ZGlmZiAtLWdpdCBhL0NPTlRSSUJVVElPTlMgYi9DT05UUklCVVRJT05TCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQyMGE1NTYKLS0tIC9kZXYvbnVsbAorKysgYi9DT05UUklCVVRJT05TCkBAIC0wLDAgKzEsMTQzIEBACitDb250cmlidXRpb25zIHRvIGhvc3RhcC5naXQKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitUaGlzIHNvZnR3YXJlIGlzIGRpc3RyaWJ1dGVkIHVuZGVyIGEgcGVybWlzc2l2ZSBvcGVuIHNvdXJjZSBsaWNlbnNlIHRvCithbGxvdyBpdCB0byBiZSB1c2VkIGluIGFueSBwcm9qZWN0cywgd2hldGhlciBvcGVuIHNvdXJjZSBvciBwcm9wcmlldGFyeS4KK0NvbnRyaWJ1dGlvbnMgdG8gdGhlIHByb2plY3QgYXJlIHdlbGNvbWUgYW5kIGl0IGlzIGltcG9ydGFudCB0byBtYWludGFpbgorY2xlYXIgcmVjb3JkIG9mIGNvbnRyaWJ1dGlvbnMgYW5kIHRlcm1zIHVuZGVyIHdoaWNoIHRoZXkgYXJlIGxpY2Vuc2VkLgorVG8gaGVscCB3aXRoIHRoaXMsIGZvbGxvd2luZyBwcm9jZWR1cmUgaXMgdXNlZCB0byBhbGxvdyBhY2NlcHRhbmNlIGFuZAorcmVjb3JkaW5nIG9mIHRoZSB0ZXJtcy4KKworQWxsIGNvbnRyaWJ1dGlvbnMgYXJlIGV4cGVjdGVkIHRvIGJlIGxpY2Vuc2VkIHVuZGVyIHRoZSBtb2RpZmllZCBCU0QKK2xpY2Vuc2UgKHNlZSBiZWxvdykuIEFja25vd2xlZGdtZW50IG9mIHRoZSB0ZXJtcyBpcyB0cmFja2VkIHRocm91Z2gKK2luY2x1c2lvbiBvZiBTaWduZWQtb2ZmLWJ5IHRhZyBpbiB0aGUgY29udHJpYnV0aW9ucyBhdCB0aGUgZW5kIG9mIHRoZQorY29tbWl0IGxvZyBtZXNzYWdlLiBUaGlzIHRhZyBpbmRpY2F0ZXMgdGhhdCB0aGUgY29udHJpYnV0b3IgYWdyZWVzIHdpdGgKK3RoZSBEZXZlbG9wZXIgQ2VydGlmaWNhdGUgb2YgT3JpZ2luIChEQ08pIHZlcnNpb24gMS4xIHRlcm1zIChzZWUgYmVsb3c7CithbHNvIGF2YWlsYWJsZSBmcm9tIGh0dHA6Ly9kZXZlbG9wZXJjZXJ0aWZpY2F0ZS5vcmcvKS4KKworCitUaGUgY3VycmVudCByZXF1aXJlbWVudHMgZm9yIGNvbnRyaWJ1dGlvbnMgdG8gaG9zdGFwLmdpdAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworVG8gaW5kaWNhdGUgeW91ciBhY2NlcHRhbmNlIG9mIERldmVsb3BlcidzIENlcnRpZmljYXRlIG9mIE9yaWdpbiAxLjEKK3Rlcm1zLCBwbGVhc2UgYWRkIHRoZSBmb2xsb3dpbmcgbGluZSB0byB0aGUgZW5kIG9mIHRoZSBjb21taXQgbWVzc2FnZQorZm9yIGVhY2ggY29udHJpYnV0aW9uIHlvdSBtYWtlIHRvIHRoZSBwcm9qZWN0OgorCitTaWduZWQtb2ZmLWJ5OiBZb3VyIE5hbWUgPHlvdXJAZW1haWwuZXhhbXBsZS5vcmc+CisKK3VzaW5nIHlvdXIgcmVhbCBuYW1lLiBQc2V1ZG9ueW1zIG9yIGFub255bW91cyBjb250cmlidXRpb25zIGNhbm5vdAordW5mb3J0dW5hdGVseSBiZSBhY2NlcHRlZC4KKworCitIaXN0b3J5IG9mIGxpY2Vuc2UgYW5kIGNvbnRyaWJ1dGlvbnMgdGVybXMKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitVbnRpbCBGZWJydWFyeSAxMSwgMjAxMiwgaW4gY2FzZSBvZiBtb3N0IGZpbGVzIGluIGhvc3RhcC5naXQsICJ1bmRlciB0aGUKK29wZW4gc291cmNlIGxpY2Vuc2UgaW5kaWNhdGVkIGluIHRoZSBmaWxlIiBtZWFucyB0aGF0IHRoZSBjb250cmlidXRpb24KK2lzIGxpY2Vuc2VkIGJvdGggdW5kZXIgR1BMIHYyIGFuZCBtb2RpZmllZCBCU0QgbGljZW5zZSAoc2VlIGJlbG93KSBhbmQKK3RoZSBjaG9pY2UgYmV0d2VlbiB0aGVzZSBsaWNlbnNlcyBpcyBnaXZlbiB0byBhbnlvbmUgd2hvIHJlZGlzdHJpYnV0ZXMKK29yIHVzZXMgdGhlIHNvZnR3YXJlLiBBcyBzdWNoLCB0aGUgY29udHJpYnV0aW9uIGhhcyB0byBiZSBsaWNlbnNlZCB1bmRlcgorYm90aCBvcHRpb25zIHRvIGFsbG93IHRoaXMgY2hvaWNlLgorCitBcyBvZiBGZWJydWFyeSAxMSwgMjAxMiwgdGhlIHByb2plY3QgaGFzIGNob3NlbiB0byB1c2Ugb25seSB0aGUgQlNECitsaWNlbnNlIG9wdGlvbiBmb3IgZnV0dXJlIGRpc3RyaWJ1dGlvbi4gQXMgc3VjaCwgdGhlIEdQTCB2MiBsaWNlbnNlCitvcHRpb24gaXMgbm8gbG9uZ2VyIHVzZWQgYW5kIHRoZSBjb250cmlidXRpb25zIGFyZSBub3QgcmVxdWlyZWQgdG8gYmUKK2xpY2Vuc2VkIHVudGlsIEdQTCB2Mi4gSW4gY2FzZSBvZiBtb3N0IGZpbGVzIGluIGhvc3RhcC5naXQsICJ1bmRlciB0aGUKK29wZW4gc291cmNlIGxpY2Vuc2UgaW5kaWNhdGVkIGluIHRoZSBmaWxlIiBtZWFucyB0aGF0IHRoZSBjb250cmlidXRpb24KK2lzIGxpY2Vuc2VkIHVuZGVyIHRoZSBtb2RpZmllZCBCU0QgbGljZW5zZSAoc2VlIGJlbG93KS4KKworVW50aWwgRmVicnVhcnkgMTMsIDIwMTQsIHRoZSBwcm9qZWN0IHVzZWQgYW4gZXh0ZW5kZWQgdmVyc2lvbiBvZiB0aGUgRENPCit0aGF0IGluY2x1ZGVkIHRoZSBpZGVudGljYWwgaXRlbXMgKGEpIHRocm91Z2ggKGQpIGZyb20gRENPIDEuMSBhbmQgYW4KK2FkZGl0aW9uYWwgaXRlbSAoZSk6CisKKyhlKSBUaGUgY29udHJpYnV0aW9uIGNhbiBiZSBsaWNlbnNlZCB1bmRlciB0aGUgbW9kaWZpZWQgQlNEIGxpY2Vuc2UKKyAgICBhcyBzaG93biBiZWxvdyBldmVuIGluIGNhc2Ugb2YgZmlsZXMgdGhhdCBhcmUgY3VycmVudGx5IGxpY2Vuc2VkCisgICAgdW5kZXIgb3RoZXIgdGVybXMuCisKK1RoaXMgd2FzIHVzZWQgZHVyaW5nIHRoZSBwZXJpb2Qgd2hlbiBzb21lIG9mIHRoZSBmaWxlcyBpbmNsdWRlZCB0aGUgb2xkCitsaWNlbnNlIHRlcm1zLiBBY2NlcHRhbmNlIG9mIHRoaXMgZXh0ZW5kZWQgRENPIHZlcnNpb24gd2FzIGluZGljYXRlZAord2l0aCBhIFNpZ25lZC1ob3N0YXAgdGFnIGluIHRoZSBjb21taXQgbWVzc2FnZS4gVGhpcyBhZGRpdGlvbmFsIGl0ZW0gKGUpCit3YXMgdXNlZCB0byBjb2xsZWN0IGV4cGxpY2l0IGFwcHJvdmFsIHRvIGxpY2Vuc2UgdGhlIGNvbnRyaWJ1dGlvbiB3aXRoCitvbmx5IHRoZSBtb2RpZmllZCBCU0QgbGljZW5zZSAoc2VlIGJlbG93KSwgaS5lLiwgd2l0aG91dCB0aGUgR1BMIHYyCitvcHRpb24uIFRoaXMgd2FzIGRvbmUgdG8gYWxsb3cgc2ltcGxlciBsaWNlbnNpbmcgdGVybXMgdG8gYmUgdXNlZCBpbiB0aGUKK2Z1dHVyZS4gSXQgc2hvdWxkIGJlIG5vdGVkIHRoYXQgdGhlIG1vZGlmaWVkIEJTRCBsaWNlbnNlIGlzIGNvbXBhdGlibGUKK3dpdGggR05VIEdQTCBhbmQgYXMgc3VjaCwgdGhpcyBwb3NzaWJsZSBtb3ZlIHRvIHNpbXBsZXIgbGljZW5zaW5nIG9wdGlvbgorZG9lcyBub3QgcHJldmVudCB1c2Ugb2YgdGhpcyBzb2Z0d2FyZSBpbiBHUEwgcHJvamVjdHMuCisKKworPT09WyBzdGFydCBxdW90ZSBmcm9tIGh0dHA6Ly9kZXZlbG9wZXJjZXJ0aWZpY2F0ZS5vcmcvIF09PT09PT09PT09PT09PT09PT09PT09PQorCitEZXZlbG9wZXIgQ2VydGlmaWNhdGUgb2YgT3JpZ2luCitWZXJzaW9uIDEuMQorCitDb3B5cmlnaHQgKEMpIDIwMDQsIDIwMDYgVGhlIExpbnV4IEZvdW5kYXRpb24gYW5kIGl0cyBjb250cmlidXRvcnMuCis2NjAgWW9yayBTdHJlZXQsIFN1aXRlIDEwMiwKK1NhbiBGcmFuY2lzY28sIENBIDk0MTEwIFVTQQorCitFdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZSB2ZXJiYXRpbSBjb3BpZXMgb2YgdGhpcworbGljZW5zZSBkb2N1bWVudCwgYnV0IGNoYW5naW5nIGl0IGlzIG5vdCBhbGxvd2VkLgorCisKK0RldmVsb3BlcidzIENlcnRpZmljYXRlIG9mIE9yaWdpbiAxLjEKKworQnkgbWFraW5nIGEgY29udHJpYnV0aW9uIHRvIHRoaXMgcHJvamVjdCwgSSBjZXJ0aWZ5IHRoYXQ6CisKKyhhKSBUaGUgY29udHJpYnV0aW9uIHdhcyBjcmVhdGVkIGluIHdob2xlIG9yIGluIHBhcnQgYnkgbWUgYW5kIEkKKyAgICBoYXZlIHRoZSByaWdodCB0byBzdWJtaXQgaXQgdW5kZXIgdGhlIG9wZW4gc291cmNlIGxpY2Vuc2UKKyAgICBpbmRpY2F0ZWQgaW4gdGhlIGZpbGU7IG9yCisKKyhiKSBUaGUgY29udHJpYnV0aW9uIGlzIGJhc2VkIHVwb24gcHJldmlvdXMgd29yayB0aGF0LCB0byB0aGUgYmVzdAorICAgIG9mIG15IGtub3dsZWRnZSwgaXMgY292ZXJlZCB1bmRlciBhbiBhcHByb3ByaWF0ZSBvcGVuIHNvdXJjZQorICAgIGxpY2Vuc2UgYW5kIEkgaGF2ZSB0aGUgcmlnaHQgdW5kZXIgdGhhdCBsaWNlbnNlIHRvIHN1Ym1pdCB0aGF0CisgICAgd29yayB3aXRoIG1vZGlmaWNhdGlvbnMsIHdoZXRoZXIgY3JlYXRlZCBpbiB3aG9sZSBvciBpbiBwYXJ0CisgICAgYnkgbWUsIHVuZGVyIHRoZSBzYW1lIG9wZW4gc291cmNlIGxpY2Vuc2UgKHVubGVzcyBJIGFtCisgICAgcGVybWl0dGVkIHRvIHN1Ym1pdCB1bmRlciBhIGRpZmZlcmVudCBsaWNlbnNlKSwgYXMgaW5kaWNhdGVkCisgICAgaW4gdGhlIGZpbGU7IG9yCisKKyhjKSBUaGUgY29udHJpYnV0aW9uIHdhcyBwcm92aWRlZCBkaXJlY3RseSB0byBtZSBieSBzb21lIG90aGVyCisgICAgcGVyc29uIHdobyBjZXJ0aWZpZWQgKGEpLCAoYikgb3IgKGMpIGFuZCBJIGhhdmUgbm90IG1vZGlmaWVkCisgICAgaXQuCisKKyhkKSBJIHVuZGVyc3RhbmQgYW5kIGFncmVlIHRoYXQgdGhpcyBwcm9qZWN0IGFuZCB0aGUgY29udHJpYnV0aW9uCisgICAgYXJlIHB1YmxpYyBhbmQgdGhhdCBhIHJlY29yZCBvZiB0aGUgY29udHJpYnV0aW9uIChpbmNsdWRpbmcgYWxsCisgICAgcGVyc29uYWwgaW5mb3JtYXRpb24gSSBzdWJtaXQgd2l0aCBpdCwgaW5jbHVkaW5nIG15IHNpZ24tb2ZmKSBpcworICAgIG1haW50YWluZWQgaW5kZWZpbml0ZWx5IGFuZCBtYXkgYmUgcmVkaXN0cmlidXRlZCBjb25zaXN0ZW50IHdpdGgKKyAgICB0aGlzIHByb2plY3Qgb3IgdGhlIG9wZW4gc291cmNlIGxpY2Vuc2UocykgaW52b2x2ZWQuCisKKz09PVsgZW5kIHF1b3RlIGZyb20gaHR0cDovL2RldmVsb3BlcmNlcnRpZmljYXRlLm9yZy8gXT09PT09PT09PT09PT09PT09PT09PT09PT0KKworCitUaGUgbGljZW5zZSB0ZXJtcyB1c2VkIGZvciBob3N0YXAuZ2l0IGZpbGVzCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK01vZGlmaWVkIEJTRCBsaWNlbnNlIChubyBhZHZlcnRpc2VtZW50IGNsYXVzZSk6CisKK0NvcHlyaWdodCAoYykgMjAwMi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPiBhbmQgY29udHJpYnV0b3JzCitBbGwgUmlnaHRzIFJlc2VydmVkLgorCitSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKK21vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKK21ldDoKKworMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKworMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisKKzMuIE5laXRoZXIgdGhlIG5hbWUocykgb2YgdGhlIGFib3ZlLWxpc3RlZCBjb3B5cmlnaHQgaG9sZGVyKHMpIG5vciB0aGUKKyAgIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzCisgICBkZXJpdmVkIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKworVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKK0xJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKK09XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCitEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKK1RIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyhJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KZGlmZiAtLWdpdCBhL0NsZWFuU3BlYy5tayBiL0NsZWFuU3BlYy5tawppbmRleCA3ZWNiYzY1Li5kYzdkNTU3IDEwMDY0NAotLS0gYS9DbGVhblNwZWMubWsKKysrIGIvQ2xlYW5TcGVjLm1rCkBAIC01OSwzICs1OSw2IEBACiAkKGNhbGwgYWRkLWNsZWFuLXN0ZXAsIHJtIC1yZiAkKFBST0RVQ1RfT1VUKS9vYmovRVhFQ1VUQUJMRVMvaG9zdGFwZF9pbnRlcm1lZGlhdGVzLyopCiAkKGNhbGwgYWRkLWNsZWFuLXN0ZXAsIHJtIC1yZiAkKFBST0RVQ1RfT1VUKS9vYmovRVhFQ1VUQUJMRVMvd3BhX3N1cHBsaWNhbnRfaW50ZXJtZWRpYXRlcy8qKQogJChjYWxsIGFkZC1jbGVhbi1zdGVwLCBybSAtcmYgJChQUk9EVUNUX09VVCkvb2JqL0VYRUNVVEFCTEVTL2hvc3RhcGRfaW50ZXJtZWRpYXRlcy8qKQorJChjYWxsIGFkZC1jbGVhbi1zdGVwLCBybSAtcmYgJChQUk9EVUNUX09VVCkvb2JqL0VYRUNVVEFCTEVTL3dwYV9zdXBwbGljYW50X2ludGVybWVkaWF0ZXMvKikKKyQoY2FsbCBhZGQtY2xlYW4tc3RlcCwgcm0gLXJmICQoUFJPRFVDVF9PVVQpL29iai9FWEVDVVRBQkxFUy9ob3N0YXBkX2ludGVybWVkaWF0ZXMvKikKKyQoY2FsbCBhZGQtY2xlYW4tc3RlcCwgcm0gLXJmICQoUFJPRFVDVF9PVVQpL29iai9FWEVDVVRBQkxFUy9ob3N0YXBkX2ludGVybWVkaWF0ZXMvKikKZGlmZiAtLWdpdCBhL1JFQURNRSBiL1JFQURNRQppbmRleCA4MDVjNmNmLi44ZGUxNGE2IDEwMDY0NAotLS0gYS9SRUFETUUKKysrIGIvUkVBRE1FCkBAIC0xLDEyICsxLDE1IEBACiB3cGFfc3VwcGxpY2FudCBhbmQgaG9zdGFwZAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAotQ29weXJpZ2h0IChjKSAyMDAyLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+IGFuZCBjb250cmlidXRvcnMKK0NvcHlyaWdodCAoYykgMjAwMi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPiBhbmQgY29udHJpYnV0b3JzCiBBbGwgUmlnaHRzIFJlc2VydmVkLgogCiBUaGVzZSBwcm9ncmFtcyBhcmUgbGljZW5zZWQgdW5kZXIgdGhlIEJTRCBsaWNlbnNlICh0aGUgb25lIHdpdGgKIGFkdmVydGlzZW1lbnQgY2xhdXNlIHJlbW92ZWQpLgogCitJZiB5b3UgYXJlIHN1Ym1pdHRpbmcgY2hhbmdlcyB0byB0aGUgcHJvamVjdCwgcGxlYXNlIHNlZSBDT05UUklCVVRJT05TCitmaWxlIGZvciBtb3JlIGluc3RydWN0aW9ucy4KKwogCiBUaGlzIHBhY2thZ2UgbWF5IGluY2x1ZGUgZWl0aGVyIHdwYV9zdXBwbGljYW50LCBob3N0YXBkLCBvciBib3RoLiBTZWUKIFJFQURNRSBmaWxlIHJlc3BlY3RpdmUgc3ViZGlyZWN0b3JpZXMgKHdwYV9zdXBwbGljYW50L1JFQURNRSBvcgpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9BbmRyb2lkLm1rIGIvaG9zdGFwZC9BbmRyb2lkLm1rCmluZGV4IDY5NWU5OWMuLmVkYWY2ZmMgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvQW5kcm9pZC5taworKysgYi9ob3N0YXBkL0FuZHJvaWQubWsKQEAgLTI0LDE2ICsyNCwxMyBAQAogIyBTZXQgQW5kcm9pZCBsb2cgbmFtZQogTF9DRkxBR1MgKz0gLURBTkRST0lEX0xPR19OQU1FPVwiaG9zdGFwZFwiCiAKLWlmZXEgKCQoQk9BUkRfV0xBTl9ERVZJQ0UpLCBiY21kaGQpCi1MX0NGTEFHUyArPSAtREFORFJPSURfUDJQCi1lbmRpZgorIyBEaXNhYmxlIHVudXNlZCBwYXJhbWV0ZXIgd2FybmluZ3MKK0xfQ0ZMQUdTICs9IC1Xbm8tdW51c2VkLXBhcmFtZXRlcgogCi1pZmVxICgkKEJPQVJEX1dMQU5fREVWSUNFKSwgcWN3Y24pCisjIFNldCBBbmRyb2lkIGV4dGVuZGVkIFAyUCBmdW5jdGlvbmFsaXR5CiBMX0NGTEFHUyArPSAtREFORFJPSURfUDJQCi1lbmRpZgotCi1pZmVxICgkKEJPQVJEX1dMQU5fREVWSUNFKSwgbXJ2bCkKLUxfQ0ZMQUdTICs9IC1EQU5EUk9JRF9QMlAKK2lmZXEgKCQoQk9BUkRfSE9TVEFQRF9QUklWQVRFX0xJQiksKQorTF9DRkxBR1MgKz0gLURBTkRST0lEX1AyUF9TVFVCCiBlbmRpZgogCiAjIFVzZSBBbmRyb2lkIHNwZWNpZmljIGRpcmVjdG9yeSBmb3IgY29udHJvbCBpbnRlcmZhY2Ugc29ja2V0cwpAQCAtNDUsMTcgKzQyLDE4IEBACiBMX0NGTEFHUyArPSAtbWFiaT1hYXBjcy1saW51eAogZW5kaWYKIAotIyBUbyBhbGxvdyBub24tQVNDSUkgY2hhcmFjdGVycyBpbiBTU0lECi1MX0NGTEFHUyArPSAtRFdQQV9VTklDT0RFX1NTSUQKLQogSU5DTFVERVMgPSAkKExPQ0FMX1BBVEgpCiBJTkNMVURFUyArPSAkKExPQ0FMX1BBVEgpL3NyYwogSU5DTFVERVMgKz0gJChMT0NBTF9QQVRIKS9zcmMvdXRpbHMKIElOQ0xVREVTICs9IGV4dGVybmFsL29wZW5zc2wvaW5jbHVkZQogSU5DTFVERVMgKz0gc3lzdGVtL3NlY3VyaXR5L2tleXN0b3JlL2luY2x1ZGUKIGlmZGVmIENPTkZJR19EUklWRVJfTkw4MDIxMQoraWZuZXEgKCQod2lsZGNhcmQgZXh0ZXJuYWwvbGlibmwpLCkKK0lOQ0xVREVTICs9IGV4dGVybmFsL2xpYm5sL2luY2x1ZGUKK2Vsc2UKIElOQ0xVREVTICs9IGV4dGVybmFsL2xpYm5sLWhlYWRlcnMKIGVuZGlmCitlbmRpZgogCiAKIGlmbmRlZiBDT05GSUdfT1MKQEAgLTEwOCw3ICsxMDYsNiBAQAogTkVFRF9BRVM9eQogTkVFRF9NRDU9eQogTkVFRF9TSEExPXkKLU5FRURfU0hBMjU2PXkKIAogT0JKUyArPSBzcmMvZHJpdmVycy9kcml2ZXJzLmMKIExfQ0ZMQUdTICs9IC1ESE9TVEFQRApAQCAtMTQxLDEwICsxMzgsMTAgQEAKIAogCiBpZm5kZWYgQ09ORklHX05PX0RVTVBfU1RBVEUKLSMgZGVmaW5lIEhPU1RBUERfRFVNUF9TVEFURSB0byBpbmNsdWRlIFNJR1VTUjEgaGFuZGxlciBmb3IgZHVtcGluZyBzdGF0ZSB0bwotIyBhIGZpbGUgKHVuZGVmaW5lIGl0LCBpZiB5b3Ugd2FudCB0byBzYXZlIGluIGJpbmFyeSBzaXplKQorIyBkZWZpbmUgSE9TVEFQRF9EVU1QX1NUQVRFIHRvIGluY2x1ZGUgc3VwcG9ydCBmb3IgZHVtcGluZyBpbnRlcm5hbCBzdGF0ZQorIyB0aHJvdWdoIGNvbnRyb2wgaW50ZXJmYWNlIGNvbW1hbmRzICh1bmRlZmluZSBpdCwgaWYgeW91IHdhbnQgdG8gc2F2ZSBpbgorIyBiaW5hcnkgc2l6ZSkKIExfQ0ZMQUdTICs9IC1ESE9TVEFQRF9EVU1QX1NUQVRFCi1PQkpTICs9IGR1bXBfc3RhdGUuYwogT0JKUyArPSBzcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX2R1bXAuYwogZW5kaWYKIApAQCAtMjAxLDYgKzE5OCwxMCBAQAogT0JKUyArPSBzcmMvYXAvcGVlcmtleV9hdXRoLmMKIGVuZGlmCiAKK2lmZGVmIENPTkZJR19IUzIwCitORUVEX0FFU19PTUFDMT15CitlbmRpZgorCiBpZmRlZiBDT05GSUdfSUVFRTgwMjExVwogTF9DRkxBR1MgKz0gLURDT05GSUdfSUVFRTgwMjExVwogTkVFRF9TSEEyNTY9eQpAQCAtMzU1LDcgKzM1Niw3IEBACiBMX0NGTEFHUyArPSAtREVBUF9TRVJWRVJfR1BTSwogT0JKUyArPSBzcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2dwc2suYyBzcmMvZWFwX2NvbW1vbi9lYXBfZ3Bza19jb21tb24uYwogaWZkZWYgQ09ORklHX0VBUF9HUFNLX1NIQTI1NgotTF9DRkxBR1MgKz0gLURFQVBfU0VSVkVSX0dQU0tfU0hBMjU2CitMX0NGTEFHUyArPSAtREVBUF9HUFNLX1NIQTI1NgogZW5kaWYKIE5FRURfU0hBMjU2PXkKIE5FRURfQUVTX09NQUMxPXkKQEAgLTM4OSwxMCArMzkwLDYgQEAKIGVuZGlmCiAKIGlmZGVmIENPTkZJR19XUFMKLWlmZGVmIENPTkZJR19XUFMyCi1MX0NGTEFHUyArPSAtRENPTkZJR19XUFMyCi1lbmRpZgotCiBMX0NGTEFHUyArPSAtRENPTkZJR19XUFMgLURFQVBfU0VSVkVSX1dTQwogT0JKUyArPSBzcmMvdXRpbHMvdXVpZC5jCiBPQkpTICs9IHNyYy9hcC93cHNfaG9zdGFwZC5jCkBAIC01MzEsMTUgKzUyOCwxMiBAQAogaWZkZWYgVExTX0ZVTkNTCiBPQkpTICs9IHNyYy9jcnlwdG8vdGxzX2dudXRscy5jCiBMSUJTICs9IC1sZ251dGxzIC1sZ3BnLWVycm9yCi1pZmRlZiBDT05GSUdfR05VVExTX0VYVFJBCi1MX0NGTEFHUyArPSAtRENPTkZJR19HTlVUTFNfRVhUUkEKLUxJQlMgKz0gLWxnbnV0bHMtZXh0cmEKLWVuZGlmCiBlbmRpZgogT0JKUyArPSBzcmMvY3J5cHRvL2NyeXB0b19nbnV0bHMuYwogSE9CSlMgKz0gc3JjL2NyeXB0by9jcnlwdG9fZ251dGxzLmMKIGlmZGVmIE5FRURfRklQUzE4Nl8yX1BSRgotT0JKUyArPSBzcmMvY3J5cHRvL2ZpcHNfcHJmX2dudXRscy5jCitPQkpTICs9IHNyYy9jcnlwdG8vZmlwc19wcmZfaW50ZXJuYWwuYworT0JKUyArPSBzcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwuYwogZW5kaWYKIExJQlMgKz0gLWxnY3J5cHQKIExJQlNfaCArPSAtbGdjcnlwdApAQCAtNTY2LDcgKzU2MCw4IEBACiBlbmRpZgogT0JKUyArPSBzcmMvY3J5cHRvL2NyeXB0b19uc3MuYwogaWZkZWYgTkVFRF9GSVBTMTg2XzJfUFJGCi1PQkpTICs9IHNyYy9jcnlwdG8vZmlwc19wcmZfbnNzLmMKK09CSlMgKz0gc3JjL2NyeXB0by9maXBzX3ByZl9pbnRlcm5hbC5jCitPQkpTICs9IHNyYy9jcnlwdG8vc2hhMS1pbnRlcm5hbC5jCiBlbmRpZgogTElCUyArPSAtbG5zczMKIExJQlNfaCArPSAtbG5zczMKQEAgLTgzMSw2ICs4MjYsNyBAQAogT0JKUyArPSBzcmMvYXAvYXBfbGlzdC5jCiBPQkpTICs9IHNyYy9hcC9pZWVlODAyXzExLmMKIE9CSlMgKz0gc3JjL2FwL2h3X2ZlYXR1cmVzLmMKK09CSlMgKz0gc3JjL2FwL2Rmcy5jCiBMX0NGTEFHUyArPSAtRE5FRURfQVBfTUxNRQogZW5kaWYKIGlmZGVmIENPTkZJR19JRUVFODAyMTFOCkBAIC04NjAsMTAgKzg1NiwyMCBAQAogCiBPQkpTICs9IHNyYy9kcml2ZXJzL2RyaXZlcl9jb21tb24uYwogCitpZmRlZiBDT05GSUdfQUNTCitMX0NGTEFHUyArPSAtRENPTkZJR19BQ1MKK09CSlMgKz0gc3JjL2FwL2Fjcy5jCitMSUJTICs9IC1sbQorZW5kaWYKKwogaWZkZWYgQ09ORklHX05PX1NURE9VVF9ERUJVRwogTF9DRkxBR1MgKz0gLURDT05GSUdfTk9fU1RET1VUX0RFQlVHCiBlbmRpZgogCitpZmRlZiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworTF9DRkxBR1MgKz0gLURDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworZW5kaWYKKwogaWZkZWYgQ09ORklHX0RFQlVHX0ZJTEUKIExfQ0ZMQUdTICs9IC1EQ09ORklHX0RFQlVHX0ZJTEUKIGVuZGlmCkBAIC04ODQsMTIgKzg5MCw2IEBACiBPQkpTX2MgKz0gc3JjL3V0aWxzL2VkaXRfc2ltcGxlLmMKIGVuZGlmCiAKLWlmZGVmIENPTkZJR19BQ1MKLUxfQ0ZMQUdTICs9IC1EQ09ORklHX0FDUwotT0JKUyArPSBzcmMvYXAvYWNzLmMKLUxJQlMgKz0gLWxtCi1lbmRpZgotCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKIAogaW5jbHVkZSAkKENMRUFSX1ZBUlMpCkBAIC05MTMsOCArOTEzLDEyIEBACiBlbmRpZgogTE9DQUxfU0hBUkVEX0xJQlJBUklFUyA6PSBsaWJjIGxpYmN1dGlscyBsaWJsb2cgbGliY3J5cHRvIGxpYnNzbAogaWZkZWYgQ09ORklHX0RSSVZFUl9OTDgwMjExCitpZm5lcSAoJCh3aWxkY2FyZCBleHRlcm5hbC9saWJubCksKQorTE9DQUxfU0hBUkVEX0xJQlJBUklFUyArPSBsaWJubAorZWxzZQogTE9DQUxfU1RBVElDX0xJQlJBUklFUyArPSBsaWJubF8yCiBlbmRpZgorZW5kaWYKIExPQ0FMX0NGTEFHUyA6PSAkKExfQ0ZMQUdTKQogTE9DQUxfU1JDX0ZJTEVTIDo9ICQoT0JKUykKIExPQ0FMX0NfSU5DTFVERVMgOj0gJChJTkNMVURFUykKZGlmZiAtLWdpdCBhL2hvc3RhcGQvQ2hhbmdlTG9nIGIvaG9zdGFwZC9DaGFuZ2VMb2cKaW5kZXggMWE0ZTU2Ni4uOWRlOTQzOCAxMDA2NDQKLS0tIGEvaG9zdGFwZC9DaGFuZ2VMb2cKKysrIGIvaG9zdGFwZC9DaGFuZ2VMb2cKQEAgLTEsOCArMSwxMjcgQEAKIENoYW5nZUxvZyBmb3IgaG9zdGFwZAogCi0/Pz8/LT8/LT8/IC0gdjIuMQotCSogYWRkZWQgc3VwcG9ydCBmb3Igc2ltdWxhdGFuZW91cyBhdXRoZW50aWNhdGlvbiBvZiBlcXVhbHMgKFNBRSkgZm9yCisyMDE0LTA2LTA0IC0gdjIuMgorCSogZml4ZWQgU0FFIGNvbmZpcm0tYmVmb3JlLWNvbW1pdCB2YWxpZGF0aW9uIHRvIGF2b2lkIGEgcG90ZW50aWFsCisJICBzZWdtZW50YXRpb24gZmF1bHQgaW4gYW4gdW5leHBlY3RlZCBtZXNzYWdlIHNlcXVlbmNlIHRoYXQgY291bGQgYmUKKwkgIHRyaWdnZXJlZCByZW1vdGVseQorCSogZXh0ZW5kZWQgVkhUIHN1cHBvcnQKKwkgIC0gT3BlcmF0aW5nIE1vZGUgTm90aWZpY2F0aW9uCisJICAtIFBvd2VyIENvbnN0cmFpbnQgZWxlbWVudCAobG9jYWxfcHdyX2NvbnN0cmFpbnQpCisJICAtIFNwZWN0cnVtIG1hbmFnZW1lbnQgY2FwYWJpbGl0eSAoc3BlY3RydW1fbWdtdF9yZXF1aXJlZD0xKQorCSAgLSBmaXggVkhUODAgc2VnbWVudCBwaWNraW5nIGluIEFDUworCSAgLSBmaXggdmh0X2NhcGFiICdNYXhpbXVtIEEtTVBEVSBMZW5ndGggRXhwb25lbnQnIGhhbmRsaW5nCisJICAtIGZpeCBWSFQyMAorCSogZml4ZWQgSFQ0MCBjby1leCBzY2FuIGZvciBzb21lIHByaS9zZWMgY2hhbm5lbCBzd2l0Y2hlcworCSogZXh0ZW5kZWQgSFQ0MCBjby1leCBzdXBwb3J0IHRvIGFsbG93IGR5bmFtaWMgY2hhbm5lbCB3aWR0aCBjaGFuZ2VzCisJICBkdXJpbmcgdGhlIGxpZmV0aW1lIG9mIHRoZSBCU1MKKwkqIGZpeGVkIEhUNDAgY28tZXggc3VwcG9ydCB0byBjaGVjayBmb3Igb3ZlcmxhcHBpbmcgMjAgTUh6IEJTUworCSogZml4ZWQgTVNDSEFQIFVURi04IHRvIFVDUy0yIGNvbnZlcnNpb24gZm9yIHRocmVlLWJ5dGUgZW5jb2Rpbmc7CisJICB0aGlzIGZpeGVzIHBhc3N3b3JkIHdpdGggaW5jbHVkZSBVVEYtOCBjaGFyYWN0ZXJzIHRoYXQgdXNlCisJICB0aHJlZS1ieXRlIGVuY29kaW5nIEVBUCBtZXRob2RzIHRoYXQgdXNlIE50UGFzc3dvcmRIYXNoCisJKiByZXZlcnRlZCBUTFMgY2VydGlmaWNhdGUgdmFsaWRhdGlvbiBzdGVwIGNoYW5nZSBpbiB2Mi4xIHRoYXQgcmVqZWN0ZWQKKwkgIGFueSBBQUEgc2VydmVyIGNlcnRpZmljYXRlIHdpdGggaWQta3AtY2xpZW50QXV0aCBldmVuIGlmCisJICBpZC1rcC1zZXJ2ZXJBdXRoIEVLVSB3YXMgaW5jbHVkZWQKKwkqIGZpeGVkIFNUQSB2YWxpZGF0aW9uIHN0ZXAgZm9yIFdQUyBFUiBjb21tYW5kcyB0byBwcmV2ZW50IGEgcG90ZW50aWFsCisJICBjcmFzaCBpZiBhbiBFUiBzZW5kcyBhbiB1bmV4cGVjdGVkIFB1dFdMQU5SZXNwb25zZSB0byBhIHN0YXRpb24gdGhhdAorCSAgaXMgZGlzYXNzb2NpYXRlZCwgYnV0IG5vdCBmdWxseSByZW1vdmVkCisJKiBlbmZvcmNlIGZ1bGwgRUFQIGF1dGhlbnRpY2F0aW9uIGFmdGVyIFJBRElVUyBEaXNjb25uZWN0LVJlcXVlc3QgYnkKKwkgIHJlbW92aW5nIHRoZSBQTUtTQSBjYWNoZSBlbnRyeQorCSogYWRkZWQgc3VwcG9ydCBmb3IgTkFTLUlQLUFkZHJlc3MsIE5BUy1pZGVudGlmaWVyLCBhbmQgTkFTLUlQdjYtQWRkcmVzcworCSAgaW4gUkFESVVTIERpc2Nvbm5lY3QtUmVxdWVzdAorCSogYWRkZWQgbWVjaGFuaXNtIGZvciByZW1vdmluZyBhZGRyZXNzZXMgZm9yIE1BQyBBQ0xzIGJ5IHByZWZpeGluZyBhbgorCSAgZW50cnkgd2l0aCAiLSIKKwkqIEludGVyd29ya2luZy9Ib3RzcG90IDIuMCBlbmhhbmNlbWVudHMKKwkgIC0gc3VwcG9ydCBIb3RzcG90IDIuMCBSZWxlYXNlIDIKKwkgICAgKiBPU0VOIG5ldHdvcmsgZm9yIG9ubGluZSBzaWdudXAgY29ubmVjdGlvbgorCSAgICAqIHN1YnNjcmlwdGlvbiByZW1lZGlhdGlvbiAoYmFzZWQgb24gUkFESVVTIHNlcnZlciByZXF1ZXN0IG9yCisJICAgICAgY29udHJvbCBpbnRlcmZhY2UgSFMyMF9XTk1fTk9USUYgZm9yIHRlc3RpbmcgcHVycG9zZXMpCisJICAgICogSG90c3BvdCAyLjAgcmVsZWFzZSBudW1iZXIgaW5kaWNhdGlvbiBpbiBXRkEgUkFESVVTIFZTQQorCSAgICAqIGRlYXV0aGVudGljYXRpb24gcmVxdWVzdCAoYmFzZWQgb24gUkFESVVTIHNlcnZlciByZXF1ZXN0IG9yCisJICAgICAgY29udHJvbCBpbnRlcmZhY2UgV05NX0RFQVVUSF9SRVEgZm9yIHRlc3RpbmcgcHVycG9zZXMpCisJICAgICogU2Vzc2lvbiBJbmZvIFVSTCBSQURJVVMgQVZQIHRvIHRyaWdnZXIgRVNTIERpc2Fzc29jaWF0aW9uIEltbWluZW50CisJICAgICogaHMyMF9pY29uIGNvbmZpZyBwYXJhbWV0ZXIgdG8gY29uZmlndXJlIGljb24gZmlsZXMgZm9yIE9TVQorCSAgICAqIG9zdV8qIGNvbmZpZyBwYXJhbWV0ZXJzIGZvciBPU1UgUHJvdmlkZXJzIGxpc3QKKwkgIC0gZG8gbm90IHVzZSBJbnRlcndvcmtpbmcgZmlsdGVyaW5nIHJ1bGVzIG9uIFByb2JlIFJlcXVlc3QgaWYKKwkgICAgSW50ZXJ3b3JraW5nIGlzIGRpc2FibGVkIHRvIGF2b2lkIGludGVyb3AgaXNzdWVzCisJKiBhZGRlZC9maXhlZCBubDgwMjExIGZ1bmN0aW9uYWxpdHkKKwkgIC0gQVAgaW50ZXJmYWNlIHRlYXJkb3duIG9wdGltaXphdGlvbgorCSAgLSBzdXBwb3J0IHZlbmRvciBzcGVjaWZpYyBkcml2ZXIgY29tbWFuZAorCSAgICAoVkVORE9SIDx2ZW5kb3IgaWQ+IDxzdWIgY29tbWFuZCBpZD4gWzxoZXggZm9ybWF0dGVkIGRhdGE+XSkKKwkqIGZpeGVkIFBNRiBwcm90ZWN0aW9uIG9mIERlYXV0aGVudGljYXRpb24gZnJhbWUgd2hlbiB0aGlzIGlzIHRyaWdnZXJlZAorCSAgYnkgc2Vzc2lvbiB0aW1lb3V0CisJKiBpbnRlcm5hbCBUTFMgaW1wbGVtZW50YXRpb24gZW5oYW5jZW1lbnRzL2ZpeGVzCisJICAtIGFkZCBTSEEyNTYtYmFzZWQgY2lwaGVyIHN1aXRlcworCSAgLSBhZGQgREhFLVJTQSBjaXBoZXIgc3VpdGVzCisJICAtIGZpeCBYLjUwOSB2YWxpZGF0aW9uIG9mIFBLQ1MjMSBzaWduYXR1cmUgdG8gY2hlY2sgZm9yIGV4dHJhIGRhdGEKKwkqIFJBRElVUyBzZXJ2ZXIgZnVuY3Rpb25hbGl0eQorCSAgLSBhZGQgbWluaW1hbCBSQURJVVMgYWNjb3VudGluZyBzZXJ2ZXIgc3VwcG9ydCAoaG9zdGFwZC1hcy1zZXJ2ZXIpOworCSAgICB0aGlzIGlzIG1haW5seSB0byBlbmFibGUgdGVzdGluZyBjb3ZlcmFnZSB3aXRoIGh3c2ltIHNjcmlwdHMKKwkgIC0gYWxsb3cgYXV0aGVudGljYXRpb24gbG9nIHRvIGJlIHdyaXR0ZW4gaW50byBTUUxpdGUgZGF0YWJzZQorCSAgLSBhZGRlZCBvcHRpb24gZm9yIFRMUyBwcm90b2NvbCB0ZXN0aW5nIG9mIGFuIEVBUCBwZWVyIGJ5IHNpbXVsYXRpbmcKKwkgICAgdmFyaW91cyBtaXNiZWhhdmlvcnMva25vd24gYXR0YWNrcworCSAgLSBNQUMgQUNMIHN1cHBvcnQgZm9yIHRlc3RpbmcgcHVycG9zZXMKKwkqIGZpeGVkIFBUSyBkZXJpdmF0aW9uIGZvciBDQ01QLTI1NiBhbmQgR0NNUC0yNTYKKwkqIGV4dGVuZGVkIFdQUyBwZXItc3RhdGlvbiBQU0sgdG8gc3VwcG9ydCBFUiBjYXNlCisJKiBhZGRlZCBvcHRpb24gdG8gY29uZmlndXJlIHRoZSBtYW5hZ2VtZW50IGdyb3VwIGNpcGhlcgorCSAgKGdyb3VwX21nbXRfY2lwaGVyPUFFUy0xMjgtQ01BQyAoZGVmYXVsdCksIEJJUC1HTUFDLTEyOCwgQklQLUdNQUMtMjU2LAorCSAgQklQLUNNQUMtMjU2KQorCSogZml4ZWQgQVAgbW9kZSBkZWZhdWx0IFRYT1AgTGltaXQgdmFsdWVzIGZvciBBQ19WSSBhbmQgQUNfVk8gKHRoZXNlCisJICB3ZXJlIHJvdW5kZWQgaW5jb3JyZWN0bHkpCisJKiBhZGRlZCBzdXBwb3J0IGZvciBwb3N0cG9uaW5nIEZUIHJlc3BvbnNlIGluIGNhc2UgUE1LLVIxIG5lZWRzIHRvIGJlCisJICBwdWxsZWQgZnJvbSBSMEtICisJKiBhZGRlZCBvcHRpb24gdG8gYWR2ZXJ0aXNlIDQwIE1IeiBpbnRvbGVyYW50IEhUIGNhcGFiaWxpdHkgd2l0aAorCSAgaHRfY2FwYWI9WzQwLUlOVE9MRVJBTlRdCisJKiByZW1vdmUgV1BTIDEuMCBvbmx5IHN1cHBvcnQsIGkuZS4sIFdTQyAyLjAgc3VwcG9ydCBpcyBub3cgZW5hYmxlZAorCSAgd2hlbmV2ZXIgQ09ORklHX1dQUz15IGlzIHNldAorCSogRUFQLXB3ZCBmaXhlcworCSAgLSBmaXggcG9zc2libGUgc2VnbWVudGF0aW9uIGZhdWx0IG9uIEVBUCBtZXRob2QgZGVpbml0IGlmIGFuIGludmFsaWQKKwkgICAgZ3JvdXAgaXMgbmVnb3RpYXRlZAorCSogZml4ZWQgUkFESVVTIGNsaWVudCByZXRyYW5zbWl0L2ZhaWxvdmVyIGJlaGF2aW9yCisJICAtIHRoZXJlIHdhcyBhIHBvdGVudGlhbCBjdGFzaCBkdWUgdG8gZnJlZWQgbWVtb3J5IGJlaW5nIGFjY2Vzc2VkCisJICAtIGZhaWxvdmVyIHRvIGEgYmFja3VwIHNlcnZlciBtZWNoYW5pc20gZGlkIG5vdCB3b3JrIHByb3Blcmx5CisJKiBmaXhlZCBhIHBvc3NpYmxlIGNyYXNoIG9uIGRvdWJsZSBESVNBQkxFIGNvbW1hbmQgd2hlbiBtdWx0aXBsZSBCU1NlcworCSAgYXJlIGVuYWJsZWQKKwkqIGZpeGVkIGEgbWVtb3J5IGxlYWsgaW4gU0FFIHJhbmRvbSBudW1iZXIgZ2VuZXJhdGlvbgorCSogZml4ZWQgR1RLIHJla2V5aW5nIHdoZW4gdGhlIHN0YXRpb24gdXNlcyBGVCBwcm90b2NvbAorCSogZml4ZWQgb2ZmLWJ5LW9uZSBib3VuZHMgY2hlY2tpbmcgaW4gcHJpbnRmX2VuY29kZSgpCisJICAtIHRoaXMgY291bGQgcmVzdWx0IGluIGRlaW5pYWwgb2Ygc2VydmljZSBpbiBzb21lIEVBUCBzZXJ2ZXIgY2FzZXMKKwkqIHZhcmlvdXMgYnVnIGZpeGVzCisKKzIwMTQtMDItMDQgLSB2Mi4xCisJKiBhZGRlZCBzdXBwb3J0IGZvciBzaW11bHRhbmVvdXMgYXV0aGVudGljYXRpb24gb2YgZXF1YWxzIChTQUUpIGZvcgogCSAgc3Ryb25nZXIgcGFzc3dvcmQtYmFzZWQgYXV0aGVudGljYXRpb24gd2l0aCBXUEEyLVBlcnNvbmFsCisJKiBhZGRlZCBubDgwMjExIGZ1bmN0aW9uYWxpdHkKKwkgIC0gVkhUIGNvbmZpZ3VyYXRpb24gZm9yIG5sODAyMTEKKwkgIC0gc3VwcG9ydCBzcGxpdCB3aXBoeSBkdW1wCisJICAtIGRyaXZlci1iYXNlZCBNQUMgQUNMCisJICAtIFFvUyBNYXBwaW5nIGNvbmZpZ3VyYXRpb24KKwkqIGFkZGVkIGZ1bGx5IGF1dG9tYXRlZCByZWdyZXNzaW9uIHRlc3Rpbmcgd2l0aCBtYWM4MDIxMV9od3NpbQorCSogYWxsb3cgY3RybF9pZmFjZSBncm91cCB0byBiZSBzcGVjaWZpZWQgb24gY29tbWFuZCBsaW5lICgtRzxncm91cD4pCisJKiBhbGxvdyBzaW5nbGUgaG9zdGFwZCBwcm9jZXNzIHRvIGNvbnRyb2wgaW5kZXBlbmRlbnQgV1BTIGludGVyZmFjZXMKKwkgICh3cHNfaW5kZXBlbmRlbnQ9MSkgaW5zdGVhZCBvZiBzeW5jaHJvbml6ZWQgb3BlcmF0aW9ucyB0aHJvdWdoIGFsbAorCSAgY29uZmlndXJlZCBpbnRlcmZhY2VzIHdpdGhpbiBhIHByb2Nlc3MKKwkqIGF2b2lkIHByb2Nlc3NpbmcgcmVjZWl2ZWQgbWFuYWdlbWVudCBmcmFtZXMgbXVsdGlwbGUgdGltZXMgd2hlbiB1c2luZworCSAgbmw4MDIxMSB3aXRoIG11bHRpcGxlIEJTU2VzCisJKiBhZGRlZCBzdXBwb3J0IGZvciBERlMgKHByb2Nlc3NpbmcgcmFkYXIgZGV0ZWN0aW9uIGV2ZW50cywgQ0FDLCBjaGFubmVsCisJICByZS1zZWxlY3Rpb24pCisJKiBhZGRlZCBFQVAtRUtFIHNlcnZlcgorCSogYWRkZWQgYXV0b21hdGljIGNoYW5uZWwgc2VsZWN0aW9uIChBQ1MpCisJKiBhZGRlZCBvcHRpb24gZm9yIHVzaW5nIHBlci1CU1MgKHZpZikgY29uZmlndXJhdGlvbiBmaWxlcyB3aXRoCisJICAtYjxwaHluYW1lPjo8Y29uZmlnIGZpbGUgbmFtZT4KKwkqIGV4dGVuZGVkIGdsb2JhbCBjb250cm9sIGludGVyZmFjZSBBREQvUkVNT1ZFIGNvbW1hbmRzIHRvIGFsbG93IEJTU2VzCisJICBvZiBhIHJhZGlvIHRvIGJlIHJlbW92ZWQgaW5kaXZpZHVhbGx5IHdpdGhvdXQgaGF2aW5nIHRvIGFkZC9yZW1vdmUgYWxsCisJICBvdGhlciBCU1NlcyBvZiB0aGUgcmFkaW8gYXQgdGhlIHNhbWUgdGltZQorCSogYWRkZWQgc3VwcG9ydCBmb3Igc2VuZGluZyBkZWJ1ZyBpbmZvIHRvIExpbnV4IHRyYWNpbmcgKC1UIG9uIGNvbW1hbmQKKwkgIGxpbmUpCisJKiByZXBsYWNlIGR1bXBfZmlsZSBmdW5jdGlvbmFsaXR5IHdpdGggc2FtZSBpbmZvcm1hdGlvbiBiZWluZyBhdmFpbGFibGUKKwkgIHRocm91Z2ggdGhlIGhvc3RhcGQgY29udHJvbCBpbnRlcmZhY2UKKwkqIGFkZGVkIHN1cHBvcnQgZm9yIHVzaW5nIFByb3RlY3RlZCBEdWFsIG9mIFB1YmxpYyBBY3Rpb24gZnJhbWVzIGZvcgorCSAgR0FTL0FOUVAgZXhjaGFuZ2VzIHdoZW4gUE1GIGlzIGVuYWJsZWQKKwkqIGFkZGVkIHN1cHBvcnQgZm9yIFdQUytORkMgdXBkYXRlcworCSAgLSBpbXByb3ZlZCBwcm90b2NvbAorCSAgLSBvcHRpb24gdG8gZmV0Y2ggYW5kIHJlcG9ydCBhbHRlcm5hdGl2ZSBjYXJyaWVyIHJlY29yZHMgZm9yIGV4dGVybmFsCisJICAgIE5GQyBvcGVyYXRpb25zCisJKiB2YXJpb3VzIGJ1ZyBmaXhlcwogCiAyMDEzLTAxLTEyIC0gdjIuMAogCSogYWRkZWQgQVAtU1RBLURJU0NPTk5FQ1RFRCBjdHJsX2lmYWNlIGV2ZW50CmRpZmYgLS1naXQgYS9ob3N0YXBkL01ha2VmaWxlIGIvaG9zdGFwZC9NYWtlZmlsZQppbmRleCBmZGE0ZTRlLi5hYzYzNzNlIDEwMDY0NAotLS0gYS9ob3N0YXBkL01ha2VmaWxlCisrKyBiL2hvc3RhcGQvTWFrZWZpbGUKQEAgLTYsOCArNiw4IEBACiBDRkxBR1MgPSAtTU1EIC1PMiAtV2FsbCAtZwogZW5kaWYKIAotQ0ZMQUdTICs9IC1JLi4vc3JjCi1DRkxBR1MgKz0gLUkuLi9zcmMvdXRpbHMKK0NGTEFHUyArPSAtSSQoYWJzcGF0aCAuLi9zcmMpCitDRkxBR1MgKz0gLUkkKGFic3BhdGggLi4vc3JjL3V0aWxzKQogCiAjIFVuY29tbWVudCBmb2xsb3dpbmcgbGluZSBhbmQgc2V0IHRoZSBwYXRoIHRvIHlvdXIga2VybmVsIHRyZWUgaW5jbHVkZQogIyBkaXJlY3RvcnkgaWYgeW91ciBDIGxpYnJhcnkgZG9lcyBub3QgaW5jbHVkZSBhbGwgaGVhZGVyIGZpbGVzLgpAQCAtMTUsNiArMTUsMTEgQEAKIAogLWluY2x1ZGUgLmNvbmZpZwogCitpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCitDRkxBR1MgKz0gLURDT05GSUdfVEVTVElOR19PUFRJT05TCitDT05GSUdfV1BTX1RFU1RJTkc9eQorZW5kaWYKKwogaWZuZGVmIENPTkZJR19PUwogaWZkZWYgQ09ORklHX05BVElWRV9XSU5ET1dTCiBDT05GSUdfT1M9d2luMzIKQEAgLTY1LDYgKzcwLDExIEBACiBPQkpTICs9IC4uL3NyYy9kcml2ZXJzL2RyaXZlcnMubwogQ0ZMQUdTICs9IC1ESE9TVEFQRAogCitpZmRlZiBDT05GSUdfTU9EVUxFX1RFU1RTCitDRkxBR1MgKz0gLURDT05GSUdfTU9EVUxFX1RFU1RTCitPQkpTICs9IGhhcGRfbW9kdWxlX3Rlc3RzLm8KK2VuZGlmCisKIGlmZGVmIENPTkZJR19XUEFfVFJBQ0UKIENGTEFHUyArPSAtRFdQQV9UUkFDRQogT0JKUyArPSAuLi9zcmMvdXRpbHMvdHJhY2UubwpAQCAtNzIsMTAgKzgyLDEwIEBACiBMREZMQUdTICs9IC1yZHluYW1pYwogQ0ZMQUdTICs9IC1mdW53aW5kLXRhYmxlcwogaWZkZWYgQ09ORklHX1dQQV9UUkFDRV9CRkQKLUNGTEFHUyArPSAtRFdQQV9UUkFDRV9CRkQKLUxJQlMgKz0gLWxiZmQKLUxJQlNfYyArPSAtbGJmZAotTElCU19oICs9IC1sYmZkCitDRkxBR1MgKz0gLURQQUNLQUdFPSJob3N0YXBkIiAtRFdQQV9UUkFDRV9CRkQKK0xJQlMgKz0gLWxiZmQgLWxkbCAtbGliZXJ0eSAtbHoKK0xJQlNfYyArPSAtbGJmZCAtbGRsIC1saWJlcnR5IC1segorTElCU19oICs9IC1sYmZkIC1sZGwgLWxpYmVydHkgLWx6CiBlbmRpZgogZW5kaWYKIApAQCAtODQsNiArOTQsMTUgQEAKIGVuZGlmCiBPQkpTICs9IC4uL3NyYy91dGlscy8kKENPTkZJR19FTE9PUCkubwogT0JKU19jICs9IC4uL3NyYy91dGlscy8kKENPTkZJR19FTE9PUCkubworCitpZmVxICgkKENPTkZJR19FTE9PUCksIGVsb29wKQorIyBVc2luZyBnbGliYyA8IDIuMTcgcmVxdWlyZXMgLWxydCBmb3IgY2xvY2tfZ2V0dGltZSgpCitMSUJTICs9IC1scnQKK0xJQlNfYyArPSAtbHJ0CitMSUJTX2ggKz0gLWxydAorTElCU19uICs9IC1scnQKK2VuZGlmCisKIE9CSlMgKz0gLi4vc3JjL3V0aWxzL2NvbW1vbi5vCiBPQkpTICs9IC4uL3NyYy91dGlscy93cGFfZGVidWcubwogT0JKU19jICs9IC4uL3NyYy91dGlscy93cGFfZGVidWcubwpAQCAtOTcsMTEgKzExNiwxOSBAQAogT0JKUyArPSAuLi9zcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtLm8KIAogCitpZmRlZiBDT05GSUdfQ09ERV9DT1ZFUkFHRQorQ0ZMQUdTICs9IC1PMCAtZnByb2ZpbGUtYXJjcyAtZnRlc3QtY292ZXJhZ2UKK0xJQlMgKz0gLWxnY292CitMSUJTX2MgKz0gLWxnY292CitMSUJTX2ggKz0gLWxnY292CitMSUJTX24gKz0gLWxnY292CitlbmRpZgorCiBpZm5kZWYgQ09ORklHX05PX0RVTVBfU1RBVEUKLSMgZGVmaW5lIEhPU1RBUERfRFVNUF9TVEFURSB0byBpbmNsdWRlIFNJR1VTUjEgaGFuZGxlciBmb3IgZHVtcGluZyBzdGF0ZSB0bwotIyBhIGZpbGUgKHVuZGVmaW5lIGl0LCBpZiB5b3Ugd2FudCB0byBzYXZlIGluIGJpbmFyeSBzaXplKQorIyBkZWZpbmUgSE9TVEFQRF9EVU1QX1NUQVRFIHRvIGluY2x1ZGUgc3VwcG9ydCBmb3IgZHVtcGluZyBpbnRlcm5hbCBzdGF0ZQorIyB0aHJvdWdoIGNvbnRyb2wgaW50ZXJmYWNlIGNvbW1hbmRzICh1bmRlZmluZSBpdCwgaWYgeW91IHdhbnQgdG8gc2F2ZSBpbgorIyBiaW5hcnkgc2l6ZSkKIENGTEFHUyArPSAtREhPU1RBUERfRFVNUF9TVEFURQotT0JKUyArPSBkdW1wX3N0YXRlLm8KIE9CSlMgKz0gLi4vc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9kdW1wLm8KIGVuZGlmCiAKQEAgLTE1OCw2ICsxODUsMTAgQEAKIE9CSlMgKz0gLi4vc3JjL2FwL3BlZXJrZXlfYXV0aC5vCiBlbmRpZgogCitpZmRlZiBDT05GSUdfSFMyMAorTkVFRF9BRVNfT01BQzE9eQorZW5kaWYKKwogaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKIENGTEFHUyArPSAtRENPTkZJR19JRUVFODAyMTFXCiBORUVEX1NIQTI1Nj15CkBAIC0zMTEsNyArMzQyLDcgQEAKIENGTEFHUyArPSAtREVBUF9TRVJWRVJfR1BTSwogT0JKUyArPSAuLi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2dwc2subyAuLi9zcmMvZWFwX2NvbW1vbi9lYXBfZ3Bza19jb21tb24ubwogaWZkZWYgQ09ORklHX0VBUF9HUFNLX1NIQTI1NgotQ0ZMQUdTICs9IC1ERUFQX1NFUlZFUl9HUFNLX1NIQTI1NgorQ0ZMQUdTICs9IC1ERUFQX0dQU0tfU0hBMjU2CiBlbmRpZgogTkVFRF9TSEEyNTY9eQogTkVFRF9BRVNfT01BQzE9eQpAQCAtMzQ1LDEwICszNzYsNiBAQAogZW5kaWYKIAogaWZkZWYgQ09ORklHX1dQUwotaWZkZWYgQ09ORklHX1dQUzIKLUNGTEFHUyArPSAtRENPTkZJR19XUFMyCi1lbmRpZgotCiBDRkxBR1MgKz0gLURDT05GSUdfV1BTIC1ERUFQX1NFUlZFUl9XU0MKIE9CSlMgKz0gLi4vc3JjL3V0aWxzL3V1aWQubwogT0JKUyArPSAuLi9zcmMvYXAvd3BzX2hvc3RhcGQubwpAQCAtNDkxLDcgKzUxOCw4IEBACiBPQkpTICs9IC4uL3NyYy9jcnlwdG8vY3J5cHRvX2dudXRscy5vCiBIT0JKUyArPSAuLi9zcmMvY3J5cHRvL2NyeXB0b19nbnV0bHMubwogaWZkZWYgTkVFRF9GSVBTMTg2XzJfUFJGCi1PQkpTICs9IC4uL3NyYy9jcnlwdG8vZmlwc19wcmZfZ251dGxzLm8KK09CSlMgKz0gLi4vc3JjL2NyeXB0by9maXBzX3ByZl9pbnRlcm5hbC5vCitTSEExT0JKUyArPSAuLi9zcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwubwogZW5kaWYKIExJQlMgKz0gLWxnY3J5cHQKIExJQlNfaCArPSAtbGdjcnlwdApAQCAtNTE4LDcgKzU0Niw4IEBACiBlbmRpZgogT0JKUyArPSAuLi9zcmMvY3J5cHRvL2NyeXB0b19uc3MubwogaWZkZWYgTkVFRF9GSVBTMTg2XzJfUFJGCi1PQkpTICs9IC4uL3NyYy9jcnlwdG8vZmlwc19wcmZfbnNzLm8KK09CSlMgKz0gLi4vc3JjL2NyeXB0by9maXBzX3ByZl9pbnRlcm5hbC5vCitTSEExT0JKUyArPSAuLi9zcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwubwogZW5kaWYKIExJQlMgKz0gLWxuc3MzCiBMSUJTX2ggKz0gLWxuc3MzCkBAIC03ODIsNiArODExLDcgQEAKIE9CSlMgKz0gLi4vc3JjL2FwL2FwX2xpc3QubwogT0JKUyArPSAuLi9zcmMvYXAvaWVlZTgwMl8xMS5vCiBPQkpTICs9IC4uL3NyYy9hcC9od19mZWF0dXJlcy5vCitPQkpTICs9IC4uL3NyYy9hcC9kZnMubwogQ0ZMQUdTICs9IC1ETkVFRF9BUF9NTE1FCiBlbmRpZgogaWZkZWYgQ09ORklHX0lFRUU4MDIxMU4KQEAgLTgyNyw2ICs4NTcsMTAgQEAKIENGTEFHUyArPSAtRENPTkZJR19OT19TVERPVVRfREVCVUcKIGVuZGlmCiAKK2lmZGVmIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HCitDRkxBR1MgKz0gLURDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworZW5kaWYKKwogaWZkZWYgQ09ORklHX0RFQlVHX0ZJTEUKIENGTEFHUyArPSAtRENPTkZJR19ERUJVR19GSUxFCiBlbmRpZgpAQCAtODM3LDEwICs4NzEsNiBAQAogTElCU19oICs9IC1sc3FsaXRlMwogZW5kaWYKIAotaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwotQ0ZMQUdTICs9IC1EQ09ORklHX1RFU1RJTkdfT1BUSU9OUwotZW5kaWYKLQogQUxMPWhvc3RhcGQgaG9zdGFwZF9jbGkKIAogYWxsOiB2ZXJpZnlfY29uZmlnICQoQUxMKQpAQCAtODUyLDkgKzg4MiwxNSBAQAogRT10cnVlCiBlbmRpZgogCitpZmRlZiBDT05GSUdfQ09ERV9DT1ZFUkFHRQorJS5vOiAlLmMKKwlAJChFKSAiICBDQyAiICQ8CisJJChRKWNkICQoZGlyICRAKTsgJChDQykgLWMgLW8gJChub3RkaXIgJEApICQoQ0ZMQUdTKSAkKG5vdGRpciAkPCkKK2Vsc2UKICUubzogJS5jCiAJJChRKSQoQ0MpIC1jIC1vICRAICQoQ0ZMQUdTKSAkPAogCUAkKEUpICIgIENDICIgJDwKK2VuZGlmCiAKIHZlcmlmeV9jb25maWc6CiAJQGlmIFsgISAtciAuY29uZmlnIF07IHRoZW4gXApAQCAtOTIzLDkgKzk1OSwxNSBAQAogCSQoUSkkKENDKSAkKExERkxBR1MpIC1vIGhscl9hdWNfZ3cgJChIT0JKUykgJChMSUJTX2gpCiAJQCQoRSkgIiAgTEQgIiAkQAogCitsY292LWh0bWw6CisJbGNvdiAtYyAtZCAuLiA+IGxjb3YuaW5mbworCWdlbmh0bWwgbGNvdi5pbmZvIC0tb3V0cHV0LWRpcmVjdG9yeSBsY292LWh0bWwKKwogY2xlYW46CiAJJChNQUtFKSAtQyAuLi9zcmMgY2xlYW4KIAlybSAtZiBjb3JlICp+ICoubyBob3N0YXBkIGhvc3RhcGRfY2xpIG50X3Bhc3N3b3JkX2hhc2ggaGxyX2F1Y19ndwotCXJtIC1mICouZAorCXJtIC1mICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgorCXJtIC1mIGxjb3YuaW5mbworCXJtIC1yZiBsY292LWh0bWwKIAogLWluY2x1ZGUgJChPQkpTOiUubz0lLmQpCmRpZmYgLS1naXQgYS9ob3N0YXBkL1JFQURNRSBiL2hvc3RhcGQvUkVBRE1FCmluZGV4IDM5YjcwY2EuLjUwODY4ZWUgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvUkVBRE1FCisrKyBiL2hvc3RhcGQvUkVBRE1FCkBAIC0yLDcgKzIsNyBAQAogCSAgQXV0aGVudGljYXRvciBhbmQgUkFESVVTIGF1dGhlbnRpY2F0aW9uIHNlcnZlcgogPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogCi1Db3B5cmlnaHQgKGMpIDIwMDItMjAxMywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4gYW5kIGNvbnRyaWJ1dG9ycworQ29weXJpZ2h0IChjKSAyMDAyLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+IGFuZCBjb250cmlidXRvcnMKIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAKIFRoaXMgcHJvZ3JhbSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQlNEIGxpY2Vuc2UgKHRoZSBvbmUgd2l0aApkaWZmIC0tZ2l0IGEvaG9zdGFwZC9SRUFETUUtV1BTIGIvaG9zdGFwZC9SRUFETUUtV1BTCmluZGV4IDY1NGI1YmMuLmJiN2QzNWYgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvUkVBRE1FLVdQUworKysgYi9ob3N0YXBkL1JFQURNRS1XUFMKQEAgLTYzLDcgKzYzLDYgQEAKIENPTkZJR19EUklWRVJfTUFEV0lGST15CiBDRkxBR1MgKz0gLUkvdXNyL3NyYy9tYWR3aWZpLTAuOS4zCiBDT05GSUdfV1BTPXkKLUNPTkZJR19XUFMyPXkKIENPTkZJR19XUFNfVVBOUD15CiAKIEZvbGxvd2luZyBwYXJhbWV0ZXIgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIHN1cHBvcnQgZm9yIE5GQyBjb25maWcgbWV0aG9kOgpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9hbmRyb2lkLmNvbmZpZyBiL2hvc3RhcGQvYW5kcm9pZC5jb25maWcKaW5kZXggZjUxYTViZi4uYWQ4MzMwOCAxMDA2NDQKLS0tIGEvaG9zdGFwZC9hbmRyb2lkLmNvbmZpZworKysgYi9ob3N0YXBkL2FuZHJvaWQuY29uZmlnCkBAIC01Miw3ICs1Miw3IEBACiAjIFRoaXMgdmVyc2lvbiBpcyBhbiBleHBlcmltZW50YWwgaW1wbGVtZW50YXRpb24gYmFzZWQgb24gSUVFRSA4MDIuMTF3L0QxLjAKICMgZHJhZnQgYW5kIGlzIHN1YmplY3QgdG8gY2hhbmdlIHNpbmNlIHRoZSBzdGFuZGFyZCBoYXMgbm90IHlldCBiZWVuIGZpbmFsaXplZC4KICMgRHJpdmVyIHN1cHBvcnQgaXMgYWxzbyBuZWVkZWQgZm9yIElFRUUgODAyLjExdy4KLSNDT05GSUdfSUVFRTgwMjExVz15CitDT05GSUdfSUVFRTgwMjExVz15CiAKICMgSW50ZWdyYXRlZCBFQVAgc2VydmVyCiAjQ09ORklHX0VBUD15CkBAIC0xMDgsOCArMTA4LDYgQEAKIAogIyBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAgKFdQUykKIENPTkZJR19XUFM9eQotIyBFbmFibGUgV1NDIDIuMCBzdXBwb3J0Ci1DT05GSUdfV1BTMj15CiAjIEVuYWJsZSBVUG5QIHN1cHBvcnQgZm9yIGV4dGVybmFsIFdQUyBSZWdpc3RyYXJzCiAjQ09ORklHX1dQU19VUE5QPXkKIApAQCAtMTU3LDcgKzE1NSw3IEBACiAjIFJlbW92ZSBzdXBwb3J0IGZvciBWTEFOcwogI0NPTkZJR19OT19WTEFOPXkKIAotIyBSZW1vdmUgc3VwcG9ydCBmb3IgZHVtcGluZyBzdGF0ZSBpbnRvIGEgZmlsZSBvbiBTSUdVU1IxIHNpZ25hbAorIyBSZW1vdmUgc3VwcG9ydCBmb3IgZHVtcGluZyBpbnRlcm5hbCBzdGF0ZSB0aHJvdWdoIGNvbnRyb2wgaW50ZXJmYWNlIGNvbW1hbmRzCiAjIFRoaXMgY2FuIGJlIHVzZWQgdG8gcmVkdWNlIGJpbmFyeSBzaXplIGF0IHRoZSBjb3N0IG9mIGRpc2FibGluZyBhIGRlYnVnZ2luZwogIyBvcHRpb24uCiAjQ09ORklHX05PX0RVTVBfU1RBVEU9eQpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9jb25maWdfZmlsZS5jIGIvaG9zdGFwZC9jb25maWdfZmlsZS5jCmluZGV4IDBiNGZkNzcuLjRjMGUzZjggMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvY29uZmlnX2ZpbGUuYworKysgYi9ob3N0YXBkL2NvbmZpZ19maWxlLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAvIENvbmZpZ3VyYXRpb24gZmlsZSBwYXJzZXIKLSAqIENvcHlyaWdodCAoYykgMjAwMy0yMDEzLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTIyLDcgKzIyLDEyIEBACiAjaW5jbHVkZSAiY29uZmlnX2ZpbGUuaCIKIAogCi1leHRlcm4gc3RydWN0IHdwYV9kcml2ZXJfb3BzICp3cGFfZHJpdmVyc1tdOworI2lmbmRlZiBDT05GSUdfTk9fUkFESVVTCisjaWZkZWYgRUFQX1NFUlZFUgorc3RhdGljIHN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICoKK2hvc3RhcGRfcGFyc2VfcmFkaXVzX2F0dHIoY29uc3QgY2hhciAqdmFsdWUpOworI2VuZGlmIC8qIEVBUF9TRVJWRVIgKi8KKyNlbmRpZiAvKiBDT05GSUdfTk9fUkFESVVTICovCiAKIAogI2lmbmRlZiBDT05GSUdfTk9fVkxBTgpAQCAtMTMyLDYgKzEzNyw4IEBACiAJfQogCiAJd2hpbGUgKGZnZXRzKGJ1Ziwgc2l6ZW9mKGJ1ZiksIGYpKSB7CisJCWludCBpLCByZW0gPSAwOworCiAJCWxpbmUrKzsKIAogCQlpZiAoYnVmWzBdID09ICcjJykKQEAgLTE0NiwxNCArMTUzLDMyIEBACiAJCX0KIAkJaWYgKGJ1ZlswXSA9PSAnXDAnKQogCQkJY29udGludWU7CisJCXBvcyA9IGJ1ZjsKKwkJaWYgKGJ1ZlswXSA9PSAnLScpIHsKKwkJCXJlbSA9IDE7CisJCQlwb3MrKzsKKwkJfQogCi0JCWlmIChod2FkZHJfYXRvbihidWYsIGFkZHIpKSB7CisJCWlmIChod2FkZHJfYXRvbihwb3MsIGFkZHIpKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkludmFsaWQgTUFDIGFkZHJlc3MgJyVzJyBhdCAiCi0JCQkJICAgImxpbmUgJWQgaW4gJyVzJyIsIGJ1ZiwgbGluZSwgZm5hbWUpOworCQkJCSAgICJsaW5lICVkIGluICclcyciLCBwb3MsIGxpbmUsIGZuYW1lKTsKIAkJCWZjbG9zZShmKTsKIAkJCXJldHVybiAtMTsKIAkJfQogCisJCWlmIChyZW0pIHsKKwkJCWkgPSAwOworCQkJd2hpbGUgKGkgPCAqbnVtKSB7CisJCQkJaWYgKG9zX21lbWNtcCgoKmFjbClbaV0uYWRkciwgYWRkciwgRVRIX0FMRU4pID09CisJCQkJICAgIDApIHsKKwkJCQkJb3NfcmVtb3ZlX2luX2FycmF5KCphY2wsICpudW0sCisJCQkJCQkJICAgc2l6ZW9mKCoqYWNsKSwgaSk7CisJCQkJCSgqbnVtKS0tOworCQkJCX0gZWxzZQorCQkJCQlpKys7CisJCQl9CisJCQljb250aW51ZTsKKwkJfQogCQl2bGFuX2lkID0gMDsKIAkJcG9zID0gYnVmOwogCQl3aGlsZSAoKnBvcyAhPSAnXDAnICYmICpwb3MgIT0gJyAnICYmICpwb3MgIT0gJ1x0JykKQEAgLTE5MSw3ICsyMTYsNyBAQAogCUZJTEUgKmY7CiAJY2hhciBidWZbNTEyXSwgKnBvcywgKnN0YXJ0LCAqcG9zMjsKIAlpbnQgbGluZSA9IDAsIHJldCA9IDAsIG51bV9tZXRob2RzOwotCXN0cnVjdCBob3N0YXBkX2VhcF91c2VyICp1c2VyLCAqdGFpbCA9IE5VTEw7CisJc3RydWN0IGhvc3RhcGRfZWFwX3VzZXIgKnVzZXIgPSBOVUxMLCAqdGFpbCA9IE5VTEw7CiAKIAlpZiAoIWZuYW1lKQogCQlyZXR1cm4gMDsKQEAgLTIyNSw2ICsyNTAsMjggQEAKIAkJaWYgKGJ1ZlswXSA9PSAnXDAnKQogCQkJY29udGludWU7CiAKKyNpZm5kZWYgQ09ORklHX05PX1JBRElVUworCQlpZiAodXNlciAmJiBvc19zdHJuY21wKGJ1ZiwgInJhZGl1c19hY2NlcHRfYXR0cj0iLCAxOSkgPT0gMCkgeworCQkJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmF0dHIsICphOworCQkJYXR0ciA9IGhvc3RhcGRfcGFyc2VfcmFkaXVzX2F0dHIoYnVmICsgMTkpOworCQkJaWYgKGF0dHIgPT0gTlVMTCkgeworCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSW52YWxpZCByYWRpdXNfYXV0aF9yZXFfYXR0cjogJXMiLAorCQkJCQkgICBidWYgKyAxOSk7CisJCQkJdXNlciA9IE5VTEw7IC8qIGFscmVhZHkgaW4gdGhlIEJTUyBsaXN0ICovCisJCQkJZ290byBmYWlsZWQ7CisJCQl9CisJCQlpZiAodXNlci0+YWNjZXB0X2F0dHIgPT0gTlVMTCkgeworCQkJCXVzZXItPmFjY2VwdF9hdHRyID0gYXR0cjsKKwkJCX0gZWxzZSB7CisJCQkJYSA9IHVzZXItPmFjY2VwdF9hdHRyOworCQkJCXdoaWxlIChhLT5uZXh0KQorCQkJCQlhID0gYS0+bmV4dDsKKwkJCQlhLT5uZXh0ID0gYXR0cjsKKwkJCX0KKwkJCWNvbnRpbnVlOworCQl9CisjZW5kaWYgLyogQ09ORklHX05PX1JBRElVUyAqLworCiAJCXVzZXIgPSBOVUxMOwogCiAJCWlmIChidWZbMF0gIT0gJyInICYmIGJ1ZlswXSAhPSAnKicpIHsKQEAgLTMxOSw2ICszNjYsMTAgQEAKIAkJCQkJCUVBUF9UVExTX0FVVEhfTVNDSEFQVjI7CiAJCQkJCWdvdG8gc2tpcF9lYXA7CiAJCQkJfQorCQkJCWlmIChvc19zdHJjbXAoc3RhcnQsICJNQUNBQ0wiKSA9PSAwKSB7CisJCQkJCXVzZXItPm1hY2FjbCA9IDE7CisJCQkJCWdvdG8gc2tpcF9lYXA7CisJCQkJfQogCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiVW5zdXBwb3J0ZWQgRUFQIHR5cGUgIgogCQkJCQkgICAiJyVzJyBvbiBsaW5lICVkIGluICclcyciLAogCQkJCQkgICBzdGFydCwgbGluZSwgZm5hbWUpOwpAQCAtMzMzLDcgKzM4NCw3IEBACiAJCQkJYnJlYWs7CiAJCQlzdGFydCA9IHBvczM7CiAJCX0KLQkJaWYgKG51bV9tZXRob2RzID09IDAgJiYgdXNlci0+dHRsc19hdXRoID09IDApIHsKKwkJaWYgKG51bV9tZXRob2RzID09IDAgJiYgdXNlci0+dHRsc19hdXRoID09IDAgJiYgIXVzZXItPm1hY2FjbCkgewogCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJObyBFQVAgdHlwZXMgY29uZmlndXJlZCBvbiAiCiAJCQkJICAgImxpbmUgJWQgaW4gJyVzJyIsIGxpbmUsIGZuYW1lKTsKIAkJCWdvdG8gZmFpbGVkOwpAQCAtNDUxLDExICs1MDIsOCBAQAogCQljb250aW51ZTsKIAogCWZhaWxlZDoKLQkJaWYgKHVzZXIpIHsKLQkJCW9zX2ZyZWUodXNlci0+cGFzc3dvcmQpOwotCQkJb3NfZnJlZSh1c2VyLT5pZGVudGl0eSk7Ci0JCQlvc19mcmVlKHVzZXIpOwotCQl9CisJCWlmICh1c2VyKQorCQkJaG9zdGFwZF9jb25maWdfZnJlZV9lYXBfdXNlcih1c2VyKTsKIAkJcmV0ID0gLTE7CiAJCWJyZWFrOwogCX0KQEAgLTc0OCwzMCArNzk2LDMyIEBACiAKIHN0YXRpYyBpbnQgaG9zdGFwZF9jb25maWdfYnNzKHN0cnVjdCBob3N0YXBkX2NvbmZpZyAqY29uZiwgY29uc3QgY2hhciAqaWZuYW1lKQogewotCXN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzczsKKwlzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICoqYWxsLCAqYnNzOwogCiAJaWYgKCppZm5hbWUgPT0gJ1wwJykKIAkJcmV0dXJuIC0xOwogCi0JYnNzID0gb3NfcmVhbGxvY19hcnJheShjb25mLT5ic3MsIGNvbmYtPm51bV9ic3MgKyAxLAotCQkJICAgICAgIHNpemVvZihzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnKSk7Ci0JaWYgKGJzcyA9PSBOVUxMKSB7CisJYWxsID0gb3NfcmVhbGxvY19hcnJheShjb25mLT5ic3MsIGNvbmYtPm51bV9ic3MgKyAxLAorCQkJICAgICAgIHNpemVvZihzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICopKTsKKwlpZiAoYWxsID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciAiCiAJCQkgICAibXVsdGktQlNTIGVudHJ5Iik7CiAJCXJldHVybiAtMTsKIAl9Ci0JY29uZi0+YnNzID0gYnNzOworCWNvbmYtPmJzcyA9IGFsbDsKIAotCWJzcyA9ICYoY29uZi0+YnNzW2NvbmYtPm51bV9ic3NdKTsKLQlvc19tZW1zZXQoYnNzLCAwLCBzaXplb2YoKmJzcykpOworCWJzcyA9IG9zX3phbGxvYyhzaXplb2YoKmJzcykpOworCWlmIChic3MgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOwogCWJzcy0+cmFkaXVzID0gb3NfemFsbG9jKHNpemVvZigqYnNzLT5yYWRpdXMpKTsKIAlpZiAoYnNzLT5yYWRpdXMgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yICIKIAkJCSAgICJtdWx0aS1CU1MgUkFESVVTIGRhdGEiKTsKKwkJb3NfZnJlZShic3MpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0JY29uZi0+bnVtX2JzcysrOworCWNvbmYtPmJzc1tjb25mLT5udW1fYnNzKytdID0gYnNzOwogCWNvbmYtPmxhc3RfYnNzID0gYnNzOwogCiAJaG9zdGFwZF9jb25maWdfZGVmYXVsdHNfYnNzKGJzcyk7CkBAIC0xMDE5LDggKzEwNjksOCBAQAogCQljb25mLT5odF9jYXBhYiB8PSBIVF9DQVBfSU5GT19NQVhfQU1TRFVfU0laRTsKIAlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW0RTU1NfQ0NLLTQwXSIpKQogCQljb25mLT5odF9jYXBhYiB8PSBIVF9DQVBfSU5GT19EU1NTX0NDSzQwTUhaOwotCWlmIChvc19zdHJzdHIoY2FwYWIsICJbUFNNUF0iKSkKLQkJY29uZi0+aHRfY2FwYWIgfD0gSFRfQ0FQX0lORk9fUFNNUF9TVVBQOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbNDAtSU5UT0xFUkFOVF0iKSkKKwkJY29uZi0+aHRfY2FwYWIgfD0gSFRfQ0FQX0lORk9fNDBNSFpfSU5UT0xFUkFOVDsKIAlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW0xTSUctVFhPUC1QUk9UXSIpKQogCQljb25mLT5odF9jYXBhYiB8PSBIVF9DQVBfSU5GT19MU0lHX1RYT1BfUFJPVEVDVF9TVVBQT1JUOwogCkBAIC0xMDQxLDggKzEwOTEsNiBAQAogCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwTUhaOwogCWlmIChvc19zdHJzdHIoY2FwYWIsICJbVkhUMTYwLTgwUExVUzgwXSIpKQogCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwXzgwUExVUzgwTUhaOwotCWlmIChvc19zdHJzdHIoY2FwYWIsICJbVkhUMTYwLTgwUExVUzgwXSIpKQotCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwXzgwUExVUzgwTUhaOwogCWlmIChvc19zdHJzdHIoY2FwYWIsICJbUlhMRFBDXSIpKQogCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9SWExEUEM7CiAJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltTSE9SVC1HSS04MF0iKSkKQEAgLTEwNjAsMTUgKzExMDgsMTUgQEAKIAlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1JYLVNUQkMtMTIzNF0iKSkKIAkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfUlhTVEJDXzQ7CiAJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltTVS1CRUFNRk9STUVSXSIpKQotCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NVV9CRUFNRk9STUVSX0NBUEFCTEU7CisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX1NVX0JFQU1GT1JNRVJfQ0FQQUJMRTsKIAlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1NVLUJFQU1GT1JNRUVdIikpCi0JCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX01VX0JFQU1GT1JNRUVfQ0FQQUJMRTsKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfU1VfQkVBTUZPUk1FRV9DQVBBQkxFOwogCWlmIChvc19zdHJzdHIoY2FwYWIsICJbQkYtQU5URU5OQS0yXSIpICYmCi0JICAgIChjb25mLT52aHRfY2FwYWIgJiBWSFRfQ0FQX01VX0JFQU1GT1JNRVJfQ0FQQUJMRSkpCi0JCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX0JFQU1GT1JNRVJfQU5URU5OQVNfTUFYOworCSAgICAoY29uZi0+dmh0X2NhcGFiICYgVkhUX0NBUF9TVV9CRUFNRk9STUVFX0NBUEFCTEUpKQorCQljb25mLT52aHRfY2FwYWIgfD0gKDEgPDwgVkhUX0NBUF9CRUFNRk9STUVFX1NUU19PRkZTRVQpOwogCWlmIChvc19zdHJzdHIoY2FwYWIsICJbU09VTkRJTkctRElNRU5TSU9OLTJdIikgJiYKLQkgICAgKGNvbmYtPnZodF9jYXBhYiAmIFZIVF9DQVBfTVVfQkVBTUZPUk1FUl9DQVBBQkxFKSkKLQkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfU09VTkRJTkdfRElNRU5USU9OX01BWDsKKwkgICAgKGNvbmYtPnZodF9jYXBhYiAmIFZIVF9DQVBfU1VfQkVBTUZPUk1FUl9DQVBBQkxFKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9ICgxIDw8IFZIVF9DQVBfU09VTkRJTkdfRElNRU5TSU9OX09GRlNFVCk7CiAJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNVS1CRUFNRk9STUVSXSIpKQogCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NVV9CRUFNRk9STUVSX0NBUEFCTEU7CiAJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNVS1CRUFNRk9STUVFXSIpKQpAQCAtMTA3Nyw4ICsxMTI1LDIwIEBACiAJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX1ZIVF9UWE9QX1BTOwogCWlmIChvc19zdHJzdHIoY2FwYWIsICJbSFRDLVZIVF0iKSkKIAkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfSFRDX1ZIVDsKLQlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW01BWC1BLU1QRFUtTEVOLUVYUDBdIikpCi0JCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX01BWF9BX01QRFVfTEVOR1RIX0VYUE9ORU5UOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbTUFYLUEtTVBEVS1MRU4tRVhQN10iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfTUFYX0FfTVBEVV9MRU5HVEhfRVhQT05FTlRfTUFYOworCWVsc2UgaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNQVgtQS1NUERVLUxFTi1FWFA2XSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF82OworCWVsc2UgaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNQVgtQS1NUERVLUxFTi1FWFA1XSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF81OworCWVsc2UgaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNQVgtQS1NUERVLUxFTi1FWFA0XSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF80OworCWVsc2UgaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNQVgtQS1NUERVLUxFTi1FWFAzXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF8zOworCWVsc2UgaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNQVgtQS1NUERVLUxFTi1FWFAyXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF8yOworCWVsc2UgaWYgKG9zX3N0cnN0cihjYXBhYiwgIltNQVgtQS1NUERVLUxFTi1FWFAxXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF8xOwogCWlmIChvc19zdHJzdHIoY2FwYWIsICJbVkhULUxJTkstQURBUFQyXSIpICYmCiAJICAgIChjb25mLT52aHRfY2FwYWIgJiBWSFRfQ0FQX0hUQ19WSFQpKQogCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9WSFRfTElOS19BREFQVEFUSU9OX1ZIVF9VTlNPTF9NRkI7CkBAIC0xMDk0LDE2NSArMTE1NCw2IEBACiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMUFDICovCiAKIAotc3RhdGljIGludCBob3N0YXBkX2NvbmZpZ19jaGVja19ic3Moc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzLAotCQkJCSAgICBzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmNvbmYpCi17Ci0JaWYgKGJzcy0+aWVlZTgwMl8xeCAmJiAhYnNzLT5lYXBfc2VydmVyICYmCi0JICAgICFic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXJzKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSW52YWxpZCBJRUVFIDgwMi4xWCBjb25maWd1cmF0aW9uIChubyAiCi0JCQkgICAiRUFQIGF1dGhlbnRpY2F0b3IgY29uZmlndXJlZCkuIik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlpZiAoYnNzLT53cGEpIHsKLQkJaW50IHdlcCwgaTsKLQotCQl3ZXAgPSBic3MtPmRlZmF1bHRfd2VwX2tleV9sZW4gPiAwIHx8Ci0JCSAgICAgICBic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPiAwOwotCQlmb3IgKGkgPSAwOyBpIDwgTlVNX1dFUF9LRVlTOyBpKyspIHsKLQkJCWlmIChic3MtPnNzaWQud2VwLmtleXNfc2V0KSB7Ci0JCQkJd2VwID0gMTsKLQkJCQlicmVhazsKLQkJCX0KLQkJfQotCi0JCWlmICh3ZXApIHsKLQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV0VQIGNvbmZpZ3VyYXRpb24gaW4gYSBXUEEgbmV0d29yayBpcyBub3Qgc3VwcG9ydGVkIik7Ci0JCQlyZXR1cm4gLTE7Ci0JCX0KLQl9Ci0KLQlpZiAoYnNzLT53cGEgJiYgYnNzLT53cGFfcHNrX3JhZGl1cyAhPSBQU0tfUkFESVVTX0lHTk9SRUQgJiYKLQkgICAgYnNzLT5tYWNhZGRyX2FjbCAhPSBVU0VfRVhURVJOQUxfUkFESVVTX0FVVEgpIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUEEtUFNLIHVzaW5nIFJBRElVUyBlbmFibGVkLCBidXQgbm8gIgotCQkJICAgIlJBRElVUyBjaGVja2luZyAobWFjYWRkcl9hY2w9MikgZW5hYmxlZC4iKTsKLQkJcmV0dXJuIC0xOwotCX0KLQotCWlmIChic3MtPndwYSAmJiAoYnNzLT53cGFfa2V5X21nbXQgJiBXUEFfS0VZX01HTVRfUFNLKSAmJgotCSAgICBic3MtPnNzaWQud3BhX3BzayA9PSBOVUxMICYmIGJzcy0+c3NpZC53cGFfcGFzc3BocmFzZSA9PSBOVUxMICYmCi0JICAgIGJzcy0+c3NpZC53cGFfcHNrX2ZpbGUgPT0gTlVMTCAmJgotCSAgICAoYnNzLT53cGFfcHNrX3JhZGl1cyAhPSBQU0tfUkFESVVTX1JFUVVJUkVEIHx8Ci0JICAgICBic3MtPm1hY2FkZHJfYWNsICE9IFVTRV9FWFRFUk5BTF9SQURJVVNfQVVUSCkpIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUEEtUFNLIGVuYWJsZWQsIGJ1dCBQU0sgb3IgcGFzc3BocmFzZSAiCi0JCQkgICAiaXMgbm90IGNvbmZpZ3VyZWQuIik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlpZiAoaG9zdGFwZF9tYWNfY29tcF9lbXB0eShic3MtPmJzc2lkKSAhPSAwKSB7Ci0JCXNpemVfdCBpOwotCi0JCWZvciAoaSA9IDA7IGkgPCBjb25mLT5udW1fYnNzOyBpKyspIHsKLQkJCWlmICgoJmNvbmYtPmJzc1tpXSAhPSBic3MpICYmCi0JCQkgICAgKGhvc3RhcGRfbWFjX2NvbXAoY29uZi0+YnNzW2ldLmJzc2lkLAotCQkJCQkgICAgICBic3MtPmJzc2lkKSA9PSAwKSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiRHVwbGljYXRlIEJTU0lEICIgTUFDU1RSCi0JCQkJCSAgICIgb24gaW50ZXJmYWNlICclcycgYW5kICclcycuIiwKLQkJCQkJICAgTUFDMlNUUihic3MtPmJzc2lkKSwKLQkJCQkJICAgY29uZi0+YnNzW2ldLmlmYWNlLCBic3MtPmlmYWNlKTsKLQkJCQlyZXR1cm4gLTE7Ci0JCQl9Ci0JCX0KLQl9Ci0KLSNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgotCWlmICh3cGFfa2V5X21nbXRfZnQoYnNzLT53cGFfa2V5X21nbXQpICYmCi0JICAgIChic3MtPm5hc19pZGVudGlmaWVyID09IE5VTEwgfHwKLQkgICAgIG9zX3N0cmxlbihic3MtPm5hc19pZGVudGlmaWVyKSA8IDEgfHwKLQkgICAgIG9zX3N0cmxlbihic3MtPm5hc19pZGVudGlmaWVyKSA+IEZUX1IwS0hfSURfTUFYX0xFTikpIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGVCAoSUVFRSA4MDIuMTFyKSByZXF1aXJlcyAiCi0JCQkgICAibmFzX2lkZW50aWZpZXIgdG8gYmUgY29uZmlndXJlZCBhcyBhIDEuLjQ4IG9jdGV0ICIKLQkJCSAgICJzdHJpbmciKTsKLQkJcmV0dXJuIC0xOwotCX0KLSNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiAqLwotCi0jaWZkZWYgQ09ORklHX0lFRUU4MDIxMU4KLQlpZiAoY29uZi0+aWVlZTgwMjExbiAmJiBjb25mLT5od19tb2RlID09IEhPU1RBUERfTU9ERV9JRUVFODAyMTFCKSB7Ci0JCWJzcy0+ZGlzYWJsZV8xMW4gPSAxOwotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkhUIChJRUVFIDgwMi4xMW4pIGluIDExYiBtb2RlIGlzIG5vdCAiCi0JCQkgICAiYWxsb3dlZCwgZGlzYWJsaW5nIEhUIGNhcGFiaWxpdGVzIik7Ci0JfQotCi0JaWYgKGNvbmYtPmllZWU4MDIxMW4gJiYKLQkgICAgYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9PSBTRUNVUklUWV9TVEFUSUNfV0VQKSB7Ci0JCWJzcy0+ZGlzYWJsZV8xMW4gPSAxOwotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkhUIChJRUVFIDgwMi4xMW4pIHdpdGggV0VQIGlzIG5vdCAiCi0JCQkgICAiYWxsb3dlZCwgZGlzYWJsaW5nIEhUIGNhcGFiaWxpdGllcyIpOwotCX0KLQotCWlmIChjb25mLT5pZWVlODAyMTFuICYmIGJzcy0+d3BhICYmCi0JICAgICEoYnNzLT53cGFfcGFpcndpc2UgJiBXUEFfQ0lQSEVSX0NDTVApICYmCi0JICAgICEoYnNzLT5yc25fcGFpcndpc2UgJiAoV1BBX0NJUEhFUl9DQ01QIHwgV1BBX0NJUEhFUl9HQ01QKSkpIHsKLQkJYnNzLT5kaXNhYmxlXzExbiA9IDE7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSFQgKElFRUUgODAyLjExbikgd2l0aCBXUEEvV1BBMiAiCi0JCQkgICAicmVxdWlyZXMgQ0NNUC9HQ01QIHRvIGJlIGVuYWJsZWQsIGRpc2FibGluZyBIVCAiCi0JCQkgICAiY2FwYWJpbGl0aWVzIik7Ci0JfQotI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFOICovCi0KLSNpZmRlZiBDT05GSUdfV1BTMgotCWlmIChic3MtPndwc19zdGF0ZSAmJiBic3MtPmlnbm9yZV9icm9hZGNhc3Rfc3NpZCkgewotCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV1BTOiBpZ25vcmVfYnJvYWRjYXN0X3NzaWQgIgotCQkJICAgImNvbmZpZ3VyYXRpb24gZm9yY2VkIFdQUyB0byBiZSBkaXNhYmxlZCIpOwotCQlic3MtPndwc19zdGF0ZSA9IDA7Ci0JfQotCi0JaWYgKGJzcy0+d3BzX3N0YXRlICYmIGJzcy0+c3NpZC53ZXAua2V5c19zZXQgJiYgYnNzLT53cGEgPT0gMCkgewotCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV1BTOiBXRVAgY29uZmlndXJhdGlvbiBmb3JjZWQgV1BTIHRvIGJlICIKLQkJCSAgICJkaXNhYmxlZCIpOwotCQlic3MtPndwc19zdGF0ZSA9IDA7Ci0JfQotCi0JaWYgKGJzcy0+d3BzX3N0YXRlICYmIGJzcy0+d3BhICYmCi0JICAgICghKGJzcy0+d3BhICYgMikgfHwKLQkgICAgICEoYnNzLT5yc25fcGFpcndpc2UgJiBXUEFfQ0lQSEVSX0NDTVApKSkgewotCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV1BTOiBXUEEvVEtJUCBjb25maWd1cmF0aW9uIHdpdGhvdXQgIgotCQkJICAgIldQQTIvQ0NNUCBmb3JjZWQgV1BTIHRvIGJlIGRpc2FibGVkIik7Ci0JCWJzcy0+d3BzX3N0YXRlID0gMDsKLQl9Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KLQotI2lmZGVmIENPTkZJR19IUzIwCi0JaWYgKGJzcy0+aHMyMCAmJgotCSAgICAoIShic3MtPndwYSAmIDIpIHx8Ci0JICAgICAhKGJzcy0+cnNuX3BhaXJ3aXNlICYgKFdQQV9DSVBIRVJfQ0NNUCB8IFdQQV9DSVBIRVJfR0NNUCkpKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkhTIDIuMDogV1BBMi1FbnRlcnByaXNlL0NDTVAgIgotCQkJICAgImNvbmZpZ3VyYXRpb24gaXMgcmVxdWlyZWQgZm9yIEhvdHNwb3QgMi4wICIKLQkJCSAgICJmdW5jdGlvbmFsaXR5Iik7Ci0JCXJldHVybiAtMTsKLQl9Ci0jZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KLQotCXJldHVybiAwOwotfQotCi0KLXN0YXRpYyBpbnQgaG9zdGFwZF9jb25maWdfY2hlY2soc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mKQotewotCXNpemVfdCBpOwotCi0JaWYgKGNvbmYtPmllZWU4MDIxMWQgJiYgKCFjb25mLT5jb3VudHJ5WzBdIHx8ICFjb25mLT5jb3VudHJ5WzFdKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNhbm5vdCBlbmFibGUgSUVFRSA4MDIuMTFkIHdpdGhvdXQgIgotCQkJICAgInNldHRpbmcgdGhlIGNvdW50cnlfY29kZSIpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JaWYgKGNvbmYtPmllZWU4MDIxMWggJiYgIWNvbmYtPmllZWU4MDIxMWQpIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDYW5ub3QgZW5hYmxlIElFRUUgODAyLjExaCB3aXRob3V0ICIKLQkJCSAgICJJRUVFIDgwMi4xMWQgZW5hYmxlZCIpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JZm9yIChpID0gMDsgaSA8IGNvbmYtPm51bV9ic3M7IGkrKykgewotCQlpZiAoaG9zdGFwZF9jb25maWdfY2hlY2tfYnNzKCZjb25mLT5ic3NbaV0sIGNvbmYpKQotCQkJcmV0dXJuIC0xOwotCX0KLQotCXJldHVybiAwOwotfQotCi0KICNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCiBzdGF0aWMgaW50IHBhcnNlX3JvYW1pbmdfY29uc29ydGl1bShzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsIGNoYXIgKnBvcywKIAkJCQkgICAgaW50IGxpbmUpCkBAIC0xMjg5LDI2ICsxMTkwLDM0IEBACiBzdGF0aWMgaW50IHBhcnNlX2xhbmdfc3RyaW5nKHN0cnVjdCBob3N0YXBkX2xhbmdfc3RyaW5nICoqYXJyYXksCiAJCQkgICAgIHVuc2lnbmVkIGludCAqY291bnQsIGNoYXIgKnBvcykKIHsKLQljaGFyICpzZXA7Ci0Jc2l6ZV90IGNsZW4sIG5sZW47CisJY2hhciAqc2VwLCAqc3RyID0gTlVMTDsKKwlzaXplX3QgY2xlbiwgbmxlbiwgc2xlbjsKIAlzdHJ1Y3QgaG9zdGFwZF9sYW5nX3N0cmluZyAqbHM7CisJaW50IHJldCA9IC0xOworCisJaWYgKCpwb3MgPT0gJyInIHx8ICgqcG9zID09ICdQJyAmJiBwb3NbMV0gPT0gJyInKSkgeworCQlzdHIgPSB3cGFfY29uZmlnX3BhcnNlX3N0cmluZyhwb3MsICZzbGVuKTsKKwkJaWYgKCFzdHIpCisJCQlyZXR1cm4gLTE7CisJCXBvcyA9IHN0cjsKKwl9CiAKIAlzZXAgPSBvc19zdHJjaHIocG9zLCAnOicpOwogCWlmIChzZXAgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOworCQlnb3RvIGZhaWw7CiAJKnNlcCsrID0gJ1wwJzsKIAogCWNsZW4gPSBvc19zdHJsZW4ocG9zKTsKLQlpZiAoY2xlbiA8IDIpCi0JCXJldHVybiAtMTsKKwlpZiAoY2xlbiA8IDIgfHwgY2xlbiA+IHNpemVvZihscy0+bGFuZykpCisJCWdvdG8gZmFpbDsKIAlubGVuID0gb3Nfc3RybGVuKHNlcCk7CiAJaWYgKG5sZW4gPiAyNTIpCi0JCXJldHVybiAtMTsKKwkJZ290byBmYWlsOwogCiAJbHMgPSBvc19yZWFsbG9jX2FycmF5KCphcnJheSwgKmNvdW50ICsgMSwKIAkJCSAgICAgIHNpemVvZihzdHJ1Y3QgaG9zdGFwZF9sYW5nX3N0cmluZykpOwogCWlmIChscyA9PSBOVUxMKQotCQlyZXR1cm4gLTE7CisJCWdvdG8gZmFpbDsKIAogCSphcnJheSA9IGxzOwogCWxzID0gJigqYXJyYXkpWypjb3VudF07CkBAIC0xMzE5LDcgKzEyMjgsMTAgQEAKIAlscy0+bmFtZV9sZW4gPSBubGVuOwogCW9zX21lbWNweShscy0+bmFtZSwgc2VwLCBubGVuKTsKIAotCXJldHVybiAwOworCXJldCA9IDA7CitmYWlsOgorCW9zX2ZyZWUoc3RyKTsKKwlyZXR1cm4gcmV0OwogfQogCiAKQEAgLTEzNDYsNyArMTI1OCw3IEBACiAKIAljb3VudCA9IDE7CiAJZm9yIChwb3MgPSBidWY7ICpwb3M7IHBvcysrKSB7Ci0JCWlmICgoKnBvcyA8ICcwJyAmJiAqcG9zID4gJzknKSAmJiAqcG9zICE9ICc7JyAmJiAqcG9zICE9ICcsJykKKwkJaWYgKCgqcG9zIDwgJzAnIHx8ICpwb3MgPiAnOScpICYmICpwb3MgIT0gJzsnICYmICpwb3MgIT0gJywnKQogCQkJZ290byBmYWlsOwogCQlpZiAoKnBvcyA9PSAnOycpCiAJCQljb3VudCsrOwpAQCAtMTU1MCw2ICsxNDYyLDQ3IEBACiAJcmV0dXJuIC0xOwogfQogCisKK3N0YXRpYyBpbnQgcGFyc2VfcW9zX21hcF9zZXQoc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzLAorCQkJICAgICBjaGFyICpidWYsIGludCBsaW5lKQoreworCXU4IHFvc19tYXBfc2V0WzE2ICsgMiAqIDIxXSwgY291bnQgPSAwOworCWNoYXIgKnBvcyA9IGJ1ZjsKKwlpbnQgdmFsOworCisJZm9yICg7OykgeworCQlpZiAoY291bnQgPT0gc2l6ZW9mKHFvc19tYXBfc2V0KSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBUb28gbWFueSBxb3NfbWFwX3NldCAiCisJCQkJICAgInBhcmFtZXRlcnMgJyVzJyIsIGxpbmUsIGJ1Zik7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQl2YWwgPSBhdG9pKHBvcyk7CisJCWlmICh2YWwgPiAyNTUgfHwgdmFsIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkIHFvc19tYXBfc2V0ICIKKwkJCQkgICAiJyVzJyIsIGxpbmUsIGJ1Zik7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQlxb3NfbWFwX3NldFtjb3VudCsrXSA9IHZhbDsKKwkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJywnKTsKKwkJaWYgKCFwb3MpCisJCQlicmVhazsKKwkJcG9zKys7CisJfQorCisJaWYgKGNvdW50IDwgMTYgfHwgY291bnQgJiAxKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBxb3NfbWFwX3NldCAnJXMnIiwKKwkJCSAgIGxpbmUsIGJ1Zik7CisJCXJldHVybiAtMTsKKwl9CisKKwlvc19tZW1jcHkoYnNzLT5xb3NfbWFwX3NldCwgcW9zX21hcF9zZXQsIGNvdW50KTsKKwlic3MtPnFvc19tYXBfc2V0X2xlbiA9IGNvdW50OworCisJcmV0dXJuIDA7Cit9CisKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAKIApAQCAtMTY0Nyw3ICsxNjAwLDcgQEAKIAogZmFpbDoKIAl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgaHMyMF93YW5fbWV0cmljcyAnJXMnIiwKLQkJICAgbGluZSwgcG9zKTsKKwkJICAgbGluZSwgYnVmKTsKIAlvc19mcmVlKHdhbl9tZXRyaWNzKTsKIAlyZXR1cm4gLTE7CiB9CkBAIC0xNjY0LDYgKzE2MTcsMTk3IEBACiAJfQogCXJldHVybiAwOwogfQorCisKK3N0YXRpYyBpbnQgaHMyMF9wYXJzZV9pY29uKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcywgY2hhciAqcG9zKQoreworCXN0cnVjdCBoczIwX2ljb24gKmljb247CisJY2hhciAqZW5kOworCisJaWNvbiA9IG9zX3JlYWxsb2NfYXJyYXkoYnNzLT5oczIwX2ljb25zLCBic3MtPmhzMjBfaWNvbnNfY291bnQgKyAxLAorCQkJCXNpemVvZihzdHJ1Y3QgaHMyMF9pY29uKSk7CisJaWYgKGljb24gPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWJzcy0+aHMyMF9pY29ucyA9IGljb247CisJaWNvbiA9ICZic3MtPmhzMjBfaWNvbnNbYnNzLT5oczIwX2ljb25zX2NvdW50XTsKKwlvc19tZW1zZXQoaWNvbiwgMCwgc2l6ZW9mKCppY29uKSk7CisKKwlpY29uLT53aWR0aCA9IGF0b2kocG9zKTsKKwlwb3MgPSBvc19zdHJjaHIocG9zLCAnOicpOworCWlmIChwb3MgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXBvcysrOworCisJaWNvbi0+aGVpZ2h0ID0gYXRvaShwb3MpOworCXBvcyA9IG9zX3N0cmNocihwb3MsICc6Jyk7CisJaWYgKHBvcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJcG9zKys7CisKKwllbmQgPSBvc19zdHJjaHIocG9zLCAnOicpOworCWlmIChlbmQgPT0gTlVMTCB8fCBlbmQgLSBwb3MgPiAzKQorCQlyZXR1cm4gLTE7CisJb3NfbWVtY3B5KGljb24tPmxhbmd1YWdlLCBwb3MsIGVuZCAtIHBvcyk7CisJcG9zID0gZW5kICsgMTsKKworCWVuZCA9IG9zX3N0cmNocihwb3MsICc6Jyk7CisJaWYgKGVuZCA9PSBOVUxMIHx8IGVuZCAtIHBvcyA+IDI1NSkKKwkJcmV0dXJuIC0xOworCW9zX21lbWNweShpY29uLT50eXBlLCBwb3MsIGVuZCAtIHBvcyk7CisJcG9zID0gZW5kICsgMTsKKworCWVuZCA9IG9zX3N0cmNocihwb3MsICc6Jyk7CisJaWYgKGVuZCA9PSBOVUxMIHx8IGVuZCAtIHBvcyA+IDI1NSkKKwkJcmV0dXJuIC0xOworCW9zX21lbWNweShpY29uLT5uYW1lLCBwb3MsIGVuZCAtIHBvcyk7CisJcG9zID0gZW5kICsgMTsKKworCWlmIChvc19zdHJsZW4ocG9zKSA+IDI1NSkKKwkJcmV0dXJuIC0xOworCW9zX21lbWNweShpY29uLT5maWxlLCBwb3MsIG9zX3N0cmxlbihwb3MpKTsKKworCWJzcy0+aHMyMF9pY29uc19jb3VudCsrOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBoczIwX3BhcnNlX29zdV9zc2lkKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcywKKwkJCSAgICAgICBjaGFyICpwb3MsIGludCBsaW5lKQoreworCXNpemVfdCBzbGVuOworCWNoYXIgKnN0cjsKKworCXN0ciA9IHdwYV9jb25maWdfcGFyc2Vfc3RyaW5nKHBvcywgJnNsZW4pOworCWlmIChzdHIgPT0gTlVMTCB8fCBzbGVuIDwgMSB8fCBzbGVuID4gSE9TVEFQRF9NQVhfU1NJRF9MRU4pIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkIFNTSUQgJyVzJyIsIGxpbmUsIHBvcyk7CisJCW9zX2ZyZWUoc3RyKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9zX21lbWNweShic3MtPm9zdV9zc2lkLCBzdHIsIHNsZW4pOworCWJzcy0+b3N1X3NzaWRfbGVuID0gc2xlbjsKKwlvc19mcmVlKHN0cik7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IGhzMjBfcGFyc2Vfb3N1X3NlcnZlcl91cmkoc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzLAorCQkJCSAgICAgY2hhciAqcG9zLCBpbnQgbGluZSkKK3sKKwlzdHJ1Y3QgaHMyMF9vc3VfcHJvdmlkZXIgKnA7CisKKwlwID0gb3NfcmVhbGxvY19hcnJheShic3MtPmhzMjBfb3N1X3Byb3ZpZGVycywKKwkJCSAgICAgYnNzLT5oczIwX29zdV9wcm92aWRlcnNfY291bnQgKyAxLCBzaXplb2YoKnApKTsKKwlpZiAocCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlic3MtPmhzMjBfb3N1X3Byb3ZpZGVycyA9IHA7CisJYnNzLT5sYXN0X29zdSA9ICZic3MtPmhzMjBfb3N1X3Byb3ZpZGVyc1tic3MtPmhzMjBfb3N1X3Byb3ZpZGVyc19jb3VudF07CisJYnNzLT5oczIwX29zdV9wcm92aWRlcnNfY291bnQrKzsKKwlvc19tZW1zZXQoYnNzLT5sYXN0X29zdSwgMCwgc2l6ZW9mKCpwKSk7CisJYnNzLT5sYXN0X29zdS0+c2VydmVyX3VyaSA9IG9zX3N0cmR1cChwb3MpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBoczIwX3BhcnNlX29zdV9mcmllbmRseV9uYW1lKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcywKKwkJCQkJY2hhciAqcG9zLCBpbnQgbGluZSkKK3sKKwlpZiAoYnNzLT5sYXN0X29zdSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogVW5leHBlY3RlZCBPU1UgZmllbGQiLCBsaW5lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChwYXJzZV9sYW5nX3N0cmluZygmYnNzLT5sYXN0X29zdS0+ZnJpZW5kbHlfbmFtZSwKKwkJCSAgICAgICZic3MtPmxhc3Rfb3N1LT5mcmllbmRseV9uYW1lX2NvdW50LCBwb3MpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBvc3VfZnJpZW5kbHlfbmFtZSAnJXMnIiwKKwkJCSAgIGxpbmUsIHBvcyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IGhzMjBfcGFyc2Vfb3N1X25haShzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsCisJCQkgICAgICBjaGFyICpwb3MsIGludCBsaW5lKQoreworCWlmIChic3MtPmxhc3Rfb3N1ID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBVbmV4cGVjdGVkIE9TVSBmaWVsZCIsIGxpbmUpOworCQlyZXR1cm4gLTE7CisJfQorCisJb3NfZnJlZShic3MtPmxhc3Rfb3N1LT5vc3VfbmFpKTsKKwlic3MtPmxhc3Rfb3N1LT5vc3VfbmFpID0gb3Nfc3RyZHVwKHBvcyk7CisJaWYgKGJzcy0+bGFzdF9vc3UtPm9zdV9uYWkgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBoczIwX3BhcnNlX29zdV9tZXRob2RfbGlzdChzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsIGNoYXIgKnBvcywKKwkJCQkgICAgICBpbnQgbGluZSkKK3sKKwlpZiAoYnNzLT5sYXN0X29zdSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogVW5leHBlY3RlZCBPU1UgZmllbGQiLCBsaW5lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChob3N0YXBkX3BhcnNlX2ludGxpc3QoJmJzcy0+bGFzdF9vc3UtPm1ldGhvZF9saXN0LCBwb3MpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBvc3VfbWV0aG9kX2xpc3QiLCBsaW5lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgaHMyMF9wYXJzZV9vc3VfaWNvbihzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsIGNoYXIgKnBvcywKKwkJCSAgICAgICBpbnQgbGluZSkKK3sKKwljaGFyICoqbjsKKwlzdHJ1Y3QgaHMyMF9vc3VfcHJvdmlkZXIgKnAgPSBic3MtPmxhc3Rfb3N1OworCisJaWYgKHAgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IFVuZXhwZWN0ZWQgT1NVIGZpZWxkIiwgbGluZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwluID0gb3NfcmVhbGxvY19hcnJheShwLT5pY29ucywgcC0+aWNvbnNfY291bnQgKyAxLCBzaXplb2YoY2hhciAqKSk7CisJaWYgKG4gPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXAtPmljb25zID0gbjsKKwlwLT5pY29uc1twLT5pY29uc19jb3VudF0gPSBvc19zdHJkdXAocG9zKTsKKwlpZiAocC0+aWNvbnNbcC0+aWNvbnNfY291bnRdID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlwLT5pY29uc19jb3VudCsrOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBoczIwX3BhcnNlX29zdV9zZXJ2aWNlX2Rlc2Moc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzLAorCQkJCSAgICAgICBjaGFyICpwb3MsIGludCBsaW5lKQoreworCWlmIChic3MtPmxhc3Rfb3N1ID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBVbmV4cGVjdGVkIE9TVSBmaWVsZCIsIGxpbmUpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKHBhcnNlX2xhbmdfc3RyaW5nKCZic3MtPmxhc3Rfb3N1LT5zZXJ2aWNlX2Rlc2MsCisJCQkgICAgICAmYnNzLT5sYXN0X29zdS0+c2VydmljZV9kZXNjX2NvdW50LCBwb3MpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBvc3Vfc2VydmljZV9kZXNjICclcyciLAorCQkJICAgbGluZSwgcG9zKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCiAjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAogCkBAIC0xNjk2LDEzNDkgKzE4NDAsMTMzMyBAQAogCQkJICAgICAgIHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcywKIAkJCSAgICAgICBjaGFyICpidWYsIGNoYXIgKnBvcywgaW50IGxpbmUpCiB7Ci0JaW50IGVycm9ycyA9IDA7Ci0KLQl7Ci0JCWlmIChvc19zdHJjbXAoYnVmLCAiaW50ZXJmYWNlIikgPT0gMCkgewotCQkJb3Nfc3RybGNweShjb25mLT5ic3NbMF0uaWZhY2UsIHBvcywKLQkJCQkgICBzaXplb2YoY29uZi0+YnNzWzBdLmlmYWNlKSk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImJyaWRnZSIpID09IDApIHsKLQkJCW9zX3N0cmxjcHkoYnNzLT5icmlkZ2UsIHBvcywgc2l6ZW9mKGJzcy0+YnJpZGdlKSk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZsYW5fYnJpZGdlIikgPT0gMCkgewotCQkJb3Nfc3RybGNweShic3MtPnZsYW5fYnJpZGdlLCBwb3MsCi0JCQkgICAgICAgICAgIHNpemVvZihic3MtPnZsYW5fYnJpZGdlKSk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndkc19icmlkZ2UiKSA9PSAwKSB7Ci0JCQlvc19zdHJsY3B5KGJzcy0+d2RzX2JyaWRnZSwgcG9zLAotCQkJCSAgIHNpemVvZihic3MtPndkc19icmlkZ2UpKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZHJpdmVyIikgPT0gMCkgewotCQkJaW50IGo7Ci0JCQkvKiBjbGVhciB0byBnZXQgZXJyb3IgYmVsb3cgaWYgc2V0dGluZyBpcyBpbnZhbGlkICovCi0JCQljb25mLT5kcml2ZXIgPSBOVUxMOwotCQkJZm9yIChqID0gMDsgd3BhX2RyaXZlcnNbal07IGorKykgewotCQkJCWlmIChvc19zdHJjbXAocG9zLCB3cGFfZHJpdmVyc1tqXS0+bmFtZSkgPT0gMCkKLQkJCQl7Ci0JCQkJCWNvbmYtPmRyaXZlciA9IHdwYV9kcml2ZXJzW2pdOwotCQkJCQlicmVhazsKLQkJCQl9CisJaWYgKG9zX3N0cmNtcChidWYsICJpbnRlcmZhY2UiKSA9PSAwKSB7CisJCW9zX3N0cmxjcHkoY29uZi0+YnNzWzBdLT5pZmFjZSwgcG9zLAorCQkJICAgc2l6ZW9mKGNvbmYtPmJzc1swXS0+aWZhY2UpKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJicmlkZ2UiKSA9PSAwKSB7CisJCW9zX3N0cmxjcHkoYnNzLT5icmlkZ2UsIHBvcywgc2l6ZW9mKGJzcy0+YnJpZGdlKSk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmxhbl9icmlkZ2UiKSA9PSAwKSB7CisJCW9zX3N0cmxjcHkoYnNzLT52bGFuX2JyaWRnZSwgcG9zLCBzaXplb2YoYnNzLT52bGFuX2JyaWRnZSkpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndkc19icmlkZ2UiKSA9PSAwKSB7CisJCW9zX3N0cmxjcHkoYnNzLT53ZHNfYnJpZGdlLCBwb3MsIHNpemVvZihic3MtPndkc19icmlkZ2UpKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkcml2ZXIiKSA9PSAwKSB7CisJCWludCBqOworCQkvKiBjbGVhciB0byBnZXQgZXJyb3IgYmVsb3cgaWYgc2V0dGluZyBpcyBpbnZhbGlkICovCisJCWNvbmYtPmRyaXZlciA9IE5VTEw7CisJCWZvciAoaiA9IDA7IHdwYV9kcml2ZXJzW2pdOyBqKyspIHsKKwkJCWlmIChvc19zdHJjbXAocG9zLCB3cGFfZHJpdmVyc1tqXS0+bmFtZSkgPT0gMCkgeworCQkJCWNvbmYtPmRyaXZlciA9IHdwYV9kcml2ZXJzW2pdOworCQkJCWJyZWFrOwogCQkJfQotCQkJaWYgKGNvbmYtPmRyaXZlciA9PSBOVUxMKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkLyIKLQkJCQkJICAgInVua25vd24gZHJpdmVyICclcyciLCBsaW5lLCBwb3MpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkZWJ1ZyIpID09IDApIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogREVQUkVDQVRFRDogJ2RlYnVnJyAiCi0JCQkJICAgImNvbmZpZ3VyYXRpb24gdmFyaWFibGUgaXMgbm90IHVzZWQgIgotCQkJCSAgICJhbnltb3JlIiwgbGluZSk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImxvZ2dlcl9zeXNsb2dfbGV2ZWwiKSA9PSAwKSB7Ci0JCQlic3MtPmxvZ2dlcl9zeXNsb2dfbGV2ZWwgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImxvZ2dlcl9zdGRvdXRfbGV2ZWwiKSA9PSAwKSB7Ci0JCQlic3MtPmxvZ2dlcl9zdGRvdXRfbGV2ZWwgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImxvZ2dlcl9zeXNsb2ciKSA9PSAwKSB7Ci0JCQlic3MtPmxvZ2dlcl9zeXNsb2cgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImxvZ2dlcl9zdGRvdXQiKSA9PSAwKSB7Ci0JCQlic3MtPmxvZ2dlcl9zdGRvdXQgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImR1bXBfZmlsZSIpID09IDApIHsKLQkJCWJzcy0+ZHVtcF9sb2dfbmFtZSA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzc2lkIikgPT0gMCkgewotCQkJYnNzLT5zc2lkLnNzaWRfbGVuID0gb3Nfc3RybGVuKHBvcyk7Ci0JCQlpZiAoYnNzLT5zc2lkLnNzaWRfbGVuID4gSE9TVEFQRF9NQVhfU1NJRF9MRU4gfHwKLQkJCSAgICBic3MtPnNzaWQuc3NpZF9sZW4gPCAxKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIFNTSUQgIgotCQkJCQkgICAiJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9IGVsc2UgewotCQkJCW9zX21lbWNweShic3MtPnNzaWQuc3NpZCwgcG9zLAotCQkJCQkgIGJzcy0+c3NpZC5zc2lkX2xlbik7Ci0JCQkJYnNzLT5zc2lkLnNzaWRfc2V0ID0gMTsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAic3NpZDIiKSA9PSAwKSB7Ci0JCQlzaXplX3Qgc2xlbjsKLQkJCWNoYXIgKnN0ciA9IHdwYV9jb25maWdfcGFyc2Vfc3RyaW5nKHBvcywgJnNsZW4pOwotCQkJaWYgKHN0ciA9PSBOVUxMIHx8IHNsZW4gPCAxIHx8Ci0JCQkJICAgc2xlbiA+IEhPU1RBUERfTUFYX1NTSURfTEVOKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIFNTSUQgIgotCQkJCQkgICAiJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9IGVsc2UgewotCQkJCW9zX21lbWNweShic3MtPnNzaWQuc3NpZCwgc3RyLCBzbGVuKTsKLQkJCQlic3MtPnNzaWQuc3NpZF9sZW4gPSBzbGVuOwotCQkJCWJzcy0+c3NpZC5zc2lkX3NldCA9IDE7Ci0JCQl9CisJCX0KKwkJaWYgKGNvbmYtPmRyaXZlciA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiTGluZSAlZDogaW52YWxpZC91bmtub3duIGRyaXZlciAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkZWJ1ZyIpID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJMaW5lICVkOiBERVBSRUNBVEVEOiAnZGVidWcnIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgaXMgbm90IHVzZWQgYW55bW9yZSIsCisJCQkgICBsaW5lKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJsb2dnZXJfc3lzbG9nX2xldmVsIikgPT0gMCkgeworCQlic3MtPmxvZ2dlcl9zeXNsb2dfbGV2ZWwgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibG9nZ2VyX3N0ZG91dF9sZXZlbCIpID09IDApIHsKKwkJYnNzLT5sb2dnZXJfc3Rkb3V0X2xldmVsID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImxvZ2dlcl9zeXNsb2ciKSA9PSAwKSB7CisJCWJzcy0+bG9nZ2VyX3N5c2xvZyA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJsb2dnZXJfc3Rkb3V0IikgPT0gMCkgeworCQlic3MtPmxvZ2dlcl9zdGRvdXQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZHVtcF9maWxlIikgPT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTGluZSAlZDogREVQUkVDQVRFRDogJ2R1bXBfZmlsZScgY29uZmlndXJhdGlvbiB2YXJpYWJsZSBpcyBub3QgdXNlZCBhbnltb3JlIiwKKwkJCSAgIGxpbmUpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInNzaWQiKSA9PSAwKSB7CisJCWJzcy0+c3NpZC5zc2lkX2xlbiA9IG9zX3N0cmxlbihwb3MpOworCQlpZiAoYnNzLT5zc2lkLnNzaWRfbGVuID4gSE9TVEFQRF9NQVhfU1NJRF9MRU4gfHwKKwkJICAgIGJzcy0+c3NpZC5zc2lkX2xlbiA8IDEpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBTU0lEICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlvc19tZW1jcHkoYnNzLT5zc2lkLnNzaWQsIHBvcywgYnNzLT5zc2lkLnNzaWRfbGVuKTsKKwkJYnNzLT5zc2lkLnNzaWRfc2V0ID0gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzc2lkMiIpID09IDApIHsKKwkJc2l6ZV90IHNsZW47CisJCWNoYXIgKnN0ciA9IHdwYV9jb25maWdfcGFyc2Vfc3RyaW5nKHBvcywgJnNsZW4pOworCQlpZiAoc3RyID09IE5VTEwgfHwgc2xlbiA8IDEgfHwgc2xlbiA+IEhPU1RBUERfTUFYX1NTSURfTEVOKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgU1NJRCAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOwogCQkJb3NfZnJlZShzdHIpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ1dGY4X3NzaWQiKSA9PSAwKSB7Ci0JCQlic3MtPnNzaWQudXRmOF9zc2lkID0gYXRvaShwb3MpID4gMDsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWFjYWRkcl9hY2wiKSA9PSAwKSB7Ci0JCQlic3MtPm1hY2FkZHJfYWNsID0gYXRvaShwb3MpOwotCQkJaWYgKGJzcy0+bWFjYWRkcl9hY2wgIT0gQUNDRVBUX1VOTEVTU19ERU5JRUQgJiYKLQkJCSAgICBic3MtPm1hY2FkZHJfYWNsICE9IERFTllfVU5MRVNTX0FDQ0VQVEVEICYmCi0JCQkgICAgYnNzLT5tYWNhZGRyX2FjbCAhPSBVU0VfRVhURVJOQUxfUkFESVVTX0FVVEgpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVua25vd24gIgotCQkJCQkgICAibWFjYWRkcl9hY2wgJWQiLAotCQkJCQkgICBsaW5lLCBic3MtPm1hY2FkZHJfYWNsKTsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYWNjZXB0X21hY19maWxlIikgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfY29uZmlnX3JlYWRfbWFjbGlzdChwb3MsICZic3MtPmFjY2VwdF9tYWMsCi0JCQkJCQkJJmJzcy0+bnVtX2FjY2VwdF9tYWMpKQotCQkJewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogRmFpbGVkIHRvICIKLQkJCQkJICAgInJlYWQgYWNjZXB0X21hY19maWxlICclcyciLAotCQkJCQkgICBsaW5lLCBwb3MpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkZW55X21hY19maWxlIikgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfY29uZmlnX3JlYWRfbWFjbGlzdChwb3MsICZic3MtPmRlbnlfbWFjLAotCQkJCQkJCSZic3MtPm51bV9kZW55X21hYykpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEZhaWxlZCB0byAiCi0JCQkJCSAgICJyZWFkIGRlbnlfbWFjX2ZpbGUgJyVzJyIsCi0JCQkJCSAgIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndkc19zdGEiKSA9PSAwKSB7Ci0JCQlic3MtPndkc19zdGEgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInN0YXJ0X2Rpc2FibGVkIikgPT0gMCkgewotCQkJYnNzLT5zdGFydF9kaXNhYmxlZCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXBfaXNvbGF0ZSIpID09IDApIHsKLQkJCWJzcy0+aXNvbGF0ZSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXBfbWF4X2luYWN0aXZpdHkiKSA9PSAwKSB7Ci0JCQlic3MtPmFwX21heF9pbmFjdGl2aXR5ID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJza2lwX2luYWN0aXZpdHlfcG9sbCIpID09IDApIHsKLQkJCWJzcy0+c2tpcF9pbmFjdGl2aXR5X3BvbGwgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImNvdW50cnlfY29kZSIpID09IDApIHsKLQkJCW9zX21lbWNweShjb25mLT5jb3VudHJ5LCBwb3MsIDIpOwotCQkJLyogRklYOiBtYWtlIHRoaXMgY29uZmlndXJhYmxlICovCi0JCQljb25mLT5jb3VudHJ5WzJdID0gJyAnOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJpZWVlODAyMTFkIikgPT0gMCkgewotCQkJY29uZi0+aWVlZTgwMjExZCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaWVlZTgwMjExaCIpID09IDApIHsKLQkJCWNvbmYtPmllZWU4MDIxMWggPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImllZWU4MDIxeCIpID09IDApIHsKLQkJCWJzcy0+aWVlZTgwMl8xeCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZWFwb2xfdmVyc2lvbiIpID09IDApIHsKLQkJCWJzcy0+ZWFwb2xfdmVyc2lvbiA9IGF0b2kocG9zKTsKLQkJCWlmIChic3MtPmVhcG9sX3ZlcnNpb24gPCAxIHx8Ci0JCQkgICAgYnNzLT5lYXBvbF92ZXJzaW9uID4gMikgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBFQVBPTCAiCi0JCQkJCSAgICJ2ZXJzaW9uICglZCk6ICclcycuIiwKLQkJCQkJICAgbGluZSwgYnNzLT5lYXBvbF92ZXJzaW9uLCBwb3MpOwotCQkJCWVycm9ycysrOwotCQkJfSBlbHNlCi0JCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJlYXBvbF92ZXJzaW9uPSVkIiwKLQkJCQkJICAgYnNzLT5lYXBvbF92ZXJzaW9uKTsKKwkJCXJldHVybiAxOworCQl9CisJCW9zX21lbWNweShic3MtPnNzaWQuc3NpZCwgc3RyLCBzbGVuKTsKKwkJYnNzLT5zc2lkLnNzaWRfbGVuID0gc2xlbjsKKwkJYnNzLT5zc2lkLnNzaWRfc2V0ID0gMTsKKwkJb3NfZnJlZShzdHIpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInV0Zjhfc3NpZCIpID09IDApIHsKKwkJYnNzLT5zc2lkLnV0Zjhfc3NpZCA9IGF0b2kocG9zKSA+IDA7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWFjYWRkcl9hY2wiKSA9PSAwKSB7CisJCWJzcy0+bWFjYWRkcl9hY2wgPSBhdG9pKHBvcyk7CisJCWlmIChic3MtPm1hY2FkZHJfYWNsICE9IEFDQ0VQVF9VTkxFU1NfREVOSUVEICYmCisJCSAgICBic3MtPm1hY2FkZHJfYWNsICE9IERFTllfVU5MRVNTX0FDQ0VQVEVEICYmCisJCSAgICBic3MtPm1hY2FkZHJfYWNsICE9IFVTRV9FWFRFUk5BTF9SQURJVVNfQVVUSCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiB1bmtub3duIG1hY2FkZHJfYWNsICVkIiwKKwkJCQkgICBsaW5lLCBic3MtPm1hY2FkZHJfYWNsKTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFjY2VwdF9tYWNfZmlsZSIpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY29uZmlnX3JlYWRfbWFjbGlzdChwb3MsICZic3MtPmFjY2VwdF9tYWMsCisJCQkJCQkmYnNzLT5udW1fYWNjZXB0X21hYykpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogRmFpbGVkIHRvIHJlYWQgYWNjZXB0X21hY19maWxlICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImRlbnlfbWFjX2ZpbGUiKSA9PSAwKSB7CisJCWlmIChob3N0YXBkX2NvbmZpZ19yZWFkX21hY2xpc3QocG9zLCAmYnNzLT5kZW55X21hYywKKwkJCQkJCSZic3MtPm51bV9kZW55X21hYykpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogRmFpbGVkIHRvIHJlYWQgZGVueV9tYWNfZmlsZSAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3ZHNfc3RhIikgPT0gMCkgeworCQlic3MtPndkc19zdGEgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAic3RhcnRfZGlzYWJsZWQiKSA9PSAwKSB7CisJCWJzcy0+c3RhcnRfZGlzYWJsZWQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXBfaXNvbGF0ZSIpID09IDApIHsKKwkJYnNzLT5pc29sYXRlID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFwX21heF9pbmFjdGl2aXR5IikgPT0gMCkgeworCQlic3MtPmFwX21heF9pbmFjdGl2aXR5ID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInNraXBfaW5hY3Rpdml0eV9wb2xsIikgPT0gMCkgeworCQlic3MtPnNraXBfaW5hY3Rpdml0eV9wb2xsID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImNvdW50cnlfY29kZSIpID09IDApIHsKKwkJb3NfbWVtY3B5KGNvbmYtPmNvdW50cnksIHBvcywgMik7CisJCS8qIEZJWDogbWFrZSB0aGlzIGNvbmZpZ3VyYWJsZSAqLworCQljb25mLT5jb3VudHJ5WzJdID0gJyAnOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImllZWU4MDIxMWQiKSA9PSAwKSB7CisJCWNvbmYtPmllZWU4MDIxMWQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaWVlZTgwMjExaCIpID09IDApIHsKKwkJY29uZi0+aWVlZTgwMjExaCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJpZWVlODAyMXgiKSA9PSAwKSB7CisJCWJzcy0+aWVlZTgwMl8xeCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBvbF92ZXJzaW9uIikgPT0gMCkgeworCQlic3MtPmVhcG9sX3ZlcnNpb24gPSBhdG9pKHBvcyk7CisJCWlmIChic3MtPmVhcG9sX3ZlcnNpb24gPCAxIHx8IGJzcy0+ZWFwb2xfdmVyc2lvbiA+IDIpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJMaW5lICVkOiBpbnZhbGlkIEVBUE9MIHZlcnNpb24gKCVkKTogJyVzJy4iLAorCQkJCSAgIGxpbmUsIGJzcy0+ZWFwb2xfdmVyc2lvbiwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiZWFwb2xfdmVyc2lvbj0lZCIsIGJzcy0+ZWFwb2xfdmVyc2lvbik7CiAjaWZkZWYgRUFQX1NFUlZFUgotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfYXV0aGVudGljYXRvciIpID09IDApIHsKLQkJCWJzcy0+ZWFwX3NlcnZlciA9IGF0b2kocG9zKTsKLQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogb2Jzb2xldGUgIgotCQkJCSAgICJlYXBfYXV0aGVudGljYXRvciB1c2VkOyB0aGlzIGhhcyBiZWVuICIKLQkJCQkgICAicmVuYW1lZCB0byBlYXBfc2VydmVyIiwgbGluZSk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcF9zZXJ2ZXIiKSA9PSAwKSB7Ci0JCQlic3MtPmVhcF9zZXJ2ZXIgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcF91c2VyX2ZpbGUiKSA9PSAwKSB7Ci0JCQlpZiAoaG9zdGFwZF9jb25maWdfcmVhZF9lYXBfdXNlcihwb3MsIGJzcykpCi0JCQkJZXJyb3JzKys7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImNhX2NlcnQiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+Y2FfY2VydCk7Ci0JCQlic3MtPmNhX2NlcnQgPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAic2VydmVyX2NlcnQiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+c2VydmVyX2NlcnQpOwotCQkJYnNzLT5zZXJ2ZXJfY2VydCA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwcml2YXRlX2tleSIpID09IDApIHsKLQkJCW9zX2ZyZWUoYnNzLT5wcml2YXRlX2tleSk7Ci0JCQlic3MtPnByaXZhdGVfa2V5ID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInByaXZhdGVfa2V5X3Bhc3N3ZCIpID09IDApIHsKLQkJCW9zX2ZyZWUoYnNzLT5wcml2YXRlX2tleV9wYXNzd2QpOwotCQkJYnNzLT5wcml2YXRlX2tleV9wYXNzd2QgPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiY2hlY2tfY3JsIikgPT0gMCkgewotCQkJYnNzLT5jaGVja19jcmwgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm9jc3Bfc3RhcGxpbmdfcmVzcG9uc2UiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+b2NzcF9zdGFwbGluZ19yZXNwb25zZSk7Ci0JCQlic3MtPm9jc3Bfc3RhcGxpbmdfcmVzcG9uc2UgPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZGhfZmlsZSIpID09IDApIHsKLQkJCW9zX2ZyZWUoYnNzLT5kaF9maWxlKTsKLQkJCWJzcy0+ZGhfZmlsZSA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJmcmFnbWVudF9zaXplIikgPT0gMCkgewotCQkJYnNzLT5mcmFnbWVudF9zaXplID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcF9hdXRoZW50aWNhdG9yIikgPT0gMCkgeworCQlic3MtPmVhcF9zZXJ2ZXIgPSBhdG9pKHBvcyk7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogb2Jzb2xldGUgZWFwX2F1dGhlbnRpY2F0b3IgdXNlZDsgdGhpcyBoYXMgYmVlbiByZW5hbWVkIHRvIGVhcF9zZXJ2ZXIiLCBsaW5lKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfc2VydmVyIikgPT0gMCkgeworCQlic3MtPmVhcF9zZXJ2ZXIgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZWFwX3VzZXJfZmlsZSIpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY29uZmlnX3JlYWRfZWFwX3VzZXIocG9zLCBic3MpKQorCQkJcmV0dXJuIDE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiY2FfY2VydCIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPmNhX2NlcnQpOworCQlic3MtPmNhX2NlcnQgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzZXJ2ZXJfY2VydCIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPnNlcnZlcl9jZXJ0KTsKKwkJYnNzLT5zZXJ2ZXJfY2VydCA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInByaXZhdGVfa2V5IikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+cHJpdmF0ZV9rZXkpOworCQlic3MtPnByaXZhdGVfa2V5ID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicHJpdmF0ZV9rZXlfcGFzc3dkIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+cHJpdmF0ZV9rZXlfcGFzc3dkKTsKKwkJYnNzLT5wcml2YXRlX2tleV9wYXNzd2QgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJjaGVja19jcmwiKSA9PSAwKSB7CisJCWJzcy0+Y2hlY2tfY3JsID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm9jc3Bfc3RhcGxpbmdfcmVzcG9uc2UiKSA9PSAwKSB7CisJCW9zX2ZyZWUoYnNzLT5vY3NwX3N0YXBsaW5nX3Jlc3BvbnNlKTsKKwkJYnNzLT5vY3NwX3N0YXBsaW5nX3Jlc3BvbnNlID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZGhfZmlsZSIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPmRoX2ZpbGUpOworCQlic3MtPmRoX2ZpbGUgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJmcmFnbWVudF9zaXplIikgPT0gMCkgeworCQlic3MtPmZyYWdtZW50X3NpemUgPSBhdG9pKHBvcyk7CiAjaWZkZWYgRUFQX1NFUlZFUl9GQVNUCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBhY19vcGFxdWVfZW5jcl9rZXkiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+cGFjX29wYXF1ZV9lbmNyX2tleSk7Ci0JCQlic3MtPnBhY19vcGFxdWVfZW5jcl9rZXkgPSBvc19tYWxsb2MoMTYpOwotCQkJaWYgKGJzcy0+cGFjX29wYXF1ZV9lbmNyX2tleSA9PSBOVUxMKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBObyBtZW1vcnkgZm9yICIKLQkJCQkJICAgInBhY19vcGFxdWVfZW5jcl9rZXkiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0gZWxzZSBpZiAoaGV4c3RyMmJpbihwb3MsIGJzcy0+cGFjX29wYXF1ZV9lbmNyX2tleSwKLQkJCQkJICAgICAgMTYpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkICIKLQkJCQkJICAgInBhY19vcGFxdWVfZW5jcl9rZXkiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZWFwX2Zhc3RfYV9pZCIpID09IDApIHsKLQkJCXNpemVfdCBpZGxlbiA9IG9zX3N0cmxlbihwb3MpOwotCQkJaWYgKGlkbGVuICYgMSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJlYXBfZmFzdF9hX2lkIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9IGVsc2UgewotCQkJCW9zX2ZyZWUoYnNzLT5lYXBfZmFzdF9hX2lkKTsKLQkJCQlic3MtPmVhcF9mYXN0X2FfaWQgPSBvc19tYWxsb2MoaWRsZW4gLyAyKTsKLQkJCQlpZiAoYnNzLT5lYXBfZmFzdF9hX2lkID09IE5VTEwgfHwKLQkJCQkgICAgaGV4c3RyMmJpbihwb3MsIGJzcy0+ZWFwX2Zhc3RfYV9pZCwKLQkJCQkJICAgICAgIGlkbGVuIC8gMikpIHsKLQkJCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiAiCi0JCQkJCQkgICAiRmFpbGVkIHRvIHBhcnNlICIKLQkJCQkJCSAgICJlYXBfZmFzdF9hX2lkIiwgbGluZSk7Ci0JCQkJCWVycm9ycysrOwotCQkJCX0gZWxzZQotCQkJCQlic3MtPmVhcF9mYXN0X2FfaWRfbGVuID0gaWRsZW4gLyAyOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfZmFzdF9hX2lkX2luZm8iKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+ZWFwX2Zhc3RfYV9pZF9pbmZvKTsKLQkJCWJzcy0+ZWFwX2Zhc3RfYV9pZF9pbmZvID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcF9mYXN0X3Byb3YiKSA9PSAwKSB7Ci0JCQlic3MtPmVhcF9mYXN0X3Byb3YgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBhY19rZXlfbGlmZXRpbWUiKSA9PSAwKSB7Ci0JCQlic3MtPnBhY19rZXlfbGlmZXRpbWUgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBhY19rZXlfcmVmcmVzaF90aW1lIikgPT0gMCkgewotCQkJYnNzLT5wYWNfa2V5X3JlZnJlc2hfdGltZSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwYWNfb3BhcXVlX2VuY3Jfa2V5IikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+cGFjX29wYXF1ZV9lbmNyX2tleSk7CisJCWJzcy0+cGFjX29wYXF1ZV9lbmNyX2tleSA9IG9zX21hbGxvYygxNik7CisJCWlmIChic3MtPnBhY19vcGFxdWVfZW5jcl9rZXkgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IE5vIG1lbW9yeSBmb3IgcGFjX29wYXF1ZV9lbmNyX2tleSIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfSBlbHNlIGlmIChoZXhzdHIyYmluKHBvcywgYnNzLT5wYWNfb3BhcXVlX2VuY3Jfa2V5LCAxNikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBwYWNfb3BhcXVlX2VuY3Jfa2V5IiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZWFwX2Zhc3RfYV9pZCIpID09IDApIHsKKwkJc2l6ZV90IGlkbGVuID0gb3Nfc3RybGVuKHBvcyk7CisJCWlmIChpZGxlbiAmIDEpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBlYXBfZmFzdF9hX2lkIiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJCW9zX2ZyZWUoYnNzLT5lYXBfZmFzdF9hX2lkKTsKKwkJYnNzLT5lYXBfZmFzdF9hX2lkID0gb3NfbWFsbG9jKGlkbGVuIC8gMik7CisJCWlmIChic3MtPmVhcF9mYXN0X2FfaWQgPT0gTlVMTCB8fAorCQkgICAgaGV4c3RyMmJpbihwb3MsIGJzcy0+ZWFwX2Zhc3RfYV9pZCwgaWRsZW4gLyAyKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBGYWlsZWQgdG8gcGFyc2UgZWFwX2Zhc3RfYV9pZCIsCisJCQkJICAgbGluZSk7CisJCQlvc19mcmVlKGJzcy0+ZWFwX2Zhc3RfYV9pZCk7CisJCQlic3MtPmVhcF9mYXN0X2FfaWQgPSBOVUxMOworCQkJcmV0dXJuIDE7CisJCX0gZWxzZSB7CisJCQlic3MtPmVhcF9mYXN0X2FfaWRfbGVuID0gaWRsZW4gLyAyOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZWFwX2Zhc3RfYV9pZF9pbmZvIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+ZWFwX2Zhc3RfYV9pZF9pbmZvKTsKKwkJYnNzLT5lYXBfZmFzdF9hX2lkX2luZm8gPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfZmFzdF9wcm92IikgPT0gMCkgeworCQlic3MtPmVhcF9mYXN0X3Byb3YgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicGFjX2tleV9saWZldGltZSIpID09IDApIHsKKwkJYnNzLT5wYWNfa2V5X2xpZmV0aW1lID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBhY19rZXlfcmVmcmVzaF90aW1lIikgPT0gMCkgeworCQlic3MtPnBhY19rZXlfcmVmcmVzaF90aW1lID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIEVBUF9TRVJWRVJfRkFTVCAqLwogI2lmZGVmIEVBUF9TRVJWRVJfU0lNCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcF9zaW1fZGIiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+ZWFwX3NpbV9kYik7Ci0JCQlic3MtPmVhcF9zaW1fZGIgPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZWFwX3NpbV9ha2FfcmVzdWx0X2luZCIpID09IDApIHsKLQkJCWJzcy0+ZWFwX3NpbV9ha2FfcmVzdWx0X2luZCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfc2ltX2RiIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+ZWFwX3NpbV9kYik7CisJCWJzcy0+ZWFwX3NpbV9kYiA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcF9zaW1fYWthX3Jlc3VsdF9pbmQiKSA9PSAwKSB7CisJCWJzcy0+ZWFwX3NpbV9ha2FfcmVzdWx0X2luZCA9IGF0b2kocG9zKTsKICNlbmRpZiAvKiBFQVBfU0VSVkVSX1NJTSAqLwogI2lmZGVmIEVBUF9TRVJWRVJfVE5DCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRuYyIpID09IDApIHsKLQkJCWJzcy0+dG5jID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRuYyIpID09IDApIHsKKwkJYnNzLT50bmMgPSBhdG9pKHBvcyk7CiAjZW5kaWYgLyogRUFQX1NFUlZFUl9UTkMgKi8KICNpZmRlZiBFQVBfU0VSVkVSX1BXRAotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwd2RfZ3JvdXAiKSA9PSAwKSB7Ci0JCQlic3MtPnB3ZF9ncm91cCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwd2RfZ3JvdXAiKSA9PSAwKSB7CisJCWJzcy0+cHdkX2dyb3VwID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIEVBUF9TRVJWRVJfUFdEICovCiAjZW5kaWYgLyogRUFQX1NFUlZFUiAqLwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfbWVzc2FnZSIpID09IDApIHsKLQkJCWNoYXIgKnRlcm07Ci0JCQlic3MtPmVhcF9yZXFfaWRfdGV4dCA9IG9zX3N0cmR1cChwb3MpOwotCQkJaWYgKGJzcy0+ZWFwX3JlcV9pZF90ZXh0ID09IE5VTEwpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEZhaWxlZCB0byAiCi0JCQkJCSAgICJhbGxvY2F0ZSBtZW1vcnkgZm9yICIKLQkJCQkJICAgImVhcF9yZXFfaWRfdGV4dCIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9Ci0JCQlic3MtPmVhcF9yZXFfaWRfdGV4dF9sZW4gPQotCQkJCW9zX3N0cmxlbihic3MtPmVhcF9yZXFfaWRfdGV4dCk7Ci0JCQl0ZXJtID0gb3Nfc3Ryc3RyKGJzcy0+ZWFwX3JlcV9pZF90ZXh0LCAiXFwwIik7Ci0JCQlpZiAodGVybSkgewotCQkJCSp0ZXJtKysgPSAnXDAnOwotCQkJCW9zX21lbW1vdmUodGVybSwgdGVybSArIDEsCi0JCQkJCSAgIGJzcy0+ZWFwX3JlcV9pZF90ZXh0X2xlbiAtCi0JCQkJCSAgICh0ZXJtIC0gYnNzLT5lYXBfcmVxX2lkX3RleHQpIC0gMSk7Ci0JCQkJYnNzLT5lYXBfcmVxX2lkX3RleHRfbGVuLS07Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndlcF9rZXlfbGVuX2Jyb2FkY2FzdCIpID09IDApIHsKLQkJCWJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiA9IGF0b2kocG9zKTsKLQkJCWlmIChic3MtPmRlZmF1bHRfd2VwX2tleV9sZW4gPiAxMykgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBXRVAgIgotCQkJCQkgICAia2V5IGxlbiAlbHUgKD0gJWx1IGJpdHMpIiwgbGluZSwKLQkJCQkJICAgKHVuc2lnbmVkIGxvbmcpCi0JCQkJCSAgIGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiwKLQkJCQkJICAgKHVuc2lnbmVkIGxvbmcpCi0JCQkJCSAgIGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiAqIDgpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5X2xlbl91bmljYXN0IikgPT0gMCkgewotCQkJYnNzLT5pbmRpdmlkdWFsX3dlcF9rZXlfbGVuID0gYXRvaShwb3MpOwotCQkJaWYgKGJzcy0+aW5kaXZpZHVhbF93ZXBfa2V5X2xlbiA8IDAgfHwKLQkJCSAgICBic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPiAxMykgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBXRVAgIgotCQkJCQkgICAia2V5IGxlbiAlZCAoPSAlZCBiaXRzKSIsIGxpbmUsCi0JCQkJCSAgIGJzcy0+aW5kaXZpZHVhbF93ZXBfa2V5X2xlbiwKLQkJCQkJICAgYnNzLT5pbmRpdmlkdWFsX3dlcF9rZXlfbGVuICogOCk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndlcF9yZWtleV9wZXJpb2QiKSA9PSAwKSB7Ci0JCQlic3MtPndlcF9yZWtleWluZ19wZXJpb2QgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT53ZXBfcmVrZXlpbmdfcGVyaW9kIDwgMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCi0JCQkJCSAgICJwZXJpb2QgJWQiLAotCQkJCQkgICBsaW5lLCBic3MtPndlcF9yZWtleWluZ19wZXJpb2QpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfcmVhdXRoX3BlcmlvZCIpID09IDApIHsKLQkJCWJzcy0+ZWFwX3JlYXV0aF9wZXJpb2QgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT5lYXBfcmVhdXRoX3BlcmlvZCA8IDApIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAicGVyaW9kICVkIiwKLQkJCQkJICAgbGluZSwgYnNzLT5lYXBfcmVhdXRoX3BlcmlvZCk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcG9sX2tleV9pbmRleF93b3JrYXJvdW5kIikgPT0gMCkgewotCQkJYnNzLT5lYXBvbF9rZXlfaW5kZXhfd29ya2Fyb3VuZCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBfbWVzc2FnZSIpID09IDApIHsKKwkJY2hhciAqdGVybTsKKwkJb3NfZnJlZShic3MtPmVhcF9yZXFfaWRfdGV4dCk7CisJCWJzcy0+ZWFwX3JlcV9pZF90ZXh0ID0gb3Nfc3RyZHVwKHBvcyk7CisJCWlmIChic3MtPmVhcF9yZXFfaWRfdGV4dCA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIGVhcF9yZXFfaWRfdGV4dCIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlic3MtPmVhcF9yZXFfaWRfdGV4dF9sZW4gPSBvc19zdHJsZW4oYnNzLT5lYXBfcmVxX2lkX3RleHQpOworCQl0ZXJtID0gb3Nfc3Ryc3RyKGJzcy0+ZWFwX3JlcV9pZF90ZXh0LCAiXFwwIik7CisJCWlmICh0ZXJtKSB7CisJCQkqdGVybSsrID0gJ1wwJzsKKwkJCW9zX21lbW1vdmUodGVybSwgdGVybSArIDEsCisJCQkJICAgYnNzLT5lYXBfcmVxX2lkX3RleHRfbGVuIC0KKwkJCQkgICAodGVybSAtIGJzcy0+ZWFwX3JlcV9pZF90ZXh0KSAtIDEpOworCQkJYnNzLT5lYXBfcmVxX2lkX3RleHRfbGVuLS07CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5X2xlbl9icm9hZGNhc3QiKSA9PSAwKSB7CisJCWJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiA9IGF0b2kocG9zKTsKKwkJaWYgKGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiA+IDEzKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgV0VQIGtleSBsZW4gJWx1ICg9ICVsdSBiaXRzKSIsCisJCQkJICAgbGluZSwKKwkJCQkgICAodW5zaWduZWQgbG9uZykgYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuLAorCQkJCSAgICh1bnNpZ25lZCBsb25nKQorCQkJCSAgIGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiAqIDgpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5X2xlbl91bmljYXN0IikgPT0gMCkgeworCQlic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPSBhdG9pKHBvcyk7CisJCWlmIChic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPCAwIHx8CisJCSAgICBic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPiAxMykgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIFdFUCBrZXkgbGVuICVkICg9ICVkIGJpdHMpIiwKKwkJCQkgICBsaW5lLCBic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4sCisJCQkJICAgYnNzLT5pbmRpdmlkdWFsX3dlcF9rZXlfbGVuICogOCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndlcF9yZWtleV9wZXJpb2QiKSA9PSAwKSB7CisJCWJzcy0+d2VwX3Jla2V5aW5nX3BlcmlvZCA9IGF0b2kocG9zKTsKKwkJaWYgKGJzcy0+d2VwX3Jla2V5aW5nX3BlcmlvZCA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBwZXJpb2QgJWQiLAorCQkJCSAgIGxpbmUsIGJzcy0+d2VwX3Jla2V5aW5nX3BlcmlvZCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImVhcF9yZWF1dGhfcGVyaW9kIikgPT0gMCkgeworCQlic3MtPmVhcF9yZWF1dGhfcGVyaW9kID0gYXRvaShwb3MpOworCQlpZiAoYnNzLT5lYXBfcmVhdXRoX3BlcmlvZCA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBwZXJpb2QgJWQiLAorCQkJCSAgIGxpbmUsIGJzcy0+ZWFwX3JlYXV0aF9wZXJpb2QpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlYXBvbF9rZXlfaW5kZXhfd29ya2Fyb3VuZCIpID09IDApIHsKKwkJYnNzLT5lYXBvbF9rZXlfaW5kZXhfd29ya2Fyb3VuZCA9IGF0b2kocG9zKTsKICNpZmRlZiBDT05GSUdfSUFQUAotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJpYXBwX2ludGVyZmFjZSIpID09IDApIHsKLQkJCWJzcy0+aWVlZTgwMl8xMWYgPSAxOwotCQkJb3Nfc3RybGNweShic3MtPmlhcHBfaWZhY2UsIHBvcywKLQkJCQkgICBzaXplb2YoYnNzLT5pYXBwX2lmYWNlKSk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaWFwcF9pbnRlcmZhY2UiKSA9PSAwKSB7CisJCWJzcy0+aWVlZTgwMl8xMWYgPSAxOworCQlvc19zdHJsY3B5KGJzcy0+aWFwcF9pZmFjZSwgcG9zLCBzaXplb2YoYnNzLT5pYXBwX2lmYWNlKSk7CiAjZW5kaWYgLyogQ09ORklHX0lBUFAgKi8KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAib3duX2lwX2FkZHIiKSA9PSAwKSB7Ci0JCQlpZiAoaG9zdGFwZF9wYXJzZV9pcF9hZGRyKHBvcywgJmJzcy0+b3duX2lwX2FkZHIpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIElQICIKLQkJCQkJICAgImFkZHJlc3MgJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm5hc19pZGVudGlmaWVyIikgPT0gMCkgewotCQkJYnNzLT5uYXNfaWRlbnRpZmllciA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm93bl9pcF9hZGRyIikgPT0gMCkgeworCQlpZiAoaG9zdGFwZF9wYXJzZV9pcF9hZGRyKHBvcywgJmJzcy0+b3duX2lwX2FkZHIpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiTGluZSAlZDogaW52YWxpZCBJUCBhZGRyZXNzICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm5hc19pZGVudGlmaWVyIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+bmFzX2lkZW50aWZpZXIpOworCQlic3MtPm5hc19pZGVudGlmaWVyID0gb3Nfc3RyZHVwKHBvcyk7CiAjaWZuZGVmIENPTkZJR19OT19SQURJVVMKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXV0aF9zZXJ2ZXJfYWRkciIpID09IDApIHsKLQkJCWlmIChob3N0YXBkX2NvbmZpZ19yZWFkX3JhZGl1c19hZGRyKAotCQkJCSAgICAmYnNzLT5yYWRpdXMtPmF1dGhfc2VydmVycywKLQkJCQkgICAgJmJzcy0+cmFkaXVzLT5udW1fYXV0aF9zZXJ2ZXJzLCBwb3MsIDE4MTIsCi0JCQkJICAgICZic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXIpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIElQICIKLQkJCQkJICAgImFkZHJlc3MgJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAoYnNzLT5yYWRpdXMtPmF1dGhfc2VydmVyICYmCi0JCQkgICBvc19zdHJjbXAoYnVmLCAiYXV0aF9zZXJ2ZXJfcG9ydCIpID09IDApIHsKLQkJCWJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlci0+cG9ydCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXIgJiYKLQkJCSAgIG9zX3N0cmNtcChidWYsICJhdXRoX3NlcnZlcl9zaGFyZWRfc2VjcmV0IikgPT0gMCkgewotCQkJaW50IGxlbiA9IG9zX3N0cmxlbihwb3MpOwotCQkJaWYgKGxlbiA9PSAwKSB7Ci0JCQkJLyogUkZDIDI4NjUsIENoLiAzICovCi0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBlbXB0eSBzaGFyZWQgIgotCQkJCQkgICAic2VjcmV0IGlzIG5vdCBhbGxvd2VkLiIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQkJYnNzLT5yYWRpdXMtPmF1dGhfc2VydmVyLT5zaGFyZWRfc2VjcmV0ID0KLQkJCQkodTggKikgb3Nfc3RyZHVwKHBvcyk7Ci0JCQlic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXItPnNoYXJlZF9zZWNyZXRfbGVuID0gbGVuOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhY2N0X3NlcnZlcl9hZGRyIikgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfY29uZmlnX3JlYWRfcmFkaXVzX2FkZHIoCi0JCQkJICAgICZic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXJzLAotCQkJCSAgICAmYnNzLT5yYWRpdXMtPm51bV9hY2N0X3NlcnZlcnMsIHBvcywgMTgxMywKLQkJCQkgICAgJmJzcy0+cmFkaXVzLT5hY2N0X3NlcnZlcikpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgSVAgIgotCQkJCQkgICAiYWRkcmVzcyAnJXMnIiwgbGluZSwgcG9zKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXIgJiYKLQkJCSAgIG9zX3N0cmNtcChidWYsICJhY2N0X3NlcnZlcl9wb3J0IikgPT0gMCkgewotCQkJYnNzLT5yYWRpdXMtPmFjY3Rfc2VydmVyLT5wb3J0ID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKGJzcy0+cmFkaXVzLT5hY2N0X3NlcnZlciAmJgotCQkJICAgb3Nfc3RyY21wKGJ1ZiwgImFjY3Rfc2VydmVyX3NoYXJlZF9zZWNyZXQiKSA9PSAwKSB7Ci0JCQlpbnQgbGVuID0gb3Nfc3RybGVuKHBvcyk7Ci0JCQlpZiAobGVuID09IDApIHsKLQkJCQkvKiBSRkMgMjg2NSwgQ2guIDMgKi8KLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGVtcHR5IHNoYXJlZCAiCi0JCQkJCSAgICJzZWNyZXQgaXMgbm90IGFsbG93ZWQuIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCQlic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXItPnNoYXJlZF9zZWNyZXQgPQotCQkJCSh1OCAqKSBvc19zdHJkdXAocG9zKTsKLQkJCWJzcy0+cmFkaXVzLT5hY2N0X3NlcnZlci0+c2hhcmVkX3NlY3JldF9sZW4gPSBsZW47Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19yZXRyeV9wcmltYXJ5X2ludGVydmFsIikgPT0KLQkJCSAgIDApIHsKLQkJCWJzcy0+cmFkaXVzLT5yZXRyeV9wcmltYXJ5X2ludGVydmFsID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfYWNjdF9pbnRlcmltX2ludGVydmFsIikgPT0gMCkKLQkJewotCQkJYnNzLT5hY2N0X2ludGVyaW1faW50ZXJ2YWwgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19yZXF1ZXN0X2N1aSIpID09IDApIHsKLQkJCWJzcy0+cmFkaXVzX3JlcXVlc3RfY3VpID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfYXV0aF9yZXFfYXR0ciIpID09IDApIHsKLQkJCXN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICphdHRyLCAqYTsKLQkJCWF0dHIgPSBob3N0YXBkX3BhcnNlX3JhZGl1c19hdHRyKHBvcyk7Ci0JCQlpZiAoYXR0ciA9PSBOVUxMKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKLQkJCQkJICAgInJhZGl1c19hdXRoX3JlcV9hdHRyIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9IGVsc2UgaWYgKGJzcy0+cmFkaXVzX2F1dGhfcmVxX2F0dHIgPT0gTlVMTCkgewotCQkJCWJzcy0+cmFkaXVzX2F1dGhfcmVxX2F0dHIgPSBhdHRyOwotCQkJfSBlbHNlIHsKLQkJCQlhID0gYnNzLT5yYWRpdXNfYXV0aF9yZXFfYXR0cjsKLQkJCQl3aGlsZSAoYS0+bmV4dCkKLQkJCQkJYSA9IGEtPm5leHQ7Ci0JCQkJYS0+bmV4dCA9IGF0dHI7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19hY2N0X3JlcV9hdHRyIikgPT0gMCkgewotCQkJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmF0dHIsICphOwotCQkJYXR0ciA9IGhvc3RhcGRfcGFyc2VfcmFkaXVzX2F0dHIocG9zKTsKLQkJCWlmIChhdHRyID09IE5VTEwpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAicmFkaXVzX2FjY3RfcmVxX2F0dHIiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0gZWxzZSBpZiAoYnNzLT5yYWRpdXNfYWNjdF9yZXFfYXR0ciA9PSBOVUxMKSB7Ci0JCQkJYnNzLT5yYWRpdXNfYWNjdF9yZXFfYXR0ciA9IGF0dHI7Ci0JCQl9IGVsc2UgewotCQkJCWEgPSBic3MtPnJhZGl1c19hY2N0X3JlcV9hdHRyOwotCQkJCXdoaWxlIChhLT5uZXh0KQotCQkJCQlhID0gYS0+bmV4dDsKLQkJCQlhLT5uZXh0ID0gYXR0cjsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2Rhc19wb3J0IikgPT0gMCkgewotCQkJYnNzLT5yYWRpdXNfZGFzX3BvcnQgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19kYXNfY2xpZW50IikgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfcGFyc2VfZGFzX2NsaWVudChic3MsIHBvcykgPCAwKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKLQkJCQkJICAgIkRBUyBjbGllbnQiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2Rhc190aW1lX3dpbmRvdyIpID09IDApIHsKLQkJCWJzcy0+cmFkaXVzX2Rhc190aW1lX3dpbmRvdyA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2Rhc19yZXF1aXJlX2V2ZW50X3RpbWVzdGFtcCIpCi0JCQkgICA9PSAwKSB7Ci0JCQlic3MtPnJhZGl1c19kYXNfcmVxdWlyZV9ldmVudF90aW1lc3RhbXAgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXV0aF9zZXJ2ZXJfYWRkciIpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY29uZmlnX3JlYWRfcmFkaXVzX2FkZHIoCisJCQkgICAgJmJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlcnMsCisJCQkgICAgJmJzcy0+cmFkaXVzLT5udW1fYXV0aF9zZXJ2ZXJzLCBwb3MsIDE4MTIsCisJCQkgICAgJmJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlcikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJMaW5lICVkOiBpbnZhbGlkIElQIGFkZHJlc3MgJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXIgJiYKKwkJICAgb3Nfc3RyY21wKGJ1ZiwgImF1dGhfc2VydmVyX3BvcnQiKSA9PSAwKSB7CisJCWJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlci0+cG9ydCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKGJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlciAmJgorCQkgICBvc19zdHJjbXAoYnVmLCAiYXV0aF9zZXJ2ZXJfc2hhcmVkX3NlY3JldCIpID09IDApIHsKKwkJaW50IGxlbiA9IG9zX3N0cmxlbihwb3MpOworCQlpZiAobGVuID09IDApIHsKKwkJCS8qIFJGQyAyODY1LCBDaC4gMyAqLworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBlbXB0eSBzaGFyZWQgc2VjcmV0IGlzIG5vdCBhbGxvd2VkIiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJCW9zX2ZyZWUoYnNzLT5yYWRpdXMtPmF1dGhfc2VydmVyLT5zaGFyZWRfc2VjcmV0KTsKKwkJYnNzLT5yYWRpdXMtPmF1dGhfc2VydmVyLT5zaGFyZWRfc2VjcmV0ID0gKHU4ICopIG9zX3N0cmR1cChwb3MpOworCQlic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXItPnNoYXJlZF9zZWNyZXRfbGVuID0gbGVuOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFjY3Rfc2VydmVyX2FkZHIiKSA9PSAwKSB7CisJCWlmIChob3N0YXBkX2NvbmZpZ19yZWFkX3JhZGl1c19hZGRyKAorCQkJICAgICZic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXJzLAorCQkJICAgICZic3MtPnJhZGl1cy0+bnVtX2FjY3Rfc2VydmVycywgcG9zLCAxODEzLAorCQkJICAgICZic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXIpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiTGluZSAlZDogaW52YWxpZCBJUCBhZGRyZXNzICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAoYnNzLT5yYWRpdXMtPmFjY3Rfc2VydmVyICYmCisJCSAgIG9zX3N0cmNtcChidWYsICJhY2N0X3NlcnZlcl9wb3J0IikgPT0gMCkgeworCQlic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXItPnBvcnQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXIgJiYKKwkJICAgb3Nfc3RyY21wKGJ1ZiwgImFjY3Rfc2VydmVyX3NoYXJlZF9zZWNyZXQiKSA9PSAwKSB7CisJCWludCBsZW4gPSBvc19zdHJsZW4ocG9zKTsKKwkJaWYgKGxlbiA9PSAwKSB7CisJCQkvKiBSRkMgMjg2NSwgQ2guIDMgKi8KKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogZW1wdHkgc2hhcmVkIHNlY3JldCBpcyBub3QgYWxsb3dlZCIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlvc19mcmVlKGJzcy0+cmFkaXVzLT5hY2N0X3NlcnZlci0+c2hhcmVkX3NlY3JldCk7CisJCWJzcy0+cmFkaXVzLT5hY2N0X3NlcnZlci0+c2hhcmVkX3NlY3JldCA9ICh1OCAqKSBvc19zdHJkdXAocG9zKTsKKwkJYnNzLT5yYWRpdXMtPmFjY3Rfc2VydmVyLT5zaGFyZWRfc2VjcmV0X2xlbiA9IGxlbjsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfcmV0cnlfcHJpbWFyeV9pbnRlcnZhbCIpID09IDApIHsKKwkJYnNzLT5yYWRpdXMtPnJldHJ5X3ByaW1hcnlfaW50ZXJ2YWwgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2FjY3RfaW50ZXJpbV9pbnRlcnZhbCIpID09IDApIHsKKwkJYnNzLT5hY2N0X2ludGVyaW1faW50ZXJ2YWwgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX3JlcXVlc3RfY3VpIikgPT0gMCkgeworCQlic3MtPnJhZGl1c19yZXF1ZXN0X2N1aSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfYXV0aF9yZXFfYXR0ciIpID09IDApIHsKKwkJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmF0dHIsICphOworCQlhdHRyID0gaG9zdGFwZF9wYXJzZV9yYWRpdXNfYXR0cihwb3MpOworCQlpZiAoYXR0ciA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiTGluZSAlZDogaW52YWxpZCByYWRpdXNfYXV0aF9yZXFfYXR0ciIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfSBlbHNlIGlmIChic3MtPnJhZGl1c19hdXRoX3JlcV9hdHRyID09IE5VTEwpIHsKKwkJCWJzcy0+cmFkaXVzX2F1dGhfcmVxX2F0dHIgPSBhdHRyOworCQl9IGVsc2UgeworCQkJYSA9IGJzcy0+cmFkaXVzX2F1dGhfcmVxX2F0dHI7CisJCQl3aGlsZSAoYS0+bmV4dCkKKwkJCQlhID0gYS0+bmV4dDsKKwkJCWEtPm5leHQgPSBhdHRyOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2FjY3RfcmVxX2F0dHIiKSA9PSAwKSB7CisJCXN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICphdHRyLCAqYTsKKwkJYXR0ciA9IGhvc3RhcGRfcGFyc2VfcmFkaXVzX2F0dHIocG9zKTsKKwkJaWYgKGF0dHIgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IGludmFsaWQgcmFkaXVzX2FjY3RfcmVxX2F0dHIiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0gZWxzZSBpZiAoYnNzLT5yYWRpdXNfYWNjdF9yZXFfYXR0ciA9PSBOVUxMKSB7CisJCQlic3MtPnJhZGl1c19hY2N0X3JlcV9hdHRyID0gYXR0cjsKKwkJfSBlbHNlIHsKKwkJCWEgPSBic3MtPnJhZGl1c19hY2N0X3JlcV9hdHRyOworCQkJd2hpbGUgKGEtPm5leHQpCisJCQkJYSA9IGEtPm5leHQ7CisJCQlhLT5uZXh0ID0gYXR0cjsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19kYXNfcG9ydCIpID09IDApIHsKKwkJYnNzLT5yYWRpdXNfZGFzX3BvcnQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2Rhc19jbGllbnQiKSA9PSAwKSB7CisJCWlmIChob3N0YXBkX3BhcnNlX2Rhc19jbGllbnQoYnNzLCBwb3MpIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIERBUyBjbGllbnQiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfZGFzX3RpbWVfd2luZG93IikgPT0gMCkgeworCQlic3MtPnJhZGl1c19kYXNfdGltZV93aW5kb3cgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2Rhc19yZXF1aXJlX2V2ZW50X3RpbWVzdGFtcCIpID09IDApIHsKKwkJYnNzLT5yYWRpdXNfZGFzX3JlcXVpcmVfZXZlbnRfdGltZXN0YW1wID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIENPTkZJR19OT19SQURJVVMgKi8KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXV0aF9hbGdzIikgPT0gMCkgewotCQkJYnNzLT5hdXRoX2FsZ3MgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT5hdXRoX2FsZ3MgPT0gMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogbm8gIgotCQkJCQkgICAiYXV0aGVudGljYXRpb24gYWxnb3JpdGhtcyBhbGxvd2VkIiwKLQkJCQkJICAgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm1heF9udW1fc3RhIikgPT0gMCkgewotCQkJYnNzLT5tYXhfbnVtX3N0YSA9IGF0b2kocG9zKTsKLQkJCWlmIChic3MtPm1heF9udW1fc3RhIDwgMCB8fAotCQkJICAgIGJzcy0+bWF4X251bV9zdGEgPiBNQVhfU1RBX0NPVU5UKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkICIKLQkJCQkJICAgIm1heF9udW1fc3RhPSVkOyBhbGxvd2VkIHJhbmdlICIKLQkJCQkJICAgIjAuLiVkIiwgbGluZSwgYnNzLT5tYXhfbnVtX3N0YSwKLQkJCQkJICAgTUFYX1NUQV9DT1VOVCk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYSIpID09IDApIHsKLQkJCWJzcy0+d3BhID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cGFfZ3JvdXBfcmVrZXkiKSA9PSAwKSB7Ci0JCQlic3MtPndwYV9ncm91cF9yZWtleSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX3N0cmljdF9yZWtleSIpID09IDApIHsKLQkJCWJzcy0+d3BhX3N0cmljdF9yZWtleSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX2dta19yZWtleSIpID09IDApIHsKLQkJCWJzcy0+d3BhX2dta19yZWtleSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX3B0a19yZWtleSIpID09IDApIHsKLQkJCWJzcy0+d3BhX3B0a19yZWtleSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX3Bhc3NwaHJhc2UiKSA9PSAwKSB7Ci0JCQlpbnQgbGVuID0gb3Nfc3RybGVuKHBvcyk7Ci0JCQlpZiAobGVuIDwgOCB8fCBsZW4gPiA2MykgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBXUEEgIgotCQkJCQkgICAicGFzc3BocmFzZSBsZW5ndGggJWQgKGV4cGVjdGVkICIKLQkJCQkJICAgIjguLjYzKSIsIGxpbmUsIGxlbik7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9IGVsc2UgewotCQkJCW9zX2ZyZWUoYnNzLT5zc2lkLndwYV9wYXNzcGhyYXNlKTsKLQkJCQlic3MtPnNzaWQud3BhX3Bhc3NwaHJhc2UgPSBvc19zdHJkdXAocG9zKTsKLQkJCQlvc19mcmVlKGJzcy0+c3NpZC53cGFfcHNrKTsKLQkJCQlic3MtPnNzaWQud3BhX3BzayA9IE5VTEw7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYV9wc2siKSA9PSAwKSB7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXV0aF9hbGdzIikgPT0gMCkgeworCQlic3MtPmF1dGhfYWxncyA9IGF0b2kocG9zKTsKKwkJaWYgKGJzcy0+YXV0aF9hbGdzID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogbm8gYXV0aGVudGljYXRpb24gYWxnb3JpdGhtcyBhbGxvd2VkIiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWF4X251bV9zdGEiKSA9PSAwKSB7CisJCWJzcy0+bWF4X251bV9zdGEgPSBhdG9pKHBvcyk7CisJCWlmIChic3MtPm1heF9udW1fc3RhIDwgMCB8fAorCQkgICAgYnNzLT5tYXhfbnVtX3N0YSA+IE1BWF9TVEFfQ09VTlQpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBtYXhfbnVtX3N0YT0lZDsgYWxsb3dlZCByYW5nZSAwLi4lZCIsCisJCQkJICAgbGluZSwgYnNzLT5tYXhfbnVtX3N0YSwgTUFYX1NUQV9DT1VOVCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYSIpID09IDApIHsKKwkJYnNzLT53cGEgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX2dyb3VwX3Jla2V5IikgPT0gMCkgeworCQlic3MtPndwYV9ncm91cF9yZWtleSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cGFfc3RyaWN0X3Jla2V5IikgPT0gMCkgeworCQlic3MtPndwYV9zdHJpY3RfcmVrZXkgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX2dta19yZWtleSIpID09IDApIHsKKwkJYnNzLT53cGFfZ21rX3Jla2V5ID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYV9wdGtfcmVrZXkiKSA9PSAwKSB7CisJCWJzcy0+d3BhX3B0a19yZWtleSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cGFfcGFzc3BocmFzZSIpID09IDApIHsKKwkJaW50IGxlbiA9IG9zX3N0cmxlbihwb3MpOworCQlpZiAobGVuIDwgOCB8fCBsZW4gPiA2MykgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIFdQQSBwYXNzcGhyYXNlIGxlbmd0aCAlZCAoZXhwZWN0ZWQgOC4uNjMpIiwKKwkJCQkgICBsaW5lLCBsZW4pOworCQkJcmV0dXJuIDE7CisJCX0KKwkJb3NfZnJlZShic3MtPnNzaWQud3BhX3Bhc3NwaHJhc2UpOworCQlic3MtPnNzaWQud3BhX3Bhc3NwaHJhc2UgPSBvc19zdHJkdXAocG9zKTsKKwkJaWYgKGJzcy0+c3NpZC53cGFfcGFzc3BocmFzZSkgewogCQkJb3NfZnJlZShic3MtPnNzaWQud3BhX3Bzayk7Ci0JCQlic3MtPnNzaWQud3BhX3BzayA9Ci0JCQkJb3NfemFsbG9jKHNpemVvZihzdHJ1Y3QgaG9zdGFwZF93cGFfcHNrKSk7Ci0JCQlpZiAoYnNzLT5zc2lkLndwYV9wc2sgPT0gTlVMTCkKLQkJCQllcnJvcnMrKzsKLQkJCWVsc2UgaWYgKGhleHN0cjJiaW4ocG9zLCBic3MtPnNzaWQud3BhX3Bzay0+cHNrLAotCQkJCQkgICAgUE1LX0xFTikgfHwKLQkJCQkgcG9zW1BNS19MRU4gKiAyXSAhPSAnXDAnKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkIFBTSyAiCi0JCQkJCSAgICInJXMnLiIsIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9IGVsc2UgewotCQkJCWJzcy0+c3NpZC53cGFfcHNrLT5ncm91cCA9IDE7Ci0JCQkJb3NfZnJlZShic3MtPnNzaWQud3BhX3Bhc3NwaHJhc2UpOwotCQkJCWJzcy0+c3NpZC53cGFfcGFzc3BocmFzZSA9IE5VTEw7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYV9wc2tfZmlsZSIpID09IDApIHsKLQkJCW9zX2ZyZWUoYnNzLT5zc2lkLndwYV9wc2tfZmlsZSk7Ci0JCQlic3MtPnNzaWQud3BhX3Bza19maWxlID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCQlpZiAoIWJzcy0+c3NpZC53cGFfcHNrX2ZpbGUpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGFsbG9jYXRpb24gIgotCQkJCQkgICAiZmFpbGVkIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYV9rZXlfbWdtdCIpID09IDApIHsKLQkJCWJzcy0+d3BhX2tleV9tZ210ID0KLQkJCQlob3N0YXBkX2NvbmZpZ19wYXJzZV9rZXlfbWdtdChsaW5lLCBwb3MpOwotCQkJaWYgKGJzcy0+d3BhX2tleV9tZ210ID09IC0xKQotCQkJCWVycm9ycysrOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cGFfcHNrX3JhZGl1cyIpID09IDApIHsKLQkJCWJzcy0+d3BhX3Bza19yYWRpdXMgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT53cGFfcHNrX3JhZGl1cyAhPSBQU0tfUkFESVVTX0lHTk9SRUQgJiYKLQkJCSAgICBic3MtPndwYV9wc2tfcmFkaXVzICE9IFBTS19SQURJVVNfQUNDRVBURUQgJiYKLQkJCSAgICBic3MtPndwYV9wc2tfcmFkaXVzICE9IFBTS19SQURJVVNfUkVRVUlSRUQpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVua25vd24gIgotCQkJCQkgICAid3BhX3Bza19yYWRpdXMgJWQiLAotCQkJCQkgICBsaW5lLCBic3MtPndwYV9wc2tfcmFkaXVzKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX3BhaXJ3aXNlIikgPT0gMCkgewotCQkJYnNzLT53cGFfcGFpcndpc2UgPQotCQkJCWhvc3RhcGRfY29uZmlnX3BhcnNlX2NpcGhlcihsaW5lLCBwb3MpOwotCQkJaWYgKGJzcy0+d3BhX3BhaXJ3aXNlID09IC0xIHx8Ci0JCQkgICAgYnNzLT53cGFfcGFpcndpc2UgPT0gMCkKLQkJCQllcnJvcnMrKzsKLQkJCWVsc2UgaWYgKGJzcy0+d3BhX3BhaXJ3aXNlICYKLQkJCQkgKFdQQV9DSVBIRVJfTk9ORSB8IFdQQV9DSVBIRVJfV0VQNDAgfAotCQkJCSAgV1BBX0NJUEhFUl9XRVAxMDQpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiB1bnN1cHBvcnRlZCAiCi0JCQkJCSAgICJwYWlyd2lzZSBjaXBoZXIgc3VpdGUgJyVzJyIsCi0JCQkJCSAgIGJzcy0+d3BhX3BhaXJ3aXNlLCBwb3MpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyc25fcGFpcndpc2UiKSA9PSAwKSB7Ci0JCQlic3MtPnJzbl9wYWlyd2lzZSA9Ci0JCQkJaG9zdGFwZF9jb25maWdfcGFyc2VfY2lwaGVyKGxpbmUsIHBvcyk7Ci0JCQlpZiAoYnNzLT5yc25fcGFpcndpc2UgPT0gLTEgfHwKLQkJCSAgICBic3MtPnJzbl9wYWlyd2lzZSA9PSAwKQotCQkJCWVycm9ycysrOwotCQkJZWxzZSBpZiAoYnNzLT5yc25fcGFpcndpc2UgJgotCQkJCSAoV1BBX0NJUEhFUl9OT05FIHwgV1BBX0NJUEhFUl9XRVA0MCB8Ci0JCQkJICBXUEFfQ0lQSEVSX1dFUDEwNCkpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVuc3VwcG9ydGVkICIKLQkJCQkJICAgInBhaXJ3aXNlIGNpcGhlciBzdWl0ZSAnJXMnIiwKLQkJCQkJICAgYnNzLT5yc25fcGFpcndpc2UsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9CisJCQlic3MtPnNzaWQud3BhX3BzayA9IE5VTEw7CisJCQlic3MtPnNzaWQud3BhX3Bhc3NwaHJhc2Vfc2V0ID0gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYV9wc2siKSA9PSAwKSB7CisJCW9zX2ZyZWUoYnNzLT5zc2lkLndwYV9wc2spOworCQlic3MtPnNzaWQud3BhX3BzayA9IG9zX3phbGxvYyhzaXplb2Yoc3RydWN0IGhvc3RhcGRfd3BhX3BzaykpOworCQlpZiAoYnNzLT5zc2lkLndwYV9wc2sgPT0gTlVMTCkKKwkJCXJldHVybiAxOworCQlpZiAoaGV4c3RyMmJpbihwb3MsIGJzcy0+c3NpZC53cGFfcHNrLT5wc2ssIFBNS19MRU4pIHx8CisJCSAgICBwb3NbUE1LX0xFTiAqIDJdICE9ICdcMCcpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBQU0sgJyVzJy4iLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlvc19mcmVlKGJzcy0+c3NpZC53cGFfcHNrKTsKKwkJCWJzcy0+c3NpZC53cGFfcHNrID0gTlVMTDsKKwkJCXJldHVybiAxOworCQl9CisJCWJzcy0+c3NpZC53cGFfcHNrLT5ncm91cCA9IDE7CisJCW9zX2ZyZWUoYnNzLT5zc2lkLndwYV9wYXNzcGhyYXNlKTsKKwkJYnNzLT5zc2lkLndwYV9wYXNzcGhyYXNlID0gTlVMTDsKKwkJYnNzLT5zc2lkLndwYV9wc2tfc2V0ID0gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cGFfcHNrX2ZpbGUiKSA9PSAwKSB7CisJCW9zX2ZyZWUoYnNzLT5zc2lkLndwYV9wc2tfZmlsZSk7CisJCWJzcy0+c3NpZC53cGFfcHNrX2ZpbGUgPSBvc19zdHJkdXAocG9zKTsKKwkJaWYgKCFic3MtPnNzaWQud3BhX3Bza19maWxlKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGFsbG9jYXRpb24gZmFpbGVkIiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BhX2tleV9tZ210IikgPT0gMCkgeworCQlic3MtPndwYV9rZXlfbWdtdCA9IGhvc3RhcGRfY29uZmlnX3BhcnNlX2tleV9tZ210KGxpbmUsIHBvcyk7CisJCWlmIChic3MtPndwYV9rZXlfbWdtdCA9PSAtMSkKKwkJCXJldHVybiAxOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYV9wc2tfcmFkaXVzIikgPT0gMCkgeworCQlic3MtPndwYV9wc2tfcmFkaXVzID0gYXRvaShwb3MpOworCQlpZiAoYnNzLT53cGFfcHNrX3JhZGl1cyAhPSBQU0tfUkFESVVTX0lHTk9SRUQgJiYKKwkJICAgIGJzcy0+d3BhX3Bza19yYWRpdXMgIT0gUFNLX1JBRElVU19BQ0NFUFRFRCAmJgorCQkgICAgYnNzLT53cGFfcHNrX3JhZGl1cyAhPSBQU0tfUkFESVVTX1JFUVVJUkVEKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiTGluZSAlZDogdW5rbm93biB3cGFfcHNrX3JhZGl1cyAlZCIsCisJCQkJICAgbGluZSwgYnNzLT53cGFfcHNrX3JhZGl1cyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwYV9wYWlyd2lzZSIpID09IDApIHsKKwkJYnNzLT53cGFfcGFpcndpc2UgPSBob3N0YXBkX2NvbmZpZ19wYXJzZV9jaXBoZXIobGluZSwgcG9zKTsKKwkJaWYgKGJzcy0+d3BhX3BhaXJ3aXNlID09IC0xIHx8IGJzcy0+d3BhX3BhaXJ3aXNlID09IDApCisJCQlyZXR1cm4gMTsKKwkJaWYgKGJzcy0+d3BhX3BhaXJ3aXNlICYKKwkJICAgIChXUEFfQ0lQSEVSX05PTkUgfCBXUEFfQ0lQSEVSX1dFUDQwIHwgV1BBX0NJUEhFUl9XRVAxMDQpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVuc3VwcG9ydGVkIHBhaXJ3aXNlIGNpcGhlciBzdWl0ZSAnJXMnIiwKKwkJCQkgICBic3MtPndwYV9wYWlyd2lzZSwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicnNuX3BhaXJ3aXNlIikgPT0gMCkgeworCQlic3MtPnJzbl9wYWlyd2lzZSA9IGhvc3RhcGRfY29uZmlnX3BhcnNlX2NpcGhlcihsaW5lLCBwb3MpOworCQlpZiAoYnNzLT5yc25fcGFpcndpc2UgPT0gLTEgfHwgYnNzLT5yc25fcGFpcndpc2UgPT0gMCkKKwkJCXJldHVybiAxOworCQlpZiAoYnNzLT5yc25fcGFpcndpc2UgJgorCQkgICAgKFdQQV9DSVBIRVJfTk9ORSB8IFdQQV9DSVBIRVJfV0VQNDAgfCBXUEFfQ0lQSEVSX1dFUDEwNCkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogdW5zdXBwb3J0ZWQgcGFpcndpc2UgY2lwaGVyIHN1aXRlICclcyciLAorCQkJCSAgIGJzcy0+cnNuX3BhaXJ3aXNlLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KICNpZmRlZiBDT05GSUdfUlNOX1BSRUFVVEgKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicnNuX3ByZWF1dGgiKSA9PSAwKSB7Ci0JCQlic3MtPnJzbl9wcmVhdXRoID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyc25fcHJlYXV0aF9pbnRlcmZhY2VzIikgPT0gMCkgewotCQkJYnNzLT5yc25fcHJlYXV0aF9pbnRlcmZhY2VzID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicnNuX3ByZWF1dGgiKSA9PSAwKSB7CisJCWJzcy0+cnNuX3ByZWF1dGggPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicnNuX3ByZWF1dGhfaW50ZXJmYWNlcyIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPnJzbl9wcmVhdXRoX2ludGVyZmFjZXMpOworCQlic3MtPnJzbl9wcmVhdXRoX2ludGVyZmFjZXMgPSBvc19zdHJkdXAocG9zKTsKICNlbmRpZiAvKiBDT05GSUdfUlNOX1BSRUFVVEggKi8KICNpZmRlZiBDT05GSUdfUEVFUktFWQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwZWVya2V5IikgPT0gMCkgewotCQkJYnNzLT5wZWVya2V5ID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBlZXJrZXkiKSA9PSAwKSB7CisJCWJzcy0+cGVlcmtleSA9IGF0b2kocG9zKTsKICNlbmRpZiAvKiBDT05GSUdfUEVFUktFWSAqLwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm1vYmlsaXR5X2RvbWFpbiIpID09IDApIHsKLQkJCWlmIChvc19zdHJsZW4ocG9zKSAhPSAyICogTU9CSUxJVFlfRE9NQUlOX0lEX0xFTiB8fAotCQkJICAgIGhleHN0cjJiaW4ocG9zLCBic3MtPm1vYmlsaXR5X2RvbWFpbiwKLQkJCQkgICAgICAgTU9CSUxJVFlfRE9NQUlOX0lEX0xFTikgIT0gMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJtb2JpbGl0eV9kb21haW4gJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQkJcmV0dXJuIGVycm9yczsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicjFfa2V5X2hvbGRlciIpID09IDApIHsKLQkJCWlmIChvc19zdHJsZW4ocG9zKSAhPSAyICogRlRfUjFLSF9JRF9MRU4gfHwKLQkJCSAgICBoZXhzdHIyYmluKHBvcywgYnNzLT5yMV9rZXlfaG9sZGVyLAotCQkJCSAgICAgICBGVF9SMUtIX0lEX0xFTikgIT0gMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJyMV9rZXlfaG9sZGVyICclcyciLCBsaW5lLCBwb3MpOwotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInIwX2tleV9saWZldGltZSIpID09IDApIHsKLQkJCWJzcy0+cjBfa2V5X2xpZmV0aW1lID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyZWFzc29jaWF0aW9uX2RlYWRsaW5lIikgPT0gMCkgewotCQkJYnNzLT5yZWFzc29jaWF0aW9uX2RlYWRsaW5lID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyMGtoIikgPT0gMCkgewotCQkJaWYgKGFkZF9yMGtoKGJzcywgcG9zKSA8IDApIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkxpbmUgJWQ6IEludmFsaWQgIgotCQkJCQkgICAicjBraCAnJXMnIiwgbGluZSwgcG9zKTsKLQkJCQllcnJvcnMrKzsKLQkJCQlyZXR1cm4gZXJyb3JzOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyMWtoIikgPT0gMCkgewotCQkJaWYgKGFkZF9yMWtoKGJzcywgcG9zKSA8IDApIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkxpbmUgJWQ6IEludmFsaWQgIgotCQkJCQkgICAicjFraCAnJXMnIiwgbGluZSwgcG9zKTsKLQkJCQllcnJvcnMrKzsKLQkJCQlyZXR1cm4gZXJyb3JzOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwbWtfcjFfcHVzaCIpID09IDApIHsKLQkJCWJzcy0+cG1rX3IxX3B1c2ggPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImZ0X292ZXJfZHMiKSA9PSAwKSB7Ci0JCQlic3MtPmZ0X292ZXJfZHMgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibW9iaWxpdHlfZG9tYWluIikgPT0gMCkgeworCQlpZiAob3Nfc3RybGVuKHBvcykgIT0gMiAqIE1PQklMSVRZX0RPTUFJTl9JRF9MRU4gfHwKKwkJICAgIGhleHN0cjJiaW4ocG9zLCBic3MtPm1vYmlsaXR5X2RvbWFpbiwKKwkJCSAgICAgICBNT0JJTElUWV9ET01BSU5fSURfTEVOKSAhPSAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiTGluZSAlZDogSW52YWxpZCBtb2JpbGl0eV9kb21haW4gJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicjFfa2V5X2hvbGRlciIpID09IDApIHsKKwkJaWYgKG9zX3N0cmxlbihwb3MpICE9IDIgKiBGVF9SMUtIX0lEX0xFTiB8fAorCQkgICAgaGV4c3RyMmJpbihwb3MsIGJzcy0+cjFfa2V5X2hvbGRlciwgRlRfUjFLSF9JRF9MRU4pICE9IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJMaW5lICVkOiBJbnZhbGlkIHIxX2tleV9ob2xkZXIgJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicjBfa2V5X2xpZmV0aW1lIikgPT0gMCkgeworCQlic3MtPnIwX2tleV9saWZldGltZSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyZWFzc29jaWF0aW9uX2RlYWRsaW5lIikgPT0gMCkgeworCQlic3MtPnJlYXNzb2NpYXRpb25fZGVhZGxpbmUgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicjBraCIpID09IDApIHsKKwkJaWYgKGFkZF9yMGtoKGJzcywgcG9zKSA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogSW52YWxpZCByMGtoICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInIxa2giKSA9PSAwKSB7CisJCWlmIChhZGRfcjFraChic3MsIHBvcykgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkxpbmUgJWQ6IEludmFsaWQgcjFraCAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwbWtfcjFfcHVzaCIpID09IDApIHsKKwkJYnNzLT5wbWtfcjFfcHVzaCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJmdF9vdmVyX2RzIikgPT0gMCkgeworCQlic3MtPmZ0X292ZXJfZHMgPSBhdG9pKHBvcyk7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KICNpZm5kZWYgQ09ORklHX05PX0NUUkxfSUZBQ0UKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiY3RybF9pbnRlcmZhY2UiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+Y3RybF9pbnRlcmZhY2UpOwotCQkJYnNzLT5jdHJsX2ludGVyZmFjZSA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJjdHJsX2ludGVyZmFjZV9ncm91cCIpID09IDApIHsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJjdHJsX2ludGVyZmFjZSIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPmN0cmxfaW50ZXJmYWNlKTsKKwkJYnNzLT5jdHJsX2ludGVyZmFjZSA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImN0cmxfaW50ZXJmYWNlX2dyb3VwIikgPT0gMCkgewogI2lmbmRlZiBDT05GSUdfTkFUSVZFX1dJTkRPV1MKLQkJCXN0cnVjdCBncm91cCAqZ3JwOwotCQkJY2hhciAqZW5kcDsKLQkJCWNvbnN0IGNoYXIgKmdyb3VwID0gcG9zOworCQlzdHJ1Y3QgZ3JvdXAgKmdycDsKKwkJY2hhciAqZW5kcDsKKwkJY29uc3QgY2hhciAqZ3JvdXAgPSBwb3M7CiAKLQkJCWdycCA9IGdldGdybmFtKGdyb3VwKTsKLQkJCWlmIChncnApIHsKLQkJCQlic3MtPmN0cmxfaW50ZXJmYWNlX2dpZCA9IGdycC0+Z3JfZ2lkOwotCQkJCWJzcy0+Y3RybF9pbnRlcmZhY2VfZ2lkX3NldCA9IDE7Ci0JCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJjdHJsX2ludGVyZmFjZV9ncm91cD0lZCIKLQkJCQkJICAgIiAoZnJvbSBncm91cCBuYW1lICclcycpIiwKLQkJCQkJICAgYnNzLT5jdHJsX2ludGVyZmFjZV9naWQsIGdyb3VwKTsKLQkJCQlyZXR1cm4gZXJyb3JzOwotCQkJfQotCi0JCQkvKiBHcm91cCBuYW1lIG5vdCBmb3VuZCAtIHRyeSB0byBwYXJzZSB0aGlzIGFzIGdpZCAqLwotCQkJYnNzLT5jdHJsX2ludGVyZmFjZV9naWQgPSBzdHJ0b2woZ3JvdXAsICZlbmRwLCAxMCk7Ci0JCQlpZiAoKmdyb3VwID09ICdcMCcgfHwgKmVuZHAgIT0gJ1wwJykgewotCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogSW52YWxpZCBncm91cCAiCi0JCQkJCSAgICInJXMnIiwgbGluZSwgZ3JvdXApOwotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9CisJCWdycCA9IGdldGdybmFtKGdyb3VwKTsKKwkJaWYgKGdycCkgeworCQkJYnNzLT5jdHJsX2ludGVyZmFjZV9naWQgPSBncnAtPmdyX2dpZDsKIAkJCWJzcy0+Y3RybF9pbnRlcmZhY2VfZ2lkX3NldCA9IDE7Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImN0cmxfaW50ZXJmYWNlX2dyb3VwPSVkIiwKLQkJCQkgICBic3MtPmN0cmxfaW50ZXJmYWNlX2dpZCk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImN0cmxfaW50ZXJmYWNlX2dyb3VwPSVkIChmcm9tIGdyb3VwIG5hbWUgJyVzJykiLAorCQkJCSAgIGJzcy0+Y3RybF9pbnRlcmZhY2VfZ2lkLCBncm91cCk7CisJCQlyZXR1cm4gMDsKKwkJfQorCisJCS8qIEdyb3VwIG5hbWUgbm90IGZvdW5kIC0gdHJ5IHRvIHBhcnNlIHRoaXMgYXMgZ2lkICovCisJCWJzcy0+Y3RybF9pbnRlcmZhY2VfZ2lkID0gc3RydG9sKGdyb3VwLCAmZW5kcCwgMTApOworCQlpZiAoKmdyb3VwID09ICdcMCcgfHwgKmVuZHAgIT0gJ1wwJykgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJMaW5lICVkOiBJbnZhbGlkIGdyb3VwICclcyciLAorCQkJCSAgIGxpbmUsIGdyb3VwKTsKKwkJCXJldHVybiAxOworCQl9CisJCWJzcy0+Y3RybF9pbnRlcmZhY2VfZ2lkX3NldCA9IDE7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiY3RybF9pbnRlcmZhY2VfZ3JvdXA9JWQiLAorCQkJICAgYnNzLT5jdHJsX2ludGVyZmFjZV9naWQpOwogI2VuZGlmIC8qIENPTkZJR19OQVRJVkVfV0lORE9XUyAqLwogI2VuZGlmIC8qIENPTkZJR19OT19DVFJMX0lGQUNFICovCiAjaWZkZWYgUkFESVVTX1NFUlZFUgotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfc2VydmVyX2NsaWVudHMiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+cmFkaXVzX3NlcnZlcl9jbGllbnRzKTsKLQkJCWJzcy0+cmFkaXVzX3NlcnZlcl9jbGllbnRzID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19zZXJ2ZXJfYXV0aF9wb3J0IikgPT0gMCkgewotCQkJYnNzLT5yYWRpdXNfc2VydmVyX2F1dGhfcG9ydCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX3NlcnZlcl9pcHY2IikgPT0gMCkgewotCQkJYnNzLT5yYWRpdXNfc2VydmVyX2lwdjYgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX3NlcnZlcl9jbGllbnRzIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+cmFkaXVzX3NlcnZlcl9jbGllbnRzKTsKKwkJYnNzLT5yYWRpdXNfc2VydmVyX2NsaWVudHMgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfc2VydmVyX2F1dGhfcG9ydCIpID09IDApIHsKKwkJYnNzLT5yYWRpdXNfc2VydmVyX2F1dGhfcG9ydCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfc2VydmVyX2FjY3RfcG9ydCIpID09IDApIHsKKwkJYnNzLT5yYWRpdXNfc2VydmVyX2FjY3RfcG9ydCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfc2VydmVyX2lwdjYiKSA9PSAwKSB7CisJCWJzcy0+cmFkaXVzX3NlcnZlcl9pcHY2ID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIFJBRElVU19TRVJWRVIgKi8KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidGVzdF9zb2NrZXQiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+dGVzdF9zb2NrZXQpOwotCQkJYnNzLT50ZXN0X3NvY2tldCA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ1c2VfcGFlX2dyb3VwX2FkZHIiKSA9PSAwKSB7Ci0JCQlic3MtPnVzZV9wYWVfZ3JvdXBfYWRkciA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaHdfbW9kZSIpID09IDApIHsKLQkJCWlmIChvc19zdHJjbXAocG9zLCAiYSIpID09IDApCi0JCQkJY29uZi0+aHdfbW9kZSA9IEhPU1RBUERfTU9ERV9JRUVFODAyMTFBOwotCQkJZWxzZSBpZiAob3Nfc3RyY21wKHBvcywgImIiKSA9PSAwKQotCQkJCWNvbmYtPmh3X21vZGUgPSBIT1NUQVBEX01PREVfSUVFRTgwMjExQjsKLQkJCWVsc2UgaWYgKG9zX3N0cmNtcChwb3MsICJnIikgPT0gMCkKLQkJCQljb25mLT5od19tb2RlID0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUc7Ci0JCQllbHNlIGlmIChvc19zdHJjbXAocG9zLCAiYWQiKSA9PSAwKQotCQkJCWNvbmYtPmh3X21vZGUgPSBIT1NUQVBEX01PREVfSUVFRTgwMjExQUQ7Ci0JCQllbHNlIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVua25vd24gIgotCQkJCQkgICAiaHdfbW9kZSAnJXMnIiwgbGluZSwgcG9zKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX3JmX2JhbmRzIikgPT0gMCkgewotCQkJaWYgKG9zX3N0cmNtcChwb3MsICJhIikgPT0gMCkKLQkJCQlic3MtPndwc19yZl9iYW5kcyA9IFdQU19SRl81MEdIWjsKLQkJCWVsc2UgaWYgKG9zX3N0cmNtcChwb3MsICJnIikgPT0gMCB8fAotCQkJCSBvc19zdHJjbXAocG9zLCAiYiIpID09IDApCi0JCQkJYnNzLT53cHNfcmZfYmFuZHMgPSBXUFNfUkZfMjRHSFo7Ci0JCQllbHNlIGlmIChvc19zdHJjbXAocG9zLCAiYWciKSA9PSAwIHx8Ci0JCQkJIG9zX3N0cmNtcChwb3MsICJnYSIpID09IDApCi0JCQkJYnNzLT53cHNfcmZfYmFuZHMgPQotCQkJCQlXUFNfUkZfMjRHSFogfCBXUFNfUkZfNTBHSFo7Ci0JCQllbHNlIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVua25vd24gIgotCQkJCQkgICAid3BzX3JmX2JhbmQgJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImNoYW5uZWwiKSA9PSAwKSB7Ci0JCQlpZiAob3Nfc3RyY21wKHBvcywgImFjc19zdXJ2ZXkiKSA9PSAwKSB7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidGVzdF9zb2NrZXQiKSA9PSAwKSB7CisJCW9zX2ZyZWUoYnNzLT50ZXN0X3NvY2tldCk7CisJCWJzcy0+dGVzdF9zb2NrZXQgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ1c2VfcGFlX2dyb3VwX2FkZHIiKSA9PSAwKSB7CisJCWJzcy0+dXNlX3BhZV9ncm91cF9hZGRyID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImh3X21vZGUiKSA9PSAwKSB7CisJCWlmIChvc19zdHJjbXAocG9zLCAiYSIpID09IDApCisJCQljb25mLT5od19tb2RlID0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUE7CisJCWVsc2UgaWYgKG9zX3N0cmNtcChwb3MsICJiIikgPT0gMCkKKwkJCWNvbmYtPmh3X21vZGUgPSBIT1NUQVBEX01PREVfSUVFRTgwMjExQjsKKwkJZWxzZSBpZiAob3Nfc3RyY21wKHBvcywgImciKSA9PSAwKQorCQkJY29uZi0+aHdfbW9kZSA9IEhPU1RBUERfTU9ERV9JRUVFODAyMTFHOworCQllbHNlIGlmIChvc19zdHJjbXAocG9zLCAiYWQiKSA9PSAwKQorCQkJY29uZi0+aHdfbW9kZSA9IEhPU1RBUERfTU9ERV9JRUVFODAyMTFBRDsKKwkJZWxzZSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVua25vd24gaHdfbW9kZSAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cHNfcmZfYmFuZHMiKSA9PSAwKSB7CisJCWlmIChvc19zdHJjbXAocG9zLCAiYSIpID09IDApCisJCQlic3MtPndwc19yZl9iYW5kcyA9IFdQU19SRl81MEdIWjsKKwkJZWxzZSBpZiAob3Nfc3RyY21wKHBvcywgImciKSA9PSAwIHx8CisJCQkgb3Nfc3RyY21wKHBvcywgImIiKSA9PSAwKQorCQkJYnNzLT53cHNfcmZfYmFuZHMgPSBXUFNfUkZfMjRHSFo7CisJCWVsc2UgaWYgKG9zX3N0cmNtcChwb3MsICJhZyIpID09IDAgfHwKKwkJCSBvc19zdHJjbXAocG9zLCAiZ2EiKSA9PSAwKQorCQkJYnNzLT53cHNfcmZfYmFuZHMgPSBXUFNfUkZfMjRHSFogfCBXUFNfUkZfNTBHSFo7CisJCWVsc2UgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IHVua25vd24gd3BzX3JmX2JhbmQgJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiY2hhbm5lbCIpID09IDApIHsKKwkJaWYgKG9zX3N0cmNtcChwb3MsICJhY3Nfc3VydmV5IikgPT0gMCkgewogI2lmbmRlZiBDT05GSUdfQUNTCi0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiB0cmllcyB0byBlbmFibGUgQUNTIGJ1dCBDT05GSUdfQUNTIGRpc2FibGVkIiwKLQkJCQkJICAgbGluZSk7Ci0JCQkJZXJyb3JzKys7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHRyaWVzIHRvIGVuYWJsZSBBQ1MgYnV0IENPTkZJR19BQ1MgZGlzYWJsZWQiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisjZWxzZSAvKiBDT05GSUdfQUNTICovCisJCQljb25mLT5jaGFubmVsID0gMDsKICNlbmRpZiAvKiBDT05GSUdfQUNTICovCi0JCQkJY29uZi0+Y2hhbm5lbCA9IDA7Ci0JCQl9IGVsc2UKLQkJCQljb25mLT5jaGFubmVsID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJiZWFjb25faW50IikgPT0gMCkgewotCQkJaW50IHZhbCA9IGF0b2kocG9zKTsKLQkJCS8qIE1JQiBkZWZpbmVzIHJhbmdlIGFzIDEuLjY1NTM1LCBidXQgdmVyeSBzbWFsbCB2YWx1ZXMKLQkJCSAqIGNhdXNlIHByb2JsZW1zIHdpdGggdGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24uCi0JCQkgKiBTaW5jZSBpdCBpcyB1bmxpa2VseSB0aGF0IHRoaXMgc21hbGwgbnVtYmVycyBhcmUKLQkJCSAqIHVzZWZ1bCBpbiByZWFsIGxpZmUgc2NlbmFyaW9zLCBkbyBub3QgYWxsb3cgYmVhY29uCi0JCQkgKiBwZXJpb2QgdG8gYmUgc2V0IGJlbG93IDE1IFRVLiAqLwotCQkJaWYgKHZhbCA8IDE1IHx8IHZhbCA+IDY1NTM1KSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKLQkJCQkJICAgImJlYWNvbl9pbnQgJWQgKGV4cGVjdGVkICIKLQkJCQkJICAgIjE1Li42NTUzNSkiLCBsaW5lLCB2YWwpOwotCQkJCWVycm9ycysrOwotCQkJfSBlbHNlCi0JCQkJY29uZi0+YmVhY29uX2ludCA9IHZhbDsKKwkJfSBlbHNlCisJCQljb25mLT5jaGFubmVsID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImNoYW5saXN0IikgPT0gMCkgeworCQlpZiAoaG9zdGFwZF9wYXJzZV9pbnRsaXN0KCZjb25mLT5jaGFubGlzdCwgcG9zKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGNoYW5uZWwgbGlzdCIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImJlYWNvbl9pbnQiKSA9PSAwKSB7CisJCWludCB2YWwgPSBhdG9pKHBvcyk7CisJCS8qIE1JQiBkZWZpbmVzIHJhbmdlIGFzIDEuLjY1NTM1LCBidXQgdmVyeSBzbWFsbCB2YWx1ZXMKKwkJICogY2F1c2UgcHJvYmxlbXMgd2l0aCB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbi4KKwkJICogU2luY2UgaXQgaXMgdW5saWtlbHkgdGhhdCB0aGlzIHNtYWxsIG51bWJlcnMgYXJlCisJCSAqIHVzZWZ1bCBpbiByZWFsIGxpZmUgc2NlbmFyaW9zLCBkbyBub3QgYWxsb3cgYmVhY29uCisJCSAqIHBlcmlvZCB0byBiZSBzZXQgYmVsb3cgMTUgVFUuICovCisJCWlmICh2YWwgPCAxNSB8fCB2YWwgPiA2NTUzNSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGJlYWNvbl9pbnQgJWQgKGV4cGVjdGVkIDE1Li42NTUzNSkiLAorCQkJCSAgIGxpbmUsIHZhbCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQljb25mLT5iZWFjb25faW50ID0gdmFsOwogI2lmZGVmIENPTkZJR19BQ1MKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYWNzX251bV9zY2FucyIpID09IDApIHsKLQkJCWludCB2YWwgPSBhdG9pKHBvcyk7Ci0JCQlpZiAodmFsIDw9IDAgfHwgdmFsID4gMTAwKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGFjc19udW1fc2NhbnMgJWQgKGV4cGVjdGVkIDEuLjEwMCkiLAotCQkJCQkgICBsaW5lLCB2YWwpOwotCQkJCWVycm9ycysrOwotCQkJfSBlbHNlCi0JCQkJY29uZi0+YWNzX251bV9zY2FucyA9IHZhbDsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhY3NfbnVtX3NjYW5zIikgPT0gMCkgeworCQlpbnQgdmFsID0gYXRvaShwb3MpOworCQlpZiAodmFsIDw9IDAgfHwgdmFsID4gMTAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgYWNzX251bV9zY2FucyAlZCAoZXhwZWN0ZWQgMS4uMTAwKSIsCisJCQkJICAgbGluZSwgdmFsKTsKKwkJCXJldHVybiAxOworCQl9CisJCWNvbmYtPmFjc19udW1fc2NhbnMgPSB2YWw7CiAjZW5kaWYgLyogQ09ORklHX0FDUyAqLwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkdGltX3BlcmlvZCIpID09IDApIHsKLQkJCWJzcy0+ZHRpbV9wZXJpb2QgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT5kdGltX3BlcmlvZCA8IDEgfHwgYnNzLT5kdGltX3BlcmlvZCA+IDI1NSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCi0JCQkJCSAgICJkdGltX3BlcmlvZCAlZCIsCi0JCQkJCSAgIGxpbmUsIGJzcy0+ZHRpbV9wZXJpb2QpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJydHNfdGhyZXNob2xkIikgPT0gMCkgewotCQkJY29uZi0+cnRzX3RocmVzaG9sZCA9IGF0b2kocG9zKTsKLQkJCWlmIChjb25mLT5ydHNfdGhyZXNob2xkIDwgMCB8fAotCQkJICAgIGNvbmYtPnJ0c190aHJlc2hvbGQgPiAyMzQ3KSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKLQkJCQkJICAgInJ0c190aHJlc2hvbGQgJWQiLAotCQkJCQkgICBsaW5lLCBjb25mLT5ydHNfdGhyZXNob2xkKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZnJhZ21fdGhyZXNob2xkIikgPT0gMCkgewotCQkJY29uZi0+ZnJhZ21fdGhyZXNob2xkID0gYXRvaShwb3MpOwotCQkJaWYgKGNvbmYtPmZyYWdtX3RocmVzaG9sZCA8IDI1NiB8fAotCQkJICAgIGNvbmYtPmZyYWdtX3RocmVzaG9sZCA+IDIzNDYpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAiZnJhZ21fdGhyZXNob2xkICVkIiwKLQkJCQkJICAgbGluZSwgY29uZi0+ZnJhZ21fdGhyZXNob2xkKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAic2VuZF9wcm9iZV9yZXNwb25zZSIpID09IDApIHsKLQkJCWludCB2YWwgPSBhdG9pKHBvcyk7Ci0JCQlpZiAodmFsICE9IDAgJiYgdmFsICE9IDEpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAic2VuZF9wcm9iZV9yZXNwb25zZSAlZCAoZXhwZWN0ZWQgIgotCQkJCQkgICAiMCBvciAxKSIsIGxpbmUsIHZhbCk7Ci0JCQl9IGVsc2UKLQkJCQljb25mLT5zZW5kX3Byb2JlX3Jlc3BvbnNlID0gdmFsOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzdXBwb3J0ZWRfcmF0ZXMiKSA9PSAwKSB7Ci0JCQlpZiAoaG9zdGFwZF9wYXJzZV9pbnRsaXN0KCZjb25mLT5zdXBwb3J0ZWRfcmF0ZXMsIHBvcykpCi0JCQl7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIHJhdGUgIgotCQkJCQkgICAibGlzdCIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJiYXNpY19yYXRlcyIpID09IDApIHsKLQkJCWlmIChob3N0YXBkX3BhcnNlX2ludGxpc3QoJmNvbmYtPmJhc2ljX3JhdGVzLCBwb3MpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIHJhdGUgIgotCQkJCQkgICAibGlzdCIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwcmVhbWJsZSIpID09IDApIHsKLQkJCWlmIChhdG9pKHBvcykpCi0JCQkJY29uZi0+cHJlYW1ibGUgPSBTSE9SVF9QUkVBTUJMRTsKLQkJCWVsc2UKLQkJCQljb25mLT5wcmVhbWJsZSA9IExPTkdfUFJFQU1CTEU7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImlnbm9yZV9icm9hZGNhc3Rfc3NpZCIpID09IDApIHsKLQkJCWJzcy0+aWdub3JlX2Jyb2FkY2FzdF9zc2lkID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3ZXBfZGVmYXVsdF9rZXkiKSA9PSAwKSB7Ci0JCQlic3MtPnNzaWQud2VwLmlkeCA9IGF0b2kocG9zKTsKLQkJCWlmIChic3MtPnNzaWQud2VwLmlkeCA+IDMpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkludmFsaWQgIgotCQkJCQkgICAid2VwX2RlZmF1bHRfa2V5IGluZGV4ICVkIiwKLQkJCQkJICAgYnNzLT5zc2lkLndlcC5pZHgpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5MCIpID09IDAgfHwKLQkJCSAgIG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5MSIpID09IDAgfHwKLQkJCSAgIG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5MiIpID09IDAgfHwKLQkJCSAgIG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5MyIpID09IDApIHsKLQkJCWlmIChob3N0YXBkX2NvbmZpZ19yZWFkX3dlcCgmYnNzLT5zc2lkLndlcCwKLQkJCQkJCSAgICBidWZbN10gLSAnMCcsIHBvcykpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgV0VQICIKLQkJCQkJICAgImtleSAnJXMnIiwgbGluZSwgYnVmKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkdGltX3BlcmlvZCIpID09IDApIHsKKwkJYnNzLT5kdGltX3BlcmlvZCA9IGF0b2kocG9zKTsKKwkJaWYgKGJzcy0+ZHRpbV9wZXJpb2QgPCAxIHx8IGJzcy0+ZHRpbV9wZXJpb2QgPiAyNTUpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBkdGltX3BlcmlvZCAlZCIsCisJCQkJICAgbGluZSwgYnNzLT5kdGltX3BlcmlvZCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJ0c190aHJlc2hvbGQiKSA9PSAwKSB7CisJCWNvbmYtPnJ0c190aHJlc2hvbGQgPSBhdG9pKHBvcyk7CisJCWlmIChjb25mLT5ydHNfdGhyZXNob2xkIDwgMCB8fCBjb25mLT5ydHNfdGhyZXNob2xkID4gMjM0NykgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IGludmFsaWQgcnRzX3RocmVzaG9sZCAlZCIsCisJCQkJICAgbGluZSwgY29uZi0+cnRzX3RocmVzaG9sZCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImZyYWdtX3RocmVzaG9sZCIpID09IDApIHsKKwkJY29uZi0+ZnJhZ21fdGhyZXNob2xkID0gYXRvaShwb3MpOworCQlpZiAoY29uZi0+ZnJhZ21fdGhyZXNob2xkIDwgMjU2IHx8CisJCSAgICBjb25mLT5mcmFnbV90aHJlc2hvbGQgPiAyMzQ2KSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiTGluZSAlZDogaW52YWxpZCBmcmFnbV90aHJlc2hvbGQgJWQiLAorCQkJCSAgIGxpbmUsIGNvbmYtPmZyYWdtX3RocmVzaG9sZCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInNlbmRfcHJvYmVfcmVzcG9uc2UiKSA9PSAwKSB7CisJCWludCB2YWwgPSBhdG9pKHBvcyk7CisJCWlmICh2YWwgIT0gMCAmJiB2YWwgIT0gMSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIHNlbmRfcHJvYmVfcmVzcG9uc2UgJWQgKGV4cGVjdGVkIDAgb3IgMSkiLAorCQkJCSAgIGxpbmUsIHZhbCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQljb25mLT5zZW5kX3Byb2JlX3Jlc3BvbnNlID0gdmFsOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInN1cHBvcnRlZF9yYXRlcyIpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfcGFyc2VfaW50bGlzdCgmY29uZi0+c3VwcG9ydGVkX3JhdGVzLCBwb3MpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgcmF0ZSBsaXN0IiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYmFzaWNfcmF0ZXMiKSA9PSAwKSB7CisJCWlmIChob3N0YXBkX3BhcnNlX2ludGxpc3QoJmNvbmYtPmJhc2ljX3JhdGVzLCBwb3MpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgcmF0ZSBsaXN0IiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicHJlYW1ibGUiKSA9PSAwKSB7CisJCWlmIChhdG9pKHBvcykpCisJCQljb25mLT5wcmVhbWJsZSA9IFNIT1JUX1BSRUFNQkxFOworCQllbHNlCisJCQljb25mLT5wcmVhbWJsZSA9IExPTkdfUFJFQU1CTEU7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaWdub3JlX2Jyb2FkY2FzdF9zc2lkIikgPT0gMCkgeworCQlic3MtPmlnbm9yZV9icm9hZGNhc3Rfc3NpZCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3ZXBfZGVmYXVsdF9rZXkiKSA9PSAwKSB7CisJCWJzcy0+c3NpZC53ZXAuaWR4ID0gYXRvaShwb3MpOworCQlpZiAoYnNzLT5zc2lkLndlcC5pZHggPiAzKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiSW52YWxpZCB3ZXBfZGVmYXVsdF9rZXkgaW5kZXggJWQiLAorCQkJCSAgIGJzcy0+c3NpZC53ZXAuaWR4KTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid2VwX2tleTAiKSA9PSAwIHx8CisJCSAgIG9zX3N0cmNtcChidWYsICJ3ZXBfa2V5MSIpID09IDAgfHwKKwkJICAgb3Nfc3RyY21wKGJ1ZiwgIndlcF9rZXkyIikgPT0gMCB8fAorCQkgICBvc19zdHJjbXAoYnVmLCAid2VwX2tleTMiKSA9PSAwKSB7CisJCWlmIChob3N0YXBkX2NvbmZpZ19yZWFkX3dlcCgmYnNzLT5zc2lkLndlcCwKKwkJCQkJICAgIGJ1Zls3XSAtICcwJywgcG9zKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIFdFUCBrZXkgJyVzJyIsCisJCQkJICAgbGluZSwgYnVmKTsKKwkJCXJldHVybiAxOworCQl9CiAjaWZuZGVmIENPTkZJR19OT19WTEFOCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImR5bmFtaWNfdmxhbiIpID09IDApIHsKLQkJCWJzcy0+c3NpZC5keW5hbWljX3ZsYW4gPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZsYW5fZmlsZSIpID09IDApIHsKLQkJCWlmIChob3N0YXBkX2NvbmZpZ19yZWFkX3ZsYW5fZmlsZShic3MsIHBvcykpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGZhaWxlZCB0byAiCi0JCQkJCSAgICJyZWFkIFZMQU4gZmlsZSAnJXMnIiwgbGluZSwgcG9zKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmxhbl9uYW1pbmciKSA9PSAwKSB7Ci0JCQlic3MtPnNzaWQudmxhbl9uYW1pbmcgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT5zc2lkLnZsYW5fbmFtaW5nID49IERZTkFNSUNfVkxBTl9OQU1JTkdfRU5EIHx8Ci0JCQkgICAgYnNzLT5zc2lkLnZsYW5fbmFtaW5nIDwgMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCi0JCQkJCSAgICJuYW1pbmcgc2NoZW1lICVkIiwgbGluZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBic3MtPnNzaWQudmxhbl9uYW1pbmcpOwotCQkJCWVycm9ycysrOwotICAgICAgICAgICAgICAgICAgICAgICAgfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImR5bmFtaWNfdmxhbiIpID09IDApIHsKKwkJYnNzLT5zc2lkLmR5bmFtaWNfdmxhbiA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2bGFuX2ZpbGUiKSA9PSAwKSB7CisJCWlmIChob3N0YXBkX2NvbmZpZ19yZWFkX3ZsYW5fZmlsZShic3MsIHBvcykpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogZmFpbGVkIHRvIHJlYWQgVkxBTiBmaWxlICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZsYW5fbmFtaW5nIikgPT0gMCkgeworCQlic3MtPnNzaWQudmxhbl9uYW1pbmcgPSBhdG9pKHBvcyk7CisJCWlmIChic3MtPnNzaWQudmxhbl9uYW1pbmcgPj0gRFlOQU1JQ19WTEFOX05BTUlOR19FTkQgfHwKKwkJICAgIGJzcy0+c3NpZC52bGFuX25hbWluZyA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJMaW5lICVkOiBpbnZhbGlkIG5hbWluZyBzY2hlbWUgJWQiLAorCQkJCSAgIGxpbmUsIGJzcy0+c3NpZC52bGFuX25hbWluZyk7CisJCQlyZXR1cm4gMTsKKwkJfQogI2lmZGVmIENPTkZJR19GVUxMX0RZTkFNSUNfVkxBTgotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2bGFuX3RhZ2dlZF9pbnRlcmZhY2UiKSA9PSAwKSB7Ci0JCQlic3MtPnNzaWQudmxhbl90YWdnZWRfaW50ZXJmYWNlID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmxhbl90YWdnZWRfaW50ZXJmYWNlIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+c3NpZC52bGFuX3RhZ2dlZF9pbnRlcmZhY2UpOworCQlic3MtPnNzaWQudmxhbl90YWdnZWRfaW50ZXJmYWNlID0gb3Nfc3RyZHVwKHBvcyk7CiAjZW5kaWYgLyogQ09ORklHX0ZVTExfRFlOQU1JQ19WTEFOICovCiAjZW5kaWYgLyogQ09ORklHX05PX1ZMQU4gKi8KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXBfdGFibGVfbWF4X3NpemUiKSA9PSAwKSB7Ci0JCQljb25mLT5hcF90YWJsZV9tYXhfc2l6ZSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXBfdGFibGVfZXhwaXJhdGlvbl90aW1lIikgPT0gMCkgewotCQkJY29uZi0+YXBfdGFibGVfZXhwaXJhdGlvbl90aW1lID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAidHhfcXVldWVfIiwgOSkgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfY29uZmlnX3R4X3F1ZXVlKGNvbmYsIGJ1ZiwgcG9zKSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBUWCAiCi0JCQkJCSAgICJxdWV1ZSBpdGVtIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndtZV9lbmFibGVkIikgPT0gMCB8fAotCQkJICAgb3Nfc3RyY21wKGJ1ZiwgIndtbV9lbmFibGVkIikgPT0gMCkgewotCQkJYnNzLT53bW1fZW5hYmxlZCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidWFwc2RfYWR2ZXJ0aXNlbWVudF9lbmFibGVkIikgPT0gMCkgewotCQkJYnNzLT53bW1fdWFwc2QgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJ3bWVfYWNfIiwgNykgPT0gMCB8fAotCQkJICAgb3Nfc3RybmNtcChidWYsICJ3bW1fYWNfIiwgNykgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfY29uZmlnX3dtbV9hYyhjb25mLT53bW1fYWNfcGFyYW1zLCBidWYsCi0JCQkJCQkgIHBvcykpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgV01NICIKLQkJCQkJICAgImFjIGl0ZW0iLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYnNzIikgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfY29uZmlnX2Jzcyhjb25mLCBwb3MpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGJzcyAiCi0JCQkJCSAgICJpdGVtIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImJzc2lkIikgPT0gMCkgewotCQkJaWYgKGh3YWRkcl9hdG9uKHBvcywgYnNzLT5ic3NpZCkpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgYnNzaWQgIgotCQkJCQkgICAiaXRlbSIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFwX3RhYmxlX21heF9zaXplIikgPT0gMCkgeworCQljb25mLT5hcF90YWJsZV9tYXhfc2l6ZSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhcF90YWJsZV9leHBpcmF0aW9uX3RpbWUiKSA9PSAwKSB7CisJCWNvbmYtPmFwX3RhYmxlX2V4cGlyYXRpb25fdGltZSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAidHhfcXVldWVfIiwgOSkgPT0gMCkgeworCQlpZiAoaG9zdGFwZF9jb25maWdfdHhfcXVldWUoY29uZiwgYnVmLCBwb3MpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgVFggcXVldWUgaXRlbSIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndtZV9lbmFibGVkIikgPT0gMCB8fAorCQkgICBvc19zdHJjbXAoYnVmLCAid21tX2VuYWJsZWQiKSA9PSAwKSB7CisJCWJzcy0+d21tX2VuYWJsZWQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidWFwc2RfYWR2ZXJ0aXNlbWVudF9lbmFibGVkIikgPT0gMCkgeworCQlic3MtPndtbV91YXBzZCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAid21lX2FjXyIsIDcpID09IDAgfHwKKwkJICAgb3Nfc3RybmNtcChidWYsICJ3bW1fYWNfIiwgNykgPT0gMCkgeworCQlpZiAoaG9zdGFwZF9jb25maWdfd21tX2FjKGNvbmYtPndtbV9hY19wYXJhbXMsIGJ1ZiwgcG9zKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIFdNTSBhYyBpdGVtIiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYnNzIikgPT0gMCkgeworCQlpZiAoaG9zdGFwZF9jb25maWdfYnNzKGNvbmYsIHBvcykpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBic3MgaXRlbSIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImJzc2lkIikgPT0gMCkgeworCQlpZiAoaHdhZGRyX2F0b24ocG9zLCBic3MtPmJzc2lkKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGJzc2lkIGl0ZW0iLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KICNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJpZWVlODAyMTF3IikgPT0gMCkgewotCQkJYnNzLT5pZWVlODAyMTF3ID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhc3NvY19zYV9xdWVyeV9tYXhfdGltZW91dCIpID09IDApIHsKLQkJCWJzcy0+YXNzb2Nfc2FfcXVlcnlfbWF4X3RpbWVvdXQgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT5hc3NvY19zYV9xdWVyeV9tYXhfdGltZW91dCA9PSAwKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKLQkJCQkJICAgImFzc29jX3NhX3F1ZXJ5X21heF90aW1lb3V0IiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFzc29jX3NhX3F1ZXJ5X3JldHJ5X3RpbWVvdXQiKSA9PSAwKQotCQl7Ci0JCQlic3MtPmFzc29jX3NhX3F1ZXJ5X3JldHJ5X3RpbWVvdXQgPSBhdG9pKHBvcyk7Ci0JCQlpZiAoYnNzLT5hc3NvY19zYV9xdWVyeV9yZXRyeV90aW1lb3V0ID09IDApIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAiYXNzb2Nfc2FfcXVlcnlfcmV0cnlfdGltZW91dCIsCi0JCQkJCSAgIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImllZWU4MDIxMXciKSA9PSAwKSB7CisJCWJzcy0+aWVlZTgwMjExdyA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJncm91cF9tZ210X2NpcGhlciIpID09IDApIHsKKwkJaWYgKG9zX3N0cmNtcChwb3MsICJBRVMtMTI4LUNNQUMiKSA9PSAwKSB7CisJCQlic3MtPmdyb3VwX21nbXRfY2lwaGVyID0gV1BBX0NJUEhFUl9BRVNfMTI4X0NNQUM7CisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKHBvcywgIkJJUC1HTUFDLTEyOCIpID09IDApIHsKKwkJCWJzcy0+Z3JvdXBfbWdtdF9jaXBoZXIgPSBXUEFfQ0lQSEVSX0JJUF9HTUFDXzEyODsKKwkJfSBlbHNlIGlmIChvc19zdHJjbXAocG9zLCAiQklQLUdNQUMtMjU2IikgPT0gMCkgeworCQkJYnNzLT5ncm91cF9tZ210X2NpcGhlciA9IFdQQV9DSVBIRVJfQklQX0dNQUNfMjU2OworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChwb3MsICJCSVAtQ01BQy0yNTYiKSA9PSAwKSB7CisJCQlic3MtPmdyb3VwX21nbXRfY2lwaGVyID0gV1BBX0NJUEhFUl9CSVBfQ01BQ18yNTY7CisJCX0gZWxzZSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgZ3JvdXBfbWdtdF9jaXBoZXI6ICVzIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhc3NvY19zYV9xdWVyeV9tYXhfdGltZW91dCIpID09IDApIHsKKwkJYnNzLT5hc3NvY19zYV9xdWVyeV9tYXhfdGltZW91dCA9IGF0b2kocG9zKTsKKwkJaWYgKGJzcy0+YXNzb2Nfc2FfcXVlcnlfbWF4X3RpbWVvdXQgPT0gMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGFzc29jX3NhX3F1ZXJ5X21heF90aW1lb3V0IiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXNzb2Nfc2FfcXVlcnlfcmV0cnlfdGltZW91dCIpID09IDApIHsKKwkJYnNzLT5hc3NvY19zYV9xdWVyeV9yZXRyeV90aW1lb3V0ID0gYXRvaShwb3MpOworCQlpZiAoYnNzLT5hc3NvY19zYV9xdWVyeV9yZXRyeV90aW1lb3V0ID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBhc3NvY19zYV9xdWVyeV9yZXRyeV90aW1lb3V0IiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KICNpZmRlZiBDT05GSUdfSUVFRTgwMjExTgotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJpZWVlODAyMTFuIikgPT0gMCkgewotCQkJY29uZi0+aWVlZTgwMjExbiA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaHRfY2FwYWIiKSA9PSAwKSB7Ci0JCQlpZiAoaG9zdGFwZF9jb25maWdfaHRfY2FwYWIoY29uZiwgcG9zKSA8IDApIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAiaHRfY2FwYWIiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmVxdWlyZV9odCIpID09IDApIHsKLQkJCWNvbmYtPnJlcXVpcmVfaHQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaWVlZTgwMjExbiIpID09IDApIHsKKwkJY29uZi0+aWVlZTgwMjExbiA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJodF9jYXBhYiIpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY29uZmlnX2h0X2NhcGFiKGNvbmYsIHBvcykgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgaHRfY2FwYWIiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyZXF1aXJlX2h0IikgPT0gMCkgeworCQljb25mLT5yZXF1aXJlX2h0ID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm9ic3NfaW50ZXJ2YWwiKSA9PSAwKSB7CisJCWNvbmYtPm9ic3NfaW50ZXJ2YWwgPSBhdG9pKHBvcyk7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMU4gKi8KICNpZmRlZiBDT05GSUdfSUVFRTgwMjExQUMKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaWVlZTgwMjExYWMiKSA9PSAwKSB7Ci0JCQljb25mLT5pZWVlODAyMTFhYyA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmh0X2NhcGFiIikgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfY29uZmlnX3ZodF9jYXBhYihjb25mLCBwb3MpIDwgMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCi0JCQkJCSAgICJ2aHRfY2FwYWIiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmVxdWlyZV92aHQiKSA9PSAwKSB7Ci0JCQljb25mLT5yZXF1aXJlX3ZodCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmh0X29wZXJfY2h3aWR0aCIpID09IDApIHsKLQkJCWNvbmYtPnZodF9vcGVyX2Nod2lkdGggPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHgiKSA9PSAwKQotCQl7Ci0JCQljb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4IikgPT0gMCkKLQkJewotCQkJY29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJpZWVlODAyMTFhYyIpID09IDApIHsKKwkJY29uZi0+aWVlZTgwMjExYWMgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmh0X2NhcGFiIikgPT0gMCkgeworCQlpZiAoaG9zdGFwZF9jb25maWdfdmh0X2NhcGFiKGNvbmYsIHBvcykgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgdmh0X2NhcGFiIiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmVxdWlyZV92aHQiKSA9PSAwKSB7CisJCWNvbmYtPnJlcXVpcmVfdmh0ID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZodF9vcGVyX2Nod2lkdGgiKSA9PSAwKSB7CisJCWNvbmYtPnZodF9vcGVyX2Nod2lkdGggPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCIpID09IDApIHsKKwkJY29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4IikgPT0gMCkgeworCQljb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4ID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFBQyAqLwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtYXhfbGlzdGVuX2ludGVydmFsIikgPT0gMCkgewotCQkJYnNzLT5tYXhfbGlzdGVuX2ludGVydmFsID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkaXNhYmxlX3Bta3NhX2NhY2hpbmciKSA9PSAwKSB7Ci0JCQlic3MtPmRpc2FibGVfcG1rc2FfY2FjaGluZyA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAib2tjIikgPT0gMCkgewotCQkJYnNzLT5va2MgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWF4X2xpc3Rlbl9pbnRlcnZhbCIpID09IDApIHsKKwkJYnNzLT5tYXhfbGlzdGVuX2ludGVydmFsID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImRpc2FibGVfcG1rc2FfY2FjaGluZyIpID09IDApIHsKKwkJYnNzLT5kaXNhYmxlX3Bta3NhX2NhY2hpbmcgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAib2tjIikgPT0gMCkgeworCQlic3MtPm9rYyA9IGF0b2kocG9zKTsKICNpZmRlZiBDT05GSUdfV1BTCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwc19zdGF0ZSIpID09IDApIHsKLQkJCWJzcy0+d3BzX3N0YXRlID0gYXRvaShwb3MpOwotCQkJaWYgKGJzcy0+d3BzX3N0YXRlIDwgMCB8fCBic3MtPndwc19zdGF0ZSA+IDIpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAid3BzX3N0YXRlIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwc19pbmRlcGVuZGVudCIpID09IDApIHsKLQkJCWJzcy0+d3BzX2luZGVwZW5kZW50ID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhcF9zZXR1cF9sb2NrZWQiKSA9PSAwKSB7Ci0JCQlic3MtPmFwX3NldHVwX2xvY2tlZCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidXVpZCIpID09IDApIHsKLQkJCWlmICh1dWlkX3N0cjJiaW4ocG9zLCBic3MtPnV1aWQpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIFVVSUQiLAotCQkJCQkgICBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX3Bpbl9yZXF1ZXN0cyIpID09IDApIHsKLQkJCW9zX2ZyZWUoYnNzLT53cHNfcGluX3JlcXVlc3RzKTsKLQkJCWJzcy0+d3BzX3Bpbl9yZXF1ZXN0cyA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkZXZpY2VfbmFtZSIpID09IDApIHsKLQkJCWlmIChvc19zdHJsZW4ocG9zKSA+IDMyKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBUb28gbG9uZyAiCi0JCQkJCSAgICJkZXZpY2VfbmFtZSIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQkJb3NfZnJlZShic3MtPmRldmljZV9uYW1lKTsKLQkJCWJzcy0+ZGV2aWNlX25hbWUgPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWFudWZhY3R1cmVyIikgPT0gMCkgewotCQkJaWYgKG9zX3N0cmxlbihwb3MpID4gNjQpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IFRvbyBsb25nICIKLQkJCQkJICAgIm1hbnVmYWN0dXJlciIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQkJb3NfZnJlZShic3MtPm1hbnVmYWN0dXJlcik7Ci0JCQlic3MtPm1hbnVmYWN0dXJlciA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtb2RlbF9uYW1lIikgPT0gMCkgewotCQkJaWYgKG9zX3N0cmxlbihwb3MpID4gMzIpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IFRvbyBsb25nICIKLQkJCQkJICAgIm1vZGVsX25hbWUiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJCW9zX2ZyZWUoYnNzLT5tb2RlbF9uYW1lKTsKLQkJCWJzcy0+bW9kZWxfbmFtZSA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtb2RlbF9udW1iZXIiKSA9PSAwKSB7Ci0JCQlpZiAob3Nfc3RybGVuKHBvcykgPiAzMikgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogVG9vIGxvbmcgIgotCQkJCQkgICAibW9kZWxfbnVtYmVyIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCQlvc19mcmVlKGJzcy0+bW9kZWxfbnVtYmVyKTsKLQkJCWJzcy0+bW9kZWxfbnVtYmVyID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInNlcmlhbF9udW1iZXIiKSA9PSAwKSB7Ci0JCQlpZiAob3Nfc3RybGVuKHBvcykgPiAzMikgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogVG9vIGxvbmcgIgotCQkJCQkgICAic2VyaWFsX251bWJlciIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQkJb3NfZnJlZShic3MtPnNlcmlhbF9udW1iZXIpOwotCQkJYnNzLT5zZXJpYWxfbnVtYmVyID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImRldmljZV90eXBlIikgPT0gMCkgewotCQkJaWYgKHdwc19kZXZfdHlwZV9zdHIyYmluKHBvcywgYnNzLT5kZXZpY2VfdHlwZSkpCi0JCQkJZXJyb3JzKys7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImNvbmZpZ19tZXRob2RzIikgPT0gMCkgewotCQkJb3NfZnJlZShic3MtPmNvbmZpZ19tZXRob2RzKTsKLQkJCWJzcy0+Y29uZmlnX21ldGhvZHMgPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAib3NfdmVyc2lvbiIpID09IDApIHsKLQkJCWlmIChoZXhzdHIyYmluKHBvcywgYnNzLT5vc192ZXJzaW9uLCA0KSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCi0JCQkJCSAgICJvc192ZXJzaW9uIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFwX3BpbiIpID09IDApIHsKLQkJCW9zX2ZyZWUoYnNzLT5hcF9waW4pOwotCQkJYnNzLT5hcF9waW4gPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAic2tpcF9jcmVkX2J1aWxkIikgPT0gMCkgewotCQkJYnNzLT5za2lwX2NyZWRfYnVpbGQgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImV4dHJhX2NyZWQiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+ZXh0cmFfY3JlZCk7Ci0JCQlic3MtPmV4dHJhX2NyZWQgPQotCQkJCSh1OCAqKSBvc19yZWFkZmlsZShwb3MsICZic3MtPmV4dHJhX2NyZWRfbGVuKTsKLQkJCWlmIChic3MtPmV4dHJhX2NyZWQgPT0gTlVMTCkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogY291bGQgbm90ICIKLQkJCQkJICAgInJlYWQgQ3JlZGVudGlhbHMgZnJvbSAnJXMnIiwKLQkJCQkJICAgbGluZSwgcG9zKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX2NyZWRfcHJvY2Vzc2luZyIpID09IDApIHsKLQkJCWJzcy0+d3BzX2NyZWRfcHJvY2Vzc2luZyA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXBfc2V0dGluZ3MiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+YXBfc2V0dGluZ3MpOwotCQkJYnNzLT5hcF9zZXR0aW5ncyA9Ci0JCQkJKHU4ICopIG9zX3JlYWRmaWxlKHBvcywgJmJzcy0+YXBfc2V0dGluZ3NfbGVuKTsKLQkJCWlmIChic3MtPmFwX3NldHRpbmdzID09IE5VTEwpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGNvdWxkIG5vdCAiCi0JCQkJCSAgICJyZWFkIEFQIFNldHRpbmdzIGZyb20gJyVzJyIsCi0JCQkJCSAgIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInVwbnBfaWZhY2UiKSA9PSAwKSB7Ci0JCQlic3MtPnVwbnBfaWZhY2UgPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZnJpZW5kbHlfbmFtZSIpID09IDApIHsKLQkJCW9zX2ZyZWUoYnNzLT5mcmllbmRseV9uYW1lKTsKLQkJCWJzcy0+ZnJpZW5kbHlfbmFtZSA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtYW51ZmFjdHVyZXJfdXJsIikgPT0gMCkgewotCQkJb3NfZnJlZShic3MtPm1hbnVmYWN0dXJlcl91cmwpOwotCQkJYnNzLT5tYW51ZmFjdHVyZXJfdXJsID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm1vZGVsX2Rlc2NyaXB0aW9uIikgPT0gMCkgewotCQkJb3NfZnJlZShic3MtPm1vZGVsX2Rlc2NyaXB0aW9uKTsKLQkJCWJzcy0+bW9kZWxfZGVzY3JpcHRpb24gPSBvc19zdHJkdXAocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibW9kZWxfdXJsIikgPT0gMCkgewotCQkJb3NfZnJlZShic3MtPm1vZGVsX3VybCk7Ci0JCQlic3MtPm1vZGVsX3VybCA9IG9zX3N0cmR1cChwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ1cGMiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+dXBjKTsKLQkJCWJzcy0+dXBjID0gb3Nfc3RyZHVwKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBiY19pbl9tMSIpID09IDApIHsKLQkJCWJzcy0+cGJjX2luX20xID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzZXJ2ZXJfaWQiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+c2VydmVyX2lkKTsKLQkJCWJzcy0+c2VydmVyX2lkID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX3N0YXRlIikgPT0gMCkgeworCQlic3MtPndwc19zdGF0ZSA9IGF0b2kocG9zKTsKKwkJaWYgKGJzcy0+d3BzX3N0YXRlIDwgMCB8fCBic3MtPndwc19zdGF0ZSA+IDIpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCB3cHNfc3RhdGUiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cHNfaW5kZXBlbmRlbnQiKSA9PSAwKSB7CisJCWJzcy0+d3BzX2luZGVwZW5kZW50ID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFwX3NldHVwX2xvY2tlZCIpID09IDApIHsKKwkJYnNzLT5hcF9zZXR1cF9sb2NrZWQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidXVpZCIpID09IDApIHsKKwkJaWYgKHV1aWRfc3RyMmJpbihwb3MsIGJzcy0+dXVpZCkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBVVUlEIiwgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwc19waW5fcmVxdWVzdHMiKSA9PSAwKSB7CisJCW9zX2ZyZWUoYnNzLT53cHNfcGluX3JlcXVlc3RzKTsKKwkJYnNzLT53cHNfcGluX3JlcXVlc3RzID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZGV2aWNlX25hbWUiKSA9PSAwKSB7CisJCWlmIChvc19zdHJsZW4ocG9zKSA+IDMyKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IFRvbyBsb25nICIKKwkJCQkgICAiZGV2aWNlX25hbWUiLCBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJCW9zX2ZyZWUoYnNzLT5kZXZpY2VfbmFtZSk7CisJCWJzcy0+ZGV2aWNlX25hbWUgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtYW51ZmFjdHVyZXIiKSA9PSAwKSB7CisJCWlmIChvc19zdHJsZW4ocG9zKSA+IDY0KSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IFRvbyBsb25nIG1hbnVmYWN0dXJlciIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlvc19mcmVlKGJzcy0+bWFudWZhY3R1cmVyKTsKKwkJYnNzLT5tYW51ZmFjdHVyZXIgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtb2RlbF9uYW1lIikgPT0gMCkgeworCQlpZiAob3Nfc3RybGVuKHBvcykgPiAzMikgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBUb28gbG9uZyBtb2RlbF9uYW1lIiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJCW9zX2ZyZWUoYnNzLT5tb2RlbF9uYW1lKTsKKwkJYnNzLT5tb2RlbF9uYW1lID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibW9kZWxfbnVtYmVyIikgPT0gMCkgeworCQlpZiAob3Nfc3RybGVuKHBvcykgPiAzMikgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBUb28gbG9uZyBtb2RlbF9udW1iZXIiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KKwkJb3NfZnJlZShic3MtPm1vZGVsX251bWJlcik7CisJCWJzcy0+bW9kZWxfbnVtYmVyID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAic2VyaWFsX251bWJlciIpID09IDApIHsKKwkJaWYgKG9zX3N0cmxlbihwb3MpID4gMzIpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogVG9vIGxvbmcgc2VyaWFsX251bWJlciIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlvc19mcmVlKGJzcy0+c2VyaWFsX251bWJlcik7CisJCWJzcy0+c2VyaWFsX251bWJlciA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImRldmljZV90eXBlIikgPT0gMCkgeworCQlpZiAod3BzX2Rldl90eXBlX3N0cjJiaW4ocG9zLCBic3MtPmRldmljZV90eXBlKSkKKwkJCXJldHVybiAxOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImNvbmZpZ19tZXRob2RzIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+Y29uZmlnX21ldGhvZHMpOworCQlic3MtPmNvbmZpZ19tZXRob2RzID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAib3NfdmVyc2lvbiIpID09IDApIHsKKwkJaWYgKGhleHN0cjJiaW4ocG9zLCBic3MtPm9zX3ZlcnNpb24sIDQpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgb3NfdmVyc2lvbiIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFwX3BpbiIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPmFwX3Bpbik7CisJCWJzcy0+YXBfcGluID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAic2tpcF9jcmVkX2J1aWxkIikgPT0gMCkgeworCQlic3MtPnNraXBfY3JlZF9idWlsZCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJleHRyYV9jcmVkIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+ZXh0cmFfY3JlZCk7CisJCWJzcy0+ZXh0cmFfY3JlZCA9ICh1OCAqKSBvc19yZWFkZmlsZShwb3MsICZic3MtPmV4dHJhX2NyZWRfbGVuKTsKKwkJaWYgKGJzcy0+ZXh0cmFfY3JlZCA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGNvdWxkIG5vdCByZWFkIENyZWRlbnRpYWxzIGZyb20gJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX2NyZWRfcHJvY2Vzc2luZyIpID09IDApIHsKKwkJYnNzLT53cHNfY3JlZF9wcm9jZXNzaW5nID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFwX3NldHRpbmdzIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+YXBfc2V0dGluZ3MpOworCQlic3MtPmFwX3NldHRpbmdzID0KKwkJCSh1OCAqKSBvc19yZWFkZmlsZShwb3MsICZic3MtPmFwX3NldHRpbmdzX2xlbik7CisJCWlmIChic3MtPmFwX3NldHRpbmdzID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogY291bGQgbm90IHJlYWQgQVAgU2V0dGluZ3MgZnJvbSAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ1cG5wX2lmYWNlIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+dXBucF9pZmFjZSk7CisJCWJzcy0+dXBucF9pZmFjZSA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImZyaWVuZGx5X25hbWUiKSA9PSAwKSB7CisJCW9zX2ZyZWUoYnNzLT5mcmllbmRseV9uYW1lKTsKKwkJYnNzLT5mcmllbmRseV9uYW1lID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWFudWZhY3R1cmVyX3VybCIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPm1hbnVmYWN0dXJlcl91cmwpOworCQlic3MtPm1hbnVmYWN0dXJlcl91cmwgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtb2RlbF9kZXNjcmlwdGlvbiIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPm1vZGVsX2Rlc2NyaXB0aW9uKTsKKwkJYnNzLT5tb2RlbF9kZXNjcmlwdGlvbiA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm1vZGVsX3VybCIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPm1vZGVsX3VybCk7CisJCWJzcy0+bW9kZWxfdXJsID0gb3Nfc3RyZHVwKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidXBjIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+dXBjKTsKKwkJYnNzLT51cGMgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJwYmNfaW5fbTEiKSA9PSAwKSB7CisJCWJzcy0+cGJjX2luX20xID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInNlcnZlcl9pZCIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPnNlcnZlcl9pZCk7CisJCWJzcy0+c2VydmVyX2lkID0gb3Nfc3RyZHVwKHBvcyk7CiAjaWZkZWYgQ09ORklHX1dQU19ORkMKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX25mY19kZXZfcHdfaWQiKSA9PSAwKSB7Ci0JCQlic3MtPndwc19uZmNfZGV2X3B3X2lkID0gYXRvaShwb3MpOwotCQkJaWYgKGJzcy0+d3BzX25mY19kZXZfcHdfaWQgPCAweDEwIHx8Ci0JCQkgICAgYnNzLT53cHNfbmZjX2Rldl9wd19pZCA+IDB4ZmZmZikgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJ3cHNfbmZjX2Rldl9wd19pZCB2YWx1ZSIsIGxpbmUpOwotCQkJCWVycm9ycysrOwotCQkJfQotCQkJYnNzLT53cHNfbmZjX3B3X2Zyb21fY29uZmlnID0gMTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX25mY19kaF9wdWJrZXkiKSA9PSAwKSB7Ci0JCQl3cGFidWZfZnJlZShic3MtPndwc19uZmNfZGhfcHVia2V5KTsKLQkJCWJzcy0+d3BzX25mY19kaF9wdWJrZXkgPSBob3N0YXBkX3BhcnNlX2Jpbihwb3MpOwotCQkJYnNzLT53cHNfbmZjX3B3X2Zyb21fY29uZmlnID0gMTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX25mY19kaF9wcml2a2V5IikgPT0gMCkgewotCQkJd3BhYnVmX2ZyZWUoYnNzLT53cHNfbmZjX2RoX3ByaXZrZXkpOwotCQkJYnNzLT53cHNfbmZjX2RoX3ByaXZrZXkgPSBob3N0YXBkX3BhcnNlX2Jpbihwb3MpOwotCQkJYnNzLT53cHNfbmZjX3B3X2Zyb21fY29uZmlnID0gMTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX25mY19kZXZfcHciKSA9PSAwKSB7Ci0JCQl3cGFidWZfZnJlZShic3MtPndwc19uZmNfZGV2X3B3KTsKLQkJCWJzcy0+d3BzX25mY19kZXZfcHcgPSBob3N0YXBkX3BhcnNlX2Jpbihwb3MpOwotCQkJYnNzLT53cHNfbmZjX3B3X2Zyb21fY29uZmlnID0gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cHNfbmZjX2Rldl9wd19pZCIpID09IDApIHsKKwkJYnNzLT53cHNfbmZjX2Rldl9wd19pZCA9IGF0b2kocG9zKTsKKwkJaWYgKGJzcy0+d3BzX25mY19kZXZfcHdfaWQgPCAweDEwIHx8CisJCSAgICBic3MtPndwc19uZmNfZGV2X3B3X2lkID4gMHhmZmZmKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgd3BzX25mY19kZXZfcHdfaWQgdmFsdWUiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KKwkJYnNzLT53cHNfbmZjX3B3X2Zyb21fY29uZmlnID0gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cHNfbmZjX2RoX3B1YmtleSIpID09IDApIHsKKwkJd3BhYnVmX2ZyZWUoYnNzLT53cHNfbmZjX2RoX3B1YmtleSk7CisJCWJzcy0+d3BzX25mY19kaF9wdWJrZXkgPSBob3N0YXBkX3BhcnNlX2Jpbihwb3MpOworCQlic3MtPndwc19uZmNfcHdfZnJvbV9jb25maWcgPSAxOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwc19uZmNfZGhfcHJpdmtleSIpID09IDApIHsKKwkJd3BhYnVmX2ZyZWUoYnNzLT53cHNfbmZjX2RoX3ByaXZrZXkpOworCQlic3MtPndwc19uZmNfZGhfcHJpdmtleSA9IGhvc3RhcGRfcGFyc2VfYmluKHBvcyk7CisJCWJzcy0+d3BzX25mY19wd19mcm9tX2NvbmZpZyA9IDE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX25mY19kZXZfcHciKSA9PSAwKSB7CisJCXdwYWJ1Zl9mcmVlKGJzcy0+d3BzX25mY19kZXZfcHcpOworCQlic3MtPndwc19uZmNfZGV2X3B3ID0gaG9zdGFwZF9wYXJzZV9iaW4ocG9zKTsKKwkJYnNzLT53cHNfbmZjX3B3X2Zyb21fY29uZmlnID0gMTsKICNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KICNpZmRlZiBDT05GSUdfUDJQX01BTkFHRVIKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWFuYWdlX3AycCIpID09IDApIHsKLQkJCWludCBtYW5hZ2UgPSBhdG9pKHBvcyk7Ci0JCQlpZiAobWFuYWdlKQotCQkJCWJzcy0+cDJwIHw9IFAyUF9NQU5BR0U7Ci0JCQllbHNlCi0JCQkJYnNzLT5wMnAgJj0gflAyUF9NQU5BR0U7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFsbG93X2Nyb3NzX2Nvbm5lY3Rpb24iKSA9PSAwKSB7Ci0JCQlpZiAoYXRvaShwb3MpKQotCQkJCWJzcy0+cDJwIHw9IFAyUF9BTExPV19DUk9TU19DT05ORUNUSU9OOwotCQkJZWxzZQotCQkJCWJzcy0+cDJwICY9IH5QMlBfQUxMT1dfQ1JPU1NfQ09OTkVDVElPTjsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtYW5hZ2VfcDJwIikgPT0gMCkgeworCQlpZiAoYXRvaShwb3MpKQorCQkJYnNzLT5wMnAgfD0gUDJQX01BTkFHRTsKKwkJZWxzZQorCQkJYnNzLT5wMnAgJj0gflAyUF9NQU5BR0U7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYWxsb3dfY3Jvc3NfY29ubmVjdGlvbiIpID09IDApIHsKKwkJaWYgKGF0b2kocG9zKSkKKwkJCWJzcy0+cDJwIHw9IFAyUF9BTExPV19DUk9TU19DT05ORUNUSU9OOworCQllbHNlCisJCQlic3MtPnAycCAmPSB+UDJQX0FMTE9XX0NST1NTX0NPTk5FQ1RJT047CiAjZW5kaWYgLyogQ09ORklHX1AyUF9NQU5BR0VSICovCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImRpc2Fzc29jX2xvd19hY2siKSA9PSAwKSB7Ci0JCQlic3MtPmRpc2Fzc29jX2xvd19hY2sgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRkbHNfcHJvaGliaXQiKSA9PSAwKSB7Ci0JCQlpbnQgdmFsID0gYXRvaShwb3MpOwotCQkJaWYgKHZhbCkKLQkJCQlic3MtPnRkbHMgfD0gVERMU19QUk9ISUJJVDsKLQkJCWVsc2UKLQkJCQlic3MtPnRkbHMgJj0gflRETFNfUFJPSElCSVQ7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRkbHNfcHJvaGliaXRfY2hhbl9zd2l0Y2giKSA9PSAwKSB7Ci0JCQlpbnQgdmFsID0gYXRvaShwb3MpOwotCQkJaWYgKHZhbCkKLQkJCQlic3MtPnRkbHMgfD0gVERMU19QUk9ISUJJVF9DSEFOX1NXSVRDSDsKLQkJCWVsc2UKLQkJCQlic3MtPnRkbHMgJj0gflRETFNfUFJPSElCSVRfQ0hBTl9TV0lUQ0g7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZGlzYXNzb2NfbG93X2FjayIpID09IDApIHsKKwkJYnNzLT5kaXNhc3NvY19sb3dfYWNrID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRkbHNfcHJvaGliaXQiKSA9PSAwKSB7CisJCWlmIChhdG9pKHBvcykpCisJCQlic3MtPnRkbHMgfD0gVERMU19QUk9ISUJJVDsKKwkJZWxzZQorCQkJYnNzLT50ZGxzICY9IH5URExTX1BST0hJQklUOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRkbHNfcHJvaGliaXRfY2hhbl9zd2l0Y2giKSA9PSAwKSB7CisJCWlmIChhdG9pKHBvcykpCisJCQlic3MtPnRkbHMgfD0gVERMU19QUk9ISUJJVF9DSEFOX1NXSVRDSDsKKwkJZWxzZQorCQkJYnNzLT50ZGxzICY9IH5URExTX1BST0hJQklUX0NIQU5fU1dJVENIOwogI2lmZGVmIENPTkZJR19SU05fVEVTVElORwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyc25fdGVzdGluZyIpID09IDApIHsKLQkJCWV4dGVybiBpbnQgcnNuX3Rlc3Rpbmc7Ci0JCQlyc25fdGVzdGluZyA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyc25fdGVzdGluZyIpID09IDApIHsKKwkJZXh0ZXJuIGludCByc25fdGVzdGluZzsKKwkJcnNuX3Rlc3RpbmcgPSBhdG9pKHBvcyk7CiAjZW5kaWYgLyogQ09ORklHX1JTTl9URVNUSU5HICovCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRpbWVfYWR2ZXJ0aXNlbWVudCIpID09IDApIHsKLQkJCWJzcy0+dGltZV9hZHZlcnRpc2VtZW50ID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ0aW1lX3pvbmUiKSA9PSAwKSB7Ci0JCQlzaXplX3QgdHpfbGVuID0gb3Nfc3RybGVuKHBvcyk7Ci0JCQlpZiAodHpfbGVuIDwgNCB8fCB0el9sZW4gPiAyNTUpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkxpbmUgJWQ6IGludmFsaWQgIgotCQkJCQkgICAidGltZV96b25lIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQkJcmV0dXJuIGVycm9yczsKLQkJCX0KLQkJCW9zX2ZyZWUoYnNzLT50aW1lX3pvbmUpOwotCQkJYnNzLT50aW1lX3pvbmUgPSBvc19zdHJkdXAocG9zKTsKLQkJCWlmIChic3MtPnRpbWVfem9uZSA9PSBOVUxMKQotCQkJCWVycm9ycysrOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInRpbWVfYWR2ZXJ0aXNlbWVudCIpID09IDApIHsKKwkJYnNzLT50aW1lX2FkdmVydGlzZW1lbnQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidGltZV96b25lIikgPT0gMCkgeworCQlzaXplX3QgdHpfbGVuID0gb3Nfc3RybGVuKHBvcyk7CisJCWlmICh0el9sZW4gPCA0IHx8IHR6X2xlbiA+IDI1NSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJMaW5lICVkOiBpbnZhbGlkIHRpbWVfem9uZSIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlvc19mcmVlKGJzcy0+dGltZV96b25lKTsKKwkJYnNzLT50aW1lX3pvbmUgPSBvc19zdHJkdXAocG9zKTsKKwkJaWYgKGJzcy0+dGltZV96b25lID09IE5VTEwpCisJCQlyZXR1cm4gMTsKICNpZmRlZiBDT05GSUdfV05NCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndubV9zbGVlcF9tb2RlIikgPT0gMCkgewotCQkJYnNzLT53bm1fc2xlZXBfbW9kZSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYnNzX3RyYW5zaXRpb24iKSA9PSAwKSB7Ci0JCQlic3MtPmJzc190cmFuc2l0aW9uID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndubV9zbGVlcF9tb2RlIikgPT0gMCkgeworCQlic3MtPndubV9zbGVlcF9tb2RlID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImJzc190cmFuc2l0aW9uIikgPT0gMCkgeworCQlic3MtPmJzc190cmFuc2l0aW9uID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIENPTkZJR19XTk0gKi8KICNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImludGVyd29ya2luZyIpID09IDApIHsKLQkJCWJzcy0+aW50ZXJ3b3JraW5nID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhY2Nlc3NfbmV0d29ya190eXBlIikgPT0gMCkgewotCQkJYnNzLT5hY2Nlc3NfbmV0d29ya190eXBlID0gYXRvaShwb3MpOwotCQkJaWYgKGJzcy0+YWNjZXNzX25ldHdvcmtfdHlwZSA8IDAgfHwKLQkJCSAgICBic3MtPmFjY2Vzc19uZXR3b3JrX3R5cGUgPiAxNSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCi0JCQkJCSAgICJhY2Nlc3NfbmV0d29ya190eXBlIiwgbGluZSk7Ci0JCQkJZXJyb3JzKys7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImludGVybmV0IikgPT0gMCkgewotCQkJYnNzLT5pbnRlcm5ldCA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXNyYSIpID09IDApIHsKLQkJCWJzcy0+YXNyYSA9IGF0b2kocG9zKTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZXNyIikgPT0gMCkgewotCQkJYnNzLT5lc3IgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInVlc2EiKSA9PSAwKSB7Ci0JCQlic3MtPnVlc2EgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZlbnVlX2dyb3VwIikgPT0gMCkgewotCQkJYnNzLT52ZW51ZV9ncm91cCA9IGF0b2kocG9zKTsKLQkJCWJzcy0+dmVudWVfaW5mb19zZXQgPSAxOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2ZW51ZV90eXBlIikgPT0gMCkgewotCQkJYnNzLT52ZW51ZV90eXBlID0gYXRvaShwb3MpOwotCQkJYnNzLT52ZW51ZV9pbmZvX3NldCA9IDE7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImhlc3NpZCIpID09IDApIHsKLQkJCWlmIChod2FkZHJfYXRvbihwb3MsIGJzcy0+aGVzc2lkKSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCi0JCQkJCSAgICJoZXNzaWQiLCBsaW5lKTsKLQkJCQllcnJvcnMrKzsKLQkJCX0KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicm9hbWluZ19jb25zb3J0aXVtIikgPT0gMCkgewotCQkJaWYgKHBhcnNlX3JvYW1pbmdfY29uc29ydGl1bShic3MsIHBvcywgbGluZSkgPCAwKQotCQkJCWVycm9ycysrOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2ZW51ZV9uYW1lIikgPT0gMCkgewotCQkJaWYgKHBhcnNlX3ZlbnVlX25hbWUoYnNzLCBwb3MsIGxpbmUpIDwgMCkKLQkJCQllcnJvcnMrKzsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibmV0d29ya19hdXRoX3R5cGUiKSA9PSAwKSB7Ci0JCQl1OCBhdXRoX3R5cGU7Ci0JCQl1MTYgcmVkaXJlY3RfdXJsX2xlbjsKLQkJCWlmIChoZXhzdHIyYmluKHBvcywgJmF1dGhfdHlwZSwgMSkpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgIgotCQkJCQkgICAibmV0d29ya19hdXRoX3R5cGUgJyVzJyIsCi0JCQkJCSAgIGxpbmUsIHBvcyk7Ci0JCQkJZXJyb3JzKys7Ci0JCQkJcmV0dXJuIGVycm9yczsKLQkJCX0KLQkJCWlmIChhdXRoX3R5cGUgPT0gMCB8fCBhdXRoX3R5cGUgPT0gMikKLQkJCQlyZWRpcmVjdF91cmxfbGVuID0gb3Nfc3RybGVuKHBvcyArIDIpOwotCQkJZWxzZQotCQkJCXJlZGlyZWN0X3VybF9sZW4gPSAwOwotCQkJb3NfZnJlZShic3MtPm5ldHdvcmtfYXV0aF90eXBlKTsKLQkJCWJzcy0+bmV0d29ya19hdXRoX3R5cGUgPQotCQkJCW9zX21hbGxvYyhyZWRpcmVjdF91cmxfbGVuICsgMyArIDEpOwotCQkJaWYgKGJzcy0+bmV0d29ya19hdXRoX3R5cGUgPT0gTlVMTCkgewotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9Ci0JCQkqYnNzLT5uZXR3b3JrX2F1dGhfdHlwZSA9IGF1dGhfdHlwZTsKLQkJCVdQQV9QVVRfTEUxNihic3MtPm5ldHdvcmtfYXV0aF90eXBlICsgMSwKLQkJCQkgICAgIHJlZGlyZWN0X3VybF9sZW4pOwotCQkJaWYgKHJlZGlyZWN0X3VybF9sZW4pCi0JCQkJb3NfbWVtY3B5KGJzcy0+bmV0d29ya19hdXRoX3R5cGUgKyAzLAotCQkJCQkgIHBvcyArIDIsIHJlZGlyZWN0X3VybF9sZW4pOwotCQkJYnNzLT5uZXR3b3JrX2F1dGhfdHlwZV9sZW4gPSAzICsgcmVkaXJlY3RfdXJsX2xlbjsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaXBhZGRyX3R5cGVfYXZhaWxhYmlsaXR5IikgPT0gMCkgewotCQkJaWYgKGhleHN0cjJiaW4ocG9zLCAmYnNzLT5pcGFkZHJfdHlwZV9hdmFpbGFiaWxpdHksIDEpKQotCQkJewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJpcGFkZHJfdHlwZV9hdmFpbGFiaWxpdHkgJyVzJyIsCi0JCQkJCSAgIGxpbmUsIHBvcyk7Ci0JCQkJYnNzLT5pcGFkZHJfdHlwZV9jb25maWd1cmVkID0gMDsKLQkJCQllcnJvcnMrKzsKLQkJCQlyZXR1cm4gZXJyb3JzOwotCQkJfQotCQkJYnNzLT5pcGFkZHJfdHlwZV9jb25maWd1cmVkID0gMTsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZG9tYWluX25hbWUiKSA9PSAwKSB7Ci0JCQlpbnQgaiwgbnVtX2RvbWFpbnMsIGRvbWFpbl9sZW4sIGRvbWFpbl9saXN0X2xlbiA9IDA7Ci0JCQljaGFyICp0b2tfc3RhcnQsICp0b2tfcHJldjsKLQkJCXU4ICpkb21haW5fbGlzdCwgKmRvbWFpbl9wdHI7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaW50ZXJ3b3JraW5nIikgPT0gMCkgeworCQlic3MtPmludGVyd29ya2luZyA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhY2Nlc3NfbmV0d29ya190eXBlIikgPT0gMCkgeworCQlic3MtPmFjY2Vzc19uZXR3b3JrX3R5cGUgPSBhdG9pKHBvcyk7CisJCWlmIChic3MtPmFjY2Vzc19uZXR3b3JrX3R5cGUgPCAwIHx8CisJCSAgICBic3MtPmFjY2Vzc19uZXR3b3JrX3R5cGUgPiAxNSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IGludmFsaWQgYWNjZXNzX25ldHdvcmtfdHlwZSIsCisJCQkJICAgbGluZSk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImludGVybmV0IikgPT0gMCkgeworCQlic3MtPmludGVybmV0ID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFzcmEiKSA9PSAwKSB7CisJCWJzcy0+YXNyYSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJlc3IiKSA9PSAwKSB7CisJCWJzcy0+ZXNyID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInVlc2EiKSA9PSAwKSB7CisJCWJzcy0+dWVzYSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2ZW51ZV9ncm91cCIpID09IDApIHsKKwkJYnNzLT52ZW51ZV9ncm91cCA9IGF0b2kocG9zKTsKKwkJYnNzLT52ZW51ZV9pbmZvX3NldCA9IDE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmVudWVfdHlwZSIpID09IDApIHsKKwkJYnNzLT52ZW51ZV90eXBlID0gYXRvaShwb3MpOworCQlic3MtPnZlbnVlX2luZm9fc2V0ID0gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJoZXNzaWQiKSA9PSAwKSB7CisJCWlmIChod2FkZHJfYXRvbihwb3MsIGJzcy0+aGVzc2lkKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGhlc3NpZCIsIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyb2FtaW5nX2NvbnNvcnRpdW0iKSA9PSAwKSB7CisJCWlmIChwYXJzZV9yb2FtaW5nX2NvbnNvcnRpdW0oYnNzLCBwb3MsIGxpbmUpIDwgMCkKKwkJCXJldHVybiAxOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZlbnVlX25hbWUiKSA9PSAwKSB7CisJCWlmIChwYXJzZV92ZW51ZV9uYW1lKGJzcywgcG9zLCBsaW5lKSA8IDApCisJCQlyZXR1cm4gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJuZXR3b3JrX2F1dGhfdHlwZSIpID09IDApIHsKKwkJdTggYXV0aF90eXBlOworCQl1MTYgcmVkaXJlY3RfdXJsX2xlbjsKKwkJaWYgKGhleHN0cjJiaW4ocG9zLCAmYXV0aF90eXBlLCAxKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IEludmFsaWQgbmV0d29ya19hdXRoX3R5cGUgJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCXJldHVybiAxOworCQl9CisJCWlmIChhdXRoX3R5cGUgPT0gMCB8fCBhdXRoX3R5cGUgPT0gMikKKwkJCXJlZGlyZWN0X3VybF9sZW4gPSBvc19zdHJsZW4ocG9zICsgMik7CisJCWVsc2UKKwkJCXJlZGlyZWN0X3VybF9sZW4gPSAwOworCQlvc19mcmVlKGJzcy0+bmV0d29ya19hdXRoX3R5cGUpOworCQlic3MtPm5ldHdvcmtfYXV0aF90eXBlID0gb3NfbWFsbG9jKHJlZGlyZWN0X3VybF9sZW4gKyAzICsgMSk7CisJCWlmIChic3MtPm5ldHdvcmtfYXV0aF90eXBlID09IE5VTEwpCisJCQlyZXR1cm4gMTsKKwkJKmJzcy0+bmV0d29ya19hdXRoX3R5cGUgPSBhdXRoX3R5cGU7CisJCVdQQV9QVVRfTEUxNihic3MtPm5ldHdvcmtfYXV0aF90eXBlICsgMSwgcmVkaXJlY3RfdXJsX2xlbik7CisJCWlmIChyZWRpcmVjdF91cmxfbGVuKQorCQkJb3NfbWVtY3B5KGJzcy0+bmV0d29ya19hdXRoX3R5cGUgKyAzLCBwb3MgKyAyLAorCQkJCSAgcmVkaXJlY3RfdXJsX2xlbik7CisJCWJzcy0+bmV0d29ya19hdXRoX3R5cGVfbGVuID0gMyArIHJlZGlyZWN0X3VybF9sZW47CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaXBhZGRyX3R5cGVfYXZhaWxhYmlsaXR5IikgPT0gMCkgeworCQlpZiAoaGV4c3RyMmJpbihwb3MsICZic3MtPmlwYWRkcl90eXBlX2F2YWlsYWJpbGl0eSwgMSkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBpcGFkZHJfdHlwZV9hdmFpbGFiaWxpdHkgJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCWJzcy0+aXBhZGRyX3R5cGVfY29uZmlndXJlZCA9IDA7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlic3MtPmlwYWRkcl90eXBlX2NvbmZpZ3VyZWQgPSAxOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImRvbWFpbl9uYW1lIikgPT0gMCkgeworCQlpbnQgaiwgbnVtX2RvbWFpbnMsIGRvbWFpbl9sZW4sIGRvbWFpbl9saXN0X2xlbiA9IDA7CisJCWNoYXIgKnRva19zdGFydCwgKnRva19wcmV2OworCQl1OCAqZG9tYWluX2xpc3QsICpkb21haW5fcHRyOwogCi0JCQlkb21haW5fbGlzdF9sZW4gPSBvc19zdHJsZW4ocG9zKSArIDE7Ci0JCQlkb21haW5fbGlzdCA9IG9zX21hbGxvYyhkb21haW5fbGlzdF9sZW4pOwotCQkJaWYgKGRvbWFpbl9saXN0ID09IE5VTEwpIHsKLQkJCQllcnJvcnMrKzsKLQkJCQlyZXR1cm4gZXJyb3JzOwotCQkJfQorCQlkb21haW5fbGlzdF9sZW4gPSBvc19zdHJsZW4ocG9zKSArIDE7CisJCWRvbWFpbl9saXN0ID0gb3NfbWFsbG9jKGRvbWFpbl9saXN0X2xlbik7CisJCWlmIChkb21haW5fbGlzdCA9PSBOVUxMKQorCQkJcmV0dXJuIDE7CiAKLQkJCWRvbWFpbl9wdHIgPSBkb21haW5fbGlzdDsKLQkJCXRva19wcmV2ID0gcG9zOwotCQkJbnVtX2RvbWFpbnMgPSAxOwotCQkJd2hpbGUgKCh0b2tfcHJldiA9IG9zX3N0cmNocih0b2tfcHJldiwgJywnKSkpIHsKLQkJCQludW1fZG9tYWlucysrOwotCQkJCXRva19wcmV2Kys7CisJCWRvbWFpbl9wdHIgPSBkb21haW5fbGlzdDsKKwkJdG9rX3ByZXYgPSBwb3M7CisJCW51bV9kb21haW5zID0gMTsKKwkJd2hpbGUgKCh0b2tfcHJldiA9IG9zX3N0cmNocih0b2tfcHJldiwgJywnKSkpIHsKKwkJCW51bV9kb21haW5zKys7CisJCQl0b2tfcHJldisrOworCQl9CisJCXRva19wcmV2ID0gcG9zOworCQlmb3IgKGogPSAwOyBqIDwgbnVtX2RvbWFpbnM7IGorKykgeworCQkJdG9rX3N0YXJ0ID0gb3Nfc3RyY2hyKHRva19wcmV2LCAnLCcpOworCQkJaWYgKHRva19zdGFydCkgeworCQkJCWRvbWFpbl9sZW4gPSB0b2tfc3RhcnQgLSB0b2tfcHJldjsKKwkJCQkqZG9tYWluX3B0ciA9IGRvbWFpbl9sZW47CisJCQkJb3NfbWVtY3B5KGRvbWFpbl9wdHIgKyAxLCB0b2tfcHJldiwgZG9tYWluX2xlbik7CisJCQkJZG9tYWluX3B0ciArPSBkb21haW5fbGVuICsgMTsKKwkJCQl0b2tfcHJldiA9ICsrdG9rX3N0YXJ0OworCQkJfSBlbHNlIHsKKwkJCQlkb21haW5fbGVuID0gb3Nfc3RybGVuKHRva19wcmV2KTsKKwkJCQkqZG9tYWluX3B0ciA9IGRvbWFpbl9sZW47CisJCQkJb3NfbWVtY3B5KGRvbWFpbl9wdHIgKyAxLCB0b2tfcHJldiwgZG9tYWluX2xlbik7CisJCQkJZG9tYWluX3B0ciArPSBkb21haW5fbGVuICsgMTsKIAkJCX0KLQkJCXRva19wcmV2ID0gcG9zOwotCQkJZm9yIChqID0gMDsgaiA8IG51bV9kb21haW5zOyBqKyspIHsKLQkJCQl0b2tfc3RhcnQgPSBvc19zdHJjaHIodG9rX3ByZXYsICcsJyk7Ci0JCQkJaWYgKHRva19zdGFydCkgewotCQkJCQlkb21haW5fbGVuID0gdG9rX3N0YXJ0IC0gdG9rX3ByZXY7Ci0JCQkJCSpkb21haW5fcHRyID0gZG9tYWluX2xlbjsKLQkJCQkJb3NfbWVtY3B5KGRvbWFpbl9wdHIgKyAxLCB0b2tfcHJldiwKLQkJCQkJCSAgZG9tYWluX2xlbik7Ci0JCQkJCWRvbWFpbl9wdHIgKz0gZG9tYWluX2xlbiArIDE7Ci0JCQkJCXRva19wcmV2ID0gKyt0b2tfc3RhcnQ7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJZG9tYWluX2xlbiA9IG9zX3N0cmxlbih0b2tfcHJldik7Ci0JCQkJCSpkb21haW5fcHRyID0gZG9tYWluX2xlbjsKLQkJCQkJb3NfbWVtY3B5KGRvbWFpbl9wdHIgKyAxLCB0b2tfcHJldiwKLQkJCQkJCSAgZG9tYWluX2xlbik7Ci0JCQkJCWRvbWFpbl9wdHIgKz0gZG9tYWluX2xlbiArIDE7Ci0JCQkJfQotCQkJfQorCQl9CiAKLQkJCW9zX2ZyZWUoYnNzLT5kb21haW5fbmFtZSk7Ci0JCQlic3MtPmRvbWFpbl9uYW1lID0gZG9tYWluX2xpc3Q7Ci0JCQlic3MtPmRvbWFpbl9uYW1lX2xlbiA9IGRvbWFpbl9saXN0X2xlbjsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYW5xcF8zZ3BwX2NlbGxfbmV0IikgPT0gMCkgewotCQkJaWYgKHBhcnNlXzNncHBfY2VsbF9uZXQoYnNzLCBwb3MsIGxpbmUpIDwgMCkKLQkJCQllcnJvcnMrKzsKLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibmFpX3JlYWxtIikgPT0gMCkgewotCQkJaWYgKHBhcnNlX25haV9yZWFsbShic3MsIHBvcywgbGluZSkgPCAwKQotCQkJCWVycm9ycysrOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJnYXNfZnJhZ19saW1pdCIpID09IDApIHsKLQkJCWJzcy0+Z2FzX2ZyYWdfbGltaXQgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImdhc19jb21lYmFja19kZWxheSIpID09IDApIHsKLQkJCWJzcy0+Z2FzX2NvbWViYWNrX2RlbGF5ID0gYXRvaShwb3MpOworCQlvc19mcmVlKGJzcy0+ZG9tYWluX25hbWUpOworCQlic3MtPmRvbWFpbl9uYW1lID0gZG9tYWluX2xpc3Q7CisJCWJzcy0+ZG9tYWluX25hbWVfbGVuID0gZG9tYWluX2xpc3RfbGVuOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImFucXBfM2dwcF9jZWxsX25ldCIpID09IDApIHsKKwkJaWYgKHBhcnNlXzNncHBfY2VsbF9uZXQoYnNzLCBwb3MsIGxpbmUpIDwgMCkKKwkJCXJldHVybiAxOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm5haV9yZWFsbSIpID09IDApIHsKKwkJaWYgKHBhcnNlX25haV9yZWFsbShic3MsIHBvcywgbGluZSkgPCAwKQorCQkJcmV0dXJuIDE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZ2FzX2ZyYWdfbGltaXQiKSA9PSAwKSB7CisJCWJzcy0+Z2FzX2ZyYWdfbGltaXQgPSBhdG9pKHBvcyk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZ2FzX2NvbWViYWNrX2RlbGF5IikgPT0gMCkgeworCQlic3MtPmdhc19jb21lYmFja19kZWxheSA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJxb3NfbWFwX3NldCIpID09IDApIHsKKwkJaWYgKHBhcnNlX3Fvc19tYXBfc2V0KGJzcywgcG9zLCBsaW5lKSA8IDApCisJCQlyZXR1cm4gMTsKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAjaWZkZWYgQ09ORklHX1JBRElVU19URVNUCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImR1bXBfbXNrX2ZpbGUiKSA9PSAwKSB7Ci0JCQlvc19mcmVlKGJzcy0+ZHVtcF9tc2tfZmlsZSk7Ci0JCQlic3MtPmR1bXBfbXNrX2ZpbGUgPSBvc19zdHJkdXAocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkdW1wX21za19maWxlIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+ZHVtcF9tc2tfZmlsZSk7CisJCWJzcy0+ZHVtcF9tc2tfZmlsZSA9IG9zX3N0cmR1cChwb3MpOwogI2VuZGlmIC8qIENPTkZJR19SQURJVVNfVEVTVCAqLwogI2lmZGVmIENPTkZJR19IUzIwCi0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImhzMjAiKSA9PSAwKSB7Ci0JCQlic3MtPmhzMjAgPSBhdG9pKHBvcyk7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImRpc2FibGVfZGdhZiIpID09IDApIHsKLQkJCWJzcy0+ZGlzYWJsZV9kZ2FmID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJoczIwX29wZXJfZnJpZW5kbHlfbmFtZSIpID09IDApIHsKLQkJCWlmIChoczIwX3BhcnNlX29wZXJfZnJpZW5kbHlfbmFtZShic3MsIHBvcywgbGluZSkgPCAwKQotCQkJCWVycm9ycysrOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJoczIwX3dhbl9tZXRyaWNzIikgPT0gMCkgewotCQkJaWYgKGhzMjBfcGFyc2Vfd2FuX21ldHJpY3MoYnNzLCBwb3MsIGxpbmUpIDwgMCkgewotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImhzMjBfY29ubl9jYXBhYiIpID09IDApIHsKLQkJCWlmIChoczIwX3BhcnNlX2Nvbm5fY2FwYWIoYnNzLCBwb3MsIGxpbmUpIDwgMCkgewotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImhzMjBfb3BlcmF0aW5nX2NsYXNzIikgPT0gMCkgewotCQkJdTggKm9wZXJfY2xhc3M7Ci0JCQlzaXplX3Qgb3Blcl9jbGFzc19sZW47Ci0JCQlvcGVyX2NsYXNzX2xlbiA9IG9zX3N0cmxlbihwb3MpOwotCQkJaWYgKG9wZXJfY2xhc3NfbGVuIDwgMiB8fCAob3Blcl9jbGFzc19sZW4gJiAweDAxKSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJoczIwX29wZXJhdGluZ19jbGFzcyAnJXMnIiwKLQkJCQkJICAgbGluZSwgcG9zKTsKLQkJCQllcnJvcnMrKzsKLQkJCQlyZXR1cm4gZXJyb3JzOwotCQkJfQotCQkJb3Blcl9jbGFzc19sZW4gLz0gMjsKLQkJCW9wZXJfY2xhc3MgPSBvc19tYWxsb2Mob3Blcl9jbGFzc19sZW4pOwotCQkJaWYgKG9wZXJfY2xhc3MgPT0gTlVMTCkgewotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9Ci0JCQlpZiAoaGV4c3RyMmJpbihwb3MsIG9wZXJfY2xhc3MsIG9wZXJfY2xhc3NfbGVuKSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJoczIwX29wZXJhdGluZ19jbGFzcyAnJXMnIiwKLQkJCQkJICAgbGluZSwgcG9zKTsKLQkJCQlvc19mcmVlKG9wZXJfY2xhc3MpOwotCQkJCWVycm9ycysrOwotCQkJCXJldHVybiBlcnJvcnM7Ci0JCQl9Ci0JCQlvc19mcmVlKGJzcy0+aHMyMF9vcGVyYXRpbmdfY2xhc3MpOwotCQkJYnNzLT5oczIwX29wZXJhdGluZ19jbGFzcyA9IG9wZXJfY2xhc3M7Ci0JCQlic3MtPmhzMjBfb3BlcmF0aW5nX2NsYXNzX2xlbiA9IG9wZXJfY2xhc3NfbGVuOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImhzMjAiKSA9PSAwKSB7CisJCWJzcy0+aHMyMCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkaXNhYmxlX2RnYWYiKSA9PSAwKSB7CisJCWJzcy0+ZGlzYWJsZV9kZ2FmID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm9zZW4iKSA9PSAwKSB7CisJCWJzcy0+b3NlbiA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJhbnFwX2RvbWFpbl9pZCIpID09IDApIHsKKwkJYnNzLT5hbnFwX2RvbWFpbl9pZCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJoczIwX2RlYXV0aF9yZXFfdGltZW91dCIpID09IDApIHsKKwkJYnNzLT5oczIwX2RlYXV0aF9yZXFfdGltZW91dCA9IGF0b2kocG9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJoczIwX29wZXJfZnJpZW5kbHlfbmFtZSIpID09IDApIHsKKwkJaWYgKGhzMjBfcGFyc2Vfb3Blcl9mcmllbmRseV9uYW1lKGJzcywgcG9zLCBsaW5lKSA8IDApCisJCQlyZXR1cm4gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJoczIwX3dhbl9tZXRyaWNzIikgPT0gMCkgeworCQlpZiAoaHMyMF9wYXJzZV93YW5fbWV0cmljcyhic3MsIHBvcywgbGluZSkgPCAwKQorCQkJcmV0dXJuIDE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaHMyMF9jb25uX2NhcGFiIikgPT0gMCkgeworCQlpZiAoaHMyMF9wYXJzZV9jb25uX2NhcGFiKGJzcywgcG9zLCBsaW5lKSA8IDApIHsKKwkJCXJldHVybiAxOworCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiaHMyMF9vcGVyYXRpbmdfY2xhc3MiKSA9PSAwKSB7CisJCXU4ICpvcGVyX2NsYXNzOworCQlzaXplX3Qgb3Blcl9jbGFzc19sZW47CisJCW9wZXJfY2xhc3NfbGVuID0gb3Nfc3RybGVuKHBvcyk7CisJCWlmIChvcGVyX2NsYXNzX2xlbiA8IDIgfHwgKG9wZXJfY2xhc3NfbGVuICYgMHgwMSkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJMaW5lICVkOiBJbnZhbGlkIGhzMjBfb3BlcmF0aW5nX2NsYXNzICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlvcGVyX2NsYXNzX2xlbiAvPSAyOworCQlvcGVyX2NsYXNzID0gb3NfbWFsbG9jKG9wZXJfY2xhc3NfbGVuKTsKKwkJaWYgKG9wZXJfY2xhc3MgPT0gTlVMTCkKKwkJCXJldHVybiAxOworCQlpZiAoaGV4c3RyMmJpbihwb3MsIG9wZXJfY2xhc3MsIG9wZXJfY2xhc3NfbGVuKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IEludmFsaWQgaHMyMF9vcGVyYXRpbmdfY2xhc3MgJyVzJyIsCisJCQkJICAgbGluZSwgcG9zKTsKKwkJCW9zX2ZyZWUob3Blcl9jbGFzcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlvc19mcmVlKGJzcy0+aHMyMF9vcGVyYXRpbmdfY2xhc3MpOworCQlic3MtPmhzMjBfb3BlcmF0aW5nX2NsYXNzID0gb3Blcl9jbGFzczsKKwkJYnNzLT5oczIwX29wZXJhdGluZ19jbGFzc19sZW4gPSBvcGVyX2NsYXNzX2xlbjsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJoczIwX2ljb24iKSA9PSAwKSB7CisJCWlmIChoczIwX3BhcnNlX2ljb24oYnNzLCBwb3MpIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkIGhzMjBfaWNvbiAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJvc3Vfc3NpZCIpID09IDApIHsKKwkJaWYgKGhzMjBfcGFyc2Vfb3N1X3NzaWQoYnNzLCBwb3MsIGxpbmUpIDwgMCkKKwkJCXJldHVybiAxOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIm9zdV9zZXJ2ZXJfdXJpIikgPT0gMCkgeworCQlpZiAoaHMyMF9wYXJzZV9vc3Vfc2VydmVyX3VyaShic3MsIHBvcywgbGluZSkgPCAwKQorCQkJcmV0dXJuIDE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAib3N1X2ZyaWVuZGx5X25hbWUiKSA9PSAwKSB7CisJCWlmIChoczIwX3BhcnNlX29zdV9mcmllbmRseV9uYW1lKGJzcywgcG9zLCBsaW5lKSA8IDApCisJCQlyZXR1cm4gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJvc3VfbmFpIikgPT0gMCkgeworCQlpZiAoaHMyMF9wYXJzZV9vc3VfbmFpKGJzcywgcG9zLCBsaW5lKSA8IDApCisJCQlyZXR1cm4gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJvc3VfbWV0aG9kX2xpc3QiKSA9PSAwKSB7CisJCWlmIChoczIwX3BhcnNlX29zdV9tZXRob2RfbGlzdChic3MsIHBvcywgbGluZSkgPCAwKQorCQkJcmV0dXJuIDE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAib3N1X2ljb24iKSA9PSAwKSB7CisJCWlmIChoczIwX3BhcnNlX29zdV9pY29uKGJzcywgcG9zLCBsaW5lKSA8IDApCisJCQlyZXR1cm4gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJvc3Vfc2VydmljZV9kZXNjIikgPT0gMCkgeworCQlpZiAoaHMyMF9wYXJzZV9vc3Vfc2VydmljZV9kZXNjKGJzcywgcG9zLCBsaW5lKSA8IDApCisJCQlyZXR1cm4gMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzdWJzY3JfcmVtZWRpYXRpb25fdXJsIikgPT0gMCkgeworCQlvc19mcmVlKGJzcy0+c3Vic2NyX3JlbWVkaWF0aW9uX3VybCk7CisJCWJzcy0+c3Vic2NyX3JlbWVkaWF0aW9uX3VybCA9IG9zX3N0cmR1cChwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInN1YnNjcl9yZW1lZGlhdGlvbl9tZXRob2QiKSA9PSAwKSB7CisJCWJzcy0+c3Vic2NyX3JlbWVkaWF0aW9uX21ldGhvZCA9IGF0b2kocG9zKTsKICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKLSNkZWZpbmUgUEFSU0VfVEVTVF9QUk9CQUJJTElUWShfdmFsKQkJCQkJXAotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICNfdmFsKSA9PSAwKSB7CQlcCi0JCQljaGFyICplbmQ7CQkJCQlcCi0JCQkJCQkJCQlcCi0JCQljb25mLT5fdmFsID0gc3RydG9kKHBvcywgJmVuZCk7CQkJXAotCQkJaWYgKCplbmQgfHwgY29uZi0+X3ZhbCA8IDAuMGQgfHwJCVwKLQkJCSAgICBjb25mLT5fdmFsID4gMS4wZCkgewkJCVwKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwJCQlcCi0JCQkJCSAgICJMaW5lICVkOiBJbnZhbGlkIHZhbHVlICclcyciLCBcCi0JCQkJCSAgIGxpbmUsIHBvcyk7CQkJXAotCQkJCWVycm9ycysrOwkJCQlcCi0JCQkJcmV0dXJuIGVycm9yczsJCQkJXAotCQkJfQotCQlQQVJTRV9URVNUX1BST0JBQklMSVRZKGlnbm9yZV9wcm9iZV9wcm9iYWJpbGl0eSkKLQkJUEFSU0VfVEVTVF9QUk9CQUJJTElUWShpZ25vcmVfYXV0aF9wcm9iYWJpbGl0eSkKLQkJUEFSU0VfVEVTVF9QUk9CQUJJTElUWShpZ25vcmVfYXNzb2NfcHJvYmFiaWxpdHkpCi0JCVBBUlNFX1RFU1RfUFJPQkFCSUxJVFkoaWdub3JlX3JlYXNzb2NfcHJvYmFiaWxpdHkpCi0JCVBBUlNFX1RFU1RfUFJPQkFCSUxJVFkoY29ycnVwdF9ndGtfcmVrZXlfbWljX3Byb2JhYmlsaXR5KQotI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KLQkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmVuZG9yX2VsZW1lbnRzIikgPT0gMCkgewotCQkJc3RydWN0IHdwYWJ1ZiAqZWxlbXM7Ci0JCQlzaXplX3QgbGVuID0gb3Nfc3RybGVuKHBvcyk7Ci0JCQlpZiAobGVuICYgMHgwMSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJ2ZW5kb3JfZWxlbWVudHMgJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJcmV0dXJuIDE7Ci0JCQl9Ci0JCQlsZW4gLz0gMjsKLQkJCWlmIChsZW4gPT0gMCkgewotCQkJCXdwYWJ1Zl9mcmVlKGJzcy0+dmVuZG9yX2VsZW1lbnRzKTsKLQkJCQlic3MtPnZlbmRvcl9lbGVtZW50cyA9IE5VTEw7Ci0JCQkJcmV0dXJuIDA7Ci0JCQl9Ci0KLQkJCWVsZW1zID0gd3BhYnVmX2FsbG9jKGxlbik7Ci0JCQlpZiAoZWxlbXMgPT0gTlVMTCkKLQkJCQlyZXR1cm4gMTsKLQotCQkJaWYgKGhleHN0cjJiaW4ocG9zLCB3cGFidWZfcHV0KGVsZW1zLCBsZW4pLCBsZW4pKSB7Ci0JCQkJd3BhYnVmX2ZyZWUoZWxlbXMpOwotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCAiCi0JCQkJCSAgICJ2ZW5kb3JfZWxlbWVudHMgJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJcmV0dXJuIDE7Ci0JCQl9Ci0KLQkJCXdwYWJ1Zl9mcmVlKGJzcy0+dmVuZG9yX2VsZW1lbnRzKTsKLQkJCWJzcy0+dmVuZG9yX2VsZW1lbnRzID0gZWxlbXM7Ci0JCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInNhZV9hbnRpX2Nsb2dnaW5nX3RocmVzaG9sZCIpID09IDApIHsKLQkJCWJzcy0+c2FlX2FudGlfY2xvZ2dpbmdfdGhyZXNob2xkID0gYXRvaShwb3MpOwotCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzYWVfZ3JvdXBzIikgPT0gMCkgewotCQkJaWYgKGhvc3RhcGRfcGFyc2VfaW50bGlzdCgmYnNzLT5zYWVfZ3JvdXBzLCBwb3MpKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkICIKLQkJCQkJICAgInNhZV9ncm91cHMgdmFsdWUgJyVzJyIsIGxpbmUsIHBvcyk7Ci0JCQkJcmV0dXJuIDE7Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IHVua25vd24gY29uZmlndXJhdGlvbiAiCi0JCQkJICAgIml0ZW0gJyVzJyIsIGxpbmUsIGJ1Zik7Ci0JCQllcnJvcnMrKzsKKyNkZWZpbmUgUEFSU0VfVEVTVF9QUk9CQUJJTElUWShfdmFsKQkJCQlcCisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAjX3ZhbCkgPT0gMCkgewkJXAorCQljaGFyICplbmQ7CQkJCQlcCisJCQkJCQkJCVwKKwkJY29uZi0+X3ZhbCA9IHN0cnRvZChwb3MsICZlbmQpOwkJCVwKKwkJaWYgKCplbmQgfHwgY29uZi0+X3ZhbCA8IDAuMCB8fAkJCVwKKwkJICAgIGNvbmYtPl92YWwgPiAxLjApIHsJCQkJXAorCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCQkJXAorCQkJCSAgICJMaW5lICVkOiBJbnZhbGlkIHZhbHVlICclcyciLCBcCisJCQkJICAgbGluZSwgcG9zKTsJCQlcCisJCQlyZXR1cm4gMTsJCQkJXAogCQl9Ci0JfQorCVBBUlNFX1RFU1RfUFJPQkFCSUxJVFkoaWdub3JlX3Byb2JlX3Byb2JhYmlsaXR5KQorCVBBUlNFX1RFU1RfUFJPQkFCSUxJVFkoaWdub3JlX2F1dGhfcHJvYmFiaWxpdHkpCisJUEFSU0VfVEVTVF9QUk9CQUJJTElUWShpZ25vcmVfYXNzb2NfcHJvYmFiaWxpdHkpCisJUEFSU0VfVEVTVF9QUk9CQUJJTElUWShpZ25vcmVfcmVhc3NvY19wcm9iYWJpbGl0eSkKKwlQQVJTRV9URVNUX1BST0JBQklMSVRZKGNvcnJ1cHRfZ3RrX3Jla2V5X21pY19wcm9iYWJpbGl0eSkKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJic3NfbG9hZF90ZXN0IikgPT0gMCkgeworCQlXUEFfUFVUX0xFMTYoYnNzLT5ic3NfbG9hZF90ZXN0LCBhdG9pKHBvcykpOworCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnOicpOworCQlpZiAocG9zID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBic3NfbG9hZF90ZXN0IiwKKwkJCQkgICBsaW5lKTsKKwkJCXJldHVybiAxOworCQl9CisJCXBvcysrOworCQlic3MtPmJzc19sb2FkX3Rlc3RbMl0gPSBhdG9pKHBvcyk7CisJCXBvcyA9IG9zX3N0cmNocihwb3MsICc6Jyk7CisJCWlmIChwb3MgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkIGJzc19sb2FkX3Rlc3QiLAorCQkJCSAgIGxpbmUpOworCQkJcmV0dXJuIDE7CisJCX0KKwkJcG9zKys7CisJCVdQQV9QVVRfTEUxNigmYnNzLT5ic3NfbG9hZF90ZXN0WzNdLCBhdG9pKHBvcykpOworCQlic3MtPmJzc19sb2FkX3Rlc3Rfc2V0ID0gMTsKKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAidmVuZG9yX2VsZW1lbnRzIikgPT0gMCkgeworCQlzdHJ1Y3Qgd3BhYnVmICplbGVtczsKKwkJc2l6ZV90IGxlbiA9IG9zX3N0cmxlbihwb3MpOworCQlpZiAobGVuICYgMHgwMSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IEludmFsaWQgdmVuZG9yX2VsZW1lbnRzICclcyciLAorCQkJCSAgIGxpbmUsIHBvcyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQlsZW4gLz0gMjsKKwkJaWYgKGxlbiA9PSAwKSB7CisJCQl3cGFidWZfZnJlZShic3MtPnZlbmRvcl9lbGVtZW50cyk7CisJCQlic3MtPnZlbmRvcl9lbGVtZW50cyA9IE5VTEw7CisJCQlyZXR1cm4gMDsKKwkJfQogCi0JcmV0dXJuIGVycm9yczsKLX0KKwkJZWxlbXMgPSB3cGFidWZfYWxsb2MobGVuKTsKKwkJaWYgKGVsZW1zID09IE5VTEwpCisJCQlyZXR1cm4gMTsKIAorCQlpZiAoaGV4c3RyMmJpbihwb3MsIHdwYWJ1Zl9wdXQoZWxlbXMsIGxlbiksIGxlbikpIHsKKwkJCXdwYWJ1Zl9mcmVlKGVsZW1zKTsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJMaW5lICVkOiBJbnZhbGlkIHZlbmRvcl9lbGVtZW50cyAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KIAotc3RhdGljIHZvaWQgaG9zdGFwZF9zZXRfc2VjdXJpdHlfcGFyYW1zKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcykKLXsKLQlpZiAoYnNzLT5pbmRpdmlkdWFsX3dlcF9rZXlfbGVuID09IDApIHsKLQkJLyogaW5kaXZpZHVhbCBrZXlzIGFyZSBub3QgdXNlOyBjYW4gdXNlIGtleSBpZHgwIGZvcgotCQkgKiBicm9hZGNhc3Qga2V5cyAqLwotCQlic3MtPmJyb2FkY2FzdF9rZXlfaWR4X21pbiA9IDA7Ci0JfQotCi0JaWYgKChic3MtPndwYSAmIDIpICYmIGJzcy0+cnNuX3BhaXJ3aXNlID09IDApCi0JCWJzcy0+cnNuX3BhaXJ3aXNlID0gYnNzLT53cGFfcGFpcndpc2U7Ci0JYnNzLT53cGFfZ3JvdXAgPSB3cGFfc2VsZWN0X2FwX2dyb3VwX2NpcGhlcihic3MtPndwYSwgYnNzLT53cGFfcGFpcndpc2UsCi0JCQkJCQkgICAgYnNzLT5yc25fcGFpcndpc2UpOwotCi0JYnNzLT5yYWRpdXMtPmF1dGhfc2VydmVyID0gYnNzLT5yYWRpdXMtPmF1dGhfc2VydmVyczsKLQlic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXIgPSBic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXJzOwotCi0JaWYgKGJzcy0+d3BhICYmIGJzcy0+aWVlZTgwMl8xeCkgewotCQlic3MtPnNzaWQuc2VjdXJpdHlfcG9saWN5ID0gU0VDVVJJVFlfV1BBOwotCX0gZWxzZSBpZiAoYnNzLT53cGEpIHsKLQkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX1dQQV9QU0s7Ci0JfSBlbHNlIGlmIChic3MtPmllZWU4MDJfMXgpIHsKLQkJaW50IGNpcGhlciA9IFdQQV9DSVBIRVJfTk9ORTsKLQkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX0lFRUVfODAyXzFYOwotCQlic3MtPnNzaWQud2VwLmRlZmF1bHRfbGVuID0gYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuOwotCQlpZiAoYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuKQotCQkJY2lwaGVyID0gYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuID49IDEzID8KLQkJCQlXUEFfQ0lQSEVSX1dFUDEwNCA6IFdQQV9DSVBIRVJfV0VQNDA7Ci0JCWJzcy0+d3BhX2dyb3VwID0gY2lwaGVyOwotCQlic3MtPndwYV9wYWlyd2lzZSA9IGNpcGhlcjsKLQkJYnNzLT5yc25fcGFpcndpc2UgPSBjaXBoZXI7Ci0JfSBlbHNlIGlmIChic3MtPnNzaWQud2VwLmtleXNfc2V0KSB7Ci0JCWludCBjaXBoZXIgPSBXUEFfQ0lQSEVSX1dFUDQwOwotCQlpZiAoYnNzLT5zc2lkLndlcC5sZW5bMF0gPj0gMTMpCi0JCQljaXBoZXIgPSBXUEFfQ0lQSEVSX1dFUDEwNDsKLQkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX1NUQVRJQ19XRVA7Ci0JCWJzcy0+d3BhX2dyb3VwID0gY2lwaGVyOwotCQlic3MtPndwYV9wYWlyd2lzZSA9IGNpcGhlcjsKLQkJYnNzLT5yc25fcGFpcndpc2UgPSBjaXBoZXI7CisJCXdwYWJ1Zl9mcmVlKGJzcy0+dmVuZG9yX2VsZW1lbnRzKTsKKwkJYnNzLT52ZW5kb3JfZWxlbWVudHMgPSBlbGVtczsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzYWVfYW50aV9jbG9nZ2luZ190aHJlc2hvbGQiKSA9PSAwKSB7CisJCWJzcy0+c2FlX2FudGlfY2xvZ2dpbmdfdGhyZXNob2xkID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInNhZV9ncm91cHMiKSA9PSAwKSB7CisJCWlmIChob3N0YXBkX3BhcnNlX2ludGxpc3QoJmJzcy0+c2FlX2dyb3VwcywgcG9zKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkxpbmUgJWQ6IEludmFsaWQgc2FlX2dyb3VwcyB2YWx1ZSAnJXMnIiwKKwkJCQkgICBsaW5lLCBwb3MpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJsb2NhbF9wd3JfY29uc3RyYWludCIpID09IDApIHsKKwkJaW50IHZhbCA9IGF0b2kocG9zKTsKKwkJaWYgKHZhbCA8IDAgfHwgdmFsID4gMjU1KSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgbG9jYWxfcHdyX2NvbnN0cmFpbnQgJWQgKGV4cGVjdGVkIDAuLjI1NSkiLAorCQkJCSAgIGxpbmUsIHZhbCk7CisJCQlyZXR1cm4gMTsKKwkJfQorCQljb25mLT5sb2NhbF9wd3JfY29uc3RyYWludCA9IHZhbDsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJzcGVjdHJ1bV9tZ210X3JlcXVpcmVkIikgPT0gMCkgeworCQljb25mLT5zcGVjdHJ1bV9tZ210X3JlcXVpcmVkID0gYXRvaShwb3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndvd2xhbl90cmlnZ2VycyIpID09IDApIHsKKwkJb3NfZnJlZShic3MtPndvd2xhbl90cmlnZ2Vycyk7CisJCWJzcy0+d293bGFuX3RyaWdnZXJzID0gb3Nfc3RyZHVwKHBvcyk7CiAJfSBlbHNlIHsKLQkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX1BMQUlOVEVYVDsKLQkJYnNzLT53cGFfZ3JvdXAgPSBXUEFfQ0lQSEVSX05PTkU7Ci0JCWJzcy0+d3BhX3BhaXJ3aXNlID0gV1BBX0NJUEhFUl9OT05FOwotCQlic3MtPnJzbl9wYWlyd2lzZSA9IFdQQV9DSVBIRVJfTk9ORTsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiTGluZSAlZDogdW5rbm93biBjb25maWd1cmF0aW9uIGl0ZW0gJyVzJyIsCisJCQkgICBsaW5lLCBidWYpOworCQlyZXR1cm4gMTsKIAl9CisKKwlyZXR1cm4gMDsKIH0KIAogCkBAIC0zMDc5LDcgKzMyMDcsNyBAQAogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlic3MgPSBjb25mLT5sYXN0X2JzcyA9IGNvbmYtPmJzczsKKwlic3MgPSBjb25mLT5sYXN0X2JzcyA9IGNvbmYtPmJzc1swXTsKIAogCXdoaWxlIChmZ2V0cyhidWYsIHNpemVvZihidWYpLCBmKSkgewogCQlic3MgPSBjb25mLT5sYXN0X2JzczsKQEAgLTMxMTMsOSArMzI0MSw5IEBACiAJZmNsb3NlKGYpOwogCiAJZm9yIChpID0gMDsgaSA8IGNvbmYtPm51bV9ic3M7IGkrKykKLQkJaG9zdGFwZF9zZXRfc2VjdXJpdHlfcGFyYW1zKCZjb25mLT5ic3NbaV0pOworCQlob3N0YXBkX3NldF9zZWN1cml0eV9wYXJhbXMoY29uZi0+YnNzW2ldLCAxKTsKIAotCWlmIChob3N0YXBkX2NvbmZpZ19jaGVjayhjb25mKSkKKwlpZiAoaG9zdGFwZF9jb25maWdfY2hlY2soY29uZiwgMSkpCiAJCWVycm9ycysrOwogCiAjaWZuZGVmIFdQQV9JR05PUkVfQ09ORklHX0VSUk9SUwpAQCAtMzE0NSw5ICszMjczLDkgQEAKIAl9CiAKIAlmb3IgKGkgPSAwOyBpIDwgY29uZi0+bnVtX2JzczsgaSsrKQotCQlob3N0YXBkX3NldF9zZWN1cml0eV9wYXJhbXMoJmNvbmYtPmJzc1tpXSk7CisJCWhvc3RhcGRfc2V0X3NlY3VyaXR5X3BhcmFtcyhjb25mLT5ic3NbaV0sIDApOwogCi0JaWYgKGhvc3RhcGRfY29uZmlnX2NoZWNrKGNvbmYpKSB7CisJaWYgKGhvc3RhcGRfY29uZmlnX2NoZWNrKGNvbmYsIDApKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ29uZmlndXJhdGlvbiBjaGVjayBmYWlsZWQiKTsKIAkJcmV0dXJuIC0xOwogCX0KZGlmZiAtLWdpdCBhL2hvc3RhcGQvY3RybF9pZmFjZS5jIGIvaG9zdGFwZC9jdHJsX2lmYWNlLmMKaW5kZXggYmU5NDFjNC4uOWNlNzgyOSAxMDA2NDQKLS0tIGEvaG9zdGFwZC9jdHJsX2lmYWNlLmMKKysrIGIvaG9zdGFwZC9jdHJsX2lmYWNlLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAvIFVOSVggZG9tYWluIHNvY2tldCAtYmFzZWQgY29udHJvbCBpbnRlcmZhY2UKLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTIwLDYgKzIwLDcgQEAKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCiAjaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKICNpbmNsdWRlICJyYWRpdXMvcmFkaXVzX2NsaWVudC5oIgorI2luY2x1ZGUgInJhZGl1cy9yYWRpdXNfc2VydmVyLmgiCiAjaW5jbHVkZSAiYXAvaG9zdGFwZC5oIgogI2luY2x1ZGUgImFwL2FwX2NvbmZpZy5oIgogI2luY2x1ZGUgImFwL2llZWU4MDJfMXguaCIKQEAgLTI5LDYgKzMwLDggQEAKICNpbmNsdWRlICJhcC93cHNfaG9zdGFwZC5oIgogI2luY2x1ZGUgImFwL2N0cmxfaWZhY2VfYXAuaCIKICNpbmNsdWRlICJhcC9hcF9kcnZfb3BzLmgiCisjaW5jbHVkZSAiYXAvaHMyMC5oIgorI2luY2x1ZGUgImFwL3dubV9hcC5oIgogI2luY2x1ZGUgImFwL3dwYV9hdXRoLmgiCiAjaW5jbHVkZSAid3BzL3dwc19kZWZzLmgiCiAjaW5jbHVkZSAid3BzL3dwcy5oIgpAQCAtODIsMTUgKzg1LDE1IEBACiAJCSAgICBvc19tZW1jbXAoZnJvbS0+c3VuX3BhdGgsIGRzdC0+YWRkci5zdW5fcGF0aCwKIAkJCSAgICAgIGZyb21sZW4gLSBvZmZzZXRvZihzdHJ1Y3Qgc29ja2FkZHJfdW4sIHN1bl9wYXRoKSkKIAkJICAgID09IDApIHsKKwkJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgbW9uaXRvciBkZXRhY2hlZCIsCisJCQkJICAgICh1OCAqKSBmcm9tLT5zdW5fcGF0aCwKKwkJCQkgICAgZnJvbWxlbiAtCisJCQkJICAgIG9mZnNldG9mKHN0cnVjdCBzb2NrYWRkcl91biwgc3VuX3BhdGgpKTsKIAkJCWlmIChwcmV2ID09IE5VTEwpCiAJCQkJaGFwZC0+Y3RybF9kc3QgPSBkc3QtPm5leHQ7CiAJCQllbHNlCiAJCQkJcHJldi0+bmV4dCA9IGRzdC0+bmV4dDsKIAkJCW9zX2ZyZWUoZHN0KTsKLQkJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgbW9uaXRvciBkZXRhY2hlZCIsCi0JCQkJICAgICh1OCAqKSBmcm9tLT5zdW5fcGF0aCwKLQkJCQkgICAgZnJvbWxlbiAtCi0JCQkJICAgIG9mZnNldG9mKHN0cnVjdCBzb2NrYWRkcl91biwgc3VuX3BhdGgpKTsKIAkJCXJldHVybiAwOwogCQl9CiAJCXByZXYgPSBkc3Q7CkBAIC0zOTcsMTMgKzQwMCw3MCBAQAogc3RhdGljIGludCBob3N0YXBkX2N0cmxfaWZhY2VfbmZjX3JlcG9ydF9oYW5kb3ZlcihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCQkJICBjaGFyICpjbWQpCiB7Ci0JLyoKLQkgKiBTaW5jZSBORkMgY29ubmVjdGlvbiBoYW5kb3ZlciBwcm92aWRlZCBmdWxsIFdQUyBDcmVkZW50aWFsLCB0aGVyZSBpcwotCSAqIG5vIG5lZWQgZm9yIGFkZGl0aW9uYWwgb3BlcmF0aW9ucyB3aXRoaW4gaG9zdGFwZC4gSnVzdCByZXBvcnQgdGhpcyBpbgotCSAqIGRlYnVnIGxvZy4KLQkgKi8KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogQ29ubmVjdGlvbiBoYW5kb3ZlciByZXBvcnRlZDogJXMiLCBjbWQpOwotCXJldHVybiAwOworCXNpemVfdCBsZW47CisJc3RydWN0IHdwYWJ1ZiAqcmVxLCAqc2VsOworCWludCByZXQ7CisJY2hhciAqcG9zLCAqcm9sZSwgKnR5cGUsICpwb3MyOworCisJcm9sZSA9IGNtZDsKKwlwb3MgPSBvc19zdHJjaHIocm9sZSwgJyAnKTsKKwlpZiAocG9zID09IE5VTEwpCisJCXJldHVybiAtMTsKKwkqcG9zKysgPSAnXDAnOworCisJdHlwZSA9IHBvczsKKwlwb3MgPSBvc19zdHJjaHIodHlwZSwgJyAnKTsKKwlpZiAocG9zID09IE5VTEwpCisJCXJldHVybiAtMTsKKwkqcG9zKysgPSAnXDAnOworCisJcG9zMiA9IG9zX3N0cmNocihwb3MsICcgJyk7CisJaWYgKHBvczIgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCSpwb3MyKysgPSAnXDAnOworCisJbGVuID0gb3Nfc3RybGVuKHBvcyk7CisJaWYgKGxlbiAmIDB4MDEpCisJCXJldHVybiAtMTsKKwlsZW4gLz0gMjsKKworCXJlcSA9IHdwYWJ1Zl9hbGxvYyhsZW4pOworCWlmIChyZXEgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWlmIChoZXhzdHIyYmluKHBvcywgd3BhYnVmX3B1dChyZXEsIGxlbiksIGxlbikgPCAwKSB7CisJCXdwYWJ1Zl9mcmVlKHJlcSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlsZW4gPSBvc19zdHJsZW4ocG9zMik7CisJaWYgKGxlbiAmIDB4MDEpIHsKKwkJd3BhYnVmX2ZyZWUocmVxKTsKKwkJcmV0dXJuIC0xOworCX0KKwlsZW4gLz0gMjsKKworCXNlbCA9IHdwYWJ1Zl9hbGxvYyhsZW4pOworCWlmIChzZWwgPT0gTlVMTCkgeworCQl3cGFidWZfZnJlZShyZXEpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChoZXhzdHIyYmluKHBvczIsIHdwYWJ1Zl9wdXQoc2VsLCBsZW4pLCBsZW4pIDwgMCkgeworCQl3cGFidWZfZnJlZShyZXEpOworCQl3cGFidWZfZnJlZShzZWwpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKG9zX3N0cmNtcChyb2xlLCAiUkVTUCIpID09IDAgJiYgb3Nfc3RyY21wKHR5cGUsICJXUFMiKSA9PSAwKSB7CisJCXJldCA9IGhvc3RhcGRfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIoaGFwZCwgcmVxLCBzZWwpOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTkZDOiBVbnN1cHBvcnRlZCBjb25uZWN0aW9uIGhhbmRvdmVyICIKKwkJCSAgICJyZXBvcnRlZDogcm9sZT0lcyB0eXBlPSVzIiwgcm9sZSwgdHlwZSk7CisJCXJldCA9IC0xOworCX0KKwl3cGFidWZfZnJlZShyZXEpOworCXdwYWJ1Zl9mcmVlKHNlbCk7CisKKwlyZXR1cm4gcmV0OwogfQogCiAjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KQEAgLTU1OCw2ICs2MTgsMTgyIEBACiAKICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAKKyNpZmRlZiBDT05GSUdfSFMyMAorCitzdGF0aWMgaW50IGhvc3RhcGRfY3RybF9pZmFjZV9oczIwX3dubV9ub3RpZihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgICAgIGNvbnN0IGNoYXIgKmNtZCkKK3sKKwl1OCBhZGRyW0VUSF9BTEVOXTsKKwljb25zdCBjaGFyICp1cmw7CisKKwlpZiAoaHdhZGRyX2F0b24oY21kLCBhZGRyKSkKKwkJcmV0dXJuIC0xOworCXVybCA9IGNtZCArIDE3OworCWlmICgqdXJsID09ICdcMCcpIHsKKwkJdXJsID0gTlVMTDsKKwl9IGVsc2UgeworCQlpZiAoKnVybCAhPSAnICcpCisJCQlyZXR1cm4gLTE7CisJCXVybCsrOworCQlpZiAoKnVybCA9PSAnXDAnKQorCQkJdXJsID0gTlVMTDsKKwl9CisKKwlyZXR1cm4gaHMyMF9zZW5kX3dubV9ub3RpZmljYXRpb24oaGFwZCwgYWRkciwgMSwgdXJsKTsKK30KKworCitzdGF0aWMgaW50IGhvc3RhcGRfY3RybF9pZmFjZV9oczIwX2RlYXV0aF9yZXEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJICAgICAgY29uc3QgY2hhciAqY21kKQoreworCXU4IGFkZHJbRVRIX0FMRU5dOworCWludCBjb2RlLCByZWF1dGhfZGVsYXksIHJldDsKKwljb25zdCBjaGFyICpwb3M7CisJc2l6ZV90IHVybF9sZW47CisJc3RydWN0IHdwYWJ1ZiAqcmVxOworCisJLyogPFNUQSBNQUMgQWRkcj4gPENvZGUoMC8xKT4gPFJlLWF1dGgtRGVsYXkoc2VjKT4gW1VSTF0gKi8KKwlpZiAoaHdhZGRyX2F0b24oY21kLCBhZGRyKSkKKwkJcmV0dXJuIC0xOworCisJcG9zID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKKwlpZiAocG9zID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlwb3MrKzsKKwljb2RlID0gYXRvaShwb3MpOworCisJcG9zID0gb3Nfc3RyY2hyKHBvcywgJyAnKTsKKwlpZiAocG9zID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlwb3MrKzsKKwlyZWF1dGhfZGVsYXkgPSBhdG9pKHBvcyk7CisKKwl1cmxfbGVuID0gMDsKKwlwb3MgPSBvc19zdHJjaHIocG9zLCAnICcpOworCWlmIChwb3MpIHsKKwkJcG9zKys7CisJCXVybF9sZW4gPSBvc19zdHJsZW4ocG9zKTsKKwl9CisKKwlyZXEgPSB3cGFidWZfYWxsb2MoNCArIHVybF9sZW4pOworCWlmIChyZXEgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXdwYWJ1Zl9wdXRfdTgocmVxLCBjb2RlKTsKKwl3cGFidWZfcHV0X2xlMTYocmVxLCByZWF1dGhfZGVsYXkpOworCXdwYWJ1Zl9wdXRfdTgocmVxLCB1cmxfbGVuKTsKKwlpZiAocG9zKQorCQl3cGFidWZfcHV0X2RhdGEocmVxLCBwb3MsIHVybF9sZW4pOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IFNlbmQgV05NLU5vdGlmaWNhdGlvbiB0byAiIE1BQ1NUUgorCQkgICAiIHRvIGluZGljYXRlIGltbWluZW50IGRlYXV0aGVudGljYXRpb24gKGNvZGU9JWQgIgorCQkgICAicmVhdXRoX2RlbGF5PSVkKSIsIE1BQzJTVFIoYWRkciksIGNvZGUsIHJlYXV0aF9kZWxheSk7CisJcmV0ID0gaHMyMF9zZW5kX3dubV9ub3RpZmljYXRpb25fZGVhdXRoX3JlcShoYXBkLCBhZGRyLCByZXEpOworCXdwYWJ1Zl9mcmVlKHJlcSk7CisJcmV0dXJuIHJldDsKK30KKworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisKKworI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKworc3RhdGljIGludCBob3N0YXBkX2N0cmxfaWZhY2Vfc2V0X3Fvc19tYXBfc2V0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgICAgIGNvbnN0IGNoYXIgKmNtZCkKK3sKKwl1OCBxb3NfbWFwX3NldFsxNiArIDIgKiAyMV0sIGNvdW50ID0gMDsKKwljb25zdCBjaGFyICpwb3MgPSBjbWQ7CisJaW50IHZhbCwgcmV0OworCisJZm9yICg7OykgeworCQlpZiAoY291bnQgPT0gc2l6ZW9mKHFvc19tYXBfc2V0KSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJUb28gbWFueSBxb3NfbWFwX3NldCBwYXJhbWV0ZXJzIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQl2YWwgPSBhdG9pKHBvcyk7CisJCWlmICh2YWwgPCAwIHx8IHZhbCA+IDI1NSkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgUW9TIE1hcCBTZXQiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCisJCXFvc19tYXBfc2V0W2NvdW50KytdID0gdmFsOworCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOworCQlpZiAoIXBvcykKKwkJCWJyZWFrOworCQlwb3MrKzsKKwl9CisKKwlpZiAoY291bnQgPCAxNiB8fCBjb3VudCAmIDEpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgUW9TIE1hcCBTZXQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldCA9IGhvc3RhcGRfZHJ2X3NldF9xb3NfbWFwKGhhcGQsIHFvc19tYXBfc2V0LCBjb3VudCk7CisJaWYgKHJldCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBRb1MgTWFwIFNldCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJb3NfbWVtY3B5KGhhcGQtPmNvbmYtPnFvc19tYXBfc2V0LCBxb3NfbWFwX3NldCwgY291bnQpOworCWhhcGQtPmNvbmYtPnFvc19tYXBfc2V0X2xlbiA9IGNvdW50OworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBob3N0YXBkX2N0cmxfaWZhY2Vfc2VuZF9xb3NfbWFwX2NvbmYoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJCWNvbnN0IGNoYXIgKmNtZCkKK3sKKwl1OCBhZGRyW0VUSF9BTEVOXTsKKwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJdTggKnFvc19tYXBfc2V0ID0gaGFwZC0+Y29uZi0+cW9zX21hcF9zZXQ7CisJdTggcW9zX21hcF9zZXRfbGVuID0gaGFwZC0+Y29uZi0+cW9zX21hcF9zZXRfbGVuOworCWludCByZXQ7CisKKwlpZiAoIXFvc19tYXBfc2V0X2xlbikgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUW9TIE1hcCBTZXQgaXMgbm90IHNldCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGh3YWRkcl9hdG9uKGNtZCwgYWRkcikpCisJCXJldHVybiAtMTsKKworCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgYWRkcik7CisJaWYgKHN0YSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU3RhdGlvbiAiIE1BQ1NUUiAiIG5vdCBmb3VuZCAiCisJCQkgICAiZm9yIFFvUyBNYXAgQ29uZmlndXJhdGlvbiBtZXNzYWdlIiwKKwkJCSAgIE1BQzJTVFIoYWRkcikpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKCFzdGEtPnFvc19tYXBfZW5hYmxlZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlN0YXRpb24gIiBNQUNTVFIgIiBkaWQgbm90IGluZGljYXRlICIKKwkJCSAgICJzdXBwb3J0IGZvciBRb1MgTWFwIiwgTUFDMlNUUihhZGRyKSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlidWYgPSB3cGFidWZfYWxsb2MoMiArIDIgKyBxb3NfbWFwX3NldF9sZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJd3BhYnVmX3B1dF91OChidWYsIFdMQU5fQUNUSU9OX1FPUyk7CisJd3BhYnVmX3B1dF91OChidWYsIFFPU19RT1NfTUFQX0NPTkZJRyk7CisKKwkvKiBRb1MgTWFwIFNldCBFbGVtZW50ICovCisJd3BhYnVmX3B1dF91OChidWYsIFdMQU5fRUlEX1FPU19NQVBfU0VUKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgcW9zX21hcF9zZXRfbGVuKTsKKwl3cGFidWZfcHV0X2RhdGEoYnVmLCBxb3NfbWFwX3NldCwgcW9zX21hcF9zZXRfbGVuKTsKKworCXJldCA9IGhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLCBhZGRyLAorCQkJCSAgICAgIHdwYWJ1Zl9oZWFkKGJ1ZiksIHdwYWJ1Zl9sZW4oYnVmKSk7CisJd3BhYnVmX2ZyZWUoYnVmKTsKKworCXJldHVybiByZXQ7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCisKIAogI2lmZGVmIENPTkZJR19XTk0KIApAQCAtNTY1LDkgKzgwMSw4IEBACiAJCQkJCQljb25zdCBjaGFyICpjbWQpCiB7CiAJdTggYWRkcltFVEhfQUxFTl07Ci0JdTggYnVmWzEwMDBdLCAqcG9zOwotCXN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKIAlpbnQgZGlzYXNzb2NfdGltZXI7CisJc3RydWN0IHN0YV9pbmZvICpzdGE7CiAKIAlpZiAoaHdhZGRyX2F0b24oY21kLCBhZGRyKSkKIAkJcmV0dXJuIC0xOwpAQCAtNTc1LDMxICs4MTAsMTUgQEAKIAkJcmV0dXJuIC0xOwogCWRpc2Fzc29jX3RpbWVyID0gYXRvaShjbWQgKyAxNyk7CiAKLQlvc19tZW1zZXQoYnVmLCAwLCBzaXplb2YoYnVmKSk7Ci0JbWdtdCA9IChzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKikgYnVmOwotCW1nbXQtPmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCi0JCQkJCSAgIFdMQU5fRkNfU1RZUEVfQUNUSU9OKTsKLQlvc19tZW1jcHkobWdtdC0+ZGEsIGFkZHIsIEVUSF9BTEVOKTsKLQlvc19tZW1jcHkobWdtdC0+c2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7Ci0Jb3NfbWVtY3B5KG1nbXQtPmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOwotCW1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ID0gV0xBTl9BQ1RJT05fV05NOwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5hY3Rpb24gPSBXTk1fQlNTX1RSQU5TX01HTVRfUkVROwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5kaWFsb2dfdG9rZW4gPSAxOwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5yZXFfbW9kZSA9Ci0JCVdOTV9CU1NfVE1fUkVRX0RJU0FTU09DX0lNTUlORU5UOwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5kaXNhc3NvY190aW1lciA9Ci0JCWhvc3RfdG9fbGUxNihkaXNhc3NvY190aW1lcik7Ci0JbWdtdC0+dS5hY3Rpb24udS5ic3NfdG1fcmVxLnZhbGlkaXR5X2ludGVydmFsID0gMDsKLQotCXBvcyA9IG1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS52YXJpYWJsZTsKLQotCWlmIChob3N0YXBkX2Rydl9zZW5kX21sbWUoaGFwZCwgYnVmLCBwb3MgLSBidWYsIDApIDwgMCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBzZW5kIEJTUyBUcmFuc2l0aW9uICIKLQkJCSAgICJNYW5hZ2VtZW50IFJlcXVlc3QgZnJhbWUiKTsKKwlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIGFkZHIpOworCWlmIChzdGEgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlN0YXRpb24gIiBNQUNTVFIKKwkJCSAgICIgbm90IGZvdW5kIGZvciBkaXNhc3NvY2lhdGlvbiBpbW1pbmVudCBtZXNzYWdlIiwKKwkJCSAgIE1BQzJTVFIoYWRkcikpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHdubV9zZW5kX2Rpc2Fzc29jX2ltbWluZW50KGhhcGQsIHN0YSwgZGlzYXNzb2NfdGltZXIpOwogfQogCiAKQEAgLTYwOCwxNCArODI3LDIwIEBACiB7CiAJdTggYWRkcltFVEhfQUxFTl07CiAJY29uc3QgY2hhciAqdXJsLCAqdGltZXJzdHI7Ci0JdTggYnVmWzEwMDBdLCAqcG9zOwotCXN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKLQlzaXplX3QgdXJsX2xlbjsKIAlpbnQgZGlzYXNzb2NfdGltZXI7CisJc3RydWN0IHN0YV9pbmZvICpzdGE7CiAKIAlpZiAoaHdhZGRyX2F0b24oY21kLCBhZGRyKSkKIAkJcmV0dXJuIC0xOwogCisJc3RhID0gYXBfZ2V0X3N0YShoYXBkLCBhZGRyKTsKKwlpZiAoc3RhID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTdGF0aW9uICIgTUFDU1RSCisJCQkgICAiIG5vdCBmb3VuZCBmb3IgRVNTIGRpc2Fzc29jaWF0aW9uIGltbWluZW50IG1lc3NhZ2UiLAorCQkJICAgTUFDMlNUUihhZGRyKSk7CisJCXJldHVybiAtMTsKKwl9CisKIAl0aW1lcnN0ciA9IGNtZCArIDE3OwogCWlmICgqdGltZXJzdHIgIT0gJyAnKQogCQlyZXR1cm4gLTE7CkBAIC02MjgsNzUgKzg1Myw4IEBACiAJaWYgKHVybCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAJdXJsKys7Ci0JdXJsX2xlbiA9IG9zX3N0cmxlbih1cmwpOwotCWlmICh1cmxfbGVuID4gMjU1KQotCQlyZXR1cm4gLTE7CiAKLQlvc19tZW1zZXQoYnVmLCAwLCBzaXplb2YoYnVmKSk7Ci0JbWdtdCA9IChzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKikgYnVmOwotCW1nbXQtPmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCi0JCQkJCSAgIFdMQU5fRkNfU1RZUEVfQUNUSU9OKTsKLQlvc19tZW1jcHkobWdtdC0+ZGEsIGFkZHIsIEVUSF9BTEVOKTsKLQlvc19tZW1jcHkobWdtdC0+c2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7Ci0Jb3NfbWVtY3B5KG1nbXQtPmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOwotCW1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ID0gV0xBTl9BQ1RJT05fV05NOwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5hY3Rpb24gPSBXTk1fQlNTX1RSQU5TX01HTVRfUkVROwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5kaWFsb2dfdG9rZW4gPSAxOwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5yZXFfbW9kZSA9Ci0JCVdOTV9CU1NfVE1fUkVRX0VTU19ESVNBU1NPQ19JTU1JTkVOVDsKLQltZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEuZGlzYXNzb2NfdGltZXIgPQotCQlob3N0X3RvX2xlMTYoZGlzYXNzb2NfdGltZXIpOwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS52YWxpZGl0eV9pbnRlcnZhbCA9IDB4MDE7Ci0KLQlwb3MgPSBtZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEudmFyaWFibGU7Ci0KLQkvKiBTZXNzaW9uIEluZm9ybWF0aW9uIFVSTCAqLwotCSpwb3MrKyA9IHVybF9sZW47Ci0Jb3NfbWVtY3B5KHBvcywgdXJsLCB1cmxfbGVuKTsKLQlwb3MgKz0gdXJsX2xlbjsKLQotCWlmIChob3N0YXBkX2Rydl9zZW5kX21sbWUoaGFwZCwgYnVmLCBwb3MgLSBidWYsIDApIDwgMCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBzZW5kIEJTUyBUcmFuc2l0aW9uICIKLQkJCSAgICJNYW5hZ2VtZW50IFJlcXVlc3QgZnJhbWUiKTsKLQkJcmV0dXJuIC0xOwotCX0KLQotCS8qIHNlbmQgZGlzYXNzb2NpYXRpb24gZnJhbWUgYWZ0ZXIgdGltZS1vdXQgKi8KLQlpZiAoZGlzYXNzb2NfdGltZXIpIHsKLQkJc3RydWN0IHN0YV9pbmZvICpzdGE7Ci0JCWludCB0aW1lb3V0LCBiZWFjb25faW50OwotCi0JCS8qCi0JCSAqIFByZXZlbnQgU1RBIGZyb20gcmVjb25uZWN0aW5nIHVzaW5nIGNhY2hlZCBQTUtTQSB0byBmb3JjZQotCQkgKiBmdWxsIGF1dGhlbnRpY2F0aW9uIHdpdGggdGhlIGF1dGhlbnRpY2F0aW9uIHNlcnZlciAod2hpY2ggbWF5Ci0JCSAqIGRlY2lkZSB0byByZWplY3QgdGhlIGNvbm5lY3Rpb24pLAotCQkgKi8KLQkJd3BhX2F1dGhfcG1rc2FfcmVtb3ZlKGhhcGQtPndwYV9hdXRoLCBhZGRyKTsKLQotCQlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIGFkZHIpOwotCQlpZiAoc3RhID09IE5VTEwpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU3RhdGlvbiAiIE1BQ1NUUiAiIG5vdCBmb3VuZCAiCi0JCQkJICAgImZvciBFU1MgZGlzYXNzb2NpYXRpb24gaW1taW5lbnQgbWVzc2FnZSIsCi0JCQkJICAgTUFDMlNUUihhZGRyKSk7Ci0JCQlyZXR1cm4gLTE7Ci0JCX0KLQotCQliZWFjb25faW50ID0gaGFwZC0+aWNvbmYtPmJlYWNvbl9pbnQ7Ci0JCWlmIChiZWFjb25faW50IDwgMSkKLQkJCWJlYWNvbl9pbnQgPSAxMDA7IC8qIGJlc3QgZ3Vlc3MgKi8KLQkJLyogQ2FsY3VsYXRlIHRpbWVvdXQgaW4gbXMgYmFzZWQgb24gYmVhY29uX2ludCBpbiBUVSAqLwotCQl0aW1lb3V0ID0gZGlzYXNzb2NfdGltZXIgKiBiZWFjb25faW50ICogMTI4IC8gMTI1OwotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRpc2Fzc29jaWF0aW9uIHRpbWVyIGZvciAiIE1BQ1NUUgotCQkJICAgIiBzZXQgdG8gJWQgbXMiLCBNQUMyU1RSKGFkZHIpLCB0aW1lb3V0KTsKLQotCQlzdGEtPnRpbWVvdXRfbmV4dCA9IFNUQV9ESVNBU1NPQ19GUk9NX0NMSTsKLQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOwotCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KHRpbWVvdXQgLyAxMDAwLAotCQkJCSAgICAgICB0aW1lb3V0ICUgMTAwMCAqIDEwMDAsCi0JCQkJICAgICAgIGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKLQl9Ci0KLQlyZXR1cm4gMDsKKwlyZXR1cm4gd25tX3NlbmRfZXNzX2Rpc2Fzc29jX2ltbWluZW50KGhhcGQsIHN0YSwgdXJsLCBkaXNhc3NvY190aW1lcik7CiB9CiAKICNlbmRpZiAvKiBDT05GSUdfV05NICovCkBAIC03ODIsNiArOTQwLDE0IEBACiAJCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKIAkJCXBvcyArPSByZXQ7CiAJCX0KKyNpZmRlZiBDT05GSUdfU0FFCisJCWlmIChoYXBkLT5jb25mLT53cGFfa2V5X21nbXQgJiBXUEFfS0VZX01HTVRfRlRfU0FFKSB7CisJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIkZULVNBRSAiKTsKKwkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCisJCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwkJCXBvcyArPSByZXQ7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfU0FFICovCiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KICNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwogCQlpZiAoaGFwZC0+Y29uZi0+d3BhX2tleV9tZ210ICYgV1BBX0tFWV9NR01UX1BTS19TSEEyNTYpIHsKQEAgLTc5Nyw2ICs5NjMsMTQgQEAKIAkJCXBvcyArPSByZXQ7CiAJCX0KICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLworI2lmZGVmIENPTkZJR19TQUUKKwkJaWYgKGhhcGQtPmNvbmYtPndwYV9rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9TQUUpIHsKKwkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiU0FFICIpOworCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQlyZXR1cm4gcG9zIC0gYnVmOworCQkJcG9zICs9IHJldDsKKwkJfQorI2VuZGlmIC8qIENPTkZJR19TQUUgKi8KIAogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlxuIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCkBAIC04ODQsNiArMTA1OCwxMCBAQAogCQl3cHNfdGVzdGluZ19kdW1teV9jcmVkID0gYXRvaSh2YWx1ZSk7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBUZXN0aW5nIC0gZHVtbXlfY3JlZD0lZCIsCiAJCQkgICB3cHNfdGVzdGluZ19kdW1teV9jcmVkKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAid3BzX2NvcnJ1cHRfcGtoYXNoIikgPT0gMCkgeworCQl3cHNfY29ycnVwdF9wa2hhc2ggPSBhdG9pKHZhbHVlKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFRlc3RpbmcgLSB3cHNfY29ycnVwdF9wa2hhc2g9JWQiLAorCQkJICAgd3BzX2NvcnJ1cHRfcGtoYXNoKTsKICNlbmRpZiAvKiBDT05GSUdfV1BTX1RFU1RJTkcgKi8KICNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCiAJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImdhc19mcmFnX2xpbWl0IikgPT0gMCkgewpAQCAtODkzLDggKzEwNzEsNDIgQEAKIAkJZWxzZQogCQkJaGFwZC0+Z2FzX2ZyYWdfbGltaXQgPSB2YWw7CiAjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKwl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAiZXh0X21nbXRfZnJhbWVfaGFuZGxpbmciKSA9PSAwKSB7CisJCWhhcGQtPmV4dF9tZ210X2ZyYW1lX2hhbmRsaW5nID0gYXRvaSh2YWx1ZSk7CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLwogCX0gZWxzZSB7CisJCXN0cnVjdCBzdGFfaW5mbyAqc3RhOworCQlpbnQgdmxhbl9pZDsKKwogCQlyZXQgPSBob3N0YXBkX3NldF9pZmFjZShoYXBkLT5pY29uZiwgaGFwZC0+Y29uZiwgY21kLCB2YWx1ZSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCisJCWlmIChvc19zdHJjYXNlY21wKGNtZCwgImRlbnlfbWFjX2ZpbGUiKSA9PSAwKSB7CisJCQlmb3IgKHN0YSA9IGhhcGQtPnN0YV9saXN0OyBzdGE7IHN0YSA9IHN0YS0+bmV4dCkgeworCQkJCWlmIChob3N0YXBkX21hY2xpc3RfZm91bmQoCisJCQkJCSAgICBoYXBkLT5jb25mLT5kZW55X21hYywKKwkJCQkJICAgIGhhcGQtPmNvbmYtPm51bV9kZW55X21hYywgc3RhLT5hZGRyLAorCQkJCQkgICAgJnZsYW5faWQpICYmCisJCQkJICAgICghdmxhbl9pZCB8fCB2bGFuX2lkID09IHN0YS0+dmxhbl9pZCkpCisJCQkJCWFwX3N0YV9kaXNjb25uZWN0KAorCQkJCQkJaGFwZCwgc3RhLCBzdGEtPmFkZHIsCisJCQkJCQlXTEFOX1JFQVNPTl9VTlNQRUNJRklFRCk7CisJCQl9CisJCX0gZWxzZSBpZiAoaGFwZC0+Y29uZi0+bWFjYWRkcl9hY2wgPT0gREVOWV9VTkxFU1NfQUNDRVBURUQgJiYKKwkJCSAgIG9zX3N0cmNhc2VjbXAoY21kLCAiYWNjZXB0X21hY19maWxlIikgPT0gMCkgeworCQkJZm9yIChzdGEgPSBoYXBkLT5zdGFfbGlzdDsgc3RhOyBzdGEgPSBzdGEtPm5leHQpIHsKKwkJCQlpZiAoIWhvc3RhcGRfbWFjbGlzdF9mb3VuZCgKKwkJCQkJICAgIGhhcGQtPmNvbmYtPmFjY2VwdF9tYWMsCisJCQkJCSAgICBoYXBkLT5jb25mLT5udW1fYWNjZXB0X21hYywKKwkJCQkJICAgIHN0YS0+YWRkciwgJnZsYW5faWQpIHx8CisJCQkJICAgICh2bGFuX2lkICYmIHZsYW5faWQgIT0gc3RhLT52bGFuX2lkKSkKKwkJCQkJYXBfc3RhX2Rpc2Nvbm5lY3QoCisJCQkJCQloYXBkLCBzdGEsIHN0YS0+YWRkciwKKwkJCQkJCVdMQU5fUkVBU09OX1VOU1BFQ0lGSUVEKTsKKwkJCX0KKwkJfQogCX0KIAogCXJldHVybiByZXQ7CkBAIC05NDksMTEgKzExNjEsMjAwIEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKworc3RhdGljIGludCBob3N0YXBkX2N0cmxfaWZhY2VfcmFkYXIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY2hhciAqY21kKQoreworCXVuaW9uIHdwYV9ldmVudF9kYXRhIGRhdGE7CisJY2hhciAqcG9zLCAqcGFyYW07CisJZW51bSB3cGFfZXZlbnRfdHlwZSBldmVudDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUkFEQVIgVEVTVDogJXMiLCBjbWQpOworCisJb3NfbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOworCisJcGFyYW0gPSBvc19zdHJjaHIoY21kLCAnICcpOworCWlmIChwYXJhbSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJKnBhcmFtKysgPSAnXDAnOworCisJaWYgKG9zX3N0cmNtcChjbWQsICJERVRFQ1RFRCIpID09IDApCisJCWV2ZW50ID0gRVZFTlRfREZTX1JBREFSX0RFVEVDVEVEOworCWVsc2UgaWYgKG9zX3N0cmNtcChjbWQsICJDQUMtRklOSVNIRUQiKSA9PSAwKQorCQlldmVudCA9IEVWRU5UX0RGU19DQUNfRklOSVNIRUQ7CisJZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgIkNBQy1BQk9SVEVEIikgPT0gMCkKKwkJZXZlbnQgPSBFVkVOVF9ERlNfQ0FDX0FCT1JURUQ7CisJZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgIk5PUC1GSU5JU0hFRCIpID09IDApCisJCWV2ZW50ID0gRVZFTlRfREZTX05PUF9GSU5JU0hFRDsKKwllbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVbnN1cHBvcnRlZCBSQURBUiB0ZXN0IGNvbW1hbmQ6ICVzIiwKKwkJCSAgIGNtZCk7CisJCXJldHVybiAtMTsKKwl9CisKKwlwb3MgPSBvc19zdHJzdHIocGFyYW0sICJmcmVxPSIpOworCWlmIChwb3MpCisJCWRhdGEuZGZzX2V2ZW50LmZyZXEgPSBhdG9pKHBvcyArIDUpOworCisJcG9zID0gb3Nfc3Ryc3RyKHBhcmFtLCAiaHRfZW5hYmxlZD0xIik7CisJaWYgKHBvcykKKwkJZGF0YS5kZnNfZXZlbnQuaHRfZW5hYmxlZCA9IDE7CisKKwlwb3MgPSBvc19zdHJzdHIocGFyYW0sICJjaGFuX29mZnNldD0iKTsKKwlpZiAocG9zKQorCQlkYXRhLmRmc19ldmVudC5jaGFuX29mZnNldCA9IGF0b2kocG9zICsgMTIpOworCisJcG9zID0gb3Nfc3Ryc3RyKHBhcmFtLCAiY2hhbl93aWR0aD0iKTsKKwlpZiAocG9zKQorCQlkYXRhLmRmc19ldmVudC5jaGFuX3dpZHRoID0gYXRvaShwb3MgKyAxMSk7CisKKwlwb3MgPSBvc19zdHJzdHIocGFyYW0sICJjZjE9Iik7CisJaWYgKHBvcykKKwkJZGF0YS5kZnNfZXZlbnQuY2YxID0gYXRvaShwb3MgKyA0KTsKKworCXBvcyA9IG9zX3N0cnN0cihwYXJhbSwgImNmMj0iKTsKKwlpZiAocG9zKQorCQlkYXRhLmRmc19ldmVudC5jZjIgPSBhdG9pKHBvcyArIDQpOworCisJd3BhX3N1cHBsaWNhbnRfZXZlbnQoaGFwZCwgZXZlbnQsICZkYXRhKTsKKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX21nbXRfdHgoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY2hhciAqY21kKQoreworCXNpemVfdCBsZW47CisJdTggKmJ1ZjsKKwlpbnQgcmVzOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFeHRlcm5hbCBNR01UIFRYOiAlcyIsIGNtZCk7CisKKwlsZW4gPSBvc19zdHJsZW4oY21kKTsKKwlpZiAobGVuICYgMSkKKwkJcmV0dXJuIC0xOworCWxlbiAvPSAyOworCisJYnVmID0gb3NfbWFsbG9jKGxlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpZiAoaGV4c3RyMmJpbihjbWQsIGJ1ZiwgbGVuKSA8IDApIHsKKwkJb3NfZnJlZShidWYpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gaG9zdGFwZF9kcnZfc2VuZF9tbG1lKGhhcGQsIGJ1ZiwgbGVuLCAwKTsKKwlvc19mcmVlKGJ1Zik7CisJcmV0dXJuIHJlczsKK30KKworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKworCitzdGF0aWMgaW50IGhvc3RhcGRfY3RybF9pZmFjZV9jaGFuX3N3aXRjaChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsCisJCQkJCSAgY2hhciAqcG9zKQoreworI2lmZGVmIE5FRURfQVBfTUxNRQorCXN0cnVjdCBjc2Ffc2V0dGluZ3Mgc2V0dGluZ3M7CisJaW50IHJldDsKKwl1bnNpZ25lZCBpbnQgaTsKKworCXJldCA9IGhvc3RhcGRfcGFyc2VfY3NhX3NldHRpbmdzKHBvcywgJnNldHRpbmdzKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspIHsKKwkJcmV0ID0gaG9zdGFwZF9zd2l0Y2hfY2hhbm5lbChpZmFjZS0+YnNzW2ldLCAmc2V0dGluZ3MpOworCQlpZiAocmV0KSB7CisJCQkvKiBGSVg6IFdoYXQgZG8gd2UgZG8gaWYgQ1NBIGZhaWxzIGluIHRoZSBtaWRkbGUgb2YKKwkJCSAqIHN1Ym1pdHRpbmcgbXVsdGktQlNTIENTQSByZXF1ZXN0cz8gKi8KKwkJCXJldHVybiByZXQ7CisJCX0KKwl9CisKKwlyZXR1cm4gMDsKKyNlbHNlIC8qIE5FRURfQVBfTUxNRSAqLworCXJldHVybiAtMTsKKyNlbmRpZiAvKiBORUVEX0FQX01MTUUgKi8KK30KKworCitzdGF0aWMgaW50IGhvc3RhcGRfY3RybF9pZmFjZV9taWIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY2hhciAqcmVwbHksCisJCQkJICBpbnQgcmVwbHlfc2l6ZSwgY29uc3QgY2hhciAqcGFyYW0pCit7CisjaWZkZWYgUkFESVVTX1NFUlZFUgorCWlmIChvc19zdHJjbXAocGFyYW0sICJyYWRpdXNfc2VydmVyIikgPT0gMCkgeworCQlyZXR1cm4gcmFkaXVzX3NlcnZlcl9nZXRfbWliKGhhcGQtPnJhZGl1c19zcnYsIHJlcGx5LAorCQkJCQkgICAgIHJlcGx5X3NpemUpOworCX0KKyNlbmRpZiAvKiBSQURJVVNfU0VSVkVSICovCisJcmV0dXJuIC0xOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX3ZlbmRvcihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjaGFyICpjbWQsCisJCQkJICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCit7CisJaW50IHJldDsKKwljaGFyICpwb3M7CisJdTggKmRhdGEgPSBOVUxMOworCXVuc2lnbmVkIGludCB2ZW5kb3JfaWQsIHN1YmNtZDsKKwlzdHJ1Y3Qgd3BhYnVmICpyZXBseTsKKwlzaXplX3QgZGF0YV9sZW4gPSAwOworCisJLyogY21kOiA8dmVuZG9yIGlkPiA8c3ViY29tbWFuZCBpZD4gWzxoZXggZm9ybWF0dGVkIGRhdGE+XSAqLworCXZlbmRvcl9pZCA9IHN0cnRvdWwoY21kLCAmcG9zLCAxNik7CisJaWYgKCFpc2JsYW5rKCpwb3MpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXN1YmNtZCA9IHN0cnRvdWwocG9zLCAmcG9zLCAxMCk7CisKKwlpZiAoKnBvcyAhPSAnXDAnKSB7CisJCWlmICghaXNibGFuaygqcG9zKyspKQorCQkJcmV0dXJuIC1FSU5WQUw7CisJCWRhdGFfbGVuID0gb3Nfc3RybGVuKHBvcyk7CisJfQorCisJaWYgKGRhdGFfbGVuKSB7CisJCWRhdGFfbGVuIC89IDI7CisJCWRhdGEgPSBvc19tYWxsb2MoZGF0YV9sZW4pOworCQlpZiAoIWRhdGEpCisJCQlyZXR1cm4gLUVOT0JVRlM7CisKKwkJaWYgKGhleHN0cjJiaW4ocG9zLCBkYXRhLCBkYXRhX2xlbikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJWZW5kb3IgY29tbWFuZDogd3JvbmcgcGFyYW1ldGVyIGZvcm1hdCIpOworCQkJb3NfZnJlZShkYXRhKTsKKwkJCXJldHVybiAtRUlOVkFMOworCQl9CisJfQorCisJcmVwbHkgPSB3cGFidWZfYWxsb2MoKGJ1ZmxlbiAtIDEpIC8gMik7CisJaWYgKCFyZXBseSkgeworCQlvc19mcmVlKGRhdGEpOworCQlyZXR1cm4gLUVOT0JVRlM7CisJfQorCisJcmV0ID0gaG9zdGFwZF9kcnZfdmVuZG9yX2NtZChoYXBkLCB2ZW5kb3JfaWQsIHN1YmNtZCwgZGF0YSwgZGF0YV9sZW4sCisJCQkJICAgICByZXBseSk7CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IHdwYV9zbnByaW50Zl9oZXgoYnVmLCBidWZsZW4sIHdwYWJ1Zl9oZWFkX3U4KHJlcGx5KSwKKwkJCQkgICAgICAgd3BhYnVmX2xlbihyZXBseSkpOworCisJd3BhYnVmX2ZyZWUocmVwbHkpOworCW9zX2ZyZWUoZGF0YSk7CisKKwlyZXR1cm4gcmV0OworfQorCisKIHN0YXRpYyB2b2lkIGhvc3RhcGRfY3RybF9pZmFjZV9yZWNlaXZlKGludCBzb2NrLCB2b2lkICplbG9vcF9jdHgsCiAJCQkJICAgICAgIHZvaWQgKnNvY2tfY3R4KQogewogCXN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQgPSBlbG9vcF9jdHg7Ci0JY2hhciBidWZbMjU2XTsKKwljaGFyIGJ1Zls0MDk2XTsKIAlpbnQgcmVzOwogCXN0cnVjdCBzb2NrYWRkcl91biBmcm9tOwogCXNvY2tsZW5fdCBmcm9tbGVuID0gc2l6ZW9mKGZyb20pOwpAQCAtOTg5LDYgKzEzOTAsMTEgQEAKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUkVMT0ciLCA1KSA9PSAwKSB7CiAJCWlmICh3cGFfZGVidWdfcmVvcGVuX2ZpbGUoKSA8IDApCiAJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJTVEFUVVMiKSA9PSAwKSB7CisJCXJlcGx5X2xlbiA9IGhvc3RhcGRfY3RybF9pZmFjZV9zdGF0dXMoaGFwZCwgcmVwbHksCisJCQkJCQkgICAgICByZXBseV9zaXplKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJTVEFUVVMtRFJJVkVSIikgPT0gMCkgeworCQlyZXBseV9sZW4gPSBob3N0YXBkX2Rydl9zdGF0dXMoaGFwZCwgcmVwbHksIHJlcGx5X3NpemUpOwogCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIk1JQiIpID09IDApIHsKIAkJcmVwbHlfbGVuID0gaWVlZTgwMl8xMV9nZXRfbWliKGhhcGQsIHJlcGx5LCByZXBseV9zaXplKTsKIAkJaWYgKHJlcGx5X2xlbiA+PSAwKSB7CkBAIC0xMDE4LDYgKzE0MjQsOSBAQAogCQkJCXJlcGx5X2xlbiArPSByZXM7CiAJCX0KICNlbmRpZiAvKiBDT05GSUdfTk9fUkFESVVTICovCisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIk1JQiAiLCA0KSA9PSAwKSB7CisJCXJlcGx5X2xlbiA9IGhvc3RhcGRfY3RybF9pZmFjZV9taWIoaGFwZCwgcmVwbHksIHJlcGx5X3NpemUsCisJCQkJCQkgICBidWYgKyA0KTsKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJTVEEtRklSU1QiKSA9PSAwKSB7CiAJCXJlcGx5X2xlbiA9IGhvc3RhcGRfY3RybF9pZmFjZV9zdGFfZmlyc3QoaGFwZCwgcmVwbHksCiAJCQkJCQkJIHJlcGx5X3NpemUpOwpAQCAtMTA5Myw2ICsxNTAyLDIyIEBACiAJCQlyZXBseV9sZW4gPSAtMTsKICNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KKyNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNFVF9RT1NfTUFQX1NFVCAiLCAxNikgPT0gMCkgeworCQlpZiAoaG9zdGFwZF9jdHJsX2lmYWNlX3NldF9xb3NfbWFwX3NldChoYXBkLCBidWYgKyAxNikpCisJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU0VORF9RT1NfTUFQX0NPTkYgIiwgMTgpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY3RybF9pZmFjZV9zZW5kX3Fvc19tYXBfY29uZihoYXBkLCBidWYgKyAxOCkpCisJCQlyZXBseV9sZW4gPSAtMTsKKyNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCisjaWZkZWYgQ09ORklHX0hTMjAKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiSFMyMF9XTk1fTk9USUYgIiwgMTUpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY3RybF9pZmFjZV9oczIwX3dubV9ub3RpZihoYXBkLCBidWYgKyAxNSkpCisJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiSFMyMF9ERUFVVEhfUkVRICIsIDE2KSA9PSAwKSB7CisJCWlmIChob3N0YXBkX2N0cmxfaWZhY2VfaHMyMF9kZWF1dGhfcmVxKGhhcGQsIGJ1ZiArIDE2KSkKKwkJCXJlcGx5X2xlbiA9IC0xOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAjaWZkZWYgQ09ORklHX1dOTQogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJESVNBU1NPQ19JTU1JTkVOVCAiLCAxOCkgPT0gMCkgewogCQlpZiAoaG9zdGFwZF9jdHJsX2lmYWNlX2Rpc2Fzc29jX2ltbWluZW50KGhhcGQsIGJ1ZiArIDE4KSkKQEAgLTExMTksNiArMTU0NCwyMSBAQAogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJESVNBQkxFIiwgNykgPT0gMCkgewogCQlpZiAoaG9zdGFwZF9jdHJsX2lmYWNlX2Rpc2FibGUoaGFwZC0+aWZhY2UpKQogCQkJcmVwbHlfbGVuID0gLTE7CisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJSQURBUiAiLCA2KSA9PSAwKSB7CisJCWlmIChob3N0YXBkX2N0cmxfaWZhY2VfcmFkYXIoaGFwZCwgYnVmICsgNikpCisJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiTUdNVF9UWCAiLCA4KSA9PSAwKSB7CisJCWlmIChob3N0YXBkX2N0cmxfaWZhY2VfbWdtdF90eChoYXBkLCBidWYgKyA4KSkKKwkJCXJlcGx5X2xlbiA9IC0xOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiQ0hBTl9TV0lUQ0ggIiwgMTIpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY3RybF9pZmFjZV9jaGFuX3N3aXRjaChoYXBkLT5pZmFjZSwgYnVmICsgMTIpKQorCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlZFTkRPUiAiLCA3KSA9PSAwKSB7CisJCXJlcGx5X2xlbiA9IGhvc3RhcGRfY3RybF9pZmFjZV92ZW5kb3IoaGFwZCwgYnVmICsgNywgcmVwbHksCisJCQkJCQkgICAgICByZXBseV9zaXplKTsKKwogCX0gZWxzZSB7CiAJCW9zX21lbWNweShyZXBseSwgIlVOS05PV04gQ09NTUFORFxuIiwgMTYpOwogCQlyZXBseV9sZW4gPSAxNjsKQEAgLTEzNjcsNiArMTgwNywxNiBAQAogfQogCiAKK3N0YXRpYyB2b2lkIGhvc3RhcGRfY3RybF9pZmFjZV9mbHVzaChzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICppbnRlcmZhY2VzKQoreworI2lmZGVmIENPTkZJR19XUFNfVEVTVElORworCXdwc192ZXJzaW9uX251bWJlciA9IDB4MjA7CisJd3BzX3Rlc3RpbmdfZHVtbXlfY3JlZCA9IDA7CisJd3BzX2NvcnJ1cHRfcGtoYXNoID0gMDsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX1RFU1RJTkcgKi8KK30KKworCiBzdGF0aWMgdm9pZCBob3N0YXBkX2dsb2JhbF9jdHJsX2lmYWNlX3JlY2VpdmUoaW50IHNvY2ssIHZvaWQgKmVsb29wX2N0eCwKIAkJCQkJICAgICAgdm9pZCAqc29ja19jdHgpCiB7CkBAIC0xMzg1LDYgKzE4MzUsNyBAQAogCQlyZXR1cm47CiAJfQogCWJ1ZltyZXNdID0gJ1wwJzsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdsb2JhbCBjdHJsX2lmYWNlIGNvbW1hbmQ6ICVzIiwgYnVmKTsKIAogCW9zX21lbWNweShyZXBseSwgIk9LXG4iLCAzKTsKIAlyZXBseV9sZW4gPSAzOwpAQCAtMTM5MiwxMiArMTg0MywyMyBAQAogCWlmIChvc19zdHJjbXAoYnVmLCAiUElORyIpID09IDApIHsKIAkJb3NfbWVtY3B5KHJlcGx5LCAiUE9OR1xuIiwgNSk7CiAJCXJlcGx5X2xlbiA9IDU7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlJFTE9HIiwgNSkgPT0gMCkgeworCQlpZiAod3BhX2RlYnVnX3Jlb3Blbl9maWxlKCkgPCAwKQorCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiRkxVU0giKSA9PSAwKSB7CisJCWhvc3RhcGRfY3RybF9pZmFjZV9mbHVzaChpbnRlcmZhY2VzKTsKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiQUREICIsIDQpID09IDApIHsKIAkJaWYgKGhvc3RhcGRfY3RybF9pZmFjZV9hZGQoaW50ZXJmYWNlcywgYnVmICsgNCkgPCAwKQogCQkJcmVwbHlfbGVuID0gLTE7CiAJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlJFTU9WRSAiLCA3KSA9PSAwKSB7CiAJCWlmIChob3N0YXBkX2N0cmxfaWZhY2VfcmVtb3ZlKGludGVyZmFjZXMsIGJ1ZiArIDcpIDwgMCkKIAkJCXJlcGx5X2xlbiA9IC0xOworI2lmZGVmIENPTkZJR19NT0RVTEVfVEVTVFMKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJNT0RVTEVfVEVTVFMiKSA9PSAwKSB7CisJCWludCBoYXBkX21vZHVsZV90ZXN0cyh2b2lkKTsKKwkJaWYgKGhhcGRfbW9kdWxlX3Rlc3RzKCkgPCAwKQorCQkJcmVwbHlfbGVuID0gLTE7CisjZW5kaWYgLyogQ09ORklHX01PRFVMRV9URVNUUyAqLwogCX0gZWxzZSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVW5yZWNvZ25pemVkIGdsb2JhbCBjdHJsX2lmYWNlIGNvbW1hbmQgIgogCQkJICAgImlnbm9yZWQiKTsKZGlmZiAtLWdpdCBhL2hvc3RhcGQvZGVmY29uZmlnIGIvaG9zdGFwZC9kZWZjb25maWcKaW5kZXggMmRkNmZjOC4uNWI3NGI2NCAxMDA2NDQKLS0tIGEvaG9zdGFwZC9kZWZjb25maWcKKysrIGIvaG9zdGFwZC9kZWZjb25maWcKQEAgLTIyLDYgKzIyLDE5IEBACiAjIERyaXZlciBpbnRlcmZhY2UgZm9yIGRyaXZlcnMgdXNpbmcgdGhlIG5sODAyMTEga2VybmVsIGludGVyZmFjZQogQ09ORklHX0RSSVZFUl9OTDgwMjExPXkKIAorIyBkcml2ZXJfbmw4MDIxMS5jIHJlcXVpcmVzIGxpYm5sLiBJZiB5b3UgYXJlIGNvbXBpbGluZyBpdCB5b3Vyc2VsZgorIyB5b3UgbWF5IG5lZWQgdG8gcG9pbnQgaG9zdGFwZCB0byB5b3VyIHZlcnNpb24gb2YgbGlibmwuCisjCisjQ0ZMQUdTICs9IC1JJDxwYXRoIHRvIGxpYm5sIGluY2x1ZGUgZmlsZXM+CisjTElCUyArPSAtTCQ8cGF0aCB0byBsaWJubCBsaWJyYXJ5IGZpbGVzPgorCisjIFVzZSBsaWJubCB2Mi4wIChvciAzLjApIGxpYnJhcmllcy4KKyNDT05GSUdfTElCTkwyMD15CisKKyMgVXNlIGxpYm5sIDMuMiBsaWJyYXJpZXMgKGlmIHRoaXMgaXMgc2VsZWN0ZWQsIENPTkZJR19MSUJOTDIwIGlzIGlnbm9yZWQpCisjQ09ORklHX0xJQk5MMzI9eQorCisKICMgRHJpdmVyIGludGVyZmFjZSBmb3IgRnJlZUJTRCBuZXQ4MDIxMSBsYXllciAoZS5nLiwgQXRoZXJvcyBkcml2ZXIpCiAjQ09ORklHX0RSSVZFUl9CU0Q9eQogI0NGTEFHUyArPSAtSS91c3IvbG9jYWwvaW5jbHVkZQpAQCAtNDIsMTAgKzU1LDcgQEAKIENPTkZJR19QRUVSS0VZPXkKIAogIyBJRUVFIDgwMi4xMXcgKG1hbmFnZW1lbnQgZnJhbWUgcHJvdGVjdGlvbikKLSMgVGhpcyB2ZXJzaW9uIGlzIGFuIGV4cGVyaW1lbnRhbCBpbXBsZW1lbnRhdGlvbiBiYXNlZCBvbiBJRUVFIDgwMi4xMXcvRDEuMAotIyBkcmFmdCBhbmQgaXMgc3ViamVjdCB0byBjaGFuZ2Ugc2luY2UgdGhlIHN0YW5kYXJkIGhhcyBub3QgeWV0IGJlZW4gZmluYWxpemVkLgotIyBEcml2ZXIgc3VwcG9ydCBpcyBhbHNvIG5lZWRlZCBmb3IgSUVFRSA4MDIuMTF3LgotI0NPTkZJR19JRUVFODAyMTFXPXkKK0NPTkZJR19JRUVFODAyMTFXPXkKIAogIyBJbnRlZ3JhdGVkIEVBUCBzZXJ2ZXIKIENPTkZJR19FQVA9eQpAQCAtOTYsMTYgKzEwNiwxMyBAQAogI0NPTkZJR19FQVBfR1BTS19TSEEyNTY9eQogCiAjIEVBUC1GQVNUIGZvciB0aGUgaW50ZWdyYXRlZCBFQVAgc2VydmVyCi0jIE5vdGU6IERlZmF1bHQgT3BlblNTTCBwYWNrYWdlIGRvZXMgbm90IGluY2x1ZGUgc3VwcG9ydCBmb3IgYWxsIHRoZQotIyBmdW5jdGlvbmFsaXR5IG5lZWRlZCBmb3IgRUFQLUZBU1QuIElmIEVBUC1GQVNUIGlzIGVuYWJsZWQgd2l0aCBPcGVuU1NMLAotIyB0aGUgT3BlblNTTCBsaWJyYXJ5IG11c3QgYmUgcGF0Y2hlZCAob3BlbnNzbC0wLjkuOS1zZXNzaW9uLXRpY2tldC5wYXRjaCkKLSMgdG8gYWRkIHRoZSBuZWVkZWQgZnVuY3Rpb25zLgorIyBOb3RlOiBJZiBPcGVuU1NMIGlzIHVzZWQgYXMgdGhlIFRMUyBsaWJyYXJ5LCBPcGVuU1NMIDEuMCBvciBuZXdlciBpcyBuZWVkZWQKKyMgZm9yIEVBUC1GQVNUIHN1cHBvcnQuIE9sZGVyIE9wZW5TU0wgcmVsZWFzZXMgd291bGQgbmVlZCB0byBiZSBwYXRjaGVkLCBlLmcuLAorIyB3aXRoIG9wZW5zc2wtMC45Ljh4LXRscy1leHRlbnNpb25zLnBhdGNoLCB0byBhZGQgdGhlIG5lZWRlZCBmdW5jdGlvbnMuCiAjQ09ORklHX0VBUF9GQVNUPXkKIAogIyBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAgKFdQUykKICNDT05GSUdfV1BTPXkKLSMgRW5hYmxlIFdTQyAyLjAgc3VwcG9ydAotI0NPTkZJR19XUFMyPXkKICMgRW5hYmxlIFVQblAgc3VwcG9ydCBmb3IgZXh0ZXJuYWwgV1BTIFJlZ2lzdHJhcnMKICNDT05GSUdfV1BTX1VQTlA9eQogIyBFbmFibGUgV1BTIHN1cHBvcnQgd2l0aCBORkMgY29uZmlnIG1ldGhvZApAQCAtMTU3LDYgKzE2NCwxMiBAQAogIyBEaXNhYmxlZCBieSBkZWZhdWx0LgogI0NPTkZJR19ERUJVR19GSUxFPXkKIAorIyBBZGQgc3VwcG9ydCBmb3Igc2VuZGluZyBhbGwgZGVidWcgbWVzc2FnZXMgKHJlZ2FyZGxlc3Mgb2YgZGVidWcgdmVyYm9zaXR5KQorIyB0byB0aGUgTGludXgga2VybmVsIHRyYWNpbmcgZmFjaWxpdHkuIFRoaXMgaGVscHMgZGVidWcgdGhlIGVudGlyZSBzdGFjayBieQorIyBtYWtpbmcgaXQgZWFzeSB0byByZWNvcmQgZXZlcnl0aGluZyBoYXBwZW5pbmcgZnJvbSB0aGUgZHJpdmVyIHVwIGludG8gdGhlCisjIHNhbWUgZmlsZSwgZS5nLiwgdXNpbmcgdHJhY2UtY21kLgorI0NPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HPXkKKwogIyBSZW1vdmUgc3VwcG9ydCBmb3IgUkFESVVTIGFjY291bnRpbmcKICNDT05GSUdfTk9fQUNDT1VOVElORz15CiAKQEAgLTE3NCw3ICsxODcsNyBAQAogIyBOb3RlOiBUaGlzIHJlcXVpcmVzIGxpYm5sIDMuMSBvciBuZXdlci4KICNDT05GSUdfVkxBTl9ORVRMSU5LPXkKIAotIyBSZW1vdmUgc3VwcG9ydCBmb3IgZHVtcGluZyBzdGF0ZSBpbnRvIGEgZmlsZSBvbiBTSUdVU1IxIHNpZ25hbAorIyBSZW1vdmUgc3VwcG9ydCBmb3IgZHVtcGluZyBpbnRlcm5hbCBzdGF0ZSB0aHJvdWdoIGNvbnRyb2wgaW50ZXJmYWNlIGNvbW1hbmRzCiAjIFRoaXMgY2FuIGJlIHVzZWQgdG8gcmVkdWNlIGJpbmFyeSBzaXplIGF0IHRoZSBjb3N0IG9mIGRpc2FibGluZyBhIGRlYnVnZ2luZwogIyBvcHRpb24uCiAjQ09ORklHX05PX0RVTVBfU1RBVEU9eQpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9kdW1wX3N0YXRlLmMgYi9ob3N0YXBkL2R1bXBfc3RhdGUuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmNkOTg5MC4uMDAwMDAwMAotLS0gYS9ob3N0YXBkL2R1bXBfc3RhdGUuYworKysgL2Rldi9udWxsCkBAIC0xLDE4OSArMCwwIEBACi0vKgotICogaG9zdGFwZCAvIFN0YXRlIGR1bXAKLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgotICoKLSAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCi0gKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCi0gKi8KLQotI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCi0jaW5jbHVkZSA8dGltZS5oPgotCi0jaW5jbHVkZSAidXRpbHMvY29tbW9uLmgiCi0jaW5jbHVkZSAicmFkaXVzL3JhZGl1c19jbGllbnQuaCIKLSNpbmNsdWRlICJyYWRpdXMvcmFkaXVzX3NlcnZlci5oIgotI2luY2x1ZGUgImVhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbS5oIgotI2luY2x1ZGUgImVhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbV9pLmgiCi0jaW5jbHVkZSAiZWFwX3NlcnZlci9lYXAuaCIKLSNpbmNsdWRlICJhcC9ob3N0YXBkLmgiCi0jaW5jbHVkZSAiYXAvYXBfY29uZmlnLmgiCi0jaW5jbHVkZSAiYXAvc3RhX2luZm8uaCIKLSNpbmNsdWRlICJkdW1wX3N0YXRlLmgiCi0jaW5jbHVkZSAiYXAvYXBfZHJ2X29wcy5oIgotCi0KLXN0YXRpYyB2b2lkIGZwcmludF9jaGFyKEZJTEUgKmYsIGNoYXIgYykKLXsKLQlpZiAoYyA+PSAzMiAmJiBjIDwgMTI3KQotCQlmcHJpbnRmKGYsICIlYyIsIGMpOwotCWVsc2UKLQkJZnByaW50ZihmLCAiPCUwMng+IiwgYyk7Ci19Ci0KLQotc3RhdGljIHZvaWQgaWVlZTgwMl8xeF9kdW1wX3N0YXRlKEZJTEUgKmYsIGNvbnN0IGNoYXIgKnByZWZpeCwKLQkJCQkgIHN0cnVjdCBzdGFfaW5mbyAqc3RhKQotewotCXN0cnVjdCBlYXBvbF9zdGF0ZV9tYWNoaW5lICpzbSA9IHN0YS0+ZWFwb2xfc207Ci0JaWYgKHNtID09IE5VTEwpCi0JCXJldHVybjsKLQotCWZwcmludGYoZiwgIiVzSUVFRSA4MDIuMVg6XG4iLCBwcmVmaXgpOwotCi0JaWYgKHNtLT5pZGVudGl0eSkgewotCQlzaXplX3QgaTsKLQkJZnByaW50ZihmLCAiJXNpZGVudGl0eT0iLCBwcmVmaXgpOwotCQlmb3IgKGkgPSAwOyBpIDwgc20tPmlkZW50aXR5X2xlbjsgaSsrKQotCQkJZnByaW50X2NoYXIoZiwgc20tPmlkZW50aXR5W2ldKTsKLQkJZnByaW50ZihmLCAiXG4iKTsKLQl9Ci0KLQlmcHJpbnRmKGYsICIlc2xhc3QgRUFQIHR5cGU6IEF1dGhlbnRpY2F0aW9uIFNlcnZlcjogJWQgKCVzKSAiCi0JCSJTdXBwbGljYW50OiAlZCAoJXMpXG4iLCBwcmVmaXgsCi0JCXNtLT5lYXBfdHlwZV9hdXRoc3J2LAotCQllYXBfc2VydmVyX2dldF9uYW1lKDAsIHNtLT5lYXBfdHlwZV9hdXRoc3J2KSwKLQkJc20tPmVhcF90eXBlX3N1cHAsIGVhcF9zZXJ2ZXJfZ2V0X25hbWUoMCwgc20tPmVhcF90eXBlX3N1cHApKTsKLQotCWZwcmludGYoZiwgIiVzY2FjaGVkX3BhY2tldHM9JXNcbiIsIHByZWZpeCwKLQkJc20tPmxhc3RfcmVjdl9yYWRpdXMgPyAiW1JYIFJBRElVU10iIDogIiIpOwotCi0JZWFwb2xfYXV0aF9kdW1wX3N0YXRlKGYsIHByZWZpeCwgc20pOwotfQotCi0KLS8qKgotICogaG9zdGFwZF9kdW1wX3N0YXRlIC0gU0lHVVNSMSBoYW5kbGVyIHRvIGR1bXAgaG9zdGFwZCBzdGF0ZSB0byBhIHRleHQgZmlsZQotICovCi1zdGF0aWMgdm9pZCBob3N0YXBkX2R1bXBfc3RhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKLXsKLQlGSUxFICpmOwotCXRpbWVfdCBub3c7Ci0Jc3RydWN0IHN0YV9pbmZvICpzdGE7Ci0JaW50IGk7Ci0jaWZuZGVmIENPTkZJR19OT19SQURJVVMKLQljaGFyICpidWY7Ci0jZW5kaWYgLyogQ09ORklHX05PX1JBRElVUyAqLwotCXN0cnVjdCBob3N0YXBfc3RhX2RyaXZlcl9kYXRhIGRhdGE7Ci0KLQlpZiAoIWhhcGQtPmNvbmYtPmR1bXBfbG9nX25hbWUpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEdW1wIGZpbGUgbm90IGRlZmluZWQgLSBpZ25vcmluZyBkdW1wICIKLQkJCSAgICJyZXF1ZXN0Iik7Ci0JCXJldHVybjsKLQl9Ci0KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkR1bXBpbmcgaG9zdGFwZCBzdGF0ZSB0byAnJXMnIiwKLQkJICAgaGFwZC0+Y29uZi0+ZHVtcF9sb2dfbmFtZSk7Ci0JZiA9IGZvcGVuKGhhcGQtPmNvbmYtPmR1bXBfbG9nX25hbWUsICJ3Iik7Ci0JaWYgKGYgPT0gTlVMTCkgewotCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiQ291bGQgbm90IG9wZW4gZHVtcCBmaWxlICclcycgZm9yICIKLQkJCSAgICJ3cml0aW5nLiIsIGhhcGQtPmNvbmYtPmR1bXBfbG9nX25hbWUpOwotCQlyZXR1cm47Ci0JfQotCi0JdGltZSgmbm93KTsKLQlmcHJpbnRmKGYsICJob3N0YXBkIHN0YXRlIGR1bXAgLSAlcyIsIGN0aW1lKCZub3cpKTsKLQlmcHJpbnRmKGYsICJudW1fc3RhPSVkIG51bV9zdGFfbm9uX2VycD0lZCAiCi0JCSJudW1fc3RhX25vX3Nob3J0X3Nsb3RfdGltZT0lZFxuIgotCQkibnVtX3N0YV9ub19zaG9ydF9wcmVhbWJsZT0lZFxuIiwKLQkJaGFwZC0+bnVtX3N0YSwgaGFwZC0+aWZhY2UtPm51bV9zdGFfbm9uX2VycCwKLQkJaGFwZC0+aWZhY2UtPm51bV9zdGFfbm9fc2hvcnRfc2xvdF90aW1lLAotCQloYXBkLT5pZmFjZS0+bnVtX3N0YV9ub19zaG9ydF9wcmVhbWJsZSk7Ci0KLQlmb3IgKHN0YSA9IGhhcGQtPnN0YV9saXN0OyBzdGEgIT0gTlVMTDsgc3RhID0gc3RhLT5uZXh0KSB7Ci0JCWZwcmludGYoZiwgIlxuU1RBPSIgTUFDU1RSICJcbiIsIE1BQzJTVFIoc3RhLT5hZGRyKSk7Ci0KLQkJZnByaW50ZihmLAotCQkJIiAgQUlEPSVkIGZsYWdzPTB4JXggJXMlcyVzJXMlcyVzJXMlcyVzJXMlcyVzJXMlcyVzJXMiCi0JCQkiXG4iCi0JCQkiICBjYXBhYmlsaXR5PTB4JXggbGlzdGVuX2ludGVydmFsPSVkXG4iLAotCQkJc3RhLT5haWQsCi0JCQlzdGEtPmZsYWdzLAotCQkJKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9BVVRIID8gIltBVVRIXSIgOiAiIiksCi0JCQkoc3RhLT5mbGFncyAmIFdMQU5fU1RBX0FTU09DID8gIltBU1NPQ10iIDogIiIpLAotCQkJKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9QUyA/ICJbUFNdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfVElNID8gIltUSU1dIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfUEVSTSA/ICJbUEVSTV0iIDogIiIpLAotCQkJKGFwX3N0YV9pc19hdXRob3JpemVkKHN0YSkgPyAiW0FVVEhPUklaRURdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfUEVORElOR19QT0xMID8gIltQRU5ESU5HX1BPTEwiIDoKLQkJCSAiIiksCi0JCQkoc3RhLT5mbGFncyAmIFdMQU5fU1RBX1NIT1JUX1BSRUFNQkxFID8KLQkJCSAiW1NIT1JUX1BSRUFNQkxFXSIgOiAiIiksCi0JCQkoc3RhLT5mbGFncyAmIFdMQU5fU1RBX1BSRUFVVEggPyAiW1BSRUFVVEhdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfV01NID8gIltXTU1dIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfTUZQID8gIltNRlBdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfV1BTID8gIltXUFNdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfTUFZQkVfV1BTID8gIltNQVlCRV9XUFNdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfV0RTID8gIltXRFNdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfTk9ORVJQID8gIltOb25FUlBdIiA6ICIiKSwKLQkJCShzdGEtPmZsYWdzICYgV0xBTl9TVEFfV1BTMiA/ICJbV1BTMl0iIDogIiIpLAotCQkJc3RhLT5jYXBhYmlsaXR5LAotCQkJc3RhLT5saXN0ZW5faW50ZXJ2YWwpOwotCi0JCWZwcmludGYoZiwgIiAgc3VwcG9ydGVkX3JhdGVzPSIpOwotCQlmb3IgKGkgPSAwOyBpIDwgc3RhLT5zdXBwb3J0ZWRfcmF0ZXNfbGVuOyBpKyspCi0JCQlmcHJpbnRmKGYsICIlMDJ4ICIsIHN0YS0+c3VwcG9ydGVkX3JhdGVzW2ldKTsKLQkJZnByaW50ZihmLCAiXG4iKTsKLQotCQlmcHJpbnRmKGYsCi0JCQkiICB0aW1lb3V0X25leHQ9JXNcbiIsCi0JCQkoc3RhLT50aW1lb3V0X25leHQgPT0gU1RBX05VTExGVU5DID8gIk5VTExGVU5DIFBPTEwiIDoKLQkJCSAoc3RhLT50aW1lb3V0X25leHQgPT0gU1RBX0RJU0FTU09DID8gIkRJU0FTU09DIiA6Ci0JCQkgICJERUFVVEgiKSkpOwotCi0JCWllZWU4MDJfMXhfZHVtcF9zdGF0ZShmLCAiICAiLCBzdGEpOwotCi0JCWlmIChob3N0YXBkX2Rydl9yZWFkX3N0YV9kYXRhKGhhcGQsICZkYXRhLCBzdGEtPmFkZHIpID09IDApIHsKLQkJCWZwcmludGYoZiwgIiAgcnhfcGt0PSVsdSB0eF9wa3Q9JWx1XG4iCi0JCQkJIiAgcnhfYnl0ZT0lbHUgdHhfYnl0ZT0lbHVcbiIsCi0JCQkJZGF0YS5yeF9wYWNrZXRzLCBkYXRhLnR4X3BhY2tldHMsCi0JCQkJZGF0YS5yeF9ieXRlcywgZGF0YS50eF9ieXRlcyk7Ci0JCX0KLQl9Ci0KLSNpZm5kZWYgQ09ORklHX05PX1JBRElVUwotCWJ1ZiA9IG9zX21hbGxvYyg0MDk2KTsKLQlpZiAoYnVmKSB7Ci0JCWludCBjb3VudCA9IHJhZGl1c19jbGllbnRfZ2V0X21pYihoYXBkLT5yYWRpdXMsIGJ1ZiwgNDA5Nik7Ci0JCWlmIChjb3VudCA8IDApCi0JCQljb3VudCA9IDA7Ci0JCWVsc2UgaWYgKGNvdW50ID4gNDA5NSkKLQkJCWNvdW50ID0gNDA5NTsKLQkJYnVmW2NvdW50XSA9ICdcMCc7Ci0JCWZwcmludGYoZiwgIiVzIiwgYnVmKTsKLQotI2lmZGVmIFJBRElVU19TRVJWRVIKLQkJY291bnQgPSByYWRpdXNfc2VydmVyX2dldF9taWIoaGFwZC0+cmFkaXVzX3NydiwgYnVmLCA0MDk2KTsKLQkJaWYgKGNvdW50IDwgMCkKLQkJCWNvdW50ID0gMDsKLQkJZWxzZSBpZiAoY291bnQgPiA0MDk1KQotCQkJY291bnQgPSA0MDk1OwotCQlidWZbY291bnRdID0gJ1wwJzsKLQkJZnByaW50ZihmLCAiJXMiLCBidWYpOwotI2VuZGlmIC8qIFJBRElVU19TRVJWRVIgKi8KLQotCQlvc19mcmVlKGJ1Zik7Ci0JfQotI2VuZGlmIC8qIENPTkZJR19OT19SQURJVVMgKi8KLQlmY2xvc2UoZik7Ci19Ci0KLQotaW50IGhhbmRsZV9kdW1wX3N0YXRlX2lmYWNlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgdm9pZCAqY3R4KQotewotCXNpemVfdCBpOwotCi0JZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspCi0JCWhvc3RhcGRfZHVtcF9zdGF0ZShpZmFjZS0+YnNzW2ldKTsKLQotCXJldHVybiAwOwotfQpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9kdW1wX3N0YXRlLmggYi9ob3N0YXBkL2R1bXBfc3RhdGUuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTIwOWQ2NS4uMDAwMDAwMAotLS0gYS9ob3N0YXBkL2R1bXBfc3RhdGUuaAorKysgL2Rldi9udWxsCkBAIC0xLDE0ICswLDAgQEAKLS8qCi0gKiBob3N0YXBkIC8gU3RhdGUgZHVtcAotICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+Ci0gKgotICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KLSAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KLSAqLwotCi0jaWZuZGVmIERVTVBfU1RBVEVfSAotI2RlZmluZSBEVU1QX1NUQVRFX0gKLQotaW50IGhhbmRsZV9kdW1wX3N0YXRlX2lmYWNlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgdm9pZCAqY3R4KTsKLQotI2VuZGlmIC8qIERVTVBfU1RBVEVfSCAqLwpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9lYXBfcmVnaXN0ZXIuYyBiL2hvc3RhcGQvZWFwX3JlZ2lzdGVyLmMKaW5kZXggOTgxZTUzOS4uODQ3N2MyMSAxMDA2NDQKLS0tIGEvaG9zdGFwZC9lYXBfcmVnaXN0ZXIuYworKysgYi9ob3N0YXBkL2VhcF9yZWdpc3Rlci5jCkBAIC00NCw2ICs0NCwxMyBAQAogCQlyZXQgPSBlYXBfc2VydmVyX3VuYXV0aF90bHNfcmVnaXN0ZXIoKTsKICNlbmRpZiAvKiBFQVBfU0VSVkVSX1RMUyAqLwogCisjaWZkZWYgRUFQX1NFUlZFUl9UTFMKKyNpZmRlZiBDT05GSUdfSFMyMAorCWlmIChyZXQgPT0gMCkKKwkJcmV0ID0gZWFwX3NlcnZlcl93ZmFfdW5hdXRoX3Rsc19yZWdpc3RlcigpOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisjZW5kaWYgLyogRUFQX1NFUlZFUl9UTFMgKi8KKwogI2lmZGVmIEVBUF9TRVJWRVJfTVNDSEFQVjIKIAlpZiAocmV0ID09IDApCiAJCXJldCA9IGVhcF9zZXJ2ZXJfbXNjaGFwdjJfcmVnaXN0ZXIoKTsKZGlmZiAtLWdpdCBhL2hvc3RhcGQvaGFwZF9tb2R1bGVfdGVzdHMuYyBiL2hvc3RhcGQvaGFwZF9tb2R1bGVfdGVzdHMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mNzg4N2ViCi0tLSAvZGV2L251bGwKKysrIGIvaG9zdGFwZC9oYXBkX21vZHVsZV90ZXN0cy5jCkBAIC0wLDAgKzEsMTcgQEAKKy8qCisgKiBob3N0YXBkIG1vZHVsZSB0ZXN0cworICogQ29weXJpZ2h0IChjKSAyMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKworaW50IGhhcGRfbW9kdWxlX3Rlc3RzKHZvaWQpCit7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgImhvc3RhcGQgbW9kdWxlIHRlc3RzIik7CisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9ob3N0YXBkL2hscl9hdWNfZ3cuYyBiL2hvc3RhcGQvaGxyX2F1Y19ndy5jCmluZGV4IGUwNGUyZTkuLmMwNDE4ODcgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvaGxyX2F1Y19ndy5jCisrKyBiL2hvc3RhcGQvaGxyX2F1Y19ndy5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIEhMUi9BdUMgdGVzdGluZyBnYXRld2F5IGZvciBob3N0YXBkIEVBUC1TSU0vQUtBIGRhdGFiYXNlL2F1dGhlbnRpY2F0b3IKLSAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA3LCAyMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDcsIDIwMTItMjAxMywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTgsNiArMTgsOSBAQAogICogU0lNLVJFUS1BVVRIIDxJTVNJPiA8bWF4X2NoYWw+CiAgKiBTSU0tUkVTUC1BVVRIIDxJTVNJPiBLYzE6U1JFUzE6UkFORDEgS2MyOlNSRVMyOlJBTkQyIFtLYzM6U1JFUzM6UkFORDNdCiAgKiBTSU0tUkVTUC1BVVRIIDxJTVNJPiBGQUlMVVJFCisgKiBHU00tQVVUSC1SRVEgPElNU0k+IFJBTkQxOlJBTkQyWzpSQU5EM10KKyAqIEdTTS1BVVRILVJFU1AgPElNU0k+IEtjMTpTUkVTMTpLYzI6U1JFUzJbOktjMzpTUkVTM10KKyAqIEdTTS1BVVRILVJFU1AgPElNU0k+IEZBSUxVUkUKICAqCiAgKiBFQVAtQUtBIC8gVU1UUyBxdWVyeS9yZXNwb25zZToKICAqIEFLQS1SRVEtQVVUSCA8SU1TST4KQEAgLTMwLDEyICszMywxNiBAQAogICogSU1TSSBhbmQgbWF4X2NoYWwgYXJlIHNlbnQgYXMgYW4gQVNDSUkgc3RyaW5nLAogICogS2MvU1JFUy9SQU5EL0FVVE4vSUsvQ0svUkVTL0FVVFMgYXMgaGV4IHN0cmluZ3MuCiAgKgotICogVGhlIGV4YW1wbGUgaW1wbGVtZW50YXRpb24gaGVyZSByZWFkcyBHU00gYXV0aGVudGljYXRpb24gdHJpcGxldHMgZnJvbSBhCisgKiBBbiBleGFtcGxlIGltcGxlbWVudGF0aW9uIGhlcmUgcmVhZHMgR1NNIGF1dGhlbnRpY2F0aW9uIHRyaXBsZXRzIGZyb20gYQogICogdGV4dCBmaWxlIGluIElNU0k6S2M6U1JFUzpSQU5EIGZvcm1hdCwgSU1TSSBpbiBBU0NJSSwgb3RoZXIgZmllbGRzIGFzIGhleAogICogc3RyaW5ncy4gVGhpcyBpcyB1c2VkIHRvIHNpbXVsYXRlIGFuIEhMUi9BdUMuIEFzIHN1Y2gsIGl0IGlzIG5vdCB2ZXJ5IHVzZWZ1bAogICogZm9yIHJlYWwgbGlmZSBhdXRoZW50aWNhdGlvbiwgYnV0IGl0IGlzIHVzZWZ1bCBib3RoIGFzIGFuIGV4YW1wbGUKICAqIGltcGxlbWVudGF0aW9uIGFuZCBmb3IgRUFQLVNJTS9BS0EvQUtBJyB0ZXN0aW5nLgogICoKKyAqIEZvciBhIHN0cm9uZ2VyIGV4YW1wbGUgZGVzaWduLCBNaWxlbmFnZSBhbmQgR1NNLU1pbGVuYWdlIGFsZ29yaXRobXMgY2FuIGJlCisgKiB1c2VkIHRvIGR5bmFtaWNhbGx5IGdlbmVyYXRlIGF1dGhlbnRpY2F0aXBuIGluZm9ybWF0aW9uIGZvciBFQVAtQUtBL0FLQScgYW5kCisgKiBFQVAtU0lNLCByZXNwZWN0aXZlbHksIGlmIEtpIGlzIGtub3duLgorICoKICAqIFNRTiBnZW5lcmF0aW9uIGZvbGxvd3MgdGhlIG5vdCB0aW1lLWJhc2VkIFByb2ZpbGUgMiBkZXNjcmliZWQgaW4KICAqIDNHUFAgVFMgMzMuMTAyIEFubmV4IEMuMy4yLiBUaGUgbGVuZ3RoIG9mIElORCBpcyA1IGJpdHMgYnkgZGVmYXVsdCwgYnV0IHRoaXMKICAqIGNhbiBiZSBjaGFuZ2VkIHdpdGggYSBjb21tYW5kIGxpbmUgb3B0aW9ucyBpZiBuZWVkZWQuCkBAIC01OCw2ICs2NSw3IEBACiBzdGF0aWMgaW50IHVwZGF0ZV9taWxlbmFnZSA9IDA7CiBzdGF0aWMgaW50IHNxbl9jaGFuZ2VzID0gMDsKIHN0YXRpYyBpbnQgaW5kX2xlbiA9IDU7CitzdGF0aWMgaW50IHN0ZG91dF9kZWJ1ZyA9IDE7CiAKIC8qIEdTTSB0cmlwbGV0cyAqLwogc3RydWN0IGdzbV90cmlwbGV0IHsKQEAgLTIxNCw2ICsyMjIsOSBAQAogewogCWNoYXIgY21kWzEyOF0sIHZhbFsxM10sICpwb3M7CiAKKwlpZiAoc3FsaXRlX2RiID09IE5VTEwpCisJCXJldHVybiAwOworCiAJcG9zID0gdmFsOwogCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgc2l6ZW9mKHZhbCksIG0tPnNxbiwgNik7CiAJKnBvcyA9ICdcMCc7CkBAIC02MTEsMzEgKzYyMiwzMCBAQAogfQogCiAKLXN0YXRpYyB2b2lkIHNpbV9yZXFfYXV0aChpbnQgcywgc3RydWN0IHNvY2thZGRyX3VuICpmcm9tLCBzb2NrbGVuX3QgZnJvbWxlbiwKLQkJCSBjaGFyICppbXNpKQorc3RhdGljIGludCBzaW1fcmVxX2F1dGgoY2hhciAqaW1zaSwgY2hhciAqcmVzcCwgc2l6ZV90IHJlc3BfbGVuKQogewogCWludCBjb3VudCwgbWF4X2NoYWwsIHJldDsKIAljaGFyICpwb3M7Ci0JY2hhciByZXBseVsxMDAwXSwgKnJwb3MsICpyZW5kOworCWNoYXIgKnJwb3MsICpyZW5kOwogCXN0cnVjdCBtaWxlbmFnZV9wYXJhbWV0ZXJzICptOwogCXN0cnVjdCBnc21fdHJpcGxldCAqZzsKIAotCXJlcGx5WzBdID0gJ1wwJzsKKwlyZXNwWzBdID0gJ1wwJzsKIAogCXBvcyA9IHN0cmNocihpbXNpLCAnICcpOwogCWlmIChwb3MpIHsKIAkJKnBvcysrID0gJ1wwJzsKIAkJbWF4X2NoYWwgPSBhdG9pKHBvcyk7Ci0JCWlmIChtYXhfY2hhbCA8IDEgfHwgbWF4X2NoYWwgPCBFQVBfU0lNX01BWF9DSEFMKQorCQlpZiAobWF4X2NoYWwgPCAxIHx8IG1heF9jaGFsID4gRUFQX1NJTV9NQVhfQ0hBTCkKIAkJCW1heF9jaGFsID0gRUFQX1NJTV9NQVhfQ0hBTDsKIAl9IGVsc2UKIAkJbWF4X2NoYWwgPSBFQVBfU0lNX01BWF9DSEFMOwogCi0JcmVuZCA9ICZyZXBseVtzaXplb2YocmVwbHkpXTsKLQlycG9zID0gcmVwbHk7CisJcmVuZCA9IHJlc3AgKyByZXNwX2xlbjsKKwlycG9zID0gcmVzcDsKIAlyZXQgPSBzbnByaW50ZihycG9zLCByZW5kIC0gcnBvcywgIlNJTS1SRVNQLUFVVEggJXMiLCBpbXNpKTsKIAlpZiAocmV0IDwgMCB8fCByZXQgPj0gcmVuZCAtIHJwb3MpCi0JCXJldHVybjsKKwkJcmV0dXJuIC0xOwogCXJwb3MgKz0gcmV0OwogCiAJbSA9IGdldF9taWxlbmFnZShpbXNpKTsKQEAgLTY0Myw3ICs2NTMsNyBAQAogCQl1OCBfcmFuZFsxNl0sIHNyZXNbNF0sIGtjWzhdOwogCQlmb3IgKGNvdW50ID0gMDsgY291bnQgPCBtYXhfY2hhbDsgY291bnQrKykgewogCQkJaWYgKHJhbmRvbV9nZXRfYnl0ZXMoX3JhbmQsIDE2KSA8IDApCi0JCQkJcmV0dXJuOworCQkJCXJldHVybiAtMTsKIAkJCWdzbV9taWxlbmFnZShtLT5vcGMsIG0tPmtpLCBfcmFuZCwgc3Jlcywga2MpOwogCQkJKnJwb3MrKyA9ICcgJzsKIAkJCXJwb3MgKz0gd3BhX3NucHJpbnRmX2hleChycG9zLCByZW5kIC0gcnBvcywga2MsIDgpOwpAQCAtNjUzLDcgKzY2Myw3IEBACiAJCQlycG9zICs9IHdwYV9zbnByaW50Zl9oZXgocnBvcywgcmVuZCAtIHJwb3MsIF9yYW5kLCAxNik7CiAJCX0KIAkJKnJwb3MgPSAnXDAnOwotCQlnb3RvIHNlbmQ7CisJCXJldHVybiAwOwogCX0KIAogCWNvdW50ID0gMDsKQEAgLTY3NywxNSArNjg3LDYxIEBACiAJCXByaW50ZigiTm8gR1NNIHRyaXBsZXRzIGZvdW5kIGZvciAlc1xuIiwgaW1zaSk7CiAJCXJldCA9IHNucHJpbnRmKHJwb3MsIHJlbmQgLSBycG9zLCAiIEZBSUxVUkUiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IHJlbmQgLSBycG9zKQotCQkJcmV0dXJuOworCQkJcmV0dXJuIC0xOwogCQlycG9zICs9IHJldDsKIAl9CiAKLXNlbmQ6Ci0JcHJpbnRmKCJTZW5kOiAlc1xuIiwgcmVwbHkpOwotCWlmIChzZW5kdG8ocywgcmVwbHksIHJwb3MgLSByZXBseSwgMCwKLQkJICAgKHN0cnVjdCBzb2NrYWRkciAqKSBmcm9tLCBmcm9tbGVuKSA8IDApCi0JCXBlcnJvcigic2VuZCIpOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgZ3NtX2F1dGhfcmVxKGNoYXIgKmltc2ksIGNoYXIgKnJlc3AsIHNpemVfdCByZXNwX2xlbikKK3sKKwlpbnQgY291bnQsIHJldDsKKwljaGFyICpwb3MsICpycG9zLCAqcmVuZDsKKwlzdHJ1Y3QgbWlsZW5hZ2VfcGFyYW1ldGVycyAqbTsKKworCXJlc3BbMF0gPSAnXDAnOworCisJcG9zID0gb3Nfc3RyY2hyKGltc2ksICcgJyk7CisJaWYgKCFwb3MpCisJCXJldHVybiAtMTsKKwkqcG9zKysgPSAnXDAnOworCisJcmVuZCA9IHJlc3AgKyByZXNwX2xlbjsKKwlycG9zID0gcmVzcDsKKwlyZXQgPSBvc19zbnByaW50ZihycG9zLCByZW5kIC0gcnBvcywgIkdTTS1BVVRILVJFU1AgJXMiLCBpbXNpKTsKKwlpZiAocmV0IDwgMCB8fCByZXQgPj0gcmVuZCAtIHJwb3MpCisJCXJldHVybiAtMTsKKwlycG9zICs9IHJldDsKKworCW0gPSBnZXRfbWlsZW5hZ2UoaW1zaSk7CisJaWYgKG0pIHsKKwkJdTggX3JhbmRbMTZdLCBzcmVzWzRdLCBrY1s4XTsKKwkJZm9yIChjb3VudCA9IDA7IGNvdW50IDwgRUFQX1NJTV9NQVhfQ0hBTDsgY291bnQrKykgeworCQkJaWYgKGhleHN0cjJiaW4ocG9zLCBfcmFuZCwgMTYpICE9IDApCisJCQkJcmV0dXJuIC0xOworCQkJZ3NtX21pbGVuYWdlKG0tPm9wYywgbS0+a2ksIF9yYW5kLCBzcmVzLCBrYyk7CisJCQkqcnBvcysrID0gY291bnQgPT0gMCA/ICcgJyA6ICc6JzsKKwkJCXJwb3MgKz0gd3BhX3NucHJpbnRmX2hleChycG9zLCByZW5kIC0gcnBvcywga2MsIDgpOworCQkJKnJwb3MrKyA9ICc6JzsKKwkJCXJwb3MgKz0gd3BhX3NucHJpbnRmX2hleChycG9zLCByZW5kIC0gcnBvcywgc3JlcywgNCk7CisJCQlwb3MgKz0gMTYgKiAyOworCQkJaWYgKCpwb3MgIT0gJzonKQorCQkJCWJyZWFrOworCQkJcG9zKys7CisJCX0KKwkJKnJwb3MgPSAnXDAnOworCQlyZXR1cm4gMDsKKwl9CisKKwlwcmludGYoIk5vIEdTTSB0cmlwbGV0cyBmb3VuZCBmb3IgJXNcbiIsIGltc2kpOworCXJldCA9IG9zX3NucHJpbnRmKHJwb3MsIHJlbmQgLSBycG9zLCAiIEZBSUxVUkUiKTsKKwlpZiAocmV0IDwgMCB8fCByZXQgPj0gcmVuZCAtIHJwb3MpCisJCXJldHVybiAtMTsKKwlycG9zICs9IHJldDsKKworCXJldHVybiAwOwogfQogCiAKQEAgLTcxMSwxMSArNzY3LDEwIEBACiB9CiAKIAotc3RhdGljIHZvaWQgYWthX3JlcV9hdXRoKGludCBzLCBzdHJ1Y3Qgc29ja2FkZHJfdW4gKmZyb20sIHNvY2tsZW5fdCBmcm9tbGVuLAotCQkJIGNoYXIgKmltc2kpCitzdGF0aWMgaW50IGFrYV9yZXFfYXV0aChjaGFyICppbXNpLCBjaGFyICpyZXNwLCBzaXplX3QgcmVzcF9sZW4pCiB7CiAJLyogQUtBLVJFU1AtQVVUSCA8SU1TST4gPFJBTkQ+IDxBVVROPiA8SUs+IDxDSz4gPFJFUz4gKi8KLQljaGFyIHJlcGx5WzEwMDBdLCAqcG9zLCAqZW5kOworCWNoYXIgKnBvcywgKmVuZDsKIAl1OCBfcmFuZFtFQVBfQUtBX1JBTkRfTEVOXTsKIAl1OCBhdXRuW0VBUF9BS0FfQVVUTl9MRU5dOwogCXU4IGlrW0VBUF9BS0FfSUtfTEVOXTsKQEAgLTcyOSwxNiArNzg0LDE4IEBACiAJbSA9IGdldF9taWxlbmFnZShpbXNpKTsKIAlpZiAobSkgewogCQlpZiAocmFuZG9tX2dldF9ieXRlcyhfcmFuZCwgRUFQX0FLQV9SQU5EX0xFTikgPCAwKQotCQkJcmV0dXJuOworCQkJcmV0dXJuIC0xOwogCQlyZXNfbGVuID0gRUFQX0FLQV9SRVNfTUFYX0xFTjsKIAkJaW5jX3NxbihtLT5zcW4pOwogI2lmZGVmIENPTkZJR19TUUxJVEUKIAkJZGJfdXBkYXRlX21pbGVuYWdlX3NxbihtKTsKICNlbmRpZiAvKiBDT05GSUdfU1FMSVRFICovCiAJCXNxbl9jaGFuZ2VzID0gMTsKLQkJcHJpbnRmKCJBS0E6IE1pbGVuYWdlIHdpdGggU1FOPSUwMnglMDJ4JTAyeCUwMnglMDJ4JTAyeFxuIiwKLQkJICAgICAgIG0tPnNxblswXSwgbS0+c3FuWzFdLCBtLT5zcW5bMl0sCi0JCSAgICAgICBtLT5zcW5bM10sIG0tPnNxbls0XSwgbS0+c3FuWzVdKTsKKwkJaWYgKHN0ZG91dF9kZWJ1ZykgeworCQkJcHJpbnRmKCJBS0E6IE1pbGVuYWdlIHdpdGggU1FOPSUwMnglMDJ4JTAyeCUwMnglMDJ4JTAyeFxuIiwKKwkJCSAgICAgICBtLT5zcW5bMF0sIG0tPnNxblsxXSwgbS0+c3FuWzJdLAorCQkJICAgICAgIG0tPnNxblszXSwgbS0+c3FuWzRdLCBtLT5zcW5bNV0pOworCQl9CiAJCW1pbGVuYWdlX2dlbmVyYXRlKG0tPm9wYywgbS0+YW1mLCBtLT5raSwgbS0+c3FuLCBfcmFuZCwKIAkJCQkgIGF1dG4sIGlrLCBjaywgcmVzLCAmcmVzX2xlbik7CiAJfSBlbHNlIHsKQEAgLTc1NiwxOCArODEzLDE4IEBACiAjZW5kaWYgLyogQUtBX1VTRV9GSVhFRF9URVNUX1ZBTFVFUyAqLwogCX0KIAotCXBvcyA9IHJlcGx5OwotCWVuZCA9ICZyZXBseVtzaXplb2YocmVwbHkpXTsKKwlwb3MgPSByZXNwOworCWVuZCA9IHJlc3AgKyByZXNwX2xlbjsKIAlyZXQgPSBzbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIkFLQS1SRVNQLUFVVEggJXMgIiwgaW1zaSk7CiAJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKLQkJcmV0dXJuOworCQlyZXR1cm4gLTE7CiAJcG9zICs9IHJldDsKIAlpZiAoZmFpbGVkKSB7CiAJCXJldCA9IHNucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiRkFJTFVSRSIpOwogCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQotCQkJcmV0dXJuOworCQkJcmV0dXJuIC0xOwogCQlwb3MgKz0gcmV0OwotCQlnb3RvIGRvbmU7CisJCXJldHVybiAwOwogCX0KIAlwb3MgKz0gd3BhX3NucHJpbnRmX2hleChwb3MsIGVuZCAtIHBvcywgX3JhbmQsIEVBUF9BS0FfUkFORF9MRU4pOwogCSpwb3MrKyA9ICcgJzsKQEAgLTc3OSw2NSArODM2LDg3IEBACiAJKnBvcysrID0gJyAnOwogCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLCByZXMsIHJlc19sZW4pOwogCi1kb25lOgotCXByaW50ZigiU2VuZDogJXNcbiIsIHJlcGx5KTsKLQotCWlmIChzZW5kdG8ocywgcmVwbHksIHBvcyAtIHJlcGx5LCAwLCAoc3RydWN0IHNvY2thZGRyICopIGZyb20sCi0JCSAgIGZyb21sZW4pIDwgMCkKLQkJcGVycm9yKCJzZW5kIik7CisJcmV0dXJuIDA7CiB9CiAKIAotc3RhdGljIHZvaWQgYWthX2F1dHMoaW50IHMsIHN0cnVjdCBzb2NrYWRkcl91biAqZnJvbSwgc29ja2xlbl90IGZyb21sZW4sCi0JCSAgICAgY2hhciAqaW1zaSkKK3N0YXRpYyBpbnQgYWthX2F1dHMoY2hhciAqaW1zaSwgY2hhciAqcmVzcCwgc2l6ZV90IHJlc3BfbGVuKQogewogCWNoYXIgKmF1dHMsICpfX3JhbmQ7CiAJdTggX2F1dHNbRUFQX0FLQV9BVVRTX0xFTl0sIF9yYW5kW0VBUF9BS0FfUkFORF9MRU5dLCBzcW5bNl07CiAJc3RydWN0IG1pbGVuYWdlX3BhcmFtZXRlcnMgKm07CiAKKwlyZXNwWzBdID0gJ1wwJzsKKwogCS8qIEFLQS1BVVRTIDxJTVNJPiA8QVVUUz4gPFJBTkQ+ICovCiAKIAlhdXRzID0gc3RyY2hyKGltc2ksICcgJyk7CiAJaWYgKGF1dHMgPT0gTlVMTCkKLQkJcmV0dXJuOworCQlyZXR1cm4gLTE7CiAJKmF1dHMrKyA9ICdcMCc7CiAKIAlfX3JhbmQgPSBzdHJjaHIoYXV0cywgJyAnKTsKIAlpZiAoX19yYW5kID09IE5VTEwpCi0JCXJldHVybjsKKwkJcmV0dXJuIC0xOwogCSpfX3JhbmQrKyA9ICdcMCc7CiAKLQlwcmludGYoIkFLQS1BVVRTOiBJTVNJPSVzIEFVVFM9JXMgUkFORD0lc1xuIiwgaW1zaSwgYXV0cywgX19yYW5kKTsKKwlpZiAoc3Rkb3V0X2RlYnVnKSB7CisJCXByaW50ZigiQUtBLUFVVFM6IElNU0k9JXMgQVVUUz0lcyBSQU5EPSVzXG4iLAorCQkgICAgICAgaW1zaSwgYXV0cywgX19yYW5kKTsKKwl9CiAJaWYgKGhleHN0cjJiaW4oYXV0cywgX2F1dHMsIEVBUF9BS0FfQVVUU19MRU4pIHx8CiAJICAgIGhleHN0cjJiaW4oX19yYW5kLCBfcmFuZCwgRUFQX0FLQV9SQU5EX0xFTikpIHsKIAkJcHJpbnRmKCJDb3VsZCBub3QgcGFyc2UgQVVUUy9SQU5EXG4iKTsKLQkJcmV0dXJuOworCQlyZXR1cm4gLTE7CiAJfQogCiAJbSA9IGdldF9taWxlbmFnZShpbXNpKTsKIAlpZiAobSA9PSBOVUxMKSB7CiAJCXByaW50ZigiVW5rbm93biBJTVNJOiAlc1xuIiwgaW1zaSk7Ci0JCXJldHVybjsKKwkJcmV0dXJuIC0xOwogCX0KIAogCWlmIChtaWxlbmFnZV9hdXRzKG0tPm9wYywgbS0+a2ksIF9yYW5kLCBfYXV0cywgc3FuKSkgewogCQlwcmludGYoIkFLQS1BVVRTOiBJbmNvcnJlY3QgTUFDLVNcbiIpOwogCX0gZWxzZSB7CiAJCW1lbWNweShtLT5zcW4sIHNxbiwgNik7Ci0JCXByaW50ZigiQUtBLUFVVFM6IFJlLXN5bmNocm9uaXplZDogIgotCQkgICAgICAgIlNRTj0lMDJ4JTAyeCUwMnglMDJ4JTAyeCUwMnhcbiIsCi0JCSAgICAgICBzcW5bMF0sIHNxblsxXSwgc3FuWzJdLCBzcW5bM10sIHNxbls0XSwgc3FuWzVdKTsKKwkJaWYgKHN0ZG91dF9kZWJ1ZykgeworCQkJcHJpbnRmKCJBS0EtQVVUUzogUmUtc3luY2hyb25pemVkOiAiCisJCQkgICAgICAgIlNRTj0lMDJ4JTAyeCUwMnglMDJ4JTAyeCUwMnhcbiIsCisJCQkgICAgICAgc3FuWzBdLCBzcW5bMV0sIHNxblsyXSwgc3FuWzNdLCBzcW5bNF0sIHNxbls1XSk7CisJCX0KICNpZmRlZiBDT05GSUdfU1FMSVRFCiAJCWRiX3VwZGF0ZV9taWxlbmFnZV9zcW4obSk7CiAjZW5kaWYgLyogQ09ORklHX1NRTElURSAqLwogCQlzcW5fY2hhbmdlcyA9IDE7CiAJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBwcm9jZXNzX2NtZChjaGFyICpjbWQsIGNoYXIgKnJlc3AsIHNpemVfdCByZXNwX2xlbikKK3sKKwlpZiAob3Nfc3RybmNtcChjbWQsICJTSU0tUkVRLUFVVEggIiwgMTMpID09IDApCisJCXJldHVybiBzaW1fcmVxX2F1dGgoY21kICsgMTMsIHJlc3AsIHJlc3BfbGVuKTsKKworCWlmIChvc19zdHJuY21wKGNtZCwgIkdTTS1BVVRILVJFUSAiLCAxMykgPT0gMCkKKwkJcmV0dXJuIGdzbV9hdXRoX3JlcShjbWQgKyAxMywgcmVzcCwgcmVzcF9sZW4pOworCisJaWYgKG9zX3N0cm5jbXAoY21kLCAiQUtBLVJFUS1BVVRIICIsIDEzKSA9PSAwKQorCQlyZXR1cm4gYWthX3JlcV9hdXRoKGNtZCArIDEzLCByZXNwLCByZXNwX2xlbik7CisKKwlpZiAob3Nfc3RybmNtcChjbWQsICJBS0EtQVVUUyAiLCA5KSA9PSAwKQorCQlyZXR1cm4gYWthX2F1dHMoY21kICsgOSwgcmVzcCwgcmVzcF9sZW4pOworCisJcHJpbnRmKCJVbmtub3duIHJlcXVlc3Q6ICVzXG4iLCBjbWQpOworCXJldHVybiAtMTsKIH0KIAogCiBzdGF0aWMgaW50IHByb2Nlc3MoaW50IHMpCiB7Ci0JY2hhciBidWZbMTAwMF07CisJY2hhciBidWZbMTAwMF0sIHJlc3BbMTAwMF07CiAJc3RydWN0IHNvY2thZGRyX3VuIGZyb207CiAJc29ja2xlbl90IGZyb21sZW47CiAJc3NpemVfdCByZXM7CkBAIC04NTksMTQgKzkzOCwyMSBAQAogCiAJcHJpbnRmKCJSZWNlaXZlZDogJXNcbiIsIGJ1Zik7CiAKLQlpZiAoc3RybmNtcChidWYsICJTSU0tUkVRLUFVVEggIiwgMTMpID09IDApCi0JCXNpbV9yZXFfYXV0aChzLCAmZnJvbSwgZnJvbWxlbiwgYnVmICsgMTMpOwotCWVsc2UgaWYgKHN0cm5jbXAoYnVmLCAiQUtBLVJFUS1BVVRIICIsIDEzKSA9PSAwKQotCQlha2FfcmVxX2F1dGgocywgJmZyb20sIGZyb21sZW4sIGJ1ZiArIDEzKTsKLQllbHNlIGlmIChzdHJuY21wKGJ1ZiwgIkFLQS1BVVRTICIsIDkpID09IDApCi0JCWFrYV9hdXRzKHMsICZmcm9tLCBmcm9tbGVuLCBidWYgKyA5KTsKLQllbHNlCi0JCXByaW50ZigiVW5rbm93biByZXF1ZXN0OiAlc1xuIiwgYnVmKTsKKwlpZiAocHJvY2Vzc19jbWQoYnVmLCByZXNwLCBzaXplb2YocmVzcCkpIDwgMCkgeworCQlwcmludGYoIkZhaWxlZCB0byBwcm9jZXNzIHJlcXVlc3RcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKHJlc3BbMF0gPT0gJ1wwJykgeworCQlwcmludGYoIk5vIHJlc3BvbnNlXG4iKTsKKwkJcmV0dXJuIDA7CisJfQorCisJcHJpbnRmKCJTZW5kOiAlc1xuIiwgcmVzcCk7CisKKwlpZiAoc2VuZHRvKHMsIHJlc3AsIG9zX3N0cmxlbihyZXNwKSwgMCwgKHN0cnVjdCBzb2NrYWRkciAqKSAmZnJvbSwKKwkJICAgZnJvbWxlbikgPCAwKQorCQlwZXJyb3IoInNlbmQiKTsKIAogCXJldHVybiAwOwogfQpAQCAtODk0LDggKzk4MCwxMCBAQAogCQlvc19mcmVlKHByZXYpOwogCX0KIAotCWNsb3NlKHNlcnZfc29jayk7Ci0JdW5saW5rKHNvY2tldF9wYXRoKTsKKwlpZiAoc2Vydl9zb2NrID49IDApCisJCWNsb3NlKHNlcnZfc29jayk7CisJaWYgKHNvY2tldF9wYXRoKQorCQl1bmxpbmsoc29ja2V0X3BhdGgpOwogCiAjaWZkZWYgQ09ORklHX1NRTElURQogCWlmIChzcWxpdGVfZGIpIHsKQEAgLTkxNywxMiArMTAwNSwxMiBAQAogewogCXByaW50ZigiSExSL0F1QyB0ZXN0aW5nIGdhdGV3YXkgZm9yIGhvc3RhcGQgRUFQLVNJTS9BS0EgIgogCSAgICAgICAiZGF0YWJhc2UvYXV0aGVudGljYXRvclxuIgotCSAgICAgICAiQ29weXJpZ2h0IChjKSAyMDA1LTIwMDcsIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+XG4iCisJICAgICAgICJDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNywgMjAxMi0yMDEzLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPlxuIgogCSAgICAgICAiXG4iCiAJICAgICAgICJ1c2FnZTpcbiIKIAkgICAgICAgImhscl9hdWNfZ3cgWy1odV0gWy1zPHNvY2tldCBwYXRoPl0gWy1nPHRyaXBsZXQgZmlsZT5dICIKIAkgICAgICAgIlstbTxtaWxlbmFnZSBmaWxlPl0gXFxcbiIKLQkgICAgICAgIiAgICAgICAgWy1EPERCIGZpbGU+XSBbLWk8SU5EIGxlbiBpbiBiaXRzPl1cbiIKKwkgICAgICAgIiAgICAgICAgWy1EPERCIGZpbGU+XSBbLWk8SU5EIGxlbiBpbiBiaXRzPl0gW2NvbW1hbmRdXG4iCiAJICAgICAgICJcbiIKIAkgICAgICAgIm9wdGlvbnM6XG4iCiAJICAgICAgICIgIC1oID0gc2hvdyB0aGlzIHVzYWdlIGhlbHBcbiIKQEAgLTkzMiw3ICsxMDIwLDE1IEBACiAJICAgICAgICIgIC1nPHRyaXBsZXQgZmlsZT4gPSBwYXRoIGZvciBHU00gYXV0aGVudGljYXRpb24gdHJpcGxldHNcbiIKIAkgICAgICAgIiAgLW08bWlsZW5hZ2UgZmlsZT4gPSBwYXRoIGZvciBNaWxlbmFnZSBrZXlzXG4iCiAJICAgICAgICIgIC1EPERCIGZpbGU+ID0gcGF0aCB0byBTUUxpdGUgZGF0YWJhc2VcbiIKLQkgICAgICAgIiAgLWk8SU5EIGxlbiBpbiBiaXRzPiA9IElORCBsZW5ndGggZm9yIFNRTiAoZGVmYXVsdDogNSlcbiIsCisJICAgICAgICIgIC1pPElORCBsZW4gaW4gYml0cz4gPSBJTkQgbGVuZ3RoIGZvciBTUU4gKGRlZmF1bHQ6IDUpXG4iCisJICAgICAgICJcbiIKKwkgICAgICAgIklmIHRoZSBvcHRpb25hbCBjb21tYW5kIGFyZ3VtZW50LCBsaWtlICIKKwkgICAgICAgIlwiQUtBLVJFUS1BVVRIIDxJTVNJPlwiIGlzIHVzZWQsIGEgc2luZ2xlXG4iCisJICAgICAgICJjb21tYW5kIGlzIHByb2Nlc3NlZCB3aXRoIHJlc3BvbnNlIHNlbnQgdG8gc3Rkb3V0LiBPdGhlcndpc2UsICIKKwkgICAgICAgImhscl9hdWNfZ3cgb3BlbnNcbiIKKwkgICAgICAgImEgY29udHJvbCBpbnRlcmZhY2UgYW5kIHByb2Nlc3NlcyBjb21tYW5kcyBzZW50IHRocm91Z2ggaXQgIgorCSAgICAgICAiKGUuZy4sIGJ5IEVBUCBzZXJ2ZXJcbiIKKwkgICAgICAgImluIGhvc3RhcGQpLlxuIiwKIAkgICAgICAgZGVmYXVsdF9zb2NrZXRfcGF0aCk7CiB9CiAKQEAgLTk0Miw2ICsxMDM4LDcgQEAKIAlpbnQgYzsKIAljaGFyICpnc21fdHJpcGxldF9maWxlID0gTlVMTDsKIAljaGFyICpzcWxpdGVfZGJfZmlsZSA9IE5VTEw7CisJaW50IHJldCA9IDA7CiAKIAlpZiAob3NfcHJvZ3JhbV9pbml0KCkpCiAJCXJldHVybiAtMTsKQEAgLTEwMDUsMTggKzExMDIsMzEgQEAKIAlpZiAobWlsZW5hZ2VfZmlsZSAmJiByZWFkX21pbGVuYWdlKG1pbGVuYWdlX2ZpbGUpIDwgMCkKIAkJcmV0dXJuIC0xOwogCi0Jc2Vydl9zb2NrID0gb3Blbl9zb2NrZXQoc29ja2V0X3BhdGgpOwotCWlmIChzZXJ2X3NvY2sgPCAwKQotCQlyZXR1cm4gLTE7CisJaWYgKG9wdGluZCA9PSBhcmdjKSB7CisJCXNlcnZfc29jayA9IG9wZW5fc29ja2V0KHNvY2tldF9wYXRoKTsKKwkJaWYgKHNlcnZfc29jayA8IDApCisJCQlyZXR1cm4gLTE7CiAKLQlwcmludGYoIkxpc3RlbmluZyBmb3IgcmVxdWVzdHMgb24gJXNcbiIsIHNvY2tldF9wYXRoKTsKKwkJcHJpbnRmKCJMaXN0ZW5pbmcgZm9yIHJlcXVlc3RzIG9uICVzXG4iLCBzb2NrZXRfcGF0aCk7CiAKLQlhdGV4aXQoY2xlYW51cCk7Ci0Jc2lnbmFsKFNJR1RFUk0sIGhhbmRsZV90ZXJtKTsKLQlzaWduYWwoU0lHSU5ULCBoYW5kbGVfdGVybSk7CisJCWF0ZXhpdChjbGVhbnVwKTsKKwkJc2lnbmFsKFNJR1RFUk0sIGhhbmRsZV90ZXJtKTsKKwkJc2lnbmFsKFNJR0lOVCwgaGFuZGxlX3Rlcm0pOwogCi0JZm9yICg7OykKLQkJcHJvY2VzcyhzZXJ2X3NvY2spOworCQlmb3IgKDs7KQorCQkJcHJvY2VzcyhzZXJ2X3NvY2spOworCX0gZWxzZSB7CisJCWNoYXIgYnVmWzEwMDBdOworCQlzb2NrZXRfcGF0aCA9IE5VTEw7CisJCXN0ZG91dF9kZWJ1ZyA9IDA7CisJCWlmIChwcm9jZXNzX2NtZChhcmd2W29wdGluZF0sIGJ1Ziwgc2l6ZW9mKGJ1ZikpIDwgMCkgeworCQkJcHJpbnRmKCJGQUlMXG4iKTsKKwkJCXJldCA9IC0xOworCQl9IGVsc2UgeworCQkJcHJpbnRmKCIlc1xuIiwgYnVmKTsKKwkJfQorCQljbGVhbnVwKCk7CisJfQogCiAjaWZkZWYgQ09ORklHX1NRTElURQogCWlmIChzcWxpdGVfZGIpIHsKQEAgLTEwMjcsNSArMTEzNyw1IEBACiAKIAlvc19wcm9ncmFtX2RlaW5pdCgpOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHJldDsKIH0KZGlmZiAtLWdpdCBhL2hvc3RhcGQvaG9zdGFwZC5jb25mIGIvaG9zdGFwZC9ob3N0YXBkLmNvbmYKaW5kZXggNDU4OTdlZC4uYTdhYjBmNiAxMDA2NDQKLS0tIGEvaG9zdGFwZC9ob3N0YXBkLmNvbmYKKysrIGIvaG9zdGFwZC9ob3N0YXBkLmNvbmYKQEAgLTUxLDkgKzUxLDYgQEAKIGxvZ2dlcl9zdGRvdXQ9LTEKIGxvZ2dlcl9zdGRvdXRfbGV2ZWw9MgogCi0jIER1bXAgZmlsZSBmb3Igc3RhdGUgaW5mb3JtYXRpb24gKG9uIFNJR1VTUjEpCi1kdW1wX2ZpbGU9L3RtcC9ob3N0YXBkLmR1bXAKLQogIyBJbnRlcmZhY2UgZm9yIHNlcGFyYXRlIGNvbnRyb2wgcHJvZ3JhbS4gSWYgdGhpcyBpcyBzcGVjaWZpZWQsIGhvc3RhcGQKICMgd2lsbCBjcmVhdGUgdGhpcyBkaXJlY3RvcnkgYW5kIGEgVU5JWCBkb21haW4gc29ja2V0IGZvciBsaXN0ZW5pbmcgdG8gcmVxdWVzdHMKICMgZnJvbSBleHRlcm5hbCBwcm9ncmFtcyAoQ0xJL0dVSSwgZXRjLikgZm9yIHN0YXR1cyBpbmZvcm1hdGlvbiBhbmQKQEAgLTExMSw2ICsxMDgsMjAgQEAKICMgKGRlZmF1bHQ6IDAgPSBkaXNhYmxlZCkKICNpZWVlODAyMTFoPTEKIAorIyBBZGQgUG93ZXIgQ29uc3RyYWludCBlbGVtZW50IHRvIEJlYWNvbiBhbmQgUHJvYmUgUmVzcG9uc2UgZnJhbWVzCisjIFRoaXMgY29uZmlnIG9wdGlvbiBhZGRzIFBvd2VyIENvbnN0cmFpbnQgZWxlbWVudCB3aGVuIGFwcGxpY2FibGUgYW5kIENvdW50cnkKKyMgZWxlbWVudCBpcyBhZGRlZC4gUG93ZXIgQ29uc3RyYWludCBlbGVtZW50IGlzIHJlcXVpcmVkIGJ5IFRyYW5zbWl0IFBvd2VyCisjIENvbnRyb2wuIFRoaXMgY2FuIGJlIHVzZWQgb25seSB3aXRoIGllZWU4MDIxMWQ9MS4KKyMgVmFsaWQgdmFsdWVzIGFyZSAwLi4yNTUuCisjbG9jYWxfcHdyX2NvbnN0cmFpbnQ9MworCisjIFNldCBTcGVjdHJ1bSBNYW5hZ2VtZW50IHN1YmZpZWxkIGluIHRoZSBDYXBhYmlsaXR5IEluZm9ybWF0aW9uIGZpZWxkLgorIyBUaGlzIGNvbmZpZyBvcHRpb24gZm9yY2VzIHRoZSBTcGVjdHJ1bSBNYW5hZ2VtZW50IGJpdCB0byBiZSBzZXQuIFdoZW4gdGhpcworIyBvcHRpb24gaXMgbm90IHNldCwgdGhlIHZhbHVlIG9mIHRoZSBTcGVjdHJ1bSBNYW5hZ2VtZW50IGJpdCBkZXBlbmRzIG9uIHdoZXRoZXIKKyMgREZTIG9yIFRQQyBpcyByZXF1aXJlZCBieSByZWd1bGF0b3J5IGF1dGhvcml0aWVzLiBUaGlzIGNhbiBiZSB1c2VkIG9ubHkgd2l0aAorIyBpZWVlODAyMTFkPTEgYW5kIGxvY2FsX3B3cl9jb25zdHJhaW50IGNvbmZpZ3VyZWQuCisjc3BlY3RydW1fbWdtdF9yZXF1aXJlZD0xCisKICMgT3BlcmF0aW9uIG1vZGUgKGEgPSBJRUVFIDgwMi4xMWEsIGIgPSBJRUVFIDgwMi4xMWIsIGcgPSBJRUVFIDgwMi4xMWcsCiAjIGFkID0gSUVFRSA4MDIuMTFhZCAoNjAgR0h6KTsgYS9nIG9wdGlvbnMgYXJlIHVzZWQgd2l0aCBJRUVFIDgwMi4xMW4sIHRvbywgdG8KICMgc3BlY2lmeSBiYW5kKQpAQCAtMTQzLDYgKzE1NCwxNCBAQAogIyBEZWZhdWx0czoKICNhY3NfbnVtX3NjYW5zPTUKIAorIyBDaGFubmVsIGxpc3QgcmVzdHJpY3Rpb24uIFRoaXMgb3B0aW9uIGFsbG93cyBob3N0YXBkIHRvIHNlbGVjdCBvbmUgb2YgdGhlCisjIHByb3ZpZGVkIGNoYW5uZWxzIHdoZW4gYSBjaGFubmVsIHNob3VsZCBiZSBhdXRvbWF0aWNhbGx5IHNlbGVjdGVkLiBUaGlzCisjIGlzIGN1cnJlbnRseSBvbmx5IHVzZWQgZm9yIERGUyB3aGVuIHRoZSBjdXJyZW50IGNoYW5uZWxzIGJlY29tZXMgdW5hdmFpbGFibGUKKyMgZHVlIHRvIHJhZGFyIGludGVyZmVyZW5jZSwgYW5kIGlzIGN1cnJlbnRseSBvbmx5IHVzZWZ1bCB3aGVuIGllZWU4MDIxMWg9MSBpcworIyBzZXQuCisjIERlZmF1bHQ6IG5vdCBzZXQgKGFsbG93IGFueSBlbmFibGVkIGNoYW5uZWwgdG8gYmUgc2VsZWN0ZWQpCisjY2hhbmxpc3Q9MTAwIDEwNCAxMDggMTEyIDExNgorCiAjIEJlYWNvbiBpbnRlcnZhbCBpbiBrdXMgKDEuMDI0IG1zKSAoZGVmYXVsdDogMTAwOyByYW5nZSAxNS4uNjU1MzUpCiBiZWFjb25faW50PTEwMAogCkBAIC00MTYsNiArNDM1LDEyIEBACiAjIGFzc29jaWF0ZWQgc3RhdGlvbnMgaW4gdGhlIEJTUy4gQnkgZGVmYXVsdCwgdGhpcyBicmlkZ2luZyBpcyBhbGxvd2VkLgogI2FwX2lzb2xhdGU9MQogCisjIEZpeGVkIEJTUyBMb2FkIHZhbHVlIGZvciB0ZXN0aW5nIHB1cnBvc2VzCisjIFRoaXMgZmllbGQgY2FuIGJlIHVzZWQgdG8gY29uZmlndXJlIGhvc3RhcGQgdG8gYWRkIGEgZml4ZWQgQlNTIExvYWQgZWxlbWVudAorIyBpbnRvIEJlYWNvbiBhbmQgUHJvYmUgUmVzcG9uc2UgZnJhbWVzIGZvciB0ZXN0aW5nIHB1cnBvc2VzLiBUaGUgZm9ybWF0IGlzCisjIDxzdGF0aW9uIGNvdW50Pjo8Y2hhbm5lbCB1dGlsaXphdGlvbj46PGF2YWlsYWJsZSBhZG1pc3Npb24gY2FwYWNpdHk+CisjYnNzX2xvYWRfdGVzdD0xMjo4MDoyMDAwMAorCiAjIyMjIyBJRUVFIDgwMi4xMW4gcmVsYXRlZCBjb25maWd1cmF0aW9uICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAKICMgaWVlZTgwMjExbjogV2hldGhlciBJRUVFIDgwMi4xMW4gKEhUKSBpcyBlbmFibGVkCkBAIC00MjgsNyArNDUzLDcgQEAKICMgTERQQyBjb2RpbmcgY2FwYWJpbGl0eTogW0xEUENdID0gc3VwcG9ydGVkCiAjIFN1cHBvcnRlZCBjaGFubmVsIHdpZHRoIHNldDogW0hUNDAtXSA9IGJvdGggMjAgTUh6IGFuZCA0MCBNSHogd2l0aCBzZWNvbmRhcnkKICMJY2hhbm5lbCBiZWxvdyB0aGUgcHJpbWFyeSBjaGFubmVsOyBbSFQ0MCtdID0gYm90aCAyMCBNSHogYW5kIDQwIE1IegotIwl3aXRoIHNlY29uZGFyeSBjaGFubmVsIGJlbG93IHRoZSBwcmltYXJ5IGNoYW5uZWwKKyMJd2l0aCBzZWNvbmRhcnkgY2hhbm5lbCBhYm92ZSB0aGUgcHJpbWFyeSBjaGFubmVsCiAjCSgyMCBNSHogb25seSBpZiBuZWl0aGVyIGlzIHNldCkKICMJTm90ZTogVGhlcmUgYXJlIGxpbWl0cyBvbiB3aGljaCBjaGFubmVscyBjYW4gYmUgdXNlZCB3aXRoIEhUNDAtIGFuZAogIwlIVDQwKy4gRm9sbG93aW5nIHRhYmxlIHNob3dzIHRoZSBjaGFubmVscyB0aGF0IG1heSBiZSBhdmFpbGFibGUgZm9yCkBAIC00NTUsMTMgKzQ4MCwyMCBAQAogIyBNYXhpbXVtIEEtTVNEVSBsZW5ndGg6IFtNQVgtQU1TRFUtNzkzNV0gZm9yIDc5MzUgb2N0ZXRzICgzODM5IG9jdGV0cyBpZiBub3QKICMJc2V0KQogIyBEU1NTL0NDSyBNb2RlIGluIDQwIE1IejogW0RTU1NfQ0NLLTQwXSA9IGFsbG93ZWQgKG5vdCBhbGxvd2VkIGlmIG5vdCBzZXQpCi0jIFBTTVAgc3VwcG9ydDogW1BTTVBdIChkaXNhYmxlZCBpZiBub3Qgc2V0KQorIyA0MCBNSHogaW50b2xlcmFudCBbNDAtSU5UT0xFUkFOVF0gKG5vdCBhZHZlcnRpc2VkIGlmIG5vdCBzZXQpCiAjIEwtU0lHIFRYT1AgcHJvdGVjdGlvbiBzdXBwb3J0OiBbTFNJRy1UWE9QLVBST1RdIChkaXNhYmxlZCBpZiBub3Qgc2V0KQogI2h0X2NhcGFiPVtIVDQwLV1bU0hPUlQtR0ktMjBdW1NIT1JULUdJLTQwXQogCiAjIFJlcXVpcmUgc3RhdGlvbnMgdG8gc3VwcG9ydCBIVCBQSFkgKHJlamVjdCBhc3NvY2lhdGlvbiBpZiB0aGV5IGRvIG5vdCkKICNyZXF1aXJlX2h0PTEKIAorIyBJZiBzZXQgbm9uLXplcm8sIHJlcXVpcmUgc3RhdGlvbnMgdG8gcGVyZm9ybSBzY2FucyBvZiBvdmVybGFwcGluZworIyBjaGFubmVscyB0byB0ZXN0IGZvciBzdGF0aW9ucyB3aGljaCB3b3VsZCBiZSBhZmZlY3RlZCBieSA0MCBNSHogdHJhZmZpYy4KKyMgVGhpcyBwYXJhbWV0ZXIgc2V0cyB0aGUgaW50ZXJ2YWwgaW4gc2Vjb25kcyBiZXR3ZWVuIHRoZXNlIHNjYW5zLiBUaGlzCisjIGlzIHVzZWZ1bCBvbmx5IGZvciB0ZXN0aW5nIHRoYXQgc3RhdGlvbnMgcHJvcGVybHkgc2V0IHRoZSBPQlNTIGludGVydmFsLAorIyBzaW5jZSB0aGUgb3RoZXIgcGFyYW1ldGVycyBpbiB0aGUgT0JTUyBzY2FuIHBhcmFtZXRlcnMgSUUgYXJlIHNldCB0byAwLgorI29ic3NfaW50ZXJ2YWw9MAorCiAjIyMjIyBJRUVFIDgwMi4xMWFjIHJlbGF0ZWQgY29uZmlndXJhdGlvbiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAKICMgaWVlZTgwMjExYWM6IFdoZXRoZXIgSUVFRSA4MDIuMTFhYyAoVkhUKSBpcyBlbmFibGVkCkBAIC05NjEsNiArOTkzLDExIEBACiAjIFRoZSBVRFAgcG9ydCBudW1iZXIgZm9yIHRoZSBSQURJVVMgYXV0aGVudGljYXRpb24gc2VydmVyCiAjcmFkaXVzX3NlcnZlcl9hdXRoX3BvcnQ9MTgxMgogCisjIFRoZSBVRFAgcG9ydCBudW1iZXIgZm9yIHRoZSBSQURJVVMgYWNjb3VudGluZyBzZXJ2ZXIKKyMgQ29tbWVudGluZyB0aGlzIG91dCBvciBzZXR0aW5nIHRoaXMgdG8gMCBjYW4gYmUgdXNlZCB0byBkaXNhYmxlIFJBRElVUworIyBhY2NvdW50aW5nIHdoaWxlIHN0aWxsIGVuYWJsaW5nIFJBRElVUyBhdXRoZW50aWNhdGlvbi4KKyNyYWRpdXNfc2VydmVyX2FjY3RfcG9ydD0xODEzCisKICMgVXNlIElQdjYgd2l0aCBSQURJVVMgc2VydmVyIChJUHY0IHdpbGwgYWxzbyBiZSBzdXBwb3J0ZWQgdXNpbmcgSVB2NiBBUEkpCiAjcmFkaXVzX3NlcnZlcl9pcHY2PTEKIApAQCAtMTA2Nyw2ICsxMTA0LDE3IEBACiAjIDIgPSByZXF1aXJlZAogI2llZWU4MDIxMXc9MAogCisjIEdyb3VwIG1hbmFnZW1lbnQgY2lwaGVyIHN1aXRlCisjIERlZmF1bHQ6IEFFUy0xMjgtQ01BQyAoQklQKQorIyBPdGhlciBvcHRpb25zIChkZXBlbmRpbmcgb24gZHJpdmVyIHN1cHBvcnQpOgorIyBCSVAtR01BQy0xMjgKKyMgQklQLUdNQUMtMjU2CisjIEJJUC1DTUFDLTI1NgorIyBOb3RlOiBBbGwgdGhlIHN0YXRpb25zIGNvbm5lY3RpbmcgdG8gdGhlIEJTUyB3aWxsIGFsc28gbmVlZCB0byBzdXBwb3J0IHRoZQorIyBzZWxlY3RlZCBjaXBoZXIuIFRoZSBkZWZhdWx0IEFFUy0xMjgtQ01BQyBpcyB0aGUgb25seSBvcHRpb24gdGhhdCBpcyBjb21tb25seQorIyBhdmFpbGFibGUgaW4gZGVwbG95ZWQgZGV2aWNlcy4KKyNncm91cF9tZ210X2NpcGhlcj1BRVMtMTI4LUNNQUMKKwogIyBBc3NvY2lhdGlvbiBTQSBRdWVyeSBtYXhpbXVtIHRpbWVvdXQgKGluIFRVID0gMS4wMjQgbXM7IGZvciBNRlApCiAjIChtYXhpbXVtIHRpbWUgdG8gd2FpdCBmb3IgYSBTQSBRdWVyeSByZXNwb25zZSkKICMgZG90MTFBc3NvY2lhdGlvblNBUXVlcnlNYXhpbXVtVGltZW91dCwgMS4uLjQyOTQ5NjcyOTUKQEAgLTE0NTcsNiArMTUwNSw5IEBACiAjIGluZm9ybWF0aW9uIHRvIGJlIGNvbXBsZXRlLgogI3ZlbnVlX25hbWU9ZW5nOkV4YW1wbGUgdmVudWUKICN2ZW51ZV9uYW1lPWZpbjpFc2ltZXJra2lwYWlra2EKKyMgQWx0ZXJuYXRpdmUgZm9ybWF0IGZvciBsYW5ndWFnZTp2YWx1ZSBzdHJpbmdzOgorIyAoZG91YmxlIHF1b3RlZCBzdHJpbmcsIHByaW50Zi1lc2NhcGVkIHN0cmluZykKKyN2ZW51ZV9uYW1lPVAiZW5nOkV4YW1wbGVcbnZlbnVlIgogCiAjIE5ldHdvcmsgQXV0aGVudGljYXRpb24gVHlwZQogIyBUaGlzIHBhcmFtZXRlciBpbmRpY2F0ZXMgd2hhdCB0eXBlIG9mIG5ldHdvcmsgYXV0aGVudGljYXRpb24gaXMgdXNlZCBpbiB0aGUKQEAgLTE1MDgsNiArMTU1OSw4IEBACiAjCSAgICBhY2NvcmRhbmNlIHdpdGggSUVURiBSRkMgNDI4MgogIyBOQUkgUmVhbG0ocyk6IFNlbWktY29sb24gZGVsaW1pdGVkIE5BSSBSZWFsbShzKQogIyBFQVAgTWV0aG9kOiA8RUFQIE1ldGhvZD5bOjxbQXV0aFBhcmFtMTpWYWwxXT5dWzxbQXV0aFBhcmFtMjpWYWwyXT5dWy4uLl0KKyMgRUFQIE1ldGhvZCB0eXBlcywgc2VlOgorIyBodHRwOi8vd3d3LmlhbmEub3JnL2Fzc2lnbm1lbnRzL2VhcC1udW1iZXJzL2VhcC1udW1iZXJzLnhodG1sI2VhcC1udW1iZXJzLTQKICMgQXV0aFBhcmFtIChUYWJsZSA4LTE4OCBpbiBJRUVFIFN0ZCA4MDIuMTEtMjAxMik6CiAjIElEIDIgPSBOb24tRUFQIElubmVyIEF1dGhlbnRpY2F0aW9uIFR5cGUKICMJMSA9IFBBUCwgMiA9IENIQVAsIDMgPSBNU0NIQVAsIDQgPSBNU0NIQVBWMgpAQCAtMTUyMSw2ICsxNTc0LDIzIEBACiAjIHVzZXJuYW1lL3Bhc3N3b3JkCiAjbmFpX3JlYWxtPTAsZXhhbXBsZS5vcmcsMTNbNTo2XSwyMVsyOjRdWzU6N10KIAorIyBRb1MgTWFwIFNldCBjb25maWd1cmF0aW9uCisjCisjIENvbW1hIGRlbGltaXRlZCBRb1MgTWFwIFNldCBpbiBkZWNpbWFsIHZhbHVlcworIyAoc2VlIElFRUUgU3RkIDgwMi4xMS0yMDEyLCA4LjQuMi45NykKKyMKKyMgZm9ybWF0OgorIyBbPERTQ1AgRXhjZXB0aW9uc1tEU0NQLFVQXT4sXTxVUCAwIHJhbmdlW2xvdyxoaWdoXT4sLi4uPFVQIDcgcmFuZ2VbbG93LGhpZ2hdPgorIworIyBUaGVyZSBjYW4gYmUgdXAgdG8gMjEgb3B0aW9uYWwgRFNDUCBFeGNlcHRpb25zIHdoaWNoIGFyZSBwYWlycyBvZiBEU0NQIFZhbHVlCisjICgwLi42MyBvciAyNTUpIGFuZCBVc2VyIFByaW9yaXR5ICgwLi43KS4gVGhpcyBpcyBmb2xsb3dlZCBieSBlaWdodCBEU0NQIFJhbmdlCisjIGRlc2NyaXB0aW9ucyB3aXRoIERTQ1AgTG93IFZhbHVlIGFuZCBEU0NQIEhpZ2ggVmFsdWUgcGFpcnMgKDAuLjYzIG9yIDI1NSkgZm9yCisjIGVhY2ggVVAgc3RhcnRpbmcgZnJvbSAwLiBJZiBib3RoIGxvdyBhbmQgaGlnaCB2YWx1ZSBhcmUgc2V0IHRvIDI1NSwgdGhlCisjIGNvcnJlc3BvbmRpbmcgVVAgaXMgbm90IHVzZWQuCisjCisjIGRlZmF1bHQ6IG5vdCBzZXQKKyNxb3NfbWFwX3NldD01MywyLDIyLDYsOCwxNSwwLDcsMjU1LDI1NSwxNiwzMSwzMiwzOSwyNTUsMjU1LDQwLDQ3LDI1NSwyNTUKKwogIyMjIyMgSG90c3BvdCAyLjAgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogCiAjIEVuYWJsZSBIb3RzcG90IDIuMCBzdXBwb3J0CkBAIC0xNTMzLDYgKzE2MDMsMjEgQEAKICMgZm9yZ2luZyBzdWNoIGZyYW1lcyB0byBvdGhlciBzdGF0aW9ucyBpbiB0aGUgQlNTLgogI2Rpc2FibGVfZGdhZj0xCiAKKyMgT1NVIFNlcnZlci1Pbmx5IEF1dGhlbnRpY2F0ZWQgTDIgRW5jcnlwdGlvbiBOZXR3b3JrCisjb3Nlbj0xCisKKyMgQU5RUCBEb21haW4gSUQgKDAuLjY1NTM1KQorIyBBbiBpZGVudGlmaWVyIGZvciBhIHNldCBvZiBBUHMgaW4gYW4gRVNTIHRoYXQgc2hhcmUgdGhlIHNhbWUgY29tbW9uIEFOUVAKKyMgaW5mb3JtYXRpb24uIDAgPSBTb21lIG9mIHRoZSBBTlFQIGluZm9ybWF0aW9uIGlzIHVuaXF1ZSB0byB0aGlzIEFQIChkZWZhdWx0KS4KKyNhbnFwX2RvbWFpbl9pZD0xMjM0CisKKyMgRGVhdXRoZW50aWNhdGlvbiByZXF1ZXN0IHRpbWVvdXQKKyMgSWYgdGhlIFJBRElVUyBzZXJ2ZXIgaW5kaWNhdGVzIHRoYXQgdGhlIHN0YXRpb24gaXMgbm90IGFsbG93ZWQgdG8gY29ubmVjdCB0bworIyB0aGUgQlNTL0VTUywgdGhlIEFQIGNhbiBhbGxvdyB0aGUgc3RhdGlvbiBzb21lIHRpbWUgdG8gZG93bmxvYWQgYQorIyBub3RpZmljYXRpb24gcGFnZSAoVVJMIGluY2x1ZGVkIGluIHRoZSBtZXNzYWdlKS4gVGhpcyBwYXJhbWV0ZXIgc2V0cyB0aGF0CisjIHRpbWVvdXQgaW4gc2Vjb25kcy4KKyNoczIwX2RlYXV0aF9yZXFfdGltZW91dD02MAorCiAjIE9wZXJhdG9yIEZyaWVuZGx5IE5hbWUKICMgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIHVzZWQgdG8gY29uZmlndXJlIG9uZSBvciBtb3JlIE9wZXJhdG9yIEZyaWVuZGx5IE5hbWUKICMgRHVwbGVzLiBFYWNoIGVudHJ5IGhhcyBhIHR3byBvciB0aHJlZSBjaGFyYWN0ZXIgbGFuZ3VhZ2UgY29kZSAoSVNPLTYzOSkKQEAgLTE1NzYsNiArMTY2MSwzMiBAQAogIyBjaGFubmVscyAzNi00OCk6CiAjaHMyMF9vcGVyYXRpbmdfY2xhc3M9NTE3MwogCisjIE9TVSBpY29ucworIyA8SWNvbiBXaWR0aD46PEljb24gSGVpZ2h0Pjo8TGFuZ3VhZ2UgY29kZT46PEljb24gVHlwZT46PE5hbWU+OjxmaWxlIHBhdGg+CisjaHMyMF9pY29uPTMyOjMyOmVuZzppbWFnZS9wbmc6aWNvbjMyOi90bXAvaWNvbjMyLnBuZworI2hzMjBfaWNvbj02NDo2NDplbmc6aW1hZ2UvcG5nOmljb242NDovdG1wL2ljb242NC5wbmcKKworIyBPU1UgU1NJRCAoc2VlIHNzaWQyIGZvciBmb3JtYXQgZGVzY3JpcHRpb24pCisjIFRoaXMgaXMgdGhlIFNTSUQgdXNlZCBmb3IgYWxsIE9TVSBjb25uZWN0aW9ucyB0byBhbGwgdGhlIGxpc3RlZCBPU1UgUHJvdmlkZXJzLgorI29zdV9zc2lkPSJleGFtcGxlIgorCisjIE9TVSBQcm92aWRlcnMKKyMgT25lIG9yIG1vcmUgc2V0cyBvZiBmb2xsb3dpbmcgcGFyYW1ldGVyLiBFYWNoIE9TVSBwcm92aWRlciBpcyBzdGFydGVkIGJ5IHRoZQorIyBtYW5kYXRvcnkgb3N1X3NlcnZlcl91cmkgaXRlbS4gVGhlIG90aGVyIHBhcmFtZXRlcnMgYWRkIGluZm9ybWF0aW9uIGZvciB0aGUKKyMgbGFzdCBhZGRlZCBPU1UgcHJvdmlkZXIuCisjCisjb3N1X3NlcnZlcl91cmk9aHR0cHM6Ly9leGFtcGxlLmNvbS9vc3UvCisjb3N1X2ZyaWVuZGx5X25hbWU9ZW5nOkV4YW1wbGUgb3BlcmF0b3IKKyNvc3VfZnJpZW5kbHlfbmFtZT1maW46RXNpbWVya2tpcGFsdmVsdW50YXJqb2FqYQorI29zdV9uYWk9YW5vbnltb3VzQGV4YW1wbGUuY29tCisjb3N1X21ldGhvZF9saXN0PTEgMAorI29zdV9pY29uPWljb24zMgorI29zdV9pY29uPWljb242NAorI29zdV9zZXJ2aWNlX2Rlc2M9ZW5nOkV4YW1wbGUgc2VydmljZXMKKyNvc3Vfc2VydmljZV9kZXNjPWZpbjpFc2ltZXJra2lwYWx2ZWx1amEKKyMKKyNvc3Vfc2VydmVyX3VyaT0uLi4KKwogIyMjIyMgVEVTVElORyBPUFRJT05TICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogIwogIyBUaGUgb3B0aW9ucyBpbiB0aGlzIHNlY3Rpb24gYXJlIG9ubHkgYXZhaWxhYmxlIHdoZW4gdGhlIGJ1aWxkIGNvbmZpZ3VyYXRpb24KQEAgLTE2MTksNiArMTczMCwxMSBAQAogIyAtIGlzIG5vdCB0aGUgc2FtZSBhcyB0aGUgTUFDIGFkZHJlc3Mgb2YgdGhlIHJhZGlvCiAjIC0gaXMgbm90IHRoZSBzYW1lIGFzIGFueSBvdGhlciBleHBsaWNpdGx5IHNwZWNpZmllZCBCU1NJRAogIworIyBOb3QgYWxsIGRyaXZlcnMgc3VwcG9ydCBtdWx0aXBsZSBCU1Nlcy4gVGhlIGV4YWN0IG1lY2hhbmlzbSBmb3IgZGV0ZXJtaW5pbmcKKyMgdGhlIGRyaXZlciBjYXBhYmlsaXRpZXMgaXMgZHJpdmVyIHNwZWNpZmljLiBXaXRoIHRoZSBjdXJyZW50IChpLmUuLCBhIHJlY2VudAorIyBrZXJuZWwpIGRyaXZlcnMgdXNpbmcgbmw4MDIxMSwgdGhpcyBpbmZvcm1hdGlvbiBjYW4gYmUgY2hlY2tlZCB3aXRoICJpdyBsaXN0IgorIyAoc2VhcmNoIGZvciAidmFsaWQgaW50ZXJmYWNlIGNvbWJpbmF0aW9ucyIpLgorIwogIyBQbGVhc2Ugbm90ZSB0aGF0IGhvc3RhcGQgdXNlcyBzb21lIG9mIHRoZSB2YWx1ZXMgY29uZmlndXJlZCBmb3IgdGhlIGZpcnN0IEJTUwogIyBhcyB0aGUgZGVmYXVsdHMgZm9yIHRoZSBmb2xsb3dpbmcgQlNTZXMuIEhvd2V2ZXIsIGl0IGlzIHJlY29tbWVuZGVkIHRoYXQgYWxsCiAjIEJTU2VzIGluY2x1ZGUgZXhwbGljaXQgY29uZmlndXJhdGlvbiBvZiBhbGwgcmVsZXZhbnQgY29uZmlndXJhdGlvbiBpdGVtcy4KZGlmZiAtLWdpdCBhL2hvc3RhcGQvaG9zdGFwZC5lYXBfdXNlciBiL2hvc3RhcGQvaG9zdGFwZC5lYXBfdXNlcgppbmRleCAxMmEyYzYxLi4wMGVkYzk1IDEwMDY0NAotLS0gYS9ob3N0YXBkL2hvc3RhcGQuZWFwX3VzZXIKKysrIGIvaG9zdGFwZC9ob3N0YXBkLmVhcF91c2VyCkBAIC00OCw2ICs0OCwxMiBAQAogIyBUVExTLUNIQVAsIFRUTFMtTVNDSEFQLCBUVExTLU1TQ0hBUFYyLiBUVExTLVBBUCBhbmQgVFRMUy1DSEFQIHJlcXVpcmUgYQogIyBwbGFpbnRleHQgcGFzc3dvcmQgd2hpbGUgVFRMUy1NU0NIQVAgYW5kIFRUTFMtTVNDSEFQVjIgY2FuIHVzZSBOVCBwYXNzd29yZAogIyBoYXNoLgorIworIyBBcmJpdHJhcnkgUkFESVVTIGF0dHJpYnV0ZXMgY2FuIGJlIGFkZGVkIGludG8gQWNjZXNzLUFjY2VwdCBwYWNrZXRzIHNpbWlsYXJseQorIyB0byB0aGUgd2F5IHJhZGl1c19hdXRoX3JlcV9hdHRyIGlzIHVzZWQgZm9yIEFjY2Vzcy1SZXF1ZXN0IHBhY2tldCBpbgorIyBob3N0YXBkLmNvbmYuIEZvciBFQVAgc2VydmVyLCB0aGlzIGlzIGNvbmZpZ3VyZWQgc2VwYXJhdGVseSBmb3IgZWFjaCB1c2VyCisjIGVudHJ5IHdpdGggcmFkaXVzX2FjY2VwdF9hdHRyPTx2YWx1ZT4gbGluZShzKSBmb2xsb3dpbmcgdGhlIG1haW4gdXNlciBlbnRyeQorIyBsaW5lLgogCiAjIFBoYXNlIDEgdXNlcnMKICJ1c2VyIgkJTUQ1CSJwYXNzd29yZCIKZGlmZiAtLWdpdCBhL2hvc3RhcGQvaG9zdGFwZC5lYXBfdXNlcl9zcWxpdGUgYi9ob3N0YXBkL2hvc3RhcGQuZWFwX3VzZXJfc3FsaXRlCmluZGV4IGY2ODgzMjcuLjgyNmRiMzQgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvaG9zdGFwZC5lYXBfdXNlcl9zcWxpdGUKKysrIGIvaG9zdGFwZC9ob3N0YXBkLmVhcF91c2VyX3NxbGl0ZQpAQCAtMiw2ICsyLDcgQEAKIAlpZGVudGl0eSBURVhUIFBSSU1BUlkgS0VZLAogCW1ldGhvZHMgVEVYVCwKIAlwYXNzd29yZCBURVhULAorCXJlbWVkaWF0aW9uIFRFWFQsCiAJcGhhc2UyIElOVEVHRVIKICk7CiAKQEAgLTE1LDMgKzE2LDExIEBACiAKIElOU0VSVCBJTlRPIHdpbGRjYXJkcyhpZGVudGl0eSxtZXRob2RzKSBWQUxVRVMgKCcnLCdUVExTLFRMUycpOwogSU5TRVJUIElOVE8gd2lsZGNhcmRzKGlkZW50aXR5LG1ldGhvZHMpIFZBTFVFUyAoJzAnLCdBS0EnKTsKKworQ1JFQVRFIFRBQkxFIGF1dGhsb2coCisJdGltZXN0YW1wIFRFWFQsCisJc2Vzc2lvbiBURVhULAorCW5hc19pcCBURVhULAorCXVzZXJuYW1lIFRFWFQsCisJbm90ZSBURVhUCispOwpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9ob3N0YXBkX2NsaS5jIGIvaG9zdGFwZC9ob3N0YXBkX2NsaS5jCmluZGV4IDcxODdhYmMuLjk1ZjI4ZDMgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvaG9zdGFwZF9jbGkuYworKysgYi9ob3N0YXBkL2hvc3RhcGRfY2xpLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAtIGNvbW1hbmQgbGluZSBpbnRlcmZhY2UgZm9yIGhvc3RhcGQgZGFlbW9uCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xOCw3ICsxOCw3IEBACiAKIHN0YXRpYyBjb25zdCBjaGFyICpob3N0YXBkX2NsaV92ZXJzaW9uID0KICJob3N0YXBkX2NsaSB2IiBWRVJTSU9OX1NUUiAiXG4iCi0iQ29weXJpZ2h0IChjKSAyMDA0LTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+IGFuZCBjb250cmlidXRvcnMiOworIkNvcHlyaWdodCAoYykgMjAwNC0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPiBhbmQgY29udHJpYnV0b3JzIjsKIAogCiBzdGF0aWMgY29uc3QgY2hhciAqaG9zdGFwZF9jbGlfbGljZW5zZSA9CkBAIC0yMTYsOCArMjE2LDIxIEBACiB9CiAKIAorc3RhdGljIGludCBob3N0YXBkX2NsaV9jbWRfc3RhdHVzKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwlpZiAoYXJnYyA+IDAgJiYgb3Nfc3RyY21wKGFyZ3ZbMF0sICJkcml2ZXIiKSA9PSAwKQorCQlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCAiU1RBVFVTLURSSVZFUiIpOworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsICJTVEFUVVMiKTsKK30KKworCiBzdGF0aWMgaW50IGhvc3RhcGRfY2xpX2NtZF9taWIoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQogeworCWlmIChhcmdjID4gMCkgeworCQljaGFyIGJ1ZlsxMDBdOworCQlvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiTUlCICVzIiwgYXJndlswXSk7CisJCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGJ1Zik7CisJfQogCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsICJNSUIiKTsKIH0KIApAQCAtMjI1LDI4ICsyMzgsMTkgQEAKIHN0YXRpYyBpbnQgaG9zdGFwZF9jbGlfZXhlYyhjb25zdCBjaGFyICpwcm9ncmFtLCBjb25zdCBjaGFyICphcmcxLAogCQkJICAgIGNvbnN0IGNoYXIgKmFyZzIpCiB7Ci0JY2hhciAqY21kOworCWNoYXIgKmFyZzsKIAlzaXplX3QgbGVuOwogCWludCByZXM7Ci0JaW50IHJldCA9IDA7CiAKLQlsZW4gPSBvc19zdHJsZW4ocHJvZ3JhbSkgKyBvc19zdHJsZW4oYXJnMSkgKyBvc19zdHJsZW4oYXJnMikgKyAzOwotCWNtZCA9IG9zX21hbGxvYyhsZW4pOwotCWlmIChjbWQgPT0gTlVMTCkKKwlsZW4gPSBvc19zdHJsZW4oYXJnMSkgKyBvc19zdHJsZW4oYXJnMikgKyAyOworCWFyZyA9IG9zX21hbGxvYyhsZW4pOworCWlmIChhcmcgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwotCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgbGVuLCAiJXMgJXMgJXMiLCBwcm9ncmFtLCBhcmcxLCBhcmcyKTsKLQlpZiAocmVzIDwgMCB8fCAoc2l6ZV90KSByZXMgPj0gbGVuKSB7Ci0JCW9zX2ZyZWUoY21kKTsKLQkJcmV0dXJuIC0xOwotCX0KLQljbWRbbGVuIC0gMV0gPSAnXDAnOwotI2lmbmRlZiBfV0lOMzJfV0NFCi0JaWYgKHN5c3RlbShjbWQpIDwgMCkKLQkJcmV0ID0gLTE7Ci0jZW5kaWYgLyogX1dJTjMyX1dDRSAqLwotCW9zX2ZyZWUoY21kKTsKKwlvc19zbnByaW50ZihhcmcsIGxlbiwgIiVzICVzIiwgYXJnMSwgYXJnMik7CisJcmVzID0gb3NfZXhlYyhwcm9ncmFtLCBhcmcsIDEpOworCW9zX2ZyZWUoYXJnKTsKIAotCXJldHVybiByZXQ7CisJcmV0dXJuIHJlczsKIH0KIAogCkBAIC0yNzAsMTIgKzI3NCwxNSBAQAogc3RhdGljIGludCBob3N0YXBkX2NsaV9jbWRfc3RhKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIHsKIAljaGFyIGJ1Zls2NF07Ci0JaWYgKGFyZ2MgIT0gMSkgewotCQlwcmludGYoIkludmFsaWQgJ3N0YScgY29tbWFuZCAtIGV4YWN0bHkgb25lIGFyZ3VtZW50LCBTVEEgIgorCWlmIChhcmdjIDwgMSkgeworCQlwcmludGYoIkludmFsaWQgJ3N0YScgY29tbWFuZCAtIGF0IGxlYXN0IG9uZSBhcmd1bWVudCwgU1RBICIKIAkJICAgICAgICJhZGRyZXNzLCBpcyByZXF1aXJlZC5cbiIpOwogCQlyZXR1cm4gLTE7CiAJfQotCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTVEEgJXMiLCBhcmd2WzBdKTsKKwlpZiAoYXJnYyA+IDEpCisJCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTVEEgJXMgJXMiLCBhcmd2WzBdLCBhcmd2WzFdKTsKKwllbHNlCisJCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTVEEgJXMiLCBhcmd2WzBdKTsKIAlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCBidWYpOwogfQogCkBAIC02ODgsNiArNjk1LDkwIEBACiB9CiAKIAorc3RhdGljIGludCBob3N0YXBkX2NsaV9jbWRfc2V0X3Fvc19tYXBfc2V0KHN0cnVjdCB3cGFfY3RybCAqY3RybCwKKwkJCQkJICAgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwljaGFyIGJ1ZlsyMDBdOworCWludCByZXM7CisKKwlpZiAoYXJnYyAhPSAxKSB7CisJCXByaW50ZigiSW52YWxpZCAnc2V0X3Fvc19tYXBfc2V0JyBjb21tYW5kIC0gIgorCQkgICAgICAgIm9uZSBhcmd1bWVudCAoY29tbWEgZGVsaW1pdGVkIFFvUyBtYXAgc2V0KSAiCisJCSAgICAgICAiaXMgbmVlZGVkXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJlcyA9IG9zX3NucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTRVRfUU9TX01BUF9TRVQgJXMiLCBhcmd2WzBdKTsKKwlpZiAocmVzIDwgMCB8fCByZXMgPj0gKGludCkgc2l6ZW9mKGJ1ZikpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCBidWYpOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jbGlfY21kX3NlbmRfcW9zX21hcF9jb25mKHN0cnVjdCB3cGFfY3RybCAqY3RybCwKKwkJCQkJICAgICBpbnQgYXJnYywgY2hhciAqYXJndltdKQoreworCWNoYXIgYnVmWzUwXTsKKwlpbnQgcmVzOworCisJaWYgKGFyZ2MgIT0gMSkgeworCQlwcmludGYoIkludmFsaWQgJ3NlbmRfcW9zX21hcF9jb25mJyBjb21tYW5kIC0gIgorCQkgICAgICAgIm9uZSBhcmd1bWVudCAoU1RBIGFkZHIpIGlzIG5lZWRlZFxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXMgPSBvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiU0VORF9RT1NfTUFQX0NPTkYgJXMiLCBhcmd2WzBdKTsKKwlpZiAocmVzIDwgMCB8fCByZXMgPj0gKGludCkgc2l6ZW9mKGJ1ZikpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCBidWYpOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jbGlfY21kX2hzMjBfd25tX25vdGlmKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJCSAgY2hhciAqYXJndltdKQoreworCWNoYXIgYnVmWzMwMF07CisJaW50IHJlczsKKworCWlmIChhcmdjIDwgMikgeworCQlwcmludGYoIkludmFsaWQgJ2hzMjBfd25tX25vdGlmJyBjb21tYW5kIC0gdHdvIGFyZ3VtZW50cyAoU1RBICIKKwkJICAgICAgICJhZGRyIGFuZCBVUkwpIGFyZSBuZWVkZWRcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIkhTMjBfV05NX05PVElGICVzICVzIiwKKwkJCSAgYXJndlswXSwgYXJndlsxXSk7CisJaWYgKHJlcyA8IDAgfHwgcmVzID49IChpbnQpIHNpemVvZihidWYpKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgYnVmKTsKK30KKworCitzdGF0aWMgaW50IGhvc3RhcGRfY2xpX2NtZF9oczIwX2RlYXV0aF9yZXEoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKKwkJCQkJICAgY2hhciAqYXJndltdKQoreworCWNoYXIgYnVmWzMwMF07CisJaW50IHJlczsKKworCWlmIChhcmdjIDwgMykgeworCQlwcmludGYoIkludmFsaWQgJ2hzMjBfZGVhdXRoX3JlcScgY29tbWFuZCAtIGF0IGxlYXN0IHRocmVlIGFyZ3VtZW50cyAoU1RBIGFkZHIsIENvZGUsIFJlLWF1dGggRGVsYXkpIGFyZSBuZWVkZWRcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGFyZ2MgPiAzKQorCQlyZXMgPSBvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLAorCQkJCSAgIkhTMjBfREVBVVRIX1JFUSAlcyAlcyAlcyAlcyIsCisJCQkJICBhcmd2WzBdLCBhcmd2WzFdLCBhcmd2WzJdLCBhcmd2WzNdKTsKKwllbHNlCisJCXJlcyA9IG9zX3NucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksCisJCQkJICAiSFMyMF9ERUFVVEhfUkVRICVzICVzICVzIiwKKwkJCQkgIGFyZ3ZbMF0sIGFyZ3ZbMV0sIGFyZ3ZbMl0pOworCWlmIChyZXMgPCAwIHx8IHJlcyA+PSAoaW50KSBzaXplb2YoYnVmKSkKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGJ1Zik7Cit9CisKKwogc3RhdGljIGludCBob3N0YXBkX2NsaV9jbWRfcXVpdChzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLCBjaGFyICphcmd2W10pCiB7CiAJaG9zdGFwZF9jbGlfcXVpdCA9IDE7CkBAIC03NDIsOCArODMzLDggQEAKIAl9CiAKIAlob3N0YXBkX2NsaV9jbG9zZV9jb25uZWN0aW9uKCk7Ci0JZnJlZShjdHJsX2lmbmFtZSk7Ci0JY3RybF9pZm5hbWUgPSBzdHJkdXAoYXJndlswXSk7CisJb3NfZnJlZShjdHJsX2lmbmFtZSk7CisJY3RybF9pZm5hbWUgPSBvc19zdHJkdXAoYXJndlswXSk7CiAKIAlpZiAoaG9zdGFwZF9jbGlfb3Blbl9jb25uZWN0aW9uKGN0cmxfaWZuYW1lKSkgewogCQlwcmludGYoIkNvbm5lY3RlZCB0byBpbnRlcmZhY2UgJyVzLlxuIiwgY3RybF9pZm5hbWUpOwpAQCAtODAxLDYgKzg5Miw2NiBAQAogfQogCiAKK3N0YXRpYyBpbnQgaG9zdGFwZF9jbGlfY21kX2NoYW5fc3dpdGNoKHN0cnVjdCB3cGFfY3RybCAqY3RybCwKKwkJCQkgICAgICAgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwljaGFyIGNtZFsyNTZdOworCWludCByZXM7CisJaW50IGk7CisJY2hhciAqdG1wOworCWludCB0b3RhbDsKKworCWlmIChhcmdjIDwgMikgeworCQlwcmludGYoIkludmFsaWQgY2hhbl9zd2l0Y2ggY29tbWFuZDogbmVlZHMgYXQgbGVhc3QgdHdvICIKKwkJICAgICAgICJhcmd1bWVudHMgKGNvdW50IGFuZCBmcmVxKVxuIgorCQkgICAgICAgInVzYWdlOiA8Y3NfY291bnQ+IDxmcmVxPiBbc2VjX2NoYW5uZWxfb2Zmc2V0PV0gIgorCQkgICAgICAgIltjZW50ZXJfZnJlcTE9XSBbY2VudGVyX2ZyZXEyPV0gW2JhbmR3aWR0aD1dICIKKwkJICAgICAgICJbYmxvY2t0eF0gW2h0fHZodF1cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIkNIQU5fU1dJVENIICVzICVzIiwKKwkJCSAgYXJndlswXSwgYXJndlsxXSk7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIENIQU5fU1dJVENIIGNvbW1hbmQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXRvdGFsID0gcmVzOworCWZvciAoaSA9IDI7IGkgPCBhcmdjOyBpKyspIHsKKwkJdG1wID0gY21kICsgdG90YWw7CisJCXJlcyA9IG9zX3NucHJpbnRmKHRtcCwgc2l6ZW9mKGNtZCkgLSB0b3RhbCwgIiAlcyIsIGFyZ3ZbaV0pOworCQlpZiAocmVzIDwgMCB8fCAoc2l6ZV90KSByZXMgPj0gc2l6ZW9mKGNtZCkgLSB0b3RhbCAtIDEpIHsKKwkJCXByaW50ZigiVG9vIGxvbmcgQ0hBTl9TV0lUQ0ggY29tbWFuZC5cbiIpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXRvdGFsICs9IHJlczsKKwl9CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgY21kKTsKK30KKworCitzdGF0aWMgaW50IGhvc3RhcGRfY2xpX2NtZF92ZW5kb3Ioc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQoreworCWNoYXIgY21kWzI1Nl07CisJaW50IHJlczsKKworCWlmIChhcmdjIDwgMiB8fCBhcmdjID4gMykgeworCQlwcmludGYoIkludmFsaWQgdmVuZG9yIGNvbW1hbmRcbiIKKwkJICAgICAgICJ1c2FnZTogPHZlbmRvciBpZD4gPGNvbW1hbmQgaWQ+IFs8aGV4IGZvcm1hdHRlZCBjb21tYW5kIGFyZ3VtZW50Pl1cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIlZFTkRPUiAlcyAlcyAlcyIsIGFyZ3ZbMF0sIGFyZ3ZbMV0sCisJCQkgIGFyZ2MgPT0gMyA/IGFyZ3ZbMl0gOiAiIik7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIFZFTkRPUiBjb21tYW5kLlxuIik7CisJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgY21kKTsKK30KKworCiBzdHJ1Y3QgaG9zdGFwZF9jbGlfY21kIHsKIAljb25zdCBjaGFyICpjbWQ7CiAJaW50ICgqaGFuZGxlcikoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKTsKQEAgLTgxMCw2ICs5NjEsNyBAQAogCXsgInBpbmciLCBob3N0YXBkX2NsaV9jbWRfcGluZyB9LAogCXsgIm1pYiIsIGhvc3RhcGRfY2xpX2NtZF9taWIgfSwKIAl7ICJyZWxvZyIsIGhvc3RhcGRfY2xpX2NtZF9yZWxvZyB9LAorCXsgInN0YXR1cyIsIGhvc3RhcGRfY2xpX2NtZF9zdGF0dXMgfSwKIAl7ICJzdGEiLCBob3N0YXBkX2NsaV9jbWRfc3RhIH0sCiAJeyAiYWxsX3N0YSIsIGhvc3RhcGRfY2xpX2NtZF9hbGxfc3RhIH0sCiAJeyAibmV3X3N0YSIsIGhvc3RhcGRfY2xpX2NtZF9uZXdfc3RhIH0sCkBAIC04NDMsNiArOTk1LDEyIEBACiAJeyAicXVpdCIsIGhvc3RhcGRfY2xpX2NtZF9xdWl0IH0sCiAJeyAic2V0IiwgaG9zdGFwZF9jbGlfY21kX3NldCB9LAogCXsgImdldCIsIGhvc3RhcGRfY2xpX2NtZF9nZXQgfSwKKwl7ICJzZXRfcW9zX21hcF9zZXQiLCBob3N0YXBkX2NsaV9jbWRfc2V0X3Fvc19tYXBfc2V0IH0sCisJeyAic2VuZF9xb3NfbWFwX2NvbmYiLCBob3N0YXBkX2NsaV9jbWRfc2VuZF9xb3NfbWFwX2NvbmYgfSwKKwl7ICJjaGFuX3N3aXRjaCIsIGhvc3RhcGRfY2xpX2NtZF9jaGFuX3N3aXRjaCB9LAorCXsgImhzMjBfd25tX25vdGlmIiwgaG9zdGFwZF9jbGlfY21kX2hzMjBfd25tX25vdGlmIH0sCisJeyAiaHMyMF9kZWF1dGhfcmVxIiwgaG9zdGFwZF9jbGlfY21kX2hzMjBfZGVhdXRoX3JlcSB9LAorCXsgInZlbmRvciIsIGhvc3RhcGRfY2xpX2NtZF92ZW5kb3IgfSwKIAl7IE5VTEwsIE5VTEwgfQogfTsKIApkaWZmIC0tZ2l0IGEvaG9zdGFwZC9tYWluLmMgYi9ob3N0YXBkL21haW4uYwppbmRleCA5MGU1OTY2Li5hZjRkODVkIDEwMDY0NAotLS0gYS9ob3N0YXBkL21haW4uYworKysgYi9ob3N0YXBkL21haW4uYwpAQCAtMTQsNiArMTQsNyBAQAogCiAjaW5jbHVkZSAidXRpbHMvY29tbW9uLmgiCiAjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKKyNpbmNsdWRlICJ1dGlscy91dWlkLmgiCiAjaW5jbHVkZSAiY3J5cHRvL3JhbmRvbS5oIgogI2luY2x1ZGUgImNyeXB0by90bHMuaCIKICNpbmNsdWRlICJjb21tb24vdmVyc2lvbi5oIgpAQCAtMjUsMTYgKzI2LDEwIEBACiAjaW5jbHVkZSAiYXAvYXBfZHJ2X29wcy5oIgogI2luY2x1ZGUgImNvbmZpZ19maWxlLmgiCiAjaW5jbHVkZSAiZWFwX3JlZ2lzdGVyLmgiCi0jaW5jbHVkZSAiZHVtcF9zdGF0ZS5oIgogI2luY2x1ZGUgImN0cmxfaWZhY2UuaCIKIAotCi1leHRlcm4gaW50IHdwYV9kZWJ1Z19sZXZlbDsKLWV4dGVybiBpbnQgd3BhX2RlYnVnX3Nob3dfa2V5czsKLWV4dGVybiBpbnQgd3BhX2RlYnVnX3RpbWVzdGFtcDsKLQotZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyAqd3BhX2RyaXZlcnNbXTsKLQorc3RydWN0IHdvd2xhbl90cmlnZ2VycyAqd3BhX2dldF93b3dsYW5fdHJpZ2dlcnMoY29uc3QgY2hhciAqd293bGFuX3RyaWdnZXJzLAorCQkJCQkJc3RydWN0IHdwYV9kcml2ZXJfY2FwYSAqY2FwYSk7CiAKIHN0cnVjdCBoYXBkX2dsb2JhbCB7CiAJdm9pZCAqKmRydl9wcml2OwpAQCAtOTksNyArOTQsOCBAQAogCWlmIChoYXBkICYmIGhhcGQtPmNvbmYgJiYgYWRkcikKIAkJb3Nfc25wcmludGYoZm9ybWF0LCBtYXhsZW4sICIlczogU1RBICIgTUFDU1RSICIlcyVzOiAlcyIsCiAJCQkgICAgaGFwZC0+Y29uZi0+aWZhY2UsIE1BQzJTVFIoYWRkciksCi0JCQkgICAgbW9kdWxlX3N0ciA/ICIgIiA6ICIiLCBtb2R1bGVfc3RyLCB0eHQpOworCQkJICAgIG1vZHVsZV9zdHIgPyAiICIgOiAiIiwgbW9kdWxlX3N0ciA/IG1vZHVsZV9zdHIgOiAiIiwKKwkJCSAgICB0eHQpOwogCWVsc2UgaWYgKGhhcGQgJiYgaGFwZC0+Y29uZikKIAkJb3Nfc25wcmludGYoZm9ybWF0LCBtYXhsZW4sICIlczolcyVzICVzIiwKIAkJCSAgICBoYXBkLT5jb25mLT5pZmFjZSwgbW9kdWxlX3N0ciA/ICIgIiA6ICIiLApAQCAtMTE0LDcgKzExMCw3IEBACiAKIAlpZiAoKGNvbmZfc3Rkb3V0ICYgbW9kdWxlKSAmJiBsZXZlbCA+PSBjb25mX3N0ZG91dF9sZXZlbCkgewogCQl3cGFfZGVidWdfcHJpbnRfdGltZXN0YW1wKCk7Ci0JCXByaW50ZigiJXNcbiIsIGZvcm1hdCk7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICIlcyIsIGZvcm1hdCk7CiAJfQogCiAjaWZuZGVmIENPTkZJR19OQVRJVkVfV0lORE9XUwpAQCAtMTQ4LDY1ICsxNDQsOCBAQAogCiAKIC8qKgotICogaG9zdGFwZF9pbml0IC0gQWxsb2NhdGUgYW5kIGluaXRpYWxpemUgcGVyLWludGVyZmFjZSBkYXRhCi0gKiBAY29uZmlnX2ZpbGU6IFBhdGggdG8gdGhlIGNvbmZpZ3VyYXRpb24gZmlsZQotICogUmV0dXJuczogUG9pbnRlciB0byB0aGUgYWxsb2NhdGVkIGludGVyZmFjZSBkYXRhIG9yICVOVUxMIG9uIGZhaWx1cmUKLSAqCi0gKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gYWxsb2NhdGUgbWFpbiBkYXRhIHN0cnVjdHVyZXMgZm9yIHBlci1pbnRlcmZhY2UKLSAqIGRhdGEuIFRoZSBhbGxvY2F0ZWQgZGF0YSBidWZmZXIgd2lsbCBiZSBmcmVlZCBieSBjYWxsaW5nCi0gKiBob3N0YXBkX2NsZWFudXBfaWZhY2UoKS4KKyAqIGhvc3RhcGRfZHJpdmVyX2luaXQgLSBQcmVwYXJhdGUgZHJpdmVyIGludGVyZmFjZQogICovCi1zdGF0aWMgc3RydWN0IGhvc3RhcGRfaWZhY2UgKiBob3N0YXBkX2luaXQoY29uc3QgY2hhciAqY29uZmlnX2ZpbGUpCi17Ci0Jc3RydWN0IGhvc3RhcGRfaWZhY2UgKmhhcGRfaWZhY2UgPSBOVUxMOwotCXN0cnVjdCBob3N0YXBkX2NvbmZpZyAqY29uZiA9IE5VTEw7Ci0Jc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZDsKLQlzaXplX3QgaTsKLQotCWhhcGRfaWZhY2UgPSBvc196YWxsb2Moc2l6ZW9mKCpoYXBkX2lmYWNlKSk7Ci0JaWYgKGhhcGRfaWZhY2UgPT0gTlVMTCkKLQkJZ290byBmYWlsOwotCi0JaGFwZF9pZmFjZS0+Y29uZmlnX2ZuYW1lID0gb3Nfc3RyZHVwKGNvbmZpZ19maWxlKTsKLQlpZiAoaGFwZF9pZmFjZS0+Y29uZmlnX2ZuYW1lID09IE5VTEwpCi0JCWdvdG8gZmFpbDsKLQotCWNvbmYgPSBob3N0YXBkX2NvbmZpZ19yZWFkKGhhcGRfaWZhY2UtPmNvbmZpZ19mbmFtZSk7Ci0JaWYgKGNvbmYgPT0gTlVMTCkKLQkJZ290byBmYWlsOwotCWhhcGRfaWZhY2UtPmNvbmYgPSBjb25mOwotCi0JaGFwZF9pZmFjZS0+bnVtX2JzcyA9IGNvbmYtPm51bV9ic3M7Ci0JaGFwZF9pZmFjZS0+YnNzID0gb3NfY2FsbG9jKGNvbmYtPm51bV9ic3MsCi0JCQkJICAgIHNpemVvZihzdHJ1Y3QgaG9zdGFwZF9kYXRhICopKTsKLQlpZiAoaGFwZF9pZmFjZS0+YnNzID09IE5VTEwpCi0JCWdvdG8gZmFpbDsKLQotCWZvciAoaSA9IDA7IGkgPCBjb25mLT5udW1fYnNzOyBpKyspIHsKLQkJaGFwZCA9IGhhcGRfaWZhY2UtPmJzc1tpXSA9Ci0JCQlob3N0YXBkX2FsbG9jX2Jzc19kYXRhKGhhcGRfaWZhY2UsIGNvbmYsCi0JCQkJCSAgICAgICAmY29uZi0+YnNzW2ldKTsKLQkJaWYgKGhhcGQgPT0gTlVMTCkKLQkJCWdvdG8gZmFpbDsKLQkJaGFwZC0+bXNnX2N0eCA9IGhhcGQ7Ci0JfQotCi0JcmV0dXJuIGhhcGRfaWZhY2U7Ci0KLWZhaWw6Ci0Jd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gc2V0IHVwIGludGVyZmFjZSB3aXRoICVzIiwKLQkJICAgY29uZmlnX2ZpbGUpOwotCWlmIChjb25mKQotCQlob3N0YXBkX2NvbmZpZ19mcmVlKGNvbmYpOwotCWlmIChoYXBkX2lmYWNlKSB7Ci0JCW9zX2ZyZWUoaGFwZF9pZmFjZS0+Y29uZmlnX2ZuYW1lKTsKLQkJb3NfZnJlZShoYXBkX2lmYWNlLT5ic3MpOwotCQlvc19mcmVlKGhhcGRfaWZhY2UpOwotCX0KLQlyZXR1cm4gTlVMTDsKLX0KLQotCiBzdGF0aWMgaW50IGhvc3RhcGRfZHJpdmVyX2luaXQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQogewogCXN0cnVjdCB3cGFfaW5pdF9wYXJhbXMgcGFyYW1zOwpAQCAtMjc0LDE4ICsyMTMsMzQgQEAKIAogCWlmIChoYXBkLT5kcml2ZXItPmdldF9jYXBhICYmCiAJICAgIGhhcGQtPmRyaXZlci0+Z2V0X2NhcGEoaGFwZC0+ZHJ2X3ByaXYsICZjYXBhKSA9PSAwKSB7CisJCXN0cnVjdCB3b3dsYW5fdHJpZ2dlcnMgKnRyaWdnczsKKwogCQlpZmFjZS0+ZHJ2X2ZsYWdzID0gY2FwYS5mbGFnczsKIAkJaWZhY2UtPnByb2JlX3Jlc3Bfb2ZmbG9hZHMgPSBjYXBhLnByb2JlX3Jlc3Bfb2ZmbG9hZHM7CiAJCWlmYWNlLT5leHRlbmRlZF9jYXBhID0gY2FwYS5leHRlbmRlZF9jYXBhOwogCQlpZmFjZS0+ZXh0ZW5kZWRfY2FwYV9tYXNrID0gY2FwYS5leHRlbmRlZF9jYXBhX21hc2s7CiAJCWlmYWNlLT5leHRlbmRlZF9jYXBhX2xlbiA9IGNhcGEuZXh0ZW5kZWRfY2FwYV9sZW47CiAJCWlmYWNlLT5kcnZfbWF4X2FjbF9tYWNfYWRkcnMgPSBjYXBhLm1heF9hY2xfbWFjX2FkZHJzOworCisJCXRyaWdncyA9IHdwYV9nZXRfd293bGFuX3RyaWdnZXJzKGNvbmYtPndvd2xhbl90cmlnZ2VycywgJmNhcGEpOworCQlpZiAodHJpZ2dzICYmIGhhcGQtPmRyaXZlci0+c2V0X3dvd2xhbikgeworCQkJaWYgKGhhcGQtPmRyaXZlci0+c2V0X3dvd2xhbihoYXBkLT5kcnZfcHJpdiwgdHJpZ2dzKSkKKwkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgInNldF93b3dsYW4gZmFpbGVkIik7CisJCX0KKwkJb3NfZnJlZSh0cmlnZ3MpOwogCX0KIAogCXJldHVybiAwOwogfQogCiAKKy8qKgorICogaG9zdGFwZF9pbnRlcmZhY2VfaW5pdCAtIFJlYWQgY29uZmlndXJhdGlvbiBmaWxlIGFuZCBpbml0IEJTUyBkYXRhCisgKgorICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIHBhcnNlIGNvbmZpZ3VyYXRpb24gZmlsZSBmb3IgYSBmdWxsIGludGVyZmFjZSAob25lCisgKiBvciBtb3JlIEJTU2VzIHNoYXJpbmcgdGhlIHNhbWUgcmFkaW8pIGFuZCBhbGxvY2F0ZSBtZW1vcnkgZm9yIHRoZSBCU1MKKyAqIGludGVyZmFjZXMuIE5vIGFjdGl1YWwgZHJpdmVyIG9wZXJhdGlvbnMgYXJlIHN0YXJ0ZWQuCisgKi8KIHN0YXRpYyBzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqCiBob3N0YXBkX2ludGVyZmFjZV9pbml0KHN0cnVjdCBoYXBkX2ludGVyZmFjZXMgKmludGVyZmFjZXMsCiAJCSAgICAgICBjb25zdCBjaGFyICpjb25maWdfZm5hbWUsIGludCBkZWJ1ZykKQEAgLTI5NCw3ICsyNDksNyBAQAogCWludCBrOwogCiAJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb25maWd1cmF0aW9uIGZpbGU6ICVzIiwgY29uZmlnX2ZuYW1lKTsKLQlpZmFjZSA9IGhvc3RhcGRfaW5pdChjb25maWdfZm5hbWUpOworCWlmYWNlID0gaG9zdGFwZF9pbml0KGludGVyZmFjZXMsIGNvbmZpZ19mbmFtZSk7CiAJaWYgKCFpZmFjZSkKIAkJcmV0dXJuIE5VTEw7CiAJaWZhY2UtPmludGVyZmFjZXMgPSBpbnRlcmZhY2VzOwpAQCAtMzA0LDcgKzI1OSw3IEBACiAJCQlpZmFjZS0+YnNzWzBdLT5jb25mLT5sb2dnZXJfc3Rkb3V0X2xldmVsLS07CiAJfQogCi0JaWYgKGlmYWNlLT5jb25mLT5ic3NbMF0uaWZhY2VbMF0gPT0gJ1wwJyAmJgorCWlmIChpZmFjZS0+Y29uZi0+YnNzWzBdLT5pZmFjZVswXSA9PSAnXDAnICYmCiAJICAgICFob3N0YXBkX2Rydl9ub25lKGlmYWNlLT5ic3NbMF0pKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSW50ZXJmYWNlIG5hbWUgbm90IHNwZWNpZmllZCBpbiAlcyIsCiAJCQkgICBjb25maWdfZm5hbWUpOwpAQCAtMzEyLDEyICsyNjcsNiBAQAogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlpZiAoaG9zdGFwZF9kcml2ZXJfaW5pdChpZmFjZSkgfHwKLQkgICAgaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2UoaWZhY2UpKSB7Ci0JCWhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdF9mcmVlKGlmYWNlKTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCiAJcmV0dXJuIGlmYWNlOwogfQogCkBAIC0zNTgsMTAgKzMwNyw3IEBACiAKIHN0YXRpYyB2b2lkIGhhbmRsZV9kdW1wX3N0YXRlKGludCBzaWcsIHZvaWQgKnNpZ25hbF9jdHgpCiB7Ci0jaWZkZWYgSE9TVEFQRF9EVU1QX1NUQVRFCi0Jc3RydWN0IGhhcGRfaW50ZXJmYWNlcyAqaW50ZXJmYWNlcyA9IHNpZ25hbF9jdHg7Ci0JaG9zdGFwZF9mb3JfZWFjaF9pbnRlcmZhY2UoaW50ZXJmYWNlcywgaGFuZGxlX2R1bXBfc3RhdGVfaWZhY2UsIE5VTEwpOwotI2VuZGlmIC8qIEhPU1RBUERfRFVNUF9TVEFURSAqLworCS8qIE5vdCB1c2VkIGFueW1vcmUgLSBpZ25vcmUgc2lnbmFsICovCiB9CiAjZW5kaWYgLyogQ09ORklHX05BVElWRV9XSU5ET1dTICovCiAKQEAgLTQ4MCw3ICs0MjYsNyBAQAogCQkiaG9zdGFwZCB2IiBWRVJTSU9OX1NUUiAiXG4iCiAJCSJVc2VyIHNwYWNlIGRhZW1vbiBmb3IgSUVFRSA4MDIuMTEgQVAgbWFuYWdlbWVudCxcbiIKIAkJIklFRUUgODAyLjFYL1dQQS9XUEEyL0VBUC9SQURJVVMgQXV0aGVudGljYXRvclxuIgotCQkiQ29weXJpZ2h0IChjKSAyMDAyLTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+ICIKKwkJIkNvcHlyaWdodCAoYykgMjAwMi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPiAiCiAJCSJhbmQgY29udHJpYnV0b3JzXG4iKTsKIH0KIApAQCAtNTA3LDYgKzQ1MywxMCBAQAogI2lmZGVmIENPTkZJR19ERUJVR19GSUxFCiAJCSIgICAtZiAgIGxvZyBvdXRwdXQgdG8gZGVidWcgZmlsZSBpbnN0ZWFkIG9mIHN0ZG91dFxuIgogI2VuZGlmIC8qIENPTkZJR19ERUJVR19GSUxFICovCisjaWZkZWYgQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcKKwkJIiAgIC1UID0gcmVjb3JkIHRvIExpbnV4IHRyYWNpbmcgaW4gYWRkaXRpb24gdG8gbG9nZ2luZ1xuIgorCQkiICAgICAgICAocmVjb3JkcyBhbGwgbWVzc2FnZXMgcmVnYXJkbGVzcyBvZiBkZWJ1ZyB2ZXJib3NpdHkpXG4iCisjZW5kaWYgLyogQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcgKi8KIAkJIiAgIC10ICAgaW5jbHVkZSB0aW1lc3RhbXBzIGluIHNvbWUgZGVidWcgbWVzc2FnZXNcbiIKIAkJIiAgIC12ICAgc2hvdyBob3N0YXBkIHZlcnNpb25cbiIpOwogCkBAIC01MTcsOCArNDY3LDkgQEAKIHN0YXRpYyBjb25zdCBjaGFyICogaG9zdGFwZF9tc2dfaWZuYW1lX2NiKHZvaWQgKmN0eCkKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkID0gY3R4OwotCWlmIChoYXBkICYmIGhhcGQtPmljb25mICYmIGhhcGQtPmljb25mLT5ic3MpCi0JCXJldHVybiBoYXBkLT5pY29uZi0+YnNzLT5pZmFjZTsKKwlpZiAoaGFwZCAmJiBoYXBkLT5pY29uZiAmJiBoYXBkLT5pY29uZi0+YnNzICYmCisJICAgIGhhcGQtPmljb25mLT5udW1fYnNzID4gMCAmJiBoYXBkLT5pY29uZi0+YnNzWzBdKQorCQlyZXR1cm4gaGFwZC0+aWNvbmYtPmJzc1swXS0+aWZhY2U7CiAJcmV0dXJuIE5VTEw7CiB9CiAKQEAgLTU2MywxNSArNTE0LDQxIEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19XUFMKK3N0YXRpYyBpbnQgZ2VuX3V1aWQoY29uc3QgY2hhciAqdHh0X2FkZHIpCit7CisJdTggYWRkcltFVEhfQUxFTl07CisJdTggdXVpZFtVVUlEX0xFTl07CisJY2hhciBidWZbMTAwXTsKKworCWlmIChod2FkZHJfYXRvbih0eHRfYWRkciwgYWRkcikgPCAwKQorCQlyZXR1cm4gLTE7CisKKwl1dWlkX2dlbl9tYWNfYWRkcihhZGRyLCB1dWlkKTsKKwlpZiAodXVpZF9iaW4yc3RyKHV1aWQsIGJ1Ziwgc2l6ZW9mKGJ1ZikpIDwgMCkKKwkJcmV0dXJuIC0xOworCisJcHJpbnRmKCIlc1xuIiwgYnVmKTsKKworCXJldHVybiAwOworfQorI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KKworCiBpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKQogewogCXN0cnVjdCBoYXBkX2ludGVyZmFjZXMgaW50ZXJmYWNlczsKIAlpbnQgcmV0ID0gMTsKLQlzaXplX3QgaTsKKwlzaXplX3QgaSwgajsKIAlpbnQgYywgZGVidWcgPSAwLCBkYWVtb25pemUgPSAwOwogCWNoYXIgKnBpZF9maWxlID0gTlVMTDsKIAljb25zdCBjaGFyICpsb2dfZmlsZSA9IE5VTEw7CiAJY29uc3QgY2hhciAqZW50cm9weV9maWxlID0gTlVMTDsKKwljaGFyICoqYnNzX2NvbmZpZyA9IE5VTEwsICoqdG1wX2JzczsKKwlzaXplX3QgbnVtX2Jzc19jb25maWdzID0gMDsKKyNpZmRlZiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworCWludCBlbmFibGVfdHJhY2VfZGJnID0gMDsKKyNlbmRpZiAvKiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORyAqLwogCiAJaWYgKG9zX3Byb2dyYW1faW5pdCgpKQogCQlyZXR1cm4gLTE7CkBAIC01ODgsNyArNTY1LDcgQEAKIAlpbnRlcmZhY2VzLmdsb2JhbF9jdHJsX3NvY2sgPSAtMTsKIAogCWZvciAoOzspIHsKLQkJYyA9IGdldG9wdChhcmdjLCBhcmd2LCAiQmRlOmY6aEtQOnR2ZzpHOiIpOworCQljID0gZ2V0b3B0KGFyZ2MsIGFyZ3YsICJiOkJkZTpmOmhLUDpUdHU6dmc6RzoiKTsKIAkJaWYgKGMgPCAwKQogCQkJYnJlYWs7CiAJCXN3aXRjaCAoYykgewpAQCAtNjE5LDYgKzU5NiwxMSBAQAogCQljYXNlICd0JzoKIAkJCXdwYV9kZWJ1Z190aW1lc3RhbXArKzsKIAkJCWJyZWFrOworI2lmZGVmIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HCisJCWNhc2UgJ1QnOgorCQkJZW5hYmxlX3RyYWNlX2RiZyA9IDE7CisJCQlicmVhazsKKyNlbmRpZiAvKiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORyAqLwogCQljYXNlICd2JzoKIAkJCXNob3dfdmVyc2lvbigpOwogCQkJZXhpdCgxKTsKQEAgLTYzMSwyMyArNjEzLDQ2IEBACiAJCQlpZiAoaG9zdGFwZF9nZXRfY3RybF9pZmFjZV9ncm91cCgmaW50ZXJmYWNlcywgb3B0YXJnKSkKIAkJCQlyZXR1cm4gLTE7CiAJCQlicmVhazsKKwkJY2FzZSAnYic6CisJCQl0bXBfYnNzID0gb3NfcmVhbGxvY19hcnJheShic3NfY29uZmlnLAorCQkJCQkJICAgbnVtX2Jzc19jb25maWdzICsgMSwKKwkJCQkJCSAgIHNpemVvZihjaGFyICopKTsKKwkJCWlmICh0bXBfYnNzID09IE5VTEwpCisJCQkJZ290byBvdXQ7CisJCQlic3NfY29uZmlnID0gdG1wX2JzczsKKwkJCWJzc19jb25maWdbbnVtX2Jzc19jb25maWdzKytdID0gb3B0YXJnOworCQkJYnJlYWs7CisjaWZkZWYgQ09ORklHX1dQUworCQljYXNlICd1JzoKKwkJCXJldHVybiBnZW5fdXVpZChvcHRhcmcpOworI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAkJZGVmYXVsdDoKIAkJCXVzYWdlKCk7CiAJCQlicmVhazsKIAkJfQogCX0KIAotCWlmIChvcHRpbmQgPT0gYXJnYyAmJiBpbnRlcmZhY2VzLmdsb2JhbF9pZmFjZV9wYXRoID09IE5VTEwpCisJaWYgKG9wdGluZCA9PSBhcmdjICYmIGludGVyZmFjZXMuZ2xvYmFsX2lmYWNlX3BhdGggPT0gTlVMTCAmJgorCSAgICBudW1fYnNzX2NvbmZpZ3MgPT0gMCkKIAkJdXNhZ2UoKTsKIAogCXdwYV9tc2dfcmVnaXN0ZXJfaWZuYW1lX2NiKGhvc3RhcGRfbXNnX2lmbmFtZV9jYik7CiAKIAlpZiAobG9nX2ZpbGUpCiAJCXdwYV9kZWJ1Z19vcGVuX2ZpbGUobG9nX2ZpbGUpOworI2lmZGVmIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HCisJaWYgKGVuYWJsZV90cmFjZV9kYmcpIHsKKwkJaW50IHRyZXQgPSB3cGFfZGVidWdfb3Blbl9saW51eF90cmFjaW5nKCk7CisJCWlmICh0cmV0KSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBlbmFibGUgdHJhY2UgbG9nZ2luZyIpOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorI2VuZGlmIC8qIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HICovCiAKIAlpbnRlcmZhY2VzLmNvdW50ID0gYXJnYyAtIG9wdGluZDsKLQlpZiAoaW50ZXJmYWNlcy5jb3VudCkgewotCQlpbnRlcmZhY2VzLmlmYWNlID0gb3NfY2FsbG9jKGludGVyZmFjZXMuY291bnQsCisJaWYgKGludGVyZmFjZXMuY291bnQgfHwgbnVtX2Jzc19jb25maWdzKSB7CisJCWludGVyZmFjZXMuaWZhY2UgPSBvc19jYWxsb2MoaW50ZXJmYWNlcy5jb3VudCArIG51bV9ic3NfY29uZmlncywKIAkJCQkJICAgICBzaXplb2Yoc3RydWN0IGhvc3RhcGRfaWZhY2UgKikpOwogCQlpZiAoaW50ZXJmYWNlcy5pZmFjZSA9PSBOVUxMKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIm1hbGxvYyBmYWlsZWQiKTsKQEAgLTY2MCw3ICs2NjUsNyBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JLyogSW5pdGlhbGl6ZSBpbnRlcmZhY2VzICovCisJLyogQWxsb2NhdGUgYW5kIHBhcnNlIGNvbmZpZ3VyYXRpb24gZm9yIGZ1bGwgaW50ZXJmYWNlIGZpbGVzICovCiAJZm9yIChpID0gMDsgaSA8IGludGVyZmFjZXMuY291bnQ7IGkrKykgewogCQlpbnRlcmZhY2VzLmlmYWNlW2ldID0gaG9zdGFwZF9pbnRlcmZhY2VfaW5pdCgmaW50ZXJmYWNlcywKIAkJCQkJCQkgICAgIGFyZ3Zbb3B0aW5kICsgaV0sCkBAIC02NzEsNiArNjc2LDU3IEBACiAJCX0KIAl9CiAKKwkvKiBBbGxvY2F0ZSBhbmQgcGFyc2UgY29uZmlndXJhdGlvbiBmb3IgcGVyLUJTUyBmaWxlcyAqLworCWZvciAoaSA9IDA7IGkgPCBudW1fYnNzX2NvbmZpZ3M7IGkrKykgeworCQlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2U7CisJCWNoYXIgKmZuYW1lOworCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJCU1MgY29uZmlnOiAlcyIsIGJzc19jb25maWdbaV0pOworCQlmbmFtZSA9IG9zX3N0cmNocihic3NfY29uZmlnW2ldLCAnOicpOworCQlpZiAoZm5hbWUgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkludmFsaWQgQlNTIGNvbmZpZyBpZGVudGlmaWVyICclcyciLAorCQkJCSAgIGJzc19jb25maWdbaV0pOworCQkJZ290byBvdXQ7CisJCX0KKwkJKmZuYW1lKysgPSAnXDAnOworCQlpZmFjZSA9IGhvc3RhcGRfaW50ZXJmYWNlX2luaXRfYnNzKCZpbnRlcmZhY2VzLCBic3NfY29uZmlnW2ldLAorCQkJCQkJICAgZm5hbWUsIGRlYnVnKTsKKwkJaWYgKGlmYWNlID09IE5VTEwpCisJCQlnb3RvIG91dDsKKwkJZm9yIChqID0gMDsgaiA8IGludGVyZmFjZXMuY291bnQ7IGorKykgeworCQkJaWYgKGludGVyZmFjZXMuaWZhY2Vbal0gPT0gaWZhY2UpCisJCQkJYnJlYWs7CisJCX0KKwkJaWYgKGogPT0gaW50ZXJmYWNlcy5jb3VudCkgeworCQkJc3RydWN0IGhvc3RhcGRfaWZhY2UgKip0bXA7CisJCQl0bXAgPSBvc19yZWFsbG9jX2FycmF5KGludGVyZmFjZXMuaWZhY2UsCisJCQkJCSAgICAgICBpbnRlcmZhY2VzLmNvdW50ICsgMSwKKwkJCQkJICAgICAgIHNpemVvZihzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqKSk7CisJCQlpZiAodG1wID09IE5VTEwpIHsKKwkJCQlob3N0YXBkX2ludGVyZmFjZV9kZWluaXRfZnJlZShpZmFjZSk7CisJCQkJZ290byBvdXQ7CisJCQl9CisJCQlpbnRlcmZhY2VzLmlmYWNlID0gdG1wOworCQkJaW50ZXJmYWNlcy5pZmFjZVtpbnRlcmZhY2VzLmNvdW50KytdID0gaWZhY2U7CisJCX0KKwl9CisKKwkvKgorCSAqIEVuYWJsZSBjb25maWd1cmVkIGludGVyZmFjZXMuIERlcGVuZGluZyBvbiBjaGFubmVsIGNvbmZpZ3VyYXRpb24sCisJICogdGhpcyBtYXkgY29tcGxldGUgZnVsbCBpbml0aWFsaXphdGlvbiBiZWZvcmUgcmV0dXJuaW5nIG9yIHVzZSBhCisJICogY2FsbGJhY2sgbWVjaGFuaXNtIHRvIGNvbXBsZXRlIHNldHVwIGluIGNhc2Ugb2Ygb3BlcmF0aW9ucyBsaWtlIEhUCisJICogY28tZXggc2NhbnMsIEFDUywgb3IgREZTIGFyZSBuZWVkZWQgdG8gZGV0ZXJtaW5lIGNoYW5uZWwgcGFyYW1ldGVycy4KKwkgKiBJbiBzdWNoIGNhc2UsIHRoZSBpbnRlcmZhY2Ugd2lsbCBiZSBlbmFibGVkIGZyb20gZWxvb3AgY29udGV4dCB3aXRoaW4KKwkgKiBob3N0YXBkX2dsb2JhbF9ydW4oKS4KKwkgKi8KKwlpbnRlcmZhY2VzLnRlcm1pbmF0ZV9vbl9lcnJvciA9IGludGVyZmFjZXMuY291bnQ7CisJZm9yIChpID0gMDsgaSA8IGludGVyZmFjZXMuY291bnQ7IGkrKykgeworCQlpZiAoaG9zdGFwZF9kcml2ZXJfaW5pdChpbnRlcmZhY2VzLmlmYWNlW2ldKSB8fAorCQkgICAgaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2UoaW50ZXJmYWNlcy5pZmFjZVtpXSkpCisJCQlnb3RvIG91dDsKKwl9CisKIAlob3N0YXBkX2dsb2JhbF9jdHJsX2lmYWNlX2luaXQoJmludGVyZmFjZXMpOwogCiAJaWYgKGhvc3RhcGRfZ2xvYmFsX3J1bigmaW50ZXJmYWNlcywgZGFlbW9uaXplLCBwaWRfZmlsZSkpIHsKQEAgLTY4Myw4ICs3MzksMTQgQEAKICBvdXQ6CiAJaG9zdGFwZF9nbG9iYWxfY3RybF9pZmFjZV9kZWluaXQoJmludGVyZmFjZXMpOwogCS8qIERlaW5pdGlhbGl6ZSBhbGwgaW50ZXJmYWNlcyAqLwotCWZvciAoaSA9IDA7IGkgPCBpbnRlcmZhY2VzLmNvdW50OyBpKyspCisJZm9yIChpID0gMDsgaSA8IGludGVyZmFjZXMuY291bnQ7IGkrKykgeworCQlpZiAoIWludGVyZmFjZXMuaWZhY2VbaV0pCisJCQljb250aW51ZTsKKwkJaW50ZXJmYWNlcy5pZmFjZVtpXS0+ZHJpdmVyX2FwX3RlYXJkb3duID0KKwkJCSEhKGludGVyZmFjZXMuaWZhY2VbaV0tPmRydl9mbGFncyAmCisJCQkgICBXUEFfRFJJVkVSX0ZMQUdTX0FQX1RFQVJET1dOX1NVUFBPUlQpOwogCQlob3N0YXBkX2ludGVyZmFjZV9kZWluaXRfZnJlZShpbnRlcmZhY2VzLmlmYWNlW2ldKTsKKwl9CiAJb3NfZnJlZShpbnRlcmZhY2VzLmlmYWNlKTsKIAogCWhvc3RhcGRfZ2xvYmFsX2RlaW5pdChwaWRfZmlsZSk7CkBAIC02OTIsNiArNzU0LDkgQEAKIAogCWlmIChsb2dfZmlsZSkKIAkJd3BhX2RlYnVnX2Nsb3NlX2ZpbGUoKTsKKwl3cGFfZGVidWdfY2xvc2VfbGludXhfdHJhY2luZygpOworCisJb3NfZnJlZShic3NfY29uZmlnKTsKIAogCW9zX3Byb2dyYW1fZGVpbml0KCk7CiAKZGlmZiAtLWdpdCBhL2hvc3RhcGQvd3BzLWFwLW5mYy5weSBiL2hvc3RhcGQvd3BzLWFwLW5mYy5weQppbmRleCA2MWI1NTE5Li4yZmMzMDEyIDEwMDc1NQotLS0gYS9ob3N0YXBkL3dwcy1hcC1uZmMucHkKKysrIGIvaG9zdGFwZC93cHMtYXAtbmZjLnB5CkBAIC05LDYgKzksNyBAQAogaW1wb3J0IG9zCiBpbXBvcnQgc3lzCiBpbXBvcnQgdGltZQoraW1wb3J0IGFyZ3BhcnNlCiAKIGltcG9ydCBuZmMKIGltcG9ydCBuZmMubmRlZgpAQCAtMTYsMTEgKzE3LDI1IEBACiBpbXBvcnQgbmZjLmhhbmRvdmVyCiAKIGltcG9ydCBsb2dnaW5nCi1sb2dnaW5nLmJhc2ljQ29uZmlnKCkKIAogaW1wb3J0IHdwYXNweQogCiB3cGFzX2N0cmwgPSAnL3Zhci9ydW4vaG9zdGFwZCcKK2NvbnRpbnVlX2xvb3AgPSBUcnVlCitzdW1tYXJ5X2ZpbGUgPSBOb25lCitzdWNjZXNzX2ZpbGUgPSBOb25lCisKK2RlZiBzdW1tYXJ5KHR4dCk6CisgICAgcHJpbnQgdHh0CisgICAgaWYgc3VtbWFyeV9maWxlOgorICAgICAgICB3aXRoIG9wZW4oc3VtbWFyeV9maWxlLCAnYScpIGFzIGY6CisgICAgICAgICAgICBmLndyaXRlKHR4dCArICJcbiIpCisKK2RlZiBzdWNjZXNzX3JlcG9ydCh0eHQpOgorICAgIHN1bW1hcnkodHh0KQorICAgIGlmIHN1Y2Nlc3NfZmlsZToKKyAgICAgICAgd2l0aCBvcGVuKHN1Y2Nlc3NfZmlsZSwgJ2EnKSBhcyBmOgorICAgICAgICAgICAgZi53cml0ZSh0eHQgKyAiXG4iKQogCiBkZWYgd3Bhc19jb25uZWN0KCk6CiAgICAgaWZhY2VzID0gW10KQEAgLTQ3LDI5ICs2Miw0MCBAQAogZGVmIHdwYXNfdGFnX3JlYWQobWVzc2FnZSk6CiAgICAgd3BhcyA9IHdwYXNfY29ubmVjdCgpCiAgICAgaWYgKHdwYXMgPT0gTm9uZSk6Ci0gICAgICAgIHJldHVybgotICAgIHByaW50IHdwYXMucmVxdWVzdCgiV1BTX05GQ19UQUdfUkVBRCAiICsgbWVzc2FnZS5lbmNvZGUoImhleCIpKQorICAgICAgICByZXR1cm4gRmFsc2UKKyAgICBpZiAiRkFJTCIgaW4gd3Bhcy5yZXF1ZXN0KCJXUFNfTkZDX1RBR19SRUFEICIgKyBzdHIobWVzc2FnZSkuZW5jb2RlKCJoZXgiKSk6CisgICAgICAgIHJldHVybiBGYWxzZQorICAgIHJldHVybiBUcnVlCiAKIAogZGVmIHdwYXNfZ2V0X2NvbmZpZ190b2tlbigpOgogICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQogICAgIGlmICh3cGFzID09IE5vbmUpOgogICAgICAgICByZXR1cm4gTm9uZQotICAgIHJldHVybiB3cGFzLnJlcXVlc3QoIldQU19ORkNfQ09ORklHX1RPS0VOIE5ERUYiKS5yc3RyaXAoKS5kZWNvZGUoImhleCIpCisgICAgcmV0ID0gd3Bhcy5yZXF1ZXN0KCJXUFNfTkZDX0NPTkZJR19UT0tFTiBOREVGIikKKyAgICBpZiAiRkFJTCIgaW4gcmV0OgorICAgICAgICByZXR1cm4gTm9uZQorICAgIHJldHVybiByZXQucnN0cmlwKCkuZGVjb2RlKCJoZXgiKQogCiAKIGRlZiB3cGFzX2dldF9wYXNzd29yZF90b2tlbigpOgogICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQogICAgIGlmICh3cGFzID09IE5vbmUpOgogICAgICAgICByZXR1cm4gTm9uZQotICAgIHJldHVybiB3cGFzLnJlcXVlc3QoIldQU19ORkNfVE9LRU4gTkRFRiIpLnJzdHJpcCgpLmRlY29kZSgiaGV4IikKKyAgICByZXQgPSB3cGFzLnJlcXVlc3QoIldQU19ORkNfVE9LRU4gTkRFRiIpCisgICAgaWYgIkZBSUwiIGluIHJldDoKKyAgICAgICAgcmV0dXJuIE5vbmUKKyAgICByZXR1cm4gcmV0LnJzdHJpcCgpLmRlY29kZSgiaGV4IikKIAogCiBkZWYgd3Bhc19nZXRfaGFuZG92ZXJfc2VsKCk6CiAgICAgd3BhcyA9IHdwYXNfY29ubmVjdCgpCiAgICAgaWYgKHdwYXMgPT0gTm9uZSk6CiAgICAgICAgIHJldHVybiBOb25lCi0gICAgcmV0dXJuIHdwYXMucmVxdWVzdCgiTkZDX0dFVF9IQU5ET1ZFUl9TRUwgTkRFRiBXUFMtQ1IiKS5yc3RyaXAoKS5kZWNvZGUoImhleCIpCisgICAgcmV0ID0gd3Bhcy5yZXF1ZXN0KCJORkNfR0VUX0hBTkRPVkVSX1NFTCBOREVGIFdQUy1DUiIpCisgICAgaWYgIkZBSUwiIGluIHJldDoKKyAgICAgICAgcmV0dXJuIE5vbmUKKyAgICByZXR1cm4gcmV0LnJzdHJpcCgpLmRlY29kZSgiaGV4IikKIAogCiBkZWYgd3Bhc19yZXBvcnRfaGFuZG92ZXIocmVxLCBzZWwpOgpAQCAtODIsMTg1ICsxMDgsMjI4IEBACiAKIAogY2xhc3MgSGFuZG92ZXJTZXJ2ZXIobmZjLmhhbmRvdmVyLkhhbmRvdmVyU2VydmVyKToKLSAgICBkZWYgX19pbml0X18oc2VsZik6Ci0gICAgICAgIHN1cGVyKEhhbmRvdmVyU2VydmVyLCBzZWxmKS5fX2luaXRfXygpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIGxsYyk6CisgICAgICAgIHN1cGVyKEhhbmRvdmVyU2VydmVyLCBzZWxmKS5fX2luaXRfXyhsbGMpCisgICAgICAgIHNlbGYuaG9fc2VydmVyX3Byb2Nlc3NpbmcgPSBGYWxzZQorICAgICAgICBzZWxmLnN1Y2Nlc3MgPSBGYWxzZQorCisgICAgIyBvdmVycmlkZSB0byBhdm9pZCBwYXJzZXIgZXJyb3IgaW4gcmVxdWVzdC9yZXNwb25zZS5wcmV0dHkoKSBpbiBuZmNweQorICAgICMgZHVlIHRvIG5ldyBXU0MgaGFuZG92ZXIgZm9ybWF0CisgICAgZGVmIF9wcm9jZXNzX3JlcXVlc3Qoc2VsZiwgcmVxdWVzdCk6CisgICAgICAgIHN1bW1hcnkoInJlY2VpdmVkIGhhbmRvdmVyIHJlcXVlc3Qge30iLmZvcm1hdChyZXF1ZXN0LnR5cGUpKQorICAgICAgICByZXNwb25zZSA9IG5mYy5uZGVmLk1lc3NhZ2UoIlx4ZDFceDAyXHgwMUhzXHgxMiIpCisgICAgICAgIGlmIG5vdCByZXF1ZXN0LnR5cGUgPT0gJ3VybjpuZmM6d2t0OkhyJzoKKyAgICAgICAgICAgIHN1bW1hcnkoIm5vdCBhIGhhbmRvdmVyIHJlcXVlc3QiKQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgdHJ5OgorICAgICAgICAgICAgICAgIHJlcXVlc3QgPSBuZmMubmRlZi5IYW5kb3ZlclJlcXVlc3RNZXNzYWdlKHJlcXVlc3QpCisgICAgICAgICAgICBleGNlcHQgbmZjLm5kZWYuRGVjb2RlRXJyb3IgYXMgZToKKyAgICAgICAgICAgICAgICBzdW1tYXJ5KCJlcnJvciBkZWNvZGluZyAnSHInIG1lc3NhZ2U6IHt9Ii5mb3JtYXQoZSkpCisgICAgICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAgIHJlc3BvbnNlID0gc2VsZi5wcm9jZXNzX3JlcXVlc3QocmVxdWVzdCkKKyAgICAgICAgc3VtbWFyeSgic2VuZCBoYW5kb3ZlciByZXNwb25zZSB7fSIuZm9ybWF0KHJlc3BvbnNlLnR5cGUpKQorICAgICAgICByZXR1cm4gcmVzcG9uc2UKIAogICAgIGRlZiBwcm9jZXNzX3JlcXVlc3Qoc2VsZiwgcmVxdWVzdCk6Ci0gICAgICAgIHByaW50ICJIYW5kb3ZlclNlcnZlciAtIHJlcXVlc3QgcmVjZWl2ZWQiCi0gICAgICAgIHByaW50ICJQYXJzZWQgaGFuZG92ZXIgcmVxdWVzdDogIiArIHJlcXVlc3QucHJldHR5KCkKKyAgICAgICAgc3VtbWFyeSgiSGFuZG92ZXJTZXJ2ZXIgLSByZXF1ZXN0IHJlY2VpdmVkIikKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgcHJpbnQgIlBhcnNlZCBoYW5kb3ZlciByZXF1ZXN0OiAiICsgcmVxdWVzdC5wcmV0dHkoKQorICAgICAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICAgICAgcHJpbnQgZQorICAgICAgICBwcmludCBzdHIocmVxdWVzdCkuZW5jb2RlKCJoZXgiKQogCiAgICAgICAgIHNlbCA9IG5mYy5uZGVmLkhhbmRvdmVyU2VsZWN0TWVzc2FnZSh2ZXJzaW9uPSIxLjIiKQogCiAgICAgICAgIGZvciBjYXJyaWVyIGluIHJlcXVlc3QuY2FycmllcnM6CiAgICAgICAgICAgICBwcmludCAiUmVtb3RlIGNhcnJpZXIgdHlwZTogIiArIGNhcnJpZXIudHlwZQogICAgICAgICAgICAgaWYgY2Fycmllci50eXBlID09ICJhcHBsaWNhdGlvbi92bmQud2ZhLndzYyI6Ci0gICAgICAgICAgICAgICAgcHJpbnQgIldQUyBjYXJyaWVyIHR5cGUgbWF0Y2ggLSBhZGQgV1BTIGNhcnJpZXIgcmVjb3JkIgotICAgICAgICAgICAgICAgIHNlbGYucmVjZWl2ZWRfY2FycmllciA9IGNhcnJpZXIucmVjb3JkCisgICAgICAgICAgICAgICAgc3VtbWFyeSgiV1BTIGNhcnJpZXIgdHlwZSBtYXRjaCAtIGFkZCBXUFMgY2FycmllciByZWNvcmQiKQogICAgICAgICAgICAgICAgIGRhdGEgPSB3cGFzX2dldF9oYW5kb3Zlcl9zZWwoKQogICAgICAgICAgICAgICAgIGlmIGRhdGEgaXMgTm9uZToKLSAgICAgICAgICAgICAgICAgICAgcHJpbnQgIkNvdWxkIG5vdCBnZXQgaGFuZG92ZXIgc2VsZWN0IGNhcnJpZXIgcmVjb3JkIGZyb20gaG9zdGFwZCIKKyAgICAgICAgICAgICAgICAgICAgc3VtbWFyeSgiQ291bGQgbm90IGdldCBoYW5kb3ZlciBzZWxlY3QgY2FycmllciByZWNvcmQgZnJvbSBob3N0YXBkIikKICAgICAgICAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgICAgICBwcmludCAiSGFuZG92ZXIgc2VsZWN0IGNhcnJpZXIgcmVjb3JkIGZyb20gaG9zdGFwZDoiCiAgICAgICAgICAgICAgICAgcHJpbnQgZGF0YS5lbmNvZGUoImhleCIpCi0gICAgICAgICAgICAgICAgc2VsZi5zZW50X2NhcnJpZXIgPSBkYXRhCisgICAgICAgICAgICAgICAgaWYgIk9LIiBpbiB3cGFzX3JlcG9ydF9oYW5kb3ZlcihjYXJyaWVyLnJlY29yZCwgZGF0YSk6CisgICAgICAgICAgICAgICAgICAgIHN1Y2Nlc3NfcmVwb3J0KCJIYW5kb3ZlciByZXBvcnRlZCBzdWNjZXNzZnVsbHkiKQorICAgICAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgICAgIHN1bW1hcnkoIkhhbmRvdmVyIHJlcG9ydCByZWplY3RlZCIpCiAKICAgICAgICAgICAgICAgICBtZXNzYWdlID0gbmZjLm5kZWYuTWVzc2FnZShkYXRhKTsKICAgICAgICAgICAgICAgICBzZWwuYWRkX2NhcnJpZXIobWVzc2FnZVswXSwgImFjdGl2ZSIsIG1lc3NhZ2VbMTpdKQogCiAgICAgICAgIHByaW50ICJIYW5kb3ZlciBzZWxlY3Q6IgotICAgICAgICBwcmludCBzZWwucHJldHR5KCkKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgcHJpbnQgc2VsLnByZXR0eSgpCisgICAgICAgIGV4Y2VwdCBFeGNlcHRpb24sIGU6CisgICAgICAgICAgICBwcmludCBlCiAgICAgICAgIHByaW50IHN0cihzZWwpLmVuY29kZSgiaGV4IikKIAotICAgICAgICBwcmludCAiU2VuZGluZyBoYW5kb3ZlciBzZWxlY3QiCisgICAgICAgIHN1bW1hcnkoIlNlbmRpbmcgaGFuZG92ZXIgc2VsZWN0IikKKyAgICAgICAgc2VsZi5zdWNjZXNzID0gVHJ1ZQogICAgICAgICByZXR1cm4gc2VsCiAKIAotZGVmIHdwc19oYW5kb3Zlcl9yZXNwKHBlZXIpOgotICAgIHByaW50ICJUcnlpbmcgdG8gaGFuZGxlIFdQUyBoYW5kb3ZlciIKLQotICAgIHNydiA9IEhhbmRvdmVyU2VydmVyKCkKLSAgICBzcnYuc2VudF9jYXJyaWVyID0gTm9uZQotCi0gICAgbmZjLmxsY3AuYWN0aXZhdGUocGVlcik7Ci0KLSAgICB0cnk6Ci0gICAgICAgIHByaW50ICJUcnlpbmcgaGFuZG92ZXIiOwotICAgICAgICBzcnYuc3RhcnQoKQotICAgICAgICBwcmludCAiV2FpdCBmb3IgZGlzY29ubmVjdCIKLSAgICAgICAgd2hpbGUgbmZjLmxsY3AuY29ubmVjdGVkKCk6Ci0gICAgICAgICAgICB0aW1lLnNsZWVwKDAuMSkKLSAgICAgICAgcHJpbnQgIkRpc2Nvbm5lY3RlZCBhZnRlciBoYW5kb3ZlciIKLSAgICBleGNlcHQgbmZjLmxsY3AuQ29ubmVjdFJlZnVzZWQ6Ci0gICAgICAgIHByaW50ICJIYW5kb3ZlciBjb25uZWN0aW9uIHJlZnVzZWQiCi0gICAgICAgIG5mYy5sbGNwLnNodXRkb3duKCkKLSAgICAgICAgcmV0dXJuCi0KLSAgICBpZiBzcnYuc2VudF9jYXJyaWVyOgotICAgICAgICB3cGFzX3JlcG9ydF9oYW5kb3ZlcihzcnYucmVjZWl2ZWRfY2Fycmllciwgc3J2LnNlbnRfY2FycmllcikKLQotICAgIHByaW50ICJSZW1vdmUgcGVlciIKLSAgICBuZmMubGxjcC5zaHV0ZG93bigpCi0gICAgcHJpbnQgIkRvbmUgd2l0aCBoYW5kb3ZlciIKLQotCiBkZWYgd3BzX3RhZ19yZWFkKHRhZyk6CisgICAgc3VjY2VzcyA9IEZhbHNlCiAgICAgaWYgbGVuKHRhZy5uZGVmLm1lc3NhZ2UpOgotICAgICAgICBtZXNzYWdlID0gbmZjLm5kZWYuTWVzc2FnZSh0YWcubmRlZi5tZXNzYWdlKQotICAgICAgICBwcmludCAibWVzc2FnZSB0eXBlICIgKyBtZXNzYWdlLnR5cGUKLQotICAgICAgICBmb3IgcmVjb3JkIGluIG1lc3NhZ2U6CisgICAgICAgIGZvciByZWNvcmQgaW4gdGFnLm5kZWYubWVzc2FnZToKICAgICAgICAgICAgIHByaW50ICJyZWNvcmQgdHlwZSAiICsgcmVjb3JkLnR5cGUKICAgICAgICAgICAgIGlmIHJlY29yZC50eXBlID09ICJhcHBsaWNhdGlvbi92bmQud2ZhLndzYyI6Ci0gICAgICAgICAgICAgICAgcHJpbnQgIldQUyB0YWcgLSBzZW5kIHRvIGhvc3RhcGQiCi0gICAgICAgICAgICAgICAgd3Bhc190YWdfcmVhZCh0YWcubmRlZi5tZXNzYWdlKQorICAgICAgICAgICAgICAgIHN1bW1hcnkoIldQUyB0YWcgLSBzZW5kIHRvIGhvc3RhcGQiKQorICAgICAgICAgICAgICAgIHN1Y2Nlc3MgPSB3cGFzX3RhZ19yZWFkKHRhZy5uZGVmLm1lc3NhZ2UpCiAgICAgICAgICAgICAgICAgYnJlYWsKICAgICBlbHNlOgotICAgICAgICBwcmludCAiRW1wdHkgdGFnIgorICAgICAgICBzdW1tYXJ5KCJFbXB0eSB0YWciKQogCi0gICAgcHJpbnQgIlJlbW92ZSB0YWciCi0gICAgd2hpbGUgdGFnLmlzX3ByZXNlbnQ6CisgICAgaWYgc3VjY2VzczoKKyAgICAgICAgc3VjY2Vzc19yZXBvcnQoIlRhZyByZWFkIHN1Y2NlZWRlZCIpCisKKyAgICByZXR1cm4gc3VjY2VzcworCisKK2RlZiByZHdyX2Nvbm5lY3RlZF93cml0ZSh0YWcpOgorICAgIHN1bW1hcnkoIlRhZyBmb3VuZCAtIHdyaXRpbmcgLSAiICsgc3RyKHRhZykpCisgICAgZ2xvYmFsIHdyaXRlX2RhdGEKKyAgICB0YWcubmRlZi5tZXNzYWdlID0gc3RyKHdyaXRlX2RhdGEpCisgICAgc3VjY2Vzc19yZXBvcnQoIlRhZyB3cml0ZSBzdWNjZWVkZWQiKQorICAgIHByaW50ICJEb25lIC0gcmVtb3ZlIHRhZyIKKyAgICBnbG9iYWwgb25seV9vbmUKKyAgICBpZiBvbmx5X29uZToKKyAgICAgICAgZ2xvYmFsIGNvbnRpbnVlX2xvb3AKKyAgICAgICAgY29udGludWVfbG9vcCA9IEZhbHNlCisgICAgZ2xvYmFsIHdyaXRlX3dhaXRfcmVtb3ZlCisgICAgd2hpbGUgd3JpdGVfd2FpdF9yZW1vdmUgYW5kIHRhZy5pc19wcmVzZW50OgogICAgICAgICB0aW1lLnNsZWVwKDAuMSkKIAotCi1kZWYgd3BzX3dyaXRlX2NvbmZpZ190YWcoY2xmKToKLSAgICBwcmludCAiV3JpdGUgV1BTIGNvbmZpZyB0b2tlbiIKLSAgICBkYXRhID0gd3Bhc19nZXRfY29uZmlnX3Rva2VuKCkKLSAgICBpZiAoZGF0YSA9PSBOb25lKToKLSAgICAgICAgcHJpbnQgIkNvdWxkIG5vdCBnZXQgV1BTIGNvbmZpZyB0b2tlbiBmcm9tIGhvc3RhcGQiCitkZWYgd3BzX3dyaXRlX2NvbmZpZ190YWcoY2xmLCB3YWl0X3JlbW92ZT1UcnVlKToKKyAgICBzdW1tYXJ5KCJXcml0ZSBXUFMgY29uZmlnIHRva2VuIikKKyAgICBnbG9iYWwgd3JpdGVfZGF0YSwgd3JpdGVfd2FpdF9yZW1vdmUKKyAgICB3cml0ZV93YWl0X3JlbW92ZSA9IHdhaXRfcmVtb3ZlCisgICAgd3JpdGVfZGF0YSA9IHdwYXNfZ2V0X2NvbmZpZ190b2tlbigpCisgICAgaWYgd3JpdGVfZGF0YSA9PSBOb25lOgorICAgICAgICBzdW1tYXJ5KCJDb3VsZCBub3QgZ2V0IFdQUyBjb25maWcgdG9rZW4gZnJvbSBob3N0YXBkIikKICAgICAgICAgcmV0dXJuCiAKICAgICBwcmludCAiVG91Y2ggYW4gTkZDIHRhZyIKLSAgICB3aGlsZSBUcnVlOgotICAgICAgICB0YWcgPSBjbGYucG9sbCgpCi0gICAgICAgIGlmIHRhZyA9PSBOb25lOgotICAgICAgICAgICAgdGltZS5zbGVlcCgwLjEpCi0gICAgICAgICAgICBjb250aW51ZQotICAgICAgICBicmVhawotCi0gICAgcHJpbnQgIlRhZyBmb3VuZCAtIHdyaXRpbmciCi0gICAgdGFnLm5kZWYubWVzc2FnZSA9IGRhdGEKLSAgICBwcmludCAiRG9uZSAtIHJlbW92ZSB0YWciCi0gICAgd2hpbGUgdGFnLmlzX3ByZXNlbnQ6Ci0gICAgICAgIHRpbWUuc2xlZXAoMC4xKQorICAgIGNsZi5jb25uZWN0KHJkd3I9eydvbi1jb25uZWN0JzogcmR3cl9jb25uZWN0ZWRfd3JpdGV9KQogCiAKLWRlZiB3cHNfd3JpdGVfcGFzc3dvcmRfdGFnKGNsZik6Ci0gICAgcHJpbnQgIldyaXRlIFdQUyBwYXNzd29yZCB0b2tlbiIKLSAgICBkYXRhID0gd3Bhc19nZXRfcGFzc3dvcmRfdG9rZW4oKQotICAgIGlmIChkYXRhID09IE5vbmUpOgotICAgICAgICBwcmludCAiQ291bGQgbm90IGdldCBXUFMgcGFzc3dvcmQgdG9rZW4gZnJvbSBob3N0YXBkIgorZGVmIHdwc193cml0ZV9wYXNzd29yZF90YWcoY2xmLCB3YWl0X3JlbW92ZT1UcnVlKToKKyAgICBzdW1tYXJ5KCJXcml0ZSBXUFMgcGFzc3dvcmQgdG9rZW4iKQorICAgIGdsb2JhbCB3cml0ZV9kYXRhLCB3cml0ZV93YWl0X3JlbW92ZQorICAgIHdyaXRlX3dhaXRfcmVtb3ZlID0gd2FpdF9yZW1vdmUKKyAgICB3cml0ZV9kYXRhID0gd3Bhc19nZXRfcGFzc3dvcmRfdG9rZW4oKQorICAgIGlmIHdyaXRlX2RhdGEgPT0gTm9uZToKKyAgICAgICAgc3VtbWFyeSgiQ291bGQgbm90IGdldCBXUFMgcGFzc3dvcmQgdG9rZW4gZnJvbSBob3N0YXBkIikKICAgICAgICAgcmV0dXJuCiAKICAgICBwcmludCAiVG91Y2ggYW4gTkZDIHRhZyIKLSAgICB3aGlsZSBUcnVlOgotICAgICAgICB0YWcgPSBjbGYucG9sbCgpCi0gICAgICAgIGlmIHRhZyA9PSBOb25lOgotICAgICAgICAgICAgdGltZS5zbGVlcCgwLjEpCi0gICAgICAgICAgICBjb250aW51ZQotICAgICAgICBicmVhawotCi0gICAgcHJpbnQgIlRhZyBmb3VuZCAtIHdyaXRpbmciCi0gICAgdGFnLm5kZWYubWVzc2FnZSA9IGRhdGEKLSAgICBwcmludCAiRG9uZSAtIHJlbW92ZSB0YWciCi0gICAgd2hpbGUgdGFnLmlzX3ByZXNlbnQ6Ci0gICAgICAgIHRpbWUuc2xlZXAoMC4xKQorICAgIGNsZi5jb25uZWN0KHJkd3I9eydvbi1jb25uZWN0JzogcmR3cl9jb25uZWN0ZWRfd3JpdGV9KQogCiAKLWRlZiBmaW5kX3BlZXIoY2xmKToKLSAgICB3aGlsZSBUcnVlOgotICAgICAgICBpZiBuZmMubGxjcC5jb25uZWN0ZWQoKToKLSAgICAgICAgICAgIHByaW50ICJMTENQIGNvbm5lY3RlZCIKLSAgICAgICAgZ2VuZXJhbF9ieXRlcyA9IG5mYy5sbGNwLnN0YXJ0dXAoe30pCi0gICAgICAgIHBlZXIgPSBjbGYubGlzdGVuKG9yZChvcy51cmFuZG9tKDEpKSArIDI1MCwgZ2VuZXJhbF9ieXRlcykKLSAgICAgICAgaWYgaXNpbnN0YW5jZShwZWVyLCBuZmMuREVQKToKLSAgICAgICAgICAgIHByaW50ICJsaXN0ZW4gLT4gREVQIjsKLSAgICAgICAgICAgIGlmIHBlZXIuZ2VuZXJhbF9ieXRlcy5zdGFydHN3aXRoKCJGZm0iKToKLSAgICAgICAgICAgICAgICBwcmludCAiRm91bmQgREVQIgotICAgICAgICAgICAgICAgIHJldHVybiBwZWVyCi0gICAgICAgICAgICBwcmludCAibWlzbWF0Y2ggaW4gZ2VuZXJhbF9ieXRlcyIKLSAgICAgICAgICAgIHByaW50IHBlZXIuZ2VuZXJhbF9ieXRlcworZGVmIHJkd3JfY29ubmVjdGVkKHRhZyk6CisgICAgZ2xvYmFsIG9ubHlfb25lLCBub193YWl0CisgICAgc3VtbWFyeSgiVGFnIGNvbm5lY3RlZDogIiArIHN0cih0YWcpKQogCi0gICAgICAgIHBlZXIgPSBjbGYucG9sbChnZW5lcmFsX2J5dGVzKQotICAgICAgICBpZiBpc2luc3RhbmNlKHBlZXIsIG5mYy5ERVApOgotICAgICAgICAgICAgcHJpbnQgInBvbGwgLT4gREVQIjsKLSAgICAgICAgICAgIGlmIHBlZXIuZ2VuZXJhbF9ieXRlcy5zdGFydHN3aXRoKCJGZm0iKToKLSAgICAgICAgICAgICAgICBwcmludCAiRm91bmQgREVQIgotICAgICAgICAgICAgICAgIHJldHVybiBwZWVyCi0gICAgICAgICAgICBwcmludCAibWlzbWF0Y2ggaW4gZ2VuZXJhbF9ieXRlcyIKLSAgICAgICAgICAgIHByaW50IHBlZXIuZ2VuZXJhbF9ieXRlcworICAgIGlmIHRhZy5uZGVmOgorICAgICAgICBwcmludCAiTkRFRiB0YWc6ICIgKyB0YWcudHlwZQorICAgICAgICB0cnk6CisgICAgICAgICAgICBwcmludCB0YWcubmRlZi5tZXNzYWdlLnByZXR0eSgpCisgICAgICAgIGV4Y2VwdCBFeGNlcHRpb24sIGU6CisgICAgICAgICAgICBwcmludCBlCisgICAgICAgIHN1Y2Nlc3MgPSB3cHNfdGFnX3JlYWQodGFnKQorICAgICAgICBpZiBvbmx5X29uZSBhbmQgc3VjY2VzczoKKyAgICAgICAgICAgIGdsb2JhbCBjb250aW51ZV9sb29wCisgICAgICAgICAgICBjb250aW51ZV9sb29wID0gRmFsc2UKKyAgICBlbHNlOgorICAgICAgICBzdW1tYXJ5KCJOb3QgYW4gTkRFRiB0YWcgLSByZW1vdmUgdGFnIikKKyAgICAgICAgcmV0dXJuIFRydWUKIAotICAgICAgICBpZiBwZWVyOgotICAgICAgICAgICAgcHJpbnQgIkZvdW5kIHRhZyIKLSAgICAgICAgICAgIHJldHVybiBwZWVyCisgICAgcmV0dXJuIG5vdCBub193YWl0CisKKworZGVmIGxsY3Bfc3RhcnR1cChjbGYsIGxsYyk6CisgICAgcHJpbnQgIlN0YXJ0IExMQ1Agc2VydmVyIgorICAgIGdsb2JhbCBzcnYKKyAgICBzcnYgPSBIYW5kb3ZlclNlcnZlcihsbGMpCisgICAgcmV0dXJuIGxsYworCitkZWYgbGxjcF9jb25uZWN0ZWQobGxjKToKKyAgICBwcmludCAiUDJQIExMQ1AgY29ubmVjdGVkIgorICAgIGdsb2JhbCB3YWl0X2Nvbm5lY3Rpb24KKyAgICB3YWl0X2Nvbm5lY3Rpb24gPSBGYWxzZQorICAgIGdsb2JhbCBzcnYKKyAgICBzcnYuc3RhcnQoKQorICAgIHJldHVybiBUcnVlCiAKIAogZGVmIG1haW4oKToKICAgICBjbGYgPSBuZmMuQ29udGFjdGxlc3NGcm9udGVuZCgpCiAKKyAgICBwYXJzZXIgPSBhcmdwYXJzZS5Bcmd1bWVudFBhcnNlcihkZXNjcmlwdGlvbj0nbmZjcHkgdG8gaG9zdGFwZCBpbnRlZ3JhdGlvbiBmb3IgV1BTIE5GQyBvcGVyYXRpb25zJykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctZCcsIGNvbnN0PWxvZ2dpbmcuREVCVUcsIGRlZmF1bHQ9bG9nZ2luZy5JTkZPLAorICAgICAgICAgICAgICAgICAgICAgICAgYWN0aW9uPSdzdG9yZV9jb25zdCcsIGRlc3Q9J2xvZ2xldmVsJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3ZlcmJvc2UgZGVidWcgb3V0cHV0JykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctcScsIGNvbnN0PWxvZ2dpbmcuV0FSTklORywgYWN0aW9uPSdzdG9yZV9jb25zdCcsCisgICAgICAgICAgICAgICAgICAgICAgICBkZXN0PSdsb2dsZXZlbCcsIGhlbHA9J2JlIHF1aWV0JykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLW9ubHktb25lJywgJy0xJywgYWN0aW9uPSdzdG9yZV90cnVlJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3J1biBvbmx5IG9uZSBvcGVyYXRpb24gYW5kIGV4aXQnKQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tbm8td2FpdCcsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdkbyBub3Qgd2FpdCBmb3IgdGFnIHRvIGJlIHJlbW92ZWQgYmVmb3JlIGV4aXRpbmcnKQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tc3VtbWFyeScsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdzdW1tYXJ5IGZpbGUgZm9yIHdyaXRpbmcgc3RhdHVzIHVwZGF0ZXMnKQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tc3VjY2VzcycsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdzdWNjZXNzIGZpbGUgZm9yIHdyaXRpbmcgc3VjY2VzcyB1cGRhdGUnKQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJ2NvbW1hbmQnLCBjaG9pY2VzPVsnd3JpdGUtY29uZmlnJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ3dyaXRlLXBhc3N3b3JkJ10sCisgICAgICAgICAgICAgICAgICAgICAgICBuYXJncz0nPycpCisgICAgYXJncyA9IHBhcnNlci5wYXJzZV9hcmdzKCkKKworICAgIGdsb2JhbCBvbmx5X29uZQorICAgIG9ubHlfb25lID0gYXJncy5vbmx5X29uZQorCisgICAgZ2xvYmFsIG5vX3dhaXQKKyAgICBub193YWl0ID0gYXJncy5ub193YWl0CisKKyAgICBpZiBhcmdzLnN1bW1hcnk6CisgICAgICAgIGdsb2JhbCBzdW1tYXJ5X2ZpbGUKKyAgICAgICAgc3VtbWFyeV9maWxlID0gYXJncy5zdW1tYXJ5CisKKyAgICBpZiBhcmdzLnN1Y2Nlc3M6CisgICAgICAgIGdsb2JhbCBzdWNjZXNzX2ZpbGUKKyAgICAgICAgc3VjY2Vzc19maWxlID0gYXJncy5zdWNjZXNzCisKKyAgICBsb2dnaW5nLmJhc2ljQ29uZmlnKGxldmVsPWFyZ3MubG9nbGV2ZWwpCisKICAgICB0cnk6Ci0gICAgICAgIGlmIGxlbihzeXMuYXJndikgPiAxIGFuZCBzeXMuYXJndlsxXSA9PSAid3JpdGUtY29uZmlnIjoKLSAgICAgICAgICAgIHdwc193cml0ZV9jb25maWdfdGFnKGNsZikKKyAgICAgICAgaWYgbm90IGNsZi5vcGVuKCJ1c2IiKToKKyAgICAgICAgICAgIHByaW50ICJDb3VsZCBub3Qgb3BlbiBjb25uZWN0aW9uIHdpdGggYW4gTkZDIGRldmljZSIKICAgICAgICAgICAgIHJhaXNlIFN5c3RlbUV4aXQKIAotICAgICAgICBpZiBsZW4oc3lzLmFyZ3YpID4gMSBhbmQgc3lzLmFyZ3ZbMV0gPT0gIndyaXRlLXBhc3N3b3JkIjoKLSAgICAgICAgICAgIHdwc193cml0ZV9wYXNzd29yZF90YWcoY2xmKQorICAgICAgICBpZiBhcmdzLmNvbW1hbmQgPT0gIndyaXRlLWNvbmZpZyI6CisgICAgICAgICAgICB3cHNfd3JpdGVfY29uZmlnX3RhZyhjbGYsIHdhaXRfcmVtb3ZlPW5vdCBhcmdzLm5vX3dhaXQpCiAgICAgICAgICAgICByYWlzZSBTeXN0ZW1FeGl0CiAKLSAgICAgICAgd2hpbGUgVHJ1ZToKKyAgICAgICAgaWYgYXJncy5jb21tYW5kID09ICJ3cml0ZS1wYXNzd29yZCI6CisgICAgICAgICAgICB3cHNfd3JpdGVfcGFzc3dvcmRfdGFnKGNsZiwgd2FpdF9yZW1vdmU9bm90IGFyZ3Mubm9fd2FpdCkKKyAgICAgICAgICAgIHJhaXNlIFN5c3RlbUV4aXQKKworICAgICAgICBnbG9iYWwgY29udGludWVfbG9vcAorICAgICAgICB3aGlsZSBjb250aW51ZV9sb29wOgogICAgICAgICAgICAgcHJpbnQgIldhaXRpbmcgZm9yIGEgdGFnIG9yIHBlZXIgdG8gYmUgdG91Y2hlZCIKKyAgICAgICAgICAgIHdhaXRfY29ubmVjdGlvbiA9IFRydWUKKyAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICBpZiBub3QgY2xmLmNvbm5lY3QocmR3cj17J29uLWNvbm5lY3QnOiByZHdyX2Nvbm5lY3RlZH0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxsY3A9eydvbi1zdGFydHVwJzogbGxjcF9zdGFydHVwLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnb24tY29ubmVjdCc6IGxsY3BfY29ubmVjdGVkfSk6CisgICAgICAgICAgICAgICAgICAgIGJyZWFrCisgICAgICAgICAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICAgICAgICAgIHByaW50ICJjbGYuY29ubmVjdCBmYWlsZWQiCiAKLSAgICAgICAgICAgIHRhZyA9IGZpbmRfcGVlcihjbGYpCi0gICAgICAgICAgICBpZiBpc2luc3RhbmNlKHRhZywgbmZjLkRFUCk6Ci0gICAgICAgICAgICAgICAgd3BzX2hhbmRvdmVyX3Jlc3AodGFnKQotICAgICAgICAgICAgICAgIGNvbnRpbnVlCi0KLSAgICAgICAgICAgIGlmIHRhZy5uZGVmOgotICAgICAgICAgICAgICAgIHdwc190YWdfcmVhZCh0YWcpCi0gICAgICAgICAgICAgICAgY29udGludWUKLQotICAgICAgICAgICAgcHJpbnQgIk5vdCBhbiBOREVGIHRhZyAtIHJlbW92ZSB0YWciCi0gICAgICAgICAgICB3aGlsZSB0YWcuaXNfcHJlc2VudDoKLSAgICAgICAgICAgICAgICB0aW1lLnNsZWVwKDAuMSkKKyAgICAgICAgICAgIGdsb2JhbCBzcnYKKyAgICAgICAgICAgIGlmIG9ubHlfb25lIGFuZCBzcnYgYW5kIHNydi5zdWNjZXNzOgorICAgICAgICAgICAgICAgIHJhaXNlIFN5c3RlbUV4aXQKIAogICAgIGV4Y2VwdCBLZXlib2FyZEludGVycnVwdDoKICAgICAgICAgcmFpc2UgU3lzdGVtRXhpdApkaWZmIC0tZ2l0IGEvaHMyMC9jbGllbnQvQW5kcm9pZC5tayBiL2hzMjAvY2xpZW50L0FuZHJvaWQubWsKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjNjYmM2ZgotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvY2xpZW50L0FuZHJvaWQubWsKQEAgLTAsMCArMSw3NyBAQAorTE9DQUxfUEFUSCA6PSAkKGNhbGwgbXktZGlyKQorCitJTkNMVURFUyA9ICQoTE9DQUxfUEFUSCkKK0lOQ0xVREVTICs9ICQoTE9DQUxfUEFUSCkvLi4vLi4vc3JjL3V0aWxzCitJTkNMVURFUyArPSAkKExPQ0FMX1BBVEgpLy4uLy4uL3NyYy9jb21tb24KK0lOQ0xVREVTICs9ICQoTE9DQUxfUEFUSCkvLi4vLi4vc3JjCitJTkNMVURFUyArPSBleHRlcm5hbC9vcGVuc3NsL2luY2x1ZGUKK0lOQ0xVREVTICs9IGV4dGVybmFsL2xpYnhtbDIvaW5jbHVkZQorSU5DTFVERVMgKz0gZXh0ZXJuYWwvY3VybC9pbmNsdWRlCitJTkNMVURFUyArPSBleHRlcm5hbC93ZWJraXQvU291cmNlL1dlYktpdC9ndGsKK2lmbmVxICgkKHdpbGRjYXJkIGV4dGVybmFsL2ljdSksKQorSU5DTFVERVMgKz0gZXh0ZXJuYWwvaWN1L2ljdTRjL3NvdXJjZS9jb21tb24KK2Vsc2UKK0lOQ0xVREVTICs9IGV4dGVybmFsL2ljdTRjL2NvbW1vbgorZW5kaWYKKworCisjR1RLQ0ZMQUdTIDo9ICQoc2hlbGwgcGtnLWNvbmZpZyAtLWNmbGFncyBndGsrLTIuMCB3ZWJraXQtMS4wKQorI0dUS0xJQlMgOj0gJChzaGVsbCBwa2ctY29uZmlnIC0tbGlicyBndGsrLTIuMCB3ZWJraXQtMS4wKQorI0NGTEFHUyArPSAkKEdUS0NGTEFHUykKKyNMSUJTICs9ICQoR1RLTElCUykKKworTF9DRkxBR1MgKz0gLURDT05GSUdfQ1RSTF9JRkFDRQorTF9DRkxBR1MgKz0gLURDT05GSUdfQ1RSTF9JRkFDRV9VTklYCitMX0NGTEFHUyArPSAtRENPTkZJR19DVFJMX0lGQUNFX0NMSUVOVF9ESVI9XCIvZGF0YS9taXNjL3dpZmkvc29ja2V0c1wiCitMX0NGTEFHUyArPSAtRExJQlhNTF9TQ0hFTUFTX0VOQUJMRUQKK0xfQ0ZMQUdTICs9IC1ETElCWE1MX1JFR0VYUF9FTkFCTEVECisKK09CSlMgPSBzcHBfY2xpZW50LmMKK09CSlMgKz0gb21hX2RtX2NsaWVudC5jCitPQkpTICs9IG9zdV9jbGllbnQuYworT0JKUyArPSBlc3QuYworT0JKUyArPSAuLi8uLi9zcmMvY29tbW9uL3dwYV9jdHJsLmMKK09CSlMgKz0gLi4vLi4vc3JjL2NvbW1vbi93cGFfaGVscGVycy5jCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy94bWwtdXRpbHMuYworI09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL2Jyb3dzZXItYW5kcm9pZC5jCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy9icm93c2VyLXdwYWRlYnVnLmMKK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL3dwYWJ1Zi5jCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy9lbG9vcC5jCitPQkpTICs9IC4uLy4uL3NyYy93cHMvaHR0cHJlYWQuYworT0JKUyArPSAuLi8uLi9zcmMvd3BzL2h0dHBfc2VydmVyLmMKK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL3htbF9saWJ4bWwyLmMKK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL2h0dHBfY3VybC5jCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy9iYXNlNjQuYworT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvb3NfdW5peC5jCitMX0NGTEFHUyArPSAtRENPTkZJR19ERUJVR19GSUxFCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy93cGFfZGVidWcuYworT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvY29tbW9uLmMKK09CSlMgKz0gLi4vLi4vc3JjL2NyeXB0by9jcnlwdG9faW50ZXJuYWwuYworT0JKUyArPSAuLi8uLi9zcmMvY3J5cHRvL21kNS1pbnRlcm5hbC5jCitPQkpTICs9IC4uLy4uL3NyYy9jcnlwdG8vc2hhMS1pbnRlcm5hbC5jCitPQkpTICs9IC4uLy4uL3NyYy9jcnlwdG8vc2hhMjU2LWludGVybmFsLmMKKworTF9DRkxBR1MgKz0gLURFQVBfVExTX09QRU5TU0wKKworI0NGTEFHUyArPSAkKHNoZWxsIHhtbDItY29uZmlnIC0tY2ZsYWdzKQorI0xJQlMgKz0gJChzaGVsbCB4bWwyLWNvbmZpZyAtLWxpYnMpCisKKworIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCitpbmNsdWRlICQoQ0xFQVJfVkFSUykKK0xPQ0FMX01PRFVMRSA6PSBoczIwLW9zdS1jbGllbnQKK0xPQ0FMX01PRFVMRV9UQUdTIDo9IG9wdGlvbmFsCisKK0xPQ0FMX1NIQVJFRF9MSUJSQVJJRVMgOj0gbGliYyBsaWJjdXRpbHMKK0xPQ0FMX1NIQVJFRF9MSUJSQVJJRVMgKz0gbGliY3J5cHRvIGxpYnNzbAorI0xPQ0FMX1NIQVJFRF9MSUJSQVJJRVMgKz0gbGlieG1sMgorTE9DQUxfU1RBVElDX0xJQlJBUklFUyArPSBsaWJ4bWwyCitMT0NBTF9TSEFSRURfTElCUkFSSUVTICs9IGxpYmljdXVjCitMT0NBTF9TSEFSRURfTElCUkFSSUVTICs9IGxpYmN1cmwKKworTE9DQUxfQ0ZMQUdTIDo9ICQoTF9DRkxBR1MpCitMT0NBTF9TUkNfRklMRVMgOj0gJChPQkpTKQorTE9DQUxfQ19JTkNMVURFUyA6PSAkKElOQ0xVREVTKQoraW5jbHVkZSAkKEJVSUxEX0VYRUNVVEFCTEUpCisKKyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvaHMyMC9jbGllbnQvTWFrZWZpbGUgYi9oczIwL2NsaWVudC9NYWtlZmlsZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jYTY3YjU0Ci0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9jbGllbnQvTWFrZWZpbGUKQEAgLTAsMCArMSw5NCBAQAorYWxsOiBoczIwLW9zdS1jbGllbnQKKworaWZuZGVmIENDCitDQz1nY2MKK2VuZGlmCisKK2lmbmRlZiBMRE8KK0xETz0kKENDKQorZW5kaWYKKworUT1ACitFPWVjaG8KK2lmZXEgKCQoViksIDEpCitRPQorRT10cnVlCitlbmRpZgorCitpZm5kZWYgQ0ZMQUdTCitDRkxBR1MgPSAtTU1EIC1PMiAtV2FsbCAtZworZW5kaWYKKworQ0ZMQUdTICs9IC1JLi4vLi4vc3JjL3V0aWxzCitDRkxBR1MgKz0gLUkuLi8uLi9zcmMvY29tbW9uCitDRkxBR1MgKz0gLUkuLi8uLi9zcmMKKworaWZuZGVmIENPTkZJR19OT19CUk9XU0VSCitpZm5kZWYgQ09ORklHX0JST1dTRVJfU1lTVEVNCitHVEtDRkxBR1MgOj0gJChzaGVsbCBwa2ctY29uZmlnIC0tY2ZsYWdzIGd0aystMy4wIHdlYmtpdGd0ay0zLjApCitHVEtMSUJTIDo9ICQoc2hlbGwgcGtnLWNvbmZpZyAtLWxpYnMgZ3RrKy0zLjAgd2Via2l0Z3RrLTMuMCkKK0NGTEFHUyArPSAkKEdUS0NGTEFHUykKK0xJQlMgKz0gJChHVEtMSUJTKQorZW5kaWYKK2VuZGlmCisKK09CSlM9c3BwX2NsaWVudC5vCitPQkpTICs9IG9tYV9kbV9jbGllbnQubworT0JKUyArPSBvc3VfY2xpZW50Lm8KK09CSlMgKz0gZXN0Lm8KK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL3htbC11dGlscy5vCitDRkxBR1MgKz0gLURDT05GSUdfQ1RSTF9JRkFDRQorQ0ZMQUdTICs9IC1EQ09ORklHX0NUUkxfSUZBQ0VfVU5JWAorT0JKUyArPSAuLi8uLi9zcmMvY29tbW9uL3dwYV9jdHJsLm8gLi4vLi4vc3JjL2NvbW1vbi93cGFfaGVscGVycy5vCitpZmRlZiBDT05GSUdfTk9fQlJPV1NFUgorQ0ZMQUdTICs9IC1EQ09ORklHX05PX0JST1dTRVIKK2Vsc2UKK2lmZGVmIENPTkZJR19CUk9XU0VSX1NZU1RFTQorT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvZWxvb3AubworT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvd3BhYnVmLm8KK09CSlMgKz0gLi4vLi4vc3JjL3dwcy9odHRwcmVhZC5vCitPQkpTICs9IC4uLy4uL3NyYy93cHMvaHR0cF9zZXJ2ZXIubworT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvYnJvd3Nlci1zeXN0ZW0ubworZWxzZQorT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvYnJvd3Nlci5vCitlbmRpZgorZW5kaWYKK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL3htbF9saWJ4bWwyLm8KK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL2h0dHBfY3VybC5vCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy9iYXNlNjQubworT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvb3NfdW5peC5vCitDRkxBR1MgKz0gLURDT05GSUdfREVCVUdfRklMRQorT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvd3BhX2RlYnVnLm8KK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL2NvbW1vbi5vCitPQkpTICs9IC4uLy4uL3NyYy9jcnlwdG8vY3J5cHRvX2ludGVybmFsLm8KK09CSlMgKz0gLi4vLi4vc3JjL2NyeXB0by9tZDUtaW50ZXJuYWwubworT0JKUyArPSAuLi8uLi9zcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwubworT0JKUyArPSAuLi8uLi9zcmMvY3J5cHRvL3NoYTI1Ni1pbnRlcm5hbC5vCisKK0NGTEFHUyArPSAkKHNoZWxsIHhtbDItY29uZmlnIC0tY2ZsYWdzKQorTElCUyArPSAkKHNoZWxsIHhtbDItY29uZmlnIC0tbGlicykKK0xJQlMgKz0gLWxjdXJsCisKK0NGTEFHUyArPSAtREVBUF9UTFNfT1BFTlNTTAorTElCUyArPSAtbHNzbCAtbGNyeXB0bworCitoczIwLW9zdS1jbGllbnQ6ICQoT0JKUykKKwkkKFEpJChMRE8pICQoTERGTEFHUykgLW8gaHMyMC1vc3UtY2xpZW50ICQoT0JKUykgJChMSUJTKQorCUAkKEUpICIgIExEICIgJEAKKworJS5vOiAlLmMKKwkkKFEpJChDQykgLWMgLW8gJEAgJChDRkxBR1MpICQ8CisJQCQoRSkgIiAgQ0MgIiAkPAorCitjbGVhbjoKKwlybSAtZiBjb3JlICp+ICoubyAqLmQgaHMyMC1vc3UtY2xpZW50CisJcm0gLWYgLi4vLi4vc3JjL3V0aWxzLyoubworCXJtIC1mIC4uLy4uL3NyYy91dGlscy8qLmQKKwlybSAtZiAuLi8uLi9zcmMvY29tbW9uLyoubworCXJtIC1mIC4uLy4uL3NyYy9jb21tb24vKi5kCisJcm0gLWYgLi4vLi4vc3JjL2NyeXB0by8qLm8KKwlybSAtZiAuLi8uLi9zcmMvY3J5cHRvLyouZAorCXJtIC1mIC4uLy4uL3NyYy93cHMvKi5vCisJcm0gLWYgLi4vLi4vc3JjL3dwcy8qLmQKKworLWluY2x1ZGUgJChPQkpTOiUubz0lLmQpCmRpZmYgLS1naXQgYS9oczIwL2NsaWVudC9kZXZkZXRhaWwueG1sIGIvaHMyMC9jbGllbnQvZGV2ZGV0YWlsLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZDAzODllCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9jbGllbnQvZGV2ZGV0YWlsLnhtbApAQCAtMCwwICsxLDQ3IEBACis8RGV2RGV0YWlsIHhtbG5zPSJ1cm46b21hOm1vOm9tYS1kbS1kZXZkZXRhaWw6MS4wIj4KKwk8RXh0PgorCQk8b3JnLndpLWZpPgorCQkJPFdpLUZpPgorCQkJCTxFQVBNZXRob2RMaXN0PgorCQkJCQk8RUFQTWV0aG9kMT4KKwkJCQkJCTxFQVBUeXBlPjEzPC9FQVBUeXBlPgorCQkJCQk8L0VBUE1ldGhvZDE+CisJCQkJCTxFQVBNZXRob2QyPgorCQkJCQkJPEVBUFR5cGU+MjE8L0VBUFR5cGU+CisJCQkJCQk8SW5uZXJNZXRob2Q+TVMtQ0hBUC1WMjwvSW5uZXJNZXRob2Q+CisJCQkJCTwvRUFQTWV0aG9kMj4KKwkJCQkJPEVBUE1ldGhvZDM+CisJCQkJCQk8RUFQVHlwZT4xODwvRUFQVHlwZT4KKwkJCQkJPC9FQVBNZXRob2QzPgorCQkJCQk8RUFQTWV0aG9kND4KKwkJCQkJCTxFQVBUeXBlPjIzPC9FQVBUeXBlPgorCQkJCQk8L0VBUE1ldGhvZDQ+CisJCQkJCTxFQVBNZXRob2Q1PgorCQkJCQkJPEVBUFR5cGU+NTA8L0VBUFR5cGU+CisJCQkJCTwvRUFQTWV0aG9kNT4KKwkJCQk8L0VBUE1ldGhvZExpc3Q+CisJCQkJPE1hbnVmYWN0dXJpbmdDZXJ0aWZpY2F0ZT5mYWxzZTwvTWFudWZhY3R1cmluZ0NlcnRpZmljYXRlPgorCQkJCTxXaS1GaU1BQ0FkZHJlc3M+MDIwMTAyMDMwNDA1PC9XaS1GaU1BQ0FkZHJlc3M+CisJCQkJPElNU0k+MzEwMDI2MDAwMDAwMDAwPC9JTVNJPgorCQkJCTxJTUVJX01FSUQ+aW1laTo0OTAxMjM0NTY3ODkwMTI8L0lNRUlfTUVJRD4KKwkJCQk8Q2xpZW50VHJpZ2dlclJlZGlyZWN0VVJJPmh0dHA6Ly9sb2NhbGhvc3Q6MTIzNDUvPC9DbGllbnRUcmlnZ2VyUmVkaXJlY3RVUkk+CisJCQkJPE9wcz4KKwkJCQkJPGxhdW5jaEJyb3dzZXJUb1VSST48L2xhdW5jaEJyb3dzZXJUb1VSST4KKwkJCQkJPG5lZ290aWF0ZUNsaWVudENlcnRUTFM+PC9uZWdvdGlhdGVDbGllbnRDZXJ0VExTPgorCQkJCQk8Z2V0Q2VydGlmaWNhdGU+PC9nZXRDZXJ0aWZpY2F0ZT4KKwkJCQk8L09wcz4KKwkJCTwvV2ktRmk+CisJCTwvb3JnLndpLWZpPgorCTwvRXh0PgorCTxVUkk+CisJCTxNYXhEZXB0aD4wPC9NYXhEZXB0aD4KKwkJPE1heFRvdExlbj4wPC9NYXhUb3RMZW4+CisJCTxNYXhTZWdMZW4+MDwvTWF4U2VnTGVuPgorCTwvVVJJPgorCTxEZXZUeXBlPk1vYmlsZVBob25lPC9EZXZUeXBlPgorCTxPRU0+TWFudWZhY3R1cmVyPC9PRU0+CisJPEZ3Vj4xLjA8L0Z3Vj4KKwk8U3dWPjEuMDwvU3dWPgorCTxId1Y+MS4wPC9Id1Y+CisJPExyZ09iaj5mYWxzZTwvTHJnT2JqPgorPC9EZXZEZXRhaWw+CmRpZmYgLS1naXQgYS9oczIwL2NsaWVudC9kZXZpbmZvLnhtbCBiL2hzMjAvY2xpZW50L2RldmluZm8ueG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ0OGE1MjAKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL2NsaWVudC9kZXZpbmZvLnhtbApAQCAtMCwwICsxLDcgQEAKKzxEZXZJbmZvIHhtbG5zPSJ1cm46b21hOm1vOm9tYS1kbS1kZXZpbmZvOjEuMCI+CisJPERldklkPnVybjpFeGFtcGxlOkhTMjAtc3RhdGlvbjoxMjM0NTY8L0RldklkPgorCTxNYW4+TWFudWZhY3R1cmVyPC9NYW4+CisJPE1vZD5IUzIwLXN0YXRpb248L01vZD4KKwk8RG1WPjEuMjwvRG1WPgorCTxMYW5nPmVuPC9MYW5nPgorPC9EZXZJbmZvPgpkaWZmIC0tZ2l0IGEvaHMyMC9jbGllbnQvZXN0LmMgYi9oczIwL2NsaWVudC9lc3QuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lYzA1YmM0Ci0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9jbGllbnQvZXN0LmMKQEAgLTAsMCArMSw3MTUgQEAKKy8qCisgKiBIb3RzcG90IDIuMCBPU1UgY2xpZW50IC0gRVNUIGNsaWVudAorICogQ29weXJpZ2h0IChjKSAyMDEyLTIwMTQsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorI2luY2x1ZGUgPG9wZW5zc2wvZXJyLmg+CisjaW5jbHVkZSA8b3BlbnNzbC9ldnAuaD4KKyNpbmNsdWRlIDxvcGVuc3NsL3BlbS5oPgorI2luY2x1ZGUgPG9wZW5zc2wvcGtjczcuaD4KKyNpbmNsdWRlIDxvcGVuc3NsL3JzYS5oPgorI2luY2x1ZGUgPG9wZW5zc2wvYXNuMS5oPgorI2luY2x1ZGUgPG9wZW5zc2wvYXNuMXQuaD4KKyNpbmNsdWRlIDxvcGVuc3NsL3g1MDkuaD4KKyNpbmNsdWRlIDxvcGVuc3NsL3g1MDl2My5oPgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAidXRpbHMvYmFzZTY0LmgiCisjaW5jbHVkZSAidXRpbHMveG1sLXV0aWxzLmgiCisjaW5jbHVkZSAidXRpbHMvaHR0cC11dGlscy5oIgorI2luY2x1ZGUgIm9zdV9jbGllbnQuaCIKKworCitzdGF0aWMgaW50IHBrY3M3X3RvX2NlcnQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCB1OCAqcGtjczcsCisJCQkgc2l6ZV90IGxlbiwgY2hhciAqcGVtX2ZpbGUsIGNoYXIgKmRlcl9maWxlKQoreworCVBLQ1M3ICpwNyA9IE5VTEw7CisJY29uc3QgdW5zaWduZWQgY2hhciAqcCA9IHBrY3M3OworCVNUQUNLX09GKFg1MDkpICpjZXJ0czsKKwlpbnQgaSwgbnVtLCByZXQgPSAtMTsKKwlCSU8gKm91dCA9IE5VTEw7CisKKwlwNyA9IGQyaV9QS0NTNyhOVUxMLCAmcCwgbGVuKTsKKwlpZiAocDcgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHBhcnNlIFBLQ1MjNyBvYmplY3Q6ICVzIiwKKwkJCSAgIEVSUl9lcnJvcl9zdHJpbmcoRVJSX2dldF9lcnJvcigpLCBOVUxMKSk7CisJCXdyaXRlX3Jlc3VsdChjdHgsICJDb3VsZCBub3QgcGFyc2UgUEtDUyM3IG9iamVjdCBmcm9tIEVTVCIpOworCQlnb3RvIGZhaWw7CisJfQorCisJc3dpdGNoIChPQkpfb2JqMm5pZChwNy0+dHlwZSkpIHsKKwljYXNlIE5JRF9wa2NzN19zaWduZWQ6CisJCWNlcnRzID0gcDctPmQuc2lnbi0+Y2VydDsKKwkJYnJlYWs7CisJY2FzZSBOSURfcGtjczdfc2lnbmVkQW5kRW52ZWxvcGVkOgorCQljZXJ0cyA9IHA3LT5kLnNpZ25lZF9hbmRfZW52ZWxvcGVkLT5jZXJ0OworCQlicmVhazsKKwlkZWZhdWx0OgorCQljZXJ0cyA9IE5VTEw7CisJCWJyZWFrOworCX0KKworCWlmICghY2VydHMgfHwgKChudW0gPSBza19YNTA5X251bShjZXJ0cykpID09IDApKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBjZXJ0aWZpY2F0ZXMgZm91bmQgaW4gUEtDUyM3IG9iamVjdCIpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiTm8gY2VydGlmaWNhdGVzIGZvdW5kIGluIFBLQ1MjNyBvYmplY3QiKTsKKwkJZ290byBmYWlsOworCX0KKworCWlmIChkZXJfZmlsZSkgeworCQlGSUxFICpmID0gZm9wZW4oZGVyX2ZpbGUsICJ3YiIpOworCQlpZiAoZiA9PSBOVUxMKQorCQkJZ290byBmYWlsOworCQlpMmRfWDUwOV9mcChmLCBza19YNTA5X3ZhbHVlKGNlcnRzLCAwKSk7CisJCWZjbG9zZShmKTsKKwl9CisKKwlpZiAocGVtX2ZpbGUpIHsKKwkJb3V0ID0gQklPX25ldyhCSU9fc19maWxlKCkpOworCQlpZiAob3V0ID09IE5VTEwgfHwKKwkJICAgIEJJT193cml0ZV9maWxlbmFtZShvdXQsIHBlbV9maWxlKSA8PSAwKQorCQkJZ290byBmYWlsOworCisJCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQkJWDUwOSAqY2VydCA9IHNrX1g1MDlfdmFsdWUoY2VydHMsIGkpOworCQkJWDUwOV9wcmludChvdXQsIGNlcnQpOworCQkJUEVNX3dyaXRlX2Jpb19YNTA5KG91dCwgY2VydCk7CisJCQlCSU9fcHV0cyhvdXQsICJcbiIpOworCQl9CisJfQorCisJcmV0ID0gMDsKKworZmFpbDoKKwlQS0NTN19mcmVlKHA3KTsKKwlpZiAob3V0KQorCQlCSU9fZnJlZV9hbGwob3V0KTsKKworCXJldHVybiByZXQ7Cit9CisKKworaW50IGVzdF9sb2FkX2NhY2VydHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwpCit7CisJY2hhciAqYnVmLCAqcmVzcDsKKwlzaXplX3QgYnVmbGVuOworCXVuc2lnbmVkIGNoYXIgKnBrY3M3OworCXNpemVfdCBwa2NzN19sZW4sIHJlc3BfbGVuOworCWludCByZXM7CisKKwlidWZsZW4gPSBvc19zdHJsZW4odXJsKSArIDEwMDsKKwlidWYgPSBvc19tYWxsb2MoYnVmbGVuKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCW9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJXMvY2FjZXJ0cyIsIHVybCk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkRvd25sb2FkIEVTVCBjYWNlcnRzIGZyb20gJXMiLCBidWYpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiRG93bmxvYWQgRVNUIGNhY2VydHMgZnJvbSAlcyIsIGJ1Zik7CisJY3R4LT5ub19vc3VfY2VydF92YWxpZGF0aW9uID0gMTsKKwlodHRwX29jc3Bfc2V0KGN0eC0+aHR0cCwgMSk7CisJcmVzID0gaHR0cF9kb3dubG9hZF9maWxlKGN0eC0+aHR0cCwgYnVmLCAiQ2VydC9lc3QtY2FjZXJ0cy50eHQiLAorCQkJCSBjdHgtPmNhX2ZuYW1lKTsKKwlodHRwX29jc3Bfc2V0KGN0eC0+aHR0cCwKKwkJICAgICAgKGN0eC0+d29ya2Fyb3VuZHMgJiBXT1JLQVJPVU5EX09DU1BfT1BUSU9OQUwpID8gMSA6IDIpOworCWN0eC0+bm9fb3N1X2NlcnRfdmFsaWRhdGlvbiA9IDA7CisJaWYgKHJlcyA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byBkb3dubG9hZCBFU1QgY2FjZXJ0cyBmcm9tICVzIiwKKwkJCSAgIGJ1Zik7CisJCXdyaXRlX3Jlc3VsdChjdHgsICJGYWlsZWQgdG8gZG93bmxvYWQgRVNUIGNhY2VydHMgZnJvbSAlcyIsCisJCQkgICAgIGJ1Zik7CisJCW9zX2ZyZWUoYnVmKTsKKwkJcmV0dXJuIC0xOworCX0KKwlvc19mcmVlKGJ1Zik7CisKKwlyZXNwID0gb3NfcmVhZGZpbGUoIkNlcnQvZXN0LWNhY2VydHMudHh0IiwgJnJlc3BfbGVuKTsKKwlpZiAocmVzcCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVhZCBDZXJ0L2VzdC1jYWNlcnRzLnR4dCIpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiQ291bGQgbm90IHJlYWQgRVNUIGNhY2VydHMiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXBrY3M3ID0gYmFzZTY0X2RlY29kZSgodW5zaWduZWQgY2hhciAqKSByZXNwLCByZXNwX2xlbiwgJnBrY3M3X2xlbik7CisJaWYgKHBrY3M3ICYmIHBrY3M3X2xlbiA8IHJlc3BfbGVuIC8gMikgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVG9vIHNob3J0IGJhc2U2NCBkZWNvZGUgKCV1IGJ5dGVzOyBkb3dubG9hZGVkICV1IGJ5dGVzKSAtIGFzc3VtZSB0aGlzIHdhcyBiaW5hcnkiLAorCQkJICAgKHVuc2lnbmVkIGludCkgcGtjczdfbGVuLCAodW5zaWduZWQgaW50KSByZXNwX2xlbik7CisJCW9zX2ZyZWUocGtjczcpOworCQlwa2NzNyA9IE5VTEw7CisJfQorCWlmIChwa2NzNyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJFU1Qgd29ya2Fyb3VuZCAtIENvdWxkIG5vdCBkZWNvZGUgYmFzZTY0LCBhc3N1bWUgdGhpcyBpcyBERVIgZW5jb2RlZCBQS0NTNyIpOworCQlwa2NzNyA9IG9zX21hbGxvYyhyZXNwX2xlbik7CisJCWlmIChwa2NzNykgeworCQkJb3NfbWVtY3B5KHBrY3M3LCByZXNwLCByZXNwX2xlbik7CisJCQlwa2NzN19sZW4gPSByZXNwX2xlbjsKKwkJfQorCX0KKwlvc19mcmVlKHJlc3ApOworCisJaWYgKHBrY3M3ID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBmZXRjaCBQS0NTNyBjYWNlcnRzIik7CisJCXdyaXRlX3Jlc3VsdChjdHgsICJDb3VsZCBub3QgZmV0Y2ggRVNUIFBLQ1MjNyBjYWNlcnRzIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXMgPSBwa2NzN190b19jZXJ0KGN0eCwgcGtjczcsIHBrY3M3X2xlbiwgIkNlcnQvZXN0LWNhY2VydHMucGVtIiwKKwkJCSAgICBOVUxMKTsKKwlvc19mcmVlKHBrY3M3KTsKKwlpZiAocmVzIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHBhcnNlIENBIGNlcnRzIGZyb20gUEtDUyM3IGNhY2VydHMgcmVzcG9uc2UiKTsKKwkJd3JpdGVfcmVzdWx0KGN0eCwgIkNvdWxkIG5vdCBwYXJzZSBDQSBjZXJ0cyBmcm9tIEVTVCBQS0NTIzcgY2FjZXJ0cyByZXNwb25zZSIpOworCQlyZXR1cm4gLTE7CisJfQorCXVubGluaygiQ2VydC9lc3QtY2FjZXJ0cy50eHQiKTsKKworCXJldHVybiAwOworfQorCisKKy8qCisgKiBDc3JBdHRycyA6Oj0gU0VRVUVOQ0UgU0laRSAoMC4uTUFYKSBPRiBBdHRyT3JPSUQKKyAqCisgKiBBdHRyT3JPSUQgOjo9IENIT0lDRSB7CisgKiAgIG9pZCBPQkpFQ1QgSURFTlRJRklFUiwKKyAqICAgYXR0cmlidXRlIEF0dHJpYnV0ZSB9CisgKgorICogQXR0cmlidXRlIDo6PSBTRVFVRU5DRSB7CisgKiAgIHR5cGUgT0JKRUNUIElERU5USUZJRVIsCisgKiAgIHZhbHVlcyBTRVQgU0laRSgxLi5NQVgpIE9GIE9CSkVDVCBJREVOVElGSUVSIH0KKyAqLworCit0eXBlZGVmIHN0cnVjdCB7CisJQVNOMV9PQkpFQ1QgKnR5cGU7CisJU1RBQ0tfT0YoQVNOMV9PQkpFQ1QpICp2YWx1ZXM7Cit9IEF0dHJpYnV0ZTsKKwordHlwZWRlZiBzdHJ1Y3QgeworCWludCB0eXBlOworCXVuaW9uIHsKKwkJQVNOMV9PQkpFQ1QgKm9pZDsKKwkJQXR0cmlidXRlICphdHRyaWJ1dGU7CisJfSBkOworfSBBdHRyT3JPSUQ7CisKK3R5cGVkZWYgc3RydWN0IHsKKwlpbnQgdHlwZTsKKwlTVEFDS19PRihBdHRyT3JPSUQpICphdHRyczsKK30gQ3NyQXR0cnM7CisKK0FTTjFfU0VRVUVOQ0UoQXR0cmlidXRlKSA9IHsKKwlBU04xX1NJTVBMRShBdHRyaWJ1dGUsIHR5cGUsIEFTTjFfT0JKRUNUKSwKKwlBU04xX1NFVF9PRihBdHRyaWJ1dGUsIHZhbHVlcywgQVNOMV9PQkpFQ1QpCit9IEFTTjFfU0VRVUVOQ0VfRU5EKEF0dHJpYnV0ZSk7CisKK0FTTjFfQ0hPSUNFKEF0dHJPck9JRCkgPSB7CisJQVNOMV9TSU1QTEUoQXR0ck9yT0lELCBkLm9pZCwgQVNOMV9PQkpFQ1QpLAorCUFTTjFfU0lNUExFKEF0dHJPck9JRCwgZC5hdHRyaWJ1dGUsIEF0dHJpYnV0ZSkKK30gQVNOMV9DSE9JQ0VfRU5EKEF0dHJPck9JRCk7CisKK0FTTjFfQ0hPSUNFKENzckF0dHJzKSA9IHsKKwlBU04xX1NFUVVFTkNFX09GKENzckF0dHJzLCBhdHRycywgQXR0ck9yT0lEKQorfSBBU04xX0NIT0lDRV9FTkQoQ3NyQXR0cnMpOworCitJTVBMRU1FTlRfQVNOMV9GVU5DVElPTlMoQ3NyQXR0cnMpOworCisKK3N0YXRpYyB2b2lkIGFkZF9jc3JhdHRyc19vaWQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBBU04xX09CSkVDVCAqb2lkLAorCQkJICAgICBTVEFDS19PRihYNTA5X0VYVEVOU0lPTikgKmV4dHMpCit7CisJY2hhciB0eHRbMTAwXTsKKwlpbnQgcmVzOworCisJaWYgKCFvaWQpCisJCXJldHVybjsKKworCXJlcyA9IE9CSl9vYmoydHh0KHR4dCwgc2l6ZW9mKHR4dCksIG9pZCwgMSk7CisJaWYgKHJlcyA8IDAgfHwgcmVzID49IChpbnQpIHNpemVvZih0eHQpKQorCQlyZXR1cm47CisKKwlpZiAob3Nfc3RyY21wKHR4dCwgIjEuMi44NDAuMTEzNTQ5LjEuOS43IikgPT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVE9ETzogY3NyYXR0ciBjaGFsbGVuZ2VQYXNzd29yZCIpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKHR4dCwgIjEuMi44NDAuMTEzNTQ5LjEuMS4xMSIpID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImNzcmF0dHIgc2hhMjU2V2l0aFJTQUVuY3J5cHRpb24iKTsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSWdub3JlIHVuc3VwcG9ydGVkIGNzcmF0dHIgb2lkICVzIiwgdHh0KTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgYWRkX2NzcmF0dHJzX2V4dF9yZXEoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCSBTVEFDS19PRihBU04xX09CSkVDVCkgKnZhbHVlcywKKwkJCQkgU1RBQ0tfT0YoWDUwOV9FWFRFTlNJT04pICpleHRzKQoreworCWNoYXIgdHh0WzEwMF07CisJaW50IGksIG51bSwgcmVzOworCisJbnVtID0gc2tfQVNOMV9PQkpFQ1RfbnVtKHZhbHVlcyk7CisJZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKSB7CisJCUFTTjFfT0JKRUNUICpvaWQgPSBza19BU04xX09CSkVDVF92YWx1ZSh2YWx1ZXMsIGkpOworCisJCXJlcyA9IE9CSl9vYmoydHh0KHR4dCwgc2l6ZW9mKHR4dCksIG9pZCwgMSk7CisJCWlmIChyZXMgPCAwIHx8IHJlcyA+PSAoaW50KSBzaXplb2YodHh0KSkKKwkJCWNvbnRpbnVlOworCisJCWlmIChvc19zdHJjbXAodHh0LCAiMS4zLjYuMS4xLjEuMS4yMiIpID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJUT0RPOiBleHRSZXEgbWFjQWRkcmVzcyIpOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcCh0eHQsICIxLjMuNi4xLjQuMS40MDgwOC4xLjEuMyIpID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJUT0RPOiBleHRSZXEgaW1laSIpOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcCh0eHQsICIxLjMuNi4xLjQuMS40MDgwOC4xLjEuNCIpID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJUT0RPOiBleHRSZXEgbWVpZCIpOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcCh0eHQsICIxLjMuNi4xLjQuMS40MDgwOC4xLjEuNSIpID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJUT0RPOiBleHRSZXEgRGV2SWQiKTsKKwkJfSBlbHNlIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJJZ25vcmUgdW5zdXBwb3J0ZWQgY3N0YXR0ciBleHRlbnNpb25zUmVxdWVzdCAlcyIsCisJCQkJICAgdHh0KTsKKwkJfQorCX0KK30KKworCitzdGF0aWMgdm9pZCBhZGRfY3NyYXR0cnNfYXR0cihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIEF0dHJpYnV0ZSAqYXR0ciwKKwkJCSAgICAgIFNUQUNLX09GKFg1MDlfRVhURU5TSU9OKSAqZXh0cykKK3sKKwljaGFyIHR4dFsxMDBdLCB0eHQyWzEwMF07CisJaW50IGksIG51bSwgcmVzOworCisJaWYgKCFhdHRyIHx8ICFhdHRyLT50eXBlIHx8ICFhdHRyLT52YWx1ZXMpCisJCXJldHVybjsKKworCXJlcyA9IE9CSl9vYmoydHh0KHR4dCwgc2l6ZW9mKHR4dCksIGF0dHItPnR5cGUsIDEpOworCWlmIChyZXMgPCAwIHx8IHJlcyA+PSAoaW50KSBzaXplb2YodHh0KSkKKwkJcmV0dXJuOworCisJaWYgKG9zX3N0cmNtcCh0eHQsICIxLjIuODQwLjExMzU0OS4xLjkuMTQiKSA9PSAwKSB7CisJCWFkZF9jc3JhdHRyc19leHRfcmVxKGN0eCwgYXR0ci0+dmFsdWVzLCBleHRzKTsKKwkJcmV0dXJuOworCX0KKworCW51bSA9IHNrX0FTTjFfT0JKRUNUX251bShhdHRyLT52YWx1ZXMpOworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQlBU04xX09CSkVDVCAqb2lkID0gc2tfQVNOMV9PQkpFQ1RfdmFsdWUoYXR0ci0+dmFsdWVzLCBpKTsKKworCQlyZXMgPSBPQkpfb2JqMnR4dCh0eHQyLCBzaXplb2YodHh0MiksIG9pZCwgMSk7CisJCWlmIChyZXMgPCAwIHx8IHJlcyA+PSAoaW50KSBzaXplb2YodHh0MikpCisJCQljb250aW51ZTsKKworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSWdub3JlIHVuc3VwcG9ydGVkIGNzdGF0dHI6OmF0dHIgJXMgb2lkICVzIiwKKwkJCSAgIHR4dCwgdHh0Mik7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIGFkZF9jc3JhdHRycyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIENzckF0dHJzICpjc3JhdHRycywKKwkJCSBTVEFDS19PRihYNTA5X0VYVEVOU0lPTikgKmV4dHMpCit7CisJaW50IGksIG51bTsKKworCWlmICghY3NyYXR0cnMgfHwgISBjc3JhdHRycy0+YXR0cnMpCisJCXJldHVybjsKKworCW51bSA9IFNLTV9za19udW0oQXR0ck9yT0lELCBjc3JhdHRycy0+YXR0cnMpOworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQlBdHRyT3JPSUQgKmFvID0gU0tNX3NrX3ZhbHVlKEF0dHJPck9JRCwgY3NyYXR0cnMtPmF0dHJzLCBpKTsKKwkJc3dpdGNoIChhby0+dHlwZSkgeworCQljYXNlIDA6CisJCQlhZGRfY3NyYXR0cnNfb2lkKGN0eCwgYW8tPmQub2lkLCBleHRzKTsKKwkJCWJyZWFrOworCQljYXNlIDE6CisJCQlhZGRfY3NyYXR0cnNfYXR0cihjdHgsIGFvLT5kLmF0dHJpYnV0ZSwgZXh0cyk7CisJCQlicmVhazsKKwkJfQorCX0KK30KKworCitzdGF0aWMgaW50IGdlbmVyYXRlX2NzcihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNoYXIgKmtleV9wZW0sCisJCQljaGFyICpjc3JfcGVtLCBjaGFyICplc3RfcmVxLCBjaGFyICpvbGRfY2VydCwKKwkJCUNzckF0dHJzICpjc3JhdHRycykKK3sKKwlFVlBfUEtFWV9DVFggKnBjdHggPSBOVUxMOworCUVWUF9QS0VZICpwa2V5ID0gTlVMTDsKKwlSU0EgKnJzYTsKKwlYNTA5X1JFUSAqcmVxID0gTlVMTDsKKwlpbnQgcmV0ID0gLTE7CisJdW5zaWduZWQgaW50IHZhbDsKKwlYNTA5X05BTUUgKnN1YmogPSBOVUxMOworCWNoYXIgbmFtZVsxMDBdOworCVNUQUNLX09GKFg1MDlfRVhURU5TSU9OKSAqZXh0cyA9IE5VTEw7CisJWDUwOV9FWFRFTlNJT04gKmV4OworCUJJTyAqb3V0OworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkdlbmVyYXRlIFJTQSBwcml2YXRlIGtleSIpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiR2VuZXJhdGUgUlNBIHByaXZhdGUga2V5Iik7CisJcGN0eCA9IEVWUF9QS0VZX0NUWF9uZXdfaWQoRVZQX1BLRVlfUlNBLCBOVUxMKTsKKwlpZiAoIXBjdHgpCisJCXJldHVybiAtMTsKKworCWlmIChFVlBfUEtFWV9rZXlnZW5faW5pdChwY3R4KSA8PSAwKQorCQlnb3RvIGZhaWw7CisKKwlpZiAoRVZQX1BLRVlfQ1RYX3NldF9yc2Ffa2V5Z2VuX2JpdHMocGN0eCwgMjA0OCkgPD0gMCkKKwkJZ290byBmYWlsOworCisJaWYgKEVWUF9QS0VZX2tleWdlbihwY3R4LCAmcGtleSkgPD0gMCkKKwkJZ290byBmYWlsOworCUVWUF9QS0VZX0NUWF9mcmVlKHBjdHgpOworCXBjdHggPSBOVUxMOworCisJcnNhID0gRVZQX1BLRVlfZ2V0MV9SU0EocGtleSk7CisJaWYgKHJzYSA9PSBOVUxMKQorCQlnb3RvIGZhaWw7CisKKwlpZiAoa2V5X3BlbSkgeworCQlGSUxFICpmID0gZm9wZW4oa2V5X3BlbSwgIndiIik7CisJCWlmIChmID09IE5VTEwpCisJCQlnb3RvIGZhaWw7CisJCWlmICghUEVNX3dyaXRlX1JTQVByaXZhdGVLZXkoZiwgcnNhLCBOVUxMLCBOVUxMLCAwLCBOVUxMLAorCQkJCQkgICAgIE5VTEwpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHdyaXRlIHByaXZhdGUga2V5OiAlcyIsCisJCQkJICAgRVJSX2Vycm9yX3N0cmluZyhFUlJfZ2V0X2Vycm9yKCksIE5VTEwpKTsKKwkJCWZjbG9zZShmKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCQlmY2xvc2UoZik7CisJfQorCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkdlbmVyYXRlIENTUiIpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiR2VuZXJhdGUgQ1NSIik7CisJcmVxID0gWDUwOV9SRVFfbmV3KCk7CisJaWYgKHJlcSA9PSBOVUxMKQorCQlnb3RvIGZhaWw7CisKKwlpZiAob2xkX2NlcnQpIHsKKwkJRklMRSAqZjsKKwkJWDUwOSAqY2VydDsKKwkJaW50IHJlczsKKworCQlmID0gZm9wZW4ob2xkX2NlcnQsICJyIik7CisJCWlmIChmID09IE5VTEwpCisJCQlnb3RvIGZhaWw7CisJCWNlcnQgPSBQRU1fcmVhZF9YNTA5KGYsIE5VTEwsIE5VTEwsIE5VTEwpOworCQlmY2xvc2UoZik7CisKKwkJaWYgKGNlcnQgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbDsKKwkJcmVzID0gWDUwOV9SRVFfc2V0X3N1YmplY3RfbmFtZShyZXEsCisJCQkJCQlYNTA5X2dldF9zdWJqZWN0X25hbWUoY2VydCkpOworCQlYNTA5X2ZyZWUoY2VydCk7CisJCWlmICghcmVzKQorCQkJZ290byBmYWlsOworCX0gZWxzZSB7CisJCW9zX2dldF9yYW5kb20oKHU4ICopICZ2YWwsIHNpemVvZih2YWwpKTsKKwkJb3Nfc25wcmludGYobmFtZSwgc2l6ZW9mKG5hbWUpLCAiY2VydC11c2VyLSV1IiwgdmFsKTsKKwkJc3ViaiA9IFg1MDlfTkFNRV9uZXcoKTsKKwkJaWYgKHN1YmogPT0gTlVMTCB8fAorCQkgICAgIVg1MDlfTkFNRV9hZGRfZW50cnlfYnlfdHh0KHN1YmosICJDTiIsIE1CU1RSSU5HX0FTQywKKwkJCQkJCSh1bnNpZ25lZCBjaGFyICopIG5hbWUsCisJCQkJCQktMSwgLTEsIDApIHx8CisJCSAgICAhWDUwOV9SRVFfc2V0X3N1YmplY3RfbmFtZShyZXEsIHN1YmopKQorCQkJZ290byBmYWlsOworCQlYNTA5X05BTUVfZnJlZShzdWJqKTsKKwkJc3ViaiA9IE5VTEw7CisJfQorCisJaWYgKCFYNTA5X1JFUV9zZXRfcHVia2V5KHJlcSwgcGtleSkpCisJCWdvdG8gZmFpbDsKKworCWV4dHMgPSBza19YNTA5X0VYVEVOU0lPTl9uZXdfbnVsbCgpOworCWlmICghZXh0cykKKwkJZ290byBmYWlsOworCisJZXggPSBYNTA5VjNfRVhUX2NvbmZfbmlkKE5VTEwsIE5VTEwsIE5JRF9iYXNpY19jb25zdHJhaW50cywKKwkJCQkgIkNBOkZBTFNFIik7CisJaWYgKGV4ID09IE5VTEwgfHwKKwkgICAgIXNrX1g1MDlfRVhURU5TSU9OX3B1c2goZXh0cywgZXgpKQorCQlnb3RvIGZhaWw7CisKKwlleCA9IFg1MDlWM19FWFRfY29uZl9uaWQoTlVMTCwgTlVMTCwgTklEX2tleV91c2FnZSwKKwkJCQkgIm5vblJlcHVkaWF0aW9uLGRpZ2l0YWxTaWduYXR1cmUsa2V5RW5jaXBoZXJtZW50Iik7CisJaWYgKGV4ID09IE5VTEwgfHwKKwkgICAgIXNrX1g1MDlfRVhURU5TSU9OX3B1c2goZXh0cywgZXgpKQorCQlnb3RvIGZhaWw7CisKKwlleCA9IFg1MDlWM19FWFRfY29uZl9uaWQoTlVMTCwgTlVMTCwgTklEX2V4dF9rZXlfdXNhZ2UsCisJCQkJICIxLjMuNi4xLjQuMS40MDgwOC4xLjEuMiIpOworCWlmIChleCA9PSBOVUxMIHx8CisJICAgICFza19YNTA5X0VYVEVOU0lPTl9wdXNoKGV4dHMsIGV4KSkKKwkJZ290byBmYWlsOworCisJYWRkX2NzcmF0dHJzKGN0eCwgY3NyYXR0cnMsIGV4dHMpOworCisJaWYgKCFYNTA5X1JFUV9hZGRfZXh0ZW5zaW9ucyhyZXEsIGV4dHMpKQorCQlnb3RvIGZhaWw7CisJc2tfWDUwOV9FWFRFTlNJT05fcG9wX2ZyZWUoZXh0cywgWDUwOV9FWFRFTlNJT05fZnJlZSk7CisJZXh0cyA9IE5VTEw7CisKKwlpZiAoIVg1MDlfUkVRX3NpZ24ocmVxLCBwa2V5LCBFVlBfc2hhMjU2KCkpKQorCQlnb3RvIGZhaWw7CisKKwlvdXQgPSBCSU9fbmV3KEJJT19zX21lbSgpKTsKKwlpZiAob3V0KSB7CisJCWNoYXIgKnR4dDsKKwkJc2l6ZV90IHJsZW47CisKKwkJWDUwOV9SRVFfcHJpbnQob3V0LCByZXEpOworCQlybGVuID0gQklPX2N0cmxfcGVuZGluZyhvdXQpOworCQl0eHQgPSBvc19tYWxsb2MocmxlbiArIDEpOworCQlpZiAodHh0KSB7CisJCQlpbnQgcmVzID0gQklPX3JlYWQob3V0LCB0eHQsIHJsZW4pOworCQkJaWYgKHJlcyA+IDApIHsKKwkJCQl0eHRbcmVzXSA9ICdcMCc7CisJCQkJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIk9wZW5TU0w6IENlcnRpZmljYXRlIHJlcXVlc3Q6XG4lcyIsCisJCQkJCSAgIHR4dCk7CisJCQl9CisJCQlvc19mcmVlKHR4dCk7CisJCX0KKwkJQklPX2ZyZWUob3V0KTsKKwl9CisKKwlpZiAoY3NyX3BlbSkgeworCQlGSUxFICpmID0gZm9wZW4oY3NyX3BlbSwgInciKTsKKwkJaWYgKGYgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbDsKKwkJWDUwOV9SRVFfcHJpbnRfZnAoZiwgcmVxKTsKKwkJaWYgKCFQRU1fd3JpdGVfWDUwOV9SRVEoZiwgcmVxKSkgeworCQkJZmNsb3NlKGYpOworCQkJZ290byBmYWlsOworCQl9CisJCWZjbG9zZShmKTsKKwl9CisKKwlpZiAoZXN0X3JlcSkgeworCQlCSU8gKm1lbSA9IEJJT19uZXcoQklPX3NfbWVtKCkpOworCQlCVUZfTUVNICpwdHI7CisJCWNoYXIgKnBvcywgKmVuZCwgKmJ1Zl9lbmQ7CisJCUZJTEUgKmY7CisKKwkJaWYgKG1lbSA9PSBOVUxMKQorCQkJZ290byBmYWlsOworCQlpZiAoIVBFTV93cml0ZV9iaW9fWDUwOV9SRVEobWVtLCByZXEpKSB7CisJCQlCSU9fZnJlZShtZW0pOworCQkJZ290byBmYWlsOworCQl9CisKKwkJQklPX2dldF9tZW1fcHRyKG1lbSwgJnB0cik7CisJCXBvcyA9IHB0ci0+ZGF0YTsKKwkJYnVmX2VuZCA9IHBvcyArIHB0ci0+bGVuZ3RoOworCisJCS8qIFJlbW92ZSBTVEFSVC9FTkQgbGluZXMgKi8KKwkJd2hpbGUgKHBvcyA8IGJ1Zl9lbmQgJiYgKnBvcyAhPSAnXG4nKQorCQkJcG9zKys7CisJCWlmIChwb3MgPT0gYnVmX2VuZCkgeworCQkJQklPX2ZyZWUobWVtKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCQlwb3MrKzsKKworCQllbmQgPSBwb3M7CisJCXdoaWxlIChlbmQgPCBidWZfZW5kICYmICplbmQgIT0gJy0nKQorCQkJZW5kKys7CisKKwkJZiA9IGZvcGVuKGVzdF9yZXEsICJ3Iik7CisJCWlmIChmID09IE5VTEwpIHsKKwkJCUJJT19mcmVlKG1lbSk7CisJCQlnb3RvIGZhaWw7CisJCX0KKwkJZndyaXRlKHBvcywgZW5kIC0gcG9zLCAxLCBmKTsKKwkJZmNsb3NlKGYpOworCisJCUJJT19mcmVlKG1lbSk7CisJfQorCisJcmV0ID0gMDsKK2ZhaWw6CisJaWYgKGV4dHMpCisJCXNrX1g1MDlfRVhURU5TSU9OX3BvcF9mcmVlKGV4dHMsIFg1MDlfRVhURU5TSU9OX2ZyZWUpOworCWlmIChzdWJqKQorCQlYNTA5X05BTUVfZnJlZShzdWJqKTsKKwlpZiAocmVxKQorCQlYNTA5X1JFUV9mcmVlKHJlcSk7CisJaWYgKHBrZXkpCisJCUVWUF9QS0VZX2ZyZWUocGtleSk7CisJaWYgKHBjdHgpCisJCUVWUF9QS0VZX0NUWF9mcmVlKHBjdHgpOworCXJldHVybiByZXQ7Cit9CisKKworaW50IGVzdF9idWlsZF9jc3Ioc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwpCit7CisJY2hhciAqYnVmOworCXNpemVfdCBidWZsZW47CisJaW50IHJlczsKKwljaGFyIG9sZF9jZXJ0X2J1ZlsyMDBdOworCWNoYXIgKm9sZF9jZXJ0ID0gTlVMTDsKKwlDc3JBdHRycyAqY3NyYXR0cnMgPSBOVUxMOworCisJYnVmbGVuID0gb3Nfc3RybGVuKHVybCkgKyAxMDA7CisJYnVmID0gb3NfbWFsbG9jKGJ1Zmxlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzL2NzcmF0dHJzIiwgdXJsKTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRG93bmxvYWQgY3NyYXR0cnMgZnJvbSAlcyIsIGJ1Zik7CisJd3JpdGVfc3VtbWFyeShjdHgsICJEb3dubG9hZCBFU1QgY3NyYXR0cnMgZnJvbSAlcyIsIGJ1Zik7CisJY3R4LT5ub19vc3VfY2VydF92YWxpZGF0aW9uID0gMTsKKwlodHRwX29jc3Bfc2V0KGN0eC0+aHR0cCwgMSk7CisJcmVzID0gaHR0cF9kb3dubG9hZF9maWxlKGN0eC0+aHR0cCwgYnVmLCAiQ2VydC9lc3QtY3NyYXR0cnMudHh0IiwKKwkJCQkgY3R4LT5jYV9mbmFtZSk7CisJaHR0cF9vY3NwX3NldChjdHgtPmh0dHAsCisJCSAgICAgIChjdHgtPndvcmthcm91bmRzICYgV09SS0FST1VORF9PQ1NQX09QVElPTkFMKSA/IDEgOiAyKTsKKwljdHgtPm5vX29zdV9jZXJ0X3ZhbGlkYXRpb24gPSAwOworCW9zX2ZyZWUoYnVmKTsKKwlpZiAocmVzIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIGRvd25sb2FkIEVTVCBjc3JhdHRycyAtIGFzc3VtZSBubyBleHRyYSBhdHRyaWJ1dGVzIGFyZSBuZWVkZWQiKTsKKwl9IGVsc2UgeworCQlzaXplX3QgcmVzcF9sZW47CisJCWNoYXIgKnJlc3A7CisJCXVuc2lnbmVkIGNoYXIgKmF0dHJzOworCQljb25zdCB1bnNpZ25lZCBjaGFyICpwb3M7CisJCXNpemVfdCBhdHRyc19sZW47CisKKwkJcmVzcCA9IG9zX3JlYWRmaWxlKCJDZXJ0L2VzdC1jc3JhdHRycy50eHQiLCAmcmVzcF9sZW4pOworCQlpZiAocmVzcCA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHJlYWQgY3NyYXR0cnMiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCisJCWF0dHJzID0gYmFzZTY0X2RlY29kZSgodW5zaWduZWQgY2hhciAqKSByZXNwLCByZXNwX2xlbiwKKwkJCQkgICAgICAmYXR0cnNfbGVuKTsKKwkJb3NfZnJlZShyZXNwKTsKKworCQlpZiAoYXR0cnMgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBiYXNlNjQgZGVjb2RlIGNzcmF0dHJzIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJdW5saW5rKCJDZXJ0L2VzdC1jc3JhdHRycy50eHQiKTsKKworCQlwb3MgPSBhdHRyczsKKwkJY3NyYXR0cnMgPSBkMmlfQ3NyQXR0cnMoTlVMTCwgJnBvcywgYXR0cnNfbGVuKTsKKwkJb3NfZnJlZShhdHRycyk7CisJCWlmIChjc3JhdHRycyA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHBhcnNlIGNzcmF0dHJzIEFTTi4xIik7CisJCQkvKiBDb250aW51ZSBhc3N1bWluZyBubyBhZGRpdGlvbmFsIHJlcXVpcmVtZW50cyAqLworCQl9CisJfQorCisJaWYgKGN0eC0+Y2xpZW50X2NlcnRfcHJlc2VudCkgeworCQlvc19zbnByaW50ZihvbGRfY2VydF9idWYsIHNpemVvZihvbGRfY2VydF9idWYpLAorCQkJICAgICJTUC8lcy9jbGllbnQtY2VydC5wZW0iLCBjdHgtPmZxZG4pOworCQlvbGRfY2VydCA9IG9sZF9jZXJ0X2J1ZjsKKwl9CisKKwlyZXMgPSBnZW5lcmF0ZV9jc3IoY3R4LCAiQ2VydC9wcml2a2V5LXBsYWluLnBlbSIsICJDZXJ0L2VzdC1yZXEucGVtIiwKKwkJCSAgICJDZXJ0L2VzdC1yZXEuYjY0Iiwgb2xkX2NlcnQsIGNzcmF0dHJzKTsKKwlpZiAoY3NyYXR0cnMpCisJCUNzckF0dHJzX2ZyZWUoY3NyYXR0cnMpOworCisJcmV0dXJuIHJlczsKK30KKworCitpbnQgZXN0X3NpbXBsZV9lbnJvbGwoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwsCisJCSAgICAgIGNvbnN0IGNoYXIgKnVzZXIsIGNvbnN0IGNoYXIgKnB3KQoreworCWNoYXIgKmJ1ZiwgKnJlc3AsICpyZXEsICpyZXEyOworCXNpemVfdCBidWZsZW4sIHJlc3BfbGVuLCBsZW4sIHBrY3M3X2xlbjsKKwl1bnNpZ25lZCBjaGFyICpwa2NzNzsKKwlGSUxFICpmOworCWNoYXIgY2xpZW50X2NlcnRfYnVmWzIwMF07CisJY2hhciBjbGllbnRfa2V5X2J1ZlsyMDBdOworCWNvbnN0IGNoYXIgKmNsaWVudF9jZXJ0ID0gTlVMTCwgKmNsaWVudF9rZXkgPSBOVUxMOworCWludCByZXM7CisKKwlyZXEgPSBvc19yZWFkZmlsZSgiQ2VydC9lc3QtcmVxLmI2NCIsICZsZW4pOworCWlmIChyZXEgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHJlYWQgQ2VydC9yZXEuYjY0Iik7CisJCXJldHVybiAtMTsKKwl9CisJcmVxMiA9IG9zX3JlYWxsb2MocmVxLCBsZW4gKyAxKTsKKwlpZiAocmVxMiA9PSBOVUxMKSB7CisJCW9zX2ZyZWUocmVxKTsKKwkJcmV0dXJuIC0xOworCX0KKwlyZXEyW2xlbl0gPSAnXDAnOworCXJlcSA9IHJlcTI7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFU1Qgc2ltcGxlZW5yb2xsIHJlcXVlc3Q6ICVzIiwgcmVxKTsKKworCWJ1ZmxlbiA9IG9zX3N0cmxlbih1cmwpICsgMTAwOworCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOworCWlmIChidWYgPT0gTlVMTCkgeworCQlvc19mcmVlKHJlcSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoY3R4LT5jbGllbnRfY2VydF9wcmVzZW50KSB7CisJCW9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJXMvc2ltcGxlcmVlbnJvbGwiLCB1cmwpOworCQlvc19zbnByaW50ZihjbGllbnRfY2VydF9idWYsIHNpemVvZihjbGllbnRfY2VydF9idWYpLAorCQkJICAgICJTUC8lcy9jbGllbnQtY2VydC5wZW0iLCBjdHgtPmZxZG4pOworCQljbGllbnRfY2VydCA9IGNsaWVudF9jZXJ0X2J1ZjsKKwkJb3Nfc25wcmludGYoY2xpZW50X2tleV9idWYsIHNpemVvZihjbGllbnRfa2V5X2J1ZiksCisJCQkgICAgIlNQLyVzL2NsaWVudC1rZXkucGVtIiwgY3R4LT5mcWRuKTsKKwkJY2xpZW50X2tleSA9IGNsaWVudF9rZXlfYnVmOworCX0gZWxzZQorCQlvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzL3NpbXBsZWVucm9sbCIsIHVybCk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVTVCBzaW1wbGVlbnJvbGwgVVJMOiAlcyIsIGJ1Zik7CisJd3JpdGVfc3VtbWFyeShjdHgsICJFU1Qgc2ltcGxlZW5yb2xsIFVSTDogJXMiLCBidWYpOworCWN0eC0+bm9fb3N1X2NlcnRfdmFsaWRhdGlvbiA9IDE7CisJaHR0cF9vY3NwX3NldChjdHgtPmh0dHAsIDEpOworCXJlc3AgPSBodHRwX3Bvc3QoY3R4LT5odHRwLCBidWYsIHJlcSwgImFwcGxpY2F0aW9uL3BrY3MxMCIsCisJCQkgIkNvbnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IGJhc2U2NCIsCisJCQkgY3R4LT5jYV9mbmFtZSwgdXNlciwgcHcsIGNsaWVudF9jZXJ0LCBjbGllbnRfa2V5LAorCQkJICZyZXNwX2xlbik7CisJaHR0cF9vY3NwX3NldChjdHgtPmh0dHAsCisJCSAgICAgIChjdHgtPndvcmthcm91bmRzICYgV09SS0FST1VORF9PQ1NQX09QVElPTkFMKSA/IDEgOiAyKTsKKwljdHgtPm5vX29zdV9jZXJ0X3ZhbGlkYXRpb24gPSAwOworCW9zX2ZyZWUoYnVmKTsKKwlpZiAocmVzcCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJFU1QgY2VydGlmaWNhdGUgZW5yb2xsbWVudCBmYWlsZWQiKTsKKwkJd3JpdGVfcmVzdWx0KGN0eCwgIkVTVCBjZXJ0aWZpY2F0ZSBlbnJvbGxtZW50IGZhaWxlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRVNUIHNpbXBsZWVucm9sbCByZXNwb25zZTogJXMiLCByZXNwKTsKKwlmID0gZm9wZW4oIkNlcnQvZXN0LXJlc3AucmF3IiwgInciKTsKKwlpZiAoZikgeworCQlmd3JpdGUocmVzcCwgcmVzcF9sZW4sIDEsIGYpOworCQlmY2xvc2UoZik7CisJfQorCisJcGtjczcgPSBiYXNlNjRfZGVjb2RlKCh1bnNpZ25lZCBjaGFyICopIHJlc3AsIHJlc3BfbGVuLCAmcGtjczdfbGVuKTsKKwlpZiAocGtjczcgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRVNUIHdvcmthcm91bmQgLSBDb3VsZCBub3QgZGVjb2RlIGJhc2U2NCwgYXNzdW1lIHRoaXMgaXMgREVSIGVuY29kZWQgUEtDUzciKTsKKwkJcGtjczcgPSBvc19tYWxsb2MocmVzcF9sZW4pOworCQlpZiAocGtjczcpIHsKKwkJCW9zX21lbWNweShwa2NzNywgcmVzcCwgcmVzcF9sZW4pOworCQkJcGtjczdfbGVuID0gcmVzcF9sZW47CisJCX0KKwl9CisJb3NfZnJlZShyZXNwKTsKKworCWlmIChwa2NzNyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gcGFyc2Ugc2ltcGxlZW5yb2xsIGJhc2U2NCByZXNwb25zZSIpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiRmFpbGVkIHRvIHBhcnNlIEVTVCBzaW1wbGVlbnJvbGwgYmFzZTY0IHJlc3BvbnNlIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXMgPSBwa2NzN190b19jZXJ0KGN0eCwgcGtjczcsIHBrY3M3X2xlbiwgIkNlcnQvZXN0X2NlcnQucGVtIiwKKwkJCSAgICAiQ2VydC9lc3RfY2VydC5kZXIiKTsKKwlvc19mcmVlKHBrY3M3KTsKKworCWlmIChyZXMgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJFU1Q6IEZhaWxlZCB0byBleHRyYWN0IGNlcnRpZmljYXRlIGZyb20gUEtDUzcgZmlsZSIpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiRVNUOiBGYWlsZWQgdG8gZXh0cmFjdCBjZXJ0aWZpY2F0ZSBmcm9tIEVTVCBQS0NTNyBmaWxlIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRVNUIHNpbXBsZSVzZW5yb2xsIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkiLAorCQkgICBjdHgtPmNsaWVudF9jZXJ0X3ByZXNlbnQgPyAicmUiIDogIiIpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiRVNUIHNpbXBsZSVzZW5yb2xsIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkiLAorCQkgICAgICBjdHgtPmNsaWVudF9jZXJ0X3ByZXNlbnQgPyAicmUiIDogIiIpOworCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9oczIwL2NsaWVudC9vbWFfZG1fY2xpZW50LmMgYi9oczIwL2NsaWVudC9vbWFfZG1fY2xpZW50LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODJlOTEwNgotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvY2xpZW50L29tYV9kbV9jbGllbnQuYwpAQCAtMCwwICsxLDEzNzAgQEAKKy8qCisgKiBIb3RzcG90IDIuMCAtIE9NQSBETSBjbGllbnQKKyAqIENvcHlyaWdodCAoYykgMjAxMy0yMDE0LCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgImNvbW1vbi5oIgorI2luY2x1ZGUgIndwYV9oZWxwZXJzLmgiCisjaW5jbHVkZSAieG1sLXV0aWxzLmgiCisjaW5jbHVkZSAiaHR0cC11dGlscy5oIgorI2luY2x1ZGUgInV0aWxzL2Jyb3dzZXIuaCIKKyNpbmNsdWRlICJvc3VfY2xpZW50LmgiCisKKworI2RlZmluZSBETV9TRVJWRVJfSU5JVElBVEVEX01HTVQgMTIwMAorI2RlZmluZSBETV9DTElFTlRfSU5JVElBVEVEX01HTVQgMTIwMQorI2RlZmluZSBETV9HRU5FUklDX0FMRVJUIDEyMjYKKworLyogT01BLVRTLVN5bmNNTC1SZXBQcm8tVjFfMl8yIC0gMTAuIFJlc3BvbnNlIFN0YXR1cyBDb2RlcyAqLworI2RlZmluZSBETV9SRVNQX09LIDIwMAorI2RlZmluZSBETV9SRVNQX0FVVEhfQUNDRVBURUQgMjEyCisjZGVmaW5lIERNX1JFU1BfQ0hVTktFRF9JVEVNX0FDQ0VQVEVEIDIxMworI2RlZmluZSBETV9SRVNQX05PVF9FWEVDVVRFRCAyMTUKKyNkZWZpbmUgRE1fUkVTUF9BVE9NSUNfUk9MTF9CQUNLX09LIDIxNgorI2RlZmluZSBETV9SRVNQX05PVF9NT0RJRklFRCAzMDQKKyNkZWZpbmUgRE1fUkVTUF9CQURfUkVRVUVTVCA0MDAKKyNkZWZpbmUgRE1fUkVTUF9VTkFVVEhPUklaRUQgNDAxCisjZGVmaW5lIERNX1JFU1BfRk9SQklEREVOIDQwMworI2RlZmluZSBETV9SRVNQX05PVF9GT1VORCA0MDQKKyNkZWZpbmUgRE1fUkVTUF9DT01NQU5EX05PVF9BTExPV0VEIDQwNQorI2RlZmluZSBETV9SRVNQX09QVElPTkFMX0ZFQVRVUkVfTk9UX1NVUFBPUlRFRCA0MDYKKyNkZWZpbmUgRE1fUkVTUF9NSVNTSU5HX0NSRURFTlRJQUxTIDQwNworI2RlZmluZSBETV9SRVNQX0NPTkZMSUNUIDQwOQorI2RlZmluZSBETV9SRVNQX0dPTkUgNDEwCisjZGVmaW5lIERNX1JFU1BfSU5DT01QTEVURV9DT01NQU5EIDQxMgorI2RlZmluZSBETV9SRVNQX1JFUV9FTlRJVFlfVE9PX0xBUkdFIDQxMworI2RlZmluZSBETV9SRVNQX1VSSV9UT09fTE9ORyA0MTQKKyNkZWZpbmUgRE1fUkVTUF9VTlNVUFBPUlRFRF9NRURJQV9UWVBFX09SX0ZPUk1BVCA0MTUKKyNkZWZpbmUgRE1fUkVTUF9SRVFfVE9PX0JJRyA0MTYKKyNkZWZpbmUgRE1fUkVTUF9BTFJFQURZX0VYSVNUUyA0MTgKKyNkZWZpbmUgRE1fUkVTUF9ERVZJQ0VfRlVMTCA0MjAKKyNkZWZpbmUgRE1fUkVTUF9TSVpFX01JU01BVENIIDQyNAorI2RlZmluZSBETV9SRVNQX1BFUk1JU1NJT05fREVOSUVEIDQyNQorI2RlZmluZSBETV9SRVNQX0NPTU1BTkRfRkFJTEVEIDUwMAorI2RlZmluZSBETV9SRVNQX0NPTU1BTkRfTk9UX0lNUExFTUVOVEVEIDUwMQorI2RlZmluZSBETV9SRVNQX0FUT01JQ19ST0xMX0JBQ0tfRkFJTEVEIDUxNgorCisjZGVmaW5lIERNX0hTMjBfU1VCU0NSSVBUSU9OX0NSRUFUSU9OIFwKKwkib3JnLndpLWZpLmhvdHNwb3QyZG90MC5TdWJzY3JpcHRpb25DcmVhdGlvbiIKKyNkZWZpbmUgRE1fSFMyMF9TVUJTQ1JJUFRJT05fUFJPVklTSU9OSU5HIFwKKwkib3JnLndpLWZpLmhvdHNwb3QyZG90MC5TdWJzY3JpcHRpb25Qcm92aXNpb25pbmciCisjZGVmaW5lIERNX0hTMjBfU1VCU0NSSVBUSU9OX1JFTUVESUFUSU9OIFwKKwkib3JnLndpLWZpLmhvdHNwb3QyZG90MC5TdWJzY3JpcHRpb25SZW1lZGlhdGlvbiIKKyNkZWZpbmUgRE1fSFMyMF9QT0xJQ1lfVVBEQVRFIFwKKwkib3JnLndpLWZpLmhvdHNwb3QyZG90MC5Qb2xpY3lVcGRhdGUiCisKKyNkZWZpbmUgRE1fVVJJX1BQUyAiLi9XaS1GaS9vcmcud2ktZmkvUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24iCisjZGVmaW5lIERNX1VSSV9MQVVOQ0hfQlJPV1NFUiBcCisJIi4vRGV2RGV0YWlsL0V4dC9vcmcud2ktZmkvV2ktRmkvT3BzL2xhdW5jaEJyb3dzZXJUb1VSSSIKKworCitzdGF0aWMgdm9pZCBhZGRfaXRlbShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIHhtbF9ub2RlX3QgKnBhcmVudCwKKwkJICAgICBjb25zdCBjaGFyICpsb2N1cmksIGNvbnN0IGNoYXIgKmRhdGEpOworCisKK3N0YXRpYyBjb25zdCBjaGFyICogaW50MnN0cihpbnQgdmFsKQoreworCXN0YXRpYyBjaGFyIGJ1ZlsyMF07CisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiVkIiwgdmFsKTsKKwlyZXR1cm4gYnVmOworfQorCisKK3N0YXRpYyBjaGFyICogb21hX2RtX2dldF90YXJnZXRfbG9jdXJpKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkgICAgICAgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxfbm9kZV90ICpsb2N1cmk7CisJY2hhciAqdXJpLCAqcmV0ID0gTlVMTDsKKworCWxvY3VyaSA9IGdldF9ub2RlKGN0eC0+eG1sLCBub2RlLCAiSXRlbS9UYXJnZXQvTG9jVVJJIik7CisJaWYgKGxvY3VyaSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXVyaSA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBsb2N1cmkpOworCWlmICh1cmkpCisJCXJldCA9IG9zX3N0cmR1cCh1cmkpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHVyaSk7CisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgdm9pZCBvbWFfZG1fYWRkX2xvY3VyaShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIHhtbF9ub2RlX3QgKnBhcmVudCwKKwkJCSAgICAgIGNvbnN0IGNoYXIgKmVsZW1lbnQsIGNvbnN0IGNoYXIgKnVyaSkKK3sKKwl4bWxfbm9kZV90ICpub2RlOworCisJbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgcGFyZW50LCBOVUxMLCBlbGVtZW50KTsKKwlpZiAobm9kZSA9PSBOVUxMKQorCQlyZXR1cm47CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIG5vZGUsIE5VTEwsICJMb2NVUkkiLCB1cmkpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogb21hX2RtX2J1aWxkX2hkcihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJICAgICBjb25zdCBjaGFyICp1cmwsIGludCBtc2dpZCkKK3sKKwl4bWxfbm9kZV90ICpzeW5jbWwsICpzeW5jaGRyOworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisKKwlzeW5jbWwgPSB4bWxfbm9kZV9jcmVhdGVfcm9vdChjdHgtPnhtbCwgIlNZTkNNTDpTWU5DTUwxLjIiLCBOVUxMLCAmbnMsCisJCQkJICAgICAgIlN5bmNNTCIpOworCisJc3luY2hkciA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgc3luY21sLCBOVUxMLCAiU3luY0hkciIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBzeW5jaGRyLCBOVUxMLCAiVmVyRFREIiwgIjEuMiIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBzeW5jaGRyLCBOVUxMLCAiVmVyUHJvdG8iLCAiRE0vMS4yIik7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIHN5bmNoZHIsIE5VTEwsICJTZXNzaW9uSUQiLCAiMSIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBzeW5jaGRyLCBOVUxMLCAiTXNnSUQiLCBpbnQyc3RyKG1zZ2lkKSk7CisKKwlvbWFfZG1fYWRkX2xvY3VyaShjdHgsIHN5bmNoZHIsICJUYXJnZXQiLCB1cmwpOworCW9tYV9kbV9hZGRfbG9jdXJpKGN0eCwgc3luY2hkciwgIlNvdXJjZSIsIGN0eC0+ZGV2aWQpOworCisJcmV0dXJuIHN5bmNtbDsKK30KKworCitzdGF0aWMgdm9pZCBvbWFfZG1fYWRkX2NtZGlkKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJICAgICBpbnQgY21kaWQpCit7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIHBhcmVudCwgTlVMTCwgIkNtZElEIiwgaW50MnN0cihjbWRpZCkpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogYWRkX2FsZXJ0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJICAgICAgaW50IGNtZGlkLCBpbnQgZGF0YSkKK3sKKwl4bWxfbm9kZV90ICpub2RlOworCisJbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgcGFyZW50LCBOVUxMLCAiQWxlcnQiKTsKKwlpZiAobm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlvbWFfZG1fYWRkX2NtZGlkKGN0eCwgbm9kZSwgY21kaWQpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBub2RlLCBOVUxMLCAiRGF0YSIsIGludDJzdHIoZGF0YSkpOworCisJcmV0dXJuIG5vZGU7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBhZGRfc3RhdHVzKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJICAgICAgIGludCBtc2dyZWYsIGludCBjbWRyZWYsIGludCBjbWRpZCwKKwkJCSAgICAgICBjb25zdCBjaGFyICpjbWQsIGludCBkYXRhLCBjb25zdCBjaGFyICp0YXJnZXRyZWYpCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKworCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHBhcmVudCwgTlVMTCwgIlN0YXR1cyIpOworCWlmIChub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCW9tYV9kbV9hZGRfY21kaWQoY3R4LCBub2RlLCBjbWRpZCk7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIG5vZGUsIE5VTEwsICJNc2dSZWYiLCBpbnQyc3RyKG1zZ3JlZikpOworCWlmIChjbWRyZWYpCisJCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBub2RlLCBOVUxMLCAiQ21kUmVmIiwKKwkJCQkgICAgIGludDJzdHIoY21kcmVmKSk7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIG5vZGUsIE5VTEwsICJDbWQiLCBjbWQpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBub2RlLCBOVUxMLCAiRGF0YSIsIGludDJzdHIoZGF0YSkpOworCWlmICh0YXJnZXRyZWYpIHsKKwkJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIG5vZGUsIE5VTEwsICJUYXJnZXRSZWYiLAorCQkJCSAgICAgdGFyZ2V0cmVmKTsKKwl9CisKKwlyZXR1cm4gbm9kZTsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGFkZF9yZXN1bHRzKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJCWludCBtc2dyZWYsIGludCBjbWRyZWYsIGludCBjbWRpZCwKKwkJCQljb25zdCBjaGFyICpsb2N1cmksIGNvbnN0IGNoYXIgKmRhdGEpCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKworCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHBhcmVudCwgTlVMTCwgIlJlc3VsdHMiKTsKKwlpZiAobm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCW9tYV9kbV9hZGRfY21kaWQoY3R4LCBub2RlLCBjbWRpZCk7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIG5vZGUsIE5VTEwsICJNc2dSZWYiLCBpbnQyc3RyKG1zZ3JlZikpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBub2RlLCBOVUxMLCAiQ21kUmVmIiwgaW50MnN0cihjbWRyZWYpKTsKKwlhZGRfaXRlbShjdHgsIG5vZGUsIGxvY3VyaSwgZGF0YSk7CisKKwlyZXR1cm4gbm9kZTsKK30KKworCitzdGF0aWMgY2hhciAqIG1vX3N0cihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnVybiwKKwkJICAgICBjb25zdCBjaGFyICpmbmFtZSkKK3sKKwl4bWxfbm9kZV90ICpmbm9kZSwgKnRuZHM7CisJY2hhciAqc3RyOworCisJZm5vZGUgPSBub2RlX2Zyb21fZmlsZShjdHgtPnhtbCwgZm5hbWUpOworCWlmICghZm5vZGUpCisJCXJldHVybiBOVUxMOworCXRuZHMgPSBtb190b190bmRzKGN0eC0+eG1sLCBmbm9kZSwgMCwgdXJuLCAic3luY21sOmRtZGRmMS4yIik7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgZm5vZGUpOworCWlmICghdG5kcykKKwkJcmV0dXJuIE5VTEw7CisKKwlzdHIgPSB4bWxfbm9kZV90b19zdHIoY3R4LT54bWwsIHRuZHMpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHRuZHMpOworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIk1nbXRUcmVlOiAlcyIsIHN0cik7CisKKwlyZXR1cm4gc3RyOworfQorCisKK3N0YXRpYyB2b2lkIGFkZF9pdGVtKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkgICAgIGNvbnN0IGNoYXIgKmxvY3VyaSwgY29uc3QgY2hhciAqZGF0YSkKK3sKKwl4bWxfbm9kZV90ICppdGVtLCAqbm9kZTsKKworCWl0ZW0gPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHBhcmVudCwgTlVMTCwgIkl0ZW0iKTsKKwlvbWFfZG1fYWRkX2xvY3VyaShjdHgsIGl0ZW0sICJTb3VyY2UiLCBsb2N1cmkpOworCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIGl0ZW0sIE5VTEwsICJNZXRhIik7CisJeG1sX25vZGVfY3JlYXRlX3RleHRfbnMoY3R4LT54bWwsIG5vZGUsICJzeW5jbWw6bWV0aW5mIiwgIkZvcm1hdCIsCisJCQkJIkNociIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0X25zKGN0eC0+eG1sLCBub2RlLCAic3luY21sOm1ldGluZiIsICJUeXBlIiwKKwkJCQkidGV4dC9wbGFpbiIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBpdGVtLCBOVUxMLCAiRGF0YSIsIGRhdGEpOworfQorCisKK3N0YXRpYyB2b2lkIGFkZF9yZXBsYWNlX2RldmluZm8oc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpwYXJlbnQsCisJCQkJaW50IGNtZGlkKQoreworCXhtbF9ub2RlX3QgKmluZm8sICpjaGlsZCwgKnJlcGxhY2U7CisJY29uc3QgY2hhciAqbmFtZTsKKwljaGFyIGxvY3VyaVsyMDBdLCAqdHh0OworCisJaW5mbyA9IG5vZGVfZnJvbV9maWxlKGN0eC0+eG1sLCAiZGV2aW5mby54bWwiKTsKKwlpZiAoaW5mbyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVhZCBkZXZpbmZvLnhtbCIpOworCQlyZXR1cm47CisJfQorCisJcmVwbGFjZSA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgcGFyZW50LCBOVUxMLCAiUmVwbGFjZSIpOworCWlmIChyZXBsYWNlID09IE5VTEwpIHsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgaW5mbyk7CisJCXJldHVybjsKKwl9CisJb21hX2RtX2FkZF9jbWRpZChjdHgsIHJlcGxhY2UsIGNtZGlkKTsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgaW5mbykgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgtPnhtbCwgY2hpbGQpOworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgY2hpbGQpOworCQlvc19zbnByaW50Zihsb2N1cmksIHNpemVvZihsb2N1cmkpLCAiLi9EZXZJbmZvLyVzIiwgbmFtZSk7CisJCXR4dCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBjaGlsZCk7CisJCWlmICh0eHQpIHsKKwkJCWFkZF9pdGVtKGN0eCwgcmVwbGFjZSwgbG9jdXJpLCB0eHQpOworCQkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgdHh0KTsKKwkJfQorCX0KKworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIGluZm8pOworfQorCisKK3N0YXRpYyB2b2lkIG9tYV9kbV9hZGRfaHMyMF9nZW5lcmljX2FsZXJ0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICB4bWxfbm9kZV90ICpzeW5jYm9keSwKKwkJCQkJICBpbnQgY21kaWQsIGNvbnN0IGNoYXIgKm9wZXIsCisJCQkJCSAgY29uc3QgY2hhciAqZGF0YSkKK3sKKwl4bWxfbm9kZV90ICpub2RlLCAqaXRlbTsKKwljaGFyIGJ1ZlsyMDBdOworCisJbm9kZSA9IGFkZF9hbGVydChjdHgsIHN5bmNib2R5LCBjbWRpZCwgRE1fR0VORVJJQ19BTEVSVCk7CisKKwlpdGVtID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBub2RlLCBOVUxMLCAiSXRlbSIpOworCW9tYV9kbV9hZGRfbG9jdXJpKGN0eCwgaXRlbSwgIlNvdXJjZSIsIERNX1VSSV9QUFMpOworCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIGl0ZW0sIE5VTEwsICJNZXRhIik7CisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIlJldmVyc2VkLURvbWFpbi1OYW1lOiAlcyIsIG9wZXIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0X25zKGN0eC0+eG1sLCBub2RlLCAic3luY21sOm1ldGluZiIsICJUeXBlIiwgYnVmKTsKKwl4bWxfbm9kZV9jcmVhdGVfdGV4dF9ucyhjdHgtPnhtbCwgbm9kZSwgInN5bmNtbDptZXRpbmYiLCAiRm9ybWF0IiwKKwkJCQkieG1sIik7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIGl0ZW0sIE5VTEwsICJEYXRhIiwgZGF0YSk7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBidWlsZF9vbWFfZG1fMShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJICAgY29uc3QgY2hhciAqdXJsLCBpbnQgbXNnaWQsIGNvbnN0IGNoYXIgKm9wZXIpCit7CisJeG1sX25vZGVfdCAqc3luY21sLCAqc3luY2JvZHk7CisJY2hhciAqc3RyOworCWludCBjbWRpZCA9IDA7CisKKwlzeW5jbWwgPSBvbWFfZG1fYnVpbGRfaGRyKGN0eCwgdXJsLCBtc2dpZCk7CisJaWYgKHN5bmNtbCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXN5bmNib2R5ID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBzeW5jbWwsIE5VTEwsICJTeW5jQm9keSIpOworCWlmIChzeW5jYm9keSA9PSBOVUxMKSB7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHN5bmNtbCk7CisJCXJldHVybiBOVUxMOworCX0KKworCWNtZGlkKys7CisJYWRkX2FsZXJ0KGN0eCwgc3luY2JvZHksIGNtZGlkLCBETV9DTElFTlRfSU5JVElBVEVEX01HTVQpOworCisJc3RyID0gbW9fc3RyKGN0eCwgTlVMTCwgImRldmRldGFpbC54bWwiKTsKKwlpZiAoc3RyID09IE5VTEwpIHsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgc3luY21sKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCWNtZGlkKys7CisJb21hX2RtX2FkZF9oczIwX2dlbmVyaWNfYWxlcnQoY3R4LCBzeW5jYm9keSwgY21kaWQsIG9wZXIsIHN0cik7CisJb3NfZnJlZShzdHIpOworCisJY21kaWQrKzsKKwlhZGRfcmVwbGFjZV9kZXZpbmZvKGN0eCwgc3luY2JvZHksIGNtZGlkKTsKKworCXhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgc3luY2JvZHksIE5VTEwsICJGaW5hbCIpOworCisJcmV0dXJuIHN5bmNtbDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX29tYV9kbV8xX3N1Yl9yZWcoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCQkgICBjb25zdCBjaGFyICp1cmwsIGludCBtc2dpZCkKK3sKKwl4bWxfbm9kZV90ICpzeW5jbWw7CisKKwlzeW5jbWwgPSBidWlsZF9vbWFfZG1fMShjdHgsIHVybCwgbXNnaWQsIERNX0hTMjBfU1VCU0NSSVBUSU9OX0NSRUFUSU9OKTsKKwlpZiAoc3luY21sKQorCQlkZWJ1Z19kdW1wX25vZGUoY3R4LCAiT01BLURNIFBhY2thZ2UgMSAoc3ViIHJlZykiLCBzeW5jbWwpOworCisJcmV0dXJuIHN5bmNtbDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX29tYV9kbV8xX3N1Yl9wcm92KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICAgIGNvbnN0IGNoYXIgKnVybCwgaW50IG1zZ2lkKQoreworCXhtbF9ub2RlX3QgKnN5bmNtbDsKKworCXN5bmNtbCA9IGJ1aWxkX29tYV9kbV8xKGN0eCwgdXJsLCBtc2dpZCwKKwkJCQlETV9IUzIwX1NVQlNDUklQVElPTl9QUk9WSVNJT05JTkcpOworCWlmIChzeW5jbWwpCisJCWRlYnVnX2R1bXBfbm9kZShjdHgsICJPTUEtRE0gUGFja2FnZSAxIChzdWIgcHJvdikiLCBzeW5jbWwpOworCisJcmV0dXJuIHN5bmNtbDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX29tYV9kbV8xX3BvbF91cGQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCQkgICBjb25zdCBjaGFyICp1cmwsIGludCBtc2dpZCkKK3sKKwl4bWxfbm9kZV90ICpzeW5jbWw7CisKKwlzeW5jbWwgPSBidWlsZF9vbWFfZG1fMShjdHgsIHVybCwgbXNnaWQsIERNX0hTMjBfUE9MSUNZX1VQREFURSk7CisJaWYgKHN5bmNtbCkKKwkJZGVidWdfZHVtcF9ub2RlKGN0eCwgIk9NQS1ETSBQYWNrYWdlIDEgKHBvbCB1cGQpIiwgc3luY21sKTsKKworCXJldHVybiBzeW5jbWw7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBidWlsZF9vbWFfZG1fMV9zdWJfcmVtKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICAgY29uc3QgY2hhciAqdXJsLCBpbnQgbXNnaWQpCit7CisJeG1sX25vZGVfdCAqc3luY21sOworCisJc3luY21sID0gYnVpbGRfb21hX2RtXzEoY3R4LCB1cmwsIG1zZ2lkLAorCQkJCURNX0hTMjBfU1VCU0NSSVBUSU9OX1JFTUVESUFUSU9OKTsKKwlpZiAoc3luY21sKQorCQlkZWJ1Z19kdW1wX25vZGUoY3R4LCAiT01BLURNIFBhY2thZ2UgMSAoc3ViIHJlbSkiLCBzeW5jbWwpOworCisJcmV0dXJuIHN5bmNtbDsKK30KKworCitzdGF0aWMgaW50IG9tYV9kbV9leGVjX2Jyb3dzZXIoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpleGVjKQoreworCXhtbF9ub2RlX3QgKm5vZGU7CisJY2hhciAqZGF0YTsKKwlpbnQgcmVzOworCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBleGVjLCAiSXRlbS9EYXRhIik7CisJaWYgKG5vZGUgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gRGF0YSBub2RlIGZvdW5kIik7CisJCXJldHVybiBETV9SRVNQX0JBRF9SRVFVRVNUOworCX0KKworCWRhdGEgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkRhdGE6ICVzIiwgZGF0YSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkxhdW5jaCBicm93c2VyIHRvIFVSSSAnJXMnIiwgZGF0YSk7CisJd3JpdGVfc3VtbWFyeShjdHgsICJMYXVuY2ggYnJvd3NlciB0byBVUkkgJyVzJyIsIGRhdGEpOworCXJlcyA9IGhzMjBfd2ViX2Jyb3dzZXIoZGF0YSk7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgZGF0YSk7CisJaWYgKHJlcyA+IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVzZXIgcmVzcG9uc2UgaW4gYnJvd3NlciBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5Iik7CisJCXdyaXRlX3N1bW1hcnkoY3R4LCAiVXNlciByZXNwb25zZSBpbiBicm93c2VyIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkiKTsKKwkJcmV0dXJuIERNX1JFU1BfT0s7CisJfSBlbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byByZWNlaXZlIHVzZXIgcmVzcG9uc2UiKTsKKwkJd3JpdGVfc3VtbWFyeShjdHgsICJGYWlsZWQgdG8gcmVjZWl2ZSB1c2VyIHJlc3BvbnNlIik7CisJCXJldHVybiBETV9SRVNQX0NPTU1BTkRfRkFJTEVEOworCX0KK30KKworCitzdGF0aWMgaW50IG9tYV9kbV9leGVjX2dldF9jZXJ0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqZXhlYykKK3sKKwl4bWxfbm9kZV90ICpub2RlLCAqZ2V0Y2VydDsKKwljaGFyICpkYXRhOworCWNvbnN0IGNoYXIgKm5hbWU7CisJaW50IHJlczsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJDbGllbnQgY2VydGlmaWNhdGUgZW5yb2xsbWVudCIpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiQ2xpZW50IGNlcnRpZmljYXRlIGVucm9sbG1lbnQiKTsKKworCW5vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgZXhlYywgIkl0ZW0vRGF0YSIpOworCWlmIChub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIERhdGEgbm9kZSBmb3VuZCIpOworCQlyZXR1cm4gRE1fUkVTUF9CQURfUkVRVUVTVDsKKwl9CisKKwlkYXRhID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCXdwYV9wcmludGYoTVNHX0lORk8sICJEYXRhOiAlcyIsIGRhdGEpOworCWdldGNlcnQgPSB4bWxfbm9kZV9mcm9tX2J1ZihjdHgtPnhtbCwgZGF0YSk7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgZGF0YSk7CisKKwlpZiAoZ2V0Y2VydCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcGFyc2UgSXRlbS9EYXRhIG5vZGUgY29udGVudHMiKTsKKwkJcmV0dXJuIERNX1JFU1BfQkFEX1JFUVVFU1Q7CisJfQorCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgIk9NQS1ETSBnZXRDZXJ0aWZpY2F0ZSIsIGdldGNlcnQpOworCisJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIGdldGNlcnQpOworCWlmIChuYW1lID09IE5VTEwgfHwgb3Nfc3RyY2FzZWNtcChuYW1lLCAiZ2V0Q2VydGlmaWNhdGUiKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVbmV4cGVjdGVkIGdldENlcnRpZmljYXRlIG5vZGUgbmFtZSAnJXMnIiwKKwkJCSAgIG5hbWUpOworCQlyZXR1cm4gRE1fUkVTUF9CQURfUkVRVUVTVDsKKwl9CisKKwlyZXMgPSBvc3VfZ2V0X2NlcnRpZmljYXRlKGN0eCwgZ2V0Y2VydCk7CisKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBnZXRjZXJ0KTsKKworCXJldHVybiByZXMgPT0gMCA/IERNX1JFU1BfT0sgOiBETV9SRVNQX0NPTU1BTkRfRkFJTEVEOworfQorCisKK3N0YXRpYyBpbnQgb21hX2RtX2V4ZWMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpleGVjKQoreworCWNoYXIgKmxvY3VyaTsKKwlpbnQgcmV0OworCisJbG9jdXJpID0gb21hX2RtX2dldF90YXJnZXRfbG9jdXJpKGN0eCwgZXhlYyk7CisJaWYgKGxvY3VyaSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBUYXJnZXQgTG9jVVJJIG5vZGUgZm91bmQiKTsKKwkJcmV0dXJuIERNX1JFU1BfQkFEX1JFUVVFU1Q7CisJfQorCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRhcmdldCBMb2NVUkk6ICVzIiwgbG9jdXJpKTsKKworCWlmIChvc19zdHJjYXNlY21wKGxvY3VyaSwgIi4vRGV2RGV0YWlsL0V4dC9vcmcud2ktZmkvV2ktRmkvT3BzLyIKKwkJCSAgImxhdW5jaEJyb3dzZXJUb1VSSSIpID09IDApIHsKKwkJcmV0ID0gb21hX2RtX2V4ZWNfYnJvd3NlcihjdHgsIGV4ZWMpOworCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChsb2N1cmksICIuL0RldkRldGFpbC9FeHQvb3JnLndpLWZpL1dpLUZpL09wcy8iCisJCQkgICJnZXRDZXJ0aWZpY2F0ZSIpID09IDApIHsKKwkJcmV0ID0gb21hX2RtX2V4ZWNfZ2V0X2NlcnQoY3R4LCBleGVjKTsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVW5zdXBwb3J0ZWQgZXhlYyBUYXJnZXQgTG9jVVJJIik7CisJCXJldCA9IERNX1JFU1BfTk9UX0ZPVU5EOworCX0KKwlvc19mcmVlKGxvY3VyaSk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgb21hX2RtX3J1bl9hZGQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpsb2N1cmksCisJCQkgIHhtbF9ub2RlX3QgKmFkZCwgeG1sX25vZGVfdCAqcHBzLAorCQkJICBjb25zdCBjaGFyICpwcHNfZm5hbWUpCit7CisJY29uc3QgY2hhciAqcG9zOworCXNpemVfdCBmcWRuX2xlbjsKKwl4bWxfbm9kZV90ICpub2RlLCAqdG5kcywgKnVub2RlLCAqcHBzX25vZGU7CisJY2hhciAqZGF0YSwgKnVyaSwgKnVwb3MsICplbmQ7CisJaW50IHVzZV90bmRzID0gMDsKKwlzaXplX3QgdXJpX2xlbjsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJBZGQgY29tbWFuZCB0YXJnZXQgTG9jVVJJOiAlcyIsIGxvY3VyaSk7CisKKwlpZiAob3Nfc3RybmNhc2VjbXAobG9jdXJpLCAiLi9XaS1GaS8iLCA4KSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJEbyBub3QgYWxsb3cgQWRkIG91dHNpZGUgLi9XaS1GaSIpOworCQlyZXR1cm4gRE1fUkVTUF9QRVJNSVNTSU9OX0RFTklFRDsKKwl9CisJcG9zID0gbG9jdXJpICsgODsKKworCWlmIChjdHgtPmZxZG4gPT0gTlVMTCkKKwkJcmV0dXJuIERNX1JFU1BfQ09NTUFORF9GQUlMRUQ7CisJZnFkbl9sZW4gPSBvc19zdHJsZW4oY3R4LT5mcWRuKTsKKwlpZiAob3Nfc3RybmNhc2VjbXAocG9zLCBjdHgtPmZxZG4sIGZxZG5fbGVuKSAhPSAwIHx8CisJICAgIHBvc1tmcWRuX2xlbl0gIT0gJy8nKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJEbyBub3QgYWxsb3cgQWRkIG91dHNpZGUgLi9XaS1GaS8lcyIsCisJCQkgICBjdHgtPmZxZG4pOworCQlyZXR1cm4gRE1fUkVTUF9QRVJNSVNTSU9OX0RFTklFRDsKKwl9CisJcG9zICs9IGZxZG5fbGVuICsgMTsKKworCWlmIChvc19zdHJuY2FzZWNtcChwb3MsICJQZXJQcm92aWRlclN1YnNjcmlwdGlvbi8iLCAyNCkgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLAorCQkJICAgIkRvIG5vdCBhbGxvdyBBZGQgb3V0c2lkZSAuL1dpLUZpLyVzL1BlclByb3ZpZGVyU3Vic2NyaXB0aW9uIiwKKwkJCSAgIGN0eC0+ZnFkbik7CisJCXJldHVybiBETV9SRVNQX1BFUk1JU1NJT05fREVOSUVEOworCX0KKwlwb3MgKz0gMjQ7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQWRkIGNvbW1hbmQgZm9yIFBQUyBub2RlICVzIiwgcG9zKTsKKworCXBwc19ub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIHBwcywgcG9zKTsKKwlpZiAocHBzX25vZGUpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNwZWNpZmllZCBQUFMgbm9kZSBleGlzdHMgYWxyZWFkeSIpOworCQlyZXR1cm4gRE1fUkVTUF9BTFJFQURZX0VYSVNUUzsKKwl9CisKKwl1cmkgPSBvc19zdHJkdXAocG9zKTsKKwlpZiAodXJpID09IE5VTEwpCisJCXJldHVybiBETV9SRVNQX0NPTU1BTkRfRkFJTEVEOworCXdoaWxlICghcHBzX25vZGUpIHsKKwkJdXBvcyA9IG9zX3N0cnJjaHIodXJpLCAnLycpOworCQlpZiAoIXVwb3MpCisJCQlicmVhazsKKwkJdXBvc1swXSA9ICdcMCc7CisJCXBwc19ub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIHBwcywgdXJpKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vZGUgJXMgJXMiLCB1cmksCisJCQkgICBwcHNfbm9kZSA/ICJleGlzdHMiIDogImRvZXMgbm90IGV4aXN0Iik7CisJfQorCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBhcmVudCBVUkk6ICVzIiwgdXJpKTsKKworCWlmICghcHBzX25vZGUpIHsKKwkJLyogQWRkIGF0IHJvb3Qgb2YgUFBTIE1PICovCisJCXBwc19ub2RlID0gcHBzOworCX0KKworCXVyaV9sZW4gPSBvc19zdHJsZW4odXJpKTsKKwlvc19zdHJsY3B5KHVyaSwgcG9zICsgdXJpX2xlbiwgb3Nfc3RybGVuKHBvcykpOworCXVwb3MgPSB1cmk7CisJd2hpbGUgKCp1cG9zID09ICcvJykKKwkJdXBvcysrOworCXdwYV9wcmludGYoTVNHX0lORk8sICJOb2RlcyB0byBhZGQ6ICVzIiwgdXBvcyk7CisKKwlmb3IgKDs7KSB7CisJCWVuZCA9IG9zX3N0cmNocih1cG9zLCAnLycpOworCQlpZiAoIWVuZCkKKwkJCWJyZWFrOworCQkqZW5kID0gJ1wwJzsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkFkZGluZyBpbnRlcmltIG5vZGUgJXMiLCB1cG9zKTsKKwkJcHBzX25vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHBwc19ub2RlLCBOVUxMLCB1cG9zKTsKKwkJaWYgKHBwc19ub2RlID09IE5VTEwpIHsKKwkJCW9zX2ZyZWUodXJpKTsKKwkJCXJldHVybiBETV9SRVNQX0NPTU1BTkRfRkFJTEVEOworCQl9CisJCXVwb3MgPSBlbmQgKyAxOworCX0KKworCXdwYV9wcmludGYoTVNHX0lORk8sICJBZGRpbmcgbm9kZSAlcyIsIHVwb3MpOworCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBhZGQsICJJdGVtL01ldGEvVHlwZSIpOworCWlmIChub2RlKSB7CisJCWNoYXIgKnR5cGU7CisJCXR5cGUgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJCXVzZV90bmRzID0gbm9kZSAmJgorCQkJb3Nfc3Ryc3RyKHR5cGUsICJhcHBsaWNhdGlvbi92bmQuc3luY21sLmRtdG5kcyt4bWwiKTsKKwl9CisKKwlub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIGFkZCwgIkl0ZW0vRGF0YSIpOworCWlmIChub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIEFkZC9JdGVtL0RhdGEgZm91bmQiKTsKKwkJb3NfZnJlZSh1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9CQURfUkVRVUVTVDsKKwl9CisKKwlkYXRhID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChkYXRhID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBnZXQgQWRkL0l0ZW0vRGF0YSB0ZXh0Iik7CisJCW9zX2ZyZWUodXJpKTsKKwkJcmV0dXJuIERNX1JFU1BfQkFEX1JFUVVFU1Q7CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBZGQvSXRlbS9EYXRhOiAlcyIsIGRhdGEpOworCisJaWYgKHVzZV90bmRzKSB7CisJCXRuZHMgPSB4bWxfbm9kZV9mcm9tX2J1ZihjdHgtPnhtbCwgZGF0YSk7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGRhdGEpOworCQlpZiAodG5kcyA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLAorCQkJCSAgICJDb3VsZCBub3QgcGFyc2UgQWRkL0l0ZW0vRGF0YSB0ZXh0Iik7CisJCQlvc19mcmVlKHVyaSk7CisJCQlyZXR1cm4gRE1fUkVTUF9CQURfUkVRVUVTVDsKKwkJfQorCisJCXVub2RlID0gdG5kc190b19tbyhjdHgtPnhtbCwgdG5kcyk7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHRuZHMpOworCQlpZiAodW5vZGUgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBwYXJzZSBUTkRTIHRleHQiKTsKKwkJCW9zX2ZyZWUodXJpKTsKKwkJCXJldHVybiBETV9SRVNQX0JBRF9SRVFVRVNUOworCQl9CisKKwkJZGVidWdfZHVtcF9ub2RlKGN0eCwgIlBhcnNlZCBUTkRTIiwgdW5vZGUpOworCisJCXhtbF9ub2RlX2FkZF9jaGlsZChjdHgtPnhtbCwgcHBzX25vZGUsIHVub2RlKTsKKwl9IGVsc2UgeworCQkvKiBUT0RPOiBXaGF0IHRvIGRvIGhlcmU/ICovCisJCW9zX2ZyZWUodXJpKTsKKwkJcmV0dXJuIERNX1JFU1BfQkFEX1JFUVVFU1Q7CisJfQorCisJb3NfZnJlZSh1cmkpOworCisJaWYgKHVwZGF0ZV9wcHNfZmlsZShjdHgsIHBwc19mbmFtZSwgcHBzKSA8IDApCisJCXJldHVybiBETV9SRVNQX0NPTU1BTkRfRkFJTEVEOworCisJY3R4LT5wcHNfdXBkYXRlZCA9IDE7CisKKwlyZXR1cm4gRE1fUkVTUF9PSzsKK30KKworCitzdGF0aWMgaW50IG9tYV9kbV9hZGQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICphZGQsCisJCSAgICAgIHhtbF9ub2RlX3QgKnBwcywgY29uc3QgY2hhciAqcHBzX2ZuYW1lKQoreworCXhtbF9ub2RlX3QgKm5vZGU7CisJY2hhciAqbG9jdXJpOworCWNoYXIgZm5hbWVbMzAwXTsKKwlpbnQgcmV0OworCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBhZGQsICJJdGVtL1RhcmdldC9Mb2NVUkkiKTsKKwlpZiAobm9kZSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBUYXJnZXQgTG9jVVJJIG5vZGUgZm91bmQiKTsKKwkJcmV0dXJuIERNX1JFU1BfQkFEX1JFUVVFU1Q7CisJfQorCWxvY3VyaSA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVGFyZ2V0IExvY1VSSTogJXMiLCBsb2N1cmkpOworCWlmIChvc19zdHJuY2FzZWNtcChsb2N1cmksICIuL1dpLUZpLyIsIDgpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuc3VwcG9ydGVkIEFkZCBUYXJnZXQgTG9jVVJJIik7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGxvY3VyaSk7CisJCXJldHVybiBETV9SRVNQX1BFUk1JU1NJT05fREVOSUVEOworCX0KKworCW5vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgYWRkLCAiSXRlbS9EYXRhIik7CisJaWYgKG5vZGUgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gRGF0YSBub2RlIGZvdW5kIik7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGxvY3VyaSk7CisJCXJldHVybiBETV9SRVNQX0JBRF9SRVFVRVNUOworCX0KKworCWlmIChwcHNfZm5hbWUgJiYgb3NfZmlsZV9leGlzdHMocHBzX2ZuYW1lKSkgeworCQlyZXQgPSBvbWFfZG1fcnVuX2FkZChjdHgsIGxvY3VyaSwgYWRkLCBwcHMsIHBwc19mbmFtZSk7CisJCWlmIChyZXQgIT0gRE1fUkVTUF9PSykgeworCQkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgbG9jdXJpKTsKKwkJCXJldHVybiByZXQ7CisJCX0KKwkJcmV0ID0gMDsKKwkJb3Nfc3RybGNweShmbmFtZSwgcHBzX2ZuYW1lLCBzaXplb2YoZm5hbWUpKTsKKwl9IGVsc2UKKwkJcmV0ID0gaHMyMF9hZGRfcHBzX21vKGN0eCwgbG9jdXJpLCBub2RlLCBmbmFtZSwgc2l6ZW9mKGZuYW1lKSk7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgbG9jdXJpKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldCA9PSAtMiA/IERNX1JFU1BfQUxSRUFEWV9FWElTVFMgOgorCQkJRE1fUkVTUF9DT01NQU5EX0ZBSUxFRDsKKworCWlmIChjdHgtPm5vX3JlY29ubmVjdCA9PSAyKSB7CisJCW9zX3NucHJpbnRmKGN0eC0+cHBzX2ZuYW1lLCBzaXplb2YoY3R4LT5wcHNfZm5hbWUpLCAiJXMiLAorCQkJICAgIGZuYW1lKTsKKwkJY3R4LT5wcHNfY3JlZF9zZXQgPSAxOworCQlyZXR1cm4gRE1fUkVTUF9PSzsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXBkYXRpbmcgd3BhX3N1cHBsaWNhbnQgY3JlZGVudGlhbHMiKTsKKwljbWRfc2V0X3BwcyhjdHgsIGZuYW1lKTsKKworCWlmIChjdHgtPm5vX3JlY29ubmVjdCkKKwkJcmV0dXJuIERNX1JFU1BfT0s7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVxdWVzdGluZyByZWNvbm5lY3Rpb24gd2l0aCB1cGRhdGVkIGNvbmZpZ3VyYXRpb24iKTsKKwlpZiAod3BhX2NvbW1hbmQoY3R4LT5pZm5hbWUsICJJTlRFUldPUktJTkdfU0VMRUNUIGF1dG8iKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gcmVxdWVzdCB3cGFfc3VwcGxpY2FudCB0byByZWNvbm5lY3QiKTsKKworCXJldHVybiBETV9SRVNQX09LOworfQorCisKK3N0YXRpYyBpbnQgb21hX2RtX3JlcGxhY2Uoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpyZXBsYWNlLAorCQkJICB4bWxfbm9kZV90ICpwcHMsIGNvbnN0IGNoYXIgKnBwc19mbmFtZSkKK3sKKwljaGFyICpsb2N1cmksICpwb3M7CisJc2l6ZV90IGZxZG5fbGVuOworCXhtbF9ub2RlX3QgKm5vZGUsICp0bmRzLCAqdW5vZGUsICpwcHNfbm9kZSwgKnBhcmVudDsKKwljaGFyICpkYXRhOworCWludCB1c2VfdG5kcyA9IDA7CisKKwlsb2N1cmkgPSBvbWFfZG1fZ2V0X3RhcmdldF9sb2N1cmkoY3R4LCByZXBsYWNlKTsKKwlpZiAobG9jdXJpID09IE5VTEwpCisJCXJldHVybiBETV9SRVNQX0JBRF9SRVFVRVNUOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlcGxhY2UgY29tbWFuZCB0YXJnZXQgTG9jVVJJOiAlcyIsIGxvY3VyaSk7CisJaWYgKG9zX3N0cm5jYXNlY21wKGxvY3VyaSwgIi4vV2ktRmkvIiwgOCkgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRG8gbm90IGFsbG93IFJlcGxhY2Ugb3V0c2lkZSAuL1dpLUZpIik7CisJCW9zX2ZyZWUobG9jdXJpKTsKKwkJcmV0dXJuIERNX1JFU1BfUEVSTUlTU0lPTl9ERU5JRUQ7CisJfQorCXBvcyA9IGxvY3VyaSArIDg7CisKKwlpZiAoY3R4LT5mcWRuID09IE5VTEwpIHsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9DT01NQU5EX0ZBSUxFRDsKKwl9CisJZnFkbl9sZW4gPSBvc19zdHJsZW4oY3R4LT5mcWRuKTsKKwlpZiAob3Nfc3RybmNhc2VjbXAocG9zLCBjdHgtPmZxZG4sIGZxZG5fbGVuKSAhPSAwIHx8CisJICAgIHBvc1tmcWRuX2xlbl0gIT0gJy8nKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJEbyBub3QgYWxsb3cgUmVwbGFjZSBvdXRzaWRlIC4vV2ktRmkvJXMiLAorCQkJICAgY3R4LT5mcWRuKTsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9QRVJNSVNTSU9OX0RFTklFRDsKKwl9CisJcG9zICs9IGZxZG5fbGVuICsgMTsKKworCWlmIChvc19zdHJuY2FzZWNtcChwb3MsICJQZXJQcm92aWRlclN1YnNjcmlwdGlvbi8iLCAyNCkgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLAorCQkJICAgIkRvIG5vdCBhbGxvdyBSZXBsYWNlIG91dHNpZGUgLi9XaS1GaS8lcy9QZXJQcm92aWRlclN1YnNjcmlwdGlvbiIsCisJCQkgICBjdHgtPmZxZG4pOworCQlvc19mcmVlKGxvY3VyaSk7CisJCXJldHVybiBETV9SRVNQX1BFUk1JU1NJT05fREVOSUVEOworCX0KKwlwb3MgKz0gMjQ7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVwbGFjZSBjb21tYW5kIGZvciBQUFMgbm9kZSAlcyIsIHBvcyk7CisKKwlwcHNfbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBwcHMsIHBvcyk7CisJaWYgKHBwc19ub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNwZWNpZmllZCBQUFMgbm9kZSBub3QgZm91bmQiKTsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9OT1RfRk9VTkQ7CisJfQorCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCByZXBsYWNlLCAiSXRlbS9NZXRhL1R5cGUiKTsKKwlpZiAobm9kZSkgeworCQljaGFyICp0eXBlOworCQl0eXBlID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCQl1c2VfdG5kcyA9IG5vZGUgJiYKKwkJCW9zX3N0cnN0cih0eXBlLCAiYXBwbGljYXRpb24vdm5kLnN5bmNtbC5kbXRuZHMreG1sIik7CisJfQorCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCByZXBsYWNlLCAiSXRlbS9EYXRhIik7CisJaWYgKG5vZGUgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gUmVwbGFjZS9JdGVtL0RhdGEgZm91bmQiKTsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9CQURfUkVRVUVTVDsKKwl9CisKKwlkYXRhID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChkYXRhID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBnZXQgUmVwbGFjZS9JdGVtL0RhdGEgdGV4dCIpOworCQlvc19mcmVlKGxvY3VyaSk7CisJCXJldHVybiBETV9SRVNQX0JBRF9SRVFVRVNUOworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUmVwbGFjZS9JdGVtL0RhdGE6ICVzIiwgZGF0YSk7CisKKwlpZiAodXNlX3RuZHMpIHsKKwkJdG5kcyA9IHhtbF9ub2RlX2Zyb21fYnVmKGN0eC0+eG1sLCBkYXRhKTsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgZGF0YSk7CisJCWlmICh0bmRzID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkJICAgIkNvdWxkIG5vdCBwYXJzZSBSZXBsYWNlL0l0ZW0vRGF0YSB0ZXh0Iik7CisJCQlvc19mcmVlKGxvY3VyaSk7CisJCQlyZXR1cm4gRE1fUkVTUF9CQURfUkVRVUVTVDsKKwkJfQorCisJCXVub2RlID0gdG5kc190b19tbyhjdHgtPnhtbCwgdG5kcyk7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHRuZHMpOworCQlpZiAodW5vZGUgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBwYXJzZSBUTkRTIHRleHQiKTsKKwkJCW9zX2ZyZWUobG9jdXJpKTsKKwkJCXJldHVybiBETV9SRVNQX0JBRF9SRVFVRVNUOworCQl9CisKKwkJZGVidWdfZHVtcF9ub2RlKGN0eCwgIlBhcnNlZCBUTkRTIiwgdW5vZGUpOworCisJCXBhcmVudCA9IHhtbF9ub2RlX2dldF9wYXJlbnQoY3R4LT54bWwsIHBwc19ub2RlKTsKKwkJeG1sX25vZGVfZGV0YWNoKGN0eC0+eG1sLCBwcHNfbm9kZSk7CisJCXhtbF9ub2RlX2FkZF9jaGlsZChjdHgtPnhtbCwgcGFyZW50LCB1bm9kZSk7CisJfSBlbHNlIHsKKwkJeG1sX25vZGVfc2V0X3RleHQoY3R4LT54bWwsIHBwc19ub2RlLCBkYXRhKTsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgZGF0YSk7CisJfQorCisJb3NfZnJlZShsb2N1cmkpOworCisJaWYgKHVwZGF0ZV9wcHNfZmlsZShjdHgsIHBwc19mbmFtZSwgcHBzKSA8IDApCisJCXJldHVybiBETV9SRVNQX0NPTU1BTkRfRkFJTEVEOworCisJY3R4LT5wcHNfdXBkYXRlZCA9IDE7CisKKwlyZXR1cm4gRE1fUkVTUF9PSzsKK30KKworCitzdGF0aWMgaW50IG9tYV9kbV9nZXQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpnZXQsCisJCSAgICAgIHhtbF9ub2RlX3QgKnBwcywgY29uc3QgY2hhciAqcHBzX2ZuYW1lLCBjaGFyICoqdmFsdWUpCit7CisJY2hhciAqbG9jdXJpLCAqcG9zOworCXNpemVfdCBmcWRuX2xlbjsKKwl4bWxfbm9kZV90ICpwcHNfbm9kZTsKKwljb25zdCBjaGFyICpuYW1lOworCisJKnZhbHVlID0gTlVMTDsKKworCWxvY3VyaSA9IG9tYV9kbV9nZXRfdGFyZ2V0X2xvY3VyaShjdHgsIGdldCk7CisJaWYgKGxvY3VyaSA9PSBOVUxMKQorCQlyZXR1cm4gRE1fUkVTUF9CQURfUkVRVUVTVDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJHZXQgY29tbWFuZCB0YXJnZXQgTG9jVVJJOiAlcyIsIGxvY3VyaSk7CisJaWYgKG9zX3N0cm5jYXNlY21wKGxvY3VyaSwgIi4vV2ktRmkvIiwgOCkgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRG8gbm90IGFsbG93IEdldCBvdXRzaWRlIC4vV2ktRmkiKTsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9QRVJNSVNTSU9OX0RFTklFRDsKKwl9CisJcG9zID0gbG9jdXJpICsgODsKKworCWlmIChjdHgtPmZxZG4gPT0gTlVMTCkKKwkJcmV0dXJuIERNX1JFU1BfQ09NTUFORF9GQUlMRUQ7CisJZnFkbl9sZW4gPSBvc19zdHJsZW4oY3R4LT5mcWRuKTsKKwlpZiAob3Nfc3RybmNhc2VjbXAocG9zLCBjdHgtPmZxZG4sIGZxZG5fbGVuKSAhPSAwIHx8CisJICAgIHBvc1tmcWRuX2xlbl0gIT0gJy8nKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJEbyBub3QgYWxsb3cgR2V0IG91dHNpZGUgLi9XaS1GaS8lcyIsCisJCQkgICBjdHgtPmZxZG4pOworCQlvc19mcmVlKGxvY3VyaSk7CisJCXJldHVybiBETV9SRVNQX1BFUk1JU1NJT05fREVOSUVEOworCX0KKwlwb3MgKz0gZnFkbl9sZW4gKyAxOworCisJaWYgKG9zX3N0cm5jYXNlY21wKHBvcywgIlBlclByb3ZpZGVyU3Vic2NyaXB0aW9uLyIsIDI0KSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkgICAiRG8gbm90IGFsbG93IEdldCBvdXRzaWRlIC4vV2ktRmkvJXMvUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24iLAorCQkJICAgY3R4LT5mcWRuKTsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9QRVJNSVNTSU9OX0RFTklFRDsKKwl9CisJcG9zICs9IDI0OworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkdldCBjb21tYW5kIGZvciBQUFMgbm9kZSAlcyIsIHBvcyk7CisKKwlwcHNfbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBwcHMsIHBvcyk7CisJaWYgKHBwc19ub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNwZWNpZmllZCBQUFMgbm9kZSBub3QgZm91bmQiKTsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9OT1RfRk9VTkQ7CisJfQorCisJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIHBwc19ub2RlKTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiR2V0IGNvbW1hbmQgcmV0dXJuZWQgbm9kZSB3aXRoIG5hbWUgJyVzJyIsIG5hbWUpOworCWlmIChvc19zdHJjYXNlY21wKG5hbWUsICJQYXNzd29yZCIpID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkRvIG5vdCBhbGxvdyBHZXQgZm9yIFBhc3N3b3JkIG5vZGUiKTsKKwkJb3NfZnJlZShsb2N1cmkpOworCQlyZXR1cm4gRE1fUkVTUF9QRVJNSVNTSU9OX0RFTklFRDsKKwl9CisKKwkvKgorCSAqIFRPRE86IE5vIHN1cHBvcnQgZm9yIERNVE5EUywgc28gaWYgaW50ZXJpb3Igbm9kZSwgcmVwbHkgd2l0aCBhCisJICogbGlzdCBvZiBjaGlsZHJlbiBub2RlIG5hbWVzIGluIFJlc3VsdHMgZWxlbWVudC4gVGhlIGNoaWxkIGxpc3QgdHlwZSBpcworCSAqIGRlZmluZWQgaW4gW0RNVE5EXS4KKwkgKi8KKworCSp2YWx1ZSA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBwcHNfbm9kZSk7CisJaWYgKCp2YWx1ZSA9PSBOVUxMKQorCQlyZXR1cm4gRE1fUkVTUF9DT01NQU5EX0ZBSUxFRDsKKworCXJldHVybiBETV9SRVNQX09LOworfQorCisKK3N0YXRpYyBpbnQgb21hX2RtX2dldF9jbWRpZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJeG1sX25vZGVfdCAqY25vZGU7CisJY2hhciAqc3RyOworCWludCByZXQ7CisKKwljbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBub2RlLCAiQ21kSUQiKTsKKwlpZiAoY25vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisKKwlzdHIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgY25vZGUpOworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisJcmV0ID0gYXRvaShzdHIpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHN0cik7CisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIG9tYV9kbV9zZW5kX3JlY3Yoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCSAgICAgY29uc3QgY2hhciAqdXJsLCB4bWxfbm9kZV90ICpzeW5jbWwsCisJCQkJICAgICBjb25zdCBjaGFyICpleHRfaGRyLAorCQkJCSAgICAgY29uc3QgY2hhciAqdXNlcm5hbWUsIGNvbnN0IGNoYXIgKnBhc3N3b3JkLAorCQkJCSAgICAgY29uc3QgY2hhciAqY2xpZW50X2NlcnQsCisJCQkJICAgICBjb25zdCBjaGFyICpjbGllbnRfa2V5KQoreworCXhtbF9ub2RlX3QgKnJlc3A7CisJY2hhciAqc3RyLCAqcmVzOworCWNoYXIgKnJlc3BfdXJpID0gTlVMTDsKKworCXN0ciA9IHhtbF9ub2RlX3RvX3N0cihjdHgtPnhtbCwgc3luY21sKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBzeW5jbWwpOworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU2VuZCBPTUEgRE0gUGFja2FnZSIpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiU2VuZCBPTUEgRE0gUGFja2FnZSIpOworCW9zX2ZyZWUoY3R4LT5zZXJ2ZXJfdXJsKTsKKwljdHgtPnNlcnZlcl91cmwgPSBvc19zdHJkdXAodXJsKTsKKwlyZXMgPSBodHRwX3Bvc3QoY3R4LT5odHRwLCB1cmwsIHN0ciwgImFwcGxpY2F0aW9uL3ZuZC5zeW5jbWwuZG0reG1sIiwKKwkJCWV4dF9oZHIsIGN0eC0+Y2FfZm5hbWUsIHVzZXJuYW1lLCBwYXNzd29yZCwKKwkJCWNsaWVudF9jZXJ0LCBjbGllbnRfa2V5LCBOVUxMKTsKKwlvc19mcmVlKHN0cik7CisJb3NfZnJlZShyZXNwX3VyaSk7CisJcmVzcF91cmkgPSBOVUxMOworCisJaWYgKHJlcyA9PSBOVUxMKSB7CisJCWNvbnN0IGNoYXIgKmVyciA9IGh0dHBfZ2V0X2VycihjdHgtPmh0dHApOworCQlpZiAoZXJyKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSFRUUCBlcnJvcjogJXMiLCBlcnIpOworCQkJd3JpdGVfcmVzdWx0KGN0eCwgIkhUVFAgZXJyb3I6ICVzIiwgZXJyKTsKKwkJfSBlbHNlIHsKKwkJCXdyaXRlX3N1bW1hcnkoY3R4LCAiRmFpbGVkIHRvIHNlbmQgT01BIERNIFBhY2thZ2UiKTsKKwkJfQorCQlyZXR1cm4gTlVMTDsKKwl9CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTZXJ2ZXIgcmVzcG9uc2U6ICVzIiwgcmVzKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJQcm9jZXNzIE9NQSBETSBQYWNrYWdlIik7CisJd3JpdGVfc3VtbWFyeShjdHgsICJQcm9jZXNzIHJlY2VpdmVkIE9NQSBETSBQYWNrYWdlIik7CisJcmVzcCA9IHhtbF9ub2RlX2Zyb21fYnVmKGN0eC0+eG1sLCByZXMpOworCW9zX2ZyZWUocmVzKTsKKwlpZiAocmVzcCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gcGFyc2UgT01BIERNIHJlc3BvbnNlIik7CisJCXJldHVybiBOVUxMOworCX0KKworCWRlYnVnX2R1bXBfbm9kZShjdHgsICJPTUEgRE0gUGFja2FnZSIsIHJlc3ApOworCisJcmV0dXJuIHJlc3A7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBvbWFfZG1fcHJvY2VzcyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnVybCwKKwkJCQkgICB4bWxfbm9kZV90ICpyZXNwLCBpbnQgbXNnaWQsCisJCQkJICAgY2hhciAqKnJldF9yZXNwX3VyaSwKKwkJCQkgICB4bWxfbm9kZV90ICpwcHMsIGNvbnN0IGNoYXIgKnBwc19mbmFtZSkKK3sKKwl4bWxfbm9kZV90ICpzeW5jbWwsICpzeW5jYm9keSwgKmhkciwgKmJvZHksICpjaGlsZDsKKwljb25zdCBjaGFyICpuYW1lOworCWNoYXIgKnJlc3BfdXJpID0gTlVMTDsKKwlpbnQgc2VydmVyX21zZ2lkID0gMDsKKwlpbnQgY21kaWQgPSAwOworCWludCBzZXJ2ZXJfY21kaWQ7CisJaW50IHJlc3BfbmVlZGVkID0gMDsKKwljaGFyICp0bXA7CisJaW50IGZpbmFsID0gMDsKKwljaGFyICpsb2N1cmk7CisKKwkqcmV0X3Jlc3BfdXJpID0gTlVMTDsKKworCW5hbWUgPSB4bWxfbm9kZV9nZXRfbG9jYWxuYW1lKGN0eC0+eG1sLCByZXNwKTsKKwlpZiAobmFtZSA9PSBOVUxMIHx8IG9zX3N0cmNhc2VjbXAobmFtZSwgIlN5bmNNTCIpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlN5bmNNTCBub2RlIG5vdCBmb3VuZCIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwloZHIgPSBnZXRfbm9kZShjdHgtPnhtbCwgcmVzcCwgIlN5bmNIZHIiKTsKKwlib2R5ID0gZ2V0X25vZGUoY3R4LT54bWwsIHJlc3AsICJTeW5jQm9keSIpOworCWlmIChoZHIgPT0gTlVMTCB8fCBib2R5ID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBmaW5kIFN5bmNIZHIgb3IgU3luY0JvZHkiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LT54bWwsIGNoaWxkLCBoZHIpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIGNoaWxkKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlN5bmNIZHIgJXMiLCBuYW1lKTsKKwkJaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlJlc3BVUkkiKSA9PSAwKSB7CisJCQl0bXAgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgY2hpbGQpOworCQkJaWYgKHRtcCkKKwkJCQlyZXNwX3VyaSA9IG9zX3N0cmR1cCh0bXApOworCQkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgdG1wKTsKKwkJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJNc2dJRCIpID09IDApIHsKKwkJCXRtcCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBjaGlsZCk7CisJCQlpZiAodG1wKQorCQkJCXNlcnZlcl9tc2dpZCA9IGF0b2kodG1wKTsKKwkJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHRtcCk7CisJCX0KKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU2VydmVyIE1zZ0lEOiAlZCIsIHNlcnZlcl9tc2dpZCk7CisJaWYgKHJlc3BfdXJpKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVzcFVSSTogJXMiLCByZXNwX3VyaSk7CisKKwlzeW5jbWwgPSBvbWFfZG1fYnVpbGRfaGRyKGN0eCwgcmVzcF91cmkgPyByZXNwX3VyaSA6IHVybCwgbXNnaWQpOworCWlmIChzeW5jbWwgPT0gTlVMTCkgeworCQlvc19mcmVlKHJlc3BfdXJpKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJc3luY2JvZHkgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHN5bmNtbCwgTlVMTCwgIlN5bmNCb2R5Iik7CisJY21kaWQrKzsKKwlhZGRfc3RhdHVzKGN0eCwgc3luY2JvZHksIHNlcnZlcl9tc2dpZCwgMCwgY21kaWQsICJTeW5jSGRyIiwKKwkJICAgRE1fUkVTUF9BVVRIX0FDQ0VQVEVELCBOVUxMKTsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgYm9keSkgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgtPnhtbCwgY2hpbGQpOworCQlzZXJ2ZXJfY21kaWQgPSBvbWFfZG1fZ2V0X2NtZGlkKGN0eCwgY2hpbGQpOworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgY2hpbGQpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU3luY0JvZHkgQ21kSUQ9JWQgLSAlcyIsCisJCQkgICBzZXJ2ZXJfY21kaWQsIG5hbWUpOworCQlpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiRXhlYyIpID09IDApIHsKKwkJCWludCByZXMgPSBvbWFfZG1fZXhlYyhjdHgsIGNoaWxkKTsKKwkJCWNtZGlkKys7CisJCQlsb2N1cmkgPSBvbWFfZG1fZ2V0X3RhcmdldF9sb2N1cmkoY3R4LCBjaGlsZCk7CisJCQlpZiAobG9jdXJpID09IE5VTEwpCisJCQkJcmVzID0gRE1fUkVTUF9CQURfUkVRVUVTVDsKKwkJCWFkZF9zdGF0dXMoY3R4LCBzeW5jYm9keSwgc2VydmVyX21zZ2lkLCBzZXJ2ZXJfY21kaWQsCisJCQkJICAgY21kaWQsIG5hbWUsIHJlcywgbG9jdXJpKTsKKwkJCW9zX2ZyZWUobG9jdXJpKTsKKwkJCXJlc3BfbmVlZGVkID0gMTsKKwkJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJBZGQiKSA9PSAwKSB7CisJCQlpbnQgcmVzID0gb21hX2RtX2FkZChjdHgsIGNoaWxkLCBwcHMsIHBwc19mbmFtZSk7CisJCQljbWRpZCsrOworCQkJbG9jdXJpID0gb21hX2RtX2dldF90YXJnZXRfbG9jdXJpKGN0eCwgY2hpbGQpOworCQkJaWYgKGxvY3VyaSA9PSBOVUxMKQorCQkJCXJlcyA9IERNX1JFU1BfQkFEX1JFUVVFU1Q7CisJCQlhZGRfc3RhdHVzKGN0eCwgc3luY2JvZHksIHNlcnZlcl9tc2dpZCwgc2VydmVyX2NtZGlkLAorCQkJCSAgIGNtZGlkLCBuYW1lLCByZXMsIGxvY3VyaSk7CisJCQlvc19mcmVlKGxvY3VyaSk7CisJCQlyZXNwX25lZWRlZCA9IDE7CisJCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiUmVwbGFjZSIpID09IDApIHsKKwkJCWludCByZXM7CisJCQlyZXMgPSBvbWFfZG1fcmVwbGFjZShjdHgsIGNoaWxkLCBwcHMsIHBwc19mbmFtZSk7CisJCQljbWRpZCsrOworCQkJbG9jdXJpID0gb21hX2RtX2dldF90YXJnZXRfbG9jdXJpKGN0eCwgY2hpbGQpOworCQkJaWYgKGxvY3VyaSA9PSBOVUxMKQorCQkJCXJlcyA9IERNX1JFU1BfQkFEX1JFUVVFU1Q7CisJCQlhZGRfc3RhdHVzKGN0eCwgc3luY2JvZHksIHNlcnZlcl9tc2dpZCwgc2VydmVyX2NtZGlkLAorCQkJCSAgIGNtZGlkLCBuYW1lLCByZXMsIGxvY3VyaSk7CisJCQlvc19mcmVlKGxvY3VyaSk7CisJCQlyZXNwX25lZWRlZCA9IDE7CisJCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiU3RhdHVzIikgPT0gMCkgeworCQkJLyogVE9ETzogVmVyaWZ5IHN1Y2Nlc3MgKi8KKwkJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJHZXQiKSA9PSAwKSB7CisJCQlpbnQgcmVzOworCQkJY2hhciAqdmFsdWU7CisJCQlyZXMgPSBvbWFfZG1fZ2V0KGN0eCwgY2hpbGQsIHBwcywgcHBzX2ZuYW1lLCAmdmFsdWUpOworCQkJY21kaWQrKzsKKwkJCWxvY3VyaSA9IG9tYV9kbV9nZXRfdGFyZ2V0X2xvY3VyaShjdHgsIGNoaWxkKTsKKwkJCWlmIChsb2N1cmkgPT0gTlVMTCkKKwkJCQlyZXMgPSBETV9SRVNQX0JBRF9SRVFVRVNUOworCQkJYWRkX3N0YXR1cyhjdHgsIHN5bmNib2R5LCBzZXJ2ZXJfbXNnaWQsIHNlcnZlcl9jbWRpZCwKKwkJCQkgICBjbWRpZCwgbmFtZSwgcmVzLCBsb2N1cmkpOworCQkJaWYgKHJlcyA9PSBETV9SRVNQX09LICYmIHZhbHVlKSB7CisJCQkJY21kaWQrKzsKKwkJCQlhZGRfcmVzdWx0cyhjdHgsIHN5bmNib2R5LCBzZXJ2ZXJfbXNnaWQsCisJCQkJCSAgICBzZXJ2ZXJfY21kaWQsIGNtZGlkLCBsb2N1cmksIHZhbHVlKTsKKwkJCX0KKwkJCW9zX2ZyZWUobG9jdXJpKTsKKwkJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHZhbHVlKTsKKwkJCXJlc3BfbmVlZGVkID0gMTsKKyNpZiAwIC8qIFRPRE86IE1VU1Qgc3VwcG9ydCAqLworCQl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIkRlbGV0ZSIpID09IDApIHsKKyNlbmRpZgorI2lmIDAgLyogVE9ETzogTVVTVCBzdXBwb3J0ICovCisJCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiU2VxdWVuY2UiKSA9PSAwKSB7CisjZW5kaWYKKwkJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJGaW5hbCIpID09IDApIHsKKwkJCWZpbmFsID0gMTsKKwkJCWJyZWFrOworCQl9IGVsc2UgeworCQkJbG9jdXJpID0gb21hX2RtX2dldF90YXJnZXRfbG9jdXJpKGN0eCwgY2hpbGQpOworCQkJYWRkX3N0YXR1cyhjdHgsIHN5bmNib2R5LCBzZXJ2ZXJfbXNnaWQsIHNlcnZlcl9jbWRpZCwKKwkJCQkgICBjbWRpZCwgbmFtZSwgRE1fUkVTUF9DT01NQU5EX05PVF9JTVBMRU1FTlRFRCwKKwkJCQkgICBsb2N1cmkpOworCQkJb3NfZnJlZShsb2N1cmkpOworCQkJcmVzcF9uZWVkZWQgPSAxOworCQl9CisJfQorCisJaWYgKCFmaW5hbCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmluYWwgbm9kZSBub3QgZm91bmQiKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgc3luY21sKTsKKwkJb3NfZnJlZShyZXNwX3VyaSk7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmICghcmVzcF9uZWVkZWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkV4Y2hhbmdlIGNvbXBsZXRlZCAtIG5vIHJlc3BvbnNlIG5lZWRlZCIpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBzeW5jbWwpOworCQlvc19mcmVlKHJlc3BfdXJpKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJeG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBzeW5jYm9keSwgTlVMTCwgIkZpbmFsIik7CisKKwlkZWJ1Z19kdW1wX25vZGUoY3R4LCAiT01BLURNIFBhY2thZ2UgMyIsIHN5bmNtbCk7CisKKwkqcmV0X3Jlc3BfdXJpID0gcmVzcF91cmk7CisJcmV0dXJuIHN5bmNtbDsKK30KKworCitpbnQgY21kX29tYV9kbV9wcm92KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqdXJsKQoreworCXhtbF9ub2RlX3QgKnN5bmNtbCwgKnJlc3A7CisJY2hhciAqcmVzcF91cmkgPSBOVUxMOworCWludCBtc2dpZCA9IDA7CisKKwlpZiAodXJsID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgcHJvdiBjb21tYW5kIChtaXNzaW5nIFVSTCkiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXdwYV9wcmludGYoTVNHX0lORk8sICJPTUEtRE0gY3JlZGVudGlhbCBwcm92aXNpb25pbmcgcmVxdWVzdGVkIik7CisJd3JpdGVfc3VtbWFyeShjdHgsICJPTUEtRE0gY3JlZGVudGlhbCBwcm92aXNpb25pbmciKTsKKworCW1zZ2lkKys7CisJc3luY21sID0gYnVpbGRfb21hX2RtXzFfc3ViX3JlZyhjdHgsIHVybCwgbXNnaWQpOworCWlmIChzeW5jbWwgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJd2hpbGUgKHN5bmNtbCkgeworCQlyZXNwID0gb21hX2RtX3NlbmRfcmVjdihjdHgsIHJlc3BfdXJpID8gcmVzcF91cmkgOiB1cmwsCisJCQkJCXN5bmNtbCwgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCk7CisJCWlmIChyZXNwID09IE5VTEwpCisJCQlyZXR1cm4gLTE7CisKKwkJbXNnaWQrKzsKKwkJc3luY21sID0gb21hX2RtX3Byb2Nlc3MoY3R4LCB1cmwsIHJlc3AsIG1zZ2lkLCAmcmVzcF91cmksCisJCQkJCU5VTEwsIE5VTEwpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCByZXNwKTsKKwl9CisKKwlvc19mcmVlKHJlc3BfdXJpKTsKKworCXJldHVybiBjdHgtPnBwc19jcmVkX3NldCA/IDAgOiAtMTsKK30KKworCitpbnQgY21kX29tYV9kbV9zaW1fcHJvdihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnVybCkKK3sKKwl4bWxfbm9kZV90ICpzeW5jbWwsICpyZXNwOworCWNoYXIgKnJlc3BfdXJpID0gTlVMTDsKKwlpbnQgbXNnaWQgPSAwOworCisJaWYgKHVybCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbnZhbGlkIHByb3YgY29tbWFuZCAobWlzc2luZyBVUkwpIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiT01BLURNIFNJTSBwcm92aXNpb25pbmcgcmVxdWVzdGVkIik7CisJY3R4LT5ub19yZWNvbm5lY3QgPSAyOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIldhaXQgZm9yIElQIGFkZHJlc3MgYmVmb3JlIHN0YXJ0aW5nIFNJTSBwcm92aXNpb25pbmciKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIldhaXQgZm9yIElQIGFkZHJlc3MgYmVmb3JlIHN0YXJ0aW5nIFNJTSBwcm92aXNpb25pbmciKTsKKworCWlmICh3YWl0X2lwX2FkZHIoY3R4LT5pZm5hbWUsIDE1KSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBnZXQgSVAgYWRkcmVzcyBmb3IgV0xBTiAtIHRyeSBjb25uZWN0aW9uIGFueXdheSIpOworCX0KKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIk9NQS1ETSBTSU0gcHJvdmlzaW9uaW5nIik7CisKKwltc2dpZCsrOworCXN5bmNtbCA9IGJ1aWxkX29tYV9kbV8xX3N1Yl9wcm92KGN0eCwgdXJsLCBtc2dpZCk7CisJaWYgKHN5bmNtbCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwl3aGlsZSAoc3luY21sKSB7CisJCXJlc3AgPSBvbWFfZG1fc2VuZF9yZWN2KGN0eCwgcmVzcF91cmkgPyByZXNwX3VyaSA6IHVybCwKKwkJCQkJc3luY21sLCBOVUxMLCBOVUxMLCBOVUxMLCBOVUxMLCBOVUxMKTsKKwkJaWYgKHJlc3AgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKworCQltc2dpZCsrOworCQlzeW5jbWwgPSBvbWFfZG1fcHJvY2VzcyhjdHgsIHVybCwgcmVzcCwgbXNnaWQsICZyZXNwX3VyaSwKKwkJCQkJTlVMTCwgTlVMTCk7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHJlc3ApOworCX0KKworCW9zX2ZyZWUocmVzcF91cmkpOworCisJaWYgKGN0eC0+cHBzX2NyZWRfc2V0KSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVcGRhdGluZyB3cGFfc3VwcGxpY2FudCBjcmVkZW50aWFscyIpOworCQljbWRfc2V0X3BwcyhjdHgsIGN0eC0+cHBzX2ZuYW1lKTsKKworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVxdWVzdGluZyByZWNvbm5lY3Rpb24gd2l0aCB1cGRhdGVkIGNvbmZpZ3VyYXRpb24iKTsKKwkJd3JpdGVfc3VtbWFyeShjdHgsICJSZXF1ZXN0aW5nIHJlY29ubmVjdGlvbiB3aXRoIHVwZGF0ZWQgY29uZmlndXJhdGlvbiIpOworCQlpZiAod3BhX2NvbW1hbmQoY3R4LT5pZm5hbWUsICJJTlRFUldPUktJTkdfU0VMRUNUIGF1dG8iKSA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gcmVxdWVzdCB3cGFfc3VwcGxpY2FudCB0byByZWNvbm5lY3QiKTsKKwkJCXdyaXRlX3N1bW1hcnkoY3R4LCAiRmFpbGVkIHRvIHJlcXVlc3Qgd3BhX3N1cHBsaWNhbnQgdG8gcmVjb25uZWN0Iik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlyZXR1cm4gY3R4LT5wcHNfY3JlZF9zZXQgPyAwIDogLTE7Cit9CisKKwordm9pZCBvbWFfZG1fcG9sX3VwZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKmFkZHJlc3MsCisJCSAgICBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCSAgICBjb25zdCBjaGFyICpjbGllbnRfY2VydCwgY29uc3QgY2hhciAqY2xpZW50X2tleSwKKwkJICAgIGNvbnN0IGNoYXIgKmNyZWRfdXNlcm5hbWUsIGNvbnN0IGNoYXIgKmNyZWRfcGFzc3dvcmQsCisJCSAgICB4bWxfbm9kZV90ICpwcHMpCit7CisJeG1sX25vZGVfdCAqc3luY21sLCAqcmVzcDsKKwljaGFyICpyZXNwX3VyaSA9IE5VTEw7CisJaW50IG1zZ2lkID0gMDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJPTUEtRE0gcG9saWN5IHVwZGF0ZSIpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiT01BLURNIHBvbGljeSB1cGRhdGUiKTsKKworCW1zZ2lkKys7CisJc3luY21sID0gYnVpbGRfb21hX2RtXzFfcG9sX3VwZChjdHgsIGFkZHJlc3MsIG1zZ2lkKTsKKwlpZiAoc3luY21sID09IE5VTEwpCisJCXJldHVybjsKKworCXdoaWxlIChzeW5jbWwpIHsKKwkJcmVzcCA9IG9tYV9kbV9zZW5kX3JlY3YoY3R4LCByZXNwX3VyaSA/IHJlc3BfdXJpIDogYWRkcmVzcywKKwkJCQkJc3luY21sLCBOVUxMLCBjcmVkX3VzZXJuYW1lLAorCQkJCQljcmVkX3Bhc3N3b3JkLCBjbGllbnRfY2VydCwgY2xpZW50X2tleSk7CisJCWlmIChyZXNwID09IE5VTEwpCisJCQlyZXR1cm47CisKKwkJbXNnaWQrKzsKKwkJc3luY21sID0gb21hX2RtX3Byb2Nlc3MoY3R4LCBhZGRyZXNzLCByZXNwLCBtc2dpZCwgJnJlc3BfdXJpLAorCQkJCQlwcHMsIHBwc19mbmFtZSk7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHJlc3ApOworCX0KKworCW9zX2ZyZWUocmVzcF91cmkpOworCisJaWYgKGN0eC0+cHBzX3VwZGF0ZWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVwZGF0ZSB3cGFfc3VwcGxpY2FudCBjcmVkZW50aWFsIGJhc2VkIG9uIHVwZGF0ZWQgUFBTIE1PIik7CisJCXdyaXRlX3N1bW1hcnkoY3R4LCAiVXBkYXRlIHdwYV9zdXBwbGljYW50IGNyZWRlbnRpYWwgYmFzZWQgb24gdXBkYXRlZCBQUFMgTU8gYW5kIHJlcXVlc3QgY29ubmVjdGlvbiIpOworCQljbWRfc2V0X3BwcyhjdHgsIHBwc19mbmFtZSk7CisJCWlmICh3cGFfY29tbWFuZChjdHgtPmlmbmFtZSwgIklOVEVSV09SS0lOR19TRUxFQ1QgYXV0byIpIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywKKwkJCQkgICAiRmFpbGVkIHRvIHJlcXVlc3Qgd3BhX3N1cHBsaWNhbnQgdG8gcmVjb25uZWN0Iik7CisJCQl3cml0ZV9zdW1tYXJ5KGN0eCwKKwkJCQkgICAgICAiRmFpbGVkIHRvIHJlcXVlc3Qgd3BhX3N1cHBsaWNhbnQgdG8gcmVjb25uZWN0Iik7CisJCX0KKwl9Cit9CisKKwordm9pZCBvbWFfZG1fc3ViX3JlbShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKmFkZHJlc3MsCisJCSAgICBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCSAgICBjb25zdCBjaGFyICpjbGllbnRfY2VydCwgY29uc3QgY2hhciAqY2xpZW50X2tleSwKKwkJICAgIGNvbnN0IGNoYXIgKmNyZWRfdXNlcm5hbWUsIGNvbnN0IGNoYXIgKmNyZWRfcGFzc3dvcmQsCisJCSAgICB4bWxfbm9kZV90ICpwcHMpCit7CisJeG1sX25vZGVfdCAqc3luY21sLCAqcmVzcDsKKwljaGFyICpyZXNwX3VyaSA9IE5VTEw7CisJaW50IG1zZ2lkID0gMDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJPTUEtRE0gc3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIik7CisJd3JpdGVfc3VtbWFyeShjdHgsICJPTUEtRE0gc3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIik7CisKKwltc2dpZCsrOworCXN5bmNtbCA9IGJ1aWxkX29tYV9kbV8xX3N1Yl9yZW0oY3R4LCBhZGRyZXNzLCBtc2dpZCk7CisJaWYgKHN5bmNtbCA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl3aGlsZSAoc3luY21sKSB7CisJCXJlc3AgPSBvbWFfZG1fc2VuZF9yZWN2KGN0eCwgcmVzcF91cmkgPyByZXNwX3VyaSA6IGFkZHJlc3MsCisJCQkJCXN5bmNtbCwgTlVMTCwgY3JlZF91c2VybmFtZSwKKwkJCQkJY3JlZF9wYXNzd29yZCwgY2xpZW50X2NlcnQsIGNsaWVudF9rZXkpOworCQlpZiAocmVzcCA9PSBOVUxMKQorCQkJcmV0dXJuOworCisJCW1zZ2lkKys7CisJCXN5bmNtbCA9IG9tYV9kbV9wcm9jZXNzKGN0eCwgYWRkcmVzcywgcmVzcCwgbXNnaWQsICZyZXNwX3VyaSwKKwkJCQkJcHBzLCBwcHNfZm5hbWUpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCByZXNwKTsKKwl9CisKKwlvc19mcmVlKHJlc3BfdXJpKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJVcGRhdGUgd3BhX3N1cHBsaWNhbnQgY3JlZGVudGlhbCBiYXNlZCBvbiB1cGRhdGVkIFBQUyBNTyBhbmQgcmVxdWVzdCByZWNvbm5lY3Rpb24iKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIlVwZGF0ZSB3cGFfc3VwcGxpY2FudCBjcmVkZW50aWFsIGJhc2VkIG9uIHVwZGF0ZWQgUFBTIE1PIGFuZCByZXF1ZXN0IHJlY29ubmVjdGlvbiIpOworCWNtZF9zZXRfcHBzKGN0eCwgcHBzX2ZuYW1lKTsKKwlpZiAod3BhX2NvbW1hbmQoY3R4LT5pZm5hbWUsICJJTlRFUldPUktJTkdfU0VMRUNUIGF1dG8iKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byByZXF1ZXN0IHdwYV9zdXBwbGljYW50IHRvIHJlY29ubmVjdCIpOworCQl3cml0ZV9zdW1tYXJ5KGN0eCwgIkZhaWxlZCB0byByZXF1ZXN0IHdwYV9zdXBwbGljYW50IHRvIHJlY29ubmVjdCIpOworCX0KK30KKworCit2b2lkIGNtZF9vbWFfZG1fYWRkKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqcHBzX2ZuYW1lLAorCQkgICAgY29uc3QgY2hhciAqYWRkX2ZuYW1lKQoreworCXhtbF9ub2RlX3QgKnBwcywgKmFkZDsKKwlpbnQgcmVzOworCisJY3R4LT5mcWRuID0gb3Nfc3RyZHVwKCJ3aS1maS5vcmciKTsKKworCXBwcyA9IG5vZGVfZnJvbV9maWxlKGN0eC0+eG1sLCBwcHNfZm5hbWUpOworCWlmIChwcHMgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUFBTIGZpbGUgJXMgY291bGQgbm90IGJlIHBhcnNlZCIsCisJCQkgICBwcHNfZm5hbWUpOworCQlyZXR1cm47CisJfQorCisJYWRkID0gbm9kZV9mcm9tX2ZpbGUoY3R4LT54bWwsIGFkZF9mbmFtZSk7CisJaWYgKGFkZCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJBZGQgZmlsZSAlcyBjb3VsZCBub3QgYmUgcGFyc2VkIiwKKwkJCSAgIGFkZF9mbmFtZSk7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7CisJCXJldHVybjsKKwl9CisKKwlyZXMgPSBvbWFfZG1fYWRkKGN0eCwgYWRkLCBwcHMsIHBwc19mbmFtZSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIm9tYV9kbV9hZGQgLS0+ICVkIiwgcmVzKTsKKworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgYWRkKTsKK30KKworCit2b2lkIGNtZF9vbWFfZG1fcmVwbGFjZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnBwc19mbmFtZSwKKwkJCWNvbnN0IGNoYXIgKnJlcGxhY2VfZm5hbWUpCit7CisJeG1sX25vZGVfdCAqcHBzLCAqcmVwbGFjZTsKKwlpbnQgcmVzOworCisJY3R4LT5mcWRuID0gb3Nfc3RyZHVwKCJ3aS1maS5vcmciKTsKKworCXBwcyA9IG5vZGVfZnJvbV9maWxlKGN0eC0+eG1sLCBwcHNfZm5hbWUpOworCWlmIChwcHMgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUFBTIGZpbGUgJXMgY291bGQgbm90IGJlIHBhcnNlZCIsCisJCQkgICBwcHNfZm5hbWUpOworCQlyZXR1cm47CisJfQorCisJcmVwbGFjZSA9IG5vZGVfZnJvbV9maWxlKGN0eC0+eG1sLCByZXBsYWNlX2ZuYW1lKTsKKwlpZiAocmVwbGFjZSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSZXBsYWNlIGZpbGUgJXMgY291bGQgbm90IGJlIHBhcnNlZCIsCisJCQkgICByZXBsYWNlX2ZuYW1lKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcHBzKTsKKwkJcmV0dXJuOworCX0KKworCXJlcyA9IG9tYV9kbV9yZXBsYWNlKGN0eCwgcmVwbGFjZSwgcHBzLCBwcHNfZm5hbWUpOworCXdwYV9wcmludGYoTVNHX0lORk8sICJvbWFfZG1fcmVwbGFjZSAtLT4gJWQiLCByZXMpOworCisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcHBzKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCByZXBsYWNlKTsKK30KZGlmZiAtLWdpdCBhL2hzMjAvY2xpZW50L29zdV9jbGllbnQuYyBiL2hzMjAvY2xpZW50L29zdV9jbGllbnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hNDM5YmRlCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9jbGllbnQvb3N1X2NsaWVudC5jCkBAIC0wLDAgKzEsMzIwMyBAQAorLyoKKyAqIEhvdHNwb3QgMi4wIE9TVSBjbGllbnQKKyAqIENvcHlyaWdodCAoYykgMjAxMi0yMDE0LCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKyNpbmNsdWRlIDx0aW1lLmg+CisjaW5jbHVkZSA8c3lzL3N0YXQuaD4KKworI2luY2x1ZGUgImNvbW1vbi5oIgorI2luY2x1ZGUgInV0aWxzL2Jyb3dzZXIuaCIKKyNpbmNsdWRlICJ1dGlscy9iYXNlNjQuaCIKKyNpbmNsdWRlICJ1dGlscy94bWwtdXRpbHMuaCIKKyNpbmNsdWRlICJ1dGlscy9odHRwLXV0aWxzLmgiCisjaW5jbHVkZSAiY29tbW9uL3dwYV9jdHJsLmgiCisjaW5jbHVkZSAiY29tbW9uL3dwYV9oZWxwZXJzLmgiCisjaW5jbHVkZSAiZWFwX2NvbW1vbi9lYXBfZGVmcy5oIgorI2luY2x1ZGUgImNyeXB0by9jcnlwdG8uaCIKKyNpbmNsdWRlICJjcnlwdG8vc2hhMjU2LmgiCisjaW5jbHVkZSAib3N1X2NsaWVudC5oIgorCisKK3ZvaWQgd3JpdGVfcmVzdWx0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqZm10LCAuLi4pCit7CisJdmFfbGlzdCBhcDsKKwlGSUxFICpmOworCWNoYXIgYnVmWzUwMF07CisKKwl2YV9zdGFydChhcCwgZm10KTsKKwl2c25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgZm10LCBhcCk7CisJdmFfZW5kKGFwKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIiVzIiwgYnVmKTsKKworCWlmICghY3R4LT5yZXN1bHRfZmlsZSkKKwkJcmV0dXJuOworCisJZiA9IGZvcGVuKGN0eC0+cmVzdWx0X2ZpbGUsICJ3Iik7CisJaWYgKGYgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJdmFfc3RhcnQoYXAsIGZtdCk7CisJdmZwcmludGYoZiwgZm10LCBhcCk7CisJdmFfZW5kKGFwKTsKKwlmcHJpbnRmKGYsICJcbiIpOworCWZjbG9zZShmKTsKK30KKworCit2b2lkIHdyaXRlX3N1bW1hcnkoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpmbXQsIC4uLikKK3sKKwl2YV9saXN0IGFwOworCUZJTEUgKmY7CisKKwlpZiAoIWN0eC0+c3VtbWFyeV9maWxlKQorCQlyZXR1cm47CisKKwlmID0gZm9wZW4oY3R4LT5zdW1tYXJ5X2ZpbGUsICJhIik7CisJaWYgKGYgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJdmFfc3RhcnQoYXAsIGZtdCk7CisJdmZwcmludGYoZiwgZm10LCBhcCk7CisJdmFfZW5kKGFwKTsKKwlmcHJpbnRmKGYsICJcbiIpOworCWZjbG9zZShmKTsKK30KKworCit2b2lkIGRlYnVnX2R1bXBfbm9kZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnRpdGxlLAorCQkgICAgIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyID0geG1sX25vZGVfdG9fc3RyKGN0eC0+eG1sLCBub2RlKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIltoczIwXSAlczogJyVzJyIsIHRpdGxlLCBzdHIpOworCWZyZWUoc3RyKTsKK30KKworCitzdGF0aWMgaW50IHZhbGlkX2ZxZG4oY29uc3QgY2hhciAqZnFkbikKK3sKKwljb25zdCBjaGFyICpwb3M7CisKKwkvKiBUT0RPOiBjb3VsZCBtYWtlIHRoaXMgbW9yZSBjb21wbGV0ZS4uICovCisJaWYgKHN0cmNocihmcWRuLCAnLicpID09IDAgfHwgc3RybGVuKGZxZG4pID4gMjU1KQorCQlyZXR1cm4gMDsKKwlmb3IgKHBvcyA9IGZxZG47ICpwb3M7IHBvcysrKSB7CisJCWlmICgqcG9zID49ICdhJyAmJiAqcG9zIDw9ICd6JykKKwkJCWNvbnRpbnVlOworCQlpZiAoKnBvcyA+PSAnQScgJiYgKnBvcyA8PSAnWicpCisJCQljb250aW51ZTsKKwkJaWYgKCpwb3MgPj0gJzAnICYmICpwb3MgPD0gJzknKQorCQkJY29udGludWU7CisJCWlmICgqcG9zID09ICctJyB8fCAqcG9zID09ICcuJyB8fCAqcG9zID09ICdfJykKKwkJCWNvbnRpbnVlOworCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDE7Cit9CisKKworaW50IG9zdV9nZXRfY2VydGlmaWNhdGUoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpnZXRjZXJ0KQoreworCXhtbF9ub2RlX3QgKm5vZGU7CisJY2hhciAqdXJsLCAqdXNlciA9IE5VTEwsICpwdyA9IE5VTEw7CisJY2hhciAqcHJvdG87CisJaW50IHJldCA9IC0xOworCisJcHJvdG8gPSB4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZShjdHgtPnhtbCwgZ2V0Y2VydCwKKwkJCQkJImVucm9sbG1lbnRQcm90b2NvbCIpOworCWlmICghcHJvdG8pCisJCXJldHVybiAtMTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiZ2V0Q2VydGlmaWNhdGUgLSBlbnJvbGxtZW50UHJvdG9jb2w9JXMiLCBwcm90byk7CisJd3JpdGVfc3VtbWFyeShjdHgsICJnZXRDZXJ0aWZpY2F0ZSAtIGVucm9sbG1lbnRQcm90b2NvbD0lcyIsIHByb3RvKTsKKwlpZiAob3Nfc3RyY2FzZWNtcChwcm90bywgIkVTVCIpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuc3VwcG9ydGVkIGVucm9sbG1lbnRQcm90b2NvbCIpOworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCBwcm90byk7CisJCXJldHVybiAtMTsKKwl9CisJeG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfZnJlZShjdHgtPnhtbCwgcHJvdG8pOworCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBnZXRjZXJ0LCAiZW5yb2xsbWVudFNlcnZlclVSSSIpOworCWlmIChub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBmaW5kIGVucm9sbG1lbnRTZXJ2ZXJVUkkgbm9kZSIpOworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCBwcm90byk7CisJCXJldHVybiAtMTsKKwl9CisJdXJsID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmICh1cmwgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGdldCBVUkwgdGV4dCIpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICJlbnJvbGxtZW50U2VydmVyVVJJOiAlcyIsIHVybCk7CisJd3JpdGVfc3VtbWFyeShjdHgsICJlbnJvbGxtZW50U2VydmVyVVJJOiAlcyIsIHVybCk7CisKKwlub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIGdldGNlcnQsICJlc3RVc2VySUQiKTsKKwlpZiAobm9kZSA9PSBOVUxMICYmICFjdHgtPmNsaWVudF9jZXJ0X3ByZXNlbnQpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBmaW5kIGVzdFVzZXJJRCBub2RlIik7CisJCWdvdG8gZmFpbDsKKwl9CisJaWYgKG5vZGUpIHsKKwkJdXNlciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwkJaWYgKHVzZXIgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBnZXQgZXN0VXNlcklEIHRleHQiKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiZXN0VXNlcklEOiAlcyIsIHVzZXIpOworCQl3cml0ZV9zdW1tYXJ5KGN0eCwgImVzdFVzZXJJRDogJXMiLCB1c2VyKTsKKwl9CisKKwlub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIGdldGNlcnQsICJlc3RQYXNzd29yZCIpOworCWlmIChub2RlID09IE5VTEwgJiYgIWN0eC0+Y2xpZW50X2NlcnRfcHJlc2VudCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGZpbmQgZXN0UGFzc3dvcmQgbm9kZSIpOworCQlnb3RvIGZhaWw7CisJfQorCWlmIChub2RlKSB7CisJCXB3ID0geG1sX25vZGVfZ2V0X2Jhc2U2NF90ZXh0KGN0eC0+eG1sLCBub2RlLCBOVUxMKTsKKwkJaWYgKHB3ID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgZ2V0IGVzdFBhc3N3b3JkIHRleHQiKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiZXN0UGFzc3dvcmQ6ICVzIiwgcHcpOworCX0KKworCW1rZGlyKCJDZXJ0IiwgU19JUldYVSk7CisJaWYgKGVzdF9sb2FkX2NhY2VydHMoY3R4LCB1cmwpIDwgMCB8fAorCSAgICBlc3RfYnVpbGRfY3NyKGN0eCwgdXJsKSA8IDAgfHwKKwkgICAgZXN0X3NpbXBsZV9lbnJvbGwoY3R4LCB1cmwsIHVzZXIsIHB3KSA8IDApCisJCWdvdG8gZmFpbDsKKworCXJldCA9IDA7CitmYWlsOgorCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHVybCk7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgdXNlcik7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgcHcpOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IHByb2Nlc3NfZXN0X2NlcnQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpjZXJ0LAorCQkJICAgIGNvbnN0IGNoYXIgKmZxZG4pCit7CisJdTggZGlnZXN0MVtTSEEyNTZfTUFDX0xFTl0sIGRpZ2VzdDJbU0hBMjU2X01BQ19MRU5dOworCWNoYXIgKmRlciwgKnBlbTsKKwlzaXplX3QgZGVyX2xlbiwgcGVtX2xlbjsKKwljaGFyICpmaW5nZXJwcmludDsKKwljaGFyIGJ1ZlsyMDBdOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBQUyBmb3IgY2VydGlmaWNhdGUgY3JlZGVudGlhbCAtIGZxZG49JXMiLCBmcWRuKTsKKworCWZpbmdlcnByaW50ID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIGNlcnQpOworCWlmIChmaW5nZXJwcmludCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJaWYgKGhleHN0cjJiaW4oZmluZ2VycHJpbnQsIGRpZ2VzdDEsIFNIQTI1Nl9NQUNfTEVOKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgU0hBMjU2IGhhc2ggdmFsdWUiKTsKKwkJd3JpdGVfcmVzdWx0KGN0eCwgIkludmFsaWQgY2xpZW50IGNlcnRpZmljYXRlIFNIQTI1NiBoYXNoIHZhbHVlIGluIFBQUyIpOworCQl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBmaW5nZXJwcmludCk7CisJCXJldHVybiAtMTsKKwl9CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgZmluZ2VycHJpbnQpOworCisJZGVyID0gb3NfcmVhZGZpbGUoIkNlcnQvZXN0X2NlcnQuZGVyIiwgJmRlcl9sZW4pOworCWlmIChkZXIgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGZpbmQgY2xpZW50IGNlcnRpZmljYXRlIGZyb20gRVNUIik7CisJCXdyaXRlX3Jlc3VsdChjdHgsICJDb3VsZCBub3QgZmluZCBjbGllbnQgY2VydGlmaWNhdGUgZnJvbSBFU1QiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChzaGEyNTZfdmVjdG9yKDEsIChjb25zdCB1OCAqKikgJmRlciwgJmRlcl9sZW4sIGRpZ2VzdDIpIDwgMCkgeworCQlvc19mcmVlKGRlcik7CisJCXJldHVybiAtMTsKKwl9CisJb3NfZnJlZShkZXIpOworCisJaWYgKG9zX21lbWNtcChkaWdlc3QxLCBkaWdlc3QyLCBzaXplb2YoZGlnZXN0MSkpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNsaWVudCBjZXJ0aWZpY2F0ZSBmcm9tIEVTVCBkb2VzIG5vdCBtYXRjaCBmaW5nZXJwcmludCBmcm9tIFBQUyBNTyIpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiQ2xpZW50IGNlcnRpZmljYXRlIGZyb20gRVNUIGRvZXMgbm90IG1hdGNoIGZpbmdlcnByaW50IGZyb20gUFBTIE1PIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ2xpZW50IGNlcnRpZmljYXRlIGZyb20gRVNUIG1hdGNoZXMgUFBTIE1PIik7CisJdW5saW5rKCJDZXJ0L2VzdF9jZXJ0LmRlciIpOworCisJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIlNQLyVzL2NsaWVudC1jYS5wZW0iLCBmcWRuKTsKKwlpZiAocmVuYW1lKCJDZXJ0L2VzdC1jYWNlcnRzLnBlbSIsIGJ1ZikgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgbW92ZSBlc3QtY2FjZXJ0cy5wZW0gdG8gY2xpZW50LWNhLnBlbTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKKwkJcmV0dXJuIC0xOworCX0KKwlwZW0gPSBvc19yZWFkZmlsZShidWYsICZwZW1fbGVuKTsKKworCW9zX3NucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTUC8lcy9jbGllbnQtY2VydC5wZW0iLCBmcWRuKTsKKwlpZiAocmVuYW1lKCJDZXJ0L2VzdF9jZXJ0LnBlbSIsIGJ1ZikgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgbW92ZSBlc3RfY2VydC5wZW0gdG8gY2xpZW50LWNlcnQucGVtOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOworCQlvc19mcmVlKHBlbSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAocGVtKSB7CisJCUZJTEUgKmYgPSBmb3BlbihidWYsICJhIik7CisJCWlmIChmKSB7CisJCQlmd3JpdGUocGVtLCBwZW1fbGVuLCAxLCBmKTsKKwkJCWZjbG9zZShmKTsKKwkJfQorCQlvc19mcmVlKHBlbSk7CisJfQorCisJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIlNQLyVzL2NsaWVudC1rZXkucGVtIiwgZnFkbik7CisJaWYgKHJlbmFtZSgiQ2VydC9wcml2a2V5LXBsYWluLnBlbSIsIGJ1ZikgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgbW92ZSBwcml2a2V5LXBsYWluLnBlbSB0byBjbGllbnQta2V5LnBlbTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXVubGluaygiQ2VydC9lc3QtcmVxLmI2NCIpOworCXVubGluaygiQ2VydC9lc3QtcmVxLnBlbSIpOworCXVubGluaygiQ2VydC9lc3QtcmVzcC5yYXciKTsKKwlybWRpcigiQ2VydCIpOworCisJcmV0dXJuIDA7Cit9CisKKworI2RlZmluZSBUTVBfQ0VSVF9ETF9GSUxFICJ0bXAtY2VydC1kb3dubG9hZCIKKworc3RhdGljIGludCBkb3dubG9hZF9jZXJ0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqcGFyYW1zLAorCQkJIGNvbnN0IGNoYXIgKmZuYW1lKQoreworCXhtbF9ub2RlX3QgKnVybF9ub2RlLCAqaGFzaF9ub2RlOworCWNoYXIgKnVybCwgKmhhc2g7CisJY2hhciAqY2VydDsKKwlzaXplX3QgbGVuOworCXU4IGRpZ2VzdDFbU0hBMjU2X01BQ19MRU5dLCBkaWdlc3QyW1NIQTI1Nl9NQUNfTEVOXTsKKwlpbnQgcmVzOworCXVuc2lnbmVkIGNoYXIgKmI2NDsKKwlGSUxFICpmOworCisJdXJsX25vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgcGFyYW1zLCAiQ2VydFVSTCIpOworCWhhc2hfbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBwYXJhbXMsICJDZXJ0U0hBMjU2RmluZ2VycHJpbnQiKTsKKwlpZiAodXJsX25vZGUgPT0gTlVMTCB8fCBoYXNoX25vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXVybCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCB1cmxfbm9kZSk7CisJaGFzaCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBoYXNoX25vZGUpOworCWlmICh1cmwgPT0gTlVMTCB8fCBoYXNoID09IE5VTEwpIHsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgdXJsKTsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgaGFzaCk7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ2VydFVSTDogJXMiLCB1cmwpOworCXdwYV9wcmludGYoTVNHX0lORk8sICJTSEEyNTYgaGFzaDogJXMiLCBoYXNoKTsKKworCWlmIChoZXhzdHIyYmluKGhhc2gsIGRpZ2VzdDEsIFNIQTI1Nl9NQUNfTEVOKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgU0hBMjU2IGhhc2ggdmFsdWUiKTsKKwkJd3JpdGVfcmVzdWx0KGN0eCwgIkludmFsaWQgU0hBMjU2IGhhc2ggdmFsdWUgZm9yIGRvd25sb2FkZWQgY2VydGlmaWNhdGUiKTsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgaGFzaCk7CisJCXJldHVybiAtMTsKKwl9CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgaGFzaCk7CisKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIkRvd25sb2FkIGNlcnRpZmljYXRlIGZyb20gJXMiLCB1cmwpOworCWN0eC0+bm9fb3N1X2NlcnRfdmFsaWRhdGlvbiA9IDE7CisJaHR0cF9vY3NwX3NldChjdHgtPmh0dHAsIDEpOworCXJlcyA9IGh0dHBfZG93bmxvYWRfZmlsZShjdHgtPmh0dHAsIHVybCwgVE1QX0NFUlRfRExfRklMRSwgTlVMTCk7CisJaHR0cF9vY3NwX3NldChjdHgtPmh0dHAsCisJCSAgICAgIChjdHgtPndvcmthcm91bmRzICYgV09SS0FST1VORF9PQ1NQX09QVElPTkFMKSA/IDEgOiAyKTsKKwljdHgtPm5vX29zdV9jZXJ0X3ZhbGlkYXRpb24gPSAwOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHVybCk7CisJaWYgKHJlcyA8IDApCisJCXJldHVybiAtMTsKKworCWNlcnQgPSBvc19yZWFkZmlsZShUTVBfQ0VSVF9ETF9GSUxFLCAmbGVuKTsKKwlyZW1vdmUoVE1QX0NFUlRfRExfRklMRSk7CisJaWYgKGNlcnQgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJaWYgKHNoYTI1Nl92ZWN0b3IoMSwgKGNvbnN0IHU4ICoqKSAmY2VydCwgJmxlbiwgZGlnZXN0MikgPCAwKSB7CisJCW9zX2ZyZWUoY2VydCk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAob3NfbWVtY21wKGRpZ2VzdDEsIGRpZ2VzdDIsIHNpemVvZihkaWdlc3QxKSkgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRG93bmxvYWRlZCBjZXJ0aWZpY2F0ZSBmaW5nZXJwcmludCBkaWQgbm90IG1hdGNoIik7CisJCXdyaXRlX3Jlc3VsdChjdHgsICJEb3dubG9hZGVkIGNlcnRpZmljYXRlIGZpbmdlcnByaW50IGRpZCBub3QgbWF0Y2giKTsKKwkJb3NfZnJlZShjZXJ0KTsKKwkJcmV0dXJuIC0xOworCX0KKworCWI2NCA9IGJhc2U2NF9lbmNvZGUoKHVuc2lnbmVkIGNoYXIgKikgY2VydCwgbGVuLCBOVUxMKTsKKwlvc19mcmVlKGNlcnQpOworCWlmIChiNjQgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJZiA9IGZvcGVuKGZuYW1lLCAid2IiKTsKKwlpZiAoZiA9PSBOVUxMKSB7CisJCW9zX2ZyZWUoYjY0KTsKKwkJcmV0dXJuIC0xOworCX0KKworCWZwcmludGYoZiwgIi0tLS0tQkVHSU4gQ0VSVElGSUNBVEUtLS0tLVxuIgorCQkiJXMiCisJCSItLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tXG4iLAorCQliNjQpOworCisJb3NfZnJlZShiNjQpOworCWZjbG9zZShmKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJEb3dubG9hZGVkIGNlcnRpZmljYXRlIGludG8gJXMgYW5kIHZhbGlkYXRlZCBmaW5nZXJwcmludCIsCisJCSAgIGZuYW1lKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIkRvd25sb2FkZWQgY2VydGlmaWNhdGUgaW50byAlcyBhbmQgdmFsaWRhdGVkIGZpbmdlcnByaW50IiwKKwkJICAgICAgZm5hbWUpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBjbWRfZGxfb3N1X2NhKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqcHBzX2ZuYW1lLAorCQkJIGNvbnN0IGNoYXIgKmNhX2ZuYW1lKQoreworCXhtbF9ub2RlX3QgKnBwcywgKm5vZGU7CisJaW50IHJldDsKKworCXBwcyA9IG5vZGVfZnJvbV9maWxlKGN0eC0+eG1sLCBwcHNfZm5hbWUpOworCWlmIChwcHMgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHJlYWQgb3IgcGFyc2UgJyVzJyIsIHBwc19mbmFtZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlub2RlID0gZ2V0X2NoaWxkX25vZGUoY3R4LT54bWwsIHBwcywKKwkJCSAgICAgICJTdWJzY3JpcHRpb25VcGRhdGUvVHJ1c3RSb290Iik7CisJaWYgKG5vZGUgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gU3Vic2NyaXB0aW9uVXBkYXRlL1RydXN0Um9vdC9DZXJ0VVJMIGZvdW5kIGZyb20gUFBTIik7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXQgPSBkb3dubG9hZF9jZXJ0KGN0eCwgbm9kZSwgY2FfZm5hbWUpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgY21kX2RsX3BvbHVwZF9jYShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnBwc19mbmFtZSwKKwkJCSAgICBjb25zdCBjaGFyICpjYV9mbmFtZSkKK3sKKwl4bWxfbm9kZV90ICpwcHMsICpub2RlOworCWludCByZXQ7CisKKwlwcHMgPSBub2RlX2Zyb21fZmlsZShjdHgtPnhtbCwgcHBzX2ZuYW1lKTsKKwlpZiAocHBzID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCByZWFkIG9yIHBhcnNlICclcyciLCBwcHNfZm5hbWUpOworCQlyZXR1cm4gLTE7CisJfQorCisJbm9kZSA9IGdldF9jaGlsZF9ub2RlKGN0eC0+eG1sLCBwcHMsCisJCQkgICAgICAiUG9saWN5VXBkYXRlL1RydXN0Um9vdCIpOworCWlmIChub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIFBvbGljeVVwZGF0ZS9UcnVzdFJvb3QvQ2VydFVSTCBmb3VuZCBmcm9tIFBQUyIpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBwcHMpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0ID0gZG93bmxvYWRfY2VydChjdHgsIG5vZGUsIGNhX2ZuYW1lKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBwcHMpOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IGNtZF9kbF9hYWFfY2Eoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCQkgY29uc3QgY2hhciAqY2FfZm5hbWUpCit7CisJeG1sX25vZGVfdCAqcHBzLCAqbm9kZSwgKmFhYTsKKwlpbnQgcmV0OworCisJcHBzID0gbm9kZV9mcm9tX2ZpbGUoY3R4LT54bWwsIHBwc19mbmFtZSk7CisJaWYgKHBwcyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVhZCBvciBwYXJzZSAnJXMnIiwgcHBzX2ZuYW1lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW5vZGUgPSBnZXRfY2hpbGRfbm9kZShjdHgtPnhtbCwgcHBzLAorCQkJICAgICAgIkFBQVNlcnZlclRydXN0Um9vdCIpOworCWlmIChub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIEFBQVNlcnZlclRydXN0Um9vdC9DZXJ0VVJMIGZvdW5kIGZyb20gUFBTIik7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlhYWEgPSB4bWxfbm9kZV9maXJzdF9jaGlsZChjdHgtPnhtbCwgbm9kZSk7CisJaWYgKGFhYSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBBQUFTZXJ2ZXJUcnVzdFJvb3QvQ2VydFVSTCBmb3VuZCBmcm9tIFBQUyIpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBwcHMpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0ID0gZG93bmxvYWRfY2VydChjdHgsIGFhYSwgY2FfZm5hbWUpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgZG93bmxvYWRfdHJ1c3Rfcm9vdHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCWNvbnN0IGNoYXIgKnBwc19mbmFtZSkKK3sKKwljaGFyICpkaXIsICpwb3M7CisJY2hhciBmbmFtZVszMDBdOworCWludCByZXQ7CisKKwlkaXIgPSBvc19zdHJkdXAocHBzX2ZuYW1lKTsKKwlpZiAoZGlyID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlwb3MgPSBvc19zdHJyY2hyKGRpciwgJy8nKTsKKwlpZiAocG9zID09IE5VTEwpIHsKKwkJb3NfZnJlZShkaXIpOworCQlyZXR1cm4gLTE7CisJfQorCSpwb3MgPSAnXDAnOworCisJc25wcmludGYoZm5hbWUsIHNpemVvZihmbmFtZSksICIlcy9jYS5wZW0iLCBkaXIpOworCXJldCA9IGNtZF9kbF9vc3VfY2EoY3R4LCBwcHNfZm5hbWUsIGZuYW1lKTsKKwlzbnByaW50ZihmbmFtZSwgc2l6ZW9mKGZuYW1lKSwgIiVzL3BvbHVwZC1jYS5wZW0iLCBkaXIpOworCWNtZF9kbF9wb2x1cGRfY2EoY3R4LCBwcHNfZm5hbWUsIGZuYW1lKTsKKwlzbnByaW50ZihmbmFtZSwgc2l6ZW9mKGZuYW1lKSwgIiVzL2FhYS1jYS5wZW0iLCBkaXIpOworCWNtZF9kbF9hYWFfY2EoY3R4LCBwcHNfZm5hbWUsIGZuYW1lKTsKKworCW9zX2ZyZWUoZGlyKTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBzZXJ2ZXJfZG5zbmFtZV9zdWZmaXhfbWF0Y2goc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCSAgICAgICBjb25zdCBjaGFyICpmcWRuKQoreworCXNpemVfdCBtYXRjaF9sZW4sIGxlbiwgaTsKKwljb25zdCBjaGFyICp2YWw7CisKKwltYXRjaF9sZW4gPSBvc19zdHJsZW4oZnFkbik7CisKKwlmb3IgKGkgPSAwOyBpIDwgY3R4LT5zZXJ2ZXJfZG5zbmFtZV9jb3VudDsgaSsrKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkgICAiQ2hlY2tpbmcgc3VmZml4IG1hdGNoIGFnYWluc3Qgc2VydmVyIGROU05hbWUgJXMiLAorCQkJICAgY3R4LT5zZXJ2ZXJfZG5zbmFtZVtpXSk7CisJCXZhbCA9IGN0eC0+c2VydmVyX2Ruc25hbWVbaV07CisJCWxlbiA9IG9zX3N0cmxlbih2YWwpOworCisJCWlmIChtYXRjaF9sZW4gPiBsZW4pCisJCQljb250aW51ZTsKKworCQlpZiAob3Nfc3RybmNhc2VjbXAodmFsICsgbGVuIC0gbWF0Y2hfbGVuLCBmcWRuLCBtYXRjaF9sZW4pICE9IDApCisJCQljb250aW51ZTsgLyogbm8gbWF0Y2ggKi8KKworCQlpZiAobWF0Y2hfbGVuID09IGxlbikKKwkJCXJldHVybiAxOyAvKiBleGFjdCBtYXRjaCAqLworCisJCWlmICh2YWxbbGVuIC0gbWF0Y2hfbGVuIC0gMV0gPT0gJy4nKQorCQkJcmV0dXJuIDE7IC8qIGZ1bGwgbGFiZWwgbWF0Y2ggY29tcGxldGVzIHN1ZmZpeCBtYXRjaCAqLworCisJCS8qIFJlamVjdCBkdWUgdG8gaW5jb21wbGV0ZSBsYWJlbCBtYXRjaCAqLworCX0KKworCS8qIE5vbmUgb2YgdGhlIGROU05hbWUocykgbWF0Y2hlZCAqLworCXJldHVybiAwOworfQorCisKK2ludCBoczIwX2FkZF9wcHNfbW8oc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmksCisJCSAgICB4bWxfbm9kZV90ICphZGRfbW8sIGNoYXIgKmZuYW1lLCBzaXplX3QgZm5hbWVfbGVuKQoreworCWNoYXIgKnN0cjsKKwljaGFyICpmcWRuLCAqcG9zOworCXhtbF9ub2RlX3QgKnRuZHMsICptbywgKmNlcnQ7CisJY29uc3QgY2hhciAqbmFtZTsKKwlpbnQgcmV0OworCisJaWYgKHN0cm5jbXAodXJpLCAiLi9XaS1GaS8iLCA4KSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVbnN1cHBvcnRlZCBsb2NhdGlvbiBmb3IgYWRkTU8gdG8gYWRkIFBQUyBNTzogJyVzJyIsCisJCQkgICB1cmkpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiVW5zdXBwb3J0ZWQgbG9jYXRpb24gZm9yIGFkZE1PIHRvIGFkZCBQUFMgTU86ICclcyciLAorCQkJICAgICB1cmkpOworCQlyZXR1cm4gLTE7CisJfQorCisJZnFkbiA9IHN0cmR1cCh1cmkgKyA4KTsKKwlpZiAoZnFkbiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJcG9zID0gc3RyY2hyKGZxZG4sICcvJyk7CisJaWYgKHBvcykgeworCQlpZiAob3Nfc3RyY2FzZWNtcChwb3MsICIvUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24iKSAhPSAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVW5zdXBwb3J0ZWQgbG9jYXRpb24gZm9yIGFkZE1PIHRvIGFkZCBQUFMgTU8gKGV4dHJhIGRpcmVjdG9yeSk6ICclcyciLAorCQkJCSAgIHVyaSk7CisJCQl3cml0ZV9yZXN1bHQoY3R4LCAiVW5zdXBwb3J0ZWQgbG9jYXRpb24gZm9yIGFkZE1PIHRvICIKKwkJCQkgICAgICJhZGQgUFBTIE1PIChleHRyYSBkaXJlY3RvcnkpOiAnJXMnIiwgdXJpKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQkqcG9zID0gJ1wwJzsgLyogcmVtb3ZlIHRyYWlsaW5nIHNsYXNoIGFuZCBQUFMgbm9kZSBuYW1lICovCisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICJTUCBGUUROOiAlcyIsIGZxZG4pOworCisJaWYgKCFzZXJ2ZXJfZG5zbmFtZV9zdWZmaXhfbWF0Y2goY3R4LCBmcWRuKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRlFETiAnJXMnIGZvciBuZXcgUFBTIE1PIGRpZCBub3QgaGF2ZSBzdWZmaXggbWF0Y2ggd2l0aCBzZXJ2ZXIncyBkTlNOYW1lIHZhbHVlcyIsCisJCQkgICBmcWRuKTsKKwkJd3JpdGVfcmVzdWx0KGN0eCwgIkZRRE4gJyVzJyBmb3IgbmV3IFBQUyBNTyBkaWQgbm90IGhhdmUgc3VmZml4IG1hdGNoIHdpdGggc2VydmVyJ3MgZE5TTmFtZSB2YWx1ZXMiLAorCQkJICAgICBmcWRuKTsKKwkJZnJlZShmcWRuKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmICghdmFsaWRfZnFkbihmcWRuKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSW52YWxpZCBGUUROICclcyciLCBmcWRuKTsKKwkJd3JpdGVfcmVzdWx0KGN0eCwgIkludmFsaWQgRlFETiAnJXMnIiwgZnFkbik7CisJCWZyZWUoZnFkbik7CisJCXJldHVybiAtMTsKKwl9CisKKwlta2RpcigiU1AiLCBTX0lSV1hVKTsKKwlzbnByaW50ZihmbmFtZSwgZm5hbWVfbGVuLCAiU1AvJXMiLCBmcWRuKTsKKwlpZiAobWtkaXIoZm5hbWUsIFNfSVJXWFUpIDwgMCkgeworCQlpZiAoZXJybm8gIT0gRUVYSVNUKSB7CisJCQlpbnQgZXJyID0gZXJybm87CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAibWtkaXIoJXMpIGZhaWxlZDogJXMiLAorCQkJCSAgIGZuYW1lLCBzdHJlcnJvcihlcnIpKTsKKwkJCWZyZWUoZnFkbik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlzbnByaW50ZihmbmFtZSwgZm5hbWVfbGVuLCAiU1AvJXMvcHBzLnhtbCIsIGZxZG4pOworCisJaWYgKG9zX2ZpbGVfZXhpc3RzKGZuYW1lKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUFBTIGZpbGUgJyVzJyBleGlzdHMgLSByZWplY3QgYWRkTU8iLAorCQkJICAgZm5hbWUpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiUFBTIGZpbGUgJyVzJyBleGlzdHMgLSByZWplY3QgYWRkTU8iLAorCQkJICAgICBmbmFtZSk7CisJCWZyZWUoZnFkbik7CisJCXJldHVybiAtMjsKKwl9CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVzaW5nIFBQUyBmaWxlOiAlcyIsIGZuYW1lKTsKKworCXN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBhZGRfbW8pOworCWlmIChzdHIgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGV4dHJhY3QgTU8gdGV4dCIpOworCQlmcmVlKGZxZG4pOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiW2hzMjBdIGFkZE1PIHRleHQ6ICclcyciLCBzdHIpOworCisJdG5kcyA9IHhtbF9ub2RlX2Zyb21fYnVmKGN0eC0+eG1sLCBzdHIpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHN0cik7CisJaWYgKHRuZHMgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiW2hzMjBdIENvdWxkIG5vdCBwYXJzZSBhZGRNTyB0ZXh0Iik7CisJCWZyZWUoZnFkbik7CisJCXJldHVybiAtMTsKKwl9CisKKwltbyA9IHRuZHNfdG9fbW8oY3R4LT54bWwsIHRuZHMpOworCWlmIChtbyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJbaHMyMF0gQ291bGQgbm90IHBhcnNlIGFkZE1PIFRORFMgdGV4dCIpOworCQlmcmVlKGZxZG4pOworCQlyZXR1cm4gLTE7CisJfQorCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgIlBhcnNlZCBUTkRTIiwgbW8pOworCisJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIG1vKTsKKwlpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24iKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJbaHMyMF0gVW5leHBlY3RlZCBQUFMgTU8gcm9vdCBub2RlIG5hbWUgJyVzJyIsCisJCQkgICBuYW1lKTsKKwkJZnJlZShmcWRuKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWNlcnQgPSBnZXRfY2hpbGRfbm9kZShjdHgtPnhtbCwgbW8sCisJCQkgICAgICAiQ3JlZGVudGlhbC9EaWdpdGFsQ2VydGlmaWNhdGUvIgorCQkJICAgICAgIkNlcnRTSEEyNTZGaW5nZXJwcmludCIpOworCWlmIChjZXJ0ICYmIHByb2Nlc3NfZXN0X2NlcnQoY3R4LCBjZXJ0LCBmcWRuKSA8IDApIHsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgbW8pOworCQlmcmVlKGZxZG4pOworCQlyZXR1cm4gLTE7CisJfQorCWZyZWUoZnFkbik7CisKKwlpZiAobm9kZV90b19maWxlKGN0eC0+eG1sLCBmbmFtZSwgbW8pIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHdyaXRlIE1PIHRvIGZpbGUiKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgbW8pOworCQlyZXR1cm4gLTE7CisJfQorCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIG1vKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJBIG5ldyBQUFMgTU8gYWRkZWQgYXMgJyVzJyIsIGZuYW1lKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIkEgbmV3IFBQUyBNTyBhZGRlZCBhcyAnJXMnIiwgZm5hbWUpOworCisJcmV0ID0gZG93bmxvYWRfdHJ1c3Rfcm9vdHMoY3R4LCBmbmFtZSk7CisJaWYgKHJldCA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlbW92ZSBpbnZhbGlkIFBQUyBNTyBmaWxlIik7CisJCXdyaXRlX3N1bW1hcnkoY3R4LCAiUmVtb3ZlIGludmFsaWQgUFBTIE1PIGZpbGUiKTsKKwkJdW5saW5rKGZuYW1lKTsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisKK2ludCB1cGRhdGVfcHBzX2ZpbGUoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCSAgICB4bWxfbm9kZV90ICpwcHMpCit7CisJY2hhciAqc3RyOworCUZJTEUgKmY7CisJY2hhciBiYWNrdXBbMzAwXTsKKworCWlmIChjdHgtPmNsaWVudF9jZXJ0X3ByZXNlbnQpIHsKKwkJeG1sX25vZGVfdCAqY2VydDsKKwkJY2VydCA9IGdldF9jaGlsZF9ub2RlKGN0eC0+eG1sLCBwcHMsCisJCQkJICAgICAgIkNyZWRlbnRpYWwvRGlnaXRhbENlcnRpZmljYXRlLyIKKwkJCQkgICAgICAiQ2VydFNIQTI1NkZpbmdlcnByaW50Iik7CisJCWlmIChjZXJ0ICYmIG9zX2ZpbGVfZXhpc3RzKCJDZXJ0L2VzdF9jZXJ0LmRlciIpICYmCisJCSAgICBwcm9jZXNzX2VzdF9jZXJ0KGN0eCwgY2VydCwgY3R4LT5mcWRuKSA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJFU1QgY2VydGlmaWNhdGUgdXBkYXRlIHByb2Nlc3NpbmcgZmFpbGVkIG9uIFBQUyBNTyB1cGRhdGUiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KKworCXdwYV9wcmludGYoTVNHX0lORk8sICJVcGRhdGluZyBQUFMgTU8gJXMiLCBwcHNfZm5hbWUpOworCisJc3RyID0geG1sX25vZGVfdG9fc3RyKGN0eC0+eG1sLCBwcHMpOworCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJbaHMyMF0gVXBkYXRlZCBQUFM6ICclcyciLCBzdHIpOworCisJc25wcmludGYoYmFja3VwLCBzaXplb2YoYmFja3VwKSwgIiVzLmJhayIsIHBwc19mbmFtZSk7CisJcmVuYW1lKHBwc19mbmFtZSwgYmFja3VwKTsKKwlmID0gZm9wZW4ocHBzX2ZuYW1lLCAidyIpOworCWlmIChmID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCB3cml0ZSBQUFMiKTsKKwkJcmVuYW1lKGJhY2t1cCwgcHBzX2ZuYW1lKTsKKwkJZnJlZShzdHIpOworCQlyZXR1cm4gLTE7CisJfQorCWZwcmludGYoZiwgIiVzXG4iLCBzdHIpOworCWZjbG9zZShmKTsKKworCWZyZWUoc3RyKTsKKworCXJldHVybiAwOworfQorCisKK3ZvaWQgZ2V0X3VzZXJfcHcoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpwcHMsCisJCSBjb25zdCBjaGFyICphbHRfbG9jLCBjaGFyICoqdXNlciwgY2hhciAqKnB3KQoreworCXhtbF9ub2RlX3QgKm5vZGU7CisKKwlub2RlID0gZ2V0X2NoaWxkX25vZGUoY3R4LT54bWwsIHBwcywKKwkJCSAgICAgICJDcmVkZW50aWFsL1VzZXJuYW1lUGFzc3dvcmQvVXNlcm5hbWUiKTsKKwlpZiAobm9kZSkKKwkJKnVzZXIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisKKwlub2RlID0gZ2V0X2NoaWxkX25vZGUoY3R4LT54bWwsIHBwcywKKwkJCSAgICAgICJDcmVkZW50aWFsL1VzZXJuYW1lUGFzc3dvcmQvUGFzc3dvcmQiKTsKKwlpZiAobm9kZSkKKwkJKnB3ID0geG1sX25vZGVfZ2V0X2Jhc2U2NF90ZXh0KGN0eC0+eG1sLCBub2RlLCBOVUxMKTsKKworCW5vZGUgPSBnZXRfY2hpbGRfbm9kZShjdHgtPnhtbCwgcHBzLCBhbHRfbG9jKTsKKwlpZiAobm9kZSkgeworCQl4bWxfbm9kZV90ICphOworCQlhID0gZ2V0X25vZGUoY3R4LT54bWwsIG5vZGUsICJVc2VybmFtZSIpOworCQlpZiAoYSkgeworCQkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgKnVzZXIpOworCQkJKnVzZXIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgYSk7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXNlIE9TVSB1c2VybmFtZSAnJXMnIiwgKnVzZXIpOworCQl9CisKKwkJYSA9IGdldF9ub2RlKGN0eC0+eG1sLCBub2RlLCAiUGFzc3dvcmQiKTsKKwkJaWYgKGEpIHsKKwkJCWZyZWUoKnB3KTsKKwkJCSpwdyA9IHhtbF9ub2RlX2dldF9iYXNlNjRfdGV4dChjdHgtPnhtbCwgYSwgTlVMTCk7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXNlIE9TVSBwYXNzd29yZCIpOworCQl9CisJfQorfQorCisKKy8qIFJlbW92ZSBvbGQgY3JlZGVudGlhbHMgYmFzZWQgb24gSG9tZVNQL0ZRRE4gKi8KK3N0YXRpYyB2b2lkIHJlbW92ZV9zcF9jcmVkcyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKmZxZG4pCit7CisJY2hhciBjbWRbMzAwXTsKKwlvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLCAiUkVNT1ZFX0NSRUQgcHJvdmlzaW9uaW5nX3NwPSVzIiwgZnFkbik7CisJaWYgKHdwYV9jb21tYW5kKGN0eC0+aWZuYW1lLCBjbWQpIDwgMCkKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byByZW1vdmUgb2xkIGNyZWRlbnRpYWwocykiKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfcG9saWN5X3NwZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgICAgeG1sX25vZGVfdCAqc3BlKQoreworCXhtbF9ub2RlX3QgKnNzaWQ7CisJY2hhciAqdHh0OworCisJc3NpZCA9IGdldF9ub2RlKGN0eC0+eG1sLCBzcGUsICJTU0lEIik7CisJaWYgKHNzaWQgPT0gTlVMTCkKKwkJcmV0dXJuOworCXR4dCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBzc2lkKTsKKwlpZiAodHh0ID09IE5VTEwpCisJCXJldHVybjsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIi0gUG9saWN5L1NQRXhjbHVzaW9uTGlzdC88WCs+L1NTSUQgPSAlcyIsIHR4dCk7CisJaWYgKHNldF9jcmVkX3F1b3RlZChjdHgtPmlmbmFtZSwgaWQsICJleGNsdWRlZF9zc2lkIiwgdHh0KSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgZXhjbHVkZWRfc3NpZCIpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHR4dCk7Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX3BvbGljeV9zcGVsKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCSAgICAgeG1sX25vZGVfdCAqc3BlbCkKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgc3BlbCkgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgtPnhtbCwgY2hpbGQpOworCQlzZXRfcHBzX2NyZWRfcG9saWN5X3NwZShjdHgsIGlkLCBjaGlsZCk7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9wb2xpY3lfcHJwKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCSAgICB4bWxfbm9kZV90ICpwcnApCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKwljaGFyICp0eHQgPSBOVUxMLCAqcG9zOworCWNoYXIgKnByaW8sICpjb3VudHJ5X2J1ZiA9IE5VTEw7CisJY29uc3QgY2hhciAqY291bnRyeTsKKwljaGFyIHZhbFsyMDBdOworCWludCBwcmlvcml0eTsKKworCW5vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgcHJwLCAiUHJpb3JpdHkiKTsKKwlpZiAobm9kZSA9PSBOVUxMKQorCQlyZXR1cm47CisJcHJpbyA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwlpZiAocHJpbyA9PSBOVUxMKQorCQlyZXR1cm47CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gUG9saWN5L1ByZWZlcnJlZFJvYW1pbmdQYXJ0bmVyTGlzdC88WCs+L1ByaW9yaXR5ID0gJXMiLAorCQkgICBwcmlvKTsKKwlwcmlvcml0eSA9IGF0b2kocHJpbyk7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgcHJpbyk7CisKKwlub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIHBycCwgIkNvdW50cnkiKTsKKwlpZiAobm9kZSkgeworCQljb3VudHJ5X2J1ZiA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwkJaWYgKGNvdW50cnlfYnVmID09IE5VTEwpCisJCQlyZXR1cm47CisJCWNvdW50cnkgPSBjb3VudHJ5X2J1ZjsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gUG9saWN5L1ByZWZlcnJlZFJvYW1pbmdQYXJ0bmVyTGlzdC88WCs+L0NvdW50cnkgPSAlcyIsCisJCQkgICBjb3VudHJ5KTsKKwl9IGVsc2UgeworCQljb3VudHJ5ID0gIioiOworCX0KKworCW5vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgcHJwLCAiRlFETl9NYXRjaCIpOworCWlmIChub2RlID09IE5VTEwpCisJCWdvdG8gb3V0OworCXR4dCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwlpZiAodHh0ID09IE5VTEwpCisJCWdvdG8gb3V0OworCXdwYV9wcmludGYoTVNHX0lORk8sICItIFBvbGljeS9QcmVmZXJyZWRSb2FtaW5nUGFydG5lckxpc3QvPFgrPi9GUUROX01hdGNoID0gJXMiLAorCQkgICB0eHQpOworCXBvcyA9IHN0cnJjaHIodHh0LCAnLCcpOworCWlmIChwb3MgPT0gTlVMTCkKKwkJZ290byBvdXQ7CisJKnBvcysrID0gJ1wwJzsKKworCXNucHJpbnRmKHZhbCwgc2l6ZW9mKHZhbCksICIlcywlZCwlZCwlcyIsIHR4dCwKKwkJIHN0cmNtcChwb3MsICJpbmNsdWRlU3ViZG9tYWlucyIpICE9IDAsIHByaW9yaXR5LCBjb3VudHJ5KTsKKwlpZiAoc2V0X2NyZWRfcXVvdGVkKGN0eC0+aWZuYW1lLCBpZCwgInJvYW1pbmdfcGFydG5lciIsIHZhbCkgPCAwKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBjcmVkIHJvYW1pbmdfcGFydG5lciIpOworb3V0OgorCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGNvdW50cnlfYnVmKTsKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCB0eHQpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9wb2xpY3lfcHJwbChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgICAgIHhtbF9ub2RlX3QgKnBycGwpCit7CisJeG1sX25vZGVfdCAqY2hpbGQ7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgtPnhtbCwgY2hpbGQsIHBycGwpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJc2V0X3Bwc19jcmVkX3BvbGljeV9wcnAoY3R4LCBpZCwgY2hpbGQpOworCX0KK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfcG9saWN5X21pbl9iYWNraGF1bChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkJICAgICB4bWxfbm9kZV90ICptaW5fYmFja2hhdWwpCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKwljaGFyICp0eXBlLCAqZGwgPSBOVUxMLCAqdWwgPSBOVUxMOworCWludCBob21lOworCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBtaW5fYmFja2hhdWwsICJOZXR3b3JrVHlwZSIpOworCWlmIChub2RlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIklnbm9yZSBNaW5CYWNraGF1bFRocmVzaG9sZCB3aXRob3V0IG1hbmRhdG9yeSBOZXR3b3JrVHlwZSBub2RlIik7CisJCXJldHVybjsKKwl9CisKKwl0eXBlID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmICh0eXBlID09IE5VTEwpCisJCXJldHVybjsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBQb2xpY3kvTWluQmFja2hhdWxUaHJlc2hvbGQvPFgrPi9OZXR3b3JrVHlwZSA9ICVzIiwKKwkJICAgdHlwZSk7CisJaWYgKG9zX3N0cmNhc2VjbXAodHlwZSwgImhvbWUiKSA9PSAwKQorCQlob21lID0gMTsKKwllbHNlIGlmIChvc19zdHJjYXNlY21wKHR5cGUsICJyb2FtaW5nIikgPT0gMCkKKwkJaG9tZSA9IDA7CisJZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJZ25vcmUgTWluQmFja2hhdWxUaHJlc2hvbGQgd2l0aCBpbnZhbGlkIE5ldHdvcmtUeXBlIik7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHR5cGUpOworCQlyZXR1cm47CisJfQorCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHR5cGUpOworCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBtaW5fYmFja2hhdWwsICJETEJhbmR3aWR0aCIpOworCWlmIChub2RlKQorCQlkbCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKworCW5vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgbWluX2JhY2toYXVsLCAiVUxCYW5kd2lkdGgiKTsKKwlpZiAobm9kZSkKKwkJdWwgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisKKwlpZiAoZGwgPT0gTlVMTCAmJiB1bCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJZ25vcmUgTWluQmFja2hhdWxUaHJlc2hvbGQgd2l0aG91dCBlaXRoZXIgRExCYW5kd2lkdGggb3IgVUxCYW5kd2lkdGggbm9kZXMiKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChkbCkKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gUG9saWN5L01pbkJhY2toYXVsVGhyZXNob2xkLzxYKz4vRExCYW5kd2lkdGggPSAlcyIsCisJCQkgICBkbCk7CisJaWYgKHVsKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBQb2xpY3kvTWluQmFja2hhdWxUaHJlc2hvbGQvPFgrPi9VTEJhbmR3aWR0aCA9ICVzIiwKKwkJCSAgIHVsKTsKKworCWlmIChob21lKSB7CisJCWlmIChkbCAmJgorCQkgICAgc2V0X2NyZWQoY3R4LT5pZm5hbWUsIGlkLCAibWluX2RsX2JhbmR3aWR0aF9ob21lIiwgZGwpIDwgMCkKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgYmFuZHdpZHRoIGxpbWl0Iik7CisJCWlmICh1bCAmJgorCQkgICAgc2V0X2NyZWQoY3R4LT5pZm5hbWUsIGlkLCAibWluX3VsX2JhbmR3aWR0aF9ob21lIiwgdWwpIDwgMCkKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgYmFuZHdpZHRoIGxpbWl0Iik7CisJfSBlbHNlIHsKKwkJaWYgKGRsICYmCisJCSAgICBzZXRfY3JlZChjdHgtPmlmbmFtZSwgaWQsICJtaW5fZGxfYmFuZHdpZHRoX3JvYW1pbmciLCBkbCkgPAorCQkgICAgMCkKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgYmFuZHdpZHRoIGxpbWl0Iik7CisJCWlmICh1bCAmJgorCQkgICAgc2V0X2NyZWQoY3R4LT5pZm5hbWUsIGlkLCAibWluX3VsX2JhbmR3aWR0aF9yb2FtaW5nIiwgdWwpIDwKKwkJICAgIDApCisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBjcmVkIGJhbmR3aWR0aCBsaW1pdCIpOworCX0KKworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGRsKTsKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCB1bCk7Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX3BvbGljeV9taW5fYmFja2hhdWxfbGlzdChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJCQkgIGludCBpZCwgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICItIFBvbGljeS9NaW5CYWNraGF1bFRocmVzaG9sZCIpOworCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LT54bWwsIGNoaWxkLCBub2RlKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eC0+eG1sLCBjaGlsZCk7CisJCXNldF9wcHNfY3JlZF9wb2xpY3lfbWluX2JhY2toYXVsKGN0eCwgaWQsIGNoaWxkKTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX3BvbGljeV91cGRhdGUoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBpbnQgaWQsCisJCQkJICAgICAgIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gUG9saWN5L1BvbGljeVVwZGF0ZSIpOworCS8qIE5vdCB1c2VkIGluIHdwYV9zdXBwbGljYW50ICovCit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX3BvbGljeV9yZXF1aXJlZF9wcm90b19wb3J0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJCSAgICBpbnQgaWQsIHhtbF9ub2RlX3QgKnR1cGxlKQoreworCXhtbF9ub2RlX3QgKm5vZGU7CisJY2hhciAqcHJvdG8sICpwb3J0OworCWNoYXIgKmJ1ZjsKKwlzaXplX3QgYnVmbGVuOworCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCB0dXBsZSwgIklQUHJvdG9jb2wiKTsKKwlpZiAobm9kZSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJZ25vcmUgUmVxdWlyZWRQcm90b1BvcnRUdXBsZSB3aXRob3V0IG1hbmRhdG9yeSBJUFByb3RvY29sIG5vZGUiKTsKKwkJcmV0dXJuOworCX0KKworCXByb3RvID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChwcm90byA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBQb2xpY3kvUmVxdWlyZWRQcm90b1BvcnRUdXBsZS88WCs+L0lQUHJvdG9jb2wgPSAlcyIsCisJCSAgIHByb3RvKTsKKworCW5vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgdHVwbGUsICJQb3J0TnVtYmVyIik7CisJcG9ydCA9IG5vZGUgPyB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSkgOiBOVUxMOworCWlmIChwb3J0KSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICItIFBvbGljeS9SZXF1aXJlZFByb3RvUG9ydFR1cGxlLzxYKz4vUG9ydE51bWJlciA9ICVzIiwKKwkJCSAgIHBvcnQpOworCQlidWZsZW4gPSBvc19zdHJsZW4ocHJvdG8pICsgb3Nfc3RybGVuKHBvcnQpICsgMTA7CisJCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOworCQlpZiAoYnVmKQorCQkJb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICIlczolcyIsIHByb3RvLCBwb3J0KTsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgcG9ydCk7CisJfSBlbHNlIHsKKwkJYnVmbGVuID0gb3Nfc3RybGVuKHByb3RvKSArIDEwOworCQlidWYgPSBvc19tYWxsb2MoYnVmbGVuKTsKKwkJaWYgKGJ1ZikKKwkJCW9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJXMiLCBwcm90byk7CisJfQorCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgcHJvdG8pOworCisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlpZiAoc2V0X2NyZWQoY3R4LT5pZm5hbWUsIGlkLCAicmVxX2Nvbm5fY2FwYWIiLCBidWYpIDwgMCkKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBzZXQgcmVxX2Nvbm5fY2FwYWIiKTsKKworCW9zX2ZyZWUoYnVmKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfcG9saWN5X3JlcXVpcmVkX3Byb3RvX3BvcnRzKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJCSAgICAgaW50IGlkLCB4bWxfbm9kZV90ICpub2RlKQoreworCXhtbF9ub2RlX3QgKmNoaWxkOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gUG9saWN5L1JlcXVpcmVkUHJvdG9Qb3J0VHVwbGUiKTsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgbm9kZSkgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgtPnhtbCwgY2hpbGQpOworCQlzZXRfcHBzX2NyZWRfcG9saWN5X3JlcXVpcmVkX3Byb3RvX3BvcnQoY3R4LCBpZCwgY2hpbGQpOworCX0KK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfcG9saWN5X21heF9ic3NfbG9hZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkJICAgICB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybjsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBQb2xpY3kvTWF4aW11bUJTU0xvYWRWYWx1ZSAtICVzIiwgc3RyKTsKKwlpZiAoc2V0X2NyZWQoY3R4LT5pZm5hbWUsIGlkLCAibWF4X2Jzc19sb2FkIiwgc3RyKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgbWF4X2Jzc19sb2FkIGxpbWl0Iik7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgc3RyKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfcG9saWN5KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCXhtbF9ub2RlX3QgKm5vZGUpCit7CisJeG1sX25vZGVfdCAqY2hpbGQ7CisJY29uc3QgY2hhciAqbmFtZTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICItIFBvbGljeSIpOworCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LT54bWwsIGNoaWxkLCBub2RlKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eC0+eG1sLCBjaGlsZCk7CisJCW5hbWUgPSB4bWxfbm9kZV9nZXRfbG9jYWxuYW1lKGN0eC0+eG1sLCBjaGlsZCk7CisJCWlmIChvc19zdHJjYXNlY21wKG5hbWUsICJQcmVmZXJyZWRSb2FtaW5nUGFydG5lckxpc3QiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX3BvbGljeV9wcnBsKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiTWluQmFja2hhdWxUaHJlc2hvbGQiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX3BvbGljeV9taW5fYmFja2hhdWxfbGlzdChjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlBvbGljeVVwZGF0ZSIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfcG9saWN5X3VwZGF0ZShjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlNQRXhjbHVzaW9uTGlzdCIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfcG9saWN5X3NwZWwoY3R4LCBpZCwgY2hpbGQpOworCQllbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJSZXF1aXJlZFByb3RvUG9ydFR1cGxlIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9wb2xpY3lfcmVxdWlyZWRfcHJvdG9fcG9ydHMoY3R4LCBpZCwgY2hpbGQpOworCQllbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJNYXhpbXVtQlNTTG9hZFZhbHVlIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9wb2xpY3lfbWF4X2Jzc19sb2FkKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZQorCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVua25vd24gUG9saWN5IG5vZGUgJyVzJyIsIG5hbWUpOworCX0KK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfcHJpb3JpdHkoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBpbnQgaWQsCisJCQkJICB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybjsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBDcmVkZW50aWFsUHJpb3JpdHkgPSAlcyIsIHN0cik7CisJaWYgKHNldF9jcmVkKGN0eC0+aWZuYW1lLCBpZCwgInNwX3ByaW9yaXR5Iiwgc3RyKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgc3BfcHJpb3JpdHkiKTsKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9hYWFfc2VydmVyX3RydXN0X3Jvb3Qoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCQkgICAgICAgaW50IGlkLCB4bWxfbm9kZV90ICpub2RlKQoreworCXdwYV9wcmludGYoTVNHX0lORk8sICItIEFBQVNlcnZlclRydXN0Um9vdCAtIFRPRE8iKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfc3ViX3VwZGF0ZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgICAgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBTdWJzY3JpcHRpb25VcGRhdGUiKTsKKwkvKiBub3QgdXNlZCB3aXRoaW4gd3BhX3N1cHBsaWNhbnQgKi8KK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfaG9tZV9zcF9uZXR3b3JrX2lkKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICAgIGludCBpZCwgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxfbm9kZV90ICpzc2lkX25vZGUsICpoZXNzaWRfbm9kZTsKKwljaGFyICpzc2lkLCAqaGVzc2lkOworCisJc3NpZF9ub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIG5vZGUsICJTU0lEIik7CisJaWYgKHNzaWRfbm9kZSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJZ25vcmUgSG9tZVNQL05ldHdvcmtJRCB3aXRob3V0IG1hbmRhdG9yeSBTU0lEIG5vZGUiKTsKKwkJcmV0dXJuOworCX0KKworCWhlc3NpZF9ub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIG5vZGUsICJIRVNTSUQiKTsKKworCXNzaWQgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgc3NpZF9ub2RlKTsKKwlpZiAoc3NpZCA9PSBOVUxMKQorCQlyZXR1cm47CisJaGVzc2lkID0gaGVzc2lkX25vZGUgPyB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgaGVzc2lkX25vZGUpIDogTlVMTDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICItIEhvbWVTUC9OZXR3b3JrSUQvPFgrPi9TU0lEID0gJXMiLCBzc2lkKTsKKwlpZiAoaGVzc2lkKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBIb21lU1AvTmV0d29ya0lELzxYKz4vSEVTU0lEID0gJXMiLAorCQkJICAgaGVzc2lkKTsKKworCS8qIFRPRE86IENvbmZpZ3VyZSB0byB3cGFfc3VwcGxpY2FudCAqLworCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgc3NpZCk7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgaGVzc2lkKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfaG9tZV9zcF9uZXR3b3JrX2lkcyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJCSAgICAgaW50IGlkLCB4bWxfbm9kZV90ICpub2RlKQoreworCXhtbF9ub2RlX3QgKmNoaWxkOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gSG9tZVNQL05ldHdvcmtJRCIpOworCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LT54bWwsIGNoaWxkLCBub2RlKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eC0+eG1sLCBjaGlsZCk7CisJCXNldF9wcHNfY3JlZF9ob21lX3NwX25ldHdvcmtfaWQoY3R4LCBpZCwgY2hpbGQpOworCX0KK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfaG9tZV9zcF9mcmllbmRseV9uYW1lKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICAgICAgIGludCBpZCwgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwljaGFyICpzdHIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gSG9tZVNQL0ZyaWVuZGx5TmFtZSA9ICVzIiwgc3RyKTsKKwkvKiBub3QgdXNlZCB3aXRoaW4gd3BhX3N1cHBsaWNhbnQoPykgKi8KKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9ob21lX3NwX2ljb25fdXJsKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICBpbnQgaWQsIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuOworCXdwYV9wcmludGYoTVNHX0lORk8sICItIEhvbWVTUC9JY29uVVJMID0gJXMiLCBzdHIpOworCS8qIG5vdCB1c2VkIHdpdGhpbiB3cGFfc3VwcGxpY2FudCAqLworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHN0cik7Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX2hvbWVfc3BfZnFkbihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgICAgICB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybjsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBIb21lU1AvRlFETiA9ICVzIiwgc3RyKTsKKwlpZiAoc2V0X2NyZWRfcXVvdGVkKGN0eC0+aWZuYW1lLCBpZCwgImRvbWFpbiIsIHN0cikgPCAwKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBjcmVkIGRvbWFpbiIpOworCWlmIChzZXRfY3JlZF9xdW90ZWQoY3R4LT5pZm5hbWUsIGlkLCAiZG9tYWluX3N1ZmZpeF9tYXRjaCIsIHN0cikgPCAwKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBjcmVkIGRvbWFpbl9zdWZmaXhfbWF0Y2giKTsKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9ob21lX3NwX29pKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCSAgICB4bWxfbm9kZV90ICpub2RlKQoreworCXhtbF9ub2RlX3QgKmNoaWxkOworCWNvbnN0IGNoYXIgKm5hbWU7CisJY2hhciAqaG9tZW9pID0gTlVMTDsKKwlpbnQgcmVxdWlyZWQgPSAwOworCWNoYXIgKnN0cjsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgbm9kZSkgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgtPnhtbCwgY2hpbGQpOworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgY2hpbGQpOworCQlpZiAoc3RyY2FzZWNtcChuYW1lLCAiSG9tZU9JIikgPT0gMCAmJiAhaG9tZW9pKSB7CisJCQlob21lb2kgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgY2hpbGQpOworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gSG9tZVNQL0hvbWVPSUxpc3QvPFgrPi9Ib21lT0kgPSAlcyIsCisJCQkJICAgaG9tZW9pKTsKKwkJfSBlbHNlIGlmIChzdHJjYXNlY21wKG5hbWUsICJIb21lT0lSZXF1aXJlZCIpID09IDApIHsKKwkJCXN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBjaGlsZCk7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBIb21lU1AvSG9tZU9JTGlzdC88WCs+L0hvbWVPSVJlcXVpcmVkID0gJyVzJyIsCisJCQkJICAgc3RyKTsKKwkJCWlmIChzdHIgPT0gTlVMTCkKKwkJCQljb250aW51ZTsKKwkJCXJlcXVpcmVkID0gc3RyY2FzZWNtcChzdHIsICJ0cnVlIikgPT0gMDsKKwkJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHN0cik7CisJCX0gZWxzZQorCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVua25vd24gSG9tZU9JTGlzdCBub2RlICclcyciLAorCQkJCSAgIG5hbWUpOworCX0KKworCWlmIChob21lb2kgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBIb21lU1AvSG9tZU9JTGlzdC88WCs+IHdpdGhvdXQgSG9tZU9JIGlnbm9yZWQiKTsKKwkJcmV0dXJuOworCX0KKworCXdwYV9wcmludGYoTVNHX0lORk8sICItIEhvbWVTUC9Ib21lT0lMaXN0LzxYKz4gJyVzJyByZXF1aXJlZD0lZCIsCisJCSAgIGhvbWVvaSwgcmVxdWlyZWQpOworCisJaWYgKHJlcXVpcmVkKSB7CisJCWlmIChzZXRfY3JlZChjdHgtPmlmbmFtZSwgaWQsICJyZXF1aXJlZF9yb2FtaW5nX2NvbnNvcnRpdW0iLAorCQkJICAgICBob21lb2kpIDwgMCkKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgcmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtIik7CisJfSBlbHNlIHsKKwkJaWYgKHNldF9jcmVkX3F1b3RlZChjdHgtPmlmbmFtZSwgaWQsICJyb2FtaW5nX2NvbnNvcnRpdW0iLAorCQkJCSAgICBob21lb2kpIDwgMCkKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgcm9hbWluZ19jb25zb3J0aXVtIik7CisJfQorCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgaG9tZW9pKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfaG9tZV9zcF9vaV9saXN0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCQkgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICItIEhvbWVTUC9Ib21lT0lMaXN0Iik7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgtPnhtbCwgY2hpbGQsIG5vZGUpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJc2V0X3Bwc19jcmVkX2hvbWVfc3Bfb2koY3R4LCBpZCwgY2hpbGQpOworCX0KK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfaG9tZV9zcF9vdGhlcl9wYXJ0bmVyKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICAgICAgIGludCBpZCwgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKwljb25zdCBjaGFyICpuYW1lOworCWNoYXIgKmZxZG4gPSBOVUxMOworCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LT54bWwsIGNoaWxkLCBub2RlKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eC0+eG1sLCBjaGlsZCk7CisJCW5hbWUgPSB4bWxfbm9kZV9nZXRfbG9jYWxuYW1lKGN0eC0+eG1sLCBjaGlsZCk7CisJCWlmIChvc19zdHJjYXNlY21wKG5hbWUsICJGUUROIikgPT0gMCAmJiAhZnFkbikgeworCQkJZnFkbiA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBjaGlsZCk7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBIb21lU1AvT3RoZXJIb21lUGFydG5lcnMvPFgrPi9GUUROID0gJXMiLAorCQkJCSAgIGZxZG4pOworCQl9IGVsc2UKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJVbmtub3duIE90aGVySG9tZVBhcnRuZXJzIG5vZGUgJyVzJyIsCisJCQkJICAgbmFtZSk7CisJfQorCisJaWYgKGZxZG4gPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBIb21lU1AvT3RoZXJIb21lUGFydG5lcnMvPFgrPiB3aXRob3V0IEZRRE4gaWdub3JlZCIpOworCQlyZXR1cm47CisJfQorCisJaWYgKHNldF9jcmVkX3F1b3RlZChjdHgtPmlmbmFtZSwgaWQsICJkb21haW4iLCBmcWRuKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgZG9tYWluIGZvciBPdGhlckhvbWVQYXJ0bmVycyBub2RlIik7CisKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBmcWRuKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfaG9tZV9zcF9vdGhlcl9wYXJ0bmVycyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJCQlpbnQgaWQsCisJCQkJCQl4bWxfbm9kZV90ICpub2RlKQoreworCXhtbF9ub2RlX3QgKmNoaWxkOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gSG9tZVNQL090aGVySG9tZVBhcnRuZXJzIik7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgtPnhtbCwgY2hpbGQsIG5vZGUpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJc2V0X3Bwc19jcmVkX2hvbWVfc3Bfb3RoZXJfcGFydG5lcihjdHgsIGlkLCBjaGlsZCk7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9ob21lX3NwX3JvYW1pbmdfY29uc29ydGl1bV9vaSgKKwlzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwljaGFyICpzdHIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gSG9tZVNQL1JvYW1pbmdDb25zb3J0aXVtT0kgPSAlcyIsIHN0cik7CisJLyogVE9ETzogU2V0IHRvIHdwYV9zdXBwbGljYW50ICovCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgc3RyKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfaG9tZV9zcChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKwljb25zdCBjaGFyICpuYW1lOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gSG9tZVNQIik7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgtPnhtbCwgY2hpbGQsIG5vZGUpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIGNoaWxkKTsKKwkJaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIk5ldHdvcmtJRCIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfaG9tZV9zcF9uZXR3b3JrX2lkcyhjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIkZyaWVuZGx5TmFtZSIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfaG9tZV9zcF9mcmllbmRseV9uYW1lKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiSWNvblVSTCIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfaG9tZV9zcF9pY29uX3VybChjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIkZRRE4iKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX2hvbWVfc3BfZnFkbihjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIkhvbWVPSUxpc3QiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX2hvbWVfc3Bfb2lfbGlzdChjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIk90aGVySG9tZVBhcnRuZXJzIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9ob21lX3NwX290aGVyX3BhcnRuZXJzKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiUm9hbWluZ0NvbnNvcnRpdW1PSSIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfaG9tZV9zcF9yb2FtaW5nX2NvbnNvcnRpdW1fb2koY3R4LCBpZCwKKwkJCQkJCQkJICAgY2hpbGQpOworCQllbHNlCisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVW5rbm93biBIb21lU1Agbm9kZSAnJXMnIiwgbmFtZSk7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9zdWJfcGFyYW1zKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCSAgICB4bWxfbm9kZV90ICpub2RlKQoreworCXdwYV9wcmludGYoTVNHX0lORk8sICItIFN1YnNjcmlwdGlvblBhcmFtZXRlcnMiKTsKKwkvKiBub3QgdXNlZCB3aXRoaW4gd3BhX3N1cHBsaWNhbnQgKi8KK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfY3JlYXRpb25fZGF0ZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgICAgICAgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwljaGFyICpzdHIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbC9DcmVhdGlvbkRhdGUgPSAlcyIsIHN0cik7CisJLyogbm90IHVzZWQgd2l0aGluIHdwYV9zdXBwbGljYW50ICovCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgc3RyKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfZXhwaXJhdGlvbl9kYXRlKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCQkgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwljaGFyICpzdHIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbC9FeHBpcmF0aW9uRGF0ZSA9ICVzIiwgc3RyKTsKKwkvKiBub3QgdXNlZCB3aXRoaW4gd3BhX3N1cHBsaWNhbnQgKi8KKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF91c2VybmFtZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuOworCXdwYV9wcmludGYoTVNHX0lORk8sICItIENyZWRlbnRpYWwvVXNlcm5hbWVQYXNzd29yZC9Vc2VybmFtZSA9ICVzIiwKKwkJICAgc3RyKTsKKwlpZiAoc2V0X2NyZWRfcXVvdGVkKGN0eC0+aWZuYW1lLCBpZCwgInVzZXJuYW1lIiwgc3RyKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgdXNlcm5hbWUiKTsKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9wYXNzd29yZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJaW50IGxlbiwgaTsKKwljaGFyICpwdywgKmhleCwgKnBvcywgKmVuZDsKKworCXB3ID0geG1sX25vZGVfZ2V0X2Jhc2U2NF90ZXh0KGN0eC0+eG1sLCBub2RlLCAmbGVuKTsKKwlpZiAocHcgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbC9Vc2VybmFtZVBhc3N3b3JkL1Bhc3N3b3JkID0gJXMiLCBwdyk7CisKKwloZXggPSBtYWxsb2MobGVuICogMiArIDEpOworCWlmIChoZXggPT0gTlVMTCkgeworCQlmcmVlKHB3KTsKKwkJcmV0dXJuOworCX0KKwllbmQgPSBoZXggKyBsZW4gKiAyICsgMTsKKwlwb3MgPSBoZXg7CisJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKSB7CisJCXNucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJTAyeCIsIHB3W2ldKTsKKwkJcG9zICs9IDI7CisJfQorCWZyZWUocHcpOworCisJaWYgKHNldF9jcmVkKGN0eC0+aWZuYW1lLCBpZCwgInBhc3N3b3JkIiwgaGV4KSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgcGFzc3dvcmQiKTsKKwlmcmVlKGhleCk7Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX21hY2hpbmVfbWFuYWdlZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkJIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuOworCXdwYV9wcmludGYoTVNHX0lORk8sICItIENyZWRlbnRpYWwvVXNlcm5hbWVQYXNzd29yZC9NYWNoaW5lTWFuYWdlZCA9ICVzIiwKKwkJICAgc3RyKTsKKwkvKiBub3QgdXNlZCB3aXRoaW4gd3BhX3N1cHBsaWNhbnQgKi8KKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9zb2Z0X3Rva2VuX2FwcChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkJeG1sX25vZGVfdCAqbm9kZSkKK3sKKwljaGFyICpzdHIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbC9Vc2VybmFtZVBhc3N3b3JkL1NvZnRUb2tlbkFwcCA9ICVzIiwKKwkJICAgc3RyKTsKKwkvKiBub3QgdXNlZCB3aXRoaW4gd3BhX3N1cHBsaWNhbnQgKi8KKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9hYmxlX3RvX3NoYXJlKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IGlkLAorCQkJCSAgICAgICB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybjsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBDcmVkZW50aWFsL1VzZXJuYW1lUGFzc3dvcmQvQWJsZVRvU2hhcmUgPSAlcyIsCisJCSAgIHN0cik7CisJLyogbm90IHVzZWQgd2l0aGluIHdwYV9zdXBwbGljYW50ICovCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgc3RyKTsKK30KKworCitzdGF0aWMgdm9pZCBzZXRfcHBzX2NyZWRfZWFwX21ldGhvZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgICAgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBDcmVkZW50aWFsL1VzZXJuYW1lUGFzc3dvcmQvRUFQTWV0aG9kIC0gVE9ETyIpOworfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF91c2VybmFtZV9wYXNzd29yZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkJICAgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKwljb25zdCBjaGFyICpuYW1lOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbC9Vc2VybmFtZVBhc3N3b3JkIik7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgtPnhtbCwgY2hpbGQsIG5vZGUpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIGNoaWxkKTsKKwkJaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlVzZXJuYW1lIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF91c2VybmFtZShjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlBhc3N3b3JkIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9wYXNzd29yZChjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIk1hY2hpbmVNYW5hZ2VkIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9tYWNoaW5lX21hbmFnZWQoY3R4LCBpZCwgY2hpbGQpOworCQllbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJTb2Z0VG9rZW5BcHAiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX3NvZnRfdG9rZW5fYXBwKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiQWJsZVRvU2hhcmUiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX2FibGVfdG9fc2hhcmUoY3R4LCBpZCwgY2hpbGQpOworCQllbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJFQVBNZXRob2QiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX2VhcF9tZXRob2QoY3R4LCBpZCwgY2hpbGQpOworCQllbHNlCisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVW5rbm93biBDcmVkZW50aWFsL1VzZXJuYW1lUGFzc3dvcmQgbm9kZSAnJXMnIiwKKwkJCQkgICBuYW1lKTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX2RpZ2l0YWxfY2VydChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCQkgICAgICB4bWxfbm9kZV90ICpub2RlLCBjb25zdCBjaGFyICpmcWRuKQoreworCWNoYXIgYnVmWzIwMF0sIGRpclsyMDBdOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbC9EaWdpdGFsQ2VydGlmaWNhdGUiKTsKKworCWlmIChnZXRjd2QoZGlyLCBzaXplb2YoZGlyKSkgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJLyogVE9ETzogY291bGQgYnVpbGQgdXNlcm5hbWUgZnJvbSBTdWJqZWN0IG9mIFN1YmplY3QgQWx0TmFtZSAqLworCWlmIChzZXRfY3JlZF9xdW90ZWQoY3R4LT5pZm5hbWUsIGlkLCAidXNlcm5hbWUiLCAiY2VydCIpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCB1c2VybmFtZSIpOworCX0KKworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICIlcy9TUC8lcy9jbGllbnQtY2VydC5wZW0iLCBkaXIsIGZxZG4pOworCWlmIChvc19maWxlX2V4aXN0cyhidWYpKSB7CisJCWlmIChzZXRfY3JlZF9xdW90ZWQoY3R4LT5pZm5hbWUsIGlkLCAiY2xpZW50X2NlcnQiLCBidWYpIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byBzZXQgY2xpZW50X2NlcnQiKTsKKwkJfQorCX0KKworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICIlcy9TUC8lcy9jbGllbnQta2V5LnBlbSIsIGRpciwgZnFkbik7CisJaWYgKG9zX2ZpbGVfZXhpc3RzKGJ1ZikpIHsKKwkJaWYgKHNldF9jcmVkX3F1b3RlZChjdHgtPmlmbmFtZSwgaWQsICJwcml2YXRlX2tleSIsIGJ1ZikgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBwcml2YXRlX2tleSIpOworCQl9CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZF9yZWFsbShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCSAgICAgICB4bWxfbm9kZV90ICpub2RlLCBjb25zdCBjaGFyICpmcWRuLCBpbnQgc2ltKQoreworCWNoYXIgKnN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwljaGFyIGJ1ZlsyMDBdLCBkaXJbMjAwXTsKKworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbC9SZWFsbSA9ICVzIiwgc3RyKTsKKwlpZiAoc2V0X2NyZWRfcXVvdGVkKGN0eC0+aWZuYW1lLCBpZCwgInJlYWxtIiwgc3RyKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgcmVhbG0iKTsKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdHIpOworCisJaWYgKHNpbSkKKwkJcmV0dXJuOworCisJaWYgKGdldGN3ZChkaXIsIHNpemVvZihkaXIpKSA9PSBOVUxMKQorCQlyZXR1cm47CisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiVzL1NQLyVzL2FhYS1jYS5wZW0iLCBkaXIsIGZxZG4pOworCWlmIChvc19maWxlX2V4aXN0cyhidWYpKSB7CisJCWlmIChzZXRfY3JlZF9xdW90ZWQoY3R4LT5pZm5hbWUsIGlkLCAiY2FfY2VydCIsIGJ1ZikgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBDQSBjZXJ0Iik7CisJCX0KKwl9Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX2NoZWNrX2FhYV9jZXJ0X3N0YXR1cyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJCSAgICAgICBpbnQgaWQsIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiLSBDcmVkZW50aWFsL0NoZWNrQUFBU2VydmVyQ2VydFN0YXR1cyA9ICVzIiwgc3RyKTsKKwlpZiAob3Nfc3RyY2FzZWNtcChzdHIsICJ0cnVlIikgPT0gMCAmJgorCSAgICBzZXRfY3JlZChjdHgtPmlmbmFtZSwgaWQsICJvY3NwIiwgIjIiKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gc2V0IGNyZWQgb2NzcCIpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHN0cik7Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX3NpbShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCSAgICAgeG1sX25vZGVfdCAqc2ltLCB4bWxfbm9kZV90ICpyZWFsbSkKK3sKKwl4bWxfbm9kZV90ICpub2RlOworCWNoYXIgKmltc2ksICplYXB0eXBlLCAqc3RyLCBidWZbMjBdOworCWludCB0eXBlOworCWludCBtbmNfbGVuID0gMzsKKwlzaXplX3QgaW1zaV9sZW47CisKKwlub2RlID0gZ2V0X25vZGUoY3R4LT54bWwsIHNpbSwgIkVBUFR5cGUiKTsKKwlpZiAobm9kZSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBTSU0vRUFQVHlwZSBub2RlIGluIGNyZWRlbnRpYWwiKTsKKwkJcmV0dXJuOworCX0KKwllYXB0eXBlID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChlYXB0eXBlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBleHRyYWN0IFNJTS9FQVBUeXBlIik7CisJCXJldHVybjsKKwl9CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIiAtIENyZWRlbnRpYWwvU0lNL0VBUFR5cGUgPSAlcyIsIGVhcHR5cGUpOworCXR5cGUgPSBhdG9pKGVhcHR5cGUpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGVhcHR5cGUpOworCisJc3dpdGNoICh0eXBlKSB7CisJY2FzZSBFQVBfVFlQRV9TSU06CisJCWlmIChzZXRfY3JlZChjdHgtPmlmbmFtZSwgaWQsICJlYXAiLCAiU0lNIikgPCAwKQorCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBzZXQgZWFwPVNJTSIpOworCQlicmVhazsKKwljYXNlIEVBUF9UWVBFX0FLQToKKwkJaWYgKHNldF9jcmVkKGN0eC0+aWZuYW1lLCBpZCwgImVhcCIsICJBS0EiKSA8IDApCisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHNldCBlYXA9U0lNIik7CisJCWJyZWFrOworCWNhc2UgRUFQX1RZUEVfQUtBX1BSSU1FOgorCQlpZiAoc2V0X2NyZWQoY3R4LT5pZm5hbWUsIGlkLCAiZWFwIiwgIkFLQSciKSA8IDApCisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHNldCBlYXA9U0lNIik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVbnN1cHBvcnRlZCBTSU0vRUFQVHlwZSAlZCIsIHR5cGUpOworCQlyZXR1cm47CisJfQorCisJbm9kZSA9IGdldF9ub2RlKGN0eC0+eG1sLCBzaW0sICJJTVNJIik7CisJaWYgKG5vZGUgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gU0lNL0lNU0kgbm9kZSBpbiBjcmVkZW50aWFsIik7CisJCXJldHVybjsKKwl9CisJaW1zaSA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBub2RlKTsKKwlpZiAoaW1zaSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgZXh0cmFjdCBTSU0vSU1TSSIpOworCQlyZXR1cm47CisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICIgLSBDcmVkZW50aWFsL1NJTS9JTVNJID0gJXMiLCBpbXNpKTsKKwlpbXNpX2xlbiA9IG9zX3N0cmxlbihpbXNpKTsKKwlpZiAoaW1zaV9sZW4gPCA3IHx8IGltc2lfbGVuICsgMiA+IHNpemVvZihidWYpKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbnZhbGlkIElNU0kgbGVuZ3RoIik7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGltc2kpOworCQlyZXR1cm47CisJfQorCisJc3RyID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCWlmIChzdHIpIHsKKwkJY2hhciAqcG9zOworCQlwb3MgPSBvc19zdHJzdHIoc3RyLCAibW5jIik7CisJCWlmIChwb3MgJiYgb3Nfc3RybGVuKHBvcykgPj0gNikgeworCQkJaWYgKG9zX3N0cm5jbXAoaW1zaSArIDMsIHBvcyArIDMsIDMpID09IDApCisJCQkJbW5jX2xlbiA9IDM7CisJCQllbHNlIGlmIChvc19zdHJuY21wKGltc2kgKyAzLCBwb3MgKyA0LCAyKSA9PSAwKQorCQkJCW1uY19sZW4gPSAyOworCQl9CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHN0cik7CisJfQorCisJb3NfbWVtY3B5KGJ1ZiwgaW1zaSwgMyArIG1uY19sZW4pOworCWJ1ZlszICsgbW5jX2xlbl0gPSAnLSc7CisJb3Nfc3RybGNweShidWYgKyAzICsgbW5jX2xlbiArIDEsIGltc2kgKyAzICsgbW5jX2xlbiwKKwkJICAgc2l6ZW9mKGJ1ZikgLSAzIC0gbW5jX2xlbiAtIDEpOworCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgaW1zaSk7CisKKwlpZiAoc2V0X2NyZWRfcXVvdGVkKGN0eC0+aWZuYW1lLCBpZCwgImltc2kiLCBidWYpIDwgMCkKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBzZXQgSU1TSSIpOworCisJaWYgKHNldF9jcmVkX3F1b3RlZChjdHgtPmlmbmFtZSwgaWQsICJtaWxlbmFnZSIsCisJCQkgICAgIjkwZGNhNGVkYTQ1YjUzY2YwZjEyZDdjOWMzYmM2YTg5OiIKKwkJCSAgICAiY2I5Y2NjYzRiOTI1OGU2ZGNhNDc2MDM3OWZiODI1ODE6MDAwMDAwMDAwMTIzIikgPAorCSAgICAwKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHNldCBNaWxlbmFnZSBwYXJhbWV0ZXJzIik7Cit9CisKKworc3RhdGljIHZvaWQgc2V0X3Bwc19jcmVkX2NyZWRlbnRpYWwoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBpbnQgaWQsCisJCQkJICAgIHhtbF9ub2RlX3QgKm5vZGUsIGNvbnN0IGNoYXIgKmZxZG4pCit7CisJeG1sX25vZGVfdCAqY2hpbGQsICpzaW0sICpyZWFsbTsKKwljb25zdCBjaGFyICpuYW1lOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gQ3JlZGVudGlhbCIpOworCisJc2ltID0gZ2V0X25vZGUoY3R4LT54bWwsIG5vZGUsICJTSU0iKTsKKwlyZWFsbSA9IGdldF9ub2RlKGN0eC0+eG1sLCBub2RlLCAiUmVhbG0iKTsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgbm9kZSkgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgtPnhtbCwgY2hpbGQpOworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgY2hpbGQpOworCQlpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiQ3JlYXRpb25EYXRlIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9jcmVhdGlvbl9kYXRlKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiRXhwaXJhdGlvbkRhdGUiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX2V4cGlyYXRpb25fZGF0ZShjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlVzZXJuYW1lUGFzc3dvcmQiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX3VzZXJuYW1lX3Bhc3N3b3JkKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiRGlnaXRhbENlcnRpZmljYXRlIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9kaWdpdGFsX2NlcnQoY3R4LCBpZCwgY2hpbGQsIGZxZG4pOworCQllbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJSZWFsbSIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfcmVhbG0oY3R4LCBpZCwgY2hpbGQsIGZxZG4sIHNpbSAhPSBOVUxMKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiQ2hlY2tBQUFTZXJ2ZXJDZXJ0U3RhdHVzIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9jaGVja19hYWFfY2VydF9zdGF0dXMoY3R4LCBpZCwgY2hpbGQpOworCQllbHNlIGlmIChvc19zdHJjYXNlY21wKG5hbWUsICJTSU0iKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX3NpbShjdHgsIGlkLCBjaGlsZCwgcmVhbG0pOworCQllbHNlCisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVW5rbm93biBDcmVkZW50aWFsIG5vZGUgJyVzJyIsCisJCQkJICAgbmFtZSk7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHNfY3JlZGVudGlhbChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGludCBpZCwKKwkJCSAgICAgICB4bWxfbm9kZV90ICpjcmVkLCBjb25zdCBjaGFyICpmcWRuKQoreworCXhtbF9ub2RlX3QgKmNoaWxkOworCWNvbnN0IGNoYXIgKm5hbWU7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgtPnhtbCwgY2hpbGQsIGNyZWQpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIGNoaWxkKTsKKwkJaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlBvbGljeSIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfcG9saWN5KGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiQ3JlZGVudGlhbFByaW9yaXR5IikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9wcmlvcml0eShjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIkFBQVNlcnZlclRydXN0Um9vdCIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfYWFhX3NlcnZlcl90cnVzdF9yb290KGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiU3Vic2NyaXB0aW9uVXBkYXRlIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9zdWJfdXBkYXRlKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiSG9tZVNQIikgPT0gMCkKKwkJCXNldF9wcHNfY3JlZF9ob21lX3NwKGN0eCwgaWQsIGNoaWxkKTsKKwkJZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChuYW1lLCAiU3Vic2NyaXB0aW9uUGFyYW1ldGVycyIpID09IDApCisJCQlzZXRfcHBzX2NyZWRfc3ViX3BhcmFtcyhjdHgsIGlkLCBjaGlsZCk7CisJCWVsc2UgaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIkNyZWRlbnRpYWwiKSA9PSAwKQorCQkJc2V0X3Bwc19jcmVkX2NyZWRlbnRpYWwoY3R4LCBpZCwgY2hpbGQsIGZxZG4pOworCQllbHNlCisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVW5rbm93biBjcmVkZW50aWFsIG5vZGUgJyVzJyIsCisJCQkJICAgbmFtZSk7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHNldF9wcHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpwcHMsCisJCSAgICBjb25zdCBjaGFyICpmcWRuKQoreworCXhtbF9ub2RlX3QgKmNoaWxkOworCWNvbnN0IGNoYXIgKm5hbWU7CisJaW50IGlkOworCWNoYXIgKnVwZGF0ZV9pZGVudGlmaWVyID0gTlVMTDsKKworCS8qCisJICogVE9ETzogQ291bGQgY29uc2lkZXIgbW9yZSBjb21wbGV4IG1lY2hhbmlzbSB0aGF0IHdvdWxkIHJlbW92ZQorCSAqIGNyZWRlbnRpYWxzIG9ubHkgaWYgdGhlcmUgYXJlIGNoYW5nZXMgaW4gdGhlIGluZm9ybWF0aW9uIHNlbnQgdG8KKwkgKiB3cGFfc3VwcGxpY2FudC4KKwkgKi8KKwlyZW1vdmVfc3BfY3JlZHMoY3R4LCBmcWRuKTsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgcHBzKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eC0+eG1sLCBjaGlsZCk7CisJCW5hbWUgPSB4bWxfbm9kZV9nZXRfbG9jYWxuYW1lKGN0eC0+eG1sLCBjaGlsZCk7CisJCWlmIChvc19zdHJjYXNlY21wKG5hbWUsICJVcGRhdGVJZGVudGlmaWVyIikgPT0gMCkgeworCQkJdXBkYXRlX2lkZW50aWZpZXIgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgY2hpbGQpOworCQkJaWYgKHVwZGF0ZV9pZGVudGlmaWVyKSB7CisJCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIi0gVXBkYXRlSWRlbnRpZmllciA9ICVzIiwKKwkJCQkJICAgdXBkYXRlX2lkZW50aWZpZXIpOworCQkJCWJyZWFrOworCQkJfQorCQl9CisJfQorCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LT54bWwsIGNoaWxkLCBwcHMpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIGNoaWxkKTsKKwkJaWYgKG9zX3N0cmNhc2VjbXAobmFtZSwgIlVwZGF0ZUlkZW50aWZpZXIiKSA9PSAwKQorCQkJY29udGludWU7CisJCWlkID0gYWRkX2NyZWQoY3R4LT5pZm5hbWUpOworCQlpZiAoaWQgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIGFkZCBjcmVkZW50aWFsIHRvIHdwYV9zdXBwbGljYW50Iik7CisJCQl3cml0ZV9zdW1tYXJ5KGN0eCwgIkZhaWxlZCB0byBhZGQgY3JlZGVudGlhbCB0byB3cGFfc3VwcGxpY2FudCIpOworCQkJYnJlYWs7CisJCX0KKwkJd3JpdGVfc3VtbWFyeShjdHgsICJBZGQgYSBjcmVkZW50aWFsIHRvIHdwYV9zdXBwbGljYW50Iik7CisJCWlmICh1cGRhdGVfaWRlbnRpZmllciAmJgorCQkgICAgc2V0X2NyZWQoY3R4LT5pZm5hbWUsIGlkLCAidXBkYXRlX2lkZW50aWZpZXIiLAorCQkJICAgICB1cGRhdGVfaWRlbnRpZmllcikgPCAwKQorCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byBzZXQgdXBkYXRlX2lkZW50aWZpZXIiKTsKKwkJaWYgKHNldF9jcmVkX3F1b3RlZChjdHgtPmlmbmFtZSwgaWQsICJwcm92aXNpb25pbmdfc3AiLCBmcWRuKSA8CisJCSAgICAwKQorCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byBzZXQgcHJvdmlzaW9uaW5nX3NwIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJjcmVkZW50aWFsIGxvY2FsbmFtZTogJyVzJyIsIG5hbWUpOworCQlzZXRfcHBzX2NyZWRlbnRpYWwoY3R4LCBpZCwgY2hpbGQsIGZxZG4pOworCQljdHgtPnBwc19jcmVkX3NldCA9IDE7CisJfQorCisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgdXBkYXRlX2lkZW50aWZpZXIpOworfQorCisKK3ZvaWQgY21kX3NldF9wcHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpwcHNfZm5hbWUpCit7CisJeG1sX25vZGVfdCAqcHBzOworCWNvbnN0IGNoYXIgKmZxZG47CisJY2hhciAqZnFkbl9idWYgPSBOVUxMLCAqcG9zOworCisJcHBzID0gbm9kZV9mcm9tX2ZpbGUoY3R4LT54bWwsIHBwc19mbmFtZSk7CisJaWYgKHBwcyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVhZCBvciBwYXJzZSAnJXMnIiwgcHBzX2ZuYW1lKTsKKwkJcmV0dXJuOworCX0KKworCWZxZG4gPSBvc19zdHJzdHIocHBzX2ZuYW1lLCAiU1AvIik7CisJaWYgKGZxZG4pIHsKKwkJZnFkbl9idWYgPSBvc19zdHJkdXAoZnFkbiArIDMpOworCQlpZiAoZnFkbl9idWYgPT0gTlVMTCkKKwkJCXJldHVybjsKKwkJcG9zID0gb3Nfc3RyY2hyKGZxZG5fYnVmLCAnLycpOworCQlpZiAocG9zKQorCQkJKnBvcyA9ICdcMCc7CisJCWZxZG4gPSBmcWRuX2J1ZjsKKwl9IGVsc2UKKwkJZnFkbiA9ICJ3aS1maS5vcmciOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNldCBQUFMgTU8gaW5mbyB0byB3cGFfc3VwcGxpY2FudCAtIFNQIEZRRE4gJXMiLAorCQkgICBmcWRuKTsKKwlzZXRfcHBzKGN0eCwgcHBzLCBmcWRuKTsKKworCW9zX2ZyZWUoZnFkbl9idWYpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7Cit9CisKKworc3RhdGljIGludCBjbWRfZ2V0X2ZxZG4oc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpwcHNfZm5hbWUpCit7CisJeG1sX25vZGVfdCAqcHBzLCAqbm9kZTsKKwljaGFyICpmcWRuID0gTlVMTDsKKworCXBwcyA9IG5vZGVfZnJvbV9maWxlKGN0eC0+eG1sLCBwcHNfZm5hbWUpOworCWlmIChwcHMgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHJlYWQgb3IgcGFyc2UgJyVzJyIsIHBwc19mbmFtZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlub2RlID0gZ2V0X2NoaWxkX25vZGUoY3R4LT54bWwsIHBwcywgIkhvbWVTUC9GUUROIik7CisJaWYgKG5vZGUpCisJCWZxZG4gPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBwcHMpOworCisJaWYgKGZxZG4pIHsKKwkJRklMRSAqZiA9IGZvcGVuKCJwcHMtZnFkbiIsICJ3Iik7CisJCWlmIChmKSB7CisJCQlmcHJpbnRmKGYsICIlcyIsIGZxZG4pOworCQkJZmNsb3NlKGYpOworCQl9CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGZxZG4pOworCQlyZXR1cm4gMDsKKwl9CisKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBmcWRuKTsKKwlyZXR1cm4gLTE7Cit9CisKKworc3RhdGljIHZvaWQgY21kX3RvX3RuZHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICppbl9mbmFtZSwKKwkJCWNvbnN0IGNoYXIgKm91dF9mbmFtZSwgY29uc3QgY2hhciAqdXJuLCBpbnQgdXNlX3BhdGgpCit7CisJeG1sX25vZGVfdCAqbW8sICpub2RlOworCisJbW8gPSBub2RlX2Zyb21fZmlsZShjdHgtPnhtbCwgaW5fZm5hbWUpOworCWlmIChtbyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVhZCBvciBwYXJzZSAnJXMnIiwgaW5fZm5hbWUpOworCQlyZXR1cm47CisJfQorCisJbm9kZSA9IG1vX3RvX3RuZHMoY3R4LT54bWwsIG1vLCB1c2VfcGF0aCwgdXJuLCBOVUxMKTsKKwlpZiAobm9kZSkgeworCQlub2RlX3RvX2ZpbGUoY3R4LT54bWwsIG91dF9mbmFtZSwgbm9kZSk7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIG5vZGUpOworCX0KKworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIG1vKTsKK30KKworCitzdGF0aWMgdm9pZCBjbWRfZnJvbV90bmRzKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqaW5fZm5hbWUsCisJCQkgIGNvbnN0IGNoYXIgKm91dF9mbmFtZSkKK3sKKwl4bWxfbm9kZV90ICp0bmRzLCAqbW87CisKKwl0bmRzID0gbm9kZV9mcm9tX2ZpbGUoY3R4LT54bWwsIGluX2ZuYW1lKTsKKwlpZiAodG5kcyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVhZCBvciBwYXJzZSAnJXMnIiwgaW5fZm5hbWUpOworCQlyZXR1cm47CisJfQorCisJbW8gPSB0bmRzX3RvX21vKGN0eC0+eG1sLCB0bmRzKTsKKwlpZiAobW8pIHsKKwkJbm9kZV90b19maWxlKGN0eC0+eG1sLCBvdXRfZm5hbWUsIG1vKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgbW8pOworCX0KKworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHRuZHMpOworfQorCisKK3N0cnVjdCBvc3VfaWNvbiB7CisJaW50IGlkOworCWNoYXIgbGFuZ1s0XTsKKwljaGFyIG1pbWVfdHlwZVsyNTZdOworCWNoYXIgZmlsZW5hbWVbMjU2XTsKK307CisKK3N0cnVjdCBvc3VfZGF0YSB7CisJY2hhciBic3NpZFsyMF07CisJY2hhciB1cmxbMjU2XTsKKwl1bnNpZ25lZCBpbnQgbWV0aG9kczsKKwljaGFyIG9zdV9zc2lkWzMzXTsKKwljaGFyIG9zdV9uYWlbMjU2XTsKKwlzdHJ1Y3Qgb3N1X2xhbmdfdGV4dCBmcmllbmRseV9uYW1lW01BWF9PU1VfVkFMU107CisJc2l6ZV90IGZyaWVuZGx5X25hbWVfY291bnQ7CisJc3RydWN0IG9zdV9sYW5nX3RleHQgc2Vydl9kZXNjW01BWF9PU1VfVkFMU107CisJc2l6ZV90IHNlcnZfZGVzY19jb3VudDsKKwlzdHJ1Y3Qgb3N1X2ljb24gaWNvbltNQVhfT1NVX1ZBTFNdOworCXNpemVfdCBpY29uX2NvdW50OworfTsKKworCitzdGF0aWMgc3RydWN0IG9zdV9kYXRhICogcGFyc2Vfb3N1X3Byb3ZpZGVycyhjb25zdCBjaGFyICpmbmFtZSwgc2l6ZV90ICpjb3VudCkKK3sKKwlGSUxFICpmOworCWNoYXIgYnVmWzEwMDBdOworCXN0cnVjdCBvc3VfZGF0YSAqb3N1ID0gTlVMTCwgKmxhc3QgPSBOVUxMOworCXNpemVfdCBvc3VfY291bnQgPSAwOworCWNoYXIgKnBvcywgKmVuZDsKKworCWYgPSBmb3BlbihmbmFtZSwgInIiKTsKKwlpZiAoZiA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ291bGQgbm90IG9wZW4gJXMiLCBmbmFtZSk7CisJCXJldHVybiBOVUxMOworCX0KKworCXdoaWxlIChmZ2V0cyhidWYsIHNpemVvZihidWYpLCBmKSkgeworCQlwb3MgPSBzdHJjaHIoYnVmLCAnXG4nKTsKKwkJaWYgKHBvcykKKwkJCSpwb3MgPSAnXDAnOworCisJCWlmIChzdHJuY21wKGJ1ZiwgIk9TVS1QUk9WSURFUiAiLCAxMykgPT0gMCkgeworCQkJbGFzdCA9IHJlYWxsb2Mob3N1LCAob3N1X2NvdW50ICsgMSkgKiBzaXplb2YoKm9zdSkpOworCQkJaWYgKGxhc3QgPT0gTlVMTCkKKwkJCQlicmVhazsKKwkJCW9zdSA9IGxhc3Q7CisJCQlsYXN0ID0gJm9zdVtvc3VfY291bnQrK107CisJCQltZW1zZXQobGFzdCwgMCwgc2l6ZW9mKCpsYXN0KSk7CisJCQlzbnByaW50ZihsYXN0LT5ic3NpZCwgc2l6ZW9mKGxhc3QtPmJzc2lkKSwgIiVzIiwKKwkJCQkgYnVmICsgMTMpOworCQkJY29udGludWU7CisJCX0KKwkJaWYgKCFsYXN0KQorCQkJY29udGludWU7CisKKwkJaWYgKHN0cm5jbXAoYnVmLCAidXJpPSIsIDQpID09IDApIHsKKwkJCXNucHJpbnRmKGxhc3QtPnVybCwgc2l6ZW9mKGxhc3QtPnVybCksICIlcyIsIGJ1ZiArIDQpOworCQkJY29udGludWU7CisJCX0KKworCQlpZiAoc3RybmNtcChidWYsICJtZXRob2RzPSIsIDgpID09IDApIHsKKwkJCWxhc3QtPm1ldGhvZHMgPSBzdHJ0b2woYnVmICsgOCwgTlVMTCwgMTYpOworCQkJY29udGludWU7CisJCX0KKworCQlpZiAoc3RybmNtcChidWYsICJvc3Vfc3NpZD0iLCA5KSA9PSAwKSB7CisJCQlzbnByaW50ZihsYXN0LT5vc3Vfc3NpZCwgc2l6ZW9mKGxhc3QtPm9zdV9zc2lkKSwKKwkJCQkgIiVzIiwgYnVmICsgOSk7CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmIChvc19zdHJuY21wKGJ1ZiwgIm9zdV9uYWk9IiwgOCkgPT0gMCkgeworCQkJb3Nfc25wcmludGYobGFzdC0+b3N1X25haSwgc2l6ZW9mKGxhc3QtPm9zdV9uYWkpLAorCQkJCSAgICAiJXMiLCBidWYgKyA4KTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJaWYgKHN0cm5jbXAoYnVmLCAiZnJpZW5kbHlfbmFtZT0iLCAxNCkgPT0gMCkgeworCQkJc3RydWN0IG9zdV9sYW5nX3RleHQgKnR4dDsKKwkJCWlmIChsYXN0LT5mcmllbmRseV9uYW1lX2NvdW50ID09IE1BWF9PU1VfVkFMUykKKwkJCQljb250aW51ZTsKKwkJCXBvcyA9IHN0cmNocihidWYgKyAxNCwgJzonKTsKKwkJCWlmIChwb3MgPT0gTlVMTCkKKwkJCQljb250aW51ZTsKKwkJCSpwb3MrKyA9ICdcMCc7CisJCQl0eHQgPSAmbGFzdC0+ZnJpZW5kbHlfbmFtZVtsYXN0LT5mcmllbmRseV9uYW1lX2NvdW50KytdOworCQkJc25wcmludGYodHh0LT5sYW5nLCBzaXplb2YodHh0LT5sYW5nKSwgIiVzIiwgYnVmICsgMTQpOworCQkJc25wcmludGYodHh0LT50ZXh0LCBzaXplb2YodHh0LT50ZXh0KSwgIiVzIiwgcG9zKTsKKwkJfQorCisJCWlmIChzdHJuY21wKGJ1ZiwgImRlc2M9IiwgNSkgPT0gMCkgeworCQkJc3RydWN0IG9zdV9sYW5nX3RleHQgKnR4dDsKKwkJCWlmIChsYXN0LT5zZXJ2X2Rlc2NfY291bnQgPT0gTUFYX09TVV9WQUxTKQorCQkJCWNvbnRpbnVlOworCQkJcG9zID0gc3RyY2hyKGJ1ZiArIDUsICc6Jyk7CisJCQlpZiAocG9zID09IE5VTEwpCisJCQkJY29udGludWU7CisJCQkqcG9zKysgPSAnXDAnOworCQkJdHh0ID0gJmxhc3QtPnNlcnZfZGVzY1tsYXN0LT5zZXJ2X2Rlc2NfY291bnQrK107CisJCQlzbnByaW50Zih0eHQtPmxhbmcsIHNpemVvZih0eHQtPmxhbmcpLCAiJXMiLCBidWYgKyA1KTsKKwkJCXNucHJpbnRmKHR4dC0+dGV4dCwgc2l6ZW9mKHR4dC0+dGV4dCksICIlcyIsIHBvcyk7CisJCX0KKworCQlpZiAoc3RybmNtcChidWYsICJpY29uPSIsIDUpID09IDApIHsKKwkJCXN0cnVjdCBvc3VfaWNvbiAqaWNvbjsKKwkJCWlmIChsYXN0LT5pY29uX2NvdW50ID09IE1BWF9PU1VfVkFMUykKKwkJCQljb250aW51ZTsKKwkJCWljb24gPSAmbGFzdC0+aWNvbltsYXN0LT5pY29uX2NvdW50KytdOworCQkJaWNvbi0+aWQgPSBhdG9pKGJ1ZiArIDUpOworCQkJcG9zID0gc3RyY2hyKGJ1ZiwgJzonKTsKKwkJCWlmIChwb3MgPT0gTlVMTCkKKwkJCQljb250aW51ZTsKKwkJCXBvcyA9IHN0cmNocihwb3MgKyAxLCAnOicpOworCQkJaWYgKHBvcyA9PSBOVUxMKQorCQkJCWNvbnRpbnVlOworCQkJcG9zID0gc3RyY2hyKHBvcyArIDEsICc6Jyk7CisJCQlpZiAocG9zID09IE5VTEwpCisJCQkJY29udGludWU7CisJCQlwb3MrKzsKKwkJCWVuZCA9IHN0cmNocihwb3MsICc6Jyk7CisJCQlpZiAoIWVuZCkKKwkJCQljb250aW51ZTsKKwkJCSplbmQgPSAnXDAnOworCQkJc25wcmludGYoaWNvbi0+bGFuZywgc2l6ZW9mKGljb24tPmxhbmcpLCAiJXMiLCBwb3MpOworCQkJcG9zID0gZW5kICsgMTsKKworCQkJZW5kID0gc3RyY2hyKHBvcywgJzonKTsKKwkJCWlmIChlbmQpCisJCQkJKmVuZCA9ICdcMCc7CisJCQlzbnByaW50ZihpY29uLT5taW1lX3R5cGUsIHNpemVvZihpY29uLT5taW1lX3R5cGUpLAorCQkJCSAiJXMiLCBwb3MpOworCQkJaWYgKCFwb3MpCisJCQkJY29udGludWU7CisJCQlwb3MgPSBlbmQgKyAxOworCisJCQllbmQgPSBzdHJjaHIocG9zLCAnOicpOworCQkJaWYgKGVuZCkKKwkJCQkqZW5kID0gJ1wwJzsKKwkJCXNucHJpbnRmKGljb24tPmZpbGVuYW1lLCBzaXplb2YoaWNvbi0+ZmlsZW5hbWUpLAorCQkJCSAiJXMiLCBwb3MpOworCQkJY29udGludWU7CisJCX0KKwl9CisKKwlmY2xvc2UoZik7CisKKwkqY291bnQgPSBvc3VfY291bnQ7CisJcmV0dXJuIG9zdTsKK30KKworCitzdGF0aWMgaW50IG9zdV9jb25uZWN0KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqYnNzaWQsCisJCSAgICAgICBjb25zdCBjaGFyICpzc2lkLCBjb25zdCBjaGFyICp1cmwsCisJCSAgICAgICB1bnNpZ25lZCBpbnQgbWV0aG9kcywgaW50IG5vX3Byb2RfYXNzb2MsCisJCSAgICAgICBjb25zdCBjaGFyICpvc3VfbmFpKQoreworCWludCBpZDsKKwljb25zdCBjaGFyICppZm5hbWUgPSBjdHgtPmlmbmFtZTsKKwljaGFyIGJ1ZlsyMDBdOworCXN0cnVjdCB3cGFfY3RybCAqbW9uOworCWludCByZXM7CisKKwlpZCA9IGFkZF9uZXR3b3JrKGlmbmFtZSk7CisJaWYgKGlkIDwgMCkKKwkJcmV0dXJuIC0xOworCWlmIChzZXRfbmV0d29ya19xdW90ZWQoaWZuYW1lLCBpZCwgInNzaWQiLCBzc2lkKSA8IDApCisJCXJldHVybiAtMTsKKwlpZiAob3N1X25haSAmJiBvc19zdHJsZW4ob3N1X25haSkgPiAwKSB7CisJCWNoYXIgZGlyWzI1NV0sIGZuYW1lWzMwMF07CisJCWlmIChnZXRjd2QoZGlyLCBzaXplb2YoZGlyKSkgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJb3Nfc25wcmludGYoZm5hbWUsIHNpemVvZihmbmFtZSksICIlcy9vc3UtY2EucGVtIiwgZGlyKTsKKworCQlpZiAoc2V0X25ldHdvcmsoaWZuYW1lLCBpZCwgInByb3RvIiwgIk9TRU4iKSA8IDAgfHwKKwkJICAgIHNldF9uZXR3b3JrKGlmbmFtZSwgaWQsICJrZXlfbWdtdCIsICJPU0VOIikgPCAwIHx8CisJCSAgICBzZXRfbmV0d29yayhpZm5hbWUsIGlkLCAicGFpcndpc2UiLCAiQ0NNUCIpIDwgMCB8fAorCQkgICAgc2V0X25ldHdvcmsoaWZuYW1lLCBpZCwgImdyb3VwIiwgIkdUS19OT1RfVVNFRCIpIDwgMCB8fAorCQkgICAgc2V0X25ldHdvcmsoaWZuYW1lLCBpZCwgImVhcCIsICJXRkEtVU5BVVRILVRMUyIpIDwgMCB8fAorCQkgICAgc2V0X25ldHdvcmsoaWZuYW1lLCBpZCwgIm9jc3AiLCAiMiIpIDwgMCB8fAorCQkgICAgc2V0X25ldHdvcmtfcXVvdGVkKGlmbmFtZSwgaWQsICJpZGVudGl0eSIsIG9zdV9uYWkpIDwgMCB8fAorCQkgICAgc2V0X25ldHdvcmtfcXVvdGVkKGlmbmFtZSwgaWQsICJjYV9jZXJ0IiwgZm5hbWUpIDwgMCkKKwkJCXJldHVybiAtMTsKKwl9IGVsc2UgeworCQlpZiAoc2V0X25ldHdvcmsoaWZuYW1lLCBpZCwgImtleV9tZ210IiwgIk5PTkUiKSA8IDApCisJCQlyZXR1cm4gLTE7CisJfQorCisJbW9uID0gb3Blbl93cGFfbW9uKGlmbmFtZSk7CisJaWYgKG1vbiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQXNzb2NpYXRlIHdpdGggT1NVIFNTSUQiKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIkFzc29jaWF0ZSB3aXRoIE9TVSBTU0lEIik7CisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIlNFTEVDVF9ORVRXT1JLICVkIiwgaWQpOworCWlmICh3cGFfY29tbWFuZChpZm5hbWUsIGJ1ZikgPCAwKQorCQlyZXR1cm4gLTE7CisKKwlyZXMgPSBnZXRfd3BhX2NsaV9ldmVudChtb24sICJDVFJMLUVWRU5ULUNPTk5FQ1RFRCIsCisJCQkJYnVmLCBzaXplb2YoYnVmKSk7CisKKwl3cGFfY3RybF9kZXRhY2gobW9uKTsKKwl3cGFfY3RybF9jbG9zZShtb24pOworCisJaWYgKHJlcyA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBjb25uZWN0Iik7CisJCXdyaXRlX3N1bW1hcnkoY3R4LCAiQ291bGQgbm90IGNvbm5lY3QgdG8gT1NVIG5ldHdvcmsiKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlbW92ZSBPU1UgbmV0d29yayBjb25uZWN0aW9uIik7CisJCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJSRU1PVkVfTkVUV09SSyAlZCIsIGlkKTsKKwkJd3BhX2NvbW1hbmQoaWZuYW1lLCBidWYpOworCQlyZXR1cm4gLTE7CisJfQorCisJd3JpdGVfc3VtbWFyeShjdHgsICJXYWl0aW5nIGZvciBJUCBhZGRyZXNzIGZvciBzdWJzY3JpcHRpb24gcmVnaXN0cmF0aW9uIik7CisJaWYgKHdhaXRfaXBfYWRkcihpZm5hbWUsIDE1KSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBnZXQgSVAgYWRkcmVzcyBmb3IgV0xBTiAtIHRyeSBjb25uZWN0aW9uIGFueXdheSIpOworCX0KKworCWlmIChub19wcm9kX2Fzc29jKSB7CisJCWlmIChyZXMgPCAwKQorCQkJcmV0dXJuIC0xOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gcHJvZHVjdGlvbiBjb25uZWN0aW9uIHVzZWQgZm9yIHRlc3RpbmcgcHVycG9zZXMiKTsKKwkJd3JpdGVfc3VtbWFyeShjdHgsICJObyBwcm9kdWN0aW9uIGNvbm5lY3Rpb24gdXNlZCBmb3IgdGVzdGluZyBwdXJwb3NlcyIpOworCQlyZXR1cm4gMDsKKwl9CisKKwljdHgtPm5vX3JlY29ubmVjdCA9IDE7CisJaWYgKG1ldGhvZHMgJiAweDAyKQorCQlyZXMgPSBjbWRfcHJvdihjdHgsIHVybCk7CisJZWxzZSBpZiAobWV0aG9kcyAmIDB4MDEpCisJCXJlcyA9IGNtZF9vbWFfZG1fcHJvdihjdHgsIHVybCk7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVtb3ZlIE9TVSBuZXR3b3JrIGNvbm5lY3Rpb24iKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIlJlbW92ZSBPU1UgbmV0d29yayBjb25uZWN0aW9uIik7CisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIlJFTU9WRV9ORVRXT1JLICVkIiwgaWQpOworCXdwYV9jb21tYW5kKGlmbmFtZSwgYnVmKTsKKworCWlmIChyZXMgPCAwKQorCQlyZXR1cm4gLTE7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVxdWVzdGluZyByZWNvbm5lY3Rpb24gd2l0aCB1cGRhdGVkIGNvbmZpZ3VyYXRpb24iKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIlJlcXVlc3RpbmcgcmVjb25uZWN0aW9uIHdpdGggdXBkYXRlZCBjb25maWd1cmF0aW9uIik7CisJaWYgKHdwYV9jb21tYW5kKGN0eC0+aWZuYW1lLCAiSU5URVJXT1JLSU5HX1NFTEVDVCBhdXRvIikgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gcmVxdWVzdCB3cGFfc3VwcGxpY2FudCB0byByZWNvbm5lY3QiKTsKKwkJd3JpdGVfc3VtbWFyeShjdHgsICJGYWlsZWQgdG8gcmVxdWVzdCB3cGFfc3VwcGxpY2FudCB0byByZWNvbm5lY3QiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgY21kX29zdV9zZWxlY3Qoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpkaXIsCisJCQkgIGludCBjb25uZWN0LCBpbnQgbm9fcHJvZF9hc3NvYywKKwkJCSAgY29uc3QgY2hhciAqZnJpZW5kbHlfbmFtZSkKK3sKKwljaGFyIGZuYW1lWzI1NV07CisJRklMRSAqZjsKKwlzdHJ1Y3Qgb3N1X2RhdGEgKm9zdSA9IE5VTEwsICpsYXN0ID0gTlVMTDsKKwlzaXplX3Qgb3N1X2NvdW50LCBpLCBqOworCWludCByZXQ7CisKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIk9TVSBwcm92aWRlciBzZWxlY3Rpb24iKTsKKworCWlmIChkaXIgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTWlzc2luZyBkaXIgcGFyYW1ldGVyIHRvIG9zdV9zZWxlY3QiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXNucHJpbnRmKGZuYW1lLCBzaXplb2YoZm5hbWUpLCAiJXMvb3N1LXByb3ZpZGVycy50eHQiLCBkaXIpOworCW9zdSA9IHBhcnNlX29zdV9wcm92aWRlcnMoZm5hbWUsICZvc3VfY291bnQpOworCWlmIChvc3UgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFueSBPU1UgcHJvdmlkZXJzIGZyb20gJXMiLAorCQkJICAgZm5hbWUpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiTm8gT1NVIHByb3ZpZGVycyBhdmFpbGFibGUiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChmcmllbmRseV9uYW1lKSB7CisJCWZvciAoaSA9IDA7IGkgPCBvc3VfY291bnQ7IGkrKykgeworCQkJbGFzdCA9ICZvc3VbaV07CisJCQlmb3IgKGogPSAwOyBqIDwgbGFzdC0+ZnJpZW5kbHlfbmFtZV9jb3VudDsgaisrKSB7CisJCQkJaWYgKG9zX3N0cmNtcChsYXN0LT5mcmllbmRseV9uYW1lW2pdLnRleHQsCisJCQkJCSAgICAgIGZyaWVuZGx5X25hbWUpID09IDApCisJCQkJCWJyZWFrOworCQkJfQorCQkJaWYgKGogPCBsYXN0LT5mcmllbmRseV9uYW1lX2NvdW50KQorCQkJCWJyZWFrOworCQl9CisJCWlmIChpID09IG9zdV9jb3VudCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlcXVlc3RlZCBvcGVyYXRvciBmcmllbmRseSBuYW1lICclcycgbm90IGZvdW5kIGluIHRoZSBsaXN0IG9mIGF2YWlsYWJsZSBwcm92aWRlcnMiLAorCQkJCSAgIGZyaWVuZGx5X25hbWUpOworCQkJd3JpdGVfc3VtbWFyeShjdHgsICJSZXF1ZXN0ZWQgb3BlcmF0b3IgZnJpZW5kbHkgbmFtZSAnJXMnIG5vdCBmb3VuZCBpbiB0aGUgbGlzdCBvZiBhdmFpbGFibGUgcHJvdmlkZXJzIiwKKwkJCQkgICAgICBmcmllbmRseV9uYW1lKTsKKwkJCWZyZWUob3N1KTsKKwkJCXJldHVybiAtMTsKKwkJfQorCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJPU1UgUHJvdmlkZXIgc2VsZWN0ZWQgYmFzZWQgb24gcmVxdWVzdGVkIG9wZXJhdG9yIGZyaWVuZGx5IG5hbWUgJyVzJyIsCisJCQkgICBmcmllbmRseV9uYW1lKTsKKwkJd3JpdGVfc3VtbWFyeShjdHgsICJPU1UgUHJvdmlkZXIgc2VsZWN0ZWQgYmFzZWQgb24gcmVxdWVzdGVkIG9wZXJhdG9yIGZyaWVuZGx5IG5hbWUgJyVzJyIsCisJCQkgICAgICBmcmllbmRseV9uYW1lKTsKKwkJcmV0ID0gaSArIDE7CisJCWdvdG8gc2VsZWN0ZWQ7CisJfQorCisJc25wcmludGYoZm5hbWUsIHNpemVvZihmbmFtZSksICIlcy9vc3UtcHJvdmlkZXJzLmh0bWwiLCBkaXIpOworCWYgPSBmb3BlbihmbmFtZSwgInciKTsKKwlpZiAoZiA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3Qgb3BlbiAlcyIsIGZuYW1lKTsKKwkJZnJlZShvc3UpOworCQlyZXR1cm4gLTE7CisJfQorCisJZnByaW50ZihmLCAiPGh0bWw+PGhlYWQ+IgorCQkiPG1ldGEgaHR0cC1lcXVpdj1cIkNvbnRlbnQtdHlwZVwiIGNvbnRlbnQ9XCJ0ZXh0L2h0bWw7ICIKKwkJImNoYXJzZXQ9dXRmLThcIjx0aXRsZT5TZWxlY3Qgc2VydmljZSBvcGVyYXRvcjwvdGl0bGU+IgorCQkiPC9oZWFkPjxib2R5PjxoMT5TZWxlY3Qgc2VydmljZSBvcGVyYXRvcjwvaDE+XG4iKTsKKworCWlmIChvc3VfY291bnQgPT0gMCkKKwkJZnByaW50ZihmLCAiTm8gb25saW5lIHNpZ251cCBhdmFpbGFibGVcbiIpOworCisJZm9yIChpID0gMDsgaSA8IG9zdV9jb3VudDsgaSsrKSB7CisJCWxhc3QgPSAmb3N1W2ldOworI2lmZGVmIEFORFJPSUQKKwkJZnByaW50ZihmLCAiPHA+XG4iCisJCQkiPGEgaHJlZj1cImh0dHA6Ly9sb2NhbGhvc3Q6MTIzNDUvb3N1LyVkXCI+IgorCQkJIjx0YWJsZT48dHI+PHRkPiIsIChpbnQpIGkgKyAxKTsKKyNlbHNlIC8qIEFORFJPSUQgKi8KKwkJZnByaW50ZihmLCAiPHA+XG4iCisJCQkiPGEgaHJlZj1cIm9zdTovLyVkXCI+IgorCQkJIjx0YWJsZT48dHI+PHRkPiIsIChpbnQpIGkgKyAxKTsKKyNlbmRpZiAvKiBBTkRST0lEICovCisJCWZvciAoaiA9IDA7IGogPCBsYXN0LT5pY29uX2NvdW50OyBqKyspIHsKKwkJCWZwcmludGYoZiwgIjxpbWcgc3JjPVwib3N1LWljb24tJWQuJXNcIj5cbiIsCisJCQkJbGFzdC0+aWNvbltqXS5pZCwKKwkJCQlzdHJjYXNlY21wKGxhc3QtPmljb25bal0ubWltZV90eXBlLAorCQkJCQkgICAiaW1hZ2UvcG5nIikgPT0gMCA/ICJwbmciIDogImljb24iKTsKKwkJfQorCQlmcHJpbnRmKGYsICI8dGQ+Iik7CisJCWZvciAoaiA9IDA7IGogPCBsYXN0LT5mcmllbmRseV9uYW1lX2NvdW50OyBqKyspIHsKKwkJCWZwcmludGYoZiwgIjxzbWFsbD5bJXNdPC9zbWFsbD4gJXM8YnI+XG4iLAorCQkJCWxhc3QtPmZyaWVuZGx5X25hbWVbal0ubGFuZywKKwkJCQlsYXN0LT5mcmllbmRseV9uYW1lW2pdLnRleHQpOworCQl9CisJCWZwcmludGYoZiwgIjx0cj48dGQgY29sc3Bhbj0yPiIpOworCQlmb3IgKGogPSAwOyBqIDwgbGFzdC0+c2Vydl9kZXNjX2NvdW50OyBqKyspIHsKKwkJCWZwcmludGYoZiwgIjxzbWFsbD5bJXNdPC9zbWFsbD4gJXM8YnI+XG4iLAorCQkJCWxhc3QtPnNlcnZfZGVzY1tqXS5sYW5nLAorCQkJCWxhc3QtPnNlcnZfZGVzY1tqXS50ZXh0KTsKKwkJfQorCQlmcHJpbnRmKGYsICI8L3RhYmxlPjwvYT48YnI+PHNtYWxsPkJTU0lEOiAlczxicj5cbiIKKwkJCSJTU0lEOiAlczxicj5cbiIsCisJCQlsYXN0LT5ic3NpZCwgbGFzdC0+b3N1X3NzaWQpOworCQlpZiAobGFzdC0+b3N1X25haSkKKwkJCWZwcmludGYoZiwgIk5BSTogJXM8YnI+XG4iLCBsYXN0LT5vc3VfbmFpKTsKKwkJZnByaW50ZihmLCAiVVJMOiAlczxicj5cbiIKKwkJCSJtZXRob2RzOiVzJXM8YnI+XG4iCisJCQkiPC9zbWFsbD48L3A+XG4iLAorCQkJbGFzdC0+dXJsLAorCQkJbGFzdC0+bWV0aG9kcyAmIDB4MDEgPyAiIE9NQS1ETSIgOiAiIiwKKwkJCWxhc3QtPm1ldGhvZHMgJiAweDAyID8gIiBTT0FQLVhNTC1TUFAiIDogIiIpOworCX0KKworCWZwcmludGYoZiwgIjwvYm9keT48L2h0bWw+XG4iKTsKKworCWZjbG9zZShmKTsKKworCXNucHJpbnRmKGZuYW1lLCBzaXplb2YoZm5hbWUpLCAiZmlsZTovLyVzL29zdS1wcm92aWRlcnMuaHRtbCIsIGRpcik7CisJd3JpdGVfc3VtbWFyeShjdHgsICJTdGFydCB3ZWIgYnJvd3NlciB3aXRoIE9TVSBwcm92aWRlciBzZWxlY3Rpb24gcGFnZSIpOworCXJldCA9IGhzMjBfd2ViX2Jyb3dzZXIoZm5hbWUpOworCitzZWxlY3RlZDoKKwlpZiAocmV0ID4gMCAmJiAoc2l6ZV90KSByZXQgPD0gb3N1X2NvdW50KSB7CisJCWNoYXIgKmRhdGE7CisJCXNpemVfdCBkYXRhX2xlbjsKKworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU2VsZWN0ZWQgT1NVIGlkPSVkIiwgcmV0KTsKKwkJbGFzdCA9ICZvc3VbcmV0IC0gMV07CisJCXJldCA9IDA7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJCU1NJRDogJXMiLCBsYXN0LT5ic3NpZCk7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJTU0lEOiAlcyIsIGxhc3QtPm9zdV9zc2lkKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVSTDogJXMiLCBsYXN0LT51cmwpOworCQl3cml0ZV9zdW1tYXJ5KGN0eCwgIlNlbGVjdGVkIE9TVSBwcm92aWRlciBpZD0lZCBCU1NJRD0lcyBTU0lEPSVzIFVSTD0lcyIsCisJCQkgICAgICByZXQsIGxhc3QtPmJzc2lkLCBsYXN0LT5vc3Vfc3NpZCwgbGFzdC0+dXJsKTsKKworCQljdHgtPmZyaWVuZGx5X25hbWVfY291bnQgPSBsYXN0LT5mcmllbmRseV9uYW1lX2NvdW50OworCQlmb3IgKGogPSAwOyBqIDwgbGFzdC0+ZnJpZW5kbHlfbmFtZV9jb3VudDsgaisrKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRlJJRU5ETFlfTkFNRTogWyVzXSVzIiwKKwkJCQkgICBsYXN0LT5mcmllbmRseV9uYW1lW2pdLmxhbmcsCisJCQkJICAgbGFzdC0+ZnJpZW5kbHlfbmFtZVtqXS50ZXh0KTsKKwkJCW9zX3N0cmxjcHkoY3R4LT5mcmllbmRseV9uYW1lW2pdLmxhbmcsCisJCQkJICAgbGFzdC0+ZnJpZW5kbHlfbmFtZVtqXS5sYW5nLAorCQkJCSAgIHNpemVvZihjdHgtPmZyaWVuZGx5X25hbWVbal0ubGFuZykpOworCQkJb3Nfc3RybGNweShjdHgtPmZyaWVuZGx5X25hbWVbal0udGV4dCwKKwkJCQkgICBsYXN0LT5mcmllbmRseV9uYW1lW2pdLnRleHQsCisJCQkJICAgc2l6ZW9mKGN0eC0+ZnJpZW5kbHlfbmFtZVtqXS50ZXh0KSk7CisJCX0KKworCQljdHgtPmljb25fY291bnQgPSBsYXN0LT5pY29uX2NvdW50OworCQlmb3IgKGogPSAwOyBqIDwgbGFzdC0+aWNvbl9jb3VudDsgaisrKSB7CisJCQljaGFyIGZuYW1lWzI1Nl07CisKKwkJCW9zX3NucHJpbnRmKGZuYW1lLCBzaXplb2YoZm5hbWUpLCAiJXMvb3N1LWljb24tJWQuJXMiLAorCQkJCSAgICBkaXIsIGxhc3QtPmljb25bal0uaWQsCisJCQkJICAgIHN0cmNhc2VjbXAobGFzdC0+aWNvbltqXS5taW1lX3R5cGUsCisJCQkJCSAgICAgICAiaW1hZ2UvcG5nIikgPT0gMCA/CisJCQkJICAgICJwbmciIDogImljb24iKTsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJJQ09OOiAlcyAoJXMpIiwKKwkJCQkgICBmbmFtZSwgbGFzdC0+aWNvbltqXS5maWxlbmFtZSk7CisJCQlvc19zdHJsY3B5KGN0eC0+aWNvbl9maWxlbmFtZVtqXSwKKwkJCQkgICBsYXN0LT5pY29uW2pdLmZpbGVuYW1lLAorCQkJCSAgIHNpemVvZihjdHgtPmljb25fZmlsZW5hbWVbal0pKTsKKworCQkJZGF0YSA9IG9zX3JlYWRmaWxlKGZuYW1lLCAmZGF0YV9sZW4pOworCQkJaWYgKGRhdGEpIHsKKwkJCQlzaGEyNTZfdmVjdG9yKDEsIChjb25zdCB1OCAqKikgJmRhdGEsICZkYXRhX2xlbiwKKwkJCQkJICAgICAgY3R4LT5pY29uX2hhc2hbal0pOworCQkJCW9zX2ZyZWUoZGF0YSk7CisJCQl9CisJCX0KKworCQlpZiAoY29ubmVjdCA9PSAyKSB7CisJCQlpZiAobGFzdC0+bWV0aG9kcyAmIDB4MDIpCisJCQkJcmV0ID0gY21kX3Byb3YoY3R4LCBsYXN0LT51cmwpOworCQkJZWxzZSBpZiAobGFzdC0+bWV0aG9kcyAmIDB4MDEpCisJCQkJcmV0ID0gY21kX29tYV9kbV9wcm92KGN0eCwgbGFzdC0+dXJsKTsKKwkJCWVsc2UKKwkJCQlyZXQgPSAtMTsKKwkJfSBlbHNlIGlmIChjb25uZWN0KQorCQkJcmV0ID0gb3N1X2Nvbm5lY3QoY3R4LCBsYXN0LT5ic3NpZCwgbGFzdC0+b3N1X3NzaWQsCisJCQkJCSAgbGFzdC0+dXJsLCBsYXN0LT5tZXRob2RzLAorCQkJCQkgIG5vX3Byb2RfYXNzb2MsIGxhc3QtPm9zdV9uYWkpOworCX0gZWxzZQorCQlyZXQgPSAtMTsKKworCWZyZWUob3N1KTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBjbWRfc2lnbnVwKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgaW50IG5vX3Byb2RfYXNzb2MsCisJCSAgICAgIGNvbnN0IGNoYXIgKmZyaWVuZGx5X25hbWUpCit7CisJY2hhciBkaXJbMjU1XTsKKwljaGFyIGZuYW1lWzMwMF0sIGJ1Zls0MDBdOworCXN0cnVjdCB3cGFfY3RybCAqbW9uOworCWNvbnN0IGNoYXIgKmlmbmFtZTsKKwlpbnQgcmVzOworCisJaWZuYW1lID0gY3R4LT5pZm5hbWU7CisKKwlpZiAoZ2V0Y3dkKGRpciwgc2l6ZW9mKGRpcikpID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXNucHJpbnRmKGZuYW1lLCBzaXplb2YoZm5hbWUpLCAiJXMvb3N1LWluZm8iLCBkaXIpOworCWlmIChta2RpcihmbmFtZSwgU19JUldYVSB8IFNfSVJXWEcpIDwgMCAmJiBlcnJubyAhPSBFRVhJU1QpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIm1rZGlyKCVzKSBmYWlsZWQ6ICVzIiwKKwkJCSAgIGZuYW1lLCBzdHJlcnJvcihlcnJubykpOworCQlyZXR1cm4gLTE7CisJfQorCisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIlNFVCBvc3VfZGlyICVzIiwgZm5hbWUpOworCWlmICh3cGFfY29tbWFuZChpZm5hbWUsIGJ1ZikgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gY29uZmlndXJlIG9zdV9kaXIgdG8gd3BhX3N1cHBsaWNhbnQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW1vbiA9IG9wZW5fd3BhX21vbihpZm5hbWUpOworCWlmIChtb24gPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlN0YXJ0aW5nIE9TVSBmZXRjaCIpOworCXdyaXRlX3N1bW1hcnkoY3R4LCAiU3RhcnRpbmcgT1NVIHByb3ZpZGVyIGluZm9ybWF0aW9uIGZldGNoIik7CisJaWYgKHdwYV9jb21tYW5kKGlmbmFtZSwgIkZFVENIX09TVSIpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHN0YXJ0IE9TVSBmZXRjaCIpOworCQl3cGFfY3RybF9kZXRhY2gobW9uKTsKKwkJd3BhX2N0cmxfY2xvc2UobW9uKTsKKwkJcmV0dXJuIC0xOworCX0KKwlyZXMgPSBnZXRfd3BhX2NsaV9ldmVudChtb24sICJPU1UgcHJvdmlkZXIgZmV0Y2ggY29tcGxldGVkIiwKKwkJCQlidWYsIHNpemVvZihidWYpKTsKKworCXdwYV9jdHJsX2RldGFjaChtb24pOworCXdwYV9jdHJsX2Nsb3NlKG1vbik7CisKKwlpZiAocmVzIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiT1NVIGZldGNoIGRpZCBub3QgY29tcGxldGUiKTsKKwkJd3JpdGVfc3VtbWFyeShjdHgsICJPU1UgZmV0Y2ggZGlkIG5vdCBjb21wbGV0ZSIpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICJPU1UgcHJvdmlkZXIgZmV0Y2ggY29tcGxldGVkIik7CisKKwlyZXR1cm4gY21kX29zdV9zZWxlY3QoY3R4LCBmbmFtZSwgMSwgbm9fcHJvZF9hc3NvYywgZnJpZW5kbHlfbmFtZSk7Cit9CisKKworc3RhdGljIHZvaWQgY21kX3N1Yl9yZW0oc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICphZGRyZXNzLAorCQkJY29uc3QgY2hhciAqcHBzX2ZuYW1lLCBjb25zdCBjaGFyICpjYV9mbmFtZSkKK3sKKwl4bWxfbm9kZV90ICpwcHMsICpub2RlOworCWNoYXIgcHBzX2ZuYW1lX2J1ZlszMDBdOworCWNoYXIgY2FfZm5hbWVfYnVmWzIwMF07CisJY2hhciAqY3JlZF91c2VybmFtZSA9IE5VTEw7CisJY2hhciAqY3JlZF9wYXNzd29yZCA9IE5VTEw7CisJY2hhciAqc3ViX3JlbV91cmkgPSBOVUxMOworCWNoYXIgY2xpZW50X2NlcnRfYnVmWzIwMF07CisJY2hhciAqY2xpZW50X2NlcnQgPSBOVUxMOworCWNoYXIgY2xpZW50X2tleV9idWZbMjAwXTsKKwljaGFyICpjbGllbnRfa2V5ID0gTlVMTDsKKwlpbnQgc3BwOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlN1YnNjcmlwdGlvbiByZW1lZGlhdGlvbiByZXF1ZXN0ZWQgd2l0aCBTZXJ2ZXIgVVJMOiAlcyIsCisJCSAgIGFkZHJlc3MpOworCisJaWYgKCFwcHNfZm5hbWUpIHsKKwkJY2hhciBidWZbMjU2XTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkRldGVybWluaW5nIFBQUyBmaWxlIGJhc2VkIG9uIEhvbWUgU1AgaW5mb3JtYXRpb24iKTsKKwkJaWYgKG9zX3N0cm5jbXAoYWRkcmVzcywgImZxZG49IiwgNSkgPT0gMCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVzZSByZXF1ZXN0ZWQgRlFETiBmcm9tIGNvbW1hbmQgbGluZSIpOworCQkJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiVzIiwgYWRkcmVzcyArIDUpOworCQkJYWRkcmVzcyA9IE5VTEw7CisJCX0gZWxzZSBpZiAoZ2V0X3dwYV9zdGF0dXMoY3R4LT5pZm5hbWUsICJwcm92aXNpb25pbmdfc3AiLCBidWYsCisJCQkJCSAgc2l6ZW9mKGJ1ZikpIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBnZXQgcHJvdmlzaW9uaW5nIEhvbWUgU1AgRlFETiBmcm9tIHdwYV9zdXBwbGljYW50Iik7CisJCQlyZXR1cm47CisJCX0KKwkJb3NfZnJlZShjdHgtPmZxZG4pOworCQljdHgtPmZxZG4gPSBvc19zdHJkdXAoYnVmKTsKKwkJaWYgKGN0eC0+ZnFkbiA9PSBOVUxMKQorCQkJcmV0dXJuOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSG9tZSBTUCBGUUROIGZvciBjdXJyZW50IGNyZWRlbnRpYWw6ICVzIiwKKwkJCSAgIGJ1Zik7CisJCW9zX3NucHJpbnRmKHBwc19mbmFtZV9idWYsIHNpemVvZihwcHNfZm5hbWVfYnVmKSwKKwkJCSAgICAiU1AvJXMvcHBzLnhtbCIsIGN0eC0+ZnFkbik7CisJCXBwc19mbmFtZSA9IHBwc19mbmFtZV9idWY7CisKKwkJb3Nfc25wcmludGYoY2FfZm5hbWVfYnVmLCBzaXplb2YoY2FfZm5hbWVfYnVmKSwgIlNQLyVzL2NhLnBlbSIsCisJCQkgICAgY3R4LT5mcWRuKTsKKwkJY2FfZm5hbWUgPSBjYV9mbmFtZV9idWY7CisJfQorCisJaWYgKCFvc19maWxlX2V4aXN0cyhwcHNfZm5hbWUpKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJQUFMgZmlsZSAnJXMnIGRvZXMgbm90IGV4aXN0IG9yIGlzIG5vdCBhY2Nlc3NpYmxlIiwKKwkJCSAgIHBwc19mbmFtZSk7CisJCXJldHVybjsKKwl9CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVzaW5nIFBQUyBmaWxlOiAlcyIsIHBwc19mbmFtZSk7CisKKwlpZiAoY2FfZm5hbWUgJiYgIW9zX2ZpbGVfZXhpc3RzKGNhX2ZuYW1lKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ0EgZmlsZSAnJXMnIGRvZXMgbm90IGV4aXN0IG9yIGlzIG5vdCBhY2Nlc3NpYmxlIiwKKwkJCSAgIGNhX2ZuYW1lKTsKKwkJcmV0dXJuOworCX0KKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXNpbmcgc2VydmVyIHRydXN0IHJvb3Q6ICVzIiwgY2FfZm5hbWUpOworCWN0eC0+Y2FfZm5hbWUgPSBjYV9mbmFtZTsKKworCXBwcyA9IG5vZGVfZnJvbV9maWxlKGN0eC0+eG1sLCBwcHNfZm5hbWUpOworCWlmIChwcHMgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IHJlYWQgUFBTIE1PIik7CisJCXJldHVybjsKKwl9CisKKwlpZiAoIWN0eC0+ZnFkbikgeworCQljaGFyICp0bXA7CisJCW5vZGUgPSBnZXRfY2hpbGRfbm9kZShjdHgtPnhtbCwgcHBzLCAiSG9tZVNQL0ZRRE4iKTsKKwkJaWYgKG5vZGUgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIEhvbWVTUC9GUUROIGZvdW5kIGZyb20gUFBTIik7CisJCQlyZXR1cm47CisJCX0KKwkJdG1wID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCQlpZiAodG1wID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBIb21lU1AvRlFETiB0ZXh0IGZvdW5kIGZyb20gUFBTIik7CisJCQlyZXR1cm47CisJCX0KKwkJY3R4LT5mcWRuID0gb3Nfc3RyZHVwKHRtcCk7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHRtcCk7CisJCWlmICghY3R4LT5mcWRuKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gRlFETiBrbm93biIpOworCQkJcmV0dXJuOworCQl9CisJfQorCisJbm9kZSA9IGdldF9jaGlsZF9ub2RlKGN0eC0+eG1sLCBwcHMsCisJCQkgICAgICAiU3Vic2NyaXB0aW9uVXBkYXRlL1VwZGF0ZU1ldGhvZCIpOworCWlmIChub2RlKSB7CisJCWNoYXIgKnRtcDsKKwkJdG1wID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCQlpZiAodG1wICYmIG9zX3N0cmNhc2VjbXAodG1wLCAiT01BLURNLUNsaWVudEluaXRpYXRlZCIpID09IDApCisJCQlzcHAgPSAwOworCQllbHNlCisJCQlzcHAgPSAxOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBVcGRhdGVNZXRob2Qgc3BlY2lmaWVkIC0gYXNzdW1lIFNQUCIpOworCQlzcHAgPSAxOworCX0KKworCWdldF91c2VyX3B3KGN0eCwgcHBzLCAiU3Vic2NyaXB0aW9uVXBkYXRlL1VzZXJuYW1lUGFzc3dvcmQiLAorCQkgICAgJmNyZWRfdXNlcm5hbWUsICZjcmVkX3Bhc3N3b3JkKTsKKwlpZiAoY3JlZF91c2VybmFtZSkKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVzaW5nIHVzZXJuYW1lOiAlcyIsIGNyZWRfdXNlcm5hbWUpOworCWlmIChjcmVkX3Bhc3N3b3JkKQorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlVzaW5nIHBhc3N3b3JkOiAlcyIsIGNyZWRfcGFzc3dvcmQpOworCisJaWYgKGNyZWRfdXNlcm5hbWUgPT0gTlVMTCAmJiBjcmVkX3Bhc3N3b3JkID09IE5VTEwgJiYKKwkgICAgZ2V0X2NoaWxkX25vZGUoY3R4LT54bWwsIHBwcywgIkNyZWRlbnRpYWwvRGlnaXRhbENlcnRpZmljYXRlIikpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVzaW5nIGNsaWVudCBjZXJ0aWZpY2F0ZSIpOworCQlvc19zbnByaW50ZihjbGllbnRfY2VydF9idWYsIHNpemVvZihjbGllbnRfY2VydF9idWYpLAorCQkJICAgICJTUC8lcy9jbGllbnQtY2VydC5wZW0iLCBjdHgtPmZxZG4pOworCQljbGllbnRfY2VydCA9IGNsaWVudF9jZXJ0X2J1ZjsKKwkJb3Nfc25wcmludGYoY2xpZW50X2tleV9idWYsIHNpemVvZihjbGllbnRfa2V5X2J1ZiksCisJCQkgICAgIlNQLyVzL2NsaWVudC1rZXkucGVtIiwgY3R4LT5mcWRuKTsKKwkJY2xpZW50X2tleSA9IGNsaWVudF9rZXlfYnVmOworCQljdHgtPmNsaWVudF9jZXJ0X3ByZXNlbnQgPSAxOworCX0KKworCW5vZGUgPSBnZXRfY2hpbGRfbm9kZShjdHgtPnhtbCwgcHBzLCAiU3Vic2NyaXB0aW9uVXBkYXRlL1VSSSIpOworCWlmIChub2RlKSB7CisJCXN1Yl9yZW1fdXJpID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCQlpZiAoc3ViX3JlbV91cmkgJiYKKwkJICAgICghYWRkcmVzcyB8fCBvc19zdHJjbXAoYWRkcmVzcywgc3ViX3JlbV91cmkpICE9IDApKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiT3ZlcnJpZGUgc3ViIHJlbSBVUkkgYmFzZWQgb24gUFBTOiAlcyIsCisJCQkJICAgc3ViX3JlbV91cmkpOworCQkJYWRkcmVzcyA9IHN1Yl9yZW1fdXJpOworCQl9CisJfQorCWlmICghYWRkcmVzcykgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU2VydmVyIFVSTCBub3Qga25vd24iKTsKKwkJcmV0dXJuOworCX0KKworCXdyaXRlX3N1bW1hcnkoY3R4LCAiV2FpdCBmb3IgSVAgYWRkcmVzcyBmb3Igc3Vic2NyaXB0aW9tIHJlbWVkaWF0aW9uIik7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIldhaXQgZm9yIElQIGFkZHJlc3MgYmVmb3JlIHN0YXJ0aW5nIHN1YnNjcmlwdGlvbiByZW1lZGlhdGlvbiIpOworCisJaWYgKHdhaXRfaXBfYWRkcihjdHgtPmlmbmFtZSwgMTUpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGdldCBJUCBhZGRyZXNzIGZvciBXTEFOIC0gdHJ5IGNvbm5lY3Rpb24gYW55d2F5Iik7CisJfQorCisJaWYgKHNwcCkKKwkJc3BwX3N1Yl9yZW0oY3R4LCBhZGRyZXNzLCBwcHNfZm5hbWUsCisJCQkgICAgY2xpZW50X2NlcnQsIGNsaWVudF9rZXksCisJCQkgICAgY3JlZF91c2VybmFtZSwgY3JlZF9wYXNzd29yZCwgcHBzKTsKKwllbHNlCisJCW9tYV9kbV9zdWJfcmVtKGN0eCwgYWRkcmVzcywgcHBzX2ZuYW1lLAorCQkJICAgICAgIGNsaWVudF9jZXJ0LCBjbGllbnRfa2V5LAorCQkJICAgICAgIGNyZWRfdXNlcm5hbWUsIGNyZWRfcGFzc3dvcmQsIHBwcyk7CisKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdWJfcmVtX3VyaSk7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgY3JlZF91c2VybmFtZSk7CisJc3RyX2NsZWFyX2ZyZWUoY3JlZF9wYXNzd29yZCk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcHBzKTsKK30KKworCitzdGF0aWMgaW50IGNtZF9wb2xfdXBkKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqYWRkcmVzcywKKwkJICAgICAgIGNvbnN0IGNoYXIgKnBwc19mbmFtZSwgY29uc3QgY2hhciAqY2FfZm5hbWUpCit7CisJeG1sX25vZGVfdCAqcHBzOworCXhtbF9ub2RlX3QgKm5vZGU7CisJY2hhciBwcHNfZm5hbWVfYnVmWzMwMF07CisJY2hhciBjYV9mbmFtZV9idWZbMjAwXTsKKwljaGFyICp1cmkgPSBOVUxMOworCWNoYXIgKmNyZWRfdXNlcm5hbWUgPSBOVUxMOworCWNoYXIgKmNyZWRfcGFzc3dvcmQgPSBOVUxMOworCWNoYXIgY2xpZW50X2NlcnRfYnVmWzIwMF07CisJY2hhciAqY2xpZW50X2NlcnQgPSBOVUxMOworCWNoYXIgY2xpZW50X2tleV9idWZbMjAwXTsKKwljaGFyICpjbGllbnRfa2V5ID0gTlVMTDsKKwlpbnQgc3BwOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBvbGljeSB1cGRhdGUgcmVxdWVzdGVkIik7CisKKwlpZiAoIXBwc19mbmFtZSkgeworCQljaGFyIGJ1ZlsyNTZdOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRGV0ZXJtaW5pbmcgUFBTIGZpbGUgYmFzZWQgb24gSG9tZSBTUCBpbmZvcm1hdGlvbiIpOworCQlpZiAob3Nfc3RybmNtcChhZGRyZXNzLCAiZnFkbj0iLCA1KSA9PSAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXNlIHJlcXVlc3RlZCBGUUROIGZyb20gY29tbWFuZCBsaW5lIik7CisJCQlvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiJXMiLCBhZGRyZXNzICsgNSk7CisJCQlhZGRyZXNzID0gTlVMTDsKKwkJfSBlbHNlIGlmIChnZXRfd3BhX3N0YXR1cyhjdHgtPmlmbmFtZSwgInByb3Zpc2lvbmluZ19zcCIsIGJ1ZiwKKwkJCQkJICBzaXplb2YoYnVmKSkgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGdldCBwcm92aXNpb25pbmcgSG9tZSBTUCBGUUROIGZyb20gd3BhX3N1cHBsaWNhbnQiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlvc19mcmVlKGN0eC0+ZnFkbik7CisJCWN0eC0+ZnFkbiA9IG9zX3N0cmR1cChidWYpOworCQlpZiAoY3R4LT5mcWRuID09IE5VTEwpCisJCQlyZXR1cm4gLTE7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJIb21lIFNQIEZRRE4gZm9yIGN1cnJlbnQgY3JlZGVudGlhbDogJXMiLAorCQkJICAgYnVmKTsKKwkJb3Nfc25wcmludGYocHBzX2ZuYW1lX2J1Ziwgc2l6ZW9mKHBwc19mbmFtZV9idWYpLAorCQkJICAgICJTUC8lcy9wcHMueG1sIiwgY3R4LT5mcWRuKTsKKwkJcHBzX2ZuYW1lID0gcHBzX2ZuYW1lX2J1ZjsKKworCQlvc19zbnByaW50ZihjYV9mbmFtZV9idWYsIHNpemVvZihjYV9mbmFtZV9idWYpLCAiU1AvJXMvY2EucGVtIiwKKwkJCSAgICBidWYpOworCQljYV9mbmFtZSA9IGNhX2ZuYW1lX2J1ZjsKKwl9CisKKwlpZiAoIW9zX2ZpbGVfZXhpc3RzKHBwc19mbmFtZSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBQUyBmaWxlICclcycgZG9lcyBub3QgZXhpc3Qgb3IgaXMgbm90IGFjY2Vzc2libGUiLAorCQkJICAgcHBzX2ZuYW1lKTsKKwkJcmV0dXJuIC0xOworCX0KKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXNpbmcgUFBTIGZpbGU6ICVzIiwgcHBzX2ZuYW1lKTsKKworCWlmIChjYV9mbmFtZSAmJiAhb3NfZmlsZV9leGlzdHMoY2FfZm5hbWUpKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDQSBmaWxlICclcycgZG9lcyBub3QgZXhpc3Qgb3IgaXMgbm90IGFjY2Vzc2libGUiLAorCQkJICAgY2FfZm5hbWUpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICJVc2luZyBzZXJ2ZXIgdHJ1c3Qgcm9vdDogJXMiLCBjYV9mbmFtZSk7CisJY3R4LT5jYV9mbmFtZSA9IGNhX2ZuYW1lOworCisJcHBzID0gbm9kZV9mcm9tX2ZpbGUoY3R4LT54bWwsIHBwc19mbmFtZSk7CisJaWYgKHBwcyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVhZCBQUFMgTU8iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmICghY3R4LT5mcWRuKSB7CisJCWNoYXIgKnRtcDsKKwkJbm9kZSA9IGdldF9jaGlsZF9ub2RlKGN0eC0+eG1sLCBwcHMsICJIb21lU1AvRlFETiIpOworCQlpZiAobm9kZSA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gSG9tZVNQL0ZRRE4gZm91bmQgZnJvbSBQUFMiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQl0bXAgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbm9kZSk7CisJCWlmICh0bXAgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIEhvbWVTUC9GUUROIHRleHQgZm91bmQgZnJvbSBQUFMiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQljdHgtPmZxZG4gPSBvc19zdHJkdXAodG1wKTsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgdG1wKTsKKwkJaWYgKCFjdHgtPmZxZG4pIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBGUUROIGtub3duIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlub2RlID0gZ2V0X2NoaWxkX25vZGUoY3R4LT54bWwsIHBwcywKKwkJCSAgICAgICJQb2xpY3kvUG9saWN5VXBkYXRlL1VwZGF0ZU1ldGhvZCIpOworCWlmIChub2RlKSB7CisJCWNoYXIgKnRtcDsKKwkJdG1wID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCQlpZiAodG1wICYmIG9zX3N0cmNhc2VjbXAodG1wLCAiT01BLURNLUNsaWVudEluaXRpYXRlZCIpID09IDApCisJCQlzcHAgPSAwOworCQllbHNlCisJCQlzcHAgPSAxOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBVcGRhdGVNZXRob2Qgc3BlY2lmaWVkIC0gYXNzdW1lIFNQUCIpOworCQlzcHAgPSAxOworCX0KKworCWdldF91c2VyX3B3KGN0eCwgcHBzLCAiUG9saWN5L1BvbGljeVVwZGF0ZS9Vc2VybmFtZVBhc3N3b3JkIiwKKwkJICAgICZjcmVkX3VzZXJuYW1lLCAmY3JlZF9wYXNzd29yZCk7CisJaWYgKGNyZWRfdXNlcm5hbWUpCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVc2luZyB1c2VybmFtZTogJXMiLCBjcmVkX3VzZXJuYW1lKTsKKwlpZiAoY3JlZF9wYXNzd29yZCkKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVc2luZyBwYXNzd29yZDogJXMiLCBjcmVkX3Bhc3N3b3JkKTsKKworCWlmIChjcmVkX3VzZXJuYW1lID09IE5VTEwgJiYgY3JlZF9wYXNzd29yZCA9PSBOVUxMICYmCisJICAgIGdldF9jaGlsZF9ub2RlKGN0eC0+eG1sLCBwcHMsICJDcmVkZW50aWFsL0RpZ2l0YWxDZXJ0aWZpY2F0ZSIpKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVc2luZyBjbGllbnQgY2VydGlmaWNhdGUiKTsKKwkJb3Nfc25wcmludGYoY2xpZW50X2NlcnRfYnVmLCBzaXplb2YoY2xpZW50X2NlcnRfYnVmKSwKKwkJCSAgICAiU1AvJXMvY2xpZW50LWNlcnQucGVtIiwgY3R4LT5mcWRuKTsKKwkJY2xpZW50X2NlcnQgPSBjbGllbnRfY2VydF9idWY7CisJCW9zX3NucHJpbnRmKGNsaWVudF9rZXlfYnVmLCBzaXplb2YoY2xpZW50X2tleV9idWYpLAorCQkJICAgICJTUC8lcy9jbGllbnQta2V5LnBlbSIsIGN0eC0+ZnFkbik7CisJCWNsaWVudF9rZXkgPSBjbGllbnRfa2V5X2J1ZjsKKwl9CisKKwlpZiAoIWFkZHJlc3MpIHsKKwkJbm9kZSA9IGdldF9jaGlsZF9ub2RlKGN0eC0+eG1sLCBwcHMsICJQb2xpY3kvUG9saWN5VXBkYXRlL1VSSSIpOworCQlpZiAobm9kZSkgeworCQkJdXJpID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIG5vZGUpOworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVSSSBiYXNlZCBvbiBQUFM6ICVzIiwgdXJpKTsKKwkJCWFkZHJlc3MgPSB1cmk7CisJCX0KKwl9CisJaWYgKCFhZGRyZXNzKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJTZXJ2ZXIgVVJMIG5vdCBrbm93biIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKHNwcCkKKwkJc3BwX3BvbF91cGQoY3R4LCBhZGRyZXNzLCBwcHNfZm5hbWUsCisJCQkgICAgY2xpZW50X2NlcnQsIGNsaWVudF9rZXksCisJCQkgICAgY3JlZF91c2VybmFtZSwgY3JlZF9wYXNzd29yZCwgcHBzKTsKKwllbHNlCisJCW9tYV9kbV9wb2xfdXBkKGN0eCwgYWRkcmVzcywgcHBzX2ZuYW1lLAorCQkJICAgICAgIGNsaWVudF9jZXJ0LCBjbGllbnRfa2V5LAorCQkJICAgICAgIGNyZWRfdXNlcm5hbWUsIGNyZWRfcGFzc3dvcmQsIHBwcyk7CisKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCB1cmkpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIGNyZWRfdXNlcm5hbWUpOworCXN0cl9jbGVhcl9mcmVlKGNyZWRfcGFzc3dvcmQpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBwcyk7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgY2hhciAqIGdldF9ob3N0bmFtZShjb25zdCBjaGFyICp1cmwpCit7CisJY29uc3QgY2hhciAqcG9zLCAqZW5kLCAqZW5kMjsKKwljaGFyICpyZXQ7CisKKwlpZiAodXJsID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJcG9zID0gb3Nfc3RyY2hyKHVybCwgJy8nKTsKKwlpZiAocG9zID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCXBvcysrOworCWlmICgqcG9zICE9ICcvJykKKwkJcmV0dXJuIE5VTEw7CisJcG9zKys7CisKKwllbmQgPSBvc19zdHJjaHIocG9zLCAnLycpOworCWVuZDIgPSBvc19zdHJjaHIocG9zLCAnOicpOworCWlmIChlbmQgJiYgZW5kMiAmJiBlbmQyIDwgZW5kKQorCQllbmQgPSBlbmQyOworCWlmIChlbmQpCisJCWVuZC0tOworCWVsc2UgeworCQllbmQgPSBwb3M7CisJCXdoaWxlICgqZW5kKQorCQkJZW5kKys7CisJCWlmIChlbmQgPiBwb3MpCisJCQllbmQtLTsKKwl9CisKKwlyZXQgPSBvc19tYWxsb2MoZW5kIC0gcG9zICsgMik7CisJaWYgKHJldCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCW9zX21lbWNweShyZXQsIHBvcywgZW5kIC0gcG9zICsgMSk7CisJcmV0W2VuZCAtIHBvcyArIDFdID0gJ1wwJzsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBvc3VfY2VydF9jYih2b2lkICpfY3R4LCBzdHJ1Y3QgaHR0cF9jZXJ0ICpjZXJ0KQoreworCXN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCA9IF9jdHg7CisJdW5zaWduZWQgaW50IGksIGo7CisJaW50IGZvdW5kOworCWNoYXIgKmhvc3QgPSBOVUxMOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIm9zdV9jZXJ0X2NiKG9zdV9jZXJ0X3ZhbGlkYXRpb249JWQpIiwKKwkJICAgIWN0eC0+bm9fb3N1X2NlcnRfdmFsaWRhdGlvbik7CisKKwlob3N0ID0gZ2V0X2hvc3RuYW1lKGN0eC0+c2VydmVyX3VybCk7CisKKwlmb3IgKGkgPSAwOyBpIDwgY3R4LT5zZXJ2ZXJfZG5zbmFtZV9jb3VudDsgaSsrKQorCQlvc19mcmVlKGN0eC0+c2VydmVyX2Ruc25hbWVbaV0pOworCW9zX2ZyZWUoY3R4LT5zZXJ2ZXJfZG5zbmFtZSk7CisJY3R4LT5zZXJ2ZXJfZG5zbmFtZSA9IG9zX2NhbGxvYyhjZXJ0LT5udW1fZG5zbmFtZSwgc2l6ZW9mKGNoYXIgKikpOworCWN0eC0+c2VydmVyX2Ruc25hbWVfY291bnQgPSAwOworCisJZm91bmQgPSAwOworCWZvciAoaSA9IDA7IGkgPCBjZXJ0LT5udW1fZG5zbmFtZTsgaSsrKSB7CisJCWlmIChjdHgtPnNlcnZlcl9kbnNuYW1lKSB7CisJCQljdHgtPnNlcnZlcl9kbnNuYW1lW2N0eC0+c2VydmVyX2Ruc25hbWVfY291bnRdID0KKwkJCQlvc19zdHJkdXAoY2VydC0+ZG5zbmFtZVtpXSk7CisJCQlpZiAoY3R4LT5zZXJ2ZXJfZG5zbmFtZVtjdHgtPnNlcnZlcl9kbnNuYW1lX2NvdW50XSkKKwkJCQljdHgtPnNlcnZlcl9kbnNuYW1lX2NvdW50Kys7CisJCX0KKwkJaWYgKGhvc3QgJiYgb3Nfc3RyY2FzZWNtcChob3N0LCBjZXJ0LT5kbnNuYW1lW2ldKSA9PSAwKQorCQkJZm91bmQgPSAxOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiZE5TTmFtZSAnJXMnIiwgY2VydC0+ZG5zbmFtZVtpXSk7CisJfQorCisJaWYgKGhvc3QgJiYgIWZvdW5kKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJTZXJ2ZXIgbmFtZSBmcm9tIFVSTCAoJXMpIGRpZCBub3QgbWF0Y2ggYW55IGROU05hbWUgLSBhYm9ydCBjb25uZWN0aW9uIiwKKwkJCSAgIGhvc3QpOworCQl3cml0ZV9yZXN1bHQoY3R4LCAiU2VydmVyIG5hbWUgZnJvbSBVUkwgKCVzKSBkaWQgbm90IG1hdGNoIGFueSBkTlNOYW1lIC0gYWJvcnQgY29ubmVjdGlvbiIsCisJCQkgICAgIGhvc3QpOworCQlvc19mcmVlKGhvc3QpOworCQlyZXR1cm4gLTE7CisJfQorCisJb3NfZnJlZShob3N0KTsKKworCWZvciAoaSA9IDA7IGkgPCBjZXJ0LT5udW1fb3RoZXJuYW1lOyBpKyspIHsKKwkJaWYgKG9zX3N0cmNtcChjZXJ0LT5vdGhlcm5hbWVbaV0ub2lkLAorCQkJICAgICAgIjEuMy42LjEuNC4xLjQwODA4LjEuMS4xIikgPT0gMCkgeworCQkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0lORk8sCisJCQkJCSAgImlkLXdmYS1ob3RzcG90LWZyaWVuZGx5TmFtZSIsCisJCQkJCSAgY2VydC0+b3RoZXJuYW1lW2ldLmRhdGEsCisJCQkJCSAgY2VydC0+b3RoZXJuYW1lW2ldLmxlbik7CisJCX0KKwl9CisKKwlmb3IgKGogPSAwOyAhY3R4LT5ub19vc3VfY2VydF92YWxpZGF0aW9uICYmCisJCSAgICAgaiA8IGN0eC0+ZnJpZW5kbHlfbmFtZV9jb3VudDsgaisrKSB7CisJCWludCBmb3VuZCA9IDA7CisJCWZvciAoaSA9IDA7IGkgPCBjZXJ0LT5udW1fb3RoZXJuYW1lOyBpKyspIHsKKwkJCWlmIChvc19zdHJjbXAoY2VydC0+b3RoZXJuYW1lW2ldLm9pZCwKKwkJCQkgICAgICAiMS4zLjYuMS40LjEuNDA4MDguMS4xLjEiKSAhPSAwKQorCQkJCWNvbnRpbnVlOworCQkJaWYgKGNlcnQtPm90aGVybmFtZVtpXS5sZW4gPCAzKQorCQkJCWNvbnRpbnVlOworCQkJaWYgKG9zX3N0cm5jYXNlY21wKChjaGFyICopIGNlcnQtPm90aGVybmFtZVtpXS5kYXRhLAorCQkJCQkgICBjdHgtPmZyaWVuZGx5X25hbWVbal0ubGFuZywgMykgIT0gMCkKKwkJCQljb250aW51ZTsKKwkJCWlmIChvc19zdHJuY21wKChjaGFyICopIGNlcnQtPm90aGVybmFtZVtpXS5kYXRhICsgMywKKwkJCQkgICAgICAgY3R4LT5mcmllbmRseV9uYW1lW2pdLnRleHQsCisJCQkJICAgICAgIGNlcnQtPm90aGVybmFtZVtpXS5sZW4gLSAzKSA9PSAwKSB7CisJCQkJZm91bmQgPSAxOworCQkJCWJyZWFrOworCQkJfQorCQl9CisKKwkJaWYgKCFmb3VuZCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIGZyaWVuZGx5IG5hbWUgbWF0Y2ggZm91bmQgZm9yICdbJXNdJXMnIiwKKwkJCQkgICBjdHgtPmZyaWVuZGx5X25hbWVbal0ubGFuZywKKwkJCQkgICBjdHgtPmZyaWVuZGx5X25hbWVbal0udGV4dCk7CisJCQl3cml0ZV9yZXN1bHQoY3R4LCAiTm8gZnJpZW5kbHkgbmFtZSBtYXRjaCBmb3VuZCBmb3IgJ1slc10lcyciLAorCQkJCSAgICAgY3R4LT5mcmllbmRseV9uYW1lW2pdLmxhbmcsCisJCQkJICAgICBjdHgtPmZyaWVuZGx5X25hbWVbal0udGV4dCk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgY2VydC0+bnVtX2xvZ287IGkrKykgeworCQlzdHJ1Y3QgaHR0cF9sb2dvICpsb2dvID0gJmNlcnQtPmxvZ29baV07CisKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImxvZ28gaGFzaCBhbGcgJXMgdXJpICclcyciLAorCQkJICAgbG9nby0+YWxnX29pZCwgbG9nby0+dXJpKTsKKwkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0lORk8sICJoYXNoVmFsdWUiLAorCQkJCSAgbG9nby0+aGFzaCwgbG9nby0+aGFzaF9sZW4pOworCX0KKworCWZvciAoaiA9IDA7ICFjdHgtPm5vX29zdV9jZXJ0X3ZhbGlkYXRpb24gJiYgaiA8IGN0eC0+aWNvbl9jb3VudDsgaisrKSB7CisJCWludCBmb3VuZCA9IDA7CisJCWNoYXIgKm5hbWUgPSBjdHgtPmljb25fZmlsZW5hbWVbal07CisJCXNpemVfdCBuYW1lX2xlbiA9IG9zX3N0cmxlbihuYW1lKTsKKworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTG9va2luZyBmb3IgaWNvbiBmaWxlIG5hbWUgJyVzJyBtYXRjaCIsCisJCQkgICBuYW1lKTsKKwkJZm9yIChpID0gMDsgaSA8IGNlcnQtPm51bV9sb2dvOyBpKyspIHsKKwkJCXN0cnVjdCBodHRwX2xvZ28gKmxvZ28gPSAmY2VydC0+bG9nb1tpXTsKKwkJCXNpemVfdCB1cmlfbGVuID0gb3Nfc3RybGVuKGxvZ28tPnVyaSk7CisJCQljaGFyICpwb3M7CisKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb21wYXJpbmcgdG8gJyVzJyB1cmlfbGVuPSVkIG5hbWVfbGVuPSVkIiwKKwkJCQkgICBsb2dvLT51cmksIChpbnQpIHVyaV9sZW4sIChpbnQpIG5hbWVfbGVuKTsKKwkJCWlmICh1cmlfbGVuIDwgMSArIG5hbWVfbGVuKQorCQkJCWNvbnRpbnVlOworCQkJcG9zID0gJmxvZ28tPnVyaVt1cmlfbGVuIC0gbmFtZV9sZW4gLSAxXTsKKwkJCWlmICgqcG9zICE9ICcvJykKKwkJCQljb250aW51ZTsKKwkJCXBvcysrOworCQkJaWYgKG9zX3N0cmNtcChwb3MsIG5hbWUpID09IDApIHsKKwkJCQlmb3VuZCA9IDE7CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKworCQlpZiAoIWZvdW5kKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gaWNvbiBmaWxlbmFtZSBtYXRjaCBmb3VuZCBmb3IgJyVzJyIsCisJCQkJICAgbmFtZSk7CisJCQl3cml0ZV9yZXN1bHQoY3R4LAorCQkJCSAgICAgIk5vIGljb24gZmlsZW5hbWUgbWF0Y2ggZm91bmQgZm9yICclcyciLAorCQkJCSAgICAgbmFtZSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlmb3IgKGogPSAwOyAhY3R4LT5ub19vc3VfY2VydF92YWxpZGF0aW9uICYmIGogPCBjdHgtPmljb25fY291bnQ7IGorKykgeworCQlpbnQgZm91bmQgPSAwOworCisJCWZvciAoaSA9IDA7IGkgPCBjZXJ0LT5udW1fbG9nbzsgaSsrKSB7CisJCQlzdHJ1Y3QgaHR0cF9sb2dvICpsb2dvID0gJmNlcnQtPmxvZ29baV07CisKKwkJCWlmIChsb2dvLT5oYXNoX2xlbiAhPSAzMikKKwkJCQljb250aW51ZTsKKwkJCWlmIChvc19tZW1jbXAobG9nby0+aGFzaCwgY3R4LT5pY29uX2hhc2hbal0sIDMyKSA9PSAwKSB7CisJCQkJZm91bmQgPSAxOworCQkJCWJyZWFrOworCQkJfQorCQl9CisKKwkJaWYgKCFmb3VuZCkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIGljb24gaGFzaCBtYXRjaCBmb3VuZCIpOworCQkJd3JpdGVfcmVzdWx0KGN0eCwgIk5vIGljb24gaGFzaCBtYXRjaCBmb3VuZCIpOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBpbml0X2N0eChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgpCit7CisJeG1sX25vZGVfdCAqZGV2aW5mbywgKmRldmlkOworCisJb3NfbWVtc2V0KGN0eCwgMCwgc2l6ZW9mKCpjdHgpKTsKKwljdHgtPmlmbmFtZSA9ICJ3bGFuMCI7CisJY3R4LT54bWwgPSB4bWxfbm9kZV9pbml0X2N0eChjdHgsIE5VTEwpOworCWlmIChjdHgtPnhtbCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlkZXZpbmZvID0gbm9kZV9mcm9tX2ZpbGUoY3R4LT54bWwsICJkZXZpbmZvLnhtbCIpOworCWlmICghZGV2aW5mbykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImRldmluZm8ueG1sIG5vdCBmb3VuZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJZGV2aWQgPSBnZXRfbm9kZShjdHgtPnhtbCwgZGV2aW5mbywgIkRldklkIik7CisJaWYgKGRldmlkKSB7CisJCWNoYXIgKnRtcCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBkZXZpZCk7CisJCWlmICh0bXApIHsKKwkJCWN0eC0+ZGV2aWQgPSBvc19zdHJkdXAodG1wKTsKKwkJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHRtcCk7CisJCX0KKwl9CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgZGV2aW5mbyk7CisKKwlpZiAoY3R4LT5kZXZpZCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ291bGQgbm90IGZldGNoIERldklkIGZyb20gZGV2aW5mby54bWwiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWN0eC0+aHR0cCA9IGh0dHBfaW5pdF9jdHgoY3R4LCBjdHgtPnhtbCk7CisJaWYgKGN0eC0+aHR0cCA9PSBOVUxMKSB7CisJCXhtbF9ub2RlX2RlaW5pdF9jdHgoY3R4LT54bWwpOworCQlyZXR1cm4gLTE7CisJfQorCWh0dHBfb2NzcF9zZXQoY3R4LT5odHRwLCAyKTsKKwlodHRwX3NldF9jZXJ0X2NiKGN0eC0+aHR0cCwgb3N1X2NlcnRfY2IsIGN0eCk7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZCBkZWluaXRfY3R4KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCkKK3sKKwlzaXplX3QgaTsKKworCWh0dHBfZGVpbml0X2N0eChjdHgtPmh0dHApOworCXhtbF9ub2RlX2RlaW5pdF9jdHgoY3R4LT54bWwpOworCW9zX2ZyZWUoY3R4LT5mcWRuKTsKKwlvc19mcmVlKGN0eC0+c2VydmVyX3VybCk7CisJb3NfZnJlZShjdHgtPmRldmlkKTsKKworCWZvciAoaSA9IDA7IGkgPCBjdHgtPnNlcnZlcl9kbnNuYW1lX2NvdW50OyBpKyspCisJCW9zX2ZyZWUoY3R4LT5zZXJ2ZXJfZG5zbmFtZVtpXSk7CisJb3NfZnJlZShjdHgtPnNlcnZlcl9kbnNuYW1lKTsKK30KKworCitzdGF0aWMgdm9pZCBjaGVja193b3JrYXJvdW5kcyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgpCit7CisJRklMRSAqZjsKKwljaGFyIGJ1ZlsxMDBdOworCXVuc2lnbmVkIGxvbmcgaW50IHZhbCA9IDA7CisKKwlmID0gZm9wZW4oImhzMjAtb3N1LWNsaWVudC53b3JrYXJvdW5kcyIsICJyIik7CisJaWYgKGYgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJaWYgKGZnZXRzKGJ1Ziwgc2l6ZW9mKGJ1ZiksIGYpKQorCQl2YWwgPSBzdHJ0b3VsKGJ1ZiwgTlVMTCwgMTYpOworCisJZmNsb3NlKGYpOworCisJaWYgKHZhbCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV29ya2Fyb3VuZHMgZW5hYmxlZDogMHglbHgiLCB2YWwpOworCQljdHgtPndvcmthcm91bmRzID0gdmFsOworCQlpZiAoY3R4LT53b3JrYXJvdW5kcyAmIFdPUktBUk9VTkRfT0NTUF9PUFRJT05BTCkKKwkJCWh0dHBfb2NzcF9zZXQoY3R4LT5odHRwLCAxKTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgdXNhZ2Uodm9pZCkKK3sKKwlwcmludGYoInVzYWdlOiBoczIwLW9zdS1jbGllbnQgWy1kZGRxcUt0XSBbLVM8c3RhdGlvbiBpZm5hbWU+XSBcXFxuIgorCSAgICAgICAiICAgIFstdzx3cGFfc3VwcGxpY2FudCBjdHJsX2lmYWNlIGRpcj5dICIKKwkgICAgICAgIlstcjxyZXN1bHQgZmlsZT5dIFstZjxkZWJ1ZyBmaWxlPl0gXFxcbiIKKwkgICAgICAgIiAgICBbLXM8c3VtbWFyeSBmaWxlPl0gXFxcbiIKKwkgICAgICAgIiAgICA8Y29tbWFuZD4gW2FyZ3VtZW50cy4uXVxuIgorCSAgICAgICAiY29tbWFuZHM6XG4iCisJICAgICAgICItIHRvX3RuZHMgPFhNTCBNTz4gPFhNTCBNTyBpbiBUTkRTIGZvcm1hdD4gW1VSTl1cbiIKKwkgICAgICAgIi0gdG9fdG5kczIgPFhNTCBNTz4gPFhNTCBNTyBpbiBUTkRTIGZvcm1hdCAoUGF0aCkgIgorCSAgICAgICAiW1VSTl0+XG4iCisJICAgICAgICItIGZyb21fdG5kcyA8WE1MIE1PIGluIFRORFMgZm9ybWF0PiA8WE1MIE1PPlxuIgorCSAgICAgICAiLSBzZXRfcHBzIDxQZXJQcm92aWRlclN1YnNjcmlwdGlvbiBYTUwgZmlsZSBuYW1lPlxuIgorCSAgICAgICAiLSBnZXRfZnFkbiA8UGVyUHJvdmlkZXJTdWJzY3JpcHRpb24gWE1MIGZpbGUgbmFtZT5cbiIKKwkgICAgICAgIi0gcG9sX3VwZCBbU2VydmVyIFVSTF0gW1BQU10gW0NBIGNlcnRdXG4iCisJICAgICAgICItIHN1Yl9yZW0gPFNlcnZlciBVUkw+IFtQUFNdIFtDQSBjZXJ0XVxuIgorCSAgICAgICAiLSBwcm92IDxTZXJ2ZXIgVVJMPiBbQ0EgY2VydF1cbiIKKwkgICAgICAgIi0gb21hX2RtX3Byb3YgPFNlcnZlciBVUkw+IFtDQSBjZXJ0XVxuIgorCSAgICAgICAiLSBzaW1fcHJvdiA8U2VydmVyIFVSTD4gW0NBIGNlcnRdXG4iCisJICAgICAgICItIG9tYV9kbV9zaW1fcHJvdiA8U2VydmVyIFVSTD4gW0NBIGNlcnRdXG4iCisJICAgICAgICItIHNpZ251cCBbQ0EgY2VydF1cbiIKKwkgICAgICAgIi0gZGxfb3N1X2NhIDxQUFM+IDxDQSBmaWxlPlxuIgorCSAgICAgICAiLSBkbF9wb2x1cGRfY2EgPFBQUz4gPENBIGZpbGU+XG4iCisJICAgICAgICItIGRsX2FhYV9jYSA8UFBTPiA8Q0EgZmlsZT5cbiIKKwkgICAgICAgIi0gYnJvd3NlciA8VVJMPlxuIgorCSAgICAgICAiLSBwYXJzZV9jZXJ0IDxYLjUwOSBjZXJ0aWZpY2F0ZSAoREVSKT5cbiIKKwkgICAgICAgIi0gb3N1X3NlbGVjdCA8T1NVIGluZm8gZGlyZWN0b3J5PiBbQ0EgY2VydF1cbiIpOworfQorCisKK2ludCBtYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pCit7CisJc3RydWN0IGhzMjBfb3N1X2NsaWVudCBjdHg7CisJaW50IGM7CisJaW50IHJldCA9IDA7CisJaW50IG5vX3Byb2RfYXNzb2MgPSAwOworCWNvbnN0IGNoYXIgKmZyaWVuZGx5X25hbWUgPSBOVUxMOworCWNvbnN0IGNoYXIgKndwYV9kZWJ1Z19maWxlX3BhdGggPSBOVUxMOworCWV4dGVybiBjaGFyICp3cGFzX2N0cmxfcGF0aDsKKwlleHRlcm4gaW50IHdwYV9kZWJ1Z19sZXZlbDsKKwlleHRlcm4gaW50IHdwYV9kZWJ1Z19zaG93X2tleXM7CisJZXh0ZXJuIGludCB3cGFfZGVidWdfdGltZXN0YW1wOworCisJaWYgKGluaXRfY3R4KCZjdHgpIDwgMCkKKwkJcmV0dXJuIC0xOworCisJZm9yICg7OykgeworCQljID0gZ2V0b3B0KGFyZ2MsIGFyZ3YsICJkZjpoaTpLTk86cXI6czpTOnR3OiIpOworCQlpZiAoYyA8IDApCisJCQlicmVhazsKKwkJc3dpdGNoIChjKSB7CisJCWNhc2UgJ2QnOgorCQkJaWYgKHdwYV9kZWJ1Z19sZXZlbCA+IDApCisJCQkJd3BhX2RlYnVnX2xldmVsLS07CisJCQlicmVhazsKKwkJY2FzZSAnZic6CisJCQl3cGFfZGVidWdfZmlsZV9wYXRoID0gb3B0YXJnOworCQkJYnJlYWs7CisJCWNhc2UgJ0snOgorCQkJd3BhX2RlYnVnX3Nob3dfa2V5cysrOworCQkJYnJlYWs7CisJCWNhc2UgJ04nOgorCQkJbm9fcHJvZF9hc3NvYyA9IDE7CisJCQlicmVhazsKKwkJY2FzZSAnTyc6CisJCQlmcmllbmRseV9uYW1lID0gb3B0YXJnOworCQkJYnJlYWs7CisJCWNhc2UgJ3EnOgorCQkJd3BhX2RlYnVnX2xldmVsKys7CisJCQlicmVhazsKKwkJY2FzZSAncic6CisJCQljdHgucmVzdWx0X2ZpbGUgPSBvcHRhcmc7CisJCQlicmVhazsKKwkJY2FzZSAncyc6CisJCQljdHguc3VtbWFyeV9maWxlID0gb3B0YXJnOworCQkJYnJlYWs7CisJCWNhc2UgJ1MnOgorCQkJY3R4LmlmbmFtZSA9IG9wdGFyZzsKKwkJCWJyZWFrOworCQljYXNlICd0JzoKKwkJCXdwYV9kZWJ1Z190aW1lc3RhbXArKzsKKwkJCWJyZWFrOworCQljYXNlICd3JzoKKwkJCXdwYXNfY3RybF9wYXRoID0gb3B0YXJnOworCQkJYnJlYWs7CisJCWNhc2UgJ2gnOgorCQlkZWZhdWx0OgorCQkJdXNhZ2UoKTsKKwkJCWV4aXQoMCk7CisJCQlicmVhazsKKwkJfQorCX0KKworCWlmIChhcmdjIC0gb3B0aW5kIDwgMSkgeworCQl1c2FnZSgpOworCQlleGl0KDApOworCX0KKworCXdwYV9kZWJ1Z19vcGVuX2ZpbGUod3BhX2RlYnVnX2ZpbGVfcGF0aCk7CisKKyNpZmRlZiBfX2xpbnV4X18KKwlzZXRsaW5lYnVmKHN0ZG91dCk7CisjZW5kaWYgLyogX19saW51eF9fICovCisKKwlpZiAoY3R4LnJlc3VsdF9maWxlKQorCQl1bmxpbmsoY3R4LnJlc3VsdF9maWxlKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIj09PVtoczIwLW9zdS1jbGllbnQgU1RBUlQgLSBjb21tYW5kOiAlcyBdPT09PT09IgorCQkgICAiPT09PT09PT09PT09PT09PSIsIGFyZ3Zbb3B0aW5kXSk7CisJY2hlY2tfd29ya2Fyb3VuZHMoJmN0eCk7CisKKwlpZiAoc3RyY21wKGFyZ3Zbb3B0aW5kXSwgInRvX3RuZHMiKSA9PSAwKSB7CisJCWlmIChhcmdjIC0gb3B0aW5kIDwgMikgeworCQkJdXNhZ2UoKTsKKwkJCWV4aXQoMCk7CisJCX0KKwkJY21kX3RvX3RuZHMoJmN0eCwgYXJndltvcHRpbmQgKyAxXSwgYXJndltvcHRpbmQgKyAyXSwKKwkJCSAgICBhcmdjID4gb3B0aW5kICsgMyA/IGFyZ3Zbb3B0aW5kICsgM10gOiBOVUxMLAorCQkJICAgIDApOworCX0gZWxzZSBpZiAoc3RyY21wKGFyZ3Zbb3B0aW5kXSwgInRvX3RuZHMyIikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWNtZF90b190bmRzKCZjdHgsIGFyZ3Zbb3B0aW5kICsgMV0sIGFyZ3Zbb3B0aW5kICsgMl0sCisJCQkgICAgYXJnYyA+IG9wdGluZCArIDMgPyBhcmd2W29wdGluZCArIDNdIDogTlVMTCwKKwkJCSAgICAxKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJmcm9tX3RuZHMiKSA9PSAwKSB7CisJCWlmIChhcmdjIC0gb3B0aW5kIDwgMikgeworCQkJdXNhZ2UoKTsKKwkJCWV4aXQoMCk7CisJCX0KKwkJY21kX2Zyb21fdG5kcygmY3R4LCBhcmd2W29wdGluZCArIDFdLCBhcmd2W29wdGluZCArIDJdKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJzdWJfcmVtIikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWlmIChhcmdjIC0gb3B0aW5kIDwgMikKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiU2VydmVyIFVSTCBtaXNzaW5nIGZyb20gY29tbWFuZCBsaW5lIik7CisJCWVsc2UKKwkJCWNtZF9zdWJfcmVtKCZjdHgsIGFyZ3Zbb3B0aW5kICsgMV0sCisJCQkJICAgIGFyZ2MgPiBvcHRpbmQgKyAyID8gYXJndltvcHRpbmQgKyAyXSA6IE5VTEwsCisJCQkJICAgIGFyZ2MgPiBvcHRpbmQgKyAzID8gYXJndltvcHRpbmQgKyAzXSA6CisJCQkJICAgIE5VTEwpOworCX0gZWxzZSBpZiAoc3RyY21wKGFyZ3Zbb3B0aW5kXSwgInBvbF91cGQiKSA9PSAwKSB7CisJCWlmIChhcmdjIC0gb3B0aW5kIDwgMikgeworCQkJdXNhZ2UoKTsKKwkJCWV4aXQoMCk7CisJCX0KKwkJcmV0ID0gY21kX3BvbF91cGQoJmN0eCwgYXJnYyA+IDIgPyBhcmd2W29wdGluZCArIDFdIDogTlVMTCwKKwkJCQkgIGFyZ2MgPiBvcHRpbmQgKyAyID8gYXJndltvcHRpbmQgKyAyXSA6IE5VTEwsCisJCQkJICBhcmdjID4gb3B0aW5kICsgMyA/IGFyZ3Zbb3B0aW5kICsgM10gOiBOVUxMKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJwcm92IikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWN0eC5jYV9mbmFtZSA9IGFyZ3Zbb3B0aW5kICsgMl07CisJCWNtZF9wcm92KCZjdHgsIGFyZ3Zbb3B0aW5kICsgMV0pOworCX0gZWxzZSBpZiAoc3RyY21wKGFyZ3Zbb3B0aW5kXSwgInNpbV9wcm92IikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWN0eC5jYV9mbmFtZSA9IGFyZ3Zbb3B0aW5kICsgMl07CisJCWNtZF9zaW1fcHJvdigmY3R4LCBhcmd2W29wdGluZCArIDFdKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJkbF9vc3VfY2EiKSA9PSAwKSB7CisJCWlmIChhcmdjIC0gb3B0aW5kIDwgMikgeworCQkJdXNhZ2UoKTsKKwkJCWV4aXQoMCk7CisJCX0KKwkJY21kX2RsX29zdV9jYSgmY3R4LCBhcmd2W29wdGluZCArIDFdLCBhcmd2W29wdGluZCArIDJdKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJkbF9wb2x1cGRfY2EiKSA9PSAwKSB7CisJCWlmIChhcmdjIC0gb3B0aW5kIDwgMikgeworCQkJdXNhZ2UoKTsKKwkJCWV4aXQoMCk7CisJCX0KKwkJY21kX2RsX3BvbHVwZF9jYSgmY3R4LCBhcmd2W29wdGluZCArIDFdLCBhcmd2W29wdGluZCArIDJdKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJkbF9hYWFfY2EiKSA9PSAwKSB7CisJCWlmIChhcmdjIC0gb3B0aW5kIDwgMikgeworCQkJdXNhZ2UoKTsKKwkJCWV4aXQoMCk7CisJCX0KKwkJY21kX2RsX2FhYV9jYSgmY3R4LCBhcmd2W29wdGluZCArIDFdLCBhcmd2W29wdGluZCArIDJdKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJvc3Vfc2VsZWN0IikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWN0eC5jYV9mbmFtZSA9IGFyZ2MgPiBvcHRpbmQgKyAyID8gYXJndltvcHRpbmQgKyAyXSA6IE5VTEw7CisJCWNtZF9vc3Vfc2VsZWN0KCZjdHgsIGFyZ3Zbb3B0aW5kICsgMV0sIDIsIDEsIE5VTEwpOworCX0gZWxzZSBpZiAoc3RyY21wKGFyZ3Zbb3B0aW5kXSwgInNpZ251cCIpID09IDApIHsKKwkJY3R4LmNhX2ZuYW1lID0gYXJnYyA+IG9wdGluZCArIDEgPyBhcmd2W29wdGluZCArIDFdIDogTlVMTDsKKwkJcmV0ID0gY21kX3NpZ251cCgmY3R4LCBub19wcm9kX2Fzc29jLCBmcmllbmRseV9uYW1lKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJzZXRfcHBzIikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWNtZF9zZXRfcHBzKCZjdHgsIGFyZ3Zbb3B0aW5kICsgMV0pOworCX0gZWxzZSBpZiAoc3RyY21wKGFyZ3Zbb3B0aW5kXSwgImdldF9mcWRuIikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDEpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCXJldCA9IGNtZF9nZXRfZnFkbigmY3R4LCBhcmd2W29wdGluZCArIDFdKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJvbWFfZG1fcHJvdiIpID09IDApIHsKKwkJaWYgKGFyZ2MgLSBvcHRpbmQgPCAyKSB7CisJCQl1c2FnZSgpOworCQkJZXhpdCgwKTsKKwkJfQorCQljdHguY2FfZm5hbWUgPSBhcmd2W29wdGluZCArIDJdOworCQljbWRfb21hX2RtX3Byb3YoJmN0eCwgYXJndltvcHRpbmQgKyAxXSk7CisJfSBlbHNlIGlmIChzdHJjbXAoYXJndltvcHRpbmRdLCAib21hX2RtX3NpbV9wcm92IikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWN0eC5jYV9mbmFtZSA9IGFyZ3Zbb3B0aW5kICsgMl07CisJCWlmIChjbWRfb21hX2RtX3NpbV9wcm92KCZjdHgsIGFyZ3Zbb3B0aW5kICsgMV0pIDwgMCkgeworCQkJd3JpdGVfc3VtbWFyeSgmY3R4LCAiRmFpbGVkIHRvIGNvbXBsZXRlIE9NQSBETSBTSU0gcHJvdmlzaW9uaW5nIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJvbWFfZG1fYWRkIikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWNtZF9vbWFfZG1fYWRkKCZjdHgsIGFyZ3Zbb3B0aW5kICsgMV0sIGFyZ3Zbb3B0aW5kICsgMl0pOworCX0gZWxzZSBpZiAoc3RyY21wKGFyZ3Zbb3B0aW5kXSwgIm9tYV9kbV9yZXBsYWNlIikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCWNtZF9vbWFfZG1fcmVwbGFjZSgmY3R4LCBhcmd2W29wdGluZCArIDFdLCBhcmd2W29wdGluZCArIDJdKTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJlc3RfY3NyIikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisJCW1rZGlyKCJDZXJ0IiwgU19JUldYVSk7CisJCWVzdF9idWlsZF9jc3IoJmN0eCwgYXJndltvcHRpbmQgKyAxXSk7CisJfSBlbHNlIGlmIChzdHJjbXAoYXJndltvcHRpbmRdLCAiYnJvd3NlciIpID09IDApIHsKKwkJaW50IHJldDsKKworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkxhdW5jaCB3ZWIgYnJvd3NlciB0byBVUkwgJXMiLAorCQkJICAgYXJndltvcHRpbmQgKyAxXSk7CisJCXJldCA9IGhzMjBfd2ViX2Jyb3dzZXIoYXJndltvcHRpbmQgKyAxXSk7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJXZWIgYnJvd3NlciByZXN1bHQ6ICVkIiwgcmV0KTsKKwl9IGVsc2UgaWYgKHN0cmNtcChhcmd2W29wdGluZF0sICJwYXJzZV9jZXJ0IikgPT0gMCkgeworCQlpZiAoYXJnYyAtIG9wdGluZCA8IDIpIHsKKwkJCXVzYWdlKCk7CisJCQlleGl0KDApOworCQl9CisKKwkJd3BhX2RlYnVnX2xldmVsID0gTVNHX01TR0RVTVA7CisJCWh0dHBfcGFyc2VfeDUwOV9jZXJ0aWZpY2F0ZShjdHguaHR0cCwgYXJndltvcHRpbmQgKyAxXSk7CisJCXdwYV9kZWJ1Z19sZXZlbCA9IE1TR19JTkZPOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVbmtub3duIGNvbW1hbmQgJyVzJyIsIGFyZ3Zbb3B0aW5kXSk7CisJfQorCisJZGVpbml0X2N0eCgmY3R4KTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIj09PVtoczIwLW9zdS1jbGllbnQgRU5EIF09PT09PT09PT09PT09PT09PT09PT09Iik7CisKKwl3cGFfZGVidWdfY2xvc2VfZmlsZSgpOworCisJcmV0dXJuIHJldDsKK30KZGlmZiAtLWdpdCBhL2hzMjAvY2xpZW50L29zdV9jbGllbnQuaCBiL2hzMjAvY2xpZW50L29zdV9jbGllbnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45YTcwNTllCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9jbGllbnQvb3N1X2NsaWVudC5oCkBAIC0wLDAgKzEsMTE4IEBACisvKgorICogSG90c3BvdCAyLjAgLSBPU1UgY2xpZW50CisgKiBDb3B5cmlnaHQgKGMpIDIwMTMtMjAxNCwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBPU1VfQ0xJRU5UX0gKKyNkZWZpbmUgT1NVX0NMSUVOVF9ICisKKyNkZWZpbmUgU1BQX05TX1VSSSAiaHR0cDovL3d3dy53aS1maS5vcmcvc3BlY2lmaWNhdGlvbnMvaG90c3BvdDJkb3QwL3YxLjAvc3BwIgorCisjZGVmaW5lIFVSTl9PTUFfRE1fREVWSU5GTyAidXJuOm9tYTptbzpvbWEtZG0tZGV2aW5mbzoxLjAiCisjZGVmaW5lIFVSTl9PTUFfRE1fREVWREVUQUlMICJ1cm46b21hOm1vOm9tYS1kbS1kZXZkZXRhaWw6MS4wIgorI2RlZmluZSBVUk5fSFMyMF9ERVZERVRBSUxfRVhUICJ1cm46d2ZhOm1vLWV4dDpob3RzcG90MmRvdDAtZGV2ZGV0YWlsLWV4dDoxLjAiCisjZGVmaW5lIFVSTl9IUzIwX1BQUyAidXJuOndmYTptbzpob3RzcG90MmRvdDAtcGVycHJvdmlkZXJzdWJzY3JpcHRpb246MS4wIgorCisKKyNkZWZpbmUgTUFYX09TVV9WQUxTIDEwCisKK3N0cnVjdCBvc3VfbGFuZ190ZXh0IHsKKwljaGFyIGxhbmdbNF07CisJY2hhciB0ZXh0WzI1M107Cit9OworCitzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50IHsKKwlzdHJ1Y3QgeG1sX25vZGVfY3R4ICp4bWw7CisJc3RydWN0IGh0dHBfY3R4ICpodHRwOworCWludCBub19yZWNvbm5lY3Q7CisJY2hhciBwcHNfZm5hbWVbMzAwXTsKKwljaGFyICpkZXZpZDsKKwljb25zdCBjaGFyICpyZXN1bHRfZmlsZTsKKwljb25zdCBjaGFyICpzdW1tYXJ5X2ZpbGU7CisJY29uc3QgY2hhciAqaWZuYW1lOworCWNvbnN0IGNoYXIgKmNhX2ZuYW1lOworCWludCBub19vc3VfY2VydF92YWxpZGF0aW9uOyAvKiBmb3IgRVNUIG9wZXJhdGlvbnMgKi8KKwljaGFyICpmcWRuOworCWNoYXIgKnNlcnZlcl91cmw7CisJc3RydWN0IG9zdV9sYW5nX3RleHQgZnJpZW5kbHlfbmFtZVtNQVhfT1NVX1ZBTFNdOworCXNpemVfdCBmcmllbmRseV9uYW1lX2NvdW50OworCXNpemVfdCBpY29uX2NvdW50OworCWNoYXIgaWNvbl9maWxlbmFtZVtNQVhfT1NVX1ZBTFNdWzI1Nl07CisJdTggaWNvbl9oYXNoW01BWF9PU1VfVkFMU11bMzJdOworCWludCBwcHNfY3JlZF9zZXQ7CisJaW50IHBwc191cGRhdGVkOworCWludCBjbGllbnRfY2VydF9wcmVzZW50OworCWNoYXIgKipzZXJ2ZXJfZG5zbmFtZTsKKwlzaXplX3Qgc2VydmVyX2Ruc25hbWVfY291bnQ7CisjZGVmaW5lIFdPUktBUk9VTkRfT0NTUF9PUFRJT05BTCAweDAwMDAwMDAxCisJdW5zaWduZWQgbG9uZyBpbnQgd29ya2Fyb3VuZHM7Cit9OworCisKKy8qIG9zdV9jbGllbnQuYyAqLworCit2b2lkIHdyaXRlX3Jlc3VsdChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQorCV9fYXR0cmlidXRlX18gKChmb3JtYXQgKHByaW50ZiwgMiwgMykpKTsKK3ZvaWQgd3JpdGVfc3VtbWFyeShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQorCV9fYXR0cmlidXRlX18gKChmb3JtYXQgKHByaW50ZiwgMiwgMykpKTsKKwordm9pZCBkZWJ1Z19kdW1wX25vZGUoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp0aXRsZSwKKwkJICAgICB4bWxfbm9kZV90ICpub2RlKTsKK2ludCBvc3VfZ2V0X2NlcnRpZmljYXRlKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqZ2V0Y2VydCk7CitpbnQgaHMyMF9hZGRfcHBzX21vKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqdXJpLAorCQkgICAgeG1sX25vZGVfdCAqYWRkX21vLCBjaGFyICpmbmFtZSwgc2l6ZV90IGZuYW1lX2xlbik7Cit2b2lkIGdldF91c2VyX3B3KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgeG1sX25vZGVfdCAqcHBzLAorCQkgY29uc3QgY2hhciAqYWx0X2xvYywgY2hhciAqKnVzZXIsIGNoYXIgKipwdyk7CitpbnQgdXBkYXRlX3Bwc19maWxlKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqcHBzX2ZuYW1lLAorCQkgICAgeG1sX25vZGVfdCAqcHBzKTsKK3ZvaWQgY21kX3NldF9wcHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpwcHNfZm5hbWUpOworCisKKy8qIHNwcF9jbGllbnQuYyAqLworCit2b2lkIHNwcF9zdWJfcmVtKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqYWRkcmVzcywKKwkJIGNvbnN0IGNoYXIgKnBwc19mbmFtZSwKKwkJIGNvbnN0IGNoYXIgKmNsaWVudF9jZXJ0LCBjb25zdCBjaGFyICpjbGllbnRfa2V5LAorCQkgY29uc3QgY2hhciAqY3JlZF91c2VybmFtZSwgY29uc3QgY2hhciAqY3JlZF9wYXNzd29yZCwKKwkJIHhtbF9ub2RlX3QgKnBwcyk7Cit2b2lkIHNwcF9wb2xfdXBkKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqYWRkcmVzcywKKwkJIGNvbnN0IGNoYXIgKnBwc19mbmFtZSwKKwkJIGNvbnN0IGNoYXIgKmNsaWVudF9jZXJ0LCBjb25zdCBjaGFyICpjbGllbnRfa2V5LAorCQkgY29uc3QgY2hhciAqY3JlZF91c2VybmFtZSwgY29uc3QgY2hhciAqY3JlZF9wYXNzd29yZCwKKwkJIHhtbF9ub2RlX3QgKnBwcyk7CitpbnQgY21kX3Byb3Yoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwpOworaW50IGNtZF9zaW1fcHJvdihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnVybCk7CisKKworLyogb21hX2RtX2NsaWVudC5jICovCisKK2ludCBjbWRfb21hX2RtX3Byb3Yoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwpOworaW50IGNtZF9vbWFfZG1fc2ltX3Byb3Yoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwpOwordm9pZCBvbWFfZG1fc3ViX3JlbShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKmFkZHJlc3MsCisJCSAgICBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCSAgICBjb25zdCBjaGFyICpjbGllbnRfY2VydCwgY29uc3QgY2hhciAqY2xpZW50X2tleSwKKwkJICAgIGNvbnN0IGNoYXIgKmNyZWRfdXNlcm5hbWUsIGNvbnN0IGNoYXIgKmNyZWRfcGFzc3dvcmQsCisJCSAgICB4bWxfbm9kZV90ICpwcHMpOwordm9pZCBvbWFfZG1fcG9sX3VwZChzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKmFkZHJlc3MsCisJCSAgICBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCSAgICBjb25zdCBjaGFyICpjbGllbnRfY2VydCwgY29uc3QgY2hhciAqY2xpZW50X2tleSwKKwkJICAgIGNvbnN0IGNoYXIgKmNyZWRfdXNlcm5hbWUsIGNvbnN0IGNoYXIgKmNyZWRfcGFzc3dvcmQsCisJCSAgICB4bWxfbm9kZV90ICpwcHMpOwordm9pZCBjbWRfb21hX2RtX3N1Yl9yZW0oc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICphZGRyZXNzLAorCQkJY29uc3QgY2hhciAqcHBzX2ZuYW1lKTsKK3ZvaWQgY21kX29tYV9kbV9hZGQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCSAgICBjb25zdCBjaGFyICphZGRfZm5hbWUpOwordm9pZCBjbWRfb21hX2RtX3JlcGxhY2Uoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICpwcHNfZm5hbWUsCisJCQljb25zdCBjaGFyICpyZXBsYWNlX2ZuYW1lKTsKKworLyogZXN0LmMgKi8KKworaW50IGVzdF9sb2FkX2NhY2VydHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwpOworaW50IGVzdF9idWlsZF9jc3Ioc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICp1cmwpOworaW50IGVzdF9zaW1wbGVfZW5yb2xsKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqdXJsLAorCQkgICAgICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpwdyk7CisKKyNlbmRpZiAvKiBPU1VfQ0xJRU5UX0ggKi8KZGlmZiAtLWdpdCBhL2hzMjAvY2xpZW50L3NwcF9jbGllbnQuYyBiL2hzMjAvY2xpZW50L3NwcF9jbGllbnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMDJhMDUwCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9jbGllbnQvc3BwX2NsaWVudC5jCkBAIC0wLDAgKzEsOTk1IEBACisvKgorICogSG90c3BvdCAyLjAgU1BQIGNsaWVudAorICogQ29weXJpZ2h0IChjKSAyMDEyLTIwMTQsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJicm93c2VyLmgiCisjaW5jbHVkZSAid3BhX2N0cmwuaCIKKyNpbmNsdWRlICJ3cGFfaGVscGVycy5oIgorI2luY2x1ZGUgInhtbC11dGlscy5oIgorI2luY2x1ZGUgImh0dHAtdXRpbHMuaCIKKyNpbmNsdWRlICJ1dGlscy9iYXNlNjQuaCIKKyNpbmNsdWRlICJjcnlwdG8vY3J5cHRvLmgiCisjaW5jbHVkZSAiY3J5cHRvL3NoYTI1Ni5oIgorI2luY2x1ZGUgIm9zdV9jbGllbnQuaCIKKworCitzdGF0aWMgaW50IGhzMjBfc3BwX3VwZGF0ZV9yZXNwb25zZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJICAgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJICAgIGNvbnN0IGNoYXIgKnNwcF9zdGF0dXMsCisJCQkJICAgIGNvbnN0IGNoYXIgKmVycm9yX2NvZGUpOworc3RhdGljIHZvaWQgaHMyMF9wb2xpY3lfdXBkYXRlX2NvbXBsZXRlKAorCXN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqcHBzX2ZuYW1lKTsKKworCitzdGF0aWMgY2hhciAqIGdldF9zcHBfYXR0cl92YWx1ZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCQkJIGNoYXIgKmF0dHJfbmFtZSkKK3sKKwlyZXR1cm4geG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfbnMoY3R4LCBub2RlLCBTUFBfTlNfVVJJLCBhdHRyX25hbWUpOworfQorCisKK3N0YXRpYyBpbnQgaHMyMF9zcHBfdmFsaWRhdGUoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICpub2RlLAorCQkJICAgICBjb25zdCBjaGFyICpleHBlY3RlZF9uYW1lKQoreworCXN0cnVjdCB4bWxfbm9kZV9jdHggKnhjdHggPSBjdHgtPnhtbDsKKwljb25zdCBjaGFyICpuYW1lOworCWNoYXIgKmVycjsKKwlpbnQgcmV0OworCisJaWYgKCF4bWxfbm9kZV9pc19lbGVtZW50KHhjdHgsIG5vZGUpKQorCQlyZXR1cm4gLTE7CisKKwluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZSh4Y3R4LCBub2RlKTsKKwlpZiAobmFtZSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpZiAoc3RyY21wKGV4cGVjdGVkX25hbWUsIG5hbWUpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuZXhwZWN0ZWQgU09BUCBtZXRob2QgbmFtZSAnJXMnIChleHBlY3RlZCAnJXMnKSIsCisJCQkgICBuYW1lLCBleHBlY3RlZF9uYW1lKTsKKwkJd3JpdGVfc3VtbWFyeShjdHgsICJVbmV4cGVjdGVkIFNPQVAgbWV0aG9kIG5hbWUgJyVzJyAoZXhwZWN0ZWQgJyVzJykiLAorCQkJICAgICAgbmFtZSwgZXhwZWN0ZWRfbmFtZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXQgPSB4bWxfdmFsaWRhdGUoeGN0eCwgbm9kZSwgInNwcC54c2QiLCAmZXJyKTsKKwlpZiAocmV0IDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiWE1MIHNjaGVtYSB2YWxpZGF0aW9uIGVycm9yKHMpXG4lcyIsIGVycik7CisJCXdyaXRlX3N1bW1hcnkoY3R4LCAiU1BQIFhNTCBzY2hlbWEgdmFsaWRhdGlvbiBmYWlsZWQiKTsKKwkJb3NfZnJlZShlcnIpOworCX0KKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyB2b2lkIGFkZF9tb19jb250YWluZXIoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbmFtZXNwYWNlX3QgKm5zLAorCQkJICAgICB4bWxfbm9kZV90ICpwYXJlbnQsIGNvbnN0IGNoYXIgKnVybiwKKwkJCSAgICAgY29uc3QgY2hhciAqZm5hbWUpCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKwl4bWxfbm9kZV90ICpmbm9kZSwgKnRuZHM7CisJY2hhciAqc3RyOworCisJZm5vZGUgPSBub2RlX2Zyb21fZmlsZShjdHgsIGZuYW1lKTsKKwlpZiAoIWZub2RlKQorCQlyZXR1cm47CisJdG5kcyA9IG1vX3RvX3RuZHMoY3R4LCBmbm9kZSwgMCwgdXJuLCAic3luY21sOmRtZGRmMS4yIik7CisJeG1sX25vZGVfZnJlZShjdHgsIGZub2RlKTsKKwlpZiAoIXRuZHMpCisJCXJldHVybjsKKworCXN0ciA9IHhtbF9ub2RlX3RvX3N0cihjdHgsIHRuZHMpOworCXhtbF9ub2RlX2ZyZWUoY3R4LCB0bmRzKTsKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybjsKKworCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGVfdGV4dChjdHgsIHBhcmVudCwgbnMsICJtb0NvbnRhaW5lciIsIHN0cik7CisJaWYgKG5vZGUpCisJCXhtbF9ub2RlX2FkZF9hdHRyKGN0eCwgbm9kZSwgbnMsICJtb1VSTiIsIHVybik7CisJb3NfZnJlZShzdHIpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogYnVpbGRfc3BwX3Bvc3RfZGV2X2RhdGEoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCQkgICAgeG1sX25hbWVzcGFjZV90ICoqcmV0X25zLAorCQkJCQkgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwKKwkJCQkJICAgIGNvbnN0IGNoYXIgKnJlYXNvbikKK3sKKwl4bWxfbmFtZXNwYWNlX3QgKm5zOworCXhtbF9ub2RlX3QgKnNwcF9ub2RlOworCisJd3JpdGVfc3VtbWFyeShjdHgsICJCdWlsZGluZyBzcHBQb3N0RGV2RGF0YSByZXF1ZXN0UmVhc29uPSclcyciLAorCQkgICAgICByZWFzb24pOworCXNwcF9ub2RlID0geG1sX25vZGVfY3JlYXRlX3Jvb3QoY3R4LT54bWwsIFNQUF9OU19VUkksICJzcHAiLCAmbnMsCisJCQkJCSJzcHBQb3N0RGV2RGF0YSIpOworCWlmIChzcHBfbm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlpZiAocmV0X25zKQorCQkqcmV0X25zID0gbnM7CisKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgc3BwX25vZGUsIG5zLCAic3BwVmVyc2lvbiIsICIxLjAiKTsKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgc3BwX25vZGUsIE5VTEwsICJyZXF1ZXN0UmVhc29uIiwgcmVhc29uKTsKKwlpZiAoc2Vzc2lvbl9pZCkKKwkJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInNlc3Npb25JRCIsCisJCQkJICBzZXNzaW9uX2lkKTsKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgc3BwX25vZGUsIE5VTEwsICJyZWRpcmVjdFVSSSIsCisJCQkgICJodHRwOi8vbG9jYWxob3N0OjEyMzQ1LyIpOworCisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInN1cHBvcnRlZFNQUFZlcnNpb25zIiwKKwkJCSAgICAgIjEuMCIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBzcHBfbm9kZSwgbnMsICJzdXBwb3J0ZWRNT0xpc3QiLAorCQkJICAgICBVUk5fSFMyMF9QUFMgIiAiIFVSTl9PTUFfRE1fREVWSU5GTyAiICIKKwkJCSAgICAgVVJOX09NQV9ETV9ERVZERVRBSUwgIiAiIFVSTl9IUzIwX0RFVkRFVEFJTF9FWFQpOworCisJYWRkX21vX2NvbnRhaW5lcihjdHgtPnhtbCwgbnMsIHNwcF9ub2RlLCBVUk5fT01BX0RNX0RFVklORk8sCisJCQkgImRldmluZm8ueG1sIik7CisJYWRkX21vX2NvbnRhaW5lcihjdHgtPnhtbCwgbnMsIHNwcF9ub2RlLCBVUk5fT01BX0RNX0RFVkRFVEFJTCwKKwkJCSAiZGV2ZGV0YWlsLnhtbCIpOworCisJcmV0dXJuIHNwcF9ub2RlOworfQorCisKK3N0YXRpYyBpbnQgcHJvY2Vzc191cGRhdGVfbm9kZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIHhtbF9ub2RlX3QgKnBwcywKKwkJCSAgICAgICB4bWxfbm9kZV90ICp1cGRhdGUpCit7CisJeG1sX25vZGVfdCAqbm9kZSwgKnBhcmVudCwgKnRuZHMsICp1bm9kZTsKKwljaGFyICpzdHI7CisJY29uc3QgY2hhciAqbmFtZTsKKwljaGFyICp1cmksICpwb3M7CisJY2hhciAqY2RhdGEsICpjZGF0YV9lbmQ7CisJc2l6ZV90IGZxZG5fbGVuOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlByb2Nlc3NpbmcgdXBkYXRlTm9kZSIpOworCWRlYnVnX2R1bXBfbm9kZShjdHgsICJ1cGRhdGVOb2RlIiwgdXBkYXRlKTsKKworCXVyaSA9IGdldF9zcHBfYXR0cl92YWx1ZShjdHgtPnhtbCwgdXBkYXRlLCAibWFuYWdlbWVudFRyZWVVUkkiKTsKKwlpZiAodXJpID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIG1hbmFnZW1lbnRUcmVlVVJJIHByZXNlbnQiKTsKKwkJcmV0dXJuIC0xOworCX0KKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAibWFuYWdlbWVudFRyZWVVcmk6ICclcyciLCB1cmkpOworCisJbmFtZSA9IG9zX3N0cnJjaHIodXJpLCAnLycpOworCWlmIChuYW1lID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuZXhwZWN0ZWQgVVJJIik7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVyaSk7CisJCXJldHVybiAtMTsKKwl9CisJbmFtZSsrOworCXdwYV9wcmludGYoTVNHX0lORk8sICJVcGRhdGUgaW50ZXJpb3Igbm9kZTogJyVzJyIsIG5hbWUpOworCisJc3RyID0geG1sX25vZGVfZ2V0X3RleHQoY3R4LT54bWwsIHVwZGF0ZSk7CisJaWYgKHN0ciA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgZXh0cmFjdCBNTyB0ZXh0Iik7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVyaSk7CisJCXJldHVybiAtMTsKKwl9CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJbaHMyMF0gbm9kZUNvbnRhaW5lciB0ZXh0OiAnJXMnIiwgc3RyKTsKKwljZGF0YSA9IHN0cnN0cihzdHIsICI8IVtDREFUQVsiKTsKKwljZGF0YV9lbmQgPSBzdHJzdHIoc3RyLCAiXV0+Iik7CisJaWYgKGNkYXRhICYmIGNkYXRhX2VuZCAmJiBjZGF0YV9lbmQgPiBjZGF0YSAmJgorCSAgICBjZGF0YSA8IHN0cnN0cihzdHIsICJNZ210VHJlZSIpICYmCisJICAgIGNkYXRhX2VuZCA+IHN0cnN0cihzdHIsICIvTWdtdFRyZWUiKSkgeworCQljaGFyICp0bXA7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiW2hzMjBdIFJlbW92aW5nIGV4dHJhIENEQVRBIGNvbnRhaW5lciIpOworCQl0bXAgPSBzdHJkdXAoY2RhdGEgKyA5KTsKKwkJaWYgKHRtcCkgeworCQkJY2RhdGFfZW5kID0gc3Ryc3RyKHRtcCwgIl1dPiIpOworCQkJaWYgKGNkYXRhX2VuZCkKKwkJCQkqY2RhdGFfZW5kID0gJ1wwJzsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiW2hzMjBdIG5vZGVDb250YWluZXIgdGV4dCB3aXRoIENEQVRBIGNvbnRhaW5lciByZW1vdmVkOiAnJXMnIiwKKwkJCQkgICB0bXApOworCQkJdG5kcyA9IHhtbF9ub2RlX2Zyb21fYnVmKGN0eC0+eG1sLCB0bXApOworCQkJZnJlZSh0bXApOworCQl9IGVsc2UKKwkJCXRuZHMgPSBOVUxMOworCX0gZWxzZQorCQl0bmRzID0geG1sX25vZGVfZnJvbV9idWYoY3R4LT54bWwsIHN0cik7CisJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgc3RyKTsKKwlpZiAodG5kcyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJbaHMyMF0gQ291bGQgbm90IHBhcnNlIG5vZGVDb250YWluZXIgdGV4dCIpOworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCB1cmkpOworCQlyZXR1cm4gLTE7CisJfQorCisJdW5vZGUgPSB0bmRzX3RvX21vKGN0eC0+eG1sLCB0bmRzKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCB0bmRzKTsKKwlpZiAodW5vZGUgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiW2hzMjBdIENvdWxkIG5vdCBwYXJzZSBub2RlQ29udGFpbmVyIFRORFMgdGV4dCIpOworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCB1cmkpOworCQlyZXR1cm4gLTE7CisJfQorCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgIlBhcnNlZCBUTkRTIiwgdW5vZGUpOworCisJaWYgKGdldF9ub2RlX3VyaShjdHgtPnhtbCwgdW5vZGUsIG5hbWUpID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIltoczIwXSAlcyBub2RlIG5vdCBmb3VuZCIsIG5hbWUpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCB1bm9kZSk7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVyaSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAob3Nfc3RybmNhc2VjbXAodXJpLCAiLi9XaS1GaS8iLCA4KSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJEbyBub3QgYWxsb3cgdXBkYXRlIG91dHNpZGUgLi9XaS1GaSIpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCB1bm9kZSk7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVyaSk7CisJCXJldHVybiAtMTsKKwl9CisJcG9zID0gdXJpICsgODsKKworCWlmIChjdHgtPmZxZG4gPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRlFETiBub3Qga25vd24iKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgdW5vZGUpOworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCB1cmkpOworCQlyZXR1cm4gLTE7CisJfQorCWZxZG5fbGVuID0gb3Nfc3RybGVuKGN0eC0+ZnFkbik7CisJaWYgKG9zX3N0cm5jYXNlY21wKHBvcywgY3R4LT5mcWRuLCBmcWRuX2xlbikgIT0gMCB8fAorCSAgICBwb3NbZnFkbl9sZW5dICE9ICcvJykgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRG8gbm90IGFsbG93IHVwZGF0ZSBvdXRzaWRlIC4vV2ktRmkvJXMiLAorCQkJICAgY3R4LT5mcWRuKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgdW5vZGUpOworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCB1cmkpOworCQlyZXR1cm4gLTE7CisJfQorCXBvcyArPSBmcWRuX2xlbiArIDE7CisKKwlpZiAob3Nfc3RybmNhc2VjbXAocG9zLCAiUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24vIiwgMjQpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkRvIG5vdCBhbGxvdyB1cGRhdGUgb3V0c2lkZSAuL1dpLUZpLyVzL1BlclByb3ZpZGVyU3Vic2NyaXB0aW9uIiwKKwkJCSAgIGN0eC0+ZnFkbik7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHVub2RlKTsKKwkJeG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfZnJlZShjdHgtPnhtbCwgdXJpKTsKKwkJcmV0dXJuIC0xOworCX0KKwlwb3MgKz0gMjQ7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXBkYXRlIGNvbW1hbmQgZm9yIFBQUyBub2RlICVzIiwgcG9zKTsKKworCW5vZGUgPSBnZXRfbm9kZShjdHgtPnhtbCwgcHBzLCBwb3MpOworCWlmIChub2RlKSB7CisJCXBhcmVudCA9IHhtbF9ub2RlX2dldF9wYXJlbnQoY3R4LT54bWwsIG5vZGUpOworCQl4bWxfbm9kZV9kZXRhY2goY3R4LT54bWwsIG5vZGUpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVwbGFjZSAnJXMnIG5vZGUiLCBuYW1lKTsKKwl9IGVsc2UgeworCQljaGFyICpwb3MyOworCQlwb3MyID0gb3Nfc3RycmNocihwb3MsICcvJyk7CisJCWlmIChwb3MyID09IE5VTEwpIHsKKwkJCXBhcmVudCA9IHBwczsKKwkJfSBlbHNlIHsKKwkJCSpwb3MyID0gJ1wwJzsKKwkJCXBhcmVudCA9IGdldF9ub2RlKGN0eC0+eG1sLCBwcHMsIHBvcyk7CisJCX0KKwkJaWYgKHBhcmVudCA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGZpbmQgcGFyZW50ICVzIiwgcG9zKTsKKwkJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHVub2RlKTsKKwkJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVyaSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkFkZCAnJXMnIG5vZGUiLCBuYW1lKTsKKwl9CisJeG1sX25vZGVfYWRkX2NoaWxkKGN0eC0+eG1sLCBwYXJlbnQsIHVub2RlKTsKKworCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVyaSk7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IHVwZGF0ZV9wcHMoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCB4bWxfbm9kZV90ICp1cGRhdGUsCisJCSAgICAgIGNvbnN0IGNoYXIgKnBwc19mbmFtZSwgeG1sX25vZGVfdCAqcHBzKQoreworCXdwYV9wcmludGYoTVNHX0lORk8sICJVcGRhdGluZyBQUFMgYmFzZWQgb24gdXBkYXRlTm9kZSBlbGVtZW50KHMpIik7CisJeG1sX25vZGVfZm9yX2VhY2hfc2libGluZyhjdHgtPnhtbCwgdXBkYXRlKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eC0+eG1sLCB1cGRhdGUpOworCQlpZiAocHJvY2Vzc191cGRhdGVfbm9kZShjdHgsIHBwcywgdXBkYXRlKSA8IDApCisJCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIHVwZGF0ZV9wcHNfZmlsZShjdHgsIHBwc19mbmFtZSwgcHBzKTsKK30KKworCitzdGF0aWMgdm9pZCBoczIwX3N1Yl9yZW1fY29tcGxldGUoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCSAgY29uc3QgY2hhciAqcHBzX2ZuYW1lKQoreworCS8qCisJICogVXBkYXRlIHdwYV9zdXBwbGljYW50IGNyZWRlbnRpYWxzIGFuZCByZWNvbm5lY3QgdXNpbmcgdXBkYXRlZAorCSAqIGluZm9ybWF0aW9uLgorCSAqLworCXdwYV9wcmludGYoTVNHX0lORk8sICJVcGRhdGluZyB3cGFfc3VwcGxpY2FudCBjcmVkZW50aWFscyIpOworCWNtZF9zZXRfcHBzKGN0eCwgcHBzX2ZuYW1lKTsKKworCWlmIChjdHgtPm5vX3JlY29ubmVjdCkKKwkJcmV0dXJuOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlcXVlc3RpbmcgcmVjb25uZWN0aW9uIHdpdGggdXBkYXRlZCBjb25maWd1cmF0aW9uIik7CisJaWYgKHdwYV9jb21tYW5kKGN0eC0+aWZuYW1lLCAiSU5URVJXT1JLSU5HX1NFTEVDVCBhdXRvIikgPCAwKQorCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byByZXF1ZXN0IHdwYV9zdXBwbGljYW50IHRvIHJlY29ubmVjdCIpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogaHMyMF9zcHBfdXBsb2FkX21vKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkgICAgICAgeG1sX25vZGVfdCAqY21kLAorCQkJCSAgICAgICBjb25zdCBjaGFyICpzZXNzaW9uX2lkLAorCQkJCSAgICAgICBjb25zdCBjaGFyICpwcHNfZm5hbWUpCit7CisJeG1sX25hbWVzcGFjZV90ICpuczsKKwl4bWxfbm9kZV90ICpub2RlLCAqcmV0X25vZGU7CisJY2hhciAqdXJuOworCisJdXJuID0gZ2V0X3NwcF9hdHRyX3ZhbHVlKGN0eC0+eG1sLCBjbWQsICJtb1VSTiIpOworCWlmICghdXJuKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBVUk4gaW5jbHVkZWQiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICJVcGxvYWQgTU8gcmVxdWVzdCAtIFVSTj0lcyIsIHVybik7CisJaWYgKHN0cmNhc2VjbXAodXJuLCBVUk5fSFMyMF9QUFMpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuc3VwcG9ydGVkIG1vVVJOIik7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVybik7CisJCXJldHVybiBOVUxMOworCX0KKwl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCB1cm4pOworCisJaWYgKCFwcHNfZm5hbWUpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBQUyBmaWxlIG5hbWUgbm8ga25vd24iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJbm9kZSA9IGJ1aWxkX3NwcF9wb3N0X2Rldl9kYXRhKGN0eCwgJm5zLCBzZXNzaW9uX2lkLAorCQkJCSAgICAgICAiTU8gdXBsb2FkIik7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJYWRkX21vX2NvbnRhaW5lcihjdHgtPnhtbCwgbnMsIG5vZGUsIFVSTl9IUzIwX1BQUywgcHBzX2ZuYW1lKTsKKworCXJldF9ub2RlID0gc29hcF9zZW5kX3JlY2VpdmUoY3R4LT5odHRwLCBub2RlKTsKKwlpZiAocmV0X25vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlkZWJ1Z19kdW1wX25vZGUoY3R4LCAiUmVjZWl2ZWQgcmVzcG9uc2UgdG8gTU8gdXBsb2FkIiwgcmV0X25vZGUpOworCisJaWYgKGhzMjBfc3BwX3ZhbGlkYXRlKGN0eCwgcmV0X25vZGUsICJzcHBQb3N0RGV2RGF0YVJlc3BvbnNlIikgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJTUFAgdmFsaWRhdGlvbiBmYWlsZWQiKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcmV0X25vZGUpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXR1cm4gcmV0X25vZGU7Cit9CisKKworc3RhdGljIGludCBoczIwX2FkZF9tbyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIHhtbF9ub2RlX3QgKmFkZF9tbywKKwkJICAgICAgIGNoYXIgKmZuYW1lLCBzaXplX3QgZm5hbWVfbGVuKQoreworCWNoYXIgKnVyaSwgKnVybjsKKwlpbnQgcmV0OworCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgIlJlY2VpdmVkIGFkZE1PIiwgYWRkX21vKTsKKworCXVybiA9IGdldF9zcHBfYXR0cl92YWx1ZShjdHgtPnhtbCwgYWRkX21vLCAibW9VUk4iKTsKKwlpZiAodXJuID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIltoczIwXSBObyBtb1VSTiBpbiBhZGRNTyIpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICJhZGRNTyAtIG1vVVJOOiAnJXMnIiwgdXJuKTsKKwlpZiAoc3RyY2FzZWNtcCh1cm4sIFVSTl9IUzIwX1BQUykgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiW2hzMjBdIFVuc3VwcG9ydGVkIE1PIGluIGFkZE1PIik7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHVybik7CisJCXJldHVybiAtMTsKKwl9CisJeG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfZnJlZShjdHgtPnhtbCwgdXJuKTsKKworCXVyaSA9IGdldF9zcHBfYXR0cl92YWx1ZShjdHgtPnhtbCwgYWRkX21vLCAibWFuYWdlbWVudFRyZWVVUkkiKTsKKwlpZiAodXJpID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIltoczIwXSBObyBtYW5hZ2VtZW50VHJlZVVSSSBpbiBhZGRNTyIpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9wcmludGYoTVNHX0lORk8sICJhZGRNTyAtIG1hbmFnZW1lbnRUcmVlVVJJOiAnJXMnIiwgdXJpKTsKKworCXJldCA9IGhzMjBfYWRkX3Bwc19tbyhjdHgsIHVyaSwgYWRkX21vLCBmbmFtZSwgZm5hbWVfbGVuKTsKKwl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCB1cmkpOworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBwcm9jZXNzX3NwcF91c2VyX2lucHV0X3Jlc3BvbnNlKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwKKwkJCQkJICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwKKwkJCQkJICAgeG1sX25vZGVfdCAqYWRkX21vKQoreworCWludCByZXQ7CisJY2hhciBmbmFtZVszMDBdOworCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgImFkZE1PIiwgYWRkX21vKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJTdWJzY3JpcHRpb24gcmVnaXN0cmF0aW9uIGNvbXBsZXRlZCIpOworCisJaWYgKGhzMjBfYWRkX21vKGN0eCwgYWRkX21vLCBmbmFtZSwgc2l6ZW9mKGZuYW1lKSkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgYWRkIE1PIik7CisJCXJldCA9IGhzMjBfc3BwX3VwZGF0ZV9yZXNwb25zZSgKKwkJCWN0eCwgc2Vzc2lvbl9pZCwKKwkJCSJFcnJvciBvY2N1cnJlZCIsCisJCQkiTU8gYWRkaXRpb24gb3IgdXBkYXRlIGZhaWxlZCIpOworCQlyZXR1cm4gMDsKKwl9CisKKwlyZXQgPSBoczIwX3NwcF91cGRhdGVfcmVzcG9uc2UoY3R4LCBzZXNzaW9uX2lkLCAiT0siLCBOVUxMKTsKKwlpZiAocmV0ID09IDApCisJCWhzMjBfc3ViX3JlbV9jb21wbGV0ZShjdHgsIGZuYW1lKTsKKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogaHMyMF9zcHBfdXNlcl9pbnB1dF9jb21wbGV0ZWQoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCQkJICAgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQpCit7CisJeG1sX25vZGVfdCAqbm9kZSwgKnJldF9ub2RlOworCisJbm9kZSA9IGJ1aWxkX3NwcF9wb3N0X2Rldl9kYXRhKGN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCQkgICAgICAgIlVzZXIgaW5wdXQgY29tcGxldGVkIik7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXRfbm9kZSA9IHNvYXBfc2VuZF9yZWNlaXZlKGN0eC0+aHR0cCwgbm9kZSk7CisJaWYgKCFyZXRfbm9kZSkgeworCQlpZiAoc29hcF9yZWluaXRfY2xpZW50KGN0eC0+aHR0cCkgPCAwKQorCQkJcmV0dXJuIE5VTEw7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJUcnkgdG8gZmluaXNoIHdpdGggcmUtb3BlbmVkIGNvbm5lY3Rpb24iKTsKKwkJbm9kZSA9IGJ1aWxkX3NwcF9wb3N0X2Rldl9kYXRhKGN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCQkJICAgICAgICJVc2VyIGlucHV0IGNvbXBsZXRlZCIpOworCQlpZiAobm9kZSA9PSBOVUxMKQorCQkJcmV0dXJuIE5VTEw7CisJCXJldF9ub2RlID0gc29hcF9zZW5kX3JlY2VpdmUoY3R4LT5odHRwLCBub2RlKTsKKwkJaWYgKHJldF9ub2RlID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvbnRpbnVlIHdpdGggbmV3IGNvbm5lY3Rpb24iKTsKKwl9CisKKwlpZiAoaHMyMF9zcHBfdmFsaWRhdGUoY3R4LCByZXRfbm9kZSwgInNwcFBvc3REZXZEYXRhUmVzcG9uc2UiKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNQUCB2YWxpZGF0aW9uIGZhaWxlZCIpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCByZXRfbm9kZSk7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiByZXRfbm9kZTsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGhzMjBfc3BwX2dldF9jZXJ0aWZpY2F0ZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJCSAgICAgeG1sX25vZGVfdCAqY21kLAorCQkJCQkgICAgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJCSAgICAgY29uc3QgY2hhciAqcHBzX2ZuYW1lKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqbm9kZSwgKnJldF9ub2RlOworCWludCByZXM7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ2xpZW50IGNlcnRpZmljYXRlIGVucm9sbG1lbnQiKTsKKworCXJlcyA9IG9zdV9nZXRfY2VydGlmaWNhdGUoY3R4LCBjbWQpOworCWlmIChyZXMgPCAwKQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRVNUIHNpbXBsZUVucm9sbCBmYWlsZWQiKTsKKworCW5vZGUgPSBidWlsZF9zcHBfcG9zdF9kZXZfZGF0YShjdHgsICZucywgc2Vzc2lvbl9pZCwKKwkJCQkgICAgICAgcmVzID09IDAgPworCQkJCSAgICAgICAiQ2VydGlmaWNhdGUgZW5yb2xsbWVudCBjb21wbGV0ZWQiIDoKKwkJCQkgICAgICAgIkNlcnRpZmljYXRlIGVucm9sbG1lbnQgZmFpbGVkIik7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXRfbm9kZSA9IHNvYXBfc2VuZF9yZWNlaXZlKGN0eC0+aHR0cCwgbm9kZSk7CisJaWYgKHJldF9ub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgIlJlY2VpdmVkIHJlc3BvbnNlIHRvIGNlcnRpZmljYXRlIGVucm9sbG1lbnQgIgorCQkJImNvbXBsZXRlZCIsIHJldF9ub2RlKTsKKworCWlmIChoczIwX3NwcF92YWxpZGF0ZShjdHgsIHJldF9ub2RlLCAic3BwUG9zdERldkRhdGFSZXNwb25zZSIpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU1BQIHZhbGlkYXRpb24gZmFpbGVkIik7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHJldF9ub2RlKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0dXJuIHJldF9ub2RlOworfQorCisKK3N0YXRpYyBpbnQgaHMyMF9zcHBfZXhlYyhzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIHhtbF9ub2RlX3QgKmV4ZWMsCisJCQkgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwgY29uc3QgY2hhciAqcHBzX2ZuYW1lLAorCQkJIHhtbF9ub2RlX3QgKnBwcywgeG1sX25vZGVfdCAqKnJldF9ub2RlKQoreworCXhtbF9ub2RlX3QgKmNtZDsKKwljb25zdCBjaGFyICpuYW1lOworCWNoYXIgKnVyaTsKKwljaGFyICppZCA9IHN0cmR1cChzZXNzaW9uX2lkKTsKKworCWlmIChpZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwkqcmV0X25vZGUgPSBOVUxMOworCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgImV4ZWMiLCBleGVjKTsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjbWQsIGV4ZWMpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNtZCk7CisJCWJyZWFrOworCX0KKwlpZiAoIWNtZCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiZXhlYyBjb21tYW5kIGVsZW1lbnQgbm90IGZvdW5kIChjbWQ9JXApIiwKKwkJCSAgIGNtZCk7CisJCWZyZWUoaWQpOworCQlyZXR1cm4gLTE7CisJfQorCisJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LT54bWwsIGNtZCk7CisKKwlpZiAoc3RyY2FzZWNtcChuYW1lLCAibGF1bmNoQnJvd3NlclRvVVJJIikgPT0gMCkgeworCQlpbnQgcmVzOworCQl1cmkgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgY21kKTsKKwkJaWYgKCF1cmkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBVUkkgZm91bmQiKTsKKwkJCWZyZWUoaWQpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJMYXVuY2ggYnJvd3NlciB0byBVUkkgJyVzJyIsIHVyaSk7CisJCXdyaXRlX3N1bW1hcnkoY3R4LCAiTGF1bmNoIGJyb3dzZXIgdG8gVVJJICclcyciLCB1cmkpOworCQlyZXMgPSBoczIwX3dlYl9icm93c2VyKHVyaSk7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHVyaSk7CisJCWlmIChyZXMgPiAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXNlciByZXNwb25zZSBpbiBicm93c2VyIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkgLSBzZXNzaW9uaWQ9JyVzJyIsCisJCQkJICAgaWQpOworCQkJd3JpdGVfc3VtbWFyeShjdHgsICJVc2VyIHJlc3BvbnNlIGluIGJyb3dzZXIgY29tcGxldGVkIHN1Y2Nlc3NmdWxseSIpOworCQkJKnJldF9ub2RlID0gaHMyMF9zcHBfdXNlcl9pbnB1dF9jb21wbGV0ZWQoY3R4LCBpZCk7CisJCQlmcmVlKGlkKTsKKwkJCXJldHVybiAqcmV0X25vZGUgPyAwIDogLTE7CisJCX0gZWxzZSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHJlY2VpdmUgdXNlciByZXNwb25zZSIpOworCQkJd3JpdGVfc3VtbWFyeShjdHgsICJGYWlsZWQgdG8gcmVjZWl2ZSB1c2VyIHJlc3BvbnNlIik7CisJCQloczIwX3NwcF91cGRhdGVfcmVzcG9uc2UoCisJCQkJY3R4LCBpZCwgIkVycm9yIG9jY3VycmVkIiwgIk90aGVyIik7CisJCQlmcmVlKGlkKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAoc3RyY2FzZWNtcChuYW1lLCAidXBsb2FkTU8iKSA9PSAwKSB7CisJCWlmIChwcHNfZm5hbWUgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJKnJldF9ub2RlID0gaHMyMF9zcHBfdXBsb2FkX21vKGN0eCwgY21kLCBpZCwKKwkJCQkJICAgICAgIHBwc19mbmFtZSk7CisJCWZyZWUoaWQpOworCQlyZXR1cm4gKnJldF9ub2RlID8gMCA6IC0xOworCX0KKworCWlmIChzdHJjYXNlY21wKG5hbWUsICJnZXRDZXJ0aWZpY2F0ZSIpID09IDApIHsKKwkJKnJldF9ub2RlID0gaHMyMF9zcHBfZ2V0X2NlcnRpZmljYXRlKGN0eCwgY21kLCBpZCwKKwkJCQkJCSAgICAgcHBzX2ZuYW1lKTsKKwkJZnJlZShpZCk7CisJCXJldHVybiAqcmV0X25vZGUgPyAwIDogLTE7CisJfQorCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuc3VwcG9ydGVkIGV4ZWMgY29tbWFuZDogJyVzJyIsIG5hbWUpOworCWZyZWUoaWQpOworCXJldHVybiAtMTsKK30KKworCitlbnVtIHNwcF9wb3N0X2Rldl9kYXRhX3VzZSB7CisJU1BQX1NVQlNDUklQVElPTl9SRU1FRElBVElPTiwKKwlTUFBfUE9MSUNZX1VQREFURSwKKwlTUFBfU1VCU0NSSVBUSU9OX1JFR0lTVFJBVElPTiwKK307CisKK3N0YXRpYyB2b2lkIHByb2Nlc3Nfc3BwX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2UoCisJc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCWVudW0gc3BwX3Bvc3RfZGV2X2RhdGFfdXNlIHVzZSwgeG1sX25vZGVfdCAqbm9kZSwKKwljb25zdCBjaGFyICpwcHNfZm5hbWUsIHhtbF9ub2RlX3QgKnBwcykKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKwljaGFyICpzdGF0dXMgPSBOVUxMOworCXhtbF9ub2RlX3QgKnVwZGF0ZSA9IE5VTEwsICpleGVjID0gTlVMTCwgKmFkZF9tbyA9IE5VTEwsICpub19tbyA9IE5VTEw7CisJY2hhciAqc2Vzc2lvbl9pZCA9IE5VTEw7CisKKwlkZWJ1Z19kdW1wX25vZGUoY3R4LCAic3BwUG9zdERldkRhdGFSZXNwb25zZSBub2RlIiwgbm9kZSk7CisKKwlzdGF0dXMgPSBnZXRfc3BwX2F0dHJfdmFsdWUoY3R4LT54bWwsIG5vZGUsICJzcHBTdGF0dXMiKTsKKwlpZiAoc3RhdHVzID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIHNwcFN0YXR1cyBhdHRyaWJ1dGUiKTsKKwkJZ290byBvdXQ7CisJfQorCXdyaXRlX3N1bW1hcnkoY3R4LCAiUmVjZWl2ZWQgc3BwUG9zdERldkRhdGFSZXNwb25zZSBzcHBTdGF0dXM9JyVzJyIsCisJCSAgICAgIHN0YXR1cyk7CisKKwlzZXNzaW9uX2lkID0gZ2V0X3NwcF9hdHRyX3ZhbHVlKGN0eC0+eG1sLCBub2RlLCAic2Vzc2lvbklEIik7CisJaWYgKHNlc3Npb25faWQgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gc2Vzc2lvbklEIGF0dHJpYnV0ZSIpOworCQlnb3RvIG91dDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiW2hzMjBdIHNwcFBvc3REZXZEYXRhUmVzcG9uc2UgLSBzcHBTdGF0dXM6ICclcycgIHNlc3Npb25JRDogJyVzJyIsCisJCSAgIHN0YXR1cywgc2Vzc2lvbl9pZCk7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgtPnhtbCwgY2hpbGQsIG5vZGUpIHsKKwkJY29uc3QgY2hhciAqbmFtZTsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LT54bWwsIGNoaWxkKTsKKwkJZGVidWdfZHVtcF9ub2RlKGN0eCwgImNoaWxkIiwgY2hpbGQpOworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgY2hpbGQpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAibG9jYWxuYW1lOiAnJXMnIiwgbmFtZSk7CisJCWlmICghdXBkYXRlICYmIHN0cmNhc2VjbXAobmFtZSwgInVwZGF0ZU5vZGUiKSA9PSAwKQorCQkJdXBkYXRlID0gY2hpbGQ7CisJCWlmICghZXhlYyAmJiBzdHJjYXNlY21wKG5hbWUsICJleGVjIikgPT0gMCkKKwkJCWV4ZWMgPSBjaGlsZDsKKwkJaWYgKCFhZGRfbW8gJiYgc3RyY2FzZWNtcChuYW1lLCAiYWRkTU8iKSA9PSAwKQorCQkJYWRkX21vID0gY2hpbGQ7CisJCWlmICghbm9fbW8gJiYgc3RyY2FzZWNtcChuYW1lLCAibm9NT1VwZGF0ZSIpID09IDApCisJCQlub19tbyA9IGNoaWxkOworCX0KKworCWlmICh1c2UgPT0gU1BQX1NVQlNDUklQVElPTl9SRU1FRElBVElPTiAmJgorCSAgICBzdHJjYXNlY21wKHN0YXR1cywKKwkJICAgICAgICJSZW1lZGlhdGlvbiBjb21wbGV0ZSwgcmVxdWVzdCBzcHBVcGRhdGVSZXNwb25zZSIpID09IDApCisJeworCQlpbnQgcmVzLCByZXQ7CisJCWlmICghdXBkYXRlICYmICFub19tbykgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIHVwZGF0ZU5vZGUgb3Igbm9NT1VwZGF0ZSBlbGVtZW50Iik7CisJCQlnb3RvIG91dDsKKwkJfQorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIGNvbXBsZXRlZCIpOworCQlyZXMgPSB1cGRhdGVfcHBzKGN0eCwgdXBkYXRlLCBwcHNfZm5hbWUsIHBwcyk7CisJCWlmIChyZXMgPCAwKQorCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byB1cGRhdGUgUFBTIE1PIik7CisJCXJldCA9IGhzMjBfc3BwX3VwZGF0ZV9yZXNwb25zZSgKKwkJCWN0eCwgc2Vzc2lvbl9pZCwKKwkJCXJlcyA8IDAgPyAiRXJyb3Igb2NjdXJyZWQiIDogIk9LIiwKKwkJCXJlcyA8IDAgPyAiTU8gYWRkaXRpb24gb3IgdXBkYXRlIGZhaWxlZCIgOiBOVUxMKTsKKwkJaWYgKHJlcyA9PSAwICYmIHJldCA9PSAwKQorCQkJaHMyMF9zdWJfcmVtX2NvbXBsZXRlKGN0eCwgcHBzX2ZuYW1lKTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKHVzZSA9PSBTUFBfU1VCU0NSSVBUSU9OX1JFTUVESUFUSU9OICYmCisJICAgIHN0cmNhc2VjbXAoc3RhdHVzLCAiRXhjaGFuZ2UgY29tcGxldGUsIHJlbGVhc2UgVExTIGNvbm5lY3Rpb24iKSA9PQorCSAgICAwKSB7CisJCWlmICghbm9fbW8pIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBub01PVXBkYXRlIGVsZW1lbnQiKTsKKwkJCWdvdG8gb3V0OworCQl9CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJTdWJzY3JpcHRpb24gcmVtZWRpYXRpb24gY29tcGxldGVkIChubyBNTyB1cGRhdGUpIik7CisJCWdvdG8gb3V0OworCX0KKworCWlmICh1c2UgPT0gU1BQX1BPTElDWV9VUERBVEUgJiYKKwkgICAgc3RyY2FzZWNtcChzdGF0dXMsICJVcGRhdGUgY29tcGxldGUsIHJlcXVlc3Qgc3BwVXBkYXRlUmVzcG9uc2UiKSA9PQorCSAgICAwKSB7CisJCWludCByZXMsIHJldDsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBvbGljeSB1cGRhdGUgcmVjZWl2ZWQgLSB1cGRhdGUgUFBTIik7CisJCXJlcyA9IHVwZGF0ZV9wcHMoY3R4LCB1cGRhdGUsIHBwc19mbmFtZSwgcHBzKTsKKwkJcmV0ID0gaHMyMF9zcHBfdXBkYXRlX3Jlc3BvbnNlKAorCQkJY3R4LCBzZXNzaW9uX2lkLAorCQkJcmVzIDwgMCA/ICJFcnJvciBvY2N1cnJlZCIgOiAiT0siLAorCQkJcmVzIDwgMCA/ICJNTyBhZGRpdGlvbiBvciB1cGRhdGUgZmFpbGVkIiA6IE5VTEwpOworCQlpZiAocmVzID09IDAgJiYgcmV0ID09IDApCisJCQloczIwX3BvbGljeV91cGRhdGVfY29tcGxldGUoY3R4LCBwcHNfZm5hbWUpOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAodXNlID09IFNQUF9TVUJTQ1JJUFRJT05fUkVHSVNUUkFUSU9OICYmCisJICAgIHN0cmNhc2VjbXAoc3RhdHVzLCAiUHJvdmlzaW9uaW5nIGNvbXBsZXRlLCByZXF1ZXN0ICIKKwkJICAgICAgICJzcHBVcGRhdGVSZXNwb25zZSIpICA9PSAwKSB7CisJCWlmICghYWRkX21vKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gYWRkTU8gZWxlbWVudCAtIG5vdCBzdXJlIHdoYXQgdG8gZG8gbmV4dCIpOworCQkJZ290byBvdXQ7CisJCX0KKwkJcHJvY2Vzc19zcHBfdXNlcl9pbnB1dF9yZXNwb25zZShjdHgsIHNlc3Npb25faWQsIGFkZF9tbyk7CisJCW5vZGUgPSBOVUxMOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAoc3RyY2FzZWNtcChzdGF0dXMsICJObyB1cGRhdGUgYXZhaWxhYmxlIGF0IHRoaXMgdGltZSIpID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIHVwZGF0ZSBhdmFpbGFibGUgYXQgdGhpcyB0aW1lIik7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChzdHJjYXNlY21wKHN0YXR1cywgIk9LIikgPT0gMCkgeworCQlpbnQgcmVzOworCQl4bWxfbm9kZV90ICpyZXQ7CisKKwkJaWYgKCFleGVjKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gZXhlYyBlbGVtZW50IC0gbm90IHN1cmUgd2hhdCB0byBkbyBuZXh0Iik7CisJCQlnb3RvIG91dDsKKwkJfQorCQlyZXMgPSBoczIwX3NwcF9leGVjKGN0eCwgZXhlYywgc2Vzc2lvbl9pZCwKKwkJCQkgICAgcHBzX2ZuYW1lLCBwcHMsICZyZXQpOworCQkvKiB4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBub2RlKTsgKi8KKwkJbm9kZSA9IE5VTEw7CisJCWlmIChyZXMgPT0gMCAmJiByZXQpCisJCQlwcm9jZXNzX3NwcF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgdXNlLAorCQkJCQkJCSAgIHJldCwgcHBzX2ZuYW1lLCBwcHMpOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAoc3RyY2FzZWNtcChzdGF0dXMsICJFcnJvciBvY2N1cnJlZCIpID09IDApIHsKKwkJeG1sX25vZGVfdCAqZXJyOworCQljaGFyICpjb2RlID0gTlVMTDsKKwkJZXJyID0gZ2V0X25vZGUoY3R4LT54bWwsIG5vZGUsICJzcHBFcnJvciIpOworCQlpZiAoZXJyKQorCQkJY29kZSA9IHhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlKGN0eC0+eG1sLCBlcnIsCisJCQkJCQkgICAgICAgImVycm9yQ29kZSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRXJyb3Igb2NjdXJyZWQgLSBlcnJvckNvZGU9JXMiLAorCQkJICAgY29kZSA/IGNvZGUgOiAiTi9BIik7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIGNvZGUpOworCQlnb3RvIG91dDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLAorCQkgICAiW2hzMjBdIFVuc3VwcG9ydGVkIHNwcFBvc3REZXZEYXRhUmVzcG9uc2Ugc3BwU3RhdHVzICclcyciLAorCQkgICBzdGF0dXMpOworb3V0OgorCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHN0YXR1cyk7CisJeG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfZnJlZShjdHgtPnhtbCwgc2Vzc2lvbl9pZCk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgbm9kZSk7Cit9CisKKworc3RhdGljIGludCBzcHBfcG9zdF9kZXZfZGF0YShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkgICAgIGVudW0gc3BwX3Bvc3RfZGV2X2RhdGFfdXNlIHVzZSwKKwkJCSAgICAgY29uc3QgY2hhciAqcmVhc29uLAorCQkJICAgICBjb25zdCBjaGFyICpwcHNfZm5hbWUsIHhtbF9ub2RlX3QgKnBwcykKK3sKKwl4bWxfbm9kZV90ICpwYXlsb2FkOworCXhtbF9ub2RlX3QgKnJldF9ub2RlOworCisJcGF5bG9hZCA9IGJ1aWxkX3NwcF9wb3N0X2Rldl9kYXRhKGN0eCwgTlVMTCwgTlVMTCwgcmVhc29uKTsKKwlpZiAocGF5bG9hZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlyZXRfbm9kZSA9IHNvYXBfc2VuZF9yZWNlaXZlKGN0eC0+aHR0cCwgcGF5bG9hZCk7CisJaWYgKCFyZXRfbm9kZSkgeworCQljb25zdCBjaGFyICplcnIgPSBodHRwX2dldF9lcnIoY3R4LT5odHRwKTsKKwkJaWYgKGVycikgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkhUVFAgZXJyb3I6ICVzIiwgZXJyKTsKKwkJCXdyaXRlX3Jlc3VsdChjdHgsICJIVFRQIGVycm9yOiAlcyIsIGVycik7CisJCX0gZWxzZSB7CisJCQl3cml0ZV9zdW1tYXJ5KGN0eCwgIkZhaWxlZCB0byBzZW5kIFNPQVAgbWVzc2FnZSIpOworCQl9CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoaHMyMF9zcHBfdmFsaWRhdGUoY3R4LCByZXRfbm9kZSwgInNwcFBvc3REZXZEYXRhUmVzcG9uc2UiKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNQUCB2YWxpZGF0aW9uIGZhaWxlZCIpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCByZXRfbm9kZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlwcm9jZXNzX3NwcF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgdXNlLCByZXRfbm9kZSwKKwkJCQkJICAgcHBzX2ZuYW1lLCBwcHMpOworCXJldHVybiAwOworfQorCisKK3ZvaWQgc3BwX3N1Yl9yZW0oc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LCBjb25zdCBjaGFyICphZGRyZXNzLAorCQkgY29uc3QgY2hhciAqcHBzX2ZuYW1lLAorCQkgY29uc3QgY2hhciAqY2xpZW50X2NlcnQsIGNvbnN0IGNoYXIgKmNsaWVudF9rZXksCisJCSBjb25zdCBjaGFyICpjcmVkX3VzZXJuYW1lLCBjb25zdCBjaGFyICpjcmVkX3Bhc3N3b3JkLAorCQkgeG1sX25vZGVfdCAqcHBzKQoreworCXdwYV9wcmludGYoTVNHX0lORk8sICJTUFAgc3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIik7CisJd3JpdGVfc3VtbWFyeShjdHgsICJTUFAgc3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIik7CisKKwlvc19mcmVlKGN0eC0+c2VydmVyX3VybCk7CisJY3R4LT5zZXJ2ZXJfdXJsID0gb3Nfc3RyZHVwKGFkZHJlc3MpOworCisJaWYgKHNvYXBfaW5pdF9jbGllbnQoY3R4LT5odHRwLCBhZGRyZXNzLCBjdHgtPmNhX2ZuYW1lLAorCQkJICAgICBjcmVkX3VzZXJuYW1lLCBjcmVkX3Bhc3N3b3JkLCBjbGllbnRfY2VydCwKKwkJCSAgICAgY2xpZW50X2tleSkgPT0gMCkgeworCQlzcHBfcG9zdF9kZXZfZGF0YShjdHgsIFNQUF9TVUJTQ1JJUFRJT05fUkVNRURJQVRJT04sCisJCQkJICAiU3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIiwgcHBzX2ZuYW1lLCBwcHMpOworCX0KK30KKworCitzdGF0aWMgdm9pZCBoczIwX3BvbGljeV91cGRhdGVfY29tcGxldGUoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCQljb25zdCBjaGFyICpwcHNfZm5hbWUpCit7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBvbGljeSB1cGRhdGUgY29tcGxldGVkIik7CisKKwkvKgorCSAqIFVwZGF0ZSB3cGFfc3VwcGxpY2FudCBjcmVkZW50aWFscyBhbmQgcmVjb25uZWN0IHVzaW5nIHVwZGF0ZWQKKwkgKiBpbmZvcm1hdGlvbi4KKwkgKi8KKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVXBkYXRpbmcgd3BhX3N1cHBsaWNhbnQgY3JlZGVudGlhbHMiKTsKKwljbWRfc2V0X3BwcyhjdHgsIHBwc19mbmFtZSk7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVxdWVzdGluZyByZWNvbm5lY3Rpb24gd2l0aCB1cGRhdGVkIGNvbmZpZ3VyYXRpb24iKTsKKwlpZiAod3BhX2NvbW1hbmQoY3R4LT5pZm5hbWUsICJJTlRFUldPUktJTkdfU0VMRUNUIGF1dG8iKSA8IDApCisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiRmFpbGVkIHRvIHJlcXVlc3Qgd3BhX3N1cHBsaWNhbnQgdG8gcmVjb25uZWN0Iik7Cit9CisKKworc3RhdGljIGludCBwcm9jZXNzX3NwcF9leGNoYW5nZV9jb21wbGV0ZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJCSB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnN0YXR1cywgKnNlc3Npb25faWQ7CisKKwlkZWJ1Z19kdW1wX25vZGUoY3R4LCAic3BwRXhjaGFuZ2VDb21wbGV0ZSIsIG5vZGUpOworCisJc3RhdHVzID0gZ2V0X3NwcF9hdHRyX3ZhbHVlKGN0eC0+eG1sLCBub2RlLCAic3BwU3RhdHVzIik7CisJaWYgKHN0YXR1cyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBzcHBTdGF0dXMgYXR0cmlidXRlIik7CisJCXJldHVybiAtMTsKKwl9CisJd3JpdGVfc3VtbWFyeShjdHgsICJSZWNlaXZlZCBzcHBFeGNoYW5nZUNvbXBsZXRlIHNwcFN0YXR1cz0nJXMnIiwKKwkJICAgICAgc3RhdHVzKTsKKworCXNlc3Npb25faWQgPSBnZXRfc3BwX2F0dHJfdmFsdWUoY3R4LT54bWwsIG5vZGUsICJzZXNzaW9uSUQiKTsKKwlpZiAoc2Vzc2lvbl9pZCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBzZXNzaW9uSUQgYXR0cmlidXRlIik7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHN0YXR1cyk7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiW2hzMjBdIHNwcFN0YXR1czogJyVzJyAgc2Vzc2lvbklEOiAnJXMnIiwKKwkJICAgc3RhdHVzLCBzZXNzaW9uX2lkKTsKKwl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCBzZXNzaW9uX2lkKTsKKworCWlmIChzdHJjYXNlY21wKHN0YXR1cywgIkV4Y2hhbmdlIGNvbXBsZXRlLCByZWxlYXNlIFRMUyBjb25uZWN0aW9uIikgPT0KKwkgICAgMCkgeworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCBzdGF0dXMpOworCQlyZXR1cm4gMDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVW5leHBlY3RlZCBzcHBTdGF0dXMgJyVzJyIsIHN0YXR1cyk7CisJd3JpdGVfc3VtbWFyeShjdHgsICJVbmV4cGVjdGVkIHNwcFN0YXR1cyAnJXMnIiwgc3RhdHVzKTsKKwl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCBzdGF0dXMpOworCXJldHVybiAtMTsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX3NwcF91cGRhdGVfcmVzcG9uc2Uoc3RydWN0IGhzMjBfb3N1X2NsaWVudCAqY3R4LAorCQkJCQkgICAgICBjb25zdCBjaGFyICpzZXNzaW9uX2lkLAorCQkJCQkgICAgICBjb25zdCBjaGFyICpzcHBfc3RhdHVzLAorCQkJCQkgICAgICBjb25zdCBjaGFyICplcnJvcl9jb2RlKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqc3BwX25vZGUsICpub2RlOworCisJc3BwX25vZGUgPSB4bWxfbm9kZV9jcmVhdGVfcm9vdChjdHgtPnhtbCwgU1BQX05TX1VSSSwgInNwcCIsICZucywKKwkJCQkJInNwcFVwZGF0ZVJlc3BvbnNlIik7CisJaWYgKHNwcF9ub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInNwcFZlcnNpb24iLCAiMS4wIik7CisJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInNlc3Npb25JRCIsIHNlc3Npb25faWQpOworCXhtbF9ub2RlX2FkZF9hdHRyKGN0eC0+eG1sLCBzcHBfbm9kZSwgbnMsICJzcHBTdGF0dXMiLCBzcHBfc3RhdHVzKTsKKworCWlmIChlcnJvcl9jb2RlKSB7CisJCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInNwcEVycm9yIik7CisJCWlmIChub2RlKQorCQkJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIG5vZGUsIE5VTEwsICJlcnJvckNvZGUiLAorCQkJCQkgIGVycm9yX2NvZGUpOworCX0KKworCXJldHVybiBzcHBfbm9kZTsKK30KKworCitzdGF0aWMgaW50IGhzMjBfc3BwX3VwZGF0ZV9yZXNwb25zZShzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsCisJCQkJICAgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJICAgIGNvbnN0IGNoYXIgKnNwcF9zdGF0dXMsCisJCQkJICAgIGNvbnN0IGNoYXIgKmVycm9yX2NvZGUpCit7CisJeG1sX25vZGVfdCAqbm9kZSwgKnJldF9ub2RlOworCWludCByZXQ7CisKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIkJ1aWxkaW5nIHNwcFVwZGF0ZVJlc3BvbnNlIHNwcFN0YXR1cz0nJXMnIGVycm9yX2NvZGU9JyVzJyIsCisJCSAgICAgIHNwcF9zdGF0dXMsIGVycm9yX2NvZGUpOworCW5vZGUgPSBidWlsZF9zcHBfdXBkYXRlX3Jlc3BvbnNlKGN0eCwgc2Vzc2lvbl9pZCwgc3BwX3N0YXR1cywKKwkJCQkJIGVycm9yX2NvZGUpOworCWlmIChub2RlID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlyZXRfbm9kZSA9IHNvYXBfc2VuZF9yZWNlaXZlKGN0eC0+aHR0cCwgbm9kZSk7CisJaWYgKCFyZXRfbm9kZSkgeworCQlpZiAoc29hcF9yZWluaXRfY2xpZW50KGN0eC0+aHR0cCkgPCAwKQorCQkJcmV0dXJuIC0xOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVHJ5IHRvIGZpbmlzaCB3aXRoIHJlLW9wZW5lZCBjb25uZWN0aW9uIik7CisJCW5vZGUgPSBidWlsZF9zcHBfdXBkYXRlX3Jlc3BvbnNlKGN0eCwgc2Vzc2lvbl9pZCwgc3BwX3N0YXR1cywKKwkJCQkJCSBlcnJvcl9jb2RlKTsKKwkJaWYgKG5vZGUgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJcmV0X25vZGUgPSBzb2FwX3NlbmRfcmVjZWl2ZShjdHgtPmh0dHAsIG5vZGUpOworCQlpZiAocmV0X25vZGUgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvbnRpbnVlIHdpdGggbmV3IGNvbm5lY3Rpb24iKTsKKwl9CisKKwlpZiAoaHMyMF9zcHBfdmFsaWRhdGUoY3R4LCByZXRfbm9kZSwgInNwcEV4Y2hhbmdlQ29tcGxldGUiKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNQUCB2YWxpZGF0aW9uIGZhaWxlZCIpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCByZXRfbm9kZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXQgPSBwcm9jZXNzX3NwcF9leGNoYW5nZV9jb21wbGV0ZShjdHgsIHJldF9ub2RlKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCByZXRfbm9kZSk7CisJcmV0dXJuIHJldDsKK30KKworCit2b2lkIHNwcF9wb2xfdXBkKHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqYWRkcmVzcywKKwkJIGNvbnN0IGNoYXIgKnBwc19mbmFtZSwKKwkJIGNvbnN0IGNoYXIgKmNsaWVudF9jZXJ0LCBjb25zdCBjaGFyICpjbGllbnRfa2V5LAorCQkgY29uc3QgY2hhciAqY3JlZF91c2VybmFtZSwgY29uc3QgY2hhciAqY3JlZF9wYXNzd29yZCwKKwkJIHhtbF9ub2RlX3QgKnBwcykKK3sKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU1BQIHBvbGljeSB1cGRhdGUiKTsKKwl3cml0ZV9zdW1tYXJ5KGN0eCwgIlNQUCBwb2xpY3kgdXBkYXRlIik7CisKKwlvc19mcmVlKGN0eC0+c2VydmVyX3VybCk7CisJY3R4LT5zZXJ2ZXJfdXJsID0gb3Nfc3RyZHVwKGFkZHJlc3MpOworCisJaWYgKHNvYXBfaW5pdF9jbGllbnQoY3R4LT5odHRwLCBhZGRyZXNzLCBjdHgtPmNhX2ZuYW1lLCBjcmVkX3VzZXJuYW1lLAorCQkJICAgICBjcmVkX3Bhc3N3b3JkLCBjbGllbnRfY2VydCwgY2xpZW50X2tleSkgPT0gMCkgeworCQlzcHBfcG9zdF9kZXZfZGF0YShjdHgsIFNQUF9QT0xJQ1lfVVBEQVRFLCAiUG9saWN5IHVwZGF0ZSIsCisJCQkJICBwcHNfZm5hbWUsIHBwcyk7CisJfQorfQorCisKK2ludCBjbWRfcHJvdihzdHJ1Y3QgaHMyMF9vc3VfY2xpZW50ICpjdHgsIGNvbnN0IGNoYXIgKnVybCkKK3sKKwl1bmxpbmsoIkNlcnQvZXN0X2NlcnQuZGVyIik7CisJdW5saW5rKCJDZXJ0L2VzdF9jZXJ0LnBlbSIpOworCisJaWYgKHVybCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbnZhbGlkIHByb3YgY29tbWFuZCAobWlzc2luZyBVUkwpIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ3JlZGVudGlhbCBwcm92aXNpb25pbmcgcmVxdWVzdGVkIik7CisKKwlvc19mcmVlKGN0eC0+c2VydmVyX3VybCk7CisJY3R4LT5zZXJ2ZXJfdXJsID0gb3Nfc3RyZHVwKHVybCk7CisKKwlpZiAoc29hcF9pbml0X2NsaWVudChjdHgtPmh0dHAsIHVybCwgY3R4LT5jYV9mbmFtZSwgTlVMTCwgTlVMTCwgTlVMTCwKKwkJCSAgICAgTlVMTCkgPCAwKQorCQlyZXR1cm4gLTE7CisJc3BwX3Bvc3RfZGV2X2RhdGEoY3R4LCBTUFBfU1VCU0NSSVBUSU9OX1JFR0lTVFJBVElPTiwKKwkJCSAgIlN1YnNjcmlwdGlvbiByZWdpc3RyYXRpb24iLCBOVUxMLCBOVUxMKTsKKworCXJldHVybiBjdHgtPnBwc19jcmVkX3NldCA/IDAgOiAtMTsKK30KKworCitpbnQgY21kX3NpbV9wcm92KHN0cnVjdCBoczIwX29zdV9jbGllbnQgKmN0eCwgY29uc3QgY2hhciAqdXJsKQoreworCWlmICh1cmwgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSW52YWxpZCBwcm92IGNvbW1hbmQgKG1pc3NpbmcgVVJMKSIpOworCQlyZXR1cm4gLTE7CisJfQorCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNJTSBwcm92aXNpb25pbmcgcmVxdWVzdGVkIik7CisKKwlvc19mcmVlKGN0eC0+c2VydmVyX3VybCk7CisJY3R4LT5zZXJ2ZXJfdXJsID0gb3Nfc3RyZHVwKHVybCk7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV2FpdCBmb3IgSVAgYWRkcmVzcyBiZWZvcmUgc3RhcnRpbmcgU0lNIHByb3Zpc2lvbmluZyIpOworCisJaWYgKHdhaXRfaXBfYWRkcihjdHgtPmlmbmFtZSwgMTUpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGdldCBJUCBhZGRyZXNzIGZvciBXTEFOIC0gdHJ5IGNvbm5lY3Rpb24gYW55d2F5Iik7CisJfQorCisJaWYgKHNvYXBfaW5pdF9jbGllbnQoY3R4LT5odHRwLCB1cmwsIGN0eC0+Y2FfZm5hbWUsIE5VTEwsIE5VTEwsIE5VTEwsCisJCQkgICAgIE5VTEwpIDwgMCkKKwkJcmV0dXJuIC0xOworCXNwcF9wb3N0X2Rldl9kYXRhKGN0eCwgU1BQX1NVQlNDUklQVElPTl9SRUdJU1RSQVRJT04sCisJCQkgICJTdWJzY3JpcHRpb24gcHJvdmlzaW9uaW5nIiwgTlVMTCwgTlVMTCk7CisKKwlyZXR1cm4gY3R4LT5wcHNfY3JlZF9zZXQgPyAwIDogLTE7Cit9CmRpZmYgLS1naXQgYS9oczIwL3NlcnZlci9NYWtlZmlsZSBiL2hzMjAvc2VydmVyL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU4NzYzM2IKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9NYWtlZmlsZQpAQCAtMCwwICsxLDQ1IEBACithbGw6IGhzMjBfc3BwX3NlcnZlcgorCitpZm5kZWYgQ0MKK0NDPWdjYworZW5kaWYKKworaWZuZGVmIExETworTERPPSQoQ0MpCitlbmRpZgorCitpZm5kZWYgQ0ZMQUdTCitDRkxBR1MgPSAtTU1EIC1PMiAtV2FsbCAtZworZW5kaWYKKworQ0ZMQUdTICs9IC1JLi4vLi4vc3JjL3V0aWxzCitDRkxBR1MgKz0gLUkuLi8uLi9zcmMvY3J5cHRvCisKK0xJQlMgKz0gLWxzcWxpdGUzCisKKyMgVXNpbmcgZ2xpYmMgPCAyLjE3IHJlcXVpcmVzIC1scnQgZm9yIGNsb2NrX2dldHRpbWUoKQorTElCUyArPSAtbHJ0CisKK09CSlM9c3BwX3NlcnZlci5vCitPQkpTICs9IGhzMjBfc3BwX3NlcnZlci5vCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy94bWwtdXRpbHMubworT0JKUyArPSAuLi8uLi9zcmMvdXRpbHMvYmFzZTY0Lm8KK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL2NvbW1vbi5vCitPQkpTICs9IC4uLy4uL3NyYy91dGlscy9vc191bml4Lm8KK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL3dwYV9kZWJ1Zy5vCitPQkpTICs9IC4uLy4uL3NyYy9jcnlwdG8vbWQ1LWludGVybmFsLm8KK0NGTEFHUyArPSAkKHNoZWxsIHhtbDItY29uZmlnIC0tY2ZsYWdzKQorTElCUyArPSAkKHNoZWxsIHhtbDItY29uZmlnIC0tbGlicykKK09CSlMgKz0gLi4vLi4vc3JjL3V0aWxzL3htbF9saWJ4bWwyLm8KKworaHMyMF9zcHBfc2VydmVyOiAkKE9CSlMpCisJJChMRE8pICQoTERGTEFHUykgLW8gaHMyMF9zcHBfc2VydmVyICQoT0JKUykgJChMSUJTKQorCitjbGVhbjoKKwlybSAtZiBjb3JlICp+ICoubyAqLmQgaHMyMF9zcHBfc2VydmVyCisJcm0gLWYgLi4vLi4vc3JjL3V0aWxzLyoubworCXJtIC1mIC4uLy4uL3NyYy91dGlscy8qLmQKKwlybSAtZiAuLi8uLi9zcmMvY3J5cHRvLyoubworCXJtIC1mIC4uLy4uL3NyYy9jcnlwdG8vKi5kCisKKy1pbmNsdWRlICQoT0JKUzolLm89JS5kKQpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2EvY2xlYW4uc2ggYi9oczIwL3NlcnZlci9jYS9jbGVhbi5zaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jNjlhMWY1Ci0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvY2EvY2xlYW4uc2gKQEAgLTAsMCArMSwxMCBAQAorIyEvYmluL3NoCisKK2ZvciBpIGluIHNlcnZlci1jbGllbnQgc2VydmVyIHNlcnZlci1yZXZva2VkIHVzZXIgb2NzcDsgZG8KKyAgICBybSAtZiAkaS5jc3IgJGkua2V5ICRpLnBlbQorZG9uZQorCitybSAtZiBvcGVuc3NsLmNuZi50bXAKK3JtIC1yIGRlbW9DQQorcm0gLWYgY2EucGVtIGxvZ28uYXNuMSBsb2dvLmRlciBzZXJ2ZXIuZGVyIG9jc3Atc2VydmVyLWNhY2hlLmRlcgorI3JtIC1yIHJvb3RDQQpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2EvZXN0LWNzcmF0dHJzLmNuZiBiL2hzMjAvc2VydmVyL2NhL2VzdC1jc3JhdHRycy5jbmYKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjUwZWEwMAotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL2NhL2VzdC1jc3JhdHRycy5jbmYKQEAgLTAsMCArMSwxNyBAQAorYXNuMSA9IFNFUVVFTkNFOmF0dHJzCisKK1thdHRyc10KKyNvaWQxID0gT0lEOmNoYWxsZW5nZVBhc3N3b3JkCithdHRyMSA9IFNFUVVFTkNFOmV4dHJlcQorb2lkMiA9IE9JRDpzaGEyNTZXaXRoUlNBRW5jcnlwdGlvbgorCitbZXh0cmVxXQorb2lkID0gT0lEOmV4dGVuc2lvblJlcXVlc3QKK3ZhbHMgPSBTRVQ6ZXh0cmVxdmFscworCitbZXh0cmVxdmFsc10KKworb2lkMSA9IE9JRDptYWNBZGRyZXNzCisjb2lkMiA9IE9JRDppbWVpCisjb2lkMyA9IE9JRDptZWlkCisjb2lkNCA9IE9JRDpEZXZJZApkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2EvZXN0LWNzcmF0dHJzLnNoIGIvaHMyMC9zZXJ2ZXIvY2EvZXN0LWNzcmF0dHJzLnNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBiNzNhMDQKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9jYS9lc3QtY3NyYXR0cnMuc2gKQEAgLTAsMCArMSw0IEBACisjIS9iaW4vc2gKKworb3BlbnNzbCBhc24xcGFyc2UgLWdlbmNvbmYgZXN0LWNzcmF0dHJzLmNuZiAtb3V0IGVzdC1jc3JhdHRycy5kZXIgLW9pZCBoczIwLm9pZAorYmFzZTY0IGVzdC1jc3JhdHRycy5kZXIgPiBlc3QtYXR0cnMuYjY0CmRpZmYgLS1naXQgYS9oczIwL3NlcnZlci9jYS9oczIwLm9pZCBiL2hzMjAvc2VydmVyL2NhL2hzMjAub2lkCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE4MjlmZjIKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9jYS9oczIwLm9pZApAQCAtMCwwICsxLDcgQEAKKzEuMy42LjEuMS4xLjEuMjIgbWFjQWRkcmVzcworMS4yLjg0MC4xMTM1NDkuMS45LjE0IGV4dGVuc2lvblJlcXVlc3QKKzEuMy42LjEuNC4xLjQwODA4LjEuMS4xIGlkLXdmYS1ob3RzcG90LWZyaWVuZGx5TmFtZQorMS4zLjYuMS40LjEuNDA4MDguMS4xLjIgaWQta3AtSFMyLjBBdXRoCisxLjMuNi4xLjQuMS40MDgwOC4xLjEuMyBpbWVpCisxLjMuNi4xLjQuMS40MDgwOC4xLjEuNCBtZWlkCisxLjMuNi4xLjQuMS40MDgwOC4xLjEuNSBEZXZJZApkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2Evb2NzcC1yZXEuc2ggYi9oczIwL3NlcnZlci9jYS9vY3NwLXJlcS5zaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45MzFhMjA2Ci0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvY2Evb2NzcC1yZXEuc2gKQEAgLTAsMCArMSwxMSBAQAorIyEvYmluL3NoCisKK2ZvciBpIGluICoucGVtOyBkbworICAgIGVjaG8gIj09PVsgJGkgXT09PT09PT09PT09PT09PT09PT0iCisgICAgb3BlbnNzbCBvY3NwIC10ZXh0IC1DQWZpbGUgY2EucGVtIC12ZXJpZnlfb3RoZXIgZGVtb0NBL2NhY2VydC5wZW0gLXRydXN0X290aGVyIC1pc3N1ZXIgZGVtb0NBL2NhY2VydC5wZW0gLWNlcnQgJGkgLXVybCBodHRwOi8vbG9jYWxob3N0Ojg4ODgvCisKKyMgICAgb3BlbnNzbCBvY3NwIC10ZXh0IC1DQWZpbGUgcm9vdENBL2NhY2VydC5wZW0gLWlzc3VlciBkZW1vQ0EvY2FjZXJ0LnBlbSAtY2VydCAkaSAtdXJsIGh0dHA6Ly9sb2NhbGhvc3Q6ODg4OC8KKworIyAgICBvcGVuc3NsIG9jc3AgLXRleHQgLUNBZmlsZSByb290Q0EvY2FjZXJ0LnBlbSAtdmVyaWZ5X290aGVyIGRlbW9DQS9jYWNlcnQucGVtIC10cnVzdF9vdGhlciAtaXNzdWVyIGRlbW9DQS9jYWNlcnQucGVtIC1jZXJ0ICRpIC11cmwgaHR0cDovL2xvY2FsaG9zdDo4ODg4LworIyAgICBvcGVuc3NsIG9jc3AgLXRleHQgLUNBZmlsZSByb290Q0EvY2FjZXJ0LnBlbSAtVkFmaWxlIGNhLnBlbSAtdHJ1c3Rfb3RoZXIgLWlzc3VlciBkZW1vQ0EvY2FjZXJ0LnBlbSAtY2VydCAkaSAtdXJsIGh0dHA6Ly9sb2NhbGhvc3Q6ODg4OC8KK2RvbmUKZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL2NhL29jc3AtcmVzcG9uZGVyLWljYS5zaCBiL2hzMjAvc2VydmVyL2NhL29jc3AtcmVzcG9uZGVyLWljYS5zaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMTZjNmUxCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvY2Evb2NzcC1yZXNwb25kZXItaWNhLnNoCkBAIC0wLDAgKzEsMyBAQAorIyEvYmluL3NoCisKK29wZW5zc2wgb2NzcCAtaW5kZXggZGVtb0NBL2luZGV4LnR4dCAtcG9ydCA4ODg4IC1ubWluIDUgLXJzaWduZXIgZGVtb0NBL2NhY2VydC5wZW0gLXJrZXkgZGVtb0NBL3ByaXZhdGUvY2FrZXktcGxhaW4ucGVtIC1DQSBkZW1vQ0EvY2FjZXJ0LnBlbSAtcmVzcF9ub19jZXJ0cyAtdGV4dApkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2Evb2NzcC1yZXNwb25kZXIuc2ggYi9oczIwL3NlcnZlci9jYS9vY3NwLXJlc3BvbmRlci5zaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44Y2ViZDc0Ci0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvY2Evb2NzcC1yZXNwb25kZXIuc2gKQEAgLTAsMCArMSwzIEBACisjIS9iaW4vc2gKKworb3BlbnNzbCBvY3NwIC1pbmRleCBkZW1vQ0EvaW5kZXgudHh0IC1wb3J0IDg4ODggLW5taW4gNSAtcnNpZ25lciBvY3NwLnBlbSAtcmtleSBvY3NwLmtleSAtQ0EgZGVtb0NBL2NhY2VydC5wZW0gLXRleHQKZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL2NhL29jc3AtdXBkYXRlLWNhY2hlLnNoIGIvaHMyMC9zZXJ2ZXIvY2Evb2NzcC11cGRhdGUtY2FjaGUuc2gKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGRkZWY5YgotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL2NhL29jc3AtdXBkYXRlLWNhY2hlLnNoCkBAIC0wLDAgKzEsMTAgQEAKKyMhL2Jpbi9zaAorCitvcGVuc3NsIG9jc3AgXAorCS1ub19ub25jZSBcCisJLUNBZmlsZSBjYS5wZW0gXAorCS12ZXJpZnlfb3RoZXIgZGVtb0NBL2NhY2VydC5wZW0gXAorCS1pc3N1ZXIgZGVtb0NBL2NhY2VydC5wZW0gXAorCS1jZXJ0IHNlcnZlci5wZW0gXAorCS11cmwgaHR0cDovL2xvY2FsaG9zdDo4ODg4LyBcCisJLXJlc3BvdXQgb2NzcC1zZXJ2ZXItY2FjaGUuZGVyCmRpZmYgLS1naXQgYS9oczIwL3NlcnZlci9jYS9vcGVuc3NsLXJvb3QuY25mIGIvaHMyMC9zZXJ2ZXIvY2Evb3BlbnNzbC1yb290LmNuZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41YjIyMGZlCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvY2Evb3BlbnNzbC1yb290LmNuZgpAQCAtMCwwICsxLDEyNSBAQAorIyBPcGVuU1NMIGNvbmZpZ3VyYXRpb24gZmlsZSBmb3IgSG90c3BvdCAyLjAgUEtJIChSb290IENBKQorCitIT01FCQkJPSAuCitSQU5ERklMRQkJPSAkRU5WOjpIT01FLy5ybmQKK29pZF9zZWN0aW9uCQk9IG5ld19vaWRzCisKK1sgbmV3X29pZHMgXQorCisjbG9nb3R5cGVvaWQ9MS4zLjYuMS41LjUuNy4xLjEyCisKKyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCitbIGNhIF0KK2RlZmF1bHRfY2EJPSBDQV9kZWZhdWx0CQkjIFRoZSBkZWZhdWx0IGNhIHNlY3Rpb24KKworIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKK1sgQ0FfZGVmYXVsdCBdCisKK2RpcgkJPSAuL3Jvb3RDQQkJIyBXaGVyZSBldmVyeXRoaW5nIGlzIGtlcHQKK2NlcnRzCQk9ICRkaXIvY2VydHMJCSMgV2hlcmUgdGhlIGlzc3VlZCBjZXJ0cyBhcmUga2VwdAorY3JsX2RpcgkJPSAkZGlyL2NybAkJIyBXaGVyZSB0aGUgaXNzdWVkIGNybCBhcmUga2VwdAorZGF0YWJhc2UJPSAkZGlyL2luZGV4LnR4dAkjIGRhdGFiYXNlIGluZGV4IGZpbGUuCisjdW5pcXVlX3N1YmplY3QJPSBubwkJCSMgU2V0IHRvICdubycgdG8gYWxsb3cgY3JlYXRpb24gb2YKKwkJCQkJIyBzZXZlcmFsIGNlcnRpZmljYXRlcyB3aXRoIHNhbWUgc3ViamVjdAorbmV3X2NlcnRzX2Rpcgk9ICRkaXIvbmV3Y2VydHMJCSMgZGVmYXVsdCBwbGFjZSBmb3IgbmV3IGNlcnRzLgorCitjZXJ0aWZpY2F0ZQk9ICRkaXIvY2FjZXJ0LnBlbSAJIyBUaGUgQ0EgY2VydGlmaWNhdGUKK3NlcmlhbAkJPSAkZGlyL3NlcmlhbCAJCSMgVGhlIGN1cnJlbnQgc2VyaWFsIG51bWJlcgorY3JsbnVtYmVyCT0gJGRpci9jcmxudW1iZXIJIyB0aGUgY3VycmVudCBjcmwgbnVtYmVyCisJCQkJCSMgbXVzdCBiZSBjb21tZW50ZWQgb3V0IHRvIGxlYXZlIGEgVjEgQ1JMCitjcmwJCT0gJGRpci9jcmwucGVtIAkJIyBUaGUgY3VycmVudCBDUkwKK3ByaXZhdGVfa2V5CT0gJGRpci9wcml2YXRlL2Nha2V5LnBlbSMgVGhlIHByaXZhdGUga2V5CitSQU5ERklMRQk9ICRkaXIvcHJpdmF0ZS8ucmFuZAkjIHByaXZhdGUgcmFuZG9tIG51bWJlciBmaWxlCisKK3g1MDlfZXh0ZW5zaW9ucwk9IHVzcl9jZXJ0CQkjIFRoZSBleHRlbnRpb25zIHRvIGFkZCB0byB0aGUgY2VydAorCituYW1lX29wdCAJPSBjYV9kZWZhdWx0CQkjIFN1YmplY3QgTmFtZSBvcHRpb25zCitjZXJ0X29wdCAJPSBjYV9kZWZhdWx0CQkjIENlcnRpZmljYXRlIGZpZWxkIG9wdGlvbnMKKworZGVmYXVsdF9kYXlzCT0gMzY1CQkJIyBob3cgbG9uZyB0byBjZXJ0aWZ5IGZvcgorZGVmYXVsdF9jcmxfZGF5cz0gMzAJCQkjIGhvdyBsb25nIGJlZm9yZSBuZXh0IENSTAorZGVmYXVsdF9tZAk9IGRlZmF1bHQJCSMgdXNlIHB1YmxpYyBrZXkgZGVmYXVsdCBNRAorcHJlc2VydmUJPSBubwkJCSMga2VlcCBwYXNzZWQgRE4gb3JkZXJpbmcKKworcG9saWN5CQk9IHBvbGljeV9tYXRjaAorCisjIEZvciB0aGUgQ0EgcG9saWN5CitbIHBvbGljeV9tYXRjaCBdCitjb3VudHJ5TmFtZQkJPSBtYXRjaAorc3RhdGVPclByb3ZpbmNlTmFtZQk9IG9wdGlvbmFsCitvcmdhbml6YXRpb25OYW1lCT0gbWF0Y2gKK29yZ2FuaXphdGlvbmFsVW5pdE5hbWUJPSBvcHRpb25hbAorY29tbW9uTmFtZQkJPSBzdXBwbGllZAorZW1haWxBZGRyZXNzCQk9IG9wdGlvbmFsCisKK1sgcG9saWN5X2FueXRoaW5nIF0KK2NvdW50cnlOYW1lCQk9IG9wdGlvbmFsCitzdGF0ZU9yUHJvdmluY2VOYW1lCT0gb3B0aW9uYWwKK2xvY2FsaXR5TmFtZQkJPSBvcHRpb25hbAorb3JnYW5pemF0aW9uTmFtZQk9IG9wdGlvbmFsCitvcmdhbml6YXRpb25hbFVuaXROYW1lCT0gb3B0aW9uYWwKK2NvbW1vbk5hbWUJCT0gc3VwcGxpZWQKK2VtYWlsQWRkcmVzcwkJPSBvcHRpb25hbAorCisjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworWyByZXEgXQorZGVmYXVsdF9iaXRzCQk9IDIwNDgKK2RlZmF1bHRfa2V5ZmlsZSAJPSBwcml2a2V5LnBlbQorZGlzdGluZ3Vpc2hlZF9uYW1lCT0gcmVxX2Rpc3Rpbmd1aXNoZWRfbmFtZQorYXR0cmlidXRlcwkJPSByZXFfYXR0cmlidXRlcworeDUwOV9leHRlbnNpb25zCT0gdjNfY2EJIyBUaGUgZXh0ZW50aW9ucyB0byBhZGQgdG8gdGhlIHNlbGYgc2lnbmVkIGNlcnQKKworaW5wdXRfcGFzc3dvcmQgPSB3aGF0ZXZlcgorb3V0cHV0X3Bhc3N3b3JkID0gd2hhdGV2ZXIKKworc3RyaW5nX21hc2sgPSB1dGY4b25seQorCitbIHJlcV9kaXN0aW5ndWlzaGVkX25hbWUgXQorY291bnRyeU5hbWUJCQk9IENvdW50cnkgTmFtZSAoMiBsZXR0ZXIgY29kZSkKK2NvdW50cnlOYW1lX2RlZmF1bHQJCT0gVVMKK2NvdW50cnlOYW1lX21pbgkJCT0gMgorY291bnRyeU5hbWVfbWF4CQkJPSAyCisKK2xvY2FsaXR5TmFtZQkJCT0gTG9jYWxpdHkgTmFtZSAoZWcsIGNpdHkpCitsb2NhbGl0eU5hbWVfZGVmYXVsdAkJPSBUdXVzdWxhCisKKzAub3JnYW5pemF0aW9uTmFtZQkJPSBPcmdhbml6YXRpb24gTmFtZSAoZWcsIGNvbXBhbnkpCiswLm9yZ2FuaXphdGlvbk5hbWVfZGVmYXVsdAk9IFdGQSBIb3RzcG90IDIuMAorCisjI29yZ2FuaXphdGlvbmFsVW5pdE5hbWUJCT0gT3JnYW5pemF0aW9uYWwgVW5pdCBOYW1lIChlZywgc2VjdGlvbikKKyNvcmdhbml6YXRpb25hbFVuaXROYW1lX2RlZmF1bHQJPQorI0BPVUAKKworY29tbW9uTmFtZQkJCT0gQ29tbW9uIE5hbWUgKGUuZy4gc2VydmVyIEZRRE4gb3IgWU9VUiBuYW1lKQorI0BDTkAKK2NvbW1vbk5hbWVfbWF4CQkJPSA2NAorCitlbWFpbEFkZHJlc3MJCQk9IEVtYWlsIEFkZHJlc3MKK2VtYWlsQWRkcmVzc19tYXgJCT0gNjQKKworWyByZXFfYXR0cmlidXRlcyBdCisKK1sgdjNfcmVxIF0KKworIyBFeHRlbnNpb25zIHRvIGFkZCB0byBhIGNlcnRpZmljYXRlIHJlcXVlc3QKK2Jhc2ljQ29uc3RyYWludHMgPSBDQTpGQUxTRQora2V5VXNhZ2UgPSBub25SZXB1ZGlhdGlvbiwgZGlnaXRhbFNpZ25hdHVyZSwga2V5RW5jaXBoZXJtZW50CitzdWJqZWN0QWx0TmFtZT1ETlM6ZXhhbXBsZS5jb20sRE5TOmFub3RoZXIuZXhhbXBsZS5jb20KKworWyB2M19jYSBdCisKKyMgSG90c3BvdCAyLjAgUEtJIHJlcXVpcmVtZW50cworc3ViamVjdEtleUlkZW50aWZpZXI9aGFzaAorYmFzaWNDb25zdHJhaW50cyA9IGNyaXRpY2FsLENBOnRydWUKK2tleVVzYWdlID0gY3JpdGljYWwsIGNSTFNpZ24sIGtleUNlcnRTaWduCisKK1sgY3JsX2V4dCBdCisKKyMgaXNzdWVyQWx0TmFtZT1pc3N1ZXI6Y29weQorYXV0aG9yaXR5S2V5SWRlbnRpZmllcj1rZXlpZDphbHdheXMKKworWyB2M19PQ1NQIF0KKworYmFzaWNDb25zdHJhaW50cyA9IENBOkZBTFNFCitrZXlVc2FnZSA9IG5vblJlcHVkaWF0aW9uLCBkaWdpdGFsU2lnbmF0dXJlLCBrZXlFbmNpcGhlcm1lbnQKK2V4dGVuZGVkS2V5VXNhZ2UgPSBPQ1NQU2lnbmluZwpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2Evb3BlbnNzbC5jbmYgYi9oczIwL3NlcnZlci9jYS9vcGVuc3NsLmNuZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hOTM5ZjA4Ci0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvY2Evb3BlbnNzbC5jbmYKQEAgLTAsMCArMSwyMDAgQEAKKyMgT3BlblNTTCBjb25maWd1cmF0aW9uIGZpbGUgZm9yIEhvdHNwb3QgMi4wIFBLSSAoSW50ZXJtZWRpYXRlIENBKQorCitIT01FCQkJPSAuCitSQU5ERklMRQkJPSAkRU5WOjpIT01FLy5ybmQKK29pZF9zZWN0aW9uCQk9IG5ld19vaWRzCisKK1sgbmV3X29pZHMgXQorCisjbG9nb3R5cGVvaWQ9MS4zLjYuMS41LjUuNy4xLjEyCisKKyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCitbIGNhIF0KK2RlZmF1bHRfY2EJPSBDQV9kZWZhdWx0CQkjIFRoZSBkZWZhdWx0IGNhIHNlY3Rpb24KKworIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKK1sgQ0FfZGVmYXVsdCBdCisKK2RpcgkJPSAuL2RlbW9DQQkJIyBXaGVyZSBldmVyeXRoaW5nIGlzIGtlcHQKK2NlcnRzCQk9ICRkaXIvY2VydHMJCSMgV2hlcmUgdGhlIGlzc3VlZCBjZXJ0cyBhcmUga2VwdAorY3JsX2RpcgkJPSAkZGlyL2NybAkJIyBXaGVyZSB0aGUgaXNzdWVkIGNybCBhcmUga2VwdAorZGF0YWJhc2UJPSAkZGlyL2luZGV4LnR4dAkjIGRhdGFiYXNlIGluZGV4IGZpbGUuCisjdW5pcXVlX3N1YmplY3QJPSBubwkJCSMgU2V0IHRvICdubycgdG8gYWxsb3cgY3JlYXRpb24gb2YKKwkJCQkJIyBzZXZlcmFsIGNlcnRpZmljYXRlcyB3aXRoIHNhbWUgc3ViamVjdAorbmV3X2NlcnRzX2Rpcgk9ICRkaXIvbmV3Y2VydHMJCSMgZGVmYXVsdCBwbGFjZSBmb3IgbmV3IGNlcnRzLgorCitjZXJ0aWZpY2F0ZQk9ICRkaXIvY2FjZXJ0LnBlbSAJIyBUaGUgQ0EgY2VydGlmaWNhdGUKK3NlcmlhbAkJPSAkZGlyL3NlcmlhbCAJCSMgVGhlIGN1cnJlbnQgc2VyaWFsIG51bWJlcgorY3JsbnVtYmVyCT0gJGRpci9jcmxudW1iZXIJIyB0aGUgY3VycmVudCBjcmwgbnVtYmVyCisJCQkJCSMgbXVzdCBiZSBjb21tZW50ZWQgb3V0IHRvIGxlYXZlIGEgVjEgQ1JMCitjcmwJCT0gJGRpci9jcmwucGVtIAkJIyBUaGUgY3VycmVudCBDUkwKK3ByaXZhdGVfa2V5CT0gJGRpci9wcml2YXRlL2Nha2V5LnBlbSMgVGhlIHByaXZhdGUga2V5CitSQU5ERklMRQk9ICRkaXIvcHJpdmF0ZS8ucmFuZAkjIHByaXZhdGUgcmFuZG9tIG51bWJlciBmaWxlCisKK3g1MDlfZXh0ZW5zaW9ucwk9IGV4dF9jbGllbnQJCSMgVGhlIGV4dGVudGlvbnMgdG8gYWRkIHRvIHRoZSBjZXJ0CisKK25hbWVfb3B0IAk9IGNhX2RlZmF1bHQJCSMgU3ViamVjdCBOYW1lIG9wdGlvbnMKK2NlcnRfb3B0IAk9IGNhX2RlZmF1bHQJCSMgQ2VydGlmaWNhdGUgZmllbGQgb3B0aW9ucworCisjIEV4dGVuc2lvbiBjb3B5aW5nIG9wdGlvbjogdXNlIHdpdGggY2F1dGlvbi4KK2NvcHlfZXh0ZW5zaW9ucyA9IGNvcHkKKworZGVmYXVsdF9kYXlzCT0gMzY1CQkJIyBob3cgbG9uZyB0byBjZXJ0aWZ5IGZvcgorZGVmYXVsdF9jcmxfZGF5cz0gMzAJCQkjIGhvdyBsb25nIGJlZm9yZSBuZXh0IENSTAorZGVmYXVsdF9tZAk9IGRlZmF1bHQJCSMgdXNlIHB1YmxpYyBrZXkgZGVmYXVsdCBNRAorcHJlc2VydmUJPSBubwkJCSMga2VlcCBwYXNzZWQgRE4gb3JkZXJpbmcKKworcG9saWN5CQk9IHBvbGljeV9tYXRjaAorCisjIEZvciB0aGUgQ0EgcG9saWN5CitbIHBvbGljeV9tYXRjaCBdCitjb3VudHJ5TmFtZQkJPSBzdXBwbGllZAorc3RhdGVPclByb3ZpbmNlTmFtZQk9IG9wdGlvbmFsCitvcmdhbml6YXRpb25OYW1lCT0gc3VwcGxpZWQKK29yZ2FuaXphdGlvbmFsVW5pdE5hbWUJPSBvcHRpb25hbAorY29tbW9uTmFtZQkJPSBzdXBwbGllZAorZW1haWxBZGRyZXNzCQk9IG9wdGlvbmFsCisKK1sgcG9saWN5X29zdV9zZXJ2ZXIgXQorY291bnRyeU5hbWUJCT0gbWF0Y2gKK3N0YXRlT3JQcm92aW5jZU5hbWUJPSBvcHRpb25hbAorb3JnYW5pemF0aW9uTmFtZQk9IG1hdGNoCitvcmdhbml6YXRpb25hbFVuaXROYW1lCT0gc3VwcGxpZWQKK2NvbW1vbk5hbWUJCT0gc3VwcGxpZWQKK2VtYWlsQWRkcmVzcwkJPSBvcHRpb25hbAorCitbIHBvbGljeV9hbnl0aGluZyBdCitjb3VudHJ5TmFtZQkJPSBvcHRpb25hbAorc3RhdGVPclByb3ZpbmNlTmFtZQk9IG9wdGlvbmFsCitsb2NhbGl0eU5hbWUJCT0gb3B0aW9uYWwKK29yZ2FuaXphdGlvbk5hbWUJPSBvcHRpb25hbAorb3JnYW5pemF0aW9uYWxVbml0TmFtZQk9IG9wdGlvbmFsCitjb21tb25OYW1lCQk9IHN1cHBsaWVkCitlbWFpbEFkZHJlc3MJCT0gb3B0aW9uYWwKKworIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKK1sgcmVxIF0KK2RlZmF1bHRfYml0cwkJPSAyMDQ4CitkZWZhdWx0X2tleWZpbGUgCT0gcHJpdmtleS5wZW0KK2Rpc3Rpbmd1aXNoZWRfbmFtZQk9IHJlcV9kaXN0aW5ndWlzaGVkX25hbWUKK2F0dHJpYnV0ZXMJCT0gcmVxX2F0dHJpYnV0ZXMKK3g1MDlfZXh0ZW5zaW9ucwk9IHYzX2NhCSMgVGhlIGV4dGVudGlvbnMgdG8gYWRkIHRvIHRoZSBzZWxmIHNpZ25lZCBjZXJ0CisKK2lucHV0X3Bhc3N3b3JkID0gd2hhdGV2ZXIKK291dHB1dF9wYXNzd29yZCA9IHdoYXRldmVyCisKK3N0cmluZ19tYXNrID0gdXRmOG9ubHkKKworWyByZXFfZGlzdGluZ3Vpc2hlZF9uYW1lIF0KK2NvdW50cnlOYW1lCQkJPSBDb3VudHJ5IE5hbWUgKDIgbGV0dGVyIGNvZGUpCitjb3VudHJ5TmFtZV9kZWZhdWx0CQk9IEZJCitjb3VudHJ5TmFtZV9taW4JCQk9IDIKK2NvdW50cnlOYW1lX21heAkJCT0gMgorCitsb2NhbGl0eU5hbWUJCQk9IExvY2FsaXR5IE5hbWUgKGVnLCBjaXR5KQorbG9jYWxpdHlOYW1lX2RlZmF1bHQJCT0gVHV1c3VsYQorCiswLm9yZ2FuaXphdGlvbk5hbWUJCT0gT3JnYW5pemF0aW9uIE5hbWUgKGVnLCBjb21wYW55KQorMC5vcmdhbml6YXRpb25OYW1lX2RlZmF1bHQJPSB3MS5maQorCisjI29yZ2FuaXphdGlvbmFsVW5pdE5hbWUJCT0gT3JnYW5pemF0aW9uYWwgVW5pdCBOYW1lIChlZywgc2VjdGlvbikKKyNvcmdhbml6YXRpb25hbFVuaXROYW1lX2RlZmF1bHQJPQorI0BPVUAKKworY29tbW9uTmFtZQkJCT0gQ29tbW9uIE5hbWUgKGUuZy4gc2VydmVyIEZRRE4gb3IgWU9VUiBuYW1lKQorI0BDTkAKK2NvbW1vbk5hbWVfbWF4CQkJPSA2NAorCitlbWFpbEFkZHJlc3MJCQk9IEVtYWlsIEFkZHJlc3MKK2VtYWlsQWRkcmVzc19tYXgJCT0gNjQKKworWyByZXFfYXR0cmlidXRlcyBdCisKK1sgdjNfY2EgXQorCisjIEhvdHNwb3QgMi4wIFBLSSByZXF1aXJlbWVudHMKK3N1YmplY3RLZXlJZGVudGlmaWVyPWhhc2gKK2F1dGhvcml0eUtleUlkZW50aWZpZXI9a2V5aWQ6YWx3YXlzLGlzc3VlcgorYmFzaWNDb25zdHJhaW50cyA9IGNyaXRpY2FsLCBDQTp0cnVlLCBwYXRobGVuOjAKK2tleVVzYWdlID0gY3JpdGljYWwsIGNSTFNpZ24sIGtleUNlcnRTaWduCithdXRob3JpdHlJbmZvQWNjZXNzID0gT0NTUDtVUkk6aHR0cDovL29zdS53MS5maTo4ODg4LworIyBGb3IgU1AgaW50ZXJtZWRpYXRlIENBCisjc3ViamVjdEFsdE5hbWU9Y3JpdGljYWwsb3RoZXJOYW1lOjEuMy42LjEuNC4xLjQwODA4LjEuMS4xO1VURjhTdHJpbmc6ZW5nRXhhbXBsZSBPU1UKKyNuYW1lQ29uc3RyYWludHM9cGVybWl0dGVkO0ROUzoudzEuZmkKKyMxLjMuNi4xLjUuNS43LjEuMTI9QVNOMTpTRVFVRU5DRTpMb2dvdHlwZUV4dG4KKworWyB2M19vc3Vfc2VydmVyIF0KKworYmFzaWNDb25zdHJhaW50cyA9IGNyaXRpY2FsLCBDQTp0cnVlLCBwYXRobGVuOjAKK2tleVVzYWdlID0gY3JpdGljYWwsIGtleUVuY2lwaGVybWVudAorI0BBTFROQU1FQAorCisjbG9nb3R5cGVvaWQ9QVNOMTpTRVFVRU5DRTpMb2dvdHlwZUV4dG4KKzEuMy42LjEuNS41LjcuMS4xMj1BU04xOlNFUVVFTkNFOkxvZ290eXBlRXh0bgorW0xvZ290eXBlRXh0bl0KK2NvbW11bml0eUxvZ29zPUVYUDowLFNFUVVFTkNFOkxvZ290eXBlSW5mbworW0xvZ290eXBlSW5mb10KKyMgbm90ZTogaW1wbGljaXQgdGFnIGNvbnZlcnRlZCB0byBleHBsaWNpdCBmb3IgQ0hPSUNFCitkaXJlY3Q9RVhQOjAsU0VRVUVOQ0U6TG9nb3R5cGVEYXRhCitbTG9nb3R5cGVEYXRhXQoraW1hZ2U9U0VRVUVOQ0U6TG9nb3R5cGVJbWFnZQorW0xvZ290eXBlSW1hZ2VdCitpbWFnZURldGFpbHM9U0VRVUVOQ0U6TG9nb3R5cGVEZXRhaWxzCitpbWFnZUluZm89U0VRVUVOQ0U6TG9nb3R5cGVJbWFnZUluZm8KK1tMb2dvdHlwZURldGFpbHNdCittZWRpYVR5cGU9SUE1U1RSSU5HOmltYWdlL3BuZworbG9nb3R5cGVIYXNoPVNFUVVFTkNFOkhhc2hBbGdBbmRWYWx1ZXMKK2xvZ290eXBlVVJJPVNFUVVFTkNFOlVSSQorW0hhc2hBbGdBbmRWYWx1ZXNdCit2YWx1ZTE9U0VRVUVOQ0U6SGFzaEFsZ0FuZFZhbHVlU0hBMjU2CisjdmFsdWUyPVNFUVVFTkNFOkhhc2hBbGdBbmRWYWx1ZVNIQTEKK1tIYXNoQWxnQW5kVmFsdWVTSEEyNTZdCitoYXNoQWxnPVNFUVVFTkNFOnNoYTI1Nl9hbGcKK2hhc2hWYWx1ZT1GT1JNQVQ6SEVYLE9DVEVUU1RSSU5HOjQ1MzJmN2VjMzY0MjQzODE2MTdjMDNjNmNlODdiNTVhNTFkNmU3MTc3ZmZhZmRhMjQzY2ViZjI4MGE2ODk1NGQKK1tIYXNoQWxnQW5kVmFsdWVTSEExXQoraGFzaEFsZz1TRVFVRU5DRTpzaGExX2FsZworaGFzaFZhbHVlPUZPUk1BVDpIRVgsT0NURVRTVFJJTkc6NWUxZDUwODU2NzZlZWRlNmIwMmRhMTRkMzFjNTIzZWMyMGZmYmEwYgorW3NoYTI1Nl9hbGddCithbGdvcml0aG09T0lEOnNoYTI1NgorW3NoYTFfYWxnXQorYWxnb3JpdGhtPU9JRDpzaGExCitbVVJJXQordXJpPUlBNVNUUklORzpodHRwOi8vb3N1LncxLmZpL3cxZmlfbG9nby5wbmcKK1tMb2dvdHlwZUltYWdlSW5mb10KKyMgZGVmYXVsdCB2YWx1ZSBjb2xvcigxKSwgY29tcG9uZW50IG9wdGlvbmFsCisjdHlwZT1JTVA6MCxJTlRFR0VSOjEKK2ZpbGVTaXplPUlOVEVHRVI6NzU0OQoreFNpemU9SU5URUdFUjoxMjgKK3lTaXplPUlOVEVHRVI6ODAKK2xhbmd1YWdlPUlNUDo0LElBNVNUUklORzp6eHgKKworWyBjcmxfZXh0IF0KKworIyBpc3N1ZXJBbHROYW1lPWlzc3Vlcjpjb3B5CithdXRob3JpdHlLZXlJZGVudGlmaWVyPWtleWlkOmFsd2F5cworCitbIHYzX09DU1AgXQorCitiYXNpY0NvbnN0cmFpbnRzID0gQ0E6RkFMU0UKK2tleVVzYWdlID0gbm9uUmVwdWRpYXRpb24sIGRpZ2l0YWxTaWduYXR1cmUsIGtleUVuY2lwaGVybWVudAorZXh0ZW5kZWRLZXlVc2FnZSA9IE9DU1BTaWduaW5nCisKK1sgZXh0X2NsaWVudCBdCisKK2Jhc2ljQ29uc3RyYWludHM9Q0E6RkFMU0UKK3N1YmplY3RLZXlJZGVudGlmaWVyPWhhc2gKK2F1dGhvcml0eUtleUlkZW50aWZpZXI9a2V5aWQsaXNzdWVyCithdXRob3JpdHlJbmZvQWNjZXNzID0gT0NTUDtVUkk6aHR0cDovL29zdS53MS5maTo4ODg4LworI0BBTFROQU1FQAorZXh0ZW5kZWRLZXlVc2FnZSA9IGNsaWVudEF1dGgKKworWyBleHRfc2VydmVyIF0KKworIyBIb3RzcG90IDIuMCBQS0kgcmVxdWlyZW1lbnRzCitiYXNpY0NvbnN0cmFpbnRzPWNyaXRpY2FsLCBDQTpGQUxTRQorc3ViamVjdEtleUlkZW50aWZpZXI9aGFzaAorYXV0aG9yaXR5S2V5SWRlbnRpZmllcj1rZXlpZCxpc3N1ZXIKK2F1dGhvcml0eUluZm9BY2Nlc3MgPSBPQ1NQO1VSSTpodHRwOi8vb3N1LncxLmZpOjg4ODgvCisjQEFMVE5BTUVACitleHRlbmRlZEtleVVzYWdlID0gY3JpdGljYWwsIHNlcnZlckF1dGgKK2tleVVzYWdlID0gY3JpdGljYWwsIGtleUVuY2lwaGVybWVudApkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2Evc2V0dXAuc2ggYi9oczIwL3NlcnZlci9jYS9zZXR1cC5zaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mNjFiZjczCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvY2Evc2V0dXAuc2gKQEAgLTAsMCArMSwxMjUgQEAKKyMhL2Jpbi9zaAorCitpZiBbIC16ICIkT1BFTlNTTCIgXTsgdGhlbgorICAgIE9QRU5TU0w9b3BlbnNzbAorZmkKK2V4cG9ydCBPUEVOU1NMX0NPTkY9JFBXRC9vcGVuc3NsLmNuZgorUEFTUz13aGF0ZXZlcgorCitmYWlsKCkKK3sKKyAgICBlY2hvICIkKiIKKyAgICBleGl0IDEKK30KKworZWNobworZWNobyAiLS0tWyBSb290IENBIF0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIgorZWNobworCitjYXQgb3BlbnNzbC1yb290LmNuZiB8IHNlZCAicy8jQENOQC9jb21tb25OYW1lX2RlZmF1bHQgPSBIb3RzcG90IDIuMCBUcnVzdCBSb290IENBIC0gOTkvIiA+IG9wZW5zc2wuY25mLnRtcAorbWtkaXIgLXAgcm9vdENBL2NlcnRzIHJvb3RDQS9jcmwgcm9vdENBL25ld2NlcnRzIHJvb3RDQS9wcml2YXRlCit0b3VjaCByb290Q0EvaW5kZXgudHh0CitpZiBbIC1lIHJvb3RDQS9wcml2YXRlL2Nha2V5LnBlbSBdOyB0aGVuCisgICAgZWNobyAiICogVXNlIGV4aXN0aW5nIFJvb3QgQ0EiCitlbHNlCisgICAgZWNobyAiICogR2VuZXJhdGUgUm9vdCBDQSBwcml2YXRlIGtleSIKKyAgICAkT1BFTlNTTCByZXEgLWNvbmZpZyBvcGVuc3NsLmNuZi50bXAgLWJhdGNoIC1uZXcgLW5ld2tleSByc2E6NDA5NiAta2V5b3V0IHJvb3RDQS9wcml2YXRlL2Nha2V5LnBlbSAtb3V0IHJvb3RDQS9jYXJlcS5wZW0gfHwgZmFpbCAiRmFpbGVkIHRvIGdlbmVyYXRlIFJvb3QgQ0EgcHJpdmF0ZSBrZXkiCisgICAgZWNobyAiICogU2lnbiBSb290IENBIGNlcnRpZmljYXRlIgorICAgICRPUEVOU1NMIGNhIC1jb25maWcgb3BlbnNzbC5jbmYudG1wIC1tZCBzaGEyNTYgLWNyZWF0ZV9zZXJpYWwgLW91dCByb290Q0EvY2FjZXJ0LnBlbSAtZGF5cyAxMDk1NyAtYmF0Y2ggLWtleWZpbGUgcm9vdENBL3ByaXZhdGUvY2FrZXkucGVtIC1wYXNzaW4gcGFzczokUEFTUyAtc2VsZnNpZ24gLWV4dGVuc2lvbnMgdjNfY2EgLW91dGRpciByb290Q0EvbmV3Y2VydHMgLWluZmlsZXMgcm9vdENBL2NhcmVxLnBlbSB8fCBmYWlsICJGYWlsZWQgdG8gc2lnbiBSb290IENBIGNlcnRpZmljYXRlIgorZmkKK2lmIFsgISAtZSByb290Q0EvY3JsbnVtYmVyIF07IHRoZW4KKyAgICBlY2hvIDAwID4gcm9vdENBL2NybG51bWJlcgorZmkKKworZWNobworZWNobyAiLS0tWyBJbnRlcm1lZGlhdGUgQ0EgXS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIgorZWNobworCitjYXQgb3BlbnNzbC5jbmYgfCBzZWQgInMvI0BDTkAvY29tbW9uTmFtZV9kZWZhdWx0ID0gdzEuZmkgSG90c3BvdCAyLjAgSW50ZXJtZWRpYXRlIENBLyIgPiBvcGVuc3NsLmNuZi50bXAKK21rZGlyIC1wIGRlbW9DQS9jZXJ0cyBkZW1vQ0EvY3JsIGRlbW9DQS9uZXdjZXJ0cyBkZW1vQ0EvcHJpdmF0ZQordG91Y2ggZGVtb0NBL2luZGV4LnR4dAoraWYgWyAtZSBkZW1vQ0EvcHJpdmF0ZS9jYWtleS5wZW0gXTsgdGhlbgorICAgIGVjaG8gIiAqIFVzZSBleGlzdGluZyBJbnRlcm1lZGlhdGUgQ0EiCitlbHNlCisgICAgZWNobyAiICogR2VuZXJhdGUgSW50ZXJtZWRpYXRlIENBIHByaXZhdGUga2V5IgorICAgICRPUEVOU1NMIHJlcSAtY29uZmlnIG9wZW5zc2wuY25mLnRtcCAtYmF0Y2ggLW5ldyAtbmV3a2V5IHJzYToyMDQ4IC1rZXlvdXQgZGVtb0NBL3ByaXZhdGUvY2FrZXkucGVtIC1vdXQgZGVtb0NBL2NhcmVxLnBlbSB8fCBmYWlsICJGYWlsZWQgdG8gZ2VuZXJhdGUgSW50ZXJtZWRpYXRlIENBIHByaXZhdGUga2V5IgorICAgIGVjaG8gIiAqIFNpZ24gSW50ZXJtZWRpYXRlIENBIGNlcnRpZmljYXRlIgorICAgICRPUEVOU1NMIGNhIC1jb25maWcgb3BlbnNzbC5jbmYudG1wIC1tZCBzaGEyNTYgLWNyZWF0ZV9zZXJpYWwgLW91dCBkZW1vQ0EvY2FjZXJ0LnBlbSAtZGF5cyAzNjUyIC1iYXRjaCAta2V5ZmlsZSByb290Q0EvcHJpdmF0ZS9jYWtleS5wZW0gLWNlcnQgcm9vdENBL2NhY2VydC5wZW0gLXBhc3NpbiBwYXNzOiRQQVNTIC1leHRlbnNpb25zIHYzX2NhIC1pbmZpbGVzIGRlbW9DQS9jYXJlcS5wZW0gfHwgZmFpbCAiRmFpbGVkIHRvIHNpZ24gSW50ZXJtZWRpYXRlIENBIGNlcnRpZmljYXRlIgorICAgICMgaG9ycmlibGUgZnJvbSBzZWN1cml0eSB2aWV3IHBvaW50LCBidXQgZm9yIHRlc3RpbmcgcHVycG9zZXMgc2luY2UgT0NTUCByZXNwb25kZXIgZG9lcyBub3Qgc2VlbSB0byBzdXBwb3J0IC1wYXNzaW4KKyAgICBvcGVuc3NsIHJzYSAtaW4gZGVtb0NBL3ByaXZhdGUvY2FrZXkucGVtIC1vdXQgZGVtb0NBL3ByaXZhdGUvY2FrZXktcGxhaW4ucGVtIC1wYXNzaW4gcGFzczokUEFTUworZmkKK2lmIFsgISAtZSBkZW1vQ0EvY3JsbnVtYmVyIF07IHRoZW4KKyAgICBlY2hvIDAwID4gZGVtb0NBL2NybG51bWJlcgorZmkKKworZWNobworZWNobyAiT0NTUCByZXNwb25kZXIiCitlY2hvCisKK2NhdCBvcGVuc3NsLmNuZiB8IHNlZCAicy8jQENOQC9jb21tb25OYW1lX2RlZmF1bHQgPSBvY3NwLncxLmZpLyIgPiBvcGVuc3NsLmNuZi50bXAKKyRPUEVOU1NMIHJlcSAtY29uZmlnICRQV0Qvb3BlbnNzbC5jbmYudG1wIC1iYXRjaCAtbmV3IC1uZXdrZXkgcnNhOjIwNDggLW5vZGVzIC1vdXQgb2NzcC5jc3IgLWtleW91dCBvY3NwLmtleSAtZXh0ZW5zaW9ucyB2M19PQ1NQCiskT1BFTlNTTCBjYSAtY29uZmlnICRQV0Qvb3BlbnNzbC5jbmYudG1wIC1iYXRjaCAtbWQgc2hhMjU2IC1rZXlmaWxlIGRlbW9DQS9wcml2YXRlL2Nha2V5LnBlbSAtcGFzc2luIHBhc3M6JFBBU1MgLWluIG9jc3AuY3NyIC1vdXQgb2NzcC5wZW0gLWRheXMgNzMwIC1leHRlbnNpb25zIHYzX09DU1AKKworZWNobworZWNobyAiLS0tWyBTZXJ2ZXIgLSB0byBiZSByZXZva2VkIF0gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIgorZWNobworCitjYXQgb3BlbnNzbC5jbmYgfCBzZWQgInMvI0BDTkAvY29tbW9uTmFtZV9kZWZhdWx0ID0gb3N1LXJldm9rZWQudzEuZmkvIiA+IG9wZW5zc2wuY25mLnRtcAorJE9QRU5TU0wgcmVxIC1jb25maWcgJFBXRC9vcGVuc3NsLmNuZi50bXAgLWJhdGNoIC1uZXcgLW5ld2tleSByc2E6MjA0OCAtbm9kZXMgLW91dCBzZXJ2ZXItcmV2b2tlZC5jc3IgLWtleW91dCBzZXJ2ZXItcmV2b2tlZC5rZXkKKyRPUEVOU1NMIGNhIC1jb25maWcgJFBXRC9vcGVuc3NsLmNuZi50bXAgLWJhdGNoIC1tZCBzaGEyNTYgLWluIHNlcnZlci1yZXZva2VkLmNzciAtb3V0IHNlcnZlci1yZXZva2VkLnBlbSAta2V5ICRQQVNTIC1kYXlzIDczMCAtZXh0ZW5zaW9ucyBleHRfc2VydmVyCiskT1BFTlNTTCBjYSAtcmV2b2tlIHNlcnZlci1yZXZva2VkLnBlbSAta2V5ICRQQVNTCisKK2VjaG8KK2VjaG8gIi0tLVsgU2VydmVyIC0gd2l0aCBjbGllbnQgZXh0IGtleSB1c2UgXSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0iCitlY2hvCisKK2NhdCBvcGVuc3NsLmNuZiB8IHNlZCAicy8jQENOQC9jb21tb25OYW1lX2RlZmF1bHQgPSBvc3UtY2xpZW50LncxLmZpLyIgPiBvcGVuc3NsLmNuZi50bXAKKyRPUEVOU1NMIHJlcSAtY29uZmlnICRQV0Qvb3BlbnNzbC5jbmYudG1wIC1iYXRjaCAtbmV3IC1uZXdrZXkgcnNhOjIwNDggLW5vZGVzIC1vdXQgc2VydmVyLWNsaWVudC5jc3IgLWtleW91dCBzZXJ2ZXItY2xpZW50LmtleQorJE9QRU5TU0wgY2EgLWNvbmZpZyAkUFdEL29wZW5zc2wuY25mLnRtcCAtYmF0Y2ggLW1kIHNoYTI1NiAtaW4gc2VydmVyLWNsaWVudC5jc3IgLW91dCBzZXJ2ZXItY2xpZW50LnBlbSAta2V5ICRQQVNTIC1kYXlzIDczMCAtZXh0ZW5zaW9ucyBleHRfY2xpZW50CisKK2VjaG8KK2VjaG8gIi0tLVsgVXNlciBdLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSIKK2VjaG8KKworY2F0IG9wZW5zc2wuY25mIHwgc2VkICJzLyNAQ05AL2NvbW1vbk5hbWVfZGVmYXVsdCA9IFVzZXIvIiA+IG9wZW5zc2wuY25mLnRtcAorJE9QRU5TU0wgcmVxIC1jb25maWcgJFBXRC9vcGVuc3NsLmNuZi50bXAgLWJhdGNoIC1uZXcgLW5ld2tleSByc2E6MjA0OCAtbm9kZXMgLW91dCB1c2VyLmNzciAta2V5b3V0IHVzZXIua2V5CiskT1BFTlNTTCBjYSAtY29uZmlnICRQV0Qvb3BlbnNzbC5jbmYudG1wIC1iYXRjaCAtbWQgc2hhMjU2IC1pbiB1c2VyLmNzciAtb3V0IHVzZXIucGVtIC1rZXkgJFBBU1MgLWRheXMgNzMwIC1leHRlbnNpb25zIGV4dF9jbGllbnQKKworZWNobworZWNobyAiLS0tWyBTZXJ2ZXIgXS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIgorZWNobworCitBTFQ9IkROUzpvc3UudzEuZmkiCitBTFQ9IiRBTFQsb3RoZXJOYW1lOjEuMy42LjEuNC4xLjQwODA4LjEuMS4xO1VURjhTdHJpbmc6ZW5ndzEuZmkgVEVTVElORyBVU0UiCitBTFQ9IiRBTFQsb3RoZXJOYW1lOjEuMy42LjEuNC4xLjQwODA4LjEuMS4xO1VURjhTdHJpbmc6ZmludzEuZmkgVEVTVElLw4RZVFTDliIKKworY2F0IG9wZW5zc2wuY25mIHwKKwlzZWQgInMvI0BDTkAvY29tbW9uTmFtZV9kZWZhdWx0ID0gb3N1LncxLmZpLyIgfAorCXNlZCAicy9eIyNvcmdhbml6YXRpb25hbFVuaXROYW1lL29yZ2FuaXphdGlvbmFsVW5pdE5hbWUvIiB8CisJc2VkICJzLyNAT1VAL29yZ2FuaXphdGlvbmFsVW5pdE5hbWVfZGVmYXVsdCA9IEhvdHNwb3QgMi4wIE9ubGluZSBTaWduIFVwIFNlcnZlci8iIHwKKwlzZWQgInMvI0BBTFROQU1FQC9zdWJqZWN0QWx0TmFtZT1jcml0aWNhbCwkQUxULyIgXAorCT4gb3BlbnNzbC5jbmYudG1wCitlY2hvICRPUEVOU1NMIHJlcSAtY29uZmlnICRQV0Qvb3BlbnNzbC5jbmYudG1wIC1iYXRjaCAtc2hhMjU2IC1uZXcgLW5ld2tleSByc2E6MjA0OCAtbm9kZXMgLW91dCBzZXJ2ZXIuY3NyIC1rZXlvdXQgc2VydmVyLmtleSAtcmVxZXh0cyB2M19vc3Vfc2VydmVyCiskT1BFTlNTTCByZXEgLWNvbmZpZyAkUFdEL29wZW5zc2wuY25mLnRtcCAtYmF0Y2ggLXNoYTI1NiAtbmV3IC1uZXdrZXkgcnNhOjIwNDggLW5vZGVzIC1vdXQgc2VydmVyLmNzciAta2V5b3V0IHNlcnZlci5rZXkgLXJlcWV4dHMgdjNfb3N1X3NlcnZlciB8fCBmYWlsICJGYWlsZWQgdG8gZ2VuZXJhdGUgc2VydmVyIHJlcXVlc3QiCiskT1BFTlNTTCBjYSAtY29uZmlnICRQV0Qvb3BlbnNzbC5jbmYudG1wIC1iYXRjaCAtbWQgc2hhMjU2IC1pbiBzZXJ2ZXIuY3NyIC1vdXQgc2VydmVyLnBlbSAta2V5ICRQQVNTIC1kYXlzIDczMCAtZXh0ZW5zaW9ucyBleHRfc2VydmVyIC1wb2xpY3kgcG9saWN5X29zdV9zZXJ2ZXIgfHwgZmFpbCAiRmFpbGVkIHRvIHNpZ24gc2VydmVyIGNlcnRpZmljYXRlIgorCisjZHVtcCBsb2dvdHlwZSBkZXRhaWxzIGZvciBkZWJ1Z2dpbmcKKyRPUEVOU1NMIHg1MDkgLWluIHNlcnZlci5wZW0gLW91dCBzZXJ2ZXIuZGVyIC1vdXRmb3JtIERFUgorb3BlbnNzbCBhc24xcGFyc2UgLWluIHNlcnZlci5kZXIgLWluZm9ybSBERVIgfCBncmVwIEhFWCB8IHRhaWwgLTEgfCBzZWQgJ3MvLio6Ly8nIHwgeHhkIC1yIC1wID4gbG9nby5kZXIKK29wZW5zc2wgYXNuMXBhcnNlIC1pbiBsb2dvLmRlciAtaW5mb3JtIERFUiA+IGxvZ28uYXNuMQorCisKK2VjaG8KK2VjaG8gIi0tLVsgQ1JMIF0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0iCitlY2hvCisKKyRPUEVOU1NMIGNhIC1jb25maWcgJFBXRC9vcGVuc3NsLmNuZiAtZ2VuY3JsIC1tZCBzaGEyNTYgLW91dCBkZW1vQ0EvY3JsL2NybC5wZW0gLXBhc3NpbiBwYXNzOiRQQVNTCisKK2VjaG8KK2VjaG8gIi0tLVsgVmVyaWZ5IF0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0iCitlY2hvCisKKyRPUEVOU1NMIHZlcmlmeSAtQ0FmaWxlIHJvb3RDQS9jYWNlcnQucGVtIGRlbW9DQS9jYWNlcnQucGVtCiskT1BFTlNTTCB2ZXJpZnkgLUNBZmlsZSByb290Q0EvY2FjZXJ0LnBlbSAtdW50cnVzdGVkIGRlbW9DQS9jYWNlcnQucGVtICoucGVtCisKK2NhdCByb290Q0EvY2FjZXJ0LnBlbSBkZW1vQ0EvY2FjZXJ0LnBlbSA+IGNhLnBlbQpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvY2EvdzFmaV9sb2dvLnBuZyBiL2hzMjAvc2VydmVyL2NhL3cxZmlfbG9nby5wbmcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWM3YzI1OQotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL2NhL3cxZmlfbG9nby5wbmcKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvaHMyMC1vc3Utc2VydmVyLnR4dCBiL2hzMjAvc2VydmVyL2hzMjAtb3N1LXNlcnZlci50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODA5ODVmNwotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL2hzMjAtb3N1LXNlcnZlci50eHQKQEAgLTAsMCArMSwxOTYgQEAKK0hvdHNwb3QgMi4wIE9TVSBzZXJ2ZXIKKz09PT09PT09PT09PT09PT09PT09PT0KKworVGhlIGluZm9ybWF0aW9uIGluIHRoaXMgZG9jdW1lbnQgaXMgYmFzZWQgb24gdGhlIGFzc3VtcHRpb24gdGhhdCBVYnVudHUKKzEyLjA0IHNlcnZlciAoNjQtYml0KSBkaXN0cmlidXRpb24gaXMgdXNlZCBhbmQgdGhlIHdlYiBzZXJ2ZXIgaXMKK0FwYWNoZTIuIE5laXRoZXIgb2YgdGhlc2UgYXJlIHJlcXVpcmVtZW50cyBmb3IgdGhlIGluc3RhbGxhdGlvbiwgYnV0IGlmCitvdGhlciBjb21iaW5hdGlvbnMgYXJlIHVzZWQsIHRoZSBwYWNrYWdlIG5hbWVzIGFuZCBjb25maWd1cmF0aW9uCitwYXJhbWV0ZXJzIG1heSBuZWVkIHRvIGJlIGFkanVzdGVkLgorCitOT1RFOiBUaGlzIGltcGxlbWVudGF0aW9uIGFuZCB0aGUgZXhhbXBsZSBjb25maWd1cmF0aW9uIGhlcmUgaXMgbWVhbnQKK29ubHkgZm9yIHRlc3RpbmcgcHVycG9zZXMgaW4gYSBsYWIgZW52aXJvbm1lbnQuIFRoaXMgZGVzaWduIGlzIG5vdAorc2VjdXJlIHRvIGJlIGluc3RhbGxlZCBpbiBhIHB1YmxpY2x5IGF2YWlsYWJsZSBJbnRlcm5ldCBzZXJ2ZXIgd2l0aG91dAorY29uc2lkZXJhYmxlIGFtb3VudCBvZiBtb2RpZmljYXRpb24gYW5kIHJldmlldyBmb3Igc2VjdXJpdHkgaXNzdWVzLgorCitOT1RFOiBXaGlsZSB0aGlzIGRlc2NyaWJlcyB1c2Ugb24gVWJ1bnR1IDEyLjA0LCB0aGUgdmVyc2lvbiBvZiBBcGFjaGUyCitpbmNsdWRlZCBpbiB0aGF0IGRpc3RyaWJ1dGlvbiBpcyBub3QgbmV3IGVub3VnaCB0byBzdXBwb3J0IGFsbCBPU1UKK3NlcnZlciB2YWxpZGF0aW9uIHN0ZXBzLiBJbiBvdGhlciB3b3JkcywgaXQgbWF5IGJlIG1vc3QgYWRhcHQgdGhlIHN0ZXBzCitkZXNjcmliZWQgaGVyZSB0byBVYnVudHUgMTMuMTAuCisKKworQnVpbGQgZGVwZW5kZW5jaWVzCistLS0tLS0tLS0tLS0tLS0tLS0KKworVWJ1bnR1IDEyLjA0IHNlcnZlcgorLSBkZWZhdWx0IGluc3RhbGxhdGlvbgorLSB1cGdyYWRlZCB0byBsYXRlc3QgcGFja2FnZSB2ZXJzaW9ucworICBzdWRvIGFwdC1nZXQgdXBkYXRlCisgIHN1ZG8gYXB0LWdldCB1cGdyYWRlCisKK1BhY2thZ2VzIG5lZWRlZCBmb3IgcnVubmluZyB0aGUgc2VydmljZToKKyAgc3VkbyBhcHQtZ2V0IGluc3RhbGwgc3FsaXRlMworICBzdWRvIGFwdC1nZXQgaW5zdGFsbCBhcGFjaGUyCisgIHN1ZG8gYXB0LWdldCBpbnN0YWxsIHBocDUtc3FsaXRlIGxpYmFwYWNoZTItbW9kLXBocDUKKworQWRkaXRpb25hbCBwYWNrYWdlcyBuZWVkZWQgZm9yIGJ1aWxkaW5nIHRoZSBjb21wb25lbnRzOgorICBzdWRvIGFwdC1nZXQgaW5zdGFsbCBidWlsZC1lc3NlbnRpYWwKKyAgc3VkbyBhcHQtZ2V0IGluc3RhbGwgbGlic3FsaXRlMy1kZXYKKyAgc3VkbyBhcHQtZ2V0IGluc3RhbGwgbGlic3NsLWRldgorICBzdWRvIGFwdC1nZXQgaW5zdGFsbCBsaWJ4bWwyLWRldgorCisKK0luc3RhbGxhdGlvbiBsb2NhdGlvbgorLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK1NlbGVjdCBhIGxvY2F0aW9uIGZvciB0aGUgaW5zdGFsbGF0aW9uIHJvb3QgZGlyZWN0b3J5LiBUaGUgZXhhbXBsZSBoZXJlCithc3N1bWVzIC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIgdG8gYmUgdXNlZCwgYnV0IHRoaXMgY2FuIGJlIGNoYW5nZWQgYnkKK2VkaXRpbmcgY291cGxlIG9mIGZpbGVzIGFzIGluZGljYXRlZCBiZWxvdy4KKworc3VkbyBta2RpciAtcCAvaG9tZS91c2VyL2hzMjAtc2VydmVyCitzdWRvIGNob3duICRVU0VSIC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIKK21rZGlyIC1wIC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIvc3BwCitta2RpciAtcCAvaG9tZS91c2VyL2hzMjAtc2VydmVyL0FTCisKKworQnVpbGQKKy0tLS0tCisKKyMgaG9zdGFwZCBhcyBSQURJVVMgc2VydmVyCitjZCBob3N0YXBkCisKKyNleGFtcGxlIGJ1aWxkIGNvbmZpZ3VyYXRpb24KK2NhdCA+IC5jb25maWcgPDxFT0YKK0NPTkZJR19EUklWRVJfTk9ORT15CitDT05GSUdfUEtDUzEyPXkKK0NPTkZJR19SQURJVVNfU0VSVkVSPXkKK0NPTkZJR19FQVA9eQorQ09ORklHX0VBUF9UTFM9eQorQ09ORklHX0VBUF9NU0NIQVBWMj15CitDT05GSUdfRUFQX1BFQVA9eQorQ09ORklHX0VBUF9HVEM9eQorQ09ORklHX0VBUF9UVExTPXkKK0NPTkZJR19FQVBfU0lNPXkKK0NPTkZJR19FQVBfQUtBPXkKK0NPTkZJR19FQVBfQUtBX1BSSU1FPXkKK0NPTkZJR19TUUxJVEU9eQorQ09ORklHX0hTMjA9eQorRU9GCisKK21ha2UgaG9zdGFwZCBobHJfYXVjX2d3CitjcCBob3N0YXBkIGhscl9hdWNfZ3cgL2hvbWUvdXNlci9oczIwLXNlcnZlci9BUworCisjIGJ1aWxkIGhzMjBfc3BwX3NlcnZlcgorY2QgLi4vaHMyMC9zZXJ2ZXIKK21ha2UgY2xlYW4KK21ha2UKK2NwIGhzMjBfc3BwX3NlcnZlciAvaG9tZS91c2VyL2hzMjAtc2VydmVyL3NwcAorIyBwcmVwYXJlIGRhdGFiYXNlICh3ZWIgc2VydmVyIHVzZXIvZ3JvdXAgbmVlZHMgdG8gaGF2ZSB3cml0ZSBhY2Nlc3MpCitta2RpciAtcCAvaG9tZS91c2VyL2hzMjAtc2VydmVyL0FTL0RCCitzdWRvIGNoZ3JwIHd3dy1kYXRhIC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIvQVMvREIKK3N1ZG8gY2htb2QgZyt3IC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIvQVMvREIKK3NxbGl0ZTMgL2hvbWUvdXNlci9oczIwLXNlcnZlci9BUy9EQi9lYXBfdXNlci5kYiA8IHNxbC50eHQKK3N1ZG8gY2hncnAgd3d3LWRhdGEgL2hvbWUvdXNlci9oczIwLXNlcnZlci9BUy9EQi9lYXBfdXNlci5kYgorc3VkbyBjaG1vZCBnK3cgL2hvbWUvdXNlci9oczIwLXNlcnZlci9BUy9EQi9lYXBfdXNlci5kYgorIyBhZGQgZXhhbXBsZSBjb25maWd1cmF0aW9uIChub3RlOiBuZWVkIHRvIHVwZGF0ZSBVUkxzIHRvIG1hdGNoIHRoZSBzeXN0ZW0pCitzcWxpdGUzIC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIvQVMvREIvZWFwX3VzZXIuZGIgPCBzcWwtZXhhbXBsZS50eHQKKworIyBjb3B5IFBIUCBzY3JpcHRzCisjIE1vZGlmeSBjb25maWcucGhwIGlmIGRpZmZlcmVudCBpbnN0YWxsYXRpb24gZGlyZWN0b3J5IGlzIHVzZWQuCisjIE1vZGlmeSBQSFAgc2NyaXB0cyB0byBnZXQgdGhlIGRlc2lyZWQgYmVoYXZpb3IgZm9yIHVzZXIgaW50ZXJhY3Rpb24gKG9yIHVzZQorIyB0aGUgZXhhbXBsZXMgYXMtaXMgZm9yIGluaXRpYWwgdGVzdGluZykuCitjcCAtciB3d3cgL2hvbWUvdXNlci9oczIwLXNlcnZlcgorCisKKyMgQ29uZmlndXJlIHN1YnNjcmlwdGlvbiBwb2xpY2llcworbWtkaXIgLXAgL2hvbWUvdXNlci9oczIwLXNlcnZlci9zcHAvcG9saWN5CitjYXQgPiAvaG9tZS91c2VyL2hzMjAtc2VydmVyL3NwcC9wb2xpY3kvZGVmYXVsdC54bWwgPDxFT0YKKzxQb2xpY3k+CisJPFBvbGljeVVwZGF0ZT4KKwkJPFVwZGF0ZUludGVydmFsPjMwPC9VcGRhdGVJbnRlcnZhbD4KKwkJPFVwZGF0ZU1ldGhvZD5DbGllbnRJbml0aWF0ZWQ8L1VwZGF0ZU1ldGhvZD4KKwkJPFJlc3RyaWN0aW9uPlVucmVzdHJpY3RlZDwvUmVzdHJpY3Rpb24+CisJCTxVUkk+aHR0cHM6Ly9wb2xpY3ktc2VydmVyLm9zdS5leGFtcGxlLmNvbS9oczIwL3NwcC5waHA8L1VSST4KKwk8L1BvbGljeVVwZGF0ZT4KKzwvUG9saWN5PgorRU9GCisKKworIyBJbnN0YWxsIEhvdHNwb3QgMi4wIFNQUCBhbmQgT01BIERNIFhNTCBzY2hlbWEvRFREIGZpbGVzCisKKyMgWE1MIHNjaGVtYSBmb3IgU1BQCisjIENvcHkgdGhlIGxhdGVzdCBYTUwgc2NoZW1hIGludG8gL2hvbWUvdXNlci9oczIwLXNlcnZlci9zcHAvc3BwLnhzZAorCisjIE9NQSBETSBEZXZpY2UgRGVzY3JpcHRpb24gRnJhbWV3b3JrIERURAorIyBDb3B5IGludG8gL2hvbWUvdXNlci9oczIwLXNlcnZlci9zcHAvZG1fZGRmLXYxXzIuZHRkCisjIGh0dHA6Ly93d3cub3Blbm1vYmlsZWFsbGlhbmNlLm9yZy90ZWNoL0RURC9kbV9kZGYtdjFfMi5kdGQKKworCisjIENvbmZpZ3VyZSBSQURJVVMgYXV0aGVudGljYXRpb24gc2VydmljZQorIyBOb3RlOiBDaGFuZ2UgdGhlIFVSTCB0byBtYXRjaCB0aGUgc2V0dXAKKyMgTm90ZTogSW5zdGFsbCBBQUEgc2VydmVyIGtleS9jZXJ0aWZpY2F0ZSBhbmQgcm9vdCBDQSBpbiBLZXkgZGlyZWN0b3J5CisKK2NhdCA+IC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIvQVMvYXMtc3FsLmNvbmYgPDxFT0YKK2RyaXZlcj1ub25lCityYWRpdXNfc2VydmVyX2NsaWVudHM9YXMucmFkaXVzX2NsaWVudHMKK2VhcF9zZXJ2ZXI9MQorZWFwX3VzZXJfZmlsZT1zcWxpdGU6REIvZWFwX3VzZXIuZGIKK2NhX2NlcnQ9S2V5L2NhLnBlbQorc2VydmVyX2NlcnQ9S2V5L3NlcnZlci5wZW0KK3ByaXZhdGVfa2V5PUtleS9zZXJ2ZXIua2V5Citwcml2YXRlX2tleV9wYXNzd2Q9cGFzc3BocmFzZQorZWFwX3NpbV9kYj11bml4Oi90bXAvaGxyX2F1Y19ndy5zb2NrIGRiPWVhcF9zaW0uZGIKK3N1YnNjcl9yZW1lZGlhdGlvbl91cmw9aHR0cHM6Ly9zdWJzY3JpcHRpb24tc2VydmVyLm9zdS5leGFtcGxlLmNvbS9oczIwL3NwcC5waHAKK0VPRgorCisjIFNldCBSQURJVVMgcGFzc3BocmFzZSBmb3IgdGhlIEFQcworIyBOb3RlOiBNb2RpZnkgdG8gbWF0Y2ggdGhlIHNldHVwCitjYXQgPiAvaG9tZS91c2VyL2hzMjAtc2VydmVyL0FTL2FzLnJhZGl1c19jbGllbnRzIDw8RU9GCiswLjAuMC4wLzAJcmFkaXVzCitFT0YKKworCitTdGFydCBSQURJVVMgYXV0aGVudGljYXRpb24gc2VydmVyCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK2NkIC9ob21lL3VzZXIvaHMyMC1zZXJ2ZXIvQVMKKy4vaG9zdGFwZCAtQiBhcy1zcWwuY29uZgorCisKK0NvbmZpZ3VyZSB3ZWIgc2VydmVyCistLS0tLS0tLS0tLS0tLS0tLS0tLQorCitFZGl0IC9ldGMvYXBhY2hlMi9zaXRlcy1hdmFpbGFibGUvZGVmYXVsdC1zc2wKKworQWRkIGZvbGxvd2luZyBibG9jayBqdXN0IGJlZm9yZSAiU1NMIEVuZ2luZSBTd2l0Y2giIGxpbmUiOgorCisgICAgICAgIEFsaWFzIC9oczIwLyAiL2hvbWUvdXNlci9oczIwLXNlcnZlci93d3cvIgorICAgICAgICA8RGlyZWN0b3J5ICIvaG9tZS91c2VyL2hzMjAtc2VydmVyL3d3dy8iPgorICAgICAgICAgICAgICAgIE9wdGlvbnMgSW5kZXhlcyBNdWx0aVZpZXdzIEZvbGxvd1N5bUxpbmtzCisgICAgICAgICAgICAgICAgQWxsb3dPdmVycmlkZSBOb25lCisgICAgICAgICAgICAgICAgT3JkZXIgYWxsb3csZGVueQorICAgICAgICAgICAgICAgIEFsbG93IGZyb20gYWxsCisgICAgICAgIDwvRGlyZWN0b3J5PgorCitVcGRhdGUgU1NMIGNvbmZpZ3VyYXRpb24gdG8gdXNlIHRoZSBPU1Ugc2VydmVyIGNlcnRpZmljYXRlL2tleS4KKworRW5hYmxlIGRlZmF1bHQtc3NsIHNpdGUgYW5kIHJlc3RhcnQgQXBhY2hlMjoKKyAgc3VkbyBhMmVuc2l0ZSBkZWZhdWx0LXNzbAorICBzdWRvIGEyZW5tb2Qgc3NsCisgIHN1ZG8gc2VydmljZSBhcGFjaGUyIHJlc3RhcnQKKworCitNYW5hZ2VtZW50IFVJCistLS0tLS0tLS0tLS0tCisKK1RoZSBzYW1wbGUgUEhQIHNjcmlwdHMgaW5jbHVkZSBhIG1hbmFnZW1lbnQgVUkgZm9yIHRlc3RpbmcKK3B1cnBvc2VzLiBUaGF0IGlzIGF2YWlsYWJsZSBhdCBodHRwczovLzxzZXJ2ZXI+L2hzMjAvdXNlcnMucGhwCisKKworQVAgY29uZmlndXJhdGlvbgorLS0tLS0tLS0tLS0tLS0tLQorCitBUHMgY2FuIG5vdyBiZSBjb25maWd1cmVkIHRvIHVzZSB0aGUgT1NVIHNlcnZlciBhcyB0aGUgUkFESVVTCithdXRoZW50aWNhdGlvbiBzZXJ2ZXIuIEluIGFkZGl0aW9uLCB0aGUgT1NVIFByb3ZpZGVyIExpc3QgQU5RUCBlbGVtZW50CitzaG91bGQgYmUgY29uZmlndXJlZCB0byB1c2UgdGhlIFNQUCAoU09BUCtYTUwpIG9wdGlvbiBhbmQgd2l0aCB0aGUKK2ZvbGxvd2luZyBTZXJ2ZXIgVVJMOgoraHR0cHM6Ly88c2VydmVyPi9oczIwL3NwcC5waHAvc2lnbnVwP3JlYWxtPWV4YW1wbGUuY29tCmRpZmYgLS1naXQgYS9oczIwL3NlcnZlci9oczIwX3NwcF9zZXJ2ZXIuYyBiL2hzMjAvc2VydmVyL2hzMjBfc3BwX3NlcnZlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU5MWY2NmIKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9oczIwX3NwcF9zZXJ2ZXIuYwpAQCAtMCwwICsxLDE4NyBAQAorLyoKKyAqIEhvdHNwb3QgMi4wIFNQUCBzZXJ2ZXIgLSBzdGFuZGFsb25lIHZlcnNpb24KKyAqIENvcHlyaWdodCAoYykgMjAxMi0yMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKyNpbmNsdWRlIDx0aW1lLmg+CisjaW5jbHVkZSA8c3FsaXRlMy5oPgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAieG1sLXV0aWxzLmgiCisjaW5jbHVkZSAic3BwX3NlcnZlci5oIgorCisKK3N0YXRpYyB2b2lkIHdyaXRlX3RpbWVzdGFtcChGSUxFICpmKQoreworCXRpbWVfdCB0OworCXN0cnVjdCB0bSAqdG07CisKKwl0aW1lKCZ0KTsKKwl0bSA9IGxvY2FsdGltZSgmdCk7CisKKwlmcHJpbnRmKGYsICIlMDR1LSUwMnUtJTAydSAlMDJ1OiUwMnU6JTAydSAiLAorCQl0bS0+dG1feWVhciArIDE5MDAsIHRtLT50bV9tb24gKyAxLCB0bS0+dG1fbWRheSwKKwkJdG0tPnRtX2hvdXIsIHRtLT50bV9taW4sIHRtLT50bV9zZWMpOworfQorCisKK3ZvaWQgZGVidWdfcHJpbnQoc3RydWN0IGhzMjBfc3ZjICpjdHgsIGludCBwcmludCwgY29uc3QgY2hhciAqZm10LCAuLi4pCit7CisJdmFfbGlzdCBhcDsKKworCWlmIChjdHgtPmRlYnVnX2xvZyA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl3cml0ZV90aW1lc3RhbXAoY3R4LT5kZWJ1Z19sb2cpOworCXZhX3N0YXJ0KGFwLCBmbXQpOworCXZmcHJpbnRmKGN0eC0+ZGVidWdfbG9nLCBmbXQsIGFwKTsKKwl2YV9lbmQoYXApOworCisJZnByaW50ZihjdHgtPmRlYnVnX2xvZywgIlxuIik7Cit9CisKKwordm9pZCBkZWJ1Z19kdW1wX25vZGUoc3RydWN0IGhzMjBfc3ZjICpjdHgsIGNvbnN0IGNoYXIgKnRpdGxlLCB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnN0cjsKKworCWlmIChjdHgtPmRlYnVnX2xvZyA9PSBOVUxMKQorCQlyZXR1cm47CisJc3RyID0geG1sX25vZGVfdG9fc3RyKGN0eC0+eG1sLCBub2RlKTsKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybjsKKworCXdyaXRlX3RpbWVzdGFtcChjdHgtPmRlYnVnX2xvZyk7CisJZnByaW50ZihjdHgtPmRlYnVnX2xvZywgIiVzOiAnJXMnXG4iLCB0aXRsZSwgc3RyKTsKKwlvc19mcmVlKHN0cik7Cit9CisKKworc3RhdGljIGludCBwcm9jZXNzKHN0cnVjdCBoczIwX3N2YyAqY3R4KQoreworCWludCBkbWFjYyA9IDA7CisJeG1sX25vZGVfdCAqc29hcCwgKnNwcCwgKnJlc3A7CisJY2hhciAqdXNlciwgKnJlYWxtLCAqcG9zdCwgKnN0cjsKKworCWN0eC0+YWRkciA9IGdldGVudigiSFMyMEFERFIiKTsKKwlpZiAoY3R4LT5hZGRyKQorCQlkZWJ1Z19wcmludChjdHgsIDEsICJDb25uZWN0aW9uIGZyb20gJXMiLCBjdHgtPmFkZHIpOworCisJdXNlciA9IGdldGVudigiSFMyMFVTRVIiKTsKKwlpZiAodXNlciAmJiBzdHJsZW4odXNlcikgPT0gMCkKKwkJdXNlciA9IE5VTEw7CisJcmVhbG0gPSBnZXRlbnYoIkhTMjBSRUFMTSIpOworCWlmIChyZWFsbSA9PSBOVUxMKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkhTMjBSRUFMTSBub3Qgc2V0Iik7CisJCXJldHVybiAtMTsKKwl9CisJcG9zdCA9IGdldGVudigiSFMyMFBPU1QiKTsKKwlpZiAocG9zdCA9PSBOVUxMKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkhTMjBQT1NUIG5vdCBzZXQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXNvYXAgPSB4bWxfbm9kZV9mcm9tX2J1ZihjdHgtPnhtbCwgcG9zdCk7CisJaWYgKHNvYXAgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJDb3VsZCBub3QgcGFyc2UgU09BUCBkYXRhIik7CisJCXJldHVybiAtMTsKKwl9CisJZGVidWdfZHVtcF9ub2RlKGN0eCwgIlJlY2VpdmVkIFNPQVAgbWVzc2FnZSIsIHNvYXApOworCXNwcCA9IHNvYXBfZ2V0X2JvZHkoY3R4LT54bWwsIHNvYXApOworCWlmIChzcHAgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJDb3VsZCBub3QgZ2V0IFNQUCBtZXNzYWdlIik7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHNvYXApOworCQlyZXR1cm4gLTE7CisJfQorCWRlYnVnX2R1bXBfbm9kZShjdHgsICJSZWNlaXZlZCBTUFAgbWVzc2FnZSIsIHNwcCk7CisKKwlyZXNwID0gaHMyMF9zcHBfc2VydmVyX3Byb2Nlc3MoY3R4LCBzcHAsIHVzZXIsIHJlYWxtLCBkbWFjYyk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgc29hcCk7CisJaWYgKHJlc3AgPT0gTlVMTCAmJiB1c2VyID09IE5VTEwpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiUmVxdWVzdCBIVFRQIGF1dGhlbnRpY2F0aW9uIik7CisJCXJldHVybiAyOyAvKiBSZXF1ZXN0IGF1dGhlbnRpY2F0aW9uICovCisJfQorCWlmIChyZXNwID09IE5VTEwpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiTm8gcmVzcG9uc2UiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXNvYXAgPSBzb2FwX2J1aWxkX2VudmVsb3BlKGN0eC0+eG1sLCByZXNwKTsKKwlpZiAoc29hcCA9PSBOVUxMKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIlNPQVAgZW52ZWxvcGUgYnVpbGRpbmcgZmFpbGVkIik7CisJCXJldHVybiAtMTsKKwl9CisJc3RyID0geG1sX25vZGVfdG9fc3RyKGN0eC0+eG1sLCBzb2FwKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBzb2FwKTsKKwlpZiAoc3RyID09IE5VTEwpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiQ291bGQgbm90IGdldCBub2RlIHN0cmluZyIpOworCQlyZXR1cm4gLTE7CisJfQorCXByaW50ZigiJXMiLCBzdHIpOworCWZyZWUoc3RyKTsKKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyB2b2lkIHVzYWdlKHZvaWQpCit7CisJcHJpbnRmKCJ1c2FnZTpcbiIKKwkgICAgICAgImhzMjBfc3BwX3NlcnZlciAtcjxyb290IGRpcmVjdG9yeT4gWy1mPGRlYnVnIGxvZz5dXG4iKTsKK30KKworCitpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKQoreworCXN0cnVjdCBoczIwX3N2YyBjdHg7CisJaW50IHJldDsKKworCW9zX21lbXNldCgmY3R4LCAwLCBzaXplb2YoY3R4KSk7CisJZm9yICg7OykgeworCQlpbnQgYyA9IGdldG9wdChhcmdjLCBhcmd2LCAiZjpyOiIpOworCQlpZiAoYyA8IDApCisJCQlicmVhazsKKwkJc3dpdGNoIChjKSB7CisJCWNhc2UgJ2YnOgorCQkJaWYgKGN0eC5kZWJ1Z19sb2cpCisJCQkJYnJlYWs7CisJCQljdHguZGVidWdfbG9nID0gZm9wZW4ob3B0YXJnLCAiYSIpOworCQkJaWYgKGN0eC5kZWJ1Z19sb2cgPT0gTlVMTCkgeworCQkJCXByaW50ZigiQ291bGQgbm90IHdyaXRlIHRvICVzXG4iLCBvcHRhcmcpOworCQkJCXJldHVybiAtMTsKKwkJCX0KKwkJCWJyZWFrOworCQljYXNlICdyJzoKKwkJCWN0eC5yb290X2RpciA9IG9wdGFyZzsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJdXNhZ2UoKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KKwlpZiAoY3R4LnJvb3RfZGlyID09IE5VTEwpIHsKKwkJdXNhZ2UoKTsKKwkJcmV0dXJuIC0xOworCX0KKwljdHgueG1sID0geG1sX25vZGVfaW5pdF9jdHgoJmN0eCwgTlVMTCk7CisJaWYgKGN0eC54bWwgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWlmIChoczIwX3NwcF9zZXJ2ZXJfaW5pdCgmY3R4KSA8IDApIHsKKwkJeG1sX25vZGVfZGVpbml0X2N0eChjdHgueG1sKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldCA9IHByb2Nlc3MoJmN0eCk7CisJZGVidWdfcHJpbnQoJmN0eCwgMSwgInByb2Nlc3MoKSAtLT4gJWQiLCByZXQpOworCisJeG1sX25vZGVfZGVpbml0X2N0eChjdHgueG1sKTsKKwloczIwX3NwcF9zZXJ2ZXJfZGVpbml0KCZjdHgpOworCWlmIChjdHguZGVidWdfbG9nKQorCQlmY2xvc2UoY3R4LmRlYnVnX2xvZyk7CisKKwlyZXR1cm4gcmV0OworfQpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvc3BwX3NlcnZlci5jIGIvaHMyMC9zZXJ2ZXIvc3BwX3NlcnZlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRkNzdkMGUKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9zcHBfc2VydmVyLmMKQEAgLTAsMCArMSwyMjYzIEBACisvKgorICogSG90c3BvdCAyLjAgU1BQIHNlcnZlcgorICogQ29weXJpZ2h0IChjKSAyMDEyLTIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdGRpby5oPgorI2luY2x1ZGUgPHN0cmluZy5oPgorI2luY2x1ZGUgPGN0eXBlLmg+CisjaW5jbHVkZSA8dGltZS5oPgorI2luY2x1ZGUgPGVycm5vLmg+CisjaW5jbHVkZSA8c3FsaXRlMy5oPgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAiYmFzZTY0LmgiCisjaW5jbHVkZSAibWQ1X2kuaCIKKyNpbmNsdWRlICJ4bWwtdXRpbHMuaCIKKyNpbmNsdWRlICJzcHBfc2VydmVyLmgiCisKKworI2RlZmluZSBTUFBfTlNfVVJJICJodHRwOi8vd3d3LndpLWZpLm9yZy9zcGVjaWZpY2F0aW9ucy9ob3RzcG90MmRvdDAvdjEuMC9zcHAiCisKKyNkZWZpbmUgVVJOX09NQV9ETV9ERVZJTkZPICJ1cm46b21hOm1vOm9tYS1kbS1kZXZpbmZvOjEuMCIKKyNkZWZpbmUgVVJOX09NQV9ETV9ERVZERVRBSUwgInVybjpvbWE6bW86b21hLWRtLWRldmRldGFpbDoxLjAiCisjZGVmaW5lIFVSTl9PTUFfRE1fRE1BQ0MgInVybjpvbWE6bW86b21hLWRtLWRtYWNjOjEuMCIKKyNkZWZpbmUgVVJOX0hTMjBfUFBTICJ1cm46d2ZhOm1vOmhvdHNwb3QyZG90MC1wZXJwcm92aWRlcnN1YnNjcmlwdGlvbjoxLjAiCisKKworLyogVE9ETzogdGltZW91dCB0byBleHBpcmUgc2Vzc2lvbnMgKi8KKworZW51bSBoczIwX3Nlc3Npb25fb3BlcmF0aW9uIHsKKwlOT19PUEVSQVRJT04sCisJVVBEQVRFX1BBU1NXT1JELAorCUNPTlRJTlVFX1NVQlNDUklQVElPTl9SRU1FRElBVElPTiwKKwlDT05USU5VRV9QT0xJQ1lfVVBEQVRFLAorCVVTRVJfUkVNRURJQVRJT04sCisJU1VCU0NSSVBUSU9OX1JFR0lTVFJBVElPTiwKKwlQT0xJQ1lfUkVNRURJQVRJT04sCisJUE9MSUNZX1VQREFURSwKKwlGUkVFX1JFTUVESUFUSU9OLAorfTsKKworCitzdGF0aWMgY2hhciAqIGRiX2dldF9zZXNzaW9uX3ZhbChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqdXNlciwKKwkJCQkgY29uc3QgY2hhciAqcmVhbG0sIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJIGNvbnN0IGNoYXIgKmZpZWxkKTsKK3N0YXRpYyBjaGFyICogZGJfZ2V0X29zdV9jb25maWdfdmFsKHN0cnVjdCBoczIwX3N2YyAqY3R4LCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCQkgICAgY29uc3QgY2hhciAqZmllbGQpOworc3RhdGljIHhtbF9ub2RlX3QgKiBidWlsZF9wb2xpY3koc3RydWN0IGhzMjBfc3ZjICpjdHgsIGNvbnN0IGNoYXIgKnVzZXIsCisJCQkJIGNvbnN0IGNoYXIgKnJlYWxtLCBpbnQgdXNlX2RtYWNjKTsKKworCitzdGF0aWMgaW50IGRiX2FkZF9zZXNzaW9uKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCSAgY29uc3QgY2hhciAqc2Vzc2lvbmlkLCBjb25zdCBjaGFyICpwdywKKwkJCSAgY29uc3QgY2hhciAqcmVkaXJlY3RfdXJpLAorCQkJICBlbnVtIGhzMjBfc2Vzc2lvbl9vcGVyYXRpb24gb3BlcmF0aW9uKQoreworCWNoYXIgKnNxbDsKKwlpbnQgcmV0ID0gMDsKKworCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiSU5TRVJUIElOVE8gc2Vzc2lvbnModGltZXN0YW1wLGlkLHVzZXIscmVhbG0sIgorCQkJICAgICAgIm9wZXJhdGlvbixwYXNzd29yZCxyZWRpcmVjdF91cmkpICIKKwkJCSAgICAgICJWQUxVRVMgIgorCQkJICAgICAgIihzdHJmdGltZSgnJSVZLSUlbS0lJWQgJSVIOiUlTTolJWYnLCdub3cnKSwiCisJCQkgICAgICAiJVEsJVEsJVEsJWQsJVEsJVEpIiwKKwkJCSAgICAgIHNlc3Npb25pZCwgdXNlciA/IHVzZXIgOiAiIiwgcmVhbG0gPyByZWFsbSA6ICIiLAorCQkJICAgICAgb3BlcmF0aW9uLCBwdyA/IHB3IDogIiIsCisJCQkgICAgICByZWRpcmVjdF91cmkgPyByZWRpcmVjdF91cmkgOiAiIik7CisJaWYgKHNxbCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJZGVidWdfcHJpbnQoY3R4LCAxLCAiREI6ICVzIiwgc3FsKTsKKwlpZiAoc3FsaXRlM19leGVjKGN0eC0+ZGIsIHNxbCwgTlVMTCwgTlVMTCwgTlVMTCkgIT0gU1FMSVRFX09LKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkZhaWxlZCB0byBhZGQgc2Vzc2lvbiBlbnRyeSBpbnRvIHNxbGl0ZSAiCisJCQkgICAgImRhdGFiYXNlOiAlcyIsIHNxbGl0ZTNfZXJybXNnKGN0eC0+ZGIpKTsKKwkJcmV0ID0gLTE7CisJfQorCXNxbGl0ZTNfZnJlZShzcWwpOworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIHZvaWQgZGJfdXBkYXRlX3Nlc3Npb25fcGFzc3dvcmQoc3RydWN0IGhzMjBfc3ZjICpjdHgsIGNvbnN0IGNoYXIgKnVzZXIsCisJCQkJICAgICAgIGNvbnN0IGNoYXIgKnJlYWxtLCBjb25zdCBjaGFyICpzZXNzaW9uaWQsCisJCQkJICAgICAgIGNvbnN0IGNoYXIgKnB3KQoreworCWNoYXIgKnNxbDsKKworCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiVVBEQVRFIHNlc3Npb25zIFNFVCBwYXNzd29yZD0lUSBXSEVSRSBpZD0lUSBBTkQgIgorCQkJICAgICAgInVzZXI9JVEgQU5EIHJlYWxtPSVRIiwKKwkJCSAgICAgIHB3LCBzZXNzaW9uaWQsIHVzZXIsIHJlYWxtKTsKKwlpZiAoc3FsID09IE5VTEwpCisJCXJldHVybjsKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogJXMiLCBzcWwpOworCWlmIChzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgc3FsLCBOVUxMLCBOVUxMLCBOVUxMKSAhPSBTUUxJVEVfT0spIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiRmFpbGVkIHRvIHVwZGF0ZSBzZXNzaW9uIHBhc3N3b3JkOiAlcyIsCisJCQkgICAgc3FsaXRlM19lcnJtc2coY3R4LT5kYikpOworCX0KKwlzcWxpdGUzX2ZyZWUoc3FsKTsKK30KKworCitzdGF0aWMgdm9pZCBkYl9hZGRfc2Vzc2lvbl9wcHMoc3RydWN0IGhzMjBfc3ZjICpjdHgsIGNvbnN0IGNoYXIgKnVzZXIsCisJCQkgICAgICAgY29uc3QgY2hhciAqcmVhbG0sIGNvbnN0IGNoYXIgKnNlc3Npb25pZCwKKwkJCSAgICAgICB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnN0cjsKKwljaGFyICpzcWw7CisKKwlzdHIgPSB4bWxfbm9kZV90b19zdHIoY3R4LT54bWwsIG5vZGUpOworCWlmIChzdHIgPT0gTlVMTCkKKwkJcmV0dXJuOworCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiVVBEQVRFIHNlc3Npb25zIFNFVCBwcHM9JVEgV0hFUkUgaWQ9JVEgQU5EICIKKwkJCSAgICAgICJ1c2VyPSVRIEFORCByZWFsbT0lUSIsCisJCQkgICAgICBzdHIsIHNlc3Npb25pZCwgdXNlciwgcmVhbG0pOworCWZyZWUoc3RyKTsKKwlpZiAoc3FsID09IE5VTEwpCisJCXJldHVybjsKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogJXMiLCBzcWwpOworCWlmIChzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgc3FsLCBOVUxMLCBOVUxMLCBOVUxMKSAhPSBTUUxJVEVfT0spIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiRmFpbGVkIHRvIGFkZCBzZXNzaW9uIHBwczogJXMiLAorCQkJICAgIHNxbGl0ZTNfZXJybXNnKGN0eC0+ZGIpKTsKKwl9CisJc3FsaXRlM19mcmVlKHNxbCk7Cit9CisKKworc3RhdGljIHZvaWQgZGJfYWRkX3Nlc3Npb25fZGV2aW5mbyhzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqc2Vzc2lvbmlkLAorCQkJCSAgIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyOworCWNoYXIgKnNxbDsKKworCXN0ciA9IHhtbF9ub2RlX3RvX3N0cihjdHgtPnhtbCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisJc3FsID0gc3FsaXRlM19tcHJpbnRmKCJVUERBVEUgc2Vzc2lvbnMgU0VUIGRldmluZm89JVEgV0hFUkUgaWQ9JVEiLAorCQkJICAgICAgc3RyLCBzZXNzaW9uaWQpOworCWZyZWUoc3RyKTsKKwlpZiAoc3FsID09IE5VTEwpCisJCXJldHVybjsKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogJXMiLCBzcWwpOworCWlmIChzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgc3FsLCBOVUxMLCBOVUxMLCBOVUxMKSAhPSBTUUxJVEVfT0spIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiRmFpbGVkIHRvIGFkZCBzZXNzaW9uIGRldmluZm86ICVzIiwKKwkJCSAgICBzcWxpdGUzX2Vycm1zZyhjdHgtPmRiKSk7CisJfQorCXNxbGl0ZTNfZnJlZShzcWwpOworfQorCisKK3N0YXRpYyB2b2lkIGRiX2FkZF9zZXNzaW9uX2RldmRldGFpbChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKnNlc3Npb25pZCwKKwkJCQkgICAgIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyOworCWNoYXIgKnNxbDsKKworCXN0ciA9IHhtbF9ub2RlX3RvX3N0cihjdHgtPnhtbCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm47CisJc3FsID0gc3FsaXRlM19tcHJpbnRmKCJVUERBVEUgc2Vzc2lvbnMgU0VUIGRldmRldGFpbD0lUSBXSEVSRSBpZD0lUSIsCisJCQkgICAgICBzdHIsIHNlc3Npb25pZCk7CisJZnJlZShzdHIpOworCWlmIChzcWwgPT0gTlVMTCkKKwkJcmV0dXJuOworCWRlYnVnX3ByaW50KGN0eCwgMSwgIkRCOiAlcyIsIHNxbCk7CisJaWYgKHNxbGl0ZTNfZXhlYyhjdHgtPmRiLCBzcWwsIE5VTEwsIE5VTEwsIE5VTEwpICE9IFNRTElURV9PSykgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJGYWlsZWQgdG8gYWRkIHNlc3Npb24gZGV2ZGV0YWlsOiAlcyIsCisJCQkgICAgc3FsaXRlM19lcnJtc2coY3R4LT5kYikpOworCX0KKwlzcWxpdGUzX2ZyZWUoc3FsKTsKK30KKworCitzdGF0aWMgdm9pZCBkYl9yZW1vdmVfc2Vzc2lvbihzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCSAgICAgIGNvbnN0IGNoYXIgKnVzZXIsIGNvbnN0IGNoYXIgKnJlYWxtLAorCQkJICAgICAgY29uc3QgY2hhciAqc2Vzc2lvbmlkKQoreworCWNoYXIgKnNxbDsKKworCWlmICh1c2VyID09IE5VTEwgfHwgcmVhbG0gPT0gTlVMTCkgeworCQlzcWwgPSBzcWxpdGUzX21wcmludGYoIkRFTEVURSBGUk9NIHNlc3Npb25zIFdIRVJFICIKKwkJCQkgICAgICAiaWQ9JVEiLCBzZXNzaW9uaWQpOworCX0gZWxzZSB7CisJCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiREVMRVRFIEZST00gc2Vzc2lvbnMgV0hFUkUgIgorCQkJCSAgICAgICJ1c2VyPSVRIEFORCByZWFsbT0lUSBBTkQgaWQ9JVEiLAorCQkJCSAgICAgIHVzZXIsIHJlYWxtLCBzZXNzaW9uaWQpOworCX0KKwlpZiAoc3FsID09IE5VTEwpCisJCXJldHVybjsKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogJXMiLCBzcWwpOworCWlmIChzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgc3FsLCBOVUxMLCBOVUxMLCBOVUxMKSAhPSBTUUxJVEVfT0spIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiRmFpbGVkIHRvIGRlbGV0ZSBzZXNzaW9uIGVudHJ5IGZyb20gIgorCQkJICAgICJzcWxpdGUgZGF0YWJhc2U6ICVzIiwgc3FsaXRlM19lcnJtc2coY3R4LT5kYikpOworCX0KKwlzcWxpdGUzX2ZyZWUoc3FsKTsKK30KKworCitzdGF0aWMgdm9pZCBoczIwX2V2ZW50bG9nKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCSAgY29uc3QgY2hhciAqc2Vzc2lvbmlkLCBjb25zdCBjaGFyICpub3RlcywKKwkJCSAgY29uc3QgY2hhciAqZHVtcCkKK3sKKwljaGFyICpzcWw7CisJY2hhciAqdXNlcl9idWYgPSBOVUxMLCAqcmVhbG1fYnVmID0gTlVMTDsKKworCWRlYnVnX3ByaW50KGN0eCwgMSwgImV2ZW50bG9nOiAlcyIsIG5vdGVzKTsKKworCWlmICh1c2VyID09IE5VTEwpIHsKKwkJdXNlcl9idWYgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCBOVUxMLCBOVUxMLCBzZXNzaW9uaWQsCisJCQkJCSAgICAgICJ1c2VyIik7CisJCXVzZXIgPSB1c2VyX2J1ZjsKKwkJcmVhbG1fYnVmID0gZGJfZ2V0X3Nlc3Npb25fdmFsKGN0eCwgTlVMTCwgTlVMTCwgc2Vzc2lvbmlkLAorCQkJCQkgICAgICAgInJlYWxtIik7CisJCXJlYWxtID0gcmVhbG1fYnVmOworCX0KKworCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiSU5TRVJUIElOVE8gZXZlbnRsb2ciCisJCQkgICAgICAiKHVzZXIscmVhbG0sc2Vzc2lvbmlkLHRpbWVzdGFtcCxub3RlcyxkdW1wLGFkZHIpIgorCQkJICAgICAgIiBWQUxVRVMgKCVRLCVRLCVRLCIKKwkJCSAgICAgICJzdHJmdGltZSgnJSVZLSUlbS0lJWQgJSVIOiUlTTolJWYnLCdub3cnKSwiCisJCQkgICAgICAiJVEsJVEsJVEpIiwKKwkJCSAgICAgIHVzZXIsIHJlYWxtLCBzZXNzaW9uaWQsIG5vdGVzLAorCQkJICAgICAgZHVtcCA/IGR1bXAgOiAiIiwgY3R4LT5hZGRyID8gY3R4LT5hZGRyIDogIiIpOworCWZyZWUodXNlcl9idWYpOworCWZyZWUocmVhbG1fYnVmKTsKKwlpZiAoc3FsID09IE5VTEwpCisJCXJldHVybjsKKwlpZiAoc3FsaXRlM19leGVjKGN0eC0+ZGIsIHNxbCwgTlVMTCwgTlVMTCwgTlVMTCkgIT0gU1FMSVRFX09LKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkZhaWxlZCB0byBhZGQgZXZlbnRsb2cgZW50cnkgaW50byBzcWxpdGUgIgorCQkJICAgICJkYXRhYmFzZTogJXMiLCBzcWxpdGUzX2Vycm1zZyhjdHgtPmRiKSk7CisJfQorCXNxbGl0ZTNfZnJlZShzcWwpOworfQorCisKK3N0YXRpYyB2b2lkIGhzMjBfZXZlbnRsb2dfbm9kZShzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCSAgICAgICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCSAgICAgICBjb25zdCBjaGFyICpzZXNzaW9uaWQsIGNvbnN0IGNoYXIgKm5vdGVzLAorCQkJICAgICAgIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyOworCisJaWYgKG5vZGUpCisJCXN0ciA9IHhtbF9ub2RlX3RvX3N0cihjdHgtPnhtbCwgbm9kZSk7CisJZWxzZQorCQlzdHIgPSBOVUxMOworCWhzMjBfZXZlbnRsb2coY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbmlkLCBub3Rlcywgc3RyKTsKKwlmcmVlKHN0cik7Cit9CisKKworc3RhdGljIHZvaWQgZGJfdXBkYXRlX21vX3N0cihzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqdXNlciwKKwkJCSAgICAgY29uc3QgY2hhciAqcmVhbG0sIGNvbnN0IGNoYXIgKm5hbWUsCisJCQkgICAgIGNvbnN0IGNoYXIgKnN0cikKK3sKKwljaGFyICpzcWw7CisJaWYgKHVzZXIgPT0gTlVMTCB8fCByZWFsbSA9PSBOVUxMIHx8IG5hbWUgPT0gTlVMTCkKKwkJcmV0dXJuOworCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiVVBEQVRFIHVzZXJzIFNFVCAlcz0lUSAiCisJCSAiV0hFUkUgaWRlbnRpdHk9JVEgQU5EIHJlYWxtPSVRIEFORCBwaGFzZTI9MSIsCisJCQkgICAgICBuYW1lLCBzdHIsIHVzZXIsIHJlYWxtKTsKKwlpZiAoc3FsID09IE5VTEwpCisJCXJldHVybjsKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogJXMiLCBzcWwpOworCWlmIChzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgc3FsLCBOVUxMLCBOVUxMLCBOVUxMKSAhPSBTUUxJVEVfT0spIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiRmFpbGVkIHRvIHVwZGF0ZSB1c2VyIE1PIGVudHJ5IGluIHNxbGl0ZSAiCisJCQkgICAgImRhdGFiYXNlOiAlcyIsIHNxbGl0ZTNfZXJybXNnKGN0eC0+ZGIpKTsKKwl9CisJc3FsaXRlM19mcmVlKHNxbCk7Cit9CisKKworc3RhdGljIHZvaWQgZGJfdXBkYXRlX21vKHN0cnVjdCBoczIwX3N2YyAqY3R4LCBjb25zdCBjaGFyICp1c2VyLAorCQkJIGNvbnN0IGNoYXIgKnJlYWxtLCBjb25zdCBjaGFyICpuYW1lLCB4bWxfbm9kZV90ICptbykKK3sKKwljaGFyICpzdHI7CisKKwlzdHIgPSB4bWxfbm9kZV90b19zdHIoY3R4LT54bWwsIG1vKTsKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybjsKKworCWRiX3VwZGF0ZV9tb19zdHIoY3R4LCB1c2VyLCByZWFsbSwgbmFtZSwgc3RyKTsKKwlmcmVlKHN0cik7Cit9CisKKworc3RhdGljIHZvaWQgYWRkX3RleHRfbm9kZShzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJICBjb25zdCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwl4bWxfbm9kZV9jcmVhdGVfdGV4dChjdHgtPnhtbCwgcGFyZW50LCBOVUxMLCBuYW1lLCB2YWx1ZSA/IHZhbHVlIDogIiIpOworfQorCisKK3N0YXRpYyB2b2lkIGFkZF90ZXh0X25vZGVfY29uZihzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqcmVhbG0sCisJCQkgICAgICAgeG1sX25vZGVfdCAqcGFyZW50LCBjb25zdCBjaGFyICpuYW1lLAorCQkJICAgICAgIGNvbnN0IGNoYXIgKmZpZWxkKQoreworCWNoYXIgKnZhbDsKKwl2YWwgPSBkYl9nZXRfb3N1X2NvbmZpZ192YWwoY3R4LCByZWFsbSwgZmllbGQpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBwYXJlbnQsIE5VTEwsIG5hbWUsIHZhbCA/IHZhbCA6ICIiKTsKKwlvc19mcmVlKHZhbCk7Cit9CisKKworc3RhdGljIGludCBuZXdfcGFzc3dvcmQoY2hhciAqYnVmLCBpbnQgYnVmbGVuKQoreworCWludCBpOworCisJaWYgKGJ1ZmxlbiA8IDEpCisJCXJldHVybiAtMTsKKwlidWZbYnVmbGVuIC0gMV0gPSAnXDAnOworCWlmIChvc19nZXRfcmFuZG9tKCh1bnNpZ25lZCBjaGFyICopIGJ1ZiwgYnVmbGVuIC0gMSkgPCAwKQorCQlyZXR1cm4gLTE7CisKKwlmb3IgKGkgPSAwOyBpIDwgYnVmbGVuIC0gMTsgaSsrKSB7CisJCXVuc2lnbmVkIGNoYXIgdmFsID0gYnVmW2ldOworCQl2YWwgJT0gMiAqIDI2ICsgMTA7CisJCWlmICh2YWwgPCAyNikKKwkJCWJ1ZltpXSA9ICdhJyArIHZhbDsKKwkJZWxzZSBpZiAodmFsIDwgMiAqIDI2KQorCQkJYnVmW2ldID0gJ0EnICsgdmFsIC0gMjY7CisJCWVsc2UKKwkJCWJ1ZltpXSA9ICcwJyArIHZhbCAtIDIgKiAyNjsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdHJ1Y3QgZ2V0X2RiX2ZpZWxkX2RhdGEgeworCWNvbnN0IGNoYXIgKmZpZWxkOworCWNoYXIgKnZhbHVlOworfTsKKworCitzdGF0aWMgaW50IGdldF9kYl9maWVsZCh2b2lkICpjdHgsIGludCBhcmdjLCBjaGFyICphcmd2W10sIGNoYXIgKmNvbFtdKQoreworCXN0cnVjdCBnZXRfZGJfZmllbGRfZGF0YSAqZGF0YSA9IGN0eDsKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBhcmdjOyBpKyspIHsKKwkJaWYgKG9zX3N0cmNtcChjb2xbaV0sIGRhdGEtPmZpZWxkKSA9PSAwICYmIGFyZ3ZbaV0pIHsKKwkJCW9zX2ZyZWUoZGF0YS0+dmFsdWUpOworCQkJZGF0YS0+dmFsdWUgPSBvc19zdHJkdXAoYXJndltpXSk7CisJCQlicmVhazsKKwkJfQorCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBjaGFyICogZGJfZ2V0X3ZhbChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqdXNlciwKKwkJCSBjb25zdCBjaGFyICpyZWFsbSwgY29uc3QgY2hhciAqZmllbGQsIGludCBkbWFjYykKK3sKKwljaGFyICpjbWQ7CisJc3RydWN0IGdldF9kYl9maWVsZF9kYXRhIGRhdGE7CisKKwljbWQgPSBzcWxpdGUzX21wcmludGYoIlNFTEVDVCAlcyBGUk9NIHVzZXJzIFdIRVJFICIKKwkJCSAgICAgICIlcz0lUSBBTkQgcmVhbG09JVEgQU5EIHBoYXNlMj0xIiwKKwkJCSAgICAgIGZpZWxkLCBkbWFjYyA/ICJvc3VfdXNlciIgOiAiaWRlbnRpdHkiLAorCQkJICAgICAgdXNlciwgcmVhbG0pOworCWlmIChjbWQgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOworCWRhdGEuZmllbGQgPSBmaWVsZDsKKwlpZiAoc3FsaXRlM19leGVjKGN0eC0+ZGIsIGNtZCwgZ2V0X2RiX2ZpZWxkLCAmZGF0YSwgTlVMTCkgIT0gU1FMSVRFX09LKQorCXsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiQ291bGQgbm90IGZpbmQgdXNlciAnJXMnIiwgdXNlcik7CisJCXNxbGl0ZTNfZnJlZShjbWQpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJc3FsaXRlM19mcmVlKGNtZCk7CisKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogdXNlcj0nJXMnIHJlYWxtPSclcycgZmllbGQ9JyVzJyBkbWFjYz0lZCAtLT4gIgorCQkgICAgInZhbHVlPSclcyciLCB1c2VyLCByZWFsbSwgZmllbGQsIGRtYWNjLCBkYXRhLnZhbHVlKTsKKworCXJldHVybiBkYXRhLnZhbHVlOworfQorCisKK3N0YXRpYyBpbnQgZGJfdXBkYXRlX3ZhbChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqdXNlciwKKwkJCSBjb25zdCBjaGFyICpyZWFsbSwgY29uc3QgY2hhciAqZmllbGQsCisJCQkgY29uc3QgY2hhciAqdmFsLCBpbnQgZG1hY2MpCit7CisJY2hhciAqY21kOworCWludCByZXQ7CisKKwljbWQgPSBzcWxpdGUzX21wcmludGYoIlVQREFURSB1c2VycyBTRVQgJXM9JVEgV0hFUkUgIgorCQkJICAgICAgIiVzPSVRIEFORCByZWFsbT0lUSBBTkQgcGhhc2UyPTEiLAorCQkJICAgICAgZmllbGQsIHZhbCwgZG1hY2MgPyAib3N1X3VzZXIiIDogImlkZW50aXR5IiwgdXNlciwKKwkJCSAgICAgIHJlYWxtKTsKKwlpZiAoY21kID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogJXMiLCBjbWQpOworCWlmIChzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgY21kLCBOVUxMLCBOVUxMLCBOVUxMKSAhPSBTUUxJVEVfT0spIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLAorCQkJICAgICJGYWlsZWQgdG8gdXBkYXRlIHVzZXIgaW4gc3FsaXRlIGRhdGFiYXNlOiAlcyIsCisJCQkgICAgc3FsaXRlM19lcnJtc2coY3R4LT5kYikpOworCQlyZXQgPSAtMTsKKwl9IGVsc2UgeworCQlkZWJ1Z19wcmludChjdHgsIDEsCisJCQkgICAgIkRCOiB1c2VyPSclcycgcmVhbG09JyVzJyBmaWVsZD0nJXMnIHNldCB0byAnJXMnIiwKKwkJCSAgICB1c2VyLCByZWFsbSwgZmllbGQsIHZhbCk7CisJCXJldCA9IDA7CisJfQorCXNxbGl0ZTNfZnJlZShjbWQpOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgY2hhciAqIGRiX2dldF9zZXNzaW9uX3ZhbChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqdXNlciwKKwkJCQkgY29uc3QgY2hhciAqcmVhbG0sIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJIGNvbnN0IGNoYXIgKmZpZWxkKQoreworCWNoYXIgKmNtZDsKKwlzdHJ1Y3QgZ2V0X2RiX2ZpZWxkX2RhdGEgZGF0YTsKKworCWlmICh1c2VyID09IE5VTEwgfHwgcmVhbG0gPT0gTlVMTCkgeworCQljbWQgPSBzcWxpdGUzX21wcmludGYoIlNFTEVDVCAlcyBGUk9NIHNlc3Npb25zIFdIRVJFICIKKwkJCQkgICAgICAiaWQ9JVEiLCBmaWVsZCwgc2Vzc2lvbl9pZCk7CisJfSBlbHNlIHsKKwkJY21kID0gc3FsaXRlM19tcHJpbnRmKCJTRUxFQ1QgJXMgRlJPTSBzZXNzaW9ucyBXSEVSRSAiCisJCQkJICAgICAgInVzZXI9JVEgQU5EIHJlYWxtPSVRIEFORCBpZD0lUSIsCisJCQkJICAgICAgZmllbGQsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkKTsKKwl9CisJaWYgKGNtZCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlkZWJ1Z19wcmludChjdHgsIDEsICJEQjogJXMiLCBjbWQpOworCW1lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKKwlkYXRhLmZpZWxkID0gZmllbGQ7CisJaWYgKHNxbGl0ZTNfZXhlYyhjdHgtPmRiLCBjbWQsIGdldF9kYl9maWVsZCwgJmRhdGEsIE5VTEwpICE9IFNRTElURV9PSykKKwl7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkRCOiBDb3VsZCBub3QgZmluZCBzZXNzaW9uICVzOiAlcyIsCisJCQkgICAgc2Vzc2lvbl9pZCwgc3FsaXRlM19lcnJtc2coY3R4LT5kYikpOworCQlzcWxpdGUzX2ZyZWUoY21kKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCXNxbGl0ZTNfZnJlZShjbWQpOworCisJZGVidWdfcHJpbnQoY3R4LCAxLCAiREI6IHJldHVybiAnJXMnIiwgZGF0YS52YWx1ZSk7CisJcmV0dXJuIGRhdGEudmFsdWU7Cit9CisKKworc3RhdGljIGludCB1cGRhdGVfcGFzc3dvcmQoc3RydWN0IGhzMjBfc3ZjICpjdHgsIGNvbnN0IGNoYXIgKnVzZXIsCisJCQkgICBjb25zdCBjaGFyICpyZWFsbSwgY29uc3QgY2hhciAqcHcsIGludCBkbWFjYykKK3sKKwljaGFyICpjbWQ7CisKKwljbWQgPSBzcWxpdGUzX21wcmludGYoIlVQREFURSB1c2VycyBTRVQgcGFzc3dvcmQ9JVEsICIKKwkJCSAgICAgICJyZW1lZGlhdGlvbj0nJyAiCisJCQkgICAgICAiV0hFUkUgJXM9JVEgQU5EIHBoYXNlMj0xIiwKKwkJCSAgICAgIHB3LCBkbWFjYyA/ICJvc3VfdXNlciIgOiAiaWRlbnRpdHkiLAorCQkJICAgICAgdXNlcik7CisJaWYgKGNtZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJZGVidWdfcHJpbnQoY3R4LCAxLCAiREI6ICVzIiwgY21kKTsKKwlpZiAoc3FsaXRlM19leGVjKGN0eC0+ZGIsIGNtZCwgTlVMTCwgTlVMTCwgTlVMTCkgIT0gU1FMSVRFX09LKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkZhaWxlZCB0byB1cGRhdGUgZGF0YWJhc2UgZm9yIHVzZXIgJyVzJyIsCisJCQkgICAgdXNlcik7CisJfQorCXNxbGl0ZTNfZnJlZShjbWQpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBhZGRfZWFwX3R0bHMoc3RydWN0IGhzMjBfc3ZjICpjdHgsIHhtbF9ub2RlX3QgKnBhcmVudCkKK3sKKwl4bWxfbm9kZV90ICpub2RlOworCisJbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgcGFyZW50LCBOVUxMLCAiRUFQTWV0aG9kIik7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJYWRkX3RleHRfbm9kZShjdHgsIG5vZGUsICJFQVBUeXBlIiwgIjIxIik7CisJYWRkX3RleHRfbm9kZShjdHgsIG5vZGUsICJJbm5lck1ldGhvZCIsICJNUy1DSEFQLVYyIik7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX3VzZXJuYW1lX3Bhc3N3b3JkKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCQkgICAgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJCQkgICAgY29uc3QgY2hhciAqdXNlciwgY29uc3QgY2hhciAqcHcpCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKwljaGFyICpiNjQ7CisKKwlub2RlID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBwYXJlbnQsIE5VTEwsICJVc2VybmFtZVBhc3N3b3JkIik7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlhZGRfdGV4dF9ub2RlKGN0eCwgbm9kZSwgIlVzZXJuYW1lIiwgdXNlcik7CisKKwliNjQgPSAoY2hhciAqKSBiYXNlNjRfZW5jb2RlKCh1bnNpZ25lZCBjaGFyICopIHB3LCBzdHJsZW4ocHcpLCBOVUxMKTsKKwlpZiAoYjY0ID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCWFkZF90ZXh0X25vZGUoY3R4LCBub2RlLCAiUGFzc3dvcmQiLCBiNjQpOworCWZyZWUoYjY0KTsKKworCXJldHVybiBub2RlOworfQorCisKK3N0YXRpYyBpbnQgYWRkX3VzZXJuYW1lX3Bhc3N3b3JkKHN0cnVjdCBoczIwX3N2YyAqY3R4LCB4bWxfbm9kZV90ICpjcmVkLAorCQkJCSBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpwdykKK3sKKwl4bWxfbm9kZV90ICpub2RlOworCisJbm9kZSA9IGJ1aWxkX3VzZXJuYW1lX3Bhc3N3b3JkKGN0eCwgY3JlZCwgdXNlciwgcHcpOworCWlmIChub2RlID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCWFkZF90ZXh0X25vZGUoY3R4LCBub2RlLCAiTWFjaGluZU1hbmFnZWQiLCAiVFJVRSIpOworCWFkZF90ZXh0X25vZGUoY3R4LCBub2RlLCAiU29mdFRva2VuQXBwIiwgIiIpOworCWFkZF9lYXBfdHRscyhjdHgsIG5vZGUpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQgYWRkX2NyZWF0aW9uX2RhdGUoc3RydWN0IGhzMjBfc3ZjICpjdHgsIHhtbF9ub2RlX3QgKmNyZWQpCit7CisJY2hhciBzdHJbMzBdOworCXRpbWVfdCBub3c7CisJc3RydWN0IHRtIHRtOworCisJdGltZSgmbm93KTsKKwlnbXRpbWVfcigmbm93LCAmdG0pOworCXNucHJpbnRmKHN0ciwgc2l6ZW9mKHN0ciksICIlMDR1LSUwMnUtJTAydVQlMDJ1OiUwMnU6JTAydVoiLAorCQkgdG0udG1feWVhciArIDE5MDAsIHRtLnRtX21vbiArIDEsIHRtLnRtX21kYXksCisJCSB0bS50bV9ob3VyLCB0bS50bV9taW4sIHRtLnRtX3NlYyk7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIGNyZWQsIE5VTEwsICJDcmVhdGlvbkRhdGUiLCBzdHIpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogYnVpbGRfY3JlZGVudGlhbF9wdyhzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkJY29uc3QgY2hhciAqdXNlciwgY29uc3QgY2hhciAqcmVhbG0sCisJCQkJCWNvbnN0IGNoYXIgKnB3KQoreworCXhtbF9ub2RlX3QgKmNyZWQ7CisKKwljcmVkID0geG1sX25vZGVfY3JlYXRlX3Jvb3QoY3R4LT54bWwsIE5VTEwsIE5VTEwsIE5VTEwsICJDcmVkZW50aWFsIik7CisJaWYgKGNyZWQgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJGYWlsZWQgdG8gY3JlYXRlIENyZWRlbnRpYWwgbm9kZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJYWRkX2NyZWF0aW9uX2RhdGUoY3R4LCBjcmVkKTsKKwlpZiAoYWRkX3VzZXJuYW1lX3Bhc3N3b3JkKGN0eCwgY3JlZCwgdXNlciwgcHcpIDwgMCkgeworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBjcmVkKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCWFkZF90ZXh0X25vZGUoY3R4LCBjcmVkLCAiUmVhbG0iLCByZWFsbSk7CisKKwlyZXR1cm4gY3JlZDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX2NyZWRlbnRpYWwoc3RydWN0IGhzMjBfc3ZjICpjdHgsCisJCQkJICAgICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCQkgICAgIGNoYXIgKm5ld19wdywgc2l6ZV90IG5ld19wd19sZW4pCit7CisJaWYgKG5ld19wYXNzd29yZChuZXdfcHcsIG5ld19wd19sZW4pIDwgMCkKKwkJcmV0dXJuIE5VTEw7CisJZGVidWdfcHJpbnQoY3R4LCAxLCAiVXBkYXRlIHBhc3N3b3JkIHRvICclcyciLCBuZXdfcHcpOworCXJldHVybiBidWlsZF9jcmVkZW50aWFsX3B3KGN0eCwgdXNlciwgcmVhbG0sIG5ld19wdyk7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBidWlsZF9jcmVkZW50aWFsX2NlcnQoc3RydWN0IGhzMjBfc3ZjICpjdHgsCisJCQkJCSAgY29uc3QgY2hhciAqdXNlciwgY29uc3QgY2hhciAqcmVhbG0sCisJCQkJCSAgY29uc3QgY2hhciAqY2VydF9maW5nZXJwcmludCkKK3sKKwl4bWxfbm9kZV90ICpjcmVkLCAqY2VydDsKKworCWNyZWQgPSB4bWxfbm9kZV9jcmVhdGVfcm9vdChjdHgtPnhtbCwgTlVMTCwgTlVMTCwgTlVMTCwgIkNyZWRlbnRpYWwiKTsKKwlpZiAoY3JlZCA9PSBOVUxMKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkZhaWxlZCB0byBjcmVhdGUgQ3JlZGVudGlhbCBub2RlIik7CisJCXJldHVybiBOVUxMOworCX0KKwlhZGRfY3JlYXRpb25fZGF0ZShjdHgsIGNyZWQpOworCWNlcnQgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIGNyZWQsIE5VTEwsICJEaWdpdGFsQ2VydGlmaWNhdGUiKTsKKwlhZGRfdGV4dF9ub2RlKGN0eCwgY2VydCwgIkNlcnRpZmljYXRlVHlwZSIsICJ4NTA5djMiKTsKKwlhZGRfdGV4dF9ub2RlKGN0eCwgY2VydCwgIkNlcnRTSEEyNTZGaW5nZXJwcmludCIsIGNlcnRfZmluZ2VycHJpbnQpOworCWFkZF90ZXh0X25vZGUoY3R4LCBjcmVkLCAiUmVhbG0iLCByZWFsbSk7CisKKwlyZXR1cm4gY3JlZDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2Uoc3RydWN0IGhzMjBfc3ZjICpjdHgsCisJCQkJCQkgeG1sX25hbWVzcGFjZV90ICoqcmV0X25zLAorCQkJCQkJIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJCQkgY29uc3QgY2hhciAqc3RhdHVzLAorCQkJCQkJIGNvbnN0IGNoYXIgKmVycm9yX2NvZGUpCit7CisJeG1sX25vZGVfdCAqc3BwX25vZGUgPSBOVUxMOworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisKKwlzcHBfbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZV9yb290KGN0eC0+eG1sLCBTUFBfTlNfVVJJLCAic3BwIiwgJm5zLAorCQkJCQkic3BwUG9zdERldkRhdGFSZXNwb25zZSIpOworCWlmIChzcHBfbm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlpZiAocmV0X25zKQorCQkqcmV0X25zID0gbnM7CisKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgc3BwX25vZGUsIG5zLCAic3BwVmVyc2lvbiIsICIxLjAiKTsKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgc3BwX25vZGUsIG5zLCAic2Vzc2lvbklEIiwgc2Vzc2lvbl9pZCk7CisJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInNwcFN0YXR1cyIsIHN0YXR1cyk7CisKKwlpZiAoZXJyb3JfY29kZSkgeworCQl4bWxfbm9kZV90ICpub2RlOworCQlub2RlID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBzcHBfbm9kZSwgbnMsICJzcHBFcnJvciIpOworCQlpZiAobm9kZSkKKwkJCXhtbF9ub2RlX2FkZF9hdHRyKGN0eC0+eG1sLCBub2RlLCBOVUxMLCAiZXJyb3JDb2RlIiwKKwkJCQkJICBlcnJvcl9jb2RlKTsKKwl9CisKKwlyZXR1cm4gc3BwX25vZGU7Cit9CisKKworc3RhdGljIGludCBhZGRfdXBkYXRlX25vZGUoc3RydWN0IGhzMjBfc3ZjICpjdHgsIHhtbF9ub2RlX3QgKnNwcF9ub2RlLAorCQkJICAgeG1sX25hbWVzcGFjZV90ICpucywgY29uc3QgY2hhciAqdXJpLAorCQkJICAgeG1sX25vZGVfdCAqdXBkX25vZGUpCit7CisJeG1sX25vZGVfdCAqbm9kZSwgKnRuZHM7CisJY2hhciAqc3RyOworCisJdG5kcyA9IG1vX3RvX3RuZHMoY3R4LT54bWwsIHVwZF9ub2RlLCAwLCBOVUxMLCBOVUxMKTsKKwlpZiAoIXRuZHMpCisJCXJldHVybiAtMTsKKworCXN0ciA9IHhtbF9ub2RlX3RvX3N0cihjdHgtPnhtbCwgdG5kcyk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgdG5kcyk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBzcHBfbm9kZSwgbnMsICJ1cGRhdGVOb2RlIiwgc3RyKTsKKwlmcmVlKHN0cik7CisKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgbm9kZSwgbnMsICJtYW5hZ2VtZW50VHJlZVVSSSIsIHVyaSk7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJ1aWxkX3N1Yl9yZW1fcmVzcChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkgICAgICAgY29uc3QgY2hhciAqdXNlciwgY29uc3QgY2hhciAqcmVhbG0sCisJCQkJICAgICAgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJICAgICAgIGludCBtYWNoaW5lX3JlbSwgaW50IGRtYWNjKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqc3BwX25vZGUsICpjcmVkOworCWNoYXIgYnVmWzQwMF07CisJY2hhciBuZXdfcHdbMzNdOworCWNoYXIgKnJlYWxfdXNlciA9IE5VTEw7CisJY2hhciAqc3RhdHVzOworCWNoYXIgKmNlcnQ7CisKKwlpZiAoZG1hY2MpIHsKKwkJcmVhbF91c2VyID0gZGJfZ2V0X3ZhbChjdHgsIHVzZXIsIHJlYWxtLCAiaWRlbnRpdHkiLCBkbWFjYyk7CisJCWlmIChyZWFsX3VzZXIgPT0gTlVMTCkgeworCQkJZGVidWdfcHJpbnQoY3R4LCAxLCAiQ291bGQgbm90IGZpbmQgdXNlciBpZGVudGl0eSBmb3IgIgorCQkJCSAgICAiZG1hY2MgdXNlciAnJXMnIiwgdXNlcik7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCX0KKworCWNlcnQgPSBkYl9nZXRfdmFsKGN0eCwgdXNlciwgcmVhbG0sICJjZXJ0IiwgZG1hY2MpOworCWlmIChjZXJ0ICYmIGNlcnRbMF0gPT0gJ1wwJykKKwkJY2VydCA9IE5VTEw7CisJaWYgKGNlcnQpIHsKKwkJY3JlZCA9IGJ1aWxkX2NyZWRlbnRpYWxfY2VydChjdHgsIHJlYWxfdXNlciA/IHJlYWxfdXNlciA6IHVzZXIsCisJCQkJCSAgICAgcmVhbG0sIGNlcnQpOworCX0gZWxzZSB7CisJCWNyZWQgPSBidWlsZF9jcmVkZW50aWFsKGN0eCwgcmVhbF91c2VyID8gcmVhbF91c2VyIDogdXNlciwKKwkJCQkJcmVhbG0sIG5ld19wdywgc2l6ZW9mKG5ld19wdykpOworCX0KKwlmcmVlKHJlYWxfdXNlcik7CisJaWYgKCFjcmVkKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkNvdWxkIG5vdCBidWlsZCBjcmVkZW50aWFsIik7CisJCXJldHVybiBOVUxMOworCX0KKworCXN0YXR1cyA9ICJSZW1lZGlhdGlvbiBjb21wbGV0ZSwgcmVxdWVzdCBzcHBVcGRhdGVSZXNwb25zZSI7CisJc3BwX25vZGUgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgJm5zLCBzZXNzaW9uX2lkLCBzdGF0dXMsCisJCQkJCQlOVUxMKTsKKwlpZiAoc3BwX25vZGUgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJDb3VsZCBub3QgYnVpbGQgc3BwUG9zdERldkRhdGFSZXNwb25zZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlzbnByaW50ZihidWYsIHNpemVvZihidWYpLAorCQkgIi4vV2ktRmkvJXMvUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24vQ3JlZGVudGlhbDEvQ3JlZGVudGlhbCIsCisJCSByZWFsbSk7CisKKwlpZiAoYWRkX3VwZGF0ZV9ub2RlKGN0eCwgc3BwX25vZGUsIG5zLCBidWYsIGNyZWQpIDwgMCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJDb3VsZCBub3QgYWRkIHVwZGF0ZSBub2RlIik7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHNwcF9ub2RlKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkgICBtYWNoaW5lX3JlbSA/ICJtYWNoaW5lIHJlbWVkaWF0aW9uIiA6CisJCQkgICAidXNlciByZW1lZGlhdGlvbiIsIGNyZWQpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIGNyZWQpOworCisJaWYgKGNlcnQpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiQ2VydGlmaWNhdGUgY3JlZGVudGlhbCAtIG5vIG5lZWQgZm9yIERCICIKKwkJCSAgICAicGFzc3dvcmQgdXBkYXRlIG9uIHN1Y2Nlc3Mgbm90aWZpY2F0aW9uIik7CisJfSBlbHNlIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiUmVxdWVzdCBEQiBwYXNzd29yZCB1cGRhdGUgb24gc3VjY2VzcyAiCisJCQkgICAgIm5vdGlmaWNhdGlvbiIpOworCQlkYl9hZGRfc2Vzc2lvbihjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLCBuZXdfcHcsIE5VTEwsCisJCQkgICAgICAgVVBEQVRFX1BBU1NXT1JEKTsKKwl9CisKKwlyZXR1cm4gc3BwX25vZGU7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBtYWNoaW5lX3JlbWVkaWF0aW9uKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCQljb25zdCBjaGFyICp1c2VyLAorCQkJCQljb25zdCBjaGFyICpyZWFsbSwKKwkJCQkJY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwgaW50IGRtYWNjKQoreworCXJldHVybiBidWlsZF9zdWJfcmVtX3Jlc3AoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgMSwgZG1hY2MpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogcG9saWN5X3JlbWVkaWF0aW9uKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCSAgICAgICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCQkgICAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwgaW50IGRtYWNjKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqc3BwX25vZGUsICpwb2xpY3k7CisJY2hhciBidWZbNDAwXTsKKwljb25zdCBjaGFyICpzdGF0dXM7CisKKwloczIwX2V2ZW50bG9nKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCSAgICAgICJyZXF1aXJlcyBwb2xpY3kgcmVtZWRpYXRpb24iLCBOVUxMKTsKKworCWRiX2FkZF9zZXNzaW9uKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsIE5VTEwsIE5VTEwsCisJCSAgICAgICBQT0xJQ1lfUkVNRURJQVRJT04pOworCisJcG9saWN5ID0gYnVpbGRfcG9saWN5KGN0eCwgdXNlciwgcmVhbG0sIGRtYWNjKTsKKwlpZiAoIXBvbGljeSkgeworCQlyZXR1cm4gYnVpbGRfcG9zdF9kZXZfZGF0YV9yZXNwb25zZSgKKwkJCWN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCSJObyB1cGRhdGUgYXZhaWxhYmxlIGF0IHRoaXMgdGltZSIsIE5VTEwpOworCX0KKworCXN0YXR1cyA9ICJSZW1lZGlhdGlvbiBjb21wbGV0ZSwgcmVxdWVzdCBzcHBVcGRhdGVSZXNwb25zZSI7CisJc3BwX25vZGUgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgJm5zLCBzZXNzaW9uX2lkLCBzdGF0dXMsCisJCQkJCQlOVUxMKTsKKwlpZiAoc3BwX25vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlzbnByaW50ZihidWYsIHNpemVvZihidWYpLAorCQkgIi4vV2ktRmkvJXMvUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24vQ3JlZGVudGlhbDEvUG9saWN5IiwKKwkJIHJlYWxtKTsKKworCWlmIChhZGRfdXBkYXRlX25vZGUoY3R4LCBzcHBfbm9kZSwgbnMsIGJ1ZiwgcG9saWN5KSA8IDApIHsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgc3BwX25vZGUpOworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBwb2xpY3kpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwloczIwX2V2ZW50bG9nX25vZGUoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCSAgICJwb2xpY3kgdXBkYXRlIChzdWIgcmVtKSIsIHBvbGljeSk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcG9saWN5KTsKKworCXJldHVybiBzcHBfbm9kZTsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGJyb3dzZXJfcmVtZWRpYXRpb24oc3RydWN0IGhzMjBfc3ZjICpjdHgsCisJCQkJCWNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJCWNvbnN0IGNoYXIgKnJlZGlyZWN0X3VyaSwKKwkJCQkJY29uc3QgY2hhciAqdXJpKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqc3BwX25vZGUsICpleGVjX25vZGU7CisKKwlpZiAocmVkaXJlY3RfdXJpID09IE5VTEwpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiTWlzc2luZyByZWRpcmVjdFVSSSBhdHRyaWJ1dGUgZm9yIHVzZXIgIgorCQkJICAgICJyZW1lZGlhdGlvbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJZGVidWdfcHJpbnQoY3R4LCAxLCAicmVkaXJlY3RVUkkgJXMiLCByZWRpcmVjdF91cmkpOworCisJc3BwX25vZGUgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgJm5zLCBzZXNzaW9uX2lkLCAiT0siLAorCQlOVUxMKTsKKwlpZiAoc3BwX25vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlleGVjX25vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgImV4ZWMiKTsKKwl4bWxfbm9kZV9jcmVhdGVfdGV4dChjdHgtPnhtbCwgZXhlY19ub2RlLCBucywgImxhdW5jaEJyb3dzZXJUb1VSSSIsCisJCQkgICAgIHVyaSk7CisJcmV0dXJuIHNwcF9ub2RlOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogdXNlcl9yZW1lZGlhdGlvbihzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgY29uc3QgY2hhciAqdXNlciwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKnJlYWxtLCBjb25zdCBjaGFyICpzZXNzaW9uX2lkLAorCQkJCSAgICAgY29uc3QgY2hhciAqcmVkaXJlY3RfdXJpKQoreworCWNoYXIgdXJpWzMwMF0sICp2YWw7CisKKwloczIwX2V2ZW50bG9nKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCSAgICAgICJyZXF1aXJlcyB1c2VyIHJlbWVkaWF0aW9uIiwgTlVMTCk7CisJdmFsID0gZGJfZ2V0X29zdV9jb25maWdfdmFsKGN0eCwgcmVhbG0sICJyZW1lZGlhdGlvbl91cmwiKTsKKwlpZiAodmFsID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZGJfYWRkX3Nlc3Npb24oY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgTlVMTCwgcmVkaXJlY3RfdXJpLAorCQkgICAgICAgVVNFUl9SRU1FRElBVElPTik7CisKKwlzbnByaW50Zih1cmksIHNpemVvZih1cmkpLCAiJXMlcyIsIHZhbCwgc2Vzc2lvbl9pZCk7CisJb3NfZnJlZSh2YWwpOworCXJldHVybiBicm93c2VyX3JlbWVkaWF0aW9uKGN0eCwgc2Vzc2lvbl9pZCwgcmVkaXJlY3RfdXJpLCB1cmkpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogZnJlZV9yZW1lZGlhdGlvbihzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKnVzZXIsIGNvbnN0IGNoYXIgKnJlYWxtLAorCQkJCSAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKnJlZGlyZWN0X3VyaSkKK3sKKwljaGFyIHVyaVszMDBdLCAqdmFsOworCisJaHMyMF9ldmVudGxvZyhjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkgICAgICAicmVxdWlyZXMgZnJlZS9wdWJsaWMgYWNjb3VudCByZW1lZGlhdGlvbiIsIE5VTEwpOworCXZhbCA9IGRiX2dldF9vc3VfY29uZmlnX3ZhbChjdHgsIHJlYWxtLCAiZnJlZV9yZW1lZGlhdGlvbl91cmwiKTsKKwlpZiAodmFsID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZGJfYWRkX3Nlc3Npb24oY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgTlVMTCwgcmVkaXJlY3RfdXJpLAorCQkgICAgICAgRlJFRV9SRU1FRElBVElPTik7CisKKwlzbnByaW50Zih1cmksIHNpemVvZih1cmkpLCAiJXMlcyIsIHZhbCwgc2Vzc2lvbl9pZCk7CisJb3NfZnJlZSh2YWwpOworCXJldHVybiBicm93c2VyX3JlbWVkaWF0aW9uKGN0eCwgc2Vzc2lvbl9pZCwgcmVkaXJlY3RfdXJpLCB1cmkpOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogbm9fc3ViX3JlbShzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCSAgICAgICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCSAgICAgICBjb25zdCBjaGFyICpzZXNzaW9uX2lkKQoreworCWNvbnN0IGNoYXIgKnN0YXR1czsKKworCWhzMjBfZXZlbnRsb2coY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJICAgICAgIm5vIHN1YnNjcmlwdGlvbiBtZWRpYXRpb24gYXZhaWxhYmxlIiwgTlVMTCk7CisKKwlzdGF0dXMgPSAiTm8gdXBkYXRlIGF2YWlsYWJsZSBhdCB0aGlzIHRpbWUiOworCXJldHVybiBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwgc3RhdHVzLAorCQkJCQkgICAgTlVMTCk7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBoczIwX3N1YnNjcmlwdGlvbl9yZW1lZGlhdGlvbihzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkJCSAgY29uc3QgY2hhciAqdXNlciwKKwkJCQkJCSAgY29uc3QgY2hhciAqcmVhbG0sCisJCQkJCQkgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJCQkgIGludCBkbWFjYywKKwkJCQkJCSAgY29uc3QgY2hhciAqcmVkaXJlY3RfdXJpKQoreworCWNoYXIgKnR5cGUsICppZGVudGl0eTsKKwl4bWxfbm9kZV90ICpyZXQ7CisJY2hhciAqZnJlZV9hY2NvdW50OworCisJaWRlbnRpdHkgPSBkYl9nZXRfdmFsKGN0eCwgdXNlciwgcmVhbG0sICJpZGVudGl0eSIsIGRtYWNjKTsKKwlpZiAoaWRlbnRpdHkgPT0gTlVMTCB8fCBzdHJsZW4oaWRlbnRpdHkpID09IDApIHsKKwkJaHMyMF9ldmVudGxvZyhjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgICAgInVzZXIgbm90IGZvdW5kIGluIGRhdGFiYXNlIGZvciByZW1lZGlhdGlvbiIsCisJCQkgICAgICBOVUxMKTsKKwkJb3NfZnJlZShpZGVudGl0eSk7CisJCXJldHVybiBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCQkJCSAgICAiRXJyb3Igb2NjdXJyZWQiLAorCQkJCQkJICAgICJOb3QgZm91bmQiKTsKKwl9CisJb3NfZnJlZShpZGVudGl0eSk7CisKKwlmcmVlX2FjY291bnQgPSBkYl9nZXRfb3N1X2NvbmZpZ192YWwoY3R4LCByZWFsbSwgImZyZWVfYWNjb3VudCIpOworCWlmIChmcmVlX2FjY291bnQgJiYgc3RyY21wKGZyZWVfYWNjb3VudCwgdXNlcikgPT0gMCkgeworCQlmcmVlKGZyZWVfYWNjb3VudCk7CisJCXJldHVybiBub19zdWJfcmVtKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQpOworCX0KKwlmcmVlKGZyZWVfYWNjb3VudCk7CisKKwl0eXBlID0gZGJfZ2V0X3ZhbChjdHgsIHVzZXIsIHJlYWxtLCAicmVtZWRpYXRpb24iLCBkbWFjYyk7CisJaWYgKHR5cGUgJiYgc3RyY21wKHR5cGUsICJmcmVlIikgIT0gMCkgeworCQljaGFyICp2YWw7CisJCWludCBzaGFyZWQgPSAwOworCQl2YWwgPSBkYl9nZXRfdmFsKGN0eCwgdXNlciwgcmVhbG0sICJzaGFyZWQiLCBkbWFjYyk7CisJCWlmICh2YWwpCisJCQlzaGFyZWQgPSBhdG9pKHZhbCk7CisJCWZyZWUodmFsKTsKKwkJaWYgKHNoYXJlZCkgeworCQkJZnJlZSh0eXBlKTsKKwkJCXJldHVybiBub19zdWJfcmVtKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQpOworCQl9CisJfQorCWlmICh0eXBlICYmIHN0cmNtcCh0eXBlLCAidXNlciIpID09IDApCisJCXJldCA9IHVzZXJfcmVtZWRpYXRpb24oY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAgICAgcmVkaXJlY3RfdXJpKTsKKwllbHNlIGlmICh0eXBlICYmIHN0cmNtcCh0eXBlLCAiZnJlZSIpID09IDApCisJCXJldCA9IGZyZWVfcmVtZWRpYXRpb24oY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAgICAgcmVkaXJlY3RfdXJpKTsKKwllbHNlIGlmICh0eXBlICYmIHN0cmNtcCh0eXBlLCAicG9saWN5IikgPT0gMCkKKwkJcmV0ID0gcG9saWN5X3JlbWVkaWF0aW9uKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsIGRtYWNjKTsKKwllbHNlCisJCXJldCA9IG1hY2hpbmVfcmVtZWRpYXRpb24oY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgZG1hY2MpOworCWZyZWUodHlwZSk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogYnVpbGRfcG9saWN5KHN0cnVjdCBoczIwX3N2YyAqY3R4LCBjb25zdCBjaGFyICp1c2VyLAorCQkJCSBjb25zdCBjaGFyICpyZWFsbSwgaW50IHVzZV9kbWFjYykKK3sKKwljaGFyICpwb2xpY3lfaWQ7CisJY2hhciBmbmFtZVsyMDBdOworCXhtbF9ub2RlX3QgKnBvbGljeSwgKm5vZGU7CisKKwlwb2xpY3lfaWQgPSBkYl9nZXRfdmFsKGN0eCwgdXNlciwgcmVhbG0sICJwb2xpY3kiLCB1c2VfZG1hY2MpOworCWlmIChwb2xpY3lfaWQgPT0gTlVMTCB8fCBzdHJsZW4ocG9saWN5X2lkKSA9PSAwKSB7CisJCWZyZWUocG9saWN5X2lkKTsKKwkJcG9saWN5X2lkID0gc3RyZHVwKCJkZWZhdWx0Iik7CisJCWlmIChwb2xpY3lfaWQgPT0gTlVMTCkKKwkJCXJldHVybiBOVUxMOworCX0KKworCXNucHJpbnRmKGZuYW1lLCBzaXplb2YoZm5hbWUpLCAiJXMvc3BwL3BvbGljeS8lcy54bWwiLAorCQkgY3R4LT5yb290X2RpciwgcG9saWN5X2lkKTsKKwlmcmVlKHBvbGljeV9pZCk7CisJZGVidWdfcHJpbnQoY3R4LCAxLCAiVXNlIHBvbGljeSBmaWxlICVzIiwgZm5hbWUpOworCisJcG9saWN5ID0gbm9kZV9mcm9tX2ZpbGUoY3R4LT54bWwsIGZuYW1lKTsKKwlpZiAocG9saWN5ID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJbm9kZSA9IGdldF9ub2RlX3VyaShjdHgtPnhtbCwgcG9saWN5LCAiUG9saWN5L1BvbGljeVVwZGF0ZS9VUkkiKTsKKwlpZiAobm9kZSkgeworCQljaGFyICp1cmw7CisJCXVybCA9IGRiX2dldF9vc3VfY29uZmlnX3ZhbChjdHgsIHJlYWxtLCAicG9saWN5X3VybCIpOworCQlpZiAodXJsID09IE5VTEwpIHsKKwkJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBvbGljeSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQl4bWxfbm9kZV9zZXRfdGV4dChjdHgtPnhtbCwgbm9kZSwgdXJsKTsKKwkJZnJlZSh1cmwpOworCX0KKworCW5vZGUgPSBnZXRfbm9kZV91cmkoY3R4LT54bWwsIHBvbGljeSwgIlBvbGljeS9Qb2xpY3lVcGRhdGUiKTsKKwlpZiAobm9kZSAmJiB1c2VfZG1hY2MpIHsKKwkJY2hhciAqcHc7CisJCXB3ID0gZGJfZ2V0X3ZhbChjdHgsIHVzZXIsIHJlYWxtLCAib3N1X3Bhc3N3b3JkIiwgdXNlX2RtYWNjKTsKKwkJaWYgKHB3ID09IE5VTEwgfHwKKwkJICAgIGJ1aWxkX3VzZXJuYW1lX3Bhc3N3b3JkKGN0eCwgbm9kZSwgdXNlciwgcHcpID09IE5VTEwpIHsKKwkJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkZhaWxlZCB0byBhZGQgUG9saWN5L1BvbGljeVVwZGF0ZS8iCisJCQkJICAgICJVc2VybmFtZVBhc3N3b3JkIik7CisJCQlmcmVlKHB3KTsKKwkJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHBvbGljeSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlmcmVlKHB3KTsKKwl9CisKKwlyZXR1cm4gcG9saWN5OworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogaHMyMF9wb2xpY3lfdXBkYXRlKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCSAgICAgICBjb25zdCBjaGFyICp1c2VyLCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCQkgICAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwgaW50IGRtYWNjKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqc3BwX25vZGU7CisJeG1sX25vZGVfdCAqcG9saWN5OworCWNoYXIgYnVmWzQwMF07CisJY29uc3QgY2hhciAqc3RhdHVzOworCWNoYXIgKmlkZW50aXR5OworCisJaWRlbnRpdHkgPSBkYl9nZXRfdmFsKGN0eCwgdXNlciwgcmVhbG0sICJpZGVudGl0eSIsIGRtYWNjKTsKKwlpZiAoaWRlbnRpdHkgPT0gTlVMTCB8fCBzdHJsZW4oaWRlbnRpdHkpID09IDApIHsKKwkJaHMyMF9ldmVudGxvZyhjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgICAgInVzZXIgbm90IGZvdW5kIGluIGRhdGFiYXNlIGZvciBwb2xpY3kgdXBkYXRlIiwKKwkJCSAgICAgIE5VTEwpOworCQlvc19mcmVlKGlkZW50aXR5KTsKKwkJcmV0dXJuIGJ1aWxkX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2UoY3R4LCBOVUxMLCBzZXNzaW9uX2lkLAorCQkJCQkJICAgICJFcnJvciBvY2N1cnJlZCIsCisJCQkJCQkgICAgIk5vdCBmb3VuZCIpOworCX0KKwlvc19mcmVlKGlkZW50aXR5KTsKKworCXBvbGljeSA9IGJ1aWxkX3BvbGljeShjdHgsIHVzZXIsIHJlYWxtLCBkbWFjYyk7CisJaWYgKCFwb2xpY3kpIHsKKwkJcmV0dXJuIGJ1aWxkX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2UoCisJCQljdHgsIE5VTEwsIHNlc3Npb25faWQsCisJCQkiTm8gdXBkYXRlIGF2YWlsYWJsZSBhdCB0aGlzIHRpbWUiLCBOVUxMKTsKKwl9CisKKwlkYl9hZGRfc2Vzc2lvbihjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLCBOVUxMLCBOVUxMLCBQT0xJQ1lfVVBEQVRFKTsKKworCXN0YXR1cyA9ICJVcGRhdGUgY29tcGxldGUsIHJlcXVlc3Qgc3BwVXBkYXRlUmVzcG9uc2UiOworCXNwcF9ub2RlID0gYnVpbGRfcG9zdF9kZXZfZGF0YV9yZXNwb25zZShjdHgsICZucywgc2Vzc2lvbl9pZCwgc3RhdHVzLAorCQkJCQkJTlVMTCk7CisJaWYgKHNwcF9ub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwKKwkJICIuL1dpLUZpLyVzL1BlclByb3ZpZGVyU3Vic2NyaXB0aW9uL0NyZWRlbnRpYWwxL1BvbGljeSIsCisJCSByZWFsbSk7CisKKwlpZiAoYWRkX3VwZGF0ZV9ub2RlKGN0eCwgc3BwX25vZGUsIG5zLCBidWYsIHBvbGljeSkgPCAwKSB7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHNwcF9ub2RlKTsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcG9saWN5KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsICJwb2xpY3kgdXBkYXRlIiwKKwkJCSAgIHBvbGljeSk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcG9saWN5KTsKKworCXJldHVybiBzcHBfbm9kZTsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIHNwcF9nZXRfbW8oc3RydWN0IGhzMjBfc3ZjICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCQkgICAgICAgY29uc3QgY2hhciAqdXJuLCBpbnQgKnZhbGlkLCBjaGFyICoqcmV0X2VycikKK3sKKwl4bWxfbm9kZV90ICpjaGlsZCwgKnRuZHMsICptbzsKKwljb25zdCBjaGFyICpuYW1lOworCWNoYXIgKm1vX3VybjsKKwljaGFyICpzdHI7CisJY2hhciBmbmFtZVsyMDBdOworCisJKnZhbGlkID0gLTE7CisJaWYgKHJldF9lcnIpCisJCSpyZXRfZXJyID0gTlVMTDsKKworCXhtbF9ub2RlX2Zvcl9lYWNoX2NoaWxkKGN0eC0+eG1sLCBjaGlsZCwgbm9kZSkgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgtPnhtbCwgY2hpbGQpOworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgY2hpbGQpOworCQlpZiAoc3RyY21wKG5hbWUsICJtb0NvbnRhaW5lciIpICE9IDApCisJCQljb250aW51ZTsKKwkJbW9fdXJuID0geG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfbnMoY3R4LT54bWwsIGNoaWxkLCBTUFBfTlNfVVJJLAorCQkJCQkJICAgICJtb1VSTiIpOworCQlpZiAoc3RyY2FzZWNtcCh1cm4sIG1vX3VybikgPT0gMCkgeworCQkJeG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfZnJlZShjdHgtPnhtbCwgbW9fdXJuKTsKKwkJCWJyZWFrOworCQl9CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIG1vX3Vybik7CisJfQorCisJaWYgKGNoaWxkID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZGVidWdfcHJpbnQoY3R4LCAxLCAibW9Db250YWluZXIgdGV4dCBmb3IgJXMiLCB1cm4pOworCWRlYnVnX2R1bXBfbm9kZShjdHgsICJtb0NvbnRhaW5lciIsIGNoaWxkKTsKKworCXN0ciA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eC0+eG1sLCBjaGlsZCk7CisJZGVidWdfcHJpbnQoY3R4LCAxLCAibW9Db250YWluZXIgcGF5bG9hZDogJyVzJyIsIHN0cik7CisJdG5kcyA9IHhtbF9ub2RlX2Zyb21fYnVmKGN0eC0+eG1sLCBzdHIpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LT54bWwsIHN0cik7CisJaWYgKHRuZHMgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJjb3VsZCBub3QgcGFyc2UgbW9Db250YWluZXIgdGV4dCIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlzbnByaW50ZihmbmFtZSwgc2l6ZW9mKGZuYW1lKSwgIiVzL3NwcC9kbV9kZGYtdjFfMi5kdGQiLCBjdHgtPnJvb3RfZGlyKTsKKwlpZiAoeG1sX3ZhbGlkYXRlX2R0ZChjdHgtPnhtbCwgdG5kcywgZm5hbWUsIHJldF9lcnIpID09IDApCisJCSp2YWxpZCA9IDE7CisJZWxzZSBpZiAocmV0X2VyciAmJiAqcmV0X2VyciAmJgorCQkgb3Nfc3RyY21wKCpyZXRfZXJyLCAiTm8gZGVjbGFyYXRpb24gZm9yIGF0dHJpYnV0ZSB4bWxucyBvZiBlbGVtZW50IE1nbXRUcmVlXG4iKSA9PSAwKSB7CisJCWZyZWUoKnJldF9lcnIpOworCQlkZWJ1Z19wcmludChjdHgsIDEsICJJZ25vcmUgT01BLURNIERERiBEVEQgdmFsaWRhdGlvbiBlcnJvciBmb3IgTWdtdFRyZWUgbmFtZXNwYWNlIGRlY2xhcmF0aW9uIHdpdGggeG1sbnMgYXR0cmlidXRlIik7CisJCSpyZXRfZXJyID0gTlVMTDsKKwkJKnZhbGlkID0gMTsKKwl9IGVsc2UKKwkJKnZhbGlkID0gMDsKKworCW1vID0gdG5kc190b19tbyhjdHgtPnhtbCwgdG5kcyk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgdG5kcyk7CisJaWYgKG1vID09IE5VTEwpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiaW52YWxpZCBtb0NvbnRhaW5lciBmb3IgJXMiLCB1cm4pOworCX0KKworCXJldHVybiBtbzsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIHNwcF9leGVjX3VwbG9hZF9tbyhzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkgICAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwgY29uc3QgY2hhciAqdXJuKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqc3BwX25vZGUsICpub2RlLCAqZXhlY19ub2RlOworCisJc3BwX25vZGUgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgJm5zLCBzZXNzaW9uX2lkLCAiT0siLAorCQkJCQkJTlVMTCk7CisJaWYgKHNwcF9ub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZXhlY19ub2RlID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBzcHBfbm9kZSwgbnMsICJleGVjIik7CisKKwlub2RlID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBleGVjX25vZGUsIG5zLCAidXBsb2FkTU8iKTsKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgbm9kZSwgbnMsICJtb1VSTiIsIHVybik7CisKKwlyZXR1cm4gc3BwX25vZGU7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBoczIwX3N1YnNjcmlwdGlvbl9yZWdpc3RyYXRpb24oc3RydWN0IGhzMjBfc3ZjICpjdHgsCisJCQkJCQkgICBjb25zdCBjaGFyICpyZWFsbSwKKwkJCQkJCSAgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJCQkgICBjb25zdCBjaGFyICpyZWRpcmVjdF91cmkpCit7CisJeG1sX25hbWVzcGFjZV90ICpuczsKKwl4bWxfbm9kZV90ICpzcHBfbm9kZSwgKmV4ZWNfbm9kZTsKKwljaGFyIHVyaVszMDBdLCAqdmFsOworCisJaWYgKGRiX2FkZF9zZXNzaW9uKGN0eCwgTlVMTCwgcmVhbG0sIHNlc3Npb25faWQsIE5VTEwsIHJlZGlyZWN0X3VyaSwKKwkJCSAgIFNVQlNDUklQVElPTl9SRUdJU1RSQVRJT04pIDwgMCkKKwkJcmV0dXJuIE5VTEw7CisJdmFsID0gZGJfZ2V0X29zdV9jb25maWdfdmFsKGN0eCwgcmVhbG0sICJzaWdudXBfdXJsIik7CisJaWYgKHZhbCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXNwcF9ub2RlID0gYnVpbGRfcG9zdF9kZXZfZGF0YV9yZXNwb25zZShjdHgsICZucywgc2Vzc2lvbl9pZCwgIk9LIiwKKwkJCQkJCU5VTEwpOworCWlmIChzcHBfbm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWV4ZWNfbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgc3BwX25vZGUsIG5zLCAiZXhlYyIpOworCisJc25wcmludGYodXJpLCBzaXplb2YodXJpKSwgIiVzJXMiLCB2YWwsIHNlc3Npb25faWQpOworCW9zX2ZyZWUodmFsKTsKKwl4bWxfbm9kZV9jcmVhdGVfdGV4dChjdHgtPnhtbCwgZXhlY19ub2RlLCBucywgImxhdW5jaEJyb3dzZXJUb1VSSSIsCisJCQkgICAgIHVyaSk7CisJcmV0dXJuIHNwcF9ub2RlOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogaHMyMF91c2VyX2lucHV0X3JlbWVkaWF0aW9uKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCQkJY29uc3QgY2hhciAqdXNlciwKKwkJCQkJCWNvbnN0IGNoYXIgKnJlYWxtLCBpbnQgZG1hY2MsCisJCQkJCQljb25zdCBjaGFyICpzZXNzaW9uX2lkKQoreworCXJldHVybiBidWlsZF9zdWJfcmVtX3Jlc3AoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgMCwgZG1hY2MpOworfQorCisKK3N0YXRpYyBjaGFyICogZGJfZ2V0X29zdV9jb25maWdfdmFsKHN0cnVjdCBoczIwX3N2YyAqY3R4LCBjb25zdCBjaGFyICpyZWFsbSwKKwkJCQkgICAgY29uc3QgY2hhciAqZmllbGQpCit7CisJY2hhciAqY21kOworCXN0cnVjdCBnZXRfZGJfZmllbGRfZGF0YSBkYXRhOworCisJY21kID0gc3FsaXRlM19tcHJpbnRmKCJTRUxFQ1QgdmFsdWUgRlJPTSBvc3VfY29uZmlnIFdIRVJFIHJlYWxtPSVRIEFORCAiCisJCQkgICAgICAiZmllbGQ9JVEiLCByZWFsbSwgZmllbGQpOworCWlmIChjbWQgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJZGVidWdfcHJpbnQoY3R4LCAxLCAiREI6ICVzIiwgY21kKTsKKwltZW1zZXQoJmRhdGEsIDAsIHNpemVvZihkYXRhKSk7CisJZGF0YS5maWVsZCA9ICJ2YWx1ZSI7CisJaWYgKHNxbGl0ZTNfZXhlYyhjdHgtPmRiLCBjbWQsIGdldF9kYl9maWVsZCwgJmRhdGEsIE5VTEwpICE9IFNRTElURV9PSykKKwl7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkRCOiBDb3VsZCBub3QgZmluZCBvc3VfY29uZmlnICVzOiAlcyIsCisJCQkgICAgcmVhbG0sIHNxbGl0ZTNfZXJybXNnKGN0eC0+ZGIpKTsKKwkJc3FsaXRlM19mcmVlKGNtZCk7CisJCXJldHVybiBOVUxMOworCX0KKwlzcWxpdGUzX2ZyZWUoY21kKTsKKworCWRlYnVnX3ByaW50KGN0eCwgMSwgIkRCOiByZXR1cm4gJyVzJyIsIGRhdGEudmFsdWUpOworCXJldHVybiBkYXRhLnZhbHVlOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogYnVpbGRfcHBzKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJICAgICAgY29uc3QgY2hhciAqdXNlciwgY29uc3QgY2hhciAqcmVhbG0sCisJCQkgICAgICBjb25zdCBjaGFyICpwdywgY29uc3QgY2hhciAqY2VydCwKKwkJCSAgICAgIGludCBtYWNoaW5lX21hbmFnZWQpCit7CisJeG1sX25vZGVfdCAqcHBzLCAqYywgKnRydXN0LCAqYWFhLCAqYWFhMSwgKnVwZCwgKmhvbWVzcDsKKwl4bWxfbm9kZV90ICpjcmVkLCAqZWFwLCAqdXNlcnB3OworCisJcHBzID0geG1sX25vZGVfY3JlYXRlX3Jvb3QoY3R4LT54bWwsIE5VTEwsIE5VTEwsIE5VTEwsCisJCQkJICAgIlBlclByb3ZpZGVyU3Vic2NyaXB0aW9uIik7CisJaWYgKHBwcyA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWFkZF90ZXh0X25vZGUoY3R4LCBwcHMsICJVcGRhdGVJZGVudGlmaWVyIiwgIjEiKTsKKworCWMgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHBwcywgTlVMTCwgIkNyZWRlbnRpYWwxIik7CisKKwlhZGRfdGV4dF9ub2RlKGN0eCwgYywgIkNyZWRlbnRpYWxQcmlvcml0eSIsICIxIik7CisKKwlhYWEgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIGMsIE5VTEwsICJBQUFTZXJ2ZXJUcnVzdFJvb3QiKTsKKwlhYWExID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCBhYWEsIE5VTEwsICJBQUExIik7CisJYWRkX3RleHRfbm9kZV9jb25mKGN0eCwgcmVhbG0sIGFhYTEsICJDZXJ0VVJMIiwKKwkJCSAgICJhYWFfdHJ1c3Rfcm9vdF9jZXJ0X3VybCIpOworCWFkZF90ZXh0X25vZGVfY29uZihjdHgsIHJlYWxtLCBhYWExLCAiQ2VydFNIQTI1NkZpbmdlcnByaW50IiwKKwkJCSAgICJhYWFfdHJ1c3Rfcm9vdF9jZXJ0X2ZpbmdlcnByaW50Iik7CisKKwl1cGQgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIGMsIE5VTEwsICJTdWJzY3JpcHRpb25VcGRhdGUiKTsKKwlhZGRfdGV4dF9ub2RlKGN0eCwgdXBkLCAiVXBkYXRlSW50ZXJ2YWwiLCAiNDI5NDk2NzI5NSIpOworCWFkZF90ZXh0X25vZGUoY3R4LCB1cGQsICJVcGRhdGVNZXRob2QiLCAiQ2xpZW50SW5pdGlhdGVkIik7CisJYWRkX3RleHRfbm9kZShjdHgsIHVwZCwgIlJlc3RyaWN0aW9uIiwgIkhvbWVTUCIpOworCWFkZF90ZXh0X25vZGVfY29uZihjdHgsIHJlYWxtLCB1cGQsICJVUkkiLCAic3BwX2h0dHBfYXV0aF91cmwiKTsKKwl0cnVzdCA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgdXBkLCBOVUxMLCAiVHJ1c3RSb290Iik7CisJYWRkX3RleHRfbm9kZV9jb25mKGN0eCwgcmVhbG0sIHRydXN0LCAiQ2VydFVSTCIsICJ0cnVzdF9yb290X2NlcnRfdXJsIik7CisJYWRkX3RleHRfbm9kZV9jb25mKGN0eCwgcmVhbG0sIHRydXN0LCAiQ2VydFNIQTI1NkZpbmdlcnByaW50IiwKKwkJCSAgICJ0cnVzdF9yb290X2NlcnRfZmluZ2VycHJpbnQiKTsKKworCWhvbWVzcCA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgYywgTlVMTCwgIkhvbWVTUCIpOworCWFkZF90ZXh0X25vZGVfY29uZihjdHgsIHJlYWxtLCBob21lc3AsICJGcmllbmRseU5hbWUiLCAiZnJpZW5kbHlfbmFtZSIpOworCWFkZF90ZXh0X25vZGVfY29uZihjdHgsIHJlYWxtLCBob21lc3AsICJGUUROIiwgImZxZG4iKTsKKworCXhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgYywgTlVMTCwgIlN1YnNjcmlwdGlvblBhcmFtZXRlcnMiKTsKKworCWNyZWQgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIGMsIE5VTEwsICJDcmVkZW50aWFsIik7CisJYWRkX2NyZWF0aW9uX2RhdGUoY3R4LCBjcmVkKTsKKwlpZiAoY2VydCkgeworCQl4bWxfbm9kZV90ICpkYzsKKwkJZGMgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIGNyZWQsIE5VTEwsCisJCQkJICAgICAiRGlnaXRhbENlcnRpZmljYXRlIik7CisJCWFkZF90ZXh0X25vZGUoY3R4LCBkYywgIkNlcnRpZmljYXRlVHlwZSIsICJ4NTA5djMiKTsKKwkJYWRkX3RleHRfbm9kZShjdHgsIGRjLCAiQ2VydFNIQTI1NkZpbmdlcnByaW50IiwgY2VydCk7CisJfSBlbHNlIHsKKwkJdXNlcnB3ID0gYnVpbGRfdXNlcm5hbWVfcGFzc3dvcmQoY3R4LCBjcmVkLCB1c2VyLCBwdyk7CisJCWFkZF90ZXh0X25vZGUoY3R4LCB1c2VycHcsICJNYWNoaW5lTWFuYWdlZCIsCisJCQkgICAgICBtYWNoaW5lX21hbmFnZWQgPyAiVFJVRSIgOiAiRkFMU0UiKTsKKwkJZWFwID0geG1sX25vZGVfY3JlYXRlKGN0eC0+eG1sLCB1c2VycHcsIE5VTEwsICJFQVBNZXRob2QiKTsKKwkJYWRkX3RleHRfbm9kZShjdHgsIGVhcCwgIkVBUFR5cGUiLCAiMjEiKTsKKwkJYWRkX3RleHRfbm9kZShjdHgsIGVhcCwgIklubmVyTWV0aG9kIiwgIk1TLUNIQVAtVjIiKTsKKwl9CisJYWRkX3RleHRfbm9kZShjdHgsIGNyZWQsICJSZWFsbSIsIHJlYWxtKTsKKworCXJldHVybiBwcHM7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBzcHBfZXhlY19nZXRfY2VydGlmaWNhdGUoc3RydWN0IGhzMjBfc3ZjICpjdHgsCisJCQkJCSAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwKKwkJCQkJICAgICBjb25zdCBjaGFyICp1c2VyLAorCQkJCQkgICAgIGNvbnN0IGNoYXIgKnJlYWxtKQoreworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisJeG1sX25vZGVfdCAqc3BwX25vZGUsICplbnJvbGwsICpleGVjX25vZGU7CisJY2hhciAqdmFsOworCWNoYXIgcGFzc3dvcmRbMTFdOworCWNoYXIgKmI2NDsKKworCWlmIChuZXdfcGFzc3dvcmQocGFzc3dvcmQsIHNpemVvZihwYXNzd29yZCkpIDwgMCkKKwkJcmV0dXJuIE5VTEw7CisKKwlzcHBfbm9kZSA9IGJ1aWxkX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2UoY3R4LCAmbnMsIHNlc3Npb25faWQsICJPSyIsCisJCQkJCQlOVUxMKTsKKwlpZiAoc3BwX25vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlleGVjX25vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgImV4ZWMiKTsKKworCWVucm9sbCA9IHhtbF9ub2RlX2NyZWF0ZShjdHgtPnhtbCwgZXhlY19ub2RlLCBucywgImdldENlcnRpZmljYXRlIik7CisJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIGVucm9sbCwgTlVMTCwgImVucm9sbG1lbnRQcm90b2NvbCIsICJFU1QiKTsKKworCXZhbCA9IGRiX2dldF9vc3VfY29uZmlnX3ZhbChjdHgsIHJlYWxtLCAiZXN0X3VybCIpOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eC0+eG1sLCBlbnJvbGwsIG5zLCAiZW5yb2xsbWVudFNlcnZlclVSSSIsCisJCQkgICAgIHZhbCA/IHZhbCA6ICIiKTsKKwlvc19mcmVlKHZhbCk7CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIGVucm9sbCwgbnMsICJlc3RVc2VySUQiLCB1c2VyKTsKKworCWI2NCA9IChjaGFyICopIGJhc2U2NF9lbmNvZGUoKHVuc2lnbmVkIGNoYXIgKikgcGFzc3dvcmQsCisJCQkJICAgICBzdHJsZW4ocGFzc3dvcmQpLCBOVUxMKTsKKwlpZiAoYjY0ID09IE5VTEwpIHsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgc3BwX25vZGUpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIGVucm9sbCwgbnMsICJlc3RQYXNzd29yZCIsIGI2NCk7CisJZnJlZShiNjQpOworCisJZGJfdXBkYXRlX3Nlc3Npb25fcGFzc3dvcmQoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgcGFzc3dvcmQpOworCisJcmV0dXJuIHNwcF9ub2RlOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogaHMyMF91c2VyX2lucHV0X3JlZ2lzdHJhdGlvbihzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkJCSBjb25zdCBjaGFyICpzZXNzaW9uX2lkLAorCQkJCQkJIGludCBlbnJvbGxtZW50X2RvbmUpCit7CisJeG1sX25hbWVzcGFjZV90ICpuczsKKwl4bWxfbm9kZV90ICpzcHBfbm9kZSwgKm5vZGUgPSBOVUxMOworCXhtbF9ub2RlX3QgKnBwcywgKnRuZHM7CisJY2hhciBidWZbNDAwXTsKKwljaGFyICpzdHI7CisJY2hhciAqdXNlciwgKnJlYWxtLCAqcHcsICp0eXBlLCAqbW07CisJY29uc3QgY2hhciAqc3RhdHVzOworCWludCBjZXJ0ID0gMDsKKwlpbnQgbWFjaGluZV9tYW5hZ2VkID0gMDsKKwljaGFyICpmaW5nZXJwcmludDsKKworCXVzZXIgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCBOVUxMLCBOVUxMLCBzZXNzaW9uX2lkLCAidXNlciIpOworCXJlYWxtID0gZGJfZ2V0X3Nlc3Npb25fdmFsKGN0eCwgTlVMTCwgTlVMTCwgc2Vzc2lvbl9pZCwgInJlYWxtIik7CisJcHcgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCBOVUxMLCBOVUxMLCBzZXNzaW9uX2lkLCAicGFzc3dvcmQiKTsKKworCWlmICghdXNlciB8fCAhcmVhbG0gfHwgIXB3KSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkNvdWxkIG5vdCBmaW5kIHNlc3Npb24gaW5mbyBmcm9tIERCIGZvciAiCisJCQkgICAgInRoZSBuZXcgc3Vic2NyaXB0aW9uIik7CisJCWZyZWUodXNlcik7CisJCWZyZWUocmVhbG0pOworCQlmcmVlKHB3KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJbW0gPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCBOVUxMLCBOVUxMLCBzZXNzaW9uX2lkLCAibWFjaGluZV9tYW5hZ2VkIik7CisJaWYgKG1tICYmIGF0b2kobW0pKQorCQltYWNoaW5lX21hbmFnZWQgPSAxOworCWZyZWUobW0pOworCisJdHlwZSA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIE5VTEwsIE5VTEwsIHNlc3Npb25faWQsICJ0eXBlIik7CisJaWYgKHR5cGUgJiYgc3RyY21wKHR5cGUsICJjZXJ0IikgPT0gMCkKKwkJY2VydCA9IDE7CisJZnJlZSh0eXBlKTsKKworCWlmIChjZXJ0ICYmICFlbnJvbGxtZW50X2RvbmUpIHsKKwkJeG1sX25vZGVfdCAqcmV0OworCQloczIwX2V2ZW50bG9nKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkgICAgICAicmVxdWVzdCBjbGllbnQgY2VydGlmaWNhdGUgZW5yb2xsbWVudCIsIE5VTEwpOworCQlyZXQgPSBzcHBfZXhlY19nZXRfY2VydGlmaWNhdGUoY3R4LCBzZXNzaW9uX2lkLCB1c2VyLCByZWFsbSk7CisJCWZyZWUodXNlcik7CisJCWZyZWUocmVhbG0pOworCQlmcmVlKHB3KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlpZiAoIWNlcnQgJiYgc3RybGVuKHB3KSA9PSAwKSB7CisJCW1hY2hpbmVfbWFuYWdlZCA9IDE7CisJCWZyZWUocHcpOworCQlwdyA9IG1hbGxvYygxMSk7CisJCWlmIChwdyA9PSBOVUxMIHx8IG5ld19wYXNzd29yZChwdywgMTEpIDwgMCkgeworCQkJZnJlZSh1c2VyKTsKKwkJCWZyZWUocmVhbG0pOworCQkJZnJlZShwdyk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCX0KKworCXN0YXR1cyA9ICJQcm92aXNpb25pbmcgY29tcGxldGUsIHJlcXVlc3Qgc3BwVXBkYXRlUmVzcG9uc2UiOworCXNwcF9ub2RlID0gYnVpbGRfcG9zdF9kZXZfZGF0YV9yZXNwb25zZShjdHgsICZucywgc2Vzc2lvbl9pZCwgc3RhdHVzLAorCQkJCQkJTlVMTCk7CisJaWYgKHNwcF9ub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZmluZ2VycHJpbnQgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCBOVUxMLCBOVUxMLCBzZXNzaW9uX2lkLCAiY2VydCIpOworCXBwcyA9IGJ1aWxkX3BwcyhjdHgsIHVzZXIsIHJlYWxtLCBwdywKKwkJCWZpbmdlcnByaW50ID8gZmluZ2VycHJpbnQgOiBOVUxMLCBtYWNoaW5lX21hbmFnZWQpOworCWZyZWUoZmluZ2VycHJpbnQpOworCWlmICghcHBzKSB7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHNwcF9ub2RlKTsKKwkJZnJlZSh1c2VyKTsKKwkJZnJlZShyZWFsbSk7CisJCWZyZWUocHcpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlkZWJ1Z19wcmludChjdHgsIDEsICJSZXF1ZXN0IERCIHN1YnNjcmlwdGlvbiByZWdpc3RyYXRpb24gb24gc3VjY2VzcyAiCisJCSAgICAibm90aWZpY2F0aW9uIik7CisJZGJfYWRkX3Nlc3Npb25fcHBzKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsIHBwcyk7CisKKwloczIwX2V2ZW50bG9nX25vZGUoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCSAgICJuZXcgc3Vic2NyaXB0aW9uIiwgcHBzKTsKKwlmcmVlKHVzZXIpOworCWZyZWUocHcpOworCisJdG5kcyA9IG1vX3RvX3RuZHMoY3R4LT54bWwsIHBwcywgMCwgVVJOX0hTMjBfUFBTLCBOVUxMKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBwcHMpOworCWlmICghdG5kcykgeworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBzcHBfbm9kZSk7CisJCWZyZWUocmVhbG0pOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlzdHIgPSB4bWxfbm9kZV90b19zdHIoY3R4LT54bWwsIHRuZHMpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIHRuZHMpOworCWlmIChzdHIgPT0gTlVMTCkgeworCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBzcHBfbm9kZSk7CisJCWZyZWUocmVhbG0pOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlub2RlID0geG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgImFkZE1PIiwgc3RyKTsKKwlmcmVlKHN0cik7CisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIi4vV2ktRmkvJXMvUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24iLCByZWFsbSk7CisJZnJlZShyZWFsbSk7CisJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIG5vZGUsIG5zLCAibWFuYWdlbWVudFRyZWVVUkkiLCBidWYpOworCXhtbF9ub2RlX2FkZF9hdHRyKGN0eC0+eG1sLCBub2RlLCBucywgIm1vVVJOIiwgVVJOX0hTMjBfUFBTKTsKKworCXJldHVybiBzcHBfbm9kZTsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGhzMjBfdXNlcl9pbnB1dF9mcmVlX3JlbWVkaWF0aW9uKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCQkJICAgICBjb25zdCBjaGFyICp1c2VyLAorCQkJCQkJICAgICBjb25zdCBjaGFyICpyZWFsbSwKKwkJCQkJCSAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCkKK3sKKwl4bWxfbmFtZXNwYWNlX3QgKm5zOworCXhtbF9ub2RlX3QgKnNwcF9ub2RlOworCXhtbF9ub2RlX3QgKmNyZWQ7CisJY2hhciBidWZbNDAwXTsKKwljaGFyICpzdGF0dXM7CisJY2hhciAqZnJlZV9hY2NvdW50LCAqcHc7CisKKwlmcmVlX2FjY291bnQgPSBkYl9nZXRfb3N1X2NvbmZpZ192YWwoY3R4LCByZWFsbSwgImZyZWVfYWNjb3VudCIpOworCWlmIChmcmVlX2FjY291bnQgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJcHcgPSBkYl9nZXRfdmFsKGN0eCwgZnJlZV9hY2NvdW50LCByZWFsbSwgInBhc3N3b3JkIiwgMCk7CisJaWYgKHB3ID09IE5VTEwpIHsKKwkJZnJlZShmcmVlX2FjY291bnQpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwljcmVkID0gYnVpbGRfY3JlZGVudGlhbF9wdyhjdHgsIGZyZWVfYWNjb3VudCwgcmVhbG0sIHB3KTsKKwlmcmVlKGZyZWVfYWNjb3VudCk7CisJZnJlZShwdyk7CisJaWYgKCFjcmVkKSB7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIGNyZWQpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlzdGF0dXMgPSAiUmVtZWRpYXRpb24gY29tcGxldGUsIHJlcXVlc3Qgc3BwVXBkYXRlUmVzcG9uc2UiOworCXNwcF9ub2RlID0gYnVpbGRfcG9zdF9kZXZfZGF0YV9yZXNwb25zZShjdHgsICZucywgc2Vzc2lvbl9pZCwgc3RhdHVzLAorCQkJCQkJTlVMTCk7CisJaWYgKHNwcF9ub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwKKwkJICIuL1dpLUZpLyVzL1BlclByb3ZpZGVyU3Vic2NyaXB0aW9uL0NyZWRlbnRpYWwxL0NyZWRlbnRpYWwiLAorCQkgcmVhbG0pOworCisJaWYgKGFkZF91cGRhdGVfbm9kZShjdHgsIHNwcF9ub2RlLCBucywgYnVmLCBjcmVkKSA8IDApIHsKKwkJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgc3BwX25vZGUpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwloczIwX2V2ZW50bG9nX25vZGUoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCSAgICJmcmVlL3B1YmxpYyByZW1lZGlhdGlvbiIsIGNyZWQpOworCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIGNyZWQpOworCisJcmV0dXJuIHNwcF9ub2RlOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogaHMyMF91c2VyX2lucHV0X2NvbXBsZXRlKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCQkgICAgIGNvbnN0IGNoYXIgKnVzZXIsCisJCQkJCSAgICAgY29uc3QgY2hhciAqcmVhbG0sIGludCBkbWFjYywKKwkJCQkJICAgICBjb25zdCBjaGFyICpzZXNzaW9uX2lkKQoreworCWNoYXIgKnZhbDsKKwllbnVtIGhzMjBfc2Vzc2lvbl9vcGVyYXRpb24gb3BlcjsKKworCXZhbCA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLCAib3BlcmF0aW9uIik7CisJaWYgKHZhbCA9PSBOVUxMKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIk5vIHNlc3Npb24gJXMgZm91bmQgdG8gY29udGludWUiLAorCQkJICAgIHNlc3Npb25faWQpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJb3BlciA9IGF0b2kodmFsKTsKKwlmcmVlKHZhbCk7CisKKwlpZiAob3BlciA9PSBVU0VSX1JFTUVESUFUSU9OKSB7CisJCXJldHVybiBoczIwX3VzZXJfaW5wdXRfcmVtZWRpYXRpb24oY3R4LCB1c2VyLCByZWFsbSwgZG1hY2MsCisJCQkJCQkgICBzZXNzaW9uX2lkKTsKKwl9CisKKwlpZiAob3BlciA9PSBGUkVFX1JFTUVESUFUSU9OKSB7CisJCXJldHVybiBoczIwX3VzZXJfaW5wdXRfZnJlZV9yZW1lZGlhdGlvbihjdHgsIHVzZXIsIHJlYWxtLAorCQkJCQkJCXNlc3Npb25faWQpOworCX0KKworCWlmIChvcGVyID09IFNVQlNDUklQVElPTl9SRUdJU1RSQVRJT04pIHsKKwkJcmV0dXJuIGhzMjBfdXNlcl9pbnB1dF9yZWdpc3RyYXRpb24oY3R4LCBzZXNzaW9uX2lkLCAwKTsKKwl9CisKKwlkZWJ1Z19wcmludChjdHgsIDEsICJVc2VyIHNlc3Npb24gJXMgbm90IGluIHN0YXRlIGZvciB1c2VyIGlucHV0ICIKKwkJICAgICJjb21wbGV0aW9uIiwgc2Vzc2lvbl9pZCk7CisJcmV0dXJuIE5VTEw7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBoczIwX2NlcnRfZW5yb2xsX2NvbXBsZXRlZChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkJICAgICAgIGNvbnN0IGNoYXIgKnVzZXIsCisJCQkJCSAgICAgICBjb25zdCBjaGFyICpyZWFsbSwgaW50IGRtYWNjLAorCQkJCQkgICAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCkKK3sKKwljaGFyICp2YWw7CisJZW51bSBoczIwX3Nlc3Npb25fb3BlcmF0aW9uIG9wZXI7CisKKwl2YWwgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgIm9wZXJhdGlvbiIpOworCWlmICh2YWwgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJObyBzZXNzaW9uICVzIGZvdW5kIHRvIGNvbnRpbnVlIiwKKwkJCSAgICBzZXNzaW9uX2lkKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCW9wZXIgPSBhdG9pKHZhbCk7CisJZnJlZSh2YWwpOworCisJaWYgKG9wZXIgPT0gU1VCU0NSSVBUSU9OX1JFR0lTVFJBVElPTikKKwkJcmV0dXJuIGhzMjBfdXNlcl9pbnB1dF9yZWdpc3RyYXRpb24oY3R4LCBzZXNzaW9uX2lkLCAxKTsKKworCWRlYnVnX3ByaW50KGN0eCwgMSwgIlVzZXIgc2Vzc2lvbiAlcyBub3QgaW4gc3RhdGUgZm9yIGNlcnRpZmljYXRlICIKKwkJICAgICJlbnJvbGxtZW50IGNvbXBsZXRpb24iLCBzZXNzaW9uX2lkKTsKKwlyZXR1cm4gTlVMTDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGhzMjBfY2VydF9lbnJvbGxfZmFpbGVkKHN0cnVjdCBoczIwX3N2YyAqY3R4LAorCQkJCQkgICAgY29uc3QgY2hhciAqdXNlciwKKwkJCQkJICAgIGNvbnN0IGNoYXIgKnJlYWxtLCBpbnQgZG1hY2MsCisJCQkJCSAgICBjb25zdCBjaGFyICpzZXNzaW9uX2lkKQoreworCWNoYXIgKnZhbDsKKwllbnVtIGhzMjBfc2Vzc2lvbl9vcGVyYXRpb24gb3BlcjsKKwl4bWxfbm9kZV90ICpzcHBfbm9kZSwgKm5vZGU7CisJY2hhciAqc3RhdHVzOworCXhtbF9uYW1lc3BhY2VfdCAqbnM7CisKKwl2YWwgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwgIm9wZXJhdGlvbiIpOworCWlmICh2YWwgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJObyBzZXNzaW9uICVzIGZvdW5kIHRvIGNvbnRpbnVlIiwKKwkJCSAgICBzZXNzaW9uX2lkKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCW9wZXIgPSBhdG9pKHZhbCk7CisJZnJlZSh2YWwpOworCisJaWYgKG9wZXIgIT0gU1VCU0NSSVBUSU9OX1JFR0lTVFJBVElPTikgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJVc2VyIHNlc3Npb24gJXMgbm90IGluIHN0YXRlIGZvciAiCisJCQkgICAgImVucm9sbG1lbnQgZmFpbHVyZSIsIHNlc3Npb25faWQpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlzdGF0dXMgPSAiRXJyb3Igb2NjdXJyZWQiOworCXNwcF9ub2RlID0gYnVpbGRfcG9zdF9kZXZfZGF0YV9yZXNwb25zZShjdHgsICZucywgc2Vzc2lvbl9pZCwgc3RhdHVzLAorCQkJCQkJTlVMTCk7CisJaWYgKHNwcF9ub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInNwcEVycm9yIik7CisJeG1sX25vZGVfYWRkX2F0dHIoY3R4LT54bWwsIG5vZGUsIE5VTEwsICJlcnJvckNvZGUiLAorCQkJICAiQ3JlZGVudGlhbHMgY2Fubm90IGJlIHByb3Zpc2lvbmVkIGF0IHRoaXMgdGltZSIpOworCWRiX3JlbW92ZV9zZXNzaW9uKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQpOworCisJcmV0dXJuIHNwcF9ub2RlOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogaHMyMF9zcHBfcG9zdF9kZXZfZGF0YShzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkJICAgeG1sX25vZGVfdCAqbm9kZSwKKwkJCQkJICAgY29uc3QgY2hhciAqdXNlciwKKwkJCQkJICAgY29uc3QgY2hhciAqcmVhbG0sCisJCQkJCSAgIGNvbnN0IGNoYXIgKnNlc3Npb25faWQsCisJCQkJCSAgIGludCBkbWFjYykKK3sKKwljb25zdCBjaGFyICpyZXFfcmVhc29uOworCWNoYXIgKnJlZGlyZWN0X3VyaSA9IE5VTEw7CisJY2hhciAqcmVxX3JlYXNvbl9idWYgPSBOVUxMOworCWNoYXIgc3RyWzIwMF07CisJeG1sX25vZGVfdCAqcmV0ID0gTlVMTCwgKmRldmluZm8gPSBOVUxMLCAqZGV2ZGV0YWlsID0gTlVMTDsKKwl4bWxfbm9kZV90ICptbzsKKwljaGFyICp2ZXJzaW9uOworCWludCB2YWxpZDsKKwljaGFyICpzdXBwLCAqcG9zOworCWNoYXIgKmVycjsKKworCXZlcnNpb24gPSB4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9ucyhjdHgtPnhtbCwgbm9kZSwgU1BQX05TX1VSSSwKKwkJCQkJICAgICAic3BwVmVyc2lvbiIpOworCWlmICh2ZXJzaW9uID09IE5VTEwgfHwgc3Ryc3RyKHZlcnNpb24sICIxLjAiKSA9PSBOVUxMKSB7CisJCXJldCA9IGJ1aWxkX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2UoCisJCQljdHgsIE5VTEwsIHNlc3Npb25faWQsICJFcnJvciBvY2N1cnJlZCIsCisJCQkiU1BQIHZlcnNpb24gbm90IHN1cHBvcnRlZCIpOworCQloczIwX2V2ZW50bG9nX25vZGUoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAiVW5zdXBwb3J0ZWQgc3BwVmVyc2lvbiIsIHJldCk7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHZlcnNpb24pOworCQlyZXR1cm4gcmV0OworCX0KKwl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCB2ZXJzaW9uKTsKKworCW1vID0gZ2V0X25vZGUoY3R4LT54bWwsIG5vZGUsICJzdXBwb3J0ZWRNT0xpc3QiKTsKKwlpZiAobW8gPT0gTlVMTCkgeworCQlyZXQgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKAorCQkJY3R4LCBOVUxMLCBzZXNzaW9uX2lkLCAiRXJyb3Igb2NjdXJyZWQiLAorCQkJIk90aGVyIik7CisJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJCSAgICJObyBzdXBwb3J0ZWRNT0xpc3QgZWxlbWVudCIsIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCXN1cHAgPSB4bWxfbm9kZV9nZXRfdGV4dChjdHgtPnhtbCwgbW8pOworCWZvciAocG9zID0gc3VwcDsgcG9zICYmICpwb3M7IHBvcysrKQorCQkqcG9zID0gdG9sb3dlcigqcG9zKTsKKwlpZiAoc3VwcCA9PSBOVUxMIHx8CisJICAgIHN0cnN0cihzdXBwLCBVUk5fT01BX0RNX0RFVklORk8pID09IE5VTEwgfHwKKwkgICAgc3Ryc3RyKHN1cHAsIFVSTl9PTUFfRE1fREVWREVUQUlMKSA9PSBOVUxMIHx8CisJICAgIHN0cnN0cihzdXBwLCBVUk5fSFMyMF9QUFMpID09IE5VTEwpIHsKKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgtPnhtbCwgc3VwcCk7CisJCXJldCA9IGJ1aWxkX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2UoCisJCQljdHgsIE5VTEwsIHNlc3Npb25faWQsICJFcnJvciBvY2N1cnJlZCIsCisJCQkiT25lIG9yIG1vcmUgbWFuZGF0b3J5IE1PcyBub3Qgc3VwcG9ydGVkIik7CisJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJCSAgICJVbnN1cHBvcnRlZCBNT3MiLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eC0+eG1sLCBzdXBwKTsKKworCXJlcV9yZWFzb25fYnVmID0geG1sX25vZGVfZ2V0X2F0dHJfdmFsdWUoY3R4LT54bWwsIG5vZGUsCisJCQkJCQkgInJlcXVlc3RSZWFzb24iKTsKKwlpZiAocmVxX3JlYXNvbl9idWYgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJObyByZXF1ZXN0UmVhc29uIGF0dHJpYnV0ZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJcmVxX3JlYXNvbiA9IHJlcV9yZWFzb25fYnVmOworCisJcmVkaXJlY3RfdXJpID0geG1sX25vZGVfZ2V0X2F0dHJfdmFsdWUoY3R4LT54bWwsIG5vZGUsICJyZWRpcmVjdFVSSSIpOworCisJZGVidWdfcHJpbnQoY3R4LCAxLCAicmVxdWVzdFJlYXNvbjogJXMgIHNlc3Npb25JRDogJXMgIHJlZGlyZWN0VVJJOiAlcyIsCisJCSAgICByZXFfcmVhc29uLCBzZXNzaW9uX2lkLCByZWRpcmVjdF91cmkpOworCXNucHJpbnRmKHN0ciwgc2l6ZW9mKHN0ciksICJzcHBQb3N0RGV2RGF0YTogcmVxdWVzdFJlYXNvbj0lcyIsCisJCSByZXFfcmVhc29uKTsKKwloczIwX2V2ZW50bG9nKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsIHN0ciwgTlVMTCk7CisKKwlkZXZpbmZvID0gc3BwX2dldF9tbyhjdHgsIG5vZGUsIFVSTl9PTUFfRE1fREVWSU5GTywgJnZhbGlkLCAmZXJyKTsKKwlpZiAoZGV2aW5mbyA9PSBOVUxMKSB7CisJCXJldCA9IGJ1aWxkX3Bvc3RfZGV2X2RhdGFfcmVzcG9uc2UoY3R4LCBOVUxMLCBzZXNzaW9uX2lkLAorCQkJCQkJICAgIkVycm9yIG9jY3VycmVkIiwgIk90aGVyIik7CisJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJCSAgICJObyBEZXZJbmZvIG1vQ29udGFpbmVyIGluIHNwcFBvc3REZXZEYXRhIiwKKwkJCQkgICByZXQpOworCQlvc19mcmVlKGVycik7CisJCWdvdG8gb3V0OworCX0KKworCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgIlJlY2VpdmVkIERldkluZm8gTU8iLCBkZXZpbmZvKTsKKwlpZiAodmFsaWQgPT0gMCkgeworCQloczIwX2V2ZW50bG9nKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkgICAgICAiT01BLURNIERERiBEVEQgdmFsaWRhdGlvbiBlcnJvcnMgaW4gRGV2SW5mbyBNTyIsCisJCQkgICAgICBlcnIpOworCQlyZXQgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCQkJCSAgICJFcnJvciBvY2N1cnJlZCIsICJPdGhlciIpOworCQlvc19mcmVlKGVycik7CisJCWdvdG8gb3V0OworCX0KKwlvc19mcmVlKGVycik7CisJaWYgKHVzZXIpCisJCWRiX3VwZGF0ZV9tbyhjdHgsIHVzZXIsIHJlYWxtLCAiZGV2aW5mbyIsIGRldmluZm8pOworCisJZGV2ZGV0YWlsID0gc3BwX2dldF9tbyhjdHgsIG5vZGUsIFVSTl9PTUFfRE1fREVWREVUQUlMLCAmdmFsaWQsICZlcnIpOworCWlmIChkZXZkZXRhaWwgPT0gTlVMTCkgeworCQlyZXQgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCQkJCSAgICJFcnJvciBvY2N1cnJlZCIsICJPdGhlciIpOworCQloczIwX2V2ZW50bG9nX25vZGUoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAiTm8gRGV2RGV0YWlsIG1vQ29udGFpbmVyIGluIHNwcFBvc3REZXZEYXRhIiwKKwkJCQkgICByZXQpOworCQlvc19mcmVlKGVycik7CisJCWdvdG8gb3V0OworCX0KKworCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgIlJlY2VpdmVkIERldkRldGFpbCBNTyIsIGRldmRldGFpbCk7CisJaWYgKHZhbGlkID09IDApIHsKKwkJaHMyMF9ldmVudGxvZyhjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgICAgIk9NQS1ETSBEREYgRFREIHZhbGlkYXRpb24gZXJyb3JzICIKKwkJCSAgICAgICJpbiBEZXZEZXRhaWwgTU8iLCBlcnIpOworCQlyZXQgPSBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKGN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCQkJCSAgICJFcnJvciBvY2N1cnJlZCIsICJPdGhlciIpOworCQlvc19mcmVlKGVycik7CisJCWdvdG8gb3V0OworCX0KKwlvc19mcmVlKGVycik7CisJaWYgKHVzZXIpCisJCWRiX3VwZGF0ZV9tbyhjdHgsIHVzZXIsIHJlYWxtLCAiZGV2ZGV0YWlsIiwgZGV2ZGV0YWlsKTsKKworCWlmICh1c2VyKQorCQltbyA9IHNwcF9nZXRfbW8oY3R4LCBub2RlLCBVUk5fSFMyMF9QUFMsICZ2YWxpZCwgJmVycik7CisJZWxzZSB7CisJCW1vID0gTlVMTDsKKwkJZXJyID0gTlVMTDsKKwl9CisJaWYgKHVzZXIgJiYgbW8pIHsKKwkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkJICAgIlJlY2VpdmVkIFBQUyBNTyIsIG1vKTsKKwkJaWYgKHZhbGlkID09IDApIHsKKwkJCWhzMjBfZXZlbnRsb2coY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAgICAiT01BLURNIERERiBEVEQgdmFsaWRhdGlvbiBlcnJvcnMgIgorCQkJCSAgICAgICJpbiBQUFMgTU8iLCBlcnIpOworCQkJeG1sX25vZGVfZ2V0X2F0dHJfdmFsdWVfZnJlZShjdHgtPnhtbCwgcmVkaXJlY3RfdXJpKTsKKwkJCW9zX2ZyZWUoZXJyKTsKKwkJCXJldHVybiBidWlsZF9wb3N0X2Rldl9kYXRhX3Jlc3BvbnNlKAorCQkJCWN0eCwgTlVMTCwgc2Vzc2lvbl9pZCwKKwkJCQkiRXJyb3Igb2NjdXJyZWQiLCAiT3RoZXIiKTsKKwkJfQorCQlkYl91cGRhdGVfbW8oY3R4LCB1c2VyLCByZWFsbSwgInBwcyIsIG1vKTsKKwkJZGJfdXBkYXRlX3ZhbChjdHgsIHVzZXIsIHJlYWxtLCAiZmV0Y2hfcHBzIiwgIjAiLCBkbWFjYyk7CisJCXhtbF9ub2RlX2ZyZWUoY3R4LT54bWwsIG1vKTsKKwl9CisJb3NfZnJlZShlcnIpOworCisJaWYgKHVzZXIgJiYgIW1vKSB7CisJCWNoYXIgKmZldGNoOworCQlpbnQgZmV0Y2hfcHBzOworCisJCWZldGNoID0gZGJfZ2V0X3ZhbChjdHgsIHVzZXIsIHJlYWxtLCAiZmV0Y2hfcHBzIiwgZG1hY2MpOworCQlmZXRjaF9wcHMgPSBmZXRjaCA/IGF0b2koZmV0Y2gpIDogMDsKKwkJZnJlZShmZXRjaCk7CisKKwkJaWYgKGZldGNoX3BwcykgeworCQkJZW51bSBoczIwX3Nlc3Npb25fb3BlcmF0aW9uIG9wZXI7CisJCQlpZiAoc3RyY2FzZWNtcChyZXFfcmVhc29uLCAiU3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIikKKwkJCSAgICA9PSAwKQorCQkJCW9wZXIgPSBDT05USU5VRV9TVUJTQ1JJUFRJT05fUkVNRURJQVRJT047CisJCQllbHNlIGlmIChzdHJjYXNlY21wKHJlcV9yZWFzb24sICJQb2xpY3kgdXBkYXRlIikgPT0gMCkKKwkJCQlvcGVyID0gQ09OVElOVUVfUE9MSUNZX1VQREFURTsKKwkJCWVsc2UKKwkJCQlvcGVyID0gTk9fT1BFUkFUSU9OOworCQkJaWYgKGRiX2FkZF9zZXNzaW9uKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsIE5VTEwsCisJCQkJCSAgIE5VTEwsIG9wZXIpIDwgMCkKKwkJCQlnb3RvIG91dDsKKworCQkJcmV0ID0gc3BwX2V4ZWNfdXBsb2FkX21vKGN0eCwgc2Vzc2lvbl9pZCwKKwkJCQkJCSBVUk5fSFMyMF9QUFMpOworCQkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkJCSAgICJyZXF1ZXN0IFBQUyBNTyB1cGxvYWQiLAorCQkJCQkgICByZXQpOworCQkJZ290byBvdXQ7CisJCX0KKwl9CisKKwlpZiAodXNlciAmJiBzdHJjYXNlY21wKHJlcV9yZWFzb24sICJNTyB1cGxvYWQiKSA9PSAwKSB7CisJCWNoYXIgKnZhbCA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJCQkgICAgICAgIm9wZXJhdGlvbiIpOworCQllbnVtIGhzMjBfc2Vzc2lvbl9vcGVyYXRpb24gb3BlcjsKKwkJaWYgKCF2YWwpIHsKKwkJCWRlYnVnX3ByaW50KGN0eCwgMSwgIk5vIHNlc3Npb24gJXMgZm91bmQgdG8gY29udGludWUiLAorCQkJCSAgICBzZXNzaW9uX2lkKTsKKwkJCWdvdG8gb3V0OworCQl9CisJCW9wZXIgPSBhdG9pKHZhbCk7CisJCWZyZWUodmFsKTsKKwkJaWYgKG9wZXIgPT0gQ09OVElOVUVfU1VCU0NSSVBUSU9OX1JFTUVESUFUSU9OKQorCQkJcmVxX3JlYXNvbiA9ICJTdWJzY3JpcHRpb24gcmVtZWRpYXRpb24iOworCQllbHNlIGlmIChvcGVyID09IENPTlRJTlVFX1BPTElDWV9VUERBVEUpCisJCQlyZXFfcmVhc29uID0gIlBvbGljeSB1cGRhdGUiOworCQllbHNlIHsKKwkJCWRlYnVnX3ByaW50KGN0eCwgMSwKKwkJCQkgICAgIk5vIHBlbmRpbmcgb3BlcmF0aW9uIGluIHNlc3Npb24gJXMiLAorCQkJCSAgICBzZXNzaW9uX2lkKTsKKwkJCWdvdG8gb3V0OworCQl9CisJfQorCisJaWYgKHN0cmNhc2VjbXAocmVxX3JlYXNvbiwgIlN1YnNjcmlwdGlvbiByZWdpc3RyYXRpb24iKSA9PSAwKSB7CisJCXJldCA9IGhzMjBfc3Vic2NyaXB0aW9uX3JlZ2lzdHJhdGlvbihjdHgsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJCQkJICAgICByZWRpcmVjdF91cmkpOworCQloczIwX2V2ZW50bG9nX25vZGUoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAic3Vic2NyaXB0aW9uIHJlZ2lzdHJhdGlvbiByZXNwb25zZSIsCisJCQkJICAgcmV0KTsKKwkJZ290byBvdXQ7CisJfQorCWlmICh1c2VyICYmIHN0cmNhc2VjbXAocmVxX3JlYXNvbiwgIlN1YnNjcmlwdGlvbiByZW1lZGlhdGlvbiIpID09IDApIHsKKwkJcmV0ID0gaHMyMF9zdWJzY3JpcHRpb25fcmVtZWRpYXRpb24oY3R4LCB1c2VyLCByZWFsbSwKKwkJCQkJCSAgICBzZXNzaW9uX2lkLCBkbWFjYywKKwkJCQkJCSAgICByZWRpcmVjdF91cmkpOworCQloczIwX2V2ZW50bG9nX25vZGUoY3R4LCB1c2VyLCByZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAic3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIHJlc3BvbnNlIiwKKwkJCQkgICByZXQpOworCQlnb3RvIG91dDsKKwl9CisJaWYgKHVzZXIgJiYgc3RyY2FzZWNtcChyZXFfcmVhc29uLCAiUG9saWN5IHVwZGF0ZSIpID09IDApIHsKKwkJcmV0ID0gaHMyMF9wb2xpY3lfdXBkYXRlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsIGRtYWNjKTsKKwkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkJICAgInBvbGljeSB1cGRhdGUgcmVzcG9uc2UiLAorCQkJCSAgIHJldCk7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChzdHJjYXNlY21wKHJlcV9yZWFzb24sICJVc2VyIGlucHV0IGNvbXBsZXRlZCIpID09IDApIHsKKwkJaWYgKGRldmluZm8pCisJCQlkYl9hZGRfc2Vzc2lvbl9kZXZpbmZvKGN0eCwgc2Vzc2lvbl9pZCwgZGV2aW5mbyk7CisJCWlmIChkZXZkZXRhaWwpCisJCQlkYl9hZGRfc2Vzc2lvbl9kZXZkZXRhaWwoY3R4LCBzZXNzaW9uX2lkLCBkZXZkZXRhaWwpOworCQlyZXQgPSBoczIwX3VzZXJfaW5wdXRfY29tcGxldGUoY3R4LCB1c2VyLCByZWFsbSwgZG1hY2MsCisJCQkJCSAgICAgICBzZXNzaW9uX2lkKTsKKwkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkJICAgInVzZXIgaW5wdXQgY29tcGxldGVkIHJlc3BvbnNlIiwgcmV0KTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKHN0cmNhc2VjbXAocmVxX3JlYXNvbiwgIkNlcnRpZmljYXRlIGVucm9sbG1lbnQgY29tcGxldGVkIikgPT0gMCkgeworCQlyZXQgPSBoczIwX2NlcnRfZW5yb2xsX2NvbXBsZXRlZChjdHgsIHVzZXIsIHJlYWxtLCBkbWFjYywKKwkJCQkJCSBzZXNzaW9uX2lkKTsKKwkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkJICAgImNlcnRpZmljYXRlIGVucm9sbG1lbnQgcmVzcG9uc2UiLCByZXQpOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAoc3RyY2FzZWNtcChyZXFfcmVhc29uLCAiQ2VydGlmaWNhdGUgZW5yb2xsbWVudCBmYWlsZWQiKSA9PSAwKSB7CisJCXJldCA9IGhzMjBfY2VydF9lbnJvbGxfZmFpbGVkKGN0eCwgdXNlciwgcmVhbG0sIGRtYWNjLAorCQkJCQkgICAgICBzZXNzaW9uX2lkKTsKKwkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsCisJCQkJICAgImNlcnRpZmljYXRlIGVucm9sbG1lbnQgZmFpbGVkIHJlc3BvbnNlIiwKKwkJCQkgICByZXQpOworCQlnb3RvIG91dDsKKwl9CisKKwlkZWJ1Z19wcmludChjdHgsIDEsICJVbnN1cHBvcnRlZCByZXF1ZXN0UmVhc29uICclcycgdXNlciAnJXMnIiwKKwkJICAgIHJlcV9yZWFzb24sIHVzZXIpOworb3V0OgorCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHJlcV9yZWFzb25fYnVmKTsKKwl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCByZWRpcmVjdF91cmkpOworCWlmIChkZXZpbmZvKQorCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBkZXZpbmZvKTsKKwlpZiAoZGV2ZGV0YWlsKQorCQl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBkZXZkZXRhaWwpOworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBidWlsZF9zcHBfZXhjaGFuZ2VfY29tcGxldGUoc3RydWN0IGhzMjBfc3ZjICpjdHgsCisJCQkJCQljb25zdCBjaGFyICpzZXNzaW9uX2lkLAorCQkJCQkJY29uc3QgY2hhciAqc3RhdHVzLAorCQkJCQkJY29uc3QgY2hhciAqZXJyb3JfY29kZSkKK3sKKwl4bWxfbmFtZXNwYWNlX3QgKm5zOworCXhtbF9ub2RlX3QgKnNwcF9ub2RlLCAqbm9kZTsKKworCXNwcF9ub2RlID0geG1sX25vZGVfY3JlYXRlX3Jvb3QoY3R4LT54bWwsIFNQUF9OU19VUkksICJzcHAiLCAmbnMsCisJCQkJCSJzcHBFeGNoYW5nZUNvbXBsZXRlIik7CisKKworCXhtbF9ub2RlX2FkZF9hdHRyKGN0eC0+eG1sLCBzcHBfbm9kZSwgbnMsICJzcHBWZXJzaW9uIiwgIjEuMCIpOworCXhtbF9ub2RlX2FkZF9hdHRyKGN0eC0+eG1sLCBzcHBfbm9kZSwgbnMsICJzZXNzaW9uSUQiLCBzZXNzaW9uX2lkKTsKKwl4bWxfbm9kZV9hZGRfYXR0cihjdHgtPnhtbCwgc3BwX25vZGUsIG5zLCAic3BwU3RhdHVzIiwgc3RhdHVzKTsKKworCWlmIChlcnJvcl9jb2RlKSB7CisJCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LT54bWwsIHNwcF9ub2RlLCBucywgInNwcEVycm9yIik7CisJCXhtbF9ub2RlX2FkZF9hdHRyKGN0eC0+eG1sLCBub2RlLCBOVUxMLCAiZXJyb3JDb2RlIiwKKwkJCQkgIGVycm9yX2NvZGUpOworCX0KKworCXJldHVybiBzcHBfbm9kZTsKK30KKworCitzdGF0aWMgaW50IGFkZF9zdWJzY3JpcHRpb24oc3RydWN0IGhzMjBfc3ZjICpjdHgsIGNvbnN0IGNoYXIgKnNlc3Npb25faWQpCit7CisJY2hhciAqdXNlciwgKnJlYWxtLCAqcHcsICpwd19tbSwgKnBwcywgKnN0cjsKKwljaGFyICpzcWw7CisJaW50IHJldCA9IC0xOworCWNoYXIgKmZyZWVfYWNjb3VudDsKKwlpbnQgZnJlZV9hY2M7CisJY2hhciAqdHlwZTsKKwlpbnQgY2VydCA9IDA7CisJY2hhciAqY2VydF9wZW0sICpmaW5nZXJwcmludDsKKworCXVzZXIgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCBOVUxMLCBOVUxMLCBzZXNzaW9uX2lkLCAidXNlciIpOworCXJlYWxtID0gZGJfZ2V0X3Nlc3Npb25fdmFsKGN0eCwgTlVMTCwgTlVMTCwgc2Vzc2lvbl9pZCwgInJlYWxtIik7CisJcHcgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCBOVUxMLCBOVUxMLCBzZXNzaW9uX2lkLCAicGFzc3dvcmQiKTsKKwlwd19tbSA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIE5VTEwsIE5VTEwsIHNlc3Npb25faWQsCisJCQkJICAgIm1hY2hpbmVfbWFuYWdlZCIpOworCXBwcyA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIE5VTEwsIE5VTEwsIHNlc3Npb25faWQsICJwcHMiKTsKKwljZXJ0X3BlbSA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIE5VTEwsIE5VTEwsIHNlc3Npb25faWQsICJjZXJ0X3BlbSIpOworCWZpbmdlcnByaW50ID0gZGJfZ2V0X3Nlc3Npb25fdmFsKGN0eCwgTlVMTCwgTlVMTCwgc2Vzc2lvbl9pZCwgImNlcnQiKTsKKwl0eXBlID0gZGJfZ2V0X3Nlc3Npb25fdmFsKGN0eCwgTlVMTCwgTlVMTCwgc2Vzc2lvbl9pZCwgInR5cGUiKTsKKwlpZiAodHlwZSAmJiBzdHJjbXAodHlwZSwgImNlcnQiKSA9PSAwKQorCQljZXJ0ID0gMTsKKwlmcmVlKHR5cGUpOworCisJaWYgKCF1c2VyIHx8ICFyZWFsbSB8fCAhcHcpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiQ291bGQgbm90IGZpbmQgc2Vzc2lvbiBpbmZvIGZyb20gREIgZm9yICIKKwkJCSAgICAidGhlIG5ldyBzdWJzY3JpcHRpb24iKTsKKwkJZ290byBvdXQ7CisJfQorCisJZnJlZV9hY2NvdW50ID0gZGJfZ2V0X29zdV9jb25maWdfdmFsKGN0eCwgcmVhbG0sICJmcmVlX2FjY291bnQiKTsKKwlmcmVlX2FjYyA9IGZyZWVfYWNjb3VudCAmJiBzdHJjbXAoZnJlZV9hY2NvdW50LCB1c2VyKSA9PSAwOworCWZyZWUoZnJlZV9hY2NvdW50KTsKKworCWRlYnVnX3ByaW50KGN0eCwgMSwKKwkJICAgICJOZXcgc3Vic2NyaXB0aW9uOiB1c2VyPSclcycgcmVhbG09JyVzJyBmcmVlX2FjYz0lZCIsCisJCSAgICB1c2VyLCByZWFsbSwgZnJlZV9hY2MpOworCWRlYnVnX3ByaW50KGN0eCwgMSwgIk5ldyBzdWJzY3JpcHRpb246IHBwcz0nJXMnIiwgcHBzKTsKKworCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiVVBEQVRFIGV2ZW50bG9nIFNFVCB1c2VyPSVRLCByZWFsbT0lUSBXSEVSRSAiCisJCQkgICAgICAic2Vzc2lvbmlkPSVRIEFORCAodXNlcj0nJyBPUiB1c2VyIElTIE5VTEwpIiwKKwkJCSAgICAgIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkKTsKKwlpZiAoc3FsKSB7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkRCOiAlcyIsIHNxbCk7CisJCWlmIChzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgc3FsLCBOVUxMLCBOVUxMLCBOVUxMKSAhPSBTUUxJVEVfT0spIHsKKwkJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkZhaWxlZCB0byB1cGRhdGUgZXZlbnRsb2cgaW4gIgorCQkJCSAgICAic3FsaXRlIGRhdGFiYXNlOiAlcyIsCisJCQkJICAgIHNxbGl0ZTNfZXJybXNnKGN0eC0+ZGIpKTsKKwkJfQorCQlzcWxpdGUzX2ZyZWUoc3FsKTsKKwl9CisKKwlpZiAoZnJlZV9hY2MpIHsKKwkJaHMyMF9ldmVudGxvZyhjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgICAgImNvbXBsZXRlZCBzaGFyZWQgZnJlZSBhY2NvdW50IHJlZ2lzdHJhdGlvbiIsCisJCQkgICAgICBOVUxMKTsKKwkJcmV0ID0gMDsKKwkJZ290byBvdXQ7CisJfQorCisJc3FsID0gc3FsaXRlM19tcHJpbnRmKCJJTlNFUlQgSU5UTyB1c2VycyhpZGVudGl0eSxyZWFsbSxwaGFzZTIsIgorCQkJICAgICAgIm1ldGhvZHMsY2VydCxjZXJ0X3BlbSxtYWNoaW5lX21hbmFnZWQpIFZBTFVFUyAiCisJCQkgICAgICAiKCVRLCVRLDEsJVEsJVEsJVEsJWQpIiwKKwkJCSAgICAgIHVzZXIsIHJlYWxtLCBjZXJ0ID8gIlRMUyIgOiAiVFRMUy1NU0NIQVBWMiIsCisJCQkgICAgICBmaW5nZXJwcmludCA/IGZpbmdlcnByaW50IDogIiIsCisJCQkgICAgICBjZXJ0X3BlbSA/IGNlcnRfcGVtIDogIiIsCisJCQkgICAgICBwd19tbSAmJiBhdG9pKHB3X21tKSA/IDEgOiAwKTsKKwlpZiAoc3FsID09IE5VTEwpCisJCWdvdG8gb3V0OworCWRlYnVnX3ByaW50KGN0eCwgMSwgIkRCOiAlcyIsIHNxbCk7CisJaWYgKHNxbGl0ZTNfZXhlYyhjdHgtPmRiLCBzcWwsIE5VTEwsIE5VTEwsIE5VTEwpICE9IFNRTElURV9PSykgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJGYWlsZWQgdG8gYWRkIHVzZXIgaW4gc3FsaXRlIGRhdGFiYXNlOiAlcyIsCisJCQkgICAgc3FsaXRlM19lcnJtc2coY3R4LT5kYikpOworCQlzcWxpdGUzX2ZyZWUoc3FsKTsKKwkJZ290byBvdXQ7CisJfQorCXNxbGl0ZTNfZnJlZShzcWwpOworCisJaWYgKGNlcnQpCisJCXJldCA9IDA7CisJZWxzZQorCQlyZXQgPSB1cGRhdGVfcGFzc3dvcmQoY3R4LCB1c2VyLCByZWFsbSwgcHcsIDApOworCWlmIChyZXQgPCAwKSB7CisJCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiREVMRVRFIEZST00gdXNlcnMgV0hFUkUgaWRlbnRpdHk9JVEgQU5EICIKKwkJCQkgICAgICAicmVhbG09JVEgQU5EIHBoYXNlMj0xIiwKKwkJCQkgICAgICB1c2VyLCByZWFsbSk7CisJCWlmIChzcWwpIHsKKwkJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkRCOiAlcyIsIHNxbCk7CisJCQlzcWxpdGUzX2V4ZWMoY3R4LT5kYiwgc3FsLCBOVUxMLCBOVUxMLCBOVUxMKTsKKwkJCXNxbGl0ZTNfZnJlZShzcWwpOworCQl9CisJfQorCisJaWYgKHBwcykKKwkJZGJfdXBkYXRlX21vX3N0cihjdHgsIHVzZXIsIHJlYWxtLCAicHBzIiwgcHBzKTsKKworCXN0ciA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIE5VTEwsIE5VTEwsIHNlc3Npb25faWQsICJkZXZpbmZvIik7CisJaWYgKHN0cikgeworCQlkYl91cGRhdGVfbW9fc3RyKGN0eCwgdXNlciwgcmVhbG0sICJkZXZpbmZvIiwgc3RyKTsKKwkJZnJlZShzdHIpOworCX0KKworCXN0ciA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIE5VTEwsIE5VTEwsIHNlc3Npb25faWQsICJkZXZkZXRhaWwiKTsKKwlpZiAoc3RyKSB7CisJCWRiX3VwZGF0ZV9tb19zdHIoY3R4LCB1c2VyLCByZWFsbSwgImRldmRldGFpbCIsIHN0cik7CisJCWZyZWUoc3RyKTsKKwl9CisKKwlpZiAocmV0ID09IDApIHsKKwkJaHMyMF9ldmVudGxvZyhjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgICAgImNvbXBsZXRlZCBzdWJzY3JpcHRpb24gcmVnaXN0cmF0aW9uIiwgTlVMTCk7CisJfQorCitvdXQ6CisJZnJlZSh1c2VyKTsKKwlmcmVlKHJlYWxtKTsKKwlmcmVlKHB3KTsKKwlmcmVlKHB3X21tKTsKKwlmcmVlKHBwcyk7CisJZnJlZShjZXJ0X3BlbSk7CisJZnJlZShmaW5nZXJwcmludCk7CisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIGhzMjBfc3BwX3VwZGF0ZV9yZXNwb25zZShzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwKKwkJCQkJICAgICB4bWxfbm9kZV90ICpub2RlLAorCQkJCQkgICAgIGNvbnN0IGNoYXIgKnVzZXIsCisJCQkJCSAgICAgY29uc3QgY2hhciAqcmVhbG0sCisJCQkJCSAgICAgY29uc3QgY2hhciAqc2Vzc2lvbl9pZCwKKwkJCQkJICAgICBpbnQgZG1hY2MpCit7CisJY2hhciAqc3RhdHVzOworCXhtbF9ub2RlX3QgKnJldDsKKwljaGFyICp2YWw7CisJZW51bSBoczIwX3Nlc3Npb25fb3BlcmF0aW9uIG9wZXI7CisKKwlzdGF0dXMgPSB4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9ucyhjdHgtPnhtbCwgbm9kZSwgU1BQX05TX1VSSSwKKwkJCQkJICAgICJzcHBTdGF0dXMiKTsKKwlpZiAoc3RhdHVzID09IE5VTEwpIHsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiTm8gc3BwU3RhdHVzIGF0dHJpYnV0ZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlkZWJ1Z19wcmludChjdHgsIDEsICJzcHBVcGRhdGVSZXNwb25zZTogc3BwU3RhdHVzOiAlcyAgc2Vzc2lvbklEOiAlcyIsCisJCSAgICBzdGF0dXMsIHNlc3Npb25faWQpOworCisJdmFsID0gZGJfZ2V0X3Nlc3Npb25fdmFsKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQsICJvcGVyYXRpb24iKTsKKwlpZiAoIXZhbCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsCisJCQkgICAgIk5vIHNlc3Npb24gYWN0aXZlIGZvciB1c2VyOiAlcyAgc2Vzc2lvbklEOiAlcyIsCisJCQkgICAgdXNlciwgc2Vzc2lvbl9pZCk7CisJCW9wZXIgPSBOT19PUEVSQVRJT047CisJfSBlbHNlCisJCW9wZXIgPSBhdG9pKHZhbCk7CisKKwlpZiAoc3RyY2FzZWNtcChzdGF0dXMsICJPSyIpID09IDApIHsKKwkJY2hhciAqbmV3X3B3ID0gTlVMTDsKKworCQl4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKGN0eC0+eG1sLCBzdGF0dXMpOworCisJCWlmIChvcGVyID09IFVTRVJfUkVNRURJQVRJT04pIHsKKwkJCW5ld19wdyA9IGRiX2dldF9zZXNzaW9uX3ZhbChjdHgsIHVzZXIsIHJlYWxtLAorCQkJCQkJICAgIHNlc3Npb25faWQsICJwYXNzd29yZCIpOworCQkJaWYgKG5ld19wdyA9PSBOVUxMIHx8IHN0cmxlbihuZXdfcHcpID09IDApIHsKKwkJCQlmcmVlKG5ld19wdyk7CisJCQkJcmV0ID0gYnVpbGRfc3BwX2V4Y2hhbmdlX2NvbXBsZXRlKAorCQkJCQljdHgsIHNlc3Npb25faWQsICJFcnJvciBvY2N1cnJlZCIsCisJCQkJCSJPdGhlciIpOworCQkJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLAorCQkJCQkJICAgc2Vzc2lvbl9pZCwgIk5vIHBhc3N3b3JkICIKKwkJCQkJCSAgICJoYWQgYmVlbiBhc3NpZ25lZCBmb3IgIgorCQkJCQkJICAgInNlc3Npb24iLCByZXQpOworCQkJCWRiX3JlbW92ZV9zZXNzaW9uKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQpOworCQkJCXJldHVybiByZXQ7CisJCQl9CisJCQlvcGVyID0gVVBEQVRFX1BBU1NXT1JEOworCQl9CisJCWlmIChvcGVyID09IFVQREFURV9QQVNTV09SRCkgeworCQkJaWYgKCFuZXdfcHcpIHsKKwkJCQluZXdfcHcgPSBkYl9nZXRfc2Vzc2lvbl92YWwoY3R4LCB1c2VyLCByZWFsbSwKKwkJCQkJCQkgICAgc2Vzc2lvbl9pZCwKKwkJCQkJCQkgICAgInBhc3N3b3JkIik7CisJCQkJaWYgKCFuZXdfcHcpIHsKKwkJCQkJZGJfcmVtb3ZlX3Nlc3Npb24oY3R4LCB1c2VyLCByZWFsbSwKKwkJCQkJCQkgIHNlc3Npb25faWQpOworCQkJCQlyZXR1cm4gTlVMTDsKKwkJCQl9CisJCQl9CisJCQlkZWJ1Z19wcmludChjdHgsIDEsICJVcGRhdGUgdXNlciAnJXMnIHBhc3N3b3JkIGluIERCIiwKKwkJCQkgICAgdXNlcik7CisJCQlpZiAodXBkYXRlX3Bhc3N3b3JkKGN0eCwgdXNlciwgcmVhbG0sIG5ld19wdywgZG1hY2MpIDwKKwkJCSAgICAwKSB7CisJCQkJZGVidWdfcHJpbnQoY3R4LCAxLCAiRmFpbGVkIHRvIHVwZGF0ZSB1c2VyICIKKwkJCQkJICAgICInJXMnIHBhc3N3b3JkIGluIERCIiwgdXNlcik7CisJCQkJcmV0ID0gYnVpbGRfc3BwX2V4Y2hhbmdlX2NvbXBsZXRlKAorCQkJCQljdHgsIHNlc3Npb25faWQsICJFcnJvciBvY2N1cnJlZCIsCisJCQkJCSJPdGhlciIpOworCQkJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLAorCQkJCQkJICAgc2Vzc2lvbl9pZCwgIkZhaWxlZCB0byAiCisJCQkJCQkgICAidXBkYXRlIGRhdGFiYXNlIiwgcmV0KTsKKwkJCQlkYl9yZW1vdmVfc2Vzc2lvbihjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkKTsKKwkJCQlyZXR1cm4gcmV0OworCQkJfQorCQkJaHMyMF9ldmVudGxvZyhjdHgsIHVzZXIsIHJlYWxtLAorCQkJCSAgICAgIHNlc3Npb25faWQsICJVcGRhdGVkIHVzZXIgcGFzc3dvcmQgIgorCQkJCSAgICAgICJpbiBkYXRhYmFzZSIsIE5VTEwpOworCQl9CisJCWlmIChvcGVyID09IFNVQlNDUklQVElPTl9SRUdJU1RSQVRJT04pIHsKKwkJCWlmIChhZGRfc3Vic2NyaXB0aW9uKGN0eCwgc2Vzc2lvbl9pZCkgPCAwKSB7CisJCQkJZGVidWdfcHJpbnQoY3R4LCAxLCAiRmFpbGVkIHRvIGFkZCAiCisJCQkJCSAgICAic3Vic2NyaXB0aW9uIGludG8gREIiKTsKKwkJCQlyZXQgPSBidWlsZF9zcHBfZXhjaGFuZ2VfY29tcGxldGUoCisJCQkJCWN0eCwgc2Vzc2lvbl9pZCwgIkVycm9yIG9jY3VycmVkIiwKKwkJCQkJIk90aGVyIik7CisJCQkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgdXNlciwgcmVhbG0sCisJCQkJCQkgICBzZXNzaW9uX2lkLCAiRmFpbGVkIHRvICIKKwkJCQkJCSAgICJ1cGRhdGUgZGF0YWJhc2UiLCByZXQpOworCQkJCWRiX3JlbW92ZV9zZXNzaW9uKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQpOworCQkJCXJldHVybiByZXQ7CisJCQl9CisJCX0KKwkJaWYgKG9wZXIgPT0gUE9MSUNZX1JFTUVESUFUSU9OIHx8IG9wZXIgPT0gUE9MSUNZX1VQREFURSkgeworCQkJY2hhciAqdmFsOworCQkJdmFsID0gZGJfZ2V0X3ZhbChjdHgsIHVzZXIsIHJlYWxtLCAicmVtZWRpYXRpb24iLAorCQkJCQkgZG1hY2MpOworCQkJaWYgKHZhbCAmJiBzdHJjbXAodmFsLCAicG9saWN5IikgPT0gMCkKKwkJCQlkYl91cGRhdGVfdmFsKGN0eCwgdXNlciwgcmVhbG0sICJyZW1lZGlhdGlvbiIsCisJCQkJCSAgICAgICIiLCBkbWFjYyk7CisJCQlmcmVlKHZhbCk7CisJCX0KKwkJcmV0ID0gYnVpbGRfc3BwX2V4Y2hhbmdlX2NvbXBsZXRlKAorCQkJY3R4LCBzZXNzaW9uX2lkLAorCQkJIkV4Y2hhbmdlIGNvbXBsZXRlLCByZWxlYXNlIFRMUyBjb25uZWN0aW9uIiwgTlVMTCk7CisJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLAorCQkJCSAgICJFeGNoYW5nZSBjb21wbGV0ZWQiLCByZXQpOworCQlkYl9yZW1vdmVfc2Vzc2lvbihjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXQgPSBidWlsZF9zcHBfZXhjaGFuZ2VfY29tcGxldGUoY3R4LCBzZXNzaW9uX2lkLCAiRXJyb3Igb2NjdXJyZWQiLAorCQkJCQkgICJPdGhlciIpOworCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIHVzZXIsIHJlYWxtLCBzZXNzaW9uX2lkLCAiRXJyb3Igb2NjdXJyZWQiLCByZXQpOworCWRiX3JlbW92ZV9zZXNzaW9uKGN0eCwgdXNlciwgcmVhbG0sIHNlc3Npb25faWQpOworCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHN0YXR1cyk7CisJcmV0dXJuIHJldDsKK30KKworCisjZGVmaW5lIFNQUF9TRVNTSU9OX0lEX0xFTiAxNgorCitzdGF0aWMgY2hhciAqIGdlbl9zcHBfc2Vzc2lvbl9pZCh2b2lkKQoreworCUZJTEUgKmY7CisJaW50IGk7CisJY2hhciAqc2Vzc2lvbjsKKworCXNlc3Npb24gPSBvc19tYWxsb2MoU1BQX1NFU1NJT05fSURfTEVOICogMiArIDEpOworCWlmIChzZXNzaW9uID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZiA9IGZvcGVuKCIvZGV2L3VyYW5kb20iLCAiciIpOworCWlmIChmID09IE5VTEwpIHsKKwkJb3NfZnJlZShzZXNzaW9uKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCWZvciAoaSA9IDA7IGkgPCBTUFBfU0VTU0lPTl9JRF9MRU47IGkrKykKKwkJb3Nfc25wcmludGYoc2Vzc2lvbiArIGkgKiAyLCAzLCAiJTAyeCIsIGZnZXRjKGYpKTsKKworCWZjbG9zZShmKTsKKwlyZXR1cm4gc2Vzc2lvbjsKK30KKworeG1sX25vZGVfdCAqIGhzMjBfc3BwX3NlcnZlcl9wcm9jZXNzKHN0cnVjdCBoczIwX3N2YyAqY3R4LCB4bWxfbm9kZV90ICpub2RlLAorCQkJCSAgICAgY29uc3QgY2hhciAqYXV0aF91c2VyLAorCQkJCSAgICAgY29uc3QgY2hhciAqYXV0aF9yZWFsbSwgaW50IGRtYWNjKQoreworCXhtbF9ub2RlX3QgKnJldCA9IE5VTEw7CisJY2hhciAqc2Vzc2lvbl9pZDsKKwljb25zdCBjaGFyICpvcF9uYW1lOworCWNoYXIgKnhtbF9lcnI7CisJY2hhciBmbmFtZVsyMDBdOworCisJZGVidWdfZHVtcF9ub2RlKGN0eCwgInJlY2VpdmVkIHJlcXVlc3QiLCBub2RlKTsKKworCWlmICghZG1hY2MgJiYgYXV0aF91c2VyICYmIGF1dGhfcmVhbG0pIHsKKwkJY2hhciAqcmVhbDsKKwkJcmVhbCA9IGRiX2dldF92YWwoY3R4LCBhdXRoX3VzZXIsIGF1dGhfcmVhbG0sICJpZGVudGl0eSIsIDApOworCQlpZiAoIXJlYWwpIHsKKwkJCXJlYWwgPSBkYl9nZXRfdmFsKGN0eCwgYXV0aF91c2VyLCBhdXRoX3JlYWxtLAorCQkJCQkgICJpZGVudGl0eSIsIDEpOworCQkJaWYgKHJlYWwpCisJCQkJZG1hY2MgPSAxOworCQl9CisJCW9zX2ZyZWUocmVhbCk7CisJfQorCisJc25wcmludGYoZm5hbWUsIHNpemVvZihmbmFtZSksICIlcy9zcHAvc3BwLnhzZCIsIGN0eC0+cm9vdF9kaXIpOworCWlmICh4bWxfdmFsaWRhdGUoY3R4LT54bWwsIG5vZGUsIGZuYW1lLCAmeG1sX2VycikgPCAwKSB7CisJCS8qCisJCSAqIFdlIG1heSBub3QgYmUgYWJsZSB0byBleHRyYWN0IHRoZSBzZXNzaW9uSUQgZnJvbSBpbnZhbGlkCisJCSAqIGlucHV0LCBidXQgd2VsbCwgd2UgY2FuIHRyeS4KKwkJICovCisJCXNlc3Npb25faWQgPSB4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9ucyhjdHgtPnhtbCwgbm9kZSwKKwkJCQkJCQlTUFBfTlNfVVJJLAorCQkJCQkJCSJzZXNzaW9uSUQiKTsKKwkJZGVidWdfcHJpbnQoY3R4LCAxLCAiU1BQIG1lc3NhZ2UgZmFpbGVkIHZhbGlkYXRpb24iKTsKKwkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgYXV0aF91c2VyLCBhdXRoX3JlYWxtLCBzZXNzaW9uX2lkLAorCQkJCSAgICJTUFAgbWVzc2FnZSBmYWlsZWQgdmFsaWRhdGlvbiIsIG5vZGUpOworCQloczIwX2V2ZW50bG9nKGN0eCwgYXV0aF91c2VyLCBhdXRoX3JlYWxtLCBzZXNzaW9uX2lkLAorCQkJICAgICAgIlZhbGlkYXRpb24gZXJyb3JzIiwgeG1sX2Vycik7CisJCW9zX2ZyZWUoeG1sX2Vycik7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHNlc3Npb25faWQpOworCQkvKiBUT0RPOiB3aGF0IHRvIHJldHVybiBoZXJlPyAqLworCQlyZXQgPSB4bWxfbm9kZV9jcmVhdGVfcm9vdChjdHgtPnhtbCwgTlVMTCwgTlVMTCwgTlVMTCwKKwkJCQkJICAgIlNwcFZhbGlkYXRpb25FcnJvciIpOworCQlyZXR1cm4gcmV0OworCX0KKworCXNlc3Npb25faWQgPSB4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9ucyhjdHgtPnhtbCwgbm9kZSwgU1BQX05TX1VSSSwKKwkJCQkJCSJzZXNzaW9uSUQiKTsKKwlpZiAoc2Vzc2lvbl9pZCkgeworCQljaGFyICp0bXA7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIlJlY2VpdmVkIHNlc3Npb25JRCAlcyIsIHNlc3Npb25faWQpOworCQl0bXAgPSBvc19zdHJkdXAoc2Vzc2lvbl9pZCk7CisJCXhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoY3R4LT54bWwsIHNlc3Npb25faWQpOworCQlpZiAodG1wID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKwkJc2Vzc2lvbl9pZCA9IHRtcDsKKwl9IGVsc2UgeworCQlzZXNzaW9uX2lkID0gZ2VuX3NwcF9zZXNzaW9uX2lkKCk7CisJCWlmIChzZXNzaW9uX2lkID09IE5VTEwpIHsKKwkJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkZhaWxlZCB0byBnZW5lcmF0ZSBzZXNzaW9uSUQiKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIkdlbmVyYXRlZCBzZXNzaW9uSUQgJXMiLCBzZXNzaW9uX2lkKTsKKwl9CisKKwlvcF9uYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgbm9kZSk7CisJaWYgKG9wX25hbWUgPT0gTlVMTCkgeworCQlkZWJ1Z19wcmludChjdHgsIDEsICJDb3VsZCBub3QgZ2V0IG9wX25hbWUiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaWYgKHN0cmNtcChvcF9uYW1lLCAic3BwUG9zdERldkRhdGEiKSA9PSAwKSB7CisJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIGF1dGhfdXNlciwgYXV0aF9yZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAic3BwUG9zdERldkRhdGEgcmVjZWl2ZWQgYW5kIHZhbGlkYXRlZCIsCisJCQkJICAgbm9kZSk7CisJCXJldCA9IGhzMjBfc3BwX3Bvc3RfZGV2X2RhdGEoY3R4LCBub2RlLCBhdXRoX3VzZXIsIGF1dGhfcmVhbG0sCisJCQkJCSAgICAgc2Vzc2lvbl9pZCwgZG1hY2MpOworCX0gZWxzZSBpZiAoc3RyY21wKG9wX25hbWUsICJzcHBVcGRhdGVSZXNwb25zZSIpID09IDApIHsKKwkJaHMyMF9ldmVudGxvZ19ub2RlKGN0eCwgYXV0aF91c2VyLCBhdXRoX3JlYWxtLCBzZXNzaW9uX2lkLAorCQkJCSAgICJzcHBVcGRhdGVSZXNwb25zZSByZWNlaXZlZCBhbmQgdmFsaWRhdGVkIiwKKwkJCQkgICBub2RlKTsKKwkJcmV0ID0gaHMyMF9zcHBfdXBkYXRlX3Jlc3BvbnNlKGN0eCwgbm9kZSwgYXV0aF91c2VyLAorCQkJCQkgICAgICAgYXV0aF9yZWFsbSwgc2Vzc2lvbl9pZCwgZG1hY2MpOworCX0gZWxzZSB7CisJCWhzMjBfZXZlbnRsb2dfbm9kZShjdHgsIGF1dGhfdXNlciwgYXV0aF9yZWFsbSwgc2Vzc2lvbl9pZCwKKwkJCQkgICAiVW5zdXBwb3J0ZWQgU1BQIG1lc3NhZ2UgcmVjZWl2ZWQgYW5kICIKKwkJCQkgICAidmFsaWRhdGVkIiwgbm9kZSk7CisJCWRlYnVnX3ByaW50KGN0eCwgMSwgIlVuc3VwcG9ydGVkIG9wZXJhdGlvbiAnJXMnIiwgb3BfbmFtZSk7CisJCS8qIFRPRE86IHdoYXQgdG8gcmV0dXJuIGhlcmU/ICovCisJCXJldCA9IHhtbF9ub2RlX2NyZWF0ZV9yb290KGN0eC0+eG1sLCBOVUxMLCBOVUxMLCBOVUxMLAorCQkJCQkgICAiU3BwVW5rbm93bkNvbW1hbmRFcnJvciIpOworCX0KKwlvc19mcmVlKHNlc3Npb25faWQpOworCisJaWYgKHJldCA9PSBOVUxMKSB7CisJCS8qIFRPRE86IHdoYXQgdG8gcmV0dXJuIGhlcmU/ICovCisJCXJldCA9IHhtbF9ub2RlX2NyZWF0ZV9yb290KGN0eC0+eG1sLCBOVUxMLCBOVUxMLCBOVUxMLAorCQkJCQkgICAiU3BwSW50ZXJuYWxFcnJvciIpOworCX0KKworCXJldHVybiByZXQ7Cit9CisKKworaW50IGhzMjBfc3BwX3NlcnZlcl9pbml0KHN0cnVjdCBoczIwX3N2YyAqY3R4KQoreworCWNoYXIgZm5hbWVbMjAwXTsKKwljdHgtPmRiID0gTlVMTDsKKwlzbnByaW50ZihmbmFtZSwgc2l6ZW9mKGZuYW1lKSwgIiVzL0FTL0RCL2VhcF91c2VyLmRiIiwgY3R4LT5yb290X2Rpcik7CisJaWYgKHNxbGl0ZTNfb3BlbihmbmFtZSwgJmN0eC0+ZGIpKSB7CisJCXByaW50ZigiRmFpbGVkIHRvIG9wZW4gc3FsaXRlIGRhdGFiYXNlOiAlc1xuIiwKKwkJICAgICAgIHNxbGl0ZTNfZXJybXNnKGN0eC0+ZGIpKTsKKwkJc3FsaXRlM19jbG9zZShjdHgtPmRiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCisKK3ZvaWQgaHMyMF9zcHBfc2VydmVyX2RlaW5pdChzdHJ1Y3QgaHMyMF9zdmMgKmN0eCkKK3sKKwlzcWxpdGUzX2Nsb3NlKGN0eC0+ZGIpOworCWN0eC0+ZGIgPSBOVUxMOworfQpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvc3BwX3NlcnZlci5oIGIvaHMyMC9zZXJ2ZXIvc3BwX3NlcnZlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdiMjdiZTMKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9zcHBfc2VydmVyLmgKQEAgLTAsMCArMSwzMiBAQAorLyoKKyAqIEhvdHNwb3QgMi4wIFNQUCBzZXJ2ZXIKKyAqIENvcHlyaWdodCAoYykgMjAxMi0yMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIFNQUF9TRVJWRVJfSAorI2RlZmluZSBTUFBfU0VSVkVSX0gKKworc3RydWN0IGhzMjBfc3ZjIHsKKwljb25zdCB2b2lkICpjdHg7CisJc3RydWN0IHhtbF9ub2RlX2N0eCAqeG1sOworCWNoYXIgKnJvb3RfZGlyOworCUZJTEUgKmRlYnVnX2xvZzsKKwlzcWxpdGUzICpkYjsKKwljb25zdCBjaGFyICphZGRyOworfTsKKworCit2b2lkIGRlYnVnX3ByaW50KHN0cnVjdCBoczIwX3N2YyAqY3R4LCBpbnQgcHJpbnQsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQorCV9fYXR0cmlidXRlX18gKChmb3JtYXQgKHByaW50ZiwgMywgNCkpKTsKK3ZvaWQgZGVidWdfZHVtcF9ub2RlKHN0cnVjdCBoczIwX3N2YyAqY3R4LCBjb25zdCBjaGFyICp0aXRsZSwgeG1sX25vZGVfdCAqbm9kZSk7CisKK3htbF9ub2RlX3QgKiBoczIwX3NwcF9zZXJ2ZXJfcHJvY2VzcyhzdHJ1Y3QgaHMyMF9zdmMgKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKmF1dGhfdXNlciwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKmF1dGhfcmVhbG0sIGludCBkbWFjYyk7CitpbnQgaHMyMF9zcHBfc2VydmVyX2luaXQoc3RydWN0IGhzMjBfc3ZjICpjdHgpOwordm9pZCBoczIwX3NwcF9zZXJ2ZXJfZGVpbml0KHN0cnVjdCBoczIwX3N2YyAqY3R4KTsKKworI2VuZGlmIC8qIFNQUF9TRVJWRVJfSCAqLwpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvc3FsLWV4YW1wbGUudHh0IGIvaHMyMC9zZXJ2ZXIvc3FsLWV4YW1wbGUudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjIwZGNmMmYKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9zcWwtZXhhbXBsZS50eHQKQEAgLTAsMCArMSwxNyBAQAorSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ2ZxZG4nLCdleGFtcGxlLmNvbScpOworSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ2ZyaWVuZGx5X25hbWUnLCdFeGFtcGxlIE9wZXJhdG9yJyk7CitJTlNFUlQgSU5UTyBvc3VfY29uZmlnKHJlYWxtLGZpZWxkLHZhbHVlKSBWQUxVRVMoJ2V4YW1wbGUuY29tJywnc3BwX2h0dHBfYXV0aF91cmwnLCdodHRwczovL3N1YnNjcmlwdGlvbi1zZXJ2ZXIub3N1LmV4YW1wbGUuY29tL2hzMjAvc3BwLnBocD9yZWFsbT1leGFtcGxlLmNvbScpOworSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ3RydXN0X3Jvb3RfY2VydF91cmwnLCdodHRwczovL29zdS1zZXJ2ZXIub3N1LmV4YW1wbGUuY29tL2hzMjAvZmlsZXMvc3BwLXJvb3QtY2EuZGVyJyk7CitJTlNFUlQgSU5UTyBvc3VfY29uZmlnKHJlYWxtLGZpZWxkLHZhbHVlKSBWQUxVRVMoJ2V4YW1wbGUuY29tJywndHJ1c3Rfcm9vdF9jZXJ0X2ZpbmdlcnByaW50JywnNWIzOTNhOTI0Njg2NTU2OTQ4NWMyNjA1YzMzMDRlNDgyMTJiNDQ5MzY3ODU4Mjk5YmViYTkzODRjNGNmNDY0NycpOworSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ2FhYV90cnVzdF9yb290X2NlcnRfdXJsJywnaHR0cHM6Ly9vc3Utc2VydmVyLm9zdS5leGFtcGxlLmNvbS9oczIwL2ZpbGVzL2FhYS1yb290LWNhLmRlcicpOworSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ2FhYV90cnVzdF9yb290X2NlcnRfZmluZ2VycHJpbnQnLCc1YjM5M2E5MjQ2ODY1NTY5NDg1YzI2MDVjMzMwNGU0ODIxMmI0NDkzNjc4NTgyOTliZWJhOTM4NGM0Y2Y0NjQ3Jyk7CitJTlNFUlQgSU5UTyBvc3VfY29uZmlnKHJlYWxtLGZpZWxkLHZhbHVlKSBWQUxVRVMoJ2V4YW1wbGUuY29tJywnZnJlZV9hY2NvdW50JywnZnJlZScpOworSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ3BvbGljeV91cmwnLCdodHRwczovL3N1YnNjcmlwdGlvbi1zZXJ2ZXIub3N1LmV4YW1wbGUuY29tL2hzMjAvc3BwLnBocD9yZWFsbT1leGFtcGxlLmNvbScpOworSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ3JlbWVkaWF0aW9uX3VybCcsJ2h0dHBzOi8vc3Vic2NyaXB0aW9uLXNlcnZlci5vc3UuZXhhbXBsZS5jb20vaHMyMC9yZW1lZGlhdGlvbi5waHA/c2Vzc2lvbl9pZD0nKTsKK0lOU0VSVCBJTlRPIG9zdV9jb25maWcocmVhbG0sZmllbGQsdmFsdWUpIFZBTFVFUygnZXhhbXBsZS5jb20nLCdmcmVlX3JlbWVkaWF0aW9uX3VybCcsJ2h0dHBzOi8vc3Vic2NyaXB0aW9uLXNlcnZlci5vc3UuZXhhbXBsZS5jb20vaHMyMC9mcmVlLXJlbWVkaWF0aW9uLnBocD9zZXNzaW9uX2lkPScpOworSU5TRVJUIElOVE8gb3N1X2NvbmZpZyhyZWFsbSxmaWVsZCx2YWx1ZSkgVkFMVUVTKCdleGFtcGxlLmNvbScsJ3NpZ251cF91cmwnLCdodHRwczovL3N1YnNjcmlwdGlvbi1zZXJ2ZXIub3N1LmV4YW1wbGUuY29tL2hzMjAvc2lnbnVwLnBocD9zZXNzaW9uX2lkPScpOworCisKK0lOU0VSVCBJTlRPIHVzZXJzKGlkZW50aXR5LHJlYWxtLG1ldGhvZHMscGFzc3dvcmQscGhhc2UyLHNoYXJlZCkgVkFMVUVTKCdmcmVlJywnZXhhbXBsZS5jb20nLCdUVExTLU1TQ0hBUFYyJywnZnJlZScsMSwxKTsKKworSU5TRVJUIElOVE8gd2lsZGNhcmRzKGlkZW50aXR5LG1ldGhvZHMpIFZBTFVFUygnJywnVFRMUyxUTFMnKTsKZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL3NxbC50eHQgYi9oczIwL3NlcnZlci9zcWwudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY2MDk1MzgKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci9zcWwudHh0CkBAIC0wLDAgKzEsNTkgQEAKK0NSRUFURSBUQUJMRSBldmVudGxvZygKKwl1c2VyIFRFWFQsCisJcmVhbG0gVEVYVCwKKwlzZXNzaW9uaWQgVEVYVCBDT0xMQVRFIE5PQ0FTRSwKKwl0aW1lc3RhbXAgVEVYVCwKKwlub3RlcyBURVhULAorCWR1bXAgVEVYVCwKKwlhZGRyIFRFWFQKKyk7CisKK0NSRUFURSBUQUJMRSBzZXNzaW9ucygKKwl0aW1lc3RhbXAgVEVYVCwKKwlpZCBURVhUIENPTExBVEUgTk9DQVNFLAorCXVzZXIgVEVYVCwKKwlyZWFsbSBURVhULAorCXBhc3N3b3JkIFRFWFQsCisJbWFjaGluZV9tYW5hZ2VkIEJPT0xFQU4sCisJb3BlcmF0aW9uIElOVEVHRVIsCisJdHlwZSBURVhULAorCXBwcyBURVhULAorCXJlZGlyZWN0X3VyaSBURVhULAorCWRldmluZm8gVEVYVCwKKwlkZXZkZXRhaWwgVEVYVCwKKwljZXJ0IFRFWFQsCisJY2VydF9wZW0gVEVYVAorKTsKKworQ1JFQVRFIGluZGV4IHNlc3Npb25zX2lkX2luZGV4IE9OIHNlc3Npb25zKGlkKTsKKworQ1JFQVRFIFRBQkxFIG9zdV9jb25maWcoCisgICAgICAgcmVhbG0gVEVYVCwKKyAgICAgICBmaWVsZCBURVhULAorICAgICAgIHZhbHVlIFRFWFQKKyk7CisKK0NSRUFURSBUQUJMRSB1c2VycygKKwlpZGVudGl0eSBURVhUIFBSSU1BUlkgS0VZLAorCW1ldGhvZHMgVEVYVCwKKwlwYXNzd29yZCBURVhULAorCW1hY2hpbmVfbWFuYWdlZCBCT09MRUFOLAorCXJlbWVkaWF0aW9uIFRFWFQsCisJcGhhc2UyIElOVEVHRVIsCisJcmVhbG0gVEVYVCwKKwlwb2xpY3kgVEVYVCwKKwlkZXZpbmZvIFRFWFQsCisJZGV2ZGV0YWlsIFRFWFQsCisJcHBzIFRFWFQsCisJZmV0Y2hfcHBzIElOVEVHRVIsCisJb3N1X3VzZXIgVEVYVCwKKwlvc3VfcGFzc3dvcmQgVEVYVCwKKwlzaGFyZWQgSU5URUdFUiwKKwljZXJ0IFRFWFQsCisJY2VydF9wZW0gVEVYVAorKTsKKworQ1JFQVRFIFRBQkxFIHdpbGRjYXJkcygKKwlpZGVudGl0eSBURVhUIFBSSU1BUlkgS0VZLAorCW1ldGhvZHMgVEVYVAorKTsKZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL3d3dy9hZGQtZnJlZS5waHAgYi9oczIwL3NlcnZlci93d3cvYWRkLWZyZWUucGhwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjFlZmM2NTUKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci93d3cvYWRkLWZyZWUucGhwCkBAIC0wLDAgKzEsNTAgQEAKKzw/cGhwCisKK3JlcXVpcmUoJ2NvbmZpZy5waHAnKTsKKworJGRiID0gbmV3IFBETygkb3N1X2RiKTsKK2lmICghJGRiKSB7CisgICBkaWUoJHNxbGl0ZWVycm9yKTsKK30KKworaWYgKGlzc2V0KCRfUE9TVFsiaWQiXSkpCisgICRpZCA9IHByZWdfcmVwbGFjZSgiL1teYS1mQS1GMC05XS8iLCAiIiwgJF9QT1NUWyJpZCJdKTsKK2Vsc2UKKyAgZGllKCJNaXNzaW5nIHNlc3Npb24gaWQiKTsKK2lmIChzdHJsZW4oJGlkKSA8IDMyKQorICBkaWUoIkludmFsaWQgc2Vzc2lvbiBpZCIpOworCiskcm93ID0gJGRiLT5xdWVyeSgiU0VMRUNUIHJvd2lkLCogRlJPTSBzZXNzaW9ucyBXSEVSRSBpZD0nJGlkJyIpLT5mZXRjaCgpOworaWYgKCRyb3cgPT0gZmFsc2UpIHsKKyAgIGRpZSgiU2Vzc2lvbiBub3QgZm91bmQiKTsKK30KKworJHVyaSA9ICRyb3dbJ3JlZGlyZWN0X3VyaSddOworJHJvd2lkID0gJHJvd1sncm93aWQnXTsKKyRyZWFsbSA9ICRyb3dbJ3JlYWxtJ107CisKKyRyb3cgPSAkZGItPnF1ZXJ5KCJTRUxFQ1QgdmFsdWUgRlJPTSBvc3VfY29uZmlnIFdIRVJFIHJlYWxtPSckcmVhbG0nIEFORCBmaWVsZD0nZnJlZV9hY2NvdW50JyIpLT5mZXRjaCgpOworaWYgKCEkcm93IHx8IHN0cmxlbigkcm93Wyd2YWx1ZSddKSA9PSAwKSB7CisgIGRpZSgiRnJlZSBhY2NvdW50IGRpc2FibGVkIik7Cit9CisKKyR1c2VyID0gJHJvd1sndmFsdWUnXTsKKworJHJvdyA9ICRkYi0+cXVlcnkoIlNFTEVDVCBwYXNzd29yZCBGUk9NIHVzZXJzIFdIRVJFIGlkZW50aXR5PSckdXNlcicgQU5EIHJlYWxtPSckcmVhbG0nIiktPmZldGNoKCk7CitpZiAoISRyb3cpCisgIGRpZSgiRnJlZSBhY2NvdW50IG5vdCBmb3VuZCIpOworCiskcHcgPSAkcm93WydwYXNzd29yZCddOworCitpZiAoISRkYi0+ZXhlYygiVVBEQVRFIHNlc3Npb25zIFNFVCB1c2VyPSckdXNlcicsIHBhc3N3b3JkPSckcHcnLCByZWFsbT0nJHJlYWxtJywgbWFjaGluZV9tYW5hZ2VkPScxJyBXSEVSRSByb3dpZD0kcm93aWQiKSkgeworICBkaWUoIkZhaWxlZCB0byB1cGRhdGUgc2Vzc2lvbiBkYXRhYmFzZSIpOworfQorCiskZGItPmV4ZWMoIklOU0VSVCBJTlRPIGV2ZW50bG9nKHVzZXIscmVhbG0sc2Vzc2lvbmlkLHRpbWVzdGFtcCxub3RlcykgIiAuCisJIlZBTFVFUyAoJyR1c2VyJywgJyRyZWFsbScsICckaWQnLCAiIC4KKwkic3RyZnRpbWUoJyVZLSVtLSVkICVIOiVNOiVmJywnbm93JyksICIgLgorCSInY29tcGxldGVkIHVzZXIgaW5wdXQgcmVzcG9uc2UgZm9yIGEgbmV3IFBQUyBNTycpIik7CisKK2hlYWRlcigiTG9jYXRpb246ICR1cmkiLCB0cnVlLCAzMDIpOworCis/PgpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvd3d3L2FkZC1tby5waHAgYi9oczIwL3NlcnZlci93d3cvYWRkLW1vLnBocApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hM2I0NTEzCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvd3d3L2FkZC1tby5waHAKQEAgLTAsMCArMSw1NiBAQAorPD9waHAKKworcmVxdWlyZSgnY29uZmlnLnBocCcpOworCiskZGIgPSBuZXcgUERPKCRvc3VfZGIpOworaWYgKCEkZGIpIHsKKyAgIGRpZSgkc3FsaXRlZXJyb3IpOworfQorCitpZiAoaXNzZXQoJF9QT1NUWyJpZCJdKSkKKyAgJGlkID0gcHJlZ19yZXBsYWNlKCIvW15hLWZBLUYwLTldLyIsICIiLCAkX1BPU1RbImlkIl0pOworZWxzZQorICBkaWUoIk1pc3Npbmcgc2Vzc2lvbiBpZCIpOworCiskdXNlciA9ICRfUE9TVFsidXNlciJdOworJHB3ID0gJF9QT1NUWyJwYXNzd29yZCJdOworaWYgKHN0cmxlbigkaWQpIDwgMzIgfHwgIWlzc2V0KCR1c2VyKSB8fCAhaXNzZXQoJHB3KSkgeworICBkaWUoIkludmFsaWQgUE9TVCBkYXRhIik7Cit9CisKK2lmIChzdHJsZW4oJHVzZXIpIDwgMSB8fCBzdHJuY2FzZWNtcCgkdXNlciwgImNlcnQtIiwgNSkgPT0gMCkgeworICBlY2hvICI8aHRtbD48Ym9keT48cD48cmVkPkludmFsaWQgdXNlcm5hbWU8L3JlZD48L3A+XG4iOworICBlY2hvICI8YSBocmVmPVwic2lnbnVwLnBocD9zZXNzaW9uX2lkPSRpZFwiPlRyeSBhZ2FpbjwvYT5cbiI7CisgIGVjaG8gIjwvYm9keT48L2h0bWw+XG4iOworICBleGl0OworfQorCiskcm93ID0gJGRiLT5xdWVyeSgiU0VMRUNUIHJvd2lkLCogRlJPTSBzZXNzaW9ucyBXSEVSRSBpZD0nJGlkJyIpLT5mZXRjaCgpOworaWYgKCRyb3cgPT0gZmFsc2UpIHsKKyAgIGRpZSgiU2Vzc2lvbiBub3QgZm91bmQiKTsKK30KKyRyZWFsbSA9ICRyb3dbJ3JlYWxtJ107CisKKyR1c2Vycm93ID0gJGRiLT5xdWVyeSgiU0VMRUNUIGlkZW50aXR5IEZST00gdXNlcnMgV0hFUkUgaWRlbnRpdHk9JyR1c2VyJyBBTkQgcmVhbG09JyRyZWFsbSciKS0+ZmV0Y2goKTsKK2lmICgkdXNlcnJvdykgeworICBlY2hvICI8aHRtbD48Ym9keT48cD48cmVkPlNlbGVjdGVkIHVzZXJuYW1lIGlzIG5vdCBhdmFpbGFibGU8L3JlZD48L3A+XG4iOworICBlY2hvICI8YSBocmVmPVwic2lnbnVwLnBocD9zZXNzaW9uX2lkPSRpZFwiPlRyeSBhZ2FpbjwvYT5cbiI7CisgIGVjaG8gIjwvYm9keT48L2h0bWw+XG4iOworICBleGl0OworfQorCiskdXJpID0gJHJvd1sncmVkaXJlY3RfdXJpJ107Ciskcm93aWQgPSAkcm93Wydyb3dpZCddOworCitpZiAoISRkYi0+ZXhlYygiVVBEQVRFIHNlc3Npb25zIFNFVCB1c2VyPSckdXNlcicsIHBhc3N3b3JkPSckcHcnLCByZWFsbT0nJHJlYWxtJywgdHlwZT0ncGFzc3dvcmQnIFdIRVJFIHJvd2lkPSRyb3dpZCIpKSB7CisgIGRpZSgiRmFpbGVkIHRvIHVwZGF0ZSBzZXNzaW9uIGRhdGFiYXNlIik7Cit9CisKKyRkYi0+ZXhlYygiSU5TRVJUIElOVE8gZXZlbnRsb2codXNlcixyZWFsbSxzZXNzaW9uaWQsdGltZXN0YW1wLG5vdGVzKSAiIC4KKwkiVkFMVUVTICgnJHVzZXInLCAnJHJlYWxtJywgJyRpZCcsICIgLgorCSJzdHJmdGltZSgnJVktJW0tJWQgJUg6JU06JWYnLCdub3cnKSwgIiAuCisJIidjb21wbGV0ZWQgdXNlciBpbnB1dCByZXNwb25zZSBmb3IgYSBuZXcgUFBTIE1PJykiKTsKKworaGVhZGVyKCJMb2NhdGlvbjogJHVyaSIsIHRydWUsIDMwMik7CisKKz8+CmRpZmYgLS1naXQgYS9oczIwL3NlcnZlci93d3cvY2VydC1lbnJvbGwucGhwIGIvaHMyMC9zZXJ2ZXIvd3d3L2NlcnQtZW5yb2xsLnBocApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mMDIzY2E1Ci0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvd3d3L2NlcnQtZW5yb2xsLnBocApAQCAtMCwwICsxLDM5IEBACis8P3BocAorCityZXF1aXJlKCdjb25maWcucGhwJyk7CisKKyRkYiA9IG5ldyBQRE8oJG9zdV9kYik7CitpZiAoISRkYikgeworICAgZGllKCRzcWxpdGVlcnJvcik7Cit9CisKK2lmIChpc3NldCgkX0dFVFsiaWQiXSkpCisgICRpZCA9IHByZWdfcmVwbGFjZSgiL1teYS1mQS1GMC05XS8iLCAiIiwgJF9HRVRbImlkIl0pOworZWxzZQorICBkaWUoIk1pc3Npbmcgc2Vzc2lvbiBpZCIpOworaWYgKHN0cmxlbigkaWQpIDwgMzIpCisgIGRpZSgiSW52YWxpZCBzZXNzaW9uIGlkIik7CisKKyRyb3cgPSAkZGItPnF1ZXJ5KCJTRUxFQ1Qgcm93aWQsKiBGUk9NIHNlc3Npb25zIFdIRVJFIGlkPSckaWQnIiktPmZldGNoKCk7CitpZiAoJHJvdyA9PSBmYWxzZSkgeworICAgZGllKCJTZXNzaW9uIG5vdCBmb3VuZCIpOworfQorCiskdXJpID0gJHJvd1sncmVkaXJlY3RfdXJpJ107Ciskcm93aWQgPSAkcm93Wydyb3dpZCddOworJHJlYWxtID0gJHJvd1sncmVhbG0nXTsKKworJHVzZXIgPSBzaGExKG10X3JhbmQoKSk7CisKK2lmICghJGRiLT5leGVjKCJVUERBVEUgc2Vzc2lvbnMgU0VUIHVzZXI9JyR1c2VyJywgdHlwZT0nY2VydCcgV0hFUkUgcm93aWQ9JHJvd2lkIikpIHsKKyAgZGllKCJGYWlsZWQgdG8gdXBkYXRlIHNlc3Npb24gZGF0YWJhc2UiKTsKK30KKworJGRiLT5leGVjKCJJTlNFUlQgSU5UTyBldmVudGxvZyh1c2VyLHJlYWxtLHNlc3Npb25pZCx0aW1lc3RhbXAsbm90ZXMpICIgLgorCSJWQUxVRVMgKCcnLCAnJHJlYWxtJywgJyRpZCcsICIgLgorCSJzdHJmdGltZSgnJVktJW0tJWQgJUg6JU06JWYnLCdub3cnKSwgIiAuCisJIidjb21wbGV0ZWQgdXNlciBpbnB1dCByZXNwb25zZSBmb3IgY2xpZW50IGNlcnRpZmljYXRlIGVucm9sbG1lbnQnKSIpOworCitoZWFkZXIoIkxvY2F0aW9uOiAkdXJpIiwgdHJ1ZSwgMzAyKTsKKworPz4KZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL3d3dy9jb25maWcucGhwIGIvaHMyMC9zZXJ2ZXIvd3d3L2NvbmZpZy5waHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTNhZjQzNQotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL3d3dy9jb25maWcucGhwCkBAIC0wLDAgKzEsNCBAQAorPD9waHAKKyRvc3Vfcm9vdCA9ICIvaG9tZS91c2VyL2hzMjAtc2VydmVyIjsKKyRvc3VfZGIgPSAic3FsaXRlOiRvc3Vfcm9vdC9BUy9EQi9lYXBfdXNlci5kYiI7Cis/PgpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvd3d3L2VzdC5waHAgYi9oczIwL3NlcnZlci93d3cvZXN0LnBocApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hNDU2NDhiCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvd3d3L2VzdC5waHAKQEAgLTAsMCArMSwxOTggQEAKKzw/cGhwCisKK3JlcXVpcmUoJ2NvbmZpZy5waHAnKTsKKworJHBhcmFtcyA9IHNwbGl0KCIvIiwgJF9TRVJWRVJbIlBBVEhfSU5GTyJdLCAzKTsKKyRyZWFsbSA9ICRwYXJhbXNbMV07CiskY21kID0gJHBhcmFtc1syXTsKKyRtZXRob2QgPSAkX1NFUlZFUlsiUkVRVUVTVF9NRVRIT0QiXTsKKwordW5zZXQoJHVzZXIpOwordW5zZXQoJHJvd2lkKTsKKworaWYgKCFlbXB0eSgkX1NFUlZFUlsnUEhQX0FVVEhfRElHRVNUJ10pKSB7CisgICRuZWVkZWQgPSBhcnJheSgnbm9uY2UnPT4xLCAnbmMnPT4xLCAnY25vbmNlJz0+MSwgJ3FvcCc9PjEsICd1c2VybmFtZSc9PjEsCisJCSAgJ3VyaSc9PjEsICdyZXNwb25zZSc9PjEpOworICAkZGF0YSA9IGFycmF5KCk7CisgICRrZXlzID0gaW1wbG9kZSgnfCcsIGFycmF5X2tleXMoJG5lZWRlZCkpOworICBwcmVnX21hdGNoX2FsbCgnQCgnIC4gJGtleXMgLiAnKT0oPzooW1wnIl0pKFteXDJdKz8pXDJ8KFteXHMsXSspKUAnLAorCQkgJF9TRVJWRVJbJ1BIUF9BVVRIX0RJR0VTVCddLCAkbWF0Y2hlcywgUFJFR19TRVRfT1JERVIpOworICBmb3JlYWNoICgkbWF0Y2hlcyBhcyAkbSkgeworICAgICRkYXRhWyRtWzFdXSA9ICRtWzNdID8gJG1bM10gOiAkbVs0XTsKKyAgICB1bnNldCgkbmVlZGVkWyRtWzFdXSk7CisgIH0KKyAgaWYgKCRuZWVkZWQpIHsKKyAgICBlcnJvcl9sb2coIkVTVDogTWlzc2luZyBhdXRoIHBhcmFtZXRlciIpOworICAgIGRpZSgnQXV0aGVudGljYXRpb24gZmFpbGVkJyk7CisgIH0KKyAgJHVzZXIgPSAkZGF0YVsndXNlcm5hbWUnXTsKKyAgaWYgKHN0cmxlbigkdXNlcikgPCAxKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IEVtcHR5IHVzZXJuYW1lIik7CisgICAgZGllKCdBdXRoZW50aWNhdGlvbiBmYWlsZWQnKTsKKyAgfQorCisgICRkYiA9IG5ldyBQRE8oJG9zdV9kYik7CisgIGlmICghJGRiKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IENvdWxkIG5vdCBhY2Nlc3MgZGF0YWJhc2UiKTsKKyAgICBkaWUoIkNvdWxkIG5vdCBhY2Nlc3MgZGF0YWJhc2UiKTsKKyAgfQorCisgICRzcWwgPSAiU0VMRUNUIHJvd2lkLHBhc3N3b3JkLG9wZXJhdGlvbiBGUk9NIHNlc3Npb25zICIgLgorICAgICJXSEVSRSB1c2VyPSckdXNlcicgQU5EIHJlYWxtPSckcmVhbG0nIjsKKyAgJHEgPSAkZGItPnF1ZXJ5KCRzcWwpOworICBpZiAoISRxKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IFNlc3Npb24gbm90IGZvdW5kIGZvciB1c2VyPSR1c2VyIHJlYWxtPSRyZWFsbSIpOworICAgIGRpZSgiU2Vzc2lvbiBub3QgZm91bmQiKTsKKyAgfQorICAkcm93ID0gJHEtPmZldGNoKCk7CisgIGlmICghJHJvdykgeworICAgIGVycm9yX2xvZygiRVNUOiBTZXNzaW9uIGZldGNoIGZhaWxlZCBmb3IgdXNlcj0kdXNlciByZWFsbT0kcmVhbG0iKTsKKyAgICBkaWUoJ1Nlc3Npb24gbm90IGZvdW5kJyk7CisgIH0KKyAgJHJvd2lkID0gJHJvd1sncm93aWQnXTsKKworICAkb3BlciA9ICRyb3dbJ29wZXJhdGlvbiddOworICBpZiAoJG9wZXIgIT0gJzUnKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IFVuZXhwZWN0ZWQgb3BlcmF0aW9uICRvcGVyIGZvciB1c2VyPSR1c2VyIHJlYWxtPSRyZWFsbSIpOworICAgIGRpZSgiU2Vzc2lvbiBub3QgZm91bmQiKTsKKyAgfQorICAkcHcgPSAkcm93WydwYXNzd29yZCddOworICBpZiAoc3RybGVuKCRwdykgPCAxKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IEVtcHR5IHBhc3N3b3JkIGZvciB1c2VyPSR1c2VyIHJlYWxtPSRyZWFsbSIpOworICAgIGRpZSgnQXV0aGVudGljYXRpb24gZmFpbGVkJyk7CisgIH0KKworICAkQTEgPSBtZDUoJHVzZXIgLiAnOicgLiAkcmVhbG0gLiAnOicgLiAkcHcpOworICAkQTIgPSBtZDUoJG1ldGhvZCAuICc6JyAuICRkYXRhWyd1cmknXSk7CisgICRyZXNwID0gbWQ1KCRBMSAuICc6JyAuICRkYXRhWydub25jZSddIC4gJzonIC4gJGRhdGFbJ25jJ10gLiAnOicgLgorCSAgICAgICRkYXRhWydjbm9uY2UnXSAuICc6JyAuICRkYXRhWydxb3AnXSAuICc6JyAuICRBMik7CisgIGlmICgkZGF0YVsncmVzcG9uc2UnXSAhPSAkcmVzcCkgeworICAgIGVycm9yX2xvZygiRVNUOiBJbmNvcnJlY3QgYXV0aGVudGljYXRpb24gcmVzcG9uc2UgZm9yIHVzZXI9JHVzZXIgcmVhbG09JHJlYWxtIik7CisgICAgZGllKCdBdXRoZW50aWNhdGlvbiBmYWlsZWQnKTsKKyAgfQorfQorCisKK2lmICgkbWV0aG9kID09ICJHRVQiICYmICRjbWQgPT0gImNhY2VydHMiKSB7CisgICRmbmFtZSA9ICIkb3N1X3Jvb3QvZXN0LyRyZWFsbS1jYWNlcnRzLnBrY3M3IjsKKyAgaWYgKCFmaWxlX2V4aXN0cygkZm5hbWUpKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IGNhY2VydHMgLSB1bmtub3duIHJlYWxtICRyZWFsbSIpOworICAgIGRpZSgiVW5rbm93biByZWFsbSIpOworICB9CisKKyAgaGVhZGVyKCJDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiBiYXNlNjQiKTsKKyAgaGVhZGVyKCJDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL3BrY3M3LW1pbWUiKTsKKworICAkZGF0YSA9IGZpbGVfZ2V0X2NvbnRlbnRzKCRmbmFtZSk7CisgIGVjaG8gd29yZHdyYXAoYmFzZTY0X2VuY29kZSgkZGF0YSksIDcyLCAiXG4iLCB0cnVlKTsKKyAgZWNobyAiXG4iOworICBlcnJvcl9sb2coIkVTVDogY2FjZXJ0cyIpOworfSBlbHNlIGlmICgkbWV0aG9kID09ICJHRVQiICYmICRjbWQgPT0gImNzcmF0dHJzIikgeworICBoZWFkZXIoIkNvbnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IGJhc2U2NCIpOworICBoZWFkZXIoIkNvbnRlbnQtVHlwZTogYXBwbGljYXRpb24vY3NyYXR0cnMiKTsKKyAgcmVhZGZpbGUoIiRvc3Vfcm9vdC9lc3QvZXN0LWF0dHJzLmI2NCIpOworICBlcnJvcl9sb2coIkVTVDogY3NyYXR0cnMiKTsKK30gZWxzZSBpZiAoJG1ldGhvZCA9PSAiUE9TVCIgJiYgJGNtZCA9PSAic2ltcGxlZW5yb2xsIikgeworICBpZiAoIWlzc2V0KCR1c2VyKSB8fCBzdHJsZW4oJHVzZXIpID09IDApIHsKKyAgICBoZWFkZXIoJ0hUVFAvMS4xIDQwMSBVbmF1dGhvcml6ZWQnKTsKKyAgICBoZWFkZXIoJ1dXVy1BdXRoZW50aWNhdGU6IERpZ2VzdCByZWFsbT0iJy4kcmVhbG0uCisJICAgJyIscW9wPSJhdXRoIixub25jZT0iJy51bmlxaWQoKS4nIixvcGFxdWU9IicubWQ1KCRyZWFsbSkuJyInKTsKKyAgICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIC0gcmVxdWlyZSBhdXRoZW50aWNhdGlvbiIpOworICAgIGRpZSgnQXV0aGVudGljYXRpb24gcmVxdWlyZWQnKTsKKyAgfQorICBpZiAoIWlzc2V0KCRfU0VSVkVSWyJDT05URU5UX1RZUEUiXSkpIHsKKyAgICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIHdpdGhvdXQgQ29udGVudC1UeXBlIik7CisgICAgZGllKCJNaXNzaW5nIENvbnRlbnQtVHlwZSIpOworICB9CisgIGlmICghc3RyaXN0cigkX1NFUlZFUlsiQ09OVEVOVF9UWVBFIl0sICJhcHBsaWNhdGlvbi9wa2NzMTAiKSkgeworICAgIGVycm9yX2xvZygiRVNUOiBzaW1wbGVlbnJvbGwgLSB1bmV4cGVjdGVkIENvbnRlbnQtVHlwZTogIiAuCisJICAgICAgJF9TRVJWRVJbIkNPTlRFTlRfVFlQRSJdKTsKKyAgICBkaWUoIlVuZXhwZWN0ZWQgQ29udGVudC1UeXBlIik7CisgIH0KKworICAkZGF0YSA9IGZpbGVfZ2V0X2NvbnRlbnRzKCJwaHA6Ly9pbnB1dCIpOworICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIC0gUE9TVCBkYXRhIGZyb20gcGhwOi8vaW5wdXQ6ICIgLiAkZGF0YSk7CisgICRyZXEgPSBiYXNlNjRfZGVjb2RlKCRkYXRhKTsKKyAgaWYgKCRyZXEgPT0gRkFMU0UpIHsKKyAgICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIC0gSW52YWxpZCBiYXNlNjQtZW5jb2RlZCBQS0NTIzEwIGRhdGEiKTsKKyAgICBkaWUoIkludmFsaWQgYmFzZTY0LWVuY29kZWQgUEtDUyMxMCBkYXRhIik7CisgIH0KKyAgJGNhZGlyID0gIiRvc3Vfcm9vdC9lc3QiOworICAkcmVxZmlsZSA9ICIkY2FkaXIvdG1wL2NlcnQtcmVxLnBrY3MxMCI7CisgICRmID0gZm9wZW4oJHJlcWZpbGUsICJ3YiIpOworICBmd3JpdGUoJGYsICRyZXEpOworICBmY2xvc2UoJGYpOworCisgICRyZXFfcGVtID0gIiRyZXFmaWxlLnBlbSI7CisgIGlmIChmaWxlX2V4aXN0cygkcmVxX3BlbSkpCisgICAgdW5saW5rKCRyZXFfcGVtKTsKKyAgZXhlYygib3BlbnNzbCByZXEgLWluICRyZXFmaWxlIC1pbmZvcm0gREVSIC1vdXQgJHJlcV9wZW0gLW91dGZvcm0gUEVNIik7CisgIGlmICghZmlsZV9leGlzdHMoJHJlcV9wZW0pKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IHNpbXBsZWVucm9sbCAtIEZhaWxlZCB0byBwYXJzZSBjZXJ0aWZpY2F0ZSByZXF1ZXN0Iik7CisgICAgZGllKCJGYWlsZWQgdG8gcGFyc2UgY2VydGlmaWNhdGUgcmVxdWVzdCIpOworICB9CisKKyAgLyogRklYOiB2YWxpZGF0ZSByZXF1ZXN0IGFuZCBhZGQgSFMgMi4wIGV4dGVuc2lvbnMgdG8gY2VydCAqLworICAkY2VydF9wZW0gPSAiJGNhZGlyL3RtcC9yZXEtc2lnbmVkLnBlbSI7CisgIGlmIChmaWxlX2V4aXN0cygkY2VydF9wZW0pKQorICAgIHVubGluaygkY2VydF9wZW0pOworICBleGVjKCJvcGVuc3NsIHg1MDkgLXJlcSAtaW4gJHJlcV9wZW0gLUNBa2V5ICRjYWRpci9jYWtleS5wZW0gLW91dCAkY2VydF9wZW0gLUNBICRjYWRpci9jYWNlcnQucGVtIC1DQXNlcmlhbCAkY2FkaXIvc2VyaWFsIC1kYXlzIDM2NSAtdGV4dCIpOworICBpZiAoIWZpbGVfZXhpc3RzKCRjZXJ0X3BlbSkpIHsKKyAgICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIC0gRmFpbGVkIHRvIHNpZ24gY2VydGlmaWNhdGUiKTsKKyAgICBkaWUoIkZhaWxlZCB0byBzaWduIGNlcnRpZmljYXRlIik7CisgIH0KKworICAkY2VydCA9IGZpbGVfZ2V0X2NvbnRlbnRzKCRjZXJ0X3BlbSk7CisgICRoYW5kbGUgPSBwb3Blbigib3BlbnNzbCB4NTA5IC1pbiAkY2VydF9wZW0gLXNlcmlhbCAtbm9vdXQiLCAiciIpOworICAkc2VyaWFsID0gZnJlYWQoJGhhbmRsZSwgMjAwKTsKKyAgcGNsb3NlKCRoYW5kbGUpOworICAkcGF0dGVybiA9ICIvc2VyaWFsPSg/UDxzbmhleD5bMC05YS1mQS1GOl0qKS9tIjsKKyAgcHJlZ19tYXRjaCgkcGF0dGVybiwgJHNlcmlhbCwgJG1hdGNoZXMpOworICBpZiAoIWlzc2V0KCRtYXRjaGVzWydzbmhleCddKSB8fCBzdHJsZW4oJG1hdGNoZXNbJ3NuaGV4J10pIDwgMSkgeworICAgIGVycm9yX2xvZygiRVNUOiBzaW1wbGVlbnJvbGwgLSBDb3VsZCBub3QgZ2V0IHNlcmlhbCBudW1iZXIiKTsKKyAgICBkaWUoIkNvdWxkIG5vdCBnZXQgc2VyaWFsIG51bWJlciIpOworICB9CisgICRzbiA9IHN0cl9yZXBsYWNlKCI6IiwgIiIsIHN0cnRvdXBwZXIoJG1hdGNoZXNbJ3NuaGV4J10pKTsKKworICAkdXNlciA9ICJjZXJ0LSRzbiI7CisgIGVycm9yX2xvZygiRVNUOiB1c2VyID0gJHVzZXIiKTsKKworICAkY2VydF9kZXIgPSAiJGNhZGlyL3RtcC9yZXEtc2lnbmVkLmRlciI7CisgIGlmIChmaWxlX2V4aXN0cygkY2VydF9kZXIpKQorICAgIHVubGluaygkY2VydF9kZXIpOworICBleGVjKCJvcGVuc3NsIHg1MDkgLWluICRjZXJ0X3BlbSAtaW5mb3JtIFBFTSAtb3V0ICRjZXJ0X2RlciAtb3V0Zm9ybSBERVIiKTsKKyAgaWYgKCFmaWxlX2V4aXN0cygkY2VydF9kZXIpKSB7CisgICAgZXJyb3JfbG9nKCJFU1Q6IHNpbXBsZWVucm9sbCAtIEZhaWxlZCB0byBjb252ZXJ0IGNlcnRpZmljYXRlIik7CisgICAgZGllKCJGYWlsZWQgdG8gY29udmVydCBjZXJ0aWZpY2F0ZSIpOworICB9CisgICRkZXIgPSBmaWxlX2dldF9jb250ZW50cygkY2VydF9kZXIpOworICAkZmluZ2VycHJpbnQgPSBoYXNoKCJzaGEyNTYiLCAkZGVyKTsKKworICAkcGtjczcgPSAiJGNhZGlyL3RtcC9lc3QtY2xpZW50LnBrY3M3IjsKKyAgaWYgKGZpbGVfZXhpc3RzKCRwa2NzNykpCisgICAgdW5saW5rKCRwa2NzNyk7CisgIGV4ZWMoIm9wZW5zc2wgY3JsMnBrY3M3IC1ub2NybCAtY2VydGZpbGUgJGNlcnRfcGVtIC1vdXQgJHBrY3M3IC1vdXRmb3JtIERFUiIpOworICBpZiAoIWZpbGVfZXhpc3RzKCRwa2NzNykpIHsKKyAgICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIC0gRmFpbGVkIHRvIHByZXBhcmUgUEtDUyM3IGZpbGUiKTsKKyAgICBkaWUoIkZhaWxlZCB0byBwcmVwYXJlIFBLQ1MjNyBmaWxlIik7CisgIH0KKworICBpZiAoISRkYi0+ZXhlYygiVVBEQVRFIHNlc3Npb25zIFNFVCB1c2VyPSckdXNlcicsIGNlcnQ9JyRmaW5nZXJwcmludCcsIGNlcnRfcGVtPSckY2VydCcgV0hFUkUgcm93aWQ9JHJvd2lkIikpIHsKKyAgICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIC0gRmFpbGVkIHRvIHVwZGF0ZSBzZXNzaW9uIGRhdGFiYXNlIik7CisgICAgZGllKCJGYWlsZWQgdG8gdXBkYXRlIHNlc3Npb24gZGF0YWJhc2UiKTsKKyAgfQorCisgIGhlYWRlcigiQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogYmFzZTY0Iik7CisgIGhlYWRlcigiQ29udGVudC1UeXBlOiBhcHBsaWNhdGlvbi9wa2NzNy1taW1lIik7CisKKyAgJGRhdGEgPSBmaWxlX2dldF9jb250ZW50cygkcGtjczcpOworICAkcmVzcCA9IHdvcmR3cmFwKGJhc2U2NF9lbmNvZGUoJGRhdGEpLCA3MiwgIlxuIiwgdHJ1ZSk7CisgIGVjaG8gJHJlc3AgLiAiXG4iOworICBlcnJvcl9sb2coIkVTVDogc2ltcGxlZW5yb2xsIC0gUEtDUyM3IHJlc3BvbnNlOiAiIC4gJHJlc3ApOworfSBlbHNlIHsKKyAgaGVhZGVyKCJIVFRQLzEuMCA0MDQgTm90IEZvdW5kIik7CisgIGVycm9yX2xvZygiRVNUOiBVbmV4cGVjdGVkIG1ldGhvZCBvciBwYXRoIik7CisgIGRpZSgiVW5leHBlY3RlZCBtZXRob2Qgb3IgcGF0aCIpOworfQorCis/PgpkaWZmIC0tZ2l0IGEvaHMyMC9zZXJ2ZXIvd3d3L2ZyZWUtcmVtZWRpYXRpb24ucGhwIGIvaHMyMC9zZXJ2ZXIvd3d3L2ZyZWUtcmVtZWRpYXRpb24ucGhwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU2NDhiMzAKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci93d3cvZnJlZS1yZW1lZGlhdGlvbi5waHAKQEAgLTAsMCArMSwxOSBAQAorPGh0bWw+Cis8aGVhZD4KKzx0aXRsZT5Ib3RzcG90IDIuMCAtIHB1YmxpYyBhbmQgZnJlZSBob3RzcG90IC0gcmVtZWRpYXRpb248L3RpdGxlPgorPC9oZWFkPgorPGJvZHk+CisKKzxoMz5Ib3RzcG90IDIuMCAtIHB1YmxpYyBhbmQgZnJlZSBob3RzcG90PC9oMz4KKworPHA+VGVybXMgYW5kIGNvbmRpdGlvbnMgaGF2ZSBjaGFuZ2VkLiBZb3UgbmVlZCB0byBhY2NlcHQgdGhlIG5ldyB0ZXJtcwordG8gY29udGludWUgdXNpbmcgdGhpcyBuZXR3b3JrLjwvcD4KKworPHA+VGVybXMgYW5kIGNvbmRpdGlvbnMuLjwvcD4KKworPD9waHAKK2VjaG8gIjxhIGhyZWY9XCJyZWRpcmVjdC5waHA/aWQ9IiAuICRfR0VUWyJzZXNzaW9uX2lkIl0gLiAiXCI+QWNjZXB0PC9hPjxicj5cbiI7Cis/PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9oczIwL3NlcnZlci93d3cvZnJlZS5waHAgYi9oczIwL3NlcnZlci93d3cvZnJlZS5waHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODE5NTA2OQotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL3d3dy9mcmVlLnBocApAQCAtMCwwICsxLDIzIEBACis8aHRtbD4KKzxoZWFkPgorPHRpdGxlPkhvdHNwb3QgMi4wIC0gcHVibGljIGFuZCBmcmVlIGhvdHNwb3Q8L3RpdGxlPgorPC9oZWFkPgorPGJvZHk+CisKKzw/cGhwCisKKyRpZCA9ICRfR0VUWyJzZXNzaW9uX2lkIl07CisKK2VjaG8gIjxoMz5Ib3RzcG90IDIuMCAtIHB1YmxpYyBhbmQgZnJlZSBob3RzcG90PC9oMz5cbiI7CisKK2VjaG8gIjxmb3JtIGFjdGlvbj1cImFkZC1mcmVlLnBocFwiIG1ldGhvZD1cIlBPU1RcIj5cbiI7CitlY2hvICI8aW5wdXQgdHlwZT1cImhpZGRlblwiIG5hbWU9XCJpZFwiIHZhbHVlPVwiJGlkXCI+XG4iOworCis/PgorCis8cD5UZXJtcyBhbmQgY29uZGl0aW9ucy4uPC9wPgorPGlucHV0IHR5cGU9InN1Ym1pdCIgdmFsdWU9IkFjY2VwdCI+Cis8L2Zvcm0+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL3d3dy9yZWRpcmVjdC5waHAgYi9oczIwL3NlcnZlci93d3cvcmVkaXJlY3QucGhwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhmYzljZDYKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci93d3cvcmVkaXJlY3QucGhwCkBAIC0wLDAgKzEsMzIgQEAKKzw/cGhwCisKK3JlcXVpcmUoJ2NvbmZpZy5waHAnKTsKKworJGRiID0gbmV3IFBETygkb3N1X2RiKTsKK2lmICghJGRiKSB7CisgICBkaWUoJHNxbGl0ZWVycm9yKTsKK30KKworaWYgKGlzc2V0KCRfR0VUWyJpZCJdKSkKKwkkaWQgPSBwcmVnX3JlcGxhY2UoIi9bXmEtZkEtRjAtOV0vIiwgIiIsICRfR0VUWyJpZCJdKTsKK2Vsc2UKKwkkaWQgPSAwOworCiskcm93ID0gJGRiLT5xdWVyeSgiU0VMRUNUIHJvd2lkLCogRlJPTSBzZXNzaW9ucyBXSEVSRSBpZD0nJGlkJyIpLT5mZXRjaCgpOworaWYgKCRyb3cgPT0gZmFsc2UpIHsKKyAgIGRpZSgiU2Vzc2lvbiBub3QgZm91bmQiKTsKK30KKworJHVyaSA9ICRyb3dbJ3JlZGlyZWN0X3VyaSddOworCitoZWFkZXIoIkxvY2F0aW9uOiAkdXJpIiwgdHJ1ZSwgMzAyKTsKKworJHVzZXIgPSAkcm93Wyd1c2VyJ107CiskcmVhbG0gPSAkcm93WydyZWFsbSddOworCiskZGItPmV4ZWMoIklOU0VSVCBJTlRPIGV2ZW50bG9nKHVzZXIscmVhbG0sc2Vzc2lvbmlkLHRpbWVzdGFtcCxub3RlcykgIiAuCisJICAiVkFMVUVTICgnJHVzZXInLCAnJHJlYWxtJywgJyRpZCcsICIgLgorCSAgInN0cmZ0aW1lKCclWS0lbS0lZCAlSDolTTolZicsJ25vdycpLCAiIC4KKwkgICIncmVkaXJlY3RlZCBhZnRlciB1c2VyIGlucHV0JykiKTsKKworPz4KZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL3d3dy9yZW1lZGlhdGlvbi5waHAgYi9oczIwL3NlcnZlci93d3cvcmVtZWRpYXRpb24ucGhwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM5MmE3YmQKLS0tIC9kZXYvbnVsbAorKysgYi9oczIwL3NlcnZlci93d3cvcmVtZWRpYXRpb24ucGhwCkBAIC0wLDAgKzEsMTggQEAKKzxodG1sPgorPGhlYWQ+Cis8dGl0bGU+SG90c3BvdCAyLjAgc3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uPC90aXRsZT4KKzwvaGVhZD4KKzxib2R5PgorCis8P3BocAorCitlY2hvICJTZXNzaW9uSUQ6ICIgLiAkX0dFVFsic2Vzc2lvbl9pZCJdIC4gIjxicj5cbiI7CisKK2VjaG8gIjxhIGhyZWY9XCJyZWRpcmVjdC5waHA/aWQ9IiAuICRfR0VUWyJzZXNzaW9uX2lkIl0gLiAiXCI+Q29tcGxldGUgdXNlciBzdWJzY3JpcHRpb24gcmVtZWRpYXRpb248L2E+PGJyPlxuIjsKKworPz4KKworVGhpcyB3aWxsIHByb3ZpZGUgYSBuZXcgbWFjaGluZS1nZW5lcmF0ZWQgcGFzc3dvcmQuCisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL3d3dy9zaWdudXAucGhwIGIvaHMyMC9zZXJ2ZXIvd3d3L3NpZ251cC5waHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTYyNjcwNAotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL3d3dy9zaWdudXAucGhwCkBAIC0wLDAgKzEsNDYgQEAKKzxodG1sPgorPGhlYWQ+Cis8dGl0bGU+SG90c3BvdCAyLjAgc2lnbnVwPC90aXRsZT4KKzwvaGVhZD4KKzxib2R5PgorCis8P3BocAorCiskaWQgPSAkX0dFVFsic2Vzc2lvbl9pZCJdOworCityZXF1aXJlKCdjb25maWcucGhwJyk7CisKKyRkYiA9IG5ldyBQRE8oJG9zdV9kYik7CitpZiAoISRkYikgeworICAgZGllKCRzcWxpdGVlcnJvcik7Cit9CisKKyRyb3cgPSAkZGItPnF1ZXJ5KCJTRUxFQ1QgcmVhbG0gRlJPTSBzZXNzaW9ucyBXSEVSRSBpZD0nJGlkJyIpLT5mZXRjaCgpOworaWYgKCRyb3cgPT0gZmFsc2UpIHsKKyAgIGRpZSgiU2Vzc2lvbiBub3QgZm91bmQiKTsKK30KKyRyZWFsbSA9ICRyb3dbJ3JlYWxtJ107CisKK2VjaG8gIjxoMz5TaWduIHVwIGZvciBhIHN1YnNjcmlwdGlvbiAtICRyZWFsbTwvaDM+XG4iOworCiskcm93ID0gJGRiLT5xdWVyeSgiU0VMRUNUIHZhbHVlIEZST00gb3N1X2NvbmZpZyBXSEVSRSByZWFsbT0nJHJlYWxtJyBBTkQgZmllbGQ9J2ZyZWVfYWNjb3VudCciKS0+ZmV0Y2goKTsKK2lmICgkcm93ICYmIHN0cmxlbigkcm93Wyd2YWx1ZSddKSA+IDApIHsKKyAgZWNobyAiPHA+PGEgaHJlZj1cImZyZWUucGhwP3Nlc3Npb25faWQ9JGlkXCI+U2lnbiB1cCBmb3IgZnJlZSBhY2Nlc3M8L2E+PC9wPlxuIjsKK30KKworZWNobyAiPGZvcm0gYWN0aW9uPVwiYWRkLW1vLnBocFwiIG1ldGhvZD1cIlBPU1RcIj5cbiI7CitlY2hvICI8aW5wdXQgdHlwZT1cImhpZGRlblwiIG5hbWU9XCJpZFwiIHZhbHVlPVwiJGlkXCI+XG4iOworPz4KK1NlbGVjdCBhIHVzZXJuYW1lIGFuZCBwYXNzd29yZC4gTGVhdmUgcGFzc3dvcmQgZW1wdHkgdG8gZ2V0IGF1dG9tYXRpY2FsbHkKK2dlbmVyYXRlZCBhbmQgbWFjaGluZSBtYW5hZ2VkIHBhc3N3b3JkLjxicj4KK1VzZXJuYW1lOiA8aW5wdXQgdHlwZT0idGV4dCIgbmFtZT0idXNlciI+PGJyPgorUGFzc3dvcmQ6IDxpbnB1dCB0eXBlPSJwYXNzd29yZCIgbmFtZT0icGFzc3dvcmQiPjxicj4KKzxpbnB1dCB0eXBlPSJzdWJtaXQiIHZhbHVlPSJDb21wbGV0ZSBzdWJzY3JpcHRpb24gcmVnaXN0cmF0aW9uIj4KKzwvZm9ybT4KKworPD9waHAKK2VjaG8gIjxwPjxhIGhyZWY9XCJjZXJ0LWVucm9sbC5waHA/aWQ9JGlkXCI+RW5yb2xsIGEgY2xpZW50IGNlcnRpZmljYXRlPC9hPjwvcD5cbiIKKz8+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL2hzMjAvc2VydmVyL3d3dy9zcHAucGhwIGIvaHMyMC9zZXJ2ZXIvd3d3L3NwcC5waHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGRlNDQzNAotLS0gL2Rldi9udWxsCisrKyBiL2hzMjAvc2VydmVyL3d3dy9zcHAucGhwCkBAIC0wLDAgKzEsMTI3IEBACis8P3BocAorCityZXF1aXJlKCdjb25maWcucGhwJyk7CisKK2lmICghc3RyaXN0cigkX1NFUlZFUlsiQ09OVEVOVF9UWVBFIl0sICJhcHBsaWNhdGlvbi9zb2FwK3htbCIpKSB7CisgIGVycm9yX2xvZygic3BwLnBocCAtIFVuZXhwZWN0ZWQgQ29udGVudC1UeXBlICIgLiAkX1NFUlZFUlsiQ09OVEVOVF9UWVBFIl0pOworICBkaWUoIlVuZXhwZWN0ZWQgQ29udGVudC1UeXBlIik7Cit9CisKK2lmICgkX1NFUlZFUlsiUkVRVUVTVF9NRVRIT0QiXSAhPSAiUE9TVCIpIHsKKyAgZXJyb3JfbG9nKCJzcHAucGhwIC0gVW5leHBlY3RlZCBtZXRob2QgIiAuICRfU0VSVkVSWyJSRVFVRVNUX01FVEhPRCJdKTsKKyAgZGllKCJVbmV4cGVjdGVkIG1ldGhvZCIpOworfQorCitpZiAoaXNzZXQoJF9HRVRbInJlYWxtIl0pKSB7CisgICRyZWFsbSA9ICRfR0VUWyJyZWFsbSJdOworICAkcmVhbG0gPSBQUkVHX1JFUExBQ0UoIi9bXjAtOWEtekEtWlwuXC1dL2kiLCAnJywgJHJlYWxtKTsKK30gZWxzZSB7CisgIGVycm9yX2xvZygic3BwLnBocCAtIFJlYWxtIG5vdCBzcGVjaWZpZWQiKTsKKyAgZGllKCJSZWFsbSBub3Qgc3BlY2lmaWVkIik7Cit9CisKK3Vuc2V0KCR1c2VyKTsKK3B1dGVudigiSFMyMENFUlQiKTsKKworaWYgKCFlbXB0eSgkX1NFUlZFUlsnUEhQX0FVVEhfRElHRVNUJ10pKSB7CisgICRuZWVkZWQgPSBhcnJheSgnbm9uY2UnPT4xLCAnbmMnPT4xLCAnY25vbmNlJz0+MSwgJ3FvcCc9PjEsICd1c2VybmFtZSc9PjEsCisJCSAgJ3VyaSc9PjEsICdyZXNwb25zZSc9PjEpOworICAkZGF0YSA9IGFycmF5KCk7CisgICRrZXlzID0gaW1wbG9kZSgnfCcsIGFycmF5X2tleXMoJG5lZWRlZCkpOworICBwcmVnX21hdGNoX2FsbCgnQCgnIC4gJGtleXMgLiAnKT0oPzooW1wnIl0pKFteXDJdKz8pXDJ8KFteXHMsXSspKUAnLAorCQkgJF9TRVJWRVJbJ1BIUF9BVVRIX0RJR0VTVCddLCAkbWF0Y2hlcywgUFJFR19TRVRfT1JERVIpOworICBmb3JlYWNoICgkbWF0Y2hlcyBhcyAkbSkgeworICAgICRkYXRhWyRtWzFdXSA9ICRtWzNdID8gJG1bM10gOiAkbVs0XTsKKyAgICB1bnNldCgkbmVlZGVkWyRtWzFdXSk7CisgIH0KKyAgaWYgKCRuZWVkZWQpIHsKKyAgICBlcnJvcl9sb2coInNwcC5waHAgLSBBdXRoZW50aWNhdGlvbiBmYWlsZWQgLSBtaXNzaW5nOiAiIC4gcHJpbnRfcigkbmVlZGVkKSk7CisgICAgZGllKCdBdXRoZW50aWNhdGlvbiBmYWlsZWQnKTsKKyAgfQorICAkdXNlciA9ICRkYXRhWyd1c2VybmFtZSddOworICBpZiAoc3RybGVuKCR1c2VyKSA8IDEpIHsKKyAgICBlcnJvcl9sb2coInNwcC5waHAgLSBBdXRoZW50aWNhdGlvbiBmYWlsZWQgLSBlbXB0eSB1c2VybmFtZSIpOworICAgIGRpZSgnQXV0aGVudGljYXRpb24gZmFpbGVkJyk7CisgIH0KKworCisgICRkYiA9IG5ldyBQRE8oJG9zdV9kYik7CisgIGlmICghJGRiKSB7CisgICAgZXJyb3JfbG9nKCJzcHAucGhwIC0gQ291bGQgbm90IGFjY2VzcyBkYXRhYmFzZSIpOworICAgIGRpZSgiQ291bGQgbm90IGFjY2VzcyBkYXRhYmFzZSIpOworICB9CisgICRyb3cgPSAkZGItPnF1ZXJ5KCJTRUxFQ1QgcGFzc3dvcmQgRlJPTSB1c2VycyAiIC4KKwkJICAgICJXSEVSRSBpZGVudGl0eT0nJHVzZXInIEFORCByZWFsbT0nJHJlYWxtJyIpLT5mZXRjaCgpOworICBpZiAoISRyb3cpIHsKKyAgICAkcm93ID0gJGRiLT5xdWVyeSgiU0VMRUNUIG9zdV9wYXNzd29yZCBGUk9NIHVzZXJzICIgLgorCQkgICAgICAiV0hFUkUgb3N1X3VzZXI9JyR1c2VyJyBBTkQgcmVhbG09JyRyZWFsbSciKS0+ZmV0Y2goKTsKKyAgICAkcHcgPSAkcm93Wydvc3VfcGFzc3dvcmQnXTsKKyAgfSBlbHNlCisgICAgJHB3ID0gJHJvd1sncGFzc3dvcmQnXTsKKyAgaWYgKCEkcm93KSB7CisgICAgZXJyb3JfbG9nKCJzcHAucGhwIC0gQXV0aGVudGljYXRpb24gZmFpbGVkIC0gdXNlciAnJHVzZXInIG5vdCBmb3VuZCIpOworICAgIGRpZSgnQXV0aGVudGljYXRpb24gZmFpbGVkJyk7CisgIH0KKyAgaWYgKHN0cmxlbigkcHcpIDwgMSkgeworICAgIGVycm9yX2xvZygic3BwLnBocCAtIEF1dGhlbnRpY2F0aW9uIGZhaWxlZCAtIGVtcHR5IHBhc3N3b3JkIik7CisgICAgZGllKCdBdXRoZW50aWNhdGlvbiBmYWlsZWQnKTsKKyAgfQorCisgICRBMSA9IG1kNSgkdXNlciAuICc6JyAuICRyZWFsbSAuICc6JyAuICRwdyk7CisgICRBMiA9IG1kNSgkX1NFUlZFUlsnUkVRVUVTVF9NRVRIT0QnXSAuICc6JyAuICRkYXRhWyd1cmknXSk7CisgICRyZXNwID0gbWQ1KCRBMSAuICc6JyAuICRkYXRhWydub25jZSddIC4gJzonIC4gJGRhdGFbJ25jJ10gLiAnOicgLgorCSAgICAgICRkYXRhWydjbm9uY2UnXSAuICc6JyAuICRkYXRhWydxb3AnXSAuICc6JyAuICRBMik7CisgIGlmICgkZGF0YVsncmVzcG9uc2UnXSAhPSAkcmVzcCkgeworICAgIGVycm9yX2xvZygiQXV0aGVudGljYXRpb24gZmFpbHVyZSAtIHJlc3BvbnNlIG1pc21hdGNoIik7CisgICAgZGllKCdBdXRoZW50aWNhdGlvbiBmYWlsZWQnKTsKKyAgfQorfSBlbHNlIGlmIChpc3NldCgkX1NFUlZFUlsiU1NMX0NMSUVOVF9WRVJJRlkiXSkgJiYKKwkgICAkX1NFUlZFUlsiU1NMX0NMSUVOVF9WRVJJRlkiXSA9PSAiU1VDQ0VTUyIgJiYKKwkgICBpc3NldCgkX1NFUlZFUlsiU1NMX0NMSUVOVF9NX1NFUklBTCJdKSkgeworICAkdXNlciA9ICJjZXJ0LSIgLiAkX1NFUlZFUlsiU1NMX0NMSUVOVF9NX1NFUklBTCJdOworICBwdXRlbnYoIkhTMjBDRVJUPXllcyIpOworfSBlbHNlIGlmICghaXNzZXQoJF9TRVJWRVJbIlBBVEhfSU5GTyJdKSB8fAorCSAgICRfU0VSVkVSWyJQQVRIX0lORk8iXSAhPSAiL3NpZ251cCIpIHsKKyAgaGVhZGVyKCdIVFRQLzEuMSA0MDEgVW5hdXRob3JpemVkJyk7CisgIGhlYWRlcignV1dXLUF1dGhlbnRpY2F0ZTogRGlnZXN0IHJlYWxtPSInLiRyZWFsbS4KKwkgJyIscW9wPSJhdXRoIixub25jZT0iJy51bmlxaWQoKS4nIixvcGFxdWU9IicubWQ1KCRyZWFsbSkuJyInKTsKKyAgZXJyb3JfbG9nKCJzcHAucGhwIC0gQXV0aGVudGljYXRpb24gcmVxdWlyZWQgKG5vdCBzaWdudXApIik7CisgIGRpZSgnQXV0aGVudGljYXRpb24gcmVxdWlyZWQgKG5vdCBzaWdudXApJyk7Cit9CisKKworaWYgKGlzc2V0KCR1c2VyKSAmJiBzdHJsZW4oJHVzZXIpID4gMCkKKyAgcHV0ZW52KCJIUzIwVVNFUj0kdXNlciIpOworZWxzZQorICBwdXRlbnYoIkhTMjBVU0VSIik7CisKK3B1dGVudigiSFMyMFJFQUxNPSRyZWFsbSIpOworcHV0ZW52KCJIUzIwUE9TVD0kSFRUUF9SQVdfUE9TVF9EQVRBIik7CiskYWRkciA9ICRfU0VSVkVSWyJSRU1PVEVfQUREUiJdOworcHV0ZW52KCJIUzIwQUREUj0kYWRkciIpOworCiskbGFzdCA9IGV4ZWMoIiRvc3Vfcm9vdC9zcHAvaHMyMF9zcHBfc2VydmVyIC1yJG9zdV9yb290IC1mL3RtcC9oczIwX3NwcF9zZXJ2ZXIubG9nIiwgJG91dHB1dCwgJHJldCk7CisKK2lmICgkcmV0ID09IDIpIHsKKyAgaWYgKGVtcHR5KCRfU0VSVkVSWydQSFBfQVVUSF9ESUdFU1QnXSkpIHsKKyAgICBoZWFkZXIoJ0hUVFAvMS4xIDQwMSBVbmF1dGhvcml6ZWQnKTsKKyAgICBoZWFkZXIoJ1dXVy1BdXRoZW50aWNhdGU6IERpZ2VzdCByZWFsbT0iJy4kcmVhbG0uCisgICAgICAgICAgICciLHFvcD0iYXV0aCIsbm9uY2U9IicudW5pcWlkKCkuJyIsb3BhcXVlPSInLm1kNSgkcmVhbG0pLiciJyk7CisgICAgZXJyb3JfbG9nKCJzcHAucGhwIC0gQXV0aGVudGljYXRpb24gcmVxdWlyZWQgKHJldCAyKSIpOworICAgIGRpZSgnQXV0aGVudGljYXRpb24gcmVxdWlyZWQnKTsKKyAgfSBlbHNlIHsKKyAgICBlcnJvcl9sb2coInNwcC5waHAgLSBVbmV4cGVjdGVkIGF1dGhlbnRpY2F0aW9uIGVycm9yIik7CisgICAgZGllKCJVbmV4cGVjdGVkIGF1dGhlbnRpY2F0aW9uIGVycm9yIik7CisgIH0KK30KK2lmICgkcmV0ICE9IDApIHsKKyAgZXJyb3JfbG9nKCJzcHAucGhwIC0gRmFpbGVkIHRvIHByb2Nlc3MgU1BQIHJlcXVlc3QiKTsKKyAgZGllKCJGYWlsZWQgdG8gcHJvY2VzcyBTUFAgcmVxdWVzdCIpOworfQorLy9lcnJvcl9sb2coInNwcC5waHA6IFJlc3BvbnNlOiAiIC4gaW1wbG9kZSgkb3V0cHV0KSk7CisKK2hlYWRlcigiQ29udGVudC1UeXBlOiBhcHBsaWNhdGlvbi9zb2FwK3htbCIpOworCitlY2hvIGltcGxvZGUoJG91dHB1dCk7CisKKz8+CmRpZmYgLS1naXQgYS9oczIwL3NlcnZlci93d3cvdXNlcnMucGhwIGIvaHMyMC9zZXJ2ZXIvd3d3L3VzZXJzLnBocApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMzQwYTMzCi0tLSAvZGV2L251bGwKKysrIGIvaHMyMC9zZXJ2ZXIvd3d3L3VzZXJzLnBocApAQCAtMCwwICsxLDM0OSBAQAorPD9waHAKKworcmVxdWlyZSgnY29uZmlnLnBocCcpOworCiskZGIgPSBuZXcgUERPKCRvc3VfZGIpOworaWYgKCEkZGIpIHsKKyAgIGRpZSgkc3FsaXRlZXJyb3IpOworfQorCitpZiAoaXNzZXQoJF9HRVRbImlkIl0pKSB7CisJJGlkID0gJF9HRVRbImlkIl07CisJaWYgKCFpc19udW1lcmljKCRpZCkpCisJCSRpZCA9IDA7Cit9IGVsc2UKKwkkaWQgPSAwOworaWYgKGlzc2V0KCRfR0VUWyJjbWQiXSkpCisJJGNtZCA9ICRfR0VUWyJjbWQiXTsKK2Vsc2UKKwkkY21kID0gJyc7CisKK2lmICgkY21kID09ICdldmVudGxvZycgJiYgJGlkID4gMCkgeworCSRyb3cgPSAkZGItPnF1ZXJ5KCJTRUxFQ1QgZHVtcCBGUk9NIGV2ZW50bG9nIFdIRVJFIHJvd2lkPSRpZCIpLT5mZXRjaCgpOworCSRkdW1wID0gJHJvd1snZHVtcCddOworCWlmICgkZHVtcFswXSA9PSAnPCcpIHsKKwkgIGhlYWRlcigiQ29udGVudC10eXBlOiB0ZXh0L3htbCIpOworCSAgZWNobyAiPD94bWwgdmVyc2lvbj1cIjEuMFwiPz5cbiI7CisJICBlY2hvICRkdW1wOworCX0gZWxzZSB7CisJICBoZWFkZXIoIkNvbnRlbnQtdHlwZTogdGV4dC9wbGFpbiIpOworCSAgZWNobyAkZHVtcDsKKwl9CisJZXhpdDsKK30KKworaWYgKCRjbWQgPT0gJ21vJyAmJiAkaWQgPiAwKSB7CisJJG1vID0gJF9HRVRbIm1vIl07CisJaWYgKCFpc3NldCgkbW8pKQorCQlleGl0OworCWlmICgkbW8gIT0gImRldmluZm8iICYmICRtbyAhPSAiZGV2ZGV0YWlsIiAmJiAkbW8gIT0gInBwcyIpCisJCWV4aXQ7CisJJHJvdyA9ICRkYi0+cXVlcnkoIlNFTEVDVCAkbW8gRlJPTSB1c2VycyBXSEVSRSByb3dpZD0kaWQiKS0+ZmV0Y2goKTsKKwloZWFkZXIoIkNvbnRlbnQtdHlwZTogdGV4dC94bWwiKTsKKwllY2hvICI8P3htbCB2ZXJzaW9uPVwiMS4wXCI/PlxuIjsKKwllY2hvICRyb3dbJG1vXTsKKwlleGl0OworfQorCitpZiAoJGNtZCA9PSAnY2VydCcgJiYgJGlkID4gMCkgeworCSRyb3cgPSAkZGItPnF1ZXJ5KCJTRUxFQ1QgY2VydF9wZW0gRlJPTSB1c2VycyBXSEVSRSByb3dpZD0kaWQiKS0+ZmV0Y2goKTsKKwloZWFkZXIoIkNvbnRlbnQtdHlwZTogdGV4dC9wbGFpbiIpOworCWVjaG8gJHJvd1snY2VydF9wZW0nXTsKKwlleGl0OworfQorCis/PgorCis8aHRtbD4KKzxoZWFkPjx0aXRsZT5IUyAyLjAgdXNlcnM8L3RpdGxlPjwvaGVhZD4KKzxib2R5PgorCis8P3BocAorCitpZiAoJGNtZCA9PSAnc3VicmVtLWNsZWFyJyAmJiAkaWQgPiAwKSB7CisJJGRiLT5leGVjKCJVUERBVEUgdXNlcnMgU0VUIHJlbWVkaWF0aW9uPScnIFdIRVJFIHJvd2lkPSRpZCIpOworfQoraWYgKCRjbWQgPT0gJ3N1YnJlbS1hZGQtdXNlcicgJiYgJGlkID4gMCkgeworCSRkYi0+ZXhlYygiVVBEQVRFIHVzZXJzIFNFVCByZW1lZGlhdGlvbj0ndXNlcicgV0hFUkUgcm93aWQ9JGlkIik7Cit9CitpZiAoJGNtZCA9PSAnc3VicmVtLWFkZC1tYWNoaW5lJyAmJiAkaWQgPiAwKSB7CisJJGRiLT5leGVjKCJVUERBVEUgdXNlcnMgU0VUIHJlbWVkaWF0aW9uPSdtYWNoaW5lJyBXSEVSRSByb3dpZD0kaWQiKTsKK30KK2lmICgkY21kID09ICdzdWJyZW0tYWRkLXBvbGljeScgJiYgJGlkID4gMCkgeworCSRkYi0+ZXhlYygiVVBEQVRFIHVzZXJzIFNFVCByZW1lZGlhdGlvbj0ncG9saWN5JyBXSEVSRSByb3dpZD0kaWQiKTsKK30KK2lmICgkY21kID09ICdzdWJyZW0tYWRkLWZyZWUnICYmICRpZCA+IDApIHsKKwkkZGItPmV4ZWMoIlVQREFURSB1c2VycyBTRVQgcmVtZWRpYXRpb249J2ZyZWUnIFdIRVJFIHJvd2lkPSRpZCIpOworfQoraWYgKCRjbWQgPT0gJ2ZldGNoLXBwcy1vbicgJiYgJGlkID4gMCkgeworCSRkYi0+ZXhlYygiVVBEQVRFIHVzZXJzIFNFVCBmZXRjaF9wcHM9MSBXSEVSRSByb3dpZD0kaWQiKTsKK30KK2lmICgkY21kID09ICdmZXRjaC1wcHMtb2ZmJyAmJiAkaWQgPiAwKSB7CisJJGRiLT5leGVjKCJVUERBVEUgdXNlcnMgU0VUIGZldGNoX3Bwcz0wIFdIRVJFIHJvd2lkPSRpZCIpOworfQoraWYgKCRjbWQgPT0gJ3Jlc2V0LXB3JyAmJiAkaWQgPiAwKSB7CisJJGRiLT5leGVjKCJVUERBVEUgdXNlcnMgU0VUIHBhc3N3b3JkPSdDaGFuZ2VNZScgV0hFUkUgcm93aWQ9JGlkIik7Cit9CitpZiAoJGNtZCA9PSAicG9saWN5IiAmJiAkaWQgPiAwICYmIGlzc2V0KCRfR0VUWyJwb2xpY3kiXSkpIHsKKwkkcG9saWN5ID0gJF9HRVRbInBvbGljeSJdOworCWlmICgkcG9saWN5ID09ICJuby1wb2xpY3kiIHx8CisJICAgIGlzX3JlYWRhYmxlKCIkb3N1X3Jvb3Qvc3BwL3BvbGljeS8kcG9saWN5LnhtbCIpKSB7CisJCSRkYi0+ZXhlYygiVVBEQVRFIHVzZXJzIFNFVCBwb2xpY3k9JyRwb2xpY3knIFdIRVJFIHJvd2lkPSRpZCIpOworCX0KK30KK2lmICgkY21kID09ICJhY2NvdW50LXR5cGUiICYmICRpZCA+IDAgJiYgaXNzZXQoJF9HRVRbInR5cGUiXSkpIHsKKwkkdHlwZSA9ICRfR0VUWyJ0eXBlIl07CisJaWYgKCR0eXBlID09ICJzaGFyZWQiKQorCQkkZGItPmV4ZWMoIlVQREFURSB1c2VycyBTRVQgc2hhcmVkPTEgV0hFUkUgcm93aWQ9JGlkIik7CisJaWYgKCR0eXBlID09ICJkZWZhdWx0IikKKwkJJGRiLT5leGVjKCJVUERBVEUgdXNlcnMgU0VUIHNoYXJlZD0wIFdIRVJFIHJvd2lkPSRpZCIpOworfQorCitpZiAoJGNtZCA9PSAic2V0LW9zdS1jcmVkIiAmJiAkaWQgPiAwKSB7CisgICRvc3VfdXNlciA9ICRfUE9TVFsib3N1X3VzZXIiXTsKKyAgJG9zdV9wYXNzd29yZCA9ICRfUE9TVFsib3N1X3Bhc3N3b3JkIl07CisgIGlmIChzdHJsZW4oJG9zdV91c2VyKSA9PSAwKQorICAgICRvc3VfcGFzc3dvcmQgPSAiIjsKKyAgJGRiLT5leGVjKCJVUERBVEUgdXNlcnMgU0VUIG9zdV91c2VyPSckb3N1X3VzZXInLCBvc3VfcGFzc3dvcmQ9JyRvc3VfcGFzc3dvcmQnIFdIRVJFIHJvd2lkPSRpZCIpOworfQorCiskZHVtcCA9IDA7CisKK2lmICgkaWQgPiAwKSB7CisKK2lmIChpc3NldCgkX0dFVFsiZHVtcCJdKSkgeworCSRkdW1wID0gJF9HRVRbImR1bXAiXTsKKwlpZiAoIWlzX251bWVyaWMoJGR1bXApKQorCQkkZHVtcCA9IDA7Cit9IGVsc2UKKwkkZHVtcCA9IDA7CisKK2VjaG8gIls8YSBocmVmPVwidXNlcnMucGhwXCI+QWxsIHVzZXJzPC9hPl0gIjsKK2lmICgkZHVtcCA9PSAwKQorCWVjaG8gIls8YSBocmVmPVwidXNlcnMucGhwP2lkPSRpZCZkdW1wPTFcIj5JbmNsdWRlIGRlYnVnIGR1bXA8L2E+XSAiOworZWxzZQorCWVjaG8gIls8YSBocmVmPVwidXNlcnMucGhwP2lkPSRpZFwiPldpdGhvdXQgZGVidWcgZHVtcDwvYT5dICI7CitlY2hvICI8YnI+XG4iOworCiskcm93ID0gJGRiLT5xdWVyeSgiU0VMRUNUIHJvd2lkLCogRlJPTSB1c2VycyBXSEVSRSByb3dpZD0kaWQiKS0+ZmV0Y2goKTsKKworZWNobyAiPEgzPiIgLiAkcm93WydpZGVudGl0eSddIC4gIkAiIC4gJHJvd1sncmVhbG0nXSAuICI8L0gzPlxuIjsKKworZWNobyAiTU86ICI7CitpZiAoc3RybGVuKCRyb3dbJ2RldmluZm8nXSkgPiAwKSB7CisJZWNobyAiWzxhIGhyZWY9XCJ1c2Vycy5waHA/Y21kPW1vJmlkPSRpZCZtbz1kZXZpbmZvXCI+RGV2SW5mbzwvYT5dXG4iOworfQoraWYgKHN0cmxlbigkcm93WydkZXZkZXRhaWwnXSkgPiAwKSB7CisJZWNobyAiWzxhIGhyZWY9XCJ1c2Vycy5waHA/Y21kPW1vJmlkPSRpZCZtbz1kZXZkZXRhaWxcIj5EZXZEZXRhaWw8L2E+XVxuIjsKK30KK2lmIChzdHJsZW4oJHJvd1sncHBzJ10pID4gMCkgeworCWVjaG8gIls8YSBocmVmPVwidXNlcnMucGhwP2NtZD1tbyZpZD0kaWQmbW89cHBzXCI+UFBTPC9hPl1cbiI7Cit9CitpZiAoc3RybGVuKCRyb3dbJ2NlcnRfcGVtJ10pID4gMCkgeworCWVjaG8gIls8YSBocmVmPVwidXNlcnMucGhwP2NtZD1jZXJ0JmlkPSRpZFwiPkNlcnRpZmljYXRlPC9hPl1cbiI7Cit9CitlY2hvICI8QlI+XG4iOworCitlY2hvICJGZXRjaCBQUFMgTU86ICI7CitpZiAoJHJvd1snZmV0Y2hfcHBzJ10gPT0gIjEiKSB7CisJZWNobyAiT24gbmV4dCBjb25uZWN0aW9uICIgLgorCQkiWzxhIGhyZWY9XCJ1c2Vycy5waHA/Y21kPWZldGNoLXBwcy1vZmYmaWQ9JGlkXCI+IiAuCisJCSJkbyBub3QgZmV0Y2g8L2E+XTxicj5cbiI7Cit9IGVsc2UgeworCWVjaG8gIkRvIG5vdCBmZXRjaCAiIC4KKwkJIls8YSBocmVmPVwidXNlcnMucGhwP2NtZD1mZXRjaC1wcHMtb24maWQ9JGlkXCI+IiAuCisJCSJyZXF1ZXN0IGZldGNoPC9hPl08YnI+XG4iOworfQorCiskY2VydCA9ICRyb3dbJ2NlcnQnXTsKK2lmIChzdHJsZW4oJGNlcnQpID4gMCkgeworICBlY2hvICJDZXJ0aWZpY2F0ZSBmaW5nZXJwcmludDogJGNlcnQ8YnI+XG4iOworfQorCitlY2hvICJSZW1lZGlhdGlvbjogIjsKKyRyZW0gPSAkcm93WydyZW1lZGlhdGlvbiddOworaWYgKCRyZW0gPT0gIiIpIHsKKwllY2hvICJOb3QgcmVxdWlyZWQiOworCWVjaG8gIiBbPGEgaHJlZj1cInVzZXJzLnBocD9jbWQ9c3VicmVtLWFkZC11c2VyJmlkPSIgLgorCQkgICAkcm93Wydyb3dpZCddIC4gIlwiPmFkZDp1c2VyPC9hPl0iOworCWVjaG8gIiBbPGEgaHJlZj1cInVzZXJzLnBocD9jbWQ9c3VicmVtLWFkZC1tYWNoaW5lJmlkPSIgLgorCQkgICAkcm93Wydyb3dpZCddIC4gIlwiPmFkZDptYWNoaW5lPC9hPl0iOworCWVjaG8gIiBbPGEgaHJlZj1cInVzZXJzLnBocD9jbWQ9c3VicmVtLWFkZC1wb2xpY3kmaWQ9IiAuCisJCSAgICRyb3dbJ3Jvd2lkJ10gLiAiXCI+YWRkOnBvbGljeTwvYT5dIjsKKwllY2hvICIgWzxhIGhyZWY9XCJ1c2Vycy5waHA/Y21kPXN1YnJlbS1hZGQtZnJlZSZpZD0iIC4KKwkJICAgJHJvd1sncm93aWQnXSAuICJcIj5hZGQ6ZnJlZTwvYT5dIjsKK30gZWxzZSBpZiAoJHJlbSA9PSAidXNlciIpIHsKKwllY2hvICJVc2VyIFs8YSBocmVmPVwidXNlcnMucGhwP2NtZD1zdWJyZW0tY2xlYXImaWQ9IiAuCisJCSAgICAgICAkcm93Wydyb3dpZCddIC4gIlwiPmNsZWFyPC9hPl0iOworfSBlbHNlIGlmICgkcmVtID09ICJwb2xpY3kiKSB7CisJZWNobyAiUG9saWN5IFs8YSBocmVmPVwidXNlcnMucGhwP2NtZD1zdWJyZW0tY2xlYXImaWQ9IiAuCisJCSAgICAgICAkcm93Wydyb3dpZCddIC4gIlwiPmNsZWFyPC9hPl0iOworfSBlbHNlIGlmICgkcmVtID09ICJmcmVlIikgeworCWVjaG8gIkZyZWUgWzxhIGhyZWY9XCJ1c2Vycy5waHA/Y21kPXN1YnJlbS1jbGVhciZpZD0iIC4KKwkJICAgICAgICRyb3dbJ3Jvd2lkJ10gLiAiXCI+Y2xlYXI8L2E+XSI7Cit9IGVsc2UgIHsKKwllY2hvICJNYWNoaW5lIFs8YSBocmVmPVwidXNlcnMucGhwP2NtZD1zdWJyZW0tY2xlYXImaWQ9IiAuCisJCQkgICRyb3dbJ3Jvd2lkJ10gLiAiXCI+Y2xlYXI8L2E+XSI7Cit9CitlY2hvICI8YnI+XG4iOworCitlY2hvICI8Zm9ybT5Qb2xpY3k6IDxzZWxlY3QgbmFtZT1cInBvbGljeVwiICIgLgorCSJvbkNoYW5nZT1cIndpbmRvdy5sb2NhdGlvbj0ndXNlcnMucGhwP2NtZD1wb2xpY3kmaWQ9IiAuCisJJHJvd1sncm93aWQnXSAuICImcG9saWN5PScgKyB0aGlzLnZhbHVlO1wiPlxuIjsKK2VjaG8gIjxvcHRpb24gdmFsdWU9XCIiIC4gJHJvd1sncG9saWN5J10gLiAiXCIgc2VsZWN0ZWQ+IiAuICRyb3dbJ3BvbGljeSddIC4KKyAgICAgICI8L29wdGlvbj5cbiI7CiskZmlsZXMgPSBzY2FuZGlyKCIkb3N1X3Jvb3Qvc3BwL3BvbGljeSIpOworZm9yZWFjaCAoJGZpbGVzIGFzICRmaWxlKSB7CisJaWYgKCFwcmVnX21hdGNoKCIvLnhtbCQvIiwgJGZpbGUpKQorCQljb250aW51ZTsKKwlpZiAoJGZpbGUgPT0gJHJvd1sncG9saWN5J10gLiAiLnhtbCIpCisJCWNvbnRpbnVlOworCSRwID0gc3Vic3RyKCRmaWxlLCAwLCAtNCk7CisJZWNobyAiPG9wdGlvbiB2YWx1ZT1cIiRwXCI+JHA8L29wdGlvbj5cbiI7Cit9CitlY2hvICI8b3B0aW9uIHZhbHVlPVwibm8tcG9saWN5XCI+bm8gcG9saWN5PC9vcHRpb24+XG4iOworZWNobyAiPC9zZWxlY3Q+PC9mb3JtPlxuIjsKKworZWNobyAiPGZvcm0+QWNjb3VudCB0eXBlOiA8c2VsZWN0IG5hbWU9XCJ0eXBlXCIgIiAuCisJIm9uQ2hhbmdlPVwid2luZG93LmxvY2F0aW9uPSd1c2Vycy5waHA/Y21kPWFjY291bnQtdHlwZSZpZD0iIC4KKwkkcm93Wydyb3dpZCddIC4gIiZ0eXBlPScgKyB0aGlzLnZhbHVlO1wiPlxuIjsKK2lmICgkcm93WydzaGFyZWQnXSA+IDApIHsKKyAgJGRlZmF1bHRfc2VsID0gIiI7CisgICRzaGFyZWRfc2VsID0gIiBzZWxlY3RlZCI7Cit9IGVsc2UgeworICAkZGVmYXVsdF9zZWwgPSAiIHNlbGVjdGVkIjsKKyAgJHNoYXJlZF9zZWwgPSAiIjsKK30KK2VjaG8gIjxvcHRpb24gdmFsdWU9XCJkZWZhdWx0XCIkZGVmYXVsdF9zZWw+ZGVmYXVsdDwvb3B0aW9uPlxuIjsKK2VjaG8gIjxvcHRpb24gdmFsdWU9XCJzaGFyZWRcIiRzaGFyZWRfc2VsPnNoYXJlZDwvb3B0aW9uPlxuIjsKK2VjaG8gIjwvc2VsZWN0PjwvZm9ybT5cbiI7CisKK2VjaG8gIlBoYXNlIDIgbWV0aG9kKHMpOiAiIC4gJHJvd1snbWV0aG9kcyddIC4gIjxicj5cbiI7CisKK2VjaG8gIjxicj5cbiI7CitlY2hvICI8YSBocmVmPVwidXNlcnMucGhwP2NtZD1yZXNldC1wdyZpZD0iIC4KKwkgJHJvd1sncm93aWQnXSAuICJcIj5SZXNldCBBQUEgcGFzc3dvcmQ8L2E+PGJyPlxuIjsKKworZWNobyAiPGJyPlxuIjsKK2VjaG8gIjxmb3JtIGFjdGlvbj1cInVzZXJzLnBocD9jbWQ9c2V0LW9zdS1jcmVkJmlkPSIgLiAkcm93Wydyb3dpZCddIC4KKyAgIlwiIG1ldGhvZD1cIlBPU1RcIj5cbiI7CitlY2hvICJPU1UgY3JlZGVudGlhbHMgKGlmIHVzZXJuYW1lIGVtcHR5LCBBQUEgY3JlZGVudGlhbHMgYXJlIHVzZWQpOjxicj5cbiI7CitlY2hvICJ1c2VybmFtZTogPGlucHV0IHR5cGU9XCJ0ZXh0XCIgbmFtZT1cIm9zdV91c2VyXCIgdmFsdWU9XCIiIC4KKyAgJHJvd1snb3N1X3VzZXInXSAuICJcIj5cbiI7CitlY2hvICJwYXNzd29yZDogPGlucHV0IHR5cGU9XCJwYXNzd29yZFwiIG5hbWU9XCJvc3VfcGFzc3dvcmRcIj5cbiI7CitlY2hvICI8aW5wdXQgdHlwZT1cInN1Ym1pdFwiIHZhbHVlPVwiU2V0IE9TVSBjcmVkZW50aWFsc1wiPlxuIjsKK2VjaG8gIjwvZm9ybT5cbiI7CisKK2VjaG8gIjxocj5cbiI7CisKKyR1c2VyID0gJHJvd1snaWRlbnRpdHknXTsKKyRvc3VfdXNlciA9ICRyb3dbJ29zdV91c2VyJ107CiskcmVhbG0gPSAkcm93WydyZWFsbSddOworfQorCitpZiAoJGlkID4gMCB8fCAoJGlkID09IDAgJiYgJGNtZCA9PSAnZXZlbnRsb2cnKSkgeworCisgIGlmICgkaWQgPT0gMCkgeworICAgIGVjaG8gIls8YSBocmVmPVwidXNlcnMucGhwXCI+QWxsIHVzZXJzPC9hPl0gIjsKKyAgICBlY2hvICI8YnI+XG4iOworICB9CisKK2VjaG8gIjx0YWJsZSBib3JkZXI9MT5cbiI7CitlY2hvICI8dHI+IjsKK2lmICgkaWQgPT0gMCkgeworICBlY2hvICI8dGg+dXNlcjx0aD5yZWFsbSI7Cit9CitlY2hvICI8dGg+dGltZTx0aD5hZGRyZXNzPHRoPnNlc3Npb25JRDx0aD5ub3RlcyI7CitpZiAoJGR1bXAgPiAwKQorCWVjaG8gIjx0aD5kdW1wIjsKK2VjaG8gIlxuIjsKK2lmIChpc3NldCgkX0dFVFsibGltaXQiXSkpIHsKKwkkbGltaXQgPSAkX0dFVFsibGltaXQiXTsKKwlpZiAoIWlzX251bWVyaWMoJGxpbWl0KSkKKwkJJGxpbWl0ID0gMjA7Cit9IGVsc2UKKwkkbGltaXQgPSAyMDsKK2lmICgkaWQgPT0gMCkKKyAgJHJlcyA9ICRkYi0+cXVlcnkoIlNFTEVDVCByb3dpZCwqIEZST00gZXZlbnRsb2cgT1JERVIgQlkgdGltZXN0YW1wIERFU0MgTElNSVQgJGxpbWl0Iik7CitlbHNlIGlmIChzdHJsZW4oJG9zdV91c2VyKSA+IDApCisgICRyZXMgPSAkZGItPnF1ZXJ5KCJTRUxFQ1Qgcm93aWQsKiBGUk9NIGV2ZW50bG9nIFdIRVJFICh1c2VyPSckdXNlcicgT1IgdXNlcj0nJG9zdV91c2VyJykgQU5EIHJlYWxtPSckcmVhbG0nIE9SREVSIEJZIHRpbWVzdGFtcCBERVNDIExJTUlUICRsaW1pdCIpOworZWxzZQorICAkcmVzID0gJGRiLT5xdWVyeSgiU0VMRUNUIHJvd2lkLCogRlJPTSBldmVudGxvZyBXSEVSRSB1c2VyPSckdXNlcicgQU5EIHJlYWxtPSckcmVhbG0nIE9SREVSIEJZIHRpbWVzdGFtcCBERVNDIExJTUlUICRsaW1pdCIpOworZm9yZWFjaCAoJHJlcyBhcyAkcm93KSB7CisJZWNobyAiPHRyPiI7CisJaWYgKCRpZCA9PSAwKSB7CisJICBlY2hvICI8dGQ+IiAuICRyb3dbJ3VzZXInXSAuICJcbiI7CisJICBlY2hvICI8dGQ+IiAuICRyb3dbJ3JlYWxtJ10gLiAiXG4iOworCX0KKwllY2hvICI8dGQ+IiAuICRyb3dbJ3RpbWVzdGFtcCddIC4gIlxuIjsKKwllY2hvICI8dGQ+IiAuICRyb3dbJ2FkZHInXSAuICJcbiI7CisJZWNobyAiPHRkPiIgLiAkcm93WydzZXNzaW9uaWQnXSAuICJcbiI7CisJZWNobyAiPHRkPiIgLiAkcm93Wydub3RlcyddIC4gIlxuIjsKKwkkZCA9ICRyb3dbJ2R1bXAnXTsKKwlpZiAoc3RybGVuKCRkKSA+IDApIHsKKwkJZWNobyAiWzxhIGhyZWY9XCJ1c2Vycy5waHA/Y21kPWV2ZW50bG9nJmlkPSIgLiAkcm93Wydyb3dpZCddIC4KKwkJICAiXCI+IjsKKwkJaWYgKCRkWzBdID09ICc8JykKKwkJICBlY2hvICJYTUwiOworCQllbHNlCisJCSAgZWNobyAidHh0IjsKKwkJZWNobyAiPC9hPl1cbiI7CisJCWlmICgkZHVtcCA+IDApCisJCQllY2hvICI8dGQ+IiAuIGh0bWxzcGVjaWFsY2hhcnMoJGQpIC4gIlxuIjsKKwl9Cit9CitlY2hvICI8L3RhYmxlPlxuIjsKKworfQorCisKK2lmICgkaWQgPT0gMCAmJiAkY21kICE9ICdldmVudGxvZycpIHsKKworZWNobyAiWzxhIGhyZWY9XCJ1c2Vycy5waHA/Y21kPWV2ZW50bG9nJmxpbWl0PTUwXCI+RXZlbnRsb2c8L2E+XSAiOworZWNobyAiPGJyPlxuIjsKKworZWNobyAiPHRhYmxlIGJvcmRlcj0xPlxuIjsKK2VjaG8gIjx0cj48dGg+VXNlcjx0aD5SZWFsbTx0aD5SZW1lZGlhdGlvbjx0aD5Qb2xpY3k8dGg+QWNjb3VudCB0eXBlPHRoPlBoYXNlIDIgbWV0aG9kKHMpPHRoPkRldklkXG4iOworCiskcmVzID0gJGRiLT5xdWVyeSgnU0VMRUNUIHJvd2lkLCogRlJPTSB1c2VycyBXSEVSRSBwaGFzZTI9MScpOworZm9yZWFjaCAoJHJlcyBhcyAkcm93KSB7CisJZWNobyAiPHRyPjx0ZD48YSBocmVmPVwidXNlcnMucGhwP2lkPSIgLiAkcm93Wydyb3dpZCddIC4gIlwiPiAiIC4KKwkgICAgJHJvd1snaWRlbnRpdHknXSAuICIgPC9hPiI7CisJZWNobyAiPHRkPiIgLiAkcm93WydyZWFsbSddOworCSRyZW0gPSAkcm93WydyZW1lZGlhdGlvbiddOworCWVjaG8gIjx0ZD4iOworCWlmICgkcmVtID09ICIiKSB7CisJCWVjaG8gIk5vdCByZXF1aXJlZCI7CisJfSBlbHNlIGlmICgkcmVtID09ICJ1c2VyIikgeworCQllY2hvICJVc2VyIjsKKwl9IGVsc2UgaWYgKCRyZW0gPT0gInBvbGljeSIpIHsKKwkJZWNobyAiUG9saWN5IjsKKwl9IGVsc2UgaWYgKCRyZW0gPT0gImZyZWUiKSB7CisJCWVjaG8gIkZyZWUiOworCX0gZWxzZSAgeworCQllY2hvICJNYWNoaW5lIjsKKwl9CisJZWNobyAiPHRkPiIgLiAkcm93Wydwb2xpY3knXTsKKwlpZiAoJHJvd1snc2hhcmVkJ10gPiAwKQorCSAgZWNobyAiPHRkPnNoYXJlZCI7CisJZWxzZQorCSAgZWNobyAiPHRkPmRlZmF1bHQiOworCWVjaG8gIjx0ZD4iIC4gJHJvd1snbWV0aG9kcyddOworCWVjaG8gIjx0ZD4iOworCSR4bWwgPSB4bWxfcGFyc2VyX2NyZWF0ZSgpOworCXhtbF9wYXJzZV9pbnRvX3N0cnVjdCgkeG1sLCAkcm93WydkZXZpbmZvJ10sICRkZXZpbmZvKTsKKwlmb3JlYWNoKCRkZXZpbmZvIGFzICRrKSB7CisJICBpZiAoJGtbJ3RhZyddID09ICdERVZJRCcpIHsKKwkgICAgZWNobyAka1sndmFsdWUnXTsKKwkgICAgYnJlYWs7CisJICB9CisJfQorCWVjaG8gIlxuIjsKK30KK2VjaG8gIjwvdGFibGU+XG4iOworCit9CisKKz8+CisKKzwvaHRtbD4KZGlmZiAtLWdpdCBhL3NyYy9NYWtlZmlsZSBiL3NyYy9NYWtlZmlsZQppbmRleCBkNzNhMTc1Li4xMGUwMTcxIDEwMDY0NAotLS0gYS9zcmMvTWFrZWZpbGUKKysrIGIvc3JjL01ha2VmaWxlCkBAIC0xLDQgKzEsNCBAQAotU1VCRElSUz1hcCBjb21tb24gY3J5cHRvIGRyaXZlcnMgZWFwb2xfYXV0aCBlYXBvbF9zdXBwIGVhcF9jb21tb24gZWFwX3BlZXIgZWFwX3NlcnZlciBsMl9wYWNrZXQgcDJwIHJhZGl1cyByc25fc3VwcCB0bHMgdXRpbHMgd3BzCitTVUJESVJTPWFwIGNvbW1vbiBjcnlwdG8gZHJpdmVycyBlYXBvbF9hdXRoIGVhcG9sX3N1cHAgZWFwX2NvbW1vbiBlYXBfcGVlciBlYXBfc2VydmVyIGwyX3BhY2tldCBwMnAgcGFlIHJhZGl1cyByc25fc3VwcCB0bHMgdXRpbHMgd3BzCiAKIGFsbDoKIAlmb3IgZCBpbiAkKFNVQkRJUlMpOyBkbyBbIC1kICQkZCBdICYmICQoTUFLRSkgLUMgJCRkOyBkb25lCmRpZmYgLS1naXQgYS9zcmMvYXAvTWFrZWZpbGUgYi9zcmMvYXAvTWFrZWZpbGUKaW5kZXggOWM0MTk2Mi4uYWRmZDNkZiAxMDA2NDQKLS0tIGEvc3JjL2FwL01ha2VmaWxlCisrKyBiL3NyYy9hcC9NYWtlZmlsZQpAQCAtMiw3ICsyLDcgQEAKIAlAZWNobyBOb3RoaW5nIHRvIGJlIG1hZGUuCiAKIGNsZWFuOgotCXJtIC1mICp+ICoubyAqLmQKKwlybSAtZiAqfiAqLm8gKi5kICouZ2NubyAqLmdjZGEgKi5nY292CiAKIGluc3RhbGw6CiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgpkaWZmIC0tZ2l0IGEvc3JjL2FwL2FjY291bnRpbmcuYyBiL3NyYy9hcC9hY2NvdW50aW5nLmMKaW5kZXggOTU0MDUzMS4uNjI5MGQzZiAxMDA2NDQKLS0tIGEvc3JjL2FwL2FjY291bnRpbmcuYworKysgYi9zcmMvYXAvYWNjb3VudGluZy5jCkBAIC0xMCw3ICsxMCw2IEBACiAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKICNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgotI2luY2x1ZGUgImRyaXZlcnMvZHJpdmVyLmgiCiAjaW5jbHVkZSAicmFkaXVzL3JhZGl1cy5oIgogI2luY2x1ZGUgInJhZGl1cy9yYWRpdXNfY2xpZW50LmgiCiAjaW5jbHVkZSAiaG9zdGFwZC5oIgpAQCAtNDQsNyArNDMsNyBAQAogCW1zZyA9IHJhZGl1c19tc2dfbmV3KFJBRElVU19DT0RFX0FDQ09VTlRJTkdfUkVRVUVTVCwKIAkJCSAgICAgcmFkaXVzX2NsaWVudF9nZXRfaWQoaGFwZC0+cmFkaXVzKSk7CiAJaWYgKG1zZyA9PSBOVUxMKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IGNyZWF0ZSBuZXQgUkFESVVTIHBhY2tldFxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgY3JlYXRlIG5ldyBSQURJVVMgcGFja2V0Iik7CiAJCXJldHVybiBOVUxMOwogCX0KIApAQCAtNTUsNyArNTQsNyBAQAogCQkJICAgIHN0YS0+YWNjdF9zZXNzaW9uX2lkX2hpLCBzdGEtPmFjY3Rfc2Vzc2lvbl9pZF9sbyk7CiAJCWlmICghcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX0FDQ1RfU0VTU0lPTl9JRCwKIAkJCQkJICh1OCAqKSBidWYsIG9zX3N0cmxlbihidWYpKSkgewotCQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIEFjY3QtU2Vzc2lvbi1JZFxuIik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBBY2N0LVNlc3Npb24tSWQiKTsKIAkJCWdvdG8gZmFpbDsKIAkJfQogCX0gZWxzZSB7CkBAIC02NCw3ICs2Myw3IEBACiAKIAlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9BQ0NUX1NUQVRVU19UWVBFLAogCQkJCSAgICAgICBzdGF0dXNfdHlwZSkpIHsKLQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIEFjY3QtU3RhdHVzLVR5cGVcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBBY2N0LVN0YXR1cy1UeXBlIik7CiAJCWdvdG8gZmFpbDsKIAl9CiAKQEAgLTc0LDcgKzczLDcgQEAKIAkJCQkgICAgICAgaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCA/CiAJCQkJICAgICAgIFJBRElVU19BQ0NUX0FVVEhFTlRJQ19SQURJVVMgOgogCQkJCSAgICAgICBSQURJVVNfQUNDVF9BVVRIRU5USUNfTE9DQUwpKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IGFkZCBBY2N0LUF1dGhlbnRpY1xuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgYWRkIEFjY3QtQXV0aGVudGljIik7CiAJCWdvdG8gZmFpbDsKIAl9CiAKQEAgLTk5LDcgKzk4LDcgQEAKIAogCQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9VU0VSX05BTUUsIHZhbCwKIAkJCQkJIGxlbikpIHsKLQkJCXByaW50ZigiQ291bGQgbm90IGFkZCBVc2VyLU5hbWVcbiIpOworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBhZGQgVXNlci1OYW1lIik7CiAJCQlnb3RvIGZhaWw7CiAJCX0KIAl9CkBAIC0xMTcsNyArMTE2LDcgQEAKIAogCQkJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgUkFESVVTX0FUVFJfQ0xBU1MsCiAJCQkJCQkgdmFsLCBsZW4pKSB7Ci0JCQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIENsYXNzXG4iKTsKKwkJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBDbGFzcyIpOwogCQkJCWdvdG8gZmFpbDsKIAkJCX0KIAkJfQpAQCAtMjAyLDcgKzIwMSw2IEBACiB2b2lkIGFjY291bnRpbmdfc3RhX3N0YXJ0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhKQogewogCXN0cnVjdCByYWRpdXNfbXNnICptc2c7Ci0Jc3RydWN0IG9zX3RpbWUgdDsKIAlpbnQgaW50ZXJ2YWw7CiAKIAlpZiAoc3RhLT5hY2N0X3Nlc3Npb25fc3RhcnRlZCkKQEAgLTIxMyw4ICsyMTEsNyBAQAogCQkgICAgICAgInN0YXJ0aW5nIGFjY291bnRpbmcgc2Vzc2lvbiAlMDhYLSUwOFgiLAogCQkgICAgICAgc3RhLT5hY2N0X3Nlc3Npb25faWRfaGksIHN0YS0+YWNjdF9zZXNzaW9uX2lkX2xvKTsKIAotCW9zX2dldF90aW1lKCZ0KTsKLQlzdGEtPmFjY3Rfc2Vzc2lvbl9zdGFydCA9IHQuc2VjOworCW9zX2dldF9yZWx0aW1lKCZzdGEtPmFjY3Rfc2Vzc2lvbl9zdGFydCk7CiAJc3RhLT5sYXN0X3J4X2J5dGVzID0gc3RhLT5sYXN0X3R4X2J5dGVzID0gMDsKIAlzdGEtPmFjY3RfaW5wdXRfZ2lnYXdvcmRzID0gc3RhLT5hY2N0X291dHB1dF9naWdhd29yZHMgPSAwOwogCWhvc3RhcGRfZHJ2X3N0YV9jbGVhcl9zdGF0cyhoYXBkLCBzdGEtPmFkZHIpOwpAQCAtMjQ0LDYgKzI0MSw3IEBACiAJc3RydWN0IHJhZGl1c19tc2cgKm1zZzsKIAlpbnQgY2F1c2UgPSBzdGEtPmFjY3RfdGVybWluYXRlX2NhdXNlOwogCXN0cnVjdCBob3N0YXBfc3RhX2RyaXZlcl9kYXRhIGRhdGE7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93X3IsIGRpZmY7CiAJc3RydWN0IG9zX3RpbWUgbm93OwogCXUzMiBnaWdhd29yZHM7CiAKQEAgLTI1NCwxNCArMjUyLDE2IEBACiAJCQkgICAgIHN0b3AgPyBSQURJVVNfQUNDVF9TVEFUVVNfVFlQRV9TVE9QIDoKIAkJCSAgICAgUkFESVVTX0FDQ1RfU1RBVFVTX1RZUEVfSU5URVJJTV9VUERBVEUpOwogCWlmICghbXNnKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IGNyZWF0ZSBSQURJVVMgQWNjb3VudGluZyBtZXNzYWdlXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBjcmVhdGUgUkFESVVTIEFjY291bnRpbmcgbWVzc2FnZSIpOwogCQlyZXR1cm47CiAJfQogCisJb3NfZ2V0X3JlbHRpbWUoJm5vd19yKTsKIAlvc19nZXRfdGltZSgmbm93KTsKKwlvc19yZWx0aW1lX3N1Yigmbm93X3IsICZzdGEtPmFjY3Rfc2Vzc2lvbl9zdGFydCwgJmRpZmYpOwogCWlmICghcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihtc2csIFJBRElVU19BVFRSX0FDQ1RfU0VTU0lPTl9USU1FLAotCQkJCSAgICAgICBub3cuc2VjIC0gc3RhLT5hY2N0X3Nlc3Npb25fc3RhcnQpKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IGFkZCBBY2N0LVNlc3Npb24tVGltZVxuIik7CisJCQkJICAgICAgIGRpZmYuc2VjKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBBY2N0LVNlc3Npb24tVGltZSIpOwogCQlnb3RvIGZhaWw7CiAJfQogCkBAIC0yNjksMTkgKzI2OSwxOSBAQAogCQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLAogCQkJCQkgICAgICAgUkFESVVTX0FUVFJfQUNDVF9JTlBVVF9QQUNLRVRTLAogCQkJCQkgICAgICAgZGF0YS5yeF9wYWNrZXRzKSkgewotCQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIEFjY3QtSW5wdXQtUGFja2V0c1xuIik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBBY2N0LUlucHV0LVBhY2tldHMiKTsKIAkJCWdvdG8gZmFpbDsKIAkJfQogCQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLAogCQkJCQkgICAgICAgUkFESVVTX0FUVFJfQUNDVF9PVVRQVVRfUEFDS0VUUywKIAkJCQkJICAgICAgIGRhdGEudHhfcGFja2V0cykpIHsKLQkJCXByaW50ZigiQ291bGQgbm90IGFkZCBBY2N0LU91dHB1dC1QYWNrZXRzXG4iKTsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgYWRkIEFjY3QtT3V0cHV0LVBhY2tldHMiKTsKIAkJCWdvdG8gZmFpbDsKIAkJfQogCQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLAogCQkJCQkgICAgICAgUkFESVVTX0FUVFJfQUNDVF9JTlBVVF9PQ1RFVFMsCiAJCQkJCSAgICAgICBkYXRhLnJ4X2J5dGVzKSkgewotCQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIEFjY3QtSW5wdXQtT2N0ZXRzXG4iKTsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgYWRkIEFjY3QtSW5wdXQtT2N0ZXRzIik7CiAJCQlnb3RvIGZhaWw7CiAJCX0KIAkJZ2lnYXdvcmRzID0gc3RhLT5hY2N0X2lucHV0X2dpZ2F3b3JkczsKQEAgLTI5MiwxMyArMjkyLDEzIEBACiAJCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMigKIAkJCSAgICBtc2csIFJBRElVU19BVFRSX0FDQ1RfSU5QVVRfR0lHQVdPUkRTLAogCQkJICAgIGdpZ2F3b3JkcykpIHsKLQkJCXByaW50ZigiQ291bGQgbm90IGFkZCBBY2N0LUlucHV0LUdpZ2F3b3Jkc1xuIik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBBY2N0LUlucHV0LUdpZ2F3b3JkcyIpOwogCQkJZ290byBmYWlsOwogCQl9CiAJCWlmICghcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihtc2csCiAJCQkJCSAgICAgICBSQURJVVNfQVRUUl9BQ0NUX09VVFBVVF9PQ1RFVFMsCiAJCQkJCSAgICAgICBkYXRhLnR4X2J5dGVzKSkgewotCQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIEFjY3QtT3V0cHV0LU9jdGV0c1xuIik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBBY2N0LU91dHB1dC1PY3RldHMiKTsKIAkJCWdvdG8gZmFpbDsKIAkJfQogCQlnaWdhd29yZHMgPSBzdGEtPmFjY3Rfb3V0cHV0X2dpZ2F3b3JkczsKQEAgLTMwOSwxNCArMzA5LDE0IEBACiAJCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMigKIAkJCSAgICBtc2csIFJBRElVU19BVFRSX0FDQ1RfT1VUUFVUX0dJR0FXT1JEUywKIAkJCSAgICBnaWdhd29yZHMpKSB7Ci0JCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgQWNjdC1PdXRwdXQtR2lnYXdvcmRzXG4iKTsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgYWRkIEFjY3QtT3V0cHV0LUdpZ2F3b3JkcyIpOwogCQkJZ290byBmYWlsOwogCQl9CiAJfQogCiAJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyX2ludDMyKG1zZywgUkFESVVTX0FUVFJfRVZFTlRfVElNRVNUQU1QLAogCQkJCSAgICAgICBub3cuc2VjKSkgewotCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgRXZlbnQtVGltZXN0YW1wXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBhZGQgRXZlbnQtVGltZXN0YW1wIik7CiAJCWdvdG8gZmFpbDsKIAl9CiAKQEAgLTMyNiw3ICszMjYsNyBAQAogCWlmIChzdG9wICYmIGNhdXNlICYmCiAJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyX2ludDMyKG1zZywgUkFESVVTX0FUVFJfQUNDVF9URVJNSU5BVEVfQ0FVU0UsCiAJCQkJICAgICAgIGNhdXNlKSkgewotCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgQWNjdC1UZXJtaW5hdGUtQ2F1c2VcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBBY2N0LVRlcm1pbmF0ZS1DYXVzZSIpOwogCQlnb3RvIGZhaWw7CiAJfQogCkBAIC00MDAsMTMgKzQwMCwxMiBAQAogCQkgICB2b2lkICpkYXRhKQogewogCWlmIChyYWRpdXNfbXNnX2dldF9oZHIobXNnKS0+Y29kZSAhPSBSQURJVVNfQ09ERV9BQ0NPVU5USU5HX1JFU1BPTlNFKSB7Ci0JCXByaW50ZigiVW5rbm93biBSQURJVVMgbWVzc2FnZSBjb2RlXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVua25vd24gUkFESVVTIG1lc3NhZ2UgY29kZSIpOwogCQlyZXR1cm4gUkFESVVTX1JYX1VOS05PV047CiAJfQogCiAJaWYgKHJhZGl1c19tc2dfdmVyaWZ5KG1zZywgc2hhcmVkX3NlY3JldCwgc2hhcmVkX3NlY3JldF9sZW4sIHJlcSwgMCkpIHsKLQkJcHJpbnRmKCJJbmNvbWluZyBSQURJVVMgcGFja2V0IGRpZCBub3QgaGF2ZSBjb3JyZWN0ICIKLQkJICAgICAgICJBdXRoZW50aWNhdG9yIC0gZHJvcHBlZFxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbmNvbWluZyBSQURJVVMgcGFja2V0IGRpZCBub3QgaGF2ZSBjb3JyZWN0IEF1dGhlbnRpY2F0b3IgLSBkcm9wcGVkIik7CiAJCXJldHVybiBSQURJVVNfUlhfSU5WQUxJRF9BVVRIRU5USUNBVE9SOwogCX0KIApAQCAtNDMyLDcgKzQzMSw3IEBACiAJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyX2ludDMyKG1zZywgUkFESVVTX0FUVFJfQUNDVF9URVJNSU5BVEVfQ0FVU0UsCiAJCQkJICAgICAgIFJBRElVU19BQ0NUX1RFUk1JTkFURV9DQVVTRV9OQVNfUkVCT09UKSkKIAl7Ci0JCXByaW50ZigiQ291bGQgbm90IGFkZCBBY2N0LVRlcm1pbmF0ZS1DYXVzZVxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgYWRkIEFjY3QtVGVybWluYXRlLUNhdXNlIik7CiAJCXJhZGl1c19tc2dfZnJlZShtc2cpOwogCQlyZXR1cm47CiAJfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2Fjcy5jIGIvc3JjL2FwL2Fjcy5jCmluZGV4IGQ1ZTNmNTkuLmI5NGI4YTQgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9hY3MuYworKysgYi9zcmMvYXAvYWNzLmMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKICNpbmNsdWRlICJ1dGlscy9saXN0LmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgorI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgImRyaXZlcnMvZHJpdmVyLmgiCiAjaW5jbHVkZSAiaG9zdGFwZC5oIgogI2luY2x1ZGUgImFwX2Rydl9vcHMuaCIKQEAgLTI3OSwxMCArMjgwLDExIEBACiB9CiAKIAotdm9pZCBhY3NfZmFpbChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCitzdGF0aWMgdm9pZCBhY3NfZmFpbChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7CiAJd3BhX3ByaW50ZihNU0dfRVJST1IsICJBQ1M6IEZhaWxlZCB0byBzdGFydCIpOwogCWFjc19jbGVhbnVwKGlmYWNlKTsKKwlob3N0YXBkX2Rpc2FibGVfaWZhY2UoaWZhY2UpOwogfQogCiAKQEAgLTM1MiwyMyArMzU0LDI2IEBACiB9CiAKIAotc3RhdGljIGludCBhY3NfdXNhYmxlX2NoYW4oc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICpjaGFuKQotewotCWlmIChkbF9saXN0X2VtcHR5KCZjaGFuLT5zdXJ2ZXlfbGlzdCkpCi0JCXJldHVybiAwOwotCWlmIChjaGFuLT5mbGFnICYgSE9TVEFQRF9DSEFOX0RJU0FCTEVEKQotCQlyZXR1cm4gMDsKLQlyZXR1cm4gMTsKLX0KLQotCiBzdGF0aWMgaW50IGFjc191c2FibGVfaHQ0MF9jaGFuKHN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbikKIHsKIAljb25zdCBpbnQgYWxsb3dlZFtdID0geyAzNiwgNDQsIDUyLCA2MCwgMTAwLCAxMDgsIDExNiwgMTI0LCAxMzIsIDE0OSwKIAkJCQkxNTcsIDE4NCwgMTkyIH07CiAJdW5zaWduZWQgaW50IGk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mKGFsbG93ZWQpIC8gc2l6ZW9mKGFsbG93ZWRbMF0pOyBpKyspCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoYWxsb3dlZCk7IGkrKykKKwkJaWYgKGNoYW4tPmNoYW4gPT0gYWxsb3dlZFtpXSkKKwkJCXJldHVybiAxOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBhY3NfdXNhYmxlX3ZodDgwX2NoYW4oc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICpjaGFuKQoreworCWNvbnN0IGludCBhbGxvd2VkW10gPSB7IDM2LCA1MiwgMTAwLCAxMTYsIDEzMiwgMTQ5IH07CisJdW5zaWduZWQgaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShhbGxvd2VkKTsgaSsrKQogCQlpZiAoY2hhbi0+Y2hhbiA9PSBhbGxvd2VkW2ldKQogCQkJcmV0dXJuIDE7CiAKQEAgLTM5OCwyOCArNDAzLDU0IEBACiB9CiAKIAorc3RhdGljIGludCBhY3Nfc3VydmV5X2xpc3RfaXNfc3VmZmljaWVudChzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4pCit7CisJc3RydWN0IGZyZXFfc3VydmV5ICpzdXJ2ZXk7CisKKwlkbF9saXN0X2Zvcl9lYWNoKHN1cnZleSwgJmNoYW4tPnN1cnZleV9saXN0LCBzdHJ1Y3QgZnJlcV9zdXJ2ZXksIGxpc3QpCisJeworCQlpZiAoIWFjc19zdXJ2ZXlfaXNfc3VmZmljaWVudChzdXJ2ZXkpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkFDUzogQ2hhbm5lbCAlZCBoYXMgaW5zdWZmaWNpZW50IHN1cnZleSBkYXRhIiwKKwkJCQkgICBjaGFuLT5jaGFuKTsKKwkJCXJldHVybiAwOworCQl9CisJfQorCisJcmV0dXJuIDE7CisKK30KKworCiBzdGF0aWMgaW50IGFjc19zdXJ2ZXlzX2FyZV9zdWZmaWNpZW50KHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKIHsKIAlpbnQgaTsKIAlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW47Ci0Jc3RydWN0IGZyZXFfc3VydmV5ICpzdXJ2ZXk7CisJaW50IHZhbGlkID0gMDsKIAogCWZvciAoaSA9IDA7IGkgPCBpZmFjZS0+Y3VycmVudF9tb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgewogCQljaGFuID0gJmlmYWNlLT5jdXJyZW50X21vZGUtPmNoYW5uZWxzW2ldOwogCQlpZiAoY2hhbi0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKIAkJCWNvbnRpbnVlOwogCi0JCWRsX2xpc3RfZm9yX2VhY2goc3VydmV5LCAmY2hhbi0+c3VydmV5X2xpc3QsCi0JCQkJIHN0cnVjdCBmcmVxX3N1cnZleSwgbGlzdCkKLQkJewotCQkJaWYgKCFhY3Nfc3VydmV5X2lzX3N1ZmZpY2llbnQoc3VydmV5KSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQUNTOiBDaGFubmVsICVkIGhhcyBpbnN1ZmZpY2llbnQgc3VydmV5IGRhdGEiLAotCQkJCQkgICBjaGFuLT5jaGFuKTsKLQkJCQlyZXR1cm4gMDsKLQkJCX0KLQkJfQorCQlpZiAoIWFjc19zdXJ2ZXlfbGlzdF9pc19zdWZmaWNpZW50KGNoYW4pKQorCQkJY29udGludWU7CisKKwkJdmFsaWQrKzsKIAl9CiAKKwkvKiBXZSBuZWVkIGF0IGxlYXN0IHN1cnZleSBkYXRhIGZvciBvbmUgY2hhbm5lbCAqLworCXJldHVybiAhIXZhbGlkOworfQorCisKK3N0YXRpYyBpbnQgYWNzX3VzYWJsZV9jaGFuKHN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbikKK3sKKwlpZiAoZGxfbGlzdF9lbXB0eSgmY2hhbi0+c3VydmV5X2xpc3QpKQorCQlyZXR1cm4gMDsKKwlpZiAoY2hhbi0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKKwkJcmV0dXJuIDA7CisJaWYgKCFhY3Nfc3VydmV5X2xpc3RfaXNfc3VmZmljaWVudChjaGFuKSkKKwkJcmV0dXJuIDA7CiAJcmV0dXJuIDE7CiB9CiAKQEAgLTQ1Niw3ICs0ODcsNyBAQAogCWZvciAoaSA9IDA7IGkgPCBpZmFjZS0+Y3VycmVudF9tb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgewogCQljaGFuID0gJmlmYWNlLT5jdXJyZW50X21vZGUtPmNoYW5uZWxzW2ldOwogCi0JCWlmICghYWNzX3VzYWJsZV9jaGFuKGNoYW4pKQorCQlpZiAoY2hhbi0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKIAkJCWNvbnRpbnVlOwogCiAJCWlmIChjaGFuLT5mcmVxID09IGZyZXEpCkBAIC00NzYsNyArNTA3LDggQEAKIHN0YXRpYyBzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKgogYWNzX2ZpbmRfaWRlYWxfY2hhbihzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7Ci0Jc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICpjaGFuLCAqYWRqX2NoYW4sICppZGVhbF9jaGFuID0gTlVMTDsKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4sICphZGpfY2hhbiwgKmlkZWFsX2NoYW4gPSBOVUxMLAorCQkqcmFuZF9jaGFuID0gTlVMTDsKIAlsb25nIGRvdWJsZSBmYWN0b3IsIGlkZWFsX2ZhY3RvciA9IDA7CiAJaW50IGksIGo7CiAJaW50IG5fY2hhbnMgPSAxOwpAQCAtNTA4LDkgKzU0MCwxMCBAQAogCWZvciAoaSA9IDA7IGkgPCBpZmFjZS0+Y3VycmVudF9tb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgewogCQljaGFuID0gJmlmYWNlLT5jdXJyZW50X21vZGUtPmNoYW5uZWxzW2ldOwogCi0JCWlmICghYWNzX3VzYWJsZV9jaGFuKGNoYW4pKQorCQlpZiAoY2hhbi0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKIAkJCWNvbnRpbnVlOwogCisKIAkJLyogSFQ0MCBvbiA1IEdIeiBoYXMgYSBsaW1pdGVkIHNldCBvZiBwcmltYXJ5IGNoYW5uZWxzIGFzIHBlcgogCQkgKiAxMW4gQW5uZXggSiAqLwogCQlpZiAoaWZhY2UtPmN1cnJlbnRfbW9kZS0+bW9kZSA9PSBIT1NUQVBEX01PREVfSUVFRTgwMjExQSAmJgpAQCAtNTIyLDE0ICs1NTUsMjYgQEAKIAkJCWNvbnRpbnVlOwogCQl9CiAKLQkJZmFjdG9yID0gY2hhbi0+aW50ZXJmZXJlbmNlX2ZhY3RvcjsKKwkJaWYgKGlmYWNlLT5jdXJyZW50X21vZGUtPm1vZGUgPT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEgJiYKKwkJICAgIGlmYWNlLT5jb25mLT5pZWVlODAyMTFhYyAmJgorCQkgICAgaWZhY2UtPmNvbmYtPnZodF9vcGVyX2Nod2lkdGggPT0gMSAmJgorCQkgICAgIWFjc191c2FibGVfdmh0ODBfY2hhbihjaGFuKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBQ1M6IENoYW5uZWwgJWQ6IG5vdCBhbGxvd2VkIGFzIHByaW1hcnkgY2hhbm5lbCBmb3IgVkhUODAiLAorCQkJCSAgIGNoYW4tPmNoYW4pOworCQkJY29udGludWU7CisJCX0KKworCQlmYWN0b3IgPSAwOworCQlpZiAoYWNzX3VzYWJsZV9jaGFuKGNoYW4pKQorCQkJZmFjdG9yID0gY2hhbi0+aW50ZXJmZXJlbmNlX2ZhY3RvcjsKIAogCQlmb3IgKGogPSAxOyBqIDwgbl9jaGFuczsgaisrKSB7CiAJCQlhZGpfY2hhbiA9IGFjc19maW5kX2NoYW4oaWZhY2UsIGNoYW4tPmZyZXEgKyAoaiAqIDIwKSk7CiAJCQlpZiAoIWFkal9jaGFuKQogCQkJCWJyZWFrOwogCi0JCQlmYWN0b3IgKz0gYWRqX2NoYW4tPmludGVyZmVyZW5jZV9mYWN0b3I7CisJCQlpZiAoYWNzX3VzYWJsZV9jaGFuKGFkal9jaGFuKSkKKwkJCQlmYWN0b3IgKz0gYWRqX2NoYW4tPmludGVyZmVyZW5jZV9mYWN0b3I7CiAJCX0KIAogCQlpZiAoaiAhPSBuX2NoYW5zKSB7CkBAIC01NDgsMjIgKzU5MywyMiBAQAogCiAJCQkJYWRqX2NoYW4gPSBhY3NfZmluZF9jaGFuKGlmYWNlLCBjaGFuLT5mcmVxICsKIAkJCQkJCQkgKGogKiAyMCkgLSA1KTsKLQkJCQlpZiAoYWRqX2NoYW4pCisJCQkJaWYgKGFkal9jaGFuICYmIGFjc191c2FibGVfY2hhbihhZGpfY2hhbikpCiAJCQkJCWZhY3RvciArPSBhZGpfY2hhbi0+aW50ZXJmZXJlbmNlX2ZhY3RvcjsKIAogCQkJCWFkal9jaGFuID0gYWNzX2ZpbmRfY2hhbihpZmFjZSwgY2hhbi0+ZnJlcSArCiAJCQkJCQkJIChqICogMjApIC0gMTApOwotCQkJCWlmIChhZGpfY2hhbikKKwkJCQlpZiAoYWRqX2NoYW4gJiYgYWNzX3VzYWJsZV9jaGFuKGFkal9jaGFuKSkKIAkJCQkJZmFjdG9yICs9IGFkal9jaGFuLT5pbnRlcmZlcmVuY2VfZmFjdG9yOwogCiAJCQkJYWRqX2NoYW4gPSBhY3NfZmluZF9jaGFuKGlmYWNlLCBjaGFuLT5mcmVxICsKIAkJCQkJCQkgKGogKiAyMCkgKyA1KTsKLQkJCQlpZiAoYWRqX2NoYW4pCisJCQkJaWYgKGFkal9jaGFuICYmIGFjc191c2FibGVfY2hhbihhZGpfY2hhbikpCiAJCQkJCWZhY3RvciArPSBhZGpfY2hhbi0+aW50ZXJmZXJlbmNlX2ZhY3RvcjsKIAogCQkJCWFkal9jaGFuID0gYWNzX2ZpbmRfY2hhbihpZmFjZSwgY2hhbi0+ZnJlcSArCiAJCQkJCQkJIChqICogMjApICsgMTApOwotCQkJCWlmIChhZGpfY2hhbikKKwkJCQlpZiAoYWRqX2NoYW4gJiYgYWNzX3VzYWJsZV9jaGFuKGFkal9jaGFuKSkKIAkJCQkJZmFjdG9yICs9IGFkal9jaGFuLT5pbnRlcmZlcmVuY2VfZmFjdG9yOwogCQkJfQogCQl9CkBAIC01NzEsMzkgKzYxNiw0OSBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFDUzogICogY2hhbm5lbCAlZDogdG90YWwgaW50ZXJmZXJlbmNlID0gJUxnIiwKIAkJCSAgIGNoYW4tPmNoYW4sIGZhY3Rvcik7CiAKLQkJaWYgKCFpZGVhbF9jaGFuIHx8IGZhY3RvciA8IGlkZWFsX2ZhY3RvcikgeworCQlpZiAoYWNzX3VzYWJsZV9jaGFuKGNoYW4pICYmCisJCSAgICAoIWlkZWFsX2NoYW4gfHwgZmFjdG9yIDwgaWRlYWxfZmFjdG9yKSkgewogCQkJaWRlYWxfZmFjdG9yID0gZmFjdG9yOwogCQkJaWRlYWxfY2hhbiA9IGNoYW47CiAJCX0KKworCQkvKiBUaGlzIGNoYW5uZWwgd291bGQgYXQgbGVhc3QgYmUgdXNhYmxlICovCisJCWlmICghcmFuZF9jaGFuKQorCQkJcmFuZF9jaGFuID0gY2hhbjsKIAl9CiAKLQlpZiAoaWRlYWxfY2hhbikKKwlpZiAoaWRlYWxfY2hhbikgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFDUzogSWRlYWwgY2hhbm5lbCBpcyAlZCAoJWQgTUh6KSB3aXRoIHRvdGFsIGludGVyZmVyZW5jZSBmYWN0b3Igb2YgJUxnIiwKIAkJCSAgIGlkZWFsX2NoYW4tPmNoYW4sIGlkZWFsX2NoYW4tPmZyZXEsIGlkZWFsX2ZhY3Rvcik7CisJCXJldHVybiBpZGVhbF9jaGFuOworCX0KIAotCXJldHVybiBpZGVhbF9jaGFuOworCXJldHVybiByYW5kX2NoYW47CiB9CiAKIAogc3RhdGljIHZvaWQgYWNzX2FkanVzdF92aHRfY2VudGVyX2ZyZXEoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQogeworCWludCBvZmZzZXQ7CisKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFDUzogQWRqdXN0aW5nIFZIVCBjZW50ZXIgZnJlcXVlbmN5Iik7CiAKIAlzd2l0Y2ggKGlmYWNlLT5jb25mLT52aHRfb3Blcl9jaHdpZHRoKSB7CiAJY2FzZSBWSFRfQ0hBTldJRFRIX1VTRV9IVDoKLQkJaWZhY2UtPmNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHggPQotCQkJaWZhY2UtPmNvbmYtPmNoYW5uZWwgKyAyOworCQlvZmZzZXQgPSAyICogaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsOwogCQlicmVhazsKIAljYXNlIFZIVF9DSEFOV0lEVEhfODBNSFo6Ci0JCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0KLQkJCWlmYWNlLT5jb25mLT5jaGFubmVsICsgNjsKKwkJb2Zmc2V0ID0gNjsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJLyogVE9ETzogSG93IGNhbiB0aGlzIGJlIGNhbGN1bGF0ZWQ/IEFkanVzdAogCQkgKiBhY3NfZmluZF9pZGVhbF9jaGFuKCkgKi8KIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkFDUzogT25seSBWSFQyMC80MC84MCBpcyBzdXBwb3J0ZWQgbm93Iik7Ci0JCWJyZWFrOworCQlyZXR1cm47CiAJfQorCisJaWZhY2UtPmNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHggPQorCQlpZmFjZS0+Y29uZi0+Y2hhbm5lbCArIG9mZnNldDsKIH0KIAogCkBAIC02NTUsNiArNzEwLDcgQEAKIAlpZGVhbF9jaGFuID0gYWNzX2ZpbmRfaWRlYWxfY2hhbihpZmFjZSk7CiAJaWYgKCFpZGVhbF9jaGFuKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQUNTOiBGYWlsZWQgdG8gY29tcHV0ZSBpZGVhbCBjaGFubmVsIik7CisJCWVyciA9IC0xOwogCQlnb3RvIGZhaWw7CiAJfQogCkBAIC02NjMsMjQgKzcxOSwyMCBAQAogCWlmIChpZmFjZS0+Y29uZi0+aWVlZTgwMjExYWMpCiAJCWFjc19hZGp1c3Rfdmh0X2NlbnRlcl9mcmVxKGlmYWNlKTsKIAorCWVyciA9IDA7CitmYWlsOgogCS8qCiAJICogaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2VfY29tcGxldGUoKSB3aWxsIHJldHVybiAtMSBvbiBmYWlsdXJlLAogCSAqIDAgb24gc3VjY2VzcyBhbmQgMCBpcyBIT1NUQVBEX0NIQU5fVkFMSUQgOikKIAkgKi8KLQlzd2l0Y2ggKGhvc3RhcGRfYWNzX2NvbXBsZXRlZChpZmFjZSkpIHsKLQljYXNlIEhPU1RBUERfQ0hBTl9WQUxJRDoKKwlpZiAoaG9zdGFwZF9hY3NfY29tcGxldGVkKGlmYWNlLCBlcnIpID09IEhPU1RBUERfQ0hBTl9WQUxJRCkgewogCQlhY3NfY2xlYW51cChpZmFjZSk7CiAJCXJldHVybjsKLQljYXNlIEhPU1RBUERfQ0hBTl9JTlZBTElEOgotCWNhc2UgSE9TVEFQRF9DSEFOX0FDUzoKLQlkZWZhdWx0OgotCQkvKiBUaGlzIGNhbiBwb3NzaWJseSBoYXBwZW4gaWYgY2hhbm5lbCBwYXJhbWV0ZXJzIChzZWNvbmRhcnkKLQkJICogY2hhbm5lbCwgY2VudGVyIGZyZXF1ZW5jaWVzKSBhcmUgbWlzY29uZmlndXJlZCAqLwotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkFDUzogUG9zc2libHkgY2hhbm5lbCBjb25maWd1cmF0aW9uIGlzIGludmFsaWQsIHBsZWFzZSByZXBvcnQgdGhpcyBhbG9uZyB3aXRoIHlvdXIgY29uZmlnIGZpbGUuIik7Ci0JCWdvdG8gZmFpbDsKIAl9CiAKLWZhaWw6CisJLyogVGhpcyBjYW4gcG9zc2libHkgaGFwcGVuIGlmIGNoYW5uZWwgcGFyYW1ldGVycyAoc2Vjb25kYXJ5CisJICogY2hhbm5lbCwgY2VudGVyIGZyZXF1ZW5jaWVzKSBhcmUgbWlzY29uZmlndXJlZCAqLworCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQUNTOiBQb3NzaWJseSBjaGFubmVsIGNvbmZpZ3VyYXRpb24gaXMgaW52YWxpZCwgcGxlYXNlIHJlcG9ydCB0aGlzIGFsb25nIHdpdGggeW91ciBjb25maWcgZmlsZS4iKTsKIAlhY3NfZmFpbChpZmFjZSk7CiB9CiAKQEAgLTY5NywyMSArNzQ5LDI0IEBACiAJZXJyID0gaG9zdGFwZF9kcnZfZ2V0X3N1cnZleShpZmFjZS0+YnNzWzBdLCAwKTsKIAlpZiAoZXJyKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQUNTOiBGYWlsZWQgdG8gZ2V0IHN1cnZleSBkYXRhIik7Ci0JCWFjc19mYWlsKGlmYWNlKTsKKwkJZ290byBmYWlsOwogCX0KIAogCWlmICgrK2lmYWNlLT5hY3NfbnVtX2NvbXBsZXRlZF9zY2FucyA8IGlmYWNlLT5jb25mLT5hY3NfbnVtX3NjYW5zKSB7CiAJCWVyciA9IGFjc19yZXF1ZXN0X3NjYW4oaWZhY2UpOwogCQlpZiAoZXJyKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkFDUzogRmFpbGVkIHRvIHJlcXVlc3Qgc2NhbiIpOwotCQkJYWNzX2ZhaWwoaWZhY2UpOwotCQkJcmV0dXJuOworCQkJZ290byBmYWlsOwogCQl9CiAKIAkJcmV0dXJuOwogCX0KIAogCWFjc19zdHVkeShpZmFjZSk7CisJcmV0dXJuOworZmFpbDoKKwlob3N0YXBkX2Fjc19jb21wbGV0ZWQoaWZhY2UsIDEpOworCWFjc19mYWlsKGlmYWNlKTsKIH0KIAogCkBAIC03NDYsNiArODAxLDcgQEAKIAlpZiAoaG9zdGFwZF9kcml2ZXJfc2NhbihpZmFjZS0+YnNzWzBdLCAmcGFyYW1zKSA8IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJBQ1M6IEZhaWxlZCB0byByZXF1ZXN0IGluaXRpYWwgc2NhbiIpOwogCQlhY3NfY2xlYW51cChpZmFjZSk7CisJCW9zX2ZyZWUocGFyYW1zLmZyZXFzKTsKIAkJcmV0dXJuIC0xOwogCX0KIApAQCAtNzY2LDUgKzgyMiw4IEBACiAJaWYgKGVyciA8IDApCiAJCXJldHVybiBIT1NUQVBEX0NIQU5fSU5WQUxJRDsKIAorCWhvc3RhcGRfc2V0X3N0YXRlKGlmYWNlLCBIQVBEX0lGQUNFX0FDUyk7CisJd3BhX21zZyhpZmFjZS0+YnNzWzBdLT5tc2dfY3R4LCBNU0dfSU5GTywgQUNTX0VWRU5UX1NUQVJURUQpOworCiAJcmV0dXJuIEhPU1RBUERfQ0hBTl9BQ1M7CiB9CmRpZmYgLS1naXQgYS9zcmMvYXAvYWNzLmggYi9zcmMvYXAvYWNzLmgKaW5kZXggMGQxZDBmMS4uZmM4NTI1OSAxMDA2NDQKLS0tIGEvc3JjL2FwL2Fjcy5oCisrKyBiL3NyYy9hcC9hY3MuaApAQCAtMTMsNyArMTMsNiBAQAogI2lmZGVmIENPTkZJR19BQ1MKIAogZW51bSBob3N0YXBkX2NoYW5fc3RhdHVzIGFjc19pbml0KHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7Ci1pbnQgaG9zdGFwZF9hY3NfY29tcGxldGVkKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7CiAKICNlbHNlIC8qIENPTkZJR19BQ1MgKi8KIApkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX2NvbmZpZy5jIGIvc3JjL2FwL2FwX2NvbmZpZy5jCmluZGV4IGNhZjc1YzQuLmQxMjc1NTAgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9hcF9jb25maWcuYworKysgYi9zcmMvYXAvYXBfY29uZmlnLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAvIENvbmZpZ3VyYXRpb24gaGVscGVyIGZ1bmN0aW9ucwotICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNzMsNiArNzMsNyBAQAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJYnNzLT5hc3NvY19zYV9xdWVyeV9tYXhfdGltZW91dCA9IDEwMDA7CiAJYnNzLT5hc3NvY19zYV9xdWVyeV9yZXRyeV90aW1lb3V0ID0gMjAxOworCWJzcy0+Z3JvdXBfbWdtdF9jaXBoZXIgPSBXUEFfQ0lQSEVSX0FFU18xMjhfQ01BQzsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogI2lmZGVmIEVBUF9TRVJWRVJfRkFTVAogCSAvKiBib3RoIGFub255bW91cyBhbmQgYXV0aGVudGljYXRlZCBwcm92aXNpb25pbmcgKi8KQEAgLTEwNiw5ICsxMDcsOSBAQAogCWNvbnN0IHN0cnVjdCBob3N0YXBkX3dtbV9hY19wYXJhbXMgYWNfYmUgPQogCQl7IGFDV21pbiwgYUNXbWF4LCAzLCAwLCAwIH07IC8qIGJlc3QgZWZmb3J0IHRyYWZmaWMgKi8KIAljb25zdCBzdHJ1Y3QgaG9zdGFwZF93bW1fYWNfcGFyYW1zIGFjX3ZpID0gLyogdmlkZW8gdHJhZmZpYyAqLwotCQl7IGFDV21pbiAtIDEsIGFDV21pbiwgMiwgMzAwMCAvIDMyLCAwIH07CisJCXsgYUNXbWluIC0gMSwgYUNXbWluLCAyLCAzMDA4IC8gMzIsIDAgfTsKIAljb25zdCBzdHJ1Y3QgaG9zdGFwZF93bW1fYWNfcGFyYW1zIGFjX3ZvID0gLyogdm9pY2UgdHJhZmZpYyAqLwotCQl7IGFDV21pbiAtIDIsIGFDV21pbiAtIDEsIDIsIDE1MDAgLyAzMiwgMCB9OworCQl7IGFDV21pbiAtIDIsIGFDV21pbiAtIDEsIDIsIDE1MDQgLyAzMiwgMCB9OwogCWNvbnN0IHN0cnVjdCBob3N0YXBkX3R4X3F1ZXVlX3BhcmFtcyB0eHFfYmsgPQogCQl7IDcsIGVjdzJjdyhhQ1dtaW4pLCBlY3cyY3coYUNXbWF4KSwgMCB9OwogCWNvbnN0IHN0cnVjdCBob3N0YXBkX3R4X3F1ZXVlX3BhcmFtcyB0eHFfYmUgPQpAQCAtMTMwLDkgKzEzMSwxNyBAQAogCQlvc19mcmVlKGJzcyk7CiAJCXJldHVybiBOVUxMOwogCX0KKwljb25mLT5ic3MgPSBvc19jYWxsb2MoMSwgc2l6ZW9mKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKikpOworCWlmIChjb25mLT5ic3MgPT0gTlVMTCkgeworCQlvc19mcmVlKGNvbmYpOworCQlvc19mcmVlKGJzcyk7CisJCXJldHVybiBOVUxMOworCX0KKwljb25mLT5ic3NbMF0gPSBic3M7CiAKIAlic3MtPnJhZGl1cyA9IG9zX3phbGxvYyhzaXplb2YoKmJzcy0+cmFkaXVzKSk7CiAJaWYgKGJzcy0+cmFkaXVzID09IE5VTEwpIHsKKwkJb3NfZnJlZShjb25mLT5ic3MpOwogCQlvc19mcmVlKGNvbmYpOwogCQlvc19mcmVlKGJzcyk7CiAJCXJldHVybiBOVUxMOwpAQCAtMTQxLDEyICsxNTAsMTMgQEAKIAlob3N0YXBkX2NvbmZpZ19kZWZhdWx0c19ic3MoYnNzKTsKIAogCWNvbmYtPm51bV9ic3MgPSAxOwotCWNvbmYtPmJzcyA9IGJzczsKIAogCWNvbmYtPmJlYWNvbl9pbnQgPSAxMDA7CiAJY29uZi0+cnRzX3RocmVzaG9sZCA9IC0xOyAvKiB1c2UgZHJpdmVyIGRlZmF1bHQ6IDIzNDcgKi8KIAljb25mLT5mcmFnbV90aHJlc2hvbGQgPSAtMTsgLyogdXNlciBkcml2ZXIgZGVmYXVsdDogMjM0NiAqLwogCWNvbmYtPnNlbmRfcHJvYmVfcmVzcG9uc2UgPSAxOworCS8qIFNldCB0byBpbnZhbGlkIHZhbHVlIG1lYW5zIGRvIG5vdCBhZGQgUG93ZXIgQ29uc3RyYWludCBJRSAqLworCWNvbmYtPmxvY2FsX3B3cl9jb25zdHJhaW50ID0gLTE7CiAKIAljb25mLT53bW1fYWNfcGFyYW1zWzBdID0gYWNfYmU7CiAJY29uZi0+d21tX2FjX3BhcmFtc1sxXSA9IGFjX2JrOwpAQCAtMTY0LDExICsxNzQsMTEgQEAKIAljb25mLT5hcF90YWJsZV9leHBpcmF0aW9uX3RpbWUgPSA2MDsKIAogI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKLQljb25mLT5pZ25vcmVfcHJvYmVfcHJvYmFiaWxpdHkgPSAwLjBkOwotCWNvbmYtPmlnbm9yZV9hdXRoX3Byb2JhYmlsaXR5ID0gMC4wZDsKLQljb25mLT5pZ25vcmVfYXNzb2NfcHJvYmFiaWxpdHkgPSAwLjBkOwotCWNvbmYtPmlnbm9yZV9yZWFzc29jX3Byb2JhYmlsaXR5ID0gMC4wZDsKLQljb25mLT5jb3JydXB0X2d0a19yZWtleV9taWNfcHJvYmFiaWxpdHkgPSAwLjBkOworCWNvbmYtPmlnbm9yZV9wcm9iZV9wcm9iYWJpbGl0eSA9IDAuMDsKKwljb25mLT5pZ25vcmVfYXV0aF9wcm9iYWJpbGl0eSA9IDAuMDsKKwljb25mLT5pZ25vcmVfYXNzb2NfcHJvYmFiaWxpdHkgPSAwLjA7CisJY29uZi0+aWdub3JlX3JlYXNzb2NfcHJvYmFiaWxpdHkgPSAwLjA7CisJY29uZi0+Y29ycnVwdF9ndGtfcmVrZXlfbWljX3Byb2JhYmlsaXR5ID0gMC4wOwogI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KIAogI2lmZGVmIENPTkZJR19BQ1MKQEAgLTMyOSwyMCArMzM5LDYgQEAKIH0KIAogCi1pbnQgaG9zdGFwZF93ZXBfa2V5X2NtcChzdHJ1Y3QgaG9zdGFwZF93ZXBfa2V5cyAqYSwgc3RydWN0IGhvc3RhcGRfd2VwX2tleXMgKmIpCi17Ci0JaW50IGk7Ci0KLQlpZiAoYS0+aWR4ICE9IGItPmlkeCB8fCBhLT5kZWZhdWx0X2xlbiAhPSBiLT5kZWZhdWx0X2xlbikKLQkJcmV0dXJuIDE7Ci0JZm9yIChpID0gMDsgaSA8IE5VTV9XRVBfS0VZUzsgaSsrKQotCQlpZiAoYS0+bGVuW2ldICE9IGItPmxlbltpXSB8fAotCQkgICAgb3NfbWVtY21wKGEtPmtleVtpXSwgYi0+a2V5W2ldLCBhLT5sZW5baV0pICE9IDApCi0JCQlyZXR1cm4gMTsKLQlyZXR1cm4gMDsKLX0KLQotCiBzdGF0aWMgdm9pZCBob3N0YXBkX2NvbmZpZ19mcmVlX3JhZGl1cyhzdHJ1Y3QgaG9zdGFwZF9yYWRpdXNfc2VydmVyICpzZXJ2ZXJzLAogCQkJCSAgICAgICBpbnQgbnVtX3NlcnZlcnMpCiB7CkBAIC0zNzksMTAgKzM3NSwxMSBAQAogfQogCiAKLXN0YXRpYyB2b2lkIGhvc3RhcGRfY29uZmlnX2ZyZWVfZWFwX3VzZXIoc3RydWN0IGhvc3RhcGRfZWFwX3VzZXIgKnVzZXIpCit2b2lkIGhvc3RhcGRfY29uZmlnX2ZyZWVfZWFwX3VzZXIoc3RydWN0IGhvc3RhcGRfZWFwX3VzZXIgKnVzZXIpCiB7CisJaG9zdGFwZF9jb25maWdfZnJlZV9yYWRpdXNfYXR0cih1c2VyLT5hY2NlcHRfYXR0cik7CiAJb3NfZnJlZSh1c2VyLT5pZGVudGl0eSk7Ci0Jb3NfZnJlZSh1c2VyLT5wYXNzd29yZCk7CisJYmluX2NsZWFyX2ZyZWUodXNlci0+cGFzc3dvcmQsIHVzZXItPnBhc3N3b3JkX2xlbik7CiAJb3NfZnJlZSh1c2VyKTsKIH0KIApAQCAtMzkxLDEzICszODgsMTMgQEAKIHsKIAlpbnQgaTsKIAlmb3IgKGkgPSAwOyBpIDwgTlVNX1dFUF9LRVlTOyBpKyspIHsKLQkJb3NfZnJlZShrZXlzLT5rZXlbaV0pOworCQliaW5fY2xlYXJfZnJlZShrZXlzLT5rZXlbaV0sIGtleXMtPmxlbltpXSk7CiAJCWtleXMtPmtleVtpXSA9IE5VTEw7CiAJfQogfQogCiAKLXN0YXRpYyB2b2lkIGhvc3RhcGRfY29uZmlnX2ZyZWVfYnNzKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmNvbmYpCit2b2lkIGhvc3RhcGRfY29uZmlnX2ZyZWVfYnNzKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmNvbmYpCiB7CiAJc3RydWN0IGhvc3RhcGRfd3BhX3BzayAqcHNrLCAqcHJldjsKIAlzdHJ1Y3QgaG9zdGFwZF9lYXBfdXNlciAqdXNlciwgKnByZXZfdXNlcjsKQEAgLTQwOSwxMCArNDA2LDEwIEBACiAJd2hpbGUgKHBzaykgewogCQlwcmV2ID0gcHNrOwogCQlwc2sgPSBwc2stPm5leHQ7Ci0JCW9zX2ZyZWUocHJldik7CisJCWJpbl9jbGVhcl9mcmVlKHByZXYsIHNpemVvZigqcHJldikpOwogCX0KIAotCW9zX2ZyZWUoY29uZi0+c3NpZC53cGFfcGFzc3BocmFzZSk7CisJc3RyX2NsZWFyX2ZyZWUoY29uZi0+c3NpZC53cGFfcGFzc3BocmFzZSk7CiAJb3NfZnJlZShjb25mLT5zc2lkLndwYV9wc2tfZmlsZSk7CiAJaG9zdGFwZF9jb25maWdfZnJlZV93ZXAoJmNvbmYtPnNzaWQud2VwKTsKICNpZmRlZiBDT05GSUdfRlVMTF9EWU5BTUlDX1ZMQU4KQEAgLTQyNywxNSArNDI0LDE2IEBACiAJfQogCW9zX2ZyZWUoY29uZi0+ZWFwX3VzZXJfc3FsaXRlKTsKIAotCW9zX2ZyZWUoY29uZi0+ZHVtcF9sb2dfbmFtZSk7CiAJb3NfZnJlZShjb25mLT5lYXBfcmVxX2lkX3RleHQpOwogCW9zX2ZyZWUoY29uZi0+YWNjZXB0X21hYyk7CiAJb3NfZnJlZShjb25mLT5kZW55X21hYyk7CiAJb3NfZnJlZShjb25mLT5uYXNfaWRlbnRpZmllcik7Ci0JaG9zdGFwZF9jb25maWdfZnJlZV9yYWRpdXMoY29uZi0+cmFkaXVzLT5hdXRoX3NlcnZlcnMsCi0JCQkJICAgY29uZi0+cmFkaXVzLT5udW1fYXV0aF9zZXJ2ZXJzKTsKLQlob3N0YXBkX2NvbmZpZ19mcmVlX3JhZGl1cyhjb25mLT5yYWRpdXMtPmFjY3Rfc2VydmVycywKLQkJCQkgICBjb25mLT5yYWRpdXMtPm51bV9hY2N0X3NlcnZlcnMpOworCWlmIChjb25mLT5yYWRpdXMpIHsKKwkJaG9zdGFwZF9jb25maWdfZnJlZV9yYWRpdXMoY29uZi0+cmFkaXVzLT5hdXRoX3NlcnZlcnMsCisJCQkJCSAgIGNvbmYtPnJhZGl1cy0+bnVtX2F1dGhfc2VydmVycyk7CisJCWhvc3RhcGRfY29uZmlnX2ZyZWVfcmFkaXVzKGNvbmYtPnJhZGl1cy0+YWNjdF9zZXJ2ZXJzLAorCQkJCQkgICBjb25mLT5yYWRpdXMtPm51bV9hY2N0X3NlcnZlcnMpOworCX0KIAlob3N0YXBkX2NvbmZpZ19mcmVlX3JhZGl1c19hdHRyKGNvbmYtPnJhZGl1c19hdXRoX3JlcV9hdHRyKTsKIAlob3N0YXBkX2NvbmZpZ19mcmVlX3JhZGl1c19hdHRyKGNvbmYtPnJhZGl1c19hY2N0X3JlcV9hdHRyKTsKIAlvc19mcmVlKGNvbmYtPnJzbl9wcmVhdXRoX2ludGVyZmFjZXMpOwpAQCAtNTE4LDEzICs1MTYsMzYgQEAKIAlvc19mcmVlKGNvbmYtPmhzMjBfd2FuX21ldHJpY3MpOwogCW9zX2ZyZWUoY29uZi0+aHMyMF9jb25uZWN0aW9uX2NhcGFiaWxpdHkpOwogCW9zX2ZyZWUoY29uZi0+aHMyMF9vcGVyYXRpbmdfY2xhc3MpOworCW9zX2ZyZWUoY29uZi0+aHMyMF9pY29ucyk7CisJaWYgKGNvbmYtPmhzMjBfb3N1X3Byb3ZpZGVycykgeworCQlzaXplX3QgaTsKKwkJZm9yIChpID0gMDsgaSA8IGNvbmYtPmhzMjBfb3N1X3Byb3ZpZGVyc19jb3VudDsgaSsrKSB7CisJCQlzdHJ1Y3QgaHMyMF9vc3VfcHJvdmlkZXIgKnA7CisJCQlzaXplX3QgajsKKwkJCXAgPSAmY29uZi0+aHMyMF9vc3VfcHJvdmlkZXJzW2ldOworCQkJb3NfZnJlZShwLT5mcmllbmRseV9uYW1lKTsKKwkJCW9zX2ZyZWUocC0+c2VydmVyX3VyaSk7CisJCQlvc19mcmVlKHAtPm1ldGhvZF9saXN0KTsKKwkJCWZvciAoaiA9IDA7IGogPCBwLT5pY29uc19jb3VudDsgaisrKQorCQkJCW9zX2ZyZWUocC0+aWNvbnNbal0pOworCQkJb3NfZnJlZShwLT5pY29ucyk7CisJCQlvc19mcmVlKHAtPm9zdV9uYWkpOworCQkJb3NfZnJlZShwLT5zZXJ2aWNlX2Rlc2MpOworCQl9CisJCW9zX2ZyZWUoY29uZi0+aHMyMF9vc3VfcHJvdmlkZXJzKTsKKwl9CisJb3NfZnJlZShjb25mLT5zdWJzY3JfcmVtZWRpYXRpb25fdXJsKTsKICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCiAJd3BhYnVmX2ZyZWUoY29uZi0+dmVuZG9yX2VsZW1lbnRzKTsKIAogCW9zX2ZyZWUoY29uZi0+c2FlX2dyb3Vwcyk7CiAKKwlvc19mcmVlKGNvbmYtPndvd2xhbl90cmlnZ2Vycyk7CisKIAlvc19mcmVlKGNvbmYtPnNlcnZlcl9pZCk7CisKKwlvc19mcmVlKGNvbmYpOwogfQogCiAKQEAgLTU0MCwxMCArNTYxLDExIEBACiAJCXJldHVybjsKIAogCWZvciAoaSA9IDA7IGkgPCBjb25mLT5udW1fYnNzOyBpKyspCi0JCWhvc3RhcGRfY29uZmlnX2ZyZWVfYnNzKCZjb25mLT5ic3NbaV0pOworCQlob3N0YXBkX2NvbmZpZ19mcmVlX2Jzcyhjb25mLT5ic3NbaV0pOwogCW9zX2ZyZWUoY29uZi0+YnNzKTsKIAlvc19mcmVlKGNvbmYtPnN1cHBvcnRlZF9yYXRlcyk7CiAJb3NfZnJlZShjb25mLT5iYXNpY19yYXRlcyk7CisJb3NfZnJlZShjb25mLT5jaGFubGlzdCk7CiAKIAlvc19mcmVlKGNvbmYpOwogfQpAQCAtNjMxLDEyICs2NTMsMTEgQEAKIAlzdHJ1Y3QgaG9zdGFwZF93cGFfcHNrICpwc2s7CiAJaW50IG5leHRfb2sgPSBwcmV2X3BzayA9PSBOVUxMOwogCi0JaWYgKHAycF9kZXZfYWRkcikgeworCWlmIChwMnBfZGV2X2FkZHIgJiYgIWlzX3plcm9fZXRoZXJfYWRkcihwMnBfZGV2X2FkZHIpKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU2VhcmNoaW5nIGEgUFNLIGZvciAiIE1BQ1NUUgogCQkJICAgIiBwMnBfZGV2X2FkZHI9IiBNQUNTVFIgIiBwcmV2X3Bzaz0lcCIsCiAJCQkgICBNQUMyU1RSKGFkZHIpLCBNQUMyU1RSKHAycF9kZXZfYWRkciksIHByZXZfcHNrKTsKLQkJaWYgKCFpc196ZXJvX2V0aGVyX2FkZHIocDJwX2Rldl9hZGRyKSkKLQkJCWFkZHIgPSBOVUxMOyAvKiBVc2UgUDJQIERldmljZSBBZGRyZXNzIGZvciBtYXRjaGluZyAqLworCQlhZGRyID0gTlVMTDsgLyogVXNlIFAyUCBEZXZpY2UgQWRkcmVzcyBmb3IgbWF0Y2hpbmcgKi8KIAl9IGVsc2UgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNlYXJjaGluZyBhIFBTSyBmb3IgIiBNQUNTVFIKIAkJCSAgICIgcHJldl9wc2s9JXAiLApAQCAtNjU4LDMgKzY3OSwyMzggQEAKIAogCXJldHVybiBOVUxMOwogfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jb25maWdfY2hlY2tfYnNzKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcywKKwkJCQkgICAgc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mLAorCQkJCSAgICBpbnQgZnVsbF9jb25maWcpCit7CisJaWYgKGZ1bGxfY29uZmlnICYmIGJzcy0+aWVlZTgwMl8xeCAmJiAhYnNzLT5lYXBfc2VydmVyICYmCisJICAgICFic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXJzKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSW52YWxpZCBJRUVFIDgwMi4xWCBjb25maWd1cmF0aW9uIChubyAiCisJCQkgICAiRUFQIGF1dGhlbnRpY2F0b3IgY29uZmlndXJlZCkuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoYnNzLT53cGEpIHsKKwkJaW50IHdlcCwgaTsKKworCQl3ZXAgPSBic3MtPmRlZmF1bHRfd2VwX2tleV9sZW4gPiAwIHx8CisJCSAgICAgICBic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPiAwOworCQlmb3IgKGkgPSAwOyBpIDwgTlVNX1dFUF9LRVlTOyBpKyspIHsKKwkJCWlmIChic3MtPnNzaWQud2VwLmtleXNfc2V0KSB7CisJCQkJd2VwID0gMTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCisJCWlmICh3ZXApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV0VQIGNvbmZpZ3VyYXRpb24gaW4gYSBXUEEgbmV0d29yayBpcyBub3Qgc3VwcG9ydGVkIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlpZiAoZnVsbF9jb25maWcgJiYgYnNzLT53cGEgJiYKKwkgICAgYnNzLT53cGFfcHNrX3JhZGl1cyAhPSBQU0tfUkFESVVTX0lHTk9SRUQgJiYKKwkgICAgYnNzLT5tYWNhZGRyX2FjbCAhPSBVU0VfRVhURVJOQUxfUkFESVVTX0FVVEgpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUEEtUFNLIHVzaW5nIFJBRElVUyBlbmFibGVkLCBidXQgbm8gIgorCQkJICAgIlJBRElVUyBjaGVja2luZyAobWFjYWRkcl9hY2w9MikgZW5hYmxlZC4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChmdWxsX2NvbmZpZyAmJiBic3MtPndwYSAmJiAoYnNzLT53cGFfa2V5X21nbXQgJiBXUEFfS0VZX01HTVRfUFNLKSAmJgorCSAgICBic3MtPnNzaWQud3BhX3BzayA9PSBOVUxMICYmIGJzcy0+c3NpZC53cGFfcGFzc3BocmFzZSA9PSBOVUxMICYmCisJICAgIGJzcy0+c3NpZC53cGFfcHNrX2ZpbGUgPT0gTlVMTCAmJgorCSAgICAoYnNzLT53cGFfcHNrX3JhZGl1cyAhPSBQU0tfUkFESVVTX1JFUVVJUkVEIHx8CisJICAgICBic3MtPm1hY2FkZHJfYWNsICE9IFVTRV9FWFRFUk5BTF9SQURJVVNfQVVUSCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUEEtUFNLIGVuYWJsZWQsIGJ1dCBQU0sgb3IgcGFzc3BocmFzZSAiCisJCQkgICAiaXMgbm90IGNvbmZpZ3VyZWQuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoZnVsbF9jb25maWcgJiYgaG9zdGFwZF9tYWNfY29tcF9lbXB0eShic3MtPmJzc2lkKSAhPSAwKSB7CisJCXNpemVfdCBpOworCisJCWZvciAoaSA9IDA7IGkgPCBjb25mLT5udW1fYnNzOyBpKyspIHsKKwkJCWlmIChjb25mLT5ic3NbaV0gIT0gYnNzICYmCisJCQkgICAgKGhvc3RhcGRfbWFjX2NvbXAoY29uZi0+YnNzW2ldLT5ic3NpZCwKKwkJCQkJICAgICAgYnNzLT5ic3NpZCkgPT0gMCkpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkR1cGxpY2F0ZSBCU1NJRCAiIE1BQ1NUUgorCQkJCQkgICAiIG9uIGludGVyZmFjZSAnJXMnIGFuZCAnJXMnLiIsCisJCQkJCSAgIE1BQzJTVFIoYnNzLT5ic3NpZCksCisJCQkJCSAgIGNvbmYtPmJzc1tpXS0+aWZhY2UsIGJzcy0+aWZhY2UpOworCQkJCXJldHVybiAtMTsKKwkJCX0KKwkJfQorCX0KKworI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCisJaWYgKGZ1bGxfY29uZmlnICYmIHdwYV9rZXlfbWdtdF9mdChic3MtPndwYV9rZXlfbWdtdCkgJiYKKwkgICAgKGJzcy0+bmFzX2lkZW50aWZpZXIgPT0gTlVMTCB8fAorCSAgICAgb3Nfc3RybGVuKGJzcy0+bmFzX2lkZW50aWZpZXIpIDwgMSB8fAorCSAgICAgb3Nfc3RybGVuKGJzcy0+bmFzX2lkZW50aWZpZXIpID4gRlRfUjBLSF9JRF9NQVhfTEVOKSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZUIChJRUVFIDgwMi4xMXIpIHJlcXVpcmVzICIKKwkJCSAgICJuYXNfaWRlbnRpZmllciB0byBiZSBjb25maWd1cmVkIGFzIGEgMS4uNDggb2N0ZXQgIgorCQkJICAgInN0cmluZyIpOworCQlyZXR1cm4gLTE7CisJfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCisKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExTgorCWlmIChmdWxsX2NvbmZpZyAmJiBjb25mLT5pZWVlODAyMTFuICYmCisJICAgIGNvbmYtPmh3X21vZGUgPT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUIpIHsKKwkJYnNzLT5kaXNhYmxlXzExbiA9IDE7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSFQgKElFRUUgODAyLjExbikgaW4gMTFiIG1vZGUgaXMgbm90ICIKKwkJCSAgICJhbGxvd2VkLCBkaXNhYmxpbmcgSFQgY2FwYWJpbGl0ZXMiKTsKKwl9CisKKwlpZiAoZnVsbF9jb25maWcgJiYgY29uZi0+aWVlZTgwMjExbiAmJgorCSAgICBic3MtPnNzaWQuc2VjdXJpdHlfcG9saWN5ID09IFNFQ1VSSVRZX1NUQVRJQ19XRVApIHsKKwkJYnNzLT5kaXNhYmxlXzExbiA9IDE7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSFQgKElFRUUgODAyLjExbikgd2l0aCBXRVAgaXMgbm90ICIKKwkJCSAgICJhbGxvd2VkLCBkaXNhYmxpbmcgSFQgY2FwYWJpbGl0aWVzIik7CisJfQorCisJaWYgKGZ1bGxfY29uZmlnICYmIGNvbmYtPmllZWU4MDIxMW4gJiYgYnNzLT53cGEgJiYKKwkgICAgIShic3MtPndwYV9wYWlyd2lzZSAmIFdQQV9DSVBIRVJfQ0NNUCkgJiYKKwkgICAgIShic3MtPnJzbl9wYWlyd2lzZSAmIChXUEFfQ0lQSEVSX0NDTVAgfCBXUEFfQ0lQSEVSX0dDTVAgfAorCQkJCSAgIFdQQV9DSVBIRVJfQ0NNUF8yNTYgfCBXUEFfQ0lQSEVSX0dDTVBfMjU2KSkpCisJeworCQlic3MtPmRpc2FibGVfMTFuID0gMTsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJIVCAoSUVFRSA4MDIuMTFuKSB3aXRoIFdQQS9XUEEyICIKKwkJCSAgICJyZXF1aXJlcyBDQ01QL0dDTVAgdG8gYmUgZW5hYmxlZCwgZGlzYWJsaW5nIEhUICIKKwkJCSAgICJjYXBhYmlsaXRpZXMiKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMU4gKi8KKworI2lmZGVmIENPTkZJR19XUFMKKwlpZiAoZnVsbF9jb25maWcgJiYgYnNzLT53cHNfc3RhdGUgJiYgYnNzLT5pZ25vcmVfYnJvYWRjYXN0X3NzaWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUzogaWdub3JlX2Jyb2FkY2FzdF9zc2lkICIKKwkJCSAgICJjb25maWd1cmF0aW9uIGZvcmNlZCBXUFMgdG8gYmUgZGlzYWJsZWQiKTsKKwkJYnNzLT53cHNfc3RhdGUgPSAwOworCX0KKworCWlmIChmdWxsX2NvbmZpZyAmJiBic3MtPndwc19zdGF0ZSAmJgorCSAgICBic3MtPnNzaWQud2VwLmtleXNfc2V0ICYmIGJzcy0+d3BhID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUzogV0VQIGNvbmZpZ3VyYXRpb24gZm9yY2VkIFdQUyB0byBiZSAiCisJCQkgICAiZGlzYWJsZWQiKTsKKwkJYnNzLT53cHNfc3RhdGUgPSAwOworCX0KKworCWlmIChmdWxsX2NvbmZpZyAmJiBic3MtPndwc19zdGF0ZSAmJiBic3MtPndwYSAmJgorCSAgICAoIShic3MtPndwYSAmIDIpIHx8CisJICAgICAhKGJzcy0+cnNuX3BhaXJ3aXNlICYgV1BBX0NJUEhFUl9DQ01QKSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUzogV1BBL1RLSVAgY29uZmlndXJhdGlvbiB3aXRob3V0ICIKKwkJCSAgICJXUEEyL0NDTVAgZm9yY2VkIFdQUyB0byBiZSBkaXNhYmxlZCIpOworCQlic3MtPndwc19zdGF0ZSA9IDA7CisJfQorI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KKworI2lmZGVmIENPTkZJR19IUzIwCisJaWYgKGZ1bGxfY29uZmlnICYmIGJzcy0+aHMyMCAmJgorCSAgICAoIShic3MtPndwYSAmIDIpIHx8CisJICAgICAhKGJzcy0+cnNuX3BhaXJ3aXNlICYgKFdQQV9DSVBIRVJfQ0NNUCB8IFdQQV9DSVBIRVJfR0NNUCB8CisJCQkJICAgIFdQQV9DSVBIRVJfQ0NNUF8yNTYgfAorCQkJCSAgICBXUEFfQ0lQSEVSX0dDTVBfMjU2KSkpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSFMgMi4wOiBXUEEyLUVudGVycHJpc2UvQ0NNUCAiCisJCQkgICAiY29uZmlndXJhdGlvbiBpcyByZXF1aXJlZCBmb3IgSG90c3BvdCAyLjAgIgorCQkJICAgImZ1bmN0aW9uYWxpdHkiKTsKKwkJcmV0dXJuIC0xOworCX0KKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLworCisJcmV0dXJuIDA7Cit9CisKKworaW50IGhvc3RhcGRfY29uZmlnX2NoZWNrKHN0cnVjdCBob3N0YXBkX2NvbmZpZyAqY29uZiwgaW50IGZ1bGxfY29uZmlnKQoreworCXNpemVfdCBpOworCisJaWYgKGZ1bGxfY29uZmlnICYmIGNvbmYtPmllZWU4MDIxMWQgJiYKKwkgICAgKCFjb25mLT5jb3VudHJ5WzBdIHx8ICFjb25mLT5jb3VudHJ5WzFdKSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNhbm5vdCBlbmFibGUgSUVFRSA4MDIuMTFkIHdpdGhvdXQgIgorCQkJICAgInNldHRpbmcgdGhlIGNvdW50cnlfY29kZSIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGZ1bGxfY29uZmlnICYmIGNvbmYtPmllZWU4MDIxMWggJiYgIWNvbmYtPmllZWU4MDIxMWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDYW5ub3QgZW5hYmxlIElFRUUgODAyLjExaCB3aXRob3V0ICIKKwkJCSAgICJJRUVFIDgwMi4xMWQgZW5hYmxlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGZ1bGxfY29uZmlnICYmIGNvbmYtPmxvY2FsX3B3cl9jb25zdHJhaW50ICE9IC0xICYmCisJICAgICFjb25mLT5pZWVlODAyMTFkKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ2Fubm90IGFkZCBQb3dlciBDb25zdHJhaW50IGVsZW1lbnQgd2l0aG91dCBDb3VudHJ5IGVsZW1lbnQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChmdWxsX2NvbmZpZyAmJiBjb25mLT5zcGVjdHJ1bV9tZ210X3JlcXVpcmVkICYmCisJICAgIGNvbmYtPmxvY2FsX3B3cl9jb25zdHJhaW50ID09IC0xKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ2Fubm90IHNldCBTcGVjdHJ1bSBNYW5hZ2VtZW50IGJpdCB3aXRob3V0IENvdW50cnkgYW5kIFBvd2VyIENvbnN0cmFpbnQgZWxlbWVudHMiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBjb25mLT5udW1fYnNzOyBpKyspIHsKKwkJaWYgKGhvc3RhcGRfY29uZmlnX2NoZWNrX2Jzcyhjb25mLT5ic3NbaV0sIGNvbmYsIGZ1bGxfY29uZmlnKSkKKwkJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCit2b2lkIGhvc3RhcGRfc2V0X3NlY3VyaXR5X3BhcmFtcyhzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsCisJCQkJIGludCBmdWxsX2NvbmZpZykKK3sKKwlpZiAoYnNzLT5pbmRpdmlkdWFsX3dlcF9rZXlfbGVuID09IDApIHsKKwkJLyogaW5kaXZpZHVhbCBrZXlzIGFyZSBub3QgdXNlOyBjYW4gdXNlIGtleSBpZHgwIGZvcgorCQkgKiBicm9hZGNhc3Qga2V5cyAqLworCQlic3MtPmJyb2FkY2FzdF9rZXlfaWR4X21pbiA9IDA7CisJfQorCisJaWYgKChic3MtPndwYSAmIDIpICYmIGJzcy0+cnNuX3BhaXJ3aXNlID09IDApCisJCWJzcy0+cnNuX3BhaXJ3aXNlID0gYnNzLT53cGFfcGFpcndpc2U7CisJYnNzLT53cGFfZ3JvdXAgPSB3cGFfc2VsZWN0X2FwX2dyb3VwX2NpcGhlcihic3MtPndwYSwgYnNzLT53cGFfcGFpcndpc2UsCisJCQkJCQkgICAgYnNzLT5yc25fcGFpcndpc2UpOworCisJaWYgKGZ1bGxfY29uZmlnKSB7CisJCWJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlciA9IGJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlcnM7CisJCWJzcy0+cmFkaXVzLT5hY2N0X3NlcnZlciA9IGJzcy0+cmFkaXVzLT5hY2N0X3NlcnZlcnM7CisJfQorCisJaWYgKGJzcy0+d3BhICYmIGJzcy0+aWVlZTgwMl8xeCkgeworCQlic3MtPnNzaWQuc2VjdXJpdHlfcG9saWN5ID0gU0VDVVJJVFlfV1BBOworCX0gZWxzZSBpZiAoYnNzLT53cGEpIHsKKwkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX1dQQV9QU0s7CisJfSBlbHNlIGlmIChic3MtPmllZWU4MDJfMXgpIHsKKwkJaW50IGNpcGhlciA9IFdQQV9DSVBIRVJfTk9ORTsKKwkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX0lFRUVfODAyXzFYOworCQlic3MtPnNzaWQud2VwLmRlZmF1bHRfbGVuID0gYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuOworCQlpZiAoYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuKQorCQkJY2lwaGVyID0gYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuID49IDEzID8KKwkJCQlXUEFfQ0lQSEVSX1dFUDEwNCA6IFdQQV9DSVBIRVJfV0VQNDA7CisJCWJzcy0+d3BhX2dyb3VwID0gY2lwaGVyOworCQlic3MtPndwYV9wYWlyd2lzZSA9IGNpcGhlcjsKKwkJYnNzLT5yc25fcGFpcndpc2UgPSBjaXBoZXI7CisJfSBlbHNlIGlmIChic3MtPnNzaWQud2VwLmtleXNfc2V0KSB7CisJCWludCBjaXBoZXIgPSBXUEFfQ0lQSEVSX1dFUDQwOworCQlpZiAoYnNzLT5zc2lkLndlcC5sZW5bMF0gPj0gMTMpCisJCQljaXBoZXIgPSBXUEFfQ0lQSEVSX1dFUDEwNDsKKwkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX1NUQVRJQ19XRVA7CisJCWJzcy0+d3BhX2dyb3VwID0gY2lwaGVyOworCQlic3MtPndwYV9wYWlyd2lzZSA9IGNpcGhlcjsKKwkJYnNzLT5yc25fcGFpcndpc2UgPSBjaXBoZXI7CisJfSBlbHNlIGlmIChic3MtPm9zZW4pIHsKKwkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX09TRU47CisJCWJzcy0+d3BhX2dyb3VwID0gV1BBX0NJUEhFUl9DQ01QOworCQlic3MtPndwYV9wYWlyd2lzZSA9IDA7CisJCWJzcy0+cnNuX3BhaXJ3aXNlID0gV1BBX0NJUEhFUl9DQ01QOworCX0gZWxzZSB7CisJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9QTEFJTlRFWFQ7CisJCWJzcy0+d3BhX2dyb3VwID0gV1BBX0NJUEhFUl9OT05FOworCQlic3MtPndwYV9wYWlyd2lzZSA9IFdQQV9DSVBIRVJfTk9ORTsKKwkJYnNzLT5yc25fcGFpcndpc2UgPSBXUEFfQ0lQSEVSX05PTkU7CisJfQorfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX2NvbmZpZy5oIGIvc3JjL2FwL2FwX2NvbmZpZy5oCmluZGV4IGM1NTMxZmEuLjI4NThjNmUgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9hcF9jb25maWcuaAorKysgYi9zcmMvYXAvYXBfY29uZmlnLmgKQEAgLTQ1LDcgKzQ1LDggQEAKIAlTRUNVUklUWV9TVEFUSUNfV0VQID0gMSwKIAlTRUNVUklUWV9JRUVFXzgwMl8xWCA9IDIsCiAJU0VDVVJJVFlfV1BBX1BTSyA9IDMsCi0JU0VDVVJJVFlfV1BBID0gNAorCVNFQ1VSSVRZX1dQQSA9IDQsCisJU0VDVVJJVFlfT1NFTiA9IDUKIH0gc2VjcG9saWN5OwogCiBzdHJ1Y3QgaG9zdGFwZF9zc2lkIHsKQEAgLTUzLDYgKzU0LDggQEAKIAlzaXplX3Qgc3NpZF9sZW47CiAJdW5zaWduZWQgaW50IHNzaWRfc2V0OjE7CiAJdW5zaWduZWQgaW50IHV0Zjhfc3NpZDoxOworCXVuc2lnbmVkIGludCB3cGFfcGFzc3BocmFzZV9zZXQ6MTsKKwl1bnNpZ25lZCBpbnQgd3BhX3Bza19zZXQ6MTsKIAogCWNoYXIgdmxhbltJRk5BTVNJWiArIDFdOwogCXNlY3BvbGljeSBzZWN1cml0eV9wb2xpY3k7CkBAIC0xMjMsNyArMTI2LDEwIEBACiAJdW5zaWduZWQgaW50IHdpbGRjYXJkX3ByZWZpeDoxOwogCXVuc2lnbmVkIGludCBwYXNzd29yZF9oYXNoOjE7IC8qIHdoZXRoZXIgcGFzc3dvcmQgaXMgaGFzaGVkIHdpdGgKIAkJCQkgICAgICAgKiBudF9wYXNzd29yZF9oYXNoKCkgKi8KKwl1bnNpZ25lZCBpbnQgcmVtZWRpYXRpb246MTsKKwl1bnNpZ25lZCBpbnQgbWFjYWNsOjE7CiAJaW50IHR0bHNfYXV0aDsgLyogRUFQX1RUTFNfQVVUSF8qIGJpdGZpZWxkICovCisJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmFjY2VwdF9hdHRyOwogfTsKIAogc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgewpAQCAtMTg3LDggKzE5Myw2IEBACiAJdW5zaWduZWQgaW50IGxvZ2dlcl9zeXNsb2c7IC8qIG1vZHVsZSBiaXRmaWVsZCAqLwogCXVuc2lnbmVkIGludCBsb2dnZXJfc3Rkb3V0OyAvKiBtb2R1bGUgYml0ZmllbGQgKi8KIAotCWNoYXIgKmR1bXBfbG9nX25hbWU7IC8qIGZpbGUgbmFtZSBmb3Igc3RhdGUgZHVtcCAoU0lHVVNSMSkgKi8KLQogCWludCBtYXhfbnVtX3N0YTsgLyogbWF4aW11bSBudW1iZXIgb2YgU1RBcyBpbiBzdGF0aW9uIHRhYmxlICovCiAKIAlpbnQgZHRpbV9wZXJpb2Q7CkBAIC0yNTEsNiArMjU1LDcgQEAKIAlpbnQgd3BhX2tleV9tZ210OwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJZW51bSBtZnBfb3B0aW9ucyBpZWVlODAyMTF3OworCWludCBncm91cF9tZ210X2NpcGhlcjsKIAkvKiBkb3QxMUFzc29jaWF0aW9uU0FRdWVyeU1heGltdW1UaW1lb3V0IChpbiBUVXMpICovCiAJdW5zaWduZWQgaW50IGFzc29jX3NhX3F1ZXJ5X21heF90aW1lb3V0OwogCS8qIGRvdDExQXNzb2NpYXRpb25TQVF1ZXJ5UmV0cnlUaW1lb3V0IChpbiBUVXMpICovCkBAIC0zMTEsNiArMzE2LDcgQEAKIAogCWNoYXIgKnJhZGl1c19zZXJ2ZXJfY2xpZW50czsKIAlpbnQgcmFkaXVzX3NlcnZlcl9hdXRoX3BvcnQ7CisJaW50IHJhZGl1c19zZXJ2ZXJfYWNjdF9wb3J0OwogCWludCByYWRpdXNfc2VydmVyX2lwdjY7CiAKIAljaGFyICp0ZXN0X3NvY2tldDsgLyogVU5JWCBkb21haW4gc29ja2V0IHBhdGggZm9yIGRyaXZlcl90ZXN0ICovCkBAIC0zODQsNiArMzkwLDEyIEBACiAjZGVmaW5lIFAyUF9NQU5BR0UgQklUKDMpCiAjZGVmaW5lIFAyUF9BTExPV19DUk9TU19DT05ORUNUSU9OIEJJVCg0KQogCWludCBwMnA7CisjaWZkZWYgQ09ORklHX1AyUAorCXU4IGlwX2FkZHJfZ29bNF07CisJdTggaXBfYWRkcl9tYXNrWzRdOworCXU4IGlwX2FkZHJfc3RhcnRbNF07CisJdTggaXBfYWRkcl9lbmRbNF07CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAJaW50IGRpc2Fzc29jX2xvd19hY2s7CiAJaW50IHNraXBfaW5hY3Rpdml0eV9wb2xsOwpAQCAtNDQyLDkgKzQ1NCwxNCBAQAogCXUxNiBnYXNfY29tZWJhY2tfZGVsYXk7CiAJaW50IGdhc19mcmFnX2xpbWl0OwogCisJdTggcW9zX21hcF9zZXRbMTYgKyAyICogMjFdOworCXVuc2lnbmVkIGludCBxb3NfbWFwX3NldF9sZW47CisKKwlpbnQgb3NlbjsKICNpZmRlZiBDT05GSUdfSFMyMAogCWludCBoczIwOwogCWludCBkaXNhYmxlX2RnYWY7CisJdTE2IGFucXBfZG9tYWluX2lkOwogCXVuc2lnbmVkIGludCBoczIwX29wZXJfZnJpZW5kbHlfbmFtZV9jb3VudDsKIAlzdHJ1Y3QgaG9zdGFwZF9sYW5nX3N0cmluZyAqaHMyMF9vcGVyX2ZyaWVuZGx5X25hbWU7CiAJdTggKmhzMjBfd2FuX21ldHJpY3M7CkBAIC00NTIsNiArNDY5LDMyIEBACiAJc2l6ZV90IGhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5X2xlbjsKIAl1OCAqaHMyMF9vcGVyYXRpbmdfY2xhc3M7CiAJdTggaHMyMF9vcGVyYXRpbmdfY2xhc3NfbGVuOworCXN0cnVjdCBoczIwX2ljb24geworCQl1MTYgd2lkdGg7CisJCXUxNiBoZWlnaHQ7CisJCWNoYXIgbGFuZ3VhZ2VbM107CisJCWNoYXIgdHlwZVsyNTZdOworCQljaGFyIG5hbWVbMjU2XTsKKwkJY2hhciBmaWxlWzI1Nl07CisJfSAqaHMyMF9pY29uczsKKwlzaXplX3QgaHMyMF9pY29uc19jb3VudDsKKwl1OCBvc3Vfc3NpZFtIT1NUQVBEX01BWF9TU0lEX0xFTl07CisJc2l6ZV90IG9zdV9zc2lkX2xlbjsKKwlzdHJ1Y3QgaHMyMF9vc3VfcHJvdmlkZXIgeworCQl1bnNpZ25lZCBpbnQgZnJpZW5kbHlfbmFtZV9jb3VudDsKKwkJc3RydWN0IGhvc3RhcGRfbGFuZ19zdHJpbmcgKmZyaWVuZGx5X25hbWU7CisJCWNoYXIgKnNlcnZlcl91cmk7CisJCWludCAqbWV0aG9kX2xpc3Q7CisJCWNoYXIgKippY29uczsKKwkJc2l6ZV90IGljb25zX2NvdW50OworCQljaGFyICpvc3VfbmFpOworCQl1bnNpZ25lZCBpbnQgc2VydmljZV9kZXNjX2NvdW50OworCQlzdHJ1Y3QgaG9zdGFwZF9sYW5nX3N0cmluZyAqc2VydmljZV9kZXNjOworCX0gKmhzMjBfb3N1X3Byb3ZpZGVycywgKmxhc3Rfb3N1OworCXNpemVfdCBoczIwX29zdV9wcm92aWRlcnNfY291bnQ7CisJdW5zaWduZWQgaW50IGhzMjBfZGVhdXRoX3JlcV90aW1lb3V0OworCWNoYXIgKnN1YnNjcl9yZW1lZGlhdGlvbl91cmw7CisJdTggc3Vic2NyX3JlbWVkaWF0aW9uX21ldGhvZDsKICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCiAJdTggd3BzX3JmX2JhbmRzOyAvKiBSRiBiYW5kcyBmb3IgV1BTIChXUFNfUkZfKikgKi8KQEAgLTQ2NCw2ICs1MDcsMTMgQEAKIAogCXVuc2lnbmVkIGludCBzYWVfYW50aV9jbG9nZ2luZ190aHJlc2hvbGQ7CiAJaW50ICpzYWVfZ3JvdXBzOworCisJY2hhciAqd293bGFuX3RyaWdnZXJzOyAvKiBXYWtlLW9uLVdMQU4gdHJpZ2dlcnMgKi8KKworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKwl1OCBic3NfbG9hZF90ZXN0WzVdOworCXU4IGJzc19sb2FkX3Rlc3Rfc2V0OworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KIH07CiAKIApAQCAtNDcxLDcgKzUyMSw3IEBACiAgKiBzdHJ1Y3QgaG9zdGFwZF9jb25maWcgLSBQZXItcmFkaW8gaW50ZXJmYWNlIGNvbmZpZ3VyYXRpb24KICAqLwogc3RydWN0IGhvc3RhcGRfY29uZmlnIHsKLQlzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsICpsYXN0X2JzczsKKwlzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICoqYnNzLCAqbGFzdF9ic3M7CiAJc2l6ZV90IG51bV9ic3M7CiAKIAl1MTYgYmVhY29uX2ludDsKQEAgLTQ3OSw2ICs1MjksNyBAQAogCWludCBmcmFnbV90aHJlc2hvbGQ7CiAJdTggc2VuZF9wcm9iZV9yZXNwb25zZTsKIAl1OCBjaGFubmVsOworCWludCAqY2hhbmxpc3Q7CiAJZW51bSBob3N0YXBkX2h3X21vZGUgaHdfbW9kZTsgLyogSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEsIC4uICovCiAJZW51bSB7CiAJCUxPTkdfUFJFQU1CTEUgPSAwLApAQCAtNTA0LDYgKzU1NSwxNiBAQAogCiAJaW50IGllZWU4MDIxMWg7IC8qIERGUyAqLwogCisJLyoKKwkgKiBMb2NhbCBwb3dlciBjb25zdHJhaW50IGlzIGFuIG9jdGV0IGVuY29kZWQgYXMgYW4gdW5zaWduZWQgaW50ZWdlciBpbgorCSAqIHVuaXRzIG9mIGRlY2liZWxzLiBJbnZhbGlkIHZhbHVlIC0xIGluZGljYXRlcyB0aGF0IFBvd2VyIENvbnN0cmFpbnQKKwkgKiBlbGVtZW50IHdpbGwgbm90IGJlIGFkZGVkLgorCSAqLworCWludCBsb2NhbF9wd3JfY29uc3RyYWludDsKKworCS8qIENvbnRyb2wgU3BlY3RydW0gTWFuYWdlbWVudCBiaXQgKi8KKwlpbnQgc3BlY3RydW1fbWdtdF9yZXF1aXJlZDsKKwogCXN0cnVjdCBob3N0YXBkX3R4X3F1ZXVlX3BhcmFtcyB0eF9xdWV1ZVtOVU1fVFhfUVVFVUVTXTsKIAogCS8qCkBAIC01MjAsNiArNTgxLDcgQEAKIAlpbnQgaWVlZTgwMjExbjsKIAlpbnQgc2Vjb25kYXJ5X2NoYW5uZWw7CiAJaW50IHJlcXVpcmVfaHQ7CisJaW50IG9ic3NfaW50ZXJ2YWw7CiAJdTMyIHZodF9jYXBhYjsKIAlpbnQgaWVlZTgwMjExYWM7CiAJaW50IHJlcXVpcmVfdmh0OwpAQCAtNTQ1LDEyICs2MDcsMTIgQEAKIGludCBob3N0YXBkX21hY19jb21wX2VtcHR5KGNvbnN0IHZvaWQgKmEpOwogc3RydWN0IGhvc3RhcGRfY29uZmlnICogaG9zdGFwZF9jb25maWdfZGVmYXVsdHModm9pZCk7CiB2b2lkIGhvc3RhcGRfY29uZmlnX2RlZmF1bHRzX2JzcyhzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MpOwordm9pZCBob3N0YXBkX2NvbmZpZ19mcmVlX2VhcF91c2VyKHN0cnVjdCBob3N0YXBkX2VhcF91c2VyICp1c2VyKTsKK3ZvaWQgaG9zdGFwZF9jb25maWdfZnJlZV9ic3Moc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqY29uZik7CiB2b2lkIGhvc3RhcGRfY29uZmlnX2ZyZWUoc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mKTsKIGludCBob3N0YXBkX21hY2xpc3RfZm91bmQoc3RydWN0IG1hY19hY2xfZW50cnkgKmxpc3QsIGludCBudW1fZW50cmllcywKIAkJCSAgY29uc3QgdTggKmFkZHIsIGludCAqdmxhbl9pZCk7CiBpbnQgaG9zdGFwZF9yYXRlX2ZvdW5kKGludCAqbGlzdCwgaW50IHJhdGUpOwotaW50IGhvc3RhcGRfd2VwX2tleV9jbXAoc3RydWN0IGhvc3RhcGRfd2VwX2tleXMgKmEsCi0JCQlzdHJ1Y3QgaG9zdGFwZF93ZXBfa2V5cyAqYik7CiBjb25zdCB1OCAqIGhvc3RhcGRfZ2V0X3Bzayhjb25zdCBzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpjb25mLAogCQkJICAgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpwMnBfZGV2X2FkZHIsCiAJCQkgICBjb25zdCB1OCAqcHJldl9wc2spOwpAQCAtNTYwLDUgKzYyMiw4IEBACiAJCQkJCWludCB2bGFuX2lkKTsKIHN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICoKIGhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihzdHJ1Y3QgaG9zdGFwZF9yYWRpdXNfYXR0ciAqYXR0ciwgdTggdHlwZSk7CitpbnQgaG9zdGFwZF9jb25maWdfY2hlY2soc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mLCBpbnQgZnVsbF9jb25maWcpOwordm9pZCBob3N0YXBkX3NldF9zZWN1cml0eV9wYXJhbXMoc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzLAorCQkJCSBpbnQgZnVsbF9jb25maWcpOwogCiAjZW5kaWYgLyogSE9TVEFQRF9DT05GSUdfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX2Rydl9vcHMuYyBiL3NyYy9hcC9hcF9kcnZfb3BzLmMKaW5kZXggMzA3MjU2Mi4uY2M0YWMxMCAxMDA2NDQKLS0tIGEvc3JjL2FwL2FwX2Rydl9vcHMuYworKysgYi9zcmMvYXAvYXBfZHJ2X29wcy5jCkBAIC05LDcgKzksNiBAQAogI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCiAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKLSNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJ3cHMvd3BzLmgiCiAjaW5jbHVkZSAicDJwL3AycC5oIgpAQCAtMTI5LDE0ICsxMjgsMTQgQEAKIAl9CiAjZW5kaWYgLyogQ09ORklHX1AyUF9NQU5BR0VSICovCiAKLSNpZmRlZiBDT05GSUdfV1BTMgorI2lmZGVmIENPTkZJR19XUFMKIAlpZiAoaGFwZC0+Y29uZi0+d3BzX3N0YXRlKSB7CiAJCXN0cnVjdCB3cGFidWYgKmEgPSB3cHNfYnVpbGRfYXNzb2NfcmVzcF9pZSgpOwogCQlpZiAoYSAmJiB3cGFidWZfcmVzaXplKCZhc3NvY3Jlc3AsIHdwYWJ1Zl9sZW4oYSkpID09IDApCiAJCQl3cGFidWZfcHV0X2J1Zihhc3NvY3Jlc3AsIGEpOwogCQl3cGFidWZfZnJlZShhKTsKIAl9Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KKyNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAKICNpZmRlZiBDT05GSUdfUDJQX01BTkFHRVIKIAlpZiAoaGFwZC0+Y29uZi0+cDJwICYgUDJQX01BTkFHRSkgewpAQCAtMTcxLDYgKzE3MCwxNyBAQAogCQkJZ290byBmYWlsOwogCQl3cGFidWZfcHV0X2RhdGEocHJvYmVyZXNwLCBidWYsIHBvcyAtIGJ1Zik7CiAJfQorCisJcG9zID0gaG9zdGFwZF9laWRfb3NlbihoYXBkLCBidWYpOworCWlmIChwb3MgIT0gYnVmKSB7CisJCWlmICh3cGFidWZfcmVzaXplKCZiZWFjb24sIHBvcyAtIGJ1ZikgIT0gMCkKKwkJCWdvdG8gZmFpbDsKKwkJd3BhYnVmX3B1dF9kYXRhKGJlYWNvbiwgYnVmLCBwb3MgLSBidWYpOworCisJCWlmICh3cGFidWZfcmVzaXplKCZwcm9iZXJlc3AsIHBvcyAtIGJ1ZikgIT0gMCkKKwkJCWdvdG8gZmFpbDsKKwkJd3BhYnVmX3B1dF9kYXRhKHByb2JlcmVzcCwgYnVmLCBwb3MgLSBidWYpOworCX0KICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCiAJaWYgKGhhcGQtPmNvbmYtPnZlbmRvcl9lbGVtZW50cykgewpAQCAtMjcwLDcgKzI4MCw4IEBACiAJCXBhcmFtcy53cGEgPSBoYXBkLT5jb25mLT53cGE7CiAJCXBhcmFtcy5pZWVlODAyXzF4ID0gaGFwZC0+Y29uZi0+aWVlZTgwMl8xeDsKIAkJcGFyYW1zLndwYV9ncm91cCA9IGhhcGQtPmNvbmYtPndwYV9ncm91cDsKLQkJcGFyYW1zLndwYV9wYWlyd2lzZSA9IGhhcGQtPmNvbmYtPndwYV9wYWlyd2lzZTsKKwkJcGFyYW1zLndwYV9wYWlyd2lzZSA9IGhhcGQtPmNvbmYtPndwYV9wYWlyd2lzZSB8CisJCQloYXBkLT5jb25mLT5yc25fcGFpcndpc2U7CiAJCXBhcmFtcy53cGFfa2V5X21nbXQgPSBoYXBkLT5jb25mLT53cGFfa2V5X21nbXQ7CiAJCXBhcmFtcy5yc25fcHJlYXV0aCA9IGhhcGQtPmNvbmYtPnJzbl9wcmVhdXRoOwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCkBAIC0yODYsNyArMjk3LDcgQEAKIAljaGFyIGZvcmNlX2lmbmFtZVtJRk5BTVNJWl07CiAJdTggaWZfYWRkcltFVEhfQUxFTl07CiAJcmV0dXJuIGhvc3RhcGRfaWZfYWRkKGhhcGQsIFdQQV9JRl9BUF9WTEFOLCBpZm5hbWUsIGhhcGQtPm93bl9hZGRyLAotCQkJICAgICAgTlVMTCwgTlVMTCwgZm9yY2VfaWZuYW1lLCBpZl9hZGRyLCBOVUxMKTsKKwkJCSAgICAgIE5VTEwsIE5VTEwsIGZvcmNlX2lmbmFtZSwgaWZfYWRkciwgTlVMTCwgMCk7CiB9CiAKIApAQCAtMzQ3LDcgKzM1OCw3IEBACiAJCSAgICB1MTYgbGlzdGVuX2ludGVydmFsLAogCQkgICAgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgKmh0X2NhcGFiLAogCQkgICAgY29uc3Qgc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzICp2aHRfY2FwYWIsCi0JCSAgICB1MzIgZmxhZ3MsIHU4IHFvc2luZm8pCisJCSAgICB1MzIgZmxhZ3MsIHU4IHFvc2luZm8sIHU4IHZodF9vcG1vZGUpCiB7CiAJc3RydWN0IGhvc3RhcGRfc3RhX2FkZF9wYXJhbXMgcGFyYW1zOwogCkBAIC0zNjUsNiArMzc2LDggQEAKIAlwYXJhbXMubGlzdGVuX2ludGVydmFsID0gbGlzdGVuX2ludGVydmFsOwogCXBhcmFtcy5odF9jYXBhYmlsaXRpZXMgPSBodF9jYXBhYjsKIAlwYXJhbXMudmh0X2NhcGFiaWxpdGllcyA9IHZodF9jYXBhYjsKKwlwYXJhbXMudmh0X29wbW9kZV9lbmFibGVkID0gISEoZmxhZ3MgJiBXTEFOX1NUQV9WSFRfT1BNT0RFX0VOQUJMRUQpOworCXBhcmFtcy52aHRfb3Btb2RlID0gdmh0X29wbW9kZTsKIAlwYXJhbXMuZmxhZ3MgPSBob3N0YXBkX3N0YV9mbGFnc190b19kcnYoZmxhZ3MpOwogCXBhcmFtcy5xb3NpbmZvID0gcW9zaW5mbzsKIAlyZXR1cm4gaGFwZC0+ZHJpdmVyLT5zdGFfYWRkKGhhcGQtPmRydl9wcml2LCAmcGFyYW1zKTsKQEAgLTQxNywyMCArNDMwLDIxIEBACiBpbnQgaG9zdGFwZF9pZl9hZGQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgZW51bSB3cGFfZHJpdmVyX2lmX3R5cGUgdHlwZSwKIAkJICAgY29uc3QgY2hhciAqaWZuYW1lLCBjb25zdCB1OCAqYWRkciwgdm9pZCAqYnNzX2N0eCwKIAkJICAgdm9pZCAqKmRydl9wcml2LCBjaGFyICpmb3JjZV9pZm5hbWUsIHU4ICppZl9hZGRyLAotCQkgICBjb25zdCBjaGFyICpicmlkZ2UpCisJCSAgIGNvbnN0IGNoYXIgKmJyaWRnZSwgaW50IHVzZV9leGlzdGluZykKIHsKIAlpZiAoaGFwZC0+ZHJpdmVyID09IE5VTEwgfHwgaGFwZC0+ZHJpdmVyLT5pZl9hZGQgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCXJldHVybiBoYXBkLT5kcml2ZXItPmlmX2FkZChoYXBkLT5kcnZfcHJpdiwgdHlwZSwgaWZuYW1lLCBhZGRyLAogCQkJCSAgICBic3NfY3R4LCBkcnZfcHJpdiwgZm9yY2VfaWZuYW1lLCBpZl9hZGRyLAotCQkJCSAgICBicmlkZ2UpOworCQkJCSAgICBicmlkZ2UsIHVzZV9leGlzdGluZyk7CiB9CiAKIAogaW50IGhvc3RhcGRfaWZfcmVtb3ZlKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGVudW0gd3BhX2RyaXZlcl9pZl90eXBlIHR5cGUsCiAJCSAgICAgIGNvbnN0IGNoYXIgKmlmbmFtZSkKIHsKLQlpZiAoaGFwZC0+ZHJpdmVyID09IE5VTEwgfHwgaGFwZC0+ZHJpdmVyLT5pZl9yZW1vdmUgPT0gTlVMTCkKKwlpZiAoaGFwZC0+ZHJpdmVyID09IE5VTEwgfHwgaGFwZC0+ZHJ2X3ByaXYgPT0gTlVMTCB8fAorCSAgICBoYXBkLT5kcml2ZXItPmlmX3JlbW92ZSA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAJcmV0dXJuIGhhcGQtPmRyaXZlci0+aWZfcmVtb3ZlKGhhcGQtPmRydl9wcml2LCB0eXBlLCBpZm5hbWUpOwogfQpAQCAtNDYzLDQ0ICs0NzcsNTEgQEAKIH0KIAogCi1pbnQgaG9zdGFwZF9zZXRfZnJlcShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBpbnQgbW9kZSwgaW50IGZyZXEsCi0JCSAgICAgaW50IGNoYW5uZWwsIGludCBodF9lbmFibGVkLCBpbnQgdmh0X2VuYWJsZWQsCi0JCSAgICAgaW50IHNlY19jaGFubmVsX29mZnNldCwgaW50IHZodF9vcGVyX2Nod2lkdGgsCi0JCSAgICAgaW50IGNlbnRlcl9zZWdtZW50MCwgaW50IGNlbnRlcl9zZWdtZW50MSkKK2ludCBob3N0YXBkX3NldF9mcmVxX3BhcmFtcyhzdHJ1Y3QgaG9zdGFwZF9mcmVxX3BhcmFtcyAqZGF0YSwgaW50IG1vZGUsCisJCQkgICAgaW50IGZyZXEsIGludCBjaGFubmVsLCBpbnQgaHRfZW5hYmxlZCwKKwkJCSAgICBpbnQgdmh0X2VuYWJsZWQsIGludCBzZWNfY2hhbm5lbF9vZmZzZXQsCisJCQkgICAgaW50IHZodF9vcGVyX2Nod2lkdGgsIGludCBjZW50ZXJfc2VnbWVudDAsCisJCQkgICAgaW50IGNlbnRlcl9zZWdtZW50MSwgdTMyIHZodF9jYXBzKQogewotCXN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zIGRhdGE7CiAJaW50IHRtcDsKIAotCW9zX21lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKLQlkYXRhLm1vZGUgPSBtb2RlOwotCWRhdGEuZnJlcSA9IGZyZXE7Ci0JZGF0YS5jaGFubmVsID0gY2hhbm5lbDsKLQlkYXRhLmh0X2VuYWJsZWQgPSBodF9lbmFibGVkOwotCWRhdGEudmh0X2VuYWJsZWQgPSB2aHRfZW5hYmxlZDsKLQlkYXRhLnNlY19jaGFubmVsX29mZnNldCA9IHNlY19jaGFubmVsX29mZnNldDsKLQlkYXRhLmNlbnRlcl9mcmVxMSA9IGZyZXEgKyBzZWNfY2hhbm5lbF9vZmZzZXQgKiAxMDsKLQlkYXRhLmNlbnRlcl9mcmVxMiA9IDA7Ci0JZGF0YS5iYW5kd2lkdGggPSBzZWNfY2hhbm5lbF9vZmZzZXQgPyA0MCA6IDIwOworCW9zX21lbXNldChkYXRhLCAwLCBzaXplb2YoKmRhdGEpKTsKKwlkYXRhLT5tb2RlID0gbW9kZTsKKwlkYXRhLT5mcmVxID0gZnJlcTsKKwlkYXRhLT5jaGFubmVsID0gY2hhbm5lbDsKKwlkYXRhLT5odF9lbmFibGVkID0gaHRfZW5hYmxlZDsKKwlkYXRhLT52aHRfZW5hYmxlZCA9IHZodF9lbmFibGVkOworCWRhdGEtPnNlY19jaGFubmVsX29mZnNldCA9IHNlY19jaGFubmVsX29mZnNldDsKKwlkYXRhLT5jZW50ZXJfZnJlcTEgPSBmcmVxICsgc2VjX2NoYW5uZWxfb2Zmc2V0ICogMTA7CisJZGF0YS0+Y2VudGVyX2ZyZXEyID0gMDsKKwlkYXRhLT5iYW5kd2lkdGggPSBzZWNfY2hhbm5lbF9vZmZzZXQgPyA0MCA6IDIwOwogCiAJLyoKIAkgKiBUaGlzIHZhbGlkYXRpb24gY29kZSBpcyBwcm9iYWJseSBtaXNwbGFjZWQsIG1heWJlIGl0IHNob3VsZCBiZQogCSAqIGluIHNyYy9hcC9od19mZWF0dXJlcy5jIGFuZCBjaGVjayB0aGUgaGFyZHdhcmUgc3VwcG9ydCBhcyB3ZWxsLgogCSAqLwotCWlmIChkYXRhLnZodF9lbmFibGVkKSBzd2l0Y2ggKHZodF9vcGVyX2Nod2lkdGgpIHsKKwlpZiAoZGF0YS0+dmh0X2VuYWJsZWQpIHN3aXRjaCAodmh0X29wZXJfY2h3aWR0aCkgewogCWNhc2UgVkhUX0NIQU5XSURUSF9VU0VfSFQ6CiAJCWlmIChjZW50ZXJfc2VnbWVudDEpCiAJCQlyZXR1cm4gLTE7Ci0JCWlmICg1MDAwICsgY2VudGVyX3NlZ21lbnQwICogNSAhPSBkYXRhLmNlbnRlcl9mcmVxMSkKKwkJaWYgKGNlbnRlcl9zZWdtZW50MCAhPSAwICYmCisJCSAgICA1MDAwICsgY2VudGVyX3NlZ21lbnQwICogNSAhPSBkYXRhLT5jZW50ZXJfZnJlcTEgJiYKKwkJICAgIDI0MDcgKyBjZW50ZXJfc2VnbWVudDAgKiA1ICE9IGRhdGEtPmNlbnRlcl9mcmVxMSkKIAkJCXJldHVybiAtMTsKIAkJYnJlYWs7CiAJY2FzZSBWSFRfQ0hBTldJRFRIXzgwUDgwTUhaOgorCQlpZiAoISh2aHRfY2FwcyAmIFZIVF9DQVBfU1VQUF9DSEFOX1dJRFRIXzE2MF84MFBMVVM4ME1IWikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICI4MCs4MCBjaGFubmVsIHdpZHRoIGlzIG5vdCBzdXBwb3J0ZWQhIik7CisJCQlyZXR1cm4gLTE7CisJCX0KIAkJaWYgKGNlbnRlcl9zZWdtZW50MSA9PSBjZW50ZXJfc2VnbWVudDAgKyA0IHx8CiAJCSAgICBjZW50ZXJfc2VnbWVudDEgPT0gY2VudGVyX3NlZ21lbnQwIC0gNCkKIAkJCXJldHVybiAtMTsKLQkJZGF0YS5jZW50ZXJfZnJlcTIgPSA1MDAwICsgY2VudGVyX3NlZ21lbnQxICogNTsKKwkJZGF0YS0+Y2VudGVyX2ZyZXEyID0gNTAwMCArIGNlbnRlcl9zZWdtZW50MSAqIDU7CiAJCS8qIGZhbGwgdGhyb3VnaCAqLwogCWNhc2UgVkhUX0NIQU5XSURUSF84ME1IWjoKLQkJZGF0YS5iYW5kd2lkdGggPSA4MDsKKwkJZGF0YS0+YmFuZHdpZHRoID0gODA7CiAJCWlmICh2aHRfb3Blcl9jaHdpZHRoID09IDEgJiYgY2VudGVyX3NlZ21lbnQxKQogCQkJcmV0dXJuIC0xOwogCQlpZiAodmh0X29wZXJfY2h3aWR0aCA9PSAzICYmICFjZW50ZXJfc2VnbWVudDEpCkBAIC01MTAsMTMgKzUzMSwxOSBAQAogCQkvKiBwcmltYXJ5IDQwIHBhcnQgbXVzdCBtYXRjaCB0aGUgSFQgY29uZmlndXJhdGlvbiAqLwogCQl0bXAgPSAoMzAgKyBmcmVxIC0gNTAwMCAtIGNlbnRlcl9zZWdtZW50MCAqIDUpLzIwOwogCQl0bXAgLz0gMjsKLQkJaWYgKGRhdGEuY2VudGVyX2ZyZXExICE9IDUwMDAgKworCQlpZiAoZGF0YS0+Y2VudGVyX2ZyZXExICE9IDUwMDAgKwogCQkJCQkgY2VudGVyX3NlZ21lbnQwICogNSAtIDIwICsgNDAgKiB0bXApCiAJCQlyZXR1cm4gLTE7Ci0JCWRhdGEuY2VudGVyX2ZyZXExID0gNTAwMCArIGNlbnRlcl9zZWdtZW50MCAqIDU7CisJCWRhdGEtPmNlbnRlcl9mcmVxMSA9IDUwMDAgKyBjZW50ZXJfc2VnbWVudDAgKiA1OwogCQlicmVhazsKIAljYXNlIFZIVF9DSEFOV0lEVEhfMTYwTUhaOgotCQlkYXRhLmJhbmR3aWR0aCA9IDE2MDsKKwkJZGF0YS0+YmFuZHdpZHRoID0gMTYwOworCQlpZiAoISh2aHRfY2FwcyAmIChWSFRfQ0FQX1NVUFBfQ0hBTl9XSURUSF8xNjBNSFogfAorCQkJCSAgVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwXzgwUExVUzgwTUhaKSkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICIxNjBNSFogY2hhbm5lbCB3aWR0aCBpcyBub3Qgc3VwcG9ydGVkISIpOworCQkJcmV0dXJuIC0xOworCQl9CiAJCWlmIChjZW50ZXJfc2VnbWVudDEpCiAJCQlyZXR1cm4gLTE7CiAJCWlmICghc2VjX2NoYW5uZWxfb2Zmc2V0KQpAQCAtNTI0LDEyICs1NTEsMzEgQEAKIAkJLyogcHJpbWFyeSA0MCBwYXJ0IG11c3QgbWF0Y2ggdGhlIEhUIGNvbmZpZ3VyYXRpb24gKi8KIAkJdG1wID0gKDcwICsgZnJlcSAtIDUwMDAgLSBjZW50ZXJfc2VnbWVudDAgKiA1KS8yMDsKIAkJdG1wIC89IDI7Ci0JCWlmIChkYXRhLmNlbnRlcl9mcmVxMSAhPSA1MDAwICsKKwkJaWYgKGRhdGEtPmNlbnRlcl9mcmVxMSAhPSA1MDAwICsKIAkJCQkJIGNlbnRlcl9zZWdtZW50MCAqIDUgLSA2MCArIDQwICogdG1wKQogCQkJcmV0dXJuIC0xOwotCQlkYXRhLmNlbnRlcl9mcmVxMSA9IDUwMDAgKyBjZW50ZXJfc2VnbWVudDAgKiA1OworCQlkYXRhLT5jZW50ZXJfZnJlcTEgPSA1MDAwICsgY2VudGVyX3NlZ21lbnQwICogNTsKIAkJYnJlYWs7CiAJfQorCisJcmV0dXJuIDA7Cit9CisKKworaW50IGhvc3RhcGRfc2V0X2ZyZXEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgaW50IG1vZGUsIGludCBmcmVxLAorCQkgICAgIGludCBjaGFubmVsLCBpbnQgaHRfZW5hYmxlZCwgaW50IHZodF9lbmFibGVkLAorCQkgICAgIGludCBzZWNfY2hhbm5lbF9vZmZzZXQsIGludCB2aHRfb3Blcl9jaHdpZHRoLAorCQkgICAgIGludCBjZW50ZXJfc2VnbWVudDAsIGludCBjZW50ZXJfc2VnbWVudDEpCit7CisJc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgZGF0YTsKKworCWlmIChob3N0YXBkX3NldF9mcmVxX3BhcmFtcygmZGF0YSwgbW9kZSwgZnJlcSwgY2hhbm5lbCwgaHRfZW5hYmxlZCwKKwkJCQkgICAgdmh0X2VuYWJsZWQsIHNlY19jaGFubmVsX29mZnNldCwKKwkJCQkgICAgdmh0X29wZXJfY2h3aWR0aCwKKwkJCQkgICAgY2VudGVyX3NlZ21lbnQwLCBjZW50ZXJfc2VnbWVudDEsCisJCQkJICAgIGhhcGQtPmlmYWNlLT5jdXJyZW50X21vZGUtPnZodF9jYXBhYikpCisJCXJldHVybiAtMTsKKwogCWlmIChoYXBkLT5kcml2ZXIgPT0gTlVMTCkKIAkJcmV0dXJuIDA7CiAJaWYgKGhhcGQtPmRyaXZlci0+c2V0X2ZyZXEgPT0gTlVMTCkKQEAgLTY4Myw3ICs3MjksNyBAQAogCQkJIGNvbnN0IHU4ICpwZWVyLCB1OCAqYnVmLCB1MTYgKmJ1Zl9sZW4pCiB7CiAJaWYgKGhhcGQtPmRyaXZlciA9PSBOVUxMIHx8IGhhcGQtPmRyaXZlci0+d25tX29wZXIgPT0gTlVMTCkKLQkJcmV0dXJuIDA7CisJCXJldHVybiAtMTsKIAlyZXR1cm4gaGFwZC0+ZHJpdmVyLT53bm1fb3BlcihoYXBkLT5kcnZfcHJpdiwgb3BlciwgcGVlciwgYnVmLAogCQkJCSAgICAgIGJ1Zl9sZW4pOwogfQpAQCAtNjk5LDMgKzc0NSw1MCBAQAogCQkJCQkgaGFwZC0+b3duX2FkZHIsIGhhcGQtPm93bl9hZGRyLCBkYXRhLAogCQkJCQkgbGVuLCAwKTsKIH0KKworCitpbnQgaG9zdGFwZF9zdGFydF9kZnNfY2FjKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgaW50IG1vZGUsIGludCBmcmVxLAorCQkJICBpbnQgY2hhbm5lbCwgaW50IGh0X2VuYWJsZWQsIGludCB2aHRfZW5hYmxlZCwKKwkJCSAgaW50IHNlY19jaGFubmVsX29mZnNldCwgaW50IHZodF9vcGVyX2Nod2lkdGgsCisJCQkgIGludCBjZW50ZXJfc2VnbWVudDAsIGludCBjZW50ZXJfc2VnbWVudDEpCit7CisJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGlmYWNlLT5ic3NbMF07CisJc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgZGF0YTsKKwlpbnQgcmVzOworCisJaWYgKCFoYXBkLT5kcml2ZXIgfHwgIWhhcGQtPmRyaXZlci0+c3RhcnRfZGZzX2NhYykKKwkJcmV0dXJuIDA7CisKKwlpZiAoIWlmYWNlLT5jb25mLT5pZWVlODAyMTFoKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ2FuJ3Qgc3RhcnQgREZTIENBQywgREZTIGZ1bmN0aW9uYWxpdHkgIgorCQkJICAgImlzIG5vdCBlbmFibGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoaG9zdGFwZF9zZXRfZnJlcV9wYXJhbXMoJmRhdGEsIG1vZGUsIGZyZXEsIGNoYW5uZWwsIGh0X2VuYWJsZWQsCisJCQkJICAgIHZodF9lbmFibGVkLCBzZWNfY2hhbm5lbF9vZmZzZXQsCisJCQkJICAgIHZodF9vcGVyX2Nod2lkdGgsIGNlbnRlcl9zZWdtZW50MCwKKwkJCQkgICAgY2VudGVyX3NlZ21lbnQxLAorCQkJCSAgICBpZmFjZS0+Y3VycmVudF9tb2RlLT52aHRfY2FwYWIpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ2FuJ3Qgc2V0IGZyZXEgcGFyYW1zIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXMgPSBoYXBkLT5kcml2ZXItPnN0YXJ0X2Rmc19jYWMoaGFwZC0+ZHJ2X3ByaXYsICZkYXRhKTsKKwlpZiAoIXJlcykgeworCQlpZmFjZS0+Y2FjX3N0YXJ0ZWQgPSAxOworCQlvc19nZXRfcmVsdGltZSgmaWZhY2UtPmRmc19jYWNfc3RhcnQpOworCX0KKworCXJldHVybiByZXM7Cit9CisKKworaW50IGhvc3RhcGRfZHJ2X3NldF9xb3NfbWFwKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkgICAgY29uc3QgdTggKnFvc19tYXBfc2V0LCB1OCBxb3NfbWFwX3NldF9sZW4pCit7CisJaWYgKGhhcGQtPmRyaXZlciA9PSBOVUxMIHx8IGhhcGQtPmRyaXZlci0+c2V0X3Fvc19tYXAgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisJcmV0dXJuIGhhcGQtPmRyaXZlci0+c2V0X3Fvc19tYXAoaGFwZC0+ZHJ2X3ByaXYsIHFvc19tYXBfc2V0LAorCQkJCQkgcW9zX21hcF9zZXRfbGVuKTsKK30KZGlmZiAtLWdpdCBhL3NyYy9hcC9hcF9kcnZfb3BzLmggYi9zcmMvYXAvYXBfZHJ2X29wcy5oCmluZGV4IDIzMjc3YjYuLjdjYzlkN2QgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9hcF9kcnZfb3BzLmgKKysrIGIvc3JjL2FwL2FwX2Rydl9vcHMuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC0gRHJpdmVyIG9wZXJhdGlvbnMKLSAqIENvcHlyaWdodCAoYykgMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwOS0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xNCw2ICsxNCw3IEBACiBzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtczsKIHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwYWJpbGl0aWVzOwogc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzOworc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXM7CiAKIHUzMiBob3N0YXBkX3N0YV9mbGFnc190b19kcnYodTMyIGZsYWdzKTsKIGludCBob3N0YXBkX2J1aWxkX2FwX2V4dHJhX2llcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLApAQCAtMzksNyArNDAsNyBAQAogCQkgICAgdTE2IGxpc3Rlbl9pbnRlcnZhbCwKIAkJICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwYWJpbGl0aWVzICpodF9jYXBhYiwKIAkJICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyAqdmh0X2NhcGFiLAotCQkgICAgdTMyIGZsYWdzLCB1OCBxb3NpbmZvKTsKKwkJICAgIHUzMiBmbGFncywgdTggcW9zaW5mbywgdTggdmh0X29wbW9kZSk7CiBpbnQgaG9zdGFwZF9zZXRfcHJpdmFjeShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBpbnQgZW5hYmxlZCk7CiBpbnQgaG9zdGFwZF9zZXRfZ2VuZXJpY19lbGVtKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICplbGVtLAogCQkJICAgICBzaXplX3QgZWxlbV9sZW4pOwpAQCAtNDgsNyArNDksNyBAQAogaW50IGhvc3RhcGRfaWZfYWRkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGVudW0gd3BhX2RyaXZlcl9pZl90eXBlIHR5cGUsCiAJCSAgIGNvbnN0IGNoYXIgKmlmbmFtZSwgY29uc3QgdTggKmFkZHIsIHZvaWQgKmJzc19jdHgsCiAJCSAgIHZvaWQgKipkcnZfcHJpdiwgY2hhciAqZm9yY2VfaWZuYW1lLCB1OCAqaWZfYWRkciwKLQkJICAgY29uc3QgY2hhciAqYnJpZGdlKTsKKwkJICAgY29uc3QgY2hhciAqYnJpZGdlLCBpbnQgdXNlX2V4aXN0aW5nKTsKIGludCBob3N0YXBkX2lmX3JlbW92ZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBlbnVtIHdwYV9kcml2ZXJfaWZfdHlwZSB0eXBlLAogCQkgICAgICBjb25zdCBjaGFyICppZm5hbWUpOwogaW50IGhvc3RhcGRfc2V0X2llZWU4MDIxeChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLApAQCAtMTAxLDYgKzEwMiwxNSBAQAogCQkgICAgICBpbnQgcmVhc3NvYywgdTE2IHN0YXR1cywgY29uc3QgdTggKmllLCBzaXplX3QgbGVuKTsKIGludCBob3N0YXBkX2FkZF90c3BlYyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkciwKIAkJICAgICAgdTggKnRzcGVjX2llLCBzaXplX3QgdHNwZWNfaWVsZW4pOworaW50IGhvc3RhcGRfc3RhcnRfZGZzX2NhYyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsIGludCBtb2RlLCBpbnQgZnJlcSwKKwkJCSAgaW50IGNoYW5uZWwsIGludCBodF9lbmFibGVkLCBpbnQgdmh0X2VuYWJsZWQsCisJCQkgIGludCBzZWNfY2hhbm5lbF9vZmZzZXQsIGludCB2aHRfb3Blcl9jaHdpZHRoLAorCQkJICBpbnQgY2VudGVyX3NlZ21lbnQwLCBpbnQgY2VudGVyX3NlZ21lbnQxKTsKK2ludCBob3N0YXBkX3NldF9mcmVxX3BhcmFtcyhzdHJ1Y3QgaG9zdGFwZF9mcmVxX3BhcmFtcyAqZGF0YSwgaW50IG1vZGUsCisJCQkgICAgaW50IGZyZXEsIGludCBjaGFubmVsLCBpbnQgaHRfZW5hYmxlZCwKKwkJCSAgICBpbnQgdmh0X2VuYWJsZWQsIGludCBzZWNfY2hhbm5lbF9vZmZzZXQsCisJCQkgICAgaW50IHZodF9vcGVyX2Nod2lkdGgsIGludCBjZW50ZXJfc2VnbWVudDAsCisJCQkgICAgaW50IGNlbnRlcl9zZWdtZW50MSwgdTMyIHZodF9jYXBzKTsKIAogCiAjaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKQEAgLTEwOSw2ICsxMTksOSBAQAogCQkJIGVudW0gd25tX29wZXIgb3BlciwgY29uc3QgdTggKnBlZXIsCiAJCQkgdTggKmJ1ZiwgdTE2ICpidWZfbGVuKTsKIAoraW50IGhvc3RhcGRfZHJ2X3NldF9xb3NfbWFwKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICpxb3NfbWFwX3NldCwKKwkJCSAgICB1OCBxb3NfbWFwX3NldF9sZW4pOworCiBzdGF0aWMgaW5saW5lIGludCBob3N0YXBkX2Rydl9zZXRfY291bnRlcm1lYXN1cmVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJCQkgIGludCBlbmFibGVkKQogewpAQCAtMjM1LDQgKzI0OCw0NyBAQAogCXJldHVybiBoYXBkLT5kcml2ZXItPmdldF9zdXJ2ZXkoaGFwZC0+ZHJ2X3ByaXYsIGZyZXEpOwogfQogCitzdGF0aWMgaW5saW5lIGludCBob3N0YXBkX2dldF9jb3VudHJ5KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNoYXIgKmFscGhhMikKK3sKKwlpZiAoaGFwZC0+ZHJpdmVyID09IE5VTEwgfHwgaGFwZC0+ZHJpdmVyLT5nZXRfY291bnRyeSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIGhhcGQtPmRyaXZlci0+Z2V0X2NvdW50cnkoaGFwZC0+ZHJ2X3ByaXYsIGFscGhhMik7Cit9CisKK3N0YXRpYyBpbmxpbmUgY29uc3QgY2hhciAqIGhvc3RhcGRfZHJ2X2dldF9yYWRpb19uYW1lKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpCit7CisJaWYgKGhhcGQtPmRyaXZlciA9PSBOVUxMIHx8IGhhcGQtPmRydl9wcml2ID09IE5VTEwgfHwKKwkgICAgaGFwZC0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gaGFwZC0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZShoYXBkLT5kcnZfcHJpdik7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGhvc3RhcGRfZHJ2X3N3aXRjaF9jaGFubmVsKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgICAgc3RydWN0IGNzYV9zZXR0aW5ncyAqc2V0dGluZ3MpCit7CisJaWYgKGhhcGQtPmRyaXZlciA9PSBOVUxMIHx8IGhhcGQtPmRyaXZlci0+c3dpdGNoX2NoYW5uZWwgPT0gTlVMTCkKKwkJcmV0dXJuIC1FTk9UU1VQOworCisJcmV0dXJuIGhhcGQtPmRyaXZlci0+c3dpdGNoX2NoYW5uZWwoaGFwZC0+ZHJ2X3ByaXYsIHNldHRpbmdzKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgaG9zdGFwZF9kcnZfc3RhdHVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNoYXIgKmJ1ZiwKKwkJCQkgICAgIHNpemVfdCBidWZsZW4pCit7CisJaWYgKGhhcGQtPmRyaXZlciA9PSBOVUxMIHx8IGhhcGQtPmRyaXZlci0+c3RhdHVzID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gaGFwZC0+ZHJpdmVyLT5zdGF0dXMoaGFwZC0+ZHJ2X3ByaXYsIGJ1ZiwgYnVmbGVuKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgaG9zdGFwZF9kcnZfdmVuZG9yX2NtZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgaW50IHZlbmRvcl9pZCwgaW50IHN1YmNtZCwKKwkJCQkJIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgZGF0YV9sZW4sCisJCQkJCSBzdHJ1Y3Qgd3BhYnVmICpidWYpCit7CisJaWYgKGhhcGQtPmRyaXZlciA9PSBOVUxMIHx8IGhhcGQtPmRyaXZlci0+dmVuZG9yX2NtZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIGhhcGQtPmRyaXZlci0+dmVuZG9yX2NtZChoYXBkLT5kcnZfcHJpdiwgdmVuZG9yX2lkLCBzdWJjbWQsIGRhdGEsCisJCQkJCWRhdGFfbGVuLCBidWYpOworfQorCiAjZW5kaWYgLyogQVBfRFJWX09QUyAqLwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX2xpc3QuYyBiL3NyYy9hcC9hcF9saXN0LmMKaW5kZXggOWYwMjE1MS4uMjg3ZDUyMCAxMDA2NDQKLS0tIGEvc3JjL2FwL2FwX2xpc3QuYworKysgYi9zcmMvYXAvYXBfbGlzdC5jCkBAIC0xNCw3ICsxNCw2IEBACiAjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfY29tbW9uLmgiCi0jaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKICNpbmNsdWRlICJob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCiAjaW5jbHVkZSAiaWVlZTgwMl8xMS5oIgpAQCAtMzMsNyArMzIsOCBAQAogewogCWludCBpOwogCi0JaWYgKGlmYWNlLT5jdXJyZW50X21vZGUtPm1vZGUgIT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcgfHwKKwlpZiAoaWZhY2UtPmN1cnJlbnRfbW9kZSA9PSBOVUxMIHx8CisJICAgIGlmYWNlLT5jdXJyZW50X21vZGUtPm1vZGUgIT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcgfHwKIAkgICAgaWZhY2UtPmNvbmYtPmNoYW5uZWwgIT0gYXAtPmNoYW5uZWwpCiAJCXJldHVybiAwOwogCkBAIC0xNzIsNyArMTcyLDYgQEAKIAkJCSAgICBzdHJ1Y3QgaG9zdGFwZF9mcmFtZV9pbmZvICpmaSkKIHsKIAlzdHJ1Y3QgYXBfaW5mbyAqYXA7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OwogCWludCBuZXdfYXAgPSAwOwogCWludCBzZXRfYmVhY29uID0gMDsKIApAQCAtMjEwLDggKzIwOSw3IEBACiAJZWxzZQogCQlhcC0+aHRfc3VwcG9ydCA9IDA7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKLQlhcC0+bGFzdF9iZWFjb24gPSBub3cuc2VjOworCW9zX2dldF9yZWx0aW1lKCZhcC0+bGFzdF9iZWFjb24pOwogCiAJaWYgKCFuZXdfYXAgJiYgYXAgIT0gaWZhY2UtPmFwX2xpc3QpIHsKIAkJLyogbW92ZSBBUCBlbnRyeSBpbnRvIHRoZSBiZWdpbm5pbmcgb2YgdGhlIGxpc3Qgc28gdGhhdCB0aGUKQEAgLTI1Miw3ICsyNTAsNyBAQAogc3RhdGljIHZvaWQgYXBfbGlzdF90aW1lcih2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQogewogCXN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSA9IGVsb29wX2N0eDsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCXN0cnVjdCBhcF9pbmZvICphcDsKIAlpbnQgc2V0X2JlYWNvbiA9IDA7CiAKQEAgLTI2MSwxMiArMjU5LDEyIEBACiAJaWYgKCFpZmFjZS0+YXBfbGlzdCkKIAkJcmV0dXJuOwogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7CisJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CiAKIAl3aGlsZSAoaWZhY2UtPmFwX2xpc3QpIHsKIAkJYXAgPSBpZmFjZS0+YXBfbGlzdC0+cHJldjsKLQkJaWYgKGFwLT5sYXN0X2JlYWNvbiArIGlmYWNlLT5jb25mLT5hcF90YWJsZV9leHBpcmF0aW9uX3RpbWUgPj0KLQkJICAgIG5vdy5zZWMpCisJCWlmICghb3NfcmVsdGltZV9leHBpcmVkKCZub3csICZhcC0+bGFzdF9iZWFjb24sCisJCQkJCWlmYWNlLT5jb25mLT5hcF90YWJsZV9leHBpcmF0aW9uX3RpbWUpKQogCQkJYnJlYWs7CiAKIAkJYXBfZnJlZV9hcChpZmFjZSwgYXApOwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX2xpc3QuaCBiL3NyYy9hcC9hcF9saXN0LmgKaW5kZXggZDA1MjlhMS4uOTNkYzBlZCAxMDA2NDQKLS0tIGEvc3JjL2FwL2FwX2xpc3QuaAorKysgYi9zcmMvYXAvYXBfbGlzdC5oCkBAIC0yNiw3ICsyNiw3IEBACiAKIAlpbnQgaHRfc3VwcG9ydDsKIAotCW9zX3RpbWVfdCBsYXN0X2JlYWNvbjsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBsYXN0X2JlYWNvbjsKIH07CiAKIHN0cnVjdCBpZWVlODAyXzExX2VsZW1zOwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX21sbWUuYyBiL3NyYy9hcC9hcF9tbG1lLmMKaW5kZXggYTk1OTY5NC4uMTM2MDRlZCAxMDA2NDQKLS0tIGEvc3JjL2FwL2FwX21sbWUuYworKysgYi9zcmMvYXAvYXBfbWxtZS5jCkBAIC0xNiw2ICsxNiw3IEBACiAjaW5jbHVkZSAid3BhX2F1dGguaCIKICNpbmNsdWRlICJzdGFfaW5mby5oIgogI2luY2x1ZGUgImFwX21sbWUuaCIKKyNpbmNsdWRlICJob3N0YXBkLmgiCiAKIAogI2lmbmRlZiBDT05GSUdfTk9fSE9TVEFQRF9MT0dHRVIKQEAgLTgwLDcgKzgxLDggQEAKIAkJICAgICAgIEhPU1RBUERfTEVWRUxfREVCVUcsCiAJCSAgICAgICAiTUxNRS1ERUFVVEhFTlRJQ0FURS5pbmRpY2F0aW9uKCIgTUFDU1RSICIsICVkKSIsCiAJCSAgICAgICBNQUMyU1RSKHN0YS0+YWRkciksIHJlYXNvbl9jb2RlKTsKLQltbG1lX2RlbGV0ZWtleXNfcmVxdWVzdChoYXBkLCBzdGEpOworCWlmICghaGFwZC0+aWZhY2UtPmRyaXZlcl9hcF90ZWFyZG93bikKKwkJbWxtZV9kZWxldGVrZXlzX3JlcXVlc3QoaGFwZCwgc3RhKTsKIH0KIAogCkBAIC0xMTgsOCArMTIwLDYgQEAKICAqIHJlYXNzb2NpYXRpb24gcHJvY2VkdXJlIHRoYXQgd2FzIGluaXRpYXRlZCBieSB0aGF0IHNwZWNpZmljIHBlZXIgTUFDIGVudGl0eS4KICAqCiAgKiBQZWVyU1RBQWRkcmVzcyA9IHN0YS0+YWRkcgotICoKLSAqIHN0YS0+cHJldmlvdXNfYXAgY29udGFpbnMgdGhlICJDdXJyZW50IEFQIiBpbmZvcm1hdGlvbiBmcm9tIFJlYXNzb2NSZXEuCiAgKi8KIHZvaWQgbWxtZV9yZWFzc29jaWF0ZV9pbmRpY2F0aW9uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJIHN0cnVjdCBzdGFfaW5mbyAqc3RhKQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2F1dGhzcnYuYyBiL3NyYy9hcC9hdXRoc3J2LmMKaW5kZXggNjhhZDRkYy4uODZmMWNiZSAxMDA2NDQKLS0tIGEvc3JjL2FwL2F1dGhzcnYuYworKysgYi9zcmMvYXAvYXV0aHNydi5jCkBAIC03OSw3ICs3OSwxMCBAQAogCQl1c2VyLT5wYXNzd29yZF9oYXNoID0gZWFwX3VzZXItPnBhc3N3b3JkX2hhc2g7CiAJfQogCXVzZXItPmZvcmNlX3ZlcnNpb24gPSBlYXBfdXNlci0+Zm9yY2VfdmVyc2lvbjsKKwl1c2VyLT5tYWNhY2wgPSBlYXBfdXNlci0+bWFjYWNsOwogCXVzZXItPnR0bHNfYXV0aCA9IGVhcF91c2VyLT50dGxzX2F1dGg7CisJdXNlci0+cmVtZWRpYXRpb24gPSBlYXBfdXNlci0+cmVtZWRpYXRpb247CisJdXNlci0+YWNjZXB0X2F0dHIgPSBlYXBfdXNlci0+YWNjZXB0X2F0dHI7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTkyLDYgKzk1LDcgQEAKIAlvc19tZW1zZXQoJnNydiwgMCwgc2l6ZW9mKHNydikpOwogCXNydi5jbGllbnRfZmlsZSA9IGNvbmYtPnJhZGl1c19zZXJ2ZXJfY2xpZW50czsKIAlzcnYuYXV0aF9wb3J0ID0gY29uZi0+cmFkaXVzX3NlcnZlcl9hdXRoX3BvcnQ7CisJc3J2LmFjY3RfcG9ydCA9IGNvbmYtPnJhZGl1c19zZXJ2ZXJfYWNjdF9wb3J0OwogCXNydi5jb25mX2N0eCA9IGhhcGQ7CiAJc3J2LmVhcF9zaW1fZGJfcHJpdiA9IGhhcGQtPmVhcF9zaW1fZGJfcHJpdjsKIAlzcnYuc3NsX2N0eCA9IGhhcGQtPnNzbF9jdHg7CkBAIC0xMTIsOSArMTE2LDE0IEBACiAJc3J2LmVhcF9yZXFfaWRfdGV4dF9sZW4gPSBjb25mLT5lYXBfcmVxX2lkX3RleHRfbGVuOwogCXNydi5wd2RfZ3JvdXAgPSBjb25mLT5wd2RfZ3JvdXA7CiAJc3J2LnNlcnZlcl9pZCA9IGNvbmYtPnNlcnZlcl9pZCA/IGNvbmYtPnNlcnZlcl9pZCA6ICJob3N0YXBkIjsKKwlzcnYuc3FsaXRlX2ZpbGUgPSBjb25mLT5lYXBfdXNlcl9zcWxpdGU7CiAjaWZkZWYgQ09ORklHX1JBRElVU19URVNUCiAJc3J2LmR1bXBfbXNrX2ZpbGUgPSBjb25mLT5kdW1wX21za19maWxlOwogI2VuZGlmIC8qIENPTkZJR19SQURJVVNfVEVTVCAqLworI2lmZGVmIENPTkZJR19IUzIwCisJc3J2LnN1YnNjcl9yZW1lZGlhdGlvbl91cmwgPSBjb25mLT5zdWJzY3JfcmVtZWRpYXRpb25fdXJsOworCXNydi5zdWJzY3JfcmVtZWRpYXRpb25fbWV0aG9kID0gY29uZi0+c3Vic2NyX3JlbWVkaWF0aW9uX21ldGhvZDsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCiAJaGFwZC0+cmFkaXVzX3NydiA9IHJhZGl1c19zZXJ2ZXJfaW5pdCgmc3J2KTsKIAlpZiAoaGFwZC0+cmFkaXVzX3NydiA9PSBOVUxMKSB7CkBAIC0xMzMsNyArMTQyLDcgQEAKICNpZmRlZiBFQVBfVExTX0ZVTkNTCiAJaWYgKGhhcGQtPmNvbmYtPmVhcF9zZXJ2ZXIgJiYKIAkgICAgKGhhcGQtPmNvbmYtPmNhX2NlcnQgfHwgaGFwZC0+Y29uZi0+c2VydmVyX2NlcnQgfHwKLQkgICAgIGhhcGQtPmNvbmYtPmRoX2ZpbGUpKSB7CisJICAgICBoYXBkLT5jb25mLT5wcml2YXRlX2tleSB8fCBoYXBkLT5jb25mLT5kaF9maWxlKSkgewogCQlzdHJ1Y3QgdGxzX2Nvbm5lY3Rpb25fcGFyYW1zIHBhcmFtczsKIAogCQloYXBkLT5zc2xfY3R4ID0gdGxzX2luaXQoTlVMTCk7CmRpZmYgLS1naXQgYS9zcmMvYXAvYmVhY29uLmMgYi9zcmMvYXAvYmVhY29uLmMKaW5kZXggMmY0YmEyMy4uYjNiNjE0OSAxMDA2NDQKLS0tIGEvc3JjL2FwL2JlYWNvbi5jCisrKyBiL3NyYy9hcC9iZWFjb24uYwpAQCAtNCwxNCArNCw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiwgRGV2aWNlc2NhcGUgU29mdHdhcmUsIEluYy4KICAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJ1dGlscy9pbmNsdWRlcy5oIgpAQCAtMjEsNyArMTUsNiBAQAogI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9jb21tb24uaCIKLSNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgogI2luY2x1ZGUgIndwcy93cHNfZGVmcy5oIgogI2luY2x1ZGUgInAycC9wMnAuaCIKICNpbmNsdWRlICJob3N0YXBkLmgiCkBAIC0zNCwxMCArMjcsMjcgQEAKICNpbmNsdWRlICJhcF9kcnZfb3BzLmgiCiAjaW5jbHVkZSAiYmVhY29uLmgiCiAjaW5jbHVkZSAiaHMyMC5oIgorI2luY2x1ZGUgImRmcy5oIgogCiAKICNpZmRlZiBORUVEX0FQX01MTUUKIAorc3RhdGljIHU4ICogaG9zdGFwZF9laWRfYnNzX2xvYWQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCwgc2l6ZV90IGxlbikKK3sKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJaWYgKGhhcGQtPmNvbmYtPmJzc19sb2FkX3Rlc3Rfc2V0KSB7CisJCWlmICgyICsgNSA+IGxlbikKKwkJCXJldHVybiBlaWQ7CisJCSplaWQrKyA9IFdMQU5fRUlEX0JTU19MT0FEOworCQkqZWlkKysgPSA1OworCQlvc19tZW1jcHkoZWlkLCBoYXBkLT5jb25mLT5ic3NfbG9hZF90ZXN0LCA1KTsKKwkJZWlkICs9IDU7CisJfQorI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKwlyZXR1cm4gZWlkOworfQorCisKIHN0YXRpYyB1OCBpZWVlODAyXzExX2VycF9pbmZvKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpCiB7CiAJdTggZXJwID0gMDsKQEAgLTkzLDYgKzEwMyw3MCBAQAogfQogCiAKK3N0YXRpYyB1OCAqIGhvc3RhcGRfZWlkX3B3cl9jb25zdHJhaW50KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpCit7CisJdTggKnBvcyA9IGVpZDsKKwl1OCBsb2NhbF9wd3JfY29uc3RyYWludCA9IDA7CisJaW50IGRmczsKKworCWlmIChoYXBkLT5pZmFjZS0+Y3VycmVudF9tb2RlID09IE5VTEwgfHwKKwkgICAgaGFwZC0+aWZhY2UtPmN1cnJlbnRfbW9kZS0+bW9kZSAhPSBIT1NUQVBEX01PREVfSUVFRTgwMjExQSkKKwkJcmV0dXJuIGVpZDsKKworCS8qCisJICogVGhlcmUgaXMgbm8gREZTIHN1cHBvcnQgYW5kIHBvd2VyIGNvbnN0cmFpbnQgd2FzIG5vdCBkaXJlY3RseQorCSAqIHJlcXVlc3RlZCBieSBjb25maWcgb3B0aW9uLgorCSAqLworCWlmICghaGFwZC0+aWNvbmYtPmllZWU4MDIxMWggJiYKKwkgICAgaGFwZC0+aWNvbmYtPmxvY2FsX3B3cl9jb25zdHJhaW50ID09IC0xKQorCQlyZXR1cm4gZWlkOworCisJLyogQ2hlY2sgaWYgREZTIGlzIHJlcXVpcmVkIGJ5IHJlZ3VsYXRvcnkuICovCisJZGZzID0gaG9zdGFwZF9pc19kZnNfcmVxdWlyZWQoaGFwZC0+aWZhY2UpOworCWlmIChkZnMgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJGYWlsZWQgdG8gY2hlY2sgaWYgREZTIGlzIHJlcXVpcmVkOyByZXQ9JWQiLAorCQkJICAgZGZzKTsKKwkJZGZzID0gMDsKKwl9CisKKwlpZiAoZGZzID09IDAgJiYgaGFwZC0+aWNvbmYtPmxvY2FsX3B3cl9jb25zdHJhaW50ID09IC0xKQorCQlyZXR1cm4gZWlkOworCisJLyoKKwkgKiBpZWVlODAyMTFoIChERlMpIGlzIGVuYWJsZWQgc28gUG93ZXIgQ29uc3RyYWludCBlbGVtZW50IHNoYWxsCisJICogYmUgYWRkZWQgd2hlbiBydW5uaW5nIG9uIERGUyBjaGFubmVsIHdoZW5ldmVyIGxvY2FsX3B3cl9jb25zdHJhaW50CisJICogaXMgY29uZmlndXJlZCBvciBub3QuIEluIG9yZGVyIHRvIG1lZXQgcmVndWxhdGlvbnMgd2hlbiBUUEMgaXMgbm90CisJICogaW1wbGVtZW50ZWQgdXNpbmcgYSB0cmFuc21pdCBwb3dlciB0aGF0IGlzIGJlbG93IHRoZSBsZWdhbCBtYXhpbXVtCisJICogKGluY2x1ZGluZyBhbnkgbWl0aWdhdGlvbiBmYWN0b3IpIHNob3VsZCBoZWxwLiBJbiB0aGlzIGNhc2UsCisJICogaW5kaWNhdGUgMyBkQiBiZWxvdyBtYXhpbXVtIGFsbG93ZWQgdHJhbnNtaXQgcG93ZXIuCisJICovCisJaWYgKGhhcGQtPmljb25mLT5sb2NhbF9wd3JfY29uc3RyYWludCA9PSAtMSkKKwkJbG9jYWxfcHdyX2NvbnN0cmFpbnQgPSAzOworCisJLyoKKwkgKiBBIFNUQSB0aGF0IGlzIG5vdCBhbiBBUCBzaGFsbCB1c2UgYSB0cmFuc21pdCBwb3dlciBsZXNzIHRoYW4gb3IKKwkgKiBlcXVhbCB0byB0aGUgbG9jYWwgbWF4aW11bSB0cmFuc21pdCBwb3dlciBsZXZlbCBmb3IgdGhlIGNoYW5uZWwuCisJICogVGhlIGxvY2FsIG1heGltdW0gdHJhbnNtaXQgcG93ZXIgY2FuIGJlIGNhbGN1bGF0ZWQgZnJvbSB0aGUgZm9ybXVsYToKKwkgKiBsb2NhbCBtYXggVFggcHdyID0gbWF4IFRYIHB3ciAtIGxvY2FsIHB3ciBjb25zdHJhaW50CisJICogV2hlcmUgbWF4IFRYIHB3ciBpcyBtYXhpbXVtIHRyYW5zbWl0IHBvd2VyIGxldmVsIHNwZWNpZmllZCBmb3IKKwkgKiBjaGFubmVsIGluIENvdW50cnkgZWxlbWVudCBhbmQgbG9jYWwgcHdyIGNvbnN0cmFpbnQgaXMgc3BlY2lmaWVkCisJICogZm9yIGNoYW5uZWwgaW4gdGhpcyBQb3dlciBDb25zdHJhaW50IGVsZW1lbnQuCisJICovCisKKwkvKiBFbGVtZW50IElEICovCisJKnBvcysrID0gV0xBTl9FSURfUFdSX0NPTlNUUkFJTlQ7CisJLyogTGVuZ3RoICovCisJKnBvcysrID0gMTsKKwkvKiBMb2NhbCBQb3dlciBDb25zdHJhaW50ICovCisJaWYgKGxvY2FsX3B3cl9jb25zdHJhaW50KQorCQkqcG9zKysgPSBsb2NhbF9wd3JfY29uc3RyYWludDsKKwllbHNlCisJCSpwb3MrKyA9IGhhcGQtPmljb25mLT5sb2NhbF9wd3JfY29uc3RyYWludDsKKworCXJldHVybiBwb3M7Cit9CisKKwogc3RhdGljIHU4ICogaG9zdGFwZF9laWRfY291bnRyeV9hZGQodTggKnBvcywgdTggKmVuZCwgaW50IGNoYW5fc3BhY2luZywKIAkJCQkgICAgc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICpzdGFydCwKIAkJCQkgICAgc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICpwcmV2KQpAQCAtMTQ2LDcgKzIyMCw3IEBACiAJCQljb250aW51ZTsgLyogY2FuIHVzZSBzYW1lIGVudHJ5ICovCiAJCX0KIAotCQlpZiAoc3RhcnQpIHsKKwkJaWYgKHN0YXJ0ICYmIHByZXYpIHsKIAkJCXBvcyA9IGhvc3RhcGRfZWlkX2NvdW50cnlfYWRkKHBvcywgZW5kLCBjaGFuX3NwYWNpbmcsCiAJCQkJCQkgICAgICBzdGFydCwgcHJldik7CiAJCQlzdGFydCA9IE5VTEw7CkBAIC0xODcsNiArMjYxLDcwIEBACiB9CiAKIAorc3RhdGljIHU4ICogaG9zdGFwZF9laWRfY3NhKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpCit7CisJdTggY2hhbjsKKworCWlmICghaGFwZC0+Y3NfZnJlcV9wYXJhbXMuZnJlcSkKKwkJcmV0dXJuIGVpZDsKKworCWlmIChpZWVlODAyMTFfZnJlcV90b19jaGFuKGhhcGQtPmNzX2ZyZXFfcGFyYW1zLmZyZXEsICZjaGFuKSA9PQorCSAgICBOVU1fSE9TVEFQRF9NT0RFUykKKwkJcmV0dXJuIGVpZDsKKworCSplaWQrKyA9IFdMQU5fRUlEX0NIQU5ORUxfU1dJVENIOworCSplaWQrKyA9IDM7CisJKmVpZCsrID0gaGFwZC0+Y3NfYmxvY2tfdHg7CisJKmVpZCsrID0gY2hhbjsKKwkqZWlkKysgPSBoYXBkLT5jc19jb3VudDsKKworCXJldHVybiBlaWQ7Cit9CisKKworc3RhdGljIHU4ICogaG9zdGFwZF9laWRfc2Vjb25kYXJ5X2NoYW5uZWwoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCkKK3sKKwl1OCBzZWNfY2g7CisKKwlpZiAoIWhhcGQtPmNzX2ZyZXFfcGFyYW1zLnNlY19jaGFubmVsX29mZnNldCkKKwkJcmV0dXJuIGVpZDsKKworCWlmIChoYXBkLT5jc19mcmVxX3BhcmFtcy5zZWNfY2hhbm5lbF9vZmZzZXQgPT0gLTEpCisJCXNlY19jaCA9IEhUX0lORk9fSFRfUEFSQU1fU0VDT05EQVJZX0NITkxfQkVMT1c7CisJZWxzZSBpZiAoaGFwZC0+Y3NfZnJlcV9wYXJhbXMuc2VjX2NoYW5uZWxfb2Zmc2V0ID09IDEpCisJCXNlY19jaCA9IEhUX0lORk9fSFRfUEFSQU1fU0VDT05EQVJZX0NITkxfQUJPVkU7CisJZWxzZQorCQlyZXR1cm4gZWlkOworCisJKmVpZCsrID0gV0xBTl9FSURfU0VDT05EQVJZX0NIQU5ORUxfT0ZGU0VUOworCSplaWQrKyA9IDE7CisJKmVpZCsrID0gc2VjX2NoOworCisJcmV0dXJuIGVpZDsKK30KKworCitzdGF0aWMgdTggKiBob3N0YXBkX2FkZF9jc2FfZWxlbXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKnBvcywKKwkJCQkgIHU4ICpzdGFydCwgdW5zaWduZWQgaW50ICpjc2FfY291bnRlcl9vZmYpCit7CisJdTggKm9sZF9wb3MgPSBwb3M7CisKKwlpZiAoIWNzYV9jb3VudGVyX29mZikKKwkJcmV0dXJuIHBvczsKKworCSpjc2FfY291bnRlcl9vZmYgPSAwOworCXBvcyA9IGhvc3RhcGRfZWlkX2NzYShoYXBkLCBwb3MpOworCisJaWYgKHBvcyAhPSBvbGRfcG9zKSB7CisJCS8qIHNhdmUgYW4gb2Zmc2V0IHRvIHRoZSBjb3VudGVyIC0gc2hvdWxkIGJlIGxhc3QgYnl0ZSAqLworCQkqY3NhX2NvdW50ZXJfb2ZmID0gcG9zIC0gc3RhcnQgLSAxOworCQlwb3MgPSBob3N0YXBkX2VpZF9zZWNvbmRhcnlfY2hhbm5lbChoYXBkLCBwb3MpOworCX0KKworCXJldHVybiBwb3M7Cit9CisKKwogc3RhdGljIHU4ICogaG9zdGFwZF9nZW5fcHJvYmVfcmVzcChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCSAgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAogCQkJCSAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqcmVxLApAQCAtMjQyLDYgKzM4MCw5IEBACiAKIAlwb3MgPSBob3N0YXBkX2VpZF9jb3VudHJ5KGhhcGQsIHBvcywgZXBvcyAtIHBvcyk7CiAKKwkvKiBQb3dlciBDb25zdHJhaW50IGVsZW1lbnQgKi8KKwlwb3MgPSBob3N0YXBkX2VpZF9wd3JfY29uc3RyYWludChoYXBkLCBwb3MpOworCiAJLyogRVJQIEluZm9ybWF0aW9uIGVsZW1lbnQgKi8KIAlwb3MgPSBob3N0YXBkX2VpZF9lcnBfaW5mbyhoYXBkLCBwb3MpOwogCkBAIC0yNTEsNiArMzkyLDggQEAKIAkvKiBSU04sIE1ESUUsIFdQQSAqLwogCXBvcyA9IGhvc3RhcGRfZWlkX3dwYShoYXBkLCBwb3MsIGVwb3MgLSBwb3MpOwogCisJcG9zID0gaG9zdGFwZF9laWRfYnNzX2xvYWQoaGFwZCwgcG9zLCBlcG9zIC0gcG9zKTsKKwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFOCiAJcG9zID0gaG9zdGFwZF9laWRfaHRfY2FwYWJpbGl0aWVzKGhhcGQsIHBvcyk7CiAJcG9zID0gaG9zdGFwZF9laWRfaHRfb3BlcmF0aW9uKGhhcGQsIHBvcyk7CkBAIC0yNjUsNiArNDA4LDggQEAKIAlwb3MgPSBob3N0YXBkX2VpZF9hZHZfcHJvdG8oaGFwZCwgcG9zKTsKIAlwb3MgPSBob3N0YXBkX2VpZF9yb2FtaW5nX2NvbnNvcnRpdW0oaGFwZCwgcG9zKTsKIAorCXBvcyA9IGhvc3RhcGRfYWRkX2NzYV9lbGVtcyhoYXBkLCBwb3MsICh1OCAqKXJlc3AsCisJCQkJICAgICZoYXBkLT5jc19jX29mZl9wcm9iZXJlc3ApOwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFBQwogCXBvcyA9IGhvc3RhcGRfZWlkX3ZodF9jYXBhYmlsaXRpZXMoaGFwZCwgcG9zKTsKIAlwb3MgPSBob3N0YXBkX2VpZF92aHRfb3BlcmF0aW9uKGhhcGQsIHBvcyk7CkBAIC0yOTcsNiArNDQyLDcgQEAKIAogI2lmZGVmIENPTkZJR19IUzIwCiAJcG9zID0gaG9zdGFwZF9laWRfaHMyMF9pbmRpY2F0aW9uKGhhcGQsIHBvcyk7CisJcG9zID0gaG9zdGFwZF9laWRfb3NlbihoYXBkLCBwb3MpOwogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKIAlpZiAoaGFwZC0+Y29uZi0+dmVuZG9yX2VsZW1lbnRzKSB7CkBAIC00NDMsMTIgKzU4OSwxMCBAQAogCQkJc3RhLT5zc2lkX3Byb2JlID0gJmhhcGQtPmNvbmYtPnNzaWQ7CiAJfSBlbHNlIHsKIAkJaWYgKCEobWdtdC0+ZGFbMF0gJiAweDAxKSkgewotCQkJY2hhciBzc2lkX3R4dFszM107Ci0JCQlpZWVlODAyXzExX3ByaW50X3NzaWQoc3NpZF90eHQsIGVsZW1zLnNzaWQsCi0JCQkJCSAgICAgIGVsZW1zLnNzaWRfbGVuKTsKIAkJCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJQcm9iZSBSZXF1ZXN0IGZyb20gIiBNQUNTVFIKIAkJCQkgICAiIGZvciBmb3JlaWduIFNTSUQgJyVzJyAoREEgIiBNQUNTVFIgIiklcyIsCi0JCQkJICAgTUFDMlNUUihtZ210LT5zYSksIHNzaWRfdHh0LAorCQkJCSAgIE1BQzJTVFIobWdtdC0+c2EpLAorCQkJCSAgIHdwYV9zc2lkX3R4dChlbGVtcy5zc2lkLCBlbGVtcy5zc2lkX2xlbiksCiAJCQkJICAgTUFDMlNUUihtZ210LT5kYSksCiAJCQkJICAgZWxlbXMuc3NpZF9saXN0ID8gIiAoU1NJRCBsaXN0KSIgOiAiIik7CiAJCX0KQEAgLTQ1Niw3ICs2MDAsOCBAQAogCX0KIAogI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKLQlpZiAoZWxlbXMuaW50ZXJ3b3JraW5nICYmIGVsZW1zLmludGVyd29ya2luZ19sZW4gPj0gMSkgeworCWlmIChoYXBkLT5jb25mLT5pbnRlcndvcmtpbmcgJiYKKwkgICAgZWxlbXMuaW50ZXJ3b3JraW5nICYmIGVsZW1zLmludGVyd29ya2luZ19sZW4gPj0gMSkgewogCQl1OCBhbnQgPSBlbGVtcy5pbnRlcndvcmtpbmdbMF0gJiAweDBmOwogCQlpZiAoYW50ICE9IElOVEVSV09SS0lOR19BTlRfV0lMRENBUkQgJiYKIAkJICAgIGFudCAhPSBoYXBkLT5jb25mLT5hY2Nlc3NfbmV0d29ya190eXBlKSB7CkBAIC00NjcsNyArNjEyLDcgQEAKIAkJfQogCX0KIAotCWlmIChlbGVtcy5pbnRlcndvcmtpbmcgJiYKKwlpZiAoaGFwZC0+Y29uZi0+aW50ZXJ3b3JraW5nICYmIGVsZW1zLmludGVyd29ya2luZyAmJgogCSAgICAoZWxlbXMuaW50ZXJ3b3JraW5nX2xlbiA9PSA3IHx8IGVsZW1zLmludGVyd29ya2luZ19sZW4gPT0gOSkpIHsKIAkJY29uc3QgdTggKmhlc3NpZDsKIAkJaWYgKGVsZW1zLmludGVyd29ya2luZ19sZW4gPT0gNykKQEAgLTUwMCw3ICs2NDUsNyBAQAogCSAqIHdpdGggQVAgY29uZmlndXJhdGlvbiAqLwogCiAjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwotCWlmIChoYXBkLT5pY29uZi0+aWdub3JlX3Byb2JlX3Byb2JhYmlsaXR5ID4gMC4wZCAmJgorCWlmIChoYXBkLT5pY29uZi0+aWdub3JlX3Byb2JlX3Byb2JhYmlsaXR5ID4gMC4wICYmCiAJICAgIGRyYW5kNDgoKSA8IGhhcGQtPmljb25mLT5pZ25vcmVfcHJvYmVfcHJvYmFiaWxpdHkpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywKIAkJCSAgICJURVNUSU5HOiBpZ25vcmluZyBwcm9iZSByZXF1ZXN0IGZyb20gIiBNQUNTVFIsCkBAIC01MjIsNyArNjY3LDcgQEAKIAkJICAgaXNfYnJvYWRjYXN0X2V0aGVyX2FkZHIobWdtdC0+ZGEpKTsKIAogCWlmIChob3N0YXBkX2Rydl9zZW5kX21sbWUoaGFwZCwgcmVzcCwgcmVzcF9sZW4sIG5vYWNrKSA8IDApCi0JCXBlcnJvcigiaGFuZGxlX3Byb2JlX3JlcTogc2VuZCIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaGFuZGxlX3Byb2JlX3JlcTogc2VuZCBmYWlsZWQiKTsKIAogCW9zX2ZyZWUocmVzcCk7CiAKQEAgLTU3MCwyMyArNzE1LDE3IEBACiAjZW5kaWYgLyogTkVFRF9BUF9NTE1FICovCiAKIAotdm9pZCBpZWVlODAyXzExX3NldF9iZWFjb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK2ludCBpZWVlODAyXzExX2J1aWxkX2FwX3BhcmFtcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJICAgICAgIHN0cnVjdCB3cGFfZHJpdmVyX2FwX3BhcmFtcyAqcGFyYW1zKQogewogCXN0cnVjdCBpZWVlODAyMTFfbWdtdCAqaGVhZCA9IE5VTEw7CiAJdTggKnRhaWwgPSBOVUxMOwogCXNpemVfdCBoZWFkX2xlbiA9IDAsIHRhaWxfbGVuID0gMDsKIAl1OCAqcmVzcCA9IE5VTEw7CiAJc2l6ZV90IHJlc3BfbGVuID0gMDsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl9hcF9wYXJhbXMgcGFyYW1zOwotCXN0cnVjdCB3cGFidWYgKmJlYWNvbiwgKnByb2JlcmVzcCwgKmFzc29jcmVzcDsKICNpZmRlZiBORUVEX0FQX01MTUUKIAl1MTYgY2FwYWJfaW5mbzsKIAl1OCAqcG9zLCAqdGFpbHBvczsKLSNlbmRpZiAvKiBORUVEX0FQX01MTUUgKi8KLQotCWhhcGQtPmJlYWNvbl9zZXRfZG9uZSA9IDE7Ci0KLSNpZmRlZiBORUVEX0FQX01MTUUKIAogI2RlZmluZSBCRUFDT05fSEVBRF9CVUZfU0laRSAyNTYKICNkZWZpbmUgQkVBQ09OX1RBSUxfQlVGX1NJWkUgNTEyCkBAIC02MDcsNyArNzQ2LDcgQEAKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gc2V0IGJlYWNvbiBkYXRhIik7CiAJCW9zX2ZyZWUoaGVhZCk7CiAJCW9zX2ZyZWUodGFpbCk7Ci0JCXJldHVybjsKKwkJcmV0dXJuIC0xOwogCX0KIAogCWhlYWQtPmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCkBAIC02NTIsNiArNzkxLDkgQEAKIAl0YWlscG9zID0gaG9zdGFwZF9laWRfY291bnRyeShoYXBkLCB0YWlscG9zLAogCQkJCSAgICAgIHRhaWwgKyBCRUFDT05fVEFJTF9CVUZfU0laRSAtIHRhaWxwb3MpOwogCisJLyogUG93ZXIgQ29uc3RyYWludCBlbGVtZW50ICovCisJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX3B3cl9jb25zdHJhaW50KGhhcGQsIHRhaWxwb3MpOworCiAJLyogRVJQIEluZm9ybWF0aW9uIGVsZW1lbnQgKi8KIAl0YWlscG9zID0gaG9zdGFwZF9laWRfZXJwX2luZm8oaGFwZCwgdGFpbHBvcyk7CiAKQEAgLTY2Miw2ICs4MDQsOSBAQAogCXRhaWxwb3MgPSBob3N0YXBkX2VpZF93cGEoaGFwZCwgdGFpbHBvcywgdGFpbCArIEJFQUNPTl9UQUlMX0JVRl9TSVpFIC0KIAkJCQkgIHRhaWxwb3MpOwogCisJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX2Jzc19sb2FkKGhhcGQsIHRhaWxwb3MsCisJCQkJICAgICAgIHRhaWwgKyBCRUFDT05fVEFJTF9CVUZfU0laRSAtIHRhaWxwb3MpOworCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMU4KIAl0YWlscG9zID0gaG9zdGFwZF9laWRfaHRfY2FwYWJpbGl0aWVzKGhhcGQsIHRhaWxwb3MpOwogCXRhaWxwb3MgPSBob3N0YXBkX2VpZF9odF9vcGVyYXRpb24oaGFwZCwgdGFpbHBvcyk7CkBAIC02NzgsNyArODIzLDggQEAKIAl0YWlscG9zID0gaG9zdGFwZF9laWRfaW50ZXJ3b3JraW5nKGhhcGQsIHRhaWxwb3MpOwogCXRhaWxwb3MgPSBob3N0YXBkX2VpZF9hZHZfcHJvdG8oaGFwZCwgdGFpbHBvcyk7CiAJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX3JvYW1pbmdfY29uc29ydGl1bShoYXBkLCB0YWlscG9zKTsKLQorCXRhaWxwb3MgPSBob3N0YXBkX2FkZF9jc2FfZWxlbXMoaGFwZCwgdGFpbHBvcywgdGFpbCwKKwkJCQkJJmhhcGQtPmNzX2Nfb2ZmX2JlYWNvbik7CiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMUFDCiAJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX3ZodF9jYXBhYmlsaXRpZXMoaGFwZCwgdGFpbHBvcyk7CiAJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX3ZodF9vcGVyYXRpb24oaGFwZCwgdGFpbHBvcyk7CkBAIC03MTAsNiArODU2LDcgQEAKIAogI2lmZGVmIENPTkZJR19IUzIwCiAJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX2hzMjBfaW5kaWNhdGlvbihoYXBkLCB0YWlscG9zKTsKKwl0YWlscG9zID0gaG9zdGFwZF9laWRfb3NlbihoYXBkLCB0YWlscG9zKTsKICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCiAJaWYgKGhhcGQtPmNvbmYtPnZlbmRvcl9lbGVtZW50cykgewpAQCAtNzIzLDk0ICs4NzAsMTYyIEBACiAJcmVzcCA9IGhvc3RhcGRfcHJvYmVfcmVzcF9vZmZsb2FkcyhoYXBkLCAmcmVzcF9sZW4pOwogI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLwogCi0Jb3NfbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKLQlwYXJhbXMuaGVhZCA9ICh1OCAqKSBoZWFkOwotCXBhcmFtcy5oZWFkX2xlbiA9IGhlYWRfbGVuOwotCXBhcmFtcy50YWlsID0gdGFpbDsKLQlwYXJhbXMudGFpbF9sZW4gPSB0YWlsX2xlbjsKLQlwYXJhbXMucHJvYmVyZXNwID0gcmVzcDsKLQlwYXJhbXMucHJvYmVyZXNwX2xlbiA9IHJlc3BfbGVuOwotCXBhcmFtcy5kdGltX3BlcmlvZCA9IGhhcGQtPmNvbmYtPmR0aW1fcGVyaW9kOwotCXBhcmFtcy5iZWFjb25faW50ID0gaGFwZC0+aWNvbmYtPmJlYWNvbl9pbnQ7Ci0JcGFyYW1zLmJhc2ljX3JhdGVzID0gaGFwZC0+aWZhY2UtPmJhc2ljX3JhdGVzOwotCXBhcmFtcy5zc2lkID0gaGFwZC0+Y29uZi0+c3NpZC5zc2lkOwotCXBhcmFtcy5zc2lkX2xlbiA9IGhhcGQtPmNvbmYtPnNzaWQuc3NpZF9sZW47Ci0JcGFyYW1zLnBhaXJ3aXNlX2NpcGhlcnMgPSBoYXBkLT5jb25mLT5yc25fcGFpcndpc2UgPwotCQloYXBkLT5jb25mLT5yc25fcGFpcndpc2UgOiBoYXBkLT5jb25mLT53cGFfcGFpcndpc2U7Ci0JcGFyYW1zLmdyb3VwX2NpcGhlciA9IGhhcGQtPmNvbmYtPndwYV9ncm91cDsKLQlwYXJhbXMua2V5X21nbXRfc3VpdGVzID0gaGFwZC0+Y29uZi0+d3BhX2tleV9tZ210OwotCXBhcmFtcy5hdXRoX2FsZ3MgPSBoYXBkLT5jb25mLT5hdXRoX2FsZ3M7Ci0JcGFyYW1zLndwYV92ZXJzaW9uID0gaGFwZC0+Y29uZi0+d3BhOwotCXBhcmFtcy5wcml2YWN5ID0gaGFwZC0+Y29uZi0+c3NpZC53ZXAua2V5c19zZXQgfHwgaGFwZC0+Y29uZi0+d3BhIHx8CisJb3NfbWVtc2V0KHBhcmFtcywgMCwgc2l6ZW9mKCpwYXJhbXMpKTsKKwlwYXJhbXMtPmhlYWQgPSAodTggKikgaGVhZDsKKwlwYXJhbXMtPmhlYWRfbGVuID0gaGVhZF9sZW47CisJcGFyYW1zLT50YWlsID0gdGFpbDsKKwlwYXJhbXMtPnRhaWxfbGVuID0gdGFpbF9sZW47CisJcGFyYW1zLT5wcm9iZXJlc3AgPSByZXNwOworCXBhcmFtcy0+cHJvYmVyZXNwX2xlbiA9IHJlc3BfbGVuOworCXBhcmFtcy0+ZHRpbV9wZXJpb2QgPSBoYXBkLT5jb25mLT5kdGltX3BlcmlvZDsKKwlwYXJhbXMtPmJlYWNvbl9pbnQgPSBoYXBkLT5pY29uZi0+YmVhY29uX2ludDsKKwlwYXJhbXMtPmJhc2ljX3JhdGVzID0gaGFwZC0+aWZhY2UtPmJhc2ljX3JhdGVzOworCXBhcmFtcy0+c3NpZCA9IGhhcGQtPmNvbmYtPnNzaWQuc3NpZDsKKwlwYXJhbXMtPnNzaWRfbGVuID0gaGFwZC0+Y29uZi0+c3NpZC5zc2lkX2xlbjsKKwlwYXJhbXMtPnBhaXJ3aXNlX2NpcGhlcnMgPSBoYXBkLT5jb25mLT53cGFfcGFpcndpc2UgfAorCQloYXBkLT5jb25mLT5yc25fcGFpcndpc2U7CisJcGFyYW1zLT5ncm91cF9jaXBoZXIgPSBoYXBkLT5jb25mLT53cGFfZ3JvdXA7CisJcGFyYW1zLT5rZXlfbWdtdF9zdWl0ZXMgPSBoYXBkLT5jb25mLT53cGFfa2V5X21nbXQ7CisJcGFyYW1zLT5hdXRoX2FsZ3MgPSBoYXBkLT5jb25mLT5hdXRoX2FsZ3M7CisJcGFyYW1zLT53cGFfdmVyc2lvbiA9IGhhcGQtPmNvbmYtPndwYTsKKwlwYXJhbXMtPnByaXZhY3kgPSBoYXBkLT5jb25mLT5zc2lkLndlcC5rZXlzX3NldCB8fCBoYXBkLT5jb25mLT53cGEgfHwKIAkJKGhhcGQtPmNvbmYtPmllZWU4MDJfMXggJiYKIAkJIChoYXBkLT5jb25mLT5kZWZhdWx0X3dlcF9rZXlfbGVuIHx8CiAJCSAgaGFwZC0+Y29uZi0+aW5kaXZpZHVhbF93ZXBfa2V5X2xlbikpOwogCXN3aXRjaCAoaGFwZC0+Y29uZi0+aWdub3JlX2Jyb2FkY2FzdF9zc2lkKSB7CiAJY2FzZSAwOgotCQlwYXJhbXMuaGlkZV9zc2lkID0gTk9fU1NJRF9ISURJTkc7CisJCXBhcmFtcy0+aGlkZV9zc2lkID0gTk9fU1NJRF9ISURJTkc7CiAJCWJyZWFrOwogCWNhc2UgMToKLQkJcGFyYW1zLmhpZGVfc3NpZCA9IEhJRERFTl9TU0lEX1pFUk9fTEVOOworCQlwYXJhbXMtPmhpZGVfc3NpZCA9IEhJRERFTl9TU0lEX1pFUk9fTEVOOwogCQlicmVhazsKIAljYXNlIDI6Ci0JCXBhcmFtcy5oaWRlX3NzaWQgPSBISURERU5fU1NJRF9aRVJPX0NPTlRFTlRTOworCQlwYXJhbXMtPmhpZGVfc3NpZCA9IEhJRERFTl9TU0lEX1pFUk9fQ09OVEVOVFM7CiAJCWJyZWFrOwogCX0KLQlob3N0YXBkX2J1aWxkX2FwX2V4dHJhX2llcyhoYXBkLCAmYmVhY29uLCAmcHJvYmVyZXNwLCAmYXNzb2NyZXNwKTsKLQlwYXJhbXMuYmVhY29uX2llcyA9IGJlYWNvbjsKLQlwYXJhbXMucHJvYmVyZXNwX2llcyA9IHByb2JlcmVzcDsKLQlwYXJhbXMuYXNzb2NyZXNwX2llcyA9IGFzc29jcmVzcDsKLQlwYXJhbXMuaXNvbGF0ZSA9IGhhcGQtPmNvbmYtPmlzb2xhdGU7CisJcGFyYW1zLT5pc29sYXRlID0gaGFwZC0+Y29uZi0+aXNvbGF0ZTsKICNpZmRlZiBORUVEX0FQX01MTUUKLQlwYXJhbXMuY3RzX3Byb3RlY3QgPSAhIShpZWVlODAyXzExX2VycF9pbmZvKGhhcGQpICYKKwlwYXJhbXMtPmN0c19wcm90ZWN0ID0gISEoaWVlZTgwMl8xMV9lcnBfaW5mbyhoYXBkKSAmCiAJCQkJRVJQX0lORk9fVVNFX1BST1RFQ1RJT04pOwotCXBhcmFtcy5wcmVhbWJsZSA9IGhhcGQtPmlmYWNlLT5udW1fc3RhX25vX3Nob3J0X3ByZWFtYmxlID09IDAgJiYKKwlwYXJhbXMtPnByZWFtYmxlID0gaGFwZC0+aWZhY2UtPm51bV9zdGFfbm9fc2hvcnRfcHJlYW1ibGUgPT0gMCAmJgogCQloYXBkLT5pY29uZi0+cHJlYW1ibGUgPT0gU0hPUlRfUFJFQU1CTEU7CiAJaWYgKGhhcGQtPmlmYWNlLT5jdXJyZW50X21vZGUgJiYKIAkgICAgaGFwZC0+aWZhY2UtPmN1cnJlbnRfbW9kZS0+bW9kZSA9PSBIT1NUQVBEX01PREVfSUVFRTgwMjExRykKLQkJcGFyYW1zLnNob3J0X3Nsb3RfdGltZSA9CisJCXBhcmFtcy0+c2hvcnRfc2xvdF90aW1lID0KIAkJCWhhcGQtPmlmYWNlLT5udW1fc3RhX25vX3Nob3J0X3Nsb3RfdGltZSA+IDAgPyAwIDogMTsKIAllbHNlCi0JCXBhcmFtcy5zaG9ydF9zbG90X3RpbWUgPSAtMTsKKwkJcGFyYW1zLT5zaG9ydF9zbG90X3RpbWUgPSAtMTsKIAlpZiAoIWhhcGQtPmljb25mLT5pZWVlODAyMTFuIHx8IGhhcGQtPmNvbmYtPmRpc2FibGVfMTFuKQotCQlwYXJhbXMuaHRfb3Btb2RlID0gLTE7CisJCXBhcmFtcy0+aHRfb3Btb2RlID0gLTE7CiAJZWxzZQotCQlwYXJhbXMuaHRfb3Btb2RlID0gaGFwZC0+aWZhY2UtPmh0X29wX21vZGU7CisJCXBhcmFtcy0+aHRfb3Btb2RlID0gaGFwZC0+aWZhY2UtPmh0X29wX21vZGU7CiAjZW5kaWYgLyogTkVFRF9BUF9NTE1FICovCi0JcGFyYW1zLmludGVyd29ya2luZyA9IGhhcGQtPmNvbmYtPmludGVyd29ya2luZzsKKwlwYXJhbXMtPmludGVyd29ya2luZyA9IGhhcGQtPmNvbmYtPmludGVyd29ya2luZzsKIAlpZiAoaGFwZC0+Y29uZi0+aW50ZXJ3b3JraW5nICYmCiAJICAgICFpc196ZXJvX2V0aGVyX2FkZHIoaGFwZC0+Y29uZi0+aGVzc2lkKSkKLQkJcGFyYW1zLmhlc3NpZCA9IGhhcGQtPmNvbmYtPmhlc3NpZDsKLQlwYXJhbXMuYWNjZXNzX25ldHdvcmtfdHlwZSA9IGhhcGQtPmNvbmYtPmFjY2Vzc19uZXR3b3JrX3R5cGU7Ci0JcGFyYW1zLmFwX21heF9pbmFjdGl2aXR5ID0gaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHk7CisJCXBhcmFtcy0+aGVzc2lkID0gaGFwZC0+Y29uZi0+aGVzc2lkOworCXBhcmFtcy0+YWNjZXNzX25ldHdvcmtfdHlwZSA9IGhhcGQtPmNvbmYtPmFjY2Vzc19uZXR3b3JrX3R5cGU7CisJcGFyYW1zLT5hcF9tYXhfaW5hY3Rpdml0eSA9IGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5OwogI2lmZGVmIENPTkZJR19IUzIwCi0JcGFyYW1zLmRpc2FibGVfZGdhZiA9IGhhcGQtPmNvbmYtPmRpc2FibGVfZGdhZjsKKwlwYXJhbXMtPmRpc2FibGVfZGdhZiA9IGhhcGQtPmNvbmYtPmRpc2FibGVfZGdhZjsKKwlpZiAoaGFwZC0+Y29uZi0+b3NlbikgeworCQlwYXJhbXMtPnByaXZhY3kgPSAxOworCQlwYXJhbXMtPm9zZW4gPSAxOworCX0KICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwotCWlmIChob3N0YXBkX2Rydl9zZXRfYXAoaGFwZCwgJnBhcmFtcykpCi0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiRmFpbGVkIHRvIHNldCBiZWFjb24gcGFyYW1ldGVycyIpOwotCWhvc3RhcGRfZnJlZV9hcF9leHRyYV9pZXMoaGFwZCwgYmVhY29uLCBwcm9iZXJlc3AsIGFzc29jcmVzcCk7Ci0KLQlvc19mcmVlKHRhaWwpOwotCW9zX2ZyZWUoaGVhZCk7Ci0Jb3NfZnJlZShyZXNwKTsKKwlyZXR1cm4gMDsKIH0KIAogCi12b2lkIGllZWU4MDJfMTFfc2V0X2JlYWNvbnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQordm9pZCBpZWVlODAyXzExX2ZyZWVfYXBfcGFyYW1zKHN0cnVjdCB3cGFfZHJpdmVyX2FwX3BhcmFtcyAqcGFyYW1zKQoreworCW9zX2ZyZWUocGFyYW1zLT50YWlsKTsKKwlwYXJhbXMtPnRhaWwgPSBOVUxMOworCW9zX2ZyZWUocGFyYW1zLT5oZWFkKTsKKwlwYXJhbXMtPmhlYWQgPSBOVUxMOworCW9zX2ZyZWUocGFyYW1zLT5wcm9iZXJlc3ApOworCXBhcmFtcy0+cHJvYmVyZXNwID0gTlVMTDsKK30KKworCitpbnQgaWVlZTgwMl8xMV9zZXRfYmVhY29uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpCit7CisJc3RydWN0IHdwYV9kcml2ZXJfYXBfcGFyYW1zIHBhcmFtczsKKwlzdHJ1Y3QgaG9zdGFwZF9mcmVxX3BhcmFtcyBmcmVxOworCXN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSA9IGhhcGQtPmlmYWNlOworCXN0cnVjdCBob3N0YXBkX2NvbmZpZyAqaWNvbmYgPSBpZmFjZS0+Y29uZjsKKwlzdHJ1Y3Qgd3BhYnVmICpiZWFjb24sICpwcm9iZXJlc3AsICphc3NvY3Jlc3A7CisJaW50IHJlcywgcmV0ID0gLTE7CisKKwlpZiAoaGFwZC0+Y3NhX2luX3Byb2dyZXNzKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ2Fubm90IHNldCBiZWFjb25zIGR1cmluZyBDU0EgcGVyaW9kIik7CisJCXJldHVybiAtMTsKKwl9CisKKwloYXBkLT5iZWFjb25fc2V0X2RvbmUgPSAxOworCisJaWYgKGllZWU4MDJfMTFfYnVpbGRfYXBfcGFyYW1zKGhhcGQsICZwYXJhbXMpIDwgMCkKKwkJcmV0dXJuIC0xOworCisJaWYgKGhvc3RhcGRfYnVpbGRfYXBfZXh0cmFfaWVzKGhhcGQsICZiZWFjb24sICZwcm9iZXJlc3AsICZhc3NvY3Jlc3ApIDwKKwkgICAgMCkKKwkJZ290byBmYWlsOworCisJcGFyYW1zLmJlYWNvbl9pZXMgPSBiZWFjb247CisJcGFyYW1zLnByb2JlcmVzcF9pZXMgPSBwcm9iZXJlc3A7CisJcGFyYW1zLmFzc29jcmVzcF9pZXMgPSBhc3NvY3Jlc3A7CisKKwlpZiAoaWZhY2UtPmN1cnJlbnRfbW9kZSAmJgorCSAgICBob3N0YXBkX3NldF9mcmVxX3BhcmFtcygmZnJlcSwgaWNvbmYtPmh3X21vZGUsIGlmYWNlLT5mcmVxLAorCQkJCSAgICBpY29uZi0+Y2hhbm5lbCwgaWNvbmYtPmllZWU4MDIxMW4sCisJCQkJICAgIGljb25mLT5pZWVlODAyMTFhYywKKwkJCQkgICAgaWNvbmYtPnNlY29uZGFyeV9jaGFubmVsLAorCQkJCSAgICBpY29uZi0+dmh0X29wZXJfY2h3aWR0aCwKKwkJCQkgICAgaWNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHgsCisJCQkJICAgIGljb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4LAorCQkJCSAgICBpZmFjZS0+Y3VycmVudF9tb2RlLT52aHRfY2FwYWIpID09IDApCisJCXBhcmFtcy5mcmVxID0gJmZyZXE7CisKKwlyZXMgPSBob3N0YXBkX2Rydl9zZXRfYXAoaGFwZCwgJnBhcmFtcyk7CisJaG9zdGFwZF9mcmVlX2FwX2V4dHJhX2llcyhoYXBkLCBiZWFjb24sIHByb2JlcmVzcCwgYXNzb2NyZXNwKTsKKwlpZiAocmVzKQorCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBzZXQgYmVhY29uIHBhcmFtZXRlcnMiKTsKKwllbHNlCisJCXJldCA9IDA7CitmYWlsOgorCWllZWU4MDJfMTFfZnJlZV9hcF9wYXJhbXMoJnBhcmFtcyk7CisJcmV0dXJuIHJldDsKK30KKworCitpbnQgaWVlZTgwMl8xMV9zZXRfYmVhY29ucyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7CiAJc2l6ZV90IGk7Ci0JZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspCi0JCWllZWU4MDJfMTFfc2V0X2JlYWNvbihpZmFjZS0+YnNzW2ldKTsKKwlpbnQgcmV0ID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBpZmFjZS0+bnVtX2JzczsgaSsrKSB7CisJCWlmIChpZmFjZS0+YnNzW2ldLT5zdGFydGVkICYmCisJCSAgICBpZWVlODAyXzExX3NldF9iZWFjb24oaWZhY2UtPmJzc1tpXSkgPCAwKQorCQkJcmV0ID0gLTE7CisJfQorCisJcmV0dXJuIHJldDsKIH0KIAogCiAvKiBvbmx5IHVwZGF0ZSBiZWFjb25zIGlmIHN0YXJ0ZWQgKi8KLXZvaWQgaWVlZTgwMl8xMV91cGRhdGVfYmVhY29ucyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCitpbnQgaWVlZTgwMl8xMV91cGRhdGVfYmVhY29ucyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7CiAJc2l6ZV90IGk7Ci0JZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspCi0JCWlmIChpZmFjZS0+YnNzW2ldLT5iZWFjb25fc2V0X2RvbmUpCi0JCQlpZWVlODAyXzExX3NldF9iZWFjb24oaWZhY2UtPmJzc1tpXSk7CisJaW50IHJldCA9IDA7CisKKwlmb3IgKGkgPSAwOyBpIDwgaWZhY2UtPm51bV9ic3M7IGkrKykgeworCQlpZiAoaWZhY2UtPmJzc1tpXS0+YmVhY29uX3NldF9kb25lICYmIGlmYWNlLT5ic3NbaV0tPnN0YXJ0ZWQgJiYKKwkJICAgIGllZWU4MDJfMTFfc2V0X2JlYWNvbihpZmFjZS0+YnNzW2ldKSA8IDApCisJCQlyZXQgPSAtMTsKKwl9CisKKwlyZXR1cm4gcmV0OwogfQogCiAjZW5kaWYgLyogQ09ORklHX05BVElWRV9XSU5ET1dTICovCmRpZmYgLS1naXQgYS9zcmMvYXAvYmVhY29uLmggYi9zcmMvYXAvYmVhY29uLmgKaW5kZXggMzdmMTBkMi4uNzIyMTU5YSAxMDA2NDQKLS0tIGEvc3JjL2FwL2JlYWNvbi5oCisrKyBiL3NyYy9hcC9iZWFjb24uaApAQCAtMywxNCArMyw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwNCwgSW5zdGFudDgwMiBOZXR3b3JrcywgSW5jLgogICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDYsIERldmljZXNjYXBlIFNvZnR3YXJlLCBJbmMuCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBCRUFDT05fSApAQCAtMjEsOCArMTUsMTEgQEAKIHZvaWQgaGFuZGxlX3Byb2JlX3JlcShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkgICAgICBjb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQsIHNpemVfdCBsZW4sCiAJCSAgICAgIGludCBzc2lfc2lnbmFsKTsKLXZvaWQgaWVlZTgwMl8xMV9zZXRfYmVhY29uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwotdm9pZCBpZWVlODAyXzExX3NldF9iZWFjb25zKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7Ci12b2lkIGllZWU4MDJfMTFfdXBkYXRlX2JlYWNvbnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKK2ludCBpZWVlODAyXzExX3NldF9iZWFjb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CitpbnQgaWVlZTgwMl8xMV9zZXRfYmVhY29ucyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpOworaW50IGllZWU4MDJfMTFfdXBkYXRlX2JlYWNvbnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKK2ludCBpZWVlODAyXzExX2J1aWxkX2FwX3BhcmFtcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJICAgICAgIHN0cnVjdCB3cGFfZHJpdmVyX2FwX3BhcmFtcyAqcGFyYW1zKTsKK3ZvaWQgaWVlZTgwMl8xMV9mcmVlX2FwX3BhcmFtcyhzdHJ1Y3Qgd3BhX2RyaXZlcl9hcF9wYXJhbXMgKnBhcmFtcyk7CiAKICNlbmRpZiAvKiBCRUFDT05fSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2N0cmxfaWZhY2VfYXAuYyBiL3NyYy9hcC9jdHJsX2lmYWNlX2FwLmMKaW5kZXggMWNiN2U3My4uMzllZGJkNyAxMDA2NDQKLS0tIGEvc3JjL2FwL2N0cmxfaWZhY2VfYXAuYworKysgYi9zcmMvYXAvY3RybF9pZmFjZV9hcC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIENvbnRyb2wgaW50ZXJmYWNlIGZvciBzaGFyZWQgQVAgY29tbWFuZHMKLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTEwLDYgKzEwLDcgQEAKIAogI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKKyNpbmNsdWRlICJlYXBvbF9hdXRoL2VhcG9sX2F1dGhfc20uaCIKICNpbmNsdWRlICJob3N0YXBkLmgiCiAjaW5jbHVkZSAiaWVlZTgwMl8xeC5oIgogI2luY2x1ZGUgIndwYV9hdXRoLmgiCkBAIC0yMSwyNSArMjIsNjEgQEAKICNpbmNsdWRlICJhcF9kcnZfb3BzLmgiCiAKIAorc3RhdGljIGludCBob3N0YXBkX2dldF9zdGFfdHhfcngoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgc3RydWN0IHN0YV9pbmZvICpzdGEsCisJCQkJIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKK3sKKwlzdHJ1Y3QgaG9zdGFwX3N0YV9kcml2ZXJfZGF0YSBkYXRhOworCWludCByZXQ7CisKKwlpZiAoaG9zdGFwZF9kcnZfcmVhZF9zdGFfZGF0YShoYXBkLCAmZGF0YSwgc3RhLT5hZGRyKSA8IDApCisJCXJldHVybiAwOworCisJcmV0ID0gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJyeF9wYWNrZXRzPSVsdVxudHhfcGFja2V0cz0lbHVcbiIKKwkJCSAgInJ4X2J5dGVzPSVsdVxudHhfYnl0ZXM9JWx1XG4iLAorCQkJICBkYXRhLnJ4X3BhY2tldHMsIGRhdGEudHhfcGFja2V0cywKKwkJCSAgZGF0YS5yeF9ieXRlcywgZGF0YS50eF9ieXRlcyk7CisJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbikKKwkJcmV0dXJuIDA7CisJcmV0dXJuIHJldDsKK30KKworCiBzdGF0aWMgaW50IGhvc3RhcGRfZ2V0X3N0YV9jb25uX3RpbWUoc3RydWN0IHN0YV9pbmZvICpzdGEsCiAJCQkJICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCiB7Ci0Jc3RydWN0IG9zX3RpbWUgbm93LCBhZ2U7Ci0JaW50IGxlbiA9IDAsIHJldDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBhZ2U7CisJaW50IHJldDsKIAogCWlmICghc3RhLT5jb25uZWN0ZWRfdGltZS5zZWMpCiAJCXJldHVybiAwOwogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7Ci0Jb3NfdGltZV9zdWIoJm5vdywgJnN0YS0+Y29ubmVjdGVkX3RpbWUsICZhZ2UpOworCW9zX3JlbHRpbWVfYWdlKCZzdGEtPmNvbm5lY3RlZF90aW1lLCAmYWdlKTsKIAotCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiArIGxlbiwgYnVmbGVuIC0gbGVuLCAiY29ubmVjdGVkX3RpbWU9JXVcbiIsCisJcmV0ID0gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJjb25uZWN0ZWRfdGltZT0ldVxuIiwKIAkJCSAgKHVuc2lnbmVkIGludCkgYWdlLnNlYyk7Ci0JaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbiAtIGxlbikKLQkJcmV0dXJuIGxlbjsKLQlsZW4gKz0gcmV0OworCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4pCisJCXJldHVybiAwOworCXJldHVybiByZXQ7Cit9CiAKLQlyZXR1cm4gbGVuOworCitzdGF0aWMgY29uc3QgY2hhciAqIHRpbWVvdXRfbmV4dF9zdHIoaW50IHZhbCkKK3sKKwlzd2l0Y2ggKHZhbCkgeworCWNhc2UgU1RBX05VTExGVU5DOgorCQlyZXR1cm4gIk5VTExGVU5DIFBPTEwiOworCWNhc2UgU1RBX0RJU0FTU09DOgorCQlyZXR1cm4gIkRJU0FTU09DIjsKKwljYXNlIFNUQV9ERUFVVEg6CisJCXJldHVybiAiREVBVVRIIjsKKwljYXNlIFNUQV9SRU1PVkU6CisJCXJldHVybiAiUkVNT1ZFIjsKKwljYXNlIFNUQV9ESVNBU1NPQ19GUk9NX0NMSToKKwkJcmV0dXJuICJESVNBU1NPQ19GUk9NX0NMSSI7CisJfQorCisJcmV0dXJuICI/IjsKIH0KIAogCkBAIC00NywyMiArODQsNDUgQEAKIAkJCQkgICAgICBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJCQkgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCiB7Ci0JaW50IGxlbiwgcmVzLCByZXQ7CisJaW50IGxlbiwgcmVzLCByZXQsIGk7CiAKLQlpZiAoc3RhID09IE5VTEwpIHsKLQkJcmV0ID0gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJGQUlMXG4iKTsKLQkJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbikKLQkJCXJldHVybiAwOwotCQlyZXR1cm4gcmV0OwotCX0KKwlpZiAoIXN0YSkKKwkJcmV0dXJuIDA7CiAKIAlsZW4gPSAwOwotCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiArIGxlbiwgYnVmbGVuIC0gbGVuLCBNQUNTVFIgIlxuIiwKKwlyZXQgPSBvc19zbnByaW50ZihidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbiwgTUFDU1RSICJcbmZsYWdzPSIsCiAJCQkgIE1BQzJTVFIoc3RhLT5hZGRyKSk7CiAJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbiAtIGxlbikKIAkJcmV0dXJuIGxlbjsKIAlsZW4gKz0gcmV0OwogCisJcmV0ID0gYXBfc3RhX2ZsYWdzX3R4dChzdGEtPmZsYWdzLCBidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbik7CisJaWYgKHJldCA8IDApCisJCXJldHVybiBsZW47CisJbGVuICs9IHJldDsKKworCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiArIGxlbiwgYnVmbGVuIC0gbGVuLCAiXG5haWQ9JWRcbmNhcGFiaWxpdHk9MHgleFxuIgorCQkJICAibGlzdGVuX2ludGVydmFsPSVkXG5zdXBwb3J0ZWRfcmF0ZXM9IiwKKwkJCSAgc3RhLT5haWQsIHN0YS0+Y2FwYWJpbGl0eSwgc3RhLT5saXN0ZW5faW50ZXJ2YWwpOworCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4gLSBsZW4pCisJCXJldHVybiBsZW47CisJbGVuICs9IHJldDsKKworCWZvciAoaSA9IDA7IGkgPCBzdGEtPnN1cHBvcnRlZF9yYXRlc19sZW47IGkrKykgeworCQlyZXQgPSBvc19zbnByaW50ZihidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbiwgIiUwMnglcyIsCisJCQkJICBzdGEtPnN1cHBvcnRlZF9yYXRlc1tpXSwKKwkJCQkgIGkgKyAxIDwgc3RhLT5zdXBwb3J0ZWRfcmF0ZXNfbGVuID8gIiAiIDogIiIpOworCQlpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gYnVmbGVuIC0gbGVuKQorCQkJcmV0dXJuIGxlbjsKKwkJbGVuICs9IHJldDsKKwl9CisKKwlyZXQgPSBvc19zbnByaW50ZihidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbiwgIlxudGltZW91dF9uZXh0PSVzXG4iLAorCQkJICB0aW1lb3V0X25leHRfc3RyKHN0YS0+dGltZW91dF9uZXh0KSk7CisJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbiAtIGxlbikKKwkJcmV0dXJuIGxlbjsKKwlsZW4gKz0gcmV0OworCiAJcmVzID0gaWVlZTgwMl8xMV9nZXRfbWliX3N0YShoYXBkLCBzdGEsIGJ1ZiArIGxlbiwgYnVmbGVuIC0gbGVuKTsKIAlpZiAocmVzID49IDApCiAJCWxlbiArPSByZXM7CkBAIC04MCw5ICsxNDAsOCBAQAogCWlmIChyZXMgPj0gMCkKIAkJbGVuICs9IHJlczsKIAotCXJlcyA9IGhvc3RhcGRfZ2V0X3N0YV9jb25uX3RpbWUoc3RhLCBidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbik7Ci0JaWYgKHJlcyA+PSAwKQotCQlsZW4gKz0gcmVzOworCWxlbiArPSBob3N0YXBkX2dldF9zdGFfdHhfcngoaGFwZCwgc3RhLCBidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbik7CisJbGVuICs9IGhvc3RhcGRfZ2V0X3N0YV9jb25uX3RpbWUoc3RhLCBidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbik7CiAKIAlyZXR1cm4gbGVuOwogfQpAQCAtMTAwLDYgKzE1OSw4IEBACiB7CiAJdTggYWRkcltFVEhfQUxFTl07CiAJaW50IHJldDsKKwljb25zdCBjaGFyICpwb3M7CisJc3RydWN0IHN0YV9pbmZvICpzdGE7CiAKIAlpZiAoaHdhZGRyX2F0b24odHh0YWRkciwgYWRkcikpIHsKIAkJcmV0ID0gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJGQUlMXG4iKTsKQEAgLTEwNyw4ICsxNjgsMjggQEAKIAkJCXJldHVybiAwOwogCQlyZXR1cm4gcmV0OwogCX0KLQlyZXR1cm4gaG9zdGFwZF9jdHJsX2lmYWNlX3N0YV9taWIoaGFwZCwgYXBfZ2V0X3N0YShoYXBkLCBhZGRyKSwKLQkJCQkJICBidWYsIGJ1Zmxlbik7CisKKwlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIGFkZHIpOworCWlmIChzdGEgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJcG9zID0gb3Nfc3RyY2hyKHR4dGFkZHIsICcgJyk7CisJaWYgKHBvcykgeworCQlwb3MrKzsKKworI2lmZGVmIEhPU1RBUERfRFVNUF9TVEFURQorCQlpZiAob3Nfc3RyY21wKHBvcywgImVhcG9sIikgPT0gMCkgeworCQkJaWYgKHN0YS0+ZWFwb2xfc20gPT0gTlVMTCkKKwkJCQlyZXR1cm4gLTE7CisJCQlyZXR1cm4gZWFwb2xfYXV0aF9kdW1wX3N0YXRlKHN0YS0+ZWFwb2xfc20sIGJ1ZiwKKwkJCQkJCSAgICAgYnVmbGVuKTsKKwkJfQorI2VuZGlmIC8qIEhPU1RBUERfRFVNUF9TVEFURSAqLworCisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gaG9zdGFwZF9jdHJsX2lmYWNlX3N0YV9taWIoaGFwZCwgc3RhLCBidWYsIGJ1Zmxlbik7CiB9CiAKIApAQCAtMTI1LDcgKzIwNiwxMSBAQAogCQlpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gYnVmbGVuKQogCQkJcmV0dXJuIDA7CiAJCXJldHVybiByZXQ7Ci0JfQkJCisJfQorCisJaWYgKCFzdGEtPm5leHQpCisJCXJldHVybiAwOworCiAJcmV0dXJuIGhvc3RhcGRfY3RybF9pZmFjZV9zdGFfbWliKGhhcGQsIHN0YS0+bmV4dCwgYnVmLCBidWZsZW4pOwogfQogCkBAIC0xNDUsMTEgKzIzMCwxMiBAQAogCWlmIChtZ210ID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAotCXdwYV9kYmcoaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiUDJQOiBEaXNjb25uZWN0IFNUQSAiIE1BQ1NUUgotCQkiIHdpdGggbWlub3IgcmVhc29uIGNvZGUgJXUgKHN0eXBlPSV1KSIsCi0JCU1BQzJTVFIoYWRkciksIG1pbm9yX3JlYXNvbl9jb2RlLCBzdHlwZSk7Ci0KIAltZ210LT5mcmFtZV9jb250cm9sID0gSUVFRTgwMjExX0ZDKFdMQU5fRkNfVFlQRV9NR01ULCBzdHlwZSk7CisJd3BhX2RiZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IERpc2Nvbm5lY3QgU1RBICIgTUFDU1RSCisJCSIgd2l0aCBtaW5vciByZWFzb24gY29kZSAldSAoc3R5cGU9JXUgKCVzKSkiLAorCQlNQUMyU1RSKGFkZHIpLCBtaW5vcl9yZWFzb25fY29kZSwgc3R5cGUsCisJCWZjMnN0cihtZ210LT5mcmFtZV9jb250cm9sKSk7CisKIAlvc19tZW1jcHkobWdtdC0+ZGEsIGFkZHIsIEVUSF9BTEVOKTsKIAlvc19tZW1jcHkobWdtdC0+c2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7CiAJb3NfbWVtY3B5KG1nbXQtPmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOwpAQCAtMTY1LDkgKzI1MSw4IEBACiAKIAkqcG9zKysgPSBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUM7CiAJKnBvcysrID0gNCArIDMgKyAxOwotCVdQQV9QVVRfQkUyNChwb3MsIE9VSV9XRkEpOwotCXBvcyArPSAzOwotCSpwb3MrKyA9IFAyUF9PVUlfVFlQRTsKKwlXUEFfUFVUX0JFMzIocG9zLCBQMlBfSUVfVkVORE9SX1RZUEUpOworCXBvcyArPSA0OwogCiAJKnBvcysrID0gUDJQX0FUVFJfTUlOT1JfUkVBU09OX0NPREU7CiAJV1BBX1BVVF9MRTE2KHBvcywgMSk7CkBAIC0xOTcsNiArMjgyLDEwIEBACiAJaWYgKGh3YWRkcl9hdG9uKHR4dGFkZHIsIGFkZHIpKQogCQlyZXR1cm4gLTE7CiAKKwlwb3MgPSBvc19zdHJzdHIodHh0YWRkciwgIiByZWFzb249Iik7CisJaWYgKHBvcykKKwkJcmVhc29uID0gYXRvaShwb3MgKyA4KTsKKwogCXBvcyA9IG9zX3N0cnN0cih0eHRhZGRyLCAiIHRlc3Q9Iik7CiAJaWYgKHBvcykgewogCQlzdHJ1Y3QgaWVlZTgwMjExX21nbXQgbWdtdDsKQEAgLTIxMSw4ICszMDAsNyBAQAogCQlvc19tZW1jcHkobWdtdC5kYSwgYWRkciwgRVRIX0FMRU4pOwogCQlvc19tZW1jcHkobWdtdC5zYSwgaGFwZC0+b3duX2FkZHIsIEVUSF9BTEVOKTsKIAkJb3NfbWVtY3B5KG1nbXQuYnNzaWQsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7Ci0JCW1nbXQudS5kZWF1dGgucmVhc29uX2NvZGUgPQotCQkJaG9zdF90b19sZTE2KFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOworCQltZ210LnUuZGVhdXRoLnJlYXNvbl9jb2RlID0gaG9zdF90b19sZTE2KHJlYXNvbik7CiAJCWlmIChoYXBkLT5kcml2ZXItPnNlbmRfZnJhbWUoaGFwZC0+ZHJ2X3ByaXYsICh1OCAqKSAmbWdtdCwKIAkJCQkJICAgICBJRUVFODAyMTFfSERSTEVOICsKIAkJCQkJICAgICBzaXplb2YobWdtdC51LmRlYXV0aCksCkBAIC0yMjksMTAgKzMxNyw2IEBACiAJfQogI2VuZGlmIC8qIENPTkZJR19QMlBfTUFOQUdFUiAqLwogCi0JcG9zID0gb3Nfc3Ryc3RyKHR4dGFkZHIsICIgcmVhc29uPSIpOwotCWlmIChwb3MpCi0JCXJlYXNvbiA9IGF0b2kocG9zICsgOCk7Ci0KIAlob3N0YXBkX2Rydl9zdGFfZGVhdXRoKGhhcGQsIGFkZHIsIHJlYXNvbik7CiAJc3RhID0gYXBfZ2V0X3N0YShoYXBkLCBhZGRyKTsKIAlpZiAoc3RhKQpAQCAtMjU4LDYgKzM0MiwxMCBAQAogCWlmIChod2FkZHJfYXRvbih0eHRhZGRyLCBhZGRyKSkKIAkJcmV0dXJuIC0xOwogCisJcG9zID0gb3Nfc3Ryc3RyKHR4dGFkZHIsICIgcmVhc29uPSIpOworCWlmIChwb3MpCisJCXJlYXNvbiA9IGF0b2kocG9zICsgOCk7CisKIAlwb3MgPSBvc19zdHJzdHIodHh0YWRkciwgIiB0ZXN0PSIpOwogCWlmIChwb3MpIHsKIAkJc3RydWN0IGllZWU4MDIxMV9tZ210IG1nbXQ7CkBAIC0yNzIsOCArMzYwLDcgQEAKIAkJb3NfbWVtY3B5KG1nbXQuZGEsIGFkZHIsIEVUSF9BTEVOKTsKIAkJb3NfbWVtY3B5KG1nbXQuc2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7CiAJCW9zX21lbWNweShtZ210LmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOwotCQltZ210LnUuZGlzYXNzb2MucmVhc29uX2NvZGUgPQotCQkJaG9zdF90b19sZTE2KFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOworCQltZ210LnUuZGlzYXNzb2MucmVhc29uX2NvZGUgPSBob3N0X3RvX2xlMTYocmVhc29uKTsKIAkJaWYgKGhhcGQtPmRyaXZlci0+c2VuZF9mcmFtZShoYXBkLT5kcnZfcHJpdiwgKHU4ICopICZtZ210LAogCQkJCQkgICAgIElFRUU4MDIxMV9IRFJMRU4gKwogCQkJCQkgICAgIHNpemVvZihtZ210LnUuZGVhdXRoKSwKQEAgLTI5MCwxMCArMzc3LDYgQEAKIAl9CiAjZW5kaWYgLyogQ09ORklHX1AyUF9NQU5BR0VSICovCiAKLQlwb3MgPSBvc19zdHJzdHIodHh0YWRkciwgIiByZWFzb249Iik7Ci0JaWYgKHBvcykKLQkJcmVhc29uID0gYXRvaShwb3MgKyA4KTsKLQogCWhvc3RhcGRfZHJ2X3N0YV9kaXNhc3NvYyhoYXBkLCBhZGRyLCByZWFzb24pOwogCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgYWRkcik7CiAJaWYgKHN0YSkKQEAgLTMwMywzICszODYsMTQ0IEBACiAKIAlyZXR1cm4gMDsKIH0KKworCitpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX3N0YXR1cyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjaGFyICpidWYsCisJCQkgICAgICBzaXplX3QgYnVmbGVuKQoreworCXN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSA9IGhhcGQtPmlmYWNlOworCWludCBsZW4gPSAwLCByZXQ7CisJc2l6ZV90IGk7CisKKwlyZXQgPSBvc19zbnByaW50ZihidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbiwKKwkJCSAgInN0YXRlPSVzXG4iCisJCQkgICJwaHk9JXNcbiIKKwkJCSAgImZyZXE9JWRcbiIKKwkJCSAgIm51bV9zdGFfbm9uX2VycD0lZFxuIgorCQkJICAibnVtX3N0YV9ub19zaG9ydF9zbG90X3RpbWU9JWRcbiIKKwkJCSAgIm51bV9zdGFfbm9fc2hvcnRfcHJlYW1ibGU9JWRcbiIKKwkJCSAgIm9sYmM9JWRcbiIKKwkJCSAgIm51bV9zdGFfaHRfbm9fZ2Y9JWRcbiIKKwkJCSAgIm51bV9zdGFfbm9faHQ9JWRcbiIKKwkJCSAgIm51bV9zdGFfaHRfMjBfbWh6PSVkXG4iCisJCQkgICJudW1fc3RhX2h0NDBfaW50b2xlcmFudD0lZFxuIgorCQkJICAib2xiY19odD0lZFxuIgorCQkJICAiaHRfb3BfbW9kZT0weCV4XG4iLAorCQkJICBob3N0YXBkX3N0YXRlX3RleHQoaWZhY2UtPnN0YXRlKSwKKwkJCSAgaWZhY2UtPnBoeSwKKwkJCSAgaWZhY2UtPmZyZXEsCisJCQkgIGlmYWNlLT5udW1fc3RhX25vbl9lcnAsCisJCQkgIGlmYWNlLT5udW1fc3RhX25vX3Nob3J0X3Nsb3RfdGltZSwKKwkJCSAgaWZhY2UtPm51bV9zdGFfbm9fc2hvcnRfcHJlYW1ibGUsCisJCQkgIGlmYWNlLT5vbGJjLAorCQkJICBpZmFjZS0+bnVtX3N0YV9odF9ub19nZiwKKwkJCSAgaWZhY2UtPm51bV9zdGFfbm9faHQsCisJCQkgIGlmYWNlLT5udW1fc3RhX2h0XzIwbWh6LAorCQkJICBpZmFjZS0+bnVtX3N0YV9odDQwX2ludG9sZXJhbnQsCisJCQkgIGlmYWNlLT5vbGJjX2h0LAorCQkJICBpZmFjZS0+aHRfb3BfbW9kZSk7CisJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbiAtIGxlbikKKwkJcmV0dXJuIGxlbjsKKwlsZW4gKz0gcmV0OworCisJaWYgKCFpZmFjZS0+Y2FjX3N0YXJ0ZWQgfHwgIWlmYWNlLT5kZnNfY2FjX21zKSB7CisJCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiArIGxlbiwgYnVmbGVuIC0gbGVuLAorCQkJCSAgImNhY190aW1lX3NlY29uZHM9JWRcbiIKKwkJCQkgICJjYWNfdGltZV9sZWZ0X3NlY29uZHM9Ti9BXG4iLAorCQkJCSAgaWZhY2UtPmRmc19jYWNfbXMgLyAxMDAwKTsKKwl9IGVsc2UgeworCQkvKiBDQUMgc3RhcnRlZCBhbmQgQ0FDIHRpbWUgc2V0IC0gY2FsY3VsYXRlIHJlbWFpbmluZyB0aW1lICovCisJCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKKwkJdW5zaWduZWQgaW50IGxlZnRfdGltZTsKKworCQlvc19yZWx0aW1lX2FnZSgmaWZhY2UtPmRmc19jYWNfc3RhcnQsICZub3cpOworCQlsZWZ0X3RpbWUgPSBpZmFjZS0+ZGZzX2NhY19tcyAvIDEwMDAgLSBub3cuc2VjOworCQlyZXQgPSBvc19zbnByaW50ZihidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbiwKKwkJCQkgICJjYWNfdGltZV9zZWNvbmRzPSV1XG4iCisJCQkJICAiY2FjX3RpbWVfbGVmdF9zZWNvbmRzPSV1XG4iLAorCQkJCSAgaWZhY2UtPmRmc19jYWNfbXMgLyAxMDAwLAorCQkJCSAgbGVmdF90aW1lKTsKKwl9CisJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbiAtIGxlbikKKwkJcmV0dXJuIGxlbjsKKwlsZW4gKz0gcmV0OworCisJcmV0ID0gb3Nfc25wcmludGYoYnVmICsgbGVuLCBidWZsZW4gLSBsZW4sCisJCQkgICJjaGFubmVsPSV1XG4iCisJCQkgICJzZWNvbmRhcnlfY2hhbm5lbD0lZFxuIgorCQkJICAiaWVlZTgwMjExbj0lZFxuIgorCQkJICAiaWVlZTgwMjExYWM9JWRcbiIKKwkJCSAgInZodF9vcGVyX2Nod2lkdGg9JWRcbiIKKwkJCSAgInZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHg9JWRcbiIKKwkJCSAgInZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHg9JWRcbiIsCisJCQkgIGlmYWNlLT5jb25mLT5jaGFubmVsLAorCQkJICBpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwsCisJCQkgIGlmYWNlLT5jb25mLT5pZWVlODAyMTFuLAorCQkJICBpZmFjZS0+Y29uZi0+aWVlZTgwMjExYWMsCisJCQkgIGlmYWNlLT5jb25mLT52aHRfb3Blcl9jaHdpZHRoLAorCQkJICBpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCwKKwkJCSAgaWZhY2UtPmNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHgpOworCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4gLSBsZW4pCisJCXJldHVybiBsZW47CisJbGVuICs9IHJldDsKKworCWZvciAoaSA9IDA7IGkgPCBpZmFjZS0+bnVtX2JzczsgaSsrKSB7CisJCXN0cnVjdCBob3N0YXBkX2RhdGEgKmJzcyA9IGlmYWNlLT5ic3NbaV07CisJCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiArIGxlbiwgYnVmbGVuIC0gbGVuLAorCQkJCSAgImJzc1slZF09JXNcbiIKKwkJCQkgICJic3NpZFslZF09IiBNQUNTVFIgIlxuIgorCQkJCSAgInNzaWRbJWRdPSVzXG4iCisJCQkJICAibnVtX3N0YVslZF09JWRcbiIsCisJCQkJICAoaW50KSBpLCBic3MtPmNvbmYtPmlmYWNlLAorCQkJCSAgKGludCkgaSwgTUFDMlNUUihic3MtPm93bl9hZGRyKSwKKwkJCQkgIChpbnQpIGksCisJCQkJICB3cGFfc3NpZF90eHQoYnNzLT5jb25mLT5zc2lkLnNzaWQsCisJCQkJCSAgICAgICBic3MtPmNvbmYtPnNzaWQuc3NpZF9sZW4pLAorCQkJCSAgKGludCkgaSwgYnNzLT5udW1fc3RhKTsKKwkJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbiAtIGxlbikKKwkJCXJldHVybiBsZW47CisJCWxlbiArPSByZXQ7CisJfQorCisJcmV0dXJuIGxlbjsKK30KKworCitpbnQgaG9zdGFwZF9wYXJzZV9jc2Ffc2V0dGluZ3MoY29uc3QgY2hhciAqcG9zLAorCQkJICAgICAgIHN0cnVjdCBjc2Ffc2V0dGluZ3MgKnNldHRpbmdzKQoreworCWNoYXIgKmVuZDsKKworCW9zX21lbXNldChzZXR0aW5ncywgMCwgc2l6ZW9mKCpzZXR0aW5ncykpOworCXNldHRpbmdzLT5jc19jb3VudCA9IHN0cnRvbChwb3MsICZlbmQsIDEwKTsKKwlpZiAocG9zID09IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImNoYW5zd2l0Y2g6IGludmFsaWQgY3NfY291bnQgcHJvdmlkZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXNldHRpbmdzLT5mcmVxX3BhcmFtcy5mcmVxID0gYXRvaShlbmQpOworCWlmIChzZXR0aW5ncy0+ZnJlcV9wYXJhbXMuZnJlcSA9PSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiY2hhbnN3aXRjaDogaW52YWxpZCBmcmVxIHByb3ZpZGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKyNkZWZpbmUgU0VUX0NTQV9TRVRUSU5HKHN0cikgXAorCWRvIHsgXAorCQljb25zdCBjaGFyICpwb3MyID0gb3Nfc3Ryc3RyKHBvcywgIiAiICNzdHIgIj0iKTsgXAorCQlpZiAocG9zMikgeyBcCisJCQlwb3MyICs9IHNpemVvZigiICIgI3N0ciAiPSIpIC0gMTsgXAorCQkJc2V0dGluZ3MtPmZyZXFfcGFyYW1zLnN0ciA9IGF0b2kocG9zMik7IFwKKwkJfSBcCisJfSB3aGlsZSAoMCkKKworCVNFVF9DU0FfU0VUVElORyhjZW50ZXJfZnJlcTEpOworCVNFVF9DU0FfU0VUVElORyhjZW50ZXJfZnJlcTIpOworCVNFVF9DU0FfU0VUVElORyhiYW5kd2lkdGgpOworCVNFVF9DU0FfU0VUVElORyhzZWNfY2hhbm5lbF9vZmZzZXQpOworCXNldHRpbmdzLT5mcmVxX3BhcmFtcy5odF9lbmFibGVkID0gISFvc19zdHJzdHIocG9zLCAiIGh0Iik7CisJc2V0dGluZ3MtPmZyZXFfcGFyYW1zLnZodF9lbmFibGVkID0gISFvc19zdHJzdHIocG9zLCAiIHZodCIpOworCXNldHRpbmdzLT5ibG9ja190eCA9ICEhb3Nfc3Ryc3RyKHBvcywgIiBibG9ja3R4Iik7CisjdW5kZWYgU0VUX0NTQV9TRVRUSU5HCisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL3NyYy9hcC9jdHJsX2lmYWNlX2FwLmggYi9zcmMvYXAvY3RybF9pZmFjZV9hcC5oCmluZGV4IGU4M2Y4OTQuLmVlNThiNGMgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9jdHJsX2lmYWNlX2FwLmgKKysrIGIvc3JjL2FwL2N0cmxfaWZhY2VfYXAuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBDb250cm9sIGludGVyZmFjZSBmb3Igc2hhcmVkIEFQIGNvbW1hbmRzCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDEzLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xOSw1ICsxOSwxMCBAQAogCQkJCSAgICAgIGNvbnN0IGNoYXIgKnR4dGFkZHIpOwogaW50IGhvc3RhcGRfY3RybF9pZmFjZV9kaXNhc3NvY2lhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKIAkJCQkgICAgY29uc3QgY2hhciAqdHh0YWRkcik7CitpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX3N0YXR1cyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjaGFyICpidWYsCisJCQkgICAgICBzaXplX3QgYnVmbGVuKTsKK2ludCBob3N0YXBkX3BhcnNlX2NzYV9zZXR0aW5ncyhjb25zdCBjaGFyICpwb3MsCisJCQkgICAgICAgc3RydWN0IGNzYV9zZXR0aW5ncyAqc2V0dGluZ3MpOworCiAKICNlbmRpZiAvKiBDVFJMX0lGQUNFX0FQX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC9kZnMuYyBiL3NyYy9hcC9kZnMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yMDQxOWYzCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL2FwL2Rmcy5jCkBAIC0wLDAgKzEsOTQ3IEBACisvKgorICogREZTIC0gRHluYW1pYyBGcmVxdWVuY3kgU2VsZWN0aW9uCisgKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAxMywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKyNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCisjaW5jbHVkZSAiY29tbW9uL3dwYV9jdHJsLmgiCisjaW5jbHVkZSAiaG9zdGFwZC5oIgorI2luY2x1ZGUgImFwX2Rydl9vcHMuaCIKKyNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgorI2luY2x1ZGUgImRmcy5oIgorCisKK3N0YXRpYyBpbnQgZGZzX2dldF91c2VkX25fY2hhbnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQoreworCWludCBuX2NoYW5zID0gMTsKKworCWlmIChpZmFjZS0+Y29uZi0+aWVlZTgwMjExbiAmJiBpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwpCisJCW5fY2hhbnMgPSAyOworCisJaWYgKGlmYWNlLT5jb25mLT5pZWVlODAyMTFhYykgeworCQlzd2l0Y2ggKGlmYWNlLT5jb25mLT52aHRfb3Blcl9jaHdpZHRoKSB7CisJCWNhc2UgVkhUX0NIQU5XSURUSF9VU0VfSFQ6CisJCQlicmVhazsKKwkJY2FzZSBWSFRfQ0hBTldJRFRIXzgwTUhaOgorCQkJbl9jaGFucyA9IDQ7CisJCQlicmVhazsKKwkJY2FzZSBWSFRfQ0hBTldJRFRIXzE2ME1IWjoKKwkJCW5fY2hhbnMgPSA4OworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlicmVhazsKKwkJfQorCX0KKworCXJldHVybiBuX2NoYW5zOworfQorCisKK3N0YXRpYyBpbnQgZGZzX2NoYW5uZWxfYXZhaWxhYmxlKHN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbiwKKwkJCQkgaW50IHNraXBfcmFkYXIpCit7CisJLyoKKwkgKiBXaGVuIHJhZGFyIGRldGVjdGlvbiBoYXBwZW5zLCBDU0EgaXMgcGVyZm9ybWVkLiBIb3dldmVyLCB0aGVyZSdzIG5vCisJICogdGltZSBmb3IgQ0FDLCBzbyByYWRhciBjaGFubmVscyBtdXN0IGJlIHNraXBwZWQgd2hlbiBmaW5kaW5nIGEgbmV3CisJICogY2hhbm5lbCBmb3IgQ1NBLCB1bmxlc3MgdGhleSBhcmUgYXZhaWxhYmxlIGZvciBpbW1lZGlhdGUgdXNlLgorCSAqLworCWlmIChza2lwX3JhZGFyICYmIChjaGFuLT5mbGFnICYgSE9TVEFQRF9DSEFOX1JBREFSKSAmJgorCSAgICAoKGNoYW4tPmZsYWcgJiBIT1NUQVBEX0NIQU5fREZTX01BU0spICE9CisJICAgICBIT1NUQVBEX0NIQU5fREZTX0FWQUlMQUJMRSkpCisJCXJldHVybiAwOworCisJaWYgKGNoYW4tPmZsYWcgJiBIT1NUQVBEX0NIQU5fRElTQUJMRUQpCisJCXJldHVybiAwOworCWlmICgoY2hhbi0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9SQURBUikgJiYKKwkgICAgKChjaGFuLT5mbGFnICYgSE9TVEFQRF9DSEFOX0RGU19NQVNLKSA9PQorCSAgICAgSE9TVEFQRF9DSEFOX0RGU19VTkFWQUlMQUJMRSkpCisJCXJldHVybiAwOworCXJldHVybiAxOworfQorCisKK3N0YXRpYyBpbnQgZGZzX2lzX2NoYW5fYWxsb3dlZChzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4sIGludCBuX2NoYW5zKQoreworCS8qCisJICogVGhlIHRhYmxlcyBjb250YWluIGZpcnN0IHZhbGlkIGNoYW5uZWwgbnVtYmVyIGJhc2VkIG9uIGNoYW5uZWwgd2lkdGguCisJICogV2Ugd2lsbCBhbHNvIGNob29zZSB0aGlzIGZpcnN0IGNoYW5uZWwgYXMgdGhlIGNvbnRyb2wgb25lLgorCSAqLworCWludCBhbGxvd2VkXzQwW10gPSB7IDM2LCA0NCwgNTIsIDYwLCAxMDAsIDEwOCwgMTE2LCAxMjQsIDEzMiwgMTQ5LCAxNTcsCisJCQkgICAgIDE4NCwgMTkyIH07CisJLyoKKwkgKiBWSFQ4MCwgdmFsaWQgY2hhbm5lbHMgYmFzZWQgb24gY2VudGVyIGZyZXF1ZW5jeToKKwkgKiA0MiwgNTgsIDEwNiwgMTIyLCAxMzgsIDE1NQorCSAqLworCWludCBhbGxvd2VkXzgwW10gPSB7IDM2LCA1MiwgMTAwLCAxMTYsIDEzMiwgMTQ5IH07CisJLyoKKwkgKiBWSFQxNjAgdmFsaWQgY2hhbm5lbHMgYmFzZWQgb24gY2VudGVyIGZyZXF1ZW5jeToKKwkgKiA1MCwgMTE0CisJICovCisJaW50IGFsbG93ZWRfMTYwW10gPSB7IDM2LCAxMDAgfTsKKwlpbnQgKmFsbG93ZWQgPSBhbGxvd2VkXzQwOworCXVuc2lnbmVkIGludCBpLCBhbGxvd2VkX25vID0gMDsKKworCXN3aXRjaCAobl9jaGFucykgeworCWNhc2UgMjoKKwkJYWxsb3dlZCA9IGFsbG93ZWRfNDA7CisJCWFsbG93ZWRfbm8gPSBBUlJBWV9TSVpFKGFsbG93ZWRfNDApOworCQlicmVhazsKKwljYXNlIDQ6CisJCWFsbG93ZWQgPSBhbGxvd2VkXzgwOworCQlhbGxvd2VkX25vID0gQVJSQVlfU0laRShhbGxvd2VkXzgwKTsKKwkJYnJlYWs7CisJY2FzZSA4OgorCQlhbGxvd2VkID0gYWxsb3dlZF8xNjA7CisJCWFsbG93ZWRfbm8gPSBBUlJBWV9TSVpFKGFsbG93ZWRfMTYwKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVbmtub3duIHdpZHRoIGZvciAlZCBjaGFubmVscyIsIG5fY2hhbnMpOworCQlicmVhazsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgYWxsb3dlZF9ubzsgaSsrKSB7CisJCWlmIChjaGFuLT5jaGFuID09IGFsbG93ZWRbaV0pCisJCQlyZXR1cm4gMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IGRmc19jaGFuX3JhbmdlX2F2YWlsYWJsZShzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZSwKKwkJCQkgICAgaW50IGZpcnN0X2NoYW5faWR4LCBpbnQgbnVtX2NoYW5zLAorCQkJCSAgICBpbnQgc2tpcF9yYWRhcikKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmZpcnN0X2NoYW4sICpjaGFuOworCWludCBpOworCisJaWYgKGZpcnN0X2NoYW5faWR4ICsgbnVtX2NoYW5zID49IG1vZGUtPm51bV9jaGFubmVscykKKwkJcmV0dXJuIDA7CisKKwlmaXJzdF9jaGFuID0gJm1vZGUtPmNoYW5uZWxzW2ZpcnN0X2NoYW5faWR4XTsKKworCWZvciAoaSA9IDA7IGkgPCBudW1fY2hhbnM7IGkrKykgeworCQljaGFuID0gJm1vZGUtPmNoYW5uZWxzW2ZpcnN0X2NoYW5faWR4ICsgaV07CisKKwkJaWYgKGZpcnN0X2NoYW4tPmZyZXEgKyBpICogMjAgIT0gY2hhbi0+ZnJlcSkKKwkJCXJldHVybiAwOworCisJCWlmICghZGZzX2NoYW5uZWxfYXZhaWxhYmxlKGNoYW4sIHNraXBfcmFkYXIpKQorCQkJcmV0dXJuIDA7CisJfQorCisJcmV0dXJuIDE7Cit9CisKKworc3RhdGljIGludCBpc19pbl9jaGFubGlzdChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsCisJCQkgIHN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbikKK3sKKwlpbnQgKmVudHJ5OworCisJaWYgKCFpZmFjZS0+Y29uZi0+Y2hhbmxpc3QpCisJCXJldHVybiAxOworCisJZm9yIChlbnRyeSA9IGlmYWNlLT5jb25mLT5jaGFubGlzdDsgKmVudHJ5ICE9IC0xOyBlbnRyeSsrKSB7CisJCWlmICgqZW50cnkgPT0gY2hhbi0+Y2hhbikKKwkJCXJldHVybiAxOworCX0KKwlyZXR1cm4gMDsKK30KKworCisvKgorICogVGhlIGZ1bmN0aW9uIGFzc3VtZXMgSFQ0MCsgb3BlcmF0aW9uLgorICogTWFrZSBzdXJlIHRvIGFkanVzdCB0aGUgZm9sbG93aW5nIHZhcmlhYmxlcyBhZnRlciBjYWxsaW5nIHRoaXM6CisgKiAgLSBoYXBkLT5zZWNvbmRhcnlfY2hhbm5lbAorICogIC0gaGFwZC0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeAorICogIC0gaGFwZC0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeAorICovCitzdGF0aWMgaW50IGRmc19maW5kX2NoYW5uZWwoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAorCQkJICAgIHN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqKnJldF9jaGFuLAorCQkJICAgIGludCBpZHgsIGludCBza2lwX3JhZGFyKQoreworCXN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlOworCXN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbjsKKwlpbnQgaSwgY2hhbm5lbF9pZHggPSAwLCBuX2NoYW5zOworCisJbW9kZSA9IGlmYWNlLT5jdXJyZW50X21vZGU7CisJbl9jaGFucyA9IGRmc19nZXRfdXNlZF9uX2NoYW5zKGlmYWNlKTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiREZTIG5ldyBjaGFuIGNoZWNraW5nICVkIGNoYW5uZWxzIiwgbl9jaGFucyk7CisJZm9yIChpID0gMDsgaSA8IG1vZGUtPm51bV9jaGFubmVsczsgaSsrKSB7CisJCWNoYW4gPSAmbW9kZS0+Y2hhbm5lbHNbaV07CisKKwkJLyogU2tpcCBIVDQwL1ZIVCBpbmNvbXBhdGlibGUgY2hhbm5lbHMgKi8KKwkJaWYgKGlmYWNlLT5jb25mLT5pZWVlODAyMTFuICYmCisJCSAgICBpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgJiYKKwkJICAgICFkZnNfaXNfY2hhbl9hbGxvd2VkKGNoYW4sIG5fY2hhbnMpKQorCQkJY29udGludWU7CisKKwkJLyogU2tpcCBpbmNvbXBhdGlibGUgY2hhbmRlZnMgKi8KKwkJaWYgKCFkZnNfY2hhbl9yYW5nZV9hdmFpbGFibGUobW9kZSwgaSwgbl9jaGFucywgc2tpcF9yYWRhcikpCisJCQljb250aW51ZTsKKworCQlpZiAoIWlzX2luX2NoYW5saXN0KGlmYWNlLCBjaGFuKSkKKwkJCWNvbnRpbnVlOworCisJCWlmIChyZXRfY2hhbiAmJiBpZHggPT0gY2hhbm5lbF9pZHgpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU2VsZWN0ZWQgY2guICMlZCIsIGNoYW4tPmNoYW4pOworCQkJKnJldF9jaGFuID0gY2hhbjsKKwkJCXJldHVybiBpZHg7CisJCX0KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBZGRpbmcgY2hhbm5lbDogJWQiLCBjaGFuLT5jaGFuKTsKKwkJY2hhbm5lbF9pZHgrKzsKKwl9CisJcmV0dXJuIGNoYW5uZWxfaWR4OworfQorCisKK3N0YXRpYyB2b2lkIGRmc19hZGp1c3Rfdmh0X2NlbnRlcl9mcmVxKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwKKwkJCQkgICAgICAgc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICpjaGFuLAorCQkJCSAgICAgICBpbnQgc2Vjb25kYXJ5X2NoYW5uZWwsCisJCQkJICAgICAgIHU4ICp2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4LAorCQkJCSAgICAgICB1OCAqdmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCkKK3sKKwlpZiAoIWlmYWNlLT5jb25mLT5pZWVlODAyMTFhYykKKwkJcmV0dXJuOworCisJaWYgKCFjaGFuKQorCQlyZXR1cm47CisKKwkqdmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCA9IDA7CisKKwlzd2l0Y2ggKGlmYWNlLT5jb25mLT52aHRfb3Blcl9jaHdpZHRoKSB7CisJY2FzZSBWSFRfQ0hBTldJRFRIX1VTRV9IVDoKKwkJaWYgKHNlY29uZGFyeV9jaGFubmVsID09IDEpCisJCQkqdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9IGNoYW4tPmNoYW4gKyAyOworCQllbHNlIGlmIChzZWNvbmRhcnlfY2hhbm5lbCA9PSAtMSkKKwkJCSp2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0gY2hhbi0+Y2hhbiAtIDI7CisJCWVsc2UKKwkJCSp2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0gY2hhbi0+Y2hhbjsKKwkJYnJlYWs7CisJY2FzZSBWSFRfQ0hBTldJRFRIXzgwTUhaOgorCQkqdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9IGNoYW4tPmNoYW4gKyA2OworCQlicmVhazsKKwljYXNlIFZIVF9DSEFOV0lEVEhfMTYwTUhaOgorCQkqdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9IGNoYW4tPmNoYW4gKyAxNDsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkRGUyBvbmx5IFZIVDIwLzQwLzgwLzE2MCBpcyBzdXBwb3J0ZWQgbm93Iik7CisJCSp2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0gMDsKKwkJYnJlYWs7CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJERlMgYWRqdXN0aW5nIFZIVCBjZW50ZXIgZnJlcXVlbmN5OiAlZCwgJWQiLAorCQkgICAqdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCwKKwkJICAgKnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHgpOworfQorCisKKy8qIFJldHVybiBzdGFydCBjaGFubmVsIGlkeCB3ZSB3aWxsIHVzZSBmb3IgbW9kZS0+Y2hhbm5lbHNbaWR4XSAqLworc3RhdGljIGludCBkZnNfZ2V0X3N0YXJ0X2NoYW5faWR4KHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZTsKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW47CisJaW50IGNoYW5uZWxfbm8gPSBpZmFjZS0+Y29uZi0+Y2hhbm5lbDsKKwlpbnQgcmVzID0gLTEsIGk7CisKKwkvKiBIVDQwLSAqLworCWlmIChpZmFjZS0+Y29uZi0+aWVlZTgwMjExbiAmJiBpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPT0gLTEpCisJCWNoYW5uZWxfbm8gLT0gNDsKKworCS8qIFZIVCAqLworCWlmIChpZmFjZS0+Y29uZi0+aWVlZTgwMjExYWMpIHsKKwkJc3dpdGNoIChpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2h3aWR0aCkgeworCQljYXNlIFZIVF9DSEFOV0lEVEhfVVNFX0hUOgorCQkJYnJlYWs7CisJCWNhc2UgVkhUX0NIQU5XSURUSF84ME1IWjoKKwkJCWNoYW5uZWxfbm8gPQorCQkJCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4IC0gNjsKKwkJCWJyZWFrOworCQljYXNlIFZIVF9DSEFOV0lEVEhfMTYwTUhaOgorCQkJY2hhbm5lbF9ubyA9CisJCQkJaWZhY2UtPmNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHggLSAxNDsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJd3BhX3ByaW50ZihNU0dfSU5GTywKKwkJCQkgICAiREZTIG9ubHkgVkhUMjAvNDAvODAvMTYwIGlzIHN1cHBvcnRlZCBub3ciKTsKKwkJCWNoYW5uZWxfbm8gPSAtMTsKKwkJCWJyZWFrOworCQl9CisJfQorCisJLyogR2V0IGlkeCAqLworCW1vZGUgPSBpZmFjZS0+Y3VycmVudF9tb2RlOworCWZvciAoaSA9IDA7IGkgPCBtb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgeworCQljaGFuID0gJm1vZGUtPmNoYW5uZWxzW2ldOworCQlpZiAoY2hhbi0+Y2hhbiA9PSBjaGFubmVsX25vKSB7CisJCQlyZXMgPSBpOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwlpZiAocmVzID09IC0xKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJICAgIkRGUyBjaGFuX2lkeCBzZWVtcyB3cm9uZzsgbnVtLWNoOiAlZCBjaC1ubzogJWQgY29uZi1jaC1ubzogJWQgMTFuOiAlZCBzZWMtY2g6ICVkIHZodC1vcGVyLXdpZHRoOiAlZCIsCisJCQkgICBtb2RlLT5udW1fY2hhbm5lbHMsIGNoYW5uZWxfbm8sIGlmYWNlLT5jb25mLT5jaGFubmVsLAorCQkJICAgaWZhY2UtPmNvbmYtPmllZWU4MDIxMW4sCisJCQkgICBpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwsCisJCQkgICBpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2h3aWR0aCk7CisKKwkJZm9yIChpID0gMDsgaSA8IG1vZGUtPm51bV9jaGFubmVsczsgaSsrKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkF2YWlsYWJsZSBjaGFubmVsOiAlZCIsCisJCQkJICAgbW9kZS0+Y2hhbm5lbHNbaV0uY2hhbik7CisJCX0KKwl9CisKKwlyZXR1cm4gcmVzOworfQorCisKKy8qIEF0IGxlYXN0IG9uZSBjaGFubmVsIGhhdmUgcmFkYXIgZmxhZyAqLworc3RhdGljIGludCBkZnNfY2hlY2tfY2hhbnNfcmFkYXIoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAorCQkJCSBpbnQgc3RhcnRfY2hhbl9pZHgsIGludCBuX2NoYW5zKQoreworCXN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbm5lbDsKKwlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZTsKKwlpbnQgaSwgcmVzID0gMDsKKworCW1vZGUgPSBpZmFjZS0+Y3VycmVudF9tb2RlOworCisJZm9yIChpID0gMDsgaSA8IG5fY2hhbnM7IGkrKykgeworCQljaGFubmVsID0gJm1vZGUtPmNoYW5uZWxzW3N0YXJ0X2NoYW5faWR4ICsgaV07CisJCWlmIChjaGFubmVsLT5mbGFnICYgSE9TVEFQRF9DSEFOX1JBREFSKQorCQkJcmVzKys7CisJfQorCisJcmV0dXJuIHJlczsKK30KKworCisvKiBBbGwgY2hhbm5lbHMgYXZhaWxhYmxlICovCitzdGF0aWMgaW50IGRmc19jaGVja19jaGFuc19hdmFpbGFibGUoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAorCQkJCSAgICAgaW50IHN0YXJ0X2NoYW5faWR4LCBpbnQgbl9jaGFucykKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW5uZWw7CisJc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGU7CisJaW50IGk7CisKKwltb2RlID0gaWZhY2UtPmN1cnJlbnRfbW9kZTsKKworCWZvciAoaSA9IDA7IGkgPCBuX2NoYW5zOyBpKyspIHsKKwkJY2hhbm5lbCA9ICZtb2RlLT5jaGFubmVsc1tzdGFydF9jaGFuX2lkeCArIGldOworCisJCWlmIChjaGFubmVsLT5mbGFnICYgSE9TVEFQRF9DSEFOX0RJU0FCTEVEKQorCQkJYnJlYWs7CisKKwkJaWYgKCEoY2hhbm5lbC0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9SQURBUikpCisJCQljb250aW51ZTsKKworCQlpZiAoKGNoYW5uZWwtPmZsYWcgJiBIT1NUQVBEX0NIQU5fREZTX01BU0spICE9CisJCSAgICBIT1NUQVBEX0NIQU5fREZTX0FWQUlMQUJMRSkKKwkJCWJyZWFrOworCX0KKworCXJldHVybiBpID09IG5fY2hhbnM7Cit9CisKKworLyogQXQgbGVhc3Qgb25lIGNoYW5uZWwgdW5hdmFpbGFibGUgKi8KK3N0YXRpYyBpbnQgZGZzX2NoZWNrX2NoYW5zX3VuYXZhaWxhYmxlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwKKwkJCQkgICAgICAgaW50IHN0YXJ0X2NoYW5faWR4LAorCQkJCSAgICAgICBpbnQgbl9jaGFucykKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW5uZWw7CisJc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGU7CisJaW50IGksIHJlcyA9IDA7CisKKwltb2RlID0gaWZhY2UtPmN1cnJlbnRfbW9kZTsKKworCWZvciAoaSA9IDA7IGkgPCBuX2NoYW5zOyBpKyspIHsKKwkJY2hhbm5lbCA9ICZtb2RlLT5jaGFubmVsc1tzdGFydF9jaGFuX2lkeCArIGldOworCQlpZiAoY2hhbm5lbC0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKKwkJCXJlcysrOworCQlpZiAoKGNoYW5uZWwtPmZsYWcgJiBIT1NUQVBEX0NIQU5fREZTX01BU0spID09CisJCSAgICBIT1NUQVBEX0NIQU5fREZTX1VOQVZBSUxBQkxFKQorCQkJcmVzKys7CisJfQorCisJcmV0dXJuIHJlczsKK30KKworCitzdGF0aWMgc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICoKK2Rmc19nZXRfdmFsaWRfY2hhbm5lbChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsCisJCSAgICAgIGludCAqc2Vjb25kYXJ5X2NoYW5uZWwsCisJCSAgICAgIHU4ICp2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4LAorCQkgICAgICB1OCAqdmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCwKKwkJICAgICAgaW50IHNraXBfcmFkYXIpCit7CisJc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGU7CisJc3RydWN0IGhvc3RhcGRfY2hhbm5lbF9kYXRhICpjaGFuID0gTlVMTDsKKwlpbnQgbnVtX2F2YWlsYWJsZV9jaGFuZGVmczsKKwlpbnQgY2hhbl9pZHg7CisJdTMyIF9yYW5kOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJERlM6IFNlbGVjdGluZyByYW5kb20gY2hhbm5lbCIpOworCSpzZWNvbmRhcnlfY2hhbm5lbCA9IDA7CisJKnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHggPSAwOworCSp2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4ID0gMDsKKworCWlmIChpZmFjZS0+Y3VycmVudF9tb2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJbW9kZSA9IGlmYWNlLT5jdXJyZW50X21vZGU7CisJaWYgKG1vZGUtPm1vZGUgIT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEpCisJCXJldHVybiBOVUxMOworCisJLyogR2V0IHRoZSBjb3VudCBmaXJzdCAqLworCW51bV9hdmFpbGFibGVfY2hhbmRlZnMgPSBkZnNfZmluZF9jaGFubmVsKGlmYWNlLCBOVUxMLCAwLCBza2lwX3JhZGFyKTsKKwlpZiAobnVtX2F2YWlsYWJsZV9jaGFuZGVmcyA9PSAwKQorCQlyZXR1cm4gTlVMTDsKKworCW9zX2dldF9yYW5kb20oKHU4ICopICZfcmFuZCwgc2l6ZW9mKF9yYW5kKSk7CisJY2hhbl9pZHggPSBfcmFuZCAlIG51bV9hdmFpbGFibGVfY2hhbmRlZnM7CisJZGZzX2ZpbmRfY2hhbm5lbChpZmFjZSwgJmNoYW4sIGNoYW5faWR4LCBza2lwX3JhZGFyKTsKKworCS8qIGRmc19maW5kX2NoYW5uZWwoKSBjYWxjdWxhdGlvbnMgYXNzdW1lIEhUNDArICovCisJaWYgKGlmYWNlLT5jb25mLT5zZWNvbmRhcnlfY2hhbm5lbCkKKwkJKnNlY29uZGFyeV9jaGFubmVsID0gMTsKKwllbHNlCisJCSpzZWNvbmRhcnlfY2hhbm5lbCA9IDA7CisKKwlkZnNfYWRqdXN0X3ZodF9jZW50ZXJfZnJlcShpZmFjZSwgY2hhbiwKKwkJCQkgICAqc2Vjb25kYXJ5X2NoYW5uZWwsCisJCQkJICAgdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCwKKwkJCQkgICB2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4KTsKKworCXJldHVybiBjaGFuOworfQorCisKK3N0YXRpYyBpbnQgc2V0X2Rmc19zdGF0ZV9mcmVxKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgaW50IGZyZXEsIHUzMiBzdGF0ZSkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZTsKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4gPSBOVUxMOworCWludCBpOworCisJbW9kZSA9IGlmYWNlLT5jdXJyZW50X21vZGU7CisJaWYgKG1vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgInNldF9kZnNfc3RhdGUgMHglWCBmb3IgJWQgTUh6Iiwgc3RhdGUsIGZyZXEpOworCWZvciAoaSA9IDA7IGkgPCBpZmFjZS0+Y3VycmVudF9tb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgeworCQljaGFuID0gJmlmYWNlLT5jdXJyZW50X21vZGUtPmNoYW5uZWxzW2ldOworCQlpZiAoY2hhbi0+ZnJlcSA9PSBmcmVxKSB7CisJCQlpZiAoY2hhbi0+ZmxhZyAmIEhPU1RBUERfQ0hBTl9SQURBUikgeworCQkJCWNoYW4tPmZsYWcgJj0gfkhPU1RBUERfQ0hBTl9ERlNfTUFTSzsKKwkJCQljaGFuLT5mbGFnIHw9IHN0YXRlOworCQkJCXJldHVybiAxOyAvKiBDaGFubmVsIGZvdW5kICovCisJCQl9CisJCX0KKwl9CisJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkNhbid0IHNldCBERlMgc3RhdGUgZm9yIGZyZXEgJWQgTUh6IiwgZnJlcSk7CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBzZXRfZGZzX3N0YXRlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgaW50IGZyZXEsIGludCBodF9lbmFibGVkLAorCQkJIGludCBjaGFuX29mZnNldCwgaW50IGNoYW5fd2lkdGgsIGludCBjZjEsCisJCQkgaW50IGNmMiwgdTMyIHN0YXRlKQoreworCWludCBuX2NoYW5zID0gMSwgaTsKKwlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZTsKKwlpbnQgZnJlcXVlbmN5ID0gZnJlcTsKKwlpbnQgcmV0ID0gMDsKKworCW1vZGUgPSBpZmFjZS0+Y3VycmVudF9tb2RlOworCWlmIChtb2RlID09IE5VTEwpCisJCXJldHVybiAwOworCisJaWYgKG1vZGUtPm1vZGUgIT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEpIHsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgImN1cnJlbnRfbW9kZSAhPSBJRUVFODAyMTFBIik7CisJCXJldHVybiAwOworCX0KKworCS8qIFNlZW1zIGNmMSBhbmQgY2hhbl93aWR0aCBpcyBlbm91Z2ggaGVyZSAqLworCXN3aXRjaCAoY2hhbl93aWR0aCkgeworCWNhc2UgQ0hBTl9XSURUSF8yMF9OT0hUOgorCWNhc2UgQ0hBTl9XSURUSF8yMDoKKwkJbl9jaGFucyA9IDE7CisJCWlmIChmcmVxdWVuY3kgPT0gMCkKKwkJCWZyZXF1ZW5jeSA9IGNmMTsKKwkJYnJlYWs7CisJY2FzZSBDSEFOX1dJRFRIXzQwOgorCQluX2NoYW5zID0gMjsKKwkJZnJlcXVlbmN5ID0gY2YxIC0gMTA7CisJCWJyZWFrOworCWNhc2UgQ0hBTl9XSURUSF84MDoKKwkJbl9jaGFucyA9IDQ7CisJCWZyZXF1ZW5jeSA9IGNmMSAtIDMwOworCQlicmVhazsKKwljYXNlIENIQU5fV0lEVEhfMTYwOgorCQluX2NoYW5zID0gODsKKwkJZnJlcXVlbmN5ID0gY2YxIC0gNzA7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJERlMgY2hhbl93aWR0aCAlZCBub3Qgc3VwcG9ydGVkIiwKKwkJCSAgIGNoYW5fd2lkdGgpOworCQlicmVhazsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRGUyBmcmVxOiAlZE1Ieiwgbl9jaGFuczogJWQiLCBmcmVxdWVuY3ksCisJCSAgIG5fY2hhbnMpOworCWZvciAoaSA9IDA7IGkgPCBuX2NoYW5zOyBpKyspIHsKKwkJcmV0ICs9IHNldF9kZnNfc3RhdGVfZnJlcShpZmFjZSwgZnJlcXVlbmN5LCBzdGF0ZSk7CisJCWZyZXF1ZW5jeSA9IGZyZXF1ZW5jeSArIDIwOworCX0KKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBkZnNfYXJlX2NoYW5uZWxzX292ZXJsYXBwZWQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBpbnQgZnJlcSwKKwkJCQkgICAgICAgaW50IGNoYW5fd2lkdGgsIGludCBjZjEsIGludCBjZjIpCit7CisJaW50IHN0YXJ0X2NoYW5faWR4OworCXN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlOworCXN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbjsKKwlpbnQgbl9jaGFucywgaSwgaiwgZnJlcXVlbmN5ID0gZnJlcSwgcmFkYXJfbl9jaGFucyA9IDE7CisJdTggcmFkYXJfY2hhbjsKKwlpbnQgcmVzID0gMDsKKworCS8qIE91ciBjb25maWd1cmF0aW9uICovCisJbW9kZSA9IGlmYWNlLT5jdXJyZW50X21vZGU7CisJc3RhcnRfY2hhbl9pZHggPSBkZnNfZ2V0X3N0YXJ0X2NoYW5faWR4KGlmYWNlKTsKKwluX2NoYW5zID0gZGZzX2dldF91c2VkX25fY2hhbnMoaWZhY2UpOworCisJLyogQ2hlY2sgd2UgYXJlIG9uIERGUyBjaGFubmVsKHMpICovCisJaWYgKCFkZnNfY2hlY2tfY2hhbnNfcmFkYXIoaWZhY2UsIHN0YXJ0X2NoYW5faWR4LCBuX2NoYW5zKSkKKwkJcmV0dXJuIDA7CisKKwkvKiBSZXBvcnRlZCB2aWEgcmFkYXIgZXZlbnQgKi8KKwlzd2l0Y2ggKGNoYW5fd2lkdGgpIHsKKwljYXNlIENIQU5fV0lEVEhfMjBfTk9IVDoKKwljYXNlIENIQU5fV0lEVEhfMjA6CisJCXJhZGFyX25fY2hhbnMgPSAxOworCQlpZiAoZnJlcXVlbmN5ID09IDApCisJCQlmcmVxdWVuY3kgPSBjZjE7CisJCWJyZWFrOworCWNhc2UgQ0hBTl9XSURUSF80MDoKKwkJcmFkYXJfbl9jaGFucyA9IDI7CisJCWZyZXF1ZW5jeSA9IGNmMSAtIDEwOworCQlicmVhazsKKwljYXNlIENIQU5fV0lEVEhfODA6CisJCXJhZGFyX25fY2hhbnMgPSA0OworCQlmcmVxdWVuY3kgPSBjZjEgLSAzMDsKKwkJYnJlYWs7CisJY2FzZSBDSEFOX1dJRFRIXzE2MDoKKwkJcmFkYXJfbl9jaGFucyA9IDg7CisJCWZyZXF1ZW5jeSA9IGNmMSAtIDcwOworCQlicmVhazsKKwlkZWZhdWx0OgorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiREZTIGNoYW5fd2lkdGggJWQgbm90IHN1cHBvcnRlZCIsCisJCQkgICBjaGFuX3dpZHRoKTsKKwkJYnJlYWs7CisJfQorCisJaWVlZTgwMjExX2ZyZXFfdG9fY2hhbihmcmVxdWVuY3ksICZyYWRhcl9jaGFuKTsKKworCWZvciAoaSA9IDA7IGkgPCBuX2NoYW5zOyBpKyspIHsKKwkJY2hhbiA9ICZtb2RlLT5jaGFubmVsc1tzdGFydF9jaGFuX2lkeCArIGldOworCQlpZiAoIShjaGFuLT5mbGFnICYgSE9TVEFQRF9DSEFOX1JBREFSKSkKKwkJCWNvbnRpbnVlOworCQlmb3IgKGogPSAwOyBqIDwgcmFkYXJfbl9jaGFuczsgaisrKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImNoZWNraW5nIG91cjogJWQsIHJhZGFyOiAlZCIsCisJCQkJICAgY2hhbi0+Y2hhbiwgcmFkYXJfY2hhbiArIGogKiA0KTsKKwkJCWlmIChjaGFuLT5jaGFuID09IHJhZGFyX2NoYW4gKyBqICogNCkKKwkJCQlyZXMrKzsKKwkJfQorCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAib3ZlcmxhcHBlZDogJWQiLCByZXMpOworCisJcmV0dXJuIHJlczsKK30KKworCitzdGF0aWMgdW5zaWduZWQgaW50IGRmc19nZXRfY2FjX3RpbWUoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAorCQkJCSAgICAgaW50IHN0YXJ0X2NoYW5faWR4LCBpbnQgbl9jaGFucykKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW5uZWw7CisJc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGU7CisJaW50IGk7CisJdW5zaWduZWQgaW50IGNhY190aW1lX21zID0gMDsKKworCW1vZGUgPSBpZmFjZS0+Y3VycmVudF9tb2RlOworCisJZm9yIChpID0gMDsgaSA8IG5fY2hhbnM7IGkrKykgeworCQljaGFubmVsID0gJm1vZGUtPmNoYW5uZWxzW3N0YXJ0X2NoYW5faWR4ICsgaV07CisJCWlmICghKGNoYW5uZWwtPmZsYWcgJiBIT1NUQVBEX0NIQU5fUkFEQVIpKQorCQkJY29udGludWU7CisJCWlmIChjaGFubmVsLT5kZnNfY2FjX21zID4gY2FjX3RpbWVfbXMpCisJCQljYWNfdGltZV9tcyA9IGNoYW5uZWwtPmRmc19jYWNfbXM7CisJfQorCisJcmV0dXJuIGNhY190aW1lX21zOworfQorCisKKy8qCisgKiBNYWluIERGUyBoYW5kbGVyCisgKiAxIC0gY29udGludWUgY2hhbm5lbC9hcCBzZXR1cAorICogMCAtIGNoYW5uZWwvYXAgc2V0dXAgd2lsbCBiZSBjb250aW51ZWQgYWZ0ZXIgQ0FDCisgKiAtMSAtIGhpdCBjcml0aWNhbCBlcnJvcgorICovCitpbnQgaG9zdGFwZF9oYW5kbGVfZGZzKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW5uZWw7CisJaW50IHJlcywgbl9jaGFucywgc3RhcnRfY2hhbl9pZHg7CisJaW50IHNraXBfcmFkYXIgPSAwOworCisJaWZhY2UtPmNhY19zdGFydGVkID0gMDsKKworCWRvIHsKKwkJLyogR2V0IHN0YXJ0IChmaXJzdCkgY2hhbm5lbCBmb3IgY3VycmVudCBjb25maWd1cmF0aW9uICovCisJCXN0YXJ0X2NoYW5faWR4ID0gZGZzX2dldF9zdGFydF9jaGFuX2lkeChpZmFjZSk7CisJCWlmIChzdGFydF9jaGFuX2lkeCA9PSAtMSkKKwkJCXJldHVybiAtMTsKKworCQkvKiBHZXQgbnVtYmVyIG9mIHVzZWQgY2hhbm5lbHMsIGRlcGVuZCBvbiB3aWR0aCAqLworCQluX2NoYW5zID0gZGZzX2dldF91c2VkX25fY2hhbnMoaWZhY2UpOworCisJCS8qIFNldHVwIENBQyB0aW1lICovCisJCWlmYWNlLT5kZnNfY2FjX21zID0gZGZzX2dldF9jYWNfdGltZShpZmFjZSwgc3RhcnRfY2hhbl9pZHgsCisJCQkJCQkgICAgIG5fY2hhbnMpOworCisJCS8qIENoZWNrIGlmIGFueSBvZiBjb25maWd1cmVkIGNoYW5uZWxzIHJlcXVpcmUgREZTICovCisJCXJlcyA9IGRmc19jaGVja19jaGFuc19yYWRhcihpZmFjZSwgc3RhcnRfY2hhbl9pZHgsIG5fY2hhbnMpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJERlMgJWQgY2hhbm5lbHMgcmVxdWlyZWQgcmFkYXIgZGV0ZWN0aW9uIiwKKwkJCSAgIHJlcyk7CisJCWlmICghcmVzKQorCQkJcmV0dXJuIDE7CisKKwkJLyogQ2hlY2sgaWYgYWxsIGNoYW5uZWxzIGFyZSBERlMgYXZhaWxhYmxlICovCisJCXJlcyA9IGRmc19jaGVja19jaGFuc19hdmFpbGFibGUoaWZhY2UsIHN0YXJ0X2NoYW5faWR4LCBuX2NoYW5zKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAiREZTIGFsbCBjaGFubmVscyBhdmFpbGFibGUsIChTS0lQIENBQyk6ICVzIiwKKwkJCSAgIHJlcyA/ICJ5ZXMiIDogIm5vIik7CisJCWlmIChyZXMpCisJCQlyZXR1cm4gMTsKKworCQkvKiBDaGVjayBpZiBhbnkgb2YgY29uZmlndXJlZCBjaGFubmVscyBpcyB1bmF2YWlsYWJsZSAqLworCQlyZXMgPSBkZnNfY2hlY2tfY2hhbnNfdW5hdmFpbGFibGUoaWZhY2UsIHN0YXJ0X2NoYW5faWR4LAorCQkJCQkJICBuX2NoYW5zKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJERlMgJWQgY2hhbnMgdW5hdmFpbGFibGUgLSBjaG9vc2Ugb3RoZXIgY2hhbm5lbDogJXMiLAorCQkJICAgcmVzLCByZXMgPyAieWVzIjogIm5vIik7CisJCWlmIChyZXMpIHsKKwkJCWludCBzZWMgPSAwOworCQkJdTggY2YxID0gMCwgY2YyID0gMDsKKworCQkJY2hhbm5lbCA9IGRmc19nZXRfdmFsaWRfY2hhbm5lbChpZmFjZSwgJnNlYywgJmNmMSwgJmNmMiwKKwkJCQkJCQlza2lwX3JhZGFyKTsKKwkJCWlmICghY2hhbm5lbCkgeworCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiY291bGQgbm90IGdldCB2YWxpZCBjaGFubmVsIik7CisJCQkJcmV0dXJuIC0xOworCQkJfQorCisJCQlpZmFjZS0+ZnJlcSA9IGNoYW5uZWwtPmZyZXE7CisJCQlpZmFjZS0+Y29uZi0+Y2hhbm5lbCA9IGNoYW5uZWwtPmNoYW47CisJCQlpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPSBzZWM7CisJCQlpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9IGNmMTsKKwkJCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4ID0gY2YyOworCQl9CisJfSB3aGlsZSAocmVzKTsKKworCS8qIEZpbmFsbHkgc3RhcnQgQ0FDICovCisJaG9zdGFwZF9zZXRfc3RhdGUoaWZhY2UsIEhBUERfSUZBQ0VfREZTKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRGUyBzdGFydCBDQUMgb24gJWQgTUh6IiwgaWZhY2UtPmZyZXEpOworCXdwYV9tc2coaWZhY2UtPmJzc1swXS0+bXNnX2N0eCwgTVNHX0lORk8sIERGU19FVkVOVF9DQUNfU1RBUlQKKwkJImZyZXE9JWQgY2hhbj0lZCBzZWNfY2hhbj0lZCwgd2lkdGg9JWQsIHNlZzA9JWQsIHNlZzE9JWQsIGNhY190aW1lPSVkcyIsCisJCWlmYWNlLT5mcmVxLAorCQlpZmFjZS0+Y29uZi0+Y2hhbm5lbCwgaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsLAorCQlpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2h3aWR0aCwKKwkJaWZhY2UtPmNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHgsCisJCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4LAorCQlpZmFjZS0+ZGZzX2NhY19tcyAvIDEwMDApOworCisJcmVzID0gaG9zdGFwZF9zdGFydF9kZnNfY2FjKGlmYWNlLCBpZmFjZS0+Y29uZi0+aHdfbW9kZSwKKwkJCQkgICAgaWZhY2UtPmZyZXEsCisJCQkJICAgIGlmYWNlLT5jb25mLT5jaGFubmVsLAorCQkJCSAgICBpZmFjZS0+Y29uZi0+aWVlZTgwMjExbiwKKwkJCQkgICAgaWZhY2UtPmNvbmYtPmllZWU4MDIxMWFjLAorCQkJCSAgICBpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwsCisJCQkJICAgIGlmYWNlLT5jb25mLT52aHRfb3Blcl9jaHdpZHRoLAorCQkJCSAgICBpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCwKKwkJCQkgICAgaWZhY2UtPmNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHgpOworCisJaWYgKHJlcykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkRGUyBzdGFydF9kZnNfY2FjKCkgZmFpbGVkLCAlZCIsIHJlcyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitpbnQgaG9zdGFwZF9kZnNfY29tcGxldGVfY2FjKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgaW50IHN1Y2Nlc3MsIGludCBmcmVxLAorCQkJICAgICBpbnQgaHRfZW5hYmxlZCwgaW50IGNoYW5fb2Zmc2V0LCBpbnQgY2hhbl93aWR0aCwKKwkJCSAgICAgaW50IGNmMSwgaW50IGNmMikKK3sKKwl3cGFfbXNnKGlmYWNlLT5ic3NbMF0tPm1zZ19jdHgsIE1TR19JTkZPLCBERlNfRVZFTlRfQ0FDX0NPTVBMRVRFRAorCQkic3VjY2Vzcz0lZCBmcmVxPSVkIGh0X2VuYWJsZWQ9JWQgY2hhbl9vZmZzZXQ9JWQgY2hhbl93aWR0aD0lZCBjZjE9JWQgY2YyPSVkIiwKKwkJc3VjY2VzcywgZnJlcSwgaHRfZW5hYmxlZCwgY2hhbl9vZmZzZXQsIGNoYW5fd2lkdGgsIGNmMSwgY2YyKTsKKworCWlmIChzdWNjZXNzKSB7CisJCS8qIENvbXBsZXRlIGlmYWNlL2FwIGNvbmZpZ3VyYXRpb24gKi8KKwkJc2V0X2Rmc19zdGF0ZShpZmFjZSwgZnJlcSwgaHRfZW5hYmxlZCwgY2hhbl9vZmZzZXQsCisJCQkgICAgICBjaGFuX3dpZHRoLCBjZjEsIGNmMiwKKwkJCSAgICAgIEhPU1RBUERfQ0hBTl9ERlNfQVZBSUxBQkxFKTsKKwkJaWZhY2UtPmNhY19zdGFydGVkID0gMDsKKwkJaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2VfY29tcGxldGUoaWZhY2UsIDApOworCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9kZnNfc3RhcnRfY2hhbm5lbF9zd2l0Y2hfY2FjKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW5uZWw7CisJaW50IHNlY29uZGFyeV9jaGFubmVsOworCXU4IHZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHggPSAwOworCXU4IHZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHggPSAwOworCWludCBza2lwX3JhZGFyID0gMDsKKwlpbnQgZXJyID0gMTsKKworCS8qIFJhZGFyIGRldGVjdGVkIGR1cmluZyBhY3RpdmUgQ0FDICovCisJaWZhY2UtPmNhY19zdGFydGVkID0gMDsKKwljaGFubmVsID0gZGZzX2dldF92YWxpZF9jaGFubmVsKGlmYWNlLCAmc2Vjb25kYXJ5X2NoYW5uZWwsCisJCQkJCSZ2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4LAorCQkJCQkmdmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCwKKwkJCQkJc2tpcF9yYWRhcik7CisKKwlpZiAoIWNoYW5uZWwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJObyB2YWxpZCBjaGFubmVsIGF2YWlsYWJsZSIpOworCQlob3N0YXBkX3NldHVwX2ludGVyZmFjZV9jb21wbGV0ZShpZmFjZSwgZXJyKTsKKwkJcmV0dXJuIGVycjsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRGUyB3aWxsIHN3aXRjaCB0byBhIG5ldyBjaGFubmVsICVkIiwKKwkJICAgY2hhbm5lbC0+Y2hhbik7CisJd3BhX21zZyhpZmFjZS0+YnNzWzBdLT5tc2dfY3R4LCBNU0dfSU5GTywgREZTX0VWRU5UX05FV19DSEFOTkVMCisJCSJmcmVxPSVkIGNoYW49JWQgc2VjX2NoYW49JWQiLCBjaGFubmVsLT5mcmVxLAorCQljaGFubmVsLT5jaGFuLCBzZWNvbmRhcnlfY2hhbm5lbCk7CisKKwlpZmFjZS0+ZnJlcSA9IGNoYW5uZWwtPmZyZXE7CisJaWZhY2UtPmNvbmYtPmNoYW5uZWwgPSBjaGFubmVsLT5jaGFuOworCWlmYWNlLT5jb25mLT5zZWNvbmRhcnlfY2hhbm5lbCA9IHNlY29uZGFyeV9jaGFubmVsOworCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0KKwkJdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeDsKKwlpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCA9CisJCXZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHg7CisJZXJyID0gMDsKKworCWhvc3RhcGRfc2V0dXBfaW50ZXJmYWNlX2NvbXBsZXRlKGlmYWNlLCBlcnIpOworCXJldHVybiBlcnI7Cit9CisKKworc3RhdGljIGludCBob3N0YXBkX2NzYV9pbl9wcm9ncmVzcyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCit7CisJdW5zaWduZWQgaW50IGk7CisJZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspCisJCWlmIChpZmFjZS0+YnNzW2ldLT5jc2FfaW5fcHJvZ3Jlc3MpCisJCQlyZXR1cm4gMTsKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IGhvc3RhcGRfZGZzX3N0YXJ0X2NoYW5uZWxfc3dpdGNoKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW5uZWw7CisJaW50IHNlY29uZGFyeV9jaGFubmVsOworCXU4IHZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHg7CisJdTggdmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeDsKKwlpbnQgc2tpcF9yYWRhciA9IDE7CisJc3RydWN0IGNzYV9zZXR0aW5ncyBjc2Ffc2V0dGluZ3M7CisJdW5zaWduZWQgaW50IGk7CisJaW50IGVyciA9IDE7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIGNhbGxlZCAoQ0FDIGFjdGl2ZTogJXMsIENTQSBhY3RpdmU6ICVzKSIsCisJCSAgIF9fZnVuY19fLCBpZmFjZS0+Y2FjX3N0YXJ0ZWQgPyAieWVzIiA6ICJubyIsCisJCSAgIGhvc3RhcGRfY3NhX2luX3Byb2dyZXNzKGlmYWNlKSA/ICJ5ZXMiIDogIm5vIik7CisKKwkvKiBDaGVjayBpZiBDU0EgaW4gcHJvZ3Jlc3MgKi8KKwlpZiAoaG9zdGFwZF9jc2FfaW5fcHJvZ3Jlc3MoaWZhY2UpKQorCQlyZXR1cm4gMDsKKworCS8qIENoZWNrIGlmIGFjdGl2ZSBDQUMgKi8KKwlpZiAoaWZhY2UtPmNhY19zdGFydGVkKQorCQlyZXR1cm4gaG9zdGFwZF9kZnNfc3RhcnRfY2hhbm5lbF9zd2l0Y2hfY2FjKGlmYWNlKTsKKworCS8qIFBlcmZvcm0gY2hhbm5lbCBzd2l0Y2gvQ1NBICovCisJY2hhbm5lbCA9IGRmc19nZXRfdmFsaWRfY2hhbm5lbChpZmFjZSwgJnNlY29uZGFyeV9jaGFubmVsLAorCQkJCQkmdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCwKKwkJCQkJJnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHgsCisJCQkJCXNraXBfcmFkYXIpOworCisJaWYgKCFjaGFubmVsKSB7CisJCS8qCisJCSAqIElmIHRoZXJlIGlzIG5vIGNoYW5uZWwgdG8gc3dpdGNoIGltbWVkaWF0ZWx5IHRvLCBjaGVjayBpZgorCQkgKiB0aGVyZSBpcyBhbm90aGVyIGNoYW5uZWwgd2hlcmUgd2UgY2FuIHN3aXRjaCBldmVuIGlmIGl0CisJCSAqIHJlcXVpcmVzIHRvIHBlcmZvcm0gYSBDQUMgZmlyc3QuCisJCSAqLworCQlza2lwX3JhZGFyID0gMDsKKwkJY2hhbm5lbCA9IGRmc19nZXRfdmFsaWRfY2hhbm5lbChpZmFjZSwgJnNlY29uZGFyeV9jaGFubmVsLAorCQkJCQkJJnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMF9pZHgsCisJCQkJCQkmdmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCwKKwkJCQkJCXNraXBfcmFkYXIpOworCQlpZiAoIWNoYW5uZWwpIHsKKwkJCS8qIEZJWE1FOiBXYWl0IGZvciBjaGFubmVsKHMpIHRvIGJlY29tZSBhdmFpbGFibGUgKi8KKwkJCWhvc3RhcGRfZGlzYWJsZV9pZmFjZShpZmFjZSk7CisJCQlyZXR1cm4gZXJyOworCQl9CisKKwkJaWZhY2UtPmZyZXEgPSBjaGFubmVsLT5mcmVxOworCQlpZmFjZS0+Y29uZi0+Y2hhbm5lbCA9IGNoYW5uZWwtPmNoYW47CisJCWlmYWNlLT5jb25mLT5zZWNvbmRhcnlfY2hhbm5lbCA9IHNlY29uZGFyeV9jaGFubmVsOworCQlpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9CisJCQl2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4OworCQlpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCA9CisJCQl2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4OworCisJCWhvc3RhcGRfZGlzYWJsZV9pZmFjZShpZmFjZSk7CisJCWhvc3RhcGRfZW5hYmxlX2lmYWNlKGlmYWNlKTsKKwkJcmV0dXJuIDA7CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJERlMgd2lsbCBzd2l0Y2ggdG8gYSBuZXcgY2hhbm5lbCAlZCIsCisJCSAgIGNoYW5uZWwtPmNoYW4pOworCXdwYV9tc2coaWZhY2UtPmJzc1swXS0+bXNnX2N0eCwgTVNHX0lORk8sIERGU19FVkVOVF9ORVdfQ0hBTk5FTAorCQkiZnJlcT0lZCBjaGFuPSVkIHNlY19jaGFuPSVkIiwgY2hhbm5lbC0+ZnJlcSwKKwkJY2hhbm5lbC0+Y2hhbiwgc2Vjb25kYXJ5X2NoYW5uZWwpOworCisJLyogU2V0dXAgQ1NBIHJlcXVlc3QgKi8KKwlvc19tZW1zZXQoJmNzYV9zZXR0aW5ncywgMCwgc2l6ZW9mKGNzYV9zZXR0aW5ncykpOworCWNzYV9zZXR0aW5ncy5jc19jb3VudCA9IDU7CisJY3NhX3NldHRpbmdzLmJsb2NrX3R4ID0gMTsKKwllcnIgPSBob3N0YXBkX3NldF9mcmVxX3BhcmFtcygmY3NhX3NldHRpbmdzLmZyZXFfcGFyYW1zLAorCQkJCSAgICAgIGlmYWNlLT5jb25mLT5od19tb2RlLAorCQkJCSAgICAgIGNoYW5uZWwtPmZyZXEsCisJCQkJICAgICAgY2hhbm5lbC0+Y2hhbiwKKwkJCQkgICAgICBpZmFjZS0+Y29uZi0+aWVlZTgwMjExbiwKKwkJCQkgICAgICBpZmFjZS0+Y29uZi0+aWVlZTgwMjExYWMsCisJCQkJICAgICAgc2Vjb25kYXJ5X2NoYW5uZWwsCisJCQkJICAgICAgaWZhY2UtPmNvbmYtPnZodF9vcGVyX2Nod2lkdGgsCisJCQkJICAgICAgdmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCwKKwkJCQkgICAgICB2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4LAorCQkJCSAgICAgIGlmYWNlLT5jdXJyZW50X21vZGUtPnZodF9jYXBhYik7CisKKwlpZiAoZXJyKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiREZTIGZhaWxlZCB0byBjYWxjdWxhdGUgQ1NBIGZyZXEgcGFyYW1zIik7CisJCWhvc3RhcGRfZGlzYWJsZV9pZmFjZShpZmFjZSk7CisJCXJldHVybiBlcnI7CisJfQorCisJZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspIHsKKwkJZXJyID0gaG9zdGFwZF9zd2l0Y2hfY2hhbm5lbChpZmFjZS0+YnNzW2ldLCAmY3NhX3NldHRpbmdzKTsKKwkJaWYgKGVycikKKwkJCWJyZWFrOworCX0KKworCWlmIChlcnIpIHsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkRGUyBmYWlsZWQgdG8gc2NoZWR1bGUgQ1NBICglZCkgLSB0cnlpbmcgZmFsbGJhY2siLAorCQkJICAgZXJyKTsKKwkJaWZhY2UtPmZyZXEgPSBjaGFubmVsLT5mcmVxOworCQlpZmFjZS0+Y29uZi0+Y2hhbm5lbCA9IGNoYW5uZWwtPmNoYW47CisJCWlmYWNlLT5jb25mLT5zZWNvbmRhcnlfY2hhbm5lbCA9IHNlY29uZGFyeV9jaGFubmVsOworCQlpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9CisJCQl2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4OworCQlpZmFjZS0+Y29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCA9CisJCQl2aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4OworCisJCWhvc3RhcGRfZGlzYWJsZV9pZmFjZShpZmFjZSk7CisJCWhvc3RhcGRfZW5hYmxlX2lmYWNlKGlmYWNlKTsKKwkJcmV0dXJuIDA7CisJfQorCisJLyogQ2hhbm5lbCBjb25maWd1cmF0aW9uIHdpbGwgYmUgdXBkYXRlZCBvbmNlIENTQSBjb21wbGV0ZXMgYW5kCisJICogY2hfc3dpdGNoX25vdGlmeSBldmVudCBpcyByZWNlaXZlZCAqLworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJERlMgd2FpdGluZyBjaGFubmVsIHN3aXRjaCBldmVudCIpOworCXJldHVybiAwOworfQorCisKK2ludCBob3N0YXBkX2Rmc19yYWRhcl9kZXRlY3RlZChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsIGludCBmcmVxLAorCQkJICAgICAgIGludCBodF9lbmFibGVkLCBpbnQgY2hhbl9vZmZzZXQsIGludCBjaGFuX3dpZHRoLAorCQkJICAgICAgIGludCBjZjEsIGludCBjZjIpCit7CisJaW50IHJlczsKKworCWlmICghaWZhY2UtPmNvbmYtPmllZWU4MDIxMWgpCisJCXJldHVybiAwOworCisJd3BhX21zZyhpZmFjZS0+YnNzWzBdLT5tc2dfY3R4LCBNU0dfSU5GTywgREZTX0VWRU5UX1JBREFSX0RFVEVDVEVECisJCSJmcmVxPSVkIGh0X2VuYWJsZWQ9JWQgY2hhbl9vZmZzZXQ9JWQgY2hhbl93aWR0aD0lZCBjZjE9JWQgY2YyPSVkIiwKKwkJZnJlcSwgaHRfZW5hYmxlZCwgY2hhbl9vZmZzZXQsIGNoYW5fd2lkdGgsIGNmMSwgY2YyKTsKKworCS8qIG1hcmsgcmFkYXIgZnJlcXVlbmN5IGFzIGludmFsaWQgKi8KKwlzZXRfZGZzX3N0YXRlKGlmYWNlLCBmcmVxLCBodF9lbmFibGVkLCBjaGFuX29mZnNldCwgY2hhbl93aWR0aCwKKwkJICAgICAgY2YxLCBjZjIsIEhPU1RBUERfQ0hBTl9ERlNfVU5BVkFJTEFCTEUpOworCisJLyogU2tpcCBpZiByZXBvcnRlZCByYWRhciBldmVudCBub3Qgb3ZlcmxhcHBlZCBvdXIgY2hhbm5lbHMgKi8KKwlyZXMgPSBkZnNfYXJlX2NoYW5uZWxzX292ZXJsYXBwZWQoaWZhY2UsIGZyZXEsIGNoYW5fd2lkdGgsIGNmMSwgY2YyKTsKKwlpZiAoIXJlcykKKwkJcmV0dXJuIDA7CisKKwkvKiByYWRhciBkZXRlY3RlZCB3aGlsZSBvcGVyYXRpbmcsIHN3aXRjaCB0aGUgY2hhbm5lbC4gKi8KKwlyZXMgPSBob3N0YXBkX2Rmc19zdGFydF9jaGFubmVsX3N3aXRjaChpZmFjZSk7CisKKwlyZXR1cm4gcmVzOworfQorCisKK2ludCBob3N0YXBkX2Rmc19ub3BfZmluaXNoZWQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBpbnQgZnJlcSwKKwkJCSAgICAgaW50IGh0X2VuYWJsZWQsIGludCBjaGFuX29mZnNldCwgaW50IGNoYW5fd2lkdGgsCisJCQkgICAgIGludCBjZjEsIGludCBjZjIpCit7CisJd3BhX21zZyhpZmFjZS0+YnNzWzBdLT5tc2dfY3R4LCBNU0dfSU5GTywgREZTX0VWRU5UX05PUF9GSU5JU0hFRAorCQkiZnJlcT0lZCBodF9lbmFibGVkPSVkIGNoYW5fb2Zmc2V0PSVkIGNoYW5fd2lkdGg9JWQgY2YxPSVkIGNmMj0lZCIsCisJCWZyZXEsIGh0X2VuYWJsZWQsIGNoYW5fb2Zmc2V0LCBjaGFuX3dpZHRoLCBjZjEsIGNmMik7CisJLyogVE9ETyBhZGQgY29ycmVjdCBpbXBsZW1lbnRhdGlvbiBoZXJlICovCisJc2V0X2Rmc19zdGF0ZShpZmFjZSwgZnJlcSwgaHRfZW5hYmxlZCwgY2hhbl9vZmZzZXQsIGNoYW5fd2lkdGgsCisJCSAgICAgIGNmMSwgY2YyLCBIT1NUQVBEX0NIQU5fREZTX1VTQUJMRSk7CisJcmV0dXJuIDA7Cit9CisKKworaW50IGhvc3RhcGRfaXNfZGZzX3JlcXVpcmVkKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKK3sKKwlpbnQgbl9jaGFucywgc3RhcnRfY2hhbl9pZHg7CisKKwlpZiAoIWlmYWNlLT5jb25mLT5pZWVlODAyMTFoIHx8ICFpZmFjZS0+Y3VycmVudF9tb2RlIHx8CisJICAgIGlmYWNlLT5jdXJyZW50X21vZGUtPm1vZGUgIT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEpCisJCXJldHVybiAwOworCisJLyogR2V0IHN0YXJ0IChmaXJzdCkgY2hhbm5lbCBmb3IgY3VycmVudCBjb25maWd1cmF0aW9uICovCisJc3RhcnRfY2hhbl9pZHggPSBkZnNfZ2V0X3N0YXJ0X2NoYW5faWR4KGlmYWNlKTsKKwlpZiAoc3RhcnRfY2hhbl9pZHggPT0gLTEpCisJCXJldHVybiAtMTsKKworCS8qIEdldCBudW1iZXIgb2YgdXNlZCBjaGFubmVscywgZGVwZW5kIG9uIHdpZHRoICovCisJbl9jaGFucyA9IGRmc19nZXRfdXNlZF9uX2NoYW5zKGlmYWNlKTsKKworCS8qIENoZWNrIGlmIGFueSBvZiBjb25maWd1cmVkIGNoYW5uZWxzIHJlcXVpcmUgREZTICovCisJcmV0dXJuIGRmc19jaGVja19jaGFuc19yYWRhcihpZmFjZSwgc3RhcnRfY2hhbl9pZHgsIG5fY2hhbnMpOworfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2Rmcy5oIGIvc3JjL2FwL2Rmcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE2MTljNTUKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvYXAvZGZzLmgKQEAgLTAsMCArMSwyNiBAQAorLyoKKyAqIERGUyAtIER5bmFtaWMgRnJlcXVlbmN5IFNlbGVjdGlvbgorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIERGU19ICisjZGVmaW5lIERGU19ICisKK2ludCBob3N0YXBkX2hhbmRsZV9kZnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKKworaW50IGhvc3RhcGRfZGZzX2NvbXBsZXRlX2NhYyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsIGludCBzdWNjZXNzLCBpbnQgZnJlcSwKKwkJCSAgICAgaW50IGh0X2VuYWJsZWQsIGludCBjaGFuX29mZnNldCwgaW50IGNoYW5fd2lkdGgsCisJCQkgICAgIGludCBjZjEsIGludCBjZjIpOworaW50IGhvc3RhcGRfZGZzX3JhZGFyX2RldGVjdGVkKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgaW50IGZyZXEsCisJCQkgICAgICAgaW50IGh0X2VuYWJsZWQsCisJCQkgICAgICAgaW50IGNoYW5fb2Zmc2V0LCBpbnQgY2hhbl93aWR0aCwKKwkJCSAgICAgICBpbnQgY2YxLCBpbnQgY2YyKTsKK2ludCBob3N0YXBkX2Rmc19ub3BfZmluaXNoZWQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBpbnQgZnJlcSwKKwkJCSAgICAgaW50IGh0X2VuYWJsZWQsCisJCQkgICAgIGludCBjaGFuX29mZnNldCwgaW50IGNoYW5fd2lkdGgsIGludCBjZjEsIGludCBjZjIpOworaW50IGhvc3RhcGRfaXNfZGZzX3JlcXVpcmVkKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7CisKKyNlbmRpZiAvKiBERlNfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2Rydl9jYWxsYmFja3MuYyBiL3NyYy9hcC9kcnZfY2FsbGJhY2tzLmMKaW5kZXggZDZiYzk4ZC4uOTM4MDRkZSAxMDA2NDQKLS0tIGEvc3JjL2FwL2Rydl9jYWxsYmFja3MuYworKysgYi9zcmMvYXAvZHJ2X2NhbGxiYWNrcy5jCkBAIC05LDYgKzksNyBAQAogI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCiAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKyNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgogI2luY2x1ZGUgInJhZGl1cy9yYWRpdXMuaCIKICNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKQEAgLTI5LDYgKzMwLDggQEAKICNpbmNsdWRlICJhcF9kcnZfb3BzLmgiCiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCiAjaW5jbHVkZSAiaHdfZmVhdHVyZXMuaCIKKyNpbmNsdWRlICJkZnMuaCIKKyNpbmNsdWRlICJiZWFjb24uaCIKIAogCiBpbnQgaG9zdGFwZF9ub3RpZl9hc3NvYyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkciwKQEAgLTc3LDYgKzgwLDEyIEBACiAJCWllID0gZWxlbXMud3BhX2llIC0gMjsKIAkJaWVsZW4gPSBlbGVtcy53cGFfaWVfbGVuICsgMjsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTVEEgaW5jbHVkZWQgV1BBIElFIGluIChSZSlBc3NvY1JlcSIpOworI2lmZGVmIENPTkZJR19IUzIwCisJfSBlbHNlIGlmIChlbGVtcy5vc2VuKSB7CisJCWllID0gZWxlbXMub3NlbiAtIDI7CisJCWllbGVuID0gZWxlbXMub3Nlbl9sZW4gKyAyOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNUQSBpbmNsdWRlZCBPU0VOIElFIGluIChSZSlBc3NvY1JlcSIpOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJfSBlbHNlIHsKIAkJaWUgPSBOVUxMOwogCQlpZWxlbiA9IDA7CkBAIC0xMTQsNiArMTIzLDMxIEBACiAJfQogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAorI2lmZGVmIENPTkZJR19JRUVFODAyMTFOCisjaWZkZWYgTkVFRF9BUF9NTE1FCisJaWYgKGVsZW1zLmh0X2NhcGFiaWxpdGllcyAmJgorCSAgICBlbGVtcy5odF9jYXBhYmlsaXRpZXNfbGVuID49CisJICAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcykgJiYKKwkgICAgKGhhcGQtPmlmYWNlLT5jb25mLT5odF9jYXBhYiAmCisJICAgICBIVF9DQVBfSU5GT19TVVBQX0NIQU5ORUxfV0lEVEhfU0VUKSkgeworCQlzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyAqaHRfY2FwID0KKwkJCShzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyAqKQorCQkJZWxlbXMuaHRfY2FwYWJpbGl0aWVzOworCisJCWlmIChsZV90b19ob3N0MTYoaHRfY2FwLT5odF9jYXBhYmlsaXRpZXNfaW5mbykgJgorCQkgICAgSFRfQ0FQX0lORk9fNDBNSFpfSU5UT0xFUkFOVCkKKwkJCWh0NDBfaW50b2xlcmFudF9hZGQoaGFwZC0+aWZhY2UsIHN0YSk7CisJfQorI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLworI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFOICovCisKKyNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCisJaWYgKGVsZW1zLmV4dF9jYXBhYiAmJiBlbGVtcy5leHRfY2FwYWJfbGVuID4gNCkgeworCQlpZiAoZWxlbXMuZXh0X2NhcGFiWzRdICYgMHgwMSkKKwkJCXN0YS0+cW9zX21hcF9lbmFibGVkID0gMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLworCiAjaWZkZWYgQ09ORklHX0hTMjAKIAl3cGFidWZfZnJlZShzdGEtPmhzMjBfaWUpOwogCWlmIChlbGVtcy5oczIwICYmIGVsZW1zLmhzMjBfbGVuID4gNCkgewpAQCAtMjczLDYgKzMwNywyOSBAQAogCQkJc3RhLT5mbGFncyB8PSBXTEFOX1NUQV9NQVlCRV9XUFM7CiAJCXdwYWJ1Zl9mcmVlKHdwcyk7CiAjZW5kaWYgLyogQ09ORklHX1dQUyAqLworI2lmZGVmIENPTkZJR19IUzIwCisJfSBlbHNlIGlmIChoYXBkLT5jb25mLT5vc2VuKSB7CisJCWlmIChlbGVtcy5vc2VuID09IE5VTEwpIHsKKwkJCWhvc3RhcGRfbG9nZ2VyKAorCQkJCWhhcGQsIHN0YS0+YWRkciwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAorCQkJCUhPU1RBUERfTEVWRUxfSU5GTywKKwkJCQkiTm8gSFMgMi4wIE9TRU4gZWxlbWVudCBpbiBhc3NvY2lhdGlvbiByZXF1ZXN0Iik7CisJCQlyZXR1cm4gV0xBTl9TVEFUVVNfSU5WQUxJRF9JRTsKKwkJfQorCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBPU0VOIGFzc29jaWF0aW9uIik7CisJCWlmIChzdGEtPndwYV9zbSA9PSBOVUxMKQorCQkJc3RhLT53cGFfc20gPSB3cGFfYXV0aF9zdGFfaW5pdChoYXBkLT53cGFfYXV0aCwKKwkJCQkJCQlzdGEtPmFkZHIsIE5VTEwpOworCQlpZiAoc3RhLT53cGFfc20gPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkZhaWxlZCB0byBpbml0aWFsaXplIFdQQSAiCisJCQkJICAgInN0YXRlIG1hY2hpbmUiKTsKKwkJCXJldHVybiBXTEFOX1NUQVRVU19VTlNQRUNJRklFRF9GQUlMVVJFOworCQl9CisJCWlmICh3cGFfdmFsaWRhdGVfb3NlbihoYXBkLT53cGFfYXV0aCwgc3RhLT53cGFfc20sCisJCQkJICAgICAgZWxlbXMub3NlbiAtIDIsIGVsZW1zLm9zZW5fbGVuICsgMikgPCAwKQorCQkJcmV0dXJuIFdMQU5fU1RBVFVTX0lOVkFMSURfSUU7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAl9CiAjaWZkZWYgQ09ORklHX1dQUwogc2tpcF93cGFfY2hlY2s6CkBAIC0yOTEsNiArMzQ4LDcgQEAKIAogCW5ld19hc3NvYyA9IChzdGEtPmZsYWdzICYgV0xBTl9TVEFfQVNTT0MpID09IDA7CiAJc3RhLT5mbGFncyB8PSBXTEFOX1NUQV9BVVRIIHwgV0xBTl9TVEFfQVNTT0M7CisJc3RhLT5mbGFncyAmPSB+V0xBTl9TVEFfV05NX1NMRUVQX01PREU7CiAKIAlpZiAocmVhc3NvYyAmJiAoc3RhLT5hdXRoX2FsZyA9PSBXTEFOX0FVVEhfRlQpKQogCQl3cGFfYXV0aF9zbV9ldmVudChzdGEtPndwYV9zbSwgV1BBX0FTU09DX0ZUKTsKQEAgLTM3MywxNCArNDMxLDE1IEBACiAKIAogdm9pZCBob3N0YXBkX2V2ZW50X2NoX3N3aXRjaChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBpbnQgZnJlcSwgaW50IGh0LAotCQkJICAgICBpbnQgb2Zmc2V0KQorCQkJICAgICBpbnQgb2Zmc2V0LCBpbnQgd2lkdGgsIGludCBjZjEsIGludCBjZjIpCiB7CiAjaWZkZWYgTkVFRF9BUF9NTE1FCi0JaW50IGNoYW5uZWw7CisJaW50IGNoYW5uZWwsIGNod2lkdGgsIHNlZzBfaWR4ID0gMCwgc2VnMV9pZHggPSAwOwogCiAJaG9zdGFwZF9sb2dnZXIoaGFwZCwgTlVMTCwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAogCQkgICAgICAgSE9TVEFQRF9MRVZFTF9JTkZPLCAiZHJpdmVyIGhhZCBjaGFubmVsIHN3aXRjaDogIgotCQkgICAgICAgImZyZXE9JWQsIGh0PSVkLCBvZmZzZXQ9JWQiLCBmcmVxLCBodCwgb2Zmc2V0KTsKKwkJICAgICAgICJmcmVxPSVkLCBodD0lZCwgb2Zmc2V0PSVkLCB3aWR0aD0lZCwgY2YxPSVkLCBjZjI9JWQiLAorCQkgICAgICAgZnJlcSwgaHQsIG9mZnNldCwgd2lkdGgsIGNmMSwgY2YyKTsKIAogCWhhcGQtPmlmYWNlLT5mcmVxID0gZnJlcTsKIApAQCAtMzkyLDkgKzQ1MSw1MiBAQAogCQlyZXR1cm47CiAJfQogCisJc3dpdGNoICh3aWR0aCkgeworCWNhc2UgQ0hBTl9XSURUSF84MDoKKwkJY2h3aWR0aCA9IFZIVF9DSEFOV0lEVEhfODBNSFo7CisJCWJyZWFrOworCWNhc2UgQ0hBTl9XSURUSF84MFA4MDoKKwkJY2h3aWR0aCA9IFZIVF9DSEFOV0lEVEhfODBQODBNSFo7CisJCWJyZWFrOworCWNhc2UgQ0hBTl9XSURUSF8xNjA6CisJCWNod2lkdGggPSBWSFRfQ0hBTldJRFRIXzE2ME1IWjsKKwkJYnJlYWs7CisJY2FzZSBDSEFOX1dJRFRIXzIwX05PSFQ6CisJY2FzZSBDSEFOX1dJRFRIXzIwOgorCWNhc2UgQ0hBTl9XSURUSF80MDoKKwlkZWZhdWx0OgorCQljaHdpZHRoID0gVkhUX0NIQU5XSURUSF9VU0VfSFQ7CisJCWJyZWFrOworCX0KKworCXN3aXRjaCAoaGFwZC0+aWZhY2UtPmN1cnJlbnRfbW9kZS0+bW9kZSkgeworCWNhc2UgSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUE6CisJCWlmIChjZjEgPiA1MDAwKQorCQkJc2VnMF9pZHggPSAoY2YxIC0gNTAwMCkgLyA1OworCQlpZiAoY2YyID4gNTAwMCkKKwkJCXNlZzFfaWR4ID0gKGNmMiAtIDUwMDApIC8gNTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJc2VnMF9pZHggPSBob3N0YXBkX2h3X2dldF9jaGFubmVsKGhhcGQsIGNmMSk7CisJCXNlZzFfaWR4ID0gaG9zdGFwZF9od19nZXRfY2hhbm5lbChoYXBkLCBjZjIpOworCQlicmVhazsKKwl9CisKIAloYXBkLT5pY29uZi0+Y2hhbm5lbCA9IGNoYW5uZWw7CiAJaGFwZC0+aWNvbmYtPmllZWU4MDIxMW4gPSBodDsKIAloYXBkLT5pY29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPSBvZmZzZXQ7CisJaGFwZC0+aWNvbmYtPnZodF9vcGVyX2Nod2lkdGggPSBjaHdpZHRoOworCWhhcGQtPmljb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0gc2VnMF9pZHg7CisJaGFwZC0+aWNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHggPSBzZWcxX2lkeDsKKworCWlmIChoYXBkLT5jc2FfaW5fcHJvZ3Jlc3MgJiYKKwkgICAgZnJlcSA9PSBoYXBkLT5jc19mcmVxX3BhcmFtcy5mcmVxKSB7CisJCWhvc3RhcGRfY2xlYW51cF9jc19wYXJhbXMoaGFwZCk7CisJCWllZWU4MDJfMTFfc2V0X2JlYWNvbihoYXBkKTsKKworCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19JTkZPLCBBUF9DU0FfRklOSVNIRUQgImZyZXE9JWQiLAorCQkJZnJlcSk7CisJfQogI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLwogfQogCkBAIC01MDYsMzkgKzYwOCw0OCBAQAogCiAKIHN0YXRpYyB2b2lkIGhvc3RhcGRfYWN0aW9uX3J4KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCi0JCQkgICAgICBzdHJ1Y3QgcnhfYWN0aW9uICphY3Rpb24pCisJCQkgICAgICBzdHJ1Y3QgcnhfbWdtdCAqZHJ2X21nbXQpCiB7CisJc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210OwogCXN0cnVjdCBzdGFfaW5mbyAqc3RhOworCXNpemVfdCBwbGVuIF9fbWF5YmVfdW51c2VkOworCXUxNiBmYzsKKworCWlmIChkcnZfbWdtdC0+ZnJhbWVfbGVuIDwgMjQgKyAxKQorCQlyZXR1cm47CisKKwlwbGVuID0gZHJ2X21nbXQtPmZyYW1lX2xlbiAtIDI0IC0gMTsKKworCW1nbXQgPSAoc3RydWN0IGllZWU4MDIxMV9tZ210ICopIGRydl9tZ210LT5mcmFtZTsKKwlmYyA9IGxlX3RvX2hvc3QxNihtZ210LT5mcmFtZV9jb250cm9sKTsKKwlpZiAoV0xBTl9GQ19HRVRfU1RZUEUoZmMpICE9IFdMQU5fRkNfU1RZUEVfQUNUSU9OKQorCQlyZXR1cm47IC8qIGhhbmRsZWQgYnkgdGhlIGRyaXZlciAqLwogCiAgICAgICAgIHdwYV9wcmludGYoTVNHX0RFQlVHLCAiUlhfQUNUSU9OIGNhdCAlZCBhY3Rpb24gcGxlbiAlZCIsCi0JCSAgIGFjdGlvbi0+Y2F0ZWdvcnksIChpbnQpIGFjdGlvbi0+bGVuKTsKKwkJICAgbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnksIChpbnQpIHBsZW4pOwogCi0Jc3RhID0gYXBfZ2V0X3N0YShoYXBkLCBhY3Rpb24tPnNhKTsKKwlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIG1nbXQtPnNhKTsKIAlpZiAoc3RhID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogc3RhdGlvbiBub3QgZm91bmQiLCBfX2Z1bmNfXyk7CiAJCXJldHVybjsKIAl9CiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKLQlpZiAoYWN0aW9uLT5jYXRlZ29yeSA9PSBXTEFOX0FDVElPTl9GVCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBGVF9BQ1RJT04gbGVuZ3RoICVkIiwKLQkJCSAgIF9fZnVuY19fLCAoaW50KSBhY3Rpb24tPmxlbik7Ci0JCXdwYV9mdF9hY3Rpb25fcngoc3RhLT53cGFfc20sIGFjdGlvbi0+ZGF0YSwgYWN0aW9uLT5sZW4pOworCWlmIChtZ210LT51LmFjdGlvbi5jYXRlZ29yeSA9PSBXTEFOX0FDVElPTl9GVCkgeworCQljb25zdCB1OCAqcGF5bG9hZCA9IGRydl9tZ210LT5mcmFtZSArIDI0ICsgMTsKKwkJd3BhX2Z0X2FjdGlvbl9yeChzdGEtPndwYV9zbSwgcGF5bG9hZCwgcGxlbik7CiAJfQogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKLQlpZiAoYWN0aW9uLT5jYXRlZ29yeSA9PSBXTEFOX0FDVElPTl9TQV9RVUVSWSAmJiBhY3Rpb24tPmxlbiA+PSA0KSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IFNBX1FVRVJZX0FDVElPTiBsZW5ndGggJWQiLAotCQkJICAgX19mdW5jX18sIChpbnQpIGFjdGlvbi0+bGVuKTsKLQkJaWVlZTgwMl8xMV9zYV9xdWVyeV9hY3Rpb24oaGFwZCwgYWN0aW9uLT5zYSwKLQkJCQkJICAgKihhY3Rpb24tPmRhdGEgKyAxKSwKLQkJCQkJICAgYWN0aW9uLT5kYXRhICsgMik7CisJaWYgKG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ID09IFdMQU5fQUNUSU9OX1NBX1FVRVJZICYmIHBsZW4gPj0gNCkgeworCQlpZWVlODAyXzExX3NhX3F1ZXJ5X2FjdGlvbigKKwkJCWhhcGQsIG1nbXQtPnNhLAorCQkJbWdtdC0+dS5hY3Rpb24udS5zYV9xdWVyeV9yZXNwLmFjdGlvbiwKKwkJCW1nbXQtPnUuYWN0aW9uLnUuc2FfcXVlcnlfcmVzcC50cmFuc19pZCk7CiAJfQogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAjaWZkZWYgQ09ORklHX1dOTQotCWlmIChhY3Rpb24tPmNhdGVnb3J5ID09IFdMQU5fQUNUSU9OX1dOTSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBXTk1fQUNUSU9OIGxlbmd0aCAlZCIsCi0JCQkgICBfX2Z1bmNfXywgKGludCkgYWN0aW9uLT5sZW4pOwotCQlpZWVlODAyXzExX3J4X3dubV9hY3Rpb25fYXAoaGFwZCwgYWN0aW9uKTsKKwlpZiAobWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgPT0gV0xBTl9BQ1RJT05fV05NKSB7CisJCWllZWU4MDJfMTFfcnhfd25tX2FjdGlvbl9hcChoYXBkLCBtZ210LCBkcnZfbWdtdC0+ZnJhbWVfbGVuKTsKIAl9CiAjZW5kaWYgLyogQ09ORklHX1dOTSAqLwogfQpAQCAtNTgwLDE3ICs2OTEsMzIgQEAKIH0KIAogCi1zdGF0aWMgdm9pZCBob3N0YXBkX21nbXRfcngoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHJ4X21nbXQgKnJ4X21nbXQpCitzdGF0aWMgaW50IGhvc3RhcGRfbWdtdF9yeChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3QgcnhfbWdtdCAqcnhfbWdtdCkKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UgPSBoYXBkLT5pZmFjZTsKIAljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX2hkciAqaGRyOwogCWNvbnN0IHU4ICpic3NpZDsKIAlzdHJ1Y3QgaG9zdGFwZF9mcmFtZV9pbmZvIGZpOworCWludCByZXQ7CisKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJaWYgKGhhcGQtPmV4dF9tZ210X2ZyYW1lX2hhbmRsaW5nKSB7CisJCXNpemVfdCBoZXhfbGVuID0gMiAqIHJ4X21nbXQtPmZyYW1lX2xlbiArIDE7CisJCWNoYXIgKmhleCA9IG9zX21hbGxvYyhoZXhfbGVuKTsKKwkJaWYgKGhleCkgeworCQkJd3BhX3NucHJpbnRmX2hleChoZXgsIGhleF9sZW4sIHJ4X21nbXQtPmZyYW1lLAorCQkJCQkgcnhfbWdtdC0+ZnJhbWVfbGVuKTsKKwkJCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX0lORk8sICJNR01ULVJYICVzIiwgaGV4KTsKKwkJCW9zX2ZyZWUoaGV4KTsKKwkJfQorCQlyZXR1cm4gMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLwogCiAJaGRyID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfaGRyICopIHJ4X21nbXQtPmZyYW1lOwogCWJzc2lkID0gZ2V0X2hkcl9ic3NpZChoZHIsIHJ4X21nbXQtPmZyYW1lX2xlbik7CiAJaWYgKGJzc2lkID09IE5VTEwpCi0JCXJldHVybjsKKwkJcmV0dXJuIDA7CiAKIAloYXBkID0gZ2V0X2hhcGRfYnNzaWQoaWZhY2UsIGJzc2lkKTsKIAlpZiAoaGFwZCA9PSBOVUxMKSB7CkBAIC02MDUsNyArNzMxLDcgQEAKIAkJICAgIFdMQU5fRkNfR0VUX1NUWVBFKGZjKSA9PSBXTEFOX0ZDX1NUWVBFX0JFQUNPTikKIAkJCWhhcGQgPSBpZmFjZS0+YnNzWzBdOwogCQllbHNlCi0JCQlyZXR1cm47CisJCQlyZXR1cm4gMDsKIAl9CiAKIAlvc19tZW1zZXQoJmZpLCAwLCBzaXplb2YoZmkpKTsKQEAgLTYxNCw1MyArNzQwLDI1IEBACiAKIAlpZiAoaGFwZCA9PSBIQVBEX0JST0FEQ0FTVCkgewogCQlzaXplX3QgaTsKLQkJZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspCi0JCQlpZWVlODAyXzExX21nbXQoaWZhY2UtPmJzc1tpXSwgcnhfbWdtdC0+ZnJhbWUsCi0JCQkJCXJ4X21nbXQtPmZyYW1lX2xlbiwgJmZpKTsKKwkJcmV0ID0gMDsKKwkJZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1fYnNzOyBpKyspIHsKKwkJCS8qIGlmIGJzcyBpcyBzZXQsIGRyaXZlciB3aWxsIGNhbGwgdGhpcyBmdW5jdGlvbiBmb3IKKwkJCSAqIGVhY2ggYnNzIGluZGl2aWR1YWxseS4gKi8KKwkJCWlmIChyeF9tZ210LT5kcnZfcHJpdiAmJgorCQkJICAgIChpZmFjZS0+YnNzW2ldLT5kcnZfcHJpdiAhPSByeF9tZ210LT5kcnZfcHJpdikpCisJCQkJY29udGludWU7CisKKwkJCWlmIChpZWVlODAyXzExX21nbXQoaWZhY2UtPmJzc1tpXSwgcnhfbWdtdC0+ZnJhbWUsCisJCQkJCSAgICByeF9tZ210LT5mcmFtZV9sZW4sICZmaSkgPiAwKQorCQkJCXJldCA9IDE7CisJCX0KIAl9IGVsc2UKLQkJaWVlZTgwMl8xMV9tZ210KGhhcGQsIHJ4X21nbXQtPmZyYW1lLCByeF9tZ210LT5mcmFtZV9sZW4sICZmaSk7CisJCXJldCA9IGllZWU4MDJfMTFfbWdtdChoYXBkLCByeF9tZ210LT5mcmFtZSwgcnhfbWdtdC0+ZnJhbWVfbGVuLAorCQkJCSAgICAgICZmaSk7CiAKIAlyYW5kb21fYWRkX3JhbmRvbW5lc3MoJmZpLCBzaXplb2YoZmkpKTsKLX0KIAotCi1zdGF0aWMgdm9pZCBob3N0YXBkX3J4X2FjdGlvbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAotCQkJICAgICAgc3RydWN0IHJ4X2FjdGlvbiAqcnhfYWN0aW9uKQotewotCXN0cnVjdCByeF9tZ210IHJ4X21nbXQ7Ci0JdTggKmJ1ZjsKLQlzdHJ1Y3QgaWVlZTgwMjExX2hkciAqaGRyOwotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJFVkVOVF9SWF9BQ1RJT04gREE9IiBNQUNTVFIgIiBTQT0iIE1BQ1NUUgotCQkgICAiIEJTU0lEPSIgTUFDU1RSICIgY2F0ZWdvcnk9JXUiLAotCQkgICBNQUMyU1RSKHJ4X2FjdGlvbi0+ZGEpLCBNQUMyU1RSKHJ4X2FjdGlvbi0+c2EpLAotCQkgICBNQUMyU1RSKHJ4X2FjdGlvbi0+YnNzaWQpLCByeF9hY3Rpb24tPmNhdGVnb3J5KTsKLQl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlJlY2VpdmVkIGFjdGlvbiBmcmFtZSBjb250ZW50cyIsCi0JCSAgICByeF9hY3Rpb24tPmRhdGEsIHJ4X2FjdGlvbi0+bGVuKTsKLQotCWJ1ZiA9IG9zX3phbGxvYygyNCArIDEgKyByeF9hY3Rpb24tPmxlbik7Ci0JaWYgKGJ1ZiA9PSBOVUxMKQotCQlyZXR1cm47Ci0JaGRyID0gKHN0cnVjdCBpZWVlODAyMTFfaGRyICopIGJ1ZjsKLQloZHItPmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCi0JCQkJCSAgV0xBTl9GQ19TVFlQRV9BQ1RJT04pOwotCWlmIChyeF9hY3Rpb24tPmNhdGVnb3J5ID09IFdMQU5fQUNUSU9OX1NBX1FVRVJZKSB7Ci0JCS8qCi0JCSAqIEFzc3VtZSBmcmFtZSB3YXMgcHJvdGVjdGVkOyBpdCB3b3VsZCBoYXZlIGJlZW4gZHJvcHBlZCBpZgotCQkgKiBub3QuCi0JCSAqLwotCQloZHItPmZyYW1lX2NvbnRyb2wgfD0gaG9zdF90b19sZTE2KFdMQU5fRkNfSVNXRVApOwotCX0KLQlvc19tZW1jcHkoaGRyLT5hZGRyMSwgcnhfYWN0aW9uLT5kYSwgRVRIX0FMRU4pOwotCW9zX21lbWNweShoZHItPmFkZHIyLCByeF9hY3Rpb24tPnNhLCBFVEhfQUxFTik7Ci0Jb3NfbWVtY3B5KGhkci0+YWRkcjMsIHJ4X2FjdGlvbi0+YnNzaWQsIEVUSF9BTEVOKTsKLQlidWZbMjRdID0gcnhfYWN0aW9uLT5jYXRlZ29yeTsKLQlvc19tZW1jcHkoYnVmICsgMjQgKyAxLCByeF9hY3Rpb24tPmRhdGEsIHJ4X2FjdGlvbi0+bGVuKTsKLQlvc19tZW1zZXQoJnJ4X21nbXQsIDAsIHNpemVvZihyeF9tZ210KSk7Ci0JcnhfbWdtdC5mcmFtZSA9IGJ1ZjsKLQlyeF9tZ210LmZyYW1lX2xlbiA9IDI0ICsgMSArIHJ4X2FjdGlvbi0+bGVuOwotCWhvc3RhcGRfbWdtdF9yeChoYXBkLCAmcnhfbWdtdCk7Ci0Jb3NfZnJlZShidWYpOworCXJldHVybiByZXQ7CiB9CiAKIApAQCAtNzg1LDYgKzg4Myw2NCBAQAogfQogCiAKKyNpZmRlZiBORUVEX0FQX01MTUUKKworc3RhdGljIHZvaWQgaG9zdGFwZF9ldmVudF9pZmFjZV91bmF2YWlsYWJsZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJmYWNlICVzIGlzIHVuYXZhaWxhYmxlIC0tIHN0b3BwZWQiLAorCQkgICBoYXBkLT5jb25mLT5pZmFjZSk7CisKKwlpZiAoaGFwZC0+Y3NhX2luX3Byb2dyZXNzKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDU0EgZmFpbGVkICglcyB3YXMgc3RvcHBlZCkiLAorCQkJICAgaGFwZC0+Y29uZi0+aWZhY2UpOworCQlob3N0YXBkX3N3aXRjaF9jaGFubmVsX2ZhbGxiYWNrKGhhcGQtPmlmYWNlLAorCQkJCQkJJmhhcGQtPmNzX2ZyZXFfcGFyYW1zKTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgaG9zdGFwZF9ldmVudF9kZnNfcmFkYXJfZGV0ZWN0ZWQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJICAgICBzdHJ1Y3QgZGZzX2V2ZW50ICpyYWRhcikKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRGUyByYWRhciBkZXRlY3RlZCBvbiAlZCBNSHoiLCByYWRhci0+ZnJlcSk7CisJaG9zdGFwZF9kZnNfcmFkYXJfZGV0ZWN0ZWQoaGFwZC0+aWZhY2UsIHJhZGFyLT5mcmVxLCByYWRhci0+aHRfZW5hYmxlZCwKKwkJCQkgICByYWRhci0+Y2hhbl9vZmZzZXQsIHJhZGFyLT5jaGFuX3dpZHRoLAorCQkJCSAgIHJhZGFyLT5jZjEsIHJhZGFyLT5jZjIpOworfQorCisKK3N0YXRpYyB2b2lkIGhvc3RhcGRfZXZlbnRfZGZzX2NhY19maW5pc2hlZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgICBzdHJ1Y3QgZGZzX2V2ZW50ICpyYWRhcikKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRGUyBDQUMgZmluaXNoZWQgb24gJWQgTUh6IiwgcmFkYXItPmZyZXEpOworCWhvc3RhcGRfZGZzX2NvbXBsZXRlX2NhYyhoYXBkLT5pZmFjZSwgMSwgcmFkYXItPmZyZXEsIHJhZGFyLT5odF9lbmFibGVkLAorCQkJCSByYWRhci0+Y2hhbl9vZmZzZXQsIHJhZGFyLT5jaGFuX3dpZHRoLAorCQkJCSByYWRhci0+Y2YxLCByYWRhci0+Y2YyKTsKK30KKworCitzdGF0aWMgdm9pZCBob3N0YXBkX2V2ZW50X2Rmc19jYWNfYWJvcnRlZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgIHN0cnVjdCBkZnNfZXZlbnQgKnJhZGFyKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiREZTIENBQyBhYm9ydGVkIG9uICVkIE1IeiIsIHJhZGFyLT5mcmVxKTsKKwlob3N0YXBkX2Rmc19jb21wbGV0ZV9jYWMoaGFwZC0+aWZhY2UsIDAsIHJhZGFyLT5mcmVxLCByYWRhci0+aHRfZW5hYmxlZCwKKwkJCQkgcmFkYXItPmNoYW5fb2Zmc2V0LCByYWRhci0+Y2hhbl93aWR0aCwKKwkJCQkgcmFkYXItPmNmMSwgcmFkYXItPmNmMik7Cit9CisKKworc3RhdGljIHZvaWQgaG9zdGFwZF9ldmVudF9kZnNfbm9wX2ZpbmlzaGVkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgIHN0cnVjdCBkZnNfZXZlbnQgKnJhZGFyKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiREZTIE5PUCBmaW5pc2hlZCBvbiAlZCBNSHoiLCByYWRhci0+ZnJlcSk7CisJaG9zdGFwZF9kZnNfbm9wX2ZpbmlzaGVkKGhhcGQtPmlmYWNlLCByYWRhci0+ZnJlcSwgcmFkYXItPmh0X2VuYWJsZWQsCisJCQkJIHJhZGFyLT5jaGFuX29mZnNldCwgcmFkYXItPmNoYW5fd2lkdGgsCisJCQkJIHJhZGFyLT5jZjEsIHJhZGFyLT5jZjIpOworfQorCisjZW5kaWYgLyogTkVFRF9BUF9NTE1FICovCisKKwogdm9pZCB3cGFfc3VwcGxpY2FudF9ldmVudCh2b2lkICpjdHgsIGVudW0gd3BhX2V2ZW50X3R5cGUgZXZlbnQsCiAJCQkgIHVuaW9uIHdwYV9ldmVudF9kYXRhICpkYXRhKQogewpAQCAtODU4LDEwICsxMDE0LDE2IEBACiAJCQkJCSAgICBkYXRhLT5yeF9mcm9tX3Vua25vd24uYWRkciwKIAkJCQkJICAgIGRhdGEtPnJ4X2Zyb21fdW5rbm93bi53ZHMpOwogCQlicmVhazsKLQljYXNlIEVWRU5UX1JYX01HTVQ6Ci0JCWhvc3RhcGRfbWdtdF9yeChoYXBkLCAmZGF0YS0+cnhfbWdtdCk7Ci0JCWJyZWFrOwogI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLworCWNhc2UgRVZFTlRfUlhfTUdNVDoKKwkJaWYgKCFkYXRhLT5yeF9tZ210LmZyYW1lKQorCQkJYnJlYWs7CisjaWZkZWYgTkVFRF9BUF9NTE1FCisJCWlmIChob3N0YXBkX21nbXRfcngoaGFwZCwgJmRhdGEtPnJ4X21nbXQpID4gMCkKKwkJCWJyZWFrOworI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLworCQlob3N0YXBkX2FjdGlvbl9yeChoYXBkLCAmZGF0YS0+cnhfbWdtdCk7CisJCWJyZWFrOwogCWNhc2UgRVZFTlRfUlhfUFJPQkVfUkVROgogCQlpZiAoZGF0YS0+cnhfcHJvYmVfcmVxLnNhID09IE5VTEwgfHwKIAkJICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZSA9PSBOVUxMKQpAQCAtOTAwLDE1ICsxMDYyLDYgQEAKIAkJCWJyZWFrOwogCQlob3N0YXBkX2V2ZW50X3N0YV9sb3dfYWNrKGhhcGQsIGRhdGEtPmxvd19hY2suYWRkcik7CiAJCWJyZWFrOwotCWNhc2UgRVZFTlRfUlhfQUNUSU9OOgotCQlpZiAoZGF0YS0+cnhfYWN0aW9uLmRhID09IE5VTEwgfHwgZGF0YS0+cnhfYWN0aW9uLnNhID09IE5VTEwgfHwKLQkJICAgIGRhdGEtPnJ4X2FjdGlvbi5ic3NpZCA9PSBOVUxMKQotCQkJYnJlYWs7Ci0jaWZkZWYgTkVFRF9BUF9NTE1FCi0JCWhvc3RhcGRfcnhfYWN0aW9uKGhhcGQsICZkYXRhLT5yeF9hY3Rpb24pOwotI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLwotCQlob3N0YXBkX2FjdGlvbl9yeChoYXBkLCAmZGF0YS0+cnhfYWN0aW9uKTsKLQkJYnJlYWs7CiAJY2FzZSBFVkVOVF9BVVRIOgogCQlob3N0YXBkX25vdGlmX2F1dGgoaGFwZCwgJmRhdGEtPmF1dGgpOwogCQlicmVhazsKQEAgLTkxNyw3ICsxMDcwLDEwIEBACiAJCQlicmVhazsKIAkJaG9zdGFwZF9ldmVudF9jaF9zd2l0Y2goaGFwZCwgZGF0YS0+Y2hfc3dpdGNoLmZyZXEsCiAJCQkJCWRhdGEtPmNoX3N3aXRjaC5odF9lbmFibGVkLAotCQkJCQlkYXRhLT5jaF9zd2l0Y2guY2hfb2Zmc2V0KTsKKwkJCQkJZGF0YS0+Y2hfc3dpdGNoLmNoX29mZnNldCwKKwkJCQkJZGF0YS0+Y2hfc3dpdGNoLmNoX3dpZHRoLAorCQkJCQlkYXRhLT5jaF9zd2l0Y2guY2YxLAorCQkJCQlkYXRhLT5jaF9zd2l0Y2guY2YyKTsKIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9DT05ORUNUX0ZBSUxFRF9SRUFTT046CiAJCWlmICghZGF0YSkKQEAgLTkyOSw2ICsxMDg1LDM5IEBACiAJY2FzZSBFVkVOVF9TVVJWRVk6CiAJCWhvc3RhcGRfZXZlbnRfZ2V0X3N1cnZleShoYXBkLCAmZGF0YS0+c3VydmV5X3Jlc3VsdHMpOwogCQlicmVhazsKKyNpZmRlZiBORUVEX0FQX01MTUUKKwljYXNlIEVWRU5UX0lOVEVSRkFDRV9VTkFWQUlMQUJMRToKKwkJaG9zdGFwZF9ldmVudF9pZmFjZV91bmF2YWlsYWJsZShoYXBkKTsKKwkJYnJlYWs7CisJY2FzZSBFVkVOVF9ERlNfUkFEQVJfREVURUNURUQ6CisJCWlmICghZGF0YSkKKwkJCWJyZWFrOworCQlob3N0YXBkX2V2ZW50X2Rmc19yYWRhcl9kZXRlY3RlZChoYXBkLCAmZGF0YS0+ZGZzX2V2ZW50KTsKKwkJYnJlYWs7CisJY2FzZSBFVkVOVF9ERlNfQ0FDX0ZJTklTSEVEOgorCQlpZiAoIWRhdGEpCisJCQlicmVhazsKKwkJaG9zdGFwZF9ldmVudF9kZnNfY2FjX2ZpbmlzaGVkKGhhcGQsICZkYXRhLT5kZnNfZXZlbnQpOworCQlicmVhazsKKwljYXNlIEVWRU5UX0RGU19DQUNfQUJPUlRFRDoKKwkJaWYgKCFkYXRhKQorCQkJYnJlYWs7CisJCWhvc3RhcGRfZXZlbnRfZGZzX2NhY19hYm9ydGVkKGhhcGQsICZkYXRhLT5kZnNfZXZlbnQpOworCQlicmVhazsKKwljYXNlIEVWRU5UX0RGU19OT1BfRklOSVNIRUQ6CisJCWlmICghZGF0YSkKKwkJCWJyZWFrOworCQlob3N0YXBkX2V2ZW50X2Rmc19ub3BfZmluaXNoZWQoaGFwZCwgJmRhdGEtPmRmc19ldmVudCk7CisJCWJyZWFrOworCWNhc2UgRVZFTlRfQ0hBTk5FTF9MSVNUX0NIQU5HRUQ6CisJCS8qIGNoYW5uZWwgbGlzdCBjaGFuZ2VkIChyZWd1bGF0b3J5PyksIHVwZGF0ZSBjaGFubmVsIGxpc3QgKi8KKwkJLyogVE9ETzogY2hlY2sgdGhpcy4gaG9zdGFwZF9nZXRfaHdfZmVhdHVyZXMoKSBpbml0aWFsaXplcworCQkgKiB0b28gbXVjaCBzdHVmZi4gKi8KKwkJLyogaG9zdGFwZF9nZXRfaHdfZmVhdHVyZXMoaGFwZC0+aWZhY2UpOyAqLworCQlob3N0YXBkX2NoYW5uZWxfbGlzdF91cGRhdGVkKAorCQkJaGFwZC0+aWZhY2UsIGRhdGEtPmNoYW5uZWxfbGlzdF9jaGFuZ2VkLmluaXRpYXRvcik7CisJCWJyZWFrOworI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLwogCWRlZmF1bHQ6CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVW5rbm93biBldmVudCAlZCIsIGV2ZW50KTsKIAkJYnJlYWs7CmRpZmYgLS1naXQgYS9zcmMvYXAvZWFwX3VzZXJfZGIuYyBiL3NyYy9hcC9lYXBfdXNlcl9kYi5jCmluZGV4IDc5ZDUwZTUuLjU1OWQ3N2YgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9lYXBfdXNlcl9kYi5jCisrKyBiL3NyYy9hcC9lYXBfdXNlcl9kYi5jCkBAIC04MywxMiArODMsMTQgQEAKIAogCWZvciAoaSA9IDA7IGkgPCBhcmdjOyBpKyspIHsKIAkJaWYgKG9zX3N0cmNtcChjb2xbaV0sICJwYXNzd29yZCIpID09IDAgJiYgYXJndltpXSkgewotCQkJb3NfZnJlZSh1c2VyLT5wYXNzd29yZCk7CisJCQliaW5fY2xlYXJfZnJlZSh1c2VyLT5wYXNzd29yZCwgdXNlci0+cGFzc3dvcmRfbGVuKTsKIAkJCXVzZXItPnBhc3N3b3JkX2xlbiA9IG9zX3N0cmxlbihhcmd2W2ldKTsKIAkJCXVzZXItPnBhc3N3b3JkID0gKHU4ICopIG9zX3N0cmR1cChhcmd2W2ldKTsKIAkJCXVzZXItPm5leHQgPSAodm9pZCAqKSAxOwogCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChjb2xbaV0sICJtZXRob2RzIikgPT0gMCAmJiBhcmd2W2ldKSB7CiAJCQlzZXRfdXNlcl9tZXRob2RzKHVzZXIsIGFyZ3ZbaV0pOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChjb2xbaV0sICJyZW1lZGlhdGlvbiIpID09IDAgJiYgYXJndltpXSkgeworCQkJdXNlci0+cmVtZWRpYXRpb24gPSBzdHJsZW4oYXJndltpXSkgPiAwOwogCQl9CiAJfQogCkBAIC0xMTYsNyArMTE4LDcgQEAKIAlpZiAobGVuIDw9IHVzZXItPmlkZW50aXR5X2xlbiAmJgogCSAgICBvc19tZW1jbXAoYXJndltpZF0sIHVzZXItPmlkZW50aXR5LCBsZW4pID09IDAgJiYKIAkgICAgKHVzZXItPnBhc3N3b3JkID09IE5VTEwgfHwgbGVuID4gdXNlci0+cGFzc3dvcmRfbGVuKSkgewotCQlvc19mcmVlKHVzZXItPnBhc3N3b3JkKTsKKwkJYmluX2NsZWFyX2ZyZWUodXNlci0+cGFzc3dvcmQsIHVzZXItPnBhc3N3b3JkX2xlbik7CiAJCXVzZXItPnBhc3N3b3JkX2xlbiA9IG9zX3N0cmxlbihhcmd2W2lkXSk7CiAJCXVzZXItPnBhc3N3b3JkID0gKHU4ICopIG9zX3N0cmR1cChhcmd2W2lkXSk7CiAJCXVzZXItPm5leHQgPSAodm9pZCAqKSAxOwpAQCAtMTU2LDggKzE1OCwxMCBAQAogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlvc19mcmVlKGhhcGQtPnRtcF9lYXBfdXNlci5pZGVudGl0eSk7Ci0Jb3NfZnJlZShoYXBkLT50bXBfZWFwX3VzZXIucGFzc3dvcmQpOworCWJpbl9jbGVhcl9mcmVlKGhhcGQtPnRtcF9lYXBfdXNlci5pZGVudGl0eSwKKwkJICAgICAgIGhhcGQtPnRtcF9lYXBfdXNlci5pZGVudGl0eV9sZW4pOworCWJpbl9jbGVhcl9mcmVlKGhhcGQtPnRtcF9lYXBfdXNlci5wYXNzd29yZCwKKwkJICAgICAgIGhhcGQtPnRtcF9lYXBfdXNlci5wYXNzd29yZF9sZW4pOwogCW9zX21lbXNldCgmaGFwZC0+dG1wX2VhcF91c2VyLCAwLCBzaXplb2YoaGFwZC0+dG1wX2VhcF91c2VyKSk7CiAJaGFwZC0+dG1wX2VhcF91c2VyLnBoYXNlMiA9IHBoYXNlMjsKIAloYXBkLT50bXBfZWFwX3VzZXIuaWRlbnRpdHkgPSBvc196YWxsb2MoaWRlbnRpdHlfbGVuICsgMSk7CkBAIC0xNzMsOCArMTc3LDggQEAKIAl9CiAKIAlvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLAotCQkgICAgIlNFTEVDVCBwYXNzd29yZCxtZXRob2RzIEZST00gdXNlcnMgV0hFUkUgIgotCQkgICAgImlkZW50aXR5PSclcycgQU5EIHBoYXNlMj0lZDsiLCBpZF9zdHIsIHBoYXNlMik7CisJCSAgICAiU0VMRUNUICogRlJPTSB1c2VycyBXSEVSRSBpZGVudGl0eT0nJXMnIEFORCBwaGFzZTI9JWQ7IiwKKwkJICAgIGlkX3N0ciwgcGhhc2UyKTsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRCOiAlcyIsIGNtZCk7CiAJaWYgKHNxbGl0ZTNfZXhlYyhkYiwgY21kLCBnZXRfdXNlcl9jYiwgJmhhcGQtPnRtcF9lYXBfdXNlciwgTlVMTCkgIT0KIAkgICAgU1FMSVRFX09LKSB7CmRpZmYgLS1naXQgYS9zcmMvYXAvZ2FzX3NlcnYuYyBiL3NyYy9hcC9nYXNfc2Vydi5jCmluZGV4IGIzNTc0YmEuLmFkMDcxMDcgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9nYXNfc2Vydi5jCisrKyBiL3NyYy9hcC9nYXNfc2Vydi5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIEdlbmVyaWMgYWR2ZXJ0aXNlbWVudCBzZXJ2aWNlIChHQVMpIHNlcnZlcgotICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTIsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAxMS0yMDE0LCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTE5LDYgKzE5LDEzIEBACiAjaW5jbHVkZSAiZ2FzX3NlcnYuaCIKIAogCitzdGF0aWMgdm9pZCBjb252ZXJ0X3RvX3Byb3RlY3RlZF9kdWFsKHN0cnVjdCB3cGFidWYgKm1zZykKK3sKKwl1OCAqY2F0ZWcgPSB3cGFidWZfbWhlYWRfdTgobXNnKTsKKwkqY2F0ZWcgPSBXTEFOX0FDVElPTl9QUk9URUNURURfRFVBTDsKK30KKworCiBzdGF0aWMgc3RydWN0IGdhc19kaWFsb2dfaW5mbyAqCiBnYXNfZGlhbG9nX2NyZWF0ZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkciwgdTggZGlhbG9nX3Rva2VuKQogewpAQCAtNDYsNiArNTMsOCBAQAogCQkgKiBpdCB0byBiZSB0aGF0IGxvbmcuCiAJCSAqLwogCQlhcF9zdGFfc2Vzc2lvbl90aW1lb3V0KGhhcGQsIHN0YSwgNSk7CisJfSBlbHNlIHsKKwkJYXBfc3RhX3JlcGxlbmlzaF90aW1lb3V0KGhhcGQsIHN0YSwgNSk7CiAJfQogCiAJaWYgKHN0YS0+Z2FzX2RpYWxvZyA9PSBOVUxMKSB7CkBAIC02Miw3ICs3MSw2IEBACiAJCQljb250aW51ZTsKIAkJZGlhID0gJnN0YS0+Z2FzX2RpYWxvZ1tpXTsKIAkJZGlhLT52YWxpZCA9IDE7Ci0JCWRpYS0+aW5kZXggPSBpOwogCQlkaWEtPmRpYWxvZ190b2tlbiA9IGRpYWxvZ190b2tlbjsKIAkJc3RhLT5nYXNfZGlhbG9nX25leHQgPSAoKytpID09IEdBU19ESUFMT0dfTUFYKSA/IDAgOiBpOwogCQlyZXR1cm4gZGlhOwpAQCAtMTUwLDYgKzE1OCwxMCBAQAogCQl3cGFidWZfcHV0X3U4KGJ1ZiwgSFMyMF9TVFlQRV9OQUlfSE9NRV9SRUFMTV9RVUVSWSk7CiAJaWYgKGhhcGQtPmNvbmYtPmhzMjBfb3BlcmF0aW5nX2NsYXNzKQogCQl3cGFidWZfcHV0X3U4KGJ1ZiwgSFMyMF9TVFlQRV9PUEVSQVRJTkdfQ0xBU1MpOworCWlmIChoYXBkLT5jb25mLT5oczIwX29zdV9wcm92aWRlcnNfY291bnQpCisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBIUzIwX1NUWVBFX09TVV9QUk9WSURFUlNfTElTVCk7CisJaWYgKGhhcGQtPmNvbmYtPmhzMjBfaWNvbnNfY291bnQpCisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBIUzIwX1NUWVBFX0lDT05fUkVRVUVTVCk7CiAJZ2FzX2FucXBfc2V0X2VsZW1lbnRfbGVuKGJ1ZiwgbGVuKTsKIH0KICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwpAQCAtNDAyLDcgKzQxNCw3IEBACiAJCQlnYXNfYW5xcF9zZXRfZWxlbWVudF9sZW4oYnVmLCByZWFsbV9kYXRhX2xlbik7CiAJCX0KIAkJZ2FzX2FucXBfc2V0X2VsZW1lbnRfbGVuKGJ1ZiwgbGVuKTsKLQl9IGVsc2UgaWYgKG5haV9ob21lX3JlYWxtICYmIGhhcGQtPmNvbmYtPm5haV9yZWFsbV9kYXRhKSB7CisJfSBlbHNlIGlmIChuYWlfaG9tZV9yZWFsbSAmJiBoYXBkLT5jb25mLT5uYWlfcmVhbG1fZGF0YSAmJiBob21lX3JlYWxtKSB7CiAJCWhzMjBfYWRkX25haV9ob21lX3JlYWxtX21hdGNoZXMoaGFwZCwgYnVmLCBob21lX3JlYWxtLAogCQkJCQkJaG9tZV9yZWFsbV9sZW4pOwogCX0KQEAgLTUwNSwxOCArNTE3LDE4OCBAQAogCX0KIH0KIAorCitzdGF0aWMgdm9pZCBhbnFwX2FkZF9vc3VfcHJvdmlkZXIoc3RydWN0IHdwYWJ1ZiAqYnVmLAorCQkJCSAgc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzLAorCQkJCSAgc3RydWN0IGhzMjBfb3N1X3Byb3ZpZGVyICpwKQoreworCXU4ICpsZW4sICpsZW4yLCAqY291bnQ7CisJdW5zaWduZWQgaW50IGk7CisKKwlsZW4gPSB3cGFidWZfcHV0KGJ1ZiwgMik7IC8qIE9TVSBQcm92aWRlciBMZW5ndGggdG8gYmUgZmlsbGVkICovCisKKwkvKiBPU1UgRnJpZW5kbHkgTmFtZSBEdXBsZXMgKi8KKwlsZW4yID0gd3BhYnVmX3B1dChidWYsIDIpOworCWZvciAoaSA9IDA7IGkgPCBwLT5mcmllbmRseV9uYW1lX2NvdW50OyBpKyspIHsKKwkJc3RydWN0IGhvc3RhcGRfbGFuZ19zdHJpbmcgKnMgPSAmcC0+ZnJpZW5kbHlfbmFtZVtpXTsKKwkJd3BhYnVmX3B1dF91OChidWYsIDMgKyBzLT5uYW1lX2xlbik7CisJCXdwYWJ1Zl9wdXRfZGF0YShidWYsIHMtPmxhbmcsIDMpOworCQl3cGFidWZfcHV0X2RhdGEoYnVmLCBzLT5uYW1lLCBzLT5uYW1lX2xlbik7CisJfQorCVdQQV9QVVRfTEUxNihsZW4yLCAodTggKikgd3BhYnVmX3B1dChidWYsIDApIC0gbGVuMiAtIDIpOworCisJLyogT1NVIFNlcnZlciBVUkkgKi8KKwlpZiAocC0+c2VydmVyX3VyaSkgeworCQl3cGFidWZfcHV0X3U4KGJ1Ziwgb3Nfc3RybGVuKHAtPnNlcnZlcl91cmkpKTsKKwkJd3BhYnVmX3B1dF9zdHIoYnVmLCBwLT5zZXJ2ZXJfdXJpKTsKKwl9IGVsc2UKKwkJd3BhYnVmX3B1dF91OChidWYsIDApOworCisJLyogT1NVIE1ldGhvZCBMaXN0ICovCisJY291bnQgPSB3cGFidWZfcHV0KGJ1ZiwgMSk7CisJZm9yIChpID0gMDsgcC0+bWV0aG9kX2xpc3RbaV0gPj0gMDsgaSsrKQorCQl3cGFidWZfcHV0X3U4KGJ1ZiwgcC0+bWV0aG9kX2xpc3RbaV0pOworCSpjb3VudCA9IGk7CisKKwkvKiBJY29ucyBBdmFpbGFibGUgKi8KKwlsZW4yID0gd3BhYnVmX3B1dChidWYsIDIpOworCWZvciAoaSA9IDA7IGkgPCBwLT5pY29uc19jb3VudDsgaSsrKSB7CisJCXNpemVfdCBqOworCQlzdHJ1Y3QgaHMyMF9pY29uICppY29uID0gTlVMTDsKKworCQlmb3IgKGogPSAwOyBqIDwgYnNzLT5oczIwX2ljb25zX2NvdW50ICYmICFpY29uOyBqKyspIHsKKwkJCWlmIChvc19zdHJjbXAocC0+aWNvbnNbaV0sIGJzcy0+aHMyMF9pY29uc1tqXS5uYW1lKSA9PQorCQkJICAgIDApCisJCQkJaWNvbiA9ICZic3MtPmhzMjBfaWNvbnNbal07CisJCX0KKwkJaWYgKCFpY29uKQorCQkJY29udGludWU7IC8qIGljb24gaW5mbyBub3QgZm91bmQgKi8KKworCQl3cGFidWZfcHV0X2xlMTYoYnVmLCBpY29uLT53aWR0aCk7CisJCXdwYWJ1Zl9wdXRfbGUxNihidWYsIGljb24tPmhlaWdodCk7CisJCXdwYWJ1Zl9wdXRfZGF0YShidWYsIGljb24tPmxhbmd1YWdlLCAzKTsKKwkJd3BhYnVmX3B1dF91OChidWYsIG9zX3N0cmxlbihpY29uLT50eXBlKSk7CisJCXdwYWJ1Zl9wdXRfc3RyKGJ1ZiwgaWNvbi0+dHlwZSk7CisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBvc19zdHJsZW4oaWNvbi0+bmFtZSkpOworCQl3cGFidWZfcHV0X3N0cihidWYsIGljb24tPm5hbWUpOworCX0KKwlXUEFfUFVUX0xFMTYobGVuMiwgKHU4ICopIHdwYWJ1Zl9wdXQoYnVmLCAwKSAtIGxlbjIgLSAyKTsKKworCS8qIE9TVV9OQUkgKi8KKwlpZiAocC0+b3N1X25haSkgeworCQl3cGFidWZfcHV0X3U4KGJ1Ziwgb3Nfc3RybGVuKHAtPm9zdV9uYWkpKTsKKwkJd3BhYnVmX3B1dF9zdHIoYnVmLCBwLT5vc3VfbmFpKTsKKwl9IGVsc2UKKwkJd3BhYnVmX3B1dF91OChidWYsIDApOworCisJLyogT1NVIFNlcnZpY2UgRGVzY3JpcHRpb24gRHVwbGVzICovCisJbGVuMiA9IHdwYWJ1Zl9wdXQoYnVmLCAyKTsKKwlmb3IgKGkgPSAwOyBpIDwgcC0+c2VydmljZV9kZXNjX2NvdW50OyBpKyspIHsKKwkJc3RydWN0IGhvc3RhcGRfbGFuZ19zdHJpbmcgKnMgPSAmcC0+c2VydmljZV9kZXNjW2ldOworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgMyArIHMtPm5hbWVfbGVuKTsKKwkJd3BhYnVmX3B1dF9kYXRhKGJ1Ziwgcy0+bGFuZywgMyk7CisJCXdwYWJ1Zl9wdXRfZGF0YShidWYsIHMtPm5hbWUsIHMtPm5hbWVfbGVuKTsKKwl9CisJV1BBX1BVVF9MRTE2KGxlbjIsICh1OCAqKSB3cGFidWZfcHV0KGJ1ZiwgMCkgLSBsZW4yIC0gMik7CisKKwlXUEFfUFVUX0xFMTYobGVuLCAodTggKikgd3BhYnVmX3B1dChidWYsIDApIC0gbGVuIC0gMik7Cit9CisKKworc3RhdGljIHZvaWQgYW5xcF9hZGRfb3N1X3Byb3ZpZGVyc19saXN0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCXN0cnVjdCB3cGFidWYgKmJ1ZikKK3sKKwlpZiAoaGFwZC0+Y29uZi0+aHMyMF9vc3VfcHJvdmlkZXJzX2NvdW50KSB7CisJCXNpemVfdCBpOworCQl1OCAqbGVuID0gZ2FzX2FucXBfYWRkX2VsZW1lbnQoYnVmLCBBTlFQX1ZFTkRPUl9TUEVDSUZJQyk7CisJCXdwYWJ1Zl9wdXRfYmUyNChidWYsIE9VSV9XRkEpOworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgSFMyMF9BTlFQX09VSV9UWVBFKTsKKwkJd3BhYnVmX3B1dF91OChidWYsIEhTMjBfU1RZUEVfT1NVX1BST1ZJREVSU19MSVNUKTsKKwkJd3BhYnVmX3B1dF91OChidWYsIDApOyAvKiBSZXNlcnZlZCAqLworCisJCS8qIE9TVSBTU0lEICovCisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBoYXBkLT5jb25mLT5vc3Vfc3NpZF9sZW4pOworCQl3cGFidWZfcHV0X2RhdGEoYnVmLCBoYXBkLT5jb25mLT5vc3Vfc3NpZCwKKwkJCQloYXBkLT5jb25mLT5vc3Vfc3NpZF9sZW4pOworCisJCS8qIE51bWJlciBvZiBPU1UgUHJvdmlkZXJzICovCisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBoYXBkLT5jb25mLT5oczIwX29zdV9wcm92aWRlcnNfY291bnQpOworCisJCWZvciAoaSA9IDA7IGkgPCBoYXBkLT5jb25mLT5oczIwX29zdV9wcm92aWRlcnNfY291bnQ7IGkrKykgeworCQkJYW5xcF9hZGRfb3N1X3Byb3ZpZGVyKAorCQkJCWJ1ZiwgaGFwZC0+Y29uZiwKKwkJCQkmaGFwZC0+Y29uZi0+aHMyMF9vc3VfcHJvdmlkZXJzW2ldKTsKKwkJfQorCisJCWdhc19hbnFwX3NldF9lbGVtZW50X2xlbihidWYsIGxlbik7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIGFucXBfYWRkX2ljb25fYmluYXJ5X2ZpbGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgICBzdHJ1Y3Qgd3BhYnVmICpidWYsCisJCQkJICAgICAgY29uc3QgdTggKm5hbWUsIHNpemVfdCBuYW1lX2xlbikKK3sKKwlzdHJ1Y3QgaHMyMF9pY29uICppY29uOworCXNpemVfdCBpOworCXU4ICpsZW47CisKKwl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJIUyAyLjA6IFJlcXVlc3RlZCBJY29uIEZpbGVuYW1lIiwKKwkJCSAgbmFtZSwgbmFtZV9sZW4pOworCWZvciAoaSA9IDA7IGkgPCBoYXBkLT5jb25mLT5oczIwX2ljb25zX2NvdW50OyBpKyspIHsKKwkJaWNvbiA9ICZoYXBkLT5jb25mLT5oczIwX2ljb25zW2ldOworCQlpZiAobmFtZV9sZW4gPT0gb3Nfc3RybGVuKGljb24tPm5hbWUpICYmCisJCSAgICBvc19tZW1jbXAobmFtZSwgaWNvbi0+bmFtZSwgbmFtZV9sZW4pID09IDApCisJCQlicmVhazsKKwl9CisKKwlpZiAoaSA8IGhhcGQtPmNvbmYtPmhzMjBfaWNvbnNfY291bnQpCisJCWljb24gPSAmaGFwZC0+Y29uZi0+aHMyMF9pY29uc1tpXTsKKwllbHNlCisJCWljb24gPSBOVUxMOworCisJbGVuID0gZ2FzX2FucXBfYWRkX2VsZW1lbnQoYnVmLCBBTlFQX1ZFTkRPUl9TUEVDSUZJQyk7CisJd3BhYnVmX3B1dF9iZTI0KGJ1ZiwgT1VJX1dGQSk7CisJd3BhYnVmX3B1dF91OChidWYsIEhTMjBfQU5RUF9PVUlfVFlQRSk7CisJd3BhYnVmX3B1dF91OChidWYsIEhTMjBfU1RZUEVfSUNPTl9CSU5BUllfRklMRSk7CisJd3BhYnVmX3B1dF91OChidWYsIDApOyAvKiBSZXNlcnZlZCAqLworCisJaWYgKGljb24pIHsKKwkJY2hhciAqZGF0YTsKKwkJc2l6ZV90IGRhdGFfbGVuOworCisJCWRhdGEgPSBvc19yZWFkZmlsZShpY29uLT5maWxlLCAmZGF0YV9sZW4pOworCQlpZiAoZGF0YSA9PSBOVUxMIHx8IGRhdGFfbGVuID4gNjU1MzUpIHsKKwkJCXdwYWJ1Zl9wdXRfdTgoYnVmLCAyKTsgLyogRG93bmxvYWQgU3RhdHVzOgorCQkJCQkJKiBVbnNwZWNpZmllZCBmaWxlIGVycm9yICovCisJCQl3cGFidWZfcHV0X3U4KGJ1ZiwgMCk7CisJCQl3cGFidWZfcHV0X2xlMTYoYnVmLCAwKTsKKwkJfSBlbHNlIHsKKwkJCXdwYWJ1Zl9wdXRfdTgoYnVmLCAwKTsgLyogRG93bmxvYWQgU3RhdHVzOiBTdWNjZXNzICovCisJCQl3cGFidWZfcHV0X3U4KGJ1Ziwgb3Nfc3RybGVuKGljb24tPnR5cGUpKTsKKwkJCXdwYWJ1Zl9wdXRfc3RyKGJ1ZiwgaWNvbi0+dHlwZSk7CisJCQl3cGFidWZfcHV0X2xlMTYoYnVmLCBkYXRhX2xlbik7CisJCQl3cGFidWZfcHV0X2RhdGEoYnVmLCBkYXRhLCBkYXRhX2xlbik7CisJCX0KKwkJb3NfZnJlZShkYXRhKTsKKwl9IGVsc2UgeworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgMSk7IC8qIERvd25sb2FkIFN0YXR1czogRmlsZSBub3QgZm91bmQgKi8KKwkJd3BhYnVmX3B1dF91OChidWYsIDApOworCQl3cGFidWZfcHV0X2xlMTYoYnVmLCAwKTsKKwl9CisKKwlnYXNfYW5xcF9zZXRfZWxlbWVudF9sZW4oYnVmLCBsZW4pOworfQorCiAjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAogCiBzdGF0aWMgc3RydWN0IHdwYWJ1ZiAqCiBnYXNfc2Vydl9idWlsZF9nYXNfcmVzcF9wYXlsb2FkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJdW5zaWduZWQgaW50IHJlcXVlc3QsCi0JCQkJc3RydWN0IGdhc19kaWFsb2dfaW5mbyAqZGksCi0JCQkJY29uc3QgdTggKmhvbWVfcmVhbG0sIHNpemVfdCBob21lX3JlYWxtX2xlbikKKwkJCQljb25zdCB1OCAqaG9tZV9yZWFsbSwgc2l6ZV90IGhvbWVfcmVhbG1fbGVuLAorCQkJCWNvbnN0IHU4ICppY29uX25hbWUsIHNpemVfdCBpY29uX25hbWVfbGVuKQogewogCXN0cnVjdCB3cGFidWYgKmJ1ZjsKKwlzaXplX3QgbGVuOwogCi0JYnVmID0gd3BhYnVmX2FsbG9jKDE0MDApOworCWxlbiA9IDE0MDA7CisJaWYgKHJlcXVlc3QgJiAoQU5RUF9SRVFfTkFJX1JFQUxNIHwgQU5RUF9SRVFfTkFJX0hPTUVfUkVBTE0pKQorCQlsZW4gKz0gMTAwMDsKKwlpZiAocmVxdWVzdCAmIEFOUVBfUkVRX0lDT05fUkVRVUVTVCkKKwkJbGVuICs9IDY1NTM2OworCisJYnVmID0gd3BhYnVmX2FsbG9jKGxlbik7CiAJaWYgKGJ1ZiA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIApAQCAtNTUwLDQ0ICs3MzIsMzEgQEAKIAkJYW5xcF9hZGRfY29ubmVjdGlvbl9jYXBhYmlsaXR5KGhhcGQsIGJ1Zik7CiAJaWYgKHJlcXVlc3QgJiBBTlFQX1JFUV9PUEVSQVRJTkdfQ0xBU1MpCiAJCWFucXBfYWRkX29wZXJhdGluZ19jbGFzcyhoYXBkLCBidWYpOworCWlmIChyZXF1ZXN0ICYgQU5RUF9SRVFfT1NVX1BST1ZJREVSU19MSVNUKQorCQlhbnFwX2FkZF9vc3VfcHJvdmlkZXJzX2xpc3QoaGFwZCwgYnVmKTsKKwlpZiAocmVxdWVzdCAmIEFOUVBfUkVRX0lDT05fUkVRVUVTVCkKKwkJYW5xcF9hZGRfaWNvbl9iaW5hcnlfZmlsZShoYXBkLCBidWYsIGljb25fbmFtZSwgaWNvbl9uYW1lX2xlbik7CiAjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAogCXJldHVybiBidWY7CiB9CiAKIAotc3RhdGljIHZvaWQgZ2FzX3NlcnZfY2xlYXJfY2FjaGVkX2llcyh2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2N0eCkKLXsKLQlzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvICpkaWEgPSBlbG9vcF9kYXRhOwotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IFRpbWVvdXQgdHJpZ2dlcmVkLCBjbGVhcmluZyBkaWFsb2cgZm9yICIKLQkJICAgImRpYWxvZyB0b2tlbiAlZCIsIGRpYS0+ZGlhbG9nX3Rva2VuKTsKLQotCWdhc19zZXJ2X2RpYWxvZ19jbGVhcihkaWEpOwotfQotCi0KIHN0cnVjdCBhbnFwX3F1ZXJ5X2luZm8gewogCXVuc2lnbmVkIGludCByZXF1ZXN0OwotCXVuc2lnbmVkIGludCByZW1vdGVfcmVxdWVzdDsKIAljb25zdCB1OCAqaG9tZV9yZWFsbV9xdWVyeTsKIAlzaXplX3QgaG9tZV9yZWFsbV9xdWVyeV9sZW47Ci0JdTE2IHJlbW90ZV9kZWxheTsKKwljb25zdCB1OCAqaWNvbl9uYW1lOworCXNpemVfdCBpY29uX25hbWVfbGVuOwogfTsKIAogCiBzdGF0aWMgdm9pZCBzZXRfYW5xcF9yZXEodW5zaWduZWQgaW50IGJpdCwgY29uc3QgY2hhciAqbmFtZSwgaW50IGxvY2FsLAotCQkJIHVuc2lnbmVkIGludCByZW1vdGUsIHUxNiByZW1vdGVfZGVsYXksCiAJCQkgc3RydWN0IGFucXBfcXVlcnlfaW5mbyAqcWkpCiB7CiAJcWktPnJlcXVlc3QgfD0gYml0OwogCWlmIChsb2NhbCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6ICVzIChsb2NhbCkiLCBuYW1lKTsKLQl9IGVsc2UgaWYgKGJpdCAmIHJlbW90ZSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6ICVzIChyZW1vdGUpIiwgbmFtZSk7Ci0JCXFpLT5yZW1vdGVfcmVxdWVzdCB8PSBiaXQ7Ci0JCWlmIChyZW1vdGVfZGVsYXkgPiBxaS0+cmVtb3RlX2RlbGF5KQotCQkJcWktPnJlbW90ZV9kZWxheSA9IHJlbW90ZV9kZWxheTsKIAl9IGVsc2UgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6ICVzIG5vdCBhdmFpbGFibGUiLCBuYW1lKTsKIAl9CkBAIC01OTksNDMgKzc2OCwzOCBAQAogewogCXN3aXRjaCAoaW5mb19pZCkgewogCWNhc2UgQU5RUF9DQVBBQklMSVRZX0xJU1Q6Ci0JCXNldF9hbnFwX3JlcShBTlFQX1JFUV9DQVBBQklMSVRZX0xJU1QsICJDYXBhYmlsaXR5IExpc3QiLCAxLCAwLAotCQkJICAgICAwLCBxaSk7CisJCXNldF9hbnFwX3JlcShBTlFQX1JFUV9DQVBBQklMSVRZX0xJU1QsICJDYXBhYmlsaXR5IExpc3QiLCAxLAorCQkJICAgICBxaSk7CiAJCWJyZWFrOwogCWNhc2UgQU5RUF9WRU5VRV9OQU1FOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfVkVOVUVfTkFNRSwgIlZlbnVlIE5hbWUiLAotCQkJICAgICBoYXBkLT5jb25mLT52ZW51ZV9uYW1lICE9IE5VTEwsIDAsIDAsIHFpKTsKKwkJCSAgICAgaGFwZC0+Y29uZi0+dmVudWVfbmFtZSAhPSBOVUxMLCBxaSk7CiAJCWJyZWFrOwogCWNhc2UgQU5RUF9ORVRXT1JLX0FVVEhfVFlQRToKIAkJc2V0X2FucXBfcmVxKEFOUVBfUkVRX05FVFdPUktfQVVUSF9UWVBFLCAiTmV0d29yayBBdXRoIFR5cGUiLAotCQkJICAgICBoYXBkLT5jb25mLT5uZXR3b3JrX2F1dGhfdHlwZSAhPSBOVUxMLAotCQkJICAgICAwLCAwLCBxaSk7CisJCQkgICAgIGhhcGQtPmNvbmYtPm5ldHdvcmtfYXV0aF90eXBlICE9IE5VTEwsIHFpKTsKIAkJYnJlYWs7CiAJY2FzZSBBTlFQX1JPQU1JTkdfQ09OU09SVElVTToKIAkJc2V0X2FucXBfcmVxKEFOUVBfUkVRX1JPQU1JTkdfQ09OU09SVElVTSwgIlJvYW1pbmcgQ29uc29ydGl1bSIsCi0JCQkgICAgIGhhcGQtPmNvbmYtPnJvYW1pbmdfY29uc29ydGl1bSAhPSBOVUxMLCAwLCAwLCBxaSk7CisJCQkgICAgIGhhcGQtPmNvbmYtPnJvYW1pbmdfY29uc29ydGl1bSAhPSBOVUxMLCBxaSk7CiAJCWJyZWFrOwogCWNhc2UgQU5RUF9JUF9BRERSX1RZUEVfQVZBSUxBQklMSVRZOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfSVBfQUREUl9UWVBFX0FWQUlMQUJJTElUWSwKIAkJCSAgICAgIklQIEFkZHIgVHlwZSBBdmFpbGFiaWxpdHkiLAotCQkJICAgICBoYXBkLT5jb25mLT5pcGFkZHJfdHlwZV9jb25maWd1cmVkLAotCQkJICAgICAwLCAwLCBxaSk7CisJCQkgICAgIGhhcGQtPmNvbmYtPmlwYWRkcl90eXBlX2NvbmZpZ3VyZWQsIHFpKTsKIAkJYnJlYWs7CiAJY2FzZSBBTlFQX05BSV9SRUFMTToKIAkJc2V0X2FucXBfcmVxKEFOUVBfUkVRX05BSV9SRUFMTSwgIk5BSSBSZWFsbSIsCi0JCQkgICAgIGhhcGQtPmNvbmYtPm5haV9yZWFsbV9kYXRhICE9IE5VTEwsCi0JCQkgICAgIDAsIDAsIHFpKTsKKwkJCSAgICAgaGFwZC0+Y29uZi0+bmFpX3JlYWxtX2RhdGEgIT0gTlVMTCwgcWkpOwogCQlicmVhazsKIAljYXNlIEFOUVBfM0dQUF9DRUxMVUxBUl9ORVRXT1JLOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfM0dQUF9DRUxMVUxBUl9ORVRXT1JLLAogCQkJICAgICAiM0dQUCBDZWxsdWxhciBOZXR3b3JrIiwKLQkJCSAgICAgaGFwZC0+Y29uZi0+YW5xcF8zZ3BwX2NlbGxfbmV0ICE9IE5VTEwsCi0JCQkgICAgIDAsIDAsIHFpKTsKKwkJCSAgICAgaGFwZC0+Y29uZi0+YW5xcF8zZ3BwX2NlbGxfbmV0ICE9IE5VTEwsIHFpKTsKIAkJYnJlYWs7CiAJY2FzZSBBTlFQX0RPTUFJTl9OQU1FOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfRE9NQUlOX05BTUUsICJEb21haW4gTmFtZSIsCi0JCQkgICAgIGhhcGQtPmNvbmYtPmRvbWFpbl9uYW1lICE9IE5VTEwsCi0JCQkgICAgIDAsIDAsIHFpKTsKKwkJCSAgICAgaGFwZC0+Y29uZi0+ZG9tYWluX25hbWUgIT0gTlVMTCwgcWkpOwogCQlicmVhazsKIAlkZWZhdWx0OgogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IFVuc3VwcG9ydGVkIEluZm8gSWQgJXUiLApAQCAtNjY3LDI5ICs4MzEsMzAgQEAKIAlzd2l0Y2ggKHN1YnR5cGUpIHsKIAljYXNlIEhTMjBfU1RZUEVfQ0FQQUJJTElUWV9MSVNUOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfSFNfQ0FQQUJJTElUWV9MSVNULCAiSFMgQ2FwYWJpbGl0eSBMaXN0IiwKLQkJCSAgICAgMSwgMCwgMCwgcWkpOworCQkJICAgICAxLCBxaSk7CiAJCWJyZWFrOwogCWNhc2UgSFMyMF9TVFlQRV9PUEVSQVRPUl9GUklFTkRMWV9OQU1FOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfT1BFUkFUT1JfRlJJRU5ETFlfTkFNRSwKIAkJCSAgICAgIk9wZXJhdG9yIEZyaWVuZGx5IE5hbWUiLAotCQkJICAgICBoYXBkLT5jb25mLT5oczIwX29wZXJfZnJpZW5kbHlfbmFtZSAhPSBOVUxMLAotCQkJICAgICAwLCAwLCBxaSk7CisJCQkgICAgIGhhcGQtPmNvbmYtPmhzMjBfb3Blcl9mcmllbmRseV9uYW1lICE9IE5VTEwsIHFpKTsKIAkJYnJlYWs7CiAJY2FzZSBIUzIwX1NUWVBFX1dBTl9NRVRSSUNTOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfV0FOX01FVFJJQ1MsICJXQU4gTWV0cmljcyIsCi0JCQkgICAgIGhhcGQtPmNvbmYtPmhzMjBfd2FuX21ldHJpY3MgIT0gTlVMTCwKLQkJCSAgICAgMCwgMCwgcWkpOworCQkJICAgICBoYXBkLT5jb25mLT5oczIwX3dhbl9tZXRyaWNzICE9IE5VTEwsIHFpKTsKIAkJYnJlYWs7CiAJY2FzZSBIUzIwX1NUWVBFX0NPTk5FQ1RJT05fQ0FQQUJJTElUWToKIAkJc2V0X2FucXBfcmVxKEFOUVBfUkVRX0NPTk5FQ1RJT05fQ0FQQUJJTElUWSwKIAkJCSAgICAgIkNvbm5lY3Rpb24gQ2FwYWJpbGl0eSIsCiAJCQkgICAgIGhhcGQtPmNvbmYtPmhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5ICE9IE5VTEwsCi0JCQkgICAgIDAsIDAsIHFpKTsKKwkJCSAgICAgcWkpOwogCQlicmVhazsKIAljYXNlIEhTMjBfU1RZUEVfT1BFUkFUSU5HX0NMQVNTOgogCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfT1BFUkFUSU5HX0NMQVNTLCAiT3BlcmF0aW5nIENsYXNzIiwKLQkJCSAgICAgaGFwZC0+Y29uZi0+aHMyMF9vcGVyYXRpbmdfY2xhc3MgIT0gTlVMTCwKLQkJCSAgICAgMCwgMCwgcWkpOworCQkJICAgICBoYXBkLT5jb25mLT5oczIwX29wZXJhdGluZ19jbGFzcyAhPSBOVUxMLCBxaSk7CisJCWJyZWFrOworCWNhc2UgSFMyMF9TVFlQRV9PU1VfUFJPVklERVJTX0xJU1Q6CisJCXNldF9hbnFwX3JlcShBTlFQX1JFUV9PU1VfUFJPVklERVJTX0xJU1QsICJPU1UgUHJvdmlkZXJzIGxpc3QiLAorCQkJICAgICBoYXBkLT5jb25mLT5oczIwX29zdV9wcm92aWRlcnNfY291bnQsIHFpKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiBVbnN1cHBvcnRlZCBIUyAyLjAgc3VidHlwZSAldSIsCkBAIC03MTYsNiArODgxLDIzIEBACiB9CiAKIAorc3RhdGljIHZvaWQgcnhfYW5xcF9oc19pY29uX3JlcXVlc3Qoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgY29uc3QgdTggKnBvcywgY29uc3QgdTggKmVuZCwKKwkJCQkgICAgc3RydWN0IGFucXBfcXVlcnlfaW5mbyAqcWkpCit7CisJcWktPnJlcXVlc3QgfD0gQU5RUF9SRVFfSUNPTl9SRVFVRVNUOworCXFpLT5pY29uX25hbWUgPSBwb3M7CisJcWktPmljb25fbmFtZV9sZW4gPSBlbmQgLSBwb3M7CisJaWYgKGhhcGQtPmNvbmYtPmhzMjBfaWNvbnNfY291bnQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiBIUyAyLjAgSWNvbiBSZXF1ZXN0IFF1ZXJ5ICIKKwkJCSAgICIobG9jYWwpIik7CisJfSBlbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiBIUyAyLjAgSWNvbiBSZXF1ZXN0IFF1ZXJ5IG5vdCAiCisJCQkgICAiYXZhaWxhYmxlIik7CisJfQorfQorCisKIHN0YXRpYyB2b2lkIHJ4X2FucXBfdmVuZG9yX3NwZWNpZmljKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJICAgIGNvbnN0IHU4ICpwb3MsIGNvbnN0IHU4ICplbmQsCiAJCQkJICAgIHN0cnVjdCBhbnFwX3F1ZXJ5X2luZm8gKnFpKQpAQCAtNzYwLDYgKzk0Miw5IEBACiAJY2FzZSBIUzIwX1NUWVBFX05BSV9IT01FX1JFQUxNX1FVRVJZOgogCQlyeF9hbnFwX2hzX25haV9ob21lX3JlYWxtKGhhcGQsIHBvcywgZW5kLCBxaSk7CiAJCWJyZWFrOworCWNhc2UgSFMyMF9TVFlQRV9JQ09OX1JFUVVFU1Q6CisJCXJ4X2FucXBfaHNfaWNvbl9yZXF1ZXN0KGhhcGQsIHBvcywgZW5kLCBxaSk7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogVW5zdXBwb3J0ZWQgSFMgMi4wIHF1ZXJ5IHN1YnR5cGUgIgogCQkJICAgIiV1Iiwgc3VidHlwZSk7CkBAIC03NzIsMTMgKzk1NywxNCBAQAogCiBzdGF0aWMgdm9pZCBnYXNfc2Vydl9yZXFfbG9jYWxfcHJvY2Vzc2luZyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCQkgIGNvbnN0IHU4ICpzYSwgdTggZGlhbG9nX3Rva2VuLAotCQkJCQkgIHN0cnVjdCBhbnFwX3F1ZXJ5X2luZm8gKnFpKQorCQkJCQkgIHN0cnVjdCBhbnFwX3F1ZXJ5X2luZm8gKnFpLCBpbnQgcHJvdCkKIHsKIAlzdHJ1Y3Qgd3BhYnVmICpidWYsICp0eF9idWY7CiAKLQlidWYgPSBnYXNfc2Vydl9idWlsZF9nYXNfcmVzcF9wYXlsb2FkKGhhcGQsIHFpLT5yZXF1ZXN0LCBOVUxMLAorCWJ1ZiA9IGdhc19zZXJ2X2J1aWxkX2dhc19yZXNwX3BheWxvYWQoaGFwZCwgcWktPnJlcXVlc3QsCiAJCQkJCSAgICAgIHFpLT5ob21lX3JlYWxtX3F1ZXJ5LAotCQkJCQkgICAgICBxaS0+aG9tZV9yZWFsbV9xdWVyeV9sZW4pOworCQkJCQkgICAgICBxaS0+aG9tZV9yZWFsbV9xdWVyeV9sZW4sCisJCQkJCSAgICAgIHFpLT5pY29uX25hbWUsIHFpLT5pY29uX25hbWVfbGVuKTsKIAl3cGFfaGV4ZHVtcF9idWYoTVNHX01TR0RVTVAsICJBTlFQOiBMb2NhbGx5IGdlbmVyYXRlZCBBTlFQIHJlc3BvbnNlcyIsCiAJCQlidWYpOwogCWlmICghYnVmKQpAQCAtODAyLDEzICs5ODgsMTcgQEAKIAkJCQkgICAiZm9yICIgTUFDU1RSICIgKGRpYWxvZyB0b2tlbiAldSkiLAogCQkJCSAgIE1BQzJTVFIoc2EpLCBkaWFsb2dfdG9rZW4pOwogCQkJd3BhYnVmX2ZyZWUoYnVmKTsKLQkJCXJldHVybjsKKwkJCXR4X2J1ZiA9IGdhc19hbnFwX2J1aWxkX2luaXRpYWxfcmVzcF9idWYoCisJCQkJZGlhbG9nX3Rva2VuLCBXTEFOX1NUQVRVU19VTlNQRUNJRklFRF9GQUlMVVJFLAorCQkJCTAsIE5VTEwpOworCQl9IGVsc2UgeworCQkJZGktPnByb3QgPSBwcm90OworCQkJZGktPnNkX3Jlc3AgPSBidWY7CisJCQlkaS0+c2RfcmVzcF9wb3MgPSAwOworCQkJdHhfYnVmID0gZ2FzX2FucXBfYnVpbGRfaW5pdGlhbF9yZXNwX2J1ZigKKwkJCQlkaWFsb2dfdG9rZW4sIFdMQU5fU1RBVFVTX1NVQ0NFU1MsCisJCQkJY29tZWJhY2tfZGVsYXksIE5VTEwpOwogCQl9Ci0JCWRpLT5zZF9yZXNwID0gYnVmOwotCQlkaS0+c2RfcmVzcF9wb3MgPSAwOwotCQl0eF9idWYgPSBnYXNfYW5xcF9idWlsZF9pbml0aWFsX3Jlc3BfYnVmKAotCQkJZGlhbG9nX3Rva2VuLCBXTEFOX1NUQVRVU19TVUNDRVNTLCBjb21lYmFja19kZWxheSwKLQkJCU5VTEwpOwogCX0gZWxzZSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogSW5pdGlhbCByZXNwb25zZSAobm8gY29tZWJhY2spIik7CiAJCXR4X2J1ZiA9IGdhc19hbnFwX2J1aWxkX2luaXRpYWxfcmVzcF9idWYoCkBAIC04MTcsNyArMTAwNyw4IEBACiAJfQogCWlmICghdHhfYnVmKQogCQlyZXR1cm47Ci0KKwlpZiAocHJvdCkKKwkJY29udmVydF90b19wcm90ZWN0ZWRfZHVhbCh0eF9idWYpOwogCWhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLCBzYSwKIAkJCQl3cGFidWZfaGVhZCh0eF9idWYpLCB3cGFidWZfbGVuKHR4X2J1ZikpOwogCXdwYWJ1Zl9mcmVlKHR4X2J1Zik7CkBAIC04MjYsNyArMTAxNyw3IEBACiAKIHN0YXRpYyB2b2lkIGdhc19zZXJ2X3J4X2dhc19pbml0aWFsX3JlcShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCQljb25zdCB1OCAqc2EsCi0JCQkJCWNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuKQorCQkJCQljb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbiwgaW50IHByb3QpCiB7CiAJY29uc3QgdTggKnBvcyA9IGRhdGE7CiAJY29uc3QgdTggKmVuZCA9IGRhdGEgKyBsZW47CkBAIC04NzYsNiArMTA2Nyw4IEBACiAJCQlyZXR1cm47CiAJCXdwYWJ1Zl9wdXRfZGF0YShidWYsIGFkdl9wcm90bywgMiArIHNsZW4pOwogCQl3cGFidWZfcHV0X2xlMTYoYnVmLCAwKTsgLyogUXVlcnkgUmVzcG9uc2UgTGVuZ3RoICovCisJCWlmIChwcm90KQorCQkJY29udmVydF90b19wcm90ZWN0ZWRfZHVhbChidWYpOwogCQlob3N0YXBkX2Rydl9zZW5kX2FjdGlvbihoYXBkLCBoYXBkLT5pZmFjZS0+ZnJlcSwgMCwgc2EsCiAJCQkJCXdwYWJ1Zl9oZWFkKGJ1ZiksIHdwYWJ1Zl9sZW4oYnVmKSk7CiAJCXdwYWJ1Zl9mcmVlKGJ1Zik7CkBAIC05MjcsMTAwICsxMTIwLDEzIEBACiAJCXBvcyArPSBlbGVuOwogCX0KIAotCWdhc19zZXJ2X3JlcV9sb2NhbF9wcm9jZXNzaW5nKGhhcGQsIHNhLCBkaWFsb2dfdG9rZW4sICZxaSk7Ci19Ci0KLQotdm9pZCBnYXNfc2Vydl90eF9nYXNfcmVzcG9uc2Uoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmRzdCwKLQkJCSAgICAgIHN0cnVjdCBnYXNfZGlhbG9nX2luZm8gKmRpYWxvZykKLXsKLQlzdHJ1Y3Qgd3BhYnVmICpidWYsICp0eF9idWY7Ci0JdTggZGlhbG9nX3Rva2VuID0gZGlhbG9nLT5kaWFsb2dfdG9rZW47Ci0Jc2l6ZV90IGZyYWdfbGVuOwotCi0JaWYgKGRpYWxvZy0+c2RfcmVzcCA9PSBOVUxMKSB7Ci0JCWJ1ZiA9IGdhc19zZXJ2X2J1aWxkX2dhc19yZXNwX3BheWxvYWQoaGFwZCwKLQkJCQkJCSAgICAgIGRpYWxvZy0+YWxsX3JlcXVlc3RlZCwKLQkJCQkJCSAgICAgIGRpYWxvZywgTlVMTCwgMCk7Ci0JCXdwYV9oZXhkdW1wX2J1ZihNU0dfTVNHRFVNUCwgIkFOUVA6IEdlbmVyYXRlZCBBTlFQIHJlc3BvbnNlcyIsCi0JCQlidWYpOwotCQlpZiAoIWJ1ZikKLQkJCWdvdG8gdHhfZ2FzX3Jlc3BvbnNlX2RvbmU7Ci0JCWRpYWxvZy0+c2RfcmVzcCA9IGJ1ZjsKLQkJZGlhbG9nLT5zZF9yZXNwX3BvcyA9IDA7Ci0JfQotCWZyYWdfbGVuID0gd3BhYnVmX2xlbihkaWFsb2ctPnNkX3Jlc3ApIC0gZGlhbG9nLT5zZF9yZXNwX3BvczsKLQlpZiAoZnJhZ19sZW4gPiBoYXBkLT5nYXNfZnJhZ19saW1pdCB8fCBkaWFsb2ctPmNvbWViYWNrX2RlbGF5IHx8Ci0JICAgIGhhcGQtPmNvbmYtPmdhc19jb21lYmFja19kZWxheSkgewotCQl1MTYgY29tZWJhY2tfZGVsYXlfdHVzID0gZGlhbG9nLT5jb21lYmFja19kZWxheSArCi0JCQlHQVNfU0VSVl9DT01FQkFDS19ERUxBWV9GVURHRTsKLQkJdTMyIGNvbWViYWNrX2RlbGF5X3NlY3MsIGNvbWViYWNrX2RlbGF5X3VzZWNzOwotCi0JCWlmIChoYXBkLT5jb25mLT5nYXNfY29tZWJhY2tfZGVsYXkpIHsKLQkJCS8qIFRlc3RpbmcgLSBhbGxvdyBvdmVycmlkaW5nIG9mIHRoZSBkZWxheSB2YWx1ZSAqLwotCQkJY29tZWJhY2tfZGVsYXlfdHVzID0gaGFwZC0+Y29uZi0+Z2FzX2NvbWViYWNrX2RlbGF5OwotCQl9Ci0KLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IFJlc3BvbnNlIGZyYWdfbGVuICV1IChmcmFnIGxpbWl0ICIKLQkJCSAgICIldSkgYW5kIGNvbWViYWNrIGRlbGF5ICV1LCAiCi0JCQkgICAicmVxdWVzdGluZyBjb21lYmFja3MiLCAodW5zaWduZWQgaW50KSBmcmFnX2xlbiwKLQkJCSAgICh1bnNpZ25lZCBpbnQpIGhhcGQtPmdhc19mcmFnX2xpbWl0LAotCQkJICAgZGlhbG9nLT5jb21lYmFja19kZWxheSk7Ci0JCXR4X2J1ZiA9IGdhc19hbnFwX2J1aWxkX2luaXRpYWxfcmVzcF9idWYoZGlhbG9nX3Rva2VuLAotCQkJCQkJCSBXTEFOX1NUQVRVU19TVUNDRVNTLAotCQkJCQkJCSBjb21lYmFja19kZWxheV90dXMsCi0JCQkJCQkJIE5VTEwpOwotCQlpZiAodHhfYnVmKSB7Ci0JCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywKLQkJCQkiR0FTOiBUeCBHQVMgSW5pdGlhbCBSZXNwIChjb21lYmFjayA9IDEwVFUpIik7Ci0JCQlob3N0YXBkX2Rydl9zZW5kX2FjdGlvbihoYXBkLCBoYXBkLT5pZmFjZS0+ZnJlcSwgMCwKLQkJCQkJCWRzdCwKLQkJCQkJCXdwYWJ1Zl9oZWFkKHR4X2J1ZiksCi0JCQkJCQl3cGFidWZfbGVuKHR4X2J1ZikpOwotCQl9Ci0JCXdwYWJ1Zl9mcmVlKHR4X2J1Zik7Ci0KLQkJLyogc3RhcnQgYSB0aW1lciBvZiAxLjUgKiBjb21lYmFjay1kZWxheSAqLwotCQljb21lYmFja19kZWxheV90dXMgPSBjb21lYmFja19kZWxheV90dXMgKwotCQkJKGNvbWViYWNrX2RlbGF5X3R1cyAvIDIpOwotCQljb21lYmFja19kZWxheV9zZWNzID0gKGNvbWViYWNrX2RlbGF5X3R1cyAqIDEwMjQpIC8gMTAwMDAwMDsKLQkJY29tZWJhY2tfZGVsYXlfdXNlY3MgPSAoY29tZWJhY2tfZGVsYXlfdHVzICogMTAyNCkgLQotCQkJKGNvbWViYWNrX2RlbGF5X3NlY3MgKiAxMDAwMDAwKTsKLQkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChjb21lYmFja19kZWxheV9zZWNzLAotCQkJCSAgICAgICBjb21lYmFja19kZWxheV91c2VjcywKLQkJCQkgICAgICAgZ2FzX3NlcnZfY2xlYXJfY2FjaGVkX2llcywgZGlhbG9nLAotCQkJCSAgICAgICBOVUxMKTsKLQkJZ290byB0eF9nYXNfcmVzcG9uc2VfZG9uZTsKLQl9Ci0KLQlidWYgPSB3cGFidWZfYWxsb2NfY29weSh3cGFidWZfaGVhZF91OChkaWFsb2ctPnNkX3Jlc3ApICsKLQkJCQlkaWFsb2ctPnNkX3Jlc3BfcG9zLCBmcmFnX2xlbik7Ci0JaWYgKGJ1ZiA9PSBOVUxMKSB7Ci0JCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiR0FTOiBCdWZmZXIgYWxsb2NhdGlvbiAiCi0JCQkiZmFpbGVkIik7Ci0JCWdvdG8gdHhfZ2FzX3Jlc3BvbnNlX2RvbmU7Ci0JfQotCXR4X2J1ZiA9IGdhc19hbnFwX2J1aWxkX2luaXRpYWxfcmVzcF9idWYoZGlhbG9nX3Rva2VuLAotCQkJCQkJIFdMQU5fU1RBVFVTX1NVQ0NFU1MsIDAsIGJ1Zik7Ci0Jd3BhYnVmX2ZyZWUoYnVmKTsKLQlpZiAodHhfYnVmID09IE5VTEwpCi0JCWdvdG8gdHhfZ2FzX3Jlc3BvbnNlX2RvbmU7Ci0Jd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJHQVM6IFR4IEdBUyBJbml0aWFsICIKLQkJIlJlc3BvbnNlIChmcmFnX2lkICVkIGZyYWdfbGVuICVkKSIsCi0JCWRpYWxvZy0+c2RfZnJhZ19pZCwgKGludCkgZnJhZ19sZW4pOwotCWRpYWxvZy0+c2RfZnJhZ19pZCsrOwotCi0JaG9zdGFwZF9kcnZfc2VuZF9hY3Rpb24oaGFwZCwgaGFwZC0+aWZhY2UtPmZyZXEsIDAsIGRzdCwKLQkJCQl3cGFidWZfaGVhZCh0eF9idWYpLCB3cGFidWZfbGVuKHR4X2J1ZikpOwotCXdwYWJ1Zl9mcmVlKHR4X2J1Zik7Ci10eF9nYXNfcmVzcG9uc2VfZG9uZToKLQlnYXNfc2Vydl9jbGVhcl9jYWNoZWRfaWVzKGRpYWxvZywgTlVMTCk7CisJZ2FzX3NlcnZfcmVxX2xvY2FsX3Byb2Nlc3NpbmcoaGFwZCwgc2EsIGRpYWxvZ190b2tlbiwgJnFpLCBwcm90KTsKIH0KIAogCiBzdGF0aWMgdm9pZCBnYXNfc2Vydl9yeF9nYXNfY29tZWJhY2tfcmVxKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJCSBjb25zdCB1OCAqc2EsCi0JCQkJCSBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbikKKwkJCQkJIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuLCBpbnQgcHJvdCkKIHsKIAlzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvICpkaWFsb2c7CiAJc3RydWN0IHdwYWJ1ZiAqYnVmLCAqdHhfYnVmOwpAQCAtMTA1MSwzMyArMTE1Nyw2IEBACiAJCWdvdG8gc2VuZF9yZXNwOwogCX0KIAotCWlmIChkaWFsb2ctPnNkX3Jlc3AgPT0gTlVMTCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogUmVtb3RlIHJlcXVlc3QgMHgleCByZWNlaXZlZCAweCV4IiwKLQkJCSAgIGRpYWxvZy0+cmVxdWVzdGVkLCBkaWFsb2ctPnJlY2VpdmVkKTsKLQkJaWYgKChkaWFsb2ctPnJlcXVlc3RlZCAmIGRpYWxvZy0+cmVjZWl2ZWQpICE9Ci0JCSAgICBkaWFsb2ctPnJlcXVlc3RlZCkgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IERpZCBub3QgcmVjZWl2ZSByZXNwb25zZSAiCi0JCQkJICAgImZyb20gcmVtb3RlIHByb2Nlc3NpbmciKTsKLQkJCWdhc19zZXJ2X2RpYWxvZ19jbGVhcihkaWFsb2cpOwotCQkJdHhfYnVmID0gZ2FzX2FucXBfYnVpbGRfY29tZWJhY2tfcmVzcF9idWYoCi0JCQkJZGlhbG9nX3Rva2VuLAotCQkJCVdMQU5fU1RBVFVTX0dBU19SRVNQX05PVF9SRUNFSVZFRCwgMCwgMCwgMCwKLQkJCQlOVUxMKTsKLQkJCWlmICh0eF9idWYgPT0gTlVMTCkKLQkJCQlyZXR1cm47Ci0JCQlnb3RvIHNlbmRfcmVzcDsKLQkJfQotCi0JCWJ1ZiA9IGdhc19zZXJ2X2J1aWxkX2dhc19yZXNwX3BheWxvYWQoaGFwZCwKLQkJCQkJCSAgICAgIGRpYWxvZy0+YWxsX3JlcXVlc3RlZCwKLQkJCQkJCSAgICAgIGRpYWxvZywgTlVMTCwgMCk7Ci0JCXdwYV9oZXhkdW1wX2J1ZihNU0dfTVNHRFVNUCwgIkFOUVA6IEdlbmVyYXRlZCBBTlFQIHJlc3BvbnNlcyIsCi0JCQlidWYpOwotCQlpZiAoIWJ1ZikKLQkJCWdvdG8gcnhfZ2FzX2NvbWViYWNrX3JlcV9kb25lOwotCQlkaWFsb2ctPnNkX3Jlc3AgPSBidWY7Ci0JCWRpYWxvZy0+c2RfcmVzcF9wb3MgPSAwOwotCX0KIAlmcmFnX2xlbiA9IHdwYWJ1Zl9sZW4oZGlhbG9nLT5zZF9yZXNwKSAtIGRpYWxvZy0+c2RfcmVzcF9wb3M7CiAJaWYgKGZyYWdfbGVuID4gaGFwZC0+Z2FzX2ZyYWdfbGltaXQpIHsKIAkJZnJhZ19sZW4gPSBoYXBkLT5nYXNfZnJhZ19saW1pdDsKQEAgLTEwOTAsMTUgKzExNjksMTggQEAKIAlpZiAoYnVmID09IE5VTEwpIHsKIAkJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJHQVM6IEZhaWxlZCB0byBhbGxvY2F0ZSAiCiAJCQkiYnVmZmVyIik7Ci0JCWdvdG8gcnhfZ2FzX2NvbWViYWNrX3JlcV9kb25lOworCQlnYXNfc2Vydl9kaWFsb2dfY2xlYXIoZGlhbG9nKTsKKwkJcmV0dXJuOwogCX0KIAl0eF9idWYgPSBnYXNfYW5xcF9idWlsZF9jb21lYmFja19yZXNwX2J1ZihkaWFsb2dfdG9rZW4sCiAJCQkJCQkgIFdMQU5fU1RBVFVTX1NVQ0NFU1MsCiAJCQkJCQkgIGRpYWxvZy0+c2RfZnJhZ19pZCwKIAkJCQkJCSAgbW9yZSwgMCwgYnVmKTsKIAl3cGFidWZfZnJlZShidWYpOwotCWlmICh0eF9idWYgPT0gTlVMTCkKLQkJZ290byByeF9nYXNfY29tZWJhY2tfcmVxX2RvbmU7CisJaWYgKHR4X2J1ZiA9PSBOVUxMKSB7CisJCWdhc19zZXJ2X2RpYWxvZ19jbGVhcihkaWFsb2cpOworCQlyZXR1cm47CisJfQogCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiR0FTOiBUeCBHQVMgQ29tZWJhY2sgUmVzcG9uc2UgIgogCQkiKGZyYWdfaWQgJWQgbW9yZT0lZCBmcmFnX2xlbj0lZCkiLAogCQlkaWFsb2ctPnNkX2ZyYWdfaWQsIG1vcmUsIChpbnQpIGZyYWdfbGVuKTsKQEAgLTExMTgsMTMgKzEyMDAsMTEgQEAKIAl9CiAKIHNlbmRfcmVzcDoKKwlpZiAocHJvdCkKKwkJY29udmVydF90b19wcm90ZWN0ZWRfZHVhbCh0eF9idWYpOwogCWhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLCBzYSwKIAkJCQl3cGFidWZfaGVhZCh0eF9idWYpLCB3cGFidWZfbGVuKHR4X2J1ZikpOwogCXdwYWJ1Zl9mcmVlKHR4X2J1Zik7Ci0JcmV0dXJuOwotCi1yeF9nYXNfY29tZWJhY2tfcmVxX2RvbmU6Ci0JZ2FzX3NlcnZfY2xlYXJfY2FjaGVkX2llcyhkaWFsb2csIE5VTEwpOwogfQogCiAKQEAgLTExMzMsMjQgKzEyMTMsMzAgQEAKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkID0gY3R4OwogCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKLQlzaXplX3QgaGRyX2xlbjsKIAljb25zdCB1OCAqc2EsICpkYXRhOworCWludCBwcm90OwogCiAJbWdtdCA9IChjb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKikgYnVmOwotCWhkcl9sZW4gPSAoY29uc3QgdTggKikgJm1nbXQtPnUuYWN0aW9uLnUudnNfcHVibGljX2FjdGlvbi5hY3Rpb24gLSBidWY7Ci0JaWYgKGhkcl9sZW4gPiBsZW4pCisJaWYgKGxlbiA8IElFRUU4MDIxMV9IRFJMRU4gKyAyKQogCQlyZXR1cm47Ci0JaWYgKG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ICE9IFdMQU5fQUNUSU9OX1BVQkxJQykKKwlpZiAobWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgIT0gV0xBTl9BQ1RJT05fUFVCTElDICYmCisJICAgIG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ICE9IFdMQU5fQUNUSU9OX1BST1RFQ1RFRF9EVUFMKQogCQlyZXR1cm47CisJLyoKKwkgKiBOb3RlOiBQdWJsaWMgQWN0aW9uIGFuZCBQcm90ZWN0ZWQgRHVhbCBvZiBQdWJsaWMgQWN0aW9uIGZyYW1lcyBzaGFyZQorCSAqIHRoZSBzYW1lIHBheWxvYWQgc3RydWN0dXJlLCBzbyBpdCBpcyBmaW5lIHRvIHVzZSBkZWZpbml0aW9ucyBvZgorCSAqIFB1YmxpYyBBY3Rpb24gZnJhbWVzIHRvIHByb2Nlc3MgYm90aC4KKwkgKi8KKwlwcm90ID0gbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgPT0gV0xBTl9BQ1RJT05fUFJPVEVDVEVEX0RVQUw7CiAJc2EgPSBtZ210LT5zYTsKLQlsZW4gLT0gaGRyX2xlbjsKLQlkYXRhID0gJm1nbXQtPnUuYWN0aW9uLnUucHVibGljX2FjdGlvbi5hY3Rpb247CisJbGVuIC09IElFRUU4MDIxMV9IRFJMRU4gKyAxOworCWRhdGEgPSBidWYgKyBJRUVFODAyMTFfSERSTEVOICsgMTsKIAlzd2l0Y2ggKGRhdGFbMF0pIHsKIAljYXNlIFdMQU5fUEFfR0FTX0lOSVRJQUxfUkVROgotCQlnYXNfc2Vydl9yeF9nYXNfaW5pdGlhbF9yZXEoaGFwZCwgc2EsIGRhdGEgKyAxLCBsZW4gLSAxKTsKKwkJZ2FzX3NlcnZfcnhfZ2FzX2luaXRpYWxfcmVxKGhhcGQsIHNhLCBkYXRhICsgMSwgbGVuIC0gMSwgcHJvdCk7CiAJCWJyZWFrOwogCWNhc2UgV0xBTl9QQV9HQVNfQ09NRUJBQ0tfUkVROgotCQlnYXNfc2Vydl9yeF9nYXNfY29tZWJhY2tfcmVxKGhhcGQsIHNhLCBkYXRhICsgMSwgbGVuIC0gMSk7CisJCWdhc19zZXJ2X3J4X2dhc19jb21lYmFja19yZXEoaGFwZCwgc2EsIGRhdGEgKyAxLCBsZW4gLSAxLCBwcm90KTsKIAkJYnJlYWs7CiAJfQogfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2dhc19zZXJ2LmggYi9zcmMvYXAvZ2FzX3NlcnYuaAppbmRleCA0MjEzY2Y2Li40ZWMzMjAxIDEwMDY0NAotLS0gYS9zcmMvYXAvZ2FzX3NlcnYuaAorKysgYi9zcmMvYXAvZ2FzX3NlcnYuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBHZW5lcmljIGFkdmVydGlzZW1lbnQgc2VydmljZSAoR0FTKSBzZXJ2ZXIKLSAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEyLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0zNywyOSArMzcsMjIgQEAKIAkoMHgxMDAwMCA8PCBIUzIwX1NUWVBFX05BSV9IT01FX1JFQUxNX1FVRVJZKQogI2RlZmluZSBBTlFQX1JFUV9PUEVSQVRJTkdfQ0xBU1MgXAogCSgweDEwMDAwIDw8IEhTMjBfU1RZUEVfT1BFUkFUSU5HX0NMQVNTKQotCi0vKiBUbyBhY2NvdW50IGZvciBsYXRlbmNpZXMgYmV0d2VlbiBob3N0YXBkIGFuZCBleHRlcm5hbCBBTlFQIHByb2Nlc3NvciAqLwotI2RlZmluZSBHQVNfU0VSVl9DT01FQkFDS19ERUxBWV9GVURHRSAxMAotI2RlZmluZSBHQVNfU0VSVl9NSU5fQ09NRUJBQ0tfREVMQVkgMTAwIC8qIGluIFRVICovCisjZGVmaW5lIEFOUVBfUkVRX09TVV9QUk9WSURFUlNfTElTVCBcCisJKDB4MTAwMDAgPDwgSFMyMF9TVFlQRV9PU1VfUFJPVklERVJTX0xJU1QpCisjZGVmaW5lIEFOUVBfUkVRX0lDT05fUkVRVUVTVCBcCisJKDB4MTAwMDAgPDwgSFMyMF9TVFlQRV9JQ09OX1JFUVVFU1QpCiAKIHN0cnVjdCBnYXNfZGlhbG9nX2luZm8gewogCXU4IHZhbGlkOwotCXU4IGluZGV4OwogCXN0cnVjdCB3cGFidWYgKnNkX3Jlc3A7IC8qIEZyYWdtZW50ZWQgcmVzcG9uc2UgKi8KIAl1OCBkaWFsb2dfdG9rZW47CiAJc2l6ZV90IHNkX3Jlc3BfcG9zOyAvKiBPZmZzZXQgaW4gc2RfcmVzcCAqLwogCXU4IHNkX2ZyYWdfaWQ7Ci0JdTE2IGNvbWViYWNrX2RlbGF5OwotCi0JdW5zaWduZWQgaW50IHJlcXVlc3RlZDsKLQl1bnNpZ25lZCBpbnQgcmVjZWl2ZWQ7Ci0JdW5zaWduZWQgaW50IGFsbF9yZXF1ZXN0ZWQ7CisJaW50IHByb3Q7IC8qIHdoZXRoZXIgUHJvdGVjdGVkIER1YWwgb2YgUHVibGljIEFjdGlvbiBmcmFtZSBpcyB1c2VkICovCiB9OwogCiBzdHJ1Y3QgaG9zdGFwZF9kYXRhOwogCi12b2lkIGdhc19zZXJ2X3R4X2dhc19yZXNwb25zZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqZHN0LAotCQkJICAgICAgc3RydWN0IGdhc19kaWFsb2dfaW5mbyAqZGlhbG9nKTsKIHN0cnVjdCBnYXNfZGlhbG9nX2luZm8gKgogZ2FzX3NlcnZfZGlhbG9nX2ZpbmQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIsCiAJCSAgICAgdTggZGlhbG9nX3Rva2VuKTsKZGlmZiAtLWdpdCBhL3NyYy9hcC9ob3N0YXBkLmMgYi9zcmMvYXAvaG9zdGFwZC5jCmluZGV4IGZkMWNhMmIuLjI2YWNhMmIgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9ob3N0YXBkLmMKKysrIGIvc3JjL2FwL2hvc3RhcGQuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC8gSW5pdGlhbGl6YXRpb24gYW5kIGNvbmZpZ3VyYXRpb24KLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTExLDkgKzExLDEwIEBACiAjaW5jbHVkZSAidXRpbHMvY29tbW9uLmgiCiAjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCisjaW5jbHVkZSAiY29tbW9uL3dwYV9jdHJsLmgiCiAjaW5jbHVkZSAicmFkaXVzL3JhZGl1c19jbGllbnQuaCIKICNpbmNsdWRlICJyYWRpdXMvcmFkaXVzX2Rhcy5oIgotI2luY2x1ZGUgImRyaXZlcnMvZHJpdmVyLmgiCisjaW5jbHVkZSAiZWFwX3NlcnZlci90bmNzLmgiCiAjaW5jbHVkZSAiaG9zdGFwZC5oIgogI2luY2x1ZGUgImF1dGhzcnYuaCIKICNpbmNsdWRlICJzdGFfaW5mby5oIgpAQCAtMzIsMTQgKzMzLDE1IEBACiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCiAjaW5jbHVkZSAicDJwX2hvc3RhcGQuaCIKICNpbmNsdWRlICJnYXNfc2Vydi5oIgorI2luY2x1ZGUgImRmcy5oIgorI2luY2x1ZGUgImllZWU4MDJfMTEuaCIKIAogCiBzdGF0aWMgaW50IGhvc3RhcGRfZmx1c2hfb2xkX3N0YXRpb25zKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHUxNiByZWFzb24pOwogc3RhdGljIGludCBob3N0YXBkX3NldHVwX2VuY3J5cHRpb24oY2hhciAqaWZhY2UsIHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwogc3RhdGljIGludCBob3N0YXBkX2Jyb2FkY2FzdF93ZXBfY2xlYXIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7Ci0KLWV4dGVybiBpbnQgd3BhX2RlYnVnX2xldmVsOwotZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyAqd3BhX2RyaXZlcnNbXTsKK3N0YXRpYyBpbnQgc2V0dXBfaW50ZXJmYWNlMihzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpOworc3RhdGljIHZvaWQgY2hhbm5lbF9saXN0X3VwZGF0ZV90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOwogCiAKIGludCBob3N0YXBkX2Zvcl9lYWNoX2ludGVyZmFjZShzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICppbnRlcmZhY2VzLApAQCAtNjEsMTAgKzYzLDIyIEBACiAKIHN0YXRpYyB2b2lkIGhvc3RhcGRfcmVsb2FkX2JzcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQogeworCXN0cnVjdCBob3N0YXBkX3NzaWQgKnNzaWQ7CisKICNpZm5kZWYgQ09ORklHX05PX1JBRElVUwogCXJhZGl1c19jbGllbnRfcmVjb25maWcoaGFwZC0+cmFkaXVzLCBoYXBkLT5jb25mLT5yYWRpdXMpOwogI2VuZGlmIC8qIENPTkZJR19OT19SQURJVVMgKi8KIAorCXNzaWQgPSAmaGFwZC0+Y29uZi0+c3NpZDsKKwlpZiAoIXNzaWQtPndwYV9wc2tfc2V0ICYmIHNzaWQtPndwYV9wc2sgJiYgIXNzaWQtPndwYV9wc2stPm5leHQgJiYKKwkgICAgc3NpZC0+d3BhX3Bhc3NwaHJhc2Vfc2V0ICYmIHNzaWQtPndwYV9wYXNzcGhyYXNlKSB7CisJCS8qCisJCSAqIEZvcmNlIFBTSyB0byBiZSBkZXJpdmVkIGFnYWluIHNpbmNlIFNTSUQgb3IgcGFzc3BocmFzZSBtYXkKKwkJICogaGF2ZSBjaGFuZ2VkLgorCQkgKi8KKwkJb3NfZnJlZShzc2lkLT53cGFfcHNrKTsKKwkJc3NpZC0+d3BhX3BzayA9IE5VTEw7CisJfQogCWlmIChob3N0YXBkX3NldHVwX3dwYV9wc2soaGFwZC0+Y29uZikpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gcmUtY29uZmlndXJlIFdQQSBQU0sgIgogCQkJICAgImFmdGVyIHJlbG9hZGluZyBjb25maWd1cmF0aW9uIik7CkBAIC03NSw3ICs4OSw3IEBACiAJZWxzZQogCQlob3N0YXBkX3NldF9kcnZfaWVlZTgwMjF4KGhhcGQsIGhhcGQtPmNvbmYtPmlmYWNlLCAwKTsKIAotCWlmIChoYXBkLT5jb25mLT53cGEgJiYgaGFwZC0+d3BhX2F1dGggPT0gTlVMTCkgeworCWlmICgoaGFwZC0+Y29uZi0+d3BhIHx8IGhhcGQtPmNvbmYtPm9zZW4pICYmIGhhcGQtPndwYV9hdXRoID09IE5VTEwpIHsKIAkJaG9zdGFwZF9zZXR1cF93cGEoaGFwZCk7CiAJCWlmIChoYXBkLT53cGFfYXV0aCkKIAkJCXdwYV9pbml0X2tleXMoaGFwZC0+d3BhX2F1dGgpOwpAQCAtMTU5LDcgKzE3MywxOCBAQAogCWZvciAoaiA9IDA7IGogPCBpZmFjZS0+bnVtX2JzczsgaisrKSB7CiAJCWhhcGQgPSBpZmFjZS0+YnNzW2pdOwogCQloYXBkLT5pY29uZiA9IG5ld2NvbmY7Ci0JCWhhcGQtPmNvbmYgPSAmbmV3Y29uZi0+YnNzW2pdOworCQloYXBkLT5pY29uZi0+Y2hhbm5lbCA9IG9sZGNvbmYtPmNoYW5uZWw7CisJCWhhcGQtPmljb25mLT5zZWNvbmRhcnlfY2hhbm5lbCA9IG9sZGNvbmYtPnNlY29uZGFyeV9jaGFubmVsOworCQloYXBkLT5pY29uZi0+aWVlZTgwMjExbiA9IG9sZGNvbmYtPmllZWU4MDIxMW47CisJCWhhcGQtPmljb25mLT5pZWVlODAyMTFhYyA9IG9sZGNvbmYtPmllZWU4MDIxMWFjOworCQloYXBkLT5pY29uZi0+aHRfY2FwYWIgPSBvbGRjb25mLT5odF9jYXBhYjsKKwkJaGFwZC0+aWNvbmYtPnZodF9jYXBhYiA9IG9sZGNvbmYtPnZodF9jYXBhYjsKKwkJaGFwZC0+aWNvbmYtPnZodF9vcGVyX2Nod2lkdGggPSBvbGRjb25mLT52aHRfb3Blcl9jaHdpZHRoOworCQloYXBkLT5pY29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9CisJCQlvbGRjb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4OworCQloYXBkLT5pY29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcxX2lkeCA9CisJCQlvbGRjb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4OworCQloYXBkLT5jb25mID0gbmV3Y29uZi0+YnNzW2pdOwogCQlob3N0YXBkX3JlbG9hZF9ic3MoaGFwZCk7CiAJfQogCkBAIC0yMjcsNiArMjUyLDE0IEBACiAKIHN0YXRpYyB2b2lkIGhvc3RhcGRfZnJlZV9oYXBkX2RhdGEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKIHsKKwlpZiAoIWhhcGQtPnN0YXJ0ZWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICIlczogSW50ZXJmYWNlICVzIHdhc24ndCBzdGFydGVkIiwKKwkJCSAgIF9fZnVuY19fLCBoYXBkLT5jb25mLT5pZmFjZSk7CisJCXJldHVybjsKKwl9CisJaGFwZC0+c3RhcnRlZCA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzKCVzKSIsIF9fZnVuY19fLCBoYXBkLT5jb25mLT5pZmFjZSk7CiAJaWFwcF9kZWluaXQoaGFwZC0+aWFwcCk7CiAJaGFwZC0+aWFwcCA9IE5VTEw7CiAJYWNjb3VudGluZ19kZWluaXQoaGFwZCk7CkBAIC0yNDQsMTAgKzI3NywyMSBAQAogCiAJYXV0aHNydl9kZWluaXQoaGFwZCk7CiAKLQlpZiAoaGFwZC0+aW50ZXJmYWNlX2FkZGVkICYmCi0JICAgIGhvc3RhcGRfaWZfcmVtb3ZlKGhhcGQsIFdQQV9JRl9BUF9CU1MsIGhhcGQtPmNvbmYtPmlmYWNlKSkgewotCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiRmFpbGVkIHRvIHJlbW92ZSBCU1MgaW50ZXJmYWNlICVzIiwKLQkJCSAgIGhhcGQtPmNvbmYtPmlmYWNlKTsKKwlpZiAoaGFwZC0+aW50ZXJmYWNlX2FkZGVkKSB7CisJCWhhcGQtPmludGVyZmFjZV9hZGRlZCA9IDA7CisJCWlmIChob3N0YXBkX2lmX3JlbW92ZShoYXBkLCBXUEFfSUZfQVBfQlNTLCBoYXBkLT5jb25mLT5pZmFjZSkpIHsKKwkJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsCisJCQkJICAgIkZhaWxlZCB0byByZW1vdmUgQlNTIGludGVyZmFjZSAlcyIsCisJCQkJICAgaGFwZC0+Y29uZi0+aWZhY2UpOworCQkJaGFwZC0+aW50ZXJmYWNlX2FkZGVkID0gMTsKKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBTaW5jZSB0aGlzIHdhcyBhIGR5bmFtaWNhbGx5IGFkZGVkIGludGVyZmFjZSwgdGhlCisJCQkgKiBkcml2ZXIgd3JhcHBlciBtYXkgaGF2ZSByZW1vdmVkIGl0cyBpbnRlcm5hbCBpbnN0YW5jZQorCQkJICogYW5kIGhhcGQtPmRydl9wcml2IGlzIG5vdCB2YWxpZCBhbnltb3JlLgorCQkJICovCisJCQloYXBkLT5kcnZfcHJpdiA9IE5VTEw7CisJCX0KIAl9CiAKIAlvc19mcmVlKGhhcGQtPnByb2JlcmVxX2NiKTsKQEAgLTI2Nyw4ICszMTEsMTAgQEAKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAKICNpZmRlZiBDT05GSUdfU1FMSVRFCi0Jb3NfZnJlZShoYXBkLT50bXBfZWFwX3VzZXIuaWRlbnRpdHkpOwotCW9zX2ZyZWUoaGFwZC0+dG1wX2VhcF91c2VyLnBhc3N3b3JkKTsKKwliaW5fY2xlYXJfZnJlZShoYXBkLT50bXBfZWFwX3VzZXIuaWRlbnRpdHksCisJCSAgICAgICBoYXBkLT50bXBfZWFwX3VzZXIuaWRlbnRpdHlfbGVuKTsKKwliaW5fY2xlYXJfZnJlZShoYXBkLT50bXBfZWFwX3VzZXIucGFzc3dvcmQsCisJCSAgICAgICBoYXBkLT50bXBfZWFwX3VzZXIucGFzc3dvcmRfbGVuKTsKICNlbmRpZiAvKiBDT05GSUdfU1FMSVRFICovCiB9CiAKQEAgLTI3OCwxMyArMzI0LDEzIEBACiAgKiBAaGFwZDogUG9pbnRlciB0byBCU1MgZGF0YQogICoKICAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byBmcmVlIGFsbCBwZXItQlNTIGRhdGEgc3RydWN0dXJlcyBhbmQgcmVzb3VyY2VzLgotICogVGhpcyBnZXRzIGNhbGxlZCBpbiBhIGxvb3AgZm9yIGVhY2ggQlNTIGJldHdlZW4gY2FsbHMgdG8KLSAqIGhvc3RhcGRfY2xlYW51cF9pZmFjZV9wcmUoKSBhbmQgaG9zdGFwZF9jbGVhbnVwX2lmYWNlKCkgd2hlbiBhbiBpbnRlcmZhY2UKLSAqIGlzIGRlaW5pdGlhbGl6ZWQuIE1vc3Qgb2YgdGhlIG1vZHVsZXMgdGhhdCBhcmUgaW5pdGlhbGl6ZWQgaW4KLSAqIGhvc3RhcGRfc2V0dXBfYnNzKCkgYXJlIGRlaW5pdGlhbGl6ZWQgaGVyZS4KKyAqIE1vc3Qgb2YgdGhlIG1vZHVsZXMgdGhhdCBhcmUgaW5pdGlhbGl6ZWQgaW4gaG9zdGFwZF9zZXR1cF9ic3MoKSBhcmUKKyAqIGRlaW5pdGlhbGl6ZWQgaGVyZS4KICAqLwogc3RhdGljIHZvaWQgaG9zdGFwZF9jbGVhbnVwKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpCiB7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyhoYXBkPSVwICglcykpIiwgX19mdW5jX18sIGhhcGQsCisJCSAgIGhhcGQtPmNvbmYtPmlmYWNlKTsKIAlpZiAoaGFwZC0+aWZhY2UtPmludGVyZmFjZXMgJiYKIAkgICAgaGFwZC0+aWZhY2UtPmludGVyZmFjZXMtPmN0cmxfaWZhY2VfZGVpbml0KQogCQloYXBkLT5pZmFjZS0+aW50ZXJmYWNlcy0+Y3RybF9pZmFjZV9kZWluaXQoaGFwZCk7CkBAIC0yOTIsMjAgKzMzOCw5IEBACiB9CiAKIAotLyoqCi0gKiBob3N0YXBkX2NsZWFudXBfaWZhY2VfcHJlIC0gUHJlbGltaW5hcnkgcGVyLWludGVyZmFjZSBjbGVhbnVwCi0gKiBAaWZhY2U6IFBvaW50ZXIgdG8gaW50ZXJmYWNlIGRhdGEKLSAqCi0gKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBiZWZvcmUgcGVyLUJTUyBkYXRhIHN0cnVjdHVyZXMgYXJlIGRlaW5pdGlhbGl6ZWQKLSAqIHdpdGggaG9zdGFwZF9jbGVhbnVwKCkuCi0gKi8KLXN0YXRpYyB2b2lkIGhvc3RhcGRfY2xlYW51cF9pZmFjZV9wcmUoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQotewotfQotCi0KIHN0YXRpYyB2b2lkIGhvc3RhcGRfY2xlYW51cF9pZmFjZV9wYXJ0aWFsKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKIHsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzKCVwKSIsIF9fZnVuY19fLCBpZmFjZSk7CiAJaG9zdGFwZF9mcmVlX2h3X2ZlYXR1cmVzKGlmYWNlLT5od19mZWF0dXJlcywgaWZhY2UtPm51bV9od19mZWF0dXJlcyk7CiAJaWZhY2UtPmh3X2ZlYXR1cmVzID0gTlVMTDsKIAlvc19mcmVlKGlmYWNlLT5jdXJyZW50X3JhdGVzKTsKQEAgLTMyNSwxOSArMzYwLDIzIEBACiAgKi8KIHN0YXRpYyB2b2lkIGhvc3RhcGRfY2xlYW51cF9pZmFjZShzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyglcCkiLCBfX2Z1bmNfXywgaWZhY2UpOworCWVsb29wX2NhbmNlbF90aW1lb3V0KGNoYW5uZWxfbGlzdF91cGRhdGVfdGltZW91dCwgaWZhY2UsIE5VTEwpOworCiAJaG9zdGFwZF9jbGVhbnVwX2lmYWNlX3BhcnRpYWwoaWZhY2UpOwogCWhvc3RhcGRfY29uZmlnX2ZyZWUoaWZhY2UtPmNvbmYpOwogCWlmYWNlLT5jb25mID0gTlVMTDsKIAogCW9zX2ZyZWUoaWZhY2UtPmNvbmZpZ19mbmFtZSk7CiAJb3NfZnJlZShpZmFjZS0+YnNzKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBmcmVlIGlmYWNlPSVwIiwgX19mdW5jX18sIGlmYWNlKTsKIAlvc19mcmVlKGlmYWNlKTsKIH0KIAogCiBzdGF0aWMgdm9pZCBob3N0YXBkX2NsZWFyX3dlcChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQogewotCWlmIChoYXBkLT5kcnZfcHJpdikgeworCWlmIChoYXBkLT5kcnZfcHJpdiAmJiAhaGFwZC0+aWZhY2UtPmRyaXZlcl9hcF90ZWFyZG93bikgewogCQlob3N0YXBkX3NldF9wcml2YWN5KGhhcGQsIDApOwogCQlob3N0YXBkX2Jyb2FkY2FzdF93ZXBfY2xlYXIoaGFwZCk7CiAJfQpAQCAtMzg4LDExICs0MjcsMTUgQEAKIAlpZiAoaG9zdGFwZF9kcnZfbm9uZShoYXBkKSB8fCBoYXBkLT5kcnZfcHJpdiA9PSBOVUxMKQogCQlyZXR1cm4gMDsKIAotCXdwYV9kYmcoaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiRmx1c2hpbmcgb2xkIHN0YXRpb24gZW50cmllcyIpOwotCWlmIChob3N0YXBkX2ZsdXNoKGhhcGQpKSB7Ci0JCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX1dBUk5JTkcsICJDb3VsZCBub3QgY29ubmVjdCB0byAiCi0JCQkia2VybmVsIGRyaXZlciIpOwotCQlyZXQgPSAtMTsKKwlpZiAoIWhhcGQtPmlmYWNlLT5kcml2ZXJfYXBfdGVhcmRvd24pIHsKKwkJd3BhX2RiZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsCisJCQkiRmx1c2hpbmcgb2xkIHN0YXRpb24gZW50cmllcyIpOworCisJCWlmIChob3N0YXBkX2ZsdXNoKGhhcGQpKSB7CisJCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19XQVJOSU5HLAorCQkJCSJDb3VsZCBub3QgY29ubmVjdCB0byBrZXJuZWwgZHJpdmVyIik7CisJCQlyZXQgPSAtMTsKKwkJfQogCX0KIAl3cGFfZGJnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkRlYXV0aGVudGljYXRlIGFsbCBzdGF0aW9ucyIpOwogCW9zX21lbXNldChhZGRyLCAweGZmLCBFVEhfQUxFTik7CkBAIC00MDMsNiArNDQ2LDE0IEBACiB9CiAKIAorc3RhdGljIHZvaWQgaG9zdGFwZF9ic3NfZGVpbml0X25vX2ZyZWUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKKwlob3N0YXBkX2ZyZWVfc3RhcyhoYXBkKTsKKwlob3N0YXBkX2ZsdXNoX29sZF9zdGF0aW9ucyhoYXBkLCBXTEFOX1JFQVNPTl9ERUFVVEhfTEVBVklORyk7CisJaG9zdGFwZF9jbGVhcl93ZXAoaGFwZCk7Cit9CisKKwogLyoqCiAgKiBob3N0YXBkX3ZhbGlkYXRlX2Jzc2lkX2NvbmZpZ3VyYXRpb24gLSBWYWxpZGF0ZSBCU1NJRCBjb25maWd1cmF0aW9uCiAgKiBAaWZhY2U6IFBvaW50ZXIgdG8gaW50ZXJmYWNlIGRhdGEKQEAgLTQyOSw3ICs0ODAsNyBAQAogCS8qIERldGVybWluZSB0aGUgYml0cyBuZWNlc3NhcnkgdG8gYW55IGNvbmZpZ3VyZWQgQlNTSURzLAogCSAgIGlmIHRoZXkgYXJlIGhpZ2hlciB0aGFuIHRoZSBudW1iZXIgb2YgQlNTSURzLiAqLwogCWZvciAoaiA9IDA7IGogPCBpZmFjZS0+Y29uZi0+bnVtX2JzczsgaisrKSB7Ci0JCWlmIChob3N0YXBkX21hY19jb21wX2VtcHR5KGlmYWNlLT5jb25mLT5ic3Nbal0uYnNzaWQpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfbWFjX2NvbXBfZW1wdHkoaWZhY2UtPmNvbmYtPmJzc1tqXS0+YnNzaWQpID09IDApIHsKIAkJCWlmIChqKQogCQkJCWF1dG9fYWRkcisrOwogCQkJY29udGludWU7CkBAIC00MzcsNyArNDg4LDcgQEAKIAogCQlmb3IgKGkgPSAwOyBpIDwgRVRIX0FMRU47IGkrKykgewogCQkJbWFza1tpXSB8PQotCQkJCWlmYWNlLT5jb25mLT5ic3Nbal0uYnNzaWRbaV0gXgorCQkJCWlmYWNlLT5jb25mLT5ic3Nbal0tPmJzc2lkW2ldIF4KIAkJCQloYXBkLT5vd25fYWRkcltpXTsKIAkJfQogCX0KQEAgLTUwMiw3ICs1NTMsNyBAQAogCXNpemVfdCBpOwogCiAJZm9yIChpID0gMDsgaSA8IGNvbmYtPm51bV9ic3M7IGkrKykgewotCQlpZiAoaG9zdGFwZF9tYWNfY29tcChjb25mLT5ic3NbaV0uYnNzaWQsIGEpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfbWFjX2NvbXAoY29uZi0+YnNzW2ldLT5ic3NpZCwgYSkgPT0gMCkgewogCQkJcmV0dXJuIDE7CiAJCX0KIAl9CkBAIC01MTYsNyArNTY3LDM0IEBACiBzdGF0aWMgaW50IGhvc3RhcGRfZGFzX25hc19taXNtYXRjaChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCSAgICBzdHJ1Y3QgcmFkaXVzX2Rhc19hdHRycyAqYXR0cikKIHsKLQkvKiBUT0RPICovCisJaWYgKGF0dHItPm5hc19pZGVudGlmaWVyICYmCisJICAgICghaGFwZC0+Y29uZi0+bmFzX2lkZW50aWZpZXIgfHwKKwkgICAgIG9zX3N0cmxlbihoYXBkLT5jb25mLT5uYXNfaWRlbnRpZmllcikgIT0KKwkgICAgIGF0dHItPm5hc19pZGVudGlmaWVyX2xlbiB8fAorCSAgICAgb3NfbWVtY21wKGhhcGQtPmNvbmYtPm5hc19pZGVudGlmaWVyLCBhdHRyLT5uYXNfaWRlbnRpZmllciwKKwkJICAgICAgIGF0dHItPm5hc19pZGVudGlmaWVyX2xlbikgIT0gMCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSQURJVVMgREFTOiBOQVMtSWRlbnRpZmllciBtaXNtYXRjaCIpOworCQlyZXR1cm4gMTsKKwl9CisKKwlpZiAoYXR0ci0+bmFzX2lwX2FkZHIgJiYKKwkgICAgKGhhcGQtPmNvbmYtPm93bl9pcF9hZGRyLmFmICE9IEFGX0lORVQgfHwKKwkgICAgIG9zX21lbWNtcCgmaGFwZC0+Y29uZi0+b3duX2lwX2FkZHIudS52NCwgYXR0ci0+bmFzX2lwX2FkZHIsIDQpICE9CisJICAgICAwKSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJBRElVUyBEQVM6IE5BUy1JUC1BZGRyZXNzIG1pc21hdGNoIik7CisJCXJldHVybiAxOworCX0KKworI2lmZGVmIENPTkZJR19JUFY2CisJaWYgKGF0dHItPm5hc19pcHY2X2FkZHIgJiYKKwkgICAgKGhhcGQtPmNvbmYtPm93bl9pcF9hZGRyLmFmICE9IEFGX0lORVQ2IHx8CisJICAgICBvc19tZW1jbXAoJmhhcGQtPmNvbmYtPm93bl9pcF9hZGRyLnUudjYsIGF0dHItPm5hc19pcHY2X2FkZHIsIDE2KQorCSAgICAgIT0gMCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSQURJVVMgREFTOiBOQVMtSVB2Ni1BZGRyZXNzIG1pc21hdGNoIik7CisJCXJldHVybiAxOworCX0KKyNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLworCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTU4Myw2ICs2NjEsOCBAQAogCWlmIChzdGEgPT0gTlVMTCkKIAkJcmV0dXJuIFJBRElVU19EQVNfU0VTU0lPTl9OT1RfRk9VTkQ7CiAKKwl3cGFfYXV0aF9wbWtzYV9yZW1vdmUoaGFwZC0+d3BhX2F1dGgsIHN0YS0+YWRkcik7CisKIAlob3N0YXBkX2Rydl9zdGFfZGVhdXRoKGhhcGQsIHN0YS0+YWRkciwKIAkJCSAgICAgICBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKIAlhcF9zdGFfZGVhdXRoZW50aWNhdGUoaGFwZCwgc3RhLCBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKQEAgLTU5Niw3ICs2NzYsOCBAQAogLyoqCiAgKiBob3N0YXBkX3NldHVwX2JzcyAtIFBlci1CU1Mgc2V0dXAgKGluaXRpYWxpemF0aW9uKQogICogQGhhcGQ6IFBvaW50ZXIgdG8gQlNTIGRhdGEKLSAqIEBmaXJzdDogV2hldGhlciB0aGlzIEJTUyBpcyB0aGUgZmlyc3QgQlNTIG9mIGFuIGludGVyZmFjZQorICogQGZpcnN0OiBXaGV0aGVyIHRoaXMgQlNTIGlzIHRoZSBmaXJzdCBCU1Mgb2YgYW4gaW50ZXJmYWNlOyAtMSA9IG5vdCBmaXJzdCwKKyAqCWJ1dCBpbnRlcmZhY2UgbWF5IGV4aXN0CiAgKgogICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIGluaXRpYWxpemUgYWxsIHBlci1CU1MgZGF0YSBzdHJ1Y3R1cmVzIGFuZAogICogcmVzb3VyY2VzLiBUaGlzIGdldHMgY2FsbGVkIGluIGEgbG9vcCBmb3IgZWFjaCBCU1Mgd2hlbiBhbiBpbnRlcmZhY2UgaXMKQEAgLTYxMSw3ICs2OTIsMjQgQEAKIAljaGFyIGZvcmNlX2lmbmFtZVtJRk5BTVNJWl07CiAJdTggaWZfYWRkcltFVEhfQUxFTl07CiAKLQlpZiAoIWZpcnN0KSB7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyhoYXBkPSVwICglcyksIGZpcnN0PSVkKSIsCisJCSAgIF9fZnVuY19fLCBoYXBkLCBoYXBkLT5jb25mLT5pZmFjZSwgZmlyc3QpOworCisjaWZkZWYgRUFQX1NFUlZFUl9UTkMKKwlpZiAoaGFwZC0+Y29uZi0+dG5jICYmIHRuY3NfZ2xvYmFsX2luaXQoKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSBUTkNTIik7CisJCXJldHVybiAtMTsKKwl9CisjZW5kaWYgLyogRUFQX1NFUlZFUl9UTkMgKi8KKworCWlmIChoYXBkLT5zdGFydGVkKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IEludGVyZmFjZSAlcyB3YXMgYWxyZWFkeSBzdGFydGVkIiwKKwkJCSAgIF9fZnVuY19fLCBoYXBkLT5jb25mLT5pZmFjZSk7CisJCXJldHVybiAtMTsKKwl9CisJaGFwZC0+c3RhcnRlZCA9IDE7CisKKwlpZiAoIWZpcnN0IHx8IGZpcnN0ID09IC0xKSB7CiAJCWlmIChob3N0YXBkX21hY19jb21wX2VtcHR5KGhhcGQtPmNvbmYtPmJzc2lkKSA9PSAwKSB7CiAJCQkvKiBBbGxvY2F0ZSB0aGUgbmV4dCBhdmFpbGFibGUgQlNTSUQuICovCiAJCQlkbyB7CkBAIC02MzYsOSArNzM0LDEwIEBACiAJCQkJICAgaGFwZC0+Y29uZi0+aWZhY2UsIGhhcGQtPm93bl9hZGRyLCBoYXBkLAogCQkJCSAgICZoYXBkLT5kcnZfcHJpdiwgZm9yY2VfaWZuYW1lLCBpZl9hZGRyLAogCQkJCSAgIGhhcGQtPmNvbmYtPmJyaWRnZVswXSA/IGhhcGQtPmNvbmYtPmJyaWRnZSA6Ci0JCQkJICAgTlVMTCkpIHsKKwkJCQkgICBOVUxMLCBmaXJzdCA9PSAtMSkpIHsKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiRmFpbGVkIHRvIGFkZCBCU1MgKEJTU0lEPSIKIAkJCQkgICBNQUNTVFIgIikiLCBNQUMyU1RSKGhhcGQtPm93bl9hZGRyKSk7CisJCQloYXBkLT5pbnRlcmZhY2VfYWRkZWQgPSAwOwogCQkJcmV0dXJuIC0xOwogCQl9CiAJfQpAQCAtNzAyLDcgKzgwMSw3IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQlpZiAod3BhX2RlYnVnX2xldmVsID09IE1TR19NU0dEVU1QKQorCWlmICh3cGFfZGVidWdfbGV2ZWwgPD0gTVNHX01TR0RVTVApCiAJCWNvbmYtPnJhZGl1cy0+bXNnX2R1bXBzID0gMTsKICNpZm5kZWYgQ09ORklHX05PX1JBRElVUwogCWhhcGQtPnJhZGl1cyA9IHJhZGl1c19jbGllbnRfaW5pdChoYXBkLCBjb25mLT5yYWRpdXMpOwpAQCAtNzQ4LDcgKzg0Nyw3IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQlpZiAoaGFwZC0+Y29uZi0+d3BhICYmIGhvc3RhcGRfc2V0dXBfd3BhKGhhcGQpKQorCWlmICgoaGFwZC0+Y29uZi0+d3BhIHx8IGhhcGQtPmNvbmYtPm9zZW4pICYmIGhvc3RhcGRfc2V0dXBfd3BhKGhhcGQpKQogCQlyZXR1cm4gLTE7CiAKIAlpZiAoYWNjb3VudGluZ19pbml0KGhhcGQpKSB7CkBAIC03NjgsMjIgKzg2NywyMiBAQAogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkdBUyBzZXJ2ZXIgaW5pdGlhbGl6YXRpb24gZmFpbGVkIik7CiAJCXJldHVybiAtMTsKIAl9Ci0jZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwogCi0JaWYgKGhhcGQtPmlmYWNlLT5pbnRlcmZhY2VzICYmCi0JICAgIGhhcGQtPmlmYWNlLT5pbnRlcmZhY2VzLT5jdHJsX2lmYWNlX2luaXQgJiYKLQkgICAgaGFwZC0+aWZhY2UtPmludGVyZmFjZXMtPmN0cmxfaWZhY2VfaW5pdChoYXBkKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBzZXR1cCBjb250cm9sIGludGVyZmFjZSIpOworCWlmIChjb25mLT5xb3NfbWFwX3NldF9sZW4gJiYKKwkgICAgaG9zdGFwZF9kcnZfc2V0X3Fvc19tYXAoaGFwZCwgY29uZi0+cW9zX21hcF9zZXQsCisJCQkJICAgIGNvbmYtPnFvc19tYXBfc2V0X2xlbikpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSBRb1MgTWFwIik7CiAJCXJldHVybiAtMTsKIAl9CisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwogCiAJaWYgKCFob3N0YXBkX2Rydl9ub25lKGhhcGQpICYmIHZsYW5faW5pdChoYXBkKSkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIlZMQU4gaW5pdGlhbGl6YXRpb24gZmFpbGVkLiIpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKCFoYXBkLT5jb25mLT5zdGFydF9kaXNhYmxlZCkKLQkJaWVlZTgwMl8xMV9zZXRfYmVhY29uKGhhcGQpOworCWlmICghaGFwZC0+Y29uZi0+c3RhcnRfZGlzYWJsZWQgJiYgaWVlZTgwMl8xMV9zZXRfYmVhY29uKGhhcGQpIDwgMCkKKwkJcmV0dXJuIC0xOwogCiAJaWYgKGhhcGQtPndwYV9hdXRoICYmIHdwYV9pbml0X2tleXMoaGFwZC0+d3BhX2F1dGgpIDwgMCkKIAkJcmV0dXJuIC0xOwpAQCAtODQ5LDQ0ICs5NDgsMTE3IEBACiAKIAlpZiAoaGFwZC0+aWZhY2UtPmRydl9tYXhfYWNsX21hY19hZGRycyA9PSAwKQogCQlyZXR1cm47Ci0JaWYgKCEoY29uZi0+YnNzLT5udW1fYWNjZXB0X21hYyB8fCBjb25mLT5ic3MtPm51bV9kZW55X21hYykpCi0JCXJldHVybjsKIAotCWlmIChjb25mLT5ic3MtPm1hY2FkZHJfYWNsID09IERFTllfVU5MRVNTX0FDQ0VQVEVEKSB7Ci0JCWlmIChjb25mLT5ic3MtPm51bV9hY2NlcHRfbWFjKSB7Ci0JCQlhY2NlcHRfYWNsID0gMTsKLQkJCWVyciA9IGhvc3RhcGRfc2V0X2FjbF9saXN0KGhhcGQsIGNvbmYtPmJzcy0+YWNjZXB0X21hYywKLQkJCQkJCSAgIGNvbmYtPmJzcy0+bnVtX2FjY2VwdF9tYWMsCi0JCQkJCQkgICBhY2NlcHRfYWNsKTsKLQkJCWlmIChlcnIpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBzZXQgYWNjZXB0IGFjbCIpOwotCQkJCXJldHVybjsKLQkJCX0KLQkJfSBlbHNlIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTWlzbWF0Y2ggYmV0d2VlbiBBQ0wgUG9saWN5ICYgQWNjZXB0L2RlbnkgbGlzdHMgZmlsZSIpOworCWlmIChjb25mLT5ic3NbMF0tPm1hY2FkZHJfYWNsID09IERFTllfVU5MRVNTX0FDQ0VQVEVEKSB7CisJCWFjY2VwdF9hY2wgPSAxOworCQllcnIgPSBob3N0YXBkX3NldF9hY2xfbGlzdChoYXBkLCBjb25mLT5ic3NbMF0tPmFjY2VwdF9tYWMsCisJCQkJCSAgIGNvbmYtPmJzc1swXS0+bnVtX2FjY2VwdF9tYWMsCisJCQkJCSAgIGFjY2VwdF9hY2wpOworCQlpZiAoZXJyKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBzZXQgYWNjZXB0IGFjbCIpOworCQkJcmV0dXJuOwogCQl9Ci0JfSBlbHNlIGlmIChjb25mLT5ic3MtPm1hY2FkZHJfYWNsID09IEFDQ0VQVF9VTkxFU1NfREVOSUVEKSB7Ci0JCWlmIChjb25mLT5ic3MtPm51bV9kZW55X21hYykgewotCQkJYWNjZXB0X2FjbCA9IDA7Ci0JCQllcnIgPSBob3N0YXBkX3NldF9hY2xfbGlzdChoYXBkLCBjb25mLT5ic3MtPmRlbnlfbWFjLAotCQkJCQkJICAgY29uZi0+YnNzLT5udW1fZGVueV9tYWMsCi0JCQkJCQkgICBhY2NlcHRfYWNsKTsKLQkJCWlmIChlcnIpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBzZXQgZGVueSBhY2wiKTsKLQkJCQlyZXR1cm47Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk1pc21hdGNoIGJldHdlZW4gQUNMIFBvbGljeSAmIEFjY2VwdC9kZW55IGxpc3RzIGZpbGUiKTsKKwl9IGVsc2UgaWYgKGNvbmYtPmJzc1swXS0+bWFjYWRkcl9hY2wgPT0gQUNDRVBUX1VOTEVTU19ERU5JRUQpIHsKKwkJYWNjZXB0X2FjbCA9IDA7CisJCWVyciA9IGhvc3RhcGRfc2V0X2FjbF9saXN0KGhhcGQsIGNvbmYtPmJzc1swXS0+ZGVueV9tYWMsCisJCQkJCSAgIGNvbmYtPmJzc1swXS0+bnVtX2RlbnlfbWFjLAorCQkJCQkgICBhY2NlcHRfYWNsKTsKKwkJaWYgKGVycikgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGYWlsZWQgdG8gc2V0IGRlbnkgYWNsIik7CisJCQlyZXR1cm47CiAJCX0KIAl9CiB9CiAKIAorc3RhdGljIGludCBzdGFydF9jdHJsX2lmYWNlX2JzcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQoreworCWlmICghaGFwZC0+aWZhY2UtPmludGVyZmFjZXMgfHwKKwkgICAgIWhhcGQtPmlmYWNlLT5pbnRlcmZhY2VzLT5jdHJsX2lmYWNlX2luaXQpCisJCXJldHVybiAwOworCisJaWYgKGhhcGQtPmlmYWNlLT5pbnRlcmZhY2VzLT5jdHJsX2lmYWNlX2luaXQoaGFwZCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiRmFpbGVkIHRvIHNldHVwIGNvbnRyb2wgaW50ZXJmYWNlIGZvciAlcyIsCisJCQkgICBoYXBkLT5jb25mLT5pZmFjZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IHN0YXJ0X2N0cmxfaWZhY2Uoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQoreworCXNpemVfdCBpOworCisJaWYgKCFpZmFjZS0+aW50ZXJmYWNlcyB8fCAhaWZhY2UtPmludGVyZmFjZXMtPmN0cmxfaWZhY2VfaW5pdCkKKwkJcmV0dXJuIDA7CisKKwlmb3IgKGkgPSAwOyBpIDwgaWZhY2UtPm51bV9ic3M7IGkrKykgeworCQlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkID0gaWZhY2UtPmJzc1tpXTsKKwkJaWYgKGlmYWNlLT5pbnRlcmZhY2VzLT5jdHJsX2lmYWNlX2luaXQoaGFwZCkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJGYWlsZWQgdG8gc2V0dXAgY29udHJvbCBpbnRlcmZhY2UgZm9yICVzIiwKKwkJCQkgICBoYXBkLT5jb25mLT5pZmFjZSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZCBjaGFubmVsX2xpc3RfdXBkYXRlX3RpbWVvdXQodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UgPSBlbG9vcF9jdHg7CisKKwlpZiAoIWlmYWNlLT53YWl0X2NoYW5uZWxfdXBkYXRlKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDaGFubmVsIGxpc3QgdXBkYXRlIHRpbWVvdXQsIGJ1dCBpbnRlcmZhY2Ugd2FzIG5vdCB3YWl0aW5nIGZvciBpdCIpOworCQlyZXR1cm47CisJfQorCisJLyoKKwkgKiBJdCBpcyBwb3NzaWJsZSB0aGF0IHRoZSBleGlzdGluZyBjaGFubmVsIGxpc3QgaXMgYWNjZXB0YWJsZSwgc28gdHJ5CisJICogdG8gcHJvY2VlZC4KKwkgKi8KKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNoYW5uZWwgbGlzdCB1cGRhdGUgdGltZW91dCAtIHRyeSB0byBjb250aW51ZSBhbnl3YXkiKTsKKwlzZXR1cF9pbnRlcmZhY2UyKGlmYWNlKTsKK30KKworCit2b2lkIGhvc3RhcGRfY2hhbm5lbF9saXN0X3VwZGF0ZWQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBpbnQgaW5pdGlhdG9yKQoreworCWlmICghaWZhY2UtPndhaXRfY2hhbm5lbF91cGRhdGUgfHwgaW5pdGlhdG9yICE9IFJFR0RPTV9TRVRfQllfVVNFUikKKwkJcmV0dXJuOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDaGFubmVsIGxpc3QgdXBkYXRlZCAtIGNvbnRpbnVlIHNldHVwIik7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoY2hhbm5lbF9saXN0X3VwZGF0ZV90aW1lb3V0LCBpZmFjZSwgTlVMTCk7CisJc2V0dXBfaW50ZXJmYWNlMihpZmFjZSk7Cit9CisKKwogc3RhdGljIGludCBzZXR1cF9pbnRlcmZhY2Uoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQogewogCXN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQgPSBpZmFjZS0+YnNzWzBdOwogCXNpemVfdCBpOwotCWNoYXIgY291bnRyeVs0XTsKKworCS8qCisJICogSXQgaXMgcG9zc2libGUgdGhhdCBzZXR1cF9pbnRlcmZhY2UoKSBpcyBjYWxsZWQgYWZ0ZXIgdGhlIGludGVyZmFjZQorCSAqIHdhcyBkaXNhYmxlZCBldGMuLCBpbiB3aGljaCBjYXNlIGRyaXZlcl9hcF90ZWFyZG93biBpcyBwb3NzaWJseSBzZXQKKwkgKiB0byAxLiBDbGVhciBpdCBoZXJlIHNvIGFueSBvdGhlciBrZXkvc3RhdGlvbiBkZWxldGlvbiwgd2hpY2ggaXMgbm90CisJICogcGFydCBvZiBhIHRlYXJkb3duIGZsb3csIHdvdWxkIGFsc28gY2FsbCB0aGUgcmVsZXZhbnQgZHJpdmVyCisJICogY2FsbGJhY2tzLgorCSAqLworCWlmYWNlLT5kcml2ZXJfYXBfdGVhcmRvd24gPSAwOworCisJaWYgKCFpZmFjZS0+cGh5WzBdKSB7CisJCWNvbnN0IGNoYXIgKnBoeSA9IGhvc3RhcGRfZHJ2X2dldF9yYWRpb19uYW1lKGhhcGQpOworCQlpZiAocGh5KSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgInBoeTogJXMiLCBwaHkpOworCQkJb3Nfc3RybGNweShpZmFjZS0+cGh5LCBwaHksIHNpemVvZihpZmFjZS0+cGh5KSk7CisJCX0KKwl9CiAKIAkvKgogCSAqIE1ha2Ugc3VyZSB0aGF0IGFsbCBCU1NlcyBnZXQgY29uZmlndXJlZCB3aXRoIGEgcG9pbnRlciB0byB0aGUgc2FtZQpAQCAtOTAwLDE1ICsxMDcyLDQ5IEBACiAJaWYgKGhvc3RhcGRfdmFsaWRhdGVfYnNzaWRfY29uZmlndXJhdGlvbihpZmFjZSkpCiAJCXJldHVybiAtMTsKIAorCS8qCisJICogSW5pdGlhbGl6ZSBjb250cm9sIGludGVyZmFjZXMgZWFybHkgdG8gYWxsb3cgZXh0ZXJuYWwgbW9uaXRvcmluZyBvZgorCSAqIGNoYW5uZWwgc2V0dXAgb3BlcmF0aW9ucyB0aGF0IG1heSB0YWtlIGNvbnNpZGVyYWJsZSBhbW91bnQgb2YgdGltZQorCSAqIGVzcGVjaWFsbHkgZm9yIERGUyBjYXNlcy4KKwkgKi8KKwlpZiAoc3RhcnRfY3RybF9pZmFjZShpZmFjZSkpCisJCXJldHVybiAtMTsKKwogCWlmIChoYXBkLT5pY29uZi0+Y291bnRyeVswXSAmJiBoYXBkLT5pY29uZi0+Y291bnRyeVsxXSkgeworCQljaGFyIGNvdW50cnlbNF0sIHByZXZpb3VzX2NvdW50cnlbNF07CisKKwkJaG9zdGFwZF9zZXRfc3RhdGUoaWZhY2UsIEhBUERfSUZBQ0VfQ09VTlRSWV9VUERBVEUpOworCQlpZiAoaG9zdGFwZF9nZXRfY291bnRyeShoYXBkLCBwcmV2aW91c19jb3VudHJ5KSA8IDApCisJCQlwcmV2aW91c19jb3VudHJ5WzBdID0gJ1wwJzsKKwogCQlvc19tZW1jcHkoY291bnRyeSwgaGFwZC0+aWNvbmYtPmNvdW50cnksIDMpOwogCQljb3VudHJ5WzNdID0gJ1wwJzsKIAkJaWYgKGhvc3RhcGRfc2V0X2NvdW50cnkoaGFwZCwgY291bnRyeSkgPCAwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBzZXQgY291bnRyeSBjb2RlIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KKworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlByZXZpb3VzIGNvdW50cnkgY29kZSAlcywgbmV3IGNvdW50cnkgY29kZSAlcyIsCisJCQkgICBwcmV2aW91c19jb3VudHJ5LCBjb3VudHJ5KTsKKworCQlpZiAob3Nfc3RybmNtcChwcmV2aW91c19jb3VudHJ5LCBjb3VudHJ5LCAyKSAhPSAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNvbnRpbnVlIGludGVyZmFjZSBzZXR1cCBhZnRlciBjaGFubmVsIGxpc3QgdXBkYXRlIik7CisJCQlpZmFjZS0+d2FpdF9jaGFubmVsX3VwZGF0ZSA9IDE7CisJCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDUsIDAsCisJCQkJCSAgICAgICBjaGFubmVsX2xpc3RfdXBkYXRlX3RpbWVvdXQsCisJCQkJCSAgICAgICBpZmFjZSwgTlVMTCk7CisJCQlyZXR1cm4gMDsKKwkJfQogCX0KIAorCXJldHVybiBzZXR1cF9pbnRlcmZhY2UyKGlmYWNlKTsKK30KKworCitzdGF0aWMgaW50IHNldHVwX2ludGVyZmFjZTIoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQoreworCWlmYWNlLT53YWl0X2NoYW5uZWxfdXBkYXRlID0gMDsKKwogCWlmIChob3N0YXBkX2dldF9od19mZWF0dXJlcyhpZmFjZSkpIHsKIAkJLyogTm90IGFsbCBkcml2ZXJzIHN1cHBvcnQgdGhpcyB5ZXQsIHNvIGNvbnRpbnVlIHdpdGhvdXQgaHcKIAkJICogZmVhdHVyZSBkYXRhLiAqLwpAQCAtOTE3LDcgKzExMjMsNyBAQAogCQlpZiAocmV0IDwgMCkgewogCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3Qgc2VsZWN0IGh3X21vZGUgYW5kICIKIAkJCQkgICAiY2hhbm5lbC4gKCVkKSIsIHJldCk7Ci0JCQlyZXR1cm4gLTE7CisJCQlnb3RvIGZhaWw7CiAJCX0KIAkJaWYgKHJldCA9PSAxKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyZmFjZSBpbml0aWFsaXphdGlvbiB3aWxsIGJlIGNvbXBsZXRlZCBpbiBhIGNhbGxiYWNrIChBQ1MpIik7CkBAIC05MjUsMzYgKzExMzEsNjUgQEAKIAkJfQogCQlyZXQgPSBob3N0YXBkX2NoZWNrX2h0X2NhcGFiKGlmYWNlKTsKIAkJaWYgKHJldCA8IDApCi0JCQlyZXR1cm4gLTE7CisJCQlnb3RvIGZhaWw7CiAJCWlmIChyZXQgPT0gMSkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcmZhY2UgaW5pdGlhbGl6YXRpb24gd2lsbCAiCiAJCQkJICAgImJlIGNvbXBsZXRlZCBpbiBhIGNhbGxiYWNrIik7CiAJCQlyZXR1cm4gMDsKIAkJfQorCisJCWlmIChpZmFjZS0+Y29uZi0+aWVlZTgwMjExaCkKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiREZTIHN1cHBvcnQgaXMgZW5hYmxlZCIpOwogCX0KIAlyZXR1cm4gaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2VfY29tcGxldGUoaWZhY2UsIDApOworCitmYWlsOgorCWhvc3RhcGRfc2V0X3N0YXRlKGlmYWNlLCBIQVBEX0lGQUNFX0RJU0FCTEVEKTsKKwl3cGFfbXNnKGlmYWNlLT5ic3NbMF0tPm1zZ19jdHgsIE1TR19JTkZPLCBBUF9FVkVOVF9ESVNBQkxFRCk7CisJaWYgKGlmYWNlLT5pbnRlcmZhY2VzICYmIGlmYWNlLT5pbnRlcmZhY2VzLT50ZXJtaW5hdGVfb25fZXJyb3IpCisJCWVsb29wX3Rlcm1pbmF0ZSgpOworCXJldHVybiAtMTsKIH0KIAogCisvKioKKyAqIGhvc3RhcGRfc2V0dXBfaW50ZXJmYWNlX2NvbXBsZXRlIC0gQ29tcGxldGUgaW50ZXJmYWNlIHNldHVwCisgKgorICogVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgd2hlbiBwcmV2aW91cyBzdGVwcyBpbiB0aGUgaW50ZXJmYWNlIHNldHVwIGhhcyBiZWVuCisgKiBjb21wbGV0ZWQuIFRoaXMgY2FuIGFsc28gc3RhcnQgb3BlcmF0aW9ucywgZS5nLiwgREZTLCB0aGF0IHdpbGwgcmVxdWlyZQorICogYWRkaXRpb25hbCBwcm9jZXNzaW5nIGJlZm9yZSBpbnRlcmZhY2UgaXMgcmVhZHkgdG8gYmUgZW5hYmxlZC4gU3VjaAorICogb3BlcmF0aW9ucyB3aWxsIGNhbGwgdGhpcyBmdW5jdGlvbiBmcm9tIGVsb29wIGNhbGxiYWNrcyB3aGVuIGZpbmlzaGVkLgorICovCiBpbnQgaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2VfY29tcGxldGUoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBpbnQgZXJyKQogewogCXN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQgPSBpZmFjZS0+YnNzWzBdOwogCXNpemVfdCBqOwogCXU4ICpwcmV2X2FkZHI7CiAKLQlpZiAoZXJyKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSW50ZXJmYWNlIGluaXRpYWxpemF0aW9uIGZhaWxlZCIpOwotCQllbG9vcF90ZXJtaW5hdGUoKTsKLQkJcmV0dXJuIC0xOwotCX0KKwlpZiAoZXJyKQorCQlnb3RvIGZhaWw7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNvbXBsZXRpbmcgaW50ZXJmYWNlIGluaXRpYWxpemF0aW9uIik7Ci0JaWYgKGhhcGQtPmljb25mLT5jaGFubmVsKSB7Ci0JCWlmYWNlLT5mcmVxID0gaG9zdGFwZF9od19nZXRfZnJlcShoYXBkLCBoYXBkLT5pY29uZi0+Y2hhbm5lbCk7CisJaWYgKGlmYWNlLT5jb25mLT5jaGFubmVsKSB7CisjaWZkZWYgTkVFRF9BUF9NTE1FCisJCWludCByZXM7CisjZW5kaWYgLyogTkVFRF9BUF9NTE1FICovCisKKwkJaWZhY2UtPmZyZXEgPSBob3N0YXBkX2h3X2dldF9mcmVxKGhhcGQsIGlmYWNlLT5jb25mLT5jaGFubmVsKTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJNb2RlOiAlcyAgQ2hhbm5lbDogJWQgICIKIAkJCSAgICJGcmVxdWVuY3k6ICVkIE1IeiIsCi0JCQkgICBob3N0YXBkX2h3X21vZGVfdHh0KGhhcGQtPmljb25mLT5od19tb2RlKSwKLQkJCSAgIGhhcGQtPmljb25mLT5jaGFubmVsLCBpZmFjZS0+ZnJlcSk7CisJCQkgICBob3N0YXBkX2h3X21vZGVfdHh0KGlmYWNlLT5jb25mLT5od19tb2RlKSwKKwkJCSAgIGlmYWNlLT5jb25mLT5jaGFubmVsLCBpZmFjZS0+ZnJlcSk7CisKKyNpZmRlZiBORUVEX0FQX01MTUUKKwkJLyogQ2hlY2sgREZTICovCisJCXJlcyA9IGhvc3RhcGRfaGFuZGxlX2RmcyhpZmFjZSk7CisJCWlmIChyZXMgPD0gMCkgeworCQkJaWYgKHJlcyA8IDApCisJCQkJZ290byBmYWlsOworCQkJcmV0dXJuIHJlczsKKwkJfQorI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLwogCiAJCWlmIChob3N0YXBkX3NldF9mcmVxKGhhcGQsIGhhcGQtPmljb25mLT5od19tb2RlLCBpZmFjZS0+ZnJlcSwKIAkJCQkgICAgIGhhcGQtPmljb25mLT5jaGFubmVsLApAQCAtOTY2LDcgKzEyMDEsNyBAQAogCQkJCSAgICAgaGFwZC0+aWNvbmYtPnZodF9vcGVyX2NlbnRyX2ZyZXFfc2VnMV9pZHgpKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCBzZXQgY2hhbm5lbCBmb3IgIgogCQkJCSAgICJrZXJuZWwgZHJpdmVyIik7Ci0JCQlyZXR1cm4gLTE7CisJCQlnb3RvIGZhaWw7CiAJCX0KIAl9CiAKQEAgLTk3Nyw3ICsxMjEyLDcgQEAKIAkJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIE5VTEwsIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKIAkJCQkgICAgICAgSE9TVEFQRF9MRVZFTF9XQVJOSU5HLAogCQkJCSAgICAgICAiRmFpbGVkIHRvIHByZXBhcmUgcmF0ZXMgdGFibGUuIik7Ci0JCQlyZXR1cm4gLTE7CisJCQlnb3RvIGZhaWw7CiAJCX0KIAl9CiAKQEAgLTk4NSwxNCArMTIyMCwxNCBAQAogCSAgICBob3N0YXBkX3NldF9ydHMoaGFwZCwgaGFwZC0+aWNvbmYtPnJ0c190aHJlc2hvbGQpKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ291bGQgbm90IHNldCBSVFMgdGhyZXNob2xkIGZvciAiCiAJCQkgICAia2VybmVsIGRyaXZlciIpOwotCQlyZXR1cm4gLTE7CisJCWdvdG8gZmFpbDsKIAl9CiAKIAlpZiAoaGFwZC0+aWNvbmYtPmZyYWdtX3RocmVzaG9sZCA+IC0xICYmCiAJICAgIGhvc3RhcGRfc2V0X2ZyYWcoaGFwZCwgaGFwZC0+aWNvbmYtPmZyYWdtX3RocmVzaG9sZCkpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3Qgc2V0IGZyYWdtZW50YXRpb24gdGhyZXNob2xkICIKIAkJCSAgICJmb3Iga2VybmVsIGRyaXZlciIpOwotCQlyZXR1cm4gLTE7CisJCWdvdG8gZmFpbDsKIAl9CiAKIAlwcmV2X2FkZHIgPSBoYXBkLT5vd25fYWRkcjsKQEAgLTEwMDEsMTEgKzEyMzYsMTggQEAKIAkJaGFwZCA9IGlmYWNlLT5ic3Nbal07CiAJCWlmIChqKQogCQkJb3NfbWVtY3B5KGhhcGQtPm93bl9hZGRyLCBwcmV2X2FkZHIsIEVUSF9BTEVOKTsKLQkJaWYgKGhvc3RhcGRfc2V0dXBfYnNzKGhhcGQsIGogPT0gMCkpCi0JCQlyZXR1cm4gLTE7CisJCWlmIChob3N0YXBkX3NldHVwX2JzcyhoYXBkLCBqID09IDApKSB7CisJCQlkbyB7CisJCQkJaGFwZCA9IGlmYWNlLT5ic3Nbal07CisJCQkJaG9zdGFwZF9ic3NfZGVpbml0X25vX2ZyZWUoaGFwZCk7CisJCQkJaG9zdGFwZF9mcmVlX2hhcGRfZGF0YShoYXBkKTsKKwkJCX0gd2hpbGUgKGotLSA+IDApOworCQkJZ290byBmYWlsOworCQl9CiAJCWlmIChob3N0YXBkX21hY19jb21wX2VtcHR5KGhhcGQtPmNvbmYtPmJzc2lkKSA9PSAwKQogCQkJcHJldl9hZGRyID0gaGFwZC0+b3duX2FkZHI7CiAJfQorCWhhcGQgPSBpZmFjZS0+YnNzWzBdOwogCiAJaG9zdGFwZF90eF9xdWV1ZV9wYXJhbXMoaWZhY2UpOwogCkBAIC0xMDE2LDcgKzEyNTgsNyBAQAogCWlmIChob3N0YXBkX2RyaXZlcl9jb21taXQoaGFwZCkgPCAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IEZhaWxlZCB0byBjb21taXQgZHJpdmVyICIKIAkJCSAgICJjb25maWd1cmF0aW9uIiwgX19mdW5jX18pOwotCQlyZXR1cm4gLTE7CisJCWdvdG8gZmFpbDsKIAl9CiAKIAkvKgpAQCAtMTAyNywxNiArMTI2OSwyOCBAQAogCSAqLwogCWZvciAoaiA9IDA7IGogPCBpZmFjZS0+bnVtX2JzczsgaisrKSB7CiAJCWlmIChob3N0YXBkX2luaXRfd3BzX2NvbXBsZXRlKGlmYWNlLT5ic3Nbal0pKQotCQkJcmV0dXJuIC0xOworCQkJZ290byBmYWlsOwogCX0KIAorCWhvc3RhcGRfc2V0X3N0YXRlKGlmYWNlLCBIQVBEX0lGQUNFX0VOQUJMRUQpOworCXdwYV9tc2coaWZhY2UtPmJzc1swXS0+bXNnX2N0eCwgTVNHX0lORk8sIEFQX0VWRU5UX0VOQUJMRUQpOwogCWlmIChoYXBkLT5zZXR1cF9jb21wbGV0ZV9jYikKIAkJaGFwZC0+c2V0dXBfY29tcGxldGVfY2IoaGFwZC0+c2V0dXBfY29tcGxldGVfY2JfY3R4KTsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IFNldHVwIG9mIGludGVyZmFjZSBkb25lLiIsCiAJCSAgIGlmYWNlLT5ic3NbMF0tPmNvbmYtPmlmYWNlKTsKKwlpZiAoaWZhY2UtPmludGVyZmFjZXMgJiYgaWZhY2UtPmludGVyZmFjZXMtPnRlcm1pbmF0ZV9vbl9lcnJvciA+IDApCisJCWlmYWNlLT5pbnRlcmZhY2VzLT50ZXJtaW5hdGVfb25fZXJyb3ItLTsKIAogCXJldHVybiAwOworCitmYWlsOgorCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSW50ZXJmYWNlIGluaXRpYWxpemF0aW9uIGZhaWxlZCIpOworCWhvc3RhcGRfc2V0X3N0YXRlKGlmYWNlLCBIQVBEX0lGQUNFX0RJU0FCTEVEKTsKKwl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19JTkZPLCBBUF9FVkVOVF9ESVNBQkxFRCk7CisJaWYgKGlmYWNlLT5pbnRlcmZhY2VzICYmIGlmYWNlLT5pbnRlcmZhY2VzLT50ZXJtaW5hdGVfb25fZXJyb3IpCisJCWVsb29wX3Rlcm1pbmF0ZSgpOworCXJldHVybiAtMTsKIH0KIAogCkBAIC0xMDQ5LDYgKzEzMDMsMTIgQEAKICAqIGFuZCBzZXRzIGRyaXZlciBwYXJhbWV0ZXJzIGJhc2VkIG9uIHRoZSBjb25maWd1cmF0aW9uLgogICogRmx1c2hlcyBvbGQgc3RhdGlvbnMsIHNldHMgdGhlIGNoYW5uZWwsIGVuY3J5cHRpb24sCiAgKiBiZWFjb25zLCBhbmQgV0RTIGxpbmtzIGJhc2VkIG9uIHRoZSBjb25maWd1cmF0aW9uLgorICoKKyAqIElmIGludGVyZmFjZSBzZXR1cCByZXF1aXJlcyBtb3JlIHRpbWUsIGUuZy4sIHRvIHBlcmZvcm0gSFQgY28tZXggc2NhbnMsIEFDUywKKyAqIG9yIERGUyBvcGVyYXRpb25zLCB0aGlzIGZ1bmN0aW9uIHJldHVybnMgMCBiZWZvcmUgc3VjaCBvcGVyYXRpb25zIGhhdmUgYmVlbgorICogY29tcGxldGVkLiBUaGUgcGVuZGluZyBvcGVyYXRpb25zIGFyZSByZWdpc3RlcmVkIGludG8gZWxvb3AgYW5kIHdpbGwgYmUKKyAqIGNvbXBsZXRlZCBmcm9tIGVsb29wIGNhbGxiYWNrcy4gVGhvc2UgY2FsbGJhY2tzIGVuZCB1cCBjYWxsaW5nCisgKiBob3N0YXBkX3NldHVwX2ludGVyZmFjZV9jb21wbGV0ZSgpIG9uY2Ugc2V0dXAgaGFzIGJlZW4gY29tcGxldGVkLgogICovCiBpbnQgaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2Uoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQogewpAQCAtMTA5OCw2OCArMTM1OCwzMjQgQEAKIH0KIAogCitzdGF0aWMgdm9pZCBob3N0YXBkX2Jzc19kZWluaXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBkZWluaXQgYnNzICVzIiwgX19mdW5jX18sCisJCSAgIGhhcGQtPmNvbmYtPmlmYWNlKTsKKwlob3N0YXBkX2Jzc19kZWluaXRfbm9fZnJlZShoYXBkKTsKKwlob3N0YXBkX2NsZWFudXAoaGFwZCk7Cit9CisKKwogdm9pZCBob3N0YXBkX2ludGVyZmFjZV9kZWluaXQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQogewotCXNpemVfdCBqOworCWludCBqOwogCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyglcCkiLCBfX2Z1bmNfXywgaWZhY2UpOwogCWlmIChpZmFjZSA9PSBOVUxMKQogCQlyZXR1cm47CiAKLQlob3N0YXBkX2NsZWFudXBfaWZhY2VfcHJlKGlmYWNlKTsKLQlmb3IgKGogPSAwOyBqIDwgaWZhY2UtPm51bV9ic3M7IGorKykgewotCQlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkID0gaWZhY2UtPmJzc1tqXTsKLQkJaG9zdGFwZF9mcmVlX3N0YXMoaGFwZCk7Ci0JCWhvc3RhcGRfZmx1c2hfb2xkX3N0YXRpb25zKGhhcGQsIFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HKTsKLQkJaG9zdGFwZF9jbGVhcl93ZXAoaGFwZCk7Ci0JCWhvc3RhcGRfY2xlYW51cChoYXBkKTsKLQl9CisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMU4KKyNpZmRlZiBORUVEX0FQX01MTUUKKwlob3N0YXBkX3N0b3Bfc2V0dXBfdGltZXJzKGlmYWNlKTsKKwllbG9vcF9jYW5jZWxfdGltZW91dChhcF9odDIwNDBfdGltZW91dCwgaWZhY2UsIE5VTEwpOworI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLworI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFOICovCisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoY2hhbm5lbF9saXN0X3VwZGF0ZV90aW1lb3V0LCBpZmFjZSwgTlVMTCk7CisJaWZhY2UtPndhaXRfY2hhbm5lbF91cGRhdGUgPSAwOworCisJZm9yIChqID0gaWZhY2UtPm51bV9ic3MgLSAxOyBqID49IDA7IGotLSkKKwkJaG9zdGFwZF9ic3NfZGVpbml0KGlmYWNlLT5ic3Nbal0pOwogfQogCiAKIHZvaWQgaG9zdGFwZF9pbnRlcmZhY2VfZnJlZShzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7CiAJc2l6ZV90IGo7Ci0JZm9yIChqID0gMDsgaiA8IGlmYWNlLT5udW1fYnNzOyBqKyspCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyglcCkiLCBfX2Z1bmNfXywgaWZhY2UpOworCWZvciAoaiA9IDA7IGogPCBpZmFjZS0+bnVtX2JzczsgaisrKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGZyZWUgaGFwZCAlcCIsCisJCQkgICBfX2Z1bmNfXywgaWZhY2UtPmJzc1tqXSk7CiAJCW9zX2ZyZWUoaWZhY2UtPmJzc1tqXSk7CisJfQogCWhvc3RhcGRfY2xlYW51cF9pZmFjZShpZmFjZSk7CiB9CiAKIAotI2lmZGVmIEhPU1RBUEQKKy8qKgorICogaG9zdGFwZF9pbml0IC0gQWxsb2NhdGUgYW5kIGluaXRpYWxpemUgcGVyLWludGVyZmFjZSBkYXRhCisgKiBAY29uZmlnX2ZpbGU6IFBhdGggdG8gdGhlIGNvbmZpZ3VyYXRpb24gZmlsZQorICogUmV0dXJuczogUG9pbnRlciB0byB0aGUgYWxsb2NhdGVkIGludGVyZmFjZSBkYXRhIG9yICVOVUxMIG9uIGZhaWx1cmUKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gYWxsb2NhdGUgbWFpbiBkYXRhIHN0cnVjdHVyZXMgZm9yIHBlci1pbnRlcmZhY2UKKyAqIGRhdGEuIFRoZSBhbGxvY2F0ZWQgZGF0YSBidWZmZXIgd2lsbCBiZSBmcmVlZCBieSBjYWxsaW5nCisgKiBob3N0YXBkX2NsZWFudXBfaWZhY2UoKS4KKyAqLworc3RydWN0IGhvc3RhcGRfaWZhY2UgKiBob3N0YXBkX2luaXQoc3RydWN0IGhhcGRfaW50ZXJmYWNlcyAqaW50ZXJmYWNlcywKKwkJCQkgICAgY29uc3QgY2hhciAqY29uZmlnX2ZpbGUpCit7CisJc3RydWN0IGhvc3RhcGRfaWZhY2UgKmhhcGRfaWZhY2UgPSBOVUxMOworCXN0cnVjdCBob3N0YXBkX2NvbmZpZyAqY29uZiA9IE5VTEw7CisJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZDsKKwlzaXplX3QgaTsKKworCWhhcGRfaWZhY2UgPSBvc196YWxsb2Moc2l6ZW9mKCpoYXBkX2lmYWNlKSk7CisJaWYgKGhhcGRfaWZhY2UgPT0gTlVMTCkKKwkJZ290byBmYWlsOworCisJaGFwZF9pZmFjZS0+Y29uZmlnX2ZuYW1lID0gb3Nfc3RyZHVwKGNvbmZpZ19maWxlKTsKKwlpZiAoaGFwZF9pZmFjZS0+Y29uZmlnX2ZuYW1lID09IE5VTEwpCisJCWdvdG8gZmFpbDsKKworCWNvbmYgPSBpbnRlcmZhY2VzLT5jb25maWdfcmVhZF9jYihoYXBkX2lmYWNlLT5jb25maWdfZm5hbWUpOworCWlmIChjb25mID09IE5VTEwpCisJCWdvdG8gZmFpbDsKKwloYXBkX2lmYWNlLT5jb25mID0gY29uZjsKKworCWhhcGRfaWZhY2UtPm51bV9ic3MgPSBjb25mLT5udW1fYnNzOworCWhhcGRfaWZhY2UtPmJzcyA9IG9zX2NhbGxvYyhjb25mLT5udW1fYnNzLAorCQkJCSAgICBzaXplb2Yoc3RydWN0IGhvc3RhcGRfZGF0YSAqKSk7CisJaWYgKGhhcGRfaWZhY2UtPmJzcyA9PSBOVUxMKQorCQlnb3RvIGZhaWw7CisKKwlmb3IgKGkgPSAwOyBpIDwgY29uZi0+bnVtX2JzczsgaSsrKSB7CisJCWhhcGQgPSBoYXBkX2lmYWNlLT5ic3NbaV0gPQorCQkJaG9zdGFwZF9hbGxvY19ic3NfZGF0YShoYXBkX2lmYWNlLCBjb25mLAorCQkJCQkgICAgICAgY29uZi0+YnNzW2ldKTsKKwkJaWYgKGhhcGQgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbDsKKwkJaGFwZC0+bXNnX2N0eCA9IGhhcGQ7CisJfQorCisJcmV0dXJuIGhhcGRfaWZhY2U7CisKK2ZhaWw6CisJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gc2V0IHVwIGludGVyZmFjZSB3aXRoICVzIiwKKwkJICAgY29uZmlnX2ZpbGUpOworCWlmIChjb25mKQorCQlob3N0YXBkX2NvbmZpZ19mcmVlKGNvbmYpOworCWlmIChoYXBkX2lmYWNlKSB7CisJCW9zX2ZyZWUoaGFwZF9pZmFjZS0+Y29uZmlnX2ZuYW1lKTsKKwkJb3NfZnJlZShoYXBkX2lmYWNlLT5ic3MpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBmcmVlIGlmYWNlICVwIiwKKwkJCSAgIF9fZnVuY19fLCBoYXBkX2lmYWNlKTsKKwkJb3NfZnJlZShoYXBkX2lmYWNlKTsKKwl9CisJcmV0dXJuIE5VTEw7Cit9CisKKworc3RhdGljIGludCBpZm5hbWVfaW5fdXNlKHN0cnVjdCBoYXBkX2ludGVyZmFjZXMgKmludGVyZmFjZXMsIGNvbnN0IGNoYXIgKmlmbmFtZSkKK3sKKwlzaXplX3QgaSwgajsKKworCWZvciAoaSA9IDA7IGkgPCBpbnRlcmZhY2VzLT5jb3VudDsgaSsrKSB7CisJCXN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSA9IGludGVyZmFjZXMtPmlmYWNlW2ldOworCQlmb3IgKGogPSAwOyBqIDwgaWZhY2UtPm51bV9ic3M7IGorKykgeworCQkJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGlmYWNlLT5ic3Nbal07CisJCQlpZiAob3Nfc3RyY21wKGlmbmFtZSwgaGFwZC0+Y29uZi0+aWZhY2UpID09IDApCisJCQkJcmV0dXJuIDE7CisJCX0KKwl9CisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGhvc3RhcGRfaW50ZXJmYWNlX2luaXRfYnNzIC0gUmVhZCBjb25maWd1cmF0aW9uIGZpbGUgYW5kIGluaXQgQlNTIGRhdGEKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gcGFyc2UgY29uZmlndXJhdGlvbiBmaWxlIGZvciBhIEJTUy4gVGhpcyBCU1MgaXMKKyAqIGFkZGVkIHRvIGFuIGV4aXN0aW5nIGludGVyZmFjZSBzaGFyaW5nIHRoZSBzYW1lIHJhZGlvIChpZiBhbnkpIG9yIGEgbmV3CisgKiBpbnRlcmZhY2UgaXMgY3JlYXRlZCBpZiB0aGlzIGlzIHRoZSBmaXJzdCBpbnRlcmZhY2Ugb24gYSByYWRpby4gVGhpcworICogYWxsb2NhdGUgbWVtb3J5IGZvciB0aGUgQlNTLiBObyBhY3R1YWwgZHJpdmVyIG9wZXJhdGlvbnMgYXJlIHN0YXJ0ZWQuCisgKgorICogVGhpcyBpcyBzaW1pbGFyIHRvIGhvc3RhcGRfaW50ZXJmYWNlX2luaXQoKSwgYnV0IGZvciBhIGNhc2Ugd2hlcmUgdGhlCisgKiBjb25maWd1cmF0aW9uIGlzIHVzZWQgdG8gYWRkIGEgc2luZ2xlIEJTUyBpbnN0ZWFkIG9mIGFsbCBCU1NlcyBmb3IgYSByYWRpby4KKyAqLworc3RydWN0IGhvc3RhcGRfaWZhY2UgKgoraG9zdGFwZF9pbnRlcmZhY2VfaW5pdF9ic3Moc3RydWN0IGhhcGRfaW50ZXJmYWNlcyAqaW50ZXJmYWNlcywgY29uc3QgY2hhciAqcGh5LAorCQkJICAgY29uc3QgY2hhciAqY29uZmlnX2ZuYW1lLCBpbnQgZGVidWcpCit7CisJc3RydWN0IGhvc3RhcGRfaWZhY2UgKm5ld19pZmFjZSA9IE5VTEwsICppZmFjZSA9IE5VTEw7CisJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZDsKKwlpbnQgazsKKwlzaXplX3QgaSwgYnNzX2lkeDsKKworCWlmICghcGh5IHx8ICEqcGh5KQorCQlyZXR1cm4gTlVMTDsKKworCWZvciAoaSA9IDA7IGkgPCBpbnRlcmZhY2VzLT5jb3VudDsgaSsrKSB7CisJCWlmIChvc19zdHJjbXAoaW50ZXJmYWNlcy0+aWZhY2VbaV0tPnBoeSwgcGh5KSA9PSAwKSB7CisJCQlpZmFjZSA9IGludGVyZmFjZXMtPmlmYWNlW2ldOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ29uZmlndXJhdGlvbiBmaWxlOiAlcyAocGh5ICVzKSVzIiwKKwkJICAgY29uZmlnX2ZuYW1lLCBwaHksIGlmYWNlID8gIiIgOiAiIC0tPiBuZXcgUEhZIik7CisJaWYgKGlmYWNlKSB7CisJCXN0cnVjdCBob3N0YXBkX2NvbmZpZyAqY29uZjsKKwkJc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqKnRtcF9jb25mOworCQlzdHJ1Y3QgaG9zdGFwZF9kYXRhICoqdG1wX2JzczsKKwkJc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzOworCQljb25zdCBjaGFyICppZm5hbWU7CisKKwkJLyogQWRkIG5ldyBCU1MgdG8gZXhpc3RpbmcgaWZhY2UgKi8KKwkJY29uZiA9IGludGVyZmFjZXMtPmNvbmZpZ19yZWFkX2NiKGNvbmZpZ19mbmFtZSk7CisJCWlmIChjb25mID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKwkJaWYgKGNvbmYtPm51bV9ic3MgPiAxKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIk11bHRpcGxlIEJTU2VzIHNwZWNpZmllZCBpbiBCU1MtY29uZmlnIik7CisJCQlob3N0YXBkX2NvbmZpZ19mcmVlKGNvbmYpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKworCQlpZm5hbWUgPSBjb25mLT5ic3NbMF0tPmlmYWNlOworCQlpZiAoaWZuYW1lWzBdICE9ICdcMCcgJiYgaWZuYW1lX2luX3VzZShpbnRlcmZhY2VzLCBpZm5hbWUpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCQkgICAiSW50ZXJmYWNlIG5hbWUgJXMgYWxyZWFkeSBpbiB1c2UiLCBpZm5hbWUpOworCQkJaG9zdGFwZF9jb25maWdfZnJlZShjb25mKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisKKwkJdG1wX2NvbmYgPSBvc19yZWFsbG9jX2FycmF5KAorCQkJaWZhY2UtPmNvbmYtPmJzcywgaWZhY2UtPmNvbmYtPm51bV9ic3MgKyAxLAorCQkJc2l6ZW9mKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKikpOworCQl0bXBfYnNzID0gb3NfcmVhbGxvY19hcnJheShpZmFjZS0+YnNzLCBpZmFjZS0+bnVtX2JzcyArIDEsCisJCQkJCSAgIHNpemVvZihzdHJ1Y3QgaG9zdGFwZF9kYXRhICopKTsKKwkJaWYgKHRtcF9ic3MpCisJCQlpZmFjZS0+YnNzID0gdG1wX2JzczsKKwkJaWYgKHRtcF9jb25mKSB7CisJCQlpZmFjZS0+Y29uZi0+YnNzID0gdG1wX2NvbmY7CisJCQlpZmFjZS0+Y29uZi0+bGFzdF9ic3MgPSB0bXBfY29uZlswXTsKKwkJfQorCQlpZiAodG1wX2JzcyA9PSBOVUxMIHx8IHRtcF9jb25mID09IE5VTEwpIHsKKwkJCWhvc3RhcGRfY29uZmlnX2ZyZWUoY29uZik7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlic3MgPSBpZmFjZS0+Y29uZi0+YnNzW2lmYWNlLT5jb25mLT5udW1fYnNzXSA9IGNvbmYtPmJzc1swXTsKKwkJaWZhY2UtPmNvbmYtPm51bV9ic3MrKzsKKworCQloYXBkID0gaG9zdGFwZF9hbGxvY19ic3NfZGF0YShpZmFjZSwgaWZhY2UtPmNvbmYsIGJzcyk7CisJCWlmIChoYXBkID09IE5VTEwpIHsKKwkJCWlmYWNlLT5jb25mLT5udW1fYnNzLS07CisJCQlob3N0YXBkX2NvbmZpZ19mcmVlKGNvbmYpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwkJaWZhY2UtPmNvbmYtPmxhc3RfYnNzID0gYnNzOworCQlpZmFjZS0+YnNzW2lmYWNlLT5udW1fYnNzXSA9IGhhcGQ7CisJCWhhcGQtPm1zZ19jdHggPSBoYXBkOworCisJCWJzc19pZHggPSBpZmFjZS0+bnVtX2JzcysrOworCQljb25mLT5udW1fYnNzLS07CisJCWNvbmYtPmJzc1swXSA9IE5VTEw7CisJCWhvc3RhcGRfY29uZmlnX2ZyZWUoY29uZik7CisJfSBlbHNlIHsKKwkJLyogQWRkIGEgbmV3IGlmYWNlIHdpdGggdGhlIGZpcnN0IEJTUyAqLworCQluZXdfaWZhY2UgPSBpZmFjZSA9IGhvc3RhcGRfaW5pdChpbnRlcmZhY2VzLCBjb25maWdfZm5hbWUpOworCQlpZiAoIWlmYWNlKQorCQkJcmV0dXJuIE5VTEw7CisJCW9zX3N0cmxjcHkoaWZhY2UtPnBoeSwgcGh5LCBzaXplb2YoaWZhY2UtPnBoeSkpOworCQlpZmFjZS0+aW50ZXJmYWNlcyA9IGludGVyZmFjZXM7CisJCWJzc19pZHggPSAwOworCX0KKworCWZvciAoayA9IDA7IGsgPCBkZWJ1ZzsgaysrKSB7CisJCWlmIChpZmFjZS0+YnNzW2Jzc19pZHhdLT5jb25mLT5sb2dnZXJfc3Rkb3V0X2xldmVsID4gMCkKKwkJCWlmYWNlLT5ic3NbYnNzX2lkeF0tPmNvbmYtPmxvZ2dlcl9zdGRvdXRfbGV2ZWwtLTsKKwl9CisKKwlpZiAoaWZhY2UtPmNvbmYtPmJzc1tic3NfaWR4XS0+aWZhY2VbMF0gPT0gJ1wwJyAmJgorCSAgICAhaG9zdGFwZF9kcnZfbm9uZShpZmFjZS0+YnNzW2Jzc19pZHhdKSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkludGVyZmFjZSBuYW1lIG5vdCBzcGVjaWZpZWQgaW4gJXMiLAorCQkJICAgY29uZmlnX2ZuYW1lKTsKKwkJaWYgKG5ld19pZmFjZSkKKwkJCWhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdF9mcmVlKG5ld19pZmFjZSk7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiBpZmFjZTsKK30KKwogCiB2b2lkIGhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdF9mcmVlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKIHsKIAljb25zdCBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgKmRyaXZlcjsKIAl2b2lkICpkcnZfcHJpdjsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMoJXApIiwgX19mdW5jX18sIGlmYWNlKTsKIAlpZiAoaWZhY2UgPT0gTlVMTCkKIAkJcmV0dXJuOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IG51bV9ic3M9JXUgY29uZi0+bnVtX2Jzcz0ldSIsCisJCSAgIF9fZnVuY19fLCAodW5zaWduZWQgaW50KSBpZmFjZS0+bnVtX2JzcywKKwkJICAgKHVuc2lnbmVkIGludCkgaWZhY2UtPmNvbmYtPm51bV9ic3MpOwogCWRyaXZlciA9IGlmYWNlLT5ic3NbMF0tPmRyaXZlcjsKIAlkcnZfcHJpdiA9IGlmYWNlLT5ic3NbMF0tPmRydl9wcml2OwogCWhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdChpZmFjZSk7Ci0JaWYgKGRyaXZlciAmJiBkcml2ZXItPmhhcGRfZGVpbml0ICYmIGRydl9wcml2KQorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGRyaXZlcj0lcCBkcnZfcHJpdj0lcCAtPiBoYXBkX2RlaW5pdCIsCisJCSAgIF9fZnVuY19fLCBkcml2ZXIsIGRydl9wcml2KTsKKwlpZiAoZHJpdmVyICYmIGRyaXZlci0+aGFwZF9kZWluaXQgJiYgZHJ2X3ByaXYpIHsKIAkJZHJpdmVyLT5oYXBkX2RlaW5pdChkcnZfcHJpdik7CisJCWlmYWNlLT5ic3NbMF0tPmRydl9wcml2ID0gTlVMTDsKKwl9CiAJaG9zdGFwZF9pbnRlcmZhY2VfZnJlZShpZmFjZSk7CiB9CiAKIAorc3RhdGljIHZvaWQgaG9zdGFwZF9kZWluaXRfZHJpdmVyKGNvbnN0IHN0cnVjdCB3cGFfZHJpdmVyX29wcyAqZHJpdmVyLAorCQkJCSAgdm9pZCAqZHJ2X3ByaXYsCisJCQkJICBzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaGFwZF9pZmFjZSkKK3sKKwlzaXplX3QgajsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGRyaXZlcj0lcCBkcnZfcHJpdj0lcCAtPiBoYXBkX2RlaW5pdCIsCisJCSAgIF9fZnVuY19fLCBkcml2ZXIsIGRydl9wcml2KTsKKwlpZiAoZHJpdmVyICYmIGRyaXZlci0+aGFwZF9kZWluaXQgJiYgZHJ2X3ByaXYpIHsKKwkJZHJpdmVyLT5oYXBkX2RlaW5pdChkcnZfcHJpdik7CisJCWZvciAoaiA9IDA7IGogPCBoYXBkX2lmYWNlLT5udW1fYnNzOyBqKyspIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6YnNzWyVkXS0+ZHJ2X3ByaXY9JXAiLAorCQkJCSAgIF9fZnVuY19fLCAoaW50KSBqLAorCQkJCSAgIGhhcGRfaWZhY2UtPmJzc1tqXS0+ZHJ2X3ByaXYpOworCQkJaWYgKGhhcGRfaWZhY2UtPmJzc1tqXS0+ZHJ2X3ByaXYgPT0gZHJ2X3ByaXYpCisJCQkJaGFwZF9pZmFjZS0+YnNzW2pdLT5kcnZfcHJpdiA9IE5VTEw7CisJCX0KKwl9Cit9CisKKwogaW50IGhvc3RhcGRfZW5hYmxlX2lmYWNlKHN0cnVjdCBob3N0YXBkX2lmYWNlICpoYXBkX2lmYWNlKQogeworCXNpemVfdCBqOworCiAJaWYgKGhhcGRfaWZhY2UtPmJzc1swXS0+ZHJ2X3ByaXYgIT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkludGVyZmFjZSAlcyBhbHJlYWR5IGVuYWJsZWQiLAotCQkJICAgaGFwZF9pZmFjZS0+Y29uZi0+YnNzWzBdLmlmYWNlKTsKKwkJCSAgIGhhcGRfaWZhY2UtPmNvbmYtPmJzc1swXS0+aWZhY2UpOwogCQlyZXR1cm4gLTE7CiAJfQogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFbmFibGUgaW50ZXJmYWNlICVzIiwKLQkJICAgaGFwZF9pZmFjZS0+Y29uZi0+YnNzWzBdLmlmYWNlKTsKKwkJICAgaGFwZF9pZmFjZS0+Y29uZi0+YnNzWzBdLT5pZmFjZSk7CisKKwlmb3IgKGogPSAwOyBqIDwgaGFwZF9pZmFjZS0+bnVtX2JzczsgaisrKQorCQlob3N0YXBkX3NldF9zZWN1cml0eV9wYXJhbXMoaGFwZF9pZmFjZS0+Y29uZi0+YnNzW2pdLCAxKTsKKwlpZiAoaG9zdGFwZF9jb25maWdfY2hlY2soaGFwZF9pZmFjZS0+Y29uZiwgMSkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbnZhbGlkIGNvbmZpZ3VyYXRpb24gLSBjYW5ub3QgZW5hYmxlIik7CisJCXJldHVybiAtMTsKKwl9CiAKIAlpZiAoaGFwZF9pZmFjZS0+aW50ZXJmYWNlcyA9PSBOVUxMIHx8CiAJICAgIGhhcGRfaWZhY2UtPmludGVyZmFjZXMtPmRyaXZlcl9pbml0ID09IE5VTEwgfHwKLQkgICAgaGFwZF9pZmFjZS0+aW50ZXJmYWNlcy0+ZHJpdmVyX2luaXQoaGFwZF9pZmFjZSkgfHwKLQkgICAgaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2UoaGFwZF9pZmFjZSkpIHsKLQkJaG9zdGFwZF9pbnRlcmZhY2VfZGVpbml0X2ZyZWUoaGFwZF9pZmFjZSk7CisJICAgIGhhcGRfaWZhY2UtPmludGVyZmFjZXMtPmRyaXZlcl9pbml0KGhhcGRfaWZhY2UpKQorCQlyZXR1cm4gLTE7CisKKwlpZiAoaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2UoaGFwZF9pZmFjZSkpIHsKKwkJaG9zdGFwZF9kZWluaXRfZHJpdmVyKGhhcGRfaWZhY2UtPmJzc1swXS0+ZHJpdmVyLAorCQkJCSAgICAgIGhhcGRfaWZhY2UtPmJzc1swXS0+ZHJ2X3ByaXYsCisJCQkJICAgICAgaGFwZF9pZmFjZSk7CiAJCXJldHVybiAtMTsKIAl9CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTE2OSwxOSArMTY4NSwxNyBAQAogCXNpemVfdCBqOwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSZWxvYWQgaW50ZXJmYWNlICVzIiwKLQkJICAgaGFwZF9pZmFjZS0+Y29uZi0+YnNzWzBdLmlmYWNlKTsKLQlmb3IgKGogPSAwOyBqIDwgaGFwZF9pZmFjZS0+bnVtX2JzczsgaisrKSB7Ci0JCWhvc3RhcGRfZmx1c2hfb2xkX3N0YXRpb25zKGhhcGRfaWZhY2UtPmJzc1tqXSwKLQkJCQkJICAgV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7Ci0KLSNpZm5kZWYgQ09ORklHX05PX1JBRElVUwotCQkvKiBUT0RPOiB1cGRhdGUgZHluYW1pYyBkYXRhIGJhc2VkIG9uIGNoYW5nZWQgY29uZmlndXJhdGlvbgotCQkgKiBpdGVtcyAoZS5nLiwgb3Blbi9jbG9zZSBzb2NrZXRzLCBldGMuKSAqLwotCQlyYWRpdXNfY2xpZW50X2ZsdXNoKGhhcGRfaWZhY2UtPmJzc1tqXS0+cmFkaXVzLCAwKTsKLSNlbmRpZiAgLyogQ09ORklHX05PX1JBRElVUyAqLwotCi0JCWhvc3RhcGRfcmVsb2FkX2JzcyhoYXBkX2lmYWNlLT5ic3Nbal0pOworCQkgICBoYXBkX2lmYWNlLT5jb25mLT5ic3NbMF0tPmlmYWNlKTsKKwlmb3IgKGogPSAwOyBqIDwgaGFwZF9pZmFjZS0+bnVtX2JzczsgaisrKQorCQlob3N0YXBkX3NldF9zZWN1cml0eV9wYXJhbXMoaGFwZF9pZmFjZS0+Y29uZi0+YnNzW2pdLCAxKTsKKwlpZiAoaG9zdGFwZF9jb25maWdfY2hlY2soaGFwZF9pZmFjZS0+Y29uZiwgMSkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiVXBkYXRlZCBjb25maWd1cmF0aW9uIGlzIGludmFsaWQiKTsKKwkJcmV0dXJuIC0xOwogCX0KKwlob3N0YXBkX2NsZWFyX29sZChoYXBkX2lmYWNlKTsKKwlmb3IgKGogPSAwOyBqIDwgaGFwZF9pZmFjZS0+bnVtX2JzczsgaisrKQorCQlob3N0YXBkX3JlbG9hZF9ic3MoaGFwZF9pZmFjZS0+YnNzW2pdKTsKKwogCXJldHVybiAwOwogfQogCkBAIC0xMTg5LDM5ICsxNzAzLDQzIEBACiBpbnQgaG9zdGFwZF9kaXNhYmxlX2lmYWNlKHN0cnVjdCBob3N0YXBkX2lmYWNlICpoYXBkX2lmYWNlKQogewogCXNpemVfdCBqOwotCXN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzczsKIAljb25zdCBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgKmRyaXZlcjsKIAl2b2lkICpkcnZfcHJpdjsKIAogCWlmIChoYXBkX2lmYWNlID09IE5VTEwpCiAJCXJldHVybiAtMTsKLQlic3MgPSBoYXBkX2lmYWNlLT5ic3NbMF0tPmNvbmY7CisKKwlpZiAoaGFwZF9pZmFjZS0+YnNzWzBdLT5kcnZfcHJpdiA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbnRlcmZhY2UgJXMgYWxyZWFkeSBkaXNhYmxlZCIsCisJCQkgICBoYXBkX2lmYWNlLT5jb25mLT5ic3NbMF0tPmlmYWNlKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXdwYV9tc2coaGFwZF9pZmFjZS0+YnNzWzBdLT5tc2dfY3R4LCBNU0dfSU5GTywgQVBfRVZFTlRfRElTQUJMRUQpOwogCWRyaXZlciA9IGhhcGRfaWZhY2UtPmJzc1swXS0+ZHJpdmVyOwogCWRydl9wcml2ID0gaGFwZF9pZmFjZS0+YnNzWzBdLT5kcnZfcHJpdjsKIAotCS8qIHdoYXRldmVyIGhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdCBkb2VzICovCisJaGFwZF9pZmFjZS0+ZHJpdmVyX2FwX3RlYXJkb3duID0KKwkJISEoaGFwZF9pZmFjZS0+ZHJ2X2ZsYWdzICYKKwkJICAgV1BBX0RSSVZFUl9GTEFHU19BUF9URUFSRE9XTl9TVVBQT1JUKTsKKworCS8qIHNhbWUgYXMgaG9zdGFwZF9pbnRlcmZhY2VfZGVpbml0IHdpdGhvdXQgZGVpbml0aWFsaXppbmcgY3RybC1pZmFjZSAqLwogCWZvciAoaiA9IDA7IGogPCBoYXBkX2lmYWNlLT5udW1fYnNzOyBqKyspIHsKIAkJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGhhcGRfaWZhY2UtPmJzc1tqXTsKLQkJaG9zdGFwZF9mcmVlX3N0YXMoaGFwZCk7Ci0JCWhvc3RhcGRfZmx1c2hfb2xkX3N0YXRpb25zKGhhcGQsIFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HKTsKLQkJaG9zdGFwZF9jbGVhcl93ZXAoaGFwZCk7CisJCWhvc3RhcGRfYnNzX2RlaW5pdF9ub19mcmVlKGhhcGQpOwogCQlob3N0YXBkX2ZyZWVfaGFwZF9kYXRhKGhhcGQpOwogCX0KIAotCWlmIChkcml2ZXIgJiYgZHJpdmVyLT5oYXBkX2RlaW5pdCAmJiBkcnZfcHJpdikgewotCQlkcml2ZXItPmhhcGRfZGVpbml0KGRydl9wcml2KTsKLQkJaGFwZF9pZmFjZS0+YnNzWzBdLT5kcnZfcHJpdiA9IE5VTEw7Ci0JfQorCWhvc3RhcGRfZGVpbml0X2RyaXZlcihkcml2ZXIsIGRydl9wcml2LCBoYXBkX2lmYWNlKTsKIAogCS8qIEZyb20gaG9zdGFwZF9jbGVhbnVwX2lmYWNlOiBUaGVzZSB3ZXJlIGluaXRpYWxpemVkIGluCiAJICogaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2UgYW5kIGhvc3RhcGRfc2V0dXBfaW50ZXJmYWNlX2NvbXBsZXRlCiAJICovCiAJaG9zdGFwZF9jbGVhbnVwX2lmYWNlX3BhcnRpYWwoaGFwZF9pZmFjZSk7Ci0JYnNzLT53cGEgPSAwOwotCWJzcy0+d3BhX2tleV9tZ210ID0gLTE7Ci0JYnNzLT53cGFfcGFpcndpc2UgPSAtMTsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJmYWNlICVzIGRpc2FibGVkIiwgYnNzLT5pZmFjZSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcmZhY2UgJXMgZGlzYWJsZWQiLAorCQkgICBoYXBkX2lmYWNlLT5ic3NbMF0tPmNvbmYtPmlmYWNlKTsKKwlob3N0YXBkX3NldF9zdGF0ZShoYXBkX2lmYWNlLCBIQVBEX0lGQUNFX0RJU0FCTEVEKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTI3Miw3ICsxNzkwLDcgQEAKIAkJcmV0dXJuIE5VTEw7CiAJfQogCi0JYnNzID0gY29uZi0+bGFzdF9ic3MgPSBjb25mLT5ic3M7CisJYnNzID0gY29uZi0+bGFzdF9ic3MgPSBjb25mLT5ic3NbMF07CiAKIAlvc19zdHJsY3B5KGJzcy0+aWZhY2UsIGlmbmFtZSwgc2l6ZW9mKGJzcy0+aWZhY2UpKTsKIAlic3MtPmN0cmxfaW50ZXJmYWNlID0gb3Nfc3RyZHVwKGN0cmxfaWZhY2UpOwpAQCAtMTMwNyw4ICsxODI1LDcgQEAKIAogCWZvciAoaSA9IDA7IGkgPCBjb25mLT5udW1fYnNzOyBpKyspIHsKIAkJaGFwZCA9IGhhcGRfaWZhY2UtPmJzc1tpXSA9Ci0JCQlob3N0YXBkX2FsbG9jX2Jzc19kYXRhKGhhcGRfaWZhY2UsIGNvbmYsCi0JCQkJCSAgICAgICAmY29uZi0+YnNzW2ldKTsKKwkJCWhvc3RhcGRfYWxsb2NfYnNzX2RhdGEoaGFwZF9pZmFjZSwgY29uZiwgY29uZi0+YnNzW2ldKTsKIAkJaWYgKGhhcGQgPT0gTlVMTCkKIAkJCXJldHVybiBOVUxMOwogCQloYXBkLT5tc2dfY3R4ID0gaGFwZDsKQEAgLTEzMjMsMTcgKzE4NDAsODUgQEAKIGludCBob3N0YXBkX2FkZF9pZmFjZShzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICppbnRlcmZhY2VzLCBjaGFyICpidWYpCiB7CiAJc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mID0gTlVMTDsKLQlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaGFwZF9pZmFjZSA9IE5VTEw7CisJc3RydWN0IGhvc3RhcGRfaWZhY2UgKmhhcGRfaWZhY2UgPSBOVUxMLCAqbmV3X2lmYWNlID0gTlVMTDsKKwlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkOwogCWNoYXIgKnB0cjsKLQlzaXplX3QgaTsKKwlzaXplX3QgaSwgajsKKwljb25zdCBjaGFyICpjb25mX2ZpbGUgPSBOVUxMLCAqcGh5X25hbWUgPSBOVUxMOworCisJaWYgKG9zX3N0cm5jbXAoYnVmLCAiYnNzX2NvbmZpZz0iLCAxMSkgPT0gMCkgeworCQljaGFyICpwb3M7CisJCXBoeV9uYW1lID0gYnVmICsgMTE7CisJCXBvcyA9IG9zX3N0cmNocihwaHlfbmFtZSwgJzonKTsKKwkJaWYgKCFwb3MpCisJCQlyZXR1cm4gLTE7CisJCSpwb3MrKyA9ICdcMCc7CisJCWNvbmZfZmlsZSA9IHBvczsKKwkJaWYgKCFvc19zdHJsZW4oY29uZl9maWxlKSkKKwkJCXJldHVybiAtMTsKKworCQloYXBkX2lmYWNlID0gaG9zdGFwZF9pbnRlcmZhY2VfaW5pdF9ic3MoaW50ZXJmYWNlcywgcGh5X25hbWUsCisJCQkJCQkJY29uZl9maWxlLCAwKTsKKwkJaWYgKCFoYXBkX2lmYWNlKQorCQkJcmV0dXJuIC0xOworCQlmb3IgKGogPSAwOyBqIDwgaW50ZXJmYWNlcy0+Y291bnQ7IGorKykgeworCQkJaWYgKGludGVyZmFjZXMtPmlmYWNlW2pdID09IGhhcGRfaWZhY2UpCisJCQkJYnJlYWs7CisJCX0KKwkJaWYgKGogPT0gaW50ZXJmYWNlcy0+Y291bnQpIHsKKwkJCXN0cnVjdCBob3N0YXBkX2lmYWNlICoqdG1wOworCQkJdG1wID0gb3NfcmVhbGxvY19hcnJheShpbnRlcmZhY2VzLT5pZmFjZSwKKwkJCQkJICAgICAgIGludGVyZmFjZXMtPmNvdW50ICsgMSwKKwkJCQkJICAgICAgIHNpemVvZihzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqKSk7CisJCQlpZiAoIXRtcCkgeworCQkJCWhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdF9mcmVlKGhhcGRfaWZhY2UpOworCQkJCXJldHVybiAtMTsKKwkJCX0KKwkJCWludGVyZmFjZXMtPmlmYWNlID0gdG1wOworCQkJaW50ZXJmYWNlcy0+aWZhY2VbaW50ZXJmYWNlcy0+Y291bnQrK10gPSBoYXBkX2lmYWNlOworCQkJbmV3X2lmYWNlID0gaGFwZF9pZmFjZTsKKwkJfQorCisJCWlmIChuZXdfaWZhY2UpIHsKKwkJCWlmIChpbnRlcmZhY2VzLT5kcml2ZXJfaW5pdChoYXBkX2lmYWNlKSB8fAorCQkJICAgIGhvc3RhcGRfc2V0dXBfaW50ZXJmYWNlKGhhcGRfaWZhY2UpKSB7CisJCQkJaW50ZXJmYWNlcy0+Y291bnQtLTsKKwkJCQlnb3RvIGZhaWw7CisJCQl9CisJCX0gZWxzZSB7CisJCQkvKiBBc3NpZ24gbmV3IEJTUyB3aXRoIGJzc1swXSdzIGRyaXZlciBpbmZvICovCisJCQloYXBkID0gaGFwZF9pZmFjZS0+YnNzW2hhcGRfaWZhY2UtPm51bV9ic3MgLSAxXTsKKwkJCWhhcGQtPmRyaXZlciA9IGhhcGRfaWZhY2UtPmJzc1swXS0+ZHJpdmVyOworCQkJaGFwZC0+ZHJ2X3ByaXYgPSBoYXBkX2lmYWNlLT5ic3NbMF0tPmRydl9wcml2OworCQkJb3NfbWVtY3B5KGhhcGQtPm93bl9hZGRyLCBoYXBkX2lmYWNlLT5ic3NbMF0tPm93bl9hZGRyLAorCQkJCSAgRVRIX0FMRU4pOworCisJCQlpZiAoc3RhcnRfY3RybF9pZmFjZV9ic3MoaGFwZCkgPCAwIHx8CisJCQkgICAgKGhhcGRfaWZhY2UtPnN0YXRlID09IEhBUERfSUZBQ0VfRU5BQkxFRCAmJgorCQkJICAgICBob3N0YXBkX3NldHVwX2JzcyhoYXBkLCAtMSkpKSB7CisJCQkJaG9zdGFwZF9jbGVhbnVwKGhhcGQpOworCQkJCWhhcGRfaWZhY2UtPmJzc1toYXBkX2lmYWNlLT5udW1fYnNzIC0gMV0gPSBOVUxMOworCQkJCWhhcGRfaWZhY2UtPmNvbmYtPm51bV9ic3MtLTsKKwkJCQloYXBkX2lmYWNlLT5udW1fYnNzLS07CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogZnJlZSBoYXBkICVwICVzIiwKKwkJCQkJICAgX19mdW5jX18sIGhhcGQsIGhhcGQtPmNvbmYtPmlmYWNlKTsKKwkJCQlvc19mcmVlKGhhcGQpOworCQkJCXJldHVybiAtMTsKKwkJCX0KKwkJfQorCQlyZXR1cm4gMDsKKwl9CiAKIAlwdHIgPSBvc19zdHJjaHIoYnVmLCAnICcpOwogCWlmIChwdHIgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCSpwdHIrKyA9ICdcMCc7CiAKKwlpZiAob3Nfc3RybmNtcChwdHIsICJjb25maWc9IiwgNykgPT0gMCkKKwkJY29uZl9maWxlID0gcHRyICsgNzsKKwogCWZvciAoaSA9IDA7IGkgPCBpbnRlcmZhY2VzLT5jb3VudDsgaSsrKSB7Ci0JCWlmICghb3Nfc3RyY21wKGludGVyZmFjZXMtPmlmYWNlW2ldLT5jb25mLT5ic3NbMF0uaWZhY2UsCisJCWlmICghb3Nfc3RyY21wKGludGVyZmFjZXMtPmlmYWNlW2ldLT5jb25mLT5ic3NbMF0tPmlmYWNlLAogCQkJICAgICAgIGJ1ZikpIHsKIAkJCXdwYV9wcmludGYoTVNHX0lORk8sICJDYW5ub3QgYWRkIGludGVyZmFjZSAtIGl0ICIKIAkJCQkgICAiYWxyZWFkeSBleGlzdHMiKTsKQEAgLTEzNDgsOCArMTkzMywxNCBAQAogCQlnb3RvIGZhaWw7CiAJfQogCi0JY29uZiA9IGhvc3RhcGRfY29uZmlnX2FsbG9jKGludGVyZmFjZXMsIGJ1ZiwgcHRyKTsKLQlpZiAoY29uZiA9PSBOVUxMKSB7CisJaWYgKGNvbmZfZmlsZSAmJiBpbnRlcmZhY2VzLT5jb25maWdfcmVhZF9jYikgeworCQljb25mID0gaW50ZXJmYWNlcy0+Y29uZmlnX3JlYWRfY2IoY29uZl9maWxlKTsKKwkJaWYgKGNvbmYgJiYgY29uZi0+YnNzKQorCQkJb3Nfc3RybGNweShjb25mLT5ic3NbMF0tPmlmYWNlLCBidWYsCisJCQkJICAgc2l6ZW9mKGNvbmYtPmJzc1swXS0+aWZhY2UpKTsKKwl9IGVsc2UKKwkJY29uZiA9IGhvc3RhcGRfY29uZmlnX2FsbG9jKGludGVyZmFjZXMsIGJ1ZiwgcHRyKTsKKwlpZiAoY29uZiA9PSBOVUxMIHx8IGNvbmYtPmJzcyA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IEZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgIgogCQkJICAgImZvciBjb25maWd1cmF0aW9uIiwgX19mdW5jX18pOwogCQlnb3RvIGZhaWw7CkBAIC0xMzYyLDE0ICsxOTUzLDEwIEBACiAJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAoaGFwZF9pZmFjZS0+aW50ZXJmYWNlcyAmJgotCSAgICBoYXBkX2lmYWNlLT5pbnRlcmZhY2VzLT5jdHJsX2lmYWNlX2luaXQgJiYKLQkgICAgaGFwZF9pZmFjZS0+aW50ZXJmYWNlcy0+Y3RybF9pZmFjZV9pbml0KGhhcGRfaWZhY2UtPmJzc1swXSkpIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICIlczogRmFpbGVkIHRvIHNldHVwIGNvbnRyb2wgIgotCQkJICAgImludGVyZmFjZSIsIF9fZnVuY19fKTsKKwlpZiAoc3RhcnRfY3RybF9pZmFjZShoYXBkX2lmYWNlKSA8IDApCiAJCWdvdG8gZmFpbDsKLQl9Ci0Jd3BhX3ByaW50ZihNU0dfSU5GTywgIkFkZCBpbnRlcmZhY2UgJyVzJyIsIGNvbmYtPmJzc1swXS5pZmFjZSk7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQWRkIGludGVyZmFjZSAnJXMnIiwgY29uZi0+YnNzWzBdLT5pZmFjZSk7CiAKIAlyZXR1cm4gMDsKIApAQCAtMTM3NywyNCArMTk2NCw3OSBAQAogCWlmIChjb25mKQogCQlob3N0YXBkX2NvbmZpZ19mcmVlKGNvbmYpOwogCWlmIChoYXBkX2lmYWNlKSB7Ci0JCW9zX2ZyZWUoaGFwZF9pZmFjZS0+YnNzW2ludGVyZmFjZXMtPmNvdW50XSk7CisJCWlmIChoYXBkX2lmYWNlLT5ic3MpIHsKKwkJCWZvciAoaSA9IDA7IGkgPCBoYXBkX2lmYWNlLT5udW1fYnNzOyBpKyspIHsKKwkJCQloYXBkID0gaGFwZF9pZmFjZS0+YnNzW2ldOworCQkJCWlmICghaGFwZCkKKwkJCQkJY29udGludWU7CisJCQkJaWYgKGhhcGRfaWZhY2UtPmludGVyZmFjZXMgJiYKKwkJCQkgICAgaGFwZF9pZmFjZS0+aW50ZXJmYWNlcy0+Y3RybF9pZmFjZV9kZWluaXQpCisJCQkJCWhhcGRfaWZhY2UtPmludGVyZmFjZXMtPgorCQkJCQkJY3RybF9pZmFjZV9kZWluaXQoaGFwZCk7CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogZnJlZSBoYXBkICVwICglcykiLAorCQkJCQkgICBfX2Z1bmNfXywgaGFwZF9pZmFjZS0+YnNzW2ldLAorCQkJCQkgICBoYXBkLT5jb25mLT5pZmFjZSk7CisJCQkJb3NfZnJlZShoYXBkKTsKKwkJCQloYXBkX2lmYWNlLT5ic3NbaV0gPSBOVUxMOworCQkJfQorCQkJb3NfZnJlZShoYXBkX2lmYWNlLT5ic3MpOworCQl9CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGZyZWUgaWZhY2UgJXAiLAorCQkJICAgX19mdW5jX18sIGhhcGRfaWZhY2UpOwogCQlvc19mcmVlKGhhcGRfaWZhY2UpOwogCX0KIAlyZXR1cm4gLTE7CiB9CiAKIAorc3RhdGljIGludCBob3N0YXBkX3JlbW92ZV9ic3Moc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCB1bnNpZ25lZCBpbnQgaWR4KQoreworCXNpemVfdCBpOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlbW92ZSBCU1MgJyVzJyIsIGlmYWNlLT5jb25mLT5ic3NbaWR4XS0+aWZhY2UpOworCisJLyogUmVtb3ZlIGhvc3RhcGRfZGF0YSBvbmx5IGlmIGl0IGhhcyBhbHJlYWR5IGJlZW4gaW5pdGlhbGl6ZWQgKi8KKwlpZiAoaWR4IDwgaWZhY2UtPm51bV9ic3MpIHsKKwkJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGlmYWNlLT5ic3NbaWR4XTsKKworCQlob3N0YXBkX2Jzc19kZWluaXQoaGFwZCk7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGZyZWUgaGFwZCAlcCAoJXMpIiwKKwkJCSAgIF9fZnVuY19fLCBoYXBkLCBoYXBkLT5jb25mLT5pZmFjZSk7CisJCWhvc3RhcGRfY29uZmlnX2ZyZWVfYnNzKGhhcGQtPmNvbmYpOworCQlvc19mcmVlKGhhcGQpOworCisJCWlmYWNlLT5udW1fYnNzLS07CisKKwkJZm9yIChpID0gaWR4OyBpIDwgaWZhY2UtPm51bV9ic3M7IGkrKykKKwkJCWlmYWNlLT5ic3NbaV0gPSBpZmFjZS0+YnNzW2kgKyAxXTsKKwl9IGVsc2UgeworCQlob3N0YXBkX2NvbmZpZ19mcmVlX2JzcyhpZmFjZS0+Y29uZi0+YnNzW2lkeF0pOworCQlpZmFjZS0+Y29uZi0+YnNzW2lkeF0gPSBOVUxMOworCX0KKworCWlmYWNlLT5jb25mLT5udW1fYnNzLS07CisJZm9yIChpID0gaWR4OyBpIDwgaWZhY2UtPmNvbmYtPm51bV9ic3M7IGkrKykKKwkJaWZhY2UtPmNvbmYtPmJzc1tpXSA9IGlmYWNlLT5jb25mLT5ic3NbaSArIDFdOworCisJcmV0dXJuIDA7Cit9CisKKwogaW50IGhvc3RhcGRfcmVtb3ZlX2lmYWNlKHN0cnVjdCBoYXBkX2ludGVyZmFjZXMgKmludGVyZmFjZXMsIGNoYXIgKmJ1ZikKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaGFwZF9pZmFjZTsKLQlzaXplX3QgaSwgayA9IDA7CisJc2l6ZV90IGksIGosIGsgPSAwOwogCiAJZm9yIChpID0gMDsgaSA8IGludGVyZmFjZXMtPmNvdW50OyBpKyspIHsKIAkJaGFwZF9pZmFjZSA9IGludGVyZmFjZXMtPmlmYWNlW2ldOwogCQlpZiAoaGFwZF9pZmFjZSA9PSBOVUxMKQogCQkJcmV0dXJuIC0xOwotCQlpZiAoIW9zX3N0cmNtcChoYXBkX2lmYWNlLT5jb25mLT5ic3NbMF0uaWZhY2UsIGJ1ZikpIHsKKwkJaWYgKCFvc19zdHJjbXAoaGFwZF9pZmFjZS0+Y29uZi0+YnNzWzBdLT5pZmFjZSwgYnVmKSkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlbW92ZSBpbnRlcmZhY2UgJyVzJyIsIGJ1Zik7CisJCQloYXBkX2lmYWNlLT5kcml2ZXJfYXBfdGVhcmRvd24gPQorCQkJCSEhKGhhcGRfaWZhY2UtPmRydl9mbGFncyAmCisJCQkJICAgV1BBX0RSSVZFUl9GTEFHU19BUF9URUFSRE9XTl9TVVBQT1JUKTsKKwogCQkJaG9zdGFwZF9pbnRlcmZhY2VfZGVpbml0X2ZyZWUoaGFwZF9pZmFjZSk7CiAJCQlrID0gaTsKIAkJCXdoaWxlIChrIDwgKGludGVyZmFjZXMtPmNvdW50IC0gMSkpIHsKQEAgLTE0MDUsMTIgKzIwNDcsMTkgQEAKIAkJCWludGVyZmFjZXMtPmNvdW50LS07CiAJCQlyZXR1cm4gMDsKIAkJfQorCisJCWZvciAoaiA9IDA7IGogPCBoYXBkX2lmYWNlLT5jb25mLT5udW1fYnNzOyBqKyspIHsKKwkJCWlmICghb3Nfc3RyY21wKGhhcGRfaWZhY2UtPmNvbmYtPmJzc1tqXS0+aWZhY2UsIGJ1ZikpIHsKKwkJCQloYXBkX2lmYWNlLT5kcml2ZXJfYXBfdGVhcmRvd24gPQorCQkJCQkhKGhhcGRfaWZhY2UtPmRydl9mbGFncyAmCisJCQkJCSAgV1BBX0RSSVZFUl9GTEFHU19BUF9URUFSRE9XTl9TVVBQT1JUKTsKKwkJCQlyZXR1cm4gaG9zdGFwZF9yZW1vdmVfYnNzKGhhcGRfaWZhY2UsIGopOworCQkJfQorCQl9CiAJfQogCXJldHVybiAtMTsKIH0KIAotI2VuZGlmIC8qIEhPU1RBUEQgKi8KLQogCiAvKioKICAqIGhvc3RhcGRfbmV3X2Fzc29jX3N0YSAtIE5vdGlmeSB0aGF0IGEgbmV3IHN0YXRpb24gYXNzb2NpYXRlZCB3aXRoIHRoZSBBUApAQCAtMTQ1MCw4ICsyMDk5LDkgQEAKIAkvKiBTdGFydCBhY2NvdW50aW5nIGhlcmUsIGlmIElFRUUgODAyLjFYIGFuZCBXUEEgYXJlIG5vdCB1c2VkLgogCSAqIElFRUUgODAyLjFYL1dQQSBjb2RlIHdpbGwgc3RhcnQgYWNjb3VudGluZyBhZnRlciB0aGUgc3RhdGlvbiBoYXMKIAkgKiBiZWVuIGF1dGhvcml6ZWQuICovCi0JaWYgKCFoYXBkLT5jb25mLT5pZWVlODAyXzF4ICYmICFoYXBkLT5jb25mLT53cGEpIHsKLQkJb3NfZ2V0X3RpbWUoJnN0YS0+Y29ubmVjdGVkX3RpbWUpOworCWlmICghaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCAmJiAhaGFwZC0+Y29uZi0+d3BhICYmICFoYXBkLT5jb25mLT5vc2VuKSB7CisJCWFwX3N0YV9zZXRfYXV0aG9yaXplZChoYXBkLCBzdGEsIDEpOworCQlvc19nZXRfcmVsdGltZSgmc3RhLT5jb25uZWN0ZWRfdGltZSk7CiAJCWFjY291bnRpbmdfc3RhX3N0YXJ0KGhhcGQsIHN0YSk7CiAJfQogCkBAIC0xNDY0LDExICsyMTE0LDMyOSBAQAogCX0gZWxzZQogCQl3cGFfYXV0aF9zdGFfYXNzb2NpYXRlZChoYXBkLT53cGFfYXV0aCwgc3RhLT53cGFfc20pOwogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogcmVzY2hlZHVsZSBhcF9oYW5kbGVfdGltZXIgdGltZW91dCAiCi0JCSAgICJmb3IgIiBNQUNTVFIgIiAoJWQgc2Vjb25kcyAtIGFwX21heF9pbmFjdGl2aXR5KSIsCi0JCSAgIF9fZnVuY19fLCBNQUMyU1RSKHN0YS0+YWRkciksCi0JCSAgIGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5KTsKLQllbG9vcF9jYW5jZWxfdGltZW91dChhcF9oYW5kbGVfdGltZXIsIGhhcGQsIHN0YSk7Ci0JZWxvb3BfcmVnaXN0ZXJfdGltZW91dChoYXBkLT5jb25mLT5hcF9tYXhfaW5hY3Rpdml0eSwgMCwKLQkJCSAgICAgICBhcF9oYW5kbGVfdGltZXIsIGhhcGQsIHN0YSk7CisJaWYgKCEoaGFwZC0+aWZhY2UtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfSU5BQ1RJVklUWV9USU1FUikpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogcmVzY2hlZHVsZSBhcF9oYW5kbGVfdGltZXIgdGltZW91dCAiCisJCQkgICAiZm9yICIgTUFDU1RSICIgKCVkIHNlY29uZHMgLSBhcF9tYXhfaW5hY3Rpdml0eSkiLAorCQkJICAgX19mdW5jX18sIE1BQzJTVFIoc3RhLT5hZGRyKSwKKwkJCSAgIGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5KTsKKwkJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5LCAwLAorCQkJCSAgICAgICBhcF9oYW5kbGVfdGltZXIsIGhhcGQsIHN0YSk7CisJfQogfQorCisKK2NvbnN0IGNoYXIgKiBob3N0YXBkX3N0YXRlX3RleHQoZW51bSBob3N0YXBkX2lmYWNlX3N0YXRlIHMpCit7CisJc3dpdGNoIChzKSB7CisJY2FzZSBIQVBEX0lGQUNFX1VOSU5JVElBTElaRUQ6CisJCXJldHVybiAiVU5JTklUSUFMSVpFRCI7CisJY2FzZSBIQVBEX0lGQUNFX0RJU0FCTEVEOgorCQlyZXR1cm4gIkRJU0FCTEVEIjsKKwljYXNlIEhBUERfSUZBQ0VfQ09VTlRSWV9VUERBVEU6CisJCXJldHVybiAiQ09VTlRSWV9VUERBVEUiOworCWNhc2UgSEFQRF9JRkFDRV9BQ1M6CisJCXJldHVybiAiQUNTIjsKKwljYXNlIEhBUERfSUZBQ0VfSFRfU0NBTjoKKwkJcmV0dXJuICJIVF9TQ0FOIjsKKwljYXNlIEhBUERfSUZBQ0VfREZTOgorCQlyZXR1cm4gIkRGUyI7CisJY2FzZSBIQVBEX0lGQUNFX0VOQUJMRUQ6CisJCXJldHVybiAiRU5BQkxFRCI7CisJfQorCisJcmV0dXJuICJVTktOT1dOIjsKK30KKworCit2b2lkIGhvc3RhcGRfc2V0X3N0YXRlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgZW51bSBob3N0YXBkX2lmYWNlX3N0YXRlIHMpCit7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIiVzOiBpbnRlcmZhY2Ugc3RhdGUgJXMtPiVzIiwKKwkJICAgaWZhY2UtPmNvbmYtPmJzc1swXS0+aWZhY2UsIGhvc3RhcGRfc3RhdGVfdGV4dChpZmFjZS0+c3RhdGUpLAorCQkgICBob3N0YXBkX3N0YXRlX3RleHQocykpOworCWlmYWNlLT5zdGF0ZSA9IHM7Cit9CisKKworI2lmZGVmIE5FRURfQVBfTUxNRQorCitzdGF0aWMgdm9pZCBmcmVlX2JlYWNvbl9kYXRhKHN0cnVjdCBiZWFjb25fZGF0YSAqYmVhY29uKQoreworCW9zX2ZyZWUoYmVhY29uLT5oZWFkKTsKKwliZWFjb24tPmhlYWQgPSBOVUxMOworCW9zX2ZyZWUoYmVhY29uLT50YWlsKTsKKwliZWFjb24tPnRhaWwgPSBOVUxMOworCW9zX2ZyZWUoYmVhY29uLT5wcm9iZV9yZXNwKTsKKwliZWFjb24tPnByb2JlX3Jlc3AgPSBOVUxMOworCW9zX2ZyZWUoYmVhY29uLT5iZWFjb25faWVzKTsKKwliZWFjb24tPmJlYWNvbl9pZXMgPSBOVUxMOworCW9zX2ZyZWUoYmVhY29uLT5wcm9iZXJlc3BfaWVzKTsKKwliZWFjb24tPnByb2JlcmVzcF9pZXMgPSBOVUxMOworCW9zX2ZyZWUoYmVhY29uLT5hc3NvY3Jlc3BfaWVzKTsKKwliZWFjb24tPmFzc29jcmVzcF9pZXMgPSBOVUxMOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9idWlsZF9iZWFjb25fZGF0YShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgICAgc3RydWN0IGJlYWNvbl9kYXRhICpiZWFjb24pCit7CisJc3RydWN0IHdwYWJ1ZiAqYmVhY29uX2V4dHJhLCAqcHJvYmVyZXNwX2V4dHJhLCAqYXNzb2NyZXNwX2V4dHJhOworCXN0cnVjdCB3cGFfZHJpdmVyX2FwX3BhcmFtcyBwYXJhbXM7CisJaW50IHJldDsKKworCW9zX21lbXNldChiZWFjb24sIDAsIHNpemVvZigqYmVhY29uKSk7CisJcmV0ID0gaWVlZTgwMl8xMV9idWlsZF9hcF9wYXJhbXMoaGFwZCwgJnBhcmFtcyk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSBob3N0YXBkX2J1aWxkX2FwX2V4dHJhX2llcyhoYXBkLCAmYmVhY29uX2V4dHJhLAorCQkJCQkgJnByb2JlcmVzcF9leHRyYSwKKwkJCQkJICZhc3NvY3Jlc3BfZXh0cmEpOworCWlmIChyZXQpCisJCWdvdG8gZnJlZV9hcF9wYXJhbXM7CisKKwlyZXQgPSAtMTsKKwliZWFjb24tPmhlYWQgPSBvc19tYWxsb2MocGFyYW1zLmhlYWRfbGVuKTsKKwlpZiAoIWJlYWNvbi0+aGVhZCkKKwkJZ290byBmcmVlX2FwX2V4dHJhX2llczsKKworCW9zX21lbWNweShiZWFjb24tPmhlYWQsIHBhcmFtcy5oZWFkLCBwYXJhbXMuaGVhZF9sZW4pOworCWJlYWNvbi0+aGVhZF9sZW4gPSBwYXJhbXMuaGVhZF9sZW47CisKKwliZWFjb24tPnRhaWwgPSBvc19tYWxsb2MocGFyYW1zLnRhaWxfbGVuKTsKKwlpZiAoIWJlYWNvbi0+dGFpbCkKKwkJZ290byBmcmVlX2JlYWNvbjsKKworCW9zX21lbWNweShiZWFjb24tPnRhaWwsIHBhcmFtcy50YWlsLCBwYXJhbXMudGFpbF9sZW4pOworCWJlYWNvbi0+dGFpbF9sZW4gPSBwYXJhbXMudGFpbF9sZW47CisKKwlpZiAocGFyYW1zLnByb2JlcmVzcCAhPSBOVUxMKSB7CisJCWJlYWNvbi0+cHJvYmVfcmVzcCA9IG9zX21hbGxvYyhwYXJhbXMucHJvYmVyZXNwX2xlbik7CisJCWlmICghYmVhY29uLT5wcm9iZV9yZXNwKQorCQkJZ290byBmcmVlX2JlYWNvbjsKKworCQlvc19tZW1jcHkoYmVhY29uLT5wcm9iZV9yZXNwLCBwYXJhbXMucHJvYmVyZXNwLAorCQkJICBwYXJhbXMucHJvYmVyZXNwX2xlbik7CisJCWJlYWNvbi0+cHJvYmVfcmVzcF9sZW4gPSBwYXJhbXMucHJvYmVyZXNwX2xlbjsKKwl9CisKKwkvKiBjb3B5IHRoZSBleHRyYSBpZXMgKi8KKwlpZiAoYmVhY29uX2V4dHJhKSB7CisJCWJlYWNvbi0+YmVhY29uX2llcyA9IG9zX21hbGxvYyh3cGFidWZfbGVuKGJlYWNvbl9leHRyYSkpOworCQlpZiAoIWJlYWNvbi0+YmVhY29uX2llcykKKwkJCWdvdG8gZnJlZV9iZWFjb247CisKKwkJb3NfbWVtY3B5KGJlYWNvbi0+YmVhY29uX2llcywKKwkJCSAgYmVhY29uX2V4dHJhLT5idWYsIHdwYWJ1Zl9sZW4oYmVhY29uX2V4dHJhKSk7CisJCWJlYWNvbi0+YmVhY29uX2llc19sZW4gPSB3cGFidWZfbGVuKGJlYWNvbl9leHRyYSk7CisJfQorCisJaWYgKHByb2JlcmVzcF9leHRyYSkgeworCQliZWFjb24tPnByb2JlcmVzcF9pZXMgPQorCQkJb3NfbWFsbG9jKHdwYWJ1Zl9sZW4ocHJvYmVyZXNwX2V4dHJhKSk7CisJCWlmICghYmVhY29uLT5wcm9iZXJlc3BfaWVzKQorCQkJZ290byBmcmVlX2JlYWNvbjsKKworCQlvc19tZW1jcHkoYmVhY29uLT5wcm9iZXJlc3BfaWVzLCBwcm9iZXJlc3BfZXh0cmEtPmJ1ZiwKKwkJCSAgd3BhYnVmX2xlbihwcm9iZXJlc3BfZXh0cmEpKTsKKwkJYmVhY29uLT5wcm9iZXJlc3BfaWVzX2xlbiA9IHdwYWJ1Zl9sZW4ocHJvYmVyZXNwX2V4dHJhKTsKKwl9CisKKwlpZiAoYXNzb2NyZXNwX2V4dHJhKSB7CisJCWJlYWNvbi0+YXNzb2NyZXNwX2llcyA9CisJCQlvc19tYWxsb2Mod3BhYnVmX2xlbihhc3NvY3Jlc3BfZXh0cmEpKTsKKwkJaWYgKCFiZWFjb24tPmFzc29jcmVzcF9pZXMpCisJCQlnb3RvIGZyZWVfYmVhY29uOworCisJCW9zX21lbWNweShiZWFjb24tPmFzc29jcmVzcF9pZXMsIGFzc29jcmVzcF9leHRyYS0+YnVmLAorCQkJICB3cGFidWZfbGVuKGFzc29jcmVzcF9leHRyYSkpOworCQliZWFjb24tPmFzc29jcmVzcF9pZXNfbGVuID0gd3BhYnVmX2xlbihhc3NvY3Jlc3BfZXh0cmEpOworCX0KKworCXJldCA9IDA7CitmcmVlX2JlYWNvbjoKKwkvKiBpZiB0aGUgZnVuY3Rpb24gZmFpbHMsIHRoZSBjYWxsZXIgc2hvdWxkIG5vdCBmcmVlIGJlYWNvbiBkYXRhICovCisJaWYgKHJldCkKKwkJZnJlZV9iZWFjb25fZGF0YShiZWFjb24pOworCitmcmVlX2FwX2V4dHJhX2llczoKKwlob3N0YXBkX2ZyZWVfYXBfZXh0cmFfaWVzKGhhcGQsIGJlYWNvbl9leHRyYSwgcHJvYmVyZXNwX2V4dHJhLAorCQkJCSAgYXNzb2NyZXNwX2V4dHJhKTsKK2ZyZWVfYXBfcGFyYW1zOgorCWllZWU4MDJfMTFfZnJlZV9hcF9wYXJhbXMoJnBhcmFtcyk7CisJcmV0dXJuIHJldDsKK30KKworCisvKgorICogVE9ETzogVGhpcyBmbG93IGN1cnJlbnRseSBzdXBwb3J0cyBvbmx5IGNoYW5naW5nIGZyZXF1ZW5jeSB3aXRoaW4gdGhlCisgKiBzYW1lIGh3X21vZGUuIEFueSBvdGhlciBjaGFuZ2VzIHRvIE1BQyBwYXJhbWV0ZXJzIG9yIHByb3ZpZGVkIHNldHRpbmdzIChldmVuCisgKiB3aWR0aCkgYXJlIG5vdCBzdXBwb3J0ZWQuCisgKi8KK3N0YXRpYyBpbnQgaG9zdGFwZF9jaGFuZ2VfY29uZmlnX2ZyZXEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgICBzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmNvbmYsCisJCQkJICAgICAgc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgKnBhcmFtcywKKwkJCQkgICAgICBzdHJ1Y3QgaG9zdGFwZF9mcmVxX3BhcmFtcyAqb2xkX3BhcmFtcykKK3sKKwlpbnQgY2hhbm5lbDsKKworCWlmICghcGFyYW1zLT5jaGFubmVsKSB7CisJCS8qIGNoZWNrIGlmIHRoZSBuZXcgY2hhbm5lbCBpcyBzdXBwb3J0ZWQgYnkgaHcgKi8KKwkJcGFyYW1zLT5jaGFubmVsID0gaG9zdGFwZF9od19nZXRfY2hhbm5lbChoYXBkLCBwYXJhbXMtPmZyZXEpOworCX0KKworCWNoYW5uZWwgPSBwYXJhbXMtPmNoYW5uZWw7CisJaWYgKCFjaGFubmVsKQorCQlyZXR1cm4gLTE7CisKKwkvKiBpZiBhIHBvaW50ZXIgdG8gb2xkX3BhcmFtcyBpcyBwcm92aWRlZCB3ZSBzYXZlIHByZXZpb3VzIHN0YXRlICovCisJaWYgKG9sZF9wYXJhbXMpIHsKKwkJb2xkX3BhcmFtcy0+Y2hhbm5lbCA9IGNvbmYtPmNoYW5uZWw7CisJCW9sZF9wYXJhbXMtPmh0X2VuYWJsZWQgPSBjb25mLT5pZWVlODAyMTFuOworCQlvbGRfcGFyYW1zLT5zZWNfY2hhbm5lbF9vZmZzZXQgPSBjb25mLT5zZWNvbmRhcnlfY2hhbm5lbDsKKwl9CisKKwljb25mLT5jaGFubmVsID0gY2hhbm5lbDsKKwljb25mLT5pZWVlODAyMTFuID0gcGFyYW1zLT5odF9lbmFibGVkOworCWNvbmYtPnNlY29uZGFyeV9jaGFubmVsID0gcGFyYW1zLT5zZWNfY2hhbm5lbF9vZmZzZXQ7CisKKwkvKiBUT0RPOiBtYXliZSBjYWxsIGhlcmUgaG9zdGFwZF9jb25maWdfY2hlY2sgaGVyZT8gKi8KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9maWxsX2NzYV9zZXR0aW5ncyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgICAgc3RydWN0IGNzYV9zZXR0aW5ncyAqc2V0dGluZ3MpCit7CisJc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlID0gaGFwZC0+aWZhY2U7CisJc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgb2xkX2ZyZXE7CisJaW50IHJldDsKKworCW9zX21lbXNldCgmb2xkX2ZyZXEsIDAsIHNpemVvZihvbGRfZnJlcSkpOworCWlmICghaWZhY2UgfHwgIWlmYWNlLT5mcmVxIHx8IGhhcGQtPmNzYV9pbl9wcm9ncmVzcykKKwkJcmV0dXJuIC0xOworCisJcmV0ID0gaG9zdGFwZF9jaGFuZ2VfY29uZmlnX2ZyZXEoaWZhY2UtPmJzc1swXSwgaWZhY2UtPmNvbmYsCisJCQkJCSAmc2V0dGluZ3MtPmZyZXFfcGFyYW1zLAorCQkJCQkgJm9sZF9mcmVxKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJcmV0ID0gaG9zdGFwZF9idWlsZF9iZWFjb25fZGF0YShoYXBkLCAmc2V0dGluZ3MtPmJlYWNvbl9hZnRlcik7CisKKwkvKiBjaGFuZ2UgYmFjayB0aGUgY29uZmlndXJhdGlvbiAqLworCWhvc3RhcGRfY2hhbmdlX2NvbmZpZ19mcmVxKGlmYWNlLT5ic3NbMF0sIGlmYWNlLT5jb25mLAorCQkJCSAgICZvbGRfZnJlcSwgTlVMTCk7CisKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJLyogc2V0IGNoYW5uZWwgc3dpdGNoIHBhcmFtZXRlcnMgZm9yIGNzYSBpZSAqLworCWhhcGQtPmNzX2ZyZXFfcGFyYW1zID0gc2V0dGluZ3MtPmZyZXFfcGFyYW1zOworCWhhcGQtPmNzX2NvdW50ID0gc2V0dGluZ3MtPmNzX2NvdW50OworCWhhcGQtPmNzX2Jsb2NrX3R4ID0gc2V0dGluZ3MtPmJsb2NrX3R4OworCisJcmV0ID0gaG9zdGFwZF9idWlsZF9iZWFjb25fZGF0YShoYXBkLCAmc2V0dGluZ3MtPmJlYWNvbl9jc2EpOworCWlmIChyZXQpIHsKKwkJZnJlZV9iZWFjb25fZGF0YSgmc2V0dGluZ3MtPmJlYWNvbl9hZnRlcik7CisJCXJldHVybiByZXQ7CisJfQorCisJc2V0dGluZ3MtPmNvdW50ZXJfb2Zmc2V0X2JlYWNvbiA9IGhhcGQtPmNzX2Nfb2ZmX2JlYWNvbjsKKwlzZXR0aW5ncy0+Y291bnRlcl9vZmZzZXRfcHJlc3AgPSBoYXBkLT5jc19jX29mZl9wcm9iZXJlc3A7CisKKwlyZXR1cm4gMDsKK30KKworCit2b2lkIGhvc3RhcGRfY2xlYW51cF9jc19wYXJhbXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKKwlvc19tZW1zZXQoJmhhcGQtPmNzX2ZyZXFfcGFyYW1zLCAwLCBzaXplb2YoaGFwZC0+Y3NfZnJlcV9wYXJhbXMpKTsKKwloYXBkLT5jc19jb3VudCA9IDA7CisJaGFwZC0+Y3NfYmxvY2tfdHggPSAwOworCWhhcGQtPmNzX2Nfb2ZmX2JlYWNvbiA9IDA7CisJaGFwZC0+Y3NfY19vZmZfcHJvYmVyZXNwID0gMDsKKwloYXBkLT5jc2FfaW5fcHJvZ3Jlc3MgPSAwOworfQorCisKK2ludCBob3N0YXBkX3N3aXRjaF9jaGFubmVsKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkgICBzdHJ1Y3QgY3NhX3NldHRpbmdzICpzZXR0aW5ncykKK3sKKwlpbnQgcmV0OworCXJldCA9IGhvc3RhcGRfZmlsbF9jc2Ffc2V0dGluZ3MoaGFwZCwgc2V0dGluZ3MpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSBob3N0YXBkX2Rydl9zd2l0Y2hfY2hhbm5lbChoYXBkLCBzZXR0aW5ncyk7CisJZnJlZV9iZWFjb25fZGF0YSgmc2V0dGluZ3MtPmJlYWNvbl9jc2EpOworCWZyZWVfYmVhY29uX2RhdGEoJnNldHRpbmdzLT5iZWFjb25fYWZ0ZXIpOworCisJaWYgKHJldCkgeworCQkvKiBpZiB3ZSBmYWlsZWQsIGNsZWFuIGNzIHBhcmFtZXRlcnMgKi8KKwkJaG9zdGFwZF9jbGVhbnVwX2NzX3BhcmFtcyhoYXBkKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwloYXBkLT5jc2FfaW5fcHJvZ3Jlc3MgPSAxOworCXJldHVybiAwOworfQorCisKK3ZvaWQKK2hvc3RhcGRfc3dpdGNoX2NoYW5uZWxfZmFsbGJhY2soc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAorCQkJCWNvbnN0IHN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zICpmcmVxX3BhcmFtcykKK3sKKwlpbnQgdmh0X3NlZzBfaWR4ID0gMCwgdmh0X3NlZzFfaWR4ID0gMCwgdmh0X2J3ID0gVkhUX0NIQU5XSURUSF9VU0VfSFQ7CisJdW5zaWduZWQgaW50IGk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJlc3RhcnRpbmcgYWxsIENTQS1yZWxhdGVkIEJTU2VzIik7CisKKwlpZiAoZnJlcV9wYXJhbXMtPmNlbnRlcl9mcmVxMSkKKwkJdmh0X3NlZzBfaWR4ID0gMzYgKyAoZnJlcV9wYXJhbXMtPmNlbnRlcl9mcmVxMSAtIDUxODApIC8gNTsKKwlpZiAoZnJlcV9wYXJhbXMtPmNlbnRlcl9mcmVxMikKKwkJdmh0X3NlZzFfaWR4ID0gMzYgKyAoZnJlcV9wYXJhbXMtPmNlbnRlcl9mcmVxMiAtIDUxODApIC8gNTsKKworCXN3aXRjaCAoZnJlcV9wYXJhbXMtPmJhbmR3aWR0aCkgeworCWNhc2UgMDoKKwljYXNlIDIwOgorCWNhc2UgNDA6CisJCXZodF9idyA9IFZIVF9DSEFOV0lEVEhfVVNFX0hUOworCQlicmVhazsKKwljYXNlIDgwOgorCQlpZiAoZnJlcV9wYXJhbXMtPmNlbnRlcl9mcmVxMikKKwkJCXZodF9idyA9IFZIVF9DSEFOV0lEVEhfODBQODBNSFo7CisJCWVsc2UKKwkJCXZodF9idyA9IFZIVF9DSEFOV0lEVEhfODBNSFo7CisJCWJyZWFrOworCWNhc2UgMTYwOgorCQl2aHRfYncgPSBWSFRfQ0hBTldJRFRIXzE2ME1IWjsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIlVua25vd24gQ1NBIGJhbmR3aWR0aDogJWQiLAorCQkJICAgZnJlcV9wYXJhbXMtPmJhbmR3aWR0aCk7CisJCWJyZWFrOworCX0KKworCWlmYWNlLT5mcmVxID0gZnJlcV9wYXJhbXMtPmZyZXE7CisJaWZhY2UtPmNvbmYtPmNoYW5uZWwgPSBmcmVxX3BhcmFtcy0+Y2hhbm5lbDsKKwlpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPSBmcmVxX3BhcmFtcy0+c2VjX2NoYW5uZWxfb2Zmc2V0OworCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0gdmh0X3NlZzBfaWR4OworCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzFfaWR4ID0gdmh0X3NlZzFfaWR4OworCWlmYWNlLT5jb25mLT52aHRfb3Blcl9jaHdpZHRoID0gdmh0X2J3OworCWlmYWNlLT5jb25mLT5pZWVlODAyMTFuID0gZnJlcV9wYXJhbXMtPmh0X2VuYWJsZWQ7CisJaWZhY2UtPmNvbmYtPmllZWU4MDIxMWFjID0gZnJlcV9wYXJhbXMtPnZodF9lbmFibGVkOworCisJLyoKKwkgKiBjc19wYXJhbXMgbXVzdCBub3QgYmUgY2xlYXJlZCBlYXJsaWVyIGJlY2F1c2UgdGhlIGZyZXFfcGFyYW1zCisJICogYXJndW1lbnQgbWF5IGFjdHVhbGx5IHBvaW50IHRvIG9uZSBvZiB0aGVzZS4KKwkgKi8KKwlmb3IgKGkgPSAwOyBpIDwgaWZhY2UtPm51bV9ic3M7IGkrKykKKwkJaG9zdGFwZF9jbGVhbnVwX2NzX3BhcmFtcyhpZmFjZS0+YnNzW2ldKTsKKworCWhvc3RhcGRfZGlzYWJsZV9pZmFjZShpZmFjZSk7CisJaG9zdGFwZF9lbmFibGVfaWZhY2UoaWZhY2UpOworfQorCisjZW5kaWYgLyogTkVFRF9BUF9NTE1FICovCmRpZmYgLS1naXQgYS9zcmMvYXAvaG9zdGFwZC5oIGIvc3JjL2FwL2hvc3RhcGQuaAppbmRleCBkYmYxYjUyLi4zYzg3MjdiIDEwMDY0NAotLS0gYS9zcmMvYXAvaG9zdGFwZC5oCisrKyBiL3NyYy9hcC9ob3N0YXBkLmgKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAvIEluaXRpYWxpemF0aW9uIGFuZCBjb25maWd1cmF0aW9uCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwMi0yMDEzLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xMSwyMSArMTEsMTkgQEAKIAogI2luY2x1ZGUgImNvbW1vbi9kZWZzLmgiCiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCisjaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKIAotc3RydWN0IHdwYV9kcml2ZXJfb3BzOwogc3RydWN0IHdwYV9jdHJsX2RzdDsKIHN0cnVjdCByYWRpdXNfc2VydmVyX2RhdGE7CiBzdHJ1Y3QgdXBucF93cHNfZGV2aWNlX3NtOwogc3RydWN0IGhvc3RhcGRfZGF0YTsKIHN0cnVjdCBzdGFfaW5mbzsKLXN0cnVjdCBob3N0YXBfc3RhX2RyaXZlcl9kYXRhOwogc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXM7CiBzdHJ1Y3QgZnVsbF9keW5hbWljX3ZsYW47CiBlbnVtIHdwc19ldmVudDsKIHVuaW9uIHdwc19ldmVudF9kYXRhOwogCiBzdHJ1Y3QgaG9zdGFwZF9pZmFjZTsKLXN0cnVjdCBob3N0YXBkX2R5bmFtaWNfaWZhY2U7CiAKIHN0cnVjdCBoYXBkX2ludGVyZmFjZXMgewogCWludCAoKnJlbG9hZF9jb25maWcpKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7CkBAIC0zOCwxMyArMzYsMTUgQEAKIAlpbnQgKCpkcml2ZXJfaW5pdCkoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKIAogCXNpemVfdCBjb3VudDsKLQlzaXplX3QgY291bnRfZHluYW1pYzsKIAlpbnQgZ2xvYmFsX2N0cmxfc29jazsKIAljaGFyICpnbG9iYWxfaWZhY2VfcGF0aDsKIAljaGFyICpnbG9iYWxfaWZhY2VfbmFtZTsKKyNpZm5kZWYgQ09ORklHX05BVElWRV9XSU5ET1dTCiAJZ2lkX3QgY3RybF9pZmFjZV9ncm91cDsKKyNlbmRpZiAvKiBDT05GSUdfTkFUSVZFX1dJTkRPV1MgKi8KIAlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqKmlmYWNlOwotCXN0cnVjdCBob3N0YXBkX2R5bmFtaWNfaWZhY2UgKipkeW5hbWljX2lmYWNlOworCisJc2l6ZV90IHRlcm1pbmF0ZV9vbl9lcnJvcjsKIH07CiAKIGVudW0gaG9zdGFwZF9jaGFuX3N0YXR1cyB7CkBAIC0xMDAsNiArMTAwLDcgQEAKIAlzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmljb25mOwogCXN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmNvbmY7CiAJaW50IGludGVyZmFjZV9hZGRlZDsgLyogdmlydHVhbCBpbnRlcmZhY2UgYWRkZWQgZm9yIHRoaXMgQlNTICovCisJdW5zaWduZWQgaW50IHN0YXJ0ZWQ6MTsKIAogCXU4IG93bl9hZGRyW0VUSF9BTEVOXTsKIApAQCAtMTM5LDcgKzE0MCw3IEBACiAJc3RydWN0IGVhcG9sX2F1dGhlbnRpY2F0b3IgKmVhcG9sX2F1dGg7CiAKIAlzdHJ1Y3QgcnNuX3ByZWF1dGhfaW50ZXJmYWNlICpwcmVhdXRoX2lmYWNlOwotCXRpbWVfdCBtaWNoYWVsX21pY19mYWlsdXJlOworCXN0cnVjdCBvc19yZWx0aW1lIG1pY2hhZWxfbWljX2ZhaWx1cmU7CiAJaW50IG1pY2hhZWxfbWljX2ZhaWx1cmVzOwogCWludCB0a2lwX2NvdW50ZXJtZWFzdXJlczsKIApAQCAtMjA5LDYgKzIxMCwxNCBAQAogCQkJICAgc2l6ZV90IHBza19sZW4pOwogCXZvaWQgKm5ld19wc2tfY2JfY3R4OwogCisJLyogY2hhbm5lbCBzd2l0Y2ggcGFyYW1ldGVycyAqLworCXN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zIGNzX2ZyZXFfcGFyYW1zOworCXU4IGNzX2NvdW50OworCWludCBjc19ibG9ja190eDsKKwl1bnNpZ25lZCBpbnQgY3NfY19vZmZfYmVhY29uOworCXVuc2lnbmVkIGludCBjc19jX29mZl9wcm9iZXJlc3A7CisJaW50IGNzYV9pbl9wcm9ncmVzczsKKwogI2lmZGVmIENPTkZJR19QMlAKIAlzdHJ1Y3QgcDJwX2RhdGEgKnAycDsKIAlzdHJ1Y3QgcDJwX2dyb3VwICpwMnBfZ3JvdXA7CkBAIC0yMzQsOCArMjQzLDEyIEBACiAjaWZkZWYgQ09ORklHX1NBRQogCS8qKiBLZXkgdXNlZCBmb3IgZ2VuZXJhdGluZyBTQUUgYW50aS1jbG9nZ2luZyB0b2tlbnMgKi8KIAl1OCBzYWVfdG9rZW5fa2V5WzhdOwotCW9zX3RpbWVfdCBsYXN0X3NhZV90b2tlbl9rZXlfdXBkYXRlOworCXN0cnVjdCBvc19yZWx0aW1lIGxhc3Rfc2FlX3Rva2VuX2tleV91cGRhdGU7CiAjZW5kaWYgLyogQ09ORklHX1NBRSAqLworCisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUworCWludCBleHRfbWdtdF9mcmFtZV9oYW5kbGluZzsKKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCiB9OwogCiAKQEAgLTI0NywxMCArMjYwLDMwIEBACiAJdm9pZCAqb3duZXI7CiAJY2hhciAqY29uZmlnX2ZuYW1lOwogCXN0cnVjdCBob3N0YXBkX2NvbmZpZyAqY29uZjsKKwljaGFyIHBoeVsxNl07IC8qIE5hbWUgb2YgdGhlIFBIWSAocmFkaW8pICovCisKKwllbnVtIGhvc3RhcGRfaWZhY2Vfc3RhdGUgeworCQlIQVBEX0lGQUNFX1VOSU5JVElBTElaRUQsCisJCUhBUERfSUZBQ0VfRElTQUJMRUQsCisJCUhBUERfSUZBQ0VfQ09VTlRSWV9VUERBVEUsCisJCUhBUERfSUZBQ0VfQUNTLAorCQlIQVBEX0lGQUNFX0hUX1NDQU4sCisJCUhBUERfSUZBQ0VfREZTLAorCQlIQVBEX0lGQUNFX0VOQUJMRUQKKwl9IHN0YXRlOwogCiAJc2l6ZV90IG51bV9ic3M7CiAJc3RydWN0IGhvc3RhcGRfZGF0YSAqKmJzczsKIAorCXVuc2lnbmVkIGludCB3YWl0X2NoYW5uZWxfdXBkYXRlOjE7CisJdW5zaWduZWQgaW50IGNhY19zdGFydGVkOjE7CisKKwkvKgorCSAqIFdoZW4gc2V0LCBpbmRpY2F0ZXMgdGhhdCB0aGUgZHJpdmVyIHdpbGwgaGFuZGxlIHRoZSBBUAorCSAqIHRlYXJkb3duOiBkZWxldGUgZ2xvYmFsIGtleXMsIHN0YXRpb24ga2V5cywgYW5kIHN0YXRpb25zLgorCSAqLworCXVuc2lnbmVkIGludCBkcml2ZXJfYXBfdGVhcmRvd246MTsKKwogCWludCBudW1fYXA7IC8qIG51bWJlciBvZiBlbnRyaWVzIGluIGFwX2xpc3QgKi8KIAlzdHJ1Y3QgYXBfaW5mbyAqYXBfbGlzdDsgLyogQVAgaW5mbyBsaXN0IGhlYWQgKi8KIAlzdHJ1Y3QgYXBfaW5mbyAqYXBfaGFzaFtTVEFfSEFTSF9TSVpFXTsKQEAgLTMwMiw2ICszMzUsOSBAQAogCS8qIE51bWJlciBvZiBIVCBhc3NvY2lhdGVkIHN0YXRpb25zIDIwIE1IeiAqLwogCWludCBudW1fc3RhX2h0XzIwbWh6OwogCisJLyogTnVtYmVyIG9mIEhUNDAgaW50b2xlcmFudCBzdGF0aW9ucyAqLworCWludCBudW1fc3RhX2h0NDBfaW50b2xlcmFudDsKKwogCS8qIE92ZXJsYXBwaW5nIEJTUyBpbmZvcm1hdGlvbiAqLwogCWludCBvbGJjX2h0OwogCkBAIC0zMTUsMjEgKzM1MSwxOSBAQAogCS8qIGxvd2VzdCBvYnNlcnZlZCBub2lzZSBmbG9vciBpbiBkQm0gKi8KIAlzOCBsb3dlc3RfbmY7CiAKKwl1bnNpZ25lZCBpbnQgZGZzX2NhY19tczsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBkZnNfY2FjX3N0YXJ0OworCisJLyogTGF0Y2hlZCB3aXRoIHRoZSBhY3R1YWwgc2Vjb25kYXJ5IGNoYW5uZWwgaW5mb3JtYXRpb24gYW5kIHdpbGwgYmUKKwkgKiB1c2VkIHdoaWxlIGp1Z2dsaW5nIGJldHdlZW4gSFQyMCBhbmQgSFQ0MCBtb2Rlcy4gKi8KKwlpbnQgc2Vjb25kYXJ5X2NoOworCiAjaWZkZWYgQ09ORklHX0FDUwogCXVuc2lnbmVkIGludCBhY3NfbnVtX2NvbXBsZXRlZF9zY2FuczsKICNlbmRpZiAvKiBDT05GSUdfQUNTICovCiAKIAl2b2lkICgqc2Nhbl9jYikoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKLX07Ci0KLS8qKgotICogc3RydWN0IGhvc3RhcGRfZHluYW1pY19pZmFjZSAtIGhvc3RhcGQgcGVyIGR5bmFtaWNhbGx5IGFsbG9jYXRlZAotICogb3IgYWRkZWQgaW50ZXJmYWNlIGRhdGEgc3RydWN0dXJlCi0gKi8KLXN0cnVjdCBob3N0YXBkX2R5bmFtaWNfaWZhY2UgewotCWNoYXIgcGFyZW50W0lGTkFNU0laICsgMV07Ci0JY2hhciBpZmFjZVtJRk5BTVNJWiArIDFdOwotCXVuc2lnbmVkIGludCB1c2FnZTsKKwlpbnQgbnVtX2h0NDBfc2Nhbl90cmllczsKIH07CiAKIC8qIGhvc3RhcGQuYyAqLwpAQCAtMzQ1LDYgKzM3OSwxMSBAQAogaW50IGhvc3RhcGRfc2V0dXBfaW50ZXJmYWNlX2NvbXBsZXRlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgaW50IGVycik7CiB2b2lkIGhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpOwogdm9pZCBob3N0YXBkX2ludGVyZmFjZV9mcmVlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7CitzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqIGhvc3RhcGRfaW5pdChzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICppbnRlcmZhY2VzLAorCQkJCSAgICBjb25zdCBjaGFyICpjb25maWdfZmlsZSk7CitzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqCitob3N0YXBkX2ludGVyZmFjZV9pbml0X2JzcyhzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICppbnRlcmZhY2VzLCBjb25zdCBjaGFyICpwaHksCisJCQkgICBjb25zdCBjaGFyICpjb25maWdfZm5hbWUsIGludCBkZWJ1Zyk7CiB2b2lkIGhvc3RhcGRfbmV3X2Fzc29jX3N0YShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJCSAgIGludCByZWFzc29jKTsKIHZvaWQgaG9zdGFwZF9pbnRlcmZhY2VfZGVpbml0X2ZyZWUoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKQEAgLTM1Myw2ICszOTIsMTUgQEAKIGludCBob3N0YXBkX2Rpc2FibGVfaWZhY2Uoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmhhcGRfaWZhY2UpOwogaW50IGhvc3RhcGRfYWRkX2lmYWNlKHN0cnVjdCBoYXBkX2ludGVyZmFjZXMgKmlmYWNlcywgY2hhciAqYnVmKTsKIGludCBob3N0YXBkX3JlbW92ZV9pZmFjZShzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICppZmFjZXMsIGNoYXIgKmJ1Zik7Cit2b2lkIGhvc3RhcGRfY2hhbm5lbF9saXN0X3VwZGF0ZWQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBpbnQgaW5pdGlhdG9yKTsKK3ZvaWQgaG9zdGFwZF9zZXRfc3RhdGUoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBlbnVtIGhvc3RhcGRfaWZhY2Vfc3RhdGUgcyk7Citjb25zdCBjaGFyICogaG9zdGFwZF9zdGF0ZV90ZXh0KGVudW0gaG9zdGFwZF9pZmFjZV9zdGF0ZSBzKTsKK2ludCBob3N0YXBkX3N3aXRjaF9jaGFubmVsKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkgICBzdHJ1Y3QgY3NhX3NldHRpbmdzICpzZXR0aW5ncyk7Cit2b2lkCitob3N0YXBkX3N3aXRjaF9jaGFubmVsX2ZhbGxiYWNrKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwKKwkJCQljb25zdCBzdHJ1Y3QgaG9zdGFwZF9mcmVxX3BhcmFtcyAqZnJlcV9wYXJhbXMpOwordm9pZCBob3N0YXBkX2NsZWFudXBfY3NfcGFyYW1zKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwogCiAvKiB1dGlscy5jICovCiBpbnQgaG9zdGFwZF9yZWdpc3Rlcl9wcm9iZXJlcV9jYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLApAQCAtMzc0LDcgKzQyMiw3IEBACiAJCQkgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCiAJCQkgaW50IHNzaV9zaWduYWwpOwogdm9pZCBob3N0YXBkX2V2ZW50X2NoX3N3aXRjaChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBpbnQgZnJlcSwgaW50IGh0LAotCQkJICAgICBpbnQgb2Zmc2V0KTsKKwkJCSAgICAgaW50IG9mZnNldCwgaW50IHdpZHRoLCBpbnQgY2YxLCBpbnQgY2YyKTsKIAogY29uc3Qgc3RydWN0IGhvc3RhcGRfZWFwX3VzZXIgKgogaG9zdGFwZF9nZXRfZWFwX3VzZXIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmlkZW50aXR5LApkaWZmIC0tZ2l0IGEvc3JjL2FwL2hzMjAuYyBiL3NyYy9hcC9oczIwLmMKaW5kZXggNDVkNTE4Yi4uZDc5MDlmYSAxMDA2NDQKLS0tIGEvc3JjL2FwL2hzMjAuYworKysgYi9zcmMvYXAvaHMyMC5jCkBAIC0xLDcgKzEsNyBAQAogLyoKICAqIEhvdHNwb3QgMi4wIEFQIEFOUVAgcHJvY2Vzc2luZwogICogQ29weXJpZ2h0IChjKSAyMDA5LCBBdGhlcm9zIENvbW11bmljYXRpb25zLCBJbmMuCi0gKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMiwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTMsMTkgKzEzLDE2NSBAQAogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCisjaW5jbHVkZSAiYXBfZHJ2X29wcy5oIgogI2luY2x1ZGUgImhzMjAuaCIKIAogCiB1OCAqIGhvc3RhcGRfZWlkX2hzMjBfaW5kaWNhdGlvbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKQogeworCXU4IGNvbmY7CiAJaWYgKCFoYXBkLT5jb25mLT5oczIwKQogCQlyZXR1cm4gZWlkOwogCSplaWQrKyA9IFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQzsKLQkqZWlkKysgPSA1OworCSplaWQrKyA9IDc7CiAJV1BBX1BVVF9CRTI0KGVpZCwgT1VJX1dGQSk7CiAJZWlkICs9IDM7CiAJKmVpZCsrID0gSFMyMF9JTkRJQ0FUSU9OX09VSV9UWVBFOwotCS8qIEhvdHNwb3QgQ29uZmlndXJhdGlvbjogREdBRiBFbmFibGVkICovCi0JKmVpZCsrID0gaGFwZC0+Y29uZi0+ZGlzYWJsZV9kZ2FmID8gMHgwMSA6IDB4MDA7CisJY29uZiA9IEhTMjBfVkVSU0lPTjsgLyogUmVsZWFzZSBOdW1iZXIgKi8KKwljb25mIHw9IEhTMjBfQU5RUF9ET01BSU5fSURfUFJFU0VOVDsKKwlpZiAoaGFwZC0+Y29uZi0+ZGlzYWJsZV9kZ2FmKQorCQljb25mIHw9IEhTMjBfREdBRl9ESVNBQkxFRDsKKwkqZWlkKysgPSBjb25mOworCVdQQV9QVVRfTEUxNihlaWQsIGhhcGQtPmNvbmYtPmFucXBfZG9tYWluX2lkKTsKKwllaWQgKz0gMjsKKwogCXJldHVybiBlaWQ7CiB9CisKKwordTggKiBob3N0YXBkX2VpZF9vc2VuKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpCit7CisJdTggKmxlbjsKKwl1MTYgY2FwYWI7CisKKwlpZiAoIWhhcGQtPmNvbmYtPm9zZW4pCisJCXJldHVybiBlaWQ7CisKKwkqZWlkKysgPSBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUM7CisJbGVuID0gZWlkKys7IC8qIHRvIGJlIGZpbGxlZCAqLworCVdQQV9QVVRfQkUyNChlaWQsIE9VSV9XRkEpOworCWVpZCArPSAzOworCSplaWQrKyA9IEhTMjBfT1NFTl9PVUlfVFlQRTsKKworCS8qIEdyb3VwIERhdGEgQ2lwaGVyIFN1aXRlICovCisJUlNOX1NFTEVDVE9SX1BVVChlaWQsIFJTTl9DSVBIRVJfU1VJVEVfTk9fR1JPVVBfQUREUkVTU0VEKTsKKwllaWQgKz0gUlNOX1NFTEVDVE9SX0xFTjsKKworCS8qIFBhaXJ3aXNlIENpcGhlciBTdWl0ZSBDb3VudCBhbmQgTGlzdCAqLworCVdQQV9QVVRfTEUxNihlaWQsIDEpOworCWVpZCArPSAyOworCVJTTl9TRUxFQ1RPUl9QVVQoZWlkLCBSU05fQ0lQSEVSX1NVSVRFX0NDTVApOworCWVpZCArPSBSU05fU0VMRUNUT1JfTEVOOworCisJLyogQUtNIFN1aXRlIENvdW50IGFuZCBMaXN0ICovCisJV1BBX1BVVF9MRTE2KGVpZCwgMSk7CisJZWlkICs9IDI7CisJUlNOX1NFTEVDVE9SX1BVVChlaWQsIFJTTl9BVVRIX0tFWV9NR01UX09TRU4pOworCWVpZCArPSBSU05fU0VMRUNUT1JfTEVOOworCisJLyogUlNOIENhcGFiaWxpdGllcyAqLworCWNhcGFiID0gMDsKKwlpZiAoaGFwZC0+Y29uZi0+d21tX2VuYWJsZWQpIHsKKwkJLyogNCBQVEtTQSByZXBsYXkgY291bnRlcnMgd2hlbiB1c2luZyBXTU0gKi8KKwkJY2FwYWIgfD0gKFJTTl9OVU1fUkVQTEFZX0NPVU5URVJTXzE2IDw8IDIpOworCX0KKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExVworCWlmIChoYXBkLT5jb25mLT5pZWVlODAyMTF3ICE9IE5PX01HTVRfRlJBTUVfUFJPVEVDVElPTikgeworCQljYXBhYiB8PSBXUEFfQ0FQQUJJTElUWV9NRlBDOworCQlpZiAoaGFwZC0+Y29uZi0+aWVlZTgwMjExdyA9PSBNR01UX0ZSQU1FX1BST1RFQ1RJT05fUkVRVUlSRUQpCisJCQljYXBhYiB8PSBXUEFfQ0FQQUJJTElUWV9NRlBSOworCX0KKyNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLworCVdQQV9QVVRfTEUxNihlaWQsIGNhcGFiKTsKKwllaWQgKz0gMjsKKworCSpsZW4gPSBlaWQgLSBsZW4gLSAxOworCisJcmV0dXJuIGVpZDsKK30KKworCitpbnQgaHMyMF9zZW5kX3dubV9ub3RpZmljYXRpb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIsCisJCQkgICAgICAgdTggb3N1X21ldGhvZCwgY29uc3QgY2hhciAqdXJsKQoreworCXN0cnVjdCB3cGFidWYgKmJ1ZjsKKwlzaXplX3QgbGVuID0gMDsKKwlpbnQgcmV0OworCisJLyogVE9ETzogc2hvdWxkIHJlZnVzZSB0byBzZW5kIG5vdGlmaWNhdGlvbiBpZiB0aGUgU1RBIGlzIG5vdCBhc3NvY2lhdGVkCisJICogb3IgaWYgdGhlIFNUQSBkaWQgbm90IGluZGljYXRlIHN1cHBvcnQgZm9yIFdOTS1Ob3RpZmljYXRpb24gKi8KKworCWlmICh1cmwpIHsKKwkJbGVuID0gMSArIG9zX3N0cmxlbih1cmwpOworCQlpZiAoNSArIGxlbiA+IDI1NSkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkhTIDIuMDogVG9vIGxvbmcgVVJMIGZvciAiCisJCQkJICAgIldOTS1Ob3RpZmljYXRpb246ICclcyciLCB1cmwpOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorCisJYnVmID0gd3BhYnVmX2FsbG9jKDQgKyA3ICsgbGVuKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXdwYWJ1Zl9wdXRfdTgoYnVmLCBXTEFOX0FDVElPTl9XTk0pOworCXdwYWJ1Zl9wdXRfdTgoYnVmLCBXTk1fTk9USUZJQ0FUSU9OX1JFUSk7CisJd3BhYnVmX3B1dF91OChidWYsIDEpOyAvKiBEaWFsb2cgdG9rZW4gKi8KKwl3cGFidWZfcHV0X3U4KGJ1ZiwgMSk7IC8qIFR5cGUgLSAxIHJlc2VydmVkIGZvciBXRkEgKi8KKworCS8qIFN1YnNjcmlwdGlvbiBSZW1lZGlhdGlvbiBzdWJlbGVtZW50ICovCisJd3BhYnVmX3B1dF91OChidWYsIFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQyk7CisJd3BhYnVmX3B1dF91OChidWYsIDUgKyBsZW4pOworCXdwYWJ1Zl9wdXRfYmUyNChidWYsIE9VSV9XRkEpOworCXdwYWJ1Zl9wdXRfdTgoYnVmLCBIUzIwX1dOTV9TVUJfUkVNX05FRURFRCk7CisJaWYgKHVybCkgeworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgbGVuIC0gMSk7CisJCXdwYWJ1Zl9wdXRfZGF0YShidWYsIHVybCwgbGVuIC0gMSk7CisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBvc3VfbWV0aG9kKTsKKwl9IGVsc2UgeworCQkvKiBTZXJ2ZXIgVVJMIGFuZCBTZXJ2ZXIgTWV0aG9kIGZpZWxkcyBub3QgaW5jbHVkZWQgKi8KKwkJd3BhYnVmX3B1dF91OChidWYsIDApOworCX0KKworCXJldCA9IGhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLCBhZGRyLAorCQkJCSAgICAgIHdwYWJ1Zl9oZWFkKGJ1ZiksIHdwYWJ1Zl9sZW4oYnVmKSk7CisKKwl3cGFidWZfZnJlZShidWYpOworCisJcmV0dXJuIHJldDsKK30KKworCitpbnQgaHMyMF9zZW5kX3dubV9ub3RpZmljYXRpb25fZGVhdXRoX3JlcShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgIGNvbnN0IHU4ICphZGRyLAorCQkJCQkgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnBheWxvYWQpCit7CisJc3RydWN0IHdwYWJ1ZiAqYnVmOworCWludCByZXQ7CisKKwkvKiBUT0RPOiBzaG91bGQgcmVmdXNlIHRvIHNlbmQgbm90aWZpY2F0aW9uIGlmIHRoZSBTVEEgaXMgbm90IGFzc29jaWF0ZWQKKwkgKiBvciBpZiB0aGUgU1RBIGRpZCBub3QgaW5kaWNhdGUgc3VwcG9ydCBmb3IgV05NLU5vdGlmaWNhdGlvbiAqLworCisJYnVmID0gd3BhYnVmX2FsbG9jKDQgKyA2ICsgd3BhYnVmX2xlbihwYXlsb2FkKSk7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgV0xBTl9BQ1RJT05fV05NKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgV05NX05PVElGSUNBVElPTl9SRVEpOworCXdwYWJ1Zl9wdXRfdTgoYnVmLCAxKTsgLyogRGlhbG9nIHRva2VuICovCisJd3BhYnVmX3B1dF91OChidWYsIDEpOyAvKiBUeXBlIC0gMSByZXNlcnZlZCBmb3IgV0ZBICovCisKKwkvKiBEZWF1dGhlbnRpY2F0aW9uIEltbWluZW50IE5vdGljZSBzdWJlbGVtZW50ICovCisJd3BhYnVmX3B1dF91OChidWYsIFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQyk7CisJd3BhYnVmX3B1dF91OChidWYsIDQgKyB3cGFidWZfbGVuKHBheWxvYWQpKTsKKwl3cGFidWZfcHV0X2JlMjQoYnVmLCBPVUlfV0ZBKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgSFMyMF9XTk1fREVBVVRIX0lNTUlORU5UX05PVElDRSk7CisJd3BhYnVmX3B1dF9idWYoYnVmLCBwYXlsb2FkKTsKKworCXJldCA9IGhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLCBhZGRyLAorCQkJCSAgICAgIHdwYWJ1Zl9oZWFkKGJ1ZiksIHdwYWJ1Zl9sZW4oYnVmKSk7CisKKwl3cGFidWZfZnJlZShidWYpOworCisJcmV0dXJuIHJldDsKK30KZGlmZiAtLWdpdCBhL3NyYy9hcC9oczIwLmggYi9zcmMvYXAvaHMyMC5oCmluZGV4IDk4Njk4Y2UuLjE1MjQzOWYgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9oczIwLmgKKysrIGIvc3JjL2FwL2hzMjAuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBIb3RzcG90IDIuMCBBUCBBTlFQIHByb2Nlc3NpbmcKLSAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEyLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xMiw1ICsxMiwxMSBAQAogc3RydWN0IGhvc3RhcGRfZGF0YTsKIAogdTggKiBob3N0YXBkX2VpZF9oczIwX2luZGljYXRpb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCk7Cit1OCAqIGhvc3RhcGRfZWlkX29zZW4oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCk7CitpbnQgaHMyMF9zZW5kX3dubV9ub3RpZmljYXRpb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIsCisJCQkgICAgICAgdTggb3N1X21ldGhvZCwgY29uc3QgY2hhciAqdXJsKTsKK2ludCBoczIwX3NlbmRfd25tX25vdGlmaWNhdGlvbl9kZWF1dGhfcmVxKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgY29uc3QgdTggKmFkZHIsCisJCQkJCSAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcGF5bG9hZCk7CiAKICNlbmRpZiAvKiBIUzIwX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC9od19mZWF0dXJlcy5jIGIvc3JjL2FwL2h3X2ZlYXR1cmVzLmMKaW5kZXggOGEyMzlmNC4uNGU2NmQxYiAxMDA2NDQKLS0tIGEvc3JjL2FwL2h3X2ZlYXR1cmVzLmMKKysrIGIvc3JjL2FwL2h3X2ZlYXR1cmVzLmMKQEAgLTQsMTQgKzQsOCBAQAogICogQ29weXJpZ2h0IDIwMDUtMjAwNiwgRGV2aWNlc2NhcGUgU29mdHdhcmUsIEluYy4KICAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJ1dGlscy9pbmNsdWRlcy5oIgpAQCAtMjAsMTEgKzE0LDEzIEBACiAjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfY29tbW9uLmgiCi0jaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKKyNpbmNsdWRlICJjb21tb24vd3BhX2N0cmwuaCIKICNpbmNsdWRlICJob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCiAjaW5jbHVkZSAiYXBfZHJ2X29wcy5oIgogI2luY2x1ZGUgImFjcy5oIgorI2luY2x1ZGUgImllZWU4MDJfMTEuaCIKKyNpbmNsdWRlICJiZWFjb24uaCIKICNpbmNsdWRlICJod19mZWF0dXJlcy5oIgogCiAKQEAgLTQ1LDYgKzQxLDM2IEBACiB9CiAKIAorI2lmbmRlZiBDT05GSUdfTk9fU1RET1VUX0RFQlVHCitzdGF0aWMgY2hhciAqIGRmc19pbmZvKHN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hhbikKK3sKKwlzdGF0aWMgY2hhciBpbmZvWzI1Nl07CisJY2hhciAqc3RhdGU7CisKKwlzd2l0Y2ggKGNoYW4tPmZsYWcgJiBIT1NUQVBEX0NIQU5fREZTX01BU0spIHsKKwljYXNlIEhPU1RBUERfQ0hBTl9ERlNfVU5LTk9XTjoKKwkJc3RhdGUgPSAidW5rbm93biI7CisJCWJyZWFrOworCWNhc2UgSE9TVEFQRF9DSEFOX0RGU19VU0FCTEU6CisJCXN0YXRlID0gInVzYWJsZSI7CisJCWJyZWFrOworCWNhc2UgSE9TVEFQRF9DSEFOX0RGU19VTkFWQUlMQUJMRToKKwkJc3RhdGUgPSAidW5hdmFpbGFibGUiOworCQlicmVhazsKKwljYXNlIEhPU1RBUERfQ0hBTl9ERlNfQVZBSUxBQkxFOgorCQlzdGF0ZSA9ICJhdmFpbGFibGUiOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4gIiI7CisJfQorCW9zX3NucHJpbnRmKGluZm8sIHNpemVvZihpbmZvKSwgIiAoREZTIHN0YXRlID0gJXMpIiwgc3RhdGUpOworCWluZm9bc2l6ZW9mKGluZm8pIC0gMV0gPSAnXDAnOworCisJcmV0dXJuIGluZm87Cit9CisjZW5kaWYgLyogQ09ORklHX05PX1NURE9VVF9ERUJVRyAqLworCisKIGludCBob3N0YXBkX2dldF9od19mZWF0dXJlcyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7CiAJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGlmYWNlLT5ic3NbMF07CkBAIC03MSwzMCArOTcsNDMgQEAKIAogCWZvciAoaSA9IDA7IGkgPCBudW1fbW9kZXM7IGkrKykgewogCQlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqZmVhdHVyZSA9ICZtb2Rlc1tpXTsKKwkJaW50IGRmc19lbmFibGVkID0gaGFwZC0+aWNvbmYtPmllZWU4MDIxMWggJiYKKwkJCShpZmFjZS0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19SQURBUik7CisKIAkJLyogc2V0IGZsYWcgZm9yIGNoYW5uZWxzIHdlIGNhbiB1c2UgaW4gY3VycmVudCByZWd1bGF0b3J5CiAJCSAqIGRvbWFpbiAqLwogCQlmb3IgKGogPSAwOyBqIDwgZmVhdHVyZS0+bnVtX2NoYW5uZWxzOyBqKyspIHsKKwkJCWludCBkZnMgPSAwOworCiAJCQkvKgogCQkJICogRGlzYWJsZSBhbGwgY2hhbm5lbHMgdGhhdCBhcmUgbWFya2VkIG5vdCB0byBhbGxvdwotCQkJICogSUJTUyBvcGVyYXRpb24gb3IgYWN0aXZlIHNjYW5uaW5nLiBJbiBhZGRpdGlvbiwKLQkJCSAqIGRpc2FibGUgYWxsIGNoYW5uZWxzIHRoYXQgcmVxdWlyZSByYWRhciBkZXRlY3Rpb24sCi0JCQkgKiBzaW5jZSB0aGF0IChpbiBhZGRpdGlvbiB0byBmdWxsIERGUykgaXMgbm90IHlldAotCQkJICogc3VwcG9ydGVkLgorCQkJICogSUJTUyBvcGVyYXRpb24gb3IgYWN0aXZlIHNjYW5uaW5nLgorCQkJICogVXNlIHJhZGFyIGNoYW5uZWxzIG9ubHkgaWYgdGhlIGRyaXZlciBzdXBwb3J0cyBERlMuCiAJCQkgKi8KLQkJCWlmIChmZWF0dXJlLT5jaGFubmVsc1tqXS5mbGFnICYKLQkJCSAgICAoSE9TVEFQRF9DSEFOX05PX0lCU1MgfAotCQkJICAgICBIT1NUQVBEX0NIQU5fUEFTU0lWRV9TQ0FOIHwKLQkJCSAgICAgSE9TVEFQRF9DSEFOX1JBREFSKSkKKwkJCWlmICgoZmVhdHVyZS0+Y2hhbm5lbHNbal0uZmxhZyAmCisJCQkgICAgIEhPU1RBUERfQ0hBTl9SQURBUikgJiYgZGZzX2VuYWJsZWQpIHsKKwkJCQlkZnMgPSAxOworCQkJfSBlbHNlIGlmICgoKGZlYXR1cmUtPmNoYW5uZWxzW2pdLmZsYWcgJgorCQkJCSAgICAgSE9TVEFQRF9DSEFOX1JBREFSKSAmJgorCQkJCSAgICAhKGlmYWNlLT5kcnZfZmxhZ3MgJgorCQkJCSAgICAgIFdQQV9EUklWRVJfRkxBR1NfREZTX09GRkxPQUQpKSB8fAorCQkJCSAgIChmZWF0dXJlLT5jaGFubmVsc1tqXS5mbGFnICYKKwkJCQkgICAgKEhPU1RBUERfQ0hBTl9OT19JQlNTIHwKKwkJCQkgICAgIEhPU1RBUERfQ0hBTl9QQVNTSVZFX1NDQU4pKSkgewogCQkJCWZlYXR1cmUtPmNoYW5uZWxzW2pdLmZsYWcgfD0KIAkJCQkJSE9TVEFQRF9DSEFOX0RJU0FCTEVEOworCQkJfQorCiAJCQlpZiAoZmVhdHVyZS0+Y2hhbm5lbHNbal0uZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKIAkJCQljb250aW51ZTsKKwogCQkJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIkFsbG93ZWQgY2hhbm5lbDogbW9kZT0lZCAiCi0JCQkJICAgImNoYW49JWQgZnJlcT0lZCBNSHogbWF4X3R4X3Bvd2VyPSVkIGRCbSIsCisJCQkJICAgImNoYW49JWQgZnJlcT0lZCBNSHogbWF4X3R4X3Bvd2VyPSVkIGRCbSVzIiwKIAkJCQkgICBmZWF0dXJlLT5tb2RlLAogCQkJCSAgIGZlYXR1cmUtPmNoYW5uZWxzW2pdLmNoYW4sCiAJCQkJICAgZmVhdHVyZS0+Y2hhbm5lbHNbal0uZnJlcSwKLQkJCQkgICBmZWF0dXJlLT5jaGFubmVsc1tqXS5tYXhfdHhfcG93ZXIpOworCQkJCSAgIGZlYXR1cmUtPmNoYW5uZWxzW2pdLm1heF90eF9wb3dlciwKKwkJCQkgICBkZnMgPyBkZnNfaW5mbygmZmVhdHVyZS0+Y2hhbm5lbHNbal0pIDogIiIpOwogCQl9CiAJfQogCkBAIC0yMzAsNyArMjY5LDcgQEAKIAkJZmlyc3QgPSBzZWNfY2hhbjsKIAogCW9rID0gMDsKLQlmb3IgKGsgPSAwOyBrIDwgc2l6ZW9mKGFsbG93ZWQpIC8gc2l6ZW9mKGFsbG93ZWRbMF0pOyBrKyspIHsKKwlmb3IgKGsgPSAwOyBrIDwgQVJSQVlfU0laRShhbGxvd2VkKTsgaysrKSB7CiAJCWlmIChmaXJzdCA9PSBhbGxvd2VkW2tdKSB7CiAJCQlvayA9IDE7CiAJCQlicmVhazsKQEAgLTI3MSw4ICszMTAsOCBAQAogCWlmIChlbGVtcy5odF9vcGVyYXRpb24gJiYKIAkgICAgZWxlbXMuaHRfb3BlcmF0aW9uX2xlbiA+PSBzaXplb2YoKm9wZXIpKSB7CiAJCW9wZXIgPSAoc3RydWN0IGllZWU4MDIxMV9odF9vcGVyYXRpb24gKikgZWxlbXMuaHRfb3BlcmF0aW9uOwotCQkqcHJpX2NoYW4gPSBvcGVyLT5jb250cm9sX2NoYW47Ci0JCWlmIChvcGVyLT5odF9wYXJhbSAmIEhUX0lORk9fSFRfUEFSQU1fUkVDX1RSQU5TX0NITkxfV0lEVEgpIHsKKwkJKnByaV9jaGFuID0gb3Blci0+cHJpbWFyeV9jaGFuOworCQlpZiAob3Blci0+aHRfcGFyYW0gJiBIVF9JTkZPX0hUX1BBUkFNX1NUQV9DSE5MX1dJRFRIKSB7CiAJCQlpbnQgc2VjID0gb3Blci0+aHRfcGFyYW0gJgogCQkJCUhUX0lORk9fSFRfUEFSQU1fU0VDT05EQVJZX0NITkxfT0ZGX01BU0s7CiAJCQlpZiAoc2VjID09IEhUX0lORk9fSFRfUEFSQU1fU0VDT05EQVJZX0NITkxfQUJPVkUpCkBAIC0yOTMsNyArMzMyLDcgQEAKIAlpbnQgbWF0Y2g7CiAKIAlwcmlfY2hhbiA9IGlmYWNlLT5jb25mLT5jaGFubmVsOwotCXNlY19jaGFuID0gaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsICogNDsKKwlzZWNfY2hhbiA9IHByaV9jaGFuICsgaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsICogNDsKIAlwcmlfZnJlcSA9IGhvc3RhcGRfaHdfZ2V0X2ZyZXEoaWZhY2UtPmJzc1swXSwgcHJpX2NoYW4pOwogCWlmIChpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPiAwKQogCQlzZWNfZnJlcSA9IHByaV9mcmVxICsgMjA7CkBAIC0zMTcsNiArMzU2LDcgQEAKIAkJCSAgICJjaGFubmVsIHRvIGdldCBzZWNvbmRhcnkgY2hhbm5lbCB3aXRoIG5vIEJlYWNvbnMgIgogCQkJICAgImZyb20gb3RoZXIgQlNTZXMiKTsKIAkJaWVlZTgwMjExbl9zd2l0Y2hfcHJpX3NlYyhpZmFjZSk7CisJCXJldHVybiAxOwogCX0KIAogCS8qCkBAIC0zNTUsNiArMzk1LDM2IEBACiB9CiAKIAorc3RhdGljIGludCBpZWVlODAyMTFuX2NoZWNrXzIwbWh6X2JzcyhzdHJ1Y3Qgd3BhX3NjYW5fcmVzICpic3MsIGludCBwcmlfZnJlcSwKKwkJCQkgICAgICBpbnQgc3RhcnQsIGludCBlbmQpCit7CisJc3RydWN0IGllZWU4MDJfMTFfZWxlbXMgZWxlbXM7CisJc3RydWN0IGllZWU4MDIxMV9odF9vcGVyYXRpb24gKm9wZXI7CisKKwlpZiAoYnNzLT5mcmVxIDwgc3RhcnQgfHwgYnNzLT5mcmVxID4gZW5kIHx8IGJzcy0+ZnJlcSA9PSBwcmlfZnJlcSkKKwkJcmV0dXJuIDA7CisKKwlpZWVlODAyXzExX3BhcnNlX2VsZW1zKCh1OCAqKSAoYnNzICsgMSksIGJzcy0+aWVfbGVuLCAmZWxlbXMsIDApOworCWlmICghZWxlbXMuaHRfY2FwYWJpbGl0aWVzKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRm91bmQgb3ZlcmxhcHBpbmcgbGVnYWN5IEJTUzogIgorCQkJICAgTUFDU1RSICIgZnJlcT0lZCIsIE1BQzJTVFIoYnNzLT5ic3NpZCksIGJzcy0+ZnJlcSk7CisJCXJldHVybiAxOworCX0KKworCWlmIChlbGVtcy5odF9vcGVyYXRpb24gJiYKKwkgICAgZWxlbXMuaHRfb3BlcmF0aW9uX2xlbiA+PSBzaXplb2YoKm9wZXIpKSB7CisJCW9wZXIgPSAoc3RydWN0IGllZWU4MDIxMV9odF9vcGVyYXRpb24gKikgZWxlbXMuaHRfb3BlcmF0aW9uOworCQlpZiAob3Blci0+aHRfcGFyYW0gJiBIVF9JTkZPX0hUX1BBUkFNX1NFQ09OREFSWV9DSE5MX09GRl9NQVNLKQorCQkJcmV0dXJuIDA7CisKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGb3VuZCBvdmVybGFwcGluZyAyMCBNSHogSFQgQlNTOiAiCisJCQkgICBNQUNTVFIgIiBmcmVxPSVkIiwgTUFDMlNUUihic3MtPmJzc2lkKSwgYnNzLT5mcmVxKTsKKwkJcmV0dXJuIDE7CisJfQorCXJldHVybiAwOworfQorCisKIHN0YXRpYyBpbnQgaWVlZTgwMjExbl9jaGVja180MG1oel8yZzQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAogCQkJCSAgICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3JlcykKIHsKQEAgLTM3Niw2ICs0NDYsMTUgQEAKIAkJaW50IHByaSA9IGJzcy0+ZnJlcTsKIAkJaW50IHNlYyA9IHByaTsKIAkJaW50IHNlY19jaGFuLCBwcmlfY2hhbjsKKwkJc3RydWN0IGllZWU4MDJfMTFfZWxlbXMgZWxlbXM7CisKKwkJLyogQ2hlY2sgZm9yIG92ZXJsYXBwaW5nIDIwIE1IeiBCU1MgKi8KKwkJaWYgKGllZWU4MDIxMW5fY2hlY2tfMjBtaHpfYnNzKGJzcywgcHJpX2ZyZXEsIGFmZmVjdGVkX3N0YXJ0LAorCQkJCQkgICAgICAgYWZmZWN0ZWRfZW5kKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkJICAgIk92ZXJsYXBwaW5nIDIwIE1IeiBCU1MgaXMgZm91bmQiKTsKKwkJCXJldHVybiAwOworCQl9CiAKIAkJaWVlZTgwMjExbl9nZXRfcHJpX3NlY19jaGFuKGJzcywgJnByaV9jaGFuLCAmc2VjX2NoYW4pOwogCkBAIC00MDcsNyArNDg2LDIzIEBACiAJCQl9CiAJCX0KIAotCQkvKiBUT0RPOiA0MCBNSHogaW50b2xlcmFudCAqLworCQlpZWVlODAyXzExX3BhcnNlX2VsZW1zKCh1OCAqKSAoYnNzICsgMSksIGJzcy0+aWVfbGVuLCAmZWxlbXMsCisJCQkJICAgICAgIDApOworCQlpZiAoZWxlbXMuaHRfY2FwYWJpbGl0aWVzICYmCisJCSAgICBlbGVtcy5odF9jYXBhYmlsaXRpZXNfbGVuID49CisJCSAgICBzaXplb2Yoc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMpKSB7CisJCQlzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyAqaHRfY2FwID0KKwkJCQkoc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgKikKKwkJCQllbGVtcy5odF9jYXBhYmlsaXRpZXM7CisKKwkJCWlmIChsZV90b19ob3N0MTYoaHRfY2FwLT5odF9jYXBhYmlsaXRpZXNfaW5mbykgJgorCQkJICAgIEhUX0NBUF9JTkZPXzQwTUhaX0lOVE9MRVJBTlQpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCQkJICAgIjQwIE1IeiBJbnRvbGVyYW50IGlzIHNldCBvbiBjaGFubmVsICVkIGluIEJTUyAiCisJCQkJCSAgIE1BQ1NUUiwgcHJpLCBNQUMyU1RSKGJzcy0+YnNzaWQpKTsKKwkJCQlyZXR1cm4gMDsKKwkJCX0KKwkJfQogCX0KIAogCXJldHVybiAxOwpAQCAtNDM3LDYgKzUzMiw3IEBACiAJCW9wZXI0MCA9IGllZWU4MDIxMW5fY2hlY2tfNDBtaHpfMmc0KGlmYWNlLCBzY2FuX3Jlcyk7CiAJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKIAorCWlmYWNlLT5zZWNvbmRhcnlfY2ggPSBpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWw7CiAJaWYgKCFvcGVyNDApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIjIwLzQwIE1IeiBvcGVyYXRpb24gbm90IHBlcm1pdHRlZCBvbiAiCiAJCQkgICAiY2hhbm5lbCBwcmk9JWQgc2VjPSVkIGJhc2VkIG9uIG92ZXJsYXBwaW5nIEJTU2VzIiwKQEAgLTQ0NCw5ICs1NDAsMjEgQEAKIAkJCSAgIGlmYWNlLT5jb25mLT5jaGFubmVsICsKIAkJCSAgIGlmYWNlLT5jb25mLT5zZWNvbmRhcnlfY2hhbm5lbCAqIDQpOwogCQlpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPSAwOworCQlpZiAoaWZhY2UtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfSFRfMjA0MF9DT0VYKSB7CisJCQkvKgorCQkJICogVE9ETzogQ291bGQgY29uc2lkZXIgc2NoZWR1bGluZyBhbm90aGVyIHNjYW4gdG8gY2hlY2sKKwkJCSAqIGlmIGNoYW5uZWwgd2lkdGggY2FuIGJlIGNoYW5nZWQgaWYgbm8gY29leCByZXBvcnRzCisJCQkgKiBhcmUgcmVjZWl2ZWQgZnJvbSBhc3NvY2lhdGluZyBzdGF0aW9ucy4KKwkJCSAqLworCQl9CiAJfQogCiAJcmVzID0gaWVlZTgwMjExbl9hbGxvd2VkX2h0NDBfY2hhbm5lbF9wYWlyKGlmYWNlKTsKKwlpZiAoIXJlcykgeworCQlpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPSAwOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFsbGJhY2sgdG8gMjAgTUh6Iik7CisJfQorCiAJaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2VfY29tcGxldGUoaWZhY2UsICFyZXMpOwogfQogCkBAIC00OTEsMjUgKzU5OSwxMjggQEAKIH0KIAogCitzdGF0aWMgdm9pZCBpZWVlODAyMTFuX3NjYW5fY2hhbm5lbHNfNWcoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAorCQkJCQlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqcGFyYW1zKQoreworCS8qIFNjYW4gb25seSB0aGUgYWZmZWN0ZWQgZnJlcXVlbmN5IHJhbmdlICovCisJaW50IHByaV9mcmVxOworCWludCBhZmZlY3RlZF9zdGFydCwgYWZmZWN0ZWRfZW5kOworCWludCBpLCBwb3M7CisJc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGU7CisKKwlpZiAoaWZhY2UtPmN1cnJlbnRfbW9kZSA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlwcmlfZnJlcSA9IGhvc3RhcGRfaHdfZ2V0X2ZyZXEoaWZhY2UtPmJzc1swXSwgaWZhY2UtPmNvbmYtPmNoYW5uZWwpOworCWlmIChpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPiAwKSB7CisJCWFmZmVjdGVkX3N0YXJ0ID0gcHJpX2ZyZXEgLSAxMDsKKwkJYWZmZWN0ZWRfZW5kID0gcHJpX2ZyZXEgKyAzMDsKKwl9IGVsc2UgeworCQlhZmZlY3RlZF9zdGFydCA9IHByaV9mcmVxIC0gMzA7CisJCWFmZmVjdGVkX2VuZCA9IHByaV9mcmVxICsgMTA7CisJfQorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiNDAgTUh6IGFmZmVjdGVkIGNoYW5uZWwgcmFuZ2U6IFslZCwlZF0gTUh6IiwKKwkJICAgYWZmZWN0ZWRfc3RhcnQsIGFmZmVjdGVkX2VuZCk7CisKKwltb2RlID0gaWZhY2UtPmN1cnJlbnRfbW9kZTsKKwlwYXJhbXMtPmZyZXFzID0gb3NfY2FsbG9jKG1vZGUtPm51bV9jaGFubmVscyArIDEsIHNpemVvZihpbnQpKTsKKwlpZiAocGFyYW1zLT5mcmVxcyA9PSBOVUxMKQorCQlyZXR1cm47CisJcG9zID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBtb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgeworCQlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4gPSAmbW9kZS0+Y2hhbm5lbHNbaV07CisJCWlmIChjaGFuLT5mbGFnICYgSE9TVEFQRF9DSEFOX0RJU0FCTEVEKQorCQkJY29udGludWU7CisJCWlmIChjaGFuLT5mcmVxIDwgYWZmZWN0ZWRfc3RhcnQgfHwKKwkJICAgIGNoYW4tPmZyZXEgPiBhZmZlY3RlZF9lbmQpCisJCQljb250aW51ZTsKKwkJcGFyYW1zLT5mcmVxc1twb3MrK10gPSBjaGFuLT5mcmVxOworCX0KK30KKworCitzdGF0aWMgdm9pZCBhcF9odDQwX3NjYW5fcmV0cnkodm9pZCAqZWxvb3BfZGF0YSwgdm9pZCAqdXNlcl9kYXRhKQoreworI2RlZmluZSBIVDIwNDBfQ09FWF9TQ0FOX1JFVFJZIDE1CisJc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlID0gZWxvb3BfZGF0YTsKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7CisJaW50IHJldDsKKworCW9zX21lbXNldCgmcGFyYW1zLCAwLCBzaXplb2YocGFyYW1zKSk7CisJaWYgKGlmYWNlLT5jdXJyZW50X21vZGUtPm1vZGUgPT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcpCisJCWllZWU4MDIxMW5fc2Nhbl9jaGFubmVsc18yZzQoaWZhY2UsICZwYXJhbXMpOworCWVsc2UKKwkJaWVlZTgwMjExbl9zY2FuX2NoYW5uZWxzXzVnKGlmYWNlLCAmcGFyYW1zKTsKKworCXJldCA9IGhvc3RhcGRfZHJpdmVyX3NjYW4oaWZhY2UtPmJzc1swXSwgJnBhcmFtcyk7CisJaWZhY2UtPm51bV9odDQwX3NjYW5fdHJpZXMrKzsKKwlvc19mcmVlKHBhcmFtcy5mcmVxcyk7CisKKwlpZiAocmV0ID09IC1FQlVTWSAmJgorCSAgICBpZmFjZS0+bnVtX2h0NDBfc2Nhbl90cmllcyA8IEhUMjA0MF9DT0VYX1NDQU5fUkVUUlkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiRmFpbGVkIHRvIHJlcXVlc3QgYSBzY2FuIG9mIG5laWdoYm9yaW5nIEJTU2VzIHJldD0lZCAoJXMpIC0gdHJ5IHRvIHNjYW4gYWdhaW4gKGF0dGVtcHQgJWQpIiwKKwkJCSAgIHJldCwgc3RyZXJyb3IoLXJldCksIGlmYWNlLT5udW1faHQ0MF9zY2FuX3RyaWVzKTsKKwkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgxLCAwLCBhcF9odDQwX3NjYW5fcmV0cnksIGlmYWNlLCBOVUxMKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChyZXQgPT0gMCkgeworCQlpZmFjZS0+c2Nhbl9jYiA9IGllZWU4MDIxMW5fY2hlY2tfc2NhbjsKKwkJcmV0dXJuOworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkgICAiRmFpbGVkIHRvIHJlcXVlc3QgYSBzY2FuIGluIGRldmljZSwgYnJpbmdpbmcgdXAgaW4gSFQyMCBtb2RlIik7CisJaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsID0gMDsKKwlpZmFjZS0+Y29uZi0+aHRfY2FwYWIgJj0gfkhUX0NBUF9JTkZPX1NVUFBfQ0hBTk5FTF9XSURUSF9TRVQ7CisJaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2VfY29tcGxldGUoaWZhY2UsIDApOworfQorCisKK3ZvaWQgaG9zdGFwZF9zdG9wX3NldHVwX3RpbWVycyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCit7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaHQ0MF9zY2FuX3JldHJ5LCBpZmFjZSwgTlVMTCk7Cit9CisKKwogc3RhdGljIGludCBpZWVlODAyMTFuX2NoZWNrXzQwbWh6KHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKIHsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7CisJaW50IHJldDsKIAogCWlmICghaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsKQogCQlyZXR1cm4gMDsgLyogSFQ0MCBub3QgdXNlZCAqLwogCisJaG9zdGFwZF9zZXRfc3RhdGUoaWZhY2UsIEhBUERfSUZBQ0VfSFRfU0NBTik7CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTY2FuIGZvciBuZWlnaGJvcmluZyBCU1NlcyBwcmlvciB0byBlbmFibGluZyAiCiAJCSAgICI0MCBNSHogY2hhbm5lbCIpOwogCW9zX21lbXNldCgmcGFyYW1zLCAwLCBzaXplb2YocGFyYW1zKSk7CiAJaWYgKGlmYWNlLT5jdXJyZW50X21vZGUtPm1vZGUgPT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcpCiAJCWllZWU4MDIxMW5fc2Nhbl9jaGFubmVsc18yZzQoaWZhY2UsICZwYXJhbXMpOwotCWlmIChob3N0YXBkX2RyaXZlcl9zY2FuKGlmYWNlLT5ic3NbMF0sICZwYXJhbXMpIDwgMCkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byByZXF1ZXN0IGEgc2NhbiBvZiAiCi0JCQkgICAibmVpZ2hib3JpbmcgQlNTZXMiKTsKLQkJb3NfZnJlZShwYXJhbXMuZnJlcXMpOworCWVsc2UKKwkJaWVlZTgwMjExbl9zY2FuX2NoYW5uZWxzXzVnKGlmYWNlLCAmcGFyYW1zKTsKKworCXJldCA9IGhvc3RhcGRfZHJpdmVyX3NjYW4oaWZhY2UtPmJzc1swXSwgJnBhcmFtcyk7CisJb3NfZnJlZShwYXJhbXMuZnJlcXMpOworCisJaWYgKHJldCA9PSAtRUJVU1kpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiRmFpbGVkIHRvIHJlcXVlc3QgYSBzY2FuIG9mIG5laWdoYm9yaW5nIEJTU2VzIHJldD0lZCAoJXMpIC0gdHJ5IHRvIHNjYW4gYWdhaW4iLAorCQkJICAgcmV0LCBzdHJlcnJvcigtcmV0KSk7CisJCWlmYWNlLT5udW1faHQ0MF9zY2FuX3RyaWVzID0gMTsKKwkJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaHQ0MF9zY2FuX3JldHJ5LCBpZmFjZSwgTlVMTCk7CisJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMSwgMCwgYXBfaHQ0MF9zY2FuX3JldHJ5LCBpZmFjZSwgTlVMTCk7CisJCXJldHVybiAxOworCX0KKworCWlmIChyZXQgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkZhaWxlZCB0byByZXF1ZXN0IGEgc2NhbiBvZiBuZWlnaGJvcmluZyBCU1NlcyByZXQ9JWQgKCVzKSIsCisJCQkgICByZXQsIHN0cmVycm9yKC1yZXQpKTsKIAkJcmV0dXJuIC0xOwogCX0KLQlvc19mcmVlKHBhcmFtcy5mcmVxcyk7CiAKIAlpZmFjZS0+c2Nhbl9jYiA9IGllZWU4MDIxMW5fY2hlY2tfc2NhbjsKIAlyZXR1cm4gMTsKQEAgLTU5NywxMiArODA4LDYgQEAKIAkJcmV0dXJuIDA7CiAJfQogCi0JaWYgKChjb25mICYgSFRfQ0FQX0lORk9fUFNNUF9TVVBQKSAmJiAhKGh3ICYgSFRfQ0FQX0lORk9fUFNNUF9TVVBQKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkRyaXZlciBkb2VzIG5vdCBzdXBwb3J0IGNvbmZpZ3VyZWQgIgotCQkJICAgIkhUIGNhcGFiaWxpdHkgW1BTTVBdIik7Ci0JCXJldHVybiAwOwotCX0KLQogCWlmICgoY29uZiAmIEhUX0NBUF9JTkZPX0xTSUdfVFhPUF9QUk9URUNUX1NVUFBPUlQpICYmCiAJICAgICEoaHcgJiBIVF9DQVBfSU5GT19MU0lHX1RYT1BfUFJPVEVDVF9TVVBQT1JUKSkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkRyaXZlciBkb2VzIG5vdCBzdXBwb3J0IGNvbmZpZ3VyZWQgIgpAQCAtNjEzLDYgKzgxOCw5MiBAQAogCXJldHVybiAxOwogfQogCisKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExQUMKKworc3RhdGljIGludCBpZWVlODAyMTFhY19jYXBfY2hlY2sodTMyIGh3LCB1MzIgY29uZiwgdTMyIGNhcCwgY29uc3QgY2hhciAqbmFtZSkKK3sKKwl1MzIgcmVxX2NhcCA9IGNvbmYgJiBjYXA7CisKKwkvKgorCSAqIE1ha2Ugc3VyZSB3ZSBzdXBwb3J0IGFsbCByZXF1ZXN0ZWQgY2FwYWJpbGl0aWVzLgorCSAqIE5PVEU6IFdlIGFzc3VtZSB0aGF0ICdjYXAnIHJlcHJlc2VudHMgYSBjYXBhYmlsaXR5IG1hc2ssCisJICogbm90IGEgZGlzY3JldGUgdmFsdWUuCisJICovCisJaWYgKChodyAmIHJlcV9jYXApICE9IHJlcV9jYXApIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJEcml2ZXIgZG9lcyBub3Qgc3VwcG9ydCBjb25maWd1cmVkIFZIVCBjYXBhYmlsaXR5IFslc10iLAorCQkJICAgbmFtZSk7CisJCXJldHVybiAwOworCX0KKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgaW50IGllZWU4MDIxMWFjX2NhcF9jaGVja19tYXgodTMyIGh3LCB1MzIgY29uZiwgdTMyIGNhcCwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKm5hbWUpCit7CisJdTMyIGh3X21heCA9IGh3ICYgY2FwOworCXUzMiBjb25mX3ZhbCA9IGNvbmYgJiBjYXA7CisKKwlpZiAoY29uZl92YWwgPiBod19tYXgpIHsKKwkJaW50IG9mZnNldCA9IGZpbmRfZmlyc3RfYml0KGNhcCk7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ29uZmlndXJlZCBWSFQgY2FwYWJpbGl0eSBbJXNdIGV4Y2VlZHMgbWF4IHZhbHVlIHN1cHBvcnRlZCBieSB0aGUgZHJpdmVyICglZCA+ICVkKSIsCisJCQkgICBuYW1lLCBjb25mX3ZhbCA+PiBvZmZzZXQsIGh3X21heCA+PiBvZmZzZXQpOworCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDE7Cit9CisKKworc3RhdGljIGludCBpZWVlODAyMTFhY19zdXBwb3J0ZWRfdmh0X2NhcGFiKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKK3sKKwl1MzIgaHcgPSBpZmFjZS0+Y3VycmVudF9tb2RlLT52aHRfY2FwYWI7CisJdTMyIGNvbmYgPSBpZmFjZS0+Y29uZi0+dmh0X2NhcGFiOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJodyB2aHQgY2FwYWI6IDB4JXgsIGNvbmYgdmh0IGNhcGFiOiAweCV4IiwKKwkJICAgaHcsIGNvbmYpOworCisjZGVmaW5lIFZIVF9DQVBfQ0hFQ0soY2FwKSBcCisJZG8geyBcCisJCWlmICghaWVlZTgwMjExYWNfY2FwX2NoZWNrKGh3LCBjb25mLCBjYXAsICNjYXApKSBcCisJCQlyZXR1cm4gMDsgXAorCX0gd2hpbGUgKDApCisKKyNkZWZpbmUgVkhUX0NBUF9DSEVDS19NQVgoY2FwKSBcCisJZG8geyBcCisJCWlmICghaWVlZTgwMjExYWNfY2FwX2NoZWNrX21heChodywgY29uZiwgY2FwLCAjY2FwKSkgXAorCQkJcmV0dXJuIDA7IFwKKwl9IHdoaWxlICgwKQorCisJVkhUX0NBUF9DSEVDS19NQVgoVkhUX0NBUF9NQVhfTVBEVV9MRU5HVEhfTUFTSyk7CisJVkhUX0NBUF9DSEVDSyhWSFRfQ0FQX1NVUFBfQ0hBTl9XSURUSF8xNjBNSFopOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwXzgwUExVUzgwTUhaKTsKKwlWSFRfQ0FQX0NIRUNLKFZIVF9DQVBfUlhMRFBDKTsKKwlWSFRfQ0FQX0NIRUNLKFZIVF9DQVBfU0hPUlRfR0lfODApOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9TSE9SVF9HSV8xNjApOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9UWFNUQkMpOworCVZIVF9DQVBfQ0hFQ0tfTUFYKFZIVF9DQVBfUlhTVEJDX01BU0spOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9TVV9CRUFNRk9STUVSX0NBUEFCTEUpOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9TVV9CRUFNRk9STUVFX0NBUEFCTEUpOworCVZIVF9DQVBfQ0hFQ0tfTUFYKFZIVF9DQVBfQkVBTUZPUk1FRV9TVFNfTUFYKTsKKwlWSFRfQ0FQX0NIRUNLX01BWChWSFRfQ0FQX1NPVU5ESU5HX0RJTUVOU0lPTl9NQVgpOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9NVV9CRUFNRk9STUVSX0NBUEFCTEUpOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9NVV9CRUFNRk9STUVFX0NBUEFCTEUpOworCVZIVF9DQVBfQ0hFQ0soVkhUX0NBUF9WSFRfVFhPUF9QUyk7CisJVkhUX0NBUF9DSEVDSyhWSFRfQ0FQX0hUQ19WSFQpOworCVZIVF9DQVBfQ0hFQ0tfTUFYKFZIVF9DQVBfTUFYX0FfTVBEVV9MRU5HVEhfRVhQT05FTlRfTUFYKTsKKwlWSFRfQ0FQX0NIRUNLKFZIVF9DQVBfVkhUX0xJTktfQURBUFRBVElPTl9WSFRfVU5TT0xfTUZCKTsKKwlWSFRfQ0FQX0NIRUNLKFZIVF9DQVBfVkhUX0xJTktfQURBUFRBVElPTl9WSFRfTVJRX01GQik7CisJVkhUX0NBUF9DSEVDSyhWSFRfQ0FQX1JYX0FOVEVOTkFfUEFUVEVSTik7CisJVkhUX0NBUF9DSEVDSyhWSFRfQ0FQX1RYX0FOVEVOTkFfUEFUVEVSTik7CisKKyN1bmRlZiBWSFRfQ0FQX0NIRUNLCisjdW5kZWYgVkhUX0NBUF9DSEVDS19NQVgKKworCXJldHVybiAxOworfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFBQyAqLworCiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMU4gKi8KIAogCkBAIC02MjQsNiArOTE1LDEwIEBACiAJCXJldHVybiAwOwogCWlmICghaWVlZTgwMjExbl9zdXBwb3J0ZWRfaHRfY2FwYWIoaWZhY2UpKQogCQlyZXR1cm4gLTE7CisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMUFDCisJaWYgKCFpZWVlODAyMTFhY19zdXBwb3J0ZWRfdmh0X2NhcGFiKGlmYWNlKSkKKwkJcmV0dXJuIC0xOworI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFBQyAqLwogCXJldCA9IGllZWU4MDIxMW5fY2hlY2tfNDBtaHooaWZhY2UpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CkBAIC03MTgsMzMgKzEwMTMsNDUgQEAKIH0KIAogCi1pbnQgaG9zdGFwZF9hY3NfY29tcGxldGVkKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSkKK2ludCBob3N0YXBkX2Fjc19jb21wbGV0ZWQoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLCBpbnQgZXJyKQogewotCWludCByZXQ7CisJaW50IHJldCA9IC0xOworCisJaWYgKGVycikKKwkJZ290byBvdXQ7CiAKIAlzd2l0Y2ggKGhvc3RhcGRfY2hlY2tfY2hhbnMoaWZhY2UpKSB7CiAJY2FzZSBIT1NUQVBEX0NIQU5fVkFMSUQ6CisJCXdwYV9tc2coaWZhY2UtPmJzc1swXS0+bXNnX2N0eCwgTVNHX0lORk8sCisJCQlBQ1NfRVZFTlRfQ09NUExFVEVEICJmcmVxPSVkIGNoYW5uZWw9JWQiLAorCQkJaG9zdGFwZF9od19nZXRfZnJlcShpZmFjZS0+YnNzWzBdLAorCQkJCQkgICAgaWZhY2UtPmNvbmYtPmNoYW5uZWwpLAorCQkJaWZhY2UtPmNvbmYtPmNoYW5uZWwpOwogCQlicmVhazsKIAljYXNlIEhPU1RBUERfQ0hBTl9BQ1M6CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQUNTIGVycm9yIC0gcmVwb3J0ZWQgY29tcGxldGUsIGJ1dCBubyByZXN1bHQgYXZhaWxhYmxlIik7CisJCXdwYV9tc2coaWZhY2UtPmJzc1swXS0+bXNnX2N0eCwgTVNHX0lORk8sIEFDU19FVkVOVF9GQUlMRUQpOwogCQlob3N0YXBkX25vdGlmeV9iYWRfY2hhbnMoaWZhY2UpOwotCQlyZXR1cm4gLTE7CisJCWdvdG8gb3V0OwogCWNhc2UgSE9TVEFQRF9DSEFOX0lOVkFMSUQ6CiAJZGVmYXVsdDoKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJBQ1MgcGlja2VkIHVudXNhYmxlIGNoYW5uZWxzIik7CisJCXdwYV9tc2coaWZhY2UtPmJzc1swXS0+bXNnX2N0eCwgTVNHX0lORk8sIEFDU19FVkVOVF9GQUlMRUQpOwogCQlob3N0YXBkX25vdGlmeV9iYWRfY2hhbnMoaWZhY2UpOwotCQlyZXR1cm4gLTE7CisJCWdvdG8gb3V0OwogCX0KIAogCXJldCA9IGhvc3RhcGRfY2hlY2tfaHRfY2FwYWIoaWZhY2UpOwogCWlmIChyZXQgPCAwKQotCQlyZXR1cm4gLTE7CisJCWdvdG8gb3V0OwogCWlmIChyZXQgPT0gMSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyZmFjZSBpbml0aWFsaXphdGlvbiB3aWxsIGJlIGNvbXBsZXRlZCBpbiBhIGNhbGxiYWNrIik7CiAJCXJldHVybiAwOwogCX0KIAotCXJldHVybiBob3N0YXBkX3NldHVwX2ludGVyZmFjZV9jb21wbGV0ZShpZmFjZSwgMCk7CisJcmV0ID0gMDsKK291dDoKKwlyZXR1cm4gaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2VfY29tcGxldGUoaWZhY2UsIHJldCk7CiB9CiAKIApAQCAtNzYzLDYgKzEwNzAsMTUgQEAKIAlpZiAoaWZhY2UtPm51bV9od19mZWF0dXJlcyA8IDEpCiAJCXJldHVybiAtMTsKIAorCWlmICgoaWZhY2UtPmNvbmYtPmh3X21vZGUgPT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcgfHwKKwkgICAgIGlmYWNlLT5jb25mLT5pZWVlODAyMTFuIHx8IGlmYWNlLT5jb25mLT5pZWVlODAyMTFhYykgJiYKKwkgICAgaWZhY2UtPmNvbmYtPmNoYW5uZWwgPT0gMTQpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkRpc2FibGUgT0ZETS9IVC9WSFQgb24gY2hhbm5lbCAxNCIpOworCQlpZmFjZS0+Y29uZi0+aHdfbW9kZSA9IEhPU1RBUERfTU9ERV9JRUVFODAyMTFCOworCQlpZmFjZS0+Y29uZi0+aWVlZTgwMjExbiA9IDA7CisJCWlmYWNlLT5jb25mLT5pZWVlODAyMTFhYyA9IDA7CisJfQorCiAJaWZhY2UtPmN1cnJlbnRfbW9kZSA9IE5VTEw7CiAJZm9yIChpID0gMDsgaSA8IGlmYWNlLT5udW1faHdfZmVhdHVyZXM7IGkrKykgewogCQlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZSA9ICZpZmFjZS0+aHdfZmVhdHVyZXNbaV07CkBAIC03OTMsOCArMTEwOSw2IEBACiAJCWhvc3RhcGRfbm90aWZ5X2JhZF9jaGFucyhpZmFjZSk7CiAJCXJldHVybiAtMzsKIAl9Ci0KLQlyZXR1cm4gMDsKIH0KIAogCmRpZmYgLS1naXQgYS9zcmMvYXAvaHdfZmVhdHVyZXMuaCBiL3NyYy9hcC9od19mZWF0dXJlcy5oCmluZGV4IGFiYWRjZDEuLjBmNjdhYjggMTAwNjQ0Ci0tLSBhL3NyYy9hcC9od19mZWF0dXJlcy5oCisrKyBiL3NyYy9hcC9od19mZWF0dXJlcy5oCkBAIC00LDE0ICs0LDggQEAKICAqIENvcHlyaWdodCAyMDA1LTIwMDYsIERldmljZXNjYXBlIFNvZnR3YXJlLCBJbmMuCiAgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaWZuZGVmIEhXX0ZFQVRVUkVTX0gKQEAgLTIxLDYgKzE1LDcgQEAKIHZvaWQgaG9zdGFwZF9mcmVlX2h3X2ZlYXR1cmVzKHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICpod19mZWF0dXJlcywKIAkJCSAgICAgIHNpemVfdCBudW1faHdfZmVhdHVyZXMpOwogaW50IGhvc3RhcGRfZ2V0X2h3X2ZlYXR1cmVzKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7CitpbnQgaG9zdGFwZF9hY3NfY29tcGxldGVkKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgaW50IGVycik7CiBpbnQgaG9zdGFwZF9zZWxlY3RfaHdfbW9kZShzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpOwogY29uc3QgY2hhciAqIGhvc3RhcGRfaHdfbW9kZV90eHQoaW50IG1vZGUpOwogaW50IGhvc3RhcGRfaHdfZ2V0X2ZyZXEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgaW50IGNoYW4pOwpAQCAtMjgsNiArMjMsNyBAQAogaW50IGhvc3RhcGRfY2hlY2tfaHRfY2FwYWIoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKIGludCBob3N0YXBkX3ByZXBhcmVfcmF0ZXMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlLAogCQkJICBzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZSk7Cit2b2lkIGhvc3RhcGRfc3RvcF9zZXR1cF90aW1lcnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKICNlbHNlIC8qIE5FRURfQVBfTUxNRSAqLwogc3RhdGljIGlubGluZSB2b2lkCiBob3N0YXBkX2ZyZWVfaHdfZmVhdHVyZXMoc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKmh3X2ZlYXR1cmVzLApAQCAtNjYsNiArNjIsMTAgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIGhvc3RhcGRfc3RvcF9zZXR1cF90aW1lcnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQoreworfQorCiAjZW5kaWYgLyogTkVFRF9BUF9NTE1FICovCiAKICNlbmRpZiAvKiBIV19GRUFUVVJFU19IICovCmRpZmYgLS1naXQgYS9zcmMvYXAvaWFwcC5jIGIvc3JjL2FwL2lhcHAuYwppbmRleCBiZTU1YzY5Li45YjI5MDBmIDEwMDY0NAotLS0gYS9zcmMvYXAvaWFwcC5jCisrKyBiL3NyYy9hcC9pYXBwLmMKQEAgLTIwNCw3ICsyMDQsNyBAQAogCWFkZHIuc2luX3BvcnQgPSBodG9ucyhJQVBQX1VEUF9QT1JUKTsKIAlpZiAoc2VuZHRvKGlhcHAtPnVkcF9zb2NrLCBidWYsIChjaGFyICopIChhZGQgKyAxKSAtIGJ1ZiwgMCwKIAkJICAgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApCi0JCXBlcnJvcigic2VuZHRvW0lBUFAtQUREXSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAic2VuZHRvW0lBUFAtQUREXTogJXMiLCBzdHJlcnJvcihlcnJubykpOwogfQogCiAKQEAgLTIzMSw3ICsyMzEsNyBAQAogCQkJCSAgICogRklYOiB3aGF0IGlzIGNvcnJlY3QgUlcgd2l0aCA4MDIuMTE/ICovCiAKIAlpZiAoc2VuZChpYXBwLT5wYWNrZXRfc29jaywgJm1zZywgc2l6ZW9mKG1zZyksIDApIDwgMCkKLQkJcGVycm9yKCJzZW5kW0wyIFVwZGF0ZV0iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgInNlbmRbTDIgVXBkYXRlXTogJXMiLCBzdHJlcnJvcihlcnJubykpOwogfQogCiAKQEAgLTI0MiwyOSArMjQyLDIyIEBACiAgKi8KIHZvaWQgaWFwcF9uZXdfc3RhdGlvbihzdHJ1Y3QgaWFwcF9kYXRhICppYXBwLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSkKIHsKLQlzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKmFzc29jOwotCXUxNiBzZXE7CisJdTE2IHNlcSA9IDA7IC8qIFRPRE8gKi8KIAogCWlmIChpYXBwID09IE5VTEwpCiAJCXJldHVybjsKIAotCWFzc29jID0gc3RhLT5sYXN0X2Fzc29jX3JlcTsKLQlzZXEgPSBhc3NvYyA/IFdMQU5fR0VUX1NFUV9TRVEobGVfdG9faG9zdDE2KGFzc29jLT5zZXFfY3RybCkpIDogMDsKLQogCS8qIElBUFAtQURELnJlcXVlc3QoTUFDIEFkZHJlc3MsIFNlcXVlbmNlIE51bWJlciwgVGltZW91dCkgKi8KIAlob3N0YXBkX2xvZ2dlcihpYXBwLT5oYXBkLCBzdGEtPmFkZHIsIEhPU1RBUERfTU9EVUxFX0lBUFAsCiAJCSAgICAgICBIT1NUQVBEX0xFVkVMX0RFQlVHLCAiSUFQUC1BREQucmVxdWVzdChzZXE9JWQpIiwgc2VxKTsKIAlpYXBwX3NlbmRfbGF5ZXIyX3VwZGF0ZShpYXBwLCBzdGEtPmFkZHIpOwogCWlhcHBfc2VuZF9hZGQoaWFwcCwgc3RhLT5hZGRyLCBzZXEpOwogCi0JaWYgKGFzc29jICYmIFdMQU5fRkNfR0VUX1NUWVBFKGxlX3RvX2hvc3QxNihhc3NvYy0+ZnJhbWVfY29udHJvbCkpID09Ci0JICAgIFdMQU5fRkNfU1RZUEVfUkVBU1NPQ19SRVEpIHsKLQkJLyogSUFQUC1NT1ZFLnJlcXVlc3QoTUFDIEFkZHJlc3MsIFNlcXVlbmNlIE51bWJlciwgT2xkIEFQLAotCQkgKiAgICAgICAgICAgICAgICAgICBDb250ZXh0IEJsb2NrLCBUaW1lb3V0KQotCQkgKi8KLQkJLyogVE9ETzogU2VuZCBJQVBQLU1PVkUgdG8gdGhlIG9sZCBBUDsgTWFwIE9sZCBBUCBCU1NJRCB0bwotCQkgKiBJUCBhZGRyZXNzICovCi0JfQorCS8qIFRPRE86IElmIHRoaXMgd2FzIHJlYXNzb2NpYXRpb246CisJICogSUFQUC1NT1ZFLnJlcXVlc3QoTUFDIEFkZHJlc3MsIFNlcXVlbmNlIE51bWJlciwgT2xkIEFQLAorCSAqICAgICAgICAgICAgICAgICAgIENvbnRleHQgQmxvY2ssIFRpbWVvdXQpCisJICogVE9ETzogU2VuZCBJQVBQLU1PVkUgdG8gdGhlIG9sZCBBUDsgTWFwIE9sZCBBUCBCU1NJRCB0bworCSAqIElQIGFkZHJlc3MgKi8KIH0KIAogCkBAIC0yNzYsOCArMjY5LDggQEAKIAlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKIAogCWlmIChsZW4gIT0gc2l6ZW9mKCphZGQpKSB7Ci0JCXByaW50ZigiSW52YWxpZCBJQVBQLUFERCBwYWNrZXQgbGVuZ3RoICVkIChleHBlY3RlZCAlbHUpXG4iLAotCQkgICAgICAgbGVuLCAodW5zaWduZWQgbG9uZykgc2l6ZW9mKCphZGQpKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgSUFQUC1BREQgcGFja2V0IGxlbmd0aCAlZCAoZXhwZWN0ZWQgJWx1KSIsCisJCQkgICBsZW4sICh1bnNpZ25lZCBsb25nKSBzaXplb2YoKmFkZCkpOwogCQlyZXR1cm47CiAJfQogCkBAIC0zMjYsNyArMzE5LDggQEAKIAlsZW4gPSByZWN2ZnJvbShpYXBwLT51ZHBfc29jaywgYnVmLCBzaXplb2YoYnVmKSwgMCwKIAkJICAgICAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sICZmcm9tbGVuKTsKIAlpZiAobGVuIDwgMCkgewotCQlwZXJyb3IoInJlY3Zmcm9tIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJpYXBwX3JlY2VpdmVfdWRwIC0gcmVjdmZyb206ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTM1MCwxNyArMzQ0LDE4IEBACiAJCSAgICAgICBoZHItPnZlcnNpb24sIGhkci0+Y29tbWFuZCwKIAkJICAgICAgIGJlX3RvX2hvc3QxNihoZHItPmlkZW50aWZpZXIpLCBobGVuKTsKIAlpZiAoaGRyLT52ZXJzaW9uICE9IElBUFBfVkVSU0lPTikgewotCQlwcmludGYoIkRyb3BwaW5nIElBUFAgZnJhbWUgd2l0aCB1bmtub3duIHZlcnNpb24gJWRcbiIsCi0JCSAgICAgICBoZHItPnZlcnNpb24pOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRHJvcHBpbmcgSUFQUCBmcmFtZSB3aXRoIHVua25vd24gdmVyc2lvbiAlZCIsCisJCQkgICBoZHItPnZlcnNpb24pOwogCQlyZXR1cm47CiAJfQogCWlmIChobGVuID4gbGVuKSB7Ci0JCXByaW50ZigiVW5kZXJmbG93IElBUFAgZnJhbWUgKGhsZW49JWQgbGVuPSVkKVxuIiwgaGxlbiwgbGVuKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuZGVyZmxvdyBJQVBQIGZyYW1lIChobGVuPSVkIGxlbj0lZCkiLAorCQkJICAgaGxlbiwgbGVuKTsKIAkJcmV0dXJuOwogCX0KIAlpZiAoaGxlbiA8IGxlbikgewotCQlwcmludGYoIklnbm9yaW5nICVkIGV4dHJhIGJ5dGVzIGZyb20gSUFQUCBmcmFtZVxuIiwKLQkJICAgICAgIGxlbiAtIGhsZW4pOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSWdub3JpbmcgJWQgZXh0cmEgYnl0ZXMgZnJvbSBJQVBQIGZyYW1lIiwKKwkJCSAgIGxlbiAtIGhsZW4pOwogCQlsZW4gPSBobGVuOwogCX0KIApAQCAtMzc2LDcgKzM3MSw3IEBACiAJCS8qIFRPRE86IHByb2Nlc3MgKi8KIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJcHJpbnRmKCJVbmtub3duIElBUFAgY29tbWFuZCAlZFxuIiwgaGRyLT5jb21tYW5kKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVua25vd24gSUFQUCBjb21tYW5kICVkIiwgaGRyLT5jb21tYW5kKTsKIAkJYnJlYWs7CiAJfQogfQpAQCAtNDAzLDcgKzM5OCw4IEBACiAKIAlpYXBwLT51ZHBfc29jayA9IHNvY2tldChQRl9JTkVULCBTT0NLX0RHUkFNLCAwKTsKIAlpZiAoaWFwcC0+dWRwX3NvY2sgPCAwKSB7Ci0JCXBlcnJvcigic29ja2V0W1BGX0lORVQsU09DS19ER1JBTV0iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImlhcHBfaW5pdCAtIHNvY2tldFtQRl9JTkVULFNPQ0tfREdSQU1dOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQlpYXBwX2RlaW5pdChpYXBwKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtNDExLDM1ICs0MDcsMzggQEAKIAlvc19tZW1zZXQoJmlmciwgMCwgc2l6ZW9mKGlmcikpOwogCW9zX3N0cmxjcHkoaWZyLmlmcl9uYW1lLCBpZmFjZSwgc2l6ZW9mKGlmci5pZnJfbmFtZSkpOwogCWlmIChpb2N0bChpYXBwLT51ZHBfc29jaywgU0lPQ0dJRklOREVYLCAmaWZyKSAhPSAwKSB7Ci0JCXBlcnJvcigiaW9jdGwoU0lPQ0dJRklOREVYKSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaWFwcF9pbml0IC0gaW9jdGwoU0lPQ0dJRklOREVYKTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJaWFwcF9kZWluaXQoaWFwcCk7CiAJCXJldHVybiBOVUxMOwogCX0KIAlpZmluZGV4ID0gaWZyLmlmcl9pZmluZGV4OwogCiAJaWYgKGlvY3RsKGlhcHAtPnVkcF9zb2NrLCBTSU9DR0lGQUREUiwgJmlmcikgIT0gMCkgewotCQlwZXJyb3IoImlvY3RsKFNJT0NHSUZBRERSKSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaWFwcF9pbml0IC0gaW9jdGwoU0lPQ0dJRkFERFIpOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQlpYXBwX2RlaW5pdChpYXBwKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCXBhZGRyID0gKHN0cnVjdCBzb2NrYWRkcl9pbiAqKSAmaWZyLmlmcl9hZGRyOwogCWlmIChwYWRkci0+c2luX2ZhbWlseSAhPSBBRl9JTkVUKSB7Ci0JCXByaW50ZigiSW52YWxpZCBhZGRyZXNzIGZhbWlseSAlaSAoU0lPQ0dJRkFERFIpXG4iLAotCQkgICAgICAgcGFkZHItPnNpbl9mYW1pbHkpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSUFQUDogSW52YWxpZCBhZGRyZXNzIGZhbWlseSAlaSAoU0lPQ0dJRkFERFIpIiwKKwkJCSAgIHBhZGRyLT5zaW5fZmFtaWx5KTsKIAkJaWFwcF9kZWluaXQoaWFwcCk7CiAJCXJldHVybiBOVUxMOwogCX0KIAlpYXBwLT5vd24uc19hZGRyID0gcGFkZHItPnNpbl9hZGRyLnNfYWRkcjsKIAogCWlmIChpb2N0bChpYXBwLT51ZHBfc29jaywgU0lPQ0dJRkJSREFERFIsICZpZnIpICE9IDApIHsKLQkJcGVycm9yKCJpb2N0bChTSU9DR0lGQlJEQUREUikiKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImlhcHBfaW5pdCAtIGlvY3RsKFNJT0NHSUZCUkRBRERSKTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJaWFwcF9kZWluaXQoaWFwcCk7CiAJCXJldHVybiBOVUxMOwogCX0KIAlwYWRkciA9IChzdHJ1Y3Qgc29ja2FkZHJfaW4gKikgJmlmci5pZnJfYWRkcjsKIAlpZiAocGFkZHItPnNpbl9mYW1pbHkgIT0gQUZfSU5FVCkgewotCQlwcmludGYoIkludmFsaWQgYWRkcmVzcyBmYW1pbHkgJWkgKFNJT0NHSUZCUkRBRERSKVxuIiwKLQkJICAgICAgIHBhZGRyLT5zaW5fZmFtaWx5KTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgYWRkcmVzcyBmYW1pbHkgJWkgKFNJT0NHSUZCUkRBRERSKSIsCisJCQkgICBwYWRkci0+c2luX2ZhbWlseSk7CiAJCWlhcHBfZGVpbml0KGlhcHApOwogCQlyZXR1cm4gTlVMTDsKIAl9CkBAIC00NTAsNyArNDQ5LDggQEAKIAl1YWRkci5zaW5fcG9ydCA9IGh0b25zKElBUFBfVURQX1BPUlQpOwogCWlmIChiaW5kKGlhcHAtPnVkcF9zb2NrLCAoc3RydWN0IHNvY2thZGRyICopICZ1YWRkciwKIAkJIHNpemVvZih1YWRkcikpIDwgMCkgewotCQlwZXJyb3IoImJpbmRbVURQXSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaWFwcF9pbml0IC0gYmluZFtVRFBdOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQlpYXBwX2RlaW5pdChpYXBwKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtNDYxLDE0ICs0NjEsMTYgQEAKIAltcmVxLmltcl9pZmluZGV4ID0gMDsKIAlpZiAoc2V0c29ja29wdChpYXBwLT51ZHBfc29jaywgU09MX0lQLCBJUF9BRERfTUVNQkVSU0hJUCwgJm1yZXEsCiAJCSAgICAgICBzaXplb2YobXJlcSkpIDwgMCkgewotCQlwZXJyb3IoInNldHNvY2tvcHRbVURQLElQX0FERF9NRU1CRVJTSElQXSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaWFwcF9pbml0IC0gc2V0c29ja29wdFtVRFAsSVBfQUREX01FTUJFUlNISVBdOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQlpYXBwX2RlaW5pdChpYXBwKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCiAJaWFwcC0+cGFja2V0X3NvY2sgPSBzb2NrZXQoUEZfUEFDS0VULCBTT0NLX1JBVywgaHRvbnMoRVRIX1BfQUxMKSk7CiAJaWYgKGlhcHAtPnBhY2tldF9zb2NrIDwgMCkgewotCQlwZXJyb3IoInNvY2tldFtQRl9QQUNLRVQsU09DS19SQVddIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJpYXBwX2luaXQgLSBzb2NrZXRbUEZfUEFDS0VULFNPQ0tfUkFXXTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJaWFwcF9kZWluaXQoaWFwcCk7CiAJCXJldHVybiBOVUxMOwogCX0KQEAgLTQ3OCwxOSArNDgwLDIwIEBACiAJYWRkci5zbGxfaWZpbmRleCA9IGlmaW5kZXg7CiAJaWYgKGJpbmQoaWFwcC0+cGFja2V0X3NvY2ssIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmFkZHIsCiAJCSBzaXplb2YoYWRkcikpIDwgMCkgewotCQlwZXJyb3IoImJpbmRbUEFDS0VUXSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaWFwcF9pbml0IC0gYmluZFtQQUNLRVRdOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQlpYXBwX2RlaW5pdChpYXBwKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCiAJaWYgKGVsb29wX3JlZ2lzdGVyX3JlYWRfc29jayhpYXBwLT51ZHBfc29jaywgaWFwcF9yZWNlaXZlX3VkcCwKIAkJCQkgICAgIGlhcHAsIE5VTEwpKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IHJlZ2lzdGVyIHJlYWQgc29ja2V0IGZvciBJQVBQLlxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcmVnaXN0ZXIgcmVhZCBzb2NrZXQgZm9yIElBUFAiKTsKIAkJaWFwcF9kZWluaXQoaWFwcCk7CiAJCXJldHVybiBOVUxMOwogCX0KIAotCXByaW50ZigiSUVFRSA4MDIuMTFGIChJQVBQKSB1c2luZyBpbnRlcmZhY2UgJXNcbiIsIGlmYWNlKTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSUVFRSA4MDIuMTFGIChJQVBQKSB1c2luZyBpbnRlcmZhY2UgJXMiLCBpZmFjZSk7CiAKIAkvKiBUT0RPOiBGb3IgbGV2ZWxzIDIgYW5kIDM6IHNlbmQgUkFESVVTIEluaXRpYXRlLVJlcXVlc3QsIHJlY2VpdmUKIAkgKiBSQURJVVMgSW5pdGlhdGUtQWNjZXB0IG9yIEluaXRpYXRlLVJlamVjdC4gSUFQUCBwb3J0IHNob3VsZCBhY3R1YWxseQpAQCAtNTE1LDcgKzUxOCw4IEBACiAJCW1yZXEuaW1yX2lmaW5kZXggPSAwOwogCQlpZiAoc2V0c29ja29wdChpYXBwLT51ZHBfc29jaywgU09MX0lQLCBJUF9EUk9QX01FTUJFUlNISVAsCiAJCQkgICAgICAgJm1yZXEsIHNpemVvZihtcmVxKSkgPCAwKSB7Ci0JCQlwZXJyb3IoInNldHNvY2tvcHRbVURQLElQX0RFTF9NRU1CRVJTSElQXSIpOworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgImlhcHBfZGVpbml0IC0gc2V0c29ja29wdFtVRFAsSVBfREVMX01FTUJFUlNISVBdOiAlcyIsCisJCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJfQogCiAJCWVsb29wX3VucmVnaXN0ZXJfcmVhZF9zb2NrKGlhcHAtPnVkcF9zb2NrKTsKZGlmZiAtLWdpdCBhL3NyYy9hcC9pZWVlODAyXzExLmMgYi9zcmMvYXAvaWVlZTgwMl8xMS5jCmluZGV4IDc4MWY4MjYuLmRlMWVlNWUgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9pZWVlODAyXzExLmMKKysrIGIvc3JjL2FwL2llZWU4MDJfMTEuYwpAQCAtMTUsNyArMTUsNiBAQAogI2luY2x1ZGUgImNyeXB0by9jcnlwdG8uaCIKICNpbmNsdWRlICJjcnlwdG8vc2hhMjU2LmgiCiAjaW5jbHVkZSAiY3J5cHRvL3JhbmRvbS5oIgotI2luY2x1ZGUgImRyaXZlcnMvZHJpdmVyLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIgogI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgpAQCAtMzksNiArMzgsNyBAQAogI2luY2x1ZGUgImFwX2Rydl9vcHMuaCIKICNpbmNsdWRlICJ3bm1fYXAuaCIKICNpbmNsdWRlICJpZWVlODAyXzExLmgiCisjaW5jbHVkZSAiZGZzLmgiCiAKIAogdTggKiBob3N0YXBkX2VpZF9zdXBwX3JhdGVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpCkBAIC02Miw3ICs2Miw2IEBACiAJfQogCiAJKnBvcysrID0gbnVtOwotCWNvdW50ID0gMDsKIAlmb3IgKGkgPSAwLCBjb3VudCA9IDA7IGkgPCBoYXBkLT5pZmFjZS0+bnVtX3JhdGVzICYmIGNvdW50IDwgbnVtOwogCSAgICAgaSsrKSB7CiAJCWNvdW50Kys7CkBAIC0xMDUsNyArMTA0LDYgQEAKIAogCSpwb3MrKyA9IFdMQU5fRUlEX0VYVF9TVVBQX1JBVEVTOwogCSpwb3MrKyA9IG51bTsKLQljb3VudCA9IDA7CiAJZm9yIChpID0gMCwgY291bnQgPSAwOyBpIDwgaGFwZC0+aWZhY2UtPm51bV9yYXRlcyAmJiBjb3VudCA8IG51bSArIDg7CiAJICAgICBpKyspIHsKIAkJY291bnQrKzsKQEAgLTEzOCw2ICsxMzYsMTUgQEAKIHsKIAlpbnQgY2FwYWIgPSBXTEFOX0NBUEFCSUxJVFlfRVNTOwogCWludCBwcml2YWN5OworCWludCBkZnM7CisKKwkvKiBDaGVjayBpZiBhbnkgb2YgY29uZmlndXJlZCBjaGFubmVscyByZXF1aXJlIERGUyAqLworCWRmcyA9IGhvc3RhcGRfaXNfZGZzX3JlcXVpcmVkKGhhcGQtPmlmYWNlKTsKKwlpZiAoZGZzIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiRmFpbGVkIHRvIGNoZWNrIGlmIERGUyBpcyByZXF1aXJlZDsgcmV0PSVkIiwKKwkJCSAgIGRmcyk7CisJCWRmcyA9IDA7CisJfQogCiAJaWYgKGhhcGQtPmlmYWNlLT5udW1fc3RhX25vX3Nob3J0X3ByZWFtYmxlID09IDAgJiYKIAkgICAgaGFwZC0+aWNvbmYtPnByZWFtYmxlID09IFNIT1JUX1BSRUFNQkxFKQpAQCAtMTUzLDYgKzE2MCwxMSBAQAogCWlmIChoYXBkLT5jb25mLT53cGEpCiAJCXByaXZhY3kgPSAxOwogCisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAoaGFwZC0+Y29uZi0+b3NlbikKKwkJcHJpdmFjeSA9IDE7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogCWlmIChzdGEpIHsKIAkJaW50IHBvbGljeSwgZGVmX2tsZW47CiAJCWlmIChwcm9iZSAmJiBzdGEtPnNzaWRfcHJvYmUpIHsKQEAgLTE3NSwyNSArMTg3LDIxIEBACiAJICAgIGhhcGQtPmlmYWNlLT5udW1fc3RhX25vX3Nob3J0X3Nsb3RfdGltZSA9PSAwKQogCQljYXBhYiB8PSBXTEFOX0NBUEFCSUxJVFlfU0hPUlRfU0xPVF9USU1FOwogCisJLyoKKwkgKiBDdXJyZW50bHksIFNwZWN0cnVtIE1hbmFnZW1lbnQgY2FwYWJpbGl0eSBiaXQgaXMgc2V0IHdoZW4gZGlyZWN0bHkKKwkgKiByZXF1ZXN0ZWQgaW4gY29uZmlndXJhdGlvbiBieSBzcGVjdHJ1bV9tZ210X3JlcXVpcmVkIG9yIHdoZW4gQVAgaXMKKwkgKiBydW5uaW5nIG9uIERGUyBjaGFubmVsLgorCSAqIFRPRE86IEFsc28gY29uc2lkZXIgZHJpdmVyIHN1cHBvcnQgZm9yIFRQQyB0byBzZXQgU3BlY3RydW0gTWdtdCBiaXQKKwkgKi8KKwlpZiAoaGFwZC0+aWZhY2UtPmN1cnJlbnRfbW9kZSAmJgorCSAgICBoYXBkLT5pZmFjZS0+Y3VycmVudF9tb2RlLT5tb2RlID09IEhPU1RBUERfTU9ERV9JRUVFODAyMTFBICYmCisJICAgIChoYXBkLT5pY29uZi0+c3BlY3RydW1fbWdtdF9yZXF1aXJlZCB8fCBkZnMpKQorCQljYXBhYiB8PSBXTEFOX0NBUEFCSUxJVFlfU1BFQ1RSVU1fTUdNVDsKKwogCXJldHVybiBjYXBhYjsKIH0KIAogCi12b2lkIGllZWU4MDJfMTFfcHJpbnRfc3NpZChjaGFyICpidWYsIGNvbnN0IHU4ICpzc2lkLCB1OCBsZW4pCi17Ci0JaW50IGk7Ci0JaWYgKGxlbiA+IEhPU1RBUERfTUFYX1NTSURfTEVOKQotCQlsZW4gPSBIT1NUQVBEX01BWF9TU0lEX0xFTjsKLQlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJaWYgKHNzaWRbaV0gPj0gMzIgJiYgc3NpZFtpXSA8IDEyNykKLQkJCWJ1ZltpXSA9IHNzaWRbaV07Ci0JCWVsc2UKLQkJCWJ1ZltpXSA9ICcuJzsKLQl9Ci0JYnVmW2xlbl0gPSAnXDAnOwotfQotCi0KIHN0YXRpYyB1MTYgYXV0aF9zaGFyZWRfa2V5KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAogCQkJICAgdTE2IGF1dGhfdHJhbnNhY3Rpb24sIGNvbnN0IHU4ICpjaGFsbGVuZ2UsCiAJCQkgICBpbnQgaXN3ZXApCkBAIC0yMjgsNyArMjM2LDggQEAKIAogCS8qIFRyYW5zYWN0aW9uIDMgKi8KIAlpZiAoIWlzd2VwIHx8ICFzdGEtPmNoYWxsZW5nZSB8fCAhY2hhbGxlbmdlIHx8Ci0JICAgIG9zX21lbWNtcChzdGEtPmNoYWxsZW5nZSwgY2hhbGxlbmdlLCBXTEFOX0FVVEhfQ0hBTExFTkdFX0xFTikpIHsKKwkgICAgb3NfbWVtY21wX2NvbnN0KHN0YS0+Y2hhbGxlbmdlLCBjaGFsbGVuZ2UsCisJCQkgICAgV0xBTl9BVVRIX0NIQUxMRU5HRV9MRU4pKSB7CiAJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIHN0YS0+YWRkciwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAogCQkJICAgICAgIEhPU1RBUERfTEVWRUxfSU5GTywKIAkJCSAgICAgICAic2hhcmVkIGtleSBhdXRoZW50aWNhdGlvbiAtIGludmFsaWQgIgpAQCAtMjM5LDEzICsyNDgsOCBAQAogCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIHN0YS0+YWRkciwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAogCQkgICAgICAgSE9TVEFQRF9MRVZFTF9ERUJVRywKIAkJICAgICAgICJhdXRoZW50aWNhdGlvbiBPSyAoc2hhcmVkIGtleSkiKTsKLSNpZmRlZiBJRUVFODAyMTFfUkVRVUlSRV9BVVRIX0FDSwotCS8qIFN0YXRpb24gd2lsbCBiZSBtYXJrZWQgYXV0aGVudGljYXRlZCBpZiBpdCBBQ0tzIHRoZQotCSAqIGF1dGhlbnRpY2F0aW9uIHJlcGx5LiAqLwotI2Vsc2UKIAlzdGEtPmZsYWdzIHw9IFdMQU5fU1RBX0FVVEg7CiAJd3BhX2F1dGhfc21fZXZlbnQoc3RhLT53cGFfc20sIFdQQV9BVVRIKTsKLSNlbmRpZgogCW9zX2ZyZWUoc3RhLT5jaGFsbGVuZ2UpOwogCXN0YS0+Y2hhbGxlbmdlID0gTlVMTDsKIApAQCAtMjg2LDcgKzI5MCw3IEBACiAJCSAgIE1BQzJTVFIoZHN0KSwgYXV0aF9hbGcsIGF1dGhfdHJhbnNhY3Rpb24sCiAJCSAgIHJlc3AsICh1bnNpZ25lZCBsb25nKSBpZXNfbGVuKTsKIAlpZiAoaG9zdGFwZF9kcnZfc2VuZF9tbG1lKGhhcGQsIHJlcGx5LCBybGVuLCAwKSA8IDApCi0JCXBlcnJvcigic2VuZF9hdXRoX3JlcGx5OiBzZW5kIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJzZW5kX2F1dGhfcmVwbHk6IHNlbmQiKTsKIAogCW9zX2ZyZWUoYnVmKTsKIH0KQEAgLTM5OSw3ICs0MDMsNyBAQAogCQlyZXR1cm4gLTE7CiAJaWYgKGhtYWNfc2hhMjU2KGhhcGQtPnNhZV90b2tlbl9rZXksIHNpemVvZihoYXBkLT5zYWVfdG9rZW5fa2V5KSwKIAkJCWFkZHIsIEVUSF9BTEVOLCBtYWMpIDwgMCB8fAotCSAgICBvc19tZW1jbXAodG9rZW4sIG1hYywgU0hBMjU2X01BQ19MRU4pICE9IDApCisJICAgIG9zX21lbWNtcF9jb25zdCh0b2tlbiwgbWFjLCBTSEEyNTZfTUFDX0xFTikgIT0gMCkKIAkJcmV0dXJuIC0xOwogCiAJcmV0dXJuIDA7CkBAIC00MTEsMTcgKzQxNSwxNyBAQAogewogCXN0cnVjdCB3cGFidWYgKmJ1ZjsKIAl1OCAqdG9rZW47Ci0Jc3RydWN0IG9zX3RpbWUgdDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKLQlvc19nZXRfdGltZSgmdCk7Ci0JaWYgKGhhcGQtPmxhc3Rfc2FlX3Rva2VuX2tleV91cGRhdGUgPT0gMCB8fAotCSAgICB0LnNlYyA+IGhhcGQtPmxhc3Rfc2FlX3Rva2VuX2tleV91cGRhdGUgKyA2MCkgeworCW9zX2dldF9yZWx0aW1lKCZub3cpOworCWlmICghb3NfcmVsdGltZV9pbml0aWFsaXplZCgmaGFwZC0+bGFzdF9zYWVfdG9rZW5fa2V5X3VwZGF0ZSkgfHwKKwkgICAgb3NfcmVsdGltZV9leHBpcmVkKCZub3csICZoYXBkLT5sYXN0X3NhZV90b2tlbl9rZXlfdXBkYXRlLCA2MCkpIHsKIAkJaWYgKHJhbmRvbV9nZXRfYnl0ZXMoaGFwZC0+c2FlX3Rva2VuX2tleSwKIAkJCQkgICAgIHNpemVvZihoYXBkLT5zYWVfdG9rZW5fa2V5KSkgPCAwKQogCQkJcmV0dXJuIE5VTEw7CiAJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlNBRTogVXBkYXRlZCB0b2tlbiBrZXkiLAogCQkJICAgIGhhcGQtPnNhZV90b2tlbl9rZXksIHNpemVvZihoYXBkLT5zYWVfdG9rZW5fa2V5KSk7Ci0JCWhhcGQtPmxhc3Rfc2FlX3Rva2VuX2tleV91cGRhdGUgPSB0LnNlYzsKKwkJaGFwZC0+bGFzdF9zYWVfdG9rZW5fa2V5X3VwZGF0ZSA9IG5vdzsKIAl9CiAKIAlidWYgPSB3cGFidWZfYWxsb2MoU0hBMjU2X01BQ19MRU4pOwpAQCAtNDkyLDYgKzQ5Niw3IEBACiAJCQkJICAgICAgIEhPU1RBUERfTEVWRUxfREVCVUcsCiAJCQkJICAgICAgICJTQUUgY29uZmlybSBiZWZvcmUgY29tbWl0Iik7CiAJCQlyZXNwID0gV0xBTl9TVEFUVVNfVU5LTk9XTl9BVVRIX1RSQU5TQUNUSU9OOworCQkJZ290byBmYWlsZWQ7CiAJCX0KIAkJaG9zdGFwZF9sb2dnZXIoaGFwZCwgc3RhLT5hZGRyLCBIT1NUQVBEX01PRFVMRV9JRUVFODAyMTEsCiAJCQkgICAgICAgSE9TVEFQRF9MRVZFTF9ERUJVRywKQEAgLTUyMyw2ICs1MjgsNyBAQAogCQlyZXNwID0gV0xBTl9TVEFUVVNfVU5LTk9XTl9BVVRIX1RSQU5TQUNUSU9OOwogCX0KIAorZmFpbGVkOgogCXN0YS0+YXV0aF9hbGcgPSBXTEFOX0FVVEhfU0FFOwogCiAJc2VuZF9hdXRoX3JlcGx5KGhhcGQsIG1nbXQtPnNhLCBtZ210LT5ic3NpZCwgV0xBTl9BVVRIX1NBRSwKQEAgLTU1MiwxMyArNTU4LDEzIEBACiAJY2hhciAqcmFkaXVzX2N1aSA9IE5VTEw7CiAKIAlpZiAobGVuIDwgSUVFRTgwMjExX0hEUkxFTiArIHNpemVvZihtZ210LT51LmF1dGgpKSB7Ci0JCXByaW50ZigiaGFuZGxlX2F1dGggLSB0b28gc2hvcnQgcGF5bG9hZCAobGVuPSVsdSlcbiIsCi0JCSAgICAgICAodW5zaWduZWQgbG9uZykgbGVuKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImhhbmRsZV9hdXRoIC0gdG9vIHNob3J0IHBheWxvYWQgKGxlbj0lbHUpIiwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBsZW4pOwogCQlyZXR1cm47CiAJfQogCiAjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwotCWlmIChoYXBkLT5pY29uZi0+aWdub3JlX2F1dGhfcHJvYmFiaWxpdHkgPiAwLjBkICYmCisJaWYgKGhhcGQtPmljb25mLT5pZ25vcmVfYXV0aF9wcm9iYWJpbGl0eSA+IDAuMCAmJgogCSAgICBkcmFuZDQ4KCkgPCBoYXBkLT5pY29uZi0+aWdub3JlX2F1dGhfcHJvYmFiaWxpdHkpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywKIAkJCSAgICJURVNUSU5HOiBpZ25vcmluZyBhdXRoIGZyYW1lIGZyb20gIiBNQUNTVFIsCkBAIC02MDEsMjMgKzYwNywyMyBAQAogI2VuZGlmIC8qIENPTkZJR19TQUUgKi8KIAkgICAgICAoKGhhcGQtPmNvbmYtPmF1dGhfYWxncyAmIFdQQV9BVVRIX0FMR19TSEFSRUQpICYmCiAJICAgICAgIGF1dGhfYWxnID09IFdMQU5fQVVUSF9TSEFSRURfS0VZKSkpIHsKLQkJcHJpbnRmKCJVbnN1cHBvcnRlZCBhdXRoZW50aWNhdGlvbiBhbGdvcml0aG0gKCVkKVxuIiwKLQkJICAgICAgIGF1dGhfYWxnKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVuc3VwcG9ydGVkIGF1dGhlbnRpY2F0aW9uIGFsZ29yaXRobSAoJWQpIiwKKwkJCSAgIGF1dGhfYWxnKTsKIAkJcmVzcCA9IFdMQU5fU1RBVFVTX05PVF9TVVBQT1JURURfQVVUSF9BTEc7CiAJCWdvdG8gZmFpbDsKIAl9CiAKIAlpZiAoIShhdXRoX3RyYW5zYWN0aW9uID09IDEgfHwgYXV0aF9hbGcgPT0gV0xBTl9BVVRIX1NBRSB8fAogCSAgICAgIChhdXRoX2FsZyA9PSBXTEFOX0FVVEhfU0hBUkVEX0tFWSAmJiBhdXRoX3RyYW5zYWN0aW9uID09IDMpKSkgewotCQlwcmludGYoIlVua25vd24gYXV0aGVudGljYXRpb24gdHJhbnNhY3Rpb24gbnVtYmVyICglZClcbiIsCi0JCSAgICAgICBhdXRoX3RyYW5zYWN0aW9uKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVua25vd24gYXV0aGVudGljYXRpb24gdHJhbnNhY3Rpb24gbnVtYmVyICglZCkiLAorCQkJICAgYXV0aF90cmFuc2FjdGlvbik7CiAJCXJlc3AgPSBXTEFOX1NUQVRVU19VTktOT1dOX0FVVEhfVFJBTlNBQ1RJT047CiAJCWdvdG8gZmFpbDsKIAl9CiAKIAlpZiAob3NfbWVtY21wKG1nbXQtPnNhLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pID09IDApIHsKLQkJcHJpbnRmKCJTdGF0aW9uICIgTUFDU1RSICIgbm90IGFsbG93ZWQgdG8gYXV0aGVudGljYXRlLlxuIiwKLQkJICAgICAgIE1BQzJTVFIobWdtdC0+c2EpKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlN0YXRpb24gIiBNQUNTVFIgIiBub3QgYWxsb3dlZCB0byBhdXRoZW50aWNhdGUiLAorCQkJICAgTUFDMlNUUihtZ210LT5zYSkpOwogCQlyZXNwID0gV0xBTl9TVEFUVVNfVU5TUEVDSUZJRURfRkFJTFVSRTsKIAkJZ290byBmYWlsOwogCX0KQEAgLTYyOCw4ICs2MzQsOCBAQAogCQkJCSAgICAgICZwc2ssICZpZGVudGl0eSwgJnJhZGl1c19jdWkpOwogCiAJaWYgKHJlcyA9PSBIT1NUQVBEX0FDTF9SRUpFQ1QpIHsKLQkJcHJpbnRmKCJTdGF0aW9uICIgTUFDU1RSICIgbm90IGFsbG93ZWQgdG8gYXV0aGVudGljYXRlLlxuIiwKLQkJICAgICAgIE1BQzJTVFIobWdtdC0+c2EpKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlN0YXRpb24gIiBNQUNTVFIgIiBub3QgYWxsb3dlZCB0byBhdXRoZW50aWNhdGUiLAorCQkJICAgTUFDMlNUUihtZ210LT5zYSkpOwogCQlyZXNwID0gV0xBTl9TVEFUVVNfVU5TUEVDSUZJRURfRkFJTFVSRTsKIAkJZ290byBmYWlsOwogCX0KQEAgLTY5MSwxNSArNjk3LDEwIEBACiAJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIHN0YS0+YWRkciwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAogCQkJICAgICAgIEhPU1RBUERfTEVWRUxfREVCVUcsCiAJCQkgICAgICAgImF1dGhlbnRpY2F0aW9uIE9LIChvcGVuIHN5c3RlbSkiKTsKLSNpZmRlZiBJRUVFODAyMTFfUkVRVUlSRV9BVVRIX0FDSwotCQkvKiBTdGF0aW9uIHdpbGwgYmUgbWFya2VkIGF1dGhlbnRpY2F0ZWQgaWYgaXQgQUNLcyB0aGUKLQkJICogYXV0aGVudGljYXRpb24gcmVwbHkuICovCi0jZWxzZQogCQlzdGEtPmZsYWdzIHw9IFdMQU5fU1RBX0FVVEg7CiAJCXdwYV9hdXRoX3NtX2V2ZW50KHN0YS0+d3BhX3NtLCBXUEFfQVVUSCk7CiAJCXN0YS0+YXV0aF9hbGcgPSBXTEFOX0FVVEhfT1BFTjsKIAkJbWxtZV9hdXRoZW50aWNhdGVfaW5kaWNhdGlvbihoYXBkLCBzdGEpOwotI2VuZGlmCiAJCWJyZWFrOwogCWNhc2UgV0xBTl9BVVRIX1NIQVJFRF9LRVk6CiAJCXJlc3AgPSBhdXRoX3NoYXJlZF9rZXkoaGFwZCwgc3RhLCBhdXRoX3RyYW5zYWN0aW9uLCBjaGFsbGVuZ2UsCkBAIC03OTIsMTIgKzc5MywxMCBAQAogCiAJaWYgKHNzaWRfaWVfbGVuICE9IGhhcGQtPmNvbmYtPnNzaWQuc3NpZF9sZW4gfHwKIAkgICAgb3NfbWVtY21wKHNzaWRfaWUsIGhhcGQtPmNvbmYtPnNzaWQuc3NpZCwgc3NpZF9pZV9sZW4pICE9IDApIHsKLQkJY2hhciBzc2lkX3R4dFszM107Ci0JCWllZWU4MDJfMTFfcHJpbnRfc3NpZChzc2lkX3R4dCwgc3NpZF9pZSwgc3NpZF9pZV9sZW4pOwogCQlob3N0YXBkX2xvZ2dlcihoYXBkLCBzdGEtPmFkZHIsIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKIAkJCSAgICAgICBIT1NUQVBEX0xFVkVMX0lORk8sCiAJCQkgICAgICAgIlN0YXRpb24gdHJpZWQgdG8gYXNzb2NpYXRlIHdpdGggdW5rbm93biBTU0lEICIKLQkJCSAgICAgICAiJyVzJyIsIHNzaWRfdHh0KTsKKwkJCSAgICAgICAiJyVzJyIsIHdwYV9zc2lkX3R4dChzc2lkX2llLCBzc2lkX2llX2xlbikpOwogCQlyZXR1cm4gV0xBTl9TVEFUVVNfVU5TUEVDSUZJRURfRkFJTFVSRTsKIAl9CiAKQEAgLTg1OSw2ICs4NTgsMjEgQEAKIH0KIAogCitzdGF0aWMgdTE2IGNoZWNrX2V4dF9jYXBhYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKKwkJCSAgIGNvbnN0IHU4ICpleHRfY2FwYWJfaWUsIHNpemVfdCBleHRfY2FwYWJfaWVfbGVuKQoreworI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKwkvKiBjaGVjayBmb3IgUW9TIE1hcCBzdXBwb3J0ICovCisJaWYgKGV4dF9jYXBhYl9pZV9sZW4gPj0gNSkgeworCQlpZiAoZXh0X2NhcGFiX2llWzRdICYgMHgwMSkKKwkJCXN0YS0+cW9zX21hcF9lbmFibGVkID0gMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLworCisJcmV0dXJuIFdMQU5fU1RBVFVTX1NVQ0NFU1M7Cit9CisKKwogc3RhdGljIHUxNiBjaGVja19hc3NvY19pZXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEsCiAJCQkgICBjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbiwgaW50IHJlYXNzb2MpCiB7CkBAIC04ODEsNiArODk1LDkgQEAKIAlyZXNwID0gY2hlY2tfd21tKGhhcGQsIHN0YSwgZWxlbXMud21tLCBlbGVtcy53bW1fbGVuKTsKIAlpZiAocmVzcCAhPSBXTEFOX1NUQVRVU19TVUNDRVNTKQogCQlyZXR1cm4gcmVzcDsKKwlyZXNwID0gY2hlY2tfZXh0X2NhcGFiKGhhcGQsIHN0YSwgZWxlbXMuZXh0X2NhcGFiLCBlbGVtcy5leHRfY2FwYWJfbGVuKTsKKwlpZiAocmVzcCAhPSBXTEFOX1NUQVRVU19TVUNDRVNTKQorCQlyZXR1cm4gcmVzcDsKIAlyZXNwID0gY29weV9zdXBwX3JhdGVzKGhhcGQsIHN0YSwgJmVsZW1zKTsKIAlpZiAocmVzcCAhPSBXTEFOX1NUQVRVU19TVUNDRVNTKQogCQlyZXR1cm4gcmVzcDsKQEAgLTkwMywxMiArOTIwLDE3IEBACiAJCQkJICBlbGVtcy52aHRfY2FwYWJpbGl0aWVzX2xlbik7CiAJaWYgKHJlc3AgIT0gV0xBTl9TVEFUVVNfU1VDQ0VTUykKIAkJcmV0dXJuIHJlc3A7CisKKwlyZXNwID0gc2V0X3N0YV92aHRfb3Btb2RlKGhhcGQsIHN0YSwgZWxlbXMudmh0X29wbW9kZV9ub3RpZik7CisJaWYgKHJlc3AgIT0gV0xBTl9TVEFUVVNfU1VDQ0VTUykKKwkJcmV0dXJuIHJlc3A7CisKIAlpZiAoaGFwZC0+aWNvbmYtPmllZWU4MDIxMWFjICYmIGhhcGQtPmljb25mLT5yZXF1aXJlX3ZodCAmJgogCSAgICAhKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9WSFQpKSB7CiAJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIHN0YS0+YWRkciwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAogCQkJICAgICAgIEhPU1RBUERfTEVWRUxfSU5GTywgIlN0YXRpb24gZG9lcyBub3Qgc3VwcG9ydCAiCiAJCQkgICAgICAgIm1hbmRhdG9yeSBWSFQgUEhZIC0gcmVqZWN0IGFzc29jaWF0aW9uIik7Ci0JCXJldHVybiBXTEFOX1NUQVRVU19VTlNQRUNJRklFRF9GQUlMVVJFOworCQlyZXR1cm4gV0xBTl9TVEFUVVNfQVNTT0NfREVOSUVEX05PX1ZIVDsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMUFDICovCiAKQEAgLTEwNTAsNyArMTA3Miw5IEBACiAKICNpZmRlZiBDT05GSUdfU0FFCiAJCWlmICh3cGFfYXV0aF91c2VzX3NhZShzdGEtPndwYV9zbSkgJiYKLQkJICAgIHN0YS0+YXV0aF9hbGcgIT0gV0xBTl9BVVRIX1NBRSkgeworCQkgICAgc3RhLT5hdXRoX2FsZyAhPSBXTEFOX0FVVEhfU0FFICYmCisJCSAgICAhKHN0YS0+YXV0aF9hbGcgPT0gV0xBTl9BVVRIX0ZUICYmCisJCSAgICAgIHdwYV9hdXRoX3VzZXNfZnRfc2FlKHN0YS0+d3BhX3NtKSkpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU0FFOiAiIE1BQ1NUUiAiIHRyaWVkIHRvIHVzZSAiCiAJCQkJICAgIlNBRSBBS00gYWZ0ZXIgbm9uLVNBRSBhdXRoX2FsZyAldSIsCiAJCQkJICAgTUFDMlNUUihzdGEtPmFkZHIpLCBzdGEtPmF1dGhfYWxnKTsKQEAgLTEwNjksNiArMTA5MywyOSBAQAogCQkJcmV0dXJuIFdMQU5fU1RBVFVTX0NJUEhFUl9SRUpFQ1RFRF9QRVJfUE9MSUNZOwogCQl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMU4gKi8KKyNpZmRlZiBDT05GSUdfSFMyMAorCX0gZWxzZSBpZiAoaGFwZC0+Y29uZi0+b3NlbikgeworCQlpZiAoZWxlbXMub3NlbiA9PSBOVUxMKSB7CisJCQlob3N0YXBkX2xvZ2dlcigKKwkJCQloYXBkLCBzdGEtPmFkZHIsIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKKwkJCQlIT1NUQVBEX0xFVkVMX0lORk8sCisJCQkJIk5vIEhTIDIuMCBPU0VOIGVsZW1lbnQgaW4gYXNzb2NpYXRpb24gcmVxdWVzdCIpOworCQkJcmV0dXJuIFdMQU5fU1RBVFVTX0lOVkFMSURfSUU7CisJCX0KKworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogT1NFTiBhc3NvY2lhdGlvbiIpOworCQlpZiAoc3RhLT53cGFfc20gPT0gTlVMTCkKKwkJCXN0YS0+d3BhX3NtID0gd3BhX2F1dGhfc3RhX2luaXQoaGFwZC0+d3BhX2F1dGgsCisJCQkJCQkJc3RhLT5hZGRyLCBOVUxMKTsKKwkJaWYgKHN0YS0+d3BhX3NtID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSBXUEEgIgorCQkJCSAgICJzdGF0ZSBtYWNoaW5lIik7CisJCQlyZXR1cm4gV0xBTl9TVEFUVVNfVU5TUEVDSUZJRURfRkFJTFVSRTsKKwkJfQorCQlpZiAod3BhX3ZhbGlkYXRlX29zZW4oaGFwZC0+d3BhX2F1dGgsIHN0YS0+d3BhX3NtLAorCQkJCSAgICAgIGVsZW1zLm9zZW4gLSAyLCBlbGVtcy5vc2VuX2xlbiArIDIpIDwgMCkKKwkJCXJldHVybiBXTEFOX1NUQVRVU19JTlZBTElEX0lFOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJfSBlbHNlCiAJCXdwYV9hdXRoX3N0YV9ub193cGEoc3RhLT53cGFfc20pOwogCkBAIC0xMTM1LDggKzExODIsNyBAQAogCXJlcGx5LT51LmFzc29jX3Jlc3AuY2FwYWJfaW5mbyA9CiAJCWhvc3RfdG9fbGUxNihob3N0YXBkX293bl9jYXBhYl9pbmZvKGhhcGQsIHN0YSwgMCkpOwogCXJlcGx5LT51LmFzc29jX3Jlc3Auc3RhdHVzX2NvZGUgPSBob3N0X3RvX2xlMTYoc3RhdHVzX2NvZGUpOwotCXJlcGx5LT51LmFzc29jX3Jlc3AuYWlkID0gaG9zdF90b19sZTE2KChzdGEgPyBzdGEtPmFpZCA6IDApCi0JCQkJCSAgICAgICB8IEJJVCgxNCkgfCBCSVQoMTUpKTsKKwlyZXBseS0+dS5hc3NvY19yZXNwLmFpZCA9IGhvc3RfdG9fbGUxNihzdGEtPmFpZCB8IEJJVCgxNCkgfCBCSVQoMTUpKTsKIAkvKiBTdXBwb3J0ZWQgcmF0ZXMgKi8KIAlwID0gaG9zdGFwZF9laWRfc3VwcF9yYXRlcyhoYXBkLCByZXBseS0+dS5hc3NvY19yZXNwLnZhcmlhYmxlKTsKIAkvKiBFeHRlbmRlZCBzdXBwb3J0ZWQgcmF0ZXMgKi8KQEAgLTExNjksNiArMTIxNSw4IEBACiAKIAlwID0gaG9zdGFwZF9laWRfZXh0X2NhcGFiKGhhcGQsIHApOwogCXAgPSBob3N0YXBkX2VpZF9ic3NfbWF4X2lkbGVfcGVyaW9kKGhhcGQsIHApOworCWlmIChzdGEtPnFvc19tYXBfZW5hYmxlZCkKKwkJcCA9IGhvc3RhcGRfZWlkX3Fvc19tYXBfc2V0KGhhcGQsIHApOwogCiAJaWYgKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9XTU0pCiAJCXAgPSBob3N0YXBkX2VpZF93bW0oaGFwZCwgcCk7CkBAIC0xMjM1LDE0ICsxMjgzLDE0IEBACiAKIAlpZiAobGVuIDwgSUVFRTgwMjExX0hEUkxFTiArIChyZWFzc29jID8gc2l6ZW9mKG1nbXQtPnUucmVhc3NvY19yZXEpIDoKIAkJCQkgICAgICBzaXplb2YobWdtdC0+dS5hc3NvY19yZXEpKSkgewotCQlwcmludGYoImhhbmRsZV9hc3NvYyhyZWFzc29jPSVkKSAtIHRvbyBzaG9ydCBwYXlsb2FkIChsZW49JWx1KSIKLQkJICAgICAgICJcbiIsIHJlYXNzb2MsICh1bnNpZ25lZCBsb25nKSBsZW4pOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaGFuZGxlX2Fzc29jKHJlYXNzb2M9JWQpIC0gdG9vIHNob3J0IHBheWxvYWQgKGxlbj0lbHUpIiwKKwkJCSAgIHJlYXNzb2MsICh1bnNpZ25lZCBsb25nKSBsZW4pOwogCQlyZXR1cm47CiAJfQogCiAjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwogCWlmIChyZWFzc29jKSB7Ci0JCWlmIChoYXBkLT5pY29uZi0+aWdub3JlX3JlYXNzb2NfcHJvYmFiaWxpdHkgPiAwLjBkICYmCisJCWlmIChoYXBkLT5pY29uZi0+aWdub3JlX3JlYXNzb2NfcHJvYmFiaWxpdHkgPiAwLjAgJiYKIAkJICAgIGRyYW5kNDgoKSA8IGhhcGQtPmljb25mLT5pZ25vcmVfcmVhc3NvY19wcm9iYWJpbGl0eSkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywKIAkJCQkgICAiVEVTVElORzogaWdub3JpbmcgcmVhc3NvYyByZXF1ZXN0IGZyb20gIgpAQCAtMTI1MCw3ICsxMjk4LDcgQEAKIAkJCXJldHVybjsKIAkJfQogCX0gZWxzZSB7Ci0JCWlmIChoYXBkLT5pY29uZi0+aWdub3JlX2Fzc29jX3Byb2JhYmlsaXR5ID4gMC4wZCAmJgorCQlpZiAoaGFwZC0+aWNvbmYtPmlnbm9yZV9hc3NvY19wcm9iYWJpbGl0eSA+IDAuMCAmJgogCQkgICAgZHJhbmQ0OCgpIDwgaGFwZC0+aWNvbmYtPmlnbm9yZV9hc3NvY19wcm9iYWJpbGl0eSkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywKIAkJCQkgICAiVEVTVElORzogaWdub3JpbmcgYXNzb2MgcmVxdWVzdCBmcm9tICIKQEAgLTEzOTYsMTcgKzE0NDQsNiBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCi0JaWYgKHJlYXNzb2MpIHsKLQkJb3NfbWVtY3B5KHN0YS0+cHJldmlvdXNfYXAsIG1nbXQtPnUucmVhc3NvY19yZXEuY3VycmVudF9hcCwKLQkJCSAgRVRIX0FMRU4pOwotCX0KLQotCWlmIChzdGEtPmxhc3RfYXNzb2NfcmVxKQotCQlvc19mcmVlKHN0YS0+bGFzdF9hc3NvY19yZXEpOwotCXN0YS0+bGFzdF9hc3NvY19yZXEgPSBvc19tYWxsb2MobGVuKTsKLQlpZiAoc3RhLT5sYXN0X2Fzc29jX3JlcSkKLQkJb3NfbWVtY3B5KHN0YS0+bGFzdF9hc3NvY19yZXEsIG1nbXQsIGxlbik7Ci0KIAkvKiBNYWtlIHN1cmUgdGhhdCB0aGUgcHJldmlvdXNseSByZWdpc3RlcmVkIGluYWN0aXZpdHkgdGltZXIgd2lsbCBub3QKIAkgKiByZW1vdmUgdGhlIFNUQSBpbW1lZGlhdGVseS4gKi8KIAlzdGEtPnRpbWVvdXRfbmV4dCA9IFNUQV9OVUxMRlVOQzsKQEAgLTE0MjIsOCArMTQ1OSw4IEBACiAJc3RydWN0IHN0YV9pbmZvICpzdGE7CiAKIAlpZiAobGVuIDwgSUVFRTgwMjExX0hEUkxFTiArIHNpemVvZihtZ210LT51LmRpc2Fzc29jKSkgewotCQlwcmludGYoImhhbmRsZV9kaXNhc3NvYyAtIHRvbyBzaG9ydCBwYXlsb2FkIChsZW49JWx1KVxuIiwKLQkJICAgICAgICh1bnNpZ25lZCBsb25nKSBsZW4pOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaGFuZGxlX2Rpc2Fzc29jIC0gdG9vIHNob3J0IHBheWxvYWQgKGxlbj0lbHUpIiwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBsZW4pOwogCQlyZXR1cm47CiAJfQogCkBAIC0xNDMzLDggKzE0NzAsOCBAQAogCiAJc3RhID0gYXBfZ2V0X3N0YShoYXBkLCBtZ210LT5zYSk7CiAJaWYgKHN0YSA9PSBOVUxMKSB7Ci0JCXByaW50ZigiU3RhdGlvbiAiIE1BQ1NUUiAiIHRyeWluZyB0byBkaXNhc3NvY2lhdGUsIGJ1dCBpdCAiCi0JCSAgICAgICAiaXMgbm90IGFzc29jaWF0ZWQuXG4iLCBNQUMyU1RSKG1nbXQtPnNhKSk7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJTdGF0aW9uICIgTUFDU1RSICIgdHJ5aW5nIHRvIGRpc2Fzc29jaWF0ZSwgYnV0IGl0IGlzIG5vdCBhc3NvY2lhdGVkIiwKKwkJCSAgIE1BQzJTVFIobWdtdC0+c2EpKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMTUwOCw4ICsxNTQ1LDggQEAKIAlzdHJ1Y3QgaWVlZTgwMl8xMV9lbGVtcyBlbGVtczsKIAogCWlmIChsZW4gPCBJRUVFODAyMTFfSERSTEVOICsgc2l6ZW9mKG1nbXQtPnUuYmVhY29uKSkgewotCQlwcmludGYoImhhbmRsZV9iZWFjb24gLSB0b28gc2hvcnQgcGF5bG9hZCAobGVuPSVsdSlcbiIsCi0JCSAgICAgICAodW5zaWduZWQgbG9uZykgbGVuKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImhhbmRsZV9iZWFjb24gLSB0b28gc2hvcnQgcGF5bG9hZCAobGVuPSVsdSkiLAorCQkJICAgKHVuc2lnbmVkIGxvbmcpIGxlbik7CiAJCXJldHVybjsKIAl9CiAKQEAgLTE1MjQsOSArMTU2MSw5IEBACiAKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwogCi1zdGF0aWMgdm9pZCBob3N0YXBkX3NhX3F1ZXJ5X2FjdGlvbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAotCQkJCSAgICBjb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQsCi0JCQkJICAgIHNpemVfdCBsZW4pCitzdGF0aWMgaW50IGhvc3RhcGRfc2FfcXVlcnlfYWN0aW9uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJICAgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LAorCQkJCSAgIHNpemVfdCBsZW4pCiB7CiAJY29uc3QgdTggKmVuZDsKIApAQCAtMTUzNSwxMiArMTU3MiwxMyBAQAogCWlmICgoKHU4ICopIG1nbXQpICsgbGVuIDwgZW5kKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSUVFRSA4MDIuMTE6IFRvbyBzaG9ydCBTQSBRdWVyeSBBY3Rpb24gIgogCQkJICAgImZyYW1lIChsZW49JWx1KSIsICh1bnNpZ25lZCBsb25nKSBsZW4pOwotCQlyZXR1cm47CisJCXJldHVybiAwOwogCX0KIAogCWllZWU4MDJfMTFfc2FfcXVlcnlfYWN0aW9uKGhhcGQsIG1nbXQtPnNhLAogCQkJCSAgIG1nbXQtPnUuYWN0aW9uLnUuc2FfcXVlcnlfcmVzcC5hY3Rpb24sCiAJCQkJICAgbWdtdC0+dS5hY3Rpb24udS5zYV9xdWVyeV9yZXNwLnRyYW5zX2lkKTsKKwlyZXR1cm4gMTsKIH0KIAogCkBAIC0xNTUyLDI5ICsxNTkwLDggQEAKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCiAKLSNpZmRlZiBDT05GSUdfV05NCi1zdGF0aWMgdm9pZCBob3N0YXBkX3dubV9hY3Rpb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEsCi0JCQkgICAgICAgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LAotCQkJICAgICAgIHNpemVfdCBsZW4pCi17Ci0Jc3RydWN0IHJ4X2FjdGlvbiBhY3Rpb247Ci0JaWYgKGxlbiA8IElFRUU4MDIxMV9IRFJMRU4gKyAyKQotCQlyZXR1cm47Ci0Jb3NfbWVtc2V0KCZhY3Rpb24sIDAsIHNpemVvZihhY3Rpb24pKTsKLQlhY3Rpb24uZGEgPSBtZ210LT5kYTsKLQlhY3Rpb24uc2EgPSBtZ210LT5zYTsKLQlhY3Rpb24uYnNzaWQgPSBtZ210LT5ic3NpZDsKLQlhY3Rpb24uY2F0ZWdvcnkgPSBtZ210LT51LmFjdGlvbi5jYXRlZ29yeTsKLQlhY3Rpb24uZGF0YSA9IChjb25zdCB1OCAqKSAmbWdtdC0+dS5hY3Rpb24udS53bm1fc2xlZXBfcmVxLmFjdGlvbjsKLQlhY3Rpb24ubGVuID0gbGVuIC0gSUVFRTgwMjExX0hEUkxFTiAtIDE7Ci0JYWN0aW9uLmZyZXEgPSBoYXBkLT5pZmFjZS0+ZnJlcTsKLQlpZWVlODAyXzExX3J4X3dubV9hY3Rpb25fYXAoaGFwZCwgJmFjdGlvbik7Ci19Ci0jZW5kaWYgLyogQ09ORklHX1dOTSAqLwotCi0KLXN0YXRpYyB2b2lkIGhhbmRsZV9hY3Rpb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKLQkJCSAgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LCBzaXplX3QgbGVuKQorc3RhdGljIGludCBoYW5kbGVfYWN0aW9uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LCBzaXplX3QgbGVuKQogewogCXN0cnVjdCBzdGFfaW5mbyAqc3RhOwogCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgbWdtdC0+c2EpOwpAQCAtMTU4NCw3ICsxNjAxLDcgQEAKIAkJCSAgICAgICBIT1NUQVBEX0xFVkVMX0RFQlVHLAogCQkJICAgICAgICJoYW5kbGVfYWN0aW9uIC0gdG9vIHNob3J0IHBheWxvYWQgKGxlbj0lbHUpIiwKIAkJCSAgICAgICAodW5zaWduZWQgbG9uZykgbGVuKTsKLQkJcmV0dXJuOworCQlyZXR1cm4gMDsKIAl9CiAKIAlpZiAobWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgIT0gV0xBTl9BQ1RJT05fUFVCTElDICYmCkBAIC0xNTkyLDQzICsxNjA5LDUzIEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSUVFRSA4MDIuMTE6IElnbm9yZWQgQWN0aW9uICIKIAkJCSAgICJmcmFtZSAoY2F0ZWdvcnk9JXUpIGZyb20gdW5hc3NvY2lhdGVkIFNUQSAiIE1BQ1NUUiwKIAkJCSAgIE1BQzJTVFIobWdtdC0+c2EpLCBtZ210LT51LmFjdGlvbi5jYXRlZ29yeSk7Ci0JCXJldHVybjsKKwkJcmV0dXJuIDA7CiAJfQogCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKIAlpZiAoc3RhICYmIChzdGEtPmZsYWdzICYgV0xBTl9TVEFfTUZQKSAmJgotCSAgICAhKG1nbXQtPmZyYW1lX2NvbnRyb2wgJiBob3N0X3RvX2xlMTYoV0xBTl9GQ19JU1dFUCkgJiYKLQkgICAgICByb2J1c3RfYWN0aW9uX2ZyYW1lKG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5KSkpIHsKKwkgICAgIShtZ210LT5mcmFtZV9jb250cm9sICYgaG9zdF90b19sZTE2KFdMQU5fRkNfSVNXRVApKSAmJgorCSAgICByb2J1c3RfYWN0aW9uX2ZyYW1lKG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5KSkgewogCQlob3N0YXBkX2xvZ2dlcihoYXBkLCBtZ210LT5zYSwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAogCQkJICAgICAgIEhPU1RBUERfTEVWRUxfREVCVUcsCiAJCQkgICAgICAgIkRyb3BwZWQgdW5wcm90ZWN0ZWQgUm9idXN0IEFjdGlvbiBmcmFtZSBmcm9tICIKIAkJCSAgICAgICAiYW4gTUZQIFNUQSIpOwotCQlyZXR1cm47CisJCXJldHVybiAwOwogCX0KICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCiAJc3dpdGNoIChtZ210LT51LmFjdGlvbi5jYXRlZ29yeSkgewogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAJY2FzZSBXTEFOX0FDVElPTl9GVDoKLQkJaWYgKHdwYV9mdF9hY3Rpb25fcngoc3RhLT53cGFfc20sICh1OCAqKSAmbWdtdC0+dS5hY3Rpb24sCisJCWlmICghc3RhIHx8CisJCSAgICB3cGFfZnRfYWN0aW9uX3J4KHN0YS0+d3BhX3NtLCAodTggKikgJm1nbXQtPnUuYWN0aW9uLAogCQkJCSAgICAgbGVuIC0gSUVFRTgwMjExX0hEUkxFTikpCiAJCQlicmVhazsKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiAqLwogCWNhc2UgV0xBTl9BQ1RJT05fV01NOgogCQlob3N0YXBkX3dtbV9hY3Rpb24oaGFwZCwgbWdtdCwgbGVuKTsKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwogCWNhc2UgV0xBTl9BQ1RJT05fU0FfUVVFUlk6Ci0JCWhvc3RhcGRfc2FfcXVlcnlfYWN0aW9uKGhhcGQsIG1nbXQsIGxlbik7Ci0JCXJldHVybjsKKwkJcmV0dXJuIGhvc3RhcGRfc2FfcXVlcnlfYWN0aW9uKGhhcGQsIG1nbXQsIGxlbik7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KICNpZmRlZiBDT05GSUdfV05NCiAJY2FzZSBXTEFOX0FDVElPTl9XTk06Ci0JCWhvc3RhcGRfd25tX2FjdGlvbihoYXBkLCBzdGEsIG1nbXQsIGxlbik7Ci0JCXJldHVybjsKKwkJaWVlZTgwMl8xMV9yeF93bm1fYWN0aW9uX2FwKGhhcGQsIG1nbXQsIGxlbik7CisJCXJldHVybiAxOwogI2VuZGlmIC8qIENPTkZJR19XTk0gKi8KIAljYXNlIFdMQU5fQUNUSU9OX1BVQkxJQzoKKwljYXNlIFdMQU5fQUNUSU9OX1BST1RFQ1RFRF9EVUFMOgorI2lmZGVmIENPTkZJR19JRUVFODAyMTFOCisJCWlmIChtZ210LT51LmFjdGlvbi51LnB1YmxpY19hY3Rpb24uYWN0aW9uID09CisJCSAgICBXTEFOX1BBXzIwXzQwX0JTU19DT0VYKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCQkgICAiSFQyMC80MCBjb2V4IG1nbXQgZnJhbWUgcmVjZWl2ZWQgZnJvbSBTVEEgIgorCQkJCSAgIE1BQ1NUUiwgTUFDMlNUUihtZ210LT5zYSkpOworCQkJaG9zdGFwZF8yMDQwX2NvZXhfYWN0aW9uKGhhcGQsIG1nbXQsIGxlbik7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExTiAqLwogCQlpZiAoaGFwZC0+cHVibGljX2FjdGlvbl9jYikgewogCQkJaGFwZC0+cHVibGljX2FjdGlvbl9jYihoYXBkLT5wdWJsaWNfYWN0aW9uX2NiX2N0eCwKIAkJCQkJICAgICAgICh1OCAqKSBtZ210LCBsZW4sCkBAIC0xNjQwLDE0ICsxNjY3LDE0IEBACiAJCQkJCQloYXBkLT5pZmFjZS0+ZnJlcSk7CiAJCX0KIAkJaWYgKGhhcGQtPnB1YmxpY19hY3Rpb25fY2IgfHwgaGFwZC0+cHVibGljX2FjdGlvbl9jYjIpCi0JCQlyZXR1cm47CisJCQlyZXR1cm4gMTsKIAkJYnJlYWs7CiAJY2FzZSBXTEFOX0FDVElPTl9WRU5ET1JfU1BFQ0lGSUM6CiAJCWlmIChoYXBkLT52ZW5kb3JfYWN0aW9uX2NiKSB7CiAJCQlpZiAoaGFwZC0+dmVuZG9yX2FjdGlvbl9jYihoYXBkLT52ZW5kb3JfYWN0aW9uX2NiX2N0eCwKIAkJCQkJCSAgICh1OCAqKSBtZ210LCBsZW4sCiAJCQkJCQkgICBoYXBkLT5pZmFjZS0+ZnJlcSkgPT0gMCkKLQkJCQlyZXR1cm47CisJCQkJcmV0dXJuIDE7CiAJCX0KIAkJYnJlYWs7CiAJfQpAQCAtMTY3MCw3ICsxNjk3LDcgQEAKIAkJCSAgICJmcmFtZSBiYWNrIHRvIHNlbmRlciIpOwogCQlyZXNwID0gb3NfbWFsbG9jKGxlbik7CiAJCWlmIChyZXNwID09IE5VTEwpCi0JCQlyZXR1cm47CisJCQlyZXR1cm4gMDsKIAkJb3NfbWVtY3B5KHJlc3AsIG1nbXQsIGxlbik7CiAJCW9zX21lbWNweShyZXNwLT5kYSwgcmVzcC0+c2EsIEVUSF9BTEVOKTsKIAkJb3NfbWVtY3B5KHJlc3AtPnNhLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOwpAQCAtMTY4Myw2ICsxNzEwLDggQEAKIAkJfQogCQlvc19mcmVlKHJlc3ApOwogCX0KKworCXJldHVybiAxOwogfQogCiAKQEAgLTE2OTksMTUgKzE3MjgsMTYgQEAKICAqIGFkZGl0aW9uLCBpdCBjYW4gYmUgY2FsbGVkIHRvIHJlLWluc2VydGVkIHBlbmRpbmcgZnJhbWVzIChlLmcuLCB3aGVuIHVzaW5nCiAgKiBleHRlcm5hbCBSQURJVVMgc2VydmVyIGFzIGFuIE1BQyBBQ0wpLgogICovCi12b2lkIGllZWU4MDJfMTFfbWdtdChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuLAotCQkgICAgIHN0cnVjdCBob3N0YXBkX2ZyYW1lX2luZm8gKmZpKQoraW50IGllZWU4MDJfMTFfbWdtdChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuLAorCQkgICAgc3RydWN0IGhvc3RhcGRfZnJhbWVfaW5mbyAqZmkpCiB7CiAJc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210OwogCWludCBicm9hZGNhc3Q7CiAJdTE2IGZjLCBzdHlwZTsKKwlpbnQgcmV0ID0gMDsKIAogCWlmIChsZW4gPCAyNCkKLQkJcmV0dXJuOworCQlyZXR1cm4gMDsKIAogCW1nbXQgPSAoc3RydWN0IGllZWU4MDIxMV9tZ210ICopIGJ1ZjsKIAlmYyA9IGxlX3RvX2hvc3QxNihtZ210LT5mcmFtZV9jb250cm9sKTsKQEAgLTE3MTUsNyArMTc0NSw3IEBACiAKIAlpZiAoc3R5cGUgPT0gV0xBTl9GQ19TVFlQRV9CRUFDT04pIHsKIAkJaGFuZGxlX2JlYWNvbihoYXBkLCBtZ210LCBsZW4sIGZpKTsKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKIAl9CiAKIAlicm9hZGNhc3QgPSBtZ210LT5ic3NpZFswXSA9PSAweGZmICYmIG1nbXQtPmJzc2lkWzFdID09IDB4ZmYgJiYKQEAgLTE3MjksMTUgKzE3NTksMTUgQEAKIAkgICAgICBzdHlwZSA9PSBXTEFOX0ZDX1NUWVBFX0FDVElPTikgJiYKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJICAgIG9zX21lbWNtcChtZ210LT5ic3NpZCwgaGFwZC0+b3duX2FkZHIsIEVUSF9BTEVOKSAhPSAwKSB7Ci0JCXByaW50ZigiTUdNVDogQlNTSUQ9IiBNQUNTVFIgIiBub3Qgb3VyIGFkZHJlc3NcbiIsCi0JCSAgICAgICBNQUMyU1RSKG1nbXQtPmJzc2lkKSk7Ci0JCXJldHVybjsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk1HTVQ6IEJTU0lEPSIgTUFDU1RSICIgbm90IG91ciBhZGRyZXNzIiwKKwkJCSAgIE1BQzJTVFIobWdtdC0+YnNzaWQpKTsKKwkJcmV0dXJuIDA7CiAJfQogCiAKIAlpZiAoc3R5cGUgPT0gV0xBTl9GQ19TVFlQRV9QUk9CRV9SRVEpIHsKIAkJaGFuZGxlX3Byb2JlX3JlcShoYXBkLCBtZ210LCBsZW4sIGZpLT5zc2lfc2lnbmFsKTsKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKIAl9CiAKIAlpZiAob3NfbWVtY21wKG1nbXQtPmRhLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pICE9IDApIHsKQEAgLTE3NDUsMzMgKzE3NzUsMzggQEAKIAkJCSAgICAgICBIT1NUQVBEX0xFVkVMX0RFQlVHLAogCQkJICAgICAgICJNR01UOiBEQT0iIE1BQ1NUUiAiIG5vdCBvdXIgYWRkcmVzcyIsCiAJCQkgICAgICAgTUFDMlNUUihtZ210LT5kYSkpOwotCQlyZXR1cm47CisJCXJldHVybiAwOwogCX0KIAogCXN3aXRjaCAoc3R5cGUpIHsKIAljYXNlIFdMQU5fRkNfU1RZUEVfQVVUSDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJtZ210OjphdXRoIik7CiAJCWhhbmRsZV9hdXRoKGhhcGQsIG1nbXQsIGxlbik7CisJCXJldCA9IDE7CiAJCWJyZWFrOwogCWNhc2UgV0xBTl9GQ19TVFlQRV9BU1NPQ19SRVE6CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibWdtdDo6YXNzb2NfcmVxIik7CiAJCWhhbmRsZV9hc3NvYyhoYXBkLCBtZ210LCBsZW4sIDApOworCQlyZXQgPSAxOwogCQlicmVhazsKIAljYXNlIFdMQU5fRkNfU1RZUEVfUkVBU1NPQ19SRVE6CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibWdtdDo6cmVhc3NvY19yZXEiKTsKIAkJaGFuZGxlX2Fzc29jKGhhcGQsIG1nbXQsIGxlbiwgMSk7CisJCXJldCA9IDE7CiAJCWJyZWFrOwogCWNhc2UgV0xBTl9GQ19TVFlQRV9ESVNBU1NPQzoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJtZ210OjpkaXNhc3NvYyIpOwogCQloYW5kbGVfZGlzYXNzb2MoaGFwZCwgbWdtdCwgbGVuKTsKKwkJcmV0ID0gMTsKIAkJYnJlYWs7CiAJY2FzZSBXTEFOX0ZDX1NUWVBFX0RFQVVUSDoKIAkJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJtZ210OjpkZWF1dGgiKTsKIAkJaGFuZGxlX2RlYXV0aChoYXBkLCBtZ210LCBsZW4pOworCQlyZXQgPSAxOwogCQlicmVhazsKIAljYXNlIFdMQU5fRkNfU1RZUEVfQUNUSU9OOgogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm1nbXQ6OmFjdGlvbiIpOwotCQloYW5kbGVfYWN0aW9uKGhhcGQsIG1nbXQsIGxlbik7CisJCXJldCA9IGhhbmRsZV9hY3Rpb24oaGFwZCwgbWdtdCwgbGVuKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJaG9zdGFwZF9sb2dnZXIoaGFwZCwgbWdtdC0+c2EsIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKQEAgLTE3NzksNiArMTgxNCw4IEBACiAJCQkgICAgICAgInVua25vd24gbWdtdCBmcmFtZSBzdWJ0eXBlICVkIiwgc3R5cGUpOwogCQlicmVhazsKIAl9CisKKwlyZXR1cm4gcmV0OwogfQogCiAKQEAgLTE3OTcsOCArMTgzNCw4IEBACiAJfQogCiAJaWYgKGxlbiA8IElFRUU4MDIxMV9IRFJMRU4gKyBzaXplb2YobWdtdC0+dS5hdXRoKSkgewotCQlwcmludGYoImhhbmRsZV9hdXRoX2NiIC0gdG9vIHNob3J0IHBheWxvYWQgKGxlbj0lbHUpXG4iLAotCQkgICAgICAgKHVuc2lnbmVkIGxvbmcpIGxlbik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJoYW5kbGVfYXV0aF9jYiAtIHRvbyBzaG9ydCBwYXlsb2FkIChsZW49JWx1KSIsCisJCQkgICAodW5zaWduZWQgbG9uZykgbGVuKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMTgwOCw4ICsxODQ1LDggQEAKIAogCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgbWdtdC0+ZGEpOwogCWlmICghc3RhKSB7Ci0JCXByaW50ZigiaGFuZGxlX2F1dGhfY2I6IFNUQSAiIE1BQ1NUUiAiIG5vdCBmb3VuZFxuIiwKLQkJICAgICAgIE1BQzJTVFIobWdtdC0+ZGEpKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImhhbmRsZV9hdXRoX2NiOiBTVEEgIiBNQUNTVFIgIiBub3QgZm91bmQiLAorCQkJICAgTUFDMlNUUihtZ210LT5kYSkpOwogCQlyZXR1cm47CiAJfQogCkBAIC0xODU5LDE1ICsxODk2LDE1IEBACiAKIAlpZiAobGVuIDwgSUVFRTgwMjExX0hEUkxFTiArIChyZWFzc29jID8gc2l6ZW9mKG1nbXQtPnUucmVhc3NvY19yZXNwKSA6CiAJCQkJICAgICAgc2l6ZW9mKG1nbXQtPnUuYXNzb2NfcmVzcCkpKSB7Ci0JCXByaW50ZigiaGFuZGxlX2Fzc29jX2NiKHJlYXNzb2M9JWQpIC0gdG9vIHNob3J0IHBheWxvYWQgIgotCQkgICAgICAgIihsZW49JWx1KVxuIiwgcmVhc3NvYywgKHVuc2lnbmVkIGxvbmcpIGxlbik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJoYW5kbGVfYXNzb2NfY2IocmVhc3NvYz0lZCkgLSB0b28gc2hvcnQgcGF5bG9hZCAobGVuPSVsdSkiLAorCQkJICAgcmVhc3NvYywgKHVuc2lnbmVkIGxvbmcpIGxlbik7CiAJCXJldHVybjsKIAl9CiAKIAlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIG1nbXQtPmRhKTsKIAlpZiAoIXN0YSkgewotCQlwcmludGYoImhhbmRsZV9hc3NvY19jYjogU1RBICIgTUFDU1RSICIgbm90IGZvdW5kXG4iLAotCQkgICAgICAgTUFDMlNUUihtZ210LT5kYSkpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaGFuZGxlX2Fzc29jX2NiOiBTVEEgIiBNQUNTVFIgIiBub3QgZm91bmQiLAorCQkJICAgTUFDMlNUUihtZ210LT5kYSkpOwogCQlyZXR1cm47CiAJfQogCkBAIC0xODg1LDcgKzE5MjIsNyBAQAogCQlzdGF0dXMgPSBsZV90b19ob3N0MTYobWdtdC0+dS5hc3NvY19yZXNwLnN0YXR1c19jb2RlKTsKIAogCWlmIChzdGF0dXMgIT0gV0xBTl9TVEFUVVNfU1VDQ0VTUykKLQkJZ290byBmYWlsOworCQlyZXR1cm47CiAKIAkvKiBTdG9wIHByZXZpb3VzIGFjY291bnRpbmcgc2Vzc2lvbiwgaWYgb25lIGlzIHN0YXJ0ZWQsIGFuZCBhbGxvY2F0ZQogCSAqIG5ldyBzZXNzaW9uIGlkIGZvciB0aGUgbmV3IHNlc3Npb24uICovCkBAIC0xODk5LDcgKzE5MzYsOCBAQAogCWlmIChzdGEtPmZsYWdzICYgV0xBTl9TVEFfQVNTT0MpCiAJCW5ld19hc3NvYyA9IDA7CiAJc3RhLT5mbGFncyB8PSBXTEFOX1NUQV9BU1NPQzsKLQlpZiAoKCFoYXBkLT5jb25mLT5pZWVlODAyXzF4ICYmICFoYXBkLT5jb25mLT53cGEpIHx8CisJc3RhLT5mbGFncyAmPSB+V0xBTl9TVEFfV05NX1NMRUVQX01PREU7CisJaWYgKCghaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCAmJiAhaGFwZC0+Y29uZi0+d3BhICYmICFoYXBkLT5jb25mLT5vc2VuKSB8fAogCSAgICBzdGEtPmF1dGhfYWxnID09IFdMQU5fQVVUSF9GVCkgewogCQkvKgogCQkgKiBPcGVuLCBzdGF0aWMgV0VQLCBvciBGVCBwcm90b2NvbDsgbm8gc2VwYXJhdGUgYXV0aG9yaXphdGlvbgpAQCAtMTkzOCw3ICsxOTc2LDcgQEAKIAkJCSAgICBzdGEtPmxpc3Rlbl9pbnRlcnZhbCwKIAkJCSAgICBzdGEtPmZsYWdzICYgV0xBTl9TVEFfSFQgPyAmaHRfY2FwIDogTlVMTCwKIAkJCSAgICBzdGEtPmZsYWdzICYgV0xBTl9TVEFfVkhUID8gJnZodF9jYXAgOiBOVUxMLAotCQkJICAgIHN0YS0+ZmxhZ3MsIHN0YS0+cW9zaW5mbykpIHsKKwkJCSAgICBzdGEtPmZsYWdzLCBzdGEtPnFvc2luZm8sIHN0YS0+dmh0X29wbW9kZSkpIHsKIAkJaG9zdGFwZF9sb2dnZXIoaGFwZCwgc3RhLT5hZGRyLCBIT1NUQVBEX01PRFVMRV9JRUVFODAyMTEsCiAJCQkgICAgICAgSE9TVEFQRF9MRVZFTF9OT1RJQ0UsCiAJCQkgICAgICAgIkNvdWxkIG5vdCBhZGQgU1RBIHRvIGtlcm5lbCBkcml2ZXIiKTsKQEAgLTE5NDYsNyArMTk4NCw3IEBACiAJCWFwX3N0YV9kaXNjb25uZWN0KGhhcGQsIHN0YSwgc3RhLT5hZGRyLAogCQkJCSAgV0xBTl9SRUFTT05fRElTQVNTT0NfQVBfQlVTWSk7CiAKLQkJZ290byBmYWlsOworCQlyZXR1cm47CiAJfQogCiAJaWYgKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9XRFMpIHsKQEAgLTE5NjYsMTEgKzIwMDQsMTEgQEAKIAkJICogaW50ZXJmYWNlIHNlbGVjdGlvbiBpcyBub3QgZ29pbmcgdG8gY2hhbmdlIGFueW1vcmUuCiAJCSAqLwogCQlpZiAoYXBfc3RhX2JpbmRfdmxhbihoYXBkLCBzdGEsIDApIDwgMCkKLQkJCWdvdG8gZmFpbDsKKwkJCXJldHVybjsKIAl9IGVsc2UgaWYgKHN0YS0+dmxhbl9pZCkgewogCQkvKiBWTEFOIElEIGFscmVhZHkgc2V0IChlLmcuLCBieSBQTUtTQSBjYWNoaW5nKSwgc28gYmluZCBTVEEgKi8KIAkJaWYgKGFwX3N0YV9iaW5kX3ZsYW4oaGFwZCwgc3RhLCAwKSA8IDApCi0JCQlnb3RvIGZhaWw7CisJCQlyZXR1cm47CiAJfQogCiAJaG9zdGFwZF9zZXRfc3RhX2ZsYWdzKGhhcGQsIHN0YSk7CkBAIC0xOTgyLDEzICsyMDIwLDYgQEAKIAloYXBkLT5uZXdfYXNzb2Nfc3RhX2NiKGhhcGQsIHN0YSwgIW5ld19hc3NvYyk7CiAKIAlpZWVlODAyXzF4X25vdGlmeV9wb3J0X2VuYWJsZWQoc3RhLT5lYXBvbF9zbSwgMSk7Ci0KLSBmYWlsOgotCS8qIENvcHkgb2YgdGhlIGFzc29jaWF0aW9uIHJlcXVlc3QgaXMgbm90IG5lZWRlZCBhbnltb3JlICovCi0JaWYgKHN0YS0+bGFzdF9hc3NvY19yZXEpIHsKLQkJb3NfZnJlZShzdGEtPmxhc3RfYXNzb2NfcmVxKTsKLQkJc3RhLT5sYXN0X2Fzc29jX3JlcSA9IE5VTEw7Ci0JfQogfQogCiAKQEAgLTIwNTUsNiArMjA4NiwxNCBAQAogCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKIAltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBidWY7CiAKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJaWYgKGhhcGQtPmV4dF9tZ210X2ZyYW1lX2hhbmRsaW5nKSB7CisJCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX0lORk8sICJNR01ULVRYLVNUQVRVUyBzdHlwZT0ldSBvaz0lZCIsCisJCQlzdHlwZSwgb2spOworCQlyZXR1cm47CisJfQorI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKwogCXN3aXRjaCAoc3R5cGUpIHsKIAljYXNlIFdMQU5fRkNfU1RZUEVfQVVUSDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJtZ210OjphdXRoIGNiIik7CkBAIC0yMDgzLDcgKzIxMjIsNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm1nbXQ6OmFjdGlvbiBjYiIpOwogCQlicmVhazsKIAlkZWZhdWx0OgotCQlwcmludGYoInVua25vd24gbWdtdCBjYiBmcmFtZSBzdWJ0eXBlICVkXG4iLCBzdHlwZSk7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJ1bmtub3duIG1nbXQgY2IgZnJhbWUgc3VidHlwZSAlZCIsIHN0eXBlKTsKIAkJYnJlYWs7CiAJfQogfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2llZWU4MDJfMTEuaCBiL3NyYy9hcC9pZWVlODAyXzExLmgKaW5kZXggMmFhYjU2ZC4uY2YwZDNmMiAxMDA2NDQKLS0tIGEvc3JjL2FwL2llZWU4MDJfMTEuaAorKysgYi9zcmMvYXAvaWVlZTgwMl8xMS5oCkBAIC0xNCwxMiArMTQsMTQgQEAKIHN0cnVjdCBzdGFfaW5mbzsKIHN0cnVjdCBob3N0YXBkX2ZyYW1lX2luZm87CiBzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllczsKK3N0cnVjdCBpZWVlODAyMTFfbWdtdDsKIAotdm9pZCBpZWVlODAyXzExX21nbXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbiwKLQkJICAgICBzdHJ1Y3QgaG9zdGFwZF9mcmFtZV9pbmZvICpmaSk7CitpbnQgaWVlZTgwMl8xMV9tZ210KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4sCisJCSAgICBzdHJ1Y3QgaG9zdGFwZF9mcmFtZV9pbmZvICpmaSk7CiB2b2lkIGllZWU4MDJfMTFfbWdtdF9jYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuLAogCQkJdTE2IHN0eXBlLCBpbnQgb2spOwotdm9pZCBpZWVlODAyXzExX3ByaW50X3NzaWQoY2hhciAqYnVmLCBjb25zdCB1OCAqc3NpZCwgdTggbGVuKTsKK3ZvaWQgaG9zdGFwZF8yMDQwX2NvZXhfYWN0aW9uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkgICAgICBjb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQsIHNpemVfdCBsZW4pOwogI2lmZGVmIE5FRURfQVBfTUxNRQogaW50IGllZWU4MDJfMTFfZ2V0X21pYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pOwogaW50IGllZWU4MDJfMTFfZ2V0X21pYl9zdGEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEsCkBAIC00MCw3ICs0Miw5IEBACiAjZW5kaWYgLyogTkVFRF9BUF9NTE1FICovCiB1MTYgaG9zdGFwZF9vd25fY2FwYWJfaW5mbyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJCSAgIGludCBwcm9iZSk7Cit2b2lkIGFwX2h0MjA0MF90aW1lb3V0KHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfZGF0YSk7CiB1OCAqIGhvc3RhcGRfZWlkX2V4dF9jYXBhYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKTsKK3U4ICogaG9zdGFwZF9laWRfcW9zX21hcF9zZXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCk7CiB1OCAqIGhvc3RhcGRfZWlkX3N1cHBfcmF0ZXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCk7CiB1OCAqIGhvc3RhcGRfZWlkX2V4dF9zdXBwX3JhdGVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpOwogdTggKiBob3N0YXBkX2VpZF9odF9jYXBhYmlsaXRpZXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCk7CkBAIC01OSw4ICs2MywxMiBAQAogdTE2IGNvcHlfc3RhX2h0X2NhcGFiKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAogCQkgICAgICBjb25zdCB1OCAqaHRfY2FwYWIsIHNpemVfdCBodF9jYXBhYl9sZW4pOwogdm9pZCB1cGRhdGVfaHRfc3RhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEpOwordm9pZCBodDQwX2ludG9sZXJhbnRfYWRkKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgc3RydWN0IHN0YV9pbmZvICpzdGEpOwordm9pZCBodDQwX2ludG9sZXJhbnRfcmVtb3ZlKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwgc3RydWN0IHN0YV9pbmZvICpzdGEpOwogdTE2IGNvcHlfc3RhX3ZodF9jYXBhYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJICAgICAgIGNvbnN0IHU4ICp2aHRfY2FwYWIsIHNpemVfdCB2aHRfY2FwYWJfbGVuKTsKK3UxNiBzZXRfc3RhX3ZodF9vcG1vZGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEsCisJCSAgICAgICBjb25zdCB1OCAqdmh0X29wbW9kZSk7CiB2b2lkIGhvc3RhcGRfdHhfc3RhdHVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICphZGRyLAogCQkgICAgICAgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbiwgaW50IGFjayk7CiB2b2lkIGhvc3RhcGRfZWFwb2xfdHhfc3RhdHVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICpkc3QsCmRpZmYgLS1naXQgYS9zcmMvYXAvaWVlZTgwMl8xMV9hdXRoLmMgYi9zcmMvYXAvaWVlZTgwMl8xMV9hdXRoLmMKaW5kZXggYzMxMWU1NS4uNTZjM2NlMCAxMDA2NDQKLS0tIGEvc3JjL2FwL2llZWU4MDJfMTFfYXV0aC5jCisrKyBiL3NyYy9hcC9pZWVlODAyXzExX2F1dGguYwpAQCAtMjksNyArMjksNyBAQAogCiAKIHN0cnVjdCBob3N0YXBkX2NhY2hlZF9yYWRpdXNfYWNsIHsKLQlvc190aW1lX3QgdGltZXN0YW1wOworCXN0cnVjdCBvc19yZWx0aW1lIHRpbWVzdGFtcDsKIAltYWNhZGRyIGFkZHI7CiAJaW50IGFjY2VwdGVkOyAvKiBIT1NUQVBEX0FDTF8qICovCiAJc3RydWN0IGhvc3RhcGRfY2FjaGVkX3JhZGl1c19hY2wgKm5leHQ7CkBAIC00Myw3ICs0Myw3IEBACiAKIAogc3RydWN0IGhvc3RhcGRfYWNsX3F1ZXJ5X2RhdGEgewotCW9zX3RpbWVfdCB0aW1lc3RhbXA7CisJc3RydWN0IG9zX3JlbHRpbWUgdGltZXN0YW1wOwogCXU4IHJhZGl1c19pZDsKIAltYWNhZGRyIGFkZHI7CiAJdTggKmF1dGhfbXNnOyAvKiBJRUVFIDgwMi4xMSBhdXRoZW50aWNhdGlvbiBmcmFtZSBmcm9tIHN0YXRpb24gKi8KQEAgLTEwNCwxNSArMTA0LDE2IEBACiAJCQkJIGNoYXIgKippZGVudGl0eSwgY2hhciAqKnJhZGl1c19jdWkpCiB7CiAJc3RydWN0IGhvc3RhcGRfY2FjaGVkX3JhZGl1c19hY2wgKmVudHJ5OwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAogCWZvciAoZW50cnkgPSBoYXBkLT5hY2xfY2FjaGU7IGVudHJ5OyBlbnRyeSA9IGVudHJ5LT5uZXh0KSB7CiAJCWlmIChvc19tZW1jbXAoZW50cnktPmFkZHIsIGFkZHIsIEVUSF9BTEVOKSAhPSAwKQogCQkJY29udGludWU7CiAKLQkJaWYgKG5vdy5zZWMgLSBlbnRyeS0+dGltZXN0YW1wID4gUkFESVVTX0FDTF9USU1FT1VUKQorCQlpZiAob3NfcmVsdGltZV9leHBpcmVkKCZub3csICZlbnRyeS0+dGltZXN0YW1wLAorCQkJCSAgICAgICBSQURJVVNfQUNMX1RJTUVPVVQpKQogCQkJcmV0dXJuIC0xOyAvKiBlbnRyeSBoYXMgZXhwaXJlZCAqLwogCQlpZiAoZW50cnktPmFjY2VwdGVkID09IEhPU1RBUERfQUNMX0FDQ0VQVF9USU1FT1VUKQogCQkJaWYgKHNlc3Npb25fdGltZW91dCkKQEAgLTI2NSw3ICsyNjYsNiBAQAogCQlyZXR1cm4gSE9TVEFQRF9BQ0xfUkVKRUNUOwogI2Vsc2UgLyogQ09ORklHX05PX1JBRElVUyAqLwogCQlzdHJ1Y3QgaG9zdGFwZF9hY2xfcXVlcnlfZGF0YSAqcXVlcnk7Ci0JCXN0cnVjdCBvc190aW1lIHQ7CiAKIAkJLyogQ2hlY2sgd2hldGhlciBBQ0wgY2FjaGUgaGFzIGFuIGVudHJ5IGZvciB0aGlzIHN0YXRpb24gKi8KIAkJaW50IHJlcyA9IGhvc3RhcGRfYWNsX2NhY2hlX2dldChoYXBkLCBhZGRyLCBzZXNzaW9uX3RpbWVvdXQsCkBAIC0zMDUsOCArMzA1LDcgQEAKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibWFsbG9jIGZvciBxdWVyeSBkYXRhIGZhaWxlZCIpOwogCQkJcmV0dXJuIEhPU1RBUERfQUNMX1JFSkVDVDsKIAkJfQotCQlvc19nZXRfdGltZSgmdCk7Ci0JCXF1ZXJ5LT50aW1lc3RhbXAgPSB0LnNlYzsKKwkJb3NfZ2V0X3JlbHRpbWUoJnF1ZXJ5LT50aW1lc3RhbXApOwogCQlvc19tZW1jcHkocXVlcnktPmFkZHIsIGFkZHIsIEVUSF9BTEVOKTsKIAkJaWYgKGhvc3RhcGRfcmFkaXVzX2FjbF9xdWVyeShoYXBkLCBhZGRyLCBxdWVyeSkpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRmFpbGVkIHRvIHNlbmQgQWNjZXNzLVJlcXVlc3QgIgpAQCAtMzM4LDcgKzMzNyw4IEBACiAKIAogI2lmbmRlZiBDT05GSUdfTk9fUkFESVVTCi1zdGF0aWMgdm9pZCBob3N0YXBkX2FjbF9leHBpcmVfY2FjaGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgb3NfdGltZV90IG5vdykKK3N0YXRpYyB2b2lkIGhvc3RhcGRfYWNsX2V4cGlyZV9jYWNoZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgICAgc3RydWN0IG9zX3JlbHRpbWUgKm5vdykKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9jYWNoZWRfcmFkaXVzX2FjbCAqcHJldiwgKmVudHJ5LCAqdG1wOwogCkBAIC0zNDYsNyArMzQ2LDggQEAKIAllbnRyeSA9IGhhcGQtPmFjbF9jYWNoZTsKIAogCXdoaWxlIChlbnRyeSkgewotCQlpZiAobm93IC0gZW50cnktPnRpbWVzdGFtcCA+IFJBRElVU19BQ0xfVElNRU9VVCkgeworCQlpZiAob3NfcmVsdGltZV9leHBpcmVkKG5vdywgJmVudHJ5LT50aW1lc3RhbXAsCisJCQkJICAgICAgIFJBRElVU19BQ0xfVElNRU9VVCkpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ2FjaGVkIEFDTCBlbnRyeSBmb3IgIiBNQUNTVFIKIAkJCQkgICAiIGhhcyBleHBpcmVkLiIsIE1BQzJTVFIoZW50cnktPmFkZHIpKTsKIAkJCWlmIChwcmV2KQpAQCAtMzY3LDcgKzM2OCw3IEBACiAKIAogc3RhdGljIHZvaWQgaG9zdGFwZF9hY2xfZXhwaXJlX3F1ZXJpZXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKLQkJCQkgICAgICAgb3NfdGltZV90IG5vdykKKwkJCQkgICAgICAgc3RydWN0IG9zX3JlbHRpbWUgKm5vdykKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9hY2xfcXVlcnlfZGF0YSAqcHJldiwgKmVudHJ5LCAqdG1wOwogCkBAIC0zNzUsNyArMzc2LDggQEAKIAllbnRyeSA9IGhhcGQtPmFjbF9xdWVyaWVzOwogCiAJd2hpbGUgKGVudHJ5KSB7Ci0JCWlmIChub3cgLSBlbnRyeS0+dGltZXN0YW1wID4gUkFESVVTX0FDTF9USU1FT1VUKSB7CisJCWlmIChvc19yZWx0aW1lX2V4cGlyZWQobm93LCAmZW50cnktPnRpbWVzdGFtcCwKKwkJCQkgICAgICAgUkFESVVTX0FDTF9USU1FT1VUKSkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBQ0wgcXVlcnkgZm9yICIgTUFDU1RSCiAJCQkJICAgIiBoYXMgZXhwaXJlZC4iLCBNQUMyU1RSKGVudHJ5LT5hZGRyKSk7CiAJCQlpZiAocHJldikKQEAgLTQwMywxMSArNDA1LDExIEBACiBzdGF0aWMgdm9pZCBob3N0YXBkX2FjbF9leHBpcmUodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkID0gZWxvb3BfY3R4OwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKLQlob3N0YXBkX2FjbF9leHBpcmVfY2FjaGUoaGFwZCwgbm93LnNlYyk7Ci0JaG9zdGFwZF9hY2xfZXhwaXJlX3F1ZXJpZXMoaGFwZCwgbm93LnNlYyk7CisJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CisJaG9zdGFwZF9hY2xfZXhwaXJlX2NhY2hlKGhhcGQsICZub3cpOworCWhvc3RhcGRfYWNsX2V4cGlyZV9xdWVyaWVzKGhhcGQsICZub3cpOwogCiAJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgxMCwgMCwgaG9zdGFwZF9hY2xfZXhwaXJlLCBoYXBkLCBOVUxMKTsKIH0KQEAgLTQ4MCw3ICs0ODIsNiBAQAogCXN0cnVjdCBob3N0YXBkX2FjbF9xdWVyeV9kYXRhICpxdWVyeSwgKnByZXY7CiAJc3RydWN0IGhvc3RhcGRfY2FjaGVkX3JhZGl1c19hY2wgKmNhY2hlOwogCXN0cnVjdCByYWRpdXNfaGRyICpoZHIgPSByYWRpdXNfbXNnX2dldF9oZHIobXNnKTsKLQlzdHJ1Y3Qgb3NfdGltZSB0OwogCiAJcXVlcnkgPSBoYXBkLT5hY2xfcXVlcmllczsKIAlwcmV2ID0gTlVMTDsKQEAgLTUxNSw4ICs1MTYsNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBhZGQgQUNMIGNhY2hlIGVudHJ5Iik7CiAJCWdvdG8gZG9uZTsKIAl9Ci0Jb3NfZ2V0X3RpbWUoJnQpOwotCWNhY2hlLT50aW1lc3RhbXAgPSB0LnNlYzsKKwlvc19nZXRfcmVsdGltZSgmY2FjaGUtPnRpbWVzdGFtcCk7CiAJb3NfbWVtY3B5KGNhY2hlLT5hZGRyLCBxdWVyeS0+YWRkciwgc2l6ZW9mKGNhY2hlLT5hZGRyKSk7CiAJaWYgKGhkci0+Y29kZSA9PSBSQURJVVNfQ09ERV9BQ0NFU1NfQUNDRVBUKSB7CiAJCXU4ICpidWY7CmRpZmYgLS1naXQgYS9zcmMvYXAvaWVlZTgwMl8xMV9odC5jIGIvc3JjL2FwL2llZWU4MDJfMTFfaHQuYwppbmRleCA2NDgzZTFjLi5mZTg3ODgzIDEwMDY0NAotLS0gYS9zcmMvYXAvaWVlZTgwMl8xMV9odC5jCisrKyBiL3NyYy9hcC9pZWVlODAyXzExX2h0LmMKQEAgLTMsMjYgKzMsMjIgQEAKICAqIENvcHlyaWdodCAoYykgMjAwMi0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICogQ29weXJpZ2h0IChjKSAyMDA3LTIwMDgsIEludGVsIENvcnBvcmF0aW9uCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCiAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKyNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKLSNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgogI2luY2x1ZGUgImhvc3RhcGQuaCIKICNpbmNsdWRlICJhcF9jb25maWcuaCIKICNpbmNsdWRlICJzdGFfaW5mby5oIgogI2luY2x1ZGUgImJlYWNvbi5oIgogI2luY2x1ZGUgImllZWU4MDJfMTEuaCIKKyNpbmNsdWRlICJod19mZWF0dXJlcy5oIgorI2luY2x1ZGUgImFwX2Rydl9vcHMuaCIKIAogCiB1OCAqIGhvc3RhcGRfZWlkX2h0X2NhcGFiaWxpdGllcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKQpAQCAtNTAsNiArNDYsMzUgQEAKIAogIAlwb3MgKz0gc2l6ZW9mKCpjYXApOwogCisJaWYgKGhhcGQtPmljb25mLT5vYnNzX2ludGVydmFsKSB7CisJCXN0cnVjdCBpZWVlODAyMTFfb2Jzc19zY2FuX3BhcmFtZXRlcnMgKnNjYW5fcGFyYW1zOworCisJCSpwb3MrKyA9IFdMQU5fRUlEX09WRVJMQVBQSU5HX0JTU19TQ0FOX1BBUkFNUzsKKwkJKnBvcysrID0gc2l6ZW9mKCpzY2FuX3BhcmFtcyk7CisKKwkJc2Nhbl9wYXJhbXMgPSAoc3RydWN0IGllZWU4MDIxMV9vYnNzX3NjYW5fcGFyYW1ldGVycyAqKSBwb3M7CisJCW9zX21lbXNldChzY2FuX3BhcmFtcywgMCwgc2l6ZW9mKCpzY2FuX3BhcmFtcykpOworCQlzY2FuX3BhcmFtcy0+d2lkdGhfdHJpZ2dlcl9zY2FuX2ludGVydmFsID0KKwkJCWhvc3RfdG9fbGUxNihoYXBkLT5pY29uZi0+b2Jzc19pbnRlcnZhbCk7CisKKwkJLyogRmlsbCBpbiBkZWZhdWx0IHZhbHVlcyBmb3IgcmVtYWluaW5nIHBhcmFtZXRlcnMKKwkJICogKElFRUUgU3RkIDgwMi4xMS0yMDEyLCA4LjQuMi42MSBhbmQgTUlCIGRlZnZhbCkgKi8KKwkJc2Nhbl9wYXJhbXMtPnNjYW5fcGFzc2l2ZV9kd2VsbCA9CisJCQlob3N0X3RvX2xlMTYoMjApOworCQlzY2FuX3BhcmFtcy0+c2Nhbl9hY3RpdmVfZHdlbGwgPQorCQkJaG9zdF90b19sZTE2KDEwKTsKKwkJc2Nhbl9wYXJhbXMtPnNjYW5fcGFzc2l2ZV90b3RhbF9wZXJfY2hhbm5lbCA9CisJCQlob3N0X3RvX2xlMTYoMjAwKTsKKwkJc2Nhbl9wYXJhbXMtPnNjYW5fYWN0aXZlX3RvdGFsX3Blcl9jaGFubmVsID0KKwkJCWhvc3RfdG9fbGUxNigyMCk7CisJCXNjYW5fcGFyYW1zLT5jaGFubmVsX3RyYW5zaXRpb25fZGVsYXlfZmFjdG9yID0KKwkJCWhvc3RfdG9fbGUxNig1KTsKKwkJc2Nhbl9wYXJhbXMtPnNjYW5fYWN0aXZpdHlfdGhyZXNob2xkID0KKwkJCWhvc3RfdG9fbGUxNigyNSk7CisKKwkJcG9zICs9IHNpemVvZigqc2Nhbl9wYXJhbXMpOworCX0KKwogCXJldHVybiBwb3M7CiB9CiAKQEAgLTY4LDE0ICs5MywxNCBAQAogCW9wZXIgPSAoc3RydWN0IGllZWU4MDIxMV9odF9vcGVyYXRpb24gKikgcG9zOwogCW9zX21lbXNldChvcGVyLCAwLCBzaXplb2YoKm9wZXIpKTsKIAotCW9wZXItPmNvbnRyb2xfY2hhbiA9IGhhcGQtPmljb25mLT5jaGFubmVsOworCW9wZXItPnByaW1hcnlfY2hhbiA9IGhhcGQtPmljb25mLT5jaGFubmVsOwogCW9wZXItPm9wZXJhdGlvbl9tb2RlID0gaG9zdF90b19sZTE2KGhhcGQtPmlmYWNlLT5odF9vcF9tb2RlKTsKIAlpZiAoaGFwZC0+aWNvbmYtPnNlY29uZGFyeV9jaGFubmVsID09IDEpCiAJCW9wZXItPmh0X3BhcmFtIHw9IEhUX0lORk9fSFRfUEFSQU1fU0VDT05EQVJZX0NITkxfQUJPVkUgfAotCQkJSFRfSU5GT19IVF9QQVJBTV9SRUNfVFJBTlNfQ0hOTF9XSURUSDsKKwkJCUhUX0lORk9fSFRfUEFSQU1fU1RBX0NITkxfV0lEVEg7CiAJaWYgKGhhcGQtPmljb25mLT5zZWNvbmRhcnlfY2hhbm5lbCA9PSAtMSkKIAkJb3Blci0+aHRfcGFyYW0gfD0gSFRfSU5GT19IVF9QQVJBTV9TRUNPTkRBUllfQ0hOTF9CRUxPVyB8Ci0JCQlIVF9JTkZPX0hUX1BBUkFNX1JFQ19UUkFOU19DSE5MX1dJRFRIOworCQkJSFRfSU5GT19IVF9QQVJBTV9TVEFfQ0hOTF9XSURUSDsKIAogCXBvcyArPSBzaXplb2YoKm9wZXIpOwogCkBAIC0xMDUsNDQgKzEzMCw0MCBAQAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMgY3VycmVudCBvcGVyYXRpb24gbW9kZT0weCVYIiwKIAkJICAgX19mdW5jX18sIGlmYWNlLT5odF9vcF9tb2RlKTsKIAotCWlmICghKGlmYWNlLT5odF9vcF9tb2RlICYgSFRfSU5GT19PUEVSQVRJT05fTU9ERV9OT05fR0ZfREVWU19QUkVTRU5UKQorCWlmICghKGlmYWNlLT5odF9vcF9tb2RlICYgSFRfT1BFUl9PUF9NT0RFX05PTl9HRl9IVF9TVEFTX1BSRVNFTlQpCiAJICAgICYmIGlmYWNlLT5udW1fc3RhX2h0X25vX2dmKSB7Ci0JCWlmYWNlLT5odF9vcF9tb2RlIHw9Ci0JCQlIVF9JTkZPX09QRVJBVElPTl9NT0RFX05PTl9HRl9ERVZTX1BSRVNFTlQ7CisJCWlmYWNlLT5odF9vcF9tb2RlIHw9IEhUX09QRVJfT1BfTU9ERV9OT05fR0ZfSFRfU1RBU19QUkVTRU5UOwogCQlvcF9tb2RlX2NoYW5nZXMrKzsKIAl9IGVsc2UgaWYgKChpZmFjZS0+aHRfb3BfbW9kZSAmCi0JCSAgICBIVF9JTkZPX09QRVJBVElPTl9NT0RFX05PTl9HRl9ERVZTX1BSRVNFTlQpICYmCisJCSAgICBIVF9PUEVSX09QX01PREVfTk9OX0dGX0hUX1NUQVNfUFJFU0VOVCkgJiYKIAkJICAgaWZhY2UtPm51bV9zdGFfaHRfbm9fZ2YgPT0gMCkgewotCQlpZmFjZS0+aHRfb3BfbW9kZSAmPQotCQkJfkhUX0lORk9fT1BFUkFUSU9OX01PREVfTk9OX0dGX0RFVlNfUFJFU0VOVDsKKwkJaWZhY2UtPmh0X29wX21vZGUgJj0gfkhUX09QRVJfT1BfTU9ERV9OT05fR0ZfSFRfU1RBU19QUkVTRU5UOwogCQlvcF9tb2RlX2NoYW5nZXMrKzsKIAl9CiAKLQlpZiAoIShpZmFjZS0+aHRfb3BfbW9kZSAmIEhUX0lORk9fT1BFUkFUSU9OX01PREVfTk9OX0hUX1NUQV9QUkVTRU5UKSAmJgorCWlmICghKGlmYWNlLT5odF9vcF9tb2RlICYgSFRfT1BFUl9PUF9NT0RFX09CU1NfTk9OX0hUX1NUQVNfUFJFU0VOVCkgJiYKIAkgICAgKGlmYWNlLT5udW1fc3RhX25vX2h0IHx8IGlmYWNlLT5vbGJjX2h0KSkgewotCQlpZmFjZS0+aHRfb3BfbW9kZSB8PSBIVF9JTkZPX09QRVJBVElPTl9NT0RFX05PTl9IVF9TVEFfUFJFU0VOVDsKKwkJaWZhY2UtPmh0X29wX21vZGUgfD0gSFRfT1BFUl9PUF9NT0RFX09CU1NfTk9OX0hUX1NUQVNfUFJFU0VOVDsKIAkJb3BfbW9kZV9jaGFuZ2VzKys7CiAJfSBlbHNlIGlmICgoaWZhY2UtPmh0X29wX21vZGUgJgotCQkgICAgSFRfSU5GT19PUEVSQVRJT05fTU9ERV9OT05fSFRfU1RBX1BSRVNFTlQpICYmCisJCSAgICBIVF9PUEVSX09QX01PREVfT0JTU19OT05fSFRfU1RBU19QUkVTRU5UKSAmJgogCQkgICAoaWZhY2UtPm51bV9zdGFfbm9faHQgPT0gMCAmJiAhaWZhY2UtPm9sYmNfaHQpKSB7Ci0JCWlmYWNlLT5odF9vcF9tb2RlICY9Ci0JCQl+SFRfSU5GT19PUEVSQVRJT05fTU9ERV9OT05fSFRfU1RBX1BSRVNFTlQ7CisJCWlmYWNlLT5odF9vcF9tb2RlICY9IH5IVF9PUEVSX09QX01PREVfT0JTU19OT05fSFRfU1RBU19QUkVTRU5UOwogCQlvcF9tb2RlX2NoYW5nZXMrKzsKIAl9CiAKLQluZXdfb3BfbW9kZSA9IDA7CiAJaWYgKGlmYWNlLT5udW1fc3RhX25vX2h0KQotCQluZXdfb3BfbW9kZSA9IE9QX01PREVfTUlYRUQ7CisJCW5ld19vcF9tb2RlID0gSFRfUFJPVF9OT05fSFRfTUlYRUQ7CiAJZWxzZSBpZiAoaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsICYmIGlmYWNlLT5udW1fc3RhX2h0XzIwbWh6KQotCQluZXdfb3BfbW9kZSA9IE9QX01PREVfMjBNSFpfSFRfU1RBX0FTU09DRUQ7CisJCW5ld19vcF9tb2RlID0gSFRfUFJPVF8yME1IWl9QUk9URUNUSU9OOwogCWVsc2UgaWYgKGlmYWNlLT5vbGJjX2h0KQotCQluZXdfb3BfbW9kZSA9IE9QX01PREVfTUFZX0JFX0xFR0FDWV9TVEFTOworCQluZXdfb3BfbW9kZSA9IEhUX1BST1RfTk9OTUVNQkVSX1BST1RFQ1RJT047CiAJZWxzZQotCQluZXdfb3BfbW9kZSA9IE9QX01PREVfUFVSRTsKKwkJbmV3X29wX21vZGUgPSBIVF9QUk9UX05PX1BST1RFQ1RJT047CiAKLQljdXJfb3BfbW9kZSA9IGlmYWNlLT5odF9vcF9tb2RlICYgSFRfSU5GT19PUEVSQVRJT05fTU9ERV9PUF9NT0RFX01BU0s7CisJY3VyX29wX21vZGUgPSBpZmFjZS0+aHRfb3BfbW9kZSAmIEhUX09QRVJfT1BfTU9ERV9IVF9QUk9UX01BU0s7CiAJaWYgKGN1cl9vcF9tb2RlICE9IG5ld19vcF9tb2RlKSB7Ci0JCWlmYWNlLT5odF9vcF9tb2RlICY9IH5IVF9JTkZPX09QRVJBVElPTl9NT0RFX09QX01PREVfTUFTSzsKKwkJaWZhY2UtPmh0X29wX21vZGUgJj0gfkhUX09QRVJfT1BfTU9ERV9IVF9QUk9UX01BU0s7CiAJCWlmYWNlLT5odF9vcF9tb2RlIHw9IG5ld19vcF9tb2RlOwogCQlvcF9tb2RlX2NoYW5nZXMrKzsKIAl9CkBAIC0xNTQsNiArMTc1LDExNSBAQAogfQogCiAKK3N0YXRpYyBpbnQgaXNfNDBfYWxsb3dlZChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsIGludCBjaGFubmVsKQoreworCWludCBwcmlfZnJlcSwgc2VjX2ZyZXE7CisJaW50IGFmZmVjdGVkX3N0YXJ0LCBhZmZlY3RlZF9lbmQ7CisJaW50IHByaSA9IDI0MDcgKyA1ICogY2hhbm5lbDsKKworCWlmIChpZmFjZS0+Y3VycmVudF9tb2RlLT5tb2RlICE9IEhPU1RBUERfTU9ERV9JRUVFODAyMTFHKQorCQlyZXR1cm4gMTsKKworCXByaV9mcmVxID0gaG9zdGFwZF9od19nZXRfZnJlcShpZmFjZS0+YnNzWzBdLCBpZmFjZS0+Y29uZi0+Y2hhbm5lbCk7CisKKwlpZiAoaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsID4gMCkKKwkJc2VjX2ZyZXEgPSBwcmlfZnJlcSArIDIwOworCWVsc2UKKwkJc2VjX2ZyZXEgPSBwcmlfZnJlcSAtIDIwOworCisJYWZmZWN0ZWRfc3RhcnQgPSAocHJpX2ZyZXEgKyBzZWNfZnJlcSkgLyAyIC0gMjU7CisJYWZmZWN0ZWRfZW5kID0gKHByaV9mcmVxICsgc2VjX2ZyZXEpIC8gMiArIDI1OworCWlmICgocHJpIDwgYWZmZWN0ZWRfc3RhcnQgfHwgcHJpID4gYWZmZWN0ZWRfZW5kKSkKKwkJcmV0dXJuIDE7IC8qIG5vdCB3aXRoaW4gYWZmZWN0ZWQgY2hhbm5lbCByYW5nZSAqLworCisJd3BhX3ByaW50ZihNU0dfRVJST1IsICI0MCBNSHogYWZmZWN0ZWQgY2hhbm5lbCByYW5nZTogWyVkLCVkXSBNSHoiLAorCQkgICBhZmZlY3RlZF9zdGFydCwgYWZmZWN0ZWRfZW5kKTsKKwl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIk5laWdoYm9yaW5nIEJTUzogZnJlcT0lZCIsIHByaSk7CisJcmV0dXJuIDA7Cit9CisKKwordm9pZCBob3N0YXBkXzIwNDBfY29leF9hY3Rpb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdCwgc2l6ZV90IGxlbikKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UgPSBoYXBkLT5pZmFjZTsKKwlzdHJ1Y3QgaWVlZTgwMjExXzIwNDBfYnNzX2NvZXhfaWUgKmJjX2llOworCXN0cnVjdCBpZWVlODAyMTFfMjA0MF9pbnRvbF9jaGFuX3JlcG9ydCAqaWNfcmVwb3J0OworCWludCBpc19odF9hbGxvd2VkID0gMTsKKwlpbnQgaTsKKwljb25zdCB1OCAqZGF0YSA9ICgoY29uc3QgdTggKikgbWdtdCkgKyAxOworCisJaG9zdGFwZF9sb2dnZXIoaGFwZCwgbWdtdC0+c2EsIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKKwkJICAgICAgIEhPU1RBUERfTEVWRUxfREVCVUcsICJob3N0YXBkX3B1YmxpY19hY3Rpb24gLSBhY3Rpb249JWQiLAorCQkgICAgICAgbWdtdC0+dS5hY3Rpb24udS5wdWJsaWNfYWN0aW9uLmFjdGlvbik7CisKKwlpZiAoIShpZmFjZS0+Y29uZi0+aHRfY2FwYWIgJiBIVF9DQVBfSU5GT19TVVBQX0NIQU5ORUxfV0lEVEhfU0VUKSkKKwkJcmV0dXJuOworCisJaWYgKGxlbiA8IElFRUU4MDIxMV9IRFJMRU4gKyAxKQorCQlyZXR1cm47CisJZGF0YSsrOworCisJYmNfaWUgPSAoc3RydWN0IGllZWU4MDIxMV8yMDQwX2Jzc19jb2V4X2llICopICZkYXRhWzBdOworCWljX3JlcG9ydCA9IChzdHJ1Y3QgaWVlZTgwMjExXzIwNDBfaW50b2xfY2hhbl9yZXBvcnQgKikKKwkJKCZkYXRhWzBdICsgc2l6ZW9mKCpiY19pZSkpOworCisJaWYgKGJjX2llLT5jb2V4X3BhcmFtICYgV0xBTl8yMF80MF9CU1NfQ09FWF8yME1IWl9XSURUSF9SRVEpIHsKKwkJaG9zdGFwZF9sb2dnZXIoaGFwZCwgbWdtdC0+c2EsCisJCQkgICAgICAgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAorCQkJICAgICAgIEhPU1RBUERfTEVWRUxfREVCVUcsCisJCQkgICAgICAgIjIwIE1IeiBCU1Mgd2lkdGggcmVxdWVzdCBiaXQgaXMgc2V0IGluIEJTUyBjb2V4aXN0ZW5jZSBpbmZvcm1hdGlvbiBmaWVsZCIpOworCQlpc19odF9hbGxvd2VkID0gMDsKKwl9CisKKwlpZiAoYmNfaWUtPmNvZXhfcGFyYW0gJiBXTEFOXzIwXzQwX0JTU19DT0VYXzQwTUhaX0lOVE9MKSB7CisJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIG1nbXQtPnNhLAorCQkJICAgICAgIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKKwkJCSAgICAgICBIT1NUQVBEX0xFVkVMX0RFQlVHLAorCQkJICAgICAgICI0MCBNSHogaW50b2xlcmFudCBiaXQgaXMgc2V0IGluIEJTUyBjb2V4aXN0ZW5jZSBpbmZvcm1hdGlvbiBmaWVsZCIpOworCQlpc19odF9hbGxvd2VkID0gMDsKKwl9CisKKwlpZiAoaWNfcmVwb3J0ICYmCisJICAgIChpY19yZXBvcnQtPmVsZW1lbnRfaWQgPT0gV0xBTl9FSURfMjBfNDBfQlNTX0lOVE9MRVJBTlQpKSB7CisJCS8qIEdvIHRocm91Z2ggdGhlIGNoYW5uZWwgcmVwb3J0IHRvIGZpbmQgYW55IEJTUyB0aGVyZSBpbiB0aGUKKwkJICogYWZmZWN0ZWQgY2hhbm5lbCByYW5nZSAqLworCQlmb3IgKGkgPSAwOyBpIDwgaWNfcmVwb3J0LT5sZW5ndGggLSAxOyBpKyspIHsKKwkJCWlmIChpc180MF9hbGxvd2VkKGlmYWNlLCBpY19yZXBvcnQtPnZhcmlhYmxlW2ldKSkKKwkJCQljb250aW51ZTsKKwkJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIG1nbXQtPnNhLAorCQkJCSAgICAgICBIT1NUQVBEX01PRFVMRV9JRUVFODAyMTEsCisJCQkJICAgICAgIEhPU1RBUERfTEVWRUxfREVCVUcsCisJCQkJICAgICAgICIyMF80MF9JTlRPTEVSQU5UIGNoYW5uZWwgJWQgcmVwb3J0ZWQiLAorCQkJCSAgICAgICBpY19yZXBvcnQtPnZhcmlhYmxlW2ldKTsKKwkJCWlzX2h0X2FsbG93ZWQgPSAwOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwlpZiAoIWlzX2h0X2FsbG93ZWQgJiYKKwkgICAgKGlmYWNlLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX0hUXzIwNDBfQ09FWCkpIHsKKwkJaWYgKGlmYWNlLT5jb25mLT5zZWNvbmRhcnlfY2hhbm5lbCkgeworCQkJaG9zdGFwZF9sb2dnZXIoaGFwZCwgbWdtdC0+c2EsCisJCQkJICAgICAgIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKKwkJCQkgICAgICAgSE9TVEFQRF9MRVZFTF9JTkZPLAorCQkJCSAgICAgICAiU3dpdGNoaW5nIHRvIDIwIE1IeiBvcGVyYXRpb24iKTsKKwkJCWlmYWNlLT5jb25mLT5zZWNvbmRhcnlfY2hhbm5lbCA9IDA7CisJCQlpZWVlODAyXzExX3NldF9iZWFjb25zKGlmYWNlKTsKKwkJfQorCQlpZiAoIWlmYWNlLT5udW1fc3RhX2h0NDBfaW50b2xlcmFudCkgeworCQkJdW5zaWduZWQgaW50IGRlbGF5X3RpbWU7CisJCQlkZWxheV90aW1lID0gT1ZFUkxBUFBJTkdfQlNTX1RSQU5TX0RFTEFZX0ZBQ1RPUiAqCisJCQkJaWZhY2UtPmNvbmYtPm9ic3NfaW50ZXJ2YWw7CisJCQllbG9vcF9jYW5jZWxfdGltZW91dChhcF9odDIwNDBfdGltZW91dCwgaGFwZC0+aWZhY2UsCisJCQkJCSAgICAgTlVMTCk7CisJCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KGRlbGF5X3RpbWUsIDAsIGFwX2h0MjA0MF90aW1lb3V0LAorCQkJCQkgICAgICAgaGFwZC0+aWZhY2UsIE5VTEwpOworCQl9CisJfQorfQorCisKIHUxNiBjb3B5X3N0YV9odF9jYXBhYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJICAgICAgY29uc3QgdTggKmh0X2NhcGFiLCBzaXplX3QgaHRfY2FwYWJfbGVuKQogewpAQCAtMTgyLDYgKzMxMiw1MiBAQAogfQogCiAKK3ZvaWQgaHQ0MF9pbnRvbGVyYW50X2FkZChzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsIHN0cnVjdCBzdGFfaW5mbyAqc3RhKQoreworCWlmIChpZmFjZS0+Y3VycmVudF9tb2RlLT5tb2RlICE9IEhPU1RBUERfTU9ERV9JRUVFODAyMTFHKQorCQlyZXR1cm47CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSFQ6IEZvcnR5IE1IeiBJbnRvbGVyYW50IGlzIHNldCBieSBTVEEgIiBNQUNTVFIKKwkJICAgIiBpbiBBc3NvY2lhdGlvbiBSZXF1ZXN0IiwgTUFDMlNUUihzdGEtPmFkZHIpKTsKKworCWlmIChzdGEtPmh0NDBfaW50b2xlcmFudF9zZXQpCisJCXJldHVybjsKKworCXN0YS0+aHQ0MF9pbnRvbGVyYW50X3NldCA9IDE7CisJaWZhY2UtPm51bV9zdGFfaHQ0MF9pbnRvbGVyYW50Kys7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaHQyMDQwX3RpbWVvdXQsIGlmYWNlLCBOVUxMKTsKKworCWlmIChpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgJiYKKwkgICAgKGlmYWNlLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX0hUXzIwNDBfQ09FWCkpIHsKKwkJaWZhY2UtPmNvbmYtPnNlY29uZGFyeV9jaGFubmVsID0gMDsKKwkJaWVlZTgwMl8xMV9zZXRfYmVhY29ucyhpZmFjZSk7CisJfQorfQorCisKK3ZvaWQgaHQ0MF9pbnRvbGVyYW50X3JlbW92ZShzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsIHN0cnVjdCBzdGFfaW5mbyAqc3RhKQoreworCWlmICghc3RhLT5odDQwX2ludG9sZXJhbnRfc2V0KQorCQlyZXR1cm47CisKKwlzdGEtPmh0NDBfaW50b2xlcmFudF9zZXQgPSAwOworCWlmYWNlLT5udW1fc3RhX2h0NDBfaW50b2xlcmFudC0tOworCisJaWYgKGlmYWNlLT5udW1fc3RhX2h0NDBfaW50b2xlcmFudCA9PSAwICYmCisJICAgIChpZmFjZS0+Y29uZi0+aHRfY2FwYWIgJiBIVF9DQVBfSU5GT19TVVBQX0NIQU5ORUxfV0lEVEhfU0VUKSAmJgorCSAgICAoaWZhY2UtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfSFRfMjA0MF9DT0VYKSkgeworCQl1bnNpZ25lZCBpbnQgZGVsYXlfdGltZSA9IE9WRVJMQVBQSU5HX0JTU19UUkFOU19ERUxBWV9GQUNUT1IgKgorCQkJaWZhY2UtPmNvbmYtPm9ic3NfaW50ZXJ2YWw7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJICAgIkhUOiBTdGFydCAyMC0+NDAgTUh6IHRyYW5zaXRpb24gdGltZXIgKCVkIHNlY29uZHMpIiwKKwkJCSAgIGRlbGF5X3RpbWUpOworCQllbG9vcF9jYW5jZWxfdGltZW91dChhcF9odDIwNDBfdGltZW91dCwgaWZhY2UsIE5VTEwpOworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KGRlbGF5X3RpbWUsIDAsIGFwX2h0MjA0MF90aW1lb3V0LAorCQkJCSAgICAgICBpZmFjZSwgTlVMTCk7CisJfQorfQorCisKIHN0YXRpYyB2b2lkIHVwZGF0ZV9zdGFfaHQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEpCiB7CiAJdTE2IGh0X2NhcGFiOwpAQCAtMjA5LDYgKzM4NSw5IEBACiAJCQkgICBfX2Z1bmNfXywgTUFDMlNUUihzdGEtPmFkZHIpLAogCQkJICAgaGFwZC0+aWZhY2UtPm51bV9zdGFfaHRfMjBtaHopOwogCX0KKworCWlmIChodF9jYXBhYiAmIEhUX0NBUF9JTkZPXzQwTUhaX0lOVE9MRVJBTlQpCisJCWh0NDBfaW50b2xlcmFudF9hZGQoaGFwZC0+aWZhY2UsIHN0YSk7CiB9CiAKIApAQCAtMjcwLDMgKzQ0OSwxNCBAQAogCiAJbmVnX2h0X2NhcC0+aHRfY2FwYWJpbGl0aWVzX2luZm8gPSBob3N0X3RvX2xlMTYoY2FwKTsKIH0KKworCit2b2lkIGFwX2h0MjA0MF90aW1lb3V0KHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfZGF0YSkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UgPSBlbG9vcF9kYXRhOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlN3aXRjaGluZyB0byA0MCBNSHogb3BlcmF0aW9uIik7CisKKwlpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPSBpZmFjZS0+c2Vjb25kYXJ5X2NoOworCWllZWU4MDJfMTFfc2V0X2JlYWNvbnMoaWZhY2UpOworfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2llZWU4MDJfMTFfc2hhcmVkLmMgYi9zcmMvYXAvaWVlZTgwMl8xMV9zaGFyZWQuYwppbmRleCBjMzZiYmUzLi4xMjQwM2Y5IDEwMDY0NAotLS0gYS9zcmMvYXAvaWVlZTgwMl8xMV9zaGFyZWQuYworKysgYi9zcmMvYXAvaWVlZTgwMl8xMV9zaGFyZWQuYwpAQCAtMjQsMTMgKzI0LDEzIEBACiB7CiAJdTggKnBvcyA9IGVpZDsKIAl1MzIgdGltZW91dCwgdHU7Ci0Jc3RydWN0IG9zX3RpbWUgbm93LCBwYXNzZWQ7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93LCBwYXNzZWQ7CiAKIAkqcG9zKysgPSBXTEFOX0VJRF9USU1FT1VUX0lOVEVSVkFMOwogCSpwb3MrKyA9IDU7CiAJKnBvcysrID0gV0xBTl9USU1FT1VUX0FTU09DX0NPTUVCQUNLOwotCW9zX2dldF90aW1lKCZub3cpOwotCW9zX3RpbWVfc3ViKCZub3csICZzdGEtPnNhX3F1ZXJ5X3N0YXJ0LCAmcGFzc2VkKTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKKwlvc19yZWx0aW1lX3N1Yigmbm93LCAmc3RhLT5zYV9xdWVyeV9zdGFydCwgJnBhc3NlZCk7CiAJdHUgPSAocGFzc2VkLnNlYyAqIDEwMDAwMDAgKyBwYXNzZWQudXNlYykgLyAxMDI0OwogCWlmIChoYXBkLT5jb25mLT5hc3NvY19zYV9xdWVyeV9tYXhfdGltZW91dCA+IHR1KQogCQl0aW1lb3V0ID0gaGFwZC0+Y29uZi0+YXNzb2Nfc2FfcXVlcnlfbWF4X3RpbWVvdXQgLSB0dTsKQEAgLTY5LDcgKzY5LDcgQEAKIAkJICBXTEFOX1NBX1FVRVJZX1RSX0lEX0xFTik7CiAJZW5kID0gbWdtdC51LmFjdGlvbi51LnNhX3F1ZXJ5X3JlcS50cmFuc19pZCArIFdMQU5fU0FfUVVFUllfVFJfSURfTEVOOwogCWlmIChob3N0YXBkX2Rydl9zZW5kX21sbWUoaGFwZCwgJm1nbXQsIGVuZCAtICh1OCAqKSAmbWdtdCwgMCkgPCAwKQotCQlwZXJyb3IoImllZWU4MDJfMTFfc2VuZF9zYV9xdWVyeV9yZXE6IHNlbmQiKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImllZWU4MDJfMTFfc2VuZF9zYV9xdWVyeV9yZXE6IHNlbmQgZmFpbGVkIik7CiB9CiAKIApAQCAtMTA3LDcgKzEwNyw3IEBACiAJCSAgV0xBTl9TQV9RVUVSWV9UUl9JRF9MRU4pOwogCWVuZCA9IHJlc3AudS5hY3Rpb24udS5zYV9xdWVyeV9yZXEudHJhbnNfaWQgKyBXTEFOX1NBX1FVRVJZX1RSX0lEX0xFTjsKIAlpZiAoaG9zdGFwZF9kcnZfc2VuZF9tbG1lKGhhcGQsICZyZXNwLCBlbmQgLSAodTggKikgJnJlc3AsIDApIDwgMCkKLQkJcGVycm9yKCJpZWVlODAyMTFfbWdtdF9zYV9xdWVyeV9yZXF1ZXN0OiBzZW5kIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJpZWVlODAyMTFfbWdtdF9zYV9xdWVyeV9yZXF1ZXN0OiBzZW5kIGZhaWxlZCIpOwogfQogCiAKQEAgLTE3MCw2ICsxNzAsOCBAQAogCiAJc3dpdGNoIChpZHgpIHsKIAljYXNlIDA6IC8qIEJpdHMgMC03ICovCisJCWlmIChoYXBkLT5pY29uZi0+b2Jzc19pbnRlcnZhbCkKKwkJCSpwb3MgfD0gMHgwMTsgLyogQml0IDAgLSBDb2V4aXN0ZW5jZSBtYW5hZ2VtZW50ICovCiAJCWJyZWFrOwogCWNhc2UgMTogLyogQml0cyA4LTE1ICovCiAJCWJyZWFrOwpAQCAtMTg5LDYgKzE5MSw4IEBACiAJCQkqcG9zIHw9IDB4ODA7IC8qIEJpdCAzMSAtIEludGVyd29ya2luZyAqLwogCQlicmVhazsKIAljYXNlIDQ6IC8qIEJpdHMgMzItMzkgKi8KKwkJaWYgKGhhcGQtPmNvbmYtPnFvc19tYXBfc2V0X2xlbikKKwkJCSpwb3MgfD0gMHgwMTsgLyogQml0IDMyIC0gUW9TIE1hcCAqLwogCQlpZiAoaGFwZC0+Y29uZi0+dGRscyAmIFRETFNfUFJPSElCSVQpCiAJCQkqcG9zIHw9IDB4NDA7IC8qIEJpdCAzOCAtIFRETFMgUHJvaGliaXRlZCAqLwogCQlpZiAoaGFwZC0+Y29uZi0+dGRscyAmIFRETFNfUFJPSElCSVRfQ0hBTl9TV0lUQ0gpIHsKQEAgLTE5Nyw2ICsyMDEsMTAgQEAKIAkJfQogCQlicmVhazsKIAljYXNlIDU6IC8qIEJpdHMgNDAtNDcgKi8KKyNpZmRlZiBDT05GSUdfSFMyMAorCQlpZiAoaGFwZC0+Y29uZi0+aHMyMCkKKwkJCSpwb3MgfD0gMHg0MDsgLyogQml0IDQ2IC0gV05NLU5vdGlmaWNhdGlvbiAqLworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJCWJyZWFrOwogCWNhc2UgNjogLyogQml0cyA0OC01NSAqLwogCQlpZiAoaGFwZC0+Y29uZi0+c3NpZC51dGY4X3NzaWQpCkBAIC0yMTcsMTIgKzIyNSwxOCBAQAogCQlsZW4gPSA0OwogCWlmIChsZW4gPCAzICYmIGhhcGQtPmNvbmYtPndubV9zbGVlcF9tb2RlKQogCQlsZW4gPSAzOworCWlmIChsZW4gPCAxICYmIGhhcGQtPmljb25mLT5vYnNzX2ludGVydmFsKQorCQlsZW4gPSAxOwogCWlmIChsZW4gPCA3ICYmIGhhcGQtPmNvbmYtPnNzaWQudXRmOF9zc2lkKQogCQlsZW4gPSA3OwogI2lmZGVmIENPTkZJR19XTk0KIAlpZiAobGVuIDwgNCkKIAkJbGVuID0gNDsKICNlbmRpZiAvKiBDT05GSUdfV05NICovCisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAoaGFwZC0+Y29uZi0+aHMyMCAmJiBsZW4gPCA2KQorCQlsZW4gPSA2OworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJaWYgKGxlbiA8IGhhcGQtPmlmYWNlLT5leHRlbmRlZF9jYXBhX2xlbikKIAkJbGVuID0gaGFwZC0+aWZhY2UtPmV4dGVuZGVkX2NhcGFfbGVuOwogCWlmIChsZW4gPT0gMCkKQEAgLTI1MCw2ICsyNjQsMjMgQEAKIH0KIAogCit1OCAqIGhvc3RhcGRfZWlkX3Fvc19tYXBfc2V0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpCit7CisJdTggKnBvcyA9IGVpZDsKKwl1OCBsZW4gPSBoYXBkLT5jb25mLT5xb3NfbWFwX3NldF9sZW47CisKKwlpZiAoIWxlbikKKwkJcmV0dXJuIGVpZDsKKworCSpwb3MrKyA9IFdMQU5fRUlEX1FPU19NQVBfU0VUOworCSpwb3MrKyA9IGxlbjsKKwlvc19tZW1jcHkocG9zLCBoYXBkLT5jb25mLT5xb3NfbWFwX3NldCwgbGVuKTsKKwlwb3MgKz0gbGVuOworCisJcmV0dXJuIHBvczsKK30KKworCiB1OCAqIGhvc3RhcGRfZWlkX2ludGVyd29ya2luZyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKQogewogCXU4ICpwb3MgPSBlaWQ7CmRpZmYgLS1naXQgYS9zcmMvYXAvaWVlZTgwMl8xMV92aHQuYyBiL3NyYy9hcC9pZWVlODAyXzExX3ZodC5jCmluZGV4IDAwMTJjMGYuLjQzN2NmNTAgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9pZWVlODAyXzExX3ZodC5jCisrKyBiL3NyYy9hcC9pZWVlODAyXzExX3ZodC5jCkBAIC0xMiw3ICsxMiw2IEBACiAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCi0jaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKICNpbmNsdWRlICJob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCiAjaW5jbHVkZSAic3RhX2luZm8uaCIKQEAgLTM1LDcgKzM0LDcgQEAKIAljYXAgPSAoc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzICopIHBvczsKIAlvc19tZW1zZXQoY2FwLCAwLCBzaXplb2YoKmNhcCkpOwogCWNhcC0+dmh0X2NhcGFiaWxpdGllc19pbmZvID0gaG9zdF90b19sZTMyKAotCQloYXBkLT5pZmFjZS0+Y3VycmVudF9tb2RlLT52aHRfY2FwYWIpOworCQloYXBkLT5pZmFjZS0+Y29uZi0+dmh0X2NhcGFiKTsKIAogCS8qIFN1cHBvcnRlZCBNQ1Mgc2V0IGNvbWVzIGZyb20gaHcgKi8KIAlvc19tZW1jcHkoJmNhcC0+dmh0X3N1cHBvcnRlZF9tY3Nfc2V0LApAQCAtMTA5LDEzICsxMDgsNzkgQEAKIAlyZXR1cm4gV0xBTl9TVEFUVVNfU1VDQ0VTUzsKIH0KIAorCit1MTYgc2V0X3N0YV92aHRfb3Btb2RlKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAorCQkgICAgICAgY29uc3QgdTggKnZodF9vcGVyX25vdGlmKQoreworCWlmICghdmh0X29wZXJfbm90aWYpIHsKKwkJc3RhLT5mbGFncyAmPSB+V0xBTl9TVEFfVkhUX09QTU9ERV9FTkFCTEVEOworCQlyZXR1cm4gV0xBTl9TVEFUVVNfU1VDQ0VTUzsKKwl9CisKKwlzdGEtPmZsYWdzIHw9IFdMQU5fU1RBX1ZIVF9PUE1PREVfRU5BQkxFRDsKKwlzdGEtPnZodF9vcG1vZGUgPSAqdmh0X29wZXJfbm90aWY7CisJcmV0dXJuIFdMQU5fU1RBVFVTX1NVQ0NFU1M7Cit9CisKKwogdm9pZCBob3N0YXBkX2dldF92aHRfY2FwYWIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKIAkJCSAgIHN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyAqdmh0X2NhcCwKIAkJCSAgIHN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyAqbmVnX3ZodF9jYXApCiB7CisJdTMyIGNhcCwgb3duX2NhcCwgc3ltX2NhcHM7CisKIAlpZiAodmh0X2NhcCA9PSBOVUxMKQogCQlyZXR1cm47CiAJb3NfbWVtY3B5KG5lZ192aHRfY2FwLCB2aHRfY2FwLCBzaXplb2YoKm5lZ192aHRfY2FwKSk7CiAKLQkvKiBUT0RPOiBtYXNrIG93biBjYXBhYmlsaXRpZXMsIGxpa2UgZ2V0X2h0X2NhcGFiKCkgKi8KKwljYXAgPSBsZV90b19ob3N0MzIobmVnX3ZodF9jYXAtPnZodF9jYXBhYmlsaXRpZXNfaW5mbyk7CisJb3duX2NhcCA9IGhhcGQtPmljb25mLT52aHRfY2FwYWI7CisKKwkvKiBtYXNrIG91dCBzeW1tZXRyaWMgVkhUIGNhcGFiaWxpdGllcyB3ZSBkb24ndCBzdXBwb3J0ICovCisJc3ltX2NhcHMgPSBWSFRfQ0FQX1NIT1JUX0dJXzgwIHwgVkhUX0NBUF9TSE9SVF9HSV8xNjA7CisJY2FwICY9IH5zeW1fY2FwcyB8IChvd25fY2FwICYgc3ltX2NhcHMpOworCisJLyogbWFzayBvdXQgYmVhbWZvcm1lci9iZWFtZm9ybWVlIGNhcHMgaWYgbm90IHN1cHBvcnRlZCAqLworCWlmICghKG93bl9jYXAgJiBWSFRfQ0FQX1NVX0JFQU1GT1JNRVJfQ0FQQUJMRSkpCisJCWNhcCAmPSB+KFZIVF9DQVBfU1VfQkVBTUZPUk1FRV9DQVBBQkxFIHwKKwkJCSBWSFRfQ0FQX0JFQU1GT1JNRUVfU1RTX01BWCk7CisKKwlpZiAoIShvd25fY2FwICYgVkhUX0NBUF9TVV9CRUFNRk9STUVFX0NBUEFCTEUpKQorCQljYXAgJj0gfihWSFRfQ0FQX1NVX0JFQU1GT1JNRVJfQ0FQQUJMRSB8CisJCQkgVkhUX0NBUF9TT1VORElOR19ESU1FTlNJT05fTUFYKTsKKworCWlmICghKG93bl9jYXAgJiBWSFRfQ0FQX01VX0JFQU1GT1JNRVJfQ0FQQUJMRSkpCisJCWNhcCAmPSB+VkhUX0NBUF9NVV9CRUFNRk9STUVFX0NBUEFCTEU7CisKKwlpZiAoIShvd25fY2FwICYgVkhUX0NBUF9NVV9CRUFNRk9STUVFX0NBUEFCTEUpKQorCQljYXAgJj0gflZIVF9DQVBfTVVfQkVBTUZPUk1FUl9DQVBBQkxFOworCisJLyogbWFzayBjaGFubmVsIHdpZHRocyB3ZSBkb24ndCBzdXBwb3J0ICovCisJc3dpdGNoIChvd25fY2FwICYgVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfTUFTSykgeworCWNhc2UgVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwXzgwUExVUzgwTUhaOgorCQlicmVhazsKKwljYXNlIFZIVF9DQVBfU1VQUF9DSEFOX1dJRFRIXzE2ME1IWjoKKwkJaWYgKGNhcCAmIFZIVF9DQVBfU1VQUF9DSEFOX1dJRFRIXzE2MF84MFBMVVM4ME1IWikgeworCQkJY2FwICY9IH5WSFRfQ0FQX1NVUFBfQ0hBTl9XSURUSF8xNjBfODBQTFVTODBNSFo7CisJCQljYXAgfD0gVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwTUhaOworCQl9CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWNhcCAmPSB+VkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfTUFTSzsKKwkJYnJlYWs7CisJfQorCisJaWYgKCEoY2FwICYgVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfTUFTSykpCisJCWNhcCAmPSB+VkhUX0NBUF9TSE9SVF9HSV8xNjA7CisKKwkvKgorCSAqIGlmIHdlIGRvbid0IHN1cHBvcnQgUlggU1RCQywgbWFzayBvdXQgVFggU1RCQyBpbiB0aGUgU1RBJ3MgSFQgY2FwcworCSAqIGlmIHdlIGRvbid0IHN1cHBvcnQgVFggU1RCQywgbWFzayBvdXQgUlggU1RCQyBpbiB0aGUgU1RBJ3MgSFQgY2FwcworCSAqLworCWlmICghKG93bl9jYXAgJiBWSFRfQ0FQX1JYU1RCQ19NQVNLKSkKKwkJY2FwICY9IH5WSFRfQ0FQX1RYU1RCQzsKKwlpZiAoIShvd25fY2FwICYgVkhUX0NBUF9UWFNUQkMpKQorCQljYXAgJj0gflZIVF9DQVBfUlhTVEJDX01BU0s7CisKKwluZWdfdmh0X2NhcC0+dmh0X2NhcGFiaWxpdGllc19pbmZvID0gaG9zdF90b19sZTMyKGNhcCk7CiB9CmRpZmYgLS1naXQgYS9zcmMvYXAvaWVlZTgwMl8xeC5jIGIvc3JjL2FwL2llZWU4MDJfMXguYwppbmRleCA5ODY3NTgxLi5lNDY4MWU5IDEwMDY0NAotLS0gYS9zcmMvYXAvaWVlZTgwMl8xeC5jCisrKyBiL3NyYy9hcC9pZWVlODAyXzF4LmMKQEAgLTI5LDExICsyOSwxNCBAQAogI2luY2x1ZGUgInBta3NhX2NhY2hlX2F1dGguaCIKICNpbmNsdWRlICJhcF9jb25maWcuaCIKICNpbmNsdWRlICJhcF9kcnZfb3BzLmgiCisjaW5jbHVkZSAid3BzX2hvc3RhcGQuaCIKKyNpbmNsdWRlICJoczIwLmgiCiAjaW5jbHVkZSAiaWVlZTgwMl8xeC5oIgogCiAKIHN0YXRpYyB2b2lkIGllZWU4MDJfMXhfZmluaXNoZWQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKLQkJCQlzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwgaW50IHN1Y2Nlc3MpOworCQkJCXN0cnVjdCBzdGFfaW5mbyAqc3RhLCBpbnQgc3VjY2VzcywKKwkJCQlpbnQgcmVtZWRpYXRpb24pOwogCiAKIHN0YXRpYyB2b2lkIGllZWU4MDJfMXhfc2VuZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKQEAgLTk2LDEyICs5OSwxMyBAQAogCX0KIAogCWlmIChyZXMgJiYgZXJybm8gIT0gRU5PRU5UKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IHNldCBzdGF0aW9uICIgTUFDU1RSICIgZmxhZ3MgZm9yIGtlcm5lbCAiCi0JCSAgICAgICAiZHJpdmVyIChlcnJubz0lZCkuXG4iLCBNQUMyU1RSKHN0YS0+YWRkciksIGVycm5vKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDb3VsZCBub3Qgc2V0IHN0YXRpb24gIiBNQUNTVFIKKwkJCSAgICIgZmxhZ3MgZm9yIGtlcm5lbCBkcml2ZXIgKGVycm5vPSVkKS4iLAorCQkJICAgTUFDMlNUUihzdGEtPmFkZHIpLCBlcnJubyk7CiAJfQogCiAJaWYgKGF1dGhvcml6ZWQpIHsKLQkJb3NfZ2V0X3RpbWUoJnN0YS0+Y29ubmVjdGVkX3RpbWUpOworCQlvc19nZXRfcmVsdGltZSgmc3RhLT5jb25uZWN0ZWRfdGltZSk7CiAJCWFjY291bnRpbmdfc3RhX3N0YXJ0KGhhcGQsIHN0YSk7CiAJfQogfQpAQCAtMzAyLDYgKzMwNiw2NyBAQAogfQogCiAKK3N0YXRpYyBpbnQgYWRkX2NvbW1vbl9yYWRpdXNfc3RhX2F0dHJfcnNuKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKnJlcV9hdHRyLAorCQkJCQkgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAorCQkJCQkgIHN0cnVjdCByYWRpdXNfbXNnICptc2cpCit7CisJdTMyIHN1aXRlOworCWludCB2ZXIsIHZhbDsKKworCXZlciA9IHdwYV9hdXRoX3N0YV93cGFfdmVyc2lvbihzdGEtPndwYV9zbSk7CisJdmFsID0gd3BhX2F1dGhfZ2V0X3BhaXJ3aXNlKHN0YS0+d3BhX3NtKTsKKwlzdWl0ZSA9IHdwYV9jaXBoZXJfdG9fc3VpdGUodmVyLCB2YWwpOworCWlmICh2YWwgIT0gLTEgJiYKKwkgICAgIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihyZXFfYXR0ciwKKwkJCQkJICAgIFJBRElVU19BVFRSX1dMQU5fUEFJUldJU0VfQ0lQSEVSKSAmJgorCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihtc2csIFJBRElVU19BVFRSX1dMQU5fUEFJUldJU0VfQ0lQSEVSLAorCQkJCSAgICAgICBzdWl0ZSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3QgYWRkIFdMQU4tUGFpcndpc2UtQ2lwaGVyIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlzdWl0ZSA9IHdwYV9jaXBoZXJfdG9fc3VpdGUoKGhhcGQtPmNvbmYtPndwYSAmIDB4MikgPworCQkJCSAgICBXUEFfUFJPVE9fUlNOIDogV1BBX1BST1RPX1dQQSwKKwkJCQkgICAgaGFwZC0+Y29uZi0+d3BhX2dyb3VwKTsKKwlpZiAoIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihyZXFfYXR0ciwKKwkJCQkJICAgIFJBRElVU19BVFRSX1dMQU5fR1JPVVBfQ0lQSEVSKSAmJgorCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihtc2csIFJBRElVU19BVFRSX1dMQU5fR1JPVVBfQ0lQSEVSLAorCQkJCSAgICAgICBzdWl0ZSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3QgYWRkIFdMQU4tR3JvdXAtQ2lwaGVyIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl2YWwgPSB3cGFfYXV0aF9zdGFfa2V5X21nbXQoc3RhLT53cGFfc20pOworCXN1aXRlID0gd3BhX2FrbV90b19zdWl0ZSh2YWwpOworCWlmICh2YWwgIT0gLTEgJiYKKwkgICAgIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihyZXFfYXR0ciwKKwkJCQkJICAgIFJBRElVU19BVFRSX1dMQU5fQUtNX1NVSVRFKSAmJgorCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihtc2csIFJBRElVU19BVFRSX1dMQU5fQUtNX1NVSVRFLAorCQkJCSAgICAgICBzdWl0ZSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3QgYWRkIFdMQU4tQUtNLVN1aXRlIik7CisJCXJldHVybiAtMTsKKwl9CisKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExVworCWlmIChoYXBkLT5jb25mLT5pZWVlODAyMTF3ICE9IE5PX01HTVRfRlJBTUVfUFJPVEVDVElPTikgeworCQlzdWl0ZSA9IHdwYV9jaXBoZXJfdG9fc3VpdGUoV1BBX1BST1RPX1JTTiwKKwkJCQkJICAgIGhhcGQtPmNvbmYtPmdyb3VwX21nbXRfY2lwaGVyKTsKKwkJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoCisJCQkgICAgcmVxX2F0dHIsIFJBRElVU19BVFRSX1dMQU5fR1JPVVBfTUdNVF9DSVBIRVIpICYmCisJCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMigKKwkJCSAgICBtc2csIFJBRElVU19BVFRSX1dMQU5fR1JPVVBfTUdNVF9DSVBIRVIsIHN1aXRlKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkNvdWxkIG5vdCBhZGQgV0xBTi1Hcm91cC1NZ210LUNpcGhlciIpOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCisKKwlyZXR1cm4gMDsKK30KKworCiBzdGF0aWMgaW50IGFkZF9jb21tb25fcmFkaXVzX3N0YV9hdHRyKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJICAgICAgc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKnJlcV9hdHRyLAogCQkJCSAgICAgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLApAQCAtMzUzLDYgKzQxOCwyNSBAQAogCQl9CiAJfQogCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKKwlpZiAoaGFwZC0+Y29uZi0+d3BhICYmIHdwYV9rZXlfbWdtdF9mdChoYXBkLT5jb25mLT53cGFfa2V5X21nbXQpICYmCisJICAgIHN0YS0+d3BhX3NtICYmCisJICAgICh3cGFfa2V5X21nbXRfZnQod3BhX2F1dGhfc3RhX2tleV9tZ210KHN0YS0+d3BhX3NtKSkgfHwKKwkgICAgIHN0YS0+YXV0aF9hbGcgPT0gV0xBTl9BVVRIX0ZUKSAmJgorCSAgICAhaG9zdGFwZF9jb25maWdfZ2V0X3JhZGl1c19hdHRyKHJlcV9hdHRyLAorCQkJCQkgICAgUkFESVVTX0FUVFJfTU9CSUxJVFlfRE9NQUlOX0lEKSAmJgorCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihtc2csIFJBRElVU19BVFRSX01PQklMSVRZX0RPTUFJTl9JRCwKKwkJCQkgICAgICAgV1BBX0dFVF9CRTE2KAorCQkJCQkgICAgICAgaGFwZC0+Y29uZi0+bW9iaWxpdHlfZG9tYWluKSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3QgYWRkIE1vYmlsaXR5LURvbWFpbi1JZCIpOworCQlyZXR1cm4gLTE7CisJfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCisKKwlpZiAoaGFwZC0+Y29uZi0+d3BhICYmIHN0YS0+d3BhX3NtICYmCisJICAgIGFkZF9jb21tb25fcmFkaXVzX3N0YV9hdHRyX3JzbihoYXBkLCByZXFfYXR0ciwgc3RhLCBtc2cpIDwgMCkKKwkJcmV0dXJuIC0xOworCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTQxNiw2ICs1MDAsMjIgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAorI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKwlpZiAoaGFwZC0+Y29uZi0+aW50ZXJ3b3JraW5nICYmCisJICAgICFpc196ZXJvX2V0aGVyX2FkZHIoaGFwZC0+Y29uZi0+aGVzc2lkKSkgeworCQlvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLCBSQURJVVNfODAyXzFYX0FERFJfRk9STUFULAorCQkJICAgIE1BQzJTVFIoaGFwZC0+Y29uZi0+aGVzc2lkKSk7CisJCWJ1ZltzaXplb2YoYnVmKSAtIDFdID0gJ1wwJzsKKwkJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIocmVxX2F0dHIsCisJCQkJCQkgICAgUkFESVVTX0FUVFJfV0xBTl9IRVNTSUQpICYmCisJCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX1dMQU5fSEVTU0lELAorCQkJCQkgKHU4ICopIGJ1Ziwgb3Nfc3RybGVuKGJ1ZikpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCBhZGQgV0xBTi1IRVNTSUQiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KKyNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCisKIAlpZiAoc3RhICYmIGFkZF9jb21tb25fcmFkaXVzX3N0YV9hdHRyKGhhcGQsIHJlcV9hdHRyLCBzdGEsIG1zZykgPCAwKQogCQlyZXR1cm4gLTE7CiAKQEAgLTQ1Miw3ICs1NTIsNyBAQAogCW1zZyA9IHJhZGl1c19tc2dfbmV3KFJBRElVU19DT0RFX0FDQ0VTU19SRVFVRVNULAogCQkJICAgICBzbS0+cmFkaXVzX2lkZW50aWZpZXIpOwogCWlmIChtc2cgPT0gTlVMTCkgewotCQlwcmludGYoIkNvdWxkIG5vdCBjcmVhdGUgbmV0IFJBRElVUyBwYWNrZXRcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGNyZWF0ZSBuZXcgUkFESVVTIHBhY2tldCIpOwogCQlyZXR1cm47CiAJfQogCkBAIC00NjEsNyArNTYxLDcgQEAKIAlpZiAoc20tPmlkZW50aXR5ICYmCiAJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgUkFESVVTX0FUVFJfVVNFUl9OQU1FLAogCQkJCSBzbS0+aWRlbnRpdHksIHNtLT5pZGVudGl0eV9sZW4pKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IGFkZCBVc2VyLU5hbWVcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBVc2VyLU5hbWUiKTsKIAkJZ290byBmYWlsOwogCX0KIApAQCAtNDc1LDEyICs1NzUsMTIgQEAKIAlpZiAoIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihoYXBkLT5jb25mLT5yYWRpdXNfYXV0aF9yZXFfYXR0ciwKIAkJCQkJICAgIFJBRElVU19BVFRSX0ZSQU1FRF9NVFUpICYmCiAJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyX2ludDMyKG1zZywgUkFESVVTX0FUVFJfRlJBTUVEX01UVSwgMTQwMCkpIHsKLQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIEZyYW1lZC1NVFVcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ291bGQgbm90IGFkZCBGcmFtZWQtTVRVIik7CiAJCWdvdG8gZmFpbDsKIAl9CiAKIAlpZiAoZWFwICYmICFyYWRpdXNfbXNnX2FkZF9lYXAobXNnLCBlYXAsIGxlbikpIHsKLQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIEVBUC1NZXNzYWdlXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBhZGQgRUFQLU1lc3NhZ2UiKTsKIAkJZ290byBmYWlsOwogCX0KIApAQCAtNDkyLDggKzU5Miw3IEBACiAJCWludCByZXMgPSByYWRpdXNfbXNnX2NvcHlfYXR0cihtc2csIHNtLT5sYXN0X3JlY3ZfcmFkaXVzLAogCQkJCQkgICAgICAgUkFESVVTX0FUVFJfU1RBVEUpOwogCQlpZiAocmVzIDwgMCkgewotCQkJcHJpbnRmKCJDb3VsZCBub3QgY29weSBTdGF0ZSBhdHRyaWJ1dGUgZnJvbSBwcmV2aW91cyAiCi0JCQkgICAgICAgIkFjY2Vzcy1DaGFsbGVuZ2VcbiIpOworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBjb3B5IFN0YXRlIGF0dHJpYnV0ZSBmcm9tIHByZXZpb3VzIEFjY2Vzcy1DaGFsbGVuZ2UiKTsKIAkJCWdvdG8gZmFpbDsKIAkJfQogCQlpZiAocmVzID4gMCkgewpAQCAtNTIwLDYgKzYxOSw0MSBAQAogCQl9CiAJfQogCisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAoaGFwZC0+Y29uZi0+aHMyMCkgeworCQl1OCB2ZXIgPSAxOyAvKiBSZWxlYXNlIDIgKi8KKwkJaWYgKCFyYWRpdXNfbXNnX2FkZF93ZmEoCisJCQkgICAgbXNnLCBSQURJVVNfVkVORE9SX0FUVFJfV0ZBX0hTMjBfQVBfVkVSU0lPTiwKKwkJCSAgICAmdmVyLCAxKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3QgYWRkIEhTIDIuMCBBUCAiCisJCQkJICAgInZlcnNpb24iKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCisJCWlmIChzdGEtPmhzMjBfaWUgJiYgd3BhYnVmX2xlbihzdGEtPmhzMjBfaWUpID4gMCkgeworCQkJY29uc3QgdTggKnBvczsKKwkJCXU4IGJ1ZlszXTsKKwkJCXUxNiBpZDsKKwkJCXBvcyA9IHdwYWJ1Zl9oZWFkX3U4KHN0YS0+aHMyMF9pZSk7CisJCQlidWZbMF0gPSAoKnBvcykgPj4gNDsKKwkJCWlmICgoKCpwb3MpICYgSFMyMF9QUFNfTU9fSURfUFJFU0VOVCkgJiYKKwkJCSAgICB3cGFidWZfbGVuKHN0YS0+aHMyMF9pZSkgPj0gMykKKwkJCQlpZCA9IFdQQV9HRVRfTEUxNihwb3MgKyAxKTsKKwkJCWVsc2UKKwkJCQlpZCA9IDA7CisJCQlXUEFfUFVUX0JFMTYoYnVmICsgMSwgaWQpOworCQkJaWYgKCFyYWRpdXNfbXNnX2FkZF93ZmEoCisJCQkJICAgIG1zZywKKwkJCQkgICAgUkFESVVTX1ZFTkRPUl9BVFRSX1dGQV9IUzIwX1NUQV9WRVJTSU9OLAorCQkJCSAgICBidWYsIHNpemVvZihidWYpKSkgeworCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ291bGQgbm90IGFkZCBIUyAyLjAgIgorCQkJCQkgICAiU1RBIHZlcnNpb24iKTsKKwkJCQlnb3RvIGZhaWw7CisJCQl9CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogCWlmIChyYWRpdXNfY2xpZW50X3NlbmQoaGFwZC0+cmFkaXVzLCBtc2csIFJBRElVU19BVVRILCBzdGEtPmFkZHIpIDwgMCkKIAkJZ290byBmYWlsOwogCkBAIC01NDMsNyArNjc3LDcgQEAKIAlkYXRhID0gKHU4ICopIChlYXAgKyAxKTsKIAogCWlmIChsZW4gPCBzaXplb2YoKmVhcCkgKyAxKSB7Ci0JCXByaW50ZigiaGFuZGxlX2VhcF9yZXNwb25zZTogdG9vIHNob3J0IHJlc3BvbnNlIGRhdGFcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiaGFuZGxlX2VhcF9yZXNwb25zZTogdG9vIHNob3J0IHJlc3BvbnNlIGRhdGEiKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtNTcxLDcgKzcwNSw3IEBACiAJdTE2IGVhcF9sZW47CiAKIAlpZiAobGVuIDwgc2l6ZW9mKCplYXApKSB7Ci0JCXByaW50ZigiICAgdG9vIHNob3J0IEVBUCBwYWNrZXRcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiICAgdG9vIHNob3J0IEVBUCBwYWNrZXQiKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtNjQ5LDcgKzc4Myw3IEBACiAJc3RydWN0IHJzbl9wbWtzYV9jYWNoZV9lbnRyeSAqcG1rc2E7CiAJaW50IGtleV9tZ210OwogCi0JaWYgKCFoYXBkLT5jb25mLT5pZWVlODAyXzF4ICYmICFoYXBkLT5jb25mLT53cGEgJiYKKwlpZiAoIWhhcGQtPmNvbmYtPmllZWU4MDJfMXggJiYgIWhhcGQtPmNvbmYtPndwYSAmJiAhaGFwZC0+Y29uZi0+b3NlbiAmJgogCSAgICAhaGFwZC0+Y29uZi0+d3BzX3N0YXRlKQogCQlyZXR1cm47CiAKQEAgLTY2NCw3ICs3OTgsNyBAQAogCX0KIAogCWlmIChsZW4gPCBzaXplb2YoKmhkcikpIHsKLQkJcHJpbnRmKCIgICB0b28gc2hvcnQgSUVFRSA4MDIuMVggcGFja2V0XG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIiAgIHRvbyBzaG9ydCBJRUVFIDgwMi4xWCBwYWNrZXQiKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtNjc0LDcgKzgwOCw3IEBACiAJCSAgIGhkci0+dmVyc2lvbiwgaGRyLT50eXBlLCBkYXRhbGVuKTsKIAogCWlmIChsZW4gLSBzaXplb2YoKmhkcikgPCBkYXRhbGVuKSB7Ci0JCXByaW50ZigiICAgZnJhbWUgdG9vIHNob3J0IGZvciB0aGlzIElFRUUgODAyLjFYIHBhY2tldFxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICIgICBmcmFtZSB0b28gc2hvcnQgZm9yIHRoaXMgSUVFRSA4MDIuMVggcGFja2V0Iik7CiAJCWlmIChzdGEtPmVhcG9sX3NtKQogCQkJc3RhLT5lYXBvbF9zbS0+ZG90MXhBdXRoRWFwTGVuZ3RoRXJyb3JGcmFtZXNSeCsrOwogCQlyZXR1cm47CkBAIC03MDAsNyArODM0LDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCWlmICghaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCAmJgorCWlmICghaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCAmJiAhaGFwZC0+Y29uZi0+b3NlbiAmJgogCSAgICAhKHN0YS0+ZmxhZ3MgJiAoV0xBTl9TVEFfV1BTIHwgV0xBTl9TVEFfTUFZQkVfV1BTKSkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJRUVFIDgwMi4xWDogSWdub3JlIEVBUE9MIG1lc3NhZ2UgLSAiCiAJCQkgICAiODAyLjFYIG5vdCBlbmFibGVkIGFuZCBXUFMgbm90IHVzZWQiKTsKQEAgLTcyMCw3ICs4NTQsNyBAQAogCQkJcmV0dXJuOwogCiAjaWZkZWYgQ09ORklHX1dQUwotCQlpZiAoIWhhcGQtPmNvbmYtPmllZWU4MDJfMXgpIHsKKwkJaWYgKCFoYXBkLT5jb25mLT5pZWVlODAyXzF4ICYmIGhhcGQtPmNvbmYtPndwc19zdGF0ZSkgewogCQkJdTMyIHdmbGFncyA9IHN0YS0+ZmxhZ3MgJiAoV0xBTl9TVEFfV1BTIHwKIAkJCQkJCSAgIFdMQU5fU1RBX1dQUzIgfAogCQkJCQkJICAgV0xBTl9TVEFfTUFZQkVfV1BTKTsKQEAgLTgzOCw3ICs5NzIsNyBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAKLQlpZiAoIWZvcmNlXzF4ICYmICFoYXBkLT5jb25mLT5pZWVlODAyXzF4KSB7CisJaWYgKCFmb3JjZV8xeCAmJiAhaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCAmJiAhaGFwZC0+Y29uZi0+b3NlbikgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIklFRUUgODAyLjFYOiBJZ25vcmUgU1RBIC0gIgogCQkJICAgIjgwMi4xWCBub3QgZW5hYmxlZCBvciBmb3JjZWQgZm9yIFdQUyIpOwogCQkvKgpAQCAtODc2LDcgKzEwMTAsOCBAQAogCiAjaWZkZWYgQ09ORklHX1dQUwogCXN0YS0+ZWFwb2xfc20tPmZsYWdzICY9IH5FQVBPTF9TTV9XQUlUX1NUQVJUOwotCWlmICghaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCAmJiAhKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9XUFMyKSkgeworCWlmICghaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCAmJiBoYXBkLT5jb25mLT53cHNfc3RhdGUgJiYKKwkgICAgIShzdGEtPmZsYWdzICYgV0xBTl9TVEFfV1BTMikpIHsKIAkJLyoKIAkJICogRGVsYXkgRUFQT0wgZnJhbWUgdHJhbnNtaXNzaW9uIHVudGlsIGEgcG9zc2libGUgV1BTIFNUQQogCQkgKiBpbml0aWF0ZXMgdGhlIGhhbmRzaGFrZSB3aXRoIEVBUE9MLVN0YXJ0LiBPbmx5IGFsbG93IHRoZQpAQCAtMTIwMiw2ICsxMzM3LDE0NyBAQAogfQogCiAKKyNpZmRlZiBDT05GSUdfSFMyMAorCitzdGF0aWMgdm9pZCBpZWVlODAyXzF4X2hzMjBfc3ViX3JlbShzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwgdTggKnBvcywgc2l6ZV90IGxlbikKK3sKKwlzdGEtPnJlbWVkaWF0aW9uID0gMTsKKwlvc19mcmVlKHN0YS0+cmVtZWRpYXRpb25fdXJsKTsKKwlpZiAobGVuID4gMikgeworCQlzdGEtPnJlbWVkaWF0aW9uX3VybCA9IG9zX21hbGxvYyhsZW4pOworCQlpZiAoIXN0YS0+cmVtZWRpYXRpb25fdXJsKQorCQkJcmV0dXJuOworCQlzdGEtPnJlbWVkaWF0aW9uX21ldGhvZCA9IHBvc1swXTsKKwkJb3NfbWVtY3B5KHN0YS0+cmVtZWRpYXRpb25fdXJsLCBwb3MgKyAxLCBsZW4gLSAxKTsKKwkJc3RhLT5yZW1lZGlhdGlvbl91cmxbbGVuIC0gMV0gPSAnXDAnOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogU3Vic2NyaXB0aW9uIHJlbWVkaWF0aW9uIG5lZWRlZCAiCisJCQkgICAiZm9yICIgTUFDU1RSICIgLSBzZXJ2ZXIgbWV0aG9kICV1IFVSTCAlcyIsCisJCQkgICBNQUMyU1RSKHN0YS0+YWRkciksIHN0YS0+cmVtZWRpYXRpb25fbWV0aG9kLAorCQkJICAgc3RhLT5yZW1lZGlhdGlvbl91cmwpOworCX0gZWxzZSB7CisJCXN0YS0+cmVtZWRpYXRpb25fdXJsID0gTlVMTDsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IFN1YnNjcmlwdGlvbiByZW1lZGlhdGlvbiBuZWVkZWQgIgorCQkJICAgImZvciAiIE1BQ1NUUiwgTUFDMlNUUihzdGEtPmFkZHIpKTsKKwl9CisJLyogVE9ETzogYXNzaWduIHRoZSBTVEEgaW50byByZW1lZGlhdGlvbiBWTEFOIG9yIGFkZCBmaWx0ZXJpbmcgKi8KK30KKworCitzdGF0aWMgdm9pZCBpZWVlODAyXzF4X2hzMjBfZGVhdXRoX3JlcShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgICAgICBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwgdTggKnBvcywKKwkJCQkgICAgICAgc2l6ZV90IGxlbikKK3sKKwlpZiAobGVuIDwgMykKKwkJcmV0dXJuOyAvKiBNYWxmb3JtZWQgaW5mb3JtYXRpb24gKi8KKwlzdGEtPmhzMjBfZGVhdXRoX3JlcXVlc3RlZCA9IDE7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IERlYXV0aGVudGljYXRpb24gcmVxdWVzdCAtIENvZGUgJXUgICIKKwkJICAgIlJlLWF1dGggRGVsYXkgJXUiLAorCQkgICAqcG9zLCBXUEFfR0VUX0xFMTYocG9zICsgMSkpOworCXdwYWJ1Zl9mcmVlKHN0YS0+aHMyMF9kZWF1dGhfcmVxKTsKKwlzdGEtPmhzMjBfZGVhdXRoX3JlcSA9IHdwYWJ1Zl9hbGxvYyhsZW4gKyAxKTsKKwlpZiAoc3RhLT5oczIwX2RlYXV0aF9yZXEpIHsKKwkJd3BhYnVmX3B1dF9kYXRhKHN0YS0+aHMyMF9kZWF1dGhfcmVxLCBwb3MsIDMpOworCQl3cGFidWZfcHV0X3U4KHN0YS0+aHMyMF9kZWF1dGhfcmVxLCBsZW4gLSAzKTsKKwkJd3BhYnVmX3B1dF9kYXRhKHN0YS0+aHMyMF9kZWF1dGhfcmVxLCBwb3MgKyAzLCBsZW4gLSAzKTsKKwl9CisJYXBfc3RhX3Nlc3Npb25fdGltZW91dChoYXBkLCBzdGEsIGhhcGQtPmNvbmYtPmhzMjBfZGVhdXRoX3JlcV90aW1lb3V0KTsKK30KKworCitzdGF0aWMgdm9pZCBpZWVlODAyXzF4X2hzMjBfc2Vzc2lvbl9pbmZvKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwgdTggKnBvcywKKwkJCQkJIHNpemVfdCBsZW4sIGludCBzZXNzaW9uX3RpbWVvdXQpCit7CisJdW5zaWduZWQgaW50IHN3dDsKKwlpbnQgd2FybmluZ190aW1lLCBiZWFjb25faW50OworCisJaWYgKGxlbiA8IDEpCisJCXJldHVybjsgLyogTWFsZm9ybWVkIGluZm9ybWF0aW9uICovCisJb3NfZnJlZShzdGEtPmhzMjBfc2Vzc2lvbl9pbmZvX3VybCk7CisJc3RhLT5oczIwX3Nlc3Npb25faW5mb191cmwgPSBvc19tYWxsb2MobGVuKTsKKwlpZiAoc3RhLT5oczIwX3Nlc3Npb25faW5mb191cmwgPT0gTlVMTCkKKwkJcmV0dXJuOworCXN3dCA9IHBvc1swXTsKKwlvc19tZW1jcHkoc3RhLT5oczIwX3Nlc3Npb25faW5mb191cmwsIHBvcyArIDEsIGxlbiAtIDEpOworCXN0YS0+aHMyMF9zZXNzaW9uX2luZm9fdXJsW2xlbiAtIDFdID0gJ1wwJzsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogU2Vzc2lvbiBJbmZvcm1hdGlvbiBVUkw9JyVzJyBTV1Q9JXUgIgorCQkgICAiKHNlc3Npb25fdGltZW91dD0lZCkiLAorCQkgICBzdGEtPmhzMjBfc2Vzc2lvbl9pbmZvX3VybCwgc3d0LCBzZXNzaW9uX3RpbWVvdXQpOworCWlmIChzZXNzaW9uX3RpbWVvdXQgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBObyBTZXNzaW9uLVRpbWVvdXQgc2V0IC0gaWdub3JlIHNlc3Npb24gaW5mbyBVUkwiKTsKKwkJcmV0dXJuOworCX0KKwlpZiAoc3d0ID09IDI1NSkKKwkJc3d0ID0gMTsgLyogVXNlIG9uZSBtaW51dGUgYXMgdGhlIEFQIHNlbGVjdGVkIHZhbHVlICovCisKKwlpZiAoKHVuc2lnbmVkIGludCkgc2Vzc2lvbl90aW1lb3V0IDwgc3d0ICogNjApCisJCXdhcm5pbmdfdGltZSA9IDA7CisJZWxzZQorCQl3YXJuaW5nX3RpbWUgPSBzZXNzaW9uX3RpbWVvdXQgLSBzd3QgKiA2MDsKKworCWJlYWNvbl9pbnQgPSBoYXBkLT5pY29uZi0+YmVhY29uX2ludDsKKwlpZiAoYmVhY29uX2ludCA8IDEpCisJCWJlYWNvbl9pbnQgPSAxMDA7IC8qIGJlc3QgZ3Vlc3MgKi8KKwlzdGEtPmhzMjBfZGlzYXNzb2NfdGltZXIgPSBzd3QgKiA2MCAqIDEwMDAgLyBiZWFjb25faW50ICogMTI1IC8gMTI4OworCWlmIChzdGEtPmhzMjBfZGlzYXNzb2NfdGltZXIgPiA2NTUzNSkKKwkJc3RhLT5oczIwX2Rpc2Fzc29jX3RpbWVyID0gNjU1MzU7CisKKwlhcF9zdGFfc2Vzc2lvbl93YXJuaW5nX3RpbWVvdXQoaGFwZCwgc3RhLCB3YXJuaW5nX3RpbWUpOworfQorCisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKworCitzdGF0aWMgdm9pZCBpZWVlODAyXzF4X2NoZWNrX2hzMjAoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAorCQkJCSAgc3RydWN0IHJhZGl1c19tc2cgKm1zZywKKwkJCQkgIGludCBzZXNzaW9uX3RpbWVvdXQpCit7CisjaWZkZWYgQ09ORklHX0hTMjAKKwl1OCAqYnVmLCAqcG9zLCAqZW5kLCB0eXBlLCBzdWJsZW47CisJc2l6ZV90IGxlbjsKKworCWJ1ZiA9IE5VTEw7CisJc3RhLT5yZW1lZGlhdGlvbiA9IDA7CisJc3RhLT5oczIwX2RlYXV0aF9yZXF1ZXN0ZWQgPSAwOworCisJZm9yICg7OykgeworCQlpZiAocmFkaXVzX21zZ19nZXRfYXR0cl9wdHIobXNnLCBSQURJVVNfQVRUUl9WRU5ET1JfU1BFQ0lGSUMsCisJCQkJCSAgICAmYnVmLCAmbGVuLCBidWYpIDwgMCkKKwkJCWJyZWFrOworCQlpZiAobGVuIDwgNikKKwkJCWNvbnRpbnVlOworCQlwb3MgPSBidWY7CisJCWVuZCA9IGJ1ZiArIGxlbjsKKwkJaWYgKFdQQV9HRVRfQkUzMihwb3MpICE9IFJBRElVU19WRU5ET1JfSURfV0ZBKQorCQkJY29udGludWU7CisJCXBvcyArPSA0OworCisJCXR5cGUgPSAqcG9zKys7CisJCXN1YmxlbiA9ICpwb3MrKzsKKwkJaWYgKHN1YmxlbiA8IDIpCisJCQljb250aW51ZTsgLyogaW52YWxpZCBsZW5ndGggKi8KKwkJc3VibGVuIC09IDI7IC8qIHNraXAgaGVhZGVyICovCisJCWlmIChwb3MgKyBzdWJsZW4gPiBlbmQpCisJCQljb250aW51ZTsgLyogaW52YWxpZCBXRkEgVlNBICovCisKKwkJc3dpdGNoICh0eXBlKSB7CisJCWNhc2UgUkFESVVTX1ZFTkRPUl9BVFRSX1dGQV9IUzIwX1NVQlNDUl9SRU1FRElBVElPTjoKKwkJCWllZWU4MDJfMXhfaHMyMF9zdWJfcmVtKHN0YSwgcG9zLCBzdWJsZW4pOworCQkJYnJlYWs7CisJCWNhc2UgUkFESVVTX1ZFTkRPUl9BVFRSX1dGQV9IUzIwX0RFQVVUSF9SRVE6CisJCQlpZWVlODAyXzF4X2hzMjBfZGVhdXRoX3JlcShoYXBkLCBzdGEsIHBvcywgc3VibGVuKTsKKwkJCWJyZWFrOworCQljYXNlIFJBRElVU19WRU5ET1JfQVRUUl9XRkFfSFMyMF9TRVNTSU9OX0lORk9fVVJMOgorCQkJaWVlZTgwMl8xeF9oczIwX3Nlc3Npb25faW5mbyhoYXBkLCBzdGEsIHBvcywgc3VibGVuLAorCQkJCQkJICAgICBzZXNzaW9uX3RpbWVvdXQpOworCQkJYnJlYWs7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KK30KKworCiBzdHJ1Y3Qgc3RhX2lkX3NlYXJjaCB7CiAJdTggaWRlbnRpZmllcjsKIAlzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqc207CkBAIC0xMjc2LDE1ICsxNTUyLDE0IEBACiAJCQkgICAiRUFQLU1lc3NhZ2UiKTsKIAl9IGVsc2UgaWYgKHJhZGl1c19tc2dfdmVyaWZ5KG1zZywgc2hhcmVkX3NlY3JldCwgc2hhcmVkX3NlY3JldF9sZW4sCiAJCQkJICAgICByZXEsIDEpKSB7Ci0JCXByaW50ZigiSW5jb21pbmcgUkFESVVTIHBhY2tldCBkaWQgbm90IGhhdmUgY29ycmVjdCAiCi0JCSAgICAgICAiTWVzc2FnZS1BdXRoZW50aWNhdG9yIC0gZHJvcHBlZFxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbmNvbWluZyBSQURJVVMgcGFja2V0IGRpZCBub3QgaGF2ZSBjb3JyZWN0IE1lc3NhZ2UtQXV0aGVudGljYXRvciAtIGRyb3BwZWQiKTsKIAkJcmV0dXJuIFJBRElVU19SWF9JTlZBTElEX0FVVEhFTlRJQ0FUT1I7CiAJfQogCiAJaWYgKGhkci0+Y29kZSAhPSBSQURJVVNfQ09ERV9BQ0NFU1NfQUNDRVBUICYmCiAJICAgIGhkci0+Y29kZSAhPSBSQURJVVNfQ09ERV9BQ0NFU1NfUkVKRUNUICYmCiAJICAgIGhkci0+Y29kZSAhPSBSQURJVVNfQ09ERV9BQ0NFU1NfQ0hBTExFTkdFKSB7Ci0JCXByaW50ZigiVW5rbm93biBSQURJVVMgbWVzc2FnZSBjb2RlXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlVua25vd24gUkFESVVTIG1lc3NhZ2UgY29kZSIpOwogCQlyZXR1cm4gUkFESVVTX1JYX1VOS05PV047CiAJfQogCkBAIC0xMzYxLDcgKzE2MzYsMTEgQEAKIAkJaWVlZTgwMl8xeF9zdG9yZV9yYWRpdXNfY2xhc3MoaGFwZCwgc3RhLCBtc2cpOwogCQlpZWVlODAyXzF4X3VwZGF0ZV9zdGFfaWRlbnRpdHkoaGFwZCwgc3RhLCBtc2cpOwogCQlpZWVlODAyXzF4X3VwZGF0ZV9zdGFfY3VpKGhhcGQsIHN0YSwgbXNnKTsKLQkJaWYgKHNtLT5lYXBfaWYtPmVhcEtleUF2YWlsYWJsZSAmJgorCQlpZWVlODAyXzF4X2NoZWNrX2hzMjAoaGFwZCwgc3RhLCBtc2csCisJCQkJICAgICAgc2Vzc2lvbl90aW1lb3V0X3NldCA/CisJCQkJICAgICAgKGludCkgc2Vzc2lvbl90aW1lb3V0IDogLTEpOworCQlpZiAoc20tPmVhcF9pZi0+ZWFwS2V5QXZhaWxhYmxlICYmICFzdGEtPnJlbWVkaWF0aW9uICYmCisJCSAgICAhc3RhLT5oczIwX2RlYXV0aF9yZXF1ZXN0ZWQgJiYKIAkJICAgIHdwYV9hdXRoX3Bta3NhX2FkZChzdGEtPndwYV9zbSwgc20tPmVhcG9sX2tleV9jcnlwdCwKIAkJCQkgICAgICAgc2Vzc2lvbl90aW1lb3V0X3NldCA/CiAJCQkJICAgICAgIChpbnQpIHNlc3Npb25fdGltZW91dCA6IC0xLCBzbSkgPT0gMCkgewpAQCAtMTQ0OCw3ICsxNzI3LDcgQEAKIAlpZiAoZWFwb2wtPmRlZmF1bHRfd2VwX2tleSA9PSBOVUxMIHx8CiAJICAgIHJhbmRvbV9nZXRfYnl0ZXMoZWFwb2wtPmRlZmF1bHRfd2VwX2tleSwKIAkJCSAgICAgaGFwZC0+Y29uZi0+ZGVmYXVsdF93ZXBfa2V5X2xlbikpIHsKLQkJcHJpbnRmKCJDb3VsZCBub3QgZ2VuZXJhdGUgcmFuZG9tIFdFUCBrZXkuXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNvdWxkIG5vdCBnZW5lcmF0ZSByYW5kb20gV0VQIGtleSIpOwogCQlvc19mcmVlKGVhcG9sLT5kZWZhdWx0X3dlcF9rZXkpOwogCQllYXBvbC0+ZGVmYXVsdF93ZXBfa2V5ID0gTlVMTDsKIAkJcmV0dXJuIC0xOwpAQCAtMTU2NCwxNCArMTg0MywxNCBAQAogCiAKIHN0YXRpYyB2b2lkIF9pZWVlODAyXzF4X2ZpbmlzaGVkKHZvaWQgKmN0eCwgdm9pZCAqc3RhX2N0eCwgaW50IHN1Y2Nlc3MsCi0JCQkJIGludCBwcmVhdXRoKQorCQkJCSBpbnQgcHJlYXV0aCwgaW50IHJlbWVkaWF0aW9uKQogewogCXN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQgPSBjdHg7CiAJc3RydWN0IHN0YV9pbmZvICpzdGEgPSBzdGFfY3R4OwogCWlmIChwcmVhdXRoKQogCQlyc25fcHJlYXV0aF9maW5pc2hlZChoYXBkLCBzdGEsIHN1Y2Nlc3MpOwogCWVsc2UKLQkJaWVlZTgwMl8xeF9maW5pc2hlZChoYXBkLCBzdGEsIHN1Y2Nlc3MpOworCQlpZWVlODAyXzF4X2ZpbmlzaGVkKGhhcGQsIHN0YSwgc3VjY2VzcywgcmVtZWRpYXRpb24pOwogfQogCiAKQEAgLTE2MDQsNyArMTg4Myw5IEBACiAJCXVzZXItPnBhc3N3b3JkX2hhc2ggPSBlYXBfdXNlci0+cGFzc3dvcmRfaGFzaDsKIAl9CiAJdXNlci0+Zm9yY2VfdmVyc2lvbiA9IGVhcF91c2VyLT5mb3JjZV92ZXJzaW9uOworCXVzZXItPm1hY2FjbCA9IGVhcF91c2VyLT5tYWNhY2w7CiAJdXNlci0+dHRsc19hdXRoID0gZWFwX3VzZXItPnR0bHNfYXV0aDsKKwl1c2VyLT5yZW1lZGlhdGlvbiA9IGVhcF91c2VyLT5yZW1lZGlhdGlvbjsKIAogCXJldHVybiAwOwogfQpAQCAtMTk1Miw3ICsyMjMzLDkgQEAKIHsKIAlpbnQgbGVuID0gMCwgcmV0OwogCXN0cnVjdCBlYXBvbF9zdGF0ZV9tYWNoaW5lICpzbSA9IHN0YS0+ZWFwb2xfc207Ci0Jc3RydWN0IG9zX3RpbWUgdDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBkaWZmOworCWNvbnN0IGNoYXIgKm5hbWUxOworCWNvbnN0IGNoYXIgKm5hbWUyOwogCiAJaWYgKHNtID09IE5VTEwpCiAJCXJldHVybiAwOwpAQCAtMjA2Nyw3ICsyMzUwLDcgQEAKIAlsZW4gKz0gcmV0OwogCiAJLyogZG90MXhBdXRoU2Vzc2lvblN0YXRzVGFibGUgKi8KLQlvc19nZXRfdGltZSgmdCk7CisJb3NfcmVsdGltZV9hZ2UoJnN0YS0+YWNjdF9zZXNzaW9uX3N0YXJ0LCAmZGlmZik7CiAJcmV0ID0gb3Nfc25wcmludGYoYnVmICsgbGVuLCBidWZsZW4gLSBsZW4sCiAJCQkgIC8qIFRPRE86IGRvdDF4QXV0aFNlc3Npb25PY3RldHNSeCAqLwogCQkJICAvKiBUT0RPOiBkb3QxeEF1dGhTZXNzaW9uT2N0ZXRzVHggKi8KQEAgLTIwODIsMjYgKzIzNjUsNzMgQEAKIAkJCSAgKHdwYV9rZXlfbWdtdF93cGFfaWVlZTgwMjF4KAogCQkJCSAgIHdwYV9hdXRoX3N0YV9rZXlfbWdtdChzdGEtPndwYV9zbSkpKSA/CiAJCQkgIDEgOiAyLAotCQkJICAodW5zaWduZWQgaW50KSAodC5zZWMgLSBzdGEtPmFjY3Rfc2Vzc2lvbl9zdGFydCksCisJCQkgICh1bnNpZ25lZCBpbnQpIGRpZmYuc2VjLAogCQkJICBzbS0+aWRlbnRpdHkpOwogCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4gLSBsZW4pCiAJCXJldHVybiBsZW47CiAJbGVuICs9IHJldDsKIAorCW5hbWUxID0gZWFwX3NlcnZlcl9nZXRfbmFtZSgwLCBzbS0+ZWFwX3R5cGVfYXV0aHNydik7CisJbmFtZTIgPSBlYXBfc2VydmVyX2dldF9uYW1lKDAsIHNtLT5lYXBfdHlwZV9zdXBwKTsKKwlyZXQgPSBvc19zbnByaW50ZihidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbiwKKwkJCSAgImxhc3RfZWFwX3R5cGVfYXM9JWQgKCVzKVxuIgorCQkJICAibGFzdF9lYXBfdHlwZV9zdGE9JWQgKCVzKVxuIiwKKwkJCSAgc20tPmVhcF90eXBlX2F1dGhzcnYsCisJCQkgIG5hbWUxID8gbmFtZTEgOiAiIiwKKwkJCSAgc20tPmVhcF90eXBlX3N1cHAsCisJCQkgIG5hbWUyID8gbmFtZTIgOiAiIik7CisJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbiAtIGxlbikKKwkJcmV0dXJuIGxlbjsKKwlsZW4gKz0gcmV0OworCiAJcmV0dXJuIGxlbjsKIH0KIAogCiBzdGF0aWMgdm9pZCBpZWVlODAyXzF4X2ZpbmlzaGVkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCi0JCQkJc3RydWN0IHN0YV9pbmZvICpzdGEsIGludCBzdWNjZXNzKQorCQkJCXN0cnVjdCBzdGFfaW5mbyAqc3RhLCBpbnQgc3VjY2VzcywKKwkJCQlpbnQgcmVtZWRpYXRpb24pCiB7CiAJY29uc3QgdTggKmtleTsKIAlzaXplX3QgbGVuOwogCS8qIFRPRE86IGdldCBQTUtMaWZldGltZSBmcm9tIFdQQSBwYXJhbWV0ZXJzICovCiAJc3RhdGljIGNvbnN0IGludCBkb3QxMVJTTkFDb25maWdQTUtMaWZldGltZSA9IDQzMjAwOwogCisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAocmVtZWRpYXRpb24gJiYgIXN0YS0+cmVtZWRpYXRpb24pIHsKKwkJc3RhLT5yZW1lZGlhdGlvbiA9IDE7CisJCW9zX2ZyZWUoc3RhLT5yZW1lZGlhdGlvbl91cmwpOworCQlzdGEtPnJlbWVkaWF0aW9uX3VybCA9CisJCQlvc19zdHJkdXAoaGFwZC0+Y29uZi0+c3Vic2NyX3JlbWVkaWF0aW9uX3VybCk7CisJCXN0YS0+cmVtZWRpYXRpb25fbWV0aG9kID0gMTsgLyogU09BUC1YTUwgU1BQICovCisJfQorCisJaWYgKHN1Y2Nlc3MpIHsKKwkJaWYgKHN0YS0+cmVtZWRpYXRpb24pIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBTZW5kIFdOTS1Ob3RpZmljYXRpb24gIgorCQkJCSAgICJ0byAiIE1BQ1NUUiAiIHRvIGluZGljYXRlIFN1YnNjcmlwdGlvbiAiCisJCQkJICAgIlJlbWVkaWF0aW9uIiwKKwkJCQkgICBNQUMyU1RSKHN0YS0+YWRkcikpOworCQkJaHMyMF9zZW5kX3dubV9ub3RpZmljYXRpb24oaGFwZCwgc3RhLT5hZGRyLAorCQkJCQkJICAgc3RhLT5yZW1lZGlhdGlvbl9tZXRob2QsCisJCQkJCQkgICBzdGEtPnJlbWVkaWF0aW9uX3VybCk7CisJCQlvc19mcmVlKHN0YS0+cmVtZWRpYXRpb25fdXJsKTsKKwkJCXN0YS0+cmVtZWRpYXRpb25fdXJsID0gTlVMTDsKKwkJfQorCisJCWlmIChzdGEtPmhzMjBfZGVhdXRoX3JlcSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IFNlbmQgV05NLU5vdGlmaWNhdGlvbiAiCisJCQkJICAgInRvICIgTUFDU1RSICIgdG8gaW5kaWNhdGUgaW1taW5lbnQgIgorCQkJCSAgICJkZWF1dGhlbnRpY2F0aW9uIiwgTUFDMlNUUihzdGEtPmFkZHIpKTsKKwkJCWhzMjBfc2VuZF93bm1fbm90aWZpY2F0aW9uX2RlYXV0aF9yZXEoCisJCQkJaGFwZCwgc3RhLT5hZGRyLCBzdGEtPmhzMjBfZGVhdXRoX3JlcSk7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogCWtleSA9IGllZWU4MDJfMXhfZ2V0X2tleShzdGEtPmVhcG9sX3NtLCAmbGVuKTsKLQlpZiAoc3VjY2VzcyAmJiBrZXkgJiYgbGVuID49IFBNS19MRU4gJiYKKwlpZiAoc3VjY2VzcyAmJiBrZXkgJiYgbGVuID49IFBNS19MRU4gJiYgIXN0YS0+cmVtZWRpYXRpb24gJiYKKwkgICAgIXN0YS0+aHMyMF9kZWF1dGhfcmVxdWVzdGVkICYmCiAJICAgIHdwYV9hdXRoX3Bta3NhX2FkZChzdGEtPndwYV9zbSwga2V5LCBkb3QxMVJTTkFDb25maWdQTUtMaWZldGltZSwKIAkJCSAgICAgICBzdGEtPmVhcG9sX3NtKSA9PSAwKSB7CiAJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIHN0YS0+YWRkciwgSE9TVEFQRF9NT0RVTEVfV1BBLApAQCAtMjEyNywxMiArMjQ1Nyw4IEBACiAJCSAqIGRyaXZlciByZW9yZGVyIG9wZXJhdGlvbnMuCiAJCSAqLwogCQlvc19zbGVlcCgwLCAxMDAwMCk7Ci0jaWZuZGVmIEFORFJPSURfUDJQCi0JCS8qIFdlIG5lZWQgbm90IGRvIHRoaXMgZm9yIGRyaXZlci4gRm9yIEFQLVNNRSBmbGFncyBpZiB3ZSBzZW5kIHRoaXMgZGlzYXNzb2MsCi0JCSAgKiB0aGUgcDJwX2NsaWVudCBpcyBnZXR0aWcgZGlzYXNzb2MgYWZ0ZXIgaXQgaGFzIGNvbXBsZXRlZCB0aGUgYXNzb2MKLQkJICAqLwogCQlhcF9zdGFfZGlzY29ubmVjdChoYXBkLCBzdGEsIHN0YS0+YWRkciwKIAkJCQkgIFdMQU5fUkVBU09OX0lFRUVfODAyXzFYX0FVVEhfRkFJTEVEKTsKLSNlbmRpZgorCQlob3N0YXBkX3dwc19lYXBfY29tcGxldGVkKGhhcGQpOwogCX0KIH0KZGlmZiAtLWdpdCBhL3NyYy9hcC9wMnBfaG9zdGFwZC5jIGIvc3JjL2FwL3AycF9ob3N0YXBkLmMKaW5kZXggNzk1ZDMxMy4uOWJlNjQwYyAxMDA2NDQKLS0tIGEvc3JjL2FwL3AycF9ob3N0YXBkLmMKKysrIGIvc3JjL2FwL3AycF9ob3N0YXBkLmMKQEAgLTk2LDkgKzk2LDggQEAKIAl1OCBiaXRtYXA7CiAJKmVpZCsrID0gV0xBTl9FSURfVkVORE9SX1NQRUNJRklDOwogCSplaWQrKyA9IDQgKyAzICsgMTsKLQlXUEFfUFVUX0JFMjQoZWlkLCBPVUlfV0ZBKTsKLQllaWQgKz0gMzsKLQkqZWlkKysgPSBQMlBfT1VJX1RZUEU7CisJV1BBX1BVVF9CRTMyKGVpZCwgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKKwllaWQgKz0gNDsKIAogCSplaWQrKyA9IFAyUF9BVFRSX01BTkFHRUFCSUxJVFk7CiAJV1BBX1BVVF9MRTE2KGVpZCwgMSk7CmRpZmYgLS1naXQgYS9zcmMvYXAvcGVlcmtleV9hdXRoLmMgYi9zcmMvYXAvcGVlcmtleV9hdXRoLmMKaW5kZXggYmE1YzYwNi4uNjEyYmFiYyAxMDA2NDQKLS0tIGEvc3JjL2FwL3BlZXJrZXlfYXV0aC5jCisrKyBiL3NyYy9hcC9wZWVya2V5X2F1dGguYwpAQCAtMjIxLDggKzIyMSw4IEBACiAJCXJldHVybjsKIAogCS8qIFBlZXIgUlNOIElFICovCi0Jb3NfbWVtY3B5KGJ1Ziwga2RlLT5yc25faWUsIGtkZS0+cnNuX2llX2xlbik7Ci0JcG9zID0gYnVmICsga2RlLT5yc25faWVfbGVuOworCW9zX21lbWNweShwb3MsIGtkZS0+cnNuX2llLCBrZGUtPnJzbl9pZV9sZW4pOworCXBvcyArPSBrZGUtPnJzbl9pZV9sZW47CiAKIAkvKiBQZWVyIE1BQyBBZGRyZXNzICovCiAJcG9zID0gd3BhX2FkZF9rZGUocG9zLCBSU05fS0VZX0RBVEFfTUFDX0FERFIsIHBlZXIsIEVUSF9BTEVOLCBOVUxMLCAwKTsKZGlmZiAtLWdpdCBhL3NyYy9hcC9wbWtzYV9jYWNoZV9hdXRoLmMgYi9zcmMvYXAvcG1rc2FfY2FjaGVfYXV0aC5jCmluZGV4IDQwOTcyZTkuLjQ3MjBiNTkgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9wbWtzYV9jYWNoZV9hdXRoLmMKKysrIGIvc3JjL2FwL3Bta3NhX2NhY2hlX2F1dGguYwpAQCAtOTEsOSArOTEsOSBAQAogc3RhdGljIHZvaWQgcG1rc2FfY2FjaGVfZXhwaXJlKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCiB7CiAJc3RydWN0IHJzbl9wbWtzYV9jYWNoZSAqcG1rc2EgPSBlbG9vcF9jdHg7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAotCW9zX2dldF90aW1lKCZub3cpOworCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCXdoaWxlIChwbWtzYS0+cG1rc2EgJiYgcG1rc2EtPnBta3NhLT5leHBpcmF0aW9uIDw9IG5vdy5zZWMpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSU046IGV4cGlyZWQgUE1LU0EgY2FjaGUgZW50cnkgZm9yICIKIAkJCSAgIE1BQ1NUUiwgTUFDMlNUUihwbWtzYS0+cG1rc2EtPnNwYSkpOwpAQCAtMTA3LDEyICsxMDcsMTIgQEAKIHN0YXRpYyB2b2lkIHBta3NhX2NhY2hlX3NldF9leHBpcmF0aW9uKHN0cnVjdCByc25fcG1rc2FfY2FjaGUgKnBta3NhKQogewogCWludCBzZWM7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAogCWVsb29wX2NhbmNlbF90aW1lb3V0KHBta3NhX2NhY2hlX2V4cGlyZSwgcG1rc2EsIE5VTEwpOwogCWlmIChwbWtzYS0+cG1rc2EgPT0gTlVMTCkKIAkJcmV0dXJuOwotCW9zX2dldF90aW1lKCZub3cpOworCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCXNlYyA9IHBta3NhLT5wbWtzYS0+ZXhwaXJhdGlvbiAtIG5vdy5zZWM7CiAJaWYgKHNlYyA8IDApCiAJCXNlYyA9IDA7CkBAIC0yNDEsNyArMjQxLDcgQEAKIAkJc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKmVhcG9sLCBpbnQgYWttcCkKIHsKIAlzdHJ1Y3QgcnNuX3Bta3NhX2NhY2hlX2VudHJ5ICplbnRyeSwgKnBvczsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCiAJaWYgKHBta19sZW4gPiBQTUtfTEVOKQogCQlyZXR1cm4gTlVMTDsKQEAgLTI1Myw3ICsyNTMsNyBAQAogCWVudHJ5LT5wbWtfbGVuID0gcG1rX2xlbjsKIAlyc25fcG1raWQocG1rLCBwbWtfbGVuLCBhYSwgc3BhLCBlbnRyeS0+cG1raWQsCiAJCSAgd3BhX2tleV9tZ210X3NoYTI1Nihha21wKSk7Ci0Jb3NfZ2V0X3RpbWUoJm5vdyk7CisJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CiAJZW50cnktPmV4cGlyYXRpb24gPSBub3cuc2VjOwogCWlmIChzZXNzaW9uX3RpbWVvdXQgPiAwKQogCQllbnRyeS0+ZXhwaXJhdGlvbiArPSBzZXNzaW9uX3RpbWVvdXQ7CmRpZmYgLS1naXQgYS9zcmMvYXAvc3RhX2luZm8uYyBiL3NyYy9hcC9zdGFfaW5mby5jCmluZGV4IDY3MDRjMDkuLjYwZjA3NjggMTAwNjQ0Ci0tLSBhL3NyYy9hcC9zdGFfaW5mby5jCisrKyBiL3NyYy9hcC9zdGFfaW5mby5jCkBAIC0xNSw3ICsxNSw2IEBACiAjaW5jbHVkZSAiY29tbW9uL3NhZS5oIgogI2luY2x1ZGUgInJhZGl1cy9yYWRpdXMuaCIKICNpbmNsdWRlICJyYWRpdXMvcmFkaXVzX2NsaWVudC5oIgotI2luY2x1ZGUgImRyaXZlcnMvZHJpdmVyLmgiCiAjaW5jbHVkZSAicDJwL3AycC5oIgogI2luY2x1ZGUgImhvc3RhcGQuaCIKICNpbmNsdWRlICJhY2NvdW50aW5nLmgiCkBAIC0zMSwxMSArMzAsMTMgQEAKICNpbmNsdWRlICJwMnBfaG9zdGFwZC5oIgogI2luY2x1ZGUgImFwX2Rydl9vcHMuaCIKICNpbmNsdWRlICJnYXNfc2Vydi5oIgorI2luY2x1ZGUgIndubV9hcC5oIgogI2luY2x1ZGUgInN0YV9pbmZvLmgiCiAKIHN0YXRpYyB2b2lkIGFwX3N0YV9yZW1vdmVfaW5fb3RoZXJfYnNzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJICAgICAgIHN0cnVjdCBzdGFfaW5mbyAqc3RhKTsKIHN0YXRpYyB2b2lkIGFwX2hhbmRsZV9zZXNzaW9uX3RpbWVyKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOworc3RhdGljIHZvaWQgYXBfaGFuZGxlX3Nlc3Npb25fd2FybmluZ190aW1lcih2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KTsKIHN0YXRpYyB2b2lkIGFwX3N0YV9kZWF1dGhfY2JfdGltZW91dCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KTsKIHN0YXRpYyB2b2lkIGFwX3N0YV9kaXNhc3NvY19jYl90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCkBAIC0xNTUsNyArMTU2LDggQEAKIAlpZiAoc3RhLT5mbGFncyAmIFdMQU5fU1RBX1dEUykKIAkJaG9zdGFwZF9zZXRfd2RzX3N0YShoYXBkLCBOVUxMLCBzdGEtPmFkZHIsIHN0YS0+YWlkLCAwKTsKIAotCWlmICghKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9QUkVBVVRIKSkKKwlpZiAoIWhhcGQtPmlmYWNlLT5kcml2ZXJfYXBfdGVhcmRvd24gJiYKKwkgICAgIShzdGEtPmZsYWdzICYgV0xBTl9TVEFfUFJFQVVUSCkpCiAJCWhvc3RhcGRfZHJ2X3N0YV9yZW1vdmUoaGFwZCwgc3RhLT5hZGRyKTsKIAogCWFwX3N0YV9oYXNoX2RlbChoYXBkLCBzdGEpOwpAQCAtMjA0LDYgKzIwNiwxMCBAQAogCQloYXBkLT5pZmFjZS0+bnVtX3N0YV9odF8yMG1oei0tOwogCX0KIAorI2lmZGVmIENPTkZJR19JRUVFODAyMTFOCisJaHQ0MF9pbnRvbGVyYW50X3JlbW92ZShoYXBkLT5pZmFjZSwgc3RhKTsKKyNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExTiAqLworCiAjaWZkZWYgQ09ORklHX1AyUAogCWlmIChzdGEtPm5vX3AycF9zZXQpIHsKIAkJc3RhLT5ub19wMnBfc2V0ID0gMDsKQEAgLTIyNSw2ICsyMzEsNyBAQAogCQkgICBfX2Z1bmNfXywgTUFDMlNUUihzdGEtPmFkZHIpKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dChhcF9oYW5kbGVfdGltZXIsIGhhcGQsIHN0YSk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3Nlc3Npb25fdGltZXIsIGhhcGQsIHN0YSk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3Nlc3Npb25fd2FybmluZ190aW1lciwgaGFwZCwgc3RhKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dChhcF9zdGFfZGVhdXRoX2NiX3RpbWVvdXQsIGhhcGQsIHN0YSk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfc3RhX2Rpc2Fzc29jX2NiX3RpbWVvdXQsIGhhcGQsIHN0YSk7CiAKQEAgLTIzMiwxMCArMjM5LDEwIEBACiAJd3BhX2F1dGhfc3RhX2RlaW5pdChzdGEtPndwYV9zbSk7CiAJcnNuX3ByZWF1dGhfZnJlZV9zdGF0aW9uKGhhcGQsIHN0YSk7CiAjaWZuZGVmIENPTkZJR19OT19SQURJVVMKLQlyYWRpdXNfY2xpZW50X2ZsdXNoX2F1dGgoaGFwZC0+cmFkaXVzLCBzdGEtPmFkZHIpOworCWlmIChoYXBkLT5yYWRpdXMpCisJCXJhZGl1c19jbGllbnRfZmx1c2hfYXV0aChoYXBkLT5yYWRpdXMsIHN0YS0+YWRkcik7CiAjZW5kaWYgLyogQ09ORklHX05PX1JBRElVUyAqLwogCi0Jb3NfZnJlZShzdGEtPmxhc3RfYXNzb2NfcmVxKTsKIAlvc19mcmVlKHN0YS0+Y2hhbGxlbmdlKTsKIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCkBAIC0yNjEsOSArMjY4LDEzIEBACiAJd3BhYnVmX2ZyZWUoc3RhLT5oczIwX2llKTsKIAogCW9zX2ZyZWUoc3RhLT5odF9jYXBhYmlsaXRpZXMpOworCW9zX2ZyZWUoc3RhLT52aHRfY2FwYWJpbGl0aWVzKTsKIAlob3N0YXBkX2ZyZWVfcHNrX2xpc3Qoc3RhLT5wc2spOwogCW9zX2ZyZWUoc3RhLT5pZGVudGl0eSk7CiAJb3NfZnJlZShzdGEtPnJhZGl1c19jdWkpOworCW9zX2ZyZWUoc3RhLT5yZW1lZGlhdGlvbl91cmwpOworCXdwYWJ1Zl9mcmVlKHN0YS0+aHMyMF9kZWF1dGhfcmVxKTsKKwlvc19mcmVlKHN0YS0+aHMyMF9zZXNzaW9uX2luZm9fdXJsKTsKIAogI2lmZGVmIENPTkZJR19TQUUKIAlzYWVfY2xlYXJfZGF0YShzdGEtPnNhZSk7CkBAIC00NjUsNyArNDc2LDYgQEAKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkID0gZWxvb3BfY3R4OwogCXN0cnVjdCBzdGFfaW5mbyAqc3RhID0gdGltZW91dF9jdHg7Ci0JdTggYWRkcltFVEhfQUxFTl07CiAKIAlpZiAoIShzdGEtPmZsYWdzICYgV0xBTl9TVEFfQVVUSCkpIHsKIAkJaWYgKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9HQVMpIHsKQEAgLTQ3Niw2ICs0ODYsOCBAQAogCQlyZXR1cm47CiAJfQogCisJaG9zdGFwZF9kcnZfc3RhX2RlYXV0aChoYXBkLCBzdGEtPmFkZHIsCisJCQkgICAgICAgV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7CiAJbWxtZV9kZWF1dGhlbnRpY2F0ZV9pbmRpY2F0aW9uKGhhcGQsIHN0YSwKIAkJCQkgICAgICAgV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7CiAJaG9zdGFwZF9sb2dnZXIoaGFwZCwgc3RhLT5hZGRyLCBIT1NUQVBEX01PRFVMRV9JRUVFODAyMTEsCkBAIC00ODMsOSArNDk1LDE5IEBACiAJCSAgICAgICAic2Vzc2lvbiB0aW1lb3V0Iik7CiAJc3RhLT5hY2N0X3Rlcm1pbmF0ZV9jYXVzZSA9CiAJCVJBRElVU19BQ0NUX1RFUk1JTkFURV9DQVVTRV9TRVNTSU9OX1RJTUVPVVQ7Ci0Jb3NfbWVtY3B5KGFkZHIsIHN0YS0+YWRkciwgRVRIX0FMRU4pOwogCWFwX2ZyZWVfc3RhKGhhcGQsIHN0YSk7Ci0JaG9zdGFwZF9kcnZfc3RhX2RlYXV0aChoYXBkLCBhZGRyLCBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKK30KKworCit2b2lkIGFwX3N0YV9yZXBsZW5pc2hfdGltZW91dChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKKwkJCSAgICAgIHUzMiBzZXNzaW9uX3RpbWVvdXQpCit7CisJaWYgKGVsb29wX3JlcGxlbmlzaF90aW1lb3V0KHNlc3Npb25fdGltZW91dCwgMCwKKwkJCQkgICAgYXBfaGFuZGxlX3Nlc3Npb25fdGltZXIsIGhhcGQsIHN0YSkgPT0gMSkgeworCQlob3N0YXBkX2xvZ2dlcihoYXBkLCBzdGEtPmFkZHIsIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKKwkJCSAgICAgICBIT1NUQVBEX0xFVkVMX0RFQlVHLCAic2V0dGluZyBzZXNzaW9uIHRpbWVvdXQgIgorCQkJICAgICAgICJ0byAlZCBzZWNvbmRzIiwgc2Vzc2lvbl90aW1lb3V0KTsKKwl9CiB9CiAKIApAQCAtNTA3LDYgKzUyOSwzMiBAQAogfQogCiAKK3N0YXRpYyB2b2lkIGFwX2hhbmRsZV9zZXNzaW9uX3dhcm5pbmdfdGltZXIodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKK3sKKyNpZmRlZiBDT05GSUdfV05NCisJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGVsb29wX2N0eDsKKwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YSA9IHRpbWVvdXRfY3R4OworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IFNlc3Npb24gd2FybmluZyB0aW1lIHJlYWNoZWQgZm9yICIgTUFDU1RSLAorCQkgICBNQUMyU1RSKHN0YS0+YWRkcikpOworCWlmIChzdGEtPmhzMjBfc2Vzc2lvbl9pbmZvX3VybCA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl3bm1fc2VuZF9lc3NfZGlzYXNzb2NfaW1taW5lbnQoaGFwZCwgc3RhLCBzdGEtPmhzMjBfc2Vzc2lvbl9pbmZvX3VybCwKKwkJCQkgICAgICAgc3RhLT5oczIwX2Rpc2Fzc29jX3RpbWVyKTsKKyNlbmRpZiAvKiBDT05GSUdfV05NICovCit9CisKKwordm9pZCBhcF9zdGFfc2Vzc2lvbl93YXJuaW5nX3RpbWVvdXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgc3RydWN0IHN0YV9pbmZvICpzdGEsIGludCB3YXJuaW5nX3RpbWUpCit7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3Nlc3Npb25fd2FybmluZ190aW1lciwgaGFwZCwgc3RhKTsKKwllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KHdhcm5pbmdfdGltZSwgMCwgYXBfaGFuZGxlX3Nlc3Npb25fd2FybmluZ190aW1lciwKKwkJCSAgICAgICBoYXBkLCBzdGEpOworfQorCisKIHN0cnVjdCBzdGFfaW5mbyAqIGFwX3N0YV9hZGQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIpCiB7CiAJc3RydWN0IHN0YV9pbmZvICpzdGE7CkBAIC01MzEsMTMgKzU3OSwxNiBAQAogCXN0YS0+YWNjdF9pbnRlcmltX2ludGVydmFsID0gaGFwZC0+Y29uZi0+YWNjdF9pbnRlcmltX2ludGVydmFsOwogCWFjY291bnRpbmdfc3RhX2dldF9pZChoYXBkLCBzdGEpOwogCisJaWYgKCEoaGFwZC0+aWZhY2UtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfSU5BQ1RJVklUWV9USU1FUikpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogcmVnaXN0ZXIgYXBfaGFuZGxlX3RpbWVyIHRpbWVvdXQgIgorCQkJICAgImZvciAiIE1BQ1NUUiAiICglZCBzZWNvbmRzIC0gYXBfbWF4X2luYWN0aXZpdHkpIiwKKwkJCSAgIF9fZnVuY19fLCBNQUMyU1RSKGFkZHIpLAorCQkJICAgaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHkpOworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5LCAwLAorCQkJCSAgICAgICBhcF9oYW5kbGVfdGltZXIsIGhhcGQsIHN0YSk7CisJfQorCiAJLyogaW5pdGlhbGl6ZSBTVEEgaW5mbyBkYXRhICovCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogcmVnaXN0ZXIgYXBfaGFuZGxlX3RpbWVyIHRpbWVvdXQgIgotCQkgICAiZm9yICIgTUFDU1RSICIgKCVkIHNlY29uZHMgLSBhcF9tYXhfaW5hY3Rpdml0eSkiLAotCQkgICBfX2Z1bmNfXywgTUFDMlNUUihhZGRyKSwKLQkJICAgaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHkpOwotCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHksIDAsCi0JCQkgICAgICAgYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOwogCW9zX21lbWNweShzdGEtPmFkZHIsIGFkZHIsIEVUSF9BTEVOKTsKIAlzdGEtPm5leHQgPSBoYXBkLT5zdGFfbGlzdDsKIAloYXBkLT5zdGFfbGlzdCA9IHN0YTsKQEAgLTgwOCw5ICs4NTksOSBAQAogaW50IGFwX2NoZWNrX3NhX3F1ZXJ5X3RpbWVvdXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEpCiB7CiAJdTMyIHR1OwotCXN0cnVjdCBvc190aW1lIG5vdywgcGFzc2VkOwotCW9zX2dldF90aW1lKCZub3cpOwotCW9zX3RpbWVfc3ViKCZub3csICZzdGEtPnNhX3F1ZXJ5X3N0YXJ0LCAmcGFzc2VkKTsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3csIHBhc3NlZDsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKKwlvc19yZWx0aW1lX3N1Yigmbm93LCAmc3RhLT5zYV9xdWVyeV9zdGFydCwgJnBhc3NlZCk7CiAJdHUgPSAocGFzc2VkLnNlYyAqIDEwMDAwMDAgKyBwYXNzZWQudXNlYykgLyAxMDI0OwogCWlmIChoYXBkLT5jb25mLT5hc3NvY19zYV9xdWVyeV9tYXhfdGltZW91dCA8IHR1KSB7CiAJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIHN0YS0+YWRkciwKQEAgLTg0Nyw3ICs4OTgsNyBAQAogCQlyZXR1cm47CiAJaWYgKHN0YS0+c2FfcXVlcnlfY291bnQgPT0gMCkgewogCQkvKiBTdGFydGluZyBhIG5ldyBTQSBRdWVyeSBwcm9jZWR1cmUgKi8KLQkJb3NfZ2V0X3RpbWUoJnN0YS0+c2FfcXVlcnlfc3RhcnQpOworCQlvc19nZXRfcmVsdGltZSgmc3RhLT5zYV9xdWVyeV9zdGFydCk7CiAJfQogCXRyYW5zX2lkID0gbmJ1ZiArIHN0YS0+c2FfcXVlcnlfY291bnQgKiBXTEFOX1NBX1FVRVJZX1RSX0lEX0xFTjsKIAlzdGEtPnNhX3F1ZXJ5X3RyYW5zX2lkID0gbmJ1ZjsKQEAgLTg5Miw2ICs5NDMsNyBAQAogCWNoYXIgYnVmWzEwMF07CiAjaWZkZWYgQ09ORklHX1AyUAogCXU4IGFkZHJbRVRIX0FMRU5dOworCXU4IGlwX2FkZHJfYnVmWzRdOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCWlmICghIWF1dGhvcml6ZWQgPT0gISEoc3RhLT5mbGFncyAmIFdMQU5fU1RBX0FVVEhPUklaRUQpKQpAQCAtOTEzLDEyICs5NjUsMjUgQEAKIAkJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgTUFDU1RSLCBNQUMyU1RSKHN0YS0+YWRkcikpOwogCiAJaWYgKGF1dGhvcml6ZWQpIHsKLQkJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfSU5GTywgQVBfU1RBX0NPTk5FQ1RFRCAiJXMiLCBidWYpOworCQljaGFyIGlwX2FkZHJbMTAwXTsKKwkJaXBfYWRkclswXSA9ICdcMCc7CisjaWZkZWYgQ09ORklHX1AyUAorCQlpZiAod3BhX2F1dGhfZ2V0X2lwX2FkZHIoc3RhLT53cGFfc20sIGlwX2FkZHJfYnVmKSA9PSAwKSB7CisJCQlvc19zbnByaW50ZihpcF9hZGRyLCBzaXplb2YoaXBfYWRkciksCisJCQkJICAgICIgaXBfYWRkcj0ldS4ldS4ldS4ldSIsCisJCQkJICAgIGlwX2FkZHJfYnVmWzBdLCBpcF9hZGRyX2J1ZlsxXSwKKwkJCQkgICAgaXBfYWRkcl9idWZbMl0sIGlwX2FkZHJfYnVmWzNdKTsKKwkJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19JTkZPLCBBUF9TVEFfQ09OTkVDVEVEICIlcyVzIiwKKwkJCWJ1ZiwgaXBfYWRkcik7CiAKIAkJaWYgKGhhcGQtPm1zZ19jdHhfcGFyZW50ICYmCiAJCSAgICBoYXBkLT5tc2dfY3R4X3BhcmVudCAhPSBoYXBkLT5tc2dfY3R4KQogCQkJd3BhX21zZ19ub19nbG9iYWwoaGFwZC0+bXNnX2N0eF9wYXJlbnQsIE1TR19JTkZPLAotCQkJCQkgIEFQX1NUQV9DT05ORUNURUQgIiVzIiwgYnVmKTsKKwkJCQkJICBBUF9TVEFfQ09OTkVDVEVEICIlcyVzIiwKKwkJCQkJICBidWYsIGlwX2FkZHIpOwogCiAJCXN0YS0+ZmxhZ3MgfD0gV0xBTl9TVEFfQVVUSE9SSVpFRDsKIAl9IGVsc2UgewpAQCAtOTk1LDMgKzEwNjAsMzMgQEAKIAllbG9vcF9jYW5jZWxfdGltZW91dChhcF9zdGFfZGlzYXNzb2NfY2JfdGltZW91dCwgaGFwZCwgc3RhKTsKIAlhcF9zdGFfZGlzYXNzb2NfY2JfdGltZW91dChoYXBkLCBzdGEpOwogfQorCisKK2ludCBhcF9zdGFfZmxhZ3NfdHh0KHUzMiBmbGFncywgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQoreworCWludCByZXM7CisKKwlidWZbMF0gPSAnXDAnOworCXJlcyA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJXMlcyVzJXMlcyVzJXMlcyVzJXMlcyVzJXMlcyVzJXMiLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9BVVRIID8gIltBVVRIXSIgOiAiIiksCisJCQkgIChmbGFncyAmIFdMQU5fU1RBX0FTU09DID8gIltBU1NPQ10iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9BVVRIT1JJWkVEID8gIltBVVRIT1JJWkVEXSIgOiAiIiksCisJCQkgIChmbGFncyAmIFdMQU5fU1RBX1BFTkRJTkdfUE9MTCA/ICJbUEVORElOR19QT0xMIiA6CisJCQkgICAiIiksCisJCQkgIChmbGFncyAmIFdMQU5fU1RBX1NIT1JUX1BSRUFNQkxFID8KKwkJCSAgICJbU0hPUlRfUFJFQU1CTEVdIiA6ICIiKSwKKwkJCSAgKGZsYWdzICYgV0xBTl9TVEFfUFJFQVVUSCA/ICJbUFJFQVVUSF0iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9XTU0gPyAiW1dNTV0iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9NRlAgPyAiW01GUF0iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9XUFMgPyAiW1dQU10iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9NQVlCRV9XUFMgPyAiW01BWUJFX1dQU10iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9XRFMgPyAiW1dEU10iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9OT05FUlAgPyAiW05vbkVSUF0iIDogIiIpLAorCQkJICAoZmxhZ3MgJiBXTEFOX1NUQV9XUFMyID8gIltXUFMyXSIgOiAiIiksCisJCQkgIChmbGFncyAmIFdMQU5fU1RBX0dBUyA/ICJbR0FTXSIgOiAiIiksCisJCQkgIChmbGFncyAmIFdMQU5fU1RBX1ZIVCA/ICJbVkhUXSIgOiAiIiksCisJCQkgIChmbGFncyAmIFdMQU5fU1RBX1dOTV9TTEVFUF9NT0RFID8KKwkJCSAgICJbV05NX1NMRUVQX01PREVdIiA6ICIiKSk7CisKKwlyZXR1cm4gcmVzOworfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL3N0YV9pbmZvLmggYi9zcmMvYXAvc3RhX2luZm8uaAppbmRleCBlNWI1MDY5Li4wM2RiOThmIDEwMDY0NAotLS0gYS9zcmMvYXAvc3RhX2luZm8uaAorKysgYi9zcmMvYXAvc3RhX2luZm8uaApAQCAtMTIsOSArMTIsNiBAQAogLyogU1RBIGZsYWdzICovCiAjZGVmaW5lIFdMQU5fU1RBX0FVVEggQklUKDApCiAjZGVmaW5lIFdMQU5fU1RBX0FTU09DIEJJVCgxKQotI2RlZmluZSBXTEFOX1NUQV9QUyBCSVQoMikKLSNkZWZpbmUgV0xBTl9TVEFfVElNIEJJVCgzKQotI2RlZmluZSBXTEFOX1NUQV9QRVJNIEJJVCg0KQogI2RlZmluZSBXTEFOX1NUQV9BVVRIT1JJWkVEIEJJVCg1KQogI2RlZmluZSBXTEFOX1NUQV9QRU5ESU5HX1BPTEwgQklUKDYpIC8qIHBlbmRpbmcgYWN0aXZpdHkgcG9sbCBub3QgQUNLZWQgKi8KICNkZWZpbmUgV0xBTl9TVEFfU0hPUlRfUFJFQU1CTEUgQklUKDcpCkBAIC0yOSw2ICsyNiw4IEBACiAjZGVmaW5lIFdMQU5fU1RBX1dQUzIgQklUKDE2KQogI2RlZmluZSBXTEFOX1NUQV9HQVMgQklUKDE3KQogI2RlZmluZSBXTEFOX1NUQV9WSFQgQklUKDE4KQorI2RlZmluZSBXTEFOX1NUQV9XTk1fU0xFRVBfTU9ERSBCSVQoMTkpCisjZGVmaW5lIFdMQU5fU1RBX1ZIVF9PUE1PREVfRU5BQkxFRCBCSVQoMjApCiAjZGVmaW5lIFdMQU5fU1RBX1BFTkRJTkdfRElTQVNTT0NfQ0IgQklUKDI5KQogI2RlZmluZSBXTEFOX1NUQV9QRU5ESU5HX0RFQVVUSF9DQiBCSVQoMzApCiAjZGVmaW5lIFdMQU5fU1RBX05PTkVSUCBCSVQoMzEpCkBAIC01NSwxMSArNTQsMTQgQEAKIAl1bnNpZ25lZCBpbnQgbm9fc2hvcnRfcHJlYW1ibGVfc2V0OjE7CiAJdW5zaWduZWQgaW50IG5vX2h0X2dmX3NldDoxOwogCXVuc2lnbmVkIGludCBub19odF9zZXQ6MTsKKwl1bnNpZ25lZCBpbnQgaHQ0MF9pbnRvbGVyYW50X3NldDoxOwogCXVuc2lnbmVkIGludCBodF8yMG1oel9zZXQ6MTsKIAl1bnNpZ25lZCBpbnQgbm9fcDJwX3NldDoxOworCXVuc2lnbmVkIGludCBxb3NfbWFwX2VuYWJsZWQ6MTsKKwl1bnNpZ25lZCBpbnQgcmVtZWRpYXRpb246MTsKKwl1bnNpZ25lZCBpbnQgaHMyMF9kZWF1dGhfcmVxdWVzdGVkOjE7CiAKIAl1MTYgYXV0aF9hbGc7Ci0JdTggcHJldmlvdXNfYXBbNl07CiAKIAllbnVtIHsKIAkJU1RBX05VTExGVU5DID0gMCwgU1RBX0RJU0FTU09DLCBTVEFfREVBVVRILCBTVEFfUkVNT1ZFLApAQCAtNzIsMTIgKzc0LDkgQEAKIAkvKiBJRUVFIDgwMi4xWCByZWxhdGVkIGRhdGEgKi8KIAlzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqZWFwb2xfc207CiAKLQkvKiBJRUVFIDgwMi4xMWYgKElBUFApIHJlbGF0ZWQgZGF0YSAqLwotCXN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbGFzdF9hc3NvY19yZXE7Ci0KIAl1MzIgYWNjdF9zZXNzaW9uX2lkX2hpOwogCXUzMiBhY2N0X3Nlc3Npb25faWRfbG87Ci0JdGltZV90IGFjY3Rfc2Vzc2lvbl9zdGFydDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBhY2N0X3Nlc3Npb25fc3RhcnQ7CiAJaW50IGFjY3Rfc2Vzc2lvbl9zdGFydGVkOwogCWludCBhY2N0X3Rlcm1pbmF0ZV9jYXVzZTsgLyogQWNjdC1UZXJtaW5hdGUtQ2F1c2UgKi8KIAlpbnQgYWNjdF9pbnRlcmltX2ludGVydmFsOyAvKiBBY2N0LUludGVyaW0tSW50ZXJ2YWwgKi8KQEAgLTEwNCw2ICsxMDMsNyBAQAogCiAJc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgKmh0X2NhcGFiaWxpdGllczsKIAlzdHJ1Y3QgaWVlZTgwMjExX3ZodF9jYXBhYmlsaXRpZXMgKnZodF9jYXBhYmlsaXRpZXM7CisJdTggdmh0X29wbW9kZTsKIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJaW50IHNhX3F1ZXJ5X2NvdW50OyAvKiBudW1iZXIgb2YgcGVuZGluZyBTQSBRdWVyeSByZXF1ZXN0czsKQEAgLTExMiw3ICsxMTIsNyBAQAogCXU4ICpzYV9xdWVyeV90cmFuc19pZDsgLyogYnVmZmVyIG9mIFdMQU5fU0FfUVVFUllfVFJfSURfTEVOICoKIAkJCQkqIHNhX3F1ZXJ5X2NvdW50IG9jdGV0cyBvZiBwZW5kaW5nIFNBIFF1ZXJ5CiAJCQkJKiB0cmFuc2FjdGlvbiBpZGVudGlmaWVycyAqLwotCXN0cnVjdCBvc190aW1lIHNhX3F1ZXJ5X3N0YXJ0OworCXN0cnVjdCBvc19yZWx0aW1lIHNhX3F1ZXJ5X3N0YXJ0OwogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAKICNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCkBAIC0xMjQsOCArMTI0LDEzIEBACiAJc3RydWN0IHdwYWJ1ZiAqd3BzX2llOyAvKiBXUFMgSUUgZnJvbSAoUmUpQXNzb2NpYXRpb24gUmVxdWVzdCAqLwogCXN0cnVjdCB3cGFidWYgKnAycF9pZTsgLyogUDJQIElFIGZyb20gKFJlKUFzc29jaWF0aW9uIFJlcXVlc3QgKi8KIAlzdHJ1Y3Qgd3BhYnVmICpoczIwX2llOyAvKiBIUyAyLjAgSUUgZnJvbSAoUmUpQXNzb2NpYXRpb24gUmVxdWVzdCAqLworCXU4IHJlbWVkaWF0aW9uX21ldGhvZDsKKwljaGFyICpyZW1lZGlhdGlvbl91cmw7IC8qIEhTIDIuMCBTdWJzY3JpcHRpb24gUmVtZWRpYXRpb24gU2VydmVyIFVSTCAqLworCXN0cnVjdCB3cGFidWYgKmhzMjBfZGVhdXRoX3JlcTsKKwljaGFyICpoczIwX3Nlc3Npb25faW5mb191cmw7CisJaW50IGhzMjBfZGlzYXNzb2NfdGltZXI7CiAKLQlzdHJ1Y3Qgb3NfdGltZSBjb25uZWN0ZWRfdGltZTsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBjb25uZWN0ZWRfdGltZTsKIAogI2lmZGVmIENPTkZJR19TQUUKIAlzdHJ1Y3Qgc2FlX2RhdGEgKnNhZTsKQEAgLTE2MSwxMCArMTY2LDE0IEBACiB2b2lkIGFwX2ZyZWVfc3RhKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhKTsKIHZvaWQgaG9zdGFwZF9mcmVlX3N0YXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CiB2b2lkIGFwX2hhbmRsZV90aW1lcih2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KTsKK3ZvaWQgYXBfc3RhX3JlcGxlbmlzaF90aW1lb3V0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAorCQkJICAgICAgdTMyIHNlc3Npb25fdGltZW91dCk7CiB2b2lkIGFwX3N0YV9zZXNzaW9uX3RpbWVvdXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEsCiAJCQkgICAgdTMyIHNlc3Npb25fdGltZW91dCk7CiB2b2lkIGFwX3N0YV9ub19zZXNzaW9uX3RpbWVvdXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKIAkJCSAgICAgICBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSk7Cit2b2lkIGFwX3N0YV9zZXNzaW9uX3dhcm5pbmdfdGltZW91dChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgICBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwgaW50IHdhcm5pbmdfdGltZSk7CiBzdHJ1Y3Qgc3RhX2luZm8gKiBhcF9zdGFfYWRkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICphZGRyKTsKIHZvaWQgYXBfc3RhX2Rpc2Fzc29jaWF0ZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJCSB1MTYgcmVhc29uKTsKQEAgLTE5Miw0ICsyMDEsNiBAQAogdm9pZCBhcF9zdGFfZGVhdXRoX2NiKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhKTsKIHZvaWQgYXBfc3RhX2Rpc2Fzc29jX2NiKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhKTsKIAoraW50IGFwX3N0YV9mbGFnc190eHQodTMyIGZsYWdzLCBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pOworCiAjZW5kaWYgLyogU1RBX0lORk9fSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2FwL3RraXBfY291bnRlcm1lYXN1cmVzLmMgYi9zcmMvYXAvdGtpcF9jb3VudGVybWVhc3VyZXMuYwppbmRleCA0YTJlYTA2Li40NzI1ZTJiIDEwMDY0NAotLS0gYS9zcmMvYXAvdGtpcF9jb3VudGVybWVhc3VyZXMuYworKysgYi9zcmMvYXAvdGtpcF9jb3VudGVybWVhc3VyZXMuYwpAQCAtNjgsNyArNjgsNyBAQAogCiBpbnQgbWljaGFlbF9taWNfZmFpbHVyZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkciwgaW50IGxvY2FsKQogewotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAJaW50IHJldCA9IDA7CiAKIAlpZiAoYWRkciAmJiBsb2NhbCkgewpAQCAtODksOCArODksOCBAQAogCQl9CiAJfQogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7Ci0JaWYgKG5vdy5zZWMgPiBoYXBkLT5taWNoYWVsX21pY19mYWlsdXJlICsgNjApIHsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKKwlpZiAob3NfcmVsdGltZV9leHBpcmVkKCZub3csICZoYXBkLT5taWNoYWVsX21pY19mYWlsdXJlLCA2MCkpIHsKIAkJaGFwZC0+bWljaGFlbF9taWNfZmFpbHVyZXMgPSAxOwogCX0gZWxzZSB7CiAJCWhhcGQtPm1pY2hhZWxfbWljX2ZhaWx1cmVzKys7CkBAIC05OSw3ICs5OSw3IEBACiAJCQlyZXQgPSAxOwogCQl9CiAJfQotCWhhcGQtPm1pY2hhZWxfbWljX2ZhaWx1cmUgPSBub3cuc2VjOworCWhhcGQtPm1pY2hhZWxfbWljX2ZhaWx1cmUgPSBub3c7CiAKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL3ZsYW5faW5pdC5jIGIvc3JjL2FwL3ZsYW5faW5pdC5jCmluZGV4IDc0NmFmNDAuLjRlNGEzNTIgMTAwNjQ0Ci0tLSBhL3NyYy9hcC92bGFuX2luaXQuYworKysgYi9zcmMvYXAvdmxhbl9pbml0LmMKQEAgLTQsMTQgKzQsOCBAQAogICogQ29weXJpZ2h0IDIwMDUtMjAwNiwgRGV2aWNlc2NhcGUgU29mdHdhcmUsIEluYy4KICAqIENvcHlyaWdodCAoYykgMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKQEAgLTQ4MCwxMjMgKzQ3NCw2IEBACiAjZW5kaWYgLyogQ09ORklHX1ZMQU5fTkVUTElOSyAqLwogCiAKLS8qKgotICogSW5jcmVhc2UgdGhlIHVzYWdlIGNvdW50ZXIgZm9yIGdpdmVuIHBhcmVudC9pZm5hbWUgY29tYmluYXRpb24uCi0gKiBJZiBjcmVhdGUgaXMgc2V0LCB0aGVuIHRoaXMgaWZhY2UgaXMgYWRkZWQgdG8gdGhlIGdsb2JhbCBsaXN0LgotICogUmV0dXJucwotICogCS0xIG9uIGVycm9yCi0gKiAJMCBpZiBpZmFjZSBpcyBub3QgaW4gbGlzdAotICogCTEgaWYgaWZhY2UgaXMgaW4gbGlzdCAod2FzIHRoZXJlIG9yIGhhcyBiZWVuIGFkZGVkKQotICovCi1zdGF0aWMgaW50IGhhcGRfZ2V0X2R5bmFtaWNfaWZhY2UoY29uc3QgY2hhciAqcGFyZW50LCBjb25zdCBjaGFyICppZm5hbWUsCi0JCQkJICBpbnQgY3JlYXRlLCBzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQotewotCXNpemVfdCBpOwotCXN0cnVjdCBob3N0YXBkX2R5bmFtaWNfaWZhY2UgKmogPSBOVUxMLCAqKnRtcDsKLQlzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICpoYXBkX2dsb2JhbCA9IGhhcGQtPmlmYWNlLT5pbnRlcmZhY2VzOwotCi0JaWYgKCFwYXJlbnQpCi0JCXBhcmVudCA9ICIiOwotCi0JZm9yIChpID0gMDsgaSA8IGhhcGRfZ2xvYmFsLT5jb3VudF9keW5hbWljOyBpKyspIHsKLQkJaiA9IGhhcGRfZ2xvYmFsLT5keW5hbWljX2lmYWNlW2ldOwotCQlpZiAob3Nfc3RybmNtcChqLT5pZmFjZSwgaWZuYW1lLCBzaXplb2Yoai0+aWZhY2UpKSA9PSAwICYmCi0JCSAgICBvc19zdHJuY21wKGotPnBhcmVudCwgcGFyZW50LCBzaXplb2Yoai0+cGFyZW50KSkgPT0gMCkKLQkJCWJyZWFrOwotCX0KLQlpZiAoaSA8IGhhcGRfZ2xvYmFsLT5jb3VudF9keW5hbWljKSB7Ci0JCWotPnVzYWdlKys7Ci0JCXJldHVybiAxOwotCX0KLQotCS8qIG5ldyBlbnRyeSByZXF1aXJlZCAqLwotCWlmICghY3JlYXRlKQotCQlyZXR1cm4gMDsKLQotCWogPSBvc196YWxsb2Moc2l6ZW9mKCpqKSk7Ci0JaWYgKCFqKQotCQlyZXR1cm4gLTE7Ci0Jb3Nfc3RybGNweShqLT5pZmFjZSwgaWZuYW1lLCBzaXplb2Yoai0+aWZhY2UpKTsKLQlvc19zdHJsY3B5KGotPnBhcmVudCwgcGFyZW50LCBzaXplb2Yoai0+cGFyZW50KSk7Ci0KLQl0bXAgPSBvc19yZWFsbG9jX2FycmF5KGhhcGRfZ2xvYmFsLT5keW5hbWljX2lmYWNlLCBpICsgMSwKLQkJCSAgICAgICBzaXplb2YoKmhhcGRfZ2xvYmFsLT5keW5hbWljX2lmYWNlKSk7Ci0JaWYgKCF0bXApIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJWTEFOOiBGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5IGluICVzIiwKLQkJCSAgIF9fZnVuY19fKTsKLQkJcmV0dXJuIC0xOwotCX0KLQloYXBkX2dsb2JhbC0+Y291bnRfZHluYW1pYysrOwotCWhhcGRfZ2xvYmFsLT5keW5hbWljX2lmYWNlID0gdG1wOwotCWhhcGRfZ2xvYmFsLT5keW5hbWljX2lmYWNlW2ldID0gajsKLQotCXJldHVybiAxOwotfQotCi0KLS8qKgotICogRGVjcmVhc2UgdGhlIHVzYWdlIGNvdW50ZXIgZm9yIGdpdmVuIGlmbmFtZS4KLSAqIFJldHVybnMKLSAqICAgICAtMSBvbiBlcnJvciBvciBpZiBpZmFjZSB3YXMgbm90IGZvdW5kCi0gKiAgICAgMCBpZiBpZmFjZSB3YXMgZm91bmQgYW5kIGlzIHN0aWxsIHByZXNlbnQKLSAqICAgICAxIGlmIGlmYWNlIHdhcyByZW1vdmVkIGZyb20gZ2xvYmFsIGxpc3QKLSAqLwotc3RhdGljIGludCBoYXBkX3B1dF9keW5hbWljX2lmYWNlKGNvbnN0IGNoYXIgKnBhcmVudCwgY29uc3QgY2hhciAqaWZuYW1lLAotCQkJCSAgc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKLXsKLQlzaXplX3QgaTsKLQlzdHJ1Y3QgaG9zdGFwZF9keW5hbWljX2lmYWNlICpqID0gTlVMTCwgKip0bXA7Ci0Jc3RydWN0IGhhcGRfaW50ZXJmYWNlcyAqaGFwZF9nbG9iID0gaGFwZC0+aWZhY2UtPmludGVyZmFjZXM7Ci0KLQlpZiAoIXBhcmVudCkKLQkJcGFyZW50ID0gIiI7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgaGFwZF9nbG9iLT5jb3VudF9keW5hbWljOyBpKyspIHsKLQkJaiA9IGhhcGRfZ2xvYi0+ZHluYW1pY19pZmFjZVtpXTsKLQkJaWYgKG9zX3N0cm5jbXAoai0+aWZhY2UsIGlmbmFtZSwgc2l6ZW9mKGotPmlmYWNlKSkgPT0gMCAmJgotCQkgICAgb3Nfc3RybmNtcChqLT5wYXJlbnQsIHBhcmVudCwgc2l6ZW9mKGotPnBhcmVudCkpID09IDApCi0JCQlicmVhazsKLQl9Ci0KLQlpZiAoaSA9PSBoYXBkX2dsb2ItPmNvdW50X2R5bmFtaWMpIHsKLQkJLyoKLQkJICogSW50ZXJmYWNlIG5vdCBpbiBnbG9iYWwgbGlzdC4gVGhpcyBjYW4gaGFwcGVuIGlmIGFsbG9jIGluCi0JCSAqIF9nZXRfIGZhaWxlZC4KLQkJICovCi0JCXJldHVybiAtMTsKLQl9Ci0KLQlpZiAoai0+dXNhZ2UgPiAwKSB7Ci0JCWotPnVzYWdlLS07Ci0JCXJldHVybiAwOwotCX0KLQotCW9zX2ZyZWUoaik7Ci0JZm9yICg7IGkgPCBoYXBkX2dsb2ItPmNvdW50X2R5bmFtaWMgLSAxOyBpKyspCi0JCWhhcGRfZ2xvYi0+ZHluYW1pY19pZmFjZVtpXSA9IGhhcGRfZ2xvYi0+ZHluYW1pY19pZmFjZVtpICsgMV07Ci0JaGFwZF9nbG9iLT5keW5hbWljX2lmYWNlW2hhcGRfZ2xvYi0+Y291bnRfZHluYW1pYyAtIDFdID0gTlVMTDsKLQloYXBkX2dsb2ItPmNvdW50X2R5bmFtaWMtLTsKLQotCWlmIChoYXBkX2dsb2ItPmNvdW50X2R5bmFtaWMgPT0gMCkgewotCQlvc19mcmVlKGhhcGRfZ2xvYi0+ZHluYW1pY19pZmFjZSk7Ci0JCWhhcGRfZ2xvYi0+ZHluYW1pY19pZmFjZSA9IE5VTEw7Ci0JCXJldHVybiAxOwotCX0KLQotCXRtcCA9IG9zX3JlYWxsb2NfYXJyYXkoaGFwZF9nbG9iLT5keW5hbWljX2lmYWNlLAotCQkJICAgICAgIGhhcGRfZ2xvYi0+Y291bnRfZHluYW1pYywKLQkJCSAgICAgICBzaXplb2YoKmhhcGRfZ2xvYi0+ZHluYW1pY19pZmFjZSkpOwotCWlmICghdG1wKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiVkxBTjogRmFpbGVkIHRvIHJlbGVhc2UgbWVtb3J5IGluICVzIiwKLQkJCSAgIF9fZnVuY19fKTsKLQkJcmV0dXJuIC0xOwotCX0KLQloYXBkX2dsb2ItPmR5bmFtaWNfaWZhY2UgPSB0bXA7Ci0KLQlyZXR1cm4gMTsKLX0KLQotCiBzdGF0aWMgdm9pZCB2bGFuX25ld2xpbmsoY2hhciAqaWZuYW1lLCBzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQogewogCWNoYXIgdmxhbl9pZm5hbWVbSUZOQU1TSVpdOwpAQCAtNjA0LDcgKzQ4MSw2IEBACiAJc3RydWN0IGhvc3RhcGRfdmxhbiAqdmxhbiA9IGhhcGQtPmNvbmYtPnZsYW47CiAJY2hhciAqdGFnZ2VkX2ludGVyZmFjZSA9IGhhcGQtPmNvbmYtPnNzaWQudmxhbl90YWdnZWRfaW50ZXJmYWNlOwogCWludCB2bGFuX25hbWluZyA9IGhhcGQtPmNvbmYtPnNzaWQudmxhbl9uYW1pbmc7Ci0JaW50IHJldDsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVkxBTjogdmxhbl9uZXdsaW5rKCVzKSIsIGlmbmFtZSk7CiAKQEAgLTYyNCw5ICs1MDAsNyBAQAogCQkJCSAgICAgICAgICAgICJicnZsYW4lZCIsIHZsYW4tPnZsYW5faWQpOwogCQkJfQogCi0JCQlyZXQgPSBicl9hZGRicihicl9uYW1lKTsKLQkJCWlmIChoYXBkX2dldF9keW5hbWljX2lmYWNlKE5VTEwsIGJyX25hbWUsIHJldCA9PSAwLAotCQkJICAgICAgICAgICAgICAgICAgICAgICAgICAgaGFwZCkpCisJCQlpZiAoIWJyX2FkZGJyKGJyX25hbWUpKQogCQkJCXZsYW4tPmNsZWFuIHw9IERWTEFOX0NMRUFOX0JSOwogCiAJCQlpZmNvbmZpZ191cChicl9uYW1lKTsKQEAgLTY0NCwyNCArNTE4LDE3IEBACiAJCQkJCQkgICAgInZsYW4lZCIsIHZsYW4tPnZsYW5faWQpOwogCiAJCQkJaWZjb25maWdfdXAodGFnZ2VkX2ludGVyZmFjZSk7Ci0JCQkJcmV0ID0gdmxhbl9hZGQodGFnZ2VkX2ludGVyZmFjZSwgdmxhbi0+dmxhbl9pZCwKLQkJCQkJICAgICAgdmxhbl9pZm5hbWUpOwotCQkJCWlmIChoYXBkX2dldF9keW5hbWljX2lmYWNlKE5VTEwsIHZsYW5faWZuYW1lLAotCQkJCSAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldCA9PSAwLCBoYXBkKSkKKwkJCQlpZiAoIXZsYW5fYWRkKHRhZ2dlZF9pbnRlcmZhY2UsIHZsYW4tPnZsYW5faWQsCisJCQkJCSAgICAgIHZsYW5faWZuYW1lKSkKIAkJCQkJdmxhbi0+Y2xlYW4gfD0gRFZMQU5fQ0xFQU5fVkxBTjsKIAotCQkJCXJldCA9IGJyX2FkZGlmKGJyX25hbWUsIHZsYW5faWZuYW1lKTsKLQkJCQlpZiAoaGFwZF9nZXRfZHluYW1pY19pZmFjZShicl9uYW1lLAotCQkJCQkJCSAgIHZsYW5faWZuYW1lLAotCQkJCQkJCSAgIHJldCA9PSAwLCBoYXBkKSkKKwkJCQlpZiAoIWJyX2FkZGlmKGJyX25hbWUsIHZsYW5faWZuYW1lKSkKIAkJCQkJdmxhbi0+Y2xlYW4gfD0gRFZMQU5fQ0xFQU5fVkxBTl9QT1JUOwogCiAJCQkJaWZjb25maWdfdXAodmxhbl9pZm5hbWUpOwogCQkJfQogCi0JCQlyZXQgPSBicl9hZGRpZihicl9uYW1lLCBpZm5hbWUpOwotCQkJaWYgKGhhcGRfZ2V0X2R5bmFtaWNfaWZhY2UoYnJfbmFtZSwgaWZuYW1lLCByZXQgPT0gMCwKLQkJCQkJCSAgIGhhcGQpKQorCQkJaWYgKCFicl9hZGRpZihicl9uYW1lLCBpZm5hbWUpKQogCQkJCXZsYW4tPmNsZWFuIHw9IERWTEFOX0NMRUFOX1dMQU5fUE9SVDsKIAogCQkJaWZjb25maWdfdXAoaWZuYW1lKTsKQEAgLTcwMCw4ICs1NjcsNyBAQAogCQkJCSAgICAgICAgICAgICJicnZsYW4lZCIsIHZsYW4tPnZsYW5faWQpOwogCQkJfQogCi0JCQlpZiAoKHZsYW4tPmNsZWFuICYgRFZMQU5fQ0xFQU5fV0xBTl9QT1JUKSAmJgotCQkJICAgIGhhcGRfcHV0X2R5bmFtaWNfaWZhY2UoYnJfbmFtZSwgdmxhbi0+aWZuYW1lLCBoYXBkKSkKKwkJCWlmICh2bGFuLT5jbGVhbiAmIERWTEFOX0NMRUFOX1dMQU5fUE9SVCkKIAkJCQlicl9kZWxpZihicl9uYW1lLCB2bGFuLT5pZm5hbWUpOwogCiAJCQlpZiAodGFnZ2VkX2ludGVyZmFjZSkgewpAQCAtNzE1LDIwICs1ODEsMTUgQEAKIAkJCQkJb3Nfc25wcmludGYodmxhbl9pZm5hbWUsCiAJCQkJCQkgICAgc2l6ZW9mKHZsYW5faWZuYW1lKSwKIAkJCQkJCSAgICAidmxhbiVkIiwgdmxhbi0+dmxhbl9pZCk7Ci0JCQkJaWYgKCh2bGFuLT5jbGVhbiAmIERWTEFOX0NMRUFOX1ZMQU5fUE9SVCkgJiYKLQkJCQkgICAgaGFwZF9wdXRfZHluYW1pY19pZmFjZShicl9uYW1lLCB2bGFuX2lmbmFtZSwKLQkJCQkJCQkgICBoYXBkKSkKKwkJCQlpZiAodmxhbi0+Y2xlYW4gJiBEVkxBTl9DTEVBTl9WTEFOX1BPUlQpCiAJCQkJCWJyX2RlbGlmKGJyX25hbWUsIHZsYW5faWZuYW1lKTsKIAkJCQlpZmNvbmZpZ19kb3duKHZsYW5faWZuYW1lKTsKIAotCQkJCWlmICgodmxhbi0+Y2xlYW4gJiBEVkxBTl9DTEVBTl9WTEFOKSAmJgotCQkJCSAgICBoYXBkX3B1dF9keW5hbWljX2lmYWNlKE5VTEwsIHZsYW5faWZuYW1lLAotCQkJCQkJCSAgIGhhcGQpKQorCQkJCWlmICh2bGFuLT5jbGVhbiAmIERWTEFOX0NMRUFOX1ZMQU4pCiAJCQkJCXZsYW5fcmVtKHZsYW5faWZuYW1lKTsKIAkJCX0KIAogCQkJaWYgKCh2bGFuLT5jbGVhbiAmIERWTEFOX0NMRUFOX0JSKSAmJgotCQkJICAgIGhhcGRfcHV0X2R5bmFtaWNfaWZhY2UoTlVMTCwgYnJfbmFtZSwgaGFwZCkgJiYKIAkJCSAgICBicl9nZXRudW1wb3J0cyhicl9uYW1lKSA9PSAwKSB7CiAJCQkJaWZjb25maWdfZG93bihicl9uYW1lKTsKIAkJCQlicl9kZWxicihicl9uYW1lKTsKQEAgLTEwMjEsNiArODgyLDcgQEAKIAogI2lmZGVmIENPTkZJR19GVUxMX0RZTkFNSUNfVkxBTgogCWZ1bGxfZHluYW1pY192bGFuX2RlaW5pdChoYXBkLT5mdWxsX2R5bmFtaWNfdmxhbik7CisJaGFwZC0+ZnVsbF9keW5hbWljX3ZsYW4gPSBOVUxMOwogI2VuZGlmIC8qIENPTkZJR19GVUxMX0RZTkFNSUNfVkxBTiAqLwogfQogCmRpZmYgLS1naXQgYS9zcmMvYXAvdmxhbl9pbml0LmggYi9zcmMvYXAvdmxhbl9pbml0LmgKaW5kZXggMzgyZDVkZS4uNzgxZWFhYyAxMDA2NDQKLS0tIGEvc3JjL2FwL3ZsYW5faW5pdC5oCisrKyBiL3NyYy9hcC92bGFuX2luaXQuaApAQCAtMywxNCArMyw4IEBACiAgKiBDb3B5cmlnaHQgMjAwMywgSW5zdGFudDgwMiBOZXR3b3JrcywgSW5jLgogICogQ29weXJpZ2h0IDIwMDUsIERldmljZXNjYXBlIFNvZnR3YXJlLCBJbmMuCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBWTEFOX0lOSVRfSApkaWZmIC0tZ2l0IGEvc3JjL2FwL3dtbS5jIGIvc3JjL2FwL3dtbS5jCmluZGV4IGQyMWM4MmYuLjZkNDE3N2MgMTAwNjQ0Ci0tLSBhL3NyYy9hcC93bW0uYworKysgYi9zcmMvYXAvd21tLmMKQEAgLTQsMTQgKzQsOCBAQAogICogQ29weXJpZ2h0IDIwMDUtMjAwNiwgRGV2aWNlc2NhcGUgU29mdHdhcmUsIEluYy4KICAqIENvcHlyaWdodCAoYykgMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKQEAgLTE1Nyw3ICsxNTEsNyBAQAogCWxlbiA9ICgodTggKikgKHQgKyAxKSkgLSBidWY7CiAKIAlpZiAoaG9zdGFwZF9kcnZfc2VuZF9tbG1lKGhhcGQsIG0sIGxlbiwgMCkgPCAwKQotCQlwZXJyb3IoIndtbV9zZW5kX2FjdGlvbjogc2VuZCIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAid21tX3NlbmRfYWN0aW9uOiBzZW5kIGZhaWxlZCIpOwogfQogCiAKZGlmZiAtLWdpdCBhL3NyYy9hcC93bW0uaCBiL3NyYy9hcC93bW0uaAppbmRleCA5NmIwNGU4Li5iNzBiODYzIDEwMDY0NAotLS0gYS9zcmMvYXAvd21tLmgKKysrIGIvc3JjL2FwL3dtbS5oCkBAIC0zLDE0ICszLDggQEAKICAqIENvcHlyaWdodCAyMDAyLTIwMDMsIEluc3RhbnQ4MDIgTmV0d29ya3MsIEluYy4KICAqIENvcHlyaWdodCAyMDA1LTIwMDYsIERldmljZXNjYXBlIFNvZnR3YXJlLCBJbmMuCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBXTUVfSApkaWZmIC0tZ2l0IGEvc3JjL2FwL3dubV9hcC5jIGIvc3JjL2FwL3dubV9hcC5jCmluZGV4IDU0YTZiODUuLmNmMjVkYmIgMTAwNjQ0Ci0tLSBhL3NyYy9hcC93bm1fYXAuYworKysgYi9zcmMvYXAvd25tX2FwLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAtIFdOTQotICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTIsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTksNiArOSw3IEBACiAjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKIAogI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgInV0aWxzL2Vsb29wLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImFwL2hvc3RhcGQuaCIKICNpbmNsdWRlICJhcC9zdGFfaW5mby5oIgpAQCAtNzIsNyArNzMsNyBAQAogCXdubXNsZWVwX2llLmxlbiA9IHdubXNsZWVwX2llX2xlbiAtIDI7CiAJd25tc2xlZXBfaWUuYWN0aW9uX3R5cGUgPSBhY3Rpb25fdHlwZTsKIAl3bm1zbGVlcF9pZS5zdGF0dXMgPSBXTk1fU1RBVFVTX1NMRUVQX0FDQ0VQVDsKLQl3bm1zbGVlcF9pZS5pbnR2YWwgPSBpbnR2YWw7CisJd25tc2xlZXBfaWUuaW50dmFsID0gaG9zdF90b19sZTE2KGludHZhbCk7CiAKIAkvKiBURlMgSUUocykgKi8KIAl3bm10ZnNfaWUgPSBvc196YWxsb2MoTUFYX1RGU19JRV9MRU4pOwpAQCAtMTU0LDYgKzE1NSw3IEBACiAJCSAqLwogCQlpZiAod25tc2xlZXBfaWUuc3RhdHVzID09IFdOTV9TVEFUVVNfU0xFRVBfQUNDRVBUICYmCiAJCSAgICB3bm1zbGVlcF9pZS5hY3Rpb25fdHlwZSA9PSBXTk1fU0xFRVBfTU9ERV9FTlRFUikgeworCQkJc3RhLT5mbGFncyB8PSBXTEFOX1NUQV9XTk1fU0xFRVBfTU9ERTsKIAkJCWhvc3RhcGRfZHJ2X3dubV9vcGVyKGhhcGQsIFdOTV9TTEVFUF9FTlRFUl9DT05GSVJNLAogCQkJCQkgICAgIGFkZHIsIE5VTEwsIE5VTEwpOwogCQkJd3BhX3NldF93bm1zbGVlcChzdGEtPndwYV9zbSwgMSk7CkBAIC0xNjcsNiArMTY5LDcgQEAKIAkJICAgICB3bm1zbGVlcF9pZS5zdGF0dXMgPT0KIAkJICAgICBXTk1fU1RBVFVTX1NMRUVQX0VYSVRfQUNDRVBUX0dUS19VUERBVEUpICYmCiAJCSAgICB3bm1zbGVlcF9pZS5hY3Rpb25fdHlwZSA9PSBXTk1fU0xFRVBfTU9ERV9FWElUKSB7CisJCQlzdGEtPmZsYWdzICY9IH5XTEFOX1NUQV9XTk1fU0xFRVBfTU9ERTsKIAkJCXdwYV9zZXRfd25tc2xlZXAoc3RhLT53cGFfc20sIDApOwogCQkJaG9zdGFwZF9kcnZfd25tX29wZXIoaGFwZCwgV05NX1NMRUVQX0VYSVRfQ09ORklSTSwKIAkJCQkJICAgICBhZGRyLCBOVUxMLCBOVUxMKTsKQEAgLTIzMyw3ICsyMzYsNyBAQAogCiAJaWVlZTgwMl8xMV9zZW5kX3dubXNsZWVwX3Jlc3AoaGFwZCwgYWRkciwgZGlhbG9nX3Rva2VuLAogCQkJCSAgICAgIHdubXNsZWVwX2llLT5hY3Rpb25fdHlwZSwKLQkJCQkgICAgICB3bm1zbGVlcF9pZS0+aW50dmFsKTsKKwkJCQkgICAgICBsZV90b19ob3N0MTYod25tc2xlZXBfaWUtPmludHZhbCkpOwogCiAJaWYgKHdubXNsZWVwX2llLT5hY3Rpb25fdHlwZSA9PSBXTk1fU0xFRVBfTU9ERV9FWElUKSB7CiAJCS8qIGNsZWFyIHRoZSB0ZnMgYWZ0ZXIgc2VuZGluZyB0aGUgcmVzcCBmcmFtZSAqLwpAQCAtMjQzLDI5ICsyNDYsMjYyIEBACiB9CiAKIAotaW50IGllZWU4MDJfMTFfcnhfd25tX2FjdGlvbl9hcChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAotCQkJCXN0cnVjdCByeF9hY3Rpb24gKmFjdGlvbikKK3N0YXRpYyBpbnQgaWVlZTgwMl8xMV9zZW5kX2Jzc190cmFuc19tZ210X3JlcXVlc3Qoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJCSAgY29uc3QgdTggKmFkZHIsCisJCQkJCQkgIHU4IGRpYWxvZ190b2tlbiwKKwkJCQkJCSAgY29uc3QgY2hhciAqdXJsKQogewotCWlmIChhY3Rpb24tPmxlbiA8IDEgfHwgYWN0aW9uLT5kYXRhID09IE5VTEwpCisJc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210OworCXNpemVfdCB1cmxfbGVuLCBsZW47CisJdTggKnBvczsKKwlpbnQgcmVzOworCisJaWYgKHVybCkKKwkJdXJsX2xlbiA9IG9zX3N0cmxlbih1cmwpOworCWVsc2UKKwkJdXJsX2xlbiA9IDA7CisKKwltZ210ID0gb3NfemFsbG9jKHNpemVvZigqbWdtdCkgKyAodXJsX2xlbiA/IDEgKyB1cmxfbGVuIDogMCkpOworCWlmIChtZ210ID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlvc19tZW1jcHkobWdtdC0+ZGEsIGFkZHIsIEVUSF9BTEVOKTsKKwlvc19tZW1jcHkobWdtdC0+c2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7CisJb3NfbWVtY3B5KG1nbXQtPmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOworCW1nbXQtPmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCisJCQkJCSAgIFdMQU5fRkNfU1RZUEVfQUNUSU9OKTsKKwltZ210LT51LmFjdGlvbi5jYXRlZ29yeSA9IFdMQU5fQUNUSU9OX1dOTTsKKwltZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEuYWN0aW9uID0gV05NX0JTU19UUkFOU19NR01UX1JFUTsKKwltZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEuZGlhbG9nX3Rva2VuID0gZGlhbG9nX3Rva2VuOworCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5yZXFfbW9kZSA9IDA7CisJbWdtdC0+dS5hY3Rpb24udS5ic3NfdG1fcmVxLmRpc2Fzc29jX3RpbWVyID0gaG9zdF90b19sZTE2KDApOworCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS52YWxpZGl0eV9pbnRlcnZhbCA9IDE7CisJcG9zID0gbWdtdC0+dS5hY3Rpb24udS5ic3NfdG1fcmVxLnZhcmlhYmxlOworCWlmICh1cmwpIHsKKwkJKnBvcysrICs9IHVybF9sZW47CisJCW9zX21lbWNweShwb3MsIHVybCwgdXJsX2xlbik7CisJCXBvcyArPSB1cmxfbGVuOworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBTZW5kIEJTUyBUcmFuc2l0aW9uIE1hbmFnZW1lbnQgUmVxdWVzdCB0byAiCisJCSAgIE1BQ1NUUiAiIGRpYWxvZ190b2tlbj0ldSByZXFfbW9kZT0weCV4IGRpc2Fzc29jX3RpbWVyPSV1ICIKKwkJICAgInZhbGlkaXR5X2ludGVydmFsPSV1IiwKKwkJICAgTUFDMlNUUihhZGRyKSwgZGlhbG9nX3Rva2VuLAorCQkgICBtZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEucmVxX21vZGUsCisJCSAgIGxlX3RvX2hvc3QxNihtZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEuZGlzYXNzb2NfdGltZXIpLAorCQkgICBtZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEudmFsaWRpdHlfaW50ZXJ2YWwpOworCisJbGVuID0gcG9zIC0gJm1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5OworCXJlcyA9IGhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLAorCQkJCSAgICAgIG1nbXQtPmRhLCAmbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnksIGxlbik7CisJb3NfZnJlZShtZ210KTsKKwlyZXR1cm4gcmVzOworfQorCisKK3N0YXRpYyB2b2lkIGllZWU4MDJfMTFfcnhfYnNzX3RyYW5zX21nbXRfcXVlcnkoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJICAgICAgIGNvbnN0IHU4ICphZGRyLCBjb25zdCB1OCAqZnJtLAorCQkJCQkgICAgICAgc2l6ZV90IGxlbikKK3sKKwl1OCBkaWFsb2dfdG9rZW4sIHJlYXNvbjsKKwljb25zdCB1OCAqcG9zLCAqZW5kOworCisJaWYgKGxlbiA8IDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IElnbm9yZSB0b28gc2hvcnQgQlNTIFRyYW5zaXRpb24gTWFuYWdlbWVudCBRdWVyeSBmcm9tICIKKwkJCSAgIE1BQ1NUUiwgTUFDMlNUUihhZGRyKSk7CisJCXJldHVybjsKKwl9CisKKwlwb3MgPSBmcm07CisJZW5kID0gcG9zICsgbGVuOworCWRpYWxvZ190b2tlbiA9ICpwb3MrKzsKKwlyZWFzb24gPSAqcG9zKys7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogQlNTIFRyYW5zaXRpb24gTWFuYWdlbWVudCBRdWVyeSBmcm9tICIKKwkJICAgTUFDU1RSICIgZGlhbG9nX3Rva2VuPSV1IHJlYXNvbj0ldSIsCisJCSAgIE1BQzJTVFIoYWRkciksIGRpYWxvZ190b2tlbiwgcmVhc29uKTsKKworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldOTTogQlNTIFRyYW5zaXRpb24gQ2FuZGlkYXRlIExpc3QgRW50cmllcyIsCisJCSAgICBwb3MsIGVuZCAtIHBvcyk7CisKKwlpZWVlODAyXzExX3NlbmRfYnNzX3RyYW5zX21nbXRfcmVxdWVzdChoYXBkLCBhZGRyLCBkaWFsb2dfdG9rZW4sIE5VTEwpOworfQorCisKK3N0YXRpYyB2b2lkIGllZWU4MDJfMTFfcnhfYnNzX3RyYW5zX21nbXRfcmVzcChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgICAgICBjb25zdCB1OCAqYWRkciwgY29uc3QgdTggKmZybSwKKwkJCQkJICAgICAgc2l6ZV90IGxlbikKK3sKKwl1OCBkaWFsb2dfdG9rZW4sIHN0YXR1c19jb2RlLCBic3NfdGVybWluYXRpb25fZGVsYXk7CisJY29uc3QgdTggKnBvcywgKmVuZDsKKworCWlmIChsZW4gPCAzKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBJZ25vcmUgdG9vIHNob3J0IEJTUyBUcmFuc2l0aW9uIE1hbmFnZW1lbnQgUmVzcG9uc2UgZnJvbSAiCisJCQkgICBNQUNTVFIsIE1BQzJTVFIoYWRkcikpOworCQlyZXR1cm47CisJfQorCisJcG9zID0gZnJtOworCWVuZCA9IHBvcyArIGxlbjsKKwlkaWFsb2dfdG9rZW4gPSAqcG9zKys7CisJc3RhdHVzX2NvZGUgPSAqcG9zKys7CisJYnNzX3Rlcm1pbmF0aW9uX2RlbGF5ID0gKnBvcysrOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IEJTUyBUcmFuc2l0aW9uIE1hbmFnZW1lbnQgUmVzcG9uc2UgZnJvbSAiCisJCSAgIE1BQ1NUUiAiIGRpYWxvZ190b2tlbj0ldSBzdGF0dXNfY29kZT0ldSAiCisJCSAgICJic3NfdGVybWluYXRpb25fZGVsYXk9JXUiLCBNQUMyU1RSKGFkZHIpLCBkaWFsb2dfdG9rZW4sCisJCSAgIHN0YXR1c19jb2RlLCBic3NfdGVybWluYXRpb25fZGVsYXkpOworCisJaWYgKHN0YXR1c19jb2RlID09IFdOTV9CU1NfVE1fQUNDRVBUKSB7CisJCWlmIChlbmQgLSBwb3MgPCBFVEhfQUxFTikgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IG5vdCBlbm91Z2ggcm9vbSBmb3IgVGFyZ2V0IEJTU0lEIGZpZWxkIik7CisJCQlyZXR1cm47CisJCX0KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IFRhcmdldCBCU1NJRDogIiBNQUNTVFIsCisJCQkgICBNQUMyU1RSKHBvcykpOworCQlwb3MgKz0gRVRIX0FMRU47CisJfQorCisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV05NOiBCU1MgVHJhbnNpdGlvbiBDYW5kaWRhdGUgTGlzdCBFbnRyaWVzIiwKKwkJICAgIHBvcywgZW5kIC0gcG9zKTsKK30KKworCitpbnQgaWVlZTgwMl8xMV9yeF93bm1fYWN0aW9uX2FwKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LCBzaXplX3QgbGVuKQoreworCXU4IGFjdGlvbjsKKwljb25zdCB1OCAqcGF5bG9hZDsKKwlzaXplX3QgcGxlbjsKKworCWlmIChsZW4gPCBJRUVFODAyMTFfSERSTEVOICsgMikKIAkJcmV0dXJuIC0xOwogCi0Jc3dpdGNoIChhY3Rpb24tPmRhdGFbMF0pIHsKKwlwYXlsb2FkID0gKChjb25zdCB1OCAqKSBtZ210KSArIElFRUU4MDIxMV9IRFJMRU4gKyAxOworCWFjdGlvbiA9ICpwYXlsb2FkKys7CisJcGxlbiA9IGxlbiAtIElFRUU4MDIxMV9IRFJMRU4gLSAyOworCisJc3dpdGNoIChhY3Rpb24pIHsKIAljYXNlIFdOTV9CU1NfVFJBTlNfTUdNVF9RVUVSWToKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IEJTUyBUcmFuc2l0aW9uIE1hbmFnZW1lbnQgUXVlcnkiKTsKLQkJLyogVE9ETyAqLwotCQlyZXR1cm4gLTE7CisJCWllZWU4MDJfMTFfcnhfYnNzX3RyYW5zX21nbXRfcXVlcnkoaGFwZCwgbWdtdC0+c2EsIHBheWxvYWQsCisJCQkJCQkgICBwbGVuKTsKKwkJcmV0dXJuIDA7CiAJY2FzZSBXTk1fQlNTX1RSQU5TX01HTVRfUkVTUDoKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IEJTUyBUcmFuc2l0aW9uIE1hbmFnZW1lbnQgIgotCQkJICAgIlJlc3BvbnNlIik7Ci0JCS8qIFRPRE8gKi8KLQkJcmV0dXJuIC0xOworCQlpZWVlODAyXzExX3J4X2Jzc190cmFuc19tZ210X3Jlc3AoaGFwZCwgbWdtdC0+c2EsIHBheWxvYWQsCisJCQkJCQkgIHBsZW4pOworCQlyZXR1cm4gMDsKIAljYXNlIFdOTV9TTEVFUF9NT0RFX1JFUToKLQkJaWVlZTgwMl8xMV9yeF93bm1zbGVlcF9yZXEoaGFwZCwgYWN0aW9uLT5zYSwgYWN0aW9uLT5kYXRhICsgMSwKLQkJCQkJICAgYWN0aW9uLT5sZW4gLSAxKTsKKwkJaWVlZTgwMl8xMV9yeF93bm1zbGVlcF9yZXEoaGFwZCwgbWdtdC0+c2EsIHBheWxvYWQsIHBsZW4pOwogCQlyZXR1cm4gMDsKIAl9CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogVW5zdXBwb3J0ZWQgV05NIEFjdGlvbiAldSBmcm9tICIgTUFDU1RSLAotCQkgICBhY3Rpb24tPmRhdGFbMF0sIE1BQzJTVFIoYWN0aW9uLT5zYSkpOworCQkgICBhY3Rpb24sIE1BQzJTVFIobWdtdC0+c2EpKTsKIAlyZXR1cm4gLTE7CiB9CisKKworaW50IHdubV9zZW5kX2Rpc2Fzc29jX2ltbWluZW50KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkgICAgICAgc3RydWN0IHN0YV9pbmZvICpzdGEsIGludCBkaXNhc3NvY190aW1lcikKK3sKKwl1OCBidWZbMTAwMF0sICpwb3M7CisJc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210OworCisJb3NfbWVtc2V0KGJ1ZiwgMCwgc2l6ZW9mKGJ1ZikpOworCW1nbXQgPSAoc3RydWN0IGllZWU4MDIxMV9tZ210ICopIGJ1ZjsKKwltZ210LT5mcmFtZV9jb250cm9sID0gSUVFRTgwMjExX0ZDKFdMQU5fRkNfVFlQRV9NR01ULAorCQkJCQkgICBXTEFOX0ZDX1NUWVBFX0FDVElPTik7CisJb3NfbWVtY3B5KG1nbXQtPmRhLCBzdGEtPmFkZHIsIEVUSF9BTEVOKTsKKwlvc19tZW1jcHkobWdtdC0+c2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7CisJb3NfbWVtY3B5KG1nbXQtPmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOworCW1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ID0gV0xBTl9BQ1RJT05fV05NOworCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5hY3Rpb24gPSBXTk1fQlNTX1RSQU5TX01HTVRfUkVROworCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5kaWFsb2dfdG9rZW4gPSAxOworCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5yZXFfbW9kZSA9CisJCVdOTV9CU1NfVE1fUkVRX0RJU0FTU09DX0lNTUlORU5UOworCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS5kaXNhc3NvY190aW1lciA9CisJCWhvc3RfdG9fbGUxNihkaXNhc3NvY190aW1lcik7CisJbWdtdC0+dS5hY3Rpb24udS5ic3NfdG1fcmVxLnZhbGlkaXR5X2ludGVydmFsID0gMDsKKworCXBvcyA9IG1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS52YXJpYWJsZTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBTZW5kIEJTUyBUcmFuc2l0aW9uIE1hbmFnZW1lbnQgUmVxdWVzdCBmcmFtZSB0byBpbmRpY2F0ZSBpbW1pbmVudCBkaXNhc3NvY2lhdGlvbiAoZGlzYXNzb2NfdGltZXI9JWQpIHRvICIKKwkJICAgTUFDU1RSLCBkaXNhc3NvY190aW1lciwgTUFDMlNUUihzdGEtPmFkZHIpKTsKKwlpZiAoaG9zdGFwZF9kcnZfc2VuZF9tbG1lKGhhcGQsIGJ1ZiwgcG9zIC0gYnVmLCAwKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGYWlsZWQgdG8gc2VuZCBCU1MgVHJhbnNpdGlvbiAiCisJCQkgICAiTWFuYWdlbWVudCBSZXF1ZXN0IGZyYW1lIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitpbnQgd25tX3NlbmRfZXNzX2Rpc2Fzc29jX2ltbWluZW50KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJICAgc3RydWN0IHN0YV9pbmZvICpzdGEsIGNvbnN0IGNoYXIgKnVybCwKKwkJCQkgICBpbnQgZGlzYXNzb2NfdGltZXIpCit7CisJdTggYnVmWzEwMDBdLCAqcG9zOworCXN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKKwlzaXplX3QgdXJsX2xlbjsKKworCW9zX21lbXNldChidWYsIDAsIHNpemVvZihidWYpKTsKKwltZ210ID0gKHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBidWY7CisJbWdtdC0+ZnJhbWVfY29udHJvbCA9IElFRUU4MDIxMV9GQyhXTEFOX0ZDX1RZUEVfTUdNVCwKKwkJCQkJICAgV0xBTl9GQ19TVFlQRV9BQ1RJT04pOworCW9zX21lbWNweShtZ210LT5kYSwgc3RhLT5hZGRyLCBFVEhfQUxFTik7CisJb3NfbWVtY3B5KG1nbXQtPnNhLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOworCW9zX21lbWNweShtZ210LT5ic3NpZCwgaGFwZC0+b3duX2FkZHIsIEVUSF9BTEVOKTsKKwltZ210LT51LmFjdGlvbi5jYXRlZ29yeSA9IFdMQU5fQUNUSU9OX1dOTTsKKwltZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEuYWN0aW9uID0gV05NX0JTU19UUkFOU19NR01UX1JFUTsKKwltZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEuZGlhbG9nX3Rva2VuID0gMTsKKwltZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEucmVxX21vZGUgPQorCQlXTk1fQlNTX1RNX1JFUV9ESVNBU1NPQ19JTU1JTkVOVCB8CisJCVdOTV9CU1NfVE1fUkVRX0VTU19ESVNBU1NPQ19JTU1JTkVOVDsKKwltZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEuZGlzYXNzb2NfdGltZXIgPQorCQlob3N0X3RvX2xlMTYoZGlzYXNzb2NfdGltZXIpOworCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3JlcS52YWxpZGl0eV9pbnRlcnZhbCA9IDB4MDE7CisKKwlwb3MgPSBtZ210LT51LmFjdGlvbi51LmJzc190bV9yZXEudmFyaWFibGU7CisKKwkvKiBTZXNzaW9uIEluZm9ybWF0aW9uIFVSTCAqLworCXVybF9sZW4gPSBvc19zdHJsZW4odXJsKTsKKwlpZiAodXJsX2xlbiA+IDI1NSkKKwkJcmV0dXJuIC0xOworCSpwb3MrKyA9IHVybF9sZW47CisJb3NfbWVtY3B5KHBvcywgdXJsLCB1cmxfbGVuKTsKKwlwb3MgKz0gdXJsX2xlbjsKKworCWlmIChob3N0YXBkX2Rydl9zZW5kX21sbWUoaGFwZCwgYnVmLCBwb3MgLSBidWYsIDApIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBzZW5kIEJTUyBUcmFuc2l0aW9uICIKKwkJCSAgICJNYW5hZ2VtZW50IFJlcXVlc3QgZnJhbWUiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCS8qIHNlbmQgZGlzYXNzb2NpYXRpb24gZnJhbWUgYWZ0ZXIgdGltZS1vdXQgKi8KKwlpZiAoZGlzYXNzb2NfdGltZXIpIHsKKwkJaW50IHRpbWVvdXQsIGJlYWNvbl9pbnQ7CisKKwkJLyoKKwkJICogUHJldmVudCBTVEEgZnJvbSByZWNvbm5lY3RpbmcgdXNpbmcgY2FjaGVkIFBNS1NBIHRvIGZvcmNlCisJCSAqIGZ1bGwgYXV0aGVudGljYXRpb24gd2l0aCB0aGUgYXV0aGVudGljYXRpb24gc2VydmVyICh3aGljaCBtYXkKKwkJICogZGVjaWRlIHRvIHJlamVjdCB0aGUgY29ubmVjdGlvbiksCisJCSAqLworCQl3cGFfYXV0aF9wbWtzYV9yZW1vdmUoaGFwZC0+d3BhX2F1dGgsIHN0YS0+YWRkcik7CisKKwkJYmVhY29uX2ludCA9IGhhcGQtPmljb25mLT5iZWFjb25faW50OworCQlpZiAoYmVhY29uX2ludCA8IDEpCisJCQliZWFjb25faW50ID0gMTAwOyAvKiBiZXN0IGd1ZXNzICovCisJCS8qIENhbGN1bGF0ZSB0aW1lb3V0IGluIG1zIGJhc2VkIG9uIGJlYWNvbl9pbnQgaW4gVFUgKi8KKwkJdGltZW91dCA9IGRpc2Fzc29jX3RpbWVyICogYmVhY29uX2ludCAqIDEyOCAvIDEyNTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEaXNhc3NvY2lhdGlvbiB0aW1lciBmb3IgIiBNQUNTVFIKKwkJCSAgICIgc2V0IHRvICVkIG1zIiwgTUFDMlNUUihzdGEtPmFkZHIpLCB0aW1lb3V0KTsKKworCQlzdGEtPnRpbWVvdXRfbmV4dCA9IFNUQV9ESVNBU1NPQ19GUk9NX0NMSTsKKwkJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KHRpbWVvdXQgLyAxMDAwLAorCQkJCSAgICAgICB0aW1lb3V0ICUgMTAwMCAqIDEwMDAsCisJCQkJICAgICAgIGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL3NyYy9hcC93bm1fYXAuaCBiL3NyYy9hcC93bm1fYXAuaAppbmRleCBmMDU3MjZlLi5lZWFmNWVjIDEwMDY0NAotLS0gYS9zcmMvYXAvd25tX2FwLmgKKysrIGIvc3JjL2FwL3dubV9hcC5oCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIElFRUUgODAyLjExdiBXTk0gcmVsYXRlZCBmdW5jdGlvbnMgYW5kIHN0cnVjdHVyZXMKLSAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEyLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC05LDkgKzksMTQgQEAKICNpZm5kZWYgV05NX0FQX0gKICNkZWZpbmUgV05NX0FQX0gKIAotc3RydWN0IHJ4X2FjdGlvbjsKK3N0cnVjdCBzdGFfaW5mbzsKIAogaW50IGllZWU4MDJfMTFfcnhfd25tX2FjdGlvbl9hcChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAotCQkJCXN0cnVjdCByeF9hY3Rpb24gKmFjdGlvbik7CisJCQkJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LCBzaXplX3QgbGVuKTsKK2ludCB3bm1fc2VuZF9kaXNhc3NvY19pbW1pbmVudChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJICAgICAgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLCBpbnQgZGlzYXNzb2NfdGltZXIpOworaW50IHdubV9zZW5kX2Vzc19kaXNhc3NvY19pbW1pbmVudChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLCBjb25zdCBjaGFyICp1cmwsCisJCQkJICAgaW50IGRpc2Fzc29jX3RpbWVyKTsKIAogI2VuZGlmIC8qIFdOTV9BUF9IICovCmRpZmYgLS1naXQgYS9zcmMvYXAvd3BhX2F1dGguYyBiL3NyYy9hcC93cGFfYXV0aC5jCmluZGV4IDAyODZjNWIuLjJiYjhhYWIgMTAwNjQ0Ci0tLSBhL3NyYy9hcC93cGFfYXV0aC5jCisrKyBiL3NyYy9hcC93cGFfYXV0aC5jCkBAIC0xMSw2ICsxMSw3IEBACiAjaW5jbHVkZSAidXRpbHMvY29tbW9uLmgiCiAjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKICNpbmNsdWRlICJ1dGlscy9zdGF0ZV9tYWNoaW5lLmgiCisjaW5jbHVkZSAidXRpbHMvYml0ZmllbGQuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCiAjaW5jbHVkZSAiY3J5cHRvL2Flc193cmFwLmgiCiAjaW5jbHVkZSAiY3J5cHRvL2NyeXB0by5oIgpAQCAtMjEwLDYgKzIxMSw4IEBACiAJaWYgKHdwYV9rZXlfbWdtdF9zaGEyNTYoc20tPndwYV9rZXlfbWdtdCkpCiAJCXJldCA9IDE7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KKwlpZiAoc20tPndwYV9rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfT1NFTikKKwkJcmV0ID0gMTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC00MjQsNiArNDI3LDE3IEBACiAJCQkJICAgICAgIHdwYV9yZWtleV9ndGssIHdwYV9hdXRoLCBOVUxMKTsKIAl9CiAKKyNpZmRlZiBDT05GSUdfUDJQCisJaWYgKFdQQV9HRVRfQkUzMihjb25mLT5pcF9hZGRyX3N0YXJ0KSkgeworCQlpbnQgY291bnQgPSBXUEFfR0VUX0JFMzIoY29uZi0+aXBfYWRkcl9lbmQpIC0KKwkJCVdQQV9HRVRfQkUzMihjb25mLT5pcF9hZGRyX3N0YXJ0KSArIDE7CisJCWlmIChjb3VudCA+IDEwMDApCisJCQljb3VudCA9IDEwMDA7CisJCWlmIChjb3VudCA+IDApCisJCQl3cGFfYXV0aC0+aXBfcG9vbCA9IGJpdGZpZWxkX2FsbG9jKGNvdW50KTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCiAJcmV0dXJuIHdwYV9hdXRoOwogfQogCkBAIC00MzcsNiArNDUxLDggQEAKIAl3cGFfZ3JvdXBfc21fc3RlcCh3cGFfYXV0aCwgZ3JvdXApOwogCWdyb3VwLT5HSW5pdCA9IEZBTFNFOwogCXdwYV9ncm91cF9zbV9zdGVwKHdwYV9hdXRoLCBncm91cCk7CisJaWYgKGdyb3VwLT53cGFfZ3JvdXBfc3RhdGUgPT0gV1BBX0dST1VQX0ZBVEFMX0ZBSUxVUkUpCisJCXJldHVybiAtMTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtNDY0LDYgKzQ4MCwxMSBAQAogCXdwYV9hdXRoLT5mdF9wbWtfY2FjaGUgPSBOVUxMOwogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiAKKyNpZmRlZiBDT05GSUdfUDJQCisJYml0ZmllbGRfZnJlZSh3cGFfYXV0aC0+aXBfcG9vbCk7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCisKIAlvc19mcmVlKHdwYV9hdXRoLT53cGFfaWUpOwogCiAJZ3JvdXAgPSB3cGFfYXV0aC0+Z3JvdXA7CkBAIC01MTYsNiArNTM3LDkgQEAKIHsKIAlzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtOwogCisJaWYgKHdwYV9hdXRoLT5ncm91cC0+d3BhX2dyb3VwX3N0YXRlID09IFdQQV9HUk9VUF9GQVRBTF9GQUlMVVJFKQorCQlyZXR1cm4gTlVMTDsKKwogCXNtID0gb3NfemFsbG9jKHNpemVvZihzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUpKTsKIAlpZiAoc20gPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CkBAIC01NDEsNiArNTY1LDggQEAKIAkJd3BhX2F1dGhfbG9nZ2VyKHdwYV9hdXRoLCBzbS0+YWRkciwgTE9HR0VSX0RFQlVHLAogCQkJCSJGVCBhdXRoZW50aWNhdGlvbiBhbHJlYWR5IGNvbXBsZXRlZCAtIGRvIG5vdCAiCiAJCQkJInN0YXJ0IDQtd2F5IGhhbmRzaGFrZSIpOworCQkvKiBHbyB0byBQVEtJTklURE9ORSBzdGF0ZSB0byBhbGxvdyBHVEsgcmVrZXlpbmcgKi8KKwkJc20tPndwYV9wdGtfc3RhdGUgPSBXUEFfUFRLX1BUS0lOSVRET05FOwogCQlyZXR1cm4gMDsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KQEAgLTU3OCwxMiArNjA0LDI2IEBACiAKIHN0YXRpYyB2b2lkIHdwYV9mcmVlX3N0YV9zbShzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtKQogeworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAoV1BBX0dFVF9CRTMyKHNtLT5pcF9hZGRyKSkgeworCQl1MzIgc3RhcnQ7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGcmVlIGFzc2lnbmVkIElQICIKKwkJCSAgICJhZGRyZXNzICV1LiV1LiV1LiV1IGZyb20gIiBNQUNTVFIsCisJCQkgICBzbS0+aXBfYWRkclswXSwgc20tPmlwX2FkZHJbMV0sCisJCQkgICBzbS0+aXBfYWRkclsyXSwgc20tPmlwX2FkZHJbM10sCisJCQkgICBNQUMyU1RSKHNtLT5hZGRyKSk7CisJCXN0YXJ0ID0gV1BBX0dFVF9CRTMyKHNtLT53cGFfYXV0aC0+Y29uZi5pcF9hZGRyX3N0YXJ0KTsKKwkJYml0ZmllbGRfY2xlYXIoc20tPndwYV9hdXRoLT5pcF9wb29sLAorCQkJICAgICAgIFdQQV9HRVRfQkUzMihzbS0+aXBfYWRkcikgLSBzdGFydCk7CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAlpZiAoc20tPkdVcGRhdGVTdGF0aW9uS2V5cykgewogCQlzbS0+Z3JvdXAtPkdLZXlEb25lU3RhdGlvbnMtLTsKIAkJc20tPkdVcGRhdGVTdGF0aW9uS2V5cyA9IEZBTFNFOwogCX0KICNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgogCW9zX2ZyZWUoc20tPmFzc29jX3Jlc3BfZnRpZSk7CisJd3BhYnVmX2ZyZWUoc20tPmZ0X3BlbmRpbmdfcmVxX2llcyk7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KIAlvc19mcmVlKHNtLT5sYXN0X3J4X2VhcG9sX2tleSk7CiAJb3NfZnJlZShzbS0+d3BhX2llKTsKQEAgLTg0Myw2ICs4ODMsNyBAQAogCQlpZiAoc20tPnBhaXJ3aXNlID09IFdQQV9DSVBIRVJfQ0NNUCB8fAogCQkgICAgc20tPnBhaXJ3aXNlID09IFdQQV9DSVBIRVJfR0NNUCkgewogCQkJaWYgKHdwYV91c2VfYWVzX2NtYWMoc20pICYmCisJCQkgICAgc20tPndwYV9rZXlfbWdtdCAhPSBXUEFfS0VZX01HTVRfT1NFTiAmJgogCQkJICAgIHZlciAhPSBXUEFfS0VZX0lORk9fVFlQRV9BRVNfMTI4X0NNQUMpIHsKIAkJCQl3cGFfYXV0aF9sb2dnZXIod3BhX2F1dGgsIHNtLT5hZGRyLAogCQkJCQkJTE9HR0VSX1dBUk5JTkcsCkBAIC05NjYsNiArMTAwNyw5IEBACiAJCWlmIChrZGUucnNuX2llKSB7CiAJCQllYXBvbF9rZXlfaWUgPSBrZGUucnNuX2llOwogCQkJZWFwb2xfa2V5X2llX2xlbiA9IGtkZS5yc25faWVfbGVuOworCQl9IGVsc2UgaWYgKGtkZS5vc2VuKSB7CisJCQllYXBvbF9rZXlfaWUgPSBrZGUub3NlbjsKKwkJCWVhcG9sX2tleV9pZV9sZW4gPSBrZGUub3Nlbl9sZW47CiAJCX0gZWxzZSB7CiAJCQllYXBvbF9rZXlfaWUgPSBrZGUud3BhX2llOwogCQkJZWFwb2xfa2V5X2llX2xlbiA9IGtkZS53cGFfaWVfbGVuOwpAQCAtOTk1LDYgKzEwMzksMjYgQEAKIAkJCXJldHVybjsKIAkJfQogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCisjaWZkZWYgQ09ORklHX1AyUAorCQlpZiAoa2RlLmlwX2FkZHJfcmVxICYmIGtkZS5pcF9hZGRyX3JlcVswXSAmJgorCQkgICAgd3BhX2F1dGgtPmlwX3Bvb2wgJiYgV1BBX0dFVF9CRTMyKHNtLT5pcF9hZGRyKSA9PSAwKSB7CisJCQlpbnQgaWR4OworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IElQIGFkZHJlc3MgcmVxdWVzdGVkIGluICIKKwkJCQkgICAiRUFQT0wtS2V5IGV4Y2hhbmdlIik7CisJCQlpZHggPSBiaXRmaWVsZF9nZXRfZmlyc3RfemVybyh3cGFfYXV0aC0+aXBfcG9vbCk7CisJCQlpZiAoaWR4ID49IDApIHsKKwkJCQl1MzIgc3RhcnQgPSBXUEFfR0VUX0JFMzIod3BhX2F1dGgtPmNvbmYuCisJCQkJCQkJIGlwX2FkZHJfc3RhcnQpOworCQkJCWJpdGZpZWxkX3NldCh3cGFfYXV0aC0+aXBfcG9vbCwgaWR4KTsKKwkJCQlXUEFfUFVUX0JFMzIoc20tPmlwX2FkZHIsIHN0YXJ0ICsgaWR4KTsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQXNzaWduZWQgSVAgIgorCQkJCQkgICAiYWRkcmVzcyAldS4ldS4ldS4ldSB0byAiIE1BQ1NUUiwKKwkJCQkJICAgc20tPmlwX2FkZHJbMF0sIHNtLT5pcF9hZGRyWzFdLAorCQkJCQkgICBzbS0+aXBfYWRkclsyXSwgc20tPmlwX2FkZHJbM10sCisJCQkJCSAgIE1BQzJTVFIoc20tPmFkZHIpKTsKKwkJCX0KKwkJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJYnJlYWs7CiAJY2FzZSBQQUlSV0lTRV80OgogCQlpZiAoc20tPndwYV9wdGtfc3RhdGUgIT0gV1BBX1BUS19QVEtJTklUTkVHT1RJQVRJTkcgfHwKQEAgLTEyMzEsNiArMTI5NSw4IEBACiAKIAlpZiAoZm9yY2VfdmVyc2lvbikKIAkJdmVyc2lvbiA9IGZvcmNlX3ZlcnNpb247CisJZWxzZSBpZiAoc20tPndwYV9rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfT1NFTikKKwkJdmVyc2lvbiA9IFdQQV9LRVlfSU5GT19UWVBFX0FLTV9ERUZJTkVEOwogCWVsc2UgaWYgKHdwYV91c2VfYWVzX2NtYWMoc20pKQogCQl2ZXJzaW9uID0gV1BBX0tFWV9JTkZPX1RZUEVfQUVTXzEyOF9DTUFDOwogCWVsc2UgaWYgKHNtLT5wYWlyd2lzZSAhPSBXUEFfQ0lQSEVSX1RLSVApCkBAIC0xMjUzLDYgKzEzMTksNyBAQAogCWtleV9kYXRhX2xlbiA9IGtkZV9sZW47CiAKIAlpZiAoKHZlcnNpb24gPT0gV1BBX0tFWV9JTkZPX1RZUEVfSE1BQ19TSEExX0FFUyB8fAorCSAgICAgc20tPndwYV9rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfT1NFTiB8fAogCSAgICAgdmVyc2lvbiA9PSBXUEFfS0VZX0lORk9fVFlQRV9BRVNfMTI4X0NNQUMpICYmIGVuY3IpIHsKIAkJcGFkX2xlbiA9IGtleV9kYXRhX2xlbiAlIDg7CiAJCWlmIChwYWRfbGVuKQpAQCAtMTMyMSw2ICsxMzg4LDcgQEAKIAkJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIlBsYWludGV4dCBFQVBPTC1LZXkgS2V5IERhdGEiLAogCQkJCWJ1Ziwga2V5X2RhdGFfbGVuKTsKIAkJaWYgKHZlcnNpb24gPT0gV1BBX0tFWV9JTkZPX1RZUEVfSE1BQ19TSEExX0FFUyB8fAorCQkgICAgc20tPndwYV9rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfT1NFTiB8fAogCQkgICAgdmVyc2lvbiA9PSBXUEFfS0VZX0lORk9fVFlQRV9BRVNfMTI4X0NNQUMpIHsKIAkJCWlmIChhZXNfd3JhcChzbS0+UFRLLmtlaywgKGtleV9kYXRhX2xlbiAtIDgpIC8gOCwgYnVmLAogCQkJCSAgICAgKHU4ICopIChrZXkgKyAxKSkpIHsKQEAgLTEzNTUsNyArMTQyMyw3IEBACiAJCQkJICBrZXktPmtleV9taWMpOwogI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKIAkJaWYgKCFwYWlyd2lzZSAmJgotCQkgICAgd3BhX2F1dGgtPmNvbmYuY29ycnVwdF9ndGtfcmVrZXlfbWljX3Byb2JhYmlsaXR5ID4gMC4wZCAmJgorCQkgICAgd3BhX2F1dGgtPmNvbmYuY29ycnVwdF9ndGtfcmVrZXlfbWljX3Byb2JhYmlsaXR5ID4gMC4wICYmCiAJCSAgICBkcmFuZDQ4KCkgPAogCQkgICAgd3BhX2F1dGgtPmNvbmYuY29ycnVwdF9ndGtfcmVrZXlfbWljX3Byb2JhYmlsaXR5KSB7CiAJCQl3cGFfYXV0aF9sb2dnZXIod3BhX2F1dGgsIHNtLT5hZGRyLCBMT0dHRVJfSU5GTywKQEAgLTE0MjIsNyArMTQ5MCw3IEBACiAJb3NfbWVtc2V0KGtleS0+a2V5X21pYywgMCwgMTYpOwogCWlmICh3cGFfZWFwb2xfa2V5X21pYyhQVEstPmtjaywga2V5X2luZm8gJiBXUEFfS0VZX0lORk9fVFlQRV9NQVNLLAogCQkJICAgICAgZGF0YSwgZGF0YV9sZW4sIGtleS0+a2V5X21pYykgfHwKLQkgICAgb3NfbWVtY21wKG1pYywga2V5LT5rZXlfbWljLCAxNikgIT0gMCkKKwkgICAgb3NfbWVtY21wX2NvbnN0KG1pYywga2V5LT5rZXlfbWljLCAxNikgIT0gMCkKIAkJcmV0ID0gLTE7CiAJb3NfbWVtY3B5KGtleS0+a2V5X21pYywgbWljLCAxNik7CiAJcmV0dXJuIHJldDsKQEAgLTE3MTksNyArMTc4Nyw4IEBACiAJICogb25lIHBvc3NpYmxlIFBTSyBmb3IgdGhpcyBTVEEuCiAJICovCiAJaWYgKHNtLT53cGEgPT0gV1BBX1ZFUlNJT05fV1BBMiAmJgotCSAgICB3cGFfa2V5X21nbXRfd3BhX2llZWU4MDIxeChzbS0+d3BhX2tleV9tZ210KSkgeworCSAgICB3cGFfa2V5X21nbXRfd3BhX2llZWU4MDIxeChzbS0+d3BhX2tleV9tZ210KSAmJgorCSAgICBzbS0+d3BhX2tleV9tZ210ICE9IFdQQV9LRVlfTUdNVF9PU0VOKSB7CiAJCXBta2lkID0gYnVmOwogCQlwbWtpZF9sZW4gPSAyICsgUlNOX1NFTEVDVE9SX0xFTiArIFBNS0lEX0xFTjsKIAkJcG1raWRbMF0gPSBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUM7CkBAIC0xNzQ3LDcgKzE4MTYsNyBAQAogc3RhdGljIGludCB3cGFfZGVyaXZlX3B0ayhzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtLCBjb25zdCB1OCAqcG1rLAogCQkJICBzdHJ1Y3Qgd3BhX3B0ayAqcHRrKQogewotCXNpemVfdCBwdGtfbGVuID0gc20tPnBhaXJ3aXNlICE9IFdQQV9DSVBIRVJfVEtJUCA/IDQ4IDogNjQ7CisJc2l6ZV90IHB0a19sZW4gPSB3cGFfY2lwaGVyX2tleV9sZW4oc20tPnBhaXJ3aXNlKSArIDMyOwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAJaWYgKHdwYV9rZXlfbWdtdF9mdChzbS0+d3BhX2tleV9tZ210KSkKIAkJcmV0dXJuIHdwYV9hdXRoX2Rlcml2ZV9wdGtfZnQoc20sIHBtaywgcHRrLCBwdGtfbGVuKTsKQEAgLTE4MDgsOCArMTg3Nyw4IEBACiAJCSAqIFZlcmlmeSB0aGF0IFBNS1IxTmFtZSBmcm9tIEVBUE9MLUtleSBtZXNzYWdlIDIvNCBtYXRjaGVzCiAJCSAqIHdpdGggdGhlIHZhbHVlIHdlIGRlcml2ZWQuCiAJCSAqLwotCQlpZiAob3NfbWVtY21wKHNtLT5zdXBfcG1rX3IxX25hbWUsIHNtLT5wbWtfcjFfbmFtZSwKLQkJCSAgICAgIFdQQV9QTUtfTkFNRV9MRU4pICE9IDApIHsKKwkJaWYgKG9zX21lbWNtcF9jb25zdChzbS0+c3VwX3Bta19yMV9uYW1lLCBzbS0+cG1rX3IxX25hbWUsCisJCQkJICAgIFdQQV9QTUtfTkFNRV9MRU4pICE9IDApIHsKIAkJCXdwYV9hdXRoX2xvZ2dlcihzbS0+d3BhX2F1dGgsIHNtLT5hZGRyLCBMT0dHRVJfREVCVUcsCiAJCQkJCSJQTUtSMU5hbWUgbWlzbWF0Y2ggaW4gRlQgNC13YXkgIgogCQkJCQkiaGFuZHNoYWtlIik7CkBAIC0xODUyLDcgKzE5MjEsOSBAQAogc3RhdGljIGludCBpZWVlODAyMTF3X2tkZV9sZW4oc3RydWN0IHdwYV9zdGF0ZV9tYWNoaW5lICpzbSkKIHsKIAlpZiAoc20tPm1nbXRfZnJhbWVfcHJvdCkgewotCQlyZXR1cm4gMiArIFJTTl9TRUxFQ1RPUl9MRU4gKyBzaXplb2Yoc3RydWN0IHdwYV9pZ3RrX2tkZSk7CisJCXNpemVfdCBsZW47CisJCWxlbiA9IHdwYV9jaXBoZXJfa2V5X2xlbihzbS0+d3BhX2F1dGgtPmNvbmYuZ3JvdXBfbWdtdF9jaXBoZXIpOworCQlyZXR1cm4gMiArIFJTTl9TRUxFQ1RPUl9MRU4gKyBXUEFfSUdUS19LREVfUFJFRklYX0xFTiArIGxlbjsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTE4NjMsNiArMTkzNCw4IEBACiB7CiAJc3RydWN0IHdwYV9pZ3RrX2tkZSBpZ3RrOwogCXN0cnVjdCB3cGFfZ3JvdXAgKmdzbSA9IHNtLT5ncm91cDsKKwl1OCByc2NbV1BBX0tFWV9SU0NfTEVOXTsKKwlzaXplX3QgbGVuID0gd3BhX2NpcGhlcl9rZXlfbGVuKHNtLT53cGFfYXV0aC0+Y29uZi5ncm91cF9tZ210X2NpcGhlcik7CiAKIAlpZiAoIXNtLT5tZ210X2ZyYW1lX3Byb3QpCiAJCXJldHVybiBwb3M7CkBAIC0xODcwLDE5ICsxOTQzLDIyIEBACiAJaWd0ay5rZXlpZFswXSA9IGdzbS0+R05faWd0azsKIAlpZ3RrLmtleWlkWzFdID0gMDsKIAlpZiAoZ3NtLT53cGFfZ3JvdXBfc3RhdGUgIT0gV1BBX0dST1VQX1NFVEtFWVNET05FIHx8Ci0JICAgIHdwYV9hdXRoX2dldF9zZXFudW0oc20tPndwYV9hdXRoLCBOVUxMLCBnc20tPkdOX2lndGssIGlndGsucG4pIDwgMCkKKwkgICAgd3BhX2F1dGhfZ2V0X3NlcW51bShzbS0+d3BhX2F1dGgsIE5VTEwsIGdzbS0+R05faWd0aywgcnNjKSA8IDApCiAJCW9zX21lbXNldChpZ3RrLnBuLCAwLCBzaXplb2YoaWd0ay5wbikpOwotCW9zX21lbWNweShpZ3RrLmlndGssIGdzbS0+SUdUS1tnc20tPkdOX2lndGsgLSA0XSwgV1BBX0lHVEtfTEVOKTsKKwllbHNlCisJCW9zX21lbWNweShpZ3RrLnBuLCByc2MsIHNpemVvZihpZ3RrLnBuKSk7CisJb3NfbWVtY3B5KGlndGsuaWd0aywgZ3NtLT5JR1RLW2dzbS0+R05faWd0ayAtIDRdLCBsZW4pOwogCWlmIChzbS0+d3BhX2F1dGgtPmNvbmYuZGlzYWJsZV9ndGspIHsKIAkJLyoKIAkJICogUHJvdmlkZSB1bmlxdWUgcmFuZG9tIElHVEsgdG8gZWFjaCBTVEEgdG8gcHJldmVudCB1c2Ugb2YKIAkJICogSUdUSyBpbiB0aGUgQlNTLgogCQkgKi8KLQkJaWYgKHJhbmRvbV9nZXRfYnl0ZXMoaWd0ay5pZ3RrLCBXUEFfSUdUS19MRU4pIDwgMCkKKwkJaWYgKHJhbmRvbV9nZXRfYnl0ZXMoaWd0ay5pZ3RrLCBsZW4pIDwgMCkKIAkJCXJldHVybiBwb3M7CiAJfQogCXBvcyA9IHdwYV9hZGRfa2RlKHBvcywgUlNOX0tFWV9EQVRBX0lHVEssCi0JCQkgIChjb25zdCB1OCAqKSAmaWd0aywgc2l6ZW9mKGlndGspLCBOVUxMLCAwKTsKKwkJCSAgKGNvbnN0IHU4ICopICZpZ3RrLCBXUEFfSUdUS19LREVfUFJFRklYX0xFTiArIGxlbiwKKwkJCSAgTlVMTCwgMCk7CiAKIAlyZXR1cm4gcG9zOwogfQpAQCAtMTk4Nyw2ICsyMDYzLDEwIEBACiAJCWtkZV9sZW4gKz0gMzAwOyAvKiBGVElFICsgMiAqIFRJRSAqLwogCX0KICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiAqLworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAoV1BBX0dFVF9CRTMyKHNtLT5pcF9hZGRyKSA+IDApCisJCWtkZV9sZW4gKz0gMiArIFJTTl9TRUxFQ1RPUl9MRU4gKyAzICogNDsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJa2RlID0gb3NfbWFsbG9jKGtkZV9sZW4pOwogCWlmIChrZGUgPT0gTlVMTCkKIAkJcmV0dXJuOwpAQCAtMjA0OCw2ICsyMTI4LDE2IEBACiAJCXBvcyArPSA0OwogCX0KICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiAqLworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAoV1BBX0dFVF9CRTMyKHNtLT5pcF9hZGRyKSA+IDApIHsKKwkJdTggYWRkclszICogNF07CisJCW9zX21lbWNweShhZGRyLCBzbS0+aXBfYWRkciwgNCk7CisJCW9zX21lbWNweShhZGRyICsgNCwgc20tPndwYV9hdXRoLT5jb25mLmlwX2FkZHJfbWFzaywgNCk7CisJCW9zX21lbWNweShhZGRyICsgOCwgc20tPndwYV9hdXRoLT5jb25mLmlwX2FkZHJfZ28sIDQpOworCQlwb3MgPSB3cGFfYWRkX2tkZShwb3MsIFdGQV9LRVlfREFUQV9JUF9BRERSX0FMTE9DLAorCQkJCSAgYWRkciwgc2l6ZW9mKGFkZHIpLCBOVUxMLCAwKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAJd3BhX3NlbmRfZWFwb2woc20tPndwYV9hdXRoLCBzbSwKIAkJICAgICAgIChzZWN1cmUgPyBXUEFfS0VZX0lORk9fU0VDVVJFIDogMCkgfCBXUEFfS0VZX0lORk9fTUlDIHwKQEAgLTIzNzQsMTUgKzI0NjQsMTYgQEAKIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJaWYgKHdwYV9hdXRoLT5jb25mLmllZWU4MDIxMXcgIT0gTk9fTUdNVF9GUkFNRV9QUk9URUNUSU9OKSB7CisJCXNpemVfdCBsZW47CisJCWxlbiA9IHdwYV9jaXBoZXJfa2V5X2xlbih3cGFfYXV0aC0+Y29uZi5ncm91cF9tZ210X2NpcGhlcik7CiAJCW9zX21lbWNweShncm91cC0+R05vbmNlLCBncm91cC0+Q291bnRlciwgV1BBX05PTkNFX0xFTik7CiAJCWluY19ieXRlX2FycmF5KGdyb3VwLT5Db3VudGVyLCBXUEFfTk9OQ0VfTEVOKTsKIAkJaWYgKHdwYV9nbWtfdG9fZ3RrKGdyb3VwLT5HTUssICJJR1RLIGtleSBleHBhbnNpb24iLAogCQkJCSAgIHdwYV9hdXRoLT5hZGRyLCBncm91cC0+R05vbmNlLAotCQkJCSAgIGdyb3VwLT5JR1RLW2dyb3VwLT5HTl9pZ3RrIC0gNF0sCi0JCQkJICAgV1BBX0lHVEtfTEVOKSA8IDApCisJCQkJICAgZ3JvdXAtPklHVEtbZ3JvdXAtPkdOX2lndGsgLSA0XSwgbGVuKSA8IDApCiAJCQlyZXQgPSAtMTsKIAkJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIklHVEsiLAotCQkJCWdyb3VwLT5JR1RLW2dyb3VwLT5HTl9pZ3RrIC0gNF0sIFdQQV9JR1RLX0xFTik7CisJCQkJZ3JvdXAtPklHVEtbZ3JvdXAtPkdOX2lndGsgLSA0XSwgbGVuKTsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIApAQCAtMjQ0OSw3ICsyNTQwLDcgQEAKIC8qIHVwZGF0ZSBHVEsgd2hlbiBleGl0aW5nIFdOTS1TbGVlcCBNb2RlICovCiB2b2lkIHdwYV93bm1zbGVlcF9yZWtleV9ndGsoc3RydWN0IHdwYV9zdGF0ZV9tYWNoaW5lICpzbSkKIHsKLQlpZiAoc20tPmlzX3dubXNsZWVwKQorCWlmIChzbSA9PSBOVUxMIHx8IHNtLT5pc193bm1zbGVlcCkKIAkJcmV0dXJuOwogCiAJd3BhX2dyb3VwX3VwZGF0ZV9zdGEoc20sIE5VTEwpOwpAQCAtMjQ1OCw3ICsyNTQ5LDggQEAKIAogdm9pZCB3cGFfc2V0X3dubXNsZWVwKHN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqc20sIGludCBmbGFnKQogewotCXNtLT5pc193bm1zbGVlcCA9ICEhZmxhZzsKKwlpZiAoc20pCisJCXNtLT5pc193bm1zbGVlcCA9ICEhZmxhZzsKIH0KIAogCkBAIC0yNDk4LDI2ICsyNTkwLDI3IEBACiB7CiAJc3RydWN0IHdwYV9ncm91cCAqZ3NtID0gc20tPmdyb3VwOwogCXU4ICpzdGFydCA9IHBvczsKKwlzaXplX3QgbGVuID0gd3BhX2NpcGhlcl9rZXlfbGVuKHNtLT53cGFfYXV0aC0+Y29uZi5ncm91cF9tZ210X2NpcGhlcik7CiAKIAkvKgogCSAqIElHVEsgc3ViZWxlbWVudDoKIAkgKiBTdWItZWxlbSBJRFsxXSB8IExlbmd0aFsxXSB8IEtleUlEWzJdIHwgUE5bNl0gfCBLZXlbMTZdCiAJICovCiAJKnBvcysrID0gV05NX1NMRUVQX1NVQkVMRU1fSUdUSzsKLQkqcG9zKysgPSAyICsgNiArIFdQQV9JR1RLX0xFTjsKKwkqcG9zKysgPSAyICsgNiArIGxlbjsKIAlXUEFfUFVUX0xFMTYocG9zLCBnc20tPkdOX2lndGspOwogCXBvcyArPSAyOwogCWlmICh3cGFfYXV0aF9nZXRfc2VxbnVtKHNtLT53cGFfYXV0aCwgTlVMTCwgZ3NtLT5HTl9pZ3RrLCBwb3MpICE9IDApCiAJCXJldHVybiAwOwogCXBvcyArPSA2OwogCi0Jb3NfbWVtY3B5KHBvcywgZ3NtLT5JR1RLW2dzbS0+R05faWd0ayAtIDRdLCBXUEFfSUdUS19MRU4pOwotCXBvcyArPSBXUEFfSUdUS19MRU47CisJb3NfbWVtY3B5KHBvcywgZ3NtLT5JR1RLW2dzbS0+R05faWd0ayAtIDRdLCBsZW4pOworCXBvcyArPSBsZW47CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogSUdUSyBLZXkgSUQgJXUgaW4gV05NLVNsZWVwIE1vZGUgZXhpdCIsCiAJCSAgIGdzbS0+R05faWd0ayk7CiAJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIldOTTogSUdUSyBpbiBXTk0tU2xlZXAgTW9kZSBleGl0IiwKLQkJCWdzbS0+SUdUS1tnc20tPkdOX2lndGsgLSA0XSwgV1BBX0lHVEtfTEVOKTsKKwkJCWdzbS0+SUdUS1tnc20tPkdOX2lndGsgLSA0XSwgbGVuKTsKIAogCXJldHVybiBwb3MgLSBzdGFydDsKIH0KQEAgLTI1NzIsMTggKzI2NjUsNDggQEAKIAkJcmV0ID0gLTE7CiAKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwotCWlmICh3cGFfYXV0aC0+Y29uZi5pZWVlODAyMTF3ICE9IE5PX01HTVRfRlJBTUVfUFJPVEVDVElPTiAmJgotCSAgICB3cGFfYXV0aF9zZXRfa2V5KHdwYV9hdXRoLCBncm91cC0+dmxhbl9pZCwgV1BBX0FMR19JR1RLLAotCQkJICAgICBicm9hZGNhc3RfZXRoZXJfYWRkciwgZ3JvdXAtPkdOX2lndGssCi0JCQkgICAgIGdyb3VwLT5JR1RLW2dyb3VwLT5HTl9pZ3RrIC0gNF0sCi0JCQkgICAgIFdQQV9JR1RLX0xFTikgPCAwKQotCQlyZXQgPSAtMTsKKwlpZiAod3BhX2F1dGgtPmNvbmYuaWVlZTgwMjExdyAhPSBOT19NR01UX0ZSQU1FX1BST1RFQ1RJT04pIHsKKwkJZW51bSB3cGFfYWxnIGFsZzsKKwkJc2l6ZV90IGxlbjsKKworCQlhbGcgPSB3cGFfY2lwaGVyX3RvX2FsZyh3cGFfYXV0aC0+Y29uZi5ncm91cF9tZ210X2NpcGhlcik7CisJCWxlbiA9IHdwYV9jaXBoZXJfa2V5X2xlbih3cGFfYXV0aC0+Y29uZi5ncm91cF9tZ210X2NpcGhlcik7CisKKwkJaWYgKHJldCA9PSAwICYmCisJCSAgICB3cGFfYXV0aF9zZXRfa2V5KHdwYV9hdXRoLCBncm91cC0+dmxhbl9pZCwgYWxnLAorCQkJCSAgICAgYnJvYWRjYXN0X2V0aGVyX2FkZHIsIGdyb3VwLT5HTl9pZ3RrLAorCQkJCSAgICAgZ3JvdXAtPklHVEtbZ3JvdXAtPkdOX2lndGsgLSA0XSwgbGVuKSA8IDApCisJCQlyZXQgPSAtMTsKKwl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIAogCXJldHVybiByZXQ7CiB9CiAKIAorc3RhdGljIGludCB3cGFfZ3JvdXBfZGlzY29ubmVjdF9jYihzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtLCB2b2lkICpjdHgpCit7CisJaWYgKHNtLT5ncm91cCA9PSBjdHgpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUEE6IE1hcmsgU1RBICIgTUFDU1RSCisJCQkgICAiIGZvciBkaXNjY29ubmVjdGlvbiBkdWUgdG8gZmF0YWwgZmFpbHVyZSIsCisJCQkgICBNQUMyU1RSKHNtLT5hZGRyKSk7CisJCXNtLT5EaXNjb25uZWN0ID0gVFJVRTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZCB3cGFfZ3JvdXBfZmF0YWxfZmFpbHVyZShzdHJ1Y3Qgd3BhX2F1dGhlbnRpY2F0b3IgKndwYV9hdXRoLAorCQkJCSAgICBzdHJ1Y3Qgd3BhX2dyb3VwICpncm91cCkKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQQTogZ3JvdXAgc3RhdGUgbWFjaGluZSBlbnRlcmluZyBzdGF0ZSBGQVRBTF9GQUlMVVJFIik7CisJZ3JvdXAtPmNoYW5nZWQgPSBUUlVFOworCWdyb3VwLT53cGFfZ3JvdXBfc3RhdGUgPSBXUEFfR1JPVVBfRkFUQUxfRkFJTFVSRTsKKwl3cGFfYXV0aF9mb3JfZWFjaF9zdGEod3BhX2F1dGgsIHdwYV9ncm91cF9kaXNjb25uZWN0X2NiLCBncm91cCk7Cit9CisKKwogc3RhdGljIGludCB3cGFfZ3JvdXBfc2V0a2V5c2RvbmUoc3RydWN0IHdwYV9hdXRoZW50aWNhdG9yICp3cGFfYXV0aCwKIAkJCQkgc3RydWN0IHdwYV9ncm91cCAqZ3JvdXApCiB7CkBAIC0yNTkyLDggKzI3MTUsMTAgQEAKIAlncm91cC0+Y2hhbmdlZCA9IFRSVUU7CiAJZ3JvdXAtPndwYV9ncm91cF9zdGF0ZSA9IFdQQV9HUk9VUF9TRVRLRVlTRE9ORTsKIAotCWlmICh3cGFfZ3JvdXBfY29uZmlnX2dyb3VwX2tleXMod3BhX2F1dGgsIGdyb3VwKSA8IDApCisJaWYgKHdwYV9ncm91cF9jb25maWdfZ3JvdXBfa2V5cyh3cGFfYXV0aCwgZ3JvdXApIDwgMCkgeworCQl3cGFfZ3JvdXBfZmF0YWxfZmFpbHVyZSh3cGFfYXV0aCwgZ3JvdXApOwogCQlyZXR1cm4gLTE7CisJfQogCiAJcmV0dXJuIDA7CiB9CkBAIC0yNjA0LDYgKzI3MjksOCBAQAogewogCWlmIChncm91cC0+R0luaXQpIHsKIAkJd3BhX2dyb3VwX2d0a19pbml0KHdwYV9hdXRoLCBncm91cCk7CisJfSBlbHNlIGlmIChncm91cC0+d3BhX2dyb3VwX3N0YXRlID09IFdQQV9HUk9VUF9GQVRBTF9GQUlMVVJFKSB7CisJCS8qIERvIG5vdCBhbGxvdyBncm91cCBvcGVyYXRpb25zICovCiAJfSBlbHNlIGlmIChncm91cC0+d3BhX2dyb3VwX3N0YXRlID09IFdQQV9HUk9VUF9HVEtfSU5JVCAmJgogCQkgICBncm91cC0+R1RLQXV0aGVudGljYXRvcikgewogCQl3cGFfZ3JvdXBfc2V0a2V5c2RvbmUod3BhX2F1dGgsIGdyb3VwKTsKQEAgLTMwMTIsNiArMzEzOSw5IEBACiAJaWYgKHNtLT5ncm91cCA9PSBncm91cCkKIAkJcmV0dXJuIDA7CiAKKwlpZiAoZ3JvdXAtPndwYV9ncm91cF9zdGF0ZSA9PSBXUEFfR1JPVVBfRkFUQUxfRkFJTFVSRSkKKwkJcmV0dXJuIC0xOworCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUEE6IE1vdmluZyBTVEEgIiBNQUNTVFIgIiB0byB1c2UgZ3JvdXAgc3RhdGUgIgogCQkgICAibWFjaGluZSBmb3IgVkxBTiBJRCAlZCIsIE1BQzJTVFIoc20tPmFkZHIpLCB2bGFuX2lkKTsKIApAQCAtMzA1NiwzICszMTg2LDIyIEBACiAJCXJldHVybiAwOwogCXJldHVybiB3cGFfa2V5X21nbXRfc2FlKHNtLT53cGFfa2V5X21nbXQpOwogfQorCisKK2ludCB3cGFfYXV0aF91c2VzX2Z0X3NhZShzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtKQoreworCWlmIChzbSA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKwlyZXR1cm4gc20tPndwYV9rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfRlRfU0FFOworfQorCisKKyNpZmRlZiBDT05GSUdfUDJQCitpbnQgd3BhX2F1dGhfZ2V0X2lwX2FkZHIoc3RydWN0IHdwYV9zdGF0ZV9tYWNoaW5lICpzbSwgdTggKmFkZHIpCit7CisJaWYgKHNtID09IE5VTEwgfHwgV1BBX0dFVF9CRTMyKHNtLT5pcF9hZGRyKSA9PSAwKQorCQlyZXR1cm4gLTE7CisJb3NfbWVtY3B5KGFkZHIsIHNtLT5pcF9hZGRyLCA0KTsKKwlyZXR1cm4gMDsKK30KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCmRpZmYgLS1naXQgYS9zcmMvYXAvd3BhX2F1dGguaCBiL3NyYy9hcC93cGFfYXV0aC5oCmluZGV4IDQ3NTAzZDAuLjkyOWEyNTMgMTAwNjQ0Ci0tLSBhL3NyYy9hcC93cGFfYXV0aC5oCisrKyBiL3NyYy9hcC93cGFfYXV0aC5oCkBAIC00Miw2ICs0Miw3IEBACiAjZGVmaW5lIEZUX1IwS0hfUjFLSF9QVUxMX0RBVEFfTEVOIDQ0CiAjZGVmaW5lIEZUX1IwS0hfUjFLSF9SRVNQX0RBVEFfTEVOIDc2CiAjZGVmaW5lIEZUX1IwS0hfUjFLSF9QVVNIX0RBVEFfTEVOIDg4CisjZGVmaW5lIEZUX1IwS0hfUjFLSF9QVUxMX05PTkNFX0xFTiAxNgogCiBzdHJ1Y3QgZnRfcjBraF9yMWtoX3B1bGxfZnJhbWUgewogCXU4IGZyYW1lX3R5cGU7IC8qIFJTTl9SRU1PVEVfRlJBTUVfVFlQRV9GVF9SUkIgKi8KQEAgLTQ5LDcgKzUwLDcgQEAKIAlsZTE2IGRhdGFfbGVuZ3RoOyAvKiBsaXR0bGUgZW5kaWFuIGxlbmd0aCBvZiBkYXRhICg0NCkgKi8KIAl1OCBhcF9hZGRyZXNzW0VUSF9BTEVOXTsKIAotCXU4IG5vbmNlWzE2XTsKKwl1OCBub25jZVtGVF9SMEtIX1IxS0hfUFVMTF9OT05DRV9MRU5dOwogCXU4IHBta19yMF9uYW1lW1dQQV9QTUtfTkFNRV9MRU5dOwogCXU4IHIxa2hfaWRbRlRfUjFLSF9JRF9MRU5dOwogCXU4IHMxa2hfaWRbRVRIX0FMRU5dOwpAQCAtNjMsNyArNjQsNyBAQAogCWxlMTYgZGF0YV9sZW5ndGg7IC8qIGxpdHRsZSBlbmRpYW4gbGVuZ3RoIG9mIGRhdGEgKDc2KSAqLwogCXU4IGFwX2FkZHJlc3NbRVRIX0FMRU5dOwogCi0JdTggbm9uY2VbMTZdOyAvKiBjb3BpZWQgZnJvbSBwdWxsICovCisJdTggbm9uY2VbRlRfUjBLSF9SMUtIX1BVTExfTk9OQ0VfTEVOXTsgLyogY29waWVkIGZyb20gcHVsbCAqLwogCXU4IHIxa2hfaWRbRlRfUjFLSF9JRF9MRU5dOyAvKiBjb3BpZWQgZnJvbSBwdWxsICovCiAJdTggczFraF9pZFtFVEhfQUxFTl07IC8qIGNvcGllZCBmcm9tIHB1bGwgKi8KIAl1OCBwbWtfcjFbUE1LX0xFTl07CkBAIC0xNDIsNiArMTQzLDcgQEAKIAlpbnQgdHhfc3RhdHVzOwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJZW51bSBtZnBfb3B0aW9ucyBpZWVlODAyMTF3OworCWludCBncm91cF9tZ210X2NpcGhlcjsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAjZGVmaW5lIFNTSURfTEVOIDMyCkBAIC0xNjMsNiArMTY1LDEyIEBACiAjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwogCWRvdWJsZSBjb3JydXB0X2d0a19yZWtleV9taWNfcHJvYmFiaWxpdHk7CiAjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLworI2lmZGVmIENPTkZJR19QMlAKKwl1OCBpcF9hZGRyX2dvWzRdOworCXU4IGlwX2FkZHJfbWFza1s0XTsKKwl1OCBpcF9hZGRyX3N0YXJ0WzRdOworCXU4IGlwX2FkZHJfZW5kWzRdOworI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIH07CiAKIHR5cGVkZWYgZW51bSB7CkBAIC0yMDMsNyArMjExLDcgQEAKIAlpbnQgKCpzZW5kX2Z0X2FjdGlvbikodm9pZCAqY3R4LCBjb25zdCB1OCAqZHN0LAogCQkJICAgICAgY29uc3QgdTggKmRhdGEsIHNpemVfdCBkYXRhX2xlbik7CiAJaW50ICgqYWRkX3RzcGVjKSh2b2lkICpjdHgsIGNvbnN0IHU4ICpzdGFfYWRkciwgdTggKnRzcGVjX2llLAotICAgICAgICAgICAgICAgICAgICAgICAgIHNpemVfdCB0c3BlY19pZWxlbik7CisJCQkgc2l6ZV90IHRzcGVjX2llbGVuKTsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiAqLwogfTsKIApAQCAtMjI2LDYgKzIzNCw5IEBACiAJCQlzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtLAogCQkJY29uc3QgdTggKndwYV9pZSwgc2l6ZV90IHdwYV9pZV9sZW4sCiAJCQljb25zdCB1OCAqbWRpZSwgc2l6ZV90IG1kaWVfbGVuKTsKK2ludCB3cGFfdmFsaWRhdGVfb3NlbihzdHJ1Y3Qgd3BhX2F1dGhlbnRpY2F0b3IgKndwYV9hdXRoLAorCQkgICAgICBzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtLAorCQkgICAgICBjb25zdCB1OCAqb3Nlbl9pZSwgc2l6ZV90IG9zZW5faWVfbGVuKTsKIGludCB3cGFfYXV0aF91c2VzX21mcChzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtKTsKIHN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqCiB3cGFfYXV0aF9zdGFfaW5pdChzdHJ1Y3Qgd3BhX2F1dGhlbnRpY2F0b3IgKndwYV9hdXRoLCBjb25zdCB1OCAqYWRkciwKQEAgLTI5NSw1ICszMDYsOCBAQAogaW50IHdwYV93bm1zbGVlcF9pZ3RrX3N1YmVsZW0oc3RydWN0IHdwYV9zdGF0ZV9tYWNoaW5lICpzbSwgdTggKnBvcyk7CiAKIGludCB3cGFfYXV0aF91c2VzX3NhZShzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtKTsKK2ludCB3cGFfYXV0aF91c2VzX2Z0X3NhZShzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtKTsKKworaW50IHdwYV9hdXRoX2dldF9pcF9hZGRyKHN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqc20sIHU4ICphZGRyKTsKIAogI2VuZGlmIC8qIFdQQV9BVVRIX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC93cGFfYXV0aF9mdC5jIGIvc3JjL2FwL3dwYV9hdXRoX2Z0LmMKaW5kZXggMjlkOWQyOS4uOGE2Y2E3MSAxMDA2NDQKLS0tIGEvc3JjL2FwL3dwYV9hdXRoX2Z0LmMKKysrIGIvc3JjL2FwL3dwYV9hdXRoX2Z0LmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAtIElFRUUgODAyLjExciAtIEZhc3QgQlNTIFRyYW5zaXRpb24KLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTksNiArOSw3IEBACiAjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKIAogI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgInV0aWxzL2Vsb29wLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIgogI2luY2x1ZGUgImNyeXB0by9hZXNfd3JhcC5oIgpAQCAtMjIsNiArMjMsMTIgQEAKIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAKK3N0YXRpYyBpbnQgd3BhX2Z0X3NlbmRfcnJiX2F1dGhfcmVzcChzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtLAorCQkJCSAgICAgY29uc3QgdTggKmN1cnJlbnRfYXAsIGNvbnN0IHU4ICpzdGFfYWRkciwKKwkJCQkgICAgIHUxNiBzdGF0dXMsIGNvbnN0IHU4ICpyZXNwX2llcywKKwkJCQkgICAgIHNpemVfdCByZXNwX2llc19sZW4pOworCisKIHN0YXRpYyBpbnQgd3BhX2Z0X3JyYl9zZW5kKHN0cnVjdCB3cGFfYXV0aGVudGljYXRvciAqd3BhX2F1dGgsIGNvbnN0IHU4ICpkc3QsCiAJCQkgICBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGRhdGFfbGVuKQogewpAQCAtNTcsNyArNjQsNyBAQAogCQkJICAgIHU4ICp0c3BlY19pZSwgc2l6ZV90IHRzcGVjX2llbGVuKQogewogCWlmICh3cGFfYXV0aC0+Y2IuYWRkX3RzcGVjID09IE5VTEwpIHsKLQkgICAgICAgIHdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IGFkZF90c3BlYyBpcyBub3QgaW5pdGlhbGl6ZWQiKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogYWRkX3RzcGVjIGlzIG5vdCBpbml0aWFsaXplZCIpOwogCQlyZXR1cm4gLTE7CiAJfQogCXJldHVybiB3cGFfYXV0aC0+Y2IuYWRkX3RzcGVjKHdwYV9hdXRoLT5jYi5jdHgsIHN0YV9hZGRyLCB0c3BlY19pZSwKQEAgLTIyOCw4ICsyMzUsOCBAQAogCXIwID0gY2FjaGUtPnBta19yMDsKIAl3aGlsZSAocjApIHsKIAkJaWYgKG9zX21lbWNtcChyMC0+c3BhLCBzcGEsIEVUSF9BTEVOKSA9PSAwICYmCi0JCSAgICBvc19tZW1jbXAocjAtPnBta19yMF9uYW1lLCBwbWtfcjBfbmFtZSwgV1BBX1BNS19OQU1FX0xFTikKLQkJICAgID09IDApIHsKKwkJICAgIG9zX21lbWNtcF9jb25zdChyMC0+cG1rX3IwX25hbWUsIHBta19yMF9uYW1lLAorCQkJCSAgICBXUEFfUE1LX05BTUVfTEVOKSA9PSAwKSB7CiAJCQlvc19tZW1jcHkocG1rX3IwLCByMC0+cG1rX3IwLCBQTUtfTEVOKTsKIAkJCWlmIChwYWlyd2lzZSkKIAkJCQkqcGFpcndpc2UgPSByMC0+cGFpcndpc2U7CkBAIC0yNzgsOCArMjg1LDggQEAKIAlyMSA9IGNhY2hlLT5wbWtfcjE7CiAJd2hpbGUgKHIxKSB7CiAJCWlmIChvc19tZW1jbXAocjEtPnNwYSwgc3BhLCBFVEhfQUxFTikgPT0gMCAmJgotCQkgICAgb3NfbWVtY21wKHIxLT5wbWtfcjFfbmFtZSwgcG1rX3IxX25hbWUsIFdQQV9QTUtfTkFNRV9MRU4pCi0JCSAgICA9PSAwKSB7CisJCSAgICBvc19tZW1jbXBfY29uc3QocjEtPnBta19yMV9uYW1lLCBwbWtfcjFfbmFtZSwKKwkJCQkgICAgV1BBX1BNS19OQU1FX0xFTikgPT0gMCkgewogCQkJb3NfbWVtY3B5KHBta19yMSwgcjEtPnBta19yMSwgUE1LX0xFTik7CiAJCQlpZiAocGFpcndpc2UpCiAJCQkJKnBhaXJ3aXNlID0gcjEtPnBhaXJ3aXNlOwpAQCAtMjkzLDIyICszMDAsMjYgQEAKIH0KIAogCi1zdGF0aWMgaW50IHdwYV9mdF9wdWxsX3Bta19yMShzdHJ1Y3Qgd3BhX2F1dGhlbnRpY2F0b3IgKndwYV9hdXRoLAotCQkJICAgICAgY29uc3QgdTggKnMxa2hfaWQsIGNvbnN0IHU4ICpyMGtoX2lkLAotCQkJICAgICAgc2l6ZV90IHIwa2hfaWRfbGVuLCBjb25zdCB1OCAqcG1rX3IwX25hbWUpCitzdGF0aWMgaW50IHdwYV9mdF9wdWxsX3Bta19yMShzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtLAorCQkJICAgICAgY29uc3QgdTggKmllcywgc2l6ZV90IGllc19sZW4sCisJCQkgICAgICBjb25zdCB1OCAqcG1rX3IwX25hbWUpCiB7CiAJc3RydWN0IGZ0X3JlbW90ZV9yMGtoICpyMGtoOwogCXN0cnVjdCBmdF9yMGtoX3Ixa2hfcHVsbF9mcmFtZSBmcmFtZSwgZjsKIAotCXIwa2ggPSB3cGFfYXV0aC0+Y29uZi5yMGtoX2xpc3Q7CisJcjBraCA9IHNtLT53cGFfYXV0aC0+Y29uZi5yMGtoX2xpc3Q7CiAJd2hpbGUgKHIwa2gpIHsKLQkJaWYgKHIwa2gtPmlkX2xlbiA9PSByMGtoX2lkX2xlbiAmJgotCQkgICAgb3NfbWVtY21wKHIwa2gtPmlkLCByMGtoX2lkLCByMGtoX2lkX2xlbikgPT0gMCkKKwkJaWYgKHIwa2gtPmlkX2xlbiA9PSBzbS0+cjBraF9pZF9sZW4gJiYKKwkJICAgIG9zX21lbWNtcF9jb25zdChyMGtoLT5pZCwgc20tPnIwa2hfaWQsIHNtLT5yMGtoX2lkX2xlbikgPT0KKwkJICAgIDApCiAJCQlicmVhazsKIAkJcjBraCA9IHIwa2gtPm5leHQ7CiAJfQotCWlmIChyMGtoID09IE5VTEwpCisJaWYgKHIwa2ggPT0gTlVMTCkgeworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJGVDogRGlkIG5vdCBmaW5kIFIwS0gtSUQiLAorCQkJICAgIHNtLT5yMGtoX2lkLCBzbS0+cjBraF9pZF9sZW4pOwogCQlyZXR1cm4gLTE7CisJfQogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogU2VuZCBQTUstUjEgcHVsbCByZXF1ZXN0IHRvIHJlbW90ZSBSMEtIICIKIAkJICAgImFkZHJlc3MgIiBNQUNTVFIsIE1BQzJTVFIocjBraC0+YWRkcikpOwpAQCAtMzE3LDI1ICszMjgsMzIgQEAKIAlmcmFtZS5mcmFtZV90eXBlID0gUlNOX1JFTU9URV9GUkFNRV9UWVBFX0ZUX1JSQjsKIAlmcmFtZS5wYWNrZXRfdHlwZSA9IEZUX1BBQ0tFVF9SMEtIX1IxS0hfUFVMTDsKIAlmcmFtZS5kYXRhX2xlbmd0aCA9IGhvc3RfdG9fbGUxNihGVF9SMEtIX1IxS0hfUFVMTF9EQVRBX0xFTik7Ci0Jb3NfbWVtY3B5KGZyYW1lLmFwX2FkZHJlc3MsIHdwYV9hdXRoLT5hZGRyLCBFVEhfQUxFTik7CisJb3NfbWVtY3B5KGZyYW1lLmFwX2FkZHJlc3MsIHNtLT53cGFfYXV0aC0+YWRkciwgRVRIX0FMRU4pOwogCiAJLyogYWVzX3dyYXAoKSBkb2VzIG5vdCBzdXBwb3J0IGlucGxhY2UgZW5jcnlwdGlvbiwgc28gdXNlIGEgdGVtcG9yYXJ5CiAJICogYnVmZmVyIGZvciB0aGUgZGF0YS4gKi8KLQlpZiAocmFuZG9tX2dldF9ieXRlcyhmLm5vbmNlLCBzaXplb2YoZi5ub25jZSkpKSB7CisJaWYgKHJhbmRvbV9nZXRfYnl0ZXMoZi5ub25jZSwgRlRfUjBLSF9SMUtIX1BVTExfTk9OQ0VfTEVOKSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBGYWlsZWQgdG8gZ2V0IHJhbmRvbSBkYXRhIGZvciAiCiAJCQkgICAibm9uY2UiKTsKIAkJcmV0dXJuIC0xOwogCX0KKwlvc19tZW1jcHkoc20tPmZ0X3BlbmRpbmdfcHVsbF9ub25jZSwgZi5ub25jZSwKKwkJICBGVF9SMEtIX1IxS0hfUFVMTF9OT05DRV9MRU4pOwogCW9zX21lbWNweShmLnBta19yMF9uYW1lLCBwbWtfcjBfbmFtZSwgV1BBX1BNS19OQU1FX0xFTik7Ci0Jb3NfbWVtY3B5KGYucjFraF9pZCwgd3BhX2F1dGgtPmNvbmYucjFfa2V5X2hvbGRlciwgRlRfUjFLSF9JRF9MRU4pOwotCW9zX21lbWNweShmLnMxa2hfaWQsIHMxa2hfaWQsIEVUSF9BTEVOKTsKKwlvc19tZW1jcHkoZi5yMWtoX2lkLCBzbS0+d3BhX2F1dGgtPmNvbmYucjFfa2V5X2hvbGRlciwgRlRfUjFLSF9JRF9MRU4pOworCW9zX21lbWNweShmLnMxa2hfaWQsIHNtLT5hZGRyLCBFVEhfQUxFTik7CiAJb3NfbWVtc2V0KGYucGFkLCAwLCBzaXplb2YoZi5wYWQpKTsKIAogCWlmIChhZXNfd3JhcChyMGtoLT5rZXksIChGVF9SMEtIX1IxS0hfUFVMTF9EQVRBX0xFTiArIDcpIC8gOCwKIAkJICAgICBmLm5vbmNlLCBmcmFtZS5ub25jZSkgPCAwKQogCQlyZXR1cm4gLTE7CiAKLQl3cGFfZnRfcnJiX3NlbmQod3BhX2F1dGgsIHIwa2gtPmFkZHIsICh1OCAqKSAmZnJhbWUsIHNpemVvZihmcmFtZSkpOworCXdwYWJ1Zl9mcmVlKHNtLT5mdF9wZW5kaW5nX3JlcV9pZXMpOworCXNtLT5mdF9wZW5kaW5nX3JlcV9pZXMgPSB3cGFidWZfYWxsb2NfY29weShpZXMsIGllc19sZW4pOworCWlmIChzbS0+ZnRfcGVuZGluZ19yZXFfaWVzID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXdwYV9mdF9ycmJfc2VuZChzbS0+d3BhX2F1dGgsIHIwa2gtPmFkZHIsICh1OCAqKSAmZnJhbWUsIHNpemVvZihmcmFtZSkpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC01NzAsOCArNTg4LDggQEAKIAkJCWVsc2UgewogCQkJCS8qIFRTUEVDIGFjY2VwdGVkOyBpbmNsdWRlIHVwZGF0ZWQgVFNQRUMgaW4KIAkJCQkgKiByZXNwb25zZSAqLwotCQkgICAgICAgICAgICAgICAgcmRpZS0+ZGVzY3JfY291bnQgPSAxOwotCSAgICAgICAgICAgICAgICAgICAgICAgIHBvcyArPSBzaXplb2YoKnRzcGVjKTsKKwkJCQlyZGllLT5kZXNjcl9jb3VudCA9IDE7CisJCQkJcG9zICs9IHNpemVvZigqdHNwZWMpOwogCQkJfQogCQkJcmV0dXJuIHBvczsKIAkJfQpAQCAtNjMzLDggKzY1MSw3IEBACiAKIAljb25mID0gJnNtLT53cGFfYXV0aC0+Y29uZjsKIAotCWlmIChzbS0+d3BhX2tleV9tZ210ICE9IFdQQV9LRVlfTUdNVF9GVF9JRUVFODAyMVggJiYKLQkgICAgc20tPndwYV9rZXlfbWdtdCAhPSBXUEFfS0VZX01HTVRfRlRfUFNLKQorCWlmICghd3BhX2tleV9tZ210X2Z0KHNtLT53cGFfa2V5X21nbXQpKQogCQlyZXR1cm4gcG9zOwogCiAJZW5kID0gcG9zICsgbWF4X2xlbjsKQEAgLTc3OCw3ICs3OTUsNyBAQAogfQogCiAKLXN0YXRpYyB1MTYgd3BhX2Z0X3Byb2Nlc3NfYXV0aF9yZXEoc3RydWN0IHdwYV9zdGF0ZV9tYWNoaW5lICpzbSwKK3N0YXRpYyBpbnQgd3BhX2Z0X3Byb2Nlc3NfYXV0aF9yZXEoc3RydWN0IHdwYV9zdGF0ZV9tYWNoaW5lICpzbSwKIAkJCQkgICBjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbiwKIAkJCQkgICB1OCAqKnJlc3BfaWVzLCBzaXplX3QgKnJlc3BfaWVzX2xlbikKIHsKQEAgLTg0OSwxOSArODY2LDEzIEBACiAKIAlpZiAod3BhX2Z0X2ZldGNoX3Bta19yMShzbS0+d3BhX2F1dGgsIHNtLT5hZGRyLCBwbWtfcjFfbmFtZSwgcG1rX3IxLAogCQkgICAgJnBhaXJ3aXNlKSA8IDApIHsKLQkJaWYgKHdwYV9mdF9wdWxsX3Bta19yMShzbS0+d3BhX2F1dGgsIHNtLT5hZGRyLCBzbS0+cjBraF9pZCwKLQkJCQkgICAgICAgc20tPnIwa2hfaWRfbGVuLCBwYXJzZS5yc25fcG1raWQpIDwgMCkgeworCQlpZiAod3BhX2Z0X3B1bGxfcG1rX3IxKHNtLCBpZXMsIGllc19sZW4sIHBhcnNlLnJzbl9wbWtpZCkgPCAwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBEaWQgbm90IGhhdmUgbWF0Y2hpbmcgIgogCQkJCSAgICJQTUstUjEgYW5kIHVua25vd24gUjBLSC1JRCIpOwogCQkJcmV0dXJuIFdMQU5fU1RBVFVTX0lOVkFMSURfUE1LSUQ7CiAJCX0KIAotCQkvKgotCQkgKiBUT0RPOiBTaG91bGQgcmV0dXJuICJzdGF0dXMgcGVuZGluZyIgKGFuZCB0aGUgY2FsbGVyIHNob3VsZAotCQkgKiBub3Qgc2VuZCBvdXQgcmVzcG9uc2Ugbm93KS4gVGhlIHJlYWwgcmVzcG9uc2Ugd2lsbCBiZSBzZW50Ci0JCSAqIG9uY2UgdGhlIHJlc3BvbnNlIGZyb20gUjBLSCBpcyByZWNlaXZlZC4KLQkJICovCi0JCXJldHVybiBXTEFOX1NUQVRVU19JTlZBTElEX1BNS0lEOworCQlyZXR1cm4gLTE7IC8qIFN0YXR1cyBwZW5kaW5nICovCiAJfQogCiAJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIkZUOiBTZWxlY3RlZCBQTUstUjEiLCBwbWtfcjEsIFBNS19MRU4pOwpAQCAtODg4LDYgKzg5OSw3IEBACiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRlQ6IFBUS05hbWUiLCBwdGtfbmFtZSwgV1BBX1BNS19OQU1FX0xFTik7CiAKIAlzbS0+cGFpcndpc2UgPSBwYWlyd2lzZTsKKwlzbS0+UFRLX3ZhbGlkID0gVFJVRTsKIAl3cGFfZnRfaW5zdGFsbF9wdGsoc20pOwogCiAJYnVmbGVuID0gMiArIHNpemVvZihzdHJ1Y3QgcnNuX21kaWUpICsgMiArIHNpemVvZihzdHJ1Y3QgcnNuX2Z0aWUpICsKQEAgLTk0MSw2ICs5NTMsNyBAQAogCXUxNiBzdGF0dXM7CiAJdTggKnJlc3BfaWVzOwogCXNpemVfdCByZXNwX2llc19sZW47CisJaW50IHJlczsKIAogCWlmIChzbSA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IFJlY2VpdmVkIGF1dGhlbnRpY2F0aW9uIGZyYW1lLCBidXQgIgpAQCAtOTUxLDggKzk2NCwxNiBAQAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IFJlY2VpdmVkIGF1dGhlbnRpY2F0aW9uIGZyYW1lOiBTVEE9IiBNQUNTVFIKIAkJICAgIiBCU1NJRD0iIE1BQ1NUUiAiIHRyYW5zYWN0aW9uPSVkIiwKIAkJICAgTUFDMlNUUihzbS0+YWRkciksIE1BQzJTVFIoYnNzaWQpLCBhdXRoX3RyYW5zYWN0aW9uKTsKLQlzdGF0dXMgPSB3cGFfZnRfcHJvY2Vzc19hdXRoX3JlcShzbSwgaWVzLCBpZXNfbGVuLCAmcmVzcF9pZXMsCi0JCQkJCSAmcmVzcF9pZXNfbGVuKTsKKwlzbS0+ZnRfcGVuZGluZ19jYiA9IGNiOworCXNtLT5mdF9wZW5kaW5nX2NiX2N0eCA9IGN0eDsKKwlzbS0+ZnRfcGVuZGluZ19hdXRoX3RyYW5zYWN0aW9uID0gYXV0aF90cmFuc2FjdGlvbjsKKwlyZXMgPSB3cGFfZnRfcHJvY2Vzc19hdXRoX3JlcShzbSwgaWVzLCBpZXNfbGVuLCAmcmVzcF9pZXMsCisJCQkJICAgICAgJnJlc3BfaWVzX2xlbik7CisJaWYgKHJlcyA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogQ2FsbGJhY2sgcG9zdHBvbmVkIHVudGlsIHJlc3BvbnNlIGlzIGF2YWlsYWJsZSIpOworCQlyZXR1cm47CisJfQorCXN0YXR1cyA9IHJlczsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IEZUIGF1dGhlbnRpY2F0aW9uIHJlc3BvbnNlOiBkc3Q9IiBNQUNTVFIKIAkJICAgIiBhdXRoX3RyYW5zYWN0aW9uPSVkIHN0YXR1cz0lZCIsCkBAIC05OTMsOCArMTAxNCw4IEBACiAJCXJldHVybiBXTEFOX1NUQVRVU19JTlZBTElEX1BNS0lEOwogCX0KIAotCWlmIChvc19tZW1jbXAocGFyc2UucnNuX3Bta2lkLCBzbS0+cG1rX3IxX25hbWUsIFdQQV9QTUtfTkFNRV9MRU4pICE9IDApCi0JeworCWlmIChvc19tZW1jbXBfY29uc3QocGFyc2UucnNuX3Bta2lkLCBzbS0+cG1rX3IxX25hbWUsIFdQQV9QTUtfTkFNRV9MRU4pCisJICAgICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUE1LSUQgaW4gUmVhc3NvYyBSZXEgZGlkIG5vdCBtYXRjaCAiCiAJCQkgICAid2l0aCB0aGUgUE1LUjFOYW1lIGRlcml2ZWQgZnJvbSBhdXRoIHJlcXVlc3QiKTsKIAkJcmV0dXJuIFdMQU5fU1RBVFVTX0lOVkFMSURfUE1LSUQ7CkBAIC0xMDQwLDcgKzEwNjEsOCBAQAogCX0KIAogCWlmIChwYXJzZS5yMGtoX2lkX2xlbiAhPSBzbS0+cjBraF9pZF9sZW4gfHwKLQkgICAgb3NfbWVtY21wKHBhcnNlLnIwa2hfaWQsIHNtLT5yMGtoX2lkLCBwYXJzZS5yMGtoX2lkX2xlbikgIT0gMCkgeworCSAgICBvc19tZW1jbXBfY29uc3QocGFyc2UucjBraF9pZCwgc20tPnIwa2hfaWQsIHBhcnNlLnIwa2hfaWRfbGVuKSAhPSAwKQorCXsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUjBLSC1JRCBpbiBGVElFIGRpZCBub3QgbWF0Y2ggd2l0aCAiCiAJCQkgICAidGhlIGN1cnJlbnQgUjBLSC1JRCIpOwogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJGVDogUjBLSC1JRCBpbiBGVElFIiwKQEAgLTEwNTUsOCArMTA3Nyw4IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQlpZiAob3NfbWVtY21wKHBhcnNlLnIxa2hfaWQsIHNtLT53cGFfYXV0aC0+Y29uZi5yMV9rZXlfaG9sZGVyLAotCQkgICAgICBGVF9SMUtIX0lEX0xFTikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QocGFyc2UucjFraF9pZCwgc20tPndwYV9hdXRoLT5jb25mLnIxX2tleV9ob2xkZXIsCisJCQkgICAgRlRfUjFLSF9JRF9MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogVW5rbm93biBSMUtILUlEIHVzZWQgaW4gIgogCQkJICAgIlJlYXNzb2NSZXEiKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRlQ6IFIxS0gtSUQgaW4gRlRJRSIsCkBAIC0xMDY3LDcgKzEwODksOCBAQAogCX0KIAogCWlmIChwYXJzZS5yc25fcG1raWQgPT0gTlVMTCB8fAotCSAgICBvc19tZW1jbXAocGFyc2UucnNuX3Bta2lkLCBzbS0+cG1rX3IxX25hbWUsIFdQQV9QTUtfTkFNRV9MRU4pKSB7CisJICAgIG9zX21lbWNtcF9jb25zdChwYXJzZS5yc25fcG1raWQsIHNtLT5wbWtfcjFfbmFtZSwgV1BBX1BNS19OQU1FX0xFTikpCisJewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBObyBtYXRjaGluZyBQTUtSMU5hbWUgKFBNS0lEKSBpbiAiCiAJCQkgICAiUlNOSUUgKHBta2lkPSVkKSIsICEhcGFyc2UucnNuX3Bta2lkKTsKIAkJcmV0dXJuIC0xOwpAQCAtMTA5Myw3ICsxMTE2LDcgQEAKIAkJcmV0dXJuIFdMQU5fU1RBVFVTX1VOU1BFQ0lGSUVEX0ZBSUxVUkU7CiAJfQogCi0JaWYgKG9zX21lbWNtcChtaWMsIGZ0aWUtPm1pYywgMTYpICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KG1pYywgZnRpZS0+bWljLCAxNikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBJbnZhbGlkIE1JQyBpbiBGVElFIik7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IGFkZHI9IiBNQUNTVFIgIiBhdXRoX2FkZHI9IiBNQUNTVFIsCiAJCQkgICBNQUMyU1RSKHNtLT5hZGRyKSwgTUFDMlNUUihzbS0+d3BhX2F1dGgtPmFkZHIpKTsKQEAgLTExODMsMTUgKzEyMDYsMjcgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFfZnRfcnJiX3J4X3JlcXVlc3RfY2Iodm9pZCAqY3R4LCBjb25zdCB1OCAqZHN0LCBjb25zdCB1OCAqYnNzaWQsCisJCQkJICAgICB1MTYgYXV0aF90cmFuc2FjdGlvbiwgdTE2IHJlc3AsCisJCQkJICAgICBjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbikKK3sKKwlzdHJ1Y3Qgd3BhX3N0YXRlX21hY2hpbmUgKnNtID0gY3R4OworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IE92ZXItdGhlLURTIFJYIHJlcXVlc3QgY2IgZm9yICIgTUFDU1RSLAorCQkgICBNQUMyU1RSKHNtLT5hZGRyKSk7CisJd3BhX2Z0X3NlbmRfcnJiX2F1dGhfcmVzcChzbSwgc20tPmZ0X3BlbmRpbmdfY3VycmVudF9hcCwgc20tPmFkZHIsCisJCQkJICBXTEFOX1NUQVRVU19TVUNDRVNTLCBpZXMsIGllc19sZW4pOworfQorCisKIHN0YXRpYyBpbnQgd3BhX2Z0X3JyYl9yeF9yZXF1ZXN0KHN0cnVjdCB3cGFfYXV0aGVudGljYXRvciAqd3BhX2F1dGgsCiAJCQkJIGNvbnN0IHU4ICpjdXJyZW50X2FwLCBjb25zdCB1OCAqc3RhX2FkZHIsCiAJCQkJIGNvbnN0IHU4ICpib2R5LCBzaXplX3QgbGVuKQogewogCXN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqc207CiAJdTE2IHN0YXR1czsKLQl1OCAqcmVzcF9pZXMsICpwb3M7Ci0Jc2l6ZV90IHJlc3BfaWVzX2xlbiwgcmxlbjsKLQlzdHJ1Y3QgZnRfcnJiX2ZyYW1lICpmcmFtZTsKKwl1OCAqcmVzcF9pZXM7CisJc2l6ZV90IHJlc3BfaWVzX2xlbjsKKwlpbnQgcmVzOwogCiAJc20gPSB3cGFfZnRfYWRkX3N0YSh3cGFfYXV0aCwgc3RhX2FkZHIpOwogCWlmIChzbSA9PSBOVUxMKSB7CkBAIC0xMjAyLDggKzEyMzcsMzMgQEAKIAogCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiRlQ6IFJSQiBSZXF1ZXN0IEZyYW1lIGJvZHkiLCBib2R5LCBsZW4pOwogCi0Jc3RhdHVzID0gd3BhX2Z0X3Byb2Nlc3NfYXV0aF9yZXEoc20sIGJvZHksIGxlbiwgJnJlc3BfaWVzLAotCQkJCQkgJnJlc3BfaWVzX2xlbik7CisJc20tPmZ0X3BlbmRpbmdfY2IgPSB3cGFfZnRfcnJiX3J4X3JlcXVlc3RfY2I7CisJc20tPmZ0X3BlbmRpbmdfY2JfY3R4ID0gc207CisJb3NfbWVtY3B5KHNtLT5mdF9wZW5kaW5nX2N1cnJlbnRfYXAsIGN1cnJlbnRfYXAsIEVUSF9BTEVOKTsKKwlyZXMgPSB3cGFfZnRfcHJvY2Vzc19hdXRoX3JlcShzbSwgYm9keSwgbGVuLCAmcmVzcF9pZXMsCisJCQkJICAgICAgJnJlc3BfaWVzX2xlbik7CisJaWYgKHJlcyA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogTm8gaW1tZWRpYXRlIHJlc3BvbnNlIGF2YWlsYWJsZSAtIHdhaXQgZm9yIHB1bGwgcmVzcG9uc2UiKTsKKwkJcmV0dXJuIDA7CisJfQorCXN0YXR1cyA9IHJlczsKKworCXJlcyA9IHdwYV9mdF9zZW5kX3JyYl9hdXRoX3Jlc3Aoc20sIGN1cnJlbnRfYXAsIHN0YV9hZGRyLCBzdGF0dXMsCisJCQkJCXJlc3BfaWVzLCByZXNwX2llc19sZW4pOworCW9zX2ZyZWUocmVzcF9pZXMpOworCXJldHVybiByZXM7Cit9CisKKworc3RhdGljIGludCB3cGFfZnRfc2VuZF9ycmJfYXV0aF9yZXNwKHN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqc20sCisJCQkJICAgICBjb25zdCB1OCAqY3VycmVudF9hcCwgY29uc3QgdTggKnN0YV9hZGRyLAorCQkJCSAgICAgdTE2IHN0YXR1cywgY29uc3QgdTggKnJlc3BfaWVzLAorCQkJCSAgICAgc2l6ZV90IHJlc3BfaWVzX2xlbikKK3sKKwlzdHJ1Y3Qgd3BhX2F1dGhlbnRpY2F0b3IgKndwYV9hdXRoID0gc20tPndwYV9hdXRoOworCXNpemVfdCBybGVuOworCXN0cnVjdCBmdF9ycmJfZnJhbWUgKmZyYW1lOworCXU4ICpwb3M7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBSUkIgYXV0aGVudGljYXRpb24gcmVzcG9uc2U6IFNUQT0iIE1BQ1NUUgogCQkgICAiIEN1cnJlbnRBUD0iIE1BQ1NUUiAiIHN0YXR1cz0lZCIsCkBAIC0xMjE5LDEwICsxMjc5LDggQEAKIAlybGVuID0gMiArIDIgKiBFVEhfQUxFTiArIDIgKyByZXNwX2llc19sZW47CiAKIAlmcmFtZSA9IG9zX21hbGxvYyhzaXplb2YoKmZyYW1lKSArIHJsZW4pOwotCWlmIChmcmFtZSA9PSBOVUxMKSB7Ci0JCW9zX2ZyZWUocmVzcF9pZXMpOworCWlmIChmcmFtZSA9PSBOVUxMKQogCQlyZXR1cm4gLTE7Ci0JfQogCWZyYW1lLT5mcmFtZV90eXBlID0gUlNOX1JFTU9URV9GUkFNRV9UWVBFX0ZUX1JSQjsKIAlmcmFtZS0+cGFja2V0X3R5cGUgPSBGVF9QQUNLRVRfUkVTUE9OU0U7CiAJZnJhbWUtPmFjdGlvbl9sZW5ndGggPSBob3N0X3RvX2xlMTYocmxlbik7CkBAIC0xMjM2LDEwICsxMjk0LDggQEAKIAlwb3MgKz0gRVRIX0FMRU47CiAJV1BBX1BVVF9MRTE2KHBvcywgc3RhdHVzKTsKIAlwb3MgKz0gMjsKLQlpZiAocmVzcF9pZXMpIHsKKwlpZiAocmVzcF9pZXMpCiAJCW9zX21lbWNweShwb3MsIHJlc3BfaWVzLCByZXNwX2llc19sZW4pOwotCQlvc19mcmVlKHJlc3BfaWVzKTsKLQl9CiAKIAl3cGFfZnRfcnJiX3NlbmQod3BhX2F1dGgsIGN1cnJlbnRfYXAsICh1OCAqKSBmcmFtZSwKIAkJCXNpemVvZigqZnJhbWUpICsgcmxlbik7CkBAIC0xMjkxLDcgKzEzNDcsNyBAQAogCQkgICAgZi5ub25jZSwgc2l6ZW9mKGYubm9uY2UpKTsKIAl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJGVDogUE1LLVIxIHB1bGwgLSBQTUtSME5hbWUiLAogCQkgICAgZi5wbWtfcjBfbmFtZSwgV1BBX1BNS19OQU1FX0xFTik7Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUE1LLVIxIHB1bGwgLSBSMUtILUlEPSIgTUFDU1RSICJTMUtILUlEPSIKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBQTUstUjEgcHVsbCAtIFIxS0gtSUQ9IiBNQUNTVFIgIiBTMUtILUlEPSIKIAkJICAgTUFDU1RSLCBNQUMyU1RSKGYucjFraF9pZCksIE1BQzJTVFIoZi5zMWtoX2lkKSk7CiAKIAlvc19tZW1zZXQoJnJlc3AsIDAsIHNpemVvZihyZXNwKSk7CkBAIC0xMzM0LDEzICsxMzkwLDU4IEBACiB9CiAKIAorc3RhdGljIHZvaWQgZnRfcHVsbF9yZXNwX2NiX2ZpbmlzaCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQoreworCXN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqc20gPSBlbG9vcF9jdHg7CisJaW50IHJlczsKKwl1OCAqcmVzcF9pZXM7CisJc2l6ZV90IHJlc3BfaWVzX2xlbjsKKwl1MTYgc3RhdHVzOworCisJcmVzID0gd3BhX2Z0X3Byb2Nlc3NfYXV0aF9yZXEoc20sIHdwYWJ1Zl9oZWFkKHNtLT5mdF9wZW5kaW5nX3JlcV9pZXMpLAorCQkJCSAgICAgIHdwYWJ1Zl9sZW4oc20tPmZ0X3BlbmRpbmdfcmVxX2llcyksCisJCQkJICAgICAgJnJlc3BfaWVzLCAmcmVzcF9pZXNfbGVuKTsKKwl3cGFidWZfZnJlZShzbS0+ZnRfcGVuZGluZ19yZXFfaWVzKTsKKwlzbS0+ZnRfcGVuZGluZ19yZXFfaWVzID0gTlVMTDsKKwlpZiAocmVzIDwgMCkKKwkJcmVzID0gV0xBTl9TVEFUVVNfVU5TUEVDSUZJRURfRkFJTFVSRTsKKwlzdGF0dXMgPSByZXM7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUG9zdHBvbmVkIGF1dGggY2FsbGJhY2sgcmVzdWx0IGZvciAiIE1BQ1NUUgorCQkgICAiIC0gc3RhdHVzICV1IiwgTUFDMlNUUihzbS0+YWRkciksIHN0YXR1cyk7CisKKwlzbS0+ZnRfcGVuZGluZ19jYihzbS0+ZnRfcGVuZGluZ19jYl9jdHgsIHNtLT5hZGRyLCBzbS0+d3BhX2F1dGgtPmFkZHIsCisJCQkgIHNtLT5mdF9wZW5kaW5nX2F1dGhfdHJhbnNhY3Rpb24gKyAxLCBzdGF0dXMsCisJCQkgIHJlc3BfaWVzLCByZXNwX2llc19sZW4pOworCW9zX2ZyZWUocmVzcF9pZXMpOworfQorCisKK3N0YXRpYyBpbnQgZnRfcHVsbF9yZXNwX2NiKHN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqc20sIHZvaWQgKmN0eCkKK3sKKwlzdHJ1Y3QgZnRfcjBraF9yMWtoX3Jlc3BfZnJhbWUgKmZyYW1lID0gY3R4OworCisJaWYgKG9zX21lbWNtcChmcmFtZS0+czFraF9pZCwgc20tPmFkZHIsIEVUSF9BTEVOKSAhPSAwKQorCQlyZXR1cm4gMDsKKwlpZiAob3NfbWVtY21wKGZyYW1lLT5ub25jZSwgc20tPmZ0X3BlbmRpbmdfcHVsbF9ub25jZSwKKwkJICAgICAgRlRfUjBLSF9SMUtIX1BVTExfTk9OQ0VfTEVOKSAhPSAwKQorCQlyZXR1cm4gMDsKKwlpZiAoc20tPmZ0X3BlbmRpbmdfY2IgPT0gTlVMTCB8fCBzbS0+ZnRfcGVuZGluZ19yZXFfaWVzID09IE5VTEwpCisJCXJldHVybiAwOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUmVzcG9uc2UgdG8gYSBwZW5kaW5nIHB1bGwgcmVxdWVzdCBmb3IgIgorCQkgICBNQUNTVFIgIiAtIHByb2Nlc3MgZnJvbSB0aW1lb3V0IiwgTUFDMlNUUihzbS0+YWRkcikpOworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMCwgMCwgZnRfcHVsbF9yZXNwX2NiX2ZpbmlzaCwgc20sIE5VTEwpOworCXJldHVybiAxOworfQorCisKIHN0YXRpYyBpbnQgd3BhX2Z0X3JyYl9yeF9yZXNwKHN0cnVjdCB3cGFfYXV0aGVudGljYXRvciAqd3BhX2F1dGgsCiAJCQkgICAgICBjb25zdCB1OCAqc3JjX2FkZHIsCiAJCQkgICAgICBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGRhdGFfbGVuKQogewogCXN0cnVjdCBmdF9yMGtoX3Ixa2hfcmVzcF9mcmFtZSAqZnJhbWUsIGY7CiAJc3RydWN0IGZ0X3JlbW90ZV9yMGtoICpyMGtoOwotCWludCBwYWlyd2lzZTsKKwlpbnQgcGFpcndpc2UsIHJlczsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IFJlY2VpdmVkIFBNSy1SMSBwdWxsIHJlc3BvbnNlIik7CiAKQEAgLTEzNzAsMjEgKzE0NzEsMTcgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmIChvc19tZW1jbXAoZi5yMWtoX2lkLCB3cGFfYXV0aC0+Y29uZi5yMV9rZXlfaG9sZGVyLCBGVF9SMUtIX0lEX0xFTikKLQkgICAgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QoZi5yMWtoX2lkLCB3cGFfYXV0aC0+Y29uZi5yMV9rZXlfaG9sZGVyLAorCQkJICAgIEZUX1IxS0hfSURfTEVOKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IFBNSy1SMSBwdWxsIHJlc3BvbnNlIGRpZCBub3QgdXNlIGEgIgogCQkJICAgIm1hdGNoaW5nIFIxS0gtSUQiKTsKIAkJcmV0dXJuIC0xOwogCX0KIAotCS8qIFRPRE86IHZlcmlmeSB0aGF0IDxub25jZSxzMWtoX2lkPiBtYXRjaGVzIHdpdGggYSBwZW5kaW5nIHJlcXVlc3QKLQkgKiBhbmQgY2FsbCB0aGlzIHJlcXVlc3RzIGNhbGxiYWNrIGZ1bmN0aW9uIHRvIGZpbmlzaCByZXF1ZXN0Ci0JICogcHJvY2Vzc2luZyAqLwotCiAJcGFpcndpc2UgPSBsZV90b19ob3N0MTYoZi5wYWlyd2lzZSk7CiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRlQ6IFBNSy1SMSBwdWxsIC0gbm9uY2UiLAogCQkgICAgZi5ub25jZSwgc2l6ZW9mKGYubm9uY2UpKTsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBQTUstUjEgcHVsbCAtIFIxS0gtSUQ9IiBNQUNTVFIgIlMxS0gtSUQ9IgorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IFBNSy1SMSBwdWxsIC0gUjFLSC1JRD0iIE1BQ1NUUiAiIFMxS0gtSUQ9IgogCQkgICBNQUNTVFIgIiBwYWlyd2lzZT0weCV4IiwKIAkJICAgTUFDMlNUUihmLnIxa2hfaWQpLCBNQUMyU1RSKGYuczFraF9pZCksIHBhaXJ3aXNlKTsKIAl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiRlQ6IFBNSy1SMSBwdWxsIC0gUE1LLVIxIiwKQEAgLTEzOTIsMTEgKzE0ODksMTMgQEAKIAl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJGVDogUE1LLVIxIHB1bGwgLSBQTUtSMU5hbWUiLAogCQkJZi5wbWtfcjFfbmFtZSwgV1BBX1BNS19OQU1FX0xFTik7CiAKLQl3cGFfZnRfc3RvcmVfcG1rX3IxKHdwYV9hdXRoLCBmLnMxa2hfaWQsIGYucG1rX3IxLCBmLnBta19yMV9uYW1lLAotCQkJICAgIHBhaXJ3aXNlKTsKKwlyZXMgPSB3cGFfZnRfc3RvcmVfcG1rX3IxKHdwYV9hdXRoLCBmLnMxa2hfaWQsIGYucG1rX3IxLCBmLnBta19yMV9uYW1lLAorCQkJCSAgcGFpcndpc2UpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IExvb2sgZm9yIHBlbmRpbmcgcHVsbCByZXF1ZXN0Iik7CisJd3BhX2F1dGhfZm9yX2VhY2hfc3RhKHdwYV9hdXRoLCBmdF9wdWxsX3Jlc3BfY2IsICZmKTsKIAlvc19tZW1zZXQoZi5wbWtfcjEsIDAsIFBNS19MRU4pOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHJlcyA/IDAgOiAtMTsKIH0KIAogCkBAIC0xNDQ4LDggKzE1NDcsOCBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKG9zX21lbWNtcChmLnIxa2hfaWQsIHdwYV9hdXRoLT5jb25mLnIxX2tleV9ob2xkZXIsIEZUX1IxS0hfSURfTEVOKQotCSAgICAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChmLnIxa2hfaWQsIHdwYV9hdXRoLT5jb25mLnIxX2tleV9ob2xkZXIsCisJCQkgICAgRlRfUjFLSF9JRF9MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUE1LLVIxIHB1c2ggZGlkIG5vdCB1c2UgYSBtYXRjaGluZyAiCiAJCQkgICAiUjFLSC1JRCAocmVjZWl2ZWQgIiBNQUNTVFIgIiBvd24gIiBNQUNTVFIgIikiLAogCQkJICAgTUFDMlNUUihmLnIxa2hfaWQpLApAQCAtMTU5MCw2ICsxNjg5LDExIEBACiAJCXJldHVybiAtMTsKIAl9CiAKKwlpZiAoZW5kID4gcG9zKSB7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkZUOiBJZ25vcmUgZXh0cmEgZGF0YSBpbiBlbmQiLAorCQkJICAgIHBvcywgZW5kIC0gcG9zKTsKKwl9CisKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2FwL3dwYV9hdXRoX2dsdWUuYyBiL3NyYy9hcC93cGFfYXV0aF9nbHVlLmMKaW5kZXggZDk3N2I0Mi4uNmVlOWE0ZiAxMDA2NDQKLS0tIGEvc3JjL2FwL3dwYV9hdXRoX2dsdWUuYworKysgYi9zcmMvYXAvd3BhX2F1dGhfZ2x1ZS5jCkBAIC0xNSw3ICsxNSw2IEBACiAjaW5jbHVkZSAiZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtX2kuaCIKICNpbmNsdWRlICJlYXBfc2VydmVyL2VhcC5oIgogI2luY2x1ZGUgImwyX3BhY2tldC9sMl9wYWNrZXQuaCIKLSNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgogI2luY2x1ZGUgImhvc3RhcGQuaCIKICNpbmNsdWRlICJpZWVlODAyXzF4LmgiCiAjaW5jbHVkZSAicHJlYXV0aF9hdXRoLmgiCkBAIC01MCw2ICs0OSw3IEBACiAJd2NvbmYtPm9rYyA9IGNvbmYtPm9rYzsKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwogCXdjb25mLT5pZWVlODAyMTF3ID0gY29uZi0+aWVlZTgwMjExdzsKKwl3Y29uZi0+Z3JvdXBfbWdtdF9jaXBoZXIgPSBjb25mLT5ncm91cF9tZ210X2NpcGhlcjsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAJd2NvbmYtPnNzaWRfbGVuID0gY29uZi0+c3NpZC5zc2lkX2xlbjsKQEAgLTc0LDExICs3NCwzMCBAQAogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiAjaWZkZWYgQ09ORklHX0hTMjAKIAl3Y29uZi0+ZGlzYWJsZV9ndGsgPSBjb25mLT5kaXNhYmxlX2RnYWY7CisJaWYgKGNvbmYtPm9zZW4pIHsKKwkJd2NvbmYtPmRpc2FibGVfZ3RrID0gMTsKKwkJd2NvbmYtPndwYSA9IFdQQV9QUk9UT19PU0VOOworCQl3Y29uZi0+d3BhX2tleV9tZ210ID0gV1BBX0tFWV9NR01UX09TRU47CisJCXdjb25mLT53cGFfcGFpcndpc2UgPSAwOworCQl3Y29uZi0+d3BhX2dyb3VwID0gV1BBX0NJUEhFUl9DQ01QOworCQl3Y29uZi0+cnNuX3BhaXJ3aXNlID0gV1BBX0NJUEhFUl9DQ01QOworCQl3Y29uZi0+cnNuX3ByZWF1dGggPSAwOworCQl3Y29uZi0+ZGlzYWJsZV9wbWtzYV9jYWNoaW5nID0gMTsKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExVworCQl3Y29uZi0+aWVlZTgwMjExdyA9IDE7CisjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KKwl9CiAjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KICNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCiAJd2NvbmYtPmNvcnJ1cHRfZ3RrX3Jla2V5X21pY19wcm9iYWJpbGl0eSA9CiAJCWljb25mLT5jb3JydXB0X2d0a19yZWtleV9taWNfcHJvYmFiaWxpdHk7CiAjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLworI2lmZGVmIENPTkZJR19QMlAKKwlvc19tZW1jcHkod2NvbmYtPmlwX2FkZHJfZ28sIGNvbmYtPmlwX2FkZHJfZ28sIDQpOworCW9zX21lbWNweSh3Y29uZi0+aXBfYWRkcl9tYXNrLCBjb25mLT5pcF9hZGRyX21hc2ssIDQpOworCW9zX21lbWNweSh3Y29uZi0+aXBfYWRkcl9zdGFydCwgY29uZi0+aXBfYWRkcl9zdGFydCwgNCk7CisJb3NfbWVtY3B5KHdjb25mLT5pcF9hZGRyX2VuZCwgY29uZi0+aXBfYWRkcl9lbmQsIDQpOworI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIH0KIAogCkBAIC02MTgsNSArNjM3LDYgQEAKIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAJbDJfcGFja2V0X2RlaW5pdChoYXBkLT5sMik7CisJaGFwZC0+bDIgPSBOVUxMOwogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiB9CmRpZmYgLS1naXQgYS9zcmMvYXAvd3BhX2F1dGhfaS5oIGIvc3JjL2FwL3dwYV9hdXRoX2kuaAppbmRleCAxMmU1OWJjLi42OTYwZmYzIDEwMDY0NAotLS0gYS9zcmMvYXAvd3BhX2F1dGhfaS5oCisrKyBiL3NyYy9hcC93cGFfYXV0aF9pLmgKQEAgLTExOCw5ICsxMTgsMjIgQEAKIAl1OCBzdXBfcG1rX3IxX25hbWVbV1BBX1BNS19OQU1FX0xFTl07IC8qIFBNS1IxTmFtZSBmcm9tIEVBUE9MLUtleQogCQkJCQkgICAgICAgKiBtZXNzYWdlIDIvNCAqLwogCXU4ICphc3NvY19yZXNwX2Z0aWU7CisKKwl2b2lkICgqZnRfcGVuZGluZ19jYikodm9pZCAqY3R4LCBjb25zdCB1OCAqZHN0LCBjb25zdCB1OCAqYnNzaWQsCisJCQkgICAgICB1MTYgYXV0aF90cmFuc2FjdGlvbiwgdTE2IHN0YXR1cywKKwkJCSAgICAgIGNvbnN0IHU4ICppZXMsIHNpemVfdCBpZXNfbGVuKTsKKwl2b2lkICpmdF9wZW5kaW5nX2NiX2N0eDsKKwlzdHJ1Y3Qgd3BhYnVmICpmdF9wZW5kaW5nX3JlcV9pZXM7CisJdTggZnRfcGVuZGluZ19wdWxsX25vbmNlW0ZUX1IwS0hfUjFLSF9QVUxMX05PTkNFX0xFTl07CisJdTggZnRfcGVuZGluZ19hdXRoX3RyYW5zYWN0aW9uOworCXU4IGZ0X3BlbmRpbmdfY3VycmVudF9hcFtFVEhfQUxFTl07CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KIAogCWludCBwZW5kaW5nXzFfb2ZfNF90aW1lb3V0OworCisjaWZkZWYgQ09ORklHX1AyUAorCXU4IGlwX2FkZHJbNF07CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogfTsKIAogCkBAIC0xMzksNyArMTUyLDggQEAKIAogCWVudW0gewogCQlXUEFfR1JPVVBfR1RLX0lOSVQgPSAwLAotCQlXUEFfR1JPVVBfU0VUS0VZUywgV1BBX0dST1VQX1NFVEtFWVNET05FCisJCVdQQV9HUk9VUF9TRVRLRVlTLCBXUEFfR1JPVVBfU0VUS0VZU0RPTkUsCisJCVdQQV9HUk9VUF9GQVRBTF9GQUlMVVJFCiAJfSB3cGFfZ3JvdXBfc3RhdGU7CiAKIAl1OCBHTUtbV1BBX0dNS19MRU5dOwpAQCAtMTQ5LDcgKzE2Myw3IEBACiAJQm9vbGVhbiBmaXJzdF9zdGFfc2VlbjsKIAlCb29sZWFuIHJlamVjdF80d2F5X2hzX2Zvcl9lbnRyb3B5OwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCi0JdTggSUdUS1syXVtXUEFfSUdUS19MRU5dOworCXU4IElHVEtbMl1bV1BBX0lHVEtfTUFYX0xFTl07CiAJaW50IEdOX2lndGssIEdNX2lndGs7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIH07CkBAIC0xODQsNiArMTk4LDEwIEBACiAKIAlzdHJ1Y3QgcnNuX3Bta3NhX2NhY2hlICpwbWtzYTsKIAlzdHJ1Y3Qgd3BhX2Z0X3Bta19jYWNoZSAqZnRfcG1rX2NhY2hlOworCisjaWZkZWYgQ09ORklHX1AyUAorCXN0cnVjdCBiaXRmaWVsZCAqaXBfcG9vbDsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiB9OwogCiAKZGlmZiAtLWdpdCBhL3NyYy9hcC93cGFfYXV0aF9pZS5jIGIvc3JjL2FwL3dwYV9hdXRoX2llLmMKaW5kZXggY2RmY2NhMS4uMWU0ZGVmYyAxMDA2NDQKLS0tIGEvc3JjL2FwL3dwYV9hdXRoX2llLmMKKysrIGIvc3JjL2FwL3dwYV9hdXRoX2llLmMKQEAgLTI2MSw3ICsyNjEsMjUgQEAKIAkJfQogCiAJCS8qIE1hbmFnZW1lbnQgR3JvdXAgQ2lwaGVyIFN1aXRlICovCi0JCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX0FFU18xMjhfQ01BQyk7CisJCXN3aXRjaCAoY29uZi0+Z3JvdXBfbWdtdF9jaXBoZXIpIHsKKwkJY2FzZSBXUEFfQ0lQSEVSX0FFU18xMjhfQ01BQzoKKwkJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX0FFU18xMjhfQ01BQyk7CisJCQlicmVhazsKKwkJY2FzZSBXUEFfQ0lQSEVSX0JJUF9HTUFDXzEyODoKKwkJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzEyOCk7CisJCQlicmVhazsKKwkJY2FzZSBXUEFfQ0lQSEVSX0JJUF9HTUFDXzI1NjoKKwkJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzI1Nik7CisJCQlicmVhazsKKwkJY2FzZSBXUEFfQ0lQSEVSX0JJUF9DTUFDXzI1NjoKKwkJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX0JJUF9DTUFDXzI1Nik7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJJbnZhbGlkIGdyb3VwIG1hbmFnZW1lbnQgY2lwaGVyICgweCV4KSIsCisJCQkJICAgY29uZi0+Z3JvdXBfbWdtdF9jaXBoZXIpOworCQkJcmV0dXJuIC0xOworCQl9CiAJCXBvcyArPSBSU05fU0VMRUNUT1JfTEVOOwogCX0KICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwpAQCAtMjk1LDYgKzMxMyw1NSBAQAogfQogCiAKK3N0YXRpYyB1OCAqIHdwYV93cml0ZV9vc2VuKHN0cnVjdCB3cGFfYXV0aF9jb25maWcgKmNvbmYsIHU4ICplaWQpCit7CisJdTggKmxlbjsKKwl1MTYgY2FwYWI7CisKKwkqZWlkKysgPSBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUM7CisJbGVuID0gZWlkKys7IC8qIHRvIGJlIGZpbGxlZCAqLworCVdQQV9QVVRfQkUyNChlaWQsIE9VSV9XRkEpOworCWVpZCArPSAzOworCSplaWQrKyA9IEhTMjBfT1NFTl9PVUlfVFlQRTsKKworCS8qIEdyb3VwIERhdGEgQ2lwaGVyIFN1aXRlICovCisJUlNOX1NFTEVDVE9SX1BVVChlaWQsIFJTTl9DSVBIRVJfU1VJVEVfTk9fR1JPVVBfQUREUkVTU0VEKTsKKwllaWQgKz0gUlNOX1NFTEVDVE9SX0xFTjsKKworCS8qIFBhaXJ3aXNlIENpcGhlciBTdWl0ZSBDb3VudCBhbmQgTGlzdCAqLworCVdQQV9QVVRfTEUxNihlaWQsIDEpOworCWVpZCArPSAyOworCVJTTl9TRUxFQ1RPUl9QVVQoZWlkLCBSU05fQ0lQSEVSX1NVSVRFX0NDTVApOworCWVpZCArPSBSU05fU0VMRUNUT1JfTEVOOworCisJLyogQUtNIFN1aXRlIENvdW50IGFuZCBMaXN0ICovCisJV1BBX1BVVF9MRTE2KGVpZCwgMSk7CisJZWlkICs9IDI7CisJUlNOX1NFTEVDVE9SX1BVVChlaWQsIFJTTl9BVVRIX0tFWV9NR01UX09TRU4pOworCWVpZCArPSBSU05fU0VMRUNUT1JfTEVOOworCisJLyogUlNOIENhcGFiaWxpdGllcyAqLworCWNhcGFiID0gMDsKKwlpZiAoY29uZi0+d21tX2VuYWJsZWQpIHsKKwkJLyogNCBQVEtTQSByZXBsYXkgY291bnRlcnMgd2hlbiB1c2luZyBXTU0gKi8KKwkJY2FwYWIgfD0gKFJTTl9OVU1fUkVQTEFZX0NPVU5URVJTXzE2IDw8IDIpOworCX0KKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExVworCWlmIChjb25mLT5pZWVlODAyMTF3ICE9IE5PX01HTVRfRlJBTUVfUFJPVEVDVElPTikgeworCQljYXBhYiB8PSBXUEFfQ0FQQUJJTElUWV9NRlBDOworCQlpZiAoY29uZi0+aWVlZTgwMjExdyA9PSBNR01UX0ZSQU1FX1BST1RFQ1RJT05fUkVRVUlSRUQpCisJCQljYXBhYiB8PSBXUEFfQ0FQQUJJTElUWV9NRlBSOworCX0KKyNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLworCVdQQV9QVVRfTEUxNihlaWQsIGNhcGFiKTsKKwllaWQgKz0gMjsKKworCSpsZW4gPSBlaWQgLSBsZW4gLSAxOworCisJcmV0dXJuIGVpZDsKK30KKworCiBpbnQgd3BhX2F1dGhfZ2VuX3dwYV9pZShzdHJ1Y3Qgd3BhX2F1dGhlbnRpY2F0b3IgKndwYV9hdXRoKQogewogCXU4ICpwb3MsIGJ1ZlsxMjhdOwpAQCAtMzAyLDYgKzM2OSw5IEBACiAKIAlwb3MgPSBidWY7CiAKKwlpZiAod3BhX2F1dGgtPmNvbmYud3BhID09IFdQQV9QUk9UT19PU0VOKSB7CisJCXBvcyA9IHdwYV93cml0ZV9vc2VuKCZ3cGFfYXV0aC0+Y29uZiwgcG9zKTsKKwl9CiAJaWYgKHdwYV9hdXRoLT5jb25mLndwYSAmIFdQQV9QUk9UT19SU04pIHsKIAkJcmVzID0gd3BhX3dyaXRlX3Jzbl9pZSgmd3BhX2F1dGgtPmNvbmYsCiAJCQkJICAgICAgIHBvcywgYnVmICsgc2l6ZW9mKGJ1ZikgLSBwb3MsIE5VTEwpOwpAQCAtNTM0LDcgKzYwNCw4IEBACiAJCQlyZXR1cm4gV1BBX01HTVRfRlJBTUVfUFJPVEVDVElPTl9WSU9MQVRJT047CiAJCX0KIAotCQlpZiAoZGF0YS5tZ210X2dyb3VwX2NpcGhlciAhPSBXUEFfQ0lQSEVSX0FFU18xMjhfQ01BQykgeworCQlpZiAoZGF0YS5tZ210X2dyb3VwX2NpcGhlciAhPSB3cGFfYXV0aC0+Y29uZi5ncm91cF9tZ210X2NpcGhlcikKKwkJewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVbnN1cHBvcnRlZCBtYW5hZ2VtZW50IGdyb3VwICIKIAkJCQkgICAiY2lwaGVyICVkIiwgZGF0YS5tZ210X2dyb3VwX2NpcGhlcik7CiAJCQlyZXR1cm4gV1BBX0lOVkFMSURfTUdNVF9HUk9VUF9DSVBIRVI7CkBAIC02MDQsNyArNjc1LDcgQEAKIAkJCWJyZWFrOwogCQl9CiAJfQotCWlmIChzbS0+cG1rc2EpIHsKKwlpZiAoc20tPnBta3NhICYmIHBta2lkKSB7CiAJCXdwYV9hdXRoX3Zsb2dnZXIod3BhX2F1dGgsIHNtLT5hZGRyLCBMT0dHRVJfREVCVUcsCiAJCQkJICJQTUtJRCBmb3VuZCBmcm9tIFBNS1NBIGNhY2hlICIKIAkJCQkgImVhcF90eXBlPSVkIHZsYW5faWQ9JWQiLApAQCAtNjI2LDYgKzY5NywzNiBAQAogfQogCiAKKyNpZmRlZiBDT05GSUdfSFMyMAoraW50IHdwYV92YWxpZGF0ZV9vc2VuKHN0cnVjdCB3cGFfYXV0aGVudGljYXRvciAqd3BhX2F1dGgsCisJCSAgICAgIHN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqc20sCisJCSAgICAgIGNvbnN0IHU4ICpvc2VuX2llLCBzaXplX3Qgb3Nlbl9pZV9sZW4pCit7CisJaWYgKHdwYV9hdXRoID09IE5VTEwgfHwgc20gPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJLyogVE9ETzogcGFyc2UgT1NFTiBlbGVtZW50ICovCisJc20tPndwYV9rZXlfbWdtdCA9IFdQQV9LRVlfTUdNVF9PU0VOOworCXNtLT5tZ210X2ZyYW1lX3Byb3QgPSAxOworCXNtLT5wYWlyd2lzZSA9IFdQQV9DSVBIRVJfQ0NNUDsKKwlzbS0+d3BhID0gV1BBX1ZFUlNJT05fV1BBMjsKKworCWlmIChzbS0+d3BhX2llID09IE5VTEwgfHwgc20tPndwYV9pZV9sZW4gPCBvc2VuX2llX2xlbikgeworCQlvc19mcmVlKHNtLT53cGFfaWUpOworCQlzbS0+d3BhX2llID0gb3NfbWFsbG9jKG9zZW5faWVfbGVuKTsKKwkJaWYgKHNtLT53cGFfaWUgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwl9CisKKwlvc19tZW1jcHkoc20tPndwYV9pZSwgb3Nlbl9pZSwgb3Nlbl9pZV9sZW4pOworCXNtLT53cGFfaWVfbGVuID0gb3Nlbl9pZV9sZW47CisKKwlyZXR1cm4gMDsKK30KKworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisKKwogLyoqCiAgKiB3cGFfcGFyc2VfZ2VuZXJpYyAtIFBhcnNlIEVBUE9MLUtleSBLZXkgRGF0YSBHZW5lcmljIElFcwogICogQHBvczogUG9pbnRlciB0byB0aGUgSUUgaGVhZGVyCkBAIC02NDgsNiArNzQ5LDEyIEBACiAJCXJldHVybiAwOwogCX0KIAorCWlmIChwb3NbMV0gPj0gNCAmJiBXUEFfR0VUX0JFMzIocG9zICsgMikgPT0gT1NFTl9JRV9WRU5ET1JfVFlQRSkgeworCQlpZS0+b3NlbiA9IHBvczsKKwkJaWUtPm9zZW5fbGVuID0gcG9zWzFdICsgMjsKKwkJcmV0dXJuIDA7CisJfQorCiAJaWYgKHBvcyArIDEgKyBSU05fU0VMRUNUT1JfTEVOIDwgZW5kICYmCiAJICAgIHBvc1sxXSA+PSBSU05fU0VMRUNUT1JfTEVOICsgUE1LSURfTEVOICYmCiAJICAgIFJTTl9TRUxFQ1RPUl9HRVQocG9zICsgMikgPT0gUlNOX0tFWV9EQVRBX1BNS0lEKSB7CkBAIC03MDgsNiArODE1LDI1IEBACiAJfQogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAKKyNpZmRlZiBDT05GSUdfUDJQCisJaWYgKHBvc1sxXSA+PSBSU05fU0VMRUNUT1JfTEVOICsgMSAmJgorCSAgICBSU05fU0VMRUNUT1JfR0VUKHBvcyArIDIpID09IFdGQV9LRVlfREFUQV9JUF9BRERSX1JFUSkgeworCQlpZS0+aXBfYWRkcl9yZXEgPSBwb3MgKyAyICsgUlNOX1NFTEVDVE9SX0xFTjsKKwkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BBOiBJUCBBZGRyZXNzIFJlcXVlc3QgaW4gRUFQT0wtS2V5IiwKKwkJCSAgICBpZS0+aXBfYWRkcl9yZXEsIHBvc1sxXSAtIFJTTl9TRUxFQ1RPUl9MRU4pOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAocG9zWzFdID49IFJTTl9TRUxFQ1RPUl9MRU4gKyAzICogNCAmJgorCSAgICBSU05fU0VMRUNUT1JfR0VUKHBvcyArIDIpID09IFdGQV9LRVlfREFUQV9JUF9BRERSX0FMTE9DKSB7CisJCWllLT5pcF9hZGRyX2FsbG9jID0gcG9zICsgMiArIFJTTl9TRUxFQ1RPUl9MRU47CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywKKwkJCSAgICAiV1BBOiBJUCBBZGRyZXNzIEFsbG9jYXRpb24gaW4gRUFQT0wtS2V5IiwKKwkJCSAgICBpZS0+aXBfYWRkcl9hbGxvYywgcG9zWzFdIC0gUlNOX1NFTEVDVE9SX0xFTik7CisJCXJldHVybiAwOworCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2FwL3dwYV9hdXRoX2llLmggYi9zcmMvYXAvd3BhX2F1dGhfaWUuaAppbmRleCA0OTk5MTM5Li5kMjA2N2JhIDEwMDY0NAotLS0gYS9zcmMvYXAvd3BhX2F1dGhfaWUuaAorKysgYi9zcmMvYXAvd3BhX2F1dGhfaWUuaApAQCAtMzksNiArMzksMTMgQEAKIAljb25zdCB1OCAqZnRpZTsKIAlzaXplX3QgZnRpZV9sZW47CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KKyNpZmRlZiBDT05GSUdfUDJQCisJY29uc3QgdTggKmlwX2FkZHJfcmVxOworCWNvbnN0IHU4ICppcF9hZGRyX2FsbG9jOworI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCWNvbnN0IHU4ICpvc2VuOworCXNpemVfdCBvc2VuX2xlbjsKIH07CiAKIGludCB3cGFfcGFyc2Vfa2RlX2llcyhjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuLApkaWZmIC0tZ2l0IGEvc3JjL2FwL3dwc19ob3N0YXBkLmMgYi9zcmMvYXAvd3BzX2hvc3RhcGQuYwppbmRleCBlYjMwMGYxLi42ZjE2ZjUwIDEwMDY0NAotLS0gYS9zcmMvYXAvd3BzX2hvc3RhcGQuYworKysgYi9zcmMvYXAvd3BzX2hvc3RhcGQuYwpAQCAtNDAsNiArNDAsNyBAQAogCQkJCSAgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCiAJCQkJICAgIGludCBzc2lfc2lnbmFsKTsKIHN0YXRpYyB2b2lkIGhvc3RhcGRfd3BzX2FwX3Bpbl90aW1lb3V0KHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfY3R4KTsKK3N0YXRpYyB2b2lkIGhvc3RhcGRfd3BzX25mY19jbGVhcihzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcyk7CiAKIAogc3RydWN0IHdwc19mb3JfZWFjaF9kYXRhIHsKQEAgLTI4Nyw2ICsyODgsMjAgQEAKIH0KIAogCit2b2lkIGhvc3RhcGRfd3BzX2VhcF9jb21wbGV0ZWQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKKwkvKgorCSAqIFJlZHVjZSByYWNlIGNvbmRpdGlvbiBvZiB0aGUgc3RhdGlvbiB0cnlpbmcgdG8gcmVjb25uZWN0IGltbWVkaWF0ZWx5CisJICogYWZ0ZXIgQVAgcmVjb25maWd1cmF0aW9uIHRocm91Z2ggV1BTIGJ5IHJlc2NoZWR1bGluZyB0aGUgcmVsb2FkCisJICogdGltZW91dCB0byBoYXBwZW4gYWZ0ZXIgRUFQIGNvbXBsZXRpb24gcmF0aGVyIHRoYW4gdGhlIG9yaWdpbmFsbHkKKwkgKiBzY2hlZHVsZWQgMTAwIG1zIGFmdGVyIG5ldyBjb25maWd1cmF0aW9uIGJlY2FtZSBrbm93bi4KKwkgKi8KKwlpZiAoZWxvb3BfZGVwbGV0ZV90aW1lb3V0KDAsIDAsIHdwc19yZWxvYWRfY29uZmlnLCBoYXBkLT5pZmFjZSwgTlVMTCkgPT0KKwkgICAgMSkKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFJlc2NoZWR1bGUgaW1tZWRpYXRlIGNvbmZpZ3VyYXRpb24gcmVsb2FkIik7Cit9CisKKwogc3RhdGljIHZvaWQgaGFwZF9uZXdfYXBfZXZlbnQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmF0dHIsCiAJCQkgICAgICBzaXplX3QgYXR0cl9sZW4pCiB7CkBAIC0zNjMsNDAgKzM3OCwxMSBAQAogCQl9CiAJCWJzcy0+YXV0aF9hbGdzID0gMTsKIAl9IGVsc2UgewotCQlpZiAoKGNyZWQtPmF1dGhfdHlwZSAmIFdQU19BVVRIX09QRU4pICYmCi0JCSAgICAoY3JlZC0+YXV0aF90eXBlICYgV1BTX0FVVEhfU0hBUkVEKSkKLQkJCWJzcy0+YXV0aF9hbGdzID0gMzsKLQkJZWxzZSBpZiAoY3JlZC0+YXV0aF90eXBlICYgV1BTX0FVVEhfU0hBUkVEKQotCQkJYnNzLT5hdXRoX2FsZ3MgPSAyOwotCQllbHNlCi0JCQlic3MtPmF1dGhfYWxncyA9IDE7Ci0JCWlmIChjcmVkLT5lbmNyX3R5cGUgJiBXUFNfRU5DUl9XRVAgJiYgY3JlZC0+a2V5X2lkeCA+IDAgJiYKLQkJICAgIGNyZWQtPmtleV9pZHggPD0gNCkgewotCQkJc3RydWN0IGhvc3RhcGRfd2VwX2tleXMgKndlcCA9ICZic3MtPnNzaWQud2VwOwotCQkJaW50IGlkeCA9IGNyZWQtPmtleV9pZHg7Ci0JCQlpZiAoaWR4KQotCQkJCWlkeC0tOwotCQkJd2VwLT5pZHggPSBpZHg7Ci0JCQlpZiAoY3JlZC0+a2V5X2xlbiA9PSAxMCB8fCBjcmVkLT5rZXlfbGVuID09IDI2KSB7Ci0JCQkJb3NfZnJlZSh3ZXAtPmtleVtpZHhdKTsKLQkJCQl3ZXAtPmtleVtpZHhdID0gb3NfbWFsbG9jKGNyZWQtPmtleV9sZW4gLyAyKTsKLQkJCQlpZiAod2VwLT5rZXlbaWR4XSA9PSBOVUxMIHx8Ci0JCQkJICAgIGhleHN0cjJiaW4oKGNvbnN0IGNoYXIgKikgY3JlZC0+a2V5LAotCQkJCQkgICAgICAgd2VwLT5rZXlbaWR4XSwKLQkJCQkJICAgICAgIGNyZWQtPmtleV9sZW4gLyAyKSkKLQkJCQkJcmV0dXJuIC0xOwotCQkJCXdlcC0+bGVuW2lkeF0gPSBjcmVkLT5rZXlfbGVuIC8gMjsKLQkJCX0gZWxzZSB7Ci0JCQkJb3NfZnJlZSh3ZXAtPmtleVtpZHhdKTsKLQkJCQl3ZXAtPmtleVtpZHhdID0gb3NfbWFsbG9jKGNyZWQtPmtleV9sZW4pOwotCQkJCWlmICh3ZXAtPmtleVtpZHhdID09IE5VTEwpCi0JCQkJCXJldHVybiAtMTsKLQkJCQlvc19tZW1jcHkod2VwLT5rZXlbaWR4XSwgY3JlZC0+a2V5LAotCQkJCQkgIGNyZWQtPmtleV9sZW4pOwotCQkJCXdlcC0+bGVuW2lkeF0gPSBjcmVkLT5rZXlfbGVuOwotCQkJfQotCQkJd2VwLT5rZXlzX3NldCA9IDE7Ci0JCX0KKwkJLyoKKwkJICogV1BTIDIuMCBkb2VzIG5vdCBhbGxvdyBXRVAgdG8gYmUgY29uZmlndXJlZCwgc28gbm8gbmVlZCB0bworCQkgKiBwcm9jZXNzIHRoYXQgb3B0aW9uIGhlcmUgZWl0aGVyLgorCQkgKi8KKwkJYnNzLT5hdXRoX2FsZ3MgPSAxOwogCX0KIAogCS8qIFNjaGVkdWxlIGNvbmZpZ3VyYXRpb24gcmVsb2FkIGFmdGVyIHNob3J0IHBlcmlvZCBvZiB0aW1lIHRvIGFsbG93CkBAIC00NTcsNiArNDQzLDggQEAKIAloYXBkLT53cHMtPnNzaWRfbGVuID0gY3JlZC0+c3NpZF9sZW47CiAJaGFwZC0+d3BzLT5lbmNyX3R5cGVzID0gY3JlZC0+ZW5jcl90eXBlOwogCWhhcGQtPndwcy0+YXV0aF90eXBlcyA9IGNyZWQtPmF1dGhfdHlwZTsKKwloYXBkLT53cHMtPmFwX2VuY3JfdHlwZSA9IGNyZWQtPmVuY3JfdHlwZTsKKwloYXBkLT53cHMtPmFwX2F1dGhfdHlwZSA9IGNyZWQtPmF1dGhfdHlwZTsKIAlpZiAoY3JlZC0+a2V5X2xlbiA9PSAwKSB7CiAJCW9zX2ZyZWUoaGFwZC0+d3BzLT5uZXR3b3JrX2tleSk7CiAJCWhhcGQtPndwcy0+bmV0d29ya19rZXkgPSBOVUxMOwpAQCAtNTY5LDMxICs1NTcsMTEgQEAKIAogCQlmcHJpbnRmKG5jb25mLCAiYXV0aF9hbGdzPTFcbiIpOwogCX0gZWxzZSB7Ci0JCWlmICgoY3JlZC0+YXV0aF90eXBlICYgV1BTX0FVVEhfT1BFTikgJiYKLQkJICAgIChjcmVkLT5hdXRoX3R5cGUgJiBXUFNfQVVUSF9TSEFSRUQpKQotCQkJZnByaW50ZihuY29uZiwgImF1dGhfYWxncz0zXG4iKTsKLQkJZWxzZSBpZiAoY3JlZC0+YXV0aF90eXBlICYgV1BTX0FVVEhfU0hBUkVEKQotCQkJZnByaW50ZihuY29uZiwgImF1dGhfYWxncz0yXG4iKTsKLQkJZWxzZQotCQkJZnByaW50ZihuY29uZiwgImF1dGhfYWxncz0xXG4iKTsKLQotCQlpZiAoY3JlZC0+ZW5jcl90eXBlICYgV1BTX0VOQ1JfV0VQICYmIGNyZWQtPmtleV9pZHggPD0gNCkgewotCQkJaW50IGtleV9pZHggPSBjcmVkLT5rZXlfaWR4OwotCQkJaWYgKGtleV9pZHgpCi0JCQkJa2V5X2lkeC0tOwotCQkJZnByaW50ZihuY29uZiwgIndlcF9kZWZhdWx0X2tleT0lZFxuIiwga2V5X2lkeCk7Ci0JCQlmcHJpbnRmKG5jb25mLCAid2VwX2tleSVkPSIsIGtleV9pZHgpOwotCQkJaWYgKGNyZWQtPmtleV9sZW4gPT0gMTAgfHwgY3JlZC0+a2V5X2xlbiA9PSAyNikgewotCQkJCS8qIFdFUCBrZXkgYXMgYSBoZXggc3RyaW5nICovCi0JCQkJZm9yIChpID0gMDsgaSA8IGNyZWQtPmtleV9sZW47IGkrKykKLQkJCQkJZnB1dGMoY3JlZC0+a2V5W2ldLCBuY29uZik7Ci0JCQl9IGVsc2UgewotCQkJCS8qIFJhdyBXRVAga2V5OyBjb252ZXJ0IHRvIGhleCAqLwotCQkJCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5rZXlfbGVuOyBpKyspCi0JCQkJCWZwcmludGYobmNvbmYsICIlMDJ4IiwgY3JlZC0+a2V5W2ldKTsKLQkJCX0KLQkJCWZwcmludGYobmNvbmYsICJcbiIpOwotCQl9CisJCS8qCisJCSAqIFdQUyAyLjAgZG9lcyBub3QgYWxsb3cgV0VQIHRvIGJlIGNvbmZpZ3VyZWQsIHNvIG5vIG5lZWQgdG8KKwkJICogcHJvY2VzcyB0aGF0IG9wdGlvbiBoZXJlIGVpdGhlci4KKwkJICovCisJCWZwcmludGYobmNvbmYsICJhdXRoX2FsZ3M9MVxuIik7CiAJfQogCiAJZnByaW50ZihuY29uZiwgIiMgV1BTIGNvbmZpZ3VyYXRpb24gLSBFTkRcbiIpOwpAQCAtODgxLDcgKzg0OSw3IEBACiB9CiAKIAotc3RhdGljIHZvaWQgaG9zdGFwZF93cHNfY2xlYXJfaWVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpCitzdGF0aWMgdm9pZCBob3N0YXBkX3dwc19jbGVhcl9pZXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgaW50IGRlaW5pdF9vbmx5KQogewogCXdwYWJ1Zl9mcmVlKGhhcGQtPndwc19iZWFjb25faWUpOwogCWhhcGQtPndwc19iZWFjb25faWUgPSBOVUxMOwpAQCAtODg5LDYgKzg1Nyw5IEBACiAJd3BhYnVmX2ZyZWUoaGFwZC0+d3BzX3Byb2JlX3Jlc3BfaWUpOwogCWhhcGQtPndwc19wcm9iZV9yZXNwX2llID0gTlVMTDsKIAorCWlmIChkZWluaXRfb25seSkKKwkJcmV0dXJuOworCiAJaG9zdGFwZF9zZXRfYXBfd3BzX2llKGhhcGQpOwogfQogCkBAIC05NzEsNiArOTQyLDIxIEBACiB9CiAKIAorc3RhdGljIHZvaWQgaG9zdGFwZF9mcmVlX3dwcyhzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcykKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBNQVhfV1BTX1ZFTkRPUl9FWFRFTlNJT05TOyBpKyspCisJCXdwYWJ1Zl9mcmVlKHdwcy0+ZGV2LnZlbmRvcl9leHRbaV0pOworCXdwc19kZXZpY2VfZGF0YV9mcmVlKCZ3cHMtPmRldik7CisJb3NfZnJlZSh3cHMtPm5ldHdvcmtfa2V5KTsKKwlob3N0YXBkX3dwc19uZmNfY2xlYXIod3BzKTsKKwl3cGFidWZfZnJlZSh3cHMtPmRoX3B1YmtleSk7CisJd3BhYnVmX2ZyZWUod3BzLT5kaF9wcml2a2V5KTsKKwlvc19mcmVlKHdwcyk7Cit9CisKKwogaW50IGhvc3RhcGRfaW5pdF93cHMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKIAkJICAgICBzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpjb25mKQogewpAQCAtOTc4LDcgKzk2NCw3IEBACiAJc3RydWN0IHdwc19yZWdpc3RyYXJfY29uZmlnIGNmZzsKIAogCWlmIChjb25mLT53cHNfc3RhdGUgPT0gMCkgewotCQlob3N0YXBkX3dwc19jbGVhcl9pZXMoaGFwZCk7CisJCWhvc3RhcGRfd3BzX2NsZWFyX2llcyhoYXBkLCAwKTsKIAkJcmV0dXJuIDA7CiAJfQogCkBAIC0xMDI3LDcgKzEwMTMsNiBAQAogCQlvc19zdHJkdXAoaGFwZC0+Y29uZi0+c2VyaWFsX251bWJlcikgOiBOVUxMOwogCXdwcy0+Y29uZmlnX21ldGhvZHMgPQogCQl3cHNfY29uZmlnX21ldGhvZHNfc3RyMmJpbihoYXBkLT5jb25mLT5jb25maWdfbWV0aG9kcyk7Ci0jaWZkZWYgQ09ORklHX1dQUzIKIAlpZiAoKHdwcy0+Y29uZmlnX21ldGhvZHMgJgogCSAgICAgKFdQU19DT05GSUdfRElTUExBWSB8IFdQU19DT05GSUdfVklSVF9ESVNQTEFZIHwKIAkgICAgICBXUFNfQ09ORklHX1BIWV9ESVNQTEFZKSkgPT0gV1BTX0NPTkZJR19ESVNQTEFZKSB7CkBAIC0xMDQyLDE0ICsxMDI3LDExIEBACiAJCQkgICAidmlydHVhbF9wdXNoX2J1dHRvbiBmb3IgV1BTIDIuMCBjb21wbGlhbmNlIik7CiAJCXdwcy0+Y29uZmlnX21ldGhvZHMgfD0gV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT047CiAJfQotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAJb3NfbWVtY3B5KHdwcy0+ZGV2LnByaV9kZXZfdHlwZSwgaGFwZC0+Y29uZi0+ZGV2aWNlX3R5cGUsCiAJCSAgV1BTX0RFVl9UWVBFX0xFTik7CiAKLQlpZiAoaG9zdGFwZF93cHNfc2V0X3ZlbmRvcl9leHQoaGFwZCwgd3BzKSA8IDApIHsKLQkJb3NfZnJlZSh3cHMpOwotCQlyZXR1cm4gLTE7Ci0JfQorCWlmIChob3N0YXBkX3dwc19zZXRfdmVuZG9yX2V4dChoYXBkLCB3cHMpIDwgMCkKKwkJZ290byBmYWlsOwogCiAJd3BzLT5kZXYub3NfdmVyc2lvbiA9IFdQQV9HRVRfQkUzMihoYXBkLT5jb25mLT5vc192ZXJzaW9uKTsKIApAQCAtMTA4OCwxOCArMTA3MCw2IEBACiAJaWYgKGNvbmYtPnNzaWQuc2VjdXJpdHlfcG9saWN5ID09IFNFQ1VSSVRZX1BMQUlOVEVYVCkgewogCQl3cHMtPmVuY3JfdHlwZXMgfD0gV1BTX0VOQ1JfTk9ORTsKIAkJd3BzLT5hdXRoX3R5cGVzIHw9IFdQU19BVVRIX09QRU47Ci0JfSBlbHNlIGlmIChjb25mLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9PSBTRUNVUklUWV9TVEFUSUNfV0VQKSB7Ci0JCXdwcy0+ZW5jcl90eXBlcyB8PSBXUFNfRU5DUl9XRVA7Ci0JCWlmIChjb25mLT5hdXRoX2FsZ3MgJiBXUEFfQVVUSF9BTEdfT1BFTikKLQkJCXdwcy0+YXV0aF90eXBlcyB8PSBXUFNfQVVUSF9PUEVOOwotCQlpZiAoY29uZi0+YXV0aF9hbGdzICYgV1BBX0FVVEhfQUxHX1NIQVJFRCkKLQkJCXdwcy0+YXV0aF90eXBlcyB8PSBXUFNfQVVUSF9TSEFSRUQ7Ci0JfSBlbHNlIGlmIChjb25mLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9PSBTRUNVUklUWV9JRUVFXzgwMl8xWCkgewotCQl3cHMtPmF1dGhfdHlwZXMgfD0gV1BTX0FVVEhfT1BFTjsKLQkJaWYgKGNvbmYtPmRlZmF1bHRfd2VwX2tleV9sZW4pCi0JCQl3cHMtPmVuY3JfdHlwZXMgfD0gV1BTX0VOQ1JfV0VQOwotCQllbHNlCi0JCQl3cHMtPmVuY3JfdHlwZXMgfD0gV1BTX0VOQ1JfTk9ORTsKIAl9CiAKIAlpZiAoY29uZi0+c3NpZC53cGFfcHNrX2ZpbGUpIHsKQEAgLTExMDksMTkgKzEwNzksMTUgQEAKIAkJd3BzLT5uZXR3b3JrX2tleV9sZW4gPSBvc19zdHJsZW4oY29uZi0+c3NpZC53cGFfcGFzc3BocmFzZSk7CiAJfSBlbHNlIGlmIChjb25mLT5zc2lkLndwYV9wc2spIHsKIAkJd3BzLT5uZXR3b3JrX2tleSA9IG9zX21hbGxvYygyICogUE1LX0xFTiArIDEpOwotCQlpZiAod3BzLT5uZXR3b3JrX2tleSA9PSBOVUxMKSB7Ci0JCQlvc19mcmVlKHdwcyk7Ci0JCQlyZXR1cm4gLTE7Ci0JCX0KKwkJaWYgKHdwcy0+bmV0d29ya19rZXkgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbDsKIAkJd3BhX3NucHJpbnRmX2hleCgoY2hhciAqKSB3cHMtPm5ldHdvcmtfa2V5LCAyICogUE1LX0xFTiArIDEsCiAJCQkJIGNvbmYtPnNzaWQud3BhX3Bzay0+cHNrLCBQTUtfTEVOKTsKIAkJd3BzLT5uZXR3b3JrX2tleV9sZW4gPSAyICogUE1LX0xFTjsKIAl9IGVsc2UgaWYgKGNvbmYtPnNzaWQud2VwLmtleXNfc2V0ICYmIGNvbmYtPnNzaWQud2VwLmtleVswXSkgewogCQl3cHMtPm5ldHdvcmtfa2V5ID0gb3NfbWFsbG9jKGNvbmYtPnNzaWQud2VwLmxlblswXSk7Ci0JCWlmICh3cHMtPm5ldHdvcmtfa2V5ID09IE5VTEwpIHsKLQkJCW9zX2ZyZWUod3BzKTsKLQkJCXJldHVybiAtMTsKLQkJfQorCQlpZiAod3BzLT5uZXR3b3JrX2tleSA9PSBOVUxMKQorCQkJZ290byBmYWlsOwogCQlvc19tZW1jcHkod3BzLT5uZXR3b3JrX2tleSwgY29uZi0+c3NpZC53ZXAua2V5WzBdLAogCQkJICBjb25mLT5zc2lkLndlcC5sZW5bMF0pOwogCQl3cHMtPm5ldHdvcmtfa2V5X2xlbiA9IGNvbmYtPnNzaWQud2VwLmxlblswXTsKQEAgLTExMzIsNiArMTA5OCw4IEBACiAJCXdwcy0+cHNrX3NldCA9IDE7CiAJfQogCisJd3BzLT5hcF9hdXRoX3R5cGUgPSB3cHMtPmF1dGhfdHlwZXM7CisJd3BzLT5hcF9lbmNyX3R5cGUgPSB3cHMtPmVuY3JfdHlwZXM7CiAJaWYgKGNvbmYtPndwc19zdGF0ZSA9PSBXUFNfU1RBVEVfTk9UX0NPTkZJR1VSRUQpIHsKIAkJLyogT3ZlcnJpZGUgcGFyYW1ldGVycyB0byBlbmFibGUgc2VjdXJpdHkgYnkgZGVmYXVsdCAqLwogCQl3cHMtPmF1dGhfdHlwZXMgPSBXUFNfQVVUSF9XUEEyUFNLIHwgV1BTX0FVVEhfV1BBUFNLOwpAQCAtMTE2NSw5ICsxMTMzLDcgQEAKIAl3cHMtPnJlZ2lzdHJhciA9IHdwc19yZWdpc3RyYXJfaW5pdCh3cHMsICZjZmcpOwogCWlmICh3cHMtPnJlZ2lzdHJhciA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiRmFpbGVkIHRvIGluaXRpYWxpemUgV1BTIFJlZ2lzdHJhciIpOwotCQlvc19mcmVlKHdwcy0+bmV0d29ya19rZXkpOwotCQlvc19mcmVlKHdwcyk7Ci0JCXJldHVybiAtMTsKKwkJZ290byBmYWlsOwogCX0KIAogI2lmZGVmIENPTkZJR19XUFNfVVBOUApAQCAtMTE4Myw2ICsxMTQ5LDEwIEBACiAJaGFwZC0+d3BzID0gd3BzOwogCiAJcmV0dXJuIDA7CisKK2ZhaWw6CisJaG9zdGFwZF9mcmVlX3dwcyh3cHMpOworCXJldHVybiAtMTsKIH0KIAogCkBAIC0xMTk3LDggKzExNjcsNyBAQAogCWlmIChob3N0YXBkX3dwc191cG5wX2luaXQoaGFwZCwgd3BzKSA8IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSBXUFMgVVBuUCIpOwogCQl3cHNfcmVnaXN0cmFyX2RlaW5pdCh3cHMtPnJlZ2lzdHJhcik7Ci0JCW9zX2ZyZWUod3BzLT5uZXR3b3JrX2tleSk7Ci0JCW9zX2ZyZWUod3BzKTsKKwkJaG9zdGFwZF9mcmVlX3dwcyh3cHMpOwogCQloYXBkLT53cHMgPSBOVUxMOwogCQlyZXR1cm4gLTE7CiAJfQpAQCAtMTIxMSw2ICsxMTgwLDcgQEAKIHN0YXRpYyB2b2lkIGhvc3RhcGRfd3BzX25mY19jbGVhcihzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcykKIHsKICNpZmRlZiBDT05GSUdfV1BTX05GQworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBDbGVhciBORkMgVGFnIGNvbnRleHQgJXAiLCB3cHMpOwogCXdwcy0+YXBfbmZjX2Rldl9wd19pZCA9IDA7CiAJd3BhYnVmX2ZyZWUod3BzLT5hcF9uZmNfZGhfcHVia2V5KTsKIAl3cHMtPmFwX25mY19kaF9wdWJrZXkgPSBOVUxMOwpAQCAtMTIyNiwyMSArMTE5NiwxOSBAQAogewogCWVsb29wX2NhbmNlbF90aW1lb3V0KGhvc3RhcGRfd3BzX3JlZW5hYmxlX2FwX3BpbiwgaGFwZCwgTlVMTCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaG9zdGFwZF93cHNfYXBfcGluX3RpbWVvdXQsIGhhcGQsIE5VTEwpOwotCWlmIChoYXBkLT53cHMgPT0gTlVMTCkKKwllbG9vcF9jYW5jZWxfdGltZW91dCh3cHNfcmVsb2FkX2NvbmZpZywgaGFwZC0+aWZhY2UsIE5VTEwpOworCWlmIChoYXBkLT53cHMgPT0gTlVMTCkgeworCQlob3N0YXBkX3dwc19jbGVhcl9pZXMoaGFwZCwgMSk7CiAJCXJldHVybjsKKwl9CiAjaWZkZWYgQ09ORklHX1dQU19VUE5QCiAJaG9zdGFwZF93cHNfdXBucF9kZWluaXQoaGFwZCk7CiAjZW5kaWYgLyogQ09ORklHX1dQU19VUE5QICovCiAJd3BzX3JlZ2lzdHJhcl9kZWluaXQoaGFwZC0+d3BzLT5yZWdpc3RyYXIpOwotCW9zX2ZyZWUoaGFwZC0+d3BzLT5uZXR3b3JrX2tleSk7Ci0Jd3BzX2RldmljZV9kYXRhX2ZyZWUoJmhhcGQtPndwcy0+ZGV2KTsKLQl3cGFidWZfZnJlZShoYXBkLT53cHMtPmRoX3B1YmtleSk7Ci0Jd3BhYnVmX2ZyZWUoaGFwZC0+d3BzLT5kaF9wcml2a2V5KTsKIAl3cHNfZnJlZV9wZW5kaW5nX21zZ3MoaGFwZC0+d3BzLT51cG5wX21zZ3MpOwotCWhvc3RhcGRfd3BzX25mY19jbGVhcihoYXBkLT53cHMpOwotCW9zX2ZyZWUoaGFwZC0+d3BzKTsKKwlob3N0YXBkX2ZyZWVfd3BzKGhhcGQtPndwcyk7CiAJaGFwZC0+d3BzID0gTlVMTDsKLQlob3N0YXBkX3dwc19jbGVhcl9pZXMoaGFwZCk7CisJaG9zdGFwZF93cHNfY2xlYXJfaWVzKGhhcGQsIDEpOwogfQogCiAKQEAgLTEzMjIsNyArMTI5MCw3IEBACiB7CiAJY29uc3QgdTggKnAycF9kZXZfYWRkciA9IGN0eDsKIAlpZiAoaGFwZC0+d3BzID09IE5VTEwpCi0JCXJldHVybiAwOworCQlyZXR1cm4gLTE7CiAJcmV0dXJuIHdwc19yZWdpc3RyYXJfYnV0dG9uX3B1c2hlZChoYXBkLT53cHMtPnJlZ2lzdHJhciwgcDJwX2Rldl9hZGRyKTsKIH0KIApAQCAtMTMzOCw3ICsxMzA2LDcgQEAKIHN0YXRpYyBpbnQgd3BzX2NhbmNlbChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB2b2lkICpjdHgpCiB7CiAJaWYgKGhhcGQtPndwcyA9PSBOVUxMKQotCQlyZXR1cm4gMDsKKwkJcmV0dXJuIC0xOwogCiAJd3BzX3JlZ2lzdHJhcl93cHNfY2FuY2VsKGhhcGQtPndwcy0+cmVnaXN0cmFyKTsKIAlhcF9mb3JfZWFjaF9zdGEoaGFwZCwgYXBfc3RhX3dwc19jYW5jZWwsIE5VTEwpOwpAQCAtMTQ1OSw2ICsxNDI3LDE2IEBACiAJCXJldHVybiAwOwogCX0KIAorCWlmICghc3RhLT5lYXBvbF9zbSkgeworCQkvKgorCQkgKiBUaGlzIGNhbiBoYXBwZW4sIGUuZy4sIGlmIGFuIEVSIHNlbmRzIGFuIGV4dHJhIG1lc3NhZ2UgYWZ0ZXIKKwkJICogdGhlIHN0YXRpb24gaGFzIGRpc2Fzc29jaWF0ZWQgKGJ1dCBub3QgZnVsbHkKKwkJICogZGVhdXRoZW50aWNhdGVkKS4KKwkJICovCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTIFVQblA6IE1hdGNoaW5nIFNUQSBkaWQgbm90IGhhdmUgRUFQT0wgc3RhdGUgbWFjaGluZSBpbml0aWFsaXplZCIpOworCQlyZXR1cm4gMDsKKwl9CisKIAlwID0gb3NfemFsbG9jKHNpemVvZigqcCkpOwogCWlmIChwID09IE5VTEwpCiAJCXJldHVybiAtMTsKQEAgLTE2NTIsOCArMTYzMCw2IEBACiAJaWYgKGVuY3IpIHsKIAkJaWYgKG9zX3N0cm5jbXAoZW5jciwgIk5PTkUiLCA0KSA9PSAwKQogCQkJY3JlZC5lbmNyX3R5cGUgPSBXUFNfRU5DUl9OT05FOwotCQllbHNlIGlmIChvc19zdHJuY21wKGVuY3IsICJXRVAiLCAzKSA9PSAwKQotCQkJY3JlZC5lbmNyX3R5cGUgPSBXUFNfRU5DUl9XRVA7CiAJCWVsc2UgaWYgKG9zX3N0cm5jbXAoZW5jciwgIlRLSVAiLCA0KSA9PSAwKQogCQkJY3JlZC5lbmNyX3R5cGUgPSBXUFNfRU5DUl9US0lQOwogCQllbHNlIGlmIChvc19zdHJuY21wKGVuY3IsICJDQ01QIiwgNCkgPT0gMCkKQEAgLTE3NjgsNyArMTc0NCw4IEBACiAJaWYgKGhhcGQtPndwcyA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAotCXJldCA9IHdwc19nZXRfb29iX2NyZWQoaGFwZC0+d3BzKTsKKwlyZXQgPSB3cHNfZ2V0X29vYl9jcmVkKGhhcGQtPndwcywgaG9zdGFwZF93cHNfcmZfYmFuZF9jYihoYXBkKSwKKwkJCSAgICAgICBoYXBkLT5pY29uZi0+Y2hhbm5lbCk7CiAJaWYgKG5kZWYgJiYgcmV0KSB7CiAJCXN0cnVjdCB3cGFidWYgKnRtcDsKIAkJdG1wID0gbmRlZl9idWlsZF93aWZpKHJldCk7CkBAIC0xNzg0LDExICsxNzYxLDEzNiBAQAogCiBzdHJ1Y3Qgd3BhYnVmICogaG9zdGFwZF93cHNfbmZjX2hzX2NyKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGludCBuZGVmKQogeworCXN0cnVjdCB3cGFidWYgKnJldDsKKworCWlmIChoYXBkLT53cHMgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAoaGFwZC0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkgPT0gTlVMTCkgeworCQlzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcyA9IGhhcGQtPndwczsKKwkJaWYgKHdwc19uZmNfZ2VuX2RoKCZoYXBkLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSwKKwkJCQkgICAmaGFwZC0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5KSA8IDApCisJCQlyZXR1cm4gTlVMTDsKKwkJaG9zdGFwZF93cHNfbmZjX2NsZWFyKHdwcyk7CisJCXdwcy0+YXBfbmZjX2Rldl9wd19pZCA9IERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUjsKKwkJd3BzLT5hcF9uZmNfZGhfcHVia2V5ID0KKwkJCXdwYWJ1Zl9kdXAoaGFwZC0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkpOworCQl3cHMtPmFwX25mY19kaF9wcml2a2V5ID0KKwkJCXdwYWJ1Zl9kdXAoaGFwZC0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5KTsKKwkJaWYgKCF3cHMtPmFwX25mY19kaF9wdWJrZXkgfHwgIXdwcy0+YXBfbmZjX2RoX3ByaXZrZXkpIHsKKwkJCWhvc3RhcGRfd3BzX25mY19jbGVhcih3cHMpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwl9CisKKwlyZXQgPSB3cHNfYnVpbGRfbmZjX2hhbmRvdmVyX3NlbChoYXBkLT53cHMsCisJCQkJCSBoYXBkLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSwKKwkJCQkJIGhhcGQtPm93bl9hZGRyLCBoYXBkLT5pZmFjZS0+ZnJlcSk7CisKKwlpZiAobmRlZiAmJiByZXQpIHsKKwkJc3RydWN0IHdwYWJ1ZiAqdG1wOworCQl0bXAgPSBuZGVmX2J1aWxkX3dpZmkocmV0KTsKKwkJd3BhYnVmX2ZyZWUocmV0KTsKKwkJaWYgKHRtcCA9PSBOVUxMKQorCQkJcmV0dXJuIE5VTEw7CisJCXJldCA9IHRtcDsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisKK2ludCBob3N0YXBkX3dwc19uZmNfcmVwb3J0X2hhbmRvdmVyKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnJlcSwKKwkJCQkgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqc2VsKQoreworCXN0cnVjdCB3cGFidWYgKndwczsKKwlpbnQgcmV0ID0gLTE7CisJdTE2IHdzY19sZW47CisJY29uc3QgdTggKnBvczsKKwlzdHJ1Y3Qgd3BhYnVmIG1zZzsKKwlzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgYXR0cjsKKwl1MTYgZGV2X3B3X2lkOworCiAJLyoKLQkgKiBIYW5kb3ZlciBTZWxlY3QgY2FycmllciByZWNvcmQgZm9yIFdQUyB1c2VzIHRoZSBzYW1lIGZvcm1hdCBhcwotCSAqIGNvbmZpZ3VyYXRpb24gdG9rZW4uCisJICogRW5yb2xsZWUvc3RhdGlvbiBpcyBhbHdheXMgaW5pdGlhdG9yIG9mIHRoZSBORkMgY29ubmVjdGlvbiBoYW5kb3ZlciwKKwkgKiBzbyB1c2UgdGhlIHJlcXVlc3QgbWVzc2FnZSBoZXJlIHRvIGZpbmQgRW5yb2xsZWUgcHVibGljIGtleSBoYXNoLgogCSAqLwotCXJldHVybiBob3N0YXBkX3dwc19uZmNfY29uZmlnX3Rva2VuKGhhcGQsIG5kZWYpOworCXdwcyA9IG5kZWZfcGFyc2Vfd2lmaShyZXEpOworCWlmICh3cHMgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBSZWNlaXZlZCBhcHBsaWNhdGlvbi92bmQud2ZhLndzYyAiCisJCSAgICJwYXlsb2FkIGZyb20gTkZDIGNvbm5lY3Rpb24gaGFuZG92ZXIiKTsKKwl3cGFfaGV4ZHVtcF9idWYoTVNHX0RFQlVHLCAiV1BTOiBORkMgcGF5bG9hZCIsIHdwcyk7CisJaWYgKHdwYWJ1Zl9sZW4od3BzKSA8IDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFRvbyBzaG9ydCBXaS1GaSBIYW5kb3ZlciBSZXF1ZXN0ICIKKwkJCSAgICJNZXNzYWdlIik7CisJCWdvdG8gb3V0OworCX0KKwlwb3MgPSB3cGFidWZfaGVhZCh3cHMpOworCXdzY19sZW4gPSBXUEFfR0VUX0JFMTYocG9zKTsKKwlpZiAod3NjX2xlbiA+IHdwYWJ1Zl9sZW4od3BzKSAtIDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEludmFsaWQgV1NDIGF0dHJpYnV0ZSBsZW5ndGggKCV1KSAiCisJCQkgICAiaW4gcnQgV2ktRmkgSGFuZG92ZXIgUmVxdWVzdCBNZXNzYWdlIiwgd3NjX2xlbik7CisJCWdvdG8gb3V0OworCX0KKwlwb3MgKz0gMjsKKworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywKKwkJICAgICJXUFM6IFdTQyBhdHRyaWJ1dGVzIGluIFdpLUZpIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSIsCisJCSAgICBwb3MsIHdzY19sZW4pOworCWlmICh3c2NfbGVuIDwgd3BhYnVmX2xlbih3cHMpIC0gMikgeworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsCisJCQkgICAgIldQUzogSWdub3JlIGV4dHJhIGRhdGEgYWZ0ZXIgV1NDIGF0dHJpYnV0ZXMiLAorCQkJICAgIHBvcyArIHdzY19sZW4sIHdwYWJ1Zl9sZW4od3BzKSAtIDIgLSB3c2NfbGVuKTsKKwl9CisKKwl3cGFidWZfc2V0KCZtc2csIHBvcywgd3NjX2xlbik7CisJcmV0ID0gd3BzX3BhcnNlX21zZygmbXNnLCAmYXR0cik7CisJaWYgKHJldCA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IENvdWxkIG5vdCBwYXJzZSBXU0MgYXR0cmlidXRlcyBpbiAiCisJCQkgICAiV2ktRmkgSGFuZG92ZXIgUmVxdWVzdCBNZXNzYWdlIik7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChhdHRyLm9vYl9kZXZfcGFzc3dvcmQgPT0gTlVMTCB8fAorCSAgICBhdHRyLm9vYl9kZXZfcGFzc3dvcmRfbGVuIDwgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gKyAyKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBPdXQtb2YtQmFuZCBEZXZpY2UgUGFzc3dvcmQgIgorCQkJICAgImluY2x1ZGVkIGluIFdpLUZpIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSIpOworCQlyZXQgPSAtMTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKGF0dHIudXVpZF9lID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IE5vIFVVSUQtRSBpbmNsdWRlZCBpbiBXaS1GaSAiCisJCQkgICAiSGFuZG92ZXIgUmVxdWVzdCBNZXNzYWdlIik7CisJCXJldCA9IC0xOworCQlnb3RvIG91dDsKKwl9CisKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUFM6IFVVSUQtRSIsIGF0dHIudXVpZF9lLCBXUFNfVVVJRF9MRU4pOworCisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBPdXQtb2YtQmFuZCBEZXZpY2UgUGFzc3dvcmQiLAorCQkgICAgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkLCBhdHRyLm9vYl9kZXZfcGFzc3dvcmRfbGVuKTsKKwlkZXZfcHdfaWQgPSBXUEFfR0VUX0JFMTYoYXR0ci5vb2JfZGV2X3Bhc3N3b3JkICsKKwkJCQkgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCWlmIChkZXZfcHdfaWQgIT0gREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVbmV4cGVjdGVkIE9PQiBEZXZpY2UgUGFzc3dvcmQgSUQgIgorCQkJICAgIiV1IGluIFdpLUZpIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSIsIGRldl9wd19pZCk7CisJCXJldCA9IC0xOworCQlnb3RvIG91dDsKKwl9CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBFbnJvbGxlZSBQdWJsaWMgS2V5IGhhc2giLAorCQkgICAgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkLCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTik7CisKKwlyZXQgPSB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcHdfdG9rZW4oaGFwZC0+d3BzLT5yZWdpc3RyYXIsCisJCQkJCSAgICAgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkLAorCQkJCQkgICAgIERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUiwKKwkJCQkJICAgICBOVUxMLCAwLCAxKTsKKworb3V0OgorCXdwYWJ1Zl9mcmVlKHdwcyk7CisJcmV0dXJuIHJldDsKIH0KIAogCkBAIC0xODIzLDYgKzE5MjUsOSBAQAogCQlyZXR1cm4gLTE7CiAKIAlob3N0YXBkX3dwc19uZmNfY2xlYXIod3BzKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIldQUzogRW5hYmxlIE5GQyBUYWcgKERldiBQdyBJZCAldSkgZm9yIEFQIGludGVyZmFjZSAlcyAoY29udGV4dCAlcCkiLAorCQkgICBoYXBkLT5jb25mLT53cHNfbmZjX2Rldl9wd19pZCwgaGFwZC0+Y29uZi0+aWZhY2UsIHdwcyk7CiAJd3BzLT5hcF9uZmNfZGV2X3B3X2lkID0gaGFwZC0+Y29uZi0+d3BzX25mY19kZXZfcHdfaWQ7CiAJd3BzLT5hcF9uZmNfZGhfcHVia2V5ID0gd3BhYnVmX2R1cChoYXBkLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSk7CiAJd3BzLT5hcF9uZmNfZGhfcHJpdmtleSA9IHdwYWJ1Zl9kdXAoaGFwZC0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5KTsKQEAgLTE4NDksNiArMTk1NCw4IEBACiAKIHZvaWQgaG9zdGFwZF93cHNfbmZjX3Rva2VuX2Rpc2FibGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKIHsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogRGlzYWJsZSBORkMgdG9rZW4gZm9yIEFQIGludGVyZmFjZSAlcyIsCisJCSAgIGhhcGQtPmNvbmYtPmlmYWNlKTsKIAlob3N0YXBkX3dwc19uZmNfY2xlYXIoaGFwZC0+d3BzKTsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2FwL3dwc19ob3N0YXBkLmggYi9zcmMvYXAvd3BzX2hvc3RhcGQuaAppbmRleCBhMmMyY2YwLi4yMDRiZDgyIDEwMDY0NAotLS0gYS9zcmMvYXAvd3BzX2hvc3RhcGQuaAorKysgYi9zcmMvYXAvd3BzX2hvc3RhcGQuaApAQCAtMTYsNiArMTYsNyBAQAogaW50IGhvc3RhcGRfaW5pdF93cHNfY29tcGxldGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CiB2b2lkIGhvc3RhcGRfZGVpbml0X3dwcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKTsKIHZvaWQgaG9zdGFwZF91cGRhdGVfd3BzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwordm9pZCBob3N0YXBkX3dwc19lYXBfY29tcGxldGVkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwogaW50IGhvc3RhcGRfd3BzX2FkZF9waW4oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIsCiAJCQljb25zdCBjaGFyICp1dWlkLCBjb25zdCBjaGFyICpwaW4sIGludCB0aW1lb3V0KTsKIGludCBob3N0YXBkX3dwc19idXR0b25fcHVzaGVkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCkBAIC0zNiw2ICszNyw5IEBACiBzdHJ1Y3Qgd3BhYnVmICogaG9zdGFwZF93cHNfbmZjX2NvbmZpZ190b2tlbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCQkgICAgIGludCBuZGVmKTsKIHN0cnVjdCB3cGFidWYgKiBob3N0YXBkX3dwc19uZmNfaHNfY3Ioc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgaW50IG5kZWYpOworaW50IGhvc3RhcGRfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcmVxLAorCQkJCSAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpzZWwpOwogc3RydWN0IHdwYWJ1ZiAqIGhvc3RhcGRfd3BzX25mY190b2tlbl9nZW4oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgaW50IG5kZWYpOwogaW50IGhvc3RhcGRfd3BzX25mY190b2tlbl9lbmFibGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CiB2b2lkIGhvc3RhcGRfd3BzX25mY190b2tlbl9kaXNhYmxlKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwpAQCAtNjEsNiArNjUsMTAgQEAKIHsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIGhvc3RhcGRfd3BzX2VhcF9jb21wbGV0ZWQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKK30KKwogc3RhdGljIGlubGluZSBpbnQgaG9zdGFwZF93cHNfZ2V0X21pYl9zdGEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKIAkJCQkJICBjb25zdCB1OCAqYWRkciwKIAkJCQkJICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL01ha2VmaWxlIGIvc3JjL2NvbW1vbi9NYWtlZmlsZQppbmRleCA5YzQxOTYyLi5hZGZkM2RmIDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL01ha2VmaWxlCisrKyBiL3NyYy9jb21tb24vTWFrZWZpbGUKQEAgLTIsNyArMiw3IEBACiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgogCiBjbGVhbjoKLQlybSAtZiAqfiAqLm8gKi5kCisJcm0gLWYgKn4gKi5vICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgogCiBpbnN0YWxsOgogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vY29tbW9uX21vZHVsZV90ZXN0cy5jIGIvc3JjL2NvbW1vbi9jb21tb25fbW9kdWxlX3Rlc3RzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTZiMTEyMgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9jb21tb24vY29tbW9uX21vZHVsZV90ZXN0cy5jCkBAIC0wLDAgKzEsMTcyIEBACisvKgorICogY29tbW9uIG1vZHVsZSB0ZXN0cworICogQ29weXJpZ2h0IChjKSAyMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKyNpbmNsdWRlICJpZWVlODAyXzExX2NvbW1vbi5oIgorI2luY2x1ZGUgIndwYV9jb21tb24uaCIKKworCitzdHJ1Y3QgaWVlZTgwMl8xMV9wYXJzZV90ZXN0X2RhdGEgeworCXU4ICpkYXRhOworCXNpemVfdCBsZW47CisJUGFyc2VSZXMgcmVzdWx0OworCWludCBjb3VudDsKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaWVlZTgwMl8xMV9wYXJzZV90ZXN0X2RhdGEgcGFyc2VfdGVzdHNbXSA9IHsKKwl7ICh1OCAqKSAiIiwgMCwgUGFyc2VPSywgMCB9LAorCXsgKHU4ICopICIgIiwgMSwgUGFyc2VGYWlsZWQsIDAgfSwKKwl7ICh1OCAqKSAiXHhmZlx4MDAiLCAyLCBQYXJzZVVua25vd24sIDEgfSwKKwl7ICh1OCAqKSAiXHhmZlx4MDEiLCAyLCBQYXJzZUZhaWxlZCwgMCB9LAorCXsgKHU4ICopICJceGRkXHgwM1x4MDFceDAyXHgwMyIsIDUsIFBhcnNlVW5rbm93biwgMSB9LAorCXsgKHU4ICopICJceGRkXHgwNFx4MDFceDAyXHgwM1x4MDQiLCA2LCBQYXJzZVVua25vd24sIDEgfSwKKwl7ICh1OCAqKSAiXHhkZFx4MDRceDAwXHg1MFx4ZjJceDAyIiwgNiwgUGFyc2VVbmtub3duLCAxIH0sCisJeyAodTggKikgIlx4ZGRceDA1XHgwMFx4NTBceGYyXHgwMlx4MDIiLCA3LCBQYXJzZU9LLCAxIH0sCisJeyAodTggKikgIlx4ZGRceDA1XHgwMFx4NTBceGYyXHgwMlx4ZmYiLCA3LCBQYXJzZVVua25vd24sIDEgfSwKKwl7ICh1OCAqKSAiXHhkZFx4MDRceDAwXHg1MFx4ZjJceGZmIiwgNiwgUGFyc2VVbmtub3duLCAxIH0sCisJeyAodTggKikgIlx4ZGRceDA0XHg1MFx4NmZceDlhXHhmZiIsIDYsIFBhcnNlVW5rbm93biwgMSB9LAorCXsgKHU4ICopICJceGRkXHgwNFx4MDBceDkwXHg0Y1x4MzMiLCA2LCBQYXJzZU9LLCAxIH0sCisJeyAodTggKikgIlx4ZGRceDA0XHgwMFx4OTBceDRjXHhmZlx4ZGRceDA0XHgwMFx4OTBceDRjXHgzMyIsIDEyLAorCSAgUGFyc2VVbmtub3duLCAyIH0sCisJeyAodTggKikgIlx4MTBceDAxXHgwMFx4MjFceDAwIiwgNSwgUGFyc2VPSywgMiB9LAorCXsgKHU4ICopICJceDI0XHgwMCIsIDIsIFBhcnNlT0ssIDEgfSwKKwl7ICh1OCAqKSAiXHgzOFx4MDAiLCAyLCBQYXJzZU9LLCAxIH0sCisJeyAodTggKikgIlx4NTRceDAwIiwgMiwgUGFyc2VPSywgMSB9LAorCXsgKHU4ICopICJceDVhXHgwMCIsIDIsIFBhcnNlT0ssIDEgfSwKKwl7ICh1OCAqKSAiXHg2NVx4MDAiLCAyLCBQYXJzZU9LLCAxIH0sCisJeyAodTggKikgIlx4NjVceDEyXHgwMFx4MDFceDAyXHgwM1x4MDRceDA1XHgwNlx4MDdceDA4XHgwOVx4MGFceDBiXHgwY1x4MGRceDBlXHgwZlx4MTBceDExIiwKKwkgIDIwLCBQYXJzZU9LLCAxIH0sCisJeyAodTggKikgIlx4NmVceDAwIiwgMiwgUGFyc2VPSywgMSB9LAorCXsgKHU4ICopICJceGM3XHgwMCIsIDIsIFBhcnNlT0ssIDEgfSwKKwl7ICh1OCAqKSAiXHhjN1x4MDFceDAwIiwgMywgUGFyc2VPSywgMSB9LAorCXsgTlVMTCwgMCwgUGFyc2VPSywgMCB9Cit9OworCitzdGF0aWMgaW50IGllZWU4MDJfMTFfcGFyc2VfdGVzdHModm9pZCkKK3sKKwlpbnQgaSwgcmV0ID0gMDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJpZWVlODAyXzExX3BhcnNlIHRlc3RzIik7CisKKwlmb3IgKGkgPSAwOyBwYXJzZV90ZXN0c1tpXS5kYXRhOyBpKyspIHsKKwkJY29uc3Qgc3RydWN0IGllZWU4MDJfMTFfcGFyc2VfdGVzdF9kYXRhICp0ZXN0OworCQlzdHJ1Y3QgaWVlZTgwMl8xMV9lbGVtcyBlbGVtczsKKwkJUGFyc2VSZXMgcmVzOworCisJCXRlc3QgPSAmcGFyc2VfdGVzdHNbaV07CisJCXJlcyA9IGllZWU4MDJfMTFfcGFyc2VfZWxlbXModGVzdC0+ZGF0YSwgdGVzdC0+bGVuLCAmZWxlbXMsIDEpOworCQlpZiAocmVzICE9IHRlc3QtPnJlc3VsdCB8fAorCQkgICAgaWVlZTgwMl8xMV9pZV9jb3VudCh0ZXN0LT5kYXRhLCB0ZXN0LT5sZW4pICE9IHRlc3QtPmNvdW50KSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImllZWU4MDJfMTFfcGFyc2UgdGVzdCAlZCBmYWlsZWQiLAorCQkJCSAgIGkpOworCQkJcmV0ID0gLTE7CisJCX0KKwl9CisKKwlpZiAoaWVlZTgwMl8xMV92ZW5kb3JfaWVfY29uY2F0KChjb25zdCB1OCAqKSAiXHgwMFx4MDEiLCAyLCAwKSAhPSBOVUxMKQorCXsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiaWVlZTgwMl8xMV92ZW5kb3JfaWVfY29uY2F0IHRlc3QgZmFpbGVkIik7CisJCXJldCA9IC0xOworCX0KKworCXJldHVybiByZXQ7Cit9CisKKworc3RydWN0IHJzbl9pZV9wYXJzZV90ZXN0X2RhdGEgeworCXU4ICpkYXRhOworCXNpemVfdCBsZW47CisJaW50IHJlc3VsdDsKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcnNuX2llX3BhcnNlX3Rlc3RfZGF0YSByc25fcGFyc2VfdGVzdHNbXSA9IHsKKwl7ICh1OCAqKSAiIiwgMCwgLTEgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MDAiLCAyLCAtMSB9LAorCXsgKHU4ICopICJceDMwXHgwMlx4MDFceDAwIiwgNCwgMCB9LAorCXsgKHU4ICopICJceDMwXHgwMlx4MDBceDAwIiwgNCwgLTIgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MDJceDAyXHgwMCIsIDQsIC0yIH0sCisJeyAodTggKikgIlx4MzBceDAyXHgwMFx4MDEiLCA0LCAtMiB9LAorCXsgKHU4ICopICJceDMwXHgwMlx4MDBceDAwXHgwMCIsIDUsIC0yIH0sCisJeyAodTggKikgIlx4MzBceDAzXHgwMVx4MDBceDAwIiwgNSwgLTMgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MDZceDAxXHgwMFx4MDBceDAwXHgwMFx4MDAiLCA4LCAtMSB9LAorCXsgKHU4ICopICJceDMwXHgwNlx4MDFceDAwXHgwMFx4MGZceGFjXHgwNCIsIDgsIDAgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MDdceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAwIiwgOSwgLTUgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MDhceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAwXHgwMCIsIDEwLCAtNCB9LAorCXsgKHU4ICopICJceDMwXHgwOFx4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDBceDAxIiwgMTAsIC00IH0sCisJeyAodTggKikgIlx4MzBceDBjXHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDA0IiwKKwkgIDE0LCAwIH0sCisJeyAodTggKikgIlx4MzBceDBjXHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMFx4MDFceDAwXHgwZlx4YWNceDA0IiwKKwkgIDE0LCAtNCB9LAorCXsgKHU4ICopICJceDMwXHgwY1x4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwNiIsCisJICAxNCwgLTEgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MTBceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAyXHgwMFx4MDBceDBmXHhhY1x4MDRceDAwXHgwZlx4YWNceDA4IiwKKwkgIDE4LCAwIH0sCisJeyAodTggKikgIlx4MzBceDBkXHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMCIsCisJICAxNSwgLTcgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MGVceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAwXHgwMCIsCisJICAxNiwgLTYgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MGVceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAwXHgwMSIsCisJICAxNiwgLTYgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MTJceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAxXHgwMFx4MDBceDBmXHhhY1x4MDEiLAorCSAgMjAsIDAgfSwKKwl7ICh1OCAqKSAiXHgzMFx4MTZceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAxXHgwMFx4MDBceDBmXHhhY1x4MDRceDAyXHgwMFx4MDBceDBmXHhhY1x4MDFceDAwXHgwZlx4YWNceDAyIiwKKwkgIDI0LCAwIH0sCisJeyAodTggKikgIlx4MzBceDEzXHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDAxXHgwMCIsCisJICAyMSwgMCB9LAorCXsgKHU4ICopICJceDMwXHgxNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwMVx4MDBceDAwIiwKKwkgIDIyLCAwIH0sCisJeyAodTggKikgIlx4MzBceDE2XHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDAxXHgwMFx4MDBceDAwXHgwMCIsCisJICAyNCwgMCB9LAorCXsgKHU4ICopICJceDMwXHgxNlx4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwMVx4MDBceDAwXHgwMFx4MDEiLAorCSAgMjQsIC05IH0sCisJeyAodTggKikgIlx4MzBceDFhXHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDAxXHgwMFx4MDBceDAwXHgwMFx4MDBceDAwXHgwMFx4MDAiLAorCSAgMjgsIC0xMCB9LAorCXsgKHU4ICopICJceDMwXHgxYVx4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwNFx4MDFceDAwXHgwMFx4MGZceGFjXHgwMVx4MDBceDAwXHgwMFx4MDBceDAwXHgwZlx4YWNceDA2IiwKKwkgIDI4LCAwIH0sCisJeyAodTggKikgIlx4MzBceDFjXHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDA0XHgwMVx4MDBceDAwXHgwZlx4YWNceDAxXHgwMFx4MDBceDAwXHgwMFx4MDBceDBmXHhhY1x4MDZceDAxXHgwMiIsCisJICAzMCwgMCB9LAorCXsgTlVMTCwgMCwgMCB9Cit9OworCitzdGF0aWMgaW50IHJzbl9pZV9wYXJzZV90ZXN0cyh2b2lkKQoreworCWludCBpLCByZXQgPSAwOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgInJzbl9pZV9wYXJzZSB0ZXN0cyIpOworCisJZm9yIChpID0gMDsgcnNuX3BhcnNlX3Rlc3RzW2ldLmRhdGE7IGkrKykgeworCQljb25zdCBzdHJ1Y3QgcnNuX2llX3BhcnNlX3Rlc3RfZGF0YSAqdGVzdDsKKwkJc3RydWN0IHdwYV9pZV9kYXRhIGRhdGE7CisKKwkJdGVzdCA9ICZyc25fcGFyc2VfdGVzdHNbaV07CisJCWlmICh3cGFfcGFyc2Vfd3BhX2llX3Jzbih0ZXN0LT5kYXRhLCB0ZXN0LT5sZW4sICZkYXRhKSAhPQorCQkgICAgdGVzdC0+cmVzdWx0KSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgInJzbl9pZV9wYXJzZSB0ZXN0ICVkIGZhaWxlZCIsIGkpOworCQkJcmV0ID0gLTE7CisJCX0KKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisKK2ludCBjb21tb25fbW9kdWxlX3Rlc3RzKHZvaWQpCit7CisJaW50IHJldCA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiY29tbW9uIG1vZHVsZSB0ZXN0cyIpOworCisJaWYgKGllZWU4MDJfMTFfcGFyc2VfdGVzdHMoKSA8IDAgfHwKKwkgICAgcnNuX2llX3BhcnNlX3Rlc3RzKCkgPCAwKQorCQlyZXQgPSAtMTsKKworCXJldHVybiByZXQ7Cit9CmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL2RlZnMuaCBiL3NyYy9jb21tb24vZGVmcy5oCmluZGV4IDI4MWRkOGEuLmQ0MDkxZTMgMTAwNjQ0Ci0tLSBhL3NyYy9jb21tb24vZGVmcy5oCisrKyBiL3NyYy9jb21tb24vZGVmcy5oCkBAIC0yMywxMSArMjMsMTUgQEAKICNkZWZpbmUgV1BBX0NJUEhFUl9XRVAxMDQgQklUKDIpCiAjZGVmaW5lIFdQQV9DSVBIRVJfVEtJUCBCSVQoMykKICNkZWZpbmUgV1BBX0NJUEhFUl9DQ01QIEJJVCg0KQotI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAjZGVmaW5lIFdQQV9DSVBIRVJfQUVTXzEyOF9DTUFDIEJJVCg1KQotI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAjZGVmaW5lIFdQQV9DSVBIRVJfR0NNUCBCSVQoNikKICNkZWZpbmUgV1BBX0NJUEhFUl9TTVM0IEJJVCg3KQorI2RlZmluZSBXUEFfQ0lQSEVSX0dDTVBfMjU2IEJJVCg4KQorI2RlZmluZSBXUEFfQ0lQSEVSX0NDTVBfMjU2IEJJVCg5KQorI2RlZmluZSBXUEFfQ0lQSEVSX0JJUF9HTUFDXzEyOCBCSVQoMTEpCisjZGVmaW5lIFdQQV9DSVBIRVJfQklQX0dNQUNfMjU2IEJJVCgxMikKKyNkZWZpbmUgV1BBX0NJUEhFUl9CSVBfQ01BQ18yNTYgQklUKDEzKQorI2RlZmluZSBXUEFfQ0lQSEVSX0dUS19OT1RfVVNFRCBCSVQoMTQpCiAKICNkZWZpbmUgV1BBX0tFWV9NR01UX0lFRUU4MDIxWCBCSVQoMCkKICNkZWZpbmUgV1BBX0tFWV9NR01UX1BTSyBCSVQoMSkKQEAgLTQ0LDEyICs0OCwxNCBAQAogI2RlZmluZSBXUEFfS0VZX01HTVRfV0FQSV9QU0sgQklUKDEyKQogI2RlZmluZSBXUEFfS0VZX01HTVRfV0FQSV9DRVJUIEJJVCgxMykKICNkZWZpbmUgV1BBX0tFWV9NR01UX0NDS00gQklUKDE0KQorI2RlZmluZSBXUEFfS0VZX01HTVRfT1NFTiBCSVQoMTUpCiAKIHN0YXRpYyBpbmxpbmUgaW50IHdwYV9rZXlfbWdtdF93cGFfaWVlZTgwMjF4KGludCBha20pCiB7CiAJcmV0dXJuICEhKGFrbSAmIChXUEFfS0VZX01HTVRfSUVFRTgwMjFYIHwKIAkJCSBXUEFfS0VZX01HTVRfRlRfSUVFRTgwMjFYIHwKIAkJCSBXUEFfS0VZX01HTVRfQ0NLTSB8CisJCQkgV1BBX0tFWV9NR01UX09TRU4gfAogCQkJIFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfU0hBMjU2KSk7CiB9CiAKQEAgLTU4LDcgKzY0LDggQEAKIAlyZXR1cm4gISEoYWttICYgKFdQQV9LRVlfTUdNVF9QU0sgfAogCQkJIFdQQV9LRVlfTUdNVF9GVF9QU0sgfAogCQkJIFdQQV9LRVlfTUdNVF9QU0tfU0hBMjU2IHwKLQkJCSBXUEFfS0VZX01HTVRfU0FFKSk7CisJCQkgV1BBX0tFWV9NR01UX1NBRSB8CisJCQkgV1BBX0tFWV9NR01UX0ZUX1NBRSkpOwogfQogCiBzdGF0aWMgaW5saW5lIGludCB3cGFfa2V5X21nbXRfZnQoaW50IGFrbSkKQEAgLTc3LDEzICs4NCwxNSBAQAogc3RhdGljIGlubGluZSBpbnQgd3BhX2tleV9tZ210X3NoYTI1NihpbnQgYWttKQogewogCXJldHVybiAhIShha20gJiAoV1BBX0tFWV9NR01UX1BTS19TSEEyNTYgfAotCQkJIFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfU0hBMjU2KSk7CisJCQkgV1BBX0tFWV9NR01UX0lFRUU4MDIxWF9TSEEyNTYgfAorCQkJIFdQQV9LRVlfTUdNVF9PU0VOKSk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgaW50IHdwYV9rZXlfbWdtdF93cGEoaW50IGFrbSkKIHsKIAlyZXR1cm4gd3BhX2tleV9tZ210X3dwYV9pZWVlODAyMXgoYWttKSB8fAotCQl3cGFfa2V5X21nbXRfd3BhX3Bzayhha20pOworCQl3cGFfa2V5X21nbXRfd3BhX3Bzayhha20pIHx8CisJCXdwYV9rZXlfbWdtdF9zYWUoYWttKTsKIH0KIAogc3RhdGljIGlubGluZSBpbnQgd3BhX2tleV9tZ210X3dwYV9hbnkoaW50IGFrbSkKQEAgLTEwMCw2ICsxMDksNyBAQAogI2RlZmluZSBXUEFfUFJPVE9fV1BBIEJJVCgwKQogI2RlZmluZSBXUEFfUFJPVE9fUlNOIEJJVCgxKQogI2RlZmluZSBXUEFfUFJPVE9fV0FQSSBCSVQoMikKKyNkZWZpbmUgV1BBX1BST1RPX09TRU4gQklUKDMpCiAKICNkZWZpbmUgV1BBX0FVVEhfQUxHX09QRU4gQklUKDApCiAjZGVmaW5lIFdQQV9BVVRIX0FMR19TSEFSRUQgQklUKDEpCkBAIC0xMTcsNDEgKzEyNywxMiBAQAogCVdQQV9BTEdfUE1LLAogCVdQQV9BTEdfR0NNUCwKIAlXUEFfQUxHX1NNUzQsCi0JV1BBX0FMR19LUksKLX07Ci0KLS8qKgotICogZW51bSB3cGFfY2lwaGVyIC0gQ2lwaGVyIHN1aXRlcwotICovCi1lbnVtIHdwYV9jaXBoZXIgewotCUNJUEhFUl9OT05FLAotCUNJUEhFUl9XRVA0MCwKLQlDSVBIRVJfVEtJUCwKLQlDSVBIRVJfQ0NNUCwKLQlDSVBIRVJfV0VQMTA0LAotCUNJUEhFUl9HQ01QLAotCUNJUEhFUl9TTVM0Ci19OwotCi0vKioKLSAqIGVudW0gd3BhX2tleV9tZ210IC0gS2V5IG1hbmFnZW1lbnQgc3VpdGVzCi0gKi8KLWVudW0gd3BhX2tleV9tZ210IHsKLQlLRVlfTUdNVF84MDJfMVgsCi0JS0VZX01HTVRfUFNLLAotCUtFWV9NR01UX05PTkUsCi0JS0VZX01HTVRfODAyXzFYX05PX1dQQSwKLQlLRVlfTUdNVF9XUEFfTk9ORSwKLQlLRVlfTUdNVF9GVF84MDJfMVgsCi0JS0VZX01HTVRfRlRfUFNLLAotCUtFWV9NR01UXzgwMl8xWF9TSEEyNTYsCi0JS0VZX01HTVRfUFNLX1NIQTI1NiwKLQlLRVlfTUdNVF9XUFMsCi0JS0VZX01HTVRfU0FFLAotCUtFWV9NR01UX0ZUX1NBRSwKLQlLRVlfTUdNVF9XQVBJX1BTSywKLQlLRVlfTUdNVF9XQVBJX0NFUlQsCi0JS0VZX01HTVRfQ0NLTQorCVdQQV9BTEdfS1JLLAorCVdQQV9BTEdfR0NNUF8yNTYsCisJV1BBX0FMR19DQ01QXzI1NiwKKwlXUEFfQUxHX0JJUF9HTUFDXzEyOCwKKwlXUEFfQUxHX0JJUF9HTUFDXzI1NiwKKwlXUEFfQUxHX0JJUF9DTUFDXzI1NgogfTsKIAogLyoqCkBAIC0zMTIsNiArMjkzLDcgQEAKIAlXUEFfQ1RSTF9SRVFfRUFQX1BJTiwKIAlXUEFfQ1RSTF9SRVFfRUFQX09UUCwKIAlXUEFfQ1RSTF9SRVFfRUFQX1BBU1NQSFJBU0UsCisJV1BBX0NUUkxfUkVRX1NJTSwKIAlOVU1fV1BBX0NUUkxfUkVRUwogfTsKIApkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi9lYXBvbF9jb21tb24uaCBiL3NyYy9jb21tb24vZWFwb2xfY29tbW9uLmgKaW5kZXggNDgxMWYzOC4uNjk1ODY2MSAxMDA2NDQKLS0tIGEvc3JjL2NvbW1vbi9lYXBvbF9jb21tb24uaAorKysgYi9zcmMvY29tbW9uL2VhcG9sX2NvbW1vbi5oCkBAIC0yMiwxNyArMjIsMjggQEAKIAkvKiBmb2xsb3dlZCBieSBsZW5ndGggb2N0ZXRzIG9mIGRhdGEgKi8KIH0gU1RSVUNUX1BBQ0tFRDsKIAorc3RydWN0IGllZWU4MDIzX2hkciB7CisJdTggZGVzdFtFVEhfQUxFTl07CisJdTggc3JjW0VUSF9BTEVOXTsKKwl1MTYgZXRoZXJ0eXBlOworfSBTVFJVQ1RfUEFDS0VEOworCiAjaWZkZWYgX01TQ19WRVIKICNwcmFnbWEgcGFjayhwb3ApCiAjZW5kaWYgLyogX01TQ19WRVIgKi8KIAorI2lmZGVmIENPTkZJR19NQUNTRUMKKyNkZWZpbmUgRUFQT0xfVkVSU0lPTiAzCisjZWxzZSAvKiBDT05GSUdfTUFDU0VDICovCiAjZGVmaW5lIEVBUE9MX1ZFUlNJT04gMgorI2VuZGlmIC8qIENPTkZJR19NQUNTRUMgKi8KIAogZW51bSB7IElFRUU4MDJfMVhfVFlQRV9FQVBfUEFDS0VUID0gMCwKICAgICAgICBJRUVFODAyXzFYX1RZUEVfRUFQT0xfU1RBUlQgPSAxLAogICAgICAgIElFRUU4MDJfMVhfVFlQRV9FQVBPTF9MT0dPRkYgPSAyLAogICAgICAgIElFRUU4MDJfMVhfVFlQRV9FQVBPTF9LRVkgPSAzLAotICAgICAgIElFRUU4MDJfMVhfVFlQRV9FQVBPTF9FTkNBUFNVTEFURURfQVNGX0FMRVJUID0gNAorICAgICAgIElFRUU4MDJfMVhfVFlQRV9FQVBPTF9FTkNBUFNVTEFURURfQVNGX0FMRVJUID0gNCwKKyAgICAgICBJRUVFODAyXzFYX1RZUEVfRUFQT0xfTUtBID0gNSwKIH07CiAKIGVudW0geyBFQVBPTF9LRVlfVFlQRV9SQzQgPSAxLCBFQVBPTF9LRVlfVFlQRV9SU04gPSAyLApkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5jIGIvc3JjL2NvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5jCmluZGV4IGFhYjhhYzYuLjE3M2E0MDAgMTAwNjQ0Ci0tLSBhL3NyYy9jb21tb24vaWVlZTgwMl8xMV9jb21tb24uYworKysgYi9zcmMvY29tbW9uL2llZWU4MDJfMTFfY29tbW9uLmMKQEAgLTEwOCwxMCArMTA4LDE1IEBACiAJCQllbGVtcy0+aHMyMCA9IHBvczsKIAkJCWVsZW1zLT5oczIwX2xlbiA9IGVsZW47CiAJCQlicmVhazsKKwkJY2FzZSBIUzIwX09TRU5fT1VJX1RZUEU6CisJCQkvKiBIb3RzcG90IDIuMCBPU0VOICovCisJCQllbGVtcy0+b3NlbiA9IHBvczsKKwkJCWVsZW1zLT5vc2VuX2xlbiA9IGVsZW47CisJCQlicmVhazsKIAkJZGVmYXVsdDoKIAkJCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJVbmtub3duIFdGQSAiCiAJCQkJICAgImluZm9ybWF0aW9uIGVsZW1lbnQgaWdub3JlZCAiCi0JCQkJICAgIih0eXBlPSVkIGxlbj0lbHUpXG4iLAorCQkJCSAgICIodHlwZT0lZCBsZW49JWx1KSIsCiAJCQkJICAgcG9zWzNdLCAodW5zaWduZWQgbG9uZykgZWxlbik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KQEAgLTE4OSwyNSArMTk0LDEyIEBACiAJCQllbGVtcy0+c3VwcF9yYXRlcyA9IHBvczsKIAkJCWVsZW1zLT5zdXBwX3JhdGVzX2xlbiA9IGVsZW47CiAJCQlicmVhazsKLQkJY2FzZSBXTEFOX0VJRF9GSF9QQVJBTVM6Ci0JCQllbGVtcy0+ZmhfcGFyYW1zID0gcG9zOwotCQkJZWxlbXMtPmZoX3BhcmFtc19sZW4gPSBlbGVuOwotCQkJYnJlYWs7CiAJCWNhc2UgV0xBTl9FSURfRFNfUEFSQU1TOgogCQkJZWxlbXMtPmRzX3BhcmFtcyA9IHBvczsKIAkJCWVsZW1zLT5kc19wYXJhbXNfbGVuID0gZWxlbjsKIAkJCWJyZWFrOwogCQljYXNlIFdMQU5fRUlEX0NGX1BBUkFNUzoKLQkJCWVsZW1zLT5jZl9wYXJhbXMgPSBwb3M7Ci0JCQllbGVtcy0+Y2ZfcGFyYW1zX2xlbiA9IGVsZW47Ci0JCQlicmVhazsKIAkJY2FzZSBXTEFOX0VJRF9USU06Ci0JCQllbGVtcy0+dGltID0gcG9zOwotCQkJZWxlbXMtPnRpbV9sZW4gPSBlbGVuOwotCQkJYnJlYWs7Ci0JCWNhc2UgV0xBTl9FSURfSUJTU19QQVJBTVM6Ci0JCQllbGVtcy0+aWJzc19wYXJhbXMgPSBwb3M7Ci0JCQllbGVtcy0+aWJzc19wYXJhbXNfbGVuID0gZWxlbjsKIAkJCWJyZWFrOwogCQljYXNlIFdMQU5fRUlEX0NIQUxMRU5HRToKIAkJCWVsZW1zLT5jaGFsbGVuZ2UgPSBwb3M7CkBAIC0yMzIsOCArMjI0LDYgQEAKIAkJCWVsZW1zLT5yc25faWVfbGVuID0gZWxlbjsKIAkJCWJyZWFrOwogCQljYXNlIFdMQU5fRUlEX1BXUl9DQVBBQklMSVRZOgotCQkJZWxlbXMtPnBvd2VyX2NhcCA9IHBvczsKLQkJCWVsZW1zLT5wb3dlcl9jYXBfbGVuID0gZWxlbjsKIAkJCWJyZWFrOwogCQljYXNlIFdMQU5fRUlEX1NVUFBPUlRFRF9DSEFOTkVMUzoKIAkJCWVsZW1zLT5zdXBwX2NoYW5uZWxzID0gcG9zOwpAQCAtMjY3LDYgKzI1NywxMSBAQAogCQkJZWxlbXMtPnZodF9vcGVyYXRpb24gPSBwb3M7CiAJCQllbGVtcy0+dmh0X29wZXJhdGlvbl9sZW4gPSBlbGVuOwogCQkJYnJlYWs7CisJCWNhc2UgV0xBTl9FSURfVkhUX09QRVJBVElOR19NT0RFX05PVElGSUNBVElPTjoKKwkJCWlmIChlbGVuICE9IDEpCisJCQkJYnJlYWs7CisJCQllbGVtcy0+dmh0X29wbW9kZV9ub3RpZiA9IHBvczsKKwkJCWJyZWFrOwogCQljYXNlIFdMQU5fRUlEX0xJTktfSUQ6CiAJCQlpZiAoZWxlbiA8IDE4KQogCQkJCWJyZWFrOwpAQCAtMjc2LDYgKzI3MSwxMiBAQAogCQkJZWxlbXMtPmludGVyd29ya2luZyA9IHBvczsKIAkJCWVsZW1zLT5pbnRlcndvcmtpbmdfbGVuID0gZWxlbjsKIAkJCWJyZWFrOworCQljYXNlIFdMQU5fRUlEX1FPU19NQVBfU0VUOgorCQkJaWYgKGVsZW4gPCAxNikKKwkJCQlicmVhazsKKwkJCWVsZW1zLT5xb3NfbWFwX3NldCA9IHBvczsKKwkJCWVsZW1zLT5xb3NfbWFwX3NldF9sZW4gPSBlbGVuOworCQkJYnJlYWs7CiAJCWNhc2UgV0xBTl9FSURfRVhUX0NBUEFCOgogCQkJZWxlbXMtPmV4dF9jYXBhYiA9IHBvczsKIAkJCWVsZW1zLT5leHRfY2FwYWJfbGVuID0gZWxlbjsKQEAgLTU0NSwzICs1NDYsNjAgQEAKIAogCXJldHVybiBudW1fMTFiID4gMCAmJiBudW1fb3RoZXJzID09IDA7CiB9CisKKworY29uc3QgY2hhciAqIGZjMnN0cih1MTYgZmMpCit7CisJdTE2IHN0eXBlID0gV0xBTl9GQ19HRVRfU1RZUEUoZmMpOworI2RlZmluZSBDMlMoeCkgY2FzZSB4OiByZXR1cm4gI3g7CisKKwlzd2l0Y2ggKFdMQU5fRkNfR0VUX1RZUEUoZmMpKSB7CisJY2FzZSBXTEFOX0ZDX1RZUEVfTUdNVDoKKwkJc3dpdGNoIChzdHlwZSkgeworCQlDMlMoV0xBTl9GQ19TVFlQRV9BU1NPQ19SRVEpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX0FTU09DX1JFU1ApCisJCUMyUyhXTEFOX0ZDX1NUWVBFX1JFQVNTT0NfUkVRKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9SRUFTU09DX1JFU1ApCisJCUMyUyhXTEFOX0ZDX1NUWVBFX1BST0JFX1JFUSkKKwkJQzJTKFdMQU5fRkNfU1RZUEVfUFJPQkVfUkVTUCkKKwkJQzJTKFdMQU5fRkNfU1RZUEVfQkVBQ09OKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9BVElNKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9ESVNBU1NPQykKKwkJQzJTKFdMQU5fRkNfU1RZUEVfQVVUSCkKKwkJQzJTKFdMQU5fRkNfU1RZUEVfREVBVVRIKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9BQ1RJT04pCisJCX0KKwkJYnJlYWs7CisJY2FzZSBXTEFOX0ZDX1RZUEVfQ1RSTDoKKwkJc3dpdGNoIChzdHlwZSkgeworCQlDMlMoV0xBTl9GQ19TVFlQRV9QU1BPTEwpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX1JUUykKKwkJQzJTKFdMQU5fRkNfU1RZUEVfQ1RTKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9BQ0spCisJCUMyUyhXTEFOX0ZDX1NUWVBFX0NGRU5EKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9DRkVOREFDSykKKwkJfQorCQlicmVhazsKKwljYXNlIFdMQU5fRkNfVFlQRV9EQVRBOgorCQlzd2l0Y2ggKHN0eXBlKSB7CisJCUMyUyhXTEFOX0ZDX1NUWVBFX0RBVEEpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX0RBVEFfQ0ZBQ0spCisJCUMyUyhXTEFOX0ZDX1NUWVBFX0RBVEFfQ0ZQT0xMKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9EQVRBX0NGQUNLUE9MTCkKKwkJQzJTKFdMQU5fRkNfU1RZUEVfTlVMTEZVTkMpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX0NGQUNLKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9DRlBPTEwpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX0NGQUNLUE9MTCkKKwkJQzJTKFdMQU5fRkNfU1RZUEVfUU9TX0RBVEEpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX1FPU19EQVRBX0NGQUNLKQorCQlDMlMoV0xBTl9GQ19TVFlQRV9RT1NfREFUQV9DRlBPTEwpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX1FPU19EQVRBX0NGQUNLUE9MTCkKKwkJQzJTKFdMQU5fRkNfU1RZUEVfUU9TX05VTEwpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX1FPU19DRlBPTEwpCisJCUMyUyhXTEFOX0ZDX1NUWVBFX1FPU19DRkFDS1BPTEwpCisJCX0KKwkJYnJlYWs7CisJfQorCXJldHVybiAiV0xBTl9GQ19UWVBFX1VOS05PV04iOworI3VuZGVmIEMyUworfQpkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIGIvc3JjL2NvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oCmluZGV4IDY4YzZiOTYuLmNmODMwNTcgMTAwNjQ0Ci0tLSBhL3NyYy9jb21tb24vaWVlZTgwMl8xMV9jb21tb24uaAorKysgYi9zcmMvY29tbW9uL2llZWU4MDJfMTFfY29tbW9uLmgKQEAgLTEzLDExICsxMyw3IEBACiBzdHJ1Y3QgaWVlZTgwMl8xMV9lbGVtcyB7CiAJY29uc3QgdTggKnNzaWQ7CiAJY29uc3QgdTggKnN1cHBfcmF0ZXM7Ci0JY29uc3QgdTggKmZoX3BhcmFtczsKIAljb25zdCB1OCAqZHNfcGFyYW1zOwotCWNvbnN0IHU4ICpjZl9wYXJhbXM7Ci0JY29uc3QgdTggKnRpbTsKLQljb25zdCB1OCAqaWJzc19wYXJhbXM7CiAJY29uc3QgdTggKmNoYWxsZW5nZTsKIAljb25zdCB1OCAqZXJwX2luZm87CiAJY29uc3QgdTggKmV4dF9zdXBwX3JhdGVzOwpAQCAtMjYsNyArMjIsNiBAQAogCWNvbnN0IHU4ICp3bW07IC8qIFdNTSBJbmZvcm1hdGlvbiBvciBQYXJhbWV0ZXIgRWxlbWVudCAqLwogCWNvbnN0IHU4ICp3bW1fdHNwZWM7CiAJY29uc3QgdTggKndwc19pZTsKLQljb25zdCB1OCAqcG93ZXJfY2FwOwogCWNvbnN0IHU4ICpzdXBwX2NoYW5uZWxzOwogCWNvbnN0IHU4ICptZGllOwogCWNvbnN0IHU4ICpmdGllOwpAQCAtMzUsMjMgKzMwLDIyIEBACiAJY29uc3QgdTggKmh0X29wZXJhdGlvbjsKIAljb25zdCB1OCAqdmh0X2NhcGFiaWxpdGllczsKIAljb25zdCB1OCAqdmh0X29wZXJhdGlvbjsKKwljb25zdCB1OCAqdmh0X29wbW9kZV9ub3RpZjsKIAljb25zdCB1OCAqdmVuZG9yX2h0X2NhcDsKIAljb25zdCB1OCAqcDJwOwogCWNvbnN0IHU4ICp3ZmQ7CiAJY29uc3QgdTggKmxpbmtfaWQ7CiAJY29uc3QgdTggKmludGVyd29ya2luZzsKKwljb25zdCB1OCAqcW9zX21hcF9zZXQ7CiAJY29uc3QgdTggKmhzMjA7CiAJY29uc3QgdTggKmV4dF9jYXBhYjsKIAljb25zdCB1OCAqYnNzX21heF9pZGxlX3BlcmlvZDsKIAljb25zdCB1OCAqc3NpZF9saXN0OworCWNvbnN0IHU4ICpvc2VuOwogCiAJdTggc3NpZF9sZW47CiAJdTggc3VwcF9yYXRlc19sZW47Ci0JdTggZmhfcGFyYW1zX2xlbjsKIAl1OCBkc19wYXJhbXNfbGVuOwotCXU4IGNmX3BhcmFtc19sZW47Ci0JdTggdGltX2xlbjsKLQl1OCBpYnNzX3BhcmFtc19sZW47CiAJdTggY2hhbGxlbmdlX2xlbjsKIAl1OCBlcnBfaW5mb19sZW47CiAJdTggZXh0X3N1cHBfcmF0ZXNfbGVuOwpAQCAtNjAsNyArNTQsNiBAQAogCXU4IHdtbV9sZW47IC8qIDcgPSBXTU0gSW5mb3JtYXRpb247IDI0ID0gV01NIFBhcmFtZXRlciAqLwogCXU4IHdtbV90c3BlY19sZW47CiAJdTggd3BzX2llX2xlbjsKLQl1OCBwb3dlcl9jYXBfbGVuOwogCXU4IHN1cHBfY2hhbm5lbHNfbGVuOwogCXU4IG1kaWVfbGVuOwogCXU4IGZ0aWVfbGVuOwpAQCAtNzMsOSArNjYsMTEgQEAKIAl1OCBwMnBfbGVuOwogCXU4IHdmZF9sZW47CiAJdTggaW50ZXJ3b3JraW5nX2xlbjsKKwl1OCBxb3NfbWFwX3NldF9sZW47CiAJdTggaHMyMF9sZW47CiAJdTggZXh0X2NhcGFiX2xlbjsKIAl1OCBzc2lkX2xpc3RfbGVuOworCXU4IG9zZW5fbGVuOwogfTsKIAogdHlwZWRlZiBlbnVtIHsgUGFyc2VPSyA9IDAsIFBhcnNlVW5rbm93biA9IDEsIFBhcnNlRmFpbGVkID0gLTEgfSBQYXJzZVJlczsKQEAgLTEwMyw0ICs5OCw1IEBACiAKIGludCBzdXBwX3JhdGVzXzExYl9vbmx5KHN0cnVjdCBpZWVlODAyXzExX2VsZW1zICplbGVtcyk7CiAKK2NvbnN0IGNoYXIgKiBmYzJzdHIodTE2IGZjKTsKICNlbmRpZiAvKiBJRUVFODAyXzExX0NPTU1PTl9IICovCmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIGIvc3JjL2NvbW1vbi9pZWVlODAyXzExX2RlZnMuaAppbmRleCAxMzdjMzA5Li42ZGU3MWU5IDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oCisrKyBiL3NyYy9jb21tb24vaWVlZTgwMl8xMV9kZWZzLmgKQEAgLTE2MSw2ICsxNjEsOCBAQAogI2RlZmluZSBXTEFOX1NUQVRVU19BTlRJX0NMT0dHSU5HX1RPS0VOX1JFUSA3NgogI2RlZmluZSBXTEFOX1NUQVRVU19GSU5JVEVfQ1lDTElDX0dST1VQX05PVF9TVVBQT1JURUQgNzcKICNkZWZpbmUgV0xBTl9TVEFUVVNfVFJBTlNNSVNTSU9OX0ZBSUxVUkUgNzkKKyNkZWZpbmUgV0xBTl9TVEFUVVNfUVVFUllfUkVTUF9PVVRTVEFORElORyA5NQorI2RlZmluZSBXTEFOX1NUQVRVU19BU1NPQ19ERU5JRURfTk9fVkhUIDEwNAogCiAvKiBSZWFzb24gY29kZXMgKElFRUUgODAyLjExLTIwMDcsIDcuMy4xLjcsIFRhYmxlIDctMjIpICovCiAjZGVmaW5lIFdMQU5fUkVBU09OX1VOU1BFQ0lGSUVEIDEKQEAgLTIwMyw2ICsyMDUsNyBAQAogI2RlZmluZSBXTEFOX0VJRF9USU0gNQogI2RlZmluZSBXTEFOX0VJRF9JQlNTX1BBUkFNUyA2CiAjZGVmaW5lIFdMQU5fRUlEX0NPVU5UUlkgNworI2RlZmluZSBXTEFOX0VJRF9CU1NfTE9BRCAxMQogI2RlZmluZSBXTEFOX0VJRF9DSEFMTEVOR0UgMTYKIC8qIEVJRHMgZGVmaW5lZCBieSBJRUVFIDgwMi4xMWggLSBTVEFSVCAqLwogI2RlZmluZSBXTEFOX0VJRF9QV1JfQ09OU1RSQUlOVCAzMgpAQCAtMjIxLDEwICsyMjQsMTIgQEAKICNkZWZpbmUgV0xBTl9FSURfUU9TIDQ2CiAjZGVmaW5lIFdMQU5fRUlEX1JTTiA0OAogI2RlZmluZSBXTEFOX0VJRF9FWFRfU1VQUF9SQVRFUyA1MAorI2RlZmluZSBXTEFOX0VJRF9ORUlHSEJPUl9SRVBPUlQgNTIKICNkZWZpbmUgV0xBTl9FSURfTU9CSUxJVFlfRE9NQUlOIDU0CiAjZGVmaW5lIFdMQU5fRUlEX0ZBU1RfQlNTX1RSQU5TSVRJT04gNTUKICNkZWZpbmUgV0xBTl9FSURfVElNRU9VVF9JTlRFUlZBTCA1NgogI2RlZmluZSBXTEFOX0VJRF9SSUNfREFUQSA1NworI2RlZmluZSBXTEFOX0VJRF9TVVBQT1JURURfT1BFUkFUSU5HX0NMQVNTRVMgNTkKICNkZWZpbmUgV0xBTl9FSURfSFRfT1BFUkFUSU9OIDYxCiAjZGVmaW5lIFdMQU5fRUlEX1NFQ09OREFSWV9DSEFOTkVMX09GRlNFVCA2MgogI2RlZmluZSBXTEFOX0VJRF9XQVBJIDY4CkBAIC0yNDIsNiArMjQ3LDcgQEAKICNkZWZpbmUgV0xBTl9FSURfTElOS19JRCAxMDEKICNkZWZpbmUgV0xBTl9FSURfSU5URVJXT1JLSU5HIDEwNwogI2RlZmluZSBXTEFOX0VJRF9BRFZfUFJPVE8gMTA4CisjZGVmaW5lIFdMQU5fRUlEX1FPU19NQVBfU0VUIDExMAogI2RlZmluZSBXTEFOX0VJRF9ST0FNSU5HX0NPTlNPUlRJVU0gMTExCiAjZGVmaW5lIFdMQU5fRUlEX0VYVF9DQVBBQiAxMjcKICNkZWZpbmUgV0xBTl9FSURfQ0NLTSAxNTYKQEAgLTI2Nyw2ICsyNzMsNyBAQAogI2RlZmluZSBXTEFOX0FDVElPTl9GVCA2CiAjZGVmaW5lIFdMQU5fQUNUSU9OX0hUIDcKICNkZWZpbmUgV0xBTl9BQ1RJT05fU0FfUVVFUlkgOAorI2RlZmluZSBXTEFOX0FDVElPTl9QUk9URUNURURfRFVBTCA5CiAjZGVmaW5lIFdMQU5fQUNUSU9OX1dOTSAxMAogI2RlZmluZSBXTEFOX0FDVElPTl9VTlBST1RFQ1RFRF9XTk0gMTEKICNkZWZpbmUgV0xBTl9BQ1RJT05fVERMUyAxMgpAQCAtMjgyLDYgKzI4OSwxOSBAQAogI2RlZmluZSBXTEFOX1BBX0dBU19DT01FQkFDS19SRVNQIDEzCiAjZGVmaW5lIFdMQU5fVERMU19ESVNDT1ZFUllfUkVTUE9OU0UgMTQKIAorLyogUHJvdGVjdGVkIER1YWwgb2YgUHVibGljIEFjdGlvbiBmcmFtZXMgKi8KKyNkZWZpbmUgV0xBTl9QUk9UX0RTRV9FTkFCTEVNRU5UIDEKKyNkZWZpbmUgV0xBTl9QUk9UX0RTRV9ERUVOQUJMRU1FTlQgMgorI2RlZmluZSBXTEFOX1BST1RfRVhUX0NTQSA0CisjZGVmaW5lIFdMQU5fUFJPVF9NRUFTVVJFTUVOVF9SRVEgNQorI2RlZmluZSBXTEFOX1BST1RfTUVBU1VSRU1FTlRfUkVQT1JUIDYKKyNkZWZpbmUgV0xBTl9QUk9UX0RTRV9QT1dFUl9DT05TVFJBSU5UIDgKKyNkZWZpbmUgV0xBTl9QUk9UX1ZFTkRPUl9TUEVDSUZJQyA5CisjZGVmaW5lIFdMQU5fUFJPVF9HQVNfSU5JVElBTF9SRVEgMTAKKyNkZWZpbmUgV0xBTl9QUk9UX0dBU19JTklUSUFMX1JFU1AgMTEKKyNkZWZpbmUgV0xBTl9QUk9UX0dBU19DT01FQkFDS19SRVEgMTIKKyNkZWZpbmUgV0xBTl9QUk9UX0dBU19DT01FQkFDS19SRVNQIDEzCisKIC8qIFNBIFF1ZXJ5IEFjdGlvbiBmcmFtZSAoSUVFRSA4MDIuMTF3L0Q4LjAsIDcuNC45KSAqLwogI2RlZmluZSBXTEFOX1NBX1FVRVJZX1JFUVVFU1QgMAogI2RlZmluZSBXTEFOX1NBX1FVRVJZX1JFU1BPTlNFIDEKQEAgLTU2Niw5ICs1ODYsMTIgQEAKIC8qIFJ4IE1DUyBiaXRtYXNrIGlzIGluIHRoZSBmaXJzdCA3NyBiaXRzIG9mIHN1cHBvcnRlZF9tY3Nfc2V0ICovCiAjZGVmaW5lIElFRUU4MDIxMV9IVF9NQ1NfTUFTS19MRU4gMTAKIAorLyogSFQgQ2FwYWJpbGl0aWVzIGVsZW1lbnQgKi8KIHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwYWJpbGl0aWVzIHsKIAlsZTE2IGh0X2NhcGFiaWxpdGllc19pbmZvOwotCXU4IGFfbXBkdV9wYXJhbXM7CisJdTggYV9tcGR1X3BhcmFtczsgLyogTWF4aW11bSBBLU1QRFUgTGVuZ3RoIEV4cG9uZW50IEIwLi5CMQorCQkJICAgKiBNaW5pbXVtIE1QRFUgU3RhcnQgU3BhY2luZyBCMi4uQjQKKwkJCSAgICogUmVzZXJ2ZWQgQjUuLkI3ICovCiAJdTggc3VwcG9ydGVkX21jc19zZXRbMTZdOwogCWxlMTYgaHRfZXh0ZW5kZWRfY2FwYWJpbGl0aWVzOwogCWxlMzIgdHhfYmZfY2FwYWJpbGl0eV9pbmZvOwpAQCAtNTc2LDEyICs1OTksMjUgQEAKIH0gU1RSVUNUX1BBQ0tFRDsKIAogCisvKiBIVCBPcGVyYXRpb24gZWxlbWVudCAqLwogc3RydWN0IGllZWU4MDIxMV9odF9vcGVyYXRpb24gewotCXU4IGNvbnRyb2xfY2hhbjsKLQl1OCBodF9wYXJhbTsKLQlsZTE2IG9wZXJhdGlvbl9tb2RlOwotCWxlMTYgc3RiY19wYXJhbTsKLQl1OCBiYXNpY19zZXRbMTZdOworCXU4IHByaW1hcnlfY2hhbjsKKwkvKiBGaXZlIG9jdGV0cyBvZiBIVCBPcGVyYXRpb24gSW5mb3JtYXRpb24gKi8KKwl1OCBodF9wYXJhbTsgLyogQjAuLkI3ICovCisJbGUxNiBvcGVyYXRpb25fbW9kZTsgLyogQjguLkIyMyAqLworCWxlMTYgcGFyYW07IC8qIEIyNC4uQjM5ICovCisJdTggYmFzaWNfbWNzX3NldFsxNl07Cit9IFNUUlVDVF9QQUNLRUQ7CisKKworc3RydWN0IGllZWU4MDIxMV9vYnNzX3NjYW5fcGFyYW1ldGVycyB7CisJbGUxNiBzY2FuX3Bhc3NpdmVfZHdlbGw7CisJbGUxNiBzY2FuX2FjdGl2ZV9kd2VsbDsKKwlsZTE2IHdpZHRoX3RyaWdnZXJfc2Nhbl9pbnRlcnZhbDsKKwlsZTE2IHNjYW5fcGFzc2l2ZV90b3RhbF9wZXJfY2hhbm5lbDsKKwlsZTE2IHNjYW5fYWN0aXZlX3RvdGFsX3Blcl9jaGFubmVsOworCWxlMTYgY2hhbm5lbF90cmFuc2l0aW9uX2RlbGF5X2ZhY3RvcjsKKwlsZTE2IHNjYW5fYWN0aXZpdHlfdGhyZXNob2xkOwogfSBTVFJVQ1RfUEFDS0VEOwogCiAKQEAgLTYxMCw3ICs2NDYsOSBAQAogI2RlZmluZSBFUlBfSU5GT19VU0VfUFJPVEVDVElPTiBCSVQoMSkKICNkZWZpbmUgRVJQX0lORk9fQkFSS0VSX1BSRUFNQkxFX01PREUgQklUKDIpCiAKKyNkZWZpbmUgT1ZFUkxBUFBJTkdfQlNTX1RSQU5TX0RFTEFZX0ZBQ1RPUiA1CiAKKy8qIEhUIENhcGFiaWxpdGllcyBJbmZvIGZpZWxkIHdpdGhpbiBIVCBDYXBhYmlsaXRpZXMgZWxlbWVudCAqLwogI2RlZmluZSBIVF9DQVBfSU5GT19MRFBDX0NPRElOR19DQVAJCSgodTE2KSBCSVQoMCkpCiAjZGVmaW5lIEhUX0NBUF9JTkZPX1NVUFBfQ0hBTk5FTF9XSURUSF9TRVQJKCh1MTYpIEJJVCgxKSkKICNkZWZpbmUgSFRfQ0FQX0lORk9fU01QU19NQVNLCQkJKCh1MTYpIChCSVQoMikgfCBCSVQoMykpKQpAQCAtNjI4LDczICs2NjYsODYgQEAKICNkZWZpbmUgSFRfQ0FQX0lORk9fREVMQVlFRF9CQQkJCSgodTE2KSBCSVQoMTApKQogI2RlZmluZSBIVF9DQVBfSU5GT19NQVhfQU1TRFVfU0laRQkJKCh1MTYpIEJJVCgxMSkpCiAjZGVmaW5lIEhUX0NBUF9JTkZPX0RTU1NfQ0NLNDBNSFoJCSgodTE2KSBCSVQoMTIpKQotI2RlZmluZSBIVF9DQVBfSU5GT19QU01QX1NVUFAJCQkoKHUxNikgQklUKDEzKSkKKy8qIEIxMyAtIFJlc2VydmVkICh3YXMgUFNNUCBzdXBwb3J0IGR1cmluZyBQODAyLjExbiBkZXZlbG9wbWVudCkgKi8KICNkZWZpbmUgSFRfQ0FQX0lORk9fNDBNSFpfSU5UT0xFUkFOVAkJKCh1MTYpIEJJVCgxNCkpCiAjZGVmaW5lIEhUX0NBUF9JTkZPX0xTSUdfVFhPUF9QUk9URUNUX1NVUFBPUlQJKCh1MTYpIEJJVCgxNSkpCiAKLQorLyogSFQgRXh0ZW5kZWQgQ2FwYWJpbGl0aWVzIGZpZWxkIHdpdGhpbiBIVCBDYXBhYmlsaXRpZXMgZWxlbWVudCAqLwogI2RlZmluZSBFWFRfSFRfQ0FQX0lORk9fUENPCQkJKCh1MTYpIEJJVCgwKSkKKyNkZWZpbmUgRVhUX0hUX0NBUF9JTkZPX1BDT19UUkFOU19USU1FX01BU0sJKCh1MTYpIChCSVQoMSkgfCBCSVQoMikpKQogI2RlZmluZSBFWFRfSFRfQ0FQX0lORk9fVFJBTlNfVElNRV9PRkZTRVQJMQorLyogQjMuLkI3IC0gUmVzZXJ2ZWQgKi8KKyNkZWZpbmUgRVhUX0hUX0NBUF9JTkZPX01DU19GRUVEQkFDS19NQVNLCSgodTE2KSAoQklUKDgpIHwgQklUKDkpKSkKICNkZWZpbmUgRVhUX0hUX0NBUF9JTkZPX01DU19GRUVEQkFDS19PRkZTRVQJOAotI2RlZmluZSBFWFRfSFRfQ0FQX0lORk9fSFRDX1NVUFBPUlRFRAkJKCh1MTYpIEJJVCgxMCkpCisjZGVmaW5lIEVYVF9IVF9DQVBfSU5GT19IVENfU1VQUE9SVAkJKCh1MTYpIEJJVCgxMCkpCiAjZGVmaW5lIEVYVF9IVF9DQVBfSU5GT19SRF9SRVNQT05ERVIJCSgodTE2KSBCSVQoMTEpKQorLyogQjEyLi5CMTUgLSBSZXNlcnZlZCAqLwogCisvKiBUcmFuc21pdCBCZWFuZm9ybWluZyBDYXBhYmlsaXRpZXMgd2l0aGluIEhUIENhcGFiaWxpdGllcyBlbGVtZW50ICovCisjZGVmaW5lIFRYX0JGX0NBUF9JTVBMSUNJVF9UWEJGX1JYX0NBUCAoKHUzMikgQklUKDApKQorI2RlZmluZSBUWF9CRl9DQVBfUlhfU1RBR0dFUkVEX1NPVU5ESU5HX0NBUCAoKHUzMikgQklUKDEpKQorI2RlZmluZSBUWF9CRl9DQVBfVFhfU1RBR0dFUkVEX1NPVU5ESU5HX0NBUCAoKHUzMikgQklUKDIpKQorI2RlZmluZSBUWF9CRl9DQVBfUlhfTkRQX0NBUCAoKHUzMikgQklUKDMpKQorI2RlZmluZSBUWF9CRl9DQVBfVFhfTkRQX0NBUCAoKHUzMikgQklUKDQpKQorI2RlZmluZSBUWF9CRl9DQVBfSU1QTElDSVRfVFhfQkZfQ0FQICgodTMyKSBCSVQoNSkpCisjZGVmaW5lIFRYX0JGX0NBUF9DQUxJQlJBVElPTl9NQVNLICgodTMyKSAoQklUKDYpIHwgQklUKDcpKQorI2RlZmluZSBUWF9CRl9DQVBfQ0FMSUJfT0ZGU0VUIDYKKyNkZWZpbmUgVFhfQkZfQ0FQX0VYUExJQ0lUX0NTSV9UWEJGX0NBUCAoKHUzMikgQklUKDgpKQorI2RlZmluZSBUWF9CRl9DQVBfRVhQTElDSVRfTk9OQ09NUFJfU1RFRVJJTkdfQ0FQICgodTMyKSBCSVQoOSkpCisjZGVmaW5lIFRYX0JGX0NBUF9FWFBMSUNJVF9DT01QUl9TVEVFUklOR19DQVAgKCh1MzIpIEJJVCgxMCkpCisjZGVmaW5lIFRYX0JGX0NBUF9FWFBMSUNJVF9UWF9CRl9DU0lfRkVFREJBQ0tfTUFTSyAoKHUzMikgKEJJVCgxMCkgfCBCSVQoMTEpKSkKKyNkZWZpbmUgVFhfQkZfQ0FQX0VYUExJQ0lUX0JGX0NTSV9GRUVEQkFDS19PRkZTRVQgMTEKKyNkZWZpbmUgVFhfQkZfQ0FQX0VYUExJQ0lUX1VOQ09NUFJfU1RFRVJJTkdfTUFUUklYX0ZFRURCQUNLX09GRlNFVCAxMworI2RlZmluZSBUWF9CRl9DQVBfRVhQTElDSVRfQ09NUFJFU1NFRF9TVEVFUklOR19NQVRSSVhfRkVFREJBQ0tfT0ZGU0VUIDE1CisjZGVmaW5lIFRYX0JGX0NBUF9NSU5JTUFMX0dST1VQSU5HX09GRlNFVCAxNworI2RlZmluZSBUWF9CRl9DQVBfQ1NJX05VTV9CRUFNRk9STUVSX0FOVF9PRkZTRVQgMTkKKyNkZWZpbmUgVFhfQkZfQ0FQX1VOQ09NUFJFU1NFRF9TVEVFUklOR19NQVRSSVhfQkVBTUZPUk1FUl9BTlRfT0ZGU0VUIDIxCisjZGVmaW5lIFRYX0JGX0NBUF9DT01QUkVTU0VEX1NURUVSSU5HX01BVFJJWF9CRUFNRk9STUVSX0FOVF9PRkZTRVQgMjMKKyNkZWZpbmUgVFhfQkZfQ0FQX1NDSV9NQVhfT0ZfUk9XU19CRUFORk9STUVSX1NVUFBPUlRFRF9PRkZTRVQgMjUKKyNkZWZpbmUgVFhfQkZfQ0FQX0NIQU5ORUxfRVNUSU1BVElPTl9DQVBfTUFTSyAoKHUzMikgKEJJVCgyNykgfCBCSVQoMjgpKSkKKyNkZWZpbmUgVFhfQkZfQ0FQX0NIQU5ORUxfRVNUSU1BVElPTl9DQVBfT0ZGU0VUIDI3CisvKiBCMjkuLkIzMSAtIFJlc2VydmVkICovCiAKLSNkZWZpbmUgVFhfQkVBTUZPUk1fQ0FQX1RYQkZfQ0FQICgodTMyKSBCSVQoMCkpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9SWF9TVEFHR0VSRURfU09VTkRJTkdfQ0FQICgodTMyKSBCSVQoMSkpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9UWF9TVEFHR0VSRURfU09VTkRJTkdfQ0FQICgodTMyKSBCSVQoMikpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9SWF9aTEZfQ0FQICgodTMyKSBCSVQoMykpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9UWF9aTEZfQ0FQICgodTMyKSBCSVQoNCkpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9JTVBMSUNJVF9aTEZfQ0FQICgodTMyKSBCSVQoNSkpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9DQUxJQl9PRkZTRVQgNgotI2RlZmluZSBUWF9CRUFNRk9STV9DQVBfRVhQTElDSVRfQ1NJX1RYQkZfQ0FQICgodTMyKSBCSVQoOCkpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9FWFBMSUNJVF9VTkNPTVBSX1NURUVSSU5HX01BVFJJWF9DQVAgKCh1MzIpIEJJVCg5KSkKLSNkZWZpbmUgVFhfQkVBTUZPUk1fQ0FQX0VYUExJQ0lUX0JGX0NTSV9GRUVEQkFDS19DQVAgKCh1MzIpIEJJVCgxMCkpCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9FWFBMSUNJVF9CRl9DU0lfRkVFREJBQ0tfT0ZGU0VUIDExCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9FWFBMSUNJVF9VTkNPTVBSX1NURUVSSU5HX01BVFJJWF9GRUVEQkFDS19PRkZTRVQgMTMKLSNkZWZpbmUgVFhfQkVBTUZPUk1fQ0FQX0VYUExJQ0lUX0NPTVBSRVNTRURfU1RFRVJJTkdfTUFUUklYX0ZFRURCQUNLX09GRlNFVCAxNQotI2RlZmluZSBUWF9CRUFNRk9STV9DQVBfTUlOSU1BTF9HUk9VUElOR19PRkZTRVQgMTcKLSNkZWZpbmUgVFhfQkVBTUZPUk1fQ0FQX0NTSV9OVU1fQkVBTUZPUk1FUl9BTlRfT0ZGU0VUIDE5Ci0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9VTkNPTVBSRVNTRURfU1RFRVJJTkdfTUFUUklYX0JFQU1GT1JNRVJfQU5UX09GRlNFVCAyMQotI2RlZmluZSBUWF9CRUFNRk9STV9DQVBfQ09NUFJFU1NFRF9TVEVFUklOR19NQVRSSVhfQkVBTUZPUk1FUl9BTlRfT0ZGU0VUIDIzCi0jZGVmaW5lIFRYX0JFQU1GT1JNX0NBUF9TQ0lfTUFYX09GX1JPV1NfQkVBTkZPUk1FUl9TVVBQT1JURURfT0ZGU0VUIDI1CisvKiBBU0VMIENhcGFiaWxpdHkgZmllbGQgd2l0aGluIEhUIENhcGFiaWxpdGllcyBlbGVtZW50ICovCisjZGVmaW5lIEFTRUxfQ0FQX0FTRUxfQ0FQQUJMRSAoKHU4KSBCSVQoMCkpCisjZGVmaW5lIEFTRUxfQ0FQX0VYUExJQ0lUX0NTSV9GRUVEQkFDS19CQVNFRF9UWF9BU19DQVAgKCh1OCkgQklUKDEpKQorI2RlZmluZSBBU0VMX0NBUF9BTlRfSU5ESUNFU19GRUVEQkFDS19CQVNFRF9UWF9BU19DQVAgKCh1OCkgQklUKDIpKQorI2RlZmluZSBBU0VMX0NBUF9FWFBMSUNJVF9DU0lfRkVFREJBQ0tfQ0FQICgodTgpIEJJVCgzKSkKKyNkZWZpbmUgQVNFTF9DQVBfQU5UX0lORElDRVNfRkVFREJBQ0tfQ0FQICgodTgpIEJJVCg0KSkKKyNkZWZpbmUgQVNFTF9DQVBfUlhfQVNfQ0FQICgodTgpIEJJVCg1KSkKKyNkZWZpbmUgQVNFTF9DQVBfVFhfU09VTkRJTkdfUFBEVVNfQ0FQICgodTgpIEJJVCg2KSkKKy8qIEI3IC0gUmVzZXJ2ZWQgKi8KIAotCi0jZGVmaW5lIEFTRUxfQ0FQQUJJTElUWV9BU0VMX0NBUEFCTEUgKCh1OCkgQklUKDApKQotI2RlZmluZSBBU0VMX0NBUEFCSUxJVFlfRVhQTElDSVRfQ1NJX0ZFRURCQUNLX0JBU0VEX1RYX0FTX0NBUCAoKHU4KSBCSVQoMSkpCi0jZGVmaW5lIEFTRUxfQ0FQQUJJTElUWV9BTlRfSU5ESUNFU19GRUVEQkFDS19CQVNFRF9UWF9BU19DQVAgKCh1OCkgQklUKDIpKQotI2RlZmluZSBBU0VMX0NBUEFCSUxJVFlfRVhQTElDSVRfQ1NJX0ZFRURCQUNLX0NBUCAoKHU4KSBCSVQoMykpCi0jZGVmaW5lIEFTRUxfQ0FQQUJJTElUWV9BTlRfSU5ESUNFU19GRUVEQkFDS19DQVAgKCh1OCkgQklUKDQpKQotI2RlZmluZSBBU0VMX0NBUEFCSUxJVFlfUlhfQVNfQ0FQICgodTgpIEJJVCg1KSkKLSNkZWZpbmUgQVNFTF9DQVBBQklMSVRZX1RYX1NPVU5EX1BQRFVTX0NBUCAoKHU4KSBCSVQoNikpCi0KKy8qIEZpcnN0IG9jdGV0IG9mIEhUIE9wZXJhdGlvbiBJbmZvcm1hdGlvbiB3aXRoaW4gSFQgT3BlcmF0aW9uIGVsZW1lbnQgKi8KICNkZWZpbmUgSFRfSU5GT19IVF9QQVJBTV9TRUNPTkRBUllfQ0hOTF9PRkZfTUFTSwkoKHU4KSBCSVQoMCkgfCBCSVQoMSkpCiAjZGVmaW5lIEhUX0lORk9fSFRfUEFSQU1fU0VDT05EQVJZX0NITkxfQUJPVkUJCSgodTgpIEJJVCgwKSkKICNkZWZpbmUgSFRfSU5GT19IVF9QQVJBTV9TRUNPTkRBUllfQ0hOTF9CRUxPVwkJKCh1OCkgQklUKDApIHwgQklUKDEpKQotI2RlZmluZSBIVF9JTkZPX0hUX1BBUkFNX1JFQ19UUkFOU19DSE5MX1dJRFRICQkoKHU4KSBCSVQoMikpCisjZGVmaW5lIEhUX0lORk9fSFRfUEFSQU1fU1RBX0NITkxfV0lEVEgJCQkoKHU4KSBCSVQoMikpCiAjZGVmaW5lIEhUX0lORk9fSFRfUEFSQU1fUklGU19NT0RFCQkJKCh1OCkgQklUKDMpKQotI2RlZmluZSBIVF9JTkZPX0hUX1BBUkFNX0NUUkxfQUNDRVNTX09OTFkJCSgodTgpIEJJVCg0KSkKLSNkZWZpbmUgSFRfSU5GT19IVF9QQVJBTV9TUlZfSU5URVJWQUxfR1JBTlVMQVJJVFkJKCh1OCkgQklUKDUpKQorLyogQjQuLkI3IC0gUmVzZXJ2ZWQgKi8KIAorLyogSFQgUHJvdGVjdGlvbiAoQjguLkI5IG9mIEhUIE9wZXJhdGlvbiBJbmZvcm1hdGlvbikgKi8KKyNkZWZpbmUgSFRfUFJPVF9OT19QUk9URUNUSU9OICAgICAgICAgICAwCisjZGVmaW5lIEhUX1BST1RfTk9OTUVNQkVSX1BST1RFQ1RJT04gICAgMQorI2RlZmluZSBIVF9QUk9UXzIwTUhaX1BST1RFQ1RJT04gICAgICAgIDIKKyNkZWZpbmUgSFRfUFJPVF9OT05fSFRfTUlYRUQgICAgICAgICAgICAzCisvKiBCaXRzIHdpdGhpbiBpZWVlODAyMTFfaHRfb3BlcmF0aW9uOjpvcGVyYXRpb25fbW9kZSAoQklUKDApIG1hcHMgdG8gQjggaW4KKyAqIEhUIE9wZXJhdGlvbiBJbmZvcm1hdGlvbikgKi8KKyNkZWZpbmUgSFRfT1BFUl9PUF9NT0RFX0hUX1BST1RfTUFTSyAoKHUxNikgKEJJVCgwKSB8IEJJVCgxKSkpIC8qIEI4Li5COSAqLworI2RlZmluZSBIVF9PUEVSX09QX01PREVfTk9OX0dGX0hUX1NUQVNfUFJFU0VOVAkoKHUxNikgQklUKDIpKSAvKiBCMTAgKi8KKy8qIEJJVCgzKSwgaS5lLiwgQjExIGluIEhUIE9wZXJhdGlvbiBJbmZvcm1hdGlvbiBmaWVsZCAtIFJlc2VydmVkICovCisjZGVmaW5lIEhUX09QRVJfT1BfTU9ERV9PQlNTX05PTl9IVF9TVEFTX1BSRVNFTlQJKCh1MTYpIEJJVCg0KSkgLyogQjEyICovCisvKiBCSVQoNSkuLkJJVCgxNSksIGkuZS4sIEIxMy4uQjIzIC0gUmVzZXJ2ZWQgKi8KIAotI2RlZmluZSBPUF9NT0RFX1BVUkUgICAgICAgICAgICAgICAgICAgIDAKLSNkZWZpbmUgT1BfTU9ERV9NQVlfQkVfTEVHQUNZX1NUQVMgICAgICAxCi0jZGVmaW5lIE9QX01PREVfMjBNSFpfSFRfU1RBX0FTU09DRUQgICAgMgotI2RlZmluZSBPUF9NT0RFX01JWEVEICAgICAgICAgICAgICAgICAgIDMKLQotI2RlZmluZSBIVF9JTkZPX09QRVJBVElPTl9NT0RFX09QX01PREVfTUFTSwlcCi0JCSgweDAwMDEgfCAweDAwMDIpCi0jZGVmaW5lIEhUX0lORk9fT1BFUkFUSU9OX01PREVfT1BfTU9ERV9PRkZTRVQJCTAKLSNkZWZpbmUgSFRfSU5GT19PUEVSQVRJT05fTU9ERV9OT05fR0ZfREVWU19QUkVTRU5UCSgodTgpIEJJVCgyKSkKLSNkZWZpbmUgSFRfSU5GT19PUEVSQVRJT05fTU9ERV9UUkFOU01JVF9CVVJTVF9MSU1JVAkoKHU4KSBCSVQoMykpCi0jZGVmaW5lIEhUX0lORk9fT1BFUkFUSU9OX01PREVfTk9OX0hUX1NUQV9QUkVTRU5UCSgodTgpIEJJVCg0KSkKLQotI2RlZmluZSBIVF9JTkZPX1NUQkNfUEFSQU1fRFVBTF9CRUFDT04JCQkoKHUxNikgQklUKDYpKQotI2RlZmluZSBIVF9JTkZPX1NUQkNfUEFSQU1fRFVBTF9TVEJDX1BST1RFQ1QJCSgodTE2KSBCSVQoNykpCi0jZGVmaW5lIEhUX0lORk9fU1RCQ19QQVJBTV9TRUNPTkRBUllfQkNOCQkoKHUxNikgQklUKDgpKQotI2RlZmluZSBIVF9JTkZPX1NUQkNfUEFSQU1fTFNJR19UWE9QX1BST1RFQ1RfQUxMT1dFRAkoKHUxNikgQklUKDkpKQotI2RlZmluZSBIVF9JTkZPX1NUQkNfUEFSQU1fUENPX0FDVElWRQkJCSgodTE2KSBCSVQoMTApKQotI2RlZmluZSBIVF9JTkZPX1NUQkNfUEFSQU1fUENPX1BIQVNFCQkJKCh1MTYpIEJJVCgxMSkpCisvKiBMYXN0IHR3byBvY3RldHMgb2YgSFQgT3BlcmF0aW9uIEluZm9ybWF0aW9uIChCSVQoMCkgPSBCMjQpICovCisvKiBCMjQuLkIyOSAtIFJlc2VydmVkICovCisjZGVmaW5lIEhUX09QRVJfUEFSQU1fRFVBTF9CRUFDT04JCQkoKHUxNikgQklUKDYpKQorI2RlZmluZSBIVF9PUEVSX1BBUkFNX0RVQUxfQ1RTX1BST1RFQ1RJT04JCSgodTE2KSBCSVQoNykpCisjZGVmaW5lIEhUX09QRVJfUEFSQU1fU1RCQ19CRUFDT04JCQkoKHUxNikgQklUKDgpKQorI2RlZmluZSBIVF9PUEVSX1BBUkFNX0xTSUdfVFhPUF9QUk9UX0ZVTExfU1VQUAkJKCh1MTYpIEJJVCg5KSkKKyNkZWZpbmUgSFRfT1BFUl9QQVJBTV9QQ09fQUNUSVZFCQkJKCh1MTYpIEJJVCgxMCkpCisjZGVmaW5lIEhUX09QRVJfUEFSQU1fUENPX1BIQVNFCQkJCSgodTE2KSBCSVQoMTEpKQorLyogQjM2Li5CMzkgLSBSZXNlcnZlZCAqLwogCiAjZGVmaW5lIEJTU19NRU1CRVJTSElQX1NFTEVDVE9SX1ZIVF9QSFkgMTI2CiAjZGVmaW5lIEJTU19NRU1CRVJTSElQX1NFTEVDVE9SX0hUX1BIWSAxMjcKQEAgLTcwMiw4ICs3NTMsMTAgQEAKIC8qIFZIVCBEZWZpbmVzICovCiAjZGVmaW5lIFZIVF9DQVBfTUFYX01QRFVfTEVOR1RIXzc5OTEgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgwKSkKICNkZWZpbmUgVkhUX0NBUF9NQVhfTVBEVV9MRU5HVEhfMTE0NTQgICAgICAgICAgICAgICAoKHUzMikgQklUKDEpKQorI2RlZmluZSBWSFRfQ0FQX01BWF9NUERVX0xFTkdUSF9NQVNLICAgICAgICAgICAgICAgICgodTMyKSBCSVQoMCkgfCBCSVQoMSkpCiAjZGVmaW5lIFZIVF9DQVBfU1VQUF9DSEFOX1dJRFRIXzE2ME1IWiAgICAgICAgICAgICAgKCh1MzIpIEJJVCgyKSkKICNkZWZpbmUgVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwXzgwUExVUzgwTUhaICAgICAoKHUzMikgQklUKDMpKQorI2RlZmluZSBWSFRfQ0FQX1NVUFBfQ0hBTl9XSURUSF9NQVNLICAgICAgICAgICAgICAgICgodTMyKSBCSVQoMikgfCBCSVQoMykpCiAjZGVmaW5lIFZIVF9DQVBfUlhMRFBDICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCg0KSkKICNkZWZpbmUgVkhUX0NBUF9TSE9SVF9HSV84MCAgICAgICAgICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDUpKQogI2RlZmluZSBWSFRfQ0FQX1NIT1JUX0dJXzE2MCAgICAgICAgICAgICAgICAgICAgICAgICgodTMyKSBCSVQoNikpCkBAIC03MTIsMjAgKzc2NSw0MSBAQAogI2RlZmluZSBWSFRfQ0FQX1JYU1RCQ18yICAgICAgICAgICAgICAgICAgICAgICAgICAgICgodTMyKSBCSVQoOSkpCiAjZGVmaW5lIFZIVF9DQVBfUlhTVEJDXzMgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCg4KSB8IEJJVCg5KSkKICNkZWZpbmUgVkhUX0NBUF9SWFNUQkNfNCAgICAgICAgICAgICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDEwKSkKKyNkZWZpbmUgVkhUX0NBUF9SWFNUQkNfTUFTSyAgICAgICAgICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDgpIHwgQklUKDkpIHwgXAorCQkJCQkJCSAgIEJJVCgxMCkpCiAjZGVmaW5lIFZIVF9DQVBfU1VfQkVBTUZPUk1FUl9DQVBBQkxFICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgxMSkpCiAjZGVmaW5lIFZIVF9DQVBfU1VfQkVBTUZPUk1FRV9DQVBBQkxFICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgxMikpCi0jZGVmaW5lIFZIVF9DQVBfQkVBTUZPUk1FUl9BTlRFTk5BU19NQVggICAgICAgICAgICAgKCh1MzIpIEJJVCgxMykgfCBCSVQoMTQpKQotI2RlZmluZSBWSFRfQ0FQX1NPVU5ESU5HX0RJTUVOVElPTl9NQVggICAgICAgICAgICAgICgodTMyKSBCSVQoMTYpIHwgQklUKDE3KSkKKyNkZWZpbmUgVkhUX0NBUF9CRUFNRk9STUVFX1NUU19NQVggICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDEzKSB8IFwKKwkJCQkJCQkgICBCSVQoMTQpIHwgQklUKDE1KSkKKyNkZWZpbmUgVkhUX0NBUF9CRUFNRk9STUVFX1NUU19PRkZTRVQgICAgICAgICAgICAgICAxMworI2RlZmluZSBWSFRfQ0FQX1NPVU5ESU5HX0RJTUVOU0lPTl9NQVggICAgICAgICAgICAgICgodTMyKSBCSVQoMTYpIHwgXAorCQkJCQkJCSAgIEJJVCgxNykgfCBCSVQoMTgpKQorI2RlZmluZSBWSFRfQ0FQX1NPVU5ESU5HX0RJTUVOU0lPTl9PRkZTRVQgICAgICAgICAgIDE2CiAjZGVmaW5lIFZIVF9DQVBfTVVfQkVBTUZPUk1FUl9DQVBBQkxFICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgxOSkpCiAjZGVmaW5lIFZIVF9DQVBfTVVfQkVBTUZPUk1FRV9DQVBBQkxFICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgyMCkpCiAjZGVmaW5lIFZIVF9DQVBfVkhUX1RYT1BfUFMgICAgICAgICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgyMSkpCiAjZGVmaW5lIFZIVF9DQVBfSFRDX1ZIVCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgyMikpCi0jZGVmaW5lIFZIVF9DQVBfTUFYX0FfTVBEVV9MRU5HVEhfRVhQT05FTlQgICAgICAgICAgKCh1MzIpIEJJVCgyMykpCisKKyNkZWZpbmUgVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF8xICAgICAgICAoKHUzMikgQklUKDIzKSkKKyNkZWZpbmUgVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF8yICAgICAgICAoKHUzMikgQklUKDI0KSkKKyNkZWZpbmUgVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF8zICAgICAgICAoKHUzMikgQklUKDIzKSB8IEJJVCgyNCkpCisjZGVmaW5lIFZIVF9DQVBfTUFYX0FfTVBEVV9MRU5HVEhfRVhQT05FTlRfNCAgICAgICAgKCh1MzIpIEJJVCgyNSkpCisjZGVmaW5lIFZIVF9DQVBfTUFYX0FfTVBEVV9MRU5HVEhfRVhQT05FTlRfNSAgICAgICAgKCh1MzIpIEJJVCgyMykgfCBCSVQoMjUpKQorI2RlZmluZSBWSFRfQ0FQX01BWF9BX01QRFVfTEVOR1RIX0VYUE9ORU5UXzYgICAgICAgICgodTMyKSBCSVQoMjQpIHwgQklUKDI1KSkKKyNkZWZpbmUgVkhUX0NBUF9NQVhfQV9NUERVX0xFTkdUSF9FWFBPTkVOVF9NQVggICAgICAoKHUzMikgQklUKDIzKSB8IFwKKwkJCQkJCQkgICBCSVQoMjQpIHwgQklUKDI1KSkKICNkZWZpbmUgVkhUX0NBUF9WSFRfTElOS19BREFQVEFUSU9OX1ZIVF9VTlNPTF9NRkIgICAoKHUzMikgQklUKDI3KSkKICNkZWZpbmUgVkhUX0NBUF9WSFRfTElOS19BREFQVEFUSU9OX1ZIVF9NUlFfTUZCICAgICAoKHUzMikgQklUKDI2KSB8IEJJVCgyNykpCiAjZGVmaW5lIFZIVF9DQVBfUlhfQU5URU5OQV9QQVRURVJOICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgyOCkpCiAjZGVmaW5lIFZIVF9DQVBfVFhfQU5URU5OQV9QQVRURVJOICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgyOSkpCiAKKyNkZWZpbmUgVkhUX09QTU9ERV9DSEFOTkVMX1dJRFRIX01BU0sJCSAgICAoKHU4KSBCSVQoMCkgfCBCSVQoMSkpCisjZGVmaW5lIFZIVF9PUE1PREVfQ0hBTk5FTF9SeE5TU19NQVNLCQkgICAgKCh1OCkgQklUKDQpIHwgQklUKDUpIHwgXAorCQkJCQkJICAgICBCSVQoNikpCisjZGVmaW5lIFZIVF9PUE1PREVfTk9USUZfUlhfTlNTX1NISUZUCQkgICAgNAorCisjZGVmaW5lIFZIVF9SWF9OU1NfTUFYX1NUUkVBTVMJCQkgICAgOAorCiAvKiBWSFQgY2hhbm5lbCB3aWR0aHMgKi8KICNkZWZpbmUgVkhUX0NIQU5XSURUSF9VU0VfSFQJMAogI2RlZmluZSBWSFRfQ0hBTldJRFRIXzgwTUhaCTEKQEAgLTczNSwxMiArODA5LDE0IEBACiAjZGVmaW5lIE9VSV9NSUNST1NPRlQgMHgwMDUwZjIgLyogTWljcm9zb2Z0IChhbHNvIHVzZWQgaW4gV2ktRmkgc3BlY3MpCiAJCQkJKiAwMDo1MDpGMiAqLwogI2RlZmluZSBXUEFfSUVfVkVORE9SX1RZUEUgMHgwMDUwZjIwMQorI2RlZmluZSBXTU1fSUVfVkVORE9SX1RZUEUgMHgwMDUwZjIwMgogI2RlZmluZSBXUFNfSUVfVkVORE9SX1RZUEUgMHgwMDUwZjIwNAogI2RlZmluZSBPVUlfV0ZBIDB4NTA2ZjlhCiAjZGVmaW5lIFAyUF9JRV9WRU5ET1JfVFlQRSAweDUwNmY5YTA5CiAjZGVmaW5lIFdGRF9JRV9WRU5ET1JfVFlQRSAweDUwNmY5YTBhCiAjZGVmaW5lIFdGRF9PVUlfVFlQRSAxMAogI2RlZmluZSBIUzIwX0lFX1ZFTkRPUl9UWVBFIDB4NTA2ZjlhMTAKKyNkZWZpbmUgT1NFTl9JRV9WRU5ET1JfVFlQRSAweDUwNmY5YTEyCiAKICNkZWZpbmUgV01NX09VSV9UWVBFIDIKICNkZWZpbmUgV01NX09VSV9TVUJUWVBFX0lORk9STUFUSU9OX0VMRU1FTlQgMApAQCAtODU2LDYgKzkzMiw3IEBACiAKICNkZWZpbmUgSFMyMF9JTkRJQ0FUSU9OX09VSV9UWVBFIDE2CiAjZGVmaW5lIEhTMjBfQU5RUF9PVUlfVFlQRSAxNworI2RlZmluZSBIUzIwX09TRU5fT1VJX1RZUEUgMTgKICNkZWZpbmUgSFMyMF9TVFlQRV9RVUVSWV9MSVNUIDEKICNkZWZpbmUgSFMyMF9TVFlQRV9DQVBBQklMSVRZX0xJU1QgMgogI2RlZmluZSBIUzIwX1NUWVBFX09QRVJBVE9SX0ZSSUVORExZX05BTUUgMwpAQCAtODYzLDYgKzk0MCwyMSBAQAogI2RlZmluZSBIUzIwX1NUWVBFX0NPTk5FQ1RJT05fQ0FQQUJJTElUWSA1CiAjZGVmaW5lIEhTMjBfU1RZUEVfTkFJX0hPTUVfUkVBTE1fUVVFUlkgNgogI2RlZmluZSBIUzIwX1NUWVBFX09QRVJBVElOR19DTEFTUyA3CisjZGVmaW5lIEhTMjBfU1RZUEVfT1NVX1BST1ZJREVSU19MSVNUIDgKKyNkZWZpbmUgSFMyMF9TVFlQRV9JQ09OX1JFUVVFU1QgMTAKKyNkZWZpbmUgSFMyMF9TVFlQRV9JQ09OX0JJTkFSWV9GSUxFIDExCisKKyNkZWZpbmUgSFMyMF9ER0FGX0RJU0FCTEVEIDB4MDEKKyNkZWZpbmUgSFMyMF9QUFNfTU9fSURfUFJFU0VOVCAweDAyCisjZGVmaW5lIEhTMjBfQU5RUF9ET01BSU5fSURfUFJFU0VOVCAweDA0CisjZGVmaW5lIEhTMjBfVkVSU0lPTiAweDEwIC8qIFJlbGVhc2UgMiAqLworCisvKiBXTk0tTm90aWZpY2F0aW9uIFdGQSB2ZW5kb3JzIHNwZWNpZmljIHN1YnR5cGVzICovCisjZGVmaW5lIEhTMjBfV05NX1NVQl9SRU1fTkVFREVEIDAKKyNkZWZpbmUgSFMyMF9XTk1fREVBVVRIX0lNTUlORU5UX05PVElDRSAxCisKKyNkZWZpbmUgSFMyMF9ERUFVVEhfUkVBU09OX0NPREVfQlNTIDAKKyNkZWZpbmUgSFMyMF9ERUFVVEhfUkVBU09OX0NPREVfRVNTIDEKIAogLyogV2ktRmkgRGlyZWN0IChQMlApICovCiAKQEAgLTg4OCw2ICs5ODAsNyBAQAogCVAyUF9BVFRSX0lOVEVSRkFDRSA9IDE2LAogCVAyUF9BVFRSX09QRVJBVElOR19DSEFOTkVMID0gMTcsCiAJUDJQX0FUVFJfSU5WSVRBVElPTl9GTEFHUyA9IDE4LAorCVAyUF9BVFRSX09PQl9HT19ORUdfQ0hBTk5FTCA9IDE5LAogCVAyUF9BVFRSX1ZFTkRPUl9TUEVDSUZJQyA9IDIyMQogfTsKIApAQCAtOTA5LDYgKzEwMDIsNyBAQAogI2RlZmluZSBQMlBfR1JPVVBfQ0FQQUJfQ1JPU1NfQ09OTiBCSVQoNCkKICNkZWZpbmUgUDJQX0dST1VQX0NBUEFCX1BFUlNJU1RFTlRfUkVDT05OIEJJVCg1KQogI2RlZmluZSBQMlBfR1JPVVBfQ0FQQUJfR1JPVVBfRk9STUFUSU9OIEJJVCg2KQorI2RlZmluZSBQMlBfR1JPVVBfQ0FQQUJfSVBfQUREUl9BTExPQ0FUSU9OIEJJVCg3KQogCiAvKiBJbnZpdGF0aW9uIEZsYWdzICovCiAjZGVmaW5lIFAyUF9JTlZJVEFUSU9OX0ZMQUdTX1RZUEUgQklUKDApCkBAIC05MzMsNiArMTAyNywxMiBAQAogCVAyUF9TQ19GQUlMX1JFSkVDVEVEX0JZX1VTRVIgPSAxMSwKIH07CiAKK2VudW0gcDJwX3JvbGVfaW5kaWNhdGlvbiB7CisJUDJQX0RFVklDRV9OT1RfSU5fR1JPVVAgPSAweDAwLAorCVAyUF9DTElFTlRfSU5fQV9HUk9VUCA9IDB4MDEsCisJUDJQX0dPX0lOX0FfR1JPVVAgPSAweDAyLAorfTsKKwogI2RlZmluZSBQMlBfV0lMRENBUkRfU1NJRCAiRElSRUNULSIKICNkZWZpbmUgUDJQX1dJTERDQVJEX1NTSURfTEVOIDcKIApAQCAtMTAwMiw2ICsxMTAyLDExIEBACiAjZGVmaW5lIFdMQU5fQ0lQSEVSX1NVSVRFX0FFU19DTUFDCTB4MDAwRkFDMDYKICNkZWZpbmUgV0xBTl9DSVBIRVJfU1VJVEVfTk9fR1JPVVBfQUREUgkweDAwMEZBQzA3CiAjZGVmaW5lIFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVAJCTB4MDAwRkFDMDgKKyNkZWZpbmUgV0xBTl9DSVBIRVJfU1VJVEVfR0NNUF8yNTYJMHgwMDBGQUMwOQorI2RlZmluZSBXTEFOX0NJUEhFUl9TVUlURV9DQ01QXzI1NgkweDAwMEZBQzBBCisjZGVmaW5lIFdMQU5fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzEyOAkweDAwMEZBQzBCCisjZGVmaW5lIFdMQU5fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzI1NgkweDAwMEZBQzBDCisjZGVmaW5lIFdMQU5fQ0lQSEVSX1NVSVRFX0JJUF9DTUFDXzI1NgkweDAwMEZBQzBECiAKICNkZWZpbmUgV0xBTl9DSVBIRVJfU1VJVEVfU01TNAkJMHgwMDE0NzIwMQogCkBAIC0xMDE1LDcgKzExMjAsMTAgQEAKICNkZWZpbmUgV0xBTl9BS01fU1VJVEVfUFNLCQkweDAwMEZBQzAyCiAjZGVmaW5lIFdMQU5fQUtNX1NVSVRFX0ZUXzgwMjFYCQkweDAwMEZBQzAzCiAjZGVmaW5lIFdMQU5fQUtNX1NVSVRFX0ZUX1BTSwkJMHgwMDBGQUMwNAorI2RlZmluZSBXTEFOX0FLTV9TVUlURV84MDIxWF9TSEEyNTYJMHgwMDBGQUMwNQorI2RlZmluZSBXTEFOX0FLTV9TVUlURV9QU0tfU0hBMjU2CTB4MDAwRkFDMDYKICNkZWZpbmUgV0xBTl9BS01fU1VJVEVfQ0NLTQkJMHgwMDQwOTYwMAorI2RlZmluZSBXTEFOX0FLTV9TVUlURV9PU0VOCQkweDUwNmY5YTAxCiAKIAogLyogSUVFRSA4MDIuMTF2IC0gV05NIEFjdGlvbiBmaWVsZCB2YWx1ZXMgKi8KQEAgLTEwNzksNiArMTE4NywxNSBAQAogI2RlZmluZSBXTk1fTkVJR0hCT1JfUlJNX0VOQUJMRURfQ0FQQUJJTElUSUVTICAgNzAKICNkZWZpbmUgV05NX05FSUdIQk9SX01VTFRJUExFX0JTU0lEICAgICAgICAgICAgIDcxCiAKKy8qIFFvUyBhY3Rpb24gKi8KK2VudW0gcW9zX2FjdGlvbiB7CisJUU9TX0FERFRTX1JFUSA9IDAsCisJUU9TX0FERFRTX1JFU1AgPSAxLAorCVFPU19ERUxUUyA9IDIsCisJUU9TX1NDSEVEVUxFID0gMywKKwlRT1NfUU9TX01BUF9DT05GSUcgPSA0LAorfTsKKwogLyogSUVFRSBTdGQgODAyLjExLTIwMTIsIDguNC4yLjYyIDIwLzQwIEJTUyBDb2V4aXN0ZW5jZSBlbGVtZW50ICovCiAjZGVmaW5lIFdMQU5fMjBfNDBfQlNTX0NPRVhfSU5GT19SRVEgICAgICAgICAgICBCSVQoMCkKICNkZWZpbmUgV0xBTl8yMF80MF9CU1NfQ09FWF80ME1IWl9JTlRPTCAgICAgICAgIEJJVCgxKQpAQCAtMTEyNiw0ICsxMjQzLDggQEAKIAlXTk1fU0xFRVBfU1VCRUxFTV9JR1RLID0gMQogfTsKIAorLyogQ2hhbm5lbCBTd2l0Y2ggbW9kZXMgKDgwMi4xMWgpICovCisjZGVmaW5lIENIQU5fU1dJVENIX01PREVfQUxMT1dfVFgJMAorI2RlZmluZSBDSEFOX1NXSVRDSF9NT0RFX0JMT0NLX1RYCTEKKwogI2VuZGlmIC8qIElFRUU4MDJfMTFfREVGU19IICovCmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL2llZWU4MDJfMXhfZGVmcy5oIGIvc3JjL2NvbW1vbi9pZWVlODAyXzF4X2RlZnMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jYzg4Y2FhCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL2NvbW1vbi9pZWVlODAyXzF4X2RlZnMuaApAQCAtMCwwICsxLDc4IEBACisvKgorICogSUVFRSBTdGQgODAyLjFYLTIwMTAgZGVmaW5pdGlvbnMKKyAqIENvcHlyaWdodCAoYykgMjAxMy0yMDE0LCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIElFRUU4MDJfMVhfREVGU19ICisjZGVmaW5lIElFRUU4MDJfMVhfREVGU19ICisKKyNkZWZpbmUgQ1NfSURfTEVOCQk4CisjZGVmaW5lIENTX0lEX0dDTV9BRVNfMTI4CXsweDAwLCAweDgwLCAweDAyLCAweDAwLCAweDAxLCAweDAwLCAweDAwLCAweDAxfQorI2RlZmluZSBDU19OQU1FX0dDTV9BRVNfMTI4CSJHQ00tQUVTLTEyOCIKKworZW51bSBtYWNzZWNfcG9saWN5IHsKKwkvKioKKwkgKiBTaG91bGQgc2VjdXJlIHNlc3Npb25zLgorCSAqIFRoaXMgYWNjZXB0cyBrZXkgc2VydmVyJ3MgYWR2aWNlIHRvIGRldGVybWluZSB3aGV0aGVyIHRvIHNlY3VyZSB0aGUKKwkgKiBzZXNzaW9uIG9yIG5vdC4KKwkgKi8KKwlTSE9VTERfU0VDVVJFLAorCisJLyoqCisJICogRGlzYWJsZWQgTUFDc2VjIC0gZG8gbm90IHNlY3VyZSBzZXNzaW9ucy4KKwkgKi8KKwlET19OT1RfU0VDVVJFLAorfTsKKworCisvKiBJRUVFIFN0ZCA4MDIuMVgtMjAxMCAtIFRhYmxlIDExLTYgLSBNQUNzZWMgQ2FwYWJpbGl0eSAqLworZW51bSBtYWNzZWNfY2FwIHsKKwkvKioKKwkgKiBNQUNzZWMgaXMgbm90IGltcGxlbWVudGVkCisJICovCisJTUFDU0VDX0NBUF9OT1RfSU1QTEVNRU5URUQsCisKKwkvKioKKwkgKiAnSW50ZWdyaXR5IHdpdGhvdXQgY29uZmlkZW50aWFsaXR5JworCSAqLworCU1BQ1NFQ19DQVBfSU5URUdSSVRZLAorCisJLyoqCisJICogJ0ludGVncml0eSB3aXRob3V0IGNvbmZpZGVudGlhbGl0eScgYW5kCisJICogJ0ludGVncml0eSBhbmQgY29uZmlkZW50aWFsaXR5JyB3aXRoIGEgY29uZmlkZW50aWFsaXR5IG9mZnNldCBvZiAwCisJICovCisJTUFDU0VDX0NBUF9JTlRFR19BTkRfQ09ORiwKKworCS8qKgorCSAqICdJbnRlZ3JpdHkgd2l0aG91dCBjb25maWRlbnRpYWxpdHknIGFuZAorCSAqICdJbnRlZ3JpdHkgYW5kIGNvbmZpZGVudGlhbGl0eScgd2l0aCBhIGNvbmZpZGVudGlhbGl0eSBvZmZzZXQgb2YgMCwKKwkgKiAzMCwgNTAKKwkgKi8KKwlNQUNTRUNfQ0FQX0lOVEVHX0FORF9DT05GXzBfMzBfNTAsCit9OworCitlbnVtIHZhbGlkYXRlX2ZyYW1lcyB7CisJRGlzYWJsZWQsCisJQ2hlY2tlZCwKKwlTdHJpY3QsCit9OworCisvKiBJRUVFIFN0ZCA4MDIuMVgtMjAxMCAtIFRhYmxlIDExLTYgLSBDb25maWRlbnRpYWxpdHkgT2Zmc2V0ICovCitlbnVtIGNvbmZpZGVudGlhbGl0eV9vZmZzZXQgeworCUNPTkZJREVOVElBTElUWV9OT05FICAgICAgPSAwLAorCUNPTkZJREVOVElBTElUWV9PRkZTRVRfMCAgPSAxLAorCUNPTkZJREVOVElBTElUWV9PRkZTRVRfMzAgPSAyLAorCUNPTkZJREVOVElBTElUWV9PRkZTRVRfNTAgPSAzLAorfTsKKworLyogSUVFRSBTdGQgODAyLjFYLTIwMTAgLSBUYWJsZSA5LTIgKi8KKyNkZWZpbmUgREVGQVVMVF9QUklPX0lORlJBX1BPUlQgICAgICAgIDB4MTAKKyNkZWZpbmUgREVGQVVMVF9QUklPX1BSSU1SQVlfQVAgICAgICAgIDB4MzAKKyNkZWZpbmUgREVGQVVMVF9QUklPX1NFQ09OREFSWV9BUCAgICAgIDB4NTAKKyNkZWZpbmUgREVGQVVMVF9QUklPX0dST1VQX0NBX01FTUJFUiAgIDB4NzAKKyNkZWZpbmUgREVGQVVMVF9QUklPX05PVF9LRVlfU0VSVkVSICAgIDB4RkYKKworI2VuZGlmIC8qIElFRUU4MDJfMVhfREVGU19IICovCmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL3FjYS12ZW5kb3ItYXR0ci5oIGIvc3JjL2NvbW1vbi9xY2EtdmVuZG9yLWF0dHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZjUxODAzCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL2NvbW1vbi9xY2EtdmVuZG9yLWF0dHIuaApAQCAtMCwwICsxLDI4IEBACisvKgorICogUXVhbGNvbW0gQXRoZXJvcyB2ZW5kb3Igc3BlY2lmaWMgYXR0cmlidXRlIGRlZmluaXRpb25zCisgKiBDb3B5cmlnaHQgKGMpIDIwMTQsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgUUNBX1ZFTkRPUl9BVFRSX0gKKyNkZWZpbmUgUUNBX1ZFTkRPUl9BVFRSX0gKKworLyoKKyAqIFRoaXMgZmlsZSBkZWZpbmVzIHNvbWUgb2YgdGhlIGF0dHJpYnV0ZXMgdXNlZCB3aXRoIFF1YWxjb21tIEF0aGVyb3MgT1VJCisgKiAwMDoxMzo3NCBpbiBhIHdheSB0aGF0IGlzIG5vdCBzdWl0YWJsZSBmb3IgcWNhLXZlbmRvci5oLCBlLmcuLCBkdWUgdG8KKyAqIGNvbXBpbGVyIGRlcGVuZGVuY2llcy4KKyAqLworCitzdHJ1Y3QgcWNhX2F2b2lkX2ZyZXFfcmFuZ2UgeworCXUzMiBzdGFydF9mcmVxOworCXUzMiBlbmRfZnJlcTsKK30gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpOworCitzdHJ1Y3QgcWNhX2F2b2lkX2ZyZXFfbGlzdCB7CisJdTMyIGNvdW50OworCXN0cnVjdCBxY2FfYXZvaWRfZnJlcV9yYW5nZSByYW5nZVswXTsKK30gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpOworCisjZW5kaWYgLyogUUNBX1ZFTkRPUl9BVFRSX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vcWNhLXZlbmRvci5oIGIvc3JjL2NvbW1vbi9xY2EtdmVuZG9yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGQ5ZWZkNQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9jb21tb24vcWNhLXZlbmRvci5oCkBAIC0wLDAgKzEsNzQgQEAKKy8qCisgKiBRdWFsY29tbSBBdGhlcm9zIE9VSSBhbmQgdmVuZG9yIHNwZWNpZmljIGFzc2lnbm1lbnRzCisgKiBDb3B5cmlnaHQgKGMpIDIwMTQsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgUUNBX1ZFTkRPUl9ICisjZGVmaW5lIFFDQV9WRU5ET1JfSAorCisvKgorICogVGhpcyBmaWxlIGlzIGEgcmVnaXN0cnkgb2YgaWRlbnRpZmllciBhc3NpZ25tZW50cyBmcm9tIHRoZSBRdWFsY29tbSBBdGhlcm9zCisgKiBPVUkgMDA6MTM6NzQgZm9yIHB1cnBvc2VzIG90aGVyIHRoYW4gTUFDIGFkZHJlc3MgYXNzaWdubWVudC4gTmV3IGlkZW50aWZpZXJzCisgKiBjYW4gYmUgYXNzaWduZWQgdGhyb3VnaCBub3JtYWwgcmV2aWV3IHByb2Nlc3MgZm9yIGNoYW5nZXMgdG8gdGhlIHVwc3RyZWFtCisgKiBob3N0YXAuZ2l0IHJlcG9zaXRvcnkuCisgKi8KKworI2RlZmluZSBPVUlfUUNBIDB4MDAxMzc0CisKKy8qKgorICogZW51bSBxY2FfcmFkaW90YXBfdmVuZG9yX2lkcyAtIFFDQSByYWRpb3RhcCB2ZW5kb3IgbmFtZXNwYWNlIElEcworICovCitlbnVtIHFjYV9yYWRpb3RhcF92ZW5kb3JfaWRzIHsKKwlRQ0FfUkFESU9UQVBfVklEX1dMQU5URVNUID0gMCwKK307CisKKy8qKgorICogZW51bSBxY2Ffbmw4MDIxMV92ZW5kb3Jfc3ViY21kcyAtIFFDQSBubDgwMjExIHZlbmRvciBjb21tYW5kIGlkZW50aWZpZXJzCisgKgorICogQFFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfVU5TUEVDOiBSZXNlcnZlZCB2YWx1ZSAwCisgKgorICogQFFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfVEVTVDogVGVzdCBjb21tYW5kL2V2ZW50CisgKgorICogQFFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfQVZPSURfRlJFUVVFTkNZOiBSZWNvbW1lbmRhdGlvbiBvZiBmcmVxdWVuY3kKKyAqCXJhbmdlcyB0byBhdm9pZCB0byByZWR1Y2UgaXNzdWVzIGR1ZSB0byBpbnRlcmZlcmVuY2Ugb3IgaW50ZXJuYWwKKyAqCWNvLWV4aXN0ZW5jZSBpbmZvcm1hdGlvbiBpbiB0aGUgZHJpdmVyLiBUaGUgZXZlbnQgZGF0YSBzdHJ1Y3R1cmUgaXMKKyAqCWRlZmluZWQgaW4gc3RydWN0IHFjYV9hdm9pZF9mcmVxX2xpc3QuCisgKgorICogQFFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfREZTX0NBUEFCSUxJVFk6IENvbW1hbmQgdG8gY2hlY2sgZHJpdmVyIHN1cHBvcnQKKyAqCWZvciBERlMgb2ZmbG9hZGluZy4KKyAqCisgKiBAUUNBX05MODAyMTFfVkVORE9SX1NVQkNNRF9OQU46IE5BTiBjb21tYW5kL2V2ZW50IHdoaWNoIGlzIHVzZWQgdG8gcGFzcworICoJTkFOIFJlcXVlc3QvUmVzcG9uc2UgYW5kIE5BTiBJbmRpY2F0aW9uIG1lc3NhZ2VzLiBUaGVzZSBtZXNzYWdlcyBhcmUKKyAqCWludGVycHJldGVkIGJldHdlZW4gdGhlIGZyYW1ld29yayBhbmQgdGhlIGZpcm13YXJlIGNvbXBvbmVudC4KKyAqLworZW51bSBxY2Ffbmw4MDIxMV92ZW5kb3Jfc3ViY21kcyB7CisJUUNBX05MODAyMTFfVkVORE9SX1NVQkNNRF9VTlNQRUMgPSAwLAorCVFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfVEVTVCA9IDEsCisJLyogc3ViY21kcyAyLi45IG5vdCB5ZXQgYWxsb2NhdGVkICovCisJUUNBX05MODAyMTFfVkVORE9SX1NVQkNNRF9BVk9JRF9GUkVRVUVOQ1kgPSAxMCwKKwlRQ0FfTkw4MDIxMV9WRU5ET1JfU1VCQ01EX0RGU19DQVBBQklMSVRZID0gIDExLAorCVFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfTkFOID0gIDEyLAorCVFDQV9OTDgwMjExX1ZFTkRPUl9TVUJNQ0RfU1RBVFNfRVhUID0gMTMsCisJLyogMTQuLjMzIC0gcmVzZXJ2ZWQgZm9yIFFDQSAqLworfTsKKworCitlbnVtIHFjYV93bGFuX3ZlbmRvcl9hdHRyIHsKKwlRQ0FfV0xBTl9WRU5ET1JfQVRUUl9JTlZBTElEID0gMCwKKwkvKiB1c2VkIGJ5IFFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfREZTX0NBUEFCSUxJVFkgKi8KKwlRQ0FfV0xBTl9WRU5ET1JfQVRUUl9ERlMgICAgID0gMSwKKwkvKiB1c2VkIGJ5IFFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfTkFOICovCisJUUNBX1dMQU5fVkVORE9SX0FUVFJfTkFOICAgICA9IDIsCisJLyogdXNlZCBieSBRQ0FfTkw4MDIxMV9WRU5ET1JfU1VCQ01EX1NUQVRTX0VYVCAqLworCVFDQV9XTEFOX1ZFTkRPUl9BVFRSX1NUQVRTX0VYVCAgICAgPSAzLAorCS8qIHVzZWQgYnkgUUNBX05MODAyMTFfVkVORE9SX1NVQkNNRF9TVEFUU19FWFQgKi8KKwlRQ0FfV0xBTl9WRU5ET1JfQVRUUl9JRklOREVYICAgICA9IDQsCisJLyoga2VlcCBsYXN0ICovCisJUUNBX1dMQU5fVkVORE9SX0FUVFJfQUZURVJfTEFTVCwKKwlRQ0FfV0xBTl9WRU5ET1JfQVRUUl9NQVgJPSBRQ0FfV0xBTl9WRU5ET1JfQVRUUl9BRlRFUl9MQVNUIC0gMSwKK307CisKKyNlbmRpZiAvKiBRQ0FfVkVORE9SX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vc2FlLmMgYi9zcmMvY29tbW9uL3NhZS5jCmluZGV4IGJjZTYwYTMuLmI2NzYyM2YgMTAwNjQ0Ci0tLSBhL3NyYy9jb21tb24vc2FlLmMKKysrIGIvc3JjL2NvbW1vbi9zYWUuYwpAQCAtMTM0LDggKzEzNCwxMCBAQAogCQkJcmV0dXJuIE5VTEw7CiAJCWlmIChjcnlwdG9fYmlnbnVtX2lzX3plcm8oYm4pIHx8CiAJCSAgICBjcnlwdG9fYmlnbnVtX2lzX29uZShibikgfHwKLQkJICAgIGNyeXB0b19iaWdudW1fY21wKGJuLCBzYWUtPnRtcC0+b3JkZXIpID49IDApCisJCSAgICBjcnlwdG9fYmlnbnVtX2NtcChibiwgc2FlLT50bXAtPm9yZGVyKSA+PSAwKSB7CisJCQljcnlwdG9fYmlnbnVtX2RlaW5pdChibiwgMCk7CiAJCQljb250aW51ZTsKKwkJfQogCQlicmVhazsKIAl9CiAKQEAgLTUwMyw2ICs1MDUsOCBAQAogCQkgICAgICAgY29uc3QgdTggKnBhc3N3b3JkLCBzaXplX3QgcGFzc3dvcmRfbGVuLAogCQkgICAgICAgc3RydWN0IHNhZV9kYXRhICpzYWUpCiB7CisJaWYgKHNhZS0+dG1wID09IE5VTEwpCisJCXJldHVybiAtMTsKIAlpZiAoc2FlLT50bXAtPmVjICYmIHNhZV9kZXJpdmVfcHdlX2VjYyhzYWUsIGFkZHIxLCBhZGRyMiwgcGFzc3dvcmQsCiAJCQkJCSAgcGFzc3dvcmRfbGVuKSA8IDApCiAJCXJldHVybiAtMTsKQEAgLTYzNCw3ICs2MzgsOCBAQAogaW50IHNhZV9wcm9jZXNzX2NvbW1pdChzdHJ1Y3Qgc2FlX2RhdGEgKnNhZSkKIHsKIAl1OCBrW1NBRV9NQVhfUFJJTUVfTEVOXTsKLQlpZiAoKHNhZS0+dG1wLT5lYyAmJiBzYWVfZGVyaXZlX2tfZWNjKHNhZSwgaykgPCAwKSB8fAorCWlmIChzYWUtPnRtcCA9PSBOVUxMIHx8CisJICAgIChzYWUtPnRtcC0+ZWMgJiYgc2FlX2Rlcml2ZV9rX2VjYyhzYWUsIGspIDwgMCkgfHwKIAkgICAgKHNhZS0+dG1wLT5kaCAmJiBzYWVfZGVyaXZlX2tfZmZjKHNhZSwgaykgPCAwKSB8fAogCSAgICBzYWVfZGVyaXZlX2tleXMoc2FlLCBrKSA8IDApCiAJCXJldHVybiAtMTsKQEAgLTY0Niw2ICs2NTEsMTAgQEAKIAkJICAgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqdG9rZW4pCiB7CiAJdTggKnBvczsKKworCWlmIChzYWUtPnRtcCA9PSBOVUxMKQorCQlyZXR1cm47CisKIAl3cGFidWZfcHV0X2xlMTYoYnVmLCBzYWUtPmdyb3VwKTsgLyogRmluaXRlIEN5Y2xpYyBHcm91cCAqLwogCWlmICh0b2tlbikKIAkJd3BhYnVmX3B1dF9idWYoYnVmLCB0b2tlbik7CkBAIC02NzgsNyArNjg3LDcgQEAKIHsKIAlpZiAoYWxsb3dlZF9ncm91cHMpIHsKIAkJaW50IGk7Ci0JCWZvciAoaSA9IDA7IGFsbG93ZWRfZ3JvdXBzW2ldID49IDA7IGkrKykgeworCQlmb3IgKGkgPSAwOyBhbGxvd2VkX2dyb3Vwc1tpXSA+IDA7IGkrKykgewogCQkJaWYgKGFsbG93ZWRfZ3JvdXBzW2ldID09IGdyb3VwKQogCQkJCWJyZWFrOwogCQl9CkBAIC03MDEsNiArNzEwLDExIEBACiAJCXJldHVybiBXTEFOX1NUQVRVU19GSU5JVEVfQ1lDTElDX0dST1VQX05PVF9TVVBQT1JURUQ7CiAJfQogCisJaWYgKHNhZS0+dG1wID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQUU6IEdyb3VwIGluZm9ybWF0aW9uIG5vdCB5ZXQgaW5pdGlhbGl6ZWQiKTsKKwkJcmV0dXJuIFdMQU5fU1RBVFVTX1VOU1BFQ0lGSUVEX0ZBSUxVUkU7CisJfQorCiAJaWYgKHNhZS0+dG1wLT5kaCAmJiAhYWxsb3dlZF9ncm91cHMpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQUU6IERvIG5vdCBhbGxvdyBGRkMgZ3JvdXAgJXUgd2l0aG91dCAiCiAJCQkgICAiZXhwbGljaXQgY29uZmlndXJhdGlvbiBlbmFibGluZyBpdCIsIGdyb3VwKTsKQEAgLTc5Nyw3ICs4MTEsNyBAQAogCiAJLyogZWxlbWVudCB4IGFuZCB5IGNvb3JkaW5hdGVzIDwgcCAqLwogCWlmIChvc19tZW1jbXAocG9zLCBwcmltZSwgc2FlLT50bXAtPnByaW1lX2xlbikgPj0gMCB8fAotCSAgICBvc19tZW1jbXAocG9zICsgc2FlLT50bXAtPnByaW1lX2xlbiArIHNhZS0+dG1wLT5wcmltZV9sZW4sIHByaW1lLAorCSAgICBvc19tZW1jbXAocG9zICsgc2FlLT50bXAtPnByaW1lX2xlbiwgcHJpbWUsCiAJCSAgICAgIHNhZS0+dG1wLT5wcmltZV9sZW4pID49IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQUU6IEludmFsaWQgY29vcmRpbmF0ZXMgaW4gcGVlciAiCiAJCQkgICAiZWxlbWVudCIpOwpAQCAtOTg1LDYgKzk5OSw5IEBACiB7CiAJY29uc3QgdTggKnNjOwogCisJaWYgKHNhZS0+dG1wID09IE5VTEwpCisJCXJldHVybjsKKwogCS8qIFNlbmQtQ29uZmlybSAqLwogCXNjID0gd3BhYnVmX3B1dChidWYsIDApOwogCXdwYWJ1Zl9wdXRfbGUxNihidWYsIHNhZS0+c2VuZF9jb25maXJtKTsKQEAgLTEwMTYsNiArMTAzMywxMSBAQAogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQUU6IHBlZXItc2VuZC1jb25maXJtICV1IiwgV1BBX0dFVF9MRTE2KGRhdGEpKTsKIAorCWlmIChzYWUtPnRtcCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU0FFOiBUZW1wb3JhcnkgZGF0YSBub3QgeWV0IGF2YWlsYWJsZSIpOworCQlyZXR1cm4gLTE7CisJfQorCiAJaWYgKHNhZS0+dG1wLT5lYykKIAkJc2FlX2NuX2NvbmZpcm1fZWNjKHNhZSwgZGF0YSwgc2FlLT5wZWVyX2NvbW1pdF9zY2FsYXIsCiAJCQkJICAgc2FlLT50bXAtPnBlZXJfY29tbWl0X2VsZW1lbnRfZWNjLApAQCAtMTAyOSw3ICsxMDUxLDcgQEAKIAkJCQkgICBzYWUtPnRtcC0+b3duX2NvbW1pdF9lbGVtZW50X2ZmYywKIAkJCQkgICB2ZXJpZmllcik7CiAKLQlpZiAob3NfbWVtY21wKHZlcmlmaWVyLCBkYXRhICsgMiwgU0hBMjU2X01BQ19MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KHZlcmlmaWVyLCBkYXRhICsgMiwgU0hBMjU2X01BQ19MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQUU6IENvbmZpcm0gbWlzbWF0Y2giKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiU0FFOiBSZWNlaXZlZCBjb25maXJtIiwKIAkJCSAgICBkYXRhICsgMiwgU0hBMjU2X01BQ19MRU4pOwpkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi90bmMuaCBiL3NyYy9jb21tb24vdG5jLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTA4YWNmOQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9jb21tb24vdG5jLmgKQEAgLTAsMCArMSwxMjEgQEAKKy8qCisgKiBUTkMgLSBDb21tb24gZGVmaW5lcworICogQ29weXJpZ2h0IChjKSAyMDA3LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIFROQ19ICisjZGVmaW5lIFROQ19ICisKK3R5cGVkZWYgdW5zaWduZWQgbG9uZyBUTkNfVUludDMyOwordHlwZWRlZiB1bnNpZ25lZCBjaGFyICpUTkNfQnVmZmVyUmVmZXJlbmNlOworCit0eXBlZGVmIFROQ19VSW50MzIgVE5DX0lNVklEOwordHlwZWRlZiBUTkNfVUludDMyIFROQ19JTUNJRDsKK3R5cGVkZWYgVE5DX1VJbnQzMiBUTkNfQ29ubmVjdGlvbklEOwordHlwZWRlZiBUTkNfVUludDMyIFROQ19Db25uZWN0aW9uU3RhdGU7Cit0eXBlZGVmIFROQ19VSW50MzIgVE5DX1JldHJ5UmVhc29uOwordHlwZWRlZiBUTkNfVUludDMyIFROQ19JTVZfQWN0aW9uX1JlY29tbWVuZGF0aW9uOwordHlwZWRlZiBUTkNfVUludDMyIFROQ19JTVZfRXZhbHVhdGlvbl9SZXN1bHQ7Cit0eXBlZGVmIFROQ19VSW50MzIgVE5DX01lc3NhZ2VUeXBlOwordHlwZWRlZiBUTkNfTWVzc2FnZVR5cGUgKlROQ19NZXNzYWdlVHlwZUxpc3Q7Cit0eXBlZGVmIFROQ19VSW50MzIgVE5DX1ZlbmRvcklEOwordHlwZWRlZiBUTkNfVUludDMyIFROQ19TdWJ0eXBlOwordHlwZWRlZiBUTkNfVUludDMyIFROQ19NZXNzYWdlU3VidHlwZTsKK3R5cGVkZWYgVE5DX1VJbnQzMiBUTkNfVmVyc2lvbjsKK3R5cGVkZWYgVE5DX1VJbnQzMiBUTkNfUmVzdWx0OwordHlwZWRlZiBUTkNfVUludDMyIFROQ19BdHRyaWJ1dGVJRDsKKwordHlwZWRlZiBUTkNfUmVzdWx0ICgqVE5DX1ROQ1NfQmluZEZ1bmN0aW9uUG9pbnRlcikoCisJVE5DX0lNVklEIGltdklELAorCWNoYXIgKmZ1bmN0aW9uTmFtZSwKKwl2b2lkICoqcE91dGZ1bmN0aW9uUG9pbnRlcik7Cit0eXBlZGVmIFROQ19SZXN1bHQgKCpUTkNfVE5DU19SZXBvcnRNZXNzYWdlVHlwZXNQb2ludGVyKSgKKwlUTkNfSU1WSUQgaW12SUQsCisJVE5DX01lc3NhZ2VUeXBlTGlzdCBzdXBwb3J0ZWRUeXBlcywKKwlUTkNfVUludDMyIHR5cGVDb3VudCk7Cit0eXBlZGVmIFROQ19SZXN1bHQgKCpUTkNfVE5DU19TZW5kTWVzc2FnZVBvaW50ZXIpKAorCVROQ19JTVZJRCBpbXZJRCwKKwlUTkNfQ29ubmVjdGlvbklEIGNvbm5lY3Rpb25JRCwKKwlUTkNfQnVmZmVyUmVmZXJlbmNlIG1lc3NhZ2UsCisJVE5DX1VJbnQzMiBtZXNzYWdlTGVuZ3RoLAorCVROQ19NZXNzYWdlVHlwZSBtZXNzYWdlVHlwZSk7Cit0eXBlZGVmIFROQ19SZXN1bHQgKCpUTkNfVE5DU19SZXF1ZXN0SGFuZHNoYWtlUmV0cnlQb2ludGVyKSgKKwlUTkNfSU1WSUQgaW12SUQsCisJVE5DX0Nvbm5lY3Rpb25JRCBjb25uZWN0aW9uSUQsCisJVE5DX1JldHJ5UmVhc29uIHJlYXNvbik7Cit0eXBlZGVmIFROQ19SZXN1bHQgKCpUTkNfVE5DU19Qcm92aWRlUmVjb21tZW5kYXRpb25Qb2ludGVyKSgKKwlUTkNfSU1WSUQgaW12SUQsCisJVE5DX0Nvbm5lY3Rpb25JRCBjb25uZWN0aW9uSUQsCisJVE5DX0lNVl9BY3Rpb25fUmVjb21tZW5kYXRpb24gcmVjb21tZW5kYXRpb24sCisJVE5DX0lNVl9FdmFsdWF0aW9uX1Jlc3VsdCBldmFsdWF0aW9uKTsKK3R5cGVkZWYgVE5DX1Jlc3VsdCAoKlROQ19UTkNDX0JpbmRGdW5jdGlvblBvaW50ZXIpKAorCVROQ19JTUNJRCBpbWNJRCwKKwljaGFyICpmdW5jdGlvbk5hbWUsCisJdm9pZCAqKnBPdXRmdW5jdGlvblBvaW50ZXIpOwordHlwZWRlZiBUTkNfUmVzdWx0ICgqVE5DX1ROQ0NfU2VuZE1lc3NhZ2VQb2ludGVyKSgKKwlUTkNfSU1DSUQgaW1jSUQsCisJVE5DX0Nvbm5lY3Rpb25JRCBjb25uZWN0aW9uSUQsCisJVE5DX0J1ZmZlclJlZmVyZW5jZSBtZXNzYWdlLAorCVROQ19VSW50MzIgbWVzc2FnZUxlbmd0aCwKKwlUTkNfTWVzc2FnZVR5cGUgbWVzc2FnZVR5cGUpOwordHlwZWRlZiBUTkNfUmVzdWx0ICgqVE5DX1ROQ0NfUmVwb3J0TWVzc2FnZVR5cGVzUG9pbnRlcikoCisJVE5DX0lNQ0lEIGltY0lELAorCVROQ19NZXNzYWdlVHlwZUxpc3Qgc3VwcG9ydGVkVHlwZXMsCisJVE5DX1VJbnQzMiB0eXBlQ291bnQpOwordHlwZWRlZiBUTkNfUmVzdWx0ICgqVE5DX1ROQ0NfUmVxdWVzdEhhbmRzaGFrZVJldHJ5UG9pbnRlcikoCisJVE5DX0lNQ0lEIGltY0lELAorCVROQ19Db25uZWN0aW9uSUQgY29ubmVjdGlvbklELAorCVROQ19SZXRyeVJlYXNvbiByZWFzb24pOworCisjZGVmaW5lIFROQ19JRklNVl9WRVJTSU9OXzEgMQorI2RlZmluZSBUTkNfSUZJTUNfVkVSU0lPTl8xIDEKKworI2RlZmluZSBUTkNfUkVTVUxUX1NVQ0NFU1MgMAorI2RlZmluZSBUTkNfUkVTVUxUX05PVF9JTklUSUFMSVpFRCAxCisjZGVmaW5lIFROQ19SRVNVTFRfQUxSRUFEWV9JTklUSUFMSVpFRCAyCisjZGVmaW5lIFROQ19SRVNVTFRfTk9fQ09NTU9OX1ZFUlNJT04gMworI2RlZmluZSBUTkNfUkVTVUxUX0NBTlRfUkVUUlkgNAorI2RlZmluZSBUTkNfUkVTVUxUX1dPTlRfUkVUUlkgNQorI2RlZmluZSBUTkNfUkVTVUxUX0lOVkFMSURfUEFSQU1FVEVSIDYKKyNkZWZpbmUgVE5DX1JFU1VMVF9DQU5UX1JFU1BPTkQgNworI2RlZmluZSBUTkNfUkVTVUxUX0lMTEVHQUxfT1BFUkFUSU9OIDgKKyNkZWZpbmUgVE5DX1JFU1VMVF9PVEhFUiA5CisjZGVmaW5lIFROQ19SRVNVTFRfRkFUQUwgMTAKKworI2RlZmluZSBUTkNfQ09OTkVDVElPTl9TVEFURV9DUkVBVEUgMAorI2RlZmluZSBUTkNfQ09OTkVDVElPTl9TVEFURV9IQU5EU0hBS0UgMQorI2RlZmluZSBUTkNfQ09OTkVDVElPTl9TVEFURV9BQ0NFU1NfQUxMT1dFRCAyCisjZGVmaW5lIFROQ19DT05ORUNUSU9OX1NUQVRFX0FDQ0VTU19JU09MQVRFRCAzCisjZGVmaW5lIFROQ19DT05ORUNUSU9OX1NUQVRFX0FDQ0VTU19OT05FIDQKKyNkZWZpbmUgVE5DX0NPTk5FQ1RJT05fU1RBVEVfREVMRVRFIDUKKworI2RlZmluZSBUTkNfVkVORE9SSURfQU5ZICgoVE5DX1ZlbmRvcklEKSAweGZmZmZmZikKKyNkZWZpbmUgVE5DX1NVQlRZUEVfQU5ZICgoVE5DX1N1YnR5cGUpIDB4ZmYpCisKKy8qIFROQ0MtVE5DUyBNZXNzYWdlIFR5cGVzICovCisjZGVmaW5lIFROQ19UTkNDU19SRUNPTU1FTkRBVElPTgkJMHgwMDAwMDAwMQorI2RlZmluZSBUTkNfVE5DQ1NfRVJST1IJCQkJMHgwMDAwMDAwMgorI2RlZmluZSBUTkNfVE5DQ1NfUFJFRkVSUkVETEFOR1VBR0UJCTB4MDAwMDAwMDMKKyNkZWZpbmUgVE5DX1ROQ0NTX1JFQVNPTlNUUklOR1MJCQkweDAwMDAwMDA0CisKKy8qIFBvc3NpYmxlIFROQ19JTVZfQWN0aW9uX1JlY29tbWVuZGF0aW9uIHZhbHVlczogKi8KK2VudW0gSU1WX0FjdGlvbl9SZWNvbW1lbmRhdGlvbiB7CisJVE5DX0lNVl9BQ1RJT05fUkVDT01NRU5EQVRJT05fQUxMT1csCisJVE5DX0lNVl9BQ1RJT05fUkVDT01NRU5EQVRJT05fTk9fQUNDRVNTLAorCVROQ19JTVZfQUNUSU9OX1JFQ09NTUVOREFUSU9OX0lTT0xBVEUsCisJVE5DX0lNVl9BQ1RJT05fUkVDT01NRU5EQVRJT05fTk9fUkVDT01NRU5EQVRJT04KK307CisKKy8qIFBvc3NpYmxlIFROQ19JTVZfRXZhbHVhdGlvbl9SZXN1bHQgdmFsdWVzOiAqLworZW51bSBJTVZfRXZhbHVhdGlvbl9SZXN1bHQgeworCVROQ19JTVZfRVZBTFVBVElPTl9SRVNVTFRfQ09NUExJQU5ULAorCVROQ19JTVZfRVZBTFVBVElPTl9SRVNVTFRfTk9OQ09NUExJQU5UX01JTk9SLAorCVROQ19JTVZfRVZBTFVBVElPTl9SRVNVTFRfTk9OQ09NUExJQU5UX01BSk9SLAorCVROQ19JTVZfRVZBTFVBVElPTl9SRVNVTFRfRVJST1IsCisJVE5DX0lNVl9FVkFMVUFUSU9OX1JFU1VMVF9ET05UX0tOT1cKK307CisKKyNlbmRpZiAvKiBUTkNfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi92ZXJzaW9uLmggYi9zcmMvY29tbW9uL3ZlcnNpb24uaAppbmRleCAyZmFhOGM3Li4xZjI1NDMyIDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL3ZlcnNpb24uaAorKysgYi9zcmMvY29tbW9uL3ZlcnNpb24uaApAQCAtNSw2ICs1LDYgQEAKICNkZWZpbmUgVkVSU0lPTl9TVFJfUE9TVEZJWCAiIgogI2VuZGlmIC8qIFZFUlNJT05fU1RSX1BPU1RGSVggKi8KIAotI2RlZmluZSBWRVJTSU9OX1NUUiAiMi4xLWRldmVsIiBWRVJTSU9OX1NUUl9QT1NURklYCisjZGVmaW5lIFZFUlNJT05fU1RSICIyLjMtZGV2ZWwiIFZFUlNJT05fU1RSX1BPU1RGSVgKIAogI2VuZGlmIC8qIFZFUlNJT05fSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi93cGFfY29tbW9uLmMgYi9zcmMvY29tbW9uL3dwYV9jb21tb24uYwppbmRleCBjM2FmYmZkLi45OThhNTFhIDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL3dwYV9jb21tb24uYworKysgYi9zcmMvY29tbW9uL3dwYV9jb21tb24uYwpAQCAtMTQsNiArMTQsNyBAQAogI2luY2x1ZGUgImNyeXB0by9zaGEyNTYuaCIKICNpbmNsdWRlICJjcnlwdG8vYWVzX3dyYXAuaCIKICNpbmNsdWRlICJjcnlwdG8vY3J5cHRvLmgiCisjaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKICNpbmNsdWRlICJpZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJkZWZzLmgiCiAjaW5jbHVkZSAid3BhX2NvbW1vbi5oIgpAQCAtNTYsNiArNTcsMTEgQEAKIAljYXNlIFdQQV9LRVlfSU5GT19UWVBFX0FFU18xMjhfQ01BQzoKIAkJcmV0dXJuIG9tYWMxX2Flc18xMjgoa2V5LCBidWYsIGxlbiwgbWljKTsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiB8fCBDT05GSUdfSUVFRTgwMjExVyAqLworI2lmZGVmIENPTkZJR19IUzIwCisJY2FzZSBXUEFfS0VZX0lORk9fVFlQRV9BS01fREVGSU5FRDoKKwkJLyogRklYOiBUaGlzIHNob3VsZCBiZSBiYXNlZCBvbiBuZWdvdGlhdGVkIEFLTSAqLworCQlyZXR1cm4gb21hYzFfYWVzXzEyOChrZXksIGJ1ZiwgbGVuLCBtaWMpOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJZGVmYXVsdDoKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTM1Myw2ICszNTksMTggQEAKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCWlmIChSU05fU0VMRUNUT1JfR0VUKHMpID09IFJTTl9DSVBIRVJfU1VJVEVfR0NNUCkKIAkJcmV0dXJuIFdQQV9DSVBIRVJfR0NNUDsKKwlpZiAoUlNOX1NFTEVDVE9SX0dFVChzKSA9PSBSU05fQ0lQSEVSX1NVSVRFX0NDTVBfMjU2KQorCQlyZXR1cm4gV1BBX0NJUEhFUl9DQ01QXzI1NjsKKwlpZiAoUlNOX1NFTEVDVE9SX0dFVChzKSA9PSBSU05fQ0lQSEVSX1NVSVRFX0dDTVBfMjU2KQorCQlyZXR1cm4gV1BBX0NJUEhFUl9HQ01QXzI1NjsKKwlpZiAoUlNOX1NFTEVDVE9SX0dFVChzKSA9PSBSU05fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzEyOCkKKwkJcmV0dXJuIFdQQV9DSVBIRVJfQklQX0dNQUNfMTI4OworCWlmIChSU05fU0VMRUNUT1JfR0VUKHMpID09IFJTTl9DSVBIRVJfU1VJVEVfQklQX0dNQUNfMjU2KQorCQlyZXR1cm4gV1BBX0NJUEhFUl9CSVBfR01BQ18yNTY7CisJaWYgKFJTTl9TRUxFQ1RPUl9HRVQocykgPT0gUlNOX0NJUEhFUl9TVUlURV9CSVBfQ01BQ18yNTYpCisJCXJldHVybiBXUEFfQ0lQSEVSX0JJUF9DTUFDXzI1NjsKKwlpZiAoUlNOX1NFTEVDVE9SX0dFVChzKSA9PSBSU05fQ0lQSEVSX1NVSVRFX05PX0dST1VQX0FERFJFU1NFRCkKKwkJcmV0dXJuIFdQQV9DSVBIRVJfR1RLX05PVF9VU0VEOwogCXJldHVybiAwOwogfQogCkBAIC0zODUsNiArNDAzLDI2IEBACiB9CiAKIAorc3RhdGljIGludCB3cGFfY2lwaGVyX3ZhbGlkX2dyb3VwKGludCBjaXBoZXIpCit7CisJcmV0dXJuIHdwYV9jaXBoZXJfdmFsaWRfcGFpcndpc2UoY2lwaGVyKSB8fAorCQljaXBoZXIgPT0gV1BBX0NJUEhFUl9XRVAxMDQgfHwKKwkJY2lwaGVyID09IFdQQV9DSVBIRVJfV0VQNDAgfHwKKwkJY2lwaGVyID09IFdQQV9DSVBIRVJfR1RLX05PVF9VU0VEOworfQorCisKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExVworaW50IHdwYV9jaXBoZXJfdmFsaWRfbWdtdF9ncm91cChpbnQgY2lwaGVyKQoreworCXJldHVybiBjaXBoZXIgPT0gV1BBX0NJUEhFUl9BRVNfMTI4X0NNQUMgfHwKKwkJY2lwaGVyID09IFdQQV9DSVBIRVJfQklQX0dNQUNfMTI4IHx8CisJCWNpcGhlciA9PSBXUEFfQ0lQSEVSX0JJUF9HTUFDXzI1NiB8fAorCQljaXBoZXIgPT0gV1BBX0NJUEhFUl9CSVBfQ01BQ18yNTY7Cit9CisjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KKworCiAvKioKICAqIHdwYV9wYXJzZV93cGFfaWVfcnNuIC0gUGFyc2UgUlNOIElFCiAgKiBAcnNuX2llOiBCdWZmZXIgY29udGFpbmluZyBSU04gSUUKQEAgLTQ0MCwxMyArNDc4LDExIEBACiAKIAlpZiAobGVmdCA+PSBSU05fU0VMRUNUT1JfTEVOKSB7CiAJCWRhdGEtPmdyb3VwX2NpcGhlciA9IHJzbl9zZWxlY3Rvcl90b19iaXRmaWVsZChwb3MpOwotI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCi0JCWlmIChkYXRhLT5ncm91cF9jaXBoZXIgPT0gV1BBX0NJUEhFUl9BRVNfMTI4X0NNQUMpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IEFFUy0xMjgtQ01BQyB1c2VkIGFzIGdyb3VwICIKLQkJCQkgICAiY2lwaGVyIiwgX19mdW5jX18pOworCQlpZiAoIXdwYV9jaXBoZXJfdmFsaWRfZ3JvdXAoZGF0YS0+Z3JvdXBfY2lwaGVyKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogaW52YWxpZCBncm91cCBjaXBoZXIgMHgleCIsCisJCQkJICAgX19mdW5jX18sIGRhdGEtPmdyb3VwX2NpcGhlcik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KLSNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCQlwb3MgKz0gUlNOX1NFTEVDVE9SX0xFTjsKIAkJbGVmdCAtPSBSU05fU0VMRUNUT1JfTEVOOwogCX0gZWxzZSBpZiAobGVmdCA+IDApIHsKQEAgLTUzMSw3ICs1NjcsNyBAQAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJaWYgKGxlZnQgPj0gNCkgewogCQlkYXRhLT5tZ210X2dyb3VwX2NpcGhlciA9IHJzbl9zZWxlY3Rvcl90b19iaXRmaWVsZChwb3MpOwotCQlpZiAoZGF0YS0+bWdtdF9ncm91cF9jaXBoZXIgIT0gV1BBX0NJUEhFUl9BRVNfMTI4X0NNQUMpIHsKKwkJaWYgKCF3cGFfY2lwaGVyX3ZhbGlkX21nbXRfZ3JvdXAoZGF0YS0+bWdtdF9ncm91cF9jaXBoZXIpKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBVbnN1cHBvcnRlZCBtYW5hZ2VtZW50ICIKIAkJCQkgICAiZ3JvdXAgY2lwaGVyIDB4JXgiLCBfX2Z1bmNfXywKIAkJCQkgICBkYXRhLT5tZ210X2dyb3VwX2NpcGhlcik7CkBAIC01NDMsOCArNTc5LDkgQEAKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCiAJaWYgKGxlZnQgPiAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGllIGhhcyAldSB0cmFpbGluZyBieXRlcyAtIGlnbm9yZWQiLAotCQkJICAgX19mdW5jX18sIGxlZnQpOworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsCisJCQkgICAgIndwYV9wYXJzZV93cGFfaWVfcnNuOiBpZ25vcmUgdHJhaWxpbmcgYnl0ZXMiLAorCQkJICAgIHBvcywgbGVmdCk7CiAJfQogCiAJcmV0dXJuIDA7CkBAIC02ODEsOCArNzE4LDkgQEAKIAl9CiAKIAlpZiAobGVmdCA+IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogaWUgaGFzICV1IHRyYWlsaW5nIGJ5dGVzIC0gaWdub3JlZCIsCi0JCQkgICBfX2Z1bmNfXywgbGVmdCk7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywKKwkJCSAgICAid3BhX3BhcnNlX3dwYV9pZV93cGE6IGlnbm9yZSB0cmFpbGluZyBieXRlcyIsCisJCQkgICAgcG9zLCBsZWZ0KTsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTkxMiw2ICs5NTAsMTIgQEAKIAkJcmV0dXJuICJDQ01QK1RLSVAiOwogCWNhc2UgV1BBX0NJUEhFUl9HQ01QOgogCQlyZXR1cm4gIkdDTVAiOworCWNhc2UgV1BBX0NJUEhFUl9HQ01QXzI1NjoKKwkJcmV0dXJuICJHQ01QLTI1NiI7CisJY2FzZSBXUEFfQ0lQSEVSX0NDTVBfMjU2OgorCQlyZXR1cm4gIkNDTVAtMjU2IjsKKwljYXNlIFdQQV9DSVBIRVJfR1RLX05PVF9VU0VEOgorCQlyZXR1cm4gIkdUS19OT1RfVVNFRCI7CiAJZGVmYXVsdDoKIAkJcmV0dXJuICJVTktOT1dOIjsKIAl9CkBAIC05NTksNiArMTAwMywzMCBAQAogfQogCiAKK3UzMiB3cGFfYWttX3RvX3N1aXRlKGludCBha20pCit7CisJaWYgKGFrbSAmIFdQQV9LRVlfTUdNVF9GVF9JRUVFODAyMVgpCisJCXJldHVybiBXTEFOX0FLTV9TVUlURV9GVF84MDIxWDsKKwlpZiAoYWttICYgV1BBX0tFWV9NR01UX0ZUX1BTSykKKwkJcmV0dXJuIFdMQU5fQUtNX1NVSVRFX0ZUX1BTSzsKKwlpZiAoYWttICYgV1BBX0tFWV9NR01UX0lFRUU4MDIxWCkKKwkJcmV0dXJuIFdMQU5fQUtNX1NVSVRFXzgwMjFYOworCWlmIChha20gJiBXUEFfS0VZX01HTVRfSUVFRTgwMjFYX1NIQTI1NikKKwkJcmV0dXJuIFdMQU5fQUtNX1NVSVRFXzgwMjFYX1NIQTI1NjsKKwlpZiAoYWttICYgV1BBX0tFWV9NR01UX0lFRUU4MDIxWCkKKwkJcmV0dXJuIFdMQU5fQUtNX1NVSVRFXzgwMjFYOworCWlmIChha20gJiBXUEFfS0VZX01HTVRfUFNLX1NIQTI1NikKKwkJcmV0dXJuIFdMQU5fQUtNX1NVSVRFX1BTS19TSEEyNTY7CisJaWYgKGFrbSAmIFdQQV9LRVlfTUdNVF9QU0spCisJCXJldHVybiBXTEFOX0FLTV9TVUlURV9QU0s7CisJaWYgKGFrbSAmIFdQQV9LRVlfTUdNVF9DQ0tNKQorCQlyZXR1cm4gV0xBTl9BS01fU1VJVEVfQ0NLTTsKKwlpZiAoYWttICYgV1BBX0tFWV9NR01UX09TRU4pCisJCXJldHVybiBXTEFOX0FLTV9TVUlURV9PU0VOOworCXJldHVybiAwOworfQorCisKIGludCB3cGFfY29tcGFyZV9yc25faWUoaW50IGZ0X2luaXRpYWxfYXNzb2MsCiAJCSAgICAgICBjb25zdCB1OCAqaWUxLCBzaXplX3QgaWUxbGVuLAogCQkgICAgICAgY29uc3QgdTggKmllMiwgc2l6ZV90IGllMmxlbikKQEAgLTEwNzgsOCArMTE0NiwxNSBAQAogaW50IHdwYV9jaXBoZXJfa2V5X2xlbihpbnQgY2lwaGVyKQogewogCXN3aXRjaCAoY2lwaGVyKSB7CisJY2FzZSBXUEFfQ0lQSEVSX0NDTVBfMjU2OgorCWNhc2UgV1BBX0NJUEhFUl9HQ01QXzI1NjoKKwljYXNlIFdQQV9DSVBIRVJfQklQX0dNQUNfMjU2OgorCWNhc2UgV1BBX0NJUEhFUl9CSVBfQ01BQ18yNTY6CisJCXJldHVybiAzMjsKIAljYXNlIFdQQV9DSVBIRVJfQ0NNUDoKIAljYXNlIFdQQV9DSVBIRVJfR0NNUDoKKwljYXNlIFdQQV9DSVBIRVJfQUVTXzEyOF9DTUFDOgorCWNhc2UgV1BBX0NJUEhFUl9CSVBfR01BQ18xMjg6CiAJCXJldHVybiAxNjsKIAljYXNlIFdQQV9DSVBIRVJfVEtJUDoKIAkJcmV0dXJuIDMyOwpAQCAtMTA5Niw2ICsxMTcxLDggQEAKIGludCB3cGFfY2lwaGVyX3JzY19sZW4oaW50IGNpcGhlcikKIHsKIAlzd2l0Y2ggKGNpcGhlcikgeworCWNhc2UgV1BBX0NJUEhFUl9DQ01QXzI1NjoKKwljYXNlIFdQQV9DSVBIRVJfR0NNUF8yNTY6CiAJY2FzZSBXUEFfQ0lQSEVSX0NDTVA6CiAJY2FzZSBXUEFfQ0lQSEVSX0dDTVA6CiAJY2FzZSBXUEFfQ0lQSEVSX1RLSVA6CkBAIC0xMTEyLDYgKzExODksMTAgQEAKIGludCB3cGFfY2lwaGVyX3RvX2FsZyhpbnQgY2lwaGVyKQogewogCXN3aXRjaCAoY2lwaGVyKSB7CisJY2FzZSBXUEFfQ0lQSEVSX0NDTVBfMjU2OgorCQlyZXR1cm4gV1BBX0FMR19DQ01QXzI1NjsKKwljYXNlIFdQQV9DSVBIRVJfR0NNUF8yNTY6CisJCXJldHVybiBXUEFfQUxHX0dDTVBfMjU2OwogCWNhc2UgV1BBX0NJUEhFUl9DQ01QOgogCQlyZXR1cm4gV1BBX0FMR19DQ01QOwogCWNhc2UgV1BBX0NJUEhFUl9HQ01QOgpAQCAtMTEyMSwzNCArMTIwMiwyNCBAQAogCWNhc2UgV1BBX0NJUEhFUl9XRVAxMDQ6CiAJY2FzZSBXUEFfQ0lQSEVSX1dFUDQwOgogCQlyZXR1cm4gV1BBX0FMR19XRVA7CisJY2FzZSBXUEFfQ0lQSEVSX0FFU18xMjhfQ01BQzoKKwkJcmV0dXJuIFdQQV9BTEdfSUdUSzsKKwljYXNlIFdQQV9DSVBIRVJfQklQX0dNQUNfMTI4OgorCQlyZXR1cm4gV1BBX0FMR19CSVBfR01BQ18xMjg7CisJY2FzZSBXUEFfQ0lQSEVSX0JJUF9HTUFDXzI1NjoKKwkJcmV0dXJuIFdQQV9BTEdfQklQX0dNQUNfMjU2OworCWNhc2UgV1BBX0NJUEhFUl9CSVBfQ01BQ18yNTY6CisJCXJldHVybiBXUEFfQUxHX0JJUF9DTUFDXzI1NjsKIAl9CiAJcmV0dXJuIFdQQV9BTEdfTk9ORTsKIH0KIAogCi1lbnVtIHdwYV9jaXBoZXIgd3BhX2NpcGhlcl90b19zdWl0ZV9kcml2ZXIoaW50IGNpcGhlcikKLXsKLQlzd2l0Y2ggKGNpcGhlcikgewotCWNhc2UgV1BBX0NJUEhFUl9OT05FOgotCQlyZXR1cm4gQ0lQSEVSX05PTkU7Ci0JY2FzZSBXUEFfQ0lQSEVSX1dFUDQwOgotCQlyZXR1cm4gQ0lQSEVSX1dFUDQwOwotCWNhc2UgV1BBX0NJUEhFUl9XRVAxMDQ6Ci0JCXJldHVybiBDSVBIRVJfV0VQMTA0OwotCWNhc2UgV1BBX0NJUEhFUl9DQ01QOgotCQlyZXR1cm4gQ0lQSEVSX0NDTVA7Ci0JY2FzZSBXUEFfQ0lQSEVSX0dDTVA6Ci0JCXJldHVybiBDSVBIRVJfR0NNUDsKLQljYXNlIFdQQV9DSVBIRVJfVEtJUDoKLQlkZWZhdWx0OgotCQlyZXR1cm4gQ0lQSEVSX1RLSVA7Ci0JfQotfQotCi0KIGludCB3cGFfY2lwaGVyX3ZhbGlkX3BhaXJ3aXNlKGludCBjaXBoZXIpCiB7Ci0JcmV0dXJuIGNpcGhlciA9PSBXUEFfQ0lQSEVSX0NDTVAgfHwKKwlyZXR1cm4gY2lwaGVyID09IFdQQV9DSVBIRVJfQ0NNUF8yNTYgfHwKKwkJY2lwaGVyID09IFdQQV9DSVBIRVJfR0NNUF8yNTYgfHwKKwkJY2lwaGVyID09IFdQQV9DSVBIRVJfQ0NNUCB8fAogCQljaXBoZXIgPT0gV1BBX0NJUEhFUl9HQ01QIHx8CiAJCWNpcGhlciA9PSBXUEFfQ0lQSEVSX1RLSVA7CiB9CkBAIC0xMTU2LDYgKzEyMjcsMTAgQEAKIAogdTMyIHdwYV9jaXBoZXJfdG9fc3VpdGUoaW50IHByb3RvLCBpbnQgY2lwaGVyKQogeworCWlmIChjaXBoZXIgJiBXUEFfQ0lQSEVSX0NDTVBfMjU2KQorCQlyZXR1cm4gUlNOX0NJUEhFUl9TVUlURV9DQ01QXzI1NjsKKwlpZiAoY2lwaGVyICYgV1BBX0NJUEhFUl9HQ01QXzI1NikKKwkJcmV0dXJuIFJTTl9DSVBIRVJfU1VJVEVfR0NNUF8yNTY7CiAJaWYgKGNpcGhlciAmIFdQQV9DSVBIRVJfQ0NNUCkKIAkJcmV0dXJuIChwcm90byA9PSBXUEFfUFJPVE9fUlNOID8KIAkJCVJTTl9DSVBIRVJfU1VJVEVfQ0NNUCA6IFdQQV9DSVBIRVJfU1VJVEVfQ0NNUCk7CkBAIC0xMTczLDY1ICsxMjQ4LDgwIEBACiAJaWYgKGNpcGhlciAmIFdQQV9DSVBIRVJfTk9ORSkKIAkJcmV0dXJuIChwcm90byA9PSBXUEFfUFJPVE9fUlNOID8KIAkJCVJTTl9DSVBIRVJfU1VJVEVfTk9ORSA6IFdQQV9DSVBIRVJfU1VJVEVfTk9ORSk7CisJaWYgKGNpcGhlciAmIFdQQV9DSVBIRVJfR1RLX05PVF9VU0VEKQorCQlyZXR1cm4gUlNOX0NJUEhFUl9TVUlURV9OT19HUk9VUF9BRERSRVNTRUQ7CisJaWYgKGNpcGhlciAmIFdQQV9DSVBIRVJfQUVTXzEyOF9DTUFDKQorCQlyZXR1cm4gUlNOX0NJUEhFUl9TVUlURV9BRVNfMTI4X0NNQUM7CisJaWYgKGNpcGhlciAmIFdQQV9DSVBIRVJfQklQX0dNQUNfMTI4KQorCQlyZXR1cm4gUlNOX0NJUEhFUl9TVUlURV9CSVBfR01BQ18xMjg7CisJaWYgKGNpcGhlciAmIFdQQV9DSVBIRVJfQklQX0dNQUNfMjU2KQorCQlyZXR1cm4gUlNOX0NJUEhFUl9TVUlURV9CSVBfR01BQ18yNTY7CisJaWYgKGNpcGhlciAmIFdQQV9DSVBIRVJfQklQX0NNQUNfMjU2KQorCQlyZXR1cm4gUlNOX0NJUEhFUl9TVUlURV9CSVBfQ01BQ18yNTY7CiAJcmV0dXJuIDA7CiB9CiAKIAotaW50IHJzbl9jaXBoZXJfcHV0X3N1aXRlcyh1OCAqcG9zLCBpbnQgY2lwaGVycykKK2ludCByc25fY2lwaGVyX3B1dF9zdWl0ZXModTggKnN0YXJ0LCBpbnQgY2lwaGVycykKIHsKLQlpbnQgbnVtX3N1aXRlcyA9IDA7CisJdTggKnBvcyA9IHN0YXJ0OwogCisJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0NDTVBfMjU2KSB7CisJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX0NDTVBfMjU2KTsKKwkJcG9zICs9IFJTTl9TRUxFQ1RPUl9MRU47CisJfQorCWlmIChjaXBoZXJzICYgV1BBX0NJUEhFUl9HQ01QXzI1NikgeworCQlSU05fU0VMRUNUT1JfUFVUKHBvcywgUlNOX0NJUEhFUl9TVUlURV9HQ01QXzI1Nik7CisJCXBvcyArPSBSU05fU0VMRUNUT1JfTEVOOworCX0KIAlpZiAoY2lwaGVycyAmIFdQQV9DSVBIRVJfQ0NNUCkgewogCQlSU05fU0VMRUNUT1JfUFVUKHBvcywgUlNOX0NJUEhFUl9TVUlURV9DQ01QKTsKIAkJcG9zICs9IFJTTl9TRUxFQ1RPUl9MRU47Ci0JCW51bV9zdWl0ZXMrKzsKIAl9CiAJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0dDTVApIHsKIAkJUlNOX1NFTEVDVE9SX1BVVChwb3MsIFJTTl9DSVBIRVJfU1VJVEVfR0NNUCk7CiAJCXBvcyArPSBSU05fU0VMRUNUT1JfTEVOOwotCQludW1fc3VpdGVzKys7CiAJfQogCWlmIChjaXBoZXJzICYgV1BBX0NJUEhFUl9US0lQKSB7CiAJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX1RLSVApOwogCQlwb3MgKz0gUlNOX1NFTEVDVE9SX0xFTjsKLQkJbnVtX3N1aXRlcysrOwogCX0KIAlpZiAoY2lwaGVycyAmIFdQQV9DSVBIRVJfTk9ORSkgewogCQlSU05fU0VMRUNUT1JfUFVUKHBvcywgUlNOX0NJUEhFUl9TVUlURV9OT05FKTsKIAkJcG9zICs9IFJTTl9TRUxFQ1RPUl9MRU47Ci0JCW51bV9zdWl0ZXMrKzsKIAl9CiAKLQlyZXR1cm4gbnVtX3N1aXRlczsKKwlyZXR1cm4gKHBvcyAtIHN0YXJ0KSAvIFJTTl9TRUxFQ1RPUl9MRU47CiB9CiAKIAotaW50IHdwYV9jaXBoZXJfcHV0X3N1aXRlcyh1OCAqcG9zLCBpbnQgY2lwaGVycykKK2ludCB3cGFfY2lwaGVyX3B1dF9zdWl0ZXModTggKnN0YXJ0LCBpbnQgY2lwaGVycykKIHsKLQlpbnQgbnVtX3N1aXRlcyA9IDA7CisJdTggKnBvcyA9IHN0YXJ0OwogCiAJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0NDTVApIHsKIAkJUlNOX1NFTEVDVE9SX1BVVChwb3MsIFdQQV9DSVBIRVJfU1VJVEVfQ0NNUCk7CiAJCXBvcyArPSBXUEFfU0VMRUNUT1JfTEVOOwotCQludW1fc3VpdGVzKys7CiAJfQogCWlmIChjaXBoZXJzICYgV1BBX0NJUEhFUl9US0lQKSB7CiAJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBXUEFfQ0lQSEVSX1NVSVRFX1RLSVApOwogCQlwb3MgKz0gV1BBX1NFTEVDVE9SX0xFTjsKLQkJbnVtX3N1aXRlcysrOwogCX0KIAlpZiAoY2lwaGVycyAmIFdQQV9DSVBIRVJfTk9ORSkgewogCQlSU05fU0VMRUNUT1JfUFVUKHBvcywgV1BBX0NJUEhFUl9TVUlURV9OT05FKTsKIAkJcG9zICs9IFdQQV9TRUxFQ1RPUl9MRU47Ci0JCW51bV9zdWl0ZXMrKzsKIAl9CiAKLQlyZXR1cm4gbnVtX3N1aXRlczsKKwlyZXR1cm4gKHBvcyAtIHN0YXJ0KSAvIFJTTl9TRUxFQ1RPUl9MRU47CiB9CiAKIAogaW50IHdwYV9waWNrX3BhaXJ3aXNlX2NpcGhlcihpbnQgY2lwaGVycywgaW50IG5vbmVfYWxsb3dlZCkKIHsKKwlpZiAoY2lwaGVycyAmIFdQQV9DSVBIRVJfQ0NNUF8yNTYpCisJCXJldHVybiBXUEFfQ0lQSEVSX0NDTVBfMjU2OworCWlmIChjaXBoZXJzICYgV1BBX0NJUEhFUl9HQ01QXzI1NikKKwkJcmV0dXJuIFdQQV9DSVBIRVJfR0NNUF8yNTY7CiAJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0NDTVApCiAJCXJldHVybiBXUEFfQ0lQSEVSX0NDTVA7CiAJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0dDTVApCkBAIC0xMjQ2LDEwICsxMzM2LDE2IEBACiAKIGludCB3cGFfcGlja19ncm91cF9jaXBoZXIoaW50IGNpcGhlcnMpCiB7CisJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0NDTVBfMjU2KQorCQlyZXR1cm4gV1BBX0NJUEhFUl9DQ01QXzI1NjsKKwlpZiAoY2lwaGVycyAmIFdQQV9DSVBIRVJfR0NNUF8yNTYpCisJCXJldHVybiBXUEFfQ0lQSEVSX0dDTVBfMjU2OwogCWlmIChjaXBoZXJzICYgV1BBX0NJUEhFUl9DQ01QKQogCQlyZXR1cm4gV1BBX0NJUEhFUl9DQ01QOwogCWlmIChjaXBoZXJzICYgV1BBX0NJUEhFUl9HQ01QKQogCQlyZXR1cm4gV1BBX0NJUEhFUl9HQ01QOworCWlmIChjaXBoZXJzICYgV1BBX0NJUEhFUl9HVEtfTk9UX1VTRUQpCisJCXJldHVybiBXUEFfQ0lQSEVSX0dUS19OT1RfVVNFRDsKIAlpZiAoY2lwaGVycyAmIFdQQV9DSVBIRVJfVEtJUCkKIAkJcmV0dXJuIFdQQV9DSVBIRVJfVEtJUDsKIAlpZiAoY2lwaGVycyAmIFdQQV9DSVBIRVJfV0VQMTA0KQpAQCAtMTI4MCw3ICsxMzc2LDExIEBACiAJCQllbmQrKzsKIAkJbGFzdCA9ICplbmQgPT0gJ1wwJzsKIAkJKmVuZCA9ICdcMCc7Ci0JCWlmIChvc19zdHJjbXAoc3RhcnQsICJDQ01QIikgPT0gMCkKKwkJaWYgKG9zX3N0cmNtcChzdGFydCwgIkNDTVAtMjU2IikgPT0gMCkKKwkJCXZhbCB8PSBXUEFfQ0lQSEVSX0NDTVBfMjU2OworCQllbHNlIGlmIChvc19zdHJjbXAoc3RhcnQsICJHQ01QLTI1NiIpID09IDApCisJCQl2YWwgfD0gV1BBX0NJUEhFUl9HQ01QXzI1NjsKKwkJZWxzZSBpZiAob3Nfc3RyY21wKHN0YXJ0LCAiQ0NNUCIpID09IDApCiAJCQl2YWwgfD0gV1BBX0NJUEhFUl9DQ01QOwogCQllbHNlIGlmIChvc19zdHJjbXAoc3RhcnQsICJHQ01QIikgPT0gMCkKIAkJCXZhbCB8PSBXUEFfQ0lQSEVSX0dDTVA7CkBAIC0xMjkyLDYgKzEzOTIsOCBAQAogCQkJdmFsIHw9IFdQQV9DSVBIRVJfV0VQNDA7CiAJCWVsc2UgaWYgKG9zX3N0cmNtcChzdGFydCwgIk5PTkUiKSA9PSAwKQogCQkJdmFsIHw9IFdQQV9DSVBIRVJfTk9ORTsKKwkJZWxzZSBpZiAob3Nfc3RyY21wKHN0YXJ0LCAiR1RLX05PVF9VU0VEIikgPT0gMCkKKwkJCXZhbCB8PSBXUEFfQ0lQSEVSX0dUS19OT1RfVVNFRDsKIAkJZWxzZSB7CiAJCQlvc19mcmVlKGJ1Zik7CiAJCQlyZXR1cm4gLTE7CkBAIC0xMzEyLDYgKzE0MTQsMjAgQEAKIAljaGFyICpwb3MgPSBzdGFydDsKIAlpbnQgcmV0OwogCisJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0NDTVBfMjU2KSB7CisJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNDQ01QLTI1NiIsCisJCQkJICBwb3MgPT0gc3RhcnQgPyAiIiA6IGRlbGltKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCXJldHVybiAtMTsKKwkJcG9zICs9IHJldDsKKwl9CisJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0dDTVBfMjU2KSB7CisJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNHQ01QLTI1NiIsCisJCQkJICBwb3MgPT0gc3RhcnQgPyAiIiA6IGRlbGltKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCXJldHVybiAtMTsKKwkJcG9zICs9IHJldDsKKwl9CiAJaWYgKGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0NDTVApIHsKIAkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0NDTVAiLAogCQkJCSAgcG9zID09IHN0YXJ0ID8gIiIgOiBkZWxpbSk7CkBAIC0xMzczLDUgKzE0ODksODYgQEAKIAkJcmV0dXJuIFdQQV9DSVBIRVJfVEtJUDsKIAlpZiAoKHBhaXJ3aXNlICYgKFdQQV9DSVBIRVJfQ0NNUCB8IFdQQV9DSVBIRVJfR0NNUCkpID09IFdQQV9DSVBIRVJfR0NNUCkKIAkJcmV0dXJuIFdQQV9DSVBIRVJfR0NNUDsKKwlpZiAoKHBhaXJ3aXNlICYgKFdQQV9DSVBIRVJfR0NNUF8yNTYgfCBXUEFfQ0lQSEVSX0NDTVAgfAorCQkJIFdQQV9DSVBIRVJfR0NNUCkpID09IFdQQV9DSVBIRVJfR0NNUF8yNTYpCisJCXJldHVybiBXUEFfQ0lQSEVSX0dDTVBfMjU2OworCWlmICgocGFpcndpc2UgJiAoV1BBX0NJUEhFUl9DQ01QXzI1NiB8IFdQQV9DSVBIRVJfQ0NNUCB8CisJCQkgV1BBX0NJUEhFUl9HQ01QKSkgPT0gV1BBX0NJUEhFUl9DQ01QXzI1NikKKwkJcmV0dXJuIFdQQV9DSVBIRVJfQ0NNUF8yNTY7CiAJcmV0dXJuIFdQQV9DSVBIRVJfQ0NNUDsKIH0KKworCitzdGF0aWMgaW50IHdwYV9jaGVja193b3dsYW5fdHJpZ2dlcihjb25zdCBjaGFyICpzdGFydCwgY29uc3QgY2hhciAqdHJpZ2dlciwKKwkJCQkgICAgaW50IGNhcGFfdHJpZ2dlciwgdTggKnBhcmFtX3RyaWdnZXIpCit7CisJaWYgKG9zX3N0cmNtcChzdGFydCwgdHJpZ2dlcikgIT0gMCkKKwkJcmV0dXJuIDA7CisJaWYgKCFjYXBhX3RyaWdnZXIpCisJCXJldHVybiAwOworCisJKnBhcmFtX3RyaWdnZXIgPSAxOworCXJldHVybiAxOworfQorCisKK3N0cnVjdCB3b3dsYW5fdHJpZ2dlcnMgKndwYV9nZXRfd293bGFuX3RyaWdnZXJzKGNvbnN0IGNoYXIgKndvd2xhbl90cmlnZ2VycywKKwkJCQkJCXN0cnVjdCB3cGFfZHJpdmVyX2NhcGEgKmNhcGEpCit7CisJc3RydWN0IHdvd2xhbl90cmlnZ2VycyAqdHJpZ2dlcnM7CisJY2hhciAqc3RhcnQsICplbmQsICpidWY7CisJaW50IGxhc3Q7CisKKwlpZiAoIXdvd2xhbl90cmlnZ2VycykKKwkJcmV0dXJuIE5VTEw7CisKKwlidWYgPSBvc19zdHJkdXAod293bGFuX3RyaWdnZXJzKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJdHJpZ2dlcnMgPSBvc196YWxsb2Moc2l6ZW9mKCp0cmlnZ2VycykpOworCWlmICh0cmlnZ2VycyA9PSBOVUxMKQorCQlnb3RvIG91dDsKKworI2RlZmluZSBDSEVDS19UUklHR0VSKHRyaWdnZXIpIFwKKwl3cGFfY2hlY2tfd293bGFuX3RyaWdnZXIoc3RhcnQsICN0cmlnZ2VyLAkJCVwKKwkJCQkgIGNhcGEtPndvd2xhbl90cmlnZ2Vycy50cmlnZ2VyLAlcCisJCQkJICAmdHJpZ2dlcnMtPnRyaWdnZXIpCisKKwlzdGFydCA9IGJ1ZjsKKwl3aGlsZSAoKnN0YXJ0ICE9ICdcMCcpIHsKKwkJd2hpbGUgKGlzYmxhbmsoKnN0YXJ0KSkKKwkJCXN0YXJ0Kys7CisJCWlmICgqc3RhcnQgPT0gJ1wwJykKKwkJCWJyZWFrOworCQllbmQgPSBzdGFydDsKKwkJd2hpbGUgKCFpc2JsYW5rKCplbmQpICYmICplbmQgIT0gJ1wwJykKKwkJCWVuZCsrOworCQlsYXN0ID0gKmVuZCA9PSAnXDAnOworCQkqZW5kID0gJ1wwJzsKKworCQlpZiAoIUNIRUNLX1RSSUdHRVIoYW55KSAmJgorCQkgICAgIUNIRUNLX1RSSUdHRVIoZGlzY29ubmVjdCkgJiYKKwkJICAgICFDSEVDS19UUklHR0VSKG1hZ2ljX3BrdCkgJiYKKwkJICAgICFDSEVDS19UUklHR0VSKGd0a19yZWtleV9mYWlsdXJlKSAmJgorCQkgICAgIUNIRUNLX1RSSUdHRVIoZWFwX2lkZW50aXR5X3JlcSkgJiYKKwkJICAgICFDSEVDS19UUklHR0VSKGZvdXJfd2F5X2hhbmRzaGFrZSkgJiYKKwkJICAgICFDSEVDS19UUklHR0VSKHJma2lsbF9yZWxlYXNlKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkJICAgIlVua25vd24vdW5zdXBwb3J0ZWQgd293bGFuIHRyaWdnZXIgJyVzJyIsCisJCQkJICAgc3RhcnQpOworCQkJb3NfZnJlZSh0cmlnZ2Vycyk7CisJCQl0cmlnZ2VycyA9IE5VTEw7CisJCQlnb3RvIG91dDsKKwkJfQorCisJCWlmIChsYXN0KQorCQkJYnJlYWs7CisJCXN0YXJ0ID0gZW5kICsgMTsKKwl9CisjdW5kZWYgQ0hFQ0tfVFJJR0dFUgorCitvdXQ6CisJb3NfZnJlZShidWYpOworCXJldHVybiB0cmlnZ2VyczsKK30KZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vd3BhX2NvbW1vbi5oIGIvc3JjL2NvbW1vbi93cGFfY29tbW9uLmgKaW5kZXggMmQ2MzY2Mi4uMGVmNWE5ZCAxMDA2NDQKLS0tIGEvc3JjL2NvbW1vbi93cGFfY29tbW9uLmgKKysrIGIvc3JjL2NvbW1vbi93cGFfY29tbW9uLmgKQEAgLTIxLDEwICsyMSwxMiBAQAogI2RlZmluZSBXUEFfR1RLX01BWF9MRU4gMzIKIAogI2RlZmluZSBXUEFfQUxMT1dFRF9QQUlSV0lTRV9DSVBIRVJTIFwKLShXUEFfQ0lQSEVSX0NDTVAgfCBXUEFfQ0lQSEVSX0dDTVAgfCBXUEFfQ0lQSEVSX1RLSVAgfCBXUEFfQ0lQSEVSX05PTkUpCisoV1BBX0NJUEhFUl9DQ01QIHwgV1BBX0NJUEhFUl9HQ01QIHwgV1BBX0NJUEhFUl9US0lQIHwgV1BBX0NJUEhFUl9OT05FIHwgXAorV1BBX0NJUEhFUl9HQ01QXzI1NiB8IFdQQV9DSVBIRVJfQ0NNUF8yNTYpCiAjZGVmaW5lIFdQQV9BTExPV0VEX0dST1VQX0NJUEhFUlMgXAogKFdQQV9DSVBIRVJfQ0NNUCB8IFdQQV9DSVBIRVJfR0NNUCB8IFdQQV9DSVBIRVJfVEtJUCB8IFdQQV9DSVBIRVJfV0VQMTA0IHwgXAotV1BBX0NJUEhFUl9XRVA0MCkKK1dQQV9DSVBIRVJfV0VQNDAgfCBXUEFfQ0lQSEVSX0dDTVBfMjU2IHwgV1BBX0NJUEhFUl9DQ01QXzI1NiB8IFwKK1dQQV9DSVBIRVJfR1RLX05PVF9VU0VEKQogCiAjZGVmaW5lIFdQQV9TRUxFQ1RPUl9MRU4gNAogI2RlZmluZSBXUEFfVkVSU0lPTiAxCkBAIC02MCw3ICs2MiwxMiBAQAogI2RlZmluZSBSU05fQVVUSF9LRVlfTUdNVF9UUEtfSEFORFNIQUtFIFJTTl9TRUxFQ1RPUigweDAwLCAweDBmLCAweGFjLCA3KQogI2RlZmluZSBSU05fQVVUSF9LRVlfTUdNVF9TQUUgUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDgpCiAjZGVmaW5lIFJTTl9BVVRIX0tFWV9NR01UX0ZUX1NBRSBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgOSkKKyNkZWZpbmUgUlNOX0FVVEhfS0VZX01HTVRfODAyXzFYX1NVSVRFX0IgUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDExKQorI2RlZmluZSBSU05fQVVUSF9LRVlfTUdNVF84MDJfMVhfU1VJVEVfQl8zODQgUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDEyKQorI2RlZmluZSBSU05fQVVUSF9LRVlfTUdNVF9GVF84MDJfMVhfU1VJVEVfQl8zODQgXAorUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDEzKQogI2RlZmluZSBSU05fQVVUSF9LRVlfTUdNVF9DQ0tNIFJTTl9TRUxFQ1RPUigweDAwLCAweDQwLCAweDk2LCAweDAwKQorI2RlZmluZSBSU05fQVVUSF9LRVlfTUdNVF9PU0VOIFJTTl9TRUxFQ1RPUigweDUwLCAweDZmLCAweDlhLCAweDAxKQogCiAjZGVmaW5lIFJTTl9DSVBIRVJfU1VJVEVfTk9ORSBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgMCkKICNkZWZpbmUgUlNOX0NJUEhFUl9TVUlURV9XRVA0MCBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgMSkKQEAgLTcwLDExICs3NywxNCBAQAogI2VuZGlmCiAjZGVmaW5lIFJTTl9DSVBIRVJfU1VJVEVfQ0NNUCBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgNCkKICNkZWZpbmUgUlNOX0NJUEhFUl9TVUlURV9XRVAxMDQgUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDUpCi0jaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKICNkZWZpbmUgUlNOX0NJUEhFUl9TVUlURV9BRVNfMTI4X0NNQUMgUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDYpCi0jZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KICNkZWZpbmUgUlNOX0NJUEhFUl9TVUlURV9OT19HUk9VUF9BRERSRVNTRUQgUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDcpCiAjZGVmaW5lIFJTTl9DSVBIRVJfU1VJVEVfR0NNUCBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgOCkKKyNkZWZpbmUgUlNOX0NJUEhFUl9TVUlURV9HQ01QXzI1NiBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgOSkKKyNkZWZpbmUgUlNOX0NJUEhFUl9TVUlURV9DQ01QXzI1NiBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgMTApCisjZGVmaW5lIFJTTl9DSVBIRVJfU1VJVEVfQklQX0dNQUNfMTI4IFJTTl9TRUxFQ1RPUigweDAwLCAweDBmLCAweGFjLCAxMSkKKyNkZWZpbmUgUlNOX0NJUEhFUl9TVUlURV9CSVBfR01BQ18yNTYgUlNOX1NFTEVDVE9SKDB4MDAsIDB4MGYsIDB4YWMsIDEyKQorI2RlZmluZSBSU05fQ0lQSEVSX1NVSVRFX0JJUF9DTUFDXzI1NiBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgMTMpCiAKIC8qIEVBUE9MLUtleSBLZXkgRGF0YSBFbmNhcHN1bGF0aW9uCiAgKiBHcm91cEtleSBhbmQgUGVlcktleSByZXF1aXJlIGVuY3J5cHRpb24sIG90aGVyd2lzZSwgZW5jcnlwdGlvbiBpcyBvcHRpb25hbC4KQEAgLTk4LDYgKzEwOCw5IEBACiAjZGVmaW5lIFJTTl9LRVlfREFUQV9NVUxUSUJBTkRfR1RLIFJTTl9TRUxFQ1RPUigweDAwLCAweDBmLCAweGFjLCAxMSkKICNkZWZpbmUgUlNOX0tFWV9EQVRBX01VTFRJQkFORF9LRVlJRCBSU05fU0VMRUNUT1IoMHgwMCwgMHgwZiwgMHhhYywgMTIpCiAKKyNkZWZpbmUgV0ZBX0tFWV9EQVRBX0lQX0FERFJfUkVRIFJTTl9TRUxFQ1RPUigweDUwLCAweDZmLCAweDlhLCA0KQorI2RlZmluZSBXRkFfS0VZX0RBVEFfSVBfQUREUl9BTExPQyBSU05fU0VMRUNUT1IoMHg1MCwgMHg2ZiwgMHg5YSwgNSkKKwogI2RlZmluZSBXUEFfT1VJX1RZUEUgUlNOX1NFTEVDVE9SKDB4MDAsIDB4NTAsIDB4ZjIsIDEpCiAKICNkZWZpbmUgUlNOX1NFTEVDVE9SX1BVVChhLCB2YWwpIFdQQV9QVVRfQkUzMigodTggKikgKGEpLCAodmFsKSkKQEAgLTExNSw2ICsxMjgsNyBAQAogCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKICNkZWZpbmUgV1BBX0lHVEtfTEVOIDE2CisjZGVmaW5lIFdQQV9JR1RLX01BWF9MRU4gMzIKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCiAKQEAgLTE0Myw2ICsxNTcsNyBAQAogCiAvKiBJRUVFIDgwMi4xMSwgOC41LjIgRUFQT0wtS2V5IGZyYW1lcyAqLwogI2RlZmluZSBXUEFfS0VZX0lORk9fVFlQRV9NQVNLICgodTE2KSAoQklUKDApIHwgQklUKDEpIHwgQklUKDIpKSkKKyNkZWZpbmUgV1BBX0tFWV9JTkZPX1RZUEVfQUtNX0RFRklORUQgMAogI2RlZmluZSBXUEFfS0VZX0lORk9fVFlQRV9ITUFDX01ENV9SQzQgQklUKDApCiAjZGVmaW5lIFdQQV9LRVlfSU5GT19UWVBFX0hNQUNfU0hBMV9BRVMgQklUKDEpCiAjZGVmaW5lIFdQQV9LRVlfSU5GT19UWVBFX0FFU18xMjhfQ01BQyAzCkBAIC0yNjksMTAgKzI4NCwxMSBAQAogfSBTVFJVQ1RfUEFDS0VEOwogCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKKyNkZWZpbmUgV1BBX0lHVEtfS0RFX1BSRUZJWF9MRU4gKDIgKyA2KQogc3RydWN0IHdwYV9pZ3RrX2tkZSB7CiAJdTgga2V5aWRbMl07CiAJdTggcG5bNl07Ci0JdTggaWd0a1tXUEFfSUdUS19MRU5dOworCXU4IGlndGtbV1BBX0lHVEtfTUFYX0xFTl07CiB9IFNUUlVDVF9QQUNLRUQ7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIApAQCAtMzYxLDYgKzM3Nyw3IEBACiAKIGNvbnN0IGNoYXIgKiB3cGFfY2lwaGVyX3R4dChpbnQgY2lwaGVyKTsKIGNvbnN0IGNoYXIgKiB3cGFfa2V5X21nbXRfdHh0KGludCBrZXlfbWdtdCwgaW50IHByb3RvKTsKK3UzMiB3cGFfYWttX3RvX3N1aXRlKGludCBha20pOwogaW50IHdwYV9jb21wYXJlX3Jzbl9pZShpbnQgZnRfaW5pdGlhbF9hc3NvYywKIAkJICAgICAgIGNvbnN0IHU4ICppZTEsIHNpemVfdCBpZTFsZW4sCiAJCSAgICAgICBjb25zdCB1OCAqaWUyLCBzaXplX3QgaWUybGVuKTsKQEAgLTM5Miw4ICs0MDksOCBAQAogaW50IHdwYV9jaXBoZXJfa2V5X2xlbihpbnQgY2lwaGVyKTsKIGludCB3cGFfY2lwaGVyX3JzY19sZW4oaW50IGNpcGhlcik7CiBpbnQgd3BhX2NpcGhlcl90b19hbGcoaW50IGNpcGhlcik7Ci1lbnVtIHdwYV9jaXBoZXIgd3BhX2NpcGhlcl90b19zdWl0ZV9kcml2ZXIoaW50IGNpcGhlcik7CiBpbnQgd3BhX2NpcGhlcl92YWxpZF9wYWlyd2lzZShpbnQgY2lwaGVyKTsKK2ludCB3cGFfY2lwaGVyX3ZhbGlkX21nbXRfZ3JvdXAoaW50IGNpcGhlcik7CiB1MzIgd3BhX2NpcGhlcl90b19zdWl0ZShpbnQgcHJvdG8sIGludCBjaXBoZXIpOwogaW50IHJzbl9jaXBoZXJfcHV0X3N1aXRlcyh1OCAqcG9zLCBpbnQgY2lwaGVycyk7CiBpbnQgd3BhX2NpcGhlcl9wdXRfc3VpdGVzKHU4ICpwb3MsIGludCBjaXBoZXJzKTsKZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vd3BhX2N0cmwuYyBiL3NyYy9jb21tb24vd3BhX2N0cmwuYwppbmRleCA4Mzc4OGQ3Li41ODIwYTEzIDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL3dwYV9jdHJsLmMKKysrIGIvc3JjL2NvbW1vbi93cGFfY3RybC5jCkBAIC0yNSw2ICsyNSwxMCBAQAogI2luY2x1ZGUgInByaXZhdGUvYW5kcm9pZF9maWxlc3lzdGVtX2NvbmZpZy5oIgogI2VuZGlmIC8qIEFORFJPSUQgKi8KIAorI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisjaW5jbHVkZSA8bmV0L2lmLmg+CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KKwogI2luY2x1ZGUgIndwYV9jdHJsLmgiCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAKQEAgLTQ2LDggKzUwLDEzIEBACiBzdHJ1Y3Qgd3BhX2N0cmwgewogI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUAogCWludCBzOworI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJc3RydWN0IHNvY2thZGRyX2luNiBsb2NhbDsKKwlzdHJ1Y3Qgc29ja2FkZHJfaW42IGRlc3Q7CisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCXN0cnVjdCBzb2NrYWRkcl9pbiBsb2NhbDsKIAlzdHJ1Y3Qgc29ja2FkZHJfaW4gZGVzdDsKKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCWNoYXIgKmNvb2tpZTsKIAljaGFyICpyZW1vdGVfaWZuYW1lOwogCWNoYXIgKnJlbW90ZV9pcDsKQEAgLTI3OSwxOSArMjg4LDMzIEBACiAJCXJldHVybiBOVUxMOwogCW9zX21lbXNldChjdHJsLCAwLCBzaXplb2YoKmN0cmwpKTsKIAorI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJY3RybC0+cyA9IHNvY2tldChQRl9JTkVUNiwgU09DS19ER1JBTSwgMCk7CisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCWN0cmwtPnMgPSBzb2NrZXQoUEZfSU5FVCwgU09DS19ER1JBTSwgMCk7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAlpZiAoY3RybC0+cyA8IDApIHsKIAkJcGVycm9yKCJzb2NrZXQiKTsKIAkJb3NfZnJlZShjdHJsKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwljdHJsLT5sb2NhbC5zaW42X2ZhbWlseSA9IEFGX0lORVQ2OworI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUKKwljdHJsLT5sb2NhbC5zaW42X2FkZHIgPSBpbjZhZGRyX2FueTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUgKi8KKwlpbmV0X3B0b24oQUZfSU5FVDYsICI6OjEiLCAmY3RybC0+bG9jYWwuc2luNl9hZGRyKTsKKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfUkVNT1RFICovCisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCWN0cmwtPmxvY2FsLnNpbl9mYW1pbHkgPSBBRl9JTkVUOwogI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUKIAljdHJsLT5sb2NhbC5zaW5fYWRkci5zX2FkZHIgPSBJTkFERFJfQU5ZOwogI2Vsc2UgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX1JFTU9URSAqLwogCWN0cmwtPmxvY2FsLnNpbl9hZGRyLnNfYWRkciA9IGh0b25sKCgxMjcgPDwgMjQpIHwgMSk7CiAjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX1JFTU9URSAqLworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCisKIAlpZiAoYmluZChjdHJsLT5zLCAoc3RydWN0IHNvY2thZGRyICopICZjdHJsLT5sb2NhbCwKIAkJIHNpemVvZihjdHJsLT5sb2NhbCkpIDwgMCkgewogCQljbG9zZShjdHJsLT5zKTsKQEAgLTI5OSwxNCArMzIyLDI0IEBACiAJCXJldHVybiBOVUxMOwogCX0KIAorI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJY3RybC0+ZGVzdC5zaW42X2ZhbWlseSA9IEFGX0lORVQ2OworCWluZXRfcHRvbihBRl9JTkVUNiwgIjo6MSIsICZjdHJsLT5kZXN0LnNpbjZfYWRkcik7CisJY3RybC0+ZGVzdC5zaW42X3BvcnQgPSBodG9ucyhXUEFfQ1RSTF9JRkFDRV9QT1JUKTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJY3RybC0+ZGVzdC5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKIAljdHJsLT5kZXN0LnNpbl9hZGRyLnNfYWRkciA9IGh0b25sKCgxMjcgPDwgMjQpIHwgMSk7CiAJY3RybC0+ZGVzdC5zaW5fcG9ydCA9IGh0b25zKFdQQV9DVFJMX0lGQUNFX1BPUlQpOworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAKICNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfUkVNT1RFCiAJaWYgKGN0cmxfcGF0aCkgewogCQljaGFyICpwb3J0LCAqbmFtZTsKIAkJaW50IHBvcnRfaWQ7CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwkJY2hhciAqc2NvcGU7CisJCWludCBzY29wZV9pZCA9IDA7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAogCQluYW1lID0gb3Nfc3RyZHVwKGN0cmxfcGF0aCk7CiAJCWlmIChuYW1lID09IE5VTEwpIHsKQEAgLTMxNCw3ICszNDcsMTEgQEAKIAkJCW9zX2ZyZWUoY3RybCk7CiAJCQlyZXR1cm4gTlVMTDsKIAkJfQorI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJCXBvcnQgPSBvc19zdHJjaHIobmFtZSwgJywnKTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJCXBvcnQgPSBvc19zdHJjaHIobmFtZSwgJzonKTsKKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCiAJCWlmIChwb3J0KSB7CiAJCQlwb3J0X2lkID0gYXRvaSgmcG9ydFsxXSk7CkBAIC0zMjIsNyArMzU5LDE2IEBACiAJCX0gZWxzZQogCQkJcG9ydF9pZCA9IFdQQV9DVFJMX0lGQUNFX1BPUlQ7CiAKKyNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNgorCQlzY29wZSA9IG9zX3N0cmNocihuYW1lLCAnJScpOworCQlpZiAoc2NvcGUpIHsKKwkJCXNjb3BlX2lkID0gaWZfbmFtZXRvaW5kZXgoJnNjb3BlWzFdKTsKKwkJCXNjb3BlWzBdID0gJ1wwJzsKKwkJfQorCQloID0gZ2V0aG9zdGJ5bmFtZTIobmFtZSwgQUZfSU5FVDYpOworI2Vsc2UgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAkJaCA9IGdldGhvc3RieW5hbWUobmFtZSk7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAkJY3RybC0+cmVtb3RlX2lwID0gb3Nfc3RyZHVwKG5hbWUpOwogCQlvc19mcmVlKG5hbWUpOwogCQlpZiAoaCA9PSBOVUxMKSB7CkBAIC0zMzIsMTYgKzM3OCwzMyBAQAogCQkJb3NfZnJlZShjdHJsKTsKIAkJCXJldHVybiBOVUxMOwogCQl9CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwkJY3RybC0+ZGVzdC5zaW42X3Njb3BlX2lkID0gc2NvcGVfaWQ7CisJCWN0cmwtPmRlc3Quc2luNl9wb3J0ID0gaHRvbnMocG9ydF9pZCk7CisJCW9zX21lbWNweSgmY3RybC0+ZGVzdC5zaW42X2FkZHIsIGgtPmhfYWRkciwgaC0+aF9sZW5ndGgpOworI2Vsc2UgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAkJY3RybC0+ZGVzdC5zaW5fcG9ydCA9IGh0b25zKHBvcnRfaWQpOwotCQlvc19tZW1jcHkoaC0+aF9hZGRyLCAoY2hhciAqKSAmY3RybC0+ZGVzdC5zaW5fYWRkci5zX2FkZHIsCi0JCQkgIGgtPmhfbGVuZ3RoKTsKKwkJb3NfbWVtY3B5KCZjdHJsLT5kZXN0LnNpbl9hZGRyLnNfYWRkciwgaC0+aF9hZGRyLCBoLT5oX2xlbmd0aCk7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAl9IGVsc2UKIAkJY3RybC0+cmVtb3RlX2lwID0gb3Nfc3RyZHVwKCJsb2NhbGhvc3QiKTsKICNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfUkVNT1RFICovCiAKIAlpZiAoY29ubmVjdChjdHJsLT5zLCAoc3RydWN0IHNvY2thZGRyICopICZjdHJsLT5kZXN0LAogCQkgICAgc2l6ZW9mKGN0cmwtPmRlc3QpKSA8IDApIHsKLQkJcGVycm9yKCJjb25uZWN0Iik7CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwkJY2hhciBhZGRyW0lORVQ2X0FERFJTVFJMRU5dOworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImNvbm5lY3QoJXM6JWQpIGZhaWxlZDogJXMiLAorCQkJICAgaW5ldF9udG9wKEFGX0lORVQ2LCAmY3RybC0+ZGVzdC5zaW42X2FkZHIsIGFkZHIsCisJCQkJICAgICBzaXplb2YoY3RybC0+ZGVzdCkpLAorCQkJICAgbnRvaHMoY3RybC0+ZGVzdC5zaW42X3BvcnQpLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiY29ubmVjdCglczolZCkgZmFpbGVkOiAlcyIsCisJCQkgICBpbmV0X250b2EoY3RybC0+ZGVzdC5zaW5fYWRkciksCisJCQkgICBudG9ocyhjdHJsLT5kZXN0LnNpbl9wb3J0KSwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAkJY2xvc2UoY3RybC0+cyk7CiAJCW9zX2ZyZWUoY3RybC0+cmVtb3RlX2lwKTsKIAkJb3NfZnJlZShjdHJsKTsKQEAgLTM5MSw3ICs0NTQsNyBAQAogCQkgICAgIHZvaWQgKCptc2dfY2IpKGNoYXIgKm1zZywgc2l6ZV90IGxlbikpCiB7CiAJc3RydWN0IHRpbWV2YWwgdHY7Ci0Jc3RydWN0IG9zX3RpbWUgc3RhcnRlZF9hdDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBzdGFydGVkX2F0OwogCWludCByZXM7CiAJZmRfc2V0IHJmZHM7CiAJY29uc3QgY2hhciAqX2NtZDsKQEAgLTQzMCwxMiArNDkzLDEyIEBACiAJCQkgKiBsb25nZXIgYmVmb3JlIGdpdmluZyB1cC4KIAkJCSAqLwogCQkJaWYgKHN0YXJ0ZWRfYXQuc2VjID09IDApCi0JCQkJb3NfZ2V0X3RpbWUoJnN0YXJ0ZWRfYXQpOworCQkJCW9zX2dldF9yZWx0aW1lKCZzdGFydGVkX2F0KTsKIAkJCWVsc2UgewotCQkJCXN0cnVjdCBvc190aW1lIG47Ci0JCQkJb3NfZ2V0X3RpbWUoJm4pOworCQkJCXN0cnVjdCBvc19yZWx0aW1lIG47CisJCQkJb3NfZ2V0X3JlbHRpbWUoJm4pOwogCQkJCS8qIFRyeSBmb3IgYSBmZXcgc2Vjb25kcy4gKi8KLQkJCQlpZiAobi5zZWMgPiBzdGFydGVkX2F0LnNlYyArIDUpCisJCQkJaWYgKG9zX3JlbHRpbWVfZXhwaXJlZCgmbiwgJnN0YXJ0ZWRfYXQsIDUpKQogCQkJCQlnb3RvIHNlbmRfZXJyOwogCQkJfQogCQkJb3Nfc2xlZXAoMSwgMCk7CmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL3dwYV9jdHJsLmggYi9zcmMvY29tbW9uL3dwYV9jdHJsLmgKaW5kZXggZmQ3ZjY4Ni4uZDkxNTk0ZSAxMDA2NDQKLS0tIGEvc3JjL2NvbW1vbi93cGFfY3RybC5oCisrKyBiL3NyYy9jb21tb24vd3BhX2N0cmwuaApAQCAtNTQsNiArNTQsOCBAQAogI2RlZmluZSBXUEFfRVZFTlRfVEVNUF9ESVNBQkxFRCAiQ1RSTC1FVkVOVC1TU0lELVRFTVAtRElTQUJMRUQgIgogLyoqIFRlbXBvcmFyaWx5IGRpc2FibGVkIG5ldHdvcmsgYmxvY2sgcmUtZW5hYmxlZCAqLwogI2RlZmluZSBXUEFfRVZFTlRfUkVFTkFCTEVEICJDVFJMLUVWRU5ULVNTSUQtUkVFTkFCTEVEICIKKy8qKiBOZXcgc2NhbiBzdGFydGVkICovCisjZGVmaW5lIFdQQV9FVkVOVF9TQ0FOX1NUQVJURUQgIkNUUkwtRVZFTlQtU0NBTi1TVEFSVEVEICIKIC8qKiBOZXcgc2NhbiByZXN1bHRzIGF2YWlsYWJsZSAqLwogI2RlZmluZSBXUEFfRVZFTlRfU0NBTl9SRVNVTFRTICJDVFJMLUVWRU5ULVNDQU4tUkVTVUxUUyAiCiAvKiogd3BhX3N1cHBsaWNhbnQgc3RhdGUgY2hhbmdlICovCkBAIC02MiwxNCArNjQsMjIgQEAKICNkZWZpbmUgV1BBX0VWRU5UX0JTU19BRERFRCAiQ1RSTC1FVkVOVC1CU1MtQURERUQgIgogLyoqIEEgQlNTIGVudHJ5IHdhcyByZW1vdmVkIChmb2xsb3dlZCBieSBCU1MgZW50cnkgaWQgYW5kIEJTU0lEKSAqLwogI2RlZmluZSBXUEFfRVZFTlRfQlNTX1JFTU9WRUQgIkNUUkwtRVZFTlQtQlNTLVJFTU9WRUQgIgotI2lmZGVmIEFORFJPSURfUDJQCi0vKiogTm90aWZ5IHRoZSBVc2Vyc3BhY2UgYWJvdXQgdGhlIGZyZXEgY29uZmxpY3QgKi8KLSNkZWZpbmUgV1BBX0VWRU5UX0ZSRVFfQ09ORkxJQ1QgIkNUUkwtRVZFTlQtRlJFUS1DT05GTElDVCAiCi0jZW5kaWYKKy8qKiBDaGFuZ2UgaW4gdGhlIHNpZ25hbCBsZXZlbCB3YXMgcmVwb3J0ZWQgYnkgdGhlIGRyaXZlciAqLworI2RlZmluZSBXUEFfRVZFTlRfU0lHTkFMX0NIQU5HRSAiQ1RSTC1FVkVOVC1TSUdOQUwtQ0hBTkdFICIKKy8qKiBSZWd1bGF0b3J5IGRvbWFpbiBjaGFubmVsICovCisjZGVmaW5lIFdQQV9FVkVOVF9SRUdET01fQ0hBTkdFICJDVFJMLUVWRU5ULVJFR0RPTS1DSEFOR0UgIgogCiAvKiogUlNOIElCU1MgNC13YXkgaGFuZHNoYWtlcyBjb21wbGV0ZWQgd2l0aCBzcGVjaWZpZWQgcGVlciAqLwogI2RlZmluZSBJQlNTX1JTTl9DT01QTEVURUQgIklCU1MtUlNOLUNPTVBMRVRFRCAiCiAKKy8qKiBOb3RpZmljYXRpb24gb2YgZnJlcXVlbmN5IGNvbmZsaWN0IGR1ZSB0byBhIGNvbmN1cnJlbnQgb3BlcmF0aW9uLgorICoKKyAqIFRoZSBpbmRpY2F0ZWQgbmV0d29yayBpcyBkaXNhYmxlZCBhbmQgbmVlZHMgdG8gYmUgcmUtZW5hYmxlZCBiZWZvcmUgaXQgY2FuCisgKiBiZSB1c2VkIGFnYWluLgorICovCisjZGVmaW5lIFdQQV9FVkVOVF9GUkVRX0NPTkZMSUNUICJDVFJMLUVWRU5ULUZSRVEtQ09ORkxJQ1QgIgorLyoqIEZyZXF1ZW5jeSByYW5nZXMgdGhhdCB0aGUgZHJpdmVyIHJlY29tbWVuZHMgdG8gYXZvaWQgKi8KKyNkZWZpbmUgV1BBX0VWRU5UX0FWT0lEX0ZSRVEgIkNUUkwtRVZFTlQtQVZPSUQtRlJFUSAiCiAvKiogV1BTIG92ZXJsYXAgZGV0ZWN0ZWQgaW4gUEJDIG1vZGUgKi8KICNkZWZpbmUgV1BTX0VWRU5UX09WRVJMQVAgIldQUy1PVkVSTEFQLURFVEVDVEVEICIKIC8qKiBBdmFpbGFibGUgV1BTIEFQIHdpdGggYWN0aXZlIFBCQyBmb3VuZCBpbiBzY2FuIHJlc3VsdHMgKi8KQEAgLTE0MywxNCArMTUzLDM5IEBACiAjZGVmaW5lIFAyUF9FVkVOVF9JTlZJVEFUSU9OX1JFU1VMVCAiUDJQLUlOVklUQVRJT04tUkVTVUxUICIKICNkZWZpbmUgUDJQX0VWRU5UX0ZJTkRfU1RPUFBFRCAiUDJQLUZJTkQtU1RPUFBFRCAiCiAjZGVmaW5lIFAyUF9FVkVOVF9QRVJTSVNURU5UX1BTS19GQUlMICJQMlAtUEVSU0lTVEVOVC1QU0stRkFJTCBpZD0iCisjZGVmaW5lIFAyUF9FVkVOVF9QUkVTRU5DRV9SRVNQT05TRSAiUDJQLVBSRVNFTkNFLVJFU1BPTlNFICIKKyNkZWZpbmUgUDJQX0VWRU5UX05GQ19CT1RIX0dPICJQMlAtTkZDLUJPVEgtR08gIgorI2RlZmluZSBQMlBfRVZFTlRfTkZDX1BFRVJfQ0xJRU5UICJQMlAtTkZDLVBFRVItQ0xJRU5UICIKKyNkZWZpbmUgUDJQX0VWRU5UX05GQ19XSElMRV9DTElFTlQgIlAyUC1ORkMtV0hJTEUtQ0xJRU5UICIKIAogLyogcGFyYW1ldGVyczogPFBNRiBlbmFibGVkPiA8dGltZW91dCBpbiBtcz4gPFNlc3Npb24gSW5mb3JtYXRpb24gVVJMPiAqLwogI2RlZmluZSBFU1NfRElTQVNTT0NfSU1NSU5FTlQgIkVTUy1ESVNBU1NPQy1JTU1JTkVOVCAiCisjZGVmaW5lIFAyUF9FVkVOVF9SRU1PVkVfQU5EX1JFRk9STV9HUk9VUCAiUDJQLVJFTU9WRS1BTkQtUkVGT1JNLUdST1VQICIKIAogI2RlZmluZSBJTlRFUldPUktJTkdfQVAgIklOVEVSV09SS0lORy1BUCAiCisjZGVmaW5lIElOVEVSV09SS0lOR19CTEFDS0xJU1RFRCAiSU5URVJXT1JLSU5HLUJMQUNLTElTVEVEICIKICNkZWZpbmUgSU5URVJXT1JLSU5HX05PX01BVENIICJJTlRFUldPUktJTkctTk8tTUFUQ0ggIgorI2RlZmluZSBJTlRFUldPUktJTkdfQUxSRUFEWV9DT05ORUNURUQgIklOVEVSV09SS0lORy1BTFJFQURZLUNPTk5FQ1RFRCAiCisjZGVmaW5lIElOVEVSV09SS0lOR19TRUxFQ1RFRCAiSU5URVJXT1JLSU5HLVNFTEVDVEVEICIKKworLyogQ3JlZGVudGlhbCBibG9jayBhZGRlZDsgcGFyYW1ldGVyczogPGlkPiAqLworI2RlZmluZSBDUkVEX0FEREVEICJDUkVELUFEREVEICIKKy8qIENyZWRlbnRpYWwgYmxvY2sgbW9kaWZpZWQ7IHBhcmFtZXRlcnM6IDxpZD4gPGZpZWxkPiAqLworI2RlZmluZSBDUkVEX01PRElGSUVEICJDUkVELU1PRElGSUVEICIKKy8qIENyZWRlbnRpYWwgYmxvY2sgcmVtb3ZlZDsgcGFyYW1ldGVyczogPGlkPiAqLworI2RlZmluZSBDUkVEX1JFTU9WRUQgIkNSRUQtUkVNT1ZFRCAiCiAKICNkZWZpbmUgR0FTX1JFU1BPTlNFX0lORk8gIkdBUy1SRVNQT05TRS1JTkZPICIKKy8qIHBhcmFtZXRlcnM6IDxhZGRyPiA8ZGlhbG9nX3Rva2VuPiA8ZnJlcT4gKi8KKyNkZWZpbmUgR0FTX1FVRVJZX1NUQVJUICJHQVMtUVVFUlktU1RBUlQgIgorLyogcGFyYW1ldGVyczogPGFkZHI+IDxkaWFsb2dfdG9rZW4+IDxmcmVxPiA8c3RhdHVzX2NvZGU+IDxyZXN1bHQ+ICovCisjZGVmaW5lIEdBU19RVUVSWV9ET05FICJHQVMtUVVFUlktRE9ORSAiCisKKyNkZWZpbmUgSFMyMF9TVUJTQ1JJUFRJT05fUkVNRURJQVRJT04gIkhTMjAtU1VCU0NSSVBUSU9OLVJFTUVESUFUSU9OICIKKyNkZWZpbmUgSFMyMF9ERUFVVEhfSU1NSU5FTlRfTk9USUNFICJIUzIwLURFQVVUSC1JTU1JTkVOVC1OT1RJQ0UgIgorCisjZGVmaW5lIEVYVF9SQURJT19XT1JLX1NUQVJUICJFWFQtUkFESU8tV09SSy1TVEFSVCAiCisjZGVmaW5lIEVYVF9SQURJT19XT1JLX1RJTUVPVVQgIkVYVC1SQURJTy1XT1JLLVRJTUVPVVQgIgogCiAvKiBob3N0YXBkIGNvbnRyb2wgaW50ZXJmYWNlIC0gZml4ZWQgbWVzc2FnZSBwcmVmaXhlcyAqLwogI2RlZmluZSBXUFNfRVZFTlRfUElOX05FRURFRCAiV1BTLVBJTi1ORUVERUQgIgpAQCAtMTY2LDYgKzIwMSwyMSBAQAogI2RlZmluZSBBUF9SRUpFQ1RFRF9NQVhfU1RBICJBUC1SRUpFQ1RFRC1NQVgtU1RBICIKICNkZWZpbmUgQVBfUkVKRUNURURfQkxPQ0tFRF9TVEEgIkFQLVJFSkVDVEVELUJMT0NLRUQtU1RBICIKIAorI2RlZmluZSBBUF9FVkVOVF9FTkFCTEVEICJBUC1FTkFCTEVEICIKKyNkZWZpbmUgQVBfRVZFTlRfRElTQUJMRUQgIkFQLURJU0FCTEVEICIKKworI2RlZmluZSBBQ1NfRVZFTlRfU1RBUlRFRCAiQUNTLVNUQVJURUQgIgorI2RlZmluZSBBQ1NfRVZFTlRfQ09NUExFVEVEICJBQ1MtQ09NUExFVEVEICIKKyNkZWZpbmUgQUNTX0VWRU5UX0ZBSUxFRCAiQUNTLUZBSUxFRCAiCisKKyNkZWZpbmUgREZTX0VWRU5UX1JBREFSX0RFVEVDVEVEICJERlMtUkFEQVItREVURUNURUQgIgorI2RlZmluZSBERlNfRVZFTlRfTkVXX0NIQU5ORUwgIkRGUy1ORVctQ0hBTk5FTCAiCisjZGVmaW5lIERGU19FVkVOVF9DQUNfU1RBUlQgIkRGUy1DQUMtU1RBUlQgIgorI2RlZmluZSBERlNfRVZFTlRfQ0FDX0NPTVBMRVRFRCAiREZTLUNBQy1DT01QTEVURUQgIgorI2RlZmluZSBERlNfRVZFTlRfTk9QX0ZJTklTSEVEICJERlMtTk9QLUZJTklTSEVEICIKKworI2RlZmluZSBBUF9DU0FfRklOSVNIRUQgIkFQLUNTQS1GSU5JU0hFRCAiCisKIC8qIEJTUyBjb21tYW5kIGluZm9ybWF0aW9uIG1hc2tzICovCiAKICNkZWZpbmUgV1BBX0JTU19NQVNLX0FMTAkJMHhGRkZERkZGRgpAQCAtMTg5LDYgKzIzOSwyNSBAQAogI2RlZmluZSBXUEFfQlNTX01BU0tfREVMSU0JCUJJVCgxNykKIAogCisvKiBWRU5ET1JfRUxFTV8qIGZyYW1lIGlkIHZhbHVlcyAqLworZW51bSB3cGFfdmVuZG9yX2VsZW1fZnJhbWUgeworCVZFTkRPUl9FTEVNX1BST0JFX1JFUV9QMlAgPSAwLAorCVZFTkRPUl9FTEVNX1BST0JFX1JFU1BfUDJQID0gMSwKKwlWRU5ET1JfRUxFTV9QUk9CRV9SRVNQX1AyUF9HTyA9IDIsCisJVkVORE9SX0VMRU1fQkVBQ09OX1AyUF9HTyA9IDMsCisJVkVORE9SX0VMRU1fUDJQX1BEX1JFUSA9IDQsCisJVkVORE9SX0VMRU1fUDJQX1BEX1JFU1AgPSA1LAorCVZFTkRPUl9FTEVNX1AyUF9HT19ORUdfUkVRID0gNiwKKwlWRU5ET1JfRUxFTV9QMlBfR09fTkVHX1JFU1AgPSA3LAorCVZFTkRPUl9FTEVNX1AyUF9HT19ORUdfQ09ORiA9IDgsCisJVkVORE9SX0VMRU1fUDJQX0lOVl9SRVEgPSA5LAorCVZFTkRPUl9FTEVNX1AyUF9JTlZfUkVTUCA9IDEwLAorCVZFTkRPUl9FTEVNX1AyUF9BU1NPQ19SRVEgPSAxMSwKKwlWRU5ET1JfRUxFTV9QMlBfQVNTT0NfUkVTUCA9IDEyLAorCU5VTV9WRU5ET1JfRUxFTV9GUkFNRVMKK307CisKKwogLyogd3BhX3N1cHBsaWNhbnQvaG9zdGFwZCBjb250cm9sIGludGVyZmFjZSBhY2Nlc3MgKi8KIAogLyoqCmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL3dwYV9oZWxwZXJzLmMgYi9zcmMvY29tbW9uL3dwYV9oZWxwZXJzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjg5MTNiOQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9jb21tb24vd3BhX2hlbHBlcnMuYwpAQCAtMCwwICsxLDI5MiBAQAorLyoKKyAqIHdwYV9zdXBwbGljYW50IGN0cmxfaWZhY2UgaGVscGVycworICogQ29weXJpZ2h0IChjKSAyMDEwLTIwMTEsIEF0aGVyb3MgQ29tbXVuaWNhdGlvbnMsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEyLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKyNpbmNsdWRlIDx0aW1lLmg+CisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJ3cGFfY3RybC5oIgorI2luY2x1ZGUgIndwYV9oZWxwZXJzLmgiCisKKworY2hhciAqd3Bhc19jdHJsX3BhdGggPSAiL3Zhci9ydW4vd3BhX3N1cHBsaWNhbnQvIjsKK3N0YXRpYyBpbnQgZGVmYXVsdF90aW1lb3V0ID0gNjA7CisKKworc3RhdGljIHN0cnVjdCB3cGFfY3RybCAqIHdwYV9vcGVuX2N0cmwoY29uc3QgY2hhciAqaWZuYW1lKQoreworCWNoYXIgYnVmWzEyOF07CisJc3RydWN0IHdwYV9jdHJsICpjdHJsOworCisJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiVzJXMiLCB3cGFzX2N0cmxfcGF0aCwgaWZuYW1lKTsKKwljdHJsID0gd3BhX2N0cmxfb3BlbihidWYpOworCWlmIChjdHJsID09IE5VTEwpCisJCXByaW50Zigid3BhX2NvbW1hbmQ6IHdwYV9jdHJsX29wZW4oJXMpIGZhaWxlZFxuIiwgYnVmKTsKKwlyZXR1cm4gY3RybDsKK30KKworCitpbnQgd3BhX2NvbW1hbmQoY29uc3QgY2hhciAqaWZuYW1lLCBjb25zdCBjaGFyICpjbWQpCit7CisJc3RydWN0IHdwYV9jdHJsICpjdHJsOworCWNoYXIgYnVmWzEyOF07CisJc2l6ZV90IGxlbjsKKworCXByaW50Zigid3BhX2NvbW1hbmQoaWZuYW1lPSclcycsIGNtZD0nJXMnKVxuIiwgaWZuYW1lLCBjbWQpOworCWN0cmwgPSB3cGFfb3Blbl9jdHJsKGlmbmFtZSk7CisJaWYgKGN0cmwgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWxlbiA9IHNpemVvZihidWYpOworCWlmICh3cGFfY3RybF9yZXF1ZXN0KGN0cmwsIGNtZCwgc3RybGVuKGNtZCksIGJ1ZiwgJmxlbiwgTlVMTCkgPCAwKSB7CisJCXByaW50Zigid3BhX2NvbW1hbmQ6IHdwYV9jdHJsX3JlcXVlc3QgZmFpbGVkXG4iKTsKKwkJd3BhX2N0cmxfY2xvc2UoY3RybCk7CisJCXJldHVybiAtMTsKKwl9CisJd3BhX2N0cmxfY2xvc2UoY3RybCk7CisJYnVmW2xlbl0gPSAnXDAnOworCWlmIChzdHJuY21wKGJ1ZiwgIkZBSUwiLCA0KSA9PSAwKSB7CisJCXByaW50Zigid3BhX2NvbW1hbmQ6IENvbW1hbmQgZmFpbGVkIChGQUlMIHJlY2VpdmVkKVxuIik7CisJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKKworaW50IHdwYV9jb21tYW5kX3Jlc3AoY29uc3QgY2hhciAqaWZuYW1lLCBjb25zdCBjaGFyICpjbWQsCisJCSAgICAgY2hhciAqcmVzcCwgc2l6ZV90IHJlc3Bfc2l6ZSkKK3sKKwlzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmw7CisJc2l6ZV90IGxlbjsKKworCXByaW50Zigid3BhX2NvbW1hbmQoaWZuYW1lPSclcycsIGNtZD0nJXMnKVxuIiwgaWZuYW1lLCBjbWQpOworCWN0cmwgPSB3cGFfb3Blbl9jdHJsKGlmbmFtZSk7CisJaWYgKGN0cmwgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWxlbiA9IHJlc3Bfc2l6ZTsKKwlpZiAod3BhX2N0cmxfcmVxdWVzdChjdHJsLCBjbWQsIHN0cmxlbihjbWQpLCByZXNwLCAmbGVuLCBOVUxMKSA8IDApIHsKKwkJcHJpbnRmKCJ3cGFfY29tbWFuZDogd3BhX2N0cmxfcmVxdWVzdCBmYWlsZWRcbiIpOworCQl3cGFfY3RybF9jbG9zZShjdHJsKTsKKwkJcmV0dXJuIC0xOworCX0KKwl3cGFfY3RybF9jbG9zZShjdHJsKTsKKwlyZXNwW2xlbl0gPSAnXDAnOworCXJldHVybiAwOworfQorCisKK3N0cnVjdCB3cGFfY3RybCAqIG9wZW5fd3BhX21vbihjb25zdCBjaGFyICppZm5hbWUpCit7CisJc3RydWN0IHdwYV9jdHJsICpjdHJsOworCisJY3RybCA9IHdwYV9vcGVuX2N0cmwoaWZuYW1lKTsKKwlpZiAoY3RybCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlpZiAod3BhX2N0cmxfYXR0YWNoKGN0cmwpIDwgMCkgeworCQl3cGFfY3RybF9jbG9zZShjdHJsKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0dXJuIGN0cmw7Cit9CisKKworaW50IGdldF93cGFfY2xpX2V2ZW50MihzdHJ1Y3Qgd3BhX2N0cmwgKm1vbiwKKwkJICAgICAgIGNvbnN0IGNoYXIgKmV2ZW50LCBjb25zdCBjaGFyICpldmVudDIsCisJCSAgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZfc2l6ZSkKK3sKKwlpbnQgZmQsIHJldDsKKwlmZF9zZXQgcmZkOworCWNoYXIgKnBvczsKKwlzdHJ1Y3QgdGltZXZhbCB0djsKKwl0aW1lX3Qgc3RhcnQsIG5vdzsKKworCXByaW50ZigiV2FpdGluZyBmb3Igd3BhX2NsaSBldmVudCAlc1xuIiwgZXZlbnQpOworCWZkID0gd3BhX2N0cmxfZ2V0X2ZkKG1vbik7CisJaWYgKGZkIDwgMCkKKwkJcmV0dXJuIC0xOworCisJdGltZSgmc3RhcnQpOworCXdoaWxlICgxKSB7CisJCXNpemVfdCBsZW47CisKKwkJRkRfWkVSTygmcmZkKTsKKwkJRkRfU0VUKGZkLCAmcmZkKTsKKwkJdHYudHZfc2VjID0gZGVmYXVsdF90aW1lb3V0OworCQl0di50dl91c2VjID0gMDsKKwkJcmV0ID0gc2VsZWN0KGZkICsgMSwgJnJmZCwgTlVMTCwgTlVMTCwgJnR2KTsKKwkJaWYgKHJldCA9PSAwKSB7CisJCQlwcmludGYoIlRpbWVvdXQgb24gd2FpdGluZyBmb3IgZXZlbnQgJXNcbiIsIGV2ZW50KTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlpZiAocmV0IDwgMCkgeworCQkJcHJpbnRmKCJzZWxlY3Q6ICVzXG4iLCBzdHJlcnJvcihlcnJubykpOworCQkJcmV0dXJuIC0xOworCQl9CisJCWxlbiA9IGJ1Zl9zaXplOworCQlpZiAod3BhX2N0cmxfcmVjdihtb24sIGJ1ZiwgJmxlbikgPCAwKSB7CisJCQlwcmludGYoIkZhaWx1cmUgd2hpbGUgd2FpdGluZyBmb3IgZXZlbnQgJXNcbiIsIGV2ZW50KTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlpZiAobGVuID09IGJ1Zl9zaXplKQorCQkJbGVuLS07CisJCWJ1ZltsZW5dID0gJ1wwJzsKKworCQlwb3MgPSBzdHJjaHIoYnVmLCAnPicpOworCQlpZiAocG9zICYmCisJCSAgICAoc3RybmNtcChwb3MgKyAxLCBldmVudCwgc3RybGVuKGV2ZW50KSkgPT0gMCB8fAorCQkgICAgIChldmVudDIgJiYKKwkJICAgICAgc3RybmNtcChwb3MgKyAxLCBldmVudDIsIHN0cmxlbihldmVudDIpKSA9PSAwKSkpCisJCQlyZXR1cm4gMDsgLyogRXZlbnQgZm91bmQgKi8KKworCQl0aW1lKCZub3cpOworCQlpZiAoKGludCkgKG5vdyAtIHN0YXJ0KSA+IGRlZmF1bHRfdGltZW91dCkgeworCQkJcHJpbnRmKCJUaW1lb3V0IG9uIHdhaXRpbmcgZm9yIGV2ZW50ICVzXG4iLCBldmVudCk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9Cit9CisKKworaW50IGdldF93cGFfY2xpX2V2ZW50KHN0cnVjdCB3cGFfY3RybCAqbW9uLAorCQkgICAgICBjb25zdCBjaGFyICpldmVudCwgY2hhciAqYnVmLCBzaXplX3QgYnVmX3NpemUpCit7CisJcmV0dXJuIGdldF93cGFfY2xpX2V2ZW50Mihtb24sIGV2ZW50LCBOVUxMLCBidWYsIGJ1Zl9zaXplKTsKK30KKworCitpbnQgZ2V0X3dwYV9zdGF0dXMoY29uc3QgY2hhciAqaWZuYW1lLCBjb25zdCBjaGFyICpmaWVsZCwgY2hhciAqb2J1ZiwKKwkJICAgc2l6ZV90IG9idWZfc2l6ZSkKK3sKKwlzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmw7CisJY2hhciBidWZbNDA5Nl07CisJY2hhciAqcG9zLCAqZW5kOworCXNpemVfdCBsZW4sIGZsZW47CisKKwljdHJsID0gd3BhX29wZW5fY3RybChpZm5hbWUpOworCWlmIChjdHJsID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlsZW4gPSBzaXplb2YoYnVmKTsKKwlpZiAod3BhX2N0cmxfcmVxdWVzdChjdHJsLCAiU1RBVFVTIiwgNiwgYnVmLCAmbGVuLCBOVUxMKSA8IDApIHsKKwkJd3BhX2N0cmxfY2xvc2UoY3RybCk7CisJCXJldHVybiAtMTsKKwl9CisJd3BhX2N0cmxfY2xvc2UoY3RybCk7CisJYnVmW2xlbl0gPSAnXDAnOworCisJZmxlbiA9IHN0cmxlbihmaWVsZCk7CisJcG9zID0gYnVmOworCXdoaWxlIChwb3MgKyBmbGVuIDwgYnVmICsgbGVuKSB7CisJCWlmIChwb3MgPiBidWYpIHsKKwkJCWlmICgqcG9zICE9ICdcbicpIHsKKwkJCQlwb3MrKzsKKwkJCQljb250aW51ZTsKKwkJCX0KKwkJCXBvcysrOworCQl9CisJCWlmIChzdHJuY21wKHBvcywgZmllbGQsIGZsZW4pICE9IDAgfHwgcG9zW2ZsZW5dICE9ICc9JykgeworCQkJcG9zKys7CisJCQljb250aW51ZTsKKwkJfQorCQlwb3MgKz0gZmxlbiArIDE7CisJCWVuZCA9IHN0cmNocihwb3MsICdcbicpOworCQlpZiAoZW5kID09IE5VTEwpCisJCQlyZXR1cm4gLTE7CisJCSplbmQrKyA9ICdcMCc7CisJCWlmIChlbmQgLSBwb3MgPiAoaW50KSBvYnVmX3NpemUpCisJCQlyZXR1cm4gLTE7CisJCW1lbWNweShvYnVmLCBwb3MsIGVuZCAtIHBvcyk7CisJCXJldHVybiAwOworCX0KKworCXJldHVybiAtMTsKK30KKworCitpbnQgd2FpdF9pcF9hZGRyKGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50IHRpbWVvdXQpCit7CisJY2hhciBpcFszMF07CisJaW50IGNvdW50ID0gdGltZW91dDsKKwlzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmw7CisKKwl3aGlsZSAoY291bnQgPiAwKSB7CisJCXByaW50ZigiJXM6IGlmbmFtZT0nJXMnIC0gJWQgc2Vjb25kcyByZW1haW5pbmdcbiIsCisJCSAgICAgICBfX2Z1bmNfXywgaWZuYW1lLCBjb3VudCk7CisJCWNvdW50LS07CisJCWlmIChnZXRfd3BhX3N0YXR1cyhpZm5hbWUsICJpcF9hZGRyZXNzIiwgaXAsIHNpemVvZihpcCkpID09IDAKKwkJICAgICYmIHN0cmxlbihpcCkgPiAwKSB7CisJCQlwcmludGYoIklQIGFkZHJlc3MgZm91bmQ6ICclcydcbiIsIGlwKTsKKwkJCXJldHVybiAwOworCQl9CisJCWN0cmwgPSB3cGFfb3Blbl9jdHJsKGlmbmFtZSk7CisJCWlmIChjdHJsID09IE5VTEwpCisJCQlyZXR1cm4gLTE7CisJCXdwYV9jdHJsX2Nsb3NlKGN0cmwpOworCQlzbGVlcCgxKTsKKwl9CisJcHJpbnRmKCIlczogQ291bGQgbm90IGdldCBJUCBhZGRyZXNzIGZvciBpZm5hbWU9JyVzJyIsIF9fZnVuY19fLAorCSAgICAgICBpZm5hbWUpOworCXJldHVybiAtMTsKK30KKworCitpbnQgYWRkX25ldHdvcmsoY29uc3QgY2hhciAqaWZuYW1lKQoreworCWNoYXIgcmVzWzMwXTsKKworCWlmICh3cGFfY29tbWFuZF9yZXNwKGlmbmFtZSwgIkFERF9ORVRXT1JLIiwgcmVzLCBzaXplb2YocmVzKSkgPCAwKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIGF0b2kocmVzKTsKK30KKworCitpbnQgc2V0X25ldHdvcmsoY29uc3QgY2hhciAqaWZuYW1lLCBpbnQgaWQsIGNvbnN0IGNoYXIgKmZpZWxkLAorCQljb25zdCBjaGFyICp2YWx1ZSkKK3sKKwljaGFyIGJ1ZlsyMDBdOworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTRVRfTkVUV09SSyAlZCAlcyAlcyIsIGlkLCBmaWVsZCwgdmFsdWUpOworCXJldHVybiB3cGFfY29tbWFuZChpZm5hbWUsIGJ1Zik7Cit9CisKKworaW50IHNldF9uZXR3b3JrX3F1b3RlZChjb25zdCBjaGFyICppZm5hbWUsIGludCBpZCwgY29uc3QgY2hhciAqZmllbGQsCisJCSAgICAgICBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwljaGFyIGJ1ZlsyMDBdOworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTRVRfTkVUV09SSyAlZCAlcyBcIiVzXCIiLAorCQkgaWQsIGZpZWxkLCB2YWx1ZSk7CisJcmV0dXJuIHdwYV9jb21tYW5kKGlmbmFtZSwgYnVmKTsKK30KKworCitpbnQgYWRkX2NyZWQoY29uc3QgY2hhciAqaWZuYW1lKQoreworCWNoYXIgcmVzWzMwXTsKKworCWlmICh3cGFfY29tbWFuZF9yZXNwKGlmbmFtZSwgIkFERF9DUkVEIiwgcmVzLCBzaXplb2YocmVzKSkgPCAwKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIGF0b2kocmVzKTsKK30KKworCitpbnQgc2V0X2NyZWQoY29uc3QgY2hhciAqaWZuYW1lLCBpbnQgaWQsIGNvbnN0IGNoYXIgKmZpZWxkLCBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwljaGFyIGJ1ZlsyMDBdOworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTRVRfQ1JFRCAlZCAlcyAlcyIsIGlkLCBmaWVsZCwgdmFsdWUpOworCXJldHVybiB3cGFfY29tbWFuZChpZm5hbWUsIGJ1Zik7Cit9CisKKworaW50IHNldF9jcmVkX3F1b3RlZChjb25zdCBjaGFyICppZm5hbWUsIGludCBpZCwgY29uc3QgY2hhciAqZmllbGQsCisJCSAgICBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwljaGFyIGJ1ZlsyMDBdOworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJTRVRfQ1JFRCAlZCAlcyBcIiVzXCIiLAorCQkgaWQsIGZpZWxkLCB2YWx1ZSk7CisJcmV0dXJuIHdwYV9jb21tYW5kKGlmbmFtZSwgYnVmKTsKK30KZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vd3BhX2hlbHBlcnMuaCBiL3NyYy9jb21tb24vd3BhX2hlbHBlcnMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NGMyODcyCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL2NvbW1vbi93cGFfaGVscGVycy5oCkBAIC0wLDAgKzEsMzcgQEAKKy8qCisgKiB3cGFfc3VwcGxpY2FudCBjdHJsX2lmYWNlIGhlbHBlcnMKKyAqIENvcHlyaWdodCAoYykgMjAxMC0yMDExLCBBdGhlcm9zIENvbW11bmljYXRpb25zLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMiwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBXUEFfSEVMUEVSU19ICisjZGVmaW5lIFdQQV9IRUxQRVJTX0gKKworaW50IHdwYV9jb21tYW5kKGNvbnN0IGNoYXIgKmlmbmFtZSwgY29uc3QgY2hhciAqY21kKTsKK2ludCB3cGFfY29tbWFuZF9yZXNwKGNvbnN0IGNoYXIgKmlmbmFtZSwgY29uc3QgY2hhciAqY21kLAorCQkgICAgIGNoYXIgKnJlc3AsIHNpemVfdCByZXNwX3NpemUpOworaW50IGdldF93cGFfc3RhdHVzKGNvbnN0IGNoYXIgKmlmbmFtZSwgY29uc3QgY2hhciAqZmllbGQsIGNoYXIgKm9idWYsCisJCSAgIHNpemVfdCBvYnVmX3NpemUpOworCitzdHJ1Y3Qgd3BhX2N0cmwgKiBvcGVuX3dwYV9tb24oY29uc3QgY2hhciAqaWZuYW1lKTsKK2ludCB3YWl0X2lwX2FkZHIoY29uc3QgY2hhciAqaWZuYW1lLCBpbnQgdGltZW91dCk7CitpbnQgZ2V0X3dwYV9jbGlfZXZlbnQoc3RydWN0IHdwYV9jdHJsICptb24sCisJCSAgICAgIGNvbnN0IGNoYXIgKmV2ZW50LCBjaGFyICpidWYsIHNpemVfdCBidWZfc2l6ZSk7CitpbnQgZ2V0X3dwYV9jbGlfZXZlbnQyKHN0cnVjdCB3cGFfY3RybCAqbW9uLAorCQkgICAgICAgY29uc3QgY2hhciAqZXZlbnQsIGNvbnN0IGNoYXIgKmV2ZW50MiwKKwkJICAgICAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1Zl9zaXplKTsKKworaW50IGFkZF9uZXR3b3JrKGNvbnN0IGNoYXIgKmlmbmFtZSk7CitpbnQgc2V0X25ldHdvcmsoY29uc3QgY2hhciAqaWZuYW1lLCBpbnQgaWQsIGNvbnN0IGNoYXIgKmZpZWxkLAorCQljb25zdCBjaGFyICp2YWx1ZSk7CitpbnQgc2V0X25ldHdvcmtfcXVvdGVkKGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50IGlkLCBjb25zdCBjaGFyICpmaWVsZCwKKwkJICAgICAgIGNvbnN0IGNoYXIgKnZhbHVlKTsKK2ludCBhZGRfY3JlZChjb25zdCBjaGFyICppZm5hbWUpOworaW50IHNldF9jcmVkKGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50IGlkLCBjb25zdCBjaGFyICpmaWVsZCwgY29uc3QgY2hhciAqdmFsdWUpOworaW50IHNldF9jcmVkX3F1b3RlZChjb25zdCBjaGFyICppZm5hbWUsIGludCBpZCwgY29uc3QgY2hhciAqZmllbGQsCisJCSAgICBjb25zdCBjaGFyICp2YWx1ZSk7CisKKyNlbmRpZiAvKiBXUEFfSEVMUEVSU19IICovCmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL01ha2VmaWxlIGIvc3JjL2NyeXB0by9NYWtlZmlsZQppbmRleCBhNjA1YTY1Li4yYTkyMTA5IDEwMDY0NAotLS0gYS9zcmMvY3J5cHRvL01ha2VmaWxlCisrKyBiL3NyYy9jcnlwdG8vTWFrZWZpbGUKQEAgLTEsNyArMSw3IEBACiBhbGw6IGxpYmNyeXB0by5hCiAKIGNsZWFuOgotCXJtIC1mICp+ICoubyAqLmQgbGliY3J5cHRvLmEKKwlybSAtZiAqfiAqLm8gKi5kICouZ2NubyAqLmdjZGEgKi5nY292IGxpYmNyeXB0by5hCiAKIGluc3RhbGw6CiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgpAQCAtOSw2ICs5LDcgQEAKIAogaW5jbHVkZSAuLi9saWIucnVsZXMKIAorQ0ZMQUdTICs9IC1EQ09ORklHX0NSWVBUT19JTlRFUk5BTAogQ0ZMQUdTICs9IC1EQ09ORklHX1RMU19JTlRFUk5BTF9DTElFTlQKIENGTEFHUyArPSAtRENPTkZJR19UTFNfSU5URVJOQUxfU0VSVkVSCiAjQ0ZMQUdTICs9IC1EQUxMX0RIX0dST1VQUwpkaWZmIC0tZ2l0IGEvc3JjL2NyeXB0by9hZXMtY2NtLmMgYi9zcmMvY3J5cHRvL2Flcy1jY20uYwppbmRleCBkMTQ2NzBkLi5jZjIyNzc4IDEwMDY0NAotLS0gYS9zcmMvY3J5cHRvL2Flcy1jY20uYworKysgYi9zcmMvY3J5cHRvL2Flcy1jY20uYwpAQCAtMjAzLDcgKzIwMyw3IEBACiAKIAlhZXNfZW5jcnlwdF9kZWluaXQoYWVzKTsKIAotCWlmIChvc19tZW1jbXAoeCwgdCwgTSkgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QoeCwgdCwgTSkgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19FWENFU1NJVkUsICJDQ006IEF1dGggbWlzbWF0Y2giKTsKIAkJcmV0dXJuIC0xOwogCX0KZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vYWVzLWdjbS5jIGIvc3JjL2NyeXB0by9hZXMtZ2NtLmMKaW5kZXggM2Q5MWM3MS4uODQyOTRkMiAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by9hZXMtZ2NtLmMKKysrIGIvc3JjL2NyeXB0by9hZXMtZ2NtLmMKQEAgLTMxMCw3ICszMTAsNyBAQAogCiAJYWVzX2VuY3J5cHRfZGVpbml0KGFlcyk7CiAKLQlpZiAob3NfbWVtY21wKHRhZywgVCwgMTYpICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KHRhZywgVCwgMTYpICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfRVhDRVNTSVZFLCAiR0NNOiBUYWcgbWlzbWF0Y2giKTsKIAkJcmV0dXJuIC0xOwogCX0KZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vY3J5cHRvLmggYi9zcmMvY3J5cHRvL2NyeXB0by5oCmluZGV4IDliY2NhYWEuLmYyZDU2NjIgMTAwNjQ0Ci0tLSBhL3NyYy9jcnlwdG8vY3J5cHRvLmgKKysrIGIvc3JjL2NyeXB0by9jcnlwdG8uaApAQCAtMjcxLDYgKzI3MSwxMCBAQAogICovCiBzdHJ1Y3QgY3J5cHRvX3B1YmxpY19rZXkgKiBjcnlwdG9fcHVibGljX2tleV9pbXBvcnQoY29uc3QgdTggKmtleSwgc2l6ZV90IGxlbik7CiAKK3N0cnVjdCBjcnlwdG9fcHVibGljX2tleSAqCitjcnlwdG9fcHVibGljX2tleV9pbXBvcnRfcGFydHMoY29uc3QgdTggKm4sIHNpemVfdCBuX2xlbiwKKwkJCSAgICAgICBjb25zdCB1OCAqZSwgc2l6ZV90IGVfbGVuKTsKKwogLyoqCiAgKiBjcnlwdG9fcHJpdmF0ZV9rZXlfaW1wb3J0IC0gSW1wb3J0IGFuIFJTQSBwcml2YXRlIGtleQogICogQGtleTogS2V5IGJ1ZmZlciAoREVSIGVuY29kZWQgUlNBIHByaXZhdGUga2V5KQpAQCAtNTM0LDE2ICs1MzgsNiBAQAogCQkJICBzdHJ1Y3QgY3J5cHRvX2JpZ251bSAqZCk7CiAKIC8qKgotICogY3J5cHRvX2JpZ251bV9yc2hpZnQgLSBiID0gYSA+PiBuCi0gKiBAYTogQmlnbnVtCi0gKiBAbjogTnVtYmVyIG9mIGJpdHMgdG8gc2hpZnQKLSAqIEBiOiBCaWdudW07IHVzZWQgdG8gc3RvcmUgdGhlIHJlc3VsdCBvZiBhID4+IG4KLSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQotICovCi1pbnQgY3J5cHRvX2JpZ251bV9yc2hpZnQoY29uc3Qgc3RydWN0IGNyeXB0b19iaWdudW0gKmEsIGludCBuLAotCQkJIHN0cnVjdCBjcnlwdG9fYmlnbnVtICpiKTsKLQotLyoqCiAgKiBjcnlwdG9fYmlnbnVtX2ludmVyc2UgLSBJbnZlcnNlIGEgYmlnbnVtIHNvIHRoYXQgYSAqIGMgPSAxIChtb2QgYikKICAqIEBhOiBCaWdudW0KICAqIEBiOiBCaWdudW0KZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vY3J5cHRvX2ludGVybmFsLXJzYS5jIGIvc3JjL2NyeXB0by9jcnlwdG9faW50ZXJuYWwtcnNhLmMKaW5kZXggNTQyMDlmYS4uZGM3ZjM1MCAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by9jcnlwdG9faW50ZXJuYWwtcnNhLmMKKysrIGIvc3JjL2NyeXB0by9jcnlwdG9faW50ZXJuYWwtcnNhLmMKQEAgLTI2LDYgKzI2LDE1IEBACiB9CiAKIAorc3RydWN0IGNyeXB0b19wdWJsaWNfa2V5ICoKK2NyeXB0b19wdWJsaWNfa2V5X2ltcG9ydF9wYXJ0cyhjb25zdCB1OCAqbiwgc2l6ZV90IG5fbGVuLAorCQkJICAgICAgIGNvbnN0IHU4ICplLCBzaXplX3QgZV9sZW4pCit7CisJcmV0dXJuIChzdHJ1Y3QgY3J5cHRvX3B1YmxpY19rZXkgKikKKwkJY3J5cHRvX3JzYV9pbXBvcnRfcHVibGljX2tleV9wYXJ0cyhuLCBuX2xlbiwgZSwgZV9sZW4pOworfQorCisKIHN0cnVjdCBjcnlwdG9fcHJpdmF0ZV9rZXkgKiBjcnlwdG9fcHJpdmF0ZV9rZXlfaW1wb3J0KGNvbnN0IHU4ICprZXksCiAJCQkJCQkgICAgICBzaXplX3QgbGVuLAogCQkJCQkJICAgICAgY29uc3QgY2hhciAqcGFzc3dkKQpkaWZmIC0tZ2l0IGEvc3JjL2NyeXB0by9jcnlwdG9fb3BlbnNzbC5jIGIvc3JjL2NyeXB0by9jcnlwdG9fb3BlbnNzbC5jCmluZGV4IDUyMTVjMDAuLmYwMmFhYWMgMTAwNjQ0Ci0tLSBhL3NyYy9jcnlwdG8vY3J5cHRvX29wZW5zc2wuYworKysgYi9zcmMvY3J5cHRvL2NyeXB0b19vcGVuc3NsLmMKQEAgLTI2LDYgKzI2LDggQEAKICNpbmNsdWRlICJjb21tb24uaCIKICNpbmNsdWRlICJ3cGFidWYuaCIKICNpbmNsdWRlICJkaF9ncm91cDUuaCIKKyNpbmNsdWRlICJzaGExLmgiCisjaW5jbHVkZSAic2hhMjU2LmgiCiAjaW5jbHVkZSAiY3J5cHRvLmgiCiAKICNpZiBPUEVOU1NMX1ZFUlNJT05fTlVNQkVSIDwgMHgwMDkwNzAwMApAQCAtMzM4LDEwICszNDAsMTAgQEAKIAlyZXQgPSAwOwogCiBlcnJvcjoKLQlCTl9mcmVlKGJuX2Jhc2UpOwotCUJOX2ZyZWUoYm5fZXhwKTsKLQlCTl9mcmVlKGJuX21vZHVsdXMpOwotCUJOX2ZyZWUoYm5fcmVzdWx0KTsKKwlCTl9jbGVhcl9mcmVlKGJuX2Jhc2UpOworCUJOX2NsZWFyX2ZyZWUoYm5fZXhwKTsKKwlCTl9jbGVhcl9mcmVlKGJuX21vZHVsdXMpOworCUJOX2NsZWFyX2ZyZWUoYm5fcmVzdWx0KTsKIAlCTl9DVFhfZnJlZShjdHgpOwogCXJldHVybiByZXQ7CiB9CkBAIC01NjksMTIgKzU3MSwxMiBAQAogCWlmIChrZXlsZW4gPCAwKQogCQlnb3RvIGVycjsKIAl3cGFidWZfcHV0KHJlcywga2V5bGVuKTsKLQlCTl9mcmVlKHB1Yl9rZXkpOworCUJOX2NsZWFyX2ZyZWUocHViX2tleSk7CiAKIAlyZXR1cm4gcmVzOwogCiBlcnI6Ci0JQk5fZnJlZShwdWJfa2V5KTsKKwlCTl9jbGVhcl9mcmVlKHB1Yl9rZXkpOwogCXdwYWJ1Zl9mcmVlKHJlcyk7CiAJcmV0dXJuIE5VTEw7CiB9CkBAIC05MTQsMTMgKzkxNiw2IEBACiB9CiAKIAotaW50IGNyeXB0b19iaWdudW1fcnNoaWZ0KGNvbnN0IHN0cnVjdCBjcnlwdG9fYmlnbnVtICphLCBpbnQgbiwKLQkJCSBzdHJ1Y3QgY3J5cHRvX2JpZ251bSAqYikKLXsKLQlyZXR1cm4gQk5fcnNoaWZ0KChCSUdOVU0gKikgYiwgKGNvbnN0IEJJR05VTSAqKSBhLCBuKSA/IDAgOiAtMTsKLX0KLQotCiBpbnQgY3J5cHRvX2JpZ251bV9pbnZlcnNlKGNvbnN0IHN0cnVjdCBjcnlwdG9fYmlnbnVtICphLAogCQkJICBjb25zdCBzdHJ1Y3QgY3J5cHRvX2JpZ251bSAqYiwKIAkJCSAgc3RydWN0IGNyeXB0b19iaWdudW0gKmMpCkBAIC0xMDcxLDcgKzEwNjYsNyBAQAogewogCWlmIChlID09IE5VTEwpCiAJCXJldHVybjsKLQlCTl9mcmVlKGUtPm9yZGVyKTsKKwlCTl9jbGVhcl9mcmVlKGUtPm9yZGVyKTsKIAlFQ19HUk9VUF9mcmVlKGUtPmdyb3VwKTsKIAlCTl9DVFhfZnJlZShlLT5ibmN0eCk7CiAJb3NfZnJlZShlKTsKQEAgLTExNDMsOCArMTEzOCw4IEBACiAJCXJldCA9IDA7CiAJfQogCi0JQk5fZnJlZSh4X2JuKTsKLQlCTl9mcmVlKHlfYm4pOworCUJOX2NsZWFyX2ZyZWUoeF9ibik7CisJQk5fY2xlYXJfZnJlZSh5X2JuKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xMTYwLDIwICsxMTU1LDIwIEBACiAJeSA9IEJOX2JpbjJibih2YWwgKyBsZW4sIGxlbiwgTlVMTCk7CiAJZWxlbSA9IEVDX1BPSU5UX25ldyhlLT5ncm91cCk7CiAJaWYgKHggPT0gTlVMTCB8fCB5ID09IE5VTEwgfHwgZWxlbSA9PSBOVUxMKSB7Ci0JCUJOX2ZyZWUoeCk7Ci0JCUJOX2ZyZWUoeSk7Ci0JCUVDX1BPSU5UX2ZyZWUoZWxlbSk7CisJCUJOX2NsZWFyX2ZyZWUoeCk7CisJCUJOX2NsZWFyX2ZyZWUoeSk7CisJCUVDX1BPSU5UX2NsZWFyX2ZyZWUoZWxlbSk7CiAJCXJldHVybiBOVUxMOwogCX0KIAogCWlmICghRUNfUE9JTlRfc2V0X2FmZmluZV9jb29yZGluYXRlc19HRnAoZS0+Z3JvdXAsIGVsZW0sIHgsIHksCiAJCQkJCQkgZS0+Ym5jdHgpKSB7Ci0JCUVDX1BPSU5UX2ZyZWUoZWxlbSk7CisJCUVDX1BPSU5UX2NsZWFyX2ZyZWUoZWxlbSk7CiAJCWVsZW0gPSBOVUxMOwogCX0KIAotCUJOX2ZyZWUoeCk7Ci0JQk5fZnJlZSh5KTsKKwlCTl9jbGVhcl9mcmVlKHgpOworCUJOX2NsZWFyX2ZyZWUoeSk7CiAKIAlyZXR1cm4gKHN0cnVjdCBjcnlwdG9fZWNfcG9pbnQgKikgZWxlbTsKIH0KZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vZGhfZ3JvdXBzLmMgYi9zcmMvY3J5cHRvL2RoX2dyb3Vwcy5jCmluZGV4IDNhNjc1ZGYuLjU4ZTk0YzMgMTAwNjQ0Ci0tLSBhL3NyYy9jcnlwdG8vZGhfZ3JvdXBzLmMKKysrIGIvc3JjL2NyeXB0by9kaF9ncm91cHMuYwpAQCAtMTE2OSw3ICsxMTY5LDcgQEAKICNlbmRpZiAvKiBBTExfREhfR1JPVVBTICovCiB9OwogCi0jZGVmaW5lIE5VTV9ESF9HUk9VUFMgKHNpemVvZihkaF9ncm91cHMpIC8gc2l6ZW9mKGRoX2dyb3Vwc1swXSkpCisjZGVmaW5lIE5VTV9ESF9HUk9VUFMgQVJSQVlfU0laRShkaF9ncm91cHMpCiAKIAogY29uc3Qgc3RydWN0IGRoX2dyb3VwICogZGhfZ3JvdXBzX2dldChpbnQgaWQpCmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL2ZpcHNfcHJmX2NyeXB0b2FwaS5jIGIvc3JjL2NyeXB0by9maXBzX3ByZl9jcnlwdG9hcGkuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGNhOTNhMy4uMDAwMDAwMAotLS0gYS9zcmMvY3J5cHRvL2ZpcHNfcHJmX2NyeXB0b2FwaS5jCisrKyAvZGV2L251bGwKQEAgLTEsMTkgKzAsMCBAQAotLyoKLSAqIEZJUFMgMTg2LTIgUFJGIGZvciBNaWNyb3NvZnQgQ3J5cHRvQVBJCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+Ci0gKgotICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KLSAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KLSAqLwotCi0jaW5jbHVkZSAiaW5jbHVkZXMuaCIKLQotI2luY2x1ZGUgImNvbW1vbi5oIgotI2luY2x1ZGUgImNyeXB0by5oIgotCi0KLWludCBmaXBzMTg2XzJfcHJmKGNvbnN0IHU4ICpzZWVkLCBzaXplX3Qgc2VlZF9sZW4sIHU4ICp4LCBzaXplX3QgeGxlbikKLXsKLQkvKiBGSVg6IGhvdyB0byBkbyB0aGlzIHdpdGggQ3J5cHRvQVBJPyAqLwotCXJldHVybiAtMTsKLX0KZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vZmlwc19wcmZfZ251dGxzLmMgYi9zcmMvY3J5cHRvL2ZpcHNfcHJmX2dudXRscy5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5NDdlNmY2Li4wMDAwMDAwCi0tLSBhL3NyYy9jcnlwdG8vZmlwc19wcmZfZ251dGxzLmMKKysrIC9kZXYvbnVsbApAQCAtMSwyMCArMCwwIEBACi0vKgotICogRklQUyAxODYtMiBQUkYgZm9yIGxpYmdjcnlwdAotICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+Ci0gKgotICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KLSAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KLSAqLwotCi0jaW5jbHVkZSAiaW5jbHVkZXMuaCIKLSNpbmNsdWRlIDxnY3J5cHQuaD4KLQotI2luY2x1ZGUgImNvbW1vbi5oIgotI2luY2x1ZGUgImNyeXB0by5oIgotCi0KLWludCBmaXBzMTg2XzJfcHJmKGNvbnN0IHU4ICpzZWVkLCBzaXplX3Qgc2VlZF9sZW4sIHU4ICp4LCBzaXplX3QgeGxlbikKLXsKLQkvKiBGSVg6IGhvdyB0byBkbyB0aGlzIHdpdGggbGliZ2NyeXB0PyAqLwotCXJldHVybiAtMTsKLX0KZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vZmlwc19wcmZfbnNzLmMgYi9zcmMvY3J5cHRvL2ZpcHNfcHJmX25zcy5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyYzk2MmY0Li4wMDAwMDAwCi0tLSBhL3NyYy9jcnlwdG8vZmlwc19wcmZfbnNzLmMKKysrIC9kZXYvbnVsbApAQCAtMSwxOSArMCwwIEBACi0vKgotICogRklQUyAxODYtMiBQUkYgZm9yIE5TUwotICogQ29weXJpZ2h0IChjKSAyMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgotICoKLSAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCi0gKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCi0gKi8KLQotI2luY2x1ZGUgImluY2x1ZGVzLmgiCi0jaW5jbHVkZSA8b3BlbnNzbC9zaGEuaD4KLQotI2luY2x1ZGUgImNvbW1vbi5oIgotI2luY2x1ZGUgImNyeXB0by5oIgotCi0KLWludCBmaXBzMTg2XzJfcHJmKGNvbnN0IHU4ICpzZWVkLCBzaXplX3Qgc2VlZF9sZW4sIHU4ICp4LCBzaXplX3QgeGxlbikKLXsKLQlyZXR1cm4gLTE7Ci19CmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL21pbGVuYWdlLmMgYi9zcmMvY3J5cHRvL21pbGVuYWdlLmMKaW5kZXggYTdmOWM2YS4uNmVkZWE1NyAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by9taWxlbmFnZS5jCisrKyBiL3NyYy9jcnlwdG8vbWlsZW5hZ2UuYwpAQCAtMjE3LDcgKzIxNyw3IEBACiAJZm9yIChpID0gMDsgaSA8IDY7IGkrKykKIAkJc3FuW2ldID0gYXV0c1tpXSBeIGFrW2ldOwogCWlmIChtaWxlbmFnZV9mMShvcGMsIGssIF9yYW5kLCBzcW4sIGFtZiwgTlVMTCwgbWFjX3MpIHx8Ci0JICAgIG1lbWNtcChtYWNfcywgYXV0cyArIDYsIDgpICE9IDApCisJICAgIG9zX21lbWNtcF9jb25zdChtYWNfcywgYXV0cyArIDYsIDgpICE9IDApCiAJCXJldHVybiAtMTsKIAlyZXR1cm4gMDsKIH0KQEAgLTMxMiw3ICszMTIsNyBAQAogCiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiTWlsZW5hZ2U6IE1BQ19BIiwgbWFjX2EsIDgpOwogCi0JaWYgKG9zX21lbWNtcChtYWNfYSwgYXV0biArIDgsIDgpICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KG1hY19hLCBhdXRuICsgOCwgOCkgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk1pbGVuYWdlOiBNQUMgbWlzbWF0Y2giKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiTWlsZW5hZ2U6IFJlY2VpdmVkIE1BQ19BIiwKIAkJCSAgICBhdXRuICsgOCwgOCk7CmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL21zX2Z1bmNzLmMgYi9zcmMvY3J5cHRvL21zX2Z1bmNzLmMKaW5kZXggYjJiYmFiMi4uNDlhNWMxYyAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by9tc19mdW5jcy5jCisrKyBiL3NyYy9jcnlwdG8vbXNfZnVuY3MuYwpAQCAtNTgsNiArNTgsNyBAQAogCQkJCVdQQV9QVVRfTEUxNih1Y3MyX2J1ZmZlciArIGosCiAJCQkJCSAgICAgKChjICYgMHhGKSA8PCAxMikgfAogCQkJCQkgICAgICgoYzIgJiAweDNGKSA8PCA2KSB8IChjMyAmIDB4M0YpKTsKKwkJCQlqICs9IDI7CiAJCQl9CiAJCX0KIAl9CmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwuYyBiL3NyYy9jcnlwdG8vc2hhMS1pbnRlcm5hbC5jCmluZGV4IDEwYmYxNTMuLjI0YmMzZmYgMTAwNjQ0Ci0tLSBhL3NyYy9jcnlwdG8vc2hhMS1pbnRlcm5hbC5jCisrKyBiL3NyYy9jcnlwdG8vc2hhMS1pbnRlcm5hbC5jCkBAIC0xOSw2ICsxOSw3IEBACiB2b2lkIFNIQTFUcmFuc2Zvcm0odTMyIHN0YXRlWzVdLCBjb25zdCB1bnNpZ25lZCBjaGFyIGJ1ZmZlcls2NF0pOwogCiAKKyNpZmRlZiBDT05GSUdfQ1JZUFRPX0lOVEVSTkFMCiAvKioKICAqIHNoYTFfdmVjdG9yIC0gU0hBLTEgaGFzaCBmb3IgZGF0YSB2ZWN0b3IKICAqIEBudW1fZWxlbTogTnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkYXRhIHZlY3RvcgpAQCAtMzgsNiArMzksNyBAQAogCVNIQTFGaW5hbChtYWMsICZjdHgpOwogCXJldHVybiAwOwogfQorI2VuZGlmIC8qIENPTkZJR19DUllQVE9fSU5URVJOQUwgKi8KIAogCiAvKiA9PT09PSBzdGFydCAtIHB1YmxpYyBkb21haW4gU0hBMSBpbXBsZW1lbnRhdGlvbiA9PT09PSAqLwpkaWZmIC0tZ2l0IGEvc3JjL2NyeXB0by90bHMuaCBiL3NyYy9jcnlwdG8vdGxzLmgKaW5kZXggMmZkYWEwMi4uNjVlMGY3OSAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by90bHMuaAorKysgYi9zcmMvY3J5cHRvL3Rscy5oCkBAIC00MCw3ICs0MCw4IEBACiAJVExTX0ZBSUxfU1VCSkVDVF9NSVNNQVRDSCA9IDUsCiAJVExTX0ZBSUxfQUxUU1VCSkVDVF9NSVNNQVRDSCA9IDYsCiAJVExTX0ZBSUxfQkFEX0NFUlRJRklDQVRFID0gNywKLQlUTFNfRkFJTF9TRVJWRVJfQ0hBSU5fUFJPQkUgPSA4CisJVExTX0ZBSUxfU0VSVkVSX0NIQUlOX1BST0JFID0gOCwKKwlUTFNfRkFJTF9ET01BSU5fU1VGRklYX01JU01BVENIID0gOQogfTsKIAogdW5pb24gdGxzX2V2ZW50X2RhdGEgewpAQCAtODQsNiArODUsOCBAQAogI2RlZmluZSBUTFNfQ09OTl9ESVNBQkxFX1NFU1NJT05fVElDS0VUIEJJVCgyKQogI2RlZmluZSBUTFNfQ09OTl9SRVFVRVNUX09DU1AgQklUKDMpCiAjZGVmaW5lIFRMU19DT05OX1JFUVVJUkVfT0NTUCBCSVQoNCkKKyNkZWZpbmUgVExTX0NPTk5fRElTQUJMRV9UTFN2MV8xIEJJVCg1KQorI2RlZmluZSBUTFNfQ09OTl9ESVNBQkxFX1RMU3YxXzIgQklUKDYpCiAKIC8qKgogICogc3RydWN0IHRsc19jb25uZWN0aW9uX3BhcmFtcyAtIFBhcmFtZXRlcnMgZm9yIFRMUyBjb25uZWN0aW9uCkBAIC05Niw2ICs5OSw4IEBACiAgKiAlTlVMTCB0byBhbGxvdyBhbGwgc3ViamVjdHMKICAqIEBhbHRzdWJqZWN0X21hdGNoOiBTdHJpbmcgdG8gbWF0Y2ggaW4gdGhlIGFsdGVybmF0aXZlIHN1YmplY3Qgb2YgdGhlIHBlZXIKICAqIGNlcnRpZmljYXRlIG9yICVOVUxMIHRvIGFsbG93IGFsbCBhbHRlcm5hdGl2ZSBzdWJqZWN0cworICogQHN1ZmZpeF9tYXRjaDogU3RyaW5nIHRvIHN1ZmZpeCBtYXRjaCBpbiB0aGUgZE5TTmFtZSBvciBDTiBvZiB0aGUgcGVlcgorICogY2VydGlmaWNhdGUgb3IgJU5VTEwgdG8gYWxsb3cgYWxsIGRvbWFpbiBuYW1lcwogICogQGNsaWVudF9jZXJ0OiBGaWxlIG9yIHJlZmVyZW5jZSBuYW1lIGZvciBjbGllbnQgWC41MDkgY2VydGlmaWNhdGUgaW4gUEVNIG9yCiAgKiBERVIgZm9ybWF0CiAgKiBAY2xpZW50X2NlcnRfYmxvYjogY2xpZW50X2NlcnQgYXMgaW5saW5lZCBkYXRhIG9yICVOVUxMIGlmIG5vdCB1c2VkCkBAIC0xMzcsNiArMTQyLDcgQEAKIAljb25zdCBjaGFyICpjYV9wYXRoOwogCWNvbnN0IGNoYXIgKnN1YmplY3RfbWF0Y2g7CiAJY29uc3QgY2hhciAqYWx0c3ViamVjdF9tYXRjaDsKKwljb25zdCBjaGFyICpzdWZmaXhfbWF0Y2g7CiAJY29uc3QgY2hhciAqY2xpZW50X2NlcnQ7CiAJY29uc3QgdTggKmNsaWVudF9jZXJ0X2Jsb2I7CiAJc2l6ZV90IGNsaWVudF9jZXJ0X2Jsb2JfbGVuOwpAQCAtNTMxLDQgKzUzNywxOSBAQAogCXZvaWQgKnRsc19jdHgsIHN0cnVjdCB0bHNfY29ubmVjdGlvbiAqY29ubiwKIAl0bHNfc2Vzc2lvbl90aWNrZXRfY2IgY2IsIHZvaWQgKmN0eCk7CiAKK3ZvaWQgdGxzX2Nvbm5lY3Rpb25fc2V0X2xvZ19jYihzdHJ1Y3QgdGxzX2Nvbm5lY3Rpb24gKmNvbm4sCisJCQkgICAgICAgdm9pZCAoKmxvZ19jYikodm9pZCAqY3R4LCBjb25zdCBjaGFyICptc2cpLAorCQkJICAgICAgIHZvaWQgKmN0eCk7CisKKyNkZWZpbmUgVExTX0JSRUFLX1ZFUklGWV9EQVRBIEJJVCgwKQorI2RlZmluZSBUTFNfQlJFQUtfU1JWX0tFWV9YX0hBU0ggQklUKDEpCisjZGVmaW5lIFRMU19CUkVBS19TUlZfS0VZX1hfU0lHTkFUVVJFIEJJVCgyKQorI2RlZmluZSBUTFNfREhFX1BSSU1FXzUxMUIgQklUKDMpCisjZGVmaW5lIFRMU19ESEVfUFJJTUVfNzY3QiBCSVQoNCkKKyNkZWZpbmUgVExTX0RIRV9QUklNRV8xNSBCSVQoNSkKKyNkZWZpbmUgVExTX0RIRV9QUklNRV81OEIgQklUKDYpCisjZGVmaW5lIFRMU19ESEVfTk9OX1BSSU1FIEJJVCg3KQorCit2b2lkIHRsc19jb25uZWN0aW9uX3NldF90ZXN0X2ZsYWdzKHN0cnVjdCB0bHNfY29ubmVjdGlvbiAqY29ubiwgdTMyIGZsYWdzKTsKKwogI2VuZGlmIC8qIFRMU19IICovCmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL3Rsc19nbnV0bHMuYyBiL3NyYy9jcnlwdG8vdGxzX2dudXRscy5jCmluZGV4IGE1ZDcyZjQuLmNiMjNlYjkgMTAwNjQ0Ci0tLSBhL3NyYy9jcnlwdG8vdGxzX2dudXRscy5jCisrKyBiL3NyYy9jcnlwdG8vdGxzX2dudXRscy5jCkBAIC0xMjUsOCArMTI1LDYgQEAKIH0KIAogCi1leHRlcm4gaW50IHdwYV9kZWJ1Z19zaG93X2tleXM7Ci0KIHZvaWQgKiB0bHNfaW5pdChjb25zdCBzdHJ1Y3QgdGxzX2NvbmZpZyAqY29uZikKIHsKIAlzdHJ1Y3QgdGxzX2dsb2JhbCAqZ2xvYmFsOwpkaWZmIC0tZ2l0IGEvc3JjL2NyeXB0by90bHNfaW50ZXJuYWwuYyBiL3NyYy9jcnlwdG8vdGxzX2ludGVybmFsLmMKaW5kZXggOTFmMDY5MC4uNjU2M2VkMiAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by90bHNfaW50ZXJuYWwuYworKysgYi9zcmMvY3J5cHRvL3Rsc19pbnRlcm5hbC5jCkBAIC0yOCw2ICsyOCw3IEBACiBzdHJ1Y3QgdGxzX2Nvbm5lY3Rpb24gewogCXN0cnVjdCB0bHN2MV9jbGllbnQgKmNsaWVudDsKIAlzdHJ1Y3QgdGxzdjFfc2VydmVyICpzZXJ2ZXI7CisJc3RydWN0IHRsc19nbG9iYWwgKmdsb2JhbDsKIH07CiAKIApAQCAtODUsNiArODYsNyBAQAogCWNvbm4gPSBvc196YWxsb2Moc2l6ZW9mKCpjb25uKSk7CiAJaWYgKGNvbm4gPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CisJY29ubi0+Z2xvYmFsID0gZ2xvYmFsOwogCiAjaWZkZWYgQ09ORklHX1RMU19JTlRFUk5BTF9DTElFTlQKIAlpZiAoIWdsb2JhbC0+c2VydmVyKSB7CkBAIC0xMDksNiArMTExLDI4IEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKyNpZmRlZiBDT05GSUdfVExTX0lOVEVSTkFMX1NFUlZFUgordm9pZCB0bHNfY29ubmVjdGlvbl9zZXRfdGVzdF9mbGFncyhzdHJ1Y3QgdGxzX2Nvbm5lY3Rpb24gKmNvbm4sIHUzMiBmbGFncykKK3sKKwlpZiAoY29ubi0+c2VydmVyKQorCQl0bHN2MV9zZXJ2ZXJfc2V0X3Rlc3RfZmxhZ3MoY29ubi0+c2VydmVyLCBmbGFncyk7Cit9CisjZW5kaWYgLyogQ09ORklHX1RMU19JTlRFUk5BTF9TRVJWRVIgKi8KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCisKKwordm9pZCB0bHNfY29ubmVjdGlvbl9zZXRfbG9nX2NiKHN0cnVjdCB0bHNfY29ubmVjdGlvbiAqY29ubiwKKwkJCSAgICAgICB2b2lkICgqbG9nX2NiKSh2b2lkICpjdHgsIGNvbnN0IGNoYXIgKm1zZyksCisJCQkgICAgICAgdm9pZCAqY3R4KQoreworI2lmZGVmIENPTkZJR19UTFNfSU5URVJOQUxfU0VSVkVSCisJaWYgKGNvbm4tPnNlcnZlcikKKwkJdGxzdjFfc2VydmVyX3NldF9sb2dfY2IoY29ubi0+c2VydmVyLCBsb2dfY2IsIGN0eCk7CisjZW5kaWYgLyogQ09ORklHX1RMU19JTlRFUk5BTF9TRVJWRVIgKi8KK30KKworCiB2b2lkIHRsc19jb25uZWN0aW9uX2RlaW5pdCh2b2lkICp0bHNfY3R4LCBzdHJ1Y3QgdGxzX2Nvbm5lY3Rpb24gKmNvbm4pCiB7CiAJaWYgKGNvbm4gPT0gTlVMTCkKZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vdGxzX29wZW5zc2wuYyBiL3NyYy9jcnlwdG8vdGxzX29wZW5zc2wuYwppbmRleCBkMjdhZjBhLi5kMmQ2NjAwIDEwMDY0NAotLS0gYS9zcmMvY3J5cHRvL3Rsc19vcGVuc3NsLmMKKysrIGIvc3JjL2NyeXB0by90bHNfb3BlbnNzbC5jCkBAIC00OCwyMyArNDgsNiBAQAogI2VuZGlmCiAjZW5kaWYKIAotI2lmZGVmIEFORFJPSUQKLSNpbmNsdWRlIDxvcGVuc3NsL3BlbS5oPgotI2luY2x1ZGUgPGtleXN0b3JlL2tleXN0b3JlX2dldC5oPgotCi1zdGF0aWMgQklPICogQklPX2Zyb21fa2V5c3RvcmUoY29uc3QgY2hhciAqa2V5KQotewotICAgIEJJTyAqYmlvID0gTlVMTDsKLSAgICB1aW50OF90ICp2YWx1ZSA9IE5VTEw7Ci0gICAgaW50IGxlbmd0aCA9IGtleXN0b3JlX2dldChrZXksIHN0cmxlbihrZXkpLCAmdmFsdWUpOwotICAgIGlmIChsZW5ndGggIT0gLTEgJiYgKGJpbyA9IEJJT19uZXcoQklPX3NfbWVtKCkpKSAhPSBOVUxMKSB7Ci0gICAgICAgIEJJT193cml0ZShiaW8sIHZhbHVlLCBsZW5ndGgpOwotICAgIH0KLSAgICBmcmVlKHZhbHVlKTsKLSAgICByZXR1cm4gYmlvOwotfQotI2VuZGlmIC8qIEFORFJPSUQgKi8KLQogI2lmZGVmIFNTTF9zZXRfdGxzZXh0X3N0YXR1c190eXBlCiAjaWZuZGVmIE9QRU5TU0xfTk9fVExTRVhUCiAjZGVmaW5lIEhBVkVfT0NTUApAQCAtNzIsNiArNTUsMjIgQEAKICNlbmRpZiAvKiBPUEVOU1NMX05PX1RMU0VYVCAqLwogI2VuZGlmIC8qIFNTTF9zZXRfdGxzZXh0X3N0YXR1c190eXBlICovCiAKKyNpZmRlZiBBTkRST0lECisjaW5jbHVkZSA8b3BlbnNzbC9wZW0uaD4KKyNpbmNsdWRlIDxrZXlzdG9yZS9rZXlzdG9yZV9nZXQuaD4KKworc3RhdGljIEJJTyAqIEJJT19mcm9tX2tleXN0b3JlKGNvbnN0IGNoYXIgKmtleSkKK3sKKwlCSU8gKmJpbyA9IE5VTEw7CisJdWludDhfdCAqdmFsdWUgPSBOVUxMOworCWludCBsZW5ndGggPSBrZXlzdG9yZV9nZXQoa2V5LCBzdHJsZW4oa2V5KSwgJnZhbHVlKTsKKwlpZiAobGVuZ3RoICE9IC0xICYmIChiaW8gPSBCSU9fbmV3KEJJT19zX21lbSgpKSkgIT0gTlVMTCkKKwkJQklPX3dyaXRlKGJpbywgdmFsdWUsIGxlbmd0aCk7CisJZnJlZSh2YWx1ZSk7CisJcmV0dXJuIGJpbzsKK30KKyNlbmRpZiAvKiBBTkRST0lEICovCisKIHN0YXRpYyBpbnQgdGxzX29wZW5zc2xfcmVmX2NvdW50ID0gMDsKIAogc3RydWN0IHRsc19jb250ZXh0IHsKQEAgLTkzLDcgKzkyLDcgQEAKIAlFTkdJTkUgKmVuZ2luZTsgICAgICAgIC8qIGZ1bmN0aW9uYWwgcmVmZXJlbmNlIHRvIHRoZSBlbmdpbmUgKi8KIAlFVlBfUEtFWSAqcHJpdmF0ZV9rZXk7IC8qIHRoZSBwcml2YXRlIGtleSBpZiB1c2luZyBlbmdpbmUgKi8KICNlbmRpZiAvKiBPUEVOU1NMX05PX0VOR0lORSAqLwotCWNoYXIgKnN1YmplY3RfbWF0Y2gsICphbHRzdWJqZWN0X21hdGNoOworCWNoYXIgKnN1YmplY3RfbWF0Y2gsICphbHRzdWJqZWN0X21hdGNoLCAqc3VmZml4X21hdGNoOwogCWludCByZWFkX2FsZXJ0cywgd3JpdGVfYWxlcnRzLCBmYWlsZWQ7CiAKIAl0bHNfc2Vzc2lvbl90aWNrZXRfY2Igc2Vzc2lvbl90aWNrZXRfY2I7CkBAIC0xMDYsNiArMTA1LDcgQEAKIAl1bnNpZ25lZCBpbnQgY2FfY2VydF92ZXJpZnk6MTsKIAl1bnNpZ25lZCBpbnQgY2VydF9wcm9iZToxOwogCXVuc2lnbmVkIGludCBzZXJ2ZXJfY2VydF9vbmx5OjE7CisJdW5zaWduZWQgaW50IGludmFsaWRfaGJfdXNlZDoxOwogCiAJdTggc3J2X2NlcnRfaGFzaFszMl07CiAKQEAgLTExMyw2ICsxMTMsNyBAQAogCiAJWDUwOSAqcGVlcl9jZXJ0OwogCVg1MDkgKnBlZXJfaXNzdWVyOworCVg1MDkgKnBlZXJfaXNzdWVyX2lzc3VlcjsKIH07CiAKIApAQCAtNzg1LDEyICs3ODYsMTMgQEAKIAkJUEtDUzEyX1BCRV9hZGQoKTsKICNlbmRpZiAgLyogUEtDUzEyX0ZVTkNTICovCiAJfSBlbHNlIHsKLQkJY29udGV4dCA9IHRsc19nbG9iYWw7CiAjaWZkZWYgT1BFTlNTTF9TVVBQT1JUU19DVFhfQVBQX0RBVEEKIAkJLyogTmV3ZXIgT3BlblNTTCBjYW4gc3RvcmUgYXBwLWRhdGEgcGVyLVNTTCAqLwogCQljb250ZXh0ID0gdGxzX2NvbnRleHRfbmV3KGNvbmYpOwogCQlpZiAoY29udGV4dCA9PSBOVUxMKQogCQkJcmV0dXJuIE5VTEw7CisjZWxzZSAvKiBPUEVOU1NMX1NVUFBPUlRTX0NUWF9BUFBfREFUQSAqLworCQljb250ZXh0ID0gdGxzX2dsb2JhbDsKICNlbmRpZiAvKiBPUEVOU1NMX1NVUFBPUlRTX0NUWF9BUFBfREFUQSAqLwogCX0KIAl0bHNfb3BlbnNzbF9yZWZfY291bnQrKzsKQEAgLTc5OCwxMSArODAwLDEzIEBACiAJc3NsID0gU1NMX0NUWF9uZXcoVExTdjFfbWV0aG9kKCkpOwogCWlmIChzc2wgPT0gTlVMTCkgewogCQl0bHNfb3BlbnNzbF9yZWZfY291bnQtLTsKKyNpZmRlZiBPUEVOU1NMX1NVUFBPUlRTX0NUWF9BUFBfREFUQQorCQlpZiAoY29udGV4dCAhPSB0bHNfZ2xvYmFsKQorCQkJb3NfZnJlZShjb250ZXh0KTsKKyNlbmRpZiAvKiBPUEVOU1NMX1NVUFBPUlRTX0NUWF9BUFBfREFUQSAqLwogCQlpZiAodGxzX29wZW5zc2xfcmVmX2NvdW50ID09IDApIHsKIAkJCW9zX2ZyZWUodGxzX2dsb2JhbCk7CiAJCQl0bHNfZ2xvYmFsID0gTlVMTDsKLQkJfSBlbHNlIGlmIChjb250ZXh0ICE9IHRsc19nbG9iYWwpIHsKLQkJCW9zX2ZyZWUoY29udGV4dCk7CiAJCX0KIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtOTgxLDE0ICs5ODUsMzUgQEAKIAlyZXR1cm4gY291bnQ7CiB9CiAKKworc3RhdGljIHZvaWQgdGxzX21zZ19jYihpbnQgd3JpdGVfcCwgaW50IHZlcnNpb24sIGludCBjb250ZW50X3R5cGUsCisJCSAgICAgICBjb25zdCB2b2lkICpidWYsIHNpemVfdCBsZW4sIFNTTCAqc3NsLCB2b2lkICphcmcpCit7CisJc3RydWN0IHRsc19jb25uZWN0aW9uICpjb25uID0gYXJnOworCWNvbnN0IHU4ICpwb3MgPSBidWY7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6ICVzIHZlcj0weCV4IGNvbnRlbnRfdHlwZT0lZCIsCisJCSAgIHdyaXRlX3AgPyAiVFgiIDogIlJYIiwgdmVyc2lvbiwgY29udGVudF90eXBlKTsKKwl3cGFfaGV4ZHVtcF9rZXkoTVNHX01TR0RVTVAsICJPcGVuU1NMOiBNZXNzYWdlIiwgYnVmLCBsZW4pOworCWlmIChjb250ZW50X3R5cGUgPT0gMjQgJiYgbGVuID49IDMgJiYgcG9zWzBdID09IDEpIHsKKwkJc2l6ZV90IHBheWxvYWRfbGVuID0gV1BBX0dFVF9CRTE2KHBvcyArIDEpOworCQlpZiAocGF5bG9hZF9sZW4gKyAzID4gbGVuKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIk9wZW5TU0w6IEhlYXJ0YmVhdCBhdHRhY2sgZGV0ZWN0ZWQiKTsKKwkJCWNvbm4tPmludmFsaWRfaGJfdXNlZCA9IDE7CisJCX0KKwl9Cit9CisKKwogc3RydWN0IHRsc19jb25uZWN0aW9uICogdGxzX2Nvbm5lY3Rpb25faW5pdCh2b2lkICpzc2xfY3R4KQogewogCVNTTF9DVFggKnNzbCA9IHNzbF9jdHg7CiAJc3RydWN0IHRsc19jb25uZWN0aW9uICpjb25uOwogCWxvbmcgb3B0aW9uczsKLQlzdHJ1Y3QgdGxzX2NvbnRleHQgKmNvbnRleHQgPSB0bHNfZ2xvYmFsOwogI2lmZGVmIE9QRU5TU0xfU1VQUE9SVFNfQ1RYX0FQUF9EQVRBCi0JY29udGV4dCA9IFNTTF9DVFhfZ2V0X2FwcF9kYXRhKHNzbCk7CisJc3RydWN0IHRsc19jb250ZXh0ICpjb250ZXh0ID0gU1NMX0NUWF9nZXRfYXBwX2RhdGEoc3NsKTsKKyNlbHNlIC8qIE9QRU5TU0xfU1VQUE9SVFNfQ1RYX0FQUF9EQVRBICovCisJc3RydWN0IHRsc19jb250ZXh0ICpjb250ZXh0ID0gdGxzX2dsb2JhbDsKICNlbmRpZiAvKiBPUEVOU1NMX1NVUFBPUlRTX0NUWF9BUFBfREFUQSAqLwogCiAJY29ubiA9IG9zX3phbGxvYyhzaXplb2YoKmNvbm4pKTsKQEAgLTEwMDQsMTYgKzEwMjksMTMgQEAKIAogCWNvbm4tPmNvbnRleHQgPSBjb250ZXh0OwogCVNTTF9zZXRfYXBwX2RhdGEoY29ubi0+c3NsLCBjb25uKTsKKwlTU0xfc2V0X21zZ19jYWxsYmFjayhjb25uLT5zc2wsIHRsc19tc2dfY2IpOworCVNTTF9zZXRfbXNnX2NhbGxiYWNrX2FyZyhjb25uLT5zc2wsIGNvbm4pOwogCW9wdGlvbnMgPSBTU0xfT1BfTk9fU1NMdjIgfCBTU0xfT1BfTk9fU1NMdjMgfAogCQlTU0xfT1BfU0lOR0xFX0RIX1VTRTsKICNpZmRlZiBTU0xfT1BfTk9fQ09NUFJFU1NJT04KIAlvcHRpb25zIHw9IFNTTF9PUF9OT19DT01QUkVTU0lPTjsKICNlbmRpZiAvKiBTU0xfT1BfTk9fQ09NUFJFU1NJT04gKi8KLSNpZmRlZiBBTkRST0lECi0Jb3B0aW9ucyB8PSBTU0xfT1BfTk9fVExTdjFfMTsKLQlvcHRpb25zIHw9IFNTTF9PUF9OT19UTFN2MV8yOwotCW9wdGlvbnMgfD0gU1NMX09QX05PX1RJQ0tFVDsKLSNlbmRpZiAvKiBBTkRST0lEICovCiAJU1NMX3NldF9vcHRpb25zKGNvbm4tPnNzbCwgb3B0aW9ucyk7CiAKIAljb25uLT5zc2xfaW4gPSBCSU9fbmV3KEJJT19zX21lbSgpKTsKQEAgLTEwNDksNiArMTA3MSw3IEBACiAJdGxzX2VuZ2luZV9kZWluaXQoY29ubik7CiAJb3NfZnJlZShjb25uLT5zdWJqZWN0X21hdGNoKTsKIAlvc19mcmVlKGNvbm4tPmFsdHN1YmplY3RfbWF0Y2gpOworCW9zX2ZyZWUoY29ubi0+c3VmZml4X21hdGNoKTsKIAlvc19mcmVlKGNvbm4tPnNlc3Npb25fdGlja2V0KTsKIAlvc19mcmVlKGNvbm4pOwogfQpAQCAtMTEzOSw2ICsxMTYyLDEwNCBAQAogfQogCiAKKyNpZm5kZWYgQ09ORklHX05BVElWRV9XSU5ET1dTCitzdGF0aWMgaW50IGRvbWFpbl9zdWZmaXhfbWF0Y2goY29uc3QgdTggKnZhbCwgc2l6ZV90IGxlbiwgY29uc3QgY2hhciAqbWF0Y2gpCit7CisJc2l6ZV90IGksIG1hdGNoX2xlbjsKKworCS8qIENoZWNrIGZvciBlbWJlZGRlZCBudWxzIHRoYXQgY291bGQgbWVzcyB1cCBzdWZmaXggbWF0Y2hpbmcgKi8KKwlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKKwkJaWYgKHZhbFtpXSA9PSAnXDAnKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMUzogRW1iZWRkZWQgbnVsbCBpbiBhIHN0cmluZyAtIHJlamVjdCIpOworCQkJcmV0dXJuIDA7CisJCX0KKwl9CisKKwltYXRjaF9sZW4gPSBvc19zdHJsZW4obWF0Y2gpOworCWlmIChtYXRjaF9sZW4gPiBsZW4pCisJCXJldHVybiAwOworCisJaWYgKG9zX3N0cm5jYXNlY21wKChjb25zdCBjaGFyICopIHZhbCArIGxlbiAtIG1hdGNoX2xlbiwgbWF0Y2gsCisJCQkgICBtYXRjaF9sZW4pICE9IDApCisJCXJldHVybiAwOyAvKiBubyBtYXRjaCAqLworCisJaWYgKG1hdGNoX2xlbiA9PSBsZW4pCisJCXJldHVybiAxOyAvKiBleGFjdCBtYXRjaCAqLworCisJaWYgKHZhbFtsZW4gLSBtYXRjaF9sZW4gLSAxXSA9PSAnLicpCisJCXJldHVybiAxOyAvKiBmdWxsIGxhYmVsIG1hdGNoIGNvbXBsZXRlcyBzdWZmaXggbWF0Y2ggKi8KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTOiBSZWplY3QgZHVlIHRvIGluY29tcGxldGUgbGFiZWwgbWF0Y2giKTsKKwlyZXR1cm4gMDsKK30KKyNlbmRpZiAvKiBDT05GSUdfTkFUSVZFX1dJTkRPV1MgKi8KKworCitzdGF0aWMgaW50IHRsc19tYXRjaF9zdWZmaXgoWDUwOSAqY2VydCwgY29uc3QgY2hhciAqbWF0Y2gpCit7CisjaWZkZWYgQ09ORklHX05BVElWRV9XSU5ET1dTCisJLyogd2luY3J5cHQuaCBoYXMgY29uZmxpY3RpbmcgWDUwOV9OQU1FIGRlZmluaXRpb24gKi8KKwlyZXR1cm4gLTE7CisjZWxzZSAvKiBDT05GSUdfTkFUSVZFX1dJTkRPV1MgKi8KKwlHRU5FUkFMX05BTUUgKmdlbjsKKwl2b2lkICpleHQ7CisJaW50IGk7CisJaW50IGRuc19uYW1lID0gMDsKKwlYNTA5X05BTUUgKm5hbWU7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMUzogTWF0Y2ggZG9tYWluIGFnYWluc3Qgc3VmZml4ICVzIiwgbWF0Y2gpOworCisJZXh0ID0gWDUwOV9nZXRfZXh0X2QyaShjZXJ0LCBOSURfc3ViamVjdF9hbHRfbmFtZSwgTlVMTCwgTlVMTCk7CisKKwlmb3IgKGkgPSAwOyBleHQgJiYgaSA8IHNrX0dFTkVSQUxfTkFNRV9udW0oZXh0KTsgaSsrKSB7CisJCWdlbiA9IHNrX0dFTkVSQUxfTkFNRV92YWx1ZShleHQsIGkpOworCQlpZiAoZ2VuLT50eXBlICE9IEdFTl9ETlMpCisJCQljb250aW51ZTsKKwkJZG5zX25hbWUrKzsKKwkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiVExTOiBDZXJ0aWZpY2F0ZSBkTlNOYW1lIiwKKwkJCQkgIGdlbi0+ZC5kTlNOYW1lLT5kYXRhLAorCQkJCSAgZ2VuLT5kLmROU05hbWUtPmxlbmd0aCk7CisJCWlmIChkb21haW5fc3VmZml4X21hdGNoKGdlbi0+ZC5kTlNOYW1lLT5kYXRhLAorCQkJCQlnZW4tPmQuZE5TTmFtZS0+bGVuZ3RoLCBtYXRjaCkgPT0gMSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFM6IFN1ZmZpeCBtYXRjaCBpbiBkTlNOYW1lIGZvdW5kIik7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0KKworCWlmIChkbnNfbmFtZSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMUzogTm9uZSBvZiB0aGUgZE5TTmFtZShzKSBtYXRjaGVkIik7CisJCXJldHVybiAwOworCX0KKworCW5hbWUgPSBYNTA5X2dldF9zdWJqZWN0X25hbWUoY2VydCk7CisJaSA9IC0xOworCWZvciAoOzspIHsKKwkJWDUwOV9OQU1FX0VOVFJZICplOworCQlBU04xX1NUUklORyAqY247CisKKwkJaSA9IFg1MDlfTkFNRV9nZXRfaW5kZXhfYnlfTklEKG5hbWUsIE5JRF9jb21tb25OYW1lLCBpKTsKKwkJaWYgKGkgPT0gLTEpCisJCQlicmVhazsKKwkJZSA9IFg1MDlfTkFNRV9nZXRfZW50cnkobmFtZSwgaSk7CisJCWlmIChlID09IE5VTEwpCisJCQljb250aW51ZTsKKwkJY24gPSBYNTA5X05BTUVfRU5UUllfZ2V0X2RhdGEoZSk7CisJCWlmIChjbiA9PSBOVUxMKQorCQkJY29udGludWU7CisJCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIlRMUzogQ2VydGlmaWNhdGUgY29tbW9uTmFtZSIsCisJCQkJICBjbi0+ZGF0YSwgY24tPmxlbmd0aCk7CisJCWlmIChkb21haW5fc3VmZml4X21hdGNoKGNuLT5kYXRhLCBjbi0+bGVuZ3RoLCBtYXRjaCkgPT0gMSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFM6IFN1ZmZpeCBtYXRjaCBpbiBjb21tb25OYW1lIGZvdW5kIik7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTOiBObyBDb21tb25OYW1lIHN1ZmZpeCBtYXRjaCBmb3VuZCIpOworCXJldHVybiAwOworI2VuZGlmIC8qIENPTkZJR19OQVRJVkVfV0lORE9XUyAqLworfQorCisKIHN0YXRpYyBlbnVtIHRsc19mYWlsX3JlYXNvbiBvcGVuc3NsX3Rsc19mYWlsX3JlYXNvbihpbnQgZXJyKQogewogCXN3aXRjaCAoZXJyKSB7CkBAIC0xMjY3LDEwICsxMzg4LDEzIEBACiAJU1NMICpzc2w7CiAJc3RydWN0IHRsc19jb25uZWN0aW9uICpjb25uOwogCXN0cnVjdCB0bHNfY29udGV4dCAqY29udGV4dDsKLQljaGFyICptYXRjaCwgKmFsdG1hdGNoOworCWNoYXIgKm1hdGNoLCAqYWx0bWF0Y2gsICpzdWZmaXhfbWF0Y2g7CiAJY29uc3QgY2hhciAqZXJyX3N0cjsKIAogCWVycl9jZXJ0ID0gWDUwOV9TVE9SRV9DVFhfZ2V0X2N1cnJlbnRfY2VydCh4NTA5X2N0eCk7CisJaWYgKCFlcnJfY2VydCkKKwkJcmV0dXJuIDA7CisKIAllcnIgPSBYNTA5X1NUT1JFX0NUWF9nZXRfZXJyb3IoeDUwOV9jdHgpOwogCWRlcHRoID0gWDUwOV9TVE9SRV9DVFhfZ2V0X2Vycm9yX2RlcHRoKHg1MDlfY3R4KTsKIAlzc2wgPSBYNTA5X1NUT1JFX0NUWF9nZXRfZXhfZGF0YSh4NTA5X2N0eCwKQEAgLTEyODUsMTAgKzE0MDksMTMgQEAKIAkJY29ubi0+cGVlcl9jZXJ0ID0gZXJyX2NlcnQ7CiAJZWxzZSBpZiAoZGVwdGggPT0gMSkKIAkJY29ubi0+cGVlcl9pc3N1ZXIgPSBlcnJfY2VydDsKKwllbHNlIGlmIChkZXB0aCA9PSAyKQorCQljb25uLT5wZWVyX2lzc3Vlcl9pc3N1ZXIgPSBlcnJfY2VydDsKIAogCWNvbnRleHQgPSBjb25uLT5jb250ZXh0OwogCW1hdGNoID0gY29ubi0+c3ViamVjdF9tYXRjaDsKIAlhbHRtYXRjaCA9IGNvbm4tPmFsdHN1YmplY3RfbWF0Y2g7CisJc3VmZml4X21hdGNoID0gY29ubi0+c3VmZml4X21hdGNoOwogCiAJaWYgKCFwcmV2ZXJpZnlfb2sgJiYgIWNvbm4tPmNhX2NlcnRfdmVyaWZ5KQogCQlwcmV2ZXJpZnlfb2sgPSAxOwpAQCAtMTM1Nyw2ICsxNDg0LDE0IEBACiAJCW9wZW5zc2xfdGxzX2ZhaWxfZXZlbnQoY29ubiwgZXJyX2NlcnQsIGVyciwgZGVwdGgsIGJ1ZiwKIAkJCQkgICAgICAgIkFsdFN1YmplY3QgbWlzbWF0Y2giLAogCQkJCSAgICAgICBUTFNfRkFJTF9BTFRTVUJKRUNUX01JU01BVENIKTsKKwl9IGVsc2UgaWYgKGRlcHRoID09IDAgJiYgc3VmZml4X21hdGNoICYmCisJCSAgICF0bHNfbWF0Y2hfc3VmZml4KGVycl9jZXJ0LCBzdWZmaXhfbWF0Y2gpKSB7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJUTFM6IERvbWFpbiBzdWZmaXggbWF0Y2ggJyVzJyBub3QgZm91bmQiLAorCQkJICAgc3VmZml4X21hdGNoKTsKKwkJcHJldmVyaWZ5X29rID0gMDsKKwkJb3BlbnNzbF90bHNfZmFpbF9ldmVudChjb25uLCBlcnJfY2VydCwgZXJyLCBkZXB0aCwgYnVmLAorCQkJCSAgICAgICAiRG9tYWluIHN1ZmZpeCBtaXNtYXRjaCIsCisJCQkJICAgICAgIFRMU19GQUlMX0RPTUFJTl9TVUZGSVhfTUlTTUFUQ0gpOwogCX0gZWxzZQogCQlvcGVuc3NsX3Rsc19jZXJ0X2V2ZW50KGNvbm4sIGVycl9jZXJ0LCBkZXB0aCwgYnVmKTsKIApAQCAtMTYxOSw3ICsxNzU0LDggQEAKIAogc3RhdGljIGludCB0bHNfY29ubmVjdGlvbl9zZXRfc3ViamVjdF9tYXRjaChzdHJ1Y3QgdGxzX2Nvbm5lY3Rpb24gKmNvbm4sCiAJCQkJCSAgICBjb25zdCBjaGFyICpzdWJqZWN0X21hdGNoLAotCQkJCQkgICAgY29uc3QgY2hhciAqYWx0c3ViamVjdF9tYXRjaCkKKwkJCQkJICAgIGNvbnN0IGNoYXIgKmFsdHN1YmplY3RfbWF0Y2gsCisJCQkJCSAgICBjb25zdCBjaGFyICpzdWZmaXhfbWF0Y2gpCiB7CiAJb3NfZnJlZShjb25uLT5zdWJqZWN0X21hdGNoKTsKIAljb25uLT5zdWJqZWN0X21hdGNoID0gTlVMTDsKQEAgLTE2MzcsNiArMTc3MywxNCBAQAogCQkJcmV0dXJuIC0xOwogCX0KIAorCW9zX2ZyZWUoY29ubi0+c3VmZml4X21hdGNoKTsKKwljb25uLT5zdWZmaXhfbWF0Y2ggPSBOVUxMOworCWlmIChzdWZmaXhfbWF0Y2gpIHsKKwkJY29ubi0+c3VmZml4X21hdGNoID0gb3Nfc3RyZHVwKHN1ZmZpeF9tYXRjaCk7CisJCWlmIChjb25uLT5zdWZmaXhfbWF0Y2ggPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwl9CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMjUyMSwxMCArMjY2NSwyNSBAQAogCW91dF9kYXRhID0gb3BlbnNzbF9oYW5kc2hha2UoY29ubiwgaW5fZGF0YSwgc2VydmVyKTsKIAlpZiAob3V0X2RhdGEgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CisJaWYgKGNvbm4tPmludmFsaWRfaGJfdXNlZCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVExTOiBIZWFydGJlYXQgYXR0YWNrIGRldGVjdGVkIC0gZG8gbm90IHNlbmQgcmVzcG9uc2UiKTsKKwkJd3BhYnVmX2ZyZWUob3V0X2RhdGEpOworCQlyZXR1cm4gTlVMTDsKKwl9CiAKIAlpZiAoU1NMX2lzX2luaXRfZmluaXNoZWQoY29ubi0+c3NsKSAmJiBhcHBsX2RhdGEgJiYgaW5fZGF0YSkKIAkJKmFwcGxfZGF0YSA9IG9wZW5zc2xfZ2V0X2FwcGxfZGF0YShjb25uLCB3cGFidWZfbGVuKGluX2RhdGEpKTsKIAorCWlmIChjb25uLT5pbnZhbGlkX2hiX3VzZWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRMUzogSGVhcnRiZWF0IGF0dGFjayBkZXRlY3RlZCAtIGRvIG5vdCBzZW5kIHJlc3BvbnNlIik7CisJCWlmIChhcHBsX2RhdGEpIHsKKwkJCXdwYWJ1Zl9mcmVlKCphcHBsX2RhdGEpOworCQkJKmFwcGxfZGF0YSA9IE5VTEw7CisJCX0KKwkJd3BhYnVmX2ZyZWUob3V0X2RhdGEpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKIAlyZXR1cm4gb3V0X2RhdGE7CiB9CiAKQEAgLTI2MjYsNiArMjc4NSwxMiBAQAogCX0KIAl3cGFidWZfcHV0KGJ1ZiwgcmVzKTsKIAorCWlmIChjb25uLT5pbnZhbGlkX2hiX3VzZWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRMUzogSGVhcnRiZWF0IGF0dGFjayBkZXRlY3RlZCAtIGRvIG5vdCBzZW5kIHJlc3BvbnNlIik7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CisJCXJldHVybiBOVUxMOworCX0KKwogCXJldHVybiBidWY7CiB9CiAKQEAgLTI3NzIsNyArMjkzNyw2IEBACiBzdGF0aWMgdm9pZCBvY3NwX2RlYnVnX3ByaW50X3Jlc3AoT0NTUF9SRVNQT05TRSAqcnNwKQogewogI2lmbmRlZiBDT05GSUdfTk9fU1RET1VUX0RFQlVHCi0JZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7CiAJQklPICpvdXQ7CiAJc2l6ZV90IHJsZW47CiAJY2hhciAqdHh0OwpAQCAtMjgwNCw2ICsyOTY4LDQxIEBACiB9CiAKIAorc3RhdGljIHZvaWQgZGVidWdfcHJpbnRfY2VydChYNTA5ICpjZXJ0LCBjb25zdCBjaGFyICp0aXRsZSkKK3sKKyNpZm5kZWYgQ09ORklHX05PX1NURE9VVF9ERUJVRworCUJJTyAqb3V0OworCXNpemVfdCBybGVuOworCWNoYXIgKnR4dDsKKwlpbnQgcmVzOworCisJaWYgKHdwYV9kZWJ1Z19sZXZlbCA+IE1TR19ERUJVRykKKwkJcmV0dXJuOworCisJb3V0ID0gQklPX25ldyhCSU9fc19tZW0oKSk7CisJaWYgKCFvdXQpCisJCXJldHVybjsKKworCVg1MDlfcHJpbnQob3V0LCBjZXJ0KTsKKwlybGVuID0gQklPX2N0cmxfcGVuZGluZyhvdXQpOworCXR4dCA9IG9zX21hbGxvYyhybGVuICsgMSk7CisJaWYgKCF0eHQpIHsKKwkJQklPX2ZyZWUob3V0KTsKKwkJcmV0dXJuOworCX0KKworCXJlcyA9IEJJT19yZWFkKG91dCwgdHh0LCBybGVuKTsKKwlpZiAocmVzID4gMCkgeworCQl0eHRbcmVzXSA9ICdcMCc7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT3BlblNTTDogJXNcbiVzIiwgdGl0bGUsIHR4dCk7CisJfQorCW9zX2ZyZWUodHh0KTsKKworCUJJT19mcmVlKG91dCk7CisjZW5kaWYgLyogQ09ORklHX05PX1NURE9VVF9ERUJVRyAqLworfQorCisKIHN0YXRpYyBpbnQgb2NzcF9yZXNwX2NiKFNTTCAqcywgdm9pZCAqYXJnKQogewogCXN0cnVjdCB0bHNfY29ubmVjdGlvbiAqY29ubiA9IGFyZzsKQEAgLTI4MTMsNiArMzAxMiw4IEBACiAJT0NTUF9CQVNJQ1JFU1AgKmJhc2ljOwogCU9DU1BfQ0VSVElEICppZDsKIAlBU04xX0dFTkVSQUxJWkVEVElNRSAqcHJvZHVjZWRfYXQsICp0aGlzX3VwZGF0ZSwgKm5leHRfdXBkYXRlOworCVg1MDlfU1RPUkUgKnN0b3JlOworCVNUQUNLX09GKFg1MDkpICpjZXJ0cyA9IE5VTEw7CiAKIAlsZW4gPSBTU0xfZ2V0X3Rsc2V4dF9zdGF0dXNfb2NzcF9yZXNwKHMsICZwKTsKIAlpZiAoIXApIHsKQEAgLTI4NDMsOCArMzA0NCw0MCBAQAogCQlyZXR1cm4gMDsKIAl9CiAKLQlzdGF0dXMgPSBPQ1NQX2Jhc2ljX3ZlcmlmeShiYXNpYywgTlVMTCwgU1NMX0NUWF9nZXRfY2VydF9zdG9yZShzLT5jdHgpLAotCQkJCSAgIDApOworCXN0b3JlID0gU1NMX0NUWF9nZXRfY2VydF9zdG9yZShzLT5jdHgpOworCWlmIChjb25uLT5wZWVyX2lzc3VlcikgeworCQlkZWJ1Z19wcmludF9jZXJ0KGNvbm4tPnBlZXJfaXNzdWVyLCAiQWRkIE9DU1AgaXNzdWVyIik7CisKKwkJaWYgKFg1MDlfU1RPUkVfYWRkX2NlcnQoc3RvcmUsIGNvbm4tPnBlZXJfaXNzdWVyKSAhPSAxKSB7CisJCQl0bHNfc2hvd19lcnJvcnMoTVNHX0lORk8sIF9fZnVuY19fLAorCQkJCQkiT3BlblNTTDogQ291bGQgbm90IGFkZCBpc3N1ZXIgdG8gY2VydGlmaWNhdGUgc3RvcmVcbiIpOworCQl9CisJCWNlcnRzID0gc2tfWDUwOV9uZXdfbnVsbCgpOworCQlpZiAoY2VydHMpIHsKKwkJCVg1MDkgKmNlcnQ7CisJCQljZXJ0ID0gWDUwOV9kdXAoY29ubi0+cGVlcl9pc3N1ZXIpOworCQkJaWYgKGNlcnQgJiYgIXNrX1g1MDlfcHVzaChjZXJ0cywgY2VydCkpIHsKKwkJCQl0bHNfc2hvd19lcnJvcnMoCisJCQkJCU1TR19JTkZPLCBfX2Z1bmNfXywKKwkJCQkJIk9wZW5TU0w6IENvdWxkIG5vdCBhZGQgaXNzdWVyIHRvIE9DU1AgcmVzcG9uZGVyIHRydXN0IHN0b3JlXG4iKTsKKwkJCQlYNTA5X2ZyZWUoY2VydCk7CisJCQkJc2tfWDUwOV9mcmVlKGNlcnRzKTsKKwkJCQljZXJ0cyA9IE5VTEw7CisJCQl9CisJCQlpZiAoY29ubi0+cGVlcl9pc3N1ZXJfaXNzdWVyKSB7CisJCQkJY2VydCA9IFg1MDlfZHVwKGNvbm4tPnBlZXJfaXNzdWVyX2lzc3Vlcik7CisJCQkJaWYgKGNlcnQgJiYgIXNrX1g1MDlfcHVzaChjZXJ0cywgY2VydCkpIHsKKwkJCQkJdGxzX3Nob3dfZXJyb3JzKAorCQkJCQkJTVNHX0lORk8sIF9fZnVuY19fLAorCQkJCQkJIk9wZW5TU0w6IENvdWxkIG5vdCBhZGQgaXNzdWVyIHRvIE9DU1AgcmVzcG9uZGVyIHRydXN0IHN0b3JlXG4iKTsKKwkJCQkJWDUwOV9mcmVlKGNlcnQpOworCQkJCX0KKwkJCX0KKwkJfQorCX0KKworCXN0YXR1cyA9IE9DU1BfYmFzaWNfdmVyaWZ5KGJhc2ljLCBjZXJ0cywgc3RvcmUsIE9DU1BfVFJVU1RPVEhFUik7CisJc2tfWDUwOV9wb3BfZnJlZShjZXJ0cywgWDUwOV9mcmVlKTsKIAlpZiAoc3RhdHVzIDw9IDApIHsKIAkJdGxzX3Nob3dfZXJyb3JzKE1TR19JTkZPLCBfX2Z1bmNfXywKIAkJCQkiT3BlblNTTDogT0NTUCByZXNwb25zZSBmYWlsZWQgdmVyaWZpY2F0aW9uIik7CkBAIC0yODU1LDggKzMwODgsMTUgQEAKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT3BlblNTTDogT0NTUCByZXNwb25zZSB2ZXJpZmljYXRpb24gc3VjY2VlZGVkIik7CiAKLQlpZiAoIWNvbm4tPnBlZXJfY2VydCB8fCAhY29ubi0+cGVlcl9pc3N1ZXIpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPcGVuU1NMOiBQZWVyIGNlcnRpZmljYXRlIG9yIGlzc3VlIGNlcnRpZmljYXRlIG5vdCBhdmFpbGFibGUgZm9yIE9DU1Agc3RhdHVzIGNoZWNrIik7CisJaWYgKCFjb25uLT5wZWVyX2NlcnQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPcGVuU1NMOiBQZWVyIGNlcnRpZmljYXRlIG5vdCBhdmFpbGFibGUgZm9yIE9DU1Agc3RhdHVzIGNoZWNrIik7CisJCU9DU1BfQkFTSUNSRVNQX2ZyZWUoYmFzaWMpOworCQlPQ1NQX1JFU1BPTlNFX2ZyZWUocnNwKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKCFjb25uLT5wZWVyX2lzc3VlcikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6IFBlZXIgaXNzdWVyIGNlcnRpZmljYXRlIG5vdCBhdmFpbGFibGUgZm9yIE9DU1Agc3RhdHVzIGNoZWNrIik7CiAJCU9DU1BfQkFTSUNSRVNQX2ZyZWUoYmFzaWMpOwogCQlPQ1NQX1JFU1BPTlNFX2ZyZWUocnNwKTsKIAkJcmV0dXJuIDA7CkBAIC0yOTAyLDcgKzMxNDIsNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6IE9DU1Agc3RhdHVzIHVua25vd24sIGJ1dCBPQ1NQIHJlcXVpcmVkIik7CiAJCXJldHVybiAwOwogCX0KLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPcGVuU1NMOiBPQ1NQIHN0YXR1cyB1bmtub3duLCBidXQgT0NTUCB3YXMgbm90IHJlcXVpcmVkLCBzbyBhbGxvdyBjb25uZWN0aW9uIHRvIGNvbnRpbnVlIik7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPcGVuU1NMOiBPQ1NQIHN0YXR1cyB1bmtub3duLCBidXQgT0NTUCB3YXMgbm90IHJlcXVpcmVkLCBzbyBhbGxvdyBjb25uZWN0aW9uIHRvIGNvbnRpbnVlIik7CiAJcmV0dXJuIDE7CiB9CiAKQEAgLTI5NDcsNyArMzE4Nyw2IEBACiB7CiAJaW50IHJldDsKIAl1bnNpZ25lZCBsb25nIGVycjsKLQlTU0xfQ1RYICpzc2xfY3R4ID0gdGxzX2N0eDsKIAogCWlmIChjb25uID09IE5VTEwpCiAJCXJldHVybiAtMTsKQEAgLTI5NjcsNyArMzIwNiw4IEBACiAJfQogCWlmICh0bHNfY29ubmVjdGlvbl9zZXRfc3ViamVjdF9tYXRjaChjb25uLAogCQkJCQkgICAgIHBhcmFtcy0+c3ViamVjdF9tYXRjaCwKLQkJCQkJICAgICBwYXJhbXMtPmFsdHN1YmplY3RfbWF0Y2gpKQorCQkJCQkgICAgIHBhcmFtcy0+YWx0c3ViamVjdF9tYXRjaCwKKwkJCQkJICAgICBwYXJhbXMtPnN1ZmZpeF9tYXRjaCkpCiAJCXJldHVybiAtMTsKIAogCWlmIChwYXJhbXMtPmVuZ2luZSAmJiBwYXJhbXMtPmNhX2NlcnRfaWQpIHsKQEAgLTMwMTcsOCArMzI1NywyMiBAQAogI2VuZGlmIC8qIFNTTF9jbGVhcl9vcHRpb25zICovCiAjZW5kaWYgLyogIFNTTF9PUF9OT19USUNLRVQgKi8KIAorI2lmZGVmIFNTTF9PUF9OT19UTFN2MV8xCisJaWYgKHBhcmFtcy0+ZmxhZ3MgJiBUTFNfQ09OTl9ESVNBQkxFX1RMU3YxXzEpCisJCVNTTF9zZXRfb3B0aW9ucyhjb25uLT5zc2wsIFNTTF9PUF9OT19UTFN2MV8xKTsKKwllbHNlCisJCVNTTF9jbGVhcl9vcHRpb25zKGNvbm4tPnNzbCwgU1NMX09QX05PX1RMU3YxXzEpOworI2VuZGlmIC8qIFNTTF9PUF9OT19UTFN2MV8xICovCisjaWZkZWYgU1NMX09QX05PX1RMU3YxXzIKKwlpZiAocGFyYW1zLT5mbGFncyAmIFRMU19DT05OX0RJU0FCTEVfVExTdjFfMikKKwkJU1NMX3NldF9vcHRpb25zKGNvbm4tPnNzbCwgU1NMX09QX05PX1RMU3YxXzIpOworCWVsc2UKKwkJU1NMX2NsZWFyX29wdGlvbnMoY29ubi0+c3NsLCBTU0xfT1BfTk9fVExTdjFfMik7CisjZW5kaWYgLyogU1NMX09QX05PX1RMU3YxXzIgKi8KKwogI2lmZGVmIEhBVkVfT0NTUAogCWlmIChwYXJhbXMtPmZsYWdzICYgVExTX0NPTk5fUkVRVUVTVF9PQ1NQKSB7CisJCVNTTF9DVFggKnNzbF9jdHggPSB0bHNfY3R4OwogCQlTU0xfc2V0X3Rsc2V4dF9zdGF0dXNfdHlwZShjb25uLT5zc2wsIFRMU0VYVF9TVEFUVVNUWVBFX29jc3ApOwogCQlTU0xfQ1RYX3NldF90bHNleHRfc3RhdHVzX2NiKHNzbF9jdHgsIG9jc3BfcmVzcF9jYik7CiAJCVNTTF9DVFhfc2V0X3Rsc2V4dF9zdGF0dXNfYXJnKHNzbF9jdHgsIGNvbm4pOwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvTWFrZWZpbGUgYi9zcmMvZHJpdmVycy9NYWtlZmlsZQppbmRleCAwNzYwMGU1Li41NzIxMTU0IDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9NYWtlZmlsZQorKysgYi9zcmMvZHJpdmVycy9NYWtlZmlsZQpAQCAtMiw3ICsyLDcgQEAKIAlAZWNobyBOb3RoaW5nIHRvIGJlIG1hZGUuCiAKIGNsZWFuOgotCXJtIC1mICp+ICoubyAqLmQKKwlybSAtZiAqfiAqLm8gKi5kICouZ2NubyAqLmdjZGEgKi5nY292CiAJcm0gLWYgYnVpbGQud3BhX3N1cHBsaWNhbnQgYnVpbGQuaG9zdGFwZAogCiBpbnN0YWxsOgpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvYW5kcm9pZF9kcnYuaCBiL3NyYy9kcml2ZXJzL2FuZHJvaWRfZHJ2LmgKaW5kZXggNTkwNjUyNy4uMzFkOTQ0MCAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvYW5kcm9pZF9kcnYuaAorKysgYi9zcmMvZHJpdmVycy9hbmRyb2lkX2Rydi5oCkBAIC0xLDEyICsxLDggQEAKIC8qCiAgKiBBbmRyb2lkIGRyaXZlciBpbnRlcmZhY2UKICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpZm5kZWYgQU5EUk9JRF9EUlZfSApkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyLmggYi9zcmMvZHJpdmVycy9kcml2ZXIuaAppbmRleCBiOGM5ODI5Li4zNTJjMTYzIDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9kcml2ZXIuaAorKysgYi9zcmMvZHJpdmVycy9kcml2ZXIuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBEcml2ZXIgaW50ZXJmYWNlIGRlZmluaXRpb24KLSAqIENvcHlyaWdodCAoYykgMjAwMy0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTM3LDYgKzM3LDI3IEBACiAjZGVmaW5lIEhPU1RBUERfQ0hBTl9ERlNfQVZBSUxBQkxFIDB4MDAwMDAzMDAKICNkZWZpbmUgSE9TVEFQRF9DSEFOX0RGU19NQVNLIDB4MDAwMDAzMDAKIAorI2RlZmluZSBIT1NUQVBEX0NIQU5fVkhUXzEwXzcwIDB4MDAwMDA4MDAKKyNkZWZpbmUgSE9TVEFQRF9DSEFOX1ZIVF8zMF81MCAweDAwMDAxMDAwCisjZGVmaW5lIEhPU1RBUERfQ0hBTl9WSFRfNTBfMzAgMHgwMDAwMjAwMAorI2RlZmluZSBIT1NUQVBEX0NIQU5fVkhUXzcwXzEwIDB4MDAwMDQwMDAKKworZW51bSByZWdfY2hhbmdlX2luaXRpYXRvciB7CisJUkVHRE9NX1NFVF9CWV9DT1JFLAorCVJFR0RPTV9TRVRfQllfVVNFUiwKKwlSRUdET01fU0VUX0JZX0RSSVZFUiwKKwlSRUdET01fU0VUX0JZX0NPVU5UUllfSUUsCisJUkVHRE9NX0JFQUNPTl9ISU5ULAorfTsKKworZW51bSByZWdfdHlwZSB7CisJUkVHRE9NX1RZUEVfVU5LTk9XTiwKKwlSRUdET01fVFlQRV9DT1VOVFJZLAorCVJFR0RPTV9UWVBFX1dPUkxELAorCVJFR0RPTV9UWVBFX0NVU1RPTV9XT1JMRCwKKwlSRUdET01fVFlQRV9JTlRFUlNFQ1RJT04sCit9OworCiAvKioKICAqIHN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAtIENoYW5uZWwgaW5mb3JtYXRpb24KICAqLwpAQCAtNTcsNyArNzgsNyBAQAogCWludCBmbGFnOwogCiAJLyoqCi0JICogbWF4X3R4X3Bvd2VyIC0gTWF4aW11bSB0cmFuc21pdCBwb3dlciBpbiBkQm0KKwkgKiBtYXhfdHhfcG93ZXIgLSBSZWd1bGF0b3J5IHRyYW5zbWl0IHBvd2VyIGxpbWl0IGluIGRCbQogCSAqLwogCXU4IG1heF90eF9wb3dlcjsKIApAQCAtODAsNiArMTAxLDkgQEAKIAkgKi8KIAlsb25nIGRvdWJsZSBpbnRlcmZlcmVuY2VfZmFjdG9yOwogI2VuZGlmIC8qIENPTkZJR19BQ1MgKi8KKworCS8qIERGUyBDQUMgdGltZSBpbiBtaWxsaXNlY29uZHMgKi8KKwl1bnNpZ25lZCBpbnQgZGZzX2NhY19tczsKIH07CiAKICNkZWZpbmUgSE9TVEFQRF9NT0RFX0ZMQUdfSFRfSU5GT19LTk9XTiBCSVQoMCkKQEAgLTIyMSw3ICsyNDUsNyBAQAogc3RydWN0IHdwYV9zY2FuX3Jlc3VsdHMgewogCXN0cnVjdCB3cGFfc2Nhbl9yZXMgKipyZXM7CiAJc2l6ZV90IG51bTsKLQlzdHJ1Y3Qgb3NfdGltZSBmZXRjaF90aW1lOworCXN0cnVjdCBvc19yZWx0aW1lIGZldGNoX3RpbWU7CiB9OwogCiAvKioKQEAgLTMyNyw3ICszNTEsMzAgQEAKIAkgKiBNYnBzIGZyb20gdGhlIHN1cHBvcnQgcmF0ZXMgZWxlbWVudChzKSBpbiB0aGUgUHJvYmUgUmVxdWVzdCBmcmFtZXMKIAkgKiBhbmQgbm90IHRvIHRyYW5zbWl0IHRoZSBmcmFtZXMgYXQgYW55IG9mIHRob3NlIHJhdGVzLgogCSAqLwotCXU4IHAycF9wcm9iZTsKKwl1bnNpZ25lZCBpbnQgcDJwX3Byb2JlOjE7CisKKwkvKioKKwkgKiBvbmx5X25ld19yZXN1bHRzIC0gUmVxdWVzdCBkcml2ZXIgdG8gcmVwb3J0IG9ubHkgbmV3IHJlc3VsdHMKKwkgKgorCSAqIFRoaXMgaXMgdXNlZCB0byByZXF1ZXN0IHRoZSBkcml2ZXIgdG8gcmVwb3J0IG9ubHkgQlNTZXMgdGhhdCBoYXZlCisJICogYmVlbiBkZXRlY3RlZCBhZnRlciB0aGlzIHNjYW4gcmVxdWVzdCBoYXMgYmVlbiBzdGFydGVkLCBpLmUuLCB0bworCSAqIGZsdXNoIG9sZCBjYWNoZWQgQlNTIGVudHJpZXMuCisJICovCisJdW5zaWduZWQgaW50IG9ubHlfbmV3X3Jlc3VsdHM6MTsKKworCS8qKgorCSAqIGxvd19wcmlvcml0eSAtIFJlcXVlc3RzIGRyaXZlciB0byB1c2UgYSBsb3dlciBzY2FuIHByaW9yaXR5CisJICoKKwkgKiBUaGlzIGlzIHVzZWQgdG8gcmVxdWVzdCB0aGUgZHJpdmVyIHRvIHVzZSBhIGxvd2VyIHNjYW4gcHJpb3JpdHkKKwkgKiBpZiBpdCBzdXBwb3J0cyBzdWNoIGEgdGhpbmcuCisJICovCisJdW5zaWduZWQgaW50IGxvd19wcmlvcml0eToxOworCisJLyoKKwkgKiBOT1RFOiBXaGVuZXZlciBhZGRpbmcgbmV3IHBhcmFtZXRlcnMgaGVyZSwgcGxlYXNlIG1ha2Ugc3VyZQorCSAqIHdwYV9zY2FuX2Nsb25lX3BhcmFtcygpIGFuZCB3cGFfc2Nhbl9mcmVlX3BhcmFtcygpIGdldCB1cGRhdGVkIHdpdGgKKwkgKiBtYXRjaGluZyBjaGFuZ2VzLgorCSAqLwogfTsKIAogLyoqCkBAIC0zNzYsNiArNDIzLDE2IEBACiAJY29uc3QgdTggKmJzc2lkOwogCiAJLyoqCisJICogYnNzaWRfaGludCAtIEJTU0lEIG9mIGEgcHJvcG9zZWQgQVAKKwkgKgorCSAqIFRoaXMgaW5kaWNhdGVzIHdoaWNoIEJTUyBoYXMgYmVlbiBmb3VuZCBhIHN1aXRhYmxlIGNhbmRpZGF0ZSBmb3IKKwkgKiBpbml0aWFsIGFzc29jaWF0aW9uIGZvciBkcml2ZXJzIHRoYXQgdXNlIGRyaXZlci9maXJtd2F0ZS1iYXNlZCBCU1MKKwkgKiBzZWxlY3Rpb24uIFVubGlrZSB0aGUgQGJzc2lkIHBhcmFtZXRlciwgQGJzc2lkX2hpbnQgZG9lcyBub3QgbGltaXQKKwkgKiB0aGUgZHJpdmVyIGZyb20gc2VsZWN0aW5nIG90aGVyIEJTU2VzIGluIHRoZSBFU1MuCisJICovCisJY29uc3QgdTggKmJzc2lkX2hpbnQ7CisKKwkvKioKIAkgKiBzc2lkIC0gVGhlIHNlbGVjdGVkIFNTSUQKIAkgKi8KIAljb25zdCB1OCAqc3NpZDsKQEAgLTM5Myw2ICs0NTAsMTYgQEAKIAlpbnQgZnJlcTsKIAogCS8qKgorCSAqIGZyZXFfaGludCAtIEZyZXF1ZW5jeSBvZiB0aGUgY2hhbm5lbCB0aGUgcHJvcG9zZWQgQVAgaXMgdXNpbmcKKwkgKgorCSAqIFRoaXMgcHJvdmlkZXMgYSBjaGFubmVsIG9uIHdoaWNoIGEgc3VpdGFibGUgQlNTIGhhcyBiZWVuIGZvdW5kIGFzIGEKKwkgKiBoaW50IGZvciB0aGUgZHJpdmVyLiBVbmxpa2UgdGhlIEBmcmVxIHBhcmFtZXRlciwgQGZyZXFfaGludCBkb2VzIG5vdAorCSAqIGxpbWl0IHRoZSBkcml2ZXIgZnJvbSBzZWxlY3Rpbmcgb3RoZXIgY2hhbm5lbHMgZm9yCisJICogZHJpdmVyL2Zpcm13YXJlLWJhc2VkIEJTUyBzZWxlY3Rpb24uCisJICovCisJaW50IGZyZXFfaGludDsKKworCS8qKgogCSAqIGJnX3NjYW5fcGVyaW9kIC0gQmFja2dyb3VuZCBzY2FuIHBlcmlvZCBpbiBzZWNvbmRzLCAwIHRvIGRpc2FibGUKIAkgKiBiYWNrZ3JvdW5kIHNjYW4sIG9yIC0xIHRvIGluZGljYXRlIG5vIGNoYW5nZSB0byBkZWZhdWx0IGRyaXZlcgogCSAqIGNvbmZpZ3VyYXRpb24KQEAgLTQwMCw2ICs0NjcsMTEgQEAKIAlpbnQgYmdfc2Nhbl9wZXJpb2Q7CiAKIAkvKioKKwkgKiBiZWFjb25faW50IC0gQmVhY29uIGludGVydmFsIGZvciBJQlNTIG9yIDAgdG8gdXNlIGRyaXZlciBkZWZhdWx0CisJICovCisJaW50IGJlYWNvbl9pbnQ7CisKKwkvKioKIAkgKiB3cGFfaWUgLSBXUEEgaW5mb3JtYXRpb24gZWxlbWVudCBmb3IgKFJlKUFzc29jaWF0aW9uIFJlcXVlc3QKIAkgKiBXUEEgaW5mb3JtYXRpb24gZWxlbWVudCB0byBiZSBpbmNsdWRlZCBpbiAoUmUpQXNzb2NpYXRpb24KIAkgKiBSZXF1ZXN0IChpbmNsdWRpbmcgaW5mb3JtYXRpb24gZWxlbWVudCBpZCBhbmQgbGVuZ3RoKS4gVXNlCkBAIC00MzAsMjUgKzUwMiwyNSBAQAogCXVuc2lnbmVkIGludCB3cGFfcHJvdG87CiAKIAkvKioKLQkgKiBwYWlyd2lzZV9zdWl0ZSAtIFNlbGVjdGVkIHBhaXJ3aXNlIGNpcGhlciBzdWl0ZQorCSAqIHBhaXJ3aXNlX3N1aXRlIC0gU2VsZWN0ZWQgcGFpcndpc2UgY2lwaGVyIHN1aXRlIChXUEFfQ0lQSEVSXyopCiAJICoKIAkgKiBUaGlzIGlzIHVzdWFsbHkgaWdub3JlZCBpZiBAd3BhX2llIGlzIHVzZWQuCiAJICovCi0JZW51bSB3cGFfY2lwaGVyIHBhaXJ3aXNlX3N1aXRlOworCXVuc2lnbmVkIGludCBwYWlyd2lzZV9zdWl0ZTsKIAogCS8qKgotCSAqIGdyb3VwX3N1aXRlIC0gU2VsZWN0ZWQgZ3JvdXAgY2lwaGVyIHN1aXRlCisJICogZ3JvdXBfc3VpdGUgLSBTZWxlY3RlZCBncm91cCBjaXBoZXIgc3VpdGUgKFdQQV9DSVBIRVJfKikKIAkgKgogCSAqIFRoaXMgaXMgdXN1YWxseSBpZ25vcmVkIGlmIEB3cGFfaWUgaXMgdXNlZC4KIAkgKi8KLQllbnVtIHdwYV9jaXBoZXIgZ3JvdXBfc3VpdGU7CisJdW5zaWduZWQgaW50IGdyb3VwX3N1aXRlOwogCiAJLyoqCi0JICoga2V5X21nbXRfc3VpdGUgLSBTZWxlY3RlZCBrZXkgbWFuYWdlbWVudCBzdWl0ZQorCSAqIGtleV9tZ210X3N1aXRlIC0gU2VsZWN0ZWQga2V5IG1hbmFnZW1lbnQgc3VpdGUgKFdQQV9LRVlfTUdNVF8qKQogCSAqCiAJICogVGhpcyBpcyB1c3VhbGx5IGlnbm9yZWQgaWYgQHdwYV9pZSBpcyB1c2VkLgogCSAqLwotCWVudW0gd3BhX2tleV9tZ210IGtleV9tZ210X3N1aXRlOworCXVuc2lnbmVkIGludCBrZXlfbWdtdF9zdWl0ZTsKIAogCS8qKgogCSAqIGF1dGhfYWxnIC0gQWxsb3dlZCBhdXRoZW50aWNhdGlvbiBhbGdvcml0aG1zCkBAIC02MTgsMTEgKzY5MCwyMSBAQAogCUhJRERFTl9TU0lEX1pFUk9fQ09OVEVOVFMKIH07CiAKK3N0cnVjdCB3b3dsYW5fdHJpZ2dlcnMgeworCXU4IGFueTsKKwl1OCBkaXNjb25uZWN0OworCXU4IG1hZ2ljX3BrdDsKKwl1OCBndGtfcmVrZXlfZmFpbHVyZTsKKwl1OCBlYXBfaWRlbnRpdHlfcmVxOworCXU4IGZvdXJfd2F5X2hhbmRzaGFrZTsKKwl1OCByZmtpbGxfcmVsZWFzZTsKK307CisKIHN0cnVjdCB3cGFfZHJpdmVyX2FwX3BhcmFtcyB7CiAJLyoqCiAJICogaGVhZCAtIEJlYWNvbiBoZWFkIGZyb20gSUVFRSA4MDIuMTEgaGVhZGVyIHRvIElFcyBiZWZvcmUgVElNIElFCiAJICovCi0JY29uc3QgdTggKmhlYWQ7CisJdTggKmhlYWQ7CiAKIAkvKioKIAkgKiBoZWFkX2xlbiAtIExlbmd0aCBvZiB0aGUgaGVhZCBidWZmZXIgaW4gb2N0ZXRzCkBAIC02MzIsNyArNzE0LDcgQEAKIAkvKioKIAkgKiB0YWlsIC0gQmVhY29uIHRhaWwgZm9sbG93aW5nIFRJTSBJRQogCSAqLwotCWNvbnN0IHU4ICp0YWlsOworCXU4ICp0YWlsOwogCiAJLyoqCiAJICogdGFpbF9sZW4gLSBMZW5ndGggb2YgdGhlIHRhaWwgYnVmZmVyIGluIG9jdGV0cwpAQCAtNjYzLDcgKzc0NSw3IEBACiAJICogVGhpcyBpcyB1c2VkIGJ5IGRyaXZlcnMgdGhhdCByZXBseSB0byBQcm9iZSBSZXF1ZXN0cyBpbnRlcm5hbGx5IGluCiAJICogQVAgbW9kZSBhbmQgcmVxdWlyZSB0aGUgZnVsbCBQcm9iZSBSZXNwb25zZSB0ZW1wbGF0ZS4KIAkgKi8KLQljb25zdCB1OCAqcHJvYmVyZXNwOworCXU4ICpwcm9iZXJlc3A7CiAKIAkvKioKIAkgKiBwcm9iZXJlc3BfbGVuIC0gTGVuZ3RoIG9mIHRoZSBwcm9iZXJlc3AgYnVmZmVyIGluIG9jdGV0cwpAQCAtNzk5LDYgKzg4MSwxNiBAQAogCSAqIGRpc2FibGVfZGdhZiAtIFdoZXRoZXIgZ3JvdXAtYWRkcmVzc2VkIGZyYW1lcyBhcmUgZGlzYWJsZWQKIAkgKi8KIAlpbnQgZGlzYWJsZV9kZ2FmOworCisJLyoqCisJICogb3NlbiAtIFdoZXRoZXIgT1NFTiBzZWN1cml0eSBpcyBlbmFibGVkCisJICovCisJaW50IG9zZW47CisKKwkvKioKKwkgKiBmcmVxIC0gQ2hhbm5lbCBwYXJhbWV0ZXJzIGZvciBkeW5hbWljIGJhbmR3aWR0aCBjaGFuZ2VzCisJICovCisJc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgKmZyZXE7CiB9OwogCiAvKioKQEAgLTgyMSw2ICs5MTMsMTMgQEAKICNkZWZpbmUgV1BBX0RSSVZFUl9DQVBBX0VOQ19DQ01QCTB4MDAwMDAwMDgKICNkZWZpbmUgV1BBX0RSSVZFUl9DQVBBX0VOQ19XRVAxMjgJMHgwMDAwMDAxMAogI2RlZmluZSBXUEFfRFJJVkVSX0NBUEFfRU5DX0dDTVAJMHgwMDAwMDAyMAorI2RlZmluZSBXUEFfRFJJVkVSX0NBUEFfRU5DX0dDTVBfMjU2CTB4MDAwMDAwNDAKKyNkZWZpbmUgV1BBX0RSSVZFUl9DQVBBX0VOQ19DQ01QXzI1NgkweDAwMDAwMDgwCisjZGVmaW5lIFdQQV9EUklWRVJfQ0FQQV9FTkNfQklQCQkweDAwMDAwMTAwCisjZGVmaW5lIFdQQV9EUklWRVJfQ0FQQV9FTkNfQklQX0dNQUNfMTI4CTB4MDAwMDAyMDAKKyNkZWZpbmUgV1BBX0RSSVZFUl9DQVBBX0VOQ19CSVBfR01BQ18yNTYJMHgwMDAwMDQwMAorI2RlZmluZSBXUEFfRFJJVkVSX0NBUEFfRU5DX0JJUF9DTUFDXzI1NgkweDAwMDAwODAwCisjZGVmaW5lIFdQQV9EUklWRVJfQ0FQQV9FTkNfR1RLX05PVF9VU0VECTB4MDAwMDEwMDAKIAl1bnNpZ25lZCBpbnQgZW5jOwogCiAjZGVmaW5lIFdQQV9EUklWRVJfQVVUSF9PUEVOCQkweDAwMDAwMDAxCkBAIC04MzIsNyArOTMxLDggQEAKICNkZWZpbmUgV1BBX0RSSVZFUl9GTEFHU19EUklWRVJfSUUJMHgwMDAwMDAwMQogLyogRHJpdmVyIG5lZWRzIHN0YXRpYyBXRVAga2V5IHNldHVwIGFmdGVyIGFzc29jaWF0aW9uIGNvbW1hbmQgKi8KICNkZWZpbmUgV1BBX0RSSVZFUl9GTEFHU19TRVRfS0VZU19BRlRFUl9BU1NPQyAweDAwMDAwMDAyCi0vKiB1bnVzZWQ6IDB4MDAwMDAwMDQgKi8KKy8qIERyaXZlciB0YWtlcyBjYXJlIG9mIGFsbCBERlMgb3BlcmF0aW9ucyAqLworI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX0RGU19PRkZMT0FECQkJMHgwMDAwMDAwNAogLyogRHJpdmVyIHRha2VzIGNhcmUgb2YgUlNOIDQtd2F5IGhhbmRzaGFrZSBpbnRlcm5hbGx5OyBQTUsgaXMgY29uZmlndXJlZCB3aXRoCiAgKiBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHM6OnNldF9rZXkgdXNpbmcgYWxnID0gV1BBX0FMR19QTUsgKi8KICNkZWZpbmUgV1BBX0RSSVZFUl9GTEFHU180V0FZX0hBTkRTSEFLRSAweDAwMDAwMDA4CkBAIC04NDQsOCArOTQ0LDggQEAKICNkZWZpbmUgV1BBX0RSSVZFUl9GTEFHU19BUAkJMHgwMDAwMDA0MAogLyogRHJpdmVyIG5lZWRzIHN0YXRpYyBXRVAga2V5IHNldHVwIGFmdGVyIGFzc29jaWF0aW9uIGhhcyBiZWVuIGNvbXBsZXRlZCAqLwogI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX1NFVF9LRVlTX0FGVEVSX0FTU09DX0RPTkUJMHgwMDAwMDA4MAotLyogRHJpdmVyIHRha2VzIGNhcmUgb2YgUDJQIG1hbmFnZW1lbnQgb3BlcmF0aW9ucyAqLwotI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UCTB4MDAwMDAxMDAKKy8qIERyaXZlciBzdXBwb3J0cyBkeW5hbWljIEhUIDIwLzQwIE1IeiBjaGFubmVsIGNoYW5nZXMgZHVyaW5nIEJTUyBsaWZldGltZSAqLworI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX0hUXzIwNDBfQ09FWAkJCTB4MDAwMDAxMDAKIC8qIERyaXZlciBzdXBwb3J0cyBjb25jdXJyZW50IFAyUCBvcGVyYXRpb25zICovCiAjZGVmaW5lIFdQQV9EUklWRVJfRkxBR1NfUDJQX0NPTkNVUlJFTlQJMHgwMDAwMDIwMAogLyoKQEAgLTg1NSw3ICs5NTUsOCBAQAogI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9ERURJQ0FURURfSU5URVJGQUNFCTB4MDAwMDA0MDAKIC8qIFRoaXMgaW50ZXJmYWNlIGlzIFAyUCBjYXBhYmxlIChQMlAgR08gb3IgUDJQIENsaWVudCkgKi8KICNkZWZpbmUgV1BBX0RSSVZFUl9GTEFHU19QMlBfQ0FQQUJMRQkweDAwMDAwODAwCi0vKiB1bnVzZWQ6IDB4MDAwMDEwMDAgKi8KKy8qIERyaXZlciBzdXBwb3J0cyBzdGF0aW9uIGFuZCBrZXkgcmVtb3ZhbCB3aGVuIHN0b3BwaW5nIGFuIEFQICovCisjZGVmaW5lIFdQQV9EUklWRVJfRkxBR1NfQVBfVEVBUkRPV05fU1VQUE9SVAkJMHgwMDAwMTAwMAogLyoKICAqIERyaXZlciB1c2VzIHRoZSBpbml0aWFsIGludGVyZmFjZSBmb3IgUDJQIG1hbmFnZW1lbnQgaW50ZXJmYWNlIGFuZCBub24tUDJQCiAgKiBwdXJwb3NlcyAoZS5nLiwgY29ubmVjdCB0byBpbmZyYSBBUCksIGJ1dCB0aGlzIGludGVyZmFjZSBjYW5ub3QgYmUgdXNlZCBmb3IKQEAgLTg5OCw2ICs5OTksMTAgQEAKICNkZWZpbmUgV1BBX0RSSVZFUl9GTEFHU19SQURBUgkJCQkweDEwMDAwMDAwCiAvKiBEcml2ZXIgc3VwcG9ydHMgYSBkZWRpY2F0ZWQgaW50ZXJmYWNlIGZvciBQMlAgRGV2aWNlICovCiAjZGVmaW5lIFdQQV9EUklWRVJfRkxBR1NfREVESUNBVEVEX1AyUF9ERVZJQ0UJCTB4MjAwMDAwMDAKKy8qIERyaXZlciBzdXBwb3J0cyBRb1MgTWFwcGluZyAqLworI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX1FPU19NQVBQSU5HCQkJMHg0MDAwMDAwMAorLyogRHJpdmVyIHN1cHBvcnRzIENTQSBpbiBBUCBtb2RlICovCisjZGVmaW5lIFdQQV9EUklWRVJfRkxBR1NfQVBfQ1NBCQkJCTB4ODAwMDAwMDAKIAl1bnNpZ25lZCBpbnQgZmxhZ3M7CiAKIAlpbnQgbWF4X3NjYW5fc3NpZHM7CkBAIC05NDUsNiArMTA1MCw4IEBACiAJICovCiAJY29uc3QgdTggKmV4dGVuZGVkX2NhcGEsICpleHRlbmRlZF9jYXBhX21hc2s7CiAJdW5zaWduZWQgaW50IGV4dGVuZGVkX2NhcGFfbGVuOworCisJc3RydWN0IHdvd2xhbl90cmlnZ2VycyB3b3dsYW5fdHJpZ2dlcnM7CiB9OwogCiAKQEAgLTk3MSwxMSArMTA3OCwxNyBAQAogCXUxNiBsaXN0ZW5faW50ZXJ2YWw7CiAJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgKmh0X2NhcGFiaWxpdGllczsKIAljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX3ZodF9jYXBhYmlsaXRpZXMgKnZodF9jYXBhYmlsaXRpZXM7CisJaW50IHZodF9vcG1vZGVfZW5hYmxlZDsKKwl1OCB2aHRfb3Btb2RlOwogCXUzMiBmbGFnczsgLyogYml0bWFzayBvZiBXUEFfU1RBXyogZmxhZ3MgKi8KIAlpbnQgc2V0OyAvKiBTZXQgU1RBIHBhcmFtZXRlcnMgaW5zdGVhZCBvZiBhZGQgKi8KIAl1OCBxb3NpbmZvOwogCWNvbnN0IHU4ICpleHRfY2FwYWI7CiAJc2l6ZV90IGV4dF9jYXBhYl9sZW47CisJY29uc3QgdTggKnN1cHBfY2hhbm5lbHM7CisJc2l6ZV90IHN1cHBfY2hhbm5lbHNfbGVuOworCWNvbnN0IHU4ICpzdXBwX29wZXJfY2xhc3NlczsKKwlzaXplX3Qgc3VwcF9vcGVyX2NsYXNzZXNfbGVuOwogfTsKIAogc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgewpAQCAtMTA4NywxNyArMTIwMCw2IEBACiAjZGVmaW5lIFdQQV9TVEFfTUZQIEJJVCgzKQogI2RlZmluZSBXUEFfU1RBX1RETFNfUEVFUiBCSVQoNCkKIAotLyoqCi0gKiBzdHJ1Y3QgcDJwX3BhcmFtcyAtIFAyUCBwYXJhbWV0ZXJzIGZvciBkcml2ZXItYmFzZWQgUDJQIG1hbmFnZW1lbnQKLSAqLwotc3RydWN0IHAycF9wYXJhbXMgewotCWNvbnN0IGNoYXIgKmRldl9uYW1lOwotCXU4IHByaV9kZXZfdHlwZVs4XTsKLSNkZWZpbmUgRFJWX01BWF9TRUNfREVWX1RZUEVTIDUKLQl1OCBzZWNfZGV2X3R5cGVbRFJWX01BWF9TRUNfREVWX1RZUEVTXVs4XTsKLQlzaXplX3QgbnVtX3NlY19kZXZfdHlwZXM7Ci19OwotCiBlbnVtIHRkbHNfb3BlciB7CiAJVERMU19ESVNDT1ZFUllfUkVRLAogCVRETFNfU0VUVVAsCkBAIC0xMTUyLDYgKzEyNTQsNzUgQEAKIH07CiAKIC8qKgorICogc3RydWN0IGJlYWNvbl9kYXRhIC0gQmVhY29uIGRhdGEKKyAqIEBoZWFkOiBIZWFkIHBvcnRpb24gb2YgQmVhY29uIGZyYW1lIChiZWZvcmUgVElNIElFKQorICogQHRhaWw6IFRhaWwgcG9ydGlvbiBvZiBCZWFjb24gZnJhbWUgKGFmdGVyIFRJTSBJRSkKKyAqIEBiZWFjb25faWVzOiBFeHRyYSBpbmZvcm1hdGlvbiBlbGVtZW50KHMpIHRvIGFkZCBpbnRvIEJlYWNvbiBmcmFtZXMgb3IgJU5VTEwKKyAqIEBwcm9iZXJlc3BfaWVzOiBFeHRyYSBpbmZvcm1hdGlvbiBlbGVtZW50KHMpIHRvIGFkZCBpbnRvIFByb2JlIFJlc3BvbnNlCisgKglmcmFtZXMgb3IgJU5VTEwKKyAqIEBhc3NvY3Jlc3BfaWVzOiBFeHRyYSBpbmZvcm1hdGlvbiBlbGVtZW50KHMpIHRvIGFkZCBpbnRvIChSZSlBc3NvY2lhdGlvbgorICoJUmVzcG9uc2UgZnJhbWVzIG9yICVOVUxMCisgKiBAcHJvYmVfcmVzcDogUHJvYmUgUmVzcG9uc2UgZnJhbWUgdGVtcGxhdGUKKyAqIEBoZWFkX2xlbjogTGVuZ3RoIG9mIEBoZWFkCisgKiBAdGFpbF9sZW46IExlbmd0aCBvZiBAdGFpbAorICogQGJlYWNvbl9pZXNfbGVuOiBMZW5ndGggb2YgYmVhY29uX2llcyBpbiBvY3RldHMKKyAqIEBwcm9iZXJlc3BfaWVzX2xlbjogTGVuZ3RoIG9mIHByb2JlcmVzcF9pZXMgaW4gb2N0ZXRzCisgKiBAcHJvYmVyZXNwX2llc19sZW46IExlbmd0aCBvZiBwcm9iZXJlc3BfaWVzIGluIG9jdGV0cworICogQHByb2JlX3Jlc3BfbGVuOiBMZW5ndGggb2YgcHJvYmUgcmVzcG9uc2UgdGVtcGxhdGUgKEBwcm9iZV9yZXNwKQorICovCitzdHJ1Y3QgYmVhY29uX2RhdGEgeworCXU4ICpoZWFkLCAqdGFpbDsKKwl1OCAqYmVhY29uX2llczsKKwl1OCAqcHJvYmVyZXNwX2llczsKKwl1OCAqYXNzb2NyZXNwX2llczsKKwl1OCAqcHJvYmVfcmVzcDsKKworCXNpemVfdCBoZWFkX2xlbiwgdGFpbF9sZW47CisJc2l6ZV90IGJlYWNvbl9pZXNfbGVuOworCXNpemVfdCBwcm9iZXJlc3BfaWVzX2xlbjsKKwlzaXplX3QgYXNzb2NyZXNwX2llc19sZW47CisJc2l6ZV90IHByb2JlX3Jlc3BfbGVuOworfTsKKworLyoqCisgKiBzdHJ1Y3QgY3NhX3NldHRpbmdzIC0gU2V0dGluZ3MgZm9yIGNoYW5uZWwgc3dpdGNoIGNvbW1hbmQKKyAqIEBjc19jb3VudDogQ291bnQgaW4gQmVhY29uIGZyYW1lcyAoVEJUVCkgdG8gcGVyZm9ybSB0aGUgc3dpdGNoCisgKiBAYmxvY2tfdHg6IDEgLSBibG9jayB0cmFuc21pc3Npb24gZm9yIENTQSBwZXJpb2QKKyAqIEBmcmVxX3BhcmFtczogTmV4dCBjaGFubmVsIGZyZXF1ZW5jeSBwYXJhbWV0ZXIKKyAqIEBiZWFjb25fY3NhOiBCZWFjb24vcHJvYmUgcmVzcC9hc29vYyByZXNwIGluZm8gZm9yIENTQSBwZXJpb2QKKyAqIEBiZWFjb25fYWZ0ZXI6IE5leHQgYmVhY29uL3Byb2JlIHJlc3AvYXNvb2MgcmVzcCBpbmZvCisgKiBAY291bnRlcl9vZmZzZXRfYmVhY29uOiBPZmZzZXQgdG8gdGhlIGNvdW50IGZpZWxkIGluIGJlYWNvbidzIHRhaWwKKyAqIEBjb3VudGVyX29mZnNldF9wcmVzcDogT2Zmc2V0IHRvIHRoZSBjb3VudCBmaWVsZCBpbiBwcm9iZSByZXNwLgorICovCitzdHJ1Y3QgY3NhX3NldHRpbmdzIHsKKwl1OCBjc19jb3VudDsKKwl1OCBibG9ja190eDsKKworCXN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zIGZyZXFfcGFyYW1zOworCXN0cnVjdCBiZWFjb25fZGF0YSBiZWFjb25fY3NhOworCXN0cnVjdCBiZWFjb25fZGF0YSBiZWFjb25fYWZ0ZXI7CisKKwl1MTYgY291bnRlcl9vZmZzZXRfYmVhY29uOworCXUxNiBjb3VudGVyX29mZnNldF9wcmVzcDsKK307CisKKy8qIFRETFMgcGVlciBjYXBhYmlsaXRpZXMgZm9yIHNlbmRfdGRsc19tZ210KCkgKi8KK2VudW0gdGRsc19wZWVyX2NhcGFiaWxpdHkgeworCVRETFNfUEVFUl9IVCA9IEJJVCgwKSwKKwlURExTX1BFRVJfVkhUID0gQklUKDEpLAorCVRETFNfUEVFUl9XTU0gPSBCSVQoMiksCit9OworCisjaWZkZWYgQ09ORklHX01BQ1NFQworc3RydWN0IG1hY3NlY19pbml0X3BhcmFtcyB7CisJQm9vbGVhbiBhbHdheXNfaW5jbHVkZV9zY2k7CisJQm9vbGVhbiB1c2VfZXM7CisJQm9vbGVhbiB1c2Vfc2NiOworfTsKKyNlbmRpZiAvKiBDT05GSUdfTUFDU0VDICovCisKKworLyoqCiAgKiBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgLSBEcml2ZXIgaW50ZXJmYWNlIEFQSSBkZWZpbml0aW9uCiAgKgogICogVGhpcyBzdHJ1Y3R1cmUgZGVmaW5lcyB0aGUgQVBJIHRoYXQgZWFjaCBkcml2ZXIgaW50ZXJmYWNlIG5lZWRzIHRvIGltcGxlbWVudApAQCAtMTIwMCw3ICsxMzcxLDkgQEAKIAkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKIAkgKiBAYWxnOiBlbmNyeXB0aW9uIGFsZ29yaXRobSAoJVdQQV9BTEdfTk9ORSwgJVdQQV9BTEdfV0VQLAogCSAqCSVXUEFfQUxHX1RLSVAsICVXUEFfQUxHX0NDTVAsICVXUEFfQUxHX0lHVEssICVXUEFfQUxHX1BNSywKLQkgKgklV1BBX0FMR19HQ01QKTsKKwkgKgklV1BBX0FMR19HQ01QLCAlV1BBX0FMR19HQ01QXzI1NiwgJVdQQV9BTEdfQ0NNUF8yNTYsCisJICoJJVdQQV9BTEdfQklQX0dNQUNfMTI4LCAlV1BBX0FMR19CSVBfR01BQ18yNTYsCisJICoJJVdQQV9BTEdfQklQX0NNQUNfMjU2KTsKIAkgKgklV1BBX0FMR19OT05FIGNsZWFycyB0aGUga2V5LgogCSAqIEBhZGRyOiBBZGRyZXNzIG9mIHRoZSBwZWVyIFNUQSAoQlNTSUQgb2YgdGhlIGN1cnJlbnQgQVAgd2hlbiBzZXR0aW5nCiAJICoJcGFpcndpc2Uga2V5IGluIHN0YXRpb24gbW9kZSksIGZmOmZmOmZmOmZmOmZmOmZmIGZvcgpAQCAtMTU2NSw2ICsxNzM4LDE0IEBACiAJaW50ICgqc2V0X2NvdW50cnkpKHZvaWQgKnByaXYsIGNvbnN0IGNoYXIgKmFscGhhMik7CiAKIAkvKioKKwkgKiBnZXRfY291bnRyeSAtIEdldCBjb3VudHJ5CisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogQGFscGhhMjogQnVmZmVyIGZvciByZXR1cm5pbmcgY291bnRyeSBjb2RlIChhdCBsZWFzdCAzIG9jdGV0cykKKwkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKKwkgKi8KKwlpbnQgKCpnZXRfY291bnRyeSkodm9pZCAqcHJpdiwgY2hhciAqYWxwaGEyKTsKKworCS8qKgogCSAqIGdsb2JhbF9pbml0IC0gR2xvYmFsIGRyaXZlciBpbml0aWFsaXphdGlvbgogCSAqIFJldHVybnM6IFBvaW50ZXIgdG8gcHJpdmF0ZSBkYXRhIChnbG9iYWwpLCAlTlVMTCBvbiBmYWlsdXJlCiAJICoKQEAgLTE5NTAsMTIgKzIxMzEsMTMgQEAKIAkgKgkodGhpcyBtYXkgZGlmZmVyIGZyb20gdGhlIHJlcXVlc3RlZCBhZGRyIGlmIHRoZSBkcml2ZXIgY2Fubm90CiAJICoJY2hhbmdlIGludGVyZmFjZSBhZGRyZXNzKQogCSAqIEBicmlkZ2U6IEJyaWRnZSBpbnRlcmZhY2UgdG8gdXNlIG9yICVOVUxMIGlmIG5vIGJyaWRnZSBjb25maWd1cmVkCisJICogQHVzZV9leGlzdGluZzogV2hldGhlciB0byBhbGxvdyBleGlzdGluZyBpbnRlcmZhY2UgdG8gYmUgdXNlZAogCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQogCSAqLwogCWludCAoKmlmX2FkZCkodm9pZCAqcHJpdiwgZW51bSB3cGFfZHJpdmVyX2lmX3R5cGUgdHlwZSwKIAkJICAgICAgY29uc3QgY2hhciAqaWZuYW1lLCBjb25zdCB1OCAqYWRkciwgdm9pZCAqYnNzX2N0eCwKIAkJICAgICAgdm9pZCAqKmRydl9wcml2LCBjaGFyICpmb3JjZV9pZm5hbWUsIHU4ICppZl9hZGRyLAotCQkgICAgICBjb25zdCBjaGFyICpicmlkZ2UpOworCQkgICAgICBjb25zdCBjaGFyICpicmlkZ2UsIGludCB1c2VfZXhpc3RpbmcpOwogCiAJLyoqCiAJICogaWZfcmVtb3ZlIC0gUmVtb3ZlIGEgdmlydHVhbCBpbnRlcmZhY2UKQEAgLTIwMTcsNyArMjE5OSw3IEBACiAJICogQHNlc3Npb25fdGltZW91dDogU2Vzc2lvbiB0aW1lb3V0IGZvciB0aGUgc3RhdGlvbgogCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQogCSAqLwotCWludCAoKnNldF9yYWRpdXNfYWNsX2F1dGgpKHZvaWQgKnByaXYsIGNvbnN0IHU4ICptYWMsIGludCBhY2NlcHRlZCwgCisJaW50ICgqc2V0X3JhZGl1c19hY2xfYXV0aCkodm9pZCAqcHJpdiwgY29uc3QgdTggKm1hYywgaW50IGFjY2VwdGVkLAogCQkJCSAgIHUzMiBzZXNzaW9uX3RpbWVvdXQpOwogCiAJLyoqCkBAIC0yMDgxLDcgKzIyNjMsNyBAQAogCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQogCSAqLwogCWludCAoKnNldF93ZHNfc3RhKSh2b2lkICpwcml2LCBjb25zdCB1OCAqYWRkciwgaW50IGFpZCwgaW50IHZhbCwKLQkgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqYnJpZGdlX2lmbmFtZSwgY2hhciAqaWZuYW1lX3dkcyk7CisJCQkgICBjb25zdCBjaGFyICpicmlkZ2VfaWZuYW1lLCBjaGFyICppZm5hbWVfd2RzKTsKIAogCS8qKgogCSAqIHNlbmRfYWN0aW9uIC0gVHJhbnNtaXQgYW4gQWN0aW9uIGZyYW1lCkBAIC0yMTMyLDcgKzIzMTQsNyBAQAogCSAqCiAJICogVGhpcyBjb21tYW5kIGlzIHVzZWQgdG8gcmVxdWVzdCB0aGUgZHJpdmVyIHRvIHJlbWFpbiBhd2FrZSBvbiB0aGUKIAkgKiBzcGVjaWZpZWQgY2hhbm5lbCBmb3IgdGhlIHNwZWNpZmllZCBkdXJhdGlvbiBhbmQgcmVwb3J0IHJlY2VpdmVkCi0JICogQWN0aW9uIGZyYW1lcyB3aXRoIEVWRU5UX1JYX0FDVElPTiBldmVudHMuIE9wdGlvbmFsbHksIHJlY2VpdmVkCisJICogQWN0aW9uIGZyYW1lcyB3aXRoIEVWRU5UX1JYX01HTVQgZXZlbnRzLiBPcHRpb25hbGx5LCByZWNlaXZlZAogCSAqIFByb2JlIFJlcXVlc3QgZnJhbWVzIG1heSBhbHNvIGJlIHJlcXVlc3RlZCB0byBiZSByZXBvcnRlZCBieSBjYWxsaW5nCiAJICogcHJvYmVfcmVxX3JlcG9ydCgpLiBUaGVzZSB3aWxsIGJlIHJlcG9ydGVkIHdpdGggRVZFTlRfUlhfUFJPQkVfUkVRLgogCSAqCkBAIC0yMzE0LDIyOCArMjQ5NiwxMyBAQAogCWNvbnN0IGNoYXIgKiAoKmdldF9yYWRpb19uYW1lKSh2b2lkICpwcml2KTsKIAogCS8qKgotCSAqIHAycF9maW5kIC0gU3RhcnQgUDJQIERldmljZSBEaXNjb3ZlcnkKLQkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBAdGltZW91dDogVGltZW91dCBmb3IgZmluZCBvcGVyYXRpb24gaW4gc2Vjb25kcyBvciAwIGZvciBubyB0aW1lb3V0Ci0JICogQHR5cGU6IERldmljZSBEaXNjb3ZlcnkgdHlwZSAoZW51bSBwMnBfZGlzY292ZXJ5X3R5cGUpCi0JICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCi0JICoKLQkgKiBUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgdXNlZCBpZiB0aGUgZHJpdmVyIGltcGxlbWVudHMgUDJQIG1hbmFnZW1lbnQsCi0JICogaS5lLiwgaWYgaXQgc2V0cyBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UIGluCi0JICogc3RydWN0IHdwYV9kcml2ZXJfY2FwYS4KLQkgKi8KLQlpbnQgKCpwMnBfZmluZCkodm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IHRpbWVvdXQsIGludCB0eXBlKTsKLQotCS8qKgotCSAqIHAycF9zdG9wX2ZpbmQgLSBTdG9wIFAyUCBEZXZpY2UgRGlzY292ZXJ5Ci0JICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCi0JICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCi0JICoKLQkgKiBUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgdXNlZCBpZiB0aGUgZHJpdmVyIGltcGxlbWVudHMgUDJQIG1hbmFnZW1lbnQsCi0JICogaS5lLiwgaWYgaXQgc2V0cyBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UIGluCi0JICogc3RydWN0IHdwYV9kcml2ZXJfY2FwYS4KLQkgKi8KLQlpbnQgKCpwMnBfc3RvcF9maW5kKSh2b2lkICpwcml2KTsKLQotCS8qKgotCSAqIHAycF9saXN0ZW4gLSBTdGFydCBQMlAgTGlzdGVuIHN0YXRlIGZvciBzcGVjaWZpZWQgZHVyYXRpb24KLQkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBAdGltZW91dDogTGlzdGVuIHN0YXRlIGR1cmF0aW9uIGluIG1pbGxpc2Vjb25kcwotCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQotCSAqCi0JICogVGhpcyBmdW5jdGlvbiBjYW4gYmUgdXNlZCB0byByZXF1ZXN0IHRoZSBQMlAgbW9kdWxlIHRvIGtlZXAgdGhlCi0JICogZGV2aWNlIGRpc2NvdmVyYWJsZSBvbiB0aGUgbGlzdGVuIGNoYW5uZWwgZm9yIGFuIGV4dGVuZGVkIHNldCBvZgotCSAqIHRpbWUuIEF0IGxlYXN0IGluIGl0cyBjdXJyZW50IGZvcm0sIHRoaXMgaXMgbWFpbmx5IHVzZWQgZm9yIHRlc3RpbmcKLQkgKiBwdXJwb3NlcyBhbmQgbWF5IG5vdCBiZSBvZiBtdWNoIHVzZSBmb3Igbm9ybWFsIFAyUCBvcGVyYXRpb25zLgotCSAqCi0JICogVGhpcyBmdW5jdGlvbiBpcyBvbmx5IHVzZWQgaWYgdGhlIGRyaXZlciBpbXBsZW1lbnRzIFAyUCBtYW5hZ2VtZW50LAotCSAqIGkuZS4sIGlmIGl0IHNldHMgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCBpbgotCSAqIHN0cnVjdCB3cGFfZHJpdmVyX2NhcGEuCi0JICovCi0JaW50ICgqcDJwX2xpc3Rlbikodm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IHRpbWVvdXQpOwotCi0JLyoqCi0JICogcDJwX2Nvbm5lY3QgLSBTdGFydCBQMlAgZ3JvdXAgZm9ybWF0aW9uIChHTyBuZWdvdGlhdGlvbikKLQkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBAcGVlcl9hZGRyOiBNQUMgYWRkcmVzcyBvZiB0aGUgcGVlciBQMlAgY2xpZW50Ci0JICogQHdwc19tZXRob2Q6IGVudW0gcDJwX3dwc19tZXRob2QgdmFsdWUgaW5kaWNhdGluZyBjb25maWcgbWV0aG9kCi0JICogQGdvX2ludGVudDogTG9jYWwgR08gaW50ZW50IHZhbHVlICgxLi4xNSkKLQkgKiBAb3duX2ludGVyZmFjZV9hZGRyOiBJbnRlbmRlZCBpbnRlcmZhY2UgYWRkcmVzcyB0byB1c2Ugd2l0aCB0aGUKLQkgKglncm91cAotCSAqIEBmb3JjZV9mcmVxOiBUaGUgb25seSBhbGxvd2VkIGNoYW5uZWwgZnJlcXVlbmN5IGluIE1IeiBvciAwCi0JICogQHBlcnNpc3RlbnRfZ3JvdXA6IFdoZXRoZXIgdG8gY3JlYXRlIHBlcnNpc3RlbnQgZ3JvdXAKLQkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKLQkgKgotCSAqIFRoaXMgZnVuY3Rpb24gaXMgb25seSB1c2VkIGlmIHRoZSBkcml2ZXIgaW1wbGVtZW50cyBQMlAgbWFuYWdlbWVudCwKLQkgKiBpLmUuLCBpZiBpdCBzZXRzIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQgaW4KLQkgKiBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhLgotCSAqLwotCWludCAoKnAycF9jb25uZWN0KSh2b2lkICpwcml2LCBjb25zdCB1OCAqcGVlcl9hZGRyLCBpbnQgd3BzX21ldGhvZCwKLQkJCSAgIGludCBnb19pbnRlbnQsIGNvbnN0IHU4ICpvd25faW50ZXJmYWNlX2FkZHIsCi0JCQkgICB1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgaW50IHBlcnNpc3RlbnRfZ3JvdXApOwotCi0JLyoqCi0JICogd3BzX3N1Y2Nlc3NfY2IgLSBSZXBvcnQgc3VjY2Vzc2Z1bGx5IGNvbXBsZXRlZCBXUFMgcHJvdmlzaW9uaW5nCi0JICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCi0JICogQHBlZXJfYWRkcjogUGVlciBhZGRyZXNzCi0JICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCi0JICoKLQkgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gcmVwb3J0IHN1Y2Nlc3NmdWxseSBjb21wbGV0ZWQgV1BTCi0JICogcHJvdmlzaW9uaW5nIGR1cmluZyBncm91cCBmb3JtYXRpb24gaW4gYm90aCBHTy9SZWdpc3RyYXIgYW5kCi0JICogY2xpZW50L0Vucm9sbGVlIHJvbGVzLgotCSAqCi0JICogVGhpcyBmdW5jdGlvbiBpcyBvbmx5IHVzZWQgaWYgdGhlIGRyaXZlciBpbXBsZW1lbnRzIFAyUCBtYW5hZ2VtZW50LAotCSAqIGkuZS4sIGlmIGl0IHNldHMgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCBpbgotCSAqIHN0cnVjdCB3cGFfZHJpdmVyX2NhcGEuCi0JICovCi0JaW50ICgqd3BzX3N1Y2Nlc3NfY2IpKHZvaWQgKnByaXYsIGNvbnN0IHU4ICpwZWVyX2FkZHIpOwotCi0JLyoqCi0JICogcDJwX2dyb3VwX2Zvcm1hdGlvbl9mYWlsZWQgLSBSZXBvcnQgZmFpbGVkIFdQUyBwcm92aXNpb25pbmcKLQkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKLQkgKgotCSAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byByZXBvcnQgZmFpbGVkIGdyb3VwIGZvcm1hdGlvbi4gVGhpcyBjYW4KLQkgKiBoYXBwZW4gZWl0aGVyIGR1ZSB0byBmYWlsZWQgV1BTIHByb3Zpc2lvbmluZyBvciBkdWUgdG8gMTUgc2Vjb25kCi0JICogdGltZW91dCBkdXJpbmcgdGhlIHByb3Zpc2lvbmluZyBwaGFzZS4KLQkgKgotCSAqIFRoaXMgZnVuY3Rpb24gaXMgb25seSB1c2VkIGlmIHRoZSBkcml2ZXIgaW1wbGVtZW50cyBQMlAgbWFuYWdlbWVudCwKLQkgKiBpLmUuLCBpZiBpdCBzZXRzIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQgaW4KLQkgKiBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhLgotCSAqLwotCWludCAoKnAycF9ncm91cF9mb3JtYXRpb25fZmFpbGVkKSh2b2lkICpwcml2KTsKLQotCS8qKgotCSAqIHAycF9zZXRfcGFyYW1zIC0gU2V0IFAyUCBwYXJhbWV0ZXJzCi0JICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCi0JICogQHBhcmFtczogUDJQIHBhcmFtZXRlcnMKLQkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKLQkgKgotCSAqIFRoaXMgZnVuY3Rpb24gaXMgb25seSB1c2VkIGlmIHRoZSBkcml2ZXIgaW1wbGVtZW50cyBQMlAgbWFuYWdlbWVudCwKLQkgKiBpLmUuLCBpZiBpdCBzZXRzIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQgaW4KLQkgKiBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhLgotCSAqLwotCWludCAoKnAycF9zZXRfcGFyYW1zKSh2b2lkICpwcml2LCBjb25zdCBzdHJ1Y3QgcDJwX3BhcmFtcyAqcGFyYW1zKTsKLQotCS8qKgotCSAqIHAycF9wcm92X2Rpc2NfcmVxIC0gU2VuZCBQcm92aXNpb24gRGlzY292ZXJ5IFJlcXVlc3QKLQkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBAcGVlcl9hZGRyOiBNQUMgYWRkcmVzcyBvZiB0aGUgcGVlciBQMlAgY2xpZW50Ci0JICogQGNvbmZpZ19tZXRob2RzOiBXUFMgQ29uZmlnIE1ldGhvZHMgdmFsdWUgKG9ubHkgb25lIGJpdCBzZXQpCi0JICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCi0JICoKLQkgKiBUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIHRvIHJlcXVlc3QgYSBkaXNjb3ZlcmVkIFAyUCBwZWVyIHRvCi0JICogZGlzcGxheSBhIFBJTiAoY29uZmlnX21ldGhvZHMgPSBXUFNfQ09ORklHX0RJU1BMQVkpIG9yIGJlIHByZXBhcmVkCi0JICogdG8gZW50ZXIgYSBQSU4gZnJvbSB1cyAoY29uZmlnX21ldGhvZHMgPSBXUFNfQ09ORklHX0tFWVBBRCkuIFRoZQotCSAqIFByb3Zpc2lvbiBEaXNjb3ZlcnkgUmVxdWVzdCBmcmFtZSBpcyB0cmFuc21pdHRlZCBvbmNlIGltbWVkaWF0ZWx5Ci0JICogYW5kIGlmIG5vIHJlc3BvbnNlIGlzIHJlY2VpdmVkLCB0aGUgZnJhbWUgd2lsbCBiZSBzZW50IGFnYWluCi0JICogd2hlbmV2ZXIgdGhlIHRhcmdldCBkZXZpY2UgaXMgZGlzY292ZXJlZCBkdXJpbmcgZGV2aWNlIGRzaWNvdmVyeQotCSAqIChzdGFydCB3aXRoIGEgcDJwX2ZpbmQoKSBjYWxsKS4gUmVzcG9uc2UgZnJvbSB0aGUgcGVlciBpcyBpbmRpY2F0ZWQKLQkgKiB3aXRoIHRoZSBFVkVOVF9QMlBfUFJPVl9ESVNDX1JFU1BPTlNFIGV2ZW50LgotCSAqCi0JICogVGhpcyBmdW5jdGlvbiBpcyBvbmx5IHVzZWQgaWYgdGhlIGRyaXZlciBpbXBsZW1lbnRzIFAyUCBtYW5hZ2VtZW50LAotCSAqIGkuZS4sIGlmIGl0IHNldHMgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCBpbgotCSAqIHN0cnVjdCB3cGFfZHJpdmVyX2NhcGEuCi0JICovCi0JaW50ICgqcDJwX3Byb3ZfZGlzY19yZXEpKHZvaWQgKnByaXYsIGNvbnN0IHU4ICpwZWVyX2FkZHIsCi0JCQkJIHUxNiBjb25maWdfbWV0aG9kcywgaW50IGpvaW4pOwotCi0JLyoqCi0JICogcDJwX3NkX3JlcXVlc3QgLSBTY2hlZHVsZSBhIHNlcnZpY2UgZGlzY292ZXJ5IHF1ZXJ5Ci0JICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCi0JICogQGRzdDogRGVzdGluYXRpb24gcGVlciBvciAlTlVMTCB0byBhcHBseSBmb3IgYWxsIHBlZXJzCi0JICogQHRsdnM6IFAyUCBTZXJ2aWNlIFF1ZXJ5IFRMVihzKQotCSAqIFJldHVybnM6IFJlZmVyZW5jZSB0byB0aGUgcXVlcnkgb3IgMCBvbiBmYWlsdXJlCi0JICoKLQkgKiBSZXNwb25zZSB0byB0aGUgcXVlcnkgaXMgaW5kaWNhdGVkIHdpdGggdGhlCi0JICogRVZFTlRfUDJQX1NEX1JFU1BPTlNFIGRyaXZlciBldmVudC4KLQkgKgotCSAqIFRoaXMgZnVuY3Rpb24gaXMgb25seSB1c2VkIGlmIHRoZSBkcml2ZXIgaW1wbGVtZW50cyBQMlAgbWFuYWdlbWVudCwKLQkgKiBpLmUuLCBpZiBpdCBzZXRzIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQgaW4KLQkgKiBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhLgotCSAqLwotCXU2NCAoKnAycF9zZF9yZXF1ZXN0KSh2b2lkICpwcml2LCBjb25zdCB1OCAqZHN0LAotCQkJICAgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqdGx2cyk7Ci0KLQkvKioKLQkgKiBwMnBfc2RfY2FuY2VsX3JlcXVlc3QgLSBDYW5jZWwgYSBwZW5kaW5nIHNlcnZpY2UgZGlzY292ZXJ5IHF1ZXJ5Ci0JICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCi0JICogQHJlcTogUXVlcnkgcmVmZXJlbmNlIGZyb20gcDJwX3NkX3JlcXVlc3QoKQotCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQotCSAqCi0JICogVGhpcyBmdW5jdGlvbiBpcyBvbmx5IHVzZWQgaWYgdGhlIGRyaXZlciBpbXBsZW1lbnRzIFAyUCBtYW5hZ2VtZW50LAotCSAqIGkuZS4sIGlmIGl0IHNldHMgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCBpbgotCSAqIHN0cnVjdCB3cGFfZHJpdmVyX2NhcGEuCi0JICovCi0JaW50ICgqcDJwX3NkX2NhbmNlbF9yZXF1ZXN0KSh2b2lkICpwcml2LCB1NjQgcmVxKTsKLQotCS8qKgotCSAqIHAycF9zZF9yZXNwb25zZSAtIFNlbmQgcmVzcG9uc2UgdG8gYSBzZXJ2aWNlIGRpc2NvdmVyeSBxdWVyeQotCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQotCSAqIEBmcmVxOiBGcmVxdWVuY3kgZnJvbSBFVkVOVF9QMlBfU0RfUkVRVUVTVCBldmVudAotCSAqIEBkc3Q6IERlc3RpbmF0aW9uIGFkZHJlc3MgZnJvbSBFVkVOVF9QMlBfU0RfUkVRVUVTVCBldmVudAotCSAqIEBkaWFsb2dfdG9rZW46IERpYWxvZyB0b2tlbiBmcm9tIEVWRU5UX1AyUF9TRF9SRVFVRVNUIGV2ZW50Ci0JICogQHJlc3BfdGx2czogUDJQIFNlcnZpY2UgUmVzcG9uc2UgVExWKHMpCi0JICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCi0JICoKLQkgKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBhcyBhIHJlc3BvbnNlIHRvIHRoZSByZXF1ZXN0IGluZGljYXRlZCB3aXRoCi0JICogdGhlIEVWRU5UX1AyUF9TRF9SRVFVRVNUIGRyaXZlciBldmVudC4KLQkgKgotCSAqIFRoaXMgZnVuY3Rpb24gaXMgb25seSB1c2VkIGlmIHRoZSBkcml2ZXIgaW1wbGVtZW50cyBQMlAgbWFuYWdlbWVudCwKLQkgKiBpLmUuLCBpZiBpdCBzZXRzIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQgaW4KLQkgKiBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhLgotCSAqLwotCWludCAoKnAycF9zZF9yZXNwb25zZSkodm9pZCAqcHJpdiwgaW50IGZyZXEsIGNvbnN0IHU4ICpkc3QsCi0JCQkgICAgICAgdTggZGlhbG9nX3Rva2VuLAotCQkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnJlc3BfdGx2cyk7Ci0KLQkvKioKLQkgKiBwMnBfc2VydmljZV91cGRhdGUgLSBJbmRpY2F0ZSBhIGNoYW5nZSBpbiBsb2NhbCBzZXJ2aWNlcwotCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQotCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQotCSAqCi0JICogVGhpcyBmdW5jdGlvbiBuZWVkcyB0byBiZSBjYWxsZWQgd2hlbmV2ZXIgdGhlcmUgaXMgYSBjaGFuZ2UgaW4KLQkgKiBhdmFpbGFiaWxpdHkgb2YgdGhlIGxvY2FsIHNlcnZpY2VzLiBUaGlzIHdpbGwgaW5jcmVtZW50IHRoZQotCSAqIFNlcnZpY2UgVXBkYXRlIEluZGljYXRvciB2YWx1ZSB3aGljaCB3aWxsIGJlIHVzZWQgaW4gU0QgUmVxdWVzdCBhbmQKLQkgKiBSZXNwb25zZSBmcmFtZXMuCi0JICoKLQkgKiBUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgdXNlZCBpZiB0aGUgZHJpdmVyIGltcGxlbWVudHMgUDJQIG1hbmFnZW1lbnQsCi0JICogaS5lLiwgaWYgaXQgc2V0cyBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UIGluCi0JICogc3RydWN0IHdwYV9kcml2ZXJfY2FwYS4KLQkgKi8KLQlpbnQgKCpwMnBfc2VydmljZV91cGRhdGUpKHZvaWQgKnByaXYpOwotCi0JLyoqCi0JICogcDJwX3JlamVjdCAtIFJlamVjdCBwZWVyIGRldmljZSAoZXhwbGljaXRseSBibG9jayBjb25uZWN0aW9ucykKLQkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBAYWRkcjogTUFDIGFkZHJlc3Mgb2YgdGhlIHBlZXIKLQkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKLQkgKi8KLQlpbnQgKCpwMnBfcmVqZWN0KSh2b2lkICpwcml2LCBjb25zdCB1OCAqYWRkcik7Ci0KLQkvKioKLQkgKiBwMnBfaW52aXRlIC0gSW52aXRlIGEgUDJQIERldmljZSBpbnRvIGEgZ3JvdXAKLQkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBAcGVlcjogRGV2aWNlIEFkZHJlc3Mgb2YgdGhlIHBlZXIgUDJQIERldmljZQotCSAqIEByb2xlOiBMb2NhbCByb2xlIGluIHRoZSBncm91cAotCSAqIEBic3NpZDogR3JvdXAgQlNTSUQgb3IgJU5VTEwgaWYgbm90IGtub3duCi0JICogQHNzaWQ6IEdyb3VwIFNTSUQKLQkgKiBAc3NpZF9sZW46IExlbmd0aCBvZiBzc2lkIGluIG9jdGV0cwotCSAqIEBnb19kZXZfYWRkcjogRm9yY2VkIEdPIERldmljZSBBZGRyZXNzIG9yICVOVUxMIGlmIG5vbmUKLQkgKiBAcGVyc2lzdGVudF9ncm91cDogV2hldGhlciB0aGlzIGlzIHRvIHJlaW52b2tlIGEgcGVyc2lzdGVudCBncm91cAotCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQotCSAqLwotCWludCAoKnAycF9pbnZpdGUpKHZvaWQgKnByaXYsIGNvbnN0IHU4ICpwZWVyLCBpbnQgcm9sZSwKLQkJCSAgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuLAotCQkJICBjb25zdCB1OCAqZ29fZGV2X2FkZHIsIGludCBwZXJzaXN0ZW50X2dyb3VwKTsKLQotCS8qKgogCSAqIHNlbmRfdGRsc19tZ210IC0gZm9yIHNlbmRpbmcgVERMUyBtYW5hZ2VtZW50IHBhY2tldHMKIAkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKIAkgKiBAZHN0OiBEZXN0aW5hdGlvbiAocGVlcikgTUFDIGFkZHJlc3MKIAkgKiBAYWN0aW9uX2NvZGU6IFRETFMgYWN0aW9uIGNvZGUgZm9yIHRoZSBtc3NhZ2UKIAkgKiBAZGlhbG9nX3Rva2VuOiBEaWFsb2cgVG9rZW4gdG8gdXNlIGluIHRoZSBtZXNzYWdlIChpZiBuZWVkZWQpCiAJICogQHN0YXR1c19jb2RlOiBTdGF0dXMgQ29kZSBvciBSZWFzb24gQ29kZSB0byB1c2UgKGlmIG5lZWRlZCkKKwkgKiBAcGVlcl9jYXBhYjogVERMUyBwZWVyIGNhcGFiaWxpdHkgKFRETFNfUEVFUl8qIGJpdGZpZWxkKQogCSAqIEBidWY6IFRETFMgSUVzIHRvIGFkZCB0byB0aGUgbWVzc2FnZQogCSAqIEBsZW46IExlbmd0aCBvZiBidWYgaW4gb2N0ZXRzCiAJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCBuZWdhdGl2ZSAoPDApIG9uIGZhaWx1cmUKQEAgLTI1NDQsNyArMjUxMSw3IEBACiAJICogcmVzcG9uc2libGUgZm9yIHJlY2VpdmluZyBhbmQgc2VuZGluZyBhbGwgVERMUyBwYWNrZXRzLgogCSAqLwogCWludCAoKnNlbmRfdGRsc19tZ210KSh2b2lkICpwcml2LCBjb25zdCB1OCAqZHN0LCB1OCBhY3Rpb25fY29kZSwKLQkJCSAgICAgIHU4IGRpYWxvZ190b2tlbiwgdTE2IHN0YXR1c19jb2RlLAorCQkJICAgICAgdTggZGlhbG9nX3Rva2VuLCB1MTYgc3RhdHVzX2NvZGUsIHUzMiBwZWVyX2NhcGFiLAogCQkJICAgICAgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbik7CiAKIAkvKioKQEAgLTI1NzIsMTAgKzI1MzksMjYgQEAKIAkJCXU4ICpidWYsIHUxNiAqYnVmX2xlbik7CiAKIAkvKioKKwkgKiBzZXRfcW9zX21hcCAtIFNldCBRb1MgTWFwCisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogQHFvc19tYXBfc2V0OiBRb1MgTWFwCisJICogQHFvc19tYXBfc2V0X2xlbjogTGVuZ3RoIG9mIFFvUyBNYXAKKwkgKi8KKwlpbnQgKCpzZXRfcW9zX21hcCkodm9pZCAqcHJpdiwgY29uc3QgdTggKnFvc19tYXBfc2V0LAorCQkJICAgdTggcW9zX21hcF9zZXRfbGVuKTsKKworCS8qKgorCSAqIHNldF93b3dsYW4gLSBTZXQgd2FrZS1vbi13aXJlbGVzcyB0cmlnZ2VycworCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQorCSAqIEB0cmlnZ2Vyczogd293bGFuIHRyaWdnZXJzCisJICovCisJaW50ICgqc2V0X3dvd2xhbikodm9pZCAqcHJpdiwgY29uc3Qgc3RydWN0IHdvd2xhbl90cmlnZ2VycyAqdHJpZ2dlcnMpOworCisJLyoqCiAJICogc2lnbmFsX3BvbGwgLSBHZXQgY3VycmVudCBjb25uZWN0aW9uIGluZm9ybWF0aW9uCiAJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCiAJICogQHNpZ25hbF9pbmZvOiBDb25uZWN0aW9uIGluZm8gc3RydWN0dXJlCi0gICAgICAgICAqLworCSAqLwogCWludCAoKnNpZ25hbF9wb2xsKSh2b2lkICpwcml2LCBzdHJ1Y3Qgd3BhX3NpZ25hbF9pbmZvICpzaWduYWxfaW5mbyk7CiAKIAkvKioKQEAgLTI1OTEsMTggKzI1NzQsNDMgQEAKIAkgKiBERVBSRUNBVEVEIC0gdXNlIHNldF9hcCgpIGluc3RlYWQKIAkgKi8KIAlpbnQgKCpzZXRfYXV0aG1vZGUpKHZvaWQgKnByaXYsIGludCBhdXRobW9kZSk7CisKICNpZmRlZiBBTkRST0lECiAJLyoqCi0JICogZHJpdmVyX2NtZCAtIGV4ZWN1dGUgZHJpdmVyLXNwZWNpZmljIGNvbW1hbmQKLQkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKLQkgKiBAY21kOiBjb21tYW5kIHRvIGV4ZWN1dGUKLQkgKiBAYnVmOiByZXR1cm4gYnVmZmVyCi0JICogQGJ1Zl9sZW46IGJ1ZmZlciBsZW5ndGgKLQkgKgorCSAqIGRyaXZlcl9jbWQgLSBFeGVjdXRlIGRyaXZlci1zcGVjaWZpYyBjb21tYW5kCisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogQGNtZDogQ29tbWFuZCB0byBleGVjdXRlCisJICogQGJ1ZjogUmV0dXJuIGJ1ZmZlcgorCSAqIEBidWZfbGVuOiBCdWZmZXIgbGVuZ3RoCiAJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCiAJICovCi0JIGludCAoKmRyaXZlcl9jbWQpKHZvaWQgKnByaXYsIGNoYXIgKmNtZCwgY2hhciAqYnVmLCBzaXplX3QgYnVmX2xlbik7Ci0jZW5kaWYKKwlpbnQgKCpkcml2ZXJfY21kKSh2b2lkICpwcml2LCBjaGFyICpjbWQsIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1Zl9sZW4pOworI2VuZGlmIC8qIEFORFJPSUQgKi8KKworCS8qKgorCSAqIHZlbmRvcl9jbWQgLSBFeGVjdXRlIHZlbmRvciBzcGVjaWZpYyBjb21tYW5kCisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogQHZlbmRvcl9pZDogVmVuZG9yIGlkCisJICogQHN1YmNtZDogVmVuZG9yIGNvbW1hbmQgaWQKKwkgKiBAZGF0YTogVmVuZG9yIGNvbW1hbmQgcGFyYW1ldGVycyAoJU5VTEwgaWYgbm8gcGFyYW1ldGVycykKKwkgKiBAZGF0YV9sZW46IERhdGEgbGVuZ3RoCisJICogQGJ1ZjogUmV0dXJuIGJ1ZmZlciAoJU5VTEwgdG8gaWdub3JlIHJlcGx5KQorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgbmVnYXRpdmUgKDwwKSBvbiBmYWlsdXJlCisJICoKKwkgKiBUaGlzIGZ1bmN0aW9uIGhhbmRsZXMgdmVuZG9yIHNwZWNpZmljIGNvbW1hbmRzIHRoYXQgYXJlIHBhc3NlZCB0bworCSAqIHRoZSBkcml2ZXIvZGV2aWNlLiBUaGUgY29tbWFuZCBpcyBpZGVudGlmaWVkIGJ5IHZlbmRvciBpZCBhbmQKKwkgKiBjb21tYW5kIGlkLiBQYXJhbWV0ZXJzIGNhbiBiZSBwYXNzZWQgYXMgYXJndW1lbnQgdG8gdGhlIGNvbW1hbmQKKwkgKiBpbiB0aGUgZGF0YSBidWZmZXIuIFJlcGx5IChpZiBhbnkpIHdpbGwgYmUgZmlsbGVkIGluIHRoZSBzdXBwbGllZAorCSAqIHJldHVybiBidWZmZXIuCisJICoKKwkgKiBUaGUgZXhhY3QgZHJpdmVyIGJlaGF2aW9yIGlzIGRyaXZlciBpbnRlcmZhY2UgYW5kIHZlbmRvciBzcGVjaWZpYy4gQXMKKwkgKiBhbiBleGFtcGxlLCB0aGlzIHdpbGwgYmUgY29udmVydGVkIHRvIGEgdmVuZG9yIHNwZWNpZmljIGNmZzgwMjExCisJICogY29tbWFuZCBpbiBjYXNlIG9mIHRoZSBubDgwMjExIGRyaXZlciBpbnRlcmZhY2UuCisJICovCisJaW50ICgqdmVuZG9yX2NtZCkodm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IHZlbmRvcl9pZCwKKwkJCSAgdW5zaWduZWQgaW50IHN1YmNtZCwgY29uc3QgdTggKmRhdGEsIHNpemVfdCBkYXRhX2xlbiwKKwkJCSAgc3RydWN0IHdwYWJ1ZiAqYnVmKTsKKwogCS8qKgogCSAqIHNldF9yZWtleV9pbmZvIC0gU2V0IHJla2V5IGluZm9ybWF0aW9uCiAJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCkBAIC0yNzM1LDIxICsyNzQzLDIxIEBACiAJICogc3dpdGNoX2NoYW5uZWwgLSBBbm5vdW5jZSBjaGFubmVsIHN3aXRjaCBhbmQgbWlncmF0ZSB0aGUgR08gdG8gdGhlCiAJICogZ2l2ZW4gZnJlcXVlbmN5CiAJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCi0JICogQGZyZXE6IEZyZXF1ZW5jeSBpbiBNSHoKKwkgKiBAc2V0dGluZ3M6IFNldHRpbmdzIGZvciBDU0EgcGVyaW9kIGFuZCBuZXcgY2hhbm5lbAogCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQogCSAqCiAJICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIG1vdmUgdGhlIEdPIHRvIHRoZSBsZWdhY3kgU1RBIGNoYW5uZWwgdG8KIAkgKiBhdm9pZCBmcmVxdWVuY3kgY29uZmxpY3QgaW4gc2luZ2xlIGNoYW5uZWwgY29uY3VycmVuY3kuCiAJICovCi0JaW50ICgqc3dpdGNoX2NoYW5uZWwpKHZvaWQgKnByaXYsIHVuc2lnbmVkIGludCBmcmVxKTsKKwlpbnQgKCpzd2l0Y2hfY2hhbm5lbCkodm9pZCAqcHJpdiwgc3RydWN0IGNzYV9zZXR0aW5ncyAqc2V0dGluZ3MpOwogCiAJLyoqCiAJICogc3RhcnRfZGZzX2NhYyAtIExpc3RlbiBmb3IgcmFkYXIgaW50ZXJmZXJlbmNlIG9uIHRoZSBjaGFubmVsCiAJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCi0JICogQGZyZXE6IEZyZXF1ZW5jeSAoaW4gTUh6KSBvZiB0aGUgY2hhbm5lbAorCSAqIEBmcmVxOiBDaGFubmVsIHBhcmFtZXRlcnMKIAkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKIAkgKi8KLQlpbnQgKCpzdGFydF9kZnNfY2FjKSh2b2lkICpwcml2LCBpbnQgZnJlcSk7CisJaW50ICgqc3RhcnRfZGZzX2NhYykodm9pZCAqcHJpdiwgc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgKmZyZXEpOwogCiAJLyoqCiAJICogc3RvcF9hcCAtIFJlbW92ZXMgYmVhY29uIGZyb20gQVAKQEAgLTI3ODYsNiArMjc5NCwyMTIgQEAKIAkgKiBzdXJ2ZXkuCiAJICovCiAJaW50ICgqZ2V0X3N1cnZleSkodm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IGZyZXEpOworCisJLyoqCisJICogc3RhdHVzIC0gR2V0IGRyaXZlciBpbnRlcmZhY2Ugc3RhdHVzIGluZm9ybWF0aW9uCisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogQGJ1ZjogQnVmZmVyIGZvciBwcmludGluZyB0b3UgdGhlIHN0YXR1cyBpbmZvcm1hdGlvbgorCSAqIEBidWZsZW46IE1heGltdW0gbGVuZ3RoIG9mIHRoZSBidWZmZXIKKwkgKiBSZXR1cm5zOiBMZW5ndGggb2Ygd3JpdHRlbiBzdGF0dXMgaW5mb3JtYXRpb24gb3IgLTEgb24gZmFpbHVyZQorCSAqLworCWludCAoKnN0YXR1cykodm9pZCAqcHJpdiwgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKTsKKworI2lmZGVmIENPTkZJR19NQUNTRUMKKwlpbnQgKCptYWNzZWNfaW5pdCkodm9pZCAqcHJpdiwgc3RydWN0IG1hY3NlY19pbml0X3BhcmFtcyAqcGFyYW1zKTsKKworCWludCAoKm1hY3NlY19kZWluaXQpKHZvaWQgKnByaXYpOworCisJLyoqCisJICogZW5hYmxlX3Byb3RlY3RfZnJhbWVzIC0gU2V0IHByb3RlY3QgZnJhbWVzIHN0YXR1cworCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQorCSAqIEBlbmFibGVkOiBUUlVFID0gcHJvdGVjdCBmcmFtZXMgZW5hYmxlZAorCSAqICAgICAgICAgICBGQUxTRSA9IHByb3RlY3QgZnJhbWVzIGRpc2FibGVkCisJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlIChvciBpZiBub3Qgc3VwcG9ydGVkKQorCSAqLworCWludCAoKmVuYWJsZV9wcm90ZWN0X2ZyYW1lcykodm9pZCAqcHJpdiwgQm9vbGVhbiBlbmFibGVkKTsKKworCS8qKgorCSAqIHNldF9yZXBsYXlfcHJvdGVjdCAtIFNldCByZXBsYXkgcHJvdGVjdCBzdGF0dXMgYW5kIHdpbmRvdyBzaXplCisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogQGVuYWJsZWQ6IFRSVUUgPSByZXBsYXkgcHJvdGVjdCBlbmFibGVkCisJICogICAgICAgICAgIEZBTFNFID0gcmVwbGF5IHByb3RlY3QgZGlzYWJsZWQKKwkgKiBAd2luZG93OiByZXBsYXkgd2luZG93IHNpemUsIHZhbGlkIG9ubHkgd2hlbiByZXBsYXkgcHJvdGVjdCBlbmFibGVkCisJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlIChvciBpZiBub3Qgc3VwcG9ydGVkKQorCSAqLworCWludCAoKnNldF9yZXBsYXlfcHJvdGVjdCkodm9pZCAqcHJpdiwgQm9vbGVhbiBlbmFibGVkLCB1MzIgd2luZG93KTsKKworCS8qKgorCSAqIHNldF9jdXJyZW50X2NpcGhlcl9zdWl0ZSAtIFNldCBjdXJyZW50IGNpcGhlciBzdWl0ZQorCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQorCSAqIEBjczogRVVJNjQgaWRlbnRpZmllcgorCSAqIEBjc19sZW46IExlbmd0aCBvZiB0aGUgY3MgYnVmZmVyIGluIG9jdGV0cworCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZSAob3IgaWYgbm90IHN1cHBvcnRlZCkKKwkgKi8KKwlpbnQgKCpzZXRfY3VycmVudF9jaXBoZXJfc3VpdGUpKHZvaWQgKnByaXYsIGNvbnN0IHU4ICpjcywKKwkJCQkJc2l6ZV90IGNzX2xlbik7CisKKwkvKioKKwkgKiBlbmFibGVfY29udHJvbGxlZF9wb3J0IC0gU2V0IGNvbnRyb2xsZWQgcG9ydCBzdGF0dXMKKwkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKKwkgKiBAZW5hYmxlZDogVFJVRSA9IGNvbnRyb2xsZWQgcG9ydCBlbmFibGVkCisJICogICAgICAgICAgIEZBTFNFID0gY29udHJvbGxlZCBwb3J0IGRpc2FibGVkCisJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlIChvciBpZiBub3Qgc3VwcG9ydGVkKQorCSAqLworCWludCAoKmVuYWJsZV9jb250cm9sbGVkX3BvcnQpKHZvaWQgKnByaXYsIEJvb2xlYW4gZW5hYmxlZCk7CisKKwkvKioKKwkgKiBnZXRfcmVjZWl2ZV9sb3dlc3RfcG4gLSBHZXQgcmVjZWl2ZSBsb3dlc3QgcG4KKwkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwKKwkgKiBAYW46IGFzc29jaWF0aW9uIG51bWJlcgorCSAqIEBsb3dlc3RfcG46IGxvd2VzdCBhY2NlcHQgcG4KKwkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUgKG9yIGlmIG5vdCBzdXBwb3J0ZWQpCisJICovCisJaW50ICgqZ2V0X3JlY2VpdmVfbG93ZXN0X3BuKSh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJICAgICB1MzIgKmxvd2VzdF9wbik7CisKKwkvKioKKwkgKiBnZXRfdHJhbnNtaXRfbmV4dF9wbiAtIEdldCB0cmFuc21pdCBuZXh0IHBuCisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogQGNoYW5uZWw6IHNlY3VyZSBjaGFubmVsCisJICogQGFuOiBhc3NvY2lhdGlvbiBudW1iZXIKKwkgKiBAbmV4dF9wbjogbmV4dCBwbgorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZSAob3IgaWYgbm90IHN1cHBvcnRlZCkKKwkgKi8KKwlpbnQgKCpnZXRfdHJhbnNtaXRfbmV4dF9wbikodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIHU4IGFuLAorCQkJCSAgICB1MzIgKm5leHRfcG4pOworCisJLyoqCisJICogc2V0X3RyYW5zbWl0X25leHRfcG4gLSBTZXQgdHJhbnNtaXQgbmV4dCBwbgorCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQorCSAqIEBjaGFubmVsOiBzZWN1cmUgY2hhbm5lbAorCSAqIEBhbjogYXNzb2NpYXRpb24gbnVtYmVyCisJICogQG5leHRfcG46IG5leHQgcG4KKwkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUgKG9yIGlmIG5vdCBzdXBwb3J0ZWQpCisJICovCisJaW50ICgqc2V0X3RyYW5zbWl0X25leHRfcG4pKHZvaWQgKnByaXYsIHUzMiBjaGFubmVsLCB1OCBhbiwKKwkJCQkgICAgdTMyIG5leHRfcG4pOworCisJLyoqCisJICogZ2V0X2F2YWlsYWJsZV9yZWNlaXZlX3NjIC0gZ2V0IGF2YWlsYWJsZSByZWNlaXZlIGNoYW5uZWwKKwkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwKKwkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUgKG9yIGlmIG5vdCBzdXBwb3J0ZWQpCisJICovCisJaW50ICgqZ2V0X2F2YWlsYWJsZV9yZWNlaXZlX3NjKSh2b2lkICpwcml2LCB1MzIgKmNoYW5uZWwpOworCisJLyoqCisJICogY3JlYXRlX3JlY2VpdmVfc2MgLSBjcmVhdGUgc2VjdXJlIGNoYW5uZWwgZm9yIHJlY2VpdmluZworCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQorCSAqIEBjaGFubmVsOiBzZWN1cmUgY2hhbm5lbAorCSAqIEBzY2lfYWRkcjogc2VjdXJlIGNoYW5uZWwgaWRlbnRpZmllciAtIGFkZHJlc3MKKwkgKiBAc2NpX3BvcnQ6IHNlY3VyZSBjaGFubmVsIGlkZW50aWZpZXIgLSBwb3J0CisJICogQGNvbmZfb2Zmc2V0OiBjb25maWRlbnRpYWxpdHkgb2Zmc2V0ICgwLCAzMCwgb3IgNTApCisJICogQHZhbGlkYXRpb246IGZyYW1lIHZhbGlkYXRpb24gcG9saWN5ICgwID0gRGlzYWJsZWQsIDEgPSBDaGVja2VkLAorCSAqCTIgPSBTdHJpY3QpCisJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlIChvciBpZiBub3Qgc3VwcG9ydGVkKQorCSAqLworCWludCAoKmNyZWF0ZV9yZWNlaXZlX3NjKSh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwgY29uc3QgdTggKnNjaV9hZGRyLAorCQkJCSB1MTYgc2NpX3BvcnQsIHVuc2lnbmVkIGludCBjb25mX29mZnNldCwKKwkJCQkgaW50IHZhbGlkYXRpb24pOworCisJLyoqCisJICogZGVsZXRlX3JlY2VpdmVfc2MgLSBkZWxldGUgc2VjdXJlIGNvbm5lY3Rpb24gZm9yIHJlY2VpdmluZworCSAqIEBwcml2OiBwcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YSBmcm9tIGluaXQoKQorCSAqIEBjaGFubmVsOiBzZWN1cmUgY2hhbm5lbAorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorCSAqLworCWludCAoKmRlbGV0ZV9yZWNlaXZlX3NjKSh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCk7CisKKwkvKioKKwkgKiBjcmVhdGVfcmVjZWl2ZV9zYSAtIGNyZWF0ZSBzZWN1cmUgYXNzb2NpYXRpb24gZm9yIHJlY2VpdmUKKwkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEgZnJvbSBpbml0KCkKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwKKwkgKiBAYW46IGFzc29jaWF0aW9uIG51bWJlcgorCSAqIEBsb3dlc3RfcG46IHRoZSBsb3dlc3QgcGFja2V0IG51bWJlciBjYW4gYmUgcmVjZWl2ZWQKKwkgKiBAc2FrOiB0aGUgc2VjdXJlIGFzc29jaWF0aW9uIGtleQorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorCSAqLworCWludCAoKmNyZWF0ZV9yZWNlaXZlX3NhKSh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJIHUzMiBsb3dlc3RfcG4sIGNvbnN0IHU4ICpzYWspOworCisJLyoqCisJICogZW5hYmxlX3JlY2VpdmVfc2EgLSBlbmFibGUgdGhlIFNBIGZvciByZWNlaXZlCisJICogQHByaXY6IHByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhIGZyb20gaW5pdCgpCisJICogQGNoYW5uZWw6IHNlY3VyZSBjaGFubmVsCisJICogQGFuOiBhc3NvY2lhdGlvbiBudW1iZXIKKwkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKKwkgKi8KKwlpbnQgKCplbmFibGVfcmVjZWl2ZV9zYSkodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIHU4IGFuKTsKKworCS8qKgorCSAqIGRpc2FibGVfcmVjZWl2ZV9zYSAtIGRpc2FibGUgU0EgZm9yIHJlY2VpdmUKKwkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEgZnJvbSBpbml0KCkKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwgaW5kZXgKKwkgKiBAYW46IGFzc29jaWF0aW9uIG51bWJlcgorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorCSAqLworCWludCAoKmRpc2FibGVfcmVjZWl2ZV9zYSkodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIHU4IGFuKTsKKworCS8qKgorCSAqIGdldF9hdmFpbGFibGVfdHJhbnNtaXRfc2MgLSBnZXQgYXZhaWxhYmxlIHRyYW5zbWl0IGNoYW5uZWwKKwkgKiBAcHJpdjogUHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwKKwkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUgKG9yIGlmIG5vdCBzdXBwb3J0ZWQpCisJICovCisJaW50ICgqZ2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYykodm9pZCAqcHJpdiwgdTMyICpjaGFubmVsKTsKKworCS8qKgorCSAqIGNyZWF0ZV90cmFuc21pdF9zYyAtIGNyZWF0ZSBzZWN1cmUgY29ubmVjdGlvbiBmb3IgdHJhbnNtaXQKKwkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEgZnJvbSBpbml0KCkKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwKKwkgKiBAc2NpX2FkZHI6IHNlY3VyZSBjaGFubmVsIGlkZW50aWZpZXIgLSBhZGRyZXNzCisJICogQHNjaV9wb3J0OiBzZWN1cmUgY2hhbm5lbCBpZGVudGlmaWVyIC0gcG9ydAorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorCSAqLworCWludCAoKmNyZWF0ZV90cmFuc21pdF9zYykodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIGNvbnN0IHU4ICpzY2lfYWRkciwKKwkJCQkgIHUxNiBzY2lfcG9ydCwgdW5zaWduZWQgaW50IGNvbmZfb2Zmc2V0KTsKKworCS8qKgorCSAqIGRlbGV0ZV90cmFuc21pdF9zYyAtIGRlbGV0ZSBzZWN1cmUgY29ubmVjdGlvbiBmb3IgdHJhbnNtaXQKKwkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEgZnJvbSBpbml0KCkKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwKKwkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKKwkgKi8KKwlpbnQgKCpkZWxldGVfdHJhbnNtaXRfc2MpKHZvaWQgKnByaXYsIHUzMiBjaGFubmVsKTsKKworCS8qKgorCSAqIGNyZWF0ZV90cmFuc21pdF9zYSAtIGNyZWF0ZSBzZWN1cmUgYXNzb2NpYXRpb24gZm9yIHRyYW5zbWl0CisJICogQHByaXY6IHByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhIGZyb20gaW5pdCgpCisJICogQGNoYW5uZWw6IHNlY3VyZSBjaGFubmVsIGluZGV4CisJICogQGFuOiBhc3NvY2lhdGlvbiBudW1iZXIKKwkgKiBAbmV4dF9wbjogdGhlIHBhY2tldCBudW1iZXIgdXNlZCBhcyBuZXh0IHRyYW5zbWl0IHBhY2tldAorCSAqIEBjb25maWRlbnRpYWxpdHk6IFRydWUgaWYgdGhlIFNBIGlzIHRvIHByb3ZpZGUgY29uZmlkZW50aWFsaXR5CisJICogICAgICAgICAgICAgICAgICAgYXMgd2VsbCBhcyBpbnRlZ3JpdHkKKwkgKiBAc2FrOiB0aGUgc2VjdXJlIGFzc29jaWF0aW9uIGtleQorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorCSAqLworCWludCAoKmNyZWF0ZV90cmFuc21pdF9zYSkodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIHU4IGFuLCB1MzIgbmV4dF9wbiwKKwkJCQkgIEJvb2xlYW4gY29uZmlkZW50aWFsaXR5LCBjb25zdCB1OCAqc2FrKTsKKworCS8qKgorCSAqIGVuYWJsZV90cmFuc21pdF9zYSAtIGVuYWJsZSBTQSBmb3IgdHJhbnNtaXQKKwkgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgaW50ZXJmYWNlIGRhdGEgZnJvbSBpbml0KCkKKwkgKiBAY2hhbm5lbDogc2VjdXJlIGNoYW5uZWwKKwkgKiBAYW46IGFzc29jaWF0aW9uIG51bWJlcgorCSAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorCSAqLworCWludCAoKmVuYWJsZV90cmFuc21pdF9zYSkodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIHU4IGFuKTsKKworCS8qKgorCSAqIGRpc2FibGVfdHJhbnNtaXRfc2EgLSBkaXNhYmxlIFNBIGZvciB0cmFuc21pdAorCSAqIEBwcml2OiBwcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YSBmcm9tIGluaXQoKQorCSAqIEBjaGFubmVsOiBzZWN1cmUgY2hhbm5lbAorCSAqIEBhbjogYXNzb2NpYXRpb24gbnVtYmVyCisJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCisJICovCisJaW50ICgqZGlzYWJsZV90cmFuc21pdF9zYSkodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIHU4IGFuKTsKKyNlbmRpZiAvKiBDT05GSUdfTUFDU0VDICovCiB9OwogCiAKQEAgLTI5OTksMTUgKzMyMTMsNiBAQAogCUVWRU5UX1JYX01HTVQsCiAKIAkvKioKLQkgKiBFVkVOVF9SWF9BQ1RJT04gLSBBY3Rpb24gZnJhbWUgcmVjZWl2ZWQKLQkgKgotCSAqIFRoaXMgZXZlbnQgaXMgdXNlZCB0byBpbmRpY2F0ZSB3aGVuIGFuIEFjdGlvbiBmcmFtZSBoYXMgYmVlbgotCSAqIHJlY2VpdmVkLiBJbmZvcm1hdGlvbiBhYm91dCB0aGUgcmVjZWl2ZWQgZnJhbWUgaXMgaW5jbHVkZWQgaW4KLQkgKiB1bmlvbiB3cGFfZXZlbnRfZGF0YTo6cnhfYWN0aW9uLgotCSAqLwotCUVWRU5UX1JYX0FDVElPTiwKLQotCS8qKgogCSAqIEVWRU5UX1JFTUFJTl9PTl9DSEFOTkVMIC0gUmVtYWluLW9uLWNoYW5uZWwgZHVyYXRpb24gc3RhcnRlZAogCSAqCiAJICogVGhpcyBldmVudCBpcyB1c2VkIHRvIGluZGljYXRlIHdoZW4gdGhlIGRyaXZlciBoYXMgc3RhcnRlZCB0aGUKQEAgLTMxMTEsNyArMzMxNiw4IEBACiAJICogdGhlIGRyaXZlciBkb2VzIG5vdCBzdXBwb3J0IHJhZGFyIGRldGVjdGlvbiBhbmQgYW5vdGhlciB2aXJ0dWFsCiAJICogaW50ZXJmYWNlcyBjYXVzZWQgdGhlIG9wZXJhdGluZyBjaGFubmVsIHRvIGNoYW5nZS4gT3RoZXIgc2ltaWxhcgogCSAqIHJlc291cmNlIGNvbmZsaWN0cyBjb3VsZCBhbHNvIHRyaWdnZXIgdGhpcyBmb3Igc3RhdGlvbiBtb2RlCi0JICogaW50ZXJmYWNlcy4KKwkgKiBpbnRlcmZhY2VzLiBUaGlzIGV2ZW50IGNhbiBiZSBwcm9wYWdhdGVkIHdoZW4gY2hhbm5lbCBzd2l0Y2hpbmcKKwkgKiBmYWlscy4KIAkgKi8KIAlFVkVOVF9JTlRFUkZBQ0VfVU5BVkFJTEFCTEUsCiAKQEAgLTMxNTQsMzggKzMzNjAsNiBAQAogCUVWRU5UX1NUQVRJT05fTE9XX0FDSywKIAogCS8qKgotCSAqIEVWRU5UX1AyUF9ERVZfRk9VTkQgLSBSZXBvcnQgYSBkaXNjb3ZlcmVkIFAyUCBkZXZpY2UKLQkgKgotCSAqIFRoaXMgZXZlbnQgaXMgdXNlZCBvbmx5IGlmIHRoZSBkcml2ZXIgaW1wbGVtZW50cyBQMlAgbWFuYWdlbWVudAotCSAqIGludGVybmFsbHkuIEV2ZW50IGRhdGEgaXMgc3RvcmVkIGluCi0JICogdW5pb24gd3BhX2V2ZW50X2RhdGE6OnAycF9kZXZfZm91bmQuCi0JICovCi0JRVZFTlRfUDJQX0RFVl9GT1VORCwKLQotCS8qKgotCSAqIEVWRU5UX1AyUF9HT19ORUdfUkVRX1JYIC0gUmVwb3J0IHJlY2VwdGlvbiBvZiBHTyBOZWdvdGlhdGlvbiBSZXF1ZXN0Ci0JICoKLQkgKiBUaGlzIGV2ZW50IGlzIHVzZWQgb25seSBpZiB0aGUgZHJpdmVyIGltcGxlbWVudHMgUDJQIG1hbmFnZW1lbnQKLQkgKiBpbnRlcm5hbGx5LiBFdmVudCBkYXRhIGlzIHN0b3JlZCBpbgotCSAqIHVuaW9uIHdwYV9ldmVudF9kYXRhOjpwMnBfZ29fbmVnX3JlcV9yeC4KLQkgKi8KLQlFVkVOVF9QMlBfR09fTkVHX1JFUV9SWCwKLQotCS8qKgotCSAqIEVWRU5UX1AyUF9HT19ORUdfQ09NUExFVEVEIC0gUmVwb3J0IGNvbXBsZXRpb24gb2YgR08gTmVnb3RpYXRpb24KLQkgKgotCSAqIFRoaXMgZXZlbnQgaXMgdXNlZCBvbmx5IGlmIHRoZSBkcml2ZXIgaW1wbGVtZW50cyBQMlAgbWFuYWdlbWVudAotCSAqIGludGVybmFsbHkuIEV2ZW50IGRhdGEgaXMgc3RvcmVkIGluCi0JICogdW5pb24gd3BhX2V2ZW50X2RhdGE6OnAycF9nb19uZWdfY29tcGxldGVkLgotCSAqLwotCUVWRU5UX1AyUF9HT19ORUdfQ09NUExFVEVELAotCi0JRVZFTlRfUDJQX1BST1ZfRElTQ19SRVFVRVNULAotCUVWRU5UX1AyUF9QUk9WX0RJU0NfUkVTUE9OU0UsCi0JRVZFTlRfUDJQX1NEX1JFUVVFU1QsCi0JRVZFTlRfUDJQX1NEX1JFU1BPTlNFLAotCi0JLyoqCiAJICogRVZFTlRfSUJTU19QRUVSX0xPU1QgLSBJQlNTIHBlZXIgbm90IHJlYWNoYWJsZSBhbnltb3JlCiAJICovCiAJRVZFTlRfSUJTU19QRUVSX0xPU1QsCkBAIC0zMjcyLDE3ICszNDQ2LDM2IEBACiAJICovCiAJRVZFTlRfREZTX05PUF9GSU5JU0hFRCwKIAotCS8qCi0JKiBFVkVOVF9TVVJWRVkgLSBSZWNlaXZlZCBzdXJ2ZXkgZGF0YQotCSoKLQkqIFRoaXMgZXZlbnQgZ2V0cyB0cmlnZ2VyZWQgd2hlbiBhIGRyaXZlciBxdWVyeSBpcyBpc3N1ZWQgZm9yIHN1cnZleQotCSogZGF0YSBhbmQgdGhlIHJlcXVlc3RlZCBkYXRhIGJlY29tZXMgYXZhaWxhYmxlLiBUaGUgcmV0dXJuZWQgZGF0YSBpcwotCSogc3RvcmVkIGluIHN0cnVjdCBzdXJ2ZXlfcmVzdWx0cy4gVGhlIHJlc3VsdHMgcHJvdmlkZSBhdCBtb3N0IG9uZQotCSogc3VydmV5IGVudHJ5IGZvciBlYWNoIGZyZXF1ZW5jeSBhbmQgYXQgbWluaW11bSB3aWxsIHByb3ZpZGUgb25lIHN1cnZleQotCSogZW50cnkgZm9yIG9uZSBmcmVxdWVuY3kuIFRoZSBzdXJ2ZXkgZGF0YSBjYW4gYmUgb3NfbWFsbG9jKCknZCBhbmQKLQkqIHRoZW4gb3NfZnJlZSgpJ2QsIHNvIHRoZSBldmVudCBjYWxsYmFjayBtdXN0IG9ubHkgY29weSBkYXRhLgotCSovCi0JRVZFTlRfU1VSVkVZCisJLyoqCisJICogRVZFTlRfU1VSVkVZIC0gUmVjZWl2ZWQgc3VydmV5IGRhdGEKKwkgKgorCSAqIFRoaXMgZXZlbnQgZ2V0cyB0cmlnZ2VyZWQgd2hlbiBhIGRyaXZlciBxdWVyeSBpcyBpc3N1ZWQgZm9yIHN1cnZleQorCSAqIGRhdGEgYW5kIHRoZSByZXF1ZXN0ZWQgZGF0YSBiZWNvbWVzIGF2YWlsYWJsZS4gVGhlIHJldHVybmVkIGRhdGEgaXMKKwkgKiBzdG9yZWQgaW4gc3RydWN0IHN1cnZleV9yZXN1bHRzLiBUaGUgcmVzdWx0cyBwcm92aWRlIGF0IG1vc3Qgb25lCisJICogc3VydmV5IGVudHJ5IGZvciBlYWNoIGZyZXF1ZW5jeSBhbmQgYXQgbWluaW11bSB3aWxsIHByb3ZpZGUgb25lCisJICogc3VydmV5IGVudHJ5IGZvciBvbmUgZnJlcXVlbmN5LiBUaGUgc3VydmV5IGRhdGEgY2FuIGJlIG9zX21hbGxvYygpJ2QKKwkgKiBhbmQgdGhlbiBvc19mcmVlKCknZCwgc28gdGhlIGV2ZW50IGNhbGxiYWNrIG11c3Qgb25seSBjb3B5IGRhdGEuCisJICovCisJRVZFTlRfU1VSVkVZLAorCisJLyoqCisJICogRVZFTlRfU0NBTl9TVEFSVEVEIC0gU2NhbiBzdGFydGVkCisJICoKKwkgKiBUaGlzIGluZGljYXRlcyB0aGF0IGRyaXZlciBoYXMgc3RhcnRlZCBhIHNjYW4gb3BlcmF0aW9uIGVpdGhlciBiYXNlZAorCSAqIG9uIGEgcmVxdWVzdCBmcm9tIHdwYV9zdXBwbGljYW50L2hvc3RhcGQgb3IgZnJvbSBhbm90aGVyIGFwcGxpY2F0aW9uLgorCSAqIEVWRU5UX1NDQU5fUkVTVUxUUyBpcyB1c2VkIHRvIGluZGljYXRlIHdoZW4gdGhlIHNjYW4gaGFzIGJlZW4KKwkgKiBjb21wbGV0ZWQgKGVpdGhlciBzdWNjZXNzZnVsbHkgb3IgYnkgZ2V0dGluZyBjYW5jZWxsZWQpLgorCSAqLworCUVWRU5UX1NDQU5fU1RBUlRFRCwKKworCS8qKgorCSAqIEVWRU5UX0FWT0lEX0ZSRVFVRU5DSUVTIC0gUmVjZWl2ZWQgYXZvaWQgZnJlcXVlbmN5IHJhbmdlCisJICoKKwkgKiBUaGlzIGV2ZW50IGluZGljYXRlcyBhIHNldCBvZiBmcmVxdWVuY3kgcmFuZ2VzIHRoYXQgc2hvdWxkIGJlIGF2b2lkZWQKKwkgKiB0byByZWR1Y2UgaXNzdWVzIGR1ZSB0byBpbnRlcmZlcmVuY2Ugb3IgaW50ZXJuYWwgY28tZXhpc3RlbmNlCisJICogaW5mb3JtYXRpb24gaW4gdGhlIGRyaXZlci4KKwkgKi8KKwlFVkVOVF9BVk9JRF9GUkVRVUVOQ0lFUwogfTsKIAogCkBAIC0zNjUwLDQ4ICszODQzLDI2IEBACiAJCWNvbnN0IHU4ICpmcmFtZTsKIAkJc2l6ZV90IGZyYW1lX2xlbjsKIAkJdTMyIGRhdGFyYXRlOwotCQlpbnQgc3NpX3NpZ25hbDsgLyogZEJtICovCi0JfSByeF9tZ210OwotCi0JLyoqCi0JICogc3RydWN0IHJ4X2FjdGlvbiAtIERhdGEgZm9yIEVWRU5UX1JYX0FDVElPTiBldmVudHMKLQkgKi8KLQlzdHJ1Y3QgcnhfYWN0aW9uIHsKLQkJLyoqCi0JCSAqIGRhIC0gRGVzdGluYXRpb24gYWRkcmVzcyBvZiB0aGUgcmVjZWl2ZWQgQWN0aW9uIGZyYW1lCi0JCSAqLwotCQljb25zdCB1OCAqZGE7CiAKIAkJLyoqCi0JCSAqIHNhIC0gU291cmNlIGFkZHJlc3Mgb2YgdGhlIHJlY2VpdmVkIEFjdGlvbiBmcmFtZQorCQkgKiBkcnZfcHJpdiAtIFBvaW50ZXIgdG8gc3RvcmUgZHJpdmVyIHByaXZhdGUgQlNTIGluZm9ybWF0aW9uCisJCSAqCisJCSAqIElmIG5vdCBzZXQgdG8gTlVMTCwgdGhpcyBpcyB1c2VkIGZvciBjb21wYXJpc29uIHdpdGgKKwkJICogaG9zdGFwZF9kYXRhLT5kcnZfcHJpdiB0byBkZXRlcm1pbmUgd2hpY2ggQlNTIHNob3VsZCBwcm9jZXNzCisJCSAqIHRoZSBmcmFtZS4KIAkJICovCi0JCWNvbnN0IHU4ICpzYTsKLQotCQkvKioKLQkJICogYnNzaWQgLSBBZGRyZXNzIDMgb2YgdGhlIHJlY2VpdmVkIEFjdGlvbiBmcmFtZQotCQkgKi8KLQkJY29uc3QgdTggKmJzc2lkOwotCi0JCS8qKgotCQkgKiBjYXRlZ29yeSAtIEFjdGlvbiBmcmFtZSBjYXRlZ29yeQotCQkgKi8KLQkJdTggY2F0ZWdvcnk7Ci0KLQkJLyoqCi0JCSAqIGRhdGEgLSBBY3Rpb24gZnJhbWUgYm9keSBhZnRlciBjYXRlZ29yeSBmaWVsZAotCQkgKi8KLQkJY29uc3QgdTggKmRhdGE7Ci0KLQkJLyoqCi0JCSAqIGxlbiAtIExlbmd0aCBvZiBkYXRhIGluIG9jdGV0cwotCQkgKi8KLQkJc2l6ZV90IGxlbjsKKwkJdm9pZCAqZHJ2X3ByaXY7CiAKIAkJLyoqCiAJCSAqIGZyZXEgLSBGcmVxdWVuY3kgKGluIE1Ieikgb24gd2hpY2ggdGhlIGZyYW1lIHdhcyByZWNlaXZlZAogCQkgKi8KIAkJaW50IGZyZXE7Ci0JfSByeF9hY3Rpb247CisKKwkJLyoqCisJCSAqIHNzaV9zaWduYWwgLSBTaWduYWwgc3RyZW5ndGggaW4gZEJtIChvciAwIGlmIG5vdCBhdmFpbGFibGUpCisJCSAqLworCQlpbnQgc3NpX3NpZ25hbDsKKwl9IHJ4X21nbXQ7CiAKIAkvKioKIAkgKiBzdHJ1Y3QgcmVtYWluX29uX2NoYW5uZWwgLSBEYXRhIGZvciBFVkVOVF9SRU1BSU5fT05fQ0hBTk5FTCBldmVudHMKQEAgLTM4MzEsNjYgKzQwMDIsNiBAQAogCX0gbG93X2FjazsKIAogCS8qKgotCSAqIHN0cnVjdCBwMnBfZGV2X2ZvdW5kIC0gRGF0YSBmb3IgRVZFTlRfUDJQX0RFVl9GT1VORAotCSAqLwotCXN0cnVjdCBwMnBfZGV2X2ZvdW5kIHsKLQkJY29uc3QgdTggKmFkZHI7Ci0JCWNvbnN0IHU4ICpkZXZfYWRkcjsKLQkJY29uc3QgdTggKnByaV9kZXZfdHlwZTsKLQkJY29uc3QgY2hhciAqZGV2X25hbWU7Ci0JCXUxNiBjb25maWdfbWV0aG9kczsKLQkJdTggZGV2X2NhcGFiOwotCQl1OCBncm91cF9jYXBhYjsKLQl9IHAycF9kZXZfZm91bmQ7Ci0KLQkvKioKLQkgKiBzdHJ1Y3QgcDJwX2dvX25lZ19yZXFfcnggLSBEYXRhIGZvciBFVkVOVF9QMlBfR09fTkVHX1JFUV9SWAotCSAqLwotCXN0cnVjdCBwMnBfZ29fbmVnX3JlcV9yeCB7Ci0JCWNvbnN0IHU4ICpzcmM7Ci0JCXUxNiBkZXZfcGFzc3dkX2lkOwotCX0gcDJwX2dvX25lZ19yZXFfcng7Ci0KLQkvKioKLQkgKiBzdHJ1Y3QgcDJwX2dvX25lZ19jb21wbGV0ZWQgLSBEYXRhIGZvciBFVkVOVF9QMlBfR09fTkVHX0NPTVBMRVRFRAotCSAqLwotCXN0cnVjdCBwMnBfZ29fbmVnX2NvbXBsZXRlZCB7Ci0JCXN0cnVjdCBwMnBfZ29fbmVnX3Jlc3VsdHMgKnJlczsKLQl9IHAycF9nb19uZWdfY29tcGxldGVkOwotCi0Jc3RydWN0IHAycF9wcm92X2Rpc2NfcmVxIHsKLQkJY29uc3QgdTggKnBlZXI7Ci0JCXUxNiBjb25maWdfbWV0aG9kczsKLQkJY29uc3QgdTggKmRldl9hZGRyOwotCQljb25zdCB1OCAqcHJpX2Rldl90eXBlOwotCQljb25zdCBjaGFyICpkZXZfbmFtZTsKLQkJdTE2IHN1cHBfY29uZmlnX21ldGhvZHM7Ci0JCXU4IGRldl9jYXBhYjsKLQkJdTggZ3JvdXBfY2FwYWI7Ci0JfSBwMnBfcHJvdl9kaXNjX3JlcTsKLQotCXN0cnVjdCBwMnBfcHJvdl9kaXNjX3Jlc3AgewotCQljb25zdCB1OCAqcGVlcjsKLQkJdTE2IGNvbmZpZ19tZXRob2RzOwotCX0gcDJwX3Byb3ZfZGlzY19yZXNwOwotCi0Jc3RydWN0IHAycF9zZF9yZXEgewotCQlpbnQgZnJlcTsKLQkJY29uc3QgdTggKnNhOwotCQl1OCBkaWFsb2dfdG9rZW47Ci0JCXUxNiB1cGRhdGVfaW5kaWM7Ci0JCWNvbnN0IHU4ICp0bHZzOwotCQlzaXplX3QgdGx2c19sZW47Ci0JfSBwMnBfc2RfcmVxOwotCi0Jc3RydWN0IHAycF9zZF9yZXNwIHsKLQkJY29uc3QgdTggKnNhOwotCQl1MTYgdXBkYXRlX2luZGljOwotCQljb25zdCB1OCAqdGx2czsKLQkJc2l6ZV90IHRsdnNfbGVuOwotCX0gcDJwX3NkX3Jlc3A7Ci0KLQkvKioKIAkgKiBzdHJ1Y3QgaWJzc19wZWVyX2xvc3QgLSBEYXRhIGZvciBFVkVOVF9JQlNTX1BFRVJfTE9TVAogCSAqLwogCXN0cnVjdCBpYnNzX3BlZXJfbG9zdCB7CkBAIC0zOTM1LDExICs0MDQ2LDE3IEBACiAJICogQGZyZXE6IEZyZXF1ZW5jeSBvZiBuZXcgY2hhbm5lbCBpbiBNSHoKIAkgKiBAaHRfZW5hYmxlZDogV2hldGhlciB0aGlzIGlzIGFuIEhUIGNoYW5uZWwKIAkgKiBAY2hfb2Zmc2V0OiBTZWNvbmRhcnkgY2hhbm5lbCBvZmZzZXQKKwkgKiBAY2hfd2lkdGg6IENoYW5uZWwgd2lkdGgKKwkgKiBAY2YxOiBDZW50ZXIgZnJlcXVlbmN5IDEKKwkgKiBAY2YyOiBDZW50ZXIgZnJlcXVlbmN5IDIKIAkgKi8KIAlzdHJ1Y3QgY2hfc3dpdGNoIHsKIAkJaW50IGZyZXE7CiAJCWludCBodF9lbmFibGVkOwogCQlpbnQgY2hfb2Zmc2V0OworCQllbnVtIGNoYW5fd2lkdGggY2hfd2lkdGg7CisJCWludCBjZjE7CisJCWludCBjZjI7CiAJfSBjaF9zd2l0Y2g7CiAKIAkvKioKQEAgLTM5NjEsNiArNDA3OCwxMSBAQAogCSAqLwogCXN0cnVjdCBkZnNfZXZlbnQgewogCQlpbnQgZnJlcTsKKwkJaW50IGh0X2VuYWJsZWQ7CisJCWludCBjaGFuX29mZnNldDsKKwkJZW51bSBjaGFuX3dpZHRoIGNoYW5fd2lkdGg7CisJCWludCBjZjE7CisJCWludCBjZjI7CiAJfSBkZnNfZXZlbnQ7CiAKIAkvKioKQEAgLTM5NzMsNiArNDA5NSwyNSBAQAogCQl1bnNpZ25lZCBpbnQgZnJlcV9maWx0ZXI7CiAJCXN0cnVjdCBkbF9saXN0IHN1cnZleV9saXN0OyAvKiBzdHJ1Y3QgZnJlcV9zdXJ2ZXkgKi8KIAl9IHN1cnZleV9yZXN1bHRzOworCisJLyoqCisJICogY2hhbm5lbF9saXN0X2NoYW5nZWQgLSBEYXRhIGZvciBFVkVOVF9DSEFOTkVMX0xJU1RfQ0hBTkdFRAorCSAqIEBpbml0aWF0b3I6IEluaXRpYXRvciBvZiB0aGUgcmVndWxhdG9yeSBjaGFuZ2UKKwkgKiBAdHlwZTogUmVndWxhdG9yeSBjaGFuZ2UgdHlwZQorCSAqIEBhbHBoYTI6IENvdW50cnkgY29kZSAob3IgIiIgaWYgbm90IGF2YWlsYWJsZSkKKwkgKi8KKwlzdHJ1Y3QgY2hhbm5lbF9saXN0X2NoYW5nZWQgeworCQllbnVtIHJlZ19jaGFuZ2VfaW5pdGlhdG9yIGluaXRpYXRvcjsKKwkJZW51bSByZWdfdHlwZSB0eXBlOworCQljaGFyIGFscGhhMlszXTsKKwl9IGNoYW5uZWxfbGlzdF9jaGFuZ2VkOworCisJLyoqCisJICogZnJlcV9yYW5nZSAtIExpc3Qgb2YgZnJlcXVlbmN5IHJhbmdlcworCSAqCisJICogVGhpcyBpcyB1c2VkIGFzIHRoZSBkYXRhIHdpdGggRVZFTlRfQVZPSURfRlJFUVVFTkNJRVMuCisJICovCisJc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3QgZnJlcV9yYW5nZTsKIH07CiAKIC8qKgpAQCAtNDAzMSw0ICs0MTcyLDcgQEAKIC8qIENvbnZlcnQgd3BhX2V2ZW50X3R5cGUgdG8gYSBzdHJpbmcgZm9yIGxvZ2dpbmcgKi8KIGNvbnN0IGNoYXIgKiBldmVudF90b19zdHJpbmcoZW51bSB3cGFfZXZlbnRfdHlwZSBldmVudCk7CiAKKy8qIE5VTEwgdGVybWluYXRlZCBhcnJheSBvZiBsaW5rZWQgaW4gZHJpdmVyIHdyYXBwZXJzICovCitleHRlcm4gc3RydWN0IHdwYV9kcml2ZXJfb3BzICp3cGFfZHJpdmVyc1tdOworCiAjZW5kaWYgLyogRFJJVkVSX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL2RyaXZlcl9hdGhlcm9zLmMgYi9zcmMvZHJpdmVycy9kcml2ZXJfYXRoZXJvcy5jCmluZGV4IGMyZjU5MzQuLmI1NjlhMGEgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl9hdGhlcm9zLmMKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyX2F0aGVyb3MuYwpAQCAtMjYwLDYgKzI2MCwxNyBAQAogCWNhc2UgV1BBX0NJUEhFUl9DQ01QOgogCQl2ID0gSUVFRTgwMjExX0NJUEhFUl9BRVNfQ0NNOwogCQlicmVhazsKKyNpZmRlZiBBVEhfR0NNX1NVUFBPUlQKKwljYXNlIFdQQV9DSVBIRVJfQ0NNUF8yNTY6CisJCXYgPSBJRUVFODAyMTFfQ0lQSEVSX0FFU19DQ01fMjU2OworCQlicmVhazsKKwljYXNlIFdQQV9DSVBIRVJfR0NNUDoKKwkJdiA9IElFRUU4MDIxMV9DSVBIRVJfQUVTX0dDTTsKKwkJYnJlYWs7CisJY2FzZSBXUEFfQ0lQSEVSX0dDTVBfMjU2OgorCQl2ID0gSUVFRTgwMjExX0NJUEhFUl9BRVNfR0NNXzI1NjsKKwkJYnJlYWs7CisjZW5kaWYgLyogQVRIX0dDTV9TVVBQT1JUICovCiAJY2FzZSBXUEFfQ0lQSEVSX1RLSVA6CiAJCXYgPSBJRUVFODAyMTFfQ0lQSEVSX1RLSVA7CiAJCWJyZWFrOwpAQCAtMjk0LDYgKzMwNSwxNCBAQAogCXYgPSAwOwogCWlmIChwYXJhbXMtPndwYV9wYWlyd2lzZSAmIFdQQV9DSVBIRVJfQ0NNUCkKIAkJdiB8PSAxPDxJRUVFODAyMTFfQ0lQSEVSX0FFU19DQ007CisjaWZkZWYgQVRIX0dDTV9TVVBQT1JUCisJaWYgKHBhcmFtcy0+d3BhX3BhaXJ3aXNlICYgV1BBX0NJUEhFUl9DQ01QXzI1NikKKwkJdiB8PSAxPDxJRUVFODAyMTFfQ0lQSEVSX0FFU19DQ01fMjU2OworCWlmIChwYXJhbXMtPndwYV9wYWlyd2lzZSAmIFdQQV9DSVBIRVJfR0NNUCkKKwkJdiB8PSAxPDxJRUVFODAyMTFfQ0lQSEVSX0FFU19HQ007CisJaWYgKHBhcmFtcy0+d3BhX3BhaXJ3aXNlICYgV1BBX0NJUEhFUl9HQ01QXzI1NikKKwkJdiB8PSAxPDxJRUVFODAyMTFfQ0lQSEVSX0FFU19HQ01fMjU2OworI2VuZGlmIC8qIEFUSF9HQ01fU1VQUE9SVCAqLwogCWlmIChwYXJhbXMtPndwYV9wYWlyd2lzZSAmIFdQQV9DSVBIRVJfVEtJUCkKIAkJdiB8PSAxPDxJRUVFODAyMTFfQ0lQSEVSX1RLSVA7CiAJaWYgKHBhcmFtcy0+d3BhX3BhaXJ3aXNlICYgV1BBX0NJUEhFUl9OT05FKQpAQCAtMzU0LDE5ICszNzMsMTYgQEAKIAkJcmV0dXJuIGF0aGVyb3Nfc2V0X3ByaXZhY3koZHJ2LCAwKTsKIAl9CiAJaWYgKCFwYXJhbXMtPndwYSAmJiAhcGFyYW1zLT5pZWVlODAyXzF4KSB7Ci0JCWhvc3RhcGRfbG9nZ2VyKGRydi0+aGFwZCwgTlVMTCwgSE9TVEFQRF9NT0RVTEVfRFJJVkVSLAotCQkJSE9TVEFQRF9MRVZFTF9XQVJOSU5HLCAiTm8gODAyLjFYIG9yIFdQQSBlbmFibGVkISIpOworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiTm8gODAyLjFYIG9yIFdQQSBlbmFibGVkISIpOwogCQlyZXR1cm4gLTE7CiAJfQogCWlmIChwYXJhbXMtPndwYSAmJiBhdGhlcm9zX2NvbmZpZ3VyZV93cGEoZHJ2LCBwYXJhbXMpICE9IDApIHsKLQkJaG9zdGFwZF9sb2dnZXIoZHJ2LT5oYXBkLCBOVUxMLCBIT1NUQVBEX01PRFVMRV9EUklWRVIsCi0JCQlIT1NUQVBEX0xFVkVMX1dBUk5JTkcsICJFcnJvciBjb25maWd1cmluZyBXUEEgc3RhdGUhIik7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJFcnJvciBjb25maWd1cmluZyBXUEEgc3RhdGUhIik7CiAJCXJldHVybiAtMTsKIAl9CiAJaWYgKHNldDgwMjExcGFyYW0ocHJpdiwgSUVFRTgwMjExX1BBUkFNX0FVVEhNT0RFLAogCQkocGFyYW1zLT53cGEgPyBJRUVFODAyMTFfQVVUSF9XUEEgOiBJRUVFODAyMTFfQVVUSF84MDIxWCkpKSB7Ci0JCWhvc3RhcGRfbG9nZ2VyKGRydi0+aGFwZCwgTlVMTCwgSE9TVEFQRF9NT0RVTEVfRFJJVkVSLAotCQkJSE9TVEFQRF9MRVZFTF9XQVJOSU5HLCAiRXJyb3IgZW5hYmxpbmcgV1BBLzgwMi4xWCEiKTsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkVycm9yIGVuYWJsaW5nIFdQQS84MDIuMVghIik7CiAJCXJldHVybiAtMTsKIAl9CiAKQEAgLTQ3NCwxMCArNDkwLDMyIEBACiAJY2FzZSBXUEFfQUxHX0NDTVA6CiAJCWNpcGhlciA9IElFRUU4MDIxMV9DSVBIRVJfQUVTX0NDTTsKIAkJYnJlYWs7CisjaWZkZWYgQVRIX0dDTV9TVVBQT1JUCisJY2FzZSBXUEFfQUxHX0NDTVBfMjU2OgorCQljaXBoZXIgPSBJRUVFODAyMTFfQ0lQSEVSX0FFU19DQ01fMjU2OworCQlicmVhazsKKwljYXNlIFdQQV9BTEdfR0NNUDoKKwkJY2lwaGVyID0gSUVFRTgwMjExX0NJUEhFUl9BRVNfR0NNOworCQlicmVhazsKKwljYXNlIFdQQV9BTEdfR0NNUF8yNTY6CisJCWNpcGhlciA9IElFRUU4MDIxMV9DSVBIRVJfQUVTX0dDTV8yNTY7CisJCWJyZWFrOworI2VuZGlmIC8qIEFUSF9HQ01fU1VQUE9SVCAqLwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJY2FzZSBXUEFfQUxHX0lHVEs6CiAJCWNpcGhlciA9IElFRUU4MDIxMV9DSVBIRVJfQUVTX0NNQUM7CiAJCWJyZWFrOworI2lmZGVmIEFUSF9HQ01fU1VQUE9SVAorCWNhc2UgV1BBX0FMR19CSVBfQ01BQ18yNTY6CisJCWNpcGhlciA9IElFRUU4MDIxMV9DSVBIRVJfQUVTX0NNQUNfMjU2OworCQlicmVhazsKKwljYXNlIFdQQV9BTEdfQklQX0dNQUNfMTI4OgorCQljaXBoZXIgPSBJRUVFODAyMTFfQ0lQSEVSX0FFU19HTUFDOworCQlicmVhazsKKwljYXNlIFdQQV9BTEdfQklQX0dNQUNfMjU2OgorCQljaXBoZXIgPSBJRUVFODAyMTFfQ0lQSEVSX0FFU19HTUFDXzI1NjsKKwkJYnJlYWs7CisjZW5kaWYgLyogQVRIX0dDTV9TVVBQT1JUICovCiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIAlkZWZhdWx0OgogCQlwcmludGYoIiVzOiB1bmtub3duL3Vuc3VwcG9ydGVkIGFsZ29yaXRobSAlZFxuIiwKQEAgLTgwOSwxNiArODQ3LDEwIEBACiAJCWRydl9ldmVudF9hc3NvYyhkcnYtPmhhcGQsIG1nbXQtPnNhLCBpZWJ1ZiwgaWVsZW4sIDEpOwogCQlicmVhazsKIAljYXNlIFdMQU5fRkNfU1RZUEVfQUNUSU9OOgotCQlpZiAoJm1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ID4gYnVmICsgbGVuKQotCQkJYnJlYWs7CiAJCW9zX21lbXNldCgmZXZlbnQsIDAsIHNpemVvZihldmVudCkpOwotCQlldmVudC5yeF9hY3Rpb24uZGEgPSBtZ210LT5kYTsKLQkJZXZlbnQucnhfYWN0aW9uLnNhID0gbWdtdC0+c2E7Ci0JCWV2ZW50LnJ4X2FjdGlvbi5ic3NpZCA9IG1nbXQtPmJzc2lkOwotCQlldmVudC5yeF9hY3Rpb24uY2F0ZWdvcnkgPSBtZ210LT51LmFjdGlvbi5jYXRlZ29yeTsKLQkJZXZlbnQucnhfYWN0aW9uLmRhdGEgPSAmbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnk7Ci0JCWV2ZW50LnJ4X2FjdGlvbi5sZW4gPSBidWYgKyBsZW4gLSBldmVudC5yeF9hY3Rpb24uZGF0YTsKLQkJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5oYXBkLCBFVkVOVF9SWF9BQ1RJT04sICZldmVudCk7CisJCWV2ZW50LnJ4X21nbXQuZnJhbWUgPSBidWY7CisJCWV2ZW50LnJ4X21nbXQuZnJhbWVfbGVuID0gbGVuOworCQl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmhhcGQsIEVWRU5UX1JYX01HTVQsICZldmVudCk7CiAJCWJyZWFrOwogCWNhc2UgV0xBTl9GQ19TVFlQRV9BVVRIOgogCQlpZiAobGVuIC0gSUVFRTgwMjExX0hEUkxFTiA8IHNpemVvZihtZ210LT51LmF1dGgpKQpAQCAtODcyLDggKzkwNCw1OSBAQAogCWV2ZW50LnJ4X21nbXQuZnJhbWVfbGVuID0gbGVuOwogCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+aGFwZCwgRVZFTlRfUlhfTUdNVCwgJmV2ZW50KTsKIH0KKwogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKKworc3RhdGljIGludCBhdGhlcm9zX3NldF9xb3NfbWFwKHZvaWQgKmN0eCwgY29uc3QgdTggKnFvc19tYXBfc2V0LAorCQkJICAgICAgIHU4IHFvc19tYXBfc2V0X2xlbikKK3sKKyNpZmRlZiBDT05GSUdfQVRIRVJPU19RT1NfTUFQCisJc3RydWN0IGF0aGVyb3NfZHJpdmVyX2RhdGEgKmRydiA9IGN0eDsKKwlzdHJ1Y3QgaWVlZTgwMjExcmVxX2F0aGRiZyByZXE7CisJc3RydWN0IGllZWU4MDIxMV9xb3NfbWFwICpxb3NfbWFwID0gJnJlcS5kYXRhLnFvc19tYXA7CisJc3RydWN0IGl3cmVxIGl3cjsKKwlpbnQgaSwgdXBfc3RhcnQ7CisKKwlpZiAocW9zX21hcF9zZXRfbGVuIDwgMTYgfHwgcW9zX21hcF9zZXRfbGVuID4gNTggfHwKKwkgICAgcW9zX21hcF9zZXRfbGVuICYgMSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkludmFsaWQgUW9TIE1hcCIpOworCQlyZXR1cm4gLTE7CisJfSBlbHNlIHsKKwkJbWVtc2V0KCZyZXEsIDAsIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExcmVxX2F0aGRiZykpOworCQlyZXEuY21kID0gSUVFRTgwMjExX0RCR1JFUV9TRVRRT1NNQVBDT05GOworCQlvc19tZW1zZXQoJml3ciwgMCwgc2l6ZW9mKGl3cikpOworCQlvc19zdHJsY3B5KGl3ci5pZnJfbmFtZSwgZHJ2LT5pZmFjZSwgc2l6ZW9mKGl3ci5pZnJfbmFtZSkpOworCQlpd3IudS5kYXRhLnBvaW50ZXIgPSAodm9pZCAqKSAmcmVxOworCQlpd3IudS5kYXRhLmxlbmd0aCA9IHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExcmVxX2F0aGRiZyk7CisJfQorCisJcW9zX21hcC0+dmFsaWQgPSAxOworCXFvc19tYXAtPm51bV9kc2NwX2V4Y2VwdCA9IChxb3NfbWFwX3NldF9sZW4gLSAxNikgLyAyOworCWlmIChxb3NfbWFwLT5udW1fZHNjcF9leGNlcHQpIHsKKwkJZm9yIChpID0gMDsgaSA8IHFvc19tYXAtPm51bV9kc2NwX2V4Y2VwdDsgaSsrKSB7CisJCQlxb3NfbWFwLT5kc2NwX2V4Y2VwdGlvbltpXS5kc2NwCT0gcW9zX21hcF9zZXRbaSAqIDJdOworCQkJcW9zX21hcC0+ZHNjcF9leGNlcHRpb25baV0udXAgPQlxb3NfbWFwX3NldFtpICogMiArIDFdOworCQl9CisJfQorCisJdXBfc3RhcnQgPSBxb3NfbWFwX3NldF9sZW4gLSAxNjsKKwlmb3IgKGkgPSAwOyBpIDwgSUVFRTgwMjExX01BWF9RT1NfVVBfUkFOR0U7IGkrKykgeworCQlxb3NfbWFwLT51cFtpXS5sb3cgPSBxb3NfbWFwX3NldFt1cF9zdGFydCArIChpICogMildOworCQlxb3NfbWFwLT51cFtpXS5oaWdoID0gcW9zX21hcF9zZXRbdXBfc3RhcnQgKyAoaSAqIDIpICsgMV07CisJfQorCisJaWYgKGlvY3RsKGRydi0+aW9jdGxfc29jaywgSUVFRTgwMjExX0lPQ1RMX0RCR1JFUSwgJml3cikgPCAwKSB7CisJCXBlcnJvcigiaW9jdGxbSUVFRTgwMjExX0lPQ1RMX0RCR1JFUV0iKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogJXM6IEZhaWxlZCB0byBzZXQgUW9TIE1hcCIsCisJCQkgICBfX2Z1bmNfXywgZHJ2LT5pZmFjZSk7CisJCXJldHVybiAtMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0FUSEVST1NfUU9TX01BUCAqLworCisJcmV0dXJuIDA7Cit9CisKICNpZiBkZWZpbmVkKENPTkZJR19XTk0pICYmICFkZWZpbmVkKENPTkZJR19JRUVFODAyMTFSKQogc3RhdGljIHZvaWQgYXRoZXJvc19yYXdfcmVjdl8xMXYodm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjX2FkZHIsIGNvbnN0IHU4ICpidWYsCiAJCQkJIHNpemVfdCBsZW4pCkBAIC05MDYsMTYgKzk4OSwxMCBAQAogCiAJc3dpdGNoIChzdHlwZSkgewogCWNhc2UgV0xBTl9GQ19TVFlQRV9BQ1RJT046Ci0JCWlmICgmbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgPiBidWYgKyBsZW4pCi0JCQlicmVhazsKIAkJb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7Ci0JCWV2ZW50LnJ4X2FjdGlvbi5kYSA9IG1nbXQtPmRhOwotCQlldmVudC5yeF9hY3Rpb24uc2EgPSBtZ210LT5zYTsKLQkJZXZlbnQucnhfYWN0aW9uLmJzc2lkID0gbWdtdC0+YnNzaWQ7Ci0JCWV2ZW50LnJ4X2FjdGlvbi5jYXRlZ29yeSA9IG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5OwotCQlldmVudC5yeF9hY3Rpb24uZGF0YSA9ICZtZ210LT51LmFjdGlvbi5jYXRlZ29yeTsKLQkJZXZlbnQucnhfYWN0aW9uLmxlbiA9IGJ1ZiArIGxlbiAtIGV2ZW50LnJ4X2FjdGlvbi5kYXRhOwotCQl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmhhcGQsIEVWRU5UX1JYX0FDVElPTiwgJmV2ZW50KTsKKwkJZXZlbnQucnhfbWdtdC5mcmFtZSA9IGJ1ZjsKKwkJZXZlbnQucnhfbWdtdC5mcmFtZV9sZW4gPSBsZW47CisJCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+aGFwZCwgRVZFTlRfUlhfTUdNVCwgJmV2ZW50KTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJYnJlYWs7CkBAIC0xMzM0LDcgKzE0MTEsNyBAQAogCiAJd2hpbGUgKDEpIHsKIAkJb3NfbWVtc2V0KCZpd3IsIDAsIHNpemVvZihpd3IpKTsKLQkJb3Nfc3RybmNweShpd3IuaWZyX25hbWUsIGRydi0+aWZhY2UsIElGTkFNU0laKTsKKwkJb3Nfc3RybGNweShpd3IuaWZyX25hbWUsIGRydi0+aWZhY2UsIElGTkFNU0laKTsKIAogCQlpd3IudS5kYXRhLnBvaW50ZXIgPSAodm9pZCAqKSB0YnVmOwogCQlpd3IudS5kYXRhLmxlbmd0aCA9IHNpemVvZih0YnVmKTsKQEAgLTE4MzIsNiArMTkwOSwyNSBAQAogCXdwYV9oZXhkdW1wX2J1ZihNU0dfREVCVUcsICJhdGhlcm9zOiBhc3NvY3Jlc3BfaWVzIiwKIAkJCXBhcmFtcy0+YXNzb2NyZXNwX2llcyk7CiAKKyNpZiBkZWZpbmVkKENPTkZJR19IUzIwKSAmJiBkZWZpbmVkKElFRUU4MDIxMV9QQVJBTV9PU0VOKQorCWlmIChwYXJhbXMtPm9zZW4pIHsKKwkJc3RydWN0IHdwYV9ic3NfcGFyYW1zIGJzc19wYXJhbXM7CisKKwkJb3NfbWVtc2V0KCZic3NfcGFyYW1zLCAwLCBzaXplb2Yoc3RydWN0IHdwYV9ic3NfcGFyYW1zKSk7CisJCWJzc19wYXJhbXMuZW5hYmxlZCA9IDE7CisJCWJzc19wYXJhbXMud3BhID0gMjsKKwkJYnNzX3BhcmFtcy53cGFfcGFpcndpc2UgPSBXUEFfQ0lQSEVSX0NDTVA7CisJCWJzc19wYXJhbXMud3BhX2dyb3VwID0gV1BBX0NJUEhFUl9DQ01QOworCQlic3NfcGFyYW1zLmllZWU4MDJfMXggPSAxOworCisJCWlmIChhdGhlcm9zX3NldF9wcml2YWN5KHByaXYsIDEpIHx8CisJCSAgICBzZXQ4MDIxMXBhcmFtKHByaXYsIElFRUU4MDIxMV9QQVJBTV9PU0VOLCAxKSkKKwkJCXJldHVybiAtMTsKKworCQlyZXR1cm4gYXRoZXJvc19zZXRfaWVlZTgwMjF4KHByaXYsICZic3NfcGFyYW1zKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgJiYgSUVFRTgwMjExX1BBUkFNX09TRU4gKi8KKwogCXJldHVybiAwOwogfQogCkBAIC0xOTYzLDcgKzIwNTksNyBAQAogfQogCiAKLSNpZmRlZiBDT05GSUdfV05NCisjaWYgZGVmaW5lZChDT05GSUdfV05NKSAmJiBkZWZpbmVkKElFRUU4MDIxMV9BUFBJRV9GUkFNRV9XTk0pCiBzdGF0aWMgaW50IGF0aHJfd25tX3RmcyhzdHJ1Y3QgYXRoZXJvc19kcml2ZXJfZGF0YSAqZHJ2LCBjb25zdCB1OCogcGVlciwKIAkJCXU4ICppZSwgdTE2ICpsZW4sIGVudW0gd25tX29wZXIgb3BlcikKIHsKQEAgLTIxMTYsNyArMjIxMiw3IEBACiAJCXJldHVybiAtMTsKIAl9CiB9Ci0jZW5kaWYgLyogQ09ORklHX1dOTSAqLworI2VuZGlmIC8qIENPTkZJR19XTk0gJiYgSUVFRTgwMjExX0FQUElFX0ZSQU1FX1dOTSAqLwogCiAKIGNvbnN0IHN0cnVjdCB3cGFfZHJpdmVyX29wcyB3cGFfZHJpdmVyX2F0aGVyb3Nfb3BzID0gewpAQCAtMjE1MCw3ICsyMjQ2LDggQEAKIAkuYWRkX3N0YV9ub2RlICAgIAk9IGF0aGVyb3NfYWRkX3N0YV9ub2RlLAogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiAJLnNlbmRfYWN0aW9uCQk9IGF0aGVyb3Nfc2VuZF9hY3Rpb24sCi0jaWZkZWYgQ09ORklHX1dOTQorI2lmIGRlZmluZWQoQ09ORklHX1dOTSkgJiYgZGVmaW5lZChJRUVFODAyMTFfQVBQSUVfRlJBTUVfV05NKQogCS53bm1fb3BlcgkJPSBhdGhlcm9zX3dubV9vcGVyLAotI2VuZGlmIC8qIENPTkZJR19XTk0gKi8KKyNlbmRpZiAvKiBDT05GSUdfV05NICYmIElFRUU4MDIxMV9BUFBJRV9GUkFNRV9XTk0gKi8KKwkuc2V0X3Fvc19tYXAJCT0gYXRoZXJvc19zZXRfcW9zX21hcCwKIH07CmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9kcml2ZXJfYnNkLmMgYi9zcmMvZHJpdmVycy9kcml2ZXJfYnNkLmMKaW5kZXggNGFjYjEyYi4uY2E2NGQ1YyAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX2JzZC5jCisrKyBiL3NyYy9kcml2ZXJzL2RyaXZlcl9ic2QuYwpAQCAtNjIsMzYgKzYyLDEyIEBACiAJaW50CXByZXZfcHJpdmFjeTsJLyogcHJpdmFjeSBzdGF0ZSB0byByZXN0b3JlIG9uIGRlaW5pdCAqLwogCWludAlwcmV2X3dwYTsJLyogd3BhIHN0YXRlIHRvIHJlc3RvcmUgb24gZGVpbml0ICovCiAJZW51bSBpZWVlODAyMTFfb3Btb2RlIG9wbW9kZTsJLyogb3BlcmF0aW9uIG1vZGUgKi8KKwljaGFyCSpldmVudF9idWY7CisJc2l6ZV90CWV2ZW50X2J1Zl9sZW47CiB9OwogCiAvKiBHZW5lcmljIGZ1bmN0aW9ucyBmb3IgaG9zdGFwZCBhbmQgd3BhX3N1cHBsaWNhbnQgKi8KIAotc3RhdGljIGVudW0gaWVlZTgwMjExX29wbW9kZQotZ2V0ODAyMTFvcG1vZGUoc3RydWN0IGJzZF9kcml2ZXJfZGF0YSAqZHJ2KQotewotCXN0cnVjdCBpZm1lZGlhcmVxIGlmbXI7Ci0KLQkodm9pZCkgbWVtc2V0KCZpZm1yLCAwLCBzaXplb2YoaWZtcikpOwotCSh2b2lkKSBzdHJuY3B5KGlmbXIuaWZtX25hbWUsIGRydi0+aWZuYW1lLCBzaXplb2YoaWZtci5pZm1fbmFtZSkpOwotCi0JaWYgKGlvY3RsKGRydi0+c29jaywgU0lPQ0dJRk1FRElBLCAoY2FkZHJfdCkmaWZtcikgPj0gMCkgewotCQlpZiAoaWZtci5pZm1fY3VycmVudCAmIElGTV9JRUVFODAyMTFfQURIT0MpIHsKLQkJCWlmIChpZm1yLmlmbV9jdXJyZW50ICYgSUZNX0ZMQUcwKQotCQkJCXJldHVybiBJRUVFODAyMTFfTV9BSERFTU87Ci0JCQllbHNlCi0JCQkJcmV0dXJuIElFRUU4MDIxMV9NX0lCU1M7Ci0JCX0KLQkJaWYgKGlmbXIuaWZtX2N1cnJlbnQgJiBJRk1fSUVFRTgwMjExX0hPU1RBUCkKLQkJCXJldHVybiBJRUVFODAyMTFfTV9IT1NUQVA7Ci0JCWlmIChpZm1yLmlmbV9jdXJyZW50ICYgSUZNX0lFRUU4MDIxMV9NT05JVE9SKQotCQkJcmV0dXJuIElFRUU4MDIxMV9NX01PTklUT1I7Ci0JCWlmIChpZm1yLmlmbV9jdXJyZW50ICYgSUZNX0lFRUU4MDIxMV9NQlNTKQotCQkJcmV0dXJuIElFRUU4MDIxMV9NX01CU1M7Ci0JfQotCXJldHVybiBJRUVFODAyMTFfTV9TVEE7Ci19Ci0KLQogc3RhdGljIGludAogYnNkX3NldDgwMjExKHZvaWQgKnByaXYsIGludCBvcCwgaW50IHZhbCwgY29uc3Qgdm9pZCAqYXJnLCBpbnQgYXJnX2xlbikKIHsKQEAgLTMxMCwyMSArMjg2LDE1IEBACiAJcmV0dXJuIDA7CiB9CiAKLSNpZmRlZiBIT1NUQVBECi1zdGF0aWMgaW50Ci1ic2RfY29tbWl0KHZvaWQgKnByaXYpCi17Ci0JcmV0dXJuIGJzZF9jdHJsX2lmYWNlKHByaXYsIDEpOwotfQotI2VuZGlmIC8qIEhPU1RBUEQgKi8KLQogc3RhdGljIGludAogYnNkX3NldF9rZXkoY29uc3QgY2hhciAqaWZuYW1lLCB2b2lkICpwcml2LCBlbnVtIHdwYV9hbGcgYWxnLAogCSAgICBjb25zdCB1bnNpZ25lZCBjaGFyICphZGRyLCBpbnQga2V5X2lkeCwgaW50IHNldF90eCwgY29uc3QgdTggKnNlcSwKIAkgICAgc2l6ZV90IHNlcV9sZW4sIGNvbnN0IHU4ICprZXksIHNpemVfdCBrZXlfbGVuKQogewogCXN0cnVjdCBpZWVlODAyMTFyZXFfa2V5IHdrOworI2lmZGVmIElFRUU4MDIxMV9LRVlfTk9SRVBMQVkKIAlzdHJ1Y3QgYnNkX2RyaXZlcl9kYXRhICpkcnYgPSBwcml2OworI2VuZGlmIC8qIElFRUU4MDIxMV9LRVlfTk9SRVBMQVkgKi8KIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGFsZz0lZCBhZGRyPSVwIGtleV9pZHg9JWQgc2V0X3R4PSVkICIKIAkJICAgInNlcV9sZW49JXp1IGtleV9sZW49JXp1IiwgX19mdW5jX18sIGFsZywgYWRkciwga2V5X2lkeCwKQEAgLTM4MCwxMiArMzUwLDE0IEBACiAJaWYgKHdrLmlrX2tleWl4ICE9IElFRUU4MDIxMV9LRVlJWF9OT05FICYmIHNldF90eCkKIAkJd2suaWtfZmxhZ3MgfD0gSUVFRTgwMjExX0tFWV9ERUZBVUxUOwogI2lmbmRlZiBIT1NUQVBECisjaWZkZWYgSUVFRTgwMjExX0tFWV9OT1JFUExBWQogCS8qCiAJICogSWdub3JlIHJlcGxheSBmYWlsdXJlcyBpbiBJQlNTIGFuZCBBSERFTU8gbW9kZS4KIAkgKi8KIAlpZiAoZHJ2LT5vcG1vZGUgPT0gSUVFRTgwMjExX01fSUJTUyB8fAogCSAgICBkcnYtPm9wbW9kZSA9PSBJRUVFODAyMTFfTV9BSERFTU8pCiAJCXdrLmlrX2ZsYWdzIHw9IElFRUU4MDIxMV9LRVlfTk9SRVBMQVk7CisjZW5kaWYgLyogSUVFRTgwMjExX0tFWV9OT1JFUExBWSAqLwogI2VuZGlmIC8qIEhPU1RBUEQgKi8KIAl3ay5pa19rZXlsZW4gPSBrZXlfbGVuOwogCWlmIChzZXEpIHsKQEAgLTUyMiwyOCArNDk0LDYgQEAKIAlyZXR1cm4gYnNkX2N0cmxfaWZhY2UocHJpdiwgMSk7CiB9CiAKLSNpZmRlZiBIT1NUQVBECi1zdGF0aWMgaW50Ci1ic2Rfc2V0X3N0YV9hdXRob3JpemVkKHZvaWQgKnByaXYsIGNvbnN0IHU4ICphZGRyLAotCQkgICAgICAgaW50IHRvdGFsX2ZsYWdzLCBpbnQgZmxhZ3Nfb3IsIGludCBmbGFnc19hbmQpCi17Ci0JaW50IGF1dGhvcml6ZWQgPSAtMTsKLQotCS8qIEZvciBub3csIG9ubHkgc3VwcG9ydCBzZXR0aW5nIEF1dGhvcml6ZWQgZmxhZyAqLwotCWlmIChmbGFnc19vciAmIFdQQV9TVEFfQVVUSE9SSVpFRCkKLQkJYXV0aG9yaXplZCA9IDE7Ci0JaWYgKCEoZmxhZ3NfYW5kICYgV1BBX1NUQV9BVVRIT1JJWkVEKSkKLQkJYXV0aG9yaXplZCA9IDA7Ci0KLQlpZiAoYXV0aG9yaXplZCA8IDApCi0JCXJldHVybiAwOwotCi0JcmV0dXJuIGJzZF9zZW5kX21sbWVfcGFyYW0ocHJpdiwgYXV0aG9yaXplZCA/Ci0JCQkJICAgSUVFRTgwMjExX01MTUVfQVVUSE9SSVpFIDoKLQkJCQkgICBJRUVFODAyMTFfTUxNRV9VTkFVVEhPUklaRSwgMCwgYWRkcik7Ci19Ci0jZW5kaWYgLyogSE9TVEFQRCAqLwotCiBzdGF0aWMgdm9pZAogYnNkX25ld19zdGEodm9pZCAqcHJpdiwgdm9pZCAqY3R4LCB1OCBhZGRyW0lFRUU4MDIxMV9BRERSX0xFTl0pCiB7CkBAIC02MzYsNyArNTg2LDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludAorc3RhdGljIHNpemVfdAogcnRidWZfbGVuKHZvaWQpCiB7CiAJc2l6ZV90IGxlbjsKQEAgLTc3MywzNyArNzIzLDI2IEBACiBic2Rfd2lyZWxlc3NfZXZlbnRfcmVjZWl2ZShpbnQgc29jaywgdm9pZCAqY3R4LCB2b2lkICpzb2NrX2N0eCkKIHsKIAlzdHJ1Y3QgYnNkX2RyaXZlcl9kYXRhICpkcnYgPSBjdHg7Ci0JY2hhciAqYnVmOwogCXN0cnVjdCBpZl9hbm5vdW5jZW1zZ2hkciAqaWZhbjsKIAlzdHJ1Y3QgcnRfbXNnaGRyICpydG07CiAJc3RydWN0IGllZWU4MDIxMV9taWNoYWVsX2V2ZW50ICptaWM7CiAJc3RydWN0IGllZWU4MDIxMV9qb2luX2V2ZW50ICpqb2luOwogCXN0cnVjdCBpZWVlODAyMTFfbGVhdmVfZXZlbnQgKmxlYXZlOwotCWludCBuLCBsZW47CisJaW50IG47CiAJdW5pb24gd3BhX2V2ZW50X2RhdGEgZGF0YTsKIAotCWxlbiA9IHJ0YnVmX2xlbigpOwotCi0JYnVmID0gb3NfbWFsbG9jKGxlbik7Ci0JaWYgKGJ1ZiA9PSBOVUxMKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXMgb3NfbWFsbG9jKCkgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybjsKLQl9Ci0KLQluID0gcmVhZChzb2NrLCBidWYsIGxlbik7CisJbiA9IHJlYWQoc29jaywgZHJ2LT5ldmVudF9idWYsIGRydi0+ZXZlbnRfYnVmX2xlbik7CiAJaWYgKG4gPCAwKSB7CiAJCWlmIChlcnJubyAhPSBFSU5UUiAmJiBlcnJubyAhPSBFQUdBSU4pCiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzIHJlYWQoKSBmYWlsZWQ6ICVzXG4iLAogCQkJCSAgIF9fZnVuY19fLCBzdHJlcnJvcihlcnJubykpOwotCQlvc19mcmVlKGJ1Zik7CiAJCXJldHVybjsKIAl9CiAKLQlydG0gPSAoc3RydWN0IHJ0X21zZ2hkciAqKSBidWY7CisJcnRtID0gKHN0cnVjdCBydF9tc2doZHIgKikgZHJ2LT5ldmVudF9idWY7CiAJaWYgKHJ0bS0+cnRtX3ZlcnNpb24gIT0gUlRNX1ZFUlNJT04pIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnZhbGlkIHJvdXRpbmcgbWVzc2FnZSB2ZXJzaW9uPSVkIiwKIAkJCSAgIHJ0bS0+cnRtX3ZlcnNpb24pOwotCQlvc19mcmVlKGJ1Zik7CiAJCXJldHVybjsKIAl9CiAJaWZhbiA9IChzdHJ1Y3QgaWZfYW5ub3VuY2Vtc2doZHIgKikgcnRtOwpAQCAtODQ0LDcgKzc4Myw2IEBACiAJCX0KIAkJYnJlYWs7CiAJfQotCW9zX2ZyZWUoYnVmKTsKIH0KIAogc3RhdGljIHZvaWQKQEAgLTg2MSw3ICs3OTksMTUgQEAKIAogCWRydiA9IG9zX3phbGxvYyhzaXplb2Yoc3RydWN0IGJzZF9kcml2ZXJfZGF0YSkpOwogCWlmIChkcnYgPT0gTlVMTCkgewotCQlwcmludGYoIkNvdWxkIG5vdCBhbGxvY2F0ZSBtZW1vcnkgZm9yIGJzZCBkcml2ZXIgZGF0YVxuIik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ291bGQgbm90IGFsbG9jYXRlIG1lbW9yeSBmb3IgYnNkIGRyaXZlciBkYXRhIik7CisJCXJldHVybiBOVUxMOworCX0KKworCWRydi0+ZXZlbnRfYnVmX2xlbiA9IHJ0YnVmX2xlbigpOworCisJZHJ2LT5ldmVudF9idWYgPSBvc19tYWxsb2MoZHJ2LT5ldmVudF9idWZfbGVuKTsKKwlpZiAoZHJ2LT5ldmVudF9idWYgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzOiBvc19tYWxsb2MoKSBmYWlsZWQiLCBfX2Z1bmNfXyk7CiAJCWdvdG8gYmFkOwogCX0KIApAQCAtOTA0LDYgKzg1MCw3IEBACiAJCWwyX3BhY2tldF9kZWluaXQoZHJ2LT5zb2NrX3htaXQpOwogCWlmIChkcnYtPnNvY2sgPj0gMCkKIAkJY2xvc2UoZHJ2LT5zb2NrKTsKKwlvc19mcmVlKGRydi0+ZXZlbnRfYnVmKTsKIAlpZiAoZHJ2ICE9IE5VTEwpCiAJCW9zX2ZyZWUoZHJ2KTsKIAlyZXR1cm4gTlVMTDsKQEAgLTkyNCw5ICs4NzEsMzcgQEAKIAkJY2xvc2UoZHJ2LT5zb2NrKTsKIAlpZiAoZHJ2LT5zb2NrX3htaXQgIT0gTlVMTCkKIAkJbDJfcGFja2V0X2RlaW5pdChkcnYtPnNvY2tfeG1pdCk7CisJb3NfZnJlZShkcnYtPmV2ZW50X2J1Zik7CiAJb3NfZnJlZShkcnYpOwogfQogCisKK3N0YXRpYyBpbnQKK2JzZF9jb21taXQodm9pZCAqcHJpdikKK3sKKwlyZXR1cm4gYnNkX2N0cmxfaWZhY2UocHJpdiwgMSk7Cit9CisKKworc3RhdGljIGludAorYnNkX3NldF9zdGFfYXV0aG9yaXplZCh2b2lkICpwcml2LCBjb25zdCB1OCAqYWRkciwKKwkJICAgICAgIGludCB0b3RhbF9mbGFncywgaW50IGZsYWdzX29yLCBpbnQgZmxhZ3NfYW5kKQoreworCWludCBhdXRob3JpemVkID0gLTE7CisKKwkvKiBGb3Igbm93LCBvbmx5IHN1cHBvcnQgc2V0dGluZyBBdXRob3JpemVkIGZsYWcgKi8KKwlpZiAoZmxhZ3Nfb3IgJiBXUEFfU1RBX0FVVEhPUklaRUQpCisJCWF1dGhvcml6ZWQgPSAxOworCWlmICghKGZsYWdzX2FuZCAmIFdQQV9TVEFfQVVUSE9SSVpFRCkpCisJCWF1dGhvcml6ZWQgPSAwOworCisJaWYgKGF1dGhvcml6ZWQgPCAwKQorCQlyZXR1cm4gMDsKKworCXJldHVybiBic2Rfc2VuZF9tbG1lX3BhcmFtKHByaXYsIGF1dGhvcml6ZWQgPworCQkJCSAgIElFRUU4MDIxMV9NTE1FX0FVVEhPUklaRSA6CisJCQkJICAgSUVFRTgwMjExX01MTUVfVU5BVVRIT1JJWkUsIDAsIGFkZHIpOworfQogI2Vsc2UgLyogSE9TVEFQRCAqLwogCiBzdGF0aWMgaW50CkBAIC0xMTA0LDkgKzEwNzksOSBAQAogCWlmICh3cGFfZHJpdmVyX2JzZF9zZXRfd3BhX2llKGRydiwgcGFyYW1zLT53cGFfaWUsIHBhcmFtcy0+d3BhX2llX2xlbikgPCAwKQogCQlyZXR1cm4gLTE7CiAKLQlwcml2YWN5ID0gIShwYXJhbXMtPnBhaXJ3aXNlX3N1aXRlID09IENJUEhFUl9OT05FICYmCi0JICAgIHBhcmFtcy0+Z3JvdXBfc3VpdGUgPT0gQ0lQSEVSX05PTkUgJiYKLQkgICAgcGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBLRVlfTUdNVF9OT05FICYmCisJcHJpdmFjeSA9ICEocGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSA9PSBXUEFfQ0lQSEVSX05PTkUgJiYKKwkgICAgcGFyYW1zLT5ncm91cF9zdWl0ZSA9PSBXUEFfQ0lQSEVSX05PTkUgJiYKKwkgICAgcGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfTk9ORSAmJgogCSAgICBwYXJhbXMtPndwYV9pZV9sZW4gPT0gMCk7CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogc2V0IFBSSVZBQ1kgJXUiLCBfX2Z1bmNfXywgcHJpdmFjeSk7CiAKQEAgLTEyMDIsNyArMTE3Nyw2IEBACiB3cGFfZHJpdmVyX2JzZF9ldmVudF9yZWNlaXZlKGludCBzb2NrLCB2b2lkICpjdHgsIHZvaWQgKnNvY2tfY3R4KQogewogCXN0cnVjdCBic2RfZHJpdmVyX2RhdGEgKmRydiA9IHNvY2tfY3R4OwotCWNoYXIgKmJ1ZjsKIAlzdHJ1Y3QgaWZfYW5ub3VuY2Vtc2doZHIgKmlmYW47CiAJc3RydWN0IGlmX21zZ2hkciAqaWZtOwogCXN0cnVjdCBydF9tc2doZHIgKnJ0bTsKQEAgLTEyMTAsMzAgKzExODQsMjAgQEAKIAlzdHJ1Y3QgaWVlZTgwMjExX21pY2hhZWxfZXZlbnQgKm1pYzsKIAlzdHJ1Y3QgaWVlZTgwMjExX2xlYXZlX2V2ZW50ICpsZWF2ZTsKIAlzdHJ1Y3QgaWVlZTgwMjExX2pvaW5fZXZlbnQgKmpvaW47Ci0JaW50IG4sIGxlbjsKKwlpbnQgbjsKIAotCWxlbiA9IHJ0YnVmX2xlbigpOwotCi0JYnVmID0gb3NfbWFsbG9jKGxlbik7Ci0JaWYgKGJ1ZiA9PSBOVUxMKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXMgb3NfbWFsbG9jKCkgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybjsKLQl9Ci0KLQluID0gcmVhZChzb2NrLCBidWYsIGxlbik7CisJbiA9IHJlYWQoc29jaywgZHJ2LT5ldmVudF9idWYsIGRydi0+ZXZlbnRfYnVmX2xlbik7CiAJaWYgKG4gPCAwKSB7CiAJCWlmIChlcnJubyAhPSBFSU5UUiAmJiBlcnJubyAhPSBFQUdBSU4pCiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzIHJlYWQoKSBmYWlsZWQ6ICVzXG4iLAogCQkJCSAgIF9fZnVuY19fLCBzdHJlcnJvcihlcnJubykpOwotCQlvc19mcmVlKGJ1Zik7CiAJCXJldHVybjsKIAl9CiAKLQlydG0gPSAoc3RydWN0IHJ0X21zZ2hkciAqKSBidWY7CisJcnRtID0gKHN0cnVjdCBydF9tc2doZHIgKikgZHJ2LT5ldmVudF9idWY7CiAJaWYgKHJ0bS0+cnRtX3ZlcnNpb24gIT0gUlRNX1ZFUlNJT04pIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnZhbGlkIHJvdXRpbmcgbWVzc2FnZSB2ZXJzaW9uPSVkIiwKIAkJCSAgIHJ0bS0+cnRtX3ZlcnNpb24pOwotCQlvc19mcmVlKGJ1Zik7CiAJCXJldHVybjsKIAl9CiAJb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7CkBAIC0xMjQ4LDcgKzEyMTIsNiBAQAogCQljYXNlIElGQU5fREVQQVJUVVJFOgogCQkJZXZlbnQuaW50ZXJmYWNlX3N0YXR1cy5pZXZlbnQgPSBFVkVOVF9JTlRFUkZBQ0VfUkVNT1ZFRDsKIAkJZGVmYXVsdDoKLQkJCW9zX2ZyZWUoYnVmKTsKIAkJCXJldHVybjsKIAkJfQogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJUTV9JRkFOTk9VTkNFOiBJbnRlcmZhY2UgJyVzJyAlcyIsCkBAIC0xMzIxLDcgKzEyODQsNiBAQAogCQl9CiAJCWJyZWFrOwogCX0KLQlvc19mcmVlKGJ1Zik7CiB9CiAKIHN0YXRpYyB2b2lkCkBAIC0xNDkyLDYgKzE0NTQsMzMgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGVudW0gaWVlZTgwMjExX29wbW9kZQorZ2V0ODAyMTFvcG1vZGUoc3RydWN0IGJzZF9kcml2ZXJfZGF0YSAqZHJ2KQoreworCXN0cnVjdCBpZm1lZGlhcmVxIGlmbXI7CisKKwkodm9pZCkgbWVtc2V0KCZpZm1yLCAwLCBzaXplb2YoaWZtcikpOworCSh2b2lkKSBvc19zdHJsY3B5KGlmbXIuaWZtX25hbWUsIGRydi0+aWZuYW1lLCBzaXplb2YoaWZtci5pZm1fbmFtZSkpOworCisJaWYgKGlvY3RsKGRydi0+c29jaywgU0lPQ0dJRk1FRElBLCAoY2FkZHJfdCkmaWZtcikgPj0gMCkgeworCQlpZiAoaWZtci5pZm1fY3VycmVudCAmIElGTV9JRUVFODAyMTFfQURIT0MpIHsKKwkJCWlmIChpZm1yLmlmbV9jdXJyZW50ICYgSUZNX0ZMQUcwKQorCQkJCXJldHVybiBJRUVFODAyMTFfTV9BSERFTU87CisJCQllbHNlCisJCQkJcmV0dXJuIElFRUU4MDIxMV9NX0lCU1M7CisJCX0KKwkJaWYgKGlmbXIuaWZtX2N1cnJlbnQgJiBJRk1fSUVFRTgwMjExX0hPU1RBUCkKKwkJCXJldHVybiBJRUVFODAyMTFfTV9IT1NUQVA7CisJCWlmIChpZm1yLmlmbV9jdXJyZW50ICYgSUZNX0lFRUU4MDIxMV9NT05JVE9SKQorCQkJcmV0dXJuIElFRUU4MDIxMV9NX01PTklUT1I7CisjaWZkZWYgSUVFRTgwMjExX01fTUJTUworCQlpZiAoaWZtci5pZm1fY3VycmVudCAmIElGTV9JRUVFODAyMTFfTUJTUykKKwkJCXJldHVybiBJRUVFODAyMTFfTV9NQlNTOworI2VuZGlmIC8qIElFRUU4MDIxMV9NX01CU1MgKi8KKwl9CisJcmV0dXJuIElFRUU4MDIxMV9NX1NUQTsKK30KKwogc3RhdGljIHZvaWQgKgogd3BhX2RyaXZlcl9ic2RfaW5pdCh2b2lkICpjdHgsIGNvbnN0IGNoYXIgKmlmbmFtZSkKIHsKQEAgLTE1MDIsNiArMTQ5MSwxNSBAQAogCWRydiA9IG9zX3phbGxvYyhzaXplb2YoKmRydikpOwogCWlmIChkcnYgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CisKKwlkcnYtPmV2ZW50X2J1Zl9sZW4gPSBydGJ1Zl9sZW4oKTsKKworCWRydi0+ZXZlbnRfYnVmID0gb3NfbWFsbG9jKGRydi0+ZXZlbnRfYnVmX2xlbik7CisJaWYgKGRydi0+ZXZlbnRfYnVmID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICIlczogb3NfbWFsbG9jKCkgZmFpbGVkIiwgX19mdW5jX18pOworCQlnb3RvIGZhaWwxOworCX0KKwogCS8qCiAJICogTkI6IFdlIHJlcXVpcmUgdGhlIGludGVyZmFjZSBuYW1lIGJlIG1hcHBhYmxlIHRvIGFuIGluZGV4LgogCSAqICAgICBUaGlzIGltcGxpZXMgd2UgZG8gbm90IHN1cHBvcnQgaGF2aW5nIHdwYV9zdXBwbGljYW50CkBAIC0xNTU2LDYgKzE1NTQsNyBAQAogZmFpbDoKIAljbG9zZShkcnYtPnNvY2spOwogZmFpbDE6CisJb3NfZnJlZShkcnYtPmV2ZW50X2J1Zik7CiAJb3NfZnJlZShkcnYpOwogCXJldHVybiBOVUxMOwogI3VuZGVmIEdFVFBBUkFNCkBAIC0xNTgxLDYgKzE1ODAsNyBAQAogCQlsMl9wYWNrZXRfZGVpbml0KGRydi0+c29ja194bWl0KTsKIAkodm9pZCkgY2xvc2UoZHJ2LT5yb3V0ZSk7CQkvKiBpb2N0bCBzb2NrZXQgKi8KIAkodm9pZCkgY2xvc2UoZHJ2LT5zb2NrKTsJCS8qIGV2ZW50IHNvY2tldCAqLworCW9zX2ZyZWUoZHJ2LT5ldmVudF9idWYpOwogCW9zX2ZyZWUoZHJ2KTsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX2NvbW1vbi5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX2NvbW1vbi5jCmluZGV4IDhkMWQyMmUuLjMwNThjZDUgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl9jb21tb24uYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfY29tbW9uLmMKQEAgLTQ5LDcgKzQ5LDYgQEAKIAlFMlMoVFhfU1RBVFVTKTsKIAlFMlMoUlhfRlJPTV9VTktOT1dOKTsKIAlFMlMoUlhfTUdNVCk7Ci0JRTJTKFJYX0FDVElPTik7CiAJRTJTKFJFTUFJTl9PTl9DSEFOTkVMKTsKIAlFMlMoQ0FOQ0VMX1JFTUFJTl9PTl9DSEFOTkVMKTsKIAlFMlMoTUxNRV9SWCk7CkBAIC02NSwxMyArNjQsNiBAQAogCUUyUyhVTlBST1RfREVBVVRIKTsKIAlFMlMoVU5QUk9UX0RJU0FTU09DKTsKIAlFMlMoU1RBVElPTl9MT1dfQUNLKTsKLQlFMlMoUDJQX0RFVl9GT1VORCk7Ci0JRTJTKFAyUF9HT19ORUdfUkVRX1JYKTsKLQlFMlMoUDJQX0dPX05FR19DT01QTEVURUQpOwotCUUyUyhQMlBfUFJPVl9ESVNDX1JFUVVFU1QpOwotCUUyUyhQMlBfUFJPVl9ESVNDX1JFU1BPTlNFKTsKLQlFMlMoUDJQX1NEX1JFUVVFU1QpOwotCUUyUyhQMlBfU0RfUkVTUE9OU0UpOwogCUUyUyhJQlNTX1BFRVJfTE9TVCk7CiAJRTJTKERSSVZFUl9HVEtfUkVLRVkpOwogCUUyUyhTQ0hFRF9TQ0FOX1NUT1BQRUQpOwpAQCAtODUsNiArNzcsOCBAQAogCUUyUyhERlNfQ0FDX0FCT1JURUQpOwogCUUyUyhERlNfTk9QX0ZJTklTSEVEKTsKIAlFMlMoU1VSVkVZKTsKKwlFMlMoU0NBTl9TVEFSVEVEKTsKKwlFMlMoQVZPSURfRlJFUVVFTkNJRVMpOwogCX0KIAogCXJldHVybiAiVU5LTk9XTiI7CmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9kcml2ZXJfbWFjc2VjX3FjYS5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX21hY3NlY19xY2EuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jZjI0Nzk5Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyX21hY3NlY19xY2EuYwpAQCAtMCwwICsxLDg4NyBAQAorLyoKKyAqIFdpcmVkIEV0aGVybmV0IGRyaXZlciBpbnRlcmZhY2UgZm9yIFFDQSBNQUNzZWMgZHJpdmVyCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNCwgR3VudGVyIEJ1cmNoYXJkdCA8dGlyYUBpc3guZGU+CisgKiBDb3B5cmlnaHQgKGMpIDIwMTMtMjAxNCwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgImluY2x1ZGVzLmgiCisjaW5jbHVkZSA8c3lzL2lvY3RsLmg+CisjaW5jbHVkZSA8bmV0L2lmLmg+CisjaWZkZWYgX19saW51eF9fCisjaW5jbHVkZSA8bmV0cGFja2V0L3BhY2tldC5oPgorI2luY2x1ZGUgPG5ldC9pZl9hcnAuaD4KKyNpbmNsdWRlIDxuZXQvaWYuaD4KKyNlbmRpZiAvKiBfX2xpbnV4X18gKi8KKyNpZiBkZWZpbmVkKF9fRnJlZUJTRF9fKSB8fCBkZWZpbmVkKF9fRHJhZ29uRmx5X18pIHx8IGRlZmluZWQoX19GcmVlQlNEX2tlcm5lbF9fKQorI2luY2x1ZGUgPG5ldC9pZl9kbC5oPgorI2luY2x1ZGUgPG5ldC9pZl9tZWRpYS5oPgorI2VuZGlmIC8qIGRlZmluZWQoX19GcmVlQlNEX18pIHx8IGRlZmluZWQoX19EcmFnb25GbHlfXykgfHwgZGVmaW5lZChfX0ZyZWVCU0Rfa2VybmVsX18pICovCisjaWZkZWYgX19zdW5fXworI2luY2x1ZGUgPHN5cy9zb2NraW8uaD4KKyNlbmRpZiAvKiBfX3N1bl9fICovCisKKyNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKyNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgorI2luY2x1ZGUgImNvbW1vbi9kZWZzLmgiCisjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMXhfZGVmcy5oIgorI2luY2x1ZGUgImRyaXZlci5oIgorCisjaW5jbHVkZSAibnNzX21hY3NlY19zZWN5LmgiCisjaW5jbHVkZSAibnNzX21hY3NlY19zZWN5X3J4LmgiCisjaW5jbHVkZSAibnNzX21hY3NlY19zZWN5X3R4LmgiCisKKyNkZWZpbmUgTUFYU0MgMTYKKworLyogVENJIGZpZWxkIGRlZmluaXRpb24gKi8KKyNkZWZpbmUgVENJX0VTICAgICAgICAgICAgICAgIDB4NDAKKyNkZWZpbmUgVENJX1NDICAgICAgICAgICAgICAgIDB4MjAKKyNkZWZpbmUgVENJX1NDQiAgICAgICAgICAgICAgIDB4MTAKKyNkZWZpbmUgVENJX0UgICAgICAgICAgICAgICAgIDB4MDgKKyNkZWZpbmUgVENJX0MgICAgICAgICAgICAgICAgIDB4MDQKKworI2lmZGVmIF9NU0NfVkVSCisjcHJhZ21hIHBhY2socHVzaCwgMSkKKyNlbmRpZiAvKiBfTVNDX1ZFUiAqLworCisjaWZkZWYgX01TQ19WRVIKKyNwcmFnbWEgcGFjayhwb3ApCisjZW5kaWYgLyogX01TQ19WRVIgKi8KKworc3RhdGljIGNvbnN0IHU4IHBhZV9ncm91cF9hZGRyW0VUSF9BTEVOXSA9Cit7IDB4MDEsIDB4ODAsIDB4YzIsIDB4MDAsIDB4MDAsIDB4MDMgfTsKKworc3RydWN0IG1hY3NlY19xY2FfZGF0YSB7CisJY2hhciBpZm5hbWVbSUZOQU1TSVogKyAxXTsKKwl1MzIgc2VjeV9pZDsKKwl2b2lkICpjdHg7CisKKwlpbnQgc29jazsgLyogcmF3IHBhY2tldCBzb2NrZXQgZm9yIGRyaXZlciBhY2Nlc3MgKi8KKwlpbnQgcGZfc29jazsKKwlpbnQgbWVtYmVyc2hpcCwgbXVsdGksIGlmZl9hbGxtdWx0aSwgaWZmX3VwOworCisJLyogc2hhZG93ICovCisJQm9vbGVhbiBhbHdheXNfaW5jbHVkZV9zY2k7CisJQm9vbGVhbiB1c2VfZXM7CisJQm9vbGVhbiB1c2Vfc2NiOworCUJvb2xlYW4gcHJvdGVjdF9mcmFtZXM7CisJQm9vbGVhbiByZXBsYXlfcHJvdGVjdDsKKwl1MzIgcmVwbGF5X3dpbmRvdzsKK307CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX211bHRpY2FzdF9tZW1iZXJzaGlwKGludCBzb2NrLCBpbnQgaWZpbmRleCwKKwkJCQkJICAgY29uc3QgdTggKmFkZHIsIGludCBhZGQpCit7CisjaWZkZWYgX19saW51eF9fCisJc3RydWN0IHBhY2tldF9tcmVxIG1yZXE7CisKKwlpZiAoc29jayA8IDApCisJCXJldHVybiAtMTsKKworCW9zX21lbXNldCgmbXJlcSwgMCwgc2l6ZW9mKG1yZXEpKTsKKwltcmVxLm1yX2lmaW5kZXggPSBpZmluZGV4OworCW1yZXEubXJfdHlwZSA9IFBBQ0tFVF9NUl9NVUxUSUNBU1Q7CisJbXJlcS5tcl9hbGVuID0gRVRIX0FMRU47CisJb3NfbWVtY3B5KG1yZXEubXJfYWRkcmVzcywgYWRkciwgRVRIX0FMRU4pOworCisJaWYgKHNldHNvY2tvcHQoc29jaywgU09MX1BBQ0tFVCwKKwkJICAgICAgIGFkZCA/IFBBQ0tFVF9BRERfTUVNQkVSU0hJUCA6IFBBQ0tFVF9EUk9QX01FTUJFUlNISVAsCisJCSAgICAgICAmbXJlcSwgc2l6ZW9mKG1yZXEpKSA8IDApIHsKKwkJcGVycm9yKCJzZXRzb2Nrb3B0Iik7CisJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIDA7CisjZWxzZSAvKiBfX2xpbnV4X18gKi8KKwlyZXR1cm4gLTE7CisjZW5kaWYgLyogX19saW51eF9fICovCit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2dldF9zc2lkKHZvaWQgKnByaXYsIHU4ICpzc2lkKQoreworCXNzaWRbMF0gPSAwOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgbWFjc2VjX3FjYV9nZXRfYnNzaWQodm9pZCAqcHJpdiwgdTggKmJzc2lkKQoreworCS8qIFJlcG9ydCBQQUUgZ3JvdXAgYWRkcmVzcyBhcyB0aGUgIkJTU0lEIiBmb3IgbWFjc2VjIGNvbm5lY3Rpb24uICovCisJb3NfbWVtY3B5KGJzc2lkLCBwYWVfZ3JvdXBfYWRkciwgRVRIX0FMRU4pOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgbWFjc2VjX3FjYV9nZXRfY2FwYSh2b2lkICpwcml2LCBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhKQoreworCW9zX21lbXNldChjYXBhLCAwLCBzaXplb2YoKmNhcGEpKTsKKwljYXBhLT5mbGFncyA9IFdQQV9EUklWRVJfRkxBR1NfV0lSRUQ7CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2dldF9pZmZsYWdzKGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50ICpmbGFncykKK3sKKwlzdHJ1Y3QgaWZyZXEgaWZyOworCWludCBzOworCisJcyA9IHNvY2tldChQRl9JTkVULCBTT0NLX0RHUkFNLCAwKTsKKwlpZiAocyA8IDApIHsKKwkJcGVycm9yKCJzb2NrZXQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9zX21lbXNldCgmaWZyLCAwLCBzaXplb2YoaWZyKSk7CisJb3Nfc3RybGNweShpZnIuaWZyX25hbWUsIGlmbmFtZSwgSUZOQU1TSVopOworCWlmIChpb2N0bChzLCBTSU9DR0lGRkxBR1MsIChjYWRkcl90KSAmaWZyKSA8IDApIHsKKwkJcGVycm9yKCJpb2N0bFtTSU9DR0lGRkxBR1NdIik7CisJCWNsb3NlKHMpOworCQlyZXR1cm4gLTE7CisJfQorCWNsb3NlKHMpOworCSpmbGFncyA9IGlmci5pZnJfZmxhZ3MgJiAweGZmZmY7CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX3NldF9pZmZsYWdzKGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50IGZsYWdzKQoreworCXN0cnVjdCBpZnJlcSBpZnI7CisJaW50IHM7CisKKwlzID0gc29ja2V0KFBGX0lORVQsIFNPQ0tfREdSQU0sIDApOworCWlmIChzIDwgMCkgeworCQlwZXJyb3IoInNvY2tldCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJb3NfbWVtc2V0KCZpZnIsIDAsIHNpemVvZihpZnIpKTsKKwlvc19zdHJsY3B5KGlmci5pZnJfbmFtZSwgaWZuYW1lLCBJRk5BTVNJWik7CisJaWZyLmlmcl9mbGFncyA9IGZsYWdzICYgMHhmZmZmOworCWlmIChpb2N0bChzLCBTSU9DU0lGRkxBR1MsIChjYWRkcl90KSAmaWZyKSA8IDApIHsKKwkJcGVycm9yKCJpb2N0bFtTSU9DU0lGRkxBR1NdIik7CisJCWNsb3NlKHMpOworCQlyZXR1cm4gLTE7CisJfQorCWNsb3NlKHMpOworCXJldHVybiAwOworfQorCisKKyNpZiBkZWZpbmVkKF9fRnJlZUJTRF9fKSB8fCBkZWZpbmVkKF9fRHJhZ29uRmx5X18pIHx8IGRlZmluZWQoX19GcmVlQlNEX2tlcm5lbF9fKQorc3RhdGljIGludCBtYWNzZWNfcWNhX2dldF9pZnN0YXR1cyhjb25zdCBjaGFyICppZm5hbWUsIGludCAqc3RhdHVzKQoreworCXN0cnVjdCBpZm1lZGlhcmVxIGlmbXI7CisJaW50IHM7CisKKwlzID0gc29ja2V0KFBGX0lORVQsIFNPQ0tfREdSQU0sIDApOworCWlmIChzIDwgMCkgeworCQlwZXJyb3IoInNvY2tldCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJb3NfbWVtc2V0KCZpZm1yLCAwLCBzaXplb2YoaWZtcikpOworCW9zX3N0cmxjcHkoaWZtci5pZm1fbmFtZSwgaWZuYW1lLCBJRk5BTVNJWik7CisJaWYgKGlvY3RsKHMsIFNJT0NHSUZNRURJQSwgKGNhZGRyX3QpICZpZm1yKSA8IDApIHsKKwkJcGVycm9yKCJpb2N0bFtTSU9DR0lGTUVESUFdIik7CisJCWNsb3NlKHMpOworCQlyZXR1cm4gLTE7CisJfQorCWNsb3NlKHMpOworCSpzdGF0dXMgPSAoaWZtci5pZm1fc3RhdHVzICYgKElGTV9BQ1RJVkUgfCBJRk1fQVZBTElEKSkgPT0KKwkJKElGTV9BQ1RJVkUgfCBJRk1fQVZBTElEKTsKKworCXJldHVybiAwOworfQorI2VuZGlmIC8qIGRlZmluZWQoX19GcmVlQlNEX18pIHx8IGRlZmluZWQoX19EcmFnb25GbHlfXykgfHwgZGVmaW5lZChGcmVlQlNEX2tlcm5lbF9fKSAqLworCisKK3N0YXRpYyBpbnQgbWFjc2VjX3FjYV9tdWx0aShjb25zdCBjaGFyICppZm5hbWUsIGNvbnN0IHU4ICphZGRyLCBpbnQgYWRkKQoreworCXN0cnVjdCBpZnJlcSBpZnI7CisJaW50IHM7CisKKyNpZmRlZiBfX3N1bl9fCisJcmV0dXJuIC0xOworI2VuZGlmIC8qIF9fc3VuX18gKi8KKworCXMgPSBzb2NrZXQoUEZfSU5FVCwgU09DS19ER1JBTSwgMCk7CisJaWYgKHMgPCAwKSB7CisJCXBlcnJvcigic29ja2V0Iik7CisJCXJldHVybiAtMTsKKwl9CisKKwlvc19tZW1zZXQoJmlmciwgMCwgc2l6ZW9mKGlmcikpOworCW9zX3N0cmxjcHkoaWZyLmlmcl9uYW1lLCBpZm5hbWUsIElGTkFNU0laKTsKKyNpZmRlZiBfX2xpbnV4X18KKwlpZnIuaWZyX2h3YWRkci5zYV9mYW1pbHkgPSBBRl9VTlNQRUM7CisJb3NfbWVtY3B5KGlmci5pZnJfaHdhZGRyLnNhX2RhdGEsIGFkZHIsIEVUSF9BTEVOKTsKKyNlbmRpZiAvKiBfX2xpbnV4X18gKi8KKyNpZiBkZWZpbmVkKF9fRnJlZUJTRF9fKSB8fCBkZWZpbmVkKF9fRHJhZ29uRmx5X18pIHx8IGRlZmluZWQoX19GcmVlQlNEX2tlcm5lbF9fKQorCXsKKwkJc3RydWN0IHNvY2thZGRyX2RsICpkbHA7CisJCWRscCA9IChzdHJ1Y3Qgc29ja2FkZHJfZGwgKikgJmlmci5pZnJfYWRkcjsKKwkJZGxwLT5zZGxfbGVuID0gc2l6ZW9mKHN0cnVjdCBzb2NrYWRkcl9kbCk7CisJCWRscC0+c2RsX2ZhbWlseSA9IEFGX0xJTks7CisJCWRscC0+c2RsX2luZGV4ID0gMDsKKwkJZGxwLT5zZGxfbmxlbiA9IDA7CisJCWRscC0+c2RsX2FsZW4gPSBFVEhfQUxFTjsKKwkJZGxwLT5zZGxfc2xlbiA9IDA7CisJCW9zX21lbWNweShMTEFERFIoZGxwKSwgYWRkciwgRVRIX0FMRU4pOworCX0KKyNlbmRpZiAvKiBkZWZpbmVkKF9fRnJlZUJTRF9fKSB8fCBkZWZpbmVkKF9fRHJhZ29uRmx5X18pIHx8IGRlZmluZWQoRnJlZUJTRF9rZXJuZWxfXykgKi8KKyNpZiBkZWZpbmVkKF9fTmV0QlNEX18pIHx8IGRlZmluZWQoX19PcGVuQlNEX18pIHx8IGRlZmluZWQoX19BUFBMRV9fKQorCXsKKwkJc3RydWN0IHNvY2thZGRyICpzYXA7CisJCXNhcCA9IChzdHJ1Y3Qgc29ja2FkZHIgKikgJmlmci5pZnJfYWRkcjsKKwkJc2FwLT5zYV9sZW4gPSBzaXplb2Yoc3RydWN0IHNvY2thZGRyKTsKKwkJc2FwLT5zYV9mYW1pbHkgPSBBRl9VTlNQRUM7CisJCW9zX21lbWNweShzYXAtPnNhX2RhdGEsIGFkZHIsIEVUSF9BTEVOKTsKKwl9CisjZW5kaWYgLyogZGVmaW5lZChfX05ldEJTRF9fKSB8fCBkZWZpbmVkKF9fT3BlbkJTRF9fKSB8fCBkZWZpbmVkKF9fQVBQTEVfXykgKi8KKworCWlmIChpb2N0bChzLCBhZGQgPyBTSU9DQURETVVMVEkgOiBTSU9DREVMTVVMVEksIChjYWRkcl90KSAmaWZyKSA8IDApIHsKKwkJcGVycm9yKCJpb2N0bFtTSU9De0FERC9ERUx9TVVMVEldIik7CisJCWNsb3NlKHMpOworCQlyZXR1cm4gLTE7CisJfQorCWNsb3NlKHMpOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyB2b2lkIF9fbWFjc2VjX2Rydl9pbml0KHN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydikKK3sKKwlpbnQgcmV0ID0gMDsKKwlmYWxfcnhfY3RsX2ZpbHRfdCByeF9jdGxfZmlsdDsKKwlmYWxfdHhfY3RsX2ZpbHRfdCB0eF9jdGxfZmlsdDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICIlczogc2VjeV9pZD0lZCIsIF9fZnVuY19fLCBkcnYtPnNlY3lfaWQpOworCisJLyogRW5hYmxlIFNlY3kgYW5kIExldCBFQVBvTCBieXBhc3MgKi8KKwlyZXQgPSBuc3NfbWFjc2VjX3NlY3lfZW5fc2V0KGRydi0+c2VjeV9pZCwgVFJVRSk7CisJaWYgKHJldCkKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJuc3NfbWFjc2VjX3NlY3lfZW5fc2V0OiBGQUlMIik7CisKKwlyZXQgPSBuc3NfbWFjc2VjX3NlY3lfc2Nfc2FfbWFwcGluZ19tb2RlX3NldChkcnYtPnNlY3lfaWQsCisJCQkJCQkgICAgIEZBTF9TQ19TQV9NQVBfMV80KTsKKwlpZiAocmV0KQorCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJuc3NfbWFjc2VjX3NlY3lfc2Nfc2FfbWFwcGluZ19tb2RlX3NldDogRkFJTCIpOworCisJb3NfbWVtc2V0KCZyeF9jdGxfZmlsdCwgMCwgc2l6ZW9mKHJ4X2N0bF9maWx0KSk7CisJcnhfY3RsX2ZpbHQuYnlwYXNzID0gMTsKKwlyeF9jdGxfZmlsdC5tYXRjaF90eXBlID0gSUdfQ1RMX0NPTVBBUkVfRVRIRVJfVFlQRTsKKwlyeF9jdGxfZmlsdC5tYXRjaF9tYXNrID0gMHhmZmZmOworCXJ4X2N0bF9maWx0LmV0aGVyX3R5cGVfZGFfcmFuZ2UgPSAweDg4OGU7CisJcmV0ID0gbnNzX21hY3NlY19zZWN5X3J4X2N0bF9maWx0X3NldChkcnYtPnNlY3lfaWQsIDAsICZyeF9jdGxfZmlsdCk7CisJaWYgKHJldCkKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJuc3NfbWFjc2VjX3NlY3lfcnhfY3RsX2ZpbHRfc2V0OiBGQUlMIik7CisKKwlvc19tZW1zZXQoJnR4X2N0bF9maWx0LCAwLCBzaXplb2YodHhfY3RsX2ZpbHQpKTsKKwl0eF9jdGxfZmlsdC5ieXBhc3MgPSAxOworCXR4X2N0bF9maWx0Lm1hdGNoX3R5cGUgPSBFR19DVExfQ09NUEFSRV9FVEhFUl9UWVBFOworCXR4X2N0bF9maWx0Lm1hdGNoX21hc2sgPSAweGZmZmY7CisJdHhfY3RsX2ZpbHQuZXRoZXJfdHlwZV9kYV9yYW5nZSA9IDB4ODg4ZTsKKwlyZXQgPSBuc3NfbWFjc2VjX3NlY3lfdHhfY3RsX2ZpbHRfc2V0KGRydi0+c2VjeV9pZCwgMCwgJnR4X2N0bF9maWx0KTsKKwlpZiAocmV0KQorCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIm5zc19tYWNzZWNfc2VjeV90eF9jdGxfZmlsdF9zZXQ6IEZBSUwiKTsKK30KKworCitzdGF0aWMgdm9pZCBfX21hY3NlY19kcnZfZGVpbml0KHN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydikKK3sKKwluc3NfbWFjc2VjX3NlY3lfZW5fc2V0KGRydi0+c2VjeV9pZCwgRkFMU0UpOworCW5zc19tYWNzZWNfc2VjeV9yeF9zY19kZWxfYWxsKGRydi0+c2VjeV9pZCk7CisJbnNzX21hY3NlY19zZWN5X3R4X3NjX2RlbF9hbGwoZHJ2LT5zZWN5X2lkKTsKK30KKworCitzdGF0aWMgdm9pZCAqIG1hY3NlY19xY2FfaW5pdCh2b2lkICpjdHgsIGNvbnN0IGNoYXIgKmlmbmFtZSkKK3sKKwlzdHJ1Y3QgbWFjc2VjX3FjYV9kYXRhICpkcnY7CisJaW50IGZsYWdzOworCisJZHJ2ID0gb3NfemFsbG9jKHNpemVvZigqZHJ2KSk7CisJaWYgKGRydiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlvc19zdHJsY3B5KGRydi0+aWZuYW1lLCBpZm5hbWUsIHNpemVvZihkcnYtPmlmbmFtZSkpOworCWRydi0+Y3R4ID0gY3R4OworCisJLyogQm9hcmQgc3BlY2lmaWMgc2V0dGluZ3MgKi8KKwlpZiAob3NfbWVtY21wKCJldGgyIiwgZHJ2LT5pZm5hbWUsIDQpID09IDApCisJCWRydi0+c2VjeV9pZCA9IDE7CisJZWxzZSBpZiAob3NfbWVtY21wKCJldGgzIiwgZHJ2LT5pZm5hbWUsIDQpID09IDApCisJCWRydi0+c2VjeV9pZCA9IDI7CisJZWxzZQorCQlkcnYtPnNlY3lfaWQgPSAtMTsKKworI2lmZGVmIF9fbGludXhfXworCWRydi0+cGZfc29jayA9IHNvY2tldChQRl9QQUNLRVQsIFNPQ0tfREdSQU0sIDApOworCWlmIChkcnYtPnBmX3NvY2sgPCAwKQorCQlwZXJyb3IoInNvY2tldChQRl9QQUNLRVQpIik7CisjZWxzZSAvKiBfX2xpbnV4X18gKi8KKwlkcnYtPnBmX3NvY2sgPSAtMTsKKyNlbmRpZiAvKiBfX2xpbnV4X18gKi8KKworCWlmIChtYWNzZWNfcWNhX2dldF9pZmZsYWdzKGlmbmFtZSwgJmZsYWdzKSA9PSAwICYmCisJICAgICEoZmxhZ3MgJiBJRkZfVVApICYmCisJICAgIG1hY3NlY19xY2Ffc2V0X2lmZmxhZ3MoaWZuYW1lLCBmbGFncyB8IElGRl9VUCkgPT0gMCkgeworCQlkcnYtPmlmZl91cCA9IDE7CisJfQorCisJaWYgKG1hY3NlY19xY2FfbXVsdGljYXN0X21lbWJlcnNoaXAoZHJ2LT5wZl9zb2NrLAorCQkJCQkgICAgaWZfbmFtZXRvaW5kZXgoZHJ2LT5pZm5hbWUpLAorCQkJCQkgICAgcGFlX2dyb3VwX2FkZHIsIDEpID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAiJXM6IEFkZGVkIG11bHRpY2FzdCBtZW1iZXJzaGlwIHdpdGggcGFja2V0IHNvY2tldCIsCisJCQkgICBfX2Z1bmNfXyk7CisJCWRydi0+bWVtYmVyc2hpcCA9IDE7CisJfSBlbHNlIGlmIChtYWNzZWNfcWNhX211bHRpKGlmbmFtZSwgcGFlX2dyb3VwX2FkZHIsIDEpID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAiJXM6IEFkZGVkIG11bHRpY2FzdCBtZW1iZXJzaGlwIHdpdGggU0lPQ0FERE1VTFRJIiwKKwkJCSAgIF9fZnVuY19fKTsKKwkJZHJ2LT5tdWx0aSA9IDE7CisJfSBlbHNlIGlmIChtYWNzZWNfcWNhX2dldF9pZmZsYWdzKGlmbmFtZSwgJmZsYWdzKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIiVzOiBDb3VsZCBub3QgZ2V0IGludGVyZmFjZSBmbGFncyIsCisJCQkgICBfX2Z1bmNfXyk7CisJCW9zX2ZyZWUoZHJ2KTsKKwkJcmV0dXJuIE5VTEw7CisJfSBlbHNlIGlmIChmbGFncyAmIElGRl9BTExNVUxUSSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICIlczogSW50ZXJmYWNlIGlzIGFscmVhZHkgY29uZmlndXJlZCBmb3IgbXVsdGljYXN0IiwKKwkJCSAgIF9fZnVuY19fKTsKKwl9IGVsc2UgaWYgKG1hY3NlY19xY2Ffc2V0X2lmZmxhZ3MoaWZuYW1lLCBmbGFncyB8IElGRl9BTExNVUxUSSkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICIlczogRmFpbGVkIHRvIGVuYWJsZSBhbGxtdWx0aSIsCisJCQkgICBfX2Z1bmNfXyk7CisJCW9zX2ZyZWUoZHJ2KTsKKwkJcmV0dXJuIE5VTEw7CisJfSBlbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogRW5hYmxlZCBhbGxtdWx0aSBtb2RlIiwgX19mdW5jX18pOworCQlkcnYtPmlmZl9hbGxtdWx0aSA9IDE7CisJfQorI2lmIGRlZmluZWQoX19GcmVlQlNEX18pIHx8IGRlZmluZWQoX19EcmFnb25GbHlfXykgfHwgZGVmaW5lZChfX0ZyZWVCU0Rfa2VybmVsX18pCisJeworCQlpbnQgc3RhdHVzOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiB3YWl0aW5nIGZvciBsaW5rIHRvIGJlY29tZSBhY3RpdmUiLAorCQkJICAgX19mdW5jX18pOworCQl3aGlsZSAobWFjc2VjX3FjYV9nZXRfaWZzdGF0dXMoaWZuYW1lLCAmc3RhdHVzKSA9PSAwICYmCisJCSAgICAgICBzdGF0dXMgPT0gMCkKKwkJCXNsZWVwKDEpOworCX0KKyNlbmRpZiAvKiBkZWZpbmVkKF9fRnJlZUJTRF9fKSB8fCBkZWZpbmVkKF9fRHJhZ29uRmx5X18pIHx8IGRlZmluZWQoRnJlZUJTRF9rZXJuZWxfXykgKi8KKworCXJldHVybiBkcnY7Cit9CisKKworc3RhdGljIHZvaWQgbWFjc2VjX3FjYV9kZWluaXQodm9pZCAqcHJpdikKK3sKKwlzdHJ1Y3QgbWFjc2VjX3FjYV9kYXRhICpkcnYgPSBwcml2OworCWludCBmbGFnczsKKworCWlmIChkcnYtPm1lbWJlcnNoaXAgJiYKKwkgICAgbWFjc2VjX3FjYV9tdWx0aWNhc3RfbWVtYmVyc2hpcChkcnYtPnBmX3NvY2ssCisJCQkJCSAgICBpZl9uYW1ldG9pbmRleChkcnYtPmlmbmFtZSksCisJCQkJCSAgICBwYWVfZ3JvdXBfYWRkciwgMCkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJICAgIiVzOiBGYWlsZWQgdG8gcmVtb3ZlIFBBRSBtdWx0aWNhc3QgZ3JvdXAgKFBBQ0tFVCkiLAorCQkJICAgX19mdW5jX18pOworCX0KKworCWlmIChkcnYtPm11bHRpICYmCisJICAgIG1hY3NlY19xY2FfbXVsdGkoZHJ2LT5pZm5hbWUsIHBhZV9ncm91cF9hZGRyLCAwKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAiJXM6IEZhaWxlZCB0byByZW1vdmUgUEFFIG11bHRpY2FzdCBncm91cCAoU0lPQ0RFTE1VTFRJKSIsCisJCQkgICBfX2Z1bmNfXyk7CisJfQorCisJaWYgKGRydi0+aWZmX2FsbG11bHRpICYmCisJICAgIChtYWNzZWNfcWNhX2dldF9pZmZsYWdzKGRydi0+aWZuYW1lLCAmZmxhZ3MpIDwgMCB8fAorCSAgICAgbWFjc2VjX3FjYV9zZXRfaWZmbGFncyhkcnYtPmlmbmFtZSwgZmxhZ3MgJiB+SUZGX0FMTE1VTFRJKSA8IDApKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IEZhaWxlZCB0byBkaXNhYmxlIGFsbG11bHRpIG1vZGUiLAorCQkJICAgX19mdW5jX18pOworCX0KKworCWlmIChkcnYtPmlmZl91cCAmJgorCSAgICBtYWNzZWNfcWNhX2dldF9pZmZsYWdzKGRydi0+aWZuYW1lLCAmZmxhZ3MpID09IDAgJiYKKwkgICAgKGZsYWdzICYgSUZGX1VQKSAmJgorCSAgICBtYWNzZWNfcWNhX3NldF9pZmZsYWdzKGRydi0+aWZuYW1lLCBmbGFncyAmIH5JRkZfVVApIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBGYWlsZWQgdG8gc2V0IHRoZSBpbnRlcmZhY2UgZG93biIsCisJCQkgICBfX2Z1bmNfXyk7CisJfQorCisJaWYgKGRydi0+cGZfc29jayAhPSAtMSkKKwkJY2xvc2UoZHJ2LT5wZl9zb2NrKTsKKworCW9zX2ZyZWUoZHJ2KTsKK30KKworCitzdGF0aWMgaW50IG1hY3NlY19xY2FfbWFjc2VjX2luaXQodm9pZCAqcHJpdiwgc3RydWN0IG1hY3NlY19pbml0X3BhcmFtcyAqcGFyYW1zKQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisKKwlkcnYtPmFsd2F5c19pbmNsdWRlX3NjaSA9IHBhcmFtcy0+YWx3YXlzX2luY2x1ZGVfc2NpOworCWRydi0+dXNlX2VzID0gcGFyYW1zLT51c2VfZXM7CisJZHJ2LT51c2Vfc2NiID0gcGFyYW1zLT51c2Vfc2NiOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogZXM9JWQsIHNjYj0lZCwgc2NpPSVkIiwKKwkJICAgX19mdW5jX18sIGRydi0+dXNlX2VzLCBkcnYtPnVzZV9zY2IsCisJCSAgIGRydi0+YWx3YXlzX2luY2x1ZGVfc2NpKTsKKworCV9fbWFjc2VjX2Rydl9pbml0KGRydik7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IG1hY3NlY19xY2FfbWFjc2VjX2RlaW5pdCh2b2lkICpwcml2KQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIiwgX19mdW5jX18pOworCisJX19tYWNzZWNfZHJ2X2RlaW5pdChkcnYpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2VuYWJsZV9wcm90ZWN0X2ZyYW1lcyh2b2lkICpwcml2LCBCb29sZWFuIGVuYWJsZWQpCit7CisJc3RydWN0IG1hY3NlY19xY2FfZGF0YSAqZHJ2ID0gcHJpdjsKKwlpbnQgcmV0ID0gMDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGVuYWJsZWQ9JWQiLCBfX2Z1bmNfXywgZW5hYmxlZCk7CisKKwlkcnYtPnByb3RlY3RfZnJhbWVzID0gZW5hYmxlZDsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX3NldF9yZXBsYXlfcHJvdGVjdCh2b2lkICpwcml2LCBCb29sZWFuIGVuYWJsZWQsCisJCQkJCSB1bnNpZ25lZCBpbnQgd2luZG93KQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBlbmFibGVkPSVkLCB3aW49JXUiLAorCQkgICBfX2Z1bmNfXywgZW5hYmxlZCwgd2luZG93KTsKKworCWRydi0+cmVwbGF5X3Byb3RlY3QgPSBlbmFibGVkOworCWRydi0+cmVwbGF5X3dpbmRvdyA9IHdpbmRvdzsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX3NldF9jdXJyZW50X2NpcGhlcl9zdWl0ZSh2b2lkICpwcml2LCBjb25zdCB1OCAqY3MsCisJCQkJCSAgICAgICBzaXplX3QgY3NfbGVuKQoreworCXU4IGRlZmF1bHRfY3NfaWRbXSA9IENTX0lEX0dDTV9BRVNfMTI4OworCisJaWYgKGNzX2xlbiAhPSBDU19JRF9MRU4gfHwKKwkgICAgb3NfbWVtY21wKGNzLCBkZWZhdWx0X2NzX2lkLCBjc19sZW4pICE9IDApIHsKKwkJd3BhX2hleGR1bXAoTVNHX0VSUk9SLCAibWFjc2VjOiBOT1Qgc3VwcG9ydGVkIENpcGhlclN1aXRlIiwKKwkJCSAgICBjcywgY3NfbGVuKTsKKwkJcmV0dXJuIC0xOworCX0KKworCS8qIFN1cHBvcnQgZGVmYXVsdCBDaXBoZXIgU3VpdGUgMDA4MDAyMDAwMTAwMDAwMSAoR0NNLUFFUy0xMjgpICovCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogZGVmYXVsdCBzdXBwb3J0IGFlcy1nY20tMTI4IiwgX19mdW5jX18pOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2VuYWJsZV9jb250cm9sbGVkX3BvcnQodm9pZCAqcHJpdiwgQm9vbGVhbiBlbmFibGVkKQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBlbmFibGU9JWQiLCBfX2Z1bmNfXywgZW5hYmxlZCk7CisKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X2NvbnRyb2xsZWRfcG9ydF9lbl9zZXQoZHJ2LT5zZWN5X2lkLCBlbmFibGVkKTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2dldF9yZWNlaXZlX2xvd2VzdF9wbih2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJCSAgICB1MzIgKmxvd2VzdF9wbikKK3sKKwlzdHJ1Y3QgbWFjc2VjX3FjYV9kYXRhICpkcnYgPSBwcml2OworCWludCByZXQgPSAwOworCXUzMiBuZXh0X3BuID0gMDsKKwlib29sIGVuYWJsZWQgPSBGQUxTRTsKKwl1MzIgd2luOworCisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV9yeF9zYV9uZXh0X3BuX2dldChkcnYtPnNlY3lfaWQsIGNoYW5uZWwsIGFuLAorCQkJCQkJICZuZXh0X3BuKTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3J4X3NjX3JlcGxheV9wcm90ZWN0X2dldChkcnYtPnNlY3lfaWQsIGNoYW5uZWwsCisJCQkJCQkJJmVuYWJsZWQpOworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfcnhfc2NfYW50aV9yZXBsYXlfd2luZG93X2dldChkcnYtPnNlY3lfaWQsCisJCQkJCQkJICAgIGNoYW5uZWwsICZ3aW4pOworCisJaWYgKGVuYWJsZWQpCisJCSpsb3dlc3RfcG4gPSAobmV4dF9wbiA+IHdpbikgPyAobmV4dF9wbiAtIHdpbikgOiAxOworCWVsc2UKKwkJKmxvd2VzdF9wbiA9IG5leHRfcG47CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBscG49MHgleCIsIF9fZnVuY19fLCAqbG93ZXN0X3BuKTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2dldF90cmFuc21pdF9uZXh0X3BuKHZvaWQgKnByaXYsIHUzMiBjaGFubmVsLCB1OCBhbiwKKwkJCQkJICAgdTMyICpuZXh0X3BuKQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3R4X3NhX25leHRfcG5fZ2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgYW4sCisJCQkJCQkgbmV4dF9wbik7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBucG49MHgleCIsIF9fZnVuY19fLCAqbmV4dF9wbik7CisKKwlyZXR1cm4gcmV0OworfQorCisKK2ludCBtYWNzZWNfcWNhX3NldF90cmFuc21pdF9uZXh0X3BuKHZvaWQgKnByaXYsIHUzMiBjaGFubmVsLCB1OCBhbiwgdTMyIG5leHRfcG4pCit7CisJc3RydWN0IG1hY3NlY19xY2FfZGF0YSAqZHJ2ID0gcHJpdjsKKwlpbnQgcmV0ID0gMDsKKworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfdHhfc2FfbmV4dF9wbl9zZXQoZHJ2LT5zZWN5X2lkLCBjaGFubmVsLCBhbiwKKwkJCQkJCSBuZXh0X3BuKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICIlczogbnBuPTB4JXgiLCBfX2Z1bmNfXywgbmV4dF9wbik7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgbWFjc2VjX3FjYV9nZXRfYXZhaWxhYmxlX3JlY2VpdmVfc2Modm9pZCAqcHJpdiwgdTMyICpjaGFubmVsKQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisJdTMyIHNjX2NoID0gMDsKKwlib29sIGluX3VzZSA9IEZBTFNFOworCisJZm9yIChzY19jaCA9IDA7IHNjX2NoIDwgTUFYU0M7IHNjX2NoKyspIHsKKwkJcmV0ID0gbnNzX21hY3NlY19zZWN5X3J4X3NjX2luX3VzZWRfZ2V0KGRydi0+c2VjeV9pZCwgc2NfY2gsCisJCQkJCQkJJmluX3VzZSk7CisJCWlmIChyZXQpCisJCQljb250aW51ZTsKKworCQlpZiAoIWluX3VzZSkgeworCQkJKmNoYW5uZWwgPSBzY19jaDsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGNoYW5uZWw9JWQiLAorCQkJCSAgIF9fZnVuY19fLCAqY2hhbm5lbCk7CisJCQlyZXR1cm4gMDsKKwkJfQorCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IG5vIGF2YWlsYWJsZSBjaGFubmVsIiwgX19mdW5jX18pOworCisJcmV0dXJuIC0xOworfQorCisKK3N0YXRpYyBpbnQgbWFjc2VjX3FjYV9jcmVhdGVfcmVjZWl2ZV9zYyh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwKKwkJCQkJY29uc3QgdTggKnNjaV9hZGRyLCB1MTYgc2NpX3BvcnQsCisJCQkJCXVuc2lnbmVkIGludCBjb25mX29mZnNldCwKKwkJCQkJaW50IHZhbGlkYXRpb24pCit7CisJc3RydWN0IG1hY3NlY19xY2FfZGF0YSAqZHJ2ID0gcHJpdjsKKwlpbnQgcmV0ID0gMDsKKwlmYWxfcnhfcHJjX2x1dF90IGVudHJ5OworCWZhbF9yeF9zY192YWxpZGF0ZV9mcmFtZV9lIHZmOworCWVudW0gdmFsaWRhdGVfZnJhbWVzIHZhbGlkYXRlX2ZyYW1lcyA9IHZhbGlkYXRpb247CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBjaGFubmVsPSVkIiwgX19mdW5jX18sIGNoYW5uZWwpOworCisJLyogcnggcHJjIGx1dCAqLworCW9zX21lbXNldCgmZW50cnksIDAsIHNpemVvZihlbnRyeSkpOworCisJb3NfbWVtY3B5KGVudHJ5LnNjaSwgc2NpX2FkZHIsIEVUSF9BTEVOKTsKKwllbnRyeS5zY2lbNl0gPSAoc2NpX3BvcnQgPj4gOCkgJiAweGY7CisJZW50cnkuc2NpWzddID0gc2NpX3BvcnQgJiAweGY7CisJZW50cnkuc2NpX21hc2sgPSAweGY7CisKKwllbnRyeS52YWxpZCA9IDE7CisJZW50cnkuY2hhbm5lbCA9IGNoYW5uZWw7CisJZW50cnkuYWN0aW9uID0gRkFMX1JYX1BSQ19BQ1RJT05fUFJPQ0VTUzsKKwllbnRyeS5vZmZzZXQgPSBjb25mX29mZnNldDsKKworCS8qIHJ4IHZhbGlkYXRlIGZyYW1lICAqLworCWlmICh2YWxpZGF0ZV9mcmFtZXMgPT0gU3RyaWN0KQorCQl2ZiA9IEZBTF9SWF9TQ19WQUxJREFURV9GUkFNRV9TVFJJQ1Q7CisJZWxzZSBpZiAodmFsaWRhdGVfZnJhbWVzID09IENoZWNrZWQpCisJCXZmID0gRkFMX1JYX1NDX1ZBTElEQVRFX0ZSQU1FX0NIRUNLOworCWVsc2UKKwkJdmYgPSBGQUxfUlhfU0NfVkFMSURBVEVfRlJBTUVfRElTQUJMRUQ7CisKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3J4X3ByY19sdXRfc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgJmVudHJ5KTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3J4X3NjX2NyZWF0ZShkcnYtPnNlY3lfaWQsIGNoYW5uZWwpOworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfcnhfc2NfdmFsaWRhdGVfZnJhbWVfc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwKKwkJCQkJCQl2Zik7CisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV9yeF9zY19yZXBsYXlfcHJvdGVjdF9zZXQoZHJ2LT5zZWN5X2lkLCBjaGFubmVsLAorCQkJCQkJCWRydi0+cmVwbGF5X3Byb3RlY3QpOworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfcnhfc2NfYW50aV9yZXBsYXlfd2luZG93X3NldChkcnYtPnNlY3lfaWQsCisJCQkJCQkJICAgIGNoYW5uZWwsCisJCQkJCQkJICAgIGRydi0+cmVwbGF5X3dpbmRvdyk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgbWFjc2VjX3FjYV9kZWxldGVfcmVjZWl2ZV9zYyh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCkKK3sKKwlzdHJ1Y3QgbWFjc2VjX3FjYV9kYXRhICpkcnYgPSBwcml2OworCWludCByZXQgPSAwOworCWZhbF9yeF9wcmNfbHV0X3QgZW50cnk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBjaGFubmVsPSVkIiwgX19mdW5jX18sIGNoYW5uZWwpOworCisJLyogcnggcHJjIGx1dCAqLworCW9zX21lbXNldCgmZW50cnksIDAsIHNpemVvZihlbnRyeSkpOworCisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV9yeF9zY19kZWwoZHJ2LT5zZWN5X2lkLCBjaGFubmVsKTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3J4X3ByY19sdXRfc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgJmVudHJ5KTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2NyZWF0ZV9yZWNlaXZlX3NhKHZvaWQgKnByaXYsIHUzMiBjaGFubmVsLCB1OCBhbiwKKwkJCQkJdTMyIGxvd2VzdF9wbiwgY29uc3QgdTggKnNhaykKK3sKKwlzdHJ1Y3QgbWFjc2VjX3FjYV9kYXRhICpkcnYgPSBwcml2OworCWludCByZXQgPSAwOworCWZhbF9yeF9zYWtfdCByeF9zYWs7CisJaW50IGkgPSAwOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcywgY2hhbm5lbD0lZCwgYW49JWQsIGxwbj0weCV4IiwKKwkJICAgX19mdW5jX18sIGNoYW5uZWwsIGFuLCBsb3dlc3RfcG4pOworCisJb3NfbWVtc2V0KCZyeF9zYWssIDAsIHNpemVvZihyeF9zYWspKTsKKwlmb3IgKGkgPSAwOyBpIDwgMTY7IGkrKykKKwkJcnhfc2FrLnNha1tpXSA9IHNha1sxNSAtIGldOworCisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV9yeF9zYV9jcmVhdGUoZHJ2LT5zZWN5X2lkLCBjaGFubmVsLCBhbik7CisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV9yeF9zYWtfc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgYW4sICZyeF9zYWspOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IG1hY3NlY19xY2FfZW5hYmxlX3JlY2VpdmVfc2Eodm9pZCAqcHJpdiwgdTMyIGNoYW5uZWwsIHU4IGFuKQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBjaGFubmVsPSVkLCBhbj0lZCIsIF9fZnVuY19fLCBjaGFubmVsLCBhbik7CisKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3J4X3NhX2VuX3NldChkcnYtPnNlY3lfaWQsIGNoYW5uZWwsIGFuLCBUUlVFKTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2Rpc2FibGVfcmVjZWl2ZV9zYSh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwgdTggYW4pCit7CisJc3RydWN0IG1hY3NlY19xY2FfZGF0YSAqZHJ2ID0gcHJpdjsKKwlpbnQgcmV0ID0gMDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGNoYW5uZWw9JWQsIGFuPSVkIiwgX19mdW5jX18sIGNoYW5uZWwsIGFuKTsKKworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfcnhfc2FfZW5fc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgYW4sIEZBTFNFKTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2dldF9hdmFpbGFibGVfdHJhbnNtaXRfc2Modm9pZCAqcHJpdiwgdTMyICpjaGFubmVsKQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisJdTMyIHNjX2NoID0gMDsKKwlib29sIGluX3VzZSA9IEZBTFNFOworCisJZm9yIChzY19jaCA9IDA7IHNjX2NoIDwgTUFYU0M7IHNjX2NoKyspIHsKKwkJcmV0ID0gbnNzX21hY3NlY19zZWN5X3R4X3NjX2luX3VzZWRfZ2V0KGRydi0+c2VjeV9pZCwgc2NfY2gsCisJCQkJCQkJJmluX3VzZSk7CisJCWlmIChyZXQpCisJCQljb250aW51ZTsKKworCQlpZiAoIWluX3VzZSkgeworCQkJKmNoYW5uZWwgPSBzY19jaDsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGNoYW5uZWw9JWQiLAorCQkJCSAgIF9fZnVuY19fLCAqY2hhbm5lbCk7CisJCQlyZXR1cm4gMDsKKwkJfQorCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IG5vIGF2YWlhYmxlIGNoYW5uZWwiLCBfX2Z1bmNfXyk7CisKKwlyZXR1cm4gLTE7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2NyZWF0ZV90cmFuc21pdF9zYyh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwKKwkJCQkJIGNvbnN0IHU4ICpzY2lfYWRkciwgdTE2IHNjaV9wb3J0LAorCQkJCQkgdW5zaWduZWQgaW50IGNvbmZfb2Zmc2V0KQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisJZmFsX3R4X2NsYXNzX2x1dF90IGVudHJ5OworCXU4IHBzY2lbRVRIX0FMRU4gKyAyXTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGNoYW5uZWw9JWQiLCBfX2Z1bmNfXywgY2hhbm5lbCk7CisKKwkvKiBjbGFzcyBsdXQgKi8KKwlvc19tZW1zZXQoJmVudHJ5LCAwLCBzaXplb2YoZW50cnkpKTsKKworCWVudHJ5LnZhbGlkID0gMTsKKwllbnRyeS5hY3Rpb24gPSBGQUxfVFhfQ0xBU1NfQUNUSU9OX0ZPUldBUkQ7CisJZW50cnkuY2hhbm5lbCA9IGNoYW5uZWw7CisKKwlvc19tZW1jcHkocHNjaSwgc2NpX2FkZHIsIEVUSF9BTEVOKTsKKwlwc2NpWzZdID0gKHNjaV9wb3J0ID4+IDgpICYgMHhmOworCXBzY2lbN10gPSBzY2lfcG9ydCAmIDB4ZjsKKworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfdHhfY2xhc3NfbHV0X3NldChkcnYtPnNlY3lfaWQsIGNoYW5uZWwsICZlbnRyeSk7CisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV90eF9zY19jcmVhdGUoZHJ2LT5zZWN5X2lkLCBjaGFubmVsLCBwc2NpLCA4KTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3R4X3NjX3Byb3RlY3Rfc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwKKwkJCQkJCSBkcnYtPnByb3RlY3RfZnJhbWVzKTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3R4X3NjX2NvbmZpZGVudGlhbGl0eV9vZmZzZXRfc2V0KGRydi0+c2VjeV9pZCwKKwkJCQkJCQkJY2hhbm5lbCwKKwkJCQkJCQkJY29uZl9vZmZzZXQpOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IG1hY3NlY19xY2FfZGVsZXRlX3RyYW5zbWl0X3NjKHZvaWQgKnByaXYsIHUzMiBjaGFubmVsKQoreworCXN0cnVjdCBtYWNzZWNfcWNhX2RhdGEgKmRydiA9IHByaXY7CisJaW50IHJldCA9IDA7CisJZmFsX3R4X2NsYXNzX2x1dF90IGVudHJ5OworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogY2hhbm5lbD0lZCIsIF9fZnVuY19fLCBjaGFubmVsKTsKKworCS8qIGNsYXNzIGx1dCAqLworCW9zX21lbXNldCgmZW50cnksIDAsIHNpemVvZihlbnRyeSkpOworCisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV90eF9jbGFzc19sdXRfc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgJmVudHJ5KTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3R4X3NjX2RlbChkcnYtPnNlY3lfaWQsIGNoYW5uZWwpOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IG1hY3NlY19xY2FfY3JlYXRlX3RyYW5zbWl0X3NhKHZvaWQgKnByaXYsIHUzMiBjaGFubmVsLCB1OCBhbiwKKwkJCQkJIHUzMiBuZXh0X3BuLCBCb29sZWFuIGNvbmZpZGVudGlhbGl0eSwKKwkJCQkJIGNvbnN0IHU4ICpzYWspCit7CisJc3RydWN0IG1hY3NlY19xY2FfZGF0YSAqZHJ2ID0gcHJpdjsKKwlpbnQgcmV0ID0gMDsKKwl1OCB0Y2kgPSAwOworCWZhbF90eF9zYWtfdCB0eF9zYWs7CisJaW50IGk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIiVzOiBjaGFubmVsPSVkLCBhbj0lZCwgbmV4dF9wbj0weCV4LCBjb25maWRlbnRpYWxpdHk9JWQiLAorCQkgICBfX2Z1bmNfXywgY2hhbm5lbCwgYW4sIG5leHRfcG4sIGNvbmZpZGVudGlhbGl0eSk7CisKKwlpZiAoZHJ2LT5hbHdheXNfaW5jbHVkZV9zY2kpCisJCXRjaSB8PSBUQ0lfU0M7CisJZWxzZSBpZiAoZHJ2LT51c2VfZXMpCisJCXRjaSB8PSBUQ0lfRVM7CisJZWxzZSBpZiAoZHJ2LT51c2Vfc2NiKQorCQl0Y2kgfD0gVENJX1NDQjsKKworCWlmIChjb25maWRlbnRpYWxpdHkpCisJCXRjaSB8PSBUQ0lfRSB8IFRDSV9DOworCisJb3NfbWVtc2V0KCZ0eF9zYWssIDAsIHNpemVvZih0eF9zYWspKTsKKwlmb3IgKGkgPSAwOyBpIDwgMTY7IGkrKykKKwkJdHhfc2FrLnNha1tpXSA9IHNha1sxNSAtIGldOworCisJcmV0ICs9IG5zc19tYWNzZWNfc2VjeV90eF9zYV9uZXh0X3BuX3NldChkcnYtPnNlY3lfaWQsIGNoYW5uZWwsIGFuLAorCQkJCQkJIG5leHRfcG4pOworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfdHhfc2FrX3NldChkcnYtPnNlY3lfaWQsIGNoYW5uZWwsIGFuLCAmdHhfc2FrKTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3R4X3NjX3RjaV83XzJfc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwKKwkJCQkJCSAodGNpID4+IDIpKTsKKwlyZXQgKz0gbnNzX21hY3NlY19zZWN5X3R4X3NjX2FuX3NldChkcnYtPnNlY3lfaWQsIGNoYW5uZWwsIGFuKTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBtYWNzZWNfcWNhX2VuYWJsZV90cmFuc21pdF9zYSh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwgdTggYW4pCit7CisJc3RydWN0IG1hY3NlY19xY2FfZGF0YSAqZHJ2ID0gcHJpdjsKKwlpbnQgcmV0ID0gMDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGNoYW5uZWw9JWQsIGFuPSVkIiwgX19mdW5jX18sIGNoYW5uZWwsIGFuKTsKKworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfdHhfc2FfZW5fc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgYW4sIFRSVUUpOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IG1hY3NlY19xY2FfZGlzYWJsZV90cmFuc21pdF9zYSh2b2lkICpwcml2LCB1MzIgY2hhbm5lbCwgdTggYW4pCit7CisJc3RydWN0IG1hY3NlY19xY2FfZGF0YSAqZHJ2ID0gcHJpdjsKKwlpbnQgcmV0ID0gMDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGNoYW5uZWw9JWQsIGFuPSVkIiwgX19mdW5jX18sIGNoYW5uZWwsIGFuKTsKKworCXJldCArPSBuc3NfbWFjc2VjX3NlY3lfdHhfc2FfZW5fc2V0KGRydi0+c2VjeV9pZCwgY2hhbm5lbCwgYW4sIEZBTFNFKTsKKworCXJldHVybiByZXQ7Cit9CisKKworY29uc3Qgc3RydWN0IHdwYV9kcml2ZXJfb3BzIHdwYV9kcml2ZXJfbWFjc2VjX3FjYV9vcHMgPSB7CisJLm5hbWUgPSAibWFjc2VjX3FjYSIsCisJLmRlc2MgPSAiUUNBIE1BQ3NlYyBFdGhlcm5ldCBkcml2ZXIiLAorCS5nZXRfc3NpZCA9IG1hY3NlY19xY2FfZ2V0X3NzaWQsCisJLmdldF9ic3NpZCA9IG1hY3NlY19xY2FfZ2V0X2Jzc2lkLAorCS5nZXRfY2FwYSA9IG1hY3NlY19xY2FfZ2V0X2NhcGEsCisJLmluaXQgPSBtYWNzZWNfcWNhX2luaXQsCisJLmRlaW5pdCA9IG1hY3NlY19xY2FfZGVpbml0LAorCisJLm1hY3NlY19pbml0ID0gbWFjc2VjX3FjYV9tYWNzZWNfaW5pdCwKKwkubWFjc2VjX2RlaW5pdCA9IG1hY3NlY19xY2FfbWFjc2VjX2RlaW5pdCwKKwkuZW5hYmxlX3Byb3RlY3RfZnJhbWVzID0gbWFjc2VjX3FjYV9lbmFibGVfcHJvdGVjdF9mcmFtZXMsCisJLnNldF9yZXBsYXlfcHJvdGVjdCA9IG1hY3NlY19xY2Ffc2V0X3JlcGxheV9wcm90ZWN0LAorCS5zZXRfY3VycmVudF9jaXBoZXJfc3VpdGUgPSBtYWNzZWNfcWNhX3NldF9jdXJyZW50X2NpcGhlcl9zdWl0ZSwKKwkuZW5hYmxlX2NvbnRyb2xsZWRfcG9ydCA9IG1hY3NlY19xY2FfZW5hYmxlX2NvbnRyb2xsZWRfcG9ydCwKKwkuZ2V0X3JlY2VpdmVfbG93ZXN0X3BuID0gbWFjc2VjX3FjYV9nZXRfcmVjZWl2ZV9sb3dlc3RfcG4sCisJLmdldF90cmFuc21pdF9uZXh0X3BuID0gbWFjc2VjX3FjYV9nZXRfdHJhbnNtaXRfbmV4dF9wbiwKKwkuc2V0X3RyYW5zbWl0X25leHRfcG4gPSBtYWNzZWNfcWNhX3NldF90cmFuc21pdF9uZXh0X3BuLAorCS5nZXRfYXZhaWxhYmxlX3JlY2VpdmVfc2MgPSBtYWNzZWNfcWNhX2dldF9hdmFpbGFibGVfcmVjZWl2ZV9zYywKKwkuY3JlYXRlX3JlY2VpdmVfc2MgPSBtYWNzZWNfcWNhX2NyZWF0ZV9yZWNlaXZlX3NjLAorCS5kZWxldGVfcmVjZWl2ZV9zYyA9IG1hY3NlY19xY2FfZGVsZXRlX3JlY2VpdmVfc2MsCisJLmNyZWF0ZV9yZWNlaXZlX3NhID0gbWFjc2VjX3FjYV9jcmVhdGVfcmVjZWl2ZV9zYSwKKwkuZW5hYmxlX3JlY2VpdmVfc2EgPSBtYWNzZWNfcWNhX2VuYWJsZV9yZWNlaXZlX3NhLAorCS5kaXNhYmxlX3JlY2VpdmVfc2EgPSBtYWNzZWNfcWNhX2Rpc2FibGVfcmVjZWl2ZV9zYSwKKwkuZ2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYyA9IG1hY3NlY19xY2FfZ2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYywKKwkuY3JlYXRlX3RyYW5zbWl0X3NjID0gbWFjc2VjX3FjYV9jcmVhdGVfdHJhbnNtaXRfc2MsCisJLmRlbGV0ZV90cmFuc21pdF9zYyA9IG1hY3NlY19xY2FfZGVsZXRlX3RyYW5zbWl0X3NjLAorCS5jcmVhdGVfdHJhbnNtaXRfc2EgPSBtYWNzZWNfcWNhX2NyZWF0ZV90cmFuc21pdF9zYSwKKwkuZW5hYmxlX3RyYW5zbWl0X3NhID0gbWFjc2VjX3FjYV9lbmFibGVfdHJhbnNtaXRfc2EsCisJLmRpc2FibGVfdHJhbnNtaXRfc2EgPSBtYWNzZWNfcWNhX2Rpc2FibGVfdHJhbnNtaXRfc2EsCit9OwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX21hZHdpZmkuYyBiL3NyYy9kcml2ZXJzL2RyaXZlcl9tYWR3aWZpLmMKaW5kZXggYmI0ODAxMS4uMTYzNWMxZiAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX21hZHdpZmkuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfbWFkd2lmaS5jCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIFdQQSBTdXBwbGljYW50IC0gZHJpdmVyIGludGVyYWN0aW9uIHdpdGggTUFEV0lGSSA4MDIuMTEgZHJpdmVyCisgKiBob3N0YXBkIC0gZHJpdmVyIGludGVyYWN0aW9uIHdpdGggTUFEV0lGSSA4MDIuMTEgZHJpdmVyCiAgKiBDb3B5cmlnaHQgKGMpIDIwMDQsIFNhbSBMZWZmbGVyIDxzYW1AZXJybm8uY29tPgogICogQ29weXJpZ2h0IChjKSAyMDA0LCBWaWRlbzU0IFRlY2hub2xvZ2llcwogICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDcsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CkBAIC03LDEwICs3LDkgQEAKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKgotICogV2hpbGUgdGhpcyBkcml2ZXIgd3JhcHBlciBzdXBwb3J0cyBib3RoIEFQIChob3N0YXBkKSBhbmQgc3RhdGlvbgotICogKHdwYV9zdXBwbGljYW50KSBvcGVyYXRpb25zLCB0aGUgc3RhdGlvbiBzaWRlIGlzIGRlcHJlY2F0ZWQgYW5kCi0gKiBkcml2ZXJfd2V4dC5jIHNob3VsZCBiZSB1c2VkIGluc3RlYWQuIFRoaXMgZHJpdmVyIHdyYXBwZXIgc2hvdWxkIG9ubHkgYmUKLSAqIHVzZWQgd2l0aCBob3N0YXBkIGZvciBBUCBtb2RlIGZ1bmN0aW9uYWxpdHkuCisgKiBUaGlzIGRyaXZlciB3cmFwcGVyIGlzIG9ubHkgZm9yIGhvc3RhcGQgQVAgbW9kZSBmdW5jdGlvbmFsaXR5LiBTdGF0aW9uCisgKiAod3BhX3N1cHBsaWNhbnQpIG9wZXJhdGlvbnMgd2l0aCBtYWR3aWZpIGFyZSBzdXBwb3J0ZWQgYnkgdGhlIGRyaXZlcl93ZXh0LmMKKyAqIHdyYXBwZXIuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCkBAIC0xODIsNyArMTgxLDcgQEAKICNlbmRpZiAvKiBNQURXSUZJX05HICovCiAJCWludCBpZHggPSBvcCAtIGZpcnN0OwogCQlpZiAoZmlyc3QgPD0gb3AgJiYKLQkJICAgIGlkeCA8IChpbnQpIChzaXplb2Yob3BuYW1lcykgLyBzaXplb2Yob3BuYW1lc1swXSkpICYmCisJCSAgICBpZHggPCAoaW50KSBBUlJBWV9TSVpFKG9wbmFtZXMpICYmCiAJCSAgICBvcG5hbWVzW2lkeF0pCiAJCQlwZXJyb3Iob3BuYW1lc1tpZHhdKTsKIAkJZWxzZQpAQCAtMzIyLDE5ICszMjEsMTYgQEAKIAkJCUlFRUU4MDIxMV9BVVRIX0FVVE8pOwogCX0KIAlpZiAoIXBhcmFtcy0+d3BhICYmICFwYXJhbXMtPmllZWU4MDJfMXgpIHsKLQkJaG9zdGFwZF9sb2dnZXIoZHJ2LT5oYXBkLCBOVUxMLCBIT1NUQVBEX01PRFVMRV9EUklWRVIsCi0JCQlIT1NUQVBEX0xFVkVMX1dBUk5JTkcsICJObyA4MDIuMVggb3IgV1BBIGVuYWJsZWQhIik7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJObyA4MDIuMVggb3IgV1BBIGVuYWJsZWQhIik7CiAJCXJldHVybiAtMTsKIAl9CiAJaWYgKHBhcmFtcy0+d3BhICYmIG1hZHdpZmlfY29uZmlndXJlX3dwYShkcnYsIHBhcmFtcykgIT0gMCkgewotCQlob3N0YXBkX2xvZ2dlcihkcnYtPmhhcGQsIE5VTEwsIEhPU1RBUERfTU9EVUxFX0RSSVZFUiwKLQkJCUhPU1RBUERfTEVWRUxfV0FSTklORywgIkVycm9yIGNvbmZpZ3VyaW5nIFdQQSBzdGF0ZSEiKTsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkVycm9yIGNvbmZpZ3VyaW5nIFdQQSBzdGF0ZSEiKTsKIAkJcmV0dXJuIC0xOwogCX0KIAlpZiAoc2V0ODAyMTFwYXJhbShwcml2LCBJRUVFODAyMTFfUEFSQU1fQVVUSE1PREUsCiAJCShwYXJhbXMtPndwYSA/IElFRUU4MDIxMV9BVVRIX1dQQSA6IElFRUU4MDIxMV9BVVRIXzgwMjFYKSkpIHsKLQkJaG9zdGFwZF9sb2dnZXIoZHJ2LT5oYXBkLCBOVUxMLCBIT1NUQVBEX01PRFVMRV9EUklWRVIsCi0JCQlIT1NUQVBEX0xFVkVMX1dBUk5JTkcsICJFcnJvciBlbmFibGluZyBXUEEvODAyLjFYISIpOworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiRXJyb3IgZW5hYmxpbmcgV1BBLzgwMi4xWCEiKTsKIAkJcmV0dXJuIC0xOwogCX0KIApkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX25kaXMuYyBiL3NyYy9kcml2ZXJzL2RyaXZlcl9uZGlzLmMKaW5kZXggNDY1NmMxYi4uNDk1M2FmNiAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX25kaXMuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfbmRpcy5jCkBAIC0xMDc0LDggKzEwNzQsOCBAQAogCQkvKiBUcnkgdG8gY29udGludWUgYW55d2F5ICovCiAJfQogCi0JaWYgKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfTk9ORSB8fAotCSAgICBwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IEtFWV9NR01UXzgwMl8xWF9OT19XUEEpIHsKKwlpZiAocGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfTk9ORSB8fAorCSAgICBwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfTk9fV1BBKSB7CiAJCS8qIFJlLXNldCBXRVAga2V5cyBpZiBzdGF0aWMgV0VQIGNvbmZpZ3VyYXRpb24gaXMgdXNlZC4gKi8KIAkJaW50IGk7CiAJCWZvciAoaSA9IDA7IGkgPCA0OyBpKyspIHsKQEAgLTExMDIsMTIgKzExMDIsMTIgQEAKIAkJcHJpdl9tb2RlID0gTmRpczgwMl8xMVByaXZGaWx0ZXJBY2NlcHRBbGw7CiAJfSBlbHNlIGlmIChwYXJhbXMtPndwYV9pZVswXSA9PSBXTEFOX0VJRF9SU04pIHsKIAkJcHJpdl9tb2RlID0gTmRpczgwMl8xMVByaXZGaWx0ZXI4MDIxeFdFUDsKLQkJaWYgKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfUFNLKQorCQlpZiAocGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfUFNLKQogCQkJYXV0aF9tb2RlID0gTmRpczgwMl8xMUF1dGhNb2RlV1BBMlBTSzsKIAkJZWxzZQogCQkJYXV0aF9tb2RlID0gTmRpczgwMl8xMUF1dGhNb2RlV1BBMjsKICNpZmRlZiBDT05GSUdfV1BTCi0JfSBlbHNlIGlmIChwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IEtFWV9NR01UX1dQUykgeworCX0gZWxzZSBpZiAocGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfV1BTKSB7CiAJCWF1dGhfbW9kZSA9IE5kaXM4MDJfMTFBdXRoTW9kZU9wZW47CiAJCXByaXZfbW9kZSA9IE5kaXM4MDJfMTFQcml2RmlsdGVyQWNjZXB0QWxsOwogCQlpZiAocGFyYW1zLT53cHMgPT0gV1BTX01PREVfUFJJVkFDWSkgewpAQCAtMTEyOSwzNSArMTEyOSwzNSBAQAogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAl9IGVsc2UgewogCQlwcml2X21vZGUgPSBOZGlzODAyXzExUHJpdkZpbHRlcjgwMjF4V0VQOwotCQlpZiAocGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBLRVlfTUdNVF9XUEFfTk9ORSkKKwkJaWYgKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX1dQQV9OT05FKQogCQkJYXV0aF9tb2RlID0gTmRpczgwMl8xMUF1dGhNb2RlV1BBTm9uZTsKLQkJZWxzZSBpZiAocGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBLRVlfTUdNVF9QU0spCisJCWVsc2UgaWYgKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX1BTSykKIAkJCWF1dGhfbW9kZSA9IE5kaXM4MDJfMTFBdXRoTW9kZVdQQVBTSzsKIAkJZWxzZQogCQkJYXV0aF9tb2RlID0gTmRpczgwMl8xMUF1dGhNb2RlV1BBOwogCX0KIAogCXN3aXRjaCAocGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSkgewotCWNhc2UgQ0lQSEVSX0NDTVA6CisJY2FzZSBXUEFfQ0lQSEVSX0NDTVA6CiAJCWVuY3IgPSBOZGlzODAyXzExRW5jcnlwdGlvbjNFbmFibGVkOwogCQlicmVhazsKLQljYXNlIENJUEhFUl9US0lQOgorCWNhc2UgV1BBX0NJUEhFUl9US0lQOgogCQllbmNyID0gTmRpczgwMl8xMUVuY3J5cHRpb24yRW5hYmxlZDsKIAkJYnJlYWs7Ci0JY2FzZSBDSVBIRVJfV0VQNDA6Ci0JY2FzZSBDSVBIRVJfV0VQMTA0OgorCWNhc2UgV1BBX0NJUEhFUl9XRVA0MDoKKwljYXNlIFdQQV9DSVBIRVJfV0VQMTA0OgogCQllbmNyID0gTmRpczgwMl8xMUVuY3J5cHRpb24xRW5hYmxlZDsKIAkJYnJlYWs7Ci0JY2FzZSBDSVBIRVJfTk9ORToKKwljYXNlIFdQQV9DSVBIRVJfTk9ORToKICNpZmRlZiBDT05GSUdfV1BTCiAJCWlmIChwYXJhbXMtPndwcyA9PSBXUFNfTU9ERV9QUklWQUNZKSB7CiAJCQllbmNyID0gTmRpczgwMl8xMUVuY3J5cHRpb24xRW5hYmxlZDsKIAkJCWJyZWFrOwogCQl9CiAjZW5kaWYgLyogQ09ORklHX1dQUyAqLwotCQlpZiAocGFyYW1zLT5ncm91cF9zdWl0ZSA9PSBDSVBIRVJfQ0NNUCkKKwkJaWYgKHBhcmFtcy0+Z3JvdXBfc3VpdGUgPT0gV1BBX0NJUEhFUl9DQ01QKQogCQkJZW5jciA9IE5kaXM4MDJfMTFFbmNyeXB0aW9uM0VuYWJsZWQ7Ci0JCWVsc2UgaWYgKHBhcmFtcy0+Z3JvdXBfc3VpdGUgPT0gQ0lQSEVSX1RLSVApCisJCWVsc2UgaWYgKHBhcmFtcy0+Z3JvdXBfc3VpdGUgPT0gV1BBX0NJUEhFUl9US0lQKQogCQkJZW5jciA9IE5kaXM4MDJfMTFFbmNyeXB0aW9uMkVuYWJsZWQ7CiAJCWVsc2UKIAkJCWVuY3IgPSBOZGlzODAyXzExRW5jcnlwdGlvbkRpc2FibGVkOwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX25sODAyMTEuYyBiL3NyYy9kcml2ZXJzL2RyaXZlcl9ubDgwMjExLmMKaW5kZXggYTNmZjE4OS4uOGViZjdkOSAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX25sODAyMTEuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfbmw4MDIxMS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIERyaXZlciBpbnRlcmFjdGlvbiB3aXRoIExpbnV4IG5sODAyMTEvY2ZnODAyMTEKLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAwNCwgSW5zdGFudDgwMiBOZXR3b3JrcywgSW5jLgogICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDYsIERldmljZXNjYXBlIFNvZnR3YXJlLCBJbmMuCiAgKiBDb3B5cmlnaHQgKGMpIDIwMDcsIEpvaGFubmVzIEJlcmcgPGpvaGFubmVzQHNpcHNvbHV0aW9ucy5uZXQ+CkBAIC0yOCw2ICsyOCw4IEBACiAjaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAiZWxvb3AuaCIKICNpbmNsdWRlICJ1dGlscy9saXN0LmgiCisjaW5jbHVkZSAiY29tbW9uL3FjYS12ZW5kb3IuaCIKKyNpbmNsdWRlICJjb21tb24vcWNhLXZlbmRvci1hdHRyLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIgogI2luY2x1ZGUgImwyX3BhY2tldC9sMl9wYWNrZXQuaCIKQEAgLTEwOSw2ICsxMTEsMTcgQEAKICNlbmRpZiAvKiBDT05GSUdfTElCTkwyMCAqLwogCiAKKyNpZmRlZiBBTkRST0lECisvKiBzeXN0ZW0vY29yZS9saWJubF8yIGRvZXMgbm90IGluY2x1ZGUgbmxfc29ja2V0X3NldF9ub25ibG9ja2luZygpICovCitzdGF0aWMgaW50IGFuZHJvaWRfbmxfc29ja2V0X3NldF9ub25ibG9ja2luZyhzdHJ1Y3QgbmxfaGFuZGxlICpoYW5kbGUpCit7CisJcmV0dXJuIGZjbnRsKG5sX3NvY2tldF9nZXRfZmQoaGFuZGxlKSwgRl9TRVRGTCwgT19OT05CTE9DSyk7Cit9CisjdW5kZWYgbmxfc29ja2V0X3NldF9ub25ibG9ja2luZworI2RlZmluZSBubF9zb2NrZXRfc2V0X25vbmJsb2NraW5nKGgpIGFuZHJvaWRfbmxfc29ja2V0X3NldF9ub25ibG9ja2luZyhoKQorI2VuZGlmIC8qIEFORFJPSUQgKi8KKworCiBzdGF0aWMgc3RydWN0IG5sX2hhbmRsZSAqIG5sX2NyZWF0ZV9oYW5kbGUoc3RydWN0IG5sX2NiICpjYiwgY29uc3QgY2hhciAqZGJnKQogewogCXN0cnVjdCBubF9oYW5kbGUgKmhhbmRsZTsKQEAgLTE0MCw2ICsxNTMsMzEgQEAKIH0KIAogCisjaWYgX19XT1JEU0laRSA9PSA2NAorI2RlZmluZSBFTE9PUF9TT0NLRVRfSU5WQUxJRAkoaW50cHRyX3QpIDB4ODg4ODg4ODg4ODg4ODg4OVVMTAorI2Vsc2UKKyNkZWZpbmUgRUxPT1BfU09DS0VUX0lOVkFMSUQJKGludHB0cl90KSAweDg4ODg4ODg5VUxMCisjZW5kaWYKKworc3RhdGljIHZvaWQgbmw4MDIxMV9yZWdpc3Rlcl9lbG9vcF9yZWFkKHN0cnVjdCBubF9oYW5kbGUgKipoYW5kbGUsCisJCQkJCWVsb29wX3NvY2tfaGFuZGxlciBoYW5kbGVyLAorCQkJCQl2b2lkICplbG9vcF9kYXRhKQoreworCW5sX3NvY2tldF9zZXRfbm9uYmxvY2tpbmcoKmhhbmRsZSk7CisJZWxvb3BfcmVnaXN0ZXJfcmVhZF9zb2NrKG5sX3NvY2tldF9nZXRfZmQoKmhhbmRsZSksIGhhbmRsZXIsCisJCQkJIGVsb29wX2RhdGEsICpoYW5kbGUpOworCSpoYW5kbGUgPSAodm9pZCAqKSAoKChpbnRwdHJfdCkgKmhhbmRsZSkgXiBFTE9PUF9TT0NLRVRfSU5WQUxJRCk7Cit9CisKKworc3RhdGljIHZvaWQgbmw4MDIxMV9kZXN0cm95X2Vsb29wX2hhbmRsZShzdHJ1Y3QgbmxfaGFuZGxlICoqaGFuZGxlKQoreworCSpoYW5kbGUgPSAodm9pZCAqKSAoKChpbnRwdHJfdCkgKmhhbmRsZSkgXiBFTE9PUF9TT0NLRVRfSU5WQUxJRCk7CisJZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2sobmxfc29ja2V0X2dldF9mZCgqaGFuZGxlKSk7CisJbmxfZGVzdHJveV9oYW5kbGVzKGhhbmRsZSk7Cit9CisKKwogI2lmbmRlZiBJRkZfTE9XRVJfVVAKICNkZWZpbmUgSUZGX0xPV0VSX1VQICAgMHgxMDAwMCAgICAgICAgIC8qIGRyaXZlciBzaWduYWxzIEwxIHVwICAgICAgICAgKi8KICNlbmRpZgpAQCAtMTkzLDEwICsyMzEsMTMgQEAKIAl1bnNpZ25lZCBpbnQgYWRkZWRfYnJpZGdlOjE7CiAJdW5zaWduZWQgaW50IGluX2RlaW5pdDoxOwogCXVuc2lnbmVkIGludCB3ZGV2X2lkX3NldDoxOworCXVuc2lnbmVkIGludCBhZGRlZF9pZjoxOworCXVuc2lnbmVkIGludCBzdGF0aWNfYXA6MTsKIAogCXU4IGFkZHJbRVRIX0FMRU5dOwogCiAJaW50IGZyZXE7CisJaW50IGJhbmR3aWR0aDsKIAlpbnQgaWZfZHluYW1pYzsKIAogCXZvaWQgKmN0eDsKQEAgLTIyNiw2ICsyNjcsMTEgQEAKIAlpbnQgb3BlcnN0YXRlOwogCiAJaW50IHNjYW5fY29tcGxldGVfZXZlbnRzOworCWVudW0gc2Nhbl9zdGF0ZXMgeworCQlOT19TQ0FOLCBTQ0FOX1JFUVVFU1RFRCwgU0NBTl9TVEFSVEVELCBTQ0FOX0NPTVBMRVRFRCwKKwkJU0NBTl9BQk9SVEVELCBTQ0hFRF9TQ0FOX1NUQVJURUQsIFNDSEVEX1NDQU5fU1RPUFBFRCwKKwkJU0NIRURfU0NBTl9SRVNVTFRTCisJfSBzY2FuX3N0YXRlOwogCiAJc3RydWN0IG5sX2NiICpubF9jYjsKIApAQCAtMjU0LDcgKzMwMCwxNSBAQAogCXVuc2lnbmVkIGludCByZXRyeV9hdXRoOjE7CiAJdW5zaWduZWQgaW50IHVzZV9tb25pdG9yOjE7CiAJdW5zaWduZWQgaW50IGlnbm9yZV9uZXh0X2xvY2FsX2Rpc2Nvbm5lY3Q6MTsKKwl1bnNpZ25lZCBpbnQgaWdub3JlX25leHRfbG9jYWxfZGVhdXRoOjE7CiAJdW5zaWduZWQgaW50IGFsbG93X3AycF9kZXZpY2U6MTsKKwl1bnNpZ25lZCBpbnQgaG9zdGFwZDoxOworCXVuc2lnbmVkIGludCBzdGFydF9tb2RlX2FwOjE7CisJdW5zaWduZWQgaW50IHN0YXJ0X2lmYWNlX3VwOjE7CisJdW5zaWduZWQgaW50IHRlc3RfdXNlX3JvY190eDoxOworCXVuc2lnbmVkIGludCBpZ25vcmVfZGVhdXRoX2V2ZW50OjE7CisJdW5zaWduZWQgaW50IGRmc192ZW5kb3JfY21kX2F2YWlsOjE7CisJdW5zaWduZWQgaW50IGhhdmVfbG93X3ByaW9fc2NhbjoxOwogCiAJdTY0IHJlbWFpbl9vbl9jaGFuX2Nvb2tpZTsKIAl1NjQgc2VuZF9hY3Rpb25fY29va2llOwpAQCAtMjY0LDIxICszMTgsMTYgQEAKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX2ZpbHRlciAqZmlsdGVyX3NzaWRzOwogCXNpemVfdCBudW1fZmlsdGVyX3NzaWRzOwogCi0Jc3RydWN0IGk4MDJfYnNzIGZpcnN0X2JzczsKKwlzdHJ1Y3QgaTgwMl9ic3MgKmZpcnN0X2JzczsKIAogCWludCBlYXBvbF90eF9zb2NrOwogCi0jaWZkZWYgSE9TVEFQRAogCWludCBlYXBvbF9zb2NrOyAvKiBzb2NrZXQgZm9yIEVBUE9MIGZyYW1lcyAqLwogCiAJaW50IGRlZmF1bHRfaWZfaW5kaWNlc1sxNl07CiAJaW50ICppZl9pbmRpY2VzOwogCWludCBudW1faWZfaW5kaWNlczsKIAotCWludCBsYXN0X2ZyZXE7Ci0JaW50IGxhc3RfZnJlcV9odDsKLSNlbmRpZiAvKiBIT1NUQVBEICovCi0KIAkvKiBGcm9tIGZhaWxlZCBhdXRoZW50aWNhdGlvbiBjb21tYW5kICovCiAJaW50IGF1dGhfZnJlcTsKIAl1OCBhdXRoX2Jzc2lkX1tFVEhfQUxFTl07CkBAIC0zMDAsOCArMzQ5LDExIEBACiAJCQkJCSAgICB2b2lkICp0aW1lb3V0X2N0eCk7CiBzdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZShzdHJ1Y3QgaTgwMl9ic3MgKmJzcywKIAkJCQkgICAgICAgZW51bSBubDgwMjExX2lmdHlwZSBubG1vZGUpOworc3RhdGljIGludCB3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGVfaWJzcyhzdHJ1Y3QgaTgwMl9ic3MgKmJzcywgaW50IGZyZXEpOworCiBzdGF0aWMgaW50Ci13cGFfZHJpdmVyX25sODAyMTFfZmluaXNoX2Rydl9pbml0KHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2KTsKK3dwYV9kcml2ZXJfbmw4MDIxMV9maW5pc2hfZHJ2X2luaXQoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCisJCQkJICAgY29uc3QgdTggKnNldF9hZGRyLCBpbnQgZmlyc3QpOwogc3RhdGljIGludCB3cGFfZHJpdmVyX25sODAyMTFfbWxtZShzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKIAkJCQkgICBjb25zdCB1OCAqYWRkciwgaW50IGNtZCwgdTE2IHJlYXNvbl9jb2RlLAogCQkJCSAgIGludCBsb2NhbF9zdGF0ZV9jaGFuZ2UpOwpAQCAtMzIwLDQ0ICszNzIsNDQgQEAKIHN0YXRpYyBpbnQgYW5kcm9pZF9wbm9fc3RhcnQoc3RydWN0IGk4MDJfYnNzICpic3MsCiAJCQkgICAgIHN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpwYXJhbXMpOwogc3RhdGljIGludCBhbmRyb2lkX3Bub19zdG9wKHN0cnVjdCBpODAyX2JzcyAqYnNzKTsKK2V4dGVybiBpbnQgd3BhX2RyaXZlcl9ubDgwMjExX2RyaXZlcl9jbWQodm9pZCAqcHJpdiwgY2hhciAqY21kLCBjaGFyICpidWYsCisJCQkJCSBzaXplX3QgYnVmX2xlbik7CiAjZW5kaWYgLyogQU5EUk9JRCAqLwogI2lmZGVmIEFORFJPSURfUDJQCisjaWZkZWYgQU5EUk9JRF9QMlBfU1RVQgoraW50IHdwYV9kcml2ZXJfc2V0X3AycF9ub2Eodm9pZCAqcHJpdiwgdTggY291bnQsIGludCBzdGFydCwgaW50IGR1cmF0aW9uKSB7CisJcmV0dXJuIDA7Cit9CitpbnQgd3BhX2RyaXZlcl9nZXRfcDJwX25vYSh2b2lkICpwcml2LCB1OCAqYnVmLCBzaXplX3QgbGVuKSB7CisJcmV0dXJuIDA7Cit9CitpbnQgd3BhX2RyaXZlcl9zZXRfcDJwX3BzKHZvaWQgKnByaXYsIGludCBsZWdhY3lfcHMsIGludCBvcHBfcHMsIGludCBjdHdpbmRvdykgeworCXJldHVybiAtMTsKK30KK2ludCB3cGFfZHJpdmVyX3NldF9hcF93cHNfcDJwX2llKHZvaWQgKnByaXYsIGNvbnN0IHN0cnVjdCB3cGFidWYgKmJlYWNvbiwKKwkJCQkgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcHJvYmVyZXNwLAorCQkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICphc3NvY3Jlc3ApIHsKKwlyZXR1cm4gMDsKK30KKyNlbHNlIC8qIEFORFJPSURfUDJQX1NUVUIgKi8KIGludCB3cGFfZHJpdmVyX3NldF9wMnBfbm9hKHZvaWQgKnByaXYsIHU4IGNvdW50LCBpbnQgc3RhcnQsIGludCBkdXJhdGlvbik7CiBpbnQgd3BhX2RyaXZlcl9nZXRfcDJwX25vYSh2b2lkICpwcml2LCB1OCAqYnVmLCBzaXplX3QgbGVuKTsKIGludCB3cGFfZHJpdmVyX3NldF9wMnBfcHModm9pZCAqcHJpdiwgaW50IGxlZ2FjeV9wcywgaW50IG9wcF9wcywgaW50IGN0d2luZG93KTsKIGludCB3cGFfZHJpdmVyX3NldF9hcF93cHNfcDJwX2llKHZvaWQgKnByaXYsIGNvbnN0IHN0cnVjdCB3cGFidWYgKmJlYWNvbiwKLQkJCQkgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnByb2JlcmVzcCwKLQkJCQkgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmFzc29jcmVzcCk7CisJCQkJIGNvbnN0IHN0cnVjdCB3cGFidWYgKnByb2JlcmVzcCwKKwkJCQkgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYXNzb2NyZXNwKTsKKyNlbmRpZiAvKiBBTkRST0lEX1AyUF9TVFVCICovCisjZW5kaWYgLyogQU5EUk9JRF9QMlAgKi8KIAotI2VuZGlmCi0jaWZkZWYgSE9TVEFQRAogc3RhdGljIHZvaWQgYWRkX2lmaWR4KHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LCBpbnQgaWZpZHgpOwogc3RhdGljIHZvaWQgZGVsX2lmaWR4KHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LCBpbnQgaWZpZHgpOwogc3RhdGljIGludCBoYXZlX2lmaWR4KHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LCBpbnQgaWZpZHgpOwogc3RhdGljIGludCB3cGFfZHJpdmVyX25sODAyMTFfaWZfcmVtb3ZlKHN0cnVjdCBpODAyX2JzcyAqYnNzLAogCQkJCQllbnVtIHdwYV9kcml2ZXJfaWZfdHlwZSB0eXBlLAogCQkJCQljb25zdCBjaGFyICppZm5hbWUpOwotI2Vsc2UgLyogSE9TVEFQRCAqLwotc3RhdGljIGlubGluZSB2b2lkIGFkZF9pZmlkeChzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwgaW50IGlmaWR4KQotewotfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgZGVsX2lmaWR4KHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LCBpbnQgaWZpZHgpCi17Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IGhhdmVfaWZpZHgoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsIGludCBpZmlkeCkKLXsKLQlyZXR1cm4gMDsKLX0KLSNlbmRpZiAvKiBIT1NUQVBEICovCi0jaWZkZWYgQU5EUk9JRAotZXh0ZXJuIGludCB3cGFfZHJpdmVyX25sODAyMTFfZHJpdmVyX2NtZCh2b2lkICpwcml2LCBjaGFyICpjbWQsIGNoYXIgKmJ1ZiwKLQkJCQkJIHNpemVfdCBidWZfbGVuKTsKLSNlbmRpZgotCi1zdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfZnJlcShzdHJ1Y3QgaTgwMl9ic3MgKmJzcywKLQkJCQkgICAgICAgc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgKmZyZXEpOworc3RhdGljIGludCBubDgwMjExX3NldF9jaGFubmVsKHN0cnVjdCBpODAyX2JzcyAqYnNzLAorCQkJICAgICAgIHN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zICpmcmVxLCBpbnQgc2V0X2NoYW4pOwogc3RhdGljIGludCBubDgwMjExX2Rpc2FibGVfMTFiX3JhdGVzKHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LAogCQkJCSAgICAgaW50IGlmaW5kZXgsIGludCBkaXNhYmxlZCk7CiAKQEAgLTM2NSw2ICs0MTcsNyBAQAogc3RhdGljIGludCB3cGFfZHJpdmVyX25sODAyMTFfYXV0aGVudGljYXRlX3JldHJ5KAogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2KTsKIAorc3RhdGljIGludCBpODAyX3NldF9mcmVxKHZvaWQgKnByaXYsIHN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zICpmcmVxKTsKIHN0YXRpYyBpbnQgaTgwMl9zZXRfaWZhY2VfZmxhZ3Moc3RydWN0IGk4MDJfYnNzICpic3MsIGludCB1cCk7CiAKIApAQCAtNDcyLDYgKzUyNSwxMSBAQAogCUMyUyhOTDgwMjExX0NNRF9GVF9FVkVOVCkKIAlDMlMoTkw4MDIxMV9DTURfQ1JJVF9QUk9UT0NPTF9TVEFSVCkKIAlDMlMoTkw4MDIxMV9DTURfQ1JJVF9QUk9UT0NPTF9TVE9QKQorCUMyUyhOTDgwMjExX0NNRF9HRVRfQ09BTEVTQ0UpCisJQzJTKE5MODAyMTFfQ01EX1NFVF9DT0FMRVNDRSkKKwlDMlMoTkw4MDIxMV9DTURfQ0hBTk5FTF9TV0lUQ0gpCisJQzJTKE5MODAyMTFfQ01EX1ZFTkRPUikKKwlDMlMoTkw4MDIxMV9DTURfU0VUX1FPU19NQVApCiAJZGVmYXVsdDoKIAkJcmV0dXJuICJOTDgwMjExX0NNRF9VTktOT1dOIjsKIAl9CkBAIC00NzksMjQgKzUzNyw0NSBAQAogfQogCiAKKy8qIENvbnZlcnRzIG5sODAyMTFfY2hhbl93aWR0aCB0byBhIGNvbW1vbiBmb3JtYXQgKi8KK3N0YXRpYyBlbnVtIGNoYW5fd2lkdGggY29udmVydDJ3aWR0aChpbnQgd2lkdGgpCit7CisJc3dpdGNoICh3aWR0aCkgeworCWNhc2UgTkw4MDIxMV9DSEFOX1dJRFRIXzIwX05PSFQ6CisJCXJldHVybiBDSEFOX1dJRFRIXzIwX05PSFQ7CisJY2FzZSBOTDgwMjExX0NIQU5fV0lEVEhfMjA6CisJCXJldHVybiBDSEFOX1dJRFRIXzIwOworCWNhc2UgTkw4MDIxMV9DSEFOX1dJRFRIXzQwOgorCQlyZXR1cm4gQ0hBTl9XSURUSF80MDsKKwljYXNlIE5MODAyMTFfQ0hBTl9XSURUSF84MDoKKwkJcmV0dXJuIENIQU5fV0lEVEhfODA7CisJY2FzZSBOTDgwMjExX0NIQU5fV0lEVEhfODBQODA6CisJCXJldHVybiBDSEFOX1dJRFRIXzgwUDgwOworCWNhc2UgTkw4MDIxMV9DSEFOX1dJRFRIXzE2MDoKKwkJcmV0dXJuIENIQU5fV0lEVEhfMTYwOworCX0KKwlyZXR1cm4gQ0hBTl9XSURUSF9VTktOT1dOOworfQorCisKIHN0YXRpYyBpbnQgaXNfYXBfaW50ZXJmYWNlKGVudW0gbmw4MDIxMV9pZnR5cGUgbmxtb2RlKQogewotCXJldHVybiAobmxtb2RlID09IE5MODAyMTFfSUZUWVBFX0FQIHx8Ci0JCW5sbW9kZSA9PSBOTDgwMjExX0lGVFlQRV9QMlBfR08pOworCXJldHVybiBubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfQVAgfHwKKwkJbmxtb2RlID09IE5MODAyMTFfSUZUWVBFX1AyUF9HTzsKIH0KIAogCiBzdGF0aWMgaW50IGlzX3N0YV9pbnRlcmZhY2UoZW51bSBubDgwMjExX2lmdHlwZSBubG1vZGUpCiB7Ci0JcmV0dXJuIChubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfU1RBVElPTiB8fAotCQlubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfUDJQX0NMSUVOVCk7CisJcmV0dXJuIG5sbW9kZSA9PSBOTDgwMjExX0lGVFlQRV9TVEFUSU9OIHx8CisJCW5sbW9kZSA9PSBOTDgwMjExX0lGVFlQRV9QMlBfQ0xJRU5UOwogfQogCiAKIHN0YXRpYyBpbnQgaXNfcDJwX25ldF9pbnRlcmZhY2UoZW51bSBubDgwMjExX2lmdHlwZSBubG1vZGUpCiB7Ci0JcmV0dXJuIChubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfUDJQX0NMSUVOVCB8fAotCQlubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfUDJQX0dPKTsKKwlyZXR1cm4gbmxtb2RlID09IE5MODAyMTFfSUZUWVBFX1AyUF9DTElFTlQgfHwKKwkJbmxtb2RlID09IE5MODAyMTFfSUZUWVBFX1AyUF9HTzsKIH0KIAogCkBAIC01MTMsNiArNTkyLDcgQEAKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydjsKIAlzdHJ1Y3Qgd3BhX3NjYW5fcmVzdWx0cyAqcmVzOwogCXVuc2lnbmVkIGludCBhc3NvY19mcmVxOworCXVuc2lnbmVkIGludCBpYnNzX2ZyZXE7CiAJdTggYXNzb2NfYnNzaWRbRVRIX0FMRU5dOwogfTsKIApAQCAtNTc1LDggKzY1NSwxNCBAQAogCQlubF9jYl9zZXQoY2IsIE5MX0NCX1ZBTElELCBOTF9DQl9DVVNUT00sCiAJCQkgIHZhbGlkX2hhbmRsZXIsIHZhbGlkX2RhdGEpOwogCi0Jd2hpbGUgKGVyciA+IDApCi0JCW5sX3JlY3Ztc2dzKG5sX2hhbmRsZSwgY2IpOworCXdoaWxlIChlcnIgPiAwKSB7CisJCWludCByZXMgPSBubF9yZWN2bXNncyhubF9oYW5kbGUsIGNiKTsKKwkJaWYgKHJlcyA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkJICAgIm5sODAyMTE6ICVzLT5ubF9yZWN2bXNncyBmYWlsZWQ6ICVkIiwKKwkJCQkgICBfX2Z1bmNfXywgcmVzKTsKKwkJfQorCX0KICBvdXQ6CiAJbmxfY2JfcHV0KGNiKTsKIAlubG1zZ19mcmVlKG1zZyk7CkBAIC01OTQsMTAgKzY4MCw3IEBACiB9CiAKIAotI2lmbmRlZiBBTkRST0lECi1zdGF0aWMKLSNlbmRpZgotaW50IHNlbmRfYW5kX3JlY3ZfbXNncyhzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKK3N0YXRpYyBpbnQgc2VuZF9hbmRfcmVjdl9tc2dzKHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LAogCQkJICAgICAgc3RydWN0IG5sX21zZyAqbXNnLAogCQkJICAgICAgaW50ICgqdmFsaWRfaGFuZGxlcikoc3RydWN0IG5sX21zZyAqLCB2b2lkICopLAogCQkJICAgICAgdm9pZCAqdmFsaWRfZGF0YSkKQEAgLTc3Miw3ICs4NTUsNiBAQAogfQogCiAKLSNpZm5kZWYgSE9TVEFQRAogc3RhdGljIGludCBubDgwMjExX2dldF9tYWNhZGRyKHN0cnVjdCBpODAyX2JzcyAqYnNzKQogewogCXN0cnVjdCBubF9tc2cgKm1zZzsKQEAgLTc5NCw3ICs4NzYsNiBAQAogCW5sbXNnX2ZyZWUobXNnKTsKIAlyZXR1cm4gTkw4MDIxMV9JRlRZUEVfVU5TUEVDSUZJRUQ7CiB9Ci0jZW5kaWYgLyogSE9TVEFQRCAqLwogCiAKIHN0YXRpYyBpbnQgbmw4MDIxMV9yZWdpc3Rlcl9iZWFjb25zKHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LApAQCAtODI5LDEwICs5MTAsMTUgQEAKIHN0YXRpYyB2b2lkIG5sODAyMTFfcmVjdl9iZWFjb25zKGludCBzb2NrLCB2b2lkICplbG9vcF9jdHgsIHZvaWQgKmhhbmRsZSkKIHsKIAlzdHJ1Y3Qgbmw4MDIxMV93aXBoeV9kYXRhICp3ID0gZWxvb3BfY3R4OworCWludCByZXM7CiAKIAl3cGFfcHJpbnRmKE1TR19FWENFU1NJVkUsICJubDgwMjExOiBCZWFjb24gZXZlbnQgbWVzc2FnZSBhdmFpbGFibGUiKTsKIAotCW5sX3JlY3Ztc2dzKGhhbmRsZSwgdy0+bmxfY2IpOworCXJlcyA9IG5sX3JlY3Ztc2dzKGhhbmRsZSwgdy0+bmxfY2IpOworCWlmIChyZXMgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJubDgwMjExOiAlcy0+bmxfcmVjdm1zZ3MgZmFpbGVkOiAlZCIsCisJCQkgICBfX2Z1bmNfXywgcmVzKTsKKwl9CiB9CiAKIApAQCAtOTE2LDggKzEwMDIsNyBAQAogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQllbG9vcF9yZWdpc3Rlcl9yZWFkX3NvY2sobmxfc29ja2V0X2dldF9mZCh3LT5ubF9iZWFjb25zKSwKLQkJCQkgbmw4MDIxMV9yZWN2X2JlYWNvbnMsIHcsIHctPm5sX2JlYWNvbnMpOworCW5sODAyMTFfcmVnaXN0ZXJfZWxvb3BfcmVhZCgmdy0+bmxfYmVhY29ucywgbmw4MDIxMV9yZWN2X2JlYWNvbnMsIHcpOwogCiAJZGxfbGlzdF9hZGQoJm5sODAyMTFfd2lwaHlzLCAmdy0+bGlzdCk7CiAKQEAgLTk2NCwxMCArMTA0OSw5IEBACiAJaWYgKCFkbF9saXN0X2VtcHR5KCZ3LT5ic3NzKSkKIAkJcmV0dXJuOwogCi0JZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2sobmxfc29ja2V0X2dldF9mZCh3LT5ubF9iZWFjb25zKSk7CisJbmw4MDIxMV9kZXN0cm95X2Vsb29wX2hhbmRsZSgmdy0+bmxfYmVhY29ucyk7CiAKIAlubF9jYl9wdXQody0+bmxfY2IpOwotCW5sX2Rlc3Ryb3lfaGFuZGxlcygmdy0+bmxfYmVhY29ucyk7CiAJZGxfbGlzdF9kZWwoJnctPmxpc3QpOwogCW9zX2ZyZWUodyk7CiB9CkBAIC05OTUsNDggKzEwNzksNTUgQEAKIH0KIAogCi1zdGF0aWMgdm9pZCB3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfbGluayhzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKLQkJCQkJICBjaGFyICpidWYsIHNpemVfdCBsZW4sIGludCBkZWwpCitzdGF0aWMgdm9pZCB3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfbmV3bGluaygKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwgY2hhciAqaWZuYW1lKQogewogCXVuaW9uIHdwYV9ldmVudF9kYXRhIGV2ZW50OwogCi0Jb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7Ci0JaWYgKGxlbiA+IHNpemVvZihldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSkpCi0JCWxlbiA9IHNpemVvZihldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSkgLSAxOwotCW9zX21lbWNweShldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSwgYnVmLCBsZW4pOwotCWV2ZW50LmludGVyZmFjZV9zdGF0dXMuaWV2ZW50ID0gZGVsID8gRVZFTlRfSU5URVJGQUNFX1JFTU9WRUQgOgotCQlFVkVOVF9JTlRFUkZBQ0VfQURERUQ7Ci0KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJUTV8lc0xJTkssIElGTEFfSUZOQU1FOiBJbnRlcmZhY2UgJyVzJyAlcyIsCi0JCSAgIGRlbCA/ICJERUwiIDogIk5FVyIsCi0JCSAgIGV2ZW50LmludGVyZmFjZV9zdGF0dXMuaWZuYW1lLAotCQkgICBkZWwgPyAicmVtb3ZlZCIgOiAiYWRkZWQiKTsKLQotCWlmIChvc19zdHJjbXAoZHJ2LT5maXJzdF9ic3MuaWZuYW1lLCBldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSkgPT0gMCkgewotCQlpZiAoZGVsKSB7Ci0JCQlpZiAoZHJ2LT5pZl9yZW1vdmVkKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBpZl9yZW1vdmVkICIKLQkJCQkJICAgImFscmVhZHkgc2V0IC0gaWdub3JlIGV2ZW50Iik7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQkJZHJ2LT5pZl9yZW1vdmVkID0gMTsKLQkJfSBlbHNlIHsKLQkJCWlmIChpZl9uYW1ldG9pbmRleChkcnYtPmZpcnN0X2Jzcy5pZm5hbWUpID09IDApIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IEludGVyZmFjZSAlcyAiCi0JCQkJCSAgICJkb2VzIG5vdCBleGlzdCAtIGlnbm9yZSAiCi0JCQkJCSAgICJSVE1fTkVXTElOSyIsCi0JCQkJCSAgIGRydi0+Zmlyc3RfYnNzLmlmbmFtZSk7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQkJaWYgKCFkcnYtPmlmX3JlbW92ZWQpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IGlmX3JlbW92ZWQgIgotCQkJCQkgICAiYWxyZWFkeSBjbGVhcmVkIC0gaWdub3JlIGV2ZW50Iik7Ci0JCQkJcmV0dXJuOwotCQkJfQotCQkJZHJ2LT5pZl9yZW1vdmVkID0gMDsKKwlpZiAob3Nfc3RyY21wKGRydi0+Zmlyc3RfYnNzLT5pZm5hbWUsIGlmbmFtZSkgPT0gMCkgeworCQlpZiAoaWZfbmFtZXRvaW5kZXgoZHJ2LT5maXJzdF9ic3MtPmlmbmFtZSkgPT0gMCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJbnRlcmZhY2UgJXMgZG9lcyBub3QgZXhpc3QgLSBpZ25vcmUgUlRNX05FV0xJTksiLAorCQkJCSAgIGRydi0+Zmlyc3RfYnNzLT5pZm5hbWUpOworCQkJcmV0dXJuOwogCQl9CisJCWlmICghZHJ2LT5pZl9yZW1vdmVkKQorCQkJcmV0dXJuOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IE1hcmsgaWZfcmVtb3ZlZD0wIGZvciAlcyBiYXNlZCBvbiBSVE1fTkVXTElOSyBldmVudCIsCisJCQkgICBkcnYtPmZpcnN0X2Jzcy0+aWZuYW1lKTsKKwkJZHJ2LT5pZl9yZW1vdmVkID0gMDsKIAl9CiAKKwlvc19tZW1zZXQoJmV2ZW50LCAwLCBzaXplb2YoZXZlbnQpKTsKKwlvc19zdHJsY3B5KGV2ZW50LmludGVyZmFjZV9zdGF0dXMuaWZuYW1lLCBpZm5hbWUsCisJCSAgIHNpemVvZihldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSkpOworCWV2ZW50LmludGVyZmFjZV9zdGF0dXMuaWV2ZW50ID0gRVZFTlRfSU5URVJGQUNFX0FEREVEOworCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9JTlRFUkZBQ0VfU1RBVFVTLCAmZXZlbnQpOworfQorCisKK3N0YXRpYyB2b2lkIHdwYV9kcml2ZXJfbmw4MDIxMV9ldmVudF9kZWxsaW5rKAorCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LCBjaGFyICppZm5hbWUpCit7CisJdW5pb24gd3BhX2V2ZW50X2RhdGEgZXZlbnQ7CisKKwlpZiAob3Nfc3RyY21wKGRydi0+Zmlyc3RfYnNzLT5pZm5hbWUsIGlmbmFtZSkgPT0gMCkgeworCQlpZiAoZHJ2LT5pZl9yZW1vdmVkKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IGlmX3JlbW92ZWQgYWxyZWFkeSBzZXQgLSBpZ25vcmUgUlRNX0RFTExJTksgZXZlbnQgZm9yICVzIiwKKwkJCQkgICBpZm5hbWUpOworCQkJcmV0dXJuOworCQl9CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUlRNX0RFTExJTks6IEludGVyZmFjZSAnJXMnIHJlbW92ZWQgLSBtYXJrIGlmX3JlbW92ZWQ9MSIsCisJCQkgICBpZm5hbWUpOworCQlkcnYtPmlmX3JlbW92ZWQgPSAxOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUlRNX0RFTExJTks6IEludGVyZmFjZSAnJXMnIHJlbW92ZWQiLAorCQkJICAgaWZuYW1lKTsKKwl9CisKKwlvc19tZW1zZXQoJmV2ZW50LCAwLCBzaXplb2YoZXZlbnQpKTsKKwlvc19zdHJsY3B5KGV2ZW50LmludGVyZmFjZV9zdGF0dXMuaWZuYW1lLCBpZm5hbWUsCisJCSAgIHNpemVvZihldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSkpOworCWV2ZW50LmludGVyZmFjZV9zdGF0dXMuaWV2ZW50ID0gRVZFTlRfSU5URVJGQUNFX1JFTU9WRUQ7CiAJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX0lOVEVSRkFDRV9TVEFUVVMsICZldmVudCk7CiB9CiAKQEAgLTEwNTMsOCArMTE0NCw4IEBACiAJcnRhX2xlbiA9IFJUQV9BTElHTihzaXplb2Yoc3RydWN0IHJ0YXR0cikpOwogCXdoaWxlIChSVEFfT0soYXR0ciwgYXR0cmxlbikpIHsKIAkJaWYgKGF0dHItPnJ0YV90eXBlID09IElGTEFfSUZOQU1FKSB7Ci0JCQlpZiAob3Nfc3RyY21wKCgoY2hhciAqKSBhdHRyKSArIHJ0YV9sZW4sIGRydi0+Zmlyc3RfYnNzLmlmbmFtZSkKLQkJCSAgICA9PSAwKQorCQkJaWYgKG9zX3N0cmNtcCgoKGNoYXIgKikgYXR0cikgKyBydGFfbGVuLAorCQkJCSAgICAgIGRydi0+Zmlyc3RfYnNzLT5pZm5hbWUpID09IDApCiAJCQkJcmV0dXJuIDE7CiAJCQllbHNlCiAJCQkJYnJlYWs7CkBAIC0xMDc1LDcgKzExNjYsNyBAQAogCWlmIChkcnYtPmlmX3JlbW92ZWQgJiYgd3BhX2RyaXZlcl9ubDgwMjExX293bl9pZm5hbWUoZHJ2LCBidWYsIGxlbikpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBVcGRhdGUgaWZpbmRleCBmb3IgYSByZW1vdmVkICIKIAkJCSAgICJpbnRlcmZhY2UiKTsKLQkJd3BhX2RyaXZlcl9ubDgwMjExX2ZpbmlzaF9kcnZfaW5pdChkcnYpOworCQl3cGFfZHJpdmVyX25sODAyMTFfZmluaXNoX2Rydl9pbml0KGRydiwgTlVMTCwgMCk7CiAJCXJldHVybiAxOwogCX0KIApAQCAtMTEwMywyMSArMTE5NCw1NyBAQAogewogCXN0cnVjdCBubDgwMjExX2dsb2JhbCAqZ2xvYmFsID0gY3R4OwogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2OwotCWludCBhdHRybGVuLCBydGFfbGVuOworCWludCBhdHRybGVuOwogCXN0cnVjdCBydGF0dHIgKmF0dHI7CiAJdTMyIGJyaWQgPSAwOwogCWNoYXIgbmFtZWJ1ZltJRk5BTVNJWl07CisJY2hhciBpZm5hbWVbSUZOQU1TSVogKyAxXTsKKwljaGFyIGV4dHJhWzEwMF0sICpwb3MsICplbmQ7CiAKIAlkcnYgPSBubDgwMjExX2ZpbmRfZHJ2KGdsb2JhbCwgaWZpLT5pZmlfaW5kZXgsIGJ1ZiwgbGVuKTsKIAlpZiAoIWRydikgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZSBldmVudCBmb3IgZm9yZWlnbiAiCi0JCQkgICAiaWZpbmRleCAlZCIsIGlmaS0+aWZpX2luZGV4KTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJZ25vcmUgUlRNX05FV0xJTksgZXZlbnQgZm9yIGZvcmVpZ24gaWZpbmRleCAlZCIsCisJCQkgICBpZmktPmlmaV9pbmRleCk7CiAJCXJldHVybjsKIAl9CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJUTV9ORVdMSU5LOiBvcGVyc3RhdGU9JWQgaWZpX2ZsYWdzPTB4JXggIgotCQkgICAiKCVzJXMlcyVzKSIsCi0JCSAgIGRydi0+b3BlcnN0YXRlLCBpZmktPmlmaV9mbGFncywKKwlleHRyYVswXSA9ICdcMCc7CisJcG9zID0gZXh0cmE7CisJZW5kID0gcG9zICsgc2l6ZW9mKGV4dHJhKTsKKwlpZm5hbWVbMF0gPSAnXDAnOworCisJYXR0cmxlbiA9IGxlbjsKKwlhdHRyID0gKHN0cnVjdCBydGF0dHIgKikgYnVmOworCXdoaWxlIChSVEFfT0soYXR0ciwgYXR0cmxlbikpIHsKKwkJc3dpdGNoIChhdHRyLT5ydGFfdHlwZSkgeworCQljYXNlIElGTEFfSUZOQU1FOgorCQkJaWYgKFJUQV9QQVlMT0FEKGF0dHIpID49IElGTkFNU0laKQorCQkJCWJyZWFrOworCQkJb3NfbWVtY3B5KGlmbmFtZSwgUlRBX0RBVEEoYXR0ciksIFJUQV9QQVlMT0FEKGF0dHIpKTsKKwkJCWlmbmFtZVtSVEFfUEFZTE9BRChhdHRyKV0gPSAnXDAnOworCQkJYnJlYWs7CisJCWNhc2UgSUZMQV9NQVNURVI6CisJCQlicmlkID0gbmxhX2dldF91MzIoKHN0cnVjdCBubGF0dHIgKikgYXR0cik7CisJCQlwb3MgKz0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgbWFzdGVyPSV1IiwgYnJpZCk7CisJCQlicmVhazsKKwkJY2FzZSBJRkxBX1dJUkVMRVNTOgorCQkJcG9zICs9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiIHdleHQiKTsKKwkJCWJyZWFrOworCQljYXNlIElGTEFfT1BFUlNUQVRFOgorCQkJcG9zICs9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiIG9wZXJzdGF0ZT0ldSIsCisJCQkJCSAgIG5sYV9nZXRfdTMyKChzdHJ1Y3QgbmxhdHRyICopIGF0dHIpKTsKKwkJCWJyZWFrOworCQljYXNlIElGTEFfTElOS01PREU6CisJCQlwb3MgKz0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgbGlua21vZGU9JXUiLAorCQkJCQkgICBubGFfZ2V0X3UzMigoc3RydWN0IG5sYXR0ciAqKSBhdHRyKSk7CisJCQlicmVhazsKKwkJfQorCQlhdHRyID0gUlRBX05FWFQoYXR0ciwgYXR0cmxlbik7CisJfQorCWV4dHJhW3NpemVvZihleHRyYSkgLSAxXSA9ICdcMCc7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJUTV9ORVdMSU5LOiBpZmlfaW5kZXg9JWQgaWZuYW1lPSVzJXMgaWZpX2ZsYWdzPTB4JXggKCVzJXMlcyVzKSIsCisJCSAgIGlmaS0+aWZpX2luZGV4LCBpZm5hbWUsIGV4dHJhLCBpZmktPmlmaV9mbGFncywKIAkJICAgKGlmaS0+aWZpX2ZsYWdzICYgSUZGX1VQKSA/ICJbVVBdIiA6ICIiLAogCQkgICAoaWZpLT5pZmlfZmxhZ3MgJiBJRkZfUlVOTklORykgPyAiW1JVTk5JTkddIiA6ICIiLAogCQkgICAoaWZpLT5pZmlfZmxhZ3MgJiBJRkZfTE9XRVJfVVApID8gIltMT1dFUl9VUF0iIDogIiIsCkBAIC0xMTI2LDcgKzEyNTMsNyBAQAogCWlmICghZHJ2LT5pZl9kaXNhYmxlZCAmJiAhKGlmaS0+aWZpX2ZsYWdzICYgSUZGX1VQKSkgewogCQlpZiAoaWZfaW5kZXh0b25hbWUoaWZpLT5pZmlfaW5kZXgsIG5hbWVidWYpICYmCiAJCSAgICBsaW51eF9pZmFjZV91cChkcnYtPmdsb2JhbC0+aW9jdGxfc29jaywKLQkJCQkgICBkcnYtPmZpcnN0X2Jzcy5pZm5hbWUpID4gMCkgeworCQkJCSAgIGRydi0+Zmlyc3RfYnNzLT5pZm5hbWUpID4gMCkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJZ25vcmUgaW50ZXJmYWNlIGRvd24gIgogCQkJCSAgICJldmVudCBzaW5jZSBpbnRlcmZhY2UgJXMgaXMgdXAiLCBuYW1lYnVmKTsKIAkJCXJldHVybjsKQEAgLTExNDAsMjQgKzEyNjcsMzQgQEAKIAkJCWRydi0+aWZfZGlzYWJsZWQgPSAxOwogCQkJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsCiAJCQkJCSAgICAgRVZFTlRfSU5URVJGQUNFX0RJU0FCTEVELCBOVUxMKTsKKworCQkJLyoKKwkJCSAqIFRyeSB0byBnZXQgZHJ2IGFnYWluLCBzaW5jZSBpdCBtYXkgYmUgcmVtb3ZlZCBhcworCQkJICogcGFydCBvZiB0aGUgRVZFTlRfSU5URVJGQUNFX0RJU0FCTEVEIGhhbmRsaW5nIGZvcgorCQkJICogZHluYW1pYyBpbnRlcmZhY2VzCisJCQkgKi8KKwkJCWRydiA9IG5sODAyMTFfZmluZF9kcnYoZ2xvYmFsLCBpZmktPmlmaV9pbmRleCwKKwkJCQkJICAgICAgIGJ1ZiwgbGVuKTsKKwkJCWlmICghZHJ2KQorCQkJCXJldHVybjsKIAkJfQogCX0KIAogCWlmIChkcnYtPmlmX2Rpc2FibGVkICYmIChpZmktPmlmaV9mbGFncyAmIElGRl9VUCkpIHsKIAkJaWYgKGlmX2luZGV4dG9uYW1lKGlmaS0+aWZpX2luZGV4LCBuYW1lYnVmKSAmJgogCQkgICAgbGludXhfaWZhY2VfdXAoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssCi0JCQkJICAgZHJ2LT5maXJzdF9ic3MuaWZuYW1lKSA9PSAwKSB7CisJCQkJICAgZHJ2LT5maXJzdF9ic3MtPmlmbmFtZSkgPT0gMCkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJZ25vcmUgaW50ZXJmYWNlIHVwICIKIAkJCQkgICAiZXZlbnQgc2luY2UgaW50ZXJmYWNlICVzIGlzIGRvd24iLAogCQkJCSAgIG5hbWVidWYpOwotCQl9IGVsc2UgaWYgKGlmX25hbWV0b2luZGV4KGRydi0+Zmlyc3RfYnNzLmlmbmFtZSkgPT0gMCkgeworCQl9IGVsc2UgaWYgKGlmX25hbWV0b2luZGV4KGRydi0+Zmlyc3RfYnNzLT5pZm5hbWUpID09IDApIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogSWdub3JlIGludGVyZmFjZSB1cCAiCiAJCQkJICAgImV2ZW50IHNpbmNlIGludGVyZmFjZSAlcyBkb2VzIG5vdCBleGlzdCIsCi0JCQkJICAgZHJ2LT5maXJzdF9ic3MuaWZuYW1lKTsKKwkJCQkgICBkcnYtPmZpcnN0X2Jzcy0+aWZuYW1lKTsKIAkJfSBlbHNlIGlmIChkcnYtPmlmX3JlbW92ZWQpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogSWdub3JlIGludGVyZmFjZSB1cCAiCiAJCQkJICAgImV2ZW50IHNpbmNlIGludGVyZmFjZSAlcyBpcyBtYXJrZWQgIgotCQkJCSAgICJyZW1vdmVkIiwgZHJ2LT5maXJzdF9ic3MuaWZuYW1lKTsKKwkJCQkgICAicmVtb3ZlZCIsIGRydi0+Zmlyc3RfYnNzLT5pZm5hbWUpOwogCQl9IGVsc2UgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJbnRlcmZhY2UgdXAiKTsKIAkJCWRydi0+aWZfZGlzYWJsZWQgPSAwOwpAQCAtMTE3NCwyNCArMTMxMSwxNSBAQAogCSAqLwogCWlmIChkcnYtPm9wZXJzdGF0ZSA9PSAxICYmCiAJICAgIChpZmktPmlmaV9mbGFncyAmIChJRkZfTE9XRVJfVVAgfCBJRkZfRE9STUFOVCkpID09IElGRl9MT1dFUl9VUCAmJgotCSAgICAhKGlmaS0+aWZpX2ZsYWdzICYgSUZGX1JVTk5JTkcpKQorCSAgICAhKGlmaS0+aWZpX2ZsYWdzICYgSUZGX1JVTk5JTkcpKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogU2V0IElGX09QRVJfVVAgYWdhaW4gYmFzZWQgb24gaWZpX2ZsYWdzIGFuZCBleHBlY3RlZCBvcGVyc3RhdGUiKTsKIAkJbmV0bGlua19zZW5kX29wZXJfaWZsYShkcnYtPmdsb2JhbC0+bmV0bGluaywgZHJ2LT5pZmluZGV4LAogCQkJCSAgICAgICAtMSwgSUZfT1BFUl9VUCk7Ci0KLQlhdHRybGVuID0gbGVuOwotCWF0dHIgPSAoc3RydWN0IHJ0YXR0ciAqKSBidWY7Ci0JcnRhX2xlbiA9IFJUQV9BTElHTihzaXplb2Yoc3RydWN0IHJ0YXR0cikpOwotCXdoaWxlIChSVEFfT0soYXR0ciwgYXR0cmxlbikpIHsKLQkJaWYgKGF0dHItPnJ0YV90eXBlID09IElGTEFfSUZOQU1FKSB7Ci0JCQl3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfbGluaygKLQkJCQlkcnYsCi0JCQkJKChjaGFyICopIGF0dHIpICsgcnRhX2xlbiwKLQkJCQlhdHRyLT5ydGFfbGVuIC0gcnRhX2xlbiwgMCk7Ci0JCX0gZWxzZSBpZiAoYXR0ci0+cnRhX3R5cGUgPT0gSUZMQV9NQVNURVIpCi0JCQlicmlkID0gbmxhX2dldF91MzIoKHN0cnVjdCBubGF0dHIgKikgYXR0cik7Ci0JCWF0dHIgPSBSVEFfTkVYVChhdHRyLCBhdHRybGVuKTsKIAl9CiAKKwlpZiAoaWZuYW1lWzBdKQorCQl3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfbmV3bGluayhkcnYsIGlmbmFtZSk7CisKIAlpZiAoaWZpLT5pZmlfZmFtaWx5ID09IEFGX0JSSURHRSAmJiBicmlkKSB7CiAJCS8qIGRldmljZSBoYXMgYmVlbiBhZGRlZCB0byBicmlkZ2UgKi8KIAkJaWZfaW5kZXh0b25hbWUoYnJpZCwgbmFtZWJ1Zik7CkBAIC0xMjA4LDMyICsxMzM2LDQwIEBACiB7CiAJc3RydWN0IG5sODAyMTFfZ2xvYmFsICpnbG9iYWwgPSBjdHg7CiAJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnY7Ci0JaW50IGF0dHJsZW4sIHJ0YV9sZW47CisJaW50IGF0dHJsZW47CiAJc3RydWN0IHJ0YXR0ciAqYXR0cjsKIAl1MzIgYnJpZCA9IDA7CisJY2hhciBpZm5hbWVbSUZOQU1TSVogKyAxXTsKIAogCWRydiA9IG5sODAyMTFfZmluZF9kcnYoZ2xvYmFsLCBpZmktPmlmaV9pbmRleCwgYnVmLCBsZW4pOwogCWlmICghZHJ2KSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogSWdub3JlIGRlbGxpbmsgZXZlbnQgZm9yICIKLQkJCSAgICJmb3JlaWduIGlmaW5kZXggJWQiLCBpZmktPmlmaV9pbmRleCk7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogSWdub3JlIFJUTV9ERUxMSU5LIGV2ZW50IGZvciBmb3JlaWduIGlmaW5kZXggJWQiLAorCQkJICAgaWZpLT5pZmlfaW5kZXgpOwogCQlyZXR1cm47CiAJfQogCisJaWZuYW1lWzBdID0gJ1wwJzsKKwogCWF0dHJsZW4gPSBsZW47CiAJYXR0ciA9IChzdHJ1Y3QgcnRhdHRyICopIGJ1ZjsKLQotCXJ0YV9sZW4gPSBSVEFfQUxJR04oc2l6ZW9mKHN0cnVjdCBydGF0dHIpKTsKIAl3aGlsZSAoUlRBX09LKGF0dHIsIGF0dHJsZW4pKSB7Ci0JCWlmIChhdHRyLT5ydGFfdHlwZSA9PSBJRkxBX0lGTkFNRSkgewotCQkJd3BhX2RyaXZlcl9ubDgwMjExX2V2ZW50X2xpbmsoCi0JCQkJZHJ2LAotCQkJCSgoY2hhciAqKSBhdHRyKSArIHJ0YV9sZW4sCi0JCQkJYXR0ci0+cnRhX2xlbiAtIHJ0YV9sZW4sIDEpOwotCQl9IGVsc2UgaWYgKGF0dHItPnJ0YV90eXBlID09IElGTEFfTUFTVEVSKQorCQlzd2l0Y2ggKGF0dHItPnJ0YV90eXBlKSB7CisJCWNhc2UgSUZMQV9JRk5BTUU6CisJCQlpZiAoUlRBX1BBWUxPQUQoYXR0cikgPj0gSUZOQU1TSVopCisJCQkJYnJlYWs7CisJCQlvc19tZW1jcHkoaWZuYW1lLCBSVEFfREFUQShhdHRyKSwgUlRBX1BBWUxPQUQoYXR0cikpOworCQkJaWZuYW1lW1JUQV9QQVlMT0FEKGF0dHIpXSA9ICdcMCc7CisJCQlicmVhazsKKwkJY2FzZSBJRkxBX01BU1RFUjoKIAkJCWJyaWQgPSBubGFfZ2V0X3UzMigoc3RydWN0IG5sYXR0ciAqKSBhdHRyKTsKKwkJCWJyZWFrOworCQl9CiAJCWF0dHIgPSBSVEFfTkVYVChhdHRyLCBhdHRybGVuKTsKIAl9CiAKKwlpZiAoaWZuYW1lWzBdKQorCQl3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfZGVsbGluayhkcnYsIGlmbmFtZSk7CisKIAlpZiAoaWZpLT5pZmlfZmFtaWx5ID09IEFGX0JSSURHRSAmJiBicmlkKSB7CiAJCS8qIGRldmljZSBoYXMgYmVlbiByZW1vdmVkIGZyb20gYnJpZGdlICovCiAJCWNoYXIgbmFtZWJ1ZltJRk5BTVNJWl07CkBAIC0xMjk0LDExICsxNDMwLDEyIEBACiAJcmV0ID0gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBic3NfaW5mb19oYW5kbGVyLCAmYXJnKTsKIAltc2cgPSBOVUxMOwogCWlmIChyZXQgPT0gMCkgeworCQl1bnNpZ25lZCBpbnQgZnJlcSA9IGRydi0+bmxtb2RlID09IE5MODAyMTFfSUZUWVBFX0FESE9DID8KKwkJCWFyZy5pYnNzX2ZyZXEgOiBhcmcuYXNzb2NfZnJlcTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBPcGVyYXRpbmcgZnJlcXVlbmN5IGZvciB0aGUgIgotCQkJICAgImFzc29jaWF0ZWQgQlNTIGZyb20gc2NhbiByZXN1bHRzOiAldSBNSHoiLAotCQkJICAgYXJnLmFzc29jX2ZyZXEpOwotCQlpZiAoYXJnLmFzc29jX2ZyZXEpCi0JCQlkcnYtPmFzc29jX2ZyZXEgPSBhcmcuYXNzb2NfZnJlcTsKKwkJCSAgICJhc3NvY2lhdGVkIEJTUyBmcm9tIHNjYW4gcmVzdWx0czogJXUgTUh6IiwgZnJlcSk7CisJCWlmIChmcmVxKQorCQkJZHJ2LT5hc3NvY19mcmVxID0gZnJlcTsKIAkJcmV0dXJuIGRydi0+YXNzb2NfZnJlcTsKIAl9CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBTY2FuIHJlc3VsdCBmZXRjaCBmYWlsZWQ6IHJldD0lZCAiCkBAIC0xNDUzLDM3ICsxNTkwLDk4IEBACiB9CiAKIAotc3RhdGljIHZvaWQgbWxtZV9ldmVudF9jaF9zd2l0Y2goc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCi0JCQkJIHN0cnVjdCBubGF0dHIgKmZyZXEsIHN0cnVjdCBubGF0dHIgKnR5cGUpCitzdGF0aWMgaW50IGNhbGN1bGF0ZV9jaGFuX29mZnNldChpbnQgd2lkdGgsIGludCBmcmVxLCBpbnQgY2YxLCBpbnQgY2YyKQogeworCWludCBmcmVxMSA9IDA7CisKKwlzd2l0Y2ggKGNvbnZlcnQyd2lkdGgod2lkdGgpKSB7CisJY2FzZSBDSEFOX1dJRFRIXzIwX05PSFQ6CisJY2FzZSBDSEFOX1dJRFRIXzIwOgorCQlyZXR1cm4gMDsKKwljYXNlIENIQU5fV0lEVEhfNDA6CisJCWZyZXExID0gY2YxIC0gMTA7CisJCWJyZWFrOworCWNhc2UgQ0hBTl9XSURUSF84MDoKKwkJZnJlcTEgPSBjZjEgLSAzMDsKKwkJYnJlYWs7CisJY2FzZSBDSEFOX1dJRFRIXzE2MDoKKwkJZnJlcTEgPSBjZjEgLSA3MDsKKwkJYnJlYWs7CisJY2FzZSBDSEFOX1dJRFRIX1VOS05PV046CisJY2FzZSBDSEFOX1dJRFRIXzgwUDgwOgorCQkvKiBGSVhNRTogaW1wbGVtZW50IHRoaXMgKi8KKwkJcmV0dXJuIDA7CisJfQorCisJcmV0dXJuIChhYnMoZnJlcSAtIGZyZXExKSAvIDIwKSAlIDIgPT0gMCA/IDEgOiAtMTsKK30KKworCitzdGF0aWMgdm9pZCBtbG1lX2V2ZW50X2NoX3N3aXRjaChzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKKwkJCQkgc3RydWN0IG5sYXR0ciAqaWZpbmRleCwgc3RydWN0IG5sYXR0ciAqZnJlcSwKKwkJCQkgc3RydWN0IG5sYXR0ciAqdHlwZSwgc3RydWN0IG5sYXR0ciAqYncsCisJCQkJIHN0cnVjdCBubGF0dHIgKmNmMSwgc3RydWN0IG5sYXR0ciAqY2YyKQoreworCXN0cnVjdCBpODAyX2JzcyAqYnNzOwogCXVuaW9uIHdwYV9ldmVudF9kYXRhIGRhdGE7CiAJaW50IGh0X2VuYWJsZWQgPSAxOwogCWludCBjaGFuX29mZnNldCA9IDA7CisJaW50IGlmaWR4OwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBDaGFubmVsIHN3aXRjaCBldmVudCIpOwogCi0JaWYgKCFmcmVxIHx8ICF0eXBlKQorCWlmICghZnJlcSkKIAkJcmV0dXJuOwogCi0Jc3dpdGNoIChubGFfZ2V0X3UzMih0eXBlKSkgewotCWNhc2UgTkw4MDIxMV9DSEFOX05PX0hUOgotCQlodF9lbmFibGVkID0gMDsKLQkJYnJlYWs7Ci0JY2FzZSBOTDgwMjExX0NIQU5fSFQyMDoKLQkJYnJlYWs7Ci0JY2FzZSBOTDgwMjExX0NIQU5fSFQ0MFBMVVM6Ci0JCWNoYW5fb2Zmc2V0ID0gMTsKLQkJYnJlYWs7Ci0JY2FzZSBOTDgwMjExX0NIQU5fSFQ0ME1JTlVTOgotCQljaGFuX29mZnNldCA9IC0xOwotCQlicmVhazsKKwlpZmlkeCA9IG5sYV9nZXRfdTMyKGlmaW5kZXgpOworCWZvciAoYnNzID0gZHJ2LT5maXJzdF9ic3M7IGJzczsgYnNzID0gYnNzLT5uZXh0KQorCQlpZiAoYnNzLT5pZmluZGV4ID09IGlmaWR4KQorCQkJYnJlYWs7CisKKwlpZiAoYnNzID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIm5sODAyMTE6IFVua25vd24gaWZpbmRleCAoJWQpIGZvciBjaGFubmVsIHN3aXRjaCwgaWdub3JpbmciLAorCQkJICAgaWZpZHgpOworCQlyZXR1cm47CiAJfQogCisJaWYgKHR5cGUpIHsKKwkJc3dpdGNoIChubGFfZ2V0X3UzMih0eXBlKSkgeworCQljYXNlIE5MODAyMTFfQ0hBTl9OT19IVDoKKwkJCWh0X2VuYWJsZWQgPSAwOworCQkJYnJlYWs7CisJCWNhc2UgTkw4MDIxMV9DSEFOX0hUMjA6CisJCQlicmVhazsKKwkJY2FzZSBOTDgwMjExX0NIQU5fSFQ0MFBMVVM6CisJCQljaGFuX29mZnNldCA9IDE7CisJCQlicmVhazsKKwkJY2FzZSBOTDgwMjExX0NIQU5fSFQ0ME1JTlVTOgorCQkJY2hhbl9vZmZzZXQgPSAtMTsKKwkJCWJyZWFrOworCQl9CisJfSBlbHNlIGlmIChidyAmJiBjZjEpIHsKKwkJLyogVGhpcyBjYW4gaGFwcGVuIGZvciBleGFtcGxlIHdpdGggVkhUODAgY2ggc3dpdGNoICovCisJCWNoYW5fb2Zmc2V0ID0gY2FsY3VsYXRlX2NoYW5fb2Zmc2V0KG5sYV9nZXRfdTMyKGJ3KSwKKwkJCQkJCSAgICBubGFfZ2V0X3UzMihmcmVxKSwKKwkJCQkJCSAgICBubGFfZ2V0X3UzMihjZjEpLAorCQkJCQkJICAgIGNmMiA/IG5sYV9nZXRfdTMyKGNmMikgOiAwKTsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAibmw4MDIxMTogVW5rbm93biBzZWNvbmRhcnkgY2hhbm5lbCBpbmZvcm1hdGlvbiAtIGZvbGxvd2luZyBjaGFubmVsIGRlZmluaXRpb24gY2FsY3VsYXRpb25zIG1heSBmYWlsIik7CisJfQorCisJb3NfbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOwogCWRhdGEuY2hfc3dpdGNoLmZyZXEgPSBubGFfZ2V0X3UzMihmcmVxKTsKIAlkYXRhLmNoX3N3aXRjaC5odF9lbmFibGVkID0gaHRfZW5hYmxlZDsKIAlkYXRhLmNoX3N3aXRjaC5jaF9vZmZzZXQgPSBjaGFuX29mZnNldDsKKwlpZiAoYncpCisJCWRhdGEuY2hfc3dpdGNoLmNoX3dpZHRoID0gY29udmVydDJ3aWR0aChubGFfZ2V0X3UzMihidykpOworCWlmIChjZjEpCisJCWRhdGEuY2hfc3dpdGNoLmNmMSA9IG5sYV9nZXRfdTMyKGNmMSk7CisJaWYgKGNmMikKKwkJZGF0YS5jaF9zd2l0Y2guY2YyID0gbmxhX2dldF91MzIoY2YyKTsKIAotCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9DSF9TV0lUQ0gsICZkYXRhKTsKKwlic3MtPmZyZXEgPSBkYXRhLmNoX3N3aXRjaC5mcmVxOworCisJd3BhX3N1cHBsaWNhbnRfZXZlbnQoYnNzLT5jdHgsIEVWRU5UX0NIX1NXSVRDSCwgJmRhdGEpOwogfQogCiAKQEAgLTE1MTIsMTkgKzE3MTAsMjEgQEAKIH0KIAogCi1zdGF0aWMgdm9pZCBtbG1lX2V2ZW50X21nbXQoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCitzdGF0aWMgdm9pZCBtbG1lX2V2ZW50X21nbXQoc3RydWN0IGk4MDJfYnNzICpic3MsCiAJCQkgICAgc3RydWN0IG5sYXR0ciAqZnJlcSwgc3RydWN0IG5sYXR0ciAqc2lnLAogCQkJICAgIGNvbnN0IHU4ICpmcmFtZSwgc2l6ZV90IGxlbikKIHsKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OwogCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKIAl1bmlvbiB3cGFfZXZlbnRfZGF0YSBldmVudDsKIAl1MTYgZmMsIHN0eXBlOwogCWludCBzc2lfc2lnbmFsID0gMDsKKwlpbnQgcnhfZnJlcSA9IDA7CiAKIAl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAibmw4MDIxMTogRnJhbWUgZXZlbnQiKTsKIAltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBmcmFtZTsKIAlpZiAobGVuIDwgMjQpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBUb28gc2hvcnQgYWN0aW9uIGZyYW1lIik7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogVG9vIHNob3J0IG1hbmFnZW1lbnQgZnJhbWUiKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMTUzNiwyMyArMTczNiwxOSBAQAogCiAJb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7CiAJaWYgKGZyZXEpIHsKLQkJZXZlbnQucnhfYWN0aW9uLmZyZXEgPSBubGFfZ2V0X3UzMihmcmVxKTsKLQkJZHJ2LT5sYXN0X21nbXRfZnJlcSA9IGV2ZW50LnJ4X2FjdGlvbi5mcmVxOworCQlldmVudC5yeF9tZ210LmZyZXEgPSBubGFfZ2V0X3UzMihmcmVxKTsKKwkJcnhfZnJlcSA9IGRydi0+bGFzdF9tZ210X2ZyZXEgPSBldmVudC5yeF9tZ210LmZyZXE7CiAJfQotCWlmIChzdHlwZSA9PSBXTEFOX0ZDX1NUWVBFX0FDVElPTikgewotCQlldmVudC5yeF9hY3Rpb24uZGEgPSBtZ210LT5kYTsKLQkJZXZlbnQucnhfYWN0aW9uLnNhID0gbWdtdC0+c2E7Ci0JCWV2ZW50LnJ4X2FjdGlvbi5ic3NpZCA9IG1nbXQtPmJzc2lkOwotCQlldmVudC5yeF9hY3Rpb24uY2F0ZWdvcnkgPSBtZ210LT51LmFjdGlvbi5jYXRlZ29yeTsKLQkJZXZlbnQucnhfYWN0aW9uLmRhdGEgPSAmbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgKyAxOwotCQlldmVudC5yeF9hY3Rpb24ubGVuID0gZnJhbWUgKyBsZW4gLSBldmVudC5yeF9hY3Rpb24uZGF0YTsKLQkJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX1JYX0FDVElPTiwgJmV2ZW50KTsKLQl9IGVsc2UgewotCQlldmVudC5yeF9tZ210LmZyYW1lID0gZnJhbWU7Ci0JCWV2ZW50LnJ4X21nbXQuZnJhbWVfbGVuID0gbGVuOwotCQlldmVudC5yeF9tZ210LnNzaV9zaWduYWwgPSBzc2lfc2lnbmFsOwotCQl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfUlhfTUdNVCwgJmV2ZW50KTsKLQl9CisJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCSAgICJubDgwMjExOiBSWCBmcmFtZSBzYT0iIE1BQ1NUUgorCQkgICAiIGZyZXE9JWQgc3NpX3NpZ25hbD0lZCBzdHlwZT0ldSAoJXMpIGxlbj0ldSIsCisJCSAgIE1BQzJTVFIobWdtdC0+c2EpLCByeF9mcmVxLCBzc2lfc2lnbmFsLCBzdHlwZSwgZmMyc3RyKGZjKSwKKwkJICAgKHVuc2lnbmVkIGludCkgbGVuKTsKKwlldmVudC5yeF9tZ210LmZyYW1lID0gZnJhbWU7CisJZXZlbnQucnhfbWdtdC5mcmFtZV9sZW4gPSBsZW47CisJZXZlbnQucnhfbWdtdC5zc2lfc2lnbmFsID0gc3NpX3NpZ25hbDsKKwlldmVudC5yeF9tZ210LmRydl9wcml2ID0gYnNzOworCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9SWF9NR01ULCAmZXZlbnQpOwogfQogCiAKQEAgLTE2NTMsNyArMTg0OSw3IEBACiAKIAlpZiAodHlwZSA9PSBFVkVOVF9ESVNBU1NPQykgewogCQlldmVudC5kaXNhc3NvY19pbmZvLmxvY2FsbHlfZ2VuZXJhdGVkID0KLQkJCSFvc19tZW1jbXAobWdtdC0+c2EsIGRydi0+Zmlyc3RfYnNzLmFkZHIsIEVUSF9BTEVOKTsKKwkJCSFvc19tZW1jbXAobWdtdC0+c2EsIGRydi0+Zmlyc3RfYnNzLT5hZGRyLCBFVEhfQUxFTik7CiAJCWV2ZW50LmRpc2Fzc29jX2luZm8uYWRkciA9IGJzc2lkOwogCQlldmVudC5kaXNhc3NvY19pbmZvLnJlYXNvbl9jb2RlID0gcmVhc29uX2NvZGU7CiAJCWlmIChmcmFtZSArIGxlbiA+IG1nbXQtPnUuZGlzYXNzb2MudmFyaWFibGUpIHsKQEAgLTE2NjIsOCArMTg1OCwyMSBAQAogCQkJCW1nbXQtPnUuZGlzYXNzb2MudmFyaWFibGU7CiAJCX0KIAl9IGVsc2UgeworCQlpZiAoZHJ2LT5pZ25vcmVfZGVhdXRoX2V2ZW50KSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZSBkZWF1dGggZXZlbnQgZHVlIHRvIHByZXZpb3VzIGZvcmNlZCBkZWF1dGgtZHVyaW5nLWF1dGgiKTsKKwkJCWRydi0+aWdub3JlX2RlYXV0aF9ldmVudCA9IDA7CisJCQlyZXR1cm47CisJCX0KIAkJZXZlbnQuZGVhdXRoX2luZm8ubG9jYWxseV9nZW5lcmF0ZWQgPQotCQkJIW9zX21lbWNtcChtZ210LT5zYSwgZHJ2LT5maXJzdF9ic3MuYWRkciwgRVRIX0FMRU4pOworCQkJIW9zX21lbWNtcChtZ210LT5zYSwgZHJ2LT5maXJzdF9ic3MtPmFkZHIsIEVUSF9BTEVOKTsKKwkJaWYgKGRydi0+aWdub3JlX25leHRfbG9jYWxfZGVhdXRoKSB7CisJCQlkcnYtPmlnbm9yZV9uZXh0X2xvY2FsX2RlYXV0aCA9IDA7CisJCQlpZiAoZXZlbnQuZGVhdXRoX2luZm8ubG9jYWxseV9nZW5lcmF0ZWQpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZSBkZWF1dGggZXZlbnQgdHJpZ2dlcmVkIGR1ZSB0byBvd24gZGVhdXRoIHJlcXVlc3QiKTsKKwkJCQlyZXR1cm47CisJCQl9CisJCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAibmw4MDIxMTogV2FzIGV4cGVjdGluZyBsb2NhbCBkZWF1dGggYnV0IGdvdCBhbm90aGVyIGRpc2Nvbm5lY3QgZXZlbnQgZmlyc3QiKTsKKwkJfQogCQlldmVudC5kZWF1dGhfaW5mby5hZGRyID0gYnNzaWQ7CiAJCWV2ZW50LmRlYXV0aF9pbmZvLnJlYXNvbl9jb2RlID0gcmVhc29uX2NvZGU7CiAJCWlmIChmcmFtZSArIGxlbiA+IG1nbXQtPnUuZGVhdXRoLnZhcmlhYmxlKSB7CkBAIC0xNzc2LDcgKzE5ODUsNyBAQAogCQkJCQkgICBubGFfZGF0YShmcmFtZSksIG5sYV9sZW4oZnJhbWUpKTsKIAkJYnJlYWs7CiAJY2FzZSBOTDgwMjExX0NNRF9GUkFNRToKLQkJbWxtZV9ldmVudF9tZ210KGRydiwgZnJlcSwgc2lnLCBubGFfZGF0YShmcmFtZSksCisJCW1sbWVfZXZlbnRfbWdtdChic3MsIGZyZXEsIHNpZywgbmxhX2RhdGEoZnJhbWUpLAogCQkJCW5sYV9sZW4oZnJhbWUpKTsKIAkJYnJlYWs7CiAJY2FzZSBOTDgwMjExX0NNRF9GUkFNRV9UWF9TVEFUVVM6CkBAIC0xODM2LDcgKzIwNDUsNyBAQAogc3RhdGljIHZvaWQgbWxtZV9ldmVudF9qb2luX2lic3Moc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCiAJCQkJIHN0cnVjdCBubGF0dHIgKnRiW10pCiB7Ci0JdTE2IHR5cGUgPSAoV0xBTl9GQ19UWVBFX01HTVQgPDwgMikgfCAoV0xBTl9GQ19TVFlQRV9BVVRIIDw8IDQpOworCXVuc2lnbmVkIGludCBmcmVxOwogCiAJaWYgKHRiW05MODAyMTFfQVRUUl9NQUNdID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBObyBhZGRyZXNzIGluIElCU1Mgam9pbmVkICIKQEAgLTE4NDUsMTQgKzIwNTQsMTcgQEAKIAl9CiAJb3NfbWVtY3B5KGRydi0+YnNzaWQsIG5sYV9kYXRhKHRiW05MODAyMTFfQVRUUl9NQUNdKSwgRVRIX0FMRU4pOwogCi0JLyogcmVnaXN0ZXIgZm9yIGFueSBBVVRIIG1lc3NhZ2UgKi8KLQlubDgwMjExX3JlZ2lzdGVyX2ZyYW1lKCZkcnYtPmZpcnN0X2JzcywgZHJ2LT5maXJzdF9ic3MubmxfbWdtdCwKLQkJCSAgICAgICB0eXBlLCBOVUxMLCAwKTsKLQogCWRydi0+YXNzb2NpYXRlZCA9IDE7CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJQlNTICIgTUFDU1RSICIgam9pbmVkIiwKIAkJICAgTUFDMlNUUihkcnYtPmJzc2lkKSk7CiAKKwlmcmVxID0gbmw4MDIxMV9nZXRfYXNzb2NfZnJlcShkcnYpOworCWlmIChmcmVxKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogSUJTUyBvbiBmcmVxdWVuY3kgJXUgTUh6IiwKKwkJCSAgIGZyZXEpOworCQlkcnYtPmZpcnN0X2Jzcy0+ZnJlcSA9IGZyZXE7CisJfQorCiAJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX0FTU09DLCBOVUxMKTsKIH0KIApAQCAtMTk2MiwyMSArMjE3NCwzNiBAQAogCQkJCSZpbmZvLT5zc2lkc1tpbmZvLT5udW1fc3NpZHNdOwogCQkJcy0+c3NpZCA9IG5sYV9kYXRhKG5sKTsKIAkJCXMtPnNzaWRfbGVuID0gbmxhX2xlbihubCk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNjYW4gcHJvYmVkIGZvciBTU0lEICclcyciLAorCQkJCSAgIHdwYV9zc2lkX3R4dChzLT5zc2lkLCBzLT5zc2lkX2xlbikpOwogCQkJaW5mby0+bnVtX3NzaWRzKys7CiAJCQlpZiAoaW5mby0+bnVtX3NzaWRzID09IFdQQVNfTUFYX1NDQU5fU1NJRFMpCiAJCQkJYnJlYWs7CiAJCX0KIAl9CiAJaWYgKHRiW05MODAyMTFfQVRUUl9TQ0FOX0ZSRVFVRU5DSUVTXSkgeworCQljaGFyIG1zZ1syMDBdLCAqcG9zLCAqZW5kOworCQlpbnQgcmVzOworCisJCXBvcyA9IG1zZzsKKwkJZW5kID0gcG9zICsgc2l6ZW9mKG1zZyk7CisJCSpwb3MgPSAnXDAnOworCiAJCW5sYV9mb3JfZWFjaF9uZXN0ZWQobmwsIHRiW05MODAyMTFfQVRUUl9TQ0FOX0ZSRVFVRU5DSUVTXSwgcmVtKQogCQl7CiAJCQlmcmVxc1tudW1fZnJlcXNdID0gbmxhX2dldF91MzIobmwpOworCQkJcmVzID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgJWQiLAorCQkJCQkgIGZyZXFzW251bV9mcmVxc10pOworCQkJaWYgKHJlcyA+IDAgJiYgZW5kIC0gcG9zID4gcmVzKQorCQkJCXBvcyArPSByZXM7CiAJCQludW1fZnJlcXMrKzsKIAkJCWlmIChudW1fZnJlcXMgPT0gTUFYX1JFUE9SVF9GUkVRUyAtIDEpCiAJCQkJYnJlYWs7CiAJCX0KIAkJaW5mby0+ZnJlcXMgPSBmcmVxczsKIAkJaW5mby0+bnVtX2ZyZXFzID0gbnVtX2ZyZXFzOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNjYW4gaW5jbHVkZWQgZnJlcXVlbmNpZXM6JXMiLAorCQkJICAgbXNnKTsKIAl9CiAJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX1NDQU5fUkVTVUxUUywgJmV2ZW50KTsKIH0KQEAgLTI1MTQsMTEgKzI3NDEsNDMgQEAKIAkJcmV0dXJuOwogCiAJb3NfbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOwotCWRhdGEuZGZzX2V2ZW50LmZyZXEgPSBubGFfZ2V0X3UxNih0YltOTDgwMjExX0FUVFJfV0lQSFlfRlJFUV0pOwotCWV2ZW50X3R5cGUgPSBubGFfZ2V0X3U4KHRiW05MODAyMTFfQVRUUl9SQURBUl9FVkVOVF0pOworCWRhdGEuZGZzX2V2ZW50LmZyZXEgPSBubGFfZ2V0X3UzMih0YltOTDgwMjExX0FUVFJfV0lQSFlfRlJFUV0pOworCWV2ZW50X3R5cGUgPSBubGFfZ2V0X3UzMih0YltOTDgwMjExX0FUVFJfUkFEQVJfRVZFTlRdKTsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogREZTIGV2ZW50IG9uIGZyZXEgJWQgTUh6IiwKLQkJICAgZGF0YS5kZnNfZXZlbnQuZnJlcSk7CisJLyogQ2hlY2sgSFQgcGFyYW1zICovCisJaWYgKHRiW05MODAyMTFfQVRUUl9XSVBIWV9DSEFOTkVMX1RZUEVdKSB7CisJCWRhdGEuZGZzX2V2ZW50Lmh0X2VuYWJsZWQgPSAxOworCQlkYXRhLmRmc19ldmVudC5jaGFuX29mZnNldCA9IDA7CisKKwkJc3dpdGNoIChubGFfZ2V0X3UzMih0YltOTDgwMjExX0FUVFJfV0lQSFlfQ0hBTk5FTF9UWVBFXSkpIHsKKwkJY2FzZSBOTDgwMjExX0NIQU5fTk9fSFQ6CisJCQlkYXRhLmRmc19ldmVudC5odF9lbmFibGVkID0gMDsKKwkJCWJyZWFrOworCQljYXNlIE5MODAyMTFfQ0hBTl9IVDIwOgorCQkJYnJlYWs7CisJCWNhc2UgTkw4MDIxMV9DSEFOX0hUNDBQTFVTOgorCQkJZGF0YS5kZnNfZXZlbnQuY2hhbl9vZmZzZXQgPSAxOworCQkJYnJlYWs7CisJCWNhc2UgTkw4MDIxMV9DSEFOX0hUNDBNSU5VUzoKKwkJCWRhdGEuZGZzX2V2ZW50LmNoYW5fb2Zmc2V0ID0gLTE7CisJCQlicmVhazsKKwkJfQorCX0KKworCS8qIEdldCBWSFQgcGFyYW1zICovCisJaWYgKHRiW05MODAyMTFfQVRUUl9DSEFOTkVMX1dJRFRIXSkKKwkJZGF0YS5kZnNfZXZlbnQuY2hhbl93aWR0aCA9CisJCQljb252ZXJ0MndpZHRoKG5sYV9nZXRfdTMyKAorCQkJCQkgICAgICB0YltOTDgwMjExX0FUVFJfQ0hBTk5FTF9XSURUSF0pKTsKKwlpZiAodGJbTkw4MDIxMV9BVFRSX0NFTlRFUl9GUkVRMV0pCisJCWRhdGEuZGZzX2V2ZW50LmNmMSA9IG5sYV9nZXRfdTMyKHRiW05MODAyMTFfQVRUUl9DRU5URVJfRlJFUTFdKTsKKwlpZiAodGJbTkw4MDIxMV9BVFRSX0NFTlRFUl9GUkVRMl0pCisJCWRhdGEuZGZzX2V2ZW50LmNmMiA9IG5sYV9nZXRfdTMyKHRiW05MODAyMTFfQVRUUl9DRU5URVJfRlJFUTJdKTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogREZTIGV2ZW50IG9uIGZyZXEgJWQgTUh6LCBodDogJWQsIG9mZnNldDogJWQsIHdpZHRoOiAlZCwgY2YxOiAlZE1IeiwgY2YyOiAlZE1IeiIsCisJCSAgIGRhdGEuZGZzX2V2ZW50LmZyZXEsIGRhdGEuZGZzX2V2ZW50Lmh0X2VuYWJsZWQsCisJCSAgIGRhdGEuZGZzX2V2ZW50LmNoYW5fb2Zmc2V0LCBkYXRhLmRmc19ldmVudC5jaGFuX3dpZHRoLAorCQkgICBkYXRhLmRmc19ldmVudC5jZjEsIGRhdGEuZGZzX2V2ZW50LmNmMik7CiAKIAlzd2l0Y2ggKGV2ZW50X3R5cGUpIHsKIAljYXNlIE5MODAyMTFfUkFEQVJfREVURUNURUQ6CkBAIC0yNTU5LDEwICsyODE4LDE4MiBAQAogfQogCiAKK3N0YXRpYyB2b2lkIHFjYV9ubDgwMjExX2F2b2lkX2ZyZXEoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCisJCQkJICAgY29uc3QgdTggKmRhdGEsIHNpemVfdCBsZW4pCit7CisJdTMyIGksIGNvdW50OworCXVuaW9uIHdwYV9ldmVudF9kYXRhIGV2ZW50OworCXN0cnVjdCB3cGFfZnJlcV9yYW5nZSAqcmFuZ2UgPSBOVUxMOworCWNvbnN0IHN0cnVjdCBxY2FfYXZvaWRfZnJlcV9saXN0ICpmcmVxX3JhbmdlOworCisJZnJlcV9yYW5nZSA9IChjb25zdCBzdHJ1Y3QgcWNhX2F2b2lkX2ZyZXFfbGlzdCAqKSBkYXRhOworCWlmIChsZW4gPCBzaXplb2YoZnJlcV9yYW5nZS0+Y291bnQpKQorCQlyZXR1cm47CisKKwljb3VudCA9IGZyZXFfcmFuZ2UtPmNvdW50OworCWlmIChsZW4gPCBzaXplb2YoZnJlcV9yYW5nZS0+Y291bnQpICsKKwkgICAgY291bnQgKiBzaXplb2Yoc3RydWN0IHFjYV9hdm9pZF9mcmVxX3JhbmdlKSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZWQgdG9vIHNob3J0IGF2b2lkIGZyZXF1ZW5jeSBsaXN0IChsZW49JXUpIiwKKwkJCSAgICh1bnNpZ25lZCBpbnQpIGxlbik7CisJCXJldHVybjsKKwl9CisKKwlpZiAoY291bnQgPiAwKSB7CisJCXJhbmdlID0gb3NfY2FsbG9jKGNvdW50LCBzaXplb2Yoc3RydWN0IHdwYV9mcmVxX3JhbmdlKSk7CisJCWlmIChyYW5nZSA9PSBOVUxMKQorCQkJcmV0dXJuOworCX0KKworCW9zX21lbXNldCgmZXZlbnQsIDAsIHNpemVvZihldmVudCkpOworCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CisJCXVuc2lnbmVkIGludCBpZHggPSBldmVudC5mcmVxX3JhbmdlLm51bTsKKwkJcmFuZ2VbaWR4XS5taW4gPSBmcmVxX3JhbmdlLT5yYW5nZVtpXS5zdGFydF9mcmVxOworCQlyYW5nZVtpZHhdLm1heCA9IGZyZXFfcmFuZ2UtPnJhbmdlW2ldLmVuZF9mcmVxOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IEF2b2lkIGZyZXF1ZW5jeSByYW5nZTogJXUtJXUiLAorCQkJICAgcmFuZ2VbaWR4XS5taW4sIHJhbmdlW2lkeF0ubWF4KTsKKwkJaWYgKHJhbmdlW2lkeF0ubWluID4gcmFuZ2VbaWR4XS5tYXgpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogSWdub3JlIGludmFsaWQgZnJlcXVlbmN5IHJhbmdlIik7CisJCQljb250aW51ZTsKKwkJfQorCQlldmVudC5mcmVxX3JhbmdlLm51bSsrOworCX0KKwlldmVudC5mcmVxX3JhbmdlLnJhbmdlID0gcmFuZ2U7CisKKwl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfQVZPSURfRlJFUVVFTkNJRVMsICZldmVudCk7CisKKwlvc19mcmVlKHJhbmdlKTsKK30KKworCitzdGF0aWMgdm9pZCBubDgwMjExX3ZlbmRvcl9ldmVudF9xY2Eoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCisJCQkJICAgICB1MzIgc3ViY21kLCB1OCAqZGF0YSwgc2l6ZV90IGxlbikKK3sKKwlzd2l0Y2ggKHN1YmNtZCkgeworCWNhc2UgUUNBX05MODAyMTFfVkVORE9SX1NVQkNNRF9BVk9JRF9GUkVRVUVOQ1k6CisJCXFjYV9ubDgwMjExX2F2b2lkX2ZyZXEoZHJ2LCBkYXRhLCBsZW4pOworCQlicmVhazsKKwlkZWZhdWx0OgorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJubDgwMjExOiBJZ25vcmUgdW5zdXBwb3J0ZWQgUUNBIHZlbmRvciBldmVudCAldSIsCisJCQkgICBzdWJjbWQpOworCQlicmVhazsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgbmw4MDIxMV92ZW5kb3JfZXZlbnQoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCisJCQkJIHN0cnVjdCBubGF0dHIgKip0YikKK3sKKwl1MzIgdmVuZG9yX2lkLCBzdWJjbWQsIHdpcGh5ID0gMDsKKwlpbnQgd2lwaHlfaWR4OworCXU4ICpkYXRhID0gTlVMTDsKKwlzaXplX3QgbGVuID0gMDsKKworCWlmICghdGJbTkw4MDIxMV9BVFRSX1ZFTkRPUl9JRF0gfHwKKwkgICAgIXRiW05MODAyMTFfQVRUUl9WRU5ET1JfU1VCQ01EXSkKKwkJcmV0dXJuOworCisJdmVuZG9yX2lkID0gbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX1ZFTkRPUl9JRF0pOworCXN1YmNtZCA9IG5sYV9nZXRfdTMyKHRiW05MODAyMTFfQVRUUl9WRU5ET1JfU1VCQ01EXSk7CisKKwlpZiAodGJbTkw4MDIxMV9BVFRSX1dJUEhZXSkKKwkJd2lwaHkgPSBubGFfZ2V0X3UzMih0YltOTDgwMjExX0FUVFJfV0lQSFldKTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogVmVuZG9yIGV2ZW50OiB3aXBoeT0ldSB2ZW5kb3JfaWQ9MHgleCBzdWJjbWQ9JXUiLAorCQkgICB3aXBoeSwgdmVuZG9yX2lkLCBzdWJjbWQpOworCisJaWYgKHRiW05MODAyMTFfQVRUUl9WRU5ET1JfREFUQV0pIHsKKwkJZGF0YSA9IG5sYV9kYXRhKHRiW05MODAyMTFfQVRUUl9WRU5ET1JfREFUQV0pOworCQlsZW4gPSBubGFfbGVuKHRiW05MODAyMTFfQVRUUl9WRU5ET1JfREFUQV0pOworCQl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIm5sODAyMTE6IFZlbmRvciBkYXRhIiwgZGF0YSwgbGVuKTsKKwl9CisKKwl3aXBoeV9pZHggPSBubDgwMjExX2dldF93aXBoeV9pbmRleChkcnYtPmZpcnN0X2Jzcyk7CisJaWYgKHdpcGh5X2lkeCA+PSAwICYmIHdpcGh5X2lkeCAhPSAoaW50KSB3aXBoeSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZSB2ZW5kb3IgZXZlbnQgZm9yIGZvcmVpZ24gd2lwaHkgJXUgKG93bjogJWQpIiwKKwkJCSAgIHdpcGh5LCB3aXBoeV9pZHgpOworCQlyZXR1cm47CisJfQorCisJc3dpdGNoICh2ZW5kb3JfaWQpIHsKKwljYXNlIE9VSV9RQ0E6CisJCW5sODAyMTFfdmVuZG9yX2V2ZW50X3FjYShkcnYsIHN1YmNtZCwgZGF0YSwgbGVuKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJZ25vcmUgdW5zdXBwb3J0ZWQgdmVuZG9yIGV2ZW50Iik7CisJCWJyZWFrOworCX0KK30KKworCitzdGF0aWMgdm9pZCBubDgwMjExX3JlZ19jaGFuZ2VfZXZlbnQoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCisJCQkJICAgICBzdHJ1Y3QgbmxhdHRyICp0YltdKQoreworCXVuaW9uIHdwYV9ldmVudF9kYXRhIGRhdGE7CisJZW51bSBubDgwMjExX3JlZ19pbml0aWF0b3IgaW5pdDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogUmVndWxhdG9yeSBkb21haW4gY2hhbmdlIik7CisKKwlpZiAodGJbTkw4MDIxMV9BVFRSX1JFR19JTklUSUFUT1JdID09IE5VTEwpCisJCXJldHVybjsKKworCW9zX21lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKKwlpbml0ID0gbmxhX2dldF91OCh0YltOTDgwMjExX0FUVFJfUkVHX0lOSVRJQVRPUl0pOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICogaW5pdGlhdG9yPSVkIiwgaW5pdCk7CisJc3dpdGNoIChpbml0KSB7CisJY2FzZSBOTDgwMjExX1JFR0RPTV9TRVRfQllfQ09SRToKKwkJZGF0YS5jaGFubmVsX2xpc3RfY2hhbmdlZC5pbml0aWF0b3IgPSBSRUdET01fU0VUX0JZX0NPUkU7CisJCWJyZWFrOworCWNhc2UgTkw4MDIxMV9SRUdET01fU0VUX0JZX1VTRVI6CisJCWRhdGEuY2hhbm5lbF9saXN0X2NoYW5nZWQuaW5pdGlhdG9yID0gUkVHRE9NX1NFVF9CWV9VU0VSOworCQlicmVhazsKKwljYXNlIE5MODAyMTFfUkVHRE9NX1NFVF9CWV9EUklWRVI6CisJCWRhdGEuY2hhbm5lbF9saXN0X2NoYW5nZWQuaW5pdGlhdG9yID0gUkVHRE9NX1NFVF9CWV9EUklWRVI7CisJCWJyZWFrOworCWNhc2UgTkw4MDIxMV9SRUdET01fU0VUX0JZX0NPVU5UUllfSUU6CisJCWRhdGEuY2hhbm5lbF9saXN0X2NoYW5nZWQuaW5pdGlhdG9yID0gUkVHRE9NX1NFVF9CWV9DT1VOVFJZX0lFOworCQlicmVhazsKKwl9CisKKwlpZiAodGJbTkw4MDIxMV9BVFRSX1JFR19UWVBFXSkgeworCQllbnVtIG5sODAyMTFfcmVnX3R5cGUgdHlwZTsKKwkJdHlwZSA9IG5sYV9nZXRfdTgodGJbTkw4MDIxMV9BVFRSX1JFR19UWVBFXSk7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICogdHlwZT0lZCIsIHR5cGUpOworCQlzd2l0Y2ggKHR5cGUpIHsKKwkJY2FzZSBOTDgwMjExX1JFR0RPTV9UWVBFX0NPVU5UUlk6CisJCQlkYXRhLmNoYW5uZWxfbGlzdF9jaGFuZ2VkLnR5cGUgPSBSRUdET01fVFlQRV9DT1VOVFJZOworCQkJYnJlYWs7CisJCWNhc2UgTkw4MDIxMV9SRUdET01fVFlQRV9XT1JMRDoKKwkJCWRhdGEuY2hhbm5lbF9saXN0X2NoYW5nZWQudHlwZSA9IFJFR0RPTV9UWVBFX1dPUkxEOworCQkJYnJlYWs7CisJCWNhc2UgTkw4MDIxMV9SRUdET01fVFlQRV9DVVNUT01fV09STEQ6CisJCQlkYXRhLmNoYW5uZWxfbGlzdF9jaGFuZ2VkLnR5cGUgPQorCQkJCVJFR0RPTV9UWVBFX0NVU1RPTV9XT1JMRDsKKwkJCWJyZWFrOworCQljYXNlIE5MODAyMTFfUkVHRE9NX1RZUEVfSU5URVJTRUNUSU9OOgorCQkJZGF0YS5jaGFubmVsX2xpc3RfY2hhbmdlZC50eXBlID0KKwkJCQlSRUdET01fVFlQRV9JTlRFUlNFQ1RJT047CisJCQlicmVhazsKKwkJfQorCX0KKworCWlmICh0YltOTDgwMjExX0FUVFJfUkVHX0FMUEhBMl0pIHsKKwkJb3Nfc3RybGNweShkYXRhLmNoYW5uZWxfbGlzdF9jaGFuZ2VkLmFscGhhMiwKKwkJCSAgIG5sYV9nZXRfc3RyaW5nKHRiW05MODAyMTFfQVRUUl9SRUdfQUxQSEEyXSksCisJCQkgICBzaXplb2YoZGF0YS5jaGFubmVsX2xpc3RfY2hhbmdlZC5hbHBoYTIpKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgKiBhbHBoYTI9JXMiLAorCQkJICAgZGF0YS5jaGFubmVsX2xpc3RfY2hhbmdlZC5hbHBoYTIpOworCX0KKworCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9DSEFOTkVMX0xJU1RfQ0hBTkdFRCwgJmRhdGEpOworfQorCisKIHN0YXRpYyB2b2lkIGRvX3Byb2Nlc3NfZHJ2X2V2ZW50KHN0cnVjdCBpODAyX2JzcyAqYnNzLCBpbnQgY21kLAogCQkJCSBzdHJ1Y3QgbmxhdHRyICoqdGIpCiB7CiAJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKKwl1bmlvbiB3cGFfZXZlbnRfZGF0YSBkYXRhOwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBEcnYgRXZlbnQgJWQgKCVzKSByZWNlaXZlZCBmb3IgJXMiLAogCQkgICBjbWQsIG5sODAyMTFfY29tbWFuZF90b19zdHJpbmcoY21kKSwgYnNzLT5pZm5hbWUpOwpAQCAtMjU3MCw3ICszMDAxLDcgQEAKIAlpZiAoZHJ2LT5hcF9zY2FuX2FzX3N0YXRpb24gIT0gTkw4MDIxMV9JRlRZUEVfVU5TUEVDSUZJRUQgJiYKIAkgICAgKGNtZCA9PSBOTDgwMjExX0NNRF9ORVdfU0NBTl9SRVNVTFRTIHx8CiAJICAgICBjbWQgPT0gTkw4MDIxMV9DTURfU0NBTl9BQk9SVEVEKSkgewotCQl3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGUoJmRydi0+Zmlyc3RfYnNzLAorCQl3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGUoZHJ2LT5maXJzdF9ic3MsCiAJCQkJCSAgICBkcnYtPmFwX3NjYW5fYXNfc3RhdGlvbik7CiAJCWRydi0+YXBfc2Nhbl9hc19zdGF0aW9uID0gTkw4MDIxMV9JRlRZUEVfVU5TUEVDSUZJRUQ7CiAJfQpAQCAtMjU3OCwxNyArMzAwOSwzMiBAQAogCXN3aXRjaCAoY21kKSB7CiAJY2FzZSBOTDgwMjExX0NNRF9UUklHR0VSX1NDQU46CiAJCXdwYV9kYmcoZHJ2LT5jdHgsIE1TR19ERUJVRywgIm5sODAyMTE6IFNjYW4gdHJpZ2dlciIpOworCQlkcnYtPnNjYW5fc3RhdGUgPSBTQ0FOX1NUQVJURUQ7CisJCWlmIChkcnYtPnNjYW5fZm9yX2F1dGgpIHsKKwkJCS8qCisJCQkgKiBDYW5ub3QgaW5kaWNhdGUgRVZFTlRfU0NBTl9TVEFSVEVEIGhlcmUgc2luY2Ugd2Ugc2tpcAorCQkJICogRVZFTlRfU0NBTl9SRVNVTFRTIGluIHNjYW5fZm9yX2F1dGggY2FzZSBhbmQgdGhlCisJCQkgKiB1cHBlciBsYXllciBpbXBsZW1lbnRhdGlvbiBjb3VsZCBnZXQgY29uZnVzZWQgYWJvdXQKKwkJCSAqIHNjYW5uaW5nIHN0YXRlLgorCQkJICovCisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IERvIG5vdCBpbmRpY2F0ZSBzY2FuLXN0YXJ0IGV2ZW50IGR1ZSB0byBpbnRlcm5hbCBzY2FuX2Zvcl9hdXRoIik7CisJCQlicmVhazsKKwkJfQorCQl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfU0NBTl9TVEFSVEVELCBOVUxMKTsKIAkJYnJlYWs7CiAJY2FzZSBOTDgwMjExX0NNRF9TVEFSVF9TQ0hFRF9TQ0FOOgogCQl3cGFfZGJnKGRydi0+Y3R4LCBNU0dfREVCVUcsICJubDgwMjExOiBTY2hlZCBzY2FuIHN0YXJ0ZWQiKTsKKwkJZHJ2LT5zY2FuX3N0YXRlID0gU0NIRURfU0NBTl9TVEFSVEVEOwogCQlicmVhazsKIAljYXNlIE5MODAyMTFfQ01EX1NDSEVEX1NDQU5fU1RPUFBFRDoKIAkJd3BhX2RiZyhkcnYtPmN0eCwgTVNHX0RFQlVHLCAibmw4MDIxMTogU2NoZWQgc2NhbiBzdG9wcGVkIik7CisJCWRydi0+c2Nhbl9zdGF0ZSA9IFNDSEVEX1NDQU5fU1RPUFBFRDsKIAkJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX1NDSEVEX1NDQU5fU1RPUFBFRCwgTlVMTCk7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DTURfTkVXX1NDQU5fUkVTVUxUUzoKIAkJd3BhX2RiZyhkcnYtPmN0eCwgTVNHX0RFQlVHLAogCQkJIm5sODAyMTE6IE5ldyBzY2FuIHJlc3VsdHMgYXZhaWxhYmxlIik7CisJCWRydi0+c2Nhbl9zdGF0ZSA9IFNDQU5fQ09NUExFVEVEOwogCQlkcnYtPnNjYW5fY29tcGxldGVfZXZlbnRzID0gMTsKIAkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3BhX2RyaXZlcl9ubDgwMjExX3NjYW5fdGltZW91dCwgZHJ2LAogCQkJCSAgICAgZHJ2LT5jdHgpOwpAQCAtMjU5NywxMCArMzA0MywxMiBAQAogCWNhc2UgTkw4MDIxMV9DTURfU0NIRURfU0NBTl9SRVNVTFRTOgogCQl3cGFfZGJnKGRydi0+Y3R4LCBNU0dfREVCVUcsCiAJCQkibmw4MDIxMTogTmV3IHNjaGVkIHNjYW4gcmVzdWx0cyBhdmFpbGFibGUiKTsKKwkJZHJ2LT5zY2FuX3N0YXRlID0gU0NIRURfU0NBTl9SRVNVTFRTOwogCQlzZW5kX3NjYW5fZXZlbnQoZHJ2LCAwLCB0Yik7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DTURfU0NBTl9BQk9SVEVEOgogCQl3cGFfZGJnKGRydi0+Y3R4LCBNU0dfREVCVUcsICJubDgwMjExOiBTY2FuIGFib3J0ZWQiKTsKKwkJZHJ2LT5zY2FuX3N0YXRlID0gU0NBTl9BQk9SVEVEOwogCQkvKgogCQkgKiBOZWVkIHRvIGluZGljYXRlIHRoYXQgc2NhbiByZXN1bHRzIGFyZSBhdmFpbGFibGUgaW4gb3JkZXIKIAkJICogbm90IHRvIG1ha2Ugd3BhX3N1cHBsaWNhbnQgc3RvcCBpdHMgc2Nhbm5pbmcuCkBAIC0yNjMxLDggKzMwNzksMTMgQEAKIAkJCQkgICB0YltOTDgwMjExX0FUVFJfUkVTUF9JRV0pOwogCQlicmVhazsKIAljYXNlIE5MODAyMTFfQ01EX0NIX1NXSVRDSF9OT1RJRlk6Ci0JCW1sbWVfZXZlbnRfY2hfc3dpdGNoKGRydiwgdGJbTkw4MDIxMV9BVFRSX1dJUEhZX0ZSRVFdLAotCQkJCSAgICAgdGJbTkw4MDIxMV9BVFRSX1dJUEhZX0NIQU5ORUxfVFlQRV0pOworCQltbG1lX2V2ZW50X2NoX3N3aXRjaChkcnYsCisJCQkJICAgICB0YltOTDgwMjExX0FUVFJfSUZJTkRFWF0sCisJCQkJICAgICB0YltOTDgwMjExX0FUVFJfV0lQSFlfRlJFUV0sCisJCQkJICAgICB0YltOTDgwMjExX0FUVFJfV0lQSFlfQ0hBTk5FTF9UWVBFXSwKKwkJCQkgICAgIHRiW05MODAyMTFfQVRUUl9DSEFOTkVMX1dJRFRIXSwKKwkJCQkgICAgIHRiW05MODAyMTFfQVRUUl9DRU5URVJfRlJFUTFdLAorCQkJCSAgICAgdGJbTkw4MDIxMV9BVFRSX0NFTlRFUl9GUkVRMl0pOwogCQlicmVhazsKIAljYXNlIE5MODAyMTFfQ01EX0RJU0NPTk5FQ1Q6CiAJCW1sbWVfZXZlbnRfZGlzY29ubmVjdChkcnYsIHRiW05MODAyMTFfQVRUUl9SRUFTT05fQ09ERV0sCkBAIC0yNjU1LDE0ICszMTA4LDE0IEBACiAJCW5sODAyMTFfY3FtX2V2ZW50KGRydiwgdGIpOwogCQlicmVhazsKIAljYXNlIE5MODAyMTFfQ01EX1JFR19DSEFOR0U6Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogUmVndWxhdG9yeSBkb21haW4gY2hhbmdlIik7Ci0JCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9DSEFOTkVMX0xJU1RfQ0hBTkdFRCwKLQkJCQkgICAgIE5VTEwpOworCQlubDgwMjExX3JlZ19jaGFuZ2VfZXZlbnQoZHJ2LCB0Yik7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DTURfUkVHX0JFQUNPTl9ISU5UOgogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFJlZ3VsYXRvcnkgYmVhY29uIGhpbnQiKTsKKwkJb3NfbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOworCQlkYXRhLmNoYW5uZWxfbGlzdF9jaGFuZ2VkLmluaXRpYXRvciA9IFJFR0RPTV9CRUFDT05fSElOVDsKIAkJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX0NIQU5ORUxfTElTVF9DSEFOR0VELAotCQkJCSAgICAgTlVMTCk7CisJCQkJICAgICAmZGF0YSk7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DTURfTkVXX1NUQVRJT046CiAJCW5sODAyMTFfbmV3X3N0YXRpb25fZXZlbnQoZHJ2LCB0Yik7CkBAIC0yNjk0LDYgKzMxNDcsOSBAQAogCWNhc2UgTkw4MDIxMV9DTURfU1RPUF9BUDoKIAkJbmw4MDIxMV9zdG9wX2FwKGRydiwgdGIpOwogCQlicmVhazsKKwljYXNlIE5MODAyMTFfQ01EX1ZFTkRPUjoKKwkJbmw4MDIxMV92ZW5kb3JfZXZlbnQoZHJ2LCB0Yik7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXdwYV9kYmcoZHJ2LT5jdHgsIE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZWQgdW5rbm93biBldmVudCAiCiAJCQkiKGNtZD0lZCkiLCBjbWQpOwpAQCAtMjcxNiw3ICszMTcyLDcgQEAKIAlpZiAodGJbTkw4MDIxMV9BVFRSX0lGSU5ERVhdKSB7CiAJCWlmaWR4ID0gbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX0lGSU5ERVhdKTsKIAotCQlmb3IgKGJzcyA9ICZkcnYtPmZpcnN0X2JzczsgYnNzOyBic3MgPSBic3MtPm5leHQpCisJCWZvciAoYnNzID0gZHJ2LT5maXJzdF9ic3M7IGJzczsgYnNzID0gYnNzLT5uZXh0KQogCQkJaWYgKGlmaWR4ID09IC0xIHx8IGlmaWR4ID09IGJzcy0+aWZpbmRleCkgewogCQkJCWRvX3Byb2Nlc3NfZHJ2X2V2ZW50KGJzcywgZ25saC0+Y21kLCB0Yik7CiAJCQkJcmV0dXJuIE5MX1NLSVA7CkBAIC0yNzI3LDcgKzMxODMsNyBAQAogCX0gZWxzZSBpZiAodGJbTkw4MDIxMV9BVFRSX1dERVZdKSB7CiAJCXU2NCB3ZGV2X2lkID0gbmxhX2dldF91NjQodGJbTkw4MDIxMV9BVFRSX1dERVZdKTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBQcm9jZXNzIGV2ZW50IG9uIFAyUCBkZXZpY2UiKTsKLQkJZm9yIChic3MgPSAmZHJ2LT5maXJzdF9ic3M7IGJzczsgYnNzID0gYnNzLT5uZXh0KSB7CisJCWZvciAoYnNzID0gZHJ2LT5maXJzdF9ic3M7IGJzczsgYnNzID0gYnNzLT5uZXh0KSB7CiAJCQlpZiAoYnNzLT53ZGV2X2lkX3NldCAmJiB3ZGV2X2lkID09IGJzcy0+d2Rldl9pZCkgewogCQkJCWRvX3Byb2Nlc3NfZHJ2X2V2ZW50KGJzcywgZ25saC0+Y21kLCB0Yik7CiAJCQkJcmV0dXJuIE5MX1NLSVA7CkBAIC0yNzY1LDcgKzMyMjEsNyBAQAogCiAJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKGRydiwgdG1wLCAmZ2xvYmFsLT5pbnRlcmZhY2VzLAogCQkJICAgICAgc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhLCBsaXN0KSB7Ci0JCWZvciAoYnNzID0gJmRydi0+Zmlyc3RfYnNzOyBic3M7IGJzcyA9IGJzcy0+bmV4dCkgeworCQlmb3IgKGJzcyA9IGRydi0+Zmlyc3RfYnNzOyBic3M7IGJzcyA9IGJzcy0+bmV4dCkgewogCQkJaWYgKChpZmlkeCA9PSAtMSAmJiAhd2Rldl9pZF9zZXQpIHx8CiAJCQkgICAgaWZpZHggPT0gYnNzLT5pZmluZGV4IHx8CiAJCQkgICAgKHdkZXZfaWRfc2V0ICYmIGJzcy0+d2Rldl9pZF9zZXQgJiYKQEAgLTI4MjIsMTAgKzMyNzgsMTUgQEAKIAkJCQkJICAgICB2b2lkICpoYW5kbGUpCiB7CiAJc3RydWN0IG5sX2NiICpjYiA9IGVsb29wX2N0eDsKKwlpbnQgcmVzOwogCiAJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIm5sODAyMTE6IEV2ZW50IG1lc3NhZ2UgYXZhaWxhYmxlIik7CiAKLQlubF9yZWN2bXNncyhoYW5kbGUsIGNiKTsKKwlyZXMgPSBubF9yZWN2bXNncyhoYW5kbGUsIGNiKTsKKwlpZiAocmVzIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAibmw4MDIxMTogJXMtPm5sX3JlY3Ztc2dzIGZhaWxlZDogJWQiLAorCQkJICAgX19mdW5jX18sIHJlcyk7CisJfQogfQogCiAKQEAgLTI4NjUsNiArMzMyNiw0NCBAQAogfQogCiAKK3N0YXRpYyBpbnQgbmw4MDIxMV9nZXRfY291bnRyeShzdHJ1Y3QgbmxfbXNnICptc2csIHZvaWQgKmFyZykKK3sKKwljaGFyICphbHBoYTIgPSBhcmc7CisJc3RydWN0IG5sYXR0ciAqdGJfbXNnW05MODAyMTFfQVRUUl9NQVggKyAxXTsKKwlzdHJ1Y3QgZ2VubG1zZ2hkciAqZ25saCA9IG5sbXNnX2RhdGEobmxtc2dfaGRyKG1zZykpOworCisJbmxhX3BhcnNlKHRiX21zZywgTkw4MDIxMV9BVFRSX01BWCwgZ2VubG1zZ19hdHRyZGF0YShnbmxoLCAwKSwKKwkJICBnZW5sbXNnX2F0dHJsZW4oZ25saCwgMCksIE5VTEwpOworCWlmICghdGJfbXNnW05MODAyMTFfQVRUUl9SRUdfQUxQSEEyXSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IE5vIGNvdW50cnkgaW5mb3JtYXRpb24gYXZhaWxhYmxlIik7CisJCXJldHVybiBOTF9TS0lQOworCX0KKwlvc19zdHJsY3B5KGFscGhhMiwgbmxhX2RhdGEodGJfbXNnW05MODAyMTFfQVRUUl9SRUdfQUxQSEEyXSksIDMpOworCXJldHVybiBOTF9TS0lQOworfQorCisKK3N0YXRpYyBpbnQgd3BhX2RyaXZlcl9ubDgwMjExX2dldF9jb3VudHJ5KHZvaWQgKnByaXYsIGNoYXIgKmFscGhhMikKK3sKKwlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CisJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKKwlzdHJ1Y3QgbmxfbXNnICptc2c7CisJaW50IHJldDsKKworCW1zZyA9IG5sbXNnX2FsbG9jKCk7CisJaWYgKCFtc2cpCisJCXJldHVybiAtRU5PTUVNOworCisJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX0dFVF9SRUcpOworCWFscGhhMlswXSA9ICdcMCc7CisJcmV0ID0gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBubDgwMjExX2dldF9jb3VudHJ5LCBhbHBoYTIpOworCWlmICghYWxwaGEyWzBdKQorCQlyZXQgPSAtMTsKKworCXJldHVybiByZXQ7Cit9CisKKwogc3RhdGljIGludCBwcm90b2NvbF9mZWF0dXJlX2hhbmRsZXIoc3RydWN0IG5sX21zZyAqbXNnLCB2b2lkICphcmcpCiB7CiAJdTMyICpmZWF0ID0gYXJnOwpAQCAtMjkxNyw2ICszNDE2LDkgQEAKIAl1bnNpZ25lZCBpbnQgcDJwX2dvX3N1cHBvcnRlZDoxOwogCXVuc2lnbmVkIGludCBwMnBfY2xpZW50X3N1cHBvcnRlZDoxOwogCXVuc2lnbmVkIGludCBwMnBfY29uY3VycmVudDoxOworCXVuc2lnbmVkIGludCBjaGFubmVsX3N3aXRjaF9zdXBwb3J0ZWQ6MTsKKwl1bnNpZ25lZCBpbnQgc2V0X3Fvc19tYXBfc3VwcG9ydGVkOjE7CisJdW5zaWduZWQgaW50IGhhdmVfbG93X3ByaW9fc2NhbjoxOwogfTsKIAogCkBAIC0zMDI1LDEwICszNTI3LDEyIEBACiAJfQogCiAJaWYgKGNvbWJpbmF0aW9uX2hhc19wMnAgJiYgY29tYmluYXRpb25faGFzX21nZCkgewotCQlpbmZvLT5wMnBfY29uY3VycmVudCA9IDE7Ci0JCWluZm8tPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCA9CisJCXVuc2lnbmVkIGludCBudW1fY2hhbm5lbHMgPQogCQkJbmxhX2dldF91MzIodGJfY29tYltOTDgwMjExX0lGQUNFX0NPTUJfTlVNX0NIQU5ORUxTXSk7Ci0JCXJldHVybiAxOworCisJCWluZm8tPnAycF9jb25jdXJyZW50ID0gMTsKKwkJaWYgKGluZm8tPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCA8IG51bV9jaGFubmVscykKKwkJCWluZm8tPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCA9IG51bV9jaGFubmVsczsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTMwNzQsNiArMzU3OCw3MSBAQAogCQljYXNlIE5MODAyMTFfQ01EX1BST0JFX0NMSUVOVDoKIAkJCWluZm8tPnBvbGxfY29tbWFuZF9zdXBwb3J0ZWQgPSAxOwogCQkJYnJlYWs7CisJCWNhc2UgTkw4MDIxMV9DTURfQ0hBTk5FTF9TV0lUQ0g6CisJCQlpbmZvLT5jaGFubmVsX3N3aXRjaF9zdXBwb3J0ZWQgPSAxOworCQkJYnJlYWs7CisJCWNhc2UgTkw4MDIxMV9DTURfU0VUX1FPU19NQVA6CisJCQlpbmZvLT5zZXRfcW9zX21hcF9zdXBwb3J0ZWQgPSAxOworCQkJYnJlYWs7CisJCX0KKwl9Cit9CisKKworc3RhdGljIHZvaWQgd2lwaHlfaW5mb19jaXBoZXJfc3VpdGVzKHN0cnVjdCB3aXBoeV9pbmZvX2RhdGEgKmluZm8sCisJCQkJICAgICBzdHJ1Y3QgbmxhdHRyICp0YikKK3sKKwlpbnQgaSwgbnVtOworCXUzMiAqY2lwaGVyczsKKworCWlmICh0YiA9PSBOVUxMKQorCQlyZXR1cm47CisKKwludW0gPSBubGFfbGVuKHRiKSAvIHNpemVvZih1MzIpOworCWNpcGhlcnMgPSBubGFfZGF0YSh0Yik7CisJZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKSB7CisJCXUzMiBjID0gY2lwaGVyc1tpXTsKKworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFN1cHBvcnRlZCBjaXBoZXIgJTAyeC0lMDJ4LSUwMng6JWQiLAorCQkJICAgYyA+PiAyNCwgKGMgPj4gMTYpICYgMHhmZiwKKwkJCSAgIChjID4+IDgpICYgMHhmZiwgYyAmIDB4ZmYpOworCQlzd2l0Y2ggKGMpIHsKKwkJY2FzZSBXTEFOX0NJUEhFUl9TVUlURV9DQ01QXzI1NjoKKwkJCWluZm8tPmNhcGEtPmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX0NDTVBfMjU2OworCQkJYnJlYWs7CisJCWNhc2UgV0xBTl9DSVBIRVJfU1VJVEVfR0NNUF8yNTY6CisJCQlpbmZvLT5jYXBhLT5lbmMgfD0gV1BBX0RSSVZFUl9DQVBBX0VOQ19HQ01QXzI1NjsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVA6CisJCQlpbmZvLT5jYXBhLT5lbmMgfD0gV1BBX0RSSVZFUl9DQVBBX0VOQ19DQ01QOworCQkJYnJlYWs7CisJCWNhc2UgV0xBTl9DSVBIRVJfU1VJVEVfR0NNUDoKKwkJCWluZm8tPmNhcGEtPmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX0dDTVA7CisJCQlicmVhazsKKwkJY2FzZSBXTEFOX0NJUEhFUl9TVUlURV9US0lQOgorCQkJaW5mby0+Y2FwYS0+ZW5jIHw9IFdQQV9EUklWRVJfQ0FQQV9FTkNfVEtJUDsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDEwNDoKKwkJCWluZm8tPmNhcGEtPmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX1dFUDEwNDsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDQwOgorCQkJaW5mby0+Y2FwYS0+ZW5jIHw9IFdQQV9EUklWRVJfQ0FQQV9FTkNfV0VQNDA7CisJCQlicmVhazsKKwkJY2FzZSBXTEFOX0NJUEhFUl9TVUlURV9BRVNfQ01BQzoKKwkJCWluZm8tPmNhcGEtPmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX0JJUDsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzEyODoKKwkJCWluZm8tPmNhcGEtPmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX0JJUF9HTUFDXzEyODsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzI1NjoKKwkJCWluZm8tPmNhcGEtPmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX0JJUF9HTUFDXzI1NjsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX0JJUF9DTUFDXzI1NjoKKwkJCWluZm8tPmNhcGEtPmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX0JJUF9DTUFDXzI1NjsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX05PX0dST1VQX0FERFI6CisJCQlpbmZvLT5jYXBhLT5lbmMgfD0gV1BBX0RSSVZFUl9DQVBBX0VOQ19HVEtfTk9UX1VTRUQ7CisJCQlicmVhazsKIAkJfQogCX0KIH0KQEAgLTMxMjUsNiArMzY5NCwxMiBAQAogCiAJaWYgKGZsYWdzICYgTkw4MDIxMV9GRUFUVVJFX05FRURfT0JTU19TQ0FOKQogCQljYXBhLT5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX09CU1NfU0NBTjsKKworCWlmIChmbGFncyAmIE5MODAyMTFfRkVBVFVSRV9BUF9NT0RFX0NIQU5fV0lEVEhfQ0hBTkdFKQorCQljYXBhLT5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX0hUXzIwNDBfQ09FWDsKKworCWlmIChmbGFncyAmIE5MODAyMTFfRkVBVFVSRV9MT1dfUFJJT1JJVFlfU0NBTikKKwkJaW5mby0+aGF2ZV9sb3dfcHJpb19zY2FuID0gMTsKIH0KIAogCkBAIC0zMTQ0LDYgKzM3MTksMzUgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3aXBoeV9pbmZvX3dvd2xhbl90cmlnZ2VycyhzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhLAorCQkJCSAgICAgICBzdHJ1Y3QgbmxhdHRyICp0YikKK3sKKwlzdHJ1Y3QgbmxhdHRyICp0cmlnZ2Vyc1tNQVhfTkw4MDIxMV9XT1dMQU5fVFJJRyArIDFdOworCisJaWYgKHRiID09IE5VTEwpCisJCXJldHVybjsKKworCWlmIChubGFfcGFyc2VfbmVzdGVkKHRyaWdnZXJzLCBNQVhfTkw4MDIxMV9XT1dMQU5fVFJJRywKKwkJCSAgICAgdGIsIE5VTEwpKQorCQlyZXR1cm47CisKKwlpZiAodHJpZ2dlcnNbTkw4MDIxMV9XT1dMQU5fVFJJR19BTlldKQorCQljYXBhLT53b3dsYW5fdHJpZ2dlcnMuYW55ID0gMTsKKwlpZiAodHJpZ2dlcnNbTkw4MDIxMV9XT1dMQU5fVFJJR19ESVNDT05ORUNUXSkKKwkJY2FwYS0+d293bGFuX3RyaWdnZXJzLmRpc2Nvbm5lY3QgPSAxOworCWlmICh0cmlnZ2Vyc1tOTDgwMjExX1dPV0xBTl9UUklHX01BR0lDX1BLVF0pCisJCWNhcGEtPndvd2xhbl90cmlnZ2Vycy5tYWdpY19wa3QgPSAxOworCWlmICh0cmlnZ2Vyc1tOTDgwMjExX1dPV0xBTl9UUklHX0dUS19SRUtFWV9GQUlMVVJFXSkKKwkJY2FwYS0+d293bGFuX3RyaWdnZXJzLmd0a19yZWtleV9mYWlsdXJlID0gMTsKKwlpZiAodHJpZ2dlcnNbTkw4MDIxMV9XT1dMQU5fVFJJR19FQVBfSURFTlRfUkVRVUVTVF0pCisJCWNhcGEtPndvd2xhbl90cmlnZ2Vycy5lYXBfaWRlbnRpdHlfcmVxID0gMTsKKwlpZiAodHJpZ2dlcnNbTkw4MDIxMV9XT1dMQU5fVFJJR180V0FZX0hBTkRTSEFLRV0pCisJCWNhcGEtPndvd2xhbl90cmlnZ2Vycy5mb3VyX3dheV9oYW5kc2hha2UgPSAxOworCWlmICh0cmlnZ2Vyc1tOTDgwMjExX1dPV0xBTl9UUklHX1JGS0lMTF9SRUxFQVNFXSkKKwkJY2FwYS0+d293bGFuX3RyaWdnZXJzLnJma2lsbF9yZWxlYXNlID0gMTsKK30KKworCiBzdGF0aWMgaW50IHdpcGh5X2luZm9faGFuZGxlcihzdHJ1Y3QgbmxfbXNnICptc2csIHZvaWQgKmFyZykKIHsKIAlzdHJ1Y3QgbmxhdHRyICp0YltOTDgwMjExX0FUVFJfTUFYICsgMV07CkBAIC0zMTU2LDcgKzM3NjAsNyBAQAogCQkgIGdlbmxtc2dfYXR0cmxlbihnbmxoLCAwKSwgTlVMTCk7CiAKIAlpZiAodGJbTkw4MDIxMV9BVFRSX1dJUEhZX05BTUVdKQotCQlvc19zdHJuY3B5KGRydi0+cGh5bmFtZSwKKwkJb3Nfc3RybGNweShkcnYtPnBoeW5hbWUsCiAJCQkgICBubGFfZ2V0X3N0cmluZyh0YltOTDgwMjExX0FUVFJfV0lQSFlfTkFNRV0pLAogCQkJICAgc2l6ZW9mKGRydi0+cGh5bmFtZSkpOwogCWlmICh0YltOTDgwMjExX0FUVFJfTUFYX05VTV9TQ0FOX1NTSURTXSkKQEAgLTMxNzgsNiArMzc4Miw3IEBACiAJd2lwaHlfaW5mb19zdXBwb3J0ZWRfaWZ0eXBlcyhpbmZvLCB0YltOTDgwMjExX0FUVFJfU1VQUE9SVEVEX0lGVFlQRVNdKTsKIAl3aXBoeV9pbmZvX2lmYWNlX2NvbWIoaW5mbywgdGJbTkw4MDIxMV9BVFRSX0lOVEVSRkFDRV9DT01CSU5BVElPTlNdKTsKIAl3aXBoeV9pbmZvX3N1cHBfY21kcyhpbmZvLCB0YltOTDgwMjExX0FUVFJfU1VQUE9SVEVEX0NPTU1BTkRTXSk7CisJd2lwaHlfaW5mb19jaXBoZXJfc3VpdGVzKGluZm8sIHRiW05MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVTXSk7CiAKIAlpZiAodGJbTkw4MDIxMV9BVFRSX09GRkNIQU5ORUxfVFhfT0tdKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogVXNpbmcgZHJpdmVyLWJhc2VkICIKQEAgLTMyMzAsNiArMzgzNSw0OSBAQAogCQl9CiAJfQogCisJaWYgKHRiW05MODAyMTFfQVRUUl9WRU5ET1JfREFUQV0pIHsKKwkJc3RydWN0IG5sYXR0ciAqbmw7CisJCWludCByZW07CisKKwkJbmxhX2Zvcl9lYWNoX25lc3RlZChubCwgdGJbTkw4MDIxMV9BVFRSX1ZFTkRPUl9EQVRBXSwgcmVtKSB7CisJCQlzdHJ1Y3Qgbmw4MDIxMV92ZW5kb3JfY21kX2luZm8gKnZpbmZvOworCQkJaWYgKG5sYV9sZW4obmwpICE9IHNpemVvZigqdmluZm8pKSB7CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBVbmV4cGVjdGVkIHZlbmRvciBkYXRhIGluZm8iKTsKKwkJCQljb250aW51ZTsKKwkJCX0KKwkJCXZpbmZvID0gbmxhX2RhdGEobmwpOworCQkJaWYgKHZpbmZvLT5zdWJjbWQgPT0KKwkJCSAgICBRQ0FfTkw4MDIxMV9WRU5ET1JfU1VCQ01EX0RGU19DQVBBQklMSVRZKQorCQkJCWRydi0+ZGZzX3ZlbmRvcl9jbWRfYXZhaWwgPSAxOworCisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFN1cHBvcnRlZCB2ZW5kb3IgY29tbWFuZDogdmVuZG9yX2lkPTB4JXggc3ViY21kPSV1IiwKKwkJCQkgICB2aW5mby0+dmVuZG9yX2lkLCB2aW5mby0+c3ViY21kKTsKKwkJfQorCX0KKworCWlmICh0YltOTDgwMjExX0FUVFJfVkVORE9SX0VWRU5UU10pIHsKKwkJc3RydWN0IG5sYXR0ciAqbmw7CisJCWludCByZW07CisKKwkJbmxhX2Zvcl9lYWNoX25lc3RlZChubCwgdGJbTkw4MDIxMV9BVFRSX1ZFTkRPUl9FVkVOVFNdLCByZW0pIHsKKwkJCXN0cnVjdCBubDgwMjExX3ZlbmRvcl9jbWRfaW5mbyAqdmluZm87CisJCQlpZiAobmxhX2xlbihubCkgIT0gc2l6ZW9mKCp2aW5mbykpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFVuZXhwZWN0ZWQgdmVuZG9yIGRhdGEgaW5mbyIpOworCQkJCWNvbnRpbnVlOworCQkJfQorCQkJdmluZm8gPSBubGFfZGF0YShubCk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFN1cHBvcnRlZCB2ZW5kb3IgZXZlbnQ6IHZlbmRvcl9pZD0weCV4IHN1YmNtZD0ldSIsCisJCQkJICAgdmluZm8tPnZlbmRvcl9pZCwgdmluZm8tPnN1YmNtZCk7CisJCX0KKwl9CisKKwl3aXBoeV9pbmZvX3dvd2xhbl90cmlnZ2VycyhjYXBhLAorCQkJCSAgIHRiW05MODAyMTFfQVRUUl9XT1dMQU5fVFJJR0dFUlNfU1VQUE9SVEVEXSk7CisKKwlpZiAodGJbTkw4MDIxMV9BVFRSX01BWF9BUF9BU1NPQ19TVEFdKQorCQljYXBhLT5tYXhfc3RhdGlvbnMgPQorCQkJbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX01BWF9BUF9BU1NPQ19TVEFdKTsKKwogCXJldHVybiBOTF9TS0lQOwogfQogCkBAIC0zMjU1LDcgKzM5MDMsNyBAQAogCQlubDgwMjExX2NtZChkcnYsIG1zZywgMCwgTkw4MDIxMV9DTURfR0VUX1dJUEhZKTsKIAogCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfQVRUUl9TUExJVF9XSVBIWV9EVU1QKTsKLQlpZiAobmw4MDIxMV9zZXRfaWZhY2VfaWQobXNnLCAmZHJ2LT5maXJzdF9ic3MpIDwgMCkKKwlpZiAobmw4MDIxMV9zZXRfaWZhY2VfaWQobXNnLCBkcnYtPmZpcnN0X2JzcykgPCAwKQogCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsKIAogCWlmIChzZW5kX2FuZF9yZWN2X21zZ3MoZHJ2LCBtc2csIHdpcGh5X2luZm9faGFuZGxlciwgaW5mbykpCkBAIC0zMjg4LDYgKzM5MzYsOSBAQAogCWlmICghZHJ2LT5jYXBhLm1heF9yZW1haW5fb25fY2hhbikKIAkJZHJ2LT5jYXBhLm1heF9yZW1haW5fb25fY2hhbiA9IDUwMDA7CiAKKwlpZiAoaW5mby0+Y2hhbm5lbF9zd2l0Y2hfc3VwcG9ydGVkKQorCQlkcnYtPmNhcGEuZmxhZ3MgfD0gV1BBX0RSSVZFUl9GTEFHU19BUF9DU0E7CisKIAlyZXR1cm4gMDsKIG5sYV9wdXRfZmFpbHVyZToKIAlubG1zZ19mcmVlKG1zZyk7CkBAIC0zMzA1LDE1ICszOTU2LDEwIEBACiAJCXJldHVybiAtMTsKIAogCWRydi0+aGFzX2NhcGFiaWxpdHkgPSAxOwotCS8qIEZvciBub3csIGFzc3VtZSBUS0lQLCBDQ01QLCBXUEEsIFdQQTIgYXJlIHN1cHBvcnRlZCAqLwogCWRydi0+Y2FwYS5rZXlfbWdtdCA9IFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEEgfAogCQlXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfV1BBX1BTSyB8CiAJCVdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEEyIHwKIAkJV1BBX0RSSVZFUl9DQVBBX0tFWV9NR01UX1dQQTJfUFNLOwotCWRydi0+Y2FwYS5lbmMgPSBXUEFfRFJJVkVSX0NBUEFfRU5DX1dFUDQwIHwKLQkJV1BBX0RSSVZFUl9DQVBBX0VOQ19XRVAxMDQgfAotCQlXUEFfRFJJVkVSX0NBUEFfRU5DX1RLSVAgfAotCQlXUEFfRFJJVkVSX0NBUEFfRU5DX0NDTVA7CiAJZHJ2LT5jYXBhLmF1dGggPSBXUEFfRFJJVkVSX0FVVEhfT1BFTiB8CiAJCVdQQV9EUklWRVJfQVVUSF9TSEFSRUQgfAogCQlXUEFfRFJJVkVSX0FVVEhfTEVBUDsKQEAgLTMzMjIsNiArMzk2OCwxNSBAQAogCWRydi0+Y2FwYS5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX1NFVF9LRVlTX0FGVEVSX0FTU09DX0RPTkU7CiAJZHJ2LT5jYXBhLmZsYWdzIHw9IFdQQV9EUklWRVJfRkxBR1NfRUFQT0xfVFhfU1RBVFVTOwogCisJLyoKKwkgKiBBcyBhbGwgY2ZnODAyMTEgZHJpdmVycyBtdXN0IHN1cHBvcnQgY2FzZXMgd2hlcmUgdGhlIEFQIGludGVyZmFjZSBpcworCSAqIHJlbW92ZWQgd2l0aG91dCB0aGUga25vd2xlZGdlIG9mIHdwYV9zdXBwbGljYW50L2hvc3RhcGQsIGUuZy4sIGluCisJICogY2FzZSB0aGF0IHRoZSB1c2VyIHNwYWNlIGRhZW1vbiBoYXMgY3Jhc2hlZCwgdGhleSBtdXN0IGJlIGFibGUgdG8KKwkgKiBjbGVhbnVwIGFsbCBzdGF0aW9ucyBhbmQga2V5IGVudHJpZXMgaW4gdGhlIEFQIHRlYXIgZG93biBmbG93LiBUaHVzLAorCSAqIHRoaXMgZmxhZyBjYW4vc2hvdWxkIGFsd2F5cyBiZSBzZXQgZm9yIGNmZzgwMjExIGRyaXZlcnMuCisJICovCisJZHJ2LT5jYXBhLmZsYWdzIHw9IFdQQV9EUklWRVJfRkxBR1NfQVBfVEVBUkRPV05fU1VQUE9SVDsKKwogCWlmICghaW5mby5kZXZpY2VfYXBfc21lKSB7CiAJCWRydi0+Y2FwYS5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX0RFQVVUSF9UWF9TVEFUVVM7CiAKQEAgLTMzMzUsMjEgKzM5OTAsMTUgQEAKIAlkcnYtPmRldmljZV9hcF9zbWUgPSBpbmZvLmRldmljZV9hcF9zbWU7CiAJZHJ2LT5wb2xsX2NvbW1hbmRfc3VwcG9ydGVkID0gaW5mby5wb2xsX2NvbW1hbmRfc3VwcG9ydGVkOwogCWRydi0+ZGF0YV90eF9zdGF0dXMgPSBpbmZvLmRhdGFfdHhfc3RhdHVzOworCWlmIChpbmZvLnNldF9xb3NfbWFwX3N1cHBvcnRlZCkKKwkJZHJ2LT5jYXBhLmZsYWdzIHw9IFdQQV9EUklWRVJfRkxBR1NfUU9TX01BUFBJTkc7CisJZHJ2LT5oYXZlX2xvd19wcmlvX3NjYW4gPSBpbmZvLmhhdmVfbG93X3ByaW9fc2NhbjsKIAotI2lmZGVmIEFORFJPSURfUDJQCi0JaWYoZHJ2LT5jYXBhLmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19PRkZDSEFOTkVMX1RYKSB7Ci0JCS8qIERyaXZlciBpcyBuZXcgZW5vdWdoIHRvIHN1cHBvcnQgbW9uaXRvcmxlc3MgbW9kZSovCi0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogRHJpdmVyIGlzIG5ldyAiCi0JCQkgICJlbm91Z2ggdG8gc3VwcG9ydCBtb25pdG9yLWxlc3MgbW9kZSIpOwotCQlkcnYtPnVzZV9tb25pdG9yID0gMDsKLQl9Ci0jZWxzZQogCS8qCiAJICogSWYgcG9sbCBjb21tYW5kIGFuZCB0eCBzdGF0dXMgYXJlIHN1cHBvcnRlZCwgbWFjODAyMTEgaXMgbmV3IGVub3VnaAogCSAqIHRvIGhhdmUgZXZlcnl0aGluZyB3ZSBuZWVkIHRvIG5vdCBuZWVkIG1vbml0b3IgaW50ZXJmYWNlcy4KIAkgKi8KIAlkcnYtPnVzZV9tb25pdG9yID0gIWluZm8ucG9sbF9jb21tYW5kX3N1cHBvcnRlZCB8fCAhaW5mby5kYXRhX3R4X3N0YXR1czsKLSNlbmRpZgogCiAJaWYgKGRydi0+ZGV2aWNlX2FwX3NtZSAmJiBkcnYtPnVzZV9tb25pdG9yKSB7CiAJCS8qCkBAIC0zNDY5LDE0ICs0MTE4LDI0IEBACiAJCS8qIENvbnRpbnVlIHdpdGhvdXQgcmVndWxhdG9yeSBldmVudHMgKi8KIAl9CiAKKwlyZXQgPSBubF9nZXRfbXVsdGljYXN0X2lkKGdsb2JhbCwgIm5sODAyMTEiLCAidmVuZG9yIik7CisJaWYgKHJldCA+PSAwKQorCQlyZXQgPSBubF9zb2NrZXRfYWRkX21lbWJlcnNoaXAoZ2xvYmFsLT5ubF9ldmVudCwgcmV0KTsKKwlpZiAocmV0IDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IENvdWxkIG5vdCBhZGQgbXVsdGljYXN0ICIKKwkJCSAgICJtZW1iZXJzaGlwIGZvciB2ZW5kb3IgZXZlbnRzOiAlZCAoJXMpIiwKKwkJCSAgIHJldCwgc3RyZXJyb3IoLXJldCkpOworCQkvKiBDb250aW51ZSB3aXRob3V0IHZlbmRvciBldmVudHMgKi8KKwl9CisKIAlubF9jYl9zZXQoZ2xvYmFsLT5ubF9jYiwgTkxfQ0JfU0VRX0NIRUNLLCBOTF9DQl9DVVNUT00sCiAJCSAgbm9fc2VxX2NoZWNrLCBOVUxMKTsKIAlubF9jYl9zZXQoZ2xvYmFsLT5ubF9jYiwgTkxfQ0JfVkFMSUQsIE5MX0NCX0NVU1RPTSwKIAkJICBwcm9jZXNzX2dsb2JhbF9ldmVudCwgZ2xvYmFsKTsKIAotCWVsb29wX3JlZ2lzdGVyX3JlYWRfc29jayhubF9zb2NrZXRfZ2V0X2ZkKGdsb2JhbC0+bmxfZXZlbnQpLAotCQkJCSB3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfcmVjZWl2ZSwKLQkJCQkgZ2xvYmFsLT5ubF9jYiwgZ2xvYmFsLT5ubF9ldmVudCk7CisJbmw4MDIxMV9yZWdpc3Rlcl9lbG9vcF9yZWFkKCZnbG9iYWwtPm5sX2V2ZW50LAorCQkJCSAgICB3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfcmVjZWl2ZSwKKwkJCQkgICAgZ2xvYmFsLT5ubF9jYik7CiAKIAlyZXR1cm4gMDsKIApAQCAtMzUyMCw3ICs0MTc5LDcgQEAKIHsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGN0eDsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFJGS0lMTCB1bmJsb2NrZWQiKTsKLQlpZiAoaTgwMl9zZXRfaWZhY2VfZmxhZ3MoJmRydi0+Zmlyc3RfYnNzLCAxKSkgeworCWlmIChpODAyX3NldF9pZmFjZV9mbGFncyhkcnYtPmZpcnN0X2JzcywgMSkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBDb3VsZCBub3Qgc2V0IGludGVyZmFjZSBVUCAiCiAJCQkgICAiYWZ0ZXIgcmZraWxsIHVuYmxvY2siKTsKIAkJcmV0dXJuOwpAQCAtMzYxMCwxNiArNDI2OSw5IEBACiB9CiAKIAotLyoqCi0gKiB3cGFfZHJpdmVyX25sODAyMTFfaW5pdCAtIEluaXRpYWxpemUgbmw4MDIxMSBkcml2ZXIgaW50ZXJmYWNlCi0gKiBAY3R4OiBjb250ZXh0IHRvIGJlIHVzZWQgd2hlbiBjYWxsaW5nIHdwYV9zdXBwbGljYW50IGZ1bmN0aW9ucywKLSAqIGUuZy4sIHdwYV9zdXBwbGljYW50X2V2ZW50KCkKLSAqIEBpZm5hbWU6IGludGVyZmFjZSBuYW1lLCBlLmcuLCB3bGFuMAotICogQGdsb2JhbF9wcml2OiBwcml2YXRlIGRyaXZlciBnbG9iYWwgZGF0YSBmcm9tIGdsb2JhbF9pbml0KCkKLSAqIFJldHVybnM6IFBvaW50ZXIgdG8gcHJpdmF0ZSBkYXRhLCAlTlVMTCBvbiBmYWlsdXJlCi0gKi8KLXN0YXRpYyB2b2lkICogd3BhX2RyaXZlcl9ubDgwMjExX2luaXQodm9pZCAqY3R4LCBjb25zdCBjaGFyICppZm5hbWUsCi0JCQkJICAgICAgdm9pZCAqZ2xvYmFsX3ByaXYpCitzdGF0aWMgdm9pZCAqIHdwYV9kcml2ZXJfbmw4MDIxMV9kcnZfaW5pdCh2b2lkICpjdHgsIGNvbnN0IGNoYXIgKmlmbmFtZSwKKwkJCQkJICB2b2lkICpnbG9iYWxfcHJpdiwgaW50IGhvc3RhcGQsCisJCQkJCSAgY29uc3QgdTggKnNldF9hZGRyKQogewogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2OwogCXN0cnVjdCByZmtpbGxfY29uZmlnICpyY2ZnOwpAQCAtMzYzMiw3ICs0Mjg0LDE3IEBACiAJCXJldHVybiBOVUxMOwogCWRydi0+Z2xvYmFsID0gZ2xvYmFsX3ByaXY7CiAJZHJ2LT5jdHggPSBjdHg7Ci0JYnNzID0gJmRydi0+Zmlyc3RfYnNzOworCWRydi0+aG9zdGFwZCA9ICEhaG9zdGFwZDsKKwlkcnYtPmVhcG9sX3NvY2sgPSAtMTsKKwlkcnYtPm51bV9pZl9pbmRpY2VzID0gc2l6ZW9mKGRydi0+ZGVmYXVsdF9pZl9pbmRpY2VzKSAvIHNpemVvZihpbnQpOworCWRydi0+aWZfaW5kaWNlcyA9IGRydi0+ZGVmYXVsdF9pZl9pbmRpY2VzOworCisJZHJ2LT5maXJzdF9ic3MgPSBvc196YWxsb2Moc2l6ZW9mKCpkcnYtPmZpcnN0X2JzcykpOworCWlmICghZHJ2LT5maXJzdF9ic3MpIHsKKwkJb3NfZnJlZShkcnYpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJYnNzID0gZHJ2LT5maXJzdF9ic3M7CiAJYnNzLT5kcnYgPSBkcnY7CiAJYnNzLT5jdHggPSBjdHg7CiAKQEAgLTM2NjMsNyArNDMyNSwxMCBAQAogCQlvc19mcmVlKHJjZmcpOwogCX0KIAotCWlmICh3cGFfZHJpdmVyX25sODAyMTFfZmluaXNoX2Rydl9pbml0KGRydikpCisJaWYgKGxpbnV4X2lmYWNlX3VwKGRydi0+Z2xvYmFsLT5pb2N0bF9zb2NrLCBpZm5hbWUpID4gMCkKKwkJZHJ2LT5zdGFydF9pZmFjZV91cCA9IDE7CisKKwlpZiAod3BhX2RyaXZlcl9ubDgwMjExX2ZpbmlzaF9kcnZfaW5pdChkcnYsIHNldF9hZGRyLCAxKSkKIAkJZ290byBmYWlsZWQ7CiAKIAlkcnYtPmVhcG9sX3R4X3NvY2sgPSBzb2NrZXQoUEZfUEFDS0VULCBTT0NLX0RHUkFNLCAwKTsKQEAgLTM3MDEsNiArNDM2NiwyMSBAQAogfQogCiAKKy8qKgorICogd3BhX2RyaXZlcl9ubDgwMjExX2luaXQgLSBJbml0aWFsaXplIG5sODAyMTEgZHJpdmVyIGludGVyZmFjZQorICogQGN0eDogY29udGV4dCB0byBiZSB1c2VkIHdoZW4gY2FsbGluZyB3cGFfc3VwcGxpY2FudCBmdW5jdGlvbnMsCisgKiBlLmcuLCB3cGFfc3VwcGxpY2FudF9ldmVudCgpCisgKiBAaWZuYW1lOiBpbnRlcmZhY2UgbmFtZSwgZS5nLiwgd2xhbjAKKyAqIEBnbG9iYWxfcHJpdjogcHJpdmF0ZSBkcml2ZXIgZ2xvYmFsIGRhdGEgZnJvbSBnbG9iYWxfaW5pdCgpCisgKiBSZXR1cm5zOiBQb2ludGVyIHRvIHByaXZhdGUgZGF0YSwgJU5VTEwgb24gZmFpbHVyZQorICovCitzdGF0aWMgdm9pZCAqIHdwYV9kcml2ZXJfbmw4MDIxMV9pbml0KHZvaWQgKmN0eCwgY29uc3QgY2hhciAqaWZuYW1lLAorCQkJCSAgICAgIHZvaWQgKmdsb2JhbF9wcml2KQoreworCXJldHVybiB3cGFfZHJpdmVyX25sODAyMTFfZHJ2X2luaXQoY3R4LCBpZm5hbWUsIGdsb2JhbF9wcml2LCAwLCBOVUxMKTsKK30KKworCiBzdGF0aWMgaW50IG5sODAyMTFfcmVnaXN0ZXJfZnJhbWUoc3RydWN0IGk4MDJfYnNzICpic3MsCiAJCQkJICBzdHJ1Y3QgbmxfaGFuZGxlICpubF9oYW5kbGUsCiAJCQkJICB1MTYgdHlwZSwgY29uc3QgdTggKm1hdGNoLCBzaXplX3QgbWF0Y2hfbGVuKQpAQCAtMzcwOCwxNSArNDM4OCwxNiBAQAogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAJc3RydWN0IG5sX21zZyAqbXNnOwogCWludCByZXQgPSAtMTsKKwljaGFyIGJ1ZlszMF07CiAKIAltc2cgPSBubG1zZ19hbGxvYygpOwogCWlmICghbXNnKQogCQlyZXR1cm4gLTE7CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFJlZ2lzdGVyIGZyYW1lIHR5cGU9MHgleCBubF9oYW5kbGU9JXAiLAotCQkgICB0eXBlLCBubF9oYW5kbGUpOwotCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIm5sODAyMTE6IFJlZ2lzdGVyIGZyYW1lIG1hdGNoIiwKLQkJICAgIG1hdGNoLCBtYXRjaF9sZW4pOworCWJ1ZlswXSA9ICdcMCc7CisJd3BhX3NucHJpbnRmX2hleChidWYsIHNpemVvZihidWYpLCBtYXRjaCwgbWF0Y2hfbGVuKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFJlZ2lzdGVyIGZyYW1lIHR5cGU9MHgleCAoJXMpIG5sX2hhbmRsZT0lcCBtYXRjaD0lcyIsCisJCSAgIHR5cGUsIGZjMnN0cih0eXBlKSwgbmxfaGFuZGxlLCBidWYpOwogCiAJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX1JFR0lTVEVSX0FDVElPTik7CiAKQEAgLTM3NTcsMTQgKzQ0MzgsMTggQEAKIAlpZiAoYnNzLT5ubF9tZ210ID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAotCWVsb29wX3JlZ2lzdGVyX3JlYWRfc29jayhubF9zb2NrZXRfZ2V0X2ZkKGJzcy0+bmxfbWdtdCksCi0JCQkJIHdwYV9kcml2ZXJfbmw4MDIxMV9ldmVudF9yZWNlaXZlLCBic3MtPm5sX2NiLAotCQkJCSBic3MtPm5sX21nbXQpOwotCiAJcmV0dXJuIDA7CiB9CiAKIAorc3RhdGljIHZvaWQgbmw4MDIxMV9tZ210X2hhbmRsZV9yZWdpc3Rlcl9lbG9vcChzdHJ1Y3QgaTgwMl9ic3MgKmJzcykKK3sKKwlubDgwMjExX3JlZ2lzdGVyX2Vsb29wX3JlYWQoJmJzcy0+bmxfbWdtdCwKKwkJCQkgICAgd3BhX2RyaXZlcl9ubDgwMjExX2V2ZW50X3JlY2VpdmUsCisJCQkJICAgIGJzcy0+bmxfY2IpOworfQorCisKIHN0YXRpYyBpbnQgbmw4MDIxMV9yZWdpc3Rlcl9hY3Rpb25fZnJhbWUoc3RydWN0IGk4MDJfYnNzICpic3MsCiAJCQkJCSBjb25zdCB1OCAqbWF0Y2gsIHNpemVfdCBtYXRjaF9sZW4pCiB7CkBAIC0zNzc3LDY3ICs0NDYyLDEwMCBAQAogc3RhdGljIGludCBubDgwMjExX21nbXRfc3Vic2NyaWJlX25vbl9hcChzdHJ1Y3QgaTgwMl9ic3MgKmJzcykKIHsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OworCWludCByZXQgPSAwOwogCiAJaWYgKG5sODAyMTFfYWxsb2NfbWdtdF9oYW5kbGUoYnNzKSkKIAkJcmV0dXJuIC0xOwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogU3Vic2NyaWJlIHRvIG1nbXQgZnJhbWVzIHdpdGggbm9uLUFQICIKIAkJICAgImhhbmRsZSAlcCIsIGJzcy0+bmxfbWdtdCk7CiAKKwlpZiAoZHJ2LT5ubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfQURIT0MpIHsKKwkJdTE2IHR5cGUgPSAoV0xBTl9GQ19UWVBFX01HTVQgPDwgMikgfCAoV0xBTl9GQ19TVFlQRV9BVVRIIDw8IDQpOworCisJCS8qIHJlZ2lzdGVyIGZvciBhbnkgQVVUSCBtZXNzYWdlICovCisJCW5sODAyMTFfcmVnaXN0ZXJfZnJhbWUoYnNzLCBic3MtPm5sX21nbXQsIHR5cGUsIE5VTEwsIDApOworCX0KKworI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKwkvKiBRb1MgTWFwIENvbmZpZ3VyZSAqLworCWlmIChubDgwMjExX3JlZ2lzdGVyX2FjdGlvbl9mcmFtZShic3MsICh1OCAqKSAiXHgwMVx4MDQiLCAyKSA8IDApCisJCXJldCA9IC0xOworI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KICNpZiBkZWZpbmVkKENPTkZJR19QMlApIHx8IGRlZmluZWQoQ09ORklHX0lOVEVSV09SS0lORykKIAkvKiBHQVMgSW5pdGlhbCBSZXF1ZXN0ICovCiAJaWYgKG5sODAyMTFfcmVnaXN0ZXJfYWN0aW9uX2ZyYW1lKGJzcywgKHU4ICopICJceDA0XHgwYSIsIDIpIDwgMCkKLQkJcmV0dXJuIC0xOworCQlyZXQgPSAtMTsKIAkvKiBHQVMgSW5pdGlhbCBSZXNwb25zZSAqLwogCWlmIChubDgwMjExX3JlZ2lzdGVyX2FjdGlvbl9mcmFtZShic3MsICh1OCAqKSAiXHgwNFx4MGIiLCAyKSA8IDApCi0JCXJldHVybiAtMTsKKwkJcmV0ID0gLTE7CiAJLyogR0FTIENvbWViYWNrIFJlcXVlc3QgKi8KIAlpZiAobmw4MDIxMV9yZWdpc3Rlcl9hY3Rpb25fZnJhbWUoYnNzLCAodTggKikgIlx4MDRceDBjIiwgMikgPCAwKQotCQlyZXR1cm4gLTE7CisJCXJldCA9IC0xOwogCS8qIEdBUyBDb21lYmFjayBSZXNwb25zZSAqLwogCWlmIChubDgwMjExX3JlZ2lzdGVyX2FjdGlvbl9mcmFtZShic3MsICh1OCAqKSAiXHgwNFx4MGQiLCAyKSA8IDApCi0JCXJldHVybiAtMTsKKwkJcmV0ID0gLTE7CisJLyogUHJvdGVjdGVkIEdBUyBJbml0aWFsIFJlcXVlc3QgKi8KKwlpZiAobmw4MDIxMV9yZWdpc3Rlcl9hY3Rpb25fZnJhbWUoYnNzLCAodTggKikgIlx4MDlceDBhIiwgMikgPCAwKQorCQlyZXQgPSAtMTsKKwkvKiBQcm90ZWN0ZWQgR0FTIEluaXRpYWwgUmVzcG9uc2UgKi8KKwlpZiAobmw4MDIxMV9yZWdpc3Rlcl9hY3Rpb25fZnJhbWUoYnNzLCAodTggKikgIlx4MDlceDBiIiwgMikgPCAwKQorCQlyZXQgPSAtMTsKKwkvKiBQcm90ZWN0ZWQgR0FTIENvbWViYWNrIFJlcXVlc3QgKi8KKwlpZiAobmw4MDIxMV9yZWdpc3Rlcl9hY3Rpb25fZnJhbWUoYnNzLCAodTggKikgIlx4MDlceDBjIiwgMikgPCAwKQorCQlyZXQgPSAtMTsKKwkvKiBQcm90ZWN0ZWQgR0FTIENvbWViYWNrIFJlc3BvbnNlICovCisJaWYgKG5sODAyMTFfcmVnaXN0ZXJfYWN0aW9uX2ZyYW1lKGJzcywgKHU4ICopICJceDA5XHgwZCIsIDIpIDwgMCkKKwkJcmV0ID0gLTE7CiAjZW5kaWYgLyogQ09ORklHX1AyUCB8fCBDT05GSUdfSU5URVJXT1JLSU5HICovCiAjaWZkZWYgQ09ORklHX1AyUAogCS8qIFAyUCBQdWJsaWMgQWN0aW9uICovCiAJaWYgKG5sODAyMTFfcmVnaXN0ZXJfYWN0aW9uX2ZyYW1lKGJzcywKIAkJCQkJICAodTggKikgIlx4MDRceDA5XHg1MFx4NmZceDlhXHgwOSIsCiAJCQkJCSAgNikgPCAwKQotCQlyZXR1cm4gLTE7CisJCXJldCA9IC0xOwogCS8qIFAyUCBBY3Rpb24gKi8KIAlpZiAobmw4MDIxMV9yZWdpc3Rlcl9hY3Rpb25fZnJhbWUoYnNzLAogCQkJCQkgICh1OCAqKSAiXHg3Zlx4NTBceDZmXHg5YVx4MDkiLAogCQkJCQkgIDUpIDwgMCkKLQkJcmV0dXJuIC0xOworCQlyZXQgPSAtMTsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKIAkvKiBTQSBRdWVyeSBSZXNwb25zZSAqLwogCWlmIChubDgwMjExX3JlZ2lzdGVyX2FjdGlvbl9mcmFtZShic3MsICh1OCAqKSAiXHgwOFx4MDEiLCAyKSA8IDApCi0JCXJldHVybiAtMTsKKwkJcmV0ID0gLTE7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KICNpZmRlZiBDT05GSUdfVERMUwogCWlmICgoZHJ2LT5jYXBhLmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19URExTX1NVUFBPUlQpKSB7CiAJCS8qIFRETFMgRGlzY292ZXJ5IFJlc3BvbnNlICovCiAJCWlmIChubDgwMjExX3JlZ2lzdGVyX2FjdGlvbl9mcmFtZShic3MsICh1OCAqKSAiXHgwNFx4MGUiLCAyKSA8CiAJCSAgICAwKQotCQkJcmV0dXJuIC0xOworCQkJcmV0ID0gLTE7CiAJfQogI2VuZGlmIC8qIENPTkZJR19URExTICovCiAKIAkvKiBGVCBBY3Rpb24gZnJhbWVzICovCiAJaWYgKG5sODAyMTFfcmVnaXN0ZXJfYWN0aW9uX2ZyYW1lKGJzcywgKHU4ICopICJceDA2IiwgMSkgPCAwKQotCQlyZXR1cm4gLTE7CisJCXJldCA9IC0xOwogCWVsc2UKIAkJZHJ2LT5jYXBhLmtleV9tZ210IHw9IFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9GVCB8CiAJCQlXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfRlRfUFNLOwogCiAJLyogV05NIC0gQlNTIFRyYW5zaXRpb24gTWFuYWdlbWVudCBSZXF1ZXN0ICovCiAJaWYgKG5sODAyMTFfcmVnaXN0ZXJfYWN0aW9uX2ZyYW1lKGJzcywgKHU4ICopICJceDBhXHgwNyIsIDIpIDwgMCkKLQkJcmV0dXJuIC0xOworCQlyZXQgPSAtMTsKIAkvKiBXTk0tU2xlZXAgTW9kZSBSZXNwb25zZSAqLwogCWlmIChubDgwMjExX3JlZ2lzdGVyX2FjdGlvbl9mcmFtZShic3MsICh1OCAqKSAiXHgwYVx4MTEiLCAyKSA8IDApCi0JCXJldHVybiAtMTsKKwkJcmV0ID0gLTE7CiAKLQlyZXR1cm4gMDsKKyNpZmRlZiBDT05GSUdfSFMyMAorCS8qIFdOTS1Ob3RpZmljYXRpb24gKi8KKwlpZiAobmw4MDIxMV9yZWdpc3Rlcl9hY3Rpb25fZnJhbWUoYnNzLCAodTggKikgIlx4MGFceDFhIiwgMikgPCAwKQorCQlyZXR1cm4gLTE7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKworCW5sODAyMTFfbWdtdF9oYW5kbGVfcmVnaXN0ZXJfZWxvb3AoYnNzKTsKKworCXJldHVybiByZXQ7CiB9CiAKIApAQCAtMzg4NSw3ICs0NjAzLDcgQEAKICAqIGl0IGlzbid0IHBlciBpbnRlcmZhY2UgLi4uIG1heWJlIGp1c3QgZHVtcCB0aGUgc2NhbgogICogcmVzdWx0cyBwZXJpb2RpY2FsbHkgZm9yIE9MQkM/CiAgKi8KLS8vCQlXTEFOX0ZDX1NUWVBFX0JFQUNPTiwKKwkJLyogV0xBTl9GQ19TVFlQRV9CRUFDT04sICovCiAJfTsKIAl1bnNpZ25lZCBpbnQgaTsKIApAQCAtMzg5NCw3ICs0NjEyLDcgQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFN1YnNjcmliZSB0byBtZ210IGZyYW1lcyB3aXRoIEFQICIKIAkJICAgImhhbmRsZSAlcCIsIGJzcy0+bmxfbWdtdCk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mKHN0eXBlcykgLyBzaXplb2Yoc3R5cGVzWzBdKTsgaSsrKSB7CisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoc3R5cGVzKTsgaSsrKSB7CiAJCWlmIChubDgwMjExX3JlZ2lzdGVyX2ZyYW1lKGJzcywgYnNzLT5ubF9tZ210LAogCQkJCQkgICAoV0xBTl9GQ19UWVBFX01HTVQgPDwgMikgfAogCQkJCQkgICAoc3R5cGVzW2ldIDw8IDQpLApAQCAtMzkwOSwxMCArNDYyNywxMCBAQAogCWlmIChubDgwMjExX2dldF93aXBoeV9kYXRhX2FwKGJzcykgPT0gTlVMTCkKIAkJZ290byBvdXRfZXJyOwogCisJbmw4MDIxMV9tZ210X2hhbmRsZV9yZWdpc3Rlcl9lbG9vcChic3MpOwogCXJldHVybiAwOwogCiBvdXRfZXJyOgotCWVsb29wX3VucmVnaXN0ZXJfcmVhZF9zb2NrKG5sX3NvY2tldF9nZXRfZmQoYnNzLT5ubF9tZ210KSk7CiAJbmxfZGVzdHJveV9oYW5kbGVzKCZic3MtPm5sX21nbXQpOwogCXJldHVybiAtMTsKIH0KQEAgLTM5MzEsMTAgKzQ2NDksMTAgQEAKIAkJCQkgICBOVUxMLCAwKSA8IDApCiAJCWdvdG8gb3V0X2VycjsKIAorCW5sODAyMTFfbWdtdF9oYW5kbGVfcmVnaXN0ZXJfZWxvb3AoYnNzKTsKIAlyZXR1cm4gMDsKIAogb3V0X2VycjoKLQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhubF9zb2NrZXRfZ2V0X2ZkKGJzcy0+bmxfbWdtdCkpOwogCW5sX2Rlc3Ryb3lfaGFuZGxlcygmYnNzLT5ubF9tZ210KTsKIAlyZXR1cm4gLTE7CiB9CkBAIC0zOTQ2LDggKzQ2NjQsNyBAQAogCQlyZXR1cm47CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBVbnN1YnNjcmliZSBtZ210IGZyYW1lcyBoYW5kbGUgJXAgIgogCQkgICAiKCVzKSIsIGJzcy0+bmxfbWdtdCwgcmVhc29uKTsKLQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhubF9zb2NrZXRfZ2V0X2ZkKGJzcy0+bmxfbWdtdCkpOwotCW5sX2Rlc3Ryb3lfaGFuZGxlcygmYnNzLT5ubF9tZ210KTsKKwlubDgwMjExX2Rlc3Ryb3lfZWxvb3BfaGFuZGxlKCZic3MtPm5sX21nbXQpOwogCiAJbmw4MDIxMV9wdXRfd2lwaHlfZGF0YV9hcChic3MpOwogfQpAQCAtMzk3Nyw3ICs0Njk0LDcgQEAKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogRGVsZXRlIFAyUCBEZXZpY2UgJXMgKDB4JWxseCk6ICVzIiwKIAkJICAgYnNzLT5pZm5hbWUsIChsb25nIGxvbmcgdW5zaWduZWQgaW50KSBic3MtPndkZXZfaWQsCi0JCSAgIHN0cmVycm9yKHJldCkpOworCQkgICBzdHJlcnJvcigtcmV0KSk7CiAKIG5sYV9wdXRfZmFpbHVyZToKIAlubG1zZ19mcmVlKG1zZyk7CkBAIC00MDA3LDcgKzQ3MjQsNyBAQAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogJXMgUDJQIERldmljZSAlcyAoMHglbGx4KTogJXMiLAogCQkgICBzdGFydCA/ICJTdGFydCIgOiAiU3RvcCIsCiAJCSAgIGJzcy0+aWZuYW1lLCAobG9uZyBsb25nIHVuc2lnbmVkIGludCkgYnNzLT53ZGV2X2lkLAotCQkgICBzdHJlcnJvcihyZXQpKTsKKwkJICAgc3RyZXJyb3IoLXJldCkpOwogCiBubGFfcHV0X2ZhaWx1cmU6CiAJbmxtc2dfZnJlZShtc2cpOwpAQCAtNDAzMSwxMyArNDc0OCwxMiBAQAogCiAKIHN0YXRpYyBpbnQKLXdwYV9kcml2ZXJfbmw4MDIxMV9maW5pc2hfZHJ2X2luaXQoc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYpCit3cGFfZHJpdmVyX25sODAyMTFfZmluaXNoX2Rydl9pbml0KHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LAorCQkJCSAgIGNvbnN0IHU4ICpzZXRfYWRkciwgaW50IGZpcnN0KQogewotI2lmbmRlZiBIT1NUQVBECi0JZW51bSBubDgwMjExX2lmdHlwZSBubG1vZGUgPSBOTDgwMjExX0lGVFlQRV9TVEFUSU9OOwotI2VuZGlmIC8qIEhPU1RBUEQgKi8KLQlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9ICZkcnYtPmZpcnN0X2JzczsKKwlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IGRydi0+Zmlyc3RfYnNzOwogCWludCBzZW5kX3Jma2lsbF9ldmVudCA9IDA7CisJZW51bSBubDgwMjExX2lmdHlwZSBubG1vZGU7CiAKIAlkcnYtPmlmaW5kZXggPSBpZl9uYW1ldG9pbmRleChic3MtPmlmbmFtZSk7CiAJYnNzLT5pZmluZGV4ID0gZHJ2LT5pZmluZGV4OwpAQCAtNDA0OCw1MiArNDc2NCw2MCBAQAogCWJzcy0+aWZfZHluYW1pYyA9IGJzcy0+aWZfZHluYW1pYyB8fCBkcnYtPmdsb2JhbC0+aWZfYWRkX3dkZXZpZF9zZXQ7CiAJZHJ2LT5nbG9iYWwtPmlmX2FkZF93ZGV2aWRfc2V0ID0gMDsKIAorCWlmICghYnNzLT5pZl9keW5hbWljICYmIG5sODAyMTFfZ2V0X2lmbW9kZShic3MpID09IE5MODAyMTFfSUZUWVBFX0FQKQorCQlic3MtPnN0YXRpY19hcCA9IDE7CisKIAlpZiAod3BhX2RyaXZlcl9ubDgwMjExX2NhcGEoZHJ2KSkKIAkJcmV0dXJuIC0xOwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBpbnRlcmZhY2UgJXMgaW4gcGh5ICVzIiwKIAkJICAgYnNzLT5pZm5hbWUsIGRydi0+cGh5bmFtZSk7CiAKLSNpZm5kZWYgSE9TVEFQRAotCWlmIChic3MtPmlmX2R5bmFtaWMpCi0JCW5sbW9kZSA9IG5sODAyMTFfZ2V0X2lmbW9kZShic3MpOworCWlmIChzZXRfYWRkciAmJgorCSAgICAobGludXhfc2V0X2lmYWNlX2ZsYWdzKGRydi0+Z2xvYmFsLT5pb2N0bF9zb2NrLCBic3MtPmlmbmFtZSwgMCkgfHwKKwkgICAgIGxpbnV4X3NldF9pZmh3YWRkcihkcnYtPmdsb2JhbC0+aW9jdGxfc29jaywgYnNzLT5pZm5hbWUsCisJCQkJc2V0X2FkZHIpKSkKKwkJcmV0dXJuIC0xOwogCi0JLyoKLQkgKiBNYWtlIHN1cmUgdGhlIGludGVyZmFjZSBzdGFydHMgdXAgaW4gc3RhdGlvbiBtb2RlIHVubGVzcyB0aGlzIGlzIGEKLQkgKiBkeW5hbWljYWxseSBhZGRlZCBpbnRlcmZhY2UgKGUuZy4sIFAyUCkgdGhhdCB3YXMgYWxyZWFkeSBjb25maWd1cmVkCi0JICogd2l0aCBwcm9wZXIgaWZ0eXBlLgotCSAqLworCWlmIChmaXJzdCAmJiBubDgwMjExX2dldF9pZm1vZGUoYnNzKSA9PSBOTDgwMjExX0lGVFlQRV9BUCkKKwkJZHJ2LT5zdGFydF9tb2RlX2FwID0gMTsKKworCWlmIChkcnYtPmhvc3RhcGQgfHwgYnNzLT5zdGF0aWNfYXApCisJCW5sbW9kZSA9IE5MODAyMTFfSUZUWVBFX0FQOworCWVsc2UgaWYgKGJzcy0+aWZfZHluYW1pYykKKwkJbmxtb2RlID0gbmw4MDIxMV9nZXRfaWZtb2RlKGJzcyk7CisJZWxzZQorCQlubG1vZGUgPSBOTDgwMjExX0lGVFlQRV9TVEFUSU9OOworCiAJaWYgKHdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZShic3MsIG5sbW9kZSkgPCAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogQ291bGQgbm90IGNvbmZpZ3VyZSBkcml2ZXIgdG8gdXNlIG1hbmFnZWQgbW9kZSIpOworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIm5sODAyMTE6IENvdWxkIG5vdCBjb25maWd1cmUgZHJpdmVyIG1vZGUiKTsKIAkJcmV0dXJuIC0xOwogCX0KLQlkcnYtPm5sbW9kZSA9IG5sbW9kZTsKIAotCWlmIChubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfUDJQX0RFVklDRSkgewotCQlpbnQgcmV0ID0gbmw4MDIxMV9zZXRfcDJwZGV2KGJzcywgMSk7Ci0JCWlmIChyZXQgPCAwKQotCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJubDgwMjExOiBDb3VsZCBub3Qgc3RhcnQgUDJQIGRldmljZSIpOworCWlmIChubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfUDJQX0RFVklDRSkKIAkJbmw4MDIxMV9nZXRfbWFjYWRkcihic3MpOwotCQlyZXR1cm4gcmV0OwotCX0KIAotCWlmIChsaW51eF9zZXRfaWZhY2VfZmxhZ3MoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssIGJzcy0+aWZuYW1lLCAxKSkgewotCQlpZiAocmZraWxsX2lzX2Jsb2NrZWQoZHJ2LT5yZmtpbGwpKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IENvdWxkIG5vdCB5ZXQgZW5hYmxlICIKLQkJCQkgICAiaW50ZXJmYWNlICclcycgZHVlIHRvIHJma2lsbCIsCi0JCQkJICAgYnNzLT5pZm5hbWUpOwotCQkJZHJ2LT5pZl9kaXNhYmxlZCA9IDE7Ci0JCQlzZW5kX3Jma2lsbF9ldmVudCA9IDE7Ci0JCX0gZWxzZSB7CisJaWYgKCFyZmtpbGxfaXNfYmxvY2tlZChkcnYtPnJma2lsbCkpIHsKKwkJaW50IHJldCA9IGk4MDJfc2V0X2lmYWNlX2ZsYWdzKGJzcywgMSk7CisJCWlmIChyZXQpIHsKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogQ291bGQgbm90IHNldCAiCiAJCQkJICAgImludGVyZmFjZSAnJXMnIFVQIiwgYnNzLT5pZm5hbWUpOwotCQkJcmV0dXJuIC0xOworCQkJcmV0dXJuIHJldDsKIAkJfQorCQlpZiAobmxtb2RlID09IE5MODAyMTFfSUZUWVBFX1AyUF9ERVZJQ0UpCisJCQlyZXR1cm4gcmV0OworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogQ291bGQgbm90IHlldCBlbmFibGUgIgorCQkJICAgImludGVyZmFjZSAnJXMnIGR1ZSB0byByZmtpbGwiLCBic3MtPmlmbmFtZSk7CisJCWlmIChubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfUDJQX0RFVklDRSkKKwkJCXJldHVybiAwOworCQlkcnYtPmlmX2Rpc2FibGVkID0gMTsKKwkJc2VuZF9yZmtpbGxfZXZlbnQgPSAxOwogCX0KIAotCW5ldGxpbmtfc2VuZF9vcGVyX2lmbGEoZHJ2LT5nbG9iYWwtPm5ldGxpbmssIGRydi0+aWZpbmRleCwKLQkJCSAgICAgICAxLCBJRl9PUEVSX0RPUk1BTlQpOwotI2VuZGlmIC8qIEhPU1RBUEQgKi8KKwlpZiAoIWRydi0+aG9zdGFwZCkKKwkJbmV0bGlua19zZW5kX29wZXJfaWZsYShkcnYtPmdsb2JhbC0+bmV0bGluaywgZHJ2LT5pZmluZGV4LAorCQkJCSAgICAgICAxLCBJRl9PUEVSX0RPUk1BTlQpOwogCiAJaWYgKGxpbnV4X2dldF9pZmh3YWRkcihkcnYtPmdsb2JhbC0+aW9jdGxfc29jaywgYnNzLT5pZm5hbWUsCiAJCQkgICAgICAgYnNzLT5hZGRyKSkKQEAgLTQxMTYsNiArNDg0MCw4IEBACiAJaWYgKCFtc2cpCiAJCXJldHVybiAtRU5PTUVNOwogCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBSZW1vdmUgYmVhY29uIChpZmluZGV4PSVkKSIsCisJCSAgIGRydi0+aWZpbmRleCk7CiAJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX0RFTF9CRUFDT04pOwogCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0lGSU5ERVgsIGRydi0+aWZpbmRleCk7CiAKQEAgLTQxNjQsMTUgKzQ4OTAsNiBAQAogCWlmIChpc19hcF9pbnRlcmZhY2UoZHJ2LT5ubG1vZGUpKQogCQl3cGFfZHJpdmVyX25sODAyMTFfZGVsX2JlYWNvbihkcnYpOwogCi0jaWZkZWYgSE9TVEFQRAotCWlmIChkcnYtPmxhc3RfZnJlcV9odCkgewotCQkvKiBDbGVhciBIVCBmbGFncyBmcm9tIHRoZSBkcml2ZXIgKi8KLQkJc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgZnJlcTsKLQkJb3NfbWVtc2V0KCZmcmVxLCAwLCBzaXplb2YoZnJlcSkpOwotCQlmcmVxLmZyZXEgPSBkcnYtPmxhc3RfZnJlcTsKLQkJd3BhX2RyaXZlcl9ubDgwMjExX3NldF9mcmVxKGJzcywgJmZyZXEpOwotCX0KLQogCWlmIChkcnYtPmVhcG9sX3NvY2sgPj0gMCkgewogCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhkcnYtPmVhcG9sX3NvY2spOwogCQljbG9zZShkcnYtPmVhcG9sX3NvY2spOwpAQCAtNDE4MCwyMCArNDg5NywyMyBAQAogCiAJaWYgKGRydi0+aWZfaW5kaWNlcyAhPSBkcnYtPmRlZmF1bHRfaWZfaW5kaWNlcykKIAkJb3NfZnJlZShkcnYtPmlmX2luZGljZXMpOwotI2VuZGlmIC8qIEhPU1RBUEQgKi8KIAogCWlmIChkcnYtPmRpc2FibGVkXzExYl9yYXRlcykKIAkJbmw4MDIxMV9kaXNhYmxlXzExYl9yYXRlcyhkcnYsIGRydi0+aWZpbmRleCwgMCk7CiAKIAluZXRsaW5rX3NlbmRfb3Blcl9pZmxhKGRydi0+Z2xvYmFsLT5uZXRsaW5rLCBkcnYtPmlmaW5kZXgsIDAsCiAJCQkgICAgICAgSUZfT1BFUl9VUCk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3BhX2RyaXZlcl9ubDgwMjExX3NlbmRfcmZraWxsLCBkcnYsIGRydi0+Y3R4KTsKIAlyZmtpbGxfZGVpbml0KGRydi0+cmZraWxsKTsKIAogCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYV9kcml2ZXJfbmw4MDIxMV9zY2FuX3RpbWVvdXQsIGRydiwgZHJ2LT5jdHgpOwogCi0JKHZvaWQpIGk4MDJfc2V0X2lmYWNlX2ZsYWdzKGJzcywgMCk7CisJaWYgKCFkcnYtPnN0YXJ0X2lmYWNlX3VwKQorCQkodm9pZCkgaTgwMl9zZXRfaWZhY2VfZmxhZ3MoYnNzLCAwKTsKIAlpZiAoZHJ2LT5ubG1vZGUgIT0gTkw4MDIxMV9JRlRZUEVfUDJQX0RFVklDRSkgewotCQl3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGUoYnNzLCBOTDgwMjExX0lGVFlQRV9TVEFUSU9OKTsKKwkJaWYgKCFkcnYtPmhvc3RhcGQgfHwgIWRydi0+c3RhcnRfbW9kZV9hcCkKKwkJCXdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZShic3MsCisJCQkJCQkgICAgTkw4MDIxMV9JRlRZUEVfU1RBVElPTik7CiAJCW5sODAyMTFfbWdtdF91bnN1YnNjcmliZShic3MsICJkZWluaXQiKTsKIAl9IGVsc2UgewogCQlubDgwMjExX21nbXRfdW5zdWJzY3JpYmUoYnNzLCAiZGVpbml0Iik7CkBAIC00MjAxLDcgKzQ5MjEsNyBAQAogCX0KIAlubF9jYl9wdXQoZHJ2LT5ubF9jYik7CiAKLQlubDgwMjExX2Rlc3Ryb3lfYnNzKCZkcnYtPmZpcnN0X2Jzcyk7CisJbmw4MDIxMV9kZXN0cm95X2JzcyhkcnYtPmZpcnN0X2Jzcyk7CiAKIAlvc19mcmVlKGRydi0+ZmlsdGVyX3NzaWRzKTsKIApAQCAtNDIxMiw2ICs0OTMyLDcgQEAKIAogCW9zX2ZyZWUoZHJ2LT5leHRlbmRlZF9jYXBhKTsKIAlvc19mcmVlKGRydi0+ZXh0ZW5kZWRfY2FwYV9tYXNrKTsKKwlvc19mcmVlKGRydi0+Zmlyc3RfYnNzKTsKIAlvc19mcmVlKGRydik7CiB9CiAKQEAgLTQyMjgsNyArNDk0OSw3IEBACiB7CiAJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBlbG9vcF9jdHg7CiAJaWYgKGRydi0+YXBfc2Nhbl9hc19zdGF0aW9uICE9IE5MODAyMTFfSUZUWVBFX1VOU1BFQ0lGSUVEKSB7Ci0JCXdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZSgmZHJ2LT5maXJzdF9ic3MsCisJCXdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZShkcnYtPmZpcnN0X2JzcywKIAkJCQkJICAgIGRydi0+YXBfc2Nhbl9hc19zdGF0aW9uKTsKIAkJZHJ2LT5hcF9zY2FuX2FzX3N0YXRpb24gPSBOTDgwMjExX0lGVFlQRV9VTlNQRUNJRklFRDsKIAl9CkBAIC00MjQzLDYgKzQ5NjQsNyBAQAogewogCXN0cnVjdCBubF9tc2cgKm1zZzsKIAlzaXplX3QgaTsKKwl1MzIgc2Nhbl9mbGFncyA9IDA7CiAKIAltc2cgPSBubG1zZ19hbGxvYygpOwogCWlmICghbXNnKQpAQCAtNDI5OSw2ICs1MDIxLDIwIEBACiAJcGFyYW1zLT5maWx0ZXJfc3NpZHMgPSBOVUxMOwogCWRydi0+bnVtX2ZpbHRlcl9zc2lkcyA9IHBhcmFtcy0+bnVtX2ZpbHRlcl9zc2lkczsKIAorCWlmIChwYXJhbXMtPm9ubHlfbmV3X3Jlc3VsdHMpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBBZGQgTkw4MDIxMV9TQ0FOX0ZMQUdfRkxVU0giKTsKKwkJc2Nhbl9mbGFncyB8PSBOTDgwMjExX1NDQU5fRkxBR19GTFVTSDsKKwl9CisKKwlpZiAocGFyYW1zLT5sb3dfcHJpb3JpdHkgJiYgZHJ2LT5oYXZlX2xvd19wcmlvX3NjYW4pIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAibmw4MDIxMTogQWRkIE5MODAyMTFfU0NBTl9GTEFHX0xPV19QUklPUklUWSIpOworCQlzY2FuX2ZsYWdzIHw9IE5MODAyMTFfU0NBTl9GTEFHX0xPV19QUklPUklUWTsKKwl9CisKKwlpZiAoc2Nhbl9mbGFncykKKwkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfU0NBTl9GTEFHUywgc2Nhbl9mbGFncyk7CisKIAlyZXR1cm4gbXNnOwogCiBmYWlsOgpAQCAtNDM1Niw4ICs1MDkyLDkgQEAKIAlpZiAocmV0KSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogU2NhbiB0cmlnZ2VyIGZhaWxlZDogcmV0PSVkICIKIAkJCSAgICIoJXMpIiwgcmV0LCBzdHJlcnJvcigtcmV0KSk7Ci0jaWZkZWYgSE9TVEFQRAotCQlpZiAoaXNfYXBfaW50ZXJmYWNlKGRydi0+bmxtb2RlKSkgeworCQlpZiAoZHJ2LT5ob3N0YXBkICYmIGlzX2FwX2ludGVyZmFjZShkcnYtPm5sbW9kZSkpIHsKKwkJCWVudW0gbmw4MDIxMV9pZnR5cGUgb2xkX21vZGUgPSBkcnYtPm5sbW9kZTsKKwogCQkJLyoKIAkJCSAqIG1hYzgwMjExIGRvZXMgbm90IGFsbG93IHNjYW4gcmVxdWVzdHMgaW4gQVAgbW9kZSwgc28KIAkJCSAqIHRyeSB0byBkbyB0aGlzIGluIHN0YXRpb24gbW9kZS4KQEAgLTQzNzIsMTUgKzUxMDksMTMgQEAKIAkJCX0KIAogCQkJLyogUmVzdG9yZSBBUCBtb2RlIHdoZW4gcHJvY2Vzc2luZyBzY2FuIHJlc3VsdHMgKi8KLQkJCWRydi0+YXBfc2Nhbl9hc19zdGF0aW9uID0gZHJ2LT5ubG1vZGU7CisJCQlkcnYtPmFwX3NjYW5fYXNfc3RhdGlvbiA9IG9sZF9tb2RlOwogCQkJcmV0ID0gMDsKIAkJfSBlbHNlCiAJCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsKLSNlbHNlIC8qIEhPU1RBUEQgKi8KLQkJZ290byBubGFfcHV0X2ZhaWx1cmU7Ci0jZW5kaWYgLyogSE9TVEFQRCAqLwogCX0KIAorCWRydi0+c2Nhbl9zdGF0ZSA9IFNDQU5fUkVRVUVTVEVEOwogCS8qIE5vdCBhbGwgZHJpdmVycyBnZW5lcmF0ZSAic2NhbiBjb21wbGV0ZWQiIHdpcmVsZXNzIGV2ZW50LCBzbyB0cnkgdG8KIAkgKiByZWFkIHJlc3VsdHMgYWZ0ZXIgYSB0aW1lb3V0LiAqLwogCXRpbWVvdXQgPSAxMDsKQEAgLTQ0NTYsMTAgKzUxOTEsMjAgQEAKIAkJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfU0NIRURfU0NBTl9NQVRDSF9TU0lELAogCQkJCWRydi0+ZmlsdGVyX3NzaWRzW2ldLnNzaWRfbGVuLAogCQkJCWRydi0+ZmlsdGVyX3NzaWRzW2ldLnNzaWQpOworCQkJaWYgKHBhcmFtcy0+ZmlsdGVyX3Jzc2kpCisJCQkJTkxBX1BVVF9VMzIobXNnLAorCQkJCQkgICAgTkw4MDIxMV9TQ0hFRF9TQ0FOX01BVENIX0FUVFJfUlNTSSwKKwkJCQkJICAgIHBhcmFtcy0+ZmlsdGVyX3Jzc2kpOwogCiAJCQlubGFfbmVzdF9lbmQobXNnLCBtYXRjaF9zZXRfc3NpZCk7CiAJCX0KIAorCQkvKgorCQkgKiBEdWUgdG8gYmFja3dhcmQgY29tcGF0aWJpbGl0eSBjb2RlLCBuZXdlciBrZXJuZWxzIHRyZWF0IHRoaXMKKwkJICogbWF0Y2hzZXQgKHdpdGggb25seSBhbiBSU1NJIGZpbHRlcikgYXMgdGhlIGRlZmF1bHQgZm9yIGFsbAorCQkgKiBvdGhlciBtYXRjaHNldHMsIHVubGVzcyBpdCdzIHRoZSBvbmx5IG9uZSwgaW4gd2hpY2ggY2FzZSB0aGUKKwkJICogbWF0Y2hzZXQgd2lsbCBhY3R1YWxseSBhbGxvdyBhbGwgU1NJRHMgYWJvdmUgdGhlIFJTU0kuCisJCSAqLwogCQlpZiAocGFyYW1zLT5maWx0ZXJfcnNzaSkgewogCQkJc3RydWN0IG5sYXR0ciAqbWF0Y2hfc2V0X3Jzc2k7CiAJCQltYXRjaF9zZXRfcnNzaSA9IG5sYV9uZXN0X3N0YXJ0KG1zZywgMCk7CkBAIC00NjI3LDYgKzUzNzIsMTMgQEAKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogQXNzb2NpYXRlZCBvbiAldSBNSHoiLAogCQkJCSAgIF9hcmctPmFzc29jX2ZyZXEpOwogCQl9CisJCWlmIChzdGF0dXMgPT0gTkw4MDIxMV9CU1NfU1RBVFVTX0lCU1NfSk9JTkVEICYmCisJCSAgICBic3NbTkw4MDIxMV9CU1NfRlJFUVVFTkNZXSkgeworCQkJX2FyZy0+aWJzc19mcmVxID0KKwkJCQlubGFfZ2V0X3UzMihic3NbTkw4MDIxMV9CU1NfRlJFUVVFTkNZXSk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElCU1Mtam9pbmVkIG9uICV1IE1IeiIsCisJCQkJICAgX2FyZy0+aWJzc19mcmVxKTsKKwkJfQogCQlpZiAoc3RhdHVzID09IE5MODAyMTFfQlNTX1NUQVRVU19BU1NPQ0lBVEVEICYmCiAJCSAgICBic3NbTkw4MDIxMV9CU1NfQlNTSURdKSB7CiAJCQlvc19tZW1jcHkoX2FyZy0+YXNzb2NfYnNzaWQsCkBAIC00NzEyLDcgKzU0NjQsOCBAQAogCSAqIEJTU0lELFNTSUQgcGFpciBpcyBzZWVuIG9uIG11bHRpcGxlIGNoYW5uZWxzLiB3cGFfc3VwcGxpY2FudCBkb2VzCiAJICogbm90IHVzZSBmcmVxdWVuY3kgYXMgYSBzZXBhcmF0ZSBrZXkgaW4gdGhlIEJTUyB0YWJsZSwgc28gZmlsdGVyIG91dAogCSAqIGR1cGxpY2F0ZWQgZW50cmllcy4gUHJlZmVyIGFzc29jaWF0ZWQgQlNTIGVudHJ5IGluIHN1Y2ggYSBjYXNlIGluCi0JICogb3JkZXIgdG8gZ2V0IHRoZSBjb3JyZWN0IGZyZXF1ZW5jeSBpbnRvIHRoZSBCU1MgdGFibGUuCisJICogb3JkZXIgdG8gZ2V0IHRoZSBjb3JyZWN0IGZyZXF1ZW5jeSBpbnRvIHRoZSBCU1MgdGFibGUuIFNpbWlsYXJseSwKKwkgKiBwcmVmZXIgbmV3ZXIgZW50cmllcyBvdmVyIG9sZGVyLgogCSAqLwogCWZvciAoaSA9IDA7IGkgPCByZXMtPm51bTsgaSsrKSB7CiAJCWNvbnN0IHU4ICpzMSwgKnMyOwpAQCAtNDczMCw4ICs1NDgzLDkgQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBSZW1vdmUgZHVwbGljYXRlZCBzY2FuIHJlc3VsdCAiCiAJCQkgICAiZm9yICIgTUFDU1RSLCBNQUMyU1RSKHItPmJzc2lkKSk7CiAKLQkJaWYgKChyLT5mbGFncyAmIFdQQV9TQ0FOX0FTU09DSUFURUQpICYmCi0JCSAgICAhKHJlcy0+cmVzW2ldLT5mbGFncyAmIFdQQV9TQ0FOX0FTU09DSUFURUQpKSB7CisJCWlmICgoKHItPmZsYWdzICYgV1BBX1NDQU5fQVNTT0NJQVRFRCkgJiYKKwkJICAgICAhKHJlcy0+cmVzW2ldLT5mbGFncyAmIFdQQV9TQ0FOX0FTU09DSUFURUQpKSB8fAorCQkgICAgci0+YWdlIDwgcmVzLT5yZXNbaV0tPmFnZSkgewogCQkJb3NfZnJlZShyZXMtPnJlc1tpXSk7CiAJCQlyZXMtPnJlc1tpXSA9IHI7CiAJCX0gZWxzZQpAQCAtNDgzMiw3ICs1NTg2LDcgQEAKIAkJZ290byBubGFfcHV0X2ZhaWx1cmU7CiAKIAlubDgwMjExX2NtZChkcnYsIG1zZywgTkxNX0ZfRFVNUCwgTkw4MDIxMV9DTURfR0VUX1NDQU4pOwotCWlmIChubDgwMjExX3NldF9pZmFjZV9pZChtc2csICZkcnYtPmZpcnN0X2JzcykgPCAwKQorCWlmIChubDgwMjExX3NldF9pZmFjZV9pZChtc2csIGRydi0+Zmlyc3RfYnNzKSA8IDApCiAJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOwogCiAJYXJnLmRydiA9IGRydjsKQEAgLTQ4OTcsNiArNTY1MSw5NyBAQAogfQogCiAKK3N0YXRpYyB1MzIgd3BhX2FsZ190b19jaXBoZXJfc3VpdGUoZW51bSB3cGFfYWxnIGFsZywgc2l6ZV90IGtleV9sZW4pCit7CisJc3dpdGNoIChhbGcpIHsKKwljYXNlIFdQQV9BTEdfV0VQOgorCQlpZiAoa2V5X2xlbiA9PSA1KQorCQkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDQwOworCQlyZXR1cm4gV0xBTl9DSVBIRVJfU1VJVEVfV0VQMTA0OworCWNhc2UgV1BBX0FMR19US0lQOgorCQlyZXR1cm4gV0xBTl9DSVBIRVJfU1VJVEVfVEtJUDsKKwljYXNlIFdQQV9BTEdfQ0NNUDoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVA7CisJY2FzZSBXUEFfQUxHX0dDTVA6CisJCXJldHVybiBXTEFOX0NJUEhFUl9TVUlURV9HQ01QOworCWNhc2UgV1BBX0FMR19DQ01QXzI1NjoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVBfMjU2OworCWNhc2UgV1BBX0FMR19HQ01QXzI1NjoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVBfMjU2OworCWNhc2UgV1BBX0FMR19JR1RLOgorCQlyZXR1cm4gV0xBTl9DSVBIRVJfU1VJVEVfQUVTX0NNQUM7CisJY2FzZSBXUEFfQUxHX0JJUF9HTUFDXzEyODoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX0JJUF9HTUFDXzEyODsKKwljYXNlIFdQQV9BTEdfQklQX0dNQUNfMjU2OgorCQlyZXR1cm4gV0xBTl9DSVBIRVJfU1VJVEVfQklQX0dNQUNfMjU2OworCWNhc2UgV1BBX0FMR19CSVBfQ01BQ18yNTY6CisJCXJldHVybiBXTEFOX0NJUEhFUl9TVUlURV9CSVBfQ01BQ18yNTY7CisJY2FzZSBXUEFfQUxHX1NNUzQ6CisJCXJldHVybiBXTEFOX0NJUEhFUl9TVUlURV9TTVM0OworCWNhc2UgV1BBX0FMR19LUks6CisJCXJldHVybiBXTEFOX0NJUEhFUl9TVUlURV9LUks7CisJY2FzZSBXUEFfQUxHX05PTkU6CisJY2FzZSBXUEFfQUxHX1BNSzoKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJubDgwMjExOiBVbmV4cGVjdGVkIGVuY3J5cHRpb24gYWxnb3JpdGhtICVkIiwKKwkJCSAgIGFsZyk7CisJCXJldHVybiAwOworCX0KKworCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogVW5zdXBwb3J0ZWQgZW5jcnlwdGlvbiBhbGdvcml0aG0gJWQiLAorCQkgICBhbGcpOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyB1MzIgd3BhX2NpcGhlcl90b19jaXBoZXJfc3VpdGUodW5zaWduZWQgaW50IGNpcGhlcikKK3sKKwlzd2l0Y2ggKGNpcGhlcikgeworCWNhc2UgV1BBX0NJUEhFUl9DQ01QXzI1NjoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVBfMjU2OworCWNhc2UgV1BBX0NJUEhFUl9HQ01QXzI1NjoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVBfMjU2OworCWNhc2UgV1BBX0NJUEhFUl9DQ01QOgorCQlyZXR1cm4gV0xBTl9DSVBIRVJfU1VJVEVfQ0NNUDsKKwljYXNlIFdQQV9DSVBIRVJfR0NNUDoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVA7CisJY2FzZSBXUEFfQ0lQSEVSX1RLSVA6CisJCXJldHVybiBXTEFOX0NJUEhFUl9TVUlURV9US0lQOworCWNhc2UgV1BBX0NJUEhFUl9XRVAxMDQ6CisJCXJldHVybiBXTEFOX0NJUEhFUl9TVUlURV9XRVAxMDQ7CisJY2FzZSBXUEFfQ0lQSEVSX1dFUDQwOgorCQlyZXR1cm4gV0xBTl9DSVBIRVJfU1VJVEVfV0VQNDA7CisJY2FzZSBXUEFfQ0lQSEVSX0dUS19OT1RfVVNFRDoKKwkJcmV0dXJuIFdMQU5fQ0lQSEVSX1NVSVRFX05PX0dST1VQX0FERFI7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cGFfY2lwaGVyX3RvX2NpcGhlcl9zdWl0ZXModW5zaWduZWQgaW50IGNpcGhlcnMsIHUzMiBzdWl0ZXNbXSwKKwkJCQkgICAgICAgaW50IG1heF9zdWl0ZXMpCit7CisJaW50IG51bV9zdWl0ZXMgPSAwOworCisJaWYgKG51bV9zdWl0ZXMgPCBtYXhfc3VpdGVzICYmIGNpcGhlcnMgJiBXUEFfQ0lQSEVSX0NDTVBfMjU2KQorCQlzdWl0ZXNbbnVtX3N1aXRlcysrXSA9IFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVBfMjU2OworCWlmIChudW1fc3VpdGVzIDwgbWF4X3N1aXRlcyAmJiBjaXBoZXJzICYgV1BBX0NJUEhFUl9HQ01QXzI1NikKKwkJc3VpdGVzW251bV9zdWl0ZXMrK10gPSBXTEFOX0NJUEhFUl9TVUlURV9HQ01QXzI1NjsKKwlpZiAobnVtX3N1aXRlcyA8IG1heF9zdWl0ZXMgJiYgY2lwaGVycyAmIFdQQV9DSVBIRVJfQ0NNUCkKKwkJc3VpdGVzW251bV9zdWl0ZXMrK10gPSBXTEFOX0NJUEhFUl9TVUlURV9DQ01QOworCWlmIChudW1fc3VpdGVzIDwgbWF4X3N1aXRlcyAmJiBjaXBoZXJzICYgV1BBX0NJUEhFUl9HQ01QKQorCQlzdWl0ZXNbbnVtX3N1aXRlcysrXSA9IFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVA7CisJaWYgKG51bV9zdWl0ZXMgPCBtYXhfc3VpdGVzICYmIGNpcGhlcnMgJiBXUEFfQ0lQSEVSX1RLSVApCisJCXN1aXRlc1tudW1fc3VpdGVzKytdID0gV0xBTl9DSVBIRVJfU1VJVEVfVEtJUDsKKwlpZiAobnVtX3N1aXRlcyA8IG1heF9zdWl0ZXMgJiYgY2lwaGVycyAmIFdQQV9DSVBIRVJfV0VQMTA0KQorCQlzdWl0ZXNbbnVtX3N1aXRlcysrXSA9IFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDEwNDsKKwlpZiAobnVtX3N1aXRlcyA8IG1heF9zdWl0ZXMgJiYgY2lwaGVycyAmIFdQQV9DSVBIRVJfV0VQNDApCisJCXN1aXRlc1tudW1fc3VpdGVzKytdID0gV0xBTl9DSVBIRVJfU1VJVEVfV0VQNDA7CisKKwlyZXR1cm4gbnVtX3N1aXRlczsKK30KKworCiBzdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfa2V5KGNvbnN0IGNoYXIgKmlmbmFtZSwgc3RydWN0IGk4MDJfYnNzICpic3MsCiAJCQkJICAgICAgZW51bSB3cGFfYWxnIGFsZywgY29uc3QgdTggKmFkZHIsCiAJCQkJICAgICAgaW50IGtleV9pZHgsIGludCBzZXRfdHgsCkBAIC00OTM0LDQ5ICs1Nzc5LDE1IEBACiAJfSBlbHNlIHsKIAkJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX05FV19LRVkpOwogCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0tFWV9EQVRBLCBrZXlfbGVuLCBrZXkpOwotCQlzd2l0Y2ggKGFsZykgewotCQljYXNlIFdQQV9BTEdfV0VQOgotCQkJaWYgKGtleV9sZW4gPT0gNSkKLQkJCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9LRVlfQ0lQSEVSLAotCQkJCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfV0VQNDApOwotCQkJZWxzZQotCQkJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0tFWV9DSVBIRVIsCi0JCQkJCSAgICBXTEFOX0NJUEhFUl9TVUlURV9XRVAxMDQpOwotCQkJYnJlYWs7Ci0JCWNhc2UgV1BBX0FMR19US0lQOgotCQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfS0VZX0NJUEhFUiwKLQkJCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfVEtJUCk7Ci0JCQlicmVhazsKLQkJY2FzZSBXUEFfQUxHX0NDTVA6Ci0JCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9LRVlfQ0lQSEVSLAotCQkJCSAgICBXTEFOX0NJUEhFUl9TVUlURV9DQ01QKTsKLQkJCWJyZWFrOwotCQljYXNlIFdQQV9BTEdfR0NNUDoKLQkJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0tFWV9DSVBIRVIsCi0JCQkJICAgIFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVApOwotCQkJYnJlYWs7Ci0JCWNhc2UgV1BBX0FMR19JR1RLOgotCQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfS0VZX0NJUEhFUiwKLQkJCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfQUVTX0NNQUMpOwotCQkJYnJlYWs7Ci0JCWNhc2UgV1BBX0FMR19TTVM0OgotCQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfS0VZX0NJUEhFUiwKLQkJCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfU01TNCk7Ci0JCQlicmVhazsKLQkJY2FzZSBXUEFfQUxHX0tSSzoKLQkJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0tFWV9DSVBIRVIsCi0JCQkJICAgIFdMQU5fQ0lQSEVSX1NVSVRFX0tSSyk7Ci0JCQlicmVhazsKLQkJZGVmYXVsdDoKLQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IFVuc3VwcG9ydGVkIGVuY3J5cHRpb24gIgotCQkJCSAgICJhbGdvcml0aG0gJWQiLCBfX2Z1bmNfXywgYWxnKTsKLQkJCW5sbXNnX2ZyZWUobXNnKTsKLQkJCXJldHVybiAtMTsKLQkJfQorCQl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAibmw4MDIxMTogS0VZX0RBVEEiLCBrZXksIGtleV9sZW4pOworCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9LRVlfQ0lQSEVSLAorCQkJICAgIHdwYV9hbGdfdG9fY2lwaGVyX3N1aXRlKGFsZywga2V5X2xlbikpOwogCX0KIAotCWlmIChzZXEgJiYgc2VxX2xlbikKKwlpZiAoc2VxICYmIHNlcV9sZW4pIHsKIAkJTkxBX1BVVChtc2csIE5MODAyMTFfQVRUUl9LRVlfU0VRLCBzZXFfbGVuLCBzZXEpOworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJubDgwMjExOiBLRVlfU0VRIiwgc2VxLCBzZXFfbGVuKTsKKwl9CiAKIAlpZiAoYWRkciAmJiAhaXNfYnJvYWRjYXN0X2V0aGVyX2FkZHIoYWRkcikpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBhZGRyPSIgTUFDU1RSLCBNQUMyU1RSKGFkZHIpKTsKQEAgLTUwNzcsMzMgKzU4ODgsOCBAQAogCiAJTkxBX1BVVF9VOChtc2csIE5MODAyMTFfS0VZX0lEWCwga2V5X2lkeCk7CiAKLQlzd2l0Y2ggKGFsZykgewotCWNhc2UgV1BBX0FMR19XRVA6Ci0JCWlmIChrZXlfbGVuID09IDUpCi0JCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfS0VZX0NJUEhFUiwKLQkJCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfV0VQNDApOwotCQllbHNlCi0JCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfS0VZX0NJUEhFUiwKLQkJCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfV0VQMTA0KTsKLQkJYnJlYWs7Ci0JY2FzZSBXUEFfQUxHX1RLSVA6Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9LRVlfQ0lQSEVSLCBXTEFOX0NJUEhFUl9TVUlURV9US0lQKTsKLQkJYnJlYWs7Ci0JY2FzZSBXUEFfQUxHX0NDTVA6Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9LRVlfQ0lQSEVSLCBXTEFOX0NJUEhFUl9TVUlURV9DQ01QKTsKLQkJYnJlYWs7Ci0JY2FzZSBXUEFfQUxHX0dDTVA6Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9LRVlfQ0lQSEVSLCBXTEFOX0NJUEhFUl9TVUlURV9HQ01QKTsKLQkJYnJlYWs7Ci0JY2FzZSBXUEFfQUxHX0lHVEs6Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9LRVlfQ0lQSEVSLAotCQkJICAgIFdMQU5fQ0lQSEVSX1NVSVRFX0FFU19DTUFDKTsKLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICIlczogVW5zdXBwb3J0ZWQgZW5jcnlwdGlvbiAiCi0JCQkgICAiYWxnb3JpdGhtICVkIiwgX19mdW5jX18sIGFsZyk7Ci0JCXJldHVybiAtMTsKLQl9CisJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0tFWV9DSVBIRVIsCisJCSAgICB3cGFfYWxnX3RvX2NpcGhlcl9zdWl0ZShhbGcsIGtleV9sZW4pKTsKIAogCWlmIChzZXEgJiYgc2VxX2xlbikKIAkJTkxBX1BVVChtc2csIE5MODAyMTFfS0VZX1NFUSwgc2VxX2xlbiwgc2VxKTsKQEAgLTUyMzgsMTUgKzYwMjQsMjUgQEAKIAkJCQkJICAgICBjb25zdCB1OCAqYWRkciwgaW50IHJlYXNvbl9jb2RlKQogewogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CisJaW50IHJldDsKKworCWlmIChkcnYtPm5sbW9kZSA9PSBOTDgwMjExX0lGVFlQRV9BREhPQykgeworCQlubDgwMjExX21hcmtfZGlzY29ubmVjdGVkKGRydik7CisJCXJldHVybiBubDgwMjExX2xlYXZlX2lic3MoZHJ2KTsKKwl9CiAJaWYgKCEoZHJ2LT5jYXBhLmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19TTUUpKQogCQlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX2Rpc2Nvbm5lY3QoZHJ2LCByZWFzb25fY29kZSk7CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyhhZGRyPSIgTUFDU1RSICIgcmVhc29uX2NvZGU9JWQpIiwKIAkJICAgX19mdW5jX18sIE1BQzJTVFIoYWRkciksIHJlYXNvbl9jb2RlKTsKIAlubDgwMjExX21hcmtfZGlzY29ubmVjdGVkKGRydik7Ci0JaWYgKGRydi0+bmxtb2RlID09IE5MODAyMTFfSUZUWVBFX0FESE9DKQotCQlyZXR1cm4gbmw4MDIxMV9sZWF2ZV9pYnNzKGRydik7Ci0JcmV0dXJuIHdwYV9kcml2ZXJfbmw4MDIxMV9tbG1lKGRydiwgYWRkciwgTkw4MDIxMV9DTURfREVBVVRIRU5USUNBVEUsCi0JCQkJICAgICAgIHJlYXNvbl9jb2RlLCAwKTsKKwlyZXQgPSB3cGFfZHJpdmVyX25sODAyMTFfbWxtZShkcnYsIGFkZHIsIE5MODAyMTFfQ01EX0RFQVVUSEVOVElDQVRFLAorCQkJCSAgICAgIHJlYXNvbl9jb2RlLCAwKTsKKwkvKgorCSAqIEZvciBsb2NhbGx5IGdlbmVyYXRlZCBkZWF1dGhlbnRpY2F0ZSwgc3VwcGxpY2FudCBhbHJlYWR5IGdlbmVyYXRlcyBhCisJICogREVBVVRIIGV2ZW50LCBzbyBpZ25vcmUgdGhlIGV2ZW50IGZyb20gTkw4MDIxMS4KKwkgKi8KKwlkcnYtPmlnbm9yZV9uZXh0X2xvY2FsX2RlYXV0aCA9IHJldCA9PSAwOworCXJldHVybiByZXQ7CiB9CiAKIApAQCAtNTMwOSw2ICs2MTA1LDcgQEAKIAogCWlzX3JldHJ5ID0gZHJ2LT5yZXRyeV9hdXRoOwogCWRydi0+cmV0cnlfYXV0aCA9IDA7CisJZHJ2LT5pZ25vcmVfZGVhdXRoX2V2ZW50ID0gMDsKIAogCW5sODAyMTFfbWFya19kaXNjb25uZWN0ZWQoZHJ2KTsKIAlvc19tZW1zZXQoZHJ2LT5hdXRoX2Jzc2lkLCAwLCBFVEhfQUxFTik7CkBAIC01NDEwLDYgKzYyMDcsNyBAQAogCQkJICovCiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFJldHJ5IGF1dGhlbnRpY2F0aW9uICIKIAkJCQkgICAiYWZ0ZXIgZm9yY2VkIGRlYXV0aGVudGljYXRpb24iKTsKKwkJCWRydi0+aWdub3JlX2RlYXV0aF9ldmVudCA9IDE7CiAJCQl3cGFfZHJpdmVyX25sODAyMTFfZGVhdXRoZW50aWNhdGUoCiAJCQkJYnNzLCBwYXJhbXMtPmJzc2lkLAogCQkJCVdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwpAQCAtNTQ3NSw3ICs2MjczLDcgQEAKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydikKIHsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9hdXRoX3BhcmFtcyBwYXJhbXM7Ci0Jc3RydWN0IGk4MDJfYnNzICpic3MgPSAmZHJ2LT5maXJzdF9ic3M7CisJc3RydWN0IGk4MDJfYnNzICpic3MgPSBkcnYtPmZpcnN0X2JzczsKIAlpbnQgaTsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogVHJ5IHRvIGF1dGhlbnRpY2F0ZSBhZ2FpbiIpOwpAQCAtNTU2MCwyMiArNjM1OCwxNyBAQAogCXU4IGNoYW5uZWw7CiAJY2hhbi0+ZnJlcSA9IG5sYV9nZXRfdTMyKHRiX2ZyZXFbTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9GUkVRXSk7CiAJY2hhbi0+ZmxhZyA9IDA7CisJY2hhbi0+ZGZzX2NhY19tcyA9IDA7CiAJaWYgKGllZWU4MDIxMV9mcmVxX3RvX2NoYW4oY2hhbi0+ZnJlcSwgJmNoYW5uZWwpICE9IE5VTV9IT1NUQVBEX01PREVTKQogCQljaGFuLT5jaGFuID0gY2hhbm5lbDsKIAogCWlmICh0Yl9mcmVxW05MODAyMTFfRlJFUVVFTkNZX0FUVFJfRElTQUJMRURdKQogCQljaGFuLT5mbGFnIHw9IEhPU1RBUERfQ0hBTl9ESVNBQkxFRDsKLQlpZiAodGJfZnJlcVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX1BBU1NJVkVfU0NBTl0pCi0JCWNoYW4tPmZsYWcgfD0gSE9TVEFQRF9DSEFOX1BBU1NJVkVfU0NBTjsKLQlpZiAodGJfZnJlcVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lCU1NdKQotCQljaGFuLT5mbGFnIHw9IEhPU1RBUERfQ0hBTl9OT19JQlNTOworCWlmICh0Yl9mcmVxW05MODAyMTFfRlJFUVVFTkNZX0FUVFJfTk9fSVJdKQorCQljaGFuLT5mbGFnIHw9IEhPU1RBUERfQ0hBTl9QQVNTSVZFX1NDQU4gfCBIT1NUQVBEX0NIQU5fTk9fSUJTUzsKIAlpZiAodGJfZnJlcVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX1JBREFSXSkKIAkJY2hhbi0+ZmxhZyB8PSBIT1NUQVBEX0NIQU5fUkFEQVI7CiAKLQlpZiAodGJfZnJlcVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWF9UWF9QT1dFUl0gJiYKLQkgICAgIXRiX2ZyZXFbTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9ESVNBQkxFRF0pCi0JCWNoYW4tPm1heF90eF9wb3dlciA9IG5sYV9nZXRfdTMyKAotCQkJdGJfZnJlcVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWF9UWF9QT1dFUl0pIC8gMTAwOwogCWlmICh0Yl9mcmVxW05MODAyMTFfRlJFUVVFTkNZX0FUVFJfREZTX1NUQVRFXSkgewogCQllbnVtIG5sODAyMTFfZGZzX3N0YXRlIHN0YXRlID0KIAkJCW5sYV9nZXRfdTMyKHRiX2ZyZXFbTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9ERlNfU1RBVEVdKTsKQEAgLTU1OTIsNiArNjM4NSwxMSBAQAogCQkJYnJlYWs7CiAJCX0KIAl9CisKKwlpZiAodGJfZnJlcVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0RGU19DQUNfVElNRV0pIHsKKwkJY2hhbi0+ZGZzX2NhY19tcyA9IG5sYV9nZXRfdTMyKAorCQkJdGJfZnJlcVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0RGU19DQUNfVElNRV0pOworCX0KIH0KIAogCkBAIC01NjAxLDggKzYzOTksNyBAQAogCXN0YXRpYyBzdHJ1Y3QgbmxhX3BvbGljeSBmcmVxX3BvbGljeVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWCArIDFdID0gewogCQlbTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9GUkVRXSA9IHsgLnR5cGUgPSBOTEFfVTMyIH0sCiAJCVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0RJU0FCTEVEXSA9IHsgLnR5cGUgPSBOTEFfRkxBRyB9LAotCQlbTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9QQVNTSVZFX1NDQU5dID0geyAudHlwZSA9IE5MQV9GTEFHIH0sCi0JCVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lCU1NdID0geyAudHlwZSA9IE5MQV9GTEFHIH0sCisJCVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lSXSA9IHsgLnR5cGUgPSBOTEFfRkxBRyB9LAogCQlbTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9SQURBUl0gPSB7IC50eXBlID0gTkxBX0ZMQUcgfSwKIAkJW05MODAyMTFfRlJFUVVFTkNZX0FUVFJfTUFYX1RYX1BPV0VSXSA9IHsgLnR5cGUgPSBOTEFfVTMyIH0sCiAJCVtOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0RGU19TVEFURV0gPSB7IC50eXBlID0gTkxBX1UzMiB9LApAQCAtNTg5OCwyNSArNjY5NSwyOSBAQAogfQogCiAKLXN0YXRpYyB2b2lkIG5sODAyMTFfcmVnX3J1bGVfaHQ0MChzdHJ1Y3QgbmxhdHRyICp0YltdLAotCQkJCSAgc3RydWN0IHBoeV9pbmZvX2FyZyAqcmVzdWx0cykKK3N0YXRpYyB2b2lkIG5sODAyMTFfcmVnX3J1bGVfbWF4X2VpcnAodTMyIHN0YXJ0LCB1MzIgZW5kLCB1MzIgbWF4X2VpcnAsCisJCQkJICAgICAgc3RydWN0IHBoeV9pbmZvX2FyZyAqcmVzdWx0cykKIHsKLQl1MzIgc3RhcnQsIGVuZCwgbWF4X2J3OwogCXUxNiBtOwogCi0JaWYgKHRiW05MODAyMTFfQVRUUl9GUkVRX1JBTkdFX1NUQVJUXSA9PSBOVUxMIHx8Ci0JICAgIHRiW05MODAyMTFfQVRUUl9GUkVRX1JBTkdFX0VORF0gPT0gTlVMTCB8fAotCSAgICB0YltOTDgwMjExX0FUVFJfRlJFUV9SQU5HRV9NQVhfQlddID09IE5VTEwpCi0JCXJldHVybjsKKwlmb3IgKG0gPSAwOyBtIDwgKnJlc3VsdHMtPm51bV9tb2RlczsgbSsrKSB7CisJCWludCBjOworCQlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZSA9ICZyZXN1bHRzLT5tb2Rlc1ttXTsKIAotCXN0YXJ0ID0gbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX0ZSRVFfUkFOR0VfU1RBUlRdKSAvIDEwMDA7Ci0JZW5kID0gbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX0ZSRVFfUkFOR0VfRU5EXSkgLyAxMDAwOwotCW1heF9idyA9IG5sYV9nZXRfdTMyKHRiW05MODAyMTFfQVRUUl9GUkVRX1JBTkdFX01BWF9CV10pIC8gMTAwMDsKKwkJZm9yIChjID0gMDsgYyA8IG1vZGUtPm51bV9jaGFubmVsczsgYysrKSB7CisJCQlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4gPSAmbW9kZS0+Y2hhbm5lbHNbY107CisJCQlpZiAoKHUzMikgY2hhbi0+ZnJlcSAtIDEwID49IHN0YXJ0ICYmCisJCQkgICAgKHUzMikgY2hhbi0+ZnJlcSArIDEwIDw9IGVuZCkKKwkJCQljaGFuLT5tYXhfdHhfcG93ZXIgPSBtYXhfZWlycDsKKwkJfQorCX0KK30KIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogJXUtJXUgQCAldSBNSHoiLAotCQkgICBzdGFydCwgZW5kLCBtYXhfYncpOwotCWlmIChtYXhfYncgPCA0MCkKLQkJcmV0dXJuOworCitzdGF0aWMgdm9pZCBubDgwMjExX3JlZ19ydWxlX2h0NDAodTMyIHN0YXJ0LCB1MzIgZW5kLAorCQkJCSAgc3RydWN0IHBoeV9pbmZvX2FyZyAqcmVzdWx0cykKK3sKKwl1MTYgbTsKIAogCWZvciAobSA9IDA7IG0gPCAqcmVzdWx0cy0+bnVtX21vZGVzOyBtKyspIHsKIAkJaWYgKCEocmVzdWx0cy0+bW9kZXNbbV0uaHRfY2FwYWIgJgpAQCAtNTk1NCw2ICs2NzU1LDc2IEBACiB9CiAKIAorc3RhdGljIHZvaWQgbmw4MDIxMV9zZXRfdmh0X21vZGUoc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGUsIGludCBzdGFydCwKKwkJCQkgaW50IGVuZCkKK3sKKwlpbnQgYzsKKworCWZvciAoYyA9IDA7IGMgPCBtb2RlLT5udW1fY2hhbm5lbHM7IGMrKykgeworCQlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4gPSAmbW9kZS0+Y2hhbm5lbHNbY107CisJCWlmIChjaGFuLT5mcmVxIC0gMTAgPj0gc3RhcnQgJiYgY2hhbi0+ZnJlcSArIDcwIDw9IGVuZCkKKwkJCWNoYW4tPmZsYWcgfD0gSE9TVEFQRF9DSEFOX1ZIVF8xMF83MDsKKworCQlpZiAoY2hhbi0+ZnJlcSAtIDMwID49IHN0YXJ0ICYmIGNoYW4tPmZyZXEgKyA1MCA8PSBlbmQpCisJCQljaGFuLT5mbGFnIHw9IEhPU1RBUERfQ0hBTl9WSFRfMzBfNTA7CisKKwkJaWYgKGNoYW4tPmZyZXEgLSA1MCA+PSBzdGFydCAmJiBjaGFuLT5mcmVxICsgMzAgPD0gZW5kKQorCQkJY2hhbi0+ZmxhZyB8PSBIT1NUQVBEX0NIQU5fVkhUXzUwXzMwOworCisJCWlmIChjaGFuLT5mcmVxIC0gNzAgPj0gc3RhcnQgJiYgY2hhbi0+ZnJlcSArIDEwIDw9IGVuZCkKKwkJCWNoYW4tPmZsYWcgfD0gSE9TVEFQRF9DSEFOX1ZIVF83MF8xMDsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgbmw4MDIxMV9yZWdfcnVsZV92aHQoc3RydWN0IG5sYXR0ciAqdGJbXSwKKwkJCQkgc3RydWN0IHBoeV9pbmZvX2FyZyAqcmVzdWx0cykKK3sKKwl1MzIgc3RhcnQsIGVuZCwgbWF4X2J3OworCXUxNiBtOworCisJaWYgKHRiW05MODAyMTFfQVRUUl9GUkVRX1JBTkdFX1NUQVJUXSA9PSBOVUxMIHx8CisJICAgIHRiW05MODAyMTFfQVRUUl9GUkVRX1JBTkdFX0VORF0gPT0gTlVMTCB8fAorCSAgICB0YltOTDgwMjExX0FUVFJfRlJFUV9SQU5HRV9NQVhfQlddID09IE5VTEwpCisJCXJldHVybjsKKworCXN0YXJ0ID0gbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX0ZSRVFfUkFOR0VfU1RBUlRdKSAvIDEwMDA7CisJZW5kID0gbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX0ZSRVFfUkFOR0VfRU5EXSkgLyAxMDAwOworCW1heF9idyA9IG5sYV9nZXRfdTMyKHRiW05MODAyMTFfQVRUUl9GUkVRX1JBTkdFX01BWF9CV10pIC8gMTAwMDsKKworCWlmIChtYXhfYncgPCA4MCkKKwkJcmV0dXJuOworCisJZm9yIChtID0gMDsgbSA8ICpyZXN1bHRzLT5udW1fbW9kZXM7IG0rKykgeworCQlpZiAoIShyZXN1bHRzLT5tb2Rlc1ttXS5odF9jYXBhYiAmCisJCSAgICAgIEhUX0NBUF9JTkZPX1NVUFBfQ0hBTk5FTF9XSURUSF9TRVQpKQorCQkJY29udGludWU7CisJCS8qIFRPRE86IHVzZSBhIHJlYWwgVkhUIHN1cHBvcnQgaW5kaWNhdGlvbiAqLworCQlpZiAoIXJlc3VsdHMtPm1vZGVzW21dLnZodF9jYXBhYikKKwkJCWNvbnRpbnVlOworCisJCW5sODAyMTFfc2V0X3ZodF9tb2RlKCZyZXN1bHRzLT5tb2Rlc1ttXSwgc3RhcnQsIGVuZCk7CisJfQorfQorCisKK3N0YXRpYyBjb25zdCBjaGFyICogZGZzX2RvbWFpbl9uYW1lKGVudW0gbmw4MDIxMV9kZnNfcmVnaW9ucyByZWdpb24pCit7CisJc3dpdGNoIChyZWdpb24pIHsKKwljYXNlIE5MODAyMTFfREZTX1VOU0VUOgorCQlyZXR1cm4gIkRGUy1VTlNFVCI7CisJY2FzZSBOTDgwMjExX0RGU19GQ0M6CisJCXJldHVybiAiREZTLUZDQyI7CisJY2FzZSBOTDgwMjExX0RGU19FVFNJOgorCQlyZXR1cm4gIkRGUy1FVFNJIjsKKwljYXNlIE5MODAyMTFfREZTX0pQOgorCQlyZXR1cm4gIkRGUy1KUCI7CisJZGVmYXVsdDoKKwkJcmV0dXJuICJERlMtaW52YWxpZCI7CisJfQorfQorCisKIHN0YXRpYyBpbnQgbmw4MDIxMV9nZXRfcmVnKHN0cnVjdCBubF9tc2cgKm1zZywgdm9pZCAqYXJnKQogewogCXN0cnVjdCBwaHlfaW5mb19hcmcgKnJlc3VsdHMgPSBhcmc7CkBAIC01OTgwLDE0ICs2ODUxLDUwIEBACiAJCXJldHVybiBOTF9TS0lQOwogCX0KIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogUmVndWxhdG9yeSBpbmZvcm1hdGlvbiAtIGNvdW50cnk9JXMiLAotCQkgICAoY2hhciAqKSBubGFfZGF0YSh0Yl9tc2dbTkw4MDIxMV9BVFRSX1JFR19BTFBIQTJdKSk7CisJaWYgKHRiX21zZ1tOTDgwMjExX0FUVFJfREZTX1JFR0lPTl0pIHsKKwkJZW51bSBubDgwMjExX2Rmc19yZWdpb25zIGRmc19kb21haW47CisJCWRmc19kb21haW4gPSBubGFfZ2V0X3U4KHRiX21zZ1tOTDgwMjExX0FUVFJfREZTX1JFR0lPTl0pOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFJlZ3VsYXRvcnkgaW5mb3JtYXRpb24gLSBjb3VudHJ5PSVzICglcykiLAorCQkJICAgKGNoYXIgKikgbmxhX2RhdGEodGJfbXNnW05MODAyMTFfQVRUUl9SRUdfQUxQSEEyXSksCisJCQkgICBkZnNfZG9tYWluX25hbWUoZGZzX2RvbWFpbikpOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogUmVndWxhdG9yeSBpbmZvcm1hdGlvbiAtIGNvdW50cnk9JXMiLAorCQkJICAgKGNoYXIgKikgbmxhX2RhdGEodGJfbXNnW05MODAyMTFfQVRUUl9SRUdfQUxQSEEyXSkpOworCX0KIAogCW5sYV9mb3JfZWFjaF9uZXN0ZWQobmxfcnVsZSwgdGJfbXNnW05MODAyMTFfQVRUUl9SRUdfUlVMRVNdLCByZW1fcnVsZSkKIAl7CisJCXUzMiBzdGFydCwgZW5kLCBtYXhfZWlycCA9IDAsIG1heF9idyA9IDAsIGZsYWdzID0gMDsKIAkJbmxhX3BhcnNlKHRiX3J1bGUsIE5MODAyMTFfRlJFUVVFTkNZX0FUVFJfTUFYLAogCQkJICBubGFfZGF0YShubF9ydWxlKSwgbmxhX2xlbihubF9ydWxlKSwgcmVnX3BvbGljeSk7Ci0JCW5sODAyMTFfcmVnX3J1bGVfaHQ0MCh0Yl9ydWxlLCByZXN1bHRzKTsKKwkJaWYgKHRiX3J1bGVbTkw4MDIxMV9BVFRSX0ZSRVFfUkFOR0VfU1RBUlRdID09IE5VTEwgfHwKKwkJICAgIHRiX3J1bGVbTkw4MDIxMV9BVFRSX0ZSRVFfUkFOR0VfRU5EXSA9PSBOVUxMKQorCQkJY29udGludWU7CisJCXN0YXJ0ID0gbmxhX2dldF91MzIodGJfcnVsZVtOTDgwMjExX0FUVFJfRlJFUV9SQU5HRV9TVEFSVF0pIC8gMTAwMDsKKwkJZW5kID0gbmxhX2dldF91MzIodGJfcnVsZVtOTDgwMjExX0FUVFJfRlJFUV9SQU5HRV9FTkRdKSAvIDEwMDA7CisJCWlmICh0Yl9ydWxlW05MODAyMTFfQVRUUl9QT1dFUl9SVUxFX01BWF9FSVJQXSkKKwkJCW1heF9laXJwID0gbmxhX2dldF91MzIodGJfcnVsZVtOTDgwMjExX0FUVFJfUE9XRVJfUlVMRV9NQVhfRUlSUF0pIC8gMTAwOworCQlpZiAodGJfcnVsZVtOTDgwMjExX0FUVFJfRlJFUV9SQU5HRV9NQVhfQlddKQorCQkJbWF4X2J3ID0gbmxhX2dldF91MzIodGJfcnVsZVtOTDgwMjExX0FUVFJfRlJFUV9SQU5HRV9NQVhfQlddKSAvIDEwMDA7CisJCWlmICh0Yl9ydWxlW05MODAyMTFfQVRUUl9SRUdfUlVMRV9GTEFHU10pCisJCQlmbGFncyA9IG5sYV9nZXRfdTMyKHRiX3J1bGVbTkw4MDIxMV9BVFRSX1JFR19SVUxFX0ZMQUdTXSk7CisKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiAldS0ldSBAICV1IE1IeiAldSBtQm0lcyVzJXMlcyVzJXMlcyVzIiwKKwkJCSAgIHN0YXJ0LCBlbmQsIG1heF9idywgbWF4X2VpcnAsCisJCQkgICBmbGFncyAmIE5MODAyMTFfUlJGX05PX09GRE0gPyAiIChubyBPRkRNKSIgOiAiIiwKKwkJCSAgIGZsYWdzICYgTkw4MDIxMV9SUkZfTk9fQ0NLID8gIiAobm8gQ0NLKSIgOiAiIiwKKwkJCSAgIGZsYWdzICYgTkw4MDIxMV9SUkZfTk9fSU5ET09SID8gIiAobm8gaW5kb29yKSIgOiAiIiwKKwkJCSAgIGZsYWdzICYgTkw4MDIxMV9SUkZfTk9fT1VURE9PUiA/ICIgKG5vIG91dGRvb3IpIiA6CisJCQkgICAiIiwKKwkJCSAgIGZsYWdzICYgTkw4MDIxMV9SUkZfREZTID8gIiAoREZTKSIgOiAiIiwKKwkJCSAgIGZsYWdzICYgTkw4MDIxMV9SUkZfUFRQX09OTFkgPyAiIChQVFAgb25seSkiIDogIiIsCisJCQkgICBmbGFncyAmIE5MODAyMTFfUlJGX1BUTVBfT05MWSA/ICIgKFBUTVAgb25seSkiIDogIiIsCisJCQkgICBmbGFncyAmIE5MODAyMTFfUlJGX05PX0lSID8gIiAobm8gSVIpIiA6ICIiKTsKKwkJaWYgKG1heF9idyA+PSA0MCkKKwkJCW5sODAyMTFfcmVnX3J1bGVfaHQ0MChzdGFydCwgZW5kLCByZXN1bHRzKTsKKwkJaWYgKHRiX3J1bGVbTkw4MDIxMV9BVFRSX1BPV0VSX1JVTEVfTUFYX0VJUlBdKQorCQkJbmw4MDIxMV9yZWdfcnVsZV9tYXhfZWlycChzdGFydCwgZW5kLCBtYXhfZWlycCwKKwkJCQkJCSAgcmVzdWx0cyk7CiAJfQogCiAJbmxhX2Zvcl9lYWNoX25lc3RlZChubF9ydWxlLCB0Yl9tc2dbTkw4MDIxMV9BVFRSX1JFR19SVUxFU10sIHJlbV9ydWxlKQpAQCAtNTk5NywxMiArNjkwNCwxOSBAQAogCQlubDgwMjExX3JlZ19ydWxlX3NlYyh0Yl9ydWxlLCByZXN1bHRzKTsKIAl9CiAKKwlubGFfZm9yX2VhY2hfbmVzdGVkKG5sX3J1bGUsIHRiX21zZ1tOTDgwMjExX0FUVFJfUkVHX1JVTEVTXSwgcmVtX3J1bGUpCisJeworCQlubGFfcGFyc2UodGJfcnVsZSwgTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9NQVgsCisJCQkgIG5sYV9kYXRhKG5sX3J1bGUpLCBubGFfbGVuKG5sX3J1bGUpLCByZWdfcG9saWN5KTsKKwkJbmw4MDIxMV9yZWdfcnVsZV92aHQodGJfcnVsZSwgcmVzdWx0cyk7CisJfQorCiAJcmV0dXJuIE5MX1NLSVA7CiB9CiAKIAotc3RhdGljIGludCBubDgwMjExX3NldF9odDQwX2ZsYWdzKHN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2LAotCQkJCSAgc3RydWN0IHBoeV9pbmZvX2FyZyAqcmVzdWx0cykKK3N0YXRpYyBpbnQgbmw4MDIxMV9zZXRfcmVndWxhdG9yeV9mbGFncyhzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKKwkJCQkJc3RydWN0IHBoeV9pbmZvX2FyZyAqcmVzdWx0cykKIHsKIAlzdHJ1Y3QgbmxfbXNnICptc2c7CiAKQEAgLTYwNDIsMTAgKzY5NTYsMTEgQEAKIAkJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX0dFVF9XSVBIWSk7CiAKIAlOTEFfUFVUX0ZMQUcobXNnLCBOTDgwMjExX0FUVFJfU1BMSVRfV0lQSFlfRFVNUCk7Ci0JTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfSUZJTkRFWCwgZHJ2LT5pZmluZGV4KTsKKwlpZiAobmw4MDIxMV9zZXRfaWZhY2VfaWQobXNnLCBic3MpIDwgMCkKKwkJZ290byBubGFfcHV0X2ZhaWx1cmU7CiAKIAlpZiAoc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBwaHlfaW5mb19oYW5kbGVyLCAmcmVzdWx0KSA9PSAwKSB7Ci0JCW5sODAyMTFfc2V0X2h0NDBfZmxhZ3MoZHJ2LCAmcmVzdWx0KTsKKwkJbmw4MDIxMV9zZXRfcmVndWxhdG9yeV9mbGFncyhkcnYsICZyZXN1bHQpOwogCQlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3Bvc3Rwcm9jZXNzX21vZGVzKHJlc3VsdC5tb2RlcywKIAkJCQkJCQkgICAgbnVtX21vZGVzKTsKIAl9CkBAIC02MTIxLDE2ICs3MDM2LDQ4IEBACiB7CiAJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKIAl1NjQgY29va2llOworCWludCByZXM7CiAKLQlpZiAoZnJlcSA9PSAwKQorCWlmIChmcmVxID09IDAgJiYgZHJ2LT5ubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfQURIT0MpIHsKKwkJZnJlcSA9IG5sODAyMTFfZ2V0X2Fzc29jX2ZyZXEoZHJ2KTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAibmw4MDIxMTogc2VuZF9mcmFtZSAtIFVzZSBhc3NvY19mcmVxPSV1IGZvciBJQlNTIiwKKwkJCSAgIGZyZXEpOworCX0KKwlpZiAoZnJlcSA9PSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogc2VuZF9mcmFtZSAtIFVzZSBic3MtPmZyZXE9JXUiLAorCQkJICAgYnNzLT5mcmVxKTsKIAkJZnJlcSA9IGJzcy0+ZnJlcTsKKwl9CiAKLQlpZiAoZHJ2LT51c2VfbW9uaXRvcikKKwlpZiAoZHJ2LT51c2VfbW9uaXRvcikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IHNlbmRfZnJhbWUoZnJlcT0ldSBic3MtPmZyZXE9JXUpIC0+IHNlbmRfbW50ciIsCisJCQkgICBmcmVxLCBic3MtPmZyZXEpOwogCQlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3NlbmRfbW50cihkcnYsIGRhdGEsIGxlbiwKIAkJCQkJCSAgICBlbmNyeXB0LCBub2Fjayk7CisJfQogCi0JcmV0dXJuIG5sODAyMTFfc2VuZF9mcmFtZV9jbWQoYnNzLCBmcmVxLCB3YWl0X3RpbWUsIGRhdGEsIGxlbiwKLQkJCQkgICAgICAmY29va2llLCBub19jY2ssIG5vYWNrLCBvZmZjaGFub2spOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogc2VuZF9mcmFtZSAtPiBzZW5kX2ZyYW1lX2NtZCIpOworCXJlcyA9IG5sODAyMTFfc2VuZF9mcmFtZV9jbWQoYnNzLCBmcmVxLCB3YWl0X3RpbWUsIGRhdGEsIGxlbiwKKwkJCQkgICAgICZjb29raWUsIG5vX2Njaywgbm9hY2ssIG9mZmNoYW5vayk7CisJaWYgKHJlcyA9PSAwICYmICFub2FjaykgeworCQljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7CisJCXUxNiBmYzsKKworCQltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBkYXRhOworCQlmYyA9IGxlX3RvX2hvc3QxNihtZ210LT5mcmFtZV9jb250cm9sKTsKKwkJaWYgKFdMQU5fRkNfR0VUX1RZUEUoZmMpID09IFdMQU5fRkNfVFlQRV9NR01UICYmCisJCSAgICBXTEFOX0ZDX0dFVF9TVFlQRShmYykgPT0gV0xBTl9GQ19TVFlQRV9BQ1RJT04pIHsKKwkJCXdwYV9wcmludGYoTVNHX01TR0RVTVAsCisJCQkJICAgIm5sODAyMTE6IFVwZGF0ZSBzZW5kX2FjdGlvbl9jb29raWUgZnJvbSAweCVsbHggdG8gMHglbGx4IiwKKwkJCQkgICAobG9uZyBsb25nIHVuc2lnbmVkIGludCkKKwkJCQkgICBkcnYtPnNlbmRfYWN0aW9uX2Nvb2tpZSwKKwkJCQkgICAobG9uZyBsb25nIHVuc2lnbmVkIGludCkgY29va2llKTsKKwkJCWRydi0+c2VuZF9hY3Rpb25fY29va2llID0gY29va2llOworCQl9CisJfQorCisJcmV0dXJuIHJlczsKIH0KIAogCkBAIC02MTQ3LDYgKzcwOTQsMTAgQEAKIAogCW1nbXQgPSAoc3RydWN0IGllZWU4MDIxMV9tZ210ICopIGRhdGE7CiAJZmMgPSBsZV90b19ob3N0MTYobWdtdC0+ZnJhbWVfY29udHJvbCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBzZW5kX21sbWUgLSBkYT0gIiBNQUNTVFIKKwkJICAgIiBub2Fjaz0lZCBmcmVxPSV1IG5vX2Njaz0lZCBvZmZjaGFub2s9JWQgd2FpdF90aW1lPSV1IGZjPTB4JXggKCVzKSBubG1vZGU9JWQiLAorCQkgICBNQUMyU1RSKG1nbXQtPmRhKSwgbm9hY2ssIGZyZXEsIG5vX2Njaywgb2ZmY2hhbm9rLCB3YWl0X3RpbWUsCisJCSAgIGZjLCBmYzJzdHIoZmMpLCBkcnYtPm5sbW9kZSk7CiAKIAlpZiAoKGlzX3N0YV9pbnRlcmZhY2UoZHJ2LT5ubG1vZGUpIHx8CiAJICAgICBkcnYtPm5sbW9kZSA9PSBOTDgwMjExX0lGVFlQRV9QMlBfREVWSUNFKSAmJgpAQCAtNjE1NywxNiArNzEwOCwyMiBAQAogCQkgKiBidXQgaXQgd29ya3MgZHVlIHRvIHRoZSBzaW5nbGUtdGhyZWFkZWQgbmF0dXJlCiAJCSAqIG9mIHdwYV9zdXBwbGljYW50LgogCQkgKi8KLQkJaWYgKGZyZXEgPT0gMCkKKwkJaWYgKGZyZXEgPT0gMCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBVc2UgbGFzdF9tZ210X2ZyZXE9JWQiLAorCQkJCSAgIGRydi0+bGFzdF9tZ210X2ZyZXEpOwogCQkJZnJlcSA9IGRydi0+bGFzdF9tZ210X2ZyZXE7CisJCX0KIAkJcmV0dXJuIG5sODAyMTFfc2VuZF9mcmFtZV9jbWQoYnNzLCBmcmVxLCAwLAogCQkJCQkgICAgICBkYXRhLCBkYXRhX2xlbiwgTlVMTCwgMSwgbm9hY2ssCiAJCQkJCSAgICAgIDEpOwogCX0KIAogCWlmIChkcnYtPmRldmljZV9hcF9zbWUgJiYgaXNfYXBfaW50ZXJmYWNlKGRydi0+bmxtb2RlKSkgewotCQlpZiAoZnJlcSA9PSAwKQorCQlpZiAoZnJlcSA9PSAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFVzZSBic3MtPmZyZXE9JWQiLAorCQkJCSAgIGJzcy0+ZnJlcSk7CiAJCQlmcmVxID0gYnNzLT5mcmVxOworCQl9CiAJCXJldHVybiBubDgwMjExX3NlbmRfZnJhbWVfY21kKGJzcywgZnJlcSwKIAkJCQkJICAgICAgKGludCkgZnJlcSA9PSBic3MtPmZyZXEgPyAwIDoKIAkJCQkJICAgICAgd2FpdF90aW1lLApAQCAtNjE4OSw2ICs3MTQ2LDcgQEAKIAkJCWVuY3J5cHQgPSAwOwogCX0KIAorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogc2VuZF9tbG1lIC0+IHNlbmRfZnJhbWUiKTsKIAlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3NlbmRfZnJhbWUoYnNzLCBkYXRhLCBkYXRhX2xlbiwgZW5jcnlwdCwKIAkJCQkJICAgICBub2FjaywgZnJlcSwgbm9fY2NrLCBvZmZjaGFub2ssCiAJCQkJCSAgICAgd2FpdF90aW1lKTsKQEAgLTYzMDUsNyArNzI2Myw3IEBACiAJaW50IGJlYWNvbl9zZXQ7CiAJaW50IGlmaW5kZXggPSBpZl9uYW1ldG9pbmRleChic3MtPmlmbmFtZSk7CiAJaW50IG51bV9zdWl0ZXM7Ci0JdTMyIHN1aXRlc1sxMF07CisJdTMyIHN1aXRlc1sxMF0sIHN1aXRlOwogCXUzMiB2ZXI7CiAKIAliZWFjb25fc2V0ID0gYnNzLT5iZWFjb25fc2V0OwpAQCAtNjQwMCwxNyArNzM1OCw4IEBACiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IHBhaXJ3aXNlX2NpcGhlcnM9MHgleCIsCiAJCSAgIHBhcmFtcy0+cGFpcndpc2VfY2lwaGVycyk7Ci0JbnVtX3N1aXRlcyA9IDA7Ci0JaWYgKHBhcmFtcy0+cGFpcndpc2VfY2lwaGVycyAmIFdQQV9DSVBIRVJfQ0NNUCkKLQkJc3VpdGVzW251bV9zdWl0ZXMrK10gPSBXTEFOX0NJUEhFUl9TVUlURV9DQ01QOwotCWlmIChwYXJhbXMtPnBhaXJ3aXNlX2NpcGhlcnMgJiBXUEFfQ0lQSEVSX0dDTVApCi0JCXN1aXRlc1tudW1fc3VpdGVzKytdID0gV0xBTl9DSVBIRVJfU1VJVEVfR0NNUDsKLQlpZiAocGFyYW1zLT5wYWlyd2lzZV9jaXBoZXJzICYgV1BBX0NJUEhFUl9US0lQKQotCQlzdWl0ZXNbbnVtX3N1aXRlcysrXSA9IFdMQU5fQ0lQSEVSX1NVSVRFX1RLSVA7Ci0JaWYgKHBhcmFtcy0+cGFpcndpc2VfY2lwaGVycyAmIFdQQV9DSVBIRVJfV0VQMTA0KQotCQlzdWl0ZXNbbnVtX3N1aXRlcysrXSA9IFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDEwNDsKLQlpZiAocGFyYW1zLT5wYWlyd2lzZV9jaXBoZXJzICYgV1BBX0NJUEhFUl9XRVA0MCkKLQkJc3VpdGVzW251bV9zdWl0ZXMrK10gPSBXTEFOX0NJUEhFUl9TVUlURV9XRVA0MDsKKwludW1fc3VpdGVzID0gd3BhX2NpcGhlcl90b19jaXBoZXJfc3VpdGVzKHBhcmFtcy0+cGFpcndpc2VfY2lwaGVycywKKwkJCQkJCSBzdWl0ZXMsIEFSUkFZX1NJWkUoc3VpdGVzKSk7CiAJaWYgKG51bV9zdWl0ZXMpIHsKIAkJTkxBX1BVVChtc2csIE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVTX1BBSVJXSVNFLAogCQkJbnVtX3N1aXRlcyAqIHNpemVvZih1MzIpLCBzdWl0ZXMpOwpAQCAtNjQxOCwyOCArNzM2Nyw5IEBACiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IGdyb3VwX2NpcGhlcj0weCV4IiwKIAkJICAgcGFyYW1zLT5ncm91cF9jaXBoZXIpOwotCXN3aXRjaCAocGFyYW1zLT5ncm91cF9jaXBoZXIpIHsKLQljYXNlIFdQQV9DSVBIRVJfQ0NNUDoKLQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0lQSEVSX1NVSVRFX0dST1VQLAotCQkJICAgIFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVApOwotCQlicmVhazsKLQljYXNlIFdQQV9DSVBIRVJfR0NNUDoKLQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0lQSEVSX1NVSVRFX0dST1VQLAotCQkJICAgIFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVApOwotCQlicmVhazsKLQljYXNlIFdQQV9DSVBIRVJfVEtJUDoKLQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0lQSEVSX1NVSVRFX0dST1VQLAotCQkJICAgIFdMQU5fQ0lQSEVSX1NVSVRFX1RLSVApOwotCQlicmVhazsKLQljYXNlIFdQQV9DSVBIRVJfV0VQMTA0OgotCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVfR1JPVVAsCi0JCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfV0VQMTA0KTsKLQkJYnJlYWs7Ci0JY2FzZSBXUEFfQ0lQSEVSX1dFUDQwOgotCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVfR1JPVVAsCi0JCQkgICAgV0xBTl9DSVBIRVJfU1VJVEVfV0VQNDApOwotCQlicmVhazsKLQl9CisJc3VpdGUgPSB3cGFfY2lwaGVyX3RvX2NpcGhlcl9zdWl0ZShwYXJhbXMtPmdyb3VwX2NpcGhlcik7CisJaWYgKHN1aXRlKQorCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVfR1JPVVAsIHN1aXRlKTsKIAogCWlmIChwYXJhbXMtPmJlYWNvbl9pZXMpIHsKIAkJd3BhX2hleGR1bXBfYnVmKE1TR19ERUJVRywgIm5sODAyMTE6IGJlYWNvbl9pZXMiLApAQCAtNjQ3OCw2ICs3NDA4LDMwIEBACiAJCW5sODAyMTFfc2V0X2Jzcyhic3MsIHBhcmFtcy0+Y3RzX3Byb3RlY3QsIHBhcmFtcy0+cHJlYW1ibGUsCiAJCQkJcGFyYW1zLT5zaG9ydF9zbG90X3RpbWUsIHBhcmFtcy0+aHRfb3Btb2RlLAogCQkJCXBhcmFtcy0+aXNvbGF0ZSwgcGFyYW1zLT5iYXNpY19yYXRlcyk7CisJCWlmIChiZWFjb25fc2V0ICYmIHBhcmFtcy0+ZnJlcSAmJgorCQkgICAgcGFyYW1zLT5mcmVxLT5iYW5kd2lkdGggIT0gYnNzLT5iYW5kd2lkdGgpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJubDgwMjExOiBVcGRhdGUgQlNTICVzIGJhbmR3aWR0aDogJWQgLT4gJWQiLAorCQkJCSAgIGJzcy0+aWZuYW1lLCBic3MtPmJhbmR3aWR0aCwKKwkJCQkgICBwYXJhbXMtPmZyZXEtPmJhbmR3aWR0aCk7CisJCQlyZXQgPSBubDgwMjExX3NldF9jaGFubmVsKGJzcywgcGFyYW1zLT5mcmVxLCAxKTsKKwkJCWlmIChyZXQpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCQkJICAgIm5sODAyMTE6IEZyZXF1ZW5jeSBzZXQgZmFpbGVkOiAlZCAoJXMpIiwKKwkJCQkJICAgcmV0LCBzdHJlcnJvcigtcmV0KSk7CisJCQl9IGVsc2UgeworCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCQkgICAibmw4MDIxMTogRnJlcXVlbmN5IHNldCBzdWNjZWVkZWQgZm9yIGh0MjA0MCBjb2V4Iik7CisJCQkJYnNzLT5iYW5kd2lkdGggPSBwYXJhbXMtPmZyZXEtPmJhbmR3aWR0aDsKKwkJCX0KKwkJfSBlbHNlIGlmICghYmVhY29uX3NldCkgeworCQkJLyoKKwkJCSAqIGNmZzgwMjExIHVwZGF0ZXMgdGhlIGRyaXZlciBvbiBmcmVxdWVuY2UgY2hhbmdlIGluIEFQCisJCQkgKiBtb2RlIG9ubHkgYXQgdGhlIHBvaW50IHdoZW4gYmVhY29uaW5nIGlzIHN0YXJ0ZWQsIHNvCisJCQkgKiBzZXQgdGhlIGluaXRpYWwgdmFsdWUgaGVyZS4KKwkJCSAqLworCQkJYnNzLT5iYW5kd2lkdGggPSBwYXJhbXMtPmZyZXEtPmJhbmR3aWR0aDsKKwkJfQogCX0KIAlyZXR1cm4gcmV0OwogIG5sYV9wdXRfZmFpbHVyZToKQEAgLTY0ODYsMjQgKzc0NDAsOSBAQAogfQogCiAKLXN0YXRpYyBpbnQgd3BhX2RyaXZlcl9ubDgwMjExX3NldF9mcmVxKHN0cnVjdCBpODAyX2JzcyAqYnNzLAotCQkJCSAgICAgICBzdHJ1Y3QgaG9zdGFwZF9mcmVxX3BhcmFtcyAqZnJlcSkKK3N0YXRpYyBpbnQgbmw4MDIxMV9wdXRfZnJlcV9wYXJhbXMoc3RydWN0IG5sX21zZyAqbXNnLAorCQkJCSAgIHN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zICpmcmVxKQogewotCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7Ci0Jc3RydWN0IG5sX21zZyAqbXNnOwotCWludCByZXQ7Ci0KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNldCBmcmVxICVkIChodF9lbmFibGVkPSVkLCB2aHRfZW5hYmxlZD0lZCwiCi0JCSAgICIgYmFuZHdpZHRoPSVkIE1IeiwgY2YxPSVkIE1IeiwgY2YyPSVkIE1IeikiLAotCQkgICBmcmVxLT5mcmVxLCBmcmVxLT5odF9lbmFibGVkLCBmcmVxLT52aHRfZW5hYmxlZCwKLQkJICAgZnJlcS0+YmFuZHdpZHRoLCBmcmVxLT5jZW50ZXJfZnJlcTEsIGZyZXEtPmNlbnRlcl9mcmVxMik7Ci0JbXNnID0gbmxtc2dfYWxsb2MoKTsKLQlpZiAoIW1zZykKLQkJcmV0dXJuIC0xOwotCi0Jbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX1NFVF9XSVBIWSk7Ci0KLQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9JRklOREVYLCBkcnYtPmlmaW5kZXgpOwogCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1dJUEhZX0ZSRVEsIGZyZXEtPmZyZXEpOwogCWlmIChmcmVxLT52aHRfZW5hYmxlZCkgewogCQlzd2l0Y2ggKGZyZXEtPmJhbmR3aWR0aCkgewpAQCAtNjUyOCw3ICs3NDY3LDcgQEAKIAkJCQkgICAgTkw4MDIxMV9DSEFOX1dJRFRIXzE2MCk7CiAJCQlicmVhazsKIAkJZGVmYXVsdDoKLQkJCXJldHVybiAtMTsKKwkJCXJldHVybiAtRUlOVkFMOwogCQl9CiAJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0NFTlRFUl9GUkVRMSwgZnJlcS0+Y2VudGVyX2ZyZXExKTsKIAkJaWYgKGZyZXEtPmNlbnRlcl9mcmVxMikKQEAgLTY1NTAsNiArNzQ4OSwzNCBAQAogCQkJYnJlYWs7CiAJCX0KIAl9CisJcmV0dXJuIDA7CisKK25sYV9wdXRfZmFpbHVyZToKKwlyZXR1cm4gLUVOT0JVRlM7Cit9CisKKworc3RhdGljIGludCBubDgwMjExX3NldF9jaGFubmVsKHN0cnVjdCBpODAyX2JzcyAqYnNzLAorCQkJICAgICAgIHN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zICpmcmVxLCBpbnQgc2V0X2NoYW4pCit7CisJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKKwlzdHJ1Y3QgbmxfbXNnICptc2c7CisJaW50IHJldDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkgICAibmw4MDIxMTogU2V0IGZyZXEgJWQgKGh0X2VuYWJsZWQ9JWQsIHZodF9lbmFibGVkPSVkLCBiYW5kd2lkdGg9JWQgTUh6LCBjZjE9JWQgTUh6LCBjZjI9JWQgTUh6KSIsCisJCSAgIGZyZXEtPmZyZXEsIGZyZXEtPmh0X2VuYWJsZWQsIGZyZXEtPnZodF9lbmFibGVkLAorCQkgICBmcmVxLT5iYW5kd2lkdGgsIGZyZXEtPmNlbnRlcl9mcmVxMSwgZnJlcS0+Y2VudGVyX2ZyZXEyKTsKKwltc2cgPSBubG1zZ19hbGxvYygpOworCWlmICghbXNnKQorCQlyZXR1cm4gLTE7CisKKwlubDgwMjExX2NtZChkcnYsIG1zZywgMCwgc2V0X2NoYW4gPyBOTDgwMjExX0NNRF9TRVRfQ0hBTk5FTCA6CisJCSAgICBOTDgwMjExX0NNRF9TRVRfV0lQSFkpOworCisJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfSUZJTkRFWCwgZHJ2LT5pZmluZGV4KTsKKwlpZiAobmw4MDIxMV9wdXRfZnJlcV9wYXJhbXMobXNnLCBmcmVxKSA8IDApCisJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOwogCiAJcmV0ID0gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBOVUxMLCBOVUxMKTsKIAltc2cgPSBOVUxMOwpAQCAtNjY1MSw2ICs3NjE4LDEyIEBACiAJCQlwYXJhbXMtPnZodF9jYXBhYmlsaXRpZXMpOwogCX0KIAorCWlmIChwYXJhbXMtPnZodF9vcG1vZGVfZW5hYmxlZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBvcG1vZGU9JXUiLCBwYXJhbXMtPnZodF9vcG1vZGUpOworCQlOTEFfUFVUX1U4KG1zZywgTkw4MDIxMV9BVFRSX09QTU9ERV9OT1RJRiwKKwkJCSAgIHBhcmFtcy0+dmh0X29wbW9kZSk7CisJfQorCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogY2FwYWJpbGl0eT0weCV4IiwgcGFyYW1zLT5jYXBhYmlsaXR5KTsKIAlOTEFfUFVUX1UxNihtc2csIE5MODAyMTFfQVRUUl9TVEFfQ0FQQUJJTElUWSwgcGFyYW1zLT5jYXBhYmlsaXR5KTsKIApAQCAtNjY2MSw2ICs3NjM0LDIyIEBACiAJCQlwYXJhbXMtPmV4dF9jYXBhYl9sZW4sIHBhcmFtcy0+ZXh0X2NhcGFiKTsKIAl9CiAKKwlpZiAocGFyYW1zLT5zdXBwX2NoYW5uZWxzKSB7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIiAgKiBzdXBwb3J0ZWQgY2hhbm5lbHMiLAorCQkJICAgIHBhcmFtcy0+c3VwcF9jaGFubmVscywgcGFyYW1zLT5zdXBwX2NoYW5uZWxzX2xlbik7CisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfU1RBX1NVUFBPUlRFRF9DSEFOTkVMUywKKwkJCXBhcmFtcy0+c3VwcF9jaGFubmVsc19sZW4sIHBhcmFtcy0+c3VwcF9jaGFubmVscyk7CisJfQorCisJaWYgKHBhcmFtcy0+c3VwcF9vcGVyX2NsYXNzZXMpIHsKKwkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiICAqIHN1cHBvcnRlZCBvcGVyYXRpbmcgY2xhc3NlcyIsCisJCQkgICAgcGFyYW1zLT5zdXBwX29wZXJfY2xhc3NlcywKKwkJCSAgICBwYXJhbXMtPnN1cHBfb3Blcl9jbGFzc2VzX2xlbik7CisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfU1RBX1NVUFBPUlRFRF9PUEVSX0NMQVNTRVMsCisJCQlwYXJhbXMtPnN1cHBfb3Blcl9jbGFzc2VzX2xlbiwKKwkJCXBhcmFtcy0+c3VwcF9vcGVyX2NsYXNzZXMpOworCX0KKwogCW9zX21lbXNldCgmdXBkLCAwLCBzaXplb2YodXBkKSk7CiAJdXBkLm1hc2sgPSBzdGFfZmxhZ3Nfbmw4MDIxMShwYXJhbXMtPmZsYWdzKTsKIAl1cGQuc2V0ID0gdXBkLm1hc2s7CkBAIC02NzMwLDExICs3NzE5LDE0IEBACiAJCQkJIGludCBpZmlkeCkKIHsKIAlzdHJ1Y3QgbmxfbXNnICptc2c7CisJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYyOwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBSZW1vdmUgaW50ZXJmYWNlIGlmaW5kZXg9JWQiLCBpZmlkeCk7CiAKIAkvKiBzdG9wIGxpc3RlbmluZyBmb3IgRUFQT0wgb24gdGhpcyBpbnRlcmZhY2UgKi8KLQlkZWxfaWZpZHgoZHJ2LCBpZmlkeCk7CisJZGxfbGlzdF9mb3JfZWFjaChkcnYyLCAmZHJ2LT5nbG9iYWwtPmludGVyZmFjZXMsCisJCQkgc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhLCBsaXN0KQorCQlkZWxfaWZpZHgoZHJ2MiwgaWZpZHgpOwogCiAJbXNnID0gbmxtc2dfYWxsb2MoKTsKIAlpZiAoIW1zZykKQEAgLTY4MDAsNyArNzc5Miw3IEBACiAJCXJldHVybiAtMTsKIAogCW5sODAyMTFfY21kKGRydiwgbXNnLCAwLCBOTDgwMjExX0NNRF9ORVdfSU5URVJGQUNFKTsKLQlpZiAobmw4MDIxMV9zZXRfaWZhY2VfaWQobXNnLCAmZHJ2LT5maXJzdF9ic3MpIDwgMCkKKwlpZiAobmw4MDIxMV9zZXRfaWZhY2VfaWQobXNnLCBkcnYtPmZpcnN0X2JzcykgPCAwKQogCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsKIAlOTEFfUFVUX1NUUklORyhtc2csIE5MODAyMTFfQVRUUl9JRk5BTUUsIGlmbmFtZSk7CiAJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfSUZUWVBFLCBpZnR5cGUpOwpAQCAtNjgxOSw2ICs3ODExLDEyIEBACiAJCU5MQV9QVVRfVTgobXNnLCBOTDgwMjExX0FUVFJfNEFERFIsIHdkcyk7CiAJfQogCisJLyoKKwkgKiBUZWxsIGNmZzgwMjExIHRoYXQgdGhlIGludGVyZmFjZSBiZWxvbmdzIHRvIHRoZSBzb2NrZXQgdGhhdCBjcmVhdGVkCisJICogaXQsIGFuZCB0aGUgaW50ZXJmYWNlIHNob3VsZCBiZSBkZWxldGVkIHdoZW4gdGhlIHNvY2tldCBpcyBjbG9zZWQuCisJICovCisJTkxBX1BVVF9GTEFHKG1zZywgTkw4MDIxMV9BVFRSX0lGQUNFX1NPQ0tFVF9PV05FUik7CisKIAlyZXQgPSBzZW5kX2FuZF9yZWN2X21zZ3MoZHJ2LCBtc2csIGhhbmRsZXIsIGFyZyk7CiAJbXNnID0gTlVMTDsKIAlpZiAocmV0KSB7CkBAIC02ODM5LDggKzc4MzcsMTcgQEAKIAlpZiAoaWZpZHggPD0gMCkKIAkJcmV0dXJuIC0xOwogCi0JLyogc3RhcnQgbGlzdGVuaW5nIGZvciBFQVBPTCBvbiB0aGlzIGludGVyZmFjZSAqLwotCWFkZF9pZmlkeChkcnYsIGlmaWR4KTsKKwkvKgorCSAqIFNvbWUgdmlydHVhbCBpbnRlcmZhY2VzIG5lZWQgdG8gcHJvY2VzcyBFQVBPTCBwYWNrZXRzIGFuZCBldmVudHMgb24KKwkgKiB0aGUgcGFyZW50IGludGVyZmFjZS4gVGhpcyBpcyB1c2VkIG1haW5seSB3aXRoIGhvc3RhcGQuCisJICovCisJaWYgKGRydi0+aG9zdGFwZCB8fAorCSAgICBpZnR5cGUgPT0gTkw4MDIxMV9JRlRZUEVfQVBfVkxBTiB8fAorCSAgICBpZnR5cGUgPT0gTkw4MDIxMV9JRlRZUEVfV0RTIHx8CisJICAgIGlmdHlwZSA9PSBOTDgwMjExX0lGVFlQRV9NT05JVE9SKSB7CisJCS8qIHN0YXJ0IGxpc3RlbmluZyBmb3IgRUFQT0wgb24gdGhpcyBpbnRlcmZhY2UgKi8KKwkJYWRkX2lmaWR4KGRydiwgaWZpZHgpOworCX0KIAogCWlmIChhZGRyICYmIGlmdHlwZSAhPSBOTDgwMjExX0lGVFlQRV9NT05JVE9SICYmCiAJICAgIGxpbnV4X3NldF9pZmh3YWRkcihkcnYtPmdsb2JhbC0+aW9jdGxfc29jaywgaWZuYW1lLCBhZGRyKSkgewpAQCAtNjg1Niw3ICs3ODYzLDcgQEAKIAkJCQljb25zdCBjaGFyICppZm5hbWUsIGVudW0gbmw4MDIxMV9pZnR5cGUgaWZ0eXBlLAogCQkJCWNvbnN0IHU4ICphZGRyLCBpbnQgd2RzLAogCQkJCWludCAoKmhhbmRsZXIpKHN0cnVjdCBubF9tc2cgKiwgdm9pZCAqKSwKLQkJCQl2b2lkICphcmcpCisJCQkJdm9pZCAqYXJnLCBpbnQgdXNlX2V4aXN0aW5nKQogewogCWludCByZXQ7CiAKQEAgLTY4NjUsNiArNzg3MiwyMSBAQAogCiAJLyogaWYgZXJyb3Igb2NjdXJyZWQgYW5kIGludGVyZmFjZSBleGlzdHMgYWxyZWFkeSAqLwogCWlmIChyZXQgPT0gLUVORklMRSAmJiBpZl9uYW1ldG9pbmRleChpZm5hbWUpKSB7CisJCWlmICh1c2VfZXhpc3RpbmcpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogQ29udGludWUgdXNpbmcgZXhpc3RpbmcgaW50ZXJmYWNlICVzIiwKKwkJCQkgICBpZm5hbWUpOworCQkJaWYgKGFkZHIgJiYgaWZ0eXBlICE9IE5MODAyMTFfSUZUWVBFX01PTklUT1IgJiYKKwkJCSAgICBsaW51eF9zZXRfaWZod2FkZHIoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssIGlmbmFtZSwKKwkJCQkJICAgICAgIGFkZHIpIDwgMCAmJgorCQkJICAgIChsaW51eF9zZXRfaWZhY2VfZmxhZ3MoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssCisJCQkJCQkgICBpZm5hbWUsIDApIDwgMCB8fAorCQkJICAgICBsaW51eF9zZXRfaWZod2FkZHIoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssIGlmbmFtZSwKKwkJCQkJCWFkZHIpIDwgMCB8fAorCQkJICAgICBsaW51eF9zZXRfaWZhY2VfZmxhZ3MoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssCisJCQkJCQkgICBpZm5hbWUsIDEpIDwgMCkpCisJCQkJCXJldHVybiAtMTsKKwkJCXJldHVybiAtRU5GSUxFOworCQl9CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJUcnkgdG8gcmVtb3ZlIGFuZCByZS1jcmVhdGUgJXMiLCBpZm5hbWUpOwogCiAJCS8qIFRyeSB0byByZW1vdmUgdGhlIGludGVyZmFjZSB0aGF0IHdhcyBhbHJlYWR5IHRoZXJlLiAqLwpAQCAtNjk2NiwxMiArNzk4OCwxMyBAQAogCiAJbGVuID0gcmVjdihzb2NrLCBidWYsIHNpemVvZihidWYpLCAwKTsKIAlpZiAobGVuIDwgMCkgewotCQlwZXJyb3IoInJlY3YiKTsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJubDgwMjExOiBNb25pdG9yIHNvY2tldCByZWN2IGZhaWxlZDogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJcmV0dXJuOwogCX0KIAotCWlmIChpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3JfaW5pdCgmaXRlciwgKHZvaWQqKWJ1ZiwgbGVuKSkgewotCQlwcmludGYoInJlY2VpdmVkIGludmFsaWQgcmFkaW90YXAgZnJhbWVcbiIpOworCWlmIChpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3JfaW5pdCgmaXRlciwgKHZvaWQgKikgYnVmLCBsZW4sIE5VTEwpKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJubDgwMjExOiByZWNlaXZlZCBpbnZhbGlkIHJhZGlvdGFwIGZyYW1lIik7CiAJCXJldHVybjsKIAl9CiAKQEAgLTY5ODAsNyArODAwMyw4IEBACiAJCWlmIChyZXQgPT0gLUVOT0VOVCkKIAkJCWJyZWFrOwogCQlpZiAocmV0KSB7Ci0JCQlwcmludGYoInJlY2VpdmVkIGludmFsaWQgcmFkaW90YXAgZnJhbWUgKCVkKVxuIiwgcmV0KTsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJubDgwMjExOiByZWNlaXZlZCBpbnZhbGlkIHJhZGlvdGFwIGZyYW1lICglZCkiLAorCQkJCSAgIHJldCk7CiAJCQlyZXR1cm47CiAJCX0KIAkJc3dpdGNoIChpdGVyLnRoaXNfYXJnX2luZGV4KSB7CkBAIC03MDE0LDExICs4MDM4LDExIEBACiAJCXJldHVybjsKIAogCWlmICghaW5qZWN0ZWQpCi0JCWhhbmRsZV9mcmFtZShkcnYsIGJ1ZiArIGl0ZXIubWF4X2xlbmd0aCwKLQkJCSAgICAgbGVuIC0gaXRlci5tYXhfbGVuZ3RoLCBkYXRhcmF0ZSwgc3NpX3NpZ25hbCk7CisJCWhhbmRsZV9mcmFtZShkcnYsIGJ1ZiArIGl0ZXIuX21heF9sZW5ndGgsCisJCQkgICAgIGxlbiAtIGl0ZXIuX21heF9sZW5ndGgsIGRhdGFyYXRlLCBzc2lfc2lnbmFsKTsKIAllbHNlCi0JCWhhbmRsZV90eF9jYWxsYmFjayhkcnYtPmN0eCwgYnVmICsgaXRlci5tYXhfbGVuZ3RoLAotCQkJCSAgIGxlbiAtIGl0ZXIubWF4X2xlbmd0aCwgIWZhaWxlZCk7CisJCWhhbmRsZV90eF9jYWxsYmFjayhkcnYtPmN0eCwgYnVmICsgaXRlci5fbWF4X2xlbmd0aCwKKwkJCQkgICBsZW4gLSBpdGVyLl9tYXhfbGVuZ3RoLCAhZmFpbGVkKTsKIH0KIAogCkBAIC03MTMwLDcgKzgxNTQsNyBAQAogfTsKIAogc3RhdGljIHN0cnVjdCBzb2NrX2Zwcm9nIG1zb2NrX2ZpbHRlciA9IHsKLQkubGVuID0gc2l6ZW9mKG1zb2NrX2ZpbHRlcl9pbnNucykvc2l6ZW9mKG1zb2NrX2ZpbHRlcl9pbnNuc1swXSksCisJLmxlbiA9IEFSUkFZX1NJWkUobXNvY2tfZmlsdGVyX2luc25zKSwKIAkuZmlsdGVyID0gbXNvY2tfZmlsdGVyX2luc25zLAogfTsKIApAQCAtNzE2NSw3ICs4MTg5LDggQEAKIAogCWlmIChzZXRzb2Nrb3B0KHMsIFNPTF9TT0NLRVQsIFNPX0FUVEFDSF9GSUxURVIsCiAJCSAgICAgICAmbXNvY2tfZmlsdGVyLCBzaXplb2YobXNvY2tfZmlsdGVyKSkpIHsKLQkJcGVycm9yKCJTT19BVFRBQ0hfRklMVEVSIik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogc2V0c29ja29wdChTT19BVFRBQ0hfRklMVEVSKSBmYWlsZWQ6ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJCXJldHVybiAtMTsKIAl9CiAKQEAgLTcxNzYsNyArODIwMSwxMCBAQAogc3RhdGljIHZvaWQgbmw4MDIxMV9yZW1vdmVfbW9uaXRvcl9pbnRlcmZhY2UoCiAJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYpCiB7Ci0JZHJ2LT5tb25pdG9yX3JlZmNvdW50LS07CisJaWYgKGRydi0+bW9uaXRvcl9yZWZjb3VudCA+IDApCisJCWRydi0+bW9uaXRvcl9yZWZjb3VudC0tOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogUmVtb3ZlIG1vbml0b3IgaW50ZXJmYWNlOiByZWZjb3VudD0lZCIsCisJCSAgIGRydi0+bW9uaXRvcl9yZWZjb3VudCk7CiAJaWYgKGRydi0+bW9uaXRvcl9yZWZjb3VudCA+IDApCiAJCXJldHVybjsKIApAQCAtNzIwMiwyNyArODIzMCwyOSBAQAogCiAJaWYgKGRydi0+bW9uaXRvcl9pZmlkeCA+PSAwKSB7CiAJCWRydi0+bW9uaXRvcl9yZWZjb3VudCsrOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFJlLXVzZSBleGlzdGluZyBtb25pdG9yIGludGVyZmFjZTogcmVmY291bnQ9JWQiLAorCQkJICAgZHJ2LT5tb25pdG9yX3JlZmNvdW50KTsKIAkJcmV0dXJuIDA7CiAJfQogCi0JaWYgKG9zX3N0cm5jbXAoZHJ2LT5maXJzdF9ic3MuaWZuYW1lLCAicDJwLSIsIDQpID09IDApIHsKKwlpZiAob3Nfc3RybmNtcChkcnYtPmZpcnN0X2Jzcy0+aWZuYW1lLCAicDJwLSIsIDQpID09IDApIHsKIAkJLyoKIAkJICogUDJQIGludGVyZmFjZSBuYW1lIGlzIG9mIHRoZSBmb3JtYXQgcDJwLSVzLSVkLiBGb3IgbW9uaXRvcgogCQkgKiBpbnRlcmZhY2UgbmFtZSBjb3JyZXNwb25kaW5nIHRvIFAyUCBHTywgcmVwbGFjZSAicDJwLSIgd2l0aAogCQkgKiAibW9uLSIgdG8gcmV0YWluIHRoZSBzYW1lIGludGVyZmFjZSBuYW1lIGxlbmd0aCBhbmQgdG8KIAkJICogaW5kaWNhdGUgdGhhdCBpdCBpcyBhIG1vbml0b3IgaW50ZXJmYWNlLgogCQkgKi8KLQkJc25wcmludGYoYnVmLCBJRk5BTVNJWiwgIm1vbi0lcyIsIGRydi0+Zmlyc3RfYnNzLmlmbmFtZSArIDQpOworCQlzbnByaW50ZihidWYsIElGTkFNU0laLCAibW9uLSVzIiwgZHJ2LT5maXJzdF9ic3MtPmlmbmFtZSArIDQpOwogCX0gZWxzZSB7CiAJCS8qIE5vbi1QMlAgaW50ZXJmYWNlIHdpdGggQVAgZnVuY3Rpb25hbGl0eS4gKi8KLQkJc25wcmludGYoYnVmLCBJRk5BTVNJWiwgIm1vbi4lcyIsIGRydi0+Zmlyc3RfYnNzLmlmbmFtZSk7CisJCXNucHJpbnRmKGJ1ZiwgSUZOQU1TSVosICJtb24uJXMiLCBkcnYtPmZpcnN0X2Jzcy0+aWZuYW1lKTsKIAl9CiAKIAlidWZbSUZOQU1TSVogLSAxXSA9ICdcMCc7CiAKIAlkcnYtPm1vbml0b3JfaWZpZHggPQogCQlubDgwMjExX2NyZWF0ZV9pZmFjZShkcnYsIGJ1ZiwgTkw4MDIxMV9JRlRZUEVfTU9OSVRPUiwgTlVMTCwKLQkJCQkgICAgIDAsIE5VTEwsIE5VTEwpOworCQkJCSAgICAgMCwgTlVMTCwgTlVMTCwgMCk7CiAKIAlpZiAoZHJ2LT5tb25pdG9yX2lmaWR4ID09IC1FT1BOT1RTVVBQKSB7CiAJCS8qCkBAIC03MjQ3LDcgKzgyNzcsOCBAQAogCWxsLnNsbF9pZmluZGV4ID0gZHJ2LT5tb25pdG9yX2lmaWR4OwogCWRydi0+bW9uaXRvcl9zb2NrID0gc29ja2V0KFBGX1BBQ0tFVCwgU09DS19SQVcsIGh0b25zKEVUSF9QX0FMTCkpOwogCWlmIChkcnYtPm1vbml0b3Jfc29jayA8IDApIHsKLQkJcGVycm9yKCJzb2NrZXRbUEZfUEFDS0VULFNPQ0tfUkFXXSIpOworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIm5sODAyMTE6IHNvY2tldFtQRl9QQUNLRVQsU09DS19SQVddIGZhaWxlZDogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJZ290byBlcnJvcjsKIAl9CiAKQEAgLTcyNTgsNyArODI4OSw4IEBACiAJfQogCiAJaWYgKGJpbmQoZHJ2LT5tb25pdG9yX3NvY2ssIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmxsLCBzaXplb2YobGwpKSA8IDApIHsKLQkJcGVycm9yKCJtb25pdG9yIHNvY2tldCBiaW5kIik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogbW9uaXRvciBzb2NrZXQgYmluZCBmYWlsZWQ6ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJCWdvdG8gZXJyb3I7CiAJfQogCkBAIC03MjY2LDE2ICs4Mjk4LDE4IEBACiAJb3B0dmFsID0gMjA7CiAJaWYgKHNldHNvY2tvcHQKIAkgICAgKGRydi0+bW9uaXRvcl9zb2NrLCBTT0xfU09DS0VULCBTT19QUklPUklUWSwgJm9wdHZhbCwgb3B0bGVuKSkgewotCQlwZXJyb3IoIkZhaWxlZCB0byBzZXQgc29ja2V0IHByaW9yaXR5Iik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogRmFpbGVkIHRvIHNldCBzb2NrZXQgcHJpb3JpdHk6ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJCWdvdG8gZXJyb3I7CiAJfQogCiAJaWYgKGVsb29wX3JlZ2lzdGVyX3JlYWRfc29jayhkcnYtPm1vbml0b3Jfc29jaywgaGFuZGxlX21vbml0b3JfcmVhZCwKIAkJCQkgICAgIGRydiwgTlVMTCkpIHsKLQkJcHJpbnRmKCJDb3VsZCBub3QgcmVnaXN0ZXIgbW9uaXRvciByZWFkIHNvY2tldFxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJubDgwMjExOiBDb3VsZCBub3QgcmVnaXN0ZXIgbW9uaXRvciByZWFkIHNvY2tldCIpOwogCQlnb3RvIGVycm9yOwogCX0KIAorCWRydi0+bW9uaXRvcl9yZWZjb3VudCsrOwogCXJldHVybiAwOwogIGVycm9yOgogCW5sODAyMTFfcmVtb3ZlX21vbml0b3JfaW50ZXJmYWNlKGRydik7CkBAIC03Mjg3LDggKzgzMjEsOCBAQAogewogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNldHVwIEFQIC0gZGV2aWNlX2FwX3NtZT0lZCAiCi0JCSAgICJ1c2VfbW9uaXRvcj0lZCIsIGRydi0+ZGV2aWNlX2FwX3NtZSwgZHJ2LT51c2VfbW9uaXRvcik7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBTZXR1cCBBUCglcykgLSBkZXZpY2VfYXBfc21lPSVkIHVzZV9tb25pdG9yPSVkIiwKKwkJICAgYnNzLT5pZm5hbWUsIGRydi0+ZGV2aWNlX2FwX3NtZSwgZHJ2LT51c2VfbW9uaXRvcik7CiAKIAkvKgogCSAqIERpc2FibGUgUHJvYmUgUmVxdWVzdCByZXBvcnRpbmcgdW5sZXNzIHdlIG5lZWQgaXQgaW4gdGhpcyB3YXkgZm9yCkBAIC03MzExLDE2ICs4MzQ1LDYgQEAKIAkgICAgIWRydi0+ZGV2aWNlX2FwX3NtZSkKIAkJcmV0dXJuIC0xOwogCi0jaWZkZWYgQU5EUk9JRF9QMlAKLQlpZiAoZHJ2LT5kZXZpY2VfYXBfc21lICYmIGRydi0+dXNlX21vbml0b3IpCi0JCWlmIChubDgwMjExX21nbXRfc3Vic2NyaWJlX2FwX2Rldl9zbWUoYnNzKSkKLQkJCXJldHVybiAtMTsKLQotCWlmIChkcnYtPnVzZV9tb25pdG9yICYmCi0JICAgIG5sODAyMTFfY3JlYXRlX21vbml0b3JfaW50ZXJmYWNlKGRydikpCi0JCXJldHVybiAtMTsKLSNlbmRpZgotCiAJaWYgKGRydi0+ZGV2aWNlX2FwX3NtZSAmJgogCSAgICB3cGFfZHJpdmVyX25sODAyMTFfcHJvYmVfcmVxX3JlcG9ydChic3MsIDEpIDwgMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IEZhaWxlZCB0byBlbmFibGUgIgpAQCAtNzMzNiw2ICs4MzYwLDggQEAKIHsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OwogCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBUZWFyZG93biBBUCglcykgLSBkZXZpY2VfYXBfc21lPSVkIHVzZV9tb25pdG9yPSVkIiwKKwkJICAgYnNzLT5pZm5hbWUsIGRydi0+ZGV2aWNlX2FwX3NtZSwgZHJ2LT51c2VfbW9uaXRvcik7CiAJaWYgKGRydi0+ZGV2aWNlX2FwX3NtZSkgewogCQl3cGFfZHJpdmVyX25sODAyMTFfcHJvYmVfcmVxX3JlcG9ydChic3MsIDApOwogCQlpZiAoIWRydi0+dXNlX21vbml0b3IpCkBAIC03MzkwLDE5ICs4NDE2LDE2IEBACiAJdTggKnBvczsKIAlpbnQgcmVzOwogCWludCBxb3MgPSBmbGFncyAmIFdQQV9TVEFfV01NOwotI2lmbmRlZiBBTkRST0lEX1AyUAorCiAJaWYgKGRydi0+ZGV2aWNlX2FwX3NtZSB8fCAhZHJ2LT51c2VfbW9uaXRvcikKLSNlbHNlCi0JaWYgKGRydi0+ZGV2aWNlX2FwX3NtZSAmJiAhZHJ2LT51c2VfbW9uaXRvcikKLSNlbmRpZgogCQlyZXR1cm4gbmw4MDIxMV9zZW5kX2VhcG9sX2RhdGEoYnNzLCBhZGRyLCBkYXRhLCBkYXRhX2xlbik7CiAKIAlsZW4gPSBzaXplb2YoKmhkcikgKyAocW9zID8gMiA6IDApICsgc2l6ZW9mKHJmYzEwNDJfaGVhZGVyKSArIDIgKwogCQlkYXRhX2xlbjsKIAloZHIgPSBvc196YWxsb2MobGVuKTsKIAlpZiAoaGRyID09IE5VTEwpIHsKLQkJcHJpbnRmKCJtYWxsb2MoKSBmYWlsZWQgZm9yIGk4MDJfc2VuZF9kYXRhKGxlbj0lbHUpXG4iLAotCQkgICAgICAgKHVuc2lnbmVkIGxvbmcpIGxlbik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJubDgwMjExOiBGYWlsZWQgdG8gYWxsb2NhdGUgRUFQT0wgYnVmZmVyKGxlbj0lbHUpIiwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBsZW4pOwogCQlyZXR1cm4gLTE7CiAJfQogCkBAIC03NTE5LDE0ICs4NTQyLDE0IEBACiAJCW5sbW9kZSA9IE5MODAyMTFfSUZUWVBFX0FQOwogCiAJb2xkX21vZGUgPSBkcnYtPm5sbW9kZTsKLQlpZiAod3BhX2RyaXZlcl9ubDgwMjExX3NldF9tb2RlKCZkcnYtPmZpcnN0X2Jzcywgbmxtb2RlKSkgeworCWlmICh3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGUoZHJ2LT5maXJzdF9ic3MsIG5sbW9kZSkpIHsKIAkJbmw4MDIxMV9yZW1vdmVfbW9uaXRvcl9pbnRlcmZhY2UoZHJ2KTsKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmICh3cGFfZHJpdmVyX25sODAyMTFfc2V0X2ZyZXEoJmRydi0+Zmlyc3RfYnNzLCAmZnJlcSkpIHsKKwlpZiAobmw4MDIxMV9zZXRfY2hhbm5lbChkcnYtPmZpcnN0X2JzcywgJmZyZXEsIDApKSB7CiAJCWlmIChvbGRfbW9kZSAhPSBubG1vZGUpCi0JCQl3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGUoJmRydi0+Zmlyc3RfYnNzLCBvbGRfbW9kZSk7CisJCQl3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGUoZHJ2LT5maXJzdF9ic3MsIG9sZF9tb2RlKTsKIAkJbmw4MDIxMV9yZW1vdmVfbW9uaXRvcl9pbnRlcmZhY2UoZHJ2KTsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTc1NTgsNiArODU4MSwxMiBAQAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogTGVhdmUgSUJTUyByZXF1ZXN0IHNlbnQgc3VjY2Vzc2Z1bGx5Iik7CiAKIG5sYV9wdXRfZmFpbHVyZToKKwlpZiAod3BhX2RyaXZlcl9ubDgwMjExX3NldF9tb2RlKGRydi0+Zmlyc3RfYnNzLAorCQkJCQlOTDgwMjExX0lGVFlQRV9TVEFUSU9OKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAibmw4MDIxMTogRmFpbGVkIHRvIHNldCBpbnRlcmZhY2UgaW50byAiCisJCQkgICAic3RhdGlvbiBtb2RlIik7CisJfQorCiAJbmxtc2dfZnJlZShtc2cpOwogCXJldHVybiByZXQ7CiB9CkBAIC03NTcyLDggKzg2MDEsNyBAQAogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBKb2luIElCU1MgKGlmaW5kZXg9JWQpIiwgZHJ2LT5pZmluZGV4KTsKIAotCWlmICh3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGUoJmRydi0+Zmlyc3RfYnNzLAotCQkJCQlOTDgwMjExX0lGVFlQRV9BREhPQykpIHsKKwlpZiAod3BhX2RyaXZlcl9ubDgwMjExX3NldF9tb2RlX2lic3MoZHJ2LT5maXJzdF9ic3MsIHBhcmFtcy0+ZnJlcSkpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIm5sODAyMTE6IEZhaWxlZCB0byBzZXQgaW50ZXJmYWNlIGludG8gIgogCQkJICAgIklCU1MgbW9kZSIpOwogCQlyZXR1cm4gLTE7CkBAIC03NjAwLDYgKzg2MjgsMTIgQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBmcmVxPSVkIiwgcGFyYW1zLT5mcmVxKTsKIAlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9XSVBIWV9GUkVRLCBwYXJhbXMtPmZyZXEpOwogCisJaWYgKHBhcmFtcy0+YmVhY29uX2ludCA+IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogYmVhY29uX2ludD0lZCIsIHBhcmFtcy0+YmVhY29uX2ludCk7CisJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0JFQUNPTl9JTlRFUlZBTCwKKwkJCSAgICBwYXJhbXMtPmJlYWNvbl9pbnQpOworCX0KKwogCXJldCA9IG5sODAyMTFfc2V0X2Nvbm5fa2V5cyhwYXJhbXMsIG1zZyk7CiAJaWYgKHJldCkKIAkJZ290byBubGFfcHV0X2ZhaWx1cmU7CkBAIC03NjEwLDEwICs4NjQ0LDEwIEBACiAJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfTUFDLCBFVEhfQUxFTiwgcGFyYW1zLT5ic3NpZCk7CiAJfQogCi0JaWYgKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfODAyXzFYIHx8Ci0JICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfUFNLIHx8Ci0JICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfODAyXzFYX1NIQTI1NiB8fAotCSAgICBwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IEtFWV9NR01UX1BTS19TSEEyNTYpIHsKKwlpZiAocGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfSUVFRTgwMjFYIHx8CisJICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX1BTSyB8fAorCSAgICBwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfU0hBMjU2IHx8CisJICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX1BTS19TSEEyNTYpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogY29udHJvbCBwb3J0Iik7CiAJCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfQVRUUl9DT05UUk9MX1BPUlQpOwogCX0KQEAgLTc2NTEsNDAgKzg2ODUsNDUgQEAKIH0KIAogCi1zdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV90cnlfY29ubmVjdCgKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl9hc3NvY2lhdGVfcGFyYW1zICpwYXJhbXMpCitzdGF0aWMgaW50IG5sODAyMTFfY29ubmVjdF9jb21tb24oc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCisJCQkJICBzdHJ1Y3Qgd3BhX2RyaXZlcl9hc3NvY2lhdGVfcGFyYW1zICpwYXJhbXMsCisJCQkJICBzdHJ1Y3QgbmxfbXNnICptc2cpCiB7Ci0Jc3RydWN0IG5sX21zZyAqbXNnOwotCWVudW0gbmw4MDIxMV9hdXRoX3R5cGUgdHlwZTsKLQlpbnQgcmV0ID0gMDsKLQlpbnQgYWxnczsKLQotCW1zZyA9IG5sbXNnX2FsbG9jKCk7Ci0JaWYgKCFtc2cpCi0JCXJldHVybiAtMTsKLQotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogQ29ubmVjdCAoaWZpbmRleD0lZCkiLCBkcnYtPmlmaW5kZXgpOwotCW5sODAyMTFfY21kKGRydiwgbXNnLCAwLCBOTDgwMjExX0NNRF9DT05ORUNUKTsKLQogCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0lGSU5ERVgsIGRydi0+aWZpbmRleCk7CisKIAlpZiAocGFyYW1zLT5ic3NpZCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBic3NpZD0iIE1BQ1NUUiwKIAkJCSAgIE1BQzJTVFIocGFyYW1zLT5ic3NpZCkpOwogCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX01BQywgRVRIX0FMRU4sIHBhcmFtcy0+YnNzaWQpOwogCX0KKworCWlmIChwYXJhbXMtPmJzc2lkX2hpbnQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogYnNzaWRfaGludD0iIE1BQ1NUUiwKKwkJCSAgIE1BQzJTVFIocGFyYW1zLT5ic3NpZF9oaW50KSk7CisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfTUFDX0hJTlQsIEVUSF9BTEVOLAorCQkJcGFyYW1zLT5ic3NpZF9oaW50KTsKKwl9CisKIAlpZiAocGFyYW1zLT5mcmVxKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIGZyZXE9JWQiLCBwYXJhbXMtPmZyZXEpOwogCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9XSVBIWV9GUkVRLCBwYXJhbXMtPmZyZXEpOwogCQlkcnYtPmFzc29jX2ZyZXEgPSBwYXJhbXMtPmZyZXE7CiAJfSBlbHNlCiAJCWRydi0+YXNzb2NfZnJlcSA9IDA7CisKKwlpZiAocGFyYW1zLT5mcmVxX2hpbnQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogZnJlcV9oaW50PSVkIiwgcGFyYW1zLT5mcmVxX2hpbnQpOworCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9XSVBIWV9GUkVRX0hJTlQsCisJCQkgICAgcGFyYW1zLT5mcmVxX2hpbnQpOworCX0KKwogCWlmIChwYXJhbXMtPmJnX3NjYW5fcGVyaW9kID49IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogYmcgc2NhbiBwZXJpb2Q9JWQiLAogCQkJICAgcGFyYW1zLT5iZ19zY2FuX3BlcmlvZCk7CiAJCU5MQV9QVVRfVTE2KG1zZywgTkw4MDIxMV9BVFRSX0JHX1NDQU5fUEVSSU9ELAogCQkJICAgIHBhcmFtcy0+Ymdfc2Nhbl9wZXJpb2QpOwogCX0KKwogCWlmIChwYXJhbXMtPnNzaWQpIHsKIAkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiICAqIFNTSUQiLAogCQkJCSAgcGFyYW1zLT5zc2lkLCBwYXJhbXMtPnNzaWRfbGVuKTsKQEAgLTc2OTUsMTEgKzg3MzQsMTQ4IEBACiAJCW9zX21lbWNweShkcnYtPnNzaWQsIHBhcmFtcy0+c3NpZCwgcGFyYW1zLT5zc2lkX2xlbik7CiAJCWRydi0+c3NpZF9sZW4gPSBwYXJhbXMtPnNzaWRfbGVuOwogCX0KKwogCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIiAgKiBJRXMiLCBwYXJhbXMtPndwYV9pZSwgcGFyYW1zLT53cGFfaWVfbGVuKTsKIAlpZiAocGFyYW1zLT53cGFfaWUpCiAJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfSUUsIHBhcmFtcy0+d3BhX2llX2xlbiwKIAkJCXBhcmFtcy0+d3BhX2llKTsKIAorCWlmIChwYXJhbXMtPndwYV9wcm90bykgeworCQllbnVtIG5sODAyMTFfd3BhX3ZlcnNpb25zIHZlciA9IDA7CisKKwkJaWYgKHBhcmFtcy0+d3BhX3Byb3RvICYgV1BBX1BST1RPX1dQQSkKKwkJCXZlciB8PSBOTDgwMjExX1dQQV9WRVJTSU9OXzE7CisJCWlmIChwYXJhbXMtPndwYV9wcm90byAmIFdQQV9QUk9UT19SU04pCisJCQl2ZXIgfD0gTkw4MDIxMV9XUEFfVkVSU0lPTl8yOworCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIFdQQSBWZXJzaW9ucyAweCV4IiwgdmVyKTsKKwkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfV1BBX1ZFUlNJT05TLCB2ZXIpOworCX0KKworCWlmIChwYXJhbXMtPnBhaXJ3aXNlX3N1aXRlICE9IFdQQV9DSVBIRVJfTk9ORSkgeworCQl1MzIgY2lwaGVyID0gd3BhX2NpcGhlcl90b19jaXBoZXJfc3VpdGUocGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSk7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIHBhaXJ3aXNlPTB4JXgiLCBjaXBoZXIpOworCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVTX1BBSVJXSVNFLCBjaXBoZXIpOworCX0KKworCWlmIChwYXJhbXMtPmdyb3VwX3N1aXRlID09IFdQQV9DSVBIRVJfR1RLX05PVF9VU0VEICYmCisJICAgICEoZHJ2LT5jYXBhLmVuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfR1RLX05PVF9VU0VEKSkgeworCQkvKgorCQkgKiBUaGlzIGlzIGxpa2VseSB0byB3b3JrIGV2ZW4gdGhvdWdoIG1hbnkgZHJpdmVycyBkbyBub3QKKwkJICogYWR2ZXJ0aXNlIHN1cHBvcnQgZm9yIG9wZXJhdGlvbnMgd2l0aG91dCBHVEsuCisJCSAqLworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBza2lwIGdyb3VwIGNpcGhlciBjb25maWd1cmF0aW9uIGZvciBHVEtfTk9UX1VTRUQgZHVlIHRvIG1pc3NpbmcgZHJpdmVyIHN1cHBvcnQgYWR2ZXJ0aXNlbWVudCIpOworCX0gZWxzZSBpZiAocGFyYW1zLT5ncm91cF9zdWl0ZSAhPSBXUEFfQ0lQSEVSX05PTkUpIHsKKwkJdTMyIGNpcGhlciA9IHdwYV9jaXBoZXJfdG9fY2lwaGVyX3N1aXRlKHBhcmFtcy0+Z3JvdXBfc3VpdGUpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBncm91cD0weCV4IiwgY2lwaGVyKTsKKwkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0lQSEVSX1NVSVRFX0dST1VQLCBjaXBoZXIpOworCX0KKworCWlmIChwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IFdQQV9LRVlfTUdNVF9JRUVFODAyMVggfHwKKwkgICAgcGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfUFNLIHx8CisJICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX0ZUX0lFRUU4MDIxWCB8fAorCSAgICBwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IFdQQV9LRVlfTUdNVF9GVF9QU0sgfHwKKwkgICAgcGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfQ0NLTSB8fAorCSAgICBwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IFdQQV9LRVlfTUdNVF9PU0VOIHx8CisJICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX0lFRUU4MDIxWF9TSEEyNTYgfHwKKwkgICAgcGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfUFNLX1NIQTI1NikgeworCQlpbnQgbWdtdCA9IFdMQU5fQUtNX1NVSVRFX1BTSzsKKworCQlzd2l0Y2ggKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUpIHsKKwkJY2FzZSBXUEFfS0VZX01HTVRfQ0NLTToKKwkJCW1nbXQgPSBXTEFOX0FLTV9TVUlURV9DQ0tNOworCQkJYnJlYWs7CisJCWNhc2UgV1BBX0tFWV9NR01UX0lFRUU4MDIxWDoKKwkJCW1nbXQgPSBXTEFOX0FLTV9TVUlURV84MDIxWDsKKwkJCWJyZWFrOworCQljYXNlIFdQQV9LRVlfTUdNVF9GVF9JRUVFODAyMVg6CisJCQltZ210ID0gV0xBTl9BS01fU1VJVEVfRlRfODAyMVg7CisJCQlicmVhazsKKwkJY2FzZSBXUEFfS0VZX01HTVRfRlRfUFNLOgorCQkJbWdtdCA9IFdMQU5fQUtNX1NVSVRFX0ZUX1BTSzsKKwkJCWJyZWFrOworCQljYXNlIFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfU0hBMjU2OgorCQkJbWdtdCA9IFdMQU5fQUtNX1NVSVRFXzgwMjFYX1NIQTI1NjsKKwkJCWJyZWFrOworCQljYXNlIFdQQV9LRVlfTUdNVF9QU0tfU0hBMjU2OgorCQkJbWdtdCA9IFdMQU5fQUtNX1NVSVRFX1BTS19TSEEyNTY7CisJCQlicmVhazsKKwkJY2FzZSBXUEFfS0VZX01HTVRfT1NFTjoKKwkJCW1nbXQgPSBXTEFOX0FLTV9TVUlURV9PU0VOOworCQkJYnJlYWs7CisJCWNhc2UgV1BBX0tFWV9NR01UX1BTSzoKKwkJZGVmYXVsdDoKKwkJCW1nbXQgPSBXTEFOX0FLTV9TVUlURV9QU0s7CisJCQlicmVhazsKKwkJfQorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBha209MHgleCIsIG1nbXQpOworCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9BS01fU1VJVEVTLCBtZ210KTsKKwl9CisKKwlOTEFfUFVUX0ZMQUcobXNnLCBOTDgwMjExX0FUVFJfQ09OVFJPTF9QT1JUKTsKKworCWlmIChwYXJhbXMtPm1nbXRfZnJhbWVfcHJvdGVjdGlvbiA9PSBNR01UX0ZSQU1FX1BST1RFQ1RJT05fUkVRVUlSRUQpCisJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1VTRV9NRlAsIE5MODAyMTFfTUZQX1JFUVVJUkVEKTsKKworCWlmIChwYXJhbXMtPmRpc2FibGVfaHQpCisJCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfQVRUUl9ESVNBQkxFX0hUKTsKKworCWlmIChwYXJhbXMtPmh0Y2FwcyAmJiBwYXJhbXMtPmh0Y2Fwc19tYXNrKSB7CisJCWludCBzeiA9IHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyk7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIiAgKiBodGNhcHMiLCBwYXJhbXMtPmh0Y2Fwcywgc3opOworCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0hUX0NBUEFCSUxJVFksIHN6LCBwYXJhbXMtPmh0Y2Fwcyk7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIiAgKiBodGNhcHNfbWFzayIsCisJCQkgICAgcGFyYW1zLT5odGNhcHNfbWFzaywgc3opOworCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0hUX0NBUEFCSUxJVFlfTUFTSywgc3osCisJCQlwYXJhbXMtPmh0Y2Fwc19tYXNrKTsKKwl9CisKKyNpZmRlZiBDT05GSUdfVkhUX09WRVJSSURFUworCWlmIChwYXJhbXMtPmRpc2FibGVfdmh0KSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIFZIVCBkaXNhYmxlZCIpOworCQlOTEFfUFVUX0ZMQUcobXNnLCBOTDgwMjExX0FUVFJfRElTQUJMRV9WSFQpOworCX0KKworCWlmIChwYXJhbXMtPnZodGNhcHMgJiYgcGFyYW1zLT52aHRjYXBzX21hc2spIHsKKwkJaW50IHN6ID0gc2l6ZW9mKHN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyk7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIiAgKiB2aHRjYXBzIiwgcGFyYW1zLT52aHRjYXBzLCBzeik7CisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfVkhUX0NBUEFCSUxJVFksIHN6LCBwYXJhbXMtPnZodGNhcHMpOworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICIgICogdmh0Y2Fwc19tYXNrIiwKKwkJCSAgICBwYXJhbXMtPnZodGNhcHNfbWFzaywgc3opOworCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX1ZIVF9DQVBBQklMSVRZX01BU0ssIHN6LAorCQkJcGFyYW1zLT52aHRjYXBzX21hc2spOworCX0KKyNlbmRpZiAvKiBDT05GSUdfVkhUX09WRVJSSURFUyAqLworCisJaWYgKHBhcmFtcy0+cDJwKQorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBQMlAgZ3JvdXAiKTsKKworCXJldHVybiAwOworbmxhX3B1dF9mYWlsdXJlOgorCXJldHVybiAtMTsKK30KKworCitzdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV90cnlfY29ubmVjdCgKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9hc3NvY2lhdGVfcGFyYW1zICpwYXJhbXMpCit7CisJc3RydWN0IG5sX21zZyAqbXNnOworCWVudW0gbmw4MDIxMV9hdXRoX3R5cGUgdHlwZTsKKwlpbnQgcmV0OworCWludCBhbGdzOworCisJbXNnID0gbmxtc2dfYWxsb2MoKTsKKwlpZiAoIW1zZykKKwkJcmV0dXJuIC0xOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBDb25uZWN0IChpZmluZGV4PSVkKSIsIGRydi0+aWZpbmRleCk7CisJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX0NPTk5FQ1QpOworCisJcmV0ID0gbmw4MDIxMV9jb25uZWN0X2NvbW1vbihkcnYsIHBhcmFtcywgbXNnKTsKKwlpZiAocmV0KQorCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsKKwogCWFsZ3MgPSAwOwogCWlmIChwYXJhbXMtPmF1dGhfYWxnICYgV1BBX0FVVEhfQUxHX09QRU4pCiAJCWFsZ3MrKzsKQEAgLTc3MjgsMTI5ICs4OTA0LDYgQEAKIAlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9BVVRIX1RZUEUsIHR5cGUpOwogCiBza2lwX2F1dGhfdHlwZToKLQlpZiAocGFyYW1zLT53cGFfcHJvdG8pIHsKLQkJZW51bSBubDgwMjExX3dwYV92ZXJzaW9ucyB2ZXIgPSAwOwotCi0JCWlmIChwYXJhbXMtPndwYV9wcm90byAmIFdQQV9QUk9UT19XUEEpCi0JCQl2ZXIgfD0gTkw4MDIxMV9XUEFfVkVSU0lPTl8xOwotCQlpZiAocGFyYW1zLT53cGFfcHJvdG8gJiBXUEFfUFJPVE9fUlNOKQotCQkJdmVyIHw9IE5MODAyMTFfV1BBX1ZFUlNJT05fMjsKLQotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgKiBXUEEgVmVyc2lvbnMgMHgleCIsIHZlcik7Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1dQQV9WRVJTSU9OUywgdmVyKTsKLQl9Ci0KLQlpZiAocGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSAhPSBDSVBIRVJfTk9ORSkgewotCQlpbnQgY2lwaGVyOwotCi0JCXN3aXRjaCAocGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSkgewotCQljYXNlIENJUEhFUl9TTVM0OgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfU01TNDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9XRVA0MDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDQwOwotCQkJYnJlYWs7Ci0JCWNhc2UgQ0lQSEVSX1dFUDEwNDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDEwNDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9DQ01QOgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfQ0NNUDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9HQ01QOgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfR0NNUDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9US0lQOgotCQlkZWZhdWx0OgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfVEtJUDsKLQkJCWJyZWFrOwotCQl9Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0NJUEhFUl9TVUlURVNfUEFJUldJU0UsIGNpcGhlcik7Ci0JfQotCi0JaWYgKHBhcmFtcy0+Z3JvdXBfc3VpdGUgIT0gQ0lQSEVSX05PTkUpIHsKLQkJaW50IGNpcGhlcjsKLQotCQlzd2l0Y2ggKHBhcmFtcy0+Z3JvdXBfc3VpdGUpIHsKLQkJY2FzZSBDSVBIRVJfU01TNDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX1NNUzQ7Ci0JCQlicmVhazsKLQkJY2FzZSBDSVBIRVJfV0VQNDA6Ci0JCQljaXBoZXIgPSBXTEFOX0NJUEhFUl9TVUlURV9XRVA0MDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9XRVAxMDQ6Ci0JCQljaXBoZXIgPSBXTEFOX0NJUEhFUl9TVUlURV9XRVAxMDQ7Ci0JCQlicmVhazsKLQkJY2FzZSBDSVBIRVJfQ0NNUDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVA7Ci0JCQlicmVhazsKLQkJY2FzZSBDSVBIRVJfR0NNUDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX0dDTVA7Ci0JCQlicmVhazsKLQkJY2FzZSBDSVBIRVJfVEtJUDoKLQkJZGVmYXVsdDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX1RLSVA7Ci0JCQlicmVhazsKLQkJfQotCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVfR1JPVVAsIGNpcGhlcik7Ci0JfQotCi0JaWYgKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfODAyXzFYIHx8Ci0JICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfUFNLIHx8Ci0JICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfRlRfODAyXzFYIHx8Ci0JICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfRlRfUFNLIHx8Ci0JICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gS0VZX01HTVRfQ0NLTSkgewotCQlpbnQgbWdtdCA9IFdMQU5fQUtNX1NVSVRFX1BTSzsKLQotCQlzd2l0Y2ggKHBhcmFtcy0+a2V5X21nbXRfc3VpdGUpIHsKLQkJY2FzZSBLRVlfTUdNVF9DQ0tNOgotCQkJbWdtdCA9IFdMQU5fQUtNX1NVSVRFX0NDS007Ci0JCQlicmVhazsKLQkJY2FzZSBLRVlfTUdNVF84MDJfMVg6Ci0JCQltZ210ID0gV0xBTl9BS01fU1VJVEVfODAyMVg7Ci0JCQlicmVhazsKLQkJY2FzZSBLRVlfTUdNVF9GVF84MDJfMVg6Ci0JCQltZ210ID0gV0xBTl9BS01fU1VJVEVfRlRfODAyMVg7Ci0JCQlicmVhazsKLQkJY2FzZSBLRVlfTUdNVF9GVF9QU0s6Ci0JCQltZ210ID0gV0xBTl9BS01fU1VJVEVfRlRfUFNLOwotCQkJYnJlYWs7Ci0JCWNhc2UgS0VZX01HTVRfUFNLOgotCQlkZWZhdWx0OgotCQkJbWdtdCA9IFdMQU5fQUtNX1NVSVRFX1BTSzsKLQkJCWJyZWFrOwotCQl9Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0FLTV9TVUlURVMsIG1nbXQpOwotCX0KLQotI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCi0JaWYgKHBhcmFtcy0+bWdtdF9mcmFtZV9wcm90ZWN0aW9uID09IE1HTVRfRlJBTUVfUFJPVEVDVElPTl9SRVFVSVJFRCkKLQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfVVNFX01GUCwgTkw4MDIxMV9NRlBfUkVRVUlSRUQpOwotI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCi0KLQlpZiAocGFyYW1zLT5kaXNhYmxlX2h0KQotCQlOTEFfUFVUX0ZMQUcobXNnLCBOTDgwMjExX0FUVFJfRElTQUJMRV9IVCk7Ci0KLQlpZiAocGFyYW1zLT5odGNhcHMgJiYgcGFyYW1zLT5odGNhcHNfbWFzaykgewotCQlpbnQgc3ogPSBzaXplb2Yoc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMpOwotCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0hUX0NBUEFCSUxJVFksIHN6LCBwYXJhbXMtPmh0Y2Fwcyk7Ci0JCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfSFRfQ0FQQUJJTElUWV9NQVNLLCBzeiwKLQkJCXBhcmFtcy0+aHRjYXBzX21hc2spOwotCX0KLQotI2lmZGVmIENPTkZJR19WSFRfT1ZFUlJJREVTCi0JaWYgKHBhcmFtcy0+ZGlzYWJsZV92aHQpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogVkhUIGRpc2FibGVkIik7Ci0JCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfQVRUUl9ESVNBQkxFX1ZIVCk7Ci0JfQotCi0JaWYgKHBhcmFtcy0+dmh0Y2FwcyAmJiBwYXJhbXMtPnZodGNhcHNfbWFzaykgewotCQlpbnQgc3ogPSBzaXplb2Yoc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzKTsKLQkJTkxBX1BVVChtc2csIE5MODAyMTFfQVRUUl9WSFRfQ0FQQUJJTElUWSwgc3osIHBhcmFtcy0+dmh0Y2Fwcyk7Ci0JCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfVkhUX0NBUEFCSUxJVFlfTUFTSywgc3osCi0JCQlwYXJhbXMtPnZodGNhcHNfbWFzayk7Ci0JfQotI2VuZGlmIC8qIENPTkZJR19WSFRfT1ZFUlJJREVTICovCi0KIAlyZXQgPSBubDgwMjExX3NldF9jb25uX2tleXMocGFyYW1zLCBtc2cpOwogCWlmIChyZXQpCiAJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOwpAQCAtNzkwMCw3ICs4OTUzLDcgQEAKIHsKIAlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CiAJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKLQlpbnQgcmV0ID0gLTE7CisJaW50IHJldDsKIAlzdHJ1Y3QgbmxfbXNnICptc2c7CiAKIAlpZiAocGFyYW1zLT5tb2RlID09IElFRUU4MDIxMV9NT0RFX0FQKQpAQCAtNzkyOCw5NSArODk4MSw5IEBACiAJCSAgIGRydi0+aWZpbmRleCk7CiAJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX0FTU09DSUFURSk7CiAKLQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9JRklOREVYLCBkcnYtPmlmaW5kZXgpOwotCWlmIChwYXJhbXMtPmJzc2lkKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIGJzc2lkPSIgTUFDU1RSLAotCQkJICAgTUFDMlNUUihwYXJhbXMtPmJzc2lkKSk7Ci0JCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfTUFDLCBFVEhfQUxFTiwgcGFyYW1zLT5ic3NpZCk7Ci0JfQotCWlmIChwYXJhbXMtPmZyZXEpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogZnJlcT0lZCIsIHBhcmFtcy0+ZnJlcSk7Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1dJUEhZX0ZSRVEsIHBhcmFtcy0+ZnJlcSk7Ci0JCWRydi0+YXNzb2NfZnJlcSA9IHBhcmFtcy0+ZnJlcTsKLQl9IGVsc2UKLQkJZHJ2LT5hc3NvY19mcmVxID0gMDsKLQlpZiAocGFyYW1zLT5iZ19zY2FuX3BlcmlvZCA+PSAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIGJnIHNjYW4gcGVyaW9kPSVkIiwKLQkJCSAgIHBhcmFtcy0+Ymdfc2Nhbl9wZXJpb2QpOwotCQlOTEFfUFVUX1UxNihtc2csIE5MODAyMTFfQVRUUl9CR19TQ0FOX1BFUklPRCwKLQkJCSAgICBwYXJhbXMtPmJnX3NjYW5fcGVyaW9kKTsKLQl9Ci0JaWYgKHBhcmFtcy0+c3NpZCkgewotCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICIgICogU1NJRCIsCi0JCQkJICBwYXJhbXMtPnNzaWQsIHBhcmFtcy0+c3NpZF9sZW4pOwotCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX1NTSUQsIHBhcmFtcy0+c3NpZF9sZW4sCi0JCQlwYXJhbXMtPnNzaWQpOwotCQlpZiAocGFyYW1zLT5zc2lkX2xlbiA+IHNpemVvZihkcnYtPnNzaWQpKQotCQkJZ290byBubGFfcHV0X2ZhaWx1cmU7Ci0JCW9zX21lbWNweShkcnYtPnNzaWQsIHBhcmFtcy0+c3NpZCwgcGFyYW1zLT5zc2lkX2xlbik7Ci0JCWRydi0+c3NpZF9sZW4gPSBwYXJhbXMtPnNzaWRfbGVuOwotCX0KLQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICIgICogSUVzIiwgcGFyYW1zLT53cGFfaWUsIHBhcmFtcy0+d3BhX2llX2xlbik7Ci0JaWYgKHBhcmFtcy0+d3BhX2llKQotCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0lFLCBwYXJhbXMtPndwYV9pZV9sZW4sCi0JCQlwYXJhbXMtPndwYV9pZSk7Ci0KLQlpZiAocGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSAhPSBDSVBIRVJfTk9ORSkgewotCQlpbnQgY2lwaGVyOwotCi0JCXN3aXRjaCAocGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSkgewotCQljYXNlIENJUEhFUl9XRVA0MDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDQwOwotCQkJYnJlYWs7Ci0JCWNhc2UgQ0lQSEVSX1dFUDEwNDoKLQkJCWNpcGhlciA9IFdMQU5fQ0lQSEVSX1NVSVRFX1dFUDEwNDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9DQ01QOgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfQ0NNUDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9HQ01QOgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfR0NNUDsKLQkJCWJyZWFrOwotCQljYXNlIENJUEhFUl9US0lQOgotCQlkZWZhdWx0OgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfVEtJUDsKLQkJCWJyZWFrOwotCQl9Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIHBhaXJ3aXNlPTB4JXgiLCBjaXBoZXIpOwotCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVTX1BBSVJXSVNFLCBjaXBoZXIpOwotCX0KLQotCWlmIChwYXJhbXMtPmdyb3VwX3N1aXRlICE9IENJUEhFUl9OT05FKSB7Ci0JCWludCBjaXBoZXI7Ci0KLQkJc3dpdGNoIChwYXJhbXMtPmdyb3VwX3N1aXRlKSB7Ci0JCWNhc2UgQ0lQSEVSX1dFUDQwOgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfV0VQNDA7Ci0JCQlicmVhazsKLQkJY2FzZSBDSVBIRVJfV0VQMTA0OgotCQkJY2lwaGVyID0gV0xBTl9DSVBIRVJfU1VJVEVfV0VQMTA0OwotCQkJYnJlYWs7Ci0JCWNhc2UgQ0lQSEVSX0NDTVA6Ci0JCQljaXBoZXIgPSBXTEFOX0NJUEhFUl9TVUlURV9DQ01QOwotCQkJYnJlYWs7Ci0JCWNhc2UgQ0lQSEVSX0dDTVA6Ci0JCQljaXBoZXIgPSBXTEFOX0NJUEhFUl9TVUlURV9HQ01QOwotCQkJYnJlYWs7Ci0JCWNhc2UgQ0lQSEVSX1RLSVA6Ci0JCWRlZmF1bHQ6Ci0JCQljaXBoZXIgPSBXTEFOX0NJUEhFUl9TVUlURV9US0lQOwotCQkJYnJlYWs7Ci0JCX0KLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogZ3JvdXA9MHgleCIsIGNpcGhlcik7Ci0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0NJUEhFUl9TVUlURV9HUk9VUCwgY2lwaGVyKTsKLQl9Ci0KLSNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwotCWlmIChwYXJhbXMtPm1nbXRfZnJhbWVfcHJvdGVjdGlvbiA9PSBNR01UX0ZSQU1FX1BST1RFQ1RJT05fUkVRVUlSRUQpCi0JCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1VTRV9NRlAsIE5MODAyMTFfTUZQX1JFUVVJUkVEKTsKLSNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwotCi0JTkxBX1BVVF9GTEFHKG1zZywgTkw4MDIxMV9BVFRSX0NPTlRST0xfUE9SVCk7CisJcmV0ID0gbmw4MDIxMV9jb25uZWN0X2NvbW1vbihkcnYsIHBhcmFtcywgbXNnKTsKKwlpZiAocmV0KQorCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsKIAogCWlmIChwYXJhbXMtPnByZXZfYnNzaWQpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogcHJldl9ic3NpZD0iIE1BQ1NUUiwKQEAgLTgwMjUsMzMgKzg5OTIsNiBAQAogCQkJcGFyYW1zLT5wcmV2X2Jzc2lkKTsKIAl9CiAKLQlpZiAocGFyYW1zLT5kaXNhYmxlX2h0KQotCQlOTEFfUFVUX0ZMQUcobXNnLCBOTDgwMjExX0FUVFJfRElTQUJMRV9IVCk7Ci0KLQlpZiAocGFyYW1zLT5odGNhcHMgJiYgcGFyYW1zLT5odGNhcHNfbWFzaykgewotCQlpbnQgc3ogPSBzaXplb2Yoc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMpOwotCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0hUX0NBUEFCSUxJVFksIHN6LCBwYXJhbXMtPmh0Y2Fwcyk7Ci0JCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfSFRfQ0FQQUJJTElUWV9NQVNLLCBzeiwKLQkJCXBhcmFtcy0+aHRjYXBzX21hc2spOwotCX0KLQotI2lmZGVmIENPTkZJR19WSFRfT1ZFUlJJREVTCi0JaWYgKHBhcmFtcy0+ZGlzYWJsZV92aHQpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogVkhUIGRpc2FibGVkIik7Ci0JCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfQVRUUl9ESVNBQkxFX1ZIVCk7Ci0JfQotCi0JaWYgKHBhcmFtcy0+dmh0Y2FwcyAmJiBwYXJhbXMtPnZodGNhcHNfbWFzaykgewotCQlpbnQgc3ogPSBzaXplb2Yoc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzKTsKLQkJTkxBX1BVVChtc2csIE5MODAyMTFfQVRUUl9WSFRfQ0FQQUJJTElUWSwgc3osIHBhcmFtcy0+dmh0Y2Fwcyk7Ci0JCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfVkhUX0NBUEFCSUxJVFlfTUFTSywgc3osCi0JCQlwYXJhbXMtPnZodGNhcHNfbWFzayk7Ci0JfQotI2VuZGlmIC8qIENPTkZJR19WSFRfT1ZFUlJJREVTICovCi0KLQlpZiAocGFyYW1zLT5wMnApCi0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAqIFAyUCBncm91cCIpOwotCiAJcmV0ID0gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBOVUxMLCBOVUxMKTsKIAltc2cgPSBOVUxMOwogCWlmIChyZXQpIHsKQEAgLTgwODUsNyArOTAyNSw3IEBACiAJCXJldHVybiAtRU5PTUVNOwogCiAJbmw4MDIxMV9jbWQoZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX1NFVF9JTlRFUkZBQ0UpOwotCWlmIChubDgwMjExX3NldF9pZmFjZV9pZChtc2csICZkcnYtPmZpcnN0X2JzcykgPCAwKQorCWlmIChubDgwMjExX3NldF9pZmFjZV9pZChtc2csIGRydi0+Zmlyc3RfYnNzKSA8IDApCiAJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOwogCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0lGVFlQRSwgbW9kZSk7CiAKQEAgLTgxMDEsMjYgKzkwNDEsMjkgQEAKIH0KIAogCi1zdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZShzdHJ1Y3QgaTgwMl9ic3MgKmJzcywKLQkJCQkgICAgICAgZW51bSBubDgwMjExX2lmdHlwZSBubG1vZGUpCitzdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZV9pbXBsKAorCQlzdHJ1Y3QgaTgwMl9ic3MgKmJzcywKKwkJZW51bSBubDgwMjExX2lmdHlwZSBubG1vZGUsCisJCXN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zICpkZXNpcmVkX2ZyZXFfcGFyYW1zKQogewogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAJaW50IHJldCA9IC0xOwogCWludCBpOwogCWludCB3YXNfYXAgPSBpc19hcF9pbnRlcmZhY2UoZHJ2LT5ubG1vZGUpOwogCWludCByZXM7CisJaW50IG1vZGVfc3dpdGNoX3JlczsKIAotCXJlcyA9IG5sODAyMTFfc2V0X21vZGUoZHJ2LCBkcnYtPmlmaW5kZXgsIG5sbW9kZSk7Ci0JaWYgKHJlcyAmJiBubG1vZGUgPT0gbmw4MDIxMV9nZXRfaWZtb2RlKGJzcykpCi0JCXJlcyA9IDA7CisJbW9kZV9zd2l0Y2hfcmVzID0gbmw4MDIxMV9zZXRfbW9kZShkcnYsIGRydi0+aWZpbmRleCwgbmxtb2RlKTsKKwlpZiAobW9kZV9zd2l0Y2hfcmVzICYmIG5sbW9kZSA9PSBubDgwMjExX2dldF9pZm1vZGUoYnNzKSkKKwkJbW9kZV9zd2l0Y2hfcmVzID0gMDsKIAotCWlmIChyZXMgPT0gMCkgeworCWlmIChtb2RlX3N3aXRjaF9yZXMgPT0gMCkgewogCQlkcnYtPm5sbW9kZSA9IG5sbW9kZTsKIAkJcmV0ID0gMDsKIAkJZ290byBkb25lOwogCX0KIAotCWlmIChyZXMgPT0gLUVOT0RFVikKKwlpZiAobW9kZV9zd2l0Y2hfcmVzID09IC1FTk9ERVYpCiAJCXJldHVybiAtMTsKIAogCWlmIChubG1vZGUgPT0gZHJ2LT5ubG1vZGUpIHsKQEAgLTgxNDAsMjEgKzkwODMsMzUgQEAKIAkJcmVzID0gaTgwMl9zZXRfaWZhY2VfZmxhZ3MoYnNzLCAwKTsKIAkJaWYgKHJlcyA9PSAtRUFDQ0VTIHx8IHJlcyA9PSAtRU5PREVWKQogCQkJYnJlYWs7Ci0JCWlmIChyZXMgPT0gMCkgewotCQkJLyogVHJ5IHRvIHNldCB0aGUgbW9kZSBhZ2FpbiB3aGlsZSB0aGUgaW50ZXJmYWNlIGlzCi0JCQkgKiBkb3duICovCi0JCQlyZXQgPSBubDgwMjExX3NldF9tb2RlKGRydiwgZHJ2LT5pZmluZGV4LCBubG1vZGUpOwotCQkJaWYgKHJldCA9PSAtRUFDQ0VTKQotCQkJCWJyZWFrOwotCQkJcmVzID0gaTgwMl9zZXRfaWZhY2VfZmxhZ3MoYnNzLCAxKTsKLQkJCWlmIChyZXMgJiYgIXJldCkKLQkJCQlyZXQgPSAtMTsKLQkJCWVsc2UgaWYgKHJldCAhPSAtRUJVU1kpCi0JCQkJYnJlYWs7Ci0JCX0gZWxzZQorCQlpZiAocmVzICE9IDApIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogRmFpbGVkIHRvIHNldCAiCiAJCQkJICAgImludGVyZmFjZSBkb3duIik7Ci0JCW9zX3NsZWVwKDAsIDEwMDAwMCk7CisJCQlvc19zbGVlcCgwLCAxMDAwMDApOworCQkJY29udGludWU7CisJCX0KKworCQkvKgorCQkgKiBTZXR0aW5nIHRoZSBtb2RlIHdpbGwgZmFpbCBmb3Igc29tZSBkcml2ZXJzIGlmIHRoZSBwaHkgaXMKKwkJICogb24gYSBmcmVxdWVuY3kgdGhhdCB0aGUgbW9kZSBpcyBkaXNhbGxvd2VkIGluLgorCQkgKi8KKwkJaWYgKGRlc2lyZWRfZnJlcV9wYXJhbXMpIHsKKwkJCXJlcyA9IGk4MDJfc2V0X2ZyZXEoYnNzLCBkZXNpcmVkX2ZyZXFfcGFyYW1zKTsKKwkJCWlmIChyZXMpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCQkJICAgIm5sODAyMTE6IEZhaWxlZCB0byBzZXQgZnJlcXVlbmN5IG9uIGludGVyZmFjZSIpOworCQkJfQorCQl9CisKKwkJLyogVHJ5IHRvIHNldCB0aGUgbW9kZSBhZ2FpbiB3aGlsZSB0aGUgaW50ZXJmYWNlIGlzIGRvd24gKi8KKwkJbW9kZV9zd2l0Y2hfcmVzID0gbmw4MDIxMV9zZXRfbW9kZShkcnYsIGRydi0+aWZpbmRleCwgbmxtb2RlKTsKKwkJaWYgKG1vZGVfc3dpdGNoX3JlcyA9PSAtRUJVU1kpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJubDgwMjExOiBEZWxheWluZyBtb2RlIHNldCB3aGlsZSBpbnRlcmZhY2UgZ29pbmcgZG93biIpOworCQkJb3Nfc2xlZXAoMCwgMTAwMDAwKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCXJldCA9IG1vZGVfc3dpdGNoX3JlczsKKwkJYnJlYWs7CiAJfQogCiAJaWYgKCFyZXQpIHsKQEAgLTgxNjQsNiArOTEyMSwxNCBAQAogCQlkcnYtPmlnbm9yZV9pZl9kb3duX2V2ZW50ID0gMTsKIAl9CiAKKwkvKiBCcmluZyB0aGUgaW50ZXJmYWNlIGJhY2sgdXAgKi8KKwlyZXMgPSBsaW51eF9zZXRfaWZhY2VfZmxhZ3MoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssIGJzcy0+aWZuYW1lLCAxKTsKKwlpZiAocmVzICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAibmw4MDIxMTogRmFpbGVkIHRvIHNldCBpbnRlcmZhY2UgdXAgYWZ0ZXIgc3dpdGNoaW5nIG1vZGUiKTsKKwkJcmV0ID0gLTE7CisJfQorCiBkb25lOgogCWlmIChyZXQpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJbnRlcmZhY2UgbW9kZSBjaGFuZ2UgdG8gJWQgIgpAQCAtODE5NywxMSArOTE2Miw2MSBAQAogfQogCiAKK3N0YXRpYyBpbnQgZGZzX2luZm9faGFuZGxlcihzdHJ1Y3QgbmxfbXNnICptc2csIHZvaWQgKmFyZykKK3sKKwlzdHJ1Y3QgbmxhdHRyICp0YltOTDgwMjExX0FUVFJfTUFYICsgMV07CisJc3RydWN0IGdlbmxtc2doZHIgKmdubGggPSBubG1zZ19kYXRhKG5sbXNnX2hkcihtc2cpKTsKKwlpbnQgKmRmc19jYXBhYmlsaXR5X3B0ciA9IGFyZzsKKworCW5sYV9wYXJzZSh0YiwgTkw4MDIxMV9BVFRSX01BWCwgZ2VubG1zZ19hdHRyZGF0YShnbmxoLCAwKSwKKwkJICBnZW5sbXNnX2F0dHJsZW4oZ25saCwgMCksIE5VTEwpOworCisJaWYgKHRiW05MODAyMTFfQVRUUl9WRU5ET1JfREFUQV0pIHsKKwkJc3RydWN0IG5sYXR0ciAqbmxfdmVuZCA9IHRiW05MODAyMTFfQVRUUl9WRU5ET1JfREFUQV07CisJCXN0cnVjdCBubGF0dHIgKnRiX3ZlbmRvcltRQ0FfV0xBTl9WRU5ET1JfQVRUUl9NQVggKyAxXTsKKworCQlubGFfcGFyc2UodGJfdmVuZG9yLCBRQ0FfV0xBTl9WRU5ET1JfQVRUUl9NQVgsCisJCQkgIG5sYV9kYXRhKG5sX3ZlbmQpLCBubGFfbGVuKG5sX3ZlbmQpLCBOVUxMKTsKKworCQlpZiAodGJfdmVuZG9yW1FDQV9XTEFOX1ZFTkRPUl9BVFRSX0RGU10pIHsKKwkJCXUzMiB2YWw7CisJCQl2YWwgPSBubGFfZ2V0X3UzMih0Yl92ZW5kb3JbUUNBX1dMQU5fVkVORE9SX0FUVFJfREZTXSk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IERGUyBvZmZsb2FkIGNhcGFiaWxpdHk6ICV1IiwKKwkJCQkgICB2YWwpOworCQkJKmRmc19jYXBhYmlsaXR5X3B0ciA9IHZhbDsKKwkJfQorCX0KKworCXJldHVybiBOTF9TS0lQOworfQorCisKK3N0YXRpYyBpbnQgd3BhX2RyaXZlcl9ubDgwMjExX3NldF9tb2RlKHN0cnVjdCBpODAyX2JzcyAqYnNzLAorCQkJCSAgICAgICBlbnVtIG5sODAyMTFfaWZ0eXBlIG5sbW9kZSkKK3sKKwlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3NldF9tb2RlX2ltcGwoYnNzLCBubG1vZGUsIE5VTEwpOworfQorCisKK3N0YXRpYyBpbnQgd3BhX2RyaXZlcl9ubDgwMjExX3NldF9tb2RlX2lic3Moc3RydWN0IGk4MDJfYnNzICpic3MsIGludCBmcmVxKQoreworCXN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zIGZyZXFfcGFyYW1zOworCW9zX21lbXNldCgmZnJlcV9wYXJhbXMsIDAsIHNpemVvZihmcmVxX3BhcmFtcykpOworCWZyZXFfcGFyYW1zLmZyZXEgPSBmcmVxOworCXJldHVybiB3cGFfZHJpdmVyX25sODAyMTFfc2V0X21vZGVfaW1wbChic3MsIE5MODAyMTFfSUZUWVBFX0FESE9DLAorCQkJCQkJJmZyZXFfcGFyYW1zKTsKK30KKworCiBzdGF0aWMgaW50IHdwYV9kcml2ZXJfbmw4MDIxMV9nZXRfY2FwYSh2b2lkICpwcml2LAogCQkJCSAgICAgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhKQogewogCXN0cnVjdCBpODAyX2JzcyAqYnNzID0gcHJpdjsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OworCXN0cnVjdCBubF9tc2cgKm1zZzsKKwlpbnQgZGZzX2NhcGFiaWxpdHkgPSAwOworCWludCByZXQgPSAwOworCiAJaWYgKCFkcnYtPmhhc19jYXBhYmlsaXR5KQogCQlyZXR1cm4gLTE7CiAJb3NfbWVtY3B5KGNhcGEsICZkcnYtPmNhcGEsIHNpemVvZigqY2FwYSkpOwpAQCAtODIxNyw3ICs5MjMyLDMxIEBACiAJCWNhcGEtPmZsYWdzICY9IH5XUEFfRFJJVkVSX0ZMQUdTX0RFRElDQVRFRF9QMlBfREVWSUNFOwogCX0KIAotCXJldHVybiAwOworCWlmIChkcnYtPmRmc192ZW5kb3JfY21kX2F2YWlsID09IDEpIHsKKwkJbXNnID0gbmxtc2dfYWxsb2MoKTsKKwkJaWYgKCFtc2cpCisJCQlyZXR1cm4gLUVOT01FTTsKKworCQlubDgwMjExX2NtZChkcnYsIG1zZywgMCwgTkw4MDIxMV9DTURfVkVORE9SKTsKKworCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9JRklOREVYLCBkcnYtPmlmaW5kZXgpOworCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9WRU5ET1JfSUQsIE9VSV9RQ0EpOworCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9WRU5ET1JfU1VCQ01ELAorCQkJICAgIFFDQV9OTDgwMjExX1ZFTkRPUl9TVUJDTURfREZTX0NBUEFCSUxJVFkpOworCisJCXJldCA9IHNlbmRfYW5kX3JlY3ZfbXNncyhkcnYsIG1zZywgZGZzX2luZm9faGFuZGxlciwKKwkJCQkJICZkZnNfY2FwYWJpbGl0eSk7CisJCWlmICghcmV0KSB7CisJCQlpZiAoZGZzX2NhcGFiaWxpdHkpCisJCQkJY2FwYS0+ZmxhZ3MgfD0gV1BBX0RSSVZFUl9GTEFHU19ERlNfT0ZGTE9BRDsKKwkJfQorCX0KKworCXJldHVybiByZXQ7CisKKyBubGFfcHV0X2ZhaWx1cmU6CisJbmxtc2dfZnJlZShtc2cpOworCXJldHVybiAtRU5PQlVGUzsKIH0KIAogCkBAIC04MjI2LDggKzkyNjUsOSBAQAogCXN0cnVjdCBpODAyX2JzcyAqYnNzID0gcHJpdjsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OwogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogb3BlcnN0YXRlICVkLT4lZCAoJXMpIiwKLQkJICAgX19mdW5jX18sIGRydi0+b3BlcnN0YXRlLCBzdGF0ZSwgc3RhdGUgPyAiVVAiIDogIkRPUk1BTlQiKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNldCAlcyBvcGVyc3RhdGUgJWQtPiVkICglcykiLAorCQkgICBic3MtPmlmbmFtZSwgZHJ2LT5vcGVyc3RhdGUsIHN0YXRlLAorCQkgICBzdGF0ZSA/ICJVUCIgOiAiRE9STUFOVCIpOwogCWRydi0+b3BlcnN0YXRlID0gc3RhdGU7CiAJcmV0dXJuIG5ldGxpbmtfc2VuZF9vcGVyX2lmbGEoZHJ2LT5nbG9iYWwtPm5ldGxpbmssIGRydi0+aWZpbmRleCwgLTEsCiAJCQkJICAgICAgc3RhdGUgPyBJRl9PUEVSX1VQIDogSUZfT1BFUl9ET1JNQU5UKTsKQEAgLTgyNDAsNiArOTI4MCwxMiBAQAogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAJc3RydWN0IG5sX21zZyAqbXNnOwogCXN0cnVjdCBubDgwMjExX3N0YV9mbGFnX3VwZGF0ZSB1cGQ7CisJaW50IHJldCA9IC1FTk9CVUZTOworCisJaWYgKCFkcnYtPmFzc29jaWF0ZWQgJiYgaXNfemVyb19ldGhlcl9hZGRyKGRydi0+YnNzaWQpICYmICFhdXRob3JpemVkKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogU2tpcCBzZXRfc3VwcF9wb3J0KHVuYXV0aG9yaXplZCkgd2hpbGUgbm90IGFzc29jaWF0ZWQiKTsKKwkJcmV0dXJuIDA7CisJfQogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBTZXQgc3VwcGxpY2FudCBwb3J0ICVzYXV0aG9yaXplZCBmb3IgIgogCQkgICBNQUNTVFIsIGF1dGhvcml6ZWQgPyAiIiA6ICJ1biIsIE1BQzJTVFIoZHJ2LT5ic3NpZCkpOwpAQCAtODI2MCwxMCArOTMwNiwxNSBAQAogCQl1cGQuc2V0ID0gQklUKE5MODAyMTFfU1RBX0ZMQUdfQVVUSE9SSVpFRCk7CiAJTkxBX1BVVChtc2csIE5MODAyMTFfQVRUUl9TVEFfRkxBR1MyLCBzaXplb2YodXBkKSwgJnVwZCk7CiAKLQlyZXR1cm4gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBOVUxMLCBOVUxMKTsKKwlyZXQgPSBzZW5kX2FuZF9yZWN2X21zZ3MoZHJ2LCBtc2csIE5VTEwsIE5VTEwpOworCW1zZyA9IE5VTEw7CisJaWYgKCFyZXQpCisJCXJldHVybiAwOwogIG5sYV9wdXRfZmFpbHVyZToKIAlubG1zZ19mcmVlKG1zZyk7Ci0JcmV0dXJuIC1FTk9CVUZTOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogRmFpbGVkIHRvIHNldCBTVEEgZmxhZzogJWQgKCVzKSIsCisJCSAgIHJldCwgc3RyZXJyb3IoLXJldCkpOworCXJldHVybiByZXQ7CiB9CiAKIApAQCAtODI3MSwxMiArOTMyMiwxMCBAQAogc3RhdGljIGludCBpODAyX3NldF9mcmVxKHZvaWQgKnByaXYsIHN0cnVjdCBob3N0YXBkX2ZyZXFfcGFyYW1zICpmcmVxKQogewogCXN0cnVjdCBpODAyX2JzcyAqYnNzID0gcHJpdjsKLQlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3NldF9mcmVxKGJzcywgZnJlcSk7CisJcmV0dXJuIG5sODAyMTFfc2V0X2NoYW5uZWwoYnNzLCBmcmVxLCAwKTsKIH0KIAogCi0jaWYgZGVmaW5lZChIT1NUQVBEKSB8fCBkZWZpbmVkKENPTkZJR19BUCkKLQogc3RhdGljIGlubGluZSBpbnQgbWluX2ludChpbnQgYSwgaW50IGIpCiB7CiAJaWYgKGEgPCBiKQpAQCAtODQzMSw4ICs5NDgwLDYgQEAKIAlyZXR1cm4gLUVOT0JVRlM7CiB9CiAKLSNlbmRpZiAvKiBIT1NUQVBEIHx8IENPTkZJR19BUCAqLwotCiAKIHN0YXRpYyBpbnQgZ2V0X3N0YV9oYW5kbGVyKHN0cnVjdCBubF9tc2cgKm1zZywgdm9pZCAqYXJnKQogewpAQCAtODUxMyw4ICs5NTYwLDYgQEAKIH0KIAogCi0jaWYgZGVmaW5lZChIT1NUQVBEKSB8fCBkZWZpbmVkKENPTkZJR19BUCkKLQogc3RhdGljIGludCBpODAyX3NldF90eF9xdWV1ZV9wYXJhbXModm9pZCAqcHJpdiwgaW50IHF1ZXVlLCBpbnQgYWlmcywKIAkJCQkgICAgaW50IGN3X21pbiwgaW50IGN3X21heCwgaW50IGJ1cnN0X3RpbWUpCiB7CkBAIC04NTg1LDYgKzk2MzAsMTAgQEAKIAlpZiAoIW1zZykKIAkJcmV0dXJuIC1FTk9NRU07CiAKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6ICVzWyVkXTogc2V0X3N0YV92bGFuKCIgTUFDU1RSCisJCSAgICIsIGlmbmFtZT0lc1slZF0sIHZsYW5faWQ9JWQpIiwKKwkJICAgYnNzLT5pZm5hbWUsIGlmX25hbWV0b2luZGV4KGJzcy0+aWZuYW1lKSwKKwkJICAgTUFDMlNUUihhZGRyKSwgaWZuYW1lLCBpZl9uYW1ldG9pbmRleChpZm5hbWUpLCB2bGFuX2lkKTsKIAlubDgwMjExX2NtZChkcnYsIG1zZywgMCwgTkw4MDIxMV9DTURfU0VUX1NUQVRJT04pOwogCiAJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfSUZJTkRFWCwKQEAgLTg2NzYsOSArOTcyNSwyOSBAQAogCQkJCQkgICAgMCk7CiB9CiAKLSNlbmRpZiAvKiBIT1NUQVBEIHx8IENPTkZJR19BUCAqLwogCi0jaWZkZWYgSE9TVEFQRAorc3RhdGljIHZvaWQgZHVtcF9pZmlkeChzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydikKK3sKKwljaGFyIGJ1ZlsyMDBdLCAqcG9zLCAqZW5kOworCWludCBpLCByZXM7CisKKwlwb3MgPSBidWY7CisJZW5kID0gcG9zICsgc2l6ZW9mKGJ1Zik7CisKKwlmb3IgKGkgPSAwOyBpIDwgZHJ2LT5udW1faWZfaW5kaWNlczsgaSsrKSB7CisJCWlmICghZHJ2LT5pZl9pbmRpY2VzW2ldKQorCQkJY29udGludWU7CisJCXJlcyA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiICVkIiwgZHJ2LT5pZl9pbmRpY2VzW2ldKTsKKwkJaWYgKHJlcyA8IDAgfHwgcmVzID49IGVuZCAtIHBvcykKKwkJCWJyZWFrOworCQlwb3MgKz0gcmVzOworCX0KKwkqcG9zID0gJ1wwJzsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogaWZfaW5kaWNlc1slZF06JXMiLAorCQkgICBkcnYtPm51bV9pZl9pbmRpY2VzLCBidWYpOworfQorCiAKIHN0YXRpYyB2b2lkIGFkZF9pZmlkeChzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwgaW50IGlmaWR4KQogewpAQCAtODY4Nyw5ICs5NzU2LDE1IEBACiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IEFkZCBvd24gaW50ZXJmYWNlIGlmaW5kZXggJWQiLAogCQkgICBpZmlkeCk7CisJaWYgKGhhdmVfaWZpZHgoZHJ2LCBpZmlkeCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBpZmluZGV4ICVkIGFscmVhZHkgaW4gdGhlIGxpc3QiLAorCQkJICAgaWZpZHgpOworCQlyZXR1cm47CisJfQogCWZvciAoaSA9IDA7IGkgPCBkcnYtPm51bV9pZl9pbmRpY2VzOyBpKyspIHsKIAkJaWYgKGRydi0+aWZfaW5kaWNlc1tpXSA9PSAwKSB7CiAJCQlkcnYtPmlmX2luZGljZXNbaV0gPSBpZmlkeDsKKwkJCWR1bXBfaWZpZHgoZHJ2KTsKIAkJCXJldHVybjsKIAkJfQogCX0KQEAgLTg3MTUsNiArOTc5MCw3IEBACiAJCQkgIHNpemVvZihkcnYtPmRlZmF1bHRfaWZfaW5kaWNlcykpOwogCWRydi0+aWZfaW5kaWNlc1tkcnYtPm51bV9pZl9pbmRpY2VzXSA9IGlmaWR4OwogCWRydi0+bnVtX2lmX2luZGljZXMrKzsKKwlkdW1wX2lmaWR4KGRydik7CiB9CiAKIApAQCAtODcyOCw2ICs5ODA0LDcgQEAKIAkJCWJyZWFrOwogCQl9CiAJfQorCWR1bXBfaWZpZHgoZHJ2KTsKIH0KIAogCkBAIC04NzQ0LDcgKzk4MjEsNyBAQAogCiAKIHN0YXRpYyBpbnQgaTgwMl9zZXRfd2RzX3N0YSh2b2lkICpwcml2LCBjb25zdCB1OCAqYWRkciwgaW50IGFpZCwgaW50IHZhbCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpicmlkZ2VfaWZuYW1lLCBjaGFyICppZm5hbWVfd2RzKQorCQkJICAgIGNvbnN0IGNoYXIgKmJyaWRnZV9pZm5hbWUsIGNoYXIgKmlmbmFtZV93ZHMpCiB7CiAJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OwogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CkBAIC04NzYwLDcgKzk4MzcsOCBAQAogCQlpZiAoIWlmX25hbWV0b2luZGV4KG5hbWUpKSB7CiAJCQlpZiAobmw4MDIxMV9jcmVhdGVfaWZhY2UoZHJ2LCBuYW1lLAogCQkJCQkJIE5MODAyMTFfSUZUWVBFX0FQX1ZMQU4sCi0JCQkJCQkgYnNzLT5hZGRyLCAxLCBOVUxMLCBOVUxMKSA8IDApCisJCQkJCQkgYnNzLT5hZGRyLCAxLCBOVUxMLCBOVUxMLCAwKSA8CisJCQkgICAgMCkKIAkJCQlyZXR1cm4gLTE7CiAJCQlpZiAoYnJpZGdlX2lmbmFtZSAmJgogCQkJICAgIGxpbnV4X2JyX2FkZF9pZihkcnYtPmdsb2JhbC0+aW9jdGxfc29jaywKQEAgLTg3NzgsOCArOTg1Niw4IEBACiAJCQkJCW5hbWUpOwogCiAJCWk4MDJfc2V0X3N0YV92bGFuKHByaXYsIGFkZHIsIGJzcy0+aWZuYW1lLCAwKTsKLQkJcmV0dXJuIHdwYV9kcml2ZXJfbmw4MDIxMV9pZl9yZW1vdmUocHJpdiwgV1BBX0lGX0FQX1ZMQU4sCi0JCQkJCQkgICAgbmFtZSk7CisJCW5sODAyMTFfcmVtb3ZlX2lmYWNlKGRydiwgaWZfbmFtZXRvaW5kZXgobmFtZSkpOworCQlyZXR1cm4gMDsKIAl9CiB9CiAKQEAgLTg3OTUsNyArOTg3Myw4IEBACiAJbGVuID0gcmVjdmZyb20oc29jaywgYnVmLCBzaXplb2YoYnVmKSwgMCwKIAkJICAgICAgIChzdHJ1Y3Qgc29ja2FkZHIgKikmbGxhZGRyLCAmZnJvbWxlbik7CiAJaWYgKGxlbiA8IDApIHsKLQkJcGVycm9yKCJyZWN2Iik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogRUFQT0wgcmVjdiBmYWlsZWQ6ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTg4NjgsMTQgKzk5NDcsMTMgQEAKIAlpbnQgaWZpbmRleCwgYnJfaWZpbmRleDsKIAlpbnQgYnJfYWRkZWQgPSAwOwogCi0JYnNzID0gd3BhX2RyaXZlcl9ubDgwMjExX2luaXQoaGFwZCwgcGFyYW1zLT5pZm5hbWUsCi0JCQkJICAgICAgcGFyYW1zLT5nbG9iYWxfcHJpdik7CisJYnNzID0gd3BhX2RyaXZlcl9ubDgwMjExX2Rydl9pbml0KGhhcGQsIHBhcmFtcy0+aWZuYW1lLAorCQkJCQkgIHBhcmFtcy0+Z2xvYmFsX3ByaXYsIDEsCisJCQkJCSAgcGFyYW1zLT5ic3NpZCk7CiAJaWYgKGJzcyA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAogCWRydiA9IGJzcy0+ZHJ2OwotCWRydi0+bmxtb2RlID0gTkw4MDIxMV9JRlRZUEVfQVA7Ci0JZHJ2LT5lYXBvbF9zb2NrID0gLTE7CiAKIAlpZiAobGludXhfYnJfZ2V0KGJybmFtZSwgcGFyYW1zLT5pZm5hbWUpID09IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBJbnRlcmZhY2UgJXMgaXMgaW4gYnJpZGdlICVzIiwKQEAgLTg4ODYsOCArOTk2NCw2IEBACiAJCWJyX2lmaW5kZXggPSAwOwogCX0KIAotCWRydi0+bnVtX2lmX2luZGljZXMgPSBzaXplb2YoZHJ2LT5kZWZhdWx0X2lmX2luZGljZXMpIC8gc2l6ZW9mKGludCk7Ci0JZHJ2LT5pZl9pbmRpY2VzID0gZHJ2LT5kZWZhdWx0X2lmX2luZGljZXM7CiAJZm9yIChpID0gMDsgaSA8IHBhcmFtcy0+bnVtX2JyaWRnZTsgaSsrKSB7CiAJCWlmIChwYXJhbXMtPmJyaWRnZVtpXSkgewogCQkJaWZpbmRleCA9IGlmX25hbWV0b2luZGV4KHBhcmFtcy0+YnJpZGdlW2ldKTsKQEAgLTg5MDQsMzcgKzk5ODAsMjAgQEAKIAkvKiBzdGFydCBsaXN0ZW5pbmcgZm9yIEVBUE9MIG9uIHRoZSBkZWZhdWx0IEFQIGludGVyZmFjZSAqLwogCWFkZF9pZmlkeChkcnYsIGRydi0+aWZpbmRleCk7CiAKLQlpZiAobGludXhfc2V0X2lmYWNlX2ZsYWdzKGRydi0+Z2xvYmFsLT5pb2N0bF9zb2NrLCBic3MtPmlmbmFtZSwgMCkpCi0JCWdvdG8gZmFpbGVkOwotCi0JaWYgKHBhcmFtcy0+YnNzaWQpIHsKLQkJaWYgKGxpbnV4X3NldF9pZmh3YWRkcihkcnYtPmdsb2JhbC0+aW9jdGxfc29jaywgYnNzLT5pZm5hbWUsCi0JCQkJICAgICAgIHBhcmFtcy0+YnNzaWQpKQotCQkJZ290byBmYWlsZWQ7Ci0JfQotCi0JaWYgKHdwYV9kcml2ZXJfbmw4MDIxMV9zZXRfbW9kZShic3MsIGRydi0+bmxtb2RlKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIm5sODAyMTE6IEZhaWxlZCB0byBzZXQgaW50ZXJmYWNlICVzICIKLQkJCSAgICJpbnRvIEFQIG1vZGUiLCBic3MtPmlmbmFtZSk7Ci0JCWdvdG8gZmFpbGVkOwotCX0KLQogCWlmIChwYXJhbXMtPm51bV9icmlkZ2UgJiYgcGFyYW1zLT5icmlkZ2VbMF0gJiYKIAkgICAgaTgwMl9jaGVja19icmlkZ2UoZHJ2LCBic3MsIHBhcmFtcy0+YnJpZGdlWzBdLCBwYXJhbXMtPmlmbmFtZSkgPCAwKQogCQlnb3RvIGZhaWxlZDsKIAotCWlmIChsaW51eF9zZXRfaWZhY2VfZmxhZ3MoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssIGJzcy0+aWZuYW1lLCAxKSkKLQkJZ290byBmYWlsZWQ7Ci0KIAlkcnYtPmVhcG9sX3NvY2sgPSBzb2NrZXQoUEZfUEFDS0VULCBTT0NLX0RHUkFNLCBodG9ucyhFVEhfUF9QQUUpKTsKIAlpZiAoZHJ2LT5lYXBvbF9zb2NrIDwgMCkgewotCQlwZXJyb3IoInNvY2tldChQRl9QQUNLRVQsIFNPQ0tfREdSQU0sIEVUSF9QX1BBRSkiKTsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJubDgwMjExOiBzb2NrZXQoUEZfUEFDS0VULCBTT0NLX0RHUkFNLCBFVEhfUF9QQUUpIGZhaWxlZDogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJZ290byBmYWlsZWQ7CiAJfQogCiAJaWYgKGVsb29wX3JlZ2lzdGVyX3JlYWRfc29jayhkcnYtPmVhcG9sX3NvY2ssIGhhbmRsZV9lYXBvbCwgZHJ2LCBOVUxMKSkKIAl7Ci0JCXByaW50ZigiQ291bGQgbm90IHJlZ2lzdGVyIHJlYWQgc29ja2V0IGZvciBlYXBvbFxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJubDgwMjExOiBDb3VsZCBub3QgcmVnaXN0ZXIgcmVhZCBzb2NrZXQgZm9yIGVhcG9sIik7CiAJCWdvdG8gZmFpbGVkOwogCX0KIApAQCAtODk1OCw4ICsxMDAxNyw2IEBACiAJd3BhX2RyaXZlcl9ubDgwMjExX2RlaW5pdChic3MpOwogfQogCi0jZW5kaWYgLyogSE9TVEFQRCAqLwotCiAKIHN0YXRpYyBlbnVtIG5sODAyMTFfaWZ0eXBlIHdwYV9kcml2ZXJfbmw4MDIxMV9pZl90eXBlKAogCWVudW0gd3BhX2RyaXZlcl9pZl90eXBlIHR5cGUpCkBAIC04OTkwLDcgKzEwMDQ3LDcgQEAKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydjsKIAlkbF9saXN0X2Zvcl9lYWNoKGRydiwgJmdsb2JhbC0+aW50ZXJmYWNlcywKIAkJCSBzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEsIGxpc3QpIHsKLQkJaWYgKG9zX21lbWNtcChhZGRyLCBkcnYtPmZpcnN0X2Jzcy5hZGRyLCBFVEhfQUxFTikgPT0gMCkKKwkJaWYgKG9zX21lbWNtcChhZGRyLCBkcnYtPmZpcnN0X2Jzcy0+YWRkciwgRVRIX0FMRU4pID09IDApCiAJCQlyZXR1cm4gMTsKIAl9CiAJcmV0dXJuIDA7CkBAIC05MDA1LDkgKzEwMDYyLDkgQEAKIAlpZiAoIWRydi0+Z2xvYmFsKQogCQlyZXR1cm4gLTE7CiAKLQlvc19tZW1jcHkobmV3X2FkZHIsIGRydi0+Zmlyc3RfYnNzLmFkZHIsIEVUSF9BTEVOKTsKKwlvc19tZW1jcHkobmV3X2FkZHIsIGRydi0+Zmlyc3RfYnNzLT5hZGRyLCBFVEhfQUxFTik7CiAJZm9yIChpZHggPSAwOyBpZHggPCA2NDsgaWR4KyspIHsKLQkJbmV3X2FkZHJbMF0gPSBkcnYtPmZpcnN0X2Jzcy5hZGRyWzBdIHwgMHgwMjsKKwkJbmV3X2FkZHJbMF0gPSBkcnYtPmZpcnN0X2Jzcy0+YWRkclswXSB8IDB4MDI7CiAJCW5ld19hZGRyWzBdIF49IGlkeCA8PCAyOwogCQlpZiAoIW5sODAyMTFfYWRkcl9pbl91c2UoZHJ2LT5nbG9iYWwsIG5ld19hZGRyKSkKIAkJCWJyZWFrOwpAQCAtOTA1NSwyMSArMTAxMTIsMTMgQEAKIAkJCQkgICAgIGNvbnN0IGNoYXIgKmlmbmFtZSwgY29uc3QgdTggKmFkZHIsCiAJCQkJICAgICB2b2lkICpic3NfY3R4LCB2b2lkICoqZHJ2X3ByaXYsCiAJCQkJICAgICBjaGFyICpmb3JjZV9pZm5hbWUsIHU4ICppZl9hZGRyLAotCQkJCSAgICAgY29uc3QgY2hhciAqYnJpZGdlKQorCQkJCSAgICAgY29uc3QgY2hhciAqYnJpZGdlLCBpbnQgdXNlX2V4aXN0aW5nKQogewogCWVudW0gbmw4MDIxMV9pZnR5cGUgbmxtb2RlOwogCXN0cnVjdCBpODAyX2JzcyAqYnNzID0gcHJpdjsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OwogCWludCBpZmlkeDsKLSNpZmRlZiBIT1NUQVBECi0Jc3RydWN0IGk4MDJfYnNzICpuZXdfYnNzID0gTlVMTDsKLQotCWlmICh0eXBlID09IFdQQV9JRl9BUF9CU1MpIHsKLQkJbmV3X2JzcyA9IG9zX3phbGxvYyhzaXplb2YoKm5ld19ic3MpKTsKLQkJaWYgKG5ld19ic3MgPT0gTlVMTCkKLQkJCXJldHVybiAtMTsKLQl9Ci0jZW5kaWYgLyogSE9TVEFQRCAqLworCWludCBhZGRlZCA9IDE7CiAKIAlpZiAoYWRkcikKIAkJb3NfbWVtY3B5KGlmX2FkZHIsIGFkZHIsIEVUSF9BTEVOKTsKQEAgLTkwODAsNyArMTAxMjksNyBAQAogCQlvc19tZW1zZXQoJnAycGRldl9pbmZvLCAwLCBzaXplb2YocDJwZGV2X2luZm8pKTsKIAkJaWZpZHggPSBubDgwMjExX2NyZWF0ZV9pZmFjZShkcnYsIGlmbmFtZSwgbmxtb2RlLCBhZGRyLAogCQkJCQkgICAgIDAsIG5sODAyMTFfd2Rldl9oYW5kbGVyLAotCQkJCQkgICAgICZwMnBkZXZfaW5mbyk7CisJCQkJCSAgICAgJnAycGRldl9pbmZvLCB1c2VfZXhpc3RpbmcpOwogCQlpZiAoIXAycGRldl9pbmZvLndkZXZfaWRfc2V0IHx8IGlmaWR4ICE9IDApIHsKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogRmFpbGVkIHRvIGNyZWF0ZSBhIFAyUCBEZXZpY2UgaW50ZXJmYWNlICVzIiwKIAkJCQkgICBpZm5hbWUpOwpAQCAtOTA5NiwxMSArMTAxNDUsMTEgQEAKIAkJCSAgIChsb25nIGxvbmcgdW5zaWduZWQgaW50KSBwMnBkZXZfaW5mby53ZGV2X2lkKTsKIAl9IGVsc2UgewogCQlpZmlkeCA9IG5sODAyMTFfY3JlYXRlX2lmYWNlKGRydiwgaWZuYW1lLCBubG1vZGUsIGFkZHIsCi0JCQkJCSAgICAgMCwgTlVMTCwgTlVMTCk7Ci0JCWlmIChpZmlkeCA8IDApIHsKLSNpZmRlZiBIT1NUQVBECi0JCQlvc19mcmVlKG5ld19ic3MpOwotI2VuZGlmIC8qIEhPU1RBUEQgKi8KKwkJCQkJICAgICAwLCBOVUxMLCBOVUxMLCB1c2VfZXhpc3RpbmcpOworCQlpZiAodXNlX2V4aXN0aW5nICYmIGlmaWR4ID09IC1FTkZJTEUpIHsKKwkJCWFkZGVkID0gMDsKKwkJCWlmaWR4ID0gaWZfbmFtZXRvaW5kZXgoaWZuYW1lKTsKKwkJfSBlbHNlIGlmIChpZmlkeCA8IDApIHsKIAkJCXJldHVybiAtMTsKIAkJfQogCX0KQEAgLTkxMTAsNyArMTAxNTksOCBAQAogCQkJb3NfbWVtY3B5KGlmX2FkZHIsIGJzcy0+YWRkciwgRVRIX0FMRU4pOwogCQllbHNlIGlmIChsaW51eF9nZXRfaWZod2FkZHIoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssCiAJCQkJCSAgICBic3MtPmlmbmFtZSwgaWZfYWRkcikgPCAwKSB7Ci0JCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKKwkJCWlmIChhZGRlZCkKKwkJCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKIAkJCXJldHVybiAtMTsKIAkJfQogCX0KQEAgLTkxMjQsMTkgKzEwMTc0LDIyIEBACiAKIAkJaWYgKGxpbnV4X2dldF9pZmh3YWRkcihkcnYtPmdsb2JhbC0+aW9jdGxfc29jaywgaWZuYW1lLAogCQkJCSAgICAgICBuZXdfYWRkcikgPCAwKSB7Ci0JCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKKwkJCWlmIChhZGRlZCkKKwkJCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKIAkJCXJldHVybiAtMTsKIAkJfQogCQlpZiAobmw4MDIxMV9hZGRyX2luX3VzZShkcnYtPmdsb2JhbCwgbmV3X2FkZHIpKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IEFsbG9jYXRlIG5ldyBhZGRyZXNzICIKIAkJCQkgICAiZm9yIFAyUCBncm91cCBpbnRlcmZhY2UiKTsKIAkJCWlmIChubDgwMjExX3AycF9pbnRlcmZhY2VfYWRkcihkcnYsIG5ld19hZGRyKSA8IDApIHsKLQkJCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKKwkJCQlpZiAoYWRkZWQpCisJCQkJCW5sODAyMTFfcmVtb3ZlX2lmYWNlKGRydiwgaWZpZHgpOwogCQkJCXJldHVybiAtMTsKIAkJCX0KIAkJCWlmIChsaW51eF9zZXRfaWZod2FkZHIoZHJ2LT5nbG9iYWwtPmlvY3RsX3NvY2ssIGlmbmFtZSwKIAkJCQkJICAgICAgIG5ld19hZGRyKSA8IDApIHsKLQkJCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKKwkJCQlpZiAoYWRkZWQpCisJCQkJCW5sODAyMTFfcmVtb3ZlX2lmYWNlKGRydiwgaWZpZHgpOwogCQkJCXJldHVybiAtMTsKIAkJCX0KIAkJfQpAQCAtOTE0NCwyMCArMTAxOTcsMjkgQEAKIAl9CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCi0jaWZkZWYgSE9TVEFQRAotCWlmIChicmlkZ2UgJiYKLQkgICAgaTgwMl9jaGVja19icmlkZ2UoZHJ2LCBuZXdfYnNzLCBicmlkZ2UsIGlmbmFtZSkgPCAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogRmFpbGVkIHRvIGFkZCB0aGUgbmV3ICIKLQkJCSAgICJpbnRlcmZhY2UgJXMgdG8gYSBicmlkZ2UgJXMiLCBpZm5hbWUsIGJyaWRnZSk7Ci0JCW5sODAyMTFfcmVtb3ZlX2lmYWNlKGRydiwgaWZpZHgpOwotCQlvc19mcmVlKG5ld19ic3MpOwotCQlyZXR1cm4gLTE7Ci0JfQotCiAJaWYgKHR5cGUgPT0gV1BBX0lGX0FQX0JTUykgeworCQlzdHJ1Y3QgaTgwMl9ic3MgKm5ld19ic3MgPSBvc196YWxsb2Moc2l6ZW9mKCpuZXdfYnNzKSk7CisJCWlmIChuZXdfYnNzID09IE5VTEwpIHsKKwkJCWlmIChhZGRlZCkKKwkJCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKKwkJCXJldHVybiAtMTsKKwkJfQorCisJCWlmIChicmlkZ2UgJiYKKwkJICAgIGk4MDJfY2hlY2tfYnJpZGdlKGRydiwgbmV3X2JzcywgYnJpZGdlLCBpZm5hbWUpIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJubDgwMjExOiBGYWlsZWQgdG8gYWRkIHRoZSBuZXcgIgorCQkJCSAgICJpbnRlcmZhY2UgJXMgdG8gYSBicmlkZ2UgJXMiLAorCQkJCSAgIGlmbmFtZSwgYnJpZGdlKTsKKwkJCWlmIChhZGRlZCkKKwkJCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKKwkJCW9zX2ZyZWUobmV3X2Jzcyk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwogCQlpZiAobGludXhfc2V0X2lmYWNlX2ZsYWdzKGRydi0+Z2xvYmFsLT5pb2N0bF9zb2NrLCBpZm5hbWUsIDEpKQogCQl7Ci0JCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKKwkJCWlmIChhZGRlZCkKKwkJCQlubDgwMjExX3JlbW92ZV9pZmFjZShkcnYsIGlmaWR4KTsKIAkJCW9zX2ZyZWUobmV3X2Jzcyk7CiAJCQlyZXR1cm4gLTE7CiAJCX0KQEAgLTkxNjUsMTAgKzEwMjI3LDExIEBACiAJCW9zX21lbWNweShuZXdfYnNzLT5hZGRyLCBpZl9hZGRyLCBFVEhfQUxFTik7CiAJCW5ld19ic3MtPmlmaW5kZXggPSBpZmlkeDsKIAkJbmV3X2Jzcy0+ZHJ2ID0gZHJ2OwotCQluZXdfYnNzLT5uZXh0ID0gZHJ2LT5maXJzdF9ic3MubmV4dDsKLQkJbmV3X2Jzcy0+ZnJlcSA9IGRydi0+Zmlyc3RfYnNzLmZyZXE7CisJCW5ld19ic3MtPm5leHQgPSBkcnYtPmZpcnN0X2Jzcy0+bmV4dDsKKwkJbmV3X2Jzcy0+ZnJlcSA9IGRydi0+Zmlyc3RfYnNzLT5mcmVxOwogCQluZXdfYnNzLT5jdHggPSBic3NfY3R4OwotCQlkcnYtPmZpcnN0X2Jzcy5uZXh0ID0gbmV3X2JzczsKKwkJbmV3X2Jzcy0+YWRkZWRfaWYgPSBhZGRlZDsKKwkJZHJ2LT5maXJzdF9ic3MtPm5leHQgPSBuZXdfYnNzOwogCQlpZiAoZHJ2X3ByaXYpCiAJCQkqZHJ2X3ByaXYgPSBuZXdfYnNzOwogCQlubDgwMjExX2luaXRfYnNzKG5ld19ic3MpOwpAQCAtOTE3NywxMSArMTAyNDAsMjEgQEAKIAkJaWYgKG5sODAyMTFfc2V0dXBfYXAobmV3X2JzcykpCiAJCQlyZXR1cm4gLTE7CiAJfQotI2VuZGlmIC8qIEhPU1RBUEQgKi8KIAogCWlmIChkcnYtPmdsb2JhbCkKIAkJZHJ2LT5nbG9iYWwtPmlmX2FkZF9pZmluZGV4ID0gaWZpZHg7CiAKKwkvKgorCSAqIFNvbWUgdmlydHVhbCBpbnRlcmZhY2VzIG5lZWQgdG8gcHJvY2VzcyBFQVBPTCBwYWNrZXRzIGFuZCBldmVudHMgb24KKwkgKiB0aGUgcGFyZW50IGludGVyZmFjZS4gVGhpcyBpcyB1c2VkIG1haW5seSB3aXRoIGhvc3RhcGQuCisJICovCisJaWYgKGlmaWR4ID4gMCAmJgorCSAgICAoZHJ2LT5ob3N0YXBkIHx8CisJICAgICBubG1vZGUgPT0gTkw4MDIxMV9JRlRZUEVfQVBfVkxBTiB8fAorCSAgICAgbmxtb2RlID09IE5MODAyMTFfSUZUWVBFX1dEUyB8fAorCSAgICAgbmxtb2RlID09IE5MODAyMTFfSUZUWVBFX01PTklUT1IpKQorCQlhZGRfaWZpZHgoZHJ2LCBpZmlkeCk7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtOTE5MywxNCArMTAyNjYsMTcgQEAKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OwogCWludCBpZmluZGV4ID0gaWZfbmFtZXRvaW5kZXgoaWZuYW1lKTsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogJXModHlwZT0lZCBpZm5hbWU9JXMpIGlmaW5kZXg9JWQiLAotCQkgICBfX2Z1bmNfXywgdHlwZSwgaWZuYW1lLCBpZmluZGV4KTsKLQlpZiAoaWZpbmRleCA8PSAwKQotCQlyZXR1cm4gLTE7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiAlcyh0eXBlPSVkIGlmbmFtZT0lcykgaWZpbmRleD0lZCBhZGRlZF9pZj0lZCIsCisJCSAgIF9fZnVuY19fLCB0eXBlLCBpZm5hbWUsIGlmaW5kZXgsIGJzcy0+YWRkZWRfaWYpOworCWlmIChpZmluZGV4ID4gMCAmJiAoYnNzLT5hZGRlZF9pZiB8fCBic3MtPmlmaW5kZXggIT0gaWZpbmRleCkpCisJCW5sODAyMTFfcmVtb3ZlX2lmYWNlKGRydiwgaWZpbmRleCk7CisJZWxzZSBpZiAoaWZpbmRleCA+IDAgJiYgIWJzcy0+YWRkZWRfaWYpIHsKKwkJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYyOworCQlkbF9saXN0X2Zvcl9lYWNoKGRydjIsICZkcnYtPmdsb2JhbC0+aW50ZXJmYWNlcywKKwkJCQkgc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhLCBsaXN0KQorCQkJZGVsX2lmaWR4KGRydjIsIGlmaW5kZXgpOworCX0KIAotCW5sODAyMTFfcmVtb3ZlX2lmYWNlKGRydiwgaWZpbmRleCk7Ci0KLSNpZmRlZiBIT1NUQVBECiAJaWYgKHR5cGUgIT0gV1BBX0lGX0FQX0JTUykKIAkJcmV0dXJuIDA7CiAKQEAgLTkyMTgsMTUgKzEwMjk0LDE4IEBACiAJCQkJICAgYnNzLT5icm5hbWUsIHN0cmVycm9yKGVycm5vKSk7CiAJfQogCi0JaWYgKGJzcyAhPSAmZHJ2LT5maXJzdF9ic3MpIHsKKwlpZiAoYnNzICE9IGRydi0+Zmlyc3RfYnNzKSB7CiAJCXN0cnVjdCBpODAyX2JzcyAqdGJzczsKIAotCQlmb3IgKHRic3MgPSAmZHJ2LT5maXJzdF9ic3M7IHRic3M7IHRic3MgPSB0YnNzLT5uZXh0KSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogTm90IHRoZSBmaXJzdCBCU1MgLSByZW1vdmUgaXQiKTsKKwkJZm9yICh0YnNzID0gZHJ2LT5maXJzdF9ic3M7IHRic3M7IHRic3MgPSB0YnNzLT5uZXh0KSB7CiAJCQlpZiAodGJzcy0+bmV4dCA9PSBic3MpIHsKIAkJCQl0YnNzLT5uZXh0ID0gYnNzLT5uZXh0OwogCQkJCS8qIFVuc3Vic2NyaWJlIG1hbmFnZW1lbnQgZnJhbWVzICovCiAJCQkJbmw4MDIxMV90ZWFyZG93bl9hcChic3MpOwogCQkJCW5sODAyMTFfZGVzdHJveV9ic3MoYnNzKTsKKwkJCQlpZiAoIWJzcy0+YWRkZWRfaWYpCisJCQkJCWk4MDJfc2V0X2lmYWNlX2ZsYWdzKGJzcywgMCk7CiAJCQkJb3NfZnJlZShic3MpOwogCQkJCWJzcyA9IE5VTEw7CiAJCQkJYnJlYWs7CkBAIC05MjM1LDggKzEwMzE0LDIyIEBACiAJCWlmIChic3MpCiAJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAibmw4MDIxMTogJXMgLSBjb3VsZCBub3QgZmluZCAiCiAJCQkJICAgIkJTUyAlcCBpbiB0aGUgbGlzdCIsIF9fZnVuY19fLCBic3MpOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogRmlyc3QgQlNTIC0gcmVhc3NpZ24gY29udGV4dCIpOworCQlubDgwMjExX3RlYXJkb3duX2FwKGJzcyk7CisJCWlmICghYnNzLT5hZGRlZF9pZiAmJiAhZHJ2LT5maXJzdF9ic3MtPm5leHQpCisJCQl3cGFfZHJpdmVyX25sODAyMTFfZGVsX2JlYWNvbihkcnYpOworCQlubDgwMjExX2Rlc3Ryb3lfYnNzKGJzcyk7CisJCWlmICghYnNzLT5hZGRlZF9pZikKKwkJCWk4MDJfc2V0X2lmYWNlX2ZsYWdzKGJzcywgMCk7CisJCWlmIChkcnYtPmZpcnN0X2Jzcy0+bmV4dCkgeworCQkJZHJ2LT5maXJzdF9ic3MgPSBkcnYtPmZpcnN0X2Jzcy0+bmV4dDsKKwkJCWRydi0+Y3R4ID0gZHJ2LT5maXJzdF9ic3MtPmN0eDsKKwkJCW9zX2ZyZWUoYnNzKTsKKwkJfSBlbHNlIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogTm8gc2Vjb25kIEJTUyB0byByZWFzc2lnbiBjb250ZXh0IHRvIik7CisJCX0KIAl9Ci0jZW5kaWYgLyogSE9TVEFQRCAqLwogCiAJcmV0dXJuIDA7CiB9CkBAIC05MjgyLDcgKzEwMzc1LDggQEAKIAkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfV0lQSFlfRlJFUSwgZnJlcSk7CiAJaWYgKHdhaXQpCiAJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0RVUkFUSU9OLCB3YWl0KTsKLQlpZiAob2ZmY2hhbm9rICYmIChkcnYtPmNhcGEuZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX09GRkNIQU5ORUxfVFgpKQorCWlmIChvZmZjaGFub2sgJiYgKChkcnYtPmNhcGEuZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX09GRkNIQU5ORUxfVFgpIHx8CisJCQkgIGRydi0+dGVzdF91c2Vfcm9jX3R4KSkKIAkJTkxBX1BVVF9GTEFHKG1zZywgTkw4MDIxMV9BVFRSX09GRkNIQU5ORUxfVFhfT0spOwogCWlmIChub19jY2spCiAJCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfQVRUUl9UWF9OT19DQ0tfUkFURSk7CkBAIC05MzQxLDcgKzEwNDM1LDEwIEBACiAJb3NfbWVtY3B5KGhkci0+YWRkcjIsIHNyYywgRVRIX0FMRU4pOwogCW9zX21lbWNweShoZHItPmFkZHIzLCBic3NpZCwgRVRIX0FMRU4pOwogCi0JaWYgKGlzX2FwX2ludGVyZmFjZShkcnYtPm5sbW9kZSkpCisJaWYgKGlzX2FwX2ludGVyZmFjZShkcnYtPm5sbW9kZSkgJiYKKwkgICAgKCEoZHJ2LT5jYXBhLmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19PRkZDSEFOTkVMX1RYKSB8fAorCSAgICAgKGludCkgZnJlcSA9PSBic3MtPmZyZXEgfHwgZHJ2LT5kZXZpY2VfYXBfc21lIHx8CisJICAgICAhZHJ2LT51c2VfbW9uaXRvcikpCiAJCXJldCA9IHdwYV9kcml2ZXJfbmw4MDIxMV9zZW5kX21sbWUoYnNzLCBidWYsIDI0ICsgZGF0YV9sZW4sCiAJCQkJCQkgICAwLCBmcmVxLCBub19jY2ssIDEsCiAJCQkJCQkgICB3YWl0X3RpbWUpOwpAQCAtOTQ3Myw3ICsxMDU3MCw4IEBACiAKIAlpZiAoIXJlcG9ydCkgewogCQlpZiAoYnNzLT5ubF9wcmVxICYmIGRydi0+ZGV2aWNlX2FwX3NtZSAmJgotCQkgICAgaXNfYXBfaW50ZXJmYWNlKGRydi0+bmxtb2RlKSkgeworCQkgICAgaXNfYXBfaW50ZXJmYWNlKGRydi0+bmxtb2RlKSAmJiAhYnNzLT5pbl9kZWluaXQgJiYKKwkJICAgICFic3MtPnN0YXRpY19hcCkgewogCQkJLyoKIAkJCSAqIERvIG5vdCBkaXNhYmxlIFByb2JlIFJlcXVlc3QgcmVwb3J0aW5nIHRoYXQgd2FzCiAJCQkgKiBlbmFibGVkIGluIG5sODAyMTFfc2V0dXBfYXAoKS4KQEAgLTk0ODQsOSArMTA1ODIsNyBAQAogCQl9IGVsc2UgaWYgKGJzcy0+bmxfcHJlcSkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBEaXNhYmxlIFByb2JlIFJlcXVlc3QgIgogCQkJCSAgICJyZXBvcnRpbmcgbmxfcHJlcT0lcCIsIGJzcy0+bmxfcHJlcSk7Ci0JCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jaygKLQkJCQlubF9zb2NrZXRfZ2V0X2ZkKGJzcy0+bmxfcHJlcSkpOwotCQkJbmxfZGVzdHJveV9oYW5kbGVzKCZic3MtPm5sX3ByZXEpOworCQkJbmw4MDIxMV9kZXN0cm95X2Vsb29wX2hhbmRsZSgmYnNzLT5ubF9wcmVxKTsKIAkJfQogCQlyZXR1cm4gMDsKIAl9CkBAIC05NTA5LDkgKzEwNjA1LDkgQEAKIAkJCQkgICBOVUxMLCAwKSA8IDApCiAJCWdvdG8gb3V0X2VycjsKIAotCWVsb29wX3JlZ2lzdGVyX3JlYWRfc29jayhubF9zb2NrZXRfZ2V0X2ZkKGJzcy0+bmxfcHJlcSksCi0JCQkJIHdwYV9kcml2ZXJfbmw4MDIxMV9ldmVudF9yZWNlaXZlLCBic3MtPm5sX2NiLAotCQkJCSBic3MtPm5sX3ByZXEpOworCW5sODAyMTFfcmVnaXN0ZXJfZWxvb3BfcmVhZCgmYnNzLT5ubF9wcmVxLAorCQkJCSAgICB3cGFfZHJpdmVyX25sODAyMTFfZXZlbnRfcmVjZWl2ZSwKKwkJCQkgICAgYnNzLT5ubF9jYik7CiAKIAlyZXR1cm4gMDsKIApAQCAtOTcxMiwyNyArMTA4MDgsNiBAQAogfQogCiAKLS8qIENvbnZlcnRzIG5sODAyMTFfY2hhbl93aWR0aCB0byBhIGNvbW1vbiBmb3JtYXQgKi8KLXN0YXRpYyBlbnVtIGNoYW5fd2lkdGggY29udmVydDJ3aWR0aChpbnQgd2lkdGgpCi17Ci0Jc3dpdGNoICh3aWR0aCkgewotCWNhc2UgTkw4MDIxMV9DSEFOX1dJRFRIXzIwX05PSFQ6Ci0JCXJldHVybiBDSEFOX1dJRFRIXzIwX05PSFQ7Ci0JY2FzZSBOTDgwMjExX0NIQU5fV0lEVEhfMjA6Ci0JCXJldHVybiBDSEFOX1dJRFRIXzIwOwotCWNhc2UgTkw4MDIxMV9DSEFOX1dJRFRIXzQwOgotCQlyZXR1cm4gQ0hBTl9XSURUSF80MDsKLQljYXNlIE5MODAyMTFfQ0hBTl9XSURUSF84MDoKLQkJcmV0dXJuIENIQU5fV0lEVEhfODA7Ci0JY2FzZSBOTDgwMjExX0NIQU5fV0lEVEhfODBQODA6Ci0JCXJldHVybiBDSEFOX1dJRFRIXzgwUDgwOwotCWNhc2UgTkw4MDIxMV9DSEFOX1dJRFRIXzE2MDoKLQkJcmV0dXJuIENIQU5fV0lEVEhfMTYwOwotCX0KLQlyZXR1cm4gQ0hBTl9XSURUSF9VTktOT1dOOwotfQotCi0KIHN0YXRpYyBpbnQgZ2V0X2NoYW5uZWxfd2lkdGgoc3RydWN0IG5sX21zZyAqbXNnLCB2b2lkICphcmcpCiB7CiAJc3RydWN0IG5sYXR0ciAqdGJbTkw4MDIxMV9BVFRSX01BWCArIDFdOwpAQCAtOTgxOCwxOSArMTA4OTMsMTUgQEAKIAkJCSBzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEsIGxpc3QpIHsKIAkJaWYgKGRydiA9PSBkcml2ZXIgfHwKIAkJICAgIG9zX3N0cmNtcChkcnYtPnBoeW5hbWUsIGRyaXZlci0+cGh5bmFtZSkgIT0gMCB8fAotI2lmZGVmIEFORFJPSURfUDJQCi0JCSAgICAoIWRyaXZlci0+YXNzb2NpYXRlZCAmJiAhaXNfYXBfaW50ZXJmYWNlKGRyaXZlci0+bmxtb2RlKSkpCi0jZWxzZQogCQkgICAgIWRyaXZlci0+YXNzb2NpYXRlZCkKLSNlbmRpZgogCQkJY29udGludWU7CiAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBGb3VuZCBhIG1hdGNoIGZvciBQSFkgJXMgLSAlcyAiCiAJCQkgICBNQUNTVFIsCi0JCQkgICBkcml2ZXItPnBoeW5hbWUsIGRyaXZlci0+Zmlyc3RfYnNzLmlmbmFtZSwKLQkJCSAgIE1BQzJTVFIoZHJpdmVyLT5maXJzdF9ic3MuYWRkcikpOworCQkJICAgZHJpdmVyLT5waHluYW1lLCBkcml2ZXItPmZpcnN0X2Jzcy0+aWZuYW1lLAorCQkJICAgTUFDMlNUUihkcml2ZXItPmZpcnN0X2Jzcy0+YWRkcikpOwogCQlpZiAoaXNfYXBfaW50ZXJmYWNlKGRyaXZlci0+bmxtb2RlKSkKLQkJCWZyZXEgPSBkcml2ZXItPmZpcnN0X2Jzcy5mcmVxOworCQkJZnJlcSA9IGRyaXZlci0+Zmlyc3RfYnNzLT5mcmVxOwogCQllbHNlCiAJCQlmcmVxID0gbmw4MDIxMV9nZXRfYXNzb2NfZnJlcShkcml2ZXIpOwogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNoYXJlZCBmcmVxIGZvciBQSFkgJXM6ICVkIiwKQEAgLTk4NzYsMTcgKzEwOTQ3LDI2IEBACiAJCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAJCWRydi0+YWxsb3dfcDJwX2RldmljZSA9IDE7CiAJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAotI2lmZGVmIEFORFJPSURfUDJQCi0JaWYob3Nfc3Ryc3RyKHBhcmFtLCAidXNlX211bHRpX2NoYW5fY29uY3VycmVudD0xIikpIHsKKwlpZiAob3Nfc3Ryc3RyKHBhcmFtLCAidXNlX21vbml0b3I9MSIpKSB7CiAJCXN0cnVjdCBpODAyX2JzcyAqYnNzID0gcHJpdjsKIAkJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBVc2UgTXVsdGkgY2hhbm5lbCAiCi0JCQkgICAiY29uY3VycmVuY3kiKTsKLQkJZHJ2LT5jYXBhLm51bV9tdWx0aWNoYW5fY29uY3VycmVudCA9IDI7CisJCWRydi0+dXNlX21vbml0b3IgPSAxOwogCX0KLSNlbmRpZgotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCWlmIChvc19zdHJzdHIocGFyYW0sICJmb3JjZV9jb25uZWN0X2NtZD0xIikpIHsKKwkJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OworCQlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OworCQlkcnYtPmNhcGEuZmxhZ3MgJj0gfldQQV9EUklWRVJfRkxBR1NfU01FOworCX0KKworCWlmIChvc19zdHJzdHIocGFyYW0sICJub19vZmZjaGFubmVsX3R4PTEiKSkgeworCQlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CisJCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CisJCWRydi0+Y2FwYS5mbGFncyAmPSB+V1BBX0RSSVZFUl9GTEFHU19PRkZDSEFOTkVMX1RYOworCQlkcnYtPnRlc3RfdXNlX3JvY190eCA9IDE7CisJfQogCiAJcmV0dXJuIDA7CiB9CkBAIC05OTIyLDcgKzExMDAyLDggQEAKIAogCWdsb2JhbC0+aW9jdGxfc29jayA9IHNvY2tldChQRl9JTkVULCBTT0NLX0RHUkFNLCAwKTsKIAlpZiAoZ2xvYmFsLT5pb2N0bF9zb2NrIDwgMCkgewotCQlwZXJyb3IoInNvY2tldChQRl9JTkVULFNPQ0tfREdSQU0pIik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAibmw4MDIxMTogc29ja2V0KFBGX0lORVQsU09DS19ER1JBTSkgZmFpbGVkOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQlnb3RvIGVycjsKIAl9CiAKQEAgLTk5NTAsMTEgKzExMDMxLDggQEAKIAogCW5sX2Rlc3Ryb3lfaGFuZGxlcygmZ2xvYmFsLT5ubCk7CiAKLQlpZiAoZ2xvYmFsLT5ubF9ldmVudCkgewotCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jaygKLQkJCW5sX3NvY2tldF9nZXRfZmQoZ2xvYmFsLT5ubF9ldmVudCkpOwotCQlubF9kZXN0cm95X2hhbmRsZXMoJmdsb2JhbC0+bmxfZXZlbnQpOwotCX0KKwlpZiAoZ2xvYmFsLT5ubF9ldmVudCkKKwkJbmw4MDIxMV9kZXN0cm95X2Vsb29wX2hhbmRsZSgmZ2xvYmFsLT5ubF9ldmVudCk7CiAKIAlubF9jYl9wdXQoZ2xvYmFsLT5ubF9jYik7CiAKQEAgLTEwMTIyLDYgKzExMjAwLDkgQEAKIAlubGFfcGFyc2UodGIsIE5MODAyMTFfQVRUUl9NQVgsIGdlbmxtc2dfYXR0cmRhdGEoZ25saCwgMCksCiAJCSAgZ2VubG1zZ19hdHRybGVuKGdubGgsIDApLCBOVUxMKTsKIAorCWlmICghdGJbTkw4MDIxMV9BVFRSX0lGSU5ERVhdKQorCQlyZXR1cm4gTkxfU0tJUDsKKwogCWlmaWR4ID0gbmxhX2dldF91MzIodGJbTkw4MDIxMV9BVFRSX0lGSU5ERVhdKTsKIAogCWlmICghdGJbTkw4MDIxMV9BVFRSX1NVUlZFWV9JTkZPXSkKQEAgLTEwMzI4LDEyICsxMTQwOSwxMyBAQAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogc2V0X3AycF9wb3dlcnNhdmUgKGxlZ2FjeV9wcz0lZCAiCiAJCSAgICJvcHBfcHM9JWQgY3R3aW5kb3c9JWQpIiwgbGVnYWN5X3BzLCBvcHBfcHMsIGN0d2luZG93KTsKIAotCWlmIChvcHBfcHMgIT0gLTEgfHwgY3R3aW5kb3cgIT0gLTEpCisJaWYgKG9wcF9wcyAhPSAtMSB8fCBjdHdpbmRvdyAhPSAtMSkgewogI2lmZGVmIEFORFJPSURfUDJQCiAJCXdwYV9kcml2ZXJfc2V0X3AycF9wcyhwcml2LCBsZWdhY3lfcHMsIG9wcF9wcywgY3R3aW5kb3cpOwotI2Vsc2UKKyNlbHNlIC8qIEFORFJPSURfUDJQICovCiAJCXJldHVybiAtMTsgLyogTm90IHlldCBzdXBwb3J0ZWQgKi8KLSNlbmRpZgorI2VuZGlmIC8qIEFORFJPSURfUDJQICovCisJfQogCiAJaWYgKGxlZ2FjeV9wcyA9PSAtMSkKIAkJcmV0dXJuIDA7CkBAIC0xMDM0NCwxNCArMTE0MjYsMTggQEAKIH0KIAogCi1zdGF0aWMgaW50IG5sODAyMTFfc3RhcnRfcmFkYXJfZGV0ZWN0aW9uKHZvaWQgKnByaXYsIGludCBmcmVxKQorc3RhdGljIGludCBubDgwMjExX3N0YXJ0X3JhZGFyX2RldGVjdGlvbih2b2lkICpwcml2LAorCQkJCQkgc3RydWN0IGhvc3RhcGRfZnJlcV9wYXJhbXMgKmZyZXEpCiB7CiAJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OwogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAJc3RydWN0IG5sX21zZyAqbXNnOwogCWludCByZXQ7CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFN0YXJ0IHJhZGFyIGRldGVjdGlvbiAoQ0FDKSIpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogU3RhcnQgcmFkYXIgZGV0ZWN0aW9uIChDQUMpICVkIE1IeiAoaHRfZW5hYmxlZD0lZCwgdmh0X2VuYWJsZWQ9JWQsIGJhbmR3aWR0aD0lZCBNSHosIGNmMT0lZCBNSHosIGNmMj0lZCBNSHopIiwKKwkJICAgZnJlcS0+ZnJlcSwgZnJlcS0+aHRfZW5hYmxlZCwgZnJlcS0+dmh0X2VuYWJsZWQsCisJCSAgIGZyZXEtPmJhbmR3aWR0aCwgZnJlcS0+Y2VudGVyX2ZyZXExLCBmcmVxLT5jZW50ZXJfZnJlcTIpOworCiAJaWYgKCEoZHJ2LT5jYXBhLmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19SQURBUikpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBEcml2ZXIgZG9lcyBub3Qgc3VwcG9ydCByYWRhciAiCiAJCQkgICAiZGV0ZWN0aW9uIik7CkBAIC0xMDM2NCwxMCArMTE0NTAsNTMgQEAKIAogCW5sODAyMTFfY21kKGJzcy0+ZHJ2LCBtc2csIDAsIE5MODAyMTFfQ01EX1JBREFSX0RFVEVDVCk7CiAJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfSUZJTkRFWCwgZHJ2LT5pZmluZGV4KTsKLQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9XSVBIWV9GUkVRLCBmcmVxKTsKKwlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9XSVBIWV9GUkVRLCBmcmVxLT5mcmVxKTsKIAotCS8qIG9ubHkgSFQyMCBpcyBzdXBwb3J0ZWQgYXQgdGhpcyBwb2ludCAqLwotCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1dJUEhZX0NIQU5ORUxfVFlQRSwgTkw4MDIxMV9DSEFOX0hUMjApOworCWlmIChmcmVxLT52aHRfZW5hYmxlZCkgeworCQlzd2l0Y2ggKGZyZXEtPmJhbmR3aWR0aCkgeworCQljYXNlIDIwOgorCQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0hBTk5FTF9XSURUSCwKKwkJCQkgICAgTkw4MDIxMV9DSEFOX1dJRFRIXzIwKTsKKwkJCWJyZWFrOworCQljYXNlIDQwOgorCQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0hBTk5FTF9XSURUSCwKKwkJCQkgICAgTkw4MDIxMV9DSEFOX1dJRFRIXzQwKTsKKwkJCWJyZWFrOworCQljYXNlIDgwOgorCQkJaWYgKGZyZXEtPmNlbnRlcl9mcmVxMikKKwkJCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSEFOTkVMX1dJRFRILAorCQkJCQkgICAgTkw4MDIxMV9DSEFOX1dJRFRIXzgwUDgwKTsKKwkJCWVsc2UKKwkJCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9DSEFOTkVMX1dJRFRILAorCQkJCQkgICAgTkw4MDIxMV9DSEFOX1dJRFRIXzgwKTsKKwkJCWJyZWFrOworCQljYXNlIDE2MDoKKwkJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0NIQU5ORUxfV0lEVEgsCisJCQkJICAgIE5MODAyMTFfQ0hBTl9XSURUSF8xNjApOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0VOVEVSX0ZSRVExLCBmcmVxLT5jZW50ZXJfZnJlcTEpOworCQlpZiAoZnJlcS0+Y2VudGVyX2ZyZXEyKQorCQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0VOVEVSX0ZSRVEyLAorCQkJCSAgICBmcmVxLT5jZW50ZXJfZnJlcTIpOworCX0gZWxzZSBpZiAoZnJlcS0+aHRfZW5hYmxlZCkgeworCQlzd2l0Y2ggKGZyZXEtPnNlY19jaGFubmVsX29mZnNldCkgeworCQljYXNlIC0xOgorCQkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfV0lQSFlfQ0hBTk5FTF9UWVBFLAorCQkJCSAgICBOTDgwMjExX0NIQU5fSFQ0ME1JTlVTKTsKKwkJCWJyZWFrOworCQljYXNlIDE6CisJCQlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9XSVBIWV9DSEFOTkVMX1RZUEUsCisJCQkJICAgIE5MODAyMTFfQ0hBTl9IVDQwUExVUyk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1dJUEhZX0NIQU5ORUxfVFlQRSwKKwkJCQkgICAgTkw4MDIxMV9DSEFOX0hUMjApOworCQkJYnJlYWs7CisJCX0KKwl9CiAKIAlyZXQgPSBzZW5kX2FuZF9yZWN2X21zZ3MoZHJ2LCBtc2csIE5VTEwsIE5VTEwpOwogCWlmIChyZXQgPT0gMCkKQEAgLTEwMzgyLDcgKzExNTExLDcgQEAKIAogc3RhdGljIGludCBubDgwMjExX3NlbmRfdGRsc19tZ210KHZvaWQgKnByaXYsIGNvbnN0IHU4ICpkc3QsIHU4IGFjdGlvbl9jb2RlLAogCQkJCSAgdTggZGlhbG9nX3Rva2VuLCB1MTYgc3RhdHVzX2NvZGUsCi0JCQkJICBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKQorCQkJCSAgdTMyIHBlZXJfY2FwYWIsIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCiB7CiAJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OwogCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CkBAIC0xMDQwNCw2ICsxMTUzMywxNSBAQAogCU5MQV9QVVRfVTgobXNnLCBOTDgwMjExX0FUVFJfVERMU19BQ1RJT04sIGFjdGlvbl9jb2RlKTsKIAlOTEFfUFVUX1U4KG1zZywgTkw4MDIxMV9BVFRSX1RETFNfRElBTE9HX1RPS0VOLCBkaWFsb2dfdG9rZW4pOwogCU5MQV9QVVRfVTE2KG1zZywgTkw4MDIxMV9BVFRSX1NUQVRVU19DT0RFLCBzdGF0dXNfY29kZSk7CisJaWYgKHBlZXJfY2FwYWIpIHsKKwkJLyoKKwkJICogVGhlIGludGVybmFsIGVudW0gdGRsc19wZWVyX2NhcGFiaWxpdHkgZGVmaW5pdGlvbiBpcworCQkgKiBjdXJyZW50bHkgaWRlbnRpY2FsIHdpdGggdGhlIG5sODAyMTEgZW51bQorCQkgKiBubDgwMjExX3RkbHNfcGVlcl9jYXBhYmlsaXR5LCBzbyBubyBjb252ZXJzaW9uIGlzIG5lZWRlZAorCQkgKiBoZXJlLgorCQkgKi8KKwkJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfVERMU19QRUVSX0NBUEFCSUxJVFksIHBlZXJfY2FwYWIpOworCX0KIAlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0lFLCBsZW4sIGJ1Zik7CiAKIAlyZXR1cm4gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBOVUxMLCBOVUxMKTsKQEAgLTEwNTcwLDcgKzExNzA4LDcgQEAKIAogCW1lbXNldCgmaWZyLCAwLCBzaXplb2YoaWZyKSk7CiAJbWVtc2V0KCZwcml2X2NtZCwgMCwgc2l6ZW9mKHByaXZfY21kKSk7Ci0Jb3Nfc3RybmNweShpZnIuaWZyX25hbWUsIGJzcy0+aWZuYW1lLCBJRk5BTVNJWik7CisJb3Nfc3RybGNweShpZnIuaWZyX25hbWUsIGJzcy0+aWZuYW1lLCBJRk5BTVNJWik7CiAKIAlwcml2X2NtZC5idWYgPSBidWY7CiAJcHJpdl9jbWQudXNlZF9sZW4gPSBicDsKQEAgLTEwNjY3LDE0ICsxMTgwNSwxMiBAQAogfQogCiAKLSNpZiBkZWZpbmVkKEhPU1RBUEQpIHx8IGRlZmluZWQoQ09ORklHX0FQKQogc3RhdGljIGludCBkcml2ZXJfbmw4MDIxMV9zZXRfc3RhX3ZsYW4odm9pZCAqcHJpdiwgY29uc3QgdTggKmFkZHIsCiAJCQkJICAgICAgIGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50IHZsYW5faWQpCiB7CiAJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OwogCXJldHVybiBpODAyX3NldF9zdGFfdmxhbihic3MsIGFkZHIsIGlmbmFtZSwgdmxhbl9pZCk7CiB9Ci0jZW5kaWYgLyogSE9TVEFQRCB8fCBDT05GSUdfQVAgKi8KIAogCiBzdGF0aWMgaW50IGRyaXZlcl9ubDgwMjExX3JlYWRfc3RhX2RhdGEodm9pZCAqcHJpdiwKQEAgLTEwNzUxLDYgKzExODg3LDQ3MSBAQAogfQogCiAKK3N0YXRpYyBjb25zdCBjaGFyICogc2Nhbl9zdGF0ZV9zdHIoZW51bSBzY2FuX3N0YXRlcyBzY2FuX3N0YXRlKQoreworCXN3aXRjaCAoc2Nhbl9zdGF0ZSkgeworCWNhc2UgTk9fU0NBTjoKKwkJcmV0dXJuICJOT19TQ0FOIjsKKwljYXNlIFNDQU5fUkVRVUVTVEVEOgorCQlyZXR1cm4gIlNDQU5fUkVRVUVTVEVEIjsKKwljYXNlIFNDQU5fU1RBUlRFRDoKKwkJcmV0dXJuICJTQ0FOX1NUQVJURUQiOworCWNhc2UgU0NBTl9DT01QTEVURUQ6CisJCXJldHVybiAiU0NBTl9DT01QTEVURUQiOworCWNhc2UgU0NBTl9BQk9SVEVEOgorCQlyZXR1cm4gIlNDQU5fQUJPUlRFRCI7CisJY2FzZSBTQ0hFRF9TQ0FOX1NUQVJURUQ6CisJCXJldHVybiAiU0NIRURfU0NBTl9TVEFSVEVEIjsKKwljYXNlIFNDSEVEX1NDQU5fU1RPUFBFRDoKKwkJcmV0dXJuICJTQ0hFRF9TQ0FOX1NUT1BQRUQiOworCWNhc2UgU0NIRURfU0NBTl9SRVNVTFRTOgorCQlyZXR1cm4gIlNDSEVEX1NDQU5fUkVTVUxUUyI7CisJfQorCisJcmV0dXJuICI/PyI7Cit9CisKKworc3RhdGljIGludCB3cGFfZHJpdmVyX25sODAyMTFfc3RhdHVzKHZvaWQgKnByaXYsIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKK3sKKwlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CisJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKKwlpbnQgcmVzOworCWNoYXIgKnBvcywgKmVuZDsKKworCXBvcyA9IGJ1ZjsKKwllbmQgPSBidWYgKyBidWZsZW47CisKKwlyZXMgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKKwkJCSAgImlmaW5kZXg9JWRcbiIKKwkJCSAgImlmbmFtZT0lc1xuIgorCQkJICAiYnJuYW1lPSVzXG4iCisJCQkgICJhZGRyPSIgTUFDU1RSICJcbiIKKwkJCSAgImZyZXE9JWRcbiIKKwkJCSAgIiVzJXMlcyVzJXMiLAorCQkJICBic3MtPmlmaW5kZXgsCisJCQkgIGJzcy0+aWZuYW1lLAorCQkJICBic3MtPmJybmFtZSwKKwkJCSAgTUFDMlNUUihic3MtPmFkZHIpLAorCQkJICBic3MtPmZyZXEsCisJCQkgIGJzcy0+YmVhY29uX3NldCA/ICJiZWFjb25fc2V0PTFcbiIgOiAiIiwKKwkJCSAgYnNzLT5hZGRlZF9pZl9pbnRvX2JyaWRnZSA/CisJCQkgICJhZGRlZF9pZl9pbnRvX2JyaWRnZT0xXG4iIDogIiIsCisJCQkgIGJzcy0+YWRkZWRfYnJpZGdlID8gImFkZGVkX2JyaWRnZT0xXG4iIDogIiIsCisJCQkgIGJzcy0+aW5fZGVpbml0ID8gImluX2RlaW5pdD0xXG4iIDogIiIsCisJCQkgIGJzcy0+aWZfZHluYW1pYyA/ICJpZl9keW5hbWljPTFcbiIgOiAiIik7CisJaWYgKHJlcyA8IDAgfHwgcmVzID49IGVuZCAtIHBvcykKKwkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwlwb3MgKz0gcmVzOworCisJaWYgKGJzcy0+d2Rldl9pZF9zZXQpIHsKKwkJcmVzID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJ3ZGV2X2lkPSVsbHVcbiIsCisJCQkJICAodW5zaWduZWQgbG9uZyBsb25nKSBic3MtPndkZXZfaWQpOworCQlpZiAocmVzIDwgMCB8fCByZXMgPj0gZW5kIC0gcG9zKQorCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwkJcG9zICs9IHJlczsKKwl9CisKKwlyZXMgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKKwkJCSAgInBoeW5hbWU9JXNcbiIKKwkJCSAgImRydl9pZmluZGV4PSVkXG4iCisJCQkgICJvcGVyc3RhdGU9JWRcbiIKKwkJCSAgInNjYW5fc3RhdGU9JXNcbiIKKwkJCSAgImF1dGhfYnNzaWQ9IiBNQUNTVFIgIlxuIgorCQkJICAiYXV0aF9hdHRlbXB0X2Jzc2lkPSIgTUFDU1RSICJcbiIKKwkJCSAgImJzc2lkPSIgTUFDU1RSICJcbiIKKwkJCSAgInByZXZfYnNzaWQ9IiBNQUNTVFIgIlxuIgorCQkJICAiYXNzb2NpYXRlZD0lZFxuIgorCQkJICAiYXNzb2NfZnJlcT0ldVxuIgorCQkJICAibW9uaXRvcl9zb2NrPSVkXG4iCisJCQkgICJtb25pdG9yX2lmaWR4PSVkXG4iCisJCQkgICJtb25pdG9yX3JlZmNvdW50PSVkXG4iCisJCQkgICJsYXN0X21nbXRfZnJlcT0ldVxuIgorCQkJICAiZWFwb2xfdHhfc29jaz0lZFxuIgorCQkJICAiJXMlcyVzJXMlcyVzJXMlcyVzJXMlcyVzJXMlcyIsCisJCQkgIGRydi0+cGh5bmFtZSwKKwkJCSAgZHJ2LT5pZmluZGV4LAorCQkJICBkcnYtPm9wZXJzdGF0ZSwKKwkJCSAgc2Nhbl9zdGF0ZV9zdHIoZHJ2LT5zY2FuX3N0YXRlKSwKKwkJCSAgTUFDMlNUUihkcnYtPmF1dGhfYnNzaWQpLAorCQkJICBNQUMyU1RSKGRydi0+YXV0aF9hdHRlbXB0X2Jzc2lkKSwKKwkJCSAgTUFDMlNUUihkcnYtPmJzc2lkKSwKKwkJCSAgTUFDMlNUUihkcnYtPnByZXZfYnNzaWQpLAorCQkJICBkcnYtPmFzc29jaWF0ZWQsCisJCQkgIGRydi0+YXNzb2NfZnJlcSwKKwkJCSAgZHJ2LT5tb25pdG9yX3NvY2ssCisJCQkgIGRydi0+bW9uaXRvcl9pZmlkeCwKKwkJCSAgZHJ2LT5tb25pdG9yX3JlZmNvdW50LAorCQkJICBkcnYtPmxhc3RfbWdtdF9mcmVxLAorCQkJICBkcnYtPmVhcG9sX3R4X3NvY2ssCisJCQkgIGRydi0+aWdub3JlX2lmX2Rvd25fZXZlbnQgPworCQkJICAiaWdub3JlX2lmX2Rvd25fZXZlbnQ9MVxuIiA6ICIiLAorCQkJICBkcnYtPnNjYW5fY29tcGxldGVfZXZlbnRzID8KKwkJCSAgInNjYW5fY29tcGxldGVfZXZlbnRzPTFcbiIgOiAiIiwKKwkJCSAgZHJ2LT5kaXNhYmxlZF8xMWJfcmF0ZXMgPworCQkJICAiZGlzYWJsZWRfMTFiX3JhdGVzPTFcbiIgOiAiIiwKKwkJCSAgZHJ2LT5wZW5kaW5nX3JlbWFpbl9vbl9jaGFuID8KKwkJCSAgInBlbmRpbmdfcmVtYWluX29uX2NoYW49MVxuIiA6ICIiLAorCQkJICBkcnYtPmluX2ludGVyZmFjZV9saXN0ID8gImluX2ludGVyZmFjZV9saXN0PTFcbiIgOiAiIiwKKwkJCSAgZHJ2LT5kZXZpY2VfYXBfc21lID8gImRldmljZV9hcF9zbWU9MVxuIiA6ICIiLAorCQkJICBkcnYtPnBvbGxfY29tbWFuZF9zdXBwb3J0ZWQgPworCQkJICAicG9sbF9jb21tYW5kX3N1cHBvcnRlZD0xXG4iIDogIiIsCisJCQkgIGRydi0+ZGF0YV90eF9zdGF0dXMgPyAiZGF0YV90eF9zdGF0dXM9MVxuIiA6ICIiLAorCQkJICBkcnYtPnNjYW5fZm9yX2F1dGggPyAic2Nhbl9mb3JfYXV0aD0xXG4iIDogIiIsCisJCQkgIGRydi0+cmV0cnlfYXV0aCA/ICJyZXRyeV9hdXRoPTFcbiIgOiAiIiwKKwkJCSAgZHJ2LT51c2VfbW9uaXRvciA/ICJ1c2VfbW9uaXRvcj0xXG4iIDogIiIsCisJCQkgIGRydi0+aWdub3JlX25leHRfbG9jYWxfZGlzY29ubmVjdCA/CisJCQkgICJpZ25vcmVfbmV4dF9sb2NhbF9kaXNjb25uZWN0PTFcbiIgOiAiIiwKKwkJCSAgZHJ2LT5pZ25vcmVfbmV4dF9sb2NhbF9kZWF1dGggPworCQkJICAiaWdub3JlX25leHRfbG9jYWxfZGVhdXRoPTFcbiIgOiAiIiwKKwkJCSAgZHJ2LT5hbGxvd19wMnBfZGV2aWNlID8gImFsbG93X3AycF9kZXZpY2U9MVxuIiA6ICIiKTsKKwlpZiAocmVzIDwgMCB8fCByZXMgPj0gZW5kIC0gcG9zKQorCQlyZXR1cm4gcG9zIC0gYnVmOworCXBvcyArPSByZXM7CisKKwlpZiAoZHJ2LT5oYXNfY2FwYWJpbGl0eSkgeworCQlyZXMgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKKwkJCQkgICJjYXBhLmtleV9tZ210PTB4JXhcbiIKKwkJCQkgICJjYXBhLmVuYz0weCV4XG4iCisJCQkJICAiY2FwYS5hdXRoPTB4JXhcbiIKKwkJCQkgICJjYXBhLmZsYWdzPTB4JXhcbiIKKwkJCQkgICJjYXBhLm1heF9zY2FuX3NzaWRzPSVkXG4iCisJCQkJICAiY2FwYS5tYXhfc2NoZWRfc2Nhbl9zc2lkcz0lZFxuIgorCQkJCSAgImNhcGEuc2NoZWRfc2Nhbl9zdXBwb3J0ZWQ9JWRcbiIKKwkJCQkgICJjYXBhLm1heF9tYXRjaF9zZXRzPSVkXG4iCisJCQkJICAiY2FwYS5tYXhfcmVtYWluX29uX2NoYW49JXVcbiIKKwkJCQkgICJjYXBhLm1heF9zdGF0aW9ucz0ldVxuIgorCQkJCSAgImNhcGEucHJvYmVfcmVzcF9vZmZsb2Fkcz0weCV4XG4iCisJCQkJICAiY2FwYS5tYXhfYWNsX21hY19hZGRycz0ldVxuIgorCQkJCSAgImNhcGEubnVtX211bHRpY2hhbl9jb25jdXJyZW50PSV1XG4iLAorCQkJCSAgZHJ2LT5jYXBhLmtleV9tZ210LAorCQkJCSAgZHJ2LT5jYXBhLmVuYywKKwkJCQkgIGRydi0+Y2FwYS5hdXRoLAorCQkJCSAgZHJ2LT5jYXBhLmZsYWdzLAorCQkJCSAgZHJ2LT5jYXBhLm1heF9zY2FuX3NzaWRzLAorCQkJCSAgZHJ2LT5jYXBhLm1heF9zY2hlZF9zY2FuX3NzaWRzLAorCQkJCSAgZHJ2LT5jYXBhLnNjaGVkX3NjYW5fc3VwcG9ydGVkLAorCQkJCSAgZHJ2LT5jYXBhLm1heF9tYXRjaF9zZXRzLAorCQkJCSAgZHJ2LT5jYXBhLm1heF9yZW1haW5fb25fY2hhbiwKKwkJCQkgIGRydi0+Y2FwYS5tYXhfc3RhdGlvbnMsCisJCQkJICBkcnYtPmNhcGEucHJvYmVfcmVzcF9vZmZsb2FkcywKKwkJCQkgIGRydi0+Y2FwYS5tYXhfYWNsX21hY19hZGRycywKKwkJCQkgIGRydi0+Y2FwYS5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQpOworCQlpZiAocmVzIDwgMCB8fCByZXMgPj0gZW5kIC0gcG9zKQorCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwkJcG9zICs9IHJlczsKKwl9CisKKwlyZXR1cm4gcG9zIC0gYnVmOworfQorCisKK3N0YXRpYyBpbnQgc2V0X2JlYWNvbl9kYXRhKHN0cnVjdCBubF9tc2cgKm1zZywgc3RydWN0IGJlYWNvbl9kYXRhICpzZXR0aW5ncykKK3sKKwlpZiAoc2V0dGluZ3MtPmhlYWQpCisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfQkVBQ09OX0hFQUQsCisJCQlzZXR0aW5ncy0+aGVhZF9sZW4sIHNldHRpbmdzLT5oZWFkKTsKKworCWlmIChzZXR0aW5ncy0+dGFpbCkKKwkJTkxBX1BVVChtc2csIE5MODAyMTFfQVRUUl9CRUFDT05fVEFJTCwKKwkJCXNldHRpbmdzLT50YWlsX2xlbiwgc2V0dGluZ3MtPnRhaWwpOworCisJaWYgKHNldHRpbmdzLT5iZWFjb25faWVzKQorCQlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX0lFLAorCQkJc2V0dGluZ3MtPmJlYWNvbl9pZXNfbGVuLCBzZXR0aW5ncy0+YmVhY29uX2llcyk7CisKKwlpZiAoc2V0dGluZ3MtPnByb2JlcmVzcF9pZXMpCisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfSUVfUFJPQkVfUkVTUCwKKwkJCXNldHRpbmdzLT5wcm9iZXJlc3BfaWVzX2xlbiwgc2V0dGluZ3MtPnByb2JlcmVzcF9pZXMpOworCisJaWYgKHNldHRpbmdzLT5hc3NvY3Jlc3BfaWVzKQorCQlOTEFfUFVUKG1zZywKKwkJCU5MODAyMTFfQVRUUl9JRV9BU1NPQ19SRVNQLAorCQkJc2V0dGluZ3MtPmFzc29jcmVzcF9pZXNfbGVuLCBzZXR0aW5ncy0+YXNzb2NyZXNwX2llcyk7CisKKwlpZiAoc2V0dGluZ3MtPnByb2JlX3Jlc3ApCisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfUFJPQkVfUkVTUCwKKwkJCXNldHRpbmdzLT5wcm9iZV9yZXNwX2xlbiwgc2V0dGluZ3MtPnByb2JlX3Jlc3ApOworCisJcmV0dXJuIDA7CisKK25sYV9wdXRfZmFpbHVyZToKKwlyZXR1cm4gLUVOT0JVRlM7Cit9CisKKworc3RhdGljIGludCBubDgwMjExX3N3aXRjaF9jaGFubmVsKHZvaWQgKnByaXYsIHN0cnVjdCBjc2Ffc2V0dGluZ3MgKnNldHRpbmdzKQoreworCXN0cnVjdCBubF9tc2cgKm1zZzsKKwlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CisJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKKwlzdHJ1Y3QgbmxhdHRyICpiZWFjb25fY3NhOworCWludCByZXQgPSAtRU5PQlVGUzsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogQ2hhbm5lbCBzd2l0Y2ggcmVxdWVzdCAoY3NfY291bnQ9JXUgYmxvY2tfdHg9JXUgZnJlcT0lZCB3aWR0aD0lZCBjZjE9JWQgY2YyPSVkKSIsCisJCSAgIHNldHRpbmdzLT5jc19jb3VudCwgc2V0dGluZ3MtPmJsb2NrX3R4LAorCQkgICBzZXR0aW5ncy0+ZnJlcV9wYXJhbXMuZnJlcSwgc2V0dGluZ3MtPmZyZXFfcGFyYW1zLmJhbmR3aWR0aCwKKwkJICAgc2V0dGluZ3MtPmZyZXFfcGFyYW1zLmNlbnRlcl9mcmVxMSwKKwkJICAgc2V0dGluZ3MtPmZyZXFfcGFyYW1zLmNlbnRlcl9mcmVxMik7CisKKwlpZiAoIShkcnYtPmNhcGEuZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX0FQX0NTQSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBEcml2ZXIgZG9lcyBub3Qgc3VwcG9ydCBjaGFubmVsIHN3aXRjaCBjb21tYW5kIik7CisJCXJldHVybiAtRU9QTk9UU1VQUDsKKwl9CisKKwlpZiAoKGRydi0+bmxtb2RlICE9IE5MODAyMTFfSUZUWVBFX0FQKSAmJgorCSAgICAoZHJ2LT5ubG1vZGUgIT0gTkw4MDIxMV9JRlRZUEVfUDJQX0dPKSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOworCisJLyogY2hlY2sgc2V0dGluZ3MgdmFsaWRpdHkgKi8KKwlpZiAoIXNldHRpbmdzLT5iZWFjb25fY3NhLnRhaWwgfHwKKwkgICAgKChzZXR0aW5ncy0+YmVhY29uX2NzYS50YWlsX2xlbiA8PQorCSAgICAgIHNldHRpbmdzLT5jb3VudGVyX29mZnNldF9iZWFjb24pIHx8CisJICAgICAoc2V0dGluZ3MtPmJlYWNvbl9jc2EudGFpbFtzZXR0aW5ncy0+Y291bnRlcl9vZmZzZXRfYmVhY29uXSAhPQorCSAgICAgIHNldHRpbmdzLT5jc19jb3VudCkpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChzZXR0aW5ncy0+YmVhY29uX2NzYS5wcm9iZV9yZXNwICYmCisJICAgICgoc2V0dGluZ3MtPmJlYWNvbl9jc2EucHJvYmVfcmVzcF9sZW4gPD0KKwkgICAgICBzZXR0aW5ncy0+Y291bnRlcl9vZmZzZXRfcHJlc3ApIHx8CisJICAgICAoc2V0dGluZ3MtPmJlYWNvbl9jc2EucHJvYmVfcmVzcFtzZXR0aW5ncy0+Y291bnRlcl9vZmZzZXRfcHJlc3BdICE9CisJICAgICAgc2V0dGluZ3MtPmNzX2NvdW50KSkpCisJCXJldHVybiAtRUlOVkFMOworCisJbXNnID0gbmxtc2dfYWxsb2MoKTsKKwlpZiAoIW1zZykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlubDgwMjExX2NtZChkcnYsIG1zZywgMCwgTkw4MDIxMV9DTURfQ0hBTk5FTF9TV0lUQ0gpOworCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX0lGSU5ERVgsIGJzcy0+aWZpbmRleCk7CisJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfQ0hfU1dJVENIX0NPVU5ULCBzZXR0aW5ncy0+Y3NfY291bnQpOworCXJldCA9IG5sODAyMTFfcHV0X2ZyZXFfcGFyYW1zKG1zZywgJnNldHRpbmdzLT5mcmVxX3BhcmFtcyk7CisJaWYgKHJldCkKKwkJZ290byBlcnJvcjsKKworCWlmIChzZXR0aW5ncy0+YmxvY2tfdHgpCisJCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfQVRUUl9DSF9TV0lUQ0hfQkxPQ0tfVFgpOworCisJLyogYmVhY29uX2FmdGVyIHBhcmFtcyAqLworCXJldCA9IHNldF9iZWFjb25fZGF0YShtc2csICZzZXR0aW5ncy0+YmVhY29uX2FmdGVyKTsKKwlpZiAocmV0KQorCQlnb3RvIGVycm9yOworCisJLyogYmVhY29uX2NzYSBwYXJhbXMgKi8KKwliZWFjb25fY3NhID0gbmxhX25lc3Rfc3RhcnQobXNnLCBOTDgwMjExX0FUVFJfQ1NBX0lFUyk7CisJaWYgKCFiZWFjb25fY3NhKQorCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsKKworCXJldCA9IHNldF9iZWFjb25fZGF0YShtc2csICZzZXR0aW5ncy0+YmVhY29uX2NzYSk7CisJaWYgKHJldCkKKwkJZ290byBlcnJvcjsKKworCU5MQV9QVVRfVTE2KG1zZywgTkw4MDIxMV9BVFRSX0NTQV9DX09GRl9CRUFDT04sCisJCSAgICBzZXR0aW5ncy0+Y291bnRlcl9vZmZzZXRfYmVhY29uKTsKKworCWlmIChzZXR0aW5ncy0+YmVhY29uX2NzYS5wcm9iZV9yZXNwKQorCQlOTEFfUFVUX1UxNihtc2csIE5MODAyMTFfQVRUUl9DU0FfQ19PRkZfUFJFU1AsCisJCQkgICAgc2V0dGluZ3MtPmNvdW50ZXJfb2Zmc2V0X3ByZXNwKTsKKworCW5sYV9uZXN0X2VuZChtc2csIGJlYWNvbl9jc2EpOworCXJldCA9IHNlbmRfYW5kX3JlY3ZfbXNncyhkcnYsIG1zZywgTlVMTCwgTlVMTCk7CisJaWYgKHJldCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IHN3aXRjaF9jaGFubmVsIGZhaWxlZCBlcnI9JWQgKCVzKSIsCisJCQkgICByZXQsIHN0cmVycm9yKC1yZXQpKTsKKwl9CisJcmV0dXJuIHJldDsKKworbmxhX3B1dF9mYWlsdXJlOgorCXJldCA9IC1FTk9CVUZTOworZXJyb3I6CisJbmxtc2dfZnJlZShtc2cpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogQ291bGQgbm90IGJ1aWxkIGNoYW5uZWwgc3dpdGNoIHJlcXVlc3QiKTsKKwlyZXR1cm4gcmV0OworfQorCisKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCitzdGF0aWMgaW50IGNtZF9yZXBseV9oYW5kbGVyKHN0cnVjdCBubF9tc2cgKm1zZywgdm9pZCAqYXJnKQoreworCXN0cnVjdCBnZW5sbXNnaGRyICpnbmxoID0gbmxtc2dfZGF0YShubG1zZ19oZHIobXNnKSk7CisJc3RydWN0IHdwYWJ1ZiAqYnVmID0gYXJnOworCisJaWYgKCFidWYpCisJCXJldHVybiBOTF9TS0lQOworCisJaWYgKChzaXplX3QpIGdlbmxtc2dfYXR0cmxlbihnbmxoLCAwKSA+IHdwYWJ1Zl90YWlscm9vbShidWYpKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJubDgwMjExOiBpbnN1ZmZpY2llbnQgYnVmZmVyIHNwYWNlIGZvciByZXBseSIpOworCQlyZXR1cm4gTkxfU0tJUDsKKwl9CisKKwl3cGFidWZfcHV0X2RhdGEoYnVmLCBnZW5sbXNnX2F0dHJkYXRhKGdubGgsIDApLAorCQkJZ2VubG1zZ19hdHRybGVuKGdubGgsIDApKTsKKworCXJldHVybiBOTF9TS0lQOworfQorI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKworCitzdGF0aWMgaW50IHZlbmRvcl9yZXBseV9oYW5kbGVyKHN0cnVjdCBubF9tc2cgKm1zZywgdm9pZCAqYXJnKQoreworCXN0cnVjdCBubGF0dHIgKnRiW05MODAyMTFfQVRUUl9NQVggKyAxXTsKKwlzdHJ1Y3QgbmxhdHRyICpubF92ZW5kb3JfcmVwbHksICpubDsKKwlzdHJ1Y3QgZ2VubG1zZ2hkciAqZ25saCA9IG5sbXNnX2RhdGEobmxtc2dfaGRyKG1zZykpOworCXN0cnVjdCB3cGFidWYgKmJ1ZiA9IGFyZzsKKwlpbnQgcmVtOworCisJaWYgKCFidWYpCisJCXJldHVybiBOTF9TS0lQOworCisJbmxhX3BhcnNlKHRiLCBOTDgwMjExX0FUVFJfTUFYLCBnZW5sbXNnX2F0dHJkYXRhKGdubGgsIDApLAorCQkgIGdlbmxtc2dfYXR0cmxlbihnbmxoLCAwKSwgTlVMTCk7CisJbmxfdmVuZG9yX3JlcGx5ID0gdGJbTkw4MDIxMV9BVFRSX1ZFTkRPUl9EQVRBXTsKKworCWlmICghbmxfdmVuZG9yX3JlcGx5KQorCQlyZXR1cm4gTkxfU0tJUDsKKworCWlmICgoc2l6ZV90KSBubGFfbGVuKG5sX3ZlbmRvcl9yZXBseSkgPiB3cGFidWZfdGFpbHJvb20oYnVmKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAibmw4MDIxMTogVmVuZG9yIGNvbW1hbmQ6IGluc3VmZmljaWVudCBidWZmZXIgc3BhY2UgZm9yIHJlcGx5Iik7CisJCXJldHVybiBOTF9TS0lQOworCX0KKworCW5sYV9mb3JfZWFjaF9uZXN0ZWQobmwsIG5sX3ZlbmRvcl9yZXBseSwgcmVtKSB7CisJCXdwYWJ1Zl9wdXRfZGF0YShidWYsIG5sYV9kYXRhKG5sKSwgbmxhX2xlbihubCkpOworCX0KKworCXJldHVybiBOTF9TS0lQOworfQorCisKK3N0YXRpYyBpbnQgbmw4MDIxMV92ZW5kb3JfY21kKHZvaWQgKnByaXYsIHVuc2lnbmVkIGludCB2ZW5kb3JfaWQsCisJCQkgICAgICB1bnNpZ25lZCBpbnQgc3ViY21kLCBjb25zdCB1OCAqZGF0YSwKKwkJCSAgICAgIHNpemVfdCBkYXRhX2xlbiwgc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCXN0cnVjdCBpODAyX2JzcyAqYnNzID0gcHJpdjsKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiA9IGJzcy0+ZHJ2OworCXN0cnVjdCBubF9tc2cgKm1zZzsKKwlpbnQgcmV0OworCisJbXNnID0gbmxtc2dfYWxsb2MoKTsKKwlpZiAoIW1zZykKKwkJcmV0dXJuIC1FTk9NRU07CisKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJaWYgKHZlbmRvcl9pZCA9PSAweGZmZmZmZmZmKSB7CisJCW5sODAyMTFfY21kKGRydiwgbXNnLCAwLCBzdWJjbWQpOworCQlpZiAobmxtc2dfYXBwZW5kKG1zZywgKHZvaWQgKikgZGF0YSwgZGF0YV9sZW4sIE5MTVNHX0FMSUdOVE8pIDwKKwkJICAgIDApCisJCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsKKwkJcmV0ID0gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBjbWRfcmVwbHlfaGFuZGxlciwgYnVmKTsKKwkJaWYgKHJldCkKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogY29tbWFuZCBmYWlsZWQgZXJyPSVkIiwKKwkJCQkgICByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCisKKwlubDgwMjExX2NtZChkcnYsIG1zZywgMCwgTkw4MDIxMV9DTURfVkVORE9SKTsKKwlpZiAobmw4MDIxMV9zZXRfaWZhY2VfaWQobXNnLCBic3MpIDwgMCkKKwkJZ290byBubGFfcHV0X2ZhaWx1cmU7CisJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfVkVORE9SX0lELCB2ZW5kb3JfaWQpOworCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1ZFTkRPUl9TVUJDTUQsIHN1YmNtZCk7CisJaWYgKGRhdGEpCisJCU5MQV9QVVQobXNnLCBOTDgwMjExX0FUVFJfVkVORE9SX0RBVEEsIGRhdGFfbGVuLCBkYXRhKTsKKworCXJldCA9IHNlbmRfYW5kX3JlY3ZfbXNncyhkcnYsIG1zZywgdmVuZG9yX3JlcGx5X2hhbmRsZXIsIGJ1Zik7CisJaWYgKHJldCkKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiB2ZW5kb3IgY29tbWFuZCBmYWlsZWQgZXJyPSVkIiwKKwkJCSAgIHJldCk7CisJcmV0dXJuIHJldDsKKworbmxhX3B1dF9mYWlsdXJlOgorCW5sbXNnX2ZyZWUobXNnKTsKKwlyZXR1cm4gLUVOT0JVRlM7Cit9CisKKworc3RhdGljIGludCBubDgwMjExX3NldF9xb3NfbWFwKHZvaWQgKnByaXYsIGNvbnN0IHU4ICpxb3NfbWFwX3NldCwKKwkJCSAgICAgICB1OCBxb3NfbWFwX3NldF9sZW4pCit7CisJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OworCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CisJc3RydWN0IG5sX21zZyAqbXNnOworCWludCByZXQ7CisKKwltc2cgPSBubG1zZ19hbGxvYygpOworCWlmICghbXNnKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIm5sODAyMTE6IFNldHRpbmcgUW9TIE1hcCIsCisJCSAgICBxb3NfbWFwX3NldCwgcW9zX21hcF9zZXRfbGVuKTsKKworCW5sODAyMTFfY21kKGRydiwgbXNnLCAwLCBOTDgwMjExX0NNRF9TRVRfUU9TX01BUCk7CisJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfSUZJTkRFWCwgZHJ2LT5pZmluZGV4KTsKKwlOTEFfUFVUKG1zZywgTkw4MDIxMV9BVFRSX1FPU19NQVAsIHFvc19tYXBfc2V0X2xlbiwgcW9zX21hcF9zZXQpOworCisJcmV0ID0gc2VuZF9hbmRfcmVjdl9tc2dzKGRydiwgbXNnLCBOVUxMLCBOVUxMKTsKKwlpZiAocmV0KQorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNldHRpbmcgUW9TIE1hcCBmYWlsZWQiKTsKKworCXJldHVybiByZXQ7CisKK25sYV9wdXRfZmFpbHVyZToKKwlubG1zZ19mcmVlKG1zZyk7CisJcmV0dXJuIC1FTk9CVUZTOworfQorCisKK3N0YXRpYyBpbnQgbmw4MDIxMV9zZXRfd293bGFuKHZvaWQgKnByaXYsCisJCQkgICAgICBjb25zdCBzdHJ1Y3Qgd293bGFuX3RyaWdnZXJzICp0cmlnZ2VycykKK3sKKwlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CisJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKKwlzdHJ1Y3QgbmxfbXNnICptc2c7CisJc3RydWN0IG5sYXR0ciAqd293bGFuX3RyaWdnZXJzOworCWludCByZXQ7CisKKwltc2cgPSBubG1zZ19hbGxvYygpOworCWlmICghbXNnKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogU2V0dGluZyB3b3dsYW4iKTsKKworCW5sODAyMTFfY21kKGRydiwgbXNnLCAwLCBOTDgwMjExX0NNRF9TRVRfV09XTEFOKTsKKwlOTEFfUFVUX1UzMihtc2csIE5MODAyMTFfQVRUUl9JRklOREVYLCBkcnYtPmlmaW5kZXgpOworCisJd293bGFuX3RyaWdnZXJzID0gbmxhX25lc3Rfc3RhcnQobXNnLCBOTDgwMjExX0FUVFJfV09XTEFOX1RSSUdHRVJTKTsKKwlpZiAoIXdvd2xhbl90cmlnZ2VycykKKwkJZ290byBubGFfcHV0X2ZhaWx1cmU7CisKKwlpZiAodHJpZ2dlcnMtPmFueSkKKwkJTkxBX1BVVF9GTEFHKG1zZywgTkw4MDIxMV9XT1dMQU5fVFJJR19BTlkpOworCWlmICh0cmlnZ2Vycy0+ZGlzY29ubmVjdCkKKwkJTkxBX1BVVF9GTEFHKG1zZywgTkw4MDIxMV9XT1dMQU5fVFJJR19ESVNDT05ORUNUKTsKKwlpZiAodHJpZ2dlcnMtPm1hZ2ljX3BrdCkKKwkJTkxBX1BVVF9GTEFHKG1zZywgTkw4MDIxMV9XT1dMQU5fVFJJR19NQUdJQ19QS1QpOworCWlmICh0cmlnZ2Vycy0+Z3RrX3Jla2V5X2ZhaWx1cmUpCisJCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfV09XTEFOX1RSSUdfR1RLX1JFS0VZX0ZBSUxVUkUpOworCWlmICh0cmlnZ2Vycy0+ZWFwX2lkZW50aXR5X3JlcSkKKwkJTkxBX1BVVF9GTEFHKG1zZywgTkw4MDIxMV9XT1dMQU5fVFJJR19FQVBfSURFTlRfUkVRVUVTVCk7CisJaWYgKHRyaWdnZXJzLT5mb3VyX3dheV9oYW5kc2hha2UpCisJCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfV09XTEFOX1RSSUdfNFdBWV9IQU5EU0hBS0UpOworCWlmICh0cmlnZ2Vycy0+cmZraWxsX3JlbGVhc2UpCisJCU5MQV9QVVRfRkxBRyhtc2csIE5MODAyMTFfV09XTEFOX1RSSUdfUkZLSUxMX1JFTEVBU0UpOworCisJbmxhX25lc3RfZW5kKG1zZywgd293bGFuX3RyaWdnZXJzKTsKKworCXJldCA9IHNlbmRfYW5kX3JlY3ZfbXNncyhkcnYsIG1zZywgTlVMTCwgTlVMTCk7CisJaWYgKHJldCkKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBTZXR0aW5nIHdvd2xhbiBmYWlsZWQiKTsKKworCXJldHVybiByZXQ7CisKK25sYV9wdXRfZmFpbHVyZToKKwlubG1zZ19mcmVlKG1zZyk7CisJcmV0dXJuIC1FTk9CVUZTOworfQorCisKIGNvbnN0IHN0cnVjdCB3cGFfZHJpdmVyX29wcyB3cGFfZHJpdmVyX25sODAyMTFfb3BzID0gewogCS5uYW1lID0gIm5sODAyMTEiLAogCS5kZXNjID0gIkxpbnV4IG5sODAyMTEvY2ZnODAyMTEiLApAQCAtMTA3NzIsNiArMTIzNzMsNyBAQAogCS5zZXRfb3BlcnN0YXRlID0gd3BhX2RyaXZlcl9ubDgwMjExX3NldF9vcGVyc3RhdGUsCiAJLnNldF9zdXBwX3BvcnQgPSB3cGFfZHJpdmVyX25sODAyMTFfc2V0X3N1cHBfcG9ydCwKIAkuc2V0X2NvdW50cnkgPSB3cGFfZHJpdmVyX25sODAyMTFfc2V0X2NvdW50cnksCisJLmdldF9jb3VudHJ5ID0gd3BhX2RyaXZlcl9ubDgwMjExX2dldF9jb3VudHJ5LAogCS5zZXRfYXAgPSB3cGFfZHJpdmVyX25sODAyMTFfc2V0X2FwLAogCS5zZXRfYWNsID0gd3BhX2RyaXZlcl9ubDgwMjExX3NldF9hY2wsCiAJLmlmX2FkZCA9IHdwYV9kcml2ZXJfbmw4MDIxMV9pZl9hZGQsCkBAIC0xMDc4MiwxMiArMTIzODQsOSBAQAogCS5zdGFfcmVtb3ZlID0gZHJpdmVyX25sODAyMTFfc3RhX3JlbW92ZSwKIAkuaGFwZF9zZW5kX2VhcG9sID0gd3BhX2RyaXZlcl9ubDgwMjExX2hhcGRfc2VuZF9lYXBvbCwKIAkuc3RhX3NldF9mbGFncyA9IHdwYV9kcml2ZXJfbmw4MDIxMV9zdGFfc2V0X2ZsYWdzLAotI2lmZGVmIEhPU1RBUEQKIAkuaGFwZF9pbml0ID0gaTgwMl9pbml0LAogCS5oYXBkX2RlaW5pdCA9IGk4MDJfZGVpbml0LAogCS5zZXRfd2RzX3N0YSA9IGk4MDJfc2V0X3dkc19zdGEsCi0jZW5kaWYgLyogSE9TVEFQRCAqLwotI2lmIGRlZmluZWQoSE9TVEFQRCkgfHwgZGVmaW5lZChDT05GSUdfQVApCiAJLmdldF9zZXFudW0gPSBpODAyX2dldF9zZXFudW0sCiAJLmZsdXNoID0gaTgwMl9mbHVzaCwKIAkuZ2V0X2luYWN0X3NlYyA9IGk4MDJfZ2V0X2luYWN0X3NlYywKQEAgLTEwNzk4LDcgKzEyMzk3LDYgQEAKIAkuc2V0X3N0YV92bGFuID0gZHJpdmVyX25sODAyMTFfc2V0X3N0YV92bGFuLAogCS5zdGFfZGVhdXRoID0gaTgwMl9zdGFfZGVhdXRoLAogCS5zdGFfZGlzYXNzb2MgPSBpODAyX3N0YV9kaXNhc3NvYywKLSNlbmRpZiAvKiBIT1NUQVBEIHx8IENPTkZJR19BUCAqLwogCS5yZWFkX3N0YV9kYXRhID0gZHJpdmVyX25sODAyMTFfcmVhZF9zdGFfZGF0YSwKIAkuc2V0X2ZyZXEgPSBpODAyX3NldF9mcmVxLAogCS5zZW5kX2FjdGlvbiA9IGRyaXZlcl9ubDgwMjExX3NlbmRfYWN0aW9uLApAQCAtMTA4MzIsMTIgKzEyNDMwLDE3IEBACiAJLnVwZGF0ZV9mdF9pZXMgPSB3cGFfZHJpdmVyX25sODAyMTFfdXBkYXRlX2Z0X2llcywKIAkuZ2V0X21hY19hZGRyID0gd3BhX2RyaXZlcl9ubDgwMjExX2dldF9tYWNhZGRyLAogCS5nZXRfc3VydmV5ID0gd3BhX2RyaXZlcl9ubDgwMjExX2dldF9zdXJ2ZXksCisJLnN0YXR1cyA9IHdwYV9kcml2ZXJfbmw4MDIxMV9zdGF0dXMsCisJLnN3aXRjaF9jaGFubmVsID0gbmw4MDIxMV9zd2l0Y2hfY2hhbm5lbCwKICNpZmRlZiBBTkRST0lEX1AyUAogCS5zZXRfbm9hID0gd3BhX2RyaXZlcl9zZXRfcDJwX25vYSwKIAkuZ2V0X25vYSA9IHdwYV9kcml2ZXJfZ2V0X3AycF9ub2EsCiAJLnNldF9hcF93cHNfaWUgPSB3cGFfZHJpdmVyX3NldF9hcF93cHNfcDJwX2llLAotI2VuZGlmCisjZW5kaWYgLyogQU5EUk9JRF9QMlAgKi8KICNpZmRlZiBBTkRST0lECiAJLmRyaXZlcl9jbWQgPSB3cGFfZHJpdmVyX25sODAyMTFfZHJpdmVyX2NtZCwKLSNlbmRpZgorI2VuZGlmIC8qIEFORFJPSUQgKi8KKwkudmVuZG9yX2NtZCA9IG5sODAyMTFfdmVuZG9yX2NtZCwKKwkuc2V0X3Fvc19tYXAgPSBubDgwMjExX3NldF9xb3NfbWFwLAorCS5zZXRfd293bGFuID0gbmw4MDIxMV9zZXRfd293bGFuLAogfTsKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL2RyaXZlcl9yb2Jvc3dpdGNoLmMgYi9zcmMvZHJpdmVycy9kcml2ZXJfcm9ib3N3aXRjaC5jCmluZGV4IDBhOTA3OGEuLjljZTNmYTIgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl9yb2Jvc3dpdGNoLmMKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3JvYm9zd2l0Y2guYwpAQCAtMjYwLDE3ICsyNjAsMTcgQEAKIAkJCQkJICAgIFJPQk9fQVJMQ1RSTF9DT05GLCByZWFkMSwgMSk7CiAJfSBlbHNlIHsKIAkJLyogaWYgYm90aCBtdWx0aXBvcnQgYWRkcmVzc2VzIGFyZSB0aGUgc2FtZSB3ZSBjYW4gYWRkICovCi0JCXdwYV9kcml2ZXJfcm9ib3N3aXRjaF9yZWFkKGRydiwgUk9CT19BUkxDVFJMX1BBR0UsCi0JCQkJCSAgIFJPQk9fQVJMQ1RSTF9BRERSXzEsIHJlYWQxLCAzKTsKLQkJd3BhX2RyaXZlcl9yb2Jvc3dpdGNoX3JlYWQoZHJ2LCBST0JPX0FSTENUUkxfUEFHRSwKLQkJCQkJICAgUk9CT19BUkxDVFJMX0FERFJfMiwgcmVhZDIsIDMpOwotCQlpZiAob3NfbWVtY21wKHJlYWQxLCByZWFkMiwgNikgIT0gMCkKKwkJaWYgKHdwYV9kcml2ZXJfcm9ib3N3aXRjaF9yZWFkKGRydiwgUk9CT19BUkxDVFJMX1BBR0UsCisJCQkJCSAgICAgICBST0JPX0FSTENUUkxfQUREUl8xLCByZWFkMSwgMykgfHwKKwkJICAgIHdwYV9kcml2ZXJfcm9ib3N3aXRjaF9yZWFkKGRydiwgUk9CT19BUkxDVFJMX1BBR0UsCisJCQkJCSAgICAgICBST0JPX0FSTENUUkxfQUREUl8yLCByZWFkMiwgMykgfHwKKwkJICAgIG9zX21lbWNtcChyZWFkMSwgcmVhZDIsIDYpICE9IDApCiAJCQlyZXR1cm4gLTE7Ci0JCXdwYV9kcml2ZXJfcm9ib3N3aXRjaF9yZWFkKGRydiwgUk9CT19BUkxDVFJMX1BBR0UsCi0JCQkJCSAgIFJPQk9fQVJMQ1RSTF9WRUNfMSwgcmVhZDEsIDEpOwotCQl3cGFfZHJpdmVyX3JvYm9zd2l0Y2hfcmVhZChkcnYsIFJPQk9fQVJMQ1RSTF9QQUdFLAotCQkJCQkgICBST0JPX0FSTENUUkxfVkVDXzIsIHJlYWQyLCAxKTsKLQkJaWYgKHJlYWQxWzBdICE9IHJlYWQyWzBdKQorCQlpZiAod3BhX2RyaXZlcl9yb2Jvc3dpdGNoX3JlYWQoZHJ2LCBST0JPX0FSTENUUkxfUEFHRSwKKwkJCQkJICAgICAgIFJPQk9fQVJMQ1RSTF9WRUNfMSwgcmVhZDEsIDEpIHx8CisJCSAgICB3cGFfZHJpdmVyX3JvYm9zd2l0Y2hfcmVhZChkcnYsIFJPQk9fQVJMQ1RSTF9QQUdFLAorCQkJCQkgICAgICAgUk9CT19BUkxDVFJMX1ZFQ18yLCByZWFkMiwgMSkgfHwKKwkJICAgIHJlYWQxWzBdICE9IHJlYWQyWzBdKQogCQkJcmV0dXJuIC0xOwogCQl3cGFfZHJpdmVyX3JvYm9zd2l0Y2hfd3JpdGUoZHJ2LCBST0JPX0FSTENUUkxfUEFHRSwKIAkJCQkJICAgIFJPQk9fQVJMQ1RSTF9BRERSXzEsIGFkZHJfYmUxNiwgMyk7CmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9kcml2ZXJfdGVzdC5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3Rlc3QuYwppbmRleCA1NDFlYmNjLi4zNjA4YjUyIDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9kcml2ZXJfdGVzdC5jCisrKyBiL3NyYy9kcml2ZXJzL2RyaXZlcl90ZXN0LmMKQEAgLTI4LDcgKzI4LDYgQEAKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCiAjaW5jbHVkZSAiY3J5cHRvL3NoYTEuaCIKICNpbmNsdWRlICJsMl9wYWNrZXQvbDJfcGFja2V0LmgiCi0jaW5jbHVkZSAicDJwL3AycC5oIgogI2luY2x1ZGUgIndwcy93cHMuaCIKICNpbmNsdWRlICJkcml2ZXIuaCIKIApAQCAtMTAyLDIwICsxMDEsNiBAQAogCXVuc2lnbmVkIGludCByZW1haW5fb25fY2hhbm5lbF9kdXJhdGlvbjsKIAogCWludCBjdXJyZW50X2ZyZXE7Ci0KLQlzdHJ1Y3QgcDJwX2RhdGEgKnAycDsKLQl1bnNpZ25lZCBpbnQgb2ZmX2NoYW5uZWxfZnJlcTsKLQlzdHJ1Y3Qgd3BhYnVmICpwZW5kaW5nX2FjdGlvbl90eDsKLQl1OCBwZW5kaW5nX2FjdGlvbl9zcmNbRVRIX0FMRU5dOwotCXU4IHBlbmRpbmdfYWN0aW9uX2RzdFtFVEhfQUxFTl07Ci0JdTggcGVuZGluZ19hY3Rpb25fYnNzaWRbRVRIX0FMRU5dOwotCXVuc2lnbmVkIGludCBwZW5kaW5nX2FjdGlvbl9mcmVxOwotCXVuc2lnbmVkIGludCBwZW5kaW5nX2FjdGlvbl9ub19jY2s7Ci0JdW5zaWduZWQgaW50IHBlbmRpbmdfbGlzdGVuX2ZyZXE7Ci0JdW5zaWduZWQgaW50IHBlbmRpbmdfbGlzdGVuX2R1cmF0aW9uOwotCWludCBwZW5kaW5nX3AycF9zY2FuOwotCXN0cnVjdCBzb2NrYWRkciAqcHJvYmVfZnJvbTsKLQlzb2NrbGVuX3QgcHJvYmVfZnJvbV9sZW47CiB9OwogCiAKQEAgLTEyNSw3ICsxMTAsNiBAQAogc3RhdGljIHZvaWQgd3BhX2RyaXZlcl90ZXN0X2Nsb3NlX3Rlc3Rfc29ja2V0KAogCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2KTsKIHN0YXRpYyB2b2lkIHRlc3RfcmVtYWluX29uX2NoYW5uZWxfdGltZW91dCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KTsKLXN0YXRpYyBpbnQgd3BhX2RyaXZlcl90ZXN0X2luaXRfcDJwKHN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2KTsKIAogCiBzdGF0aWMgdm9pZCB0ZXN0X2RyaXZlcl9mcmVlX2JzcyhzdHJ1Y3QgdGVzdF9kcml2ZXJfYnNzICpic3MpCkBAIC00NzksMzQgKzQ2Myw2IEBACiAJZXZlbnQudHhfc3RhdHVzLmFjayA9IHJldCA+PSAwOwogCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9UWF9TVEFUVVMsICZldmVudCk7CiAKLSNpZmRlZiBDT05GSUdfUDJQCi0JaWYgKGRydi0+cDJwICYmCi0JICAgIFdMQU5fRkNfR0VUX1RZUEUoZmMpID09IFdMQU5fRkNfVFlQRV9NR01UICYmCi0JICAgIFdMQU5fRkNfR0VUX1NUWVBFKGZjKSA9PSBXTEFOX0ZDX1NUWVBFX0FDVElPTikgewotCQlpZiAoZHJ2LT5wZW5kaW5nX2FjdGlvbl90eCA9PSBOVUxMKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogSWdub3JlIEFjdGlvbiBUWCBzdGF0dXMgLSAiCi0JCQkJICAgIm5vIHBlbmRpbmcgb3BlcmF0aW9uIik7Ci0JCQlyZXR1cm4gcmV0OwotCQl9Ci0KLQkJaWYgKG9zX21lbWNtcChoZHItPmFkZHIxLCBkcnYtPnBlbmRpbmdfYWN0aW9uX2RzdCwgRVRIX0FMRU4pICE9Ci0JCSAgICAwKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogSWdub3JlIEFjdGlvbiBUWCBzdGF0dXMgLSAiCi0JCQkJICAgInVua25vd24gZGVzdGluYXRpb24gYWRkcmVzcyIpOwotCQkJcmV0dXJuIHJldDsKLQkJfQotCi0JCXdwYWJ1Zl9mcmVlKGRydi0+cGVuZGluZ19hY3Rpb25fdHgpOwotCQlkcnYtPnBlbmRpbmdfYWN0aW9uX3R4ID0gTlVMTDsKLQotCQlwMnBfc2VuZF9hY3Rpb25fY2IoZHJ2LT5wMnAsIGRydi0+cGVuZGluZ19hY3Rpb25fZnJlcSwKLQkJCQkgICBkcnYtPnBlbmRpbmdfYWN0aW9uX2RzdCwKLQkJCQkgICBkcnYtPnBlbmRpbmdfYWN0aW9uX3NyYywKLQkJCQkgICBkcnYtPnBlbmRpbmdfYWN0aW9uX2Jzc2lkLAotCQkJCSAgIHJldCA+PSAwKTsKLQl9Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwotCiAJcmV0dXJuIHJldDsKIH0KIApAQCAtNTUzLDEwICs1MDksNiBAQAogCQlldmVudC5yeF9wcm9iZV9yZXEuaWUgPSBpZTsKIAkJZXZlbnQucnhfcHJvYmVfcmVxLmllX2xlbiA9IGllbGVuOwogCQl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfUlhfUFJPQkVfUkVRLCAmZXZlbnQpOwotI2lmZGVmIENPTkZJR19QMlAKLQkJaWYgKGRydi0+cDJwKQotCQkJcDJwX3Byb2JlX3JlcV9yeChkcnYtPnAycCwgc2EsIE5VTEwsIE5VTEwsIGllLCBpZWxlbik7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCX0KIAogCWRsX2xpc3RfZm9yX2VhY2goYnNzLCAmZHJ2LT5ic3MsIHN0cnVjdCB0ZXN0X2RyaXZlcl9ic3MsIGxpc3QpIHsKQEAgLTEwNTksNyArMTAxMSw3IEBACiAJCQkgICAgICBjb25zdCBjaGFyICppZm5hbWUsIGNvbnN0IHU4ICphZGRyLAogCQkJICAgICAgdm9pZCAqYnNzX2N0eCwgdm9pZCAqKmRydl9wcml2LAogCQkJICAgICAgY2hhciAqZm9yY2VfaWZuYW1lLCB1OCAqaWZfYWRkciwKLQkJCSAgICAgIGNvbnN0IGNoYXIgKmJyaWRnZSkKKwkJCSAgICAgIGNvbnN0IGNoYXIgKmJyaWRnZSwgaW50IHVzZV9leGlzdGluZykKIHsKIAlzdHJ1Y3QgdGVzdF9kcml2ZXJfYnNzICpkYnNzID0gcHJpdjsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGRic3MtPmRydjsKQEAgLTEzMTMsMjUgKzEyNjUsNyBAQAogCiBzdGF0aWMgdm9pZCB3cGFfZHJpdmVyX3Rlc3Rfc2Nhbl90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCiB7Ci0Jc3RydWN0IHdwYV9kcml2ZXJfdGVzdF9kYXRhICpkcnYgPSBlbG9vcF9jdHg7CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTY2FuIHRpbWVvdXQgLSB0cnkgdG8gZ2V0IHJlc3VsdHMiKTsKLQlpZiAoZHJ2LT5wZW5kaW5nX3AycF9zY2FuICYmIGRydi0+cDJwKSB7Ci0jaWZkZWYgQ09ORklHX1AyUAotCQlzaXplX3QgaTsKLQkJc3RydWN0IG9zX3RpbWUgbm93OwotCQlvc19nZXRfdGltZSgmbm93KTsKLQkJZm9yIChpID0gMDsgaSA8IGRydi0+bnVtX3NjYW5yZXM7IGkrKykgewotCQkJc3RydWN0IHdwYV9zY2FuX3JlcyAqYnNzID0gZHJ2LT5zY2FucmVzW2ldOwotCQkJaWYgKHAycF9zY2FuX3Jlc19oYW5kbGVyKGRydi0+cDJwLCBic3MtPmJzc2lkLAotCQkJCQkJIGJzcy0+ZnJlcSwgJm5vdywgYnNzLT5sZXZlbCwKLQkJCQkJCSAoY29uc3QgdTggKikgKGJzcyArIDEpLAotCQkJCQkJIGJzcy0+aWVfbGVuKSA+IDApCi0JCQkJcmV0dXJuOwotCQl9Ci0JCXAycF9zY2FuX3Jlc19oYW5kbGVkKGRydi0+cDJwKTsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCi0JCXJldHVybjsKLQl9CiAJd3BhX3N1cHBsaWNhbnRfZXZlbnQodGltZW91dF9jdHgsIEVWRU5UX1NDQU5fUkVTVUxUUywgTlVMTCk7CiB9CiAKQEAgLTE1OTUsNyArMTUyOSw4IEBACiAjZW5kaWYgLyogRFJJVkVSX1RFU1RfVU5JWCAqLwogCiAJaWYgKHBhcmFtcy0+bW9kZSA9PSBJRUVFODAyMTFfTU9ERV9BUCkgewotCQlvc19tZW1jcHkoZGJzcy0+c3NpZCwgcGFyYW1zLT5zc2lkLCBwYXJhbXMtPnNzaWRfbGVuKTsKKwkJaWYgKHBhcmFtcy0+c3NpZCkKKwkJCW9zX21lbWNweShkYnNzLT5zc2lkLCBwYXJhbXMtPnNzaWQsIHBhcmFtcy0+c3NpZF9sZW4pOwogCQlkYnNzLT5zc2lkX2xlbiA9IHBhcmFtcy0+c3NpZF9sZW47CiAJCW9zX21lbWNweShkYnNzLT5ic3NpZCwgZHJ2LT5vd25fYWRkciwgRVRIX0FMRU4pOwogCQlpZiAocGFyYW1zLT53cGFfaWUgJiYgcGFyYW1zLT53cGFfaWVfbGVuKSB7CkBAIC0xNjE2LDggKzE1NTEsOSBAQAogCQkJCSAgTUFDMlNUUihkcnYtPm93bl9hZGRyKSk7CiAJCWlmIChyZXQgPj0gMCAmJiByZXQgPCBlbmQgLSBwb3MpCiAJCQlwb3MgKz0gcmV0OwotCQlwb3MgKz0gd3BhX3NucHJpbnRmX2hleChwb3MsIGVuZCAtIHBvcywgcGFyYW1zLT5zc2lkLAotCQkJCQlwYXJhbXMtPnNzaWRfbGVuKTsKKwkJaWYgKHBhcmFtcy0+c3NpZCkKKwkJCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLCBwYXJhbXMtPnNzaWQsCisJCQkJCQlwYXJhbXMtPnNzaWRfbGVuKTsKIAkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgIik7CiAJCWlmIChyZXQgPj0gMCAmJiByZXQgPCBlbmQgLSBwb3MpCiAJCQlwb3MgKz0gcmV0OwpAQCAtMTY0MSwxMiArMTU3NywxNSBAQAogCQkJcmV0dXJuIC0xOwogCQl9CiAKLQkJb3NfbWVtY3B5KGRic3MtPnNzaWQsIHBhcmFtcy0+c3NpZCwgcGFyYW1zLT5zc2lkX2xlbik7CisJCWlmIChwYXJhbXMtPnNzaWQpCisJCQlvc19tZW1jcHkoZGJzcy0+c3NpZCwgcGFyYW1zLT5zc2lkLCBwYXJhbXMtPnNzaWRfbGVuKTsKIAkJZGJzcy0+c3NpZF9sZW4gPSBwYXJhbXMtPnNzaWRfbGVuOwogCX0gZWxzZSB7CiAJCWRydi0+YXNzb2NpYXRlZCA9IDE7CiAJCWlmIChwYXJhbXMtPm1vZGUgPT0gSUVFRTgwMjExX01PREVfSUJTUykgewotCQkJb3NfbWVtY3B5KGRic3MtPnNzaWQsIHBhcmFtcy0+c3NpZCwgcGFyYW1zLT5zc2lkX2xlbik7CisJCQlpZiAocGFyYW1zLT5zc2lkKQorCQkJCW9zX21lbWNweShkYnNzLT5zc2lkLCBwYXJhbXMtPnNzaWQsCisJCQkJCSAgcGFyYW1zLT5zc2lkX2xlbik7CiAJCQlkYnNzLT5zc2lkX2xlbiA9IHBhcmFtcy0+c3NpZF9sZW47CiAJCQlpZiAocGFyYW1zLT5ic3NpZCkKIAkJCQlvc19tZW1jcHkoZGJzcy0+YnNzaWQsIHBhcmFtcy0+YnNzaWQsCkBAIC0xOTQ5LDMwICsxODg4LDggQEAKIAkJCQlkYXRhX2xlbiAtIChtZ210LT51LnByb2JlX3JlcS52YXJpYWJsZSAtIGRhdGEpOwogCQkJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX1JYX1BST0JFX1JFUSwKIAkJCQkJICAgICAmZXZlbnQpOwotI2lmZGVmIENPTkZJR19QMlAKLQkJCWlmIChkcnYtPnAycCkKLQkJCQlwMnBfcHJvYmVfcmVxX3J4KGRydi0+cDJwLCBtZ210LT5zYSwKLQkJCQkJCSBtZ210LT5kYSwgbWdtdC0+YnNzaWQsCi0JCQkJCQkgZXZlbnQucnhfcHJvYmVfcmVxLmllLAotCQkJCQkJIGV2ZW50LnJ4X3Byb2JlX3JlcS5pZV9sZW4pOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJfQogCX0KLQotI2lmZGVmIENPTkZJR19QMlAKLQlpZiAoZHJ2LT5wMnAgJiYKLQkgICAgV0xBTl9GQ19HRVRfVFlQRShmYykgPT0gV0xBTl9GQ19UWVBFX01HTVQgJiYKLQkgICAgV0xBTl9GQ19HRVRfU1RZUEUoZmMpID09IFdMQU5fRkNfU1RZUEVfQUNUSU9OKSB7Ci0JCXNpemVfdCBoZHJfbGVuOwotCQloZHJfbGVuID0gKGNvbnN0IHU4ICopCi0JCQkmbWdtdC0+dS5hY3Rpb24udS52c19wdWJsaWNfYWN0aW9uLmFjdGlvbiAtIGRhdGE7Ci0JCXAycF9yeF9hY3Rpb24oZHJ2LT5wMnAsIG1nbXQtPmRhLCBtZ210LT5zYSwgbWdtdC0+YnNzaWQsCi0JCQkgICAgICBtZ210LT51LmFjdGlvbi5jYXRlZ29yeSwKLQkJCSAgICAgICZtZ210LT51LmFjdGlvbi51LnZzX3B1YmxpY19hY3Rpb24uYWN0aW9uLAotCQkJICAgICAgZGF0YV9sZW4gLSBoZHJfbGVuLCBmcmVxKTsKLQl9Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwotCiB9CiAKIApAQCAtMTk4OCwzMSArMTkwNSw4IEBACiAJYnNzID0gZGxfbGlzdF9maXJzdCgmZHJ2LT5ic3MsIHN0cnVjdCB0ZXN0X2RyaXZlcl9ic3MsIGxpc3QpOwogCiAJLyogZGF0YTogb3B0aW9uYWwgWyBTVEEtYWRkciB8ICcgJyB8IElFcyhoZXgpIF0gKi8KLSNpZmRlZiBDT05GSUdfUDJQCi0JaWYgKGRydi0+cHJvYmVfcmVxX3JlcG9ydCAmJiBkcnYtPnAycCAmJiBkYXRhX2xlbikgewotCQljb25zdCBjaGFyICpkID0gKGNvbnN0IGNoYXIgKikgZGF0YTsKLQkJdTggc2FbRVRIX0FMRU5dOwotCQl1OCBpZVs1MTJdOwotCQlzaXplX3QgaWVsZW47CiAKLQkJaWYgKGh3YWRkcl9hdG9uKGQsIHNhKSkKLQkJCXJldHVybjsKLQkJZCArPSAxODsKLQkJd2hpbGUgKCpkID09ICcgJykKLQkJCWQrKzsKLQkJaWVsZW4gPSBvc19zdHJsZW4oZCkgLyAyOwotCQlpZiAoaWVsZW4gPiBzaXplb2YoaWUpKQotCQkJaWVsZW4gPSBzaXplb2YoaWUpOwotCQlpZiAoaGV4c3RyMmJpbihkLCBpZSwgaWVsZW4pIDwgMCkKLQkJCWllbGVuID0gMDsKLQkJZHJ2LT5wcm9iZV9mcm9tID0gZnJvbTsKLQkJZHJ2LT5wcm9iZV9mcm9tX2xlbiA9IGZyb21sZW47Ci0JCXAycF9wcm9iZV9yZXFfcngoZHJ2LT5wMnAsIHNhLCBOVUxMLCBOVUxMLCBpZSwgaWVsZW4pOwotCQlkcnYtPnByb2JlX2Zyb20gPSBOVUxMOwotCX0KLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCi0KLQlpZiAoIWRydi0+aWJzcykKKwlpZiAoYnNzID09IE5VTEwgfHwgIWRydi0+aWJzcykKIAkJcmV0dXJuOwogCiAJcG9zID0gYnVmOwpAQCAtMjE2NywxMiArMjA2MSw2IEBACiAJc3RydWN0IHRlc3RfY2xpZW50X3NvY2tldCAqY2xpLCAqcHJldjsKIAlpbnQgaTsKIAotI2lmZGVmIENPTkZJR19QMlAKLQlpZiAoZHJ2LT5wMnApCi0JCXAycF9kZWluaXQoZHJ2LT5wMnApOwotCXdwYWJ1Zl9mcmVlKGRydi0+cGVuZGluZ19hY3Rpb25fdHgpOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KLQogCWNsaSA9IGRydi0+Y2xpOwogCXdoaWxlIChjbGkpIHsKIAkJcHJldiA9IGNsaTsKQEAgLTIzNjksMTMgKzIyNTcsNiBAQAogCQlkcnYtPnVzZV9hc3NvY2luZm8gPSAxOwogCX0KIAotCWlmIChvc19zdHJzdHIocGFyYW0sICJwMnBfbWdtdD0xIikpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJ0ZXN0X2RyaXZlcjogVXNlIGludGVybmFsIFAyUCAiCi0JCQkgICAibWFuYWdlbWVudCIpOwotCQlpZiAod3BhX2RyaXZlcl90ZXN0X2luaXRfcDJwKGRydikgPCAwKQotCQkJcmV0dXJuIC0xOwotCX0KLQogCXJldHVybiAwOwogfQogCkBAIC0yNDY1LDggKzIzNDYsNiBAQAogCiBzdGF0aWMgaW50IHdwYV9kcml2ZXJfdGVzdF9nZXRfY2FwYSh2b2lkICpwcml2LCBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhKQogewotCXN0cnVjdCB0ZXN0X2RyaXZlcl9ic3MgKmRic3MgPSBwcml2OwotCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2ID0gZGJzcy0+ZHJ2OwogCW9zX21lbXNldChjYXBhLCAwLCBzaXplb2YoKmNhcGEpKTsKIAljYXBhLT5rZXlfbWdtdCA9IFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEEgfAogCQlXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfV1BBMiB8CkBAIC0yNDgyLDggKzIzNjEsNiBAQAogCWNhcGEtPmF1dGggPSBXUEFfRFJJVkVSX0FVVEhfT1BFTiB8CiAJCVdQQV9EUklWRVJfQVVUSF9TSEFSRUQgfAogCQlXUEFfRFJJVkVSX0FVVEhfTEVBUDsKLQlpZiAoZHJ2LT5wMnApCi0JCWNhcGEtPmZsYWdzIHw9IFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQ7CiAJY2FwYS0+ZmxhZ3MgfD0gV1BBX0RSSVZFUl9GTEFHU19BUDsKIAljYXBhLT5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9DT05DVVJSRU5UOwogCWNhcGEtPmZsYWdzIHw9IFdQQV9EUklWRVJfRkxBR1NfUDJQX0RFRElDQVRFRF9JTlRFUkZBQ0U7CkBAIC0yNjkxLDMzICsyNTY4LDYgQEAKIH0KIAogCi0jaWZkZWYgQ09ORklHX1AyUAotc3RhdGljIHZvaWQgdGVzdF9zZW5kX2FjdGlvbl9jYih2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQotewotCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2ID0gZWxvb3BfY3R4OwotCi0JaWYgKGRydi0+cGVuZGluZ19hY3Rpb25fdHggPT0gTlVMTCkKLQkJcmV0dXJuOwotCi0JaWYgKGRydi0+b2ZmX2NoYW5uZWxfZnJlcSAhPSBkcnYtPnBlbmRpbmdfYWN0aW9uX2ZyZXEpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFBlbmRpbmcgQWN0aW9uIGZyYW1lIFRYICIKLQkJCSAgICJ3YWl0aW5nIGZvciBhbm90aGVyIGZyZXE9JXUiLAotCQkJICAgZHJ2LT5wZW5kaW5nX2FjdGlvbl9mcmVxKTsKLQkJcmV0dXJuOwotCX0KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogU2VuZGluZyBwZW5kaW5nIEFjdGlvbiBmcmFtZSB0byAiCi0JCSAgIE1BQ1NUUiwgTUFDMlNUUihkcnYtPnBlbmRpbmdfYWN0aW9uX2RzdCkpOwotCXdwYV9kcml2ZXJfdGVzdF9zZW5kX2FjdGlvbihkcnYsIGRydi0+cGVuZGluZ19hY3Rpb25fZnJlcSwgMCwKLQkJCQkgICAgZHJ2LT5wZW5kaW5nX2FjdGlvbl9kc3QsCi0JCQkJICAgIGRydi0+cGVuZGluZ19hY3Rpb25fc3JjLAotCQkJCSAgICBkcnYtPnBlbmRpbmdfYWN0aW9uX2Jzc2lkLAotCQkJCSAgICB3cGFidWZfaGVhZChkcnYtPnBlbmRpbmdfYWN0aW9uX3R4KSwKLQkJCQkgICAgd3BhYnVmX2xlbihkcnYtPnBlbmRpbmdfYWN0aW9uX3R4KSwKLQkJCQkgICAgZHJ2LT5wZW5kaW5nX2FjdGlvbl9ub19jY2spOwotfQotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KLQotCiBzdGF0aWMgdm9pZCB0ZXN0X3JlbWFpbl9vbl9jaGFubmVsX3RpbWVvdXQodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKIHsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGVsb29wX2N0eDsKQEAgLTI3MjksOSArMjU3OSw2IEBACiAJZGF0YS5yZW1haW5fb25fY2hhbm5lbC5mcmVxID0gZHJ2LT5yZW1haW5fb25fY2hhbm5lbF9mcmVxOwogCWRhdGEucmVtYWluX29uX2NoYW5uZWwuZHVyYXRpb24gPSBkcnYtPnJlbWFpbl9vbl9jaGFubmVsX2R1cmF0aW9uOwogCi0JaWYgKGRydi0+cDJwKQotCQlkcnYtPm9mZl9jaGFubmVsX2ZyZXEgPSAwOwotCiAJZHJ2LT5yZW1haW5fb25fY2hhbm5lbF9mcmVxID0gMDsKIAogCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9DQU5DRUxfUkVNQUlOX09OX0NIQU5ORUwsICZkYXRhKTsKQEAgLTI3NjUsMTggKzI2MTIsNiBAQAogCWRhdGEucmVtYWluX29uX2NoYW5uZWwuZHVyYXRpb24gPSBkdXJhdGlvbjsKIAl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfUkVNQUlOX09OX0NIQU5ORUwsICZkYXRhKTsKIAotI2lmZGVmIENPTkZJR19QMlAKLQlpZiAoZHJ2LT5wMnApIHsKLQkJZHJ2LT5vZmZfY2hhbm5lbF9mcmVxID0gZHJ2LT5yZW1haW5fb25fY2hhbm5lbF9mcmVxOwotCQl0ZXN0X3NlbmRfYWN0aW9uX2NiKGRydiwgTlVMTCk7Ci0JCWlmIChkcnYtPm9mZl9jaGFubmVsX2ZyZXEgPT0gZHJ2LT5wZW5kaW5nX2xpc3Rlbl9mcmVxKSB7Ci0JCQlwMnBfbGlzdGVuX2NiKGRydi0+cDJwLCBkcnYtPnBlbmRpbmdfbGlzdGVuX2ZyZXEsCi0JCQkJICAgICAgZHJ2LT5wZW5kaW5nX2xpc3Rlbl9kdXJhdGlvbik7Ci0JCQlkcnYtPnBlbmRpbmdfbGlzdGVuX2ZyZXEgPSAwOwotCQl9Ci0JfQotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KLQogCXJldHVybiAwOwogfQogCkBAIC0yODA0LDQ3MCArMjYzOSw2IEBACiB9CiAKIAotI2lmZGVmIENPTkZJR19QMlAKLQotc3RhdGljIGludCB3cGFfZHJpdmVyX3Rlc3RfcDJwX2ZpbmQodm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IHRpbWVvdXQsIGludCB0eXBlKQotewotCXN0cnVjdCB0ZXN0X2RyaXZlcl9ic3MgKmRic3MgPSBwcml2OwotCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2ID0gZGJzcy0+ZHJ2OwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXModGltZW91dD0ldSkiLCBfX2Z1bmNfXywgdGltZW91dCk7Ci0JaWYgKCFkcnYtPnAycCkKLQkJcmV0dXJuIC0xOwotCXJldHVybiBwMnBfZmluZChkcnYtPnAycCwgdGltZW91dCwgdHlwZSwgMCwgTlVMTCwgTlVMTCwgMCk7Ci19Ci0KLQotc3RhdGljIGludCB3cGFfZHJpdmVyX3Rlc3RfcDJwX3N0b3BfZmluZCh2b2lkICpwcml2KQotewotCXN0cnVjdCB0ZXN0X2RyaXZlcl9ic3MgKmRic3MgPSBwcml2OwotCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2ID0gZGJzcy0+ZHJ2OwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMiLCBfX2Z1bmNfXyk7Ci0JaWYgKCFkcnYtPnAycCkKLQkJcmV0dXJuIC0xOwotCXAycF9zdG9wX2ZpbmQoZHJ2LT5wMnApOwotCXJldHVybiAwOwotfQotCi0KLXN0YXRpYyBpbnQgd3BhX2RyaXZlcl90ZXN0X3AycF9saXN0ZW4odm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IHRpbWVvdXQpCi17Ci0Jc3RydWN0IHRlc3RfZHJpdmVyX2JzcyAqZGJzcyA9IHByaXY7Ci0Jc3RydWN0IHdwYV9kcml2ZXJfdGVzdF9kYXRhICpkcnYgPSBkYnNzLT5kcnY7Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyh0aW1lb3V0PSV1KSIsIF9fZnVuY19fLCB0aW1lb3V0KTsKLQlpZiAoIWRydi0+cDJwKQotCQlyZXR1cm4gLTE7Ci0JcmV0dXJuIHAycF9saXN0ZW4oZHJ2LT5wMnAsIHRpbWVvdXQpOwotfQotCi0KLXN0YXRpYyBpbnQgd3BhX2RyaXZlcl90ZXN0X3AycF9jb25uZWN0KHZvaWQgKnByaXYsIGNvbnN0IHU4ICpwZWVyX2FkZHIsCi0JCQkJICAgICAgIGludCB3cHNfbWV0aG9kLCBpbnQgZ29faW50ZW50LAotCQkJCSAgICAgICBjb25zdCB1OCAqb3duX2ludGVyZmFjZV9hZGRyLAotCQkJCSAgICAgICB1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwKLQkJCQkgICAgICAgaW50IHBlcnNpc3RlbnRfZ3JvdXApCi17Ci0Jc3RydWN0IHRlc3RfZHJpdmVyX2JzcyAqZGJzcyA9IHByaXY7Ci0Jc3RydWN0IHdwYV9kcml2ZXJfdGVzdF9kYXRhICpkcnYgPSBkYnNzLT5kcnY7Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyhwZWVyX2FkZHI9IiBNQUNTVFIgIiB3cHNfbWV0aG9kPSVkICIKLQkJICAgImdvX2ludGVudD0lZCAiCi0JCSAgICJvd25faW50ZXJmYWNlX2FkZHI9IiBNQUNTVFIgIiBmb3JjZV9mcmVxPSV1ICIKLQkJICAgInBlcnNpc3RlbnRfZ3JvdXA9JWQpIiwKLQkJICAgX19mdW5jX18sIE1BQzJTVFIocGVlcl9hZGRyKSwgd3BzX21ldGhvZCwgZ29faW50ZW50LAotCQkgICBNQUMyU1RSKG93bl9pbnRlcmZhY2VfYWRkciksIGZvcmNlX2ZyZXEsIHBlcnNpc3RlbnRfZ3JvdXApOwotCWlmICghZHJ2LT5wMnApCi0JCXJldHVybiAtMTsKLQlyZXR1cm4gcDJwX2Nvbm5lY3QoZHJ2LT5wMnAsIHBlZXJfYWRkciwgd3BzX21ldGhvZCwgZ29faW50ZW50LAotCQkJICAgb3duX2ludGVyZmFjZV9hZGRyLCBmb3JjZV9mcmVxLCBwZXJzaXN0ZW50X2dyb3VwLAotCQkJICAgTlVMTCwgMCwgMCwgMCk7Ci19Ci0KLQotc3RhdGljIGludCB3cGFfZHJpdmVyX3Rlc3Rfd3BzX3N1Y2Nlc3NfY2Iodm9pZCAqcHJpdiwgY29uc3QgdTggKnBlZXJfYWRkcikKLXsKLQlzdHJ1Y3QgdGVzdF9kcml2ZXJfYnNzICpkYnNzID0gcHJpdjsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGRic3MtPmRydjsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzKHBlZXJfYWRkcj0iIE1BQ1NUUiAiKSIsCi0JCSAgIF9fZnVuY19fLCBNQUMyU1RSKHBlZXJfYWRkcikpOwotCWlmICghZHJ2LT5wMnApCi0JCXJldHVybiAtMTsKLQlwMnBfd3BzX3N1Y2Nlc3NfY2IoZHJ2LT5wMnAsIHBlZXJfYWRkcik7Ci0JcmV0dXJuIDA7Ci19Ci0KLQotc3RhdGljIGludCB3cGFfZHJpdmVyX3Rlc3RfcDJwX2dyb3VwX2Zvcm1hdGlvbl9mYWlsZWQodm9pZCAqcHJpdikKLXsKLQlzdHJ1Y3QgdGVzdF9kcml2ZXJfYnNzICpkYnNzID0gcHJpdjsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGRic3MtPmRydjsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIiwgX19mdW5jX18pOwotCWlmICghZHJ2LT5wMnApCi0JCXJldHVybiAtMTsKLQlwMnBfZ3JvdXBfZm9ybWF0aW9uX2ZhaWxlZChkcnYtPnAycCk7Ci0JcmV0dXJuIDA7Ci19Ci0KLQotc3RhdGljIGludCB3cGFfZHJpdmVyX3Rlc3RfcDJwX3NldF9wYXJhbXModm9pZCAqcHJpdiwKLQkJCQkJICBjb25zdCBzdHJ1Y3QgcDJwX3BhcmFtcyAqcGFyYW1zKQotewotCXN0cnVjdCB0ZXN0X2RyaXZlcl9ic3MgKmRic3MgPSBwcml2OwotCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2ID0gZGJzcy0+ZHJ2OwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMiLCBfX2Z1bmNfXyk7Ci0JaWYgKCFkcnYtPnAycCkKLQkJcmV0dXJuIC0xOwotCWlmIChwMnBfc2V0X2Rldl9uYW1lKGRydi0+cDJwLCBwYXJhbXMtPmRldl9uYW1lKSA8IDAgfHwKLQkgICAgcDJwX3NldF9wcmlfZGV2X3R5cGUoZHJ2LT5wMnAsIHBhcmFtcy0+cHJpX2Rldl90eXBlKSA8IDAgfHwKLQkgICAgcDJwX3NldF9zZWNfZGV2X3R5cGVzKGRydi0+cDJwLCBwYXJhbXMtPnNlY19kZXZfdHlwZSwKLQkJCQkgIHBhcmFtcy0+bnVtX3NlY19kZXZfdHlwZXMpIDwgMCkKLQkJcmV0dXJuIC0xOwotCXJldHVybiAwOwotfQotCi0KLXN0YXRpYyBpbnQgdGVzdF9wMnBfc2Nhbih2b2lkICpjdHgsIGVudW0gcDJwX3NjYW5fdHlwZSB0eXBlLCBpbnQgZnJlcSwKLQkJCSB1bnNpZ25lZCBpbnQgbnVtX3JlcV9kZXZfdHlwZXMsCi0JCQkgY29uc3QgdTggKnJlcV9kZXZfdHlwZXMsIGNvbnN0IHU4ICpkZXZfaWQsIHUxNiBwd19pZCkKLXsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGN0eDsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7Ci0JaW50IHJldDsKLQlzdHJ1Y3Qgd3BhYnVmICp3cHNfaWUsICppZXM7Ci0JaW50IHNvY2lhbF9jaGFubmVsc1tdID0geyAyNDEyLCAyNDM3LCAyNDYyLCAwLCAwIH07Ci0Jc2l6ZV90IGllbGVuOwotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyh0eXBlPSVkIGZyZXE9JWQpIiwKLQkJICAgX19mdW5jX18sIHR5cGUsIGZyZXEpOwotCi0Jb3NfbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKLQotCS8qIFAyUCBXaWxkY2FyZCBTU0lEICovCi0JcGFyYW1zLm51bV9zc2lkcyA9IDE7Ci0JcGFyYW1zLnNzaWRzWzBdLnNzaWQgPSAodTggKikgUDJQX1dJTERDQVJEX1NTSUQ7Ci0JcGFyYW1zLnNzaWRzWzBdLnNzaWRfbGVuID0gUDJQX1dJTERDQVJEX1NTSURfTEVOOwotCi0jaWYgMCAvKiBUT0RPOiBXUFMgSUUgKi8KLQl3cGFfcy0+d3BzLT5kZXYucDJwID0gMTsKLQl3cHNfaWUgPSB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKHB3X2lkLCAmd3BhX3MtPndwcy0+ZGV2LAotCQkJCQl3cGFfcy0+d3BzLT51dWlkLCBXUFNfUkVRX0VOUk9MTEVFKTsKLSNlbHNlCi0Jd3BzX2llID0gd3BhYnVmX2FsbG9jKDEpOwotI2VuZGlmCi0JaWYgKHdwc19pZSA9PSBOVUxMKQotCQlyZXR1cm4gLTE7Ci0KLQlpZWxlbiA9IHAycF9zY2FuX2llX2J1Zl9sZW4oZHJ2LT5wMnApOwotCWllcyA9IHdwYWJ1Zl9hbGxvYyh3cGFidWZfbGVuKHdwc19pZSkgKyBpZWxlbik7Ci0JaWYgKGllcyA9PSBOVUxMKSB7Ci0JCXdwYWJ1Zl9mcmVlKHdwc19pZSk7Ci0JCXJldHVybiAtMTsKLQl9Ci0Jd3BhYnVmX3B1dF9idWYoaWVzLCB3cHNfaWUpOwotCXdwYWJ1Zl9mcmVlKHdwc19pZSk7Ci0KLQlwMnBfc2Nhbl9pZShkcnYtPnAycCwgaWVzLCBkZXZfaWQpOwotCi0JcGFyYW1zLmV4dHJhX2llcyA9IHdwYWJ1Zl9oZWFkKGllcyk7Ci0JcGFyYW1zLmV4dHJhX2llc19sZW4gPSB3cGFidWZfbGVuKGllcyk7Ci0KLQlzd2l0Y2ggKHR5cGUpIHsKLQljYXNlIFAyUF9TQ0FOX1NPQ0lBTDoKLQkJcGFyYW1zLmZyZXFzID0gc29jaWFsX2NoYW5uZWxzOwotCQlicmVhazsKLQljYXNlIFAyUF9TQ0FOX0ZVTEw6Ci0JCWJyZWFrOwotCWNhc2UgUDJQX1NDQU5fU09DSUFMX1BMVVNfT05FOgotCQlzb2NpYWxfY2hhbm5lbHNbM10gPSBmcmVxOwotCQlwYXJhbXMuZnJlcXMgPSBzb2NpYWxfY2hhbm5lbHM7Ci0JCWJyZWFrOwotCX0KLQotCWRydi0+cGVuZGluZ19wMnBfc2NhbiA9IDE7Ci0JcmV0ID0gd3BhX2RyaXZlcl90ZXN0X3NjYW4oZHJ2LCAmcGFyYW1zKTsKLQotCXdwYWJ1Zl9mcmVlKGllcyk7Ci0KLQlyZXR1cm4gcmV0OwotfQotCi0KLXN0YXRpYyBpbnQgdGVzdF9zZW5kX2FjdGlvbih2b2lkICpjdHgsIHVuc2lnbmVkIGludCBmcmVxLCBjb25zdCB1OCAqZHN0LAotCQkJICAgIGNvbnN0IHU4ICpzcmMsIGNvbnN0IHU4ICpic3NpZCwgY29uc3QgdTggKmJ1ZiwKLQkJCSAgICBzaXplX3QgbGVuLCB1bnNpZ25lZCBpbnQgd2FpdF90aW1lKQotewotCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2ID0gY3R4OwotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyhmcmVxPSV1IGRzdD0iIE1BQ1NUUiAiIHNyYz0iIE1BQ1NUUgotCQkgICAiIGJzc2lkPSIgTUFDU1RSICIgbGVuPSVkIiwKLQkJICAgX19mdW5jX18sIGZyZXEsIE1BQzJTVFIoZHN0KSwgTUFDMlNUUihzcmMpLCBNQUMyU1RSKGJzc2lkKSwKLQkJICAgKGludCkgbGVuKTsKLQlpZiAoZnJlcSA8PSAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJQMlA6IE5vIGZyZXF1ZW5jeSBzcGVjaWZpZWQgZm9yICIKLQkJCSAgICJhY3Rpb24gZnJhbWUgVFgiKTsKLQkJcmV0dXJuIC0xOwotCX0KLQotCWlmIChkcnYtPnBlbmRpbmdfYWN0aW9uX3R4KSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBEcm9wcGVkIHBlbmRpbmcgQWN0aW9uIGZyYW1lIFRYICIKLQkJCSAgICJ0byAiIE1BQ1NUUiwgTUFDMlNUUihkcnYtPnBlbmRpbmdfYWN0aW9uX2RzdCkpOwotCQl3cGFidWZfZnJlZShkcnYtPnBlbmRpbmdfYWN0aW9uX3R4KTsKLQl9Ci0JZHJ2LT5wZW5kaW5nX2FjdGlvbl90eCA9IHdwYWJ1Zl9hbGxvYyhsZW4pOwotCWlmIChkcnYtPnBlbmRpbmdfYWN0aW9uX3R4ID09IE5VTEwpCi0JCXJldHVybiAtMTsKLQl3cGFidWZfcHV0X2RhdGEoZHJ2LT5wZW5kaW5nX2FjdGlvbl90eCwgYnVmLCBsZW4pOwotCW9zX21lbWNweShkcnYtPnBlbmRpbmdfYWN0aW9uX3NyYywgc3JjLCBFVEhfQUxFTik7Ci0Jb3NfbWVtY3B5KGRydi0+cGVuZGluZ19hY3Rpb25fZHN0LCBkc3QsIEVUSF9BTEVOKTsKLQlvc19tZW1jcHkoZHJ2LT5wZW5kaW5nX2FjdGlvbl9ic3NpZCwgYnNzaWQsIEVUSF9BTEVOKTsKLQlkcnYtPnBlbmRpbmdfYWN0aW9uX2ZyZXEgPSBmcmVxOwotCWRydi0+cGVuZGluZ19hY3Rpb25fbm9fY2NrID0gMTsKLQotCWlmIChkcnYtPm9mZl9jaGFubmVsX2ZyZXEgPT0gZnJlcSkgewotCQkvKiBBbHJlYWR5IG9uIHJlcXVlc3RlZCBjaGFubmVsOyBzZW5kIGltbWVkaWF0ZWx5ICovCi0JCS8qIFRPRE86IFdvdWxkIHRoZXJlIGV2ZXIgYmUgbmVlZCB0byBleHRlbmQgdGhlIGN1cnJlbnQKLQkJICogZHVyYXRpb24gb24gdGhlIGNoYW5uZWw/ICovCi0JCWVsb29wX2NhbmNlbF90aW1lb3V0KHRlc3Rfc2VuZF9hY3Rpb25fY2IsIGRydiwgTlVMTCk7Ci0JCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMCwgMCwgdGVzdF9zZW5kX2FjdGlvbl9jYiwgZHJ2LCBOVUxMKTsKLQkJcmV0dXJuIDA7Ci0JfQotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNjaGVkdWxlIEFjdGlvbiBmcmFtZSB0byBiZSB0cmFuc21pdHRlZCAiCi0JCSAgICJvbmNlIHRoZSBkcml2ZXIgZ2V0cyB0byB0aGUgcmVxdWVzdGVkIGNoYW5uZWwiKTsKLQlpZiAod3BhX2RyaXZlcl90ZXN0X3JlbWFpbl9vbl9jaGFubmVsKGRydiwgZnJlcSwgd2FpdF90aW1lKSA8IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEZhaWxlZCB0byByZXF1ZXN0IGRyaXZlciAiCi0JCQkgICAidG8gcmVtYWluIG9uIGNoYW5uZWwgKCV1IE1IeikgZm9yIEFjdGlvbiAiCi0JCQkgICAiRnJhbWUgVFgiLCBmcmVxKTsKLQkJcmV0dXJuIC0xOwotCX0KLQotCXJldHVybiAwOwotfQotCi0KLXN0YXRpYyB2b2lkIHRlc3Rfc2VuZF9hY3Rpb25fZG9uZSh2b2lkICpjdHgpCi17Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyIsIF9fZnVuY19fKTsKLQkvKiBUT0RPICovCi19Ci0KLQotc3RhdGljIHZvaWQgdGVzdF9nb19uZWdfY29tcGxldGVkKHZvaWQgKmN0eCwgc3RydWN0IHAycF9nb19uZWdfcmVzdWx0cyAqcmVzKQotewotCXN0cnVjdCB3cGFfZHJpdmVyX3Rlc3RfZGF0YSAqZHJ2ID0gY3R4OwotCXVuaW9uIHdwYV9ldmVudF9kYXRhIGV2ZW50OwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMiLCBfX2Z1bmNfXyk7Ci0Jb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7Ci0JZXZlbnQucDJwX2dvX25lZ19jb21wbGV0ZWQucmVzID0gcmVzOwotCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9QMlBfR09fTkVHX0NPTVBMRVRFRCwgJmV2ZW50KTsKLX0KLQotCi1zdGF0aWMgdm9pZCB0ZXN0X2dvX25lZ19yZXFfcngodm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjLCB1MTYgZGV2X3Bhc3N3ZF9pZCkKLXsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGN0eDsKLQl1bmlvbiB3cGFfZXZlbnRfZGF0YSBldmVudDsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzKHNyYz0iIE1BQ1NUUiAiKSIsIF9fZnVuY19fLCBNQUMyU1RSKHNyYykpOwotCW9zX21lbXNldCgmZXZlbnQsIDAsIHNpemVvZihldmVudCkpOwotCWV2ZW50LnAycF9nb19uZWdfcmVxX3J4LnNyYyA9IHNyYzsKLQlldmVudC5wMnBfZ29fbmVnX3JlcV9yeC5kZXZfcGFzc3dkX2lkID0gZGV2X3Bhc3N3ZF9pZDsKLQl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfUDJQX0dPX05FR19SRVFfUlgsICZldmVudCk7Ci19Ci0KLQotc3RhdGljIHZvaWQgdGVzdF9kZXZfZm91bmQodm9pZCAqY3R4LCBjb25zdCB1OCAqYWRkciwKLQkJCSAgIGNvbnN0IHN0cnVjdCBwMnBfcGVlcl9pbmZvICppbmZvLCBpbnQgbmV3X2RldmljZSkKLXsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGN0eDsKLQl1bmlvbiB3cGFfZXZlbnRfZGF0YSBldmVudDsKLQljaGFyIGRldnR5cGVbV1BTX0RFVl9UWVBFX0JVRlNJWkVdOwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMoIiBNQUNTVFIgIiBwMnBfZGV2X2FkZHI9IiBNQUNTVFIKLQkJICAgIiBwcmlfZGV2X3R5cGU9JXMgbmFtZT0nJXMnIGNvbmZpZ19tZXRob2RzPTB4JXggIgotCQkgICAiZGV2X2NhcGFiPTB4JXggZ3JvdXBfY2FwYWI9MHgleCkiLAotCQkgICBfX2Z1bmNfXywgTUFDMlNUUihhZGRyKSwgTUFDMlNUUihpbmZvLT5wMnBfZGV2aWNlX2FkZHIpLAotCQkgICB3cHNfZGV2X3R5cGVfYmluMnN0cihpbmZvLT5wcmlfZGV2X3R5cGUsIGRldnR5cGUsCi0JCQkJCXNpemVvZihkZXZ0eXBlKSksCi0JCSAgIGluZm8tPmRldmljZV9uYW1lLCBpbmZvLT5jb25maWdfbWV0aG9kcywgaW5mby0+ZGV2X2NhcGFiLAotCQkgICBpbmZvLT5ncm91cF9jYXBhYik7Ci0KLQlvc19tZW1zZXQoJmV2ZW50LCAwLCBzaXplb2YoZXZlbnQpKTsKLQlldmVudC5wMnBfZGV2X2ZvdW5kLmFkZHIgPSBhZGRyOwotCWV2ZW50LnAycF9kZXZfZm91bmQuZGV2X2FkZHIgPSBpbmZvLT5wMnBfZGV2aWNlX2FkZHI7Ci0JZXZlbnQucDJwX2Rldl9mb3VuZC5wcmlfZGV2X3R5cGUgPSBpbmZvLT5wcmlfZGV2X3R5cGU7Ci0JZXZlbnQucDJwX2Rldl9mb3VuZC5kZXZfbmFtZSA9IGluZm8tPmRldmljZV9uYW1lOwotCWV2ZW50LnAycF9kZXZfZm91bmQuY29uZmlnX21ldGhvZHMgPSBpbmZvLT5jb25maWdfbWV0aG9kczsKLQlldmVudC5wMnBfZGV2X2ZvdW5kLmRldl9jYXBhYiA9IGluZm8tPmRldl9jYXBhYjsKLQlldmVudC5wMnBfZGV2X2ZvdW5kLmdyb3VwX2NhcGFiID0gaW5mby0+Z3JvdXBfY2FwYWI7Ci0Jd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX1AyUF9ERVZfRk9VTkQsICZldmVudCk7Ci19Ci0KLQotc3RhdGljIGludCB0ZXN0X3N0YXJ0X2xpc3Rlbih2b2lkICpjdHgsIHVuc2lnbmVkIGludCBmcmVxLAotCQkJICAgICB1bnNpZ25lZCBpbnQgZHVyYXRpb24sCi0JCQkgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnByb2JlX3Jlc3BfaWUpCi17Ci0Jc3RydWN0IHdwYV9kcml2ZXJfdGVzdF9kYXRhICpkcnYgPSBjdHg7Ci0KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzKGZyZXE9JXUgZHVyYXRpb249JXUpIiwKLQkJICAgX19mdW5jX18sIGZyZXEsIGR1cmF0aW9uKTsKLQotCWlmICh3cGFfZHJpdmVyX3Rlc3RfcHJvYmVfcmVxX3JlcG9ydChkcnYsIDEpIDwgMCkKLQkJcmV0dXJuIC0xOwotCi0JZHJ2LT5wZW5kaW5nX2xpc3Rlbl9mcmVxID0gZnJlcTsKLQlkcnYtPnBlbmRpbmdfbGlzdGVuX2R1cmF0aW9uID0gZHVyYXRpb247Ci0KLQlpZiAod3BhX2RyaXZlcl90ZXN0X3JlbWFpbl9vbl9jaGFubmVsKGRydiwgZnJlcSwgZHVyYXRpb24pIDwgMCkgewotCQlkcnYtPnBlbmRpbmdfbGlzdGVuX2ZyZXEgPSAwOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLQotc3RhdGljIHZvaWQgdGVzdF9zdG9wX2xpc3Rlbih2b2lkICpjdHgpCi17Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyIsIF9fZnVuY19fKTsKLQkvKiBUT0RPICovCi19Ci0KLQotc3RhdGljIGludCB0ZXN0X3NlbmRfcHJvYmVfcmVzcCh2b2lkICpjdHgsIGNvbnN0IHN0cnVjdCB3cGFidWYgKmJ1ZikKLXsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGN0eDsKLQljaGFyIHJlc3BbNTEyXSwgKnBvcywgKmVuZDsKLQlpbnQgcmV0OwotCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKLQljb25zdCB1OCAqaWUsICppZV9lbmQ7Ci0KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIiwgX19mdW5jX18pOwotCXdwYV9oZXhkdW1wX2J1ZihNU0dfTVNHRFVNUCwgIlByb2JlIFJlc3BvbnNlIiwgYnVmKTsKLQlpZiAod3BhYnVmX2xlbihidWYpIDwgMjQpCi0JCXJldHVybiAtMTsKLQlpZiAoIWRydi0+cHJvYmVfZnJvbSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBwcm9iZV9mcm9tIG5vdCBzZXQiLCBfX2Z1bmNfXyk7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlwb3MgPSByZXNwOwotCWVuZCA9IHJlc3AgKyBzaXplb2YocmVzcCk7Ci0KLQltZ210ID0gd3BhYnVmX2hlYWQoYnVmKTsKLQotCS8qIHJlcGx5OiBTQ0FOUkVTUCBCU1NJRCBTU0lEIElFcyAqLwotCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiU0NBTlJFU1AgIiBNQUNTVFIgIiAiLAotCQkJICBNQUMyU1RSKG1nbXQtPmJzc2lkKSk7Ci0JaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKLQkJcmV0dXJuIC0xOwotCXBvcyArPSByZXQ7Ci0KLQlpZSA9IG1nbXQtPnUucHJvYmVfcmVzcC52YXJpYWJsZTsKLQlpZV9lbmQgPSB3cGFidWZfaGVhZF91OChidWYpICsgd3BhYnVmX2xlbihidWYpOwotCWlmIChpZV9lbmQgLSBpZSA8IDIgfHwgaWVbMF0gIT0gV0xBTl9FSURfU1NJRCB8fAotCSAgICBpZSArIDIgKyBpZVsxXSA+IGllX2VuZCkKLQkJcmV0dXJuIC0xOwotCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLCBpZSArIDIsIGllWzFdKTsKLQotCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiICIpOwotCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCi0JCXJldHVybiAtMTsKLQlwb3MgKz0gcmV0OwotCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLCBpZSwgaWVfZW5kIC0gaWUpOwotCi0Jc2VuZHRvKGRydi0+dGVzdF9zb2NrZXQsIHJlc3AsIHBvcyAtIHJlc3AsIDAsCi0JICAgICAgIGRydi0+cHJvYmVfZnJvbSwgZHJ2LT5wcm9iZV9mcm9tX2xlbik7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi1zdGF0aWMgdm9pZCB0ZXN0X3NkX3JlcXVlc3Qodm9pZCAqY3R4LCBpbnQgZnJlcSwgY29uc3QgdTggKnNhLCB1OCBkaWFsb2dfdG9rZW4sCi0JCQkgICAgdTE2IHVwZGF0ZV9pbmRpYywgY29uc3QgdTggKnRsdnMsIHNpemVfdCB0bHZzX2xlbikKLXsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIiwgX19mdW5jX18pOwotCS8qIFRPRE8gKi8KLX0KLQotCi1zdGF0aWMgdm9pZCB0ZXN0X3NkX3Jlc3BvbnNlKHZvaWQgKmN0eCwgY29uc3QgdTggKnNhLCB1MTYgdXBkYXRlX2luZGljLAotCQkJICAgICBjb25zdCB1OCAqdGx2cywgc2l6ZV90IHRsdnNfbGVuKQotewotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMiLCBfX2Z1bmNfXyk7Ci0JLyogVE9ETyAqLwotfQotCi0KLXN0YXRpYyB2b2lkIHRlc3RfcHJvdl9kaXNjX3JlcSh2b2lkICpjdHgsIGNvbnN0IHU4ICpwZWVyLCB1MTYgY29uZmlnX21ldGhvZHMsCi0JCQkgICAgICAgY29uc3QgdTggKmRldl9hZGRyLCBjb25zdCB1OCAqcHJpX2Rldl90eXBlLAotCQkJICAgICAgIGNvbnN0IGNoYXIgKmRldl9uYW1lLCB1MTYgc3VwcF9jb25maWdfbWV0aG9kcywKLQkJCSAgICAgICB1OCBkZXZfY2FwYWIsIHU4IGdyb3VwX2NhcGFiLAotCQkJICAgICAgIGNvbnN0IHU4ICpncm91cF9pZCwgc2l6ZV90IGdyb3VwX2lkX2xlbikKLXsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzKHBlZXI9IiBNQUNTVFIgIiBjb25maWdfbWV0aG9kcz0weCV4KSIsCi0JCSAgIF9fZnVuY19fLCBNQUMyU1RSKHBlZXIpLCBjb25maWdfbWV0aG9kcyk7Ci0JLyogVE9ETyAqLwotfQotCi0KLXN0YXRpYyB2b2lkIHRlc3RfcHJvdl9kaXNjX3Jlc3Aodm9pZCAqY3R4LCBjb25zdCB1OCAqcGVlciwgdTE2IGNvbmZpZ19tZXRob2RzKQotewotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMocGVlcj0iIE1BQ1NUUiAiIGNvbmZpZ19tZXRob2RzPTB4JXgpIiwKLQkJICAgX19mdW5jX18sIE1BQzJTVFIocGVlciksIGNvbmZpZ19tZXRob2RzKTsKLQkvKiBUT0RPICovCi19Ci0KLQotc3RhdGljIHZvaWQgdGVzdF9wMnBfZGVidWdfcHJpbnQodm9pZCAqY3R4LCBpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKm1zZykKLXsKLQl3cGFfcHJpbnRmKGxldmVsLCAiUDJQOiAlcyIsIG1zZyk7Ci19Ci0KLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCi0KLQotc3RhdGljIGludCB3cGFfZHJpdmVyX3Rlc3RfaW5pdF9wMnAoc3RydWN0IHdwYV9kcml2ZXJfdGVzdF9kYXRhICpkcnYpCi17Ci0jaWZkZWYgQ09ORklHX1AyUAotCXN0cnVjdCBwMnBfY29uZmlnIHAycDsKLQl1bnNpZ25lZCBpbnQgcjsKLQlpbnQgaTsKLQotCW9zX21lbXNldCgmcDJwLCAwLCBzaXplb2YocDJwKSk7Ci0JcDJwLmNiX2N0eCA9IGRydjsKLQlwMnAuZGVidWdfcHJpbnQgPSB0ZXN0X3AycF9kZWJ1Z19wcmludDsKLQlwMnAucDJwX3NjYW4gPSB0ZXN0X3AycF9zY2FuOwotCXAycC5zZW5kX2FjdGlvbiA9IHRlc3Rfc2VuZF9hY3Rpb247Ci0JcDJwLnNlbmRfYWN0aW9uX2RvbmUgPSB0ZXN0X3NlbmRfYWN0aW9uX2RvbmU7Ci0JcDJwLmdvX25lZ19jb21wbGV0ZWQgPSB0ZXN0X2dvX25lZ19jb21wbGV0ZWQ7Ci0JcDJwLmdvX25lZ19yZXFfcnggPSB0ZXN0X2dvX25lZ19yZXFfcng7Ci0JcDJwLmRldl9mb3VuZCA9IHRlc3RfZGV2X2ZvdW5kOwotCXAycC5zdGFydF9saXN0ZW4gPSB0ZXN0X3N0YXJ0X2xpc3RlbjsKLQlwMnAuc3RvcF9saXN0ZW4gPSB0ZXN0X3N0b3BfbGlzdGVuOwotCXAycC5zZW5kX3Byb2JlX3Jlc3AgPSB0ZXN0X3NlbmRfcHJvYmVfcmVzcDsKLQlwMnAuc2RfcmVxdWVzdCA9IHRlc3Rfc2RfcmVxdWVzdDsKLQlwMnAuc2RfcmVzcG9uc2UgPSB0ZXN0X3NkX3Jlc3BvbnNlOwotCXAycC5wcm92X2Rpc2NfcmVxID0gdGVzdF9wcm92X2Rpc2NfcmVxOwotCXAycC5wcm92X2Rpc2NfcmVzcCA9IHRlc3RfcHJvdl9kaXNjX3Jlc3A7Ci0KLQlvc19tZW1jcHkocDJwLmRldl9hZGRyLCBkcnYtPm93bl9hZGRyLCBFVEhfQUxFTik7Ci0KLQlwMnAucmVnX2NsYXNzID0gMTI7IC8qIFRPRE86IGNoYW5nZSBkZXBlbmRpbmcgb24gbG9jYXRpb24gKi8KLQkvKgotCSAqIFBpY2sgb25lIG9mIHRoZSBzb2NpYWwgY2hhbm5lbHMgcmFuZG9tbHkgYXMgdGhlIGxpc3RlbgotCSAqIGNoYW5uZWwuCi0JICovCi0Jb3NfZ2V0X3JhbmRvbSgodTggKikgJnIsIHNpemVvZihyKSk7Ci0JcDJwLmNoYW5uZWwgPSAxICsgKHIgJSAzKSAqIDU7Ci0KLQkvKiBUT0RPOiBjaGFuZ2UgZGVwZW5kaW5nIG9uIGxvY2F0aW9uICovCi0JcDJwLm9wX3JlZ19jbGFzcyA9IDEyOwotCS8qCi0JICogRm9yIGluaXRpYWwgdGVzdHMsIHBpY2sgdGhlIG9wZXJhdGlvbiBjaGFubmVsIHJhbmRvbWx5LgotCSAqIFRPRE86IFVzZSBzY2FuIHJlc3VsdHMgKGV0Yy4pIHRvIHNlbGVjdCB0aGUgYmVzdCBjaGFubmVsLgotCSAqLwotCXAycC5vcF9jaGFubmVsID0gMSArIHIgJSAxMTsKLQotCW9zX21lbWNweShwMnAuY291bnRyeSwgIlVTICIsIDMpOwotCi0JLyogRklYOiBmZXRjaCBhdmFpbGFibGUgY2hhbm5lbHMgZnJvbSB0aGUgZHJpdmVyICovCi0JcDJwLmNoYW5uZWxzLnJlZ19jbGFzc2VzID0gMTsKLQlwMnAuY2hhbm5lbHMucmVnX2NsYXNzWzBdLnJlZ19jbGFzcyA9IDEyOyAvKiBVUy8xMiA9IDIuNCBHSHogYmFuZCAqLwotCXAycC5jaGFubmVscy5yZWdfY2xhc3NbMF0uY2hhbm5lbHMgPSAxMTsKLQlmb3IgKGkgPSAwOyBpIDwgMTE7IGkrKykKLQkJcDJwLmNoYW5uZWxzLnJlZ19jbGFzc1swXS5jaGFubmVsW2ldID0gaSArIDE7Ci0KLQlwMnAubWF4X3BlZXJzID0gMTAwOwotCi0JZHJ2LT5wMnAgPSBwMnBfaW5pdCgmcDJwKTsKLQlpZiAoZHJ2LT5wMnAgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwotCXJldHVybiAwOwotI2Vsc2UgLyogQ09ORklHX1AyUCAqLwotCXdwYV9wcmludGYoTVNHX0lORk8sICJkcml2ZXJfdGVzdDogUDJQIHN1cHBvcnQgbm90IGluY2x1ZGVkIik7Ci0JcmV0dXJuIC0xOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KLX0KLQotCiBjb25zdCBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgd3BhX2RyaXZlcl90ZXN0X29wcyA9IHsKIAkidGVzdCIsCiAJIndwYV9zdXBwbGljYW50IHRlc3QgZHJpdmVyIiwKQEAgLTMzMDksMTQgKzI2ODAsNCBAQAogCS5yZW1haW5fb25fY2hhbm5lbCA9IHdwYV9kcml2ZXJfdGVzdF9yZW1haW5fb25fY2hhbm5lbCwKIAkuY2FuY2VsX3JlbWFpbl9vbl9jaGFubmVsID0gd3BhX2RyaXZlcl90ZXN0X2NhbmNlbF9yZW1haW5fb25fY2hhbm5lbCwKIAkucHJvYmVfcmVxX3JlcG9ydCA9IHdwYV9kcml2ZXJfdGVzdF9wcm9iZV9yZXFfcmVwb3J0LAotI2lmZGVmIENPTkZJR19QMlAKLQkucDJwX2ZpbmQgPSB3cGFfZHJpdmVyX3Rlc3RfcDJwX2ZpbmQsCi0JLnAycF9zdG9wX2ZpbmQgPSB3cGFfZHJpdmVyX3Rlc3RfcDJwX3N0b3BfZmluZCwKLQkucDJwX2xpc3RlbiA9IHdwYV9kcml2ZXJfdGVzdF9wMnBfbGlzdGVuLAotCS5wMnBfY29ubmVjdCA9IHdwYV9kcml2ZXJfdGVzdF9wMnBfY29ubmVjdCwKLQkud3BzX3N1Y2Nlc3NfY2IgPSB3cGFfZHJpdmVyX3Rlc3Rfd3BzX3N1Y2Nlc3NfY2IsCi0JLnAycF9ncm91cF9mb3JtYXRpb25fZmFpbGVkID0KLQl3cGFfZHJpdmVyX3Rlc3RfcDJwX2dyb3VwX2Zvcm1hdGlvbl9mYWlsZWQsCi0JLnAycF9zZXRfcGFyYW1zID0gd3BhX2RyaXZlcl90ZXN0X3AycF9zZXRfcGFyYW1zLAotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIH07CmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9kcml2ZXJfd2V4dC5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3dleHQuYwppbmRleCAxNDAxMDUwLi40NTlhYzQ4IDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9kcml2ZXJfd2V4dC5jCisrKyBiL3NyYy9kcml2ZXJzL2RyaXZlcl93ZXh0LmMKQEAgLTMxLDEwICszMSw2IEBACiAjaW5jbHVkZSAiZHJpdmVyLmgiCiAjaW5jbHVkZSAiZHJpdmVyX3dleHQuaCIKIAotI2lmZGVmIEFORFJPSUQKLSNpbmNsdWRlICJhbmRyb2lkX2Rydi5oIgotI2VuZGlmIC8qIEFORFJPSUQgKi8KLQogc3RhdGljIGludCB3cGFfZHJpdmVyX3dleHRfZmx1c2hfcG1raWQodm9pZCAqcHJpdik7CiBzdGF0aWMgaW50IHdwYV9kcml2ZXJfd2V4dF9nZXRfcmFuZ2Uodm9pZCAqcHJpdik7CiBzdGF0aWMgaW50IHdwYV9kcml2ZXJfd2V4dF9maW5pc2hfZHJ2X2luaXQoc3RydWN0IHdwYV9kcml2ZXJfd2V4dF9kYXRhICpkcnYpOwpAQCAtMjk5LDE0ICsyOTUsNiBAQAogCQl9CiAJCXdwYV9zdXBwbGljYW50X2V2ZW50KGN0eCwgRVZFTlRfU1RLU1RBUlQsICZkYXRhKTsKICNlbmRpZiAvKiBDT05GSUdfUEVFUktFWSAqLwotI2lmZGVmIEFORFJPSUQKLQl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoY3VzdG9tLCAiU1RPUCIsIDQpID09IDApIHsKLQkJd3BhX21zZyhjdHgsIE1TR19JTkZPLCBXUEFfRVZFTlRfRFJJVkVSX1NUQVRFICJTVE9QUEVEIik7Ci0JfSBlbHNlIGlmIChvc19zdHJuY21wKGN1c3RvbSwgIlNUQVJUIiwgNSkgPT0gMCkgewotCQl3cGFfbXNnKGN0eCwgTVNHX0lORk8sIFdQQV9FVkVOVF9EUklWRVJfU1RBVEUgIlNUQVJURUQiKTsKLQl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoY3VzdG9tLCAiSEFORyIsIDQpID09IDApIHsKLQkJd3BhX21zZyhjdHgsIE1TR19JTkZPLCBXUEFfRVZFTlRfRFJJVkVSX1NUQVRFICJIQU5HRUQiKTsKLSNlbmRpZiAvKiBBTkRST0lEICovCiAJfQogfQogCkBAIC04NTgsMTIgKzg0Niw2IEBACiAKIAlkcnYtPm1sbWVfc29jayA9IC0xOwogCi0jaWZkZWYgQU5EUk9JRAotCWRydi0+ZXJyb3JzID0gMDsKLQlkcnYtPmRyaXZlcl9pc19zdGFydGVkID0gVFJVRTsKLQlkcnYtPmJnc2Nhbl9lbmFibGVkID0gMDsKLSNlbmRpZiAvKiBBTkRST0lEICovCi0KIAlpZiAod3BhX2RyaXZlcl93ZXh0X2ZpbmlzaF9kcnZfaW5pdChkcnYpIDwgMCkKIAkJZ290byBlcnIzOwogCkBAIC0xODY5LDEwICsxODUxLDggQEAKIHsKIAlzdHJ1Y3QgaXdyZXEgaXdyOwogCWNvbnN0IHU4IG51bGxfYnNzaWRbRVRIX0FMRU5dID0geyAwLCAwLCAwLCAwLCAwLCAwIH07Ci0jaWZuZGVmIEFORFJPSUQKIAl1OCBzc2lkWzMyXTsKIAlpbnQgaTsKLSNlbmRpZiAvKiBBTkRST0lEICovCiAKIAkvKgogCSAqIE9ubHkgZm9yY2UtZGlzY29ubmVjdCB3aGVuIHRoZSBjYXJkIGlzIGluIGluZnJhc3RydWN0dXJlIG1vZGUsCkBAIC0xODkzLDcgKzE4NzMsNiBAQAogCQkJCSAgICJzZWxlY3Rpb24gb24gZGlzY29ubmVjdCIpOwogCQl9CiAKLSNpZm5kZWYgQU5EUk9JRAogCQlpZiAoZHJ2LT5jZmc4MDIxMSkgewogCQkJLyoKIAkJCSAqIGNmZzgwMjExIHN1cHBvcnRzIFNJT0NTSVdNTE1FIGNvbW1hbmRzLCBzbyB0aGVyZSBpcwpAQCAtMTkxOSw3ICsxODk4LDYgQEAKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV0VYVDogRmFpbGVkIHRvIHNldCBib2d1cyAiCiAJCQkJICAgIlNTSUQgdG8gZGlzY29ubmVjdCIpOwogCQl9Ci0jZW5kaWYgLyogQU5EUk9JRCAqLwogCX0KIH0KIApAQCAtMTk2MCwxNSArMTkzOCwxNSBAQAogaW50IHdwYV9kcml2ZXJfd2V4dF9jaXBoZXIyd2V4dChpbnQgY2lwaGVyKQogewogCXN3aXRjaCAoY2lwaGVyKSB7Ci0JY2FzZSBDSVBIRVJfTk9ORToKKwljYXNlIFdQQV9DSVBIRVJfTk9ORToKIAkJcmV0dXJuIElXX0FVVEhfQ0lQSEVSX05PTkU7Ci0JY2FzZSBDSVBIRVJfV0VQNDA6CisJY2FzZSBXUEFfQ0lQSEVSX1dFUDQwOgogCQlyZXR1cm4gSVdfQVVUSF9DSVBIRVJfV0VQNDA7Ci0JY2FzZSBDSVBIRVJfVEtJUDoKKwljYXNlIFdQQV9DSVBIRVJfVEtJUDoKIAkJcmV0dXJuIElXX0FVVEhfQ0lQSEVSX1RLSVA7Ci0JY2FzZSBDSVBIRVJfQ0NNUDoKKwljYXNlIFdQQV9DSVBIRVJfQ0NNUDoKIAkJcmV0dXJuIElXX0FVVEhfQ0lQSEVSX0NDTVA7Ci0JY2FzZSBDSVBIRVJfV0VQMTA0OgorCWNhc2UgV1BBX0NJUEhFUl9XRVAxMDQ6CiAJCXJldHVybiBJV19BVVRIX0NJUEhFUl9XRVAxMDQ7CiAJZGVmYXVsdDoKIAkJcmV0dXJuIDA7CkBAIC0xOTc5LDEwICsxOTU3LDEwIEBACiBpbnQgd3BhX2RyaXZlcl93ZXh0X2tleW1nbXQyd2V4dChpbnQga2V5bWdtdCkKIHsKIAlzd2l0Y2ggKGtleW1nbXQpIHsKLQljYXNlIEtFWV9NR01UXzgwMl8xWDoKLQljYXNlIEtFWV9NR01UXzgwMl8xWF9OT19XUEE6CisJY2FzZSBXUEFfS0VZX01HTVRfSUVFRTgwMjFYOgorCWNhc2UgV1BBX0tFWV9NR01UX0lFRUU4MDIxWF9OT19XUEE6CiAJCXJldHVybiBJV19BVVRIX0tFWV9NR01UXzgwMl8xWDsKLQljYXNlIEtFWV9NR01UX1BTSzoKKwljYXNlIFdQQV9LRVlfTUdNVF9QU0s6CiAJCXJldHVybiBJV19BVVRIX0tFWV9NR01UX1BTSzsKIAlkZWZhdWx0OgogCQlyZXR1cm4gMDsKQEAgLTIwNDksNyArMjAyNywxMSBAQAogCQkgKiBTdG9wIGNmZzgwMjExIGZyb20gdHJ5aW5nIHRvIGFzc29jaWF0ZSBiZWZvcmUgd2UgYXJlIGRvbmUKIAkJICogd2l0aCBhbGwgcGFyYW1ldGVycy4KIAkJICovCi0JCXdwYV9kcml2ZXJfd2V4dF9zZXRfc3NpZChkcnYsICh1OCAqKSAiIiwgMCk7CisJCWlmICh3cGFfZHJpdmVyX3dleHRfc2V0X3NzaWQoZHJ2LCAodTggKikgIiIsIDApIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkJICAgIldFWFQ6IEZhaWxlZCB0byBjbGVhciBTU0lEIHRvIHN0b3AgcGVuZGluZyBjZmc4MDIxMSBhc3NvY2lhdGlvbiBhdHRlbXB0cyAoaWYgYW55KSIpOworCQkJLyogY29udGludWUgYW55d2F5ICovCisJCX0KIAl9CiAKIAlpZiAod3BhX2RyaXZlcl93ZXh0X3NldF9kcm9wX3VuZW5jcnlwdGVkKGRydiwgcGFyYW1zLT5kcm9wX3VuZW5jcnlwdGVkKQpAQCAtMjA5OSw5ICsyMDgxLDkgQEAKIAlpZiAod3BhX2RyaXZlcl93ZXh0X3NldF9hdXRoX3BhcmFtKGRydiwKIAkJCQkJICAgSVdfQVVUSF9LRVlfTUdNVCwgdmFsdWUpIDwgMCkKIAkJcmV0ID0gLTE7Ci0JdmFsdWUgPSBwYXJhbXMtPmtleV9tZ210X3N1aXRlICE9IEtFWV9NR01UX05PTkUgfHwKLQkJcGFyYW1zLT5wYWlyd2lzZV9zdWl0ZSAhPSBDSVBIRVJfTk9ORSB8fAotCQlwYXJhbXMtPmdyb3VwX3N1aXRlICE9IENJUEhFUl9OT05FIHx8CisJdmFsdWUgPSBwYXJhbXMtPmtleV9tZ210X3N1aXRlICE9IFdQQV9LRVlfTUdNVF9OT05FIHx8CisJCXBhcmFtcy0+cGFpcndpc2Vfc3VpdGUgIT0gV1BBX0NJUEhFUl9OT05FIHx8CisJCXBhcmFtcy0+Z3JvdXBfc3VpdGUgIT0gV1BBX0NJUEhFUl9OT05FIHx8CiAJCXBhcmFtcy0+d3BhX2llX2xlbjsKIAlpZiAod3BhX2RyaXZlcl93ZXh0X3NldF9hdXRoX3BhcmFtKGRydiwKIAkJCQkJICAgSVdfQVVUSF9QUklWQUNZX0lOVk9LRUQsIHZhbHVlKSA8IDApCkBAIC0yMTEwLDggKzIwOTIsOCBAQAogCS8qIEFsbG93IHVuZW5jcnlwdGVkIEVBUE9MIG1lc3NhZ2VzIGV2ZW4gaWYgcGFpcndpc2Uga2V5cyBhcmUgc2V0IHdoZW4KIAkgKiBub3QgdXNpbmcgV1BBLiBJRUVFIDgwMi4xWCBzcGVjaWZpZXMgdGhhdCB0aGVzZSBmcmFtZXMgYXJlIG5vdAogCSAqIGVuY3J5cHRlZCwgYnV0IFdQQSBlbmNyeXB0cyB0aGVtIHdoZW4gcGFpcndpc2Uga2V5cyBhcmUgaW4gdXNlLiAqLwotCWlmIChwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IEtFWV9NR01UXzgwMl8xWCB8fAotCSAgICBwYXJhbXMtPmtleV9tZ210X3N1aXRlID09IEtFWV9NR01UX1BTSykKKwlpZiAocGFyYW1zLT5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfSUVFRTgwMjFYIHx8CisJICAgIHBhcmFtcy0+a2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX1BTSykKIAkJYWxsb3dfdW5lbmNyeXB0ZWRfZWFwb2wgPSAwOwogCWVsc2UKIAkJYWxsb3dfdW5lbmNyeXB0ZWRfZWFwb2wgPSAxOwpAQCAtMjMzOCwxMjkgKzIzMjAsMzcgQEAKIH0KIAogCi0jaWZkZWYgQU5EUk9JRAotCi1zdGF0aWMgaW50IGFuZHJvaWRfd2V4dF9jbWQoc3RydWN0IHdwYV9kcml2ZXJfd2V4dF9kYXRhICpkcnYsIGNvbnN0IGNoYXIgKmNtZCkKK3N0YXRpYyBpbnQgd3BhX2RyaXZlcl93ZXh0X3NpZ25hbF9wb2xsKHZvaWQgKnByaXYsIHN0cnVjdCB3cGFfc2lnbmFsX2luZm8gKnNpKQogeworCXN0cnVjdCB3cGFfZHJpdmVyX3dleHRfZGF0YSAqZHJ2ID0gcHJpdjsKKwlzdHJ1Y3QgaXdfc3RhdGlzdGljcyBzdGF0czsKIAlzdHJ1Y3QgaXdyZXEgaXdyOwotCWNoYXIgYnVmW01BWF9EUlZfQ01EX1NJWkVdOwotCWludCByZXQ7CisKKwlvc19tZW1zZXQoc2ksIDAsIHNpemVvZigqc2kpKTsKKwlzaS0+Y3VycmVudF9zaWduYWwgPSAtOTk5OTsKKwlzaS0+Y3VycmVudF9ub2lzZSA9IDk5OTk7CisJc2ktPmNoYW53aWR0aCA9IENIQU5fV0lEVEhfVU5LTk9XTjsKIAogCW9zX21lbXNldCgmaXdyLCAwLCBzaXplb2YoaXdyKSk7CiAJb3Nfc3RybGNweShpd3IuaWZyX25hbWUsIGRydi0+aWZuYW1lLCBJRk5BTVNJWik7CisJaXdyLnUuZGF0YS5wb2ludGVyID0gKGNhZGRyX3QpICZzdGF0czsKKwlpd3IudS5kYXRhLmxlbmd0aCA9IHNpemVvZihzdGF0cyk7CisJaXdyLnUuZGF0YS5mbGFncyA9IDE7CiAKLQlvc19tZW1zZXQoYnVmLCAwLCBzaXplb2YoYnVmKSk7Ci0Jb3Nfc3RybGNweShidWYsIGNtZCwgc2l6ZW9mKGJ1ZikpOwotCi0JaXdyLnUuZGF0YS5wb2ludGVyID0gYnVmOwotCWl3ci51LmRhdGEubGVuZ3RoID0gc2l6ZW9mKGJ1Zik7Ci0KLQlyZXQgPSBpb2N0bChkcnYtPmlvY3RsX3NvY2ssIFNJT0NTSVdQUklWLCAmaXdyKTsKLQotCWlmIChyZXQgPCAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXMgZmFpbGVkICglZCk6ICVzIiwgX19mdW5jX18sIHJldCwKLQkJCSAgIGNtZCk7Ci0JCWRydi0+ZXJyb3JzKys7Ci0JCWlmIChkcnYtPmVycm9ycyA+IERSVl9OVU1CRVJfU0VRVUVOVElBTF9FUlJPUlMpIHsKLQkJCWRydi0+ZXJyb3JzID0gMDsKLQkJCXdwYV9tc2coZHJ2LT5jdHgsIE1TR19JTkZPLCBXUEFfRVZFTlRfRFJJVkVSX1NUQVRFCi0JCQkJIkhBTkdFRCIpOwotCQl9Ci0JCXJldHVybiByZXQ7CisJaWYgKGlvY3RsKGRydi0+aW9jdGxfc29jaywgU0lPQ0dJV1NUQVRTLCAmaXdyKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXRVhUOiBTSU9DR0lXU1RBVFM6ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CisJCXJldHVybiAtMTsKIAl9CiAKLQlkcnYtPmVycm9ycyA9IDA7CisJc2ktPmN1cnJlbnRfc2lnbmFsID0gc3RhdHMucXVhbC5sZXZlbCAtCisJCSgoc3RhdHMucXVhbC51cGRhdGVkICYgSVdfUVVBTF9EQk0pID8gMHgxMDAgOiAwKTsKKwlzaS0+Y3VycmVudF9ub2lzZSA9IHN0YXRzLnF1YWwubm9pc2UgLQorCQkoKHN0YXRzLnF1YWwudXBkYXRlZCAmIElXX1FVQUxfREJNKSA/IDB4MTAwIDogMCk7CiAJcmV0dXJuIDA7CiB9CiAKIAotc3RhdGljIGludCB3ZXh0X3NjaGVkX3NjYW4odm9pZCAqcHJpdiwgc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgKnBhcmFtcywKLQkJCSAgIHUzMiBpbnRlcnZhbCkKLXsKLQlzdHJ1Y3Qgd3BhX2RyaXZlcl93ZXh0X2RhdGEgKmRydiA9IHByaXY7Ci0Jc3RydWN0IGl3cmVxIGl3cjsKLQlpbnQgcmV0ID0gMCwgaSA9IDAsIGJwOwotCWNoYXIgYnVmW1dFWFRfUE5PX01BWF9DT01NQU5EX1NJWkVdOwotCi0JYnAgPSBXRVhUX1BOT1NFVFVQX0hFQURFUl9TSVpFOwotCW9zX21lbWNweShidWYsIFdFWFRfUE5PU0VUVVBfSEVBREVSLCBicCk7Ci0JYnVmW2JwKytdID0gV0VYVF9QTk9fVExWX1BSRUZJWDsKLQlidWZbYnArK10gPSBXRVhUX1BOT19UTFZfVkVSU0lPTjsKLQlidWZbYnArK10gPSBXRVhUX1BOT19UTFZfU1VCVkVSU0lPTjsKLQlidWZbYnArK10gPSBXRVhUX1BOT19UTFZfUkVTRVJWRUQ7Ci0KLQl3aGlsZSAoaSA8IFdFWFRfUE5PX0FNT1VOVCAmJiAoc2l6ZV90KSBpIDwgcGFyYW1zLT5udW1fc3NpZHMpIHsKLQkJLyoKLQkJICogQ2hlY2sgdGhhdCB0aGVyZSBpcyBlbm91Z2ggc3BhY2UgbmVlZGVkIGZvciAxIG1vcmUgU1NJRCwgdGhlCi0JCSAqIG90aGVyIHNlY3Rpb25zIGFuZCBudWxsIHRlcm1pbmF0aW9uLgotCQkgKi8KLQkJaWYgKChicCArIFdFWFRfUE5PX1NTSURfSEVBREVSX1NJWkUgKyBJV19FU1NJRF9NQVhfU0laRSArCi0JCSAgICAgV0VYVF9QTk9fTk9OU1NJRF9TRUNUSU9OU19TSVpFICsgMSkgPj0gKGludCkgc2l6ZW9mKGJ1ZikpCi0JCQlicmVhazsKLQotCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJGb3IgUE5PIFNjYW4iLAotCQkJCSAgcGFyYW1zLT5zc2lkc1tpXS5zc2lkLAotCQkJCSAgcGFyYW1zLT5zc2lkc1tpXS5zc2lkX2xlbik7Ci0JCWJ1ZlticCsrXSA9IFdFWFRfUE5PX1NTSURfU0VDVElPTjsKLQkJYnVmW2JwKytdID0gcGFyYW1zLT5zc2lkc1tpXS5zc2lkX2xlbjsKLQkJb3NfbWVtY3B5KCZidWZbYnBdLCBwYXJhbXMtPnNzaWRzW2ldLnNzaWQsCi0JCQkgIHBhcmFtcy0+c3NpZHNbaV0uc3NpZF9sZW4pOwotCQlicCArPSBwYXJhbXMtPnNzaWRzW2ldLnNzaWRfbGVuOwotCQlpKys7Ci0JfQotCi0JYnVmW2JwKytdID0gV0VYVF9QTk9fU0NBTl9JTlRFUlZBTF9TRUNUSU9OOwotCS8qIFRPRE86IGNvbnNpZGVyIHVzaW5nIGludGVydmFsIHBhcmFtZXRlciAoaW50ZXJ2YWwgaW4gbXNlYykgaW5zdGVhZAotCSAqIG9mIGhhcmRjb2RlZCB2YWx1ZSBoZXJlICovCi0Jb3Nfc25wcmludGYoJmJ1ZlticF0sIFdFWFRfUE5PX1NDQU5fSU5URVJWQUxfTEVOR1RIICsgMSwgIiV4IiwKLQkJICAgIFdFWFRfUE5PX1NDQU5fSU5URVJWQUwpOwotCWJwICs9IFdFWFRfUE5PX1NDQU5fSU5URVJWQUxfTEVOR1RIOwotCi0JYnVmW2JwKytdID0gV0VYVF9QTk9fUkVQRUFUX1NFQ1RJT047Ci0Jb3Nfc25wcmludGYoJmJ1ZlticF0sIFdFWFRfUE5PX1JFUEVBVF9MRU5HVEggKyAxLCAiJXgiLAotCQkgICAgV0VYVF9QTk9fUkVQRUFUKTsKLQlicCArPSBXRVhUX1BOT19SRVBFQVRfTEVOR1RIOwotCi0JYnVmW2JwKytdID0gV0VYVF9QTk9fTUFYX1JFUEVBVF9TRUNUSU9OOwotCW9zX3NucHJpbnRmKCZidWZbYnBdLCBXRVhUX1BOT19NQVhfUkVQRUFUX0xFTkdUSCArIDEsICIleCIsCi0JCSAgICBXRVhUX1BOT19NQVhfUkVQRUFUKTsKLQlicCArPSBXRVhUX1BOT19NQVhfUkVQRUFUX0xFTkdUSCArIDE7Ci0KLQlvc19tZW1zZXQoJml3ciwgMCwgc2l6ZW9mKGl3cikpOwotCW9zX3N0cm5jcHkoaXdyLmlmcl9uYW1lLCBkcnYtPmlmbmFtZSwgSUZOQU1TSVopOwotCWl3ci51LmRhdGEucG9pbnRlciA9IGJ1ZjsKLQlpd3IudS5kYXRhLmxlbmd0aCA9IGJwOwotCi0JcmV0ID0gaW9jdGwoZHJ2LT5pb2N0bF9zb2NrLCBTSU9DU0lXUFJJViwgJml3cik7Ci0JaWYgKHJldCA8IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJpb2N0bFtTSU9DU0lXUFJJVl0gKHBub3NldHVwKTogJWQiLAotCQkJICAgcmV0KTsKLQkJZHJ2LT5lcnJvcnMrKzsKLQkJaWYgKGRydi0+ZXJyb3JzID4gRFJWX05VTUJFUl9TRVFVRU5USUFMX0VSUk9SUykgewotCQkJZHJ2LT5lcnJvcnMgPSAwOwotCQkJd3BhX21zZyhkcnYtPmN0eCwgTVNHX0lORk8sCi0JCQkJV1BBX0VWRU5UX0RSSVZFUl9TVEFURSAiSEFOR0VEIik7Ci0JCX0KLQkJcmV0dXJuIHJldDsKLQl9Ci0KLQlkcnYtPmVycm9ycyA9IDA7Ci0JZHJ2LT5iZ3NjYW5fZW5hYmxlZCA9IDE7Ci0KLQlyZXR1cm4gYW5kcm9pZF93ZXh0X2NtZChkcnYsICJQTk9GT1JDRSAxIik7Ci19Ci0KLQotc3RhdGljIGludCB3ZXh0X3N0b3Bfc2NoZWRfc2Nhbih2b2lkICpwcml2KQotewotCXN0cnVjdCB3cGFfZHJpdmVyX3dleHRfZGF0YSAqZHJ2ID0gcHJpdjsKLQlkcnYtPmJnc2Nhbl9lbmFibGVkID0gMDsKLQlyZXR1cm4gYW5kcm9pZF93ZXh0X2NtZChkcnYsICJQTk9GT1JDRSAwIik7Ci19Ci0KLSNlbmRpZiAvKiBBTkRST0lEICovCi0KLQogY29uc3Qgc3RydWN0IHdwYV9kcml2ZXJfb3BzIHdwYV9kcml2ZXJfd2V4dF9vcHMgPSB7CiAJLm5hbWUgPSAid2V4dCIsCiAJLmRlc2MgPSAiTGludXggd2lyZWxlc3MgZXh0ZW5zaW9ucyAoZ2VuZXJpYykiLApAQCAtMjQ4MCw4ICsyMzcwLDUgQEAKIAkuZ2V0X2NhcGEgPSB3cGFfZHJpdmVyX3dleHRfZ2V0X2NhcGEsCiAJLnNldF9vcGVyc3RhdGUgPSB3cGFfZHJpdmVyX3dleHRfc2V0X29wZXJzdGF0ZSwKIAkuZ2V0X3JhZGlvX25hbWUgPSB3ZXh0X2dldF9yYWRpb19uYW1lLAotI2lmZGVmIEFORFJPSUQKLQkuc2NoZWRfc2NhbiA9IHdleHRfc2NoZWRfc2NhbiwKLQkuc3RvcF9zY2hlZF9zY2FuID0gd2V4dF9zdG9wX3NjaGVkX3NjYW4sCi0jZW5kaWYgLyogQU5EUk9JRCAqLworCS5zaWduYWxfcG9sbCA9IHdwYV9kcml2ZXJfd2V4dF9zaWduYWxfcG9sbCwKIH07CmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9kcml2ZXJfd2V4dC5oIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3dleHQuaAppbmRleCBjNGE1YmM5Li5iNGI1OTYwIDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9kcml2ZXJfd2V4dC5oCisrKyBiL3NyYy9kcml2ZXJzL2RyaXZlcl93ZXh0LmgKQEAgLTQ0LDEyICs0NCw2IEBACiAJaW50IGNmZzgwMjExOyAvKiB3aGV0aGVyIGRyaXZlciBpcyB1c2luZyBjZmc4MDIxMSAqLwogCiAJdTggbWF4X2xldmVsOwotCi0jaWZkZWYgQU5EUk9JRAotCWludCBlcnJvcnM7Ci0JaW50IGRyaXZlcl9pc19zdGFydGVkOwotCWludCBiZ3NjYW5fZW5hYmxlZDsKLSNlbmRpZiAvKiBBTkRST0lEICovCiB9OwogCiBpbnQgd3BhX2RyaXZlcl93ZXh0X2dldF9ic3NpZCh2b2lkICpwcml2LCB1OCAqYnNzaWQpOwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVycy5jIGIvc3JjL2RyaXZlcnMvZHJpdmVycy5jCmluZGV4IDA0ZWI0ZmQuLmQwZTQyZWMgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcnMuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJzLmMKQEAgLTYsOCArNiw5IEBACiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAotI2luY2x1ZGUgImluY2x1ZGVzLmgiCi0KKyNpbmNsdWRlICJ1dGlscy9pbmNsdWRlcy5oIgorI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgImRyaXZlci5oIgogCiAjaWZkZWYgQ09ORklHX0RSSVZFUl9XRVhUCiBleHRlcm4gc3RydWN0IHdwYV9kcml2ZXJfb3BzIHdwYV9kcml2ZXJfd2V4dF9vcHM7IC8qIGRyaXZlcl93ZXh0LmMgKi8KQEAgLTMzLDYgKzM0LDEwIEBACiAjaWZkZWYgQ09ORklHX0RSSVZFUl9XSVJFRAogZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyB3cGFfZHJpdmVyX3dpcmVkX29wczsgLyogZHJpdmVyX3dpcmVkLmMgKi8KICNlbmRpZiAvKiBDT05GSUdfRFJJVkVSX1dJUkVEICovCisjaWZkZWYgQ09ORklHX0RSSVZFUl9NQUNTRUNfUUNBCisgLyogZHJpdmVyX21hY3NlY19xY2EuYyAqLworZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyB3cGFfZHJpdmVyX21hY3NlY19xY2Ffb3BzOworI2VuZGlmIC8qIENPTkZJR19EUklWRVJfTUFDU0VDX1FDQSAqLwogI2lmZGVmIENPTkZJR19EUklWRVJfVEVTVAogZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyB3cGFfZHJpdmVyX3Rlc3Rfb3BzOyAvKiBkcml2ZXJfdGVzdC5jICovCiAjZW5kaWYgLyogQ09ORklHX0RSSVZFUl9URVNUICovCkBAIC03NCw2ICs3OSw5IEBACiAjaWZkZWYgQ09ORklHX0RSSVZFUl9XSVJFRAogCSZ3cGFfZHJpdmVyX3dpcmVkX29wcywKICNlbmRpZiAvKiBDT05GSUdfRFJJVkVSX1dJUkVEICovCisjaWZkZWYgQ09ORklHX0RSSVZFUl9NQUNTRUNfUUNBCisJJndwYV9kcml2ZXJfbWFjc2VjX3FjYV9vcHMsCisjZW5kaWYgLyogQ09ORklHX0RSSVZFUl9NQUNTRUNfUUNBICovCiAjaWZkZWYgQ09ORklHX0RSSVZFUl9URVNUCiAJJndwYV9kcml2ZXJfdGVzdF9vcHMsCiAjZW5kaWYgLyogQ09ORklHX0RSSVZFUl9URVNUICovCmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9kcml2ZXJzLm1hayBiL3NyYy9kcml2ZXJzL2RyaXZlcnMubWFrCmluZGV4IDY4ZmY5MTAuLjQwYWFiYTUgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcnMubWFrCisrKyBiL3NyYy9kcml2ZXJzL2RyaXZlcnMubWFrCkBAIC0xNyw2ICsxNywxMSBAQAogRFJWX09CSlMgKz0gLi4vc3JjL2RyaXZlcnMvZHJpdmVyX3dpcmVkLm8KIGVuZGlmCiAKK2lmZGVmIENPTkZJR19EUklWRVJfTUFDU0VDX1FDQQorRFJWX0NGTEFHUyArPSAtRENPTkZJR19EUklWRVJfTUFDU0VDX1FDQQorRFJWX09CSlMgKz0gLi4vc3JjL2RyaXZlcnMvZHJpdmVyX21hY3NlY19xY2EubworZW5kaWYKKwogaWZkZWYgQ09ORklHX0RSSVZFUl9OTDgwMjExCiBEUlZfQ0ZMQUdTICs9IC1EQ09ORklHX0RSSVZFUl9OTDgwMjExCiBEUlZfT0JKUyArPSAuLi9zcmMvZHJpdmVycy9kcml2ZXJfbmw4MDIxMS5vCkBAIC0xMDAsNiArMTA1LDkgQEAKIENPTkZJR19MMl9QQUNLRVQ9bGludXgKIE5FRURfTkVUTElOSz15CiBORUVEX0xJTlVYX0lPQ1RMPXkKK2lmZGVmIEFUSF9HQ01fU1VQUE9SVAorQ0ZMQUdTICs9IC1EQVRIX0dDTV9TVVBQT1JUCitlbmRpZgogZW5kaWYKIAogIyMjIyMgUFVSRSBDTElFTlQgRFJJVkVSUwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvbGludXhfaW9jdGwuYyBiL3NyYy9kcml2ZXJzL2xpbnV4X2lvY3RsLmMKaW5kZXggNDM4MDQyOC4uODM3OTcxZCAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvbGludXhfaW9jdGwuYworKysgYi9zcmMvZHJpdmVycy9saW51eF9pb2N0bC5jCkBAIC0yMDQsMTEgKzIwNCwxNCBAQAogaW50IGxpbnV4X2JyX2dldChjaGFyICpicm5hbWUsIGNvbnN0IGNoYXIgKmlmbmFtZSkKIHsKIAljaGFyIHBhdGhbMTI4XSwgYnJsaW5rWzEyOF0sICpwb3M7CisJc3NpemVfdCByZXM7CisKIAlvc19zbnByaW50ZihwYXRoLCBzaXplb2YocGF0aCksICIvc3lzL2NsYXNzL25ldC8lcy9icnBvcnQvYnJpZGdlIiwKIAkJICAgIGlmbmFtZSk7Ci0Jb3NfbWVtc2V0KGJybGluaywgMCwgc2l6ZW9mKGJybGluaykpOwotCWlmIChyZWFkbGluayhwYXRoLCBicmxpbmssIHNpemVvZihicmxpbmspIC0gMSkgPCAwKQorCXJlcyA9IHJlYWRsaW5rKHBhdGgsIGJybGluaywgc2l6ZW9mKGJybGluaykpOworCWlmIChyZXMgPCAwIHx8IChzaXplX3QpIHJlcyA+PSBzaXplb2YoYnJsaW5rKSkKIAkJcmV0dXJuIC0xOworCWJybGlua1tyZXNdID0gJ1wwJzsKIAlwb3MgPSBvc19zdHJyY2hyKGJybGluaywgJy8nKTsKIAlpZiAocG9zID09IE5VTEwpCiAJCXJldHVybiAtMTsKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL25ldGxpbmsuYyBiL3NyYy9kcml2ZXJzL25ldGxpbmsuYwppbmRleCA2YzYwNTUwLi4yZmEyMGIxIDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9uZXRsaW5rLmMKKysrIGIvc3JjL2RyaXZlcnMvbmV0bGluay5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIE5ldGxpbmsgaGVscGVyIGZ1bmN0aW9ucyBmb3IgZHJpdmVyIHdyYXBwZXJzCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwMi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xMzcsNiArMTM3LDM1IEBACiAJb3NfZnJlZShuZXRsaW5rKTsKIH0KIAorCitzdGF0aWMgY29uc3QgY2hhciAqIGxpbmttb2RlX3N0cihpbnQgbW9kZSkKK3sKKwlzd2l0Y2ggKG1vZGUpIHsKKwljYXNlIC0xOgorCQlyZXR1cm4gIm5vIGNoYW5nZSI7CisJY2FzZSAwOgorCQlyZXR1cm4gImtlcm5lbC1jb250cm9sIjsKKwljYXNlIDE6CisJCXJldHVybiAidXNlcnNwYWNlLWNvbnRyb2wiOworCX0KKwlyZXR1cm4gIj8iOworfQorCisKK3N0YXRpYyBjb25zdCBjaGFyICogb3BlcnN0YXRlX3N0cihpbnQgc3RhdGUpCit7CisJc3dpdGNoIChzdGF0ZSkgeworCWNhc2UgLTE6CisJCXJldHVybiAibm8gY2hhbmdlIjsKKwljYXNlIElGX09QRVJfRE9STUFOVDoKKwkJcmV0dXJuICJJRl9PUEVSX0RPUk1BTlQiOworCWNhc2UgSUZfT1BFUl9VUDoKKwkJcmV0dXJuICJJRl9PUEVSX1VQIjsKKwl9CisJcmV0dXJuICI/IjsKK30KKworCiBpbnQgbmV0bGlua19zZW5kX29wZXJfaWZsYShzdHJ1Y3QgbmV0bGlua19kYXRhICpuZXRsaW5rLCBpbnQgaWZpbmRleCwKIAkJCSAgIGludCBsaW5rbW9kZSwgaW50IG9wZXJzdGF0ZSkKIHsKQEAgLTE4NCw4ICsyMTMsOSBAQAogCQkJUlRBX0xFTkdUSChzaXplb2YoY2hhcikpOwogCX0KIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmV0bGluazogT3BlcnN0YXRlOiBsaW5rbW9kZT0lZCwgb3BlcnN0YXRlPSVkIiwKLQkJICAgbGlua21vZGUsIG9wZXJzdGF0ZSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJuZXRsaW5rOiBPcGVyc3RhdGU6IGlmaW5kZXg9JWQgbGlua21vZGU9JWQgKCVzKSwgb3BlcnN0YXRlPSVkICglcykiLAorCQkgICBpZmluZGV4LCBsaW5rbW9kZSwgbGlua21vZGVfc3RyKGxpbmttb2RlKSwKKwkJICAgb3BlcnN0YXRlLCBvcGVyc3RhdGVfc3RyKG9wZXJzdGF0ZSkpOwogCiAJcmV0ID0gc2VuZChuZXRsaW5rLT5zb2NrLCAmcmVxLCByZXEuaGRyLm5sbXNnX2xlbiwgMCk7CiAJaWYgKHJldCA8IDApIHsKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL25sODAyMTFfY29weS5oIGIvc3JjL2RyaXZlcnMvbmw4MDIxMV9jb3B5LmgKaW5kZXggMzJiMDYwZS4uNDA2MDEwZCAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvbmw4MDIxMV9jb3B5LmgKKysrIGIvc3JjL2RyaXZlcnMvbmw4MDIxMV9jb3B5LmgKQEAgLTEyNiw2ICsxMjYsMzEgQEAKICAqLwogCiAvKioKKyAqIERPQzogcGFja2V0IGNvYWxlc2NlIHN1cHBvcnQKKyAqCisgKiBJbiBtb3N0IGNhc2VzLCBob3N0IHRoYXQgcmVjZWl2ZXMgSVB2NCBhbmQgSVB2NiBtdWx0aWNhc3QvYnJvYWRjYXN0CisgKiBwYWNrZXRzIGRvZXMgbm90IGRvIGFueXRoaW5nIHdpdGggdGhlc2UgcGFja2V0cy4gVGhlcmVmb3JlIHRoZQorICogcmVjZXB0aW9uIG9mIHRoZXNlIHVud2FudGVkIHBhY2tldHMgY2F1c2VzIHVubmVjZXNzYXJ5IHByb2Nlc3NpbmcKKyAqIGFuZCBwb3dlciBjb25zdW1wdGlvbi4KKyAqCisgKiBQYWNrZXQgY29hbGVzY2UgZmVhdHVyZSBoZWxwcyB0byByZWR1Y2UgbnVtYmVyIG9mIHJlY2VpdmVkIGludGVycnVwdHMKKyAqIHRvIGhvc3QgYnkgYnVmZmVyaW5nIHRoZXNlIHBhY2tldHMgaW4gZmlybXdhcmUvaGFyZHdhcmUgZm9yIHNvbWUKKyAqIHByZWRlZmluZWQgdGltZS4gUmVjZWl2ZWQgaW50ZXJydXB0IHdpbGwgYmUgZ2VuZXJhdGVkIHdoZW4gb25lIG9mIHRoZQorICogZm9sbG93aW5nIGV2ZW50cyBvY2N1ci4KKyAqIGEpIEV4cGlyYXRpb24gb2YgaGFyZHdhcmUgdGltZXIgd2hvc2UgZXhwaXJhdGlvbiB0aW1lIGlzIHNldCB0byBtYXhpbXVtCisgKiBjb2FsZXNjaW5nIGRlbGF5IG9mIG1hdGNoaW5nIGNvYWxlc2NlIHJ1bGUuCisgKiBiKSBDb2FsZXNjaW5nIGJ1ZmZlciBpbiBoYXJkd2FyZSByZWFjaGVzIGl0J3MgbGltaXQuCisgKiBjKSBQYWNrZXQgZG9lc24ndCBtYXRjaCBhbnkgb2YgdGhlIGNvbmZpZ3VyZWQgY29hbGVzY2UgcnVsZXMuCisgKgorICogVXNlciBuZWVkcyB0byBjb25maWd1cmUgZm9sbG93aW5nIHBhcmFtZXRlcnMgZm9yIGNyZWF0aW5nIGEgY29hbGVzY2UKKyAqIHJ1bGUuCisgKiBhKSBNYXhpbXVtIGNvYWxlc2NpbmcgZGVsYXkKKyAqIGIpIExpc3Qgb2YgcGFja2V0IHBhdHRlcm5zIHdoaWNoIG5lZWRzIHRvIGJlIG1hdGNoZWQKKyAqIGMpIENvbmRpdGlvbiBmb3IgY29hbGVzY2VuY2UuIHBhdHRlcm4gJ21hdGNoJyBvciAnbm8gbWF0Y2gnCisgKiBNdWx0aXBsZSBzdWNoIHJ1bGVzIGNhbiBiZSBjcmVhdGVkLgorICovCisKKy8qKgogICogZW51bSBubDgwMjExX2NvbW1hbmRzIC0gc3VwcG9ydGVkIG5sODAyMTEgY29tbWFuZHMKICAqCiAgKiBATkw4MDIxMV9DTURfVU5TUEVDOiB1bnNwZWNpZmllZCBjb21tYW5kIHRvIGNhdGNoIGVycm9ycwpAQCAtMjc4LDggKzMwMyw5IEBACiAgKglwYXNzZWQsIGFsbCBjaGFubmVscyBhbGxvd2VkIGZvciB0aGUgY3VycmVudCByZWd1bGF0b3J5IGRvbWFpbgogICoJYXJlIHVzZWQuICBFeHRyYSBJRXMgY2FuIGFsc28gYmUgcGFzc2VkIGZyb20gdGhlIHVzZXJzcGFjZSBieQogICoJdXNpbmcgdGhlICVOTDgwMjExX0FUVFJfSUUgYXR0cmlidXRlLgotICogQE5MODAyMTFfQ01EX1NUT1BfU0NIRURfU0NBTjogc3RvcCBhIHNjaGVkdWxlZCBzY2FuLiAgUmV0dXJucyAtRU5PRU5UCi0gKglpZiBzY2hlZHVsZWQgc2NhbiBpcyBub3QgcnVubmluZy4KKyAqIEBOTDgwMjExX0NNRF9TVE9QX1NDSEVEX1NDQU46IHN0b3AgYSBzY2hlZHVsZWQgc2Nhbi4gUmV0dXJucyAtRU5PRU5UIGlmCisgKglzY2hlZHVsZWQgc2NhbiBpcyBub3QgcnVubmluZy4gVGhlIGNhbGxlciBtYXkgYXNzdW1lIHRoYXQgYXMgc29vbgorICoJYXMgdGhlIGNhbGwgcmV0dXJucywgaXQgaXMgc2FmZSB0byBzdGFydCBhIG5ldyBzY2hlZHVsZWQgc2NhbiBhZ2Fpbi4KICAqIEBOTDgwMjExX0NNRF9TQ0hFRF9TQ0FOX1JFU1VMVFM6IGluZGljYXRlcyB0aGF0IHRoZXJlIGFyZSBzY2hlZHVsZWQgc2NhbgogICoJcmVzdWx0cyBhdmFpbGFibGUuCiAgKiBATkw4MDIxMV9DTURfU0NIRURfU0NBTl9TVE9QUEVEOiBpbmRpY2F0ZXMgdGhhdCB0aGUgc2NoZWR1bGVkIHNjYW4gaGFzCkBAIC0zOTMsOCArNDE5LDE4IEBACiAgKgklTkw4MDIxMV9BVFRSX1NTSUQgYXR0cmlidXRlLCBhbmQgY2FuIG9wdGlvbmFsbHkgc3BlY2lmeSB0aGUgYXNzb2NpYXRpb24KICAqCUlFcyBpbiAlTkw4MDIxMV9BVFRSX0lFLCAlTkw4MDIxMV9BVFRSX0FVVEhfVFlQRSwgJU5MODAyMTFfQVRUUl9VU0VfTUZQLAogICoJJU5MODAyMTFfQVRUUl9NQUMsICVOTDgwMjExX0FUVFJfV0lQSFlfRlJFUSwgJU5MODAyMTFfQVRUUl9DT05UUk9MX1BPUlQsCi0gKgklTkw4MDIxMV9BVFRSX0NPTlRST0xfUE9SVF9FVEhFUlRZUEUgYW5kCi0gKgklTkw4MDIxMV9BVFRSX0NPTlRST0xfUE9SVF9OT19FTkNSWVBULgorICoJJU5MODAyMTFfQVRUUl9DT05UUk9MX1BPUlRfRVRIRVJUWVBFLAorICoJJU5MODAyMTFfQVRUUl9DT05UUk9MX1BPUlRfTk9fRU5DUllQVCwgJU5MODAyMTFfQVRUUl9NQUNfSElOVCwgYW5kCisgKgklTkw4MDIxMV9BVFRSX1dJUEhZX0ZSRVFfSElOVC4KKyAqCUlmIGluY2x1ZGVkLCAlTkw4MDIxMV9BVFRSX01BQyBhbmQgJU5MODAyMTFfQVRUUl9XSVBIWV9GUkVRIGFyZQorICoJcmVzdHJpY3Rpb25zIG9uIEJTUyBzZWxlY3Rpb24sIGkuZS4sIHRoZXkgZWZmZWN0aXZlbHkgcHJldmVudCByb2FtaW5nCisgKgl3aXRoaW4gdGhlIEVTUy4gJU5MODAyMTFfQVRUUl9NQUNfSElOVCBhbmQgJU5MODAyMTFfQVRUUl9XSVBIWV9GUkVRX0hJTlQKKyAqCWNhbiBiZSBpbmNsdWRlZCB0byBwcm92aWRlIGEgcmVjb21tZW5kYXRpb24gb2YgdGhlIGluaXRpYWwgQlNTIHdoaWxlCisgKglhbGxvd2luZyB0aGUgZHJpdmVyIHRvIHJvYW0gdG8gb3RoZXIgQlNTZXMgd2l0aGluIHRoZSBFU1MgYW5kIGFsc28gdG8KKyAqCWlnbm9yZSB0aGlzIHJlY29tbWVuZGF0aW9uIGlmIHRoZSBpbmRpY2F0ZWQgQlNTIGlzIG5vdCBpZGVhbC4gT25seSBvbmUKKyAqCXNldCBvZiBCU1NJRCxmcmVxdWVuY3kgcGFyYW1ldGVycyBpcyB1c2VkIChpLmUuLCBlaXRoZXIgdGhlIGVuZm9yY2luZworICoJJU5MODAyMTFfQVRUUl9NQUMsJU5MODAyMTFfQVRUUl9XSVBIWV9GUkVRIG9yIHRoZSBsZXNzIHN0cmljdAorICoJJU5MODAyMTFfQVRUUl9NQUNfSElOVCBhbmQgJU5MODAyMTFfQVRUUl9XSVBIWV9GUkVRX0hJTlQpLgogICoJQmFja2dyb3VuZCBzY2FuIHBlcmlvZCBjYW4gb3B0aW9uYWxseSBiZQogICoJc3BlY2lmaWVkIGluICVOTDgwMjExX0FUVFJfQkdfU0NBTl9QRVJJT0QsCiAgKglpZiBub3Qgc3BlY2lmaWVkIGRlZmF1bHQgYmFja2dyb3VuZCBzY2FuIGNvbmZpZ3VyYXRpb24KQEAgLTU1Niw3ICs1OTIsMTQgQEAKICAqCW9wZXJhdGlvbiwgJU5MODAyMTFfQVRUUl9NQUMgY29udGFpbnMgdGhlIHBlZXIgTUFDIGFkZHJlc3MsIGFuZAogICoJJU5MODAyMTFfQVRUUl9SRUFTT05fQ09ERSB0aGUgcmVhc29uIGNvZGUgdG8gYmUgdXNlZCAob25seSB3aXRoCiAgKgklTkw4MDIxMV9URExTX1RFQVJET1dOKS4KLSAqIEBOTDgwMjExX0NNRF9URExTX01HTVQ6IFNlbmQgYSBURExTIG1hbmFnZW1lbnQgZnJhbWUuCisgKiBATkw4MDIxMV9DTURfVERMU19NR01UOiBTZW5kIGEgVERMUyBtYW5hZ2VtZW50IGZyYW1lLiBUaGUKKyAqCSVOTDgwMjExX0FUVFJfVERMU19BQ1RJT04gYXR0cmlidXRlIGRldGVybWluZXMgdGhlIHR5cGUgb2YgZnJhbWUgdG8gYmUKKyAqCXNlbnQuIFB1YmxpYyBBY3Rpb24gY29kZXMgKDgwMi4xMS0yMDEyIDguMS41LjEpIHdpbGwgYmUgc2VudCBhcworICoJODAyLjExIG1hbmFnZW1lbnQgZnJhbWVzLCB3aGlsZSBURExTIGFjdGlvbiBjb2RlcyAoODAyLjExLTIwMTIKKyAqCTguNS4xMy4xKSB3aWxsIGJlIGVuY2Fwc3VsYXRlZCBhbmQgc2VudCBhcyBkYXRhIGZyYW1lcy4gVGhlIGN1cnJlbnRseQorICoJc3VwcG9ydGVkIFB1YmxpYyBBY3Rpb24gY29kZSBpcyAlV0xBTl9QVUJfQUNUSU9OX1RETFNfRElTQ09WRVJfUkVTCisgKglhbmQgdGhlIGN1cnJlbnRseSBzdXBwb3J0ZWQgVERMUyBhY3Rpb25zIGNvZGVzIGFyZSBnaXZlbiBpbgorICoJJmVudW0gaWVlZTgwMjExX3RkbHNfYWN0aW9uY29kZS4KICAqCiAgKiBATkw4MDIxMV9DTURfVU5FWFBFQ1RFRF9GUkFNRTogVXNlZCBieSBhbiBhcHBsaWNhdGlvbiBjb250cm9sbGluZyBhbiBBUAogICoJKG9yIEdPKSBpbnRlcmZhY2UgKGkuZS4gaG9zdGFwZCkgdG8gYXNrIGZvciB1bmV4cGVjdGVkIGZyYW1lcyB0bwpAQCAtNjQ4LDYgKzY5MSwzNCBAQAogICogQE5MODAyMTFfQ01EX0NSSVRfUFJPVE9DT0xfU1RPUDogSW5kaWNhdGVzIHRoZSBjb25uZWN0aW9uIHJlbGlhYmlsaXR5IGNhbgogICoJcmV0dXJuIGJhY2sgdG8gbm9ybWFsLgogICoKKyAqIEBOTDgwMjExX0NNRF9HRVRfQ09BTEVTQ0U6IEdldCBjdXJyZW50bHkgc3VwcG9ydGVkIGNvYWxlc2NlIHJ1bGVzLgorICogQE5MODAyMTFfQ01EX1NFVF9DT0FMRVNDRTogQ29uZmlndXJlIGNvYWxlc2NlIHJ1bGVzIG9yIGNsZWFyIGV4aXN0aW5nIHJ1bGVzLgorICoKKyAqIEBOTDgwMjExX0NNRF9DSEFOTkVMX1NXSVRDSDogUGVyZm9ybSBhIGNoYW5uZWwgc3dpdGNoIGJ5IGFubm91bmNpbmcgdGhlCisgKgl0aGUgbmV3IGNoYW5uZWwgaW5mb3JtYXRpb24gKENoYW5uZWwgU3dpdGNoIEFubm91bmNlbWVudCAtIENTQSkKKyAqCWluIHRoZSBiZWFjb24gZm9yIHNvbWUgdGltZSAoYXMgZGVmaW5lZCBpbiB0aGUKKyAqCSVOTDgwMjExX0FUVFJfQ0hfU1dJVENIX0NPVU5UIHBhcmFtZXRlcikgYW5kIHRoZW4gY2hhbmdlIHRvIHRoZQorICoJbmV3IGNoYW5uZWwuIFVzZXJzcGFjZSBwcm92aWRlcyB0aGUgbmV3IGNoYW5uZWwgaW5mb3JtYXRpb24gKHVzaW5nCisgKgklTkw4MDIxMV9BVFRSX1dJUEhZX0ZSRVEgYW5kIHRoZSBhdHRyaWJ1dGVzIGRldGVybWluaW5nIGNoYW5uZWwKKyAqCXdpZHRoKS4gJU5MODAyMTFfQVRUUl9DSF9TV0lUQ0hfQkxPQ0tfVFggbWF5IGJlIHN1cHBsaWVkIHRvIGluZm9ybQorICoJb3RoZXIgc3RhdGlvbiB0aGF0IHRyYW5zbWlzc2lvbiBtdXN0IGJlIGJsb2NrZWQgdW50aWwgdGhlIGNoYW5uZWwKKyAqCXN3aXRjaCBpcyBjb21wbGV0ZS4KKyAqCisgKiBATkw4MDIxMV9DTURfVkVORE9SOiBWZW5kb3Itc3BlY2lmaWVkIGNvbW1hbmQvZXZlbnQuIFRoZSBjb21tYW5kIGlzIHNwZWNpZmllZAorICoJYnkgdGhlICVOTDgwMjExX0FUVFJfVkVORE9SX0lEIGF0dHJpYnV0ZSBhbmQgYSBzdWItY29tbWFuZCBpbgorICoJJU5MODAyMTFfQVRUUl9WRU5ET1JfU1VCQ01ELiBQYXJhbWV0ZXIocykgY2FuIGJlIHRyYW5zcG9ydGVkIGluCisgKgklTkw4MDIxMV9BVFRSX1ZFTkRPUl9EQVRBLgorICoJRm9yIGZlYXR1cmUgYWR2ZXJ0aXNlbWVudCwgdGhlICVOTDgwMjExX0FUVFJfVkVORE9SX0RBVEEgYXR0cmlidXRlIGlzCisgKgl1c2VkIGluIHRoZSB3aXBoeSBkYXRhIGFzIGEgbmVzdGVkIGF0dHJpYnV0ZSBjb250YWluaW5nIGRlc2NyaXB0aW9ucworICoJKCZzdHJ1Y3Qgbmw4MDIxMV92ZW5kb3JfY21kX2luZm8pIG9mIHRoZSBzdXBwb3J0ZWQgdmVuZG9yIGNvbW1hbmRzLgorICoJVGhpcyBtYXkgYWxzbyBiZSBzZW50IGFzIGFuIGV2ZW50IHdpdGggdGhlIHNhbWUgYXR0cmlidXRlcy4KKyAqCisgKiBATkw4MDIxMV9DTURfU0VUX1FPU19NQVA6IFNldCBJbnRlcndvcmtpbmcgUW9TIG1hcHBpbmcgZm9yIElQIERTQ1AgdmFsdWVzLgorICoJVGhlIFFvUyBtYXBwaW5nIGluZm9ybWF0aW9uIGlzIGluY2x1ZGVkIGluICVOTDgwMjExX0FUVFJfUU9TX01BUC4gSWYKKyAqCXRoYXQgYXR0cmlidXRlIGlzIG5vdCBpbmNsdWRlZCwgUW9TIG1hcHBpbmcgaXMgZGlzYWJsZWQuIFNpbmNlIHRoaXMKKyAqCVFvUyBtYXBwaW5nIGlzIHJlbGV2YW50IGZvciBJUCBwYWNrZXRzLCBpdCBpcyBvbmx5IHZhbGlkIGR1cmluZyBhbgorICoJYXNzb2NpYXRpb24uIFRoaXMgaXMgY2xlYXJlZCBvbiBkaXNhc3NvY2lhdGlvbiBhbmQgQVAgcmVzdGFydC4KKyAqCiAgKiBATkw4MDIxMV9DTURfTUFYOiBoaWdoZXN0IHVzZWQgY29tbWFuZCBudW1iZXIKICAqIEBfX05MODAyMTFfQ01EX0FGVEVSX0xBU1Q6IGludGVybmFsIHVzZQogICovCkBAIC04MTAsNiArODgxLDE1IEBACiAJTkw4MDIxMV9DTURfQ1JJVF9QUk9UT0NPTF9TVEFSVCwKIAlOTDgwMjExX0NNRF9DUklUX1BST1RPQ09MX1NUT1AsCiAKKwlOTDgwMjExX0NNRF9HRVRfQ09BTEVTQ0UsCisJTkw4MDIxMV9DTURfU0VUX0NPQUxFU0NFLAorCisJTkw4MDIxMV9DTURfQ0hBTk5FTF9TV0lUQ0gsCisKKwlOTDgwMjExX0NNRF9WRU5ET1IsCisKKwlOTDgwMjExX0NNRF9TRVRfUU9TX01BUCwKKwogCS8qIGFkZCBuZXcgY29tbWFuZHMgYWJvdmUgaGVyZSAqLwogCiAJLyogdXNlZCB0byBkZWZpbmUgTkw4MDIxMV9DTURfTUFYIGJlbG93ICovCkBAIC05NDUsNyArMTAyNSw3IEBACiAgKiAJdG8gcXVlcnkgdGhlIENSREEgdG8gcmV0cmlldmUgb25lIHJlZ3VsYXRvcnkgZG9tYWluLiBUaGlzIGF0dHJpYnV0ZSBjYW4KICAqIAlhbHNvIGJlIHVzZWQgYnkgdXNlcnNwYWNlIHRvIHF1ZXJ5IHRoZSBrZXJuZWwgZm9yIHRoZSBjdXJyZW50bHkgc2V0CiAgKiAJcmVndWxhdG9yeSBkb21haW4uIFdlIGNob3NlIGFuIGFscGhhMiBhcyB0aGF0IGlzIGFsc28gdXNlZCBieSB0aGUKLSAqIAlJRUVFLTgwMi4xMWQgY291bnRyeSBpbmZvcm1hdGlvbiBlbGVtZW50IHRvIGlkZW50aWZ5IGEgY291bnRyeS4KKyAqIAlJRUVFLTgwMi4xMSBjb3VudHJ5IGluZm9ybWF0aW9uIGVsZW1lbnQgdG8gaWRlbnRpZnkgYSBjb3VudHJ5LgogICogCVVzZXJzIGNhbiBhbHNvIHNpbXBseSBhc2sgdGhlIHdpcmVsZXNzIGNvcmUgdG8gc2V0IHJlZ3VsYXRvcnkgZG9tYWluCiAgKiAJdG8gYSBzcGVjaWZpYyBhbHBoYTIuCiAgKiBATkw4MDIxMV9BVFRSX1JFR19SVUxFUzogYSBuZXN0ZWQgYXJyYXkgb2YgcmVndWxhdG9yeSBkb21haW4gcmVndWxhdG9yeQpAQCAtMTQzNiw2ICsxNTE2LDczIEBACiAgKglhbGxvd2VkIHRvIGJlIHVzZWQgd2l0aCB0aGUgZmlyc3QgQE5MODAyMTFfQ01EX1NFVF9TVEFUSU9OIGNvbW1hbmQgdG8KICAqCXVwZGF0ZSBhIFRETFMgcGVlciBTVEEgZW50cnkuCiAgKgorICogQE5MODAyMTFfQVRUUl9DT0FMRVNDRV9SVUxFOiBDb2FsZXNjZSBydWxlIGluZm9ybWF0aW9uLgorICoKKyAqIEBOTDgwMjExX0FUVFJfQ0hfU1dJVENIX0NPVU5UOiB1MzIgYXR0cmlidXRlIHNwZWNpZnlpbmcgdGhlIG51bWJlciBvZiBUQlRUJ3MKKyAqCXVudGlsIHRoZSBjaGFubmVsIHN3aXRjaCBldmVudC4KKyAqIEBOTDgwMjExX0FUVFJfQ0hfU1dJVENIX0JMT0NLX1RYOiBmbGFnIGF0dHJpYnV0ZSBzcGVjaWZ5aW5nIHRoYXQgdHJhbnNtaXNzaW9uCisgKgltdXN0IGJlIGJsb2NrZWQgb24gdGhlIGN1cnJlbnQgY2hhbm5lbCAoYmVmb3JlIHRoZSBjaGFubmVsIHN3aXRjaAorICoJb3BlcmF0aW9uKS4KKyAqIEBOTDgwMjExX0FUVFJfQ1NBX0lFUzogTmVzdGVkIHNldCBvZiBhdHRyaWJ1dGVzIGNvbnRhaW5pbmcgdGhlIElFIGluZm9ybWF0aW9uCisgKglmb3IgdGhlIHRpbWUgd2hpbGUgcGVyZm9ybWluZyBhIGNoYW5uZWwgc3dpdGNoLgorICogQE5MODAyMTFfQVRUUl9DU0FfQ19PRkZfQkVBQ09OOiBPZmZzZXQgb2YgdGhlIGNoYW5uZWwgc3dpdGNoIGNvdW50ZXIKKyAqCWZpZWxkIGluIHRoZSBiZWFjb25zIHRhaWwgKCVOTDgwMjExX0FUVFJfQkVBQ09OX1RBSUwpLgorICogQE5MODAyMTFfQVRUUl9DU0FfQ19PRkZfUFJFU1A6IE9mZnNldCBvZiB0aGUgY2hhbm5lbCBzd2l0Y2ggY291bnRlcgorICoJZmllbGQgaW4gdGhlIHByb2JlIHJlc3BvbnNlICglTkw4MDIxMV9BVFRSX1BST0JFX1JFU1ApLgorICoKKyAqIEBOTDgwMjExX0FUVFJfUlhNR01UX0ZMQUdTOiBmbGFncyBmb3Igbmw4MDIxMV9zZW5kX21nbXQoKSwgdTMyLgorICoJQXMgc3BlY2lmaWVkIGluIHRoZSAmZW51bSBubDgwMjExX3J4bWdtdF9mbGFncy4KKyAqCisgKiBATkw4MDIxMV9BVFRSX1NUQV9TVVBQT1JURURfQ0hBTk5FTFM6IGFycmF5IG9mIHN1cHBvcnRlZCBjaGFubmVscy4KKyAqCisgKiBATkw4MDIxMV9BVFRSX1NUQV9TVVBQT1JURURfT1BFUl9DTEFTU0VTOiBhcnJheSBvZiBzdXBwb3J0ZWQKKyAqICAgICAgc3VwcG9ydGVkIG9wZXJhdGluZyBjbGFzc2VzLgorICoKKyAqIEBOTDgwMjExX0FUVFJfSEFORExFX0RGUzogQSBmbGFnIGluZGljYXRpbmcgd2hldGhlciB1c2VyIHNwYWNlCisgKgljb250cm9scyBERlMgb3BlcmF0aW9uIGluIElCU1MgbW9kZS4gSWYgdGhlIGZsYWcgaXMgaW5jbHVkZWQgaW4KKyAqCSVOTDgwMjExX0NNRF9KT0lOX0lCU1MgcmVxdWVzdCwgdGhlIGRyaXZlciB3aWxsIGFsbG93IHVzZSBvZiBERlMKKyAqCWNoYW5uZWxzIGFuZCByZXBvcnRzIHJhZGFyIGV2ZW50cyB0byB1c2Vyc3BhY2UuIFVzZXJzcGFjZSBpcyByZXF1aXJlZAorICoJdG8gcmVhY3QgdG8gcmFkYXIgZXZlbnRzLCBlLmcuIGluaXRpYXRlIGEgY2hhbm5lbCBzd2l0Y2ggb3IgbGVhdmUgdGhlCisgKglJQlNTIG5ldHdvcmsuCisgKgorICogQE5MODAyMTFfQVRUUl9TVVBQT1JUXzVfTUhaOiBBIGZsYWcgaW5kaWNhdGluZyB0aGF0IHRoZSBkZXZpY2Ugc3VwcG9ydHMKKyAqCTUgTUh6IGNoYW5uZWwgYmFuZHdpZHRoLgorICogQE5MODAyMTFfQVRUUl9TVVBQT1JUXzEwX01IWjogQSBmbGFnIGluZGljYXRpbmcgdGhhdCB0aGUgZGV2aWNlIHN1cHBvcnRzCisgKgkxMCBNSHogY2hhbm5lbCBiYW5kd2lkdGguCisgKgorICogQE5MODAyMTFfQVRUUl9PUE1PREVfTk9USUY6IE9wZXJhdGluZyBtb2RlIGZpZWxkIGZyb20gT3BlcmF0aW5nIE1vZGUKKyAqCU5vdGlmaWNhdGlvbiBFbGVtZW50IGJhc2VkIG9uIGFzc29jaWF0aW9uIHJlcXVlc3Qgd2hlbiB1c2VkIHdpdGgKKyAqCSVOTDgwMjExX0NNRF9ORVdfU1RBVElPTjsgdTggYXR0cmlidXRlLgorICoKKyAqIEBOTDgwMjExX0FUVFJfVkVORE9SX0lEOiBUaGUgdmVuZG9yIElELCBlaXRoZXIgYSAyNC1iaXQgT1VJIG9yLCBpZgorICoJJU5MODAyMTFfVkVORE9SX0lEX0lTX0xJTlVYIGlzIHNldCwgYSBzcGVjaWFsIExpbnV4IElEIChub3QgdXNlZCB5ZXQpCisgKiBATkw4MDIxMV9BVFRSX1ZFTkRPUl9TVUJDTUQ6IHZlbmRvciBzdWItY29tbWFuZAorICogQE5MODAyMTFfQVRUUl9WRU5ET1JfREFUQTogZGF0YSBmb3IgdGhlIHZlbmRvciBjb21tYW5kLCBpZiBhbnk7IHRoaXMKKyAqCWF0dHJpYnV0ZSBpcyBhbHNvIHVzZWQgZm9yIHZlbmRvciBjb21tYW5kIGZlYXR1cmUgYWR2ZXJ0aXNlbWVudAorICogQE5MODAyMTFfQVRUUl9WRU5ET1JfRVZFTlRTOiB1c2VkIGZvciBldmVudCBsaXN0IGFkdmVydGlzaW5nIGluIHRoZSB3aXBoeQorICoJaW5mbywgY29udGFpbmluZyBhIG5lc3RlZCBhcnJheSBvZiBwb3NzaWJsZSBldmVudHMKKyAqCisgKiBATkw4MDIxMV9BVFRSX1FPU19NQVA6IElQIERTQ1AgbWFwcGluZyBmb3IgSW50ZXJ3b3JraW5nIFFvUyBtYXBwaW5nLiBUaGlzCisgKglkYXRhIGlzIGluIHRoZSBmb3JtYXQgZGVmaW5lZCBmb3IgdGhlIHBheWxvYWQgb2YgdGhlIFFvUyBNYXAgU2V0IGVsZW1lbnQKKyAqCWluIElFRUUgU3RkIDgwMi4xMS0yMDEyLCA4LjQuMi45Ny4KKyAqCisgKiBATkw4MDIxMV9BVFRSX01BQ19ISU5UOiBNQUMgYWRkcmVzcyByZWNvbW1lbmRhdGlvbiBhcyBpbml0aWFsIEJTUworICogQE5MODAyMTFfQVRUUl9XSVBIWV9GUkVRX0hJTlQ6IGZyZXF1ZW5jeSBvZiB0aGUgcmVjb21tZW5kZWQgaW5pdGlhbCBCU1MKKyAqCisgKiBATkw4MDIxMV9BVFRSX01BWF9BUF9BU1NPQ19TVEE6IERldmljZSBhdHRyaWJ1dGUgdGhhdCBpbmRpY2F0ZXMgaG93IG1hbnkKKyAqCWFzc29jaWF0ZWQgc3RhdGlvbnMgYXJlIHN1cHBvcnRlZCBpbiBBUCBtb2RlIChpbmNsdWRpbmcgUDJQIEdPKTsgdTMyLgorICoJU2luY2UgZHJpdmVycyBtYXkgbm90IGhhdmUgYSBmaXhlZCBsaW1pdCBvbiB0aGUgbWF4aW11bSBudW1iZXIgKGUuZy4sCisgKglvdGhlciBjb25jdXJyZW50IG9wZXJhdGlvbnMgbWF5IGFmZmVjdCB0aGlzKSwgZHJpdmVycyBhcmUgYWxsb3dlZCB0bworICoJYWR2ZXJ0aXNlIHZhbHVlcyB0aGF0IGNhbm5vdCBhbHdheXMgYmUgbWV0LiBJbiBzdWNoIGNhc2VzLCBhbiBhdHRlbXB0CisgKgl0byBhZGQgYSBuZXcgc3RhdGlvbiBlbnRyeSB3aXRoIEBOTDgwMjExX0NNRF9ORVdfU1RBVElPTiBtYXkgZmFpbC4KKyAqCisgKiBATkw4MDIxMV9BVFRSX1RETFNfUEVFUl9DQVBBQklMSVRZOiBmbGFncyBmb3IgVERMUyBwZWVyIGNhcGFiaWxpdGllcywgdTMyLgorICoJQXMgc3BlY2lmaWVkIGluIHRoZSAmZW51bSBubDgwMjExX3RkbHNfcGVlcl9jYXBhYmlsaXR5LgorICoKKyAqIEBOTDgwMjExX0FUVFJfSUZBQ0VfU09DS0VUX09XTkVSOiBmbGFnIGF0dHJpYnV0ZSwgaWYgc2V0IGR1cmluZyBpbnRlcmZhY2UKKyAqCWNyZWF0aW9uIHRoZW4gdGhlIG5ldyBpbnRlcmZhY2Ugd2lsbCBiZSBvd25lZCBieSB0aGUgbmV0bGluayBzb2NrZXQKKyAqCXRoYXQgY3JlYXRlZCBpdCBhbmQgd2lsbCBiZSBkZXN0cm95ZWQgd2hlbiB0aGUgc29ja2V0IGlzIGNsb3NlZAorICoKICAqIEBOTDgwMjExX0FUVFJfTUFYOiBoaWdoZXN0IGF0dHJpYnV0ZSBudW1iZXIgY3VycmVudGx5IGRlZmluZWQKICAqIEBfX05MODAyMTFfQVRUUl9BRlRFUl9MQVNUOiBpbnRlcm5hbCB1c2UKICAqLwpAQCAtMTczNiw2ICsxODgzLDQzIEBACiAKIAlOTDgwMjExX0FUVFJfUEVFUl9BSUQsCiAKKwlOTDgwMjExX0FUVFJfQ09BTEVTQ0VfUlVMRSwKKworCU5MODAyMTFfQVRUUl9DSF9TV0lUQ0hfQ09VTlQsCisJTkw4MDIxMV9BVFRSX0NIX1NXSVRDSF9CTE9DS19UWCwKKwlOTDgwMjExX0FUVFJfQ1NBX0lFUywKKwlOTDgwMjExX0FUVFJfQ1NBX0NfT0ZGX0JFQUNPTiwKKwlOTDgwMjExX0FUVFJfQ1NBX0NfT0ZGX1BSRVNQLAorCisJTkw4MDIxMV9BVFRSX1JYTUdNVF9GTEFHUywKKworCU5MODAyMTFfQVRUUl9TVEFfU1VQUE9SVEVEX0NIQU5ORUxTLAorCisJTkw4MDIxMV9BVFRSX1NUQV9TVVBQT1JURURfT1BFUl9DTEFTU0VTLAorCisJTkw4MDIxMV9BVFRSX0hBTkRMRV9ERlMsCisKKwlOTDgwMjExX0FUVFJfU1VQUE9SVF81X01IWiwKKwlOTDgwMjExX0FUVFJfU1VQUE9SVF8xMF9NSFosCisKKwlOTDgwMjExX0FUVFJfT1BNT0RFX05PVElGLAorCisJTkw4MDIxMV9BVFRSX1ZFTkRPUl9JRCwKKwlOTDgwMjExX0FUVFJfVkVORE9SX1NVQkNNRCwKKwlOTDgwMjExX0FUVFJfVkVORE9SX0RBVEEsCisJTkw4MDIxMV9BVFRSX1ZFTkRPUl9FVkVOVFMsCisKKwlOTDgwMjExX0FUVFJfUU9TX01BUCwKKworCU5MODAyMTFfQVRUUl9NQUNfSElOVCwKKwlOTDgwMjExX0FUVFJfV0lQSFlfRlJFUV9ISU5ULAorCisJTkw4MDIxMV9BVFRSX01BWF9BUF9BU1NPQ19TVEEsCisKKwlOTDgwMjExX0FUVFJfVERMU19QRUVSX0NBUEFCSUxJVFksCisKKwlOTDgwMjExX0FUVFJfSUZBQ0VfU09DS0VUX09XTkVSLAorCiAJLyogYWRkIGF0dHJpYnV0ZXMgaGVyZSwgdXBkYXRlIHRoZSBwb2xpY3kgaW4gbmw4MDIxMS5jICovCiAKIAlfX05MODAyMTFfQVRUUl9BRlRFUl9MQVNULApAQCAtMjEzNiwxMCArMjMyMCw5IEBACiAgKiBATkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9GUkVROiBGcmVxdWVuY3kgaW4gTUh6CiAgKiBATkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9ESVNBQkxFRDogQ2hhbm5lbCBpcyBkaXNhYmxlZCBpbiBjdXJyZW50CiAgKglyZWd1bGF0b3J5IGRvbWFpbi4KLSAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX1BBU1NJVkVfU0NBTjogT25seSBwYXNzaXZlIHNjYW5uaW5nIGlzCi0gKglwZXJtaXR0ZWQgb24gdGhpcyBjaGFubmVsIGluIGN1cnJlbnQgcmVndWxhdG9yeSBkb21haW4uCi0gKiBATkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9OT19JQlNTOiBJQlNTIG5ldHdvcmtzIGFyZSBub3QgcGVybWl0dGVkCi0gKglvbiB0aGlzIGNoYW5uZWwgaW4gY3VycmVudCByZWd1bGF0b3J5IGRvbWFpbi4KKyAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lSOiBubyBtZWNoYW5pc21zIHRoYXQgaW5pdGlhdGUgcmFkaWF0aW9uCisgKiAJYXJlIHBlcm1pdHRlZCBvbiB0aGlzIGNoYW5uZWwsIHRoaXMgaW5jbHVkZXMgc2VuZGluZyBwcm9iZQorICogCXJlcXVlc3RzLCBvciBtb2RlcyBvZiBvcGVyYXRpb24gdGhhdCByZXF1aXJlIGJlYWNvbmluZy4KICAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX1JBREFSOiBSYWRhciBkZXRlY3Rpb24gaXMgbWFuZGF0b3J5CiAgKglvbiB0aGlzIGNoYW5uZWwgaW4gY3VycmVudCByZWd1bGF0b3J5IGRvbWFpbi4KICAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWF9UWF9QT1dFUjogTWF4aW11bSB0cmFuc21pc3Npb24gcG93ZXIgaW4gbUJtCkBAIC0yMTU4LDE2ICsyMzQxLDQyIEBACiAgKiBATkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9OT18xNjBNSFo6IGFueSAxNjAgTUh6IChidXQgbm90IDgwKzgwKSBjaGFubmVsCiAgKgl1c2luZyB0aGlzIGNoYW5uZWwgYXMgdGhlIHByaW1hcnkgb3IgYW55IG9mIHRoZSBzZWNvbmRhcnkgY2hhbm5lbHMKICAqCWlzbid0IHBvc3NpYmxlCisgKiBATkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9ERlNfQ0FDX1RJTUU6IERGUyBDQUMgdGltZSBpbiBtaWxsaXNlY29uZHMuCisgKiBATkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9JTkRPT1JfT05MWTogT25seSBpbmRvb3IgdXNlIGlzIHBlcm1pdHRlZCBvbiB0aGlzCisgKgljaGFubmVsLiBBIGNoYW5uZWwgdGhhdCBoYXMgdGhlIElORE9PUl9PTkxZIGF0dHJpYnV0ZSBjYW4gb25seSBiZQorICoJdXNlZCB3aGVuIHRoZXJlIGlzIGEgY2xlYXIgYXNzZXNzbWVudCB0aGF0IHRoZSBkZXZpY2UgaXMgb3BlcmF0aW5nIGluCisgKglhbiBpbmRvb3Igc3Vycm91bmRpbmdzLCBpLmUuLCBpdCBpcyBjb25uZWN0ZWQgdG8gQUMgcG93ZXIgKGFuZCBub3QKKyAqCXRocm91Z2ggcG9ydGFibGUgREMgaW52ZXJ0ZXJzKSBvciBpcyB1bmRlciB0aGUgY29udHJvbCBvZiBhIG1hc3RlcgorICoJdGhhdCBpcyBhY3RpbmcgYXMgYW4gQVAgYW5kIGlzIGNvbm5lY3RlZCB0byBBQyBwb3dlci4KKyAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0dPX0NPTkNVUlJFTlQ6IEdPIG9wZXJhdGlvbiBpcyBhbGxvd2VkIG9uIHRoaXMKKyAqCWNoYW5uZWwgaWYgaXQncyBjb25uZWN0ZWQgY29uY3VycmVudGx5IHRvIGEgQlNTIG9uIHRoZSBzYW1lIGNoYW5uZWwgb24KKyAqCXRoZSAyIEdIeiBiYW5kIG9yIHRvIGEgY2hhbm5lbCBpbiB0aGUgc2FtZSBVTklJIGJhbmQgKG9uIHRoZSA1IEdIegorICoJYmFuZCksIGFuZCBJRUVFODAyMTFfQ0hBTl9SQURBUiBpcyBub3Qgc2V0LiBJbnN0YW50aWF0aW5nIGEgR08gb24gYQorICoJY2hhbm5lbCB0aGF0IGhhcyB0aGUgR09fQ09OQ1VSUkVOVCBhdHRyaWJ1dGUgc2V0IGNhbiBiZSBkb25lIHdoZW4gdGhlcmUKKyAqCWlzIGEgY2xlYXIgYXNzZXNzbWVudCB0aGF0IHRoZSBkZXZpY2UgaXMgb3BlcmF0aW5nIHVuZGVyIHRoZSBndWlkYW5jZSBvZgorICoJYW4gYXV0aG9yaXplZCBtYXN0ZXIsIGkuZS4sIHNldHRpbmcgdXAgYSBHTyB3aGlsZSB0aGUgZGV2aWNlIGlzIGFsc28KKyAqCWNvbm5lY3RlZCB0byBhbiBBUCB3aXRoIERGUyBhbmQgcmFkYXIgZGV0ZWN0aW9uIG9uIHRoZSBVTklJIGJhbmQgKGl0IGlzCisgKgl1cCB0byB1c2VyLXNwYWNlLCBpLmUuLCB3cGFfc3VwcGxpY2FudCB0byBwZXJmb3JtIHRoZSByZXF1aXJlZAorICoJdmVyaWZpY2F0aW9ucykKKyAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PXzIwTUhaOiAyMCBNSHogb3BlcmF0aW9uIGlzIG5vdCBhbGxvd2VkCisgKglvbiB0aGlzIGNoYW5uZWwgaW4gY3VycmVudCByZWd1bGF0b3J5IGRvbWFpbi4KKyAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PXzEwTUhaOiAxMCBNSHogb3BlcmF0aW9uIGlzIG5vdCBhbGxvd2VkCisgKglvbiB0aGlzIGNoYW5uZWwgaW4gY3VycmVudCByZWd1bGF0b3J5IGRvbWFpbi4KICAqIEBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWDogaGlnaGVzdCBmcmVxdWVuY3kgYXR0cmlidXRlIG51bWJlcgogICoJY3VycmVudGx5IGRlZmluZWQKICAqIEBfX05MODAyMTFfRlJFUVVFTkNZX0FUVFJfQUZURVJfTEFTVDogaW50ZXJuYWwgdXNlCisgKgorICogU2VlIGh0dHBzOi8vYXBwcy5mY2MuZ292L2Vhcy9jb21tZW50cy9HZXRQdWJsaXNoZWREb2N1bWVudC5odG1sP2lkPTMyNyZ0bj01MjgxMjIKKyAqIGZvciBtb3JlIGluZm9ybWF0aW9uIG9uIHRoZSBGQ0MgZGVzY3JpcHRpb24gb2YgdGhlIHJlbGF4YXRpb25zIGFsbG93ZWQKKyAqIGJ5IE5MODAyMTFfRlJFUVVFTkNZX0FUVFJfSU5ET09SX09OTFkgYW5kCisgKiBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0dPX0NPTkNVUlJFTlQuCiAgKi8KIGVudW0gbmw4MDIxMV9mcmVxdWVuY3lfYXR0ciB7CiAJX19OTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0lOVkFMSUQsCiAJTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9GUkVRLAogCU5MODAyMTFfRlJFUVVFTkNZX0FUVFJfRElTQUJMRUQsCi0JTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9QQVNTSVZFX1NDQU4sCi0JTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9OT19JQlNTLAorCU5MODAyMTFfRlJFUVVFTkNZX0FUVFJfTk9fSVIsCisJX19OTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lCU1MsCiAJTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9SQURBUiwKIAlOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWF9UWF9QT1dFUiwKIAlOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0RGU19TVEFURSwKQEAgLTIxNzYsNiArMjM4NSwxMSBAQAogCU5MODAyMTFfRlJFUVVFTkNZX0FUVFJfTk9fSFQ0MF9QTFVTLAogCU5MODAyMTFfRlJFUVVFTkNZX0FUVFJfTk9fODBNSFosCiAJTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9OT18xNjBNSFosCisJTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9ERlNfQ0FDX1RJTUUsCisJTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9JTkRPT1JfT05MWSwKKwlOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0dPX0NPTkNVUlJFTlQsCisJTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9OT18yME1IWiwKKwlOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PXzEwTUhaLAogCiAJLyoga2VlcCBsYXN0ICovCiAJX19OTDgwMjExX0ZSRVFVRU5DWV9BVFRSX0FGVEVSX0xBU1QsCkBAIC0yMTgzLDYgKzIzOTcsOSBAQAogfTsKIAogI2RlZmluZSBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWF9UWF9QT1dFUiBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX01BWF9UWF9QT1dFUgorI2RlZmluZSBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX1BBU1NJVkVfU0NBTglOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lSCisjZGVmaW5lIE5MODAyMTFfRlJFUVVFTkNZX0FUVFJfTk9fSUJTUwkJTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9OT19JUgorI2RlZmluZSBOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lSCQlOTDgwMjExX0ZSRVFVRU5DWV9BVFRSX05PX0lSCiAKIC8qKgogICogZW51bSBubDgwMjExX2JpdHJhdGVfYXR0ciAtIGJpdHJhdGUgYXR0cmlidXRlcwpAQCAtMjI2MywxMiArMjQ4MCwxNCBAQAogICogCWluIEtIei4gVGhpcyBpcyBub3QgYSBjZW50ZXIgYSBmcmVxdWVuY3kgYnV0IGFuIGFjdHVhbCByZWd1bGF0b3J5CiAgKiAJYmFuZCBlZGdlLgogICogQE5MODAyMTFfQVRUUl9GUkVRX1JBTkdFX01BWF9CVzogbWF4aW11bSBhbGxvd2VkIGJhbmR3aWR0aCBmb3IgdGhpcwotICogCWZyZXF1ZW5jeSByYW5nZSwgaW4gS0h6LgorICoJZnJlcXVlbmN5IHJhbmdlLCBpbiBLSHouCiAgKiBATkw4MDIxMV9BVFRSX1BPV0VSX1JVTEVfTUFYX0FOVF9HQUlOOiB0aGUgbWF4aW11bSBhbGxvd2VkIGFudGVubmEgZ2FpbgogICogCWZvciBhIGdpdmVuIGZyZXF1ZW5jeSByYW5nZS4gVGhlIHZhbHVlIGlzIGluIG1CaSAoMTAwICogZEJpKS4KICAqIAlJZiB5b3UgZG9uJ3QgaGF2ZSBvbmUgdGhlbiBkb24ndCBzZW5kIHRoaXMuCiAgKiBATkw4MDIxMV9BVFRSX1BPV0VSX1JVTEVfTUFYX0VJUlA6IHRoZSBtYXhpbXVtIGFsbG93ZWQgRUlSUCBmb3IKICAqIAlhIGdpdmVuIGZyZXF1ZW5jeSByYW5nZS4gVGhlIHZhbHVlIGlzIGluIG1CbSAoMTAwICogZEJtKS4KKyAqIEBOTDgwMjExX0FUVFJfREZTX0NBQ19USU1FOiBERlMgQ0FDIHRpbWUgaW4gbWlsbGlzZWNvbmRzLgorICoJSWYgbm90IHByZXNlbnQgb3IgMCBkZWZhdWx0IENBQyB0aW1lIHdpbGwgYmUgdXNlZC4KICAqIEBOTDgwMjExX1JFR19SVUxFX0FUVFJfTUFYOiBoaWdoZXN0IHJlZ3VsYXRvcnkgcnVsZSBhdHRyaWJ1dGUgbnVtYmVyCiAgKgljdXJyZW50bHkgZGVmaW5lZAogICogQF9fTkw4MDIxMV9SRUdfUlVMRV9BVFRSX0FGVEVSX0xBU1Q6IGludGVybmFsIHVzZQpAQCAtMjI4NCw2ICsyNTAzLDggQEAKIAlOTDgwMjExX0FUVFJfUE9XRVJfUlVMRV9NQVhfQU5UX0dBSU4sCiAJTkw4MDIxMV9BVFRSX1BPV0VSX1JVTEVfTUFYX0VJUlAsCiAKKwlOTDgwMjExX0FUVFJfREZTX0NBQ19USU1FLAorCiAJLyoga2VlcCBsYXN0ICovCiAJX19OTDgwMjExX1JFR19SVUxFX0FUVFJfQUZURVJfTEFTVCwKIAlOTDgwMjExX1JFR19SVUxFX0FUVFJfTUFYID0gX19OTDgwMjExX1JFR19SVUxFX0FUVFJfQUZURVJfTEFTVCAtIDEKQEAgLTIyOTMsOSArMjUxNCwxNSBAQAogICogZW51bSBubDgwMjExX3NjaGVkX3NjYW5fbWF0Y2hfYXR0ciAtIHNjaGVkdWxlZCBzY2FuIG1hdGNoIGF0dHJpYnV0ZXMKICAqIEBfX05MODAyMTFfU0NIRURfU0NBTl9NQVRDSF9BVFRSX0lOVkFMSUQ6IGF0dHJpYnV0ZSBudW1iZXIgMCBpcyByZXNlcnZlZAogICogQE5MODAyMTFfU0NIRURfU0NBTl9NQVRDSF9BVFRSX1NTSUQ6IFNTSUQgdG8gYmUgdXNlZCBmb3IgbWF0Y2hpbmcsCi0gKiBvbmx5IHJlcG9ydCBCU1Mgd2l0aCBtYXRjaGluZyBTU0lELgorICoJb25seSByZXBvcnQgQlNTIHdpdGggbWF0Y2hpbmcgU1NJRC4KICAqIEBOTDgwMjExX1NDSEVEX1NDQU5fTUFUQ0hfQVRUUl9SU1NJOiBSU1NJIHRocmVzaG9sZCAoaW4gZEJtKSBmb3IgcmVwb3J0aW5nIGEKLSAqCUJTUyBpbiBzY2FuIHJlc3VsdHMuIEZpbHRlcmluZyBpcyB0dXJuZWQgb2ZmIGlmIG5vdCBzcGVjaWZpZWQuCisgKglCU1MgaW4gc2NhbiByZXN1bHRzLiBGaWx0ZXJpbmcgaXMgdHVybmVkIG9mZiBpZiBub3Qgc3BlY2lmaWVkLiBOb3RlIHRoYXQKKyAqCWlmIHRoaXMgYXR0cmlidXRlIGlzIGluIGEgbWF0Y2ggc2V0IG9mIGl0cyBvd24sIHRoZW4gaXQgaXMgdHJlYXRlZCBhcworICoJdGhlIGRlZmF1bHQgdmFsdWUgZm9yIGFsbCBtYXRjaHNldHMgd2l0aCBhbiBTU0lELCByYXRoZXIgdGhhbiBiZWluZyBhCisgKgltYXRjaHNldCBvZiBpdHMgb3duIHdpdGhvdXQgYW4gUlNTSSBmaWx0ZXIuIFRoaXMgaXMgZHVlIHRvIHByb2JsZW1zIHdpdGgKKyAqCWhvdyB0aGlzIEFQSSB3YXMgaW1wbGVtZW50ZWQgaW4gdGhlIHBhc3QuIEFsc28sIGR1ZSB0byB0aGUgc2FtZSBwcm9ibGVtLAorICoJdGhlIG9ubHkgd2F5IHRvIGNyZWF0ZSBhIG1hdGNoc2V0IHdpdGggb25seSBhbiBSU1NJIGZpbHRlciAod2l0aCB0aGlzCisgKglhdHRyaWJ1dGUpIGlzIGlmIHRoZXJlJ3Mgb25seSBhIHNpbmdsZSBtYXRjaHNldCB3aXRoIHRoZSBSU1NJIGF0dHJpYnV0ZS4KICAqIEBOTDgwMjExX1NDSEVEX1NDQU5fTUFUQ0hfQVRUUl9NQVg6IGhpZ2hlc3Qgc2NoZWR1bGVkIHNjYW4gZmlsdGVyCiAgKglhdHRyaWJ1dGUgbnVtYmVyIGN1cnJlbnRseSBkZWZpbmVkCiAgKiBAX19OTDgwMjExX1NDSEVEX1NDQU5fTUFUQ0hfQVRUUl9BRlRFUl9MQVNUOiBpbnRlcm5hbCB1c2UKQEAgLTIzMjUsOCArMjU1MiwxMiBAQAogICogQE5MODAyMTFfUlJGX0RGUzogREZTIHN1cHBvcnQgaXMgcmVxdWlyZWQgdG8gYmUgdXNlZAogICogQE5MODAyMTFfUlJGX1BUUF9PTkxZOiB0aGlzIGlzIG9ubHkgZm9yIFBvaW50IFRvIFBvaW50IGxpbmtzCiAgKiBATkw4MDIxMV9SUkZfUFRNUF9PTkxZOiB0aGlzIGlzIG9ubHkgZm9yIFBvaW50IFRvIE11bHRpIFBvaW50IGxpbmtzCi0gKiBATkw4MDIxMV9SUkZfUEFTU0lWRV9TQ0FOOiBwYXNzaXZlIHNjYW4gaXMgcmVxdWlyZWQKLSAqIEBOTDgwMjExX1JSRl9OT19JQlNTOiBubyBJQlNTIGlzIGFsbG93ZWQKKyAqIEBOTDgwMjExX1JSRl9OT19JUjogbm8gbWVjaGFuaXNtcyB0aGF0IGluaXRpYXRlIHJhZGlhdGlvbiBhcmUgYWxsb3dlZCwKKyAqIAl0aGlzIGluY2x1ZGVzIHByb2JlIHJlcXVlc3RzIG9yIG1vZGVzIG9mIG9wZXJhdGlvbiB0aGF0IHJlcXVpcmUKKyAqIAliZWFjb25pbmcuCisgKiBATkw4MDIxMV9SUkZfQVVUT19CVzogbWF4aW11bSBhdmFpbGFibGUgYmFuZHdpZHRoIHNob3VsZCBiZSBjYWxjdWxhdGVkCisgKgliYXNlIG9uIGNvbnRpZ3VvdXMgcnVsZXMgYW5kIHdpZGVyIGNoYW5uZWxzIHdpbGwgYmUgYWxsb3dlZCB0byBjcm9zcworICoJbXVsdGlwbGUgY29udGlndW91cy9vdmVybGFwcGluZyBmcmVxdWVuY3kgcmFuZ2VzLgogICovCiBlbnVtIG5sODAyMTFfcmVnX3J1bGVfZmxhZ3MgewogCU5MODAyMTFfUlJGX05PX09GRE0JCT0gMTw8MCwKQEAgLTIzMzYsMTAgKzI1NjcsMTggQEAKIAlOTDgwMjExX1JSRl9ERlMJCQk9IDE8PDQsCiAJTkw4MDIxMV9SUkZfUFRQX09OTFkJCT0gMTw8NSwKIAlOTDgwMjExX1JSRl9QVE1QX09OTFkJCT0gMTw8NiwKLQlOTDgwMjExX1JSRl9QQVNTSVZFX1NDQU4JPSAxPDw3LAotCU5MODAyMTFfUlJGX05PX0lCU1MJCT0gMTw8OCwKKwlOTDgwMjExX1JSRl9OT19JUgkJPSAxPDw3LAorCV9fTkw4MDIxMV9SUkZfTk9fSUJTUwkJPSAxPDw4LAorCU5MODAyMTFfUlJGX0FVVE9fQlcJCT0gMTw8MTEsCiB9OwogCisjZGVmaW5lIE5MODAyMTFfUlJGX1BBU1NJVkVfU0NBTglOTDgwMjExX1JSRl9OT19JUgorI2RlZmluZSBOTDgwMjExX1JSRl9OT19JQlNTCQlOTDgwMjExX1JSRl9OT19JUgorI2RlZmluZSBOTDgwMjExX1JSRl9OT19JUgkJTkw4MDIxMV9SUkZfTk9fSVIKKworLyogRm9yIGJhY2twb3J0IGNvbXBhdGliaWxpdHkgd2l0aCBvbGRlciB1c2Vyc3BhY2UgKi8KKyNkZWZpbmUgTkw4MDIxMV9SUkZfTk9fSVJfQUxMCQkoTkw4MDIxMV9SUkZfTk9fSVIgfCBfX05MODAyMTFfUlJGX05PX0lCU1MpCisKIC8qKgogICogZW51bSBubDgwMjExX2Rmc19yZWdpb25zIC0gcmVndWxhdG9yeSBERlMgcmVnaW9ucwogICoKQEAgLTIzNjksMTAgKzI2MDgsMTMgQEAKICAqCXByZXNlbnQgaGFzIGJlZW4gcmVnaXN0ZXJlZCB3aXRoIHRoZSB3aXJlbGVzcyBjb3JlIHRoYXQKICAqCWhhcyBsaXN0ZWQgTkw4MDIxMV9GRUFUVVJFX0NFTExfQkFTRV9SRUdfSElOVFMgYXMgYQogICoJc3VwcG9ydGVkIGZlYXR1cmUuCisgKiBATkw4MDIxMV9VU0VSX1JFR19ISU5UX0lORE9PUjogYSB1c2VyIHNlbnQgYW4gaGludCBpbmRpY2F0aW5nIHRoYXQgdGhlCisgKglwbGF0Zm9ybSBpcyBvcGVyYXRpbmcgaW4gYW4gaW5kb29yIGVudmlyb25tZW50LgogICovCiBlbnVtIG5sODAyMTFfdXNlcl9yZWdfaGludF90eXBlIHsKIAlOTDgwMjExX1VTRVJfUkVHX0hJTlRfVVNFUgk9IDAsCiAJTkw4MDIxMV9VU0VSX1JFR19ISU5UX0NFTExfQkFTRSA9IDEsCisJTkw4MDIxMV9VU0VSX1JFR19ISU5UX0lORE9PUiAgICA9IDIsCiB9OwogCiAvKioKQEAgLTI0MjgsNiArMjY3MCw4IEBACiAgKiBATkw4MDIxMV9NTlRSX0ZMQUdfT1RIRVJfQlNTOiBkaXNhYmxlIEJTU0lEIGZpbHRlcmluZwogICogQE5MODAyMTFfTU5UUl9GTEFHX0NPT0tfRlJBTUVTOiByZXBvcnQgZnJhbWVzIGFmdGVyIHByb2Nlc3NpbmcuCiAgKglvdmVycmlkZXMgYWxsIG90aGVyIGZsYWdzLgorICogQE5MODAyMTFfTU5UUl9GTEFHX0FDVElWRTogdXNlIHRoZSBjb25maWd1cmVkIE1BQyBhZGRyZXNzCisgKglhbmQgQUNLIGluY29taW5nIHVuaWNhc3QgcGFja2V0cy4KICAqCiAgKiBAX19OTDgwMjExX01OVFJfRkxBR19BRlRFUl9MQVNUOiBpbnRlcm5hbCB1c2UKICAqIEBOTDgwMjExX01OVFJfRkxBR19NQVg6IGhpZ2hlc3QgcG9zc2libGUgbW9uaXRvciBmbGFnCkBAIC0yNDM5LDYgKzI2ODMsNyBAQAogCU5MODAyMTFfTU5UUl9GTEFHX0NPTlRST0wsCiAJTkw4MDIxMV9NTlRSX0ZMQUdfT1RIRVJfQlNTLAogCU5MODAyMTFfTU5UUl9GTEFHX0NPT0tfRlJBTUVTLAorCU5MODAyMTFfTU5UUl9GTEFHX0FDVElWRSwKIAogCS8qIGtlZXAgbGFzdCAqLwogCV9fTkw4MDIxMV9NTlRSX0ZMQUdfQUZURVJfTEFTVCwKQEAgLTI1NzQsNiArMjgxOSwxMCBAQAogICoKICAqIEBOTDgwMjExX01FU0hDT05GX0FXQUtFX1dJTkRPVzogYXdha2Ugd2luZG93IGR1cmF0aW9uIChpbiBUVXMpCiAgKgorICogQE5MODAyMTFfTUVTSENPTkZfUExJTktfVElNRU9VVDogSWYgbm8gdHggYWN0aXZpdHkgaXMgc2VlbiBmcm9tIGEgU1RBIHdlJ3ZlCisgKgllc3RhYmxpc2hlZCBwZWVyaW5nIHdpdGggZm9yIGxvbmdlciB0aGFuIHRoaXMgdGltZSAoaW4gc2Vjb25kcyksIHRoZW4KKyAqCXJlbW92ZSBpdCBmcm9tIHRoZSBTVEEncyBsaXN0IG9mIHBlZXJzLiAgRGVmYXVsdCBpcyAzMCBtaW51dGVzLgorICoKICAqIEBfX05MODAyMTFfTUVTSENPTkZfQVRUUl9BRlRFUl9MQVNUOiBpbnRlcm5hbCB1c2UKICAqLwogZW51bSBubDgwMjExX21lc2hjb25mX3BhcmFtcyB7CkBAIC0yNjA1LDYgKzI4NTQsNyBAQAogCU5MODAyMTFfTUVTSENPTkZfSFdNUF9DT05GSVJNQVRJT05fSU5URVJWQUwsCiAJTkw4MDIxMV9NRVNIQ09ORl9QT1dFUl9NT0RFLAogCU5MODAyMTFfTUVTSENPTkZfQVdBS0VfV0lORE9XLAorCU5MODAyMTFfTUVTSENPTkZfUExJTktfVElNRU9VVCwKIAogCS8qIGtlZXAgbGFzdCAqLwogCV9fTkw4MDIxMV9NRVNIQ09ORl9BVFRSX0FGVEVSX0xBU1QsCkBAIC0yNzUwLDYgKzMwMDAsOCBAQAogICoJYW5kICVOTDgwMjExX0FUVFJfQ0VOVEVSX0ZSRVEyIGF0dHJpYnV0ZXMgbXVzdCBiZSBwcm92aWRlZCBhcyB3ZWxsCiAgKiBATkw4MDIxMV9DSEFOX1dJRFRIXzE2MDogMTYwIE1IeiBjaGFubmVsLCB0aGUgJU5MODAyMTFfQVRUUl9DRU5URVJfRlJFUTEKICAqCWF0dHJpYnV0ZSBtdXN0IGJlIHByb3ZpZGVkIGFzIHdlbGwKKyAqIEBOTDgwMjExX0NIQU5fV0lEVEhfNTogNSBNSHogT0ZETSBjaGFubmVsCisgKiBATkw4MDIxMV9DSEFOX1dJRFRIXzEwOiAxMCBNSHogT0ZETSBjaGFubmVsCiAgKi8KIGVudW0gbmw4MDIxMV9jaGFuX3dpZHRoIHsKIAlOTDgwMjExX0NIQU5fV0lEVEhfMjBfTk9IVCwKQEAgLTI3NTgsNiArMzAxMCwyMyBAQAogCU5MODAyMTFfQ0hBTl9XSURUSF84MCwKIAlOTDgwMjExX0NIQU5fV0lEVEhfODBQODAsCiAJTkw4MDIxMV9DSEFOX1dJRFRIXzE2MCwKKwlOTDgwMjExX0NIQU5fV0lEVEhfNSwKKwlOTDgwMjExX0NIQU5fV0lEVEhfMTAsCit9OworCisvKioKKyAqIGVudW0gbmw4MDIxMV9ic3Nfc2Nhbl93aWR0aCAtIGNvbnRyb2wgY2hhbm5lbCB3aWR0aCBmb3IgYSBCU1MKKyAqCisgKiBUaGVzZSB2YWx1ZXMgYXJlIHVzZWQgd2l0aCB0aGUgJU5MODAyMTFfQlNTX0NIQU5fV0lEVEggYXR0cmlidXRlLgorICoKKyAqIEBOTDgwMjExX0JTU19DSEFOX1dJRFRIXzIwOiBjb250cm9sIGNoYW5uZWwgaXMgMjAgTUh6IHdpZGUgb3IgY29tcGF0aWJsZQorICogQE5MODAyMTFfQlNTX0NIQU5fV0lEVEhfMTA6IGNvbnRyb2wgY2hhbm5lbCBpcyAxMCBNSHogd2lkZQorICogQE5MODAyMTFfQlNTX0NIQU5fV0lEVEhfNTogY29udHJvbCBjaGFubmVsIGlzIDUgTUh6IHdpZGUKKyAqLworZW51bSBubDgwMjExX2Jzc19zY2FuX3dpZHRoIHsKKwlOTDgwMjExX0JTU19DSEFOX1dJRFRIXzIwLAorCU5MODAyMTFfQlNTX0NIQU5fV0lEVEhfMTAsCisJTkw4MDIxMV9CU1NfQ0hBTl9XSURUSF81LAogfTsKIAogLyoqCkBAIC0yNzg0LDYgKzMwNTMsOCBAQAogICogQE5MODAyMTFfQlNTX0JFQUNPTl9JRVM6IGJpbmFyeSBhdHRyaWJ1dGUgY29udGFpbmluZyB0aGUgcmF3IGluZm9ybWF0aW9uCiAgKgllbGVtZW50cyBmcm9tIGEgQmVhY29uIGZyYW1lIChiaW4pOyBub3QgcHJlc2VudCBpZiBubyBCZWFjb24gZnJhbWUgaGFzCiAgKgl5ZXQgYmVlbiByZWNlaXZlZAorICogQE5MODAyMTFfQlNTX0NIQU5fV0lEVEg6IGNoYW5uZWwgd2lkdGggb2YgdGhlIGNvbnRyb2wgY2hhbm5lbAorICoJKHUzMiwgZW51bSBubDgwMjExX2Jzc19zY2FuX3dpZHRoKQogICogQF9fTkw4MDIxMV9CU1NfQUZURVJfTEFTVDogaW50ZXJuYWwKICAqIEBOTDgwMjExX0JTU19NQVg6IGhpZ2hlc3QgQlNTIGF0dHJpYnV0ZQogICovCkBAIC0yODAwLDYgKzMwNzEsNyBAQAogCU5MODAyMTFfQlNTX1NUQVRVUywKIAlOTDgwMjExX0JTU19TRUVOX01TX0FHTywKIAlOTDgwMjExX0JTU19CRUFDT05fSUVTLAorCU5MODAyMTFfQlNTX0NIQU5fV0lEVEgsCiAKIAkvKiBrZWVwIGxhc3QgKi8KIAlfX05MODAyMTFfQlNTX0FGVEVSX0xBU1QsCkBAIC0yOTQwLDIxICszMjEyLDQzIEBACiAgKglpbiBhbiBhcnJheSBvZiByYXRlcyBhcyBkZWZpbmVkIGluIElFRUUgODAyLjExIDcuMy4yLjIgKHU4IHZhbHVlcyB3aXRoCiAgKgkxID0gNTAwIGticHMpIGJ1dCB3aXRob3V0IHRoZSBJRSBsZW5ndGggcmVzdHJpY3Rpb24gKGF0IG1vc3QKICAqCSVOTDgwMjExX01BWF9TVVBQX1JBVEVTIGluIGEgc2luZ2xlIGFycmF5KS4KLSAqIEBOTDgwMjExX1RYUkFURV9NQ1M6IEhUIChNQ1MpIHJhdGVzIGFsbG93ZWQgZm9yIFRYIHJhdGUgc2VsZWN0aW9uCisgKiBATkw4MDIxMV9UWFJBVEVfSFQ6IEhUIChNQ1MpIHJhdGVzIGFsbG93ZWQgZm9yIFRYIHJhdGUgc2VsZWN0aW9uCiAgKglpbiBhbiBhcnJheSBvZiBNQ1MgbnVtYmVycy4KKyAqIEBOTDgwMjExX1RYUkFURV9WSFQ6IFZIVCByYXRlcyBhbGxvd2VkIGZvciBUWCByYXRlIHNlbGVjdGlvbiwKKyAqCXNlZSAmc3RydWN0IG5sODAyMTFfdHhyYXRlX3ZodAorICogQE5MODAyMTFfVFhSQVRFX0dJOiBjb25maWd1cmUgR0ksIHNlZSAmZW51bSBubDgwMjExX3R4cmF0ZV9naQogICogQF9fTkw4MDIxMV9UWFJBVEVfQUZURVJfTEFTVDogaW50ZXJuYWwKICAqIEBOTDgwMjExX1RYUkFURV9NQVg6IGhpZ2hlc3QgVFggcmF0ZSBhdHRyaWJ1dGUKICAqLwogZW51bSBubDgwMjExX3R4X3JhdGVfYXR0cmlidXRlcyB7CiAJX19OTDgwMjExX1RYUkFURV9JTlZBTElELAogCU5MODAyMTFfVFhSQVRFX0xFR0FDWSwKLQlOTDgwMjExX1RYUkFURV9NQ1MsCisJTkw4MDIxMV9UWFJBVEVfSFQsCisJTkw4MDIxMV9UWFJBVEVfVkhULAorCU5MODAyMTFfVFhSQVRFX0dJLAogCiAJLyoga2VlcCBsYXN0ICovCiAJX19OTDgwMjExX1RYUkFURV9BRlRFUl9MQVNULAogCU5MODAyMTFfVFhSQVRFX01BWCA9IF9fTkw4MDIxMV9UWFJBVEVfQUZURVJfTEFTVCAtIDEKIH07CiAKKyNkZWZpbmUgTkw4MDIxMV9UWFJBVEVfTUNTIE5MODAyMTFfVFhSQVRFX0hUCisjZGVmaW5lIE5MODAyMTFfVkhUX05TU19NQVgJCTgKKworLyoqCisgKiBzdHJ1Y3Qgbmw4MDIxMV90eHJhdGVfdmh0IC0gVkhUIE1DUy9OU1MgdHhyYXRlIGJpdG1hcAorICogQG1jczogTUNTIGJpdG1hcCB0YWJsZSBmb3IgZWFjaCBOU1MgKGFycmF5IGluZGV4IDAgZm9yIDEgc3RyZWFtLCBldGMuKQorICovCitzdHJ1Y3Qgbmw4MDIxMV90eHJhdGVfdmh0IHsKKwlfX3UxNiBtY3NbTkw4MDIxMV9WSFRfTlNTX01BWF07Cit9OworCitlbnVtIG5sODAyMTFfdHhyYXRlX2dpIHsKKwlOTDgwMjExX1RYUkFURV9ERUZBVUxUX0dJLAorCU5MODAyMTFfVFhSQVRFX0ZPUkNFX1NHSSwKKwlOTDgwMjExX1RYUkFURV9GT1JDRV9MR0ksCit9OworCiAvKioKICAqIGVudW0gbmw4MDIxMV9iYW5kIC0gRnJlcXVlbmN5IGJhbmQKICAqIEBOTDgwMjExX0JBTkRfMkdIWjogMi40IEdIeiBJU00gYmFuZApAQCAtMzA0OCwxMSArMzM0MiwxMSBAQAogfTsKIAogLyoqCi0gKiBlbnVtIG5sODAyMTFfd293bGFuX3BhY2tldF9wYXR0ZXJuX2F0dHIgLSBXb1dMQU4gcGFja2V0IHBhdHRlcm4gYXR0cmlidXRlCi0gKiBAX19OTDgwMjExX1dPV0xBTl9QS1RQQVRfSU5WQUxJRDogaW52YWxpZCBudW1iZXIgZm9yIG5lc3RlZCBhdHRyaWJ1dGUKLSAqIEBOTDgwMjExX1dPV0xBTl9QS1RQQVRfUEFUVEVSTjogdGhlIHBhdHRlcm4sIHZhbHVlcyB3aGVyZSB0aGUgbWFzayBoYXMKKyAqIGVudW0gbmw4MDIxMV9wYWNrZXRfcGF0dGVybl9hdHRyIC0gcGFja2V0IHBhdHRlcm4gYXR0cmlidXRlCisgKiBAX19OTDgwMjExX1BLVFBBVF9JTlZBTElEOiBpbnZhbGlkIG51bWJlciBmb3IgbmVzdGVkIGF0dHJpYnV0ZQorICogQE5MODAyMTFfUEtUUEFUX1BBVFRFUk46IHRoZSBwYXR0ZXJuLCB2YWx1ZXMgd2hlcmUgdGhlIG1hc2sgaGFzCiAgKglhIHplcm8gYml0IGFyZSBpZ25vcmVkCi0gKiBATkw4MDIxMV9XT1dMQU5fUEtUUEFUX01BU0s6IHBhdHRlcm4gbWFzaywgbXVzdCBiZSBsb25nIGVub3VnaCB0byBoYXZlCisgKiBATkw4MDIxMV9QS1RQQVRfTUFTSzogcGF0dGVybiBtYXNrLCBtdXN0IGJlIGxvbmcgZW5vdWdoIHRvIGhhdmUKICAqCWEgYml0IGZvciBlYWNoIGJ5dGUgaW4gdGhlIHBhdHRlcm4uIFRoZSBsb3dlc3Qtb3JkZXIgYml0IGNvcnJlc3BvbmRzCiAgKgl0byB0aGUgZmlyc3QgYnl0ZSBvZiB0aGUgcGF0dGVybiwgYnV0IHRoZSBieXRlcyBvZiB0aGUgcGF0dGVybiBhcmUKICAqCWluIGEgbGl0dGxlLWVuZGlhbi1saWtlIGZvcm1hdCwgaS5lLiB0aGUgOXRoIGJ5dGUgb2YgdGhlIHBhdHRlcm4KQEAgLTMwNjMsMzkgKzMzNTcsNTAgQEAKICAqCU5vdGUgdGhhdCB0aGUgcGF0dGVybiBtYXRjaGluZyBpcyBkb25lIGFzIHRob3VnaCBmcmFtZXMgd2VyZSBub3QKICAqCTgwMi4xMSBmcmFtZXMgYnV0IDgwMi4zIGZyYW1lcywgaS5lLiB0aGUgZnJhbWUgaXMgZnVsbHkgdW5wYWNrZWQKICAqCWZpcnN0IChpbmNsdWRpbmcgU05BUCBoZWFkZXIgdW5wYWNraW5nKSBhbmQgdGhlbiBtYXRjaGVkLgotICogQE5MODAyMTFfV09XTEFOX1BLVFBBVF9PRkZTRVQ6IHBhY2tldCBvZmZzZXQsIHBhdHRlcm4gaXMgbWF0Y2hlZCBhZnRlcgorICogQE5MODAyMTFfUEtUUEFUX09GRlNFVDogcGFja2V0IG9mZnNldCwgcGF0dGVybiBpcyBtYXRjaGVkIGFmdGVyCiAgKgl0aGVzZSBmaXhlZCBudW1iZXIgb2YgYnl0ZXMgb2YgcmVjZWl2ZWQgcGFja2V0Ci0gKiBATlVNX05MODAyMTFfV09XTEFOX1BLVFBBVDogbnVtYmVyIG9mIGF0dHJpYnV0ZXMKLSAqIEBNQVhfTkw4MDIxMV9XT1dMQU5fUEtUUEFUOiBtYXggYXR0cmlidXRlIG51bWJlcgorICogQE5VTV9OTDgwMjExX1BLVFBBVDogbnVtYmVyIG9mIGF0dHJpYnV0ZXMKKyAqIEBNQVhfTkw4MDIxMV9QS1RQQVQ6IG1heCBhdHRyaWJ1dGUgbnVtYmVyCiAgKi8KLWVudW0gbmw4MDIxMV93b3dsYW5fcGFja2V0X3BhdHRlcm5fYXR0ciB7Ci0JX19OTDgwMjExX1dPV0xBTl9QS1RQQVRfSU5WQUxJRCwKLQlOTDgwMjExX1dPV0xBTl9QS1RQQVRfTUFTSywKLQlOTDgwMjExX1dPV0xBTl9QS1RQQVRfUEFUVEVSTiwKLQlOTDgwMjExX1dPV0xBTl9QS1RQQVRfT0ZGU0VULAorZW51bSBubDgwMjExX3BhY2tldF9wYXR0ZXJuX2F0dHIgeworCV9fTkw4MDIxMV9QS1RQQVRfSU5WQUxJRCwKKwlOTDgwMjExX1BLVFBBVF9NQVNLLAorCU5MODAyMTFfUEtUUEFUX1BBVFRFUk4sCisJTkw4MDIxMV9QS1RQQVRfT0ZGU0VULAogCi0JTlVNX05MODAyMTFfV09XTEFOX1BLVFBBVCwKLQlNQVhfTkw4MDIxMV9XT1dMQU5fUEtUUEFUID0gTlVNX05MODAyMTFfV09XTEFOX1BLVFBBVCAtIDEsCisJTlVNX05MODAyMTFfUEtUUEFULAorCU1BWF9OTDgwMjExX1BLVFBBVCA9IE5VTV9OTDgwMjExX1BLVFBBVCAtIDEsCiB9OwogCiAvKioKLSAqIHN0cnVjdCBubDgwMjExX3dvd2xhbl9wYXR0ZXJuX3N1cHBvcnQgLSBwYXR0ZXJuIHN1cHBvcnQgaW5mb3JtYXRpb24KKyAqIHN0cnVjdCBubDgwMjExX3BhdHRlcm5fc3VwcG9ydCAtIHBhY2tldCBwYXR0ZXJuIHN1cHBvcnQgaW5mb3JtYXRpb24KICAqIEBtYXhfcGF0dGVybnM6IG1heGltdW0gbnVtYmVyIG9mIHBhdHRlcm5zIHN1cHBvcnRlZAogICogQG1pbl9wYXR0ZXJuX2xlbjogbWluaW11bSBsZW5ndGggb2YgZWFjaCBwYXR0ZXJuCiAgKiBAbWF4X3BhdHRlcm5fbGVuOiBtYXhpbXVtIGxlbmd0aCBvZiBlYWNoIHBhdHRlcm4KICAqIEBtYXhfcGt0X29mZnNldDogbWF4aW11bSBSeCBwYWNrZXQgb2Zmc2V0CiAgKgogICogVGhpcyBzdHJ1Y3QgaXMgY2FycmllZCBpbiAlTkw4MDIxMV9XT1dMQU5fVFJJR19QS1RfUEFUVEVSTiB3aGVuCi0gKiB0aGF0IGlzIHBhcnQgb2YgJU5MODAyMTFfQVRUUl9XT1dMQU5fVFJJR0dFUlNfU1VQUE9SVEVEIGluIHRoZQotICogY2FwYWJpbGl0eSBpbmZvcm1hdGlvbiBnaXZlbiBieSB0aGUga2VybmVsIHRvIHVzZXJzcGFjZS4KKyAqIHRoYXQgaXMgcGFydCBvZiAlTkw4MDIxMV9BVFRSX1dPV0xBTl9UUklHR0VSU19TVVBQT1JURUQgb3IgaW4KKyAqICVOTDgwMjExX0FUVFJfQ09BTEVTQ0VfUlVMRV9QS1RfUEFUVEVSTiB3aGVuIHRoYXQgaXMgcGFydCBvZgorICogJU5MODAyMTFfQVRUUl9DT0FMRVNDRV9SVUxFIGluIHRoZSBjYXBhYmlsaXR5IGluZm9ybWF0aW9uIGdpdmVuCisgKiBieSB0aGUga2VybmVsIHRvIHVzZXJzcGFjZS4KICAqLwotc3RydWN0IG5sODAyMTFfd293bGFuX3BhdHRlcm5fc3VwcG9ydCB7CitzdHJ1Y3Qgbmw4MDIxMV9wYXR0ZXJuX3N1cHBvcnQgewogCV9fdTMyIG1heF9wYXR0ZXJuczsKIAlfX3UzMiBtaW5fcGF0dGVybl9sZW47CiAJX191MzIgbWF4X3BhdHRlcm5fbGVuOwogCV9fdTMyIG1heF9wa3Rfb2Zmc2V0OwogfSBfX2F0dHJpYnV0ZV9fKChwYWNrZWQpKTsKIAorLyogb25seSBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSAqLworI2RlZmluZSBfX05MODAyMTFfV09XTEFOX1BLVFBBVF9JTlZBTElEIF9fTkw4MDIxMV9QS1RQQVRfSU5WQUxJRAorI2RlZmluZSBOTDgwMjExX1dPV0xBTl9QS1RQQVRfTUFTSyBOTDgwMjExX1BLVFBBVF9NQVNLCisjZGVmaW5lIE5MODAyMTFfV09XTEFOX1BLVFBBVF9QQVRURVJOIE5MODAyMTFfUEtUUEFUX1BBVFRFUk4KKyNkZWZpbmUgTkw4MDIxMV9XT1dMQU5fUEtUUEFUX09GRlNFVCBOTDgwMjExX1BLVFBBVF9PRkZTRVQKKyNkZWZpbmUgTlVNX05MODAyMTFfV09XTEFOX1BLVFBBVCBOVU1fTkw4MDIxMV9QS1RQQVQKKyNkZWZpbmUgTUFYX05MODAyMTFfV09XTEFOX1BLVFBBVCBNQVhfTkw4MDIxMV9QS1RQQVQKKyNkZWZpbmUgbmw4MDIxMV93b3dsYW5fcGF0dGVybl9zdXBwb3J0IG5sODAyMTFfcGF0dGVybl9zdXBwb3J0CisKIC8qKgogICogZW51bSBubDgwMjExX3dvd2xhbl90cmlnZ2VycyAtIFdvV0xBTiB0cmlnZ2VyIGRlZmluaXRpb25zCiAgKiBAX19OTDgwMjExX1dPV0xBTl9UUklHX0lOVkFMSUQ6IGludmFsaWQgbnVtYmVyIGZvciBuZXN0ZWQgYXR0cmlidXRlcwpAQCAtMzExNSw3ICszNDIwLDcgQEAKICAqCXBhdHRlcm4gbWF0Y2hpbmcgaXMgZG9uZSBhZnRlciB0aGUgcGFja2V0IGlzIGNvbnZlcnRlZCB0byB0aGUgTVNEVS4KICAqCiAgKglJbiAlTkw4MDIxMV9BVFRSX1dPV0xBTl9UUklHR0VSU19TVVBQT1JURUQsIGl0IGlzIGEgYmluYXJ5IGF0dHJpYnV0ZQotICoJY2FycnlpbmcgYSAmc3RydWN0IG5sODAyMTFfd293bGFuX3BhdHRlcm5fc3VwcG9ydC4KKyAqCWNhcnJ5aW5nIGEgJnN0cnVjdCBubDgwMjExX3BhdHRlcm5fc3VwcG9ydC4KICAqCiAgKglXaGVuIHJlcG9ydGluZyB3YWtldXAuIGl0IGlzIGEgdTMyIGF0dHJpYnV0ZSBjb250YWluaW5nIHRoZSAwLWJhc2VkCiAgKglpbmRleCBvZiB0aGUgcGF0dGVybiB0aGF0IGNhdXNlZCB0aGUgd2FrZXVwLCBpbiB0aGUgcGF0dGVybnMgcGFzc2VkCkBAIC0zMjcyLDcgKzM1NzcsNyBAQAogICogQE5MODAyMTFfV09XTEFOX1RDUF9XQUtFX1BBWUxPQUQ6IHdha2UgcGFja2V0IHBheWxvYWQsIGZvciBhZHZlcnRpc2luZyBhCiAgKgl1MzIgYXR0cmlidXRlIGhvbGRpbmcgdGhlIG1heGltdW0gbGVuZ3RoCiAgKiBATkw4MDIxMV9XT1dMQU5fVENQX1dBS0VfTUFTSzogV2FrZSBwYWNrZXQgcGF5bG9hZCBtYXNrLCBub3QgdXNlZCBmb3IKLSAqCWZlYXR1cmUgYWR2ZXJ0aXNpbmcuIFRoZSBtYXNrIHdvcmtzIGxpa2UgQE5MODAyMTFfV09XTEFOX1BLVFBBVF9NQVNLCisgKglmZWF0dXJlIGFkdmVydGlzaW5nLiBUaGUgbWFzayB3b3JrcyBsaWtlIEBOTDgwMjExX1BLVFBBVF9NQVNLCiAgKglidXQgb24gdGhlIFRDUCBwYXlsb2FkIG9ubHkuCiAgKiBATlVNX05MODAyMTFfV09XTEFOX1RDUDogbnVtYmVyIG9mIFRDUCBhdHRyaWJ1dGVzCiAgKiBATUFYX05MODAyMTFfV09XTEFOX1RDUDogaGlnaGVzdCBhdHRyaWJ1dGUgbnVtYmVyCkBAIC0zMjk3LDYgKzM2MDIsNTUgQEAKIH07CiAKIC8qKgorICogc3RydWN0IG5sODAyMTFfY29hbGVzY2VfcnVsZV9zdXBwb3J0IC0gY29hbGVzY2UgcnVsZSBzdXBwb3J0IGluZm9ybWF0aW9uCisgKiBAbWF4X3J1bGVzOiBtYXhpbXVtIG51bWJlciBvZiBydWxlcyBzdXBwb3J0ZWQKKyAqIEBwYXQ6IHBhY2tldCBwYXR0ZXJuIHN1cHBvcnQgaW5mb3JtYXRpb24KKyAqIEBtYXhfZGVsYXk6IG1heGltdW0gc3VwcG9ydGVkIGNvYWxlc2NpbmcgZGVsYXkgaW4gbXNlY3MKKyAqCisgKiBUaGlzIHN0cnVjdCBpcyBjYXJyaWVkIGluICVOTDgwMjExX0FUVFJfQ09BTEVTQ0VfUlVMRSBpbiB0aGUKKyAqIGNhcGFiaWxpdHkgaW5mb3JtYXRpb24gZ2l2ZW4gYnkgdGhlIGtlcm5lbCB0byB1c2Vyc3BhY2UuCisgKi8KK3N0cnVjdCBubDgwMjExX2NvYWxlc2NlX3J1bGVfc3VwcG9ydCB7CisJX191MzIgbWF4X3J1bGVzOworCXN0cnVjdCBubDgwMjExX3BhdHRlcm5fc3VwcG9ydCBwYXQ7CisJX191MzIgbWF4X2RlbGF5OworfSBfX2F0dHJpYnV0ZV9fKChwYWNrZWQpKTsKKworLyoqCisgKiBlbnVtIG5sODAyMTFfYXR0cl9jb2FsZXNjZV9ydWxlIC0gY29hbGVzY2UgcnVsZSBhdHRyaWJ1dGUKKyAqIEBfX05MODAyMTFfQ09BTEVTQ0VfUlVMRV9JTlZBTElEOiBpbnZhbGlkIG51bWJlciBmb3IgbmVzdGVkIGF0dHJpYnV0ZQorICogQE5MODAyMTFfQVRUUl9DT0FMRVNDRV9SVUxFX0RFTEFZOiBkZWxheSBpbiBtc2VjcyB1c2VkIGZvciBwYWNrZXQgY29hbGVzY2luZworICogQE5MODAyMTFfQVRUUl9DT0FMRVNDRV9SVUxFX0NPTkRJVElPTjogY29uZGl0aW9uIGZvciBwYWNrZXQgY29hbGVzY2VuY2UsCisgKglzZWUgJmVudW0gbmw4MDIxMV9jb2FsZXNjZV9jb25kaXRpb24uCisgKiBATkw4MDIxMV9BVFRSX0NPQUxFU0NFX1JVTEVfUEtUX1BBVFRFUk46IHBhY2tldCBvZmZzZXQsIHBhdHRlcm4gaXMgbWF0Y2hlZAorICoJYWZ0ZXIgdGhlc2UgZml4ZWQgbnVtYmVyIG9mIGJ5dGVzIG9mIHJlY2VpdmVkIHBhY2tldAorICogQE5VTV9OTDgwMjExX0FUVFJfQ09BTEVTQ0VfUlVMRTogbnVtYmVyIG9mIGF0dHJpYnV0ZXMKKyAqIEBOTDgwMjExX0FUVFJfQ09BTEVTQ0VfUlVMRV9NQVg6IG1heCBhdHRyaWJ1dGUgbnVtYmVyCisgKi8KK2VudW0gbmw4MDIxMV9hdHRyX2NvYWxlc2NlX3J1bGUgeworCV9fTkw4MDIxMV9DT0FMRVNDRV9SVUxFX0lOVkFMSUQsCisJTkw4MDIxMV9BVFRSX0NPQUxFU0NFX1JVTEVfREVMQVksCisJTkw4MDIxMV9BVFRSX0NPQUxFU0NFX1JVTEVfQ09ORElUSU9OLAorCU5MODAyMTFfQVRUUl9DT0FMRVNDRV9SVUxFX1BLVF9QQVRURVJOLAorCisJLyoga2VlcCBsYXN0ICovCisJTlVNX05MODAyMTFfQVRUUl9DT0FMRVNDRV9SVUxFLAorCU5MODAyMTFfQVRUUl9DT0FMRVNDRV9SVUxFX01BWCA9IE5VTV9OTDgwMjExX0FUVFJfQ09BTEVTQ0VfUlVMRSAtIDEKK307CisKKy8qKgorICogZW51bSBubDgwMjExX2NvYWxlc2NlX2NvbmRpdGlvbiAtIGNvYWxlc2NlIHJ1bGUgY29uZGl0aW9ucworICogQE5MODAyMTFfQ09BTEVTQ0VfQ09ORElUSU9OX01BVENIOiBjb2FsYWVzY2UgUnggcGFja2V0cyB3aGVuIHBhdHRlcm5zCisgKglpbiBhIHJ1bGUgYXJlIG1hdGNoZWQuCisgKiBATkw4MDIxMV9DT0FMRVNDRV9DT05ESVRJT05fTk9fTUFUQ0g6IGNvYWxlc2NlIFJ4IHBhY2tldHMgd2hlbiBwYXR0ZXJucworICoJaW4gYSBydWxlIGFyZSBub3QgbWF0Y2hlZC4KKyAqLworZW51bSBubDgwMjExX2NvYWxlc2NlX2NvbmRpdGlvbiB7CisJTkw4MDIxMV9DT0FMRVNDRV9DT05ESVRJT05fTUFUQ0gsCisJTkw4MDIxMV9DT0FMRVNDRV9DT05ESVRJT05fTk9fTUFUQ0gKK307CisKKy8qKgogICogZW51bSBubDgwMjExX2lmYWNlX2xpbWl0X2F0dHJzIC0gbGltaXQgYXR0cmlidXRlcwogICogQE5MODAyMTFfSUZBQ0VfTElNSVRfVU5TUEVDOiAocmVzZXJ2ZWQpCiAgKiBATkw4MDIxMV9JRkFDRV9MSU1JVF9NQVg6IG1heGltdW0gbnVtYmVyIG9mIGludGVyZmFjZXMgdGhhdApAQCAtMzU0MCwxMSArMzg5NCw2IEBACiAgKiBATkw4MDIxMV9GRUFUVVJFX0NFTExfQkFTRV9SRUdfSElOVFM6IFRoaXMgZHJpdmVyIGhhcyBiZWVuIHRlc3RlZAogICoJdG8gd29yayBwcm9wZXJseSB0byBzdXBwcG9ydCByZWNlaXZpbmcgcmVndWxhdG9yeSBoaW50cyBmcm9tCiAgKgljZWxsdWxhciBiYXNlIHN0YXRpb25zLgotICogQE5MODAyMTFfRkVBVFVSRV9QMlBfREVWSUNFX05FRURTX0NIQU5ORUw6IElmIHRoaXMgaXMgc2V0LCBhbiBhY3RpdmUKLSAqCVAyUCBEZXZpY2UgKCVOTDgwMjExX0lGVFlQRV9QMlBfREVWSUNFKSByZXF1aXJlcyBpdHMgb3duIGNoYW5uZWwKLSAqCWluIHRoZSBpbnRlcmZhY2UgY29tYmluYXRpb25zLCBldmVuIHdoZW4gaXQncyBvbmx5IHVzZWQgZm9yIHNjYW4KLSAqCWFuZCByZW1haW4tb24tY2hhbm5lbC4gVGhpcyBjb3VsZCBiZSBkdWUgdG8sIGZvciBleGFtcGxlLCB0aGUKLSAqCXJlbWFpbi1vbi1jaGFubmVsIGltcGxlbWVudGF0aW9uIHJlcXVpcmluZyBhIGNoYW5uZWwgY29udGV4dC4KICAqIEBOTDgwMjExX0ZFQVRVUkVfU0FFOiBUaGlzIGRyaXZlciBzdXBwb3J0cyBzaW11bHRhbmVvdXMgYXV0aGVudGljYXRpb24gb2YKICAqCWVxdWFscyAoU0FFKSB3aXRoIHVzZXIgc3BhY2UgU01FIChOTDgwMjExX0NNRF9BVVRIRU5USUNBVEUpIGluIHN0YXRpb24KICAqCW1vZGUKQEAgLTM1NzYsMTMgKzM5MjUsMjAgQEAKICAqCVBlZXJpbmcgTWFuYWdlbWVudCBlbnRpdHkgd2hpY2ggbWF5IGJlIGltcGxlbWVudGVkIGJ5IHJlZ2lzdGVyaW5nIGZvcgogICoJYmVhY29ucyBvciBOTDgwMjExX0NNRF9ORVdfUEVFUl9DQU5ESURBVEUgZXZlbnRzLiBUaGUgbWVzaCBiZWFjb24gaXMKICAqCXN0aWxsIGdlbmVyYXRlZCBieSB0aGUgZHJpdmVyLgorICogQE5MODAyMTFfRkVBVFVSRV9BQ1RJVkVfTU9OSVRPUjogVGhpcyBkcml2ZXIgc3VwcG9ydHMgYW4gYWN0aXZlIG1vbml0b3IKKyAqCWludGVyZmFjZS4gQW4gYWN0aXZlIG1vbml0b3IgaW50ZXJmYWNlIGJlaGF2ZXMgbGlrZSBhIG5vcm1hbCBtb25pdG9yCisgKglpbnRlcmZhY2UsIGJ1dCBnZXRzIGFkZGVkIHRvIHRoZSBkcml2ZXIuIEl0IGVuc3VyZXMgdGhhdCBpbmNvbWluZworICoJdW5pY2FzdCBwYWNrZXRzIGRpcmVjdGVkIGF0IHRoZSBjb25maWd1cmVkIGludGVyZmFjZSBhZGRyZXNzIGdldCBBQ0tlZC4KKyAqIEBOTDgwMjExX0ZFQVRVUkVfQVBfTU9ERV9DSEFOX1dJRFRIX0NIQU5HRTogVGhpcyBkcml2ZXIgc3VwcG9ydHMgZHluYW1pYworICoJY2hhbm5lbCBiYW5kd2lkdGggY2hhbmdlIChlLmcuLCBIVCAyMCA8LT4gNDAgTUh6IGNoYW5uZWwpIGR1cmluZyB0aGUKKyAqCWxpZmV0aW1lIG9mIGEgQlNTLgogICovCiBlbnVtIG5sODAyMTFfZmVhdHVyZV9mbGFncyB7CiAJTkw4MDIxMV9GRUFUVVJFX1NLX1RYX1NUQVRVUwkJCT0gMSA8PCAwLAogCU5MODAyMTFfRkVBVFVSRV9IVF9JQlNTCQkJCT0gMSA8PCAxLAogCU5MODAyMTFfRkVBVFVSRV9JTkFDVElWSVRZX1RJTUVSCQk9IDEgPDwgMiwKIAlOTDgwMjExX0ZFQVRVUkVfQ0VMTF9CQVNFX1JFR19ISU5UUwkJPSAxIDw8IDMsCi0JTkw4MDIxMV9GRUFUVVJFX1AyUF9ERVZJQ0VfTkVFRFNfQ0hBTk5FTAk9IDEgPDwgNCwKKwkvKiBiaXQgNCBpcyByZXNlcnZlZCAtIGRvbid0IHVzZSAqLwogCU5MODAyMTFfRkVBVFVSRV9TQUUJCQkJPSAxIDw8IDUsCiAJTkw4MDIxMV9GRUFUVVJFX0xPV19QUklPUklUWV9TQ0FOCQk9IDEgPDwgNiwKIAlOTDgwMjExX0ZFQVRVUkVfU0NBTl9GTFVTSAkJCT0gMSA8PCA3LApAQCAtMzU5NSw2ICszOTUxLDggQEAKIAlOTDgwMjExX0ZFQVRVUkVfQURWRVJUSVNFX0NIQU5fTElNSVRTCQk9IDEgPDwgMTQsCiAJTkw4MDIxMV9GRUFUVVJFX0ZVTExfQVBfQ0xJRU5UX1NUQVRFCQk9IDEgPDwgMTUsCiAJTkw4MDIxMV9GRUFUVVJFX1VTRVJTUEFDRV9NUE0JCQk9IDEgPDwgMTYsCisJTkw4MDIxMV9GRUFUVVJFX0FDVElWRV9NT05JVE9SCQkJPSAxIDw8IDE3LAorCU5MODAyMTFfRkVBVFVSRV9BUF9NT0RFX0NIQU5fV0lEVEhfQ0hBTkdFCT0gMSA8PCAxOCwKIH07CiAKIC8qKgpAQCAtMzY5NSwxMyArNDA1MywxMiBAQAogICoKICAqIENoYW5uZWwgc3RhdGVzIHVzZWQgYnkgdGhlIERGUyBjb2RlLgogICoKLSAqIEBJRUVFODAyMTFfREZTX1VTQUJMRTogVGhlIGNoYW5uZWwgY2FuIGJlIHVzZWQsIGJ1dCBjaGFubmVsIGF2YWlsYWJpbGl0eQorICogQE5MODAyMTFfREZTX1VTQUJMRTogVGhlIGNoYW5uZWwgY2FuIGJlIHVzZWQsIGJ1dCBjaGFubmVsIGF2YWlsYWJpbGl0eQogICoJY2hlY2sgKENBQykgbXVzdCBiZSBwZXJmb3JtZWQgYmVmb3JlIHVzaW5nIGl0IGZvciBBUCBvciBJQlNTLgotICogQElFRUU4MDIxMV9ERlNfVU5BVkFJTEFCTEU6IEEgcmFkYXIgaGFzIGJlZW4gZGV0ZWN0ZWQgb24gdGhpcyBjaGFubmVsLCBpdAorICogQE5MODAyMTFfREZTX1VOQVZBSUxBQkxFOiBBIHJhZGFyIGhhcyBiZWVuIGRldGVjdGVkIG9uIHRoaXMgY2hhbm5lbCwgaXQKICAqCWlzIHRoZXJlZm9yZSBtYXJrZWQgYXMgbm90IGF2YWlsYWJsZS4KLSAqIEBJRUVFODAyMTFfREZTX0FWQUlMQUJMRTogVGhlIGNoYW5uZWwgaGFzIGJlZW4gQ0FDIGNoZWNrZWQgYW5kIGlzIGF2YWlsYWJsZS4KKyAqIEBOTDgwMjExX0RGU19BVkFJTEFCTEU6IFRoZSBjaGFubmVsIGhhcyBiZWVuIENBQyBjaGVja2VkIGFuZCBpcyBhdmFpbGFibGUuCiAgKi8KLQogZW51bSBubDgwMjExX2Rmc19zdGF0ZSB7CiAJTkw4MDIxMV9ERlNfVVNBQkxFLAogCU5MODAyMTFfREZTX1VOQVZBSUxBQkxFLApAQCAtMzc0MSw0ICs0MDk4LDUxIEBACiAvKiBtYXhpbXVtIGR1cmF0aW9uIGZvciBjcml0aWNhbCBwcm90b2NvbCBtZWFzdXJlcyAqLwogI2RlZmluZSBOTDgwMjExX0NSSVRfUFJPVE9fTUFYX0RVUkFUSU9OCQk1MDAwIC8qIG1zZWMgKi8KIAorLyoqCisgKiBlbnVtIG5sODAyMTFfcnhtZ210X2ZsYWdzIC0gZmxhZ3MgZm9yIHJlY2VpdmVkIG1hbmFnZW1lbnQgZnJhbWUuCisgKgorICogVXNlZCBieSBjZmc4MDIxMV9yeF9tZ210KCkKKyAqCisgKiBATkw4MDIxMV9SWE1HTVRfRkxBR19BTlNXRVJFRDogZnJhbWUgd2FzIGFuc3dlcmVkIGJ5IGRldmljZS9kcml2ZXIuCisgKi8KK2VudW0gbmw4MDIxMV9yeG1nbXRfZmxhZ3MgeworCU5MODAyMTFfUlhNR01UX0ZMQUdfQU5TV0VSRUQgPSAxIDw8IDAsCit9OworCisvKgorICogSWYgdGhpcyBmbGFnIGlzIHVuc2V0LCB0aGUgbG93ZXIgMjQgYml0cyBhcmUgYW4gT1VJLCBpZiBzZXQKKyAqIGEgTGludXggbmw4MDIxMSB2ZW5kb3IgSUQgaXMgdXNlZCAobm8gc3VjaCBJRHMgYXJlIGFsbG9jYXRlZAorICogeWV0LCBzbyB0aGF0J3Mgbm90IHZhbGlkIHNvIGZhcikKKyAqLworI2RlZmluZSBOTDgwMjExX1ZFTkRPUl9JRF9JU19MSU5VWAkweDgwMDAwMDAwCisKKy8qKgorICogc3RydWN0IG5sODAyMTFfdmVuZG9yX2NtZF9pbmZvIC0gdmVuZG9yIGNvbW1hbmQgZGF0YQorICogQHZlbmRvcl9pZDogSWYgdGhlICVOTDgwMjExX1ZFTkRPUl9JRF9JU19MSU5VWCBmbGFnIGlzIGNsZWFyLCB0aGVuIHRoZQorICoJdmFsdWUgaXMgYSAyNC1iaXQgT1VJOyBpZiBpdCBpcyBzZXQgdGhlbiBhIHNlcGFyYXRlbHkgYWxsb2NhdGVkIElECisgKgltYXkgYmUgdXNlZCwgYnV0IG5vIHN1Y2ggSURzIGFyZSBhbGxvY2F0ZWQgeWV0LiBOZXcgSURzIHNob3VsZCBiZQorICoJYWRkZWQgdG8gdGhpcyBmaWxlIHdoZW4gbmVlZGVkLgorICogQHN1YmNtZDogc3ViLWNvbW1hbmQgSUQgZm9yIHRoZSBjb21tYW5kCisgKi8KK3N0cnVjdCBubDgwMjExX3ZlbmRvcl9jbWRfaW5mbyB7CisJX191MzIgdmVuZG9yX2lkOworCV9fdTMyIHN1YmNtZDsKK307CisKKy8qKgorICogZW51bSBubDgwMjExX3RkbHNfcGVlcl9jYXBhYmlsaXR5IC0gVERMUyBwZWVyIGZsYWdzLgorICoKKyAqIFVzZWQgYnkgdGRsc19tZ210KCkgdG8gZGV0ZXJtaW5lIHdoaWNoIGNvbmRpdGlvbmFsIGVsZW1lbnRzIG5lZWQKKyAqIHRvIGJlIGFkZGVkIHRvIFRETFMgU2V0dXAgZnJhbWVzLgorICoKKyAqIEBOTDgwMjExX1RETFNfUEVFUl9IVDogVERMUyBwZWVyIGlzIEhUIGNhcGFibGUuCisgKiBATkw4MDIxMV9URExTX1BFRVJfVkhUOiBURExTIHBlZXIgaXMgVkhUIGNhcGFibGUuCisgKiBATkw4MDIxMV9URExTX1BFRVJfV01NOiBURExTIHBlZXIgaXMgV01NIGNhcGFibGUuCisgKi8KK2VudW0gbmw4MDIxMV90ZGxzX3BlZXJfY2FwYWJpbGl0eSB7CisJTkw4MDIxMV9URExTX1BFRVJfSFQgPSAxPDwwLAorCU5MODAyMTFfVERMU19QRUVSX1ZIVCA9IDE8PDEsCisJTkw4MDIxMV9URExTX1BFRVJfV01NID0gMTw8MiwKK307CisKICNlbmRpZiAvKiBfX0xJTlVYX05MODAyMTFfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvcHJpdl9uZXRsaW5rLmggYi9zcmMvZHJpdmVycy9wcml2X25ldGxpbmsuaAppbmRleCA3NGQ2Y2U1Li42MjMyMDg4IDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9wcml2X25ldGxpbmsuaAorKysgYi9zcmMvZHJpdmVycy9wcml2X25ldGxpbmsuaApAQCAtNjksNiArNjksNyBAQAogKHN0cnVjdCBydGF0dHIgKikgKCgoY2hhciAqKShydGEpKSArIFJUQV9BTElHTigocnRhKS0+cnRhX2xlbikpKQogI2RlZmluZSBSVEFfTEVOR1RIKGxlbikgKFJUQV9BTElHTihzaXplb2Yoc3RydWN0IHJ0YXR0cikpICsgKGxlbikpCiAjZGVmaW5lIFJUQV9EQVRBKHJ0YSkgKCh2b2lkICopICgoKGNoYXIgKikgKHJ0YSkpICsgUlRBX0xFTkdUSCgwKSkpCisjZGVmaW5lIFJUQV9QQVlMT0FEKHJ0YSkgKChpbnQpICgocnRhKS0+cnRhX2xlbikgLSBSVEFfTEVOR1RIKDApKQogCiAKIHN0cnVjdCBzb2NrYWRkcl9ubApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vTWFrZWZpbGUgYi9zcmMvZWFwX2NvbW1vbi9NYWtlZmlsZQppbmRleCA5YzQxOTYyLi5hZGZkM2RmIDEwMDY0NAotLS0gYS9zcmMvZWFwX2NvbW1vbi9NYWtlZmlsZQorKysgYi9zcmMvZWFwX2NvbW1vbi9NYWtlZmlsZQpAQCAtMiw3ICsyLDcgQEAKIAlAZWNobyBOb3RoaW5nIHRvIGJlIG1hZGUuCiAKIGNsZWFuOgotCXJtIC1mICp+ICoubyAqLmQKKwlybSAtZiAqfiAqLm8gKi5kICouZ2NubyAqLmdjZGEgKi5nY292CiAKIGluc3RhbGw6CiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX2RlZnMuaCBiL3NyYy9lYXBfY29tbW9uL2VhcF9kZWZzLmgKaW5kZXggZjU4OTBiZS4uNGYxNGEwMSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX2RlZnMuaAorKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfZGVmcy5oCkBAIC03MiwxMyArNzIsMTYgQEAKIGVudW0gewogCUVBUF9WRU5ET1JfSUVURiA9IDAsCiAJRUFQX1ZFTkRPUl9NSUNST1NPRlQgPSAweDAwMDEzNyAvKiBNaWNyb3NvZnQgKi8sCi0JRUFQX1ZFTkRPUl9XRkEgPSAweDAwMzcyQSAvKiBXaS1GaSBBbGxpYW5jZSAqLywKLQlFQVBfVkVORE9SX0hPU1RBUCA9IDM5MDY4IC8qIGhvc3RhcGQvd3BhX3N1cHBsaWNhbnQgcHJvamVjdCAqLworCUVBUF9WRU5ET1JfV0ZBID0gMHgwMDM3MkEgLyogV2ktRmkgQWxsaWFuY2UgKG1vdmVkIHRvIFdCQSkgKi8sCisJRUFQX1ZFTkRPUl9IT1NUQVAgPSAzOTA2OCAvKiBob3N0YXBkL3dwYV9zdXBwbGljYW50IHByb2plY3QgKi8sCisJRUFQX1ZFTkRPUl9XRkFfTkVXID0gNDA4MDggLyogV2ktRmkgQWxsaWFuY2UgKi8KIH07CiAKICNkZWZpbmUgRUFQX1ZFTkRPUl9VTkFVVEhfVExTIEVBUF9WRU5ET1JfSE9TVEFQCiAjZGVmaW5lIEVBUF9WRU5ET1JfVFlQRV9VTkFVVEhfVExTIDEKIAorI2RlZmluZSBFQVBfVkVORE9SX1dGQV9VTkFVVEhfVExTIDEzCisKICNkZWZpbmUgRUFQX01TS19MRU4gNjQKICNkZWZpbmUgRUFQX0VNU0tfTEVOIDY0CiAKZGlmZiAtLWdpdCBhL3NyYy9lYXBfY29tbW9uL2VhcF9la2VfY29tbW9uLmMgYi9zcmMvZWFwX2NvbW1vbi9lYXBfZWtlX2NvbW1vbi5jCmluZGV4IGE2MmFjOGUuLjRkZmRiM2YgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfY29tbW9uL2VhcF9la2VfY29tbW9uLmMKKysrIGIvc3JjL2VhcF9jb21tb24vZWFwX2VrZV9jb21tb24uYwpAQCAtNjkyLDcgKzY5Miw3IEBACiAJaWYgKGVhcF9la2VfbWFjKHNlc3MtPm1hYywgc2Vzcy0+a2ksIHByb3QgKyBibG9ja19zaXplLAogCQkJcHJvdF9sZW4gLSBibG9ja19zaXplIC0gaWN2X2xlbiwgaWN2KSA8IDApCiAJCXJldHVybiAtMTsKLQlpZiAob3NfbWVtY21wKGljdiwgcHJvdCArIHByb3RfbGVuIC0gaWN2X2xlbiwgaWN2X2xlbikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QoaWN2LCBwcm90ICsgcHJvdF9sZW4gLSBpY3ZfbGVuLCBpY3ZfbGVuKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtRUtFOiBJQ1YgbWlzbWF0Y2ggaW4gUHJvdCgpIGRhdGEiKTsKIAkJcmV0dXJuIC0xOwogCX0KZGlmZiAtLWdpdCBhL3NyYy9lYXBfY29tbW9uL2VhcF9mYXN0X2NvbW1vbi5jIGIvc3JjL2VhcF9jb21tb24vZWFwX2Zhc3RfY29tbW9uLmMKaW5kZXggMDRiOTg3ZC4uZmNlYjFiMCAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX2Zhc3RfY29tbW9uLmMKKysrIGIvc3JjL2VhcF9jb21tb24vZWFwX2Zhc3RfY29tbW9uLmMKQEAgLTE3NCw3ICsxNzQsNyBAQAogCiAKIGludCBlYXBfZmFzdF9wYXJzZV90bHYoc3RydWN0IGVhcF9mYXN0X3Rsdl9wYXJzZSAqdGx2LAotCQkgICAgICAgaW50IHRsdl90eXBlLCB1OCAqcG9zLCBpbnQgbGVuKQorCQkgICAgICAgaW50IHRsdl90eXBlLCB1OCAqcG9zLCBzaXplX3QgbGVuKQogewogCXN3aXRjaCAodGx2X3R5cGUpIHsKIAljYXNlIEVBUF9UTFZfRUFQX1BBWUxPQURfVExWOgpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX2Zhc3RfY29tbW9uLmggYi9zcmMvZWFwX2NvbW1vbi9lYXBfZmFzdF9jb21tb24uaAppbmRleCA4OTU1NjE3Li5kNTlhODQ1IDEwMDY0NAotLS0gYS9zcmMvZWFwX2NvbW1vbi9lYXBfZmFzdF9jb21tb24uaAorKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfZmFzdF9jb21tb24uaApAQCAtMTAyLDYgKzEwMiw2IEBACiB2b2lkIGVhcF9mYXN0X2Rlcml2ZV9lYXBfbXNrKGNvbnN0IHU4ICpzaW1jaywgdTggKm1zayk7CiB2b2lkIGVhcF9mYXN0X2Rlcml2ZV9lYXBfZW1zayhjb25zdCB1OCAqc2ltY2ssIHU4ICplbXNrKTsKIGludCBlYXBfZmFzdF9wYXJzZV90bHYoc3RydWN0IGVhcF9mYXN0X3Rsdl9wYXJzZSAqdGx2LAotCQkgICAgICAgaW50IHRsdl90eXBlLCB1OCAqcG9zLCBpbnQgbGVuKTsKKwkJICAgICAgIGludCB0bHZfdHlwZSwgdTggKnBvcywgc2l6ZV90IGxlbik7CiAKICNlbmRpZiAvKiBFQVBfRkFTVF9IICovCmRpZmYgLS1naXQgYS9zcmMvZWFwX2NvbW1vbi9lYXBfZ3Bza19jb21tb24uYyBiL3NyYy9lYXBfY29tbW9uL2VhcF9ncHNrX2NvbW1vbi5jCmluZGV4IDdhMzMyMTUuLjhjN2FlMjcgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfY29tbW9uL2VhcF9ncHNrX2NvbW1vbi5jCisrKyBiL3NyYy9lYXBfY29tbW9uL2VhcF9ncHNrX2NvbW1vbi5jCkBAIC0yODQsNyArMjg0LDYgQEAKIAkJCSB1OCAqcGssIHNpemVfdCAqcGtfbGVuKQogewogCXU4ICpzZWVkLCAqcG9zOwotCXNpemVfdCBzZWVkX2xlbjsKIAlpbnQgcmV0OwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtR1BTSzogRGVyaXZpbmcga2V5cyAoJWQ6JWQpIiwKQEAgLTI5Niw4ICsyOTUsNyBAQAogCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJFQVAtR1BTSzogUFNLIiwgcHNrLCBwc2tfbGVuKTsKIAogCS8qIFNlZWQgPSBSQU5EX1BlZXIgfHwgSURfUGVlciB8fCBSQU5EX1NlcnZlciB8fCBJRF9TZXJ2ZXIgKi8KLQlzZWVkX2xlbiA9IDIgKiBFQVBfR1BTS19SQU5EX0xFTiArIGlkX3NlcnZlcl9sZW4gKyBpZF9wZWVyX2xlbjsKLQlzZWVkID0gb3NfbWFsbG9jKHNlZWRfbGVuKTsKKwlzZWVkID0gb3NfbWFsbG9jKDIgKiBFQVBfR1BTS19SQU5EX0xFTiArIGlkX3NlcnZlcl9sZW4gKyBpZF9wZWVyX2xlbik7CiAJaWYgKHNlZWQgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1HUFNLOiBGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5ICIKIAkJCSAgICJmb3Iga2V5IGRlcml2YXRpb24iKTsKQEAgLTMxMywxNyArMzExLDE4IEBACiAJcG9zICs9IEVBUF9HUFNLX1JBTkRfTEVOOwogCW9zX21lbWNweShwb3MsIGlkX3NlcnZlciwgaWRfc2VydmVyX2xlbik7CiAJcG9zICs9IGlkX3NlcnZlcl9sZW47Ci0Jd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IFNlZWQiLCBzZWVkLCBzZWVkX2xlbik7CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IFNlZWQiLCBzZWVkLCBwb3MgLSBzZWVkKTsKIAogCXN3aXRjaCAoc3BlY2lmaWVyKSB7CiAJY2FzZSBFQVBfR1BTS19DSVBIRVJfQUVTOgotCQlyZXQgPSBlYXBfZ3Bza19kZXJpdmVfa2V5c19hZXMocHNrLCBwc2tfbGVuLCBzZWVkLCBzZWVkX2xlbiwKKwkJcmV0ID0gZWFwX2dwc2tfZGVyaXZlX2tleXNfYWVzKHBzaywgcHNrX2xlbiwgc2VlZCwgcG9zIC0gc2VlZCwKIAkJCQkJICAgICAgIG1zaywgZW1zaywgc2ssIHNrX2xlbiwKIAkJCQkJICAgICAgIHBrLCBwa19sZW4pOwogCQlicmVhazsKICNpZmRlZiBFQVBfR1BTS19TSEEyNTYKIAljYXNlIEVBUF9HUFNLX0NJUEhFUl9TSEEyNTY6Ci0JCXJldCA9IGVhcF9ncHNrX2Rlcml2ZV9rZXlzX3NoYTI1Nihwc2ssIHBza19sZW4sIHNlZWQsIHNlZWRfbGVuLAorCQlyZXQgPSBlYXBfZ3Bza19kZXJpdmVfa2V5c19zaGEyNTYocHNrLCBwc2tfbGVuLCBzZWVkLAorCQkJCQkJICBwb3MgLSBzZWVkLAogCQkJCQkJICBtc2ssIGVtc2ssIHNrLCBza19sZW4pOwogCQlicmVhazsKICNlbmRpZiAvKiBFQVBfR1BTS19TSEEyNTYgKi8KQEAgLTQyMyw3ICs0MjIsNiBAQAogewogCXU4ICpzZWVkLCAqcG9zOwogCXU4IGtkZl9vdXRbMTZdOwotCXNpemVfdCBzZWVkX2xlbjsKIAlpbnQgcmV0OwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtR1BTSzogRGVyaXZpbmcgU2Vzc2lvbiBJRCglZDolZCkiLApAQCAtNDQxLDggKzQzOSw3IEBACiAJICogTWV0aG9kLUlEID0gR0tERi0xNiAoemVybywgIk1ldGhvZCBJRCIgfHwgRUFQX01ldGhvZF9UeXBlIHx8CiAJICogICAgICAgICAgICAgICAgICAgICAgQ1N1aXRlX1NlbCB8fCBpbnB1dFN0cmluZykKIAkgKi8KLQlzZWVkX2xlbiA9IDIgKiBFQVBfR1BTS19SQU5EX0xFTiArIGlkX3NlcnZlcl9sZW4gKyBpZF9wZWVyX2xlbjsKLQlzZWVkID0gb3NfbWFsbG9jKHNlZWRfbGVuKTsKKwlzZWVkID0gb3NfbWFsbG9jKDIgKiBFQVBfR1BTS19SQU5EX0xFTiArIGlkX3NlcnZlcl9sZW4gKyBpZF9wZWVyX2xlbik7CiAJaWYgKHNlZWQgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1HUFNLOiBGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5ICIKIAkJCSAgICJmb3IgU2Vzc2lvbi1JZCBkZXJpdmF0aW9uIik7CkBAIC00NTgsMTEgKzQ1NSwxMSBAQAogCXBvcyArPSBFQVBfR1BTS19SQU5EX0xFTjsKIAlvc19tZW1jcHkocG9zLCBpZF9zZXJ2ZXIsIGlkX3NlcnZlcl9sZW4pOwogCXBvcyArPSBpZF9zZXJ2ZXJfbGVuOwotCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkVBUC1HUFNLOiBTZWVkIiwgc2VlZCwgc2VlZF9sZW4pOworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkVBUC1HUFNLOiBTZWVkIiwgc2VlZCwgcG9zIC0gc2VlZCk7CiAKIAlyZXQgPSBlYXBfZ3Bza19kZXJpdmVfbWlkX2hlbHBlcihzcGVjaWZpZXIsCiAJCQkJCSBrZGZfb3V0LCBzaXplb2Yoa2RmX291dCksCi0JCQkJCSBwc2ssIHNlZWQsIHNlZWRfbGVuLAorCQkJCQkgcHNrLCBzZWVkLCBwb3MgLSBzZWVkLAogCQkJCQkgbWV0aG9kX3R5cGUpOwogCiAJc2lkWzBdID0gbWV0aG9kX3R5cGU7CmRpZmYgLS1naXQgYS9zcmMvZWFwX2NvbW1vbi9lYXBfaWtldjJfY29tbW9uLmMgYi9zcmMvZWFwX2NvbW1vbi9lYXBfaWtldjJfY29tbW9uLmMKaW5kZXggNjA5NWZkOC4uNTg1Yzc5YyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX2lrZXYyX2NvbW1vbi5jCisrKyBiL3NyYy9lYXBfY29tbW9uL2VhcF9pa2V2Ml9jb21tb24uYwpAQCAtNTIsMjIgKzUyLDEyIEBACiB7CiAJc3RydWN0IHdwYWJ1ZiAqbXNnOwogCi0jaWZkZWYgQ0NOU19QTAotCW1zZyA9IGVhcF9tc2dfYWxsb2MoRUFQX1ZFTkRPUl9JRVRGLCBFQVBfVFlQRV9JS0VWMiwgMSwgY29kZSwgaWQpOwotCWlmIChtc2cgPT0gTlVMTCkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkVBUC1JS0VWMjogRmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSAiCi0JCQkgICAiZm9yIGZyYWdtZW50IGFjayIpOwotCQlyZXR1cm4gTlVMTDsKLQl9Ci0Jd3BhYnVmX3B1dF91OChtc2csIDApOyAvKiBGbGFncyAqLwotI2Vsc2UgLyogQ0NOU19QTCAqLwogCW1zZyA9IGVhcF9tc2dfYWxsb2MoRUFQX1ZFTkRPUl9JRVRGLCBFQVBfVFlQRV9JS0VWMiwgMCwgY29kZSwgaWQpOwogCWlmIChtc2cgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkVBUC1JS0VWMjogRmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSAiCiAJCQkgICAiZm9yIGZyYWdtZW50IGFjayIpOwogCQlyZXR1cm4gTlVMTDsKIAl9Ci0jZW5kaWYgLyogQ0NOU19QTCAqLwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtSUtFVjI6IFNlbmQgZnJhZ21lbnQgYWNrIik7CiAKQEAgLTExMCw3ICsxMDAsNyBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKG9zX21lbWNtcChpY3YsIGVuZCAtIGljdl9sZW4sIGljdl9sZW4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KGljdiwgZW5kIC0gaWN2X2xlbiwgaWN2X2xlbikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLUlLRVYyOiBJbnZhbGlkIElDViIpOwogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAtSUtFVjI6IENhbGN1bGF0ZWQgSUNWIiwKIAkJCSAgICBpY3YsIGljdl9sZW4pOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX2lrZXYyX2NvbW1vbi5oIGIvc3JjL2VhcF9jb21tb24vZWFwX2lrZXYyX2NvbW1vbi5oCmluZGV4IDMyOWNjYzQuLmU3NTAyZDcgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfY29tbW9uL2VhcF9pa2V2Ml9jb21tb24uaAorKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfaWtldjJfY29tbW9uLmgKQEAgLTksMTYgKzksOSBAQAogI2lmbmRlZiBFQVBfSUtFVjJfQ09NTU9OX0gKICNkZWZpbmUgRUFQX0lLRVYyX0NPTU1PTl9ICiAKLSNpZmRlZiBDQ05TX1BMCi0vKiBpbmNvcnJlY3QgYml0IG9yZGVyICovCi0jZGVmaW5lIElLRVYyX0ZMQUdTX0xFTkdUSF9JTkNMVURFRCAweDAxCi0jZGVmaW5lIElLRVYyX0ZMQUdTX01PUkVfRlJBR01FTlRTIDB4MDIKLSNkZWZpbmUgSUtFVjJfRkxBR1NfSUNWX0lOQ0xVREVEIDB4MDQKLSNlbHNlIC8qIENDTlNfUEwgKi8KICNkZWZpbmUgSUtFVjJfRkxBR1NfTEVOR1RIX0lOQ0xVREVEIDB4ODAKICNkZWZpbmUgSUtFVjJfRkxBR1NfTU9SRV9GUkFHTUVOVFMgMHg0MAogI2RlZmluZSBJS0VWMl9GTEFHU19JQ1ZfSU5DTFVERUQgMHgyMAotI2VuZGlmIC8qIENDTlNfUEwgKi8KIAogI2RlZmluZSBJS0VWMl9GUkFHTUVOVF9TSVpFIDE0MDAKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uYyBiL3NyYy9lYXBfY29tbW9uL2VhcF9wd2RfY29tbW9uLmMKaW5kZXggN2Q2ZTZiOC4uZmRjZmY3ZiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uYworKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfcHdkX2NvbW1vbi5jCkBAIC0yNjMsMTggKzI2MywxOCBAQAogIGZhaWw6CiAJCUVDX0dST1VQX2ZyZWUoZ3JwLT5ncm91cCk7CiAJCWdycC0+Z3JvdXAgPSBOVUxMOwotCQlFQ19QT0lOVF9mcmVlKGdycC0+cHdlKTsKKwkJRUNfUE9JTlRfY2xlYXJfZnJlZShncnAtPnB3ZSk7CiAJCWdycC0+cHdlID0gTlVMTDsKLQkJQk5fZnJlZShncnAtPm9yZGVyKTsKKwkJQk5fY2xlYXJfZnJlZShncnAtPm9yZGVyKTsKIAkJZ3JwLT5vcmRlciA9IE5VTEw7Ci0JCUJOX2ZyZWUoZ3JwLT5wcmltZSk7CisJCUJOX2NsZWFyX2ZyZWUoZ3JwLT5wcmltZSk7CiAJCWdycC0+cHJpbWUgPSBOVUxMOwogCQlyZXQgPSAxOwogCX0KIAkvKiBjbGVhbmxpbmVzcyBhbmQgb3JkZXIuLi4uICovCi0JQk5fZnJlZShjb2ZhY3Rvcik7Ci0JQk5fZnJlZSh4X2NhbmRpZGF0ZSk7Ci0JQk5fZnJlZShybmQpOworCUJOX2NsZWFyX2ZyZWUoY29mYWN0b3IpOworCUJOX2NsZWFyX2ZyZWUoeF9jYW5kaWRhdGUpOworCUJOX2NsZWFyX2ZyZWUocm5kKTsKIAlvc19mcmVlKHByZmJ1Zik7CiAKIAlyZXR1cm4gcmV0OwpAQCAtMjg0LDExICsyODQsMTAgQEAKIGludCBjb21wdXRlX2tleXMoRUFQX1BXRF9ncm91cCAqZ3JwLCBCTl9DVFggKmJuY3R4LCBCSUdOVU0gKmssCiAJCSBCSUdOVU0gKnBlZXJfc2NhbGFyLCBCSUdOVU0gKnNlcnZlcl9zY2FsYXIsCiAJCSB1OCAqY29uZmlybV9wZWVyLCB1OCAqY29uZmlybV9zZXJ2ZXIsCi0JCSB1MzIgKmNpcGhlcnN1aXRlLCB1OCAqbXNrLCB1OCAqZW1zaykKKwkJIHUzMiAqY2lwaGVyc3VpdGUsIHU4ICptc2ssIHU4ICplbXNrLCB1OCAqc2Vzc2lvbl9pZCkKIHsKIAlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmhhc2g7CiAJdTggbWtbU0hBMjU2X01BQ19MRU5dLCAqY3J1ZnQ7Ci0JdTggc2Vzc2lvbl9pZFtTSEEyNTZfTUFDX0xFTiArIDFdOwogCXU4IG1za19lbXNrW0VBUF9NU0tfTEVOICsgRUFQX0VNU0tfTEVOXTsKIAlpbnQgb2Zmc2V0OwogCmRpZmYgLS1naXQgYS9zcmMvZWFwX2NvbW1vbi9lYXBfcHdkX2NvbW1vbi5oIGIvc3JjL2VhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uaAppbmRleCA4MTZlNThjLi5jNTRjNDQxIDEwMDY0NAotLS0gYS9zcmMvZWFwX2NvbW1vbi9lYXBfcHdkX2NvbW1vbi5oCisrKyBiL3NyYy9lYXBfY29tbW9uL2VhcF9wd2RfY29tbW9uLmgKQEAgLTU5LDcgKzU5LDcgQEAKIGludCBjb21wdXRlX3Bhc3N3b3JkX2VsZW1lbnQoRUFQX1BXRF9ncm91cCAqLCB1MTYsIHU4ICosIGludCwgdTggKiwgaW50LCB1OCAqLAogCQkJICAgICBpbnQsIHU4ICopOwogaW50IGNvbXB1dGVfa2V5cyhFQVBfUFdEX2dyb3VwICosIEJOX0NUWCAqLCBCSUdOVU0gKiwgQklHTlVNICosIEJJR05VTSAqLAotCQkgdTggKiwgdTggKiwgdTMyICosIHU4ICosIHU4ICopOworCQkgdTggKiwgdTggKiwgdTMyICosIHU4ICosIHU4ICosIHU4ICopOwogc3RydWN0IGNyeXB0b19oYXNoICogZWFwX3B3ZF9oX2luaXQodm9pZCk7CiB2b2lkIGVhcF9wd2RfaF91cGRhdGUoc3RydWN0IGNyeXB0b19oYXNoICpoYXNoLCBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbik7CiB2b2lkIGVhcF9wd2RfaF9maW5hbChzdHJ1Y3QgY3J5cHRvX2hhc2ggKmhhc2gsIHU4ICpkaWdlc3QpOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX3NpbV9jb21tb24uYyBiL3NyYy9lYXBfY29tbW9uL2VhcF9zaW1fY29tbW9uLmMKaW5kZXggZTE3NzNiZi4uMmFkYzNiMyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX3NpbV9jb21tb24uYworKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfc2ltX2NvbW1vbi5jCkBAIC0xOTgsNyArMTk4LDcgQEAKIAkJICAgIGhtYWMsIEVBUF9TSU1fTUFDX0xFTik7CiAJb3NfZnJlZSh0bXApOwogCi0JcmV0dXJuIChvc19tZW1jbXAoaG1hYywgbWFjLCBFQVBfU0lNX01BQ19MRU4pID09IDApID8gMCA6IDE7CisJcmV0dXJuIChvc19tZW1jbXBfY29uc3QoaG1hYywgbWFjLCBFQVBfU0lNX01BQ19MRU4pID09IDApID8gMCA6IDE7CiB9CiAKIApAQCAtMzkzLDcgKzM5Myw3IEBACiAJCSAgICBobWFjLCBFQVBfU0lNX01BQ19MRU4pOwogCW9zX2ZyZWUodG1wKTsKIAotCXJldHVybiAob3NfbWVtY21wKGhtYWMsIG1hYywgRUFQX1NJTV9NQUNfTEVOKSA9PSAwKSA/IDAgOiAxOworCXJldHVybiAob3NfbWVtY21wX2NvbnN0KGhtYWMsIG1hYywgRUFQX1NJTV9NQUNfTEVOKSA9PSAwKSA/IDAgOiAxOwogfQogCiAKQEAgLTg5Myw3ICs4OTMsNyBAQAogCQkJaWYgKGF0dHItPmtkZl9jb3VudCA9PSBFQVBfQUtBX1BSSU1FX0tERl9NQVgpIHsKIAkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1BS0EnOiBUb28gbWFueSAiCiAJCQkJCSAgICJBVF9LREYgYXR0cmlidXRlcyAtIGlnbm9yZSB0aGlzIik7Ci0JCQkJY29udGludWU7CisJCQkJYnJlYWs7CiAJCQl9CiAJCQlhdHRyLT5rZGZbYXR0ci0+a2RmX2NvdW50XSA9IFdQQV9HRVRfQkUxNihhcG9zKTsKIAkJCWF0dHItPmtkZl9jb3VudCsrOwpAQCAtOTcyLDcgKzk3Miw2IEBACiBzdHJ1Y3QgZWFwX3NpbV9tc2cgewogCXN0cnVjdCB3cGFidWYgKmJ1ZjsKIAlzaXplX3QgbWFjLCBpdiwgZW5jcjsgLyogaW5kZXggZnJvbSBidWYgKi8KLQlpbnQgdHlwZTsKIH07CiAKIApAQCAtOTg2LDcgKzk4NSw2IEBACiAJaWYgKG1zZyA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAotCW1zZy0+dHlwZSA9IHR5cGU7CiAJbXNnLT5idWYgPSB3cGFidWZfYWxsb2MoRUFQX1NJTV9JTklUX0xFTik7CiAJaWYgKG1zZy0+YnVmID09IE5VTEwpIHsKIAkJb3NfZnJlZShtc2cpOwpAQCAtMTAwNiw3ICsxMDA0LDggQEAKIH0KIAogCi1zdHJ1Y3Qgd3BhYnVmICogZWFwX3NpbV9tc2dfZmluaXNoKHN0cnVjdCBlYXBfc2ltX21zZyAqbXNnLCBjb25zdCB1OCAqa19hdXQsCitzdHJ1Y3Qgd3BhYnVmICogZWFwX3NpbV9tc2dfZmluaXNoKHN0cnVjdCBlYXBfc2ltX21zZyAqbXNnLCBpbnQgdHlwZSwKKwkJCQkgICBjb25zdCB1OCAqa19hdXQsCiAJCQkJICAgY29uc3QgdTggKmV4dHJhLCBzaXplX3QgZXh0cmFfbGVuKQogewogCXN0cnVjdCBlYXBfaGRyICplYXA7CkBAIC0xMDE5LDcgKzEwMTgsNyBAQAogCWVhcC0+bGVuZ3RoID0gaG9zdF90b19iZTE2KHdwYWJ1Zl9sZW4obXNnLT5idWYpKTsKIAogI2lmIGRlZmluZWQoRUFQX0FLQV9QUklNRSkgfHwgZGVmaW5lZChFQVBfU0VSVkVSX0FLQV9QUklNRSkKLQlpZiAoa19hdXQgJiYgbXNnLT5tYWMgJiYgbXNnLT50eXBlID09IEVBUF9UWVBFX0FLQV9QUklNRSkgeworCWlmIChrX2F1dCAmJiBtc2ctPm1hYyAmJiB0eXBlID09IEVBUF9UWVBFX0FLQV9QUklNRSkgewogCQllYXBfc2ltX2FkZF9tYWNfc2hhMjU2KGtfYXV0LCAodTggKikgd3BhYnVmX2hlYWQobXNnLT5idWYpLAogCQkJCSAgICAgICB3cGFidWZfbGVuKG1zZy0+YnVmKSwKIAkJCQkgICAgICAgKHU4ICopIHdwYWJ1Zl9taGVhZChtc2ctPmJ1ZikgKwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX3NpbV9jb21tb24uaCBiL3NyYy9lYXBfY29tbW9uL2VhcF9zaW1fY29tbW9uLmgKaW5kZXggNjAyMWJkMi4uZGFlYjBlMiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX3NpbV9jb21tb24uaAorKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfc2ltX2NvbW1vbi5oCkBAIC0yMTEsNyArMjExLDggQEAKIHN0cnVjdCBlYXBfc2ltX21zZzsKIAogc3RydWN0IGVhcF9zaW1fbXNnICogZWFwX3NpbV9tc2dfaW5pdChpbnQgY29kZSwgaW50IGlkLCBpbnQgdHlwZSwgaW50IHN1YnR5cGUpOwotc3RydWN0IHdwYWJ1ZiAqIGVhcF9zaW1fbXNnX2ZpbmlzaChzdHJ1Y3QgZWFwX3NpbV9tc2cgKm1zZywgY29uc3QgdTggKmtfYXV0LAorc3RydWN0IHdwYWJ1ZiAqIGVhcF9zaW1fbXNnX2ZpbmlzaChzdHJ1Y3QgZWFwX3NpbV9tc2cgKm1zZywgaW50IHR5cGUsCisJCQkJICAgY29uc3QgdTggKmtfYXV0LAogCQkJCSAgIGNvbnN0IHU4ICpleHRyYSwgc2l6ZV90IGV4dHJhX2xlbik7CiB2b2lkIGVhcF9zaW1fbXNnX2ZyZWUoc3RydWN0IGVhcF9zaW1fbXNnICptc2cpOwogdTggKiBlYXBfc2ltX21zZ19hZGRfZnVsbChzdHJ1Y3QgZWFwX3NpbV9tc2cgKm1zZywgdTggYXR0ciwKZGlmZiAtLWdpdCBhL3NyYy9lYXBfY29tbW9uL2lrZXYyX2NvbW1vbi5jIGIvc3JjL2VhcF9jb21tb24vaWtldjJfY29tbW9uLmMKaW5kZXggMzc2ZmNhZC4uM2Q0ZmI2ZiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vaWtldjJfY29tbW9uLmMKKysrIGIvc3JjL2VhcF9jb21tb24vaWtldjJfY29tbW9uLmMKQEAgLTIxLDcgKzIxLDcgQEAKIAl7IEFVVEhfSE1BQ19NRDVfOTYsIDE2LCAxMiB9CiB9OwogCi0jZGVmaW5lIE5VTV9JTlRFR19BTEdTIChzaXplb2YoaWtldjJfaW50ZWdfYWxncykgLyBzaXplb2YoaWtldjJfaW50ZWdfYWxnc1swXSkpCisjZGVmaW5lIE5VTV9JTlRFR19BTEdTIEFSUkFZX1NJWkUoaWtldjJfaW50ZWdfYWxncykKIAogCiBzdGF0aWMgc3RydWN0IGlrZXYyX3ByZl9hbGcgaWtldjJfcHJmX2FsZ3NbXSA9IHsKQEAgLTI5LDcgKzI5LDcgQEAKIAl7IFBSRl9ITUFDX01ENSwgMTYsIDE2IH0KIH07CiAKLSNkZWZpbmUgTlVNX1BSRl9BTEdTIChzaXplb2YoaWtldjJfcHJmX2FsZ3MpIC8gc2l6ZW9mKGlrZXYyX3ByZl9hbGdzWzBdKSkKKyNkZWZpbmUgTlVNX1BSRl9BTEdTIEFSUkFZX1NJWkUoaWtldjJfcHJmX2FsZ3MpCiAKIAogc3RhdGljIHN0cnVjdCBpa2V2Ml9lbmNyX2FsZyBpa2V2Ml9lbmNyX2FsZ3NbXSA9IHsKQEAgLTM3LDcgKzM3LDcgQEAKIAl7IEVOQ1JfM0RFUywgMjQsIDggfQogfTsKIAotI2RlZmluZSBOVU1fRU5DUl9BTEdTIChzaXplb2YoaWtldjJfZW5jcl9hbGdzKSAvIHNpemVvZihpa2V2Ml9lbmNyX2FsZ3NbMF0pKQorI2RlZmluZSBOVU1fRU5DUl9BTEdTIEFSUkFZX1NJWkUoaWtldjJfZW5jcl9hbGdzKQogCiAKIGNvbnN0IHN0cnVjdCBpa2V2Ml9pbnRlZ19hbGcgKiBpa2V2Ml9nZXRfaW50ZWcoaW50IGlkKQpAQCAtMTczLDQ2ICsxNzMsMTIgQEAKIH0KIAogCi0jaWZkZWYgQ0NOU19QTAotLyogZnJvbSBkZXMuYyAqLwotc3RydWN0IGRlczNfa2V5X3MgewotCXUzMiBla1szXVszMl07Ci0JdTMyIGRrWzNdWzMyXTsKLX07Ci0KLXZvaWQgZGVzM19rZXlfc2V0dXAoY29uc3QgdTggKmtleSwgc3RydWN0IGRlczNfa2V5X3MgKmRrZXkpOwotdm9pZCBkZXMzX2VuY3J5cHQoY29uc3QgdTggKnBsYWluLCBjb25zdCBzdHJ1Y3QgZGVzM19rZXlfcyAqa2V5LCB1OCAqY3J5cHQpOwotdm9pZCBkZXMzX2RlY3J5cHQoY29uc3QgdTggKmNyeXB0LCBjb25zdCBzdHJ1Y3QgZGVzM19rZXlfcyAqa2V5LCB1OCAqcGxhaW4pOwotI2VuZGlmIC8qIENDTlNfUEwgKi8KLQotCiBpbnQgaWtldjJfZW5jcl9lbmNyeXB0KGludCBhbGcsIGNvbnN0IHU4ICprZXksIHNpemVfdCBrZXlfbGVuLCBjb25zdCB1OCAqaXYsCiAJCSAgICAgICBjb25zdCB1OCAqcGxhaW4sIHU4ICpjcnlwdCwgc2l6ZV90IGxlbikKIHsKIAlzdHJ1Y3QgY3J5cHRvX2NpcGhlciAqY2lwaGVyOwogCWludCBlbmNyX2FsZzsKIAotI2lmZGVmIENDTlNfUEwKLQlpZiAoYWxnID09IEVOQ1JfM0RFUykgewotCQlzdHJ1Y3QgZGVzM19rZXlfcyBkZXMza2V5OwotCQlzaXplX3QgaSwgYmxvY2tzOwotCQl1OCAqcG9zOwotCi0JCS8qIEVDQiBtb2RlIGlzIHVzZWQgaW5jb3JyZWN0bHkgZm9yIDNERVMhPyAqLwotCQlpZiAoa2V5X2xlbiAhPSAyNCkgewotCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIklLRVYyOiBJbnZhbGlkIGVuY3Iga2V5IGxlbmd0aCIpOwotCQkJcmV0dXJuIC0xOwotCQl9Ci0JCWRlczNfa2V5X3NldHVwKGtleSwgJmRlczNrZXkpOwotCi0JCWJsb2NrcyA9IGxlbiAvIDg7Ci0JCXBvcyA9IGNyeXB0OwotCQlmb3IgKGkgPSAwOyBpIDwgYmxvY2tzOyBpKyspIHsKLQkJCWRlczNfZW5jcnlwdChwb3MsICZkZXMza2V5LCBwb3MpOwotCQkJcG9zICs9IDg7Ci0JCX0KLQl9IGVsc2UgewotI2VuZGlmIC8qIENDTlNfUEwgKi8KIAlzd2l0Y2ggKGFsZykgewogCWNhc2UgRU5DUl8zREVTOgogCQllbmNyX2FsZyA9IENSWVBUT19DSVBIRVJfQUxHXzNERVM7CkBAIC0yMzcsOSArMjAzLDYgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAljcnlwdG9fY2lwaGVyX2RlaW5pdChjaXBoZXIpOwotI2lmZGVmIENDTlNfUEwKLQl9Ci0jZW5kaWYgLyogQ0NOU19QTCAqLwogCiAJcmV0dXJuIDA7CiB9CkBAIC0yNTEsMzEgKzIxNCw2IEBACiAJc3RydWN0IGNyeXB0b19jaXBoZXIgKmNpcGhlcjsKIAlpbnQgZW5jcl9hbGc7CiAKLSNpZmRlZiBDQ05TX1BMCi0JaWYgKGFsZyA9PSBFTkNSXzNERVMpIHsKLQkJc3RydWN0IGRlczNfa2V5X3MgZGVzM2tleTsKLQkJc2l6ZV90IGksIGJsb2NrczsKLQotCQkvKiBFQ0IgbW9kZSBpcyB1c2VkIGluY29ycmVjdGx5IGZvciAzREVTIT8gKi8KLQkJaWYgKGtleV9sZW4gIT0gMjQpIHsKLQkJCXdwYV9wcmludGYoTVNHX0lORk8sICJJS0VWMjogSW52YWxpZCBlbmNyIGtleSBsZW5ndGgiKTsKLQkJCXJldHVybiAtMTsKLQkJfQotCQlkZXMzX2tleV9zZXR1cChrZXksICZkZXMza2V5KTsKLQotCQlpZiAobGVuICUgOCkgewotCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIklLRVYyOiBJbnZhbGlkIGVuY3J5cHRlZCAiCi0JCQkJICAgImxlbmd0aCIpOwotCQkJcmV0dXJuIC0xOwotCQl9Ci0JCWJsb2NrcyA9IGxlbiAvIDg7Ci0JCWZvciAoaSA9IDA7IGkgPCBibG9ja3M7IGkrKykgewotCQkJZGVzM19kZWNyeXB0KGNyeXB0LCAmZGVzM2tleSwgcGxhaW4pOwotCQkJcGxhaW4gKz0gODsKLQkJCWNyeXB0ICs9IDg7Ci0JCX0KLQl9IGVsc2UgewotI2VuZGlmIC8qIENDTlNfUEwgKi8KIAlzd2l0Y2ggKGFsZykgewogCWNhc2UgRU5DUl8zREVTOgogCQllbmNyX2FsZyA9IENSWVBUT19DSVBIRVJfQUxHXzNERVM7CkBAIC0zMDAsOSArMjM4LDYgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAljcnlwdG9fY2lwaGVyX2RlaW5pdChjaXBoZXIpOwotI2lmZGVmIENDTlNfUEwKLQl9Ci0jZW5kaWYgLyogQ0NOU19QTCAqLwogCiAJcmV0dXJuIDA7CiB9CkBAIC01NDIsNyArNDc3LDcgQEAKIAkJCSAgICJoYXNoIik7CiAJCXJldHVybiBOVUxMOwogCX0KLQlpZiAob3NfbWVtY21wKGludGVnLCBoYXNoLCBpbnRlZ19hbGctPmhhc2hfbGVuKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChpbnRlZywgaGFzaCwgaW50ZWdfYWxnLT5oYXNoX2xlbikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSUtFVjI6IEluY29ycmVjdCBJbnRlZ3JpdHkgQ2hlY2tzdW0gIgogCQkJICAgIkRhdGEiKTsKIAkJcmV0dXJuIE5VTEw7CkBAIC03MDYsMTAgKzY0MSw2IEBACiAJa2V5cy0+U0tfaW50ZWdfbGVuID0gaW50ZWctPmtleV9sZW47CiAJa2V5cy0+U0tfZW5jcl9sZW4gPSBlbmNyLT5rZXlfbGVuOwogCWtleXMtPlNLX3ByZl9sZW4gPSBwcmYtPmtleV9sZW47Ci0jaWZkZWYgQ0NOU19QTAotCS8qIFVzZXMgZW5jcnlwdGlvbiBrZXkgbGVuZ3RoIGZvciBTS19kOyBzaG91bGQgYmUgUFJGIGxlbmd0aCAqLwotCWtleXMtPlNLX2RfbGVuID0ga2V5cy0+U0tfZW5jcl9sZW47Ci0jZW5kaWYgLyogQ0NOU19QTCAqLwogCiAJa2V5YnVmX2xlbiA9IGtleXMtPlNLX2RfbGVuICsgMiAqIGtleXMtPlNLX2ludGVnX2xlbiArCiAJCTIgKiBrZXlzLT5TS19lbmNyX2xlbiArIDIgKiBrZXlzLT5TS19wcmZfbGVuOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vaWtldjJfY29tbW9uLmggYi9zcmMvZWFwX2NvbW1vbi9pa2V2Ml9jb21tb24uaAppbmRleCA0NWM5NzBiLi44YTc5ODJhIDEwMDY0NAotLS0gYS9zcmMvZWFwX2NvbW1vbi9pa2V2Ml9jb21tb24uaAorKysgYi9zcmMvZWFwX2NvbW1vbi9pa2V2Ml9jb21tb24uaApAQCAtNzAsMTEgKzcwLDcgQEAKIC8qIEN1cnJlbnQgSUtFdjIgdmVyc2lvbiBmcm9tIFJGQyA0MzA2ICovCiAjZGVmaW5lIElLRVYyX01qVmVyIDIKICNkZWZpbmUgSUtFVjJfTW5WZXIgMAotI2lmZGVmIENDTlNfUEwKLSNkZWZpbmUgSUtFVjJfVkVSU0lPTiAoKElLRVYyX01qVmVyKSB8ICgoSUtFVjJfTW5WZXIpIDw8IDQpKQotI2Vsc2UgLyogQ0NOU19QTCAqLwogI2RlZmluZSBJS0VWMl9WRVJTSU9OICgoKElLRVYyX01qVmVyKSA8PCA0KSB8IChJS0VWMl9NblZlcikpCi0jZW5kaWYgLyogQ0NOU19QTCAqLwogCiAvKiBJS0V2MiBFeGNoYW5nZSBUeXBlcyAqLwogZW51bSB7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvTWFrZWZpbGUgYi9zcmMvZWFwX3BlZXIvTWFrZWZpbGUKaW5kZXggMzY1MTA1Ni4uZjc5NTE5YiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL01ha2VmaWxlCisrKyBiL3NyYy9lYXBfcGVlci9NYWtlZmlsZQpAQCAtMiw3ICsyLDcgQEAKIAlAZWNobyBOb3RoaW5nIHRvIGJlIG1hZGUuCiAKIGNsZWFuOgotCXJtIC1mICp+ICoubyAqLnNvICouZAorCXJtIC1mICp+ICoubyAqLnNvICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgogCiBpbnN0YWxsOgogCWlmIGxzICouc28gPi9kZXYvbnVsbCAyPiYxOyB0aGVuIFwKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXAuYyBiL3NyYy9lYXBfcGVlci9lYXAuYwppbmRleCA1NTRlN2U5Li45ODgwZDNiIDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwLmMKKysrIGIvc3JjL2VhcF9wZWVyL2VhcC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIEVBUCBwZWVyIHN0YXRlIG1hY2hpbmVzIChSRkMgNDEzNykKLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTkyLDYgKzkyLDE1IEBACiB9CiAKIAorc3RhdGljIHZvaWQgZWFwX3NtX2ZyZWVfa2V5KHN0cnVjdCBlYXBfc20gKnNtKQoreworCWlmIChzbS0+ZWFwS2V5RGF0YSkgeworCQliaW5fY2xlYXJfZnJlZShzbS0+ZWFwS2V5RGF0YSwgc20tPmVhcEtleURhdGFMZW4pOworCQlzbS0+ZWFwS2V5RGF0YSA9IE5VTEw7CisJfQorfQorCisKIHN0YXRpYyB2b2lkIGVhcF9kZWluaXRfcHJldl9tZXRob2Qoc3RydWN0IGVhcF9zbSAqc20sIGNvbnN0IGNoYXIgKnR4dCkKIHsKIAlleHRfcGFzc3dvcmRfZnJlZShzbS0+ZXh0X3B3X2J1Zik7CkBAIC0xNDQsMTEgKzE1MywxMyBAQAogCVNNX0VOVFJZKEVBUCwgSU5JVElBTElaRSk7CiAJaWYgKHNtLT5mYXN0X3JlYXV0aCAmJiBzbS0+bSAmJiBzbS0+bS0+aGFzX3JlYXV0aF9kYXRhICYmCiAJICAgIHNtLT5tLT5oYXNfcmVhdXRoX2RhdGEoc20sIHNtLT5lYXBfbWV0aG9kX3ByaXYpICYmCi0JICAgICFzbS0+cHJldl9mYWlsdXJlKSB7CisJICAgICFzbS0+cHJldl9mYWlsdXJlICYmCisJICAgIHNtLT5sYXN0X2NvbmZpZyA9PSBlYXBfZ2V0X2NvbmZpZyhzbSkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVA6IG1haW50YWluaW5nIEVBUCBtZXRob2QgZGF0YSBmb3IgIgogCQkJICAgImZhc3QgcmVhdXRoZW50aWNhdGlvbiIpOwogCQlzbS0+bS0+ZGVpbml0X2Zvcl9yZWF1dGgoc20sIHNtLT5lYXBfbWV0aG9kX3ByaXYpOwogCX0gZWxzZSB7CisJCXNtLT5sYXN0X2NvbmZpZyA9IGVhcF9nZXRfY29uZmlnKHNtKTsKIAkJZWFwX2RlaW5pdF9wcmV2X21ldGhvZChzbSwgIklOSVRJQUxJWkUiKTsKIAl9CiAJc20tPnNlbGVjdGVkTWV0aG9kID0gRUFQX1RZUEVfTk9ORTsKQEAgLTE1OSw4ICsxNzAsNyBAQAogCWVhcG9sX3NldF9pbnQoc20sIEVBUE9MX2lkbGVXaGlsZSwgc20tPkNsaWVudFRpbWVvdXQpOwogCWVhcG9sX3NldF9ib29sKHNtLCBFQVBPTF9lYXBTdWNjZXNzLCBGQUxTRSk7CiAJZWFwb2xfc2V0X2Jvb2woc20sIEVBUE9MX2VhcEZhaWwsIEZBTFNFKTsKLQlvc19mcmVlKHNtLT5lYXBLZXlEYXRhKTsKLQlzbS0+ZWFwS2V5RGF0YSA9IE5VTEw7CisJZWFwX3NtX2ZyZWVfa2V5KHNtKTsKIAlvc19mcmVlKHNtLT5lYXBTZXNzaW9uSWQpOwogCXNtLT5lYXBTZXNzaW9uSWQgPSBOVUxMOwogCXNtLT5lYXBLZXlBdmFpbGFibGUgPSBGQUxTRTsKQEAgLTE3OSw2ICsxODksNyBAQAogCWVhcG9sX3NldF9ib29sKHNtLCBFQVBPTF9lYXBOb1Jlc3AsIEZBTFNFKTsKIAlzbS0+bnVtX3JvdW5kcyA9IDA7CiAJc20tPnByZXZfZmFpbHVyZSA9IDA7CisJc20tPmV4cGVjdGVkX2ZhaWx1cmUgPSAwOwogfQogCiAKQEAgLTM4OCwxMCArMzk5LDExIEBACiAJc20tPmVhcFJlc3BEYXRhID0gc20tPm0tPnByb2Nlc3Moc20sIHNtLT5lYXBfbWV0aG9kX3ByaXYsICZyZXQsCiAJCQkJCSBlYXBSZXFEYXRhKTsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUDogbWV0aG9kIHByb2Nlc3MgLT4gaWdub3JlPSVzICIKLQkJICAgIm1ldGhvZFN0YXRlPSVzIGRlY2lzaW9uPSVzIiwKKwkJICAgIm1ldGhvZFN0YXRlPSVzIGRlY2lzaW9uPSVzIGVhcFJlc3BEYXRhPSVwIiwKIAkJICAgcmV0Lmlnbm9yZSA/ICJUUlVFIiA6ICJGQUxTRSIsCiAJCSAgIGVhcF9zbV9tZXRob2Rfc3RhdGVfdHh0KHJldC5tZXRob2RTdGF0ZSksCi0JCSAgIGVhcF9zbV9kZWNpc2lvbl90eHQocmV0LmRlY2lzaW9uKSk7CisJCSAgIGVhcF9zbV9kZWNpc2lvbl90eHQocmV0LmRlY2lzaW9uKSwKKwkJICAgc20tPmVhcFJlc3BEYXRhKTsKIAogCXNtLT5pZ25vcmUgPSByZXQuaWdub3JlOwogCWlmIChzbS0+aWdub3JlKQpAQCAtNDAyLDcgKzQxNCw3IEBACiAKIAlpZiAoc20tPm0tPmlzS2V5QXZhaWxhYmxlICYmIHNtLT5tLT5nZXRLZXkgJiYKIAkgICAgc20tPm0tPmlzS2V5QXZhaWxhYmxlKHNtLCBzbS0+ZWFwX21ldGhvZF9wcml2KSkgewotCQlvc19mcmVlKHNtLT5lYXBLZXlEYXRhKTsKKwkJZWFwX3NtX2ZyZWVfa2V5KHNtKTsKIAkJc20tPmVhcEtleURhdGEgPSBzbS0+bS0+Z2V0S2V5KHNtLCBzbS0+ZWFwX21ldGhvZF9wcml2LAogCQkJCQkgICAgICAgJnNtLT5lYXBLZXlEYXRhTGVuKTsKIAkJb3NfZnJlZShzbS0+ZWFwU2Vzc2lvbklkKTsKQEAgLTQzMiw4ICs0NDQsMTAgQEAKIAkJc20tPmxhc3RJZCA9IHNtLT5yZXFJZDsKIAkJc20tPmxhc3RSZXNwRGF0YSA9IHdwYWJ1Zl9kdXAoc20tPmVhcFJlc3BEYXRhKTsKIAkJZWFwb2xfc2V0X2Jvb2woc20sIEVBUE9MX2VhcFJlc3AsIFRSVUUpOwotCX0gZWxzZQorCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQOiBObyBlYXBSZXNwRGF0YSBhdmFpbGFibGUiKTsKIAkJc20tPmxhc3RSZXNwRGF0YSA9IE5VTEw7CisJfQogCWVhcG9sX3NldF9ib29sKHNtLCBFQVBPTF9lYXBSZXEsIEZBTFNFKTsKIAllYXBvbF9zZXRfaW50KHNtLCBFQVBPTF9pZGxlV2hpbGUsIHNtLT5DbGllbnRUaW1lb3V0KTsKIH0KQEAgLTcyNCw4ICs3MzgsMTkgQEAKIAkJCVNNX0VOVEVSKEVBUCwgU0VORF9SRVNQT05TRSk7CiAJCWJyZWFrOwogCWNhc2UgRUFQX01FVEhPRDoKKwkJLyoKKwkJICogTm90ZTogUkZDIDQxMzcgdXNlcyBtZXRob2RTdGF0ZSA9PSBET05FICYmIGRlY2lzaW9uID09IEZBSUwKKwkJICogYXMgdGhlIGNvbmRpdGlvbi4gZWFwUmVzcERhdGEgPT0gTlVMTCBoZXJlIGlzIHVzZWQgdG8gYWxsb3cKKwkJICogZmluYWwgRUFQIG1ldGhvZCByZXNwb25zZSB0byBiZSBzZW50IHdpdGhvdXQgaGF2aW5nIHRvIGNoYW5nZQorCQkgKiBhbGwgbWV0aG9kcyB0byBlaXRoZXIgdXNlIG1ldGhvZFN0YXRlIE1BWV9DT05UIG9yIGxlYXZpbmcKKwkJICogZGVjaXNpb24gdG8gc29tZXRoaW5nIGVsc2UgdGhhbiBGQUlMIGluIGNhc2VzIHdoZXJlIHRoZSBvbmx5CisJCSAqIGV4cGVjdGVkIHJlc3BvbnNlIGlzIEVBUC1GYWlsdXJlLgorCQkgKi8KIAkJaWYgKHNtLT5pZ25vcmUpCiAJCQlTTV9FTlRFUihFQVAsIERJU0NBUkQpOworCQllbHNlIGlmIChzbS0+bWV0aG9kU3RhdGUgPT0gTUVUSE9EX0RPTkUgJiYKKwkJCSBzbS0+ZGVjaXNpb24gPT0gREVDSVNJT05fRkFJTCAmJiAhc20tPmVhcFJlc3BEYXRhKQorCQkJU01fRU5URVIoRUFQLCBGQUlMVVJFKTsKIAkJZWxzZQogCQkJU01fRU5URVIoRUFQLCBTRU5EX1JFU1BPTlNFKTsKIAkJYnJlYWs7CkBAIC0xNDczLDggKzE0OTgsNyBAQAogCXNtLT5sYXN0UmVzcERhdGEgPSBOVUxMOwogCXdwYWJ1Zl9mcmVlKHNtLT5lYXBSZXNwRGF0YSk7CiAJc20tPmVhcFJlc3BEYXRhID0gTlVMTDsKLQlvc19mcmVlKHNtLT5lYXBLZXlEYXRhKTsKLQlzbS0+ZWFwS2V5RGF0YSA9IE5VTEw7CisJZWFwX3NtX2ZyZWVfa2V5KHNtKTsKIAlvc19mcmVlKHNtLT5lYXBTZXNzaW9uSWQpOwogCXNtLT5lYXBTZXNzaW9uSWQgPSBOVUxMOwogCkBAIC0xNjM4LDcgKzE2NjIsOCBAQAogCQkJICAgY29uc3QgY2hhciAqbXNnLCBzaXplX3QgbXNnbGVuKQogewogCXN0cnVjdCBlYXBfcGVlcl9jb25maWcgKmNvbmZpZzsKLQljaGFyICp0eHQgPSBOVUxMLCAqdG1wOworCWNvbnN0IGNoYXIgKnR4dCA9IE5VTEw7CisJY2hhciAqdG1wOwogCiAJaWYgKHNtID09IE5VTEwpCiAJCXJldHVybjsKQEAgLTE2ODEsNiArMTcwNiw5IEBACiAJY2FzZSBXUEFfQ1RSTF9SRVFfRUFQX1BBU1NQSFJBU0U6CiAJCWNvbmZpZy0+cGVuZGluZ19yZXFfcGFzc3BocmFzZSsrOwogCQlicmVhazsKKwljYXNlIFdQQV9DVFJMX1JFUV9TSU06CisJCXR4dCA9IG1zZzsKKwkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJcmV0dXJuOwogCX0KQEAgLTE3OTIsNiArMTgyMCwxNyBAQAogCiAKIC8qKgorICogZWFwX3NtX3JlcXVlc3Rfc2ltIC0gUmVxdWVzdCBleHRlcm5hbCBTSU0gcHJvY2Vzc2luZworICogQHNtOiBQb2ludGVyIHRvIEVBUCBzdGF0ZSBtYWNoaW5lIGFsbG9jYXRlZCB3aXRoIGVhcF9wZWVyX3NtX2luaXQoKQorICogQHJlcTogRUFQIG1ldGhvZCBzcGVjaWZpYyByZXF1ZXN0CisgKi8KK3ZvaWQgZWFwX3NtX3JlcXVlc3Rfc2ltKHN0cnVjdCBlYXBfc20gKnNtLCBjb25zdCBjaGFyICpyZXEpCit7CisJZWFwX3NtX3JlcXVlc3Qoc20sIFdQQV9DVFJMX1JFUV9TSU0sIHJlcSwgb3Nfc3RybGVuKHJlcSkpOworfQorCisKKy8qKgogICogZWFwX3NtX25vdGlmeV9jdHJsX2F0dGFjaGVkIC0gTm90aWZpY2F0aW9uIG9mIGF0dGFjaGVkIG1vbml0b3IKICAqIEBzbTogUG9pbnRlciB0byBFQVAgc3RhdGUgbWFjaGluZSBhbGxvY2F0ZWQgd2l0aCBlYXBfcGVlcl9zbV9pbml0KCkKICAqCkBAIC0yMDE3LDYgKzIwNTYsOCBAQAogCWlmIChjb25maWctPmZsYWdzICYgRUFQX0NPTkZJR19GTEFHU19FWFRfUEFTU1dPUkQpIHsKIAkJaWYgKGVhcF9nZXRfZXh0X3Bhc3N3b3JkKHNtLCBjb25maWcpIDwgMCkKIAkJCXJldHVybiBOVUxMOworCQlpZiAoaGFzaCkKKwkJCSpoYXNoID0gMDsKIAkJKmxlbiA9IHdwYWJ1Zl9sZW4oc20tPmV4dF9wd19idWYpOwogCQlyZXR1cm4gd3BhYnVmX2hlYWQoc20tPmV4dF9wd19idWYpOwogCX0KQEAgLTIzMDQsNiArMjM0NSwxNyBAQAogfQogCiAKKy8qKgorICogZWFwX3NldF9leHRlcm5hbF9zaW0gLSBTZXQgZXh0ZXJuYWxfc2ltIGZsYWcKKyAqIEBzbTogUG9pbnRlciB0byBFQVAgc3RhdGUgbWFjaGluZSBhbGxvY2F0ZWQgd2l0aCBlYXBfcGVlcl9zbV9pbml0KCkKKyAqIEBleHRlcm5hbF9zaW06IFdoZXRoZXIgZXh0ZXJuYWwgU0lNL1VTSU0gcHJvY2Vzc2luZyBpcyB1c2VkCisgKi8KK3ZvaWQgZWFwX3NldF9leHRlcm5hbF9zaW0oc3RydWN0IGVhcF9zbSAqc20sIGludCBleHRlcm5hbF9zaW0pCit7CisJc20tPmV4dGVybmFsX3NpbSA9IGV4dGVybmFsX3NpbTsKK30KKworCiAgLyoqCiAgKiBlYXBfbm90aWZ5X3BlbmRpbmcgLSBOb3RpZnkgdGhhdCBFQVAgbWV0aG9kIGlzIHJlYWR5IHRvIHJlLXByb2Nlc3MgYSByZXF1ZXN0CiAgKiBAc206IFBvaW50ZXIgdG8gRUFQIHN0YXRlIG1hY2hpbmUgYWxsb2NhdGVkIHdpdGggZWFwX3BlZXJfc21faW5pdCgpCkBAIC0yMzc1LDMgKzI0MjcsOSBAQAogCWlmIChzbS0+ZWFwb2xfY2ItPnNldF9hbm9uX2lkKQogCQlzbS0+ZWFwb2xfY2ItPnNldF9hbm9uX2lkKHNtLT5lYXBvbF9jdHgsIGlkLCBsZW4pOwogfQorCisKK2ludCBlYXBfcGVlcl93YXNfZmFpbHVyZV9leHBlY3RlZChzdHJ1Y3QgZWFwX3NtICpzbSkKK3sKKwlyZXR1cm4gc20tPmV4cGVjdGVkX2ZhaWx1cmU7Cit9CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwLmggYi9zcmMvZWFwX3BlZXIvZWFwLmgKaW5kZXggZjg3ZjliMy4uNzEyZTkyOSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcC5oCisrKyBiL3NyYy9lYXBfcGVlci9lYXAuaApAQCAtMjk2LDYgKzI5Niw3IEBACiB2b2lkIGVhcF9zbV9yZXF1ZXN0X3BpbihzdHJ1Y3QgZWFwX3NtICpzbSk7CiB2b2lkIGVhcF9zbV9yZXF1ZXN0X290cChzdHJ1Y3QgZWFwX3NtICpzbSwgY29uc3QgY2hhciAqbXNnLCBzaXplX3QgbXNnX2xlbik7CiB2b2lkIGVhcF9zbV9yZXF1ZXN0X3Bhc3NwaHJhc2Uoc3RydWN0IGVhcF9zbSAqc20pOwordm9pZCBlYXBfc21fcmVxdWVzdF9zaW0oc3RydWN0IGVhcF9zbSAqc20sIGNvbnN0IGNoYXIgKnJlcSk7CiB2b2lkIGVhcF9zbV9ub3RpZnlfY3RybF9hdHRhY2hlZChzdHJ1Y3QgZWFwX3NtICpzbSk7CiB1MzIgZWFwX2dldF9waGFzZTJfdHlwZShjb25zdCBjaGFyICpuYW1lLCBpbnQgKnZlbmRvcik7CiBzdHJ1Y3QgZWFwX21ldGhvZF90eXBlICogZWFwX2dldF9waGFzZTJfdHlwZXMoc3RydWN0IGVhcF9wZWVyX2NvbmZpZyAqY29uZmlnLApAQCAtMzAzLDYgKzMwNCw3IEBACiB2b2lkIGVhcF9zZXRfZmFzdF9yZWF1dGgoc3RydWN0IGVhcF9zbSAqc20sIGludCBlbmFibGVkKTsKIHZvaWQgZWFwX3NldF93b3JrYXJvdW5kKHN0cnVjdCBlYXBfc20gKnNtLCB1bnNpZ25lZCBpbnQgd29ya2Fyb3VuZCk7CiB2b2lkIGVhcF9zZXRfZm9yY2VfZGlzYWJsZWQoc3RydWN0IGVhcF9zbSAqc20sIGludCBkaXNhYmxlZCk7Cit2b2lkIGVhcF9zZXRfZXh0ZXJuYWxfc2ltKHN0cnVjdCBlYXBfc20gKnNtLCBpbnQgZXh0ZXJuYWxfc2ltKTsKIGludCBlYXBfa2V5X2F2YWlsYWJsZShzdHJ1Y3QgZWFwX3NtICpzbSk7CiB2b2lkIGVhcF9ub3RpZnlfc3VjY2VzcyhzdHJ1Y3QgZWFwX3NtICpzbSk7CiB2b2lkIGVhcF9ub3RpZnlfbG93ZXJfbGF5ZXJfc3VjY2VzcyhzdHJ1Y3QgZWFwX3NtICpzbSk7CkBAIC0zMTgsNiArMzIwLDcgQEAKIHN0cnVjdCBleHRfcGFzc3dvcmRfZGF0YTsKIHZvaWQgZWFwX3NtX3NldF9leHRfcHdfY3R4KHN0cnVjdCBlYXBfc20gKnNtLCBzdHJ1Y3QgZXh0X3Bhc3N3b3JkX2RhdGEgKmV4dCk7CiB2b2lkIGVhcF9zZXRfYW5vbl9pZChzdHJ1Y3QgZWFwX3NtICpzbSwgY29uc3QgdTggKmlkLCBzaXplX3QgbGVuKTsKK2ludCBlYXBfcGVlcl93YXNfZmFpbHVyZV9leHBlY3RlZChzdHJ1Y3QgZWFwX3NtICpzbSk7CiAKICNlbmRpZiAvKiBJRUVFODAyMVhfRUFQT0wgKi8KIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9ha2EuYyBiL3NyYy9lYXBfcGVlci9lYXBfYWthLmMKaW5kZXggZGM0MjRkNy4uMDY2MmFlNyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9ha2EuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX2FrYS5jCkBAIC00Miw3ICs0Miw3IEBACiAJdTggKmxhc3RfZWFwX2lkZW50aXR5OwogCXNpemVfdCBsYXN0X2VhcF9pZGVudGl0eV9sZW47CiAJZW51bSB7Ci0JCUNPTlRJTlVFLCBSRVNVTFRfU1VDQ0VTUywgUkVTVUxUX0ZBSUxVUkUsIFNVQ0NFU1MsIEZBSUxVUkUKKwkJQ09OVElOVUUsIFJFU1VMVF9TVUNDRVNTLCBTVUNDRVNTLCBGQUlMVVJFCiAJfSBzdGF0ZTsKIAogCXN0cnVjdCB3cGFidWYgKmlkX21zZ3M7CkBAIC02NCw4ICs2NCw2IEBACiAJCXJldHVybiAiQ09OVElOVUUiOwogCWNhc2UgUkVTVUxUX1NVQ0NFU1M6CiAJCXJldHVybiAiUkVTVUxUX1NVQ0NFU1MiOwotCWNhc2UgUkVTVUxUX0ZBSUxVUkU6Ci0JCXJldHVybiAiUkVTVUxUX0ZBSUxVUkUiOwogCWNhc2UgU1VDQ0VTUzoKIAkJcmV0dXJuICJTVUNDRVNTIjsKIAljYXNlIEZBSUxVUkU6CkBAIC0xMjgsNiArMTI2LDIxIEBACiAjZW5kaWYgLyogRUFQX0FLQV9QUklNRSAqLwogCiAKK3N0YXRpYyB2b2lkIGVhcF9ha2FfY2xlYXJfa2V5cyhzdHJ1Y3QgZWFwX2FrYV9kYXRhICpkYXRhLCBpbnQgcmVhdXRoKQoreworCWlmICghcmVhdXRoKSB7CisJCW9zX21lbXNldChkYXRhLT5taywgMCwgRUFQX1NJTV9NS19MRU4pOworCQlvc19tZW1zZXQoZGF0YS0+a19hdXQsIDAsIEVBUF9BS0FfUFJJTUVfS19BVVRfTEVOKTsKKwkJb3NfbWVtc2V0KGRhdGEtPmtfZW5jciwgMCwgRUFQX1NJTV9LX0VOQ1JfTEVOKTsKKwkJb3NfbWVtc2V0KGRhdGEtPmtfcmUsIDAsIEVBUF9BS0FfUFJJTUVfS19SRV9MRU4pOworCX0KKwlvc19tZW1zZXQoZGF0YS0+bXNrLCAwLCBFQVBfU0lNX0tFWUlOR19EQVRBX0xFTik7CisJb3NfbWVtc2V0KGRhdGEtPmVtc2ssIDAsIEVBUF9FTVNLX0xFTik7CisJb3NfbWVtc2V0KGRhdGEtPmF1dG4sIDAsIEVBUF9BS0FfQVVUTl9MRU4pOworCW9zX21lbXNldChkYXRhLT5hdXRzLCAwLCBFQVBfQUtBX0FVVFNfTEVOKTsKK30KKworCiBzdGF0aWMgdm9pZCBlYXBfYWthX2RlaW5pdChzdHJ1Y3QgZWFwX3NtICpzbSwgdm9pZCAqcHJpdikKIHsKIAlzdHJ1Y3QgZWFwX2FrYV9kYXRhICpkYXRhID0gcHJpdjsKQEAgLTEzNywxMSArMTUwLDk1IEBACiAJCW9zX2ZyZWUoZGF0YS0+bGFzdF9lYXBfaWRlbnRpdHkpOwogCQl3cGFidWZfZnJlZShkYXRhLT5pZF9tc2dzKTsKIAkJb3NfZnJlZShkYXRhLT5uZXR3b3JrX25hbWUpOworCQllYXBfYWthX2NsZWFyX2tleXMoZGF0YSwgMCk7CiAJCW9zX2ZyZWUoZGF0YSk7CiAJfQogfQogCiAKK3N0YXRpYyBpbnQgZWFwX2FrYV9leHRfc2ltX3JlcShzdHJ1Y3QgZWFwX3NtICpzbSwgc3RydWN0IGVhcF9ha2FfZGF0YSAqZGF0YSkKK3sKKwljaGFyIHJlcVsyMDBdLCAqcG9zLCAqZW5kOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtQUtBOiBVc2UgZXh0ZXJuYWwgVVNJTSBwcm9jZXNzaW5nIik7CisJcG9zID0gcmVxOworCWVuZCA9IHBvcyArIHNpemVvZihyZXEpOworCXBvcyArPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlVNVFMtQVVUSCIpOworCXBvcyArPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIjoiKTsKKwlwb3MgKz0gd3BhX3NucHJpbnRmX2hleChwb3MsIGVuZCAtIHBvcywgZGF0YS0+cmFuZCwgRUFQX0FLQV9SQU5EX0xFTik7CisJcG9zICs9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiOiIpOworCXdwYV9zbnByaW50Zl9oZXgocG9zLCBlbmQgLSBwb3MsIGRhdGEtPmF1dG4sIEVBUF9BS0FfQVVUTl9MRU4pOworCisJZWFwX3NtX3JlcXVlc3Rfc2ltKHNtLCByZXEpOworCXJldHVybiAxOworfQorCisKK3N0YXRpYyBpbnQgZWFwX2FrYV9leHRfc2ltX3Jlc3VsdChzdHJ1Y3QgZWFwX3NtICpzbSwgc3RydWN0IGVhcF9ha2FfZGF0YSAqZGF0YSwKKwkJCQkgIHN0cnVjdCBlYXBfcGVlcl9jb25maWcgKmNvbmYpCit7CisJY2hhciAqcmVzcCwgKnBvczsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkgICAiRUFQLUFLQTogVXNlIHJlc3VsdCBmcm9tIGV4dGVybmFsIFVTSU0gcHJvY2Vzc2luZyIpOworCisJcmVzcCA9IGNvbmYtPmV4dGVybmFsX3NpbV9yZXNwOworCWNvbmYtPmV4dGVybmFsX3NpbV9yZXNwID0gTlVMTDsKKworCWlmIChvc19zdHJuY21wKHJlc3AsICJVTVRTLUFVVFM6IiwgMTApID09IDApIHsKKwkJcG9zID0gcmVzcCArIDEwOworCQlpZiAoaGV4c3RyMmJpbihwb3MsIGRhdGEtPmF1dHMsIEVBUF9BS0FfQVVUU19MRU4pIDwgMCkKKwkJCWdvdG8gaW52YWxpZDsKKwkJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIkVBUC1BS0E6IEFVVFMiLCBkYXRhLT5hdXRzLAorCQkJCUVBUF9BS0FfQVVUU19MRU4pOworCQlvc19mcmVlKHJlc3ApOworCQlyZXR1cm4gLTI7CisJfQorCisJaWYgKG9zX3N0cm5jbXAocmVzcCwgIlVNVFMtQVVUSDoiLCAxMCkgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1BS0E6IFVucmVjb2duaXplZCBleHRlcm5hbCBVU0lNIHByb2Nlc3NpbmcgcmVzcG9uc2UiKTsKKwkJb3NfZnJlZShyZXNwKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXBvcyA9IHJlc3AgKyAxMDsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAtQUtBOiBSQU5EIiwgZGF0YS0+cmFuZCwgRUFQX0FLQV9SQU5EX0xFTik7CisKKwlpZiAoaGV4c3RyMmJpbihwb3MsIGRhdGEtPmlrLCBFQVBfQUtBX0lLX0xFTikgPCAwKQorCQlnb3RvIGludmFsaWQ7CisJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIkVBUC1BS0E6IElLIiwgZGF0YS0+aWssIEVBUF9BS0FfSUtfTEVOKTsKKwlwb3MgKz0gRUFQX0FLQV9JS19MRU4gKiAyOworCWlmICgqcG9zICE9ICc6JykKKwkJZ290byBpbnZhbGlkOworCXBvcysrOworCisJaWYgKGhleHN0cjJiaW4ocG9zLCBkYXRhLT5jaywgRUFQX0FLQV9DS19MRU4pIDwgMCkKKwkJZ290byBpbnZhbGlkOworCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJFQVAtQUtBOiBDSyIsIGRhdGEtPmNrLCBFQVBfQUtBX0NLX0xFTik7CisJcG9zICs9IEVBUF9BS0FfQ0tfTEVOICogMjsKKwlpZiAoKnBvcyAhPSAnOicpCisJCWdvdG8gaW52YWxpZDsKKwlwb3MrKzsKKworCWRhdGEtPnJlc19sZW4gPSBvc19zdHJsZW4ocG9zKSAvIDI7CisJaWYgKGRhdGEtPnJlc19sZW4gPiBFQVBfQUtBX1JFU19NQVhfTEVOKSB7CisJCWRhdGEtPnJlc19sZW4gPSAwOworCQlnb3RvIGludmFsaWQ7CisJfQorCWlmIChoZXhzdHIyYmluKHBvcywgZGF0YS0+cmVzLCBkYXRhLT5yZXNfbGVuKSA8IDApCisJCWdvdG8gaW52YWxpZDsKKwl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiRUFQLUFLQTogUkVTIiwgZGF0YS0+cmVzLCBkYXRhLT5yZXNfbGVuKTsKKworCW9zX2ZyZWUocmVzcCk7CisJcmV0dXJuIDA7CisKK2ludmFsaWQ6CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtQUtBOiBJbnZhbGlkIGV4dGVybmFsIFVTSU0gcHJvY2Vzc2luZyBVTVRTLUFVVEggcmVzcG9uc2UiKTsKKwlvc19mcmVlKHJlc3ApOworCXJldHVybiAtMTsKK30KKworCiBzdGF0aWMgaW50IGVhcF9ha2FfdW10c19hdXRoKHN0cnVjdCBlYXBfc20gKnNtLCBzdHJ1Y3QgZWFwX2FrYV9kYXRhICpkYXRhKQogewogCXN0cnVjdCBlYXBfcGVlcl9jb25maWcgKmNvbmY7CkBAIC0xNTEsNiArMjQ4LDE0IEBACiAJY29uZiA9IGVhcF9nZXRfY29uZmlnKHNtKTsKIAlpZiAoY29uZiA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CisKKwlpZiAoc20tPmV4dGVybmFsX3NpbSkgeworCQlpZiAoY29uZi0+ZXh0ZXJuYWxfc2ltX3Jlc3ApCisJCQlyZXR1cm4gZWFwX2FrYV9leHRfc2ltX3Jlc3VsdChzbSwgZGF0YSwgY29uZik7CisJCWVsc2UKKwkJCXJldHVybiBlYXBfYWthX2V4dF9zaW1fcmVxKHNtLCBkYXRhKTsKKwl9CisKIAlpZiAoY29uZi0+cGNzYykgewogCQlyZXR1cm4gc2NhcmRfdW10c19hdXRoKHNtLT5zY2FyZF9jdHgsIGRhdGEtPnJhbmQsCiAJCQkJICAgICAgIGRhdGEtPmF1dG4sIGRhdGEtPnJlcywgJmRhdGEtPnJlc19sZW4sCkBAIC0yMDUsNyArMzEwLDcgQEAKIAl7CiAJCXU4IGF1dG5bRUFQX0FLQV9BVVROX0xFTl07CiAJCW9zX21lbXNldChhdXRuLCAnMScsIEVBUF9BS0FfQVVUTl9MRU4pOwotCQlpZiAob3NfbWVtY21wKGF1dG4sIGRhdGEtPmF1dG4sIEVBUF9BS0FfQVVUTl9MRU4pICE9IDApIHsKKwkJaWYgKG9zX21lbWNtcF9jb25zdChhdXRuLCBkYXRhLT5hdXRuLCBFQVBfQUtBX0FVVE5fTEVOKSAhPSAwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiRUFQLUFLQTogQVVUTiBkaWQgbm90IG1hdGNoICIKIAkJCQkgICAid2l0aCBleHBlY3RlZCB2YWx1ZSIpOwogCQkJcmV0dXJuIC0xOwpAQCAtMjI1LDcgKzMzMCw3IEBACiAKICNlbHNlIC8qIENPTkZJR19VU0lNX0hBUkRDT0RFRCAqLwogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtQUtBOiBObyBVTVRTIGF1dGhlbnRpY2F0aW9uIGFsZ29yaXRoICIKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1BS0E6IE5vIFVNVFMgYXV0aGVudGljYXRpb24gYWxnb3JpdGhtICIKIAkJICAgImVuYWJsZWQiKTsKIAlyZXR1cm4gLTE7CiAKQEAgLTQyMCw3ICs1MjUsNyBAQAogI2VuZGlmIC8qIEVBUF9BS0FfUFJJTUUgKi8KIAkJc2hhMV92ZWN0b3IoMSwgJmFkZHIsICZsZW4sIGhhc2gpOwogCi0JaWYgKG9zX21lbWNtcChoYXNoLCBjaGVja2NvZGUsIGhhc2hfbGVuKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChoYXNoLCBjaGVja2NvZGUsIGhhc2hfbGVuKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUFLQTogTWlzbWF0Y2ggaW4gQVRfQ0hFQ0tDT0RFIik7CiAJCXJldHVybiAtMTsKIAl9CkBAIC00NDMsNyArNTQ4LDcgQEAKIAltc2cgPSBlYXBfc2ltX21zZ19pbml0KEVBUF9DT0RFX1JFU1BPTlNFLCBpZCwgZGF0YS0+ZWFwX21ldGhvZCwKIAkJCSAgICAgICBFQVBfQUtBX1NVQlRZUEVfQ0xJRU5UX0VSUk9SKTsKIAllYXBfc2ltX21zZ19hZGQobXNnLCBFQVBfU0lNX0FUX0NMSUVOVF9FUlJPUl9DT0RFLCBlcnIsIE5VTEwsIDApOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBOVUxMLCBOVUxMLCAwKTsKKwlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+ZWFwX21ldGhvZCwgTlVMTCwgTlVMTCwgMCk7CiB9CiAKIApAQCAtNDYwLDcgKzU2NSw3IEBACiAJCSAgICIoaWQ9JWQpIiwgaWQpOwogCW1zZyA9IGVhcF9zaW1fbXNnX2luaXQoRUFQX0NPREVfUkVTUE9OU0UsIGlkLCBkYXRhLT5lYXBfbWV0aG9kLAogCQkJICAgICAgIEVBUF9BS0FfU1VCVFlQRV9BVVRIRU5USUNBVElPTl9SRUpFQ1QpOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBOVUxMLCBOVUxMLCAwKTsKKwlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+ZWFwX21ldGhvZCwgTlVMTCwgTlVMTCwgMCk7CiB9CiAKIApAQCAtNDc5LDcgKzU4NCw3IEBACiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9BVVRTIik7CiAJZWFwX3NpbV9tc2dfYWRkX2Z1bGwobXNnLCBFQVBfU0lNX0FUX0FVVFMsIGRhdGEtPmF1dHMsCiAJCQkgICAgIEVBUF9BS0FfQVVUU19MRU4pOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBOVUxMLCBOVUxMLCAwKTsKKwlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+ZWFwX21ldGhvZCwgTlVMTCwgTlVMTCwgMCk7CiB9CiAKIApAQCAtNTIzLDcgKzYyOCw3IEBACiAJCQkJaWRlbnRpdHksIGlkZW50aXR5X2xlbik7CiAJfQogCi0JcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIE5VTEwsIE5VTEwsIDApOworCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5lYXBfbWV0aG9kLCBOVUxMLCBOVUxMLCAwKTsKIH0KIAogCkBAIC01NDUsNyArNjUwLDggQEAKIAl9CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9NQUMiKTsKIAllYXBfc2ltX21zZ19hZGRfbWFjKG1zZywgRUFQX1NJTV9BVF9NQUMpOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5rX2F1dCwgKHU4ICopICIiLCAwKTsKKwlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+ZWFwX21ldGhvZCwgZGF0YS0+a19hdXQsICh1OCAqKSAiIiwKKwkJCQkgIDApOwogfQogCiAKQEAgLTU4Nyw3ICs2OTMsNyBAQAogCX0KIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX01BQyIpOwogCWVhcF9zaW1fbXNnX2FkZF9tYWMobXNnLCBFQVBfU0lNX0FUX01BQyk7Ci0JcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIGRhdGEtPmtfYXV0LCBub25jZV9zLAorCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5lYXBfbWV0aG9kLCBkYXRhLT5rX2F1dCwgbm9uY2VfcywKIAkJCQkgIEVBUF9TSU1fTk9OQ0VfU19MRU4pOwogfQogCkBAIC02MjEsNyArNzI3LDcgQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9NQUMiKTsKIAkJZWFwX3NpbV9tc2dfYWRkX21hYyhtc2csIEVBUF9TSU1fQVRfTUFDKTsKIAl9Ci0JcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIGtfYXV0LCAodTggKikgIiIsIDApOworCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5lYXBfbWV0aG9kLCBrX2F1dCwgKHU4ICopICIiLCAwKTsKIH0KIAogCkBAIC03MDEsNyArODA3LDcgQEAKIAkJCSAgICAgICBFQVBfQUtBX1NVQlRZUEVfQ0hBTExFTkdFKTsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX0tERiIpOwogCWVhcF9zaW1fbXNnX2FkZChtc2csIEVBUF9TSU1fQVRfS0RGLCBrZGYsIE5VTEwsIDApOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBOVUxMLCBOVUxMLCAwKTsKKwlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+ZWFwX21ldGhvZCwgTlVMTCwgTlVMTCwgMCk7CiB9CiAKIApAQCAtODYxLDYgKzk2Nyw5IEBACiAJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJFQVAtQUtBOiBVTVRTIGF1dGhlbnRpY2F0aW9uICIKIAkJCSAgICJmYWlsZWQgKEFVVE4gc2VxIyAtPiBBVVRTKSIpOwogCQlyZXR1cm4gZWFwX2FrYV9zeW5jaHJvbml6YXRpb25fZmFpbHVyZShkYXRhLCBpZCk7CisJfSBlbHNlIGlmIChyZXMgPiAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUFLQTogV2FpdCBmb3IgZXh0ZXJuYWwgVVNJTSBwcm9jZXNzaW5nIik7CisJCXJldHVybiBOVUxMOwogCX0gZWxzZSBpZiAocmVzKSB7CiAJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJFQVAtQUtBOiBVTVRTIGF1dGhlbnRpY2F0aW9uIGZhaWxlZCIpOwogCQlyZXR1cm4gZWFwX2FrYV9jbGllbnRfZXJyb3IoZGF0YSwgaWQsCkBAIC05MzEsNyArMTA0MCw3IEBACiAJaWYgKGRhdGEtPnJlc3VsdF9pbmQgJiYgYXR0ci0+cmVzdWx0X2luZCkKIAkJZGF0YS0+dXNlX3Jlc3VsdF9pbmQgPSAxOwogCi0JaWYgKGRhdGEtPnN0YXRlICE9IEZBSUxVUkUgJiYgZGF0YS0+c3RhdGUgIT0gUkVTVUxUX0ZBSUxVUkUpIHsKKwlpZiAoZGF0YS0+c3RhdGUgIT0gRkFJTFVSRSkgewogCQllYXBfYWthX3N0YXRlKGRhdGEsIGRhdGEtPnVzZV9yZXN1bHRfaW5kID8KIAkJCSAgICAgIFJFU1VMVF9TVUNDRVNTIDogU1VDQ0VTUyk7CiAJfQpAQCAtMTE0Nyw3ICsxMjU2LDcgQEAKIAlpZiAoZGF0YS0+cmVzdWx0X2luZCAmJiBhdHRyLT5yZXN1bHRfaW5kKQogCQlkYXRhLT51c2VfcmVzdWx0X2luZCA9IDE7CiAKLQlpZiAoZGF0YS0+c3RhdGUgIT0gRkFJTFVSRSAmJiBkYXRhLT5zdGF0ZSAhPSBSRVNVTFRfRkFJTFVSRSkgeworCWlmIChkYXRhLT5zdGF0ZSAhPSBGQUlMVVJFKSB7CiAJCWVhcF9ha2Ffc3RhdGUoZGF0YSwgZGF0YS0+dXNlX3Jlc3VsdF9pbmQgPwogCQkJICAgICAgUkVTVUxUX1NVQ0NFU1MgOiBTVUNDRVNTKTsKIAl9CkBAIC0xMjUzLDkgKzEzNjIsNyBAQAogCQkgKi8KIAkJcmV0LT5tZXRob2RTdGF0ZSA9IGRhdGEtPnVzZV9yZXN1bHRfaW5kID8KIAkJCU1FVEhPRF9ET05FIDogTUVUSE9EX01BWV9DT05UOwotCX0gZWxzZSBpZiAoZGF0YS0+c3RhdGUgPT0gUkVTVUxUX0ZBSUxVUkUpCi0JCXJldC0+bWV0aG9kU3RhdGUgPSBNRVRIT0RfQ09OVDsKLQllbHNlIGlmIChkYXRhLT5zdGF0ZSA9PSBSRVNVTFRfU1VDQ0VTUykKKwl9IGVsc2UgaWYgKGRhdGEtPnN0YXRlID09IFJFU1VMVF9TVUNDRVNTKQogCQlyZXQtPm1ldGhvZFN0YXRlID0gTUVUSE9EX0NPTlQ7CiAKIAlpZiAocmV0LT5tZXRob2RTdGF0ZSA9PSBNRVRIT0RfRE9ORSkgewpAQCAtMTI4Miw2ICsxMzg5LDcgQEAKIAlkYXRhLT5pZF9tc2dzID0gTlVMTDsKIAlkYXRhLT51c2VfcmVzdWx0X2luZCA9IDA7CiAJZGF0YS0+a2RmX25lZ290aWF0aW9uID0gMDsKKwllYXBfYWthX2NsZWFyX2tleXMoZGF0YSwgMSk7CiB9CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9jb25maWcuaCBiL3NyYy9lYXBfcGVlci9lYXBfY29uZmlnLmgKaW5kZXggNDJmNTI1Yi4uMjU5MWUxMSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9jb25maWcuaAorKysgYi9zcmMvZWFwX3BlZXIvZWFwX2NvbmZpZy5oCkBAIC0xNTcsNyArMTU3LDcgQEAKIAkgKgogCSAqIElmIGxlZnQgb3V0LCB0aGlzIHdpbGwgYmUgYXNrZWQgdGhyb3VnaCBjb250cm9sIGludGVyZmFjZS4KIAkgKi8KLQl1OCAqcHJpdmF0ZV9rZXlfcGFzc3dkOworCWNoYXIgKnByaXZhdGVfa2V5X3Bhc3N3ZDsKIAogCS8qKgogCSAqIGRoX2ZpbGUgLSBGaWxlIHBhdGggdG8gREgvRFNBIHBhcmFtZXRlcnMgZmlsZSAoaW4gUEVNIGZvcm1hdCkKQEAgLTIwOCw2ICsyMDgsMjQgQEAKIAl1OCAqYWx0c3ViamVjdF9tYXRjaDsKIAogCS8qKgorCSAqIGRvbWFpbl9zdWZmaXhfbWF0Y2ggLSBDb25zdHJhaW50IGZvciBzZXJ2ZXIgZG9tYWluIG5hbWUKKwkgKgorCSAqIElmIHNldCwgdGhpcyBGUUROIGlzIHVzZWQgYXMgYSBzdWZmaXggbWF0Y2ggcmVxdWlyZW1lbnQgZm9yIHRoZQorCSAqIHNlcnZlciBjZXJ0aWZpY2F0ZSBpbiBTdWJqZWN0QWx0TmFtZSBkTlNOYW1lIGVsZW1lbnQocykuIElmIGEKKwkgKiBtYXRjaGluZyBkTlNOYW1lIGlzIGZvdW5kLCB0aGlzIGNvbnN0cmFpbnQgaXMgbWV0LiBJZiBubyBkTlNOYW1lCisJICogdmFsdWVzIGFyZSBwcmVzZW50LCB0aGlzIGNvbnN0cmFpbnQgaXMgbWF0Y2hlZCBhZ2FpbnN0IFN1YmpldE5hbWUgQ04KKwkgKiB1c2luZyBzYW1lIHN1ZmZpeCBtYXRjaCBjb21wYXJpc29uLiBTdWZmaXggbWF0Y2ggaGVyZSBtZWFucyB0aGF0IHRoZQorCSAqIGhvc3QvZG9tYWluIG5hbWUgaXMgY29tcGFyZWQgb25lIGxhYmVsIGF0IGEgdGltZSBzdGFydGluZyBmcm9tIHRoZQorCSAqIHRvcC1sZXZlbCBkb21haW4gYW5kIGFsbCB0aGUgbGFiZWxzIGluIGRvbWFpbl9zdWZmaXhfbWF0Y2ggc2hhbGwgYmUKKwkgKiBpbmNsdWRlZCBpbiB0aGUgY2VydGlmaWNhdGUuIFRoZSBjZXJ0aWZpY2F0ZSBtYXkgaW5jbHVkZSBhZGRpdGlvbmFsCisJICogc3ViLWxldmVsIGxhYmVscyBpbiBhZGRpdGlvbiB0byB0aGUgcmVxdWlyZWQgbGFiZWxzLgorCSAqCisJICogRm9yIGV4YW1wbGUsIGRvbWFpbl9zdWZmaXhfbWF0Y2g9ZXhhbXBsZS5jb20gd291bGQgbWF0Y2gKKwkgKiB0ZXN0LmV4YW1wbGUuY29tIGJ1dCB3b3VsZCBub3QgbWF0Y2ggdGVzdC1leGFtcGxlLmNvbS4KKwkgKi8KKwljaGFyICpkb21haW5fc3VmZml4X21hdGNoOworCisJLyoqCiAJICogY2FfY2VydDIgLSBGaWxlIHBhdGggdG8gQ0EgY2VydGlmaWNhdGUgZmlsZSAoUEVNL0RFUikgKFBoYXNlIDIpCiAJICoKIAkgKiBUaGlzIGZpbGUgY2FuIGhhdmUgb25lIG9yIG1vcmUgdHJ1c3RlZCBDQSBjZXJ0aWZpY2F0ZXMuIElmIGNhX2NlcnQyCkBAIC0yNzEsNyArMjg5LDcgQEAKIAkgKiBUaGlzIGZpZWxkIGlzIGxpa2UgcHJpdmF0ZV9rZXlfcGFzc3dkLCBidXQgdXNlZCBmb3IgcGhhc2UgMiAoaW5zaWRlCiAJICogRUFQLVRUTFMvUEVBUC9GQVNUIHR1bm5lbCkgYXV0aGVudGljYXRpb24uCiAJICovCi0JdTggKnByaXZhdGVfa2V5Ml9wYXNzd2Q7CisJY2hhciAqcHJpdmF0ZV9rZXkyX3Bhc3N3ZDsKIAogCS8qKgogCSAqIGRoX2ZpbGUyIC0gRmlsZSBwYXRoIHRvIERIL0RTQSBwYXJhbWV0ZXJzIGZpbGUgKGluIFBFTSBmb3JtYXQpCkBAIC0zMDMsNiArMzIxLDE0IEBACiAJdTggKmFsdHN1YmplY3RfbWF0Y2gyOwogCiAJLyoqCisJICogZG9tYWluX3N1ZmZpeF9tYXRjaDIgLSBDb25zdHJhaW50IGZvciBzZXJ2ZXIgZG9tYWluIG5hbWUKKwkgKgorCSAqIFRoaXMgZmllbGQgaXMgbGlrZSBkb21haW5fc3VmZml4X21hdGNoLCBidXQgdXNlZCBmb3IgcGhhc2UgMiAoaW5zaWRlCisJICogRUFQLVRUTFMvUEVBUC9GQVNUIHR1bm5lbCkgYXV0aGVudGljYXRpb24uCisJICovCisJY2hhciAqZG9tYWluX3N1ZmZpeF9tYXRjaDI7CisKKwkvKioKIAkgKiBlYXBfbWV0aG9kcyAtIEFsbG93ZWQgRUFQIG1ldGhvZHMKIAkgKgogCSAqICh2ZW5kb3I9RUFQX1ZFTkRPUl9JRVRGLG1ldGhvZD1FQVBfVFlQRV9OT05FKSB0ZXJtaW5hdGVkIGxpc3Qgb2YKQEAgLTY0Myw2ICs2NjksMjMgQEAKIAkgKiAyID0gcmVxdWlyZSB2YWxpZCBPQ1NQIHN0YXBsaW5nIHJlc3BvbnNlCiAJICovCiAJaW50IG9jc3A7CisKKwkvKioKKwkgKiBleHRlcm5hbF9zaW1fcmVzcCAtIFJlc3BvbnNlIGZyb20gZXh0ZXJuYWwgU0lNIHByb2Nlc3NpbmcKKwkgKgorCSAqIFRoaXMgZmllbGQgc2hvdWxkIG5vdCBiZSBzZXQgaW4gY29uZmlndXJhdGlvbiBzdGVwLiBJdCBpcyBvbmx5IHVzZWQKKwkgKiBpbnRlcm5hbGx5IHdoZW4gY29udHJvbCBpbnRlcmZhY2UgaXMgdXNlZCB0byByZXF1ZXN0IGV4dGVybmFsCisJICogU0lNL1VTSU0gcHJvY2Vzc2luZy4KKwkgKi8KKwljaGFyICpleHRlcm5hbF9zaW1fcmVzcDsKKworCS8qKgorCSAqIHNpbV9udW0gLSBVc2VyIHNlbGVjdGVkIFNJTSBpZGVudGlmaWVyCisJICoKKwkgKiBUaGlzIHZhcmlhYmxlIGlzIHVzZWQgZm9yIGlkZW50aWZ5aW5nIHdoaWNoIFNJTSBpcyB1c2VkIGlmIHRoZSBzeXN0ZW0KKwkgKiBoYXMgbW9yZSB0aGFuIG9uZS4KKwkgKi8KKwlpbnQgc2ltX251bTsKIH07CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9la2UuYyBiL3NyYy9lYXBfcGVlci9lYXBfZWtlLmMKaW5kZXggYzcxZGI1Zi4uOWZlYzY2YyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9la2UuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX2VrZS5jCkBAIC0yOCw2ICsyOCwxMCBAQAogCXU4IG5vbmNlX3BbRUFQX0VLRV9NQVhfTk9OQ0VfTEVOXTsKIAl1OCBub25jZV9zW0VBUF9FS0VfTUFYX05PTkNFX0xFTl07CiAJc3RydWN0IHdwYWJ1ZiAqbXNnczsKKwl1OCBkaGdyb3VwOyAvKiBmb3JjZWQgREggZ3JvdXAgb3IgMCB0byBhbGxvdyBhbGwgc3VwcG9ydGVkICovCisJdTggZW5jcjsgLyogZm9yY2VkIGVuY3J5cHRpb24gYWxnb3JpdGhtIG9yIDAgdG8gYWxsb3cgYWxsIHN1cHBvcnRlZCAqLworCXU4IHByZjsgLyogZm9yY2VkIFBSRiBvciAwIHRvIGFsbG93IGFsbCBzdXBwb3J0ZWQgKi8KKwl1OCBtYWM7IC8qIGZvcmNlZCBNQUMgb3IgMCB0byBhbGxvdyBhbGwgc3VwcG9ydGVkICovCiB9OwogCiAKQEAgLTY2LDYgKzcwLDcgQEAKIAlzdHJ1Y3QgZWFwX2VrZV9kYXRhICpkYXRhOwogCWNvbnN0IHU4ICppZGVudGl0eSwgKnBhc3N3b3JkOwogCXNpemVfdCBpZGVudGl0eV9sZW4sIHBhc3N3b3JkX2xlbjsKKwljb25zdCBjaGFyICpwaGFzZTE7CiAKIAlwYXNzd29yZCA9IGVhcF9nZXRfY29uZmlnX3Bhc3N3b3JkKHNtLCAmcGFzc3dvcmRfbGVuKTsKIAlpZiAoIXBhc3N3b3JkKSB7CkBAIC04OSw2ICs5NCwzOSBAQAogCQlkYXRhLT5wZWVyaWRfbGVuID0gaWRlbnRpdHlfbGVuOwogCX0KIAorCXBoYXNlMSA9IGVhcF9nZXRfY29uZmlnX3BoYXNlMShzbSk7CisJaWYgKHBoYXNlMSkgeworCQljb25zdCBjaGFyICpwb3M7CisKKwkJcG9zID0gb3Nfc3Ryc3RyKHBoYXNlMSwgImRoZ3JvdXA9Iik7CisJCWlmIChwb3MpIHsKKwkJCWRhdGEtPmRoZ3JvdXAgPSBhdG9pKHBvcyArIDgpOworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtRUtFOiBGb3JjZWQgZGhncm91cCAldSIsCisJCQkJICAgZGF0YS0+ZGhncm91cCk7CisJCX0KKworCQlwb3MgPSBvc19zdHJzdHIocGhhc2UxLCAiZW5jcj0iKTsKKwkJaWYgKHBvcykgeworCQkJZGF0YS0+ZW5jciA9IGF0b2kocG9zICsgNSk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1FS0U6IEZvcmNlZCBlbmNyICV1IiwKKwkJCQkgICBkYXRhLT5lbmNyKTsKKwkJfQorCisJCXBvcyA9IG9zX3N0cnN0cihwaGFzZTEsICJwcmY9Iik7CisJCWlmIChwb3MpIHsKKwkJCWRhdGEtPnByZiA9IGF0b2kocG9zICsgNCk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1FS0U6IEZvcmNlZCBwcmYgJXUiLAorCQkJCSAgIGRhdGEtPnByZik7CisJCX0KKworCQlwb3MgPSBvc19zdHJzdHIocGhhc2UxLCAibWFjPSIpOworCQlpZiAocG9zKSB7CisJCQlkYXRhLT5tYWMgPSBhdG9pKHBvcyArIDQpOworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtRUtFOiBGb3JjZWQgbWFjICV1IiwKKwkJCQkgICBkYXRhLT5tYWMpOworCQl9CisJfQorCiAJcmV0dXJuIGRhdGE7CiB9CiAKQEAgLTEwMCw3ICsxMzgsNyBAQAogCW9zX2ZyZWUoZGF0YS0+c2VydmVyaWQpOwogCW9zX2ZyZWUoZGF0YS0+cGVlcmlkKTsKIAl3cGFidWZfZnJlZShkYXRhLT5tc2dzKTsKLQlvc19mcmVlKGRhdGEpOworCWJpbl9jbGVhcl9mcmVlKGRhdGEsIHNpemVvZigqZGF0YSkpOwogfQogCiAKQEAgLTIyNiwxNiArMjY0LDIwIEBACiAJCQkgICBpLCBwb3NbMF0sIHBvc1sxXSwgcG9zWzJdLCBwb3NbM10pOwogCQlwb3MgKz0gNDsKIAotCQlpZiAoIWVhcF9la2Vfc3VwcF9kaGdyb3VwKCp0bXApKQorCQlpZiAoKGRhdGEtPmRoZ3JvdXAgJiYgZGF0YS0+ZGhncm91cCAhPSAqdG1wKSB8fAorCQkgICAgIWVhcF9la2Vfc3VwcF9kaGdyb3VwKCp0bXApKQogCQkJY29udGludWU7CiAJCXRtcCsrOwotCQlpZiAoIWVhcF9la2Vfc3VwcF9lbmNyKCp0bXApKQorCQlpZiAoKGRhdGEtPmVuY3IgJiYgZGF0YS0+ZW5jciAhPSAqdG1wKSB8fAorCQkgICAgIWVhcF9la2Vfc3VwcF9lbmNyKCp0bXApKQogCQkJY29udGludWU7CiAJCXRtcCsrOwotCQlpZiAoIWVhcF9la2Vfc3VwcF9wcmYoKnRtcCkpCisJCWlmICgoZGF0YS0+cHJmICYmIGRhdGEtPnByZiAhPSAqdG1wKSB8fAorCQkgICAgIWVhcF9la2Vfc3VwcF9wcmYoKnRtcCkpCiAJCQljb250aW51ZTsKIAkJdG1wKys7Ci0JCWlmICghZWFwX2VrZV9zdXBwX21hYygqdG1wKSkKKwkJaWYgKChkYXRhLT5tYWMgJiYgZGF0YS0+bWFjICE9ICp0bXApIHx8CisJCSAgICAhZWFwX2VrZV9zdXBwX21hYygqdG1wKSkKIAkJCWNvbnRpbnVlOwogCiAJCXByb3AgPSB0bXAgLSAzOwpAQCAtNDA5LDcgKzQ1MSw3IEBACiAJLyogREhDb21wb25lbnRfUCA9IEVuY3Ioa2V5LCB5X3ApICovCiAJcnBvcyA9IHdwYWJ1Zl9wdXQocmVzcCwgZGF0YS0+c2Vzcy5kaGNvbXBfbGVuKTsKIAlpZiAoZWFwX2VrZV9kaGNvbXAoJmRhdGEtPnNlc3MsIGtleSwgcHViLCBycG9zKSA8IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1FS0U6IEZhaWxlZCB0byBidWlsZCBESENvbXBvbmVudF9TIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtRUtFOiBGYWlsZWQgdG8gYnVpbGQgREhDb21wb25lbnRfUCIpOwogCQlvc19tZW1zZXQoa2V5LCAwLCBzaXplb2Yoa2V5KSk7CiAJCXJldHVybiBlYXBfZWtlX2J1aWxkX2ZhaWwoZGF0YSwgcmV0LCByZXFEYXRhLAogCQkJCQkgIEVBUF9FS0VfRkFJTF9QUklWQVRFX0lOVEVSTkFMX0VSUk9SKTsKQEAgLTQ4MSw3ICs1MjMsNyBAQAogCWVuZCA9IHBheWxvYWQgKyBwYXlsb2FkX2xlbjsKIAogCWlmIChwb3MgKyBkYXRhLT5zZXNzLnBub25jZV9wc19sZW4gKyBkYXRhLT5zZXNzLnByZl9sZW4gPiBlbmQpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtRUtFOiBUb28gc2hvcnQgRUFQLUVLRS1Db21taXQiKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtRUtFOiBUb28gc2hvcnQgRUFQLUVLRS1Db25maXJtIik7CiAJCXJldHVybiBlYXBfZWtlX2J1aWxkX2ZhaWwoZGF0YSwgcmV0LCByZXFEYXRhLAogCQkJCQkgIEVBUF9FS0VfRkFJTF9QUk9UT19FUlJPUik7CiAJfQpAQCAtNTAxLDcgKzU0Myw3IEBACiAJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIkVBUC1FS0U6IFJlY2VpdmVkIE5vbmNlX1AgfCBOb25jZV9TIiwKIAkJCW5vbmNlcywgMiAqIGRhdGEtPnNlc3Mubm9uY2VfbGVuKTsKIAlpZiAob3NfbWVtY21wKGRhdGEtPm5vbmNlX3AsIG5vbmNlcywgZGF0YS0+c2Vzcy5ub25jZV9sZW4pICE9IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1FS0U6IFJlY2VpdmVkIE5vbmNlX1AgZG9lcyBub3QgbWF0Y2ggdHJuc21pdHRlZCBOb25jZV9QIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtRUtFOiBSZWNlaXZlZCBOb25jZV9QIGRvZXMgbm90IG1hdGNoIHRyYW5zbWl0dGVkIE5vbmNlX1AiKTsKIAkJcmV0dXJuIGVhcF9la2VfYnVpbGRfZmFpbChkYXRhLCByZXQsIHJlcURhdGEsCiAJCQkJCSAgRUFQX0VLRV9GQUlMX0FVVEhFTlRJQ0FUSU9OX0ZBSUwpOwogCX0KQEAgLTUyNCw4ICs1NjYsOCBAQAogCQkJCQkgIEVBUF9FS0VfRkFJTF9QUklWQVRFX0lOVEVSTkFMX0VSUk9SKTsKIAl9CiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUVLRTogQXV0aF9TIiwgYXV0aF9zLCBkYXRhLT5zZXNzLnByZl9sZW4pOwotCWlmIChvc19tZW1jbXAoYXV0aF9zLCBwb3MgKyBkYXRhLT5zZXNzLnBub25jZV9wc19sZW4sCi0JCSAgICAgIGRhdGEtPnNlc3MucHJmX2xlbikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QoYXV0aF9zLCBwb3MgKyBkYXRhLT5zZXNzLnBub25jZV9wc19sZW4sCisJCQkgICAgZGF0YS0+c2Vzcy5wcmZfbGVuKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtRUtFOiBBdXRoX1MgZG9lcyBub3QgbWF0Y2giKTsKIAkJcmV0dXJuIGVhcF9la2VfYnVpbGRfZmFpbChkYXRhLCByZXQsIHJlcURhdGEsCiAJCQkJCSAgRUFQX0VLRV9GQUlMX0FVVEhFTlRJQ0FUSU9OX0ZBSUwpOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9mYXN0LmMgYi9zcmMvZWFwX3BlZXIvZWFwX2Zhc3QuYwppbmRleCAzYjhkODAzLi4wNzM5MTg3IDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX2Zhc3QuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX2Zhc3QuYwpAQCAtMTQ5LDE0ICsxNDksMTYgQEAKIAlzdHJ1Y3QgZWFwX2Zhc3RfZGF0YSAqZGF0YTsKIAlzdHJ1Y3QgZWFwX3BlZXJfY29uZmlnICpjb25maWcgPSBlYXBfZ2V0X2NvbmZpZyhzbSk7CiAKKwlpZiAoY29uZmlnID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCiAJZGF0YSA9IG9zX3phbGxvYyhzaXplb2YoKmRhdGEpKTsKIAlpZiAoZGF0YSA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAlkYXRhLT5mYXN0X3ZlcnNpb24gPSBFQVBfRkFTVF9WRVJTSU9OOwogCWRhdGEtPm1heF9wYWNfbGlzdF9sZW4gPSAxMDsKIAotCWlmIChjb25maWcgJiYgY29uZmlnLT5waGFzZTEgJiYKLQkgICAgZWFwX2Zhc3RfcGFyc2VfcGhhc2UxKGRhdGEsIGNvbmZpZy0+cGhhc2UxKSA8IDApIHsKKwlpZiAoY29uZmlnLT5waGFzZTEgJiYgZWFwX2Zhc3RfcGFyc2VfcGhhc2UxKGRhdGEsIGNvbmZpZy0+cGhhc2UxKSA8IDApIHsKIAkJZWFwX2Zhc3RfZGVpbml0KHNtLCBkYXRhKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtMTk2LDE0ICsxOTgsMjIgQEAKIAkJCSAgICJ3b3JrYXJvdW5kcyIpOwogCX0KIAorCWlmICghY29uZmlnLT5wYWNfZmlsZSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLUZBU1Q6IE5vIFBBQyBmaWxlIGNvbmZpZ3VyZWQiKTsKKwkJZWFwX2Zhc3RfZGVpbml0KHNtLCBkYXRhKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCiAJaWYgKGRhdGEtPnVzZV9wYWNfYmluYXJ5X2Zvcm1hdCAmJgogCSAgICBlYXBfZmFzdF9sb2FkX3BhY19iaW4oc20sICZkYXRhLT5wYWMsIGNvbmZpZy0+cGFjX2ZpbGUpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLUZBU1Q6IEZhaWxlZCB0byBsb2FkIFBBQyBmaWxlIik7CiAJCWVhcF9mYXN0X2RlaW5pdChzbSwgZGF0YSk7CiAJCXJldHVybiBOVUxMOwogCX0KIAogCWlmICghZGF0YS0+dXNlX3BhY19iaW5hcnlfZm9ybWF0ICYmCiAJICAgIGVhcF9mYXN0X2xvYWRfcGFjKHNtLCAmZGF0YS0+cGFjLCBjb25maWctPnBhY19maWxlKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1GQVNUOiBGYWlsZWQgdG8gbG9hZCBQQUMgZmlsZSIpOwogCQllYXBfZmFzdF9kZWluaXQoc20sIGRhdGEpOwogCQlyZXR1cm4gTlVMTDsKIAl9CkBAIC0yNDAsNiArMjUwLDggQEAKIAkJcGFjID0gcGFjLT5uZXh0OwogCQllYXBfZmFzdF9mcmVlX3BhYyhwcmV2KTsKIAl9CisJb3NfbWVtc2V0KGRhdGEtPmtleV9kYXRhLCAwLCBFQVBfRkFTVF9LRVlfTEVOKTsKKwlvc19tZW1zZXQoZGF0YS0+ZW1zaywgMCwgRUFQX0VNU0tfTEVOKTsKIAlvc19mcmVlKGRhdGEtPnNlc3Npb25faWQpOwogCXdwYWJ1Zl9mcmVlKGRhdGEtPnBlbmRpbmdfcGhhc2UyX3JlcSk7CiAJb3NfZnJlZShkYXRhKTsKQEAgLTc1Nyw3ICs3NjksNyBAQAogCQkgICAgIk1BQyBjYWxjdWxhdGlvbiIsICh1OCAqKSBfYmluZCwgYmluZF9sZW4pOwogCWhtYWNfc2hhMShjbWssIEVBUF9GQVNUX0NNS19MRU4sICh1OCAqKSBfYmluZCwgYmluZF9sZW4sCiAJCSAgX2JpbmQtPmNvbXBvdW5kX21hYyk7Ci0JcmVzID0gb3NfbWVtY21wKGNtYWMsIF9iaW5kLT5jb21wb3VuZF9tYWMsIHNpemVvZihjbWFjKSk7CisJcmVzID0gb3NfbWVtY21wX2NvbnN0KGNtYWMsIF9iaW5kLT5jb21wb3VuZF9tYWMsIHNpemVvZihjbWFjKSk7CiAJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJFQVAtRkFTVDogUmVjZWl2ZWQgQ29tcG91bmQgTUFDIiwKIAkJICAgIGNtYWMsIHNpemVvZihjbWFjKSk7CiAJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJFQVAtRkFTVDogQ2FsY3VsYXRlZCBDb21wb3VuZCBNQUMiLApAQCAtMTA0Nyw2ICsxMDU5LDcgQEAKIAkJfQogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1GQVNUOiBTZW5kIFBBQy1BY2tub3dsZWRnZW1lbnQgVExWICIKIAkJCSAgICItIFByb3Zpc2lvbmluZyBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5Iik7CisJCXNtLT5leHBlY3RlZF9mYWlsdXJlID0gMTsKIAl9IGVsc2UgewogCQkvKgogCQkgKiBUaGlzIGlzIFBBQyByZWZyZXNoaW5nLCBpLmUuLCBub3JtYWwgYXV0aGVudGljYXRpb24gdGhhdCBpcwpAQCAtMTA2OSw3ICsxMDgyLDggQEAKIAkJCQkgICAgc3RydWN0IGVhcF9mYXN0X3Rsdl9wYXJzZSAqdGx2LAogCQkJCSAgICBzdHJ1Y3Qgd3BhYnVmICoqcmVzcCkKIHsKLQlpbnQgbWFuZGF0b3J5LCB0bHZfdHlwZSwgbGVuLCByZXM7CisJaW50IG1hbmRhdG9yeSwgdGx2X3R5cGUsIHJlczsKKwlzaXplX3QgbGVuOwogCXU4ICpwb3MsICplbmQ7CiAKIAlvc19tZW1zZXQodGx2LCAwLCBzaXplb2YoKnRsdikpOwpAQCAtMTA4MywxMyArMTA5NywxNCBAQAogCQlwb3MgKz0gMjsKIAkJbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CiAJCXBvcyArPSAyOwotCQlpZiAocG9zICsgbGVuID4gZW5kKSB7CisJCWlmIChsZW4gPiAoc2l6ZV90KSAoZW5kIC0gcG9zKSkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1GQVNUOiBUTFYgb3ZlcmZsb3ciKTsKIAkJCXJldHVybiAtMTsKIAkJfQogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1GQVNUOiBSZWNlaXZlZCBQaGFzZSAyOiAiCi0JCQkgICAiVExWIHR5cGUgJWQgbGVuZ3RoICVkJXMiLAotCQkJICAgdGx2X3R5cGUsIGxlbiwgbWFuZGF0b3J5ID8gIiAobWFuZGF0b3J5KSIgOiAiIik7CisJCQkgICAiVExWIHR5cGUgJWQgbGVuZ3RoICV1JXMiLAorCQkJICAgdGx2X3R5cGUsICh1bnNpZ25lZCBpbnQpIGxlbiwKKwkJCSAgIG1hbmRhdG9yeSA/ICIgKG1hbmRhdG9yeSkiIDogIiIpOwogCiAJCXJlcyA9IGVhcF9mYXN0X3BhcnNlX3Rsdih0bHYsIHRsdl90eXBlLCBwb3MsIGxlbik7CiAJCWlmIChyZXMgPT0gLTIpCkBAIC0xMjQ0LDYgKzEyNTksNyBAQAogCQkJCSAgICJwcm92aXNpb25pbmcgY29tcGxldGVkIHN1Y2Nlc3NmdWxseS4iKTsKIAkJCXJldC0+bWV0aG9kU3RhdGUgPSBNRVRIT0RfRE9ORTsKIAkJCXJldC0+ZGVjaXNpb24gPSBERUNJU0lPTl9GQUlMOworCQkJc20tPmV4cGVjdGVkX2ZhaWx1cmUgPSAxOwogCQl9IGVsc2UgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtRkFTVDogQXV0aGVudGljYXRpb24gIgogCQkJCSAgICJjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5LiIpOwpAQCAtMTYyMiw2ICsxNjM4LDggQEAKIAkJb3NfZnJlZShkYXRhKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQorCW9zX21lbXNldChkYXRhLT5rZXlfZGF0YSwgMCwgRUFQX0ZBU1RfS0VZX0xFTik7CisJb3NfbWVtc2V0KGRhdGEtPmVtc2ssIDAsIEVBUF9FTVNLX0xFTik7CiAJb3NfZnJlZShkYXRhLT5zZXNzaW9uX2lkKTsKIAlkYXRhLT5zZXNzaW9uX2lkID0gTlVMTDsKIAlpZiAoZGF0YS0+cGhhc2UyX3ByaXYgJiYgZGF0YS0+cGhhc2UyX21ldGhvZCAmJgpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9mYXN0X3BhYy5jIGIvc3JjL2VhcF9wZWVyL2VhcF9mYXN0X3BhYy5jCmluZGV4IDhjNDgwYjkuLjIxZDYwOTggMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9lYXBfZmFzdF9wYWMuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX2Zhc3RfcGFjLmMKQEAgLTMzMCw2ICszMzAsOCBAQAogc3RhdGljIGNvbnN0IGNoYXIgKiBlYXBfZmFzdF9wYXJzZV9wYWNfdHlwZShzdHJ1Y3QgZWFwX2Zhc3RfcGFjICpwYWMsCiAJCQkJCSAgICBjaGFyICpwb3MpCiB7CisJaWYgKCFwb3MpCisJCXJldHVybiAiQ2Fubm90IHBhcnNlIHBhYyB0eXBlIjsKIAlwYWMtPnBhY190eXBlID0gYXRvaShwb3MpOwogCWlmIChwYWMtPnBhY190eXBlICE9IFBBQ19UWVBFX1RVTk5FTF9QQUMgJiYKIAkgICAgcGFjLT5wYWNfdHlwZSAhPSBQQUNfVFlQRV9VU0VSX0FVVEhPUklaQVRJT04gJiYKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfZ3Bzay5jIGIvc3JjL2VhcF9wZWVyL2VhcF9ncHNrLmMKaW5kZXggOGEwNjQ0ZC4uYzU0YmYxMSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9ncHNrLmMKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF9ncHNrLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogRUFQIHBlZXIgbWV0aG9kOiBFQVAtR1BTSyAoUkZDIDU0MzMpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAwOCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0zMyw2ICszMyw3IEBACiAJaW50IHNwZWNpZmllcjsgLyogQ1N1aXRlL1NwZWNpZmllciAqLwogCXU4ICpwc2s7CiAJc2l6ZV90IHBza19sZW47CisJdTE2IGZvcmNlZF9jaXBoZXI7IC8qIGZvcmNlIGNpcGhlciBvciAwIHRvIGFsbG93IGFsbCBzdXBwb3J0ZWQgKi8KIH07CiAKIApAQCAtODAsNiArODEsNyBAQAogCXN0cnVjdCBlYXBfZ3Bza19kYXRhICpkYXRhOwogCWNvbnN0IHU4ICppZGVudGl0eSwgKnBhc3N3b3JkOwogCXNpemVfdCBpZGVudGl0eV9sZW4sIHBhc3N3b3JkX2xlbjsKKwljb25zdCBjaGFyICpwaGFzZTE7CiAKIAlwYXNzd29yZCA9IGVhcF9nZXRfY29uZmlnX3Bhc3N3b3JkKHNtLCAmcGFzc3dvcmRfbGVuKTsKIAlpZiAocGFzc3dvcmQgPT0gTlVMTCkgewpAQCAtMTAzLDYgKzEwNSwxOCBAQAogCQlkYXRhLT5pZF9wZWVyX2xlbiA9IGlkZW50aXR5X2xlbjsKIAl9CiAKKwlwaGFzZTEgPSBlYXBfZ2V0X2NvbmZpZ19waGFzZTEoc20pOworCWlmIChwaGFzZTEpIHsKKwkJY29uc3QgY2hhciAqcG9zOworCisJCXBvcyA9IG9zX3N0cnN0cihwaGFzZTEsICJjaXBoZXI9Iik7CisJCWlmIChwb3MpIHsKKwkJCWRhdGEtPmZvcmNlZF9jaXBoZXIgPSBhdG9pKHBvcyArIDcpOworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtR1BTSzogRm9yY2VkIGNpcGhlciAldSIsCisJCQkJICAgZGF0YS0+Zm9yY2VkX2NpcGhlcik7CisJCX0KKwl9CisKIAlkYXRhLT5wc2sgPSBvc19tYWxsb2MocGFzc3dvcmRfbGVuKTsKIAlpZiAoZGF0YS0+cHNrID09IE5VTEwpIHsKIAkJZWFwX2dwc2tfZGVpbml0KHNtLCBkYXRhKTsKQEAgLTEyMCw4ICsxMzQsMTEgQEAKIAlzdHJ1Y3QgZWFwX2dwc2tfZGF0YSAqZGF0YSA9IHByaXY7CiAJb3NfZnJlZShkYXRhLT5pZF9zZXJ2ZXIpOwogCW9zX2ZyZWUoZGF0YS0+aWRfcGVlcik7Ci0Jb3NfZnJlZShkYXRhLT5wc2spOwotCW9zX2ZyZWUoZGF0YSk7CisJaWYgKGRhdGEtPnBzaykgeworCQlvc19tZW1zZXQoZGF0YS0+cHNrLCAwLCBkYXRhLT5wc2tfbGVuKTsKKwkJb3NfZnJlZShkYXRhLT5wc2spOworCX0KKwliaW5fY2xlYXJfZnJlZShkYXRhLCBzaXplb2YoKmRhdGEpKTsKIH0KIAogCkBAIC0xOTUsNyArMjEyLDkgQEAKIAkJCSAgIGksIHZlbmRvciwgc3BlY2lmaWVyKTsKIAkJaWYgKGRhdGEtPnZlbmRvciA9PSBFQVBfR1BTS19WRU5ET1JfSUVURiAmJgogCQkgICAgZGF0YS0+c3BlY2lmaWVyID09IEVBUF9HUFNLX0NJUEhFUl9SRVNFUlZFRCAmJgotCQkgICAgZWFwX2dwc2tfc3VwcG9ydGVkX2NpcGhlcnN1aXRlKHZlbmRvciwgc3BlY2lmaWVyKSkgeworCQkgICAgZWFwX2dwc2tfc3VwcG9ydGVkX2NpcGhlcnN1aXRlKHZlbmRvciwgc3BlY2lmaWVyKSAmJgorCQkgICAgKCFkYXRhLT5mb3JjZWRfY2lwaGVyIHx8IGRhdGEtPmZvcmNlZF9jaXBoZXIgPT0gc3BlY2lmaWVyKSkKKwkJewogCQkJZGF0YS0+dmVuZG9yID0gdmVuZG9yOwogCQkJZGF0YS0+c3BlY2lmaWVyID0gc3BlY2lmaWVyOwogCQl9CkBAIC0yMjAsNiArMjM5LDggQEAKIAkJCQkJICAgICAgIHNpemVfdCAqbGlzdF9sZW4sCiAJCQkJCSAgICAgICBjb25zdCB1OCAqcG9zLCBjb25zdCB1OCAqZW5kKQogeworCXNpemVfdCBsZW47CisKIAlpZiAocG9zID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwogCkBAIC0yMjcsMjMgKzI0OCwyNSBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1HUFNLOiBUb28gc2hvcnQgR1BTSy0xIHBhY2tldCIpOwogCQlyZXR1cm4gTlVMTDsKIAl9Ci0JKmxpc3RfbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CisJbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CiAJcG9zICs9IDI7Ci0JaWYgKGVuZCAtIHBvcyA8IChpbnQpICpsaXN0X2xlbikgeworCWlmIChsZW4gPiAoc2l6ZV90KSAoZW5kIC0gcG9zKSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1HUFNLOiBDU3VpdGVfTGlzdCBvdmVyZmxvdyIpOwogCQlyZXR1cm4gTlVMTDsKIAl9Ci0JaWYgKCpsaXN0X2xlbiA9PSAwIHx8ICgqbGlzdF9sZW4gJSBzaXplb2Yoc3RydWN0IGVhcF9ncHNrX2NzdWl0ZSkpKSB7CisJaWYgKGxlbiA9PSAwIHx8IChsZW4gJSBzaXplb2Yoc3RydWN0IGVhcF9ncHNrX2NzdWl0ZSkpKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IEludmFsaWQgQ1N1aXRlX0xpc3QgbGVuICVsdSIsCi0JCQkgICAodW5zaWduZWQgbG9uZykgKmxpc3RfbGVuKTsKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBsZW4pOwogCQlyZXR1cm4gTlVMTDsKIAl9Ci0JKmxpc3QgPSBwb3M7Ci0JcG9zICs9ICpsaXN0X2xlbjsKIAotCWlmIChlYXBfZ3Bza19zZWxlY3RfY3N1aXRlKHNtLCBkYXRhLCAqbGlzdCwgKmxpc3RfbGVuKSA8IDApCisJaWYgKGVhcF9ncHNrX3NlbGVjdF9jc3VpdGUoc20sIGRhdGEsIHBvcywgbGVuKSA8IDApCiAJCXJldHVybiBOVUxMOwogCisJKmxpc3QgPSBwb3M7CisJKmxpc3RfbGVuID0gbGVuOworCXBvcyArPSBsZW47CisKIAlyZXR1cm4gcG9zOwogfQogCkBAIC0yNzMsNiArMjk2LDcgQEAKIAlwb3MgPSBlYXBfZ3Bza19wcm9jZXNzX2NzdWl0ZV9saXN0KHNtLCBkYXRhLCAmY3N1aXRlX2xpc3QsCiAJCQkJCSAgICZjc3VpdGVfbGlzdF9sZW4sIHBvcywgZW5kKTsKIAlpZiAocG9zID09IE5VTEwpIHsKKwkJcmV0LT5tZXRob2RTdGF0ZSA9IE1FVEhPRF9ET05FOwogCQllYXBfZ3Bza19zdGF0ZShkYXRhLCBGQUlMVVJFKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtNTQ0LDcgKzU2OCw3IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IEZhaWxlZCB0byBjb21wdXRlIE1JQyIpOwogCQlyZXR1cm4gTlVMTDsKIAl9Ci0JaWYgKG9zX21lbWNtcChtaWMsIHBvcywgbWljbGVuKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChtaWMsIHBvcywgbWljbGVuKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtR1BTSzogSW5jb3JyZWN0IE1JQyBpbiBHUFNLLTMiKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IFJlY2VpdmVkIE1JQyIsIHBvcywgbWljbGVuKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IENvbXB1dGVkIE1JQyIsIG1pYywgbWljbGVuKTsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfaS5oIGIvc3JjL2VhcF9wZWVyL2VhcF9pLmgKaW5kZXggNjJjODY3Yy4uZmRlODA5YyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9pLmgKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF9pLmgKQEAgLTM0NSw5ICszNDUsMTQgQEAKIAlzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwczsKIAogCWludCBwcmV2X2ZhaWx1cmU7CisJc3RydWN0IGVhcF9wZWVyX2NvbmZpZyAqbGFzdF9jb25maWc7CiAKIAlzdHJ1Y3QgZXh0X3Bhc3N3b3JkX2RhdGEgKmV4dF9wdzsKIAlzdHJ1Y3Qgd3BhYnVmICpleHRfcHdfYnVmOworCisJaW50IGV4dGVybmFsX3NpbTsKKworCXVuc2lnbmVkIGludCBleHBlY3RlZF9mYWlsdXJlOjE7CiB9OwogCiBjb25zdCB1OCAqIGVhcF9nZXRfY29uZmlnX2lkZW50aXR5KHN0cnVjdCBlYXBfc20gKnNtLCBzaXplX3QgKmxlbik7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX2lrZXYyLmMgYi9zcmMvZWFwX3BlZXIvZWFwX2lrZXYyLmMKaW5kZXggMDlhNjU1ZS4uYzEyYjUxOSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9pa2V2Mi5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfaWtldjIuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBFQVAtSUtFdjIgcGVlciAoUkZDIDUxMDYpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDctMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNjAsNiArNjAsNyBAQAogCXN0cnVjdCBlYXBfaWtldjJfZGF0YSAqZGF0YTsKIAljb25zdCB1OCAqaWRlbnRpdHksICpwYXNzd29yZDsKIAlzaXplX3QgaWRlbnRpdHlfbGVuLCBwYXNzd29yZF9sZW47CisJaW50IGZyYWdtZW50X3NpemU7CiAKIAlpZGVudGl0eSA9IGVhcF9nZXRfY29uZmlnX2lkZW50aXR5KHNtLCAmaWRlbnRpdHlfbGVuKTsKIAlpZiAoaWRlbnRpdHkgPT0gTlVMTCkgewpAQCAtNzEsNyArNzIsMTEgQEAKIAlpZiAoZGF0YSA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAlkYXRhLT5zdGF0ZSA9IFdBSVRfU1RBUlQ7Ci0JZGF0YS0+ZnJhZ21lbnRfc2l6ZSA9IElLRVYyX0ZSQUdNRU5UX1NJWkU7CisJZnJhZ21lbnRfc2l6ZSA9IGVhcF9nZXRfY29uZmlnX2ZyYWdtZW50X3NpemUoc20pOworCWlmIChmcmFnbWVudF9zaXplIDw9IDApCisJCWRhdGEtPmZyYWdtZW50X3NpemUgPSBJS0VWMl9GUkFHTUVOVF9TSVpFOworCWVsc2UKKwkJZGF0YS0+ZnJhZ21lbnRfc2l6ZSA9IGZyYWdtZW50X3NpemU7CiAJZGF0YS0+aWtldjIuc3RhdGUgPSBTQV9JTklUOwogCWRhdGEtPmlrZXYyLnBlZXJfYXV0aCA9IFBFRVJfQVVUSF9TRUNSRVQ7CiAJZGF0YS0+aWtldjIua2V5X3BhZCA9ICh1OCAqKSBvc19zdHJkdXAoIktleSBQYWQgZm9yIEVBUC1JS0V2MiIpOwpAQCAtMTA4LDcgKzExMyw3IEBACiAJd3BhYnVmX2ZyZWUoZGF0YS0+aW5fYnVmKTsKIAl3cGFidWZfZnJlZShkYXRhLT5vdXRfYnVmKTsKIAlpa2V2Ml9yZXNwb25kZXJfZGVpbml0KCZkYXRhLT5pa2V2Mik7Ci0Jb3NfZnJlZShkYXRhKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLCBzaXplb2YoKmRhdGEpKTsKIH0KIAogCkBAIC0xNDksMTIgKzE1NCw2IEBACiAJCQlzZW5kX2xlbiAtPSA0OwogCQl9CiAJfQotI2lmZGVmIENDTlNfUEwKLQkvKiBTb21lIGlzc3VlcyBmaWd1cmluZyBvdXQgdGhlIGxlbmd0aCBvZiB0aGUgbWVzc2FnZSBpZiBNZXNzYWdlIExlbmd0aAotCSAqIGZpZWxkIG5vdCBpbmNsdWRlZD8hICovCi0JaWYgKCEoZmxhZ3MgJiBJS0VWMl9GTEFHU19MRU5HVEhfSU5DTFVERUQpKQotCQlmbGFncyB8PSBJS0VWMl9GTEFHU19MRU5HVEhfSU5DTFVERUQ7Ci0jZW5kaWYgLyogQ0NOU19QTCAqLwogCiAJcGxlbiA9IDEgKyBzZW5kX2xlbjsKIAlpZiAoZmxhZ3MgJiBJS0VWMl9GTEFHU19MRU5HVEhfSU5DTFVERUQpCkBAIC0yNDYsNyArMjQ1LDggQEAKIAogc3RhdGljIGludCBlYXBfaWtldjJfcHJvY2Vzc19pY3Yoc3RydWN0IGVhcF9pa2V2Ml9kYXRhICpkYXRhLAogCQkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpyZXFEYXRhLAotCQkJCSB1OCBmbGFncywgY29uc3QgdTggKnBvcywgY29uc3QgdTggKiplbmQpCisJCQkJIHU4IGZsYWdzLCBjb25zdCB1OCAqcG9zLCBjb25zdCB1OCAqKmVuZCwKKwkJCQkgaW50IGZyYWdfYWNrKQogewogCWlmIChmbGFncyAmIElLRVYyX0ZMQUdTX0lDVl9JTkNMVURFRCkgewogCQlpbnQgaWN2X2xlbiA9IGVhcF9pa2V2Ml92YWxpZGF0ZV9pY3YoCkBAIC0yNTYsNyArMjU2LDcgQEAKIAkJCXJldHVybiAtMTsKIAkJLyogSGlkZSBJbnRlZ3JpdHkgQ2hlY2tzdW0gRGF0YSBmcm9tIGZ1cnRoZXIgcHJvY2Vzc2luZyAqLwogCQkqZW5kIC09IGljdl9sZW47Ci0JfSBlbHNlIGlmIChkYXRhLT5rZXlzX3JlYWR5KSB7CisJfSBlbHNlIGlmIChkYXRhLT5rZXlzX3JlYWR5ICYmICFmcmFnX2FjaykgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLUlLRVYyOiBUaGUgbWVzc2FnZSBzaG91bGQgaGF2ZSAiCiAJCQkgICAiaW5jbHVkZWQgaW50ZWdyaXR5IGNoZWNrc3VtIik7CiAJCXJldHVybiAtMTsKQEAgLTM0Niw3ICszNDYsOSBAQAogCWVsc2UKIAkJZmxhZ3MgPSAqcG9zKys7CiAKLQlpZiAoZWFwX2lrZXYyX3Byb2Nlc3NfaWN2KGRhdGEsIHJlcURhdGEsIGZsYWdzLCBwb3MsICZlbmQpIDwgMCkgeworCWlmIChlYXBfaWtldjJfcHJvY2Vzc19pY3YoZGF0YSwgcmVxRGF0YSwgZmxhZ3MsIHBvcywgJmVuZCwKKwkJCQkgIGRhdGEtPnN0YXRlID09IFdBSVRfRlJBR19BQ0sgJiYgbGVuID09IDApIDwgMCkKKwl7CiAJCXJldC0+aWdub3JlID0gVFJVRTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtMzczLDEyICszNzUsNyBAQAogCQkgICAiTWVzc2FnZSBMZW5ndGggJXUiLCBmbGFncywgbWVzc2FnZV9sZW5ndGgpOwogCiAJaWYgKGRhdGEtPnN0YXRlID09IFdBSVRfRlJBR19BQ0spIHsKLSNpZmRlZiBDQ05TX1BMCi0JCWlmIChsZW4gPiAxKSAvKiBFbXB0eSBGbGFncyBmaWVsZCBpbmNsdWRlZCBpbiBBQ0sgKi8KLSNlbHNlIC8qIENDTlNfUEwgKi8KLQkJaWYgKGxlbiAhPSAwKQotI2VuZGlmIC8qIENDTlNfUEwgKi8KLQkJeworCQlpZiAobGVuICE9IDApIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUlLRVYyOiBVbmV4cGVjdGVkIHBheWxvYWQgIgogCQkJCSAgICJpbiBXQUlUX0ZSQUdfQUNLIHN0YXRlIik7CiAJCQlyZXQtPmlnbm9yZSA9IFRSVUU7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX2xlYXAuYyBiL3NyYy9lYXBfcGVlci9lYXBfbGVhcC5jCmluZGV4IGRmMzQwMTMuLmUwZjhiY2YgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9lYXBfbGVhcC5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfbGVhcC5jCkBAIC0yNDQsNyArMjQ0LDcgQEAKIAlyZXQtPm1ldGhvZFN0YXRlID0gTUVUSE9EX0RPTkU7CiAJcmV0LT5hbGxvd05vdGlmaWNhdGlvbnMgPSBGQUxTRTsKIAotCWlmIChvc19tZW1jbXAocG9zLCBleHBlY3RlZCwgTEVBUF9SRVNQT05TRV9MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KHBvcywgZXhwZWN0ZWQsIExFQVBfUkVTUE9OU0VfTEVOKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJFQVAtTEVBUDogQVAgc2VudCBhbiBpbnZhbGlkICIKIAkJCSAgICJyZXNwb25zZSAtIGF1dGhlbnRpY2F0aW9uIGZhaWxlZCIpOwogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAtTEVBUDogRXhwZWN0ZWQgcmVzcG9uc2UgZnJvbSBBUCIsCkBAIC0zODMsNiArMzgzLDkgQEAKIAl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiRUFQLUxFQVA6IG1hc3RlciBrZXkiLCBrZXksIExFQVBfS0VZX0xFTik7CiAJKmxlbiA9IExFQVBfS0VZX0xFTjsKIAorCW9zX21lbXNldChwd19oYXNoLCAwLCBzaXplb2YocHdfaGFzaCkpOworCW9zX21lbXNldChwd19oYXNoX2hhc2gsIDAsIHNpemVvZihwd19oYXNoX2hhc2gpKTsKKwogCXJldHVybiBrZXk7CiB9CiAKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfbWV0aG9kcy5oIGIvc3JjL2VhcF9wZWVyL2VhcF9tZXRob2RzLmgKaW5kZXggYTQ2NWZkMi4uZTM1YzkxOSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9tZXRob2RzLmgKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF9tZXRob2RzLmgKQEAgLTg2LDYgKzg2LDcgQEAKIGludCBlYXBfcGVlcl9tZDVfcmVnaXN0ZXIodm9pZCk7CiBpbnQgZWFwX3BlZXJfdGxzX3JlZ2lzdGVyKHZvaWQpOwogaW50IGVhcF9wZWVyX3VuYXV0aF90bHNfcmVnaXN0ZXIodm9pZCk7CitpbnQgZWFwX3BlZXJfd2ZhX3VuYXV0aF90bHNfcmVnaXN0ZXIodm9pZCk7CiBpbnQgZWFwX3BlZXJfbXNjaGFwdjJfcmVnaXN0ZXIodm9pZCk7CiBpbnQgZWFwX3BlZXJfcGVhcF9yZWdpc3Rlcih2b2lkKTsKIGludCBlYXBfcGVlcl90dGxzX3JlZ2lzdGVyKHZvaWQpOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9tc2NoYXB2Mi5jIGIvc3JjL2VhcF9wZWVyL2VhcF9tc2NoYXB2Mi5jCmluZGV4IGY5YWE3NDIuLjQzMGM1MDEgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9lYXBfbXNjaGFwdjIuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX21zY2hhcHYyLmMKQEAgLTE0MCw3ICsxNDAsNyBAQAogCW9zX2ZyZWUoZGF0YS0+cGVlcl9jaGFsbGVuZ2UpOwogCW9zX2ZyZWUoZGF0YS0+YXV0aF9jaGFsbGVuZ2UpOwogCXdwYWJ1Zl9mcmVlKGRhdGEtPnByZXZfY2hhbGxlbmdlKTsKLQlvc19mcmVlKGRhdGEpOworCWJpbl9jbGVhcl9mcmVlKGRhdGEsIHNpemVvZigqZGF0YSkpOwogfQogCiAKQEAgLTMwMywxOCArMzAzLDIzIEBACiAJCQlXUEFfRVZFTlRfUEFTU1dPUkRfQ0hBTkdFRAogCQkJIkVBUC1NU0NIQVBWMjogUGFzc3dvcmQgY2hhbmdlZCBzdWNjZXNzZnVsbHkiKTsKIAkJZGF0YS0+cHJldl9lcnJvciA9IDA7Ci0JCW9zX2ZyZWUoY29uZmlnLT5wYXNzd29yZCk7CisJCWJpbl9jbGVhcl9mcmVlKGNvbmZpZy0+cGFzc3dvcmQsIGNvbmZpZy0+cGFzc3dvcmRfbGVuKTsKIAkJaWYgKGNvbmZpZy0+ZmxhZ3MgJiBFQVBfQ09ORklHX0ZMQUdTX0VYVF9QQVNTV09SRCkgewogCQkJLyogVE9ETzogdXBkYXRlIGV4dGVybmFsIHN0b3JhZ2UgKi8KIAkJfSBlbHNlIGlmIChjb25maWctPmZsYWdzICYgRUFQX0NPTkZJR19GTEFHU19QQVNTV09SRF9OVEhBU0gpIHsKIAkJCWNvbmZpZy0+cGFzc3dvcmQgPSBvc19tYWxsb2MoMTYpOwogCQkJY29uZmlnLT5wYXNzd29yZF9sZW4gPSAxNjsKLQkJCWlmIChjb25maWctPnBhc3N3b3JkKSB7Ci0JCQkJbnRfcGFzc3dvcmRfaGFzaChjb25maWctPm5ld19wYXNzd29yZCwKLQkJCQkJCSBjb25maWctPm5ld19wYXNzd29yZF9sZW4sCi0JCQkJCQkgY29uZmlnLT5wYXNzd29yZCk7CisJCQlpZiAoY29uZmlnLT5wYXNzd29yZCAmJgorCQkJICAgIG50X3Bhc3N3b3JkX2hhc2goY29uZmlnLT5uZXdfcGFzc3dvcmQsCisJCQkJCSAgICAgY29uZmlnLT5uZXdfcGFzc3dvcmRfbGVuLAorCQkJCQkgICAgIGNvbmZpZy0+cGFzc3dvcmQpKSB7CisJCQkJYmluX2NsZWFyX2ZyZWUoY29uZmlnLT5wYXNzd29yZCwKKwkJCQkJICAgICAgIGNvbmZpZy0+cGFzc3dvcmRfbGVuKTsKKwkJCQljb25maWctPnBhc3N3b3JkID0gTlVMTDsKKwkJCQljb25maWctPnBhc3N3b3JkX2xlbiA9IDA7CiAJCQl9Ci0JCQlvc19mcmVlKGNvbmZpZy0+bmV3X3Bhc3N3b3JkKTsKKwkJCWJpbl9jbGVhcl9mcmVlKGNvbmZpZy0+bmV3X3Bhc3N3b3JkLAorCQkJCSAgICAgICBjb25maWctPm5ld19wYXNzd29yZF9sZW4pOwogCQl9IGVsc2UgewogCQkJY29uZmlnLT5wYXNzd29yZCA9IGNvbmZpZy0+bmV3X3Bhc3N3b3JkOwogCQkJY29uZmlnLT5wYXNzd29yZF9sZW4gPSBjb25maWctPm5ld19wYXNzd29yZF9sZW47CkBAIC01NDksMTUgKzU1NCwxNyBAQAogCS8qIEVuY3J5cHRlZC1IYXNoICovCiAJaWYgKHB3aGFzaCkgewogCQl1OCBuZXdfcGFzc3dvcmRfaGFzaFsxNl07Ci0JCW50X3Bhc3N3b3JkX2hhc2gobmV3X3Bhc3N3b3JkLCBuZXdfcGFzc3dvcmRfbGVuLAotCQkJCSBuZXdfcGFzc3dvcmRfaGFzaCk7CisJCWlmIChudF9wYXNzd29yZF9oYXNoKG5ld19wYXNzd29yZCwgbmV3X3Bhc3N3b3JkX2xlbiwKKwkJCQkgICAgIG5ld19wYXNzd29yZF9oYXNoKSkKKwkJCWdvdG8gZmFpbDsKIAkJbnRfcGFzc3dvcmRfaGFzaF9lbmNyeXB0ZWRfd2l0aF9ibG9jayhwYXNzd29yZCwKIAkJCQkJCSAgICAgIG5ld19wYXNzd29yZF9oYXNoLAogCQkJCQkJICAgICAgY3AtPmVuY3JfaGFzaCk7CiAJfSBlbHNlIHsKLQkJb2xkX250X3Bhc3N3b3JkX2hhc2hfZW5jcnlwdGVkX3dpdGhfbmV3X250X3Bhc3N3b3JkX2hhc2goCi0JCQluZXdfcGFzc3dvcmQsIG5ld19wYXNzd29yZF9sZW4sCi0JCQlwYXNzd29yZCwgcGFzc3dvcmRfbGVuLCBjcC0+ZW5jcl9oYXNoKTsKKwkJaWYgKG9sZF9udF9wYXNzd29yZF9oYXNoX2VuY3J5cHRlZF93aXRoX25ld19udF9wYXNzd29yZF9oYXNoKAorCQkJICAgIG5ld19wYXNzd29yZCwgbmV3X3Bhc3N3b3JkX2xlbiwKKwkJCSAgICBwYXNzd29yZCwgcGFzc3dvcmRfbGVuLCBjcC0+ZW5jcl9oYXNoKSkKKwkJCWdvdG8gZmFpbDsKIAl9CiAKIAkvKiBQZWVyLUNoYWxsZW5nZSAqLwpAQCAtNTk0LDkgKzYwMSwxMyBAQAogCiAJLyogTGlrZXdpc2UsIGdlbmVyYXRlIG1hc3Rlcl9rZXkgaGVyZSBzaW5jZSB3ZSBoYXZlIHRoZSBuZWVkZWQgZGF0YQogCSAqIGF2YWlsYWJsZS4gKi8KLQludF9wYXNzd29yZF9oYXNoKG5ld19wYXNzd29yZCwgbmV3X3Bhc3N3b3JkX2xlbiwgcGFzc3dvcmRfaGFzaCk7Ci0JaGFzaF9udF9wYXNzd29yZF9oYXNoKHBhc3N3b3JkX2hhc2gsIHBhc3N3b3JkX2hhc2hfaGFzaCk7Ci0JZ2V0X21hc3Rlcl9rZXkocGFzc3dvcmRfaGFzaF9oYXNoLCBjcC0+bnRfcmVzcG9uc2UsIGRhdGEtPm1hc3Rlcl9rZXkpOworCWlmIChudF9wYXNzd29yZF9oYXNoKG5ld19wYXNzd29yZCwgbmV3X3Bhc3N3b3JkX2xlbiwgcGFzc3dvcmRfaGFzaCkgfHwKKwkgICAgaGFzaF9udF9wYXNzd29yZF9oYXNoKHBhc3N3b3JkX2hhc2gsIHBhc3N3b3JkX2hhc2hfaGFzaCkgfHwKKwkgICAgZ2V0X21hc3Rlcl9rZXkocGFzc3dvcmRfaGFzaF9oYXNoLCBjcC0+bnRfcmVzcG9uc2UsCisJCQkgICBkYXRhLT5tYXN0ZXJfa2V5KSkgeworCQlkYXRhLT5hdXRoX3Jlc3BvbnNlX3ZhbGlkID0gMDsKKwkJZ290byBmYWlsOworCX0KIAlkYXRhLT5tYXN0ZXJfa2V5X3ZhbGlkID0gMTsKIAogCS8qIEZsYWdzICovCmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3BheC5jIGIvc3JjL2VhcF9wZWVyL2VhcF9wYXguYwppbmRleCA3Zjg3MDUyLi4xYzExMWMyIDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3BheC5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfcGF4LmMKQEAgLTg2LDcgKzg2LDcgQEAKIHsKIAlzdHJ1Y3QgZWFwX3BheF9kYXRhICpkYXRhID0gcHJpdjsKIAlvc19mcmVlKGRhdGEtPmNpZCk7Ci0Jb3NfZnJlZShkYXRhKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLCBzaXplb2YoKmRhdGEpKTsKIH0KIAogCkBAIC0yNzgsNyArMjc4LDcgQEAKIAllYXBfcGF4X21hYyhkYXRhLT5tYWNfaWQsIGRhdGEtPmNrLCBFQVBfUEFYX0NLX0xFTiwKIAkJICAgIGRhdGEtPnJhbmQuci55LCBFQVBfUEFYX1JBTkRfTEVOLAogCQkgICAgKHU4ICopIGRhdGEtPmNpZCwgZGF0YS0+Y2lkX2xlbiwgTlVMTCwgMCwgbWFjKTsKLQlpZiAob3NfbWVtY21wKHBvcywgbWFjLCBFQVBfUEFYX01BQ19MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KHBvcywgbWFjLCBFQVBfUEFYX01BQ19MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QQVg6IEludmFsaWQgTUFDX0NLKEIsIENJRCkgIgogCQkJICAgInJlY2VpdmVkIik7CiAJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiRUFQLVBBWDogZXhwZWN0ZWQgTUFDX0NLKEIsIENJRCkiLApAQCAtNDE1LDcgKzQxNSw3IEBACiAJCQkgICAgd3BhYnVmX2hlYWQocmVxRGF0YSksIG1sZW4sIE5VTEwsIDAsIE5VTEwsIDAsCiAJCQkgICAgaWN2YnVmKTsKIAl9Ci0JaWYgKG9zX21lbWNtcChpY3YsIGljdmJ1ZiwgRUFQX1BBWF9JQ1ZfTEVOKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChpY3YsIGljdmJ1ZiwgRUFQX1BBWF9JQ1ZfTEVOKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVBBWDogaW52YWxpZCBJQ1YgLSBpZ25vcmluZyB0aGUgIgogCQkJICAgIm1lc3NhZ2UiKTsKIAkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJFQVAtUEFYOiBleHBlY3RlZCBJQ1YiLApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9wZWFwLmMgYi9zcmMvZWFwX3BlZXIvZWFwX3BlYXAuYwppbmRleCAzYjkzMjA5Li40NzJlODYxIDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3BlYXAuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX3BlYXAuYwpAQCAtMjIsNyArMjIsNiBAQAogLyogTWF4aW11bSBzdXBwb3J0ZWQgUEVBUCB2ZXJzaW9uCiAgKiAwID0gTWljcm9zb2Z0J3MgUEVBUCB2ZXJzaW9uIDA7IGRyYWZ0LWthbWF0aC1wcHBleHQtcGVhcHYwLTAwLnR4dAogICogMSA9IGRyYWZ0LWpvc2Vmc3Nvbi1wcGV4dC1lYXAtdGxzLWVhcC0wNS50eHQKLSAqIDIgPSBkcmFmdC1qb3NlZnNzb24tcHBleHQtZWFwLXRscy1lYXAtMTAudHh0CiAgKi8KICNkZWZpbmUgRUFQX1BFQVBfVkVSU0lPTiAxCiAKQEAgLTE3MSw2ICsxNzAsMTUgQEAKIH0KIAogCitzdGF0aWMgdm9pZCBlYXBfcGVhcF9mcmVlX2tleShzdHJ1Y3QgZWFwX3BlYXBfZGF0YSAqZGF0YSkKK3sKKwlpZiAoZGF0YS0+a2V5X2RhdGEpIHsKKwkJYmluX2NsZWFyX2ZyZWUoZGF0YS0+a2V5X2RhdGEsIEVBUF9UTFNfS0VZX0xFTik7CisJCWRhdGEtPmtleV9kYXRhID0gTlVMTDsKKwl9Cit9CisKKwogc3RhdGljIHZvaWQgZWFwX3BlYXBfZGVpbml0KHN0cnVjdCBlYXBfc20gKnNtLCB2b2lkICpwcml2KQogewogCXN0cnVjdCBlYXBfcGVhcF9kYXRhICpkYXRhID0gcHJpdjsKQEAgLTE4MCw3ICsxODgsNyBAQAogCQlkYXRhLT5waGFzZTJfbWV0aG9kLT5kZWluaXQoc20sIGRhdGEtPnBoYXNlMl9wcml2KTsKIAlvc19mcmVlKGRhdGEtPnBoYXNlMl90eXBlcyk7CiAJZWFwX3BlZXJfdGxzX3NzbF9kZWluaXQoc20sICZkYXRhLT5zc2wpOwotCW9zX2ZyZWUoZGF0YS0+a2V5X2RhdGEpOworCWVhcF9wZWFwX2ZyZWVfa2V5KGRhdGEpOwogCW9zX2ZyZWUoZGF0YS0+c2Vzc2lvbl9pZCk7CiAJd3BhYnVmX2ZyZWUoZGF0YS0+cGVuZGluZ19waGFzZTJfcmVxKTsKIAlvc19mcmVlKGRhdGEpOwpAQCAtMzE1LDggKzMyMyw2IEBACiAJbGVuWzFdID0gMTsKIAogCXRsdl90eXBlID0gRUFQX1RMVl9DUllQVE9fQklORElOR19UTFY7Ci0JaWYgKGRhdGEtPnBlYXBfdmVyc2lvbiA+PSAyKQotCQl0bHZfdHlwZSB8PSBFQVBfVExWX1RZUEVfTUFOREFUT1JZOwogCXdwYWJ1Zl9wdXRfYmUxNihidWYsIHRsdl90eXBlKTsKIAl3cGFidWZfcHV0X2JlMTYoYnVmLCA1Nik7CiAKQEAgLTQyNiw3ICs0MzIsNyBAQAogCQkgICAgYnVmLCBzaXplb2YoYnVmKSk7CiAJaG1hY19zaGExKGRhdGEtPmNtaywgMjAsIGJ1Ziwgc2l6ZW9mKGJ1ZiksIG1hYyk7CiAKLQlpZiAob3NfbWVtY21wKG1hYywgcG9zLCBTSEExX01BQ19MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KG1hYywgcG9zLCBTSEExX01BQ19MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtUEVBUDogSW52YWxpZCBDb21wb3VuZF9NQUMgaW4gIgogCQkJICAgImNyeXB0b2JpbmRpbmcgVExWIik7CiAJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkVBUC1QRUFQOiBSZWNlaXZlZCBNQUMiLApAQCAtNTgwLDMzICs1ODYsNiBAQAogfQogCiAKLXN0YXRpYyBzdHJ1Y3Qgd3BhYnVmICogZWFwX3BlYXB2Ml90bHZfZWFwX3BheWxvYWQoc3RydWN0IHdwYWJ1ZiAqYnVmKQotewotCXN0cnVjdCB3cGFidWYgKmU7Ci0Jc3RydWN0IGVhcF90bHZfaGRyICp0bHY7Ci0KLQlpZiAoYnVmID09IE5VTEwpCi0JCXJldHVybiBOVUxMOwotCi0JLyogRW5jYXBzdWxhdGUgRUFQIHBhY2tldCBpbiBFQVAtUGF5bG9hZCBUTFYgKi8KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1QRUFQdjI6IEFkZCBFQVAtUGF5bG9hZCBUTFYiKTsKLQllID0gd3BhYnVmX2FsbG9jKHNpemVvZigqdGx2KSArIHdwYWJ1Zl9sZW4oYnVmKSk7Ci0JaWYgKGUgPT0gTlVMTCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1QRUFQdjI6IEZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgIgotCQkJICAgImZvciBUTFYgZW5jYXBzdWxhdGlvbiIpOwotCQl3cGFidWZfZnJlZShidWYpOwotCQlyZXR1cm4gTlVMTDsKLQl9Ci0JdGx2ID0gd3BhYnVmX3B1dChlLCBzaXplb2YoKnRsdikpOwotCXRsdi0+dGx2X3R5cGUgPSBob3N0X3RvX2JlMTYoRUFQX1RMVl9UWVBFX01BTkRBVE9SWSB8Ci0JCQkJICAgICBFQVBfVExWX0VBUF9QQVlMT0FEX1RMVik7Ci0JdGx2LT5sZW5ndGggPSBob3N0X3RvX2JlMTYod3BhYnVmX2xlbihidWYpKTsKLQl3cGFidWZfcHV0X2J1ZihlLCBidWYpOwotCXdwYWJ1Zl9mcmVlKGJ1Zik7Ci0JcmV0dXJuIGU7Ci19Ci0KLQogc3RhdGljIGludCBlYXBfcGVhcF9waGFzZTJfcmVxdWVzdChzdHJ1Y3QgZWFwX3NtICpzbSwKIAkJCQkgICBzdHJ1Y3QgZWFwX3BlYXBfZGF0YSAqZGF0YSwKIAkJCQkgICBzdHJ1Y3QgZWFwX21ldGhvZF9yZXQgKnJldCwKQEAgLTgzNyw0OSArODE2LDYgQEAKIAkJaW5fZGVjcnlwdGVkID0gbm1zZzsKIAl9CiAKLQlpZiAoZGF0YS0+cGVhcF92ZXJzaW9uID49IDIpIHsKLQkJc3RydWN0IGVhcF90bHZfaGRyICp0bHY7Ci0JCXN0cnVjdCB3cGFidWYgKm5tc2c7Ci0KLQkJaWYgKHdwYWJ1Zl9sZW4oaW5fZGVjcnlwdGVkKSA8IHNpemVvZigqdGx2KSArIHNpemVvZigqaGRyKSkgewotCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QRUFQdjI6IFRvbyBzaG9ydCBQaGFzZSAyICIKLQkJCQkgICAiRUFQIFRMViIpOwotCQkJd3BhYnVmX2ZyZWUoaW5fZGVjcnlwdGVkKTsKLQkJCXJldHVybiAwOwotCQl9Ci0JCXRsdiA9IHdwYWJ1Zl9taGVhZChpbl9kZWNyeXB0ZWQpOwotCQlpZiAoKGJlX3RvX2hvc3QxNih0bHYtPnRsdl90eXBlKSAmIDB4M2ZmZikgIT0KLQkJICAgIEVBUF9UTFZfRUFQX1BBWUxPQURfVExWKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVBFQVB2MjogTm90IGFuIEVBUCBUTFYiKTsKLQkJCXdwYWJ1Zl9mcmVlKGluX2RlY3J5cHRlZCk7Ci0JCQlyZXR1cm4gMDsKLQkJfQotCQlpZiAoc2l6ZW9mKCp0bHYpICsgYmVfdG9faG9zdDE2KHRsdi0+bGVuZ3RoKSA+Ci0JCSAgICB3cGFidWZfbGVuKGluX2RlY3J5cHRlZCkpIHsKLQkJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUEVBUHYyOiBJbnZhbGlkIEVBUCBUTFYgIgotCQkJCSAgICJsZW5ndGgiKTsKLQkJCXdwYWJ1Zl9mcmVlKGluX2RlY3J5cHRlZCk7Ci0JCQlyZXR1cm4gMDsKLQkJfQotCQloZHIgPSAoc3RydWN0IGVhcF9oZHIgKikgKHRsdiArIDEpOwotCQlpZiAoYmVfdG9faG9zdDE2KGhkci0+bGVuZ3RoKSA+IGJlX3RvX2hvc3QxNih0bHYtPmxlbmd0aCkpIHsKLQkJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUEVBUHYyOiBObyByb29tIGZvciBmdWxsICIKLQkJCQkgICAiRUFQIHBhY2tldCBpbiBFQVAgVExWIik7Ci0JCQl3cGFidWZfZnJlZShpbl9kZWNyeXB0ZWQpOwotCQkJcmV0dXJuIDA7Ci0JCX0KLQotCQlubXNnID0gd3BhYnVmX2FsbG9jKGJlX3RvX2hvc3QxNihoZHItPmxlbmd0aCkpOwotCQlpZiAobm1zZyA9PSBOVUxMKSB7Ci0JCQl3cGFidWZfZnJlZShpbl9kZWNyeXB0ZWQpOwotCQkJcmV0dXJuIDA7Ci0JCX0KLQotCQl3cGFidWZfcHV0X2RhdGEobm1zZywgaGRyLCBiZV90b19ob3N0MTYoaGRyLT5sZW5ndGgpKTsKLQkJd3BhYnVmX2ZyZWUoaW5fZGVjcnlwdGVkKTsKLQkJaW5fZGVjcnlwdGVkID0gbm1zZzsKLQl9Ci0KIAloZHIgPSB3cGFidWZfbWhlYWQoaW5fZGVjcnlwdGVkKTsKIAlpZiAod3BhYnVmX2xlbihpbl9kZWNyeXB0ZWQpIDwgc2l6ZW9mKCpoZHIpKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUEVBUDogVG9vIHNob3J0IFBoYXNlIDIgIgpAQCAtOTk2LDExICs5MzIsNiBAQAogCQl3cGFfaGV4ZHVtcF9idWZfa2V5KE1TR19ERUJVRywKIAkJCQkgICAgIkVBUC1QRUFQOiBFbmNyeXB0aW5nIFBoYXNlIDIgZGF0YSIsIHJlc3ApOwogCQkvKiBQRUFQIHZlcnNpb24gY2hhbmdlcyAqLwotCQlpZiAoZGF0YS0+cGVhcF92ZXJzaW9uID49IDIpIHsKLQkJCXJlc3AgPSBlYXBfcGVhcHYyX3Rsdl9lYXBfcGF5bG9hZChyZXNwKTsKLQkJCWlmIChyZXNwID09IE5VTEwpCi0JCQkJcmV0dXJuIC0xOwotCQl9CiAJCWlmICh3cGFidWZfbGVuKHJlc3ApID49IDUgJiYKIAkJICAgIHdwYWJ1Zl9oZWFkX3U4KHJlc3ApWzBdID09IEVBUF9DT0RFX1JFU1BPTlNFICYmCiAJCSAgICBlYXBfZ2V0X3R5cGUocmVzcCkgPT0gRUFQX1RZUEVfVExWKQpAQCAtMTA4Myw3ICsxMDE0LDcgQEAKIAkJCWNoYXIgKmxhYmVsOwogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsCiAJCQkJICAgIkVBUC1QRUFQOiBUTFMgZG9uZSwgcHJvY2VlZCB0byBQaGFzZSAyIik7Ci0JCQlvc19mcmVlKGRhdGEtPmtleV9kYXRhKTsKKwkJCWVhcF9wZWFwX2ZyZWVfa2V5KGRhdGEpOwogCQkJLyogZHJhZnQtam9zZWZzc29uLXBwZXh0LWVhcC10bHMtZWFwLTA1LnR4dAogCQkJICogc3BlY2lmaWVzIHRoYXQgUEVBUHYxIHdvdWxkIHVzZSAiY2xpZW50IFBFQVAKIAkJCSAqIGVuY3J5cHRpb24iIGFzIHRoZSBsYWJlbC4gSG93ZXZlciwgbW9zdCBleGlzdGluZwpAQCAtMTA5MSw3ICsxMDIyLDcgQEAKIAkJCSAqIGxhYmVsLCAiY2xpZW50IEVBUCBlbmNyeXB0aW9uIiwgaW5zdGVhZC4gVXNlIHRoZSBvbGQKIAkJCSAqIGxhYmVsIGJ5IGRlZmF1bHQsIGJ1dCBhbGxvdyBpdCB0byBiZSBjb25maWd1cmVkIHdpdGgKIAkJCSAqIHBoYXNlMSBwYXJhbWV0ZXIgcGVhcGxhYmVsPTEuICovCi0JCQlpZiAoZGF0YS0+cGVhcF92ZXJzaW9uID4gMSB8fCBkYXRhLT5mb3JjZV9uZXdfbGFiZWwpCisJCQlpZiAoZGF0YS0+Zm9yY2VfbmV3X2xhYmVsKQogCQkJCWxhYmVsID0gImNsaWVudCBQRUFQIGVuY3J5cHRpb24iOwogCQkJZWxzZQogCQkJCWxhYmVsID0gImNsaWVudCBFQVAgZW5jcnlwdGlvbiI7CkBAIC0xMTkzLDggKzExMjQsNyBAQAogc3RhdGljIHZvaWQgKiBlYXBfcGVhcF9pbml0X2Zvcl9yZWF1dGgoc3RydWN0IGVhcF9zbSAqc20sIHZvaWQgKnByaXYpCiB7CiAJc3RydWN0IGVhcF9wZWFwX2RhdGEgKmRhdGEgPSBwcml2OwotCW9zX2ZyZWUoZGF0YS0+a2V5X2RhdGEpOwotCWRhdGEtPmtleV9kYXRhID0gTlVMTDsKKwllYXBfcGVhcF9mcmVlX2tleShkYXRhKTsKIAlvc19mcmVlKGRhdGEtPnNlc3Npb25faWQpOwogCWRhdGEtPnNlc3Npb25faWQgPSBOVUxMOwogCWlmIChlYXBfcGVlcl90bHNfcmVhdXRoX2luaXQoc20sICZkYXRhLT5zc2wpKSB7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3Byb3h5LmggYi9zcmMvZWFwX3BlZXIvZWFwX3Byb3h5LmgKaW5kZXggM2I0ZGNlZi4uMjNjZGJlNiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9wcm94eS5oCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfcHJveHkuaApAQCAtNDAsNyArNDAsOCBAQAogaW50IGVhcF9wcm94eV9zbV9nZXRfc3RhdHVzKHN0cnVjdCBlYXBfcHJveHlfc20gKnNtLCBjaGFyICpidWYsIHNpemVfdCBidWZsZW4sCiAJCQkgICAgaW50IHZlcmJvc2UpOwogCi1pbnQgZWFwX3Byb3h5X2dldF9pbXNpKGNoYXIgKmltc2lfYnVmLCBzaXplX3QgKmltc2lfbGVuKTsKK2ludCBlYXBfcHJveHlfZ2V0X2ltc2koc3RydWN0IGVhcF9wcm94eV9zbSAqZWFwX3Byb3h5LCBjaGFyICppbXNpX2J1ZiwKKwkJICAgICAgIHNpemVfdCAqaW1zaV9sZW4pOwogCiBpbnQgZWFwX3Byb3h5X25vdGlmeV9jb25maWcoc3RydWN0IGVhcF9wcm94eV9zbSAqc20sCiAJCQkgICAgc3RydWN0IGVhcF9wZWVyX2NvbmZpZyAqY29uZmlnKTsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfcHJveHlfZHVtbXkuYyBiL3NyYy9lYXBfcGVlci9lYXBfcHJveHlfZHVtbXkuYwppbmRleCBjZDk3ZmI2Li5kODRmMDEyIDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3Byb3h5X2R1bW15LmMKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF9wcm94eV9kdW1teS5jCkBAIC02Myw3ICs2Myw4IEBACiB9CiAKIAotaW50IGVhcF9wcm94eV9nZXRfaW1zaShjaGFyICppbXNpX2J1Ziwgc2l6ZV90ICppbXNpX2xlbikKK2ludCBlYXBfcHJveHlfZ2V0X2ltc2koc3RydWN0IGVhcF9wcm94eV9zbSAqZWFwX3Byb3h5LCBjaGFyICppbXNpX2J1ZiwKKwkJICAgICAgIHNpemVfdCAqaW1zaV9sZW4pCiB7CiAJcmV0dXJuIC0xOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9wc2suYyBiL3NyYy9lYXBfcGVlci9lYXBfcHNrLmMKaW5kZXggY2QwZTNmOS4uZjAxMjY2MyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9wc2suYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX3Bzay5jCkBAIC03Niw3ICs3Niw3IEBACiAJc3RydWN0IGVhcF9wc2tfZGF0YSAqZGF0YSA9IHByaXY7CiAJb3NfZnJlZShkYXRhLT5pZF9zKTsKIAlvc19mcmVlKGRhdGEtPmlkX3ApOwotCW9zX2ZyZWUoZGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiB9CiAKIApAQCAtMjM3LDcgKzIzNyw3IEBACiAJCXJldHVybiBOVUxMOwogCX0KIAlvc19mcmVlKGJ1Zik7Ci0JaWYgKG9zX21lbWNtcChtYWMsIGhkcjMtPm1hY19zLCBFQVBfUFNLX01BQ19MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KG1hYywgaGRyMy0+bWFjX3MsIEVBUF9QU0tfTUFDX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiRUFQLVBTSzogSW52YWxpZCBNQUNfUyBpbiB0aGlyZCAiCiAJCQkgICAibWVzc2FnZSIpOwogCQlyZXQtPm1ldGhvZFN0YXRlID0gTUVUSE9EX0RPTkU7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3B3ZC5jIGIvc3JjL2VhcF9wZWVyL2VhcF9wd2QuYwppbmRleCA5NzZlMDE3Li42YTBlNDViIDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3B3ZC5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfcHdkLmMKQEAgLTE2LDcgKzE2LDggQEAKIAogc3RydWN0IGVhcF9wd2RfZGF0YSB7CiAJZW51bSB7Ci0JCVBXRF9JRF9SZXEsIFBXRF9Db21taXRfUmVxLCBQV0RfQ29uZmlybV9SZXEsIFNVQ0NFU1MsIEZBSUxVUkUKKwkJUFdEX0lEX1JlcSwgUFdEX0NvbW1pdF9SZXEsIFBXRF9Db25maXJtX1JlcSwKKwkJU1VDQ0VTU19PTl9GUkFHX0NPTVBMRVRJT04sIFNVQ0NFU1MsIEZBSUxVUkUKIAl9IHN0YXRlOwogCXU4ICppZF9wZWVyOwogCXNpemVfdCBpZF9wZWVyX2xlbjsKQEAgLTQyLDYgKzQzLDcgQEAKIAogCXU4IG1za1tFQVBfTVNLX0xFTl07CiAJdTggZW1za1tFQVBfRU1TS19MRU5dOworCXU4IHNlc3Npb25faWRbMSArIFNIQTI1Nl9NQUNfTEVOXTsKIAogCUJOX0NUWCAqYm5jdHg7CiB9OwpAQCAtNTcsNiArNTksOCBAQAogCQlyZXR1cm4gIlBXRC1Db21taXQtUmVxIjsKICAgICAgICAgY2FzZSBQV0RfQ29uZmlybV9SZXE6CiAJCXJldHVybiAiUFdELUNvbmZpcm0tUmVxIjsKKwljYXNlIFNVQ0NFU1NfT05fRlJBR19DT01QTEVUSU9OOgorCQlyZXR1cm4gIlNVQ0NFU1NfT05fRlJBR19DT01QTEVUSU9OIjsKICAgICAgICAgY2FzZSBTVUNDRVNTOgogCQlyZXR1cm4gIlNVQ0NFU1MiOwogICAgICAgICBjYXNlIEZBSUxVUkU6CkBAIC04MSw2ICs4NSw3IEBACiAJc3RydWN0IGVhcF9wd2RfZGF0YSAqZGF0YTsKIAljb25zdCB1OCAqaWRlbnRpdHksICpwYXNzd29yZDsKIAlzaXplX3QgaWRlbnRpdHlfbGVuLCBwYXNzd29yZF9sZW47CisJaW50IGZyYWdtZW50X3NpemU7CiAKIAlwYXNzd29yZCA9IGVhcF9nZXRfY29uZmlnX3Bhc3N3b3JkKHNtLCAmcGFzc3dvcmRfbGVuKTsKIAlpZiAocGFzc3dvcmQgPT0gTlVMTCkgewpAQCAtMTE4LDcgKzEyMyw3IEBACiAJaWYgKChkYXRhLT5wYXNzd29yZCA9IG9zX21hbGxvYyhwYXNzd29yZF9sZW4pKSA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUFdEOiBtZW1vcnkgYWxsb2NhdGlvbiBwc2sgZmFpbCIpOwogCQlCTl9DVFhfZnJlZShkYXRhLT5ibmN0eCk7Ci0JCW9zX2ZyZWUoZGF0YS0+aWRfcGVlcik7CisJCWJpbl9jbGVhcl9mcmVlKGRhdGEtPmlkX3BlZXIsIGRhdGEtPmlkX3BlZXJfbGVuKTsKIAkJb3NfZnJlZShkYXRhKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtMTI3LDcgKzEzMiwxMSBAQAogCiAJZGF0YS0+b3V0X2ZyYWdfcG9zID0gZGF0YS0+aW5fZnJhZ19wb3MgPSAwOwogCWRhdGEtPmluYnVmID0gZGF0YS0+b3V0YnVmID0gTlVMTDsKLQlkYXRhLT5tdHUgPSAxMDIwOyAvKiBkZWZhdWx0IGZyb20gUkZDIDU5MzEsIG1ha2UgaXQgY29uZmlndXJhYmxlISAqLworCWZyYWdtZW50X3NpemUgPSBlYXBfZ2V0X2NvbmZpZ19mcmFnbWVudF9zaXplKHNtKTsKKwlpZiAoZnJhZ21lbnRfc2l6ZSA8PSAwKQorCQlkYXRhLT5tdHUgPSAxMDIwOyAvKiBkZWZhdWx0IGZyb20gUkZDIDU5MzEgKi8KKwllbHNlCisJCWRhdGEtPm10dSA9IGZyYWdtZW50X3NpemU7CiAKIAlkYXRhLT5zdGF0ZSA9IFBXRF9JRF9SZXE7CiAKQEAgLTEzOSwyNCArMTQ4LDI2IEBACiB7CiAJc3RydWN0IGVhcF9wd2RfZGF0YSAqZGF0YSA9IHByaXY7CiAKLQlCTl9mcmVlKGRhdGEtPnByaXZhdGVfdmFsdWUpOwotCUJOX2ZyZWUoZGF0YS0+c2VydmVyX3NjYWxhcik7Ci0JQk5fZnJlZShkYXRhLT5teV9zY2FsYXIpOwotCUJOX2ZyZWUoZGF0YS0+ayk7CisJQk5fY2xlYXJfZnJlZShkYXRhLT5wcml2YXRlX3ZhbHVlKTsKKwlCTl9jbGVhcl9mcmVlKGRhdGEtPnNlcnZlcl9zY2FsYXIpOworCUJOX2NsZWFyX2ZyZWUoZGF0YS0+bXlfc2NhbGFyKTsKKwlCTl9jbGVhcl9mcmVlKGRhdGEtPmspOwogCUJOX0NUWF9mcmVlKGRhdGEtPmJuY3R4KTsKLQlFQ19QT0lOVF9mcmVlKGRhdGEtPm15X2VsZW1lbnQpOwotCUVDX1BPSU5UX2ZyZWUoZGF0YS0+c2VydmVyX2VsZW1lbnQpOwotCW9zX2ZyZWUoZGF0YS0+aWRfcGVlcik7Ci0Jb3NfZnJlZShkYXRhLT5pZF9zZXJ2ZXIpOwotCW9zX2ZyZWUoZGF0YS0+cGFzc3dvcmQpOworCUVDX1BPSU5UX2NsZWFyX2ZyZWUoZGF0YS0+bXlfZWxlbWVudCk7CisJRUNfUE9JTlRfY2xlYXJfZnJlZShkYXRhLT5zZXJ2ZXJfZWxlbWVudCk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YS0+aWRfcGVlciwgZGF0YS0+aWRfcGVlcl9sZW4pOworCWJpbl9jbGVhcl9mcmVlKGRhdGEtPmlkX3NlcnZlciwgZGF0YS0+aWRfc2VydmVyX2xlbik7CisJYmluX2NsZWFyX2ZyZWUoZGF0YS0+cGFzc3dvcmQsIGRhdGEtPnBhc3N3b3JkX2xlbik7CiAJaWYgKGRhdGEtPmdycCkgewogCQlFQ19HUk9VUF9mcmVlKGRhdGEtPmdycC0+Z3JvdXApOwotCQlFQ19QT0lOVF9mcmVlKGRhdGEtPmdycC0+cHdlKTsKLQkJQk5fZnJlZShkYXRhLT5ncnAtPm9yZGVyKTsKLQkJQk5fZnJlZShkYXRhLT5ncnAtPnByaW1lKTsKKwkJRUNfUE9JTlRfY2xlYXJfZnJlZShkYXRhLT5ncnAtPnB3ZSk7CisJCUJOX2NsZWFyX2ZyZWUoZGF0YS0+Z3JwLT5vcmRlcik7CisJCUJOX2NsZWFyX2ZyZWUoZGF0YS0+Z3JwLT5wcmltZSk7CiAJCW9zX2ZyZWUoZGF0YS0+Z3JwKTsKIAl9Ci0Jb3NfZnJlZShkYXRhKTsKKwl3cGFidWZfZnJlZShkYXRhLT5pbmJ1Zik7CisJd3BhYnVmX2ZyZWUoZGF0YS0+b3V0YnVmKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLCBzaXplb2YoKmRhdGEpKTsKIH0KIAogCkBAIC0xNzksNiArMTkwLDI1IEBACiB9CiAKIAorc3RhdGljIHU4ICogZWFwX3B3ZF9nZXRfc2Vzc2lvbl9pZChzdHJ1Y3QgZWFwX3NtICpzbSwgdm9pZCAqcHJpdiwgc2l6ZV90ICpsZW4pCit7CisJc3RydWN0IGVhcF9wd2RfZGF0YSAqZGF0YSA9IHByaXY7CisJdTggKmlkOworCisJaWYgKGRhdGEtPnN0YXRlICE9IFNVQ0NFU1MpCisJCXJldHVybiBOVUxMOworCisJaWQgPSBvc19tYWxsb2MoMSArIFNIQTI1Nl9NQUNfTEVOKTsKKwlpZiAoaWQgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlvc19tZW1jcHkoaWQsIGRhdGEtPnNlc3Npb25faWQsIDEgKyBTSEEyNTZfTUFDX0xFTik7CisJKmxlbiA9IDEgKyBTSEEyNTZfTUFDX0xFTjsKKworCXJldHVybiBpZDsKK30KKworCiBzdGF0aWMgdm9pZAogZWFwX3B3ZF9wZXJmb3JtX2lkX2V4Y2hhbmdlKHN0cnVjdCBlYXBfc20gKnNtLCBzdHJ1Y3QgZWFwX3B3ZF9kYXRhICpkYXRhLAogCQkJICAgIHN0cnVjdCBlYXBfbWV0aG9kX3JldCAqcmV0LApAQCAtMjIyLDggKzI1Miw4IEBACiAJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0lORk8sICJFQVAtUFdEIChwZWVyKTogc2VydmVyIHNlbnQgaWQgb2YiLAogCQkJICBkYXRhLT5pZF9zZXJ2ZXIsIGRhdGEtPmlkX3NlcnZlcl9sZW4pOwogCi0JaWYgKChkYXRhLT5ncnAgPSAoRUFQX1BXRF9ncm91cCAqKSBvc19tYWxsb2Moc2l6ZW9mKEVBUF9QV0RfZ3JvdXApKSkgPT0KLQkgICAgTlVMTCkgeworCWRhdGEtPmdycCA9IG9zX3phbGxvYyhzaXplb2YoRUFQX1BXRF9ncm91cCkpOworCWlmIChkYXRhLT5ncnAgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVBXRDogZmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IgIgogCQkJICAgImdyb3VwIik7CiAJCWVhcF9wd2Rfc3RhdGUoZGF0YSwgRkFJTFVSRSk7CkBAIC0yODcsMTEgKzMxNywxNSBAQAogCQlnb3RvIGZpbjsKIAl9CiAKLQlCTl9yYW5kX3JhbmdlKGRhdGEtPnByaXZhdGVfdmFsdWUsIGRhdGEtPmdycC0+b3JkZXIpOwotCUJOX3JhbmRfcmFuZ2UobWFzaywgZGF0YS0+Z3JwLT5vcmRlcik7Ci0JQk5fYWRkKGRhdGEtPm15X3NjYWxhciwgZGF0YS0+cHJpdmF0ZV92YWx1ZSwgbWFzayk7Ci0JQk5fbW9kKGRhdGEtPm15X3NjYWxhciwgZGF0YS0+bXlfc2NhbGFyLCBkYXRhLT5ncnAtPm9yZGVyLAotCSAgICAgICBkYXRhLT5ibmN0eCk7CisJaWYgKEJOX3JhbmRfcmFuZ2UoZGF0YS0+cHJpdmF0ZV92YWx1ZSwgZGF0YS0+Z3JwLT5vcmRlcikgIT0gMSB8fAorCSAgICBCTl9yYW5kX3JhbmdlKG1hc2ssIGRhdGEtPmdycC0+b3JkZXIpICE9IDEgfHwKKwkgICAgQk5fYWRkKGRhdGEtPm15X3NjYWxhciwgZGF0YS0+cHJpdmF0ZV92YWx1ZSwgbWFzaykgIT0gMSB8fAorCSAgICBCTl9tb2QoZGF0YS0+bXlfc2NhbGFyLCBkYXRhLT5teV9zY2FsYXIsIGRhdGEtPmdycC0+b3JkZXIsCisJCSAgIGRhdGEtPmJuY3R4KSAhPSAxKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkgICAiRUFQLXB3ZCAocGVlcik6IHVuYWJsZSB0byBnZXQgcmFuZG9tbmVzcyIpOworCQlnb3RvIGZpbjsKKwl9CiAKIAlpZiAoIUVDX1BPSU5UX211bChkYXRhLT5ncnAtPmdyb3VwLCBkYXRhLT5teV9lbGVtZW50LCBOVUxMLAogCQkJICBkYXRhLT5ncnAtPnB3ZSwgbWFzaywgZGF0YS0+Ym5jdHgpKSB7CkBAIC0zMDYsNyArMzQwLDcgQEAKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QV0QgKHBlZXIpOiBlbGVtZW50IGludmVyc2lvbiBmYWlsIik7CiAJCWdvdG8gZmluOwogCX0KLQlCTl9mcmVlKG1hc2spOworCUJOX2NsZWFyX2ZyZWUobWFzayk7CiAKIAlpZiAoKCh4ID0gQk5fbmV3KCkpID09IE5VTEwpIHx8CiAJICAgICgoeSA9IEJOX25ldygpKSA9PSBOVUxMKSkgewpAQCAtNDQxLDExICs0NzUsMTEgQEAKIGZpbjoKIAlvc19mcmVlKHNjYWxhcik7CiAJb3NfZnJlZShlbGVtZW50KTsKLQlCTl9mcmVlKHgpOwotCUJOX2ZyZWUoeSk7Ci0JQk5fZnJlZShjb2ZhY3Rvcik7Ci0JRUNfUE9JTlRfZnJlZShLKTsKLQlFQ19QT0lOVF9mcmVlKHBvaW50KTsKKwlCTl9jbGVhcl9mcmVlKHgpOworCUJOX2NsZWFyX2ZyZWUoeSk7CisJQk5fY2xlYXJfZnJlZShjb2ZhY3Rvcik7CisJRUNfUE9JTlRfY2xlYXJfZnJlZShLKTsKKwlFQ19QT0lOVF9jbGVhcl9mcmVlKHBvaW50KTsKIAlpZiAoZGF0YS0+b3V0YnVmID09IE5VTEwpCiAJCWVhcF9wd2Rfc3RhdGUoZGF0YSwgRkFJTFVSRSk7CiAJZWxzZQpAQCAtNTU5LDcgKzU5Myw3IEBACiAJZWFwX3B3ZF9oX2ZpbmFsKGhhc2gsIGNvbmYpOwogCiAJcHRyID0gKHU4ICopIHBheWxvYWQ7Ci0JaWYgKG9zX21lbWNtcChjb25mLCBwdHIsIFNIQTI1Nl9NQUNfTEVOKSkgeworCWlmIChvc19tZW1jbXBfY29uc3QoY29uZiwgcHRyLCBTSEEyNTZfTUFDX0xFTikpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QV0QgKHBlZXIpOiBjb25maXJtIGRpZCBub3QgdmVyaWZ5Iik7CiAJCWdvdG8gZmluOwogCX0KQEAgLTYzNyw3ICs2NzEsNyBAQAogCiAJaWYgKGNvbXB1dGVfa2V5cyhkYXRhLT5ncnAsIGRhdGEtPmJuY3R4LCBkYXRhLT5rLAogCQkJIGRhdGEtPm15X3NjYWxhciwgZGF0YS0+c2VydmVyX3NjYWxhciwgY29uZiwgcHRyLAotCQkJICZjcywgZGF0YS0+bXNrLCBkYXRhLT5lbXNrKSA8IDApIHsKKwkJCSAmY3MsIGRhdGEtPm1zaywgZGF0YS0+ZW1zaywgZGF0YS0+c2Vzc2lvbl9pZCkgPCAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUFdEIChwZWVyKTogdW5hYmxlIHRvIGNvbXB1dGUgTVNLIHwgIgogCQkJICAgIkVNU0siKTsKIAkJZ290byBmaW47CkBAIC02NTAsMTYgKzY4NCwxNSBAQAogCXdwYWJ1Zl9wdXRfZGF0YShkYXRhLT5vdXRidWYsIGNvbmYsIFNIQTI1Nl9NQUNfTEVOKTsKIAogZmluOgotCW9zX2ZyZWUoY3J1ZnQpOwotCUJOX2ZyZWUoeCk7Ci0JQk5fZnJlZSh5KTsKLQlyZXQtPm1ldGhvZFN0YXRlID0gTUVUSE9EX0RPTkU7CisJYmluX2NsZWFyX2ZyZWUoY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJQk5fY2xlYXJfZnJlZSh4KTsKKwlCTl9jbGVhcl9mcmVlKHkpOwogCWlmIChkYXRhLT5vdXRidWYgPT0gTlVMTCkgeworCQlyZXQtPm1ldGhvZFN0YXRlID0gTUVUSE9EX0RPTkU7CiAJCXJldC0+ZGVjaXNpb24gPSBERUNJU0lPTl9GQUlMOwogCQllYXBfcHdkX3N0YXRlKGRhdGEsIEZBSUxVUkUpOwogCX0gZWxzZSB7Ci0JCXJldC0+ZGVjaXNpb24gPSBERUNJU0lPTl9VTkNPTkRfU1VDQzsKLQkJZWFwX3B3ZF9zdGF0ZShkYXRhLCBTVUNDRVNTKTsKKwkJZWFwX3B3ZF9zdGF0ZShkYXRhLCBTVUNDRVNTX09OX0ZSQUdfQ09NUExFVElPTik7CiAJfQogfQogCkBAIC03MzYsNiArNzY5LDExIEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLXB3ZDogU2VuZCAlcyBmcmFnbWVudCBvZiAlZCBieXRlcyIsCiAJCQkgICBkYXRhLT5vdXRfZnJhZ19wb3MgPT0gMCA/ICJsYXN0IiA6ICJuZXh0IiwKIAkJCSAgIChpbnQpIGxlbik7CisJCWlmIChkYXRhLT5zdGF0ZSA9PSBTVUNDRVNTX09OX0ZSQUdfQ09NUExFVElPTikgeworCQkJcmV0LT5tZXRob2RTdGF0ZSA9IE1FVEhPRF9ET05FOworCQkJcmV0LT5kZWNpc2lvbiA9IERFQ0lTSU9OX1VOQ09ORF9TVUNDOworCQkJZWFwX3B3ZF9zdGF0ZShkYXRhLCBTVUNDRVNTKTsKKwkJfQogCQlyZXR1cm4gcmVzcDsKIAl9CiAKQEAgLTc0OCw2ICs3ODYsOCBAQAogCQl0b3RfbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLXB3ZDogSW5jb21pbmcgZnJhZ21lbnRzIHdob3NlICIKIAkJCSAgICJ0b3RhbCBsZW5ndGggPSAlZCIsIHRvdF9sZW4pOworCQlpZiAodG90X2xlbiA+IDE1MDAwKQorCQkJcmV0dXJuIE5VTEw7CiAJCWRhdGEtPmluYnVmID0gd3BhYnVmX2FsbG9jKHRvdF9sZW4pOwogCQlpZiAoZGF0YS0+aW5idWYgPT0gTlVMTCkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk91dCBvZiBtZW1vcnkgdG8gYnVmZmVyICIKQEAgLTc2OCw2ICs4MDgsNyBAQAogCQkJCSAgIChpbnQpIGRhdGEtPmluX2ZyYWdfcG9zLAogCQkJCSAgIChpbnQpIHdwYWJ1Zl9sZW4oZGF0YS0+aW5idWYpKTsKIAkJCXdwYWJ1Zl9mcmVlKGRhdGEtPmluYnVmKTsKKwkJCWRhdGEtPmluYnVmID0gTlVMTDsKIAkJCWRhdGEtPmluX2ZyYWdfcG9zID0gMDsKIAkJCXJldHVybiBOVUxMOwogCQl9CkBAIC04MTgsMTEgKzg1OSwxNSBAQAogCSAqLwogCWlmIChkYXRhLT5pbl9mcmFnX3BvcykgewogCQl3cGFidWZfZnJlZShkYXRhLT5pbmJ1Zik7CisJCWRhdGEtPmluYnVmID0gTlVMTDsKIAkJZGF0YS0+aW5fZnJhZ19wb3MgPSAwOwogCX0KIAotCWlmIChkYXRhLT5vdXRidWYgPT0gTlVMTCkKKwlpZiAoZGF0YS0+b3V0YnVmID09IE5VTEwpIHsKKwkJcmV0LT5tZXRob2RTdGF0ZSA9IE1FVEhPRF9ET05FOworCQlyZXQtPmRlY2lzaW9uID0gREVDSVNJT05fRkFJTDsKIAkJcmV0dXJuIE5VTEw7ICAgICAgICAvKiBnZW5lcmljIGZhaWx1cmUgKi8KKwl9CiAKIAkvKgogCSAqIHdlIGhhdmUgb3V0cHV0ISBEbyB3ZSBuZWVkIHRvIGZyYWdtZW50IGl0PwpAQCAtODY1LDYgKzkxMCwxMSBAQAogCQl3cGFidWZfZnJlZShkYXRhLT5vdXRidWYpOwogCQlkYXRhLT5vdXRidWYgPSBOVUxMOwogCQlkYXRhLT5vdXRfZnJhZ19wb3MgPSAwOworCQlpZiAoZGF0YS0+c3RhdGUgPT0gU1VDQ0VTU19PTl9GUkFHX0NPTVBMRVRJT04pIHsKKwkJCXJldC0+bWV0aG9kU3RhdGUgPSBNRVRIT0RfRE9ORTsKKwkJCXJldC0+ZGVjaXNpb24gPSBERUNJU0lPTl9VTkNPTkRfU1VDQzsKKwkJCWVhcF9wd2Rfc3RhdGUoZGF0YSwgU1VDQ0VTUyk7CisJCX0KIAl9CiAKIAlyZXR1cm4gcmVzcDsKQEAgLTkxMiw2ICs5NjIsNyBAQAogCWVhcC0+cHJvY2VzcyA9IGVhcF9wd2RfcHJvY2VzczsKIAllYXAtPmlzS2V5QXZhaWxhYmxlID0gZWFwX3B3ZF9rZXlfYXZhaWxhYmxlOwogCWVhcC0+Z2V0S2V5ID0gZWFwX3B3ZF9nZXRrZXk7CisJZWFwLT5nZXRTZXNzaW9uSWQgPSBlYXBfcHdkX2dldF9zZXNzaW9uX2lkOwogCWVhcC0+Z2V0X2Vtc2sgPSBlYXBfcHdkX2dldF9lbXNrOwogCiAJcmV0ID0gZWFwX3BlZXJfbWV0aG9kX3JlZ2lzdGVyKGVhcCk7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3Nha2UuYyBiL3NyYy9lYXBfcGVlci9lYXBfc2FrZS5jCmluZGV4IDQzMTUxOWMuLjdkMTQ5MDcgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9lYXBfc2FrZS5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfc2FrZS5jCkBAIC0xMDgsNyArMTA4LDcgQEAKIAlzdHJ1Y3QgZWFwX3Nha2VfZGF0YSAqZGF0YSA9IHByaXY7CiAJb3NfZnJlZShkYXRhLT5zZXJ2ZXJpZCk7CiAJb3NfZnJlZShkYXRhLT5wZWVyaWQpOwotCW9zX2ZyZWUoZGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiB9CiAKIApAQCAtMzE1LDcgKzMxNSw3IEBACiAJCQkgICAgIGRhdGEtPnBlZXJpZCwgZGF0YS0+cGVlcmlkX2xlbiwgMCwKIAkJCSAgICAgd3BhYnVmX2hlYWQocmVxRGF0YSksIHdwYWJ1Zl9sZW4ocmVxRGF0YSksCiAJCQkgICAgIGF0dHIubWljX3MsIG1pY19zKTsKLQlpZiAob3NfbWVtY21wKGF0dHIubWljX3MsIG1pY19zLCBFQVBfU0FLRV9NSUNfTEVOKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChhdHRyLm1pY19zLCBtaWNfcywgRUFQX1NBS0VfTUlDX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVNBS0U6IEluY29ycmVjdCBBVF9NSUNfUyIpOwogCQllYXBfc2FrZV9zdGF0ZShkYXRhLCBGQUlMVVJFKTsKIAkJcmV0LT5tZXRob2RTdGF0ZSA9IE1FVEhPRF9ET05FOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9zaW0uYyBiL3NyYy9lYXBfcGVlci9lYXBfc2ltLmMKaW5kZXggODJlYTE4ZC4uYmQwNmRmNyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9zaW0uYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX3NpbS5jCkBAIC00Myw3ICs0Myw3IEBACiAJdTggKmxhc3RfZWFwX2lkZW50aXR5OwogCXNpemVfdCBsYXN0X2VhcF9pZGVudGl0eV9sZW47CiAJZW51bSB7Ci0JCUNPTlRJTlVFLCBSRVNVTFRfU1VDQ0VTUywgUkVTVUxUX0ZBSUxVUkUsIFNVQ0NFU1MsIEZBSUxVUkUKKwkJQ09OVElOVUUsIFJFU1VMVF9TVUNDRVNTLCBTVUNDRVNTLCBGQUlMVVJFCiAJfSBzdGF0ZTsKIAlpbnQgcmVzdWx0X2luZCwgdXNlX3Jlc3VsdF9pbmQ7CiB9OwpAQCAtNTcsOCArNTcsNiBAQAogCQlyZXR1cm4gIkNPTlRJTlVFIjsKIAljYXNlIFJFU1VMVF9TVUNDRVNTOgogCQlyZXR1cm4gIlJFU1VMVF9TVUNDRVNTIjsKLQljYXNlIFJFU1VMVF9GQUlMVVJFOgotCQlyZXR1cm4gIlJFU1VMVF9GQUlMVVJFIjsKIAljYXNlIFNVQ0NFU1M6CiAJCXJldHVybiAiU1VDQ0VTUyI7CiAJY2FzZSBGQUlMVVJFOgpAQCAtMTMyLDYgKzEzMCwyMCBAQAogfQogCiAKK3N0YXRpYyB2b2lkIGVhcF9zaW1fY2xlYXJfa2V5cyhzdHJ1Y3QgZWFwX3NpbV9kYXRhICpkYXRhLCBpbnQgcmVhdXRoKQoreworCWlmICghcmVhdXRoKSB7CisJCW9zX21lbXNldChkYXRhLT5taywgMCwgRUFQX1NJTV9NS19MRU4pOworCQlvc19tZW1zZXQoZGF0YS0+a19hdXQsIDAsIEVBUF9TSU1fS19BVVRfTEVOKTsKKwkJb3NfbWVtc2V0KGRhdGEtPmtfZW5jciwgMCwgRUFQX1NJTV9LX0VOQ1JfTEVOKTsKKwl9CisJb3NfbWVtc2V0KGRhdGEtPmtjLCAwLCAzICogRUFQX1NJTV9LQ19MRU4pOworCW9zX21lbXNldChkYXRhLT5zcmVzLCAwLCAzICogRUFQX1NJTV9TUkVTX0xFTik7CisJb3NfbWVtc2V0KGRhdGEtPm1zaywgMCwgRUFQX1NJTV9LRVlJTkdfREFUQV9MRU4pOworCW9zX21lbXNldChkYXRhLT5lbXNrLCAwLCBFQVBfRU1TS19MRU4pOworfQorCisKIHN0YXRpYyB2b2lkIGVhcF9zaW1fZGVpbml0KHN0cnVjdCBlYXBfc20gKnNtLCB2b2lkICpwcml2KQogewogCXN0cnVjdCBlYXBfc2ltX2RhdGEgKmRhdGEgPSBwcml2OwpAQCAtMTQwLDExICsxNTIsODYgQEAKIAkJb3NfZnJlZShkYXRhLT5wc2V1ZG9ueW0pOwogCQlvc19mcmVlKGRhdGEtPnJlYXV0aF9pZCk7CiAJCW9zX2ZyZWUoZGF0YS0+bGFzdF9lYXBfaWRlbnRpdHkpOworCQllYXBfc2ltX2NsZWFyX2tleXMoZGF0YSwgMCk7CiAJCW9zX2ZyZWUoZGF0YSk7CiAJfQogfQogCiAKK3N0YXRpYyBpbnQgZWFwX3NpbV9leHRfc2ltX3JlcShzdHJ1Y3QgZWFwX3NtICpzbSwgc3RydWN0IGVhcF9zaW1fZGF0YSAqZGF0YSkKK3sKKwljaGFyIHJlcVsyMDBdLCAqcG9zLCAqZW5kOworCXNpemVfdCBpOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtU0lNOiBVc2UgZXh0ZXJuYWwgU0lNIHByb2Nlc3NpbmciKTsKKwlwb3MgPSByZXE7CisJZW5kID0gcG9zICsgc2l6ZW9mKHJlcSk7CisJcG9zICs9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiR1NNLUFVVEgiKTsKKwlmb3IgKGkgPSAwOyBpIDwgZGF0YS0+bnVtX2NoYWw7IGkrKykgeworCQlwb3MgKz0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICI6Iik7CisJCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLCBkYXRhLT5yYW5kW2ldLAorCQkJCQlHU01fUkFORF9MRU4pOworCX0KKworCWVhcF9zbV9yZXF1ZXN0X3NpbShzbSwgcmVxKTsKKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgaW50IGVhcF9zaW1fZXh0X3NpbV9yZXN1bHQoc3RydWN0IGVhcF9zbSAqc20sIHN0cnVjdCBlYXBfc2ltX2RhdGEgKmRhdGEsCisJCQkJICBzdHJ1Y3QgZWFwX3BlZXJfY29uZmlnICpjb25mKQoreworCWNoYXIgKnJlc3AsICpwb3M7CisJc2l6ZV90IGk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIkVBUC1TSU06IFVzZSByZXN1bHQgZnJvbSBleHRlcm5hbCBTSU0gcHJvY2Vzc2luZyIpOworCisJcmVzcCA9IGNvbmYtPmV4dGVybmFsX3NpbV9yZXNwOworCWNvbmYtPmV4dGVybmFsX3NpbV9yZXNwID0gTlVMTDsKKworCWlmIChvc19zdHJuY21wKHJlc3AsICJHU00tQVVUSDoiLCA5KSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVNJTTogVW5yZWNvZ25pemVkIGV4dGVybmFsIFNJTSBwcm9jZXNzaW5nIHJlc3BvbnNlIik7CisJCW9zX2ZyZWUocmVzcCk7CisJCXJldHVybiAtMTsKKwl9CisKKwlwb3MgPSByZXNwICsgOTsKKwlmb3IgKGkgPSAwOyBpIDwgZGF0YS0+bnVtX2NoYWw7IGkrKykgeworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAtU0lNOiBSQU5EIiwKKwkJCSAgICBkYXRhLT5yYW5kW2ldLCBHU01fUkFORF9MRU4pOworCisJCWlmIChoZXhzdHIyYmluKHBvcywgZGF0YS0+a2NbaV0sIEVBUF9TSU1fS0NfTEVOKSA8IDApCisJCQlnb3RvIGludmFsaWQ7CisJCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJFQVAtU0lNOiBLYyIsCisJCQkJZGF0YS0+a2NbaV0sIEVBUF9TSU1fS0NfTEVOKTsKKwkJcG9zICs9IEVBUF9TSU1fS0NfTEVOICogMjsKKwkJaWYgKCpwb3MgIT0gJzonKQorCQkJZ290byBpbnZhbGlkOworCQlwb3MrKzsKKworCQlpZiAoaGV4c3RyMmJpbihwb3MsIGRhdGEtPnNyZXNbaV0sIEVBUF9TSU1fU1JFU19MRU4pIDwgMCkKKwkJCWdvdG8gaW52YWxpZDsKKwkJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIkVBUC1TSU06IFNSRVMiLAorCQkJCWRhdGEtPnNyZXNbaV0sIEVBUF9TSU1fU1JFU19MRU4pOworCQlwb3MgKz0gRUFQX1NJTV9TUkVTX0xFTiAqIDI7CisJCWlmIChpICsgMSA8IGRhdGEtPm51bV9jaGFsKSB7CisJCQlpZiAoKnBvcyAhPSAnOicpCisJCQkJZ290byBpbnZhbGlkOworCQkJcG9zKys7CisJCX0KKwl9CisKKwlvc19mcmVlKHJlc3ApOworCXJldHVybiAwOworCitpbnZhbGlkOgorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVNJTTogSW52YWxpZCBleHRlcm5hbCBTSU0gcHJvY2Vzc2luZyBHU00tQVVUSCByZXNwb25zZSIpOworCW9zX2ZyZWUocmVzcCk7CisJcmV0dXJuIC0xOworfQorCisKIHN0YXRpYyBpbnQgZWFwX3NpbV9nc21fYXV0aChzdHJ1Y3QgZWFwX3NtICpzbSwgc3RydWN0IGVhcF9zaW1fZGF0YSAqZGF0YSkKIHsKIAlzdHJ1Y3QgZWFwX3BlZXJfY29uZmlnICpjb25mOwpAQCAtMTU0LDYgKzI0MSwxNCBAQAogCWNvbmYgPSBlYXBfZ2V0X2NvbmZpZyhzbSk7CiAJaWYgKGNvbmYgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOworCisJaWYgKHNtLT5leHRlcm5hbF9zaW0pIHsKKwkJaWYgKGNvbmYtPmV4dGVybmFsX3NpbV9yZXNwKQorCQkJcmV0dXJuIGVhcF9zaW1fZXh0X3NpbV9yZXN1bHQoc20sIGRhdGEsIGNvbmYpOworCQllbHNlCisJCQlyZXR1cm4gZWFwX3NpbV9leHRfc2ltX3JlcShzbSwgZGF0YSk7CisJfQorCiAJaWYgKGNvbmYtPnBjc2MpIHsKIAkJaWYgKHNjYXJkX2dzbV9hdXRoKHNtLT5zY2FyZF9jdHgsIGRhdGEtPnJhbmRbMF0sCiAJCQkJICAgZGF0YS0+c3Jlc1swXSwgZGF0YS0+a2NbMF0pIHx8CkBAIC0zNjksNyArNDY0LDcgQEAKIAltc2cgPSBlYXBfc2ltX21zZ19pbml0KEVBUF9DT0RFX1JFU1BPTlNFLCBpZCwgRUFQX1RZUEVfU0lNLAogCQkJICAgICAgIEVBUF9TSU1fU1VCVFlQRV9DTElFTlRfRVJST1IpOwogCWVhcF9zaW1fbXNnX2FkZChtc2csIEVBUF9TSU1fQVRfQ0xJRU5UX0VSUk9SX0NPREUsIGVyciwgTlVMTCwgMCk7Ci0JcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIE5VTEwsIE5VTEwsIDApOworCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBFQVBfVFlQRV9TSU0sIE5VTEwsIE5VTEwsIDApOwogfQogCiAKQEAgLTQyMiw3ICs1MTcsNyBAQAogCQkJCWlkZW50aXR5LCBpZGVudGl0eV9sZW4pOwogCX0KIAotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBOVUxMLCBOVUxMLCAwKTsKKwlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgRUFQX1RZUEVfU0lNLCBOVUxMLCBOVUxMLCAwKTsKIH0KIAogCkBAIC00NDAsNyArNTM1LDggQEAKIAl9CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9NQUMiKTsKIAllYXBfc2ltX21zZ19hZGRfbWFjKG1zZywgRUFQX1NJTV9BVF9NQUMpOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5rX2F1dCwgKHU4ICopIGRhdGEtPnNyZXMsCisJcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIEVBUF9UWVBFX1NJTSwgZGF0YS0+a19hdXQsCisJCQkJICAodTggKikgZGF0YS0+c3JlcywKIAkJCQkgIGRhdGEtPm51bV9jaGFsICogRUFQX1NJTV9TUkVTX0xFTik7CiB9CiAKQEAgLTQ4Miw3ICs1NzgsNyBAQAogCX0KIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX01BQyIpOwogCWVhcF9zaW1fbXNnX2FkZF9tYWMobXNnLCBFQVBfU0lNX0FUX01BQyk7Ci0JcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIGRhdGEtPmtfYXV0LCBub25jZV9zLAorCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBFQVBfVFlQRV9TSU0sIGRhdGEtPmtfYXV0LCBub25jZV9zLAogCQkJCSAgRUFQX1NJTV9OT05DRV9TX0xFTik7CiB9CiAKQEAgLTUxNiw3ICs2MTIsNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX01BQyIpOwogCQllYXBfc2ltX21zZ19hZGRfbWFjKG1zZywgRUFQX1NJTV9BVF9NQUMpOwogCX0KLQlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywga19hdXQsICh1OCAqKSAiIiwgMCk7CisJcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIEVBUF9UWVBFX1NJTSwga19hdXQsICh1OCAqKSAiIiwgMCk7CiB9CiAKIApAQCAtNjA1LDYgKzcwMSw3IEBACiAJY29uc3QgdTggKmlkZW50aXR5OwogCXNpemVfdCBpZGVudGl0eV9sZW47CiAJc3RydWN0IGVhcF9zaW1fYXR0cnMgZWF0dHI7CisJaW50IHJlczsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVNJTTogc3VidHlwZSBDaGFsbGVuZ2UiKTsKIAlkYXRhLT5yZWF1dGggPSAwOwpAQCAtNjQ4LDggKzc0NSwxMyBAQAogCiAJb3NfbWVtY3B5KGRhdGEtPnJhbmQsIGF0dHItPnJhbmQsIGF0dHItPm51bV9jaGFsICogR1NNX1JBTkRfTEVOKTsKIAlkYXRhLT5udW1fY2hhbCA9IGF0dHItPm51bV9jaGFsOwotCQkKLQlpZiAoZWFwX3NpbV9nc21fYXV0aChzbSwgZGF0YSkpIHsKKworCXJlcyA9IGVhcF9zaW1fZ3NtX2F1dGgoc20sIGRhdGEpOworCWlmIChyZXMgPiAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVNJTTogV2FpdCBmb3IgZXh0ZXJuYWwgU0lNIHByb2Nlc3NpbmciKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCWlmIChyZXMpIHsKIAkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkVBUC1TSU06IEdTTSBhdXRoZW50aWNhdGlvbiBmYWlsZWQiKTsKIAkJcmV0dXJuIGVhcF9zaW1fY2xpZW50X2Vycm9yKGRhdGEsIGlkLAogCQkJCQkgICAgRUFQX1NJTV9VTkFCTEVfVE9fUFJPQ0VTU19QQUNLRVQpOwpAQCAtNzAwLDcgKzgwMiw3IEBACiAJaWYgKGRhdGEtPnJlc3VsdF9pbmQgJiYgYXR0ci0+cmVzdWx0X2luZCkKIAkJZGF0YS0+dXNlX3Jlc3VsdF9pbmQgPSAxOwogCi0JaWYgKGRhdGEtPnN0YXRlICE9IEZBSUxVUkUgJiYgZGF0YS0+c3RhdGUgIT0gUkVTVUxUX0ZBSUxVUkUpIHsKKwlpZiAoZGF0YS0+c3RhdGUgIT0gRkFJTFVSRSkgewogCQllYXBfc2ltX3N0YXRlKGRhdGEsIGRhdGEtPnVzZV9yZXN1bHRfaW5kID8KIAkJCSAgICAgIFJFU1VMVF9TVUNDRVNTIDogU1VDQ0VTUyk7CiAJfQpAQCAtODY0LDkgKzk2NiwxMSBAQAogCX0KIAogCWlmIChlYXR0ci5jb3VudGVyIDwgMCB8fCAoc2l6ZV90KSBlYXR0ci5jb3VudGVyIDw9IGRhdGEtPmNvdW50ZXIpIHsKKwkJc3RydWN0IHdwYWJ1ZiAqcmVzOwogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVNJTTogKGVuY3IpIEludmFsaWQgY291bnRlciAiCiAJCQkgICAiKCVkIDw9ICVkKSIsIGVhdHRyLmNvdW50ZXIsIGRhdGEtPmNvdW50ZXIpOwogCQlkYXRhLT5jb3VudGVyX3Rvb19zbWFsbCA9IGVhdHRyLmNvdW50ZXI7CisKIAkJLyogUmVwbHkgdXNpbmcgUmUtYXV0aCB3LyBBVF9DT1VOVEVSX1RPT19TTUFMTC4gVGhlIGN1cnJlbnQKIAkJICogcmVhdXRoX2lkIG11c3Qgbm90IGJlIHVzZWQgdG8gc3RhcnQgYSBuZXcgcmVhdXRoZW50aWNhdGlvbi4KIAkJICogSG93ZXZlciwgc2luY2UgaXQgd2FzIHVzZWQgaW4gdGhlIGxhc3QgRUFQLVJlc3BvbnNlLUlkZW50aXR5CkBAIC04NzcsOCArOTgxLDExIEBACiAJCWRhdGEtPmxhc3RfZWFwX2lkZW50aXR5X2xlbiA9IGRhdGEtPnJlYXV0aF9pZF9sZW47CiAJCWRhdGEtPnJlYXV0aF9pZCA9IE5VTEw7CiAJCWRhdGEtPnJlYXV0aF9pZF9sZW4gPSAwOworCisJCXJlcyA9IGVhcF9zaW1fcmVzcG9uc2VfcmVhdXRoKGRhdGEsIGlkLCAxLCBlYXR0ci5ub25jZV9zKTsKIAkJb3NfZnJlZShkZWNyeXB0ZWQpOwotCQlyZXR1cm4gZWFwX3NpbV9yZXNwb25zZV9yZWF1dGgoZGF0YSwgaWQsIDEsIGVhdHRyLm5vbmNlX3MpOworCisJCXJldHVybiByZXM7CiAJfQogCWRhdGEtPmNvdW50ZXIgPSBlYXR0ci5jb3VudGVyOwogCkBAIC04OTYsNyArMTAwMyw3IEBACiAJaWYgKGRhdGEtPnJlc3VsdF9pbmQgJiYgYXR0ci0+cmVzdWx0X2luZCkKIAkJZGF0YS0+dXNlX3Jlc3VsdF9pbmQgPSAxOwogCi0JaWYgKGRhdGEtPnN0YXRlICE9IEZBSUxVUkUgJiYgZGF0YS0+c3RhdGUgIT0gUkVTVUxUX0ZBSUxVUkUpIHsKKwlpZiAoZGF0YS0+c3RhdGUgIT0gRkFJTFVSRSkgewogCQllYXBfc2ltX3N0YXRlKGRhdGEsIGRhdGEtPnVzZV9yZXN1bHRfaW5kID8KIAkJCSAgICAgIFJFU1VMVF9TVUNDRVNTIDogU1VDQ0VTUyk7CiAJfQpAQCAtOTk1LDkgKzExMDIsNyBAQAogCQkJREVDSVNJT05fVU5DT05EX1NVQ0MgOiBERUNJU0lPTl9DT05EX1NVQ0M7CiAJCXJldC0+bWV0aG9kU3RhdGUgPSBkYXRhLT51c2VfcmVzdWx0X2luZCA/CiAJCQlNRVRIT0RfRE9ORSA6IE1FVEhPRF9NQVlfQ09OVDsKLQl9IGVsc2UgaWYgKGRhdGEtPnN0YXRlID09IFJFU1VMVF9GQUlMVVJFKQotCQlyZXQtPm1ldGhvZFN0YXRlID0gTUVUSE9EX0NPTlQ7Ci0JZWxzZSBpZiAoZGF0YS0+c3RhdGUgPT0gUkVTVUxUX1NVQ0NFU1MpCisJfSBlbHNlIGlmIChkYXRhLT5zdGF0ZSA9PSBSRVNVTFRfU1VDQ0VTUykKIAkJcmV0LT5tZXRob2RTdGF0ZSA9IE1FVEhPRF9DT05UOwogCiAJaWYgKHJldC0+bWV0aG9kU3RhdGUgPT0gTUVUSE9EX0RPTkUpIHsKQEAgLTEwMjAsNiArMTEyNSw3IEBACiAJc3RydWN0IGVhcF9zaW1fZGF0YSAqZGF0YSA9IHByaXY7CiAJZWFwX3NpbV9jbGVhcl9pZGVudGl0aWVzKHNtLCBkYXRhLCBDTEVBUl9FQVBfSUQpOwogCWRhdGEtPnVzZV9yZXN1bHRfaW5kID0gMDsKKwllYXBfc2ltX2NsZWFyX2tleXMoZGF0YSwgMSk7CiB9CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF90bHMuYyBiL3NyYy9lYXBfcGVlci9lYXBfdGxzLmMKaW5kZXggZDIwNjZjZC4uNWFhM2ZkNSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF90bHMuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX3Rscy5jCkBAIC05OCwxMyArOTgsNDkgQEAKICNlbmRpZiAvKiBFQVBfVU5BVVRIX1RMUyAqLwogCiAKKyNpZmRlZiBDT05GSUdfSFMyMAorc3RhdGljIHZvaWQgKiBlYXBfd2ZhX3VuYXV0aF90bHNfaW5pdChzdHJ1Y3QgZWFwX3NtICpzbSkKK3sKKwlzdHJ1Y3QgZWFwX3Rsc19kYXRhICpkYXRhOworCXN0cnVjdCBlYXBfcGVlcl9jb25maWcgKmNvbmZpZyA9IGVhcF9nZXRfY29uZmlnKHNtKTsKKworCWRhdGEgPSBvc196YWxsb2Moc2l6ZW9mKCpkYXRhKSk7CisJaWYgKGRhdGEgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlkYXRhLT5zc2xfY3R4ID0gc20tPmluaXRfcGhhc2UyICYmIHNtLT5zc2xfY3R4MiA/IHNtLT5zc2xfY3R4MiA6CisJCXNtLT5zc2xfY3R4OworCisJaWYgKGVhcF9wZWVyX3Rsc19zc2xfaW5pdChzbSwgJmRhdGEtPnNzbCwgY29uZmlnLAorCQkJCSAgRUFQX1dGQV9VTkFVVEhfVExTX1RZUEUpKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtVExTOiBGYWlsZWQgdG8gaW5pdGlhbGl6ZSBTU0wuIik7CisJCWVhcF90bHNfZGVpbml0KHNtLCBkYXRhKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJZGF0YS0+ZWFwX3R5cGUgPSBFQVBfV0ZBX1VOQVVUSF9UTFNfVFlQRTsKKworCXJldHVybiBkYXRhOworfQorI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisKKworc3RhdGljIHZvaWQgZWFwX3Rsc19mcmVlX2tleShzdHJ1Y3QgZWFwX3Rsc19kYXRhICpkYXRhKQoreworCWlmIChkYXRhLT5rZXlfZGF0YSkgeworCQliaW5fY2xlYXJfZnJlZShkYXRhLT5rZXlfZGF0YSwgRUFQX1RMU19LRVlfTEVOICsgRUFQX0VNU0tfTEVOKTsKKwkJZGF0YS0+a2V5X2RhdGEgPSBOVUxMOworCX0KK30KKworCiBzdGF0aWMgdm9pZCBlYXBfdGxzX2RlaW5pdChzdHJ1Y3QgZWFwX3NtICpzbSwgdm9pZCAqcHJpdikKIHsKIAlzdHJ1Y3QgZWFwX3Rsc19kYXRhICpkYXRhID0gcHJpdjsKIAlpZiAoZGF0YSA9PSBOVUxMKQogCQlyZXR1cm47CiAJZWFwX3BlZXJfdGxzX3NzbF9kZWluaXQoc20sICZkYXRhLT5zc2wpOwotCW9zX2ZyZWUoZGF0YS0+a2V5X2RhdGEpOworCWVhcF90bHNfZnJlZV9rZXkoZGF0YSk7CiAJb3NfZnJlZShkYXRhLT5zZXNzaW9uX2lkKTsKIAlvc19mcmVlKGRhdGEpOwogfQpAQCAtMTU0LDcgKzE5MCw3IEBACiAJcmV0LT5tZXRob2RTdGF0ZSA9IE1FVEhPRF9ET05FOwogCXJldC0+ZGVjaXNpb24gPSBERUNJU0lPTl9VTkNPTkRfU1VDQzsKIAotCW9zX2ZyZWUoZGF0YS0+a2V5X2RhdGEpOworCWVhcF90bHNfZnJlZV9rZXkoZGF0YSk7CiAJZGF0YS0+a2V5X2RhdGEgPSBlYXBfcGVlcl90bHNfZGVyaXZlX2tleShzbSwgJmRhdGEtPnNzbCwKIAkJCQkJCSAiY2xpZW50IEVBUCBlbmNyeXB0aW9uIiwKIAkJCQkJCSBFQVBfVExTX0tFWV9MRU4gKwpAQCAtMjQwLDggKzI3Niw3IEBACiBzdGF0aWMgdm9pZCAqIGVhcF90bHNfaW5pdF9mb3JfcmVhdXRoKHN0cnVjdCBlYXBfc20gKnNtLCB2b2lkICpwcml2KQogewogCXN0cnVjdCBlYXBfdGxzX2RhdGEgKmRhdGEgPSBwcml2OwotCW9zX2ZyZWUoZGF0YS0+a2V5X2RhdGEpOwotCWRhdGEtPmtleV9kYXRhID0gTlVMTDsKKwllYXBfdGxzX2ZyZWVfa2V5KGRhdGEpOwogCW9zX2ZyZWUoZGF0YS0+c2Vzc2lvbl9pZCk7CiAJZGF0YS0+c2Vzc2lvbl9pZCA9IE5VTEw7CiAJaWYgKGVhcF9wZWVyX3Rsc19yZWF1dGhfaW5pdChzbSwgJmRhdGEtPnNzbCkpIHsKQEAgLTM4MiwzICs0MTcsMzUgQEAKIAlyZXR1cm4gcmV0OwogfQogI2VuZGlmIC8qIEVBUF9VTkFVVEhfVExTICovCisKKworI2lmZGVmIENPTkZJR19IUzIwCitpbnQgZWFwX3BlZXJfd2ZhX3VuYXV0aF90bHNfcmVnaXN0ZXIodm9pZCkKK3sKKwlzdHJ1Y3QgZWFwX21ldGhvZCAqZWFwOworCWludCByZXQ7CisKKwllYXAgPSBlYXBfcGVlcl9tZXRob2RfYWxsb2MoRUFQX1BFRVJfTUVUSE9EX0lOVEVSRkFDRV9WRVJTSU9OLAorCQkJCSAgICBFQVBfVkVORE9SX1dGQV9ORVcsCisJCQkJICAgIEVBUF9WRU5ET1JfV0ZBX1VOQVVUSF9UTFMsCisJCQkJICAgICJXRkEtVU5BVVRILVRMUyIpOworCWlmIChlYXAgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJZWFwLT5pbml0ID0gZWFwX3dmYV91bmF1dGhfdGxzX2luaXQ7CisJZWFwLT5kZWluaXQgPSBlYXBfdGxzX2RlaW5pdDsKKwllYXAtPnByb2Nlc3MgPSBlYXBfdGxzX3Byb2Nlc3M7CisJZWFwLT5pc0tleUF2YWlsYWJsZSA9IGVhcF90bHNfaXNLZXlBdmFpbGFibGU7CisJZWFwLT5nZXRLZXkgPSBlYXBfdGxzX2dldEtleTsKKwllYXAtPmdldF9zdGF0dXMgPSBlYXBfdGxzX2dldF9zdGF0dXM7CisJZWFwLT5oYXNfcmVhdXRoX2RhdGEgPSBlYXBfdGxzX2hhc19yZWF1dGhfZGF0YTsKKwllYXAtPmRlaW5pdF9mb3JfcmVhdXRoID0gZWFwX3Rsc19kZWluaXRfZm9yX3JlYXV0aDsKKwllYXAtPmluaXRfZm9yX3JlYXV0aCA9IGVhcF90bHNfaW5pdF9mb3JfcmVhdXRoOworCWVhcC0+Z2V0X2Vtc2sgPSBlYXBfdGxzX2dldF9lbXNrOworCisJcmV0ID0gZWFwX3BlZXJfbWV0aG9kX3JlZ2lzdGVyKGVhcCk7CisJaWYgKHJldCkKKwkJZWFwX3BlZXJfbWV0aG9kX2ZyZWUoZWFwKTsKKwlyZXR1cm4gcmV0OworfQorI2VuZGlmIC8qIENPTkZJR19IUzIwICovCmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3Rsc19jb21tb24uYyBiL3NyYy9lYXBfcGVlci9lYXBfdGxzX2NvbW1vbi5jCmluZGV4IGJlOGMzMDEuLmZlOWJmZTAgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9lYXBfdGxzX2NvbW1vbi5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfdGxzX2NvbW1vbi5jCkBAIC0yMyw2ICsyMywxMCBAQAogCQlyZXR1cm4gZWFwX21zZ19hbGxvYyhFQVBfVkVORE9SX1VOQVVUSF9UTFMsCiAJCQkJICAgICBFQVBfVkVORE9SX1RZUEVfVU5BVVRIX1RMUywgcGF5bG9hZF9sZW4sCiAJCQkJICAgICBjb2RlLCBpZGVudGlmaWVyKTsKKwlpZiAodHlwZSA9PSBFQVBfV0ZBX1VOQVVUSF9UTFNfVFlQRSkKKwkJcmV0dXJuIGVhcF9tc2dfYWxsb2MoRUFQX1ZFTkRPUl9XRkFfTkVXLAorCQkJCSAgICAgRUFQX1ZFTkRPUl9XRkFfVU5BVVRIX1RMUywgcGF5bG9hZF9sZW4sCisJCQkJICAgICBjb2RlLCBpZGVudGlmaWVyKTsKIAlyZXR1cm4gZWFwX21zZ19hbGxvYyhFQVBfVkVORE9SX0lFVEYsIHR5cGUsIHBheWxvYWRfbGVuLCBjb2RlLAogCQkJICAgICBpZGVudGlmaWVyKTsKIH0KQEAgLTY0LDYgKzY4LDE0IEBACiAJCXBhcmFtcy0+ZmxhZ3MgfD0gVExTX0NPTk5fRElTQUJMRV9TRVNTSU9OX1RJQ0tFVDsKIAlpZiAob3Nfc3Ryc3RyKHR4dCwgInRsc19kaXNhYmxlX3Nlc3Npb25fdGlja2V0PTAiKSkKIAkJcGFyYW1zLT5mbGFncyAmPSB+VExTX0NPTk5fRElTQUJMRV9TRVNTSU9OX1RJQ0tFVDsKKwlpZiAob3Nfc3Ryc3RyKHR4dCwgInRsc19kaXNhYmxlX3Rsc3YxXzE9MSIpKQorCQlwYXJhbXMtPmZsYWdzIHw9IFRMU19DT05OX0RJU0FCTEVfVExTdjFfMTsKKwlpZiAob3Nfc3Ryc3RyKHR4dCwgInRsc19kaXNhYmxlX3Rsc3YxXzE9MCIpKQorCQlwYXJhbXMtPmZsYWdzICY9IH5UTFNfQ09OTl9ESVNBQkxFX1RMU3YxXzE7CisJaWYgKG9zX3N0cnN0cih0eHQsICJ0bHNfZGlzYWJsZV90bHN2MV8yPTEiKSkKKwkJcGFyYW1zLT5mbGFncyB8PSBUTFNfQ09OTl9ESVNBQkxFX1RMU3YxXzI7CisJaWYgKG9zX3N0cnN0cih0eHQsICJ0bHNfZGlzYWJsZV90bHN2MV8yPTAiKSkKKwkJcGFyYW1zLT5mbGFncyAmPSB+VExTX0NPTk5fRElTQUJMRV9UTFN2MV8yOwogfQogCiAKQEAgLTc4LDYgKzkwLDcgQEAKIAlwYXJhbXMtPmRoX2ZpbGUgPSAoY2hhciAqKSBjb25maWctPmRoX2ZpbGU7CiAJcGFyYW1zLT5zdWJqZWN0X21hdGNoID0gKGNoYXIgKikgY29uZmlnLT5zdWJqZWN0X21hdGNoOwogCXBhcmFtcy0+YWx0c3ViamVjdF9tYXRjaCA9IChjaGFyICopIGNvbmZpZy0+YWx0c3ViamVjdF9tYXRjaDsKKwlwYXJhbXMtPnN1ZmZpeF9tYXRjaCA9IGNvbmZpZy0+ZG9tYWluX3N1ZmZpeF9tYXRjaDsKIAlwYXJhbXMtPmVuZ2luZSA9IGNvbmZpZy0+ZW5naW5lOwogCXBhcmFtcy0+ZW5naW5lX2lkID0gY29uZmlnLT5lbmdpbmVfaWQ7CiAJcGFyYW1zLT5waW4gPSBjb25maWctPnBpbjsKQEAgLTk5LDYgKzExMiw3IEBACiAJcGFyYW1zLT5kaF9maWxlID0gKGNoYXIgKikgY29uZmlnLT5kaF9maWxlMjsKIAlwYXJhbXMtPnN1YmplY3RfbWF0Y2ggPSAoY2hhciAqKSBjb25maWctPnN1YmplY3RfbWF0Y2gyOwogCXBhcmFtcy0+YWx0c3ViamVjdF9tYXRjaCA9IChjaGFyICopIGNvbmZpZy0+YWx0c3ViamVjdF9tYXRjaDI7CisJcGFyYW1zLT5zdWZmaXhfbWF0Y2ggPSBjb25maWctPmRvbWFpbl9zdWZmaXhfbWF0Y2gyOwogCXBhcmFtcy0+ZW5naW5lID0gY29uZmlnLT5lbmdpbmUyOwogCXBhcmFtcy0+ZW5naW5lX2lkID0gY29uZmlnLT5lbmdpbmUyX2lkOwogCXBhcmFtcy0+cGluID0gY29uZmlnLT5waW4yOwpAQCAtODM2LDYgKzg1MCwxMCBAQAogCQlwb3MgPSBlYXBfaGRyX3ZhbGlkYXRlKEVBUF9WRU5ET1JfVU5BVVRIX1RMUywKIAkJCQkgICAgICAgRUFQX1ZFTkRPUl9UWVBFX1VOQVVUSF9UTFMsIHJlcURhdGEsCiAJCQkJICAgICAgICZsZWZ0KTsKKwllbHNlIGlmIChlYXBfdHlwZSA9PSBFQVBfV0ZBX1VOQVVUSF9UTFNfVFlQRSkKKwkJcG9zID0gZWFwX2hkcl92YWxpZGF0ZShFQVBfVkVORE9SX1dGQV9ORVcsCisJCQkJICAgICAgIEVBUF9WRU5ET1JfV0ZBX1VOQVVUSF9UTFMsIHJlcURhdGEsCisJCQkJICAgICAgICZsZWZ0KTsKIAllbHNlCiAJCXBvcyA9IGVhcF9oZHJfdmFsaWRhdGUoRUFQX1ZFTkRPUl9JRVRGLCBlYXBfdHlwZSwgcmVxRGF0YSwKIAkJCQkgICAgICAgJmxlZnQpOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF90bHNfY29tbW9uLmggYi9zcmMvZWFwX3BlZXIvZWFwX3Rsc19jb21tb24uaAppbmRleCAxYTVlMGY4Li4zOTBjMjE2IDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3Rsc19jb21tb24uaAorKysgYi9zcmMvZWFwX3BlZXIvZWFwX3Rsc19jb21tb24uaApAQCAtODcsNiArODcsNyBAQAogCiAvKiBkdW1teSB0eXBlIHVzZWQgYXMgYSBmbGFnIGZvciBVTkFVVEgtVExTICovCiAjZGVmaW5lIEVBUF9VTkFVVEhfVExTX1RZUEUgMjU1CisjZGVmaW5lIEVBUF9XRkFfVU5BVVRIX1RMU19UWVBFIDI1NAogCiAKIGludCBlYXBfcGVlcl90bHNfc3NsX2luaXQoc3RydWN0IGVhcF9zbSAqc20sIHN0cnVjdCBlYXBfc3NsX2RhdGEgKmRhdGEsCmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3RuYy5jIGIvc3JjL2VhcF9wZWVyL2VhcF90bmMuYwppbmRleCBiYzEzNjQ3Li4yNWI5ZjEyIDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3RuYy5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfdG5jLmMKQEAgLTI0Myw3ICsyNDMsOCBAQAogCQltZXNzYWdlX2xlbmd0aCA9IFdQQV9HRVRfQkUzMihwb3MpOwogCQlwb3MgKz0gNDsKIAotCQlpZiAobWVzc2FnZV9sZW5ndGggPCAodTMyKSAoZW5kIC0gcG9zKSkgeworCQlpZiAobWVzc2FnZV9sZW5ndGggPCAodTMyKSAoZW5kIC0gcG9zKSB8fAorCQkgICAgbWVzc2FnZV9sZW5ndGggPiA3NTAwMCkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtVE5DOiBJbnZhbGlkIE1lc3NhZ2UgIgogCQkJCSAgICJMZW5ndGggKCVkOyAlbGQgcmVtYWluaW5nIGluIHRoaXMgbXNnKSIsCiAJCQkJICAgbWVzc2FnZV9sZW5ndGgsIChsb25nKSAoZW5kIC0gcG9zKSk7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3R0bHMuYyBiL3NyYy9lYXBfcGVlci9lYXBfdHRscy5jCmluZGV4IDUwOTFiZjAuLjc3MWRhNTggMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9lYXBfdHRscy5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfdHRscy5jCkBAIC0xMzMsNiArMTMzLDE1IEBACiB9CiAKIAorc3RhdGljIHZvaWQgZWFwX3R0bHNfZnJlZV9rZXkoc3RydWN0IGVhcF90dGxzX2RhdGEgKmRhdGEpCit7CisJaWYgKGRhdGEtPmtleV9kYXRhKSB7CisJCWJpbl9jbGVhcl9mcmVlKGRhdGEtPmtleV9kYXRhLCBFQVBfVExTX0tFWV9MRU4pOworCQlkYXRhLT5rZXlfZGF0YSA9IE5VTEw7CisJfQorfQorCisKIHN0YXRpYyB2b2lkIGVhcF90dGxzX2RlaW5pdChzdHJ1Y3QgZWFwX3NtICpzbSwgdm9pZCAqcHJpdikKIHsKIAlzdHJ1Y3QgZWFwX3R0bHNfZGF0YSAqZGF0YSA9IHByaXY7CkBAIC0xNDEsNyArMTUwLDcgQEAKIAllYXBfdHRsc19waGFzZTJfZWFwX2RlaW5pdChzbSwgZGF0YSk7CiAJb3NfZnJlZShkYXRhLT5waGFzZTJfZWFwX3R5cGVzKTsKIAllYXBfcGVlcl90bHNfc3NsX2RlaW5pdChzbSwgJmRhdGEtPnNzbCk7Ci0Jb3NfZnJlZShkYXRhLT5rZXlfZGF0YSk7CisJZWFwX3R0bHNfZnJlZV9rZXkoZGF0YSk7CiAJb3NfZnJlZShkYXRhLT5zZXNzaW9uX2lkKTsKIAl3cGFidWZfZnJlZShkYXRhLT5wZW5kaW5nX3BoYXNlMl9yZXEpOwogCW9zX2ZyZWUoZGF0YSk7CkBAIC0yMTMsNyArMjIyLDcgQEAKIHN0YXRpYyBpbnQgZWFwX3R0bHNfdjBfZGVyaXZlX2tleShzdHJ1Y3QgZWFwX3NtICpzbSwKIAkJCQkgIHN0cnVjdCBlYXBfdHRsc19kYXRhICpkYXRhKQogewotCW9zX2ZyZWUoZGF0YS0+a2V5X2RhdGEpOworCWVhcF90dGxzX2ZyZWVfa2V5KGRhdGEpOwogCWRhdGEtPmtleV9kYXRhID0gZWFwX3BlZXJfdGxzX2Rlcml2ZV9rZXkoc20sICZkYXRhLT5zc2wsCiAJCQkJCQkgInR0bHMga2V5aW5nIG1hdGVyaWFsIiwKIAkJCQkJCSBFQVBfVExTX0tFWV9MRU4pOwpAQCAtNDkyLDE2ICs1MDEsNiBAQAogCXdwYWJ1Zl9wdXQobXNnLCBwb3MgLSBidWYpOwogCSpyZXNwID0gbXNnOwogCi0JaWYgKHNtLT53b3JrYXJvdW5kKSB7Ci0JCS8qIEF0IGxlYXN0IEZyZWVSQURJVVMgc2VlbXMgdG8gYmUgdGVybWluYXRpbmcKLQkJICogRUFQLVRUTFMvTVNIQ0FQVjIgd2l0aG91dCB0aGUgZXhwZWN0ZWQgTVMtQ0hBUC12MiBTdWNjZXNzCi0JCSAqIHBhY2tldC4gKi8KLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtVFRMUy9NU0NIQVBWMjogRUFQIHdvcmthcm91bmQgLSAiCi0JCQkgICAiYWxsb3cgc3VjY2VzcyB3aXRob3V0IHR1bm5lbGVkIHJlc3BvbnNlIik7Ci0JCXJldC0+bWV0aG9kU3RhdGUgPSBNRVRIT0RfTUFZX0NPTlQ7Ci0JCXJldC0+ZGVjaXNpb24gPSBERUNJU0lPTl9DT05EX1NVQ0M7Ci0JfQotCiAJcmV0dXJuIDA7CiAjZWxzZSAvKiBFQVBfTVNDSEFQdjIgKi8KIAl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkVBUC1UVExTOiBNU0NIQVB2MiBub3QgaW5jbHVkZWQgaW4gdGhlIGJ1aWxkIik7CkBAIC0xNTQwLDggKzE1MzksNyBAQAogc3RhdGljIHZvaWQgKiBlYXBfdHRsc19pbml0X2Zvcl9yZWF1dGgoc3RydWN0IGVhcF9zbSAqc20sIHZvaWQgKnByaXYpCiB7CiAJc3RydWN0IGVhcF90dGxzX2RhdGEgKmRhdGEgPSBwcml2OwotCW9zX2ZyZWUoZGF0YS0+a2V5X2RhdGEpOwotCWRhdGEtPmtleV9kYXRhID0gTlVMTDsKKwllYXBfdHRsc19mcmVlX2tleShkYXRhKTsKIAlvc19mcmVlKGRhdGEtPnNlc3Npb25faWQpOwogCWRhdGEtPnNlc3Npb25faWQgPSBOVUxMOwogCWlmIChlYXBfcGVlcl90bHNfcmVhdXRoX2luaXQoc20sICZkYXRhLT5zc2wpKSB7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3dzYy5jIGIvc3JjL2VhcF9wZWVyL2VhcF93c2MuYwppbmRleCA4ZWRiMWNhLi4yM2U5ODIzIDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3dzYy5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfd3NjLmMKQEAgLTEwNiw4ICsxMDYsMTAgQEAKIAl9CiAJaWYgKG9zX3N0cm5jbXAocG9zICsgOSwgIk5PTkUiLCA0KSA9PSAwKQogCQljcmVkLT5lbmNyX3R5cGUgPSBXUFNfRU5DUl9OT05FOworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKIAllbHNlIGlmIChvc19zdHJuY21wKHBvcyArIDksICJXRVAiLCAzKSA9PSAwKQogCQljcmVkLT5lbmNyX3R5cGUgPSBXUFNfRU5DUl9XRVA7CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLwogCWVsc2UgaWYgKG9zX3N0cm5jbXAocG9zICsgOSwgIlRLSVAiLCA0KSA9PSAwKQogCQljcmVkLT5lbmNyX3R5cGUgPSBXUFNfRU5DUl9US0lQOwogCWVsc2UgaWYgKG9zX3N0cm5jbXAocG9zICsgOSwgIkNDTVAiLCA0KSA9PSAwKQpAQCAtMTQ0LDEyICsxNDYsMTMgQEAKIAlzaXplX3QgaWRlbnRpdHlfbGVuOwogCWludCByZWdpc3RyYXI7CiAJc3RydWN0IHdwc19jb25maWcgY2ZnOwotCWNvbnN0IGNoYXIgKnBvczsKKwljb25zdCBjaGFyICpwb3MsICplbmQ7CiAJY29uc3QgY2hhciAqcGhhc2UxOwogCXN0cnVjdCB3cHNfY29udGV4dCAqd3BzOwogCXN0cnVjdCB3cHNfY3JlZGVudGlhbCBuZXdfYXBfc2V0dGluZ3M7CiAJaW50IHJlczsKIAlpbnQgbmZjID0gMDsKKwl1OCBwa2hhc2hbV1BTX09PQl9QVUJLRVlfSEFTSF9MRU5dOwogCiAJd3BzID0gc20tPndwczsKIAlpZiAod3BzID09IE5VTEwpIHsKQEAgLTIwOSw2ICsyMTIsMTUgQEAKIAkJCWNmZy5wYmMgPSAxOwogCX0KIAorCXBvcyA9IG9zX3N0cnN0cihwaGFzZTEsICJkZXZfcHdfaWQ9Iik7CisJaWYgKHBvcykgeworCQl1MTYgaWQgPSBhdG9pKHBvcyArIDEwKTsKKwkJaWYgKGlkID09IERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUikKKwkJCW5mYyA9IDE7CisJCWlmIChjZmcucGluIHx8IGlkID09IERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUikKKwkJCWNmZy5kZXZfcHdfaWQgPSBpZDsKKwl9CisKIAlpZiAoY2ZnLnBpbiA9PSBOVUxMICYmICFjZmcucGJjICYmICFuZmMpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1XU0M6IFBJTiBvciBQQkMgbm90IHNldCBpbiBwaGFzZTEgIgogCQkJICAgImNvbmZpZ3VyYXRpb24gZGF0YSIpOwpAQCAtMjE2LDkgKzIyOCwyMyBAQAogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlwb3MgPSBvc19zdHJzdHIocGhhc2UxLCAiZGV2X3B3X2lkPSIpOwotCWlmIChwb3MgJiYgY2ZnLnBpbikKLQkJY2ZnLmRldl9wd19pZCA9IGF0b2kocG9zICsgMTApOworCXBvcyA9IG9zX3N0cnN0cihwaGFzZTEsICIgcGtoYXNoPSIpOworCWlmIChwb3MpIHsKKwkJc2l6ZV90IGxlbjsKKwkJcG9zICs9IDg7CisJCWVuZCA9IG9zX3N0cmNocihwb3MsICcgJyk7CisJCWlmIChlbmQpCisJCQlsZW4gPSBlbmQgLSBwb3M7CisJCWVsc2UKKwkJCWxlbiA9IG9zX3N0cmxlbihwb3MpOworCQlpZiAobGVuICE9IDIgKiBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiB8fAorCQkgICAgaGV4c3RyMmJpbihwb3MsIHBraGFzaCwgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVdTQzogSW52YWxpZCBwa2hhc2giKTsKKwkJCW9zX2ZyZWUoZGF0YSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQljZmcucGVlcl9wdWJrZXlfaGFzaCA9IHBraGFzaDsKKwl9CiAKIAlyZXMgPSBlYXBfd3NjX25ld19hcF9zZXR0aW5ncygmbmV3X2FwX3NldHRpbmdzLCBwaGFzZTEpOwogCWlmIChyZXMgPCAwKSB7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvaWtldjIuYyBiL3NyYy9lYXBfcGVlci9pa2V2Mi5jCmluZGV4IGZjZjQ3MTIuLjgxODZhZmIgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9pa2V2Mi5jCisrKyBiL3NyYy9lYXBfcGVlci9pa2V2Mi5jCkBAIC03MiwyNyArNzIsMTAgQEAKIAlvc19tZW1jcHkocG9zLCBkYXRhLT5pX3NwaSwgSUtFVjJfU1BJX0xFTik7CiAJcG9zICs9IElLRVYyX1NQSV9MRU47CiAJb3NfbWVtY3B5KHBvcywgZGF0YS0+cl9zcGksIElLRVYyX1NQSV9MRU4pOwotI2lmZGVmIENDTlNfUEwKLSNpZiBfX0JZVEVfT1JERVIgPT0gX19MSVRUTEVfRU5ESUFOCi0JewotCQlpbnQgaTsKLQkJdTggKnRtcCA9IHBvcyAtIElLRVYyX1NQSV9MRU47Ci0JCS8qIEluY29ycmVjdCBieXRlIHJlLW9yZGVyaW5nIG9uIGxpdHRsZSBlbmRpYW4gaG9zdHMuLiAqLwotCQlmb3IgKGkgPSAwOyBpIDwgSUtFVjJfU1BJX0xFTjsgaSsrKQotCQkJKnRtcCsrID0gZGF0YS0+aV9zcGlbSUtFVjJfU1BJX0xFTiAtIDEgLSBpXTsKLQkJZm9yIChpID0gMDsgaSA8IElLRVYyX1NQSV9MRU47IGkrKykKLQkJCSp0bXArKyA9IGRhdGEtPnJfc3BpW0lLRVYyX1NQSV9MRU4gLSAxIC0gaV07Ci0JfQotI2VuZGlmCi0jZW5kaWYgLyogQ0NOU19QTCAqLwogCiAJLyogU0tFWVNFRUQgPSBwcmYoTmkgfCBOciwgZ15pcikgKi8KIAkvKiBVc2UgemVyby1wYWRkaW5nIHBlciBSRkMgNDMwNiwgU2VjdC4gMi4xNCAqLwogCXBhZF9sZW4gPSBkYXRhLT5kaC0+cHJpbWVfbGVuIC0gd3BhYnVmX2xlbihzaGFyZWQpOwotI2lmZGVmIENDTlNfUEwKLQkvKiBTaGFyZWQgc2VjcmV0IGlzIG5vdCB6ZXJvLXBhZGRlZCBjb3JyZWN0bHkgKi8KLQlwYWRfbGVuID0gMDsKLSNlbmRpZiAvKiBDQ05TX1BMICovCiAJcGFkID0gb3NfemFsbG9jKHBhZF9sZW4gPyBwYWRfbGVuIDogMSk7CiAJaWYgKHBhZCA9PSBOVUxMKSB7CiAJCXdwYWJ1Zl9mcmVlKHNoYXJlZCk7CkBAIC0xNzksMjEgKzE2MiwxMiBAQAogCQkJCQkJICAgIlRyYW5zZm9ybSBBdHRyIGZvciBBRVMiKTsKIAkJCQkJYnJlYWs7CiAJCQkJfQotI2lmZGVmIENDTlNfUEwKLQkJCQlpZiAoV1BBX0dFVF9CRTE2KHBvcykgIT0gMHgwMDFkIC8qID8/ICovKSB7Ci0JCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSUtFVjI6IE5vdCBhICIKLQkJCQkJCSAgICJLZXkgU2l6ZSBhdHRyaWJ1dGUgZm9yICIKLQkJCQkJCSAgICJBRVMiKTsKLQkJCQkJYnJlYWs7Ci0JCQkJfQotI2Vsc2UgLyogQ0NOU19QTCAqLwogCQkJCWlmIChXUEFfR0VUX0JFMTYocG9zKSAhPSAweDgwMGUpIHsKIAkJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJS0VWMjogTm90IGEgIgogCQkJCQkJICAgIktleSBTaXplIGF0dHJpYnV0ZSBmb3IgIgogCQkJCQkJICAgIkFFUyIpOwogCQkJCQlicmVhazsKIAkJCQl9Ci0jZW5kaWYgLyogQ0NOU19QTCAqLwogCQkJCWlmIChXUEFfR0VUX0JFMTYocG9zICsgMikgIT0gMTI4KSB7CiAJCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSUtFVjI6ICIKIAkJCQkJCSAgICJVbnN1cHBvcnRlZCBBRVMga2V5IHNpemUgIgpAQCAtNDU2LDE0ICs0MzAsNiBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0jaWZkZWYgQ0NOU19QTAotCS8qIFplcm9zIGFyZSByZW1vdmVkIGluY29ycmVjdGx5IGZyb20gdGhlIGJlZ2lubmluZyBvZiB0aGUgbm9uY2VzICovCi0Jd2hpbGUgKG5pX2xlbiA+IDEgJiYgKm5pID09IDApIHsKLQkJbmlfbGVuLS07Ci0JCW5pKys7Ci0JfQotI2VuZGlmIC8qIENDTlNfUEwgKi8KLQogCWRhdGEtPmlfbm9uY2VfbGVuID0gbmlfbGVuOwogCW9zX21lbWNweShkYXRhLT5pX25vbmNlLCBuaSwgbmlfbGVuKTsKIAl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIklLRVYyOiBOaSIsCkBAIC01OTksNyArNTY1LDcgQEAKIAkJcmV0dXJuIC0xOwogCiAJaWYgKGF1dGhfbGVuICE9IHByZi0+aGFzaF9sZW4gfHwKLQkgICAgb3NfbWVtY21wKGF1dGgsIGF1dGhfZGF0YSwgYXV0aF9sZW4pICE9IDApIHsKKwkgICAgb3NfbWVtY21wX2NvbnN0KGF1dGgsIGF1dGhfZGF0YSwgYXV0aF9sZW4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIklLRVYyOiBJbnZhbGlkIEF1dGhlbnRpY2F0aW9uIERhdGEiKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiSUtFVjI6IFJlY2VpdmVkIEF1dGhlbnRpY2F0aW9uIERhdGEiLAogCQkJICAgIGF1dGgsIGF1dGhfbGVuKTsKQEAgLTg4NywxNiArODUzLDcgQEAKIAlwaGRyLT5mbGFncyA9IDA7CiAKIAlwID0gd3BhYnVmX3B1dChtc2csIHNpemVvZigqcCkpOwotI2lmZGVmIENDTlNfUEwKLQkvKiBTZWVtcyB0byByZXF1aXJlIHRoYXQgdGhlIFByb3Bvc2FsICMgaXMgMSBldmVuIHRob3VnaCBSRkMgNDMwNgotCSAqIFNlY3QgMy4zLjEgaGFzIGZvbGxvd2luZyByZXF1aXJlbWVudCAiV2hlbiBhIHByb3Bvc2FsIGlzIGFjY2VwdGVkLAotCSAqIGFsbCBvZiB0aGUgcHJvcG9zYWwgbnVtYmVycyBpbiB0aGUgU0EgcGF5bG9hZCBNVVNUIGJlIHRoZSBzYW1lIGFuZAotCSAqIE1VU1QgbWF0Y2ggdGhlIG51bWJlciBvbiB0aGUgcHJvcG9zYWwgc2VudCB0aGF0IHdhcyBhY2NlcHRlZC4iLgotCSAqLwotCXAtPnByb3Bvc2FsX251bSA9IDE7Ci0jZWxzZSAvKiBDQ05TX1BMICovCiAJcC0+cHJvcG9zYWxfbnVtID0gZGF0YS0+cHJvcG9zYWwucHJvcG9zYWxfbnVtOwotI2VuZGlmIC8qIENDTlNfUEwgKi8KIAlwLT5wcm90b2NvbF9pZCA9IElLRVYyX1BST1RPQ09MX0lLRTsKIAlwLT5udW1fdHJhbnNmb3JtcyA9IDQ7CiAKQEAgLTkwNiwxMSArODYzLDcgQEAKIAlXUEFfUFVUX0JFMTYodC0+dHJhbnNmb3JtX2lkLCBkYXRhLT5wcm9wb3NhbC5lbmNyKTsKIAlpZiAoZGF0YS0+cHJvcG9zYWwuZW5jciA9PSBFTkNSX0FFU19DQkMpIHsKIAkJLyogVHJhbnNmb3JtIEF0dHJpYnV0ZTogS2V5IExlbiA9IDEyOCBiaXRzICovCi0jaWZkZWYgQ0NOU19QTAotCQl3cGFidWZfcHV0X2JlMTYobXNnLCAweDAwMWQpOyAvKiA/PyAqLwotI2Vsc2UgLyogQ0NOU19QTCAqLwogCQl3cGFidWZfcHV0X2JlMTYobXNnLCAweDgwMGUpOyAvKiBBRj0xLCBBdHRyVHlwZT0xNCAqLwotI2VuZGlmIC8qIENDTlNfUEwgKi8KIAkJd3BhYnVmX3B1dF9iZTE2KG1zZywgMTI4KTsgLyogMTI4LWJpdCBrZXkgKi8KIAl9CiAJcGxlbiA9ICh1OCAqKSB3cGFidWZfcHV0KG1zZywgMCkgLSAodTggKikgdDsKQEAgLTEwODIsMTEgKzEwMzUsNyBAQAogCXBoZHIgPSB3cGFidWZfcHV0KG1zZywgc2l6ZW9mKCpwaGRyKSk7CiAJcGhkci0+bmV4dF9wYXlsb2FkID0gbmV4dF9wYXlsb2FkOwogCXBoZHItPmZsYWdzID0gMDsKLSNpZmRlZiBDQ05TX1BMCi0Jd3BhYnVmX3B1dF91OChtc2csIDEpOyAvKiBQcm90b2NvbCBJRDogSUtFX1NBIG5vdGlmaWNhdGlvbiAqLwotI2Vsc2UgLyogQ0NOU19QTCAqLwogCXdwYWJ1Zl9wdXRfdTgobXNnLCAwKTsgLyogUHJvdG9jb2wgSUQ6IG5vIGV4aXN0aW5nIFNBICovCi0jZW5kaWYgLyogQ0NOU19QTCAqLwogCXdwYWJ1Zl9wdXRfdTgobXNnLCAwKTsgLyogU1BJIFNpemUgKi8KIAl3cGFidWZfcHV0X2JlMTYobXNnLCBkYXRhLT5lcnJvcl90eXBlKTsKIApAQCAtMTEzMCwxMyArMTA3OSw2IEBACiAJZGF0YS0+cl9ub25jZV9sZW4gPSBJS0VWMl9OT05DRV9NSU5fTEVOOwogCWlmIChyYW5kb21fZ2V0X2J5dGVzKGRhdGEtPnJfbm9uY2UsIGRhdGEtPnJfbm9uY2VfbGVuKSkKIAkJcmV0dXJuIE5VTEw7Ci0jaWZkZWYgQ0NOU19QTAotCS8qIFplcm9zIGFyZSByZW1vdmVkIGluY29ycmVjdGx5IGZyb20gdGhlIGJlZ2lubmluZyBvZiB0aGUgbm9uY2VzIGluCi0JICoga2V5IGRlcml2YXRpb247IGFzIGEgd29ya2Fyb3VuZCwgbWFrZSBzdXJlIE5yIGRvZXMgbm90IHN0YXJ0IHdpdGgKLQkgKiB6ZXJvLi4gKi8KLQlpZiAoZGF0YS0+cl9ub25jZVswXSA9PSAwKQotCQlkYXRhLT5yX25vbmNlWzBdID0gMTsKLSNlbmRpZiAvKiBDQ05TX1BMICovCiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiSUtFVjI6IE5yIiwgZGF0YS0+cl9ub25jZSwgZGF0YS0+cl9ub25jZV9sZW4pOwogCiAJbXNnID0gd3BhYnVmX2FsbG9jKHNpemVvZihzdHJ1Y3QgaWtldjJfaGRyKSArIGRhdGEtPklEcl9sZW4gKyAxNTAwKTsKQEAgLTEyNTcsNiArMTE5OSw3IEBACiAJCQl3cGFidWZfZnJlZShtc2cpOwogCQkJcmV0dXJuIE5VTEw7CiAJCX0KKwkJd3BhYnVmX2ZyZWUocGxhaW4pOwogCQlkYXRhLT5zdGF0ZSA9IElLRVYyX0ZBSUxFRDsKIAl9IGVsc2UgewogCQkvKiBIRFIsIE4gKi8KZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9tc2NoYXB2Mi5jIGIvc3JjL2VhcF9wZWVyL21zY2hhcHYyLmMKaW5kZXggMzdlNjczNS4uOWJjNzM3MCAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL21zY2hhcHYyLmMKKysrIGIvc3JjL2VhcF9wZWVyL21zY2hhcHYyLmMKQEAgLTExNyw4ICsxMTcsOCBAQAogCSAgICBidWZbMF0gIT0gJ1MnIHx8IGJ1ZlsxXSAhPSAnPScgfHwKIAkgICAgaGV4c3RyMmJpbigoY2hhciAqKSAoYnVmICsgMiksIHJlY3ZfcmVzcG9uc2UsCiAJCSAgICAgICBNU0NIQVBWMl9BVVRIX1JFU1BPTlNFX0xFTikgfHwKLQkgICAgb3NfbWVtY21wKGF1dGhfcmVzcG9uc2UsIHJlY3ZfcmVzcG9uc2UsCi0JCSAgICAgIE1TQ0hBUFYyX0FVVEhfUkVTUE9OU0VfTEVOKSAhPSAwKQorCSAgICBvc19tZW1jbXBfY29uc3QoYXV0aF9yZXNwb25zZSwgcmVjdl9yZXNwb25zZSwKKwkJCSAgICBNU0NIQVBWMl9BVVRIX1JFU1BPTlNFX0xFTikgIT0gMCkKIAkJcmV0dXJuIC0xOwogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL3RuY2MuYyBiL3NyYy9lYXBfcGVlci90bmNjLmMKaW5kZXggYTNlYzM5NS4uN2NhOTU2ZSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL3RuY2MuYworKysgYi9zcmMvZWFwX3BlZXIvdG5jYy5jCkBAIC0xMyw2ICsxMyw3IEBACiAKICNpbmNsdWRlICJjb21tb24uaCIKICNpbmNsdWRlICJiYXNlNjQuaCIKKyNpbmNsdWRlICJjb21tb24vdG5jLmgiCiAjaW5jbHVkZSAidG5jYy5oIgogI2luY2x1ZGUgImVhcF9jb21tb24vZWFwX3Rsdl9jb21tb24uaCIKICNpbmNsdWRlICJlYXBfY29tbW9uL2VhcF9kZWZzLmgiCkBAIC0yNSw3ICsyNiw5IEBACiAjZW5kaWYgLyogVU5JQ09ERSAqLwogCiAKKyNpZm5kZWYgVE5DX0NPTkZJR19GSUxFCiAjZGVmaW5lIFROQ19DT05GSUdfRklMRSAiL2V0Yy90bmNfY29uZmlnIgorI2VuZGlmIC8qIFROQ19DT05GSUdfRklMRSAqLwogI2RlZmluZSBUTkNfV0lOUkVHX1BBVEggVEVYVCgiU09GVFdBUkVcXFRydXN0ZWQgQ29tcHV0aW5nIEdyb3VwXFxUTkNcXElNQ3MiKQogI2RlZmluZSBJRl9UTkNDU19TVEFSVCBcCiAiPD94bWwgdmVyc2lvbj1cIjEuMFwiPz5cbiIgXApAQCAtMzgsNTYgKzQxLDYgQEAKIAogLyogVE5DIElGLUlNQyAqLwogCi10eXBlZGVmIHVuc2lnbmVkIGxvbmcgVE5DX1VJbnQzMjsKLXR5cGVkZWYgdW5zaWduZWQgY2hhciAqVE5DX0J1ZmZlclJlZmVyZW5jZTsKLQotdHlwZWRlZiBUTkNfVUludDMyIFROQ19JTUNJRDsKLXR5cGVkZWYgVE5DX1VJbnQzMiBUTkNfQ29ubmVjdGlvbklEOwotdHlwZWRlZiBUTkNfVUludDMyIFROQ19Db25uZWN0aW9uU3RhdGU7Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX1JldHJ5UmVhc29uOwotdHlwZWRlZiBUTkNfVUludDMyIFROQ19NZXNzYWdlVHlwZTsKLXR5cGVkZWYgVE5DX01lc3NhZ2VUeXBlICpUTkNfTWVzc2FnZVR5cGVMaXN0OwotdHlwZWRlZiBUTkNfVUludDMyIFROQ19WZW5kb3JJRDsKLXR5cGVkZWYgVE5DX1VJbnQzMiBUTkNfTWVzc2FnZVN1YnR5cGU7Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX1ZlcnNpb247Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX1Jlc3VsdDsKLQotdHlwZWRlZiBUTkNfUmVzdWx0ICgqVE5DX1ROQ0NfQmluZEZ1bmN0aW9uUG9pbnRlcikoCi0JVE5DX0lNQ0lEIGltY0lELAotCWNoYXIgKmZ1bmN0aW9uTmFtZSwKLQl2b2lkICoqcE91dGZ1bmN0aW9uUG9pbnRlcik7Ci0KLSNkZWZpbmUgVE5DX1JFU1VMVF9TVUNDRVNTIDAKLSNkZWZpbmUgVE5DX1JFU1VMVF9OT1RfSU5JVElBTElaRUQgMQotI2RlZmluZSBUTkNfUkVTVUxUX0FMUkVBRFlfSU5JVElBTElaRUQgMgotI2RlZmluZSBUTkNfUkVTVUxUX05PX0NPTU1PTl9WRVJTSU9OIDMKLSNkZWZpbmUgVE5DX1JFU1VMVF9DQU5UX1JFVFJZIDQKLSNkZWZpbmUgVE5DX1JFU1VMVF9XT05UX1JFVFJZIDUKLSNkZWZpbmUgVE5DX1JFU1VMVF9JTlZBTElEX1BBUkFNRVRFUiA2Ci0jZGVmaW5lIFROQ19SRVNVTFRfQ0FOVF9SRVNQT05EIDcKLSNkZWZpbmUgVE5DX1JFU1VMVF9JTExFR0FMX09QRVJBVElPTiA4Ci0jZGVmaW5lIFROQ19SRVNVTFRfT1RIRVIgOQotI2RlZmluZSBUTkNfUkVTVUxUX0ZBVEFMIDEwCi0KLSNkZWZpbmUgVE5DX0NPTk5FQ1RJT05fU1RBVEVfQ1JFQVRFIDAKLSNkZWZpbmUgVE5DX0NPTk5FQ1RJT05fU1RBVEVfSEFORFNIQUtFIDEKLSNkZWZpbmUgVE5DX0NPTk5FQ1RJT05fU1RBVEVfQUNDRVNTX0FMTE9XRUQgMgotI2RlZmluZSBUTkNfQ09OTkVDVElPTl9TVEFURV9BQ0NFU1NfSVNPTEFURUQgMwotI2RlZmluZSBUTkNfQ09OTkVDVElPTl9TVEFURV9BQ0NFU1NfTk9ORSA0Ci0jZGVmaW5lIFROQ19DT05ORUNUSU9OX1NUQVRFX0RFTEVURSA1Ci0KLSNkZWZpbmUgVE5DX0lGSU1DX1ZFUlNJT05fMSAxCi0KLSNkZWZpbmUgVE5DX1ZFTkRPUklEX0FOWSAoKFROQ19WZW5kb3JJRCkgMHhmZmZmZmYpCi0jZGVmaW5lIFROQ19TVUJUWVBFX0FOWSAoKFROQ19NZXNzYWdlU3VidHlwZSkgMHhmZikKLQotLyogVE5DQy1UTkNTIE1lc3NhZ2UgVHlwZXMgKi8KLSNkZWZpbmUgVE5DX1ROQ0NTX1JFQ09NTUVOREFUSU9OCQkweDAwMDAwMDAxCi0jZGVmaW5lIFROQ19UTkNDU19FUlJPUgkJCQkweDAwMDAwMDAyCi0jZGVmaW5lIFROQ19UTkNDU19QUkVGRVJSRURMQU5HVUFHRQkJMHgwMDAwMDAwMwotI2RlZmluZSBUTkNfVE5DQ1NfUkVBU09OU1RSSU5HUwkJCTB4MDAwMDAwMDQKLQotCiAvKiBJRi1UTkNDUy1TT0ggLSBTU29IIGFuZCBTU29IUiBBdHRyaWJ1dGVzICovCiBlbnVtIHsKIAlTU09IX01TX01BQ0hJTkVfSU5WRU5UT1JZID0gMSwKQEAgLTExMzksOCArMTA5MiwxMCBAQAogCQkJaW50IGVycm9yID0gMDsKIAogCQkJaW1jID0gdG5jY19wYXJzZV9pbWMocG9zICsgNCwgbGluZV9lbmQsICZlcnJvcik7Ci0JCQlpZiAoZXJyb3IpCisJCQlpZiAoZXJyb3IpIHsKKwkJCQlvc19mcmVlKGNvbmZpZyk7CiAJCQkJcmV0dXJuIC0xOworCQkJfQogCQkJaWYgKGltYykgewogCQkJCWlmIChsYXN0ID09IE5VTEwpCiAJCQkJCXRuY2MtPmltYyA9IGltYzsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL01ha2VmaWxlIGIvc3JjL2VhcF9zZXJ2ZXIvTWFrZWZpbGUKaW5kZXggOWM0MTk2Mi4uYWRmZDNkZiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvTWFrZWZpbGUKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvTWFrZWZpbGUKQEAgLTIsNyArMiw3IEBACiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgogCiBjbGVhbjoKLQlybSAtZiAqfiAqLm8gKi5kCisJcm0gLWYgKn4gKi5vICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgogCiBpbnN0YWxsOgogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcC5oIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwLmgKaW5kZXggMzZiMjMwYi4uMTI1M2JkNiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwLmgKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwLmgKQEAgLTMyLDggKzMyLDExIEBACiAJCQkgICAgKiBudF9wYXNzd29yZF9oYXNoKCkgKi8KIAlpbnQgcGhhc2UyOwogCWludCBmb3JjZV92ZXJzaW9uOworCXVuc2lnbmVkIGludCByZW1lZGlhdGlvbjoxOworCXVuc2lnbmVkIGludCBtYWNhY2w6MTsKIAlpbnQgdHRsc19hdXRoOyAvKiBiaXRmaWVsZCBvZgogCQkJKiBFQVBfVFRMU19BVVRIX3tQQVAsQ0hBUCxNU0NIQVAsTVNDSEFQVjJ9ICovCisJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmFjY2VwdF9hdHRyOwogfTsKIAogc3RydWN0IGVhcF9lYXBvbF9pbnRlcmZhY2UgewpAQCAtNzksNiArODIsNyBAQAogCWludCAoKmdldF9lYXBfdXNlcikodm9pZCAqY3R4LCBjb25zdCB1OCAqaWRlbnRpdHksIHNpemVfdCBpZGVudGl0eV9sZW4sCiAJCQkgICAgaW50IHBoYXNlMiwgc3RydWN0IGVhcF91c2VyICp1c2VyKTsKIAljb25zdCBjaGFyICogKCpnZXRfZWFwX3JlcV9pZF90ZXh0KSh2b2lkICpjdHgsIHNpemVfdCAqbGVuKTsKKwl2b2lkICgqbG9nX21zZykodm9pZCAqY3R4LCBjb25zdCBjaGFyICptc2cpOwogfTsKIAogc3RydWN0IGVhcF9jb25maWcgewpAQCAtMTA3LDYgKzExMSwxMCBAQAogCiAJY29uc3QgdTggKnNlcnZlcl9pZDsKIAlzaXplX3Qgc2VydmVyX2lkX2xlbjsKKworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKwl1MzIgdGxzX3Rlc3RfZmxhZ3M7CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLwogfTsKIAogCmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfaS5oIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX2kuaAppbmRleCAwMDNlMjAyLi4zYTY4MDJiIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfaS5oCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9pLmgKQEAgLTE5MSwxMCArMTkxLDE2IEBACiAKIAljb25zdCB1OCAqc2VydmVyX2lkOwogCXNpemVfdCBzZXJ2ZXJfaWRfbGVuOworCisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUworCXUzMiB0bHNfdGVzdF9mbGFnczsKKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCiB9OwogCiBpbnQgZWFwX3VzZXJfZ2V0KHN0cnVjdCBlYXBfc20gKnNtLCBjb25zdCB1OCAqaWRlbnRpdHksIHNpemVfdCBpZGVudGl0eV9sZW4sCiAJCSBpbnQgcGhhc2UyKTsKK3ZvaWQgZWFwX2xvZ19tc2coc3RydWN0IGVhcF9zbSAqc20sIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQorUFJJTlRGX0ZPUk1BVCgyLCAzKTsKIHZvaWQgZWFwX3NtX3Byb2Nlc3NfbmFrKHN0cnVjdCBlYXBfc20gKnNtLCBjb25zdCB1OCAqbmFrX2xpc3QsIHNpemVfdCBsZW4pOwogCiAjZW5kaWYgLyogRUFQX0lfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX21ldGhvZHMuaCBiL3NyYy9lYXBfc2VydmVyL2VhcF9tZXRob2RzLmgKaW5kZXggNDI5Y2I3Mi4uMGJhYTMyNyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX21ldGhvZHMuaAorKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfbWV0aG9kcy5oCkBAIC0yNyw2ICsyNyw3IEBACiBpbnQgZWFwX3NlcnZlcl9tZDVfcmVnaXN0ZXIodm9pZCk7CiBpbnQgZWFwX3NlcnZlcl90bHNfcmVnaXN0ZXIodm9pZCk7CiBpbnQgZWFwX3NlcnZlcl91bmF1dGhfdGxzX3JlZ2lzdGVyKHZvaWQpOworaW50IGVhcF9zZXJ2ZXJfd2ZhX3VuYXV0aF90bHNfcmVnaXN0ZXIodm9pZCk7CiBpbnQgZWFwX3NlcnZlcl9tc2NoYXB2Ml9yZWdpc3Rlcih2b2lkKTsKIGludCBlYXBfc2VydmVyX3BlYXBfcmVnaXN0ZXIodm9pZCk7CiBpbnQgZWFwX3NlcnZlcl90bHZfcmVnaXN0ZXIodm9pZCk7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyLmMgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyLmMKaW5kZXggNTRiNzUzMy4uYzFiYjZiOCAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlci5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXIuYwpAQCAtMTE5LDYgKzExOSwzMiBAQAogfQogCiAKK3ZvaWQgZWFwX2xvZ19tc2coc3RydWN0IGVhcF9zbSAqc20sIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQoreworCXZhX2xpc3QgYXA7CisJY2hhciAqYnVmOworCWludCBidWZsZW47CisKKwlpZiAoc20gPT0gTlVMTCB8fCBzbS0+ZWFwb2xfY2IgPT0gTlVMTCB8fCBzbS0+ZWFwb2xfY2ItPmxvZ19tc2cgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJdmFfc3RhcnQoYXAsIGZtdCk7CisJYnVmbGVuID0gdnNucHJpbnRmKE5VTEwsIDAsIGZtdCwgYXApICsgMTsKKwl2YV9lbmQoYXApOworCisJYnVmID0gb3NfbWFsbG9jKGJ1Zmxlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm47CisJdmFfc3RhcnQoYXAsIGZtdCk7CisJdnNucHJpbnRmKGJ1ZiwgYnVmbGVuLCBmbXQsIGFwKTsKKwl2YV9lbmQoYXApOworCisJc20tPmVhcG9sX2NiLT5sb2dfbXNnKHNtLT5lYXBvbF9jdHgsIGJ1Zik7CisKKwlvc19mcmVlKGJ1Zik7Cit9CisKKwogU01fU1RBVEUoRUFQLCBESVNBQkxFRCkKIHsKIAlTTV9FTlRSWShFQVAsIERJU0FCTEVEKTsKQEAgLTE0Miw3ICsxNjgsNyBAQAogCXNtLT5lYXBfaWYuZWFwU3VjY2VzcyA9IEZBTFNFOwogCXNtLT5lYXBfaWYuZWFwRmFpbCA9IEZBTFNFOwogCXNtLT5lYXBfaWYuZWFwVGltZW91dCA9IEZBTFNFOwotCW9zX2ZyZWUoc20tPmVhcF9pZi5lYXBLZXlEYXRhKTsKKwliaW5fY2xlYXJfZnJlZShzbS0+ZWFwX2lmLmVhcEtleURhdGEsIHNtLT5lYXBfaWYuZWFwS2V5RGF0YUxlbik7CiAJc20tPmVhcF9pZi5lYXBLZXlEYXRhID0gTlVMTDsKIAlzbS0+ZWFwX2lmLmVhcEtleURhdGFMZW4gPSAwOwogCXNtLT5lYXBfaWYuZWFwS2V5QXZhaWxhYmxlID0gRkFMU0U7CkBAIC0zMjAsNyArMzQ2LDcgQEAKIAlzbS0+bS0+cHJvY2VzcyhzbSwgc20tPmVhcF9tZXRob2RfcHJpdiwgc20tPmVhcF9pZi5lYXBSZXNwRGF0YSk7CiAJaWYgKHNtLT5tLT5pc0RvbmUoc20sIHNtLT5lYXBfbWV0aG9kX3ByaXYpKSB7CiAJCWVhcF9zbV9Qb2xpY3lfdXBkYXRlKHNtLCBOVUxMLCAwKTsKLQkJb3NfZnJlZShzbS0+ZWFwX2lmLmVhcEtleURhdGEpOworCQliaW5fY2xlYXJfZnJlZShzbS0+ZWFwX2lmLmVhcEtleURhdGEsIHNtLT5lYXBfaWYuZWFwS2V5RGF0YUxlbik7CiAJCWlmIChzbS0+bS0+Z2V0S2V5KSB7CiAJCQlzbS0+ZWFwX2lmLmVhcEtleURhdGEgPSBzbS0+bS0+Z2V0S2V5KAogCQkJCXNtLCBzbS0+ZWFwX21ldGhvZF9wcml2LApAQCAtMzQzLDYgKzM2OSw3IEBACiAKIAlTTV9FTlRSWShFQVAsIFBST1BPU0VfTUVUSE9EKTsKIAordHJ5X2Fub3RoZXJfbWV0aG9kOgogCXR5cGUgPSBlYXBfc21fUG9saWN5X2dldE5leHRNZXRob2Qoc20sICZ2ZW5kb3IpOwogCWlmICh2ZW5kb3IgPT0gRUFQX1ZFTkRPUl9JRVRGKQogCQlzbS0+Y3VycmVudE1ldGhvZCA9IHR5cGU7CkBAIC0zNjAsOCArMzg3LDE1IEBACiAJCQkJICAgIm1ldGhvZCAlZCIsIHNtLT5jdXJyZW50TWV0aG9kKTsKIAkJCXNtLT5tID0gTlVMTDsKIAkJCXNtLT5jdXJyZW50TWV0aG9kID0gRUFQX1RZUEVfTk9ORTsKKwkJCWdvdG8gdHJ5X2Fub3RoZXJfbWV0aG9kOwogCQl9CiAJfQorCWlmIChzbS0+bSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQOiBDb3VsZCBub3QgZmluZCBzdWl0YWJsZSBFQVAgbWV0aG9kIik7CisJCWVhcF9sb2dfbXNnKHNtLCAiQ291bGQgbm90IGZpbmQgc3VpdGFibGUgRUFQIG1ldGhvZCIpOworCQlzbS0+ZGVjaXNpb24gPSBERUNJU0lPTl9GQUlMVVJFOworCQlyZXR1cm47CisJfQogCWlmIChzbS0+Y3VycmVudE1ldGhvZCA9PSBFQVBfVFlQRV9JREVOVElUWSB8fAogCSAgICBzbS0+Y3VycmVudE1ldGhvZCA9PSBFQVBfVFlQRV9OT1RJRklDQVRJT04pCiAJCXNtLT5tZXRob2RTdGF0ZSA9IE1FVEhPRF9DT05USU5VRTsKQEAgLTM3MCw2ICs0MDQsOCBAQAogCiAJd3BhX21zZyhzbS0+bXNnX2N0eCwgTVNHX0lORk8sIFdQQV9FVkVOVF9FQVBfUFJPUE9TRURfTUVUSE9ECiAJCSJ2ZW5kb3I9JXUgbWV0aG9kPSV1IiwgdmVuZG9yLCBzbS0+Y3VycmVudE1ldGhvZCk7CisJZWFwX2xvZ19tc2coc20sICJQcm9wb3NlIEVBUCBtZXRob2QgdmVuZG9yPSV1IG1ldGhvZD0ldSIsCisJCSAgICB2ZW5kb3IsIHNtLT5jdXJyZW50TWV0aG9kKTsKIH0KIAogCkBAIC01OTYsNyArNjMyLDcgQEAKIAlpZiAoc20tPmVhcF9pZi5hYWFFYXBLZXlBdmFpbGFibGUpIHsKIAkJRUFQX0NPUFkoJnNtLT5lYXBfaWYuZWFwS2V5RGF0YSwgc20tPmVhcF9pZi5hYWFFYXBLZXlEYXRhKTsKIAl9IGVsc2UgewotCQlvc19mcmVlKHNtLT5lYXBfaWYuZWFwS2V5RGF0YSk7CisJCWJpbl9jbGVhcl9mcmVlKHNtLT5lYXBfaWYuZWFwS2V5RGF0YSwgc20tPmVhcF9pZi5lYXBLZXlEYXRhTGVuKTsKIAkJc20tPmVhcF9pZi5lYXBLZXlEYXRhID0gTlVMTDsKIAkJc20tPmVhcF9pZi5lYXBLZXlEYXRhTGVuID0gMDsKIAl9CkBAIC02ODYsNiArNzIyLDcgQEAKIAkJCQkgICAicmVzcE1ldGhvZD0lZCBjdXJyZW50TWV0aG9kPSVkIiwKIAkJCQkgICBzbS0+cnhSZXNwLCBzbS0+cmVzcElkLCBzbS0+Y3VycmVudElkLAogCQkJCSAgIHNtLT5yZXNwTWV0aG9kLCBzbS0+Y3VycmVudE1ldGhvZCk7CisJCQllYXBfbG9nX21zZyhzbSwgIkRpc2NhcmQgcmVjZWl2ZWQgRUFQIG1lc3NhZ2UiKTsKIAkJCVNNX0VOVEVSKEVBUCwgRElTQ0FSRCk7CiAJCX0KIAkJYnJlYWs7CkBAIC03MDIsNiArNzM5LDE1IEBACiAJCQlTTV9FTlRFUihFQVAsIE1FVEhPRF9SRVNQT05TRSk7CiAJCWJyZWFrOwogCWNhc2UgRUFQX01FVEhPRF9SRVFVRVNUOgorCQlpZiAoc20tPm0gPT0gTlVMTCkgeworCQkJLyoKKwkJCSAqIFRoaXMgdHJhbnNpdGlvbiBpcyBub3QgbWVudGlvbmVkIGluIFJGQyA0MTM3LCBidXQgaXQKKwkJCSAqIGlzIG5lZWRlZCB0byBoYW5kbGUgY2xlYW5seSBhIGNhc2Ugd2hlcmUgRUFQIG1ldGhvZAorCQkJICogaW5pdGlhbGl6YXRpb24gZmFpbHMuCisJCQkgKi8KKwkJCVNNX0VOVEVSKEVBUCwgRkFJTFVSRSk7CisJCQlicmVhazsKKwkJfQogCQlTTV9FTlRFUihFQVAsIFNFTkRfUkVRVUVTVCk7CiAJCWJyZWFrOwogCWNhc2UgRUFQX01FVEhPRF9SRVNQT05TRToKQEAgLTEyMTQsNyArMTI2MCw3IEBACiB7CiAJaWYgKHVzZXIgPT0gTlVMTCkKIAkJcmV0dXJuOwotCW9zX2ZyZWUodXNlci0+cGFzc3dvcmQpOworCWJpbl9jbGVhcl9mcmVlKHVzZXItPnBhc3N3b3JkLCB1c2VyLT5wYXNzd29yZF9sZW4pOwogCXVzZXItPnBhc3N3b3JkID0gTlVMTDsKIAlvc19mcmVlKHVzZXIpOwogfQpAQCAtMTI4MSw2ICsxMzI3LDEwIEBACiAJc20tPnNlcnZlcl9pZCA9IGNvbmYtPnNlcnZlcl9pZDsKIAlzbS0+c2VydmVyX2lkX2xlbiA9IGNvbmYtPnNlcnZlcl9pZF9sZW47CiAKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJc20tPnRsc190ZXN0X2ZsYWdzID0gY29uZi0+dGxzX3Rlc3RfZmxhZ3M7CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLworCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVA6IFNlcnZlciBzdGF0ZSBtYWNoaW5lIGNyZWF0ZWQiKTsKIAogCXJldHVybiBzbTsKQEAgLTEzMDIsNyArMTM1Miw3IEBACiAJaWYgKHNtLT5tICYmIHNtLT5lYXBfbWV0aG9kX3ByaXYpCiAJCXNtLT5tLT5yZXNldChzbSwgc20tPmVhcF9tZXRob2RfcHJpdik7CiAJd3BhYnVmX2ZyZWUoc20tPmVhcF9pZi5lYXBSZXFEYXRhKTsKLQlvc19mcmVlKHNtLT5lYXBfaWYuZWFwS2V5RGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoc20tPmVhcF9pZi5lYXBLZXlEYXRhLCBzbS0+ZWFwX2lmLmVhcEtleURhdGFMZW4pOwogCXdwYWJ1Zl9mcmVlKHNtLT5sYXN0UmVxRGF0YSk7CiAJd3BhYnVmX2ZyZWUoc20tPmVhcF9pZi5lYXBSZXNwRGF0YSk7CiAJb3NfZnJlZShzbS0+aWRlbnRpdHkpOwpAQCAtMTMxMSw3ICsxMzYxLDcgQEAKIAlvc19mcmVlKHNtLT5lYXBfZmFzdF9hX2lkX2luZm8pOwogCXdwYWJ1Zl9mcmVlKHNtLT5lYXBfaWYuYWFhRWFwUmVxRGF0YSk7CiAJd3BhYnVmX2ZyZWUoc20tPmVhcF9pZi5hYWFFYXBSZXNwRGF0YSk7Ci0Jb3NfZnJlZShzbS0+ZWFwX2lmLmFhYUVhcEtleURhdGEpOworCWJpbl9jbGVhcl9mcmVlKHNtLT5lYXBfaWYuYWFhRWFwS2V5RGF0YSwgc20tPmVhcF9pZi5hYWFFYXBLZXlEYXRhTGVuKTsKIAllYXBfdXNlcl9mcmVlKHNtLT51c2VyKTsKIAl3cGFidWZfZnJlZShzbS0+YXNzb2Nfd3BzX2llKTsKIAl3cGFidWZfZnJlZShzbS0+YXNzb2NfcDJwX2llKTsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfYWthLmMgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2FrYS5jCmluZGV4IDQ2OWI5YTAuLjA5Yjk3NmUgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfYWthLmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9ha2EuYwpAQCAtMjQxLDcgKzI0MSw3IEBACiAJb3NfZnJlZShkYXRhLT5uZXh0X3JlYXV0aF9pZCk7CiAJd3BhYnVmX2ZyZWUoZGF0YS0+aWRfbXNncyk7CiAJb3NfZnJlZShkYXRhLT5uZXR3b3JrX25hbWUpOwotCW9zX2ZyZWUoZGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiB9CiAKIApAQCAtMzM2LDcgKzMzNiw3IEBACiAJZWxzZQogCQlzaGExX3ZlY3RvcigxLCAmYWRkciwgJmxlbiwgaGFzaCk7CiAKLQlpZiAob3NfbWVtY21wKGhhc2gsIGNoZWNrY29kZSwgaGFzaF9sZW4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KGhhc2gsIGNoZWNrY29kZSwgaGFzaF9sZW4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtQUtBOiBNaXNtYXRjaCBpbiBBVF9DSEVDS0NPREUiKTsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTM3Nyw3ICszNzcsNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX1BFUk1BTkVOVF9JRF9SRVEiKTsKIAkJZWFwX3NpbV9tc2dfYWRkKG1zZywgRUFQX1NJTV9BVF9QRVJNQU5FTlRfSURfUkVRLCAwLCBOVUxMLCAwKTsKIAl9Ci0JYnVmID0gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgTlVMTCwgTlVMTCwgMCk7CisJYnVmID0gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+ZWFwX21ldGhvZCwgTlVMTCwgTlVMTCwgMCk7CiAJaWYgKGVhcF9ha2FfYWRkX2lkX21zZyhkYXRhLCBidWYpIDwgMCkgewogCQl3cGFidWZfZnJlZShidWYpOwogCQlyZXR1cm4gTlVMTDsKQEAgLTUzNCw3ICs1MzQsNyBAQAogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9NQUMiKTsKIAllYXBfc2ltX21zZ19hZGRfbWFjKG1zZywgRUFQX1NJTV9BVF9NQUMpOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5rX2F1dCwgTlVMTCwgMCk7CisJcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIGRhdGEtPmVhcF9tZXRob2QsIGRhdGEtPmtfYXV0LCBOVUxMLCAwKTsKIH0KIAogCkBAIC01ODEsNyArNTgxLDcgQEAKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAgQVRfTUFDIik7CiAJZWFwX3NpbV9tc2dfYWRkX21hYyhtc2csIEVBUF9TSU1fQVRfTUFDKTsKLQlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+a19hdXQsIE5VTEwsIDApOworCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5lYXBfbWV0aG9kLCBkYXRhLT5rX2F1dCwgTlVMTCwgMCk7CiB9CiAKIApAQCAtNjIwLDcgKzYyMCw3IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAgQVRfTUFDIik7CiAJCWVhcF9zaW1fbXNnX2FkZF9tYWMobXNnLCBFQVBfU0lNX0FUX01BQyk7CiAJfQotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5rX2F1dCwgTlVMTCwgMCk7CisJcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIGRhdGEtPmVhcF9tZXRob2QsIGRhdGEtPmtfYXV0LCBOVUxMLCAwKTsKIH0KIAogCkBAIC05NjMsNyArOTYzLDcgQEAKIAkgKi8KIAlpZiAoYXR0ci0+cmVzID09IE5VTEwgfHwgYXR0ci0+cmVzX2xlbiA8IGRhdGEtPnJlc19sZW4gfHwKIAkgICAgYXR0ci0+cmVzX2xlbl9iaXRzICE9IGRhdGEtPnJlc19sZW4gKiA4IHx8Ci0JICAgIG9zX21lbWNtcChhdHRyLT5yZXMsIGRhdGEtPnJlcywgZGF0YS0+cmVzX2xlbikgIT0gMCkgeworCSAgICBvc19tZW1jbXBfY29uc3QoYXR0ci0+cmVzLCBkYXRhLT5yZXMsIGRhdGEtPnJlc19sZW4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkVBUC1BS0E6IENoYWxsZW5nZSBtZXNzYWdlIGRpZCBub3QgIgogCQkJICAgImluY2x1ZGUgdmFsaWQgQVRfUkVTIChhdHRyIGxlbj0lbHUsIHJlcyBsZW49JWx1ICIKIAkJCSAgICJiaXRzLCBleHBlY3RlZCAlbHUgYml0cykiLApAQCAtMTA0MCw2ICsxMDQwLDcgQEAKIAlkYXRhLT5hdXRzX3JlcG9ydGVkID0gMTsKIAogCS8qIFJlbWFpbiBpbiBDSEFMTEVOR0Ugc3RhdGUgdG8gcmUtdHJ5IGFmdGVyIHJlc3luY2hyb25pemF0aW9uICovCisJZWFwX2FrYV9mdWxsYXV0aChzbSwgZGF0YSk7CiB9CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9la2UuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfZWtlLmMKaW5kZXggYjE5YTMyMS4uOTY2ZjUxMSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9la2UuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2VrZS5jCkBAIC0xMDQsNyArMTA0LDcgQEAKIAllYXBfZWtlX3Nlc3Npb25fY2xlYW4oJmRhdGEtPnNlc3MpOwogCW9zX2ZyZWUoZGF0YS0+cGVlcmlkKTsKIAl3cGFidWZfZnJlZShkYXRhLT5tc2dzKTsKLQlvc19mcmVlKGRhdGEpOworCWJpbl9jbGVhcl9mcmVlKGRhdGEsIHNpemVvZigqZGF0YSkpOwogfQogCiAKQEAgLTYzNSw4ICs2MzUsOCBAQAogCQlyZXR1cm47CiAJfQogCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkVBUC1FS0U6IEF1dGhfUCIsIGF1dGhfcCwgZGF0YS0+c2Vzcy5wcmZfbGVuKTsKLQlpZiAob3NfbWVtY21wKGF1dGhfcCwgcGF5bG9hZCArIGRhdGEtPnNlc3MucG5vbmNlX2xlbiwKLQkJICAgICAgZGF0YS0+c2Vzcy5wcmZfbGVuKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChhdXRoX3AsIHBheWxvYWQgKyBkYXRhLT5zZXNzLnBub25jZV9sZW4sCisJCQkgICAgZGF0YS0+c2Vzcy5wcmZfbGVuKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtRUtFOiBBdXRoX1AgZG9lcyBub3QgbWF0Y2giKTsKIAkJZWFwX2VrZV9mYWlsKGRhdGEsIEVBUF9FS0VfRkFJTF9BVVRIRU5USUNBVElPTl9GQUlMKTsKIAkJcmV0dXJuOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9mYXN0LmMgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2Zhc3QuYwppbmRleCBmY2I4MGRjLi40NjkxZTcyIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2Zhc3QuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2Zhc3QuYwpAQCAtMTg3LDcgKzE4Nyw3IEBACiAJCXN3aXRjaCAoKnBvcykgewogCQljYXNlIFBBQ19PUEFRVUVfVFlQRV9QQUQ6CiAJCQlwb3MgPSBlbmQ7Ci0JCQlicmVhazsKKwkJCWdvdG8gZG9uZTsKIAkJY2FzZSBQQUNfT1BBUVVFX1RZUEVfS0VZOgogCQkJaWYgKHBvc1sxXSAhPSBFQVBfRkFTVF9QQUNfS0VZX0xFTikgewogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUZBU1Q6IEludmFsaWQgIgpAQCAtMjE4LDYgKzIxOCw3IEBACiAKIAkJcG9zICs9IDIgKyBwb3NbMV07CiAJfQorZG9uZToKIAogCWlmIChwYWNfa2V5ID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtRkFTVDogTm8gUEFDLUtleSBpbmNsdWRlZCBpbiAiCkBAIC01MTEsNyArNTEyLDcgQEAKIAlvc19mcmVlKGRhdGEtPmtleV9ibG9ja19wKTsKIAl3cGFidWZfZnJlZShkYXRhLT5wZW5kaW5nX3BoYXNlMl9yZXNwKTsKIAlvc19mcmVlKGRhdGEtPmlkZW50aXR5KTsKLQlvc19mcmVlKGRhdGEpOworCWJpbl9jbGVhcl9mcmVlKGRhdGEsIHNpemVvZigqZGF0YSkpOwogfQogCiAKQEAgLTExMjMsNyArMTEyNCw4IEBACiBzdGF0aWMgaW50IGVhcF9mYXN0X3BhcnNlX3RsdnMoc3RydWN0IHdwYWJ1ZiAqZGF0YSwKIAkJCSAgICAgICBzdHJ1Y3QgZWFwX2Zhc3RfdGx2X3BhcnNlICp0bHYpCiB7Ci0JaW50IG1hbmRhdG9yeSwgdGx2X3R5cGUsIGxlbiwgcmVzOworCWludCBtYW5kYXRvcnksIHRsdl90eXBlLCByZXM7CisJc2l6ZV90IGxlbjsKIAl1OCAqcG9zLCAqZW5kOwogCiAJb3NfbWVtc2V0KHRsdiwgMCwgc2l6ZW9mKCp0bHYpKTsKQEAgLTExMzYsMTMgKzExMzgsMTQgQEAKIAkJcG9zICs9IDI7CiAJCWxlbiA9IFdQQV9HRVRfQkUxNihwb3MpOwogCQlwb3MgKz0gMjsKLQkJaWYgKHBvcyArIGxlbiA+IGVuZCkgeworCQlpZiAobGVuID4gKHNpemVfdCkgKGVuZCAtIHBvcykpIHsKIAkJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtRkFTVDogVExWIG92ZXJmbG93Iik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtRkFTVDogUmVjZWl2ZWQgUGhhc2UgMjogIgotCQkJICAgIlRMViB0eXBlICVkIGxlbmd0aCAlZCVzIiwKLQkJCSAgIHRsdl90eXBlLCBsZW4sIG1hbmRhdG9yeSA/ICIgKG1hbmRhdG9yeSkiIDogIiIpOworCQkJICAgIlRMViB0eXBlICVkIGxlbmd0aCAldSVzIiwKKwkJCSAgIHRsdl90eXBlLCAodW5zaWduZWQgaW50KSBsZW4sCisJCQkgICBtYW5kYXRvcnkgPyAiIChtYW5kYXRvcnkpIiA6ICIiKTsKIAogCQlyZXMgPSBlYXBfZmFzdF9wYXJzZV90bHYodGx2LCB0bHZfdHlwZSwgcG9zLCBsZW4pOwogCQlpZiAocmVzID09IC0yKQpAQCAtMTE5Niw3ICsxMTk5LDcgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmIChvc19tZW1jbXAoZGF0YS0+Y3J5cHRvX2JpbmRpbmdfbm9uY2UsIGItPm5vbmNlLCAzMSkgIT0gMCB8fAorCWlmIChvc19tZW1jbXBfY29uc3QoZGF0YS0+Y3J5cHRvX2JpbmRpbmdfbm9uY2UsIGItPm5vbmNlLCAzMSkgIT0gMCB8fAogCSAgICAoZGF0YS0+Y3J5cHRvX2JpbmRpbmdfbm9uY2VbMzFdIHwgMSkgIT0gYi0+bm9uY2VbMzFdKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUZBU1Q6IEludmFsaWQgbm9uY2UgaW4gIgogCQkJICAgIkNyeXB0by1CaW5kaW5nIik7CkBAIC0xMjEwLDcgKzEyMTMsNyBAQAogCQkgICAgKHU4ICopIGIsIGJpbmRfbGVuKTsKIAlobWFjX3NoYTEoZGF0YS0+Y21rLCBFQVBfRkFTVF9DTUtfTEVOLCAodTggKikgYiwgYmluZF9sZW4sCiAJCSAgYi0+Y29tcG91bmRfbWFjKTsKLQlpZiAob3NfbWVtY21wKGNtYWMsIGItPmNvbXBvdW5kX21hYywgc2l6ZW9mKGNtYWMpKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChjbWFjLCBiLT5jb21wb3VuZF9tYWMsIHNpemVvZihjbWFjKSkgIT0gMCkgewogCQl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwKIAkJCSAgICAiRUFQLUZBU1Q6IENhbGN1bGF0ZWQgQ29tcG91bmQgTUFDIiwKIAkJCSAgICBiLT5jb21wb3VuZF9tYWMsIHNpemVvZihjbWFjKSk7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2dwc2suYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfZ3Bzay5jCmluZGV4IDY2ZjQyNzEuLmNiMzY5ZTQgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfZ3Bzay5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfZ3Bzay5jCkBAIC05NSw3ICs5NSw3IEBACiB7CiAJc3RydWN0IGVhcF9ncHNrX2RhdGEgKmRhdGEgPSBwcml2OwogCW9zX2ZyZWUoZGF0YS0+aWRfcGVlcik7Ci0Jb3NfZnJlZShkYXRhKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLCBzaXplb2YoKmRhdGEpKTsKIH0KIAogCkBAIC00MzMsNyArNDMzLDcgQEAKIAkJZWFwX2dwc2tfc3RhdGUoZGF0YSwgRkFJTFVSRSk7CiAJCXJldHVybjsKIAl9Ci0JaWYgKG9zX21lbWNtcChtaWMsIHBvcywgbWljbGVuKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChtaWMsIHBvcywgbWljbGVuKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtR1BTSzogSW5jb3JyZWN0IE1JQyBpbiBHUFNLLTIiKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IFJlY2VpdmVkIE1JQyIsIHBvcywgbWljbGVuKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUdQU0s6IENvbXB1dGVkIE1JQyIsIG1pYywgbWljbGVuKTsKQEAgLTUwMiw3ICs1MDIsNyBAQAogCQllYXBfZ3Bza19zdGF0ZShkYXRhLCBGQUlMVVJFKTsKIAkJcmV0dXJuOwogCX0KLQlpZiAob3NfbWVtY21wKG1pYywgcG9zLCBtaWNsZW4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KG1pYywgcG9zLCBtaWNsZW4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1HUFNLOiBJbmNvcnJlY3QgTUlDIGluIEdQU0stNCIpOwogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAtR1BTSzogUmVjZWl2ZWQgTUlDIiwgcG9zLCBtaWNsZW4pOwogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAtR1BTSzogQ29tcHV0ZWQgTUlDIiwgbWljLCBtaWNsZW4pOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9ndGMuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfZ3RjLmMKaW5kZXggZjQyMzEwNi4uOThhYzNjNiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9ndGMuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2d0Yy5jCkBAIC0xNzUsNyArMTc1LDcgQEAKIAl9CiAKIAlpZiAocmxlbiAhPSBzbS0+dXNlci0+cGFzc3dvcmRfbGVuIHx8Ci0JICAgIG9zX21lbWNtcChwb3MsIHNtLT51c2VyLT5wYXNzd29yZCwgcmxlbikgIT0gMCkgeworCSAgICBvc19tZW1jbXBfY29uc3QocG9zLCBzbS0+dXNlci0+cGFzc3dvcmQsIHJsZW4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtR1RDOiBEb25lIC0gRmFpbHVyZSIpOwogCQlkYXRhLT5zdGF0ZSA9IEZBSUxVUkU7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfaWRlbnRpdHkuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfaWRlbnRpdHkuYwppbmRleCA1MWRjNGU4Li40NTAxNTMzIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2lkZW50aXR5LmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9pZGVudGl0eS5jCkBAIC0xMDIsNiArMTAyLDcgQEAKIAlzdHJ1Y3QgZWFwX2lkZW50aXR5X2RhdGEgKmRhdGEgPSBwcml2OwogCWNvbnN0IHU4ICpwb3M7CiAJc2l6ZV90IGxlbjsKKwljaGFyICpidWY7CiAKIAlpZiAoZGF0YS0+cGlja191cCkgewogCQlpZiAoZWFwX2lkZW50aXR5X2NoZWNrKHNtLCBkYXRhLCByZXNwRGF0YSkpIHsKQEAgLTExOSw2ICsxMjAsMTIgQEAKIAkJcmV0dXJuOyAvKiBTaG91bGQgbm90IGhhcHBlbiAtIGZyYW1lIGFscmVhZHkgdmFsaWRhdGVkICovCiAKIAl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJFQVAtSWRlbnRpdHk6IFBlZXIgaWRlbnRpdHkiLCBwb3MsIGxlbik7CisJYnVmID0gb3NfbWFsbG9jKGxlbiAqIDQgKyAxKTsKKwlpZiAoYnVmKSB7CisJCXByaW50Zl9lbmNvZGUoYnVmLCBsZW4gKiA0ICsgMSwgcG9zLCBsZW4pOworCQllYXBfbG9nX21zZyhzbSwgIkVBUC1SZXNwb25zZS9JZGVudGl0eSAnJXMnIiwgYnVmKTsKKwkJb3NfZnJlZShidWYpOworCX0KIAlpZiAoc20tPmlkZW50aXR5KQogCQlzbS0+dXBkYXRlX3VzZXIgPSBUUlVFOwogCW9zX2ZyZWUoc20tPmlkZW50aXR5KTsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfaWtldjIuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfaWtldjIuYwppbmRleCAxYWRhMGM4Li42NWIyZWY2IDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2lrZXYyLmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9pa2V2Mi5jCkBAIC0xMjcsNyArMTI3LDcgQEAKIAl3cGFidWZfZnJlZShkYXRhLT5pbl9idWYpOwogCXdwYWJ1Zl9mcmVlKGRhdGEtPm91dF9idWYpOwogCWlrZXYyX2luaXRpYXRvcl9kZWluaXQoJmRhdGEtPmlrZXYyKTsKLQlvc19mcmVlKGRhdGEpOworCWJpbl9jbGVhcl9mcmVlKGRhdGEsIHNpemVvZigqZGF0YSkpOwogfQogCiAKQEAgLTI1Niw3ICsyNTYsOCBAQAogCiBzdGF0aWMgaW50IGVhcF9pa2V2Ml9wcm9jZXNzX2ljdihzdHJ1Y3QgZWFwX2lrZXYyX2RhdGEgKmRhdGEsCiAJCQkJIGNvbnN0IHN0cnVjdCB3cGFidWYgKnJlc3BEYXRhLAotCQkJCSB1OCBmbGFncywgY29uc3QgdTggKnBvcywgY29uc3QgdTggKiplbmQpCisJCQkJIHU4IGZsYWdzLCBjb25zdCB1OCAqcG9zLCBjb25zdCB1OCAqKmVuZCwKKwkJCQkgaW50IGZyYWdfYWNrKQogewogCWlmIChmbGFncyAmIElLRVYyX0ZMQUdTX0lDVl9JTkNMVURFRCkgewogCQlpbnQgaWN2X2xlbiA9IGVhcF9pa2V2Ml92YWxpZGF0ZV9pY3YoCkBAIC0yNjYsNyArMjY3LDcgQEAKIAkJCXJldHVybiAtMTsKIAkJLyogSGlkZSBJbnRlZ3JpdHkgQ2hlY2tzdW0gRGF0YSBmcm9tIGZ1cnRoZXIgcHJvY2Vzc2luZyAqLwogCQkqZW5kIC09IGljdl9sZW47Ci0JfSBlbHNlIGlmIChkYXRhLT5rZXlzX3JlYWR5KSB7CisJfSBlbHNlIGlmIChkYXRhLT5rZXlzX3JlYWR5ICYmICFmcmFnX2FjaykgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLUlLRVYyOiBUaGUgbWVzc2FnZSBzaG91bGQgaGF2ZSAiCiAJCQkgICAiaW5jbHVkZWQgaW50ZWdyaXR5IGNoZWNrc3VtIik7CiAJCXJldHVybiAtMTsKQEAgLTM2NSw3ICszNjYsOSBAQAogCX0gZWxzZQogCQlmbGFncyA9ICpwb3MrKzsKIAotCWlmIChlYXBfaWtldjJfcHJvY2Vzc19pY3YoZGF0YSwgcmVzcERhdGEsIGZsYWdzLCBwb3MsICZlbmQpIDwgMCkgeworCWlmIChlYXBfaWtldjJfcHJvY2Vzc19pY3YoZGF0YSwgcmVzcERhdGEsIGZsYWdzLCBwb3MsICZlbmQsCisJCQkJICBkYXRhLT5zdGF0ZSA9PSBXQUlUX0ZSQUdfQUNLICYmIGxlbiA9PSAwKSA8IDApCisJewogCQllYXBfaWtldjJfc3RhdGUoZGF0YSwgRkFJTCk7CiAJCXJldHVybjsKIAl9CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX21kNS5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9tZDUuYwppbmRleCA1YTVlMjkwLi43MWU4ZDU5IDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX21kNS5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfbWQ1LmMKQEAgLTEyNiw3ICsxMjYsNyBAQAogCQlyZXR1cm47CiAJfQogCi0JaWYgKG9zX21lbWNtcChoYXNoLCBwb3MsIENIQVBfTUQ1X0xFTikgPT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QoaGFzaCwgcG9zLCBDSEFQX01ENV9MRU4pID09IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtTUQ1OiBEb25lIC0gU3VjY2VzcyIpOwogCQlkYXRhLT5zdGF0ZSA9IFNVQ0NFU1M7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfbXNjaGFwdjIuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfbXNjaGFwdjIuYwppbmRleCAzMTUzZDJlLi5mN2E3NTNkIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX21zY2hhcHYyLmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9tc2NoYXB2Mi5jCkBAIC05MSw3ICs5MSw3IEBACiAJCXJldHVybjsKIAogCW9zX2ZyZWUoZGF0YS0+cGVlcl9jaGFsbGVuZ2UpOwotCW9zX2ZyZWUoZGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiB9CiAKIApAQCAtMjkwLDYgKzI5MCw3IEBACiAJY29uc3QgdTggKnVzZXJuYW1lLCAqdXNlcjsKIAlzaXplX3QgdXNlcm5hbWVfbGVuLCB1c2VyX2xlbjsKIAlpbnQgcmVzOworCWNoYXIgKmJ1ZjsKIAogCXBvcyA9IGVhcF9oZHJfdmFsaWRhdGUoRUFQX1ZFTkRPUl9JRVRGLCBFQVBfVFlQRV9NU0NIQVBWMiwgcmVzcERhdGEsCiAJCQkgICAgICAgJmxlbik7CkBAIC0zMjksNiArMzMwLDEzIEBACiAJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIkVBUC1NU0NIQVBWMjogRmxhZ3MgMHgleCIsIGZsYWdzKTsKIAl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfTVNHRFVNUCwgIkVBUC1NU0NIQVBWMjogTmFtZSIsIG5hbWUsIG5hbWVfbGVuKTsKIAorCWJ1ZiA9IG9zX21hbGxvYyhuYW1lX2xlbiAqIDQgKyAxKTsKKwlpZiAoYnVmKSB7CisJCXByaW50Zl9lbmNvZGUoYnVmLCBuYW1lX2xlbiAqIDQgKyAxLCBuYW1lLCBuYW1lX2xlbik7CisJCWVhcF9sb2dfbXNnKHNtLCAiRUFQLU1TQ0hBUFYyIE5hbWUgJyVzJyIsIGJ1Zik7CisJCW9zX2ZyZWUoYnVmKTsKKwl9CisKIAkvKiBNU0NIQVB2MiBkb2VzIG5vdCBpbmNsdWRlIG9wdGlvbmFsIGRvbWFpbiBuYW1lIGluIHRoZQogCSAqIGNoYWxsZW5nZS1yZXNwb25zZSBjYWxjdWxhdGlvbiwgc28gcmVtb3ZlIGRvbWFpbiBwcmVmaXgKIAkgKiAoaWYgcHJlc2VudCkuICovCkBAIC0zODUsNyArMzkzLDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCWlmIChvc19tZW1jbXAobnRfcmVzcG9uc2UsIGV4cGVjdGVkLCAyNCkgPT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QobnRfcmVzcG9uc2UsIGV4cGVjdGVkLCAyNCkgPT0gMCkgewogCQljb25zdCB1OCAqcHdfaGFzaDsKIAkJdTggcHdfaGFzaF9idWZbMTZdLCBwd19oYXNoX2hhc2hbMTZdOwogCmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3BheC5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wYXguYwppbmRleCAzNWE0MmFkLi5jODc4NDhjIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3BheC5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfcGF4LmMKQEAgLTY0LDcgKzY0LDcgQEAKIHsKIAlzdHJ1Y3QgZWFwX3BheF9kYXRhICpkYXRhID0gcHJpdjsKIAlvc19mcmVlKGRhdGEtPmNpZCk7Ci0Jb3NfZnJlZShkYXRhKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLCBzaXplb2YoKmRhdGEpKTsKIH0KIAogCkBAIC0yNjgsNyArMjY4LDcgQEAKIAkJCSAgICB3cGFidWZfbWhlYWQocmVzcERhdGEpLAogCQkJICAgIHdwYWJ1Zl9sZW4ocmVzcERhdGEpIC0gRUFQX1BBWF9JQ1ZfTEVOLAogCQkJICAgIE5VTEwsIDAsIE5VTEwsIDAsIGljdmJ1Zik7Ci0JCWlmIChvc19tZW1jbXAoaWN2YnVmLCBpY3YsIEVBUF9QQVhfSUNWX0xFTikgIT0gMCkgeworCQlpZiAob3NfbWVtY21wX2NvbnN0KGljdmJ1ZiwgaWN2LCBFQVBfUEFYX0lDVl9MRU4pICE9IDApIHsKIAkJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUEFYOiBJbnZhbGlkIElDViIpOwogCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJFQVAtUEFYOiBFeHBlY3RlZCBJQ1YiLAogCQkJCSAgICBpY3ZidWYsIEVBUF9QQVhfSUNWX0xFTik7CkBAIC0zOTUsNyArMzk1LDcgQEAKIAkJICAgIGRhdGEtPnJhbmQuci54LCBFQVBfUEFYX1JBTkRfTEVOLAogCQkgICAgZGF0YS0+cmFuZC5yLnksIEVBUF9QQVhfUkFORF9MRU4sCiAJCSAgICAodTggKikgZGF0YS0+Y2lkLCBkYXRhLT5jaWRfbGVuLCBtYWMpOwotCWlmIChvc19tZW1jbXAobWFjLCBwb3MsIEVBUF9QQVhfTUFDX0xFTikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QobWFjLCBwb3MsIEVBUF9QQVhfTUFDX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVBBWDogSW52YWxpZCBNQUNfQ0soQSwgQiwgQ0lEKSBpbiAiCiAJCQkgICAiUEFYX1NURC0yIik7CiAJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiRUFQLVBBWDogRXhwZWN0ZWQgTUFDX0NLKEEsIEIsIENJRCkiLApAQCAtNDE3LDcgKzQxNyw3IEBACiAJCSAgICB3cGFidWZfaGVhZChyZXNwRGF0YSksCiAJCSAgICB3cGFidWZfbGVuKHJlc3BEYXRhKSAtIEVBUF9QQVhfSUNWX0xFTiwgTlVMTCwgMCwgTlVMTCwgMCwKIAkJICAgIGljdmJ1Zik7Ci0JaWYgKG9zX21lbWNtcChpY3ZidWYsIHBvcywgRUFQX1BBWF9JQ1ZfTEVOKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChpY3ZidWYsIHBvcywgRUFQX1BBWF9JQ1ZfTEVOKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUEFYOiBJbnZhbGlkIElDViBpbiBQQVhfU1RELTIiKTsKIAkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJFQVAtUEFYOiBFeHBlY3RlZCBJQ1YiLAogCQkJICAgIGljdmJ1ZiwgRUFQX1BBWF9JQ1ZfTEVOKTsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfcGVhcC5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wZWFwLmMKaW5kZXggNjgyNTNjNC4uNTk0ZTAyZCAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wZWFwLmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wZWFwLmMKQEAgLTIyLDcgKzIyLDYgQEAKIC8qIE1heGltdW0gc3VwcG9ydGVkIFBFQVAgdmVyc2lvbgogICogMCA9IE1pY3Jvc29mdCdzIFBFQVAgdmVyc2lvbiAwOyBkcmFmdC1rYW1hdGgtcHBwZXh0LXBlYXB2MC0wMC50eHQKICAqIDEgPSBkcmFmdC1qb3NlZnNzb24tcHBleHQtZWFwLXRscy1lYXAtMDUudHh0Ci0gKiAyID0gZHJhZnQtam9zZWZzc29uLXBwZXh0LWVhcC10bHMtZWFwLTEwLnR4dAogICovCiAjZGVmaW5lIEVBUF9QRUFQX1ZFUlNJT04gMQogCkBAIC05OSwzMyArOTgsNiBAQAogfQogCiAKLXN0YXRpYyBzdHJ1Y3Qgd3BhYnVmICogZWFwX3BlYXB2Ml90bHZfZWFwX3BheWxvYWQoc3RydWN0IHdwYWJ1ZiAqYnVmKQotewotCXN0cnVjdCB3cGFidWYgKmU7Ci0Jc3RydWN0IGVhcF90bHZfaGRyICp0bHY7Ci0KLQlpZiAoYnVmID09IE5VTEwpCi0JCXJldHVybiBOVUxMOwotCi0JLyogRW5jYXBzdWxhdGUgRUFQIHBhY2tldCBpbiBFQVAtUGF5bG9hZCBUTFYgKi8KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1QRUFQdjI6IEFkZCBFQVAtUGF5bG9hZCBUTFYiKTsKLQllID0gd3BhYnVmX2FsbG9jKHNpemVvZigqdGx2KSArIHdwYWJ1Zl9sZW4oYnVmKSk7Ci0JaWYgKGUgPT0gTlVMTCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1QRUFQdjI6IEZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgIgotCQkJICAgImZvciBUTFYgZW5jYXBzdWxhdGlvbiIpOwotCQl3cGFidWZfZnJlZShidWYpOwotCQlyZXR1cm4gTlVMTDsKLQl9Ci0JdGx2ID0gd3BhYnVmX3B1dChlLCBzaXplb2YoKnRsdikpOwotCXRsdi0+dGx2X3R5cGUgPSBob3N0X3RvX2JlMTYoRUFQX1RMVl9UWVBFX01BTkRBVE9SWSB8Ci0JCQkJICAgICBFQVBfVExWX0VBUF9QQVlMT0FEX1RMVik7Ci0JdGx2LT5sZW5ndGggPSBob3N0X3RvX2JlMTYod3BhYnVmX2xlbihidWYpKTsKLQl3cGFidWZfcHV0X2J1ZihlLCBidWYpOwotCXdwYWJ1Zl9mcmVlKGJ1Zik7Ci0JcmV0dXJuIGU7Ci19Ci0KLQogc3RhdGljIHZvaWQgZWFwX3BlYXBfcmVxX3N1Y2Nlc3Moc3RydWN0IGVhcF9zbSAqc20sCiAJCQkJIHN0cnVjdCBlYXBfcGVhcF9kYXRhICpkYXRhKQogewpAQCAtMjAwLDcgKzE3Miw3IEBACiAJd3BhYnVmX2ZyZWUoZGF0YS0+cGVuZGluZ19waGFzZTJfcmVzcCk7CiAJb3NfZnJlZShkYXRhLT5waGFzZTJfa2V5KTsKIAl3cGFidWZfZnJlZShkYXRhLT5zb2hfcmVzcG9uc2UpOwotCW9zX2ZyZWUoZGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiB9CiAKIApAQCAtMjM5LDggKzIxMSw2IEBACiAJCXJldHVybiBOVUxMOwogCX0KIAlidWYgPSBkYXRhLT5waGFzZTJfbWV0aG9kLT5idWlsZFJlcShzbSwgZGF0YS0+cGhhc2UyX3ByaXYsIGlkKTsKLQlpZiAoZGF0YS0+cGVhcF92ZXJzaW9uID49IDIgJiYgYnVmKQotCQlidWYgPSBlYXBfcGVhcHYyX3Rsdl9lYXBfcGF5bG9hZChidWYpOwogCWlmIChidWYgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAKQEAgLTQyNSw4ICszOTUsNiBAQAogCQlsZW5bMV0gPSAxOwogCiAJCXRsdl90eXBlID0gRUFQX1RMVl9DUllQVE9fQklORElOR19UTFY7Ci0JCWlmIChkYXRhLT5wZWFwX3ZlcnNpb24gPj0gMikKLQkJCXRsdl90eXBlIHw9IEVBUF9UTFZfVFlQRV9NQU5EQVRPUlk7CiAJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIHRsdl90eXBlKTsKIAkJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgNTYpOwogCkBAIC01MDUsOCArNDczLDcgQEAKIAkJcmV0dXJuIGVhcF9wZWFwX2J1aWxkX3N0YXJ0KHNtLCBkYXRhLCBpZCk7CiAJY2FzZSBQSEFTRTE6CiAJY2FzZSBQSEFTRTFfSUQyOgotCQlpZiAoZGF0YS0+cGVhcF92ZXJzaW9uIDwgMiAmJgotCQkgICAgdGxzX2Nvbm5lY3Rpb25fZXN0YWJsaXNoZWQoc20tPnNzbF9jdHgsIGRhdGEtPnNzbC5jb25uKSkgeworCQlpZiAodGxzX2Nvbm5lY3Rpb25fZXN0YWJsaXNoZWQoc20tPnNzbF9jdHgsIGRhdGEtPnNzbC5jb25uKSkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtUEVBUDogUGhhc2UxIGRvbmUsICIKIAkJCQkgICAic3RhcnRpbmcgUGhhc2UyIik7CiAJCQllYXBfcGVhcF9zdGF0ZShkYXRhLCBQSEFTRTJfU1RBUlQpOwpAQCAtNjI2LDcgKzU5Myw3IEBACiAJYnVmWzYwXSA9IEVBUF9UWVBFX1BFQVA7CiAJaG1hY19zaGExKGRhdGEtPmNtaywgMjAsIGJ1Ziwgc2l6ZW9mKGJ1ZiksIG1hYyk7CiAKLQlpZiAob3NfbWVtY21wKG1hYywgcG9zLCBTSEExX01BQ19MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KG1hYywgcG9zLCBTSEExX01BQ19MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtUEVBUDogSW52YWxpZCBDb21wb3VuZF9NQUMgaW4gIgogCQkJICAgImNyeXB0b2JpbmRpbmcgVExWIik7CiAJCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJFQVAtUEVBUDogQ01LIiwgZGF0YS0+Y21rLCAyMCk7CkBAIC0xMDc5LDQ3ICsxMDQ2LDYgQEAKIAkJd3BhYnVmX2ZyZWUoaW5fZGVjcnlwdGVkKTsKIAogCQlpbl9kZWNyeXB0ZWQgPSBuYnVmOwotCX0gZWxzZSBpZiAoZGF0YS0+cGVhcF92ZXJzaW9uID49IDIpIHsKLQkJc3RydWN0IGVhcF90bHZfaGRyICp0bHY7Ci0JCXN0cnVjdCB3cGFidWYgKm5tc2c7Ci0KLQkJaWYgKHdwYWJ1Zl9sZW4oaW5fZGVjcnlwdGVkKSA8IHNpemVvZigqdGx2KSArIHNpemVvZigqaGRyKSkgewotCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QRUFQdjI6IFRvbyBzaG9ydCBQaGFzZSAyICIKLQkJCQkgICAiRUFQIFRMViIpOwotCQkJd3BhYnVmX2ZyZWUoaW5fZGVjcnlwdGVkKTsKLQkJCXJldHVybjsKLQkJfQotCQl0bHYgPSB3cGFidWZfbWhlYWQoaW5fZGVjcnlwdGVkKTsKLQkJaWYgKChiZV90b19ob3N0MTYodGx2LT50bHZfdHlwZSkgJiBFQVBfVExWX1RZUEVfTUFTSykgIT0KLQkJICAgIEVBUF9UTFZfRUFQX1BBWUxPQURfVExWKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVBFQVB2MjogTm90IGFuIEVBUCBUTFYiKTsKLQkJCXdwYWJ1Zl9mcmVlKGluX2RlY3J5cHRlZCk7Ci0JCQlyZXR1cm47Ci0JCX0KLQkJaWYgKHNpemVvZigqdGx2KSArIGJlX3RvX2hvc3QxNih0bHYtPmxlbmd0aCkgPgotCQkgICAgd3BhYnVmX2xlbihpbl9kZWNyeXB0ZWQpKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVBFQVB2MjogSW52YWxpZCBFQVAgVExWICIKLQkJCQkgICAibGVuZ3RoIik7Ci0JCQl3cGFidWZfZnJlZShpbl9kZWNyeXB0ZWQpOwotCQkJcmV0dXJuOwotCQl9Ci0JCWhkciA9IChzdHJ1Y3QgZWFwX2hkciAqKSAodGx2ICsgMSk7Ci0JCWlmIChiZV90b19ob3N0MTYoaGRyLT5sZW5ndGgpID4gYmVfdG9faG9zdDE2KHRsdi0+bGVuZ3RoKSkgewotCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QRUFQdjI6IE5vIHJvb20gZm9yIGZ1bGwgIgotCQkJCSAgICJFQVAgcGFja2V0IGluIEVBUCBUTFYiKTsKLQkJCXdwYWJ1Zl9mcmVlKGluX2RlY3J5cHRlZCk7Ci0JCQlyZXR1cm47Ci0JCX0KLQotCQlubXNnID0gd3BhYnVmX2FsbG9jKGJlX3RvX2hvc3QxNihoZHItPmxlbmd0aCkpOwotCQlpZiAobm1zZyA9PSBOVUxMKSB7Ci0JCQl3cGFidWZfZnJlZShpbl9kZWNyeXB0ZWQpOwotCQkJcmV0dXJuOwotCQl9Ci0KLQkJd3BhYnVmX3B1dF9kYXRhKG5tc2csIGhkciwgYmVfdG9faG9zdDE2KGhkci0+bGVuZ3RoKSk7Ci0JCXdwYWJ1Zl9mcmVlKGluX2RlY3J5cHRlZCk7Ci0JCWluX2RlY3J5cHRlZCA9IG5tc2c7CiAJfQogCiAJaGRyID0gd3BhYnVmX2hlYWQoaW5fZGVjcnlwdGVkKTsKQEAgLTExNjgsNTMgKzEwOTQsNiBAQAogfQogCiAKLXN0YXRpYyBpbnQgZWFwX3BlYXB2Ml9zdGFydF9waGFzZTIoc3RydWN0IGVhcF9zbSAqc20sCi0JCQkJICAgc3RydWN0IGVhcF9wZWFwX2RhdGEgKmRhdGEpCi17Ci0Jc3RydWN0IHdwYWJ1ZiAqYnVmLCAqYnVmMjsKLQotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVBFQVB2MjogUGhhc2UxIGRvbmUsIGluY2x1ZGUgZmlyc3QgUGhhc2UyICIKLQkJICAgInBheWxvYWQgaW4gdGhlIHNhbWUgbWVzc2FnZSIpOwotCWVhcF9wZWFwX3N0YXRlKGRhdGEsIFBIQVNFMV9JRDIpOwotCWlmIChlYXBfcGVhcF9waGFzZTJfaW5pdChzbSwgZGF0YSwgRUFQX1RZUEVfSURFTlRJVFkpKQotCQlyZXR1cm4gLTE7Ci0KLQkvKiBUT0RPOiB3aGljaCBJZCB0byB1c2UgaGVyZT8gKi8KLQlidWYgPSBkYXRhLT5waGFzZTJfbWV0aG9kLT5idWlsZFJlcShzbSwgZGF0YS0+cGhhc2UyX3ByaXYsIDYpOwotCWlmIChidWYgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwotCi0JYnVmMiA9IGVhcF9wZWFwdjJfdGx2X2VhcF9wYXlsb2FkKGJ1Zik7Ci0JaWYgKGJ1ZjIgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwotCi0Jd3BhX2hleGR1bXBfYnVmKE1TR19ERUJVRywgIkVBUC1QRUFQdjI6IElkZW50aXR5IFJlcXVlc3QiLCBidWYyKTsKLQotCWJ1ZiA9IHRsc19jb25uZWN0aW9uX2VuY3J5cHQoc20tPnNzbF9jdHgsIGRhdGEtPnNzbC5jb25uLAotCQkJCSAgICAgYnVmMik7Ci0Jd3BhYnVmX2ZyZWUoYnVmMik7Ci0KLQlpZiAoYnVmID09IE5VTEwpIHsKLQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QRUFQdjI6IEZhaWxlZCB0byBlbmNyeXB0IFBoYXNlIDIgIgotCQkJICAgImRhdGEiKTsKLQkJcmV0dXJuIC0xOwotCX0KLQotCXdwYV9oZXhkdW1wX2J1ZihNU0dfREVCVUcsICJFQVAtUEVBUHYyOiBFbmNyeXB0ZWQgSWRlbnRpdHkgUmVxdWVzdCIsCi0JCQlidWYpOwotCi0JLyogQXBwZW5kIFRMUyBkYXRhIGludG8gdGhlIHBlbmRpbmcgYnVmZmVyIGFmdGVyIHRoZSBTZXJ2ZXIgRmluaXNoZWQgKi8KLQlpZiAod3BhYnVmX3Jlc2l6ZSgmZGF0YS0+c3NsLnRsc19vdXQsIHdwYWJ1Zl9sZW4oYnVmKSkgPCAwKSB7Ci0JCXdwYWJ1Zl9mcmVlKGJ1Zik7Ci0JCXJldHVybiAtMTsKLQl9Ci0Jd3BhYnVmX3B1dF9idWYoZGF0YS0+c3NsLnRsc19vdXQsIGJ1Zik7Ci0Jd3BhYnVmX2ZyZWUoYnVmKTsKLQotCXJldHVybiAwOwotfQotCi0KIHN0YXRpYyBpbnQgZWFwX3BlYXBfcHJvY2Vzc192ZXJzaW9uKHN0cnVjdCBlYXBfc20gKnNtLCB2b2lkICpwcml2LAogCQkJCSAgICBpbnQgcGVlcl92ZXJzaW9uKQogewpAQCAtMTI0OSwxNCArMTEyOCw2IEBACiAJCQllYXBfcGVhcF9zdGF0ZShkYXRhLCBGQUlMVVJFKTsKIAkJCWJyZWFrOwogCQl9Ci0KLQkJaWYgKGRhdGEtPnBlYXBfdmVyc2lvbiA+PSAyICYmCi0JCSAgICB0bHNfY29ubmVjdGlvbl9lc3RhYmxpc2hlZChzbS0+c3NsX2N0eCwgZGF0YS0+c3NsLmNvbm4pKSB7Ci0JCQlpZiAoZWFwX3BlYXB2Ml9zdGFydF9waGFzZTIoc20sIGRhdGEpKSB7Ci0JCQkJZWFwX3BlYXBfc3RhdGUoZGF0YSwgRkFJTFVSRSk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KIAkJYnJlYWs7CiAJY2FzZSBQSEFTRTJfU1RBUlQ6CiAJCWVhcF9wZWFwX3N0YXRlKGRhdGEsIFBIQVNFMl9JRCk7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3Bzay5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wc2suYwppbmRleCA0NmJlZGQ5Li5kYjM5NGU5IDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3Bzay5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfcHNrLmMKQEAgLTQ3LDcgKzQ3LDcgQEAKIHsKIAlzdHJ1Y3QgZWFwX3Bza19kYXRhICpkYXRhID0gcHJpdjsKIAlvc19mcmVlKGRhdGEtPmlkX3ApOwotCW9zX2ZyZWUoZGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiB9CiAKIApAQCAtMzE0LDcgKzMxNCw3IEBACiAJfQogCW9zX2ZyZWUoYnVmKTsKIAl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAtUFNLOiBNQUNfUCIsIHJlc3AtPm1hY19wLCBFQVBfUFNLX01BQ19MRU4pOwotCWlmIChvc19tZW1jbXAobWFjLCByZXNwLT5tYWNfcCwgRUFQX1BTS19NQUNfTEVOKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChtYWMsIHJlc3AtPm1hY19wLCBFQVBfUFNLX01BQ19MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QU0s6IEludmFsaWQgTUFDX1AiKTsKIAkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJFQVAtUFNLOiBFeHBlY3RlZCBNQUNfUCIsCiAJCQkgICAgbWFjLCBFQVBfUFNLX01BQ19MRU4pOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wd2QuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfcHdkLmMKaW5kZXggZDJjNDhhNS4uYjQ4YzMzMSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wd2QuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3B3ZC5jCkBAIC00NSw2ICs0NSw3IEBACiAKIAl1OCBtc2tbRUFQX01TS19MRU5dOwogCXU4IGVtc2tbRUFQX0VNU0tfTEVOXTsKKwl1OCBzZXNzaW9uX2lkWzEgKyBTSEEyNTZfTUFDX0xFTl07CiAKIAlCTl9DVFggKmJuY3R4OwogfTsKQEAgLTEwNSw3ICsxMDYsNyBAQAogCWlmIChkYXRhLT5wYXNzd29yZCA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUFdEOiBNZW1vcnkgYWxsb2NhdGlvbiBwYXNzd29yZCAiCiAJCQkgICAiZmFpbCIpOwotCQlvc19mcmVlKGRhdGEtPmlkX3NlcnZlcik7CisJCWJpbl9jbGVhcl9mcmVlKGRhdGEtPmlkX3NlcnZlciwgZGF0YS0+aWRfc2VydmVyX2xlbik7CiAJCW9zX2ZyZWUoZGF0YSk7CiAJCXJldHVybiBOVUxMOwogCX0KQEAgLTExNSwxNSArMTE2LDE2IEBACiAJZGF0YS0+Ym5jdHggPSBCTl9DVFhfbmV3KCk7CiAJaWYgKGRhdGEtPmJuY3R4ID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QV0Q6IGJuIGNvbnRleHQgYWxsb2NhdGlvbiBmYWlsIik7Ci0JCW9zX2ZyZWUoZGF0YS0+cGFzc3dvcmQpOwotCQlvc19mcmVlKGRhdGEtPmlkX3NlcnZlcik7CisJCWJpbl9jbGVhcl9mcmVlKGRhdGEtPnBhc3N3b3JkLCBkYXRhLT5wYXNzd29yZF9sZW4pOworCQliaW5fY2xlYXJfZnJlZShkYXRhLT5pZF9zZXJ2ZXIsIGRhdGEtPmlkX3NlcnZlcl9sZW4pOwogCQlvc19mcmVlKGRhdGEpOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAKIAlkYXRhLT5pbl9mcmFnX3BvcyA9IGRhdGEtPm91dF9mcmFnX3BvcyA9IDA7CiAJZGF0YS0+aW5idWYgPSBkYXRhLT5vdXRidWYgPSBOVUxMOwotCWRhdGEtPm10dSA9IDEwMjA7IC8qIGRlZmF1bHQgZnJvbSBSRkMgNTkzMSwgbWFrZSBpdCBjb25maWd1cmFibGUhICovCisJLyogdXNlIGRlZmF1bHQgTVRVIGZyb20gUkZDIDU5MzEgaWYgbm90IGNvbmZpZ3VyZWQgb3RoZXJ3aXNlICovCisJZGF0YS0+bXR1ID0gc20tPmZyYWdtZW50X3NpemUgPiAwID8gc20tPmZyYWdtZW50X3NpemUgOiAxMDIwOwogCiAJcmV0dXJuIGRhdGE7CiB9CkBAIC0xMzMsMjQgKzEzNSwyNiBAQAogewogCXN0cnVjdCBlYXBfcHdkX2RhdGEgKmRhdGEgPSBwcml2OwogCi0JQk5fZnJlZShkYXRhLT5wcml2YXRlX3ZhbHVlKTsKLQlCTl9mcmVlKGRhdGEtPnBlZXJfc2NhbGFyKTsKLQlCTl9mcmVlKGRhdGEtPm15X3NjYWxhcik7Ci0JQk5fZnJlZShkYXRhLT5rKTsKKwlCTl9jbGVhcl9mcmVlKGRhdGEtPnByaXZhdGVfdmFsdWUpOworCUJOX2NsZWFyX2ZyZWUoZGF0YS0+cGVlcl9zY2FsYXIpOworCUJOX2NsZWFyX2ZyZWUoZGF0YS0+bXlfc2NhbGFyKTsKKwlCTl9jbGVhcl9mcmVlKGRhdGEtPmspOwogCUJOX0NUWF9mcmVlKGRhdGEtPmJuY3R4KTsKLQlFQ19QT0lOVF9mcmVlKGRhdGEtPm15X2VsZW1lbnQpOwotCUVDX1BPSU5UX2ZyZWUoZGF0YS0+cGVlcl9lbGVtZW50KTsKLQlvc19mcmVlKGRhdGEtPmlkX3BlZXIpOwotCW9zX2ZyZWUoZGF0YS0+aWRfc2VydmVyKTsKLQlvc19mcmVlKGRhdGEtPnBhc3N3b3JkKTsKKwlFQ19QT0lOVF9jbGVhcl9mcmVlKGRhdGEtPm15X2VsZW1lbnQpOworCUVDX1BPSU5UX2NsZWFyX2ZyZWUoZGF0YS0+cGVlcl9lbGVtZW50KTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLT5pZF9wZWVyLCBkYXRhLT5pZF9wZWVyX2xlbik7CisJYmluX2NsZWFyX2ZyZWUoZGF0YS0+aWRfc2VydmVyLCBkYXRhLT5pZF9zZXJ2ZXJfbGVuKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLT5wYXNzd29yZCwgZGF0YS0+cGFzc3dvcmRfbGVuKTsKIAlpZiAoZGF0YS0+Z3JwKSB7CiAJCUVDX0dST1VQX2ZyZWUoZGF0YS0+Z3JwLT5ncm91cCk7Ci0JCUVDX1BPSU5UX2ZyZWUoZGF0YS0+Z3JwLT5wd2UpOwotCQlCTl9mcmVlKGRhdGEtPmdycC0+b3JkZXIpOwotCQlCTl9mcmVlKGRhdGEtPmdycC0+cHJpbWUpOworCQlFQ19QT0lOVF9jbGVhcl9mcmVlKGRhdGEtPmdycC0+cHdlKTsKKwkJQk5fY2xlYXJfZnJlZShkYXRhLT5ncnAtPm9yZGVyKTsKKwkJQk5fY2xlYXJfZnJlZShkYXRhLT5ncnAtPnByaW1lKTsKIAkJb3NfZnJlZShkYXRhLT5ncnApOwogCX0KLQlvc19mcmVlKGRhdGEpOworCXdwYWJ1Zl9mcmVlKGRhdGEtPmluYnVmKTsKKwl3cGFidWZfZnJlZShkYXRhLT5vdXRidWYpOworCWJpbl9jbGVhcl9mcmVlKGRhdGEsIHNpemVvZigqZGF0YSkpOwogfQogCiAKQEAgLTIwNiwxMSArMjEwLDE1IEBACiAJCWdvdG8gZmluOwogCX0KIAotCUJOX3JhbmRfcmFuZ2UoZGF0YS0+cHJpdmF0ZV92YWx1ZSwgZGF0YS0+Z3JwLT5vcmRlcik7Ci0JQk5fcmFuZF9yYW5nZShtYXNrLCBkYXRhLT5ncnAtPm9yZGVyKTsKLQlCTl9hZGQoZGF0YS0+bXlfc2NhbGFyLCBkYXRhLT5wcml2YXRlX3ZhbHVlLCBtYXNrKTsKLQlCTl9tb2QoZGF0YS0+bXlfc2NhbGFyLCBkYXRhLT5teV9zY2FsYXIsIGRhdGEtPmdycC0+b3JkZXIsCi0JICAgICAgIGRhdGEtPmJuY3R4KTsKKwlpZiAoQk5fcmFuZF9yYW5nZShkYXRhLT5wcml2YXRlX3ZhbHVlLCBkYXRhLT5ncnAtPm9yZGVyKSAhPSAxIHx8CisJICAgIEJOX3JhbmRfcmFuZ2UobWFzaywgZGF0YS0+Z3JwLT5vcmRlcikgIT0gMSB8fAorCSAgICBCTl9hZGQoZGF0YS0+bXlfc2NhbGFyLCBkYXRhLT5wcml2YXRlX3ZhbHVlLCBtYXNrKSAhPSAxIHx8CisJICAgIEJOX21vZChkYXRhLT5teV9zY2FsYXIsIGRhdGEtPm15X3NjYWxhciwgZGF0YS0+Z3JwLT5vcmRlciwKKwkJICAgZGF0YS0+Ym5jdHgpICE9IDEpIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywKKwkJCSAgICJFQVAtcHdkIChzZXJ2ZXIpOiB1bmFibGUgdG8gZ2V0IHJhbmRvbW5lc3MiKTsKKwkJZ290byBmaW47CisJfQogCiAJaWYgKCFFQ19QT0lOVF9tdWwoZGF0YS0+Z3JwLT5ncm91cCwgZGF0YS0+bXlfZWxlbWVudCwgTlVMTCwKIAkJCSAgZGF0YS0+Z3JwLT5wd2UsIG1hc2ssIGRhdGEtPmJuY3R4KSkgewpAQCAtMjI2LDcgKzIzNCw3IEBACiAJCQkgICAiZmFpbCIpOwogCQlnb3RvIGZpbjsKIAl9Ci0JQk5fZnJlZShtYXNrKTsKKwlCTl9jbGVhcl9mcmVlKG1hc2spOwogCiAJaWYgKCgoeCA9IEJOX25ldygpKSA9PSBOVUxMKSB8fAogCSAgICAoKHkgPSBCTl9uZXcoKSkgPT0gTlVMTCkpIHsKQEAgLTI3OCw4ICsyODYsOCBAQAogZmluOgogCW9zX2ZyZWUoc2NhbGFyKTsKIAlvc19mcmVlKGVsZW1lbnQpOwotCUJOX2ZyZWUoeCk7Ci0JQk5fZnJlZSh5KTsKKwlCTl9jbGVhcl9mcmVlKHgpOworCUJOX2NsZWFyX2ZyZWUoeSk7CiAJaWYgKGRhdGEtPm91dGJ1ZiA9PSBOVUxMKQogCQllYXBfcHdkX3N0YXRlKGRhdGEsIEZBSUxVUkUpOwogfQpAQCAtNDAyLDkgKzQxMCw5IEBACiAJd3BhYnVmX3B1dF9kYXRhKGRhdGEtPm91dGJ1ZiwgY29uZiwgU0hBMjU2X01BQ19MRU4pOwogCiBmaW46Ci0Jb3NfZnJlZShjcnVmdCk7Ci0JQk5fZnJlZSh4KTsKLQlCTl9mcmVlKHkpOworCWJpbl9jbGVhcl9mcmVlKGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCUJOX2NsZWFyX2ZyZWUoeCk7CisJQk5fY2xlYXJfZnJlZSh5KTsKIAlpZiAoZGF0YS0+b3V0YnVmID09IE5VTEwpCiAJCWVhcF9wd2Rfc3RhdGUoZGF0YSwgRkFJTFVSRSk7CiB9CkBAIC01MjMsNiArNTMxLDcgQEAKIAkgKi8KIAlpZiAoZGF0YS0+b3V0X2ZyYWdfcG9zID49IHdwYWJ1Zl9sZW4oZGF0YS0+b3V0YnVmKSkgewogCQl3cGFidWZfZnJlZShkYXRhLT5vdXRidWYpOworCQlkYXRhLT5vdXRidWYgPSBOVUxMOwogCQlkYXRhLT5vdXRfZnJhZ19wb3MgPSAwOwogCX0KIApAQCAtNTk1LDcgKzYwNCw4IEBACiAJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiRUFQLVBXRCAoc2VydmVyKTogcGVlciBzZW50IGlkIG9mIiwKIAkJCSAgZGF0YS0+aWRfcGVlciwgZGF0YS0+aWRfcGVlcl9sZW4pOwogCi0JaWYgKChkYXRhLT5ncnAgPSBvc19tYWxsb2Moc2l6ZW9mKEVBUF9QV0RfZ3JvdXApKSkgPT0gTlVMTCkgeworCWRhdGEtPmdycCA9IG9zX3phbGxvYyhzaXplb2YoRUFQX1BXRF9ncm91cCkpOworCWlmIChkYXRhLT5ncnAgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVBXRDogZmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IgIgogCQkJICAgImdyb3VwIik7CiAJCXJldHVybjsKQEAgLTcxOCwxMSArNzI4LDExIEBACiAJcmVzID0gMTsKIAogZmluOgotCUVDX1BPSU5UX2ZyZWUoSyk7Ci0JRUNfUE9JTlRfZnJlZShwb2ludCk7Ci0JQk5fZnJlZShjb2ZhY3Rvcik7Ci0JQk5fZnJlZSh4KTsKLQlCTl9mcmVlKHkpOworCUVDX1BPSU5UX2NsZWFyX2ZyZWUoSyk7CisJRUNfUE9JTlRfY2xlYXJfZnJlZShwb2ludCk7CisJQk5fY2xlYXJfZnJlZShjb2ZhY3Rvcik7CisJQk5fY2xlYXJfZnJlZSh4KTsKKwlCTl9jbGVhcl9mcmVlKHkpOwogCiAJaWYgKHJlcykKIAkJZWFwX3B3ZF9zdGF0ZShkYXRhLCBQV0RfQ29uZmlybV9SZXEpOwpAQCAtODI5LDcgKzgzOSw3IEBACiAJZWFwX3B3ZF9oX2ZpbmFsKGhhc2gsIGNvbmYpOwogCiAJcHRyID0gKHU4ICopIHBheWxvYWQ7Ci0JaWYgKG9zX21lbWNtcChjb25mLCBwdHIsIFNIQTI1Nl9NQUNfTEVOKSkgeworCWlmIChvc19tZW1jbXBfY29uc3QoY29uZiwgcHRyLCBTSEEyNTZfTUFDX0xFTikpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkVBUC1QV0QgKHNlcnZlcik6IGNvbmZpcm0gZGlkIG5vdCAiCiAJCQkgICAidmVyaWZ5Iik7CiAJCWdvdG8gZmluOwpAQCAtODM4LDE1ICs4NDgsMTYgQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1wd2QgKHNlcnZlcik6IGNvbmZpcm0gdmVyaWZpZWQiKTsKIAlpZiAoY29tcHV0ZV9rZXlzKGRhdGEtPmdycCwgZGF0YS0+Ym5jdHgsIGRhdGEtPmssCiAJCQkgZGF0YS0+cGVlcl9zY2FsYXIsIGRhdGEtPm15X3NjYWxhciwgY29uZiwKLQkJCSBkYXRhLT5teV9jb25maXJtLCAmY3MsIGRhdGEtPm1zaywgZGF0YS0+ZW1zaykgPCAwKQorCQkJIGRhdGEtPm15X2NvbmZpcm0sICZjcywgZGF0YS0+bXNrLCBkYXRhLT5lbXNrLAorCQkJIGRhdGEtPnNlc3Npb25faWQpIDwgMCkKIAkJZWFwX3B3ZF9zdGF0ZShkYXRhLCBGQUlMVVJFKTsKIAllbHNlCiAJCWVhcF9wd2Rfc3RhdGUoZGF0YSwgU1VDQ0VTUyk7CiAKIGZpbjoKLQlvc19mcmVlKGNydWZ0KTsKLQlCTl9mcmVlKHgpOwotCUJOX2ZyZWUoeSk7CisJYmluX2NsZWFyX2ZyZWUoY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJQk5fY2xlYXJfZnJlZSh4KTsKKwlCTl9jbGVhcl9mcmVlKHkpOwogfQogCiAKQEAgLTg5Myw2ICs5MDQsOCBAQAogCQl0b3RfbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLXB3ZDogSW5jb21pbmcgZnJhZ21lbnRzLCB0b3RhbCAiCiAJCQkgICAibGVuZ3RoID0gJWQiLCB0b3RfbGVuKTsKKwkJaWYgKHRvdF9sZW4gPiAxNTAwMCkKKwkJCXJldHVybjsKIAkJZGF0YS0+aW5idWYgPSB3cGFidWZfYWxsb2ModG90X2xlbik7CiAJCWlmIChkYXRhLT5pbmJ1ZiA9PSBOVUxMKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLXB3ZDogT3V0IG9mIG1lbW9yeSB0byAiCkBAIC05NDksNiArOTYyLDcgQEAKIAkgKi8KIAlpZiAoZGF0YS0+aW5fZnJhZ19wb3MpIHsKIAkJd3BhYnVmX2ZyZWUoZGF0YS0+aW5idWYpOworCQlkYXRhLT5pbmJ1ZiA9IE5VTEw7CiAJCWRhdGEtPmluX2ZyYWdfcG9zID0gMDsKIAl9CiB9CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3Nha2UuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfc2FrZS5jCmluZGV4IDY4ZGQ3NmIuLjE5Mzc2MjEgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfc2FrZS5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfc2FrZS5jCkBAIC04Myw3ICs4Myw3IEBACiB7CiAJc3RydWN0IGVhcF9zYWtlX2RhdGEgKmRhdGEgPSBwcml2OwogCW9zX2ZyZWUoZGF0YS0+cGVlcmlkKTsKLQlvc19mcmVlKGRhdGEpOworCWJpbl9jbGVhcl9mcmVlKGRhdGEsIHNpemVvZigqZGF0YSkpOwogfQogCiAKQEAgLTM1MSw3ICszNTEsNyBAQAogCQkJICAgICBkYXRhLT5wZWVyaWQsIGRhdGEtPnBlZXJpZF9sZW4sIDEsCiAJCQkgICAgIHdwYWJ1Zl9oZWFkKHJlc3BEYXRhKSwgd3BhYnVmX2xlbihyZXNwRGF0YSksCiAJCQkgICAgIGF0dHIubWljX3AsIG1pY19wKTsKLQlpZiAob3NfbWVtY21wKGF0dHIubWljX3AsIG1pY19wLCBFQVBfU0FLRV9NSUNfTEVOKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChhdHRyLm1pY19wLCBtaWNfcCwgRUFQX1NBS0VfTUlDX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVNBS0U6IEluY29ycmVjdCBBVF9NSUNfUCIpOwogCQllYXBfc2FrZV9zdGF0ZShkYXRhLCBGQUlMVVJFKTsKIAkJcmV0dXJuOwpAQCAtMzg4LDcgKzM4OCw3IEBACiAJCQkgICAgIGRhdGEtPnBlZXJpZCwgZGF0YS0+cGVlcmlkX2xlbiwgMSwKIAkJCSAgICAgd3BhYnVmX2hlYWQocmVzcERhdGEpLCB3cGFidWZfbGVuKHJlc3BEYXRhKSwKIAkJCSAgICAgYXR0ci5taWNfcCwgbWljX3ApOwotCWlmIChvc19tZW1jbXAoYXR0ci5taWNfcCwgbWljX3AsIEVBUF9TQUtFX01JQ19MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KGF0dHIubWljX3AsIG1pY19wLCBFQVBfU0FLRV9NSUNfTEVOKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtU0FLRTogSW5jb3JyZWN0IEFUX01JQ19QIik7CiAJCWVhcF9zYWtlX3N0YXRlKGRhdGEsIEZBSUxVUkUpOwogCX0gZWxzZQpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9zaW0uYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfc2ltLmMKaW5kZXggYjUzMTI0MS4uMjNlZTJiNiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9zaW0uYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3NpbS5jCkBAIC05NCw3ICs5NCw3IEBACiAJc3RydWN0IGVhcF9zaW1fZGF0YSAqZGF0YSA9IHByaXY7CiAJb3NfZnJlZShkYXRhLT5uZXh0X3BzZXVkb255bSk7CiAJb3NfZnJlZShkYXRhLT5uZXh0X3JlYXV0aF9pZCk7Ci0Jb3NfZnJlZShkYXRhKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLCBzaXplb2YoKmRhdGEpKTsKIH0KIAogCkBAIC0xNDAsNyArMTQwLDcgQEAKIAl2ZXJbMV0gPSBFQVBfU0lNX1ZFUlNJT047CiAJZWFwX3NpbV9tc2dfYWRkKG1zZywgRUFQX1NJTV9BVF9WRVJTSU9OX0xJU1QsIHNpemVvZih2ZXIpLAogCQkJdmVyLCBzaXplb2YodmVyKSk7Ci0JcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIE5VTEwsIE5VTEwsIDApOworCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBFQVBfVFlQRV9TSU0sIE5VTEwsIE5VTEwsIDApOwogfQogCiAKQEAgLTI0MCw4ICsyNDAsOCBAQAogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9NQUMiKTsKIAllYXBfc2ltX21zZ19hZGRfbWFjKG1zZywgRUFQX1NJTV9BVF9NQUMpOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5rX2F1dCwgZGF0YS0+bm9uY2VfbXQsCi0JCQkJICBFQVBfU0lNX05PTkNFX01UX0xFTik7CisJcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIEVBUF9UWVBFX1NJTSwgZGF0YS0+a19hdXQsCisJCQkJICBkYXRhLT5ub25jZV9tdCwgRUFQX1NJTV9OT05DRV9NVF9MRU4pOwogfQogCiAKQEAgLTI3OCw3ICsyNzgsNyBAQAogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9NQUMiKTsKIAllYXBfc2ltX21zZ19hZGRfbWFjKG1zZywgRUFQX1NJTV9BVF9NQUMpOwotCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBkYXRhLT5rX2F1dCwgTlVMTCwgMCk7CisJcmV0dXJuIGVhcF9zaW1fbXNnX2ZpbmlzaChtc2csIEVBUF9UWVBFX1NJTSwgZGF0YS0+a19hdXQsIE5VTEwsIDApOwogfQogCiAKQEAgLTMxNyw3ICszMTcsNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX01BQyIpOwogCQllYXBfc2ltX21zZ19hZGRfbWFjKG1zZywgRUFQX1NJTV9BVF9NQUMpOwogCX0KLQlyZXR1cm4gZWFwX3NpbV9tc2dfZmluaXNoKG1zZywgZGF0YS0+a19hdXQsIE5VTEwsIDApOworCXJldHVybiBlYXBfc2ltX21zZ19maW5pc2gobXNnLCBFQVBfVFlQRV9TSU0sIGRhdGEtPmtfYXV0LCBOVUxMLCAwKTsKIH0KIAogCmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3Rscy5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl90bHMuYwppbmRleCA0NDdmNDdjLi42YmVkNjJmIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3Rscy5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfdGxzLmMKQEAgLTk0LDYgKzk0LDI4IEBACiAjZW5kaWYgLyogRUFQX1NFUlZFUl9VTkFVVEhfVExTICovCiAKIAorI2lmZGVmIENPTkZJR19IUzIwCitzdGF0aWMgdm9pZCAqIGVhcF93ZmFfdW5hdXRoX3Rsc19pbml0KHN0cnVjdCBlYXBfc20gKnNtKQoreworCXN0cnVjdCBlYXBfdGxzX2RhdGEgKmRhdGE7CisKKwlkYXRhID0gb3NfemFsbG9jKHNpemVvZigqZGF0YSkpOworCWlmIChkYXRhID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCWRhdGEtPnN0YXRlID0gU1RBUlQ7CisKKwlpZiAoZWFwX3NlcnZlcl90bHNfc3NsX2luaXQoc20sICZkYXRhLT5zc2wsIDApKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtVExTOiBGYWlsZWQgdG8gaW5pdGlhbGl6ZSBTU0wuIik7CisJCWVhcF90bHNfcmVzZXQoc20sIGRhdGEpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlkYXRhLT5lYXBfdHlwZSA9IEVBUF9XRkFfVU5BVVRIX1RMU19UWVBFOworCXJldHVybiBkYXRhOworfQorI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisKKwogc3RhdGljIHZvaWQgZWFwX3Rsc19yZXNldChzdHJ1Y3QgZWFwX3NtICpzbSwgdm9pZCAqcHJpdikKIHsKIAlzdHJ1Y3QgZWFwX3Rsc19kYXRhICpkYXRhID0gcHJpdjsKQEAgLTE3OCw2ICsyMDAsMTAgQEAKIAkJcG9zID0gZWFwX2hkcl92YWxpZGF0ZShFQVBfVkVORE9SX1VOQVVUSF9UTFMsCiAJCQkJICAgICAgIEVBUF9WRU5ET1JfVFlQRV9VTkFVVEhfVExTLCByZXNwRGF0YSwKIAkJCQkgICAgICAgJmxlbik7CisJZWxzZSBpZiAoZGF0YS0+ZWFwX3R5cGUgPT0gRUFQX1dGQV9VTkFVVEhfVExTX1RZUEUpCisJCXBvcyA9IGVhcF9oZHJfdmFsaWRhdGUoRUFQX1ZFTkRPUl9XRkFfTkVXLAorCQkJCSAgICAgICBFQVBfVkVORE9SX1dGQV9VTkFVVEhfVExTLCByZXNwRGF0YSwKKwkJCQkgICAgICAgJmxlbik7CiAJZWxzZQogCQlwb3MgPSBlYXBfaGRyX3ZhbGlkYXRlKEVBUF9WRU5ET1JfSUVURiwgZGF0YS0+ZWFwX3R5cGUsCiAJCQkJICAgICAgIHJlc3BEYXRhLCAmbGVuKTsKQEAgLTM0MCwzICszNjYsMzQgQEAKIAlyZXR1cm4gcmV0OwogfQogI2VuZGlmIC8qIEVBUF9TRVJWRVJfVU5BVVRIX1RMUyAqLworCisKKyNpZmRlZiBDT05GSUdfSFMyMAoraW50IGVhcF9zZXJ2ZXJfd2ZhX3VuYXV0aF90bHNfcmVnaXN0ZXIodm9pZCkKK3sKKwlzdHJ1Y3QgZWFwX21ldGhvZCAqZWFwOworCWludCByZXQ7CisKKwllYXAgPSBlYXBfc2VydmVyX21ldGhvZF9hbGxvYyhFQVBfU0VSVkVSX01FVEhPRF9JTlRFUkZBQ0VfVkVSU0lPTiwKKwkJCQkgICAgICBFQVBfVkVORE9SX1dGQV9ORVcsCisJCQkJICAgICAgRUFQX1ZFTkRPUl9XRkFfVU5BVVRIX1RMUywKKwkJCQkgICAgICAiV0ZBLVVOQVVUSC1UTFMiKTsKKwlpZiAoZWFwID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCWVhcC0+aW5pdCA9IGVhcF93ZmFfdW5hdXRoX3Rsc19pbml0OworCWVhcC0+cmVzZXQgPSBlYXBfdGxzX3Jlc2V0OworCWVhcC0+YnVpbGRSZXEgPSBlYXBfdGxzX2J1aWxkUmVxOworCWVhcC0+Y2hlY2sgPSBlYXBfdGxzX2NoZWNrOworCWVhcC0+cHJvY2VzcyA9IGVhcF90bHNfcHJvY2VzczsKKwllYXAtPmlzRG9uZSA9IGVhcF90bHNfaXNEb25lOworCWVhcC0+Z2V0S2V5ID0gZWFwX3Rsc19nZXRLZXk7CisJZWFwLT5pc1N1Y2Nlc3MgPSBlYXBfdGxzX2lzU3VjY2VzczsKKwllYXAtPmdldF9lbXNrID0gZWFwX3Rsc19nZXRfZW1zazsKKworCXJldCA9IGVhcF9zZXJ2ZXJfbWV0aG9kX3JlZ2lzdGVyKGVhcCk7CisJaWYgKHJldCkKKwkJZWFwX3NlcnZlcl9tZXRob2RfZnJlZShlYXApOworCXJldHVybiByZXQ7Cit9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfdGxzX2NvbW1vbi5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl90bHNfY29tbW9uLmMKaW5kZXggOWVmYjViMi4uMDE4NTNlNiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl90bHNfY29tbW9uLmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl90bHNfY29tbW9uLmMKQEAgLTI1LDE0ICsyNSwzMiBAQAogCQlyZXR1cm4gZWFwX21zZ19hbGxvYyhFQVBfVkVORE9SX1VOQVVUSF9UTFMsCiAJCQkJICAgICBFQVBfVkVORE9SX1RZUEVfVU5BVVRIX1RMUywgcGF5bG9hZF9sZW4sCiAJCQkJICAgICBjb2RlLCBpZGVudGlmaWVyKTsKKwllbHNlIGlmICh0eXBlID09IEVBUF9XRkFfVU5BVVRIX1RMU19UWVBFKQorCQlyZXR1cm4gZWFwX21zZ19hbGxvYyhFQVBfVkVORE9SX1dGQV9ORVcsCisJCQkJICAgICBFQVBfVkVORE9SX1dGQV9VTkFVVEhfVExTLCBwYXlsb2FkX2xlbiwKKwkJCQkgICAgIGNvZGUsIGlkZW50aWZpZXIpOwogCXJldHVybiBlYXBfbXNnX2FsbG9jKEVBUF9WRU5ET1JfSUVURiwgdHlwZSwgcGF5bG9hZF9sZW4sIGNvZGUsCiAJCQkgICAgIGlkZW50aWZpZXIpOwogfQogCiAKKyNpZmRlZiBDT05GSUdfVExTX0lOVEVSTkFMCitzdGF0aWMgdm9pZCBlYXBfc2VydmVyX3Rsc19sb2dfY2Iodm9pZCAqY3R4LCBjb25zdCBjaGFyICptc2cpCit7CisJc3RydWN0IGVhcF9zbSAqc20gPSBjdHg7CisJZWFwX2xvZ19tc2coc20sICJUTFM6ICVzIiwgbXNnKTsKK30KKyNlbmRpZiAvKiBDT05GSUdfVExTX0lOVEVSTkFMICovCisKKwogaW50IGVhcF9zZXJ2ZXJfdGxzX3NzbF9pbml0KHN0cnVjdCBlYXBfc20gKnNtLCBzdHJ1Y3QgZWFwX3NzbF9kYXRhICpkYXRhLAogCQkJICAgIGludCB2ZXJpZnlfcGVlcikKIHsKKwlpZiAoc20tPnNzbF9jdHggPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIlRMUyBjb250ZXh0IG5vdCBpbml0aWFsaXplZCAtIGNhbm5vdCB1c2UgVExTLWJhc2VkIEVBUCBtZXRob2QiKTsKKwkJcmV0dXJuIC0xOworCX0KKwogCWRhdGEtPmVhcCA9IHNtOwogCWRhdGEtPnBoYXNlMiA9IHNtLT5pbml0X3BoYXNlMjsKIApAQCAtNDMsNiArNjEsMTMgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAorI2lmZGVmIENPTkZJR19UTFNfSU5URVJOQUwKKwl0bHNfY29ubmVjdGlvbl9zZXRfbG9nX2NiKGRhdGEtPmNvbm4sIGVhcF9zZXJ2ZXJfdGxzX2xvZ19jYiwgc20pOworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKwl0bHNfY29ubmVjdGlvbl9zZXRfdGVzdF9mbGFncyhkYXRhLT5jb25uLCBzbS0+dGxzX3Rlc3RfZmxhZ3MpOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKyNlbmRpZiAvKiBDT05GSUdfVExTX0lOVEVSTkFMICovCisKIAlpZiAodGxzX2Nvbm5lY3Rpb25fc2V0X3ZlcmlmeShzbS0+c3NsX2N0eCwgZGF0YS0+Y29ubiwgdmVyaWZ5X3BlZXIpKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJTU0w6IEZhaWxlZCB0byBjb25maWd1cmUgdmVyaWZpY2F0aW9uICIKIAkJCSAgICJvZiBUTFMgcGVlciBjZXJ0aWZpY2F0ZSIpOwpAQCAtMzg4LDYgKzQxMywxMCBAQAogCQlwb3MgPSBlYXBfaGRyX3ZhbGlkYXRlKEVBUF9WRU5ET1JfVU5BVVRIX1RMUywKIAkJCQkgICAgICAgRUFQX1ZFTkRPUl9UWVBFX1VOQVVUSF9UTFMsIHJlc3BEYXRhLAogCQkJCSAgICAgICAmbGVmdCk7CisJZWxzZSBpZiAoZWFwX3R5cGUgPT0gRUFQX1dGQV9VTkFVVEhfVExTX1RZUEUpCisJCXBvcyA9IGVhcF9oZHJfdmFsaWRhdGUoRUFQX1ZFTkRPUl9XRkFfTkVXLAorCQkJCSAgICAgICBFQVBfVkVORE9SX1dGQV9VTkFVVEhfVExTLCByZXNwRGF0YSwKKwkJCQkgICAgICAgJmxlZnQpOwogCWVsc2UKIAkJcG9zID0gZWFwX2hkcl92YWxpZGF0ZShFQVBfVkVORE9SX0lFVEYsIGVhcF90eXBlLCByZXNwRGF0YSwKIAkJCQkgICAgICAgJmxlZnQpOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl90bmMuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfdG5jLmMKaW5kZXggNjdhM2RmYS4uMjFiZDI2ZiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl90bmMuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3RuYy5jCkBAIC00ODAsNyArNDgwLDggQEAKIAkJbWVzc2FnZV9sZW5ndGggPSBXUEFfR0VUX0JFMzIocG9zKTsKIAkJcG9zICs9IDQ7CiAKLQkJaWYgKG1lc3NhZ2VfbGVuZ3RoIDwgKHUzMikgKGVuZCAtIHBvcykpIHsKKwkJaWYgKG1lc3NhZ2VfbGVuZ3RoIDwgKHUzMikgKGVuZCAtIHBvcykgfHwKKwkJICAgIG1lc3NhZ2VfbGVuZ3RoID4gNzUwMDApIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVROQzogSW52YWxpZCBNZXNzYWdlICIKIAkJCQkgICAiTGVuZ3RoICglZDsgJWxkIHJlbWFpbmluZyBpbiB0aGlzIG1zZykiLAogCQkJCSAgIG1lc3NhZ2VfbGVuZ3RoLCAobG9uZykgKGVuZCAtIHBvcykpOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl90dGxzLmMgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3R0bHMuYwppbmRleCA2NDdiZDJmLi4zMWUzODcxIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3R0bHMuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3R0bHMuYwpAQCAtMzM2LDcgKzMzNiw3IEBACiAJCWRhdGEtPnBoYXNlMl9tZXRob2QtPnJlc2V0KHNtLCBkYXRhLT5waGFzZTJfcHJpdik7CiAJZWFwX3NlcnZlcl90bHNfc3NsX2RlaW5pdChzbSwgJmRhdGEtPnNzbCk7CiAJd3BhYnVmX2ZyZWUoZGF0YS0+cGVuZGluZ19waGFzZTJfZWFwX3Jlc3ApOwotCW9zX2ZyZWUoZGF0YSk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiB9CiAKIApAQCAtNTA5LDggKzUwOSw4IEBACiAJfQogCiAJaWYgKHNtLT51c2VyLT5wYXNzd29yZF9sZW4gIT0gdXNlcl9wYXNzd29yZF9sZW4gfHwKLQkgICAgb3NfbWVtY21wKHNtLT51c2VyLT5wYXNzd29yZCwgdXNlcl9wYXNzd29yZCwgdXNlcl9wYXNzd29yZF9sZW4pICE9Ci0JICAgIDApIHsKKwkgICAgb3NfbWVtY21wX2NvbnN0KHNtLT51c2VyLT5wYXNzd29yZCwgdXNlcl9wYXNzd29yZCwKKwkJCSAgICB1c2VyX3Bhc3N3b3JkX2xlbikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1UVExTL1BBUDogSW52YWxpZCB1c2VyIHBhc3N3b3JkIik7CiAJCWVhcF90dGxzX3N0YXRlKGRhdGEsIEZBSUxVUkUpOwogCQlyZXR1cm47CkBAIC01NTgsNyArNTU4LDggQEAKIAkJcmV0dXJuOwogCX0KIAotCWlmIChvc19tZW1jbXAoY2hhbGxlbmdlLCBjaGFsLCBFQVBfVFRMU19DSEFQX0NIQUxMRU5HRV9MRU4pICE9IDAgfHwKKwlpZiAob3NfbWVtY21wX2NvbnN0KGNoYWxsZW5nZSwgY2hhbCwgRUFQX1RUTFNfQ0hBUF9DSEFMTEVOR0VfTEVOKQorCSAgICAhPSAwIHx8CiAJICAgIHBhc3N3b3JkWzBdICE9IGNoYWxbRUFQX1RUTFNfQ0hBUF9DSEFMTEVOR0VfTEVOXSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1UVExTL0NIQVA6IENoYWxsZW5nZSBtaXNtYXRjaCIpOwogCQlvc19mcmVlKGNoYWwpOwpAQCAtNTcxLDcgKzU3Miw4IEBACiAJY2hhcF9tZDUocGFzc3dvcmRbMF0sIHNtLT51c2VyLT5wYXNzd29yZCwgc20tPnVzZXItPnBhc3N3b3JkX2xlbiwKIAkJIGNoYWxsZW5nZSwgY2hhbGxlbmdlX2xlbiwgaGFzaCk7CiAKLQlpZiAob3NfbWVtY21wKGhhc2gsIHBhc3N3b3JkICsgMSwgRUFQX1RUTFNfQ0hBUF9QQVNTV09SRF9MRU4pID09IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KGhhc2gsIHBhc3N3b3JkICsgMSwgRUFQX1RUTFNfQ0hBUF9QQVNTV09SRF9MRU4pID09CisJICAgIDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtVFRMUy9DSEFQOiBDb3JyZWN0IHVzZXIgcGFzc3dvcmQiKTsKIAkJZWFwX3R0bHNfc3RhdGUoZGF0YSwgU1VDQ0VTUyk7CiAJfSBlbHNlIHsKQEAgLTYxNiw3ICs2MTgsOCBAQAogCQlyZXR1cm47CiAJfQogCi0JaWYgKG9zX21lbWNtcChjaGFsbGVuZ2UsIGNoYWwsIEVBUF9UVExTX01TQ0hBUF9DSEFMTEVOR0VfTEVOKSAhPSAwIHx8CisJaWYgKG9zX21lbWNtcF9jb25zdChjaGFsbGVuZ2UsIGNoYWwsIEVBUF9UVExTX01TQ0hBUF9DSEFMTEVOR0VfTEVOKQorCSAgICAhPSAwIHx8CiAJICAgIHJlc3BvbnNlWzBdICE9IGNoYWxbRUFQX1RUTFNfTVNDSEFQX0NIQUxMRU5HRV9MRU5dKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVRUTFMvTVNDSEFQOiBDaGFsbGVuZ2UgbWlzbWF0Y2giKTsKIAkJb3NfZnJlZShjaGFsKTsKQEAgLTYzMSw3ICs2MzQsNyBAQAogCQludF9jaGFsbGVuZ2VfcmVzcG9uc2UoY2hhbGxlbmdlLCBzbS0+dXNlci0+cGFzc3dvcmQsCiAJCQkJICAgICAgc20tPnVzZXItPnBhc3N3b3JkX2xlbiwgbnRfcmVzcG9uc2UpOwogCi0JaWYgKG9zX21lbWNtcChudF9yZXNwb25zZSwgcmVzcG9uc2UgKyAyICsgMjQsIDI0KSA9PSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChudF9yZXNwb25zZSwgcmVzcG9uc2UgKyAyICsgMjQsIDI0KSA9PSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVRUTFMvTVNDSEFQOiBDb3JyZWN0IHJlc3BvbnNlIik7CiAJCWVhcF90dGxzX3N0YXRlKGRhdGEsIFNVQ0NFU1MpOwogCX0gZWxzZSB7CkBAIC03MDMsNyArNzA2LDggQEAKIAkJcmV0dXJuOwogCX0KIAotCWlmIChvc19tZW1jbXAoY2hhbGxlbmdlLCBjaGFsLCBFQVBfVFRMU19NU0NIQVBWMl9DSEFMTEVOR0VfTEVOKSAhPSAwIHx8CisJaWYgKG9zX21lbWNtcF9jb25zdChjaGFsbGVuZ2UsIGNoYWwsIEVBUF9UVExTX01TQ0hBUFYyX0NIQUxMRU5HRV9MRU4pCisJICAgICE9IDAgfHwKIAkgICAgcmVzcG9uc2VbMF0gIT0gY2hhbFtFQVBfVFRMU19NU0NIQVBWMl9DSEFMTEVOR0VfTEVOXSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1UVExTL01TQ0hBUFYyOiBDaGFsbGVuZ2UgbWlzbWF0Y2giKTsKIAkJb3NfZnJlZShjaGFsKTsKQEAgLTczNiw3ICs3NDAsNyBAQAogCX0KIAogCXJ4X3Jlc3AgPSByZXNwb25zZSArIDIgKyBFQVBfVFRMU19NU0NIQVBWMl9DSEFMTEVOR0VfTEVOICsgODsKLQlpZiAob3NfbWVtY21wKG50X3Jlc3BvbnNlLCByeF9yZXNwLCAyNCkgPT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QobnRfcmVzcG9uc2UsIHJ4X3Jlc3AsIDI0KSA9PSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVRUTFMvTVNDSEFQVjI6IENvcnJlY3QgIgogCQkJICAgIk5ULVJlc3BvbnNlIik7CiAJCWRhdGEtPm1zY2hhcHYyX3Jlc3Bfb2sgPSAxOwpAQCAtOTg0LDYgKzk4OCwxNiBAQAogCX0KIAogCWlmIChwYXJzZS51c2VyX25hbWUpIHsKKwkJY2hhciAqbmJ1ZjsKKwkJbmJ1ZiA9IG9zX21hbGxvYyhwYXJzZS51c2VyX25hbWVfbGVuICogNCArIDEpOworCQlpZiAobmJ1ZikgeworCQkJcHJpbnRmX2VuY29kZShuYnVmLCBwYXJzZS51c2VyX25hbWVfbGVuICogNCArIDEsCisJCQkJICAgICAgcGFyc2UudXNlcl9uYW1lLAorCQkJCSAgICAgIHBhcnNlLnVzZXJfbmFtZV9sZW4pOworCQkJZWFwX2xvZ19tc2coc20sICJUVExTLVVzZXItTmFtZSAnJXMnIiwgbmJ1Zik7CisJCQlvc19mcmVlKG5idWYpOworCQl9CisKIAkJb3NfZnJlZShzbS0+aWRlbnRpdHkpOwogCQlzbS0+aWRlbnRpdHkgPSBvc19tYWxsb2MocGFyc2UudXNlcl9uYW1lX2xlbik7CiAJCWlmIChzbS0+aWRlbnRpdHkgPT0gTlVMTCkgewpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NpbV9kYi5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NpbV9kYi5jCmluZGV4IDFiOWQ3MDEuLmJjMmNiZTUgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfc2VydmVyL2VhcF9zaW1fZGIuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2ltX2RiLmMKQEAgLTM4LDcgKzM4LDYgQEAKIAljaGFyIGltc2lbMjBdOwogCWVudW0geyBQRU5ESU5HLCBTVUNDRVNTLCBGQUlMVVJFIH0gc3RhdGU7CiAJdm9pZCAqY2Jfc2Vzc2lvbl9jdHg7Ci0Jc3RydWN0IG9zX3RpbWUgdGltZXN0YW1wOwogCWludCBha2E7CiAJdW5pb24gewogCQlzdHJ1Y3QgewpAQCAtNjMwLDcgKzYyOSw3IEBACiAKIAlkYXRhLT5zb2NrID0gc29ja2V0KFBGX1VOSVgsIFNPQ0tfREdSQU0sIDApOwogCWlmIChkYXRhLT5zb2NrIDwgMCkgewotCQlwZXJyb3IoInNvY2tldChlYXBfc2ltX2RiKSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAic29ja2V0KGVhcF9zaW1fZGIpOiAlcyIsIHN0cmVycm9yKGVycm5vKSk7CiAJCXJldHVybiAtMTsKIAl9CiAKQEAgLTY0MCw4ICs2MzksMTMgQEAKIAkJICAgICIvdG1wL2VhcF9zaW1fZGJfJWQtJWQiLCBnZXRwaWQoKSwgY291bnRlcisrKTsKIAlvc19mcmVlKGRhdGEtPmxvY2FsX3NvY2spOwogCWRhdGEtPmxvY2FsX3NvY2sgPSBvc19zdHJkdXAoYWRkci5zdW5fcGF0aCk7CisJaWYgKGRhdGEtPmxvY2FsX3NvY2sgPT0gTlVMTCkgeworCQljbG9zZShkYXRhLT5zb2NrKTsKKwkJZGF0YS0+c29jayA9IC0xOworCQlyZXR1cm4gLTE7CisJfQogCWlmIChiaW5kKGRhdGEtPnNvY2ssIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmFkZHIsIHNpemVvZihhZGRyKSkgPCAwKSB7Ci0JCXBlcnJvcigiYmluZChlYXBfc2ltX2RiKSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiYmluZChlYXBfc2ltX2RiKTogJXMiLCBzdHJlcnJvcihlcnJubykpOwogCQljbG9zZShkYXRhLT5zb2NrKTsKIAkJZGF0YS0+c29jayA9IC0xOwogCQlyZXR1cm4gLTE7CkBAIC02NTEsMTIgKzY1NSwxNiBAQAogCWFkZHIuc3VuX2ZhbWlseSA9IEFGX1VOSVg7CiAJb3Nfc3RybGNweShhZGRyLnN1bl9wYXRoLCBkYXRhLT5mbmFtZSArIDUsIHNpemVvZihhZGRyLnN1bl9wYXRoKSk7CiAJaWYgKGNvbm5lY3QoZGF0YS0+c29jaywgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApIHsKLQkJcGVycm9yKCJjb25uZWN0KGVhcF9zaW1fZGIpIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJjb25uZWN0KGVhcF9zaW1fZGIpOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfSU5GTywgIkhMUi9BdUMgR1cgc29ja2V0IiwKIAkJCQkgICh1OCAqKSBhZGRyLnN1bl9wYXRoLAogCQkJCSAgb3Nfc3RybGVuKGFkZHIuc3VuX3BhdGgpKTsKIAkJY2xvc2UoZGF0YS0+c29jayk7CiAJCWRhdGEtPnNvY2sgPSAtMTsKKwkJdW5saW5rKGRhdGEtPmxvY2FsX3NvY2spOworCQlvc19mcmVlKGRhdGEtPmxvY2FsX3NvY2spOworCQlkYXRhLT5sb2NhbF9zb2NrID0gTlVMTDsKIAkJcmV0dXJuIC0xOwogCX0KIApAQCAtODA0LDcgKzgxMiw4IEBACiAKIAlpZiAoc2VuZChkYXRhLT5zb2NrLCBtc2csIGxlbiwgMCkgPCAwKSB7CiAJCV9lcnJubyA9IGVycm5vOwotCQlwZXJyb3IoInNlbmRbRUFQLVNJTSBEQiBVTklYXSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAic2VuZFtFQVAtU0lNIERCIFVOSVhdOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCX0KIAogCWlmIChfZXJybm8gPT0gRU5PVENPTk4gfHwgX2Vycm5vID09IEVERVNUQUREUlJFUSB8fCBfZXJybm8gPT0gRUlOVkFMIHx8CkBAIC04MTYsNyArODI1LDggQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtU0lNIERCOiBSZWNvbm5lY3RlZCB0byB0aGUgIgogCQkJICAgImV4dGVybmFsIHNlcnZlciIpOwogCQlpZiAoc2VuZChkYXRhLT5zb2NrLCBtc2csIGxlbiwgMCkgPCAwKSB7Ci0JCQlwZXJyb3IoInNlbmRbRUFQLVNJTSBEQiBVTklYXSIpOworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgInNlbmRbRUFQLVNJTSBEQiBVTklYXTogJXMiLAorCQkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAl9CkBAIC05MzIsNyArOTQyLDYgQEAKIAlpZiAoZW50cnkgPT0gTlVMTCkKIAkJcmV0dXJuIEVBUF9TSU1fREJfRkFJTFVSRTsKIAotCW9zX2dldF90aW1lKCZlbnRyeS0+dGltZXN0YW1wKTsKIAlvc19zdHJsY3B5KGVudHJ5LT5pbXNpLCBpbXNpLCBzaXplb2YoZW50cnktPmltc2kpKTsKIAllbnRyeS0+Y2Jfc2Vzc2lvbl9jdHggPSBjYl9zZXNzaW9uX2N0eDsKIAllbnRyeS0+c3RhdGUgPSBQRU5ESU5HOwpAQCAtMTM5Miw3ICsxNDAxLDYgQEAKIAlpZiAoZW50cnkgPT0gTlVMTCkKIAkJcmV0dXJuIEVBUF9TSU1fREJfRkFJTFVSRTsKIAotCW9zX2dldF90aW1lKCZlbnRyeS0+dGltZXN0YW1wKTsKIAllbnRyeS0+YWthID0gMTsKIAlvc19zdHJsY3B5KGVudHJ5LT5pbXNpLCBpbXNpLCBzaXplb2YoZW50cnktPmltc2kpKTsKIAllbnRyeS0+Y2Jfc2Vzc2lvbl9jdHggPSBjYl9zZXNzaW9uX2N0eDsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF90bHNfY29tbW9uLmggYi9zcmMvZWFwX3NlcnZlci9lYXBfdGxzX2NvbW1vbi5oCmluZGV4IDExZjU4MjcuLjkxNDQ5YWYgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfc2VydmVyL2VhcF90bHNfY29tbW9uLmgKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3Rsc19jb21tb24uaApAQCAtNjQsNiArNjQsNyBAQAogCiAvKiBkdW1teSB0eXBlIHVzZWQgYXMgYSBmbGFnIGZvciBVTkFVVEgtVExTICovCiAjZGVmaW5lIEVBUF9VTkFVVEhfVExTX1RZUEUgMjU1CisjZGVmaW5lIEVBUF9XRkFfVU5BVVRIX1RMU19UWVBFIDI1NAogCiAKIHN0cnVjdCB3cGFidWYgKiBlYXBfdGxzX21zZ19hbGxvYyhFYXBUeXBlIHR5cGUsIHNpemVfdCBwYXlsb2FkX2xlbiwKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2lrZXYyLmMgYi9zcmMvZWFwX3NlcnZlci9pa2V2Mi5jCmluZGV4IDUxMmJhMzAuLjYzMjU5OGYgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfc2VydmVyL2lrZXYyLmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvaWtldjIuYwpAQCAtNjMzLDcgKzYzMyw3IEBACiAJCXJldHVybiAtMTsKIAogCWlmIChhdXRoX2xlbiAhPSBwcmYtPmhhc2hfbGVuIHx8Ci0JICAgIG9zX21lbWNtcChhdXRoLCBhdXRoX2RhdGEsIGF1dGhfbGVuKSAhPSAwKSB7CisJICAgIG9zX21lbWNtcF9jb25zdChhdXRoLCBhdXRoX2RhdGEsIGF1dGhfbGVuKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJJS0VWMjogSW52YWxpZCBBdXRoZW50aWNhdGlvbiBEYXRhIik7CiAJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIklLRVYyOiBSZWNlaXZlZCBBdXRoZW50aWNhdGlvbiBEYXRhIiwKIAkJCSAgICBhdXRoLCBhdXRoX2xlbik7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci90bmNzLmMgYi9zcmMvZWFwX3NlcnZlci90bmNzLmMKaW5kZXggZTQyOWYxZS4uZGM2ZjY4OSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvdG5jcy5jCisrKyBiL3NyYy9lYXBfc2VydmVyL3RuY3MuYwpAQCAtMTEsNiArMTEsNyBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAiYmFzZTY0LmgiCisjaW5jbHVkZSAiY29tbW9uL3RuYy5oIgogI2luY2x1ZGUgInRuY3MuaCIKICNpbmNsdWRlICJlYXBfY29tbW9uL2VhcF90bHZfY29tbW9uLmgiCiAjaW5jbHVkZSAiZWFwX2NvbW1vbi9lYXBfZGVmcy5oIgpAQCAtMTksNyArMjAsOSBAQAogLyogVE9ETzogVE5DUyBtdXN0IGJlIHRocmVhZC1zYWZlOyByZXZpZXcgdGhlIGNvZGUgYW5kIGFkZCBsb2NraW5nIGV0Yy4gaWYKICAqIG5lZWRlZC4uICovCiAKKyNpZm5kZWYgVE5DX0NPTkZJR19GSUxFCiAjZGVmaW5lIFROQ19DT05GSUdfRklMRSAiL2V0Yy90bmNfY29uZmlnIgorI2VuZGlmIC8qIFROQ19DT05GSUdfRklMRSAqLwogI2RlZmluZSBJRl9UTkNDU19TVEFSVCBcCiAiPD94bWwgdmVyc2lvbj1cIjEuMFwiPz5cbiIgXAogIjxUTkNDUy1CYXRjaCBCYXRjaElkPVwiJWRcIiBSZWNpcGllbnQ9XCJUTkNTXCIgIiBcCkBAIC0zMSw3NSArMzQsNiBAQAogCiAvKiBUTkMgSUYtSU1WICovCiAKLXR5cGVkZWYgdW5zaWduZWQgbG9uZyBUTkNfVUludDMyOwotdHlwZWRlZiB1bnNpZ25lZCBjaGFyICpUTkNfQnVmZmVyUmVmZXJlbmNlOwotCi10eXBlZGVmIFROQ19VSW50MzIgVE5DX0lNVklEOwotdHlwZWRlZiBUTkNfVUludDMyIFROQ19Db25uZWN0aW9uSUQ7Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX0Nvbm5lY3Rpb25TdGF0ZTsKLXR5cGVkZWYgVE5DX1VJbnQzMiBUTkNfUmV0cnlSZWFzb247Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX0lNVl9BY3Rpb25fUmVjb21tZW5kYXRpb247Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX0lNVl9FdmFsdWF0aW9uX1Jlc3VsdDsKLXR5cGVkZWYgVE5DX1VJbnQzMiBUTkNfTWVzc2FnZVR5cGU7Ci10eXBlZGVmIFROQ19NZXNzYWdlVHlwZSAqVE5DX01lc3NhZ2VUeXBlTGlzdDsKLXR5cGVkZWYgVE5DX1VJbnQzMiBUTkNfVmVuZG9ySUQ7Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX1N1YnR5cGU7Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX1ZlcnNpb247Ci10eXBlZGVmIFROQ19VSW50MzIgVE5DX1Jlc3VsdDsKLXR5cGVkZWYgVE5DX1VJbnQzMiBUTkNfQXR0cmlidXRlSUQ7Ci0KLXR5cGVkZWYgVE5DX1Jlc3VsdCAoKlROQ19UTkNTX0JpbmRGdW5jdGlvblBvaW50ZXIpKAotCVROQ19JTVZJRCBpbXZJRCwKLQljaGFyICpmdW5jdGlvbk5hbWUsCi0Jdm9pZCAqKnBPdXRmdW5jdGlvblBvaW50ZXIpOwotCi0jZGVmaW5lIFROQ19SRVNVTFRfU1VDQ0VTUyAwCi0jZGVmaW5lIFROQ19SRVNVTFRfTk9UX0lOSVRJQUxJWkVEIDEKLSNkZWZpbmUgVE5DX1JFU1VMVF9BTFJFQURZX0lOSVRJQUxJWkVEIDIKLSNkZWZpbmUgVE5DX1JFU1VMVF9OT19DT01NT05fVkVSU0lPTiAzCi0jZGVmaW5lIFROQ19SRVNVTFRfQ0FOVF9SRVRSWSA0Ci0jZGVmaW5lIFROQ19SRVNVTFRfV09OVF9SRVRSWSA1Ci0jZGVmaW5lIFROQ19SRVNVTFRfSU5WQUxJRF9QQVJBTUVURVIgNgotI2RlZmluZSBUTkNfUkVTVUxUX0NBTlRfUkVTUE9ORCA3Ci0jZGVmaW5lIFROQ19SRVNVTFRfSUxMRUdBTF9PUEVSQVRJT04gOAotI2RlZmluZSBUTkNfUkVTVUxUX09USEVSIDkKLSNkZWZpbmUgVE5DX1JFU1VMVF9GQVRBTCAxMAotCi0jZGVmaW5lIFROQ19DT05ORUNUSU9OX1NUQVRFX0NSRUFURSAwCi0jZGVmaW5lIFROQ19DT05ORUNUSU9OX1NUQVRFX0hBTkRTSEFLRSAxCi0jZGVmaW5lIFROQ19DT05ORUNUSU9OX1NUQVRFX0FDQ0VTU19BTExPV0VEIDIKLSNkZWZpbmUgVE5DX0NPTk5FQ1RJT05fU1RBVEVfQUNDRVNTX0lTT0xBVEVEIDMKLSNkZWZpbmUgVE5DX0NPTk5FQ1RJT05fU1RBVEVfQUNDRVNTX05PTkUgNAotI2RlZmluZSBUTkNfQ09OTkVDVElPTl9TVEFURV9ERUxFVEUgNQotCi0jZGVmaW5lIFROQ19JRklNVl9WRVJTSU9OXzEgMQotCi0jZGVmaW5lIFROQ19WRU5ET1JJRF9BTlkgKChUTkNfVmVuZG9ySUQpIDB4ZmZmZmZmKQotI2RlZmluZSBUTkNfU1VCVFlQRV9BTlkgKChUTkNfU3VidHlwZSkgMHhmZikKLQotLyogVE5DQy1UTkNTIE1lc3NhZ2UgVHlwZXMgKi8KLSNkZWZpbmUgVE5DX1ROQ0NTX1JFQ09NTUVOREFUSU9OCQkweDAwMDAwMDAxCi0jZGVmaW5lIFROQ19UTkNDU19FUlJPUgkJCQkweDAwMDAwMDAyCi0jZGVmaW5lIFROQ19UTkNDU19QUkVGRVJSRURMQU5HVUFHRQkJMHgwMDAwMDAwMwotI2RlZmluZSBUTkNfVE5DQ1NfUkVBU09OU1RSSU5HUwkJCTB4MDAwMDAwMDQKLQotLyogUG9zc2libGUgVE5DX0lNVl9BY3Rpb25fUmVjb21tZW5kYXRpb24gdmFsdWVzOiAqLwotZW51bSBJTVZfQWN0aW9uX1JlY29tbWVuZGF0aW9uIHsKLQlUTkNfSU1WX0FDVElPTl9SRUNPTU1FTkRBVElPTl9BTExPVywKLQlUTkNfSU1WX0FDVElPTl9SRUNPTU1FTkRBVElPTl9OT19BQ0NFU1MsCi0JVE5DX0lNVl9BQ1RJT05fUkVDT01NRU5EQVRJT05fSVNPTEFURSwKLQlUTkNfSU1WX0FDVElPTl9SRUNPTU1FTkRBVElPTl9OT19SRUNPTU1FTkRBVElPTgotfTsKLQotLyogUG9zc2libGUgVE5DX0lNVl9FdmFsdWF0aW9uX1Jlc3VsdCB2YWx1ZXM6ICovCi1lbnVtIElNVl9FdmFsdWF0aW9uX1Jlc3VsdCB7Ci0JVE5DX0lNVl9FVkFMVUFUSU9OX1JFU1VMVF9DT01QTElBTlQsCi0JVE5DX0lNVl9FVkFMVUFUSU9OX1JFU1VMVF9OT05DT01QTElBTlRfTUlOT1IsCi0JVE5DX0lNVl9FVkFMVUFUSU9OX1JFU1VMVF9OT05DT01QTElBTlRfTUFKT1IsCi0JVE5DX0lNVl9FVkFMVUFUSU9OX1JFU1VMVF9FUlJPUiwKLQlUTkNfSU1WX0VWQUxVQVRJT05fUkVTVUxUX0RPTlRfS05PVwotfTsKLQogc3RydWN0IHRuY19pZl9pbXYgewogCXN0cnVjdCB0bmNfaWZfaW12ICpuZXh0OwogCWNoYXIgKm5hbWU7CkBAIC0xMTgxLDYgKzExMTUsOSBAQAogewogCXN0cnVjdCB0bmNfaWZfaW12ICppbXY7CiAKKwlpZiAodG5jc19nbG9iYWxfZGF0YSkKKwkJcmV0dXJuIDA7CisKIAl0bmNzX2dsb2JhbF9kYXRhID0gb3NfemFsbG9jKHNpemVvZigqdG5jc19nbG9iYWxfZGF0YSkpOwogCWlmICh0bmNzX2dsb2JhbF9kYXRhID09IE5VTEwpCiAJCXJldHVybiAtMTsKZGlmZiAtLWdpdCBhL3NyYy9lYXBvbF9hdXRoL01ha2VmaWxlIGIvc3JjL2VhcG9sX2F1dGgvTWFrZWZpbGUKaW5kZXggOWM0MTk2Mi4uYWRmZDNkZiAxMDA2NDQKLS0tIGEvc3JjL2VhcG9sX2F1dGgvTWFrZWZpbGUKKysrIGIvc3JjL2VhcG9sX2F1dGgvTWFrZWZpbGUKQEAgLTIsNyArMiw3IEBACiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgogCiBjbGVhbjoKLQlybSAtZiAqfiAqLm8gKi5kCisJcm0gLWYgKn4gKi5vICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgogCiBpbnN0YWxsOgogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KZGlmZiAtLWdpdCBhL3NyYy9lYXBvbF9hdXRoL2VhcG9sX2F1dGhfZHVtcC5jIGIvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9kdW1wLmMKaW5kZXggYjZlMGIxMy4uNmM2OTY5YiAxMDA2NDQKLS0tIGEvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9kdW1wLmMKKysrIGIvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9kdW1wLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogSUVFRSA4MDIuMVgtMjAwNCBBdXRoZW50aWNhdG9yIC0gU3RhdGUgZHVtcAotICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAxMywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTE4LDEwOCArMTE4LDE3MiBAQAogfQogCiAKLXZvaWQgZWFwb2xfYXV0aF9kdW1wX3N0YXRlKEZJTEUgKmYsIGNvbnN0IGNoYXIgKnByZWZpeCwKLQkJCSAgIHN0cnVjdCBlYXBvbF9zdGF0ZV9tYWNoaW5lICpzbSkKK2ludCBlYXBvbF9hdXRoX2R1bXBfc3RhdGUoc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtLCBjaGFyICpidWYsCisJCQkgIHNpemVfdCBidWZsZW4pCiB7Ci0JZnByaW50ZihmLCAiJXNFQVBPTCBzdGF0ZSBtYWNoaW5lOlxuIiwgcHJlZml4KTsKLQlmcHJpbnRmKGYsICIlcyAgYVdoaWxlPSVkIHF1aWV0V2hpbGU9JWQgcmVBdXRoV2hlbj0lZFxuIiwgcHJlZml4LAotCQlzbS0+YVdoaWxlLCBzbS0+cXVpZXRXaGlsZSwgc20tPnJlQXV0aFdoZW4pOworCWNoYXIgKnBvcywgKmVuZDsKKwlpbnQgcmV0OworCisJcG9zID0gYnVmOworCWVuZCA9IHBvcyArIGJ1ZmxlbjsKKworCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiYVdoaWxlPSVkXG5xdWlldFdoaWxlPSVkXG4iCisJCQkgICJyZUF1dGhXaGVuPSVkXG4iLAorCQkJICBzbS0+YVdoaWxlLCBzbS0+cXVpZXRXaGlsZSwgc20tPnJlQXV0aFdoZW4pOworCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCisJCXJldHVybiBwb3MgLSBidWY7CisJcG9zICs9IHJldDsKKwogI2RlZmluZSBfU0IoYikgKChiKSA/ICJUUlVFIiA6ICJGQUxTRSIpCi0JZnByaW50ZihmLAotCQkiJXMgIGF1dGhBYm9ydD0lcyBhdXRoRmFpbD0lcyBhdXRoUG9ydFN0YXR1cz0lcyBhdXRoU3RhcnQ9JXNcbiIKLQkJIiVzICBhdXRoVGltZW91dD0lcyBhdXRoU3VjY2Vzcz0lcyBlYXBGYWlsPSVzIGVhcG9sRWFwPSVzXG4iCi0JCSIlcyAgZWFwU3VjY2Vzcz0lcyBlYXBUaW1lb3V0PSVzIGluaXRpYWxpemU9JXMgIgotCQkia2V5QXZhaWxhYmxlPSVzXG4iCi0JCSIlcyAga2V5RG9uZT0lcyBrZXlSdW49JXMga2V5VHhFbmFibGVkPSVzIHBvcnRDb250cm9sPSVzXG4iCi0JCSIlcyAgcG9ydEVuYWJsZWQ9JXMgcG9ydFZhbGlkPSVzIHJlQXV0aGVudGljYXRlPSVzXG4iLAotCQlwcmVmaXgsIF9TQihzbS0+YXV0aEFib3J0KSwgX1NCKHNtLT5hdXRoRmFpbCksCi0JCXBvcnRfc3RhdGVfdHh0KHNtLT5hdXRoUG9ydFN0YXR1cyksIF9TQihzbS0+YXV0aFN0YXJ0KSwKLQkJcHJlZml4LCBfU0Ioc20tPmF1dGhUaW1lb3V0KSwgX1NCKHNtLT5hdXRoU3VjY2VzcyksCi0JCV9TQihzbS0+ZWFwX2lmLT5lYXBGYWlsKSwgX1NCKHNtLT5lYXBvbEVhcCksCi0JCXByZWZpeCwgX1NCKHNtLT5lYXBfaWYtPmVhcFN1Y2Nlc3MpLAotCQlfU0Ioc20tPmVhcF9pZi0+ZWFwVGltZW91dCksCi0JCV9TQihzbS0+aW5pdGlhbGl6ZSksIF9TQihzbS0+ZWFwX2lmLT5lYXBLZXlBdmFpbGFibGUpLAotCQlwcmVmaXgsIF9TQihzbS0+a2V5RG9uZSksIF9TQihzbS0+a2V5UnVuKSwKLQkJX1NCKHNtLT5rZXlUeEVuYWJsZWQpLCBwb3J0X3R5cGVfdHh0KHNtLT5wb3J0Q29udHJvbCksCi0JCXByZWZpeCwgX1NCKHNtLT5lYXBfaWYtPnBvcnRFbmFibGVkKSwgX1NCKHNtLT5wb3J0VmFsaWQpLAotCQlfU0Ioc20tPnJlQXV0aGVudGljYXRlKSk7CisJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsCisJCQkgICJhdXRoQWJvcnQ9JXNcbiIKKwkJCSAgImF1dGhGYWlsPSVzXG4iCisJCQkgICJhdXRoUG9ydFN0YXR1cz0lc1xuIgorCQkJICAiYXV0aFN0YXJ0PSVzXG4iCisJCQkgICJhdXRoVGltZW91dD0lc1xuIgorCQkJICAiYXV0aFN1Y2Nlc3M9JXNcbiIKKwkJCSAgImVhcEZhaWw9JXNcbiIKKwkJCSAgImVhcG9sRWFwPSVzXG4iCisJCQkgICJlYXBTdWNjZXNzPSVzXG4iCisJCQkgICJlYXBUaW1lb3V0PSVzXG4iCisJCQkgICJpbml0aWFsaXplPSVzXG4iCisJCQkgICJrZXlBdmFpbGFibGU9JXNcbiIKKwkJCSAgImtleURvbmU9JXNcbiIKKwkJCSAgImtleVJ1bj0lc1xuIgorCQkJICAia2V5VHhFbmFibGVkPSVzXG4iCisJCQkgICJwb3J0Q29udHJvbD0lc1xuIgorCQkJICAicG9ydEVuYWJsZWQ9JXNcbiIKKwkJCSAgInBvcnRWYWxpZD0lc1xuIgorCQkJICAicmVBdXRoZW50aWNhdGU9JXNcbiIsCisJCQkgIF9TQihzbS0+YXV0aEFib3J0KSwKKwkJCSAgX1NCKHNtLT5hdXRoRmFpbCksCisJCQkgIHBvcnRfc3RhdGVfdHh0KHNtLT5hdXRoUG9ydFN0YXR1cyksCisJCQkgIF9TQihzbS0+YXV0aFN0YXJ0KSwKKwkJCSAgX1NCKHNtLT5hdXRoVGltZW91dCksCisJCQkgIF9TQihzbS0+YXV0aFN1Y2Nlc3MpLAorCQkJICBfU0Ioc20tPmVhcF9pZi0+ZWFwRmFpbCksCisJCQkgIF9TQihzbS0+ZWFwb2xFYXApLAorCQkJICBfU0Ioc20tPmVhcF9pZi0+ZWFwU3VjY2VzcyksCisJCQkgIF9TQihzbS0+ZWFwX2lmLT5lYXBUaW1lb3V0KSwKKwkJCSAgX1NCKHNtLT5pbml0aWFsaXplKSwKKwkJCSAgX1NCKHNtLT5lYXBfaWYtPmVhcEtleUF2YWlsYWJsZSksCisJCQkgIF9TQihzbS0+a2V5RG9uZSksIF9TQihzbS0+a2V5UnVuKSwKKwkJCSAgX1NCKHNtLT5rZXlUeEVuYWJsZWQpLAorCQkJICBwb3J0X3R5cGVfdHh0KHNtLT5wb3J0Q29udHJvbCksCisJCQkgIF9TQihzbS0+ZWFwX2lmLT5wb3J0RW5hYmxlZCksCisJCQkgIF9TQihzbS0+cG9ydFZhbGlkKSwKKwkJCSAgX1NCKHNtLT5yZUF1dGhlbnRpY2F0ZSkpOworCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCisJCXJldHVybiBwb3MgLSBidWY7CisJcG9zICs9IHJldDsKIAotCWZwcmludGYoZiwgIiVzICBBdXRoZW50aWNhdG9yIFBBRTpcbiIKLQkJIiVzICAgIHN0YXRlPSVzXG4iCi0JCSIlcyAgICBlYXBvbExvZ29mZj0lcyBlYXBvbFN0YXJ0PSVzIGVhcFJlc3RhcnQ9JXNcbiIKLQkJIiVzICAgIHBvcnRNb2RlPSVzIHJlQXV0aENvdW50PSVkXG4iCi0JCSIlcyAgICBxdWlldFBlcmlvZD0lZCByZUF1dGhNYXg9JWRcbiIKLQkJIiVzICAgIGF1dGhFbnRlcnNDb25uZWN0aW5nPSVkXG4iCi0JCSIlcyAgICBhdXRoRWFwTG9nb2Zmc1doaWxlQ29ubmVjdGluZz0lZFxuIgotCQkiJXMgICAgYXV0aEVudGVyc0F1dGhlbnRpY2F0aW5nPSVkXG4iCi0JCSIlcyAgICBhdXRoQXV0aFN1Y2Nlc3Nlc1doaWxlQXV0aGVudGljYXRpbmc9JWRcbiIKLQkJIiVzICAgIGF1dGhBdXRoVGltZW91dHNXaGlsZUF1dGhlbnRpY2F0aW5nPSVkXG4iCi0JCSIlcyAgICBhdXRoQXV0aEZhaWxXaGlsZUF1dGhlbnRpY2F0aW5nPSVkXG4iCi0JCSIlcyAgICBhdXRoQXV0aEVhcFN0YXJ0c1doaWxlQXV0aGVudGljYXRpbmc9JWRcbiIKLQkJIiVzICAgIGF1dGhBdXRoRWFwTG9nb2ZmV2hpbGVBdXRoZW50aWNhdGluZz0lZFxuIgotCQkiJXMgICAgYXV0aEF1dGhSZWF1dGhzV2hpbGVBdXRoZW50aWNhdGVkPSVkXG4iCi0JCSIlcyAgICBhdXRoQXV0aEVhcFN0YXJ0c1doaWxlQXV0aGVudGljYXRlZD0lZFxuIgotCQkiJXMgICAgYXV0aEF1dGhFYXBMb2dvZmZXaGlsZUF1dGhlbnRpY2F0ZWQ9JWRcbiIsCi0JCXByZWZpeCwgcHJlZml4LCBhdXRoX3BhZV9zdGF0ZV90eHQoc20tPmF1dGhfcGFlX3N0YXRlKSwgcHJlZml4LAotCQlfU0Ioc20tPmVhcG9sTG9nb2ZmKSwgX1NCKHNtLT5lYXBvbFN0YXJ0KSwKLQkJX1NCKHNtLT5lYXBfaWYtPmVhcFJlc3RhcnQpLAotCQlwcmVmaXgsIHBvcnRfdHlwZV90eHQoc20tPnBvcnRNb2RlKSwgc20tPnJlQXV0aENvdW50LAotCQlwcmVmaXgsIHNtLT5xdWlldFBlcmlvZCwgc20tPnJlQXV0aE1heCwKLQkJcHJlZml4LCBzbS0+YXV0aEVudGVyc0Nvbm5lY3RpbmcsCi0JCXByZWZpeCwgc20tPmF1dGhFYXBMb2dvZmZzV2hpbGVDb25uZWN0aW5nLAotCQlwcmVmaXgsIHNtLT5hdXRoRW50ZXJzQXV0aGVudGljYXRpbmcsCi0JCXByZWZpeCwgc20tPmF1dGhBdXRoU3VjY2Vzc2VzV2hpbGVBdXRoZW50aWNhdGluZywKLQkJcHJlZml4LCBzbS0+YXV0aEF1dGhUaW1lb3V0c1doaWxlQXV0aGVudGljYXRpbmcsCi0JCXByZWZpeCwgc20tPmF1dGhBdXRoRmFpbFdoaWxlQXV0aGVudGljYXRpbmcsCi0JCXByZWZpeCwgc20tPmF1dGhBdXRoRWFwU3RhcnRzV2hpbGVBdXRoZW50aWNhdGluZywKLQkJcHJlZml4LCBzbS0+YXV0aEF1dGhFYXBMb2dvZmZXaGlsZUF1dGhlbnRpY2F0aW5nLAotCQlwcmVmaXgsIHNtLT5hdXRoQXV0aFJlYXV0aHNXaGlsZUF1dGhlbnRpY2F0ZWQsCi0JCXByZWZpeCwgc20tPmF1dGhBdXRoRWFwU3RhcnRzV2hpbGVBdXRoZW50aWNhdGVkLAotCQlwcmVmaXgsIHNtLT5hdXRoQXV0aEVhcExvZ29mZldoaWxlQXV0aGVudGljYXRlZCk7CisJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsCisJCQkgICJhdXRoX3BhZV9zdGF0ZT0lc1xuIgorCQkJICAiZWFwb2xMb2dvZmY9JXNcbiIKKwkJCSAgImVhcG9sU3RhcnQ9JXNcbiIKKwkJCSAgImVhcFJlc3RhcnQ9JXNcbiIKKwkJCSAgInBvcnRNb2RlPSVzXG4iCisJCQkgICJyZUF1dGhDb3VudD0lZFxuIgorCQkJICAicXVpZXRQZXJpb2Q9JWRcbiIKKwkJCSAgInJlQXV0aE1heD0lZFxuIgorCQkJICAiYXV0aEVudGVyc0Nvbm5lY3Rpbmc9JWRcbiIKKwkJCSAgImF1dGhFYXBMb2dvZmZzV2hpbGVDb25uZWN0aW5nPSVkXG4iCisJCQkgICJhdXRoRW50ZXJzQXV0aGVudGljYXRpbmc9JWRcbiIKKwkJCSAgImF1dGhBdXRoU3VjY2Vzc2VzV2hpbGVBdXRoZW50aWNhdGluZz0lZFxuIgorCQkJICAiYXV0aEF1dGhUaW1lb3V0c1doaWxlQXV0aGVudGljYXRpbmc9JWRcbiIKKwkJCSAgImF1dGhBdXRoRmFpbFdoaWxlQXV0aGVudGljYXRpbmc9JWRcbiIKKwkJCSAgImF1dGhBdXRoRWFwU3RhcnRzV2hpbGVBdXRoZW50aWNhdGluZz0lZFxuIgorCQkJICAiYXV0aEF1dGhFYXBMb2dvZmZXaGlsZUF1dGhlbnRpY2F0aW5nPSVkXG4iCisJCQkgICJhdXRoQXV0aFJlYXV0aHNXaGlsZUF1dGhlbnRpY2F0ZWQ9JWRcbiIKKwkJCSAgImF1dGhBdXRoRWFwU3RhcnRzV2hpbGVBdXRoZW50aWNhdGVkPSVkXG4iCisJCQkgICJhdXRoQXV0aEVhcExvZ29mZldoaWxlQXV0aGVudGljYXRlZD0lZFxuIiwKKwkJCSAgYXV0aF9wYWVfc3RhdGVfdHh0KHNtLT5hdXRoX3BhZV9zdGF0ZSksCisJCQkgIF9TQihzbS0+ZWFwb2xMb2dvZmYpLAorCQkJICBfU0Ioc20tPmVhcG9sU3RhcnQpLAorCQkJICBfU0Ioc20tPmVhcF9pZi0+ZWFwUmVzdGFydCksCisJCQkgIHBvcnRfdHlwZV90eHQoc20tPnBvcnRNb2RlKSwKKwkJCSAgc20tPnJlQXV0aENvdW50LAorCQkJICBzbS0+cXVpZXRQZXJpb2QsIHNtLT5yZUF1dGhNYXgsCisJCQkgIHNtLT5hdXRoRW50ZXJzQ29ubmVjdGluZywKKwkJCSAgc20tPmF1dGhFYXBMb2dvZmZzV2hpbGVDb25uZWN0aW5nLAorCQkJICBzbS0+YXV0aEVudGVyc0F1dGhlbnRpY2F0aW5nLAorCQkJICBzbS0+YXV0aEF1dGhTdWNjZXNzZXNXaGlsZUF1dGhlbnRpY2F0aW5nLAorCQkJICBzbS0+YXV0aEF1dGhUaW1lb3V0c1doaWxlQXV0aGVudGljYXRpbmcsCisJCQkgIHNtLT5hdXRoQXV0aEZhaWxXaGlsZUF1dGhlbnRpY2F0aW5nLAorCQkJICBzbS0+YXV0aEF1dGhFYXBTdGFydHNXaGlsZUF1dGhlbnRpY2F0aW5nLAorCQkJICBzbS0+YXV0aEF1dGhFYXBMb2dvZmZXaGlsZUF1dGhlbnRpY2F0aW5nLAorCQkJICBzbS0+YXV0aEF1dGhSZWF1dGhzV2hpbGVBdXRoZW50aWNhdGVkLAorCQkJICBzbS0+YXV0aEF1dGhFYXBTdGFydHNXaGlsZUF1dGhlbnRpY2F0ZWQsCisJCQkgIHNtLT5hdXRoQXV0aEVhcExvZ29mZldoaWxlQXV0aGVudGljYXRlZCk7CisJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwlwb3MgKz0gcmV0OwogCi0JZnByaW50ZihmLCAiJXMgIEJhY2tlbmQgQXV0aGVudGljYXRpb246XG4iCi0JCSIlcyAgICBzdGF0ZT0lc1xuIgotCQkiJXMgICAgZWFwTm9SZXE9JXMgZWFwUmVxPSVzIGVhcFJlc3A9JXNcbiIKLQkJIiVzICAgIHNlcnZlclRpbWVvdXQ9JWRcbiIKLQkJIiVzICAgIGJhY2tlbmRSZXNwb25zZXM9JWRcbiIKLQkJIiVzICAgIGJhY2tlbmRBY2Nlc3NDaGFsbGVuZ2VzPSVkXG4iCi0JCSIlcyAgICBiYWNrZW5kT3RoZXJSZXF1ZXN0c1RvU3VwcGxpY2FudD0lZFxuIgotCQkiJXMgICAgYmFja2VuZEF1dGhTdWNjZXNzZXM9JWRcbiIKLQkJIiVzICAgIGJhY2tlbmRBdXRoRmFpbHM9JWRcbiIsCi0JCXByZWZpeCwgcHJlZml4LAotCQliZV9hdXRoX3N0YXRlX3R4dChzbS0+YmVfYXV0aF9zdGF0ZSksCi0JCXByZWZpeCwgX1NCKHNtLT5lYXBfaWYtPmVhcE5vUmVxKSwgX1NCKHNtLT5lYXBfaWYtPmVhcFJlcSksCi0JCV9TQihzbS0+ZWFwX2lmLT5lYXBSZXNwKSwKLQkJcHJlZml4LCBzbS0+c2VydmVyVGltZW91dCwKLQkJcHJlZml4LCBzbS0+YmFja2VuZFJlc3BvbnNlcywKLQkJcHJlZml4LCBzbS0+YmFja2VuZEFjY2Vzc0NoYWxsZW5nZXMsCi0JCXByZWZpeCwgc20tPmJhY2tlbmRPdGhlclJlcXVlc3RzVG9TdXBwbGljYW50LAotCQlwcmVmaXgsIHNtLT5iYWNrZW5kQXV0aFN1Y2Nlc3NlcywKLQkJcHJlZml4LCBzbS0+YmFja2VuZEF1dGhGYWlscyk7CisJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsCisJCQkgICJiZV9hdXRoX3N0YXRlPSVzXG4iCisJCQkgICJlYXBOb1JlcT0lc1xuIgorCQkJICAiZWFwUmVxPSVzXG4iCisJCQkgICJlYXBSZXNwPSVzXG4iCisJCQkgICJzZXJ2ZXJUaW1lb3V0PSVkXG4iCisJCQkgICJiYWNrZW5kUmVzcG9uc2VzPSVkXG4iCisJCQkgICJiYWNrZW5kQWNjZXNzQ2hhbGxlbmdlcz0lZFxuIgorCQkJICAiYmFja2VuZE90aGVyUmVxdWVzdHNUb1N1cHBsaWNhbnQ9JWRcbiIKKwkJCSAgImJhY2tlbmRBdXRoU3VjY2Vzc2VzPSVkXG4iCisJCQkgICJiYWNrZW5kQXV0aEZhaWxzPSVkXG4iLAorCQkJICBiZV9hdXRoX3N0YXRlX3R4dChzbS0+YmVfYXV0aF9zdGF0ZSksCisJCQkgIF9TQihzbS0+ZWFwX2lmLT5lYXBOb1JlcSksCisJCQkgIF9TQihzbS0+ZWFwX2lmLT5lYXBSZXEpLAorCQkJICBfU0Ioc20tPmVhcF9pZi0+ZWFwUmVzcCksCisJCQkgIHNtLT5zZXJ2ZXJUaW1lb3V0LAorCQkJICBzbS0+YmFja2VuZFJlc3BvbnNlcywKKwkJCSAgc20tPmJhY2tlbmRBY2Nlc3NDaGFsbGVuZ2VzLAorCQkJICBzbS0+YmFja2VuZE90aGVyUmVxdWVzdHNUb1N1cHBsaWNhbnQsCisJCQkgIHNtLT5iYWNrZW5kQXV0aFN1Y2Nlc3NlcywKKwkJCSAgc20tPmJhY2tlbmRBdXRoRmFpbHMpOworCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCisJCXJldHVybiBwb3MgLSBidWY7CisJcG9zICs9IHJldDsKIAotCWZwcmludGYoZiwgIiVzICBSZWF1dGhlbnRpY2F0aW9uIFRpbWVyOlxuIgotCQkiJXMgICAgc3RhdGU9JXNcbiIKLQkJIiVzICAgIHJlQXV0aFBlcmlvZD0lZCByZUF1dGhFbmFibGVkPSVzXG4iLCBwcmVmaXgsIHByZWZpeCwKLQkJcmVhdXRoX3RpbWVyX3N0YXRlX3R4dChzbS0+cmVhdXRoX3RpbWVyX3N0YXRlKSwgcHJlZml4LAotCQlzbS0+cmVBdXRoUGVyaW9kLCBfU0Ioc20tPnJlQXV0aEVuYWJsZWQpKTsKKwlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKKwkJCSAgInJlYXV0aF90aW1lcl9zdGF0ZT0lc1xuIgorCQkJICAicmVBdXRoUGVyaW9kPSVkXG4iCisJCQkgICJyZUF1dGhFbmFibGVkPSVzXG4iLAorCQkJICByZWF1dGhfdGltZXJfc3RhdGVfdHh0KHNtLT5yZWF1dGhfdGltZXJfc3RhdGUpLAorCQkJICBzbS0+cmVBdXRoUGVyaW9kLAorCQkJICBfU0Ioc20tPnJlQXV0aEVuYWJsZWQpKTsKKwlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQlyZXR1cm4gcG9zIC0gYnVmOworCXBvcyArPSByZXQ7CiAKLQlmcHJpbnRmKGYsICIlcyAgQXV0aGVudGljYXRvciBLZXkgVHJhbnNtaXQ6XG4iCi0JCSIlcyAgICBzdGF0ZT0lc1xuIiwgcHJlZml4LCBwcmVmaXgsCi0JCWF1dGhfa2V5X3R4X3N0YXRlX3R4dChzbS0+YXV0aF9rZXlfdHhfc3RhdGUpKTsKKwlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKKwkJCSAgImF1dGhfa2V5X3R4X3N0YXRlPSVzXG4iLAorCQkJICBhdXRoX2tleV90eF9zdGF0ZV90eHQoc20tPmF1dGhfa2V5X3R4X3N0YXRlKSk7CisJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwlwb3MgKz0gcmV0OwogCi0JZnByaW50ZihmLCAiJXMgIEtleSBSZWNlaXZlOlxuIgotCQkiJXMgICAgc3RhdGU9JXNcbiIKLQkJIiVzICAgIHJ4S2V5PSVzXG4iLCBwcmVmaXgsIHByZWZpeCwKLQkJa2V5X3J4X3N0YXRlX3R4dChzbS0+a2V5X3J4X3N0YXRlKSwgcHJlZml4LCBfU0Ioc20tPnJ4S2V5KSk7CisJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsCisJCQkgICJrZXlfcnhfc3RhdGU9JXNcbiIKKwkJCSAgInJ4S2V5PSVzXG4iLAorCQkJICBrZXlfcnhfc3RhdGVfdHh0KHNtLT5rZXlfcnhfc3RhdGUpLAorCQkJICBfU0Ioc20tPnJ4S2V5KSk7CisJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwlwb3MgKz0gcmV0OwogCi0JZnByaW50ZihmLCAiJXMgIENvbnRyb2xsZWQgRGlyZWN0aW9uczpcbiIKLQkJIiVzICAgIHN0YXRlPSVzXG4iCi0JCSIlcyAgICBhZG1pbkNvbnRyb2xsZWREaXJlY3Rpb25zPSVzICIKLQkJIm9wZXJDb250cm9sbGVkRGlyZWN0aW9ucz0lc1xuIgotCQkiJXMgICAgb3BlckVkZ2U9JXNcbiIsIHByZWZpeCwgcHJlZml4LAotCQljdHJsX2Rpcl9zdGF0ZV90eHQoc20tPmN0cmxfZGlyX3N0YXRlKSwKLQkJcHJlZml4LCBjdHJsX2Rpcl90eHQoc20tPmFkbWluQ29udHJvbGxlZERpcmVjdGlvbnMpLAotCQljdHJsX2Rpcl90eHQoc20tPm9wZXJDb250cm9sbGVkRGlyZWN0aW9ucyksCi0JCXByZWZpeCwgX1NCKHNtLT5vcGVyRWRnZSkpOworCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAorCQkJICAiY3RybF9kaXJfc3RhdGU9JXNcbiIKKwkJCSAgImFkbWluQ29udHJvbGxlZERpcmVjdGlvbnM9JXNcbiIKKwkJCSAgIm9wZXJDb250cm9sbGVkRGlyZWN0aW9ucz0lc1xuIgorCQkJICAib3BlckVkZ2U9JXNcbiIsCisJCQkgIGN0cmxfZGlyX3N0YXRlX3R4dChzbS0+Y3RybF9kaXJfc3RhdGUpLAorCQkJICBjdHJsX2Rpcl90eHQoc20tPmFkbWluQ29udHJvbGxlZERpcmVjdGlvbnMpLAorCQkJICBjdHJsX2Rpcl90eHQoc20tPm9wZXJDb250cm9sbGVkRGlyZWN0aW9ucyksCisJCQkgIF9TQihzbS0+b3BlckVkZ2UpKTsKKwlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQlyZXR1cm4gcG9zIC0gYnVmOworCXBvcyArPSByZXQ7CiAjdW5kZWYgX1NCCisKKwlyZXR1cm4gcG9zIC0gYnVmOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbS5jIGIvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbS5jCmluZGV4IDAxM2Q3ODEuLmE3NmZhMTMgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBvbF9hdXRoL2VhcG9sX2F1dGhfc20uYworKysgYi9zcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtLmMKQEAgLTIxOSw3ICsyMTksOCBAQAogCXNtLT5lYXBvbExvZ29mZiA9IEZBTFNFOwogCWlmICghZnJvbV9pbml0aWFsaXplKSB7CiAJCXNtLT5lYXBvbC0+Y2IuZmluaXNoZWQoc20tPmVhcG9sLT5jb25mLmN0eCwgc20tPnN0YSwgMCwKLQkJCQkgICAgICAgc20tPmZsYWdzICYgRUFQT0xfU01fUFJFQVVUSCk7CisJCQkJICAgICAgIHNtLT5mbGFncyAmIEVBUE9MX1NNX1BSRUFVVEgsCisJCQkJICAgICAgIHNtLT5yZW1lZGlhdGlvbik7CiAJfQogfQogCkBAIC0yNzYsNyArMjc3LDcgQEAKIAkJCQkgICBlYXBfc2VydmVyX2dldF9uYW1lKDAsIHNtLT5lYXBfdHlwZV9zdXBwKSk7CiAJfQogCXNtLT5lYXBvbC0+Y2IuZmluaXNoZWQoc20tPmVhcG9sLT5jb25mLmN0eCwgc20tPnN0YSwgMCwKLQkJCSAgICAgICBzbS0+ZmxhZ3MgJiBFQVBPTF9TTV9QUkVBVVRIKTsKKwkJCSAgICAgICBzbS0+ZmxhZ3MgJiBFQVBPTF9TTV9QUkVBVVRILCBzbS0+cmVtZWRpYXRpb24pOwogfQogCiAKQEAgLTMwMiw3ICszMDMsNyBAQAogCQkJICAgZWFwX3NlcnZlcl9nZXRfbmFtZSgwLCBzbS0+ZWFwX3R5cGVfYXV0aHNydiksCiAJCQkgICBleHRyYSk7CiAJc20tPmVhcG9sLT5jYi5maW5pc2hlZChzbS0+ZWFwb2wtPmNvbmYuY3R4LCBzbS0+c3RhLCAxLAotCQkJICAgICAgIHNtLT5mbGFncyAmIEVBUE9MX1NNX1BSRUFVVEgpOworCQkJICAgICAgIHNtLT5mbGFncyAmIEVBUE9MX1NNX1BSRUFVVEgsIHNtLT5yZW1lZGlhdGlvbik7CiB9CiAKIApAQCAtMTAwMSw4ICsxMDAyLDEzIEBACiAJCQkJIHN0cnVjdCBlYXBfdXNlciAqdXNlcikKIHsKIAlzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqc20gPSBjdHg7Ci0JcmV0dXJuIHNtLT5lYXBvbC0+Y2IuZ2V0X2VhcF91c2VyKHNtLT5lYXBvbC0+Y29uZi5jdHgsIGlkZW50aXR5LAotCQkJCQkgIGlkZW50aXR5X2xlbiwgcGhhc2UyLCB1c2VyKTsKKwlpbnQgcmV0OworCisJcmV0ID0gc20tPmVhcG9sLT5jYi5nZXRfZWFwX3VzZXIoc20tPmVhcG9sLT5jb25mLmN0eCwgaWRlbnRpdHksCisJCQkJCSBpZGVudGl0eV9sZW4sIHBoYXNlMiwgdXNlcik7CisJaWYgKHVzZXItPnJlbWVkaWF0aW9uKQorCQlzbS0+cmVtZWRpYXRpb24gPSAxOworCXJldHVybiByZXQ7CiB9CiAKIApAQCAtMTAxNyw3ICsxMDIzLDggQEAKIHN0YXRpYyBzdHJ1Y3QgZWFwb2xfY2FsbGJhY2tzIGVhcG9sX2NiID0KIHsKIAllYXBvbF9zbV9nZXRfZWFwX3VzZXIsCi0JZWFwb2xfc21fZ2V0X2VhcF9yZXFfaWRfdGV4dAorCWVhcG9sX3NtX2dldF9lYXBfcmVxX2lkX3RleHQsCisJTlVMTAogfTsKIAogCkBAIC0xMDYyLDYgKzEwNjksMTAgQEAKIAl9CiAJaWYgKHNyYy0+cGFjX29wYXF1ZV9lbmNyX2tleSkgewogCQlkc3QtPnBhY19vcGFxdWVfZW5jcl9rZXkgPSBvc19tYWxsb2MoMTYpOworCQlpZiAoZHN0LT5wYWNfb3BhcXVlX2VuY3Jfa2V5ID09IE5VTEwpIHsKKwkJCW9zX2ZyZWUoZHN0LT5lYXBfcmVxX2lkX3RleHQpOworCQkJcmV0dXJuIC0xOworCQl9CiAJCW9zX21lbWNweShkc3QtPnBhY19vcGFxdWVfZW5jcl9rZXksIHNyYy0+cGFjX29wYXF1ZV9lbmNyX2tleSwKIAkJCSAgMTYpOwogCX0gZWxzZQpAQCAtMTA3MCw2ICsxMDgxLDcgQEAKIAkJZHN0LT5lYXBfZmFzdF9hX2lkID0gb3NfbWFsbG9jKHNyYy0+ZWFwX2Zhc3RfYV9pZF9sZW4pOwogCQlpZiAoZHN0LT5lYXBfZmFzdF9hX2lkID09IE5VTEwpIHsKIAkJCW9zX2ZyZWUoZHN0LT5lYXBfcmVxX2lkX3RleHQpOworCQkJb3NfZnJlZShkc3QtPnBhY19vcGFxdWVfZW5jcl9rZXkpOwogCQkJcmV0dXJuIC0xOwogCQl9CiAJCW9zX21lbWNweShkc3QtPmVhcF9mYXN0X2FfaWQsIHNyYy0+ZWFwX2Zhc3RfYV9pZCwKQEAgLTEwODEsNiArMTA5Myw3IEBACiAJCWRzdC0+ZWFwX2Zhc3RfYV9pZF9pbmZvID0gb3Nfc3RyZHVwKHNyYy0+ZWFwX2Zhc3RfYV9pZF9pbmZvKTsKIAkJaWYgKGRzdC0+ZWFwX2Zhc3RfYV9pZF9pbmZvID09IE5VTEwpIHsKIAkJCW9zX2ZyZWUoZHN0LT5lYXBfcmVxX2lkX3RleHQpOworCQkJb3NfZnJlZShkc3QtPnBhY19vcGFxdWVfZW5jcl9rZXkpOwogCQkJb3NfZnJlZShkc3QtPmVhcF9mYXN0X2FfaWQpOwogCQkJcmV0dXJuIC0xOwogCQl9CmRpZmYgLS1naXQgYS9zcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtLmggYi9zcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtLmgKaW5kZXggM2EwZjQ1MC4uMzIwYTBhZCAxMDA2NDQKLS0tIGEvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbS5oCisrKyBiL3NyYy9lYXBvbF9hdXRoL2VhcG9sX2F1dGhfc20uaApAQCAtNjAsNyArNjAsOCBAQAogCQkJICAgc2l6ZV90IGRhdGFsZW4pOwogCXZvaWQgKCphYWFfc2VuZCkodm9pZCAqY3R4LCB2b2lkICpzdGFfY3R4LCBjb25zdCB1OCAqZGF0YSwKIAkJCSBzaXplX3QgZGF0YWxlbik7Ci0Jdm9pZCAoKmZpbmlzaGVkKSh2b2lkICpjdHgsIHZvaWQgKnN0YV9jdHgsIGludCBzdWNjZXNzLCBpbnQgcHJlYXV0aCk7CisJdm9pZCAoKmZpbmlzaGVkKSh2b2lkICpjdHgsIHZvaWQgKnN0YV9jdHgsIGludCBzdWNjZXNzLCBpbnQgcHJlYXV0aCwKKwkJCSBpbnQgcmVtZWRpYXRpb24pOwogCWludCAoKmdldF9lYXBfdXNlcikodm9pZCAqY3R4LCBjb25zdCB1OCAqaWRlbnRpdHksIHNpemVfdCBpZGVudGl0eV9sZW4sCiAJCQkgICAgaW50IHBoYXNlMiwgc3RydWN0IGVhcF91c2VyICp1c2VyKTsKIAlpbnQgKCpzdGFfZW50cnlfYWxpdmUpKHZvaWQgKmN0eCwgY29uc3QgdTggKmFkZHIpOwpAQCAtODMsOCArODQsOCBAQAogCQkgY29uc3QgY2hhciAqaWRlbnRpdHksIGNvbnN0IGNoYXIgKnJhZGl1c19jdWkpOwogdm9pZCBlYXBvbF9hdXRoX2ZyZWUoc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtKTsKIHZvaWQgZWFwb2xfYXV0aF9zdGVwKHN0cnVjdCBlYXBvbF9zdGF0ZV9tYWNoaW5lICpzbSk7Ci12b2lkIGVhcG9sX2F1dGhfZHVtcF9zdGF0ZShGSUxFICpmLCBjb25zdCBjaGFyICpwcmVmaXgsCi0JCQkgICBzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqc20pOworaW50IGVhcG9sX2F1dGhfZHVtcF9zdGF0ZShzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqc20sIGNoYXIgKmJ1ZiwKKwkJCSAgc2l6ZV90IGJ1Zmxlbik7CiBpbnQgZWFwb2xfYXV0aF9lYXBfcGVuZGluZ19jYihzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqc20sIHZvaWQgKmN0eCk7CiAKICNlbmRpZiAvKiBFQVBPTF9BVVRIX1NNX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9lYXBvbF9hdXRoL2VhcG9sX2F1dGhfc21faS5oIGIvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbV9pLmgKaW5kZXggZDdmODkzYS4uMjViYWRkYiAxMDA2NDQKLS0tIGEvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbV9pLmgKKysrIGIvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbV9pLmgKQEAgLTE3Myw2ICsxNzMsOCBAQAogCXN0cnVjdCBlYXBvbF9hdXRoZW50aWNhdG9yICplYXBvbDsKIAogCXZvaWQgKnN0YTsgLyogc3RhdGlvbiBjb250ZXh0IHBvaW50ZXIgdG8gdXNlIGluIGNhbGxiYWNrcyAqLworCisJaW50IHJlbWVkaWF0aW9uOwogfTsKIAogI2VuZGlmIC8qIEVBUE9MX0FVVEhfU01fSV9IICovCmRpZmYgLS1naXQgYS9zcmMvZWFwb2xfc3VwcC9NYWtlZmlsZSBiL3NyYy9lYXBvbF9zdXBwL01ha2VmaWxlCmluZGV4IDljNDE5NjIuLmFkZmQzZGYgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBvbF9zdXBwL01ha2VmaWxlCisrKyBiL3NyYy9lYXBvbF9zdXBwL01ha2VmaWxlCkBAIC0yLDcgKzIsNyBAQAogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KIAogY2xlYW46Ci0Jcm0gLWYgKn4gKi5vICouZAorCXJtIC1mICp+ICoubyAqLmQgKi5nY25vICouZ2NkYSAqLmdjb3YKIAogaW5zdGFsbDoKIAlAZWNobyBOb3RoaW5nIHRvIGJlIG1hZGUuCmRpZmYgLS1naXQgYS9zcmMvZWFwb2xfc3VwcC9lYXBvbF9zdXBwX3NtLmMgYi9zcmMvZWFwb2xfc3VwcC9lYXBvbF9zdXBwX3NtLmMKaW5kZXggOWIwNTRmYy4uY2YzNTA2ZCAxMDA2NDQKLS0tIGEvc3JjL2VhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5jCisrKyBiL3NyYy9lYXBvbF9zdXBwL2VhcG9sX3N1cHBfc20uYwpAQCAtMTM3LDYgKzEzNyw5IEBACiAJQm9vbGVhbiBjYWNoZWRfcG1rOwogCiAJQm9vbGVhbiB1bmljYXN0X2tleV9yZWNlaXZlZCwgYnJvYWRjYXN0X2tleV9yZWNlaXZlZDsKKworCUJvb2xlYW4gZm9yY2VfYXV0aG9yaXplZF91cGRhdGU7CisKICNpZmRlZiBDT05GSUdfRUFQX1BST1hZCiAJQm9vbGVhbiB1c2VfZWFwX3Byb3h5OwogCXN0cnVjdCBlYXBfcHJveHlfc20gKmVhcF9wcm94eTsKQEAgLTIxMCw3ICsyMTMsNiBAQAogCVNNX0VOVFJZKFNVUFBfUEFFLCBMT0dPRkYpOwogCWVhcG9sX3NtX3R4TG9nb2ZmKHNtKTsKIAlzbS0+bG9nb2ZmU2VudCA9IFRSVUU7Ci0Jc20tPnN1cHBQb3J0U3RhdHVzID0gVW5hdXRob3JpemVkOwogCWVhcG9sX3NtX3NldF9wb3J0X3VuYXV0aG9yaXplZChzbSk7CiB9CiAKQEAgLTIyMSw3ICsyMjMsNiBAQAogCXNtLT5zUG9ydE1vZGUgPSBBdXRvOwogCXNtLT5zdGFydENvdW50ID0gMDsKIAlzbS0+bG9nb2ZmU2VudCA9IEZBTFNFOwotCXNtLT5zdXBwUG9ydFN0YXR1cyA9IFVuYXV0aG9yaXplZDsKIAllYXBvbF9zbV9zZXRfcG9ydF91bmF1dGhvcml6ZWQoc20pOwogCXNtLT5zdXBwQWJvcnQgPSBUUlVFOwogCkBAIC0yODYsNyArMjg3LDYgQEAKIAlTTV9FTlRSWShTVVBQX1BBRSwgSEVMRCk7CiAJc20tPmhlbGRXaGlsZSA9IHNtLT5oZWxkUGVyaW9kOwogCWVhcG9sX2VuYWJsZV90aW1lcl90aWNrKHNtKTsKLQlzbS0+c3VwcFBvcnRTdGF0dXMgPSBVbmF1dGhvcml6ZWQ7CiAJZWFwb2xfc21fc2V0X3BvcnRfdW5hdXRob3JpemVkKHNtKTsKIAlzbS0+Y2Jfc3RhdHVzID0gRUFQT0xfQ0JfRkFJTFVSRTsKIH0KQEAgLTI5NSw3ICsyOTUsNiBAQAogU01fU1RBVEUoU1VQUF9QQUUsIEFVVEhFTlRJQ0FURUQpCiB7CiAJU01fRU5UUlkoU1VQUF9QQUUsIEFVVEhFTlRJQ0FURUQpOwotCXNtLT5zdXBwUG9ydFN0YXR1cyA9IEF1dGhvcml6ZWQ7CiAJZWFwb2xfc21fc2V0X3BvcnRfYXV0aG9yaXplZChzbSk7CiAJc20tPmNiX3N0YXR1cyA9IEVBUE9MX0NCX1NVQ0NFU1M7CiB9CkBAIC0zMTEsNyArMzEwLDYgQEAKIFNNX1NUQVRFKFNVUFBfUEFFLCBTX0ZPUkNFX0FVVEgpCiB7CiAJU01fRU5UUlkoU1VQUF9QQUUsIFNfRk9SQ0VfQVVUSCk7Ci0Jc20tPnN1cHBQb3J0U3RhdHVzID0gQXV0aG9yaXplZDsKIAllYXBvbF9zbV9zZXRfcG9ydF9hdXRob3JpemVkKHNtKTsKIAlzbS0+c1BvcnRNb2RlID0gRm9yY2VBdXRob3JpemVkOwogfQpAQCAtMzIwLDcgKzMxOCw2IEBACiBTTV9TVEFURShTVVBQX1BBRSwgU19GT1JDRV9VTkFVVEgpCiB7CiAJU01fRU5UUlkoU1VQUF9QQUUsIFNfRk9SQ0VfVU5BVVRIKTsKLQlzbS0+c3VwcFBvcnRTdGF0dXMgPSBVbmF1dGhvcml6ZWQ7CiAJZWFwb2xfc21fc2V0X3BvcnRfdW5hdXRob3JpemVkKHNtKTsKIAlzbS0+c1BvcnRNb2RlID0gRm9yY2VVbmF1dGhvcml6ZWQ7CiAJZWFwb2xfc21fdHhMb2dvZmYoc20pOwpAQCAtNzIyLDggKzcxOSw4IEBACiAJaG1hY19tZDUoa2V5ZGF0YS5zaWduX2tleSwgc2lnbl9rZXlfbGVuLAogCQkgc20tPmxhc3Rfcnhfa2V5LCBzaXplb2YoKmhkcikgKyBiZV90b19ob3N0MTYoaGRyLT5sZW5ndGgpLAogCQkga2V5LT5rZXlfc2lnbmF0dXJlKTsKLQlpZiAob3NfbWVtY21wKG9yaWdfa2V5X3NpZ24sIGtleS0+a2V5X3NpZ25hdHVyZSwKLQkJICAgICAgSUVFRTgwMjFYX0tFWV9TSUdOX0xFTikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3Qob3JpZ19rZXlfc2lnbiwga2V5LT5rZXlfc2lnbmF0dXJlLAorCQkJICAgIElFRUU4MDIxWF9LRVlfU0lHTl9MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVBPTDogSW52YWxpZCBrZXkgc2lnbmF0dXJlIGluICIKIAkJCSAgICJFQVBPTC1LZXkgcGFja2V0Iik7CiAJCW9zX21lbWNweShrZXktPmtleV9zaWduYXR1cmUsIG9yaWdfa2V5X3NpZ24sCkBAIC04NzksMTQgKzg3NiwyNCBAQAogCiBzdGF0aWMgdm9pZCBlYXBvbF9zbV9zZXRfcG9ydF9hdXRob3JpemVkKHN0cnVjdCBlYXBvbF9zbSAqc20pCiB7Ci0JaWYgKHNtLT5jdHgtPnBvcnRfY2IpCisJaW50IGNiOworCisJY2IgPSBzbS0+c3VwcFBvcnRTdGF0dXMgIT0gQXV0aG9yaXplZCB8fCBzbS0+Zm9yY2VfYXV0aG9yaXplZF91cGRhdGU7CisJc20tPmZvcmNlX2F1dGhvcml6ZWRfdXBkYXRlID0gRkFMU0U7CisJc20tPnN1cHBQb3J0U3RhdHVzID0gQXV0aG9yaXplZDsKKwlpZiAoY2IgJiYgc20tPmN0eC0+cG9ydF9jYikKIAkJc20tPmN0eC0+cG9ydF9jYihzbS0+Y3R4LT5jdHgsIDEpOwogfQogCiAKIHN0YXRpYyB2b2lkIGVhcG9sX3NtX3NldF9wb3J0X3VuYXV0aG9yaXplZChzdHJ1Y3QgZWFwb2xfc20gKnNtKQogewotCWlmIChzbS0+Y3R4LT5wb3J0X2NiKQorCWludCBjYjsKKworCWNiID0gc20tPnN1cHBQb3J0U3RhdHVzICE9IFVuYXV0aG9yaXplZCB8fCBzbS0+Zm9yY2VfYXV0aG9yaXplZF91cGRhdGU7CisJc20tPmZvcmNlX2F1dGhvcml6ZWRfdXBkYXRlID0gRkFMU0U7CisJc20tPnN1cHBQb3J0U3RhdHVzID0gVW5hdXRob3JpemVkOworCWlmIChjYiAmJiBzbS0+Y3R4LT5wb3J0X2NiKQogCQlzbS0+Y3R4LT5wb3J0X2NiKHNtLT5jdHgtPmN0eCwgMCk7CiB9CiAKQEAgLTkzMyw5ICs5NDAsMTUgQEAKIAl9CiAKIAlpZiAoc20tPmN0eC0+Y2IgJiYgc20tPmNiX3N0YXR1cyAhPSBFQVBPTF9DQl9JTl9QUk9HUkVTUykgewotCQlpbnQgc3VjY2VzcyA9IHNtLT5jYl9zdGF0dXMgPT0gRUFQT0xfQ0JfU1VDQ0VTUyA/IDEgOiAwOworCQllbnVtIGVhcG9sX3N1cHBfcmVzdWx0IHJlc3VsdDsKKwkJaWYgKHNtLT5jYl9zdGF0dXMgPT0gRUFQT0xfQ0JfU1VDQ0VTUykKKwkJCXJlc3VsdCA9IEVBUE9MX1NVUFBfUkVTVUxUX1NVQ0NFU1M7CisJCWVsc2UgaWYgKGVhcF9wZWVyX3dhc19mYWlsdXJlX2V4cGVjdGVkKHNtLT5lYXApKQorCQkJcmVzdWx0ID0gRUFQT0xfU1VQUF9SRVNVTFRfRVhQRUNURURfRkFJTFVSRTsKKwkJZWxzZQorCQkJcmVzdWx0ID0gRUFQT0xfU1VQUF9SRVNVTFRfRkFJTFVSRTsKIAkJc20tPmNiX3N0YXR1cyA9IEVBUE9MX0NCX0lOX1BST0dSRVNTOwotCQlzbS0+Y3R4LT5jYihzbSwgc3VjY2Vzcywgc20tPmN0eC0+Y2JfY3R4KTsKKwkJc20tPmN0eC0+Y2Ioc20sIHJlc3VsdCwgc20tPmN0eC0+Y2JfY3R4KTsKIAl9CiB9CiAKQEAgLTEyNTcsNiArMTI3MCwyNCBAQAogCiAJc3dpdGNoIChoZHItPnR5cGUpIHsKIAljYXNlIElFRUU4MDJfMVhfVFlQRV9FQVBfUEFDS0VUOgorCQlpZiAoc20tPmNvbmYud29ya2Fyb3VuZCkgeworCQkJLyoKKwkJCSAqIEFuIEFQIGhhcyBiZWVuIHJlcG9ydGVkIHRvIHNlbmQgb3V0IEVBUCBtZXNzYWdlIHdpdGgKKwkJCSAqIHVuZG9jdW1lbnRlZCBjb2RlIDEwIGF0IHNvbWUgcG9pbnQgbmVhciB0aGUKKwkJCSAqIGNvbXBsZXRpb24gb2YgRUFQIGF1dGhlbnRpY2F0aW9uLiBUaGlzIGNhbiByZXN1bHQgaW4KKwkJCSAqIGlzc3VlcyB3aXRoIHRoZSB1bmV4cGVjdGVkIEVBUCBtZXNzYWdlIHRyaWdnZXJpbmcKKwkJCSAqIHJlc3RhcnQgb2YgRUFQT0wgYXV0aGVudGljYXRpb24uIEF2b2lkIHRoaXMgYnkKKwkJCSAqIHNraXBwaW5nIHRoZSBtZXNzYWdlIHdpdGhvdXQgYWR2YW5jaW5nIHRoZSBzdGF0ZQorCQkJICogbWFjaGluZS4KKwkJCSAqLworCQkJY29uc3Qgc3RydWN0IGVhcF9oZHIgKmVoZHIgPQorCQkJCShjb25zdCBzdHJ1Y3QgZWFwX2hkciAqKSAoaGRyICsgMSk7CisJCQlpZiAocGxlbiA+PSBzaXplb2YoKmVoZHIpICYmIGVoZHItPmNvZGUgPT0gMTApIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUE9MOiBJZ25vcmUgRUFQIHBhY2tldCB3aXRoIHVua25vd24gY29kZSAxMCIpOworCQkJCWJyZWFrOworCQkJfQorCQl9CisKIAkJaWYgKHNtLT5jYWNoZWRfcG1rKSB7CiAJCQkvKiBUcnlpbmcgdG8gdXNlIFBNS1NBIGNhY2hpbmcsIGJ1dCBBdXRoZW50aWNhdG9yIGRpZAogCQkJICogbm90IHNlZW0gdG8gaGF2ZSBhIG1hdGNoaW5nIGVudHJ5LiBOZWVkIHRvIHJlc3RhcnQKQEAgLTEzMTQsNiArMTM0NSwxMyBAQAogCQkJZWFwb2xfc21fc3RlcChzbSk7CiAJCX0KIAkJYnJlYWs7CisjaWZkZWYgQ09ORklHX01BQ1NFQworCWNhc2UgSUVFRTgwMl8xWF9UWVBFX0VBUE9MX01LQToKKwkJd3BhX3ByaW50ZihNU0dfRVhDRVNTSVZFLAorCQkJICAgIkVBUE9MIHR5cGUgJWQgd2lsbCBiZSBoYW5kbGVkIGJ5IE1LQSIsCisJCQkgICBoZHItPnR5cGUpOworCQlicmVhazsKKyNlbmRpZiAvKiBDT05GSUdfTUFDU0VDICovCiAJZGVmYXVsdDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVBPTDogUmVjZWl2ZWQgdW5rbm93biBFQVBPTCB0eXBlICVkIiwKIAkJCSAgIGhkci0+dHlwZSk7CkBAIC0xMzUyLDYgKzEzOTAsOCBAQAogCQlyZXR1cm47CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVBPTDogRXh0ZXJuYWwgbm90aWZpY2F0aW9uIC0gIgogCQkgICAicG9ydEVuYWJsZWQ9JWQiLCBlbmFibGVkKTsKKwlpZiAoc20tPnBvcnRFbmFibGVkICE9IGVuYWJsZWQpCisJCXNtLT5mb3JjZV9hdXRob3JpemVkX3VwZGF0ZSA9IFRSVUU7CiAJc20tPnBvcnRFbmFibGVkID0gZW5hYmxlZDsKIAllYXBvbF9zbV9zdGVwKHNtKTsKIH0KQEAgLTE0NjEsNiArMTUwMSw3IEBACiAJCWVhcF9zZXRfZmFzdF9yZWF1dGgoc20tPmVhcCwgY29uZi0+ZmFzdF9yZWF1dGgpOwogCQllYXBfc2V0X3dvcmthcm91bmQoc20tPmVhcCwgY29uZi0+d29ya2Fyb3VuZCk7CiAJCWVhcF9zZXRfZm9yY2VfZGlzYWJsZWQoc20tPmVhcCwgY29uZi0+ZWFwX2Rpc2FibGVkKTsKKwkJZWFwX3NldF9leHRlcm5hbF9zaW0oc20tPmVhcCwgY29uZi0+ZXh0ZXJuYWxfc2ltKTsKIAl9CiB9CiAKQEAgLTE0ODIsNyArMTUyMyw3IEBACiAJc2l6ZV90IGVhcF9sZW47CiAKICNpZmRlZiBDT05GSUdfRUFQX1BST1hZCi0JaWYgKHNtLT51c2VfZWFwX3Byb3h5KSB7CisJaWYgKHNtICYmIHNtLT51c2VfZWFwX3Byb3h5KSB7CiAJCS8qIEdldCBrZXkgZnJvbSBFQVAgcHJveHkgKi8KIAkJaWYgKHNtID09IE5VTEwgfHwgIWVhcF9wcm94eV9rZXlfYXZhaWxhYmxlKHNtLT5lYXBfcHJveHkpKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUE9MOiBFQVAga2V5IG5vdCBhdmFpbGFibGUiKTsKQEAgLTE1MjMsNiArMTU2NCwyNCBAQAogCiAKIC8qKgorICogZWFwb2xfc21fZ2V0X3Nlc3Npb25faWQgLSBHZXQgRUFQIFNlc3Npb24tSWQKKyAqIEBzbTogUG9pbnRlciB0byBFQVBPTCBzdGF0ZSBtYWNoaW5lIGFsbG9jYXRlZCB3aXRoIGVhcG9sX3NtX2luaXQoKQorICogQGxlbjogUG9pbnRlciB0byB2YXJpYWJsZSB0aGF0IHdpbGwgYmUgc2V0IHRvIG51bWJlciBvZiBieXRlcyBpbiB0aGUgc2Vzc2lvbgorICogUmV0dXJuczogUG9pbnRlciB0byB0aGUgRUFQIFNlc3Npb24tSWQgb3IgJU5VTEwgb24gZmFpbHVyZQorICoKKyAqIFRoZSBTZXNzaW9uLUlkIGlzIGF2YWlsYWJsZSBvbmx5IGFmdGVyIGEgc3VjY2Vzc2Z1bCBhdXRoZW50aWNhdGlvbi4KKyAqLworY29uc3QgdTggKiBlYXBvbF9zbV9nZXRfc2Vzc2lvbl9pZChzdHJ1Y3QgZWFwb2xfc20gKnNtLCBzaXplX3QgKmxlbikKK3sKKwlpZiAoc20gPT0gTlVMTCB8fCAhZWFwX2tleV9hdmFpbGFibGUoc20tPmVhcCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVBPTDogRUFQIFNlc3Npb24tSWQgbm90IGF2YWlsYWJsZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJcmV0dXJuIGVhcF9nZXRfZWFwU2Vzc2lvbklkKHNtLT5lYXAsIGxlbik7Cit9CisKKworLyoqCiAgKiBlYXBvbF9zbV9ub3RpZnlfbG9nb2ZmIC0gTm90aWZpY2F0aW9uIG9mIGxvZ29uL2xvZ29mZiBjb21tYW5kcwogICogQHNtOiBQb2ludGVyIHRvIEVBUE9MIHN0YXRlIG1hY2hpbmUgYWxsb2NhdGVkIHdpdGggZWFwb2xfc21faW5pdCgpCiAgKiBAbG9nb2ZmOiBXaGV0aGVyIGNvbW1hbmQgd2FzIGxvZ29mZgpAQCAtMTU4OSw3ICsxNjQ4LDYgQEAKIAkJcmV0dXJuOwogCXNtLT5jYWNoZWRfcG1rID0gRkFMU0U7CiAJc20tPlNVUFBfUEFFX3N0YXRlID0gU1VQUF9QQUVfQ09OTkVDVElORzsKLQlzbS0+c3VwcFBvcnRTdGF0dXMgPSBVbmF1dGhvcml6ZWQ7CiAJZWFwb2xfc21fc2V0X3BvcnRfdW5hdXRob3JpemVkKHNtKTsKIAogCS8qIE1ha2Ugc3VyZSB3ZSBkbyBub3Qgc3RhcnQgc2VuZGluZyBFQVBPTC1TdGFydCBmcmFtZXMgZmlyc3QsIGJ1dApAQCAtMTk4Myw2ICsyMDQxLDcgQEAKICNlbmRpZiAvKiBDT05GSUdfRUFQX1BST1hZICovCiAKIAkvKiBJbml0aWFsaXplIEVBUE9MIHN0YXRlIG1hY2hpbmVzICovCisJc20tPmZvcmNlX2F1dGhvcml6ZWRfdXBkYXRlID0gVFJVRTsKIAlzbS0+aW5pdGlhbGl6ZSA9IFRSVUU7CiAJZWFwb2xfc21fc3RlcChzbSk7CiAJc20tPmluaXRpYWxpemUgPSBGQUxTRTsKQEAgLTIwMzIsMyArMjA5MSwxNSBAQAogCQlyZXR1cm4gMDsKIAlyZXR1cm4gIXNtLT5lYXBTdWNjZXNzICYmIHNtLT5lYXBGYWlsOwogfQorCisKK2ludCBlYXBvbF9zbV9nZXRfZWFwX3Byb3h5X2ltc2koc3RydWN0IGVhcG9sX3NtICpzbSwgY2hhciAqaW1zaSwgc2l6ZV90ICpsZW4pCit7CisjaWZkZWYgQ09ORklHX0VBUF9QUk9YWQorCWlmIChzbS0+ZWFwX3Byb3h5ID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gZWFwX3Byb3h5X2dldF9pbXNpKHNtLT5lYXBfcHJveHksIGltc2ksIGxlbik7CisjZWxzZSAvKiBDT05GSUdfRUFQX1BST1hZICovCisJcmV0dXJuIC0xOworI2VuZGlmIC8qIENPTkZJR19FQVBfUFJPWFkgKi8KK30KZGlmZiAtLWdpdCBhL3NyYy9lYXBvbF9zdXBwL2VhcG9sX3N1cHBfc20uaCBiL3NyYy9lYXBvbF9zdXBwL2VhcG9sX3N1cHBfc20uaAppbmRleCBjNGI4N2RhLi5kNzZjOGMyIDEwMDY0NAotLS0gYS9zcmMvZWFwb2xfc3VwcC9lYXBvbF9zdXBwX3NtLmgKKysrIGIvc3JjL2VhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5oCkBAIC01MywxMSArNTMsMjIgQEAKIAkgKiBlYXBfZGlzYWJsZWQgLSBXaGV0aGVyIEVBUCBpcyBkaXNhYmxlZAogCSAqLwogCWludCBlYXBfZGlzYWJsZWQ7CisKKwkvKioKKwkgKiBleHRlcm5hbF9zaW0gLSBVc2UgZXh0ZXJuYWwgcHJvY2Vzc2luZyBmb3IgU0lNL1VTSU0gb3BlcmF0aW9ucworCSAqLworCWludCBleHRlcm5hbF9zaW07CiB9OwogCiBzdHJ1Y3QgZWFwb2xfc207CiBzdHJ1Y3Qgd3BhX2NvbmZpZ19ibG9iOwogCitlbnVtIGVhcG9sX3N1cHBfcmVzdWx0IHsKKwlFQVBPTF9TVVBQX1JFU1VMVF9GQUlMVVJFLAorCUVBUE9MX1NVUFBfUkVTVUxUX1NVQ0NFU1MsCisJRUFQT0xfU1VQUF9SRVNVTFRfRVhQRUNURURfRkFJTFVSRQorfTsKKwogLyoqCiAgKiBzdHJ1Y3QgZWFwb2xfY3R4IC0gR2xvYmFsIChmb3IgYWxsIG5ldHdvcmtzKSBFQVBPTCBzdGF0ZSBtYWNoaW5lIGNvbnRleHQKICAqLwpAQCAtNzgsNyArODksNyBAQAogCS8qKgogCSAqIGNiIC0gRnVuY3Rpb24gdG8gYmUgY2FsbGVkIHdoZW4gRUFQT0wgbmVnb3RpYXRpb24gaGFzIGJlZW4gY29tcGxldGVkCiAJICogQGVhcG9sOiBQb2ludGVyIHRvIEVBUE9MIHN0YXRlIG1hY2hpbmUgZGF0YQotCSAqIEBzdWNjZXNzOiBXaGV0aGVyIHRoZSBhdXRoZW50aWNhdGlvbiB3YXMgY29tcGxldGVkIHN1Y2Nlc3NmdWxseQorCSAqIEByZXN1bHQ6IFdoZXRoZXIgdGhlIGF1dGhlbnRpY2F0aW9uIHdhcyBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5CiAJICogQGN0eDogUG9pbnRlciB0byBjb250ZXh0IGRhdGEgKGNiX2N0eCkKIAkgKgogCSAqIFRoaXMgb3B0aW9uYWwgY2FsbGJhY2sgZnVuY3Rpb24gd2lsbCBiZSBjYWxsZWQgd2hlbiB0aGUgRUFQT0wKQEAgLTg2LDcgKzk3LDggQEAKIAkgKiBFQVBPTCBzdGF0ZSBtYWNoaW5lIHRvIHByb2Nlc3MgdGhlIGtleSBhbmQgdGVybWluYXRlIHRoZSBFQVBPTCBzdGF0ZQogCSAqIG1hY2hpbmUuIEN1cnJlbnRseSwgdGhpcyBpcyB1c2VkIG9ubHkgaW4gUlNOIHByZS1hdXRoZW50aWNhdGlvbi4KIAkgKi8KLQl2b2lkICgqY2IpKHN0cnVjdCBlYXBvbF9zbSAqZWFwb2wsIGludCBzdWNjZXNzLCB2b2lkICpjdHgpOworCXZvaWQgKCpjYikoc3RydWN0IGVhcG9sX3NtICplYXBvbCwgZW51bSBlYXBvbF9zdXBwX3Jlc3VsdCByZXN1bHQsCisJCSAgIHZvaWQgKmN0eCk7CiAKIAkvKioKIAkgKiBjYl9jdHggLSBDYWxsYmFjayBjb250ZXh0IGZvciBjYigpCkBAIC0yNzMsNiArMjg1LDcgQEAKIAkJCSAgICBzdHJ1Y3QgZWFwX3BlZXJfY29uZmlnICpjb25maWcsCiAJCQkgICAgY29uc3Qgc3RydWN0IGVhcG9sX2NvbmZpZyAqY29uZik7CiBpbnQgZWFwb2xfc21fZ2V0X2tleShzdHJ1Y3QgZWFwb2xfc20gKnNtLCB1OCAqa2V5LCBzaXplX3QgbGVuKTsKK2NvbnN0IHU4ICogZWFwb2xfc21fZ2V0X3Nlc3Npb25faWQoc3RydWN0IGVhcG9sX3NtICpzbSwgc2l6ZV90ICpsZW4pOwogdm9pZCBlYXBvbF9zbV9ub3RpZnlfbG9nb2ZmKHN0cnVjdCBlYXBvbF9zbSAqc20sIEJvb2xlYW4gbG9nb2ZmKTsKIHZvaWQgZWFwb2xfc21fbm90aWZ5X2NhY2hlZChzdHJ1Y3QgZWFwb2xfc20gKnNtKTsKIHZvaWQgZWFwb2xfc21fbm90aWZ5X3Bta2lkX2F0dGVtcHQoc3RydWN0IGVhcG9sX3NtICpzbSwgaW50IGF0dGVtcHQpOwpAQCAtMjg3LDYgKzMwMCw3IEBACiB2b2lkIGVhcG9sX3NtX3NldF9leHRfcHdfY3R4KHN0cnVjdCBlYXBvbF9zbSAqc20sCiAJCQkgICAgIHN0cnVjdCBleHRfcGFzc3dvcmRfZGF0YSAqZXh0KTsKIGludCBlYXBvbF9zbV9mYWlsZWQoc3RydWN0IGVhcG9sX3NtICpzbSk7CitpbnQgZWFwb2xfc21fZ2V0X2VhcF9wcm94eV9pbXNpKHN0cnVjdCBlYXBvbF9zbSAqc20sIGNoYXIgKmltc2ksIHNpemVfdCAqbGVuKTsKICNlbHNlIC8qIElFRUU4MDIxWF9FQVBPTCAqLwogc3RhdGljIGlubGluZSBzdHJ1Y3QgZWFwb2xfc20gKmVhcG9sX3NtX2luaXQoc3RydWN0IGVhcG9sX2N0eCAqY3R4KQogewpkaWZmIC0tZ2l0IGEvc3JjL2wyX3BhY2tldC9NYWtlZmlsZSBiL3NyYy9sMl9wYWNrZXQvTWFrZWZpbGUKaW5kZXggOWM0MTk2Mi4uYWRmZDNkZiAxMDA2NDQKLS0tIGEvc3JjL2wyX3BhY2tldC9NYWtlZmlsZQorKysgYi9zcmMvbDJfcGFja2V0L01ha2VmaWxlCkBAIC0yLDcgKzIsNyBAQAogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KIAogY2xlYW46Ci0Jcm0gLWYgKn4gKi5vICouZAorCXJtIC1mICp+ICoubyAqLmQgKi5nY25vICouZ2NkYSAqLmdjb3YKIAogaW5zdGFsbDoKIAlAZWNobyBOb3RoaW5nIHRvIGJlIG1hZGUuCmRpZmYgLS1naXQgYS9zcmMvbDJfcGFja2V0L2wyX3BhY2tldF9ub25lLmMgYi9zcmMvbDJfcGFja2V0L2wyX3BhY2tldF9ub25lLmMKaW5kZXggYjAxZTgzMC4uNjg5NmM0ZSAxMDA2NDQKLS0tIGEvc3JjL2wyX3BhY2tldC9sMl9wYWNrZXRfbm9uZS5jCisrKyBiL3NyYy9sMl9wYWNrZXQvbDJfcGFja2V0X25vbmUuYwpAQCAtODQsNyArODQsOCBAQAogCSAqIFRPRE86IG9wZW4gY29ubmVjdGlvbiBmb3IgcmVjZWl2aW5nIGZyYW1lcwogCSAqLwogCWwyLT5mZCA9IC0xOwotCWVsb29wX3JlZ2lzdGVyX3JlYWRfc29jayhsMi0+ZmQsIGwyX3BhY2tldF9yZWNlaXZlLCBsMiwgTlVMTCk7CisJaWYgKGwyLT5mZCA+PSAwKQorCQllbG9vcF9yZWdpc3Rlcl9yZWFkX3NvY2sobDItPmZkLCBsMl9wYWNrZXRfcmVjZWl2ZSwgbDIsIE5VTEwpOwogCiAJcmV0dXJuIGwyOwogfQpkaWZmIC0tZ2l0IGEvc3JjL3AycC9NYWtlZmlsZSBiL3NyYy9wMnAvTWFrZWZpbGUKaW5kZXggY2ZmYmE2Mi4uYWRmZDNkZiAxMDA2NDQKLS0tIGEvc3JjL3AycC9NYWtlZmlsZQorKysgYi9zcmMvcDJwL01ha2VmaWxlCkBAIC0yLDggKzIsNyBAQAogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KIAogY2xlYW46Ci0JZm9yIGQgaW4gJChTVUJESVJTKTsgZG8gbWFrZSAtQyAkJGQgY2xlYW47IGRvbmUKLQlybSAtZiAqfiAqLm8gKi5kCisJcm0gLWYgKn4gKi5vICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgogCiBpbnN0YWxsOgogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwLmMgYi9zcmMvcDJwL3AycC5jCmluZGV4IGZhNmE4NDkuLjY2N2I5NmIgMTAwNjQ0Ci0tLSBhL3NyYy9wMnAvcDJwLmMKKysrIGIvc3JjL3AycC9wMnAuYwpAQCAtMTIsNiArMTIsNyBAQAogI2luY2x1ZGUgImVsb29wLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIgorI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgIndwcy93cHNfaS5oIgogI2luY2x1ZGUgInAycF9pLmgiCiAjaW5jbHVkZSAicDJwLmgiCkBAIC00MSw1MSArNDIsMzIgQEAKICAqIFAyUF9QRUVSX0VYUElSQVRJT05fQUdFIC0gTnVtYmVyIG9mIHNlY29uZHMgYWZ0ZXIgd2hpY2ggaW5hY3RpdmUgcGVlcgogICogZW50cmllcyB3aWxsIGJlIHJlbW92ZWQKICAqLwotI2lmZGVmIEFORFJPSURfUDJQCi0jZGVmaW5lIFAyUF9QRUVSX0VYUElSQVRJT05fQUdFIDMwCi0jZWxzZQotI2RlZmluZSBQMlBfUEVFUl9FWFBJUkFUSU9OX0FHRSAzMDAKLSNlbmRpZgorI2lmbmRlZiBQMlBfUEVFUl9FWFBJUkFUSU9OX0FHRQorI2RlZmluZSBQMlBfUEVFUl9FWFBJUkFUSU9OX0FHRSA2MAorI2VuZGlmIC8qIFAyUF9QRUVSX0VYUElSQVRJT05fQUdFICovCiAKICNkZWZpbmUgUDJQX1BFRVJfRVhQSVJBVElPTl9JTlRFUlZBTCAoUDJQX1BFRVJfRVhQSVJBVElPTl9BR0UgLyAyKQogCi0jaWZkZWYgQU5EUk9JRF9QMlAKLWludCBwMnBfY29ubmVjdGlvbl9pbl9wcm9ncmVzcyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCkKLXsKLQlpbnQgcmV0ID0gMDsKLQotCXN3aXRjaCAocDJwLT5zdGF0ZSkgewotCQljYXNlIFAyUF9DT05ORUNUOgotCQljYXNlIFAyUF9DT05ORUNUX0xJU1RFTjoKLQkJY2FzZSBQMlBfR09fTkVHOgotCQljYXNlIFAyUF9XQUlUX1BFRVJfQ09OTkVDVDoKLQkJY2FzZSBQMlBfV0FJVF9QRUVSX0lETEU6Ci0JCWNhc2UgUDJQX1BST1ZJU0lPTklORzoKLQkJY2FzZSBQMlBfSU5WSVRFOgotCQljYXNlIFAyUF9JTlZJVEVfTElTVEVOOgotCQkJcmV0ID0gMTsKLQkJCWJyZWFrOwotCi0JCWRlZmF1bHQ6Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgInAycF9jb25uZWN0aW9uX2luX3Byb2dyZXNzIHN0YXRlICVkIiwgcDJwLT5zdGF0ZSk7Ci0JCQlyZXQgPSAwOwotCX0KLQotCXJldHVybiByZXQ7Ci19Ci0jZW5kaWYKLQogc3RhdGljIHZvaWQgcDJwX2V4cGlyZV9wZWVycyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCkKIHsKIAlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2LCAqbjsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCXNpemVfdCBpOwogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7CisJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CiAJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKGRldiwgbiwgJnAycC0+ZGV2aWNlcywgc3RydWN0IHAycF9kZXZpY2UsIGxpc3QpIHsKIAkJaWYgKGRldi0+bGFzdF9zZWVuLnNlYyArIFAyUF9QRUVSX0VYUElSQVRJT05fQUdFID49IG5vdy5zZWMpCiAJCQljb250aW51ZTsKIAorCQlpZiAoZGV2ID09IHAycC0+Z29fbmVnX3BlZXIpIHsKKwkJCS8qCisJCQkgKiBHTyBOZWdvdGlhdGlvbiBpcyBpbiBwcm9ncmVzcyB3aXRoIHRoZSBwZWVyLCBzbworCQkJICogZG9uJ3QgZXhwaXJlIHRoZSBwZWVyIGVudHJ5IHVudGlsIEdPIE5lZ290aWF0aW9uCisJCQkgKiBmYWlscyBvciB0aW1lcyBvdXQuCisJCQkgKi8KKwkJCWNvbnRpbnVlOworCQl9CisKIAkJaWYgKHAycC0+Y2ZnLT5nb19jb25uZWN0ZWQgJiYKIAkJICAgIHAycC0+Y2ZnLT5nb19jb25uZWN0ZWQocDJwLT5jZmctPmNiX2N0eCwKIAkJCQkJICAgZGV2LT5pbmZvLnAycF9kZXZpY2VfYWRkcikpIHsKQEAgLTkzLDcgKzc1LDcgQEAKIAkJCSAqIFdlIGFyZSBjb25uZWN0ZWQgYXMgYSBjbGllbnQgdG8gYSBncm91cCBpbiB3aGljaCB0aGUKIAkJCSAqIHBlZXIgaXMgdGhlIEdPLCBzbyBkbyBub3QgZXhwaXJlIHRoZSBwZWVyIGVudHJ5LgogCQkJICovCi0JCQlvc19nZXRfdGltZSgmZGV2LT5sYXN0X3NlZW4pOworCQkJb3NfZ2V0X3JlbHRpbWUoJmRldi0+bGFzdF9zZWVuKTsKIAkJCWNvbnRpbnVlOwogCQl9CiAKQEAgLTEwNywyNSArODksMTIgQEAKIAkJCSAqIFRoZSBwZWVyIGlzIGNvbm5lY3RlZCBhcyBhIGNsaWVudCBpbiBhIGdyb3VwIHdoZXJlCiAJCQkgKiB3ZSBhcmUgdGhlIEdPLCBzbyBkbyBub3QgZXhwaXJlIHRoZSBwZWVyIGVudHJ5LgogCQkJICovCi0JCQlvc19nZXRfdGltZSgmZGV2LT5sYXN0X3NlZW4pOworCQkJb3NfZ2V0X3JlbHRpbWUoJmRldi0+bGFzdF9zZWVuKTsKIAkJCWNvbnRpbnVlOwogCQl9CiAKLSNpZmRlZiBBTkRST0lEX1AyUAotCQkvKiBJZiBDb25uZWN0aW9uIGlzIGluIHByb2dyZXNzLCBkb24ndCBleHBpcmUgdGhlIHBlZXIKLQkJKi8KLQkJaWYgKHAycF9jb25uZWN0aW9uX2luX3Byb2dyZXNzKHAycCkpCi0JCQljb250aW51ZTsKLSNlbmRpZgotCiAJCXAycF9kYmcocDJwLCAiRXhwaXJpbmcgb2xkIHBlZXIgZW50cnkgIiBNQUNTVFIsCiAJCQlNQUMyU1RSKGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIpKTsKLQotI2lmZGVmIEFORFJPSURfUDJQCi0JCS8qIFNEX0ZBSVJfUE9MSUNZOiBVcGRhdGUgdGhlIGN1cnJlbnQgc2RfZGV2X2xpc3QgcG9pbnRlciB0byBuZXh0IGRldmljZSAqLwotCQlpZigmZGV2LT5saXN0ID09IHAycC0+c2RfZGV2X2xpc3QpCi0JCQlwMnAtPnNkX2Rldl9saXN0ID0gZGV2LT5saXN0Lm5leHQ7Ci0jZW5kaWYKIAkJZGxfbGlzdF9kZWwoJmRldi0+bGlzdCk7CiAJCXAycF9kZXZpY2VfZnJlZShwMnAsIGRldik7CiAJfQpAQCAtMTcwLDEwICsxMzksNiBAQAogCQlyZXR1cm4gIklOVklURSI7CiAJY2FzZSBQMlBfSU5WSVRFX0xJU1RFTjoKIAkJcmV0dXJuICJJTlZJVEVfTElTVEVOIjsKLQljYXNlIFAyUF9TRUFSQ0hfV0hFTl9SRUFEWToKLQkJcmV0dXJuICJTRUFSQ0hfV0hFTl9SRUFEWSI7Ci0JY2FzZSBQMlBfQ09OVElOVUVfU0VBUkNIX1dIRU5fUkVBRFk6Ci0JCXJldHVybiAiQ09OVElOVUVfU0VBUkNIX1dIRU5fUkVBRFkiOwogCWRlZmF1bHQ6CiAJCXJldHVybiAiPyI7CiAJfQpAQCAtMjE5LDYgKzE4NCwxNCBAQAogCXAycF9kYmcocDJwLCAiU3RhdGUgJXMgLT4gJXMiLAogCQlwMnBfc3RhdGVfdHh0KHAycC0+c3RhdGUpLCBwMnBfc3RhdGVfdHh0KG5ld19zdGF0ZSkpOwogCXAycC0+c3RhdGUgPSBuZXdfc3RhdGU7CisKKwlpZiAobmV3X3N0YXRlID09IFAyUF9JRExFICYmIHAycC0+cGVuZGluZ19jaGFubmVsKSB7CisJCXAycF9kYmcocDJwLCAiQXBwbHkgY2hhbmdlIGluIGxpc3RlbiBjaGFubmVsIik7CisJCXAycC0+Y2ZnLT5yZWdfY2xhc3MgPSBwMnAtPnBlbmRpbmdfcmVnX2NsYXNzOworCQlwMnAtPmNmZy0+Y2hhbm5lbCA9IHAycC0+cGVuZGluZ19jaGFubmVsOworCQlwMnAtPnBlbmRpbmdfcmVnX2NsYXNzID0gMDsKKwkJcDJwLT5wZW5kaW5nX2NoYW5uZWwgPSAwOworCX0KIH0KIAogCkBAIC0yNDcsMTIgKzIyMCwxNSBAQAogCWlmIChwMnAtPmdvX25lZ19wZWVyKSB7CiAJCXAycC0+Z29fbmVnX3BlZXItPmZsYWdzICY9IH5QMlBfREVWX1BFRVJfV0FJVElOR19SRVNQT05TRTsKIAkJcDJwLT5nb19uZWdfcGVlci0+d3BzX21ldGhvZCA9IFdQU19OT1RfUkVBRFk7CisJCXAycC0+Z29fbmVnX3BlZXItPm9vYl9wd19pZCA9IDA7CiAJfQogCXAycC0+Z29fbmVnX3BlZXIgPSBOVUxMOwogCiAJb3NfbWVtc2V0KCZyZXMsIDAsIHNpemVvZihyZXMpKTsKIAlyZXMuc3RhdHVzID0gc3RhdHVzOwogCWlmIChwZWVyKSB7CisJCXdwYWJ1Zl9mcmVlKHBlZXItPmdvX25lZ19jb25mKTsKKwkJcGVlci0+Z29fbmVnX2NvbmYgPSBOVUxMOwogCQlvc19tZW1jcHkocmVzLnBlZXJfZGV2aWNlX2FkZHIsIHBlZXItPmluZm8ucDJwX2RldmljZV9hZGRyLAogCQkJICBFVEhfQUxFTik7CiAJCW9zX21lbWNweShyZXMucGVlcl9pbnRlcmZhY2VfYWRkciwgcGVlci0+aW50ZW5kZWRfYWRkciwKQEAgLTI3MSw2ICsyNDcsMTIgQEAKIAlwMnBfZGJnKHAycCwgIlN0YXJ0aW5nIHNob3J0IGxpc3RlbiBzdGF0ZSAoc3RhdGU9JXMpIiwKIAkJcDJwX3N0YXRlX3R4dChwMnAtPnN0YXRlKSk7CiAKKwlpZiAocDJwLT5wZW5kaW5nX2xpc3Rlbl9mcmVxKSB7CisJCS8qIFdlIGhhdmUgYSBwZW5kaW5nIHAycF9saXN0ZW4gcmVxdWVzdCAqLworCQlwMnBfZGJnKHAycCwgInAycF9saXN0ZW4gY29tbWFuZCBwZW5kaW5nIGFscmVhZHkiKTsKKwkJcmV0dXJuOworCX0KKwogCWZyZXEgPSBwMnBfY2hhbm5lbF90b19mcmVxKHAycC0+Y2ZnLT5yZWdfY2xhc3MsIHAycC0+Y2ZnLT5jaGFubmVsKTsKIAlpZiAoZnJlcSA8IDApIHsKIAkJcDJwX2RiZyhwMnAsICJVbmtub3duIHJlZ3VsYXRvcnkgY2xhc3MvY2hhbm5lbCIpOwpAQCAtMjkzLDE0ICsyNzUsMTQgQEAKIAkJcmV0dXJuOwogCX0KIAotCXAycC0+cGVuZGluZ19saXN0ZW5fZnJlcSA9IGZyZXE7Ci0JcDJwLT5wZW5kaW5nX2xpc3Rlbl9zZWMgPSAwOwotCXAycC0+cGVuZGluZ19saXN0ZW5fdXNlYyA9IDEwMjQgKiB0dTsKLQogCWllcyA9IHAycF9idWlsZF9wcm9iZV9yZXNwX2llcyhwMnApOwogCWlmIChpZXMgPT0gTlVMTCkKIAkJcmV0dXJuOwogCisJcDJwLT5wZW5kaW5nX2xpc3Rlbl9mcmVxID0gZnJlcTsKKwlwMnAtPnBlbmRpbmdfbGlzdGVuX3NlYyA9IDA7CisJcDJwLT5wZW5kaW5nX2xpc3Rlbl91c2VjID0gMTAyNCAqIHR1OworCiAJaWYgKHAycC0+Y2ZnLT5zdGFydF9saXN0ZW4ocDJwLT5jZmctPmNiX2N0eCwgZnJlcSwgMTAyNCAqIHR1IC8gMTAwMCwKIAkJICAgIGllcykgPCAwKSB7CiAJCXAycF9kYmcocDJwLCAiRmFpbGVkIHRvIHN0YXJ0IGxpc3RlbiBtb2RlIik7CkBAIC0zMTcsMTMgKzI5OSwxOCBAQAogCiAJcDJwX2RiZyhwMnAsICJHb2luZyB0byBsaXN0ZW4ob25seSkgc3RhdGUiKTsKIAorCWlmIChwMnAtPnBlbmRpbmdfbGlzdGVuX2ZyZXEpIHsKKwkJLyogV2UgaGF2ZSBhIHBlbmRpbmcgcDJwX2xpc3RlbiByZXF1ZXN0ICovCisJCXAycF9kYmcocDJwLCAicDJwX2xpc3RlbiBjb21tYW5kIHBlbmRpbmcgYWxyZWFkeSIpOworCQlyZXR1cm4gLTE7CisJfQorCiAJZnJlcSA9IHAycF9jaGFubmVsX3RvX2ZyZXEocDJwLT5jZmctPnJlZ19jbGFzcywgcDJwLT5jZmctPmNoYW5uZWwpOwogCWlmIChmcmVxIDwgMCkgewogCQlwMnBfZGJnKHAycCwgIlVua25vd24gcmVndWxhdG9yeSBjbGFzcy9jaGFubmVsIik7CiAJCXJldHVybiAtMTsKIAl9CiAKLQlwMnAtPnBlbmRpbmdfbGlzdGVuX2ZyZXEgPSBmcmVxOwogCXAycC0+cGVuZGluZ19saXN0ZW5fc2VjID0gdGltZW91dCAvIDEwMDA7CiAJcDJwLT5wZW5kaW5nX2xpc3Rlbl91c2VjID0gKHRpbWVvdXQgJSAxMDAwKSAqIDEwMDA7CiAKQEAgLTM0MSw2ICszMjgsOCBAQAogCWlmIChpZXMgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCisJcDJwLT5wZW5kaW5nX2xpc3Rlbl9mcmVxID0gZnJlcTsKKwogCWlmIChwMnAtPmNmZy0+c3RhcnRfbGlzdGVuKHAycC0+Y2ZnLT5jYl9jdHgsIGZyZXEsIHRpbWVvdXQsIGllcykgPCAwKSB7CiAJCXAycF9kYmcocDJwLCAiRmFpbGVkIHRvIHN0YXJ0IGxpc3RlbiBtb2RlIik7CiAJCXAycC0+cGVuZGluZ19saXN0ZW5fZnJlcSA9IDA7CkBAIC00MjAsMTYgKzQwOSwxMSBAQAogCWRsX2xpc3RfZm9yX2VhY2goZGV2LCAmcDJwLT5kZXZpY2VzLCBzdHJ1Y3QgcDJwX2RldmljZSwgbGlzdCkgewogCQljb3VudCsrOwogCQlpZiAob2xkZXN0ID09IE5VTEwgfHwKLQkJICAgIG9zX3RpbWVfYmVmb3JlKCZkZXYtPmxhc3Rfc2VlbiwgJm9sZGVzdC0+bGFzdF9zZWVuKSkKKwkJICAgIG9zX3JlbHRpbWVfYmVmb3JlKCZkZXYtPmxhc3Rfc2VlbiwgJm9sZGVzdC0+bGFzdF9zZWVuKSkKIAkJCW9sZGVzdCA9IGRldjsKIAl9CiAJaWYgKGNvdW50ICsgMSA+IHAycC0+Y2ZnLT5tYXhfcGVlcnMgJiYgb2xkZXN0KSB7CiAJCXAycF9kYmcocDJwLCAiUmVtb3ZlIG9sZGVzdCBwZWVyIGVudHJ5IHRvIG1ha2Ugcm9vbSBmb3IgYSBuZXcgcGVlciIpOwotI2lmZGVmIEFORFJPSURfUDJQCi0JCS8qIFNEX0ZBSVJfUE9MSUNZOiBVcGRhdGUgdGhlIGN1cnJlbnQgc2RfZGV2X2xpc3QgcG9pbnRlciB0byBuZXh0IGRldmljZSAqLwotCQlpZigmb2xkZXN0LT5saXN0ID09IHAycC0+c2RfZGV2X2xpc3QpCi0JCQlwMnAtPnNkX2Rldl9saXN0ID0gb2xkZXN0LT5saXN0Lm5leHQ7Ci0jZW5kaWYKIAkJZGxfbGlzdF9kZWwoJm9sZGVzdC0+bGlzdCk7CiAJCXAycF9kZXZpY2VfZnJlZShwMnAsIG9sZGVzdCk7CiAJfQpAQCAtNTI4LDcgKzUxMiw3IEBACiAKIAkJb3NfbWVtY3B5KGRldi0+aW50ZXJmYWNlX2FkZHIsIGNsaS0+cDJwX2ludGVyZmFjZV9hZGRyLAogCQkJICBFVEhfQUxFTik7Ci0JCW9zX2dldF90aW1lKCZkZXYtPmxhc3Rfc2Vlbik7CisJCW9zX2dldF9yZWx0aW1lKCZkZXYtPmxhc3Rfc2Vlbik7CiAJCW9zX21lbWNweShkZXYtPm1lbWJlcl9pbl9nb19kZXYsIGdvX2Rldl9hZGRyLCBFVEhfQUxFTik7CiAJCW9zX21lbWNweShkZXYtPm1lbWJlcl9pbl9nb19pZmFjZSwgZ29faW50ZXJmYWNlX2FkZHIsCiAJCQkgIEVUSF9BTEVOKTsKQEAgLTYyNSw2ICs2MDksNDYgQEAKIH0KIAogCitzdGF0aWMgdm9pZCBwMnBfdXBkYXRlX3BlZXJfdmVuZG9yX2VsZW1zKHN0cnVjdCBwMnBfZGV2aWNlICpkZXYsIGNvbnN0IHU4ICppZXMsCisJCQkJCSBzaXplX3QgaWVzX2xlbikKK3sKKwljb25zdCB1OCAqcG9zLCAqZW5kOworCXU4IGlkLCBsZW47CisKKwl3cGFidWZfZnJlZShkZXYtPmluZm8udmVuZG9yX2VsZW1zKTsKKwlkZXYtPmluZm8udmVuZG9yX2VsZW1zID0gTlVMTDsKKworCWVuZCA9IGllcyArIGllc19sZW47CisKKwlmb3IgKHBvcyA9IGllczsgcG9zICsgMSA8IGVuZDsgcG9zICs9IGxlbikgeworCQlpZCA9ICpwb3MrKzsKKwkJbGVuID0gKnBvcysrOworCisJCWlmIChwb3MgKyBsZW4gPiBlbmQpCisJCQlicmVhazsKKworCQlpZiAoaWQgIT0gV0xBTl9FSURfVkVORE9SX1NQRUNJRklDIHx8IGxlbiA8IDMpCisJCQljb250aW51ZTsKKworCQlpZiAobGVuID49IDQpIHsKKwkJCXUzMiB0eXBlID0gV1BBX0dFVF9CRTMyKHBvcyk7CisKKwkJCWlmICh0eXBlID09IFdQQV9JRV9WRU5ET1JfVFlQRSB8fAorCQkJICAgIHR5cGUgPT0gV01NX0lFX1ZFTkRPUl9UWVBFIHx8CisJCQkgICAgdHlwZSA9PSBXUFNfSUVfVkVORE9SX1RZUEUgfHwKKwkJCSAgICB0eXBlID09IFAyUF9JRV9WRU5ET1JfVFlQRSB8fAorCQkJICAgIHR5cGUgPT0gV0ZEX0lFX1ZFTkRPUl9UWVBFKQorCQkJCWNvbnRpbnVlOworCQl9CisKKwkJLyogVW5rbm93biB2ZW5kb3IgZWxlbWVudCAtIG1ha2UgcmF3IElFIGRhdGEgYXZhaWxhYmxlICovCisJCWlmICh3cGFidWZfcmVzaXplKCZkZXYtPmluZm8udmVuZG9yX2VsZW1zLCAyICsgbGVuKSA8IDApCisJCQlicmVhazsKKwkJd3BhYnVmX3B1dF9kYXRhKGRldi0+aW5mby52ZW5kb3JfZWxlbXMsIHBvcyAtIDIsIDIgKyBsZW4pOworCX0KK30KKworCiAvKioKICAqIHAycF9hZGRfZGV2aWNlIC0gQWRkIHBlZXIgZW50cmllcyBiYXNlZCBvbiBzY2FuIHJlc3VsdHMgb3IgUDJQIGZyYW1lcwogICogQHAycDogUDJQIG1vZHVsZSBjb250ZXh0IGZyb20gcDJwX2luaXQoKQpAQCAtNjQ0LDE0ICs2NjgsMTQgQEAKICAqIEluZm8gYXR0cmlidXRlcy4KICAqLwogaW50IHAycF9hZGRfZGV2aWNlKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqYWRkciwgaW50IGZyZXEsCi0JCSAgIHN0cnVjdCBvc190aW1lICpyeF90aW1lLCBpbnQgbGV2ZWwsIGNvbnN0IHU4ICppZXMsCisJCSAgIHN0cnVjdCBvc19yZWx0aW1lICpyeF90aW1lLCBpbnQgbGV2ZWwsIGNvbnN0IHU4ICppZXMsCiAJCSAgIHNpemVfdCBpZXNfbGVuLCBpbnQgc2Nhbl9yZXMpCiB7CiAJc3RydWN0IHAycF9kZXZpY2UgKmRldjsKIAlzdHJ1Y3QgcDJwX21lc3NhZ2UgbXNnOwogCWNvbnN0IHU4ICpwMnBfZGV2X2FkZHI7CiAJaW50IGk7Ci0Jc3RydWN0IG9zX3RpbWUgdGltZV9ub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgdGltZV9ub3c7CiAKIAlvc19tZW1zZXQoJm1zZywgMCwgc2l6ZW9mKG1zZykpOwogCWlmIChwMnBfcGFyc2VfaWVzKGllcywgaWVzX2xlbiwgJm1zZykpIHsKQEAgLTY4NSw3ICs3MDksNyBAQAogCX0KIAogCWlmIChyeF90aW1lID09IE5VTEwpIHsKLQkJb3NfZ2V0X3RpbWUoJnRpbWVfbm93KTsKKwkJb3NfZ2V0X3JlbHRpbWUoJnRpbWVfbm93KTsKIAkJcnhfdGltZSA9ICZ0aW1lX25vdzsKIAl9CiAKQEAgLTY5NCw3ICs3MTgsNyBAQAogCSAqIGVudHJ5IGlzIG5ld2VyIHRoYW4gdGhlIG9uZSBwcmV2aW91c2x5IHN0b3JlZC4KIAkgKi8KIAlpZiAoZGV2LT5sYXN0X3NlZW4uc2VjID4gMCAmJgotCSAgICBvc190aW1lX2JlZm9yZShyeF90aW1lLCAmZGV2LT5sYXN0X3NlZW4pKSB7CisJICAgIG9zX3JlbHRpbWVfYmVmb3JlKHJ4X3RpbWUsICZkZXYtPmxhc3Rfc2VlbikpIHsKIAkJcDJwX2RiZyhwMnAsICJEbyBub3QgdXBkYXRlIHBlZXIgZW50cnkgYmFzZWQgb24gb2xkIGZyYW1lIChyeF90aW1lPSV1LiUwNnUgbGFzdF9zZWVuPSV1LiUwNnUpIiwKIAkJCSh1bnNpZ25lZCBpbnQpIHJ4X3RpbWUtPnNlYywKIAkJCSh1bnNpZ25lZCBpbnQpIHJ4X3RpbWUtPnVzZWMsCkBAIC03MDQsNyArNzI4LDcgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCW9zX21lbWNweSgmZGV2LT5sYXN0X3NlZW4sIHJ4X3RpbWUsIHNpemVvZihzdHJ1Y3Qgb3NfdGltZSkpOworCW9zX21lbWNweSgmZGV2LT5sYXN0X3NlZW4sIHJ4X3RpbWUsIHNpemVvZihzdHJ1Y3Qgb3NfcmVsdGltZSkpOwogCiAJZGV2LT5mbGFncyAmPSB+KFAyUF9ERVZfUFJPQkVfUkVRX09OTFkgfCBQMlBfREVWX0dST1VQX0NMSUVOVF9PTkxZKTsKIApAQCAtNzc0LDggKzc5OCw3IEBACiAKIAlwMnBfcGFyc2VfZnJlZSgmbXNnKTsKIAotCWlmIChwMnBfcGVuZGluZ19zZF9yZXEocDJwLCBkZXYpKQotCQlkZXYtPmZsYWdzIHw9IFAyUF9ERVZfU0RfU0NIRURVTEU7CisJcDJwX3VwZGF0ZV9wZWVyX3ZlbmRvcl9lbGVtcyhkZXYsIGllcywgaWVzX2xlbik7CiAKIAlpZiAoZGV2LT5mbGFncyAmIFAyUF9ERVZfUkVQT1JURUQpCiAJCXJldHVybiAwOwpAQCAtODQ2LDYgKzg2OSw4IEBACiAJfQogCiAJd3BhYnVmX2ZyZWUoZGV2LT5pbmZvLndmZF9zdWJlbGVtcyk7CisJd3BhYnVmX2ZyZWUoZGV2LT5pbmZvLnZlbmRvcl9lbGVtcyk7CisJd3BhYnVmX2ZyZWUoZGV2LT5nb19uZWdfY29uZik7CiAKIAlvc19mcmVlKGRldik7CiB9CkBAIC05MzMsOSArOTU4LDYgQEAKIAlpZiAocmVzIDwgMCkgewogCQlwMnBfZGJnKHAycCwgIlNjYW4gcmVxdWVzdCBmYWlsZWQiKTsKIAkJcDJwX2NvbnRpbnVlX2ZpbmQocDJwKTsKLQl9IGVsc2UgaWYgKHJlcyA9PSAxKSB7Ci0JCXAycF9kYmcocDJwLCAiQ291bGQgbm90IHN0YXJ0IHAycF9zY2FuIGF0IHRoaXMgcG9pbnQgLSB3aWxsIHRyeSBhZ2FpbiBhZnRlciBwcmV2aW91cyBzY2FuIGNvbXBsZXRlcyIpOwotCQlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX0NPTlRJTlVFX1NFQVJDSF9XSEVOX1JFQURZKTsKIAl9IGVsc2UgewogCQlwMnBfZGJnKHAycCwgIlJ1bm5pbmcgcDJwX3NjYW4iKTsKIAkJcDJwLT5wMnBfc2Nhbl9ydW5uaW5nID0gMTsKQEAgLTk3MiwxNSArOTk0LDcgQEAKIAkJCQkgICAgICBwMnAtPmFmdGVyX3NjYW5fdHgtPndhaXRfdGltZSk7CiAJCW9zX2ZyZWUocDJwLT5hZnRlcl9zY2FuX3R4KTsKIAkJcDJwLT5hZnRlcl9zY2FuX3R4ID0gTlVMTDsKLSNpZmRlZiBBTkRST0lEX1AyUAotCQkvKiBGb3IgU0QgZnJhbWVzLCB0aGVyZSBpcyBhIHNjZW5hcmlvLCB3aGVyZSB3ZSBjYW4gcmVjZWl2ZSBhIFNEIHJlcXVlc3QgZnJhbWUgZHVyaW5nIHAycF9zY2FuLgotCQkgKiBBdCB0aGF0IG1vbWVudCwgd2Ugd2lsbCBzZW5kIHRoZSBTRCByZXNwb25zZSBmcm9tIHRoaXMgY29udGV4dC4gQWZ0ZXIgc2VuZGluZyB0aGUgU0QgcmVzcG9uc2UsCi0JCSAqIHdlIG5lZWQgdG8gY29udGludWUgcDJwX2ZpbmQuIEJ1dCBpZiB3ZSByZXR1cm4gMSBmcm9tIGhlcmUsIHAycF9maW5kIGlzIGdvaW5nIHRvIGJlIHN0b3BwZWQuCi0JCSAqLwotCQlyZXR1cm4gMDsKLSNlbHNlCiAJCXJldHVybiAxOwotI2VuZGlmCiAJfQogCiAJb3AgPSBwMnAtPnN0YXJ0X2FmdGVyX3NjYW47CkBAIC0xMDM5LDcgKzEwNTMsNyBAQAogCWludCByZXM7CiAKIAlwMnBfZGJnKHAycCwgIlN0YXJ0aW5nIGZpbmQgKHR5cGU9JWQpIiwgdHlwZSk7Ci0Jb3NfZ2V0X3RpbWUoJnAycC0+ZmluZF9zdGFydCk7CisJb3NfZ2V0X3JlbHRpbWUoJnAycC0+ZmluZF9zdGFydCk7CiAJaWYgKHAycC0+cDJwX3NjYW5fcnVubmluZykgewogCQlwMnBfZGJnKHAycCwgInAycF9zY2FuIGlzIGFscmVhZHkgcnVubmluZyIpOwogCX0KQEAgLTEwOTgsMTEgKzExMTIsMTAgQEAKIAkJZWxvb3BfY2FuY2VsX3RpbWVvdXQocDJwX3NjYW5fdGltZW91dCwgcDJwLCBOVUxMKTsKIAkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChQMlBfU0NBTl9USU1FT1VULCAwLCBwMnBfc2Nhbl90aW1lb3V0LAogCQkJCSAgICAgICBwMnAsIE5VTEwpOwotCX0gZWxzZSBpZiAocmVzID09IDEpIHsKLQkJcDJwX2RiZyhwMnAsICJDb3VsZCBub3Qgc3RhcnQgcDJwX3NjYW4gYXQgdGhpcyBwb2ludCAtIHdpbGwgdHJ5IGFnYWluIGFmdGVyIHByZXZpb3VzIHNjYW4gY29tcGxldGVzIik7Ci0JCXJlcyA9IDA7Ci0JCXAycF9zZXRfc3RhdGUocDJwLCBQMlBfU0VBUkNIX1dIRU5fUkVBRFkpOwotCQllbG9vcF9jYW5jZWxfdGltZW91dChwMnBfZmluZF90aW1lb3V0LCBwMnAsIE5VTEwpOworCX0gZWxzZSBpZiAocDJwLT5wMnBfc2Nhbl9ydW5uaW5nKSB7CisJCXAycF9kYmcocDJwLCAiRmFpbGVkIHRvIHN0YXJ0IHAycF9zY2FuIC0gYW5vdGhlciBwMnBfc2NhbiB3YXMgYWxyZWFkeSBydW5uaW5nIik7CisJCS8qIHdhaXQgZm9yIHRoZSBwcmV2aW91cyBwMnBfc2NhbiB0byBjb21wbGV0ZSAqLworCQlyZXMgPSAwOyAvKiBkbyBub3QgcmVwb3J0IGZhaWx1cmUgKi8KIAl9IGVsc2UgewogCQlwMnBfZGJnKHAycCwgIkZhaWxlZCB0byBzdGFydCBwMnBfc2NhbiIpOwogCQlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX0lETEUpOwpAQCAtMTExMiw0NyArMTEyNSwxMyBAQAogCXJldHVybiByZXM7CiB9CiAKLSNpZmRlZiBBTkRST0lEX1AyUAotaW50IHAycF9zZWFyY2hfcGVuZGluZyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCkKLXsKLQlpZihwMnAgPT0gTlVMTCkKLQkJcmV0dXJuIDA7Ci0KLQlpZihwMnAtPnN0YXRlID09IFAyUF9TRUFSQ0hfV0hFTl9SRUFEWSkKLQkJcmV0dXJuIDE7Ci0KLQlyZXR1cm4gMDsKLX0KLSNlbmRpZgotCi1pbnQgcDJwX290aGVyX3NjYW5fY29tcGxldGVkKHN0cnVjdCBwMnBfZGF0YSAqcDJwKQotewotCWlmIChwMnAtPnN0YXRlID09IFAyUF9DT05USU5VRV9TRUFSQ0hfV0hFTl9SRUFEWSkgewotCQlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX1NFQVJDSCk7Ci0JCXAycF9zZWFyY2gocDJwKTsKLQkJcmV0dXJuIDE7Ci0JfQotCWlmIChwMnAtPnN0YXRlICE9IFAyUF9TRUFSQ0hfV0hFTl9SRUFEWSkKLQkJcmV0dXJuIDA7Ci0JcDJwX2RiZyhwMnAsICJTdGFydGluZyBwZW5kaW5nIFAyUCBmaW5kIG5vdyB0aGF0IHByZXZpb3VzIHNjYW4gd2FzIGNvbXBsZXRlZCIpOwotCWlmIChwMnBfZmluZChwMnAsIHAycC0+bGFzdF9wMnBfZmluZF90aW1lb3V0LCBwMnAtPmZpbmRfdHlwZSwKLQkJICAgICBwMnAtPm51bV9yZXFfZGV2X3R5cGVzLCBwMnAtPnJlcV9kZXZfdHlwZXMsCi0JCSAgICAgcDJwLT5maW5kX2Rldl9pZCwgcDJwLT5zZWFyY2hfZGVsYXkpIDwgMCkgewotCQlwMnAtPmNmZy0+ZmluZF9zdG9wcGVkKHAycC0+Y2ZnLT5jYl9jdHgpOwotCQlyZXR1cm4gMDsKLQl9Ci0JcmV0dXJuIDE7Ci19Ci0KIAogdm9pZCBwMnBfc3RvcF9maW5kX2Zvcl9mcmVxKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBpbnQgZnJlcSkKIHsKIAlwMnBfZGJnKHAycCwgIlN0b3BwaW5nIGZpbmQiKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dChwMnBfZmluZF90aW1lb3V0LCBwMnAsIE5VTEwpOwogCXAycF9jbGVhcl90aW1lb3V0KHAycCk7Ci0JaWYgKHAycC0+c3RhdGUgPT0gUDJQX1NFQVJDSCB8fAotCSAgICBwMnAtPnN0YXRlID09IFAyUF9DT05USU5VRV9TRUFSQ0hfV0hFTl9SRUFEWSB8fAotCSAgICBwMnAtPnN0YXRlID09IFAyUF9TRUFSQ0hfV0hFTl9SRUFEWSkKKwlpZiAocDJwLT5zdGF0ZSA9PSBQMlBfU0VBUkNIKQogCQlwMnAtPmNmZy0+ZmluZF9zdG9wcGVkKHAycC0+Y2ZnLT5jYl9jdHgpOwogCXAycF9zZXRfc3RhdGUocDJwLCBQMlBfSURMRSk7CiAJcDJwX2ZyZWVfcmVxX2Rldl90eXBlcyhwMnApOwpAQCAtMTIwMywyNSArMTE4MiwyOCBAQAogCiB2b2lkIHAycF9zdG9wX2ZpbmQoc3RydWN0IHAycF9kYXRhICpwMnApCiB7CisJcDJwLT5wZW5kaW5nX2xpc3Rlbl9mcmVxID0gMDsKIAlwMnBfc3RvcF9maW5kX2Zvcl9mcmVxKHAycCwgMCk7CiB9CiAKIAogc3RhdGljIGludCBwMnBfcHJlcGFyZV9jaGFubmVsX3ByZWYoc3RydWN0IHAycF9kYXRhICpwMnAsCiAJCQkJICAgIHVuc2lnbmVkIGludCBmb3JjZV9mcmVxLAotCQkJCSAgICB1bnNpZ25lZCBpbnQgcHJlZl9mcmVxKQorCQkJCSAgICB1bnNpZ25lZCBpbnQgcHJlZl9mcmVxLCBpbnQgZ28pCiB7CiAJdTggb3BfY2xhc3MsIG9wX2NoYW5uZWw7CiAJdW5zaWduZWQgaW50IGZyZXEgPSBmb3JjZV9mcmVxID8gZm9yY2VfZnJlcSA6IHByZWZfZnJlcTsKIAotCXAycF9kYmcocDJwLCAiUHJlcGFyZSBjaGFubmVsIHByZWYgLSBmb3JjZV9mcmVxPSV1IHByZWZfZnJlcT0ldSIsCi0JCWZvcmNlX2ZyZXEsIHByZWZfZnJlcSk7CisJcDJwX2RiZyhwMnAsICJQcmVwYXJlIGNoYW5uZWwgcHJlZiAtIGZvcmNlX2ZyZXE9JXUgcHJlZl9mcmVxPSV1IGdvPSVkIiwKKwkJZm9yY2VfZnJlcSwgcHJlZl9mcmVxLCBnbyk7CiAJaWYgKHAycF9mcmVxX3RvX2NoYW5uZWwoZnJlcSwgJm9wX2NsYXNzLCAmb3BfY2hhbm5lbCkgPCAwKSB7CiAJCXAycF9kYmcocDJwLCAiVW5zdXBwb3J0ZWQgZnJlcXVlbmN5ICV1IE1IeiIsIGZyZXEpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKCFwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJnAycC0+Y2ZnLT5jaGFubmVscywgb3BfY2xhc3MsIG9wX2NoYW5uZWwpKSB7CisJaWYgKCFwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJnAycC0+Y2ZnLT5jaGFubmVscywgb3BfY2xhc3MsIG9wX2NoYW5uZWwpICYmCisJICAgIChnbyB8fCAhcDJwX2NoYW5uZWxzX2luY2x1ZGVzKCZwMnAtPmNmZy0+Y2xpX2NoYW5uZWxzLCBvcF9jbGFzcywKKwkJCQkJICBvcF9jaGFubmVsKSkpIHsKIAkJcDJwX2RiZyhwMnAsICJGcmVxdWVuY3kgJXUgTUh6IChvcGVyX2NsYXNzICV1IGNoYW5uZWwgJXUpIG5vdCBhbGxvd2VkIGZvciBQMlAiLAogCQkJZnJlcSwgb3BfY2xhc3MsIG9wX2NoYW5uZWwpOwogCQlyZXR1cm4gLTE7CkBAIC0xMjQ3LDYgKzEyMjksOSBAQAogc3RhdGljIHZvaWQgcDJwX3ByZXBhcmVfY2hhbm5lbF9iZXN0KHN0cnVjdCBwMnBfZGF0YSAqcDJwKQogewogCXU4IG9wX2NsYXNzLCBvcF9jaGFubmVsOworCWNvbnN0IGludCBvcF9jbGFzc2VzXzVnaHpbXSA9IHsgMTI0LCAxMTUsIDAgfTsKKwljb25zdCBpbnQgb3BfY2xhc3Nlc19odDQwW10gPSB7IDEyNiwgMTI3LCAxMTYsIDExNywgMCB9OworCWNvbnN0IGludCBvcF9jbGFzc2VzX3ZodFtdID0geyAxMjgsIDAgfTsKIAogCXAycF9kYmcocDJwLCAiUHJlcGFyZSBjaGFubmVsIGJlc3QiKTsKIApAQCAtMTI3OCwxMCArMTI2Myw0MCBAQAogCQlwMnBfZGJnKHAycCwgIlNlbGVjdCBmaXJzdCBwcmVmX2NoYW4gZW50cnkgYXMgb3BlcmF0aW5nIGNoYW5uZWwgcHJlZmVyZW5jZSIpOwogCQlwMnAtPm9wX3JlZ19jbGFzcyA9IHAycC0+Y2ZnLT5wcmVmX2NoYW5bMF0ub3BfY2xhc3M7CiAJCXAycC0+b3BfY2hhbm5lbCA9IHAycC0+Y2ZnLT5wcmVmX2NoYW5bMF0uY2hhbjsKLQl9IGVsc2UgeworCX0gZWxzZSBpZiAocDJwX2NoYW5uZWxfc2VsZWN0KCZwMnAtPmNmZy0+Y2hhbm5lbHMsIG9wX2NsYXNzZXNfdmh0LAorCQkJCSAgICAgICZwMnAtPm9wX3JlZ19jbGFzcywgJnAycC0+b3BfY2hhbm5lbCkgPT0KKwkJICAgMCkgeworCQlwMnBfZGJnKHAycCwgIlNlbGVjdCBwb3NzaWJsZSBWSFQgY2hhbm5lbCAob3BfY2xhc3MgJXUgY2hhbm5lbCAldSkgYXMgb3BlcmF0aW5nIGNoYW5uZWwgcHJlZmVyZW5jZSIsCisJCQlwMnAtPm9wX3JlZ19jbGFzcywgcDJwLT5vcF9jaGFubmVsKTsKKwl9IGVsc2UgaWYgKHAycF9jaGFubmVsX3NlbGVjdCgmcDJwLT5jZmctPmNoYW5uZWxzLCBvcF9jbGFzc2VzX2h0NDAsCisJCQkJICAgICAgJnAycC0+b3BfcmVnX2NsYXNzLCAmcDJwLT5vcF9jaGFubmVsKSA9PQorCQkgICAwKSB7CisJCXAycF9kYmcocDJwLCAiU2VsZWN0IHBvc3NpYmxlIEhUNDAgY2hhbm5lbCAob3BfY2xhc3MgJXUgY2hhbm5lbCAldSkgYXMgb3BlcmF0aW5nIGNoYW5uZWwgcHJlZmVyZW5jZSIsCisJCQlwMnAtPm9wX3JlZ19jbGFzcywgcDJwLT5vcF9jaGFubmVsKTsKKwl9IGVsc2UgaWYgKHAycF9jaGFubmVsX3NlbGVjdCgmcDJwLT5jZmctPmNoYW5uZWxzLCBvcF9jbGFzc2VzXzVnaHosCisJCQkJICAgICAgJnAycC0+b3BfcmVnX2NsYXNzLCAmcDJwLT5vcF9jaGFubmVsKSA9PQorCQkgICAwKSB7CisJCXAycF9kYmcocDJwLCAiU2VsZWN0IHBvc3NpYmxlIDUgR0h6IGNoYW5uZWwgKG9wX2NsYXNzICV1IGNoYW5uZWwgJXUpIGFzIG9wZXJhdGluZyBjaGFubmVsIHByZWZlcmVuY2UiLAorCQkJcDJwLT5vcF9yZWdfY2xhc3MsIHAycC0+b3BfY2hhbm5lbCk7CisJfSBlbHNlIGlmIChwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJnAycC0+Y2ZnLT5jaGFubmVscywKKwkJCQkJIHAycC0+Y2ZnLT5vcF9yZWdfY2xhc3MsCisJCQkJCSBwMnAtPmNmZy0+b3BfY2hhbm5lbCkpIHsKIAkJcDJwX2RiZyhwMnAsICJTZWxlY3QgcHJlLWNvbmZpZ3VyZWQgY2hhbm5lbCBhcyBvcGVyYXRpbmcgY2hhbm5lbCBwcmVmZXJlbmNlIik7CiAJCXAycC0+b3BfcmVnX2NsYXNzID0gcDJwLT5jZmctPm9wX3JlZ19jbGFzczsKIAkJcDJwLT5vcF9jaGFubmVsID0gcDJwLT5jZmctPm9wX2NoYW5uZWw7CisJfSBlbHNlIGlmIChwMnBfY2hhbm5lbF9yYW5kb21fc29jaWFsKCZwMnAtPmNmZy0+Y2hhbm5lbHMsCisJCQkJCSAgICAgJnAycC0+b3BfcmVnX2NsYXNzLAorCQkJCQkgICAgICZwMnAtPm9wX2NoYW5uZWwpID09IDApIHsKKwkJcDJwX2RiZyhwMnAsICJTZWxlY3QgcmFuZG9tIGF2YWlsYWJsZSBzb2NpYWwgY2hhbm5lbCAlZCBmcm9tIDIuNCBHSHogYmFuZCBhcyBvcGVyYXRpbmcgY2hhbm5lbCBwcmVmZXJlbmNlIiwKKwkJCXAycC0+b3BfY2hhbm5lbCk7CisJfSBlbHNlIHsKKwkJLyogU2VsZWN0IGFueSByYW5kb20gYXZhaWxhYmxlIGNoYW5uZWwgZnJvbSB0aGUgZmlyc3QgYXZhaWxhYmxlCisJCSAqIG9wZXJhdGluZyBjbGFzcyAqLworCQlwMnBfY2hhbm5lbF9zZWxlY3QoJnAycC0+Y2ZnLT5jaGFubmVscywgTlVMTCwKKwkJCQkgICAmcDJwLT5vcF9yZWdfY2xhc3MsCisJCQkJICAgJnAycC0+b3BfY2hhbm5lbCk7CisJCXAycF9kYmcocDJwLCAiU2VsZWN0IHJhbmRvbSBhdmFpbGFibGUgY2hhbm5lbCAlZCBmcm9tIG9wZXJhdGluZyBjbGFzcyAlZCBhcyBvcGVyYXRpbmcgY2hhbm5lbCBwcmVmZXJlbmNlIiwKKwkJCXAycC0+b3BfY2hhbm5lbCwgcDJwLT5vcF9yZWdfY2xhc3MpOwogCX0KIAogCW9zX21lbWNweSgmcDJwLT5jaGFubmVscywgJnAycC0+Y2ZnLT5jaGFubmVscywKQEAgLTEyOTUsNiArMTMxMCw3IEBACiAgKiBAZGV2OiBTZWxlY3RlZCBwZWVyIGRldmljZQogICogQGZvcmNlX2ZyZXE6IEZvcmNlZCBmcmVxdWVuY3kgaW4gTUh6IG9yIDAgaWYgbm90IGZvcmNlZAogICogQHByZWZfZnJlcTogUHJlZmVycmVkIGZyZXF1ZW5jeSBpbiBNSHogb3IgMCBpZiBubyBwcmVmZXJlbmNlCisgKiBAZ286IFdoZXRoZXIgdGhlIGxvY2FsIGVuZCB3aWxsIGJlIGZvcmNlZCB0byBiZSBHTwogICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlIChjaGFubmVsIG5vdCBzdXBwb3J0ZWQgZm9yIFAyUCkKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gZG8gaW5pdGlhbCBvcGVyYXRpbmcgY2hhbm5lbCBzZWxlY3Rpb24gZm9yIEdPCkBAIC0xMzAzLDE2ICsxMzE5LDI1IEBACiAgKiBpcyBhdmFpbGFibGUuCiAgKi8KIGludCBwMnBfcHJlcGFyZV9jaGFubmVsKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBzdHJ1Y3QgcDJwX2RldmljZSAqZGV2LAotCQkJdW5zaWduZWQgaW50IGZvcmNlX2ZyZXEsIHVuc2lnbmVkIGludCBwcmVmX2ZyZXEpCisJCQl1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgdW5zaWduZWQgaW50IHByZWZfZnJlcSwgaW50IGdvKQogewotCXAycF9kYmcocDJwLCAiUHJlcGFyZSBjaGFubmVsIC0gZm9yY2VfZnJlcT0ldSBwcmVmX2ZyZXE9JXUiLAotCQlmb3JjZV9mcmVxLCBwcmVmX2ZyZXEpOworCXAycF9kYmcocDJwLCAiUHJlcGFyZSBjaGFubmVsIC0gZm9yY2VfZnJlcT0ldSBwcmVmX2ZyZXE9JXUgZ289JWQiLAorCQlmb3JjZV9mcmVxLCBwcmVmX2ZyZXEsIGdvKTsKIAlpZiAoZm9yY2VfZnJlcSB8fCBwcmVmX2ZyZXEpIHsKLQkJaWYgKHAycF9wcmVwYXJlX2NoYW5uZWxfcHJlZihwMnAsIGZvcmNlX2ZyZXEsIHByZWZfZnJlcSkgPCAwKQorCQlpZiAocDJwX3ByZXBhcmVfY2hhbm5lbF9wcmVmKHAycCwgZm9yY2VfZnJlcSwgcHJlZl9mcmVxLCBnbykgPAorCQkgICAgMCkKIAkJCXJldHVybiAtMTsKIAl9IGVsc2UgewogCQlwMnBfcHJlcGFyZV9jaGFubmVsX2Jlc3QocDJwKTsKIAl9CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAicHJlcGFyZWQgY2hhbm5lbHMiLCAmcDJwLT5jaGFubmVscyk7CisJaWYgKGdvKQorCQlwMnBfY2hhbm5lbHNfcmVtb3ZlX2ZyZXFzKCZwMnAtPmNoYW5uZWxzLCAmcDJwLT5ub19nb19mcmVxKTsKKwllbHNlIGlmICghZm9yY2VfZnJlcSkKKwkJcDJwX2NoYW5uZWxzX3VuaW9uKCZwMnAtPmNoYW5uZWxzLCAmcDJwLT5jZmctPmNsaV9jaGFubmVscywKKwkJCQkgICAmcDJwLT5jaGFubmVscyk7CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAiYWZ0ZXIgZ28vY2xpIGZpbHRlci9hZGQiLCAmcDJwLT5jaGFubmVscyk7CisKIAlwMnBfZGJnKHAycCwgIk93biBwcmVmZXJlbmNlIGZvciBvcGVyYXRpb24gY2hhbm5lbDogT3BlcmF0aW5nIENsYXNzICV1IENoYW5uZWwgJXUlcyIsCiAJCXAycC0+b3BfcmVnX2NsYXNzLCBwMnAtPm9wX2NoYW5uZWwsCiAJCWZvcmNlX2ZyZXEgPyAiIChmb3JjZWQpIiA6ICIiKTsKQEAgLTEzNTEsMTUgKzEzNzYsMTYgQEAKIAkJaW50IGdvX2ludGVudCwgY29uc3QgdTggKm93bl9pbnRlcmZhY2VfYWRkciwKIAkJdW5zaWduZWQgaW50IGZvcmNlX2ZyZXEsIGludCBwZXJzaXN0ZW50X2dyb3VwLAogCQljb25zdCB1OCAqZm9yY2Vfc3NpZCwgc2l6ZV90IGZvcmNlX3NzaWRfbGVuLAotCQlpbnQgcGRfYmVmb3JlX2dvX25lZywgdW5zaWduZWQgaW50IHByZWZfZnJlcSkKKwkJaW50IHBkX2JlZm9yZV9nb19uZWcsIHVuc2lnbmVkIGludCBwcmVmX2ZyZXEsIHUxNiBvb2JfcHdfaWQpCiB7CiAJc3RydWN0IHAycF9kZXZpY2UgKmRldjsKIAogCXAycF9kYmcocDJwLCAiUmVxdWVzdCB0byBzdGFydCBncm91cCBuZWdvdGlhdGlvbiAtIHBlZXI9IiBNQUNTVFIKIAkJIiAgR08gSW50ZW50PSVkICBJbnRlbmRlZCBJbnRlcmZhY2UgQWRkcmVzcz0iIE1BQ1NUUgotCQkiIHdwc19tZXRob2Q9JWQgcGVyc2lzdGVudF9ncm91cD0lZCBwZF9iZWZvcmVfZ29fbmVnPSVkIiwKKwkJIiB3cHNfbWV0aG9kPSVkIHBlcnNpc3RlbnRfZ3JvdXA9JWQgcGRfYmVmb3JlX2dvX25lZz0lZCAiCisJCSJvb2JfcHdfaWQ9JXUiLAogCQlNQUMyU1RSKHBlZXJfYWRkciksIGdvX2ludGVudCwgTUFDMlNUUihvd25faW50ZXJmYWNlX2FkZHIpLAotCQl3cHNfbWV0aG9kLCBwZXJzaXN0ZW50X2dyb3VwLCBwZF9iZWZvcmVfZ29fbmVnKTsKKwkJd3BzX21ldGhvZCwgcGVyc2lzdGVudF9ncm91cCwgcGRfYmVmb3JlX2dvX25lZywgb29iX3B3X2lkKTsKIAogCWRldiA9IHAycF9nZXRfZGV2aWNlKHAycCwgcGVlcl9hZGRyKTsKIAlpZiAoZGV2ID09IE5VTEwgfHwgKGRldi0+ZmxhZ3MgJiBQMlBfREVWX1BST0JFX1JFUV9PTkxZKSkgewpAQCAtMTM2OCw3ICsxMzk0LDggQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmIChwMnBfcHJlcGFyZV9jaGFubmVsKHAycCwgZGV2LCBmb3JjZV9mcmVxLCBwcmVmX2ZyZXEpIDwgMCkKKwlpZiAocDJwX3ByZXBhcmVfY2hhbm5lbChwMnAsIGRldiwgZm9yY2VfZnJlcSwgcHJlZl9mcmVxLAorCQkJCWdvX2ludGVudCA9PSAxNSkgPCAwKQogCQlyZXR1cm4gLTE7CiAKIAlpZiAoZGV2LT5mbGFncyAmIFAyUF9ERVZfR1JPVVBfQ0xJRU5UX09OTFkpIHsKQEAgLTE0NDIsNiArMTQ2OSw3IEBACiAJfQogCiAJZGV2LT53cHNfbWV0aG9kID0gd3BzX21ldGhvZDsKKwlkZXYtPm9vYl9wd19pZCA9IG9vYl9wd19pZDsKIAlkZXYtPnN0YXR1cyA9IFAyUF9TQ19TVUNDRVNTOwogCiAJaWYgKHAycC0+cDJwX3NjYW5fcnVubmluZykgewpAQCAtMTQ2MSwxNSArMTQ4OSwxNSBAQAogCQkgIGludCBnb19pbnRlbnQsIGNvbnN0IHU4ICpvd25faW50ZXJmYWNlX2FkZHIsCiAJCSAgdW5zaWduZWQgaW50IGZvcmNlX2ZyZXEsIGludCBwZXJzaXN0ZW50X2dyb3VwLAogCQkgIGNvbnN0IHU4ICpmb3JjZV9zc2lkLCBzaXplX3QgZm9yY2Vfc3NpZF9sZW4sCi0JCSAgdW5zaWduZWQgaW50IHByZWZfZnJlcSkKKwkJICB1bnNpZ25lZCBpbnQgcHJlZl9mcmVxLCB1MTYgb29iX3B3X2lkKQogewogCXN0cnVjdCBwMnBfZGV2aWNlICpkZXY7CiAKIAlwMnBfZGJnKHAycCwgIlJlcXVlc3QgdG8gYXV0aG9yaXplIGdyb3VwIG5lZ290aWF0aW9uIC0gcGVlcj0iIE1BQ1NUUgogCQkiICBHTyBJbnRlbnQ9JWQgIEludGVuZGVkIEludGVyZmFjZSBBZGRyZXNzPSIgTUFDU1RSCi0JCSIgd3BzX21ldGhvZD0lZCAgcGVyc2lzdGVudF9ncm91cD0lZCIsCisJCSIgd3BzX21ldGhvZD0lZCAgcGVyc2lzdGVudF9ncm91cD0lZCBvb2JfcHdfaWQ9JXUiLAogCQlNQUMyU1RSKHBlZXJfYWRkciksIGdvX2ludGVudCwgTUFDMlNUUihvd25faW50ZXJmYWNlX2FkZHIpLAotCQl3cHNfbWV0aG9kLCBwZXJzaXN0ZW50X2dyb3VwKTsKKwkJd3BzX21ldGhvZCwgcGVyc2lzdGVudF9ncm91cCwgb29iX3B3X2lkKTsKIAogCWRldiA9IHAycF9nZXRfZGV2aWNlKHAycCwgcGVlcl9hZGRyKTsKIAlpZiAoZGV2ID09IE5VTEwpIHsKQEAgLTE0NzgsNyArMTUwNiw4IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQlpZiAocDJwX3ByZXBhcmVfY2hhbm5lbChwMnAsIGRldiwgZm9yY2VfZnJlcSwgcHJlZl9mcmVxKSA8IDApCisJaWYgKHAycF9wcmVwYXJlX2NoYW5uZWwocDJwLCBkZXYsIGZvcmNlX2ZyZXEsIHByZWZfZnJlcSwgZ29faW50ZW50ID09CisJCQkJMTUpIDwgMCkKIAkJcmV0dXJuIC0xOwogCiAJcDJwLT5zc2lkX3NldCA9IDA7CkBAIC0xNDk5LDYgKzE1MjgsNyBAQAogCW9zX21lbWNweShwMnAtPmludGVuZGVkX2FkZHIsIG93bl9pbnRlcmZhY2VfYWRkciwgRVRIX0FMRU4pOwogCiAJZGV2LT53cHNfbWV0aG9kID0gd3BzX21ldGhvZDsKKwlkZXYtPm9vYl9wd19pZCA9IG9vYl9wd19pZDsKIAlkZXYtPnN0YXR1cyA9IFAyUF9TQ19TVUNDRVNTOwogCiAJcmV0dXJuIDA7CkBAIC0xNTA4LDcgKzE1MzgsNyBAQAogdm9pZCBwMnBfYWRkX2Rldl9pbmZvKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqYWRkciwKIAkJICAgICAgc3RydWN0IHAycF9kZXZpY2UgKmRldiwgc3RydWN0IHAycF9tZXNzYWdlICptc2cpCiB7Ci0Jb3NfZ2V0X3RpbWUoJmRldi0+bGFzdF9zZWVuKTsKKwlvc19nZXRfcmVsdGltZSgmZGV2LT5sYXN0X3NlZW4pOwogCiAJcDJwX2NvcHlfd3BzX2luZm8ocDJwLCBkZXYsIDAsIG1zZyk7CiAKQEAgLTE1NzYsNyArMTYwNiw3IEBACiBpbnQgcDJwX2dvX3BhcmFtcyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHAycF9nb19uZWdfcmVzdWx0cyAqcGFyYW1zKQogewogCXAycF9idWlsZF9zc2lkKHAycCwgcGFyYW1zLT5zc2lkLCAmcGFyYW1zLT5zc2lkX2xlbik7Ci0JcDJwX3JhbmRvbShwYXJhbXMtPnBhc3NwaHJhc2UsIDgpOworCXAycF9yYW5kb20ocGFyYW1zLT5wYXNzcGhyYXNlLCBwMnAtPmNmZy0+cGFzc3BocmFzZV9sZW4pOwogCXJldHVybiAwOwogfQogCkBAIC0xNjEwLDcgKzE2NDAsNyBAQAogCQkJCQkgICAgICAgcDJwLT5vcF9jaGFubmVsKTsKIAkJb3NfbWVtY3B5KHJlcy5zc2lkLCBwMnAtPnNzaWQsIHAycC0+c3NpZF9sZW4pOwogCQlyZXMuc3NpZF9sZW4gPSBwMnAtPnNzaWRfbGVuOwotCQlwMnBfcmFuZG9tKHJlcy5wYXNzcGhyYXNlLCA4KTsKKwkJcDJwX3JhbmRvbShyZXMucGFzc3BocmFzZSwgcDJwLT5jZmctPnBhc3NwaHJhc2VfbGVuKTsKIAl9IGVsc2UgewogCQlyZXMuZnJlcSA9IHBlZXItPm9wZXJfZnJlcTsKIAkJaWYgKHAycC0+c3NpZF9sZW4pIHsKQEAgLTE2MTksOCArMTY0OSwxNSBAQAogCQl9CiAJfQogCisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAib3duIGNoYW5uZWxzIiwgJnAycC0+Y2hhbm5lbHMpOworCXAycF9jaGFubmVsc19kdW1wKHAycCwgInBlZXIgY2hhbm5lbHMiLCAmcGVlci0+Y2hhbm5lbHMpOwogCXAycF9jaGFubmVsc19pbnRlcnNlY3QoJnAycC0+Y2hhbm5lbHMsICZwZWVyLT5jaGFubmVscywKIAkJCSAgICAgICAmaW50ZXJzZWN0aW9uKTsKKwlpZiAoZ28pIHsKKwkJcDJwX2NoYW5uZWxzX3JlbW92ZV9mcmVxcygmaW50ZXJzZWN0aW9uLCAmcDJwLT5ub19nb19mcmVxKTsKKwkJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAiaW50ZXJzZWN0aW9uIGFmdGVyIG5vLUdPIHJlbW92YWwiLAorCQkJCSAgJmludGVyc2VjdGlvbik7CisJfQogCWZyZXFzID0gMDsKIAlmb3IgKGkgPSAwOyBpIDwgaW50ZXJzZWN0aW9uLnJlZ19jbGFzc2VzOyBpKyspIHsKIAkJc3RydWN0IHAycF9yZWdfY2xhc3MgKmMgPSAmaW50ZXJzZWN0aW9uLnJlZ19jbGFzc1tpXTsKQEAgLTE2NDMsNiArMTY4MCw5IEBACiAJcDJwLT5zc2lkX3NldCA9IDA7CiAJcGVlci0+Z29fbmVnX3JlcV9zZW50ID0gMDsKIAlwZWVyLT53cHNfbWV0aG9kID0gV1BTX05PVF9SRUFEWTsKKwlwZWVyLT5vb2JfcHdfaWQgPSAwOworCXdwYWJ1Zl9mcmVlKHBlZXItPmdvX25lZ19jb25mKTsKKwlwZWVyLT5nb19uZWdfY29uZiA9IE5VTEw7CiAKIAlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX1BST1ZJU0lPTklORyk7CiAJcDJwLT5jZmctPmdvX25lZ19jb21wbGV0ZWQocDJwLT5jZmctPmNiX2N0eCwgJnJlcyk7CkBAIC0xNjczLDYgKzE3MTMsNyBAQAogCQkJCQkgICByeF9mcmVxKTsKIAkJYnJlYWs7CiAJY2FzZSBQMlBfSU5WSVRBVElPTl9SRVNQOgorCQlwMnAtPmNmZy0+c2VuZF9hY3Rpb25fZG9uZShwMnAtPmNmZy0+Y2JfY3R4KTsKIAkJcDJwX3Byb2Nlc3NfaW52aXRhdGlvbl9yZXNwKHAycCwgc2EsIGRhdGEgKyAxLCBsZW4gLSAxKTsKIAkJYnJlYWs7CiAJY2FzZSBQMlBfUFJPVl9ESVNDX1JFUToKQEAgLTE3MDYsMjAgKzE3NDcsMTUgQEAKIAljYXNlIFdMQU5fUEFfVkVORE9SX1NQRUNJRklDOgogCQlkYXRhKys7CiAJCWxlbi0tOwotCQlpZiAobGVuIDwgMykKKwkJaWYgKGxlbiA8IDQpCiAJCQlyZXR1cm47Ci0JCWlmIChXUEFfR0VUX0JFMjQoZGF0YSkgIT0gT1VJX1dGQSkKKwkJaWYgKFdQQV9HRVRfQkUzMihkYXRhKSAhPSBQMlBfSUVfVkVORE9SX1RZUEUpCiAJCQlyZXR1cm47CiAKLQkJZGF0YSArPSAzOwotCQlsZW4gLT0gMzsKLQkJaWYgKGxlbiA8IDEpCi0JCQlyZXR1cm47CisJCWRhdGEgKz0gNDsKKwkJbGVuIC09IDQ7CiAKLQkJaWYgKCpkYXRhICE9IFAyUF9PVUlfVFlQRSkKLQkJCXJldHVybjsKLQotCQlwMnBfcnhfcDJwX2FjdGlvbihwMnAsIHNhLCBkYXRhICsgMSwgbGVuIC0gMSwgZnJlcSk7CisJCXAycF9yeF9wMnBfYWN0aW9uKHAycCwgc2EsIGRhdGEsIGxlbiwgZnJlcSk7CiAJCWJyZWFrOwogCWNhc2UgV0xBTl9QQV9HQVNfSU5JVElBTF9SRVE6CiAJCXAycF9yeF9nYXNfaW5pdGlhbF9yZXEocDJwLCBzYSwgZGF0YSArIDEsIGxlbiAtIDEsIGZyZXEpOwpAQCAtMTc1MiwxNSArMTc4OCwxMCBAQAogCWlmIChsZW4gPCA0KQogCQlyZXR1cm47CiAKLQlpZiAoV1BBX0dFVF9CRTI0KGRhdGEpICE9IE9VSV9XRkEpCisJaWYgKFdQQV9HRVRfQkUzMihkYXRhKSAhPSBQMlBfSUVfVkVORE9SX1RZUEUpCiAJCXJldHVybjsKLQlkYXRhICs9IDM7Ci0JbGVuIC09IDM7Ci0KLQlpZiAoKmRhdGEgIT0gUDJQX09VSV9UWVBFKQotCQlyZXR1cm47Ci0JZGF0YSsrOwotCWxlbi0tOworCWRhdGEgKz0gNDsKKwlsZW4gLT0gNDsKIAogCS8qIFAyUCBhY3Rpb24gZnJhbWUgKi8KIAlwMnBfZGJnKHAycCwgIlJYIFAyUCBBY3Rpb24gZnJvbSAiIE1BQ1NUUiwgTUFDMlNUUihzYSkpOwpAQCAtMTgwNiw3ICsxODM3LDggQEAKIAlpZiAocDJwLT5pbnZpdGVfcGVlciA9PSBOVUxMKQogCQlyZXR1cm47CiAJcDJwLT5jZmctPnN0b3BfbGlzdGVuKHAycC0+Y2ZnLT5jYl9jdHgpOwotCXAycF9pbnZpdGVfc2VuZChwMnAsIHAycC0+aW52aXRlX3BlZXIsIHAycC0+aW52aXRlX2dvX2Rldl9hZGRyKTsKKwlwMnBfaW52aXRlX3NlbmQocDJwLCBwMnAtPmludml0ZV9wZWVyLCBwMnAtPmludml0ZV9nb19kZXZfYWRkciwKKwkJCXAycC0+aW52aXRlX2Rldl9wd19pZCk7CiB9CiAKIApAQCAtMTgzOSw3ICsxODcxLDcgQEAKIAlpZiAoZGV2KSB7CiAJCWlmIChkZXYtPmNvdW50cnlbMF0gPT0gMCAmJiBtc2cubGlzdGVuX2NoYW5uZWwpCiAJCQlvc19tZW1jcHkoZGV2LT5jb3VudHJ5LCBtc2cubGlzdGVuX2NoYW5uZWwsIDMpOwotCQlvc19nZXRfdGltZSgmZGV2LT5sYXN0X3NlZW4pOworCQlvc19nZXRfcmVsdGltZSgmZGV2LT5sYXN0X3NlZW4pOwogCQlwMnBfcGFyc2VfZnJlZSgmbXNnKTsKIAkJcmV0dXJuOyAvKiBhbHJlYWR5IGtub3duICovCiAJfQpAQCAtMTg1MCw3ICsxODgyLDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCW9zX2dldF90aW1lKCZkZXYtPmxhc3Rfc2Vlbik7CisJb3NfZ2V0X3JlbHRpbWUoJmRldi0+bGFzdF9zZWVuKTsKIAlkZXYtPmZsYWdzIHw9IFAyUF9ERVZfUFJPQkVfUkVRX09OTFk7CiAKIAlpZiAobXNnLmxpc3Rlbl9jaGFubmVsKSB7CkBAIC0xODg0LDcgKzE5MTYsNyBAQAogCiAJZGV2ID0gcDJwX2dldF9kZXZpY2UocDJwLCBhZGRyKTsKIAlpZiAoZGV2KSB7Ci0JCW9zX2dldF90aW1lKCZkZXYtPmxhc3Rfc2Vlbik7CisJCW9zX2dldF9yZWx0aW1lKCZkZXYtPmxhc3Rfc2Vlbik7CiAJCXJldHVybiBkZXY7IC8qIGFscmVhZHkga25vd24gKi8KIAl9CiAKQEAgLTE5NzAsNiArMjAwMiw5IEBACiAJCWV4dHJhID0gd3BhYnVmX2xlbihwMnAtPndmZF9pZV9wcm9iZV9yZXNwKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAKKwlpZiAocDJwLT52ZW5kb3JfZWxlbSAmJiBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1BST0JFX1JFU1BfUDJQXSkKKwkJZXh0cmEgKz0gd3BhYnVmX2xlbihwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1BST0JFX1JFU1BfUDJQXSk7CisKIAlidWYgPSB3cGFidWZfYWxsb2MoMTAwMCArIGV4dHJhKTsKIAlpZiAoYnVmID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwpAQCAtMTk3OSwxMyArMjAxNCwyMSBAQAogCQlwd19pZCA9IHAycF93cHNfbWV0aG9kX3B3X2lkKHAycC0+Z29fbmVnX3BlZXItPndwc19tZXRob2QpOwogCX0KIAotCXAycF9idWlsZF93cHNfaWUocDJwLCBidWYsIHB3X2lkLCAxKTsKKwlpZiAocDJwX2J1aWxkX3dwc19pZShwMnAsIGJ1ZiwgcHdfaWQsIDEpIDwgMCkgeworCQlwMnBfZGJnKHAycCwgIkZhaWxlZCB0byBidWlsZCBXUFMgSUUgZm9yIFByb2JlIFJlc3BvbnNlIik7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CisJCXJldHVybiBOVUxMOworCX0KIAogI2lmZGVmIENPTkZJR19XSUZJX0RJU1BMQVkKIAlpZiAocDJwLT53ZmRfaWVfcHJvYmVfcmVzcCkKIAkJd3BhYnVmX3B1dF9idWYoYnVmLCBwMnAtPndmZF9pZV9wcm9iZV9yZXNwKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAKKwlpZiAocDJwLT52ZW5kb3JfZWxlbSAmJiBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1BST0JFX1JFU1BfUDJQXSkKKwkJd3BhYnVmX3B1dF9idWYoYnVmLAorCQkJICAgICAgIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUFJPQkVfUkVTUF9QMlBdKTsKKwogCS8qIFAyUCBJRSAqLwogCWxlbiA9IHAycF9idWZfYWRkX2llX2hkcihidWYpOwogCXAycF9idWZfYWRkX2NhcGFiaWxpdHkoYnVmLCBwMnAtPmRldl9jYXBhYiAmCkBAIC0yMDEyLDE3ICsyMDU1LDIxIEBACiAKIAlpZiAoIXAycC0+aW5fbGlzdGVuIHx8ICFwMnAtPmRydl9pbl9saXN0ZW4pIHsKIAkJLyogbm90IGluIExpc3RlbiBzdGF0ZSAtIGlnbm9yZSBQcm9iZSBSZXF1ZXN0ICovCisJCXAycF9kYmcocDJwLCAiTm90IGluIExpc3RlbiBzdGF0ZSAoaW5fbGlzdGVuPSVkIGRydl9pbl9saXN0ZW49JWQpIC0gaWdub3JlIFByb2JlIFJlcXVlc3QiLAorCQkJcDJwLT5pbl9saXN0ZW4sIHAycC0+ZHJ2X2luX2xpc3Rlbik7CiAJCXJldHVybiBQMlBfUFJFUV9OT1RfTElTVEVOOwogCX0KIAogCWlmIChpZWVlODAyXzExX3BhcnNlX2VsZW1zKCh1OCAqKSBpZSwgaWVfbGVuLCAmZWxlbXMsIDApID09CiAJICAgIFBhcnNlRmFpbGVkKSB7CiAJCS8qIElnbm9yZSBpbnZhbGlkIFByb2JlIFJlcXVlc3QgZnJhbWVzICovCisJCXAycF9kYmcocDJwLCAiQ291bGQgbm90IHBhcnNlIFByb2JlIFJlcXVlc3QgZnJhbWUgLSBpZ25vcmUgaXQiKTsKIAkJcmV0dXJuIFAyUF9QUkVRX01BTEZPUk1FRDsKIAl9CiAKIAlpZiAoZWxlbXMucDJwID09IE5VTEwpIHsKIAkJLyogbm90IGEgUDJQIHByb2JlIC0gaWdub3JlIGl0ICovCisJCXAycF9kYmcocDJwLCAiTm90IGEgUDJQIHByb2JlIC0gaWdub3JlIGl0Iik7CiAJCXJldHVybiBQMlBfUFJFUV9OT1RfUDJQOwogCX0KIApAQCAtMjAzMCwxMSArMjA3NywxNSBAQAogCSAgICBvc19tZW1jbXAoZHN0LCBwMnAtPmNmZy0+ZGV2X2FkZHIsIEVUSF9BTEVOKSAhPSAwKSB7CiAJCS8qIE5vdCBzZW50IHRvIHRoZSBicm9hZGNhc3QgYWRkcmVzcyBvciBvdXIgUDJQIERldmljZSBBZGRyZXNzCiAJCSAqLworCQlwMnBfZGJnKHAycCwgIlByb2JlIFJlcSBEQSAiIE1BQ1NUUiAiIG5vdCBvdXJzIC0gaWdub3JlIGl0IiwKKwkJCU1BQzJTVFIoZHN0KSk7CiAJCXJldHVybiBQMlBfUFJFUV9OT1RfUFJPQ0VTU0VEOwogCX0KIAogCWlmIChic3NpZCAmJiAhaXNfYnJvYWRjYXN0X2V0aGVyX2FkZHIoYnNzaWQpKSB7CiAJCS8qIE5vdCBzZW50IHRvIHRoZSBXaWxkY2FyZCBCU1NJRCAqLworCQlwMnBfZGJnKHAycCwgIlByb2JlIFJlcSBCU1NJRCAiIE1BQ1NUUiAiIG5vdCB3aWxkY2FyZCAtIGlnbm9yZSBpdCIsCisJCQlNQUMyU1RSKGJzc2lkKSk7CiAJCXJldHVybiBQMlBfUFJFUV9OT1RfUFJPQ0VTU0VEOwogCX0KIApAQCAtMjA0MiwyMyArMjA5MywyOCBAQAogCSAgICBvc19tZW1jbXAoZWxlbXMuc3NpZCwgUDJQX1dJTERDQVJEX1NTSUQsIFAyUF9XSUxEQ0FSRF9TU0lEX0xFTikgIT0KIAkgICAgMCkgewogCQkvKiBub3QgdXNpbmcgUDJQIFdpbGRjYXJkIFNTSUQgLSBpZ25vcmUgKi8KKwkJcDJwX2RiZyhwMnAsICJQcm9iZSBSZXEgbm90IHVzaW5nIFAyUCBXaWxkY2FyZCBTU0lEIC0gaWdub3JlIGl0Iik7CiAJCXJldHVybiBQMlBfUFJFUV9OT1RfUFJPQ0VTU0VEOwogCX0KIAogCWlmIChzdXBwX3JhdGVzXzExYl9vbmx5KCZlbGVtcykpIHsKIAkJLyogSW5kaWNhdGVzIHN1cHBvcnQgZm9yIDExYiByYXRlcyBvbmx5ICovCisJCXAycF9kYmcocDJwLCAiUHJvYmUgUmVxIHdpdGggMTFiIHJhdGVzIG9ubHkgc3VwcG9ydGVkIC0gaWdub3JlIGl0Iik7CiAJCXJldHVybiBQMlBfUFJFUV9OT1RfUDJQOwogCX0KIAogCW9zX21lbXNldCgmbXNnLCAwLCBzaXplb2YobXNnKSk7CiAJaWYgKHAycF9wYXJzZV9pZXMoaWUsIGllX2xlbiwgJm1zZykgPCAwKSB7CiAJCS8qIENvdWxkIG5vdCBwYXJzZSBQMlAgYXR0cmlidXRlcyAqLworCQlwMnBfZGJnKHAycCwgIkNvdWxkIG5vdCBwYXJzZSBQMlAgYXR0cmlidXRlcyBpbiBQcm9iZSBSZXEgLSBpZ25vcmUgaXQiKTsKIAkJcmV0dXJuIFAyUF9QUkVRX05PVF9QMlA7CiAJfQogCiAJaWYgKG1zZy5kZXZpY2VfaWQgJiYKIAkgICAgb3NfbWVtY21wKG1zZy5kZXZpY2VfaWQsIHAycC0+Y2ZnLT5kZXZfYWRkciwgRVRIX0FMRU4pICE9IDApIHsKIAkJLyogRGV2aWNlIElEIGRpZCBub3QgbWF0Y2ggKi8KKwkJcDJwX2RiZyhwMnAsICJQcm9iZSBSZXEgcmVxdWVzdGVkIERldmljZSBJRCAiIE1BQ1NUUiAiIGRpZCBub3QgbWF0Y2ggLSBpZ25vcmUgaXQiLAorCQkJTUFDMlNUUihtc2cuZGV2aWNlX2lkKSk7CiAJCXAycF9wYXJzZV9mcmVlKCZtc2cpOwogCQlyZXR1cm4gUDJQX1BSRVFfTk9UX1BST0NFU1NFRDsKIAl9CkBAIC0yMDY3LDYgKzIxMjMsNyBAQAogCWlmIChtc2cud3BzX2F0dHJpYnV0ZXMgJiYKIAkgICAgIXAycF9tYXRjaF9kZXZfdHlwZShwMnAsIG1zZy53cHNfYXR0cmlidXRlcykpIHsKIAkJLyogTm8gbWF0Y2ggd2l0aCBSZXF1ZXN0ZWQgRGV2aWNlIFR5cGUgKi8KKwkJcDJwX2RiZyhwMnAsICJQcm9iZSBSZXEgcmVxdWVzdHJlZCBEZXZpY2UgVHlwZSBkaWQgbm90IG1hdGNoIC0gaWdub3JlIGl0Iik7CiAJCXAycF9wYXJzZV9mcmVlKCZtc2cpOwogCQlyZXR1cm4gUDJQX1BSRVFfTk9UX1BST0NFU1NFRDsKIAl9CkBAIC0yMDc0LDYgKzIxMzEsNyBAQAogCiAJaWYgKCFwMnAtPmNmZy0+c2VuZF9wcm9iZV9yZXNwKSB7CiAJCS8qIFJlc3BvbnNlIGdlbmVyYXRlZCBlbHNld2hlcmUgKi8KKwkJcDJwX2RiZyhwMnAsICJQcm9iZSBSZXNwIGdlbmVyYXRlZCBlbHNld2hlcmUgLSBkbyBub3QgZ2VuZXJhdGUgYWRkaXRpb25hbCByZXNwb25zZSIpOwogCQlyZXR1cm4gUDJQX1BSRVFfTk9UX1BST0NFU1NFRDsKIAl9CiAKQEAgLTIxNjQsMTAgKzIyMjIsMTIgQEAKIAogCWlmICgocDJwLT5zdGF0ZSA9PSBQMlBfSU5WSVRFIHx8IHAycC0+c3RhdGUgPT0gUDJQX0lOVklURV9MSVNURU4pICYmCiAJICAgIHAycC0+aW52aXRlX3BlZXIgJiYKKwkgICAgKHAycC0+aW52aXRlX3BlZXItPmZsYWdzICYgUDJQX0RFVl9XQUlUX0lOVl9SRVFfQUNLKSAmJgogCSAgICBvc19tZW1jbXAoYWRkciwgcDJwLT5pbnZpdGVfcGVlci0+aW5mby5wMnBfZGV2aWNlX2FkZHIsIEVUSF9BTEVOKQogCSAgICA9PSAwKSB7CiAJCS8qIFJlY2VpdmVkIGEgUHJvYmUgUmVxdWVzdCBmcm9tIEludml0ZSBwZWVyICovCiAJCXAycF9kYmcocDJwLCAiRm91bmQgSW52aXRlIHBlZXIgLSB0cnkgdG8gc3RhcnQgSW52aXRlIGZyb20gdGltZW91dCIpOworCQllbG9vcF9jYW5jZWxfdGltZW91dChwMnBfaW52aXRlX3N0YXJ0LCBwMnAsIE5VTEwpOwogCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDAsIHAycF9pbnZpdGVfc3RhcnQsIHAycCwgTlVMTCk7CiAJCXJldHVybiBQMlBfUFJFUV9QUk9DRVNTRUQ7CiAJfQpAQCAtMjI0NCw2ICsyMzA0LDkgQEAKIAkJZXh0cmEgPSB3cGFidWZfbGVuKHAycC0+d2ZkX2llX2Fzc29jX3JlcSk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKHAycC0+dmVuZG9yX2VsZW0gJiYgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfQVNTT0NfUkVRXSkKKwkJZXh0cmEgKz0gd3BhYnVmX2xlbihwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1AyUF9BU1NPQ19SRVFdKTsKKwogCS8qCiAJICogKFJlKUFzc29jaWF0aW9uIFJlcXVlc3QgLSBQMlAgSUUKIAkgKiBQMlAgQ2FwYWJpbGl0eSBhdHRyaWJ1dGUgKHNoYWxsIGJlIHByZXNlbnQpCkBAIC0yMjU5LDYgKzIzMjIsMTAgQEAKIAkJd3BhYnVmX3B1dF9idWYodG1wLCBwMnAtPndmZF9pZV9hc3NvY19yZXEpOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChwMnAtPnZlbmRvcl9lbGVtICYmIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0FTU09DX1JFUV0pCisJCXdwYWJ1Zl9wdXRfYnVmKHRtcCwKKwkJCSAgICAgICBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1AyUF9BU1NPQ19SRVFdKTsKKwogCXBlZXIgPSBic3NpZCA/IHAycF9nZXRfZGV2aWNlKHAycCwgYnNzaWQpIDogTlVMTDsKIAogCWxwb3MgPSBwMnBfYnVmX2FkZF9pZV9oZHIodG1wKTsKQEAgLTIzODAsNyArMjQ0Nyw4IEBACiB7CiAJc3RydWN0IHAycF9kYXRhICpwMnA7CiAKLQlpZiAoY2ZnLT5tYXhfcGVlcnMgPCAxKQorCWlmIChjZmctPm1heF9wZWVycyA8IDEgfHwKKwkgICAgY2ZnLT5wYXNzcGhyYXNlX2xlbiA8IDggfHwgY2ZnLT5wYXNzcGhyYXNlX2xlbiA+IDYzKQogCQlyZXR1cm4gTlVMTDsKIAogCXAycCA9IG9zX3phbGxvYyhzaXplb2YoKnAycCkgKyBzaXplb2YoKmNmZykpOwpAQCAtMjQwOSwxNiArMjQ3Nyw3IEBACiAJCQlwMnAtPmNmZy0+bnVtX3ByZWZfY2hhbiA9IDA7CiAJfQogCi0jaWZkZWYgQU5EUk9JRF9QMlAKLQkvKiAxMDBtcyBsaXN0ZW4gdGltZSBpcyB0b28gbGVzcyB0byByZWNlaXZlIHRoZSByZXNwb25zZSBmcmFtZXMgaW4gc29tZSBzY2VuYXJpb3MKLQkgKiBpbmNyZWFzaW5nIG1pbiBsaXN0ZW4gdGltZSB0byAyMDBtcy4KLQkgKi8KLQlwMnAtPm1pbl9kaXNjX2ludCA9IDI7Ci0JLyogU0RfRkFJUl9QT0xJQ1k6IEluaXRpYWxpemluZyB0aGUgU0QgY3VycmVudCBzZXJ2aWNlZCBwb2ludGVyIHRvIE5VTEwgKi8KLQlwMnAtPnNkX2Rldl9saXN0ID0gTlVMTDsKLSNlbHNlCiAJcDJwLT5taW5fZGlzY19pbnQgPSAxOwotI2VuZGlmCiAJcDJwLT5tYXhfZGlzY19pbnQgPSAzOwogCXAycC0+bWF4X2Rpc2NfdHUgPSAtMTsKIApAQCAtMjQzOCw2ICsyNDk3LDExIEBACiAKIAlwMnAtPmdvX3RpbWVvdXQgPSAxMDA7CiAJcDJwLT5jbGllbnRfdGltZW91dCA9IDIwOworCXAycC0+bnVtX3AycF9zZF9xdWVyaWVzID0gMDsKKworCXAycF9kYmcocDJwLCAiaW5pdGlhbGl6ZWQiKTsKKwlwMnBfY2hhbm5lbHNfZHVtcChwMnAsICJjaGFubmVscyIsICZwMnAtPmNmZy0+Y2hhbm5lbHMpOworCXAycF9jaGFubmVsc19kdW1wKHAycCwgImNsaV9jaGFubmVscyIsICZwMnAtPmNmZy0+Y2xpX2NoYW5uZWxzKTsKIAogCXJldHVybiBwMnA7CiB9CkBAIC0yNDc1LDYgKzI1MzksNyBAQAogCXdwYWJ1Zl9mcmVlKHAycC0+c2RfcmVzcCk7CiAJb3NfZnJlZShwMnAtPmFmdGVyX3NjYW5fdHgpOwogCXAycF9yZW1vdmVfd3BzX3ZlbmRvcl9leHRlbnNpb25zKHAycCk7CisJb3NfZnJlZShwMnAtPm5vX2dvX2ZyZXEucmFuZ2UpOwogCW9zX2ZyZWUocDJwKTsKIH0KIApAQCAtMjQ4OCwxMCArMjU1Myw2IEBACiAJCWRsX2xpc3RfZGVsKCZkZXYtPmxpc3QpOwogCQlwMnBfZGV2aWNlX2ZyZWUocDJwLCBkZXYpOwogCX0KLSNpZmRlZiBBTkRST0lEX1AyUAotCS8qIFNEX0ZBSVJfUE9MSUNZOiBJbml0aWFsaXppbmcgdGhlIFNEIGN1cnJlbnQgc2VydmljZWQgcG9pbnRlciB0byBOVUxMICovCi0JcDJwLT5zZF9kZXZfbGlzdCA9IE5VTEw7Ci0jZW5kaWYKIAlwMnBfZnJlZV9zZF9xdWVyaWVzKHAycCk7CiAJb3NfZnJlZShwMnAtPmFmdGVyX3NjYW5fdHgpOwogCXAycC0+YWZ0ZXJfc2Nhbl90eCA9IE5VTEw7CkBAIC0yNTEyLDYgKzI1NzMsNyBAQAogCQlwMnAtPmdvX25lZ19wZWVyID0gTlVMTDsKIAogCWRldi0+d3BzX21ldGhvZCA9IFdQU19OT1RfUkVBRFk7CisJZGV2LT5vb2JfcHdfaWQgPSAwOwogCWRldi0+ZmxhZ3MgJj0gflAyUF9ERVZfV0FJVF9HT19ORUdfUkVTUE9OU0U7CiAJZGV2LT5mbGFncyAmPSB+UDJQX0RFVl9XQUlUX0dPX05FR19DT05GSVJNOwogCkBAIC0yNjY5LDQ0ICsyNzMxLDE4IEBACiB2b2lkIHAycF9jb250aW51ZV9maW5kKHN0cnVjdCBwMnBfZGF0YSAqcDJwKQogewogCXN0cnVjdCBwMnBfZGV2aWNlICpkZXY7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQlpbnQgc2tpcD0xOwotI2VuZGlmCiAJcDJwX3NldF9zdGF0ZShwMnAsIFAyUF9TRUFSQ0gpOwogCWRsX2xpc3RfZm9yX2VhY2goZGV2LCAmcDJwLT5kZXZpY2VzLCBzdHJ1Y3QgcDJwX2RldmljZSwgbGlzdCkgewotI2lmZGVmIEFORFJPSURfUDJQCi0JCS8qIFNEX0ZBSVJfUE9MSUNZOiBXZSBuZWVkIHRvIGdpdmUgY2hhbmNlIHRvIGFsbCBkZXZpY2VzIGluIHRoZSBkZXZpY2UgbGlzdAotCQkgKiBUaGVyZSBtYXkgYmUgYSBzY2VuYXJpbywgd2hlcmUgYSBwYXJ0aWN1bGFyIHBlZXIgZGV2aWNlIGhhdmUKLQkJICogbm90IHJlZ2lzdGVyZWQgYW55IHF1ZXJ5IHJlc3BvbnNlLiBXaGVuIHdlIHNlbmQgYSBTRCByZXF1ZXN0IHRvIHN1Y2ggZGV2aWNlLAotCQkgKiBubyByZXNwb25zZSB3aWxsIGJlIHJlY2VpdmVkLiBBbmQgaWYgd2UgY29udGludWUgdG8gZ2V0IHByb2JlIHJlc3BvbnNlcyBmcm9tIHRoYXQgZGV2aWNlLCAKLQkJICogYW5kIGlmIHRoYXQgZGV2aWNlIGhhcHBlbnMgdG8gYmUgb24gdG9wIGluIG91ciBkZXZpY2UgbGlzdCwgCi0JCSAqIHdlIHdpbGwgYWx3YXlzIGNvbnRpbnVlIHRvIHNlbmQgU0QgcmVxdWVzdHMgYWx3YXlzIHRvIHRoYXQgcGVlciBvbmx5LiAKLQkJICogV2Ugd2lsbCBub3QgYmUgYWJsZSB0byBzZW5kIFNEIHJlcXVlc3RzIHRvIG90aGVyIGRldmljZXMgaW4gdGhhdCBjYXNlLiAKLQkJICogVGhpcyBpbXBsZW1lbnRhdGlvbiBrZWVwcyB0cmFjayBvZiBsYXN0IHNlcnZpY2VkIHBlZXIgZGV2aWNlLiAKLQkJICogQW5kIHRoZW4gdGFrZXMgdGhlIG5leHQgb25lIGZyb20gdGhlIGRldmljZSBsaXN0LCBpbiB0aGUgbmV4dCBpdGVyYXRpb24uCi0JCSAqLwotCQlpZiAocDJwLT5zZF9kZXZfbGlzdCAmJiBwMnAtPnNkX2Rldl9saXN0ICE9ICZwMnAtPmRldmljZXMpIHsKLQkJCWlmKHNraXApIHsKLQkJCQlpZiAoKCZkZXYtPmxpc3QgPT0gcDJwLT5zZF9kZXZfbGlzdCkgKSB7Ci0JCQkJCXNraXAgPSAwOwotCQkJCQlpZiAoZGV2LT5saXN0Lm5leHQgPT0gJnAycC0+ZGV2aWNlcykKLQkJCQkJCXAycC0+c2RfZGV2X2xpc3QgPSBOVUxMOwotCQkJCX0KLQkJCQljb250aW51ZTsKLQkJCX0KKwkJaWYgKGRldi0+c2RfcGVuZGluZ19iY2FzdF9xdWVyaWVzID09IDApIHsKKwkJCS8qIEluaXRpYWxpemUgd2l0aCB0b3RhbCBudW1iZXIgb2YgcmVnaXN0ZXJlZCBicm9hZGNhc3QKKwkJCSAqIFNEIHF1ZXJpZXMuICovCisJCQlkZXYtPnNkX3BlbmRpbmdfYmNhc3RfcXVlcmllcyA9IHAycC0+bnVtX3AycF9zZF9xdWVyaWVzOwogCQl9Ci0JCXAycC0+c2RfZGV2X2xpc3QgPSAmZGV2LT5saXN0OwotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogIyMjIFNlcnZpY2luZyAlcCBkZXYtPmZsYWdzIDB4JXggU0Qgc2NoZWR1bGUgJXMgZGV2YWRkciAiIE1BQ1NUUiwKLQkJCXAycC0+c2RfZGV2X2xpc3QsIGRldi0+ZmxhZ3MsIGRldi0+ZmxhZ3MgJiBQMlBfREVWX1NEX1NDSEVEVUxFID8gIlRSVUUiOiAiRkFMU0UiLAotCQkJTUFDMlNUUihkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyKSk7Ci0jZW5kaWYKLQkJaWYgKGRldi0+ZmxhZ3MgJiBQMlBfREVWX1NEX1NDSEVEVUxFKSB7Ci0JCQlpZiAocDJwX3N0YXJ0X3NkKHAycCwgZGV2KSA9PSAwKQotCQkJCXJldHVybjsKLQkJCWVsc2UKLQkJCQlicmVhazsKLQkJfSBlbHNlIGlmIChkZXYtPnJlcV9jb25maWdfbWV0aG9kcyAmJgotCQkJICAgIShkZXYtPmZsYWdzICYgUDJQX0RFVl9QRF9GT1JfSk9JTikpIHsKKworCQlpZiAocDJwX3N0YXJ0X3NkKHAycCwgZGV2KSA9PSAwKQorCQkJcmV0dXJuOworCQlpZiAoZGV2LT5yZXFfY29uZmlnX21ldGhvZHMgJiYKKwkJICAgICEoZGV2LT5mbGFncyAmIFAyUF9ERVZfUERfRk9SX0pPSU4pKSB7CiAJCQlwMnBfZGJnKHAycCwgIlNlbmQgcGVuZGluZyBQcm92aXNpb24gRGlzY292ZXJ5IFJlcXVlc3QgdG8gIgogCQkJCU1BQ1NUUiAiIChjb25maWcgbWV0aG9kcyAweCV4KSIsCiAJCQkJTUFDMlNUUihkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyKSwKQEAgLTI3MjcsMTAgKzI3NjMsNyBAQAogCXAycC0+cGVuZGluZ19hY3Rpb25fc3RhdGUgPSBQMlBfTk9fUEVORElOR19BQ1RJT047CiAKIAlpZiAoIXN1Y2Nlc3MpIHsKLQkJaWYgKHAycC0+c2RfcGVlcikgewotCQkJcDJwLT5zZF9wZWVyLT5mbGFncyAmPSB+UDJQX0RFVl9TRF9TQ0hFRFVMRTsKLQkJCXAycC0+c2RfcGVlciA9IE5VTEw7Ci0JCX0KKwkJcDJwLT5zZF9wZWVyID0gTlVMTDsKIAkJcDJwX2NvbnRpbnVlX2ZpbmQocDJwKTsKIAkJcmV0dXJuOwogCX0KQEAgLTI3NzUsNyArMjgwOCw4IEBACiAJCQlNQUMyU1RSKGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIpLAogCQkJZGV2LT5yZXFfY29uZmlnX21ldGhvZHMpOwogCQlwMnBfc2VuZF9wcm92X2Rpc2NfcmVxKHAycCwgZGV2LAotCQkJCSAgICAgICBkZXYtPmZsYWdzICYgUDJQX0RFVl9QRF9GT1JfSk9JTiwgMCk7CisJCQkJICAgICAgIGRldi0+ZmxhZ3MgJiBQMlBfREVWX1BEX0ZPUl9KT0lOLAorCQkJCSAgICAgICBwMnAtPnBkX2ZvcmNlX2ZyZXEpOwogCQlyZXR1cm47CiAJfQogfQpAQCAtMjgwOSwxMSArMjg0Myw3IEBACiAJCQlwMnBfY29udGludWVfZmluZChwMnApOwogCQllbHNlIGlmIChwMnAtPnVzZXJfaW5pdGlhdGVkX3BkKSB7CiAJCQlwMnAtPnBlbmRpbmdfYWN0aW9uX3N0YXRlID0gUDJQX1BFTkRJTkdfUEQ7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQkJCXAycF9zZXRfdGltZW91dChwMnAsIDAsIDM1MDAwMCk7Ci0jZWxzZQogCQkJcDJwX3NldF90aW1lb3V0KHAycCwgMCwgMzAwMDAwKTsKLSNlbmRpZgogCQl9CiAJCXJldHVybjsKIAl9CkBAIC0yODMwLDE5ICsyODYwLDE1IEBACiAJLyogV2FpdCBmb3IgcmVzcG9uc2UgZnJvbSB0aGUgcGVlciAqLwogCWlmIChwMnAtPnN0YXRlID09IFAyUF9TRUFSQ0gpCiAJCXAycF9zZXRfc3RhdGUocDJwLCBQMlBfUERfRFVSSU5HX0ZJTkQpOwotI2lmZGVmIEFORFJPSURfUDJQCi0JcDJwX3NldF90aW1lb3V0KHAycCwgMCwgMzUwMDAwKTsKLSNlbHNlCiAJcDJwX3NldF90aW1lb3V0KHAycCwgMCwgMjAwMDAwKTsKLSNlbmRpZgogfQogCiAKIGludCBwMnBfc2Nhbl9yZXNfaGFuZGxlcihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmJzc2lkLCBpbnQgZnJlcSwKLQkJCSBzdHJ1Y3Qgb3NfdGltZSAqcnhfdGltZSwgaW50IGxldmVsLCBjb25zdCB1OCAqaWVzLAorCQkJIHN0cnVjdCBvc19yZWx0aW1lICpyeF90aW1lLCBpbnQgbGV2ZWwsIGNvbnN0IHU4ICppZXMsCiAJCQkgc2l6ZV90IGllc19sZW4pCiB7Ci0JaWYgKG9zX3RpbWVfYmVmb3JlKHJ4X3RpbWUsICZwMnAtPmZpbmRfc3RhcnQpKSB7CisJaWYgKG9zX3JlbHRpbWVfYmVmb3JlKHJ4X3RpbWUsICZwMnAtPmZpbmRfc3RhcnQpKSB7CiAJCS8qCiAJCSAqIFRoZSBkcml2ZXIgbWF5IGhhdmUgY2FjaGVkIChlLmcuLCBpbiBjZmc4MDIxMSBCU1MgdGFibGUpIHRoZQogCQkgKiBzY2FuIHJlc3VsdHMgZm9yIHJlbGF0aXZlbHkgbG9uZyB0aW1lLiBUbyBhdm9pZCByZXBvcnRpbmcKQEAgLTI4ODcsNiArMjkxMywxMCBAQAogCQl3cGFidWZfcHV0X2J1ZihpZXMsIHAycC0+d2ZkX2llX3Byb2JlX3JlcSk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKHAycC0+dmVuZG9yX2VsZW0gJiYgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QUk9CRV9SRVFfUDJQXSkKKwkJd3BhYnVmX3B1dF9idWYoaWVzLAorCQkJICAgICAgIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUFJPQkVfUkVRX1AyUF0pOworCiAJbGVuID0gcDJwX2J1Zl9hZGRfaWVfaGRyKGllcyk7CiAJcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShpZXMsIHAycC0+ZGV2X2NhcGFiICYKIAkJCSAgICAgICB+UDJQX0RFVl9DQVBBQl9DTElFTlRfRElTQ09WRVJBQklMSVRZLCAwKTsKQEAgLTI5MTMsNiArMjk0MywxMCBAQAogCQlsZW4gKz0gd3BhYnVmX2xlbihwMnAtPndmZF9pZV9wcm9iZV9yZXEpOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChwMnAgJiYgcDJwLT52ZW5kb3JfZWxlbSAmJgorCSAgICBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1BST0JFX1JFUV9QMlBdKQorCQlsZW4gKz0gd3BhYnVmX2xlbihwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1BST0JFX1JFUV9QMlBdKTsKKwogCXJldHVybiBsZW47CiB9CiAKQEAgLTMwMDEsOCArMzAzNSwxNyBAQAogCQlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OwogCQlkZXYgPSBwMnBfZ2V0X2RldmljZShwMnAsIGFkZHIpOwogCQlpZiAoZGV2ICYmCi0JCSAgICBkZXYtPnN0YXR1cyA9PSBQMlBfU0NfRkFJTF9JTkZPX0NVUlJFTlRMWV9VTkFWQUlMQUJMRSkKKwkJICAgIGRldi0+c3RhdHVzID09IFAyUF9TQ19GQUlMX0lORk9fQ1VSUkVOVExZX1VOQVZBSUxBQkxFKSB7CiAJCQlkZXYtPmZsYWdzIHw9IFAyUF9ERVZfUEVFUl9XQUlUSU5HX1JFU1BPTlNFOworCQkJaWYgKChwMnAtPnN0YXRlID09IFAyUF9TRUFSQ0gpIHx8CisJCQkgICAgKHAycC0+c3RhdGUgPT0gUDJQX0xJU1RFTl9PTkxZKSkgeworCQkJCS8qIENsZWFyIG91ciBzZWFyY2ggc3RhdGUgb3IgTGlzdGVuIHN0YXRlIHNpbmNlCisJCQkJICogbm93IHBlZXIgaXMgYXdhaXRpbmcgcmVzcG9uc2UgZnJvbSBvdXIgc2lkZS4KKwkJCQkgKi8KKwkJCQlwMnBfZGJnKHAycCwgIkNsZWFyIHRoZSBQMlAgZGlzY292ZXJ5IHN0YXRlIik7CisJCQkJcDJwX3N0b3BfZmluZChwMnApOworCQkJfQorCQl9CiAJfQogfQogCkBAIC0zMDEzLDEzICszMDU2LDQ0IEBACiAJc3RydWN0IHAycF9kZXZpY2UgKmRldjsKIAogCXAycF9kYmcocDJwLCAiR08gTmVnb3RpYXRpb24gQ29uZmlybSBUWCBjYWxsYmFjazogcmVzdWx0PSVkIiwgcmVzdWx0KTsKLQlwMnAtPmNmZy0+c2VuZF9hY3Rpb25fZG9uZShwMnAtPmNmZy0+Y2JfY3R4KTsKIAlpZiAocmVzdWx0ID09IFAyUF9TRU5EX0FDVElPTl9GQUlMRUQpIHsKKwkJcDJwLT5jZmctPnNlbmRfYWN0aW9uX2RvbmUocDJwLT5jZmctPmNiX2N0eCk7CiAJCXAycF9nb19uZWdfZmFpbGVkKHAycCwgcDJwLT5nb19uZWdfcGVlciwgLTEpOwogCQlyZXR1cm47CiAJfQorCisJZGV2ID0gcDJwLT5nb19uZWdfcGVlcjsKKwogCWlmIChyZXN1bHQgPT0gUDJQX1NFTkRfQUNUSU9OX05PX0FDSykgewogCQkvKgorCQkgKiBSZXRyeSBHTyBOZWdvdGlhdGlvbiBDb25maXJtYXRpb24KKwkJICogUDJQX0dPX05FR19DTkZfTUFYX1JFVFJZX0NPVU5UIHRpbWVzIGlmIHdlIGRpZCBub3QgcmVjZWl2ZQorCQkgKiBBQ0sgZm9yIGNvbmZpcm1hdGlvbi4KKwkJICovCisJCWlmIChkZXYgJiYgZGV2LT5nb19uZWdfY29uZiAmJgorCQkgICAgZGV2LT5nb19uZWdfY29uZl9zZW50IDw9IFAyUF9HT19ORUdfQ05GX01BWF9SRVRSWV9DT1VOVCkgeworCQkJcDJwX2RiZyhwMnAsICJHTyBOZWdvdGlhdGlvbiBDb25maXJtIHJldHJ5ICVkIiwKKwkJCQlkZXYtPmdvX25lZ19jb25mX3NlbnQpOworCQkJcDJwLT5wZW5kaW5nX2FjdGlvbl9zdGF0ZSA9IFAyUF9QRU5ESU5HX0dPX05FR19DT05GSVJNOworCQkJaWYgKHAycF9zZW5kX2FjdGlvbihwMnAsIGRldi0+Z29fbmVnX2NvbmZfZnJlcSwKKwkJCQkJICAgIGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCisJCQkJCSAgICBwMnAtPmNmZy0+ZGV2X2FkZHIsCisJCQkJCSAgICBkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyLAorCQkJCQkgICAgd3BhYnVmX2hlYWQoZGV2LT5nb19uZWdfY29uZiksCisJCQkJCSAgICB3cGFidWZfbGVuKGRldi0+Z29fbmVnX2NvbmYpLCAwKSA+PQorCQkJICAgIDApIHsKKwkJCQlkZXYtPmdvX25lZ19jb25mX3NlbnQrKzsKKwkJCQlyZXR1cm47CisJCQl9CisJCQlwMnBfZGJnKHAycCwgIkZhaWxlZCB0byByZS1zZW5kIEFjdGlvbiBmcmFtZSIpOworCisJCQkvKgorCQkJICogQ29udGludWUgd2l0aCB0aGUgYXNzdW1wdGlvbiB0aGF0IHRoZSBmaXJzdCBhdHRlbXB0CisJCQkgKiB3ZW50IHRocm91Z2ggYW5kIGp1c3QgdGhlIEFDSyBmcmFtZSB3YXMgbG9zdC4KKwkJCSAqLworCQl9CisKKwkJLyoKIAkJICogSXQgbG9va3MgbGlrZSB0aGUgVFggc3RhdHVzIGZvciBHTyBOZWdvdGlhdGlvbiBDb25maXJtIGlzCiAJCSAqIG9mdGVuIHNob3dpbmcgZmFpbHVyZSBldmVuIHdoZW4gdGhlIHBlZXIgaGFzIGFjdHVhbGx5CiAJCSAqIHJlY2VpdmVkIHRoZSBmcmFtZS4gU2luY2UgdGhlIHBlZXIgbWF5IGNoYW5nZSBjaGFubmVscwpAQCAtMzAzMiw3ICszMTA2LDggQEAKIAkJcDJwX2RiZyhwMnAsICJBc3N1bWUgR08gTmVnb3RpYXRpb24gQ29uZmlybSBUWCB3YXMgYWN0dWFsbHkgcmVjZWl2ZWQgYnkgdGhlIHBlZXIgZXZlbiB0aG91Z2ggQWNrIHdhcyBub3QgcmVwb3J0ZWQiKTsKIAl9CiAKLQlkZXYgPSBwMnAtPmdvX25lZ19wZWVyOworCXAycC0+Y2ZnLT5zZW5kX2FjdGlvbl9kb25lKHAycC0+Y2ZnLT5jYl9jdHgpOworCiAJaWYgKGRldiA9PSBOVUxMKQogCQlyZXR1cm47CiAKQEAgLTMwNTYsNiArMzEzMSwxMCBAQAogCXAycC0+cGVuZGluZ19hY3Rpb25fc3RhdGUgPSBQMlBfTk9fUEVORElOR19BQ1RJT047CiAJc3dpdGNoIChzdGF0ZSkgewogCWNhc2UgUDJQX05PX1BFTkRJTkdfQUNUSU9OOgorCQlpZiAocDJwLT5zZW5kX2FjdGlvbl9pbl9wcm9ncmVzcykgeworCQkJcDJwLT5zZW5kX2FjdGlvbl9pbl9wcm9ncmVzcyA9IDA7CisJCQlwMnAtPmNmZy0+c2VuZF9hY3Rpb25fZG9uZShwMnAtPmNmZy0+Y2JfY3R4KTsKKwkJfQogCQlpZiAocDJwLT5hZnRlcl9zY2FuX3R4X2luX3Byb2dyZXNzKSB7CiAJCQlwMnAtPmFmdGVyX3NjYW5fdHhfaW5fcHJvZ3Jlc3MgPSAwOwogCQkJaWYgKHAycC0+c3RhcnRfYWZ0ZXJfc2NhbiAhPSBQMlBfQUZURVJfU0NBTl9OT1RISU5HICYmCkBAIC0zMjExLDcgKzMyOTAsMTIgQEAKIAkJcDJwX2Nvbm5lY3Rfc2VuZChwMnAsIHAycC0+Z29fbmVnX3BlZXIpOwogCQlyZXR1cm47CiAJfQotCisJaWYgKHAycC0+Z29fbmVnX3BlZXIgJiYgcDJwLT5nb19uZWdfcGVlci0+b29iX2dvX25lZ19mcmVxID4gMCkgeworCQlwMnBfZGJnKHAycCwgIlNraXAgY29ubmVjdC1saXN0ZW4gc2luY2UgR08gTmVnIGNoYW5uZWwga25vd24gKE9PQikiKTsKKwkJcDJwX3NldF9zdGF0ZShwMnAsIFAyUF9DT05ORUNUX0xJU1RFTik7CisJCXAycF9zZXRfdGltZW91dChwMnAsIDAsIDMwMDAwKTsKKwkJcmV0dXJuOworCX0KIAlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX0NPTk5FQ1RfTElTVEVOKTsKIAlwMnBfbGlzdGVuX2luX2ZpbmQocDJwLCAwKTsKIH0KQEAgLTMyNDAsMjcgKzMzMjQsMjggQEAKIAogc3RhdGljIHZvaWQgcDJwX3RpbWVvdXRfd2FpdF9wZWVyX2Nvbm5lY3Qoc3RydWN0IHAycF9kYXRhICpwMnApCiB7Ci0JLyoKLQkgKiBUT0RPOiBjb3VsZCByZW1haW4gY29uc3RhbnRseSBpbiBMaXN0ZW4gc3RhdGUgZm9yIHNvbWUgdGltZSBpZiB0aGVyZQotCSAqIGFyZSBubyBvdGhlciBjb25jdXJyZW50IHVzZXMgZm9yIHRoZSByYWRpby4gRm9yIG5vdywgZ28gdG8gbGlzdGVuCi0JICogc3RhdGUgb25jZSBwZXIgc2Vjb25kIHRvIGdpdmUgb3RoZXIgdXNlcyBhIGNoYW5jZSB0byB1c2UgdGhlIHJhZGlvLgotCSAqLwogCXAycF9zZXRfc3RhdGUocDJwLCBQMlBfV0FJVF9QRUVSX0lETEUpOwotCXAycF9zZXRfdGltZW91dChwMnAsIDAsIDUwMDAwMCk7CisKKwlpZiAocDJwLT5jZmctPmlzX2NvbmN1cnJlbnRfc2Vzc2lvbl9hY3RpdmUgJiYKKwkgICAgcDJwLT5jZmctPmlzX2NvbmN1cnJlbnRfc2Vzc2lvbl9hY3RpdmUocDJwLT5jZmctPmNiX2N0eCkpCisJCXAycF9zZXRfdGltZW91dChwMnAsIDAsIDUwMDAwMCk7CisJZWxzZQorCQlwMnBfc2V0X3RpbWVvdXQocDJwLCAwLCAyMDAwMDApOwogfQogCiAKIHN0YXRpYyB2b2lkIHAycF90aW1lb3V0X3dhaXRfcGVlcl9pZGxlKHN0cnVjdCBwMnBfZGF0YSAqcDJwKQogewogCXN0cnVjdCBwMnBfZGV2aWNlICpkZXYgPSBwMnAtPmdvX25lZ19wZWVyOworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAogCWlmIChkZXYgPT0gTlVMTCkgewogCQlwMnBfZGJnKHAycCwgIlVua25vd24gR08gTmVnIHBlZXIgLSBzdG9wIEdPIE5lZyB3YWl0Iik7CiAJCXJldHVybjsKIAl9CiAKLQlkZXYtPndhaXRfY291bnQrKzsKLQlpZiAoZGV2LT53YWl0X2NvdW50ID49IDEyMCkgeworCW9zX2dldF9yZWx0aW1lKCZub3cpOworCWlmIChvc19yZWx0aW1lX2V4cGlyZWQoJm5vdywgJmRldi0+Z29fbmVnX3dhaXRfc3RhcnRlZCwgMTIwKSkgewogCQlwMnBfZGJnKHAycCwgIlRpbWVvdXQgb24gd2FpdGluZyBwZWVyIHRvIGJlY29tZSByZWFkeSBmb3IgR08gTmVnb3RpYXRpb24iKTsKIAkJcDJwX2dvX25lZ19mYWlsZWQocDJwLCBkZXYsIC0xKTsKIAkJcmV0dXJuOwpAQCAtMzI3Nyw3ICszMzYyLDYgQEAKIAlwMnBfZGJnKHAycCwgIlNlcnZpY2UgRGlzY292ZXJ5IFF1ZXJ5IHRpbWVvdXQiKTsKIAlpZiAocDJwLT5zZF9wZWVyKSB7CiAJCXAycC0+Y2ZnLT5zZW5kX2FjdGlvbl9kb25lKHAycC0+Y2ZnLT5jYl9jdHgpOwotCQlwMnAtPnNkX3BlZXItPmZsYWdzICY9IH5QMlBfREVWX1NEX1NDSEVEVUxFOwogCQlwMnAtPnNkX3BlZXIgPSBOVUxMOwogCX0KIAlwMnBfY29udGludWVfZmluZChwMnApOwpAQCAtMzM1NSwxNCArMzQzOSwxNSBAQAogCWlmIChwMnAtPmludml0ZV9wZWVyICYmIHAycC0+aW52aXRlX3BlZXItPmludml0YXRpb25fcmVxcyA8IDEwMCkgewogCQlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX0lOVklURSk7CiAJCXAycF9pbnZpdGVfc2VuZChwMnAsIHAycC0+aW52aXRlX3BlZXIsCi0JCQkJcDJwLT5pbnZpdGVfZ29fZGV2X2FkZHIpOworCQkJCXAycC0+aW52aXRlX2dvX2Rldl9hZGRyLCBwMnAtPmludml0ZV9kZXZfcHdfaWQpOwogCX0gZWxzZSB7CiAJCWlmIChwMnAtPmludml0ZV9wZWVyKSB7CiAJCQlwMnBfZGJnKHAycCwgIkludml0YXRpb24gUmVxdWVzdCByZXRyeSBsaW1pdCByZWFjaGVkIik7CiAJCQlpZiAocDJwLT5jZmctPmludml0YXRpb25fcmVzdWx0KQogCQkJCXAycC0+Y2ZnLT5pbnZpdGF0aW9uX3Jlc3VsdCgKIAkJCQkJcDJwLT5jZmctPmNiX2N0eCwgLTEsIE5VTEwsIE5VTEwsCi0JCQkJCXAycC0+aW52aXRlX3BlZXItPmluZm8ucDJwX2RldmljZV9hZGRyKTsKKwkJCQkJcDJwLT5pbnZpdGVfcGVlci0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCisJCQkJCTAsIDApOwogCQl9CiAJCXAycF9zZXRfc3RhdGUocDJwLCBQMlBfSURMRSk7CiAJfQpAQCAtMzQzNywxMCArMzUyMiw2IEBACiAJY2FzZSBQMlBfSU5WSVRFX0xJU1RFTjoKIAkJcDJwX3RpbWVvdXRfaW52aXRlX2xpc3RlbihwMnApOwogCQlicmVhazsKLQljYXNlIFAyUF9TRUFSQ0hfV0hFTl9SRUFEWToKLQkJYnJlYWs7Ci0JY2FzZSBQMlBfQ09OVElOVUVfU0VBUkNIX1dIRU5fUkVBRFk6Ci0JCWJyZWFrOwogCX0KIH0KIApAQCAtMzQ3Myw2ICszNTU0LDggQEAKIAkJcmV0dXJuICJLZXlwYWQiOwogCWNhc2UgV1BTX1BCQzoKIAkJcmV0dXJuICJQQkMiOworCWNhc2UgV1BTX05GQzoKKwkJcmV0dXJuICJORkMiOwogCX0KIAogCXJldHVybiAiPz8iOwpAQCAtMzUyMyw3ICszNjA2LDcgQEAKIAlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OwogCWludCByZXM7CiAJY2hhciAqcG9zLCAqZW5kOwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKIAlpZiAoaW5mbyA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CkBAIC0zNTM0LDcgKzM2MTcsNyBAQAogCXBvcyA9IGJ1ZjsKIAllbmQgPSBidWYgKyBidWZsZW47CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAlyZXMgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKIAkJCSAgImFnZT0lZFxuIgogCQkJICAibGlzdGVuX2ZyZXE9JWRcbiIKQEAgLTM1NDksOSArMzYzMiw4IEBACiAJCQkgICJjb3VudHJ5PSVjJWNcbiIKIAkJCSAgIm9wZXJfZnJlcT0lZFxuIgogCQkJICAicmVxX2NvbmZpZ19tZXRob2RzPTB4JXhcbiIKLQkJCSAgImZsYWdzPSVzJXMlcyVzJXMlcyVzJXMlcyVzJXMlcyVzJXMlc1xuIgorCQkJICAiZmxhZ3M9JXMlcyVzJXMlcyVzJXMlcyVzJXMlcyVzJXNcbiIKIAkJCSAgInN0YXR1cz0lZFxuIgotCQkJICAid2FpdF9jb3VudD0ldVxuIgogCQkJICAiaW52aXRhdGlvbl9yZXFzPSV1XG4iLAogCQkJICAoaW50KSAobm93LnNlYyAtIGRldi0+bGFzdF9zZWVuLnNlYyksCiAJCQkgIGRldi0+bGlzdGVuX2ZyZXEsCkBAIC0zNTcyLDkgKzM2NTQsNiBAQAogCQkJICBkZXYtPmZsYWdzICYgUDJQX0RFVl9SRVBPUlRFRCA/ICJbUkVQT1JURURdIiA6ICIiLAogCQkJICBkZXYtPmZsYWdzICYgUDJQX0RFVl9OT1RfWUVUX1JFQURZID8KIAkJCSAgIltOT1RfWUVUX1JFQURZXSIgOiAiIiwKLQkJCSAgZGV2LT5mbGFncyAmIFAyUF9ERVZfU0RfSU5GTyA/ICJbU0RfSU5GT10iIDogIiIsCi0JCQkgIGRldi0+ZmxhZ3MgJiBQMlBfREVWX1NEX1NDSEVEVUxFID8gIltTRF9TQ0hFRFVMRV0iIDoKLQkJCSAgIiIsCiAJCQkgIGRldi0+ZmxhZ3MgJiBQMlBfREVWX1BEX1BFRVJfRElTUExBWSA/CiAJCQkgICJbUERfUEVFUl9ESVNQTEFZXSIgOiAiIiwKIAkJCSAgZGV2LT5mbGFncyAmIFAyUF9ERVZfUERfUEVFUl9LRVlQQUQgPwpAQCAtMzU5Niw3ICszNjc1LDYgQEAKIAkJCSAgZGV2LT5mbGFncyAmIFAyUF9ERVZfUERfRk9SX0pPSU4gPwogCQkJICAiW1BEX0ZPUl9KT0lOXSIgOiAiIiwKIAkJCSAgZGV2LT5zdGF0dXMsCi0JCQkgIGRldi0+d2FpdF9jb3VudCwKIAkJCSAgZGV2LT5pbnZpdGF0aW9uX3JlcXMpOwogCWlmIChyZXMgPCAwIHx8IHJlcyA+PSBlbmQgLSBwb3MpCiAJCXJldHVybiBwb3MgLSBidWY7CkBAIC0zODM4LDYgKzM5MTYsMTEgQEAKIAkJcmV0dXJuOwogCX0KIAorCWlmIChwMnAtPmNmZy0+cHJlc2VuY2VfcmVzcCkgeworCQlwMnAtPmNmZy0+cHJlc2VuY2VfcmVzcChwMnAtPmNmZy0+Y2JfY3R4LCBzYSwgKm1zZy5zdGF0dXMsCisJCQkJCW1zZy5ub2EsIG1zZy5ub2FfbGVuKTsKKwl9CisKIAlpZiAoKm1zZy5zdGF0dXMpIHsKIAkJcDJwX2RiZyhwMnAsICJQMlAgUHJlc2VuY2UgUmVxdWVzdCB3YXMgcmVqZWN0ZWQ6IHN0YXR1cyAldSIsCiAJCQkqbXNnLnN0YXR1cyk7CkBAIC0zODY0LDYgKzM5NDcsMTUgQEAKIAkJCQkgICAgICAgcDJwX2V4dF9saXN0ZW5fdGltZW91dCwgcDJwLCBOVUxMKTsKIAl9CiAKKwlpZiAoKHAycC0+Y2ZnLT5pc19wMnBfaW5fcHJvZ3Jlc3MgJiYKKwkgICAgIHAycC0+Y2ZnLT5pc19wMnBfaW5fcHJvZ3Jlc3MocDJwLT5jZmctPmNiX2N0eCkpIHx8CisJICAgIChwMnAtPnBlbmRpbmdfYWN0aW9uX3N0YXRlID09IFAyUF9QRU5ESU5HX1BEICYmCisJICAgICBwMnAtPnBkX3JldHJpZXMgPiAwKSkgeworCQlwMnBfZGJnKHAycCwgIk9wZXJhdGlvbiBpbiBwcm9ncmVzcyAtIHNraXAgRXh0ZW5kZWQgTGlzdGVuIHRpbWVvdXQgKCVzKSIsCisJCQlwMnBfc3RhdGVfdHh0KHAycC0+c3RhdGUpKTsKKwkJcmV0dXJuOworCX0KKwogCWlmIChwMnAtPnN0YXRlID09IFAyUF9MSVNURU5fT05MWSAmJiBwMnAtPmV4dF9saXN0ZW5fb25seSkgewogCQkvKgogCQkgKiBUaGlzIHNob3VsZCBub3QgcmVhbGx5IGhhcHBlbiwgYnV0IGl0IGxvb2tzIGxpa2UgdGhlIExpc3RlbgpAQCAtMzkzNSw4ICs0MDI3LDEwIEBACiAJb3NfbWVtc2V0KCZtc2csIDAsIHNpemVvZihtc2cpKTsKIAlpZiAocDJwX3BhcnNlX2llcyhpZSwgaWVfbGVuLCAmbXNnKSkKIAkJcmV0dXJuOwotCWlmIChtc2cubWlub3JfcmVhc29uX2NvZGUgPT0gTlVMTCkKKwlpZiAobXNnLm1pbm9yX3JlYXNvbl9jb2RlID09IE5VTEwpIHsKKwkJcDJwX3BhcnNlX2ZyZWUoJm1zZyk7CiAJCXJldHVybjsKKwl9CiAKIAlwMnBfZGJnKHAycCwgIkRlYXV0aGVudGljYXRpb24gbm90aWZpY2F0aW9uIEJTU0lEICIgTUFDU1RSCiAJCSIgcmVhc29uX2NvZGU9JXUgbWlub3JfcmVhc29uX2NvZGU9JXUiLApAQCAtMzk1Nyw4ICs0MDUxLDEwIEBACiAJb3NfbWVtc2V0KCZtc2csIDAsIHNpemVvZihtc2cpKTsKIAlpZiAocDJwX3BhcnNlX2llcyhpZSwgaWVfbGVuLCAmbXNnKSkKIAkJcmV0dXJuOwotCWlmIChtc2cubWlub3JfcmVhc29uX2NvZGUgPT0gTlVMTCkKKwlpZiAobXNnLm1pbm9yX3JlYXNvbl9jb2RlID09IE5VTEwpIHsKKwkJcDJwX3BhcnNlX2ZyZWUoJm1zZyk7CiAJCXJldHVybjsKKwl9CiAKIAlwMnBfZGJnKHAycCwgIkRpc2Fzc29jaWF0aW9uIG5vdGlmaWNhdGlvbiBCU1NJRCAiIE1BQ1NUUgogCQkiIHJlYXNvbl9jb2RlPSV1IG1pbm9yX3JlYXNvbl9jb2RlPSV1IiwKQEAgLTM5ODAsMjAgKzQwNzYsNDMgQEAKIH0KIAogCi1pbnQgcDJwX3NldF9saXN0ZW5fY2hhbm5lbChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgdTggcmVnX2NsYXNzLCB1OCBjaGFubmVsKQoraW50IHAycF9zZXRfbGlzdGVuX2NoYW5uZWwoc3RydWN0IHAycF9kYXRhICpwMnAsIHU4IHJlZ19jbGFzcywgdTggY2hhbm5lbCwKKwkJCSAgIHU4IGZvcmNlZCkKIHsKIAlpZiAocDJwX2NoYW5uZWxfdG9fZnJlcShyZWdfY2xhc3MsIGNoYW5uZWwpIDwgMCkKIAkJcmV0dXJuIC0xOwogCiAJcDJwX2RiZyhwMnAsICJTZXQgTGlzdGVuIGNoYW5uZWw6IHJlZ19jbGFzcyAldSBjaGFubmVsICV1IiwKIAkJcmVnX2NsYXNzLCBjaGFubmVsKTsKLQlwMnAtPmNmZy0+cmVnX2NsYXNzID0gcmVnX2NsYXNzOwotCXAycC0+Y2ZnLT5jaGFubmVsID0gY2hhbm5lbDsKKworCS8qCisJICogTGlzdGVuIGNoYW5uZWwgd2FzIHNldCBpbiBjb25maWd1cmF0aW9uIG9yIHNldCBieSBjb250cm9sIGludGVyZmFjZTsKKwkgKiBjYW5ub3Qgb3ZlcnJpZGUgaXQuCisJICovCisJaWYgKHAycC0+Y2ZnLT5jaGFubmVsX2ZvcmNlZCAmJiBmb3JjZWQgPT0gMCkKKwkJcmV0dXJuIC0xOworCisJaWYgKHAycC0+c3RhdGUgPT0gUDJQX0lETEUpIHsKKwkJcDJwLT5jZmctPnJlZ19jbGFzcyA9IHJlZ19jbGFzczsKKwkJcDJwLT5jZmctPmNoYW5uZWwgPSBjaGFubmVsOworCQlwMnAtPmNmZy0+Y2hhbm5lbF9mb3JjZWQgPSBmb3JjZWQ7CisJfSBlbHNlIHsKKwkJcDJwX2RiZyhwMnAsICJEZWZlciBzZXR0aW5nIGxpc3RlbiBjaGFubmVsIik7CisJCXAycC0+cGVuZGluZ19yZWdfY2xhc3MgPSByZWdfY2xhc3M7CisJCXAycC0+cGVuZGluZ19jaGFubmVsID0gY2hhbm5lbDsKKwkJcDJwLT5wZW5kaW5nX2NoYW5uZWxfZm9yY2VkID0gZm9yY2VkOworCX0KIAogCXJldHVybiAwOwogfQogCiAKK3U4IHAycF9nZXRfbGlzdGVuX2NoYW5uZWwoc3RydWN0IHAycF9kYXRhICpwMnApCit7CisJcmV0dXJuIHAycC0+Y2ZnLT5jaGFubmVsOworfQorCisKIGludCBwMnBfc2V0X3NzaWRfcG9zdGZpeChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKnBvc3RmaXgsIHNpemVfdCBsZW4pCiB7CiAJcDJwX2RiZyhwMnAsICJOZXcgU1NJRCBwb3N0Zml4OiAlcyIsIHdwYV9zc2lkX3R4dChwb3N0Zml4LCBsZW4pKTsKQEAgLTQwNDYsNiArNDE2NSwzMSBAQAogfQogCiAKK2ludCBwMnBfc2V0X25vX2dvX2ZyZXEoc3RydWN0IHAycF9kYXRhICpwMnAsCisJCSAgICAgICBjb25zdCBzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2VfbGlzdCAqbGlzdCkKK3sKKwlzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2UgKnRtcDsKKworCWlmIChsaXN0ID09IE5VTEwgfHwgbGlzdC0+bnVtID09IDApIHsKKwkJb3NfZnJlZShwMnAtPm5vX2dvX2ZyZXEucmFuZ2UpOworCQlwMnAtPm5vX2dvX2ZyZXEucmFuZ2UgPSBOVUxMOworCQlwMnAtPm5vX2dvX2ZyZXEubnVtID0gMDsKKwkJcmV0dXJuIDA7CisJfQorCisJdG1wID0gb3NfY2FsbG9jKGxpc3QtPm51bSwgc2l6ZW9mKHN0cnVjdCB3cGFfZnJlcV9yYW5nZSkpOworCWlmICh0bXAgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCW9zX21lbWNweSh0bXAsIGxpc3QtPnJhbmdlLCBsaXN0LT5udW0gKiBzaXplb2Yoc3RydWN0IHdwYV9mcmVxX3JhbmdlKSk7CisJb3NfZnJlZShwMnAtPm5vX2dvX2ZyZXEucmFuZ2UpOworCXAycC0+bm9fZ29fZnJlcS5yYW5nZSA9IHRtcDsKKwlwMnAtPm5vX2dvX2ZyZXEubnVtID0gbGlzdC0+bnVtOworCXAycF9kYmcocDJwLCAiVXBkYXRlZCBubyBHTyBjaGFuIGxpc3QiKTsKKworCXJldHVybiAwOworfQorCisKIGludCBwMnBfZ2V0X2ludGVyZmFjZV9hZGRyKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqZGV2X2FkZHIsCiAJCQkgICB1OCAqaWZhY2VfYWRkcikKIHsKQEAgLTQxMDgsMTAgKzQyNTIsMTYgQEAKIH0KIAogCi12b2lkIHAycF91cGRhdGVfY2hhbm5lbF9saXN0KHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFuKQordm9pZCBwMnBfdXBkYXRlX2NoYW5uZWxfbGlzdChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCSAgICAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2hhbiwKKwkJCSAgICAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2xpX2NoYW4pCiB7CiAJcDJwX2RiZyhwMnAsICJVcGRhdGUgY2hhbm5lbCBsaXN0Iik7CiAJb3NfbWVtY3B5KCZwMnAtPmNmZy0+Y2hhbm5lbHMsIGNoYW4sIHNpemVvZihzdHJ1Y3QgcDJwX2NoYW5uZWxzKSk7CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAiY2hhbm5lbHMiLCAmcDJwLT5jZmctPmNoYW5uZWxzKTsKKwlvc19tZW1jcHkoJnAycC0+Y2ZnLT5jbGlfY2hhbm5lbHMsIGNsaV9jaGFuLAorCQkgIHNpemVvZihzdHJ1Y3QgcDJwX2NoYW5uZWxzKSk7CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAiY2xpX2NoYW5uZWxzIiwgJnAycC0+Y2ZnLT5jbGlfY2hhbm5lbHMpOwogfQogCiAKQEAgLTQxOTAsNyArNDM0MCw3IEBACiAJCQkJZGV2ID0gZGxfbGlzdF9maXJzdCgmZGV2LT5saXN0LAogCQkJCQkJICAgIHN0cnVjdCBwMnBfZGV2aWNlLAogCQkJCQkJICAgIGxpc3QpOwotCQkJCWlmICgmZGV2LT5saXN0ID09ICZwMnAtPmRldmljZXMpCisJCQkJaWYgKCFkZXYgfHwgJmRldi0+bGlzdCA9PSAmcDJwLT5kZXZpY2VzKQogCQkJCQlyZXR1cm4gTlVMTDsKIAkJCX0gd2hpbGUgKGRldi0+ZmxhZ3MgJiBQMlBfREVWX1BST0JFX1JFUV9PTkxZKTsKIAkJfQpAQCAtNDIwMiw3ICs0MzUyLDcgQEAKIAkJCWRldiA9IGRsX2xpc3RfZmlyc3QoJmRldi0+bGlzdCwKIAkJCQkJICAgIHN0cnVjdCBwMnBfZGV2aWNlLAogCQkJCQkgICAgbGlzdCk7Ci0JCQlpZiAoJmRldi0+bGlzdCA9PSAmcDJwLT5kZXZpY2VzKQorCQkJaWYgKCFkZXYgfHwgJmRldi0+bGlzdCA9PSAmcDJwLT5kZXZpY2VzKQogCQkJCXJldHVybiBOVUxMOwogCQl9CiAJfQpAQCAtNDIxMCwyMiArNDM2MCwxMiBAQAogCXJldHVybiAmZGV2LT5pbmZvOwogfQogCi0jaWZkZWYgQU5EUk9JRF9QMlAKLWludCBwMnBfc2VhcmNoX2luX3Byb2dyZXNzKHN0cnVjdCBwMnBfZGF0YSAqcDJwKQotewotCWlmIChwMnAgPT0gTlVMTCkKLQkJcmV0dXJuIDA7Ci0KLQlyZXR1cm4gcDJwLT5zdGF0ZSA9PSBQMlBfU0VBUkNIOwotfQotI2VuZGlmCiAKIGludCBwMnBfaW5fcHJvZ3Jlc3Moc3RydWN0IHAycF9kYXRhICpwMnApCiB7CiAJaWYgKHAycCA9PSBOVUxMKQogCQlyZXR1cm4gMDsKLQlpZiAocDJwLT5zdGF0ZSA9PSBQMlBfU0VBUkNIIHx8IHAycC0+c3RhdGUgPT0gUDJQX1NFQVJDSF9XSEVOX1JFQURZIHx8Ci0JICAgIHAycC0+c3RhdGUgPT0gUDJQX0NPTlRJTlVFX1NFQVJDSF9XSEVOX1JFQURZKQorCWlmIChwMnAtPnN0YXRlID09IFAyUF9TRUFSQ0gpCiAJCXJldHVybiAyOwogCXJldHVybiBwMnAtPnN0YXRlICE9IFAyUF9JRExFICYmIHAycC0+c3RhdGUgIT0gUDJQX1BST1ZJU0lPTklORzsKIH0KQEAgLTQyNDEsMTMgKzQzODEsNiBAQAogfQogCiAKLXZvaWQgcDJwX2luY3JlYXNlX3NlYXJjaF9kZWxheShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgdW5zaWduZWQgaW50IGRlbGF5KQotewotCWlmIChwMnAgJiYgcDJwLT5zZWFyY2hfZGVsYXkgPCBkZWxheSkKLQkJcDJwLT5zZWFyY2hfZGVsYXkgPSBkZWxheTsKLX0KLQotCiAjaWZkZWYgQ09ORklHX1dJRklfRElTUExBWQogCiBzdGF0aWMgdm9pZCBwMnBfdXBkYXRlX3dmZF9pZV9ncm91cHMoc3RydWN0IHAycF9kYXRhICpwMnApCkBAIC00MjU3LDcgKzQzOTAsNyBAQAogCiAJZm9yIChnID0gMDsgZyA8IHAycC0+bnVtX2dyb3VwczsgZysrKSB7CiAJCWdyb3VwID0gcDJwLT5ncm91cHNbZ107Ci0JCXAycF9ncm91cF91cGRhdGVfaWVzKGdyb3VwKTsKKwkJcDJwX2dyb3VwX2ZvcmNlX2JlYWNvbl91cGRhdGVfaWVzKGdyb3VwKTsKIAl9CiB9CiAKQEAgLTQ0MzUsMyArNDU2OCwyNTkgQEAKIAl2YV9lbmQoYXApOwogCXAycC0+Y2ZnLT5kZWJ1Z19wcmludChwMnAtPmNmZy0+Y2JfY3R4LCBNU0dfRVJST1IsIGJ1Zik7CiB9CisKKwordm9pZCBwMnBfbG9vcF9vbl9rbm93bl9wZWVycyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCSAgICAgdm9pZCAoKnBlZXJfY2FsbGJhY2spKHN0cnVjdCBwMnBfcGVlcl9pbmZvICpwZWVyLAorCQkJCQkJICAgdm9pZCAqdXNlcl9kYXRhKSwKKwkJCSAgICAgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCBwMnBfZGV2aWNlICpkZXYsICpuOworCisJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKGRldiwgbiwgJnAycC0+ZGV2aWNlcywgc3RydWN0IHAycF9kZXZpY2UsIGxpc3QpIHsKKwkJcGVlcl9jYWxsYmFjaygmZGV2LT5pbmZvLCB1c2VyX2RhdGEpOworCX0KK30KKworCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKworc3RhdGljIHN0cnVjdCB3cGFidWYgKiBwMnBfYnVpbGRfbmZjX2hhbmRvdmVyKHN0cnVjdCBwMnBfZGF0YSAqcDJwLAorCQkJCQkgICAgICBpbnQgY2xpZW50X2ZyZXEsCisJCQkJCSAgICAgIGNvbnN0IHU4ICpnb19kZXZfYWRkciwKKwkJCQkJICAgICAgY29uc3QgdTggKnNzaWQsIHNpemVfdCBzc2lkX2xlbikKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJdTggb3BfY2xhc3MsIGNoYW5uZWw7CisJZW51bSBwMnBfcm9sZV9pbmRpY2F0aW9uIHJvbGUgPSBQMlBfREVWSUNFX05PVF9JTl9HUk9VUDsKKworCWJ1ZiA9IHdwYWJ1Zl9hbGxvYygxMDAwKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJb3BfY2xhc3MgPSBwMnAtPmNmZy0+cmVnX2NsYXNzOworCWNoYW5uZWwgPSBwMnAtPmNmZy0+Y2hhbm5lbDsKKworCXAycF9idWZfYWRkX2NhcGFiaWxpdHkoYnVmLCBwMnAtPmRldl9jYXBhYiAmCisJCQkgICAgICAgflAyUF9ERVZfQ0FQQUJfQ0xJRU5UX0RJU0NPVkVSQUJJTElUWSwgMCk7CisJcDJwX2J1Zl9hZGRfZGV2aWNlX2luZm8oYnVmLCBwMnAsIE5VTEwpOworCisJaWYgKHAycC0+bnVtX2dyb3VwcyA+IDApIHsKKwkJaW50IGZyZXEgPSBwMnBfZ3JvdXBfZ2V0X2ZyZXEocDJwLT5ncm91cHNbMF0pOworCQlyb2xlID0gUDJQX0dPX0lOX0FfR1JPVVA7CisJCWlmIChwMnBfZnJlcV90b19jaGFubmVsKGZyZXEsICZvcF9jbGFzcywgJmNoYW5uZWwpIDwgMCkgeworCQkJcDJwX2RiZyhwMnAsCisJCQkJIlVua25vd24gR08gb3BlcmF0aW5nIGZyZXF1ZW5jeSAlZCBNSHogZm9yIE5GQyBoYW5kb3ZlciIsCisJCQkJZnJlcSk7CisJCQl3cGFidWZfZnJlZShidWYpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwl9IGVsc2UgaWYgKGNsaWVudF9mcmVxID4gMCkgeworCQlyb2xlID0gUDJQX0NMSUVOVF9JTl9BX0dST1VQOworCQlpZiAocDJwX2ZyZXFfdG9fY2hhbm5lbChjbGllbnRfZnJlcSwgJm9wX2NsYXNzLCAmY2hhbm5lbCkgPCAwKSB7CisJCQlwMnBfZGJnKHAycCwKKwkJCQkiVW5rbm93biBjbGllbnQgb3BlcmF0aW5nIGZyZXF1ZW5jeSAlZCBNSHogZm9yIE5GQyBoYW5kb3ZlciIsCisJCQkJY2xpZW50X2ZyZXEpOworCQkJd3BhYnVmX2ZyZWUoYnVmKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJfQorCisJcDJwX2J1Zl9hZGRfb29iX2dvX25lZ19jaGFubmVsKGJ1ZiwgcDJwLT5jZmctPmNvdW50cnksIG9wX2NsYXNzLAorCQkJCSAgICAgICBjaGFubmVsLCByb2xlKTsKKworCWlmIChwMnAtPm51bV9ncm91cHMgPiAwKSB7CisJCS8qIExpbWl0IG51bWJlciBvZiBjbGllbnRzIHRvIGF2b2lkIHZlcnkgbG9uZyBtZXNzYWdlICovCisJCXAycF9idWZfYWRkX2dyb3VwX2luZm8ocDJwLT5ncm91cHNbMF0sIGJ1ZiwgNSk7CisJCXAycF9ncm91cF9idWZfYWRkX2lkKHAycC0+Z3JvdXBzWzBdLCBidWYpOworCX0gZWxzZSBpZiAoY2xpZW50X2ZyZXEgPiAwICYmCisJCSAgIGdvX2Rldl9hZGRyICYmICFpc196ZXJvX2V0aGVyX2FkZHIoZ29fZGV2X2FkZHIpICYmCisJCSAgIHNzaWQgJiYgc3NpZF9sZW4gPiAwKSB7CisJCS8qCisJCSAqIEFkZCB0aGUgb3B0aW9uYWwgUDJQIEdyb3VwIElEIHRvIGluZGljYXRlIGluIHdoaWNoIGdyb3VwIHRoaXMKKwkJICogZGV2aWNlIGlzIGEgUDJQIENsaWVudC4KKwkJICovCisJCXAycF9idWZfYWRkX2dyb3VwX2lkKGJ1ZiwgZ29fZGV2X2FkZHIsIHNzaWQsIHNzaWRfbGVuKTsKKwl9CisKKwlyZXR1cm4gYnVmOworfQorCisKK3N0cnVjdCB3cGFidWYgKiBwMnBfYnVpbGRfbmZjX2hhbmRvdmVyX3JlcShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCQkJICAgaW50IGNsaWVudF9mcmVxLAorCQkJCQkgICBjb25zdCB1OCAqZ29fZGV2X2FkZHIsCisJCQkJCSAgIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pCit7CisJcmV0dXJuIHAycF9idWlsZF9uZmNfaGFuZG92ZXIocDJwLCBjbGllbnRfZnJlcSwgZ29fZGV2X2FkZHIsIHNzaWQsCisJCQkJICAgICAgc3NpZF9sZW4pOworfQorCisKK3N0cnVjdCB3cGFidWYgKiBwMnBfYnVpbGRfbmZjX2hhbmRvdmVyX3NlbChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCQkJICAgaW50IGNsaWVudF9mcmVxLAorCQkJCQkgICBjb25zdCB1OCAqZ29fZGV2X2FkZHIsCisJCQkJCSAgIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pCit7CisJcmV0dXJuIHAycF9idWlsZF9uZmNfaGFuZG92ZXIocDJwLCBjbGllbnRfZnJlcSwgZ29fZGV2X2FkZHIsIHNzaWQsCisJCQkJICAgICAgc3NpZF9sZW4pOworfQorCisKK2ludCBwMnBfcHJvY2Vzc19uZmNfY29ubmVjdGlvbl9oYW5kb3ZlcihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCQkJc3RydWN0IHAycF9uZmNfcGFyYW1zICpwYXJhbXMpCit7CisJc3RydWN0IHAycF9tZXNzYWdlIG1zZzsKKwlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OworCWNvbnN0IHU4ICpwMnBfZGV2X2FkZHI7CisJaW50IGZyZXE7CisJZW51bSBwMnBfcm9sZV9pbmRpY2F0aW9uIHJvbGU7CisKKwlwYXJhbXMtPm5leHRfc3RlcCA9IE5PX0FDVElPTjsKKworCWlmIChwMnBfcGFyc2VfaWVzX3NlcGFyYXRlKHBhcmFtcy0+d3NjX2F0dHIsIHBhcmFtcy0+d3NjX2xlbiwKKwkJCQkgICBwYXJhbXMtPnAycF9hdHRyLCBwYXJhbXMtPnAycF9sZW4sICZtc2cpKSB7CisJCXAycF9kYmcocDJwLCAiRmFpbGVkIHRvIHBhcnNlIFdTQy9QMlAgYXR0cmlidXRlcyBmcm9tIE5GQyIpOworCQlwMnBfcGFyc2VfZnJlZSgmbXNnKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChtc2cucDJwX2RldmljZV9hZGRyKQorCQlwMnBfZGV2X2FkZHIgPSBtc2cucDJwX2RldmljZV9hZGRyOworCWVsc2UgaWYgKG1zZy5kZXZpY2VfaWQpCisJCXAycF9kZXZfYWRkciA9IG1zZy5kZXZpY2VfaWQ7CisJZWxzZSB7CisJCXAycF9kYmcocDJwLCAiSWdub3JlIHNjYW4gZGF0YSB3aXRob3V0IFAyUCBEZXZpY2UgSW5mbyBvciBQMlAgRGV2aWNlIElkIik7CisJCXAycF9wYXJzZV9mcmVlKCZtc2cpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKG1zZy5vb2JfZGV2X3Bhc3N3b3JkKSB7CisJCW9zX21lbWNweShwYXJhbXMtPm9vYl9kZXZfcHcsIG1zZy5vb2JfZGV2X3Bhc3N3b3JkLAorCQkJICBtc2cub29iX2Rldl9wYXNzd29yZF9sZW4pOworCQlwYXJhbXMtPm9vYl9kZXZfcHdfbGVuID0gbXNnLm9vYl9kZXZfcGFzc3dvcmRfbGVuOworCX0KKworCWRldiA9IHAycF9jcmVhdGVfZGV2aWNlKHAycCwgcDJwX2Rldl9hZGRyKTsKKwlpZiAoZGV2ID09IE5VTEwpIHsKKwkJcDJwX3BhcnNlX2ZyZWUoJm1zZyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlwYXJhbXMtPnBlZXIgPSAmZGV2LT5pbmZvOworCisJb3NfZ2V0X3JlbHRpbWUoJmRldi0+bGFzdF9zZWVuKTsKKwlkZXYtPmZsYWdzICY9IH4oUDJQX0RFVl9QUk9CRV9SRVFfT05MWSB8IFAyUF9ERVZfR1JPVVBfQ0xJRU5UX09OTFkpOworCXAycF9jb3B5X3dwc19pbmZvKHAycCwgZGV2LCAwLCAmbXNnKTsKKworCWlmICghbXNnLm9vYl9nb19uZWdfY2hhbm5lbCkgeworCQlwMnBfZGJnKHAycCwgIk9PQiBHTyBOZWdvdGlhdGlvbiBDaGFubmVsIGF0dHJpYnV0ZSBub3QgaW5jbHVkZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChtc2cub29iX2dvX25lZ19jaGFubmVsWzNdID09IDAgJiYKKwkgICAgbXNnLm9vYl9nb19uZWdfY2hhbm5lbFs0XSA9PSAwKQorCQlmcmVxID0gMDsKKwllbHNlCisJCWZyZXEgPSBwMnBfY2hhbm5lbF90b19mcmVxKG1zZy5vb2JfZ29fbmVnX2NoYW5uZWxbM10sCisJCQkJCSAgIG1zZy5vb2JfZ29fbmVnX2NoYW5uZWxbNF0pOworCWlmIChmcmVxIDwgMCkgeworCQlwMnBfZGJnKHAycCwgIlVua25vd24gcGVlciBPT0IgR08gTmVnIGNoYW5uZWwiKTsKKwkJcmV0dXJuIC0xOworCX0KKwlyb2xlID0gbXNnLm9vYl9nb19uZWdfY2hhbm5lbFs1XTsKKworCWlmIChyb2xlID09IFAyUF9HT19JTl9BX0dST1VQKSB7CisJCXAycF9kYmcocDJwLCAiUGVlciBPT0IgR08gb3BlcmF0aW5nIGNoYW5uZWw6ICV1IE1IeiIsIGZyZXEpOworCQlwYXJhbXMtPmdvX2ZyZXEgPSBmcmVxOworCX0gZWxzZSBpZiAocm9sZSA9PSBQMlBfQ0xJRU5UX0lOX0FfR1JPVVApIHsKKwkJcDJwX2RiZyhwMnAsICJQZWVyIChjbGllbnQpIE9PQiBHTyBvcGVyYXRpbmcgY2hhbm5lbDogJXUgTUh6IiwKKwkJCWZyZXEpOworCQlwYXJhbXMtPmdvX2ZyZXEgPSBmcmVxOworCX0gZWxzZQorCQlwMnBfZGJnKHAycCwgIlBlZXIgT09CIEdPIE5lZyBjaGFubmVsOiAldSBNSHoiLCBmcmVxKTsKKwlkZXYtPm9vYl9nb19uZWdfZnJlcSA9IGZyZXE7CisKKwlpZiAoIXBhcmFtcy0+c2VsICYmIHJvbGUgIT0gUDJQX0dPX0lOX0FfR1JPVVApIHsKKwkJZnJlcSA9IHAycF9jaGFubmVsX3RvX2ZyZXEocDJwLT5jZmctPnJlZ19jbGFzcywKKwkJCQkJICAgcDJwLT5jZmctPmNoYW5uZWwpOworCQlpZiAoZnJlcSA8IDApIHsKKwkJCXAycF9kYmcocDJwLCAiT3duIGxpc3RlbiBjaGFubmVsIG5vdCBrbm93biIpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXAycF9kYmcocDJwLCAiVXNlIG93biBMaXN0ZW4gY2hhbm5lbCBhcyBPT0IgR08gTmVnIGNoYW5uZWw6ICV1IE1IeiIsIGZyZXEpOworCQlkZXYtPm9vYl9nb19uZWdfZnJlcSA9IGZyZXE7CisJfQorCisJaWYgKG1zZy5ncm91cF9pZCkgeworCQlvc19tZW1jcHkocGFyYW1zLT5nb19kZXZfYWRkciwgbXNnLmdyb3VwX2lkLCBFVEhfQUxFTik7CisJCXBhcmFtcy0+Z29fc3NpZF9sZW4gPSBtc2cuZ3JvdXBfaWRfbGVuIC0gRVRIX0FMRU47CisJCW9zX21lbWNweShwYXJhbXMtPmdvX3NzaWQsIG1zZy5ncm91cF9pZCArIEVUSF9BTEVOLAorCQkJICBwYXJhbXMtPmdvX3NzaWRfbGVuKTsKKwl9CisKKwlpZiAoZGV2LT5mbGFncyAmIFAyUF9ERVZfVVNFUl9SRUpFQ1RFRCkgeworCQlwMnBfZGJnKHAycCwgIkRvIG5vdCByZXBvcnQgcmVqZWN0ZWQgZGV2aWNlIik7CisJCXAycF9wYXJzZV9mcmVlKCZtc2cpOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAoIShkZXYtPmZsYWdzICYgUDJQX0RFVl9SRVBPUlRFRCkpIHsKKwkJcDJwLT5jZmctPmRldl9mb3VuZChwMnAtPmNmZy0+Y2JfY3R4LCBwMnBfZGV2X2FkZHIsICZkZXYtPmluZm8sCisJCQkJICAgICEoZGV2LT5mbGFncyAmIFAyUF9ERVZfUkVQT1JURURfT05DRSkpOworCQlkZXYtPmZsYWdzIHw9IFAyUF9ERVZfUkVQT1JURUQgfCBQMlBfREVWX1JFUE9SVEVEX09OQ0U7CisJfQorCXAycF9wYXJzZV9mcmVlKCZtc2cpOworCisJaWYgKHJvbGUgPT0gUDJQX0dPX0lOX0FfR1JPVVAgJiYgcDJwLT5udW1fZ3JvdXBzID4gMCkKKwkJcGFyYW1zLT5uZXh0X3N0ZXAgPSBCT1RIX0dPOworCWVsc2UgaWYgKHJvbGUgPT0gUDJQX0dPX0lOX0FfR1JPVVApCisJCXBhcmFtcy0+bmV4dF9zdGVwID0gSk9JTl9HUk9VUDsKKwllbHNlIGlmIChyb2xlID09IFAyUF9DTElFTlRfSU5fQV9HUk9VUCkgeworCQlkZXYtPmZsYWdzIHw9IFAyUF9ERVZfR1JPVVBfQ0xJRU5UX09OTFk7CisJCXBhcmFtcy0+bmV4dF9zdGVwID0gUEVFUl9DTElFTlQ7CisJfSBlbHNlIGlmIChwMnAtPm51bV9ncm91cHMgPiAwKQorCQlwYXJhbXMtPm5leHRfc3RlcCA9IEFVVEhfSk9JTjsKKwllbHNlIGlmIChwYXJhbXMtPnNlbCkKKwkJcGFyYW1zLT5uZXh0X3N0ZXAgPSBJTklUX0dPX05FRzsKKwllbHNlCisJCXBhcmFtcy0+bmV4dF9zdGVwID0gUkVTUF9HT19ORUc7CisKKwlyZXR1cm4gMDsKK30KKworCit2b2lkIHAycF9zZXRfYXV0aG9yaXplZF9vb2JfZGV2X3B3X2lkKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1MTYgZGV2X3B3X2lkLAorCQkJCSAgICAgIGludCBnb19pbnRlbnQsCisJCQkJICAgICAgY29uc3QgdTggKm93bl9pbnRlcmZhY2VfYWRkcikKK3sKKworCXAycC0+YXV0aG9yaXplZF9vb2JfZGV2X3B3X2lkID0gZGV2X3B3X2lkOworCWlmIChkZXZfcHdfaWQgPT0gMCkgeworCQlwMnBfZGJnKHAycCwgIk5GQyBPT0IgUGFzc3dvcmQgdW5hdXRob3JpemVkIGZvciBzdGF0aWMgaGFuZG92ZXIiKTsKKwkJcmV0dXJuOworCX0KKworCXAycF9kYmcocDJwLCAiTkZDIE9PQiBQYXNzd29yZCAoaWQ9JXUpIGF1dGhvcml6ZWQgZm9yIHN0YXRpYyBoYW5kb3ZlciIsCisJCWRldl9wd19pZCk7CisKKwlwMnAtPmdvX2ludGVudCA9IGdvX2ludGVudDsKKwlvc19tZW1jcHkocDJwLT5pbnRlbmRlZF9hZGRyLCBvd25faW50ZXJmYWNlX2FkZHIsIEVUSF9BTEVOKTsKK30KKworI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCisKKworaW50IHAycF9zZXRfcGFzc3BocmFzZV9sZW4oc3RydWN0IHAycF9kYXRhICpwMnAsIHVuc2lnbmVkIGludCBsZW4pCit7CisJaWYgKGxlbiA8IDggfHwgbGVuID4gNjMpCisJCXJldHVybiAtMTsKKwlwMnAtPmNmZy0+cGFzc3BocmFzZV9sZW4gPSBsZW47CisJcmV0dXJuIDA7Cit9CisKKwordm9pZCBwMnBfc2V0X3ZlbmRvcl9lbGVtcyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqKnZlbmRvcl9lbGVtKQoreworCXAycC0+dmVuZG9yX2VsZW0gPSB2ZW5kb3JfZWxlbTsKK30KZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwLmggYi9zcmMvcDJwL3AycC5oCmluZGV4IDdmODQ1YjIuLmRlZTc5ZGYgMTAwNjQ0Ci0tLSBhL3NyYy9wMnAvcDJwLmgKKysrIGIvc3JjL3AycC9wMnAuaApAQCAtOSw2ICs5LDggQEAKICNpZm5kZWYgUDJQX0gKICNkZWZpbmUgUDJQX0gKIAorI2luY2x1ZGUgIndwcy93cHNfZGVmcy5oIgorCiAvKioKICAqIFAyUF9NQVhfUkVHX0NMQVNTRVMgLSBNYXhpbXVtIG51bWJlciBvZiByZWd1bGF0b3J5IGNsYXNzZXMKICAqLwpAQCAtNTAsNyArNTIsNyBAQAogfTsKIAogZW51bSBwMnBfd3BzX21ldGhvZCB7Ci0JV1BTX05PVF9SRUFEWSwgV1BTX1BJTl9ESVNQTEFZLCBXUFNfUElOX0tFWVBBRCwgV1BTX1BCQworCVdQU19OT1RfUkVBRFksIFdQU19QSU5fRElTUExBWSwgV1BTX1BJTl9LRVlQQUQsIFdQU19QQkMsIFdQU19ORkMKIH07CiAKIC8qKgpAQCAtNzcsNiArNzksOCBAQAogCiAJaW50IGh0NDA7CiAKKwlpbnQgdmh0OworCiAJLyoqCiAJICogc3NpZCAtIFNTSUQgb2YgdGhlIGdyb3VwCiAJICovCkBAIC0yMjYsNiArMjMwLDE0IEBACiAJICogd2ZkX3N1YmVsZW1zIC0gV2ktRmkgRGlzcGxheSBzdWJlbGVtZW50cyBmcm9tIFdGRCBJRShzKQogCSAqLwogCXN0cnVjdCB3cGFidWYgKndmZF9zdWJlbGVtczsKKworCS8qKgorCSAqIHZlbmRvcl9lbGVtcyAtIFVucmVjb2duaXplZCB2ZW5kb3IgZWxlbWVudHMKKwkgKgorCSAqIFRoaXMgYnVmZmVyIGluY2x1ZGVzIGFueSBvdGhlciB2ZW5kb3IgZWxlbWVudCB0aGFuIFAyUCwgV1BTLCBhbmQgV0ZECisJICogSUUocykgZnJvbSB0aGUgZnJhbWUgdGhhdCB3YXMgdXNlZCB0byBkaXNjb3ZlciB0aGUgcGVlci4KKwkgKi8KKwlzdHJ1Y3Qgd3BhYnVmICp2ZW5kb3JfZWxlbXM7CiB9OwogCiBlbnVtIHAycF9wcm92X2Rpc2Nfc3RhdHVzIHsKQEAgLTI2Myw2ICsyNzUsMTIgQEAKIAl1OCBjaGFubmVsOwogCiAJLyoqCisJICogY2hhbm5lbF9mb3JjZWQgLSB0aGUgbGlzdGVuIGNoYW5uZWwgd2FzIGZvcmNlZCBieSBjb25maWd1cmF0aW9uCisJICogICAgICAgICAgICAgICAgICBvciBieSBjb250cm9sIGludGVyZmFjZSBhbmQgY2Fubm90IGJlIG92ZXJyaWRkZW4KKwkgKi8KKwl1OCBjaGFubmVsX2ZvcmNlZDsKKworCS8qKgogCSAqIFJlZ3VsYXRvcnkgY2xhc3MgZm9yIG93biBvcGVyYXRpb25hbCBjaGFubmVsCiAJICovCiAJdTggb3BfcmVnX2NsYXNzOwpAQCAtMjg3LDYgKzMwNSwyMCBAQAogCXN0cnVjdCBwMnBfY2hhbm5lbHMgY2hhbm5lbHM7CiAKIAkvKioKKwkgKiBjbGlfY2hhbm5lbHMgLSBBZGRpdGlvbmFsIGNsaWVudCBjaGFubmVscworCSAqCisJICogVGhpcyBsaXN0IG9mIGNoYW5uZWxzIChpZiBhbnkpIHdpbGwgYmUgdXNlZCB3aGVuIGFkdmVydGlzaW5nIGxvY2FsCisJICogY2hhbm5lbHMgZHVyaW5nIEdPIE5lZ290aWF0aW9uIG9yIEludml0YXRpb24gZm9yIHRoZSBjYXNlcyB3aGVyZSB0aGUKKwkgKiBsb2NhbCBlbmQgbWF5IGJlY29tZSB0aGUgY2xpZW50LiBUaGlzIG1heSBhbGxvdyB0aGUgcGVlciB0byBiZWNvbWUgYQorCSAqIEdPIG9uIGFkZGl0aW9uYWwgY2hhbm5lbHMgaWYgaXQgc3VwcG9ydHMgdGhlc2Ugb3B0aW9ucy4gVGhlIG1haW4gdXNlCisJICogY2FzZSBmb3IgdGhpcyBpcyB0byBpbmNsdWRlIHBhc3NpdmUtc2NhbiBjaGFubmVscyBvbiBkZXZpY2VzIHRoYXQgbWF5CisJICogbm90IGtub3cgdGhlaXIgY3VycmVudCBsb2NhdGlvbiBhbmQgaGF2ZSBjb25maWd1cmVkIG1vc3QgY2hhbm5lbHMgdG8KKwkgKiBub3QgYWxsb3cgaW5pdGlhdGlvbiBvZiByYWRpdGlvbiAoaS5lLiwgYW5vdGhlciBkZXZpY2UgbmVlZHMgdG8gdGFrZQorCSAqIG1hc3RlciByZXNwb25zaWJpbGl0aWVzKS4KKwkgKi8KKwlzdHJ1Y3QgcDJwX2NoYW5uZWxzIGNsaV9jaGFubmVsczsKKworCS8qKgogCSAqIG51bV9wcmVmX2NoYW4gLSBOdW1iZXIgb2YgcHJlZl9jaGFuIGVudHJpZXMKIAkgKi8KIAl1bnNpZ25lZCBpbnQgbnVtX3ByZWZfY2hhbjsKQEAgLTM3MSw2ICs0MDMsMTQgQEAKIAl1bnNpZ25lZCBpbnQgbWF4X2xpc3RlbjsKIAogCS8qKgorCSAqIHBhc3NwaHJhc2VfbGVuIC0gUGFzc3BocmFzZSBsZW5ndGggKDguLjYzKQorCSAqCisJICogVGhpcyBwYXJhbWV0ZXIgY29udHJvbHMgdGhlIGxlbmd0aCBvZiB0aGUgcmFuZG9tIHBhc3NwaHJhc2UgdGhhdCBpcworCSAqIGdlbmVyYXRlZCBhdCB0aGUgR08uCisJICovCisJdW5zaWduZWQgaW50IHBhc3NwaHJhc2VfbGVuOworCisJLyoqCiAJICogY2JfY3R4IC0gQ29udGV4dCB0byB1c2Ugd2l0aCBjYWxsYmFjayBmdW5jdGlvbnMKIAkgKi8KIAl2b2lkICpjYl9jdHg7CkBAIC02OTAsNiArNzMwLDggQEAKIAkgKglwZXJzaXN0ZW50IGdyb3VwIChpbnN0ZWFkIG9mIGludml0YXRpb24gdG8gam9pbiBhbiBhY3RpdmUKIAkgKglncm91cCkKIAkgKiBAY2hhbm5lbHM6IEF2YWlsYWJsZSBvcGVyYXRpbmcgY2hhbm5lbHMgZm9yIHRoZSBncm91cAorCSAqIEBkZXZfcHdfaWQ6IERldmljZSBQYXNzd29yZCBJRCBmb3IgTkZDIHN0YXRpYyBoYW5kb3ZlciBvciAtMSBpZiBub3QKKwkgKgl1c2VkCiAJICogUmV0dXJuczogU3RhdHVzIGNvZGUgKFAyUF9TQ18qKQogCSAqCiAJICogVGhpcyBvcHRpb25hbCBjYWxsYmFjayBjYW4gYmUgdXNlZCB0byBpbXBsZW1lbnQgcGVyc2lzdGVudCByZWNvbm5lY3QKQEAgLTcxMSw3ICs3NTMsOCBAQAogCQkJCSBjb25zdCB1OCAqZ29fZGV2X2FkZHIsIGNvbnN0IHU4ICpzc2lkLAogCQkJCSBzaXplX3Qgc3NpZF9sZW4sIGludCAqZ28sIHU4ICpncm91cF9ic3NpZCwKIAkJCQkgaW50ICpmb3JjZV9mcmVxLCBpbnQgcGVyc2lzdGVudF9ncm91cCwKLQkJCQkgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2hhbm5lbHMpOworCQkJCSBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscywKKwkJCQkgaW50IGRldl9wd19pZCk7CiAKIAkvKioKIAkgKiBpbnZpdGF0aW9uX3JlY2VpdmVkIC0gQ2FsbGJhY2sgb24gSW52aXRhdGlvbiBSZXF1ZXN0IFJYCkBAIC03NDIsNiArNzg1LDkgQEAKIAkgKiBAYnNzaWQ6IFAyUCBHcm91cCBCU1NJRCBvciAlTlVMTCBpZiBub3QgcmVjZWl2ZWQKIAkgKiBAY2hhbm5lbHM6IEF2YWlsYWJsZSBvcGVyYXRpbmcgY2hhbm5lbHMgZm9yIHRoZSBncm91cAogCSAqIEBhZGRyOiBQZWVyIGFkZHJlc3MKKwkgKiBAZnJlcTogRnJlcXVlbmN5IChpbiBNSHopIGluZGljYXRlZCBkdXJpbmcgaW52aXRhdGlvbiBvciAwCisJICogQHBlZXJfb3Blcl9mcmVxOiBPcGVyYXRpbmcgZnJlcXVlbmN5IChpbiBNSHopIGFkdmVydGl6ZWQgYnkgdGhlIHBlZXIKKwkgKiBkdXJpbmcgaW52aXRhdGlvbiBvciAwCiAJICoKIAkgKiBUaGlzIGNhbGxiYWNrIGlzIHVzZWQgdG8gaW5kaWNhdGUgcmVzdWx0IG9mIGFuIEludml0YXRpb24gcHJvY2VkdXJlCiAJICogc3RhcnRlZCB3aXRoIGEgY2FsbCB0byBwMnBfaW52aXRlKCkuIFRoZSBpbmRpY2F0ZWQgc3RhdHVzIGNvZGUgaXMKQEAgLTc1MSw3ICs3OTcsNyBAQAogCSAqLwogCXZvaWQgKCppbnZpdGF0aW9uX3Jlc3VsdCkodm9pZCAqY3R4LCBpbnQgc3RhdHVzLCBjb25zdCB1OCAqYnNzaWQsCiAJCQkJICBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscywKLQkJCQkgIGNvbnN0IHU4ICphZGRyKTsKKwkJCQkgIGNvbnN0IHU4ICphZGRyLCBpbnQgZnJlcSwgaW50IHBlZXJfb3Blcl9mcmVxKTsKIAogCS8qKgogCSAqIGdvX2Nvbm5lY3RlZCAtIENoZWNrIHdoZXRoZXIgd2UgYXJlIGNvbm5lY3RlZCB0byBhIEdPCkBAIC03NjEsNiArODA3LDM0IEBACiAJICogb3IgMCBpZiBub3QuCiAJICovCiAJaW50ICgqZ29fY29ubmVjdGVkKSh2b2lkICpjdHgsIGNvbnN0IHU4ICpkZXZfYWRkcik7CisKKwkvKioKKwkgKiBwcmVzZW5jZV9yZXNwIC0gQ2FsbGJhY2sgb24gUHJlc2VuY2UgUmVzcG9uc2UKKwkgKiBAY3R4OiBDYWxsYmFjayBjb250ZXh0IGZyb20gY2JfY3R4CisJICogQHNyYzogU291cmNlIGFkZHJlc3MgKEdPJ3MgUDJQIEludGVyZmFjZSBBZGRyZXNzKQorCSAqIEBzdGF0dXM6IFJlc3VsdCBvZiB0aGUgcmVxdWVzdCAoUDJQX1NDXyopCisJICogQG5vYTogUmV0dXJuZWQgTm9BIHZhbHVlCisJICogQG5vYV9sZW46IExlbmd0aCBvZiB0aGUgTm9BIGJ1ZmZlciBpbiBvY3RldHMKKwkgKi8KKwl2b2lkICgqcHJlc2VuY2VfcmVzcCkodm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjLCB1OCBzdGF0dXMsCisJCQkgICAgICBjb25zdCB1OCAqbm9hLCBzaXplX3Qgbm9hX2xlbik7CisKKwkvKioKKwkgKiBpc19jb25jdXJyZW50X3Nlc3Npb25fYWN0aXZlIC0gQ2hlY2sgd2hldGhlciBjb25jdXJyZW50IHNlc3Npb24gaXMKKwkgKiBhY3RpdmUgb24gb3RoZXIgdmlydHVhbCBpbnRlcmZhY2VzCisJICogQGN0eDogQ2FsbGJhY2sgY29udGV4dCBmcm9tIGNiX2N0eAorCSAqIFJldHVybnM6IDEgaWYgY29uY3VycmVudCBzZXNzaW9uIGlzIGFjdGl2ZSBvbiBvdGhlciB2aXJ0dWFsIGludGVyZmFjZQorCSAqIG9yIDAgaWYgbm90LgorCSAqLworCWludCAoKmlzX2NvbmN1cnJlbnRfc2Vzc2lvbl9hY3RpdmUpKHZvaWQgKmN0eCk7CisKKwkvKioKKwkgKiBpc19wMnBfaW5fcHJvZ3Jlc3MgLSBDaGVjayB3aGV0aGVyIFAyUCBvcGVyYXRpb24gaXMgaW4gcHJvZ3Jlc3MKKwkgKiBAY3R4OiBDYWxsYmFjayBjb250ZXh0IGZyb20gY2JfY3R4CisJICogUmV0dXJuczogMSBpZiBQMlAgb3BlcmF0aW9uIChlLmcuLCBncm91cCBmb3JtYXRpb24pIGlzIGluIHByb2dyZXNzCisJICogb3IgMCBpZiBub3QuCisJICovCisJaW50ICgqaXNfcDJwX2luX3Byb2dyZXNzKSh2b2lkICpjdHgpOwogfTsKIAogCkBAIC05MzUsNyArMTAwOSw3IEBACiAJCWludCBnb19pbnRlbnQsIGNvbnN0IHU4ICpvd25faW50ZXJmYWNlX2FkZHIsCiAJCXVuc2lnbmVkIGludCBmb3JjZV9mcmVxLCBpbnQgcGVyc2lzdGVudF9ncm91cCwKIAkJY29uc3QgdTggKmZvcmNlX3NzaWQsIHNpemVfdCBmb3JjZV9zc2lkX2xlbiwKLQkJaW50IHBkX2JlZm9yZV9nb19uZWcsIHVuc2lnbmVkIGludCBwcmVmX2ZyZXEpOworCQlpbnQgcGRfYmVmb3JlX2dvX25lZywgdW5zaWduZWQgaW50IHByZWZfZnJlcSwgdTE2IG9vYl9wd19pZCk7CiAKIC8qKgogICogcDJwX2F1dGhvcml6ZSAtIEF1dGhvcml6ZSBQMlAgZ3JvdXAgZm9ybWF0aW9uIChHTyBuZWdvdGlhdGlvbikKQEAgLTk2Myw3ICsxMDM3LDcgQEAKIAkJICBpbnQgZ29faW50ZW50LCBjb25zdCB1OCAqb3duX2ludGVyZmFjZV9hZGRyLAogCQkgIHVuc2lnbmVkIGludCBmb3JjZV9mcmVxLCBpbnQgcGVyc2lzdGVudF9ncm91cCwKIAkJICBjb25zdCB1OCAqZm9yY2Vfc3NpZCwgc2l6ZV90IGZvcmNlX3NzaWRfbGVuLAotCQkgIHVuc2lnbmVkIGludCBwcmVmX2ZyZXEpOworCQkgIHVuc2lnbmVkIGludCBwcmVmX2ZyZXEsIHUxNiBvb2JfcHdfaWQpOwogCiAvKioKICAqIHAycF9yZWplY3QgLSBSZWplY3QgcGVlciBkZXZpY2UgKGV4cGxpY2l0bHkgYmxvY2sgY29ubmVjdGlvbiBhdHRlbXB0cykKQEAgLTEwNjUsMTIgKzExMzksMTQgQEAKICAqIEBwZXJzaXN0ZW50X2dyb3VwOiBXaGV0aGVyIHRoaXMgaXMgdG8gcmVpbnZva2UgYSBwZXJzaXN0ZW50IGdyb3VwCiAgKiBAcHJlZl9mcmVxOiBQcmVmZXJyZWQgb3BlcmF0aW5nIGZyZXF1ZW5jeSBpbiBNSHogb3IgMCAodGhpcyBpcyBvbmx5IHVzZWQgaWYKICAqCWZvcmNlX2ZyZXEgPT0gMCkKKyAqIEBkZXZfcHdfaWQ6IERldmljZSBQYXNzd29yZCBJRCBmcm9tIE9PQiBEZXZpY2UgUGFzc3dvcmQgKE5GQykgc3RhdGljIGhhbmRvdmVyCisgKgljYXNlIG9yIC0xIGlmIG5vdCB1c2VkCiAgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKICAqLwogaW50IHAycF9pbnZpdGUoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICpwZWVyLCBlbnVtIHAycF9pbnZpdGVfcm9sZSByb2xlLAogCSAgICAgICBjb25zdCB1OCAqYnNzaWQsIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4sCiAJICAgICAgIHVuc2lnbmVkIGludCBmb3JjZV9mcmVxLCBjb25zdCB1OCAqZ29fZGV2X2FkZHIsCi0JICAgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwLCB1bnNpZ25lZCBpbnQgcHJlZl9mcmVxKTsKKwkgICAgICAgaW50IHBlcnNpc3RlbnRfZ3JvdXAsIHVuc2lnbmVkIGludCBwcmVmX2ZyZXEsIGludCBkZXZfcHdfaWQpOwogCiAvKioKICAqIHAycF9wcmVzZW5jZV9yZXEgLSBSZXF1ZXN0IEdPIHByZXNlbmNlCkBAIC0xMjI4LDcgKzEzMDQsNyBAQAogICogc3RhcnQgb2YgYSBwZW5kaW5nIG9wZXJhdGlvbiwgZS5nLiwgdG8gc3RhcnQgYSBwZW5kaW5nIEdPIG5lZ290aWF0aW9uLgogICovCiBpbnQgcDJwX3NjYW5fcmVzX2hhbmRsZXIoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICpic3NpZCwgaW50IGZyZXEsCi0JCQkgc3RydWN0IG9zX3RpbWUgKnJ4X3RpbWUsIGludCBsZXZlbCwgY29uc3QgdTggKmllcywKKwkJCSBzdHJ1Y3Qgb3NfcmVsdGltZSAqcnhfdGltZSwgaW50IGxldmVsLCBjb25zdCB1OCAqaWVzLAogCQkJIHNpemVfdCBpZXNfbGVuKTsKIAogLyoqCkBAIC0xMzM1LDYgKzE0MTEsMTEgQEAKIAlzaXplX3Qgc3NpZF9sZW47CiAKIAkvKioKKwkgKiBmcmVxIC0gT3BlcmF0aW5nIGNoYW5uZWwgb2YgdGhlIGdyb3VwCisJICovCisJaW50IGZyZXE7CisKKwkvKioKIAkgKiBjYl9jdHggLSBDb250ZXh0IHRvIHVzZSB3aXRoIGNhbGxiYWNrIGZ1bmN0aW9ucwogCSAqLwogCXZvaWQgKmNiX2N0eDsKQEAgLTE2MTAsNyArMTY5MSwxMCBAQAogICovCiB2b2lkIHAycF9zZXRfbWFuYWdlZF9vcGVyKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBpbnQgZW5hYmxlZCk7CiAKLWludCBwMnBfc2V0X2xpc3Rlbl9jaGFubmVsKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1OCByZWdfY2xhc3MsIHU4IGNoYW5uZWwpOworaW50IHAycF9zZXRfbGlzdGVuX2NoYW5uZWwoc3RydWN0IHAycF9kYXRhICpwMnAsIHU4IHJlZ19jbGFzcywgdTggY2hhbm5lbCwKKwkJCSAgIHU4IGZvcmNlZCk7CisKK3U4IHAycF9nZXRfbGlzdGVuX2NoYW5uZWwoc3RydWN0IHAycF9kYXRhICpwMnApOwogCiBpbnQgcDJwX3NldF9zc2lkX3Bvc3RmaXgoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICpwb3N0Zml4LCBzaXplX3QgbGVuKTsKIApAQCAtMTY0OSw2ICsxNzMzLDIyIEBACiBpbnQgcDJwX3N1cHBvcnRlZF9mcmVxKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1bnNpZ25lZCBpbnQgZnJlcSk7CiAKIC8qKgorICogcDJwX3N1cHBvcnRlZF9mcmVxX2dvIC0gQ2hlY2sgd2hldGhlciBjaGFubmVsIGlzIHN1cHBvcnRlZCBmb3IgUDJQIEdPIG9wZXJhdGlvbgorICogQHAycDogUDJQIG1vZHVsZSBjb250ZXh0IGZyb20gcDJwX2luaXQoKQorICogQGZyZXE6IENoYW5uZWwgZnJlcXVlbmN5IGluIE1IegorICogUmV0dXJuczogMCBpZiBjaGFubmVsIG5vdCB1c2FibGUgZm9yIFAyUCwgMSBpZiB1c2FibGUgZm9yIFAyUAorICovCitpbnQgcDJwX3N1cHBvcnRlZF9mcmVxX2dvKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1bnNpZ25lZCBpbnQgZnJlcSk7CisKKy8qKgorICogcDJwX3N1cHBvcnRlZF9mcmVxX2NsaSAtIENoZWNrIHdoZXRoZXIgY2hhbm5lbCBpcyBzdXBwb3J0ZWQgZm9yIFAyUCBjbGllbnQgb3BlcmF0aW9uCisgKiBAcDJwOiBQMlAgbW9kdWxlIGNvbnRleHQgZnJvbSBwMnBfaW5pdCgpCisgKiBAZnJlcTogQ2hhbm5lbCBmcmVxdWVuY3kgaW4gTUh6CisgKiBSZXR1cm5zOiAwIGlmIGNoYW5uZWwgbm90IHVzYWJsZSBmb3IgUDJQLCAxIGlmIHVzYWJsZSBmb3IgUDJQCisgKi8KK2ludCBwMnBfc3VwcG9ydGVkX2ZyZXFfY2xpKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1bnNpZ25lZCBpbnQgZnJlcSk7CisKKy8qKgogICogcDJwX2dldF9wcmVmX2ZyZXEgLSBHZXQgY2hhbm5lbCBmcm9tIHByZWZlcnJlZCBjaGFubmVsIGxpc3QKICAqIEBwMnA6IFAyUCBtb2R1bGUgY29udGV4dCBmcm9tIHAycF9pbml0KCkKICAqIEBjaGFubmVsczogTGlzdCBvZiBjaGFubmVscwpAQCAtMTY1Nyw3ICsxNzU3LDkgQEAKIHVuc2lnbmVkIGludCBwMnBfZ2V0X3ByZWZfZnJlcShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKIAkJCSAgICAgICBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscyk7CiAKLXZvaWQgcDJwX3VwZGF0ZV9jaGFubmVsX2xpc3Qoc3RydWN0IHAycF9kYXRhICpwMnAsIHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW4pOwordm9pZCBwMnBfdXBkYXRlX2NoYW5uZWxfbGlzdChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCSAgICAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2hhbiwKKwkJCSAgICAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2xpX2NoYW4pOwogCiAvKioKICAqIHAycF9zZXRfYmVzdF9jaGFubmVscyAtIFVwZGF0ZSBiZXN0IGNoYW5uZWwgaW5mb3JtYXRpb24KQEAgLTE2OTQsNyArMTc5Niw3IEBACiAgKiBAZ3JvdXA6IFAyUCBncm91cCBjb250ZXh0IGZyb20gcDJwX2dyb3VwX2luaXQoKQogICogQG5leHQ6IGl0ZXJhdGlvbiBwb2ludGVyLCBtdXN0IGJlIGEgcG9pbnRlciB0byBhIHZvaWQgKiB0aGF0IGlzIHNldCB0byAlTlVMTAogICoJb24gdGhlIGZpcnN0IGNhbGwgYW5kIG5vdCBtb2RpZmllZCBsYXRlcgotICogUmV0dXJuczogQSBQMlAgSW50ZXJmYWNlIEFkZHJlc3MgZm9yIGVhY2ggY2FsbCBhbmQgJU5VTEwgZm9yIG5vIG1vcmUgbWVtYmVycworICogUmV0dXJuczogQSBQMlAgRGV2aWNlIEFkZHJlc3MgZm9yIGVhY2ggY2FsbCBhbmQgJU5VTEwgZm9yIG5vIG1vcmUgbWVtYmVycwogICovCiBjb25zdCB1OCAqIHAycF9pdGVyYXRlX2dyb3VwX21lbWJlcnMoc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsIHZvaWQgKipuZXh0KTsKIApAQCAtMTcxNiw2ICsxODE4LDI2IEBACiBpbnQgcDJwX2dyb3VwX2lzX2NsaWVudF9jb25uZWN0ZWQoc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsIGNvbnN0IHU4ICpkZXZfYWRkcik7CiAKIC8qKgorICogcDJwX2dyb3VwX2dldF9jb25maWcgLSBHZXQgdGhlIGdyb3VwIGNvbmZpZ3VyYXRpb24KKyAqIEBncm91cDogUDJQIGdyb3VwIGNvbnRleHQgZnJvbSBwMnBfZ3JvdXBfaW5pdCgpCisgKiBSZXR1cm5zOiBUaGUgZ3JvdXAgY29uZmlndXJhdGlvbiBwb2ludGVyCisgKi8KK2NvbnN0IHN0cnVjdCBwMnBfZ3JvdXBfY29uZmlnICogcDJwX2dyb3VwX2dldF9jb25maWcoc3RydWN0IHAycF9ncm91cCAqZ3JvdXApOworCisvKioKKyAqIHAycF9sb29wX29uX2FsbF9ncm91cHMgLSBSdW4gdGhlIGdpdmVuIGNhbGxiYWNrIG9uIGFsbCBncm91cHMKKyAqIEBwMnA6IFAyUCBtb2R1bGUgY29udGV4dCBmcm9tIHAycF9pbml0KCkKKyAqIEBncm91cF9jYWxsYmFjazogVGhlIGNhbGxiYWNrIGZ1bmN0aW9uIHBvaW50ZXIKKyAqIEB1c2VyX2RhdGE6IFNvbWUgdXNlciBkYXRhIHBvaW50ZXIgd2hpY2ggY2FuIGJlICVOVUxMCisgKgorICogVGhlIGdyb3VwX2NhbGxiYWNrIGZ1bmN0aW9uIGNhbiBzdG9wIHRoZSBpdGVyYXRpb24gYnkgcmV0dXJuaW5nIDAuCisgKi8KK3ZvaWQgcDJwX2xvb3Bfb25fYWxsX2dyb3VwcyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCSAgICBpbnQgKCpncm91cF9jYWxsYmFjaykoc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsCisJCQkJCQkgIHZvaWQgKnVzZXJfZGF0YSksCisJCQkgICAgdm9pZCAqdXNlcl9kYXRhKTsKKworLyoqCiAgKiBwMnBfZ2V0X3BlZXJfZm91bmQgLSBHZXQgUDJQIHBlZXIgaW5mbyBzdHJ1Y3R1cmUgb2YgYSBmb3VuZCBwZWVyCiAgKiBAcDJwOiBQMlAgbW9kdWxlIGNvbnRleHQgZnJvbSBwMnBfaW5pdCgpCiAgKiBAYWRkcjogUDJQIERldmljZSBBZGRyZXNzIG9mIHRoZSBwZWVyIG9yICVOVUxMIHRvIGluZGljYXRlIHRoZSBmaXJzdCBwZWVyCkBAIC0xNzY1LDM1ICsxODg3LDIxIEBACiAJCSAgICAgIGNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbCAqcHJlZl9jaGFuKTsKIAogLyoqCisgKiBwMnBfc2V0X25vX2dvX2ZyZXEgLSBTZXQgbm8gR08gY2hhbm5lbCByYW5nZXMKKyAqIEBwMnA6IFAyUCBtb2R1bGUgY29udGV4dCBmcm9tIHAycF9pbml0KCkKKyAqIEBsaXN0OiBDaGFubmVsIHJhbmdlcyBvciAlTlVMTCB0byByZW1vdmUgcmVzdHJpY3Rpb24KKyAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorICovCitpbnQgcDJwX3NldF9ub19nb19mcmVxKHN0cnVjdCBwMnBfZGF0YSAqcDJwLAorCQkgICAgICAgY29uc3Qgc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3QgKmxpc3QpOworCisvKioKICAqIHAycF9pbl9wcm9ncmVzcyAtIENoZWNrIHdoZXRoZXIgYSBQMlAgb3BlcmF0aW9uIGlzIHByb2dyZXNzCiAgKiBAcDJwOiBQMlAgbW9kdWxlIGNvbnRleHQgZnJvbSBwMnBfaW5pdCgpCiAgKiBSZXR1cm5zOiAwIGlmIFAyUCBtb2R1bGUgaXMgaWRsZSBvciAxIGlmIGFuIG9wZXJhdGlvbiBpcyBpbiBwcm9ncmVzcwogICovCiBpbnQgcDJwX2luX3Byb2dyZXNzKHN0cnVjdCBwMnBfZGF0YSAqcDJwKTsKIAotI2lmZGVmIEFORFJPSURfUDJQCi0vKioKLSAqIHAycF9zZWFyY2hfaW5fcHJvZ3Jlc3MgLSBDaGVjayB3aGV0aGVyIGEgUDJQIFNFQVJDSCBpcyBpbiBwcm9ncmVzcwotICogQHAycDogUDJQIG1vZHVsZSBjb250ZXh0IGZyb20gcDJwX2luaXQoKQotICogUmV0dXJuczogMCBpZiBQMlAgbW9kdWxlIGlzIGlkbGUgb3IgMSBpZiBhbiBvcGVyYXRpb24gaXMgaW4gcHJvZ3Jlc3MKLSAqLwotaW50IHAycF9zZWFyY2hfaW5fcHJvZ3Jlc3Moc3RydWN0IHAycF9kYXRhICpwMnApOwotCi0vKioKLSAqIHAycF9zZWFyY2hfcGVuZGluZyAtIENoZWNrIHdoZXRoZXIgdGhlcmUgaXMgYSBkZWZlcnJlZCBQMlAgU0VBUkNICi0gKiBAcDJwOiBQMlAgbW9kdWxlIGNvbnRleHQgZnJvbSBwMnBfaW5pdCgpCi0gKiBSZXR1cm5zOiAwIGlmIHRoZXJlIGlzIG5vIGRlZmVycmVkIFAyUCBzZWFyY2ggb3IgMSBpZiB0aGVyZSBpcyBvbmUKLSAqLwotaW50IHAycF9zZWFyY2hfcGVuZGluZyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCk7Ci0jZW5kaWYKLQotLyoqCi0gKiBwMnBfb3RoZXJfc2Nhbl9jb21wbGV0ZWQgLSBOb3RpZnkgY29tcGxldGlvbiBvZiBub24tUDJQIHNjYW4KLSAqIEBwMnA6IFAyUCBtb2R1bGUgY29udGV4dCBmcm9tIHAycF9pbml0KCkKLSAqIFJldHVybnM6IDAgaWYgUDJQIG1vZHVsZSBpcyBpZGxlIG9yIDEgaWYgYW4gb3BlcmF0aW9uIHdhcyBzdGFydGVkCi0gKi8KLWludCBwMnBfb3RoZXJfc2Nhbl9jb21wbGV0ZWQoc3RydWN0IHAycF9kYXRhICpwMnApOwotCiBjb25zdCBjaGFyICogcDJwX3dwc19tZXRob2RfdGV4dChlbnVtIHAycF93cHNfbWV0aG9kIG1ldGhvZCk7CiAKIC8qKgpAQCAtMTgwNSw4ICsxOTEzLDYgQEAKIHZvaWQgcDJwX3NldF9jb25maWdfdGltZW91dChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgdTggZ29fdGltZW91dCwKIAkJCSAgICB1OCBjbGllbnRfdGltZW91dCk7CiAKLXZvaWQgcDJwX2luY3JlYXNlX3NlYXJjaF9kZWxheShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgdW5zaWduZWQgaW50IGRlbGF5KTsKLQogaW50IHAycF9zZXRfd2ZkX2llX2JlYWNvbihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqaWUpOwogaW50IHAycF9zZXRfd2ZkX2llX3Byb2JlX3JlcShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqaWUpOwogaW50IHAycF9zZXRfd2ZkX2llX3Byb2JlX3Jlc3Aoc3RydWN0IHAycF9kYXRhICpwMnAsIHN0cnVjdCB3cGFidWYgKmllKTsKQEAgLTE4NTMsNCArMTk1OSw1MCBAQAogICovCiBjb25zdCBjaGFyICogcDJwX2dldF9zdGF0ZV90eHQoc3RydWN0IHAycF9kYXRhICpwMnApOwogCitzdHJ1Y3Qgd3BhYnVmICogcDJwX2J1aWxkX25mY19oYW5kb3Zlcl9yZXEoc3RydWN0IHAycF9kYXRhICpwMnAsCisJCQkJCSAgIGludCBjbGllbnRfZnJlcSwKKwkJCQkJICAgY29uc3QgdTggKmdvX2Rldl9hZGRyLAorCQkJCQkgICBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuKTsKK3N0cnVjdCB3cGFidWYgKiBwMnBfYnVpbGRfbmZjX2hhbmRvdmVyX3NlbChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCQkJICAgaW50IGNsaWVudF9mcmVxLAorCQkJCQkgICBjb25zdCB1OCAqZ29fZGV2X2FkZHIsCisJCQkJCSAgIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pOworCitzdHJ1Y3QgcDJwX25mY19wYXJhbXMgeworCWludCBzZWw7CisJY29uc3QgdTggKndzY19hdHRyOworCXNpemVfdCB3c2NfbGVuOworCWNvbnN0IHU4ICpwMnBfYXR0cjsKKwlzaXplX3QgcDJwX2xlbjsKKworCWVudW0geworCQlOT19BQ1RJT04sIEpPSU5fR1JPVVAsIEFVVEhfSk9JTiwgSU5JVF9HT19ORUcsIFJFU1BfR09fTkVHLAorCQlCT1RIX0dPLCBQRUVSX0NMSUVOVAorCX0gbmV4dF9zdGVwOworCXN0cnVjdCBwMnBfcGVlcl9pbmZvICpwZWVyOworCXU4IG9vYl9kZXZfcHdbV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gKyAyICsKKwkJICAgICAgV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOXTsKKwlzaXplX3Qgb29iX2Rldl9wd19sZW47CisJaW50IGdvX2ZyZXE7CisJdTggZ29fZGV2X2FkZHJbRVRIX0FMRU5dOworCXU4IGdvX3NzaWRbMzJdOworCXNpemVfdCBnb19zc2lkX2xlbjsKK307CisKK2ludCBwMnBfcHJvY2Vzc19uZmNfY29ubmVjdGlvbl9oYW5kb3ZlcihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCQkJc3RydWN0IHAycF9uZmNfcGFyYW1zICpwYXJhbXMpOworCit2b2lkIHAycF9zZXRfYXV0aG9yaXplZF9vb2JfZGV2X3B3X2lkKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1MTYgZGV2X3B3X2lkLAorCQkJCSAgICAgIGludCBnb19pbnRlbnQsCisJCQkJICAgICAgY29uc3QgdTggKm93bl9pbnRlcmZhY2VfYWRkcik7CisKK2ludCBwMnBfc2V0X3Bhc3NwaHJhc2VfbGVuKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1bnNpZ25lZCBpbnQgbGVuKTsKKwordm9pZCBwMnBfbG9vcF9vbl9rbm93bl9wZWVycyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKKwkJCSAgICAgdm9pZCAoKnBlZXJfY2FsbGJhY2spKHN0cnVjdCBwMnBfcGVlcl9pbmZvICpwZWVyLAorCQkJCQkJICAgdm9pZCAqdXNlcl9kYXRhKSwKKwkJCSAgICAgdm9pZCAqdXNlcl9kYXRhKTsKKwordm9pZCBwMnBfc2V0X3ZlbmRvcl9lbGVtcyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqKnZlbmRvcl9lbGVtKTsKKwogI2VuZGlmIC8qIFAyUF9IICovCmRpZmYgLS1naXQgYS9zcmMvcDJwL3AycF9idWlsZC5jIGIvc3JjL3AycC9wMnBfYnVpbGQuYwppbmRleCA1ODM4ZDM1Li5lOWI2ODNkIDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9idWlsZC5jCisrKyBiL3NyYy9wMnAvcDJwX2J1aWxkLmMKQEAgLTE3LDggKzE3LDcgQEAKIHZvaWQgcDJwX2J1Zl9hZGRfYWN0aW9uX2hkcihzdHJ1Y3Qgd3BhYnVmICpidWYsIHU4IHN1YnR5cGUsIHU4IGRpYWxvZ190b2tlbikKIHsKIAl3cGFidWZfcHV0X3U4KGJ1ZiwgV0xBTl9BQ1RJT05fVkVORE9SX1NQRUNJRklDKTsKLQl3cGFidWZfcHV0X2JlMjQoYnVmLCBPVUlfV0ZBKTsKLQl3cGFidWZfcHV0X3U4KGJ1ZiwgUDJQX09VSV9UWVBFKTsKKwl3cGFidWZfcHV0X2JlMzIoYnVmLCBQMlBfSUVfVkVORE9SX1RZUEUpOwogCiAJd3BhYnVmX3B1dF91OChidWYsIHN1YnR5cGUpOyAvKiBPVUkgU3VidHlwZSAqLwogCXdwYWJ1Zl9wdXRfdTgoYnVmLCBkaWFsb2dfdG9rZW4pOwpAQCAtMzEsOCArMzAsNyBAQAogewogCXdwYWJ1Zl9wdXRfdTgoYnVmLCBXTEFOX0FDVElPTl9QVUJMSUMpOwogCXdwYWJ1Zl9wdXRfdTgoYnVmLCBXTEFOX1BBX1ZFTkRPUl9TUEVDSUZJQyk7Ci0Jd3BhYnVmX3B1dF9iZTI0KGJ1ZiwgT1VJX1dGQSk7Ci0Jd3BhYnVmX3B1dF91OChidWYsIFAyUF9PVUlfVFlQRSk7CisJd3BhYnVmX3B1dF9iZTMyKGJ1ZiwgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKIAogCXdwYWJ1Zl9wdXRfdTgoYnVmLCBzdWJ0eXBlKTsgLyogT1VJIFN1YnR5cGUgKi8KIAl3cGFidWZfcHV0X3U4KGJ1ZiwgZGlhbG9nX3Rva2VuKTsKQEAgLTQ3LDggKzQ1LDcgQEAKIAkvKiBQMlAgSUUgaGVhZGVyICovCiAJd3BhYnVmX3B1dF91OChidWYsIFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQyk7CiAJbGVuID0gd3BhYnVmX3B1dChidWYsIDEpOyAvKiBJRSBsZW5ndGggdG8gYmUgZmlsbGVkICovCi0Jd3BhYnVmX3B1dF9iZTI0KGJ1ZiwgT1VJX1dGQSk7Ci0Jd3BhYnVmX3B1dF91OChidWYsIFAyUF9PVUlfVFlQRSk7CisJd3BhYnVmX3B1dF9iZTMyKGJ1ZiwgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogKiBQMlAgSUUgaGVhZGVyIik7CiAJcmV0dXJuIGxlbjsKIH0KQEAgLTI1OCw2ICsyNTUsNyBAQAogCXdwYWJ1Zl9wdXRfZGF0YShidWYsIHNzaWQsIHNzaWRfbGVuKTsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogKiBQMlAgR3JvdXAgSUQgIiBNQUNTVFIsCiAJCSAgIE1BQzJTVFIoZGV2X2FkZHIpKTsKKwl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJQMlA6IFAyUCBHcm91cCBJRCBTU0lEIiwgc3NpZCwgc3NpZF9sZW4pOwogfQogCiAKQEAgLTMyNywxMyArMzI1LDMyIEBACiB9CiAKIAotc3RhdGljIHZvaWQgcDJwX2FkZF93cHNfc3RyaW5nKHN0cnVjdCB3cGFidWYgKmJ1ZiwgZW51bSB3cHNfYXR0cmlidXRlIGF0dHIsCi0JCQkgICAgICAgY29uc3QgY2hhciAqdmFsKQordm9pZCBwMnBfYnVmX2FkZF9vb2JfZ29fbmVnX2NoYW5uZWwoc3RydWN0IHdwYWJ1ZiAqYnVmLCBjb25zdCBjaGFyICpjb3VudHJ5LAorCQkJCSAgICB1OCBvcGVyX2NsYXNzLCB1OCBjaGFubmVsLAorCQkJCSAgICBlbnVtIHAycF9yb2xlX2luZGljYXRpb24gcm9sZSkKK3sKKwkvKiBPT0IgR3JvdXAgT3duZXIgTmVnb3RpYXRpb24gQ2hhbm5lbCAqLworCXdwYWJ1Zl9wdXRfdTgoYnVmLCBQMlBfQVRUUl9PT0JfR09fTkVHX0NIQU5ORUwpOworCXdwYWJ1Zl9wdXRfbGUxNihidWYsIDYpOworCXdwYWJ1Zl9wdXRfZGF0YShidWYsIGNvdW50cnksIDMpOworCXdwYWJ1Zl9wdXRfdTgoYnVmLCBvcGVyX2NsYXNzKTsgLyogT3BlcmF0aW5nIENsYXNzICovCisJd3BhYnVmX3B1dF91OChidWYsIGNoYW5uZWwpOyAvKiBDaGFubmVsIE51bWJlciAqLworCXdwYWJ1Zl9wdXRfdTgoYnVmLCAodTgpIHJvbGUpOyAvKiBSb2xlIGluZGljYXRpb24gKi8KKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogKiBPT0IgR08gTmVnb3RpYXRpb24gQ2hhbm5lbDogT3BlcmF0aW5nICIKKwkJICAgIkNsYXNzICV1IENoYW5uZWwgJXUgUm9sZSAlZCIsCisJCSAgIG9wZXJfY2xhc3MsIGNoYW5uZWwsIHJvbGUpOworfQorCisKK3N0YXRpYyBpbnQgcDJwX2FkZF93cHNfc3RyaW5nKHN0cnVjdCB3cGFidWYgKmJ1ZiwgZW51bSB3cHNfYXR0cmlidXRlIGF0dHIsCisJCQkgICAgICBjb25zdCBjaGFyICp2YWwpCiB7CiAJc2l6ZV90IGxlbjsKIAotCXdwYWJ1Zl9wdXRfYmUxNihidWYsIGF0dHIpOwogCWxlbiA9IHZhbCA/IG9zX3N0cmxlbih2YWwpIDogMDsKKwlpZiAod3BhYnVmX3RhaWxyb29tKGJ1ZikgPCA0ICsgbGVuKQorCQlyZXR1cm4gLTE7CisJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgYXR0cik7CiAjaWZuZGVmIENPTkZJR19XUFNfU1RSSUNUCiAJaWYgKGxlbiA9PSAwKSB7CiAJCS8qCkBAIC0zNDEsMzYgKzM1OCw0NiBAQAogCQkgKiBhdHRyaWJ1dGVzLiBBcyBhIHdvcmthcm91bmQsIHNlbmQgYSBzcGFjZSBjaGFyYWN0ZXIgaWYgdGhlCiAJCSAqIGRldmljZSBhdHRyaWJ1dGUgc3RyaW5nIGlzIGVtcHR5LgogCQkgKi8KKwkJaWYgKHdwYWJ1Zl90YWlscm9vbShidWYpIDwgMykKKwkJCXJldHVybiAtMTsKIAkJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgMSk7CiAJCXdwYWJ1Zl9wdXRfdTgoYnVmLCAnICcpOwotCQlyZXR1cm47CisJCXJldHVybiAwOwogCX0KICNlbmRpZiAvKiBDT05GSUdfV1BTX1NUUklDVCAqLwogCXdwYWJ1Zl9wdXRfYmUxNihidWYsIGxlbik7CiAJaWYgKHZhbCkKIAkJd3BhYnVmX3B1dF9kYXRhKGJ1ZiwgdmFsLCBsZW4pOworCXJldHVybiAwOwogfQogCiAKLXZvaWQgcDJwX2J1aWxkX3dwc19pZShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqYnVmLCBpbnQgcHdfaWQsCi0JCSAgICAgIGludCBhbGxfYXR0cikKK2ludCBwMnBfYnVpbGRfd3BzX2llKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBzdHJ1Y3Qgd3BhYnVmICpidWYsIGludCBwd19pZCwKKwkJICAgICBpbnQgYWxsX2F0dHIpCiB7CiAJdTggKmxlbjsKIAlpbnQgaTsKIAorCWlmICh3cGFidWZfdGFpbHJvb20oYnVmKSA8IDYpCisJCXJldHVybiAtMTsKIAl3cGFidWZfcHV0X3U4KGJ1ZiwgV0xBTl9FSURfVkVORE9SX1NQRUNJRklDKTsKIAlsZW4gPSB3cGFidWZfcHV0KGJ1ZiwgMSk7CiAJd3BhYnVmX3B1dF9iZTMyKGJ1ZiwgV1BTX0RFVl9PVUlfV0ZBKTsKIAotCXdwc19idWlsZF92ZXJzaW9uKGJ1Zik7CisJaWYgKHdwc19idWlsZF92ZXJzaW9uKGJ1ZikgPCAwKQorCQlyZXR1cm4gLTE7CiAKIAlpZiAoYWxsX2F0dHIpIHsKKwkJaWYgKHdwYWJ1Zl90YWlscm9vbShidWYpIDwgNSkKKwkJCXJldHVybiAtMTsKIAkJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgQVRUUl9XUFNfU1RBVEUpOwogCQl3cGFidWZfcHV0X2JlMTYoYnVmLCAxKTsKIAkJd3BhYnVmX3B1dF91OChidWYsIFdQU19TVEFURV9OT1RfQ09ORklHVVJFRCk7CiAJfQogCiAJaWYgKHB3X2lkID49IDApIHsKKwkJaWYgKHdwYWJ1Zl90YWlscm9vbShidWYpIDwgNikKKwkJCXJldHVybiAtMTsKIAkJLyogRGV2aWNlIFBhc3N3b3JkIElEICovCiAJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIEFUVFJfREVWX1BBU1NXT1JEX0lEKTsKIAkJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgMik7CkBAIC0zODAsMzMgKzQwNyw0NyBAQAogCX0KIAogCWlmIChhbGxfYXR0cikgeworCQlpZiAod3BhYnVmX3RhaWxyb29tKGJ1ZikgPCA1KQorCQkJcmV0dXJuIC0xOwogCQl3cGFidWZfcHV0X2JlMTYoYnVmLCBBVFRSX1JFU1BPTlNFX1RZUEUpOwogCQl3cGFidWZfcHV0X2JlMTYoYnVmLCAxKTsKIAkJd3BhYnVmX3B1dF91OChidWYsIFdQU19SRVNQX0VOUk9MTEVFX0lORk8pOwogCi0JCXdwc19idWlsZF91dWlkX2UoYnVmLCBwMnAtPmNmZy0+dXVpZCk7Ci0JCXAycF9hZGRfd3BzX3N0cmluZyhidWYsIEFUVFJfTUFOVUZBQ1RVUkVSLAotCQkJCSAgIHAycC0+Y2ZnLT5tYW51ZmFjdHVyZXIpOwotCQlwMnBfYWRkX3dwc19zdHJpbmcoYnVmLCBBVFRSX01PREVMX05BTUUsIHAycC0+Y2ZnLT5tb2RlbF9uYW1lKTsKLQkJcDJwX2FkZF93cHNfc3RyaW5nKGJ1ZiwgQVRUUl9NT0RFTF9OVU1CRVIsCi0JCQkJICAgcDJwLT5jZmctPm1vZGVsX251bWJlcik7Ci0JCXAycF9hZGRfd3BzX3N0cmluZyhidWYsIEFUVFJfU0VSSUFMX05VTUJFUiwKLQkJCQkgICBwMnAtPmNmZy0+c2VyaWFsX251bWJlcik7CisJCWlmICh3cHNfYnVpbGRfdXVpZF9lKGJ1ZiwgcDJwLT5jZmctPnV1aWQpIDwgMCB8fAorCQkgICAgcDJwX2FkZF93cHNfc3RyaW5nKGJ1ZiwgQVRUUl9NQU5VRkFDVFVSRVIsCisJCQkJICAgICAgIHAycC0+Y2ZnLT5tYW51ZmFjdHVyZXIpIDwgMCB8fAorCQkgICAgcDJwX2FkZF93cHNfc3RyaW5nKGJ1ZiwgQVRUUl9NT0RFTF9OQU1FLAorCQkJCSAgICAgICBwMnAtPmNmZy0+bW9kZWxfbmFtZSkgPCAwIHx8CisJCSAgICBwMnBfYWRkX3dwc19zdHJpbmcoYnVmLCBBVFRSX01PREVMX05VTUJFUiwKKwkJCQkgICAgICAgcDJwLT5jZmctPm1vZGVsX251bWJlcikgPCAwIHx8CisJCSAgICBwMnBfYWRkX3dwc19zdHJpbmcoYnVmLCBBVFRSX1NFUklBTF9OVU1CRVIsCisJCQkJICAgICAgIHAycC0+Y2ZnLT5zZXJpYWxfbnVtYmVyKSA8IDApCisJCQlyZXR1cm4gLTE7CiAKKwkJaWYgKHdwYWJ1Zl90YWlscm9vbShidWYpIDwgNCArIFdQU19ERVZfVFlQRV9MRU4pCisJCQlyZXR1cm4gLTE7CiAJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIEFUVFJfUFJJTUFSWV9ERVZfVFlQRSk7CiAJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIFdQU19ERVZfVFlQRV9MRU4pOwogCQl3cGFidWZfcHV0X2RhdGEoYnVmLCBwMnAtPmNmZy0+cHJpX2Rldl90eXBlLCBXUFNfREVWX1RZUEVfTEVOKTsKIAotCQlwMnBfYWRkX3dwc19zdHJpbmcoYnVmLCBBVFRSX0RFVl9OQU1FLCBwMnAtPmNmZy0+ZGV2X25hbWUpOworCQlpZiAocDJwX2FkZF93cHNfc3RyaW5nKGJ1ZiwgQVRUUl9ERVZfTkFNRSwgcDJwLT5jZmctPmRldl9uYW1lKQorCQkgICAgPCAwKQorCQkJcmV0dXJuIC0xOwogCisJCWlmICh3cGFidWZfdGFpbHJvb20oYnVmKSA8IDYpCisJCQlyZXR1cm4gLTE7CiAJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIEFUVFJfQ09ORklHX01FVEhPRFMpOwogCQl3cGFidWZfcHV0X2JlMTYoYnVmLCAyKTsKIAkJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgcDJwLT5jZmctPmNvbmZpZ19tZXRob2RzKTsKIAl9CiAKLQl3cHNfYnVpbGRfd2ZhX2V4dChidWYsIDAsIE5VTEwsIDApOworCWlmICh3cHNfYnVpbGRfd2ZhX2V4dChidWYsIDAsIE5VTEwsIDApIDwgMCkKKwkJcmV0dXJuIC0xOwogCiAJaWYgKGFsbF9hdHRyICYmIHAycC0+Y2ZnLT5udW1fc2VjX2Rldl90eXBlcykgeworCQlpZiAod3BhYnVmX3RhaWxyb29tKGJ1ZikgPAorCQkgICAgNCArIFdQU19ERVZfVFlQRV9MRU4gKiBwMnAtPmNmZy0+bnVtX3NlY19kZXZfdHlwZXMpCisJCQlyZXR1cm4gLTE7CiAJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIEFUVFJfU0VDT05EQVJZX0RFVl9UWVBFX0xJU1QpOwogCQl3cGFidWZfcHV0X2JlMTYoYnVmLCBXUFNfREVWX1RZUEVfTEVOICoKIAkJCQlwMnAtPmNmZy0+bnVtX3NlY19kZXZfdHlwZXMpOwpAQCAtNDI4LDQgKzQ2OSw2IEBACiAJfQogCiAJcDJwX2J1Zl91cGRhdGVfaWVfaGRyKGJ1ZiwgbGVuKTsKKworCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvc3JjL3AycC9wMnBfZGV2X2Rpc2MuYyBiL3NyYy9wMnAvcDJwX2Rldl9kaXNjLmMKaW5kZXggNzZkMDFjZi4uODZiYWUxYSAxMDA2NDQKLS0tIGEvc3JjL3AycC9wMnBfZGV2X2Rpc2MuYworKysgYi9zcmMvcDJwL3AycF9kZXZfZGlzYy5jCkBAIC02OCw2ICs2OCw3IEBACiB7CiAJc3RydWN0IHAycF9kZXZpY2UgKmdvOwogCXN0cnVjdCB3cGFidWYgKnJlcTsKKwl1bnNpZ25lZCBpbnQgd2FpdF90aW1lOwogCiAJZ28gPSBwMnBfZ2V0X2RldmljZShwMnAsIGRldi0+bWVtYmVyX2luX2dvX2Rldik7CiAJaWYgKGdvID09IE5VTEwgfHwgZGV2LT5vcGVyX2ZyZXEgPD0gMCkgewpAQCAtODgsOSArODksMTIgQEAKIAlvc19tZW1jcHkocDJwLT5wZW5kaW5nX2NsaWVudF9kaXNjX2FkZHIsIGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCiAJCSAgRVRIX0FMRU4pOwogCXAycC0+cGVuZGluZ19hY3Rpb25fc3RhdGUgPSBQMlBfUEVORElOR19ERVZfRElTQ19SRVFVRVNUOworCXdhaXRfdGltZSA9IDEwMDA7CisJaWYgKHAycC0+Y2ZnLT5tYXhfbGlzdGVuICYmIHdhaXRfdGltZSA+IHAycC0+Y2ZnLT5tYXhfbGlzdGVuKQorCQl3YWl0X3RpbWUgPSBwMnAtPmNmZy0+bWF4X2xpc3RlbjsKIAlpZiAocDJwX3NlbmRfYWN0aW9uKHAycCwgZGV2LT5vcGVyX2ZyZXEsIGdvLT5pbmZvLnAycF9kZXZpY2VfYWRkciwKIAkJCSAgICBwMnAtPmNmZy0+ZGV2X2FkZHIsIGdvLT5pbmZvLnAycF9kZXZpY2VfYWRkciwKLQkJCSAgICB3cGFidWZfaGVhZChyZXEpLCB3cGFidWZfbGVuKHJlcSksIDEwMDApIDwgMCkgeworCQkJICAgIHdwYWJ1Zl9oZWFkKHJlcSksIHdwYWJ1Zl9sZW4ocmVxKSwgd2FpdF90aW1lKSA8IDApIHsKIAkJcDJwX2RiZyhwMnAsICJGYWlsZWQgdG8gc2VuZCBBY3Rpb24gZnJhbWUiKTsKIAkJd3BhYnVmX2ZyZWUocmVxKTsKIAkJLyogVE9ETzogaG93IHRvIHJlY292ZXIgZnJvbSBmYWlsdXJlPyAqLwpkaWZmIC0tZ2l0IGEvc3JjL3AycC9wMnBfZ29fbmVnLmMgYi9zcmMvcDJwL3AycF9nb19uZWcuYwppbmRleCBiZDU4M2JlLi5iZDdhMmNmIDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9nb19uZWcuYworKysgYi9zcmMvcDJwL3AycF9nb19uZWcuYwpAQCAtMTAsNiArMTAsNyBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgorI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgIndwcy93cHNfZGVmcy5oIgogI2luY2x1ZGUgInAycF9pLmgiCiAjaW5jbHVkZSAicDJwLmgiCkBAIC0xMDMsNiArMTA0LDggQEAKIAkJcmV0dXJuIERFVl9QV19VU0VSX1NQRUNJRklFRDsKIAljYXNlIFdQU19QQkM6CiAJCXJldHVybiBERVZfUFdfUFVTSEJVVFRPTjsKKwljYXNlIFdQU19ORkM6CisJCXJldHVybiBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVI7CiAJZGVmYXVsdDoKIAkJcmV0dXJuIERFVl9QV19ERUZBVUxUOwogCX0KQEAgLTExOCw2ICsxMjEsOCBAQAogCQlyZXR1cm4gIktleXBhZCI7CiAJY2FzZSBXUFNfUEJDOgogCQlyZXR1cm4gIlBCQyI7CisJY2FzZSBXUFNfTkZDOgorCQlyZXR1cm4gIk5GQyI7CiAJZGVmYXVsdDoKIAkJcmV0dXJuICI/PyI7CiAJfQpAQCAtMTMxLDEyICsxMzYsMTYgQEAKIAl1OCAqbGVuOwogCXU4IGdyb3VwX2NhcGFiOwogCXNpemVfdCBleHRyYSA9IDA7CisJdTE2IHB3X2lkOwogCiAjaWZkZWYgQ09ORklHX1dJRklfRElTUExBWQogCWlmIChwMnAtPndmZF9pZV9nb19uZWcpCiAJCWV4dHJhID0gd3BhYnVmX2xlbihwMnAtPndmZF9pZV9nb19uZWcpOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChwMnAtPnZlbmRvcl9lbGVtICYmIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0dPX05FR19SRVFdKQorCQlleHRyYSArPSB3cGFidWZfbGVuKHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0dPX05FR19SRVFdKTsKKwogCWJ1ZiA9IHdwYWJ1Zl9hbGxvYygxMDAwICsgZXh0cmEpOwogCWlmIChidWYgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CkBAIC0xNzIsMTMgKzE4MSwyMyBAQAogCXAycF9idWZfdXBkYXRlX2llX2hkcihidWYsIGxlbik7CiAKIAkvKiBXUFMgSUUgd2l0aCBEZXZpY2UgUGFzc3dvcmQgSUQgYXR0cmlidXRlICovCi0JcDJwX2J1aWxkX3dwc19pZShwMnAsIGJ1ZiwgcDJwX3dwc19tZXRob2RfcHdfaWQocGVlci0+d3BzX21ldGhvZCksIDApOworCXB3X2lkID0gcDJwX3dwc19tZXRob2RfcHdfaWQocGVlci0+d3BzX21ldGhvZCk7CisJaWYgKHBlZXItPm9vYl9wd19pZCkKKwkJcHdfaWQgPSBwZWVyLT5vb2JfcHdfaWQ7CisJaWYgKHAycF9idWlsZF93cHNfaWUocDJwLCBidWYsIHB3X2lkLCAwKSA8IDApIHsKKwkJcDJwX2RiZyhwMnAsICJGYWlsZWQgdG8gYnVpbGQgV1BTIElFIGZvciBHTyBOZWdvdGlhdGlvbiBSZXF1ZXN0Iik7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CisJCXJldHVybiBOVUxMOworCX0KIAogI2lmZGVmIENPTkZJR19XSUZJX0RJU1BMQVkKIAlpZiAocDJwLT53ZmRfaWVfZ29fbmVnKQogCQl3cGFidWZfcHV0X2J1ZihidWYsIHAycC0+d2ZkX2llX2dvX25lZyk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKHAycC0+dmVuZG9yX2VsZW0gJiYgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfR09fTkVHX1JFUV0pCisJCXdwYWJ1Zl9wdXRfYnVmKGJ1ZiwgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfR09fTkVHX1JFUV0pOworCiAJcmV0dXJuIGJ1ZjsKIH0KIApAQCAtMjA1LDYgKzIyNCw4IEBACiAJfQogCiAJZnJlcSA9IGRldi0+bGlzdGVuX2ZyZXEgPiAwID8gZGV2LT5saXN0ZW5fZnJlcSA6IGRldi0+b3Blcl9mcmVxOworCWlmIChkZXYtPm9vYl9nb19uZWdfZnJlcSA+IDApCisJCWZyZXEgPSBkZXYtPm9vYl9nb19uZWdfZnJlcTsKIAlpZiAoZnJlcSA8PSAwKSB7CiAJCXAycF9kYmcocDJwLCAiTm8gTGlzdGVuL09wZXJhdGluZyBmcmVxdWVuY3kga25vd24gZm9yIHRoZSBwZWVyICIKIAkJCU1BQ1NUUiAiIHRvIHNlbmQgR08gTmVnb3RpYXRpb24gUmVxdWVzdCIsCkBAIC0yNDUsNiArMjY2LDcgQEAKIAl1OCAqbGVuOwogCXU4IGdyb3VwX2NhcGFiOwogCXNpemVfdCBleHRyYSA9IDA7CisJdTE2IHB3X2lkOwogCiAJcDJwX2RiZyhwMnAsICJCdWlsZGluZyBHTyBOZWdvdGlhdGlvbiBSZXNwb25zZSIpOwogCkBAIC0yNTMsNiArMjc1LDkgQEAKIAkJZXh0cmEgPSB3cGFidWZfbGVuKHAycC0+d2ZkX2llX2dvX25lZyk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKHAycC0+dmVuZG9yX2VsZW0gJiYgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfR09fTkVHX1JFU1BdKQorCQlleHRyYSArPSB3cGFidWZfbGVuKHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0dPX05FR19SRVNQXSk7CisKIAlidWYgPSB3cGFidWZfYWxsb2MoMTAwMCArIGV4dHJhKTsKIAlpZiAoYnVmID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwpAQCAtMzA3LDE1ICszMzIsMjIgQEAKIAlwMnBfYnVmX3VwZGF0ZV9pZV9oZHIoYnVmLCBsZW4pOwogCiAJLyogV1BTIElFIHdpdGggRGV2aWNlIFBhc3N3b3JkIElEIGF0dHJpYnV0ZSAqLwotCXAycF9idWlsZF93cHNfaWUocDJwLCBidWYsCi0JCQkgcDJwX3dwc19tZXRob2RfcHdfaWQocGVlciA/IHBlZXItPndwc19tZXRob2QgOgotCQkJCQkgICAgICBXUFNfTk9UX1JFQURZKSwgMCk7CisJcHdfaWQgPSBwMnBfd3BzX21ldGhvZF9wd19pZChwZWVyID8gcGVlci0+d3BzX21ldGhvZCA6IFdQU19OT1RfUkVBRFkpOworCWlmIChwZWVyICYmIHBlZXItPm9vYl9wd19pZCkKKwkJcHdfaWQgPSBwZWVyLT5vb2JfcHdfaWQ7CisJaWYgKHAycF9idWlsZF93cHNfaWUocDJwLCBidWYsIHB3X2lkLCAwKSA8IDApIHsKKwkJcDJwX2RiZyhwMnAsICJGYWlsZWQgdG8gYnVpbGQgV1BTIElFIGZvciBHTyBOZWdvdGlhdGlvbiBSZXNwb25zZSIpOworCQl3cGFidWZfZnJlZShidWYpOworCQlyZXR1cm4gTlVMTDsKKwl9CiAKICNpZmRlZiBDT05GSUdfV0lGSV9ESVNQTEFZCiAJaWYgKHAycC0+d2ZkX2llX2dvX25lZykKIAkJd3BhYnVmX3B1dF9idWYoYnVmLCBwMnAtPndmZF9pZV9nb19uZWcpOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChwMnAtPnZlbmRvcl9lbGVtICYmIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0dPX05FR19SRVNQXSkKKwkJd3BhYnVmX3B1dF9idWYoYnVmLCBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1AyUF9HT19ORUdfUkVTUF0pOwogCiAJcmV0dXJuIGJ1ZjsKIH0KQEAgLTMzOSw2ICszNzEsOSBAQAogCWludCBmcmVxOwogCXU4IG9wX3JlZ19jbGFzcywgb3BfY2hhbm5lbDsKIAl1bnNpZ25lZCBpbnQgaTsKKwljb25zdCBpbnQgb3BfY2xhc3Nlc181Z2h6W10gPSB7IDEyNCwgMTE1LCAwIH07CisJY29uc3QgaW50IG9wX2NsYXNzZXNfaHQ0MFtdID0geyAxMjYsIDEyNywgMTE2LCAxMTcsIDAgfTsKKwljb25zdCBpbnQgb3BfY2xhc3Nlc192aHRbXSA9IHsgMTI4LCAwIH07CiAKIAlpZiAocDJwLT5vd25fZnJlcV9wcmVmZXJlbmNlID4gMCAmJgogCSAgICBwMnBfZnJlcV90b19jaGFubmVsKHAycC0+b3duX2ZyZXFfcHJlZmVyZW5jZSwKQEAgLTQwMyw0NCArNDM4LDI4IEBACiAJCX0KIAl9CiAKKwkvKiBUcnkgYSBjaGFubmVsIHdoZXJlIHdlIG1pZ2h0IGJlIGFibGUgdG8gdXNlIFZIVCAqLworCWlmIChwMnBfY2hhbm5lbF9zZWxlY3QoaW50ZXJzZWN0aW9uLCBvcF9jbGFzc2VzX3ZodCwKKwkJCSAgICAgICAmcDJwLT5vcF9yZWdfY2xhc3MsICZwMnAtPm9wX2NoYW5uZWwpID09IDApIHsKKwkJcDJwX2RiZyhwMnAsICJQaWNrIHBvc3NpYmxlIFZIVCBjaGFubmVsIChvcF9jbGFzcyAldSBjaGFubmVsICV1KSBmcm9tIGludGVyc2VjdGlvbiIsCisJCQlwMnAtPm9wX3JlZ19jbGFzcywgcDJwLT5vcF9jaGFubmVsKTsKKwkJcmV0dXJuOworCX0KKwogCS8qIFRyeSBhIGNoYW5uZWwgd2hlcmUgd2UgbWlnaHQgYmUgYWJsZSB0byB1c2UgSFQ0MCAqLwotCWZvciAoaSA9IDA7IGkgPCBpbnRlcnNlY3Rpb24tPnJlZ19jbGFzc2VzOyBpKyspIHsKLQkJc3RydWN0IHAycF9yZWdfY2xhc3MgKmMgPSAmaW50ZXJzZWN0aW9uLT5yZWdfY2xhc3NbaV07Ci0JCWlmIChjLT5yZWdfY2xhc3MgPT0gMTE2IHx8IGMtPnJlZ19jbGFzcyA9PSAxMTcgfHwKLQkJICAgIGMtPnJlZ19jbGFzcyA9PSAxMjYgfHwgYy0+cmVnX2NsYXNzID09IDEyNykgewotCQkJcDJwX2RiZyhwMnAsICJQaWNrIHBvc3NpYmxlIEhUNDAgY2hhbm5lbCAocmVnX2NsYXNzICV1IGNoYW5uZWwgJXUpIGZyb20gaW50ZXJzZWN0aW9uIiwKLQkJCQljLT5yZWdfY2xhc3MsIGMtPmNoYW5uZWxbMF0pOwotCQkJcDJwLT5vcF9yZWdfY2xhc3MgPSBjLT5yZWdfY2xhc3M7Ci0JCQlwMnAtPm9wX2NoYW5uZWwgPSBjLT5jaGFubmVsWzBdOwotCQkJcmV0dXJuOwotCQl9CisJaWYgKHAycF9jaGFubmVsX3NlbGVjdChpbnRlcnNlY3Rpb24sIG9wX2NsYXNzZXNfaHQ0MCwKKwkJCSAgICAgICAmcDJwLT5vcF9yZWdfY2xhc3MsICZwMnAtPm9wX2NoYW5uZWwpID09IDApIHsKKwkJcDJwX2RiZyhwMnAsICJQaWNrIHBvc3NpYmxlIEhUNDAgY2hhbm5lbCAob3BfY2xhc3MgJXUgY2hhbm5lbCAldSkgZnJvbSBpbnRlcnNlY3Rpb24iLAorCQkJcDJwLT5vcF9yZWdfY2xhc3MsIHAycC0+b3BfY2hhbm5lbCk7CisJCXJldHVybjsKIAl9CiAKIAkvKiBQcmVmZXIgYSA1IEdIeiBjaGFubmVsICovCi0JZm9yIChpID0gMDsgaSA8IGludGVyc2VjdGlvbi0+cmVnX2NsYXNzZXM7IGkrKykgewotI2lmZGVmIEFORFJPSURfUDJQCi0JCXN0cnVjdCBwMnBfcmVnX2NsYXNzIHByYzsKLQkJc3RydWN0IHAycF9yZWdfY2xhc3MgKmMgPSAmcHJjOwotCQlwMnBfY29weV9yZWdfY2xhc3MoYywgJmludGVyc2VjdGlvbi0+cmVnX2NsYXNzW2ldKTsKLSNlbHNlCi0JCXN0cnVjdCBwMnBfcmVnX2NsYXNzICpjID0gJmludGVyc2VjdGlvbi0+cmVnX2NsYXNzW2ldOwotI2VuZGlmCi0JCWlmICgoYy0+cmVnX2NsYXNzID09IDExNSB8fCBjLT5yZWdfY2xhc3MgPT0gMTI0KSAmJgotCQkgICAgYy0+Y2hhbm5lbHMpIHsKLQkJCXVuc2lnbmVkIGludCByOwotCi0JCQkvKgotCQkJICogUGljayBvbmUgb2YgdGhlIGF2YWlsYWJsZSBjaGFubmVscyBpbiB0aGUgb3BlcmF0aW5nCi0JCQkgKiBjbGFzcyBhdCByYW5kb20uCi0JCQkgKi8KLQkJCW9zX2dldF9yYW5kb20oKHU4ICopICZyLCBzaXplb2YocikpOwotCQkJciAlPSBjLT5jaGFubmVsczsKLQkJCXAycF9kYmcocDJwLCAiUGljayBwb3NzaWJsZSA1IEdIeiBjaGFubmVsIChvcF9jbGFzcyAldSBjaGFubmVsICV1KSBmcm9tIGludGVyc2VjdGlvbiIsCi0JCQkJYy0+cmVnX2NsYXNzLCBjLT5jaGFubmVsW3JdKTsKLQkJCXAycC0+b3BfcmVnX2NsYXNzID0gYy0+cmVnX2NsYXNzOwotCQkJcDJwLT5vcF9jaGFubmVsID0gYy0+Y2hhbm5lbFtyXTsKLQkJCXJldHVybjsKLQkJfQorCWlmIChwMnBfY2hhbm5lbF9zZWxlY3QoaW50ZXJzZWN0aW9uLCBvcF9jbGFzc2VzXzVnaHosCisJCQkgICAgICAgJnAycC0+b3BfcmVnX2NsYXNzLCAmcDJwLT5vcF9jaGFubmVsKSA9PSAwKSB7CisJCXAycF9kYmcocDJwLCAiUGljayBwb3NzaWJsZSA1IEdIeiBjaGFubmVsIChvcF9jbGFzcyAldSBjaGFubmVsICV1KSBmcm9tIGludGVyc2VjdGlvbiIsCisJCQlwMnAtPm9wX3JlZ19jbGFzcywgcDJwLT5vcF9jaGFubmVsKTsKKwkJcmV0dXJuOwogCX0KIAogCS8qCkBAIC00NzAsMTAgKzQ4OSwxNyBAQAogc3RhdGljIGludCBwMnBfZ29fc2VsZWN0X2NoYW5uZWwoc3RydWN0IHAycF9kYXRhICpwMnAsIHN0cnVjdCBwMnBfZGV2aWNlICpkZXYsCiAJCQkJIHU4ICpzdGF0dXMpCiB7Ci0Jc3RydWN0IHAycF9jaGFubmVscyBpbnRlcnNlY3Rpb247Ci0Jc2l6ZV90IGk7CisJc3RydWN0IHAycF9jaGFubmVscyB0bXAsIGludGVyc2VjdGlvbjsKIAotCXAycF9jaGFubmVsc19pbnRlcnNlY3QoJnAycC0+Y2hhbm5lbHMsICZkZXYtPmNoYW5uZWxzLCAmaW50ZXJzZWN0aW9uKTsKKwlwMnBfY2hhbm5lbHNfZHVtcChwMnAsICJvd24gY2hhbm5lbHMiLCAmcDJwLT5jaGFubmVscyk7CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAicGVlciBjaGFubmVscyIsICZkZXYtPmNoYW5uZWxzKTsKKwlwMnBfY2hhbm5lbHNfaW50ZXJzZWN0KCZwMnAtPmNoYW5uZWxzLCAmZGV2LT5jaGFubmVscywgJnRtcCk7CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAiaW50ZXJzZWN0aW9uIiwgJnRtcCk7CisJcDJwX2NoYW5uZWxzX3JlbW92ZV9mcmVxcygmdG1wLCAmcDJwLT5ub19nb19mcmVxKTsKKwlwMnBfY2hhbm5lbHNfZHVtcChwMnAsICJpbnRlcnNlY3Rpb24gYWZ0ZXIgbm8tR08gcmVtb3ZhbCIsICZ0bXApOworCXAycF9jaGFubmVsc19pbnRlcnNlY3QoJnRtcCwgJnAycC0+Y2ZnLT5jaGFubmVscywgJmludGVyc2VjdGlvbik7CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAiaW50ZXJzZWN0aW9uIHdpdGggbG9jYWwgY2hhbm5lbCBsaXN0IiwKKwkJCSAgJmludGVyc2VjdGlvbik7CiAJaWYgKGludGVyc2VjdGlvbi5yZWdfY2xhc3NlcyA9PSAwIHx8CiAJICAgIGludGVyc2VjdGlvbi5yZWdfY2xhc3NbMF0uY2hhbm5lbHMgPT0gMCkgewogCQkqc3RhdHVzID0gUDJQX1NDX0ZBSUxfTk9fQ09NTU9OX0NIQU5ORUxTOwpAQCAtNDgxLDE0ICs1MDcsNiBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JZm9yIChpID0gMDsgaSA8IGludGVyc2VjdGlvbi5yZWdfY2xhc3NlczsgaSsrKSB7Ci0JCXN0cnVjdCBwMnBfcmVnX2NsYXNzICpjOwotCQljID0gJmludGVyc2VjdGlvbi5yZWdfY2xhc3NbaV07Ci0JCXAycF9kYmcocDJwLCAicmVnX2NsYXNzICV1IiwgYy0+cmVnX2NsYXNzKTsKLQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUDJQOiBjaGFubmVscyIsCi0JCQkgICAgYy0+Y2hhbm5lbCwgYy0+Y2hhbm5lbHMpOwotCX0KLQogCWlmICghcDJwX2NoYW5uZWxzX2luY2x1ZGVzKCZpbnRlcnNlY3Rpb24sIHAycC0+b3BfcmVnX2NsYXNzLAogCQkJCSAgIHAycC0+b3BfY2hhbm5lbCkpIHsKIAkJaWYgKGRldi0+ZmxhZ3MgJiBQMlBfREVWX0ZPUkNFX0ZSRVEpIHsKQEAgLTU4OCwxNyArNjA2LDUzIEBACiAJaWYgKG1zZy5zdGF0dXMgJiYgKm1zZy5zdGF0dXMpIHsKIAkJcDJwX2RiZyhwMnAsICJVbmV4cGVjdGVkIFN0YXR1cyBhdHRyaWJ1dGUgKCVkKSBpbiBHTyBOZWdvdGlhdGlvbiBSZXF1ZXN0IiwKIAkJCSptc2cuc3RhdHVzKTsKKwkJaWYgKGRldiAmJiBwMnAtPmdvX25lZ19wZWVyID09IGRldiAmJgorCQkgICAgKm1zZy5zdGF0dXMgPT0gUDJQX1NDX0ZBSUxfUkVKRUNURURfQllfVVNFUikgeworCQkJLyoKKwkJCSAqIFRoaXMgbWVjaGFuaXNtIGZvciB1c2luZyBTdGF0dXMgYXR0cmlidXRlIGluIEdPCisJCQkgKiBOZWdvdGlhdGlvbiBSZXF1ZXN0IGlzIG5vdCBjb21wbGlhbnQgd2l0aCB0aGUgUDJQCisJCQkgKiBzcGVjaWZpY2F0aW9uLCBidXQgc29tZSBkZXBsb3llZCBkZXZpY2VzIHVzZSBpdCB0bworCQkJICogaW5kaWNhdGUgcmVqZWN0aW9uIG9mIEdPIE5lZ290aWF0aW9uIGluIGEgY2FzZSB3aGVyZQorCQkJICogdGhleSBoYXZlIHNlbnQgb3V0IEdPIE5lZ290aWF0aW9uIFJlc3BvbnNlIHdpdGgKKwkJCSAqIHN0YXR1cyAxLiBUaGUgUDJQIHNwZWNpZmljYXRpb24gZXhwbGljaXRseSBkaXNhbGxvd3MKKwkJCSAqIHRoaXMuIFRvIGF2b2lkIHVubmVjZXNzYXJ5IGludGVyb3BlcmFiaWxpdHkgaXNzdWVzCisJCQkgKiBhbmQgZXh0cmEgZnJhbWVzLCBtYXJrIHRoZSBwZW5kaW5nIG5lZ290aWF0aW9uIGFzCisJCQkgKiBmYWlsZWQgYW5kIGRvIG5vdCByZXBseSB0byB0aGlzIEdPIE5lZ290aWF0aW9uCisJCQkgKiBSZXF1ZXN0IGZyYW1lLgorCQkJICovCisJCQlwMnAtPmNmZy0+c2VuZF9hY3Rpb25fZG9uZShwMnAtPmNmZy0+Y2JfY3R4KTsKKwkJCXAycF9nb19uZWdfZmFpbGVkKHAycCwgZGV2LCAqbXNnLnN0YXR1cyk7CisJCQlwMnBfcGFyc2VfZnJlZSgmbXNnKTsKKwkJCXJldHVybjsKKwkJfQogCQlnb3RvIGZhaWw7CiAJfQogCiAJaWYgKGRldiA9PSBOVUxMKQogCQlkZXYgPSBwMnBfYWRkX2Rldl9mcm9tX2dvX25lZ19yZXEocDJwLCBzYSwgJm1zZyk7Ci0JZWxzZSBpZiAoZGV2LT5mbGFncyAmIFAyUF9ERVZfUFJPQkVfUkVRX09OTFkpCisJZWxzZSBpZiAoKGRldi0+ZmxhZ3MgJiBQMlBfREVWX1BST0JFX1JFUV9PTkxZKSB8fAorCQkgICEoZGV2LT5mbGFncyAmIFAyUF9ERVZfUkVQT1JURUQpKQogCQlwMnBfYWRkX2Rldl9pbmZvKHAycCwgc2EsIGRldiwgJm1zZyk7CisJZWxzZSBpZiAoIWRldi0+bGlzdGVuX2ZyZXEgJiYgIWRldi0+b3Blcl9mcmVxKSB7CisJCS8qCisJCSAqIFRoaXMgbWF5IGhhcHBlbiBpZiB0aGUgcGVlciBlbnRyeSB3YXMgYWRkZWQgYmFzZWQgb24gUEQKKwkJICogUmVxdWVzdCBhbmQgbm8gUHJvYmUgUmVxdWVzdC9SZXNwb25zZSBmcmFtZSBoYXMgYmVlbiByZWNlaXZlZAorCQkgKiBmcm9tIHRoaXMgcGVlciAob3IgdGhhdCBpbmZvcm1hdGlvbiBoYXMgdGltZWQgb3V0KS4KKwkJICovCisJCXAycF9kYmcocDJwLCAiVXBkYXRlIHBlZXIgIiBNQUNTVFIKKwkJCSIgYmFzZWQgb24gR08gTmVnIFJlcSBzaW5jZSBsaXN0ZW4vb3BlciBmcmVxIG5vdCBrbm93biIsCisJCQlNQUMyU1RSKGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIpKTsKKwkJcDJwX2FkZF9kZXZfaW5mbyhwMnAsIHNhLCBkZXYsICZtc2cpOworCX0KKwogCWlmIChkZXYgJiYgZGV2LT5mbGFncyAmIFAyUF9ERVZfVVNFUl9SRUpFQ1RFRCkgewogCQlwMnBfZGJnKHAycCwgIlVzZXIgaGFzIHJlamVjdGVkIHRoaXMgcGVlciIpOwogCQlzdGF0dXMgPSBQMlBfU0NfRkFJTF9SRUpFQ1RFRF9CWV9VU0VSOwotCX0gZWxzZSBpZiAoZGV2ID09IE5VTEwgfHwgZGV2LT53cHNfbWV0aG9kID09IFdQU19OT1RfUkVBRFkpIHsKKwl9IGVsc2UgaWYgKGRldiA9PSBOVUxMIHx8CisJCSAgIChkZXYtPndwc19tZXRob2QgPT0gV1BTX05PVF9SRUFEWSAmJgorCQkgICAgKHAycC0+YXV0aG9yaXplZF9vb2JfZGV2X3B3X2lkID09IDAgfHwKKwkJICAgICBwMnAtPmF1dGhvcml6ZWRfb29iX2Rldl9wd19pZCAhPQorCQkgICAgIG1zZy5kZXZfcGFzc3dvcmRfaWQpKSkgewogCQlwMnBfZGJnKHAycCwgIk5vdCByZWFkeSBmb3IgR08gbmVnb3RpYXRpb24gd2l0aCAiIE1BQ1NUUiwKIAkJCU1BQzJTVFIoc2EpKTsKIAkJc3RhdHVzID0gUDJQX1NDX0ZBSUxfSU5GT19DVVJSRU5UTFlfVU5BVkFJTEFCTEU7CkBAIC02ODUsNiArNzM5LDI4IEBACiAJCQl9CiAJCQlicmVhazsKIAkJZGVmYXVsdDoKKwkJCWlmIChtc2cuZGV2X3Bhc3N3b3JkX2lkICYmCisJCQkgICAgbXNnLmRldl9wYXNzd29yZF9pZCA9PSBkZXYtPm9vYl9wd19pZCkgeworCQkJCXAycF9kYmcocDJwLCAiUGVlciB1c2luZyBORkMiKTsKKwkJCQlpZiAoZGV2LT53cHNfbWV0aG9kICE9IFdQU19ORkMpIHsKKwkJCQkJcDJwX2RiZyhwMnAsICJXZSBoYXZlIHdwc19tZXRob2Q9JXMgLT4gaW5jb21wYXRpYmxlIiwKKwkJCQkJCXAycF93cHNfbWV0aG9kX3N0cigKKwkJCQkJCQlkZXYtPndwc19tZXRob2QpKTsKKwkJCQkJc3RhdHVzID0gUDJQX1NDX0ZBSUxfSU5DT01QQVRJQkxFX1BST1ZfTUVUSE9EOworCQkJCQlnb3RvIGZhaWw7CisJCQkJfQorCQkJCWJyZWFrOworCQkJfQorI2lmZGVmIENPTkZJR19XUFNfTkZDCisJCQlpZiAocDJwLT5hdXRob3JpemVkX29vYl9kZXZfcHdfaWQgJiYKKwkJCSAgICBtc2cuZGV2X3Bhc3N3b3JkX2lkID09CisJCQkgICAgcDJwLT5hdXRob3JpemVkX29vYl9kZXZfcHdfaWQpIHsKKwkJCQlwMnBfZGJnKHAycCwgIlVzaW5nIHN0YXRpYyBoYW5kb3ZlciB3aXRoIG91ciBkZXZpY2UgcGFzc3dvcmQgZnJvbSBORkMgVGFnIik7CisJCQkJZGV2LT53cHNfbWV0aG9kID0gV1BTX05GQzsKKwkJCQlkZXYtPm9vYl9wd19pZCA9IHAycC0+YXV0aG9yaXplZF9vb2JfZGV2X3B3X2lkOworCQkJCWJyZWFrOworCQkJfQorI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCiAJCQlwMnBfZGJnKHAycCwgIlVuc3VwcG9ydGVkIERldmljZSBQYXNzd29yZCBJRCAlZCIsCiAJCQkJbXNnLmRldl9wYXNzd29yZF9pZCk7CiAJCQlzdGF0dXMgPSBQMlBfU0NfRkFJTF9JTkNPTVBBVElCTEVfUFJPVl9NRVRIT0Q7CkBAIC03ODAsNiArODU2LDkgQEAKIAkJZXh0cmEgPSB3cGFidWZfbGVuKHAycC0+d2ZkX2llX2dvX25lZyk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKHAycC0+dmVuZG9yX2VsZW0gJiYgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfR09fTkVHX0NPTkZdKQorCQlleHRyYSArPSB3cGFidWZfbGVuKHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0dPX05FR19DT05GXSk7CisKIAlidWYgPSB3cGFidWZfYWxsb2MoMTAwMCArIGV4dHJhKTsKIAlpZiAoYnVmID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwpAQCAtODI0LDYgKzkwMyw5IEBACiAJCXdwYWJ1Zl9wdXRfYnVmKGJ1ZiwgcDJwLT53ZmRfaWVfZ29fbmVnKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAKKwlpZiAocDJwLT52ZW5kb3JfZWxlbSAmJiBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1AyUF9HT19ORUdfQ09ORl0pCisJCXdwYWJ1Zl9wdXRfYnVmKGJ1ZiwgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfR09fTkVHX0NPTkZdKTsKKwogCXJldHVybiBidWY7CiB9CiAKQEAgLTgzMiw3ICs5MTQsNiBAQAogCQkJICAgICBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbiwgaW50IHJ4X2ZyZXEpCiB7CiAJc3RydWN0IHAycF9kZXZpY2UgKmRldjsKLQlzdHJ1Y3Qgd3BhYnVmICpjb25mOwogCWludCBnbyA9IC0xOwogCXN0cnVjdCBwMnBfbWVzc2FnZSBtc2c7CiAJdTggc3RhdHVzID0gUDJQX1NDX1NVQ0NFU1M7CkBAIC04NzYsNyArOTU3LDcgQEAKIAkJaWYgKCptc2cuc3RhdHVzID09IFAyUF9TQ19GQUlMX0lORk9fQ1VSUkVOVExZX1VOQVZBSUxBQkxFKSB7CiAJCQlwMnBfZGJnKHAycCwgIldhaXQgZm9yIHRoZSBwZWVyIHRvIGJlY29tZSByZWFkeSBmb3IgR08gTmVnb3RpYXRpb24iKTsKIAkJCWRldi0+ZmxhZ3MgfD0gUDJQX0RFVl9OT1RfWUVUX1JFQURZOwotCQkJZGV2LT53YWl0X2NvdW50ID0gMDsKKwkJCW9zX2dldF9yZWx0aW1lKCZkZXYtPmdvX25lZ193YWl0X3N0YXJ0ZWQpOwogCQkJcDJwX3NldF9zdGF0ZShwMnAsIFAyUF9XQUlUX1BFRVJfSURMRSk7CiAJCQlwMnBfc2V0X3RpbWVvdXQocDJwLCAwLCAwKTsKIAkJfSBlbHNlIHsKQEAgLTEwMTAsNiArMTA5MSwxNyBAQAogCQl9CiAJCWJyZWFrOwogCWRlZmF1bHQ6CisJCWlmIChtc2cuZGV2X3Bhc3N3b3JkX2lkICYmCisJCSAgICBtc2cuZGV2X3Bhc3N3b3JkX2lkID09IGRldi0+b29iX3B3X2lkKSB7CisJCQlwMnBfZGJnKHAycCwgIlBlZXIgdXNpbmcgTkZDIik7CisJCQlpZiAoZGV2LT53cHNfbWV0aG9kICE9IFdQU19ORkMpIHsKKwkJCQlwMnBfZGJnKHAycCwgIldlIGhhdmUgd3BzX21ldGhvZD0lcyAtPiBpbmNvbXBhdGlibGUiLAorCQkJCQlwMnBfd3BzX21ldGhvZF9zdHIoZGV2LT53cHNfbWV0aG9kKSk7CisJCQkJc3RhdHVzID0gUDJQX1NDX0ZBSUxfSU5DT01QQVRJQkxFX1BST1ZfTUVUSE9EOworCQkJCWdvdG8gZmFpbDsKKwkJCX0KKwkJCWJyZWFrOworCQl9CiAJCXAycF9kYmcocDJwLCAiVW5zdXBwb3J0ZWQgRGV2aWNlIFBhc3N3b3JkIElEICVkIiwKIAkJCW1zZy5kZXZfcGFzc3dvcmRfaWQpOwogCQlzdGF0dXMgPSBQMlBfU0NfRkFJTF9JTkNPTVBBVElCTEVfUFJPVl9NRVRIT0Q7CkBAIC0xMDI2LDEwICsxMTE4LDEzIEBACiAJb3NfbWVtY3B5KGRldi0+aW50ZW5kZWRfYWRkciwgbXNnLmludGVuZGVkX2FkZHIsIEVUSF9BTEVOKTsKIAogZmFpbDoKLQljb25mID0gcDJwX2J1aWxkX2dvX25lZ19jb25mKHAycCwgZGV2LCBtc2cuZGlhbG9nX3Rva2VuLCBzdGF0dXMsCi0JCQkJICAgICBtc2cub3BlcmF0aW5nX2NoYW5uZWwsIGdvKTsKKwkvKiBTdG9yZSBHTyBOZWdvdGlhdGlvbiBDb25maXJtYXRpb24gdG8gYWxsb3cgcmV0cmFuc21pc3Npb24gKi8KKwl3cGFidWZfZnJlZShkZXYtPmdvX25lZ19jb25mKTsKKwlkZXYtPmdvX25lZ19jb25mID0gcDJwX2J1aWxkX2dvX25lZ19jb25mKHAycCwgZGV2LCBtc2cuZGlhbG9nX3Rva2VuLAorCQkJCQkJIHN0YXR1cywgbXNnLm9wZXJhdGluZ19jaGFubmVsLAorCQkJCQkJIGdvKTsKIAlwMnBfcGFyc2VfZnJlZSgmbXNnKTsKLQlpZiAoY29uZiA9PSBOVUxMKQorCWlmIChkZXYtPmdvX25lZ19jb25mID09IE5VTEwpCiAJCXJldHVybjsKIAlwMnBfZGJnKHAycCwgIlNlbmRpbmcgR08gTmVnb3RpYXRpb24gQ29uZmlybSIpOwogCWlmIChzdGF0dXMgPT0gUDJQX1NDX1NVQ0NFU1MpIHsKQEAgLTEwNDEsMTIgKzExMzYsMTggQEAKIAkJZnJlcSA9IHJ4X2ZyZXE7CiAJZWxzZQogCQlmcmVxID0gZGV2LT5saXN0ZW5fZnJlcTsKKworCWRldi0+Z29fbmVnX2NvbmZfZnJlcSA9IGZyZXE7CisJZGV2LT5nb19uZWdfY29uZl9zZW50ID0gMDsKKwogCWlmIChwMnBfc2VuZF9hY3Rpb24ocDJwLCBmcmVxLCBzYSwgcDJwLT5jZmctPmRldl9hZGRyLCBzYSwKLQkJCSAgICB3cGFidWZfaGVhZChjb25mKSwgd3BhYnVmX2xlbihjb25mKSwgMCkgPCAwKSB7CisJCQkgICAgd3BhYnVmX2hlYWQoZGV2LT5nb19uZWdfY29uZiksCisJCQkgICAgd3BhYnVmX2xlbihkZXYtPmdvX25lZ19jb25mKSwgMjAwKSA8IDApIHsKIAkJcDJwX2RiZyhwMnAsICJGYWlsZWQgdG8gc2VuZCBBY3Rpb24gZnJhbWUiKTsKIAkJcDJwX2dvX25lZ19mYWlsZWQocDJwLCBkZXYsIC0xKTsKLQl9Ci0Jd3BhYnVmX2ZyZWUoY29uZik7CisJCXAycC0+Y2ZnLT5zZW5kX2FjdGlvbl9kb25lKHAycC0+Y2ZnLT5jYl9jdHgpOworCX0gZWxzZQorCQlkZXYtPmdvX25lZ19jb25mX3NlbnQrKzsKIAlpZiAoc3RhdHVzICE9IFAyUF9TQ19TVUNDRVNTKSB7CiAJCXAycF9kYmcocDJwLCAiR08gTmVnb3RpYXRpb24gZmFpbGVkIik7CiAJCXAycF9nb19uZWdfZmFpbGVkKHAycCwgZGV2LCBzdGF0dXMpOwpAQCAtMTA4MCw5ICsxMTgxLDExIEBACiAKIAlpZiAoIShkZXYtPmZsYWdzICYgUDJQX0RFVl9XQUlUX0dPX05FR19DT05GSVJNKSkgewogCQlwMnBfZGJnKHAycCwgIldhcyBub3QgZXhwZWN0aW5nIEdPIE5lZ290aWF0aW9uIENvbmZpcm0gLSBpZ25vcmUiKTsKKwkJcDJwX3BhcnNlX2ZyZWUoJm1zZyk7CiAJCXJldHVybjsKIAl9CiAJZGV2LT5mbGFncyAmPSB+UDJQX0RFVl9XQUlUX0dPX05FR19DT05GSVJNOworCXAycC0+Y2ZnLT5zZW5kX2FjdGlvbl9kb25lKHAycC0+Y2ZnLT5jYl9jdHgpOwogCiAJaWYgKG1zZy5kaWFsb2dfdG9rZW4gIT0gZGV2LT5kaWFsb2dfdG9rZW4pIHsKIAkJcDJwX2RiZyhwMnAsICJVbmV4cGVjdGVkIERpYWxvZyBUb2tlbiAldSAoZXhwZWN0ZWQgJXUpIiwKQEAgLTExMzEsMTYgKzEyMzQsNiBAQAogCQl9CiAJfQogCi0jaWZkZWYgQU5EUk9JRF9QMlAKLQlpZiAobXNnLm9wZXJhdGluZ19jaGFubmVsKSB7Ci0JCWRldi0+b3Blcl9mcmVxID0gcDJwX2NoYW5uZWxfdG9fZnJlcShtc2cub3BlcmF0aW5nX2NoYW5uZWxbM10sCi0JCQkJCQkgICAgIG1zZy5vcGVyYXRpbmdfY2hhbm5lbFs0XSk7Ci0JCXAycF9kYmcocDJwLCAiUDJQOiBQZWVyIG9wZXJhdGluZyBjaGFubmVsIHByZWZlcmVuY2U6ICVkIE1IeiIsCi0JCQlkZXYtPm9wZXJfZnJlcSk7Ci0JfSBlbHNlCi0JCWRldi0+b3Blcl9mcmVxID0gMDsKLSNlbmRpZgotCiAJaWYgKCFtc2cuY2hhbm5lbF9saXN0KSB7CiAJCXAycF9kYmcocDJwLCAiTWFuZGF0b3J5IE9wZXJhdGluZyBDaGFubmVsIGF0dHJpYnV0ZSBtaXNzaW5nIGZyb20gR08gTmVnb3RpYXRpb24gQ29uZmlybWF0aW9uIik7CiAjaWZkZWYgQ09ORklHX1AyUF9TVFJJQ1QKZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX2dyb3VwLmMgYi9zcmMvcDJwL3AycF9ncm91cC5jCmluZGV4IDE1ZTc2MjIuLmRhODU4OGEgMTAwNjQ0Ci0tLSBhL3NyYy9wMnAvcDJwX2dyb3VwLmMKKysrIGIvc3JjL3AycC9wMnBfZ3JvdXAuYwpAQCAtMTEsNiArMTEsNyBAQAogI2luY2x1ZGUgImNvbW1vbi5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9jb21tb24uaCIKKyNpbmNsdWRlICJjb21tb24vd3BhX2N0cmwuaCIKICNpbmNsdWRlICJ3cHMvd3BzX2RlZnMuaCIKICNpbmNsdWRlICJ3cHMvd3BzX2kuaCIKICNpbmNsdWRlICJwMnBfaS5oIgpAQCAtMTU0LDYgKzE1NSw3IEBACiAJCWdyb3VwX2NhcGFiIHw9IFAyUF9HUk9VUF9DQVBBQl9DUk9TU19DT05OOwogCWlmIChncm91cC0+bnVtX21lbWJlcnMgPj0gZ3JvdXAtPmNmZy0+bWF4X2NsaWVudHMpCiAJCWdyb3VwX2NhcGFiIHw9IFAyUF9HUk9VUF9DQVBBQl9HUk9VUF9MSU1JVDsKKwlncm91cF9jYXBhYiB8PSBQMlBfR1JPVVBfQ0FQQUJfSVBfQUREUl9BTExPQ0FUSU9OOwogCXAycF9idWZfYWRkX2NhcGFiaWxpdHkoaWUsIGRldl9jYXBhYiwgZ3JvdXBfY2FwYWIpOwogfQogCkBAIC0yMTMsNiArMjE1LDEwIEBACiAJCWV4dHJhID0gd3BhYnVmX2xlbihncm91cC0+cDJwLT53ZmRfaWVfYmVhY29uKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAKKwlpZiAoZ3JvdXAtPnAycC0+dmVuZG9yX2VsZW0gJiYKKwkgICAgZ3JvdXAtPnAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fQkVBQ09OX1AyUF9HT10pCisJCWV4dHJhICs9IHdwYWJ1Zl9sZW4oZ3JvdXAtPnAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fQkVBQ09OX1AyUF9HT10pOworCiAJaWUgPSB3cGFidWZfYWxsb2MoMjU3ICsgZXh0cmEpOwogCWlmIChpZSA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKQEAgLTIyMiw2ICsyMjgsMTEgQEAKIAkJd3BhYnVmX3B1dF9idWYoaWUsIGdyb3VwLT5wMnAtPndmZF9pZV9iZWFjb24pOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChncm91cC0+cDJwLT52ZW5kb3JfZWxlbSAmJgorCSAgICBncm91cC0+cDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9CRUFDT05fUDJQX0dPXSkKKwkJd3BhYnVmX3B1dF9idWYoaWUsCisJCQkgICAgICAgZ3JvdXAtPnAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fQkVBQ09OX1AyUF9HT10pOworCiAJbGVuID0gcDJwX2J1Zl9hZGRfaWVfaGRyKGllKTsKIAlwMnBfZ3JvdXBfYWRkX2NvbW1vbl9pZXMoZ3JvdXAsIGllKTsKIAlwMnBfYnVmX2FkZF9kZXZpY2VfaWQoaWUsIGdyb3VwLT5wMnAtPmNmZy0+ZGV2X2FkZHIpOwpAQCAtMzk3LDEwICs0MDgsMzggQEAKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAKIAordm9pZCBwMnBfYnVmX2FkZF9ncm91cF9pbmZvKHN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwLCBzdHJ1Y3Qgd3BhYnVmICpidWYsCisJCQkgICAgaW50IG1heF9jbGllbnRzKQoreworCXU4ICpncm91cF9pbmZvOworCWludCBjb3VudCA9IDA7CisJc3RydWN0IHAycF9ncm91cF9tZW1iZXIgKm07CisKKwlwMnBfZGJnKGdyb3VwLT5wMnAsICIqIFAyUCBHcm91cCBJbmZvIik7CisJZ3JvdXBfaW5mbyA9IHdwYWJ1Zl9wdXQoYnVmLCAwKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgUDJQX0FUVFJfR1JPVVBfSU5GTyk7CisJd3BhYnVmX3B1dF9sZTE2KGJ1ZiwgMCk7IC8qIExlbmd0aCB0byBiZSBmaWxsZWQgKi8KKwlmb3IgKG0gPSBncm91cC0+bWVtYmVyczsgbTsgbSA9IG0tPm5leHQpIHsKKwkJcDJwX2NsaWVudF9pbmZvKGJ1ZiwgbSk7CisJCWNvdW50Kys7CisJCWlmIChtYXhfY2xpZW50cyA+PSAwICYmIGNvdW50ID49IG1heF9jbGllbnRzKQorCQkJYnJlYWs7CisJfQorCVdQQV9QVVRfTEUxNihncm91cF9pbmZvICsgMSwKKwkJICAgICAodTggKikgd3BhYnVmX3B1dChidWYsIDApIC0gZ3JvdXBfaW5mbyAtIDMpOworfQorCisKK3ZvaWQgcDJwX2dyb3VwX2J1Zl9hZGRfaWQoc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsIHN0cnVjdCB3cGFidWYgKmJ1ZikKK3sKKwlwMnBfYnVmX2FkZF9ncm91cF9pZChidWYsIGdyb3VwLT5wMnAtPmNmZy0+ZGV2X2FkZHIsIGdyb3VwLT5jZmctPnNzaWQsCisJCQkgICAgIGdyb3VwLT5jZmctPnNzaWRfbGVuKTsKK30KKworCiBzdGF0aWMgc3RydWN0IHdwYWJ1ZiAqIHAycF9ncm91cF9idWlsZF9wcm9iZV9yZXNwX2llKHN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwKQogewogCXN0cnVjdCB3cGFidWYgKnAycF9zdWJlbGVtcywgKmllOwotCXN0cnVjdCBwMnBfZ3JvdXBfbWVtYmVyICptOwogCiAJcDJwX3N1YmVsZW1zID0gd3BhYnVmX2FsbG9jKDUwMCk7CiAJaWYgKHAycF9zdWJlbGVtcyA9PSBOVUxMKQpAQCAtNDEzLDIxICs0NTIsMTkgQEAKIAlwMnBfYnVmX2FkZF9kZXZpY2VfaW5mbyhwMnBfc3ViZWxlbXMsIGdyb3VwLT5wMnAsIE5VTEwpOwogCiAJLyogUDJQIEdyb3VwIEluZm86IE9ubHkgd2hlbiBhdCBsZWFzdCBvbmUgUDJQIENsaWVudCBpcyBjb25uZWN0ZWQgKi8KLQlpZiAoZ3JvdXAtPm1lbWJlcnMpIHsKLQkJdTggKmdyb3VwX2luZm87Ci0JCWdyb3VwX2luZm8gPSB3cGFidWZfcHV0KHAycF9zdWJlbGVtcywgMCk7Ci0JCXdwYWJ1Zl9wdXRfdTgocDJwX3N1YmVsZW1zLCBQMlBfQVRUUl9HUk9VUF9JTkZPKTsKLQkJd3BhYnVmX3B1dF9sZTE2KHAycF9zdWJlbGVtcywgMCk7IC8qIExlbmd0aCB0byBiZSBmaWxsZWQgKi8KLQkJZm9yIChtID0gZ3JvdXAtPm1lbWJlcnM7IG07IG0gPSBtLT5uZXh0KQotCQkJcDJwX2NsaWVudF9pbmZvKHAycF9zdWJlbGVtcywgbSk7Ci0JCVdQQV9QVVRfTEUxNihncm91cF9pbmZvICsgMSwKLQkJCSAgICAgKHU4ICopIHdwYWJ1Zl9wdXQocDJwX3N1YmVsZW1zLCAwKSAtIGdyb3VwX2luZm8gLQotCQkJICAgICAzKTsKLQl9CisJaWYgKGdyb3VwLT5tZW1iZXJzKQorCQlwMnBfYnVmX2FkZF9ncm91cF9pbmZvKGdyb3VwLCBwMnBfc3ViZWxlbXMsIC0xKTsKIAogCWllID0gcDJwX2dyb3VwX2VuY2Fwc19wcm9iZV9yZXNwKHAycF9zdWJlbGVtcyk7CiAJd3BhYnVmX2ZyZWUocDJwX3N1YmVsZW1zKTsKIAorCWlmIChncm91cC0+cDJwLT52ZW5kb3JfZWxlbSAmJgorCSAgICBncm91cC0+cDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QUk9CRV9SRVNQX1AyUF9HT10pIHsKKwkJc3RydWN0IHdwYWJ1ZiAqZXh0cmE7CisJCWV4dHJhID0gd3BhYnVmX2R1cChncm91cC0+cDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QUk9CRV9SRVNQX1AyUF9HT10pOworCQlpZSA9IHdwYWJ1Zl9jb25jYXQoZXh0cmEsIGllKTsKKwl9CisKICNpZmRlZiBDT05GSUdfV0lGSV9ESVNQTEFZCiAJaWYgKGdyb3VwLT53ZmRfaWUpIHsKIAkJc3RydWN0IHdwYWJ1ZiAqd2ZkID0gd3BhYnVmX2R1cChncm91cC0+d2ZkX2llKTsKQEAgLTYxNCw2ICs2NTEsMTAgQEAKIAkJZXh0cmEgPSB3cGFidWZfbGVuKGdyb3VwLT53ZmRfaWUpOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChncm91cC0+cDJwLT52ZW5kb3JfZWxlbSAmJgorCSAgICBncm91cC0+cDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfQVNTT0NfUkVTUF0pCisJCWV4dHJhICs9IHdwYWJ1Zl9sZW4oZ3JvdXAtPnAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0FTU09DX1JFU1BdKTsKKwogCS8qCiAJICogKFJlKUFzc29jaWF0aW9uIFJlc3BvbnNlIC0gUDJQIElFCiAJICogU3RhdHVzIGF0dHJpYnV0ZSAoc2hhbGwgYmUgcHJlc2VudCB3aGVuIGFzc29jaWF0aW9uIHJlcXVlc3QgaXMKQEAgLTYyOSw2ICs2NzAsMTEgQEAKIAkJd3BhYnVmX3B1dF9idWYocmVzcCwgZ3JvdXAtPndmZF9pZSk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKGdyb3VwLT5wMnAtPnZlbmRvcl9lbGVtICYmCisJICAgIGdyb3VwLT5wMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1AyUF9BU1NPQ19SRVNQXSkKKwkJd3BhYnVmX3B1dF9idWYocmVzcCwKKwkJCSAgICAgICBncm91cC0+cDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfQVNTT0NfUkVTUF0pOworCiAJcmxlbiA9IHAycF9idWZfYWRkX2llX2hkcihyZXNwKTsKIAlpZiAoc3RhdHVzICE9IFAyUF9TQ19TVUNDRVNTKQogCQlwMnBfYnVmX2FkZF9zdGF0dXMocmVzcCwgc3RhdHVzKTsKQEAgLTk1Myw3ICs5OTksNyBAQAogCWlmICghaXRlcikKIAkJcmV0dXJuIE5VTEw7CiAKLQlyZXR1cm4gaXRlci0+YWRkcjsKKwlyZXR1cm4gaXRlci0+ZGV2X2FkZHI7CiB9CiAKIApAQCAtOTgwLDMgKzEwMjYsMzYgQEAKIAlyZXR1cm4gb3NfbWVtY21wKGdyb3VwX2lkICsgRVRIX0FMRU4sIGdyb3VwLT5jZmctPnNzaWQsCiAJCQkgZ3JvdXAtPmNmZy0+c3NpZF9sZW4pID09IDA7CiB9CisKKwordm9pZCBwMnBfZ3JvdXBfZm9yY2VfYmVhY29uX3VwZGF0ZV9pZXMoc3RydWN0IHAycF9ncm91cCAqZ3JvdXApCit7CisJZ3JvdXAtPmJlYWNvbl91cGRhdGUgPSAxOworCXAycF9ncm91cF91cGRhdGVfaWVzKGdyb3VwKTsKK30KKworCitpbnQgcDJwX2dyb3VwX2dldF9mcmVxKHN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwKQoreworCXJldHVybiBncm91cC0+Y2ZnLT5mcmVxOworfQorCisKK2NvbnN0IHN0cnVjdCBwMnBfZ3JvdXBfY29uZmlnICogcDJwX2dyb3VwX2dldF9jb25maWcoc3RydWN0IHAycF9ncm91cCAqZ3JvdXApCit7CisJcmV0dXJuIGdyb3VwLT5jZmc7Cit9CisKKwordm9pZCBwMnBfbG9vcF9vbl9hbGxfZ3JvdXBzKHN0cnVjdCBwMnBfZGF0YSAqcDJwLAorCQkJICAgIGludCAoKmdyb3VwX2NhbGxiYWNrKShzdHJ1Y3QgcDJwX2dyb3VwICpncm91cCwKKwkJCQkJCSAgdm9pZCAqdXNlcl9kYXRhKSwKKwkJCSAgICB2b2lkICp1c2VyX2RhdGEpCit7CisJdW5zaWduZWQgaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgcDJwLT5udW1fZ3JvdXBzOyBpKyspIHsKKwkJaWYgKCFncm91cF9jYWxsYmFjayhwMnAtPmdyb3Vwc1tpXSwgdXNlcl9kYXRhKSkKKwkJCWJyZWFrOworCX0KK30KZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX2kuaCBiL3NyYy9wMnAvcDJwX2kuaAppbmRleCA4MWU1MjFlLi4zYjYwNTgyIDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9pLmgKKysrIGIvc3JjL3AycC9wMnBfaS5oCkBAIC0xMiw2ICsxMiwxMCBAQAogI2luY2x1ZGUgInV0aWxzL2xpc3QuaCIKICNpbmNsdWRlICJwMnAuaCIKIAorI2RlZmluZSBQMlBfR09fTkVHX0NORl9NQVhfUkVUUllfQ09VTlQgMQorCitlbnVtIHAycF9yb2xlX2luZGljYXRpb247CisKIGVudW0gcDJwX2dvX3N0YXRlIHsKIAlVTktOT1dOX0dPLAogCUxPQ0FMX0dPLApAQCAtMjMsOSArMjcsMTEgQEAKICAqLwogc3RydWN0IHAycF9kZXZpY2UgewogCXN0cnVjdCBkbF9saXN0IGxpc3Q7Ci0Jc3RydWN0IG9zX3RpbWUgbGFzdF9zZWVuOworCXN0cnVjdCBvc19yZWx0aW1lIGxhc3Rfc2VlbjsKIAlpbnQgbGlzdGVuX2ZyZXE7CisJaW50IG9vYl9nb19uZWdfZnJlcTsKIAllbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2Q7CisJdTE2IG9vYl9wd19pZDsKIAogCXN0cnVjdCBwMnBfcGVlcl9pbmZvIGluZm87CiAKQEAgLTc3LDggKzgzLDYgQEAKICNkZWZpbmUgUDJQX0RFVl9QUk9CRV9SRVFfT05MWSBCSVQoMCkKICNkZWZpbmUgUDJQX0RFVl9SRVBPUlRFRCBCSVQoMSkKICNkZWZpbmUgUDJQX0RFVl9OT1RfWUVUX1JFQURZIEJJVCgyKQotI2RlZmluZSBQMlBfREVWX1NEX0lORk8gQklUKDMpCi0jZGVmaW5lIFAyUF9ERVZfU0RfU0NIRURVTEUgQklUKDQpCiAjZGVmaW5lIFAyUF9ERVZfUERfUEVFUl9ESVNQTEFZIEJJVCg1KQogI2RlZmluZSBQMlBfREVWX1BEX1BFRVJfS0VZUEFEIEJJVCg2KQogI2RlZmluZSBQMlBfREVWX1VTRVJfUkVKRUNURUQgQklUKDcpCkBAIC05Myw5ICs5NywxMSBAQAogI2RlZmluZSBQMlBfREVWX1BSRUZFUl9QRVJTSVNURU5UX1JFQ09OTiBCSVQoMTYpCiAjZGVmaW5lIFAyUF9ERVZfUERfQkVGT1JFX0dPX05FRyBCSVQoMTcpCiAjZGVmaW5lIFAyUF9ERVZfTk9fUFJFRl9DSEFOIEJJVCgxOCkKKyNkZWZpbmUgUDJQX0RFVl9XQUlUX0lOVl9SRVFfQUNLIEJJVCgxOSkKIAl1bnNpZ25lZCBpbnQgZmxhZ3M7CiAKIAlpbnQgc3RhdHVzOyAvKiBlbnVtIHAycF9zdGF0dXNfY29kZSAqLworCXN0cnVjdCBvc19yZWx0aW1lIGdvX25lZ193YWl0X3N0YXJ0ZWQ7CiAJdW5zaWduZWQgaW50IHdhaXRfY291bnQ7CiAJdW5zaWduZWQgaW50IGNvbm5lY3RfcmVxczsKIAl1bnNpZ25lZCBpbnQgaW52aXRhdGlvbl9yZXFzOwpAQCAtMTA1LDYgKzExMSwyMyBAQAogCiAJdTggZ29fdGltZW91dDsKIAl1OCBjbGllbnRfdGltZW91dDsKKworCS8qKgorCSAqIGdvX25lZ19jb25mX3NlbnQgLSBOdW1iZXIgb2YgR08gTmVnb3RpYXRpb24gQ29uZmlybWF0aW9uIHJldHJpZXMKKwkgKi8KKwl1OCBnb19uZWdfY29uZl9zZW50OworCisJLyoqCisJICogZnJlcSAtIEZycXVlbmN5IG9uIHdoaWNoIHRoZSBHTyBOZWdvdGlhdGlvbiBDb25maXJtYXRpb24gaXMgc2VudAorCSAqLworCWludCBnb19uZWdfY29uZl9mcmVxOworCisJLyoqCisJICogZ29fbmVnX2NvbmYgLSBHTyBOZWdvdGlhdGlvbiBDb25maXJtYXRpb24gZnJhbWUKKwkgKi8KKwlzdHJ1Y3Qgd3BhYnVmICpnb19uZWdfY29uZjsKKworCWludCBzZF9wZW5kaW5nX2JjYXN0X3F1ZXJpZXM7CiB9OwogCiBzdHJ1Y3QgcDJwX3NkX3F1ZXJ5IHsKQEAgLTIwNSwxNiArMjI4LDYgQEAKIAkJICogUDJQX0lOVklURV9MSVNURU4gLSBMaXN0ZW4gZHVyaW5nIEludml0ZQogCQkgKi8KIAkJUDJQX0lOVklURV9MSVNURU4sCi0KLQkJLyoqCi0JCSAqIFAyUF9TRUFSQ0hfV0hFTl9SRUFEWSAtIFdhaXRpbmcgdG8gc3RhcnQgU2VhcmNoCi0JCSAqLwotCQlQMlBfU0VBUkNIX1dIRU5fUkVBRFksCi0KLQkJLyoqCi0JCSAqIFAyUF9DT05USU5VRV9TRUFSQ0hfV0hFTl9SRUFEWSAtIFdhaXRpbmcgdG8gY29udGludWUgU2VhcmNoCi0JCSAqLwotCQlQMlBfQ09OVElOVUVfU0VBUkNIX1dIRU5fUkVBRFksCiAJfSBzdGF0ZTsKIAogCS8qKgpAQCAtMjM3LDE0ICsyNTAsNiBAQAogCSAqLwogCXN0cnVjdCBkbF9saXN0IGRldmljZXM7CiAKLSNpZmRlZiBBTkRST0lEX1AyUAotCS8qKgotCSAqIHNkX2Rldl9saXN0IC0gZGV2aWNlIHBvaW50ZXIgdG8gYmUgc2VydmljZWQgbmV4dAotCSAqIGZvciBzZXJ2aWNlIGRpc2NvdmVyeQotCSAqLwotCXN0cnVjdCBkbF9saXN0ICpzZF9kZXZfbGlzdDsKLSNlbmRpZgotCiAJLyoqCiAJICogZ29fbmVnX3BlZXIgLSBQb2ludGVyIHRvIEdPIE5lZ290aWF0aW9uIHBlZXIKIAkgKi8KQEAgLTI1Nyw2ICsyNjIsNyBAQAogCiAJY29uc3QgdTggKmludml0ZV9nb19kZXZfYWRkcjsKIAl1OCBpbnZpdGVfZ29fZGV2X2FkZHJfYnVmW0VUSF9BTEVOXTsKKwlpbnQgaW52aXRlX2Rldl9wd19pZDsKIAogCS8qKgogCSAqIHNkX3BlZXIgLSBQb2ludGVyIHRvIFNlcnZpY2UgRGlzY292ZXJ5IHBlZXIKQEAgLTI2OCw2ICsyNzQsMTIgQEAKIAkgKi8KIAlzdHJ1Y3QgcDJwX3NkX3F1ZXJ5ICpzZF9xdWVyeTsKIAorCS8qKgorCSAqIG51bV9wMnBfc2RfcXVlcmllcyAtIFRvdGFsIG51bWJlciBvZiBicm9hZGNhc3QgU0QgcXVlcmllcyBwcmVzZW50IGluCisJICogdGhlIGxpc3QKKwkgKi8KKwlpbnQgbnVtX3AycF9zZF9xdWVyaWVzOworCiAJLyogR08gTmVnb3RpYXRpb24gZGF0YSAqLwogCiAJLyoqCkBAIC0zMjQsNiArMzM2LDggQEAKIAkgKi8KIAlzdHJ1Y3QgcDJwX2NoYW5uZWxzIGNoYW5uZWxzOwogCisJc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3Qgbm9fZ29fZnJlcTsKKwogCWVudW0gcDJwX3BlbmRpbmdfYWN0aW9uX3N0YXRlIHsKIAkJUDJQX05PX1BFTkRJTkdfQUNUSU9OLAogCQlQMlBfUEVORElOR19HT19ORUdfUkVRVUVTVCwKQEAgLTM5NCw2ICs0MDgsNyBAQAogCXU4IGFmdGVyX3NjYW5fcGVlcltFVEhfQUxFTl07CiAJc3RydWN0IHAycF9wZW5kaW5nX2FjdGlvbl90eCAqYWZ0ZXJfc2Nhbl90eDsKIAl1bnNpZ25lZCBpbnQgYWZ0ZXJfc2Nhbl90eF9pbl9wcm9ncmVzczoxOworCXVuc2lnbmVkIGludCBzZW5kX2FjdGlvbl9pbl9wcm9ncmVzczoxOwogCiAJLyogUmVxdWVzdGVkIGRldmljZSB0eXBlcyBmb3IgZmluZC9zZWFyY2ggKi8KIAl1bnNpZ25lZCBpbnQgbnVtX3JlcV9kZXZfdHlwZXM7CkBAIC00MDEsNyArNDE2LDcgQEAKIAl1OCAqZmluZF9kZXZfaWQ7CiAJdTggZmluZF9kZXZfaWRfYnVmW0VUSF9BTEVOXTsKIAotCXN0cnVjdCBvc190aW1lIGZpbmRfc3RhcnQ7IC8qIHRpbWUgb2YgbGFzdCBwMnBfZmluZCBzdGFydCAqLworCXN0cnVjdCBvc19yZWx0aW1lIGZpbmRfc3RhcnQ7IC8qIHRpbWUgb2YgbGFzdCBwMnBfZmluZCBzdGFydCAqLwogCiAJc3RydWN0IHAycF9ncm91cCAqKmdyb3VwczsKIAlzaXplX3QgbnVtX2dyb3VwczsKQEAgLTQ1MCw2ICs0NjUsMTQgQEAKIAkgKi8KIAlpbnQgcGRfcmV0cmllczsKIAorCS8qKgorCSAqIHBkX2ZvcmNlX2ZyZXEgLSBGb3JjZWQgZnJlcXVlbmN5IGZvciBQRCByZXRyaWVzIG9yIDAgdG8gYXV0by1zZWxlY3QKKwkgKgorCSAqIFRoaXMgaXMgaXMgdXNlZCBkdXJpbmcgUEQgcmV0cmllcyBmb3Igam9pbi1hLWdyb3VwIGNhc2UgdG8gdXNlIHRoZQorCSAqIGNvcnJlY3Qgb3BlcmF0aW5nIGZyZXF1ZW5jeSBkZXRlcm1pbmVkIGZyb20gYSBCU1MgZW50cnkgZm9yIHRoZSBHTy4KKwkgKi8KKwlpbnQgcGRfZm9yY2VfZnJlcTsKKwogCXU4IGdvX3RpbWVvdXQ7CiAJdTggY2xpZW50X3RpbWVvdXQ7CiAKQEAgLTQ1Nyw2ICs0ODAsMTAgQEAKIAl1bnNpZ25lZCBpbnQgc2VhcmNoX2RlbGF5OwogCWludCBpbl9zZWFyY2hfZGVsYXk7CiAKKwl1OCBwZW5kaW5nX3JlZ19jbGFzczsKKwl1OCBwZW5kaW5nX2NoYW5uZWw7CisJdTggcGVuZGluZ19jaGFubmVsX2ZvcmNlZDsKKwogI2lmZGVmIENPTkZJR19XSUZJX0RJU1BMQVkKIAlzdHJ1Y3Qgd3BhYnVmICp3ZmRfaWVfYmVhY29uOwogCXN0cnVjdCB3cGFidWYgKndmZF9pZV9wcm9iZV9yZXE7CkBAIC00NzAsNiArNDk3LDEwIEBACiAJc3RydWN0IHdwYWJ1ZiAqd2ZkX2Fzc29jX2Jzc2lkOwogCXN0cnVjdCB3cGFidWYgKndmZF9jb3VwbGVkX3NpbmtfaW5mbzsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCisKKwl1MTYgYXV0aG9yaXplZF9vb2JfZGV2X3B3X2lkOworCisJc3RydWN0IHdwYWJ1ZiAqKnZlbmRvcl9lbGVtOwogfTsKIAogLyoqCkBAIC01MTEsNiArNTQyLDggQEAKIAogCWNvbnN0IHU4ICptaW5vcl9yZWFzb25fY29kZTsKIAorCWNvbnN0IHU4ICpvb2JfZ29fbmVnX2NoYW5uZWw7CisKIAkvKiBQMlAgRGV2aWNlIEluZm8gKi8KIAljb25zdCB1OCAqcDJwX2RldmljZV9pbmZvOwogCXNpemVfdCBwMnBfZGV2aWNlX2luZm9fbGVuOwpAQCAtNTIyLDYgKzU1NSw3IEBACiAKIAkvKiBXUFMgSUUgKi8KIAl1MTYgZGV2X3Bhc3N3b3JkX2lkOworCWludCBkZXZfcGFzc3dvcmRfaWRfcHJlc2VudDsKIAl1MTYgd3BzX2NvbmZpZ19tZXRob2RzOwogCWNvbnN0IHU4ICp3cHNfcHJpX2Rldl90eXBlOwogCWNvbnN0IHU4ICp3cHNfc2VjX2Rldl90eXBlX2xpc3Q7CkBAIC01MzYsNiArNTcwLDggQEAKIAlzaXplX3QgbW9kZWxfbnVtYmVyX2xlbjsKIAljb25zdCB1OCAqc2VyaWFsX251bWJlcjsKIAlzaXplX3Qgc2VyaWFsX251bWJlcl9sZW47CisJY29uc3QgdTggKm9vYl9kZXZfcGFzc3dvcmQ7CisJc2l6ZV90IG9vYl9kZXZfcGFzc3dvcmRfbGVuOwogCiAJLyogRFMgUGFyYW1ldGVyIFNldCBJRSAqLwogCWNvbnN0IHU4ICpkc19wYXJhbXM7CkBAIC01NzAsMTYgKzYwNiwyNiBAQAogdm9pZCBwMnBfY2hhbm5lbHNfaW50ZXJzZWN0KGNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbHMgKmEsCiAJCQkgICAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqYiwKIAkJCSAgICBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpyZXMpOwordm9pZCBwMnBfY2hhbm5lbHNfdW5pb24oY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqYSwKKwkJCWNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbHMgKmIsCisJCQlzdHJ1Y3QgcDJwX2NoYW5uZWxzICpyZXMpOwordm9pZCBwMnBfY2hhbm5lbHNfcmVtb3ZlX2ZyZXFzKHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW4sCisJCQkgICAgICAgY29uc3Qgc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3QgKmxpc3QpOwogaW50IHAycF9jaGFubmVsc19pbmNsdWRlcyhjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscywgdTggcmVnX2NsYXNzLAogCQkJICB1OCBjaGFubmVsKTsKLSNpZmRlZiBBTkRST0lEX1AyUAotc2l6ZV90IHAycF9jb3B5X3JlZ19jbGFzcyhzdHJ1Y3QgcDJwX3JlZ19jbGFzcyAqZGMsIHN0cnVjdCBwMnBfcmVnX2NsYXNzICpzYyk7Ci0jZW5kaWYKK3ZvaWQgcDJwX2NoYW5uZWxzX2R1bXAoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IGNoYXIgKnRpdGxlLAorCQkgICAgICAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2hhbik7CitpbnQgcDJwX2NoYW5uZWxfc2VsZWN0KHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW5zLCBjb25zdCBpbnQgKmNsYXNzZXMsCisJCSAgICAgICB1OCAqb3BfY2xhc3MsIHU4ICpvcF9jaGFubmVsKTsKK2ludCBwMnBfY2hhbm5lbF9yYW5kb21fc29jaWFsKHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW5zLCB1OCAqb3BfY2xhc3MsCisJCQkgICAgICB1OCAqb3BfY2hhbm5lbCk7CiAKIC8qIHAycF9wYXJzZS5jICovCiBpbnQgcDJwX3BhcnNlX3AycF9pZShjb25zdCBzdHJ1Y3Qgd3BhYnVmICpidWYsIHN0cnVjdCBwMnBfbWVzc2FnZSAqbXNnKTsKIGludCBwMnBfcGFyc2VfaWVzKGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuLCBzdHJ1Y3QgcDJwX21lc3NhZ2UgKm1zZyk7CiBpbnQgcDJwX3BhcnNlKGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuLCBzdHJ1Y3QgcDJwX21lc3NhZ2UgKm1zZyk7CitpbnQgcDJwX3BhcnNlX2llc19zZXBhcmF0ZShjb25zdCB1OCAqd3NjLCBzaXplX3Qgd3NjX2xlbiwgY29uc3QgdTggKnAycCwKKwkJCSAgIHNpemVfdCBwMnBfbGVuLCBzdHJ1Y3QgcDJwX21lc3NhZ2UgKm1zZyk7CiB2b2lkIHAycF9wYXJzZV9mcmVlKHN0cnVjdCBwMnBfbWVzc2FnZSAqbXNnKTsKIGludCBwMnBfYXR0cl90ZXh0KHN0cnVjdCB3cGFidWYgKmRhdGEsIGNoYXIgKmJ1ZiwgY2hhciAqZW5kKTsKIGludCBwMnBfZ3JvdXBfaW5mb19wYXJzZShjb25zdCB1OCAqZ2ksIHNpemVfdCBnaV9sZW4sCkBAIC02MDIsNyArNjQ4LDEyIEBACiBpbnQgcDJwX2dyb3VwX2lzX2dyb3VwX2lkX21hdGNoKHN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwLCBjb25zdCB1OCAqZ3JvdXBfaWQsCiAJCQkJc2l6ZV90IGdyb3VwX2lkX2xlbik7CiB2b2lkIHAycF9ncm91cF91cGRhdGVfaWVzKHN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwKTsKK3ZvaWQgcDJwX2dyb3VwX2ZvcmNlX2JlYWNvbl91cGRhdGVfaWVzKHN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwKTsKIHN0cnVjdCB3cGFidWYgKiBwMnBfZ3JvdXBfZ2V0X3dmZF9pZShzdHJ1Y3QgcDJwX2dyb3VwICpnKTsKK3ZvaWQgcDJwX2J1Zl9hZGRfZ3JvdXBfaW5mbyhzdHJ1Y3QgcDJwX2dyb3VwICpncm91cCwgc3RydWN0IHdwYWJ1ZiAqYnVmLAorCQkJICAgIGludCBtYXhfY2xpZW50cyk7Cit2b2lkIHAycF9ncm91cF9idWZfYWRkX2lkKHN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwLCBzdHJ1Y3Qgd3BhYnVmICpidWYpOworaW50IHAycF9ncm91cF9nZXRfZnJlcShzdHJ1Y3QgcDJwX2dyb3VwICpncm91cCk7CiAKIAogdm9pZCBwMnBfYnVmX2FkZF9hY3Rpb25faGRyKHN0cnVjdCB3cGFidWYgKmJ1ZiwgdTggc3VidHlwZSwgdTggZGlhbG9nX3Rva2VuKTsKQEAgLTYzNCw4ICs2ODUsMTEgQEAKIHZvaWQgcDJwX2J1Zl9hZGRfZXh0X2xpc3Rlbl90aW1pbmcoc3RydWN0IHdwYWJ1ZiAqYnVmLCB1MTYgcGVyaW9kLAogCQkJCSAgIHUxNiBpbnRlcnZhbCk7CiB2b2lkIHAycF9idWZfYWRkX3AycF9pbnRlcmZhY2Uoc3RydWN0IHdwYWJ1ZiAqYnVmLCBzdHJ1Y3QgcDJwX2RhdGEgKnAycCk7Ci12b2lkIHAycF9idWlsZF93cHNfaWUoc3RydWN0IHAycF9kYXRhICpwMnAsIHN0cnVjdCB3cGFidWYgKmJ1ZiwgaW50IHB3X2lkLAotCQkgICAgICBpbnQgYWxsX2F0dHIpOwordm9pZCBwMnBfYnVmX2FkZF9vb2JfZ29fbmVnX2NoYW5uZWwoc3RydWN0IHdwYWJ1ZiAqYnVmLCBjb25zdCBjaGFyICpjb3VudHJ5LAorCQkJCSAgICB1OCBvcGVyX2NsYXNzLCB1OCBjaGFubmVsLAorCQkJCSAgICBlbnVtIHAycF9yb2xlX2luZGljYXRpb24gcm9sZSk7CitpbnQgcDJwX2J1aWxkX3dwc19pZShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqYnVmLCBpbnQgcHdfaWQsCisJCSAgICAgaW50IGFsbF9hdHRyKTsKIAogLyogcDJwX3NkLmMgKi8KIHN0cnVjdCBwMnBfc2RfcXVlcnkgKiBwMnBfcGVuZGluZ19zZF9yZXEoc3RydWN0IHAycF9kYXRhICpwMnAsCkBAIC02ODEsNyArNzM1LDcgQEAKIHZvaWQgcDJwX3Byb2Nlc3NfaW52aXRhdGlvbl9yZXNwKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqc2EsCiAJCQkJIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuKTsKIGludCBwMnBfaW52aXRlX3NlbmQoc3RydWN0IHAycF9kYXRhICpwMnAsIHN0cnVjdCBwMnBfZGV2aWNlICpkZXYsCi0JCSAgICBjb25zdCB1OCAqZ29fZGV2X2FkZHIpOworCQkgICAgY29uc3QgdTggKmdvX2Rldl9hZGRyLCBpbnQgZGV2X3B3X2lkKTsKIHZvaWQgcDJwX2ludml0YXRpb25fcmVxX2NiKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBpbnQgc3VjY2Vzcyk7CiB2b2lkIHAycF9pbnZpdGF0aW9uX3Jlc3BfY2Ioc3RydWN0IHAycF9kYXRhICpwMnAsIGludCBzdWNjZXNzKTsKIApAQCAtNzA5LDcgKzc2Myw3IEBACiB2b2lkIHAycF9hZGRfZGV2X2luZm8oc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyLAogCQkgICAgICBzdHJ1Y3QgcDJwX2RldmljZSAqZGV2LCBzdHJ1Y3QgcDJwX21lc3NhZ2UgKm1zZyk7CiBpbnQgcDJwX2FkZF9kZXZpY2Uoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyLCBpbnQgZnJlcSwKLQkJICAgc3RydWN0IG9zX3RpbWUgKnJ4X3RpbWUsIGludCBsZXZlbCwgY29uc3QgdTggKmllcywKKwkJICAgc3RydWN0IG9zX3JlbHRpbWUgKnJ4X3RpbWUsIGludCBsZXZlbCwgY29uc3QgdTggKmllcywKIAkJICAgc2l6ZV90IGllc19sZW4sIGludCBzY2FuX3Jlcyk7CiBzdHJ1Y3QgcDJwX2RldmljZSAqIHAycF9nZXRfZGV2aWNlKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqYWRkcik7CiBzdHJ1Y3QgcDJwX2RldmljZSAqIHAycF9nZXRfZGV2aWNlX2ludGVyZmFjZShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKQEAgLTcyNyw3ICs3ODEsOCBAQAogCQkgICAgc2l6ZV90IGxlbiwgdW5zaWduZWQgaW50IHdhaXRfdGltZSk7CiB2b2lkIHAycF9zdG9wX2xpc3Rlbl9mb3JfZnJlcShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgaW50IGZyZXEpOwogaW50IHAycF9wcmVwYXJlX2NoYW5uZWwoc3RydWN0IHAycF9kYXRhICpwMnAsIHN0cnVjdCBwMnBfZGV2aWNlICpkZXYsCi0JCQl1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgdW5zaWduZWQgaW50IHByZWZfZnJlcSk7CisJCQl1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgdW5zaWduZWQgaW50IHByZWZfZnJlcSwKKwkJCWludCBnbyk7CiB2b2lkIHAycF9kYmcoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQogUFJJTlRGX0ZPUk1BVCgyLCAzKTsKIHZvaWQgcDJwX2luZm8oc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQpkaWZmIC0tZ2l0IGEvc3JjL3AycC9wMnBfaW52aXRhdGlvbi5jIGIvc3JjL3AycC9wMnBfaW52aXRhdGlvbi5jCmluZGV4IDZiM2RhZmIuLmVmMDFhNjYgMTAwNjQ0Ci0tLSBhL3NyYy9wMnAvcDJwX2ludml0YXRpb24uYworKysgYi9zcmMvcDJwL3AycF9pbnZpdGF0aW9uLmMKQEAgLTEwLDEzICsxMCwxNSBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgorI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgInAycF9pLmgiCiAjaW5jbHVkZSAicDJwLmgiCiAKIAogc3RhdGljIHN0cnVjdCB3cGFidWYgKiBwMnBfYnVpbGRfaW52aXRhdGlvbl9yZXEoc3RydWN0IHAycF9kYXRhICpwMnAsCiAJCQkJCQlzdHJ1Y3QgcDJwX2RldmljZSAqcGVlciwKLQkJCQkJCWNvbnN0IHU4ICpnb19kZXZfYWRkcikKKwkJCQkJCWNvbnN0IHU4ICpnb19kZXZfYWRkciwKKwkJCQkJCWludCBkZXZfcHdfaWQpCiB7CiAJc3RydWN0IHdwYWJ1ZiAqYnVmOwogCXU4ICpsZW47CkBAIC00NCw2ICs0Niw5IEBACiAJCWV4dHJhID0gd3BhYnVmX2xlbih3ZmRfaWUpOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChwMnAtPnZlbmRvcl9lbGVtICYmIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0lOVl9SRVFdKQorCQlleHRyYSArPSB3cGFidWZfbGVuKHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX0lOVl9SRVFdKTsKKwogCWJ1ZiA9IHdwYWJ1Zl9hbGxvYygxMDAwICsgZXh0cmEpOwogCWlmIChidWYgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CkBAIC04NSw2ICs5MCwxNCBAQAogCQl3cGFidWZfcHV0X2J1ZihidWYsIHdmZF9pZSk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKHAycC0+dmVuZG9yX2VsZW0gJiYgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfSU5WX1JFUV0pCisJCXdwYWJ1Zl9wdXRfYnVmKGJ1ZiwgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfSU5WX1JFUV0pOworCisJaWYgKGRldl9wd19pZCA+PSAwKSB7CisJCS8qIFdTQyBJRSBpbiBJbnZpdGF0aW9uIFJlcXVlc3QgZm9yIE5GQyBzdGF0aWMgaGFuZG92ZXIgKi8KKwkJcDJwX2J1aWxkX3dwc19pZShwMnAsIGJ1ZiwgZGV2X3B3X2lkLCAwKTsKKwl9CisKIAlyZXR1cm4gYnVmOwogfQogCkBAIC0yMjEsMTQgKzIzNCwxOCBAQAogCQlnb3RvIGZhaWw7CiAJfQogCisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAib3duIGNoYW5uZWxzIiwgJnAycC0+Y2ZnLT5jaGFubmVscyk7CisJcDJwX2NoYW5uZWxzX2R1bXAocDJwLCAicGVlciBjaGFubmVscyIsICZkZXYtPmNoYW5uZWxzKTsKIAlwMnBfY2hhbm5lbHNfaW50ZXJzZWN0KCZwMnAtPmNmZy0+Y2hhbm5lbHMsICZkZXYtPmNoYW5uZWxzLAogCQkJICAgICAgICZpbnRlcnNlY3Rpb24pOworCXAycF9jaGFubmVsc19kdW1wKHAycCwgImludGVyc2VjdGlvbiIsICZpbnRlcnNlY3Rpb24pOwogCiAJaWYgKHAycC0+Y2ZnLT5pbnZpdGF0aW9uX3Byb2Nlc3MpIHsKIAkJc3RhdHVzID0gcDJwLT5jZmctPmludml0YXRpb25fcHJvY2VzcygKIAkJCXAycC0+Y2ZnLT5jYl9jdHgsIHNhLCBtc2cuZ3JvdXBfYnNzaWQsIG1zZy5ncm91cF9pZCwKIAkJCW1zZy5ncm91cF9pZCArIEVUSF9BTEVOLCBtc2cuZ3JvdXBfaWRfbGVuIC0gRVRIX0FMRU4sCi0JCQkmZ28sIGdyb3VwX2Jzc2lkLCAmb3BfZnJlcSwgcGVyc2lzdGVudCwgJmludGVyc2VjdGlvbik7CisJCQkmZ28sIGdyb3VwX2Jzc2lkLCAmb3BfZnJlcSwgcGVyc2lzdGVudCwgJmludGVyc2VjdGlvbiwKKwkJCW1zZy5kZXZfcGFzc3dvcmRfaWRfcHJlc2VudCA/IG1zZy5kZXZfcGFzc3dvcmRfaWQgOiAtMSk7CiAJfQogCiAJaWYgKG9wX2ZyZXEpIHsKQEAgLTI4MSw3ICsyOTgsOSBAQAogCQkJfQogCQl9CiAKLQkJaWYgKCFwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJmludGVyc2VjdGlvbiwgcDJwLT5vcF9yZWdfY2xhc3MsCisJCS8qIFJlc2VsZWN0IHRoZSBjaGFubmVsIG9ubHkgZm9yIHRoZSBjYXNlIG9mIHRoZSBHTyAqLworCQlpZiAoZ28gJiYKKwkJICAgICFwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJmludGVyc2VjdGlvbiwgcDJwLT5vcF9yZWdfY2xhc3MsCiAJCQkJCSAgIHAycC0+b3BfY2hhbm5lbCkpIHsKIAkJCXAycF9kYmcocDJwLCAiSW5pdGlhbGx5IHNlbGVjdGVkIGNoYW5uZWwgKG9wX2NsYXNzICVkIGNoYW5uZWwgJWQpIG5vdCBpbiBjaGFubmVsIGludGVyc2VjdGlvbiAtIHRyeSB0byByZXNlbGVjdCIsCiAJCQkJcDJwLT5vcF9yZWdfY2xhc3MsIHAycC0+b3BfY2hhbm5lbCk7CkBAIC0yOTYsNyArMzE1LDcgQEAKIAkJCQlzdGF0dXMgPSBQMlBfU0NfRkFJTF9OT19DT01NT05fQ0hBTk5FTFM7CiAJCQkJZ290byBmYWlsOwogCQkJfQotCQl9IGVsc2UgaWYgKCEoZGV2LT5mbGFncyAmIFAyUF9ERVZfRk9SQ0VfRlJFUSkgJiYKKwkJfSBlbHNlIGlmIChnbyAmJiAhKGRldi0+ZmxhZ3MgJiBQMlBfREVWX0ZPUkNFX0ZSRVEpICYmCiAJCQkgICAhcDJwLT5jZmctPmNmZ19vcF9jaGFubmVsKSB7CiAJCQlwMnBfZGJnKHAycCwgIlRyeSB0byByZXNlbGVjdCBjaGFubmVsIHNlbGVjdGlvbiB3aXRoIHBlZXIgaW5mb3JtYXRpb24gcmVjZWl2ZWQ7IHByZXZpb3VzbHkgc2VsZWN0ZWQgb3BfY2xhc3MgJXUgY2hhbm5lbCAldSIsCiAJCQkJcDJwLT5vcF9yZWdfY2xhc3MsIHAycC0+b3BfY2hhbm5lbCk7CkBAIC0zNTIsMTIgKzM3MSwxNyBAQAogCQlwMnAtPmludl9ncm91cF9ic3NpZF9wdHIgPSBwMnAtPmludl9ncm91cF9ic3NpZDsKIAl9IGVsc2UKIAkJcDJwLT5pbnZfZ3JvdXBfYnNzaWRfcHRyID0gTlVMTDsKLQlpZiAobXNnLmdyb3VwX2lkX2xlbiAtIEVUSF9BTEVOIDw9IDMyKSB7Ci0JCW9zX21lbWNweShwMnAtPmludl9zc2lkLCBtc2cuZ3JvdXBfaWQgKyBFVEhfQUxFTiwKLQkJCSAgbXNnLmdyb3VwX2lkX2xlbiAtIEVUSF9BTEVOKTsKLQkJcDJwLT5pbnZfc3NpZF9sZW4gPSBtc2cuZ3JvdXBfaWRfbGVuIC0gRVRIX0FMRU47CisJaWYgKG1zZy5ncm91cF9pZCkgeworCQlpZiAobXNnLmdyb3VwX2lkX2xlbiAtIEVUSF9BTEVOIDw9IDMyKSB7CisJCQlvc19tZW1jcHkocDJwLT5pbnZfc3NpZCwgbXNnLmdyb3VwX2lkICsgRVRIX0FMRU4sCisJCQkJICBtc2cuZ3JvdXBfaWRfbGVuIC0gRVRIX0FMRU4pOworCQkJcDJwLT5pbnZfc3NpZF9sZW4gPSBtc2cuZ3JvdXBfaWRfbGVuIC0gRVRIX0FMRU47CisJCX0KKwkJb3NfbWVtY3B5KHAycC0+aW52X2dvX2Rldl9hZGRyLCBtc2cuZ3JvdXBfaWQsIEVUSF9BTEVOKTsKKwl9IGVsc2UgeworCQlwMnAtPmludl9zc2lkX2xlbiA9IDA7CisJCW9zX21lbXNldChwMnAtPmludl9nb19kZXZfYWRkciwgMCwgRVRIX0FMRU4pOwogCX0KLQlvc19tZW1jcHkocDJwLT5pbnZfZ29fZGV2X2FkZHIsIG1zZy5ncm91cF9pZCwgRVRIX0FMRU4pOwogCXAycC0+aW52X3N0YXR1cyA9IHN0YXR1czsKIAlwMnAtPmludl9vcF9mcmVxID0gb3BfZnJlcTsKIApAQCAtNDA3LDcgKzQzMSw3IEBACiAJCXJldHVybjsKIAl9CiAKLQlpZiAoIW1zZy5jaGFubmVsX2xpc3QpIHsKKwlpZiAoIW1zZy5jaGFubmVsX2xpc3QgJiYgKm1zZy5zdGF0dXMgPT0gUDJQX1NDX1NVQ0NFU1MpIHsKIAkJcDJwX2RiZyhwMnAsICJNYW5kYXRvcnkgQ2hhbm5lbCBMaXN0IGF0dHJpYnV0ZSBtaXNzaW5nIGluIEludml0YXRpb24gUmVzcG9uc2UgZnJvbSAiCiAJCQlNQUNTVFIsIE1BQzJTVFIoc2EpKTsKICNpZmRlZiBDT05GSUdfUDJQX1NUUklDVApAQCAtNDE2LDYgKzQ0MCw5IEBACiAjZW5kaWYgLyogQ09ORklHX1AyUF9TVFJJQ1QgKi8KIAkJLyogVHJ5IHRvIHN1cnZpdmUgd2l0aG91dCBwZWVyIGNoYW5uZWwgbGlzdCAqLwogCQljaGFubmVscyA9ICZwMnAtPmNoYW5uZWxzOworCX0gZWxzZSBpZiAoIW1zZy5jaGFubmVsX2xpc3QpIHsKKwkJLyogTm9uLXN1Y2Nlc3MgY2FzZXMgYXJlIG5vdCByZXF1aXJlZCB0byBpbmNsdWRlIENoYW5uZWwgTGlzdCAqLworCQljaGFubmVscyA9ICZwMnAtPmNoYW5uZWxzOwogCX0gZWxzZSBpZiAocDJwX3BlZXJfY2hhbm5lbHNfY2hlY2socDJwLCAmcDJwLT5jaGFubmVscywgZGV2LAogCQkJCQkgICBtc2cuY2hhbm5lbF9saXN0LAogCQkJCQkgICBtc2cuY2hhbm5lbF9saXN0X2xlbikgPCAwKSB7CkBAIC00MjgsOSArNDU1LDI1IEBACiAJCWNoYW5uZWxzID0gJmludGVyc2VjdGlvbjsKIAl9CiAKLQlpZiAocDJwLT5jZmctPmludml0YXRpb25fcmVzdWx0KQorCWlmIChwMnAtPmNmZy0+aW52aXRhdGlvbl9yZXN1bHQpIHsKKwkJaW50IHBlZXJfb3Blcl9mcmVxID0gMDsKKwkJaW50IGZyZXEgPSBwMnBfY2hhbm5lbF90b19mcmVxKHAycC0+b3BfcmVnX2NsYXNzLAorCQkJCQkgICAgICAgcDJwLT5vcF9jaGFubmVsKTsKKwkJaWYgKGZyZXEgPCAwKQorCQkJZnJlcSA9IDA7CisKKwkJaWYgKG1zZy5vcGVyYXRpbmdfY2hhbm5lbCkgeworCQkJcGVlcl9vcGVyX2ZyZXEgPSBwMnBfY2hhbm5lbF90b19mcmVxKAorCQkJCW1zZy5vcGVyYXRpbmdfY2hhbm5lbFszXSwKKwkJCQltc2cub3BlcmF0aW5nX2NoYW5uZWxbNF0pOworCQkJaWYgKHBlZXJfb3Blcl9mcmVxIDwgMCkKKwkJCQlwZWVyX29wZXJfZnJlcSA9IDA7CisJCX0KKwogCQlwMnAtPmNmZy0+aW52aXRhdGlvbl9yZXN1bHQocDJwLT5jZmctPmNiX2N0eCwgKm1zZy5zdGF0dXMsCi0JCQkJCSAgICBtc2cuZ3JvdXBfYnNzaWQsIGNoYW5uZWxzLCBzYSk7CisJCQkJCSAgICBtc2cuZ3JvdXBfYnNzaWQsIGNoYW5uZWxzLCBzYSwKKwkJCQkJICAgIGZyZXEsIHBlZXJfb3Blcl9mcmVxKTsKKwl9CiAKIAlwMnBfcGFyc2VfZnJlZSgmbXNnKTsKIApAQCAtNDQxLDEyICs0ODQsMTQgQEAKIAogCiBpbnQgcDJwX2ludml0ZV9zZW5kKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBzdHJ1Y3QgcDJwX2RldmljZSAqZGV2LAotCQkgICAgY29uc3QgdTggKmdvX2Rldl9hZGRyKQorCQkgICAgY29uc3QgdTggKmdvX2Rldl9hZGRyLCBpbnQgZGV2X3B3X2lkKQogewogCXN0cnVjdCB3cGFidWYgKnJlcTsKIAlpbnQgZnJlcTsKIAogCWZyZXEgPSBkZXYtPmxpc3Rlbl9mcmVxID4gMCA/IGRldi0+bGlzdGVuX2ZyZXEgOiBkZXYtPm9wZXJfZnJlcTsKKwlpZiAoZnJlcSA8PSAwKQorCQlmcmVxID0gZGV2LT5vb2JfZ29fbmVnX2ZyZXE7CiAJaWYgKGZyZXEgPD0gMCkgewogCQlwMnBfZGJnKHAycCwgIk5vIExpc3Rlbi9PcGVyYXRpbmcgZnJlcXVlbmN5IGtub3duIGZvciB0aGUgcGVlciAiCiAJCQlNQUNTVFIgIiB0byBzZW5kIEludml0YXRpb24gUmVxdWVzdCIsCkBAIC00NTQsNyArNDk5LDcgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCXJlcSA9IHAycF9idWlsZF9pbnZpdGF0aW9uX3JlcShwMnAsIGRldiwgZ29fZGV2X2FkZHIpOworCXJlcSA9IHAycF9idWlsZF9pbnZpdGF0aW9uX3JlcShwMnAsIGRldiwgZ29fZGV2X2FkZHIsIGRldl9wd19pZCk7CiAJaWYgKHJlcSA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAJaWYgKHAycC0+c3RhdGUgIT0gUDJQX0lETEUpCkBAIC00NjYsMTAgKzUxMSwxMiBAQAogCWRldi0+aW52aXRhdGlvbl9yZXFzKys7CiAJaWYgKHAycF9zZW5kX2FjdGlvbihwMnAsIGZyZXEsIGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCiAJCQkgICAgcDJwLT5jZmctPmRldl9hZGRyLCBkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyLAotCQkJICAgIHdwYWJ1Zl9oZWFkKHJlcSksIHdwYWJ1Zl9sZW4ocmVxKSwgMjAwKSA8IDApIHsKKwkJCSAgICB3cGFidWZfaGVhZChyZXEpLCB3cGFidWZfbGVuKHJlcSksIDUwMCkgPCAwKSB7CiAJCXAycF9kYmcocDJwLCAiRmFpbGVkIHRvIHNlbmQgQWN0aW9uIGZyYW1lIik7CiAJCS8qIFVzZSBQMlAgZmluZCB0byByZWNvdmVyIGFuZCByZXRyeSAqLwogCQlwMnBfc2V0X3RpbWVvdXQocDJwLCAwLCAwKTsKKwl9IGVsc2UgeworCQlkZXYtPmZsYWdzIHw9IFAyUF9ERVZfV0FJVF9JTlZfUkVRX0FDSzsKIAl9CiAKIAl3cGFidWZfZnJlZShyZXEpOwpAQCAtNDg3LDEyICs1MzQsMTUgQEAKIAkJcmV0dXJuOwogCX0KIAorCWlmIChzdWNjZXNzKQorCQlwMnAtPmludml0ZV9wZWVyLT5mbGFncyAmPSB+UDJQX0RFVl9XQUlUX0lOVl9SRVFfQUNLOworCiAJLyoKIAkgKiBVc2UgUDJQIGZpbmQsIGlmIG5lZWRlZCwgdG8gZmluZCB0aGUgb3RoZXIgZGV2aWNlIGZyb20gaXRzIGxpc3RlbgogCSAqIGNoYW5uZWwuCiAJICovCiAJcDJwX3NldF9zdGF0ZShwMnAsIFAyUF9JTlZJVEUpOwotCXAycF9zZXRfdGltZW91dChwMnAsIDAsIHN1Y2Nlc3MgPyAzNTAwMDAgOiAxMDAwMDApOworCXAycF9zZXRfdGltZW91dChwMnAsIDAsIHN1Y2Nlc3MgPyA1MDAwMDAgOiAxMDAwMDApOwogfQogCiAKQEAgLTUxOSw3ICs1NjksNyBAQAogaW50IHAycF9pbnZpdGUoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICpwZWVyLCBlbnVtIHAycF9pbnZpdGVfcm9sZSByb2xlLAogCSAgICAgICBjb25zdCB1OCAqYnNzaWQsIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4sCiAJICAgICAgIHVuc2lnbmVkIGludCBmb3JjZV9mcmVxLCBjb25zdCB1OCAqZ29fZGV2X2FkZHIsCi0JICAgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwLCB1bnNpZ25lZCBpbnQgcHJlZl9mcmVxKQorCSAgICAgICBpbnQgcGVyc2lzdGVudF9ncm91cCwgdW5zaWduZWQgaW50IHByZWZfZnJlcSwgaW50IGRldl9wd19pZCkKIHsKIAlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OwogCkBAIC01MzcsMTUgKzU4NywyMiBAQAogCQlwMnAtPmludml0ZV9nb19kZXZfYWRkciA9IE5VTEw7CiAJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiSW52aXRhdGlvbiBmb3IgU1NJRCIsCiAJCQkgIHNzaWQsIHNzaWRfbGVuKTsKKwlpZiAoZGV2X3B3X2lkID49IDApIHsKKwkJcDJwX2RiZyhwMnAsICJJbnZpdGF0aW9uIHRvIHVzZSBEZXZpY2UgUGFzc3dvcmQgSUQgJWQiLAorCQkJZGV2X3B3X2lkKTsKKwl9CisJcDJwLT5pbnZpdGVfZGV2X3B3X2lkID0gZGV2X3B3X2lkOwogCiAJZGV2ID0gcDJwX2dldF9kZXZpY2UocDJwLCBwZWVyKTsKLQlpZiAoZGV2ID09IE5VTEwgfHwgKGRldi0+bGlzdGVuX2ZyZXEgPD0gMCAmJiBkZXYtPm9wZXJfZnJlcSA8PSAwKSkgeworCWlmIChkZXYgPT0gTlVMTCB8fCAoZGV2LT5saXN0ZW5fZnJlcSA8PSAwICYmIGRldi0+b3Blcl9mcmVxIDw9IDAgJiYKKwkJCSAgICBkZXYtPm9vYl9nb19uZWdfZnJlcSA8PSAwKSkgewogCQlwMnBfZGJnKHAycCwgIkNhbm5vdCBpbnZpdGUgdW5rbm93biBQMlAgRGV2aWNlICIgTUFDU1RSLAogCQkJTUFDMlNUUihwZWVyKSk7CiAJCXJldHVybiAtMTsKIAl9CiAKLQlpZiAocDJwX3ByZXBhcmVfY2hhbm5lbChwMnAsIGRldiwgZm9yY2VfZnJlcSwgcHJlZl9mcmVxKSA8IDApCisJaWYgKHAycF9wcmVwYXJlX2NoYW5uZWwocDJwLCBkZXYsIGZvcmNlX2ZyZXEsIHByZWZfZnJlcSwKKwkJCQlyb2xlICE9IFAyUF9JTlZJVEVfUk9MRV9DTElFTlQpIDwgMCkKIAkJcmV0dXJuIC0xOwogCiAJaWYgKHBlcnNpc3RlbnRfZ3JvdXAgJiYgcm9sZSA9PSBQMlBfSU5WSVRFX1JPTEVfQ0xJRU5UICYmICFmb3JjZV9mcmVxICYmCkBAIC01NzYsNSArNjMzLDUgQEAKIAlvc19tZW1jcHkocDJwLT5pbnZfc3NpZCwgc3NpZCwgc3NpZF9sZW4pOwogCXAycC0+aW52X3NzaWRfbGVuID0gc3NpZF9sZW47CiAJcDJwLT5pbnZfcGVyc2lzdGVudCA9IHBlcnNpc3RlbnRfZ3JvdXA7Ci0JcmV0dXJuIHAycF9pbnZpdGVfc2VuZChwMnAsIGRldiwgZ29fZGV2X2FkZHIpOworCXJldHVybiBwMnBfaW52aXRlX3NlbmQocDJwLCBkZXYsIGdvX2Rldl9hZGRyLCBkZXZfcHdfaWQpOwogfQpkaWZmIC0tZ2l0IGEvc3JjL3AycC9wMnBfcGFyc2UuYyBiL3NyYy9wMnAvcDJwX3BhcnNlLmMKaW5kZXggMDk3YTMxZC4uZDYxNDRhMCAxMDA2NDQKLS0tIGEvc3JjL3AycC9wMnBfcGFyc2UuYworKysgYi9zcmMvcDJwL3AycF9wYXJzZS5jCkBAIC0yNjgsNiArMjY4LDE5IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiAqIE1pbm9yIFJlYXNvbiBDb2RlOiAldSIsCiAJCQkgICAqbXNnLT5taW5vcl9yZWFzb25fY29kZSk7CiAJCWJyZWFrOworCWNhc2UgUDJQX0FUVFJfT09CX0dPX05FR19DSEFOTkVMOgorCQlpZiAobGVuIDwgNikgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRvbyBzaG9ydCBPT0IgR08gTmVnICIKKwkJCQkgICAiQ2hhbm5lbCBhdHRyaWJ1dGUgKGxlbmd0aCAlZCkiLCBsZW4pOworCQkJcmV0dXJuIC0xOworCQl9CisJCW1zZy0+b29iX2dvX25lZ19jaGFubmVsID0gZGF0YTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6ICogT09CIEdPIE5lZyBDaGFubmVsOiAiCisJCQkgICAiQ291bnRyeSAlYyVjKDB4JTAyeCkgT3BlcmF0aW5nIENsYXNzICVkICIKKwkJCSAgICJDaGFubmVsIE51bWJlciAlZCBSb2xlICVkIiwKKwkJCSAgIGRhdGFbMF0sIGRhdGFbMV0sIGRhdGFbMl0sIGRhdGFbM10sIGRhdGFbNF0sCisJCQkgICBkYXRhWzVdKTsKKwkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNraXBwZWQgdW5rbm93biBhdHRyaWJ1dGUgJWQgIgogCQkJICAgIihsZW5ndGggJWQpIiwgaWQsIGxlbik7CkBAIC0zNDAsNiArMzUzLDcgQEAKIAkJbXNnLT5kZXZfcGFzc3dvcmRfaWQgPSBXUEFfR0VUX0JFMTYoYXR0ci5kZXZfcGFzc3dvcmRfaWQpOwogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRGV2aWNlIFBhc3N3b3JkIElEOiAlZCIsCiAJCQkgICBtc2ctPmRldl9wYXNzd29yZF9pZCk7CisJCW1zZy0+ZGV2X3Bhc3N3b3JkX2lkX3ByZXNlbnQgPSAxOwogCX0KIAlpZiAoYXR0ci5wcmltYXJ5X2Rldl90eXBlKSB7CiAJCWNoYXIgZGV2dHlwZVtXUFNfREVWX1RZUEVfQlVGU0laRV07CkBAIC0zNjcsNiArMzgxLDkgQEAKIAltc2ctPnNlcmlhbF9udW1iZXIgPSBhdHRyLnNlcmlhbF9udW1iZXI7CiAJbXNnLT5zZXJpYWxfbnVtYmVyX2xlbiA9IGF0dHIuc2VyaWFsX251bWJlcl9sZW47CiAKKwltc2ctPm9vYl9kZXZfcGFzc3dvcmQgPSBhdHRyLm9vYl9kZXZfcGFzc3dvcmQ7CisJbXNnLT5vb2JfZGV2X3Bhc3N3b3JkX2xlbiA9IGF0dHIub29iX2Rldl9wYXNzd29yZF9sZW47CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtNDUwLDYgKzQ2NywzMyBAQAogfQogCiAKK2ludCBwMnBfcGFyc2VfaWVzX3NlcGFyYXRlKGNvbnN0IHU4ICp3c2MsIHNpemVfdCB3c2NfbGVuLCBjb25zdCB1OCAqcDJwLAorCQkJICAgc2l6ZV90IHAycF9sZW4sIHN0cnVjdCBwMnBfbWVzc2FnZSAqbXNnKQoreworCW9zX21lbXNldChtc2csIDAsIHNpemVvZigqbXNnKSk7CisKKwltc2ctPndwc19hdHRyaWJ1dGVzID0gd3BhYnVmX2FsbG9jX2NvcHkod3NjLCB3c2NfbGVuKTsKKwlpZiAobXNnLT53cHNfYXR0cmlidXRlcyAmJgorCSAgICBwMnBfcGFyc2Vfd3BzX2llKG1zZy0+d3BzX2F0dHJpYnV0ZXMsIG1zZykpIHsKKwkJcDJwX3BhcnNlX2ZyZWUobXNnKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW1zZy0+cDJwX2F0dHJpYnV0ZXMgPSB3cGFidWZfYWxsb2NfY29weShwMnAsIHAycF9sZW4pOworCWlmIChtc2ctPnAycF9hdHRyaWJ1dGVzICYmCisJICAgIHAycF9wYXJzZV9wMnBfaWUobXNnLT5wMnBfYXR0cmlidXRlcywgbXNnKSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRmFpbGVkIHRvIHBhcnNlIFAyUCBJRSBkYXRhIik7CisJCWlmIChtc2ctPnAycF9hdHRyaWJ1dGVzKQorCQkJd3BhX2hleGR1bXBfYnVmKE1TR19NU0dEVU1QLCAiUDJQOiBQMlAgSUUgZGF0YSIsCisJCQkJCW1zZy0+cDJwX2F0dHJpYnV0ZXMpOworCQlwMnBfcGFyc2VfZnJlZShtc2cpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKwogLyoqCiAgKiBwMnBfcGFyc2VfZnJlZSAtIEZyZWUgdGVtcG9yYXJ5IGRhdGEgZnJvbSBQMlAgcGFyc2luZwogICogQG1zZzogUGFyc2VkIGF0dHJpYnV0ZXMKZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX3BkLmMgYi9zcmMvcDJwL3AycF9wZC5jCmluZGV4IDU0YWE0MjguLmUxMDEzNjcgMTAwNjQ0Ci0tLSBhL3NyYy9wMnAvcDJwX3BkLmMKKysrIGIvc3JjL3AycC9wMnBfcGQuYwpAQCAtMTAsNiArMTAsNyBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgorI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgIndwcy93cHNfZGVmcy5oIgogI2luY2x1ZGUgInAycF9pLmgiCiAjaW5jbHVkZSAicDJwLmgiCkBAIC01Myw2ICs1NCw5IEBACiAJCWV4dHJhID0gd3BhYnVmX2xlbihwMnAtPndmZF9pZV9wcm92X2Rpc2NfcmVxKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAKKwlpZiAocDJwLT52ZW5kb3JfZWxlbSAmJiBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1AyUF9QRF9SRVFdKQorCQlleHRyYSArPSB3cGFidWZfbGVuKHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX1BEX1JFUV0pOworCiAJYnVmID0gd3BhYnVmX2FsbG9jKDEwMDAgKyBleHRyYSk7CiAJaWYgKGJ1ZiA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKQEAgLTc3LDYgKzgxLDkgQEAKIAkJd3BhYnVmX3B1dF9idWYoYnVmLCBwMnAtPndmZF9pZV9wcm92X2Rpc2NfcmVxKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAKKwlpZiAocDJwLT52ZW5kb3JfZWxlbSAmJiBwMnAtPnZlbmRvcl9lbGVtW1ZFTkRPUl9FTEVNX1AyUF9QRF9SRVFdKQorCQl3cGFidWZfcHV0X2J1ZihidWYsIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX1BEX1JFUV0pOworCiAJcmV0dXJuIGJ1ZjsKIH0KIApAQCAtMTExLDYgKzExOCw5IEBACiAJCWV4dHJhID0gd3BhYnVmX2xlbih3ZmRfaWUpOwogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCWlmIChwMnAtPnZlbmRvcl9lbGVtICYmIHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX1BEX1JFU1BdKQorCQlleHRyYSArPSB3cGFidWZfbGVuKHAycC0+dmVuZG9yX2VsZW1bVkVORE9SX0VMRU1fUDJQX1BEX1JFU1BdKTsKKwogCWJ1ZiA9IHdwYWJ1Zl9hbGxvYygxMDAgKyBleHRyYSk7CiAJaWYgKGJ1ZiA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKQEAgLTEyNSw2ICsxMzUsOSBAQAogCQl3cGFidWZfcHV0X2J1ZihidWYsIHdmZF9pZSk7CiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCisJaWYgKHAycC0+dmVuZG9yX2VsZW0gJiYgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfUERfUkVTUF0pCisJCXdwYWJ1Zl9wdXRfYnVmKGJ1ZiwgcDJwLT52ZW5kb3JfZWxlbVtWRU5ET1JfRUxFTV9QMlBfUERfUkVTUF0pOworCiAJcmV0dXJuIGJ1ZjsKIH0KIApAQCAtMjI0LDcgKzIzNyw4IEBACiAJCQkgICAgcDJwLT5jZmctPmRldl9hZGRyLAogCQkJICAgIHdwYWJ1Zl9oZWFkKHJlc3ApLCB3cGFidWZfbGVuKHJlc3ApLCAyMDApIDwgMCkgewogCQlwMnBfZGJnKHAycCwgIkZhaWxlZCB0byBzZW5kIEFjdGlvbiBmcmFtZSIpOwotCX0KKwl9IGVsc2UKKwkJcDJwLT5zZW5kX2FjdGlvbl9pbl9wcm9ncmVzcyA9IDE7CiAKIAl3cGFidWZfZnJlZShyZXNwKTsKIApAQCAtNDM3LDYgKzQ1MSw3IEBACiAJfQogCiAJcDJwLT51c2VyX2luaXRpYXRlZF9wZCA9IHVzZXJfaW5pdGlhdGVkX3BkOworCXAycC0+cGRfZm9yY2VfZnJlcSA9IGZvcmNlX2ZyZXE7CiAKIAlpZiAocDJwLT51c2VyX2luaXRpYXRlZF9wZCkKIAkJcDJwLT5wZF9yZXRyaWVzID0gTUFYX1BST1ZfRElTQ19SRVFfUkVUUklFUzsKQEAgLTQ3Miw0ICs0ODcsNSBAQAogCXAycC0+dXNlcl9pbml0aWF0ZWRfcGQgPSAwOwogCW9zX21lbXNldChwMnAtPnBlbmRpbmdfcGRfZGV2YWRkciwgMCwgRVRIX0FMRU4pOwogCXAycC0+cGRfcmV0cmllcyA9IDA7CisJcDJwLT5wZF9mb3JjZV9mcmVxID0gMDsKIH0KZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX3NkLmMgYi9zcmMvcDJwL3AycF9zZC5jCmluZGV4IDc5NWNhNmIuLjYyMzViMWQgMTAwNjQ0Ci0tLSBhL3NyYy9wMnAvcDJwX3NkLmMKKysrIGIvc3JjL3AycC9wMnBfc2QuYwpAQCAtNTIsNiArNTIsNyBAQAogewogCXN0cnVjdCBwMnBfc2RfcXVlcnkgKnE7CiAJaW50IHdzZCA9IDA7CisJaW50IGNvdW50ID0gMDsKIAogCWlmICghKGRldi0+aW5mby5kZXZfY2FwYWIgJiBQMlBfREVWX0NBUEFCX1NFUlZJQ0VfRElTQ09WRVJZKSkKIAkJcmV0dXJuIE5VTEw7IC8qIHBlZXIgZG9lcyBub3Qgc3VwcG9ydCBTRCAqLwpAQCAtNjQsOCArNjUsMTkgQEAKIAkJLyogVXNlIFdTRCBvbmx5IGlmIHRoZSBwZWVyIGluZGljYXRlcyBzdXBwb3J0IG9yIGl0ICovCiAJCWlmIChxLT53c2QgJiYgIXdzZCkKIAkJCWNvbnRpbnVlOwotCQlpZiAocS0+Zm9yX2FsbF9wZWVycyAmJiAhKGRldi0+ZmxhZ3MgJiBQMlBfREVWX1NEX0lORk8pKQotCQkJcmV0dXJuIHE7CisJCS8qIGlmIHRoZSBxdWVyeSBpcyBhIGJyb2FkY2FzdCBxdWVyeSAqLworCQlpZiAocS0+Zm9yX2FsbF9wZWVycykgeworCQkJLyoKKwkJCSAqIGNoZWNrIGlmIHRoZXJlIGFyZSBhbnkgYnJvYWRjYXN0IHF1ZXJpZXMgcGVuZGluZyBmb3IKKwkJCSAqIHRoaXMgZGV2aWNlCisJCQkgKi8KKwkJCWlmIChkZXYtPnNkX3BlbmRpbmdfYmNhc3RfcXVlcmllcyA8PSAwKQorCQkJCXJldHVybiBOVUxMOworCQkJLyogcXVlcnkgbnVtYmVyIHRoYXQgbmVlZHMgdG8gYmUgc2VuZCB0byB0aGUgZGV2aWNlICovCisJCQlpZiAoY291bnQgPT0gZGV2LT5zZF9wZW5kaW5nX2JjYXN0X3F1ZXJpZXMgLSAxKQorCQkJCXJldHVybiBxOworCQkJY291bnQrKzsKKwkJfQogCQlpZiAoIXEtPmZvcl9hbGxfcGVlcnMgJiYKIAkJICAgIG9zX21lbWNtcChxLT5wZWVyLCBkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyLCBFVEhfQUxFTikgPT0KIAkJICAgIDApCkBAIC03NiwxNCArODgsMzcgQEAKIH0KIAogCitzdGF0aWMgdm9pZCBwMnBfZGVjcmVhc2Vfc2RfYmNfcXVlcmllcyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgaW50IHF1ZXJ5X251bWJlcikKK3sKKwlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OworCisJcDJwLT5udW1fcDJwX3NkX3F1ZXJpZXMtLTsKKwlkbF9saXN0X2Zvcl9lYWNoKGRldiwgJnAycC0+ZGV2aWNlcywgc3RydWN0IHAycF9kZXZpY2UsIGxpc3QpIHsKKwkJaWYgKHF1ZXJ5X251bWJlciA8PSBkZXYtPnNkX3BlbmRpbmdfYmNhc3RfcXVlcmllcyAtIDEpIHsKKwkJCS8qCisJCQkgKiBRdWVyeSBub3QgeWV0IHNlbnQgdG8gdGhlIGRldmljZSBhbmQgaXQgaXMgdG8gYmUKKwkJCSAqIHJlbW92ZWQsIHNvIHVwZGF0ZSB0aGUgcGVuZGluZyBjb3VudC4KKwkJCSovCisJCQlkZXYtPnNkX3BlbmRpbmdfYmNhc3RfcXVlcmllcy0tOworCQl9CisJfQorfQorCisKIHN0YXRpYyBpbnQgcDJwX3VubGlua19zZF9xdWVyeShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwKIAkJCSAgICAgICBzdHJ1Y3QgcDJwX3NkX3F1ZXJ5ICpxdWVyeSkKIHsKIAlzdHJ1Y3QgcDJwX3NkX3F1ZXJ5ICpxLCAqcHJldjsKKwlpbnQgcXVlcnlfbnVtYmVyID0gMDsKKwogCXEgPSBwMnAtPnNkX3F1ZXJpZXM7CiAJcHJldiA9IE5VTEw7CiAJd2hpbGUgKHEpIHsKIAkJaWYgKHEgPT0gcXVlcnkpIHsKKwkJCS8qIElmIHRoZSBxdWVyeSBpcyBhIGJyb2FkY2FzdCBxdWVyeSwgZGVjcmVhc2Ugb25lIGZyb20KKwkJCSAqIGFsbCB0aGUgZGV2aWNlcyAqLworCQkJaWYgKHF1ZXJ5LT5mb3JfYWxsX3BlZXJzKQorCQkJCXAycF9kZWNyZWFzZV9zZF9iY19xdWVyaWVzKHAycCwgcXVlcnlfbnVtYmVyKTsKIAkJCWlmIChwcmV2KQogCQkJCXByZXYtPm5leHQgPSBxLT5uZXh0OwogCQkJZWxzZQpAQCAtOTIsNiArMTI3LDggQEAKIAkJCQlwMnAtPnNkX3F1ZXJ5ID0gTlVMTDsKIAkJCXJldHVybiAxOwogCQl9CisJCWlmIChxLT5mb3JfYWxsX3BlZXJzKQorCQkJcXVlcnlfbnVtYmVyKys7CiAJCXByZXYgPSBxOwogCQlxID0gcS0+bmV4dDsKIAl9CkBAIC0xMTgsNiArMTU1LDcgQEAKIAkJcSA9IHEtPm5leHQ7CiAJCXAycF9mcmVlX3NkX3F1ZXJ5KHByZXYpOwogCX0KKwlwMnAtPm51bV9wMnBfc2RfcXVlcmllcyA9IDA7CiB9CiAKIApAQCAtMTMzLDggKzE3MSw3IEBACiAKIAkvKiBBTlFQIFF1ZXJ5IFJlcXVlc3QgRnJhbWUgKi8KIAlsZW5fcG9zID0gZ2FzX2FucXBfYWRkX2VsZW1lbnQoYnVmLCBBTlFQX1ZFTkRPUl9TUEVDSUZJQyk7Ci0Jd3BhYnVmX3B1dF9iZTI0KGJ1ZiwgT1VJX1dGQSk7Ci0Jd3BhYnVmX3B1dF91OChidWYsIFAyUF9PVUlfVFlQRSk7CisJd3BhYnVmX3B1dF9iZTMyKGJ1ZiwgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKIAl3cGFidWZfcHV0X2xlMTYoYnVmLCB1cGRhdGVfaW5kaWMpOyAvKiBTZXJ2aWNlIFVwZGF0ZSBJbmRpY2F0b3IgKi8KIAl3cGFidWZfcHV0X2J1ZihidWYsIHRsdnMpOwogCWdhc19hbnFwX3NldF9lbGVtZW50X2xlbihidWYsIGxlbl9wb3MpOwpAQCAtMTgwLDggKzIxNyw3IEBACiAJaWYgKHRsdnMpIHsKIAkJLyogQU5RUCBRdWVyeSBSZXNwb25zZSBGcmFtZSAqLwogCQlsZW5fcG9zID0gZ2FzX2FucXBfYWRkX2VsZW1lbnQoYnVmLCBBTlFQX1ZFTkRPUl9TUEVDSUZJQyk7Ci0JCXdwYWJ1Zl9wdXRfYmUyNChidWYsIE9VSV9XRkEpOwotCQl3cGFidWZfcHV0X3U4KGJ1ZiwgUDJQX09VSV9UWVBFKTsKKwkJd3BhYnVmX3B1dF9iZTMyKGJ1ZiwgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKIAkJIC8qIFNlcnZpY2UgVXBkYXRlIEluZGljYXRvciAqLwogCQl3cGFidWZfcHV0X2xlMTYoYnVmLCB1cGRhdGVfaW5kaWMpOwogCQl3cGFidWZfcHV0X2J1ZihidWYsIHRsdnMpOwpAQCAtMjEyLDggKzI0OCw3IEBACiAJCS8qIEFOUVAgUXVlcnkgUmVzcG9uc2UgRnJhbWUgKi8KIAkJd3BhYnVmX3B1dF9sZTE2KGJ1ZiwgQU5RUF9WRU5ET1JfU1BFQ0lGSUMpOyAvKiBJbmZvIElEICovCiAJCXdwYWJ1Zl9wdXRfbGUxNihidWYsIDMgKyAxICsgMiArIHRvdGFsX2xlbik7Ci0JCXdwYWJ1Zl9wdXRfYmUyNChidWYsIE9VSV9XRkEpOwotCQl3cGFidWZfcHV0X3U4KGJ1ZiwgUDJQX09VSV9UWVBFKTsKKwkJd3BhYnVmX3B1dF9iZTMyKGJ1ZiwgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKIAkJLyogU2VydmljZSBVcGRhdGUgSW5kaWNhdG9yICovCiAJCXdwYWJ1Zl9wdXRfbGUxNihidWYsIHVwZGF0ZV9pbmRpYyk7CiAJfQpAQCAtMjMxLDYgKzI2Niw3IEBACiAJaW50IHJldCA9IDA7CiAJc3RydWN0IHAycF9zZF9xdWVyeSAqcXVlcnk7CiAJaW50IGZyZXE7CisJdW5zaWduZWQgaW50IHdhaXRfdGltZTsKIAogCWZyZXEgPSBkZXYtPmxpc3Rlbl9mcmVxID4gMCA/IGRldi0+bGlzdGVuX2ZyZXEgOiBkZXYtPm9wZXJfZnJlcTsKIAlpZiAoZnJlcSA8PSAwKSB7CkBAIC0yNTUsMTMgKzI5MSwyNiBAQAogCXAycC0+c2RfcXVlcnkgPSBxdWVyeTsKIAlwMnAtPnBlbmRpbmdfYWN0aW9uX3N0YXRlID0gUDJQX1BFTkRJTkdfU0Q7CiAKKwl3YWl0X3RpbWUgPSA1MDAwOworCWlmIChwMnAtPmNmZy0+bWF4X2xpc3RlbiAmJiB3YWl0X3RpbWUgPiBwMnAtPmNmZy0+bWF4X2xpc3RlbikKKwkJd2FpdF90aW1lID0gcDJwLT5jZmctPm1heF9saXN0ZW47CiAJaWYgKHAycF9zZW5kX2FjdGlvbihwMnAsIGZyZXEsIGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCiAJCQkgICAgcDJwLT5jZmctPmRldl9hZGRyLCBkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyLAotCQkJICAgIHdwYWJ1Zl9oZWFkKHJlcSksIHdwYWJ1Zl9sZW4ocmVxKSwgNTAwMCkgPCAwKSB7CisJCQkgICAgd3BhYnVmX2hlYWQocmVxKSwgd3BhYnVmX2xlbihyZXEpLCB3YWl0X3RpbWUpIDwgMCkgewogCQlwMnBfZGJnKHAycCwgIkZhaWxlZCB0byBzZW5kIEFjdGlvbiBmcmFtZSIpOwogCQlyZXQgPSAtMTsKIAl9CiAKKwkvKiBVcGRhdGUgdGhlIHBlbmRpbmcgYnJvYWRjYXN0IFNEIHF1ZXJ5IGNvdW50IGZvciB0aGlzIGRldmljZSAqLworCWRldi0+c2RfcGVuZGluZ19iY2FzdF9xdWVyaWVzLS07CisKKwkvKgorCSAqIElmIHRoZXJlIGFyZSBubyBwZW5kaW5nIGJyb2FkY2FzdCBxdWVyaWVzIGZvciB0aGlzIGRldmljZSwgbWFyayBpdCBhcworCSAqIGRvbmUgKC0xKS4KKwkgKi8KKwlpZiAoZGV2LT5zZF9wZW5kaW5nX2JjYXN0X3F1ZXJpZXMgPT0gMCkKKwkJZGV2LT5zZF9wZW5kaW5nX2JjYXN0X3F1ZXJpZXMgPSAtMTsKKwogCXdwYWJ1Zl9mcmVlKHJlcSk7CiAKIAlyZXR1cm4gcmV0OwpAQCAtMzQ1LDE3ICszOTQsMTIgQEAKIAkJcmV0dXJuOwogCX0KIAotCWlmIChXUEFfR0VUX0JFMjQocG9zKSAhPSBPVUlfV0ZBKSB7Ci0JCXAycF9kYmcocDJwLCAiVW5zdXBwb3J0ZWQgQU5RUCBPVUkgJTA2eCIsIFdQQV9HRVRfQkUyNChwb3MpKTsKKwlpZiAoV1BBX0dFVF9CRTMyKHBvcykgIT0gUDJQX0lFX1ZFTkRPUl9UWVBFKSB7CisJCXAycF9kYmcocDJwLCAiVW5zdXBwb3J0ZWQgQU5RUCB2ZW5kb3IgT1VJLXR5cGUgJTA4eCIsCisJCQlXUEFfR0VUX0JFMzIocG9zKSk7CiAJCXJldHVybjsKIAl9Ci0JcG9zICs9IDM7Ci0KLQlpZiAoKnBvcyAhPSBQMlBfT1VJX1RZUEUpIHsKLQkJcDJwX2RiZyhwMnAsICJVbnN1cHBvcnRlZCBBTlFQIHZlbmRvciB0eXBlICV1IiwgKnBvcyk7Ci0JCXJldHVybjsKLQl9Ci0JcG9zKys7CisJcG9zICs9IDQ7CiAKIAlpZiAocG9zICsgMiA+IGVuZCkKIAkJcmV0dXJuOwpAQCAtNDMwLDE1ICs0NzQsNyBAQAogCXUxNiBzbGVuOwogCXUxNiB1cGRhdGVfaW5kaWM7CiAKLSNpZmRlZiBBTkRST0lEX1AyUAotCWlmIChwMnAtPnN0YXRlICE9IFAyUF9TRF9EVVJJTkdfRklORCkgewotCQlwMnBfZGJnKHAycCwgIlAyUDogIyMjIyBOb3QgaWdub3JpbmcgdW5leHBlY3RlZCBHQVMgSW5pdGlhbCBSZXNwb25zZSBmcm9tICIKLQkJCU1BQ1NUUiAiIHN0YXRlICVkIiwgTUFDMlNUUihzYSksIHAycC0+c3RhdGUpOwotCX0KLQlpZiAocDJwLT5zZF9wZWVyID09IE5VTEwgfHwKLSNlbHNlCiAJaWYgKHAycC0+c3RhdGUgIT0gUDJQX1NEX0RVUklOR19GSU5EIHx8IHAycC0+c2RfcGVlciA9PSBOVUxMIHx8Ci0jZW5kaWYKIAkgICAgb3NfbWVtY21wKHNhLCBwMnAtPnNkX3BlZXItPmluZm8ucDJwX2RldmljZV9hZGRyLCBFVEhfQUxFTikgIT0gMCkgewogCQlwMnBfZGJnKHAycCwgIklnbm9yZSB1bmV4cGVjdGVkIEdBUyBJbml0aWFsIFJlc3BvbnNlIGZyb20gIgogCQkJTUFDU1RSLCBNQUMyU1RSKHNhKSk7CkBAIC01MzEsMTcgKzU2NywxMiBAQAogCQlyZXR1cm47CiAJfQogCi0JaWYgKFdQQV9HRVRfQkUyNChwb3MpICE9IE9VSV9XRkEpIHsKLQkJcDJwX2RiZyhwMnAsICJVbnN1cHBvcnRlZCBBTlFQIE9VSSAlMDZ4IiwgV1BBX0dFVF9CRTI0KHBvcykpOworCWlmIChXUEFfR0VUX0JFMzIocG9zKSAhPSBQMlBfSUVfVkVORE9SX1RZUEUpIHsKKwkJcDJwX2RiZyhwMnAsICJVbnN1cHBvcnRlZCBBTlFQIHZlbmRvciBPVUktdHlwZSAlMDh4IiwKKwkJCVdQQV9HRVRfQkUzMihwb3MpKTsKIAkJcmV0dXJuOwogCX0KLQlwb3MgKz0gMzsKLQotCWlmICgqcG9zICE9IFAyUF9PVUlfVFlQRSkgewotCQlwMnBfZGJnKHAycCwgIlVuc3VwcG9ydGVkIEFOUVAgdmVuZG9yIHR5cGUgJXUiLCAqcG9zKTsKLQkJcmV0dXJuOwotCX0KLQlwb3MrKzsKKwlwb3MgKz0gNDsKIAogCWlmIChwb3MgKyAyID4gZW5kKQogCQlyZXR1cm47CkBAIC01NDksOCArNTgwLDYgQEAKIAlwMnBfZGJnKHAycCwgIlNlcnZpY2UgVXBkYXRlIEluZGljYXRvcjogJXUiLCB1cGRhdGVfaW5kaWMpOwogCXBvcyArPSAyOwogCi0JcDJwLT5zZF9wZWVyLT5mbGFncyB8PSBQMlBfREVWX1NEX0lORk87Ci0JcDJwLT5zZF9wZWVyLT5mbGFncyAmPSB+UDJQX0RFVl9TRF9TQ0hFRFVMRTsKIAlwMnAtPnNkX3BlZXIgPSBOVUxMOwogCiAJaWYgKHAycC0+c2RfcXVlcnkpIHsKQEAgLTY1MywxNSArNjgyLDcgQEAKIAogCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlAyUDogUlggR0FTIENvbWViYWNrIFJlc3BvbnNlIiwgZGF0YSwgbGVuKTsKIAotI2lmZGVmIEFORFJPSURfUDJQCi0JaWYgKHAycC0+c3RhdGUgIT0gUDJQX1NEX0RVUklOR19GSU5EKSB7Ci0JCXAycF9kYmcocDJwLCAiUDJQOiAjIyMjIE5vdCBpZ25vcmluZyB1bmV4cGVjdGVkIEdBUyBDb21lYmFjayBSZXNwb25zZSBmcm9tICIKLQkJCU1BQ1NUUiAiIHN0YXRlICVkIiwgTUFDMlNUUihzYSksIHAycC0+c3RhdGUpOwotCX0KLQlpZiAocDJwLT5zZF9wZWVyID09IE5VTEwgfHwKLSNlbHNlCiAJaWYgKHAycC0+c3RhdGUgIT0gUDJQX1NEX0RVUklOR19GSU5EIHx8IHAycC0+c2RfcGVlciA9PSBOVUxMIHx8Ci0jZW5kaWYKIAkgICAgb3NfbWVtY21wKHNhLCBwMnAtPnNkX3BlZXItPmluZm8ucDJwX2RldmljZV9hZGRyLCBFVEhfQUxFTikgIT0gMCkgewogCQlwMnBfZGJnKHAycCwgIklnbm9yZSB1bmV4cGVjdGVkIEdBUyBDb21lYmFjayBSZXNwb25zZSBmcm9tICIKIAkJCU1BQ1NUUiwgTUFDMlNUUihzYSkpOwpAQCAtNzY1LDE3ICs3ODYsMTIgQEAKIAlpZiAocG9zICsgNCA+IGVuZCkKIAkJcmV0dXJuOwogCi0JaWYgKFdQQV9HRVRfQkUyNChwb3MpICE9IE9VSV9XRkEpIHsKLQkJcDJwX2RiZyhwMnAsICJVbnN1cHBvcnRlZCBBTlFQIE9VSSAlMDZ4IiwgV1BBX0dFVF9CRTI0KHBvcykpOworCWlmIChXUEFfR0VUX0JFMzIocG9zKSAhPSBQMlBfSUVfVkVORE9SX1RZUEUpIHsKKwkJcDJwX2RiZyhwMnAsICJVbnN1cHBvcnRlZCBBTlFQIHZlbmRvciBPVUktdHlwZSAlMDh4IiwKKwkJCVdQQV9HRVRfQkUzMihwb3MpKTsKIAkJcmV0dXJuOwogCX0KLQlwb3MgKz0gMzsKLQotCWlmICgqcG9zICE9IFAyUF9PVUlfVFlQRSkgewotCQlwMnBfZGJnKHAycCwgIlVuc3VwcG9ydGVkIEFOUVAgdmVuZG9yIHR5cGUgJXUiLCAqcG9zKTsKLQkJcmV0dXJuOwotCX0KLQlwb3MrKzsKKwlwb3MgKz0gNDsKIAogCWlmIChwb3MgKyAyID4gZW5kKQogCQlyZXR1cm47CkBAIC04MDMsOCArODE5LDYgQEAKIAkJcmV0dXJuOwogCX0KIAotCXAycC0+c2RfcGVlci0+ZmxhZ3MgfD0gUDJQX0RFVl9TRF9JTkZPOwotCXAycC0+c2RfcGVlci0+ZmxhZ3MgJj0gflAyUF9ERVZfU0RfU0NIRURVTEU7CiAJcDJwLT5zZF9wZWVyID0gTlVMTDsKIAogCWlmIChwMnAtPnNkX3F1ZXJ5KSB7CkBAIC04MzUsMTkgKzg0OSw2IEBACiAJCSAgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnRsdnMpCiB7CiAJc3RydWN0IHAycF9zZF9xdWVyeSAqcTsKLSNpZmRlZiBBTkRST0lEX1AyUAotCS8qIEN1cnJlbnRseSwgc3VwcGxpY2FudCBkb2Vzbid0IHN1cHBvcnQgbW9yZSB0aGFuIG9uZSBwZW5kaW5nIGJyb2FkY2FzdCBTRCByZXF1ZXN0LgotCSAqIFNvIHJlamVjdCBpZiBhcHBsaWNhdGlvbiBpcyByZWdpc3RlcmluZyBhbm90aGVyIG9uZSBiZWZvcmUgY2FuY2VsbGluZyB0aGUgZXhpc3Rpbmcgb25lLgotCSAqLwotCWZvciAocSA9IHAycC0+c2RfcXVlcmllczsgcTsgcSA9IHEtPm5leHQpIHsKLQkJaWYoIChxLT5mb3JfYWxsX3BlZXJzID09IDEpICYmICghZHN0KSkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUDJQOiBBbHJlYWR5IG9uZSBwZW5kaW5nIgotCQkJCQkiIEJyb2FkY2FzdCByZXF1ZXN0LiBQbGVhc2UgY2FuY2VsIHRoZSBjdXJyZW50IG9uZSIKLQkJCQkJIiBiZWZvcmUgYWRkaW5nIGEgbmV3IG9uZSIpOwotCQkJCXJldHVybiBOVUxMOwotCQl9Ci0JfQotI2VuZGlmCiAKIAlxID0gb3NfemFsbG9jKHNpemVvZigqcSkpOwogCWlmIChxID09IE5VTEwpCkBAIC04NzAsOCArODcxLDE2IEBACiAKIAlpZiAoZHN0ID09IE5VTEwpIHsKIAkJc3RydWN0IHAycF9kZXZpY2UgKmRldjsKLQkJZGxfbGlzdF9mb3JfZWFjaChkZXYsICZwMnAtPmRldmljZXMsIHN0cnVjdCBwMnBfZGV2aWNlLCBsaXN0KQotCQkJZGV2LT5mbGFncyAmPSB+UDJQX0RFVl9TRF9JTkZPOworCisJCXAycC0+bnVtX3AycF9zZF9xdWVyaWVzKys7CisKKwkJLyogVXBkYXRlIGFsbCB0aGUgZGV2aWNlcyBmb3IgdGhlIG5ld2x5IGFkZGVkIGJyb2FkY2FzdCBxdWVyeSAqLworCQlkbF9saXN0X2Zvcl9lYWNoKGRldiwgJnAycC0+ZGV2aWNlcywgc3RydWN0IHAycF9kZXZpY2UsIGxpc3QpIHsKKwkJCWlmIChkZXYtPnNkX3BlbmRpbmdfYmNhc3RfcXVlcmllcyA8PSAwKQorCQkJCWRldi0+c2RfcGVuZGluZ19iY2FzdF9xdWVyaWVzID0gMTsKKwkJCWVsc2UKKwkJCQlkZXYtPnNkX3BlbmRpbmdfYmNhc3RfcXVlcmllcysrOworCQl9CiAJfQogCiAJcmV0dXJuIHE7CkBAIC05MDEsOSArOTEwLDYgQEAKIHsKIAlpZiAocDJwX3VubGlua19zZF9xdWVyeShwMnAsIHJlcSkpIHsKIAkJcDJwX2RiZyhwMnAsICJDYW5jZWwgcGVuZGluZyBTRCBxdWVyeSAlcCIsIHJlcSk7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQkJcDJwLT5zZF9kZXZfbGlzdCA9IE5VTEw7Ci0jZW5kaWYKIAkJcDJwX2ZyZWVfc2RfcXVlcnkocmVxKTsKIAkJcmV0dXJuIDA7CiAJfQpkaWZmIC0tZ2l0IGEvc3JjL3AycC9wMnBfdXRpbHMuYyBiL3NyYy9wMnAvcDJwX3V0aWxzLmMKaW5kZXggYTRjNDhmNi4uMTg5MzAwYSAxMDA2NDQKLS0tIGEvc3JjL3AycC9wMnBfdXRpbHMuYworKysgYi9zcmMvcDJwL3AycF91dGlscy5jCkBAIC05NCw2ICs5NCwxNCBAQAogCQlpZiAoY2hhbm5lbCA8IDE0OSB8fCBjaGFubmVsID4gMTYxKQogCQkJcmV0dXJuIC0xOwogCQlyZXR1cm4gNTAwMCArIDUgKiBjaGFubmVsOworCWNhc2UgMTI4OiAvKiBjZW50ZXIgZnJlcXMgNDIsIDU4LCAxMDYsIDEyMiwgMTM4LCAxNTU7IDgwIE1IeiAqLworCQlpZiAoY2hhbm5lbCA8IDM2IHx8IGNoYW5uZWwgPiAxNjEpCisJCQlyZXR1cm4gLTE7CisJCXJldHVybiA1MDAwICsgNSAqIGNoYW5uZWw7CisJY2FzZSAxODA6IC8qIDYwIEdIeiBiYW5kLCBjaGFubmVscyAxLi40ICovCisJCWlmIChjaGFubmVsIDwgMSB8fCBjaGFubmVsID4gNCkKKwkJCXJldHVybiAtMTsKKwkJcmV0dXJuIDU2MTYwICsgMjE2MCAqIGNoYW5uZWw7CiAJfQogCXJldHVybiAtMTsKIH0KQEAgLTIwNCw2ICsyMTIsMTA1IEBACiB9CiAKIAorc3RhdGljIHZvaWQgcDJwX29wX2NsYXNzX3VuaW9uKHN0cnVjdCBwMnBfcmVnX2NsYXNzICpjbCwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3QgcDJwX3JlZ19jbGFzcyAqYl9jbCkKK3sKKwlzaXplX3QgaSwgajsKKworCWZvciAoaSA9IDA7IGkgPCBiX2NsLT5jaGFubmVsczsgaSsrKSB7CisJCWZvciAoaiA9IDA7IGogPCBjbC0+Y2hhbm5lbHM7IGorKykgeworCQkJaWYgKGJfY2wtPmNoYW5uZWxbaV0gPT0gY2wtPmNoYW5uZWxbal0pCisJCQkJYnJlYWs7CisJCX0KKwkJaWYgKGogPT0gY2wtPmNoYW5uZWxzKSB7CisJCQlpZiAoY2wtPmNoYW5uZWxzID09IFAyUF9NQVhfUkVHX0NMQVNTX0NIQU5ORUxTKQorCQkJCXJldHVybjsKKwkJCWNsLT5jaGFubmVsW2NsLT5jaGFubmVscysrXSA9IGJfY2wtPmNoYW5uZWxbaV07CisJCX0KKwl9Cit9CisKKworLyoqCisgKiBwMnBfY2hhbm5lbHNfdW5pb24gLSBVbmlvbiBvZiBjaGFubmVsIGxpc3RzCisgKiBAYTogRmlyc3Qgc2V0IG9mIGNoYW5uZWxzCisgKiBAYjogU2Vjb25kIHNldCBvZiBjaGFubmVscworICogQHJlczogRGF0YSBzdHJ1Y3R1cmUgZm9yIHJldHVybmluZyB0aGUgdW5pb24gb2YgY2hhbm5lbHMKKyAqLwordm9pZCBwMnBfY2hhbm5lbHNfdW5pb24oY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqYSwKKwkJCWNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbHMgKmIsCisJCQlzdHJ1Y3QgcDJwX2NoYW5uZWxzICpyZXMpCit7CisJc2l6ZV90IGksIGo7CisKKwlpZiAoYSAhPSByZXMpCisJCW9zX21lbWNweShyZXMsIGEsIHNpemVvZigqcmVzKSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgcmVzLT5yZWdfY2xhc3NlczsgaSsrKSB7CisJCXN0cnVjdCBwMnBfcmVnX2NsYXNzICpjbCA9ICZyZXMtPnJlZ19jbGFzc1tpXTsKKwkJZm9yIChqID0gMDsgaiA8IGItPnJlZ19jbGFzc2VzOyBqKyspIHsKKwkJCWNvbnN0IHN0cnVjdCBwMnBfcmVnX2NsYXNzICpiX2NsID0gJmItPnJlZ19jbGFzc1tqXTsKKwkJCWlmIChjbC0+cmVnX2NsYXNzICE9IGJfY2wtPnJlZ19jbGFzcykKKwkJCQljb250aW51ZTsKKwkJCXAycF9vcF9jbGFzc191bmlvbihjbCwgYl9jbCk7CisJCX0KKwl9CisKKwlmb3IgKGogPSAwOyBqIDwgYi0+cmVnX2NsYXNzZXM7IGorKykgeworCQljb25zdCBzdHJ1Y3QgcDJwX3JlZ19jbGFzcyAqYl9jbCA9ICZiLT5yZWdfY2xhc3Nbal07CisKKwkJZm9yIChpID0gMDsgaSA8IHJlcy0+cmVnX2NsYXNzZXM7IGkrKykgeworCQkJc3RydWN0IHAycF9yZWdfY2xhc3MgKmNsID0gJnJlcy0+cmVnX2NsYXNzW2ldOworCQkJaWYgKGNsLT5yZWdfY2xhc3MgPT0gYl9jbC0+cmVnX2NsYXNzKQorCQkJCWJyZWFrOworCQl9CisKKwkJaWYgKGkgPT0gcmVzLT5yZWdfY2xhc3NlcykgeworCQkJaWYgKHJlcy0+cmVnX2NsYXNzZXMgPT0gUDJQX01BWF9SRUdfQ0xBU1NFUykKKwkJCQlyZXR1cm47CisJCQlvc19tZW1jcHkoJnJlcy0+cmVnX2NsYXNzW3Jlcy0+cmVnX2NsYXNzZXMrK10sCisJCQkJICBiX2NsLCBzaXplb2Yoc3RydWN0IHAycF9yZWdfY2xhc3MpKTsKKwkJfQorCX0KK30KKworCit2b2lkIHAycF9jaGFubmVsc19yZW1vdmVfZnJlcXMoc3RydWN0IHAycF9jaGFubmVscyAqY2hhbiwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2VfbGlzdCAqbGlzdCkKK3sKKwlzaXplX3QgbywgYzsKKworCWlmIChsaXN0ID09IE5VTEwpCisJCXJldHVybjsKKworCW8gPSAwOworCXdoaWxlIChvIDwgY2hhbi0+cmVnX2NsYXNzZXMpIHsKKwkJc3RydWN0IHAycF9yZWdfY2xhc3MgKm9wID0gJmNoYW4tPnJlZ19jbGFzc1tvXTsKKworCQljID0gMDsKKwkJd2hpbGUgKGMgPCBvcC0+Y2hhbm5lbHMpIHsKKwkJCWludCBmcmVxID0gcDJwX2NoYW5uZWxfdG9fZnJlcShvcC0+cmVnX2NsYXNzLAorCQkJCQkJICAgICAgIG9wLT5jaGFubmVsW2NdKTsKKwkJCWlmIChmcmVxID4gMCAmJiBmcmVxX3JhbmdlX2xpc3RfaW5jbHVkZXMobGlzdCwgZnJlcSkpIHsKKwkJCQlvcC0+Y2hhbm5lbHMtLTsKKwkJCQlvc19tZW1tb3ZlKCZvcC0+Y2hhbm5lbFtjXSwKKwkJCQkJICAgJm9wLT5jaGFubmVsW2MgKyAxXSwKKwkJCQkJICAgb3AtPmNoYW5uZWxzIC0gYyk7CisJCQl9IGVsc2UKKwkJCQljKys7CisJCX0KKworCQlpZiAob3AtPmNoYW5uZWxzID09IDApIHsKKwkJCWNoYW4tPnJlZ19jbGFzc2VzLS07CisJCQlvc19tZW1tb3ZlKCZjaGFuLT5yZWdfY2xhc3Nbb10sICZjaGFuLT5yZWdfY2xhc3NbbyArIDFdLAorCQkJCSAgIChjaGFuLT5yZWdfY2xhc3NlcyAtIG8pICoKKwkJCQkgICBzaXplb2Yoc3RydWN0IHAycF9yZWdfY2xhc3MpKTsKKwkJfSBlbHNlCisJCQlvKys7CisJfQorfQorCisKIC8qKgogICogcDJwX2NoYW5uZWxzX2luY2x1ZGVzIC0gQ2hlY2sgd2hldGhlciBhIGNoYW5uZWwgaXMgaW5jbHVkZWQgaW4gdGhlIGxpc3QKICAqIEBjaGFubmVsczogTGlzdCBvZiBzdXBwb3J0ZWQgY2hhbm5lbHMKQEAgLTI0NCwzOSArMzUxLDkgQEAKIH0KIAogCi0jaWZkZWYgQU5EUk9JRF9QMlAKLXN0YXRpYyBpbnQgcDJwX2Jsb2NrX29wX2ZyZXEodW5zaWduZWQgaW50IGZyZXEpCi17Ci0JcmV0dXJuIChmcmVxID49IDUxNzAgJiYgZnJlcSA8IDU3NDUpOwotfQotCi0KLXNpemVfdCBwMnBfY29weV9yZWdfY2xhc3Moc3RydWN0IHAycF9yZWdfY2xhc3MgKmRjLCBzdHJ1Y3QgcDJwX3JlZ19jbGFzcyAqc2MpCi17Ci0JdW5zaWduZWQgaW50IGk7Ci0KLQlkYy0+cmVnX2NsYXNzID0gc2MtPnJlZ19jbGFzczsKLQlkYy0+Y2hhbm5lbHMgPSAwOwotCWZvciAoaT0wOyBpIDwgc2MtPmNoYW5uZWxzOyBpKyspIHsKLQkJaWYgKCFwMnBfYmxvY2tfb3BfZnJlcShwMnBfY2hhbm5lbF90b19mcmVxKHNjLT5yZWdfY2xhc3MsCi0JCQkJCQkJICAgc2MtPmNoYW5uZWxbaV0pKSkgewotCQkJZGMtPmNoYW5uZWxbZGMtPmNoYW5uZWxzXSA9IHNjLT5jaGFubmVsW2ldOwotCQkJZGMtPmNoYW5uZWxzKys7Ci0JCX0KLQl9Ci0JcmV0dXJuIGRjLT5jaGFubmVsczsKLX0KLSNlbmRpZgotCi0KIGludCBwMnBfc3VwcG9ydGVkX2ZyZXEoc3RydWN0IHAycF9kYXRhICpwMnAsIHVuc2lnbmVkIGludCBmcmVxKQogewogCXU4IG9wX3JlZ19jbGFzcywgb3BfY2hhbm5lbDsKLQotI2lmZGVmIEFORFJPSURfUDJQCi0JaWYgKHAycF9ibG9ja19vcF9mcmVxKGZyZXEpKQotCQlyZXR1cm4gMDsKLSNlbmRpZgogCWlmIChwMnBfZnJlcV90b19jaGFubmVsKGZyZXEsICZvcF9yZWdfY2xhc3MsICZvcF9jaGFubmVsKSA8IDApCiAJCXJldHVybiAwOwogCXJldHVybiBwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJnAycC0+Y2ZnLT5jaGFubmVscywgb3BfcmVnX2NsYXNzLApAQCAtMjg0LDI5ICszNjEsMTQyIEBACiB9CiAKIAoraW50IHAycF9zdXBwb3J0ZWRfZnJlcV9nbyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgdW5zaWduZWQgaW50IGZyZXEpCit7CisJdTggb3BfcmVnX2NsYXNzLCBvcF9jaGFubmVsOworCWlmIChwMnBfZnJlcV90b19jaGFubmVsKGZyZXEsICZvcF9yZWdfY2xhc3MsICZvcF9jaGFubmVsKSA8IDApCisJCXJldHVybiAwOworCXJldHVybiBwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJnAycC0+Y2ZnLT5jaGFubmVscywgb3BfcmVnX2NsYXNzLAorCQkJCSAgICAgb3BfY2hhbm5lbCkgJiYKKwkJIWZyZXFfcmFuZ2VfbGlzdF9pbmNsdWRlcygmcDJwLT5ub19nb19mcmVxLCBmcmVxKTsKK30KKworCitpbnQgcDJwX3N1cHBvcnRlZF9mcmVxX2NsaShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgdW5zaWduZWQgaW50IGZyZXEpCit7CisJdTggb3BfcmVnX2NsYXNzLCBvcF9jaGFubmVsOworCWlmIChwMnBfZnJlcV90b19jaGFubmVsKGZyZXEsICZvcF9yZWdfY2xhc3MsICZvcF9jaGFubmVsKSA8IDApCisJCXJldHVybiAwOworCXJldHVybiBwMnBfY2hhbm5lbHNfaW5jbHVkZXMoJnAycC0+Y2ZnLT5jaGFubmVscywgb3BfcmVnX2NsYXNzLAorCQkJCSAgICAgb3BfY2hhbm5lbCkgfHwKKwkJcDJwX2NoYW5uZWxzX2luY2x1ZGVzKCZwMnAtPmNmZy0+Y2xpX2NoYW5uZWxzLCBvcF9yZWdfY2xhc3MsCisJCQkJICAgICAgb3BfY2hhbm5lbCk7Cit9CisKKwogdW5zaWduZWQgaW50IHAycF9nZXRfcHJlZl9mcmVxKHN0cnVjdCBwMnBfZGF0YSAqcDJwLAogCQkJICAgICAgIGNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW5uZWxzKQogewogCXVuc2lnbmVkIGludCBpOwogCWludCBmcmVxID0gMDsKKwljb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICp0bXBjID0gY2hhbm5lbHMgPworCQljaGFubmVscyA6ICZwMnAtPmNmZy0+Y2hhbm5lbHM7CiAKLQlpZiAoY2hhbm5lbHMgPT0gTlVMTCkgewotCQlpZiAocDJwLT5jZmctPm51bV9wcmVmX2NoYW4pIHsKLQkJCWZyZXEgPSBwMnBfY2hhbm5lbF90b19mcmVxKAotCQkJCXAycC0+Y2ZnLT5wcmVmX2NoYW5bMF0ub3BfY2xhc3MsCi0JCQkJcDJwLT5jZmctPnByZWZfY2hhblswXS5jaGFuKTsKLQkJCWlmIChmcmVxIDwgMCkKLQkJCQlmcmVxID0gMDsKLQkJfQotCQlyZXR1cm4gZnJlcTsKLQl9CisJaWYgKHRtcGMgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CiAKIAlmb3IgKGkgPSAwOyBwMnAtPmNmZy0+cHJlZl9jaGFuICYmIGkgPCBwMnAtPmNmZy0+bnVtX3ByZWZfY2hhbjsgaSsrKSB7CiAJCWZyZXEgPSBwMnBfY2hhbm5lbF90b19mcmVxKHAycC0+Y2ZnLT5wcmVmX2NoYW5baV0ub3BfY2xhc3MsCiAJCQkJCSAgIHAycC0+Y2ZnLT5wcmVmX2NoYW5baV0uY2hhbik7Ci0JCWlmIChwMnBfY2hhbm5lbHNfaW5jbHVkZXNfZnJlcShjaGFubmVscywgZnJlcSkpCisJCWlmIChwMnBfY2hhbm5lbHNfaW5jbHVkZXNfZnJlcSh0bXBjLCBmcmVxKSkKIAkJCXJldHVybiBmcmVxOwogCX0KKwlyZXR1cm4gMDsKK30KKworCit2b2lkIHAycF9jaGFubmVsc19kdW1wKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCBjaGFyICp0aXRsZSwKKwkJICAgICAgIGNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW4pCit7CisJY2hhciBidWZbNTAwXSwgKnBvcywgKmVuZDsKKwlzaXplX3QgaSwgajsKKwlpbnQgcmV0OworCisJcG9zID0gYnVmOworCWVuZCA9IHBvcyArIHNpemVvZihidWYpOworCisJZm9yIChpID0gMDsgaSA8IGNoYW4tPnJlZ19jbGFzc2VzOyBpKyspIHsKKwkJY29uc3Qgc3RydWN0IHAycF9yZWdfY2xhc3MgKmM7CisJCWMgPSAmY2hhbi0+cmVnX2NsYXNzW2ldOworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiAldToiLCBjLT5yZWdfY2xhc3MpOworCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJYnJlYWs7CisJCXBvcyArPSByZXQ7CisKKwkJZm9yIChqID0gMDsgaiA8IGMtPmNoYW5uZWxzOyBqKyspIHsKKwkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXMldSIsCisJCQkJCSAgaiA9PSAwID8gIiIgOiAiLCIsCisJCQkJCSAgYy0+Y2hhbm5lbFtqXSk7CisJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJCWJyZWFrOworCQkJcG9zICs9IHJldDsKKwkJfQorCX0KKwkqcG9zID0gJ1wwJzsKKworCXAycF9kYmcocDJwLCAiJXM6JXMiLCB0aXRsZSwgYnVmKTsKK30KKworCitzdGF0aWMgdTggcDJwX2NoYW5uZWxfcGlja19yYW5kb20oY29uc3QgdTggKmNoYW5uZWxzLCB1bnNpZ25lZCBpbnQgbnVtX2NoYW5uZWxzKQoreworCXVuc2lnbmVkIGludCByOworCW9zX2dldF9yYW5kb20oKHU4ICopICZyLCBzaXplb2YocikpOworCXIgJT0gbnVtX2NoYW5uZWxzOworCXJldHVybiBjaGFubmVsc1tyXTsKK30KKworCitpbnQgcDJwX2NoYW5uZWxfc2VsZWN0KHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW5zLCBjb25zdCBpbnQgKmNsYXNzZXMsCisJCSAgICAgICB1OCAqb3BfY2xhc3MsIHU4ICpvcF9jaGFubmVsKQoreworCXVuc2lnbmVkIGludCBpLCBqOworCisJZm9yIChqID0gMDsgY2xhc3NlcyA9PSBOVUxMIHx8IGNsYXNzZXNbal07IGorKykgeworCQlmb3IgKGkgPSAwOyBpIDwgY2hhbnMtPnJlZ19jbGFzc2VzOyBpKyspIHsKKwkJCXN0cnVjdCBwMnBfcmVnX2NsYXNzICpjID0gJmNoYW5zLT5yZWdfY2xhc3NbaV07CisKKwkJCWlmIChjLT5jaGFubmVscyA9PSAwKQorCQkJCWNvbnRpbnVlOworCisJCQlpZiAoY2xhc3NlcyA9PSBOVUxMIHx8IGMtPnJlZ19jbGFzcyA9PSBjbGFzc2VzW2pdKSB7CisJCQkJLyoKKwkJCQkgKiBQaWNrIG9uZSBvZiB0aGUgYXZhaWxhYmxlIGNoYW5uZWxzIGluIHRoZQorCQkJCSAqIG9wZXJhdGluZyBjbGFzcyBhdCByYW5kb20uCisJCQkJICovCisJCQkJKm9wX2NsYXNzID0gYy0+cmVnX2NsYXNzOworCQkJCSpvcF9jaGFubmVsID0gcDJwX2NoYW5uZWxfcGlja19yYW5kb20oCisJCQkJCWMtPmNoYW5uZWwsIGMtPmNoYW5uZWxzKTsKKwkJCQlyZXR1cm4gMDsKKwkJCX0KKwkJfQorCQlpZiAoY2xhc3NlcyA9PSBOVUxMKQorCQkJYnJlYWs7CisJfQorCisJcmV0dXJuIC0xOworfQorCisKK2ludCBwMnBfY2hhbm5lbF9yYW5kb21fc29jaWFsKHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW5zLCB1OCAqb3BfY2xhc3MsCisJCQkgICAgICB1OCAqb3BfY2hhbm5lbCkKK3sKKwl1OCBjaGFuWzNdOworCXVuc2lnbmVkIGludCBudW1fY2hhbm5lbHMgPSAwOworCisJLyogVHJ5IHRvIGZpbmQgYXZhaWxhYmxlIHNvY2lhbCBjaGFubmVscyBmcm9tIDIuNCBHSHogKi8KKwlpZiAocDJwX2NoYW5uZWxzX2luY2x1ZGVzKGNoYW5zLCA4MSwgMSkpCisJCWNoYW5bbnVtX2NoYW5uZWxzKytdID0gMTsKKwlpZiAocDJwX2NoYW5uZWxzX2luY2x1ZGVzKGNoYW5zLCA4MSwgNikpCisJCWNoYW5bbnVtX2NoYW5uZWxzKytdID0gNjsKKwlpZiAocDJwX2NoYW5uZWxzX2luY2x1ZGVzKGNoYW5zLCA4MSwgMTEpKQorCQljaGFuW251bV9jaGFubmVscysrXSA9IDExOworCisJaWYgKG51bV9jaGFubmVscyA9PSAwKQorCQlyZXR1cm4gLTE7CisKKwkqb3BfY2xhc3MgPSA4MTsKKwkqb3BfY2hhbm5lbCA9IHAycF9jaGFubmVsX3BpY2tfcmFuZG9tKGNoYW4sIG51bV9jaGFubmVscyk7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL3NyYy9wYWUvTWFrZWZpbGUgYi9zcmMvcGFlL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjljNDE5NjIKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvcGFlL01ha2VmaWxlCkBAIC0wLDAgKzEsOCBAQAorYWxsOgorCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KKworY2xlYW46CisJcm0gLWYgKn4gKi5vICouZAorCitpbnN0YWxsOgorCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KZGlmZiAtLWdpdCBhL3NyYy9wYWUvaWVlZTgwMl8xeF9jcC5jIGIvc3JjL3BhZS9pZWVlODAyXzF4X2NwLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2Y0M2M1OQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9wYWUvaWVlZTgwMl8xeF9jcC5jCkBAIC0wLDAgKzEsNzQ0IEBACisvKgorICogSUVFRSA4MDIuMVgtMjAxMCBDb250cm9sbGVkIFBvcnQgb2YgUEFFIHN0YXRlIG1hY2hpbmUgLSBDUCBzdGF0ZSBtYWNoaW5lCisgKiBDb3B5cmlnaHQgKGMpIDIwMTMtMjAxNCwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgInV0aWxzL2luY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKyNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgorI2luY2x1ZGUgImNvbW1vbi9kZWZzLmgiCisjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMXhfZGVmcy5oIgorI2luY2x1ZGUgInV0aWxzL3N0YXRlX21hY2hpbmUuaCIKKyNpbmNsdWRlICJpZWVlODAyXzF4X2theS5oIgorI2luY2x1ZGUgImllZWU4MDJfMXhfc2VjeV9vcHMuaCIKKyNpbmNsdWRlICJwYWUvaWVlZTgwMl8xeF9jcC5oIgorCisjZGVmaW5lIFNUQVRFX01BQ0hJTkVfREFUQSBzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbQorI2RlZmluZSBTVEFURV9NQUNISU5FX0RFQlVHX1BSRUZJWCAiQ1AiCisKK3N0YXRpYyB1OCBkZWZhdWx0X2NzX2lkW10gPSBDU19JRF9HQ01fQUVTXzEyODsKKworLyogVGhlIHZhcmlhYmxlIGRlZmluZWQgaW4gY2xhdXNlIDEyIGluIElFRUUgU3RkIDgwMi4xWC0yMDEwICovCitlbnVtIGNvbm5lY3RfdHlwZSB7IFBFTkRJTkcsIFVOQVVUSEVOVElDQVRFRCwgQVVUSEVOVElDQVRFRCwgU0VDVVJFIH07CisKK3N0cnVjdCBpZWVlODAyXzF4X2NwX3NtIHsKKwllbnVtIGNwX3N0YXRlcyB7CisJCUNQX0JFR0lOLCBDUF9JTklULCBDUF9DSEFOR0UsIENQX0FMTE9XRUQsIENQX0FVVEhFTlRJQ0FURUQsCisJCUNQX1NFQ1VSRUQsIENQX1JFQ0VJVkUsIENQX1JFQ0VJVklORywgQ1BfUkVBRFksIENQX1RSQU5TTUlULAorCQlDUF9UUkFOU01JVFRJTkcsIENQX0FCQU5ET04sIENQX1JFVElSRQorCX0gQ1Bfc3RhdGU7CisJQm9vbGVhbiBjaGFuZ2VkOworCisJLyogQ1AgLT4gQ2xpZW50ICovCisJQm9vbGVhbiBwb3J0X3ZhbGlkOworCisJLyogTG9nb24gLT4gQ1AgKi8KKwllbnVtIGNvbm5lY3RfdHlwZSBjb25uZWN0OworCXU4ICphdXRob3JpemF0aW9uX2RhdGE7CisKKwkvKiBLYVkgLT4gQ1AgKi8KKwlCb29sZWFuIGNoZ2Rfc2VydmVyOyAvKiBjbGVhciBieSBDUCAqLworCUJvb2xlYW4gZWxlY3RlZF9zZWxmOworCXU4ICphdXRob3JpemF0aW9uX2RhdGExOworCWVudW0gY29uZmlkZW50aWFsaXR5X29mZnNldCBjaXBoZXJfb2Zmc2V0OworCXU4ICpjaXBoZXJfc3VpdGU7CisJQm9vbGVhbiBuZXdfc2FrOyAvKiBjbGVhciBieSBDUCAqLworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9raSBkaXN0cmlidXRlZF9raTsKKwl1OCBkaXN0cmlidXRlZF9hbjsKKwlCb29sZWFuIHVzaW5nX3JlY2VpdmVfc2FzOworCUJvb2xlYW4gYWxsX3JlY2VpdmluZzsKKwlCb29sZWFuIHNlcnZlcl90cmFuc21pdHRpbmc7CisJQm9vbGVhbiB1c2luZ190cmFuc21pdF9zYTsKKworCS8qIENQIC0+IEthWSAqLworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9raSAqbGtpOworCXU4IGxhbjsKKwlCb29sZWFuIGx0eDsKKwlCb29sZWFuIGxyeDsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffa2kgKm9raTsKKwl1OCBvYW47CisJQm9vbGVhbiBvdHg7CisJQm9vbGVhbiBvcng7CisKKwkvKiBDUCAtPiBTZWNZICovCisJQm9vbGVhbiBwcm90ZWN0X2ZyYW1lczsKKwllbnVtIHZhbGlkYXRlX2ZyYW1lcyB2YWxpZGF0ZV9mcmFtZXM7CisKKwlCb29sZWFuIHJlcGxheV9wcm90ZWN0OworCXUzMiByZXBsYXlfd2luZG93OworCisJdTggKmN1cnJlbnRfY2lwaGVyX3N1aXRlOworCWVudW0gY29uZmlkZW50aWFsaXR5X29mZnNldCBjb25maWRlbnRpYWxpdHlfb2Zmc2V0OworCUJvb2xlYW4gY29udHJvbGxlZF9wb3J0X2VuYWJsZWQ7CisKKwkvKiBTZWNZIC0+IENQICovCisJQm9vbGVhbiBwb3J0X2VuYWJsZWQ7IC8qIFNlY1ktPkNQICovCisKKwkvKiBwcml2YXRlICovCisJdTMyIHRyYW5zbWl0X3doZW47CisJdTMyIHRyYW5zbWl0X2RlbGF5OworCXUzMiByZXRpcmVfd2hlbjsKKwl1MzIgcmV0aXJlX2RlbGF5OworCisJLyogbm90IGRlZmluZWQgSUVFRSBTdGQgODAyLjFYLTIwMTAgKi8KKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheTsKK307CisKK3N0YXRpYyB2b2lkIGllZWU4MDJfMXhfY3BfcmV0aXJlX3doZW5fdGltZW91dCh2b2lkICplbG9vcF9jdHgsCisJCQkJCSAgICAgIHZvaWQgKnRpbWVvdXRfY3R4KTsKK3N0YXRpYyB2b2lkIGllZWU4MDJfMXhfY3BfdHJhbnNtaXRfd2hlbl90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwKKwkJCQkJCXZvaWQgKnRpbWVvdXRfY3R4KTsKKworCitzdGF0aWMgaW50IGNoYW5nZWRfY2lwaGVyKHN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSkKK3sKKwlyZXR1cm4gc20tPmNvbmZpZGVudGlhbGl0eV9vZmZzZXQgIT0gc20tPmNpcGhlcl9vZmZzZXQgfHwKKwkJb3NfbWVtY21wKHNtLT5jdXJyZW50X2NpcGhlcl9zdWl0ZSwgc20tPmNpcGhlcl9zdWl0ZSwKKwkJCSAgQ1NfSURfTEVOKSAhPSAwOworfQorCisKK3N0YXRpYyBpbnQgY2hhbmdlZF9jb25uZWN0KHN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSkKK3sKKwlyZXR1cm4gc20tPmNvbm5lY3QgIT0gU0VDVVJFIHx8IHNtLT5jaGdkX3NlcnZlciB8fCBjaGFuZ2VkX2NpcGhlcihzbSk7Cit9CisKKworU01fU1RBVEUoQ1AsIElOSVQpCit7CisJU01fRU5UUlkoQ1AsIElOSVQpOworCisJc20tPmNvbnRyb2xsZWRfcG9ydF9lbmFibGVkID0gRkFMU0U7CisJc2VjeV9jcF9jb250cm9sX2VuYWJsZV9wb3J0KHNtLT5rYXksIHNtLT5jb250cm9sbGVkX3BvcnRfZW5hYmxlZCk7CisKKwlzbS0+cG9ydF92YWxpZCA9IEZBTFNFOworCisJb3NfZnJlZShzbS0+bGtpKTsKKwlzbS0+bGtpID0gTlVMTDsKKwlzbS0+bHR4ID0gRkFMU0U7CisJc20tPmxyeCA9IEZBTFNFOworCisJb3NfZnJlZShzbS0+b2tpKTsKKwlzbS0+b2tpID0gTlVMTDsKKwlzbS0+b3R4ID0gRkFMU0U7CisJc20tPm9yeCA9IEZBTFNFOworCisJc20tPnBvcnRfZW5hYmxlZCA9IFRSVUU7CisJc20tPmNoZ2Rfc2VydmVyID0gRkFMU0U7Cit9CisKKworU01fU1RBVEUoQ1AsIENIQU5HRSkKK3sKKwlTTV9FTlRSWShDUCwgQ0hBTkdFKTsKKworCXNtLT5wb3J0X3ZhbGlkID0gRkFMU0U7CisJc20tPmNvbnRyb2xsZWRfcG9ydF9lbmFibGVkID0gRkFMU0U7CisJc2VjeV9jcF9jb250cm9sX2VuYWJsZV9wb3J0KHNtLT5rYXksIHNtLT5jb250cm9sbGVkX3BvcnRfZW5hYmxlZCk7CisKKwlpZiAoc20tPmxraSkKKwkJaWVlZTgwMl8xeF9rYXlfZGVsZXRlX3NhcyhzbS0+a2F5LCBzbS0+bGtpKTsKKwlpZiAoc20tPm9raSkKKwkJaWVlZTgwMl8xeF9rYXlfZGVsZXRlX3NhcyhzbS0+a2F5LCBzbS0+b2tpKTsKK30KKworCitTTV9TVEFURShDUCwgQUxMT1dFRCkKK3sKKwlTTV9FTlRSWShDUCwgQUxMT1dFRCk7CisKKwlzbS0+cHJvdGVjdF9mcmFtZXMgPSBGQUxTRTsKKwlzbS0+cmVwbGF5X3Byb3RlY3QgPSBGQUxTRTsKKwlzbS0+dmFsaWRhdGVfZnJhbWVzID0gQ2hlY2tlZDsKKworCXNtLT5wb3J0X3ZhbGlkID0gRkFMU0U7CisJc20tPmNvbnRyb2xsZWRfcG9ydF9lbmFibGVkID0gVFJVRTsKKworCXNlY3lfY3BfY29udHJvbF9lbmFibGVfcG9ydChzbS0+a2F5LCBzbS0+Y29udHJvbGxlZF9wb3J0X2VuYWJsZWQpOworCXNlY3lfY3BfY29udHJvbF9wcm90ZWN0X2ZyYW1lcyhzbS0+a2F5LCBzbS0+cHJvdGVjdF9mcmFtZXMpOworCXNlY3lfY3BfY29udHJvbF92YWxpZGF0ZV9mcmFtZXMoc20tPmtheSwgc20tPnZhbGlkYXRlX2ZyYW1lcyk7CisJc2VjeV9jcF9jb250cm9sX3JlcGxheShzbS0+a2F5LCBzbS0+cmVwbGF5X3Byb3RlY3QsIHNtLT5yZXBsYXlfd2luZG93KTsKK30KKworCitTTV9TVEFURShDUCwgQVVUSEVOVElDQVRFRCkKK3sKKwlTTV9FTlRSWShDUCwgQVVUSEVOVElDQVRFRCk7CisKKwlzbS0+cHJvdGVjdF9mcmFtZXMgPSBGQUxTRTsKKwlzbS0+cmVwbGF5X3Byb3RlY3QgPSBGQUxTRTsKKwlzbS0+dmFsaWRhdGVfZnJhbWVzID0gQ2hlY2tlZDsKKworCXNtLT5wb3J0X3ZhbGlkID0gRkFMU0U7CisJc20tPmNvbnRyb2xsZWRfcG9ydF9lbmFibGVkID0gVFJVRTsKKworCXNlY3lfY3BfY29udHJvbF9lbmFibGVfcG9ydChzbS0+a2F5LCBzbS0+Y29udHJvbGxlZF9wb3J0X2VuYWJsZWQpOworCXNlY3lfY3BfY29udHJvbF9wcm90ZWN0X2ZyYW1lcyhzbS0+a2F5LCBzbS0+cHJvdGVjdF9mcmFtZXMpOworCXNlY3lfY3BfY29udHJvbF92YWxpZGF0ZV9mcmFtZXMoc20tPmtheSwgc20tPnZhbGlkYXRlX2ZyYW1lcyk7CisJc2VjeV9jcF9jb250cm9sX3JlcGxheShzbS0+a2F5LCBzbS0+cmVwbGF5X3Byb3RlY3QsIHNtLT5yZXBsYXlfd2luZG93KTsKK30KKworCitTTV9TVEFURShDUCwgU0VDVVJFRCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9jb25mIGNvbmY7CisKKwlTTV9FTlRSWShDUCwgU0VDVVJFRCk7CisKKwlzbS0+Y2hnZF9zZXJ2ZXIgPSBGQUxTRTsKKworCWllZWU4MDJfMXhfa2F5X2NwX2NvbmYoc20tPmtheSwgJmNvbmYpOworCXNtLT5wcm90ZWN0X2ZyYW1lcyA9IGNvbmYucHJvdGVjdDsKKwlzbS0+cmVwbGF5X3Byb3RlY3QgPSBjb25mLnJlcGxheV9wcm90ZWN0OworCXNtLT52YWxpZGF0ZV9mcmFtZXMgPSBjb25mLnZhbGlkYXRlOworCisJLyogTk9URTogbm93IG5vIG90aGVyIHRoYW4gZGVmYXVsdCBjaXBoZXIgc3VpdGVyKEFFUy1HQ00tMTI4KSAqLworCW9zX21lbWNweShzbS0+Y3VycmVudF9jaXBoZXJfc3VpdGUsIHNtLT5jaXBoZXJfc3VpdGUsIENTX0lEX0xFTik7CisJc2VjeV9jcF9jb250cm9sX2N1cnJlbnRfY2lwaGVyX3N1aXRlKHNtLT5rYXksIHNtLT5jdXJyZW50X2NpcGhlcl9zdWl0ZSwKKwkJCQkJICAgICBDU19JRF9MRU4pOworCisJc20tPmNvbmZpZGVudGlhbGl0eV9vZmZzZXQgPSBzbS0+Y2lwaGVyX29mZnNldDsKKworCXNtLT5wb3J0X3ZhbGlkID0gVFJVRTsKKworCXNlY3lfY3BfY29udHJvbF9jb25maWRlbnRpYWxpdHlfb2Zmc2V0KHNtLT5rYXksCisJCQkJCSAgICAgICBzbS0+Y29uZmlkZW50aWFsaXR5X29mZnNldCk7CisJc2VjeV9jcF9jb250cm9sX3Byb3RlY3RfZnJhbWVzKHNtLT5rYXksIHNtLT5wcm90ZWN0X2ZyYW1lcyk7CisJc2VjeV9jcF9jb250cm9sX3ZhbGlkYXRlX2ZyYW1lcyhzbS0+a2F5LCBzbS0+dmFsaWRhdGVfZnJhbWVzKTsKKwlzZWN5X2NwX2NvbnRyb2xfcmVwbGF5KHNtLT5rYXksIHNtLT5yZXBsYXlfcHJvdGVjdCwgc20tPnJlcGxheV93aW5kb3cpOworfQorCisKK1NNX1NUQVRFKENQLCBSRUNFSVZFKQoreworCVNNX0VOVFJZKENQLCBSRUNFSVZFKTsKKwkvKiBSRUNFSVZFIHN0YXRlIG1hY2hpbmUgbm90IGtlZXAgd2l0aCBGaWd1cmUgMTItMiBpbgorCSAqIElFRUUgU3RkIDgwMi4xWC0yMDEwICovCisJc20tPm9raSA9IHNtLT5sa2k7CisJc20tPm9hbiA9IHNtLT5sYW47CisJc20tPm90eCA9IHNtLT5sdHg7CisJc20tPm9yeCA9IHNtLT5scng7CisJaWVlZTgwMl8xeF9rYXlfc2V0X29sZF9zYV9hdHRyKHNtLT5rYXksIHNtLT5va2ksIHNtLT5vYW4sCisJCQkJICAgICAgIHNtLT5vdHgsIHNtLT5vcngpOworCisJc20tPmxraSA9IG9zX21hbGxvYyhzaXplb2YoKnNtLT5sa2kpKTsKKwlpZiAoIXNtLT5sa2kpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDUC0lczogT3V0IG9mIG1lbW9yeSIsIF9fZnVuY19fKTsKKwkJcmV0dXJuOworCX0KKwlvc19tZW1jcHkoc20tPmxraSwgJnNtLT5kaXN0cmlidXRlZF9raSwgc2l6ZW9mKCpzbS0+bGtpKSk7CisJc20tPmxhbiA9IHNtLT5kaXN0cmlidXRlZF9hbjsKKwlzbS0+bHR4ID0gRkFMU0U7CisJc20tPmxyeCA9IEZBTFNFOworCWllZWU4MDJfMXhfa2F5X3NldF9sYXRlc3Rfc2FfYXR0cihzbS0+a2F5LCBzbS0+bGtpLCBzbS0+bGFuLAorCQkJCQkgIHNtLT5sdHgsIHNtLT5scngpOworCWllZWU4MDJfMXhfa2F5X2NyZWF0ZV9zYXMoc20tPmtheSwgc20tPmxraSk7CisJaWVlZTgwMl8xeF9rYXlfZW5hYmxlX3J4X3NhcyhzbS0+a2F5LCBzbS0+bGtpKTsKKwlzbS0+bmV3X3NhayA9IEZBTFNFOworCXNtLT5hbGxfcmVjZWl2aW5nID0gRkFMU0U7Cit9CisKKworU01fU1RBVEUoQ1AsIFJFQ0VJVklORykKK3sKKwlTTV9FTlRSWShDUCwgUkVDRUlWSU5HKTsKKworCXNtLT5scnggPSBUUlVFOworCWllZWU4MDJfMXhfa2F5X3NldF9sYXRlc3Rfc2FfYXR0cihzbS0+a2F5LCBzbS0+bGtpLCBzbS0+bGFuLAorCQkJCQkgIHNtLT5sdHgsIHNtLT5scngpOworCXNtLT50cmFuc21pdF93aGVuID0gc20tPnRyYW5zbWl0X2RlbGF5OworCWVsb29wX2NhbmNlbF90aW1lb3V0KGllZWU4MDJfMXhfY3BfdHJhbnNtaXRfd2hlbl90aW1lb3V0LCBzbSwgTlVMTCk7CisJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChzbS0+dHJhbnNtaXRfd2hlbiAvIDEwMDAsIDAsCisJCQkgICAgICAgaWVlZTgwMl8xeF9jcF90cmFuc21pdF93aGVuX3RpbWVvdXQsIHNtLCBOVUxMKTsKKwkvKiB0aGUgZWxlY3RlZFNlbGYgaGF2ZSBiZWVuIHNldCBiZWZvcmUgQ1AgZW50ZXJpbmcgdG8gUkVDRUlWSU5HCisJICogYnV0IHRoZSBDUCB3aWxsIHRyYW5zbWl0IGZyb20gUkVDRUlWSU5HIHRvIFJFQURZIHVuZGVyCisJICogdGhlICFlbGVjdGVkU2VsZiB3aGVuIEthWSBpcyBub3Qga2V5IHNlcnZlciAqLworCWllZWU4MDJfMXhfY3Bfc21fc3RlcChzbSk7CisJc20tPnVzaW5nX3JlY2VpdmVfc2FzID0gRkFMU0U7CisJc20tPnNlcnZlcl90cmFuc21pdHRpbmcgPSBGQUxTRTsKK30KKworCitTTV9TVEFURShDUCwgUkVBRFkpCit7CisJU01fRU5UUlkoQ1AsIFJFQURZKTsKKworCWllZWU4MDJfMXhfa2F5X2VuYWJsZV9uZXdfaW5mbyhzbS0+a2F5KTsKK30KKworCitTTV9TVEFURShDUCwgVFJBTlNNSVQpCit7CisJU01fRU5UUlkoQ1AsIFRSQU5TTUlUKTsKKworCXNtLT5jb250cm9sbGVkX3BvcnRfZW5hYmxlZCA9IFRSVUU7CisJc2VjeV9jcF9jb250cm9sX2VuYWJsZV9wb3J0KHNtLT5rYXksIHNtLT5jb250cm9sbGVkX3BvcnRfZW5hYmxlZCk7CisJc20tPmx0eCA9IFRSVUU7CisJaWVlZTgwMl8xeF9rYXlfc2V0X2xhdGVzdF9zYV9hdHRyKHNtLT5rYXksIHNtLT5sa2ksIHNtLT5sYW4sCisJCQkJCSAgc20tPmx0eCwgc20tPmxyeCk7CisJaWVlZTgwMl8xeF9rYXlfZW5hYmxlX3R4X3NhcyhzbS0+a2F5LCAgc20tPmxraSk7CisJc20tPmFsbF9yZWNlaXZpbmcgPSBGQUxTRTsKKwlzbS0+c2VydmVyX3RyYW5zbWl0dGluZyA9IEZBTFNFOworfQorCisKK1NNX1NUQVRFKENQLCBUUkFOU01JVFRJTkcpCit7CisJU01fRU5UUlkoQ1AsIFRSQU5TTUlUVElORyk7CisJc20tPnJldGlyZV93aGVuID0gc20tPm9yeCA/IHNtLT5yZXRpcmVfZGVsYXkgOiAwOworCXNtLT5vdHggPSBGQUxTRTsKKwlpZWVlODAyXzF4X2theV9zZXRfb2xkX3NhX2F0dHIoc20tPmtheSwgc20tPm9raSwgc20tPm9hbiwKKwkJCQkgICAgICAgc20tPm90eCwgc20tPm9yeCk7CisJaWVlZTgwMl8xeF9rYXlfZW5hYmxlX25ld19pbmZvKHNtLT5rYXkpOworCWVsb29wX2NhbmNlbF90aW1lb3V0KGllZWU4MDJfMXhfY3BfcmV0aXJlX3doZW5fdGltZW91dCwgc20sIE5VTEwpOworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoc20tPnJldGlyZV93aGVuIC8gMTAwMCwgMCwKKwkJCSAgICAgICBpZWVlODAyXzF4X2NwX3JldGlyZV93aGVuX3RpbWVvdXQsIHNtLCBOVUxMKTsKKwlzbS0+dXNpbmdfdHJhbnNtaXRfc2EgPSBGQUxTRTsKK30KKworCitTTV9TVEFURShDUCwgQUJBTkRPTikKK3sKKwlTTV9FTlRSWShDUCwgQUJBTkRPTik7CisJc20tPmxyeCA9IEZBTFNFOworCWllZWU4MDJfMXhfa2F5X3NldF9sYXRlc3Rfc2FfYXR0cihzbS0+a2F5LCBzbS0+bGtpLCBzbS0+bGFuLAorCQkJCQkgIHNtLT5sdHgsIHNtLT5scngpOworCWllZWU4MDJfMXhfa2F5X2RlbGV0ZV9zYXMoc20tPmtheSwgc20tPmxraSk7CisKKwlvc19mcmVlKHNtLT5sa2kpOworCXNtLT5sa2kgPSBOVUxMOworCWllZWU4MDJfMXhfa2F5X3NldF9sYXRlc3Rfc2FfYXR0cihzbS0+a2F5LCBzbS0+bGtpLCBzbS0+bGFuLAorCQkJCQkgIHNtLT5sdHgsIHNtLT5scngpOworCXNtLT5uZXdfc2FrID0gRkFMU0U7Cit9CisKKworU01fU1RBVEUoQ1AsIFJFVElSRSkKK3sKKwlTTV9FTlRSWShDUCwgUkVUSVJFKTsKKwkvKiBSRVRJUkUgc3RhdGUgbWFjaGluZSBub3Qga2VlcCB3aXRoIEZpZ3VyZSAxMi0yIGluCisJICogSUVFRSBTdGQgODAyLjFYLTIwMTAgKi8KKwlvc19mcmVlKHNtLT5va2kpOworCXNtLT5va2kgPSBOVUxMOworCXNtLT5vcnggPSBGQUxTRTsKKwlzbS0+b3R4ID0gRkFMU0U7CisJaWVlZTgwMl8xeF9rYXlfc2V0X29sZF9zYV9hdHRyKHNtLT5rYXksIHNtLT5va2ksIHNtLT5vYW4sCisJCQkJICAgICAgIHNtLT5vdHgsIHNtLT5vcngpOworfQorCisKKy8qKgorICogQ1Agc3RhdGUgbWFjaGluZSBoYW5kbGVyIGVudHJ5CisgKi8KK1NNX1NURVAoQ1ApCit7CisJaWYgKCFzbS0+cG9ydF9lbmFibGVkKQorCQlTTV9FTlRFUihDUCwgSU5JVCk7CisKKwlzd2l0Y2ggKHNtLT5DUF9zdGF0ZSkgeworCWNhc2UgQ1BfQkVHSU46CisJCVNNX0VOVEVSKENQLCBJTklUKTsKKwkJYnJlYWs7CisKKwljYXNlIENQX0lOSVQ6CisJCVNNX0VOVEVSKENQLCBDSEFOR0UpOworCQlicmVhazsKKworCWNhc2UgQ1BfQ0hBTkdFOgorCQlpZiAoc20tPmNvbm5lY3QgPT0gVU5BVVRIRU5USUNBVEVEKQorCQkJU01fRU5URVIoQ1AsIEFMTE9XRUQpOworCQllbHNlIGlmIChzbS0+Y29ubmVjdCA9PSBBVVRIRU5USUNBVEVEKQorCQkJU01fRU5URVIoQ1AsIEFVVEhFTlRJQ0FURUQpOworCQllbHNlIGlmIChzbS0+Y29ubmVjdCA9PSBTRUNVUkUpCisJCQlTTV9FTlRFUihDUCwgU0VDVVJFRCk7CisJCWJyZWFrOworCisJY2FzZSBDUF9BTExPV0VEOgorCQlpZiAoc20tPmNvbm5lY3QgIT0gVU5BVVRIRU5USUNBVEVEKQorCQkJU01fRU5URVIoQ1AsIENIQU5HRSk7CisJCWJyZWFrOworCisJY2FzZSBDUF9BVVRIRU5USUNBVEVEOgorCQlpZiAoc20tPmNvbm5lY3QgIT0gQVVUSEVOVElDQVRFRCkKKwkJCVNNX0VOVEVSKENQLCBDSEFOR0UpOworCQlicmVhazsKKworCWNhc2UgQ1BfU0VDVVJFRDoKKwkJaWYgKGNoYW5nZWRfY29ubmVjdChzbSkpCisJCQlTTV9FTlRFUihDUCwgQ0hBTkdFKTsKKwkJZWxzZSBpZiAoc20tPm5ld19zYWspCisJCQlTTV9FTlRFUihDUCwgUkVDRUlWRSk7CisJCWJyZWFrOworCisJY2FzZSBDUF9SRUNFSVZFOgorCQlpZiAoc20tPnVzaW5nX3JlY2VpdmVfc2FzKQorCQkJU01fRU5URVIoQ1AsIFJFQ0VJVklORyk7CisJCWJyZWFrOworCisJY2FzZSBDUF9SRUNFSVZJTkc6CisJCWlmIChzbS0+bmV3X3NhayB8fCBjaGFuZ2VkX2Nvbm5lY3Qoc20pKQorCQkJU01fRU5URVIoQ1AsIEFCQU5ET04pOworCQlpZiAoIXNtLT5lbGVjdGVkX3NlbGYpCisJCQlTTV9FTlRFUihDUCwgUkVBRFkpOworCQlpZiAoc20tPmVsZWN0ZWRfc2VsZiAmJgorCQkgICAgKHNtLT5hbGxfcmVjZWl2aW5nIHx8ICFzbS0+dHJhbnNtaXRfd2hlbikpCisJCQlTTV9FTlRFUihDUCwgVFJBTlNNSVQpOworCQlicmVhazsKKworCWNhc2UgQ1BfVFJBTlNNSVQ6CisJCWlmIChzbS0+dXNpbmdfdHJhbnNtaXRfc2EpCisJCQlTTV9FTlRFUihDUCwgVFJBTlNNSVRUSU5HKTsKKwkJYnJlYWs7CisKKwljYXNlIENQX1RSQU5TTUlUVElORzoKKwkJaWYgKCFzbS0+cmV0aXJlX3doZW4gfHwgY2hhbmdlZF9jb25uZWN0KHNtKSkKKwkJCVNNX0VOVEVSKENQLCBSRVRJUkUpOworCQlicmVhazsKKworCWNhc2UgQ1BfUkVUSVJFOgorCQlpZiAoY2hhbmdlZF9jb25uZWN0KHNtKSkKKwkJCVNNX0VOVEVSKENQLCBDSEFOR0UpOworCQllbHNlIGlmIChzbS0+bmV3X3NhaykKKwkJCVNNX0VOVEVSKENQLCBSRUNFSVZFKTsKKwkJYnJlYWs7CisKKwljYXNlIENQX1JFQURZOgorCQlpZiAoc20tPm5ld19zYWsgfHwgY2hhbmdlZF9jb25uZWN0KHNtKSkKKwkJCVNNX0VOVEVSKENQLCBSRUNFSVZFKTsKKwkJaWYgKHNtLT5zZXJ2ZXJfdHJhbnNtaXR0aW5nKQorCQkJU01fRU5URVIoQ1AsIFRSQU5TTUlUKTsKKwkJYnJlYWs7CisJY2FzZSBDUF9BQkFORE9OOgorCQlpZiAoY2hhbmdlZF9jb25uZWN0KHNtKSkKKwkJCVNNX0VOVEVSKENQLCBSRVRJUkUpOworCQllbHNlIGlmIChzbS0+bmV3X3NhaykKKwkJCVNNX0VOVEVSKENQLCBSRUNFSVZFKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDUDogdGhlIHN0YXRlIG1hY2hpbmUgaXMgbm90IGRlZmluZWQiKTsKKwkJYnJlYWs7CisJfQorfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9jcF9zbV9pbml0IC0KKyAqLworc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKiBpZWVlODAyXzF4X2NwX3NtX2luaXQoCisJc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJc3RydWN0IGllZWU4MDJfMXhfY3BfY29uZiAqcGNwX2NvbmYpCit7CisJc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKnNtOworCisJc20gPSBvc196YWxsb2Moc2l6ZW9mKCpzbSkpOworCWlmIChzbSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ1AtJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBOVUxMOworCX0KKworCXNtLT5rYXkgPSBrYXk7CisKKwlzbS0+cG9ydF92YWxpZCA9IEZBTFNFOworCisJc20tPmNoZ2Rfc2VydmVyID0gRkFMU0U7CisKKwlzbS0+cHJvdGVjdF9mcmFtZXMgPSBwY3BfY29uZi0+cHJvdGVjdDsKKwlzbS0+dmFsaWRhdGVfZnJhbWVzID0gcGNwX2NvbmYtPnZhbGlkYXRlOworCXNtLT5yZXBsYXlfcHJvdGVjdCA9IHBjcF9jb25mLT5yZXBsYXlfcHJvdGVjdDsKKwlzbS0+cmVwbGF5X3dpbmRvdyA9IHBjcF9jb25mLT5yZXBsYXlfd2luZG93OworCisJc20tPmNvbnRyb2xsZWRfcG9ydF9lbmFibGVkID0gRkFMU0U7CisKKwlzbS0+bGtpID0gTlVMTDsKKwlzbS0+bHJ4ID0gRkFMU0U7CisJc20tPmx0eCA9IEZBTFNFOworCXNtLT5va2kgPSBOVUxMOworCXNtLT5vcnggPSBGQUxTRTsKKwlzbS0+b3R4ID0gRkFMU0U7CisKKwlzbS0+Y2lwaGVyX3N1aXRlID0gb3NfemFsbG9jKENTX0lEX0xFTik7CisJc20tPmN1cnJlbnRfY2lwaGVyX3N1aXRlID0gb3NfemFsbG9jKENTX0lEX0xFTik7CisJaWYgKCFzbS0+Y2lwaGVyX3N1aXRlIHx8ICFzbS0+Y3VycmVudF9jaXBoZXJfc3VpdGUpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDUC0lczogb3V0IG9mIG1lbW9yeSIsIF9fZnVuY19fKTsKKwkJb3NfZnJlZShzbS0+Y2lwaGVyX3N1aXRlKTsKKwkJb3NfZnJlZShzbS0+Y3VycmVudF9jaXBoZXJfc3VpdGUpOworCQlvc19mcmVlKHNtKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCW9zX21lbWNweShzbS0+Y3VycmVudF9jaXBoZXJfc3VpdGUsIGRlZmF1bHRfY3NfaWQsIENTX0lEX0xFTik7CisJb3NfbWVtY3B5KHNtLT5jaXBoZXJfc3VpdGUsIGRlZmF1bHRfY3NfaWQsIENTX0lEX0xFTik7CisJc20tPmNpcGhlcl9vZmZzZXQgPSBDT05GSURFTlRJQUxJVFlfT0ZGU0VUXzA7CisJc20tPmNvbmZpZGVudGlhbGl0eV9vZmZzZXQgPSBzbS0+Y2lwaGVyX29mZnNldDsKKwlzbS0+dHJhbnNtaXRfZGVsYXkgPSBNS0FfTElGRV9USU1FOworCXNtLT5yZXRpcmVfZGVsYXkgPSBNS0FfU0FLX1JFVElSRV9USU1FOworCXNtLT5DUF9zdGF0ZSA9IENQX0JFR0lOOworCXNtLT5jaGFuZ2VkID0gRkFMU0U7CisJc20tPmF1dGhvcml6YXRpb25fZGF0YSA9IE5VTEw7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNQOiBzdGF0ZSBtYWNoaW5lIGNyZWF0ZWQiKTsKKworCXNlY3lfY3BfY29udHJvbF9wcm90ZWN0X2ZyYW1lcyhzbS0+a2F5LCBzbS0+cHJvdGVjdF9mcmFtZXMpOworCXNlY3lfY3BfY29udHJvbF92YWxpZGF0ZV9mcmFtZXMoc20tPmtheSwgc20tPnZhbGlkYXRlX2ZyYW1lcyk7CisJc2VjeV9jcF9jb250cm9sX3JlcGxheShzbS0+a2F5LCBzbS0+cmVwbGF5X3Byb3RlY3QsIHNtLT5yZXBsYXlfd2luZG93KTsKKwlzZWN5X2NwX2NvbnRyb2xfZW5hYmxlX3BvcnQoc20tPmtheSwgc20tPmNvbnRyb2xsZWRfcG9ydF9lbmFibGVkKTsKKwlzZWN5X2NwX2NvbnRyb2xfY29uZmlkZW50aWFsaXR5X29mZnNldChzbS0+a2F5LAorCQkJCQkgICAgICAgc20tPmNvbmZpZGVudGlhbGl0eV9vZmZzZXQpOworCisJU01fRU5URVIoQ1AsIElOSVQpOworCVNNX1NURVBfUlVOKENQKTsKKworCXJldHVybiBzbTsKK30KKworCitzdGF0aWMgdm9pZCBpZWVlODAyXzF4X2NwX3N0ZXBfcnVuKHN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSkKK3sKKwllbnVtIGNwX3N0YXRlcyBwcmV2X3N0YXRlOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IDEwMDsgaSsrKSB7CisJCXByZXZfc3RhdGUgPSBzbS0+Q1Bfc3RhdGU7CisJCVNNX1NURVBfUlVOKENQKTsKKwkJaWYgKHByZXZfc3RhdGUgPT0gc20tPkNQX3N0YXRlKQorCQkJYnJlYWs7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIGllZWU4MDJfMXhfY3Bfc3RlcF9jYih2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGVsb29wX2N0eDsKKwlpZWVlODAyXzF4X2NwX3N0ZXBfcnVuKHNtKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc21fZGVpbml0IC0KKyAqLwordm9pZCBpZWVlODAyXzF4X2NwX3NtX2RlaW5pdChzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20pCit7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDUDogc3RhdGUgbWFjaGluZSByZW1vdmVkIik7CisJaWYgKCFzbSkKKwkJcmV0dXJuOworCisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaWVlZTgwMl8xeF9jcF9yZXRpcmVfd2hlbl90aW1lb3V0LCBzbSwgTlVMTCk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaWVlZTgwMl8xeF9jcF90cmFuc21pdF93aGVuX3RpbWVvdXQsIHNtLCBOVUxMKTsKKwllbG9vcF9jYW5jZWxfdGltZW91dChpZWVlODAyXzF4X2NwX3N0ZXBfY2IsIHNtLCBOVUxMKTsKKwlvc19mcmVlKHNtLT5sa2kpOworCW9zX2ZyZWUoc20tPm9raSk7CisJb3NfZnJlZShzbS0+Y2lwaGVyX3N1aXRlKTsKKwlvc19mcmVlKHNtLT5jdXJyZW50X2NpcGhlcl9zdWl0ZSk7CisJb3NfZnJlZShzbS0+YXV0aG9yaXphdGlvbl9kYXRhKTsKKwlvc19mcmVlKHNtKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3BfY29ubmVjdF9wZW5kaW5nCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9jcF9jb25uZWN0X3BlbmRpbmcodm9pZCAqY3BfY3R4KQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGNwX2N0eDsKKworCXNtLT5jb25uZWN0ID0gUEVORElORzsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3BfY29ubmVjdF91bmF1dGhlbnRpY2F0ZWQKKyAqLwordm9pZCBpZWVlODAyXzF4X2NwX2Nvbm5lY3RfdW5hdXRoZW50aWNhdGVkKHZvaWQgKmNwX2N0eCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20gPSAoc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKiljcF9jdHg7CisKKwlzbS0+Y29ubmVjdCA9IFVOQVVUSEVOVElDQVRFRDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3BfY29ubmVjdF9hdXRoZW50aWNhdGVkCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9jcF9jb25uZWN0X2F1dGhlbnRpY2F0ZWQodm9pZCAqY3BfY3R4KQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGNwX2N0eDsKKworCXNtLT5jb25uZWN0ID0gQVVUSEVOVElDQVRFRDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3BfY29ubmVjdF9zZWN1cmUKKyAqLwordm9pZCBpZWVlODAyXzF4X2NwX2Nvbm5lY3Rfc2VjdXJlKHZvaWQgKmNwX2N0eCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20gPSBjcF9jdHg7CisKKwlzbS0+Y29ubmVjdCA9IFNFQ1VSRTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc2V0X2NoZ2RzZXJ2ZXIgLQorICovCit2b2lkIGllZWU4MDJfMXhfY3Bfc2lnbmFsX2NoZ2RzZXJ2ZXIodm9pZCAqY3BfY3R4KQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGNwX2N0eDsKKworCXNtLT5jaGdkX3NlcnZlciA9IFRSVUU7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2NwX3NldF9lbGVjdGVkc2VsZiAtCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9jcF9zZXRfZWxlY3RlZHNlbGYodm9pZCAqY3BfY3R4LCBCb29sZWFuIHN0YXR1cykKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20gPSBjcF9jdHg7CisJc20tPmVsZWN0ZWRfc2VsZiA9IHN0YXR1czsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc2V0X2F1dGhvcml6YXRpb25kYXRhIC0KKyAqLwordm9pZCBpZWVlODAyXzF4X2NwX3NldF9hdXRob3JpemF0aW9uZGF0YSh2b2lkICpjcF9jdHgsIHU4ICpwZGF0YSwgaW50IGxlbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20gPSBjcF9jdHg7CisJb3NfZnJlZShzbS0+YXV0aG9yaXphdGlvbl9kYXRhKTsKKwlzbS0+YXV0aG9yaXphdGlvbl9kYXRhID0gb3NfemFsbG9jKGxlbik7CisJaWYgKHNtLT5hdXRob3JpemF0aW9uX2RhdGEpCisJCW9zX21lbWNweShzbS0+YXV0aG9yaXphdGlvbl9kYXRhLCBwZGF0YSwgbGVuKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc2V0X2NpcGhlcnN1aXRlIC0KKyAqLwordm9pZCBpZWVlODAyXzF4X2NwX3NldF9jaXBoZXJzdWl0ZSh2b2lkICpjcF9jdHgsIHZvaWQgKnBpZCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20gPSBjcF9jdHg7CisJb3NfbWVtY3B5KHNtLT5jaXBoZXJfc3VpdGUsIHBpZCwgQ1NfSURfTEVOKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc2V0X29mZnNldCAtCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9jcF9zZXRfb2Zmc2V0KHZvaWQgKmNwX2N0eCwgZW51bSBjb25maWRlbnRpYWxpdHlfb2Zmc2V0IG9mZnNldCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20gPSBjcF9jdHg7CisJc20tPmNpcGhlcl9vZmZzZXQgPSBvZmZzZXQ7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2NwX3NpZ25hbF9uZXdzYWsgLQorICovCit2b2lkIGllZWU4MDJfMXhfY3Bfc2lnbmFsX25ld3Nhayh2b2lkICpjcF9jdHgpCit7CisJc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKnNtID0gY3BfY3R4OworCXNtLT5uZXdfc2FrID0gVFJVRTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc2V0X2Rpc3RyaWJ1dGVka2kgLQorICovCit2b2lkIGllZWU4MDJfMXhfY3Bfc2V0X2Rpc3RyaWJ1dGVka2kodm9pZCAqY3BfY3R4LAorCQkJCSAgICAgY29uc3Qgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpka2kpCit7CisJc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKnNtID0gY3BfY3R4OworCW9zX21lbWNweSgmc20tPmRpc3RyaWJ1dGVkX2tpLCBka2ksIHNpemVvZihzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffa2kpKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc2V0X2Rpc3RyaWJ1dGVkYW4gLQorICovCit2b2lkIGllZWU4MDJfMXhfY3Bfc2V0X2Rpc3RyaWJ1dGVkYW4odm9pZCAqY3BfY3R4LCB1OCBhbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20gPSBjcF9jdHg7CisJc20tPmRpc3RyaWJ1dGVkX2FuID0gYW47Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2NwX3NldF91c2luZ3JlY2VpdmVzYXMgLQorICovCit2b2lkIGllZWU4MDJfMXhfY3Bfc2V0X3VzaW5ncmVjZWl2ZXNhcyh2b2lkICpjcF9jdHgsIEJvb2xlYW4gc3RhdHVzKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGNwX2N0eDsKKwlzbS0+dXNpbmdfcmVjZWl2ZV9zYXMgPSBzdGF0dXM7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2NwX3NldF9hbGxyZWNlaXZpbmcgLQorICovCit2b2lkIGllZWU4MDJfMXhfY3Bfc2V0X2FsbHJlY2VpdmluZyh2b2lkICpjcF9jdHgsIEJvb2xlYW4gc3RhdHVzKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGNwX2N0eDsKKwlzbS0+YWxsX3JlY2VpdmluZyA9IHN0YXR1czsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc2V0X3NlcnZlcnRyYW5zbWl0dGluZyAtCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9jcF9zZXRfc2VydmVydHJhbnNtaXR0aW5nKHZvaWQgKmNwX2N0eCwgQm9vbGVhbiBzdGF0dXMpCit7CisJc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKnNtID0gY3BfY3R4OworCXNtLT5zZXJ2ZXJfdHJhbnNtaXR0aW5nID0gc3RhdHVzOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9jcF9zZXRfdXNpbmd0cmFuc21pdHNhcyAtCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9jcF9zZXRfdXNpbmd0cmFuc21pdGFzKHZvaWQgKmNwX2N0eCwgQm9vbGVhbiBzdGF0dXMpCit7CisJc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKnNtID0gY3BfY3R4OworCXNtLT51c2luZ190cmFuc21pdF9zYSA9IHN0YXR1czsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfY3Bfc21fc3RlcCAtIEFkdmFuY2UgRUFQT0wgc3RhdGUgbWFjaGluZXMKKyAqIEBzbTogRUFQT0wgc3RhdGUgbWFjaGluZQorICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIHRvIGFkdmFuY2UgQ1Agc3RhdGUgbWFjaGluZXMgYWZ0ZXIgYW55IGNoYW5nZQorICogdGhhdCBjb3VsZCBhZmZlY3QgdGhlaXIgc3RhdGUuCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9jcF9zbV9zdGVwKHZvaWQgKmNwX2N0eCkKK3sKKwkvKgorCSAqIFJ1biBpZWVlODAyXzF4X2NwX3N0ZXBfcnVuIGZyb20gYSByZWdpc3RlcmVkIHRpbWVvdXQKKwkgKiB0byBtYWtlIHN1cmUgdGhhdCBvdGhlciBwb3NzaWJsZSB0aW1lb3V0cy9ldmVudHMgYXJlIHByb2Nlc3NlZAorCSAqIGFuZCB0byBhdm9pZCBsb25nIGZ1bmN0aW9uIGNhbGwgY2hhaW5zLgorCSAqLworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGNwX2N0eDsKKwllbG9vcF9jYW5jZWxfdGltZW91dChpZWVlODAyXzF4X2NwX3N0ZXBfY2IsIHNtLCBOVUxMKTsKKwllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDAsIGllZWU4MDJfMXhfY3Bfc3RlcF9jYiwgc20sIE5VTEwpOworfQorCisKK3N0YXRpYyB2b2lkIGllZWU4MDJfMXhfY3BfcmV0aXJlX3doZW5fdGltZW91dCh2b2lkICplbG9vcF9jdHgsCisJCQkJCSAgICAgIHZvaWQgKnRpbWVvdXRfY3R4KQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGVsb29wX2N0eDsKKwlzbS0+cmV0aXJlX3doZW4gPSAwOworCWllZWU4MDJfMXhfY3Bfc3RlcF9ydW4oc20pOworfQorCisKK3N0YXRpYyB2b2lkCitpZWVlODAyXzF4X2NwX3RyYW5zbWl0X3doZW5fdGltZW91dCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICpzbSA9IGVsb29wX2N0eDsKKwlzbS0+dHJhbnNtaXRfd2hlbiA9IDA7CisJaWVlZTgwMl8xeF9jcF9zdGVwX3J1bihzbSk7Cit9CmRpZmYgLS1naXQgYS9zcmMvcGFlL2llZWU4MDJfMXhfY3AuaCBiL3NyYy9wYWUvaWVlZTgwMl8xeF9jcC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc3M2M5MzAKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvcGFlL2llZWU4MDJfMXhfY3AuaApAQCAtMCwwICsxLDUwIEBACisvKgorICogSUVFRSBTdGQgODAyLjFYLTIwMTAgQ29udHJvbGxlZCBQb3J0IG9mIFBBRSBzdGF0ZSBtYWNoaW5lIC0gQ1Agc3RhdGUgbWFjaGluZQorICogQ29weXJpZ2h0IChjKSAyMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIElFRUU4MDJfMVhfQ1BfSAorI2RlZmluZSBJRUVFODAyXzFYX0NQX0gKKworI2luY2x1ZGUgImNvbW1vbi9kZWZzLmgiCisjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMXhfZGVmcy5oIgorCitzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbTsKK3N0cnVjdCBpZWVlODAyXzF4X2theTsKK3N0cnVjdCBpZWVlODAyXzF4X21rYV9raTsKKworc3RydWN0IGllZWU4MDJfMXhfY3BfY29uZiB7CisJQm9vbGVhbiBwcm90ZWN0OworCUJvb2xlYW4gcmVwbGF5X3Byb3RlY3Q7CisJZW51bSB2YWxpZGF0ZV9mcmFtZXMgdmFsaWRhdGU7CisJdTMyIHJlcGxheV93aW5kb3c7Cit9OworCisKK3N0cnVjdCBpZWVlODAyXzF4X2NwX3NtICoKK2llZWU4MDJfMXhfY3Bfc21faW5pdChzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJICAgICAgc3RydWN0IGllZWU4MDJfMXhfY3BfY29uZiAqcGNwX2NvbmYpOwordm9pZCBpZWVlODAyXzF4X2NwX3NtX2RlaW5pdChzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9zbSAqc20pOwordm9pZCBpZWVlODAyXzF4X2NwX3NtX3N0ZXAodm9pZCAqY3BfY3R4KTsKK3ZvaWQgaWVlZTgwMl8xeF9jcF9jb25uZWN0X3BlbmRpbmcodm9pZCAqY3BfY3R4KTsKK3ZvaWQgaWVlZTgwMl8xeF9jcF9jb25uZWN0X3VuYXV0aGVudGljYXRlZCh2b2lkICpjcF9jdHgpOwordm9pZCBpZWVlODAyXzF4X2NwX2Nvbm5lY3RfYXV0aGVudGljYXRlZCh2b2lkICpjcF9jdHgpOwordm9pZCBpZWVlODAyXzF4X2NwX2Nvbm5lY3Rfc2VjdXJlKHZvaWQgKmNwX2N0eCk7Cit2b2lkIGllZWU4MDJfMXhfY3Bfc2lnbmFsX2NoZ2RzZXJ2ZXIodm9pZCAqY3BfY3R4KTsKK3ZvaWQgaWVlZTgwMl8xeF9jcF9zZXRfZWxlY3RlZHNlbGYodm9pZCAqY3BfY3R4LCBCb29sZWFuIHN0YXR1cyk7Cit2b2lkIGllZWU4MDJfMXhfY3Bfc2V0X2F1dGhvcml6YXRpb25kYXRhKHZvaWQgKmNwX2N0eCwgdTggKnBkYXRhLCBpbnQgbGVuKTsKK3ZvaWQgaWVlZTgwMl8xeF9jcF9zZXRfY2lwaGVyc3VpdGUodm9pZCAqY3BfY3R4LCB2b2lkICpwaWQpOwordm9pZCBpZWVlODAyXzF4X2NwX3NldF9vZmZzZXQodm9pZCAqY3BfY3R4LCBlbnVtIGNvbmZpZGVudGlhbGl0eV9vZmZzZXQgb2Zmc2V0KTsKK3ZvaWQgaWVlZTgwMl8xeF9jcF9zaWduYWxfbmV3c2FrKHZvaWQgKmNwX2N0eCk7Cit2b2lkIGllZWU4MDJfMXhfY3Bfc2V0X2Rpc3RyaWJ1dGVka2kodm9pZCAqY3BfY3R4LAorCQkJCSAgICAgY29uc3Qgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpka2kpOwordm9pZCBpZWVlODAyXzF4X2NwX3NldF9kaXN0cmlidXRlZGFuKHZvaWQgKmNwX2N0eCwgdTggYW4pOwordm9pZCBpZWVlODAyXzF4X2NwX3NldF91c2luZ3JlY2VpdmVzYXModm9pZCAqY3BfY3R4LCBCb29sZWFuIHN0YXR1cyk7Cit2b2lkIGllZWU4MDJfMXhfY3Bfc2V0X2FsbHJlY2VpdmluZyh2b2lkICpjcF9jdHgsIEJvb2xlYW4gc3RhdHVzKTsKK3ZvaWQgaWVlZTgwMl8xeF9jcF9zZXRfc2VydmVydHJhbnNtaXR0aW5nKHZvaWQgKmNwX2N0eCwgQm9vbGVhbiBzdGF0dXMpOwordm9pZCBpZWVlODAyXzF4X2NwX3NldF91c2luZ3RyYW5zbWl0YXModm9pZCAqY3BfY3R4LCBCb29sZWFuIHN0YXR1cyk7CisKKyNlbmRpZiAvKiBJRUVFODAyXzFYX0NQX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9wYWUvaWVlZTgwMl8xeF9rYXkuYyBiL3NyYy9wYWUvaWVlZTgwMl8xeF9rYXkuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NmMxOTVhCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3BhZS9pZWVlODAyXzF4X2theS5jCkBAIC0wLDAgKzEsMzUyNyBAQAorLyoKKyAqIElFRUUgODAyLjFYLTIwMTAgS2V5IEFncmVlIFByb3RvY29sIG9mIFBBRSBzdGF0ZSBtYWNoaW5lCisgKiBDb3B5cmlnaHQgKGMpIDIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDx0aW1lLmg+CisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJsaXN0LmgiCisjaW5jbHVkZSAiZWxvb3AuaCIKKyNpbmNsdWRlICJ3cGFidWYuaCIKKyNpbmNsdWRlICJzdGF0ZV9tYWNoaW5lLmgiCisjaW5jbHVkZSAibDJfcGFja2V0L2wyX3BhY2tldC5oIgorI2luY2x1ZGUgImNvbW1vbi9lYXBvbF9jb21tb24uaCIKKyNpbmNsdWRlICJjcnlwdG8vYWVzX3dyYXAuaCIKKyNpbmNsdWRlICJpZWVlODAyXzF4X2NwLmgiCisjaW5jbHVkZSAiaWVlZTgwMl8xeF9rZXkuaCIKKyNpbmNsdWRlICJpZWVlODAyXzF4X2theS5oIgorI2luY2x1ZGUgImllZWU4MDJfMXhfa2F5X2kuaCIKKyNpbmNsdWRlICJpZWVlODAyXzF4X3NlY3lfb3BzLmgiCisKKworI2RlZmluZSBERUZBVUxUX1NBX0tFWV9MRU4JMTYKKyNkZWZpbmUgREVGQVVMVF9JQ1ZfTEVOCQkxNgorI2RlZmluZSBNQVhfSUNWX0xFTgkJMzIgIC8qIDMyIGJ5dGVzLCAyNTYgYml0cyAqLworCisjZGVmaW5lIFBFTkRJTkdfUE5fRVhIQVVTVElPTiAweEMwMDAwMDAwCisKKy8qIElFRUUgU3RkIDgwMi4xWC0yMDEwLCBUYWJsZSA5LTEgLSBNS0EgQWxnb3JpdGhtIEFnaWxpdHkgKi8KKyNkZWZpbmUgTUtBX0FMR09fQUdJTElUWV8yMDA5IHsgMHgwMCwgMHg4MCwgMHhDMiwgMHgwMSB9CitzdGF0aWMgdTggbWthX2FsZ29fYWdpbGl0eVs0XSA9IE1LQV9BTEdPX0FHSUxJVFlfMjAwOTsKKworLyogSUVFRTgwMi4xQUUtMjAwNiBUYWJsZSAxNC0xIE1BQ3NlYyBDaXBoZXIgU3VpdGVzICovCitzdGF0aWMgc3RydWN0IG1hY3NlY19jaXBoZXJzdWl0ZSBjaXBoZXJfc3VpdGVfdGJsW10gPSB7CisJLyogR0NNLUFFUy0xMjggKi8KKwl7CisJCUNTX0lEX0dDTV9BRVNfMTI4LAorCQlDU19OQU1FX0dDTV9BRVNfMTI4LAorCQlNQUNTRUNfQ0FQX0lOVEVHX0FORF9DT05GXzBfMzBfNTAsCisJCTE2LAorCisJCTAgLyogaW5kZXggKi8KKwl9LAorfTsKKyNkZWZpbmUgQ1NfVEFCTEVfU0laRSAoQVJSQVlfU0laRShjaXBoZXJfc3VpdGVfdGJsKSkKKyNkZWZpbmUgREVGQVVMVF9DU19JTkRFWCAgMAorCitzdGF0aWMgc3RydWN0IG1rYV9hbGcgbWthX2FsZ190YmxbXSA9IHsKKwl7CisJCU1LQV9BTEdPX0FHSUxJVFlfMjAwOSwKKwkJLyogMTI4LWJpdCBDQUssIEtFSywgSUNLLCBJQ1YgKi8KKwkJMTYsIDE2LAkxNiwgMTYsCisJCWllZWU4MDJfMXhfY2FrXzEyOGJpdHNfYWVzX2NtYWMsCisJCWllZWU4MDJfMXhfY2tuXzEyOGJpdHNfYWVzX2NtYWMsCisJCWllZWU4MDJfMXhfa2VrXzEyOGJpdHNfYWVzX2NtYWMsCisJCWllZWU4MDJfMXhfaWNrXzEyOGJpdHNfYWVzX2NtYWMsCisJCWllZWU4MDJfMXhfaWN2XzEyOGJpdHNfYWVzX2NtYWMsCisKKwkJMSwgLyogaW5kZXggKi8KKwl9LAorfTsKKyNkZWZpbmUgTUtBX0FMR19UQUJMRV9TSVpFIChBUlJBWV9TSVpFKG1rYV9hbGdfdGJsKSkKKworCitzdGF0aWMgaW50IGlzX2tpX2VxdWFsKHN0cnVjdCBpZWVlODAyXzF4X21rYV9raSAqa2kxLAorCQkgICAgICAgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpraTIpCit7CisJcmV0dXJuIG9zX21lbWNtcChraTEtPm1pLCBraTItPm1pLCBNSV9MRU4pID09IDAgJiYKKwkJa2kxLT5rbiA9PSBraTItPmtuOworfQorCisKK3N0cnVjdCBta2FfcGFyYW1fYm9keV9oYW5kbGVyIHsKKwlpbnQgKCpib2R5X3R4KShzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCQkgICAgICAgc3RydWN0IHdwYWJ1ZiAqYnVmKTsKKwlpbnQgKCpib2R5X3J4KShzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCQkgICAgICAgY29uc3QgdTggKm1rYV9tc2csIHNpemVfdCBtc2dfbGVuKTsKKwlpbnQgKCpib2R5X2xlbmd0aCkoc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCk7CisJQm9vbGVhbiAoKmJvZHlfcHJlc2VudCkoc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCk7Cit9OworCisKK3N0YXRpYyB2b2lkIHNldF9ta2FfcGFyYW1fYm9keV9sZW4odm9pZCAqYm9keSwgdW5zaWduZWQgaW50IGxlbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICpoZHIgPSBib2R5OworCWhkci0+bGVuZ3RoID0gKGxlbiA+PiA4KSAmIDB4MGY7CisJaGRyLT5sZW5ndGgxID0gbGVuICYgMHhmZjsKK30KKworCitzdGF0aWMgdW5zaWduZWQgaW50IGdldF9ta2FfcGFyYW1fYm9keV9sZW4oY29uc3Qgdm9pZCAqYm9keSkKK3sKKwljb25zdCBzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICpoZHIgPSBib2R5OworCXJldHVybiAoaGRyLT5sZW5ndGggPDwgOCkgfCBoZHItPmxlbmd0aDE7Cit9CisKKworc3RhdGljIGludCBnZXRfbWthX3BhcmFtX2JvZHlfdHlwZShjb25zdCB2b2lkICpib2R5KQoreworCWNvbnN0IHN0cnVjdCBpZWVlODAyXzF4X21rYV9oZHIgKmhkciA9IGJvZHk7CisJcmV0dXJuIGhkci0+dHlwZTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2R1bXBfYmFzaWNfYm9keSAtCisgKi8KK3N0YXRpYyB2b2lkCitpZWVlODAyXzF4X21rYV9kdW1wX2Jhc2ljX2JvZHkoc3RydWN0IGllZWU4MDJfMXhfbWthX2Jhc2ljX2JvZHkgKmJvZHkpCit7CisJc2l6ZV90IGJvZHlfbGVuOworCisJaWYgKCFib2R5KQorCQlyZXR1cm47CisKKwlib2R5X2xlbiA9IGdldF9ta2FfcGFyYW1fYm9keV9sZW4oYm9keSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIqKiogTUtBIEJhc2ljIFBhcmFtZXRlciBzZXQgKioqIik7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdFZlcnNpb24uLi4uLi4uOiAlZCIsIGJvZHktPnZlcnNpb24pOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRQcmlvcml0eS4uLi4uLjogJWQiLCBib2R5LT5wcmlvcml0eSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdEtleVN2ci4uLi4uLi4uOiAlZCIsIGJvZHktPmtleV9zZXJ2ZXIpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRNQUNTZWNEZXNpcmVkLjogJWQiLCBib2R5LT5tYWNzZWNfZGVzaXJlZCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE1BQ1NlY0NhcGFibGUuOiAlZCIsIGJvZHktPm1hY3NlY19jYXBiaWxpdHkpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRCb2R5IExlbmd0aC4uLjogJWQiLCAoaW50KSBib2R5X2xlbik7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdFNDSSBNQUMuLi4uLi4uOiAiIE1BQ1NUUiwKKwkJICAgTUFDMlNUUihib2R5LT5hY3Rvcl9zY2kuYWRkcikpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRTQ0kgUG9ydCAuLi4uLjogJWQiLAorCQkgICBiZV90b19ob3N0MTYoYm9keS0+YWN0b3Jfc2NpLnBvcnQpKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJcdE1lbWJlciBJZC4uLi4uOiIsCisJCSAgICBib2R5LT5hY3Rvcl9taSwgc2l6ZW9mKGJvZHktPmFjdG9yX21pKSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE1lc3NhZ2UgTnVtYmVyOiAlZCIsCisJCSAgIGJlX3RvX2hvc3QzMihib2R5LT5hY3Rvcl9tbikpOworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlx0QWxnbyBBZ2lsaXR5Li46IiwKKwkJICAgIGJvZHktPmFsZ29fYWdpbGl0eSwgc2l6ZW9mKGJvZHktPmFsZ29fYWdpbGl0eSkpOworCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIlx0Q0FLIE5hbWUuLi4uLi46IiwgYm9keS0+Y2tuLAorCQkJICBib2R5X2xlbiArIE1LQV9IRFJfTEVOIC0gc2l6ZW9mKCpib2R5KSk7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9kdW1wX3BlZXJfYm9keSAtCisgKi8KK3N0YXRpYyB2b2lkCitpZWVlODAyXzF4X21rYV9kdW1wX3BlZXJfYm9keShzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGVlcl9ib2R5ICpib2R5KQoreworCXNpemVfdCBib2R5X2xlbjsKKwlzaXplX3QgaTsKKwl1OCAqbWk7CisJdTMyIG1uOworCisJaWYgKGJvZHkgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJYm9keV9sZW4gPSBnZXRfbWthX3BhcmFtX2JvZHlfbGVuKGJvZHkpOworCWlmIChib2R5LT50eXBlID09IE1LQV9MSVZFX1BFRVJfTElTVCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIioqKiBMaXZlIFBlZXIgTGlzdCAqKioiKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdEJvZHkgTGVuZ3RoLi4uOiAlZCIsIChpbnQpIGJvZHlfbGVuKTsKKwl9IGVsc2UgaWYgKGJvZHktPnR5cGUgPT0gTUtBX1BPVEVOVElBTF9QRUVSX0xJU1QpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIqKiogUG90ZW50aWFsIExpdmUgUGVlciBMaXN0ICoqKiIpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlx0Qm9keSBMZW5ndGguLi46ICVkIiwgKGludCkgYm9keV9sZW4pOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBib2R5X2xlbjsgaSArPSBNSV9MRU4gKyBzaXplb2YobW4pKSB7CisJCW1pID0gYm9keS0+cGVlciArIGk7CisJCW9zX21lbWNweSgmbW4sIG1pICsgTUlfTEVOLCBzaXplb2YobW4pKTsKKwkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiXHRNZW1iZXIgSWQuLi4uLjoiLCBtaSwgTUlfTEVOKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE1lc3NhZ2UgTnVtYmVyOiAlZCIsIGJlX3RvX2hvc3QzMihtbikpOworCX0KK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2R1bXBfZGlzdF9zYWtfYm9keSAtCisgKi8KK3N0YXRpYyB2b2lkCitpZWVlODAyXzF4X21rYV9kdW1wX2Rpc3Rfc2FrX2JvZHkoc3RydWN0IGllZWU4MDJfMXhfbWthX2Rpc3Rfc2FrX2JvZHkgKmJvZHkpCit7CisJc2l6ZV90IGJvZHlfbGVuOworCisJaWYgKGJvZHkgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJYm9keV9sZW4gPSBnZXRfbWthX3BhcmFtX2JvZHlfbGVuKGJvZHkpOworCXdwYV9wcmludGYoTVNHX0lORk8sICIqKiogRGlzdHJpYnV0ZWQgU0FLICoqKiIpOworCXdwYV9wcmludGYoTVNHX0lORk8sICJcdERpc3RyaWJ1dGVkIEFOLi4uLi4uLi46ICVkIiwgYm9keS0+ZGFuKTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiXHRDb25maWRlbnRpYWxpdHkgT2Zmc2V0OiAlZCIsCisJCSAgIGJvZHktPmNvbmZpZF9vZmZzZXQpOworCXdwYV9wcmludGYoTVNHX0lORk8sICJcdEJvZHkgTGVuZ3RoLi4uLi4uLi4uLi46ICVkIiwgKGludCkgYm9keV9sZW4pOworCWlmICghYm9keV9sZW4pCisJCXJldHVybjsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJcdEtleSBOdW1iZXIuLi4uLi4uLi4uLi46ICVkIiwKKwkJICAgYmVfdG9faG9zdDMyKGJvZHktPmtuKSk7CisJd3BhX2hleGR1bXAoTVNHX0lORk8sICJcdEFFUyBLZXkgV3JhcCBvZiBTQUsuLi46IiwgYm9keS0+c2FrLCAyNCk7Cit9CisKKworc3RhdGljIGNvbnN0IGNoYXIgKiB5ZXNfbm8oaW50IHZhbCkKK3sKKwlyZXR1cm4gdmFsID8gIlllcyIgOiAiTm8iOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfZHVtcF9zYWtfdXNlX2JvZHkgLQorICovCitzdGF0aWMgdm9pZAoraWVlZTgwMl8xeF9ta2FfZHVtcF9zYWtfdXNlX2JvZHkoc3RydWN0IGllZWU4MDJfMXhfbWthX3Nha191c2VfYm9keSAqYm9keSkKK3sKKwlpbnQgYm9keV9sZW47CisKKwlpZiAoYm9keSA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlib2R5X2xlbiA9IGdldF9ta2FfcGFyYW1fYm9keV9sZW4oYm9keSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIqKiogTUFDc2VjIFNBSyBVc2UgKioqIik7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdExhdGVzdCBLZXkgQU4uLi4uOiAlZCIsIGJvZHktPmxhbik7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdExhdGVzdCBLZXkgVHguLi4uOiAlcyIsIHllc19ubyhib2R5LT5sdHgpKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlx0TGF0ZXN0IEtleSBSeC4uLi46ICVzIiwgeWVzX25vKGJvZHktPmxyeCkpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRPbGQgS2V5IEFOLi4uLjogJWQiLCBib2R5LT5vYW4pOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRPbGQgS2V5IFR4Li4uLjogJXMiLCB5ZXNfbm8oYm9keS0+b3R4KSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE9sZCBLZXkgUnguLi4uOiAlcyIsIHllc19ubyhib2R5LT5vcngpKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlx0UGxhaW4gS2V5IFR4Li4uLjogJXMiLCB5ZXNfbm8oYm9keS0+cHR4KSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdFBsYWluIEtleSBSeC4uLi46ICVzIiwgeWVzX25vKGJvZHktPnByeCkpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHREZWxheSBQcm90ZWN0Li4uLjogJXMiLAorCQkgICB5ZXNfbm8oYm9keS0+ZGVsYXlfcHJvdGVjdCkpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRCb2R5IExlbmd0aC4uLi4uLjogJWQiLCBib2R5X2xlbik7CisJaWYgKCFib2R5X2xlbikKKwkJcmV0dXJuOworCisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiXHRLZXkgU2VydmVyIE1JLi4uLjoiLAorCQkgICAgYm9keS0+bHNydl9taSwgc2l6ZW9mKGJvZHktPmxzcnZfbWkpKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlx0S2V5IE51bWJlci4uLi4uLi46ICV1IiwKKwkJICAgYmVfdG9faG9zdDMyKGJvZHktPmxrbikpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRMb3dlc3QgUE4uLi4uLi4uLjogJXUiLAorCQkgICBiZV90b19ob3N0MzIoYm9keS0+bGxwbikpOworCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIlx0T2xkIEtleSBTZXJ2ZXIgTUkuLi4uOiIsCisJCQkgIGJvZHktPm9zcnZfbWksIHNpemVvZihib2R5LT5vc3J2X21pKSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE9sZCBLZXkgTnVtYmVyLi4uLi4uLjogJXUiLAorCQkgICBiZV90b19ob3N0MzIoYm9keS0+b2tuKSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE9sZCBMb3dlc3QgUE4uLi4uLi4uLjogJXUiLAorCQkgICBiZV90b19ob3N0MzIoYm9keS0+b2xwbikpOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfZ2V0X3BhcnRpY2lwYW50IC0KKyAqLworc3RhdGljIHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqCitpZWVlODAyXzF4X2theV9nZXRfcGFydGljaXBhbnQoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIGNvbnN0IHU4ICpja24pCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudDsKKworCWRsX2xpc3RfZm9yX2VhY2gocGFydGljaXBhbnQsICZrYXktPnBhcnRpY2lwYW50X2xpc3QsCisJCQkgc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50LCBsaXN0KSB7CisJCWlmIChvc19tZW1jbXAocGFydGljaXBhbnQtPmNrbi5uYW1lLCBja24sCisJCQkgICAgICBwYXJ0aWNpcGFudC0+Y2tuLmxlbikgPT0gMCkKKwkJCXJldHVybiBwYXJ0aWNpcGFudDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkthWTogcGFydGljaXBhbnQgaXMgbm90IGZvdW5kIik7CisKKwlyZXR1cm4gTlVMTDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2dldF9wcmluY2lwYWxfcGFydGljaXBhbnQgLQorICovCitzdGF0aWMgc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICoKK2llZWU4MDJfMXhfa2F5X2dldF9wcmluY2lwYWxfcGFydGljaXBhbnQoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXkpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudDsKKworCWRsX2xpc3RfZm9yX2VhY2gocGFydGljaXBhbnQsICZrYXktPnBhcnRpY2lwYW50X2xpc3QsCisJCQkgc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50LCBsaXN0KSB7CisJCWlmIChwYXJ0aWNpcGFudC0+cHJpbmNpcGFsKQorCQkJcmV0dXJuIHBhcnRpY2lwYW50OworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiS2FZOiBwcmluY2lwYWwgcGFydGljaXBhbnQgaXMgbm90IGZvdW5kZWQiKTsKKwlyZXR1cm4gTlVMTDsKK30KKworCitzdGF0aWMgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKiBnZXRfcGVlcl9taShzdHJ1Y3QgZGxfbGlzdCAqcGVlcnMsCisJCQkJCQljb25zdCB1OCAqbWkpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKnBlZXI7CisKKwlkbF9saXN0X2Zvcl9lYWNoKHBlZXIsIHBlZXJzLCBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCkgeworCQlpZiAob3NfbWVtY21wKHBlZXItPm1pLCBtaSwgTUlfTEVOKSA9PSAwKQorCQkJcmV0dXJuIHBlZXI7CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9pc19pbl9wb3RlbnRpYWxfcGVlcgorICovCitzdGF0aWMgQm9vbGVhbgoraWVlZTgwMl8xeF9rYXlfaXNfaW5fcG90ZW50aWFsX3BlZXIoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCwgY29uc3QgdTggKm1pKQoreworCXJldHVybiBnZXRfcGVlcl9taSgmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycywgbWkpICE9IE5VTEw7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9pc19pbl9saXZlX3BlZXIKKyAqLworc3RhdGljIEJvb2xlYW4KK2llZWU4MDJfMXhfa2F5X2lzX2luX2xpdmVfcGVlcigKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LCBjb25zdCB1OCAqbWkpCit7CisJcmV0dXJuIGdldF9wZWVyX21pKCZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywgbWkpICE9IE5VTEw7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9pc19pbl9wZWVyCisgKi8KK3N0YXRpYyBCb29sZWFuCitpZWVlODAyXzF4X2theV9pc19pbl9wZWVyKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJCQkgIGNvbnN0IHU4ICptaSkKK3sKKwlyZXR1cm4gaWVlZTgwMl8xeF9rYXlfaXNfaW5fbGl2ZV9wZWVyKHBhcnRpY2lwYW50LCBtaSkgfHwKKwkJaWVlZTgwMl8xeF9rYXlfaXNfaW5fcG90ZW50aWFsX3BlZXIocGFydGljaXBhbnQsIG1pKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2dldF9wZWVyCisgKi8KK3N0YXRpYyBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciAqCitpZWVlODAyXzF4X2theV9nZXRfcGVlcihzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCQkJY29uc3QgdTggKm1pKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCisJcGVlciA9IGdldF9wZWVyX21pKCZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywgbWkpOworCWlmIChwZWVyKQorCQlyZXR1cm4gcGVlcjsKKworCXJldHVybiBnZXRfcGVlcl9taSgmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycywgbWkpOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfZ2V0X2xpdmVfcGVlcgorICovCitzdGF0aWMgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKgoraWVlZTgwMl8xeF9rYXlfZ2V0X2xpdmVfcGVlcihzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCQkJICAgICBjb25zdCB1OCAqbWkpCit7CisJcmV0dXJuIGdldF9wZWVyX21pKCZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywgbWkpOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfZ2V0X2NpcGhlcl9zdWl0ZQorICovCitzdGF0aWMgc3RydWN0IG1hY3NlY19jaXBoZXJzdWl0ZSAqCitpZWVlODAyXzF4X2theV9nZXRfY2lwaGVyX3N1aXRlKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJCQkJdTggKmNzX2lkKQoreworCXVuc2lnbmVkIGludCBpOworCisJZm9yIChpID0gMDsgaSA8IENTX1RBQkxFX1NJWkU7IGkrKykgeworCQlpZiAob3NfbWVtY21wKGNpcGhlcl9zdWl0ZV90YmxbaV0uaWQsIGNzX2lkLCBDU19JRF9MRU4pID09IDApCisJCQlicmVhazsKKwl9CisJaWYgKGkgPj0gQ1NfVEFCTEVfU0laRSkKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXR1cm4gJmNpcGhlcl9zdWl0ZV90YmxbaV07Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9nZXRfcGVlcl9zY2kKKyAqLworc3RhdGljIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICoKK2llZWU4MDJfMXhfa2F5X2dldF9wZWVyX3NjaShzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCQkJICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyXzF4X21rYV9zY2kgKnNjaSkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciAqcGVlcjsKKworCWRsX2xpc3RfZm9yX2VhY2gocGVlciwgJnBhcnRpY2lwYW50LT5saXZlX3BlZXJzLAorCQkJIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyLCBsaXN0KSB7CisJCWlmIChvc19tZW1jbXAoJnBlZXItPnNjaSwgc2NpLCBzaXplb2YocGVlci0+c2NpKSkgPT0gMCkKKwkJCXJldHVybiBwZWVyOworCX0KKworCWRsX2xpc3RfZm9yX2VhY2gocGVlciwgJnBhcnRpY2lwYW50LT5wb3RlbnRpYWxfcGVlcnMsCisJCQkgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIsIGxpc3QpIHsKKwkJaWYgKG9zX21lbWNtcCgmcGVlci0+c2NpLCBzY2ksIHNpemVvZihwZWVyLT5zY2kpKSA9PSAwKQorCQkJcmV0dXJuIHBlZXI7CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9pbml0X3JlY2VpdmVfc2EgLQorICovCitzdGF0aWMgc3RydWN0IHJlY2VpdmVfc2EgKgoraWVlZTgwMl8xeF9rYXlfaW5pdF9yZWNlaXZlX3NhKHN0cnVjdCByZWNlaXZlX3NjICpwc2MsIHU4IGFuLCB1MzIgbG93ZXN0X3BuLAorCQkJICAgICAgIHN0cnVjdCBkYXRhX2tleSAqa2V5KQoreworCXN0cnVjdCByZWNlaXZlX3NhICpwc2E7CisKKwlpZiAoIXBzYyB8fCAha2V5KQorCQlyZXR1cm4gTlVMTDsKKworCXBzYSA9IG9zX3phbGxvYyhzaXplb2YoKnBzYSkpOworCWlmICghcHNhKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBOVUxMOworCX0KKworCXBzYS0+cGtleSA9IGtleTsKKwlwc2EtPmxvd2VzdF9wbiA9IGxvd2VzdF9wbjsKKwlwc2EtPm5leHRfcG4gPSBsb3dlc3RfcG47CisJcHNhLT5hbiA9IGFuOworCXBzYS0+c2MgPSBwc2M7CisKKwlvc19nZXRfdGltZSgmcHNhLT5jcmVhdGVkX3RpbWUpOworCXBzYS0+aW5fdXNlID0gRkFMU0U7CisKKwlkbF9saXN0X2FkZCgmcHNjLT5zYV9saXN0LCAmcHNhLT5saXN0KTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIkthWTogQ3JlYXRlIHJlY2VpdmUgU0EoQU46ICVkIGxvd2VzdF9wbjogJXUgb2YgU0MoY2hhbm5lbDogJWQpIiwKKwkJICAgKGludCkgYW4sIGxvd2VzdF9wbiwgcHNjLT5jaGFubmVsKTsKKworCXJldHVybiBwc2E7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9kZWluaXRfcmVjZWl2ZV9zYSAtCisgKi8KK3N0YXRpYyB2b2lkIGllZWU4MDJfMXhfa2F5X2RlaW5pdF9yZWNlaXZlX3NhKHN0cnVjdCByZWNlaXZlX3NhICpwc2EpCit7CisJcHNhLT5wa2V5ID0gTlVMTDsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIkthWTogRGVsZXRlIHJlY2VpdmUgU0EoYW46ICVkKSBvZiBTQyhjaGFubmVsOiAlZCkiLAorCQkgICBwc2EtPmFuLCBwc2EtPnNjLT5jaGFubmVsKTsKKwlkbF9saXN0X2RlbCgmcHNhLT5saXN0KTsKKwlvc19mcmVlKHBzYSk7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9pbml0X3JlY2VpdmVfc2MgLQorICovCitzdGF0aWMgc3RydWN0IHJlY2VpdmVfc2MgKgoraWVlZTgwMl8xeF9rYXlfaW5pdF9yZWNlaXZlX3NjKGNvbnN0IHN0cnVjdCBpZWVlODAyXzF4X21rYV9zY2kgKnBzY2ksCisJCQkgICAgICAgaW50IGNoYW5uZWwpCit7CisJc3RydWN0IHJlY2VpdmVfc2MgKnBzYzsKKworCWlmICghcHNjaSkKKwkJcmV0dXJuIE5VTEw7CisKKwlwc2MgPSBvc196YWxsb2Moc2l6ZW9mKCpwc2MpKTsKKwlpZiAoIXBzYykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzOiBvdXQgb2YgbWVtb3J5IiwgX19mdW5jX18pOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlvc19tZW1jcHkoJnBzYy0+c2NpLCBwc2NpLCBzaXplb2YocHNjLT5zY2kpKTsKKwlwc2MtPmNoYW5uZWwgPSBjaGFubmVsOworCisJb3NfZ2V0X3RpbWUoJnBzYy0+Y3JlYXRlZF90aW1lKTsKKwlwc2MtPnJlY2VpdmluZyA9IEZBTFNFOworCisJZGxfbGlzdF9pbml0KCZwc2MtPnNhX2xpc3QpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiS2FZOiBDcmVhdGUgcmVjZWl2ZSBTQyhjaGFubmVsOiAlZCkiLCBjaGFubmVsKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJTQ0k6ICIsICh1OCAqKXBzY2ksIHNpemVvZigqcHNjaSkpOworCisJcmV0dXJuIHBzYzsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2RlaW5pdF9yZWNlaXZlX3NjIC0KKyAqKi8KK3N0YXRpYyB2b2lkCitpZWVlODAyXzF4X2theV9kZWluaXRfcmVjZWl2ZV9zYygKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LCBzdHJ1Y3QgcmVjZWl2ZV9zYyAqcHNjKQoreworCXN0cnVjdCByZWNlaXZlX3NhICpwc2EsICpwcmVfc2E7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkthWTogRGVsZXRlIHJlY2VpdmUgU0MoY2hhbm5lbDogJWQpIiwKKwkJICAgcHNjLT5jaGFubmVsKTsKKwlkbF9saXN0X2Zvcl9lYWNoX3NhZmUocHNhLCBwcmVfc2EsICZwc2MtPnNhX2xpc3QsIHN0cnVjdCByZWNlaXZlX3NhLAorCQkJICAgICAgbGlzdCkgIHsKKwkJc2VjeV9kaXNhYmxlX3JlY2VpdmVfc2EocGFydGljaXBhbnQtPmtheSwgcHNhKTsKKwkJaWVlZTgwMl8xeF9rYXlfZGVpbml0X3JlY2VpdmVfc2EocHNhKTsKKwl9CisJZGxfbGlzdF9kZWwoJnBzYy0+bGlzdCk7CisJb3NfZnJlZShwc2MpOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfY3JlYXRlX2xpdmVfcGVlcgorICovCitzdGF0aWMgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKgoraWVlZTgwMl8xeF9rYXlfY3JlYXRlX2xpdmVfcGVlcihzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCQkJCXU4ICptaSwgdTMyIG1uKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCXN0cnVjdCByZWNlaXZlX3NjICpyeHNjOworCXUzMiBzY19jaCA9IDA7CisKKwlwZWVyID0gb3NfemFsbG9jKHNpemVvZigqcGVlcikpOworCWlmIChwZWVyID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVktJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBOVUxMOworCX0KKworCW9zX21lbWNweShwZWVyLT5taSwgbWksIE1JX0xFTik7CisJcGVlci0+bW4gPSBtbjsKKwlwZWVyLT5leHBpcmUgPSB0aW1lKE5VTEwpICsgTUtBX0xJRkVfVElNRSAvIDEwMDA7CisJcGVlci0+c2FrX3VzZWQgPSBGQUxTRTsKKwlvc19tZW1jcHkoJnBlZXItPnNjaSwgJnBhcnRpY2lwYW50LT5jdXJyZW50X3BlZXJfc2NpLAorCQkgIHNpemVvZihwZWVyLT5zY2kpKTsKKwlkbF9saXN0X2FkZCgmcGFydGljaXBhbnQtPmxpdmVfcGVlcnMsICZwZWVyLT5saXN0KTsKKworCXNlY3lfZ2V0X2F2YWlsYWJsZV9yZWNlaXZlX3NjKHBhcnRpY2lwYW50LT5rYXksICZzY19jaCk7CisKKwlyeHNjID0gaWVlZTgwMl8xeF9rYXlfaW5pdF9yZWNlaXZlX3NjKCZwZWVyLT5zY2ksIHNjX2NoKTsKKwlpZiAoIXJ4c2MpCisJCXJldHVybiBOVUxMOworCisJZGxfbGlzdF9hZGQoJnBhcnRpY2lwYW50LT5yeHNjX2xpc3QsICZyeHNjLT5saXN0KTsKKwlzZWN5X2NyZWF0ZV9yZWNlaXZlX3NjKHBhcnRpY2lwYW50LT5rYXksIHJ4c2MpOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJLYVk6IExpdmUgcGVlciBjcmVhdGVkIik7CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiXHRNSTogIiwgcGVlci0+bWksIHNpemVvZihwZWVyLT5taSkpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRNTjogJWQiLCBwZWVyLT5tbik7CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiXHRTQ0kgQWRkcjogIiwgcGVlci0+c2NpLmFkZHIsIEVUSF9BTEVOKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlx0UG9ydDogJWQiLCBwZWVyLT5zY2kucG9ydCk7CisKKwlyZXR1cm4gcGVlcjsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2NyZWF0ZV9wb3RlbnRpYWxfcGVlcgorICovCitzdGF0aWMgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKgoraWVlZTgwMl8xeF9rYXlfY3JlYXRlX3BvdGVudGlhbF9wZWVyKAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsIGNvbnN0IHU4ICptaSwgdTMyIG1uKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCisJcGVlciA9IG9zX3phbGxvYyhzaXplb2YoKnBlZXIpKTsKKwlpZiAocGVlciA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZLSVzOiBvdXQgb2YgbWVtb3J5IiwgX19mdW5jX18pOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlvc19tZW1jcHkocGVlci0+bWksIG1pLCBNSV9MRU4pOworCXBlZXItPm1uID0gbW47CisJcGVlci0+ZXhwaXJlID0gdGltZShOVUxMKSArIE1LQV9MSUZFX1RJTUUgLyAxMDAwOworCXBlZXItPnNha191c2VkID0gRkFMU0U7CisKKwlkbF9saXN0X2FkZCgmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycywgJnBlZXItPmxpc3QpOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJLYVk6IHBvdGVudGlhbCBwZWVyIGNyZWF0ZWQiKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJcdE1JOiAiLCBwZWVyLT5taSwgc2l6ZW9mKHBlZXItPm1pKSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE1OOiAlZCIsIHBlZXItPm1uKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJcdFNDSSBBZGRyOiAiLCBwZWVyLT5zY2kuYWRkciwgRVRIX0FMRU4pOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRQb3J0OiAlZCIsIHBlZXItPnNjaS5wb3J0KTsKKworCXJldHVybiBwZWVyOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfbW92ZV9saXZlX3BlZXIKKyAqLworc3RhdGljIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICoKK2llZWU4MDJfMXhfa2F5X21vdmVfbGl2ZV9wZWVyKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJCQkgICAgICB1OCAqbWksIHUzMiBtbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciAqcGVlcjsKKwlzdHJ1Y3QgcmVjZWl2ZV9zYyAqcnhzYzsKKwl1MzIgc2NfY2ggPSAwOworCisJZGxfbGlzdF9mb3JfZWFjaChwZWVyLCAmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycywKKwkJCSBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCkgeworCQlpZiAob3NfbWVtY21wKHBlZXItPm1pLCBtaSwgTUlfTEVOKSA9PSAwKQorCQkJYnJlYWs7CisJfQorCisJb3NfbWVtY3B5KCZwZWVyLT5zY2ksICZwYXJ0aWNpcGFudC0+Y3VycmVudF9wZWVyX3NjaSwKKwkJICBzaXplb2YocGVlci0+c2NpKSk7CisJcGVlci0+bW4gPSBtbjsKKwlwZWVyLT5leHBpcmUgPSB0aW1lKE5VTEwpICsgTUtBX0xJRkVfVElNRSAvIDEwMDA7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkthWTogbW92ZSBwb3RlbnRpYWwgcGVlciB0byBsaXZlIHBlZXIiKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJcdE1JOiAiLCBwZWVyLT5taSwgc2l6ZW9mKHBlZXItPm1pKSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE1OOiAlZCIsIHBlZXItPm1uKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJcdFNDSSBBZGRyOiAiLCBwZWVyLT5zY2kuYWRkciwgRVRIX0FMRU4pOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiXHRQb3J0OiAlZCIsIHBlZXItPnNjaS5wb3J0KTsKKworCWRsX2xpc3RfZGVsKCZwZWVyLT5saXN0KTsKKwlkbF9saXN0X2FkZF90YWlsKCZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywgJnBlZXItPmxpc3QpOworCisJc2VjeV9nZXRfYXZhaWxhYmxlX3JlY2VpdmVfc2MocGFydGljaXBhbnQtPmtheSwgJnNjX2NoKTsKKworCXJ4c2MgPSBpZWVlODAyXzF4X2theV9pbml0X3JlY2VpdmVfc2MoJnBlZXItPnNjaSwgc2NfY2gpOworCWlmICghcnhzYykKKwkJcmV0dXJuIE5VTEw7CisKKwlkbF9saXN0X2FkZCgmcGFydGljaXBhbnQtPnJ4c2NfbGlzdCwgJnJ4c2MtPmxpc3QpOworCXNlY3lfY3JlYXRlX3JlY2VpdmVfc2MocGFydGljaXBhbnQtPmtheSwgcnhzYyk7CisKKwlyZXR1cm4gcGVlcjsKK30KKworCisKKy8qKgorICogIGllZWU4MDJfMXhfbWthX2Jhc2ljX2JvZHlfcHJlc2VudCAtCisgKi8KK3N0YXRpYyBCb29sZWFuCitpZWVlODAyXzF4X21rYV9iYXNpY19ib2R5X3ByZXNlbnQoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlyZXR1cm4gVFJVRTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2Jhc2ljX2JvZHlfbGVuZ3RoIC0KKyAqLworc3RhdGljIGludAoraWVlZTgwMl8xeF9ta2FfYmFzaWNfYm9keV9sZW5ndGgoc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlpbnQgbGVuZ3RoOworCisJbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X21rYV9iYXNpY19ib2R5KTsKKwlsZW5ndGggKz0gcGFydGljaXBhbnQtPmNrbi5sZW47CisJcmV0dXJuIChsZW5ndGggKyAweDMpICYgfjB4MzsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2VuY29kZV9iYXNpY19ib2R5CisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2VuY29kZV9iYXNpY19ib2R5KAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9iYXNpY19ib2R5ICpib2R5OworCXN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5ID0gcGFydGljaXBhbnQtPmtheTsKKwl1bnNpZ25lZCBpbnQgbGVuZ3RoID0gaWVlZTgwMl8xeF9ta2FfYmFzaWNfYm9keV9sZW5ndGgocGFydGljaXBhbnQpOworCisJYm9keSA9IHdwYWJ1Zl9wdXQoYnVmLCBsZW5ndGgpOworCisJYm9keS0+dmVyc2lvbiA9IGtheS0+bWthX3ZlcnNpb247CisJYm9keS0+cHJpb3JpdHkgPSBrYXktPmFjdG9yX3ByaW9yaXR5OworCWlmIChwYXJ0aWNpcGFudC0+aXNfZWxlY3RlZCkKKwkJYm9keS0+a2V5X3NlcnZlciA9IHBhcnRpY2lwYW50LT5pc19rZXlfc2VydmVyOworCWVsc2UKKwkJYm9keS0+a2V5X3NlcnZlciA9IHBhcnRpY2lwYW50LT5jYW5fYmVfa2V5X3NlcnZlcjsKKworCWJvZHktPm1hY3NlY19kZXNpcmVkID0ga2F5LT5tYWNzZWNfZGVzaXJlZDsKKwlib2R5LT5tYWNzZWNfY2FwYmlsaXR5ID0ga2F5LT5tYWNzZWNfY2FwYWJsZTsKKwlzZXRfbWthX3BhcmFtX2JvZHlfbGVuKGJvZHksIGxlbmd0aCAtIE1LQV9IRFJfTEVOKTsKKworCW9zX21lbWNweShib2R5LT5hY3Rvcl9zY2kuYWRkciwga2F5LT5hY3Rvcl9zY2kuYWRkciwKKwkJICBzaXplb2Yoa2F5LT5hY3Rvcl9zY2kuYWRkcikpOworCWJvZHktPmFjdG9yX3NjaS5wb3J0ID0gaG9zdF90b19iZTE2KGtheS0+YWN0b3Jfc2NpLnBvcnQpOworCisJb3NfbWVtY3B5KGJvZHktPmFjdG9yX21pLCBwYXJ0aWNpcGFudC0+bWksIHNpemVvZihib2R5LT5hY3Rvcl9taSkpOworCXBhcnRpY2lwYW50LT5tbiA9IHBhcnRpY2lwYW50LT5tbiArIDE7CisJYm9keS0+YWN0b3JfbW4gPSBob3N0X3RvX2JlMzIocGFydGljaXBhbnQtPm1uKTsKKwlvc19tZW1jcHkoYm9keS0+YWxnb19hZ2lsaXR5LCBwYXJ0aWNpcGFudC0+a2F5LT5hbGdvX2FnaWxpdHksCisJCSAgc2l6ZW9mKGJvZHktPmFsZ29fYWdpbGl0eSkpOworCisJb3NfbWVtY3B5KGJvZHktPmNrbiwgcGFydGljaXBhbnQtPmNrbi5uYW1lLCBwYXJ0aWNpcGFudC0+Y2tuLmxlbik7CisKKwlpZWVlODAyXzF4X21rYV9kdW1wX2Jhc2ljX2JvZHkoYm9keSk7CisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2RlY29kZV9iYXNpY19ib2R5IC0KKyAqLworc3RhdGljIHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqCitpZWVlODAyXzF4X21rYV9kZWNvZGVfYmFzaWNfYm9keShzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgY29uc3QgdTggKm1rYV9tc2csCisJCQkJIHNpemVfdCBtc2dfbGVuKQoreworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQ7CisJY29uc3Qgc3RydWN0IGllZWU4MDJfMXhfbWthX2Jhc2ljX2JvZHkgKmJvZHk7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKnBlZXI7CisKKwlib2R5ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyXzF4X21rYV9iYXNpY19ib2R5ICopIG1rYV9tc2c7CisKKwlpZiAoYm9keS0+dmVyc2lvbiA+IE1LQV9WRVJTSU9OX0lEKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJICAgIkthWTogcGVlcidzIHZlcnNpb24oJWQpIGdyZWF0ZXIgdGhhbiBta2EgY3VycmVudCB2ZXJzaW9uKCVkKSIsCisJCQkgICBib2R5LT52ZXJzaW9uLCBNS0FfVkVSU0lPTl9JRCk7CisJfQorCWlmIChrYXktPmlzX29ibGlnZWRfa2V5X3NlcnZlciAmJiBib2R5LT5rZXlfc2VydmVyKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSSBtdXN0IGJlIGFzIGtleSBzZXJ2ZXIiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcGFydGljaXBhbnQgPSBpZWVlODAyXzF4X2theV9nZXRfcGFydGljaXBhbnQoa2F5LCBib2R5LT5ja24pOworCWlmICghcGFydGljaXBhbnQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQZWVyIGlzIG5vdCBpbmNsdWRlZCBpbiBteSBDQSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwkvKiBJZiB0aGUgcGVlcidzIE1JIGlzIG15IE1JLCBJIHdpbGwgY2hvb3NlIG5ldyBNSSAqLworCWlmIChvc19tZW1jbXAoYm9keS0+YWN0b3JfbWksIHBhcnRpY2lwYW50LT5taSwgTUlfTEVOKSA9PSAwKSB7CisJCW9zX2dldF9yYW5kb20ocGFydGljaXBhbnQtPm1pLCBzaXplb2YocGFydGljaXBhbnQtPm1pKSk7CisJCXBhcnRpY2lwYW50LT5tbiA9IDA7CisJfQorCisJb3NfbWVtY3B5KHBhcnRpY2lwYW50LT5jdXJyZW50X3BlZXJfaWQubWksIGJvZHktPmFjdG9yX21pLCBNSV9MRU4pOworCXBhcnRpY2lwYW50LT5jdXJyZW50X3BlZXJfaWQubW4gPSAgYmVfdG9faG9zdDMyKGJvZHktPmFjdG9yX21uKTsKKwlvc19tZW1jcHkocGFydGljaXBhbnQtPmN1cnJlbnRfcGVlcl9zY2kuYWRkciwgYm9keS0+YWN0b3Jfc2NpLmFkZHIsCisJCSAgc2l6ZW9mKHBhcnRpY2lwYW50LT5jdXJyZW50X3BlZXJfc2NpLmFkZHIpKTsKKwlwYXJ0aWNpcGFudC0+Y3VycmVudF9wZWVyX3NjaS5wb3J0ID0gYmVfdG9faG9zdDE2KGJvZHktPmFjdG9yX3NjaS5wb3J0KTsKKworCS8qIGhhbmRsZXIgcGVlciAqLworCXBlZXIgPSBpZWVlODAyXzF4X2theV9nZXRfcGVlcihwYXJ0aWNpcGFudCwgYm9keS0+YWN0b3JfbWkpOworCWlmICghcGVlcikgeworCQkvKiBDaGVjayBkdXBsaWNhdGVkIFNDSSAqLworCQkvKiBUT0RPOiBXaGF0IHBvbGljeSBzaG91bGQgYmUgYXBwbGllZCB0byBkZXRlY3QgZHVwbGljYXRlZCBTQ0kKKwkJICogaXMgYWN0aXZlIGF0dGFja2VyIG9yIGEgdmFsaWQgcGVlciB3aG9zZSBNSSBpcyBiZSBjaGFuZ2VkPworCQkgKi8KKwkJcGVlciA9IGllZWU4MDJfMXhfa2F5X2dldF9wZWVyX3NjaShwYXJ0aWNpcGFudCwKKwkJCQkJCSAgICZib2R5LT5hY3Rvcl9zY2kpOworCQlpZiAocGVlcikgeworCQkJd3BhX3ByaW50ZihNU0dfV0FSTklORywKKwkJCQkgICAiS2FZOiBkdXBsaWNhdGVkIFNDSSBkZXRlY3RlZCwgTWF5YmUgYWN0aXZlIGF0dGFja2VyIik7CisJCQlkbF9saXN0X2RlbCgmcGVlci0+bGlzdCk7CisJCQlvc19mcmVlKHBlZXIpOworCQl9CisKKwkJcGVlciA9IGllZWU4MDJfMXhfa2F5X2NyZWF0ZV9wb3RlbnRpYWxfcGVlcigKKwkJCXBhcnRpY2lwYW50LCBib2R5LT5hY3Rvcl9taSwKKwkJCWJlX3RvX2hvc3QzMihib2R5LT5hY3Rvcl9tbikpOworCQlpZiAoIXBlZXIpCisJCQlyZXR1cm4gTlVMTDsKKworCQlwZWVyLT5tYWNzZWNfZGVzaXJlZCA9IGJvZHktPm1hY3NlY19kZXNpcmVkOworCQlwZWVyLT5tYWNzZWNfY2FwYmlsaXR5ID0gYm9keS0+bWFjc2VjX2NhcGJpbGl0eTsKKwkJcGVlci0+aXNfa2V5X3NlcnZlciA9IChCb29sZWFuKSBib2R5LT5rZXlfc2VydmVyOworCQlwZWVyLT5rZXlfc2VydmVyX3ByaW9yaXR5ID0gYm9keS0+cHJpb3JpdHk7CisJfSBlbHNlIGlmIChwZWVyLT5tbiA8IGJlX3RvX2hvc3QzMihib2R5LT5hY3Rvcl9tbikpIHsKKwkJcGVlci0+bW4gPSBiZV90b19ob3N0MzIoYm9keS0+YWN0b3JfbW4pOworCQlwZWVyLT5leHBpcmUgPSB0aW1lKE5VTEwpICsgTUtBX0xJRkVfVElNRSAvIDEwMDA7CisJCXBlZXItPm1hY3NlY19kZXNpcmVkID0gYm9keS0+bWFjc2VjX2Rlc2lyZWQ7CisJCXBlZXItPm1hY3NlY19jYXBiaWxpdHkgPSBib2R5LT5tYWNzZWNfY2FwYmlsaXR5OworCQlwZWVyLT5pc19rZXlfc2VydmVyID0gKEJvb2xlYW4pIGJvZHktPmtleV9zZXJ2ZXI7CisJCXBlZXItPmtleV9zZXJ2ZXJfcHJpb3JpdHkgPSBib2R5LT5wcmlvcml0eTsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiS2FZOiBUaGUgcGVlciBNTiBoYXZlIHJlY2VpdmVkIik7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiBwYXJ0aWNpcGFudDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2xpdmVfcGVlcl9ib2R5X3ByZXNlbnQKKyAqLworc3RhdGljIEJvb2xlYW4KK2llZWU4MDJfMXhfbWthX2xpdmVfcGVlcl9ib2R5X3ByZXNlbnQoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlyZXR1cm4gIWRsX2xpc3RfZW1wdHkoJnBhcnRpY2lwYW50LT5saXZlX3BlZXJzKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2dldF9saXZlX3BlZXJfbGVuZ3RoCisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2dldF9saXZlX3BlZXJfbGVuZ3RoKAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQpCit7CisJaW50IGxlbiA9IE1LQV9IRFJfTEVOOworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCisJZGxfbGlzdF9mb3JfZWFjaChwZWVyLCAmcGFydGljaXBhbnQtPmxpdmVfcGVlcnMsCisJCQkgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIsIGxpc3QpCisJCWxlbiArPSBzaXplb2Yoc3RydWN0IGllZWU4MDJfMXhfbWthX3BlZXJfaWQpOworCisJcmV0dXJuIChsZW4gKyAweDMpICYgfjB4MzsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2VuY29kZV9saXZlX3BlZXJfYm9keSAtCisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2VuY29kZV9saXZlX3BlZXJfYm9keSgKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCXN0cnVjdCB3cGFidWYgKmJ1ZikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGVlcl9ib2R5ICpib2R5OworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCXVuc2lnbmVkIGludCBsZW5ndGg7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BlZXJfaWQgKmJvZHlfcGVlcjsKKworCWxlbmd0aCA9IGllZWU4MDJfMXhfbWthX2dldF9saXZlX3BlZXJfbGVuZ3RoKHBhcnRpY2lwYW50KTsKKwlib2R5ID0gd3BhYnVmX3B1dChidWYsIHNpemVvZihzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGVlcl9ib2R5KSk7CisKKwlib2R5LT50eXBlID0gTUtBX0xJVkVfUEVFUl9MSVNUOworCXNldF9ta2FfcGFyYW1fYm9keV9sZW4oYm9keSwgbGVuZ3RoIC0gTUtBX0hEUl9MRU4pOworCisJZGxfbGlzdF9mb3JfZWFjaChwZWVyLCAmcGFydGljaXBhbnQtPmxpdmVfcGVlcnMsCisJCQkgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIsIGxpc3QpIHsKKwkJYm9keV9wZWVyID0gd3BhYnVmX3B1dChidWYsCisJCQkJICAgICAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGVlcl9pZCkpOworCQlvc19tZW1jcHkoYm9keV9wZWVyLT5taSwgcGVlci0+bWksIE1JX0xFTik7CisJCWJvZHlfcGVlci0+bW4gPSBob3N0X3RvX2JlMzIocGVlci0+bW4pOworCQlib2R5X3BlZXIrKzsKKwl9CisKKwlpZWVlODAyXzF4X21rYV9kdW1wX3BlZXJfYm9keShib2R5KTsKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9wb3RlbnRpYWxfcGVlcl9ib2R5X3ByZXNlbnQKKyAqLworc3RhdGljIEJvb2xlYW4KK2llZWU4MDJfMXhfbWthX3BvdGVudGlhbF9wZWVyX2JvZHlfcHJlc2VudCgKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50KQoreworCXJldHVybiAhZGxfbGlzdF9lbXB0eSgmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycyk7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9nZXRfcG90ZW50aWFsX3BlZXJfbGVuZ3RoCisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2dldF9wb3RlbnRpYWxfcGVlcl9sZW5ndGgoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlpbnQgbGVuID0gTUtBX0hEUl9MRU47CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKnBlZXI7CisKKwlkbF9saXN0X2Zvcl9lYWNoKHBlZXIsICZwYXJ0aWNpcGFudC0+cG90ZW50aWFsX3BlZXJzLAorCQkJIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyLCBsaXN0KQorCQlsZW4gKz0gc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wZWVyX2lkKTsKKworCXJldHVybiAobGVuICsgMHgzKSAmIH4weDM7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9lbmNvZGVfcG90ZW50aWFsX3BlZXJfYm9keSAtCisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2VuY29kZV9wb3RlbnRpYWxfcGVlcl9ib2R5KAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wZWVyX2JvZHkgKmJvZHk7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKnBlZXI7CisJdW5zaWduZWQgaW50IGxlbmd0aDsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGVlcl9pZCAqYm9keV9wZWVyOworCisJbGVuZ3RoID0gaWVlZTgwMl8xeF9ta2FfZ2V0X3BvdGVudGlhbF9wZWVyX2xlbmd0aChwYXJ0aWNpcGFudCk7CisJYm9keSA9IHdwYWJ1Zl9wdXQoYnVmLCBzaXplb2Yoc3RydWN0IGllZWU4MDJfMXhfbWthX3BlZXJfYm9keSkpOworCisJYm9keS0+dHlwZSA9IE1LQV9QT1RFTlRJQUxfUEVFUl9MSVNUOworCXNldF9ta2FfcGFyYW1fYm9keV9sZW4oYm9keSwgbGVuZ3RoIC0gTUtBX0hEUl9MRU4pOworCisJZGxfbGlzdF9mb3JfZWFjaChwZWVyLCAmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycywKKwkJCSBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCkgeworCQlib2R5X3BlZXIgPSB3cGFidWZfcHV0KGJ1ZiwKKwkJCQkgICAgICAgc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wZWVyX2lkKSk7CisJCW9zX21lbWNweShib2R5X3BlZXItPm1pLCBwZWVyLT5taSwgTUlfTEVOKTsKKwkJYm9keV9wZWVyLT5tbiA9IGhvc3RfdG9fYmUzMihwZWVyLT5tbik7CisJCWJvZHlfcGVlcisrOworCX0KKworCWllZWU4MDJfMXhfbWthX2R1bXBfcGVlcl9ib2R5KGJvZHkpOworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfaV9pbl9wZWVybGlzdCAtCisgKi8KK3N0YXRpYyBCb29sZWFuCitpZWVlODAyXzF4X21rYV9pX2luX3BlZXJsaXN0KHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJCQkgICAgIGNvbnN0IHU4ICpta2FfbXNnLCBzaXplX3QgbXNnX2xlbikKK3sKKwlCb29sZWFuIGluY2x1ZGVkID0gRkFMU0U7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqaGRyOworCXNpemVfdCBib2R5X2xlbjsKKwlzaXplX3QgbGVmdF9sZW47CisJaW50IGJvZHlfdHlwZTsKKwl1MzIgcGVlcl9tbjsKKwljb25zdCB1OCAqcGVlcl9taTsKKwljb25zdCB1OCAqcG9zOworCXNpemVfdCBpOworCisJcG9zID0gbWthX21zZzsKKwlsZWZ0X2xlbiA9IG1zZ19sZW47CisJd2hpbGUgKGxlZnRfbGVuID4gKE1LQV9IRFJfTEVOICsgREVGQVVMVF9JQ1ZfTEVOKSkgeworCQloZHIgPSAoc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqKSBwb3M7CisJCWJvZHlfbGVuID0gZ2V0X21rYV9wYXJhbV9ib2R5X2xlbihoZHIpOworCQlib2R5X3R5cGUgPSBnZXRfbWthX3BhcmFtX2JvZHlfdHlwZShoZHIpOworCisJCWlmIChib2R5X3R5cGUgIT0gTUtBX0xJVkVfUEVFUl9MSVNUICYmCisJCSAgICBib2R5X3R5cGUgIT0gTUtBX1BPVEVOVElBTF9QRUVSX0xJU1QpCisJCQlnb3RvIFNLSVBfUEVFUjsKKworCQlpZWVlODAyXzF4X21rYV9kdW1wX3BlZXJfYm9keSgKKwkJCShzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGVlcl9ib2R5ICopcG9zKTsKKworCQlpZiAobGVmdF9sZW4gPCAoTUtBX0hEUl9MRU4gKyBib2R5X2xlbiArIERFRkFVTFRfSUNWX0xFTikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJLYVk6IE1LQSBQZWVyIFBhY2tldCBCb2R5IExlbmd0aCAoJWQgYnl0ZXMpIGlzIGxlc3MgdGhhbiB0aGUgUGFyYW1ldGVyIFNldCBIZWFkZXIgTGVuZ3RoICglZCBieXRlcykgKyB0aGUgUGFyYW1ldGVyIFNldCBCb2R5IExlbmd0aCAoJWQgYnl0ZXMpICsgJWQgYnl0ZXMgb2YgSUNWIiwKKwkJCQkgICAoaW50KSBsZWZ0X2xlbiwgKGludCkgTUtBX0hEUl9MRU4sCisJCQkJICAgKGludCkgYm9keV9sZW4sIERFRkFVTFRfSUNWX0xFTik7CisJCQlnb3RvIFNLSVBfUEVFUjsKKwkJfQorCisJCWlmICgoYm9keV9sZW4gJSAxNikgIT0gMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkthWTogTUtBIFBlZXIgUGFja2V0IEJvZHkgTGVuZ3RoICglZCBieXRlcykgc2hvdWxkIG11bHRpcGxlIG9mIDE2IG9jdGV0cyIsCisJCQkJICAgKGludCkgYm9keV9sZW4pOworCQkJZ290byBTS0lQX1BFRVI7CisJCX0KKworCQlmb3IgKGkgPSAwOyBpIDwgYm9keV9sZW47IGkgKz0gTUlfTEVOICsgc2l6ZW9mKHBlZXJfbW4pKSB7CisJCQlwZWVyX21pID0gTUtBX0hEUl9MRU4gKyBwb3MgKyBpOworCQkJb3NfbWVtY3B5KCZwZWVyX21uLCBwZWVyX21pICsgTUlfTEVOLCBzaXplb2YocGVlcl9tbikpOworCQkJcGVlcl9tbiA9IGJlX3RvX2hvc3QzMihwZWVyX21uKTsKKwkJCWlmIChvc19tZW1jbXAocGVlcl9taSwgcGFydGljaXBhbnQtPm1pLCBNSV9MRU4pID09IDAgJiYKKwkJCSAgICBwZWVyX21uID09IHBhcnRpY2lwYW50LT5tbikgeworCQkJCWluY2x1ZGVkID0gVFJVRTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCisJCWlmIChpbmNsdWRlZCkKKwkJCXJldHVybiBUUlVFOworCitTS0lQX1BFRVI6CisJCWxlZnRfbGVuIC09IGJvZHlfbGVuICsgTUtBX0hEUl9MRU47CisJCXBvcyArPSBib2R5X2xlbiArIE1LQV9IRFJfTEVOOworCX0KKworCXJldHVybiBGQUxTRTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2RlY29kZV9saXZlX3BlZXJfYm9keSAtCisgKi8KK3N0YXRpYyBpbnQgaWVlZTgwMl8xeF9ta2FfZGVjb2RlX2xpdmVfcGVlcl9ib2R5KAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJY29uc3QgdTggKnBlZXJfbXNnLCBzaXplX3QgbXNnX2xlbikKK3sKKwljb25zdCBzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICpoZHI7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKnBlZXI7CisJc2l6ZV90IGJvZHlfbGVuOworCXUzMiBwZWVyX21uOworCWNvbnN0IHU4ICpwZWVyX21pOworCXNpemVfdCBpOworCUJvb2xlYW4gaXNfaW5jbHVkZWQ7CisKKwlpc19pbmNsdWRlZCA9IGllZWU4MDJfMXhfa2F5X2lzX2luX2xpdmVfcGVlcigKKwkJcGFydGljaXBhbnQsIHBhcnRpY2lwYW50LT5jdXJyZW50X3BlZXJfaWQubWkpOworCisJaGRyID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyXzF4X21rYV9oZHIgKikgcGVlcl9tc2c7CisJYm9keV9sZW4gPSBnZXRfbWthX3BhcmFtX2JvZHlfbGVuKGhkcik7CisKKwlmb3IgKGkgPSAwOyBpIDwgYm9keV9sZW47IGkgKz0gTUlfTEVOICsgc2l6ZW9mKHBlZXJfbW4pKSB7CisJCXBlZXJfbWkgPSBNS0FfSERSX0xFTiArIHBlZXJfbXNnICsgaTsKKwkJb3NfbWVtY3B5KCZwZWVyX21uLCBwZWVyX21pICsgTUlfTEVOLCBzaXplb2YocGVlcl9tbikpOworCQlwZWVyX21uID0gYmVfdG9faG9zdDMyKHBlZXJfbW4pOworCisJCS8qIGl0IGlzIG15c2VsZiAqLworCQlpZiAob3NfbWVtY21wKHBlZXJfbWksIHBhcnRpY2lwYW50LT5taSwgTUlfTEVOKSA9PSAwKSB7CisJCQkvKiBNeSBtZXNzYWdlIGlkIGlzIHVzZWQgYnkgb3RoZXIgcGFydGljaXBhbnQgKi8KKwkJCWlmIChwZWVyX21uID4gcGFydGljaXBhbnQtPm1uKSB7CisJCQkJb3NfZ2V0X3JhbmRvbShwYXJ0aWNpcGFudC0+bWksCisJCQkJCSAgICAgIHNpemVvZihwYXJ0aWNpcGFudC0+bWkpKTsKKwkJCQlwYXJ0aWNpcGFudC0+bW4gPSAwOworCQkJfQorCQkJY29udGludWU7CisJCX0KKwkJaWYgKCFpc19pbmNsdWRlZCkKKwkJCWNvbnRpbnVlOworCisJCXBlZXIgPSBpZWVlODAyXzF4X2theV9nZXRfcGVlcihwYXJ0aWNpcGFudCwgcGVlcl9taSk7CisJCWlmIChOVUxMICE9IHBlZXIpIHsKKwkJCXBlZXItPm1uID0gcGVlcl9tbjsKKwkJCXBlZXItPmV4cGlyZSA9IHRpbWUoTlVMTCkgKyBNS0FfTElGRV9USU1FIC8gMTAwMDsKKwkJfSBlbHNlIHsKKwkJCWlmICghaWVlZTgwMl8xeF9rYXlfY3JlYXRlX3BvdGVudGlhbF9wZWVyKAorCQkJCXBhcnRpY2lwYW50LCBwZWVyX21pLCBwZWVyX21uKSkgeworCQkJCXJldHVybiAtMTsKKwkJCX0KKwkJfQorCX0KKworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfZGVjb2RlX3BvdGVudGlhbF9wZWVyX2JvZHkgLQorICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X21rYV9kZWNvZGVfcG90ZW50aWFsX3BlZXJfYm9keSgKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCWNvbnN0IHU4ICpwZWVyX21zZywgc2l6ZV90IG1zZ19sZW4pCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqaGRyOworCXNpemVfdCBib2R5X2xlbjsKKwl1MzIgcGVlcl9tbjsKKwljb25zdCB1OCAqcGVlcl9taTsKKwlzaXplX3QgaTsKKworCWhkciA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICopIHBlZXJfbXNnOworCWJvZHlfbGVuID0gZ2V0X21rYV9wYXJhbV9ib2R5X2xlbihoZHIpOworCisJZm9yIChpID0gMDsgaSA8IGJvZHlfbGVuOyBpICs9IE1JX0xFTiArIHNpemVvZihwZWVyX21uKSkgeworCQlwZWVyX21pID0gTUtBX0hEUl9MRU4gKyBwZWVyX21zZyArIGk7CisJCW9zX21lbWNweSgmcGVlcl9tbiwgcGVlcl9taSArIE1JX0xFTiwgc2l6ZW9mKHBlZXJfbW4pKTsKKwkJcGVlcl9tbiA9IGJlX3RvX2hvc3QzMihwZWVyX21uKTsKKworCQkvKiBpdCBpcyBteXNlbGYgKi8KKwkJaWYgKG9zX21lbWNtcChwZWVyX21pLCBwYXJ0aWNpcGFudC0+bWksIE1JX0xFTikgPT0gMCkgeworCQkJLyogTXkgbWVzc2FnZSBpZCBpcyB1c2VkIGJ5IG90aGVyIHBhcnRpY2lwYW50ICovCisJCQlpZiAocGVlcl9tbiA+IHBhcnRpY2lwYW50LT5tbikgeworCQkJCW9zX2dldF9yYW5kb20ocGFydGljaXBhbnQtPm1pLAorCQkJCQkgICAgICBzaXplb2YocGFydGljaXBhbnQtPm1pKSk7CisJCQkJcGFydGljaXBhbnQtPm1uID0gMDsKKwkJCX0KKwkJCWNvbnRpbnVlOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9zYWtfdXNlX2JvZHlfcHJlc2VudAorICovCitzdGF0aWMgQm9vbGVhbgoraWVlZTgwMl8xeF9ta2Ffc2FrX3VzZV9ib2R5X3ByZXNlbnQoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlpZiAocGFydGljaXBhbnQtPnRvX3VzZV9zYWspCisJCXJldHVybiBUUlVFOworCWVsc2UKKwkJcmV0dXJuIEZBTFNFOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfZ2V0X3Nha191c2VfbGVuZ3RoCisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2dldF9zYWtfdXNlX2xlbmd0aCgKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50KQoreworCWludCBsZW5ndGggPSBNS0FfSERSX0xFTjsKKworCWlmIChwYXJ0aWNpcGFudC0+a2F5LT5tYWNzZWNfZGVzaXJlZCAmJiBwYXJ0aWNpcGFudC0+YWR2aXNlZF9kZXNpcmVkKQorCQlsZW5ndGggPSBzaXplb2Yoc3RydWN0IGllZWU4MDJfMXhfbWthX3Nha191c2VfYm9keSk7CisJZWxzZQorCQlsZW5ndGggPSBNS0FfSERSX0xFTjsKKworCWxlbmd0aCA9IChsZW5ndGggKyAweDMpICYgfjB4MzsKKworCXJldHVybiBsZW5ndGg7Cit9CisKKworLyoqCisgKgorICovCitzdGF0aWMgdTMyCitpZWVlODAyXzF4X21rYV9nZXRfbHBuKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcHJpbmNpcGFsLAorCQkgICAgICAgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpraSkKK3sKKwlzdHJ1Y3QgcmVjZWl2ZV9zYSAqcnhzYTsKKwlzdHJ1Y3QgcmVjZWl2ZV9zYyAqcnhzYzsKKwl1MzIgbHBuID0gMDsKKworCWRsX2xpc3RfZm9yX2VhY2gocnhzYywgJnByaW5jaXBhbC0+cnhzY19saXN0LCBzdHJ1Y3QgcmVjZWl2ZV9zYywgbGlzdCkgeworCQlkbF9saXN0X2Zvcl9lYWNoKHJ4c2EsICZyeHNjLT5zYV9saXN0LCBzdHJ1Y3QgcmVjZWl2ZV9zYSwgbGlzdCkKKwkJeworCQkJaWYgKGlzX2tpX2VxdWFsKCZyeHNhLT5wa2V5LT5rZXlfaWRlbnRpZmllciwga2kpKSB7CisJCQkJc2VjeV9nZXRfcmVjZWl2ZV9sb3dlc3RfcG4ocHJpbmNpcGFsLT5rYXksCisJCQkJCQkJICAgcnhzYSk7CisKKwkJCQlscG4gPSBscG4gPiByeHNhLT5sb3dlc3RfcG4gPworCQkJCQlscG4gOiByeHNhLT5sb3dlc3RfcG47CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKwl9CisKKwlpZiAobHBuID09IDApCisJCWxwbiA9IDE7CisKKwlyZXR1cm4gbHBuOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfZW5jb2RlX3Nha191c2VfYm9keSAtCisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2VuY29kZV9zYWtfdXNlX2JvZHkoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCwKKwlzdHJ1Y3Qgd3BhYnVmICpidWYpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3Nha191c2VfYm9keSAqYm9keTsKKwl1bnNpZ25lZCBpbnQgbGVuZ3RoOworCXUzMiBwbiA9IDE7CisKKwlsZW5ndGggPSBpZWVlODAyXzF4X21rYV9nZXRfc2FrX3VzZV9sZW5ndGgocGFydGljaXBhbnQpOworCWJvZHkgPSB3cGFidWZfcHV0KGJ1Ziwgc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X21rYV9zYWtfdXNlX2JvZHkpKTsKKworCWJvZHktPnR5cGUgPSBNS0FfU0FLX1VTRTsKKwlzZXRfbWthX3BhcmFtX2JvZHlfbGVuKGJvZHksIGxlbmd0aCAtIE1LQV9IRFJfTEVOKTsKKworCWlmIChsZW5ndGggPT0gTUtBX0hEUl9MRU4pIHsKKwkJYm9keS0+cHR4ID0gVFJVRTsKKwkJYm9keS0+cHJ4ID0gVFJVRTsKKwkJYm9keS0+bGFuID0gMDsKKwkJYm9keS0+bHJ4ID0gRkFMU0U7CisJCWJvZHktPmx0eCA9IEZBTFNFOworCQlib2R5LT5kZWxheV9wcm90ZWN0ID0gRkFMU0U7CisJCXJldHVybiAwOworCX0KKworCS8qIGRhdGEgcHJvdGVjdCwgbG93ZXN0IGFjY2VwdCBwYWNrZXQgbnVtYmVyICovCisJYm9keS0+ZGVsYXlfcHJvdGVjdCA9IHBhcnRpY2lwYW50LT5rYXktPm1hY3NlY19yZXBsYXlfcHJvdGVjdDsKKwlwbiA9IGllZWU4MDJfMXhfbWthX2dldF9scG4ocGFydGljaXBhbnQsICZwYXJ0aWNpcGFudC0+bGtpKTsKKwlpZiAocG4gPiBwYXJ0aWNpcGFudC0+a2F5LT5wbl9leGhhdXN0aW9uKSB7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJLYVk6IE15IExQTiBleGhhdXN0aW9uIik7CisJCWlmIChwYXJ0aWNpcGFudC0+aXNfa2V5X3NlcnZlcikKKwkJCXBhcnRpY2lwYW50LT5uZXdfc2FrID0gVFJVRTsKKwl9CisKKwlib2R5LT5sbHBuID0gaG9zdF90b19iZTMyKHBuKTsKKwlwbiA9IGllZWU4MDJfMXhfbWthX2dldF9scG4ocGFydGljaXBhbnQsICZwYXJ0aWNpcGFudC0+b2tpKTsKKwlib2R5LT5vbHBuID0gaG9zdF90b19iZTMyKHBuKTsKKworCS8qIHBsYWluIHR4LCBwbGFpbiByeCAqLworCWlmIChwYXJ0aWNpcGFudC0+a2F5LT5tYWNzZWNfcHJvdGVjdCkKKwkJYm9keS0+cHR4ID0gRkFMU0U7CisJZWxzZQorCQlib2R5LT5wdHggPSBUUlVFOworCisJaWYgKHBhcnRpY2lwYW50LT5rYXktPm1hY3NlY192YWxpZGF0ZSA9PSBTdHJpY3QpCisJCWJvZHktPnByeCA9IEZBTFNFOworCWVsc2UKKwkJYm9keS0+cHJ4ID0gVFJVRTsKKworCS8qIGxhdGVzdCBrZXk6IHJ4LCB0eCwga2V5IHNlcnZlciBtZW1iZXIgaWRlbnRpZmllciBrZXkgbnVtYmVyICovCisJYm9keS0+bGFuID0gcGFydGljaXBhbnQtPmxhbjsKKwlvc19tZW1jcHkoYm9keS0+bHNydl9taSwgcGFydGljaXBhbnQtPmxraS5taSwKKwkJICBzaXplb2YoYm9keS0+bHNydl9taSkpOworCWJvZHktPmxrbiA9IGhvc3RfdG9fYmUzMihwYXJ0aWNpcGFudC0+bGtpLmtuKTsKKwlib2R5LT5scnggPSBwYXJ0aWNpcGFudC0+bHJ4OworCWJvZHktPmx0eCA9IHBhcnRpY2lwYW50LT5sdHg7CisKKwkvKiBvbGQga2V5OiByeCwgdHgsIGtleSBzZXJ2ZXIgbWVtYmVyIGlkZW50aWZpZXIga2V5IG51bWJlciAqLworCWJvZHktPm9hbiA9IHBhcnRpY2lwYW50LT5vYW47CisJaWYgKHBhcnRpY2lwYW50LT5va2kua24gIT0gcGFydGljaXBhbnQtPmxraS5rbiAmJgorCSAgICBwYXJ0aWNpcGFudC0+b2tpLmtuICE9IDApIHsKKwkJYm9keS0+b3R4ID0gVFJVRTsKKwkJYm9keS0+b3J4ID0gVFJVRTsKKwkJb3NfbWVtY3B5KGJvZHktPm9zcnZfbWksIHBhcnRpY2lwYW50LT5va2kubWksCisJCQkgIHNpemVvZihib2R5LT5vc3J2X21pKSk7CisJCWJvZHktPm9rbiA9IGhvc3RfdG9fYmUzMihwYXJ0aWNpcGFudC0+b2tpLmtuKTsKKwl9IGVsc2UgeworCQlib2R5LT5vdHggPSBGQUxTRTsKKwkJYm9keS0+b3J4ID0gRkFMU0U7CisJfQorCisJLyogc2V0IENQJ3MgdmFyaWFibGUgKi8KKwlpZiAoYm9keS0+bHR4KSB7CisJCWlmICghcGFydGljaXBhbnQtPmtheS0+dHhfZW5hYmxlKQorCQkJcGFydGljaXBhbnQtPmtheS0+dHhfZW5hYmxlID0gVFJVRTsKKworCQlpZiAoIXBhcnRpY2lwYW50LT5rYXktPnBvcnRfZW5hYmxlKQorCQkJcGFydGljaXBhbnQtPmtheS0+cG9ydF9lbmFibGUgPSBUUlVFOworCX0KKwlpZiAoYm9keS0+bHJ4KSB7CisJCWlmICghcGFydGljaXBhbnQtPmtheS0+cnhfZW5hYmxlKQorCQkJcGFydGljaXBhbnQtPmtheS0+cnhfZW5hYmxlID0gVFJVRTsKKwl9CisKKwlpZWVlODAyXzF4X21rYV9kdW1wX3Nha191c2VfYm9keShib2R5KTsKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfbWthX2RlY29kZV9zYWtfdXNlX2JvZHkgLQorICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X21rYV9kZWNvZGVfc2FrX3VzZV9ib2R5KAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJY29uc3QgdTggKm1rYV9tc2csIHNpemVfdCBtc2dfbGVuKQoreworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9oZHIgKmhkcjsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffc2FrX3VzZV9ib2R5ICpib2R5OworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCXN0cnVjdCB0cmFuc21pdF9zYSAqdHhzYTsKKwlzdHJ1Y3QgZGF0YV9rZXkgKnNhX2tleSA9IE5VTEw7CisJc2l6ZV90IGJvZHlfbGVuOworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9raSBraTsKKwl1MzIgbHBuOworCUJvb2xlYW4gYWxsX3JlY2VpdmluZzsKKwlCb29sZWFuIGZvdW5kZWQ7CisKKwlpZiAoIXBhcnRpY2lwYW50LT5wcmluY2lwYWwpIHsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkthWTogUGFydGljaXBhbnQgaXMgbm90IHByaW5jaXBhbCIpOworCQlyZXR1cm4gLTE7CisJfQorCXBlZXIgPSBpZWVlODAyXzF4X2theV9nZXRfbGl2ZV9wZWVyKHBhcnRpY2lwYW50LAorCQkJCQkgICAgcGFydGljaXBhbnQtPmN1cnJlbnRfcGVlcl9pZC5taSk7CisJaWYgKCFwZWVyKSB7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJLYVk6IHRoZSBwZWVyIGlzIG5vdCBteSBsaXZlIHBlZXIiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWhkciA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICopIG1rYV9tc2c7CisJYm9keV9sZW4gPSBnZXRfbWthX3BhcmFtX2JvZHlfbGVuKGhkcik7CisJYm9keSA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffc2FrX3VzZV9ib2R5ICopIG1rYV9tc2c7CisJaWVlZTgwMl8xeF9ta2FfZHVtcF9zYWtfdXNlX2JvZHkoYm9keSk7CisKKwlpZiAoKGJvZHlfbGVuICE9IDApICYmIChib2R5X2xlbiA8IDQwKSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IE1LQSBVc2UgU0FLIFBhY2tldCBCb2R5IExlbmd0aCAoJWQgYnl0ZXMpIHNob3VsZCBiZSAwLCA0MCwgb3IgbW9yZSBvY3RldHMiLAorCQkJICAgKGludCkgYm9keV9sZW4pOworCQlyZXR1cm4gLTE7CisJfQorCisJLyogVE9ETzogd2hhdCBhY3Rpb24gc2hvdWxkIEkgdGFrZSB3aGVuIHBlZXIgZG9lcyBub3Qgc3VwcG9ydCBNQUNzZWMgKi8KKwlpZiAoYm9keV9sZW4gPT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiS2FZOiBQZWVyIGRvZXMgbm90IHN1cHBvcnQgTUFDc2VjIik7CisJCXJldHVybiAwOworCX0KKworCS8qIFRPRE86IHdoZW4gdGhlIHBsYWluIHR4IG9yIHJ4IG9mIHBlZXIgaXMgdHJ1ZSwgc2hvdWxkIEkgY2hhbmdlCisJICogdGhlIGF0dHJpYnV0ZSBvZiBjb250cm9sbGVkIHBvcnQKKwkgKi8KKwlpZiAoYm9keS0+cHJ4KQorCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiS2FZOiBwZWVyJ3MgcGxhaW4gcnggYXJlIFRSVUUiKTsKKworCWlmIChib2R5LT5wdHgpCisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJLYVk6IHBlZXIncyBwbGFpbiB0eCBhcmUgVFJVRSIpOworCisJLyogY2hlY2sgbGF0ZXN0IGtleSBpcyB2YWxpZCAqLworCWlmIChib2R5LT5sdHggfHwgYm9keS0+bHJ4KSB7CisJCWZvdW5kZWQgPSBGQUxTRTsKKwkJb3NfbWVtY3B5KGtpLm1pLCBib2R5LT5sc3J2X21pLCBzaXplb2Yoa2kubWkpKTsKKwkJa2kua24gPSBudG9obChib2R5LT5sa24pOworCQlkbF9saXN0X2Zvcl9lYWNoKHNhX2tleSwgJnBhcnRpY2lwYW50LT5zYWtfbGlzdCwKKwkJCQkgc3RydWN0IGRhdGFfa2V5LCBsaXN0KSB7CisJCQlpZiAoaXNfa2lfZXF1YWwoJnNhX2tleS0+a2V5X2lkZW50aWZpZXIsICZraSkpIHsKKwkJCQlmb3VuZGVkID0gVFJVRTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCQlpZiAoIWZvdW5kZWQpIHsKKwkJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJLYVk6IExhdGVzdCBrZXkgaXMgaW52YWxpZCIpOworCQkJcmV0dXJuIC0xOworCQl9CisJCWlmIChvc19tZW1jbXAocGFydGljaXBhbnQtPmxraS5taSwgYm9keS0+bHNydl9taSwKKwkJCSAgICAgIHNpemVvZihwYXJ0aWNpcGFudC0+bGtpLm1pKSkgPT0gMCAmJgorCQkgICAgbnRvaGwoYm9keS0+bGtuKSA9PSBwYXJ0aWNpcGFudC0+bGtpLmtuICYmCisJCSAgICBib2R5LT5sYW4gPT0gcGFydGljaXBhbnQtPmxhbikgeworCQkJcGVlci0+c2FrX3VzZWQgPSBUUlVFOworCQl9CisJCWlmIChib2R5LT5sdHggJiYgcGVlci0+aXNfa2V5X3NlcnZlcikgeworCQkJaWVlZTgwMl8xeF9jcF9zZXRfc2VydmVydHJhbnNtaXR0aW5nKAorCQkJCXBhcnRpY2lwYW50LT5rYXktPmNwLCBUUlVFKTsKKwkJCWllZWU4MDJfMXhfY3Bfc21fc3RlcChwYXJ0aWNpcGFudC0+a2F5LT5jcCk7CisJCX0KKwl9CisKKwkvKiBjaGVjayBvbGQga2V5IGlzIHZhbGlkICovCisJaWYgKGJvZHktPm90eCB8fCBib2R5LT5vcngpIHsKKwkJaWYgKG9zX21lbWNtcChwYXJ0aWNpcGFudC0+b2tpLm1pLCBib2R5LT5vc3J2X21pLAorCQkJICAgICAgc2l6ZW9mKHBhcnRpY2lwYW50LT5va2kubWkpKSAhPSAwIHx8CisJCSAgICBudG9obChib2R5LT5va24pICE9IHBhcnRpY2lwYW50LT5va2kua24gfHwKKwkJICAgIGJvZHktPm9hbiAhPSBwYXJ0aWNpcGFudC0+b2FuKSB7CisJCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiS2FZOiBPbGQga2V5IGlzIGludmFsaWQiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KKworCS8qIFRPRE86IGhvdyB0byBzZXQgdGhlIE1BQ3NlYyBoYXJkd2FyZSB3aGVuIGRlbGF5X3Byb3RlY3QgaXMgdHJ1ZSAqLworCWlmIChib2R5LT5kZWxheV9wcm90ZWN0ICYmICghbnRvaGwoYm9keS0+bGxwbikgfHwgIW50b2hsKGJvZHktPm9scG4pKSkgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLAorCQkJICAgIkthWTogTG93ZXN0IHBhY2tldCBudW1iZXIgc2hvdWxkIGdyZWF0ZXIgdGhhbiAwIHdoZW4gZGVsYXlfcHJvdGVjdCBpcyBUUlVFIik7CisJCXJldHVybiAtMTsKKwl9CisKKwkvKiBjaGVjayBhbGwgbGl2ZSBwZWVyIGhhdmUgdXNlZCB0aGUgc2FrIGZvciByZWNlaXZpbmcgc2EgKi8KKwlhbGxfcmVjZWl2aW5nID0gVFJVRTsKKwlkbF9saXN0X2Zvcl9lYWNoKHBlZXIsICZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywKKwkJCSBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCkgeworCQlpZiAoIXBlZXItPnNha191c2VkKSB7CisJCQlhbGxfcmVjZWl2aW5nID0gRkFMU0U7CisJCQlicmVhazsKKwkJfQorCX0KKwlpZiAoYWxsX3JlY2VpdmluZykgeworCQlwYXJ0aWNpcGFudC0+dG9fZGlzdF9zYWsgPSBGQUxTRTsKKwkJaWVlZTgwMl8xeF9jcF9zZXRfYWxscmVjZWl2aW5nKHBhcnRpY2lwYW50LT5rYXktPmNwLCBUUlVFKTsKKwkJaWVlZTgwMl8xeF9jcF9zbV9zdGVwKHBhcnRpY2lwYW50LT5rYXktPmNwKTsKKwl9CisKKwkvKiBpZiBpJ20ga2V5IHNlcnZlciwgYW5kIGRldGVjdHMgcGVlciBtZW1iZXIgcG4gZXhoYXVzdGlvbiwgcmVrZXkuKi8KKwlscG4gPSBudG9obChib2R5LT5sbHBuKTsKKwlpZiAobHBuID4gcGFydGljaXBhbnQtPmtheS0+cG5fZXhoYXVzdGlvbikgeworCQlpZiAocGFydGljaXBhbnQtPmlzX2tleV9zZXJ2ZXIpIHsKKwkJCXBhcnRpY2lwYW50LT5uZXdfc2FrID0gVFJVRTsKKwkJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJLYVk6IFBlZXIgTFBOIGV4aGF1c3Rpb24iKTsKKwkJfQorCX0KKworCWZvdW5kZWQgPSBGQUxTRTsKKwlkbF9saXN0X2Zvcl9lYWNoKHR4c2EsICZwYXJ0aWNpcGFudC0+dHhzYy0+c2FfbGlzdCwKKwkJCSBzdHJ1Y3QgdHJhbnNtaXRfc2EsIGxpc3QpIHsKKwkJaWYgKHNhX2tleSAhPSBOVUxMICYmIHR4c2EtPnBrZXkgPT0gc2Ffa2V5KSB7CisJCQlmb3VuZGVkID0gVFJVRTsKKwkJCWJyZWFrOworCQl9CisJfQorCWlmICghZm91bmRlZCkgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiS2FZOiBDYW4ndCBmaW5kIHR4c2EiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCS8qIEZJWE1FOiBTZWN5IGNyZWF0ZXMgdHhzYSB3aXRoIGRlZmF1bHQgbnBuLiBJZiBNS0EgZGV0ZWN0ZWQgTGF0ZXN0IEtleQorCSAqIG5wbiBpcyBsYXJnZXIgdGhhbiB0eHNhJ3MgbnBuLCBzZXQgaXQgdG8gdHhzYS4KKwkgKi8KKwlzZWN5X2dldF90cmFuc21pdF9uZXh0X3BuKHBhcnRpY2lwYW50LT5rYXksIHR4c2EpOworCWlmIChscG4gPiB0eHNhLT5uZXh0X3BuKSB7CisJCXNlY3lfc2V0X3RyYW5zbWl0X25leHRfcG4ocGFydGljaXBhbnQtPmtheSwgdHhzYSk7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJLYVk6IHVwZGF0ZSBscG4gPTB4JXgiLCBscG4pOworCX0KKworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfZGlzdF9zYWtfYm9keV9wcmVzZW50CisgKi8KK3N0YXRpYyBCb29sZWFuCitpZWVlODAyXzF4X21rYV9kaXN0X3Nha19ib2R5X3ByZXNlbnQoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlpZiAoIXBhcnRpY2lwYW50LT50b19kaXN0X3NhayB8fCAhcGFydGljaXBhbnQtPm5ld19rZXkpCisJCXJldHVybiBGQUxTRTsKKworCXJldHVybiBUUlVFOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfZ2V0X2Rpc3Rfc2FrX2xlbmd0aAorICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X21rYV9nZXRfZGlzdF9zYWtfbGVuZ3RoKAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQpCit7CisJaW50IGxlbmd0aDsKKwlpbnQgY3NfaW5kZXggPSBwYXJ0aWNpcGFudC0+a2F5LT5tYWNzZWNfY3NpbmRleDsKKworCWlmIChwYXJ0aWNpcGFudC0+YWR2aXNlZF9kZXNpcmVkKSB7CisJCWxlbmd0aCA9IHNpemVvZihzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfZGlzdF9zYWtfYm9keSk7CisJCWlmIChjc19pbmRleCAhPSBERUZBVUxUX0NTX0lOREVYKQorCQkJbGVuZ3RoICs9IENTX0lEX0xFTjsKKworCQlsZW5ndGggKz0gY2lwaGVyX3N1aXRlX3RibFtjc19pbmRleF0uc2FrX2xlbiArIDg7CisJfSBlbHNlIHsKKwkJbGVuZ3RoID0gTUtBX0hEUl9MRU47CisJfQorCWxlbmd0aCA9IChsZW5ndGggKyAweDMpICYgfjB4MzsKKworCXJldHVybiBsZW5ndGg7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9lbmNvZGVfZGlzdF9zYWtfYm9keSAtCisgKi8KK3N0YXRpYyBpbnQKK2llZWU4MDJfMXhfbWthX2VuY29kZV9kaXN0X3Nha19ib2R5KAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9kaXN0X3Nha19ib2R5ICpib2R5OworCXN0cnVjdCBkYXRhX2tleSAqc2FrOworCXVuc2lnbmVkIGludCBsZW5ndGg7CisJaW50IGNzX2luZGV4OworCWludCBzYWtfcG9zOworCisJbGVuZ3RoID0gaWVlZTgwMl8xeF9ta2FfZ2V0X2Rpc3Rfc2FrX2xlbmd0aChwYXJ0aWNpcGFudCk7CisJYm9keSA9IHdwYWJ1Zl9wdXQoYnVmLCBsZW5ndGgpOworCWJvZHktPnR5cGUgPSBNS0FfRElTVFJJQlVURURfU0FLOworCXNldF9ta2FfcGFyYW1fYm9keV9sZW4oYm9keSwgbGVuZ3RoIC0gTUtBX0hEUl9MRU4pOworCWlmIChsZW5ndGggPT0gTUtBX0hEUl9MRU4pIHsKKwkJYm9keS0+Y29uZmlkX29mZnNldCA9IDA7CisJCWJvZHktPmRhbiA9IDA7CisJCXJldHVybiAwOworCX0KKworCXNhayA9IHBhcnRpY2lwYW50LT5uZXdfa2V5OworCWJvZHktPmNvbmZpZF9vZmZzZXQgPSBzYWstPmNvbmZpZGVudGlhbGl0eV9vZmZzZXQ7CisJYm9keS0+ZGFuID0gc2FrLT5hbjsKKwlib2R5LT5rbiA9IGhvc3RfdG9fYmUzMihzYWstPmtleV9pZGVudGlmaWVyLmtuKTsKKwljc19pbmRleCA9IHBhcnRpY2lwYW50LT5rYXktPm1hY3NlY19jc2luZGV4OworCXNha19wb3MgPSAwOworCWlmIChjc19pbmRleCAhPSBERUZBVUxUX0NTX0lOREVYKSB7CisJCW9zX21lbWNweShib2R5LT5zYWssIGNpcGhlcl9zdWl0ZV90YmxbY3NfaW5kZXhdLmlkLCBDU19JRF9MRU4pOworCQlzYWtfcG9zID0gQ1NfSURfTEVOOworCX0KKwlpZiAoYWVzX3dyYXAocGFydGljaXBhbnQtPmtlay5rZXksCisJCSAgICAgY2lwaGVyX3N1aXRlX3RibFtjc19pbmRleF0uc2FrX2xlbiAvIDgsCisJCSAgICAgc2FrLT5rZXksIGJvZHktPnNhayArIHNha19wb3MpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiBBRVMgd3JhcCBmYWlsZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWllZWU4MDJfMXhfbWthX2R1bXBfZGlzdF9zYWtfYm9keShib2R5KTsKKworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfaW5pdF9kYXRhX2tleSAtCisgKi8KK3N0YXRpYyBzdHJ1Y3QgZGF0YV9rZXkgKgoraWVlZTgwMl8xeF9rYXlfaW5pdF9kYXRhX2tleShjb25zdCBzdHJ1Y3Qga2V5X2NvbmYgKmNvbmYpCit7CisJc3RydWN0IGRhdGFfa2V5ICpwa2V5OworCisJaWYgKCFjb25mKQorCQlyZXR1cm4gTlVMTDsKKworCXBrZXkgPSBvc196YWxsb2Moc2l6ZW9mKCpwa2V5KSk7CisJaWYgKHBrZXkgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzOiBvdXQgb2YgbWVtb3J5IiwgX19mdW5jX18pOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlwa2V5LT5rZXkgPSBvc196YWxsb2MoY29uZi0+a2V5X2xlbik7CisJaWYgKHBrZXktPmtleSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCW9zX2ZyZWUocGtleSk7CisJCXJldHVybiBOVUxMOworCX0KKworCW9zX21lbWNweShwa2V5LT5rZXksIGNvbmYtPmtleSwgY29uZi0+a2V5X2xlbik7CisJb3NfbWVtY3B5KCZwa2V5LT5rZXlfaWRlbnRpZmllciwgJmNvbmYtPmtpLAorCQkgIHNpemVvZihwa2V5LT5rZXlfaWRlbnRpZmllcikpOworCXBrZXktPmNvbmZpZGVudGlhbGl0eV9vZmZzZXQgPSBjb25mLT5vZmZzZXQ7CisJcGtleS0+YW4gPSBjb25mLT5hbjsKKwlwa2V5LT50cmFuc21pdHMgPSBjb25mLT50eDsKKwlwa2V5LT5yZWNlaXZlcyA9IGNvbmYtPnJ4OworCW9zX2dldF90aW1lKCZwa2V5LT5jcmVhdGVkX3RpbWUpOworCisJcGtleS0+dXNlciA9IDE7CisKKwlyZXR1cm4gcGtleTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2RlY29kZV9kaXN0X3Nha19ib2R5IC0KKyAqLworc3RhdGljIGludAoraWVlZTgwMl8xeF9ta2FfZGVjb2RlX2Rpc3Rfc2FrX2JvZHkoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCwKKwljb25zdCB1OCAqbWthX21zZywgc2l6ZV90IG1zZ19sZW4pCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqaGRyOworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9kaXN0X3Nha19ib2R5ICpib2R5OworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCXN0cnVjdCBtYWNzZWNfY2lwaGVyc3VpdGUgKmNzOworCXNpemVfdCBib2R5X2xlbjsKKwlzdHJ1Y3Qga2V5X2NvbmYgKmNvbmY7CisJc3RydWN0IGRhdGFfa2V5ICpzYV9rZXkgPSBOVUxMOworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9raSBzYWtfa2k7CisJaW50IHNha19sZW47CisJdTggKndyYXBfc2FrOworCXU4ICp1bndyYXBfc2FrOworCisJaGRyID0gKHN0cnVjdCBpZWVlODAyXzF4X21rYV9oZHIgKikgbWthX21zZzsKKwlib2R5X2xlbiA9IGdldF9ta2FfcGFyYW1fYm9keV9sZW4oaGRyKTsKKwlpZiAoKGJvZHlfbGVuICE9IDApICYmIChib2R5X2xlbiAhPSAyOCkgJiYgKGJvZHlfbGVuIDwgMzYpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogTUtBIFVzZSBTQUsgUGFja2V0IEJvZHkgTGVuZ3RoICglZCBieXRlcykgc2hvdWxkIGJlIDAsIDI4LCAzNiwgb3IgbW9yZSBvY3RldHMiLAorCQkJICAgKGludCkgYm9keV9sZW4pOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKCFwYXJ0aWNpcGFudC0+cHJpbmNpcGFsKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogSSBjYW4ndCBhY2NlcHQgdGhlIGRpc3RyaWJ1dGVkIFNBSyBhcyBJIGFtIG5vdCBwcmluY2lwYWwiKTsKKwkJcmV0dXJuIC0xOworCX0KKwlpZiAocGFydGljaXBhbnQtPmlzX2tleV9zZXJ2ZXIpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBJIGNhbid0IGFjY2VwdCB0aGUgZGlzdHJpYnV0ZWQgU0FLIGFzIG15c2VsZiBpcyBrZXkgc2VydmVyICIpOworCQlyZXR1cm4gLTE7CisJfQorCWlmICghcGFydGljaXBhbnQtPmtheS0+bWFjc2VjX2Rlc2lyZWQgfHwKKwkgICAgcGFydGljaXBhbnQtPmtheS0+bWFjc2VjX2NhcGFibGUgPT0gTUFDU0VDX0NBUF9OT1RfSU1QTEVNRU5URUQpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBJIGFtIG5vdCBNQUNzZWMtZGVzaXJlZCBvciB3aXRob3V0IE1BQ3NlYyBjYXBhYmxlIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlwZWVyID0gaWVlZTgwMl8xeF9rYXlfZ2V0X2xpdmVfcGVlcihwYXJ0aWNpcGFudCwKKwkJCQkJICAgIHBhcnRpY2lwYW50LT5jdXJyZW50X3BlZXJfaWQubWkpOworCWlmICghcGVlcikgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IFRoZSBrZXkgc2VydmVyIGlzIG5vdCBpbiBteSBsaXZlIHBlZXJzIGxpc3QiKTsKKwkJcmV0dXJuIC0xOworCX0KKwlpZiAob3NfbWVtY21wKCZwYXJ0aWNpcGFudC0+a2F5LT5rZXlfc2VydmVyX3NjaSwKKwkJICAgICAgJnBlZXItPnNjaSwgc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X21rYV9zY2kpKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiBUaGUga2V5IHNlcnZlciBpcyBub3QgZWxlY3RlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChib2R5X2xlbiA9PSAwKSB7CisJCXBhcnRpY2lwYW50LT5rYXktPmF1dGhlbnRpY2F0ZWQgPSBUUlVFOworCQlwYXJ0aWNpcGFudC0+a2F5LT5zZWN1cmVkID0gRkFMU0U7CisJCXBhcnRpY2lwYW50LT5rYXktPmZhaWxlZCA9IEZBTFNFOworCQlwYXJ0aWNpcGFudC0+YWR2aXNlZF9kZXNpcmVkID0gRkFMU0U7CisJCWllZWU4MDJfMXhfY3BfY29ubmVjdF9hdXRoZW50aWNhdGVkKHBhcnRpY2lwYW50LT5rYXktPmNwKTsKKwkJaWVlZTgwMl8xeF9jcF9zbV9zdGVwKHBhcnRpY2lwYW50LT5rYXktPmNwKTsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkthWTpUaGUgS2V5IHNlcnZlciBhZHZpc2Ugbm8gTUFDc2VjIik7CisJCXBhcnRpY2lwYW50LT50b191c2Vfc2FrID0gVFJVRTsKKwkJcmV0dXJuIDA7CisJfQorCXBhcnRpY2lwYW50LT5hZHZpc2VkX2Rlc2lyZWQgPSBUUlVFOworCXBhcnRpY2lwYW50LT5rYXktPmF1dGhlbnRpY2F0ZWQgPSBGQUxTRTsKKwlwYXJ0aWNpcGFudC0+a2F5LT5zZWN1cmVkID0gVFJVRTsKKwlwYXJ0aWNpcGFudC0+a2F5LT5mYWlsZWQgPSBGQUxTRTsKKwlpZWVlODAyXzF4X2NwX2Nvbm5lY3Rfc2VjdXJlKHBhcnRpY2lwYW50LT5rYXktPmNwKTsKKwlpZWVlODAyXzF4X2NwX3NtX3N0ZXAocGFydGljaXBhbnQtPmtheS0+Y3ApOworCisJYm9keSA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfZGlzdF9zYWtfYm9keSAqKW1rYV9tc2c7CisJaWVlZTgwMl8xeF9ta2FfZHVtcF9kaXN0X3Nha19ib2R5KGJvZHkpOworCWRsX2xpc3RfZm9yX2VhY2goc2Ffa2V5LCAmcGFydGljaXBhbnQtPnNha19saXN0LCBzdHJ1Y3QgZGF0YV9rZXksIGxpc3QpCisJeworCQlpZiAob3NfbWVtY21wKHNhX2tleS0+a2V5X2lkZW50aWZpZXIubWksCisJCQkgICAgICBwYXJ0aWNpcGFudC0+Y3VycmVudF9wZWVyX2lkLm1pLCBNSV9MRU4pID09IDAgJiYKKwkJICAgIHNhX2tleS0+a2V5X2lkZW50aWZpZXIua24gPT0gYmVfdG9faG9zdDMyKGJvZHktPmtuKSkgeworCQkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkthWTpUaGUgS2V5IGhhcyBpbnN0YWxsZWQiKTsKKwkJCXJldHVybiAwOworCQl9CisJfQorCWlmIChib2R5X2xlbiA9PSAyOCkgeworCQlzYWtfbGVuID0gREVGQVVMVF9TQV9LRVlfTEVOOworCQl3cmFwX3NhayA9ICBib2R5LT5zYWs7CisJCXBhcnRpY2lwYW50LT5rYXktPm1hY3NlY19jc2luZGV4ID0gREVGQVVMVF9DU19JTkRFWDsKKwl9IGVsc2UgeworCQljcyA9IGllZWU4MDJfMXhfa2F5X2dldF9jaXBoZXJfc3VpdGUocGFydGljaXBhbnQsIGJvZHktPnNhayk7CisJCWlmICghY3MpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJLYVk6IEkgY2FuJ3Qgc3VwcG9ydCB0aGUgQ2lwaGVyIFN1aXRlIGFkdmlzZWQgYnkga2V5IHNlcnZlciIpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXNha19sZW4gPSBjcy0+c2FrX2xlbjsKKwkJd3JhcF9zYWsgPSBib2R5LT5zYWsgKyBDU19JRF9MRU47CisJCXBhcnRpY2lwYW50LT5rYXktPm1hY3NlY19jc2luZGV4ID0gY3MtPmluZGV4OworCX0KKworCXVud3JhcF9zYWsgPSBvc196YWxsb2Moc2FrX2xlbik7CisJaWYgKCF1bndyYXBfc2FrKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZLSVzOiBPdXQgb2YgbWVtb3J5IiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChhZXNfdW53cmFwKHBhcnRpY2lwYW50LT5rZWsua2V5LCBzYWtfbGVuID4+IDMsIHdyYXBfc2FrLAorCQkgICAgICAgdW53cmFwX3NhaykpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6IEFFUyB1bndyYXAgZmFpbGVkIik7CisJCW9zX2ZyZWUodW53cmFwX3Nhayk7CisJCXJldHVybiAtMTsKKwl9CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiXHRBRVMgS2V5IFVud3JhcCBvZiBTQUs6IiwgdW53cmFwX3Nhaywgc2FrX2xlbik7CisKKwljb25mID0gb3NfemFsbG9jKHNpemVvZigqY29uZikpOworCWlmICghY29uZikgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWS0lczogT3V0IG9mIG1lbW9yeSIsIF9fZnVuY19fKTsKKwkJb3NfZnJlZSh1bndyYXBfc2FrKTsKKwkJcmV0dXJuIC0xOworCX0KKwljb25mLT5rZXlfbGVuID0gc2FrX2xlbjsKKworCWNvbmYtPmtleSA9IG9zX3phbGxvYyhjb25mLT5rZXlfbGVuKTsKKwlpZiAoIWNvbmYtPmtleSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWS0lczogT3V0IG9mIG1lbW9yeSIsIF9fZnVuY19fKTsKKwkJb3NfZnJlZSh1bndyYXBfc2FrKTsKKwkJb3NfZnJlZShjb25mKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9zX21lbWNweShjb25mLT5rZXksIHVud3JhcF9zYWssIGNvbmYtPmtleV9sZW4pOworCisJb3NfbWVtY3B5KCZzYWtfa2kubWksICZwYXJ0aWNpcGFudC0+Y3VycmVudF9wZWVyX2lkLm1pLAorCQkgIHNpemVvZihzYWtfa2kubWkpKTsKKwlzYWtfa2kua24gPSBiZV90b19ob3N0MzIoYm9keS0+a24pOworCisJb3NfbWVtY3B5KGNvbmYtPmtpLm1pLCBzYWtfa2kubWksIE1JX0xFTik7CisJY29uZi0+a2kua24gPSBzYWtfa2kua247CisJY29uZi0+YW4gPSBib2R5LT5kYW47CisJY29uZi0+b2Zmc2V0ID0gYm9keS0+Y29uZmlkX29mZnNldDsKKwljb25mLT5yeCA9IFRSVUU7CisJY29uZi0+dHggPSBUUlVFOworCisJc2Ffa2V5ID0gaWVlZTgwMl8xeF9rYXlfaW5pdF9kYXRhX2tleShjb25mKTsKKwlpZiAoIXNhX2tleSkgeworCQlvc19mcmVlKHVud3JhcF9zYWspOworCQlvc19mcmVlKGNvbmYtPmtleSk7CisJCW9zX2ZyZWUoY29uZik7CisJCXJldHVybiAtMTsKKwl9CisKKwlkbF9saXN0X2FkZCgmcGFydGljaXBhbnQtPnNha19saXN0LCAmc2Ffa2V5LT5saXN0KTsKKworCWllZWU4MDJfMXhfY3Bfc2V0X2NpcGhlcnN1aXRlKAorCQlwYXJ0aWNpcGFudC0+a2F5LT5jcCwKKwkJY2lwaGVyX3N1aXRlX3RibFtwYXJ0aWNpcGFudC0+a2F5LT5tYWNzZWNfY3NpbmRleF0uaWQpOworCWllZWU4MDJfMXhfY3Bfc21fc3RlcChwYXJ0aWNpcGFudC0+a2F5LT5jcCk7CisJaWVlZTgwMl8xeF9jcF9zZXRfb2Zmc2V0KHBhcnRpY2lwYW50LT5rYXktPmNwLCBib2R5LT5jb25maWRfb2Zmc2V0KTsKKwlpZWVlODAyXzF4X2NwX3NtX3N0ZXAocGFydGljaXBhbnQtPmtheS0+Y3ApOworCWllZWU4MDJfMXhfY3Bfc2V0X2Rpc3RyaWJ1dGVka2kocGFydGljaXBhbnQtPmtheS0+Y3AsICZzYWtfa2kpOworCWllZWU4MDJfMXhfY3Bfc2V0X2Rpc3RyaWJ1dGVkYW4ocGFydGljaXBhbnQtPmtheS0+Y3AsIGJvZHktPmRhbik7CisJaWVlZTgwMl8xeF9jcF9zaWduYWxfbmV3c2FrKHBhcnRpY2lwYW50LT5rYXktPmNwKTsKKwlpZWVlODAyXzF4X2NwX3NtX3N0ZXAocGFydGljaXBhbnQtPmtheS0+Y3ApOworCisJcGFydGljaXBhbnQtPnRvX3VzZV9zYWsgPSBUUlVFOworCisJb3NfZnJlZSh1bndyYXBfc2FrKTsKKwlvc19mcmVlKGNvbmYtPmtleSk7CisJb3NfZnJlZShjb25mKTsKKworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfaWN2X2JvZHlfcHJlc2VudAorICovCitzdGF0aWMgQm9vbGVhbgoraWVlZTgwMl8xeF9ta2FfaWN2X2JvZHlfcHJlc2VudChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50KQoreworCXJldHVybiBUUlVFOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfZ2V0X2ljdl9sZW5ndGgKKyAqLworc3RhdGljIGludAoraWVlZTgwMl8xeF9ta2FfZ2V0X2ljdl9sZW5ndGgoc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlpbnQgbGVuZ3RoOworCisJbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X21rYV9pY3ZfYm9keSk7CisJbGVuZ3RoICs9IG1rYV9hbGdfdGJsW3BhcnRpY2lwYW50LT5rYXktPm1rYV9hbGdpbmRleF0uaWN2X2xlbjsKKworCXJldHVybiAobGVuZ3RoICsgMHgzKSAmIH4weDM7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9lbmNvZGVfaWN2X2JvZHkgLQorICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X21rYV9lbmNvZGVfaWN2X2JvZHkoc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCwKKwkJCSAgICAgICBzdHJ1Y3Qgd3BhYnVmICpidWYpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2ljdl9ib2R5ICpib2R5OworCXVuc2lnbmVkIGludCBsZW5ndGg7CisJdTggY21hY1tNQVhfSUNWX0xFTl07CisKKwlsZW5ndGggPSBpZWVlODAyXzF4X21rYV9nZXRfaWN2X2xlbmd0aChwYXJ0aWNpcGFudCk7CisJaWYgKGxlbmd0aCAhPSBERUZBVUxUX0lDVl9MRU4pICB7CisJCWJvZHkgPSB3cGFidWZfcHV0KGJ1ZiwgTUtBX0hEUl9MRU4pOworCQlib2R5LT50eXBlID0gTUtBX0lDVl9JTkRJQ0FUT1I7CisJCXNldF9ta2FfcGFyYW1fYm9keV9sZW4oYm9keSwgbGVuZ3RoIC0gTUtBX0hEUl9MRU4pOworCX0KKworCWlmIChta2FfYWxnX3RibFtwYXJ0aWNpcGFudC0+a2F5LT5ta2FfYWxnaW5kZXhdLmljdl9oYXNoKAorCQkgICAgcGFydGljaXBhbnQtPmljay5rZXksIHdwYWJ1Zl9oZWFkKGJ1ZiksIGJ1Zi0+dXNlZCwgY21hYykpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVksIG9tYWMxX2Flc18xMjggZmFpbGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAobGVuZ3RoICE9IERFRkFVTFRfSUNWX0xFTikgIHsKKwkJb3NfbWVtY3B5KHdwYWJ1Zl9wdXQoYnVmLCBsZW5ndGggLSBNS0FfSERSX0xFTiksIGNtYWMsCisJCQkgIGxlbmd0aCAtIE1LQV9IRFJfTEVOKTsKKwl9IGVsc2UgeworCQlvc19tZW1jcHkod3BhYnVmX3B1dChidWYsIGxlbmd0aCksIGNtYWMsIGxlbmd0aCk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfZGVjb2RlX2ljdl9ib2R5IC0KKyAqLworc3RhdGljIHU4ICoKK2llZWU4MDJfMXhfbWthX2RlY29kZV9pY3ZfYm9keShzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50LAorCQkJICAgICAgIGNvbnN0IHU4ICpta2FfbXNnLCBzaXplX3QgbXNnX2xlbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICpoZHI7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2ljdl9ib2R5ICpib2R5OworCXNpemVfdCBib2R5X2xlbjsKKwlzaXplX3QgbGVmdF9sZW47CisJaW50IGJvZHlfdHlwZTsKKwljb25zdCB1OCAqcG9zOworCisJcG9zID0gbWthX21zZzsKKwlsZWZ0X2xlbiA9IG1zZ19sZW47CisJd2hpbGUgKGxlZnRfbGVuID4gKE1LQV9IRFJfTEVOICsgREVGQVVMVF9JQ1ZfTEVOKSkgeworCQloZHIgPSAoc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqKSBwb3M7CisJCWJvZHlfbGVuID0gZ2V0X21rYV9wYXJhbV9ib2R5X2xlbihoZHIpOworCQlib2R5X3R5cGUgPSBnZXRfbWthX3BhcmFtX2JvZHlfdHlwZShoZHIpOworCisJCWlmIChsZWZ0X2xlbiA8IChib2R5X2xlbiArIE1LQV9IRFJfTEVOKSkKKwkJCWJyZWFrOworCisJCWlmIChib2R5X3R5cGUgIT0gTUtBX0lDVl9JTkRJQ0FUT1IpIHsKKwkJCWxlZnRfbGVuIC09IE1LQV9IRFJfTEVOICsgYm9keV9sZW47CisJCQlwb3MgKz0gTUtBX0hEUl9MRU4gKyBib2R5X2xlbjsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJYm9keSA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaWN2X2JvZHkgKilwb3M7CisJCWlmIChib2R5X2xlbgorCQkJPCBta2FfYWxnX3RibFtwYXJ0aWNpcGFudC0+a2F5LT5ta2FfYWxnaW5kZXhdLmljdl9sZW4pIHsKKwkJCXJldHVybiBOVUxMOworCQl9CisKKwkJcmV0dXJuIGJvZHktPmljdjsKKwl9CisKKwlyZXR1cm4gKHU4ICopIChta2FfbXNnICsgbXNnX2xlbiAtIERFRkFVTFRfSUNWX0xFTik7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9kZWNvZGVfZGlzdF9jYWtfYm9keS0KKyAqLworc3RhdGljIGludAoraWVlZTgwMl8xeF9ta2FfZGVjb2RlX2Rpc3RfY2FrX2JvZHkoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCwKKwljb25zdCB1OCAqbWthX21zZywgc2l6ZV90IG1zZ19sZW4pCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqaGRyOworCXNpemVfdCBib2R5X2xlbjsKKworCWhkciA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICopIG1rYV9tc2c7CisJYm9keV9sZW4gPSBnZXRfbWthX3BhcmFtX2JvZHlfbGVuKGhkcik7CisJaWYgKGJvZHlfbGVuIDwgMjgpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBNS0EgVXNlIFNBSyBQYWNrZXQgQm9keSBMZW5ndGggKCVkIGJ5dGVzKSBzaG91bGQgYmUgMjggb3IgbW9yZSBvY3RldHMiLAorCQkJICAgKGludCkgYm9keV9sZW4pOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X21rYV9kZWNvZGVfa21kX2JvZHkgLQorICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X21rYV9kZWNvZGVfa21kX2JvZHkoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCwKKwljb25zdCB1OCAqbWthX21zZywgc2l6ZV90IG1zZ19sZW4pCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqaGRyOworCXNpemVfdCBib2R5X2xlbjsKKworCWhkciA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICopIG1rYV9tc2c7CisJYm9keV9sZW4gPSBnZXRfbWthX3BhcmFtX2JvZHlfbGVuKGhkcik7CisJaWYgKGJvZHlfbGVuIDwgNSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IE1LQSBVc2UgU0FLIFBhY2tldCBCb2R5IExlbmd0aCAoJWQgYnl0ZXMpIHNob3VsZCBiZSA1IG9yIG1vcmUgb2N0ZXRzIiwKKwkJCSAgIChpbnQpIGJvZHlfbGVuKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9ta2FfZGVjb2RlX2Fubm91bmNlX2JvZHkgLQorICovCitzdGF0aWMgaW50IGllZWU4MDJfMXhfbWthX2RlY29kZV9hbm5vdW5jZV9ib2R5KAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsCisJY29uc3QgdTggKm1rYV9tc2csIHNpemVfdCBtc2dfbGVuKQoreworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBzdHJ1Y3QgbWthX3BhcmFtX2JvZHlfaGFuZGxlciBtYWtfYm9keV9oYW5kbGVyW10gPSB7CisJLyogYmFzaWMgcGFyYW1ldGVyIHNldCAqLworCXsKKwkJaWVlZTgwMl8xeF9ta2FfZW5jb2RlX2Jhc2ljX2JvZHksCisJCU5VTEwsCisJCWllZWU4MDJfMXhfbWthX2Jhc2ljX2JvZHlfbGVuZ3RoLAorCQlpZWVlODAyXzF4X21rYV9iYXNpY19ib2R5X3ByZXNlbnQKKwl9LAorCisJLyogbGl2ZSBwZWVyIGxpc3QgcGFyYW1ldGVyIHNldCAqLworCXsKKwkJaWVlZTgwMl8xeF9ta2FfZW5jb2RlX2xpdmVfcGVlcl9ib2R5LAorCQlpZWVlODAyXzF4X21rYV9kZWNvZGVfbGl2ZV9wZWVyX2JvZHksCisJCWllZWU4MDJfMXhfbWthX2dldF9saXZlX3BlZXJfbGVuZ3RoLAorCQlpZWVlODAyXzF4X21rYV9saXZlX3BlZXJfYm9keV9wcmVzZW50CisJfSwKKworCS8qIHBvdGVudGlhbCBwZWVyIGxpc3QgcGFyYW1ldGVyIHNldCAqLworCXsKKwkJaWVlZTgwMl8xeF9ta2FfZW5jb2RlX3BvdGVudGlhbF9wZWVyX2JvZHksCisJCWllZWU4MDJfMXhfbWthX2RlY29kZV9wb3RlbnRpYWxfcGVlcl9ib2R5LAorCQlpZWVlODAyXzF4X21rYV9nZXRfcG90ZW50aWFsX3BlZXJfbGVuZ3RoLAorCQlpZWVlODAyXzF4X21rYV9wb3RlbnRpYWxfcGVlcl9ib2R5X3ByZXNlbnQKKwl9LAorCisJLyogc2FrIHVzZSBwYXJhbWV0ZXIgc2V0ICovCisJeworCQlpZWVlODAyXzF4X21rYV9lbmNvZGVfc2FrX3VzZV9ib2R5LAorCQlpZWVlODAyXzF4X21rYV9kZWNvZGVfc2FrX3VzZV9ib2R5LAorCQlpZWVlODAyXzF4X21rYV9nZXRfc2FrX3VzZV9sZW5ndGgsCisJCWllZWU4MDJfMXhfbWthX3Nha191c2VfYm9keV9wcmVzZW50CisJfSwKKworCS8qIGRpc3RyaWJ1dGUgc2FrIHBhcmFtZXRlciBzZXQgKi8KKwl7CisJCWllZWU4MDJfMXhfbWthX2VuY29kZV9kaXN0X3Nha19ib2R5LAorCQlpZWVlODAyXzF4X21rYV9kZWNvZGVfZGlzdF9zYWtfYm9keSwKKwkJaWVlZTgwMl8xeF9ta2FfZ2V0X2Rpc3Rfc2FrX2xlbmd0aCwKKwkJaWVlZTgwMl8xeF9ta2FfZGlzdF9zYWtfYm9keV9wcmVzZW50CisJfSwKKworCS8qIGRpc3RyaWJ1dGUgY2FrIHBhcmFtZXRlciBzZXQgKi8KKwl7CisJCU5VTEwsCisJCWllZWU4MDJfMXhfbWthX2RlY29kZV9kaXN0X2Nha19ib2R5LAorCQlOVUxMLAorCQlOVUxMCisJfSwKKworCS8qIGttZCBwYXJhbWV0ZXIgc2V0ICovCisJeworCQlOVUxMLAorCQlpZWVlODAyXzF4X21rYV9kZWNvZGVfa21kX2JvZHksCisJCU5VTEwsCisJCU5VTEwKKwl9LAorCisJLyogYW5ub3VuY2UgcGFyYW1ldGVyIHNldCAqLworCXsKKwkJTlVMTCwKKwkJaWVlZTgwMl8xeF9ta2FfZGVjb2RlX2Fubm91bmNlX2JvZHksCisJCU5VTEwsCisJCU5VTEwKKwl9LAorCisJLyogaWN2IHBhcmFtZXRlciBzZXQgKi8KKwl7CisJCWllZWU4MDJfMXhfbWthX2VuY29kZV9pY3ZfYm9keSwKKwkJTlVMTCwKKwkJaWVlZTgwMl8xeF9ta2FfZ2V0X2ljdl9sZW5ndGgsCisJCWllZWU4MDJfMXhfbWthX2ljdl9ib2R5X3ByZXNlbnQKKwl9LAorfTsKKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2RlaW5pdF9kYXRhX2tleSAtCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9rYXlfZGVpbml0X2RhdGFfa2V5KHN0cnVjdCBkYXRhX2tleSAqcGtleSkKK3sKKwlpZiAoIXBrZXkpCisJCXJldHVybjsKKworCXBrZXktPnVzZXItLTsKKwlpZiAocGtleS0+dXNlciA+IDEpCisJCXJldHVybjsKKworCWRsX2xpc3RfZGVsKCZwa2V5LT5saXN0KTsKKwlvc19mcmVlKHBrZXktPmtleSk7CisJb3NfZnJlZShwa2V5KTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2dlbmVyYXRlX25ld19zYWsgLQorICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X2theV9nZW5lcmF0ZV9uZXdfc2FrKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQpCit7CisJc3RydWN0IGRhdGFfa2V5ICpzYV9rZXkgPSBOVUxMOworCXN0cnVjdCBrZXlfY29uZiAqY29uZjsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciAqcGVlcjsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSA9IHBhcnRpY2lwYW50LT5rYXk7CisJaW50IGN0eF9sZW4sIGN0eF9vZmZzZXQ7CisJdTggKmNvbnRleHQ7CisKKwkvKiBjaGVjayBjb25kaXRpb24gZm9yIGdlbmVyYXRpbmcgYSBmcmVzaCBTQUs6CisJICogbXVzdCBoYXZlIG9uZSBsaXZlIHBlZXIKKwkgKiBhbmQgTUtBIGxpZmUgdGltZSBlbGFwc2Ugc2luY2UgbGFzdCBkaXN0cmlidXRpb24KKwkgKiBvciBwb3RlbnRpYWwgcGVlciBpcyBlbXB0eQorCSAqLworCWlmIChkbF9saXN0X2VtcHR5KCZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycykpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBMaXZlIHBlZXJzIGxpc3QgbXVzdCBub3QgZW1wdHkgd2hlbiBnZW5lcmF0aW5nIGZyZXNoIFNBSyIpOworCQlyZXR1cm4gLTE7CisJfQorCisJLyogRklYTUU6IEEgZnJlc2ggU0FLIG5vdCBnZW5lcmF0ZWQgdW50aWwKKwkgKiB0aGUgbGl2ZSBwZWVyIGxpc3QgY29udGFpbnMgYXQgbGVhc3Qgb25lIHBlZXIgYW5kCisJICogTUtBIGxpZmUgdGltZSBoYXMgZWxhcHNlZCBzaW5jZSB0aGUgcHJpb3IgU0FLIHdhcyBmaXJzdCBkaXN0cmlidXRlZCwKKwkgKiBvciB0aGUgS2V5IHNlcnZlcidzIHBvdGVudGlhbCBwZWVyIGlzIGVtcHR5CisJICogYnV0IEkgY2FuJ3QgdW5kZXJzdGFuZCB0aGUgc2Vjb25kIGl0ZW0sIHNvCisJICogaGVyZSBvbmx5IGNoZWNrIGZpcnN0IGl0ZW0gYW5kIGluZ29yZQorCSAqICAgJiYgKCFkbF9saXN0X2VtcHR5KCZwYXJ0aWNpcGFudC0+cG90ZW50aWFsX3BlZXJzKSkpIHsKKwkgKi8KKwlpZiAoKHRpbWUoTlVMTCkgLSBrYXktPmRpc3RfdGltZSkgPCBNS0FfTElGRV9USU1FIC8gMTAwMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IExpZmUgdGltZSBoYXZlIG5vdCBlbGFwc2VkIHNpbmNlIHByaW9yIFNBSyBkaXN0cmlidXRlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJY29uZiA9IG9zX3phbGxvYyhzaXplb2YoKmNvbmYpKTsKKwlpZiAoIWNvbmYpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVktJXM6IE91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtMTsKKwl9CisJY29uZi0+a2V5X2xlbiA9IGNpcGhlcl9zdWl0ZV90Ymxba2F5LT5tYWNzZWNfY3NpbmRleF0uc2FrX2xlbjsKKworCWNvbmYtPmtleSA9IG9zX3phbGxvYyhjb25mLT5rZXlfbGVuKTsKKwlpZiAoIWNvbmYtPmtleSkgeworCQlvc19mcmVlKGNvbmYpOworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWS0lczogT3V0IG9mIG1lbW9yeSIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWN0eF9sZW4gPSBjb25mLT5rZXlfbGVuICsgc2l6ZW9mKGtheS0+ZGlzdF9rbik7CisJZGxfbGlzdF9mb3JfZWFjaChwZWVyLCAmcGFydGljaXBhbnQtPmxpdmVfcGVlcnMsCisJCQkgc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIsIGxpc3QpCisJCWN0eF9sZW4gKz0gc2l6ZW9mKHBlZXItPm1pKTsKKwljdHhfbGVuICs9IHNpemVvZihwYXJ0aWNpcGFudC0+bWkpOworCisJY29udGV4dCA9IG9zX3phbGxvYyhjdHhfbGVuKTsKKwlpZiAoIWNvbnRleHQpIHsKKwkJb3NfZnJlZShjb25mLT5rZXkpOworCQlvc19mcmVlKGNvbmYpOworCQlyZXR1cm4gLTE7CisJfQorCWN0eF9vZmZzZXQgPSAwOworCW9zX2dldF9yYW5kb20oY29udGV4dCArIGN0eF9vZmZzZXQsIGNvbmYtPmtleV9sZW4pOworCWN0eF9vZmZzZXQgKz0gY29uZi0+a2V5X2xlbjsKKwlkbF9saXN0X2Zvcl9lYWNoKHBlZXIsICZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywKKwkJCSBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCkgeworCQlvc19tZW1jcHkoY29udGV4dCArIGN0eF9vZmZzZXQsIHBlZXItPm1pLCBzaXplb2YocGVlci0+bWkpKTsKKwkJY3R4X29mZnNldCArPSBzaXplb2YocGVlci0+bWkpOworCX0KKwlvc19tZW1jcHkoY29udGV4dCArIGN0eF9vZmZzZXQsIHBhcnRpY2lwYW50LT5taSwKKwkJICBzaXplb2YocGFydGljaXBhbnQtPm1pKSk7CisJY3R4X29mZnNldCArPSBzaXplb2YocGFydGljaXBhbnQtPm1pKTsKKwlvc19tZW1jcHkoY29udGV4dCArIGN0eF9vZmZzZXQsICZrYXktPmRpc3Rfa24sIHNpemVvZihrYXktPmRpc3Rfa24pKTsKKworCWlmIChjb25mLT5rZXlfbGVuID09IDE2KSB7CisJCWllZWU4MDJfMXhfc2FrXzEyOGJpdHNfYWVzX2NtYWMocGFydGljaXBhbnQtPmNhay5rZXksCisJCQkJCQljb250ZXh0LCBjdHhfbGVuLCBjb25mLT5rZXkpOworCX0gZWxzZSBpZiAoY29uZi0+a2V5X2xlbiA9PSAzMikgeworCQlpZWVlODAyXzF4X3Nha18xMjhiaXRzX2Flc19jbWFjKHBhcnRpY2lwYW50LT5jYWsua2V5LAorCQkJCQkJY29udGV4dCwgY3R4X2xlbiwgY29uZi0+a2V5KTsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogU0FLIExlbmd0aCBub3Qgc3VwcG9ydCIpOworCQlvc19mcmVlKGNvbmYtPmtleSk7CisJCW9zX2ZyZWUoY29uZik7CisJCW9zX2ZyZWUoY29udGV4dCk7CisJCXJldHVybiAtMTsKKwl9CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiS2FZOiBnZW5lcmF0ZWQgbmV3IFNBSyIsCisJCSAgICBjb25mLT5rZXksIGNvbmYtPmtleV9sZW4pOworCisJb3NfbWVtY3B5KGNvbmYtPmtpLm1pLCBwYXJ0aWNpcGFudC0+bWksIE1JX0xFTik7CisJY29uZi0+a2kua24gPSBwYXJ0aWNpcGFudC0+a2F5LT5kaXN0X2tuOworCWNvbmYtPmFuID0gcGFydGljaXBhbnQtPmtheS0+ZGlzdF9hbjsKKwljb25mLT5vZmZzZXQgPSBrYXktPm1hY3NlY19jb25maWRlbnRpYWxpdHk7CisJY29uZi0+cnggPSBUUlVFOworCWNvbmYtPnR4ID0gVFJVRTsKKworCXNhX2tleSA9IGllZWU4MDJfMXhfa2F5X2luaXRfZGF0YV9rZXkoY29uZik7CisJaWYgKCFzYV9rZXkpIHsKKwkJb3NfZnJlZShjb25mLT5rZXkpOworCQlvc19mcmVlKGNvbmYpOworCQlvc19mcmVlKGNvbnRleHQpOworCQlyZXR1cm4gLTE7CisJfQorCXBhcnRpY2lwYW50LT5uZXdfa2V5ID0gc2Ffa2V5OworCisJZGxfbGlzdF9hZGQoJnBhcnRpY2lwYW50LT5zYWtfbGlzdCwgJnNhX2tleS0+bGlzdCk7CisJaWVlZTgwMl8xeF9jcF9zZXRfY2lwaGVyc3VpdGUocGFydGljaXBhbnQtPmtheS0+Y3AsCisJCQkJICAgICAgY2lwaGVyX3N1aXRlX3RibFtrYXktPm1hY3NlY19jc2luZGV4XS5pZCk7CisJaWVlZTgwMl8xeF9jcF9zbV9zdGVwKGtheS0+Y3ApOworCWllZWU4MDJfMXhfY3Bfc2V0X29mZnNldChrYXktPmNwLCBjb25mLT5vZmZzZXQpOworCWllZWU4MDJfMXhfY3Bfc21fc3RlcChrYXktPmNwKTsKKwlpZWVlODAyXzF4X2NwX3NldF9kaXN0cmlidXRlZGtpKGtheS0+Y3AsICZjb25mLT5raSk7CisJaWVlZTgwMl8xeF9jcF9zZXRfZGlzdHJpYnV0ZWRhbihrYXktPmNwLCBjb25mLT5hbik7CisJaWVlZTgwMl8xeF9jcF9zaWduYWxfbmV3c2FrKGtheS0+Y3ApOworCWllZWU4MDJfMXhfY3Bfc21fc3RlcChrYXktPmNwKTsKKworCWRsX2xpc3RfZm9yX2VhY2gocGVlciwgJnBhcnRpY2lwYW50LT5saXZlX3BlZXJzLAorCQkJIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyLCBsaXN0KQorCQlwZWVyLT5zYWtfdXNlZCA9IEZBTFNFOworCisJcGFydGljaXBhbnQtPmtheS0+ZGlzdF9rbisrOworCXBhcnRpY2lwYW50LT5rYXktPmRpc3RfYW4rKzsKKwlpZiAocGFydGljaXBhbnQtPmtheS0+ZGlzdF9hbiA+IDMpCisJCXBhcnRpY2lwYW50LT5rYXktPmRpc3RfYW4gPSAwOworCisJcGFydGljaXBhbnQtPmtheS0+ZGlzdF90aW1lID0gdGltZShOVUxMKTsKKworCW9zX2ZyZWUoY29uZi0+a2V5KTsKKwlvc19mcmVlKGNvbmYpOworCW9zX2ZyZWUoY29udGV4dCk7CisJcmV0dXJuIDA7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9lbGVjdF9rZXlfc2VydmVyIC0gZWxlY3QgdGhlIGtleSBzZXJ2ZXIKKyAqIHdoZW4gdG8gZWxlY3Q6IHdoZW5ldmVyIHRoZSBsaXZlIHBlZXJzIGxpc3QgY2hhbmdlcworICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X2theV9lbGVjdF9rZXlfc2VydmVyKHN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKnBlZXI7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKmtleV9zZXJ2ZXIgPSBOVUxMOworCXN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5ID0gcGFydGljaXBhbnQtPmtheTsKKwlCb29sZWFuIGlfaXNfa2V5X3NlcnZlcjsKKwlpbnQgaTsKKworCWlmIChwYXJ0aWNpcGFudC0+aXNfb2JsaWdlZF9rZXlfc2VydmVyKSB7CisJCXBhcnRpY2lwYW50LT5uZXdfc2FrID0gVFJVRTsKKwkJcGFydGljaXBhbnQtPnRvX2Rpc3Rfc2FrID0gRkFMU0U7CisJCWllZWU4MDJfMXhfY3Bfc2V0X2VsZWN0ZWRzZWxmKGtheS0+Y3AsIFRSVUUpOworCQlyZXR1cm4gMDsKKwl9CisKKwkvKiBlbGVjdCB0aGUga2V5IHNlcnZlciBhbW9uZyB0aGUgcGVlcnMgKi8KKwlkbF9saXN0X2Zvcl9lYWNoKHBlZXIsICZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywKKwkJCSBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCkgeworCQlpZiAoIXBlZXItPmlzX2tleV9zZXJ2ZXIpCisJCQljb250aW51ZTsKKworCQlpZiAoIWtleV9zZXJ2ZXIpIHsKKwkJCWtleV9zZXJ2ZXIgPSBwZWVyOworCQkJY29udGludWU7CisJCX0KKworCQlpZiAocGVlci0+a2V5X3NlcnZlcl9wcmlvcml0eSA8CisJCSAgICBrZXlfc2VydmVyLT5rZXlfc2VydmVyX3ByaW9yaXR5KSB7CisJCQlrZXlfc2VydmVyID0gcGVlcjsKKwkJfSBlbHNlIGlmIChwZWVyLT5rZXlfc2VydmVyX3ByaW9yaXR5ID09CisJCQkgICBrZXlfc2VydmVyLT5rZXlfc2VydmVyX3ByaW9yaXR5KSB7CisJCQlmb3IgKGkgPSAwOyBpIDwgNjsgaSsrKSB7CisJCQkJaWYgKHBlZXItPnNjaS5hZGRyW2ldIDwKKwkJCQkgICAga2V5X3NlcnZlci0+c2NpLmFkZHJbaV0pCisJCQkJCWtleV9zZXJ2ZXIgPSBwZWVyOworCQkJfQorCQl9CisJfQorCisJLyogZWxlY3QgdGhlIGtleSBzZXJ2ZXIgYmV0d2VlbiBtZSBhbmQgdGhlIGFib3ZlIGVsZWN0ZWQgcGVlciAqLworCWlfaXNfa2V5X3NlcnZlciA9IEZBTFNFOworCWlmIChrZXlfc2VydmVyICYmIHBhcnRpY2lwYW50LT5jYW5fYmVfa2V5X3NlcnZlcikgeworCQlpZiAoa2F5LT5hY3Rvcl9wcmlvcml0eQorCQkJICAgPCBrZXlfc2VydmVyLT5rZXlfc2VydmVyX3ByaW9yaXR5KSB7CisJCQlpX2lzX2tleV9zZXJ2ZXIgPSBUUlVFOworCQl9IGVsc2UgaWYgKGtheS0+YWN0b3JfcHJpb3JpdHkKKwkJCQkJPT0ga2V5X3NlcnZlci0+a2V5X3NlcnZlcl9wcmlvcml0eSkgeworCQkJZm9yIChpID0gMDsgaSA8IDY7IGkrKykgeworCQkJCWlmIChrYXktPmFjdG9yX3NjaS5hZGRyW2ldCisJCQkJCTwga2V5X3NlcnZlci0+c2NpLmFkZHJbaV0pIHsKKwkJCQkJaV9pc19rZXlfc2VydmVyID0gVFJVRTsKKwkJCQl9CisJCQl9CisJCX0KKwl9CisKKwlpZiAoIWtleV9zZXJ2ZXIgJiYgIWlfaXNfa2V5X3NlcnZlcikgeworCQlwYXJ0aWNpcGFudC0+cHJpbmNpcGFsID0gRkFMU0U7CisJCXBhcnRpY2lwYW50LT5pc19rZXlfc2VydmVyID0gRkFMU0U7CisJCXBhcnRpY2lwYW50LT5pc19lbGVjdGVkID0gRkFMU0U7CisJCXJldHVybiAwOworCX0KKworCWlmIChpX2lzX2tleV9zZXJ2ZXIpIHsKKwkJaWVlZTgwMl8xeF9jcF9zZXRfZWxlY3RlZHNlbGYoa2F5LT5jcCwgVFJVRSk7CisJCWlmIChvc19tZW1jbXAoJmtheS0+a2V5X3NlcnZlcl9zY2ksICZrYXktPmFjdG9yX3NjaSwKKwkJCSAgICAgIHNpemVvZihrYXktPmtleV9zZXJ2ZXJfc2NpKSkpIHsKKwkJCWllZWU4MDJfMXhfY3Bfc2lnbmFsX2NoZ2RzZXJ2ZXIoa2F5LT5jcCk7CisJCQlpZWVlODAyXzF4X2NwX3NtX3N0ZXAoa2F5LT5jcCk7CisJCX0KKworCQlwYXJ0aWNpcGFudC0+aXNfa2V5X3NlcnZlciA9IFRSVUU7CisJCXBhcnRpY2lwYW50LT5wcmluY2lwYWwgPSBUUlVFOworCQlwYXJ0aWNpcGFudC0+bmV3X3NhayA9IFRSVUU7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiS2FZOiBJIGlzIGVsZWN0ZWQgYXMga2V5IHNlcnZlciIpOworCQlwYXJ0aWNpcGFudC0+dG9fZGlzdF9zYWsgPSBGQUxTRTsKKwkJcGFydGljaXBhbnQtPmlzX2VsZWN0ZWQgPSBUUlVFOworCisJCW9zX21lbWNweSgma2F5LT5rZXlfc2VydmVyX3NjaSwgJmtheS0+YWN0b3Jfc2NpLAorCQkJICBzaXplb2Yoa2F5LT5rZXlfc2VydmVyX3NjaSkpOworCQlrYXktPmtleV9zZXJ2ZXJfcHJpb3JpdHkgPSBrYXktPmFjdG9yX3ByaW9yaXR5OworCX0KKworCWlmIChrZXlfc2VydmVyKSB7CisJCWllZWU4MDJfMXhfY3Bfc2V0X2VsZWN0ZWRzZWxmKGtheS0+Y3AsIEZBTFNFKTsKKwkJaWYgKG9zX21lbWNtcCgma2F5LT5rZXlfc2VydmVyX3NjaSwgJmtleV9zZXJ2ZXItPnNjaSwKKwkJCSAgICAgIHNpemVvZihrYXktPmtleV9zZXJ2ZXJfc2NpKSkpIHsKKwkJCWllZWU4MDJfMXhfY3Bfc2lnbmFsX2NoZ2RzZXJ2ZXIoa2F5LT5jcCk7CisJCQlpZWVlODAyXzF4X2NwX3NtX3N0ZXAoa2F5LT5jcCk7CisJCX0KKworCQlwYXJ0aWNpcGFudC0+aXNfa2V5X3NlcnZlciA9IEZBTFNFOworCQlwYXJ0aWNpcGFudC0+cHJpbmNpcGFsID0gVFJVRTsKKwkJcGFydGljaXBhbnQtPmlzX2VsZWN0ZWQgPSBUUlVFOworCisJCW9zX21lbWNweSgma2F5LT5rZXlfc2VydmVyX3NjaSwgJmtleV9zZXJ2ZXItPnNjaSwKKwkJCSAgc2l6ZW9mKGtheS0+a2V5X3NlcnZlcl9zY2kpKTsKKwkJa2F5LT5rZXlfc2VydmVyX3ByaW9yaXR5ID0ga2V5X3NlcnZlci0+a2V5X3NlcnZlcl9wcmlvcml0eTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2RlY2lkZV9tYWNzZWNfdXNlIC0gdGhlIGtleSBzZXJ2ZXIgZGV0ZXJtaW5hdGUKKyAqCQkgaG93IHRvIHVzZSBNQUNzZWM6IHdoZXRoZXIgdXNlIE1BQ3NlYyBhbmQgaXRzIGNhcGFiaWxpdHkKKyAqIHByb3RlY3RGcmFtZXMgd2lsbCBiZSBhZHZpc2VkIGlmIHRoZSBrZXkgc2VydmVyIGFuZCBvbmUgb2YgaXRzIGxpdmUgcGVlcnMgYXJlCisgKiBNQUNzZWMgY2FwYWJsZSBhbmQgb25lIG9mIHRob3NlIHJlcXVlc3QgTUFDc2VjIHByb3RlY3Rpb24KKyAqLworc3RhdGljIGludAoraWVlZTgwMl8xeF9rYXlfZGVjaWRlX21hY3NlY191c2UoCisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSA9IHBhcnRpY2lwYW50LT5rYXk7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgKnBlZXI7CisJZW51bSBtYWNzZWNfY2FwIGxlc3NfY2FwYWJpbGl0eTsKKwlCb29sZWFuIGhhc19wZWVyOworCisJaWYgKCFwYXJ0aWNpcGFudC0+aXNfa2V5X3NlcnZlcikKKwkJcmV0dXJuIC0xOworCisJLyoga2V5IHNlcnZlciBzZWxmIGlzIE1BQ3NlYy1kZXNpcmVkIGFuZCByZXF1ZXN0aW5nIE1BQ3NlYyAqLworCWlmICgha2F5LT5tYWNzZWNfZGVzaXJlZCkgeworCQlwYXJ0aWNpcGFudC0+YWR2aXNlZF9kZXNpcmVkID0gRkFMU0U7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKGtheS0+bWFjc2VjX2NhcGFibGUgPT0gTUFDU0VDX0NBUF9OT1RfSU1QTEVNRU5URUQpIHsKKwkJcGFydGljaXBhbnQtPmFkdmlzZWRfZGVzaXJlZCA9IEZBTFNFOworCQlyZXR1cm4gLTE7CisJfQorCWxlc3NfY2FwYWJpbGl0eSA9IGtheS0+bWFjc2VjX2NhcGFibGU7CisKKwkvKiBhdCBsZWFzdCBvbmUgb2YgcGVlcnMgaXMgTUFDc2VjLWRlc2lyZWQgYW5kIHJlcXVlc3RpbmcgTUFDc2VjICovCisJaGFzX3BlZXIgPSBGQUxTRTsKKwlkbF9saXN0X2Zvcl9lYWNoKHBlZXIsICZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywKKwkJCSBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCkgeworCQlpZiAoIXBlZXItPm1hY3NlY19kZXNpcmVkKQorCQkJY29udGludWU7CisKKwkJaWYgKHBlZXItPm1hY3NlY19jYXBiaWxpdHkgPT0gTUFDU0VDX0NBUF9OT1RfSU1QTEVNRU5URUQpCisJCQljb250aW51ZTsKKworCQlsZXNzX2NhcGFiaWxpdHkgPSAobGVzc19jYXBhYmlsaXR5IDwgcGVlci0+bWFjc2VjX2NhcGJpbGl0eSkgPworCQkJbGVzc19jYXBhYmlsaXR5IDogcGVlci0+bWFjc2VjX2NhcGJpbGl0eTsKKwkJaGFzX3BlZXIgPSBUUlVFOworCX0KKworCWlmIChoYXNfcGVlcikgeworCQlwYXJ0aWNpcGFudC0+YWR2aXNlZF9kZXNpcmVkID0gVFJVRTsKKwkJcGFydGljaXBhbnQtPmFkdmlzZWRfY2FwYWJpbGl0eSA9IGxlc3NfY2FwYWJpbGl0eTsKKwkJa2F5LT5hdXRoZW50aWNhdGVkID0gRkFMU0U7CisJCWtheS0+c2VjdXJlZCA9IFRSVUU7CisJCWtheS0+ZmFpbGVkID0gRkFMU0U7CisJCWllZWU4MDJfMXhfY3BfY29ubmVjdF9zZWN1cmUoa2F5LT5jcCk7CisJCWllZWU4MDJfMXhfY3Bfc21fc3RlcChrYXktPmNwKTsKKwl9IGVsc2UgeworCQlwYXJ0aWNpcGFudC0+YWR2aXNlZF9kZXNpcmVkID0gRkFMU0U7CisJCXBhcnRpY2lwYW50LT5hZHZpc2VkX2NhcGFiaWxpdHkgPSBNQUNTRUNfQ0FQX05PVF9JTVBMRU1FTlRFRDsKKwkJcGFydGljaXBhbnQtPnRvX3VzZV9zYWsgPSBGQUxTRTsKKwkJa2F5LT5hdXRoZW50aWNhdGVkID0gVFJVRTsKKwkJa2F5LT5zZWN1cmVkID0gRkFMU0U7CisJCWtheS0+ZmFpbGVkID0gRkFMU0U7CisJCWtheS0+bHR4X2tuID0gMDsKKwkJa2F5LT5sdHhfYW4gPSAwOworCQlrYXktPmxyeF9rbiA9IDA7CisJCWtheS0+bHJ4X2FuID0gMDsKKwkJa2F5LT5vdHhfa24gPSAwOworCQlrYXktPm90eF9hbiA9IDA7CisJCWtheS0+b3J4X2tuID0gMDsKKwkJa2F5LT5vcnhfYW4gPSAwOworCQlpZWVlODAyXzF4X2NwX2Nvbm5lY3RfYXV0aGVudGljYXRlZChrYXktPmNwKTsKKwkJaWVlZTgwMl8xeF9jcF9zbV9zdGVwKGtheS0+Y3ApOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3QgdTggcGFlX2dyb3VwX2FkZHJbRVRIX0FMRU5dID0geworCTB4MDEsIDB4ODAsIDB4YzIsIDB4MDAsIDB4MDAsIDB4MDMKK307CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9lbmNvZGVfbWtwZHUgLQorICovCitzdGF0aWMgaW50CitpZWVlODAyXzF4X2theV9lbmNvZGVfbWtwZHUoc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudCwKKwkJCSAgICBzdHJ1Y3Qgd3BhYnVmICpwYnVmKQoreworCXVuc2lnbmVkIGludCBpOworCXN0cnVjdCBpZWVlODAyM19oZHIgKmV0aGVyX2hkcjsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9oZHIgKmVhcG9sX2hkcjsKKworCWV0aGVyX2hkciA9IHdwYWJ1Zl9wdXQocGJ1Ziwgc2l6ZW9mKCpldGhlcl9oZHIpKTsKKwlvc19tZW1jcHkoZXRoZXJfaGRyLT5kZXN0LCBwYWVfZ3JvdXBfYWRkciwgc2l6ZW9mKGV0aGVyX2hkci0+ZGVzdCkpOworCW9zX21lbWNweShldGhlcl9oZHItPnNyYywgcGFydGljaXBhbnQtPmtheS0+YWN0b3Jfc2NpLmFkZHIsCisJCSAgc2l6ZW9mKGV0aGVyX2hkci0+ZGVzdCkpOworCWV0aGVyX2hkci0+ZXRoZXJ0eXBlID0gaG9zdF90b19iZTE2KEVUSF9QX0VBUE9MKTsKKworCWVhcG9sX2hkciA9IHdwYWJ1Zl9wdXQocGJ1Ziwgc2l6ZW9mKCplYXBvbF9oZHIpKTsKKwllYXBvbF9oZHItPnZlcnNpb24gPSBFQVBPTF9WRVJTSU9OOworCWVhcG9sX2hkci0+dHlwZSA9IElFRUU4MDJfMVhfVFlQRV9FQVBPTF9NS0E7CisJZWFwb2xfaGRyLT5sZW5ndGggPSBob3N0X3RvX2JlMTYocGJ1Zi0+c2l6ZSAtIHBidWYtPnVzZWQpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUobWFrX2JvZHlfaGFuZGxlcik7IGkrKykgeworCQlpZiAobWFrX2JvZHlfaGFuZGxlcltpXS5ib2R5X3ByZXNlbnQgJiYKKwkJICAgIG1ha19ib2R5X2hhbmRsZXJbaV0uYm9keV9wcmVzZW50KHBhcnRpY2lwYW50KSkgeworCQkJaWYgKG1ha19ib2R5X2hhbmRsZXJbaV0uYm9keV90eChwYXJ0aWNpcGFudCwgcGJ1ZikpCisJCQkJcmV0dXJuIC0xOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogaWVlZTgwMl8xeF9wYXJ0aWNpcGFudF9zZW5kX21rcGR1IC0KKyAqLworc3RhdGljIGludAoraWVlZTgwMl8xeF9wYXJ0aWNpcGFudF9zZW5kX21rcGR1KAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQpCit7CisJc3RydWN0IHdwYWJ1ZiAqYnVmOworCXN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5ID0gcGFydGljaXBhbnQtPmtheTsKKwlzaXplX3QgbGVuZ3RoID0gMDsKKwl1bnNpZ25lZCBpbnQgaTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiS2FZOiB0byBlbnBhY2tldCBhbmQgc2VuZCB0aGUgTUtQRFUiKTsKKwlsZW5ndGggKz0gc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X2hkcikgKyBzaXplb2Yoc3RydWN0IGllZWU4MDIzX2hkcik7CisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUobWFrX2JvZHlfaGFuZGxlcik7IGkrKykgeworCQlpZiAobWFrX2JvZHlfaGFuZGxlcltpXS5ib2R5X3ByZXNlbnQgJiYKKwkJICAgIG1ha19ib2R5X2hhbmRsZXJbaV0uYm9keV9wcmVzZW50KHBhcnRpY2lwYW50KSkKKwkJCWxlbmd0aCArPSBtYWtfYm9keV9oYW5kbGVyW2ldLmJvZHlfbGVuZ3RoKHBhcnRpY2lwYW50KTsKKwl9CisKKwlidWYgPSB3cGFidWZfYWxsb2MobGVuZ3RoKTsKKwlpZiAoIWJ1ZikgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogb3V0IG9mIG1lbW9yeSIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGllZWU4MDJfMXhfa2F5X2VuY29kZV9ta3BkdShwYXJ0aWNpcGFudCwgYnVmKSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogZW5jb2RlIG1rcGR1IGZhaWwhIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlsMl9wYWNrZXRfc2VuZChrYXktPmwyX21rYSwgTlVMTCwgMCwgd3BhYnVmX2hlYWQoYnVmKSwgd3BhYnVmX2xlbihidWYpKTsKKwl3cGFidWZfZnJlZShidWYpOworCisJa2F5LT5hY3RpdmUgPSBUUlVFOworCXBhcnRpY2lwYW50LT5hY3RpdmUgPSBUUlVFOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQgaWVlZTgwMl8xeF9rYXlfZGVpbml0X3RyYW5zbWl0X3NhKHN0cnVjdCB0cmFuc21pdF9zYSAqcHNhKTsKKy8qKgorICogaWVlZTgwMl8xeF9wYXJ0aWNpcGFudF90aW1lciAtCisgKi8KK3N0YXRpYyB2b2lkIGllZWU4MDJfMXhfcGFydGljaXBhbnRfdGltZXIodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50OworCXN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5OworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyLCAqcHJlX3BlZXI7CisJdGltZV90IG5vdyA9IHRpbWUoTlVMTCk7CisJQm9vbGVhbiBscF9jaGFuZ2VkOworCXN0cnVjdCByZWNlaXZlX3NjICpyeHNjLCAqcHJlX3J4c2M7CisJc3RydWN0IHRyYW5zbWl0X3NhICp0eHNhLCAqcHJlX3R4c2E7CisKKwlwYXJ0aWNpcGFudCA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKillbG9vcF9jdHg7CisJa2F5ID0gcGFydGljaXBhbnQtPmtheTsKKwlpZiAocGFydGljaXBhbnQtPmNha19saWZlKSB7CisJCWlmIChub3cgPiBwYXJ0aWNpcGFudC0+Y2FrX2xpZmUpIHsKKwkJCWtheS0+YXV0aGVudGljYXRlZCA9IEZBTFNFOworCQkJa2F5LT5zZWN1cmVkID0gRkFMU0U7CisJCQlrYXktPmZhaWxlZCA9IFRSVUU7CisJCQlpZWVlODAyXzF4X2theV9kZWxldGVfbWthKGtheSwgJnBhcnRpY2lwYW50LT5ja24pOworCQkJcmV0dXJuOworCQl9CisJfQorCisJLyogc2hvdWxkIGRlbGV0ZSBNS0EgaW5zdGFuY2UgaWYgdGhlcmUgYXJlIG5vdCBsaXZlIHBlZXJzCisJICogd2hlbiB0aGUgTUtBIGxpZmUgZWxhcHNlZCBzaW5jZSBpdHMgY3JlYXRpbmcgKi8KKwlpZiAocGFydGljaXBhbnQtPm1rYV9saWZlKSB7CisJCWlmIChkbF9saXN0X2VtcHR5KCZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycykpIHsKKwkJCWlmIChub3cgPiBwYXJ0aWNpcGFudC0+bWthX2xpZmUpIHsKKwkJCQlrYXktPmF1dGhlbnRpY2F0ZWQgPSBGQUxTRTsKKwkJCQlrYXktPnNlY3VyZWQgPSBGQUxTRTsKKwkJCQlrYXktPmZhaWxlZCA9IFRSVUU7CisJCQkJaWVlZTgwMl8xeF9rYXlfZGVsZXRlX21rYShrYXksCisJCQkJCQkJICAmcGFydGljaXBhbnQtPmNrbik7CisJCQkJcmV0dXJuOworCQkJfQorCQl9IGVsc2UgeworCQkJcGFydGljaXBhbnQtPm1rYV9saWZlID0gMDsKKwkJfQorCX0KKworCWxwX2NoYW5nZWQgPSBGQUxTRTsKKwlkbF9saXN0X2Zvcl9lYWNoX3NhZmUocGVlciwgcHJlX3BlZXIsICZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycywKKwkJCSAgICAgIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyLCBsaXN0KSB7CisJCWlmIChub3cgPiBwZWVyLT5leHBpcmUpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiS2FZOiBMaXZlIHBlZXIgcmVtb3ZlZCIpOworCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiXHRNSTogIiwgcGVlci0+bWksCisJCQkJICAgIHNpemVvZihwZWVyLT5taSkpOworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJcdE1OOiAlZCIsIHBlZXItPm1uKTsKKwkJCWRsX2xpc3RfZm9yX2VhY2hfc2FmZShyeHNjLCBwcmVfcnhzYywKKwkJCQkJICAgICAgJnBhcnRpY2lwYW50LT5yeHNjX2xpc3QsCisJCQkJCSAgICAgIHN0cnVjdCByZWNlaXZlX3NjLCBsaXN0KSB7CisJCQkJaWYgKG9zX21lbWNtcCgmcnhzYy0+c2NpLCAmcGVlci0+c2NpLAorCQkJCQkgICAgICBzaXplb2YocnhzYy0+c2NpKSkgPT0gMCkgeworCQkJCQlzZWN5X2RlbGV0ZV9yZWNlaXZlX3NjKGtheSwgcnhzYyk7CisJCQkJCWllZWU4MDJfMXhfa2F5X2RlaW5pdF9yZWNlaXZlX3NjKAorCQkJCQkJcGFydGljaXBhbnQsIHJ4c2MpOworCQkJCX0KKwkJCX0KKwkJCWRsX2xpc3RfZGVsKCZwZWVyLT5saXN0KTsKKwkJCW9zX2ZyZWUocGVlcik7CisJCQlscF9jaGFuZ2VkID0gVFJVRTsKKwkJfQorCX0KKworCWlmIChscF9jaGFuZ2VkKSB7CisJCWlmIChkbF9saXN0X2VtcHR5KCZwYXJ0aWNpcGFudC0+bGl2ZV9wZWVycykpIHsKKwkJCXBhcnRpY2lwYW50LT5hZHZpc2VkX2Rlc2lyZWQgPSBGQUxTRTsKKwkJCXBhcnRpY2lwYW50LT5hZHZpc2VkX2NhcGFiaWxpdHkgPQorCQkJCU1BQ1NFQ19DQVBfTk9UX0lNUExFTUVOVEVEOworCQkJcGFydGljaXBhbnQtPnRvX3VzZV9zYWsgPSBGQUxTRTsKKwkJCWtheS0+YXV0aGVudGljYXRlZCA9IFRSVUU7CisJCQlrYXktPnNlY3VyZWQgPSBGQUxTRTsKKwkJCWtheS0+ZmFpbGVkID0gRkFMU0U7CisJCQlrYXktPmx0eF9rbiA9IDA7CisJCQlrYXktPmx0eF9hbiA9IDA7CisJCQlrYXktPmxyeF9rbiA9IDA7CisJCQlrYXktPmxyeF9hbiA9IDA7CisJCQlrYXktPm90eF9rbiA9IDA7CisJCQlrYXktPm90eF9hbiA9IDA7CisJCQlrYXktPm9yeF9rbiA9IDA7CisJCQlrYXktPm9yeF9hbiA9IDA7CisJCQlkbF9saXN0X2Zvcl9lYWNoX3NhZmUodHhzYSwgcHJlX3R4c2EsCisJCQkJCSAgICAgICZwYXJ0aWNpcGFudC0+dHhzYy0+c2FfbGlzdCwKKwkJCQkJICAgICAgc3RydWN0IHRyYW5zbWl0X3NhLCBsaXN0KSB7CisJCQkJc2VjeV9kaXNhYmxlX3RyYW5zbWl0X3NhKGtheSwgdHhzYSk7CisJCQkJaWVlZTgwMl8xeF9rYXlfZGVpbml0X3RyYW5zbWl0X3NhKHR4c2EpOworCQkJfQorCisJCQlpZWVlODAyXzF4X2NwX2Nvbm5lY3RfYXV0aGVudGljYXRlZChrYXktPmNwKTsKKwkJCWllZWU4MDJfMXhfY3Bfc21fc3RlcChrYXktPmNwKTsKKwkJfSBlbHNlIHsKKwkJCWllZWU4MDJfMXhfa2F5X2VsZWN0X2tleV9zZXJ2ZXIocGFydGljaXBhbnQpOworCQkJaWVlZTgwMl8xeF9rYXlfZGVjaWRlX21hY3NlY191c2UocGFydGljaXBhbnQpOworCQl9CisJfQorCisJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKHBlZXIsIHByZV9wZWVyLCAmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycywKKwkJCSAgICAgIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyLCBsaXN0KSB7CisJCWlmIChub3cgPiBwZWVyLT5leHBpcmUpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiS2FZOiBQb3RlbnRpYWwgcGVlciByZW1vdmVkIik7CisJCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJcdE1JOiAiLCBwZWVyLT5taSwKKwkJCQkgICAgc2l6ZW9mKHBlZXItPm1pKSk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlx0TU46ICVkIiwgcGVlci0+bW4pOworCQkJZGxfbGlzdF9kZWwoJnBlZXItPmxpc3QpOworCQkJb3NfZnJlZShwZWVyKTsKKwkJfQorCX0KKworCWlmIChwYXJ0aWNpcGFudC0+bmV3X3NhaykgeworCQlpZiAoIWllZWU4MDJfMXhfa2F5X2dlbmVyYXRlX25ld19zYWsocGFydGljaXBhbnQpKQorCQkJcGFydGljaXBhbnQtPnRvX2Rpc3Rfc2FrID0gVFJVRTsKKworCQlwYXJ0aWNpcGFudC0+bmV3X3NhayA9IEZBTFNFOworCX0KKworCWlmIChwYXJ0aWNpcGFudC0+cmV0cnlfY291bnQgPCBNQVhfUkVUUllfQ05UKSB7CisJCWllZWU4MDJfMXhfcGFydGljaXBhbnRfc2VuZF9ta3BkdShwYXJ0aWNpcGFudCk7CisJCXBhcnRpY2lwYW50LT5yZXRyeV9jb3VudCsrOworCX0KKworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoTUtBX0hFTExPX1RJTUUgLyAxMDAwLCAwLAorCQkJICAgICAgIGllZWU4MDJfMXhfcGFydGljaXBhbnRfdGltZXIsCisJCQkgICAgICAgcGFydGljaXBhbnQsIE5VTEwpOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfaW5pdF90cmFuc21pdF9zYSAtCisgKi8KK3N0YXRpYyBzdHJ1Y3QgdHJhbnNtaXRfc2EgKgoraWVlZTgwMl8xeF9rYXlfaW5pdF90cmFuc21pdF9zYShzdHJ1Y3QgdHJhbnNtaXRfc2MgKnBzYywgdTggYW4sIHUzMiBuZXh0X1BOLAorCQkJCXN0cnVjdCBkYXRhX2tleSAqa2V5KQoreworCXN0cnVjdCB0cmFuc21pdF9zYSAqcHNhOworCisJa2V5LT50eF9sYXRlc3QgPSBUUlVFOworCWtleS0+cnhfbGF0ZXN0ID0gVFJVRTsKKworCXBzYSA9IG9zX3phbGxvYyhzaXplb2YoKnBzYSkpOworCWlmICghcHNhKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmIChrZXktPmNvbmZpZGVudGlhbGl0eV9vZmZzZXQgPj0gQ09ORklERU5USUFMSVRZX09GRlNFVF8wICYmCisJICAgIGtleS0+Y29uZmlkZW50aWFsaXR5X29mZnNldCA8PSBDT05GSURFTlRJQUxJVFlfT0ZGU0VUXzUwKQorCQlwc2EtPmNvbmZpZGVudGlhbGl0eSA9IFRSVUU7CisJZWxzZQorCQlwc2EtPmNvbmZpZGVudGlhbGl0eSA9IEZBTFNFOworCisJcHNhLT5hbiA9IGFuOworCXBzYS0+cGtleSA9IGtleTsKKwlwc2EtPm5leHRfcG4gPSBuZXh0X1BOOworCXBzYS0+c2MgPSBwc2M7CisKKwlvc19nZXRfdGltZSgmcHNhLT5jcmVhdGVkX3RpbWUpOworCXBzYS0+aW5fdXNlID0gRkFMU0U7CisKKwlkbF9saXN0X2FkZCgmcHNjLT5zYV9saXN0LCAmcHNhLT5saXN0KTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIkthWTogQ3JlYXRlIHRyYW5zbWl0IFNBKGFuOiAlZCwgbmV4dF9QTjogJXUpIG9mIFNDKGNoYW5uZWw6ICVkKSIsCisJCSAgIChpbnQpIGFuLCBuZXh0X1BOLCBwc2MtPmNoYW5uZWwpOworCisJcmV0dXJuIHBzYTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2RlaW5pdF90cmFuc21pdF9zYSAtCisgKi8KK3N0YXRpYyB2b2lkIGllZWU4MDJfMXhfa2F5X2RlaW5pdF90cmFuc21pdF9zYShzdHJ1Y3QgdHJhbnNtaXRfc2EgKnBzYSkKK3sKKwlwc2EtPnBrZXkgPSBOVUxMOworCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkgICAiS2FZOiBEZWxldGUgdHJhbnNtaXQgU0EoYW46ICVkKSBvZiBTQyhjaGFubmVsOiAlZCkiLAorCQkgICBwc2EtPmFuLCBwc2EtPnNjLT5jaGFubmVsKTsKKwlkbF9saXN0X2RlbCgmcHNhLT5saXN0KTsKKwlvc19mcmVlKHBzYSk7Cit9CisKKworLyoqCisgKiBpbml0X3RyYW5zbWl0X3NjIC0KKyAqLworc3RhdGljIHN0cnVjdCB0cmFuc21pdF9zYyAqCitpZWVlODAyXzF4X2theV9pbml0X3RyYW5zbWl0X3NjKGNvbnN0IHN0cnVjdCBpZWVlODAyXzF4X21rYV9zY2kgKnNjaSwKKwkJCQlpbnQgY2hhbm5lbCkKK3sKKwlzdHJ1Y3QgdHJhbnNtaXRfc2MgKnBzYzsKKworCXBzYyA9IG9zX3phbGxvYyhzaXplb2YoKnBzYykpOworCWlmICghcHNjKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBOVUxMOworCX0KKwlvc19tZW1jcHkoJnBzYy0+c2NpLCBzY2ksIHNpemVvZihwc2MtPnNjaSkpOworCXBzYy0+Y2hhbm5lbCA9IGNoYW5uZWw7CisKKwlvc19nZXRfdGltZSgmcHNjLT5jcmVhdGVkX3RpbWUpOworCXBzYy0+dHJhbnNtaXR0aW5nID0gRkFMU0U7CisJcHNjLT5lbmNvZGluZ19zYSA9IEZBTFNFOworCXBzYy0+ZW5jaXBoZXJpbmdfc2EgPSBGQUxTRTsKKworCWRsX2xpc3RfaW5pdCgmcHNjLT5zYV9saXN0KTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkthWTogQ3JlYXRlIHRyYW5zbWl0IFNDKGNoYW5uZWw6ICVkKSIsIGNoYW5uZWwpOworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlNDSTogIiwgKHU4ICopc2NpICwgc2l6ZW9mKCpzY2kpKTsKKworCXJldHVybiBwc2M7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9kZWluaXRfdHJhbnNtaXRfc2MgLQorICovCitzdGF0aWMgdm9pZAoraWVlZTgwMl8xeF9rYXlfZGVpbml0X3RyYW5zbWl0X3NjKAorCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQsIHN0cnVjdCB0cmFuc21pdF9zYyAqcHNjKQoreworCXN0cnVjdCB0cmFuc21pdF9zYSAqcHNhLCAqdG1wOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJLYVk6IERlbGV0ZSB0cmFuc21pdCBTQyhjaGFubmVsOiAlZCkiLAorCQkgICBwc2MtPmNoYW5uZWwpOworCWRsX2xpc3RfZm9yX2VhY2hfc2FmZShwc2EsIHRtcCwgJnBzYy0+c2FfbGlzdCwgc3RydWN0IHRyYW5zbWl0X3NhLAorCQkJICAgICAgbGlzdCkgeworCQlzZWN5X2Rpc2FibGVfdHJhbnNtaXRfc2EocGFydGljaXBhbnQtPmtheSwgcHNhKTsKKwkJaWVlZTgwMl8xeF9rYXlfZGVpbml0X3RyYW5zbWl0X3NhKHBzYSk7CisJfQorCisJb3NfZnJlZShwc2MpOworfQorCisKKy8qKioqKioqKioqKioqKioqKiogSW50ZXJmYWNlIGJldHdlZW4gQ1AgYW5kIEtBWSAqKioqKioqKioqKioqKioqKioqKiovCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X3NldF9sYXRlc3Rfc2FfYXR0ciAtCisgKi8KK2ludCBpZWVlODAyXzF4X2theV9zZXRfbGF0ZXN0X3NhX2F0dHIoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkJICAgICAgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpsa2ksIHU4IGxhbiwKKwkJCQkgICAgICBCb29sZWFuIGx0eCwgQm9vbGVhbiBscngpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwcmluY2lwYWw7CisKKwlwcmluY2lwYWwgPSBpZWVlODAyXzF4X2theV9nZXRfcHJpbmNpcGFsX3BhcnRpY2lwYW50KGtheSk7CisJaWYgKCFwcmluY2lwYWwpCisJCXJldHVybiAtMTsKKworCWlmICghbGtpKQorCQlvc19tZW1zZXQoJnByaW5jaXBhbC0+bGtpLCAwLCBzaXplb2YocHJpbmNpcGFsLT5sa2kpKTsKKwllbHNlCisJCW9zX21lbWNweSgmcHJpbmNpcGFsLT5sa2ksIGxraSwgc2l6ZW9mKHByaW5jaXBhbC0+bGtpKSk7CisKKwlwcmluY2lwYWwtPmxhbiA9IGxhbjsKKwlwcmluY2lwYWwtPmx0eCA9IGx0eDsKKwlwcmluY2lwYWwtPmxyeCA9IGxyeDsKKwlpZiAoIWxraSkgeworCQlrYXktPmx0eF9rbiA9IDA7CisJCWtheS0+bHJ4X2tuID0gMDsKKwl9IGVsc2UgeworCQlrYXktPmx0eF9rbiA9IGxraS0+a247CisJCWtheS0+bHJ4X2tuID0gbGtpLT5rbjsKKwl9CisJa2F5LT5sdHhfYW4gPSBsYW47CisJa2F5LT5scnhfYW4gPSBsYW47CisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X3NldF9vbGRfc2FfYXR0ciAtCisgKi8KK2ludCBpZWVlODAyXzF4X2theV9zZXRfb2xkX3NhX2F0dHIoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkJICAgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpva2ksCisJCQkJICAgdTggb2FuLCBCb29sZWFuIG90eCwgQm9vbGVhbiBvcngpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwcmluY2lwYWw7CisKKwlwcmluY2lwYWwgPSBpZWVlODAyXzF4X2theV9nZXRfcHJpbmNpcGFsX3BhcnRpY2lwYW50KGtheSk7CisJaWYgKCFwcmluY2lwYWwpCisJCXJldHVybiAtMTsKKworCWlmICghb2tpKQorCQlvc19tZW1zZXQoJnByaW5jaXBhbC0+b2tpLCAwLCBzaXplb2YocHJpbmNpcGFsLT5va2kpKTsKKwllbHNlCisJCW9zX21lbWNweSgmcHJpbmNpcGFsLT5va2ksIG9raSwgc2l6ZW9mKHByaW5jaXBhbC0+b2tpKSk7CisKKwlwcmluY2lwYWwtPm9hbiA9IG9hbjsKKwlwcmluY2lwYWwtPm90eCA9IG90eDsKKwlwcmluY2lwYWwtPm9yeCA9IG9yeDsKKworCWlmICghb2tpKSB7CisJCWtheS0+b3R4X2tuID0gMDsKKwkJa2F5LT5vcnhfa24gPSAwOworCX0gZWxzZSB7CisJCWtheS0+b3R4X2tuID0gb2tpLT5rbjsKKwkJa2F5LT5vcnhfa24gPSBva2ktPmtuOworCX0KKwlrYXktPm90eF9hbiA9IG9hbjsKKwlrYXktPm9yeF9hbiA9IG9hbjsKKworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfY3JlYXRlX3NhcyAtCisgKi8KK2ludCBpZWVlODAyXzF4X2theV9jcmVhdGVfc2FzKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgICAgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpsa2kpCit7CisJc3RydWN0IGRhdGFfa2V5ICpzYV9rZXksICpsYXRlc3Rfc2FrOworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcHJpbmNpcGFsOworCXN0cnVjdCByZWNlaXZlX3NjICpyeHNjOworCXN0cnVjdCByZWNlaXZlX3NhICpyeHNhOworCXN0cnVjdCB0cmFuc21pdF9zYSAqdHhzYTsKKworCXByaW5jaXBhbCA9IGllZWU4MDJfMXhfa2F5X2dldF9wcmluY2lwYWxfcGFydGljaXBhbnQoa2F5KTsKKwlpZiAoIXByaW5jaXBhbCkKKwkJcmV0dXJuIC0xOworCisJbGF0ZXN0X3NhayA9IE5VTEw7CisJZGxfbGlzdF9mb3JfZWFjaChzYV9rZXksICZwcmluY2lwYWwtPnNha19saXN0LCBzdHJ1Y3QgZGF0YV9rZXksIGxpc3QpIHsKKwkJaWYgKGlzX2tpX2VxdWFsKCZzYV9rZXktPmtleV9pZGVudGlmaWVyLCBsa2kpKSB7CisJCQlzYV9rZXktPnJ4X2xhdGVzdCA9IFRSVUU7CisJCQlzYV9rZXktPnR4X2xhdGVzdCA9IFRSVUU7CisJCQlsYXRlc3Rfc2FrID0gc2Ffa2V5OworCQkJcHJpbmNpcGFsLT50b191c2Vfc2FrID0gVFJVRTsKKwkJfSBlbHNlIHsKKwkJCXNhX2tleS0+cnhfbGF0ZXN0ID0gRkFMU0U7CisJCQlzYV9rZXktPnR4X2xhdGVzdCA9IEZBTFNFOworCQl9CisJfQorCWlmICghbGF0ZXN0X3NhaykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImxraSByZWxhdGVkIHNhayBub3QgZm91bmQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWRsX2xpc3RfZm9yX2VhY2gocnhzYywgJnByaW5jaXBhbC0+cnhzY19saXN0LCBzdHJ1Y3QgcmVjZWl2ZV9zYywgbGlzdCkgeworCQlyeHNhID0gaWVlZTgwMl8xeF9rYXlfaW5pdF9yZWNlaXZlX3NhKHJ4c2MsIGxhdGVzdF9zYWstPmFuLCAxLAorCQkJCQkJICAgICAgbGF0ZXN0X3Nhayk7CisJCWlmICghcnhzYSkKKwkJCXJldHVybiAtMTsKKworCQlzZWN5X2NyZWF0ZV9yZWNlaXZlX3NhKGtheSwgcnhzYSk7CisJfQorCisJdHhzYSA9IGllZWU4MDJfMXhfa2F5X2luaXRfdHJhbnNtaXRfc2EocHJpbmNpcGFsLT50eHNjLCBsYXRlc3Rfc2FrLT5hbiwKKwkJCQkJICAgICAgIDEsIGxhdGVzdF9zYWspOworCWlmICghdHhzYSkKKwkJcmV0dXJuIC0xOworCisJc2VjeV9jcmVhdGVfdHJhbnNtaXRfc2Eoa2F5LCB0eHNhKTsKKworCisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2RlbGV0ZV9zYXMgLQorICovCitpbnQgaWVlZTgwMl8xeF9rYXlfZGVsZXRlX3NhcyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCSAgICAgIHN0cnVjdCBpZWVlODAyXzF4X21rYV9raSAqa2kpCit7CisJc3RydWN0IGRhdGFfa2V5ICpzYV9rZXksICpwcmVfa2V5OworCXN0cnVjdCB0cmFuc21pdF9zYSAqdHhzYSwgKnByZV90eHNhOworCXN0cnVjdCByZWNlaXZlX3NhICpyeHNhLCAqcHJlX3J4c2E7CisJc3RydWN0IHJlY2VpdmVfc2MgKnJ4c2M7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwcmluY2lwYWw7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkthWTogRW50cnkgaW50byAlcyIsIF9fZnVuY19fKTsKKwlwcmluY2lwYWwgPSBpZWVlODAyXzF4X2theV9nZXRfcHJpbmNpcGFsX3BhcnRpY2lwYW50KGtheSk7CisJaWYgKCFwcmluY2lwYWwpCisJCXJldHVybiAtMTsKKworCS8qIHJlbW92ZSB0aGUgdHJhbnNtaXQgc2EgKi8KKwlkbF9saXN0X2Zvcl9lYWNoX3NhZmUodHhzYSwgcHJlX3R4c2EsICZwcmluY2lwYWwtPnR4c2MtPnNhX2xpc3QsCisJCQkgICAgICBzdHJ1Y3QgdHJhbnNtaXRfc2EsIGxpc3QpIHsKKwkJaWYgKGlzX2tpX2VxdWFsKCZ0eHNhLT5wa2V5LT5rZXlfaWRlbnRpZmllciwga2kpKSB7CisJCQlzZWN5X2Rpc2FibGVfdHJhbnNtaXRfc2Eoa2F5LCB0eHNhKTsKKwkJCWllZWU4MDJfMXhfa2F5X2RlaW5pdF90cmFuc21pdF9zYSh0eHNhKTsKKwkJfQorCX0KKworCS8qIHJlbW92ZSB0aGUgcmVjZWl2ZSBzYSAqLworCWRsX2xpc3RfZm9yX2VhY2gocnhzYywgJnByaW5jaXBhbC0+cnhzY19saXN0LCBzdHJ1Y3QgcmVjZWl2ZV9zYywgbGlzdCkgeworCQlkbF9saXN0X2Zvcl9lYWNoX3NhZmUocnhzYSwgcHJlX3J4c2EsICZyeHNjLT5zYV9saXN0LAorCQkJCSAgICAgIHN0cnVjdCByZWNlaXZlX3NhLCBsaXN0KSB7CisJCQlpZiAoaXNfa2lfZXF1YWwoJnJ4c2EtPnBrZXktPmtleV9pZGVudGlmaWVyLCBraSkpIHsKKwkJCQlzZWN5X2Rpc2FibGVfcmVjZWl2ZV9zYShrYXksIHJ4c2EpOworCQkJCWllZWU4MDJfMXhfa2F5X2RlaW5pdF9yZWNlaXZlX3NhKHJ4c2EpOworCQkJfQorCQl9CisJfQorCisJLyogcmVtb3ZlIHRoZSBzYWsgKi8KKwlkbF9saXN0X2Zvcl9lYWNoX3NhZmUoc2Ffa2V5LCBwcmVfa2V5LCAmcHJpbmNpcGFsLT5zYWtfbGlzdCwKKwkJCSAgICAgIHN0cnVjdCBkYXRhX2tleSwgbGlzdCkgeworCQlpZiAoaXNfa2lfZXF1YWwoJnNhX2tleS0+a2V5X2lkZW50aWZpZXIsIGtpKSkgeworCQkJaWVlZTgwMl8xeF9rYXlfZGVpbml0X2RhdGFfa2V5KHNhX2tleSk7CisJCQlicmVhazsKKwkJfQorCQlpZiAocHJpbmNpcGFsLT5uZXdfa2V5ID09IHNhX2tleSkKKwkJCXByaW5jaXBhbC0+bmV3X2tleSA9IE5VTEw7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9lbmFibGVfdHhfc2FzIC0KKyAqLworaW50IGllZWU4MDJfMXhfa2F5X2VuYWJsZV90eF9zYXMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkJIHN0cnVjdCBpZWVlODAyXzF4X21rYV9raSAqbGtpKQoreworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcHJpbmNpcGFsOworCXN0cnVjdCB0cmFuc21pdF9zYSAqdHhzYTsKKworCXByaW5jaXBhbCA9IGllZWU4MDJfMXhfa2F5X2dldF9wcmluY2lwYWxfcGFydGljaXBhbnQoa2F5KTsKKwlpZiAoIXByaW5jaXBhbCkKKwkJcmV0dXJuIC0xOworCisJZGxfbGlzdF9mb3JfZWFjaCh0eHNhLCAmcHJpbmNpcGFsLT50eHNjLT5zYV9saXN0LCBzdHJ1Y3QgdHJhbnNtaXRfc2EsCisJCQkgbGlzdCkgeworCQlpZiAoaXNfa2lfZXF1YWwoJnR4c2EtPnBrZXktPmtleV9pZGVudGlmaWVyLCBsa2kpKSB7CisJCQl0eHNhLT5pbl91c2UgPSBUUlVFOworCQkJc2VjeV9lbmFibGVfdHJhbnNtaXRfc2Eoa2F5LCB0eHNhKTsKKwkJCWllZWU4MDJfMXhfY3Bfc2V0X3VzaW5ndHJhbnNtaXRhcygKKwkJCQlwcmluY2lwYWwtPmtheS0+Y3AsIFRSVUUpOworCQkJaWVlZTgwMl8xeF9jcF9zbV9zdGVwKHByaW5jaXBhbC0+a2F5LT5jcCk7CisJCX0KKwl9CisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2VuYWJsZV9yeF9zYXMgLQorICovCitpbnQgaWVlZTgwMl8xeF9rYXlfZW5hYmxlX3J4X3NhcyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCQkgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpsa2kpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwcmluY2lwYWw7CisJc3RydWN0IHJlY2VpdmVfc2EgKnJ4c2E7CisJc3RydWN0IHJlY2VpdmVfc2MgKnJ4c2M7CisKKwlwcmluY2lwYWwgPSBpZWVlODAyXzF4X2theV9nZXRfcHJpbmNpcGFsX3BhcnRpY2lwYW50KGtheSk7CisJaWYgKCFwcmluY2lwYWwpCisJCXJldHVybiAtMTsKKworCWRsX2xpc3RfZm9yX2VhY2gocnhzYywgJnByaW5jaXBhbC0+cnhzY19saXN0LCBzdHJ1Y3QgcmVjZWl2ZV9zYywgbGlzdCkgeworCQlkbF9saXN0X2Zvcl9lYWNoKHJ4c2EsICZyeHNjLT5zYV9saXN0LCBzdHJ1Y3QgcmVjZWl2ZV9zYSwgbGlzdCkKKwkJeworCQkJaWYgKGlzX2tpX2VxdWFsKCZyeHNhLT5wa2V5LT5rZXlfaWRlbnRpZmllciwgbGtpKSkgeworCQkJCXJ4c2EtPmluX3VzZSA9IFRSVUU7CisJCQkJc2VjeV9lbmFibGVfcmVjZWl2ZV9zYShrYXksIHJ4c2EpOworCQkJCWllZWU4MDJfMXhfY3Bfc2V0X3VzaW5ncmVjZWl2ZXNhcygKKwkJCQkJcHJpbmNpcGFsLT5rYXktPmNwLCBUUlVFKTsKKwkJCQlpZWVlODAyXzF4X2NwX3NtX3N0ZXAocHJpbmNpcGFsLT5rYXktPmNwKTsKKwkJCX0KKwkJfQorCX0KKworCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfZW5hYmxlX25ld19pbmZvIC0KKyAqLworaW50IGllZWU4MDJfMXhfa2F5X2VuYWJsZV9uZXdfaW5mbyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnByaW5jaXBhbDsKKworCXByaW5jaXBhbCA9IGllZWU4MDJfMXhfa2F5X2dldF9wcmluY2lwYWxfcGFydGljaXBhbnQoa2F5KTsKKwlpZiAoIXByaW5jaXBhbCkKKwkJcmV0dXJuIC0xOworCisJaWYgKHByaW5jaXBhbC0+cmV0cnlfY291bnQgPCBNQVhfUkVUUllfQ05UKSB7CisJCWllZWU4MDJfMXhfcGFydGljaXBhbnRfc2VuZF9ta3BkdShwcmluY2lwYWwpOworCQlwcmluY2lwYWwtPnJldHJ5X2NvdW50Kys7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9jcF9jb25mIC0KKyAqLworaW50IGllZWU4MDJfMXhfa2F5X2NwX2NvbmYoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICBzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9jb25mICpwY29uZikKK3sKKwlwY29uZi0+cHJvdGVjdCA9IGtheS0+bWFjc2VjX3Byb3RlY3Q7CisJcGNvbmYtPnJlcGxheV9wcm90ZWN0ID0ga2F5LT5tYWNzZWNfcmVwbGF5X3Byb3RlY3Q7CisJcGNvbmYtPnZhbGlkYXRlID0ga2F5LT5tYWNzZWNfdmFsaWRhdGU7CisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2FsbG9jX2NwX3NtIC0KKyAqLworc3RhdGljIHN0cnVjdCBpZWVlODAyXzF4X2NwX3NtICoKK2llZWU4MDJfMXhfa2F5X2FsbG9jX2NwX3NtKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5KQoreworCXN0cnVjdCBpZWVlODAyXzF4X2NwX2NvbmYgY29uZjsKKworCW9zX21lbXNldCgmY29uZiwgMCwgc2l6ZW9mKGNvbmYpKTsKKwljb25mLnByb3RlY3QgPSBrYXktPm1hY3NlY19wcm90ZWN0OworCWNvbmYucmVwbGF5X3Byb3RlY3QgPSBrYXktPm1hY3NlY19yZXBsYXlfcHJvdGVjdDsKKwljb25mLnZhbGlkYXRlID0ga2F5LT5tYWNzZWNfdmFsaWRhdGU7CisJY29uZi5yZXBsYXlfd2luZG93ID0ga2F5LT5tYWNzZWNfcmVwbGF5X3dpbmRvdzsKKworCXJldHVybiBpZWVlODAyXzF4X2NwX3NtX2luaXQoa2F5LCAmY29uZik7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9ta3BkdV9zYW5pdHlfY2hlY2sgLQorICogICAgIHNhbml0eSBjaGVjayBzcGVjaWZpZWQgaW4gY2xhdXNlIDExLjExLjIgb2YgSUVFRTgwMi4xWC0yMDEwCisgKi8KK3N0YXRpYyBpbnQgaWVlZTgwMl8xeF9rYXlfbWtwZHVfc2FuaXR5X2NoZWNrKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCQkgICAgIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCit7CisJc3RydWN0IGllZWU4MDIzX2hkciAqZXRoX2hkcjsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9oZHIgKmVhcG9sX2hkcjsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICpta2FfaGRyOworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9iYXNpY19ib2R5ICpib2R5OworCXNpemVfdCBta2FfbXNnX2xlbjsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50OworCXNpemVfdCBib2R5X2xlbjsKKwl1OCBpY3ZbTUFYX0lDVl9MRU5dOworCXU4ICptc2dfaWN2OworCisJZXRoX2hkciA9IChzdHJ1Y3QgaWVlZTgwMjNfaGRyICopIGJ1ZjsKKwllYXBvbF9oZHIgPSAoc3RydWN0IGllZWU4MDJfMXhfaGRyICopIChldGhfaGRyICsgMSk7CisJbWthX2hkciA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaGRyICopIChlYXBvbF9oZHIgKyAxKTsKKworCS8qIGRlc3RpbmF0aW9uIGFkZHJlc3Mgc2hvdWxkIGJlIG5vdCBpbmRpdmlkdWFsIGFkZHJlc3MgKi8KKwlpZiAob3NfbWVtY21wKGV0aF9oZHItPmRlc3QsIHBhZV9ncm91cF9hZGRyLCBFVEhfQUxFTikgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLAorCQkJICAgIkthWTogZXRoZXJuZXQgZGVzdGluYXRpb24gYWRkcmVzcyBpcyBub3QgUEFFIGdyb3VwIGFkZHJlc3MiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCS8qIE1LUERVIHNob3VsZCBub3QgbGVzcyB0aGFuIDMyIG9jdGV0cyAqLworCW1rYV9tc2dfbGVuID0gYmVfdG9faG9zdDE2KGVhcG9sX2hkci0+bGVuZ3RoKTsKKwlpZiAobWthX21zZ19sZW4gPCAzMikgeworCQl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiS2FZOiBNS1BEVSBpcyBsZXNzIHRoYW4gMzIgb2N0ZXRzIik7CisJCXJldHVybiAtMTsKKwl9CisJLyogTUtQRFUgc2hvdWxkIG11bHRpcGxlIDQgb2N0ZXRzICovCisJaWYgKChta2FfbXNnX2xlbiAlIDQpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwKKwkJCSAgICJLYVk6IE1LUERVIGlzIG5vdCBtdWx0aXBsZSBvZiA0IG9jdGV0cyIpOworCQlyZXR1cm4gLTE7CisJfQorCisJYm9keSA9IChzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfYmFzaWNfYm9keSAqKSBta2FfaGRyOworCWllZWU4MDJfMXhfbWthX2R1bXBfYmFzaWNfYm9keShib2R5KTsKKwlib2R5X2xlbiA9IGdldF9ta2FfcGFyYW1fYm9keV9sZW4oYm9keSk7CisJLyogRUFQT0wtTUtBIGJvZHkgc2hvdWxkIGNvbXByaXNlIGJhc2ljIHBhcmFtZXRlciBzZXQgYW5kIElDViAqLworCWlmIChta2FfbXNnX2xlbiA8IE1LQV9IRFJfTEVOICsgYm9keV9sZW4gKyBERUZBVUxUX0lDVl9MRU4pIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBSZWNlaXZlZCBFQVBPTC1NS0EgUGFja2V0IEJvZHkgTGVuZ3RoICglZCBieXRlcykgaXMgbGVzcyB0aGFuIHRoZSBCYXNpYyBQYXJhbWV0ZXIgU2V0IEhlYWRlciBMZW5ndGggKCVkIGJ5dGVzKSArIHRoZSBCYXNpYyBQYXJhbWV0ZXIgU2V0IEJvZHkgTGVuZ3RoICglZCBieXRlcykgKyAlZCBieXRlcyBvZiBJQ1YiLAorCQkJICAgKGludCkgbWthX21zZ19sZW4sIChpbnQpIE1LQV9IRFJfTEVOLAorCQkJICAgKGludCkgYm9keV9sZW4sIERFRkFVTFRfSUNWX0xFTik7CisJCXJldHVybiAtMTsKKwl9CisKKwkvKiBDS04gc2hvdWxkIGJlIG93bmVkIGJ5IEkgKi8KKwlwYXJ0aWNpcGFudCA9IGllZWU4MDJfMXhfa2F5X2dldF9wYXJ0aWNpcGFudChrYXksIGJvZHktPmNrbik7CisJaWYgKCFwYXJ0aWNpcGFudCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNLTiBpcyBub3QgaW5jbHVkZWQgaW4gbXkgQ0EiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCS8qIGFsZ29yaXRobSBhZ2lsaXR5IGNoZWNrICovCisJaWYgKG9zX21lbWNtcChib2R5LT5hbGdvX2FnaWxpdHksIG1rYV9hbGdvX2FnaWxpdHksCisJCSAgICAgIHNpemVvZihib2R5LT5hbGdvX2FnaWxpdHkpKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogcGVlcidzIGFsZ29yaXRobSBhZ2lsaXR5IG5vdCBzdXBwb3J0ZWQgZm9yIG1lIik7CisJCXJldHVybiAtMTsKKwl9CisKKwkvKiBJQ1YgY2hlY2sgKi8KKwkvKgorCSAqIFRoZSBJQ1Ygd2lsbCBjb21wcmlzZSB0aGUgZmluYWwgb2N0ZXRzIG9mIHRoZSBwYWNrZXQgYm9keSwgd2hhdGV2ZXIKKwkgKiBpdHMgc2l6ZSwgbm90IHRoZSBmaXhlZCBsZW5ndGggMTYgb2N0ZXRzLCBpbmRpY2F0ZWQgYnkgdGhlIEVBUE9MCisJICogcGFja2V0IGJvZHkgbGVuZ3RoLgorCSAqLworCWlmIChta2FfYWxnX3RibFtrYXktPm1rYV9hbGdpbmRleF0uaWN2X2hhc2goCisJCSAgICBwYXJ0aWNpcGFudC0+aWNrLmtleSwKKwkJICAgIGJ1ZiwgbGVuIC0gbWthX2FsZ190Ymxba2F5LT5ta2FfYWxnaW5kZXhdLmljdl9sZW4sIGljdikpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6IG9tYWMxX2Flc18xMjggZmFpbGVkIik7CisJCXJldHVybiAtMTsKKwl9CisJbXNnX2ljdiA9IGllZWU4MDJfMXhfbWthX2RlY29kZV9pY3ZfYm9keShwYXJ0aWNpcGFudCwgKHU4ICopIG1rYV9oZHIsCisJCQkJCQkgbWthX21zZ19sZW4pOworCisJaWYgKG1zZ19pY3YpIHsKKwkJaWYgKG9zX21lbWNtcF9jb25zdChtc2dfaWN2LCBpY3YsCisJCQkJICAgIG1rYV9hbGdfdGJsW2theS0+bWthX2FsZ2luZGV4XS5pY3ZfbGVuKSAhPQorCQkgICAgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkthWTogQ29tcHV0ZWQgSUNWIGlzIG5vdCBlcXVhbCB0byBSZWNlaXZlZCBJQ1YiKTsKKwkJcmV0dXJuIC0xOworCQl9CisJfSBlbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6IE5vIElDViIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9kZWNvZGVfbWtwZHUgLQorICovCitzdGF0aWMgaW50IGllZWU4MDJfMXhfa2F5X2RlY29kZV9ta3BkdShzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCQkgICAgICAgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50OworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9oZHIgKmhkcjsKKwlzaXplX3QgYm9keV9sZW47CisJc2l6ZV90IGxlZnRfbGVuOworCWludCBib2R5X3R5cGU7CisJaW50IGk7CisJY29uc3QgdTggKnBvczsKKwlCb29sZWFuIG15X2luY2x1ZGVkOworCUJvb2xlYW4gaGFuZGxlZFsyNTZdOworCisJaWYgKGllZWU4MDJfMXhfa2F5X21rcGR1X3Nhbml0eV9jaGVjayhrYXksIGJ1ZiwgbGVuKSkKKwkJcmV0dXJuIC0xOworCisJLyogaGFuZGxlIGJhc2ljIHBhcmFtZXRlciBzZXQgKi8KKwlwb3MgPSBidWYgKyBzaXplb2Yoc3RydWN0IGllZWU4MDIzX2hkcikgKyBzaXplb2Yoc3RydWN0IGllZWU4MDJfMXhfaGRyKTsKKwlsZWZ0X2xlbiA9IGxlbiAtIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjNfaGRyKSAtCisJCXNpemVvZihzdHJ1Y3QgaWVlZTgwMl8xeF9oZHIpOworCXBhcnRpY2lwYW50ID0gaWVlZTgwMl8xeF9ta2FfZGVjb2RlX2Jhc2ljX2JvZHkoa2F5LCBwb3MsIGxlZnRfbGVuKTsKKwlpZiAoIXBhcnRpY2lwYW50KQorCQlyZXR1cm4gLTE7CisKKwkvKiB0byBza2lwIGJhc2ljIHBhcmFtZXRlciBzZXQgKi8KKwloZHIgPSAoc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqKSBwb3M7CisJYm9keV9sZW4gPSBnZXRfbWthX3BhcmFtX2JvZHlfbGVuKGhkcik7CisJcG9zICs9IGJvZHlfbGVuICsgTUtBX0hEUl9MRU47CisJbGVmdF9sZW4gLT0gYm9keV9sZW4gKyBNS0FfSERSX0xFTjsKKworCS8qIGNoZWNrIGkgYW0gaW4gdGhlIHBlZXIncyBwZWVyIGxpc3QgKi8KKwlteV9pbmNsdWRlZCA9IGllZWU4MDJfMXhfbWthX2lfaW5fcGVlcmxpc3QocGFydGljaXBhbnQsIHBvcywgbGVmdF9sZW4pOworCWlmIChteV9pbmNsdWRlZCkgeworCQkvKiBhY2NlcHQgdGhlIHBlZXIgYXMgbGl2ZSBwZWVyICovCisJCWlmICghaWVlZTgwMl8xeF9rYXlfaXNfaW5fcGVlcigKKwkJCSAgICBwYXJ0aWNpcGFudCwKKwkJCSAgICBwYXJ0aWNpcGFudC0+Y3VycmVudF9wZWVyX2lkLm1pKSkgeworCQkJaWYgKCFpZWVlODAyXzF4X2theV9jcmVhdGVfbGl2ZV9wZWVyKAorCQkJCSAgICBwYXJ0aWNpcGFudCwKKwkJCQkgICAgcGFydGljaXBhbnQtPmN1cnJlbnRfcGVlcl9pZC5taSwKKwkJCQkgICAgcGFydGljaXBhbnQtPmN1cnJlbnRfcGVlcl9pZC5tbikpCisJCQkJcmV0dXJuIC0xOworCQkJaWVlZTgwMl8xeF9rYXlfZWxlY3Rfa2V5X3NlcnZlcihwYXJ0aWNpcGFudCk7CisJCQlpZWVlODAyXzF4X2theV9kZWNpZGVfbWFjc2VjX3VzZShwYXJ0aWNpcGFudCk7CisJCX0KKwkJaWYgKGllZWU4MDJfMXhfa2F5X2lzX2luX3BvdGVudGlhbF9wZWVyKAorCQkJICAgIHBhcnRpY2lwYW50LCBwYXJ0aWNpcGFudC0+Y3VycmVudF9wZWVyX2lkLm1pKSkgeworCQkJaWVlZTgwMl8xeF9rYXlfbW92ZV9saXZlX3BlZXIoCisJCQkJcGFydGljaXBhbnQsIHBhcnRpY2lwYW50LT5jdXJyZW50X3BlZXJfaWQubWksCisJCQkJcGFydGljaXBhbnQtPmN1cnJlbnRfcGVlcl9pZC5tbik7CisJCQlpZWVlODAyXzF4X2theV9lbGVjdF9rZXlfc2VydmVyKHBhcnRpY2lwYW50KTsKKwkJCWllZWU4MDJfMXhfa2F5X2RlY2lkZV9tYWNzZWNfdXNlKHBhcnRpY2lwYW50KTsKKwkJfQorCX0KKworCS8qCisJICogSGFuZGxlIG90aGVyIHBhcmFtZXRlciBzZXQgdGhhbiBiYXNpYyBwYXJhbWV0ZXIgc2V0LgorCSAqIEVhY2ggcGFyYW1ldGVyIHNldCBzaG91bGQgYmUgcHJlc2VudCBvbmx5IG9uY2UuCisJICovCisJZm9yIChpID0gMDsgaSA8IDI1NjsgaSsrKQorCQloYW5kbGVkW2ldID0gRkFMU0U7CisKKwloYW5kbGVkWzBdID0gVFJVRTsKKwl3aGlsZSAobGVmdF9sZW4gPiBNS0FfSERSX0xFTiArIERFRkFVTFRfSUNWX0xFTikgeworCQloZHIgPSAoc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciAqKSBwb3M7CisJCWJvZHlfbGVuID0gZ2V0X21rYV9wYXJhbV9ib2R5X2xlbihoZHIpOworCQlib2R5X3R5cGUgPSBnZXRfbWthX3BhcmFtX2JvZHlfdHlwZShoZHIpOworCisJCWlmIChib2R5X3R5cGUgPT0gTUtBX0lDVl9JTkRJQ0FUT1IpCisJCQlyZXR1cm4gMDsKKworCQlpZiAobGVmdF9sZW4gPCAoTUtBX0hEUl9MRU4gKyBib2R5X2xlbiArIERFRkFVTFRfSUNWX0xFTikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJCSAgICJLYVk6IE1LQSBQZWVyIFBhY2tldCBCb2R5IExlbmd0aCAoJWQgYnl0ZXMpIGlzIGxlc3MgdGhhbiB0aGUgUGFyYW1ldGVyIFNldCBIZWFkZXIgTGVuZ3RoICglZCBieXRlcykgKyB0aGUgUGFyYW1ldGVyIFNldCBCb2R5IExlbmd0aCAoJWQgYnl0ZXMpICsgJWQgYnl0ZXMgb2YgSUNWIiwKKwkJCQkgICAoaW50KSBsZWZ0X2xlbiwgKGludCkgTUtBX0hEUl9MRU4sCisJCQkJICAgKGludCkgYm9keV9sZW4sIERFRkFVTFRfSUNWX0xFTik7CisJCQlnb3RvIG5leHRfcGFyYV9zZXQ7CisJCX0KKworCQlpZiAoaGFuZGxlZFtib2R5X3R5cGVdKQorCQkJZ290byBuZXh0X3BhcmFfc2V0OworCisJCWhhbmRsZWRbYm9keV90eXBlXSA9IFRSVUU7CisJCWlmIChtYWtfYm9keV9oYW5kbGVyW2JvZHlfdHlwZV0uYm9keV9yeCkgeworCQkJbWFrX2JvZHlfaGFuZGxlcltib2R5X3R5cGVdLmJvZHlfcngKKwkJCQkocGFydGljaXBhbnQsIHBvcywgbGVmdF9sZW4pOworCQl9IGVsc2UgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIlRoZSB0eXBlICVkIG5vdCBzdXBwb3J0ZWQgaW4gdGhpcyBNS0EgdmVyc2lvbiAlZCIsCisJCQkJICAgYm9keV90eXBlLCBNS0FfVkVSU0lPTl9JRCk7CisJCX0KKworbmV4dF9wYXJhX3NldDoKKwkJcG9zICs9IGJvZHlfbGVuICsgTUtBX0hEUl9MRU47CisJCWxlZnRfbGVuIC09IGJvZHlfbGVuICsgTUtBX0hEUl9MRU47CisJfQorCisJa2F5LT5hY3RpdmUgPSBUUlVFOworCXBhcnRpY2lwYW50LT5yZXRyeV9jb3VudCA9IDA7CisJcGFydGljaXBhbnQtPmFjdGl2ZSA9IFRSVUU7CisKKwlyZXR1cm4gMDsKK30KKworCisKK3N0YXRpYyB2b2lkIGtheV9sMl9yZWNlaXZlKHZvaWQgKmN0eCwgY29uc3QgdTggKnNyY19hZGRyLCBjb25zdCB1OCAqYnVmLAorCQkJICAgc2l6ZV90IGxlbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSA9IGN0eDsKKwlzdHJ1Y3QgaWVlZTgwMjNfaGRyICpldGhfaGRyOworCXN0cnVjdCBpZWVlODAyXzF4X2hkciAqZWFwb2xfaGRyOworCisJLyogbXVzdCBjb250YWluIGF0IGxlYXN0IGllZWU4MDIzX2hkciArIGllZWU4MDJfMXhfaGRyICovCisJaWYgKGxlbiA8IHNpemVvZigqZXRoX2hkcikgKyBzaXplb2YoKmVhcG9sX2hkcikpIHsKKwkJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIkthWTogRUFQT0wgZnJhbWUgdG9vIHNob3J0ICglbHUpIiwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBsZW4pOworCQlyZXR1cm47CisJfQorCisJZXRoX2hkciA9IChzdHJ1Y3QgaWVlZTgwMjNfaGRyICopIGJ1ZjsKKwllYXBvbF9oZHIgPSAoc3RydWN0IGllZWU4MDJfMXhfaGRyICopIChldGhfaGRyICsgMSk7CisJaWYgKGxlbiAhPSBzaXplb2YoKmV0aF9oZHIpICsgc2l6ZW9mKCplYXBvbF9oZHIpICsKKwkgICAgbnRvaHMoZWFwb2xfaGRyLT5sZW5ndGgpKSB7CisJCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJLQVk6IEVBUE9MIE1QRFUgaXMgaW52YWxpZDogKCVsdS0lbHUpIiwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBsZW4sCisJCQkgICAodW5zaWduZWQgbG9uZykgbnRvaHMoZWFwb2xfaGRyLT5sZW5ndGgpKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChlYXBvbF9oZHItPnZlcnNpb24gPCBFQVBPTF9WRVJTSU9OKSB7CisJCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJLYVk6IHZlcnNpb24gJWQgZG9lcyBub3Qgc3VwcG9ydCBNS0EiLAorCQkJICAgZWFwb2xfaGRyLT52ZXJzaW9uKTsKKwkJcmV0dXJuOworCX0KKwlpZiAobnRvaHMoZXRoX2hkci0+ZXRoZXJ0eXBlKSAhPSBFVEhfUF9QQUUgfHwKKwkgICAgZWFwb2xfaGRyLT50eXBlICE9IElFRUU4MDJfMVhfVFlQRV9FQVBPTF9NS0EpCisJCXJldHVybjsKKworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlJYIEVBUE9MLU1LQTogIiwgYnVmLCBsZW4pOworCWlmIChkbF9saXN0X2VtcHR5KCZrYXktPnBhcnRpY2lwYW50X2xpc3QpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiBubyBNS0EgcGFydGljaXBhbnQgaW5zdGFuY2UiKTsKKwkJcmV0dXJuOworCX0KKworCWllZWU4MDJfMXhfa2F5X2RlY29kZV9ta3BkdShrYXksIGJ1ZiwgbGVuKTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2luaXQgLQorICovCitzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKgoraWVlZTgwMl8xeF9rYXlfaW5pdChzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY3R4ICpjdHgsIGVudW0gbWFjc2VjX3BvbGljeSBwb2xpY3ksCisJCSAgICBjb25zdCBjaGFyICppZm5hbWUsIGNvbnN0IHU4ICphZGRyKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5OworCisJa2F5ID0gb3NfemFsbG9jKHNpemVvZigqa2F5KSk7CisJaWYgKCFrYXkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVktJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBOVUxMOworCX0KKworCWtheS0+Y3R4ID0gY3R4OworCisJa2F5LT5lbmFibGUgPSBUUlVFOworCWtheS0+YWN0aXZlID0gRkFMU0U7CisKKwlrYXktPmF1dGhlbnRpY2F0ZWQgPSBGQUxTRTsKKwlrYXktPnNlY3VyZWQgPSBGQUxTRTsKKwlrYXktPmZhaWxlZCA9IEZBTFNFOworCWtheS0+cG9saWN5ID0gcG9saWN5OworCisJb3Nfc3RybGNweShrYXktPmlmX25hbWUsIGlmbmFtZSwgSUZOQU1TSVopOworCW9zX21lbWNweShrYXktPmFjdG9yX3NjaS5hZGRyLCBhZGRyLCBFVEhfQUxFTik7CisJa2F5LT5hY3Rvcl9zY2kucG9ydCA9IDB4MDAwMTsKKwlrYXktPmFjdG9yX3ByaW9yaXR5ID0gREVGQVVMVF9QUklPX05PVF9LRVlfU0VSVkVSOworCisJLyogV2hpbGUgYWN0b3IgYWN0cyBhcyBhIGtleSBzZXJ2ZXIsIHNoYWxsIGRpc3RyaWJ1dGUgc2FrZXkgKi8KKwlrYXktPmRpc3Rfa24gPSAxOworCWtheS0+ZGlzdF9hbiA9IDA7CisJa2F5LT5kaXN0X3RpbWUgPSAwOworCisJa2F5LT5wbl9leGhhdXN0aW9uID0gUEVORElOR19QTl9FWEhBVVNUSU9OOworCWtheS0+bWFjc2VjX2NzaW5kZXggPSBERUZBVUxUX0NTX0lOREVYOworCWtheS0+bWthX2FsZ2luZGV4ID0gREVGQVVMVF9NS0FfQUxHX0lOREVYOworCWtheS0+bWthX3ZlcnNpb24gPSBNS0FfVkVSU0lPTl9JRDsKKworCW9zX21lbWNweShrYXktPmFsZ29fYWdpbGl0eSwgbWthX2FsZ29fYWdpbGl0eSwKKwkJICBzaXplb2Yoa2F5LT5hbGdvX2FnaWxpdHkpKTsKKworCWRsX2xpc3RfaW5pdCgma2F5LT5wYXJ0aWNpcGFudF9saXN0KTsKKworCWlmIChwb2xpY3kgPT0gRE9fTk9UX1NFQ1VSRSkgeworCQlrYXktPm1hY3NlY19jYXBhYmxlID0gTUFDU0VDX0NBUF9OT1RfSU1QTEVNRU5URUQ7CisJCWtheS0+bWFjc2VjX2Rlc2lyZWQgPSBGQUxTRTsKKwkJa2F5LT5tYWNzZWNfcHJvdGVjdCA9IEZBTFNFOworCQlrYXktPm1hY3NlY192YWxpZGF0ZSA9IEZBTFNFOworCQlrYXktPm1hY3NlY19yZXBsYXlfcHJvdGVjdCA9IEZBTFNFOworCQlrYXktPm1hY3NlY19yZXBsYXlfd2luZG93ID0gMDsKKwkJa2F5LT5tYWNzZWNfY29uZmlkZW50aWFsaXR5ID0gQ09ORklERU5USUFMSVRZX05PTkU7CisJfSBlbHNlIHsKKwkJa2F5LT5tYWNzZWNfY2FwYWJsZSA9IE1BQ1NFQ19DQVBfSU5URUdfQU5EX0NPTkZfMF8zMF81MDsKKwkJa2F5LT5tYWNzZWNfZGVzaXJlZCA9IFRSVUU7CisJCWtheS0+bWFjc2VjX3Byb3RlY3QgPSBUUlVFOworCQlrYXktPm1hY3NlY192YWxpZGF0ZSA9IFRSVUU7CisJCWtheS0+bWFjc2VjX3JlcGxheV9wcm90ZWN0ID0gRkFMU0U7CisJCWtheS0+bWFjc2VjX3JlcGxheV93aW5kb3cgPSAwOworCQlrYXktPm1hY3NlY19jb25maWRlbnRpYWxpdHkgPSBDT05GSURFTlRJQUxJVFlfT0ZGU0VUXzA7CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJLYVk6IHN0YXRlIG1hY2hpbmUgY3JlYXRlZCIpOworCisJLyogSW5pdGlhbGl6ZSB0aGUgU2VjWSBtdXN0IGJlIHByaW8gdG8gQ1AsIGFzIENQIHdpbGwgY29udHJvbCBTZWNZICovCisJc2VjeV9pbml0X21hY3NlYyhrYXkpOworCXNlY3lfZ2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYyhrYXksICZrYXktPnNjX2NoKTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiS2FZOiBzZWN5IGluaXQgbWFjc2VjIGRvbmUiKTsKKworCS8qIGluaXQgQ1AgKi8KKwlrYXktPmNwID0gaWVlZTgwMl8xeF9rYXlfYWxsb2NfY3Bfc20oa2F5KTsKKwlpZiAoa2F5LT5jcCA9PSBOVUxMKSB7CisJCWllZWU4MDJfMXhfa2F5X2RlaW5pdChrYXkpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlpZiAocG9saWN5ID09IERPX05PVF9TRUNVUkUpIHsKKwkJaWVlZTgwMl8xeF9jcF9jb25uZWN0X2F1dGhlbnRpY2F0ZWQoa2F5LT5jcCk7CisJCWllZWU4MDJfMXhfY3Bfc21fc3RlcChrYXktPmNwKTsKKwl9IGVsc2UgeworCQlrYXktPmwyX21rYSA9IGwyX3BhY2tldF9pbml0KGtheS0+aWZfbmFtZSwgTlVMTCwgRVRIX1BfUEFFLAorCQkJCQkgICAgIGtheV9sMl9yZWNlaXZlLCBrYXksIDEpOworCQlpZiAoa2F5LT5sMl9ta2EgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfV0FSTklORywKKwkJCQkgICAiS2FZOiBGYWlsZWQgdG8gaW5pdGlhbGl6ZSBMMiBwYWNrZXQgcHJvY2Vzc2luZyBmb3IgTUtBIHBhY2tldCIpOworCQkJaWVlZTgwMl8xeF9rYXlfZGVpbml0KGtheSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCX0KKworCXJldHVybiBrYXk7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9kZWluaXQgLQorICovCit2b2lkCitpZWVlODAyXzF4X2theV9kZWluaXQoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXkpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudDsKKworCWlmICgha2F5KQorCQlyZXR1cm47CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkthWTogc3RhdGUgbWFjaGluZSByZW1vdmVkIik7CisKKwl3aGlsZSAoIWRsX2xpc3RfZW1wdHkoJmtheS0+cGFydGljaXBhbnRfbGlzdCkpIHsKKwkJcGFydGljaXBhbnQgPSBkbF9saXN0X2VudHJ5KGtheS0+cGFydGljaXBhbnRfbGlzdC5uZXh0LAorCQkJCQkgICAgc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50LAorCQkJCQkgICAgbGlzdCk7CisJCWllZWU4MDJfMXhfa2F5X2RlbGV0ZV9ta2Eoa2F5LCAmcGFydGljaXBhbnQtPmNrbik7CisJfQorCisJaWVlZTgwMl8xeF9jcF9zbV9kZWluaXQoa2F5LT5jcCk7CisJc2VjeV9kZWluaXRfbWFjc2VjKGtheSk7CisKKwlpZiAoa2F5LT5sMl9ta2EpIHsKKwkJbDJfcGFja2V0X2RlaW5pdChrYXktPmwyX21rYSk7CisJCWtheS0+bDJfbWthID0gTlVMTDsKKwl9CisKKwlvc19mcmVlKGtheS0+Y3R4KTsKKwlvc19mcmVlKGtheSk7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2theV9jcmVhdGVfbWthIC0KKyAqLworc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICoKK2llZWU4MDJfMXhfa2F5X2NyZWF0ZV9ta2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIHN0cnVjdCBta2Ffa2V5X25hbWUgKmNrbiwKKwkJCSAgc3RydWN0IG1rYV9rZXkgKmNhaywgdTMyIGxpZmUsCisJCQkgIGVudW0gbWthX2NyZWF0ZWRfbW9kZSBtb2RlLCBCb29sZWFuIGlzX2F1dGhlbnRpY2F0b3IpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudDsKKwl1bnNpZ25lZCBpbnQgdXNlY3M7CisKKwlpZiAoIWtheSB8fCAhY2tuIHx8ICFjYWspIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6IGNrbiBvciBjYWsgaXMgbnVsbCIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlpZiAoY2FrLT5sZW4gIT0gbWthX2FsZ190Ymxba2F5LT5ta2FfYWxnaW5kZXhdLmNha19sZW4pIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6IENBSyBsZW5ndGggbm90IGZvbGxvdyBrZXkgc2NoZW1hIik7CisJCXJldHVybiBOVUxMOworCX0KKwlpZiAoY2tuLT5sZW4gPiBNQVhfQ0tOX0xFTikgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogQ0tOIGlzIG91dCBvZiByYW5nZSg8PTMyIGJ5dGVzKSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJaWYgKCFrYXktPmVuYWJsZSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogTm93IGlzIGF0IGRpc2FibGUgc3RhdGUiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcGFydGljaXBhbnQgPSBvc196YWxsb2Moc2l6ZW9mKCpwYXJ0aWNpcGFudCkpOworCWlmICghcGFydGljaXBhbnQpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVktJXM6IG91dCBvZiBtZW1vcnkiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBOVUxMOworCX0KKworCXBhcnRpY2lwYW50LT5ja24ubGVuID0gY2tuLT5sZW47CisJb3NfbWVtY3B5KHBhcnRpY2lwYW50LT5ja24ubmFtZSwgY2tuLT5uYW1lLCBja24tPmxlbik7CisJcGFydGljaXBhbnQtPmNhay5sZW4gPSBjYWstPmxlbjsKKwlvc19tZW1jcHkocGFydGljaXBhbnQtPmNhay5rZXksIGNhay0+a2V5LCBjYWstPmxlbik7CisJaWYgKGxpZmUpCisJCXBhcnRpY2lwYW50LT5jYWtfbGlmZSA9IGxpZmUgKyB0aW1lKE5VTEwpOworCisJc3dpdGNoIChtb2RlKSB7CisJY2FzZSBFQVBfRVhDSEFOR0U6CisJCWlmIChpc19hdXRoZW50aWNhdG9yKSB7CisJCQlwYXJ0aWNpcGFudC0+aXNfb2JsaWdlZF9rZXlfc2VydmVyID0gVFJVRTsKKwkJCXBhcnRpY2lwYW50LT5jYW5fYmVfa2V5X3NlcnZlciA9IFRSVUU7CisJCQlwYXJ0aWNpcGFudC0+aXNfa2V5X3NlcnZlciA9IFRSVUU7CisJCQlwYXJ0aWNpcGFudC0+cHJpbmNpcGFsID0gVFJVRTsKKworCQkJb3NfbWVtY3B5KCZrYXktPmtleV9zZXJ2ZXJfc2NpLCAma2F5LT5hY3Rvcl9zY2ksCisJCQkJICBzaXplb2Yoa2F5LT5rZXlfc2VydmVyX3NjaSkpOworCQkJa2F5LT5rZXlfc2VydmVyX3ByaW9yaXR5ID0ga2F5LT5hY3Rvcl9wcmlvcml0eTsKKwkJCXBhcnRpY2lwYW50LT5pc19lbGVjdGVkID0gVFJVRTsKKwkJfSBlbHNlIHsKKwkJCXBhcnRpY2lwYW50LT5pc19vYmxpZ2VkX2tleV9zZXJ2ZXIgPSBGQUxTRTsKKwkJCXBhcnRpY2lwYW50LT5jYW5fYmVfa2V5X3NlcnZlciA9IEZBTFNFOworCQkJcGFydGljaXBhbnQtPmlzX2tleV9zZXJ2ZXIgPSBGQUxTRTsKKwkJCXBhcnRpY2lwYW50LT5pc19lbGVjdGVkID0gVFJVRTsKKwkJfQorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCXBhcnRpY2lwYW50LT5pc19vYmxpZ2VkX2tleV9zZXJ2ZXIgPSBGQUxTRTsKKwkJcGFydGljaXBhbnQtPmNhbl9iZV9rZXlfc2VydmVyID0gVFJVRTsKKwkJcGFydGljaXBhbnQtPmlzX2tleV9zZXJ2ZXIgPSBGQUxTRTsKKwkJcGFydGljaXBhbnQtPmlzX2VsZWN0ZWQgPSBGQUxTRTsKKwkJYnJlYWs7CisJfQorCisJcGFydGljaXBhbnQtPmNhY2hlZCA9IEZBTFNFOworCisJcGFydGljaXBhbnQtPmFjdGl2ZSA9IEZBTFNFOworCXBhcnRpY2lwYW50LT5wYXJ0aWNpcGFudCA9IEZBTFNFOworCXBhcnRpY2lwYW50LT5yZXRhaW4gPSBGQUxTRTsKKwlwYXJ0aWNpcGFudC0+YWN0aXZhdGUgPSBERUZBVUxUOworCisJaWYgKHBhcnRpY2lwYW50LT5pc19rZXlfc2VydmVyKQorCQlwYXJ0aWNpcGFudC0+cHJpbmNpcGFsID0gVFJVRTsKKworCWRsX2xpc3RfaW5pdCgmcGFydGljaXBhbnQtPmxpdmVfcGVlcnMpOworCWRsX2xpc3RfaW5pdCgmcGFydGljaXBhbnQtPnBvdGVudGlhbF9wZWVycyk7CisKKwlwYXJ0aWNpcGFudC0+cmV0cnlfY291bnQgPSAwOworCXBhcnRpY2lwYW50LT5rYXkgPSBrYXk7CisKKwlvc19nZXRfcmFuZG9tKHBhcnRpY2lwYW50LT5taSwgc2l6ZW9mKHBhcnRpY2lwYW50LT5taSkpOworCXBhcnRpY2lwYW50LT5tbiA9IDA7CisKKwlwYXJ0aWNpcGFudC0+bHJ4ID0gRkFMU0U7CisJcGFydGljaXBhbnQtPmx0eCA9IEZBTFNFOworCXBhcnRpY2lwYW50LT5vcnggPSBGQUxTRTsKKwlwYXJ0aWNpcGFudC0+b3R4ID0gRkFMU0U7CisJcGFydGljaXBhbnQtPnRvX2Rpc3Rfc2FrID0gRkFMU0U7CisJcGFydGljaXBhbnQtPnRvX3VzZV9zYWsgPSBGQUxTRTsKKwlwYXJ0aWNpcGFudC0+bmV3X3NhayA9IEZBTFNFOworCWRsX2xpc3RfaW5pdCgmcGFydGljaXBhbnQtPnNha19saXN0KTsKKwlwYXJ0aWNpcGFudC0+bmV3X2tleSA9IE5VTEw7CisJZGxfbGlzdF9pbml0KCZwYXJ0aWNpcGFudC0+cnhzY19saXN0KTsKKwlwYXJ0aWNpcGFudC0+dHhzYyA9IGllZWU4MDJfMXhfa2F5X2luaXRfdHJhbnNtaXRfc2MoJmtheS0+YWN0b3Jfc2NpLAorCQkJCQkJCSAgICBrYXktPnNjX2NoKTsKKwlzZWN5X2NyZWF0ZV90cmFuc21pdF9zYyhrYXksIHBhcnRpY2lwYW50LT50eHNjKTsKKworCS8qIHRvIGRlcml2ZSBLRUsgZnJvbSBDQUsgYW5kIENLTiAqLworCXBhcnRpY2lwYW50LT5rZWsubGVuID0gbWthX2FsZ190Ymxba2F5LT5ta2FfYWxnaW5kZXhdLmtla19sZW47CisJaWYgKG1rYV9hbGdfdGJsW2theS0+bWthX2FsZ2luZGV4XS5rZWtfdHJmbShwYXJ0aWNpcGFudC0+Y2FrLmtleSwKKwkJCQkJCSAgICBwYXJ0aWNpcGFudC0+Y2tuLm5hbWUsCisJCQkJCQkgICAgcGFydGljaXBhbnQtPmNrbi5sZW4sCisJCQkJCQkgICAgcGFydGljaXBhbnQtPmtlay5rZXkpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiBEZXJpdmVkIEtFSyBmYWlsZWQiKTsKKwkJZ290byBmYWlsOworCX0KKwl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiS2FZOiBEZXJpdmVkIEtFSyIsCisJCQlwYXJ0aWNpcGFudC0+a2VrLmtleSwgcGFydGljaXBhbnQtPmtlay5sZW4pOworCisJLyogdG8gZGVyaXZlIElDSyBmcm9tIENBSyBhbmQgQ0tOICovCisJcGFydGljaXBhbnQtPmljay5sZW4gPSBta2FfYWxnX3RibFtrYXktPm1rYV9hbGdpbmRleF0uaWNrX2xlbjsKKwlpZiAobWthX2FsZ190Ymxba2F5LT5ta2FfYWxnaW5kZXhdLmlja190cmZtKHBhcnRpY2lwYW50LT5jYWsua2V5LAorCQkJCQkJICAgIHBhcnRpY2lwYW50LT5ja24ubmFtZSwKKwkJCQkJCSAgICBwYXJ0aWNpcGFudC0+Y2tuLmxlbiwKKwkJCQkJCSAgICBwYXJ0aWNpcGFudC0+aWNrLmtleSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6IERlcml2ZWQgSUNLIGZhaWxlZCIpOworCQlnb3RvIGZhaWw7CisJfQorCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJLYVk6IERlcml2ZWQgSUNLIiwKKwkJCXBhcnRpY2lwYW50LT5pY2sua2V5LCBwYXJ0aWNpcGFudC0+aWNrLmxlbik7CisKKwlkbF9saXN0X2FkZCgma2F5LT5wYXJ0aWNpcGFudF9saXN0LCAmcGFydGljaXBhbnQtPmxpc3QpOworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIkthWTogUGFydGljaXBhbnQgY3JlYXRlZDoiLAorCQkgICAgY2tuLT5uYW1lLCBja24tPmxlbik7CisKKwl1c2VjcyA9IG9zX3JhbmRvbSgpICUgKE1LQV9IRUxMT19USU1FICogMTAwMCk7CisJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCB1c2VjcywgaWVlZTgwMl8xeF9wYXJ0aWNpcGFudF90aW1lciwKKwkJCSAgICAgICBwYXJ0aWNpcGFudCwgTlVMTCk7CisJcGFydGljaXBhbnQtPm1rYV9saWZlID0gTUtBX0xJRkVfVElNRSAvIDEwMDAgKyB0aW1lKE5VTEwpICsKKwkJdXNlY3MgLyAxMDAwMDAwOworCisJcmV0dXJuIHBhcnRpY2lwYW50OworCitmYWlsOgorCW9zX2ZyZWUocGFydGljaXBhbnQpOworCXJldHVybiBOVUxMOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9rYXlfZGVsZXRlX21rYSAtCisgKi8KK3ZvaWQKK2llZWU4MDJfMXhfa2F5X2RlbGV0ZV9ta2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIHN0cnVjdCBta2Ffa2V5X25hbWUgKmNrbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50OworCXN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyICpwZWVyOworCXN0cnVjdCBkYXRhX2tleSAqc2FrOworCXN0cnVjdCByZWNlaXZlX3NjICpyeHNjOworCisJaWYgKCFrYXkgfHwgIWNrbikKKwkJcmV0dXJuOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJLYVk6IHBhcnRpY2lwYW50IHJlbW92ZWQiKTsKKworCS8qIGdldCB0aGUgcGFydGljaXBhbnQgKi8KKwlwYXJ0aWNpcGFudCA9IGllZWU4MDJfMXhfa2F5X2dldF9wYXJ0aWNpcGFudChrYXksIGNrbi0+bmFtZSk7CisJaWYgKCFwYXJ0aWNpcGFudCkgeworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJLYVk6IHBhcnRpY2lwYW50IGlzIG5vdCBmb3VuZCIsCisJCQkgICAgY2tuLT5uYW1lLCBja24tPmxlbik7CisJCXJldHVybjsKKwl9CisKKwlkbF9saXN0X2RlbCgmcGFydGljaXBhbnQtPmxpc3QpOworCisJLyogcmVtb3ZlIGxpdmUgcGVlciAqLworCXdoaWxlICghZGxfbGlzdF9lbXB0eSgmcGFydGljaXBhbnQtPmxpdmVfcGVlcnMpKSB7CisJCXBlZXIgPSBkbF9saXN0X2VudHJ5KHBhcnRpY2lwYW50LT5saXZlX3BlZXJzLm5leHQsCisJCQkJICAgICBzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfcGVlciwgbGlzdCk7CisJCWRsX2xpc3RfZGVsKCZwZWVyLT5saXN0KTsKKwkJb3NfZnJlZShwZWVyKTsKKwl9CisKKwkvKiByZW1vdmUgcG90ZW50aWFsIHBlZXIgKi8KKwl3aGlsZSAoIWRsX2xpc3RfZW1wdHkoJnBhcnRpY2lwYW50LT5wb3RlbnRpYWxfcGVlcnMpKSB7CisJCXBlZXIgPSBkbF9saXN0X2VudHJ5KHBhcnRpY2lwYW50LT5wb3RlbnRpYWxfcGVlcnMubmV4dCwKKwkJCQkgICAgIHN0cnVjdCBpZWVlODAyXzF4X2theV9wZWVyLCBsaXN0KTsKKwkJZGxfbGlzdF9kZWwoJnBlZXItPmxpc3QpOworCQlvc19mcmVlKHBlZXIpOworCX0KKworCS8qIHJlbW92ZSBzYWsgKi8KKwl3aGlsZSAoIWRsX2xpc3RfZW1wdHkoJnBhcnRpY2lwYW50LT5zYWtfbGlzdCkpIHsKKwkJc2FrID0gZGxfbGlzdF9lbnRyeShwYXJ0aWNpcGFudC0+c2FrX2xpc3QubmV4dCwKKwkJCQkgICAgc3RydWN0IGRhdGFfa2V5LCBsaXN0KTsKKwkJZGxfbGlzdF9kZWwoJnNhay0+bGlzdCk7CisJCW9zX2ZyZWUoc2FrLT5rZXkpOworCQlvc19mcmVlKHNhayk7CisJfQorCXdoaWxlICghZGxfbGlzdF9lbXB0eSgmcGFydGljaXBhbnQtPnJ4c2NfbGlzdCkpIHsKKwkJcnhzYyA9IGRsX2xpc3RfZW50cnkocGFydGljaXBhbnQtPnJ4c2NfbGlzdC5uZXh0LAorCQkJCSAgICAgc3RydWN0IHJlY2VpdmVfc2MsIGxpc3QpOworCQlzZWN5X2RlbGV0ZV9yZWNlaXZlX3NjKGtheSwgcnhzYyk7CisJCWllZWU4MDJfMXhfa2F5X2RlaW5pdF9yZWNlaXZlX3NjKHBhcnRpY2lwYW50LCByeHNjKTsKKwl9CisJc2VjeV9kZWxldGVfdHJhbnNtaXRfc2Moa2F5LCBwYXJ0aWNpcGFudC0+dHhzYyk7CisJaWVlZTgwMl8xeF9rYXlfZGVpbml0X3RyYW5zbWl0X3NjKHBhcnRpY2lwYW50LCBwYXJ0aWNpcGFudC0+dHhzYyk7CisKKwlvc19tZW1zZXQoJnBhcnRpY2lwYW50LT5jYWssIDAsIHNpemVvZihwYXJ0aWNpcGFudC0+Y2FrKSk7CisJb3NfbWVtc2V0KCZwYXJ0aWNpcGFudC0+a2VrLCAwLCBzaXplb2YocGFydGljaXBhbnQtPmtlaykpOworCW9zX21lbXNldCgmcGFydGljaXBhbnQtPmljaywgMCwgc2l6ZW9mKHBhcnRpY2lwYW50LT5pY2spKTsKKwlvc19mcmVlKHBhcnRpY2lwYW50KTsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X21rYV9wYXJ0aWNpcGF0ZSAtCisgKi8KK3ZvaWQgaWVlZTgwMl8xeF9rYXlfbWthX3BhcnRpY2lwYXRlKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCSAgICBzdHJ1Y3QgbWthX2tleV9uYW1lICpja24sCisJCQkJICAgIEJvb2xlYW4gc3RhdHVzKQoreworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wYXJ0aWNpcGFudCAqcGFydGljaXBhbnQ7CisKKwlpZiAoIWtheSB8fCAhY2tuKQorCQlyZXR1cm47CisKKwlwYXJ0aWNpcGFudCA9IGllZWU4MDJfMXhfa2F5X2dldF9wYXJ0aWNpcGFudChrYXksIGNrbi0+bmFtZSk7CisJaWYgKCFwYXJ0aWNpcGFudCkKKwkJcmV0dXJuOworCisJcGFydGljaXBhbnQtPmFjdGl2ZSA9IHN0YXR1czsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X25ld19zYWsgLQorICovCitpbnQKK2llZWU4MDJfMXhfa2F5X25ld19zYWsoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXkpCit7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50ICpwYXJ0aWNpcGFudDsKKworCWlmICgha2F5KQorCQlyZXR1cm4gLTE7CisKKwlwYXJ0aWNpcGFudCA9IGllZWU4MDJfMXhfa2F5X2dldF9wcmluY2lwYWxfcGFydGljaXBhbnQoa2F5KTsKKwlpZiAoIXBhcnRpY2lwYW50KQorCQlyZXR1cm4gLTE7CisKKwlwYXJ0aWNpcGFudC0+bmV3X3NhayA9IFRSVUU7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJLYVk6IG5ldyBTQUsgc2lnbmFsIik7CisKKwlyZXR1cm4gMDsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2F5X2NoYW5nZV9jaXBoZXJfc3VpdGUgLQorICovCitpbnQKK2llZWU4MDJfMXhfa2F5X2NoYW5nZV9jaXBoZXJfc3VpdGUoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIGludCBjc19pbmRleCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKnBhcnRpY2lwYW50OworCisJaWYgKCFrYXkpCisJCXJldHVybiAtMTsKKworCWlmICgodW5zaWduZWQgaW50KSBjc19pbmRleCA+PSBDU19UQUJMRV9TSVpFKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogQ29uZmlndXJlZCBjaXBoZXIgc3VpdGUgaW5kZXggaXMgb3V0IG9mIHJhbmdlIik7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKGtheS0+bWFjc2VjX2NzaW5kZXggPT0gY3NfaW5kZXgpCisJCXJldHVybiAtMjsKKworCWlmIChjc19pbmRleCA9PSAwKQorCQlrYXktPm1hY3NlY19kZXNpcmVkID0gRkFMU0U7CisKKwlrYXktPm1hY3NlY19jc2luZGV4ID0gY3NfaW5kZXg7CisJa2F5LT5tYWNzZWNfY2FwYWJsZSA9IGNpcGhlcl9zdWl0ZV90Ymxba2F5LT5tYWNzZWNfY3NpbmRleF0uY2FwYWJsZTsKKworCXBhcnRpY2lwYW50ID0gaWVlZTgwMl8xeF9rYXlfZ2V0X3ByaW5jaXBhbF9wYXJ0aWNpcGFudChrYXkpOworCWlmIChwYXJ0aWNpcGFudCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiS2FZOiBDaXBoZXIgU3VpdGUgY2hhbmdlZCIpOworCQlwYXJ0aWNpcGFudC0+bmV3X3NhayA9IFRSVUU7CisJfQorCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9zcmMvcGFlL2llZWU4MDJfMXhfa2F5LmggYi9zcmMvcGFlL2llZWU4MDJfMXhfa2F5LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDY0NDE3ZQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9wYWUvaWVlZTgwMl8xeF9rYXkuaApAQCAtMCwwICsxLDE5NCBAQAorLyoKKyAqIElFRUUgODAyLjFYLTIwMTAgS2V5IEFncmVlIFByb3RvY29sIG9mIFBBRSBzdGF0ZSBtYWNoaW5lCisgKiBDb3B5cmlnaHQgKGMpIDIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgSUVFRTgwMl8xWF9LQVlfSAorI2RlZmluZSBJRUVFODAyXzFYX0tBWV9ICisKKyNpbmNsdWRlICJ1dGlscy9saXN0LmgiCisjaW5jbHVkZSAiY29tbW9uL2RlZnMuaCIKKyNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xeF9kZWZzLmgiCisKK3N0cnVjdCBtYWNzZWNfaW5pdF9wYXJhbXM7CitzdHJ1Y3QgaWVlZTgwMl8xeF9jcF9jb25mOworCisjZGVmaW5lIE1JX0xFTgkJCTEyCisjZGVmaW5lIE1BWF9LRVlfTEVOCQkzMiAgLyogMzIgYnl0ZXMsIDI1NiBiaXRzICovCisjZGVmaW5lIE1BWF9DS05fTEVOCQkzMiAgLyogMzIgYnl0ZXMsIDI1NiBiaXRzICovCisKKy8qIE1LQSB0aW1lciwgdW5pdDogbWlsbGlzZWNvbmQgKi8KKyNkZWZpbmUgTUtBX0hFTExPX1RJTUUJCTIwMDAKKyNkZWZpbmUgTUtBX0xJRkVfVElNRQkJNjAwMAorI2RlZmluZSBNS0FfU0FLX1JFVElSRV9USU1FCTMwMDAKKworc3RydWN0IGllZWU4MDJfMXhfbWthX2tpIHsKKwl1OCBtaVtNSV9MRU5dOworCXUzMiBrbjsKK307CisKK3N0cnVjdCBpZWVlODAyXzF4X21rYV9zY2kgeworCXU4IGFkZHJbRVRIX0FMRU5dOworCXUxNiBwb3J0OworfTsKKworc3RydWN0IG1rYV9rZXkgeworCXU4IGtleVtNQVhfS0VZX0xFTl07CisJc2l6ZV90IGxlbjsKK307CisKK3N0cnVjdCBta2Ffa2V5X25hbWUgeworCXU4IG5hbWVbTUFYX0NLTl9MRU5dOworCXNpemVfdCBsZW47Cit9OworCitlbnVtIG1rYV9jcmVhdGVkX21vZGUgeworCVBTSywKKwlFQVBfRVhDSEFOR0UsCisJRElTVFJJQlVURUQsCisJQ0FDSEVELAorfTsKKworc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCB7CisJLyogcG9pbnRlciB0byBhcmJpdHJhcnkgdXBwZXIgbGV2ZWwgY29udGV4dCAqLworCXZvaWQgKmN0eDsKKworCS8qIGFic3RyYWN0IHdwYSBkcml2ZXIgaW50ZXJmYWNlICovCisJaW50ICgqbWFjc2VjX2luaXQpKHZvaWQgKmN0eCwgc3RydWN0IG1hY3NlY19pbml0X3BhcmFtcyAqcGFyYW1zKTsKKwlpbnQgKCptYWNzZWNfZGVpbml0KSh2b2lkICpjdHgpOworCWludCAoKmVuYWJsZV9wcm90ZWN0X2ZyYW1lcykodm9pZCAqY3R4LCBCb29sZWFuIGVuYWJsZWQpOworCWludCAoKnNldF9yZXBsYXlfcHJvdGVjdCkodm9pZCAqY3R4LCBCb29sZWFuIGVuYWJsZWQsIHUzMiB3aW5kb3cpOworCWludCAoKnNldF9jdXJyZW50X2NpcGhlcl9zdWl0ZSkodm9pZCAqY3R4LCBjb25zdCB1OCAqY3MsIHNpemVfdCBjc19sZW4pOworCWludCAoKmVuYWJsZV9jb250cm9sbGVkX3BvcnQpKHZvaWQgKmN0eCwgQm9vbGVhbiBlbmFibGVkKTsKKwlpbnQgKCpnZXRfcmVjZWl2ZV9sb3dlc3RfcG4pKHZvaWQgKmN0eCwgdTMyIGNoYW5uZWwsIHU4IGFuLAorCQkJCSAgICAgdTMyICpsb3dlc3RfcG4pOworCWludCAoKmdldF90cmFuc21pdF9uZXh0X3BuKSh2b2lkICpjdHgsIHUzMiBjaGFubmVsLCB1OCBhbiwKKwkJCQkgICAgdTMyICpuZXh0X3BuKTsKKwlpbnQgKCpzZXRfdHJhbnNtaXRfbmV4dF9wbikodm9pZCAqY3R4LCB1MzIgY2hhbm5lbCwgdTggYW4sIHUzMiBuZXh0X3BuKTsKKwlpbnQgKCpnZXRfYXZhaWxhYmxlX3JlY2VpdmVfc2MpKHZvaWQgKmN0eCwgdTMyICpjaGFubmVsKTsKKwlpbnQgKCpjcmVhdGVfcmVjZWl2ZV9zYykodm9pZCAqY3R4LCB1MzIgY2hhbm5lbCwKKwkJCQkgc3RydWN0IGllZWU4MDJfMXhfbWthX3NjaSAqc2NpLAorCQkJCSBlbnVtIHZhbGlkYXRlX2ZyYW1lcyB2ZiwKKwkJCQkgZW51bSBjb25maWRlbnRpYWxpdHlfb2Zmc2V0IGNvKTsKKwlpbnQgKCpkZWxldGVfcmVjZWl2ZV9zYykodm9pZCAqY3R4LCB1MzIgY2hhbm5lbCk7CisJaW50ICgqY3JlYXRlX3JlY2VpdmVfc2EpKHZvaWQgKmN0eCwgdTMyIGNoYW5uZWwsIHU4IGFuLCB1MzIgbG93ZXN0X3BuLAorCQkJCSBjb25zdCB1OCAqc2FrKTsKKwlpbnQgKCplbmFibGVfcmVjZWl2ZV9zYSkodm9pZCAqY3R4LCB1MzIgY2hhbm5lbCwgdTggYW4pOworCWludCAoKmRpc2FibGVfcmVjZWl2ZV9zYSkodm9pZCAqY3R4LCB1MzIgY2hhbm5lbCwgdTggYW4pOworCWludCAoKmdldF9hdmFpbGFibGVfdHJhbnNtaXRfc2MpKHZvaWQgKmN0eCwgdTMyICpjaGFubmVsKTsKKwlpbnQgKCpjcmVhdGVfdHJhbnNtaXRfc2MpKHZvaWQgKmN0eCwgdTMyIGNoYW5uZWwsCisJCQkJICBjb25zdCBzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffc2NpICpzY2ksCisJCQkJICBlbnVtIGNvbmZpZGVudGlhbGl0eV9vZmZzZXQgY28pOworCWludCAoKmRlbGV0ZV90cmFuc21pdF9zYykodm9pZCAqY3R4LCB1MzIgY2hhbm5lbCk7CisJaW50ICgqY3JlYXRlX3RyYW5zbWl0X3NhKSh2b2lkICpjdHgsIHUzMiBjaGFubmVsLCB1OCBhbiwgdTMyIG5leHRfcG4sCisJCQkJICBCb29sZWFuIGNvbmZpZGVudGlhbGl0eSwgY29uc3QgdTggKnNhayk7CisJaW50ICgqZW5hYmxlX3RyYW5zbWl0X3NhKSh2b2lkICpjdHgsIHUzMiBjaGFubmVsLCB1OCBhbik7CisJaW50ICgqZGlzYWJsZV90cmFuc21pdF9zYSkodm9pZCAqY3R4LCB1MzIgY2hhbm5lbCwgdTggYW4pOworfTsKKworc3RydWN0IGllZWU4MDJfMXhfa2F5IHsKKwlCb29sZWFuIGVuYWJsZTsKKwlCb29sZWFuIGFjdGl2ZTsKKworCUJvb2xlYW4gYXV0aGVudGljYXRlZDsKKwlCb29sZWFuIHNlY3VyZWQ7CisJQm9vbGVhbiBmYWlsZWQ7CisKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffc2NpIGFjdG9yX3NjaTsKKwl1OCBhY3Rvcl9wcmlvcml0eTsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffc2NpIGtleV9zZXJ2ZXJfc2NpOworCXU4IGtleV9zZXJ2ZXJfcHJpb3JpdHk7CisKKwllbnVtIG1hY3NlY19jYXAgbWFjc2VjX2NhcGFibGU7CisJQm9vbGVhbiBtYWNzZWNfZGVzaXJlZDsKKwlCb29sZWFuIG1hY3NlY19wcm90ZWN0OworCUJvb2xlYW4gbWFjc2VjX3JlcGxheV9wcm90ZWN0OworCXUzMiBtYWNzZWNfcmVwbGF5X3dpbmRvdzsKKwllbnVtIHZhbGlkYXRlX2ZyYW1lcyBtYWNzZWNfdmFsaWRhdGU7CisJZW51bSBjb25maWRlbnRpYWxpdHlfb2Zmc2V0IG1hY3NlY19jb25maWRlbnRpYWxpdHk7CisKKwl1MzIgbHR4X2tuOworCXU4IGx0eF9hbjsKKwl1MzIgbHJ4X2tuOworCXU4IGxyeF9hbjsKKworCXUzMiBvdHhfa247CisJdTggb3R4X2FuOworCXUzMiBvcnhfa247CisJdTggb3J4X2FuOworCisJLyogbm90IGRlZmluZWQgaW4gSUVFRTgwMi4xWCAqLworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKmN0eDsKKwlCb29sZWFuIGlzX2tleV9zZXJ2ZXI7CisJQm9vbGVhbiBpc19vYmxpZ2VkX2tleV9zZXJ2ZXI7CisJY2hhciBpZl9uYW1lW0lGTkFNU0laXTsKKworCWludCBtYWNzZWNfY3NpbmRleDsgIC8qICBNQUNzZWMgY2lwaGVyIHN1aXRlIHRhYmxlIGluZGV4ICovCisJaW50IG1rYV9hbGdpbmRleDsgIC8qIE1LQSBhbGcgdGFibGUgaW5kZXggKi8KKworCXUzMiBkaXN0X2tuOworCXU4IGRpc3RfYW47CisJdGltZV90IGRpc3RfdGltZTsKKworCXU4IG1rYV92ZXJzaW9uOworCXU4IGFsZ29fYWdpbGl0eVs0XTsKKwl1MzIgc2NfY2g7CisKKwl1MzIgcG5fZXhoYXVzdGlvbjsKKwlCb29sZWFuIHBvcnRfZW5hYmxlOworCUJvb2xlYW4gcnhfZW5hYmxlOworCUJvb2xlYW4gdHhfZW5hYmxlOworCisJc3RydWN0IGRsX2xpc3QgcGFydGljaXBhbnRfbGlzdDsKKwllbnVtIG1hY3NlY19wb2xpY3kgcG9saWN5OworCisJc3RydWN0IGllZWU4MDJfMXhfY3Bfc20gKmNwOworCisJc3RydWN0IGwyX3BhY2tldF9kYXRhICpsMl9ta2E7CisKKwllbnVtIHZhbGlkYXRlX2ZyYW1lcyB2ZjsKKwllbnVtIGNvbmZpZGVudGlhbGl0eV9vZmZzZXQgY287Cit9OworCisKK3N0cnVjdCBpZWVlODAyXzF4X2theSAqCitpZWVlODAyXzF4X2theV9pbml0KHN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKmN0eCwgZW51bSBtYWNzZWNfcG9saWN5IHBvbGljeSwKKwkJICAgIGNvbnN0IGNoYXIgKmlmbmFtZSwgY29uc3QgdTggKmFkZHIpOwordm9pZCBpZWVlODAyXzF4X2theV9kZWluaXQoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXkpOworCitzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGFydGljaXBhbnQgKgoraWVlZTgwMl8xeF9rYXlfY3JlYXRlX21rYShzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCSAgc3RydWN0IG1rYV9rZXlfbmFtZSAqY2tuLCBzdHJ1Y3QgbWthX2tleSAqY2FrLAorCQkJICB1MzIgbGlmZSwgZW51bSBta2FfY3JlYXRlZF9tb2RlIG1vZGUsCisJCQkgIEJvb2xlYW4gaXNfYXV0aGVudGljYXRvcik7Cit2b2lkIGllZWU4MDJfMXhfa2F5X2RlbGV0ZV9ta2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgICAgc3RydWN0IG1rYV9rZXlfbmFtZSAqY2tuKTsKK3ZvaWQgaWVlZTgwMl8xeF9rYXlfbWthX3BhcnRpY2lwYXRlKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCSAgICBzdHJ1Y3QgbWthX2tleV9uYW1lICpja24sCisJCQkJICAgIEJvb2xlYW4gc3RhdHVzKTsKK2ludCBpZWVlODAyXzF4X2theV9uZXdfc2FrKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5KTsKK2ludCBpZWVlODAyXzF4X2theV9jaGFuZ2VfY2lwaGVyX3N1aXRlKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCSAgICAgICBpbnQgY3NfaW5kZXgpOworCitpbnQgaWVlZTgwMl8xeF9rYXlfc2V0X2xhdGVzdF9zYV9hdHRyKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCSAgICAgIHN0cnVjdCBpZWVlODAyXzF4X21rYV9raSAqbGtpLCB1OCBsYW4sCisJCQkJICAgICAgQm9vbGVhbiBsdHgsIEJvb2xlYW4gbHJ4KTsKK2ludCBpZWVlODAyXzF4X2theV9zZXRfb2xkX3NhX2F0dHIoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkJICAgc3RydWN0IGllZWU4MDJfMXhfbWthX2tpICpva2ksCisJCQkJICAgdTggb2FuLCBCb29sZWFuIG90eCwgQm9vbGVhbiBvcngpOworaW50IGllZWU4MDJfMXhfa2F5X2NyZWF0ZV9zYXMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgICBzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffa2kgKmxraSk7CitpbnQgaWVlZTgwMl8xeF9rYXlfZGVsZXRlX3NhcyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCSAgICAgIHN0cnVjdCBpZWVlODAyXzF4X21rYV9raSAqa2kpOworaW50IGllZWU4MDJfMXhfa2F5X2VuYWJsZV90eF9zYXMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkJIHN0cnVjdCBpZWVlODAyXzF4X21rYV9raSAqbGtpKTsKK2ludCBpZWVlODAyXzF4X2theV9lbmFibGVfcnhfc2FzKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCSBzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffa2kgKmxraSk7CitpbnQgaWVlZTgwMl8xeF9rYXlfZW5hYmxlX25ld19pbmZvKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5KTsKK2ludCBpZWVlODAyXzF4X2theV9jcF9jb25mKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgc3RydWN0IGllZWU4MDJfMXhfY3BfY29uZiAqcGNvbmYpOworCisjZW5kaWYgLyogSUVFRTgwMl8xWF9LQVlfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3BhZS9pZWVlODAyXzF4X2theV9pLmggYi9zcmMvcGFlL2llZWU4MDJfMXhfa2F5X2kuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iZGFkM2E1Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3BhZS9pZWVlODAyXzF4X2theV9pLmgKQEAgLTAsMCArMSw0MTkgQEAKKy8qCisgKiBJRUVFIDgwMi4xWC0yMDEwIEtleSBBZ3JlZSBQcm90b2NvbCBvZiBQQUUgc3RhdGUgbWFjaGluZQorICogQ29weXJpZ2h0IChjKSAyMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIElFRUU4MDJfMVhfS0FZX0lfSAorI2RlZmluZSBJRUVFODAyXzFYX0tBWV9JX0gKKworI2luY2x1ZGUgInV0aWxzL2xpc3QuaCIKKyNpbmNsdWRlICJjb21tb24vZGVmcy5oIgorI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzF4X2RlZnMuaCIKKworI2RlZmluZSBNS0FfVkVSU0lPTl9JRCAgICAgICAgICAgICAgMQorCisvKiBJRUVFIFN0ZCA4MDIuMVgtMjAxMCwgMTEuMTEuMSwgVGFibGUgMTEtNyAqLworZW51bSBta2FfcGFja2V0X3R5cGUgeworCU1LQV9CQVNJQ19QQVJBTUVURVJfU0VUID0gTUtBX1ZFUlNJT05fSUQsCisJTUtBX0xJVkVfUEVFUl9MSVNUID0gMSwKKwlNS0FfUE9URU5USUFMX1BFRVJfTElTVCA9IDIsCisJTUtBX1NBS19VU0UgPSAzLAorCU1LQV9ESVNUUklCVVRFRF9TQUsgPSA0LAorCU1LQV9ESVNUUklCVVRFRF9DQUsgPSA1LAorCU1LQV9LTUQgPSA2LAorCU1LQV9BTk5PVU5DRU1FTlQgPSA3LAorCU1LQV9JQ1ZfSU5ESUNBVE9SID0gMjU1Cit9OworCisjZGVmaW5lIElDVl9MRU4gICAgICAgICAgICAgICAgICAgICAgICAgMTYgIC8qIDE2IGJ5dGVzICovCisjZGVmaW5lIFNBS19XUkFQUEVEX0xFTiAgICAgICAgICAgICAgICAgMjQKKy8qIEtOICsgV3JhcHBlciBTQUsgKi8KKyNkZWZpbmUgREVGQVVMVF9ESVNfU0FLX0JPRFlfTEVOR1RIICAgICAoU0FLX1dSQVBQRURfTEVOICsgNCkKKyNkZWZpbmUgTUFYX1JFVFJZX0NOVCAgICAgICAgICAgICAgICAgICA1CisKK3N0cnVjdCBpZWVlODAyXzF4X2theTsKKworc3RydWN0IGllZWU4MDJfMXhfbWthX3BlZXJfaWQgeworCXU4IG1pW01JX0xFTl07CisJdTMyIG1uOworfTsKKworc3RydWN0IGllZWU4MDJfMXhfa2F5X3BlZXIgeworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9zY2kgc2NpOworCXU4IG1pW01JX0xFTl07CisJdTMyIG1uOworCXRpbWVfdCBleHBpcmU7CisJQm9vbGVhbiBpc19rZXlfc2VydmVyOworCXU4IGtleV9zZXJ2ZXJfcHJpb3JpdHk7CisJQm9vbGVhbiBtYWNzZWNfZGVzaXJlZDsKKwllbnVtIG1hY3NlY19jYXAgbWFjc2VjX2NhcGJpbGl0eTsKKwlCb29sZWFuIHNha191c2VkOworCXN0cnVjdCBkbF9saXN0IGxpc3Q7Cit9OworCitzdHJ1Y3Qga2V5X2NvbmYgeworCXU4ICprZXk7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2tpIGtpOworCWVudW0gY29uZmlkZW50aWFsaXR5X29mZnNldCBvZmZzZXQ7CisJdTggYW47CisJQm9vbGVhbiB0eDsKKwlCb29sZWFuIHJ4OworCWludCBrZXlfbGVuOyAvKiB1bml0OiBieXRlICovCit9OworCitzdHJ1Y3QgZGF0YV9rZXkgeworCXU4ICprZXk7CisJaW50IGtleV9sZW47CisJc3RydWN0IGllZWU4MDJfMXhfbWthX2tpIGtleV9pZGVudGlmaWVyOworCWVudW0gY29uZmlkZW50aWFsaXR5X29mZnNldCBjb25maWRlbnRpYWxpdHlfb2Zmc2V0OworCXU4IGFuOworCUJvb2xlYW4gdHJhbnNtaXRzOworCUJvb2xlYW4gcmVjZWl2ZXM7CisJc3RydWN0IG9zX3RpbWUgY3JlYXRlZF90aW1lOworCXUzMiBuZXh0X3BuOworCisJLyogbm90IGRlZmluZWQgZGF0YSAqLworCUJvb2xlYW4gcnhfbGF0ZXN0OworCUJvb2xlYW4gdHhfbGF0ZXN0OworCisJaW50IHVzZXI7ICAvKiBGSVhNRTogdG8gaW5kaWNhdGUgaWYgaXQgY2FuIGJlIGRlbGV0ZSBzYWZlbHkgKi8KKworCXN0cnVjdCBkbF9saXN0IGxpc3Q7Cit9OworCisvKiBUcmFuc21pdFNDIGluIElFRUUgU3RkIDgwMi4xQUUtMjAwNiwgRmlndXJlIDEwLTYgKi8KK3N0cnVjdCB0cmFuc21pdF9zYyB7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3NjaSBzY2k7IC8qIGNvbnN0IFNDSSBzY2kgKi8KKwlCb29sZWFuIHRyYW5zbWl0dGluZzsgLyogYm9vbCB0cmFuc21pdHRpbmcgKHJlYWQgb25seSkgKi8KKworCXN0cnVjdCBvc190aW1lIGNyZWF0ZWRfdGltZTsgLyogVGltZSBjcmVhdGVkVGltZSAqLworCisJdTggZW5jb2Rpbmdfc2E7IC8qIEFOIGVuY29kaW5nU0EgKHJlYWQgb25seSkgKi8KKwl1OCBlbmNpcGhlcmluZ19zYTsgLyogQU4gZW5jaXBoZXJpbmdTQSAocmVhZCBvbmx5KSAqLworCisJLyogbm90IGRlZmluZWQgZGF0YSAqLworCXVuc2lnbmVkIGludCBjaGFubmVsOworCisJc3RydWN0IGRsX2xpc3QgbGlzdDsKKwlzdHJ1Y3QgZGxfbGlzdCBzYV9saXN0OworfTsKKworLyogVHJhbnNtaXRTQSBpbiBJRUVFIFN0ZCA4MDIuMUFFLTIwMDYsIEZpZ3VyZSAxMC02ICovCitzdHJ1Y3QgdHJhbnNtaXRfc2EgeworCUJvb2xlYW4gaW5fdXNlOyAvKiBib29sIGluVXNlIChyZWFkIG9ubHkpICovCisJdTMyIG5leHRfcG47IC8qIFBOIG5leHRQTiAocmVhZCBvbmx5KSAqLworCXN0cnVjdCBvc190aW1lIGNyZWF0ZWRfdGltZTsgLyogVGltZSBjcmVhdGVkVGltZSAqLworCisJQm9vbGVhbiBlbmFibGVfdHJhbnNtaXQ7IC8qIGJvb2wgRW5hYmxlVHJhbnNtaXQgKi8KKworCXU4IGFuOworCUJvb2xlYW4gY29uZmlkZW50aWFsaXR5OworCXN0cnVjdCBkYXRhX2tleSAqcGtleTsKKworCXN0cnVjdCB0cmFuc21pdF9zYyAqc2M7CisJc3RydWN0IGRsX2xpc3QgbGlzdDsgLyogbGlzdCBlbnRyeSBpbiBzdHJ1Y3QgdHJhbnNtaXRfc2M6OnNhX2xpc3QgKi8KK307CisKKy8qIFJlY2VpdmVTQyBpbiBJRUVFIFN0ZCA4MDIuMUFFLTIwMDYsIEZpZ3VyZSAxMC02ICovCitzdHJ1Y3QgcmVjZWl2ZV9zYyB7CisJc3RydWN0IGllZWU4MDJfMXhfbWthX3NjaSBzY2k7IC8qIGNvbnN0IFNDSSBzY2kgKi8KKwlCb29sZWFuIHJlY2VpdmluZzsgLyogYm9vbCByZWNlaXZpbmcgKHJlYWQgb25seSkgKi8KKworCXN0cnVjdCBvc190aW1lIGNyZWF0ZWRfdGltZTsgLyogVGltZSBjcmVhdGVkVGltZSAqLworCisJdW5zaWduZWQgaW50IGNoYW5uZWw7CisKKwlzdHJ1Y3QgZGxfbGlzdCBsaXN0OworCXN0cnVjdCBkbF9saXN0IHNhX2xpc3Q7Cit9OworCisvKiBSZWNlaXZlU0EgaW4gSUVFRSBTdGQgODAyLjFBRS0yMDA2LCBGaWd1cmUgMTAtNiAqLworc3RydWN0IHJlY2VpdmVfc2EgeworCUJvb2xlYW4gZW5hYmxlX3JlY2VpdmU7IC8qIGJvb2wgZW5hYmxlUmVjZWl2ZSAqLworCUJvb2xlYW4gaW5fdXNlOyAvKiBib29sIGluVXNlIChyZWFkIG9ubHkpICovCisKKwl1MzIgbmV4dF9wbjsgLyogUE4gbmV4dFBOIChyZWFkIG9ubHkpICovCisJdTMyIGxvd2VzdF9wbjsgLyogUE4gbG93ZXN0UE4gKHJlYWQgb25seSkgKi8KKwl1OCBhbjsKKwlzdHJ1Y3Qgb3NfdGltZSBjcmVhdGVkX3RpbWU7CisKKwlzdHJ1Y3QgZGF0YV9rZXkgKnBrZXk7CisJc3RydWN0IHJlY2VpdmVfc2MgKnNjOyAvKiBsaXN0IGVudHJ5IGluIHN0cnVjdCByZWNlaXZlX3NjOjpzYV9saXN0ICovCisKKwlzdHJ1Y3QgZGxfbGlzdCBsaXN0OworfTsKKworc3RydWN0IG1hY3NlY19jaXBoZXJzdWl0ZSB7CisJdTggaWRbQ1NfSURfTEVOXTsKKwljaGFyIG5hbWVbMzJdOworCWVudW0gbWFjc2VjX2NhcCBjYXBhYmxlOworCWludCBzYWtfbGVuOyAvKiB1bml0OiBieXRlICovCisKKwl1MzIgaW5kZXg7Cit9OworCitzdHJ1Y3QgbWthX2FsZyB7CisJdTggcGFyYW1ldGVyWzRdOworCXNpemVfdCBjYWtfbGVuOworCXNpemVfdCBrZWtfbGVuOworCXNpemVfdCBpY2tfbGVuOworCXNpemVfdCBpY3ZfbGVuOworCisJaW50ICgqY2FrX3RyZm0pKGNvbnN0IHU4ICptc2ssIGNvbnN0IHU4ICptYWMxLCBjb25zdCB1OCAqbWFjMiwgdTggKmNhayk7CisJaW50ICgqY2tuX3RyZm0pKGNvbnN0IHU4ICptc2ssIGNvbnN0IHU4ICptYWMxLCBjb25zdCB1OCAqbWFjMiwKKwkJCWNvbnN0IHU4ICpzaWQsIHNpemVfdCBzaWRfbGVuLCB1OCAqY2tuKTsKKwlpbnQgKCprZWtfdHJmbSkoY29uc3QgdTggKmNhaywgY29uc3QgdTggKmNrbiwgc2l6ZV90IGNrbl9sZW4sIHU4ICprZWspOworCWludCAoKmlja190cmZtKShjb25zdCB1OCAqY2FrLCBjb25zdCB1OCAqY2tuLCBzaXplX3QgY2tuX2xlbiwgdTggKmljayk7CisJaW50ICgqaWN2X2hhc2gpKGNvbnN0IHU4ICppY2ssIGNvbnN0IHU4ICptc2csIHNpemVfdCBtc2dfbGVuLCB1OCAqaWN2KTsKKworCWludCBpbmRleDsgLyogaW5kZXggZm9yIGNvbmZpZ3VyaW5nICovCit9OworCisjZGVmaW5lIERFRkFVTFRfTUtBX0FMR19JTkRFWCAwCisKKy8qIFNlZSBJRUVFIFN0ZCA4MDIuMVgtMjAxMCwgOS4xNiBNS0EgbWFuYWdlbWVudCAqLworc3RydWN0IGllZWU4MDJfMXhfbWthX3BhcnRpY2lwYW50IHsKKwkvKiB1c2VkIGZvciBhY3RpdmUgYW5kIHBvdGVudGlhbCBwYXJ0aWNpcGFudCAqLworCXN0cnVjdCBta2Ffa2V5X25hbWUgY2tuOworCXN0cnVjdCBta2Ffa2V5IGNhazsKKwlCb29sZWFuIGNhY2hlZDsKKworCS8qIHVzZWQgYnkgbWFuYWdlbWVudCB0byBtb25pdG9yIGFuZCBjb250cm9sIGFjdGl2YXRpb24gKi8KKwlCb29sZWFuIGFjdGl2ZTsKKwlCb29sZWFuIHBhcnRpY2lwYW50OworCUJvb2xlYW4gcmV0YWluOworCisJZW51bSB7IERFRkFVTFQsIERJU0FCTEVELCBPTl9PUEVSX1VQLCBBTFdBWVMgfSBhY3RpdmF0ZTsKKworCS8qIHVzZWQgZm9yIGFjdGl2ZSBwYXJ0aWNpcGFudCAqLworCUJvb2xlYW4gcHJpbmNpcGFsOworCXN0cnVjdCBkbF9saXN0IGxpdmVfcGVlcnM7CisJc3RydWN0IGRsX2xpc3QgcG90ZW50aWFsX3BlZXJzOworCisJLyogbm90IGRlZmluZWQgaW4gSUVFRSA4MDIuMVggKi8KKwlzdHJ1Y3QgZGxfbGlzdCBsaXN0OworCisJc3RydWN0IG1rYV9rZXkga2VrOworCXN0cnVjdCBta2Ffa2V5IGljazsKKworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9raSBsa2k7CisJdTggbGFuOworCUJvb2xlYW4gbHR4OworCUJvb2xlYW4gbHJ4OworCisJc3RydWN0IGllZWU4MDJfMXhfbWthX2tpIG9raTsKKwl1OCBvYW47CisJQm9vbGVhbiBvdHg7CisJQm9vbGVhbiBvcng7CisKKwlCb29sZWFuIGlzX2tleV9zZXJ2ZXI7CisJQm9vbGVhbiBpc19vYmxpZ2VkX2tleV9zZXJ2ZXI7CisJQm9vbGVhbiBjYW5fYmVfa2V5X3NlcnZlcjsKKwlCb29sZWFuIGlzX2VsZWN0ZWQ7CisKKwlzdHJ1Y3QgZGxfbGlzdCBzYWtfbGlzdDsKKwlzdHJ1Y3QgZGxfbGlzdCByeHNjX2xpc3Q7CisKKwlzdHJ1Y3QgdHJhbnNtaXRfc2MgKnR4c2M7CisKKwl1OCBtaVtNSV9MRU5dOworCXUzMiBtbjsKKworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9wZWVyX2lkIGN1cnJlbnRfcGVlcl9pZDsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffc2NpIGN1cnJlbnRfcGVlcl9zY2k7CisJdGltZV90IGNha19saWZlOworCXRpbWVfdCBta2FfbGlmZTsKKwlCb29sZWFuIHRvX2Rpc3Rfc2FrOworCUJvb2xlYW4gdG9fdXNlX3NhazsKKwlCb29sZWFuIG5ld19zYWs7CisKKwlCb29sZWFuIGFkdmlzZWRfZGVzaXJlZDsKKwllbnVtIG1hY3NlY19jYXAgYWR2aXNlZF9jYXBhYmlsaXR5OworCisJc3RydWN0IGRhdGFfa2V5ICpuZXdfa2V5OworCXUzMiByZXRyeV9jb3VudDsKKworCXN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5OworfTsKKworc3RydWN0IGllZWU4MDJfMXhfbWthX2hkciB7CisJLyogb2N0ZXQgMSAqLworCXUzMiB0eXBlOjg7CisJLyogb2N0ZXQgMiAqLworCXUzMiByZXNlcnZlOjg7CisJLyogb2N0ZXQgMyAqLworI2lmIF9fQllURV9PUkRFUiA9PSBfX0xJVFRMRV9FTkRJQU4KKwl1MzIgbGVuZ3RoOjQ7CisJdTMyIHJlc2VydmUxOjQ7CisjZWxpZiBfX0JZVEVfT1JERVIgPT0gX19CSUdfRU5ESUFOCisJdTMyIHJlc2VydmUxOjQ7CisJdTMyIGxlbmd0aDo0OworI2Vsc2UKKyNlcnJvciAiUGxlYXNlIGZpeCA8Yml0cy9lbmRpYW4uaD4iCisjZW5kaWYKKwkvKiBvY3RldCA0ICovCisJdTMyIGxlbmd0aDE6ODsKK307CisKKyNkZWZpbmUgTUtBX0hEUl9MRU4gc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X21rYV9oZHIpCisKK3N0cnVjdCBpZWVlODAyXzF4X21rYV9iYXNpY19ib2R5IHsKKwkvKiBvY3RldCAxICovCisJdTMyIHZlcnNpb246ODsKKwkvKiBvY3RldCAyICovCisJdTMyIHByaW9yaXR5Ojg7CisJLyogb2N0ZXQgMyAqLworI2lmIF9fQllURV9PUkRFUiA9PSBfX0xJVFRMRV9FTkRJQU4KKwl1MzIgbGVuZ3RoOjQ7CisJdTMyIG1hY3NlY19jYXBiaWxpdHk6MjsKKwl1MzIgbWFjc2VjX2Rlc2lyZWQ6MTsKKwl1MzIga2V5X3NlcnZlcjoxOworI2VsaWYgX19CWVRFX09SREVSID09IF9fQklHX0VORElBTgorCXUzMiBrZXlfc2VydmVyOjE7CisJdTMyIG1hY3NlY19kZXNpcmVkOjE7CisJdTMyIG1hY3NlY19jYXBiaWxpdHk6MjsKKwl1MzIgbGVuZ3RoOjQ7CisjZW5kaWYKKwkvKiBvY3RldCA0ICovCisJdTMyIGxlbmd0aDE6ODsKKworCXN0cnVjdCBpZWVlODAyXzF4X21rYV9zY2kgYWN0b3Jfc2NpOworCXU4IGFjdG9yX21pW01JX0xFTl07CisJdTMyIGFjdG9yX21uOworCXU4IGFsZ29fYWdpbGl0eVs0XTsKKworCS8qIGZvbGxvd2VkIGJ5IENBSyBOYW1lKi8KKwl1OCBja25bMF07Cit9OworCitzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfcGVlcl9ib2R5IHsKKwkvKiBvY3RldCAxICovCisJdTMyIHR5cGU6ODsKKwkvKiBvY3RldCAyICovCisJdTMyIHJlc2VydmU6ODsKKwkvKiBvY3RldCAzICovCisjaWYgX19CWVRFX09SREVSID09IF9fTElUVExFX0VORElBTgorCXUzMiBsZW5ndGg6NDsKKwl1MzIgcmVzZXJ2ZTE6NDsKKyNlbGlmIF9fQllURV9PUkRFUiA9PSBfX0JJR19FTkRJQU4KKwl1MzIgcmVzZXJ2ZTE6NDsKKwl1MzIgbGVuZ3RoOjQ7CisjZW5kaWYKKwkvKiBvY3RldCA0ICovCisJdTMyIGxlbmd0aDE6ODsKKworCXU4IHBlZXJbMF07CisJLyogZm9sbG93ZWQgYnkgUGVlcnMgKi8KK307CisKK3N0cnVjdCBpZWVlODAyXzF4X21rYV9zYWtfdXNlX2JvZHkgeworCS8qIG9jdGV0IDEgKi8KKwl1MzIgdHlwZTo4OworCS8qIG9jdGV0IDIgKi8KKyNpZiBfX0JZVEVfT1JERVIgPT0gX19MSVRUTEVfRU5ESUFOCisJdTMyIG9yeDoxOworCXUzMiBvdHg6MTsKKwl1MzIgb2FuOjI7CisJdTMyIGxyeDoxOworCXUzMiBsdHg6MTsKKwl1MzIgbGFuOjI7CisjZWxpZiBfX0JZVEVfT1JERVIgPT0gX19CSUdfRU5ESUFOCisJdTMyIGxhbjoyOworCXUzMiBsdHg6MTsKKwl1MzIgbHJ4OjE7CisJdTMyIG9hbjoyOworCXUzMiBvdHg6MTsKKwl1MzIgb3J4OjE7CisjZW5kaWYKKworCS8qIG9jdGV0IDMgKi8KKyNpZiBfX0JZVEVfT1JERVIgPT0gX19MSVRUTEVfRU5ESUFOCisJdTMyIGxlbmd0aDo0OworCXUzMiBkZWxheV9wcm90ZWN0OjE7CisJdTMyIHJlc2VydmU6MTsKKwl1MzIgcHJ4OjE7CisJdTMyIHB0eDoxOworI2VsaWYgX19CWVRFX09SREVSID09IF9fQklHX0VORElBTgorCXUzMiBwdHg6MTsKKwl1MzIgcHJ4OjE7CisJdTMyIHJlc2VydmU6MTsKKwl1MzIgZGVsYXlfcHJvdGVjdDoxOworCXUzMiBsZW5ndGg6NDsKKyNlbmRpZgorCisJLyogb2N0ZXQgNCAqLworCXUzMiBsZW5ndGgxOjg7CisKKwkvKiBvY3RldCA1IC0gMTYgKi8KKwl1OCBsc3J2X21pW01JX0xFTl07CisJLyogb2N0ZXQgMTcgLSAyMCAqLworCXUzMiBsa247CisJLyogb2N0ZXQgMjEgLSAyNCAqLworCXUzMiBsbHBuOworCisJLyogb2N0ZXQgMjUgLSAzNiAqLworCXU4IG9zcnZfbWlbTUlfTEVOXTsKKwkvKiBvY3RldCAzNyAtIDQwICovCisJdTMyIG9rbjsKKwkvKiBvY3RldCA0MSAtIDQ0ICovCisJdTMyIG9scG47Cit9OworCisKK3N0cnVjdCBpZWVlODAyXzF4X21rYV9kaXN0X3Nha19ib2R5IHsKKwkvKiBvY3RldCAxICovCisJdTMyIHR5cGU6ODsKKwkvKiBvY3RldCAyICovCisjaWYgX19CWVRFX09SREVSID09IF9fTElUVExFX0VORElBTgorCXUzMiByZXNlcnZlOjQ7CisJdTMyIGNvbmZpZF9vZmZzZXQ6MjsKKwl1MzIgZGFuOjI7CisjZWxpZiBfX0JZVEVfT1JERVIgPT0gX19CSUdfRU5ESUFOCisJdTMyIGRhbjoyOworCXUzMiBjb25maWRfb2Zmc2V0OjI7CisJdTMyIHJlc2VydmU6NDsKKyNlbmRpZgorCS8qIG9jdGV0IDMgKi8KKyNpZiBfX0JZVEVfT1JERVIgPT0gX19MSVRUTEVfRU5ESUFOCisJdTMyIGxlbmd0aDo0OworCXUzMiByZXNlcnZlMTo0OworI2VsaWYgX19CWVRFX09SREVSID09IF9fQklHX0VORElBTgorCXUzMiByZXNlcnZlMTo0OworCXUzMiBsZW5ndGg6NDsKKyNlbmRpZgorCS8qIG9jdGV0IDQgKi8KKwl1MzIgbGVuZ3RoMTo4OworCS8qIG9jdGV0IDUgLSA4ICovCisJdTMyIGtuOworCisJLyogZm9yIEdDTS1BRVMtMTI4OiBvY3RldCA5LTMyOiBTQUsKKwkgKiBmb3Igb3RoZXIgY2lwaGVyIHN1aXRlOiBvY3RldCA5LTE2OiBjaXBoZXIgc3VpdGUgaWQsIG9jdGV0IDE3LTogU0FLCisJICovCisJdTggc2FrWzBdOworfTsKKworCitzdHJ1Y3QgaWVlZTgwMl8xeF9ta2FfaWN2X2JvZHkgeworCS8qIG9jdGV0IDEgKi8KKwl1MzIgdHlwZTo4OworCS8qIG9jdGV0IDIgKi8KKwl1MzIgcmVzZXJ2ZTo4OworCS8qIG9jdGV0IDMgKi8KKyNpZiBfX0JZVEVfT1JERVIgPT0gX19MSVRUTEVfRU5ESUFOCisJdTMyIGxlbmd0aDo0OworCXUzMiByZXNlcnZlMTo0OworI2VsaWYgX19CWVRFX09SREVSID09IF9fQklHX0VORElBTgorCXUzMiByZXNlcnZlMTo0OworCXUzMiBsZW5ndGg6NDsKKyNlbmRpZgorCS8qIG9jdGV0IDQgKi8KKwl1MzIgbGVuZ3RoMTo4OworCisJLyogb2N0ZXQgNSAtICovCisJdTggaWN2WzBdOworfTsKKworI2VuZGlmIC8qIElFRUU4MDJfMVhfS0FZX0lfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3BhZS9pZWVlODAyXzF4X2tleS5jIGIvc3JjL3BhZS9pZWVlODAyXzF4X2tleS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjlhOGQ5MjMKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvcGFlL2llZWU4MDJfMXhfa2V5LmMKQEAgLTAsMCArMSwxODkgQEAKKy8qCisgKiBJRUVFIDgwMi4xWC0yMDEwIEtleSBIaWVyYXJjaHkKKyAqIENvcHlyaWdodCAoYykgMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogU0FLIGRlcml2YXRpb24gc3BlY2lmaWVkIGluIElFRUUgU3RkIDgwMi4xWC0yMDEwLCBDbGF1c2UgNi4yCisqLworCisjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgImNyeXB0by9tZDUuaCIKKyNpbmNsdWRlICJjcnlwdG8vc2hhMS5oIgorI2luY2x1ZGUgImNyeXB0by9hZXNfd3JhcC5oIgorI2luY2x1ZGUgImNyeXB0by9jcnlwdG8uaCIKKyNpbmNsdWRlICJpZWVlODAyXzF4X2tleS5oIgorCisKK3N0YXRpYyB2b2lkIGpvaW50X3R3b19tYWMoY29uc3QgdTggKm1hYzEsIGNvbnN0IHU4ICptYWMyLCB1OCAqb3V0KQoreworCWlmIChvc19tZW1jbXAobWFjMSwgbWFjMiwgRVRIX0FMRU4pIDwgMCkgeworCQlvc19tZW1jcHkob3V0LCBtYWMxLCBFVEhfQUxFTik7CisJCW9zX21lbWNweShvdXQgKyBFVEhfQUxFTiwgbWFjMiwgRVRIX0FMRU4pOworCX0gZWxzZSB7CisJCW9zX21lbWNweShvdXQsIG1hYzIsIEVUSF9BTEVOKTsKKwkJb3NfbWVtY3B5KG91dCArIEVUSF9BTEVOLCBtYWMxLCBFVEhfQUxFTik7CisJfQorfQorCisKKy8qIElFRUUgU3RkIDgwMi4xWC0yMDEwLCA2LjIuMSBLREYgKi8KK3N0YXRpYyBpbnQgYWVzX2tkZl8xMjgoY29uc3QgdTggKmtkaywgY29uc3QgY2hhciAqbGFiZWwsIGNvbnN0IHU4ICpjb250ZXh0LAorCQkgICAgICAgaW50IGN0eF9iaXRzLCBpbnQgcmV0X2JpdHMsIHU4ICpyZXQpCit7CisJY29uc3QgaW50IGggPSAxMjg7CisJY29uc3QgaW50IHIgPSA4OworCWludCBpLCBuOworCWludCBsYWJfbGVuLCBjdHhfbGVuLCByZXRfbGVuLCBidWZfbGVuOworCXU4ICpidWY7CisKKwlsYWJfbGVuID0gb3Nfc3RybGVuKGxhYmVsKTsKKwljdHhfbGVuID0gKGN0eF9iaXRzICsgNykgLyA4OworCXJldF9sZW4gPSAoKHJldF9iaXRzICYgMHhmZmZmKSArIDcpIC8gODsKKwlidWZfbGVuID0gbGFiX2xlbiArIGN0eF9sZW4gKyA0OworCisJb3NfbWVtc2V0KHJldCwgMCwgcmV0X2xlbik7CisKKwluID0gKHJldF9iaXRzICsgaCAtIDEpIC8gaDsKKwlpZiAobiA+ICgoMHgxIDw8IHIpIC0gMSkpCisJCXJldHVybiAtMTsKKworCWJ1ZiA9IG9zX3phbGxvYyhidWZfbGVuKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCW9zX21lbWNweShidWYgKyAxLCBsYWJlbCwgbGFiX2xlbik7CisJb3NfbWVtY3B5KGJ1ZiArIGxhYl9sZW4gKyAyLCBjb250ZXh0LCBjdHhfbGVuKTsKKwlXUEFfUFVUX0JFMTYoJmJ1ZltidWZfbGVuIC0gMl0sIHJldF9iaXRzKTsKKworCWZvciAoaSA9IDA7IGkgPCBuOyBpKyspIHsKKwkJYnVmWzBdID0gKHU4KSAoaSArIDEpOworCQlpZiAob21hYzFfYWVzXzEyOChrZGssIGJ1ZiwgYnVmX2xlbiwgcmV0KSkgeworCQkJb3NfZnJlZShidWYpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXJldCA9IHJldCArIGggLyA4OworCX0KKwlvc19mcmVlKGJ1Zik7CisJcmV0dXJuIDA7Cit9CisKKworLyoqKioqKioqKiogQUVTLUNNQUMtMTI4ICoqKioqKioqKiovCisvKioKKyAqIGllZWU4MDJfMXhfY2FrXzEyOGJpdHNfYWVzX2NtYWMKKyAqCisgKiBJRUVFIFN0ZCA4MDIuMVgtMjAxMCwgNi4yLjIKKyAqIENBSyA9IEtERihLZXksIExhYmVsLCBtYWMxIHwgbWFjMiwgQ0FLbGVuZ3RoKQorICovCitpbnQgaWVlZTgwMl8xeF9jYWtfMTI4Yml0c19hZXNfY21hYyhjb25zdCB1OCAqbXNrLCBjb25zdCB1OCAqbWFjMSwKKwkJCQkgICAgY29uc3QgdTggKm1hYzIsIHU4ICpjYWspCit7CisJdTggY29udGV4dFsyICogRVRIX0FMRU5dOworCisJam9pbnRfdHdvX21hYyhtYWMxLCBtYWMyLCBjb250ZXh0KTsKKwlyZXR1cm4gYWVzX2tkZl8xMjgobXNrLCAiSUVFRTgwMjEgRUFQIENBSyIsCisJCQkgICBjb250ZXh0LCBzaXplb2YoY29udGV4dCkgKiA4LCAxMjgsIGNhayk7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2Nrbl8xMjhiaXRzX2Flc19jbWFjCisgKgorICogSUVFRSBTdGQgODAyLjFYLTIwMTAsIDYuMi4yCisgKiBDS04gPSBLREYoS2V5LCBMYWJlbCwgSUQgfCBtYWMxIHwgbWFjMiwgQ0tObGVuZ3RoKQorICovCitpbnQgaWVlZTgwMl8xeF9ja25fMTI4Yml0c19hZXNfY21hYyhjb25zdCB1OCAqbXNrLCBjb25zdCB1OCAqbWFjMSwKKwkJCQkgICAgY29uc3QgdTggKm1hYzIsIGNvbnN0IHU4ICpzaWQsCisJCQkJICAgIHNpemVfdCBzaWRfYnl0ZXMsIHU4ICpja24pCit7CisJaW50IHJlczsKKwl1OCAqY29udGV4dDsKKwlzaXplX3QgY3R4X2xlbiA9IHNpZF9ieXRlcyArIEVUSF9BTEVOICogMjsKKworCWNvbnRleHQgPSBvc196YWxsb2MoY3R4X2xlbik7CisJaWYgKCFjb250ZXh0KSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTUtBLSVzOiBvdXQgb2YgbWVtb3J5IiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCW9zX21lbWNweShjb250ZXh0LCBzaWQsIHNpZF9ieXRlcyk7CisJam9pbnRfdHdvX21hYyhtYWMxLCBtYWMyLCBjb250ZXh0ICsgc2lkX2J5dGVzKTsKKworCXJlcyA9IGFlc19rZGZfMTI4KG1zaywgIklFRUU4MDIxIEVBUCBDS04iLCBjb250ZXh0LCBjdHhfbGVuICogOCwKKwkJCSAgMTI4LCBja24pOworCW9zX2ZyZWUoY29udGV4dCk7CisJcmV0dXJuIHJlczsKK30KKworCisvKioKKyAqIGllZWU4MDJfMXhfa2VrXzEyOGJpdHNfYWVzX2NtYWMKKyAqCisgKiBJRUVFIFN0ZCA4MDIuMVgtMjAxMCwgOS4zLjMKKyAqIEtFSyA9IEtERihLZXksIExhYmVsLCBLZXlpZCwgS0VLTGVuZ3RoKQorICovCitpbnQgaWVlZTgwMl8xeF9rZWtfMTI4Yml0c19hZXNfY21hYyhjb25zdCB1OCAqY2FrLCBjb25zdCB1OCAqY2tuLAorCQkJCSAgICBzaXplX3QgY2tuX2J5dGVzLCB1OCAqa2VrKQoreworCXU4IGNvbnRleHRbMTZdOworCisJLyogRmlyc3QgMTYgb2N0ZXRzIG9mIENLTiwgd2l0aCBudWxsIG9jdGV0cyBhcHBlbmRlZCB0byBwYWQgaWYgbmVlZGVkICovCisJb3NfbWVtc2V0KGNvbnRleHQsIDAsIHNpemVvZihjb250ZXh0KSk7CisJb3NfbWVtY3B5KGNvbnRleHQsIGNrbiwgKGNrbl9ieXRlcyA8IDE2KSA/IGNrbl9ieXRlcyA6IDE2KTsKKworCXJldHVybiBhZXNfa2RmXzEyOChjYWssICJJRUVFODAyMSBLRUsiLCBjb250ZXh0LCBzaXplb2YoY29udGV4dCkgKiA4LAorCQkJICAgMTI4LCBrZWspOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9pY2tfMTI4Yml0c19hZXNfY21hYworICoKKyAqIElFRUUgU3RkIDgwMi4xWC0yMDEwLCA5LjMuMworICogSUNLID0gS0RGKEtleSwgTGFiZWwsIEtleWlkLCBJQ0tMZW5ndGgpCisgKi8KK2ludCBpZWVlODAyXzF4X2lja18xMjhiaXRzX2Flc19jbWFjKGNvbnN0IHU4ICpjYWssIGNvbnN0IHU4ICpja24sCisJCQkJICAgIHNpemVfdCBja25fYnl0ZXMsIHU4ICppY2spCit7CisJdTggY29udGV4dFsxNl07CisKKwkvKiBGaXJzdCAxNiBvY3RldHMgb2YgQ0tOLCB3aXRoIG51bGwgb2N0ZXRzIGFwcGVuZGVkIHRvIHBhZCBpZiBuZWVkZWQgKi8KKwlvc19tZW1zZXQoY29udGV4dCwgMCwgc2l6ZW9mKGNvbnRleHQpKTsKKwlvc19tZW1jcHkoY29udGV4dCwgY2tuLCAoY2tuX2J5dGVzIDwgMTYpID8gY2tuX2J5dGVzIDogMTYpOworCisJcmV0dXJuIGFlc19rZGZfMTI4KGNhaywgIklFRUU4MDIxIElDSyIsIGNvbnRleHQsIHNpemVvZihjb250ZXh0KSAqIDgsCisJCQkgICAxMjgsIGljayk7Cit9CisKKworLyoqCisgKiBpZWVlODAyXzF4X2ljdl8xMjhiaXRzX2Flc19jbWFjCisgKgorICogSUVFRSBTdGQgODAyLjFYLTIwMTAsIDkuNC4xCisgKiBJQ1YgPSBBRVMtQ01BQyhJQ0ssIE0sIDEyOCkKKyAqLworaW50IGllZWU4MDJfMXhfaWN2XzEyOGJpdHNfYWVzX2NtYWMoY29uc3QgdTggKmljaywgY29uc3QgdTggKm1zZywKKwkJCQkgICAgc2l6ZV90IG1zZ19ieXRlcywgdTggKmljdikKK3sKKwlpZiAob21hYzFfYWVzXzEyOChpY2ssIG1zZywgbXNnX2J5dGVzLCBpY3YpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTUtBOiBvbWFjMV9hZXNfMTI4IGZhaWxlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCXJldHVybiAwOworfQorCisKKy8qKgorICogaWVlZTgwMl8xeF9zYWtfMTI4Yml0c19hZXNfY21hYworICoKKyAqIElFRUUgU3RkIDgwMi4xWC0yMDEwLCA5LjguMQorICogU0FLID0gS0RGKEtleSwgTGFiZWwsIEtTLW5vbmNlIHwgTUktdmFsdWUgbGlzdCB8IEtOLCBTQUtMZW5ndGgpCisgKi8KK2ludCBpZWVlODAyXzF4X3Nha18xMjhiaXRzX2Flc19jbWFjKGNvbnN0IHU4ICpjYWssIGNvbnN0IHU4ICpjdHgsCisJCQkJICAgIHNpemVfdCBjdHhfYnl0ZXMsIHU4ICpzYWspCit7CisJcmV0dXJuIGFlc19rZGZfMTI4KGNhaywgIklFRUU4MDIxIFNBSyIsIGN0eCwgY3R4X2J5dGVzICogOCwgMTI4LCBzYWspOworfQpkaWZmIC0tZ2l0IGEvc3JjL3BhZS9pZWVlODAyXzF4X2tleS5oIGIvc3JjL3BhZS9pZWVlODAyXzF4X2tleS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVhMzE4ZWEKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvcGFlL2llZWU4MDJfMXhfa2V5LmgKQEAgLTAsMCArMSwyNiBAQAorLyoKKyAqIElFRUUgODAyLjFYLTIwMTAgS2V5IEhpZXJhcmNoeQorICogQ29weXJpZ2h0IChjKSAyMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIElFRUU4MDJfMVhfS0VZX0gKKyNkZWZpbmUgSUVFRTgwMl8xWF9LRVlfSAorCitpbnQgaWVlZTgwMl8xeF9jYWtfMTI4Yml0c19hZXNfY21hYyhjb25zdCB1OCAqbXNrLCBjb25zdCB1OCAqbWFjMSwKKwkJCQkgICAgY29uc3QgdTggKm1hYzIsIHU4ICpjYWspOworaW50IGllZWU4MDJfMXhfY2tuXzEyOGJpdHNfYWVzX2NtYWMoY29uc3QgdTggKm1zaywgY29uc3QgdTggKm1hYzEsCisJCQkJICAgIGNvbnN0IHU4ICptYWMyLCBjb25zdCB1OCAqc2lkLAorCQkJCSAgICBzaXplX3Qgc2lkX2J5dGVzLCB1OCAqY2tuKTsKK2ludCBpZWVlODAyXzF4X2tla18xMjhiaXRzX2Flc19jbWFjKGNvbnN0IHU4ICpjYWssIGNvbnN0IHU4ICpja24sCisJCQkJICAgIHNpemVfdCBja25fYnl0ZXMsIHU4ICprZWspOworaW50IGllZWU4MDJfMXhfaWNrXzEyOGJpdHNfYWVzX2NtYWMoY29uc3QgdTggKmNhaywgY29uc3QgdTggKmNrbiwKKwkJCQkgICAgc2l6ZV90IGNrbl9ieXRlcywgdTggKmljayk7CitpbnQgaWVlZTgwMl8xeF9pY3ZfMTI4Yml0c19hZXNfY21hYyhjb25zdCB1OCAqaWNrLCBjb25zdCB1OCAqbXNnLAorCQkJCSAgICBzaXplX3QgbXNnX2J5dGVzLCB1OCAqaWN2KTsKK2ludCBpZWVlODAyXzF4X3Nha18xMjhiaXRzX2Flc19jbWFjKGNvbnN0IHU4ICpjYWssIGNvbnN0IHU4ICpjdHgsCisJCQkJICAgIHNpemVfdCBjdHhfYnl0ZXMsIHU4ICpzYWspOworCisjZW5kaWYgLyogSUVFRTgwMl8xWF9LRVlfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3BhZS9pZWVlODAyXzF4X3NlY3lfb3BzLmMgYi9zcmMvcGFlL2llZWU4MDJfMXhfc2VjeV9vcHMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYmUwNWRjCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3BhZS9pZWVlODAyXzF4X3NlY3lfb3BzLmMKQEAgLTAsMCArMSw0OTIgQEAKKyAvKgorICogU2VjWSBPcGVyYXRpb25zCisgKiBDb3B5cmlnaHQgKGMpIDIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJ1dGlscy9pbmNsdWRlcy5oIgorCisjaW5jbHVkZSAidXRpbHMvY29tbW9uLmgiCisjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKKyNpbmNsdWRlICJjb21tb24vZGVmcy5oIgorI2luY2x1ZGUgImRyaXZlcnMvZHJpdmVyLmgiCisjaW5jbHVkZSAicGFlL2llZWU4MDJfMXhfa2F5LmgiCisjaW5jbHVkZSAicGFlL2llZWU4MDJfMXhfa2F5X2kuaCIKKyNpbmNsdWRlICJwYWUvaWVlZTgwMl8xeF9zZWN5X29wcy5oIgorCisKK2ludCBzZWN5X2NwX2NvbnRyb2xfdmFsaWRhdGVfZnJhbWVzKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCSAgICBlbnVtIHZhbGlkYXRlX2ZyYW1lcyB2ZikKK3sKKwlrYXktPnZmID0gdmY7CisJcmV0dXJuIDA7Cit9CisKKworaW50IHNlY3lfY3BfY29udHJvbF9wcm90ZWN0X2ZyYW1lcyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgQm9vbGVhbiBlbmFibGVkKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5KSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPmVuYWJsZV9wcm90ZWN0X2ZyYW1lcykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgZW5hYmxlX3Byb3RlY3RfZnJhbWVzIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gb3BzLT5lbmFibGVfcHJvdGVjdF9mcmFtZXMob3BzLT5jdHgsIGVuYWJsZWQpOworfQorCisKK2ludCBzZWN5X2NwX2NvbnRyb2xfcmVwbGF5KHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LCBCb29sZWFuIGVuYWJsZWQsIHUzMiB3aW4pCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqb3BzOworCisJaWYgKCFrYXkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6ICVzIHBhcmFtcyBpbnZhbGlkIiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCisJb3BzID0ga2F5LT5jdHg7CisJaWYgKCFvcHMgfHwgIW9wcy0+c2V0X3JlcGxheV9wcm90ZWN0KSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogc2VjeSBzZXRfcmVwbGF5X3Byb3RlY3Qgb3BlcmF0aW9uIG5vdCBzdXBwb3J0ZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiBvcHMtPnNldF9yZXBsYXlfcHJvdGVjdChvcHMtPmN0eCwgZW5hYmxlZCwgd2luKTsKK30KKworCitpbnQgc2VjeV9jcF9jb250cm9sX2N1cnJlbnRfY2lwaGVyX3N1aXRlKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCQkgY29uc3QgdTggKmNzLCBzaXplX3QgY3NfbGVuKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5KSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPnNldF9jdXJyZW50X2NpcGhlcl9zdWl0ZSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgc2V0X2N1cnJlbnRfY2lwaGVyX3N1aXRlIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gb3BzLT5zZXRfY3VycmVudF9jaXBoZXJfc3VpdGUob3BzLT5jdHgsIGNzLCBjc19sZW4pOworfQorCisKK2ludCBzZWN5X2NwX2NvbnRyb2xfY29uZmlkZW50aWFsaXR5X29mZnNldChzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCQkJICAgZW51bSBjb25maWRlbnRpYWxpdHlfb2Zmc2V0IGNvKQoreworCWtheS0+Y28gPSBjbzsKKwlyZXR1cm4gMDsKK30KKworCitpbnQgc2VjeV9jcF9jb250cm9sX2VuYWJsZV9wb3J0KHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LCBCb29sZWFuIGVuYWJsZWQpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqb3BzOworCisJaWYgKCFrYXkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6ICVzIHBhcmFtcyBpbnZhbGlkIiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCisJb3BzID0ga2F5LT5jdHg7CisJaWYgKCFvcHMgfHwgIW9wcy0+ZW5hYmxlX2NvbnRyb2xsZWRfcG9ydCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgZW5hYmxlX2NvbnRyb2xsZWRfcG9ydCBvcGVyYXRpb24gbm90IHN1cHBvcnRlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIG9wcy0+ZW5hYmxlX2NvbnRyb2xsZWRfcG9ydChvcHMtPmN0eCwgZW5hYmxlZCk7Cit9CisKKworaW50IHNlY3lfZ2V0X3JlY2VpdmVfbG93ZXN0X3BuKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgICAgIHN0cnVjdCByZWNlaXZlX3NhICpyeHNhKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5IHx8ICFyeHNhKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPmdldF9yZWNlaXZlX2xvd2VzdF9wbikgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgZ2V0X3JlY2VpdmVfbG93ZXN0X3BuIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gb3BzLT5nZXRfcmVjZWl2ZV9sb3dlc3RfcG4ob3BzLT5jdHgsCisJCQkJCXJ4c2EtPnNjLT5jaGFubmVsLAorCQkJCQlyeHNhLT5hbiwKKwkJCQkJJnJ4c2EtPmxvd2VzdF9wbik7Cit9CisKKworaW50IHNlY3lfZ2V0X3RyYW5zbWl0X25leHRfcG4oc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgICBzdHJ1Y3QgdHJhbnNtaXRfc2EgKnR4c2EpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqb3BzOworCisJaWYgKCFrYXkgfHwgIXR4c2EpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6ICVzIHBhcmFtcyBpbnZhbGlkIiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCisJb3BzID0ga2F5LT5jdHg7CisJaWYgKCFvcHMgfHwgIW9wcy0+Z2V0X3RyYW5zbWl0X25leHRfcG4pIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBzZWN5IGdldF9yZWNlaXZlX2xvd2VzdF9wbiBvcGVyYXRpb24gbm90IHN1cHBvcnRlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIG9wcy0+Z2V0X3RyYW5zbWl0X25leHRfcG4ob3BzLT5jdHgsCisJCQkJCXR4c2EtPnNjLT5jaGFubmVsLAorCQkJCQl0eHNhLT5hbiwKKwkJCQkJJnR4c2EtPm5leHRfcG4pOworfQorCisKK2ludCBzZWN5X3NldF90cmFuc21pdF9uZXh0X3BuKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgICAgc3RydWN0IHRyYW5zbWl0X3NhICp0eHNhKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5IHx8ICF0eHNhKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPnNldF90cmFuc21pdF9uZXh0X3BuKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogc2VjeSBnZXRfcmVjZWl2ZV9sb3dlc3RfcG4gb3BlcmF0aW9uIG5vdCBzdXBwb3J0ZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiBvcHMtPnNldF90cmFuc21pdF9uZXh0X3BuKG9wcy0+Y3R4LAorCQkJCQl0eHNhLT5zYy0+Y2hhbm5lbCwKKwkJCQkJdHhzYS0+YW4sCisJCQkJCXR4c2EtPm5leHRfcG4pOworfQorCisKK2ludCBzZWN5X2dldF9hdmFpbGFibGVfcmVjZWl2ZV9zYyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgdTMyICpjaGFubmVsKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5KSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPmdldF9hdmFpbGFibGVfcmVjZWl2ZV9zYykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgZ2V0X2F2YWlsYWJsZV9yZWNlaXZlX3NjIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gb3BzLT5nZXRfYXZhaWxhYmxlX3JlY2VpdmVfc2Mob3BzLT5jdHgsIGNoYW5uZWwpOworfQorCisKK2ludCBzZWN5X2NyZWF0ZV9yZWNlaXZlX3NjKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LCBzdHJ1Y3QgcmVjZWl2ZV9zYyAqcnhzYykKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY3R4ICpvcHM7CisKKwlpZiAoIWtheSB8fCAhcnhzYykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogJXMgcGFyYW1zIGludmFsaWQiLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlvcHMgPSBrYXktPmN0eDsKKwlpZiAoIW9wcyB8fCAhb3BzLT5jcmVhdGVfcmVjZWl2ZV9zYykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgY3JlYXRlX3JlY2VpdmVfc2Mgb3BlcmF0aW9uIG5vdCBzdXBwb3J0ZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiBvcHMtPmNyZWF0ZV9yZWNlaXZlX3NjKG9wcy0+Y3R4LCByeHNjLT5jaGFubmVsLCAmcnhzYy0+c2NpLAorCQkJCSAgICAgIGtheS0+dmYsIGtheS0+Y28pOworfQorCisKK2ludCBzZWN5X2RlbGV0ZV9yZWNlaXZlX3NjKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LCBzdHJ1Y3QgcmVjZWl2ZV9zYyAqcnhzYykKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY3R4ICpvcHM7CisKKwlpZiAoIWtheSB8fCAhcnhzYykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogJXMgcGFyYW1zIGludmFsaWQiLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlvcHMgPSBrYXktPmN0eDsKKwlpZiAoIW9wcyB8fCAhb3BzLT5kZWxldGVfcmVjZWl2ZV9zYykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgZGVsZXRlX3JlY2VpdmVfc2Mgb3BlcmF0aW9uIG5vdCBzdXBwb3J0ZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiBvcHMtPmRlbGV0ZV9yZWNlaXZlX3NjKG9wcy0+Y3R4LCByeHNjLT5jaGFubmVsKTsKK30KKworCitpbnQgc2VjeV9jcmVhdGVfcmVjZWl2ZV9zYShzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgc3RydWN0IHJlY2VpdmVfc2EgKnJ4c2EpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqb3BzOworCisJaWYgKCFrYXkgfHwgIXJ4c2EpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6ICVzIHBhcmFtcyBpbnZhbGlkIiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCisJb3BzID0ga2F5LT5jdHg7CisJaWYgKCFvcHMgfHwgIW9wcy0+Y3JlYXRlX3JlY2VpdmVfc2EpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBzZWN5IGNyZWF0ZV9yZWNlaXZlX3NhIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gb3BzLT5jcmVhdGVfcmVjZWl2ZV9zYShvcHMtPmN0eCwgcnhzYS0+c2MtPmNoYW5uZWwsIHJ4c2EtPmFuLAorCQkJCSAgICAgIHJ4c2EtPmxvd2VzdF9wbiwgcnhzYS0+cGtleS0+a2V5KTsKK30KKworCitpbnQgc2VjeV9lbmFibGVfcmVjZWl2ZV9zYShzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgc3RydWN0IHJlY2VpdmVfc2EgKnJ4c2EpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqb3BzOworCisJaWYgKCFrYXkgfHwgIXJ4c2EpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6ICVzIHBhcmFtcyBpbnZhbGlkIiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCisJb3BzID0ga2F5LT5jdHg7CisJaWYgKCFvcHMgfHwgIW9wcy0+ZW5hYmxlX3JlY2VpdmVfc2EpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBzZWN5IGVuYWJsZV9yZWNlaXZlX3NhIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyeHNhLT5lbmFibGVfcmVjZWl2ZSA9IFRSVUU7CisKKwlyZXR1cm4gb3BzLT5lbmFibGVfcmVjZWl2ZV9zYShvcHMtPmN0eCwgcnhzYS0+c2MtPmNoYW5uZWwsIHJ4c2EtPmFuKTsKK30KKworCitpbnQgc2VjeV9kaXNhYmxlX3JlY2VpdmVfc2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIHN0cnVjdCByZWNlaXZlX3NhICpyeHNhKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5IHx8ICFyeHNhKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPmRpc2FibGVfcmVjZWl2ZV9zYSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgZGlzYWJsZV9yZWNlaXZlX3NhIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyeHNhLT5lbmFibGVfcmVjZWl2ZSA9IEZBTFNFOworCisJcmV0dXJuIG9wcy0+ZGlzYWJsZV9yZWNlaXZlX3NhKG9wcy0+Y3R4LCByeHNhLT5zYy0+Y2hhbm5lbCwgcnhzYS0+YW4pOworfQorCisKK2ludCBzZWN5X2dldF9hdmFpbGFibGVfdHJhbnNtaXRfc2Moc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIHUzMiAqY2hhbm5lbCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY3R4ICpvcHM7CisKKwlpZiAoIWtheSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogJXMgcGFyYW1zIGludmFsaWQiLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlvcHMgPSBrYXktPmN0eDsKKwlpZiAoIW9wcyB8fCAhb3BzLT5nZXRfYXZhaWxhYmxlX3RyYW5zbWl0X3NjKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogc2VjeSBnZXRfYXZhaWxhYmxlX3RyYW5zbWl0X3NjIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gb3BzLT5nZXRfYXZhaWxhYmxlX3RyYW5zbWl0X3NjKG9wcy0+Y3R4LCBjaGFubmVsKTsKK30KKworCitpbnQgc2VjeV9jcmVhdGVfdHJhbnNtaXRfc2Moc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgc3RydWN0IHRyYW5zbWl0X3NjICp0eHNjKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5IHx8ICF0eHNjKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPmNyZWF0ZV90cmFuc21pdF9zYykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgY3JlYXRlX3RyYW5zbWl0X3NjIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gb3BzLT5jcmVhdGVfdHJhbnNtaXRfc2Mob3BzLT5jdHgsIHR4c2MtPmNoYW5uZWwsICZ0eHNjLT5zY2ksCisJCQkJICAgICAgIGtheS0+Y28pOworfQorCisKK2ludCBzZWN5X2RlbGV0ZV90cmFuc21pdF9zYyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCSAgICBzdHJ1Y3QgdHJhbnNtaXRfc2MgKnR4c2MpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqb3BzOworCisJaWYgKCFrYXkgfHwgIXR4c2MpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6ICVzIHBhcmFtcyBpbnZhbGlkIiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCisJb3BzID0ga2F5LT5jdHg7CisJaWYgKCFvcHMgfHwgIW9wcy0+ZGVsZXRlX3RyYW5zbWl0X3NjKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogc2VjeSBkZWxldGVfdHJhbnNtaXRfc2Mgb3BlcmF0aW9uIG5vdCBzdXBwb3J0ZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiBvcHMtPmRlbGV0ZV90cmFuc21pdF9zYyhvcHMtPmN0eCwgdHhzYy0+Y2hhbm5lbCk7Cit9CisKKworaW50IHNlY3lfY3JlYXRlX3RyYW5zbWl0X3NhKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgIHN0cnVjdCB0cmFuc21pdF9zYSAqdHhzYSkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY3R4ICpvcHM7CisKKwlpZiAoIWtheSB8fCAhdHhzYSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogJXMgcGFyYW1zIGludmFsaWQiLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlvcHMgPSBrYXktPmN0eDsKKwlpZiAoIW9wcyB8fCAhb3BzLT5jcmVhdGVfdHJhbnNtaXRfc2EpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiS2FZOiBzZWN5IGNyZWF0ZV90cmFuc21pdF9zYSBvcGVyYXRpb24gbm90IHN1cHBvcnRlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIG9wcy0+Y3JlYXRlX3RyYW5zbWl0X3NhKG9wcy0+Y3R4LCB0eHNhLT5zYy0+Y2hhbm5lbCwgdHhzYS0+YW4sCisJCQkJCXR4c2EtPm5leHRfcG4sIHR4c2EtPmNvbmZpZGVudGlhbGl0eSwKKwkJCQkJdHhzYS0+cGtleS0+a2V5KTsKK30KKworCitpbnQgc2VjeV9lbmFibGVfdHJhbnNtaXRfc2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgc3RydWN0IHRyYW5zbWl0X3NhICp0eHNhKQoreworCXN0cnVjdCBpZWVlODAyXzF4X2theV9jdHggKm9wczsKKworCWlmICgha2F5IHx8ICF0eHNhKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiS2FZOiAlcyBwYXJhbXMgaW52YWxpZCIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9wcyA9IGtheS0+Y3R4OworCWlmICghb3BzIHx8ICFvcHMtPmVuYWJsZV90cmFuc21pdF9zYSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgZW5hYmxlX3RyYW5zbWl0X3NhIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl0eHNhLT5lbmFibGVfdHJhbnNtaXQgPSBUUlVFOworCisJcmV0dXJuIG9wcy0+ZW5hYmxlX3RyYW5zbWl0X3NhKG9wcy0+Y3R4LCB0eHNhLT5zYy0+Y2hhbm5lbCwgdHhzYS0+YW4pOworfQorCisKK2ludCBzZWN5X2Rpc2FibGVfdHJhbnNtaXRfc2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgIHN0cnVjdCB0cmFuc21pdF9zYSAqdHhzYSkKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY3R4ICpvcHM7CisKKwlpZiAoIWtheSB8fCAhdHhzYSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogJXMgcGFyYW1zIGludmFsaWQiLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlvcHMgPSBrYXktPmN0eDsKKwlpZiAoIW9wcyB8fCAhb3BzLT5kaXNhYmxlX3RyYW5zbWl0X3NhKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIkthWTogc2VjeSBkaXNhYmxlX3RyYW5zbWl0X3NhIG9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl0eHNhLT5lbmFibGVfdHJhbnNtaXQgPSBGQUxTRTsKKworCXJldHVybiBvcHMtPmRpc2FibGVfdHJhbnNtaXRfc2Eob3BzLT5jdHgsIHR4c2EtPnNjLT5jaGFubmVsLCB0eHNhLT5hbik7Cit9CisKKworaW50IHNlY3lfaW5pdF9tYWNzZWMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXkpCit7CisJaW50IHJldDsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY3R4ICpvcHM7CisJc3RydWN0IG1hY3NlY19pbml0X3BhcmFtcyBwYXJhbXM7CisKKwlpZiAoIWtheSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkthWTogJXMgcGFyYW1zIGludmFsaWQiLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlvcHMgPSBrYXktPmN0eDsKKwlpZiAoIW9wcyB8fCAhb3BzLT5tYWNzZWNfaW5pdCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgbWFjc2VjX2luaXQgb3BlcmF0aW9uIG5vdCBzdXBwb3J0ZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXBhcmFtcy51c2VfZXMgPSBGQUxTRTsKKwlwYXJhbXMudXNlX3NjYiA9IEZBTFNFOworCXBhcmFtcy5hbHdheXNfaW5jbHVkZV9zY2kgPSBUUlVFOworCisJcmV0ID0gb3BzLT5tYWNzZWNfaW5pdChvcHMtPmN0eCwgJnBhcmFtcyk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK2ludCBzZWN5X2RlaW5pdF9tYWNzZWMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXkpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqb3BzOworCisJaWYgKCFrYXkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJLYVk6ICVzIHBhcmFtcyBpbnZhbGlkIiwgX19mdW5jX18pOworCQlyZXR1cm4gLTE7CisJfQorCisJb3BzID0ga2F5LT5jdHg7CisJaWYgKCFvcHMgfHwgIW9wcy0+bWFjc2VjX2RlaW5pdCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJLYVk6IHNlY3kgbWFjc2VjX2RlaW5pdCBvcGVyYXRpb24gbm90IHN1cHBvcnRlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIG9wcy0+bWFjc2VjX2RlaW5pdChvcHMtPmN0eCk7Cit9CmRpZmYgLS1naXQgYS9zcmMvcGFlL2llZWU4MDJfMXhfc2VjeV9vcHMuaCBiL3NyYy9wYWUvaWVlZTgwMl8xeF9zZWN5X29wcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI5NWI4MjMKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvcGFlL2llZWU4MDJfMXhfc2VjeV9vcHMuaApAQCAtMCwwICsxLDYyIEBACisgLyoKKyAqIFNlY1kgT3BlcmF0aW9ucworICogQ29weXJpZ2h0IChjKSAyMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIElFRUU4MDJfMVhfU0VDWV9PUFNfSAorI2RlZmluZSBJRUVFODAyXzFYX1NFQ1lfT1BTX0gKKworI2luY2x1ZGUgImNvbW1vbi9kZWZzLmgiCisjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMXhfZGVmcy5oIgorCitzdHJ1Y3QgaWVlZTgwMl8xeF9rYXlfY29uZjsKK3N0cnVjdCByZWNlaXZlX3NhOworc3RydWN0IHRyYW5zbWl0X3NhOworc3RydWN0IHJlY2VpdmVfc2M7CitzdHJ1Y3QgdHJhbnNtaXRfc2M7CisKK2ludCBzZWN5X2luaXRfbWFjc2VjKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5KTsKK2ludCBzZWN5X2RlaW5pdF9tYWNzZWMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXkpOworCisvKioqKioqIENQIC0+IFNlY1kgKioqKioqLworaW50IHNlY3lfY3BfY29udHJvbF92YWxpZGF0ZV9mcmFtZXMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkJICAgIGVudW0gdmFsaWRhdGVfZnJhbWVzIHZmKTsKK2ludCBzZWN5X2NwX2NvbnRyb2xfcHJvdGVjdF9mcmFtZXMoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIEJvb2xlYW4gZmxhZyk7CitpbnQgc2VjeV9jcF9jb250cm9sX3JlcGxheShzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgQm9vbGVhbiBmbGFnLCB1MzIgd2luKTsKK2ludCBzZWN5X2NwX2NvbnRyb2xfY3VycmVudF9jaXBoZXJfc3VpdGUoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkJCSBjb25zdCB1OCAqY3MsIHNpemVfdCBjc19sZW4pOworaW50IHNlY3lfY3BfY29udHJvbF9jb25maWRlbnRpYWxpdHlfb2Zmc2V0KHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJCQkgICBlbnVtIGNvbmZpZGVudGlhbGl0eV9vZmZzZXQgY28pOworaW50IHNlY3lfY3BfY29udHJvbF9lbmFibGVfcG9ydChzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgQm9vbGVhbiBmbGFnKTsKKworLyoqKioqKiBLYVkgLT4gU2VjWSAqKioqKioqLworaW50IHNlY3lfZ2V0X3JlY2VpdmVfbG93ZXN0X3BuKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgICAgIHN0cnVjdCByZWNlaXZlX3NhICpyeHNhKTsKK2ludCBzZWN5X2dldF90cmFuc21pdF9uZXh0X3BuKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgICAgc3RydWN0IHRyYW5zbWl0X3NhICp0eHNhKTsKK2ludCBzZWN5X3NldF90cmFuc21pdF9uZXh0X3BuKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgICAgc3RydWN0IHRyYW5zbWl0X3NhICp0eHNhKTsKK2ludCBzZWN5X2dldF9hdmFpbGFibGVfcmVjZWl2ZV9zYyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgdTMyICpjaGFubmVsKTsKK2ludCBzZWN5X2NyZWF0ZV9yZWNlaXZlX3NjKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LCBzdHJ1Y3QgcmVjZWl2ZV9zYyAqcnhzYyk7CitpbnQgc2VjeV9kZWxldGVfcmVjZWl2ZV9zYyhzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwgc3RydWN0IHJlY2VpdmVfc2MgKnJ4c2MpOworaW50IHNlY3lfY3JlYXRlX3JlY2VpdmVfc2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksIHN0cnVjdCByZWNlaXZlX3NhICpyeHNhKTsKK2ludCBzZWN5X2VuYWJsZV9yZWNlaXZlX3NhKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LCBzdHJ1Y3QgcmVjZWl2ZV9zYSAqcnhzYSk7CitpbnQgc2VjeV9kaXNhYmxlX3JlY2VpdmVfc2Eoc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgc3RydWN0IHJlY2VpdmVfc2EgKnJ4c2EpOworCitpbnQgc2VjeV9nZXRfYXZhaWxhYmxlX3RyYW5zbWl0X3NjKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LCB1MzIgKmNoYW5uZWwpOworaW50IHNlY3lfY3JlYXRlX3RyYW5zbWl0X3NjKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgIHN0cnVjdCB0cmFuc21pdF9zYyAqdHhzYyk7CitpbnQgc2VjeV9kZWxldGVfdHJhbnNtaXRfc2Moc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXksCisJCQkgICAgc3RydWN0IHRyYW5zbWl0X3NjICp0eHNjKTsKK2ludCBzZWN5X2NyZWF0ZV90cmFuc21pdF9zYShzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKmtheSwKKwkJCSAgICBzdHJ1Y3QgdHJhbnNtaXRfc2EgKnR4c2EpOworaW50IHNlY3lfZW5hYmxlX3RyYW5zbWl0X3NhKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgIHN0cnVjdCB0cmFuc21pdF9zYSAqdHhzYSk7CitpbnQgc2VjeV9kaXNhYmxlX3RyYW5zbWl0X3NhKHN0cnVjdCBpZWVlODAyXzF4X2theSAqa2F5LAorCQkJICAgICBzdHJ1Y3QgdHJhbnNtaXRfc2EgKnR4c2EpOworCisjZW5kaWYgLyogSUVFRTgwMl8xWF9TRUNZX09QU19IICovCmRpZmYgLS1naXQgYS9zcmMvcmFkaXVzL01ha2VmaWxlIGIvc3JjL3JhZGl1cy9NYWtlZmlsZQppbmRleCBiMTk5YmU4Li5iNWQwNjNkIDEwMDY0NAotLS0gYS9zcmMvcmFkaXVzL01ha2VmaWxlCisrKyBiL3NyYy9yYWRpdXMvTWFrZWZpbGUKQEAgLTEsNyArMSw3IEBACiBhbGw6IGxpYnJhZGl1cy5hCiAKIGNsZWFuOgotCXJtIC1mICp+ICoubyAqLmQgbGlicmFkaXVzLmEKKwlybSAtZiAqfiAqLm8gKi5kICouZ2NubyAqLmdjZGEgKi5nY292IGxpYnJhZGl1cy5hCiAKIGluc3RhbGw6CiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgpkaWZmIC0tZ2l0IGEvc3JjL3JhZGl1cy9yYWRpdXMuYyBiL3NyYy9yYWRpdXMvcmFkaXVzLmMKaW5kZXggZDFmZWVjOS4uZjNiNjQ1ZCAxMDA2NDQKLS0tIGEvc3JjL3JhZGl1cy9yYWRpdXMuYworKysgYi9zcmMvcmFkaXVzL3JhZGl1cy5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFJBRElVUyBtZXNzYWdlIHByb2Nlc3NpbmcKLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDA5LCAyMDExLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwOSwgMjAxMS0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yMzEsOSArMjMxLDIxIEBACiAJeyBSQURJVVNfQVRUUl9DSEFSR0VBQkxFX1VTRVJfSURFTlRJVFksICJDaGFyZ2VhYmxlLVVzZXItSWRlbnRpdHkiLAogCSAgUkFESVVTX0FUVFJfVEVYVCB9LAogCXsgUkFESVVTX0FUVFJfTkFTX0lQVjZfQUREUkVTUywgIk5BUy1JUHY2LUFkZHJlc3MiLCBSQURJVVNfQVRUUl9JUFY2IH0sCi0JeyBSQURJVVNfQVRUUl9FUlJPUl9DQVVTRSwgIkVycm9yLUNhdXNlIiwgUkFESVVTX0FUVFJfSU5UMzIgfQorCXsgUkFESVVTX0FUVFJfRVJST1JfQ0FVU0UsICJFcnJvci1DYXVzZSIsIFJBRElVU19BVFRSX0lOVDMyIH0sCisJeyBSQURJVVNfQVRUUl9FQVBfS0VZX05BTUUsICJFQVAtS2V5LU5hbWUiLCBSQURJVVNfQVRUUl9IRVhEVU1QIH0sCisJeyBSQURJVVNfQVRUUl9NT0JJTElUWV9ET01BSU5fSUQsICJNb2JpbGl0eS1Eb21haW4tSWQiLAorCSAgUkFESVVTX0FUVFJfSU5UMzIgfSwKKwl7IFJBRElVU19BVFRSX1dMQU5fSEVTU0lELCAiV0xBTi1IRVNTSUQiLCBSQURJVVNfQVRUUl9URVhUIH0sCisJeyBSQURJVVNfQVRUUl9XTEFOX1BBSVJXSVNFX0NJUEhFUiwgIldMQU4tUGFpcndpc2UtQ2lwaGVyIiwKKwkgIFJBRElVU19BVFRSX0hFWERVTVAgfSwKKwl7IFJBRElVU19BVFRSX1dMQU5fR1JPVVBfQ0lQSEVSLCAiV0xBTi1Hcm91cC1DaXBoZXIiLAorCSAgUkFESVVTX0FUVFJfSEVYRFVNUCB9LAorCXsgUkFESVVTX0FUVFJfV0xBTl9BS01fU1VJVEUsICJXTEFOLUFLTS1TdWl0ZSIsCisJICBSQURJVVNfQVRUUl9IRVhEVU1QIH0sCisJeyBSQURJVVNfQVRUUl9XTEFOX0dST1VQX01HTVRfQ0lQSEVSLCAiV0xBTi1Hcm91cC1NZ210LVBhaXJ3aXNlLUNpcGhlciIsCisJICBSQURJVVNfQVRUUl9IRVhEVU1QIH0sCiB9OwotI2RlZmluZSBSQURJVVNfQVRUUlMgKHNpemVvZihyYWRpdXNfYXR0cnMpIC8gc2l6ZW9mKHJhZGl1c19hdHRyc1swXSkpCisjZGVmaW5lIFJBRElVU19BVFRSUyBBUlJBWV9TSVpFKHJhZGl1c19hdHRycykKIAogCiBzdGF0aWMgc3RydWN0IHJhZGl1c19hdHRyX3R5cGUgKnJhZGl1c19nZXRfYXR0cl90eXBlKHU4IHR5cGUpCkBAIC0yNDksMjUgKzI2MSwxNyBAQAogfQogCiAKLXN0YXRpYyB2b2lkIHByaW50X2NoYXIoY2hhciBjKQotewotCWlmIChjID49IDMyICYmIGMgPCAxMjcpCi0JCXByaW50ZigiJWMiLCBjKTsKLQllbHNlCi0JCXByaW50ZigiPCUwMng+IiwgYyk7Ci19Ci0KLQogc3RhdGljIHZvaWQgcmFkaXVzX21zZ19kdW1wX2F0dHIoc3RydWN0IHJhZGl1c19hdHRyX2hkciAqaGRyKQogewogCXN0cnVjdCByYWRpdXNfYXR0cl90eXBlICphdHRyOwotCWludCBpLCBsZW47CisJaW50IGxlbjsKIAl1bnNpZ25lZCBjaGFyICpwb3M7CisJY2hhciBidWZbMTAwMF07CiAKIAlhdHRyID0gcmFkaXVzX2dldF9hdHRyX3R5cGUoaGRyLT50eXBlKTsKIAotCXByaW50ZigiICAgQXR0cmlidXRlICVkICglcykgbGVuZ3RoPSVkXG4iLAotCSAgICAgICBoZHItPnR5cGUsIGF0dHIgPyBhdHRyLT5uYW1lIDogIj9Vbmtub3duPyIsIGhkci0+bGVuZ3RoKTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiICAgQXR0cmlidXRlICVkICglcykgbGVuZ3RoPSVkIiwKKwkJICAgaGRyLT50eXBlLCBhdHRyID8gYXR0ci0+bmFtZSA6ICI/VW5rbm93bj8iLCBoZHItPmxlbmd0aCk7CiAKIAlpZiAoYXR0ciA9PSBOVUxMIHx8IGhkci0+bGVuZ3RoIDwgc2l6ZW9mKHN0cnVjdCByYWRpdXNfYXR0cl9oZHIpKQogCQlyZXR1cm47CkBAIC0yNzcsNDcgKzI4MSw1MCBAQAogCiAJc3dpdGNoIChhdHRyLT5kYXRhX3R5cGUpIHsKIAljYXNlIFJBRElVU19BVFRSX1RFWFQ6Ci0JCXByaW50ZigiICAgICAgVmFsdWU6ICciKTsKLQkJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKQotCQkJcHJpbnRfY2hhcihwb3NbaV0pOwotCQlwcmludGYoIidcbiIpOworCQlwcmludGZfZW5jb2RlKGJ1Ziwgc2l6ZW9mKGJ1ZiksIHBvcywgbGVuKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIiAgICAgIFZhbHVlOiAnJXMnIiwgYnVmKTsKIAkJYnJlYWs7CiAKIAljYXNlIFJBRElVU19BVFRSX0lQOgogCQlpZiAobGVuID09IDQpIHsKIAkJCXN0cnVjdCBpbl9hZGRyIGFkZHI7CiAJCQlvc19tZW1jcHkoJmFkZHIsIHBvcywgNCk7Ci0JCQlwcmludGYoIiAgICAgIFZhbHVlOiAlc1xuIiwgaW5ldF9udG9hKGFkZHIpKTsKLQkJfSBlbHNlCi0JCQlwcmludGYoIiAgICAgIEludmFsaWQgSVAgYWRkcmVzcyBsZW5ndGggJWRcbiIsIGxlbik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiICAgICAgVmFsdWU6ICVzIiwKKwkJCQkgICBpbmV0X250b2EoYWRkcikpOworCQl9IGVsc2UgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIiAgICAgIEludmFsaWQgSVAgYWRkcmVzcyBsZW5ndGggJWQiLAorCQkJCSAgIGxlbik7CisJCX0KIAkJYnJlYWs7CiAKICNpZmRlZiBDT05GSUdfSVBWNgogCWNhc2UgUkFESVVTX0FUVFJfSVBWNjoKIAkJaWYgKGxlbiA9PSAxNikgewotCQkJY2hhciBidWZbMTI4XTsKIAkJCWNvbnN0IGNoYXIgKmF0eHQ7CiAJCQlzdHJ1Y3QgaW42X2FkZHIgKmFkZHIgPSAoc3RydWN0IGluNl9hZGRyICopIHBvczsKIAkJCWF0eHQgPSBpbmV0X250b3AoQUZfSU5FVDYsIGFkZHIsIGJ1Ziwgc2l6ZW9mKGJ1ZikpOwotCQkJcHJpbnRmKCIgICAgICBWYWx1ZTogJXNcbiIsIGF0eHQgPyBhdHh0IDogIj8iKTsKLQkJfSBlbHNlCi0JCQlwcmludGYoIiAgICAgIEludmFsaWQgSVB2NiBhZGRyZXNzIGxlbmd0aCAlZFxuIiwgbGVuKTsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICIgICAgICBWYWx1ZTogJXMiLAorCQkJCSAgIGF0eHQgPyBhdHh0IDogIj8iKTsKKwkJfSBlbHNlIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICIgICAgICBJbnZhbGlkIElQdjYgYWRkcmVzcyBsZW5ndGggJWQiLAorCQkJCSAgIGxlbik7CisJCX0KIAkJYnJlYWs7CiAjZW5kaWYgLyogQ09ORklHX0lQVjYgKi8KIAogCWNhc2UgUkFESVVTX0FUVFJfSEVYRFVNUDoKIAljYXNlIFJBRElVU19BVFRSX1VORElTVDoKLQkJcHJpbnRmKCIgICAgICBWYWx1ZToiKTsKLQkJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKQotCQkJcHJpbnRmKCIgJTAyeCIsIHBvc1tpXSk7Ci0JCXByaW50ZigiXG4iKTsKKwkJd3BhX3NucHJpbnRmX2hleChidWYsIHNpemVvZihidWYpLCBwb3MsIGxlbik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICIgICAgICBWYWx1ZTogJXMiLCBidWYpOwogCQlicmVhazsKIAogCWNhc2UgUkFESVVTX0FUVFJfSU5UMzI6CiAJCWlmIChsZW4gPT0gNCkKLQkJCXByaW50ZigiICAgICAgVmFsdWU6ICV1XG4iLCBXUEFfR0VUX0JFMzIocG9zKSk7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiICAgICAgVmFsdWU6ICV1IiwKKwkJCQkgICBXUEFfR0VUX0JFMzIocG9zKSk7CiAJCWVsc2UKLQkJCXByaW50ZigiICAgICAgSW52YWxpZCBJTlQzMiBsZW5ndGggJWRcbiIsIGxlbik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiICAgICAgSW52YWxpZCBJTlQzMiBsZW5ndGggJWQiLAorCQkJCSAgIGxlbik7CiAJCWJyZWFrOwogCiAJZGVmYXVsdDoKQEAgLTMzMCw5ICszMzcsOSBAQAogewogCXNpemVfdCBpOwogCi0JcHJpbnRmKCJSQURJVVMgbWVzc2FnZTogY29kZT0lZCAoJXMpIGlkZW50aWZpZXI9JWQgbGVuZ3RoPSVkXG4iLAotCSAgICAgICBtc2ctPmhkci0+Y29kZSwgcmFkaXVzX2NvZGVfc3RyaW5nKG1zZy0+aGRyLT5jb2RlKSwKLQkgICAgICAgbXNnLT5oZHItPmlkZW50aWZpZXIsIGJlX3RvX2hvc3QxNihtc2ctPmhkci0+bGVuZ3RoKSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJBRElVUyBtZXNzYWdlOiBjb2RlPSVkICglcykgaWRlbnRpZmllcj0lZCBsZW5ndGg9JWQiLAorCQkgICBtc2ctPmhkci0+Y29kZSwgcmFkaXVzX2NvZGVfc3RyaW5nKG1zZy0+aGRyLT5jb2RlKSwKKwkJICAgbXNnLT5oZHItPmlkZW50aWZpZXIsIGJlX3RvX2hvc3QxNihtc2ctPmhkci0+bGVuZ3RoKSk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgbXNnLT5hdHRyX3VzZWQ7IGkrKykgewogCQlzdHJ1Y3QgcmFkaXVzX2F0dHJfaGRyICphdHRyID0gcmFkaXVzX2dldF9hdHRyX2hkcihtc2csIGkpOwpAQCAtMzg0LDcgKzM5MSw3IEBACiAJYXR0ciA9IHJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9NRVNTQUdFX0FVVEhFTlRJQ0FUT1IsCiAJCQkJICAgYXV0aCwgTUQ1X01BQ19MRU4pOwogCWlmIChhdHRyID09IE5VTEwpIHsKLQkJcHJpbnRmKCJXQVJOSU5HOiBDb3VsZCBub3QgYWRkIE1lc3NhZ2UtQXV0aGVudGljYXRvclxuIik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV0FSTklORzogQ291bGQgbm90IGFkZCBNZXNzYWdlLUF1dGhlbnRpY2F0b3IiKTsKIAkJcmV0dXJuIC0xOwogCX0KIAltc2ctPmhkci0+bGVuZ3RoID0gaG9zdF90b19iZTE2KHdwYWJ1Zl9sZW4obXNnLT5idWYpKTsKQEAgLTQ3Myw2ICs0ODAsMjcgQEAKIH0KIAogCit2b2lkIHJhZGl1c19tc2dfZmluaXNoX2FjY3RfcmVzcChzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAorCQkJCSBzaXplX3Qgc2VjcmV0X2xlbiwgY29uc3QgdTggKnJlcV9hdXRoZW50aWNhdG9yKQoreworCWNvbnN0IHU4ICphZGRyWzJdOworCXNpemVfdCBsZW5bMl07CisKKwltc2ctPmhkci0+bGVuZ3RoID0gaG9zdF90b19iZTE2KHdwYWJ1Zl9sZW4obXNnLT5idWYpKTsKKwlvc19tZW1jcHkobXNnLT5oZHItPmF1dGhlbnRpY2F0b3IsIHJlcV9hdXRoZW50aWNhdG9yLCBNRDVfTUFDX0xFTik7CisJYWRkclswXSA9IHdwYWJ1Zl9oZWFkKG1zZy0+YnVmKTsKKwlsZW5bMF0gPSB3cGFidWZfbGVuKG1zZy0+YnVmKTsKKwlhZGRyWzFdID0gc2VjcmV0OworCWxlblsxXSA9IHNlY3JldF9sZW47CisJbWQ1X3ZlY3RvcigyLCBhZGRyLCBsZW4sIG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yKTsKKworCWlmICh3cGFidWZfbGVuKG1zZy0+YnVmKSA+IDB4ZmZmZikgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiUkFESVVTOiBUb28gbG9uZyBtZXNzYWdlcyAoJWx1KSIsCisJCQkgICAodW5zaWduZWQgbG9uZykgd3BhYnVmX2xlbihtc2ctPmJ1ZikpOworCX0KK30KKworCiBpbnQgcmFkaXVzX21zZ192ZXJpZnlfYWNjdF9yZXEoc3RydWN0IHJhZGl1c19tc2cgKm1zZywgY29uc3QgdTggKnNlY3JldCwKIAkJCSAgICAgICBzaXplX3Qgc2VjcmV0X2xlbikKIHsKQEAgLTQ5MSw3ICs1MTksNyBAQAogCWFkZHJbM10gPSBzZWNyZXQ7CiAJbGVuWzNdID0gc2VjcmV0X2xlbjsKIAltZDVfdmVjdG9yKDQsIGFkZHIsIGxlbiwgaGFzaCk7Ci0JcmV0dXJuIG9zX21lbWNtcChtc2ctPmhkci0+YXV0aGVudGljYXRvciwgaGFzaCwgTUQ1X01BQ19MRU4pICE9IDA7CisJcmV0dXJuIG9zX21lbWNtcF9jb25zdChtc2ctPmhkci0+YXV0aGVudGljYXRvciwgaGFzaCwgTUQ1X01BQ19MRU4pICE9IDA7CiB9CiAKIApAQCAtNTE4LDcgKzU0Niw3IEBACiAJYWRkclszXSA9IHNlY3JldDsKIAlsZW5bM10gPSBzZWNyZXRfbGVuOwogCW1kNV92ZWN0b3IoNCwgYWRkciwgbGVuLCBoYXNoKTsKLQlpZiAob3NfbWVtY21wKG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yLCBoYXNoLCBNRDVfTUFDX0xFTikgIT0gMCkKKwlpZiAob3NfbWVtY21wX2NvbnN0KG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yLCBoYXNoLCBNRDVfTUFDX0xFTikgIT0gMCkKIAkJcmV0dXJuIDE7CiAKIAlmb3IgKGkgPSAwOyBpIDwgbXNnLT5hdHRyX3VzZWQ7IGkrKykgewpAQCAtNTUxLDcgKzU3OSw3IEBACiAJb3NfbWVtY3B5KG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yLCBvcmlnX2F1dGhlbnRpY2F0b3IsCiAJCSAgc2l6ZW9mKG9yaWdfYXV0aGVudGljYXRvcikpOwogCi0JcmV0dXJuIG9zX21lbWNtcChvcmlnLCBhdXRoLCBNRDVfTUFDX0xFTikgIT0gMDsKKwlyZXR1cm4gb3NfbWVtY21wX2NvbnN0KG9yaWcsIGF1dGgsIE1ENV9NQUNfTEVOKSAhPSAwOwogfQogCiAKQEAgLTU4NSw3ICs2MTMsNyBAQAogCXN0cnVjdCByYWRpdXNfYXR0cl9oZHIgKmF0dHI7CiAKIAlpZiAoZGF0YV9sZW4gPiBSQURJVVNfTUFYX0FUVFJfTEVOKSB7Ci0JCXByaW50ZigicmFkaXVzX21zZ19hZGRfYXR0cjogdG9vIGxvbmcgYXR0cmlidXRlICglbHUgYnl0ZXMpXG4iLAorCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgInJhZGl1c19tc2dfYWRkX2F0dHI6IHRvbyBsb25nIGF0dHJpYnV0ZSAoJWx1IGJ5dGVzKSIsCiAJCSAgICAgICAodW5zaWduZWQgbG9uZykgZGF0YV9sZW4pOwogCQlyZXR1cm4gTlVMTDsKIAl9CkBAIC03NTYsOCArNzg0LDcgQEAKIAkJdG1wID0gcmFkaXVzX2dldF9hdHRyX2hkcihtc2csIGkpOwogCQlpZiAodG1wLT50eXBlID09IFJBRElVU19BVFRSX01FU1NBR0VfQVVUSEVOVElDQVRPUikgewogCQkJaWYgKGF0dHIgIT0gTlVMTCkgewotCQkJCXByaW50ZigiTXVsdGlwbGUgTWVzc2FnZS1BdXRoZW50aWNhdG9yICIKLQkJCQkgICAgICAgImF0dHJpYnV0ZXMgaW4gUkFESVVTIG1lc3NhZ2VcbiIpOworCQkJCXdwYV9wcmludGYoTVNHX0lORk8sICJNdWx0aXBsZSBNZXNzYWdlLUF1dGhlbnRpY2F0b3IgYXR0cmlidXRlcyBpbiBSQURJVVMgbWVzc2FnZSIpOwogCQkJCXJldHVybiAxOwogCQkJfQogCQkJYXR0ciA9IHRtcDsKQEAgLTc2NSw3ICs3OTIsNyBAQAogCX0KIAogCWlmIChhdHRyID09IE5VTEwpIHsKLQkJcHJpbnRmKCJObyBNZXNzYWdlLUF1dGhlbnRpY2F0b3IgYXR0cmlidXRlIGZvdW5kXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIE1lc3NhZ2UtQXV0aGVudGljYXRvciBhdHRyaWJ1dGUgZm91bmQiKTsKIAkJcmV0dXJuIDE7CiAJfQogCkBAIC03ODUsOCArODEyLDggQEAKIAkJCSAgc2l6ZW9mKG9yaWdfYXV0aGVudGljYXRvcikpOwogCX0KIAotCWlmIChvc19tZW1jbXAob3JpZywgYXV0aCwgTUQ1X01BQ19MRU4pICE9IDApIHsKLQkJcHJpbnRmKCJJbnZhbGlkIE1lc3NhZ2UtQXV0aGVudGljYXRvciFcbiIpOworCWlmIChvc19tZW1jbXBfY29uc3Qob3JpZywgYXV0aCwgTUQ1X01BQ19MRU4pICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgTWVzc2FnZS1BdXRoZW50aWNhdG9yISIpOwogCQlyZXR1cm4gMTsKIAl9CiAKQEAgLTgwMiw3ICs4MjksNyBAQAogCXU4IGhhc2hbTUQ1X01BQ19MRU5dOwogCiAJaWYgKHNlbnRfbXNnID09IE5VTEwpIHsKLQkJcHJpbnRmKCJObyBtYXRjaGluZyBBY2Nlc3MtUmVxdWVzdCBtZXNzYWdlIGZvdW5kXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIG1hdGNoaW5nIEFjY2Vzcy1SZXF1ZXN0IG1lc3NhZ2UgZm91bmQiKTsKIAkJcmV0dXJuIDE7CiAJfQogCkBAIC04MjIsOCArODQ5LDggQEAKIAlhZGRyWzNdID0gc2VjcmV0OwogCWxlblszXSA9IHNlY3JldF9sZW47CiAJbWQ1X3ZlY3Rvcig0LCBhZGRyLCBsZW4sIGhhc2gpOwotCWlmIChvc19tZW1jbXAoaGFzaCwgbXNnLT5oZHItPmF1dGhlbnRpY2F0b3IsIE1ENV9NQUNfTEVOKSAhPSAwKSB7Ci0JCXByaW50ZigiUmVzcG9uc2UgQXV0aGVudGljYXRvciBpbnZhbGlkIVxuIik7CisJaWYgKG9zX21lbWNtcF9jb25zdChoYXNoLCBtc2ctPmhkci0+YXV0aGVudGljYXRvciwgTUQ1X01BQ19MRU4pICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJlc3BvbnNlIEF1dGhlbnRpY2F0b3IgaW52YWxpZCEiKTsKIAkJcmV0dXJuIDE7CiAJfQogCkBAIC05NjIsNyArOTg5LDggQEAKIAlwb3MgPSBrZXkgKyAyOwogCWxlZnQgPSBsZW4gLSAyOwogCWlmIChsZWZ0ICUgMTYpIHsKLQkJcHJpbnRmKCJJbnZhbGlkIG1zIGtleSBsZW4gJWx1XG4iLCAodW5zaWduZWQgbG9uZykgbGVmdCk7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJJbnZhbGlkIG1zIGtleSBsZW4gJWx1IiwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBsZWZ0KTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCkBAIC05OTYsNyArMTAyNCw3IEBACiAJfQogCiAJaWYgKHBsYWluWzBdID09IDAgfHwgcGxhaW5bMF0gPiBwbGVuIC0gMSkgewotCQlwcmludGYoIkZhaWxlZCB0byBkZWNyeXB0IE1QUEUga2V5XG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byBkZWNyeXB0IE1QUEUga2V5Iik7CiAJCW9zX2ZyZWUocGxhaW4pOwogCQlyZXR1cm4gTlVMTDsKIAl9CkBAIC0xMjA0LDMwICsxMjMyLDU1IEBACiB9CiAKIAotLyogQWRkIFVzZXItUGFzc3dvcmQgYXR0cmlidXRlIHRvIGEgUkFESVVTIG1lc3NhZ2UgYW5kIGVuY3J5cHQgaXQgYXMgc3BlY2lmaWVkCi0gKiBpbiBSRkMgMjg2NSwgQ2hhcC4gNS4yICovCi1zdHJ1Y3QgcmFkaXVzX2F0dHJfaGRyICoKLXJhZGl1c19tc2dfYWRkX2F0dHJfdXNlcl9wYXNzd29yZChzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLAotCQkJCSAgY29uc3QgdTggKmRhdGEsIHNpemVfdCBkYXRhX2xlbiwKLQkJCQkgIGNvbnN0IHU4ICpzZWNyZXQsIHNpemVfdCBzZWNyZXRfbGVuKQoraW50IHJhZGl1c19tc2dfYWRkX3dmYShzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCB1OCBzdWJ0eXBlLCBjb25zdCB1OCAqZGF0YSwKKwkJICAgICAgIHNpemVfdCBsZW4pCiB7Ci0JdTggYnVmWzEyOF07Ci0Jc2l6ZV90IHBhZGxlbiwgaSwgYnVmX2xlbiwgcG9zOworCXN0cnVjdCByYWRpdXNfYXR0cl9oZHIgKmF0dHI7CisJdTggKmJ1ZiwgKnBvczsKKwlzaXplX3QgYWxlbjsKKworCWFsZW4gPSA0ICsgMiArIGxlbjsKKwlidWYgPSBvc19tYWxsb2MoYWxlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKwlwb3MgPSBidWY7CisJV1BBX1BVVF9CRTMyKHBvcywgUkFESVVTX1ZFTkRPUl9JRF9XRkEpOworCXBvcyArPSA0OworCSpwb3MrKyA9IHN1YnR5cGU7CisJKnBvcysrID0gMiArIGxlbjsKKwlvc19tZW1jcHkocG9zLCBkYXRhLCBsZW4pOworCWF0dHIgPSByYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgUkFESVVTX0FUVFJfVkVORE9SX1NQRUNJRklDLAorCQkJCSAgIGJ1ZiwgYWxlbik7CisJb3NfZnJlZShidWYpOworCWlmIChhdHRyID09IE5VTEwpCisJCXJldHVybiAwOworCisJcmV0dXJuIDE7Cit9CisKKworaW50IHJhZGl1c191c2VyX3Bhc3N3b3JkX2hpZGUoc3RydWN0IHJhZGl1c19tc2cgKm1zZywKKwkJCSAgICAgIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgZGF0YV9sZW4sCisJCQkgICAgICBjb25zdCB1OCAqc2VjcmV0LCBzaXplX3Qgc2VjcmV0X2xlbiwKKwkJCSAgICAgIHU4ICpidWYsIHNpemVfdCBidWZfbGVuKQoreworCXNpemVfdCBwYWRsZW4sIGksIHBvczsKIAljb25zdCB1OCAqYWRkclsyXTsKIAlzaXplX3QgbGVuWzJdOwogCXU4IGhhc2hbMTZdOwogCi0JaWYgKGRhdGFfbGVuID4gMTI4KQotCQlyZXR1cm4gTlVMTDsKKwlpZiAoZGF0YV9sZW4gKyAxNiA+IGJ1Zl9sZW4pCisJCXJldHVybiAtMTsKIAogCW9zX21lbWNweShidWYsIGRhdGEsIGRhdGFfbGVuKTsKLQlidWZfbGVuID0gZGF0YV9sZW47CiAKIAlwYWRsZW4gPSBkYXRhX2xlbiAlIDE2OwotCWlmIChwYWRsZW4gJiYgZGF0YV9sZW4gPCBzaXplb2YoYnVmKSkgeworCWlmIChwYWRsZW4gJiYgZGF0YV9sZW4gPCBidWZfbGVuKSB7CiAJCXBhZGxlbiA9IDE2IC0gcGFkbGVuOwogCQlvc19tZW1zZXQoYnVmICsgZGF0YV9sZW4sIDAsIHBhZGxlbik7Ci0JCWJ1Zl9sZW4gKz0gcGFkbGVuOworCQlidWZfbGVuID0gZGF0YV9sZW4gKyBwYWRsZW47CisJfSBlbHNlIHsKKwkJYnVmX2xlbiA9IGRhdGFfbGVuOwogCX0KIAogCWFkZHJbMF0gPSBzZWNyZXQ7CkBAIC0xMjUzLDggKzEzMDYsMjcgQEAKIAkJcG9zICs9IDE2OwogCX0KIAorCXJldHVybiBidWZfbGVuOworfQorCisKKy8qIEFkZCBVc2VyLVBhc3N3b3JkIGF0dHJpYnV0ZSB0byBhIFJBRElVUyBtZXNzYWdlIGFuZCBlbmNyeXB0IGl0IGFzIHNwZWNpZmllZAorICogaW4gUkZDIDI4NjUsIENoYXAuIDUuMiAqLworc3RydWN0IHJhZGl1c19hdHRyX2hkciAqCityYWRpdXNfbXNnX2FkZF9hdHRyX3VzZXJfcGFzc3dvcmQoc3RydWN0IHJhZGl1c19tc2cgKm1zZywKKwkJCQkgIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgZGF0YV9sZW4sCisJCQkJICBjb25zdCB1OCAqc2VjcmV0LCBzaXplX3Qgc2VjcmV0X2xlbikKK3sKKwl1OCBidWZbMTI4XTsKKwlpbnQgcmVzOworCisJcmVzID0gcmFkaXVzX3VzZXJfcGFzc3dvcmRfaGlkZShtc2csIGRhdGEsIGRhdGFfbGVuLAorCQkJCQlzZWNyZXQsIHNlY3JldF9sZW4sIGJ1Ziwgc2l6ZW9mKGJ1ZikpOworCWlmIChyZXMgPCAwKQorCQlyZXR1cm4gTlVMTDsKKwogCXJldHVybiByYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgUkFESVVTX0FUVFJfVVNFUl9QQVNTV09SRCwKLQkJCQkgICBidWYsIGJ1Zl9sZW4pOworCQkJCSAgIGJ1ZiwgcmVzKTsKIH0KIAogCmRpZmYgLS1naXQgYS9zcmMvcmFkaXVzL3JhZGl1cy5oIGIvc3JjL3JhZGl1cy9yYWRpdXMuaAppbmRleCAyMDMxMDU0Li42MmZhYWUxIDEwMDY0NAotLS0gYS9zcmMvcmFkaXVzL3JhZGl1cy5oCisrKyBiL3NyYy9yYWRpdXMvcmFkaXVzLmgKQEAgLTEsNiArMSw2IEBACiAvKgogICogUkFESVVTIG1lc3NhZ2UgcHJvY2Vzc2luZwotICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwOSwgMjAxMiwgMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtOTAsNyArOTAsMTQgQEAKICAgICAgICBSQURJVVNfQVRUUl9BQ0NUX0lOVEVSSU1fSU5URVJWQUwgPSA4NSwKICAgICAgICBSQURJVVNfQVRUUl9DSEFSR0VBQkxFX1VTRVJfSURFTlRJVFkgPSA4OSwKICAgICAgICBSQURJVVNfQVRUUl9OQVNfSVBWNl9BRERSRVNTID0gOTUsCi0gICAgICAgUkFESVVTX0FUVFJfRVJST1JfQ0FVU0UgPSAxMDEKKyAgICAgICBSQURJVVNfQVRUUl9FUlJPUl9DQVVTRSA9IDEwMSwKKyAgICAgICBSQURJVVNfQVRUUl9FQVBfS0VZX05BTUUgPSAxMDIsCisgICAgICAgUkFESVVTX0FUVFJfTU9CSUxJVFlfRE9NQUlOX0lEID0gMTc3LAorICAgICAgIFJBRElVU19BVFRSX1dMQU5fSEVTU0lEID0gMTgxLAorICAgICAgIFJBRElVU19BVFRSX1dMQU5fUEFJUldJU0VfQ0lQSEVSID0gMTg2LAorICAgICAgIFJBRElVU19BVFRSX1dMQU5fR1JPVVBfQ0lQSEVSID0gMTg3LAorICAgICAgIFJBRElVU19BVFRSX1dMQU5fQUtNX1NVSVRFID0gMTg4LAorICAgICAgIFJBRElVU19BVFRSX1dMQU5fR1JPVVBfTUdNVF9DSVBIRVIgPSAxODksCiB9OwogCiAKQEAgLTE2Myw2ICsxNzAsMTggQEAKICAgICAgICBSQURJVVNfVkVORE9SX0FUVFJfTVNfTVBQRV9SRUNWX0tFWSA9IDE3CiB9OwogCisKKy8qIEhvdHNwb3QgMi4wIC0gV0ZBIFZlbmRvci1zcGVjaWZpYyBSQURJVVMgQXR0cmlidXRlcyAqLworI2RlZmluZSBSQURJVVNfVkVORE9SX0lEX1dGQSA0MDgwOAorCitlbnVtIHsKKwlSQURJVVNfVkVORE9SX0FUVFJfV0ZBX0hTMjBfU1VCU0NSX1JFTUVESUFUSU9OID0gMSwKKwlSQURJVVNfVkVORE9SX0FUVFJfV0ZBX0hTMjBfQVBfVkVSU0lPTiA9IDIsCisJUkFESVVTX1ZFTkRPUl9BVFRSX1dGQV9IUzIwX1NUQV9WRVJTSU9OID0gMywKKwlSQURJVVNfVkVORE9SX0FUVFJfV0ZBX0hTMjBfREVBVVRIX1JFUSA9IDQsCisJUkFESVVTX1ZFTkRPUl9BVFRSX1dGQV9IUzIwX1NFU1NJT05fSU5GT19VUkwgPSA1LAorfTsKKwogI2lmZGVmIF9NU0NfVkVSCiAjcHJhZ21hIHBhY2socG9wKQogI2VuZGlmIC8qIF9NU0NfVkVSICovCkBAIC0yMDQsNiArMjIzLDkgQEAKIAkJCSAgICAgICBjb25zdCBzdHJ1Y3QgcmFkaXVzX2hkciAqcmVxX2hkcik7CiB2b2lkIHJhZGl1c19tc2dfZmluaXNoX2FjY3Qoc3RydWN0IHJhZGl1c19tc2cgKm1zZywgY29uc3QgdTggKnNlY3JldCwKIAkJCSAgICBzaXplX3Qgc2VjcmV0X2xlbik7Cit2b2lkIHJhZGl1c19tc2dfZmluaXNoX2FjY3RfcmVzcChzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAorCQkJCSBzaXplX3Qgc2VjcmV0X2xlbiwKKwkJCQkgY29uc3QgdTggKnJlcV9hdXRoZW50aWNhdG9yKTsKIGludCByYWRpdXNfbXNnX3ZlcmlmeV9hY2N0X3JlcShzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAogCQkJICAgICAgIHNpemVfdCBzZWNyZXRfbGVuKTsKIGludCByYWRpdXNfbXNnX3ZlcmlmeV9kYXNfcmVxKHN0cnVjdCByYWRpdXNfbXNnICptc2csIGNvbnN0IHU4ICpzZWNyZXQsCkBAIC0yMzQsNiArMjU2LDEyIEBACiAJCQkgICAgIGNvbnN0IHU4ICpzZWNyZXQsIHNpemVfdCBzZWNyZXRfbGVuLAogCQkJICAgICBjb25zdCB1OCAqc2VuZF9rZXksIHNpemVfdCBzZW5kX2tleV9sZW4sCiAJCQkgICAgIGNvbnN0IHU4ICpyZWN2X2tleSwgc2l6ZV90IHJlY3Zfa2V5X2xlbik7CitpbnQgcmFkaXVzX21zZ19hZGRfd2ZhKHN0cnVjdCByYWRpdXNfbXNnICptc2csIHU4IHN1YnR5cGUsIGNvbnN0IHU4ICpkYXRhLAorCQkgICAgICAgc2l6ZV90IGxlbik7CitpbnQgcmFkaXVzX3VzZXJfcGFzc3dvcmRfaGlkZShzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLAorCQkJICAgICAgY29uc3QgdTggKmRhdGEsIHNpemVfdCBkYXRhX2xlbiwKKwkJCSAgICAgIGNvbnN0IHU4ICpzZWNyZXQsIHNpemVfdCBzZWNyZXRfbGVuLAorCQkJICAgICAgdTggKmJ1Ziwgc2l6ZV90IGJ1Zl9sZW4pOwogc3RydWN0IHJhZGl1c19hdHRyX2hkciAqCiByYWRpdXNfbXNnX2FkZF9hdHRyX3VzZXJfcGFzc3dvcmQoc3RydWN0IHJhZGl1c19tc2cgKm1zZywKIAkJCQkgIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgZGF0YV9sZW4sCmRpZmYgLS1naXQgYS9zcmMvcmFkaXVzL3JhZGl1c19jbGllbnQuYyBiL3NyYy9yYWRpdXMvcmFkaXVzX2NsaWVudC5jCmluZGV4IDQyNWFkOTMuLjEwMDU2YTYgMTAwNjQ0Ci0tLSBhL3NyYy9yYWRpdXMvcmFkaXVzX2NsaWVudC5jCisrKyBiL3NyYy9yYWRpdXMvcmFkaXVzX2NsaWVudC5jCkBAIC0xMjIsNyArMTIyLDcgQEAKIAkvKioKIAkgKiBsYXN0X2F0dGVtcHQgLSBUaW1lIG9mIHRoZSBsYXN0IHRyYW5zbWlzc2lvbiBhdHRlbXB0CiAJICovCi0Jc3RydWN0IG9zX3RpbWUgbGFzdF9hdHRlbXB0OworCXN0cnVjdCBvc19yZWx0aW1lIGxhc3RfYXR0ZW1wdDsKIAogCS8qKgogCSAqIHNoYXJlZF9zZWNyZXQgLSBTaGFyZWQgc2VjcmV0IHdpdGggdGhlIHRhcmdldCBSQURJVVMgc2VydmVyCkBAIC0yOTUsMjYgKzI5NSwzNCBAQAogfQogCiAKLXN0YXRpYyB2b2lkIHJhZGl1c19jbGllbnRfaGFuZGxlX3NlbmRfZXJyb3Ioc3RydWN0IHJhZGl1c19jbGllbnRfZGF0YSAqcmFkaXVzLAotCQkJCQkgICAgaW50IHMsIFJhZGl1c1R5cGUgbXNnX3R5cGUpCisvKgorICogUmV0dXJucyA+MCBpZiBtZXNzYWdlIHF1ZXVlIHdhcyBmbHVzaGVkIChpLmUuLCB0aGUgbWVzc2FnZSB0aGF0IHRyaWdnZXJlZAorICogdGhlIGVycm9yIGlzIG5vdCBhdmFpbGFibGUgYW55bW9yZSkKKyAqLworc3RhdGljIGludCByYWRpdXNfY2xpZW50X2hhbmRsZV9zZW5kX2Vycm9yKHN0cnVjdCByYWRpdXNfY2xpZW50X2RhdGEgKnJhZGl1cywKKwkJCQkJICAgaW50IHMsIFJhZGl1c1R5cGUgbXNnX3R5cGUpCiB7CiAjaWZuZGVmIENPTkZJR19OQVRJVkVfV0lORE9XUwogCWludCBfZXJybm8gPSBlcnJubzsKLQlwZXJyb3IoInNlbmRbUkFESVVTXSIpOworCXdwYV9wcmludGYoTVNHX0lORk8sICJzZW5kW1JBRElVU106ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKIAlpZiAoX2Vycm5vID09IEVOT1RDT05OIHx8IF9lcnJubyA9PSBFREVTVEFERFJSRVEgfHwgX2Vycm5vID09IEVJTlZBTCB8fAotCSAgICBfZXJybm8gPT0gRUJBREYpIHsKKwkgICAgX2Vycm5vID09IEVCQURGIHx8IF9lcnJubyA9PSBFTkVUVU5SRUFDSCkgewogCQlob3N0YXBkX2xvZ2dlcihyYWRpdXMtPmN0eCwgTlVMTCwgSE9TVEFQRF9NT0RVTEVfUkFESVVTLAogCQkJICAgICAgIEhPU1RBUERfTEVWRUxfSU5GTywKIAkJCSAgICAgICAiU2VuZCBmYWlsZWQgLSBtYXliZSBpbnRlcmZhY2Ugc3RhdHVzIGNoYW5nZWQgLSIKIAkJCSAgICAgICAiIHRyeSB0byBjb25uZWN0IGFnYWluIik7Ci0JCWVsb29wX3VucmVnaXN0ZXJfcmVhZF9zb2NrKHMpOwotCQljbG9zZShzKTsKLQkJaWYgKG1zZ190eXBlID09IFJBRElVU19BQ0NUIHx8IG1zZ190eXBlID09IFJBRElVU19BQ0NUX0lOVEVSSU0pCisJCWlmIChtc2dfdHlwZSA9PSBSQURJVVNfQUNDVCB8fAorCQkgICAgbXNnX3R5cGUgPT0gUkFESVVTX0FDQ1RfSU5URVJJTSkgewogCQkJcmFkaXVzX2NsaWVudF9pbml0X2FjY3QocmFkaXVzKTsKLQkJZWxzZQorCQkJcmV0dXJuIDA7CisJCX0gZWxzZSB7CiAJCQlyYWRpdXNfY2xpZW50X2luaXRfYXV0aChyYWRpdXMpOworCQkJcmV0dXJuIDE7CisJCX0KIAl9CiAjZW5kaWYgLyogQ09ORklHX05BVElWRV9XSU5ET1dTICovCisKKwlyZXR1cm4gMDsKIH0KIAogCkBAIC0zNTEsMTggKzM1OSwyMCBAQAogCQkgICAgICAgSE9TVEFQRF9MRVZFTF9ERUJVRywgIlJlc2VuZGluZyBSQURJVVMgbWVzc2FnZSAoaWQ9JWQpIiwKIAkJICAgICAgIHJhZGl1c19tc2dfZ2V0X2hkcihlbnRyeS0+bXNnKS0+aWRlbnRpZmllcik7CiAKLQlvc19nZXRfdGltZSgmZW50cnktPmxhc3RfYXR0ZW1wdCk7CisJb3NfZ2V0X3JlbHRpbWUoJmVudHJ5LT5sYXN0X2F0dGVtcHQpOwogCWJ1ZiA9IHJhZGl1c19tc2dfZ2V0X2J1ZihlbnRyeS0+bXNnKTsKLQlpZiAoc2VuZChzLCB3cGFidWZfaGVhZChidWYpLCB3cGFidWZfbGVuKGJ1ZiksIDApIDwgMCkKLQkJcmFkaXVzX2NsaWVudF9oYW5kbGVfc2VuZF9lcnJvcihyYWRpdXMsIHMsIGVudHJ5LT5tc2dfdHlwZSk7CisJaWYgKHNlbmQocywgd3BhYnVmX2hlYWQoYnVmKSwgd3BhYnVmX2xlbihidWYpLCAwKSA8IDApIHsKKwkJaWYgKHJhZGl1c19jbGllbnRfaGFuZGxlX3NlbmRfZXJyb3IocmFkaXVzLCBzLCBlbnRyeS0+bXNnX3R5cGUpCisJCSAgICA+IDApCisJCQlyZXR1cm4gMDsKKwl9CiAKIAllbnRyeS0+bmV4dF90cnkgPSBub3cgKyBlbnRyeS0+bmV4dF93YWl0OwogCWVudHJ5LT5uZXh0X3dhaXQgKj0gMjsKIAlpZiAoZW50cnktPm5leHRfd2FpdCA+IFJBRElVU19DTElFTlRfTUFYX1dBSVQpCiAJCWVudHJ5LT5uZXh0X3dhaXQgPSBSQURJVVNfQ0xJRU5UX01BWF9XQUlUOwogCWlmIChlbnRyeS0+YXR0ZW1wdHMgPj0gUkFESVVTX0NMSUVOVF9NQVhfUkVUUklFUykgewotCQlwcmludGYoIlJlbW92aW5nIHVuLUFDS2VkIFJBRElVUyBtZXNzYWdlIGR1ZSB0byB0b28gbWFueSAiCi0JCSAgICAgICAiZmFpbGVkIHJldHJhbnNtaXQgYXR0ZW1wdHNcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUkFESVVTOiBSZW1vdmluZyB1bi1BQ0tlZCBtZXNzYWdlIGR1ZSB0byB0b28gbWFueSBmYWlsZWQgcmV0cmFuc21pdCBhdHRlbXB0cyIpOwogCQlyZXR1cm4gMTsKIAl9CiAKQEAgLTM3NCwyMSArMzg0LDI0IEBACiB7CiAJc3RydWN0IHJhZGl1c19jbGllbnRfZGF0YSAqcmFkaXVzID0gZWxvb3BfY3R4OwogCXN0cnVjdCBob3N0YXBkX3JhZGl1c19zZXJ2ZXJzICpjb25mID0gcmFkaXVzLT5jb25mOwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAJb3NfdGltZV90IGZpcnN0OwogCXN0cnVjdCByYWRpdXNfbXNnX2xpc3QgKmVudHJ5LCAqcHJldiwgKnRtcDsKIAlpbnQgYXV0aF9mYWlsb3ZlciA9IDAsIGFjY3RfZmFpbG92ZXIgPSAwOwogCWNoYXIgYWJ1Zls1MF07CisJc2l6ZV90IHByZXZfbnVtX21zZ3M7CisJaW50IHM7CiAKIAllbnRyeSA9IHJhZGl1cy0+bXNnczsKIAlpZiAoIWVudHJ5KQogCQlyZXR1cm47CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAlmaXJzdCA9IDA7CiAKIAlwcmV2ID0gTlVMTDsKIAl3aGlsZSAoZW50cnkpIHsKKwkJcHJldl9udW1fbXNncyA9IHJhZGl1cy0+bnVtX21zZ3M7CiAJCWlmIChub3cuc2VjID49IGVudHJ5LT5uZXh0X3RyeSAmJgogCQkgICAgcmFkaXVzX2NsaWVudF9yZXRyYW5zbWl0KHJhZGl1cywgZW50cnksIG5vdy5zZWMpKSB7CiAJCQlpZiAocHJldikKQEAgLTQwMyw3ICs0MTYsMTggQEAKIAkJCWNvbnRpbnVlOwogCQl9CiAKLQkJaWYgKGVudHJ5LT5hdHRlbXB0cyA+IFJBRElVU19DTElFTlRfTlVNX0ZBSUxPVkVSKSB7CisJCWlmIChwcmV2X251bV9tc2dzICE9IHJhZGl1cy0+bnVtX21zZ3MpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJSQURJVVM6IE1lc3NhZ2UgcmVtb3ZlZCBmcm9tIHF1ZXVlIC0gcmVzdGFydCBmcm9tIGJlZ2lubmluZyIpOworCQkJZW50cnkgPSByYWRpdXMtPm1zZ3M7CisJCQlwcmV2ID0gTlVMTDsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJcyA9IGVudHJ5LT5tc2dfdHlwZSA9PSBSQURJVVNfQVVUSCA/IHJhZGl1cy0+YXV0aF9zb2NrIDoKKwkJCXJhZGl1cy0+YWNjdF9zb2NrOworCQlpZiAoZW50cnktPmF0dGVtcHRzID4gUkFESVVTX0NMSUVOVF9OVU1fRkFJTE9WRVIgfHwKKwkJICAgIChzIDwgMCAmJiBlbnRyeS0+YXR0ZW1wdHMgPiAwKSkgewogCQkJaWYgKGVudHJ5LT5tc2dfdHlwZSA9PSBSQURJVVNfQUNDVCB8fAogCQkJICAgIGVudHJ5LT5tc2dfdHlwZSA9PSBSQURJVVNfQUNDVF9JTlRFUklNKQogCQkJCWFjY3RfZmFpbG92ZXIrKzsKQEAgLTQ4Miw3ICs1MDYsNyBAQAogCiBzdGF0aWMgdm9pZCByYWRpdXNfY2xpZW50X3VwZGF0ZV90aW1lb3V0KHN0cnVjdCByYWRpdXNfY2xpZW50X2RhdGEgKnJhZGl1cykKIHsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCW9zX3RpbWVfdCBmaXJzdDsKIAlzdHJ1Y3QgcmFkaXVzX21zZ19saXN0ICplbnRyeTsKIApAQCAtNDk4LDcgKzUyMiw3IEBACiAJCQlmaXJzdCA9IGVudHJ5LT5uZXh0X3RyeTsKIAl9CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAlpZiAoZmlyc3QgPCBub3cuc2VjKQogCQlmaXJzdCA9IG5vdy5zZWM7CiAJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChmaXJzdCAtIG5vdy5zZWMsIDAsIHJhZGl1c19jbGllbnRfdGltZXIsIHJhZGl1cywKQEAgLTUyNiw3ICs1NTAsNyBAQAogCiAJZW50cnkgPSBvc196YWxsb2Moc2l6ZW9mKCplbnRyeSkpOwogCWlmIChlbnRyeSA9PSBOVUxMKSB7Ci0JCXByaW50ZigiRmFpbGVkIHRvIGFkZCBSQURJVVMgcGFja2V0IGludG8gcmV0cmFuc21pdCBsaXN0XG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJBRElVUzogRmFpbGVkIHRvIGFkZCBwYWNrZXQgaW50byByZXRyYW5zbWl0IGxpc3QiKTsKIAkJcmFkaXVzX21zZ19mcmVlKG1zZyk7CiAJCXJldHVybjsKIAl9CkBAIC01MzcsNyArNTYxLDcgQEAKIAllbnRyeS0+bXNnX3R5cGUgPSBtc2dfdHlwZTsKIAllbnRyeS0+c2hhcmVkX3NlY3JldCA9IHNoYXJlZF9zZWNyZXQ7CiAJZW50cnktPnNoYXJlZF9zZWNyZXRfbGVuID0gc2hhcmVkX3NlY3JldF9sZW47Ci0Jb3NfZ2V0X3RpbWUoJmVudHJ5LT5sYXN0X2F0dGVtcHQpOworCW9zX2dldF9yZWx0aW1lKCZlbnRyeS0+bGFzdF9hdHRlbXB0KTsKIAllbnRyeS0+Zmlyc3RfdHJ5ID0gZW50cnktPmxhc3RfYXR0ZW1wdC5zZWM7CiAJZW50cnktPm5leHRfdHJ5ID0gZW50cnktPmZpcnN0X3RyeSArIFJBRElVU19DTElFTlRfRklSU1RfV0FJVDsKIAllbnRyeS0+YXR0ZW1wdHMgPSAxOwpAQCAtNTQ3LDggKzU3MSw3IEBACiAJcmFkaXVzX2NsaWVudF91cGRhdGVfdGltZW91dChyYWRpdXMpOwogCiAJaWYgKHJhZGl1cy0+bnVtX21zZ3MgPj0gUkFESVVTX0NMSUVOVF9NQVhfRU5UUklFUykgewotCQlwcmludGYoIlJlbW92aW5nIHRoZSBvbGRlc3QgdW4tQUNLZWQgUkFESVVTIHBhY2tldCBkdWUgdG8gIgotCQkgICAgICAgInJldHJhbnNtaXQgbGlzdCBsaW1pdHMuXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJBRElVUzogUmVtb3ZpbmcgdGhlIG9sZGVzdCB1bi1BQ0tlZCBwYWNrZXQgZHVlIHRvIHJldHJhbnNtaXQgbGlzdCBsaW1pdHMiKTsKIAkJcHJldiA9IE5VTEw7CiAJCXdoaWxlIChlbnRyeS0+bmV4dCkgewogCQkJcHJldiA9IGVudHJ5OwpAQCAtNjM1LDcgKzY1OCw3IEBACiAJfQogCiAJaWYgKG1zZ190eXBlID09IFJBRElVU19BQ0NUIHx8IG1zZ190eXBlID09IFJBRElVU19BQ0NUX0lOVEVSSU0pIHsKLQkJaWYgKGNvbmYtPmFjY3Rfc2VydmVyID09IE5VTEwpIHsKKwkJaWYgKGNvbmYtPmFjY3Rfc2VydmVyID09IE5VTEwgfHwgcmFkaXVzLT5hY2N0X3NvY2sgPCAwKSB7CiAJCQlob3N0YXBkX2xvZ2dlcihyYWRpdXMtPmN0eCwgTlVMTCwKIAkJCQkgICAgICAgSE9TVEFQRF9NT0RVTEVfUkFESVVTLAogCQkJCSAgICAgICBIT1NUQVBEX0xFVkVMX0lORk8sCkBAIC02NDksNyArNjcyLDcgQEAKIAkJcyA9IHJhZGl1cy0+YWNjdF9zb2NrOwogCQljb25mLT5hY2N0X3NlcnZlci0+cmVxdWVzdHMrKzsKIAl9IGVsc2UgewotCQlpZiAoY29uZi0+YXV0aF9zZXJ2ZXIgPT0gTlVMTCkgeworCQlpZiAoY29uZi0+YXV0aF9zZXJ2ZXIgPT0gTlVMTCB8fCByYWRpdXMtPmF1dGhfc29jayA8IDApIHsKIAkJCWhvc3RhcGRfbG9nZ2VyKHJhZGl1cy0+Y3R4LCBOVUxMLAogCQkJCSAgICAgICBIT1NUQVBEX01PRFVMRV9SQURJVVMsCiAJCQkJICAgICAgIEhPU1RBUERfTEVWRUxfSU5GTywKQEAgLTY5NCw3ICs3MTcsNyBAQAogCXN0cnVjdCByYWRpdXNfcnhfaGFuZGxlciAqaGFuZGxlcnM7CiAJc2l6ZV90IG51bV9oYW5kbGVycywgaTsKIAlzdHJ1Y3QgcmFkaXVzX21zZ19saXN0ICpyZXEsICpwcmV2X3JlcTsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCXN0cnVjdCBob3N0YXBkX3JhZGl1c19zZXJ2ZXIgKnJjb25mOwogCWludCBpbnZhbGlkX2F1dGhlbnRpY2F0b3IgPSAwOwogCkBAIC03MTAsMjEgKzczMywyMCBAQAogCiAJbGVuID0gcmVjdihzb2NrLCBidWYsIHNpemVvZihidWYpLCBNU0dfRE9OVFdBSVQpOwogCWlmIChsZW4gPCAwKSB7Ci0JCXBlcnJvcigicmVjdltSQURJVVNdIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJyZWN2W1JBRElVU106ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKIAkJcmV0dXJuOwogCX0KIAlob3N0YXBkX2xvZ2dlcihyYWRpdXMtPmN0eCwgTlVMTCwgSE9TVEFQRF9NT0RVTEVfUkFESVVTLAogCQkgICAgICAgSE9TVEFQRF9MRVZFTF9ERUJVRywgIlJlY2VpdmVkICVkIGJ5dGVzIGZyb20gUkFESVVTICIKIAkJICAgICAgICJzZXJ2ZXIiLCBsZW4pOwogCWlmIChsZW4gPT0gc2l6ZW9mKGJ1ZikpIHsKLQkJcHJpbnRmKCJQb3NzaWJseSB0b28gbG9uZyBVRFAgZnJhbWUgZm9yIG91ciBidWZmZXIgLSAiCi0JCSAgICAgICAiZHJvcHBpbmcgaXRcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUkFESVVTOiBQb3NzaWJseSB0b28gbG9uZyBVRFAgZnJhbWUgZm9yIG91ciBidWZmZXIgLSBkcm9wcGluZyBpdCIpOwogCQlyZXR1cm47CiAJfQogCiAJbXNnID0gcmFkaXVzX21zZ19wYXJzZShidWYsIGxlbik7CiAJaWYgKG1zZyA9PSBOVUxMKSB7Ci0JCXByaW50ZigiUGFyc2luZyBpbmNvbWluZyBSQURJVVMgZnJhbWUgZmFpbGVkXG4iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJBRElVUzogUGFyc2luZyBpbmNvbWluZyBmcmFtZSBmYWlsZWQiKTsKIAkJcmNvbmYtPm1hbGZvcm1lZF9yZXNwb25zZXMrKzsKIAkJcmV0dXJuOwogCX0KQEAgLTc3NSw3ICs3OTcsNyBAQAogCQlnb3RvIGZhaWw7CiAJfQogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7CisJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CiAJcm91bmR0cmlwID0gKG5vdy5zZWMgLSByZXEtPmxhc3RfYXR0ZW1wdC5zZWMpICogMTAwICsKIAkJKG5vdy51c2VjIC0gcmVxLT5sYXN0X2F0dGVtcHQudXNlYykgLyAxMDAwMDsKIAlob3N0YXBkX2xvZ2dlcihyYWRpdXMtPmN0eCwgcmVxLT5hZGRyLCBIT1NUQVBEX01PRFVMRV9SQURJVVMsCkBAIC05NTQsOSArOTc2LDEwIEBACiAJCSAgICAgICBob3N0YXBkX2lwX3R4dCgmbnNlcnYtPmFkZHIsIGFidWYsIHNpemVvZihhYnVmKSksCiAJCSAgICAgICBuc2Vydi0+cG9ydCk7CiAKLQlpZiAoIW9zZXJ2IHx8IG5zZXJ2LT5zaGFyZWRfc2VjcmV0X2xlbiAhPSBvc2Vydi0+c2hhcmVkX3NlY3JldF9sZW4gfHwKLQkgICAgb3NfbWVtY21wKG5zZXJ2LT5zaGFyZWRfc2VjcmV0LCBvc2Vydi0+c2hhcmVkX3NlY3JldCwKLQkJICAgICAgbnNlcnYtPnNoYXJlZF9zZWNyZXRfbGVuKSAhPSAwKSB7CisJaWYgKG9zZXJ2ICYmIG9zZXJ2ICE9IG5zZXJ2ICYmCisJICAgIChuc2Vydi0+c2hhcmVkX3NlY3JldF9sZW4gIT0gb3NlcnYtPnNoYXJlZF9zZWNyZXRfbGVuIHx8CisJICAgICBvc19tZW1jbXAobnNlcnYtPnNoYXJlZF9zZWNyZXQsIG9zZXJ2LT5zaGFyZWRfc2VjcmV0LAorCQkgICAgICAgbnNlcnYtPnNoYXJlZF9zZWNyZXRfbGVuKSAhPSAwKSkgewogCQkvKiBQZW5kaW5nIFJBRElVUyBwYWNrZXRzIHVzZWQgZGlmZmVyZW50IHNoYXJlZCBzZWNyZXQsIHNvCiAJCSAqIHRoZXkgbmVlZCB0byBiZSBtb2RpZmllZC4gVXBkYXRlIGFjY291bnRpbmcgbWVzc2FnZQogCQkgKiBhdXRoZW50aWNhdG9ycyBoZXJlLiBBdXRoZW50aWNhdGlvbiBtZXNzYWdlcyBhcmUgcmVtb3ZlZApAQCAtOTc0LDcgKzk5Nyw4IEBACiAJfQogCiAJLyogUmVzZXQgcmV0cnkgY291bnRlcnMgZm9yIHRoZSBuZXcgc2VydmVyICovCi0JZm9yIChlbnRyeSA9IHJhZGl1cy0+bXNnczsgZW50cnk7IGVudHJ5ID0gZW50cnktPm5leHQpIHsKKwlmb3IgKGVudHJ5ID0gcmFkaXVzLT5tc2dzOyBvc2VydiAmJiBvc2VydiAhPSBuc2VydiAmJiBlbnRyeTsKKwkgICAgIGVudHJ5ID0gZW50cnktPm5leHQpIHsKIAkJaWYgKChhdXRoICYmIGVudHJ5LT5tc2dfdHlwZSAhPSBSQURJVVNfQVVUSCkgfHwKIAkJICAgICghYXV0aCAmJiBlbnRyeS0+bXNnX3R5cGUgIT0gUkFESVVTX0FDQ1QpKQogCQkJY29udGludWU7CkBAIC0xMDQxLDEzICsxMDY1LDE0IEBACiAJCX0KIAogCQlpZiAoYmluZChzZWxfc29jaywgY2xfYWRkciwgY2xhZGRybGVuKSA8IDApIHsKLQkJCXBlcnJvcigiYmluZFtyYWRpdXNdIik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiYmluZFtyYWRpdXNdOiAlcyIsCisJCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJCXJldHVybiAtMTsKIAkJfQogCX0KIAogCWlmIChjb25uZWN0KHNlbF9zb2NrLCBhZGRyLCBhZGRybGVuKSA8IDApIHsKLQkJcGVycm9yKCJjb25uZWN0W3JhZGl1c10iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgImNvbm5lY3RbcmFkaXVzXTogJXMiLCBzdHJlcnJvcihlcnJubykpOwogCQlyZXR1cm4gLTE7CiAJfQogCkBAIC0xMTIzLDIxICsxMTQ4LDYyIEBACiAJciA9IHNldHNvY2tvcHQocywgSVBQUk9UT19JUCwgSVBfTVRVX0RJU0NPVkVSLCAmYWN0aW9uLAogCQkgICAgICAgc2l6ZW9mKGFjdGlvbikpOwogCWlmIChyID09IC0xKQotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBzZXQgSVBfTVRVX0RJU0NPVkVSOiAiCi0JCQkgICAiJXMiLCBzdHJlcnJvcihlcnJubykpOworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIlJBRElVUzogRmFpbGVkIHRvIHNldCBJUF9NVFVfRElTQ09WRVI6ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAjZW5kaWYKIAlyZXR1cm4gcjsKIH0KIAogCitzdGF0aWMgdm9pZCByYWRpdXNfY2xvc2VfYXV0aF9zb2NrZXRzKHN0cnVjdCByYWRpdXNfY2xpZW50X2RhdGEgKnJhZGl1cykKK3sKKwlyYWRpdXMtPmF1dGhfc29jayA9IC0xOworCisJaWYgKHJhZGl1cy0+YXV0aF9zZXJ2X3NvY2sgPj0gMCkgeworCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhyYWRpdXMtPmF1dGhfc2Vydl9zb2NrKTsKKwkJY2xvc2UocmFkaXVzLT5hdXRoX3NlcnZfc29jayk7CisJCXJhZGl1cy0+YXV0aF9zZXJ2X3NvY2sgPSAtMTsKKwl9CisjaWZkZWYgQ09ORklHX0lQVjYKKwlpZiAocmFkaXVzLT5hdXRoX3NlcnZfc29jazYgPj0gMCkgeworCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhyYWRpdXMtPmF1dGhfc2Vydl9zb2NrNik7CisJCWNsb3NlKHJhZGl1cy0+YXV0aF9zZXJ2X3NvY2s2KTsKKwkJcmFkaXVzLT5hdXRoX3NlcnZfc29jazYgPSAtMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0lQVjYgKi8KK30KKworCitzdGF0aWMgdm9pZCByYWRpdXNfY2xvc2VfYWNjdF9zb2NrZXRzKHN0cnVjdCByYWRpdXNfY2xpZW50X2RhdGEgKnJhZGl1cykKK3sKKwlyYWRpdXMtPmFjY3Rfc29jayA9IC0xOworCisJaWYgKHJhZGl1cy0+YWNjdF9zZXJ2X3NvY2sgPj0gMCkgeworCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhyYWRpdXMtPmFjY3Rfc2Vydl9zb2NrKTsKKwkJY2xvc2UocmFkaXVzLT5hY2N0X3NlcnZfc29jayk7CisJCXJhZGl1cy0+YWNjdF9zZXJ2X3NvY2sgPSAtMTsKKwl9CisjaWZkZWYgQ09ORklHX0lQVjYKKwlpZiAocmFkaXVzLT5hY2N0X3NlcnZfc29jazYgPj0gMCkgeworCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhyYWRpdXMtPmFjY3Rfc2Vydl9zb2NrNik7CisJCWNsb3NlKHJhZGl1cy0+YWNjdF9zZXJ2X3NvY2s2KTsKKwkJcmFkaXVzLT5hY2N0X3NlcnZfc29jazYgPSAtMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0lQVjYgKi8KK30KKworCiBzdGF0aWMgaW50IHJhZGl1c19jbGllbnRfaW5pdF9hdXRoKHN0cnVjdCByYWRpdXNfY2xpZW50X2RhdGEgKnJhZGl1cykKIHsKIAlzdHJ1Y3QgaG9zdGFwZF9yYWRpdXNfc2VydmVycyAqY29uZiA9IHJhZGl1cy0+Y29uZjsKIAlpbnQgb2sgPSAwOwogCisJcmFkaXVzX2Nsb3NlX2F1dGhfc29ja2V0cyhyYWRpdXMpOworCiAJcmFkaXVzLT5hdXRoX3NlcnZfc29jayA9IHNvY2tldChQRl9JTkVULCBTT0NLX0RHUkFNLCAwKTsKIAlpZiAocmFkaXVzLT5hdXRoX3NlcnZfc29jayA8IDApCi0JCXBlcnJvcigic29ja2V0W1BGX0lORVQsU09DS19ER1JBTV0iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJBRElVUzogc29ja2V0W1BGX0lORVQsU09DS19ER1JBTV06ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJZWxzZSB7CiAJCXJhZGl1c19jbGllbnRfZGlzYWJsZV9wbXR1X2Rpc2NvdmVyeShyYWRpdXMtPmF1dGhfc2Vydl9zb2NrKTsKIAkJb2srKzsKQEAgLTExNDYsNyArMTIxMiw4IEBACiAjaWZkZWYgQ09ORklHX0lQVjYKIAlyYWRpdXMtPmF1dGhfc2Vydl9zb2NrNiA9IHNvY2tldChQRl9JTkVUNiwgU09DS19ER1JBTSwgMCk7CiAJaWYgKHJhZGl1cy0+YXV0aF9zZXJ2X3NvY2s2IDwgMCkKLQkJcGVycm9yKCJzb2NrZXRbUEZfSU5FVDYsU09DS19ER1JBTV0iKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJBRElVUzogc29ja2V0W1BGX0lORVQ2LFNPQ0tfREdSQU1dOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOwogCWVsc2UKIAkJb2srKzsKICNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLwpAQCAtMTE2Miw4ICsxMjI5LDggQEAKIAkgICAgZWxvb3BfcmVnaXN0ZXJfcmVhZF9zb2NrKHJhZGl1cy0+YXV0aF9zZXJ2X3NvY2ssCiAJCQkJICAgICByYWRpdXNfY2xpZW50X3JlY2VpdmUsIHJhZGl1cywKIAkJCQkgICAgICh2b2lkICopIFJBRElVU19BVVRIKSkgewotCQlwcmludGYoIkNvdWxkIG5vdCByZWdpc3RlciByZWFkIHNvY2tldCBmb3IgYXV0aGVudGljYXRpb24gIgotCQkgICAgICAgInNlcnZlclxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSQURJVVM6IENvdWxkIG5vdCByZWdpc3RlciByZWFkIHNvY2tldCBmb3IgYXV0aGVudGljYXRpb24gc2VydmVyIik7CisJCXJhZGl1c19jbG9zZV9hdXRoX3NvY2tldHMocmFkaXVzKTsKIAkJcmV0dXJuIC0xOwogCX0KIApAQCAtMTE3Miw4ICsxMjM5LDggQEAKIAkgICAgZWxvb3BfcmVnaXN0ZXJfcmVhZF9zb2NrKHJhZGl1cy0+YXV0aF9zZXJ2X3NvY2s2LAogCQkJCSAgICAgcmFkaXVzX2NsaWVudF9yZWNlaXZlLCByYWRpdXMsCiAJCQkJICAgICAodm9pZCAqKSBSQURJVVNfQVVUSCkpIHsKLQkJcHJpbnRmKCJDb3VsZCBub3QgcmVnaXN0ZXIgcmVhZCBzb2NrZXQgZm9yIGF1dGhlbnRpY2F0aW9uICIKLQkJICAgICAgICJzZXJ2ZXJcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUkFESVVTOiBDb3VsZCBub3QgcmVnaXN0ZXIgcmVhZCBzb2NrZXQgZm9yIGF1dGhlbnRpY2F0aW9uIHNlcnZlciIpOworCQlyYWRpdXNfY2xvc2VfYXV0aF9zb2NrZXRzKHJhZGl1cyk7CiAJCXJldHVybiAtMTsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lQVjYgKi8KQEAgLTExODcsOSArMTI1NCwxMiBAQAogCXN0cnVjdCBob3N0YXBkX3JhZGl1c19zZXJ2ZXJzICpjb25mID0gcmFkaXVzLT5jb25mOwogCWludCBvayA9IDA7CiAKKwlyYWRpdXNfY2xvc2VfYWNjdF9zb2NrZXRzKHJhZGl1cyk7CisKIAlyYWRpdXMtPmFjY3Rfc2Vydl9zb2NrID0gc29ja2V0KFBGX0lORVQsIFNPQ0tfREdSQU0sIDApOwogCWlmIChyYWRpdXMtPmFjY3Rfc2Vydl9zb2NrIDwgMCkKLQkJcGVycm9yKCJzb2NrZXRbUEZfSU5FVCxTT0NLX0RHUkFNXSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUkFESVVTOiBzb2NrZXRbUEZfSU5FVCxTT0NLX0RHUkFNXTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAllbHNlIHsKIAkJcmFkaXVzX2NsaWVudF9kaXNhYmxlX3BtdHVfZGlzY292ZXJ5KHJhZGl1cy0+YWNjdF9zZXJ2X3NvY2spOwogCQlvaysrOwpAQCAtMTE5OCw3ICsxMjY4LDggQEAKICNpZmRlZiBDT05GSUdfSVBWNgogCXJhZGl1cy0+YWNjdF9zZXJ2X3NvY2s2ID0gc29ja2V0KFBGX0lORVQ2LCBTT0NLX0RHUkFNLCAwKTsKIAlpZiAocmFkaXVzLT5hY2N0X3NlcnZfc29jazYgPCAwKQotCQlwZXJyb3IoInNvY2tldFtQRl9JTkVUNixTT0NLX0RHUkFNXSIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUkFESVVTOiBzb2NrZXRbUEZfSU5FVDYsU09DS19ER1JBTV06ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CiAJZWxzZQogCQlvaysrOwogI2VuZGlmIC8qIENPTkZJR19JUFY2ICovCkBAIC0xMjE0LDggKzEyODUsOCBAQAogCSAgICBlbG9vcF9yZWdpc3Rlcl9yZWFkX3NvY2socmFkaXVzLT5hY2N0X3NlcnZfc29jaywKIAkJCQkgICAgIHJhZGl1c19jbGllbnRfcmVjZWl2ZSwgcmFkaXVzLAogCQkJCSAgICAgKHZvaWQgKikgUkFESVVTX0FDQ1QpKSB7Ci0JCXByaW50ZigiQ291bGQgbm90IHJlZ2lzdGVyIHJlYWQgc29ja2V0IGZvciBhY2NvdW50aW5nICIKLQkJICAgICAgICJzZXJ2ZXJcbiIpOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUkFESVVTOiBDb3VsZCBub3QgcmVnaXN0ZXIgcmVhZCBzb2NrZXQgZm9yIGFjY291bnRpbmcgc2VydmVyIik7CisJCXJhZGl1c19jbG9zZV9hY2N0X3NvY2tldHMocmFkaXVzKTsKIAkJcmV0dXJuIC0xOwogCX0KIApAQCAtMTIyNCw4ICsxMjk1LDggQEAKIAkgICAgZWxvb3BfcmVnaXN0ZXJfcmVhZF9zb2NrKHJhZGl1cy0+YWNjdF9zZXJ2X3NvY2s2LAogCQkJCSAgICAgcmFkaXVzX2NsaWVudF9yZWNlaXZlLCByYWRpdXMsCiAJCQkJICAgICAodm9pZCAqKSBSQURJVVNfQUNDVCkpIHsKLQkJcHJpbnRmKCJDb3VsZCBub3QgcmVnaXN0ZXIgcmVhZCBzb2NrZXQgZm9yIGFjY291bnRpbmcgIgotCQkgICAgICAgInNlcnZlclxuIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSQURJVVM6IENvdWxkIG5vdCByZWdpc3RlciByZWFkIHNvY2tldCBmb3IgYWNjb3VudGluZyBzZXJ2ZXIiKTsKKwkJcmFkaXVzX2Nsb3NlX2FjY3Rfc29ja2V0cyhyYWRpdXMpOwogCQlyZXR1cm4gLTE7CiAJfQogI2VuZGlmIC8qIENPTkZJR19JUFY2ICovCkBAIC0xMjg3LDE2ICsxMzU4LDggQEAKIAlpZiAoIXJhZGl1cykKIAkJcmV0dXJuOwogCi0JaWYgKHJhZGl1cy0+YXV0aF9zZXJ2X3NvY2sgPj0gMCkKLQkJZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2socmFkaXVzLT5hdXRoX3NlcnZfc29jayk7Ci0JaWYgKHJhZGl1cy0+YWNjdF9zZXJ2X3NvY2sgPj0gMCkKLQkJZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2socmFkaXVzLT5hY2N0X3NlcnZfc29jayk7Ci0jaWZkZWYgQ09ORklHX0lQVjYKLQlpZiAocmFkaXVzLT5hdXRoX3NlcnZfc29jazYgPj0gMCkKLQkJZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2socmFkaXVzLT5hdXRoX3NlcnZfc29jazYpOwotCWlmIChyYWRpdXMtPmFjY3Rfc2Vydl9zb2NrNiA+PSAwKQotCQllbG9vcF91bnJlZ2lzdGVyX3JlYWRfc29jayhyYWRpdXMtPmFjY3Rfc2Vydl9zb2NrNik7Ci0jZW5kaWYgLyogQ09ORklHX0lQVjYgKi8KKwlyYWRpdXNfY2xvc2VfYXV0aF9zb2NrZXRzKHJhZGl1cyk7CisJcmFkaXVzX2Nsb3NlX2FjY3Rfc29ja2V0cyhyYWRpdXMpOwogCiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQocmFkaXVzX3JldHJ5X3ByaW1hcnlfdGltZXIsIHJhZGl1cywgTlVMTCk7CiAKZGlmZiAtLWdpdCBhL3NyYy9yYWRpdXMvcmFkaXVzX2Rhcy5jIGIvc3JjL3JhZGl1cy9yYWRpdXNfZGFzLmMKaW5kZXggYmRlZDk2NS4uOTY1NWY0YyAxMDA2NDQKLS0tIGEvc3JjL3JhZGl1cy9yYWRpdXNfZGFzLmMKKysrIGIvc3JjL3JhZGl1cy9yYWRpdXNfZGFzLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogUkFESVVTIER5bmFtaWMgQXV0aG9yaXphdGlvbiBTZXJ2ZXIgKERBUykgKFJGQyA1MTc2KQotICogQ29weXJpZ2h0IChjKSAyMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDEyLTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTE2LDkgKzE2LDYgQEAKICNpbmNsdWRlICJyYWRpdXNfZGFzLmgiCiAKIAotZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7Ci0KLQogc3RydWN0IHJhZGl1c19kYXNfZGF0YSB7CiAJaW50IHNvY2s7CiAJdTggKnNoYXJlZF9zZWNyZXQ7CkBAIC00MSwxMSArMzgsMTYgQEAKIAlzdHJ1Y3QgcmFkaXVzX21zZyAqcmVwbHk7CiAJdTggYWxsb3dlZFtdID0gewogCQlSQURJVVNfQVRUUl9VU0VSX05BTUUsCisJCVJBRElVU19BVFRSX05BU19JUF9BRERSRVNTLAogCQlSQURJVVNfQVRUUl9DQUxMSU5HX1NUQVRJT05fSUQsCisJCVJBRElVU19BVFRSX05BU19JREVOVElGSUVSLAogCQlSQURJVVNfQVRUUl9BQ0NUX1NFU1NJT05fSUQsCiAJCVJBRElVU19BVFRSX0VWRU5UX1RJTUVTVEFNUCwKIAkJUkFESVVTX0FUVFJfTUVTU0FHRV9BVVRIRU5USUNBVE9SLAogCQlSQURJVVNfQVRUUl9DSEFSR0VBQkxFX1VTRVJfSURFTlRJVFksCisjaWZkZWYgQ09ORklHX0lQVjYKKwkJUkFESVVTX0FUVFJfTkFTX0lQVjZfQUREUkVTUywKKyNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLwogCQkwCiAJfTsKIAlpbnQgZXJyb3IgPSA0MDU7CkBAIC03MCw2ICs3MiwzNiBAQAogCiAJb3NfbWVtc2V0KCZhdHRycywgMCwgc2l6ZW9mKGF0dHJzKSk7CiAKKwlpZiAocmFkaXVzX21zZ19nZXRfYXR0cl9wdHIobXNnLCBSQURJVVNfQVRUUl9OQVNfSVBfQUREUkVTUywKKwkJCQkgICAgJmJ1ZiwgJmxlbiwgTlVMTCkgPT0gMCkgeworCQlpZiAobGVuICE9IDQpIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJEQVM6IEludmFsaWQgTkFTLUlQLUFkZHJlc3MgZnJvbSAlczolZCIsCisJCQkJICAgYWJ1ZiwgZnJvbV9wb3J0KTsKKwkJCWVycm9yID0gNDA3OworCQkJZ290byBmYWlsOworCQl9CisJCWF0dHJzLm5hc19pcF9hZGRyID0gYnVmOworCX0KKworI2lmZGVmIENPTkZJR19JUFY2CisJaWYgKHJhZGl1c19tc2dfZ2V0X2F0dHJfcHRyKG1zZywgUkFESVVTX0FUVFJfTkFTX0lQVjZfQUREUkVTUywKKwkJCQkgICAgJmJ1ZiwgJmxlbiwgTlVMTCkgPT0gMCkgeworCQlpZiAobGVuICE9IDE2KSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiREFTOiBJbnZhbGlkIE5BUy1JUHY2LUFkZHJlc3MgZnJvbSAlczolZCIsCisJCQkJICAgYWJ1ZiwgZnJvbV9wb3J0KTsKKwkJCWVycm9yID0gNDA3OworCQkJZ290byBmYWlsOworCQl9CisJCWF0dHJzLm5hc19pcHY2X2FkZHIgPSBidWY7CisJfQorI2VuZGlmIC8qIENPTkZJR19JUFY2ICovCisKKwlpZiAocmFkaXVzX21zZ19nZXRfYXR0cl9wdHIobXNnLCBSQURJVVNfQVRUUl9OQVNfSURFTlRJRklFUiwKKwkJCQkgICAgJmJ1ZiwgJmxlbiwgTlVMTCkgPT0gMCkgeworCQlhdHRycy5uYXNfaWRlbnRpZmllciA9IGJ1ZjsKKwkJYXR0cnMubmFzX2lkZW50aWZpZXJfbGVuID0gbGVuOworCX0KKwogCWlmIChyYWRpdXNfbXNnX2dldF9hdHRyX3B0cihtc2csIFJBRElVU19BVFRSX0NBTExJTkdfU1RBVElPTl9JRCwKIAkJCQkgICAgJmJ1ZiwgJmxlbiwgTlVMTCkgPT0gMCkgewogCQlpZiAobGVuID49IHNpemVvZih0bXApKQpAQCAtMjAwLDcgKzIzMiw4IEBACiAJCQkJICAodTggKikgJnZhbCwgNCk7CiAJaWYgKHJlcyA9PSA0KSB7CiAJCXUzMiB0aW1lc3RhbXAgPSBudG9obCh2YWwpOwotCQlpZiAoYWJzKG5vdy5zZWMgLSB0aW1lc3RhbXApID4gZGFzLT50aW1lX3dpbmRvdykgeworCQlpZiAoKHVuc2lnbmVkIGludCkgYWJzKG5vdy5zZWMgLSB0aW1lc3RhbXApID4KKwkJICAgIGRhcy0+dGltZV93aW5kb3cpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiREFTOiBVbmFjY2VwdGFibGUgIgogCQkJCSAgICJFdmVudC1UaW1lc3RhbXAgKCV1OyBsb2NhbCB0aW1lICV1KSBpbiAiCiAJCQkJICAgInBhY2tldCBmcm9tICVzOiVkIC0gZHJvcCIsCkBAIC0yODQsNyArMzE3LDcgQEAKIAogCXMgPSBzb2NrZXQoUEZfSU5FVCwgU09DS19ER1JBTSwgMCk7CiAJaWYgKHMgPCAwKSB7Ci0JCXBlcnJvcigic29ja2V0Iik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSQURJVVMgREFTOiBzb2NrZXQ6ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKIAkJcmV0dXJuIC0xOwogCX0KIApAQCAtMjkyLDcgKzMyNSw3IEBACiAJYWRkci5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKIAlhZGRyLnNpbl9wb3J0ID0gaHRvbnMocG9ydCk7CiAJaWYgKGJpbmQocywgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApIHsKLQkJcGVycm9yKCJiaW5kIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSQURJVVMgREFTOiBiaW5kOiAlcyIsIHN0cmVycm9yKGVycm5vKSk7CiAJCWNsb3NlKHMpOwogCQlyZXR1cm4gLTE7CiAJfQpkaWZmIC0tZ2l0IGEvc3JjL3JhZGl1cy9yYWRpdXNfZGFzLmggYi9zcmMvcmFkaXVzL3JhZGl1c19kYXMuaAppbmRleCA3MzhiMThiLi5lM2VkNTQwIDEwMDY0NAotLS0gYS9zcmMvcmFkaXVzL3JhZGl1c19kYXMuaAorKysgYi9zcmMvcmFkaXVzL3JhZGl1c19kYXMuaApAQCAtMTgsNiArMTgsMTMgQEAKIH07CiAKIHN0cnVjdCByYWRpdXNfZGFzX2F0dHJzIHsKKwkvKiBOQVMgaWRlbnRpZmljYXRpb24gYXR0cmlidXRlcyAqLworCWNvbnN0IHU4ICpuYXNfaXBfYWRkcjsKKwljb25zdCB1OCAqbmFzX2lkZW50aWZpZXI7CisJc2l6ZV90IG5hc19pZGVudGlmaWVyX2xlbjsKKwljb25zdCB1OCAqbmFzX2lwdjZfYWRkcjsKKworCS8qIFNlc3Npb24gaWRlbnRpZmljYXRpb24gYXR0cmlidXRlcyAqLwogCWNvbnN0IHU4ICpzdGFfYWRkcjsKIAljb25zdCB1OCAqdXNlcl9uYW1lOwogCXNpemVfdCB1c2VyX25hbWVfbGVuOwpkaWZmIC0tZ2l0IGEvc3JjL3JhZGl1cy9yYWRpdXNfc2VydmVyLmMgYi9zcmMvcmFkaXVzL3JhZGl1c19zZXJ2ZXIuYwppbmRleCAwMTQ0YzlmLi4yNDM0OGEzIDEwMDY0NAotLS0gYS9zcmMvcmFkaXVzL3JhZGl1c19zZXJ2ZXIuYworKysgYi9zcmMvcmFkaXVzL3JhZGl1c19zZXJ2ZXIuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBSQURJVVMgYXV0aGVudGljYXRpb24gc2VydmVyCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSwgMjAxMSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5LCAyMDExLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTgsMTEgKzgsMTYgQEAKIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCiAjaW5jbHVkZSA8bmV0L2lmLmg+CisjaWZkZWYgQ09ORklHX1NRTElURQorI2luY2x1ZGUgPHNxbGl0ZTMuaD4KKyNlbmRpZiAvKiBDT05GSUdfU1FMSVRFICovCiAKICNpbmNsdWRlICJjb21tb24uaCIKICNpbmNsdWRlICJyYWRpdXMuaCIKICNpbmNsdWRlICJlbG9vcC5oIgogI2luY2x1ZGUgImVhcF9zZXJ2ZXIvZWFwLmgiCisjaW5jbHVkZSAiYXAvYXBfY29uZmlnLmgiCisjaW5jbHVkZSAiY3J5cHRvL3Rscy5oIgogI2luY2x1ZGUgInJhZGl1c19zZXJ2ZXIuaCIKIAogLyoqCkBAIC00OSw2ICs1NCwxMyBAQAogCXUzMiBiYWRfYXV0aGVudGljYXRvcnM7CiAJdTMyIHBhY2tldHNfZHJvcHBlZDsKIAl1MzIgdW5rbm93bl90eXBlczsKKworCXUzMiBhY2N0X3JlcXVlc3RzOworCXUzMiBpbnZhbGlkX2FjY3RfcmVxdWVzdHM7CisJdTMyIGFjY3RfcmVzcG9uc2VzOworCXUzMiBtYWxmb3JtZWRfYWNjdF9yZXF1ZXN0czsKKwl1MzIgYWNjdF9iYWRfYXV0aGVudGljYXRvcnM7CisJdTMyIHVua25vd25fYWNjdF90eXBlczsKIH07CiAKIC8qKgpAQCAtNjEsNiArNzMsOCBAQAogCXVuc2lnbmVkIGludCBzZXNzX2lkOwogCXN0cnVjdCBlYXBfc20gKmVhcDsKIAlzdHJ1Y3QgZWFwX2VhcG9sX2ludGVyZmFjZSAqZWFwX2lmOworCWNoYXIgKnVzZXJuYW1lOyAvKiBmcm9tIFVzZXItTmFtZSBhdHRyaWJ1dGUgKi8KKwljaGFyICpuYXNfaXA7CiAKIAlzdHJ1Y3QgcmFkaXVzX21zZyAqbGFzdF9tc2c7CiAJY2hhciAqbGFzdF9mcm9tX2FkZHI7CkBAIC03MCw2ICs4NCwxMSBAQAogCXU4IGxhc3RfaWRlbnRpZmllcjsKIAlzdHJ1Y3QgcmFkaXVzX21zZyAqbGFzdF9yZXBseTsKIAl1OCBsYXN0X2F1dGhlbnRpY2F0b3JbMTZdOworCisJdW5zaWduZWQgaW50IHJlbWVkaWF0aW9uOjE7CisJdW5zaWduZWQgaW50IG1hY2FjbDoxOworCisJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmFjY2VwdF9hdHRyOwogfTsKIAogLyoqCkBAIC05OSw2ICsxMTgsMTEgQEAKIAlpbnQgYXV0aF9zb2NrOwogCiAJLyoqCisJICogYWNjdF9zb2NrIC0gU29ja2V0IGZvciBSQURJVVMgYWNjb3VudGluZyBtZXNzYWdlcworCSAqLworCWludCBhY2N0X3NvY2s7CisKKwkvKioKIAkgKiBjbGllbnRzIC0gTGlzdCBvZiBhdXRob3JpemVkIFJBRElVUyBjbGllbnRzCiAJICovCiAJc3RydWN0IHJhZGl1c19jbGllbnQgKmNsaWVudHM7CkBAIC0yNDQsNyArMjY4LDcgQEAKIAkvKioKIAkgKiBzdGFydF90aW1lIC0gVGltZXN0YW1wIG9mIHNlcnZlciBzdGFydAogCSAqLwotCXN0cnVjdCBvc190aW1lIHN0YXJ0X3RpbWU7CisJc3RydWN0IG9zX3JlbHRpbWUgc3RhcnRfdGltZTsKIAogCS8qKgogCSAqIGNvdW50ZXJzIC0gU3RhdGlzdGljcyBjb3VudGVycyBmb3Igc2VydmVyIG9wZXJhdGlvbnMKQEAgLTI5NSwxMSArMzE5LDE2IEBACiAjaWZkZWYgQ09ORklHX1JBRElVU19URVNUCiAJY2hhciAqZHVtcF9tc2tfZmlsZTsKICNlbmRpZiAvKiBDT05GSUdfUkFESVVTX1RFU1QgKi8KKworCWNoYXIgKnN1YnNjcl9yZW1lZGlhdGlvbl91cmw7CisJdTggc3Vic2NyX3JlbWVkaWF0aW9uX21ldGhvZDsKKworI2lmZGVmIENPTkZJR19TUUxJVEUKKwlzcWxpdGUzICpkYjsKKyNlbmRpZiAvKiBDT05GSUdfU1FMSVRFICovCiB9OwogCiAKLWV4dGVybiBpbnQgd3BhX2RlYnVnX2xldmVsOwotCiAjZGVmaW5lIFJBRElVU19ERUJVRyhhcmdzLi4uKSBcCiB3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJBRElVUyBTUlY6ICIgYXJncykKICNkZWZpbmUgUkFESVVTX0VSUk9SKGFyZ3MuLi4pIFwKQEAgLTMxNCw2ICszNDMsNTIgQEAKIHN0YXRpYyB2b2lkIHJhZGl1c19zZXJ2ZXJfc2Vzc2lvbl9yZW1vdmVfdGltZW91dCh2b2lkICplbG9vcF9jdHgsCiAJCQkJCQkgdm9pZCAqdGltZW91dF9jdHgpOwogCit2b2lkIHNydl9sb2coc3RydWN0IHJhZGl1c19zZXNzaW9uICpzZXNzLCBjb25zdCBjaGFyICpmbXQsIC4uLikKK1BSSU5URl9GT1JNQVQoMiwgMyk7CisKK3ZvaWQgc3J2X2xvZyhzdHJ1Y3QgcmFkaXVzX3Nlc3Npb24gKnNlc3MsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQoreworCXZhX2xpc3QgYXA7CisJY2hhciAqYnVmOworCWludCBidWZsZW47CisKKwl2YV9zdGFydChhcCwgZm10KTsKKwlidWZsZW4gPSB2c25wcmludGYoTlVMTCwgMCwgZm10LCBhcCkgKyAxOworCXZhX2VuZChhcCk7CisKKwlidWYgPSBvc19tYWxsb2MoYnVmbGVuKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybjsKKwl2YV9zdGFydChhcCwgZm10KTsKKwl2c25wcmludGYoYnVmLCBidWZsZW4sIGZtdCwgYXApOworCXZhX2VuZChhcCk7CisKKwlSQURJVVNfREVCVUcoIlsweCV4ICVzXSAlcyIsIHNlc3MtPnNlc3NfaWQsIHNlc3MtPm5hc19pcCwgYnVmKTsKKworI2lmZGVmIENPTkZJR19TUUxJVEUKKwlpZiAoc2Vzcy0+c2VydmVyLT5kYikgeworCQljaGFyICpzcWw7CisJCXNxbCA9IHNxbGl0ZTNfbXByaW50ZigiSU5TRVJUIElOVE8gYXV0aGxvZyIKKwkJCQkgICAgICAiKHRpbWVzdGFtcCxzZXNzaW9uLG5hc19pcCx1c2VybmFtZSxub3RlKSIKKwkJCQkgICAgICAiIFZBTFVFUyAoIgorCQkJCSAgICAgICJzdHJmdGltZSgnJSVZLSUlbS0lJWQgJSVIOiUlTTolJWYnLCIKKwkJCQkgICAgICAiJ25vdycpLCV1LCVRLCVRLCVRKSIsCisJCQkJICAgICAgc2Vzcy0+c2Vzc19pZCwgc2Vzcy0+bmFzX2lwLAorCQkJCSAgICAgIHNlc3MtPnVzZXJuYW1lLCBidWYpOworCQlpZiAoc3FsKSB7CisJCQlpZiAoc3FsaXRlM19leGVjKHNlc3MtPnNlcnZlci0+ZGIsIHNxbCwgTlVMTCwgTlVMTCwKKwkJCQkJIE5VTEwpICE9IFNRTElURV9PSykgeworCQkJCVJBRElVU19FUlJPUigiRmFpbGVkIHRvIGFkZCBhdXRobG9nIGVudHJ5IGludG8gc3FsaXRlIGRhdGFiYXNlOiAlcyIsCisJCQkJCSAgICAgc3FsaXRlM19lcnJtc2coc2Vzcy0+c2VydmVyLT5kYikpOworCQkJfQorCQkJc3FsaXRlM19mcmVlKHNxbCk7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX1NRTElURSAqLworCisJb3NfZnJlZShidWYpOworfQorCiAKIHN0YXRpYyBzdHJ1Y3QgcmFkaXVzX2NsaWVudCAqCiByYWRpdXNfc2VydmVyX2dldF9jbGllbnQoc3RydWN0IHJhZGl1c19zZXJ2ZXJfZGF0YSAqZGF0YSwgc3RydWN0IGluX2FkZHIgKmFkZHIsCkBAIC0zNzksNiArNDU0LDggQEAKIAlyYWRpdXNfbXNnX2ZyZWUoc2Vzcy0+bGFzdF9tc2cpOwogCW9zX2ZyZWUoc2Vzcy0+bGFzdF9mcm9tX2FkZHIpOwogCXJhZGl1c19tc2dfZnJlZShzZXNzLT5sYXN0X3JlcGx5KTsKKwlvc19mcmVlKHNlc3MtPnVzZXJuYW1lKTsKKwlvc19mcmVlKHNlc3MtPm5hc19pcCk7CiAJb3NfZnJlZShzZXNzKTsKIAlkYXRhLT5udW1fc2Vzcy0tOwogfQpAQCAtNDU4LDQ3ICs1MzUsMTI1IEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKK3N0YXRpYyB2b2lkIHJhZGl1c19zZXJ2ZXJfdGVzdGluZ19vcHRpb25zX3RscyhzdHJ1Y3QgcmFkaXVzX3Nlc3Npb24gKnNlc3MsCisJCQkJCSAgICAgIGNvbnN0IGNoYXIgKnRscywKKwkJCQkJICAgICAgc3RydWN0IGVhcF9jb25maWcgKmVhcF9jb25mKQoreworCWludCB0ZXN0ID0gYXRvaSh0bHMpOworCisJc3dpdGNoICh0ZXN0KSB7CisJY2FzZSAxOgorCQlzcnZfbG9nKHNlc3MsICJUTFMgdGVzdCAtIGJyZWFrIFZlcmlmeURhdGEiKTsKKwkJZWFwX2NvbmYtPnRsc190ZXN0X2ZsYWdzID0gVExTX0JSRUFLX1ZFUklGWV9EQVRBOworCQlicmVhazsKKwljYXNlIDI6CisJCXNydl9sb2coc2VzcywgIlRMUyB0ZXN0IC0gYnJlYWsgU2VydmVyS2V5RXhjaGFuZ2UgU2VydmVyUGFyYW1zIGhhc2giKTsKKwkJZWFwX2NvbmYtPnRsc190ZXN0X2ZsYWdzID0gVExTX0JSRUFLX1NSVl9LRVlfWF9IQVNIOworCQlicmVhazsKKwljYXNlIDM6CisJCXNydl9sb2coc2VzcywgIlRMUyB0ZXN0IC0gYnJlYWsgU2VydmVyS2V5RXhjaGFuZ2UgU2VydmVyUGFyYW1zIFNpZ25hdHVyZSIpOworCQllYXBfY29uZi0+dGxzX3Rlc3RfZmxhZ3MgPSBUTFNfQlJFQUtfU1JWX0tFWV9YX1NJR05BVFVSRTsKKwkJYnJlYWs7CisJY2FzZSA0OgorCQlzcnZfbG9nKHNlc3MsICJUTFMgdGVzdCAtIFJTQS1ESEUgdXNpbmcgYSBzaG9ydCA1MTEtYml0IHByaW1lIik7CisJCWVhcF9jb25mLT50bHNfdGVzdF9mbGFncyA9IFRMU19ESEVfUFJJTUVfNTExQjsKKwkJYnJlYWs7CisJY2FzZSA1OgorCQlzcnZfbG9nKHNlc3MsICJUTFMgdGVzdCAtIFJTQS1ESEUgdXNpbmcgYSBzaG9ydCA3NjctYml0IHByaW1lIik7CisJCWVhcF9jb25mLT50bHNfdGVzdF9mbGFncyA9IFRMU19ESEVfUFJJTUVfNzY3QjsKKwkJYnJlYWs7CisJY2FzZSA2OgorCQlzcnZfbG9nKHNlc3MsICJUTFMgdGVzdCAtIFJTQS1ESEUgdXNpbmcgYSBib2d1cyAxNSBcInByaW1lXCIiKTsKKwkJZWFwX2NvbmYtPnRsc190ZXN0X2ZsYWdzID0gVExTX0RIRV9QUklNRV8xNTsKKwkJYnJlYWs7CisJY2FzZSA3OgorCQlzcnZfbG9nKHNlc3MsICJUTFMgdGVzdCAtIFJTQS1ESEUgdXNpbmcgYSBzaG9ydCA1OC1iaXQgcHJpbWUgaW4gbG9uZyBjb250YWluZXIiKTsKKwkJZWFwX2NvbmYtPnRsc190ZXN0X2ZsYWdzID0gVExTX0RIRV9QUklNRV81OEI7CisJCWJyZWFrOworCWNhc2UgODoKKwkJc3J2X2xvZyhzZXNzLCAiVExTIHRlc3QgLSBSU0EtREhFIHVzaW5nIGEgbm9uLXByaW1lIik7CisJCWVhcF9jb25mLT50bHNfdGVzdF9mbGFncyA9IFRMU19ESEVfTk9OX1BSSU1FOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlzcnZfbG9nKHNlc3MsICJVbnJlY29nbml6ZWQgVExTIHRlc3QiKTsKKwkJYnJlYWs7CisJfQorfQorI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKworc3RhdGljIHZvaWQgcmFkaXVzX3NlcnZlcl90ZXN0aW5nX29wdGlvbnMoc3RydWN0IHJhZGl1c19zZXNzaW9uICpzZXNzLAorCQkJCQkgIHN0cnVjdCBlYXBfY29uZmlnICplYXBfY29uZikKK3sKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJY29uc3QgY2hhciAqcG9zOworCisJcG9zID0gb3Nfc3Ryc3RyKHNlc3MtPnVzZXJuYW1lLCAiQHRlc3QtIik7CisJaWYgKHBvcyA9PSBOVUxMKQorCQlyZXR1cm47CisJcG9zICs9IDY7CisJaWYgKG9zX3N0cm5jbXAocG9zLCAidGxzLSIsIDQpID09IDApCisJCXJhZGl1c19zZXJ2ZXJfdGVzdGluZ19vcHRpb25zX3RscyhzZXNzLCBwb3MgKyA0LCBlYXBfY29uZik7CisJZWxzZQorCQlzcnZfbG9nKHNlc3MsICJVbnJlY29nbml6ZWQgdGVzdDogJXMiLCBwb3MpOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KK30KKworCiBzdGF0aWMgc3RydWN0IHJhZGl1c19zZXNzaW9uICoKIHJhZGl1c19zZXJ2ZXJfZ2V0X25ld19zZXNzaW9uKHN0cnVjdCByYWRpdXNfc2VydmVyX2RhdGEgKmRhdGEsCiAJCQkgICAgICBzdHJ1Y3QgcmFkaXVzX2NsaWVudCAqY2xpZW50LAotCQkJICAgICAgc3RydWN0IHJhZGl1c19tc2cgKm1zZykKKwkJCSAgICAgIHN0cnVjdCByYWRpdXNfbXNnICptc2csIGNvbnN0IGNoYXIgKmZyb21fYWRkcikKIHsKIAl1OCAqdXNlcjsKIAlzaXplX3QgdXNlcl9sZW47CiAJaW50IHJlczsKIAlzdHJ1Y3QgcmFkaXVzX3Nlc3Npb24gKnNlc3M7CiAJc3RydWN0IGVhcF9jb25maWcgZWFwX2NvbmY7CisJc3RydWN0IGVhcF91c2VyIHRtcDsKIAogCVJBRElVU19ERUJVRygiQ3JlYXRpbmcgYSBuZXcgc2Vzc2lvbiIpOwogCi0JdXNlciA9IG9zX21hbGxvYygyNTYpOwotCWlmICh1c2VyID09IE5VTEwpIHsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCXJlcyA9IHJhZGl1c19tc2dfZ2V0X2F0dHIobXNnLCBSQURJVVNfQVRUUl9VU0VSX05BTUUsIHVzZXIsIDI1Nik7Ci0JaWYgKHJlcyA8IDAgfHwgcmVzID4gMjU2KSB7CisJaWYgKHJhZGl1c19tc2dfZ2V0X2F0dHJfcHRyKG1zZywgUkFESVVTX0FUVFJfVVNFUl9OQU1FLCAmdXNlciwKKwkJCQkgICAgJnVzZXJfbGVuLCBOVUxMKSA8IDApIHsKIAkJUkFESVVTX0RFQlVHKCJDb3VsZCBub3QgZ2V0IFVzZXItTmFtZSIpOwotCQlvc19mcmVlKHVzZXIpOwogCQlyZXR1cm4gTlVMTDsKIAl9Ci0JdXNlcl9sZW4gPSByZXM7CiAJUkFESVVTX0RVTVBfQVNDSUkoIlVzZXItTmFtZSIsIHVzZXIsIHVzZXJfbGVuKTsKIAotCXJlcyA9IGRhdGEtPmdldF9lYXBfdXNlcihkYXRhLT5jb25mX2N0eCwgdXNlciwgdXNlcl9sZW4sIDAsIE5VTEwpOwotCW9zX2ZyZWUodXNlcik7CisJb3NfbWVtc2V0KCZ0bXAsIDAsIHNpemVvZih0bXApKTsKKwlyZXMgPSBkYXRhLT5nZXRfZWFwX3VzZXIoZGF0YS0+Y29uZl9jdHgsIHVzZXIsIHVzZXJfbGVuLCAwLCAmdG1wKTsKKwliaW5fY2xlYXJfZnJlZSh0bXAucGFzc3dvcmQsIHRtcC5wYXNzd29yZF9sZW4pOwogCi0JaWYgKHJlcyA9PSAwKSB7Ci0JCVJBRElVU19ERUJVRygiTWF0Y2hpbmcgdXNlciBlbnRyeSBmb3VuZCIpOwotCQlzZXNzID0gcmFkaXVzX3NlcnZlcl9uZXdfc2Vzc2lvbihkYXRhLCBjbGllbnQpOwotCQlpZiAoc2VzcyA9PSBOVUxMKSB7Ci0JCQlSQURJVVNfREVCVUcoIkZhaWxlZCB0byBjcmVhdGUgYSBuZXcgc2Vzc2lvbiIpOwotCQkJcmV0dXJuIE5VTEw7Ci0JCX0KLQl9IGVsc2UgeworCWlmIChyZXMgIT0gMCkgewogCQlSQURJVVNfREVCVUcoIlVzZXItTmFtZSBub3QgZm91bmQgZnJvbSB1c2VyIGRhdGFiYXNlIik7CiAJCXJldHVybiBOVUxMOwogCX0KIAorCVJBRElVU19ERUJVRygiTWF0Y2hpbmcgdXNlciBlbnRyeSBmb3VuZCIpOworCXNlc3MgPSByYWRpdXNfc2VydmVyX25ld19zZXNzaW9uKGRhdGEsIGNsaWVudCk7CisJaWYgKHNlc3MgPT0gTlVMTCkgeworCQlSQURJVVNfREVCVUcoIkZhaWxlZCB0byBjcmVhdGUgYSBuZXcgc2Vzc2lvbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJc2Vzcy0+YWNjZXB0X2F0dHIgPSB0bXAuYWNjZXB0X2F0dHI7CisJc2Vzcy0+bWFjYWNsID0gdG1wLm1hY2FjbDsKKworCXNlc3MtPnVzZXJuYW1lID0gb3NfbWFsbG9jKHVzZXJfbGVuICogNCArIDEpOworCWlmIChzZXNzLT51c2VybmFtZSA9PSBOVUxMKSB7CisJCXJhZGl1c19zZXJ2ZXJfc2Vzc2lvbl9mcmVlKGRhdGEsIHNlc3MpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJcHJpbnRmX2VuY29kZShzZXNzLT51c2VybmFtZSwgdXNlcl9sZW4gKiA0ICsgMSwgdXNlciwgdXNlcl9sZW4pOworCisJc2Vzcy0+bmFzX2lwID0gb3Nfc3RyZHVwKGZyb21fYWRkcik7CisJaWYgKHNlc3MtPm5hc19pcCA9PSBOVUxMKSB7CisJCXJhZGl1c19zZXJ2ZXJfc2Vzc2lvbl9mcmVlKGRhdGEsIHNlc3MpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlzcnZfbG9nKHNlc3MsICJOZXcgc2Vzc2lvbiBjcmVhdGVkIik7CisKIAlvc19tZW1zZXQoJmVhcF9jb25mLCAwLCBzaXplb2YoZWFwX2NvbmYpKTsKIAllYXBfY29uZi5zc2xfY3R4ID0gZGF0YS0+c3NsX2N0eDsKIAllYXBfY29uZi5tc2dfY3R4ID0gZGF0YS0+bXNnX2N0eDsKQEAgLTUxOCw2ICs2NzMsNyBAQAogCWVhcF9jb25mLnB3ZF9ncm91cCA9IGRhdGEtPnB3ZF9ncm91cDsKIAllYXBfY29uZi5zZXJ2ZXJfaWQgPSAoY29uc3QgdTggKikgZGF0YS0+c2VydmVyX2lkOwogCWVhcF9jb25mLnNlcnZlcl9pZF9sZW4gPSBvc19zdHJsZW4oZGF0YS0+c2VydmVyX2lkKTsKKwlyYWRpdXNfc2VydmVyX3Rlc3Rpbmdfb3B0aW9ucyhzZXNzLCAmZWFwX2NvbmYpOwogCXNlc3MtPmVhcCA9IGVhcF9zZXJ2ZXJfc21faW5pdChzZXNzLCAmcmFkaXVzX3NlcnZlcl9lYXBvbF9jYiwKIAkJCQkgICAgICAgJmVhcF9jb25mKTsKIAlpZiAoc2Vzcy0+ZWFwID09IE5VTEwpIHsKQEAgLTYxMiwxMiArNzY4LDEzNCBAQAogCQl9CiAJfQogCisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAoY29kZSA9PSBSQURJVVNfQ09ERV9BQ0NFU1NfQUNDRVBUICYmIHNlc3MtPnJlbWVkaWF0aW9uICYmCisJICAgIGRhdGEtPnN1YnNjcl9yZW1lZGlhdGlvbl91cmwpIHsKKwkJdTggKmJ1ZjsKKwkJc2l6ZV90IHVybF9sZW4gPSBvc19zdHJsZW4oZGF0YS0+c3Vic2NyX3JlbWVkaWF0aW9uX3VybCk7CisJCWJ1ZiA9IG9zX21hbGxvYygxICsgdXJsX2xlbik7CisJCWlmIChidWYgPT0gTlVMTCkgeworCQkJcmFkaXVzX21zZ19mcmVlKG1zZyk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlidWZbMF0gPSBkYXRhLT5zdWJzY3JfcmVtZWRpYXRpb25fbWV0aG9kOworCQlvc19tZW1jcHkoJmJ1ZlsxXSwgZGF0YS0+c3Vic2NyX3JlbWVkaWF0aW9uX3VybCwgdXJsX2xlbik7CisJCWlmICghcmFkaXVzX21zZ19hZGRfd2ZhKAorCQkJICAgIG1zZywgUkFESVVTX1ZFTkRPUl9BVFRSX1dGQV9IUzIwX1NVQlNDUl9SRU1FRElBVElPTiwKKwkJCSAgICBidWYsIDEgKyB1cmxfbGVuKSkgeworCQkJUkFESVVTX0RFQlVHKCJGYWlsZWQgdG8gYWRkIFdGQS1IUzIwLVN1YnNjclJlbSIpOworCQl9CisJCW9zX2ZyZWUoYnVmKTsKKwl9IGVsc2UgaWYgKGNvZGUgPT0gUkFESVVTX0NPREVfQUNDRVNTX0FDQ0VQVCAmJiBzZXNzLT5yZW1lZGlhdGlvbikgeworCQl1OCBidWZbMV07CisJCWlmICghcmFkaXVzX21zZ19hZGRfd2ZhKAorCQkJICAgIG1zZywgUkFESVVTX1ZFTkRPUl9BVFRSX1dGQV9IUzIwX1NVQlNDUl9SRU1FRElBVElPTiwKKwkJCSAgICBidWYsIDApKSB7CisJCQlSQURJVVNfREVCVUcoIkZhaWxlZCB0byBhZGQgV0ZBLUhTMjAtU3Vic2NyUmVtIik7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogCWlmIChyYWRpdXNfbXNnX2NvcHlfYXR0cihtc2csIHJlcXVlc3QsIFJBRElVU19BVFRSX1BST1hZX1NUQVRFKSA8IDApIHsKIAkJUkFESVVTX0RFQlVHKCJGYWlsZWQgdG8gY29weSBQcm94eS1TdGF0ZSBhdHRyaWJ1dGUocykiKTsKIAkJcmFkaXVzX21zZ19mcmVlKG1zZyk7CiAJCXJldHVybiBOVUxMOwogCX0KIAorCWlmIChjb2RlID09IFJBRElVU19DT0RFX0FDQ0VTU19BQ0NFUFQpIHsKKwkJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmF0dHI7CisJCWZvciAoYXR0ciA9IHNlc3MtPmFjY2VwdF9hdHRyOyBhdHRyOyBhdHRyID0gYXR0ci0+bmV4dCkgeworCQkJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgYXR0ci0+dHlwZSwKKwkJCQkJCSB3cGFidWZfaGVhZChhdHRyLT52YWwpLAorCQkJCQkJIHdwYWJ1Zl9sZW4oYXR0ci0+dmFsKSkpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCBhZGQgUkFESVVTIGF0dHJpYnV0ZSIpOworCQkJCXJhZGl1c19tc2dfZnJlZShtc2cpOworCQkJCXJldHVybiBOVUxMOworCQkJfQorCQl9CisJfQorCisJaWYgKHJhZGl1c19tc2dfZmluaXNoX3Nydihtc2csICh1OCAqKSBjbGllbnQtPnNoYXJlZF9zZWNyZXQsCisJCQkJICBjbGllbnQtPnNoYXJlZF9zZWNyZXRfbGVuLAorCQkJCSAgaGRyLT5hdXRoZW50aWNhdG9yKSA8IDApIHsKKwkJUkFESVVTX0RFQlVHKCJGYWlsZWQgdG8gYWRkIE1lc3NhZ2UtQXV0aGVudGljYXRvciBhdHRyaWJ1dGUiKTsKKwl9CisKKwlyZXR1cm4gbXNnOworfQorCisKK3N0YXRpYyBzdHJ1Y3QgcmFkaXVzX21zZyAqCityYWRpdXNfc2VydmVyX21hY2FjbChzdHJ1Y3QgcmFkaXVzX3NlcnZlcl9kYXRhICpkYXRhLAorCQkgICAgIHN0cnVjdCByYWRpdXNfY2xpZW50ICpjbGllbnQsCisJCSAgICAgc3RydWN0IHJhZGl1c19zZXNzaW9uICpzZXNzLAorCQkgICAgIHN0cnVjdCByYWRpdXNfbXNnICpyZXF1ZXN0KQoreworCXN0cnVjdCByYWRpdXNfbXNnICptc2c7CisJaW50IGNvZGU7CisJc3RydWN0IHJhZGl1c19oZHIgKmhkciA9IHJhZGl1c19tc2dfZ2V0X2hkcihyZXF1ZXN0KTsKKwl1OCAqcHc7CisJc2l6ZV90IHB3X2xlbjsKKworCWNvZGUgPSBSQURJVVNfQ09ERV9BQ0NFU1NfQUNDRVBUOworCisJaWYgKHJhZGl1c19tc2dfZ2V0X2F0dHJfcHRyKHJlcXVlc3QsIFJBRElVU19BVFRSX1VTRVJfUEFTU1dPUkQsICZwdywKKwkJCQkgICAgJnB3X2xlbiwgTlVMTCkgPCAwKSB7CisJCVJBRElVU19ERUJVRygiQ291bGQgbm90IGdldCBVc2VyLVBhc3N3b3JkIik7CisJCWNvZGUgPSBSQURJVVNfQ09ERV9BQ0NFU1NfUkVKRUNUOworCX0gZWxzZSB7CisJCWludCByZXM7CisJCXN0cnVjdCBlYXBfdXNlciB0bXA7CisKKwkJb3NfbWVtc2V0KCZ0bXAsIDAsIHNpemVvZih0bXApKTsKKwkJcmVzID0gZGF0YS0+Z2V0X2VhcF91c2VyKGRhdGEtPmNvbmZfY3R4LCAodTggKikgc2Vzcy0+dXNlcm5hbWUsCisJCQkJCSBvc19zdHJsZW4oc2Vzcy0+dXNlcm5hbWUpLCAwLCAmdG1wKTsKKwkJaWYgKHJlcyB8fCAhdG1wLm1hY2FjbCB8fCB0bXAucGFzc3dvcmQgPT0gTlVMTCkgeworCQkJUkFESVVTX0RFQlVHKCJObyBNQUMgQUNMIHVzZXIgZW50cnkiKTsKKwkJCWJpbl9jbGVhcl9mcmVlKHRtcC5wYXNzd29yZCwgdG1wLnBhc3N3b3JkX2xlbik7CisJCQljb2RlID0gUkFESVVTX0NPREVfQUNDRVNTX1JFSkVDVDsKKwkJfSBlbHNlIHsKKwkJCXU4IGJ1ZlsxMjhdOworCQkJcmVzID0gcmFkaXVzX3VzZXJfcGFzc3dvcmRfaGlkZSgKKwkJCQlyZXF1ZXN0LCB0bXAucGFzc3dvcmQsIHRtcC5wYXNzd29yZF9sZW4sCisJCQkJKHU4ICopIGNsaWVudC0+c2hhcmVkX3NlY3JldCwKKwkJCQljbGllbnQtPnNoYXJlZF9zZWNyZXRfbGVuLAorCQkJCWJ1Ziwgc2l6ZW9mKGJ1ZikpOworCQkJYmluX2NsZWFyX2ZyZWUodG1wLnBhc3N3b3JkLCB0bXAucGFzc3dvcmRfbGVuKTsKKworCQkJaWYgKHJlcyA8IDAgfHwgcHdfbGVuICE9IChzaXplX3QpIHJlcyB8fAorCQkJICAgIG9zX21lbWNtcF9jb25zdChwdywgYnVmLCByZXMpICE9IDApIHsKKwkJCQlSQURJVVNfREVCVUcoIkluY29ycmVjdCBVc2VyLVBhc3N3b3JkIik7CisJCQkJY29kZSA9IFJBRElVU19DT0RFX0FDQ0VTU19SRUpFQ1Q7CisJCQl9CisJCX0KKwl9CisKKwltc2cgPSByYWRpdXNfbXNnX25ldyhjb2RlLCBoZHItPmlkZW50aWZpZXIpOworCWlmIChtc2cgPT0gTlVMTCkgeworCQlSQURJVVNfREVCVUcoIkZhaWxlZCB0byBhbGxvY2F0ZSByZXBseSBtZXNzYWdlIik7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmIChyYWRpdXNfbXNnX2NvcHlfYXR0cihtc2csIHJlcXVlc3QsIFJBRElVU19BVFRSX1BST1hZX1NUQVRFKSA8IDApIHsKKwkJUkFESVVTX0RFQlVHKCJGYWlsZWQgdG8gY29weSBQcm94eS1TdGF0ZSBhdHRyaWJ1dGUocykiKTsKKwkJcmFkaXVzX21zZ19mcmVlKG1zZyk7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmIChjb2RlID09IFJBRElVU19DT0RFX0FDQ0VTU19BQ0NFUFQpIHsKKwkJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmF0dHI7CisJCWZvciAoYXR0ciA9IHNlc3MtPmFjY2VwdF9hdHRyOyBhdHRyOyBhdHRyID0gYXR0ci0+bmV4dCkgeworCQkJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgYXR0ci0+dHlwZSwKKwkJCQkJCSB3cGFidWZfaGVhZChhdHRyLT52YWwpLAorCQkJCQkJIHdwYWJ1Zl9sZW4oYXR0ci0+dmFsKSkpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCBhZGQgUkFESVVTIGF0dHJpYnV0ZSIpOworCQkJCXJhZGl1c19tc2dfZnJlZShtc2cpOworCQkJCXJldHVybiBOVUxMOworCQkJfQorCQl9CisJfQorCiAJaWYgKHJhZGl1c19tc2dfZmluaXNoX3Nydihtc2csICh1OCAqKSBjbGllbnQtPnNoYXJlZF9zZWNyZXQsCiAJCQkJICBjbGllbnQtPnNoYXJlZF9zZWNyZXRfbGVuLAogCQkJCSAgaGRyLT5hdXRoZW50aWNhdG9yKSA8IDApIHsKQEAgLTY3OSw3ICs5NTcsNyBAQAogCWJ1ZiA9IHJhZGl1c19tc2dfZ2V0X2J1Zihtc2cpOwogCWlmIChzZW5kdG8oZGF0YS0+YXV0aF9zb2NrLCB3cGFidWZfaGVhZChidWYpLCB3cGFidWZfbGVuKGJ1ZiksIDAsCiAJCSAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgZnJvbSwgc2l6ZW9mKCpmcm9tKSkgPCAwKSB7Ci0JCXBlcnJvcigic2VuZHRvW1JBRElVUyBTUlZdIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJzZW5kdG9bUkFESVVTIFNSVl06ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKIAkJcmV0ID0gLTE7CiAJfQogCkBAIC03MjYsNyArMTAwNCw4IEBACiAJCQkJICAgICBmcm9tX2FkZHIsIGZyb21fcG9ydCk7CiAJCXJldHVybiAtMTsKIAl9IGVsc2UgewotCQlzZXNzID0gcmFkaXVzX3NlcnZlcl9nZXRfbmV3X3Nlc3Npb24oZGF0YSwgY2xpZW50LCBtc2cpOworCQlzZXNzID0gcmFkaXVzX3NlcnZlcl9nZXRfbmV3X3Nlc3Npb24oZGF0YSwgY2xpZW50LCBtc2csCisJCQkJCQkgICAgIGZyb21fYWRkcik7CiAJCWlmIChzZXNzID09IE5VTEwpIHsKIAkJCVJBRElVU19ERUJVRygiQ291bGQgbm90IGNyZWF0ZSBhIG5ldyBzZXNzaW9uIik7CiAJCQlyYWRpdXNfc2VydmVyX3JlamVjdChkYXRhLCBjbGllbnQsIG1zZywgZnJvbSwgZnJvbWxlbiwKQEAgLTc1MCw3ICsxMDI5LDggQEAKIAkJCQkgICAgIHdwYWJ1Zl9sZW4oYnVmKSwgMCwKIAkJCQkgICAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgZnJvbSwgZnJvbWxlbik7CiAJCQlpZiAocmVzIDwgMCkgewotCQkJCXBlcnJvcigic2VuZHRvW1JBRElVUyBTUlZdIik7CisJCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgInNlbmR0b1tSQURJVVMgU1JWXTogJXMiLAorCQkJCQkgICBzdHJlcnJvcihlcnJubykpOwogCQkJfQogCQkJcmV0dXJuIDA7CiAJCX0KQEAgLTc2MSw2ICsxMDQxLDEyIEBACiAJfQogCQkgICAgICAKIAllYXAgPSByYWRpdXNfbXNnX2dldF9lYXAobXNnKTsKKwlpZiAoZWFwID09IE5VTEwgJiYgc2Vzcy0+bWFjYWNsKSB7CisJCXJlcGx5ID0gcmFkaXVzX3NlcnZlcl9tYWNhY2woZGF0YSwgY2xpZW50LCBzZXNzLCBtc2cpOworCQlpZiAocmVwbHkgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJZ290byBzZW5kX3JlcGx5OworCX0KIAlpZiAoZWFwID09IE5VTEwpIHsKIAkJUkFESVVTX0RFQlVHKCJObyBFQVAtTWVzc2FnZSBpbiBSQURJVVMgcGFja2V0IGZyb20gJXMiLAogCQkJICAgICBmcm9tX2FkZHIpOwpAQCAtODExLDkgKzEwOTcsMTQgQEAKIAogCWlmIChzZXNzLT5lYXBfaWYtPmVhcFN1Y2Nlc3MgfHwgc2Vzcy0+ZWFwX2lmLT5lYXBGYWlsKQogCQlpc19jb21wbGV0ZSA9IDE7CisJaWYgKHNlc3MtPmVhcF9pZi0+ZWFwRmFpbCkKKwkJc3J2X2xvZyhzZXNzLCAiRUFQIGF1dGhlbnRpY2F0aW9uIGZhaWxlZCIpOworCWVsc2UgaWYgKHNlc3MtPmVhcF9pZi0+ZWFwU3VjY2VzcykKKwkJc3J2X2xvZyhzZXNzLCAiRUFQIGF1dGhlbnRpY2F0aW9uIHN1Y2NlZWRlZCIpOwogCiAJcmVwbHkgPSByYWRpdXNfc2VydmVyX2VuY2Fwc3VsYXRlX2VhcChkYXRhLCBjbGllbnQsIHNlc3MsIG1zZyk7CiAKK3NlbmRfcmVwbHk6CiAJaWYgKHJlcGx5KSB7CiAJCXN0cnVjdCB3cGFidWYgKmJ1ZjsKIAkJc3RydWN0IHJhZGl1c19oZHIgKmhkcjsKQEAgLTgyNSwxMCArMTExNiwxMiBAQAogCiAJCXN3aXRjaCAocmFkaXVzX21zZ19nZXRfaGRyKHJlcGx5KS0+Y29kZSkgewogCQljYXNlIFJBRElVU19DT0RFX0FDQ0VTU19BQ0NFUFQ6CisJCQlzcnZfbG9nKHNlc3MsICJTZW5kaW5nIEFjY2Vzcy1BY2NlcHQiKTsKIAkJCWRhdGEtPmNvdW50ZXJzLmFjY2Vzc19hY2NlcHRzKys7CiAJCQljbGllbnQtPmNvdW50ZXJzLmFjY2Vzc19hY2NlcHRzKys7CiAJCQlicmVhazsKIAkJY2FzZSBSQURJVVNfQ09ERV9BQ0NFU1NfUkVKRUNUOgorCQkJc3J2X2xvZyhzZXNzLCAiU2VuZGluZyBBY2Nlc3MtUmVqZWN0Iik7CiAJCQlkYXRhLT5jb3VudGVycy5hY2Nlc3NfcmVqZWN0cysrOwogCQkJY2xpZW50LT5jb3VudGVycy5hY2Nlc3NfcmVqZWN0cysrOwogCQkJYnJlYWs7CkBAIC04NDIsNyArMTEzNSw4IEBACiAJCQkgICAgIHdwYWJ1Zl9sZW4oYnVmKSwgMCwKIAkJCSAgICAgKHN0cnVjdCBzb2NrYWRkciAqKSBmcm9tLCBmcm9tbGVuKTsKIAkJaWYgKHJlcyA8IDApIHsKLQkJCXBlcnJvcigic2VuZHRvW1JBRElVUyBTUlZdIik7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAic2VuZHRvW1JBRElVUyBTUlZdOiAlcyIsCisJCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJfQogCQlyYWRpdXNfbXNnX2ZyZWUoc2Vzcy0+bGFzdF9yZXBseSk7CiAJCXNlc3MtPmxhc3RfcmVwbHkgPSByZXBseTsKQEAgLTg5Nyw3ICsxMTkxLDggQEAKIAlsZW4gPSByZWN2ZnJvbShzb2NrLCBidWYsIFJBRElVU19NQVhfTVNHX0xFTiwgMCwKIAkJICAgICAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20uc3MsICZmcm9tbGVuKTsKIAlpZiAobGVuIDwgMCkgewotCQlwZXJyb3IoInJlY3Zmcm9tW3JhZGl1c19zZXJ2ZXJdIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJyZWN2ZnJvbVtyYWRpdXNfc2VydmVyXTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJZ290byBmYWlsOwogCX0KIApAQCAtOTc4LDYgKzEyNzMsMTQwIEBACiB9CiAKIAorc3RhdGljIHZvaWQgcmFkaXVzX3NlcnZlcl9yZWNlaXZlX2FjY3QoaW50IHNvY2ssIHZvaWQgKmVsb29wX2N0eCwKKwkJCQkgICAgICAgdm9pZCAqc29ja19jdHgpCit7CisJc3RydWN0IHJhZGl1c19zZXJ2ZXJfZGF0YSAqZGF0YSA9IGVsb29wX2N0eDsKKwl1OCAqYnVmID0gTlVMTDsKKwl1bmlvbiB7CisJCXN0cnVjdCBzb2NrYWRkcl9zdG9yYWdlIHNzOworCQlzdHJ1Y3Qgc29ja2FkZHJfaW4gc2luOworI2lmZGVmIENPTkZJR19JUFY2CisJCXN0cnVjdCBzb2NrYWRkcl9pbjYgc2luNjsKKyNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLworCX0gZnJvbTsKKwlzb2NrbGVuX3QgZnJvbWxlbjsKKwlpbnQgbGVuLCByZXM7CisJc3RydWN0IHJhZGl1c19jbGllbnQgKmNsaWVudCA9IE5VTEw7CisJc3RydWN0IHJhZGl1c19tc2cgKm1zZyA9IE5VTEwsICpyZXNwID0gTlVMTDsKKwljaGFyIGFidWZbNTBdOworCWludCBmcm9tX3BvcnQgPSAwOworCXN0cnVjdCByYWRpdXNfaGRyICpoZHI7CisJc3RydWN0IHdwYWJ1ZiAqcmJ1ZjsKKworCWJ1ZiA9IG9zX21hbGxvYyhSQURJVVNfTUFYX01TR19MRU4pOworCWlmIChidWYgPT0gTlVMTCkgeworCQlnb3RvIGZhaWw7CisJfQorCisJZnJvbWxlbiA9IHNpemVvZihmcm9tKTsKKwlsZW4gPSByZWN2ZnJvbShzb2NrLCBidWYsIFJBRElVU19NQVhfTVNHX0xFTiwgMCwKKwkJICAgICAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20uc3MsICZmcm9tbGVuKTsKKwlpZiAobGVuIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAicmVjdmZyb21bcmFkaXVzX3NlcnZlcl06ICVzIiwKKwkJCSAgIHN0cmVycm9yKGVycm5vKSk7CisJCWdvdG8gZmFpbDsKKwl9CisKKyNpZmRlZiBDT05GSUdfSVBWNgorCWlmIChkYXRhLT5pcHY2KSB7CisJCWlmIChpbmV0X250b3AoQUZfSU5FVDYsICZmcm9tLnNpbjYuc2luNl9hZGRyLCBhYnVmLAorCQkJICAgICAgc2l6ZW9mKGFidWYpKSA9PSBOVUxMKQorCQkJYWJ1ZlswXSA9ICdcMCc7CisJCWZyb21fcG9ydCA9IG50b2hzKGZyb20uc2luNi5zaW42X3BvcnQpOworCQlSQURJVVNfREVCVUcoIlJlY2VpdmVkICVkIGJ5dGVzIGZyb20gJXM6JWQiLAorCQkJICAgICBsZW4sIGFidWYsIGZyb21fcG9ydCk7CisKKwkJY2xpZW50ID0gcmFkaXVzX3NlcnZlcl9nZXRfY2xpZW50KGRhdGEsCisJCQkJCQkgIChzdHJ1Y3QgaW5fYWRkciAqKQorCQkJCQkJICAmZnJvbS5zaW42LnNpbjZfYWRkciwgMSk7CisJfQorI2VuZGlmIC8qIENPTkZJR19JUFY2ICovCisKKwlpZiAoIWRhdGEtPmlwdjYpIHsKKwkJb3Nfc3RybGNweShhYnVmLCBpbmV0X250b2EoZnJvbS5zaW4uc2luX2FkZHIpLCBzaXplb2YoYWJ1ZikpOworCQlmcm9tX3BvcnQgPSBudG9ocyhmcm9tLnNpbi5zaW5fcG9ydCk7CisJCVJBRElVU19ERUJVRygiUmVjZWl2ZWQgJWQgYnl0ZXMgZnJvbSAlczolZCIsCisJCQkgICAgIGxlbiwgYWJ1ZiwgZnJvbV9wb3J0KTsKKworCQljbGllbnQgPSByYWRpdXNfc2VydmVyX2dldF9jbGllbnQoZGF0YSwgJmZyb20uc2luLnNpbl9hZGRyLCAwKTsKKwl9CisKKwlSQURJVVNfRFVNUCgiUmVjZWl2ZWQgZGF0YSIsIGJ1ZiwgbGVuKTsKKworCWlmIChjbGllbnQgPT0gTlVMTCkgeworCQlSQURJVVNfREVCVUcoIlVua25vd24gY2xpZW50ICVzIC0gcGFja2V0IGlnbm9yZWQiLCBhYnVmKTsKKwkJZGF0YS0+Y291bnRlcnMuaW52YWxpZF9hY2N0X3JlcXVlc3RzKys7CisJCWdvdG8gZmFpbDsKKwl9CisKKwltc2cgPSByYWRpdXNfbXNnX3BhcnNlKGJ1ZiwgbGVuKTsKKwlpZiAobXNnID09IE5VTEwpIHsKKwkJUkFESVVTX0RFQlVHKCJQYXJzaW5nIGluY29taW5nIFJBRElVUyBmcmFtZSBmYWlsZWQiKTsKKwkJZGF0YS0+Y291bnRlcnMubWFsZm9ybWVkX2FjY3RfcmVxdWVzdHMrKzsKKwkJY2xpZW50LT5jb3VudGVycy5tYWxmb3JtZWRfYWNjdF9yZXF1ZXN0cysrOworCQlnb3RvIGZhaWw7CisJfQorCisJb3NfZnJlZShidWYpOworCWJ1ZiA9IE5VTEw7CisKKwlpZiAod3BhX2RlYnVnX2xldmVsIDw9IE1TR19NU0dEVU1QKSB7CisJCXJhZGl1c19tc2dfZHVtcChtc2cpOworCX0KKworCWlmIChyYWRpdXNfbXNnX2dldF9oZHIobXNnKS0+Y29kZSAhPSBSQURJVVNfQ09ERV9BQ0NPVU5USU5HX1JFUVVFU1QpIHsKKwkJUkFESVVTX0RFQlVHKCJVbmV4cGVjdGVkIFJBRElVUyBjb2RlICVkIiwKKwkJCSAgICAgcmFkaXVzX21zZ19nZXRfaGRyKG1zZyktPmNvZGUpOworCQlkYXRhLT5jb3VudGVycy51bmtub3duX2FjY3RfdHlwZXMrKzsKKwkJY2xpZW50LT5jb3VudGVycy51bmtub3duX2FjY3RfdHlwZXMrKzsKKwkJZ290byBmYWlsOworCX0KKworCWRhdGEtPmNvdW50ZXJzLmFjY3RfcmVxdWVzdHMrKzsKKwljbGllbnQtPmNvdW50ZXJzLmFjY3RfcmVxdWVzdHMrKzsKKworCWlmIChyYWRpdXNfbXNnX3ZlcmlmeV9hY2N0X3JlcShtc2csICh1OCAqKSBjbGllbnQtPnNoYXJlZF9zZWNyZXQsCisJCQkJICAgICAgIGNsaWVudC0+c2hhcmVkX3NlY3JldF9sZW4pKSB7CisJCVJBRElVU19ERUJVRygiSW52YWxpZCBBdXRoZW50aWNhdG9yIGZyb20gJXMiLCBhYnVmKTsKKwkJZGF0YS0+Y291bnRlcnMuYWNjdF9iYWRfYXV0aGVudGljYXRvcnMrKzsKKwkJY2xpZW50LT5jb3VudGVycy5hY2N0X2JhZF9hdXRoZW50aWNhdG9ycysrOworCQlnb3RvIGZhaWw7CisJfQorCisJLyogVE9ETzogV3JpdGUgYWNjb3VudGluZyBpbmZvcm1hdGlvbiB0byBhIGZpbGUgb3IgZGF0YWJhc2UgKi8KKworCWhkciA9IHJhZGl1c19tc2dfZ2V0X2hkcihtc2cpOworCisJcmVzcCA9IHJhZGl1c19tc2dfbmV3KFJBRElVU19DT0RFX0FDQ09VTlRJTkdfUkVTUE9OU0UsIGhkci0+aWRlbnRpZmllcik7CisJaWYgKHJlc3AgPT0gTlVMTCkKKwkJZ290byBmYWlsOworCisJcmFkaXVzX21zZ19maW5pc2hfYWNjdF9yZXNwKHJlc3AsICh1OCAqKSBjbGllbnQtPnNoYXJlZF9zZWNyZXQsCisJCQkJICAgIGNsaWVudC0+c2hhcmVkX3NlY3JldF9sZW4sCisJCQkJICAgIGhkci0+YXV0aGVudGljYXRvcik7CisKKwlSQURJVVNfREVCVUcoIlJlcGx5IHRvICVzOiVkIiwgYWJ1ZiwgZnJvbV9wb3J0KTsKKwlpZiAod3BhX2RlYnVnX2xldmVsIDw9IE1TR19NU0dEVU1QKSB7CisJCXJhZGl1c19tc2dfZHVtcChyZXNwKTsKKwl9CisJcmJ1ZiA9IHJhZGl1c19tc2dfZ2V0X2J1ZihyZXNwKTsKKwlkYXRhLT5jb3VudGVycy5hY2N0X3Jlc3BvbnNlcysrOworCWNsaWVudC0+Y291bnRlcnMuYWNjdF9yZXNwb25zZXMrKzsKKwlyZXMgPSBzZW5kdG8oZGF0YS0+YWNjdF9zb2NrLCB3cGFidWZfaGVhZChyYnVmKSwgd3BhYnVmX2xlbihyYnVmKSwgMCwKKwkJICAgICAoc3RydWN0IHNvY2thZGRyICopICZmcm9tLnNzLCBmcm9tbGVuKTsKKwlpZiAocmVzIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAic2VuZHRvW1JBRElVUyBTUlZdOiAlcyIsCisJCQkgICBzdHJlcnJvcihlcnJubykpOworCX0KKworZmFpbDoKKwlyYWRpdXNfbXNnX2ZyZWUocmVzcCk7CisJcmFkaXVzX21zZ19mcmVlKG1zZyk7CisJb3NfZnJlZShidWYpOworfQorCisKIHN0YXRpYyBpbnQgcmFkaXVzX3NlcnZlcl9kaXNhYmxlX3BtdHVfZGlzY292ZXJ5KGludCBzKQogewogCWludCByID0gLTE7CkBAIC0xMDAxLDcgKzE0MzAsNyBAQAogCiAJcyA9IHNvY2tldChQRl9JTkVULCBTT0NLX0RHUkFNLCAwKTsKIAlpZiAocyA8IDApIHsKLQkJcGVycm9yKCJzb2NrZXQiKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlJBRElVUzogc29ja2V0OiAlcyIsIHN0cmVycm9yKGVycm5vKSk7CiAJCXJldHVybiAtMTsKIAl9CiAKQEAgLTEwMTEsNyArMTQ0MCw3IEBACiAJYWRkci5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKIAlhZGRyLnNpbl9wb3J0ID0gaHRvbnMocG9ydCk7CiAJaWYgKGJpbmQocywgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApIHsKLQkJcGVycm9yKCJiaW5kIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSQURJVVM6IGJpbmQ6ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKIAkJY2xvc2Uocyk7CiAJCXJldHVybiAtMTsKIAl9CkBAIC0xMDI4LDcgKzE0NTcsOCBAQAogCiAJcyA9IHNvY2tldChQRl9JTkVUNiwgU09DS19ER1JBTSwgMCk7CiAJaWYgKHMgPCAwKSB7Ci0JCXBlcnJvcigic29ja2V0W0lQdjZdIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSQURJVVM6IHNvY2tldFtJUHY2XTogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKIAkJcmV0dXJuIC0xOwogCX0KIApAQCAtMTAzNyw3ICsxNDY3LDcgQEAKIAlvc19tZW1jcHkoJmFkZHIuc2luNl9hZGRyLCAmaW42YWRkcl9hbnksIHNpemVvZihpbjZhZGRyX2FueSkpOwogCWFkZHIuc2luNl9wb3J0ID0gaHRvbnMocG9ydCk7CiAJaWYgKGJpbmQocywgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApIHsKLQkJcGVycm9yKCJiaW5kIik7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJSQURJVVM6IGJpbmQ6ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKIAkJY2xvc2Uocyk7CiAJCXJldHVybiAtMTsKIAl9CkBAIC0xMTkwLDggKzE2MjAsOCBAQAogCQkJYnJlYWs7CiAJCX0KIAkJZW50cnktPnNoYXJlZF9zZWNyZXRfbGVuID0gb3Nfc3RybGVuKGVudHJ5LT5zaGFyZWRfc2VjcmV0KTsKLQkJZW50cnktPmFkZHIuc19hZGRyID0gYWRkci5zX2FkZHI7CiAJCWlmICghaXB2NikgeworCQkJZW50cnktPmFkZHIuc19hZGRyID0gYWRkci5zX2FkZHI7CiAJCQl2YWwgPSAwOwogCQkJZm9yIChpID0gMDsgaSA8IG1hc2s7IGkrKykKIAkJCQl2YWwgfD0gMSA8PCAoMzEgLSBpKTsKQEAgLTEyNDgsOCArMTY3OCw3IEBACiAKICNpZm5kZWYgQ09ORklHX0lQVjYKIAlpZiAoY29uZi0+aXB2NikgewotCQlmcHJpbnRmKHN0ZGVyciwgIlJBRElVUyBzZXJ2ZXIgY29tcGlsZWQgd2l0aG91dCBJUHY2ICIKLQkJCSJzdXBwb3J0LlxuIik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUkFESVVTIHNlcnZlciBjb21waWxlZCB3aXRob3V0IElQdjYgc3VwcG9ydCIpOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lQVjYgKi8KQEAgLTEyNTgsNyArMTY4Nyw3IEBACiAJaWYgKGRhdGEgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAKLQlvc19nZXRfdGltZSgmZGF0YS0+c3RhcnRfdGltZSk7CisJb3NfZ2V0X3JlbHRpbWUoJmRhdGEtPnN0YXJ0X3RpbWUpOwogCWRhdGEtPmNvbmZfY3R4ID0gY29uZi0+Y29uZl9jdHg7CiAJZGF0YS0+ZWFwX3NpbV9kYl9wcml2ID0gY29uZi0+ZWFwX3NpbV9kYl9wcml2OwogCWRhdGEtPnNzbF9jdHggPSBjb25mLT5zc2xfY3R4OwpAQCAtMTI5Nyw2ICsxNzI2LDIzIEBACiAJCX0KIAl9CiAKKwlpZiAoY29uZi0+c3Vic2NyX3JlbWVkaWF0aW9uX3VybCkgeworCQlkYXRhLT5zdWJzY3JfcmVtZWRpYXRpb25fdXJsID0KKwkJCW9zX3N0cmR1cChjb25mLT5zdWJzY3JfcmVtZWRpYXRpb25fdXJsKTsKKwl9CisJZGF0YS0+c3Vic2NyX3JlbWVkaWF0aW9uX21ldGhvZCA9IGNvbmYtPnN1YnNjcl9yZW1lZGlhdGlvbl9tZXRob2Q7CisKKyNpZmRlZiBDT05GSUdfU1FMSVRFCisJaWYgKGNvbmYtPnNxbGl0ZV9maWxlKSB7CisJCWlmIChzcWxpdGUzX29wZW4oY29uZi0+c3FsaXRlX2ZpbGUsICZkYXRhLT5kYikpIHsKKwkJCVJBRElVU19FUlJPUigiQ291bGQgbm90IG9wZW4gU1FMaXRlIGZpbGUgJyVzJyIsCisJCQkJICAgICBjb25mLT5zcWxpdGVfZmlsZSk7CisJCQlyYWRpdXNfc2VydmVyX2RlaW5pdChkYXRhKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJfQorI2VuZGlmIC8qIENPTkZJR19TUUxJVEUgKi8KKwogI2lmZGVmIENPTkZJR19SQURJVVNfVEVTVAogCWlmIChjb25mLT5kdW1wX21za19maWxlKQogCQlkYXRhLT5kdW1wX21za19maWxlID0gb3Nfc3RyZHVwKGNvbmYtPmR1bXBfbXNrX2ZpbGUpOwpAQCAtMTMwNSw3ICsxNzUxLDcgQEAKIAlkYXRhLT5jbGllbnRzID0gcmFkaXVzX3NlcnZlcl9yZWFkX2NsaWVudHMoY29uZi0+Y2xpZW50X2ZpbGUsCiAJCQkJCQkgICBjb25mLT5pcHY2KTsKIAlpZiAoZGF0YS0+Y2xpZW50cyA9PSBOVUxMKSB7Ci0JCXByaW50ZigiTm8gUkFESVVTIGNsaWVudHMgY29uZmlndXJlZC5cbiIpOworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIk5vIFJBRElVUyBjbGllbnRzIGNvbmZpZ3VyZWQiKTsKIAkJcmFkaXVzX3NlcnZlcl9kZWluaXQoZGF0YSk7CiAJCXJldHVybiBOVUxMOwogCX0KQEAgLTEzMTcsOCArMTc2Myw3IEBACiAjZW5kaWYgLyogQ09ORklHX0lQVjYgKi8KIAlkYXRhLT5hdXRoX3NvY2sgPSByYWRpdXNfc2VydmVyX29wZW5fc29ja2V0KGNvbmYtPmF1dGhfcG9ydCk7CiAJaWYgKGRhdGEtPmF1dGhfc29jayA8IDApIHsKLQkJcHJpbnRmKCJGYWlsZWQgdG8gb3BlbiBVRFAgc29ja2V0IGZvciBSQURJVVMgYXV0aGVudGljYXRpb24gIgotCQkgICAgICAgInNlcnZlclxuIik7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiRmFpbGVkIHRvIG9wZW4gVURQIHNvY2tldCBmb3IgUkFESVVTIGF1dGhlbnRpY2F0aW9uIHNlcnZlciIpOwogCQlyYWRpdXNfc2VydmVyX2RlaW5pdChkYXRhKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtMTMyOSw2ICsxNzc0LDI5IEBACiAJCXJldHVybiBOVUxMOwogCX0KIAorCWlmIChjb25mLT5hY2N0X3BvcnQpIHsKKyNpZmRlZiBDT05GSUdfSVBWNgorCQlpZiAoY29uZi0+aXB2NikKKwkJCWRhdGEtPmFjY3Rfc29jayA9IHJhZGl1c19zZXJ2ZXJfb3Blbl9zb2NrZXQ2KAorCQkJCWNvbmYtPmFjY3RfcG9ydCk7CisJCWVsc2UKKyNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLworCQlkYXRhLT5hY2N0X3NvY2sgPSByYWRpdXNfc2VydmVyX29wZW5fc29ja2V0KGNvbmYtPmFjY3RfcG9ydCk7CisJCWlmIChkYXRhLT5hY2N0X3NvY2sgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBvcGVuIFVEUCBzb2NrZXQgZm9yIFJBRElVUyBhY2NvdW50aW5nIHNlcnZlciIpOworCQkJcmFkaXVzX3NlcnZlcl9kZWluaXQoZGF0YSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlpZiAoZWxvb3BfcmVnaXN0ZXJfcmVhZF9zb2NrKGRhdGEtPmFjY3Rfc29jaywKKwkJCQkJICAgICByYWRpdXNfc2VydmVyX3JlY2VpdmVfYWNjdCwKKwkJCQkJICAgICBkYXRhLCBOVUxMKSkgeworCQkJcmFkaXVzX3NlcnZlcl9kZWluaXQoZGF0YSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCX0gZWxzZSB7CisJCWRhdGEtPmFjY3Rfc29jayA9IC0xOworCX0KKwogCXJldHVybiBkYXRhOwogfQogCkBAIC0xMzQ3LDYgKzE4MTUsMTEgQEAKIAkJY2xvc2UoZGF0YS0+YXV0aF9zb2NrKTsKIAl9CiAKKwlpZiAoZGF0YS0+YWNjdF9zb2NrID49IDApIHsKKwkJZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2soZGF0YS0+YWNjdF9zb2NrKTsKKwkJY2xvc2UoZGF0YS0+YWNjdF9zb2NrKTsKKwl9CisKIAlyYWRpdXNfc2VydmVyX2ZyZWVfY2xpZW50cyhkYXRhLCBkYXRhLT5jbGllbnRzKTsKIAogCW9zX2ZyZWUoZGF0YS0+cGFjX29wYXF1ZV9lbmNyX2tleSk7CkBAIC0xMzU2LDYgKzE4MjksMTMgQEAKICNpZmRlZiBDT05GSUdfUkFESVVTX1RFU1QKIAlvc19mcmVlKGRhdGEtPmR1bXBfbXNrX2ZpbGUpOwogI2VuZGlmIC8qIENPTkZJR19SQURJVVNfVEVTVCAqLworCW9zX2ZyZWUoZGF0YS0+c3Vic2NyX3JlbWVkaWF0aW9uX3VybCk7CisKKyNpZmRlZiBDT05GSUdfU1FMSVRFCisJaWYgKGRhdGEtPmRiKQorCQlzcWxpdGUzX2Nsb3NlKGRhdGEtPmRiKTsKKyNlbmRpZiAvKiBDT05GSUdfU1FMSVRFICovCisKIAlvc19mcmVlKGRhdGEpOwogfQogCkBAIC0xMzczLDcgKzE4NTMsNyBAQAogCWludCByZXQsIHVwdGltZTsKIAl1bnNpZ25lZCBpbnQgaWR4OwogCWNoYXIgKmVuZCwgKnBvczsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCXN0cnVjdCByYWRpdXNfY2xpZW50ICpjbGk7CiAKIAkvKiBSRkMgMjYxOSAtIFJBRElVUyBBdXRoZW50aWNhdGlvbiBTZXJ2ZXIgTUlCICovCkBAIC0xMzg0LDcgKzE4NjQsNyBAQAogCXBvcyA9IGJ1ZjsKIAllbmQgPSBidWYgKyBidWZsZW47CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAl1cHRpbWUgPSAobm93LnNlYyAtIGRhdGEtPnN0YXJ0X3RpbWUuc2VjKSAqIDEwMCArCiAJCSgobm93LnVzZWMgLSBkYXRhLT5zdGFydF90aW1lLnVzZWMpIC8gMTAwMDApICUgMTAwOwogCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLApAQCAtMTQxMCw3ICsxODkwLDEzIEBACiAJCQkgICJyYWRpdXNBdXRoU2VydlRvdGFsTWFsZm9ybWVkQWNjZXNzUmVxdWVzdHM9JXVcbiIKIAkJCSAgInJhZGl1c0F1dGhTZXJ2VG90YWxCYWRBdXRoZW50aWNhdG9ycz0ldVxuIgogCQkJICAicmFkaXVzQXV0aFNlcnZUb3RhbFBhY2tldHNEcm9wcGVkPSV1XG4iCi0JCQkgICJyYWRpdXNBdXRoU2VydlRvdGFsVW5rbm93blR5cGVzPSV1XG4iLAorCQkJICAicmFkaXVzQXV0aFNlcnZUb3RhbFVua25vd25UeXBlcz0ldVxuIgorCQkJICAicmFkaXVzQWNjU2VydlRvdGFsUmVxdWVzdHM9JXVcbiIKKwkJCSAgInJhZGl1c0FjY1NlcnZUb3RhbEludmFsaWRSZXF1ZXN0cz0ldVxuIgorCQkJICAicmFkaXVzQWNjU2VydlRvdGFsUmVzcG9uc2VzPSV1XG4iCisJCQkgICJyYWRpdXNBY2NTZXJ2VG90YWxNYWxmb3JtZWRSZXF1ZXN0cz0ldVxuIgorCQkJICAicmFkaXVzQWNjU2VydlRvdGFsQmFkQXV0aGVudGljYXRvcnM9JXVcbiIKKwkJCSAgInJhZGl1c0FjY1NlcnZUb3RhbFVua25vd25UeXBlcz0ldVxuIiwKIAkJCSAgZGF0YS0+Y291bnRlcnMuYWNjZXNzX3JlcXVlc3RzLAogCQkJICBkYXRhLT5jb3VudGVycy5pbnZhbGlkX3JlcXVlc3RzLAogCQkJICBkYXRhLT5jb3VudGVycy5kdXBfYWNjZXNzX3JlcXVlc3RzLApAQCAtMTQyMCw3ICsxOTA2LDEzIEBACiAJCQkgIGRhdGEtPmNvdW50ZXJzLm1hbGZvcm1lZF9hY2Nlc3NfcmVxdWVzdHMsCiAJCQkgIGRhdGEtPmNvdW50ZXJzLmJhZF9hdXRoZW50aWNhdG9ycywKIAkJCSAgZGF0YS0+Y291bnRlcnMucGFja2V0c19kcm9wcGVkLAotCQkJICBkYXRhLT5jb3VudGVycy51bmtub3duX3R5cGVzKTsKKwkJCSAgZGF0YS0+Y291bnRlcnMudW5rbm93bl90eXBlcywKKwkJCSAgZGF0YS0+Y291bnRlcnMuYWNjdF9yZXF1ZXN0cywKKwkJCSAgZGF0YS0+Y291bnRlcnMuaW52YWxpZF9hY2N0X3JlcXVlc3RzLAorCQkJICBkYXRhLT5jb3VudGVycy5hY2N0X3Jlc3BvbnNlcywKKwkJCSAgZGF0YS0+Y291bnRlcnMubWFsZm9ybWVkX2FjY3RfcmVxdWVzdHMsCisJCQkgIGRhdGEtPmNvdW50ZXJzLmFjY3RfYmFkX2F1dGhlbnRpY2F0b3JzLAorCQkJICBkYXRhLT5jb3VudGVycy51bmtub3duX2FjY3RfdHlwZXMpOwogCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpIHsKIAkJKnBvcyA9ICdcMCc7CiAJCXJldHVybiBwb3MgLSBidWY7CkBAIC0xNDU1LDcgKzE5NDcsMTMgQEAKIAkJCQkgICJyYWRpdXNBdXRoU2Vydk1hbGZvcm1lZEFjY2Vzc1JlcXVlc3RzPSV1XG4iCiAJCQkJICAicmFkaXVzQXV0aFNlcnZCYWRBdXRoZW50aWNhdG9ycz0ldVxuIgogCQkJCSAgInJhZGl1c0F1dGhTZXJ2UGFja2V0c0Ryb3BwZWQ9JXVcbiIKLQkJCQkgICJyYWRpdXNBdXRoU2VydlVua25vd25UeXBlcz0ldVxuIiwKKwkJCQkgICJyYWRpdXNBdXRoU2VydlVua25vd25UeXBlcz0ldVxuIgorCQkJCSAgInJhZGl1c0FjY1NlcnZUb3RhbFJlcXVlc3RzPSV1XG4iCisJCQkJICAicmFkaXVzQWNjU2VydlRvdGFsSW52YWxpZFJlcXVlc3RzPSV1XG4iCisJCQkJICAicmFkaXVzQWNjU2VydlRvdGFsUmVzcG9uc2VzPSV1XG4iCisJCQkJICAicmFkaXVzQWNjU2VydlRvdGFsTWFsZm9ybWVkUmVxdWVzdHM9JXVcbiIKKwkJCQkgICJyYWRpdXNBY2NTZXJ2VG90YWxCYWRBdXRoZW50aWNhdG9ycz0ldVxuIgorCQkJCSAgInJhZGl1c0FjY1NlcnZUb3RhbFVua25vd25UeXBlcz0ldVxuIiwKIAkJCQkgIGlkeCwKIAkJCQkgIGFidWYsIG1idWYsCiAJCQkJICBjbGktPmNvdW50ZXJzLmFjY2Vzc19yZXF1ZXN0cywKQEAgLTE0NjYsNyArMTk2NCwxMyBAQAogCQkJCSAgY2xpLT5jb3VudGVycy5tYWxmb3JtZWRfYWNjZXNzX3JlcXVlc3RzLAogCQkJCSAgY2xpLT5jb3VudGVycy5iYWRfYXV0aGVudGljYXRvcnMsCiAJCQkJICBjbGktPmNvdW50ZXJzLnBhY2tldHNfZHJvcHBlZCwKLQkJCQkgIGNsaS0+Y291bnRlcnMudW5rbm93bl90eXBlcyk7CisJCQkJICBjbGktPmNvdW50ZXJzLnVua25vd25fdHlwZXMsCisJCQkJICBjbGktPmNvdW50ZXJzLmFjY3RfcmVxdWVzdHMsCisJCQkJICBjbGktPmNvdW50ZXJzLmludmFsaWRfYWNjdF9yZXF1ZXN0cywKKwkJCQkgIGNsaS0+Y291bnRlcnMuYWNjdF9yZXNwb25zZXMsCisJCQkJICBjbGktPmNvdW50ZXJzLm1hbGZvcm1lZF9hY2N0X3JlcXVlc3RzLAorCQkJCSAgY2xpLT5jb3VudGVycy5hY2N0X2JhZF9hdXRoZW50aWNhdG9ycywKKwkJCQkgIGNsaS0+Y291bnRlcnMudW5rbm93bl9hY2N0X3R5cGVzKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykgewogCQkJKnBvcyA9ICdcMCc7CiAJCQlyZXR1cm4gcG9zIC0gYnVmOwpAQCAtMTQ4NCw5ICsxOTg4LDE2IEBACiB7CiAJc3RydWN0IHJhZGl1c19zZXNzaW9uICpzZXNzID0gY3R4OwogCXN0cnVjdCByYWRpdXNfc2VydmVyX2RhdGEgKmRhdGEgPSBzZXNzLT5zZXJ2ZXI7CisJaW50IHJldDsKIAotCXJldHVybiBkYXRhLT5nZXRfZWFwX3VzZXIoZGF0YS0+Y29uZl9jdHgsIGlkZW50aXR5LCBpZGVudGl0eV9sZW4sCi0JCQkJICBwaGFzZTIsIHVzZXIpOworCXJldCA9IGRhdGEtPmdldF9lYXBfdXNlcihkYXRhLT5jb25mX2N0eCwgaWRlbnRpdHksIGlkZW50aXR5X2xlbiwKKwkJCQkgcGhhc2UyLCB1c2VyKTsKKwlpZiAocmV0ID09IDAgJiYgdXNlcikgeworCQlzZXNzLT5hY2NlcHRfYXR0ciA9IHVzZXItPmFjY2VwdF9hdHRyOworCQlzZXNzLT5yZW1lZGlhdGlvbiA9IHVzZXItPnJlbWVkaWF0aW9uOworCQlzZXNzLT5tYWNhY2wgPSB1c2VyLT5tYWNhY2w7CisJfQorCXJldHVybiByZXQ7CiB9CiAKIApAQCAtMTQ5OSwxMCArMjAxMCwxOCBAQAogfQogCiAKK3N0YXRpYyB2b2lkIHJhZGl1c19zZXJ2ZXJfbG9nX21zZyh2b2lkICpjdHgsIGNvbnN0IGNoYXIgKm1zZykKK3sKKwlzdHJ1Y3QgcmFkaXVzX3Nlc3Npb24gKnNlc3MgPSBjdHg7CisJc3J2X2xvZyhzZXNzLCAiRUFQOiAlcyIsIG1zZyk7Cit9CisKKwogc3RhdGljIHN0cnVjdCBlYXBvbF9jYWxsYmFja3MgcmFkaXVzX3NlcnZlcl9lYXBvbF9jYiA9CiB7CiAJLmdldF9lYXBfdXNlciA9IHJhZGl1c19zZXJ2ZXJfZ2V0X2VhcF91c2VyLAogCS5nZXRfZWFwX3JlcV9pZF90ZXh0ID0gcmFkaXVzX3NlcnZlcl9nZXRfZWFwX3JlcV9pZF90ZXh0LAorCS5sb2dfbXNnID0gcmFkaXVzX3NlcnZlcl9sb2dfbXNnLAogfTsKIAogCmRpZmYgLS1naXQgYS9zcmMvcmFkaXVzL3JhZGl1c19zZXJ2ZXIuaCBiL3NyYy9yYWRpdXMvcmFkaXVzX3NlcnZlci5oCmluZGV4IDI4NGJkNTkuLjQ2YWMzMTIgMTAwNjQ0Ci0tLSBhL3NyYy9yYWRpdXMvcmFkaXVzX3NlcnZlci5oCisrKyBiL3NyYy9yYWRpdXMvcmFkaXVzX3NlcnZlci5oCkBAIC0yMiw2ICsyMiwxMSBAQAogCWludCBhdXRoX3BvcnQ7CiAKIAkvKioKKwkgKiBhY2N0X3BvcnQgLSBVRFAgcG9ydCB0byBsaXN0ZW4gdG8gYXMgYW4gYWNjb3VudGluZyBzZXJ2ZXIKKwkgKi8KKwlpbnQgYWNjdF9wb3J0OworCisJLyoqCiAJICogY2xpZW50X2ZpbGUgLSBSQURJVVMgY2xpZW50IGNvbmZpZ3VyYXRpb24gZmlsZQogCSAqCiAJICogVGhpcyBmaWxlIGNvbnRhaW5zIHRoZSBSQURJVVMgY2xpZW50cyBhbmQgdGhlIHNoYXJlZCBzZWNyZXQgdG8gYmUKQEAgLTM1LDYgKzQwLDExIEBACiAJY2hhciAqY2xpZW50X2ZpbGU7CiAKIAkvKioKKwkgKiBzcWxpdGVfZmlsZSAtIFNRTGl0ZSBkYXRhYmFzZSBmb3Igc3RvcmluZyBkZWJ1ZyBsb2cgaW5mb3JtYXRpb24KKwkgKi8KKwljb25zdCBjaGFyICpzcWxpdGVfZmlsZTsKKworCS8qKgogCSAqIGNvbmZfY3R4IC0gQ29udGV4dCBwb2ludGVyIGZvciBjYWxsYmFja3MKIAkgKgogCSAqIFRoaXMgaXMgdXNlZCBhcyB0aGUgY3R4IGFyZ3VtZW50IGluIGdldF9lYXBfdXNlcigpIGNhbGxzLgpAQCAtMjA0LDYgKzIxNCw5IEBACiAjaWZkZWYgQ09ORklHX1JBRElVU19URVNUCiAJY29uc3QgY2hhciAqZHVtcF9tc2tfZmlsZTsKICNlbmRpZiAvKiBDT05GSUdfUkFESVVTX1RFU1QgKi8KKworCWNoYXIgKnN1YnNjcl9yZW1lZGlhdGlvbl91cmw7CisJdTggc3Vic2NyX3JlbWVkaWF0aW9uX21ldGhvZDsKIH07CiAKIApkaWZmIC0tZ2l0IGEvc3JjL3Jzbl9zdXBwL01ha2VmaWxlIGIvc3JjL3Jzbl9zdXBwL01ha2VmaWxlCmluZGV4IDljNDE5NjIuLmFkZmQzZGYgMTAwNjQ0Ci0tLSBhL3NyYy9yc25fc3VwcC9NYWtlZmlsZQorKysgYi9zcmMvcnNuX3N1cHAvTWFrZWZpbGUKQEAgLTIsNyArMiw3IEBACiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgogCiBjbGVhbjoKLQlybSAtZiAqfiAqLm8gKi5kCisJcm0gLWYgKn4gKi5vICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgogCiBpbnN0YWxsOgogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KZGlmZiAtLWdpdCBhL3NyYy9yc25fc3VwcC9wZWVya2V5LmMgYi9zcmMvcnNuX3N1cHAvcGVlcmtleS5jCmluZGV4IDc4OWFjMjUuLmFhYjhiN2UgMTAwNjQ0Ci0tLSBhL3NyYy9yc25fc3VwcC9wZWVya2V5LmMKKysrIGIvc3JjL3Jzbl9zdXBwL3BlZXJrZXkuYwpAQCAtNTE2LDcgKzUxNiw2IEBACiAJc3RydWN0IHdwYV9wZWVya2V5ICpwZWVya2V5OwogCXN0cnVjdCB3cGFfZWFwb2xfaWVfcGFyc2Uga2RlOwogCXUzMiBsaWZldGltZTsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CiAKIAlpZiAoIXNtLT5wZWVya2V5X2VuYWJsZWQgfHwgc20tPnByb3RvICE9IFdQQV9QUk9UT19SU04pIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSU046IFNNSyBoYW5kc2hha2Ugbm90IGFsbG93ZWQgZm9yICIKQEAgLTU2OCwxMCArNTY3LDggQEAKIAlsaWZldGltZSA9IFdQQV9HRVRfQkUzMihrZGUubGlmZXRpbWUpOwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUlNOOiBTTUsgbGlmZXRpbWUgJXUgc2Vjb25kcyIsIGxpZmV0aW1lKTsKIAlpZiAobGlmZXRpbWUgPiAxMDAwMDAwMDAwKQotCQlsaWZldGltZSA9IDEwMDAwMDAwMDA7IC8qIGF2b2lkIG92ZXJmbG93aW5nIGV4cGlyYXRpb24gdGltZSAqLworCQlsaWZldGltZSA9IDEwMDAwMDAwMDA7IC8qIGF2b2lkIG92ZXJmbG93aW5nIGVsb29wIHRpbWUgKi8KIAlwZWVya2V5LT5saWZldGltZSA9IGxpZmV0aW1lOwotCW9zX2dldF90aW1lKCZub3cpOwotCXBlZXJrZXktPmV4cGlyYXRpb24gPSBub3cuc2VjICsgbGlmZXRpbWU7CiAJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChsaWZldGltZSwgMCwgd3BhX3N1cHBsaWNhbnRfc21rX3RpbWVvdXQsCiAJCQkgICAgICAgc20sIHBlZXJrZXkpOwogCkBAIC02NTYsMTEgKzY1MywxMSBAQAogc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfcHJvY2Vzc19zdGtfMV9vZl80KHN0cnVjdCB3cGFfc20gKnNtLAogCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX3BlZXJrZXkgKnBlZXJrZXksCiAJCQkJCSAgICAgIGNvbnN0IHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksCi0JCQkJCSAgICAgIHUxNiB2ZXIpCisJCQkJCSAgICAgIHUxNiB2ZXIsIGNvbnN0IHU4ICprZXlfZGF0YSwKKwkJCQkJICAgICAgc2l6ZV90IGtleV9kYXRhX2xlbikKIHsKIAlzdHJ1Y3Qgd3BhX2VhcG9sX2llX3BhcnNlIGllOwotCWNvbnN0IHU4ICprZGU7Ci0Jc2l6ZV90IGxlbiwga2RlX2J1Zl9sZW47CisJc2l6ZV90IGtkZV9idWZfbGVuOwogCXN0cnVjdCB3cGFfcHRrICpzdGs7CiAJdTggYnVmWzhdLCAqa2RlX2J1ZiwgKnBvczsKIAliZTMyIGxpZmV0aW1lOwpAQCAtNjcxLDE0ICs2NjgsMTMgQEAKIAlvc19tZW1zZXQoJmllLCAwLCBzaXplb2YoaWUpKTsKIAogCS8qIFJTTjogbXNnIDEvNCBzaG91bGQgY29udGFpbiBTTUtJRCBmb3IgdGhlIHNlbGVjdGVkIFNNSyAqLwotCWtkZSA9IChjb25zdCB1OCAqKSAoa2V5ICsgMSk7Ci0JbGVuID0gV1BBX0dFVF9CRTE2KGtleS0+a2V5X2RhdGFfbGVuZ3RoKTsKLQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJSU046IG1zZyAxLzQga2V5IGRhdGEiLCBrZGUsIGxlbik7Ci0JaWYgKHdwYV9zdXBwbGljYW50X3BhcnNlX2llcyhrZGUsIGxlbiwgJmllKSA8IDAgfHwgaWUucG1raWQgPT0gTlVMTCkgeworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlJTTjogbXNnIDEvNCBrZXkgZGF0YSIsIGtleV9kYXRhLCBrZXlfZGF0YV9sZW4pOworCWlmICh3cGFfc3VwcGxpY2FudF9wYXJzZV9pZXMoa2V5X2RhdGEsIGtleV9kYXRhX2xlbiwgJmllKSA8IDAgfHwKKwkgICAgaWUucG1raWQgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJTTjogTm8gU01LSUQgaW4gU1RLIDEvNCIpOwogCQlyZXR1cm47CiAJfQotCWlmIChvc19tZW1jbXAoaWUucG1raWQsIHBlZXJrZXktPnNta2lkLCBQTUtJRF9MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KGllLnBta2lkLCBwZWVya2V5LT5zbWtpZCwgUE1LSURfTEVOKSAhPSAwKSB7CiAJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlJTTjogVW5rbm93biBTTUtJRCBpbiBTVEsgMS80IiwKIAkJCSAgICBpZS5wbWtpZCwgUE1LSURfTEVOKTsKIAkJcmV0dXJuOwpAQCAtNzM2LDcgKzczMiw2IEBACiAJCQkJCSAgICAgICBzdHJ1Y3Qgd3BhX2VhcG9sX2llX3BhcnNlICprZGUpCiB7CiAJdTMyIGxpZmV0aW1lOwotCXN0cnVjdCBvc190aW1lIG5vdzsKIAogCWlmIChrZGUtPmxpZmV0aW1lID09IE5VTEwgfHwga2RlLT5saWZldGltZV9sZW4gPCBzaXplb2YobGlmZXRpbWUpKQogCQlyZXR1cm47CkBAIC03NTUsOCArNzUwLDYgQEAKIAkJICAgbGlmZXRpbWUsIHBlZXJrZXktPmxpZmV0aW1lKTsKIAlwZWVya2V5LT5saWZldGltZSA9IGxpZmV0aW1lOwogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7Ci0JcGVlcmtleS0+ZXhwaXJhdGlvbiA9IG5vdy5zZWMgKyBsaWZldGltZTsKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFfc3VwcGxpY2FudF9zbWtfdGltZW91dCwgc20sIHBlZXJrZXkpOwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQobGlmZXRpbWUsIDAsIHdwYV9zdXBwbGljYW50X3Nta190aW1lb3V0LAogCQkJICAgICAgIHNtLCBwZWVya2V5KTsKQEAgLTc2NiwxMSArNzU5LDEwIEBACiBzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9wcm9jZXNzX3N0a18yX29mXzQoc3RydWN0IHdwYV9zbSAqc20sCiAJCQkJCSAgICAgIHN0cnVjdCB3cGFfcGVlcmtleSAqcGVlcmtleSwKIAkJCQkJICAgICAgY29uc3Qgc3RydWN0IHdwYV9lYXBvbF9rZXkgKmtleSwKLQkJCQkJICAgICAgdTE2IHZlcikKKwkJCQkJICAgICAgdTE2IHZlciwgY29uc3QgdTggKmtleV9kYXRhLAorCQkJCQkgICAgICBzaXplX3Qga2V5X2RhdGFfbGVuKQogewogCXN0cnVjdCB3cGFfZWFwb2xfaWVfcGFyc2Uga2RlOwotCWNvbnN0IHU4ICprZXlkYXRhOwotCXNpemVfdCBsZW47CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJTTjogUlggbWVzc2FnZSAyIG9mIFNUSyA0LVdheSBIYW5kc2hha2UgZnJvbSAiCiAJCSAgIE1BQ1NUUiAiICh2ZXI9JWQpIiwgTUFDMlNUUihwZWVya2V5LT5hZGRyKSwgdmVyKTsKQEAgLTc3OSwxNiArNzcxLDE0IEBACiAKIAkvKiBSU046IG1zZyAyLzQgc2hvdWxkIGNvbnRhaW4gU01LSUQgZm9yIHRoZSBzZWxlY3RlZCBTTUsgYW5kIFJTTiBJRQogCSAqIGZyb20gdGhlIHBlZXIuIEl0IG1heSBhbHNvIGluY2x1ZGUgTGlmZXRpbWUgS0RFLiAqLwotCWtleWRhdGEgPSAoY29uc3QgdTggKikgKGtleSArIDEpOwotCWxlbiA9IFdQQV9HRVRfQkUxNihrZXktPmtleV9kYXRhX2xlbmd0aCk7Ci0Jd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUlNOOiBtc2cgMi80IGtleSBkYXRhIiwga2V5ZGF0YSwgbGVuKTsKLQlpZiAod3BhX3N1cHBsaWNhbnRfcGFyc2VfaWVzKGtleWRhdGEsIGxlbiwgJmtkZSkgPCAwIHx8CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUlNOOiBtc2cgMi80IGtleSBkYXRhIiwga2V5X2RhdGEsIGtleV9kYXRhX2xlbik7CisJaWYgKHdwYV9zdXBwbGljYW50X3BhcnNlX2llcyhrZXlfZGF0YSwga2V5X2RhdGFfbGVuLCAma2RlKSA8IDAgfHwKIAkgICAga2RlLnBta2lkID09IE5VTEwgfHwga2RlLnJzbl9pZSA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUlNOOiBObyBTTUtJRCBvciBSU04gSUUgaW4gU1RLIDIvNCIpOwogCQlyZXR1cm47CiAJfQogCi0JaWYgKG9zX21lbWNtcChrZGUucG1raWQsIHBlZXJrZXktPnNta2lkLCBQTUtJRF9MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KGtkZS5wbWtpZCwgcGVlcmtleS0+c21raWQsIFBNS0lEX0xFTikgIT0gMCkgewogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJSU046IFVua25vd24gU01LSUQgaW4gU1RLIDIvNCIsCiAJCQkgICAga2RlLnBta2lkLCBQTUtJRF9MRU4pOwogCQlyZXR1cm47CkBAIC04MTUsMTEgKzgwNSwxMSBAQAogc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfcHJvY2Vzc19zdGtfM19vZl80KHN0cnVjdCB3cGFfc20gKnNtLAogCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX3BlZXJrZXkgKnBlZXJrZXksCiAJCQkJCSAgICAgIGNvbnN0IHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksCi0JCQkJCSAgICAgIHUxNiB2ZXIpCisJCQkJCSAgICAgIHUxNiB2ZXIsIGNvbnN0IHU4ICprZXlfZGF0YSwKKwkJCQkJICAgICAgc2l6ZV90IGtleV9kYXRhX2xlbikKIHsKIAlzdHJ1Y3Qgd3BhX2VhcG9sX2llX3BhcnNlIGtkZTsKLQljb25zdCB1OCAqa2V5ZGF0YTsKLQlzaXplX3QgbGVuLCBrZXlfbGVuOworCXNpemVfdCBrZXlfbGVuOwogCWNvbnN0IHU4ICpfa2V5OwogCXU4IGtleV9idWZbMzJdLCByc2NbNl07CiAKQEAgLTgzMCwxMCArODIwLDggQEAKIAogCS8qIFJTTjogbXNnIDMvNCBzaG91bGQgY29udGFpbiBJbml0aWF0b3IgUlNOIElFLiBJdCBtYXkgYWxzbyBpbmNsdWRlCiAJICogTGlmZXRpbWUgS0RFLiAqLwotCWtleWRhdGEgPSAoY29uc3QgdTggKikgKGtleSArIDEpOwotCWxlbiA9IFdQQV9HRVRfQkUxNihrZXktPmtleV9kYXRhX2xlbmd0aCk7Ci0Jd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUlNOOiBtc2cgMy80IGtleSBkYXRhIiwga2V5ZGF0YSwgbGVuKTsKLQlpZiAod3BhX3N1cHBsaWNhbnRfcGFyc2VfaWVzKGtleWRhdGEsIGxlbiwgJmtkZSkgPCAwKSB7CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUlNOOiBtc2cgMy80IGtleSBkYXRhIiwga2V5X2RhdGEsIGtleV9kYXRhX2xlbik7CisJaWYgKHdwYV9zdXBwbGljYW50X3BhcnNlX2llcyhrZXlfZGF0YSwga2V5X2RhdGFfbGVuLCAma2RlKSA8IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSU046IEZhaWxlZCB0byBwYXJzZSBrZXkgZGF0YSBpbiAiCiAJCQkgICAiU1RLIDMvNCIpOwogCQlyZXR1cm47CkBAIC04NjQsNyArODUyLDcgQEAKIAogCWlmICh3cGFfc3VwcGxpY2FudF9zZW5kXzRfb2ZfNChzbSwgcGVlcmtleS0+YWRkciwga2V5LCB2ZXIsCiAJCQkJICAgICAgIFdQQV9HRVRfQkUxNihrZXktPmtleV9pbmZvKSwKLQkJCQkgICAgICAgTlVMTCwgMCwgJnBlZXJrZXktPnN0aykpCisJCQkJICAgICAgICZwZWVya2V5LT5zdGspKQogCQlyZXR1cm47CiAKIAlfa2V5ID0gKHU4ICopIHBlZXJrZXktPnN0ay50azE7CkBAIC05NDEsNyArOTI5LDcgQEAKIAkJb3NfbWVtc2V0KGtleS0+a2V5X21pYywgMCwgMTYpOwogCQl3cGFfZWFwb2xfa2V5X21pYyhwZWVya2V5LT50c3RrLmtjaywgdmVyLCBidWYsIGxlbiwKIAkJCQkgIGtleS0+a2V5X21pYyk7Ci0JCWlmIChvc19tZW1jbXAobWljLCBrZXktPmtleV9taWMsIDE2KSAhPSAwKSB7CisJCWlmIChvc19tZW1jbXBfY29uc3QobWljLCBrZXktPmtleV9taWMsIDE2KSAhPSAwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiUlNOOiBJbnZhbGlkIEVBUE9MLUtleSBNSUMgIgogCQkJCSAgICJ3aGVuIHVzaW5nIFRTVEsgLSBpZ25vcmluZyBUU1RLIik7CiAJCX0gZWxzZSB7CkBAIC05NTcsNyArOTQ1LDcgQEAKIAkJb3NfbWVtc2V0KGtleS0+a2V5X21pYywgMCwgMTYpOwogCQl3cGFfZWFwb2xfa2V5X21pYyhwZWVya2V5LT5zdGsua2NrLCB2ZXIsIGJ1ZiwgbGVuLAogCQkJCSAga2V5LT5rZXlfbWljKTsKLQkJaWYgKG9zX21lbWNtcChtaWMsIGtleS0+a2V5X21pYywgMTYpICE9IDApIHsKKwkJaWYgKG9zX21lbWNtcF9jb25zdChtaWMsIGtleS0+a2V5X21pYywgMTYpICE9IDApIHsKIAkJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJSU046IEludmFsaWQgRUFQT0wtS2V5IE1JQyAiCiAJCQkJICAgIi0gZHJvcHBpbmcgcGFja2V0Iik7CiAJCQlyZXR1cm4gLTE7CkBAIC0xMTE2LDI4ICsxMTA0LDMyIEBACiAJd2hpbGUgKHBlZXJrZXkpIHsKIAkJcHJldiA9IHBlZXJrZXk7CiAJCXBlZXJrZXkgPSBwZWVya2V5LT5uZXh0OwotCQlvc19mcmVlKHByZXYpOworCQl3cGFfc3VwcGxpY2FudF9wZWVya2V5X2ZyZWUoc20sIHByZXYpOwogCX0KIAlzbS0+cGVlcmtleSA9IE5VTEw7CiB9CiAKIAogdm9pZCBwZWVya2V5X3J4X2VhcG9sXzR3YXkoc3RydWN0IHdwYV9zbSAqc20sIHN0cnVjdCB3cGFfcGVlcmtleSAqcGVlcmtleSwKLQkJCSAgIHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksIHUxNiBrZXlfaW5mbywgdTE2IHZlcikKKwkJCSAgIHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksIHUxNiBrZXlfaW5mbywgdTE2IHZlciwKKwkJCSAgIGNvbnN0IHU4ICprZXlfZGF0YSwgc2l6ZV90IGtleV9kYXRhX2xlbikKIHsKIAlpZiAoKGtleV9pbmZvICYgKFdQQV9LRVlfSU5GT19NSUMgfCBXUEFfS0VZX0lORk9fQUNLKSkgPT0KIAkgICAgKFdQQV9LRVlfSU5GT19NSUMgfCBXUEFfS0VZX0lORk9fQUNLKSkgewogCQkvKiAzLzQgU1RLIDQtV2F5IEhhbmRzaGFrZSAqLwotCQl3cGFfc3VwcGxpY2FudF9wcm9jZXNzX3N0a18zX29mXzQoc20sIHBlZXJrZXksIGtleSwgdmVyKTsKKwkJd3BhX3N1cHBsaWNhbnRfcHJvY2Vzc19zdGtfM19vZl80KHNtLCBwZWVya2V5LCBrZXksIHZlciwKKwkJCQkJCSAga2V5X2RhdGEsIGtleV9kYXRhX2xlbik7CiAJfSBlbHNlIGlmIChrZXlfaW5mbyAmIFdQQV9LRVlfSU5GT19BQ0spIHsKIAkJLyogMS80IFNUSyA0LVdheSBIYW5kc2hha2UgKi8KLQkJd3BhX3N1cHBsaWNhbnRfcHJvY2Vzc19zdGtfMV9vZl80KHNtLCBwZWVya2V5LCBrZXksIHZlcik7CisJCXdwYV9zdXBwbGljYW50X3Byb2Nlc3Nfc3RrXzFfb2ZfNChzbSwgcGVlcmtleSwga2V5LCB2ZXIsCisJCQkJCQkgIGtleV9kYXRhLCBrZXlfZGF0YV9sZW4pOwogCX0gZWxzZSBpZiAoa2V5X2luZm8gJiBXUEFfS0VZX0lORk9fU0VDVVJFKSB7CiAJCS8qIDQvNCBTVEsgNC1XYXkgSGFuZHNoYWtlICovCiAJCXdwYV9zdXBwbGljYW50X3Byb2Nlc3Nfc3RrXzRfb2ZfNChzbSwgcGVlcmtleSwga2V5LCB2ZXIpOwogCX0gZWxzZSB7CiAJCS8qIDIvNCBTVEsgNC1XYXkgSGFuZHNoYWtlICovCi0JCXdwYV9zdXBwbGljYW50X3Byb2Nlc3Nfc3RrXzJfb2ZfNChzbSwgcGVlcmtleSwga2V5LCB2ZXIpOworCQl3cGFfc3VwcGxpY2FudF9wcm9jZXNzX3N0a18yX29mXzQoc20sIHBlZXJrZXksIGtleSwgdmVyLAorCQkJCQkJICBrZXlfZGF0YSwga2V5X2RhdGFfbGVuKTsKIAl9CiB9CiAKZGlmZiAtLWdpdCBhL3NyYy9yc25fc3VwcC9wZWVya2V5LmggYi9zcmMvcnNuX3N1cHAvcGVlcmtleS5oCmluZGV4IGI4ODQ1ZjcuLjRjMTdlYWUgMTAwNjQ0Ci0tLSBhL3NyYy9yc25fc3VwcC9wZWVya2V5LmgKKysrIGIvc3JjL3Jzbl9zdXBwL3BlZXJrZXkuaApAQCAtMjQsNyArMjQsNiBAQAogCWludCBzbWtfY29tcGxldGU7CiAJdTggc21raWRbUE1LSURfTEVOXTsKIAl1MzIgbGlmZXRpbWU7Ci0Jb3NfdGltZV90IGV4cGlyYXRpb247CiAJaW50IGNpcGhlcjsgLyogU2VsZWN0ZWQgY2lwaGVyIChXUEFfQ0lQSEVSXyopICovCiAJdTggcmVwbGF5X2NvdW50ZXJbV1BBX1JFUExBWV9DT1VOVEVSX0xFTl07CiAJaW50IHJlcGxheV9jb3VudGVyX3NldDsKQEAgLTQyLDcgKzQxLDggQEAKIAkJCQkgc3RydWN0IHdwYV9lYXBvbF9rZXkgKmtleSwgdTE2IHZlciwKIAkJCQkgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbik7CiB2b2lkIHBlZXJrZXlfcnhfZWFwb2xfNHdheShzdHJ1Y3Qgd3BhX3NtICpzbSwgc3RydWN0IHdwYV9wZWVya2V5ICpwZWVya2V5LAotCQkJICAgc3RydWN0IHdwYV9lYXBvbF9rZXkgKmtleSwgdTE2IGtleV9pbmZvLCB1MTYgdmVyKTsKKwkJCSAgIHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksIHUxNiBrZXlfaW5mbywgdTE2IHZlciwKKwkJCSAgIGNvbnN0IHU4ICprZXlfZGF0YSwgc2l6ZV90IGtleV9kYXRhX2xlbik7CiB2b2lkIHBlZXJrZXlfcnhfZWFwb2xfc21rKHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqc3JjX2FkZHIsCiAJCQkgIHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksIHNpemVfdCBleHRyYV9sZW4sCiAJCQkgIHUxNiBrZXlfaW5mbywgdTE2IHZlcik7CkBAIC02MSw3ICs2MSw4IEBACiAKIHN0YXRpYyBpbmxpbmUgdm9pZAogcGVlcmtleV9yeF9lYXBvbF80d2F5KHN0cnVjdCB3cGFfc20gKnNtLCBzdHJ1Y3Qgd3BhX3BlZXJrZXkgKnBlZXJrZXksCi0JCSAgICAgIHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksIHUxNiBrZXlfaW5mbywgdTE2IHZlcikKKwkJICAgICAgc3RydWN0IHdwYV9lYXBvbF9rZXkgKmtleSwgdTE2IGtleV9pbmZvLCB1MTYgdmVyLAorCQkgICAgICBjb25zdCB1OCAqa2V5X2RhdGEsIHNpemVfdCBrZXlfZGF0YV9sZW4pCiB7CiB9CiAKZGlmZiAtLWdpdCBhL3NyYy9yc25fc3VwcC9wbWtzYV9jYWNoZS5jIGIvc3JjL3Jzbl9zdXBwL3Bta3NhX2NhY2hlLmMKaW5kZXggMzNmYTFhMi4uYjVhODdmYyAxMDA2NDQKLS0tIGEvc3JjL3Jzbl9zdXBwL3Bta3NhX2NhY2hlLmMKKysrIGIvc3JjL3Jzbl9zdXBwL3Bta3NhX2NhY2hlLmMKQEAgLTUzLDkgKzUzLDkgQEAKIHN0YXRpYyB2b2lkIHBta3NhX2NhY2hlX2V4cGlyZSh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQogewogCXN0cnVjdCByc25fcG1rc2FfY2FjaGUgKnBta3NhID0gZWxvb3BfY3R4OwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAl3aGlsZSAocG1rc2EtPnBta3NhICYmIHBta3NhLT5wbWtzYS0+ZXhwaXJhdGlvbiA8PSBub3cuc2VjKSB7CiAJCXN0cnVjdCByc25fcG1rc2FfY2FjaGVfZW50cnkgKmVudHJ5ID0gcG1rc2EtPnBta3NhOwogCQlwbWtzYS0+cG1rc2EgPSBlbnRyeS0+bmV4dDsKQEAgLTgwLDEzICs4MCwxMyBAQAogewogCWludCBzZWM7CiAJc3RydWN0IHJzbl9wbWtzYV9jYWNoZV9lbnRyeSAqZW50cnk7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAogCWVsb29wX2NhbmNlbF90aW1lb3V0KHBta3NhX2NhY2hlX2V4cGlyZSwgcG1rc2EsIE5VTEwpOwogCWVsb29wX2NhbmNlbF90aW1lb3V0KHBta3NhX2NhY2hlX3JlYXV0aCwgcG1rc2EsIE5VTEwpOwogCWlmIChwbWtzYS0+cG1rc2EgPT0gTlVMTCkKIAkJcmV0dXJuOwotCW9zX2dldF90aW1lKCZub3cpOworCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCXNlYyA9IHBta3NhLT5wbWtzYS0+ZXhwaXJhdGlvbiAtIG5vdy5zZWM7CiAJaWYgKHNlYyA8IDApCiAJCXNlYyA9IDA7CkBAIC0xMjUsNyArMTI1LDcgQEAKIAkJY29uc3QgdTggKmFhLCBjb25zdCB1OCAqc3BhLCB2b2lkICpuZXR3b3JrX2N0eCwgaW50IGFrbXApCiB7CiAJc3RydWN0IHJzbl9wbWtzYV9jYWNoZV9lbnRyeSAqZW50cnksICpwb3MsICpwcmV2OwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKIAlpZiAocG1rX2xlbiA+IFBNS19MRU4pCiAJCXJldHVybiBOVUxMOwpAQCAtMTM3LDcgKzEzNyw3IEBACiAJZW50cnktPnBta19sZW4gPSBwbWtfbGVuOwogCXJzbl9wbWtpZChwbWssIHBta19sZW4sIGFhLCBzcGEsIGVudHJ5LT5wbWtpZCwKIAkJICB3cGFfa2V5X21nbXRfc2hhMjU2KGFrbXApKTsKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAllbnRyeS0+ZXhwaXJhdGlvbiA9IG5vdy5zZWMgKyBwbWtzYS0+c20tPmRvdDExUlNOQUNvbmZpZ1BNS0xpZmV0aW1lOwogCWVudHJ5LT5yZWF1dGhfdGltZSA9IG5vdy5zZWMgKyBwbWtzYS0+c20tPmRvdDExUlNOQUNvbmZpZ1BNS0xpZmV0aW1lICoKIAkJcG1rc2EtPnNtLT5kb3QxMVJTTkFDb25maWdQTUtSZWF1dGhUaHJlc2hvbGQgLyAxMDA7CkBAIC0xNTIsOSArMTUyLDkgQEAKIAl3aGlsZSAocG9zKSB7CiAJCWlmIChvc19tZW1jbXAoYWEsIHBvcy0+YWEsIEVUSF9BTEVOKSA9PSAwKSB7CiAJCQlpZiAocG9zLT5wbWtfbGVuID09IHBta19sZW4gJiYKLQkJCSAgICBvc19tZW1jbXAocG9zLT5wbWssIHBtaywgcG1rX2xlbikgPT0gMCAmJgotCQkJICAgIG9zX21lbWNtcChwb3MtPnBta2lkLCBlbnRyeS0+cG1raWQsIFBNS0lEX0xFTikgPT0KLQkJCSAgICAwKSB7CisJCQkgICAgb3NfbWVtY21wX2NvbnN0KHBvcy0+cG1rLCBwbWssIHBta19sZW4pID09IDAgJiYKKwkJCSAgICBvc19tZW1jbXBfY29uc3QocG9zLT5wbWtpZCwgZW50cnktPnBta2lkLAorCQkJCQkgICAgUE1LSURfTEVOKSA9PSAwKSB7CiAJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUEE6IHJldXNpbmcgcHJldmlvdXMgIgogCQkJCQkgICAiUE1LU0EgZW50cnkiKTsKIAkJCQlvc19mcmVlKGVudHJ5KTsKQEAgLTQ2Niw5ICs0NjYsOSBAQAogCWludCBpLCByZXQ7CiAJY2hhciAqcG9zID0gYnVmOwogCXN0cnVjdCByc25fcG1rc2FfY2FjaGVfZW50cnkgKmVudHJ5OwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAlyZXQgPSBvc19zbnByaW50Zihwb3MsIGJ1ZiArIGxlbiAtIHBvcywKIAkJCSAgIkluZGV4IC8gQUEgLyBQTUtJRCAvIGV4cGlyYXRpb24gKGluIHNlY29uZHMpIC8gIgogCQkJICAib3Bwb3J0dW5pc3RpY1xuIik7CmRpZmYgLS1naXQgYS9zcmMvcnNuX3N1cHAvcHJlYXV0aC5jIGIvc3JjL3Jzbl9zdXBwL3ByZWF1dGguYwppbmRleCBjNTE2MjBlLi45MTVmODVlIDEwMDY0NAotLS0gYS9zcmMvcnNuX3N1cHAvcHJlYXV0aC5jCisrKyBiL3NyYy9yc25fc3VwcC9wcmVhdXRoLmMKQEAgLTcwLDEzICs3MCwxNCBAQAogfQogCiAKLXN0YXRpYyB2b2lkIHJzbl9wcmVhdXRoX2VhcG9sX2NiKHN0cnVjdCBlYXBvbF9zbSAqZWFwb2wsIGludCBzdWNjZXNzLAorc3RhdGljIHZvaWQgcnNuX3ByZWF1dGhfZWFwb2xfY2Ioc3RydWN0IGVhcG9sX3NtICplYXBvbCwKKwkJCQkgZW51bSBlYXBvbF9zdXBwX3Jlc3VsdCByZXN1bHQsCiAJCQkJIHZvaWQgKmN0eCkKIHsKIAlzdHJ1Y3Qgd3BhX3NtICpzbSA9IGN0eDsKIAl1OCBwbWtbUE1LX0xFTl07CiAKLQlpZiAoc3VjY2VzcykgeworCWlmIChyZXN1bHQgPT0gRUFQT0xfU1VQUF9SRVNVTFRfU1VDQ0VTUykgewogCQlpbnQgcmVzLCBwbWtfbGVuOwogCQlwbWtfbGVuID0gUE1LX0xFTjsKIAkJcmVzID0gZWFwb2xfc21fZ2V0X2tleShlYXBvbCwgcG1rLCBQTUtfTEVOKTsKQEAgLTEwMCwxMyArMTAxLDE0IEBACiAJCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19JTkZPLAogCQkJCSJSU046IGZhaWxlZCB0byBnZXQgbWFzdGVyIHNlc3Npb24ga2V5IGZyb20gIgogCQkJCSJwcmUtYXV0aCBFQVBPTCBzdGF0ZSBtYWNoaW5lcyIpOwotCQkJc3VjY2VzcyA9IDA7CisJCQlyZXN1bHQgPSBFQVBPTF9TVVBQX1JFU1VMVF9GQUlMVVJFOwogCQl9CiAJfQogCiAJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfSU5GTywgIlJTTjogcHJlLWF1dGhlbnRpY2F0aW9uIHdpdGggIgogCQlNQUNTVFIgIiAlcyIsIE1BQzJTVFIoc20tPnByZWF1dGhfYnNzaWQpLAotCQlzdWNjZXNzID8gImNvbXBsZXRlZCBzdWNjZXNzZnVsbHkiIDogImZhaWxlZCIpOworCQlyZXN1bHQgPT0gRUFQT0xfU1VQUF9SRVNVTFRfU1VDQ0VTUyA/ICJjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5IiA6CisJCSJmYWlsZWQiKTsKIAogCXJzbl9wcmVhdXRoX2RlaW5pdChzbSk7CiAJcnNuX3ByZWF1dGhfY2FuZGlkYXRlX3Byb2Nlc3Moc20pOwpkaWZmIC0tZ2l0IGEvc3JjL3Jzbl9zdXBwL3RkbHMuYyBiL3NyYy9yc25fc3VwcC90ZGxzLmMKaW5kZXggZTkxMWFkMC4uY2QzNDIyMyAxMDA2NDQKLS0tIGEvc3JjL3Jzbl9zdXBwL3RkbHMuYworKysgYi9zcmMvcnNuX3N1cHAvdGRscy5jCkBAIC0zMyw2ICszMyw3IEBACiAjZGVmaW5lIFRETFNfVEVTVElOR19OT19UUEtfRVhQSVJBVElPTiBCSVQoOCkKICNkZWZpbmUgVERMU19URVNUSU5HX0RFQ0xJTkVfUkVTUCBCSVQoOSkKICNkZWZpbmUgVERMU19URVNUSU5HX0lHTk9SRV9BUF9QUk9ISUJJVCBCSVQoMTApCisjZGVmaW5lIFRETFNfVEVTVElOR19XUk9OR19NSUMgQklUKDExKQogdW5zaWduZWQgaW50IHRkbHNfdGVzdGluZyA9IDA7CiAjZW5kaWYgLyogQ09ORklHX1RETFNfVEVTVElORyAqLwogCkBAIC04Myw2ICs4NCw4IEBACiBzdGF0aWMgdm9pZCB3cGFfdGRsc19wZWVyX2ZyZWUoc3RydWN0IHdwYV9zbSAqc20sIHN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyKTsKIHN0YXRpYyB2b2lkIHdwYV90ZGxzX2Rpc2FibGVfcGVlcl9saW5rKHN0cnVjdCB3cGFfc20gKnNtLAogCQkJCSAgICAgICBzdHJ1Y3Qgd3BhX3RkbHNfcGVlciAqcGVlcik7CitzdGF0aWMgaW50IHdwYV90ZGxzX3NlbmRfdGVhcmRvd24oc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICphZGRyLAorCQkJCSAgdTE2IHJlYXNvbl9jb2RlKTsKIAogCiAjZGVmaW5lIFRETFNfTUFYX0lFX0xFTiA4MApAQCAtMTE4LDYgKzEyMSw3IEBACiAJCXU4IGFjdGlvbl9jb2RlOyAvKiBURExTIGZyYW1lIHR5cGUgKi8KIAkJdTggZGlhbG9nX3Rva2VuOwogCQl1MTYgc3RhdHVzX2NvZGU7CisJCXUzMiBwZWVyX2NhcGFiOwogCQlpbnQgYnVmX2xlbjsgICAgLyogbGVuZ3RoIG9mIFRQSyBtZXNzYWdlIGZvciByZXRyYW5zbWlzc2lvbiAqLwogCQl1OCAqYnVmOyAgICAgICAgLyogYnVmZmVyIGZvciBUUEsgbWVzc2FnZSAqLwogCX0gc21fdG1yOwpAQCAtMTM2LDYgKzE0MCwxNCBAQAogCiAJdTggKmV4dF9jYXBhYjsKIAlzaXplX3QgZXh0X2NhcGFiX2xlbjsKKworCXU4ICpzdXBwX2NoYW5uZWxzOworCXNpemVfdCBzdXBwX2NoYW5uZWxzX2xlbjsKKworCXU4ICpzdXBwX29wZXJfY2xhc3NlczsKKwlzaXplX3Qgc3VwcF9vcGVyX2NsYXNzZXNfbGVuOworCisJdTggd21tX2NhcGFibGU7CiB9OwogCiAKQEAgLTIwNSwyNiArMjE3LDI3IEBACiAKIHN0YXRpYyBpbnQgd3BhX3RkbHNfc2VuZF90cGtfbXNnKHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqZHN0LAogCQkJCSB1OCBhY3Rpb25fY29kZSwgdTggZGlhbG9nX3Rva2VuLAotCQkJCSB1MTYgc3RhdHVzX2NvZGUsIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCisJCQkJIHUxNiBzdGF0dXNfY29kZSwgdTMyIHBlZXJfY2FwYWIsCisJCQkJIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCiB7CiAJcmV0dXJuIHdwYV9zbV9zZW5kX3RkbHNfbWdtdChzbSwgZHN0LCBhY3Rpb25fY29kZSwgZGlhbG9nX3Rva2VuLAotCQkJCSAgICAgc3RhdHVzX2NvZGUsIGJ1ZiwgbGVuKTsKKwkJCQkgICAgIHN0YXR1c19jb2RlLCBwZWVyX2NhcGFiLCBidWYsIGxlbik7CiB9CiAKIAogc3RhdGljIGludCB3cGFfdGRsc190cGtfc2VuZChzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdTggKmRlc3QsIHU4IGFjdGlvbl9jb2RlLAotCQkJICAgICB1OCBkaWFsb2dfdG9rZW4sIHUxNiBzdGF0dXNfY29kZSwKKwkJCSAgICAgdTggZGlhbG9nX3Rva2VuLCB1MTYgc3RhdHVzX2NvZGUsIHUzMiBwZWVyX2NhcGFiLAogCQkJICAgICBjb25zdCB1OCAqbXNnLCBzaXplX3QgbXNnX2xlbikKIHsKIAlzdHJ1Y3Qgd3BhX3RkbHNfcGVlciAqcGVlcjsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogVFBLIHNlbmQgZGVzdD0iIE1BQ1NUUiAiIGFjdGlvbl9jb2RlPSV1ICIKLQkJICAgImRpYWxvZ190b2tlbj0ldSBzdGF0dXNfY29kZT0ldSBtc2dfbGVuPSV1IiwKKwkJICAgImRpYWxvZ190b2tlbj0ldSBzdGF0dXNfY29kZT0ldSBwZWVyX2NhcGFiPSV1IG1zZ19sZW49JXUiLAogCQkgICBNQUMyU1RSKGRlc3QpLCBhY3Rpb25fY29kZSwgZGlhbG9nX3Rva2VuLCBzdGF0dXNfY29kZSwKLQkJICAgKHVuc2lnbmVkIGludCkgbXNnX2xlbik7CisJCSAgIHBlZXJfY2FwYWIsICh1bnNpZ25lZCBpbnQpIG1zZ19sZW4pOwogCiAJaWYgKHdwYV90ZGxzX3NlbmRfdHBrX21zZyhzbSwgZGVzdCwgYWN0aW9uX2NvZGUsIGRpYWxvZ190b2tlbiwKLQkJCQkgIHN0YXR1c19jb2RlLCBtc2csIG1zZ19sZW4pKSB7CisJCQkJICBzdGF0dXNfY29kZSwgcGVlcl9jYXBhYiwgbXNnLCBtc2dfbGVuKSkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVERMUzogRmFpbGVkIHRvIHNlbmQgbWVzc2FnZSAiCiAJCQkgICAiKGFjdGlvbl9jb2RlPSV1KSIsIGFjdGlvbl9jb2RlKTsKIAkJcmV0dXJuIC0xOwpAQCAtMjYyLDYgKzI3NSw3IEBACiAJcGVlci0+c21fdG1yLmFjdGlvbl9jb2RlID0gYWN0aW9uX2NvZGU7CiAJcGVlci0+c21fdG1yLmRpYWxvZ190b2tlbiA9IGRpYWxvZ190b2tlbjsKIAlwZWVyLT5zbV90bXIuc3RhdHVzX2NvZGUgPSBzdGF0dXNfY29kZTsKKwlwZWVyLT5zbV90bXIucGVlcl9jYXBhYiA9IHBlZXJfY2FwYWI7CiAJcGVlci0+c21fdG1yLmJ1Zl9sZW4gPSBtc2dfbGVuOwogCW9zX2ZyZWUocGVlci0+c21fdG1yLmJ1Zik7CiAJcGVlci0+c21fdG1yLmJ1ZiA9IG9zX21hbGxvYyhtc2dfbGVuKTsKQEAgLTMxOCw2ICszMzIsNyBAQAogCQkJCQkgIHBlZXItPnNtX3Rtci5hY3Rpb25fY29kZSwKIAkJCQkJICBwZWVyLT5zbV90bXIuZGlhbG9nX3Rva2VuLAogCQkJCQkgIHBlZXItPnNtX3Rtci5zdGF0dXNfY29kZSwKKwkJCQkJICBwZWVyLT5zbV90bXIucGVlcl9jYXBhYiwKIAkJCQkJICBwZWVyLT5zbV90bXIuYnVmLAogCQkJCQkgIHBlZXItPnNtX3Rtci5idWZfbGVuKSkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRETFM6IEZhaWxlZCB0byByZXRyeSAiCkBAIC01NDksNyArNTY0LDcgQEAKIAkJd3BhX3RkbHNfZnRpZV9taWMocGVlci0+dHBrLmtjaywgdHJhbnNfc2VxLCBsbmtpZCwKIAkJCQkgIHBlZXItPnJzbmllX3AsIHRpbWVvdXRpZSwgKHU4ICopIGZ0aWUsCiAJCQkJICBtaWMpOwotCQlpZiAob3NfbWVtY21wKG1pYywgZnRpZS0+bWljLCAxNikgIT0gMCkgeworCQlpZiAob3NfbWVtY21wX2NvbnN0KG1pYywgZnRpZS0+bWljLCAxNikgIT0gMCkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRETFM6IEludmFsaWQgTUlDIGluIEZUSUUgLSAiCiAJCQkJICAgImRyb3BwaW5nIHBhY2tldCIpOwogCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiVERMUzogUmVjZWl2ZWQgTUlDIiwKQEAgLTU3Niw3ICs1OTEsNyBAQAogCWlmIChwZWVyLT50cGtfc2V0KSB7CiAJCXdwYV90ZGxzX2tleV9taWNfdGVhcmRvd24ocGVlci0+dHBrLmtjaywgdHJhbnNfc2VxLCByY29kZSwKIAkJCQkJICBkdG9rZW4sIGxua2lkLCAodTggKikgZnRpZSwgbWljKTsKLQkJaWYgKG9zX21lbWNtcChtaWMsIGZ0aWUtPm1pYywgMTYpICE9IDApIHsKKwkJaWYgKG9zX21lbWNtcF9jb25zdChtaWMsIGZ0aWUtPm1pYywgMTYpICE9IDApIHsKIAkJCXdwYV9wcmludGYoTVNHX0lORk8sICJURExTOiBJbnZhbGlkIE1JQyBpbiBUZWFyZG93biAtICIKIAkJCQkgICAiZHJvcHBpbmcgcGFja2V0Iik7CiAJCQlyZXR1cm4gLTE7CkBAIC02MTYsNyArNjMxLDMzIEBACiB9CiAKIAotc3RhdGljIHZvaWQgd3BhX3RkbHNfcGVlcl9mcmVlKHN0cnVjdCB3cGFfc20gKnNtLCBzdHJ1Y3Qgd3BhX3RkbHNfcGVlciAqcGVlcikKK3N0YXRpYyB2b2lkIHdwYV90ZGxzX3BlZXJfcmVtb3ZlX2Zyb21fbGlzdChzdHJ1Y3Qgd3BhX3NtICpzbSwKKwkJCQkJICAgc3RydWN0IHdwYV90ZGxzX3BlZXIgKnBlZXIpCit7CisJc3RydWN0IHdwYV90ZGxzX3BlZXIgKmN1ciwgKnByZXY7CisKKwljdXIgPSBzbS0+dGRsczsKKwlwcmV2ID0gTlVMTDsKKwl3aGlsZSAoY3VyICYmIGN1ciAhPSBwZWVyKSB7CisJCXByZXYgPSBjdXI7CisJCWN1ciA9IGN1ci0+bmV4dDsKKwl9CisKKwlpZiAoY3VyICE9IHBlZXIpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJURExTOiBDb3VsZCBub3QgZmluZCBwZWVyICIgTUFDU1RSCisJCQkgICAiIHRvIHJlbW92ZSBpdCBmcm9tIHRoZSBsaXN0IiwKKwkJCSAgIE1BQzJTVFIocGVlci0+YWRkcikpOworCQlyZXR1cm47CisJfQorCisJaWYgKHByZXYpCisJCXByZXYtPm5leHQgPSBwZWVyLT5uZXh0OworCWVsc2UKKwkJc20tPnRkbHMgPSBwZWVyLT5uZXh0OworfQorCisKK3N0YXRpYyB2b2lkIHdwYV90ZGxzX3BlZXJfY2xlYXIoc3RydWN0IHdwYV9zbSAqc20sIHN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyKQogewogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogQ2xlYXIgc3RhdGUgZm9yIHBlZXIgIiBNQUNTVFIsCiAJCSAgIE1BQzJTVFIocGVlci0+YWRkcikpOwpAQCAtNjMzLDggKzY3NCwxNCBAQAogCXBlZXItPnZodF9jYXBhYmlsaXRpZXMgPSBOVUxMOwogCW9zX2ZyZWUocGVlci0+ZXh0X2NhcGFiKTsKIAlwZWVyLT5leHRfY2FwYWIgPSBOVUxMOworCW9zX2ZyZWUocGVlci0+c3VwcF9jaGFubmVscyk7CisJcGVlci0+c3VwcF9jaGFubmVscyA9IE5VTEw7CisJb3NfZnJlZShwZWVyLT5zdXBwX29wZXJfY2xhc3Nlcyk7CisJcGVlci0+c3VwcF9vcGVyX2NsYXNzZXMgPSBOVUxMOwogCXBlZXItPnJzbmllX2lfbGVuID0gcGVlci0+cnNuaWVfcF9sZW4gPSAwOwogCXBlZXItPmNpcGhlciA9IDA7CisJcGVlci0+cW9zX2luZm8gPSAwOworCXBlZXItPndtbV9jYXBhYmxlID0gMDsKIAlwZWVyLT50cGtfc2V0ID0gcGVlci0+dHBrX3N1Y2Nlc3MgPSAwOwogCW9zX21lbXNldCgmcGVlci0+dHBrLCAwLCBzaXplb2YocGVlci0+dHBrKSk7CiAJb3NfbWVtc2V0KHBlZXItPmlub25jZSwgMCwgV1BBX05PTkNFX0xFTik7CkBAIC02NDIsNiArNjg5LDE0IEBACiB9CiAKIAorc3RhdGljIHZvaWQgd3BhX3RkbHNfcGVlcl9mcmVlKHN0cnVjdCB3cGFfc20gKnNtLCBzdHJ1Y3Qgd3BhX3RkbHNfcGVlciAqcGVlcikKK3sKKwl3cGFfdGRsc19wZWVyX2NsZWFyKHNtLCBwZWVyKTsKKwl3cGFfdGRsc19wZWVyX3JlbW92ZV9mcm9tX2xpc3Qoc20sIHBlZXIpOworCW9zX2ZyZWUocGVlcik7Cit9CisKKwogc3RhdGljIHZvaWQgd3BhX3RkbHNfbGlua2lkKHN0cnVjdCB3cGFfc20gKnNtLCBzdHJ1Y3Qgd3BhX3RkbHNfcGVlciAqcGVlciwKIAkJCSAgICBzdHJ1Y3Qgd3BhX3RkbHNfbG5raWQgKmxua2lkKQogewpAQCAtNjU4LDcgKzcxMyw4IEBACiB9CiAKIAotaW50IHdwYV90ZGxzX3NlbmRfdGVhcmRvd24oc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICphZGRyLCB1MTYgcmVhc29uX2NvZGUpCitzdGF0aWMgaW50IHdwYV90ZGxzX3NlbmRfdGVhcmRvd24oc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICphZGRyLAorCQkJCSAgdTE2IHJlYXNvbl9jb2RlKQogewogCXN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyOwogCXN0cnVjdCB3cGFfdGRsc19mdGllICpmdGllOwpAQCAtNzM3LDEyICs3OTMsOSBAQAogCiAJLyogcmVxdWVzdCBkcml2ZXIgdG8gc2VuZCBUZWFyZG93biB1c2luZyB0aGlzIEZUSUUgKi8KIAl3cGFfdGRsc190cGtfc2VuZChzbSwgYWRkciwgV0xBTl9URExTX1RFQVJET1dOLCAwLAotCQkJICByZWFzb25fY29kZSwgcmJ1ZiwgcG9zIC0gcmJ1Zik7CisJCQkgIHJlYXNvbl9jb2RlLCAwLCByYnVmLCBwb3MgLSByYnVmKTsKIAlvc19mcmVlKHJidWYpOwogCi0JLyogY2xlYXIgdGhlIFBlZXJrZXkgc3RhdGVtYWNoaW5lICovCi0Jd3BhX3RkbHNfcGVlcl9mcmVlKHNtLCBwZWVyKTsKLQogCXJldHVybiAwOwogfQogCkBAIC03ODMsNyArODM2LDcgQEAKIH0KIAogCi12b2lkIHdwYV90ZGxzX2Rpc2FibGVfbGluayhzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdTggKmFkZHIpCit2b2lkIHdwYV90ZGxzX2Rpc2FibGVfdW5yZWFjaGFibGVfbGluayhzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdTggKmFkZHIpCiB7CiAJc3RydWN0IHdwYV90ZGxzX3BlZXIgKnBlZXI7CiAKQEAgLTc5Miw4ICs4NDUsNDcgQEAKIAkJCWJyZWFrOwogCX0KIAotCWlmIChwZWVyKQorCWlmICghcGVlciB8fCAhcGVlci0+dHBrX3N1Y2Nlc3MpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBQZWVyICIgTUFDU1RSCisJCQkgICAiIG5vdCBjb25uZWN0ZWQgLSBjYW5ub3QgdGVhcmRvd24gdW5yZWFjaGFibGUgbGluayIsCisJCQkgICBNQUMyU1RSKGFkZHIpKTsKKwkJcmV0dXJuOworCX0KKworCWlmICh3cGFfdGRsc19pc19leHRlcm5hbF9zZXR1cChzbSkpIHsKKwkJLyoKKwkJICogRGlzYWJsZSB0aGUgbGluaywgc2VuZCBhIHRlYXJkb3duIHBhY2tldCB0aHJvdWdoIHRoZQorCQkgKiBBUCwgYW5kIHRoZW4gcmVzZXQgbGluayBkYXRhLgorCQkgKi8KKwkJd3BhX3NtX3RkbHNfb3BlcihzbSwgVERMU19ESVNBQkxFX0xJTkssIGFkZHIpOworCQl3cGFfdGRsc19zZW5kX3RlYXJkb3duKHNtLCBhZGRyLAorCQkJCSAgICAgICBXTEFOX1JFQVNPTl9URExTX1RFQVJET1dOX1VOUkVBQ0hBQkxFKTsKKwkJd3BhX3RkbHNfcGVlcl9mcmVlKHNtLCBwZWVyKTsKKwl9IGVsc2UgewogCQl3cGFfdGRsc19kaXNhYmxlX3BlZXJfbGluayhzbSwgcGVlcik7CisJfQorfQorCisKK2NvbnN0IGNoYXIgKiB3cGFfdGRsc19nZXRfbGlua19zdGF0dXMoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICphZGRyKQoreworCXN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyOworCisJaWYgKHNtLT50ZGxzX2Rpc2FibGVkIHx8ICFzbS0+dGRsc19zdXBwb3J0ZWQpCisJCXJldHVybiAiZGlzYWJsZWQiOworCisJZm9yIChwZWVyID0gc20tPnRkbHM7IHBlZXI7IHBlZXIgPSBwZWVyLT5uZXh0KSB7CisJCWlmIChvc19tZW1jbXAocGVlci0+YWRkciwgYWRkciwgRVRIX0FMRU4pID09IDApCisJCQlicmVhazsKKwl9CisKKwlpZiAocGVlciA9PSBOVUxMKQorCQlyZXR1cm4gInBlZXIgZG9lcyBub3QgZXhpc3QiOworCisJaWYgKCFwZWVyLT50cGtfc3VjY2VzcykKKwkJcmV0dXJuICJwZWVyIG5vdCBjb25uZWN0ZWQiOworCisJcmV0dXJuICJjb25uZWN0ZWQiOwogfQogCiAKQEAgLTg4Niw3ICs5NzgsNyBAQAogCQkgICAiIChhY3Rpb249JXUgc3RhdHVzPSV1KSIsCiAJCSAgIE1BQzJTVFIoZHN0KSwgdGRsc19hY3Rpb24sIHN0YXR1cyk7CiAJcmV0dXJuIHdwYV90ZGxzX3Rwa19zZW5kKHNtLCBkc3QsIHRkbHNfYWN0aW9uLCBkaWFsb2dfdG9rZW4sIHN0YXR1cywKLQkJCQkgTlVMTCwgMCk7CisJCQkJIDAsIE5VTEwsIDApOwogfQogCiAKQEAgLTEwOTIsNyArMTE4NCw3IEBACiAJCSAgIE1BQzJTVFIocGVlci0+YWRkcikpOwogCiAJc3RhdHVzID0gd3BhX3RkbHNfdHBrX3NlbmQoc20sIHBlZXItPmFkZHIsIFdMQU5fVERMU19TRVRVUF9SRVFVRVNULAotCQkJCSAgIDEsIDAsIHJidWYsIHBvcyAtIHJidWYpOworCQkJCSAgIDEsIDAsIDAsIHJidWYsIHBvcyAtIHJidWYpOwogCW9zX2ZyZWUocmJ1Zik7CiAKIAlyZXR1cm4gc3RhdHVzOwpAQCAtMTE3MywxMCArMTI2NSwxNiBAQAogCS8qIGNvbXB1dGUgTUlDIGJlZm9yZSBzZW5kaW5nICovCiAJd3BhX3RkbHNfZnRpZV9taWMocGVlci0+dHBrLmtjaywgMiwgKHU4ICopIGxua2lkLCBwZWVyLT5yc25pZV9wLAogCQkJICAodTggKikgJnRpbWVvdXRpZSwgKHU4ICopIGZ0aWUsIGZ0aWUtPm1pYyk7CisjaWZkZWYgQ09ORklHX1RETFNfVEVTVElORworCWlmICh0ZGxzX3Rlc3RpbmcgJiBURExTX1RFU1RJTkdfV1JPTkdfTUlDKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogVGVzdGluZyAtIHVzZSB3cm9uZyBNSUMiKTsKKwkJZnRpZS0+bWljWzBdIF49IDB4MDE7CisJfQorI2VuZGlmIC8qIENPTkZJR19URExTX1RFU1RJTkcgKi8KIAogc2tpcF9pZXM6CiAJc3RhdHVzID0gd3BhX3RkbHNfdHBrX3NlbmQoc20sIHNyY19hZGRyLCBXTEFOX1RETFNfU0VUVVBfUkVTUE9OU0UsCi0JCQkJICAgZHRva2VuLCAwLCByYnVmLCBwb3MgLSByYnVmKTsKKwkJCQkgICBkdG9rZW4sIDAsIDAsIHJidWYsIHBvcyAtIHJidWYpOwogCW9zX2ZyZWUocmJ1Zik7CiAKIAlyZXR1cm4gc3RhdHVzOwpAQCAtMTE5NCw2ICsxMjkyLDcgQEAKIAlzdHJ1Y3Qgd3BhX3RkbHNfdGltZW91dGllIHRpbWVvdXRpZTsKIAl1MzIgbGlmZXRpbWU7CiAJaW50IHN0YXR1czsKKwl1MzIgcGVlcl9jYXBhYiA9IDA7CiAKIAlidWZfbGVuID0gMDsKIAlpZiAod3BhX3RkbHNfZ2V0X3ByaXZhY3koc20pKSB7CkBAIC0xMjU1LDEwICsxMzU0LDI0IEBACiAJLyogY29tcHV0ZSBNSUMgYmVmb3JlIHNlbmRpbmcgKi8KIAl3cGFfdGRsc19mdGllX21pYyhwZWVyLT50cGsua2NrLCAzLCAodTggKikgbG5raWQsIHBlZXItPnJzbmllX3AsCiAJCQkgICh1OCAqKSAmdGltZW91dGllLCAodTggKikgZnRpZSwgZnRpZS0+bWljKTsKKyNpZmRlZiBDT05GSUdfVERMU19URVNUSU5HCisJaWYgKHRkbHNfdGVzdGluZyAmIFRETFNfVEVTVElOR19XUk9OR19NSUMpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBUZXN0aW5nIC0gdXNlIHdyb25nIE1JQyIpOworCQlmdGllLT5taWNbMF0gXj0gMHgwMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1RETFNfVEVTVElORyAqLwogCiBza2lwX2llczoKKworCWlmIChwZWVyLT52aHRfY2FwYWJpbGl0aWVzKQorCQlwZWVyX2NhcGFiIHw9IFRETFNfUEVFUl9WSFQ7CisJaWYgKHBlZXItPmh0X2NhcGFiaWxpdGllcykKKwkJcGVlcl9jYXBhYiB8PSBURExTX1BFRVJfSFQ7CisJaWYgKHBlZXItPndtbV9jYXBhYmxlKQorCQlwZWVyX2NhcGFiIHw9IFRETFNfUEVFUl9XTU07CisKIAlzdGF0dXMgPSB3cGFfdGRsc190cGtfc2VuZChzbSwgc3JjX2FkZHIsIFdMQU5fVERMU19TRVRVUF9DT05GSVJNLAotCQkJCSAgIGR0b2tlbiwgMCwgcmJ1ZiwgcG9zIC0gcmJ1Zik7CisJCQkJICAgZHRva2VuLCAwLCBwZWVyX2NhcGFiLCByYnVmLCBwb3MgLSByYnVmKTsKIAlvc19mcmVlKHJidWYpOwogCiAJcmV0dXJuIHN0YXR1czsKQEAgLTEyNzMsNyArMTM4Niw3IEBACiAJCSAgICIocGVlciAiIE1BQ1NUUiAiKSIsIE1BQzJTVFIocGVlci0+YWRkcikpOwogCiAJcmV0dXJuIHdwYV90ZGxzX3Rwa19zZW5kKHNtLCBwZWVyLT5hZGRyLCBXTEFOX1RETFNfRElTQ09WRVJZX1JFU1BPTlNFLAotCQkJCSBkaWFsb2dfdG9rZW4sIDAsIE5VTEwsIDApOworCQkJCSBkaWFsb2dfdG9rZW4sIDAsIDAsIE5VTEwsIDApOwogfQogCiAKQEAgLTEyOTksMTAgKzE0MTIsMTcgQEAKIAogCWRpYWxvZ190b2tlbiA9IGJ1ZltzaXplb2Yoc3RydWN0IHdwYV90ZGxzX2ZyYW1lKV07CiAKKwkvKgorCSAqIFNvbWUgQVBzIHdpbGwgdGFjayBvbiBhIHdlaXJkIElFIHRvIHRoZSBlbmQgb2YgYSBURExTCisJICogZGlzY292ZXJ5IHJlcXVlc3QgcGFja2V0LiBUaGlzIG5lZWRuJ3QgZmFpbCB0aGUgcmVzcG9uc2UsCisJICogc2luY2UgdGhlIHJlcXVpcmVkIElFIGFyZSB2ZXJpZmllZCBzZXBhcmF0ZWx5LgorCSAqLwogCWlmICh3cGFfc3VwcGxpY2FudF9wYXJzZV9pZXMoYnVmICsgc2l6ZW9mKHN0cnVjdCB3cGFfdGRsc19mcmFtZSkgKyAxLAogCQkJCSAgICAgbGVuIC0gKHNpemVvZihzdHJ1Y3Qgd3BhX3RkbHNfZnJhbWUpICsgMSksCi0JCQkJICAgICAma2RlKSA8IDApCi0JCXJldHVybiAtMTsKKwkJCQkgICAgICZrZGUpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJURExTOiBGYWlsZWQgdG8gcGFyc2UgSUVzIGluIERpc2NvdmVyeSBSZXF1ZXN0IC0gaWdub3JlIGFzIGFuIGludGVyb3Agd29ya2Fyb3VuZCIpOworCX0KIAogCWlmICgha2RlLmxua2lkKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogTGluayBJRCBub3QgZm91bmQgaW4gRGlzY292ZXJ5ICIKQEAgLTEzMzQsNyArMTQ1NCw3IEBACiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBTZW5kaW5nIERpc2NvdmVyeSBSZXF1ZXN0IHRvIHBlZXIgIgogCQkgICBNQUNTVFIsIE1BQzJTVFIoYWRkcikpOwogCXJldHVybiB3cGFfdGRsc190cGtfc2VuZChzbSwgYWRkciwgV0xBTl9URExTX0RJU0NPVkVSWV9SRVFVRVNULAotCQkJCSAxLCAwLCBOVUxMLCAwKTsKKwkJCQkgMSwgMCwgMCwgTlVMTCwgMCk7CiB9CiAKIApAQCAtMTQzNCw2ICsxNTU0LDEwMCBAQAogfQogCiAKK3N0YXRpYyBpbnQgY29weV9wZWVyX3dtbV9jYXBhYihjb25zdCBzdHJ1Y3Qgd3BhX2VhcG9sX2llX3BhcnNlICprZGUsCisJCQkgICAgICAgc3RydWN0IHdwYV90ZGxzX3BlZXIgKnBlZXIpCit7CisJc3RydWN0IHdtbV9pbmZvcm1hdGlvbl9lbGVtZW50ICp3bW07CisKKwlpZiAoIWtkZS0+d21tKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogTm8gc3VwcG9ydGVkIFdNTSBjYXBhYmlsaXRpZXMgcmVjZWl2ZWQiKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKGtkZS0+d21tX2xlbiA8IHNpemVvZihzdHJ1Y3Qgd21tX2luZm9ybWF0aW9uX2VsZW1lbnQpKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogSW52YWxpZCBzdXBwb3J0ZWQgV01NIGNhcGFiaWxpdGllcyByZWNlaXZlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJd21tID0gKHN0cnVjdCB3bW1faW5mb3JtYXRpb25fZWxlbWVudCAqKSBrZGUtPndtbTsKKwlwZWVyLT5xb3NfaW5mbyA9IHdtbS0+cW9zX2luZm87CisKKwlwZWVyLT53bW1fY2FwYWJsZSA9IDE7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRETFM6IFBlZXIgV01NIFFPUyBJbmZvIDB4JXgiLCBwZWVyLT5xb3NfaW5mbyk7CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBjb3B5X3BlZXJfc3VwcF9jaGFubmVscyhjb25zdCBzdHJ1Y3Qgd3BhX2VhcG9sX2llX3BhcnNlICprZGUsCisJCQkJICAgc3RydWN0IHdwYV90ZGxzX3BlZXIgKnBlZXIpCit7CisJaWYgKCFrZGUtPnN1cHBfY2hhbm5lbHMpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBObyBzdXBwb3J0ZWQgY2hhbm5lbHMgcmVjZWl2ZWQiKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKCFwZWVyLT5zdXBwX2NoYW5uZWxzIHx8CisJICAgIHBlZXItPnN1cHBfY2hhbm5lbHNfbGVuIDwga2RlLT5zdXBwX2NoYW5uZWxzX2xlbikgeworCQlvc19mcmVlKHBlZXItPnN1cHBfY2hhbm5lbHMpOworCQlwZWVyLT5zdXBwX2NoYW5uZWxzID0gb3NfemFsbG9jKGtkZS0+c3VwcF9jaGFubmVsc19sZW4pOworCQlpZiAocGVlci0+c3VwcF9jaGFubmVscyA9PSBOVUxMKQorCQkJcmV0dXJuIC0xOworCX0KKworCXBlZXItPnN1cHBfY2hhbm5lbHNfbGVuID0ga2RlLT5zdXBwX2NoYW5uZWxzX2xlbjsKKworCW9zX21lbWNweShwZWVyLT5zdXBwX2NoYW5uZWxzLCBrZGUtPnN1cHBfY2hhbm5lbHMsCisJCSAgcGVlci0+c3VwcF9jaGFubmVsc19sZW4pOworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlRETFM6IFBlZXIgU3VwcG9ydGVkIENoYW5uZWxzIiwKKwkJICAgICh1OCAqKSBwZWVyLT5zdXBwX2NoYW5uZWxzLCBwZWVyLT5zdXBwX2NoYW5uZWxzX2xlbik7CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBjb3B5X3BlZXJfc3VwcF9vcGVyX2NsYXNzZXMoY29uc3Qgc3RydWN0IHdwYV9lYXBvbF9pZV9wYXJzZSAqa2RlLAorCQkJCSAgICAgICBzdHJ1Y3Qgd3BhX3RkbHNfcGVlciAqcGVlcikKK3sKKwlpZiAoIWtkZS0+c3VwcF9vcGVyX2NsYXNzZXMpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBObyBzdXBwb3J0ZWQgb3BlcmF0aW5nIGNsYXNzZXMgcmVjZWl2ZWQiKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKCFwZWVyLT5zdXBwX29wZXJfY2xhc3NlcyB8fAorCSAgICBwZWVyLT5zdXBwX29wZXJfY2xhc3Nlc19sZW4gPCBrZGUtPnN1cHBfb3Blcl9jbGFzc2VzX2xlbikgeworCQlvc19mcmVlKHBlZXItPnN1cHBfb3Blcl9jbGFzc2VzKTsKKwkJcGVlci0+c3VwcF9vcGVyX2NsYXNzZXMgPSBvc196YWxsb2Moa2RlLT5zdXBwX29wZXJfY2xhc3Nlc19sZW4pOworCQlpZiAocGVlci0+c3VwcF9vcGVyX2NsYXNzZXMgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwl9CisKKwlwZWVyLT5zdXBwX29wZXJfY2xhc3Nlc19sZW4gPSBrZGUtPnN1cHBfb3Blcl9jbGFzc2VzX2xlbjsKKwlvc19tZW1jcHkocGVlci0+c3VwcF9vcGVyX2NsYXNzZXMsIGtkZS0+c3VwcF9vcGVyX2NsYXNzZXMsCisJCSAgcGVlci0+c3VwcF9vcGVyX2NsYXNzZXNfbGVuKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJURExTOiBQZWVyIFN1cHBvcnRlZCBPcGVyYXRpbmcgQ2xhc3NlcyIsCisJCSAgICAodTggKikgcGVlci0+c3VwcF9vcGVyX2NsYXNzZXMsCisJCSAgICBwZWVyLT5zdXBwX29wZXJfY2xhc3Nlc19sZW4pOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgd3BhX3RkbHNfYWRkc2V0X3BlZXIoc3RydWN0IHdwYV9zbSAqc20sIHN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyLAorCQkJCWludCBhZGQpCit7CisJcmV0dXJuIHdwYV9zbV90ZGxzX3BlZXJfYWRkc2V0KHNtLCBwZWVyLT5hZGRyLCBhZGQsIHBlZXItPmFpZCwKKwkJCQkgICAgICAgcGVlci0+Y2FwYWJpbGl0eSwKKwkJCQkgICAgICAgcGVlci0+c3VwcF9yYXRlcywgcGVlci0+c3VwcF9yYXRlc19sZW4sCisJCQkJICAgICAgIHBlZXItPmh0X2NhcGFiaWxpdGllcywKKwkJCQkgICAgICAgcGVlci0+dmh0X2NhcGFiaWxpdGllcywKKwkJCQkgICAgICAgcGVlci0+cW9zX2luZm8sIHBlZXItPmV4dF9jYXBhYiwKKwkJCQkgICAgICAgcGVlci0+ZXh0X2NhcGFiX2xlbiwKKwkJCQkgICAgICAgcGVlci0+c3VwcF9jaGFubmVscywKKwkJCQkgICAgICAgcGVlci0+c3VwcF9jaGFubmVsc19sZW4sCisJCQkJICAgICAgIHBlZXItPnN1cHBfb3Blcl9jbGFzc2VzLAorCQkJCSAgICAgICBwZWVyLT5zdXBwX29wZXJfY2xhc3Nlc19sZW4pOworfQorCisKIHN0YXRpYyBpbnQgd3BhX3RkbHNfcHJvY2Vzc190cGtfbTEoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICpzcmNfYWRkciwKIAkJCQkgICBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKQogewpAQCAtMTQ4MSwxNiArMTY5NSwxNiBAQAogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBURExTIFNldHVwIFJlcXVlc3Qgd2hpbGUgIgogCQkJCSAgICJkaXJlY3QgbGluayBpcyBlbmFibGVkIC0gdGVhciBkb3duIHRoZSAiCiAJCQkJICAgIm9sZCBsaW5rIGZpcnN0Iik7Ci0JCQl3cGFfdGRsc19kaXNhYmxlX3BlZXJfbGluayhzbSwgcGVlcik7Ci0JCX0KLQotCQkvKgotCQkgKiBBbiBlbnRyeSBpcyBhbHJlYWR5IHByZXNlbnQsIHNvIGNoZWNrIGlmIHdlIGFscmVhZHkgc2VudCBhCi0JCSAqIFRETFMgU2V0dXAgUmVxdWVzdC4gSWYgc28sIGNvbXBhcmUgTUFDIGFkZHJlc3NlcyBhbmQgbGV0IHRoZQotCQkgKiBTVEEgd2l0aCB0aGUgbG93ZXIgTUFDIGFkZHJlc3MgY29udGludWUgYXMgdGhlIGluaXRpYXRvci4KLQkJICogVGhlIG90aGVyIG5lZ290aWF0aW9uIGlzIHRlcm1pbmF0ZWQuCi0JCSAqLwotCQlpZiAocGVlci0+aW5pdGlhdG9yKSB7CisJCQl3cGFfc21fdGRsc19vcGVyKHNtLCBURExTX0RJU0FCTEVfTElOSywgcGVlci0+YWRkcik7CisJCQl3cGFfdGRsc19wZWVyX2NsZWFyKHNtLCBwZWVyKTsKKwkJfSBlbHNlIGlmIChwZWVyLT5pbml0aWF0b3IpIHsKKwkJCS8qCisJCQkgKiBBbiBlbnRyeSBpcyBhbHJlYWR5IHByZXNlbnQsIHNvIGNoZWNrIGlmIHdlIGFscmVhZHkKKwkJCSAqIHNlbnQgYSBURExTIFNldHVwIFJlcXVlc3QuIElmIHNvLCBjb21wYXJlIE1BQworCQkJICogYWRkcmVzc2VzIGFuZCBsZXQgdGhlIFNUQSB3aXRoIHRoZSBsb3dlciBNQUMgYWRkcmVzcworCQkJICogY29udGludWUgYXMgdGhlIGluaXRpYXRvci4gVGhlIG90aGVyIG5lZ290aWF0aW9uIGlzCisJCQkgKiB0ZXJtaW5hdGVkLgorCQkJICovCiAJCQlpZiAob3NfbWVtY21wKHNtLT5vd25fYWRkciwgc3JjX2FkZHIsIEVUSF9BTEVOKSA8IDApIHsKIAkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRETFM6IERpc2NhcmQgcmVxdWVzdCAiCiAJCQkJCSAgICJmcm9tIHBlZXIgd2l0aCBoaWdoZXIgYWRkcmVzcyAiCkBAIC0xNTAyLDcgKzE3MTYsOSBAQAogCQkJCQkgICBNQUNTVFIgIiAodGVybWluYXRlIHByZXZpb3VzbHkgIgogCQkJCQkgICAiaW5pdGlhdGVkIG5lZ290aWF0aW9uIiwKIAkJCQkJICAgTUFDMlNUUihzcmNfYWRkcikpOwotCQkJCXdwYV90ZGxzX2Rpc2FibGVfcGVlcl9saW5rKHNtLCBwZWVyKTsKKwkJCQl3cGFfc21fdGRsc19vcGVyKHNtLCBURExTX0RJU0FCTEVfTElOSywKKwkJCQkJCSBwZWVyLT5hZGRyKTsKKwkJCQl3cGFfdGRsc19wZWVyX2NsZWFyKHNtLCBwZWVyKTsKIAkJCX0KIAkJfQogCX0KQEAgLTE1NDYsOCArMTc2MiwxOCBAQAogCWlmIChjb3B5X3BlZXJfZXh0X2NhcGFiKCZrZGUsIHBlZXIpIDwgMCkKIAkJZ290byBlcnJvcjsKIAorCWlmIChjb3B5X3BlZXJfc3VwcF9jaGFubmVscygma2RlLCBwZWVyKSA8IDApCisJCWdvdG8gZXJyb3I7CisKKwlpZiAoY29weV9wZWVyX3N1cHBfb3Blcl9jbGFzc2VzKCZrZGUsIHBlZXIpIDwgMCkKKwkJZ290byBlcnJvcjsKKwogCXBlZXItPnFvc19pbmZvID0ga2RlLnFvc2luZm87CiAKKwkvKiBPdmVyd3JpdGUgd2l0aCB0aGUgcW9zX2luZm8gb2J0YWluZWQgaW4gV01NIElFICovCisJaWYgKGNvcHlfcGVlcl93bW1fY2FwYWIoJmtkZSwgcGVlcikgPCAwKQorCQlnb3RvIGVycm9yOworCiAJcGVlci0+YWlkID0ga2RlLmFpZDsKIAogI2lmZGVmIENPTkZJR19URExTX1RFU1RJTkcKQEAgLTE2ODIsNyArMTkwOCw2IEBACiAJCWlmIChvc19nZXRfcmFuZG9tKHBlZXItPnJub25jZSwgV1BBX05PTkNFX0xFTikpIHsKIAkJCXdwYV9tc2coc20tPmN0eC0+Y3R4LCBNU0dfV0FSTklORywKIAkJCQkiVERMUzogRmFpbGVkIHRvIGdldCByYW5kb20gZGF0YSBmb3IgcmVzcG9uZGVyIG5vbmNlIik7Ci0JCQl3cGFfdGRsc19wZWVyX2ZyZWUoc20sIHBlZXIpOwogCQkJZ290byBlcnJvcjsKIAkJfQogCX0KQEAgLTE3MzcsMTQgKzE5NjIsMTUgQEAKIAl3cGFfdGRsc19nZW5lcmF0ZV90cGsocGVlciwgc20tPm93bl9hZGRyLCBzbS0+YnNzaWQpOwogCiBza2lwX3Jzbl9jaGVjazoKLQkvKiBhZGQgdGhlIHBlZXIgdG8gdGhlIGRyaXZlciBhcyBhICJzZXR1cCBpbiBwcm9ncmVzcyIgcGVlciAqLwotCXdwYV9zbV90ZGxzX3BlZXJfYWRkc2V0KHNtLCBwZWVyLT5hZGRyLCAxLCAwLCAwLCBOVUxMLCAwLCBOVUxMLCBOVUxMLCAwLAotCQkJCU5VTEwsIDApOworCS8qIGFkZCBzdXBwb3J0ZWQgcmF0ZXMsIGNhcGFiaWxpdGllcywgYW5kIHFvc19pbmZvIHRvIHRoZSBURExTIHBlZXIgKi8KKwlpZiAod3BhX3RkbHNfYWRkc2V0X3BlZXIoc20sIHBlZXIsIDEpIDwgMCkKKwkJZ290byBlcnJvcjsKKwogCXBlZXItPnRwa19pbl9wcm9ncmVzcyA9IDE7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRETFM6IFNlbmRpbmcgVERMUyBTZXR1cCBSZXNwb25zZSAvIFRQSyBNMiIpOwogCWlmICh3cGFfdGRsc19zZW5kX3Rwa19tMihzbSwgc3JjX2FkZHIsIGR0b2tlbiwgbG5raWQsIHBlZXIpIDwgMCkgewotCQl3cGFfdGRsc19kaXNhYmxlX3BlZXJfbGluayhzbSwgcGVlcik7CisJCXdwYV9zbV90ZGxzX29wZXIoc20sIFRETFNfRElTQUJMRV9MSU5LLCBwZWVyLT5hZGRyKTsKIAkJZ290byBlcnJvcjsKIAl9CiAKQEAgLTE3NTMsNiArMTk3OSw4IEBACiBlcnJvcjoKIAl3cGFfdGRsc19zZW5kX2Vycm9yKHNtLCBzcmNfYWRkciwgV0xBTl9URExTX1NFVFVQX1JFU1BPTlNFLCBkdG9rZW4sCiAJCQkgICAgc3RhdHVzKTsKKwlpZiAocGVlcikKKwkJd3BhX3RkbHNfcGVlcl9mcmVlKHNtLCBwZWVyKTsKIAlyZXR1cm4gLTE7CiB9CiAKQEAgLTE3ODEsMTYgKzIwMDksNiBAQAogI2VuZGlmIC8qIENPTkZJR19URExTX1RFU1RJTkcgKi8KIAl9CiAKLQkvKiBhZGQgc3VwcG9ydGVkIHJhdGVzLCBjYXBhYmlsaXRpZXMsIGFuZCBxb3NfaW5mbyB0byB0aGUgVERMUyBwZWVyICovCi0JaWYgKHdwYV9zbV90ZGxzX3BlZXJfYWRkc2V0KHNtLCBwZWVyLT5hZGRyLCAwLCBwZWVyLT5haWQsCi0JCQkJICAgIHBlZXItPmNhcGFiaWxpdHksCi0JCQkJICAgIHBlZXItPnN1cHBfcmF0ZXMsIHBlZXItPnN1cHBfcmF0ZXNfbGVuLAotCQkJCSAgICBwZWVyLT5odF9jYXBhYmlsaXRpZXMsCi0JCQkJICAgIHBlZXItPnZodF9jYXBhYmlsaXRpZXMsCi0JCQkJICAgIHBlZXItPnFvc19pbmZvLCBwZWVyLT5leHRfY2FwYWIsCi0JCQkJICAgIHBlZXItPmV4dF9jYXBhYl9sZW4pIDwgMCkKLQkJcmV0dXJuIC0xOwotCiAJaWYgKHBlZXItPnJlY29uZmlnX2tleSAmJiB3cGFfdGRsc19zZXRfa2V5KHNtLCBwZWVyKSA8IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRETFM6IENvdWxkIG5vdCBjb25maWd1cmUga2V5IHRvIHRoZSAiCiAJCQkgICAiZHJpdmVyIik7CkBAIC0xODE3LDcgKzIwMzUsNyBAQAogCWludCBpZWxlbjsKIAl1MTYgc3RhdHVzOwogCWNvbnN0IHU4ICpwb3M7Ci0JaW50IHJldDsKKwlpbnQgcmV0ID0gMDsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogUmVjZWl2ZWQgVERMUyBTZXR1cCBSZXNwb25zZSAvIFRQSyBNMiAiCiAJCSAgICIoUGVlciAiIE1BQ1NUUiAiKSIsIE1BQzJTVFIoc3JjX2FkZHIpKTsKQEAgLTE5MTYsOCArMjEzNCwxOCBAQAogCWlmIChjb3B5X3BlZXJfZXh0X2NhcGFiKCZrZGUsIHBlZXIpIDwgMCkKIAkJZ290byBlcnJvcjsKIAorCWlmIChjb3B5X3BlZXJfc3VwcF9jaGFubmVscygma2RlLCBwZWVyKSA8IDApCisJCWdvdG8gZXJyb3I7CisKKwlpZiAoY29weV9wZWVyX3N1cHBfb3Blcl9jbGFzc2VzKCZrZGUsIHBlZXIpIDwgMCkKKwkJZ290byBlcnJvcjsKKwogCXBlZXItPnFvc19pbmZvID0ga2RlLnFvc2luZm87CiAKKwkvKiBPdmVyd3JpdGUgd2l0aCB0aGUgcW9zX2luZm8gb2J0YWluZWQgaW4gV01NIElFICovCisJaWYgKGNvcHlfcGVlcl93bW1fY2FwYWIoJmtkZSwgcGVlcikgPCAwKQorCQlnb3RvIGVycm9yOworCiAJcGVlci0+YWlkID0ga2RlLmFpZDsKIAogCWlmICghd3BhX3RkbHNfZ2V0X3ByaXZhY3koc20pKSB7CkBAIC0xOTM1LDYgKzIxNjMsMTMgQEAKIAl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJURExTOiBSU04gSUUgUmVjZWl2ZWQgZnJvbSBUUEsgTTIiLAogCQkgICAga2RlLnJzbl9pZSwga2RlLnJzbl9pZV9sZW4pOwogCisJaWYgKGtkZS5yc25faWVfbGVuID4gVERMU19NQVhfSUVfTEVOKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkgICAiVERMUzogVG9vIGxvbmcgUmVzcG9uZGVyIFJTTiBJRSBpbiBUUEsgTTIiKTsKKwkJc3RhdHVzID0gV0xBTl9TVEFUVVNfSU5WQUxJRF9SU05JRTsKKwkJZ290byBlcnJvcjsKKwl9CisKIAkvKgogCSAqIEZJWDogYml0d2lzZSBjb21wYXJpc29uIG9mIFJTTiBJRSBpcyBub3QgdGhlIGNvcnJlY3Qgd2F5IG9mCiAJICogdmFsaWRhdGlvbiB0aGlzLiBJdCBjYW4gYmUgZGlmZmVyZW50LCBidXQgY2VydGFpbiBmaWVsZHMgbXVzdApAQCAtMjAyNywxOCArMjI2MiwyOCBAQAogc2tpcF9yc246CiAJcGVlci0+ZHRva2VuID0gZHRva2VuOwogCisJLyogYWRkIHN1cHBvcnRlZCByYXRlcywgY2FwYWJpbGl0aWVzLCBhbmQgcW9zX2luZm8gdG8gdGhlIFRETFMgcGVlciAqLworCWlmICh3cGFfdGRsc19hZGRzZXRfcGVlcihzbSwgcGVlciwgMCkgPCAwKQorCQlnb3RvIGVycm9yOworCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBTZW5kaW5nIFRETFMgU2V0dXAgQ29uZmlybSAvICIKIAkJICAgIlRQSyBIYW5kc2hha2UgTWVzc2FnZSAzIik7Ci0JaWYgKHdwYV90ZGxzX3NlbmRfdHBrX20zKHNtLCBzcmNfYWRkciwgZHRva2VuLCBsbmtpZCwgcGVlcikgPCAwKSB7Ci0JCXdwYV90ZGxzX2Rpc2FibGVfcGVlcl9saW5rKHNtLCBwZWVyKTsKLQkJcmV0dXJuIC0xOwotCX0KKwlpZiAod3BhX3RkbHNfc2VuZF90cGtfbTMoc20sIHNyY19hZGRyLCBkdG9rZW4sIGxua2lkLCBwZWVyKSA8IDApCisJCWdvdG8gZXJyb3I7CiAKLQlyZXQgPSB3cGFfdGRsc19lbmFibGVfbGluayhzbSwgcGVlcik7Ci0JaWYgKHJldCA8IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBDb3VsZCBub3QgZW5hYmxlIGxpbmsiKTsKLQkJd3BhX3RkbHNfZG9fdGVhcmRvd24oc20sIHBlZXIsCi0JCQkJICAgICBXTEFOX1JFQVNPTl9URExTX1RFQVJET1dOX1VOU1BFQ0lGSUVEKTsKKwlpZiAoIXBlZXItPnRwa19zdWNjZXNzKSB7CisJCS8qCisJCSAqIEVuYWJsZSBMaW5rIG9ubHkgd2hlbiB0cGtfc3VjY2VzcyBpcyAwLCBzaWduaWZ5aW5nIHRoYXQgdGhpcworCQkgKiBwcm9jZXNzaW5nIG9mIFRQSyBNMiBmcmFtZSBpcyBub3QgYmVjYXVzZSBvZiBhIHJldHJhbnNtaXNzaW9uCisJCSAqIGR1cmluZyBURExTIHNldHVwIGhhbmRzaGFrZS4KKwkJICovCisJCXJldCA9IHdwYV90ZGxzX2VuYWJsZV9saW5rKHNtLCBwZWVyKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogQ291bGQgbm90IGVuYWJsZSBsaW5rIik7CisJCQl3cGFfdGRsc19kb190ZWFyZG93bigKKwkJCQlzbSwgcGVlciwKKwkJCQlXTEFOX1JFQVNPTl9URExTX1RFQVJET1dOX1VOU1BFQ0lGSUVEKTsKKwkJfQogCX0KIAlyZXR1cm4gcmV0OwogCkBAIC0yMDYyLDcgKzIzMDcsNyBAQAogCXUxNiBzdGF0dXM7CiAJY29uc3QgdTggKnBvczsKIAl1MzIgbGlmZXRpbWU7Ci0JaW50IHJldDsKKwlpbnQgcmV0ID0gMDsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogUmVjZWl2ZWQgVERMUyBTZXR1cCBDb25maXJtIC8gVFBLIE0zICIKIAkJICAgIihQZWVyICIgTUFDU1RSICIpIiwgTUFDMlNUUihzcmNfYWRkcikpOwpAQCAtMjA5Miw5ICsyMzM3LDE2IEBACiAJcG9zICs9IDIgLyogc3RhdHVzIGNvZGUgKi8gKyAxIC8qIGRpYWxvZyB0b2tlbiAqLzsKIAogCWllbGVuID0gbGVuIC0gKHBvcyAtIGJ1Zik7IC8qIHN0YXJ0IG9mIElFIGluIGJ1ZiAqLworCisJLyoKKwkgKiBEb24ndCByZWplY3QgdGhlIG1lc3NhZ2UgaWYgZmFpbGluZyB0byBwYXJzZSBJRXMuIFRoZSBJRXMgd2UgbmVlZCBhcmUKKwkgKiBleHBsaWNpdGx5IGNoZWNrZWQgYmVsb3cuIFNvbWUgQVBzIHBpZ2d5LWJhY2sgYnJva2VuIElFcyB0byB0aGUgZW5kCisJICogb2YgYSBURExTIENvbmZpcm0gcGFja2V0LCB3aGljaCB3aWxsIGZhaWwgdGhlIGxpbmsgaWYgd2UgZG9uJ3QgaWdub3JlCisJICogdGhpcyBlcnJvci4KKwkgKi8KIAlpZiAod3BhX3N1cHBsaWNhbnRfcGFyc2VfaWVzKChjb25zdCB1OCAqKSBwb3MsIGllbGVuLCAma2RlKSA8IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRETFM6IEZhaWxlZCB0byBwYXJzZSBLREVzIGluIFRQSyBNMyIpOwotCQlnb3RvIGVycm9yOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJURExTOiBGYWlsZWQgdG8gcGFyc2UgS0RFcyBpbiBUUEsgTTMgLSBpZ25vcmUgYXMgYW4gaW50ZXJvcCB3b3JrYXJvdW5kIik7CiAJfQogCiAJaWYgKGtkZS5sbmtpZCA9PSBOVUxMIHx8IGtkZS5sbmtpZF9sZW4gPCAzICogRVRIX0FMRU4pIHsKQEAgLTIxNzksMTUgKzI0MzEsMjUgQEAKIAl9CiAKIHNraXBfcnNuOgotCXJldCA9IHdwYV90ZGxzX2VuYWJsZV9saW5rKHNtLCBwZWVyKTsKLQlpZiAocmV0IDwgMCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRETFM6IENvdWxkIG5vdCBlbmFibGUgbGluayIpOwotCQl3cGFfdGRsc19kb190ZWFyZG93bihzbSwgcGVlciwKLQkJCQkgICAgIFdMQU5fUkVBU09OX1RETFNfVEVBUkRPV05fVU5TUEVDSUZJRUQpOworCS8qIGFkZCBzdXBwb3J0ZWQgcmF0ZXMsIGNhcGFiaWxpdGllcywgYW5kIHFvc19pbmZvIHRvIHRoZSBURExTIHBlZXIgKi8KKwlpZiAod3BhX3RkbHNfYWRkc2V0X3BlZXIoc20sIHBlZXIsIDApIDwgMCkKKwkJZ290byBlcnJvcjsKKworCWlmICghcGVlci0+dHBrX3N1Y2Nlc3MpIHsKKwkJLyoKKwkJICogRW5hYmxlIExpbmsgb25seSB3aGVuIHRwa19zdWNjZXNzIGlzIDAsIHNpZ25pZnlpbmcgdGhhdCB0aGlzCisJCSAqIHByb2Nlc3Npbmcgb2YgVFBLIE0zIGZyYW1lIGlzIG5vdCBiZWNhdXNlIG9mIGEgcmV0cmFuc21pc3Npb24KKwkJICogZHVyaW5nIFRETFMgc2V0dXAgaGFuZHNoYWtlLgorCQkgKi8KKwkJcmV0ID0gd3BhX3RkbHNfZW5hYmxlX2xpbmsoc20sIHBlZXIpOworCQlpZiAocmV0IDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBDb3VsZCBub3QgZW5hYmxlIGxpbmsiKTsKKwkJCWdvdG8gZXJyb3I7CisJCX0KIAl9CiAJcmV0dXJuIHJldDsKIGVycm9yOgotCXdwYV90ZGxzX2Rpc2FibGVfcGVlcl9saW5rKHNtLCBwZWVyKTsKKwl3cGFfdGRsc19kb190ZWFyZG93bihzbSwgcGVlciwgV0xBTl9SRUFTT05fVERMU19URUFSRE9XTl9VTlNQRUNJRklFRCk7CiAJcmV0dXJuIC0xOwogfQogCkBAIC0yMjUwLDggKzI1MTIsMTEgQEAKIAlwZWVyLT5pbml0aWF0b3IgPSAxOwogCiAJLyogYWRkIHRoZSBwZWVyIHRvIHRoZSBkcml2ZXIgYXMgYSAic2V0dXAgaW4gcHJvZ3Jlc3MiIHBlZXIgKi8KLQl3cGFfc21fdGRsc19wZWVyX2FkZHNldChzbSwgcGVlci0+YWRkciwgMSwgMCwgMCwgTlVMTCwgMCwgTlVMTCwgTlVMTCwgMCwKLQkJCQlOVUxMLCAwKTsKKwlpZiAod3BhX3NtX3RkbHNfcGVlcl9hZGRzZXQoc20sIHBlZXItPmFkZHIsIDEsIDAsIDAsIE5VTEwsIDAsIE5VTEwsCisJCQkJICAgIE5VTEwsIDAsIE5VTEwsIDAsIE5VTEwsIDAsIE5VTEwsIDApKSB7CisJCXdwYV90ZGxzX2Rpc2FibGVfcGVlcl9saW5rKHNtLCBwZWVyKTsKKwkJcmV0dXJuIC0xOworCX0KIAogCXBlZXItPnRwa19pbl9wcm9ncmVzcyA9IDE7CiAKQEAgLTIyODQsNyArMjU0OSw4IEBACiAJCSAqIERpc2FibGUgcHJldmlvdXMgbGluayB0byBhbGxvdyByZW5lZ290aWF0aW9uIHRvIGJlIGNvbXBsZXRlZAogCQkgKiBvbiBBUCBwYXRoLgogCQkgKi8KLQkJd3BhX3NtX3RkbHNfb3BlcihzbSwgVERMU19ESVNBQkxFX0xJTkssIHBlZXItPmFkZHIpOworCQl3cGFfdGRsc19kb190ZWFyZG93bihzbSwgcGVlciwKKwkJCQkgICAgIFdMQU5fUkVBU09OX1RETFNfVEVBUkRPV05fVU5TUEVDSUZJRUQpOwogCX0KIH0KIApAQCAtMjQwMCwyMiArMjY2NiwyMyBAQAogCiB2b2lkIHdwYV90ZGxzX3RlYXJkb3duX3BlZXJzKHN0cnVjdCB3cGFfc20gKnNtKQogewotCXN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyOworCXN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyLCAqdG1wOwogCiAJcGVlciA9IHNtLT50ZGxzOwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiBUZWFyIGRvd24gcGVlcnMiKTsKIAogCXdoaWxlIChwZWVyKSB7CisJCXRtcCA9IHBlZXItPm5leHQ7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogVGVhciBkb3duIHBlZXIgIiBNQUNTVFIsCiAJCQkgICBNQUMyU1RSKHBlZXItPmFkZHIpKTsKIAkJaWYgKHNtLT50ZGxzX2V4dGVybmFsX3NldHVwKQotCQkJd3BhX3RkbHNfc2VuZF90ZWFyZG93bihzbSwgcGVlci0+YWRkciwKLQkJCQkJICAgICAgIFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HKTsKKwkJCXdwYV90ZGxzX2RvX3RlYXJkb3duKHNtLCBwZWVyLAorCQkJCQkgICAgIFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HKTsKIAkJZWxzZQogCQkJd3BhX3NtX3RkbHNfb3BlcihzbSwgVERMU19URUFSRE9XTiwgcGVlci0+YWRkcik7CiAKLQkJcGVlciA9IHBlZXItPm5leHQ7CisJCXBlZXIgPSB0bXA7CiAJfQogfQogCkBAIC0yNDI1LDcgKzI2OTIsNiBAQAogCXN0cnVjdCB3cGFfdGRsc19wZWVyICpwZWVyLCAqdG1wOwogCiAJcGVlciA9IHNtLT50ZGxzOwotCXNtLT50ZGxzID0gTlVMTDsKIAogCXdoaWxlIChwZWVyKSB7CiAJCWludCByZXM7CkBAIC0yNDM0LDcgKzI3MDAsNiBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRETFM6IFJlbW92ZSBwZWVyICIgTUFDU1RSICIgKHJlcz0lZCkiLAogCQkJICAgTUFDMlNUUihwZWVyLT5hZGRyKSwgcmVzKTsKIAkJd3BhX3RkbHNfcGVlcl9mcmVlKHNtLCBwZWVyKTsKLQkJb3NfZnJlZShwZWVyKTsKIAkJcGVlciA9IHRtcDsKIAl9CiB9CmRpZmYgLS1naXQgYS9zcmMvcnNuX3N1cHAvd3BhLmMgYi9zcmMvcnNuX3N1cHAvd3BhLmMKaW5kZXggMjkyMjU1Yy4uZDZmYjZhMSAxMDA2NDQKLS0tIGEvc3JjL3Jzbl9zdXBwL3dwYS5jCisrKyBiL3NyYy9yc25fc3VwcC93cGEuYwpAQCAtODksNyArODksMTAgQEAKIAlpbnQga2V5X2luZm8sIHZlcjsKIAl1OCBic3NpZFtFVEhfQUxFTl0sICpyYnVmOwogCi0JaWYgKHdwYV9rZXlfbWdtdF9mdChzbS0+a2V5X21nbXQpIHx8IHdwYV9rZXlfbWdtdF9zaGEyNTYoc20tPmtleV9tZ210KSkKKwlpZiAoc20tPmtleV9tZ210ID09IFdQQV9LRVlfTUdNVF9PU0VOKQorCQl2ZXIgPSBXUEFfS0VZX0lORk9fVFlQRV9BS01fREVGSU5FRDsKKwllbHNlIGlmICh3cGFfa2V5X21nbXRfZnQoc20tPmtleV9tZ210KSB8fAorCQkgd3BhX2tleV9tZ210X3NoYTI1NihzbS0+a2V5X21nbXQpKQogCQl2ZXIgPSBXUEFfS0VZX0lORk9fVFlQRV9BRVNfMTI4X0NNQUM7CiAJZWxzZSBpZiAoc20tPnBhaXJ3aXNlX2NpcGhlciAhPSBXUEFfQ0lQSEVSX1RLSVApCiAJCXZlciA9IFdQQV9LRVlfSU5GT19UWVBFX0hNQUNfU0hBMV9BRVM7CkBAIC0xMDcsNyArMTEwLDggQEAKIAlpZiAocmJ1ZiA9PSBOVUxMKQogCQlyZXR1cm47CiAKLQlyZXBseS0+dHlwZSA9IHNtLT5wcm90byA9PSBXUEFfUFJPVE9fUlNOID8KKwlyZXBseS0+dHlwZSA9IChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTiB8fAorCQkgICAgICAgc20tPnByb3RvID09IFdQQV9QUk9UT19PU0VOKSA/CiAJCUVBUE9MX0tFWV9UWVBFX1JTTiA6IEVBUE9MX0tFWV9UWVBFX1dQQTsKIAlrZXlfaW5mbyA9IFdQQV9LRVlfSU5GT19SRVFVRVNUIHwgdmVyOwogCWlmIChzbS0+cHRrX3NldCkKQEAgLTE1OCw3ICsxNjIsNyBAQAogCX0KIAogCWlmIChwbWtpZCAmJiBzbS0+Y3VyX3Bta3NhICYmCi0JICAgIG9zX21lbWNtcChwbWtpZCwgc20tPmN1cl9wbWtzYS0+cG1raWQsIFBNS0lEX0xFTikgPT0gMCkgeworCSAgICBvc19tZW1jbXBfY29uc3QocG1raWQsIHNtLT5jdXJfcG1rc2EtPnBta2lkLCBQTUtJRF9MRU4pID09IDApIHsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUlNOOiBtYXRjaGVkIFBNS0lEIiwgcG1raWQsIFBNS0lEX0xFTik7CiAJCXdwYV9zbV9zZXRfcG1rX2Zyb21fcG1rc2Eoc20pOwogCQl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiUlNOOiBQTUsgZnJvbSBQTUtTQSBjYWNoZSIsCkBAIC0yMzEsNyArMjM1LDggQEAKIAl9CiAKIAlpZiAoYWJvcnRfY2FjaGVkICYmIHdwYV9rZXlfbWdtdF93cGFfaWVlZTgwMjF4KHNtLT5rZXlfbWdtdCkgJiYKLQkgICAgIXdwYV9rZXlfbWdtdF9mdChzbS0+a2V5X21nbXQpKSB7CisJICAgICF3cGFfa2V5X21nbXRfZnQoc20tPmtleV9tZ210KSAmJiBzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX09TRU4pCisJewogCQkvKiBTZW5kIEVBUE9MLVN0YXJ0IHRvIHRyaWdnZXIgZnVsbCBFQVAgYXV0aGVudGljYXRpb24uICovCiAJCXU4ICpidWY7CiAJCXNpemVfdCBidWZsZW47CkBAIC0zMjUsMTEgKzMzMCwxMiBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JcmVwbHktPnR5cGUgPSBzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTiA/CisJcmVwbHktPnR5cGUgPSAoc20tPnByb3RvID09IFdQQV9QUk9UT19SU04gfHwKKwkJICAgICAgIHNtLT5wcm90byA9PSBXUEFfUFJPVE9fT1NFTikgPwogCQlFQVBPTF9LRVlfVFlQRV9SU04gOiBFQVBPTF9LRVlfVFlQRV9XUEE7CiAJV1BBX1BVVF9CRTE2KHJlcGx5LT5rZXlfaW5mbywKIAkJICAgICB2ZXIgfCBXUEFfS0VZX0lORk9fS0VZX1RZUEUgfCBXUEFfS0VZX0lORk9fTUlDKTsKLQlpZiAoc20tPnByb3RvID09IFdQQV9QUk9UT19SU04pCisJaWYgKHNtLT5wcm90byA9PSBXUEFfUFJPVE9fUlNOIHx8IHNtLT5wcm90byA9PSBXUEFfUFJPVE9fT1NFTikKIAkJV1BBX1BVVF9CRTE2KHJlcGx5LT5rZXlfbGVuZ3RoLCAwKTsKIAllbHNlCiAJCW9zX21lbWNweShyZXBseS0+a2V5X2xlbmd0aCwga2V5LT5rZXlfbGVuZ3RoLCAyKTsKQEAgLTM1Niw3ICszNjIsNyBAQAogCQkJICBjb25zdCBzdHJ1Y3Qgd3BhX2VhcG9sX2tleSAqa2V5LAogCQkJICBzdHJ1Y3Qgd3BhX3B0ayAqcHRrKQogewotCXNpemVfdCBwdGtfbGVuID0gc20tPnBhaXJ3aXNlX2NpcGhlciAhPSBXUEFfQ0lQSEVSX1RLSVAgPyA0OCA6IDY0OworCXNpemVfdCBwdGtfbGVuID0gd3BhX2NpcGhlcl9rZXlfbGVuKHNtLT5wYWlyd2lzZV9jaXBoZXIpICsgMzI7CiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKIAlpZiAod3BhX2tleV9tZ210X2Z0KHNtLT5rZXlfbWdtdCkpCiAJCXJldHVybiB3cGFfZGVyaXZlX3B0a19mdChzbSwgc3JjX2FkZHIsIGtleSwgcHRrLCBwdGtfbGVuKTsKQEAgLTM3MywxMiArMzc5LDE0IEBACiBzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9wcm9jZXNzXzFfb2ZfNChzdHJ1Y3Qgd3BhX3NtICpzbSwKIAkJCQkJICBjb25zdCB1bnNpZ25lZCBjaGFyICpzcmNfYWRkciwKIAkJCQkJICBjb25zdCBzdHJ1Y3Qgd3BhX2VhcG9sX2tleSAqa2V5LAotCQkJCQkgIHUxNiB2ZXIpCisJCQkJCSAgdTE2IHZlciwgY29uc3QgdTggKmtleV9kYXRhLAorCQkJCQkgIHNpemVfdCBrZXlfZGF0YV9sZW4pCiB7CiAJc3RydWN0IHdwYV9lYXBvbF9pZV9wYXJzZSBpZTsKIAlzdHJ1Y3Qgd3BhX3B0ayAqcHRrOwotCXU4IGJ1Zls4XTsKIAlpbnQgcmVzOworCXU4ICprZGUsICprZGVfYnVmID0gTlVMTDsKKwlzaXplX3Qga2RlX2xlbjsKIAogCWlmICh3cGFfc21fZ2V0X25ldHdvcmtfY3R4KHNtKSA9PSBOVUxMKSB7CiAJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX1dBUk5JTkcsICJXUEE6IE5vIFNTSUQgaW5mbyAiCkBAIC0zOTIsMTIgKzQwMCwxMSBAQAogCiAJb3NfbWVtc2V0KCZpZSwgMCwgc2l6ZW9mKGllKSk7CiAKLQlpZiAoc20tPnByb3RvID09IFdQQV9QUk9UT19SU04pIHsKKwlpZiAoc20tPnByb3RvID09IFdQQV9QUk9UT19SU04gfHwgc20tPnByb3RvID09IFdQQV9QUk9UT19PU0VOKSB7CiAJCS8qIFJTTjogbXNnIDEvNCBzaG91bGQgY29udGFpbiBQTUtJRCBmb3IgdGhlIHNlbGVjdGVkIFBNSyAqLwotCQljb25zdCB1OCAqX2J1ZiA9IChjb25zdCB1OCAqKSAoa2V5ICsgMSk7Ci0JCXNpemVfdCBsZW4gPSBXUEFfR0VUX0JFMTYoa2V5LT5rZXlfZGF0YV9sZW5ndGgpOwotCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJSU046IG1zZyAxLzQga2V5IGRhdGEiLCBfYnVmLCBsZW4pOwotCQlpZiAod3BhX3N1cHBsaWNhbnRfcGFyc2VfaWVzKF9idWYsIGxlbiwgJmllKSA8IDApCisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlJTTjogbXNnIDEvNCBrZXkgZGF0YSIsCisJCQkgICAga2V5X2RhdGEsIGtleV9kYXRhX2xlbik7CisJCWlmICh3cGFfc3VwcGxpY2FudF9wYXJzZV9pZXMoa2V5X2RhdGEsIGtleV9kYXRhX2xlbiwgJmllKSA8IDApCiAJCQlnb3RvIGZhaWxlZDsKIAkJaWYgKGllLnBta2lkKSB7CiAJCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJSU046IFBNS0lEIGZyb20gIgpAQCAtNDI5LDIxICs0MzYsNDkgQEAKIAkgKiBiZWVuIHZlcmlmaWVkIHdoZW4gcHJvY2Vzc2luZyBtZXNzYWdlIDMvNC4gKi8KIAlwdGsgPSAmc20tPnRwdGs7CiAJd3BhX2Rlcml2ZV9wdGsoc20sIHNyY19hZGRyLCBrZXksIHB0ayk7Ci0JLyogU3VwcGxpY2FudDogc3dhcCB0eC9yeCBNaWMga2V5cyAqLwotCW9zX21lbWNweShidWYsIHB0ay0+dS5hdXRoLnR4X21pY19rZXksIDgpOwotCW9zX21lbWNweShwdGstPnUuYXV0aC50eF9taWNfa2V5LCBwdGstPnUuYXV0aC5yeF9taWNfa2V5LCA4KTsKLQlvc19tZW1jcHkocHRrLT51LmF1dGgucnhfbWljX2tleSwgYnVmLCA4KTsKKwlpZiAoc20tPnBhaXJ3aXNlX2NpcGhlciA9PSBXUEFfQ0lQSEVSX1RLSVApIHsKKwkJdTggYnVmWzhdOworCQkvKiBTdXBwbGljYW50OiBzd2FwIHR4L3J4IE1pYyBrZXlzICovCisJCW9zX21lbWNweShidWYsIHB0ay0+dS5hdXRoLnR4X21pY19rZXksIDgpOworCQlvc19tZW1jcHkocHRrLT51LmF1dGgudHhfbWljX2tleSwgcHRrLT51LmF1dGgucnhfbWljX2tleSwgOCk7CisJCW9zX21lbWNweShwdGstPnUuYXV0aC5yeF9taWNfa2V5LCBidWYsIDgpOworCQlvc19tZW1zZXQoYnVmLCAwLCBzaXplb2YoYnVmKSk7CisJfQogCXNtLT50cHRrX3NldCA9IDE7CiAKKwlrZGUgPSBzbS0+YXNzb2Nfd3BhX2llOworCWtkZV9sZW4gPSBzbS0+YXNzb2Nfd3BhX2llX2xlbjsKKworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAoc20tPnAycCkgeworCQlrZGVfYnVmID0gb3NfbWFsbG9jKGtkZV9sZW4gKyAyICsgUlNOX1NFTEVDVE9SX0xFTiArIDEpOworCQlpZiAoa2RlX2J1ZikgeworCQkJdTggKnBvczsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBBZGQgSVAgQWRkcmVzcyBSZXF1ZXN0IEtERSAiCisJCQkJICAgImludG8gRUFQT0wtS2V5IDIvNCIpOworCQkJb3NfbWVtY3B5KGtkZV9idWYsIGtkZSwga2RlX2xlbik7CisJCQlrZGUgPSBrZGVfYnVmOworCQkJcG9zID0ga2RlICsga2RlX2xlbjsKKwkJCSpwb3MrKyA9IFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQzsKKwkJCSpwb3MrKyA9IFJTTl9TRUxFQ1RPUl9MRU4gKyAxOworCQkJUlNOX1NFTEVDVE9SX1BVVChwb3MsIFdGQV9LRVlfREFUQV9JUF9BRERSX1JFUSk7CisJCQlwb3MgKz0gUlNOX1NFTEVDVE9SX0xFTjsKKwkJCSpwb3MrKyA9IDB4MDE7CisJCQlrZGVfbGVuID0gcG9zIC0ga2RlOworCQl9CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKwogCWlmICh3cGFfc3VwcGxpY2FudF9zZW5kXzJfb2ZfNChzbSwgc20tPmJzc2lkLCBrZXksIHZlciwgc20tPnNub25jZSwKLQkJCQkgICAgICAgc20tPmFzc29jX3dwYV9pZSwgc20tPmFzc29jX3dwYV9pZV9sZW4sCi0JCQkJICAgICAgIHB0aykpCisJCQkJICAgICAgIGtkZSwga2RlX2xlbiwgcHRrKSkKIAkJZ290byBmYWlsZWQ7CiAKKwlvc19mcmVlKGtkZV9idWYpOwogCW9zX21lbWNweShzbS0+YW5vbmNlLCBrZXktPmtleV9ub25jZSwgV1BBX05PTkNFX0xFTik7CiAJcmV0dXJuOwogCiBmYWlsZWQ6CisJb3NfZnJlZShrZGVfYnVmKTsKIAl3cGFfc21fZGVhdXRoZW50aWNhdGUoc20sIFdMQU5fUkVBU09OX1VOU1BFQ0lGSUVEKTsKIH0KIApAQCAtNTM1LDcgKzU3MCw3IEBACiAJa2V5bGVuID0gd3BhX2NpcGhlcl9rZXlfbGVuKHNtLT5wYWlyd2lzZV9jaXBoZXIpOwogCXJzY2xlbiA9IHdwYV9jaXBoZXJfcnNjX2xlbihzbS0+cGFpcndpc2VfY2lwaGVyKTsKIAotCWlmIChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTikgeworCWlmIChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTiB8fCBzbS0+cHJvdG8gPT0gV1BBX1BST1RPX09TRU4pIHsKIAkJa2V5X3JzYyA9IG51bGxfcnNjOwogCX0gZWxzZSB7CiAJCWtleV9yc2MgPSBrZXktPmtleV9yc2M7CkBAIC02MjMsNiArNjU4LDcgQEAKIAkJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX1dBUk5JTkcsCiAJCQkJIldQQTogRmFpbGVkIHRvIHNldCBHVEsgdG8gdGhlIGRyaXZlciAiCiAJCQkJIihHcm91cCBvbmx5KSIpOworCQkJb3NfbWVtc2V0KGd0a19idWYsIDAsIHNpemVvZihndGtfYnVmKSk7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAl9IGVsc2UgaWYgKHdwYV9zbV9zZXRfa2V5KHNtLCBnZC0+YWxnLCBicm9hZGNhc3RfZXRoZXJfYWRkciwKQEAgLTYzMiw4ICs2NjgsMTAgQEAKIAkJCSJXUEE6IEZhaWxlZCB0byBzZXQgR1RLIHRvICIKIAkJCSJ0aGUgZHJpdmVyIChhbGc9JWQga2V5bGVuPSVkIGtleWlkeD0lZCkiLAogCQkJZ2QtPmFsZywgZ2QtPmd0a19sZW4sIGdkLT5rZXlpZHgpOworCQlvc19tZW1zZXQoZ3RrX2J1ZiwgMCwgc2l6ZW9mKGd0a19idWYpKTsKIAkJcmV0dXJuIC0xOwogCX0KKwlvc19tZW1zZXQoZ3RrX2J1ZiwgMCwgc2l6ZW9mKGd0a19idWYpKTsKIAogCXJldHVybiAwOwogfQpAQCAtNjg4LDE0ICs3MjYsMTcgQEAKIAlvc19tZW1jcHkoZ2QuZ3RrLCBndGssIGd0a19sZW4pOwogCWdkLmd0a19sZW4gPSBndGtfbGVuOwogCi0JaWYgKHdwYV9zdXBwbGljYW50X2NoZWNrX2dyb3VwX2NpcGhlcihzbSwgc20tPmdyb3VwX2NpcGhlciwKLQkJCQkJICAgICAgZ3RrX2xlbiwgZ3RrX2xlbiwKLQkJCQkJICAgICAgJmdkLmtleV9yc2NfbGVuLCAmZ2QuYWxnKSB8fAotCSAgICB3cGFfc3VwcGxpY2FudF9pbnN0YWxsX2d0ayhzbSwgJmdkLCBrZXktPmtleV9yc2MpKSB7CisJaWYgKHNtLT5ncm91cF9jaXBoZXIgIT0gV1BBX0NJUEhFUl9HVEtfTk9UX1VTRUQgJiYKKwkgICAgKHdwYV9zdXBwbGljYW50X2NoZWNrX2dyb3VwX2NpcGhlcihzbSwgc20tPmdyb3VwX2NpcGhlciwKKwkJCQkJICAgICAgIGd0a19sZW4sIGd0a19sZW4sCisJCQkJCSAgICAgICAmZ2Qua2V5X3JzY19sZW4sICZnZC5hbGcpIHx8CisJICAgICB3cGFfc3VwcGxpY2FudF9pbnN0YWxsX2d0ayhzbSwgJmdkLCBrZXktPmtleV9yc2MpKSkgewogCQl3cGFfZGJnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19ERUJVRywKIAkJCSJSU046IEZhaWxlZCB0byBpbnN0YWxsIEdUSyIpOworCQlvc19tZW1zZXQoJmdkLCAwLCBzaXplb2YoZ2QpKTsKIAkJcmV0dXJuIC0xOwogCX0KKwlvc19tZW1zZXQoJmdkLCAwLCBzaXplb2YoZ2QpKTsKIAogCXdwYV9zdXBwbGljYW50X2tleV9uZWdfY29tcGxldGUoc20sIHNtLT5ic3NpZCwKIAkJCQkJa2V5X2luZm8gJiBXUEFfS0VZX0lORk9fU0VDVVJFKTsKQEAgLTcwNywxMyArNzQ4LDE1IEBACiAJCQkgICAgICAgc3RydWN0IHdwYV9lYXBvbF9pZV9wYXJzZSAqaWUpCiB7CiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKLQlpZiAoc20tPm1nbXRfZ3JvdXBfY2lwaGVyICE9IFdQQV9DSVBIRVJfQUVTXzEyOF9DTUFDKQorCWlmICghd3BhX2NpcGhlcl92YWxpZF9tZ210X2dyb3VwKHNtLT5tZ210X2dyb3VwX2NpcGhlcikpCiAJCXJldHVybiAwOwogCiAJaWYgKGllLT5pZ3RrKSB7CisJCXNpemVfdCBsZW47CiAJCWNvbnN0IHN0cnVjdCB3cGFfaWd0a19rZGUgKmlndGs7CiAJCXUxNiBrZXlpZHg7Ci0JCWlmIChpZS0+aWd0a19sZW4gIT0gc2l6ZW9mKCppZ3RrKSkKKwkJbGVuID0gd3BhX2NpcGhlcl9rZXlfbGVuKHNtLT5tZ210X2dyb3VwX2NpcGhlcik7CisJCWlmIChpZS0+aWd0a19sZW4gIT0gV1BBX0lHVEtfS0RFX1BSRUZJWF9MRU4gKyBsZW4pCiAJCQlyZXR1cm4gLTE7CiAJCWlndGsgPSAoY29uc3Qgc3RydWN0IHdwYV9pZ3RrX2tkZSAqKSBpZS0+aWd0azsKIAkJa2V5aWR4ID0gV1BBX0dFVF9MRTE2KGlndGstPmtleWlkKTsKQEAgLTcyMSwxNSArNzY0LDE2IEBACiAJCQkicG4gJTAyeCUwMnglMDJ4JTAyeCUwMnglMDJ4IiwKIAkJCWtleWlkeCwgTUFDMlNUUihpZ3RrLT5wbikpOwogCQl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiV1BBOiBJR1RLIiwKLQkJCQlpZ3RrLT5pZ3RrLCBXUEFfSUdUS19MRU4pOworCQkJCWlndGstPmlndGssIGxlbik7CiAJCWlmIChrZXlpZHggPiA0MDk1KSB7CiAJCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19XQVJOSU5HLAogCQkJCSJXUEE6IEludmFsaWQgSUdUSyBLZXlJRCAlZCIsIGtleWlkeCk7CiAJCQlyZXR1cm4gLTE7CiAJCX0KLQkJaWYgKHdwYV9zbV9zZXRfa2V5KHNtLCBXUEFfQUxHX0lHVEssIGJyb2FkY2FzdF9ldGhlcl9hZGRyLAorCQlpZiAod3BhX3NtX3NldF9rZXkoc20sIHdwYV9jaXBoZXJfdG9fYWxnKHNtLT5tZ210X2dyb3VwX2NpcGhlciksCisJCQkJICAgYnJvYWRjYXN0X2V0aGVyX2FkZHIsCiAJCQkJICAga2V5aWR4LCAwLCBpZ3RrLT5wbiwgc2l6ZW9mKGlndGstPnBuKSwKLQkJCQkgICBpZ3RrLT5pZ3RrLCBXUEFfSUdUS19MRU4pIDwgMCkgeworCQkJCSAgIGlndGstPmlndGssIGxlbikgPCAwKSB7CiAJCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19XQVJOSU5HLAogCQkJCSJXUEE6IEZhaWxlZCB0byBjb25maWd1cmUgSUdUSyB0byB0aGUgZHJpdmVyIik7CiAJCQlyZXR1cm4gLTE7CkBAIC04NjIsNyArOTA2LDggQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmIChvc19tZW1jbXAocnNuLnBta2lkLCBzbS0+cG1rX3IxX25hbWUsIFdQQV9QTUtfTkFNRV9MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KHJzbi5wbWtpZCwgc20tPnBta19yMV9uYW1lLCBXUEFfUE1LX05BTUVfTEVOKSAhPSAwKQorCXsKIAkJd3BhX2RiZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfREVCVUcsCiAJCQkiRlQ6IFBNS1IxTmFtZSBtaXNtYXRjaCBpbiAiCiAJCQkiRlQgNC13YXkgaGFuZHNoYWtlIG1lc3NhZ2UgMy80Iik7CkBAIC05ODIsNDUgKzEwMjcsMzcgQEAKICAqIEBrZXk6IFBvaW50ZXIgdG8gdGhlIEVBUE9MLUtleSBmcmFtZSBoZWFkZXIKICAqIEB2ZXI6IFZlcnNpb24gYml0cyBmcm9tIEVBUE9MLUtleSBLZXkgSW5mbwogICogQGtleV9pbmZvOiBLZXkgSW5mbwotICogQGtkZTogS0RFcyB0byBpbmNsdWRlIHRoZSBFQVBPTC1LZXkgZnJhbWUKLSAqIEBrZGVfbGVuOiBMZW5ndGggb2YgS0RFcwogICogQHB0azogUFRLIHRvIHVzZSBmb3Iga2V5ZWQgaGFzaCBhbmQgZW5jcnlwdGlvbgogICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCiAgKi8KIGludCB3cGFfc3VwcGxpY2FudF9zZW5kXzRfb2ZfNChzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdW5zaWduZWQgY2hhciAqZHN0LAogCQkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksCiAJCQkgICAgICAgdTE2IHZlciwgdTE2IGtleV9pbmZvLAotCQkJICAgICAgIGNvbnN0IHU4ICprZGUsIHNpemVfdCBrZGVfbGVuLAogCQkJICAgICAgIHN0cnVjdCB3cGFfcHRrICpwdGspCiB7CiAJc2l6ZV90IHJsZW47CiAJc3RydWN0IHdwYV9lYXBvbF9rZXkgKnJlcGx5OwogCXU4ICpyYnVmOwogCi0JaWYgKGtkZSkKLQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BBOiBLREUgZm9yIG1zZyA0LzQiLCBrZGUsIGtkZV9sZW4pOwotCiAJcmJ1ZiA9IHdwYV9zbV9hbGxvY19lYXBvbChzbSwgSUVFRTgwMl8xWF9UWVBFX0VBUE9MX0tFWSwgTlVMTCwKLQkJCQkgIHNpemVvZigqcmVwbHkpICsga2RlX2xlbiwKLQkJCQkgICZybGVuLCAodm9pZCAqKSAmcmVwbHkpOworCQkJCSAgc2l6ZW9mKCpyZXBseSksICZybGVuLCAodm9pZCAqKSAmcmVwbHkpOwogCWlmIChyYnVmID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAotCXJlcGx5LT50eXBlID0gc20tPnByb3RvID09IFdQQV9QUk9UT19SU04gPworCXJlcGx5LT50eXBlID0gKHNtLT5wcm90byA9PSBXUEFfUFJPVE9fUlNOIHx8CisJCSAgICAgICBzbS0+cHJvdG8gPT0gV1BBX1BST1RPX09TRU4pID8KIAkJRUFQT0xfS0VZX1RZUEVfUlNOIDogRUFQT0xfS0VZX1RZUEVfV1BBOwogCWtleV9pbmZvICY9IFdQQV9LRVlfSU5GT19TRUNVUkU7CiAJa2V5X2luZm8gfD0gdmVyIHwgV1BBX0tFWV9JTkZPX0tFWV9UWVBFIHwgV1BBX0tFWV9JTkZPX01JQzsKIAlXUEFfUFVUX0JFMTYocmVwbHktPmtleV9pbmZvLCBrZXlfaW5mbyk7Ci0JaWYgKHNtLT5wcm90byA9PSBXUEFfUFJPVE9fUlNOKQorCWlmIChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTiB8fCBzbS0+cHJvdG8gPT0gV1BBX1BST1RPX09TRU4pCiAJCVdQQV9QVVRfQkUxNihyZXBseS0+a2V5X2xlbmd0aCwgMCk7CiAJZWxzZQogCQlvc19tZW1jcHkocmVwbHktPmtleV9sZW5ndGgsIGtleS0+a2V5X2xlbmd0aCwgMik7CiAJb3NfbWVtY3B5KHJlcGx5LT5yZXBsYXlfY291bnRlciwga2V5LT5yZXBsYXlfY291bnRlciwKIAkJICBXUEFfUkVQTEFZX0NPVU5URVJfTEVOKTsKIAotCVdQQV9QVVRfQkUxNihyZXBseS0+a2V5X2RhdGFfbGVuZ3RoLCBrZGVfbGVuKTsKLQlpZiAoa2RlKQotCQlvc19tZW1jcHkocmVwbHkgKyAxLCBrZGUsIGtkZV9sZW4pOworCVdQQV9QVVRfQkUxNihyZXBseS0+a2V5X2RhdGFfbGVuZ3RoLCAwKTsKIAogCXdwYV9kYmcoc20tPmN0eC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiV1BBOiBTZW5kaW5nIEVBUE9MLUtleSA0LzQiKTsKIAl3cGFfZWFwb2xfa2V5X3NlbmQoc20sIHB0ay0+a2NrLCB2ZXIsIGRzdCwgRVRIX1BfRUFQT0wsCkBAIC0xMDMyLDEwICsxMDY5LDEwIEBACiAKIHN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X3Byb2Nlc3NfM19vZl80KHN0cnVjdCB3cGFfc20gKnNtLAogCQkJCQkgIGNvbnN0IHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksCi0JCQkJCSAgdTE2IHZlcikKKwkJCQkJICB1MTYgdmVyLCBjb25zdCB1OCAqa2V5X2RhdGEsCisJCQkJCSAgc2l6ZV90IGtleV9kYXRhX2xlbikKIHsKLQl1MTYga2V5X2luZm8sIGtleWxlbiwgbGVuOwotCWNvbnN0IHU4ICpwb3M7CisJdTE2IGtleV9pbmZvLCBrZXlsZW47CiAJc3RydWN0IHdwYV9lYXBvbF9pZV9wYXJzZSBpZTsKIAogCXdwYV9zbV9zZXRfc3RhdGUoc20sIFdQQV80V0FZX0hBTkRTSEFLRSk7CkBAIC0xMDQ0LDEwICsxMDgxLDggQEAKIAogCWtleV9pbmZvID0gV1BBX0dFVF9CRTE2KGtleS0+a2V5X2luZm8pOwogCi0JcG9zID0gKGNvbnN0IHU4ICopIChrZXkgKyAxKTsKLQlsZW4gPSBXUEFfR0VUX0JFMTYoa2V5LT5rZXlfZGF0YV9sZW5ndGgpOwotCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldQQTogSUUgS2V5RGF0YSIsIHBvcywgbGVuKTsKLQlpZiAod3BhX3N1cHBsaWNhbnRfcGFyc2VfaWVzKHBvcywgbGVuLCAmaWUpIDwgMCkKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUEE6IElFIEtleURhdGEiLCBrZXlfZGF0YSwga2V5X2RhdGFfbGVuKTsKKwlpZiAod3BhX3N1cHBsaWNhbnRfcGFyc2VfaWVzKGtleV9kYXRhLCBrZXlfZGF0YV9sZW4sICZpZSkgPCAwKQogCQlnb3RvIGZhaWxlZDsKIAlpZiAoaWUuZ3RrICYmICEoa2V5X2luZm8gJiBXUEFfS0VZX0lORk9fRU5DUl9LRVlfREFUQSkpIHsKIAkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfV0FSTklORywKQEAgLTEwNjEsNyArMTA5NiwxMCBAQAogCQlnb3RvIGZhaWxlZDsKIAl9CiAKLQlpZiAoaWUuaWd0ayAmJiBpZS5pZ3RrX2xlbiAhPSBzaXplb2Yoc3RydWN0IHdwYV9pZ3RrX2tkZSkpIHsKKwlpZiAoaWUuaWd0ayAmJgorCSAgICB3cGFfY2lwaGVyX3ZhbGlkX21nbXRfZ3JvdXAoc20tPm1nbXRfZ3JvdXBfY2lwaGVyKSAmJgorCSAgICBpZS5pZ3RrX2xlbiAhPSBXUEFfSUdUS19LREVfUFJFRklYX0xFTiArCisJICAgICh1bnNpZ25lZCBpbnQpIHdwYV9jaXBoZXJfa2V5X2xlbihzbS0+bWdtdF9ncm91cF9jaXBoZXIpKSB7CiAJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX1dBUk5JTkcsCiAJCQkiV1BBOiBJbnZhbGlkIElHVEsgS0RFIGxlbmd0aCAlbHUiLAogCQkJKHVuc2lnbmVkIGxvbmcpIGllLmlndGtfbGVuKTsKQEAgLTEwODksOCArMTEyNywxNiBAQAogCQlnb3RvIGZhaWxlZDsKIAl9CiAKKyNpZmRlZiBDT05GSUdfUDJQCisJaWYgKGllLmlwX2FkZHJfYWxsb2MpIHsKKwkJb3NfbWVtY3B5KHNtLT5wMnBfaXBfYWRkciwgaWUuaXBfYWRkcl9hbGxvYywgMyAqIDQpOworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJQMlA6IElQIGFkZHJlc3MgaW5mbyIsCisJCQkgICAgc20tPnAycF9pcF9hZGRyLCBzaXplb2Yoc20tPnAycF9pcF9hZGRyKSk7CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKwogCWlmICh3cGFfc3VwcGxpY2FudF9zZW5kXzRfb2ZfNChzbSwgc20tPmJzc2lkLCBrZXksIHZlciwga2V5X2luZm8sCi0JCQkJICAgICAgIE5VTEwsIDAsICZzbS0+cHRrKSkgeworCQkJCSAgICAgICAmc20tPnB0aykpIHsKIAkJZ290byBmYWlsZWQ7CiAJfQogCkBAIC0xMTEyLDcgKzExNTgsMTAgQEAKIAl9CiAJd3BhX3NtX3NldF9zdGF0ZShzbSwgV1BBX0dST1VQX0hBTkRTSEFLRSk7CiAKLQlpZiAoaWUuZ3RrICYmCisJaWYgKHNtLT5ncm91cF9jaXBoZXIgPT0gV1BBX0NJUEhFUl9HVEtfTk9UX1VTRUQpIHsKKwkJd3BhX3N1cHBsaWNhbnRfa2V5X25lZ19jb21wbGV0ZShzbSwgc20tPmJzc2lkLAorCQkJCQkJa2V5X2luZm8gJiBXUEFfS0VZX0lORk9fU0VDVVJFKTsKKwl9IGVsc2UgaWYgKGllLmd0ayAmJgogCSAgICB3cGFfc3VwcGxpY2FudF9wYWlyd2lzZV9ndGsoc20sIGtleSwKIAkJCQkJaWUuZ3RrLCBpZS5ndGtfbGVuLCBrZXlfaW5mbykgPCAwKSB7CiAJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX0lORk8sCkBAIC0xMTI2LDcgKzExNzUsOCBAQAogCQlnb3RvIGZhaWxlZDsKIAl9CiAKLQl3cGFfc21fc2V0X3Jla2V5X29mZmxvYWQoc20pOworCWlmIChpZS5ndGspCisJCXdwYV9zbV9zZXRfcmVrZXlfb2ZmbG9hZChzbSk7CiAKIAlyZXR1cm47CiAKQEAgLTExODcsMjIgKzEyMzcsMTQgQEAKIAogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9wcm9jZXNzXzFfb2ZfMl93cGEoc3RydWN0IHdwYV9zbSAqc20sCiAJCQkJCSAgICAgY29uc3Qgc3RydWN0IHdwYV9lYXBvbF9rZXkgKmtleSwKLQkJCQkJICAgICBzaXplX3Qga2V5ZGF0YWxlbiwgaW50IGtleV9pbmZvLAotCQkJCQkgICAgIHNpemVfdCBleHRyYV9sZW4sIHUxNiB2ZXIsCi0JCQkJCSAgICAgc3RydWN0IHdwYV9ndGtfZGF0YSAqZ2QpCisJCQkJCSAgICAgY29uc3QgdTggKmtleV9kYXRhLAorCQkJCQkgICAgIHNpemVfdCBrZXlfZGF0YV9sZW4sIHUxNiBrZXlfaW5mbywKKwkJCQkJICAgICB1MTYgdmVyLCBzdHJ1Y3Qgd3BhX2d0a19kYXRhICpnZCkKIHsKIAlzaXplX3QgbWF4a2V5bGVuOwotCXU4IGVrWzMyXTsKIAogCWdkLT5ndGtfbGVuID0gV1BBX0dFVF9CRTE2KGtleS0+a2V5X2xlbmd0aCk7Ci0JbWF4a2V5bGVuID0ga2V5ZGF0YWxlbjsKLQlpZiAoa2V5ZGF0YWxlbiA+IGV4dHJhX2xlbikgewotCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19JTkZPLAotCQkJIldQQTogVHJ1bmNhdGVkIEVBUE9MLUtleSBwYWNrZXQ6ICIKLQkJCSJrZXlfZGF0YV9sZW5ndGg9JWx1ID4gZXh0cmFfbGVuPSVsdSIsCi0JCQkodW5zaWduZWQgbG9uZykga2V5ZGF0YWxlbiwgKHVuc2lnbmVkIGxvbmcpIGV4dHJhX2xlbik7Ci0JCXJldHVybiAtMTsKLQl9CisJbWF4a2V5bGVuID0ga2V5X2RhdGFfbGVuOwogCWlmICh2ZXIgPT0gV1BBX0tFWV9JTkZPX1RZUEVfSE1BQ19TSEExX0FFUykgewogCQlpZiAobWF4a2V5bGVuIDwgOCkgewogCQkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfSU5GTywKQEAgLTEyMjEsMzcgKzEyNjMsMzkgQEAKIAlnZC0+a2V5aWR4ID0gKGtleV9pbmZvICYgV1BBX0tFWV9JTkZPX0tFWV9JTkRFWF9NQVNLKSA+PgogCQlXUEFfS0VZX0lORk9fS0VZX0lOREVYX1NISUZUOwogCWlmICh2ZXIgPT0gV1BBX0tFWV9JTkZPX1RZUEVfSE1BQ19NRDVfUkM0KSB7Ci0JCW9zX21lbWNweShlaywga2V5LT5rZXlfaXYsIDE2KTsKLQkJb3NfbWVtY3B5KGVrICsgMTYsIHNtLT5wdGsua2VrLCAxNik7Ci0JCWlmIChrZXlkYXRhbGVuID4gc2l6ZW9mKGdkLT5ndGspKSB7CisJCXU4IGVrWzMyXTsKKwkJaWYgKGtleV9kYXRhX2xlbiA+IHNpemVvZihnZC0+Z3RrKSkgewogCQkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfV0FSTklORywKIAkJCQkiV1BBOiBSQzQga2V5IGRhdGEgdG9vIGxvbmcgKCVsdSkiLAotCQkJCSh1bnNpZ25lZCBsb25nKSBrZXlkYXRhbGVuKTsKKwkJCQkodW5zaWduZWQgbG9uZykga2V5X2RhdGFfbGVuKTsKIAkJCXJldHVybiAtMTsKIAkJfQotCQlvc19tZW1jcHkoZ2QtPmd0aywga2V5ICsgMSwga2V5ZGF0YWxlbik7Ci0JCWlmIChyYzRfc2tpcChlaywgMzIsIDI1NiwgZ2QtPmd0aywga2V5ZGF0YWxlbikpIHsKKwkJb3NfbWVtY3B5KGVrLCBrZXktPmtleV9pdiwgMTYpOworCQlvc19tZW1jcHkoZWsgKyAxNiwgc20tPnB0ay5rZWssIDE2KTsKKwkJb3NfbWVtY3B5KGdkLT5ndGssIGtleV9kYXRhLCBrZXlfZGF0YV9sZW4pOworCQlpZiAocmM0X3NraXAoZWssIDMyLCAyNTYsIGdkLT5ndGssIGtleV9kYXRhX2xlbikpIHsKKwkJCW9zX21lbXNldChlaywgMCwgc2l6ZW9mKGVrKSk7CiAJCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19FUlJPUiwKIAkJCQkiV1BBOiBSQzQgZmFpbGVkIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KKwkJb3NfbWVtc2V0KGVrLCAwLCBzaXplb2YoZWspKTsKIAl9IGVsc2UgaWYgKHZlciA9PSBXUEFfS0VZX0lORk9fVFlQRV9ITUFDX1NIQTFfQUVTKSB7Ci0JCWlmIChrZXlkYXRhbGVuICUgOCkgeworCQlpZiAobWF4a2V5bGVuICUgOCkgewogCQkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfV0FSTklORywKIAkJCQkiV1BBOiBVbnN1cHBvcnRlZCBBRVMtV1JBUCBsZW4gJWx1IiwKLQkJCQkodW5zaWduZWQgbG9uZykga2V5ZGF0YWxlbik7CisJCQkJKHVuc2lnbmVkIGxvbmcpIG1heGtleWxlbik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAkJaWYgKG1heGtleWxlbiA+IHNpemVvZihnZC0+Z3RrKSkgewogCQkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfV0FSTklORywKIAkJCQkiV1BBOiBBRVMtV1JBUCBrZXkgZGF0YSAiCiAJCQkJInRvbyBsb25nIChrZXlkYXRhbGVuPSVsdSBtYXhrZXlsZW49JWx1KSIsCi0JCQkJKHVuc2lnbmVkIGxvbmcpIGtleWRhdGFsZW4sCisJCQkJKHVuc2lnbmVkIGxvbmcpIGtleV9kYXRhX2xlbiwKIAkJCQkodW5zaWduZWQgbG9uZykgbWF4a2V5bGVuKTsKIAkJCXJldHVybiAtMTsKIAkJfQotCQlpZiAoYWVzX3Vud3JhcChzbS0+cHRrLmtlaywgbWF4a2V5bGVuIC8gOCwKLQkJCSAgICAgICAoY29uc3QgdTggKikgKGtleSArIDEpLCBnZC0+Z3RrKSkgeworCQlpZiAoYWVzX3Vud3JhcChzbS0+cHRrLmtlaywgbWF4a2V5bGVuIC8gOCwga2V5X2RhdGEsIGdkLT5ndGspKSB7CiAJCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19XQVJOSU5HLAogCQkJCSJXUEE6IEFFUyB1bndyYXAgZmFpbGVkIC0gY291bGQgbm90IGRlY3J5cHQgIgogCQkJCSJHVEsiKTsKQEAgLTEyODEsMTIgKzEzMjUsMTMgQEAKIAlpZiAocmJ1ZiA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAKLQlyZXBseS0+dHlwZSA9IHNtLT5wcm90byA9PSBXUEFfUFJPVE9fUlNOID8KKwlyZXBseS0+dHlwZSA9IChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTiB8fAorCQkgICAgICAgc20tPnByb3RvID09IFdQQV9QUk9UT19PU0VOKSA/CiAJCUVBUE9MX0tFWV9UWVBFX1JTTiA6IEVBUE9MX0tFWV9UWVBFX1dQQTsKIAlrZXlfaW5mbyAmPSBXUEFfS0VZX0lORk9fS0VZX0lOREVYX01BU0s7CiAJa2V5X2luZm8gfD0gdmVyIHwgV1BBX0tFWV9JTkZPX01JQyB8IFdQQV9LRVlfSU5GT19TRUNVUkU7CiAJV1BBX1BVVF9CRTE2KHJlcGx5LT5rZXlfaW5mbywga2V5X2luZm8pOwotCWlmIChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTikKKwlpZiAoc20tPnByb3RvID09IFdQQV9QUk9UT19SU04gfHwgc20tPnByb3RvID09IFdQQV9QUk9UT19PU0VOKQogCQlXUEFfUFVUX0JFMTYocmVwbHktPmtleV9sZW5ndGgsIDApOwogCWVsc2UKIAkJb3NfbWVtY3B5KHJlcGx5LT5rZXlfbGVuZ3RoLCBrZXktPmtleV9sZW5ndGgsIDIpOwpAQCAtMTMwNiw5ICsxMzUxLDEwIEBACiBzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9wcm9jZXNzXzFfb2ZfMihzdHJ1Y3Qgd3BhX3NtICpzbSwKIAkJCQkJICBjb25zdCB1bnNpZ25lZCBjaGFyICpzcmNfYWRkciwKIAkJCQkJICBjb25zdCBzdHJ1Y3Qgd3BhX2VhcG9sX2tleSAqa2V5LAotCQkJCQkgIGludCBleHRyYV9sZW4sIHUxNiB2ZXIpCisJCQkJCSAgY29uc3QgdTggKmtleV9kYXRhLAorCQkJCQkgIHNpemVfdCBrZXlfZGF0YV9sZW4sIHUxNiB2ZXIpCiB7Ci0JdTE2IGtleV9pbmZvLCBrZXlkYXRhbGVuOworCXUxNiBrZXlfaW5mbzsKIAlpbnQgcmVrZXksIHJldDsKIAlzdHJ1Y3Qgd3BhX2d0a19kYXRhIGdkOwogCkBAIC0xMzE5LDE3ICsxMzY1LDE1IEBACiAJCSJIYW5kc2hha2UgZnJvbSAiIE1BQ1NUUiAiICh2ZXI9JWQpIiwgTUFDMlNUUihzcmNfYWRkciksIHZlcik7CiAKIAlrZXlfaW5mbyA9IFdQQV9HRVRfQkUxNihrZXktPmtleV9pbmZvKTsKLQlrZXlkYXRhbGVuID0gV1BBX0dFVF9CRTE2KGtleS0+a2V5X2RhdGFfbGVuZ3RoKTsKIAotCWlmIChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTikgewotCQlyZXQgPSB3cGFfc3VwcGxpY2FudF9wcm9jZXNzXzFfb2ZfMl9yc24oc20sCi0JCQkJCQkJKGNvbnN0IHU4ICopIChrZXkgKyAxKSwKLQkJCQkJCQlrZXlkYXRhbGVuLCBrZXlfaW5mbywKKwlpZiAoc20tPnByb3RvID09IFdQQV9QUk9UT19SU04gfHwgc20tPnByb3RvID09IFdQQV9QUk9UT19PU0VOKSB7CisJCXJldCA9IHdwYV9zdXBwbGljYW50X3Byb2Nlc3NfMV9vZl8yX3JzbihzbSwga2V5X2RhdGEsCisJCQkJCQkJa2V5X2RhdGFfbGVuLCBrZXlfaW5mbywKIAkJCQkJCQkmZ2QpOwogCX0gZWxzZSB7Ci0JCXJldCA9IHdwYV9zdXBwbGljYW50X3Byb2Nlc3NfMV9vZl8yX3dwYShzbSwga2V5LCBrZXlkYXRhbGVuLAotCQkJCQkJCWtleV9pbmZvLCBleHRyYV9sZW4sCi0JCQkJCQkJdmVyLCAmZ2QpOworCQlyZXQgPSB3cGFfc3VwcGxpY2FudF9wcm9jZXNzXzFfb2ZfMl93cGEoc20sIGtleSwga2V5X2RhdGEsCisJCQkJCQkJa2V5X2RhdGFfbGVuLAorCQkJCQkJCWtleV9pbmZvLCB2ZXIsICZnZCk7CiAJfQogCiAJd3BhX3NtX3NldF9zdGF0ZShzbSwgV1BBX0dST1VQX0hBTkRTSEFLRSk7CkBAIC0xMzQ3LDEzICsxMzkxLDE0IEBACiAJCQlNQUMyU1RSKHNtLT5ic3NpZCksIHdwYV9jaXBoZXJfdHh0KHNtLT5ncm91cF9jaXBoZXIpKTsKIAkJd3BhX3NtX2NhbmNlbF9hdXRoX3RpbWVvdXQoc20pOwogCQl3cGFfc21fc2V0X3N0YXRlKHNtLCBXUEFfQ09NUExFVEVEKTsKLQotCQl3cGFfc21fc2V0X3Jla2V5X29mZmxvYWQoc20pOwogCX0gZWxzZSB7CiAJCXdwYV9zdXBwbGljYW50X2tleV9uZWdfY29tcGxldGUoc20sIHNtLT5ic3NpZCwKIAkJCQkJCWtleV9pbmZvICYKIAkJCQkJCVdQQV9LRVlfSU5GT19TRUNVUkUpOwogCX0KKworCXdwYV9zbV9zZXRfcmVrZXlfb2ZmbG9hZChzbSk7CisKIAlyZXR1cm47CiAKIGZhaWxlZDoKQEAgLTEzNzQsNyArMTQxOSw3IEBACiAJCW9zX21lbXNldChrZXktPmtleV9taWMsIDAsIDE2KTsKIAkJd3BhX2VhcG9sX2tleV9taWMoc20tPnRwdGsua2NrLCB2ZXIsIGJ1ZiwgbGVuLAogCQkJCSAga2V5LT5rZXlfbWljKTsKLQkJaWYgKG9zX21lbWNtcChtaWMsIGtleS0+a2V5X21pYywgMTYpICE9IDApIHsKKwkJaWYgKG9zX21lbWNtcF9jb25zdChtaWMsIGtleS0+a2V5X21pYywgMTYpICE9IDApIHsKIAkJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX1dBUk5JTkcsCiAJCQkJIldQQTogSW52YWxpZCBFQVBPTC1LZXkgTUlDICIKIAkJCQkid2hlbiB1c2luZyBUUFRLIC0gaWdub3JpbmcgVFBUSyIpOwpAQCAtMTM4Myw2ICsxNDI4LDcgQEAKIAkJCXNtLT50cHRrX3NldCA9IDA7CiAJCQlzbS0+cHRrX3NldCA9IDE7CiAJCQlvc19tZW1jcHkoJnNtLT5wdGssICZzbS0+dHB0aywgc2l6ZW9mKHNtLT5wdGspKTsKKwkJCW9zX21lbXNldCgmc20tPnRwdGssIDAsIHNpemVvZihzbS0+dHB0aykpOwogCQl9CiAJfQogCkBAIC0xMzkwLDcgKzE0MzYsNyBAQAogCQlvc19tZW1zZXQoa2V5LT5rZXlfbWljLCAwLCAxNik7CiAJCXdwYV9lYXBvbF9rZXlfbWljKHNtLT5wdGsua2NrLCB2ZXIsIGJ1ZiwgbGVuLAogCQkJCSAga2V5LT5rZXlfbWljKTsKLQkJaWYgKG9zX21lbWNtcChtaWMsIGtleS0+a2V5X21pYywgMTYpICE9IDApIHsKKwkJaWYgKG9zX21lbWNtcF9jb25zdChtaWMsIGtleS0+a2V5X21pYywgMTYpICE9IDApIHsKIAkJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX1dBUk5JTkcsCiAJCQkJIldQQTogSW52YWxpZCBFQVBPTC1LZXkgTUlDIC0gIgogCQkJCSJkcm9wcGluZyBwYWNrZXQiKTsKQEAgLTE0MTUsMTIgKzE0NjEsMTEgQEAKIAogLyogRGVjcnlwdCBSU04gRUFQT0wtS2V5IGtleSBkYXRhIChSQzQgb3IgQUVTLVdSQVApICovCiBzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2RlY3J5cHRfa2V5X2RhdGEoc3RydWN0IHdwYV9zbSAqc20sCi0JCQkJCSAgIHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksIHUxNiB2ZXIpCisJCQkJCSAgIHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksIHUxNiB2ZXIsCisJCQkJCSAgIHU4ICprZXlfZGF0YSwgc2l6ZV90ICprZXlfZGF0YV9sZW4pCiB7Ci0JdTE2IGtleWRhdGFsZW4gPSBXUEFfR0VUX0JFMTYoa2V5LT5rZXlfZGF0YV9sZW5ndGgpOwotCiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUlNOOiBlbmNyeXB0ZWQga2V5IGRhdGEiLAotCQkgICAgKHU4ICopIChrZXkgKyAxKSwga2V5ZGF0YWxlbik7CisJCSAgICBrZXlfZGF0YSwgKmtleV9kYXRhX2xlbik7CiAJaWYgKCFzbS0+cHRrX3NldCkgewogCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19XQVJOSU5HLAogCQkJIldQQTogUFRLIG5vdCBhdmFpbGFibGUsIGNhbm5vdCBkZWNyeXB0IEVBUE9MLUtleSBLZXkgIgpAQCAtMTQzNCw0NSArMTQ3OSw0OCBAQAogCQl1OCBla1szMl07CiAJCW9zX21lbWNweShlaywga2V5LT5rZXlfaXYsIDE2KTsKIAkJb3NfbWVtY3B5KGVrICsgMTYsIHNtLT5wdGsua2VrLCAxNik7Ci0JCWlmIChyYzRfc2tpcChlaywgMzIsIDI1NiwgKHU4ICopIChrZXkgKyAxKSwga2V5ZGF0YWxlbikpIHsKKwkJaWYgKHJjNF9za2lwKGVrLCAzMiwgMjU2LCBrZXlfZGF0YSwgKmtleV9kYXRhX2xlbikpIHsKKwkJCW9zX21lbXNldChlaywgMCwgc2l6ZW9mKGVrKSk7CiAJCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19FUlJPUiwKIAkJCQkiV1BBOiBSQzQgZmFpbGVkIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KKwkJb3NfbWVtc2V0KGVrLCAwLCBzaXplb2YoZWspKTsKIAl9IGVsc2UgaWYgKHZlciA9PSBXUEFfS0VZX0lORk9fVFlQRV9ITUFDX1NIQTFfQUVTIHx8Ci0JCSAgIHZlciA9PSBXUEFfS0VZX0lORk9fVFlQRV9BRVNfMTI4X0NNQUMpIHsKKwkJICAgdmVyID09IFdQQV9LRVlfSU5GT19UWVBFX0FFU18xMjhfQ01BQyB8fAorCQkgICBzbS0+a2V5X21nbXQgPT0gV1BBX0tFWV9NR01UX09TRU4pIHsKIAkJdTggKmJ1ZjsKLQkJaWYgKGtleWRhdGFsZW4gJSA4KSB7CisJCWlmICgqa2V5X2RhdGFfbGVuIDwgOCB8fCAqa2V5X2RhdGFfbGVuICUgOCkgewogCQkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfV0FSTklORywKLQkJCQkiV1BBOiBVbnN1cHBvcnRlZCBBRVMtV1JBUCBsZW4gJWQiLAotCQkJCWtleWRhdGFsZW4pOworCQkJCSJXUEE6IFVuc3VwcG9ydGVkIEFFUy1XUkFQIGxlbiAldSIsCisJCQkJKHVuc2lnbmVkIGludCkgKmtleV9kYXRhX2xlbik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KLQkJa2V5ZGF0YWxlbiAtPSA4OyAvKiBBRVMtV1JBUCBhZGRzIDggYnl0ZXMgKi8KLQkJYnVmID0gb3NfbWFsbG9jKGtleWRhdGFsZW4pOworCQkqa2V5X2RhdGFfbGVuIC09IDg7IC8qIEFFUy1XUkFQIGFkZHMgOCBieXRlcyAqLworCQlidWYgPSBvc19tYWxsb2MoKmtleV9kYXRhX2xlbik7CiAJCWlmIChidWYgPT0gTlVMTCkgewogCQkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfV0FSTklORywKIAkJCQkiV1BBOiBObyBtZW1vcnkgZm9yIEFFUy1VTldSQVAgYnVmZmVyIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KLQkJaWYgKGFlc191bndyYXAoc20tPnB0ay5rZWssIGtleWRhdGFsZW4gLyA4LAotCQkJICAgICAgICh1OCAqKSAoa2V5ICsgMSksIGJ1ZikpIHsKKwkJaWYgKGFlc191bndyYXAoc20tPnB0ay5rZWssICprZXlfZGF0YV9sZW4gLyA4LAorCQkJICAgICAgIGtleV9kYXRhLCBidWYpKSB7CiAJCQlvc19mcmVlKGJ1Zik7CiAJCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19XQVJOSU5HLAogCQkJCSJXUEE6IEFFUyB1bndyYXAgZmFpbGVkIC0gIgogCQkJCSJjb3VsZCBub3QgZGVjcnlwdCBFQVBPTC1LZXkga2V5IGRhdGEiKTsKIAkJCXJldHVybiAtMTsKIAkJfQotCQlvc19tZW1jcHkoa2V5ICsgMSwgYnVmLCBrZXlkYXRhbGVuKTsKKwkJb3NfbWVtY3B5KGtleV9kYXRhLCBidWYsICprZXlfZGF0YV9sZW4pOwogCQlvc19mcmVlKGJ1Zik7Ci0JCVdQQV9QVVRfQkUxNihrZXktPmtleV9kYXRhX2xlbmd0aCwga2V5ZGF0YWxlbik7CisJCVdQQV9QVVRfQkUxNihrZXktPmtleV9kYXRhX2xlbmd0aCwgKmtleV9kYXRhX2xlbik7CiAJfSBlbHNlIHsKIAkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfV0FSTklORywKIAkJCSJXUEE6IFVuc3VwcG9ydGVkIGtleV9pbmZvIHR5cGUgJWQiLCB2ZXIpOwogCQlyZXR1cm4gLTE7CiAJfQogCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJXUEE6IGRlY3J5cHRlZCBFQVBPTC1LZXkga2V5IGRhdGEiLAotCQkJKHU4ICopIChrZXkgKyAxKSwga2V5ZGF0YWxlbik7CisJCQlrZXlfZGF0YSwgKmtleV9kYXRhX2xlbik7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTE1NDYsMTMgKzE1OTQsMTQgQEAKIGludCB3cGFfc21fcnhfZWFwb2woc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICpzcmNfYWRkciwKIAkJICAgIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCiB7Ci0Jc2l6ZV90IHBsZW4sIGRhdGFfbGVuLCBleHRyYV9sZW47Ci0Jc3RydWN0IGllZWU4MDJfMXhfaGRyICpoZHI7CisJc2l6ZV90IHBsZW4sIGRhdGFfbGVuLCBrZXlfZGF0YV9sZW47CisJY29uc3Qgc3RydWN0IGllZWU4MDJfMXhfaGRyICpoZHI7CiAJc3RydWN0IHdwYV9lYXBvbF9rZXkgKmtleTsKIAl1MTYga2V5X2luZm8sIHZlcjsKLQl1OCAqdG1wOworCXU4ICp0bXAgPSBOVUxMOwogCWludCByZXQgPSAtMTsKIAlzdHJ1Y3Qgd3BhX3BlZXJrZXkgKnBlZXJrZXkgPSBOVUxMOworCXU4ICprZXlfZGF0YTsKIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAJc20tPmZ0X2NvbXBsZXRlZCA9IDA7CkBAIC0xNTY3LDEzICsxNjE2LDcgQEAKIAkJcmV0dXJuIDA7CiAJfQogCi0JdG1wID0gb3NfbWFsbG9jKGxlbik7Ci0JaWYgKHRtcCA9PSBOVUxMKQotCQlyZXR1cm4gLTE7Ci0Jb3NfbWVtY3B5KHRtcCwgYnVmLCBsZW4pOwotCi0JaGRyID0gKHN0cnVjdCBpZWVlODAyXzF4X2hkciAqKSB0bXA7Ci0Ja2V5ID0gKHN0cnVjdCB3cGFfZWFwb2xfa2V5ICopIChoZHIgKyAxKTsKKwloZHIgPSAoY29uc3Qgc3RydWN0IGllZWU4MDJfMXhfaGRyICopIGJ1ZjsKIAlwbGVuID0gYmVfdG9faG9zdDE2KGhkci0+bGVuZ3RoKTsKIAlkYXRhX2xlbiA9IHBsZW4gKyBzaXplb2YoKmhkcik7CiAJd3BhX2RiZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfREVCVUcsCkBAIC0xNTkwLDYgKzE2MzMsNyBAQAogCQlyZXQgPSAwOwogCQlnb3RvIG91dDsKIAl9CisJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJXUEE6IFJYIEVBUE9MLUtleSIsIGJ1ZiwgbGVuKTsKIAlpZiAocGxlbiA+IGxlbiAtIHNpemVvZigqaGRyKSB8fCBwbGVuIDwgc2l6ZW9mKCprZXkpKSB7CiAJCXdwYV9kYmcoc20tPmN0eC0+bXNnX2N0eCwgTVNHX0RFQlVHLAogCQkJIldQQTogRUFQT0wgZnJhbWUgcGF5bG9hZCBzaXplICVsdSAiCkBAIC0xNTk4LDYgKzE2NDIsMjIgQEAKIAkJcmV0ID0gMDsKIAkJZ290byBvdXQ7CiAJfQorCWlmIChkYXRhX2xlbiA8IGxlbikgeworCQl3cGFfZGJnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19ERUJVRywKKwkJCSJXUEE6IGlnbm9yaW5nICVsdSBieXRlcyBhZnRlciB0aGUgSUVFRSA4MDIuMVggZGF0YSIsCisJCQkodW5zaWduZWQgbG9uZykgbGVuIC0gZGF0YV9sZW4pOworCX0KKworCS8qCisJICogTWFrZSBhIGNvcHkgb2YgdGhlIGZyYW1lIHNpbmNlIHdlIG5lZWQgdG8gbW9kaWZ5IHRoZSBidWZmZXIgZHVyaW5nCisJICogTUFDIHZhbGlkYXRpb24gYW5kIEtleSBEYXRhIGRlY3J5cHRpb24uCisJICovCisJdG1wID0gb3NfbWFsbG9jKGRhdGFfbGVuKTsKKwlpZiAodG1wID09IE5VTEwpCisJCWdvdG8gb3V0OworCW9zX21lbWNweSh0bXAsIGJ1ZiwgZGF0YV9sZW4pOworCWtleSA9IChzdHJ1Y3Qgd3BhX2VhcG9sX2tleSAqKSAodG1wICsgc2l6ZW9mKHN0cnVjdCBpZWVlODAyXzF4X2hkcikpOworCWtleV9kYXRhID0gKHU4ICopIChrZXkgKyAxKTsKIAogCWlmIChrZXktPnR5cGUgIT0gRUFQT0xfS0VZX1RZUEVfV1BBICYmIGtleS0+dHlwZSAhPSBFQVBPTF9LRVlfVFlQRV9SU04pCiAJewpAQCAtMTYwOSwyNiArMTY2OSwzOCBAQAogCX0KIAl3cGFfZWFwb2xfa2V5X2R1bXAoc20sIGtleSk7CiAKLQllYXBvbF9zbV9ub3RpZnlfbG93ZXJfbGF5ZXJfc3VjY2VzcyhzbS0+ZWFwb2wsIDApOwotCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiV1BBOiBSWCBFQVBPTC1LZXkiLCB0bXAsIGxlbik7Ci0JaWYgKGRhdGFfbGVuIDwgbGVuKSB7Ci0JCXdwYV9kYmcoc20tPmN0eC0+bXNnX2N0eCwgTVNHX0RFQlVHLAotCQkJIldQQTogaWdub3JpbmcgJWx1IGJ5dGVzIGFmdGVyIHRoZSBJRUVFIDgwMi4xWCBkYXRhIiwKLQkJCSh1bnNpZ25lZCBsb25nKSBsZW4gLSBkYXRhX2xlbik7CisJa2V5X2RhdGFfbGVuID0gV1BBX0dFVF9CRTE2KGtleS0+a2V5X2RhdGFfbGVuZ3RoKTsKKwlpZiAoa2V5X2RhdGFfbGVuID4gcGxlbiAtIHNpemVvZihzdHJ1Y3Qgd3BhX2VhcG9sX2tleSkpIHsKKwkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfSU5GTywgIldQQTogSW52YWxpZCBFQVBPTC1LZXkgIgorCQkJImZyYW1lIC0ga2V5X2RhdGEgb3ZlcmZsb3cgKCV1ID4gJXUpIiwKKwkJCSh1bnNpZ25lZCBpbnQpIGtleV9kYXRhX2xlbiwKKwkJCSh1bnNpZ25lZCBpbnQpIChwbGVuIC0gc2l6ZW9mKHN0cnVjdCB3cGFfZWFwb2xfa2V5KSkpOworCQlnb3RvIG91dDsKIAl9CisKKwllYXBvbF9zbV9ub3RpZnlfbG93ZXJfbGF5ZXJfc3VjY2VzcyhzbS0+ZWFwb2wsIDApOwogCWtleV9pbmZvID0gV1BBX0dFVF9CRTE2KGtleS0+a2V5X2luZm8pOwogCXZlciA9IGtleV9pbmZvICYgV1BBX0tFWV9JTkZPX1RZUEVfTUFTSzsKIAlpZiAodmVyICE9IFdQQV9LRVlfSU5GT19UWVBFX0hNQUNfTUQ1X1JDNCAmJgogI2lmIGRlZmluZWQoQ09ORklHX0lFRUU4MDIxMVIpIHx8IGRlZmluZWQoQ09ORklHX0lFRUU4MDIxMVcpCiAJICAgIHZlciAhPSBXUEFfS0VZX0lORk9fVFlQRV9BRVNfMTI4X0NNQUMgJiYKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiB8fCBDT05GSUdfSUVFRTgwMjExVyAqLwotCSAgICB2ZXIgIT0gV1BBX0tFWV9JTkZPX1RZUEVfSE1BQ19TSEExX0FFUykgeworCSAgICB2ZXIgIT0gV1BBX0tFWV9JTkZPX1RZUEVfSE1BQ19TSEExX0FFUyAmJgorCSAgICBzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX09TRU4pIHsKIAkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfSU5GTywKIAkJCSJXUEE6IFVuc3VwcG9ydGVkIEVBUE9MLUtleSBkZXNjcmlwdG9yIHZlcnNpb24gJWQiLAogCQkJdmVyKTsKIAkJZ290byBvdXQ7CiAJfQogCisJaWYgKHNtLT5rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfT1NFTiAmJgorCSAgICB2ZXIgIT0gV1BBX0tFWV9JTkZPX1RZUEVfQUtNX0RFRklORUQpIHsKKwkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfSU5GTywKKwkJCSJPU0VOOiBVbnN1cHBvcnRlZCBFQVBPTC1LZXkgZGVzY3JpcHRvciB2ZXJzaW9uICVkIiwKKwkJCXZlcik7CisJCWdvdG8gb3V0OworCX0KKwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAJaWYgKHdwYV9rZXlfbWdtdF9mdChzbS0+a2V5X21nbXQpKSB7CiAJCS8qIElFRUUgODAyLjExciB1c2VzIGEgbmV3IGtleV9pbmZvIHR5cGUgKEFFUy0xMjgtQ01BQykuICovCkBAIC0xNjQxLDcgKzE3MTMsOCBAQAogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKIAlpZiAod3BhX2tleV9tZ210X3NoYTI1NihzbS0+a2V5X21nbXQpKSB7Ci0JCWlmICh2ZXIgIT0gV1BBX0tFWV9JTkZPX1RZUEVfQUVTXzEyOF9DTUFDKSB7CisJCWlmICh2ZXIgIT0gV1BBX0tFWV9JTkZPX1RZUEVfQUVTXzEyOF9DTUFDICYmCisJCSAgICBzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX09TRU4pIHsKIAkJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX0lORk8sCiAJCQkJIldQQTogQVAgZGlkIG5vdCB1c2UgdGhlICIKIAkJCQkibmVnb3RpYXRlZCBBRVMtMTI4LUNNQUMiKTsKQEAgLTE2NjMsMTEgKzE3MzYsMTMgQEAKIAkJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX0lORk8sCiAJCQkJIldQQTogQmFja3dhcmRzIGNvbXBhdGliaWxpdHk6IGFsbG93IGludmFsaWQgIgogCQkJCSJ2ZXJzaW9uIGZvciBub24tQ0NNUCBncm91cCBrZXlzIik7CisJCX0gZWxzZSBpZiAodmVyID09IFdQQV9LRVlfSU5GT19UWVBFX0FFU18xMjhfQ01BQykgeworCQkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfSU5GTywKKwkJCQkiV1BBOiBJbnRlcm9wZXJhYmlsaXR5IHdvcmthcm91bmQ6IGFsbG93IGluY29ycmVjdCAoc2hvdWxkIGhhdmUgYmVlbiBITUFDLVNIQTEpLCBidXQgc3Ryb25nZXIgKGlzIEFFUy0xMjgtQ01BQyksIGRlc2NyaXB0b3IgdmVyc2lvbiB0byBiZSB1c2VkIik7CiAJCX0gZWxzZQogCQkJZ290byBvdXQ7Ci0JfQotCWlmIChzbS0+cGFpcndpc2VfY2lwaGVyID09IFdQQV9DSVBIRVJfR0NNUCAmJgotCSAgICB2ZXIgIT0gV1BBX0tFWV9JTkZPX1RZUEVfSE1BQ19TSEExX0FFUykgeworCX0gZWxzZSBpZiAoc20tPnBhaXJ3aXNlX2NpcGhlciA9PSBXUEFfQ0lQSEVSX0dDTVAgJiYKKwkJICAgdmVyICE9IFdQQV9LRVlfSU5GT19UWVBFX0hNQUNfU0hBMV9BRVMpIHsKIAkJd3BhX21zZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfSU5GTywKIAkJCSJXUEE6IEdDTVAgaXMgdXNlZCwgYnV0IEVBUE9MLUtleSAiCiAJCQkiZGVzY3JpcHRvciB2ZXJzaW9uICglZCkgaXMgbm90IDIiLCB2ZXIpOwpAQCAtMTc0NiwyMiArMTgyMSwxMSBAQAogCQlnb3RvIG91dDsKICNlbmRpZiAvKiBDT05GSUdfUEVFUktFWSAqLwogCi0JZXh0cmFfbGVuID0gZGF0YV9sZW4gLSBzaXplb2YoKmhkcikgLSBzaXplb2YoKmtleSk7Ci0KLQlpZiAoV1BBX0dFVF9CRTE2KGtleS0+a2V5X2RhdGFfbGVuZ3RoKSA+IGV4dHJhX2xlbikgewotCQl3cGFfbXNnKHNtLT5jdHgtPm1zZ19jdHgsIE1TR19JTkZPLCAiV1BBOiBJbnZhbGlkIEVBUE9MLUtleSAiCi0JCQkiZnJhbWUgLSBrZXlfZGF0YSBvdmVyZmxvdyAoJWQgPiAlbHUpIiwKLQkJCVdQQV9HRVRfQkUxNihrZXktPmtleV9kYXRhX2xlbmd0aCksCi0JCQkodW5zaWduZWQgbG9uZykgZXh0cmFfbGVuKTsKLQkJZ290byBvdXQ7Ci0JfQotCWV4dHJhX2xlbiA9IFdQQV9HRVRfQkUxNihrZXktPmtleV9kYXRhX2xlbmd0aCk7Ci0KLQlpZiAoc20tPnByb3RvID09IFdQQV9QUk9UT19SU04gJiYKKwlpZiAoKHNtLT5wcm90byA9PSBXUEFfUFJPVE9fUlNOIHx8IHNtLT5wcm90byA9PSBXUEFfUFJPVE9fT1NFTikgJiYKIAkgICAgKGtleV9pbmZvICYgV1BBX0tFWV9JTkZPX0VOQ1JfS0VZX0RBVEEpKSB7Ci0JCWlmICh3cGFfc3VwcGxpY2FudF9kZWNyeXB0X2tleV9kYXRhKHNtLCBrZXksIHZlcikpCisJCWlmICh3cGFfc3VwcGxpY2FudF9kZWNyeXB0X2tleV9kYXRhKHNtLCBrZXksIHZlciwga2V5X2RhdGEsCisJCQkJCQkgICAgJmtleV9kYXRhX2xlbikpCiAJCQlnb3RvIG91dDsKLQkJZXh0cmFfbGVuID0gV1BBX0dFVF9CRTE2KGtleS0+a2V5X2RhdGFfbGVuZ3RoKTsKIAl9CiAKIAlpZiAoa2V5X2luZm8gJiBXUEFfS0VZX0lORk9fS0VZX1RZUEUpIHsKQEAgLTE3NzMsMjQgKzE4MzcsMjggQEAKIAkJfQogCQlpZiAocGVlcmtleSkgewogCQkJLyogUGVlcktleSA0LVdheSBIYW5kc2hha2UgKi8KLQkJCXBlZXJrZXlfcnhfZWFwb2xfNHdheShzbSwgcGVlcmtleSwga2V5LCBrZXlfaW5mbywgdmVyKTsKKwkJCXBlZXJrZXlfcnhfZWFwb2xfNHdheShzbSwgcGVlcmtleSwga2V5LCBrZXlfaW5mbywgdmVyLAorCQkJCQkgICAgICBrZXlfZGF0YSwga2V5X2RhdGFfbGVuKTsKIAkJfSBlbHNlIGlmIChrZXlfaW5mbyAmIFdQQV9LRVlfSU5GT19NSUMpIHsKIAkJCS8qIDMvNCA0LVdheSBIYW5kc2hha2UgKi8KLQkJCXdwYV9zdXBwbGljYW50X3Byb2Nlc3NfM19vZl80KHNtLCBrZXksIHZlcik7CisJCQl3cGFfc3VwcGxpY2FudF9wcm9jZXNzXzNfb2ZfNChzbSwga2V5LCB2ZXIsIGtleV9kYXRhLAorCQkJCQkJICAgICAga2V5X2RhdGFfbGVuKTsKIAkJfSBlbHNlIHsKIAkJCS8qIDEvNCA0LVdheSBIYW5kc2hha2UgKi8KIAkJCXdwYV9zdXBwbGljYW50X3Byb2Nlc3NfMV9vZl80KHNtLCBzcmNfYWRkciwga2V5LAotCQkJCQkJICAgICAgdmVyKTsKKwkJCQkJCSAgICAgIHZlciwga2V5X2RhdGEsCisJCQkJCQkgICAgICBrZXlfZGF0YV9sZW4pOwogCQl9CiAJfSBlbHNlIGlmIChrZXlfaW5mbyAmIFdQQV9LRVlfSU5GT19TTUtfTUVTU0FHRSkgewogCQkvKiBQZWVyS2V5IFNNSyBIYW5kc2hha2UgKi8KLQkJcGVlcmtleV9yeF9lYXBvbF9zbWsoc20sIHNyY19hZGRyLCBrZXksIGV4dHJhX2xlbiwga2V5X2luZm8sCisJCXBlZXJrZXlfcnhfZWFwb2xfc21rKHNtLCBzcmNfYWRkciwga2V5LCBrZXlfZGF0YV9sZW4sIGtleV9pbmZvLAogCQkJCSAgICAgdmVyKTsKIAl9IGVsc2UgewogCQlpZiAoa2V5X2luZm8gJiBXUEFfS0VZX0lORk9fTUlDKSB7CiAJCQkvKiAxLzIgR3JvdXAgS2V5IEhhbmRzaGFrZSAqLwogCQkJd3BhX3N1cHBsaWNhbnRfcHJvY2Vzc18xX29mXzIoc20sIHNyY19hZGRyLCBrZXksCi0JCQkJCQkgICAgICBleHRyYV9sZW4sIHZlcik7CisJCQkJCQkgICAgICBrZXlfZGF0YSwga2V5X2RhdGFfbGVuLAorCQkJCQkJICAgICAgdmVyKTsKIAkJfSBlbHNlIHsKIAkJCXdwYV9tc2coc20tPmN0eC0+bXNnX2N0eCwgTVNHX1dBUk5JTkcsCiAJCQkJIldQQTogRUFQT0wtS2V5IChHcm91cCkgd2l0aG91dCBNaWMgYml0IC0gIgpAQCAtMTgxMSw3ICsxODc5LDggQEAKIHsKIAlzd2l0Y2ggKHNtLT5rZXlfbWdtdCkgewogCWNhc2UgV1BBX0tFWV9NR01UX0lFRUU4MDIxWDoKLQkJcmV0dXJuIChzbS0+cHJvdG8gPT0gV1BBX1BST1RPX1JTTiA/CisJCXJldHVybiAoKHNtLT5wcm90byA9PSBXUEFfUFJPVE9fUlNOIHx8CisJCQkgc20tPnByb3RvID09IFdQQV9QUk9UT19PU0VOKSA/CiAJCQlSU05fQVVUSF9LRVlfTUdNVF9VTlNQRUNfODAyXzFYIDoKIAkJCVdQQV9BVVRIX0tFWV9NR01UX1VOU1BFQ184MDJfMVgpOwogCWNhc2UgV1BBX0tFWV9NR01UX1BTSzoKQEAgLTIwNzQsMTIgKzIxNDMsMTggQEAKIAkJICovCiAJCXdwYV9kYmcoc20tPmN0eC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiV1BBOiBDbGVhciBvbGQgUFRLIik7CiAJCXNtLT5wdGtfc2V0ID0gMDsKKwkJb3NfbWVtc2V0KCZzbS0+cHRrLCAwLCBzaXplb2Yoc20tPnB0aykpOwogCQlzbS0+dHB0a19zZXQgPSAwOworCQlvc19tZW1zZXQoJnNtLT50cHRrLCAwLCBzaXplb2Yoc20tPnRwdGspKTsKIAl9CiAKICNpZmRlZiBDT05GSUdfVERMUwogCXdwYV90ZGxzX2Fzc29jKHNtKTsKICNlbmRpZiAvKiBDT05GSUdfVERMUyAqLworCisjaWZkZWYgQ09ORklHX1AyUAorCW9zX21lbXNldChzbS0+cDJwX2lwX2FkZHIsIDAsIHNpemVvZihzbS0+cDJwX2lwX2FkZHIpKTsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiB9CiAKIApAQCAtMjA5Miw2ICsyMTY3LDcgQEAKICAqLwogdm9pZCB3cGFfc21fbm90aWZ5X2Rpc2Fzc29jKHN0cnVjdCB3cGFfc20gKnNtKQogeworCXBlZXJrZXlfZGVpbml0KHNtKTsKIAlyc25fcHJlYXV0aF9kZWluaXQoc20pOwogCXBta3NhX2NhY2hlX2NsZWFyX2N1cnJlbnQoc20pOwogCWlmICh3cGFfc21fZ2V0X3N0YXRlKHNtKSA9PSBXUEFfNFdBWV9IQU5EU0hBS0UpCkBAIC0yMjAyLDYgKzIyNzgsNyBAQAogCQl9IGVsc2UKIAkJCXNtLT5zc2lkX2xlbiA9IDA7CiAJCXNtLT53cGFfcHRrX3Jla2V5ID0gY29uZmlnLT53cGFfcHRrX3Jla2V5OworCQlzbS0+cDJwID0gY29uZmlnLT5wMnA7CiAJfSBlbHNlIHsKIAkJc20tPm5ldHdvcmtfY3R4ID0gTlVMTDsKIAkJc20tPnBlZXJrZXlfZW5hYmxlZCA9IDA7CkBAIC0yMjExLDYgKzIyODgsNyBAQAogCQlzbS0+ZWFwX2NvbmZfY3R4ID0gTlVMTDsKIAkJc20tPnNzaWRfbGVuID0gMDsKIAkJc20tPndwYV9wdGtfcmVrZXkgPSAwOworCQlzbS0+cDJwID0gMDsKIAl9CiB9CiAKQEAgLTIzMjEsNDQgKzIzOTksNiBAQAogCiAKIC8qKgotICogd3BhX3NtX2dldF9wYXJhbSAtIEdldCBXUEEgc3RhdGUgbWFjaGluZSBwYXJhbWV0ZXJzCi0gKiBAc206IFBvaW50ZXIgdG8gV1BBIHN0YXRlIG1hY2hpbmUgZGF0YSBmcm9tIHdwYV9zbV9pbml0KCkKLSAqIEBwYXJhbTogUGFyYW1ldGVyIGZpZWxkCi0gKiBSZXR1cm5zOiBQYXJhbWV0ZXIgdmFsdWUKLSAqLwotdW5zaWduZWQgaW50IHdwYV9zbV9nZXRfcGFyYW0oc3RydWN0IHdwYV9zbSAqc20sIGVudW0gd3BhX3NtX2NvbmZfcGFyYW1zIHBhcmFtKQotewotCWlmIChzbSA9PSBOVUxMKQotCQlyZXR1cm4gMDsKLQotCXN3aXRjaCAocGFyYW0pIHsKLQljYXNlIFJTTkFfUE1LX0xJRkVUSU1FOgotCQlyZXR1cm4gc20tPmRvdDExUlNOQUNvbmZpZ1BNS0xpZmV0aW1lOwotCWNhc2UgUlNOQV9QTUtfUkVBVVRIX1RIUkVTSE9MRDoKLQkJcmV0dXJuIHNtLT5kb3QxMVJTTkFDb25maWdQTUtSZWF1dGhUaHJlc2hvbGQ7Ci0JY2FzZSBSU05BX1NBX1RJTUVPVVQ6Ci0JCXJldHVybiBzbS0+ZG90MTFSU05BQ29uZmlnU0FUaW1lb3V0OwotCWNhc2UgV1BBX1BBUkFNX1BST1RPOgotCQlyZXR1cm4gc20tPnByb3RvOwotCWNhc2UgV1BBX1BBUkFNX1BBSVJXSVNFOgotCQlyZXR1cm4gc20tPnBhaXJ3aXNlX2NpcGhlcjsKLQljYXNlIFdQQV9QQVJBTV9HUk9VUDoKLQkJcmV0dXJuIHNtLT5ncm91cF9jaXBoZXI7Ci0JY2FzZSBXUEFfUEFSQU1fS0VZX01HTVQ6Ci0JCXJldHVybiBzbS0+a2V5X21nbXQ7Ci0jaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKLQljYXNlIFdQQV9QQVJBTV9NR01UX0dST1VQOgotCQlyZXR1cm4gc20tPm1nbXRfZ3JvdXBfY2lwaGVyOwotI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCi0JY2FzZSBXUEFfUEFSQU1fUlNOX0VOQUJMRUQ6Ci0JCXJldHVybiBzbS0+cnNuX2VuYWJsZWQ7Ci0JZGVmYXVsdDoKLQkJcmV0dXJuIDA7Ci0JfQotfQotCi0KLS8qKgogICogd3BhX3NtX2dldF9zdGF0dXMgLSBHZXQgV1BBIHN0YXRlIG1hY2hpbmUKICAqIEBzbTogUG9pbnRlciB0byBXUEEgc3RhdGUgbWFjaGluZSBkYXRhIGZyb20gd3BhX3NtX2luaXQoKQogICogQGJ1ZjogQnVmZmVyIGZvciBzdGF0dXMgaW5mb3JtYXRpb24KQEAgLTI1OTksNiArMjYzOSw3IEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKIHZvaWQgd3BhX3NtX2Ryb3Bfc2Eoc3RydWN0IHdwYV9zbSAqc20pCiB7CiAJd3BhX2RiZyhzbS0+Y3R4LT5tc2dfY3R4LCBNU0dfREVCVUcsICJXUEE6IENsZWFyIG9sZCBQTUsgYW5kIFBUSyIpOwpAQCAtMjYwOCw2ICsyNjQ5LDcgQEAKIAlvc19tZW1zZXQoJnNtLT5wdGssIDAsIHNpemVvZihzbS0+cHRrKSk7CiAJb3NfbWVtc2V0KCZzbS0+dHB0aywgMCwgc2l6ZW9mKHNtLT50cHRrKSk7CiB9CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLwogCiAKIGludCB3cGFfc21faGFzX3B0ayhzdHJ1Y3Qgd3BhX3NtICpzbSkKQEAgLTI2MzMsMjkgKzI2NzUsMjIgQEAKICNpZmRlZiBDT05GSUdfV05NCiBpbnQgd3BhX3dubXNsZWVwX2luc3RhbGxfa2V5KHN0cnVjdCB3cGFfc20gKnNtLCB1OCBzdWJlbGVtX2lkLCB1OCAqYnVmKQogewotCXN0cnVjdCB3cGFfZ3RrX2RhdGEgZ2Q7Ci0jaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKLQlzdHJ1Y3Qgd3BhX2lndGtfa2RlIGlnZDsKLQl1MTYga2V5aWR4OwotI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAJdTE2IGtleWluZm87CiAJdTgga2V5bGVuOyAgLyogcGxhaW50ZXh0IGtleSBsZW4gKi8KIAl1OCAqa2V5X3JzYzsKIAotCW9zX21lbXNldCgmZ2QsIDAsIHNpemVvZihnZCkpOwotI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCi0Jb3NfbWVtc2V0KCZpZ2QsIDAsIHNpemVvZihpZ2QpKTsKLSNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwotCi0Ja2V5bGVuID0gd3BhX2NpcGhlcl9rZXlfbGVuKHNtLT5ncm91cF9jaXBoZXIpOwotCWdkLmtleV9yc2NfbGVuID0gd3BhX2NpcGhlcl9yc2NfbGVuKHNtLT5ncm91cF9jaXBoZXIpOwotCWdkLmFsZyA9IHdwYV9jaXBoZXJfdG9fYWxnKHNtLT5ncm91cF9jaXBoZXIpOwotCWlmIChnZC5hbGcgPT0gV1BBX0FMR19OT05FKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVW5zdXBwb3J0ZWQgZ3JvdXAgY2lwaGVyIHN1aXRlIik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KIAlpZiAoc3ViZWxlbV9pZCA9PSBXTk1fU0xFRVBfU1VCRUxFTV9HVEspIHsKKwkJc3RydWN0IHdwYV9ndGtfZGF0YSBnZDsKKworCQlvc19tZW1zZXQoJmdkLCAwLCBzaXplb2YoZ2QpKTsKKwkJa2V5bGVuID0gd3BhX2NpcGhlcl9rZXlfbGVuKHNtLT5ncm91cF9jaXBoZXIpOworCQlnZC5rZXlfcnNjX2xlbiA9IHdwYV9jaXBoZXJfcnNjX2xlbihzbS0+Z3JvdXBfY2lwaGVyKTsKKwkJZ2QuYWxnID0gd3BhX2NpcGhlcl90b19hbGcoc20tPmdyb3VwX2NpcGhlcik7CisJCWlmIChnZC5hbGcgPT0gV1BBX0FMR19OT05FKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlVuc3VwcG9ydGVkIGdyb3VwIGNpcGhlciBzdWl0ZSIpOworCQkJcmV0dXJuIC0xOworCQl9CisKIAkJa2V5X3JzYyA9IGJ1ZiArIDU7CiAJCWtleWluZm8gPSBXUEFfR0VUX0xFMTYoYnVmICsgMik7CiAJCWdkLmd0a19sZW4gPSBrZXlsZW47CkBAIC0yNjczLDI3ICsyNzA4LDM3IEBACiAJCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJJbnN0YWxsIEdUSyAoV05NIFNMRUVQKSIsCiAJCQkJZ2QuZ3RrLCBnZC5ndGtfbGVuKTsKIAkJaWYgKHdwYV9zdXBwbGljYW50X2luc3RhbGxfZ3RrKHNtLCAmZ2QsIGtleV9yc2MpKSB7CisJCQlvc19tZW1zZXQoJmdkLCAwLCBzaXplb2YoZ2QpKTsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRmFpbGVkIHRvIGluc3RhbGwgdGhlIEdUSyBpbiAiCiAJCQkJICAgIldOTSBtb2RlIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KKwkJb3NfbWVtc2V0KCZnZCwgMCwgc2l6ZW9mKGdkKSk7CiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKIAl9IGVsc2UgaWYgKHN1YmVsZW1faWQgPT0gV05NX1NMRUVQX1NVQkVMRU1fSUdUSykgeworCQlzdHJ1Y3Qgd3BhX2lndGtfa2RlIGlnZDsKKwkJdTE2IGtleWlkeDsKKworCQlvc19tZW1zZXQoJmlnZCwgMCwgc2l6ZW9mKGlnZCkpOworCQlrZXlsZW4gPSB3cGFfY2lwaGVyX2tleV9sZW4oc20tPm1nbXRfZ3JvdXBfY2lwaGVyKTsKIAkJb3NfbWVtY3B5KGlnZC5rZXlpZCwgYnVmICsgMiwgMik7CiAJCW9zX21lbWNweShpZ2QucG4sIGJ1ZiArIDQsIDYpOwogCiAJCWtleWlkeCA9IFdQQV9HRVRfTEUxNihpZ2Qua2V5aWQpOwotCQlvc19tZW1jcHkoaWdkLmlndGssIGJ1ZiArIDEwLCBXUEFfSUdUS19MRU4pOworCQlvc19tZW1jcHkoaWdkLmlndGssIGJ1ZiArIDEwLCBrZXlsZW4pOwogCiAJCXdwYV9oZXhkdW1wX2tleShNU0dfREVCVUcsICJJbnN0YWxsIElHVEsgKFdOTSBTTEVFUCkiLAotCQkJCWlnZC5pZ3RrLCBXUEFfSUdUS19MRU4pOwotCQlpZiAod3BhX3NtX3NldF9rZXkoc20sIFdQQV9BTEdfSUdUSywgYnJvYWRjYXN0X2V0aGVyX2FkZHIsCisJCQkJaWdkLmlndGssIGtleWxlbik7CisJCWlmICh3cGFfc21fc2V0X2tleShzbSwgd3BhX2NpcGhlcl90b19hbGcoc20tPm1nbXRfZ3JvdXBfY2lwaGVyKSwKKwkJCQkgICBicm9hZGNhc3RfZXRoZXJfYWRkciwKIAkJCQkgICBrZXlpZHgsIDAsIGlnZC5wbiwgc2l6ZW9mKGlnZC5wbiksCi0JCQkJICAgaWdkLmlndGssIFdQQV9JR1RLX0xFTikgPCAwKSB7CisJCQkJICAgaWdkLmlndGssIGtleWxlbikgPCAwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZhaWxlZCB0byBpbnN0YWxsIHRoZSBJR1RLIGluICIKIAkJCQkgICAiV05NIG1vZGUiKTsKKwkJCW9zX21lbXNldCgmaWdkLCAwLCBzaXplb2YoaWdkKSk7CiAJCQlyZXR1cm4gLTE7CiAJCX0KKwkJb3NfbWVtc2V0KCZpZ2QsIDAsIHNpemVvZihpZ2QpKTsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwogCX0gZWxzZSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVW5rbm93biBlbGVtZW50IGlkIik7CkBAIC0yNzAzLDMgKzI3NDgsMzcgQEAKIAlyZXR1cm4gMDsKIH0KICNlbmRpZiAvKiBDT05GSUdfV05NICovCisKKworI2lmZGVmIENPTkZJR19QRUVSS0VZCitpbnQgd3BhX3NtX3J4X2VhcG9sX3BlZXJrZXkoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICpzcmNfYWRkciwKKwkJCSAgICBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKQoreworCXN0cnVjdCB3cGFfcGVlcmtleSAqcGVlcmtleTsKKworCWZvciAocGVlcmtleSA9IHNtLT5wZWVya2V5OyBwZWVya2V5OyBwZWVya2V5ID0gcGVlcmtleS0+bmV4dCkgeworCQlpZiAob3NfbWVtY21wKHBlZXJrZXktPmFkZHIsIHNyY19hZGRyLCBFVEhfQUxFTikgPT0gMCkKKwkJCWJyZWFrOworCX0KKworCWlmICghcGVlcmtleSkKKwkJcmV0dXJuIDA7CisKKwl3cGFfc21fcnhfZWFwb2woc20sIHNyY19hZGRyLCBidWYsIGxlbik7CisKKwlyZXR1cm4gMTsKK30KKyNlbmRpZiAvKiBDT05GSUdfUEVFUktFWSAqLworCisKKyNpZmRlZiBDT05GSUdfUDJQCisKK2ludCB3cGFfc21fZ2V0X3AycF9pcF9hZGRyKHN0cnVjdCB3cGFfc20gKnNtLCB1OCAqYnVmKQoreworCWlmIChzbSA9PSBOVUxMIHx8IFdQQV9HRVRfQkUzMihzbS0+cDJwX2lwX2FkZHIpID09IDApCisJCXJldHVybiAtMTsKKwlvc19tZW1jcHkoYnVmLCBzbS0+cDJwX2lwX2FkZHIsIDMgKiA0KTsKKwlyZXR1cm4gMDsKK30KKworI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KZGlmZiAtLWdpdCBhL3NyYy9yc25fc3VwcC93cGEuaCBiL3NyYy9yc25fc3VwcC93cGEuaAppbmRleCAyNmU5YzZjLi4wN2E3YmY5IDEwMDY0NAotLS0gYS9zcmMvcnNuX3N1cHAvd3BhLmgKKysrIGIvc3JjL3Jzbl9zdXBwL3dwYS5oCkBAIC01NCw3ICs1NCw4IEBACiAJCQkgICAgIGludCAqdGRsc19leHRfc2V0dXApOwogCWludCAoKnNlbmRfdGRsc19tZ210KSh2b2lkICpjdHgsIGNvbnN0IHU4ICpkc3QsCiAJCQkgICAgICB1OCBhY3Rpb25fY29kZSwgdTggZGlhbG9nX3Rva2VuLAotCQkJICAgICAgdTE2IHN0YXR1c19jb2RlLCBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKTsKKwkJCSAgICAgIHUxNiBzdGF0dXNfY29kZSwgdTMyIHBlZXJfY2FwYWIsCisJCQkgICAgICBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKTsKIAlpbnQgKCp0ZGxzX29wZXIpKHZvaWQgKmN0eCwgaW50IG9wZXIsIGNvbnN0IHU4ICpwZWVyKTsKIAlpbnQgKCp0ZGxzX3BlZXJfYWRkc2V0KSh2b2lkICpjdHgsIGNvbnN0IHU4ICphZGRyLCBpbnQgYWRkLCB1MTYgYWlkLAogCQkJCXUxNiBjYXBhYmlsaXR5LCBjb25zdCB1OCAqc3VwcF9yYXRlcywKQEAgLTYyLDcgKzYzLDEwIEBACiAJCQkJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgKmh0X2NhcGFiLAogCQkJCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyAqdmh0X2NhcGFiLAogCQkJCXU4IHFvc2luZm8sIGNvbnN0IHU4ICpleHRfY2FwYWIsCi0JCQkJc2l6ZV90IGV4dF9jYXBhYl9sZW4pOworCQkJCXNpemVfdCBleHRfY2FwYWJfbGVuLCBjb25zdCB1OCAqc3VwcF9jaGFubmVscywKKwkJCQlzaXplX3Qgc3VwcF9jaGFubmVsc19sZW4sCisJCQkJY29uc3QgdTggKnN1cHBfb3Blcl9jbGFzc2VzLAorCQkJCXNpemVfdCBzdXBwX29wZXJfY2xhc3Nlc19sZW4pOwogI2VuZGlmIC8qIENPTkZJR19URExTICovCiAJdm9pZCAoKnNldF9yZWtleV9vZmZsb2FkKSh2b2lkICpjdHgsIGNvbnN0IHU4ICprZWssIGNvbnN0IHU4ICprY2ssCiAJCQkJICBjb25zdCB1OCAqcmVwbGF5X2N0cik7CkBAIC05Miw2ICs5Niw3IEBACiAJY29uc3QgdTggKnNzaWQ7CiAJc2l6ZV90IHNzaWRfbGVuOwogCWludCB3cGFfcHRrX3Jla2V5OworCWludCBwMnA7CiB9OwogCiAjaWZuZGVmIENPTkZJR19OT19XUEEKQEAgLTExOCw4ICsxMjMsNiBAQAogCiBpbnQgd3BhX3NtX3NldF9wYXJhbShzdHJ1Y3Qgd3BhX3NtICpzbSwgZW51bSB3cGFfc21fY29uZl9wYXJhbXMgcGFyYW0sCiAJCSAgICAgdW5zaWduZWQgaW50IHZhbHVlKTsKLXVuc2lnbmVkIGludCB3cGFfc21fZ2V0X3BhcmFtKHN0cnVjdCB3cGFfc20gKnNtLAotCQkJICAgICAgZW51bSB3cGFfc21fY29uZl9wYXJhbXMgcGFyYW0pOwogCiBpbnQgd3BhX3NtX2dldF9zdGF0dXMoc3RydWN0IHdwYV9zbSAqc20sIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbiwKIAkJICAgICAgaW50IHZlcmJvc2UpOwpAQCAtMTQyLDYgKzE0NSw4IEBACiAKIHZvaWQgd3BhX3NtX3Bta3NhX2NhY2hlX2ZsdXNoKHN0cnVjdCB3cGFfc20gKnNtLCB2b2lkICpuZXR3b3JrX2N0eCk7CiAKK2ludCB3cGFfc21fZ2V0X3AycF9pcF9hZGRyKHN0cnVjdCB3cGFfc20gKnNtLCB1OCAqYnVmKTsKKwogI2Vsc2UgLyogQ09ORklHX05PX1dQQSAqLwogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCB3cGFfc20gKiB3cGFfc21faW5pdChzdHJ1Y3Qgd3BhX3NtX2N0eCAqY3R4KQpAQCAtMjMzLDEyICsyMzgsNiBAQAogCXJldHVybiAtMTsKIH0KIAotc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgd3BhX3NtX2dldF9wYXJhbShzdHJ1Y3Qgd3BhX3NtICpzbSwKLQkJCQkJICAgIGVudW0gd3BhX3NtX2NvbmZfcGFyYW1zIHBhcmFtKQotewotCXJldHVybiAwOwotfQotCiBzdGF0aWMgaW5saW5lIGludCB3cGFfc21fZ2V0X3N0YXR1cyhzdHJ1Y3Qgd3BhX3NtICpzbSwgY2hhciAqYnVmLAogCQkJCSAgICBzaXplX3QgYnVmbGVuLCBpbnQgdmVyYm9zZSkKIHsKQEAgLTMwNiwxMSArMzA1LDE5IEBACiAKICNpZmRlZiBDT05GSUdfUEVFUktFWQogaW50IHdwYV9zbV9zdGtzdGFydChzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdTggKnBlZXIpOworaW50IHdwYV9zbV9yeF9lYXBvbF9wZWVya2V5KHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqc3JjX2FkZHIsCisJCQkgICAgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbik7CiAjZWxzZSAvKiBDT05GSUdfUEVFUktFWSAqLwogc3RhdGljIGlubGluZSBpbnQgd3BhX3NtX3N0a3N0YXJ0KHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqcGVlcikKIHsKIAlyZXR1cm4gLTE7CiB9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYV9zbV9yeF9lYXBvbF9wZWVya2V5KHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqc3JjX2FkZHIsCisJCQkJCSAgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbikKK3sKKwlyZXR1cm4gMDsKK30KICNlbmRpZiAvKiBDT05GSUdfUEVFUktFWSAqLwogCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKQEAgLTM3MiwxNCArMzc5LDE0IEBACiB2b2lkIHdwYV90ZGxzX2Fzc29jX3Jlc3BfaWVzKHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqaWVzLCBzaXplX3QgbGVuKTsKIGludCB3cGFfdGRsc19zdGFydChzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdTggKmFkZHIpOwogdm9pZCB3cGFfdGRsc19yZW1vdmUoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICphZGRyKTsKLWludCB3cGFfdGRsc19zZW5kX3RlYXJkb3duKHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqYWRkciwgdTE2IHJlYXNvbl9jb2RlKTsKIGludCB3cGFfdGRsc190ZWFyZG93bl9saW5rKHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqYWRkciwgdTE2IHJlYXNvbl9jb2RlKTsKIGludCB3cGFfdGRsc19zZW5kX2Rpc2NvdmVyeV9yZXF1ZXN0KHN0cnVjdCB3cGFfc20gKnNtLCBjb25zdCB1OCAqYWRkcik7CiBpbnQgd3BhX3RkbHNfaW5pdChzdHJ1Y3Qgd3BhX3NtICpzbSk7CiB2b2lkIHdwYV90ZGxzX3RlYXJkb3duX3BlZXJzKHN0cnVjdCB3cGFfc20gKnNtKTsKIHZvaWQgd3BhX3RkbHNfZGVpbml0KHN0cnVjdCB3cGFfc20gKnNtKTsKIHZvaWQgd3BhX3RkbHNfZW5hYmxlKHN0cnVjdCB3cGFfc20gKnNtLCBpbnQgZW5hYmxlZCk7Ci12b2lkIHdwYV90ZGxzX2Rpc2FibGVfbGluayhzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdTggKmFkZHIpOwordm9pZCB3cGFfdGRsc19kaXNhYmxlX3VucmVhY2hhYmxlX2xpbmsoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICphZGRyKTsKK2NvbnN0IGNoYXIgKiB3cGFfdGRsc19nZXRfbGlua19zdGF0dXMoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICphZGRyKTsKIGludCB3cGFfdGRsc19pc19leHRlcm5hbF9zZXR1cChzdHJ1Y3Qgd3BhX3NtICpzbSk7CiAKIGludCB3cGFfd25tc2xlZXBfaW5zdGFsbF9rZXkoc3RydWN0IHdwYV9zbSAqc20sIHU4IHN1YmVsZW1faWQsIHU4ICpidWYpOwpkaWZmIC0tZ2l0IGEvc3JjL3Jzbl9zdXBwL3dwYV9mdC5jIGIvc3JjL3Jzbl9zdXBwL3dwYV9mdC5jCmluZGV4IDNhNDBjOTYuLjRhNzViOTIgMTAwNjQ0Ci0tLSBhL3NyYy9yc25fc3VwcC93cGFfZnQuYworKysgYi9zcmMvcnNuX3N1cHAvd3BhX2Z0LmMKQEAgLTIwNyw2ICsyMDcsOCBAQAogCQlSU05fU0VMRUNUT1JfUFVUKHBvcywgUlNOX0FVVEhfS0VZX01HTVRfRlRfODAyXzFYKTsKIAllbHNlIGlmIChzbS0+a2V5X21nbXQgPT0gV1BBX0tFWV9NR01UX0ZUX1BTSykKIAkJUlNOX1NFTEVDVE9SX1BVVChwb3MsIFJTTl9BVVRIX0tFWV9NR01UX0ZUX1BTSyk7CisJZWxzZSBpZiAoc20tPmtleV9tZ210ID09IFdQQV9LRVlfTUdNVF9GVF9TQUUpCisJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQVVUSF9LRVlfTUdNVF9GVF9TQUUpOwogCWVsc2UgewogCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiRlQ6IEludmFsaWQga2V5IG1hbmFnZW1lbnQgdHlwZSAoJWQpIiwKIAkJCSAgIHNtLT5rZXlfbWdtdCk7CkBAIC00MDAsOCArNDAyLDcgQEAKIAkJfQogCX0KIAotCWlmIChzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX0ZUX0lFRUU4MDIxWCAmJgotCSAgICBzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX0ZUX1BTSykgeworCWlmICghd3BhX2tleV9tZ210X2Z0KHNtLT5rZXlfbWdtdCkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUmVqZWN0IEZUIElFcyBzaW5jZSBGVCBpcyBub3QgIgogCQkJICAgImVuYWJsZWQgZm9yIHRoaXMgY29ubmVjdGlvbiIpOwogCQlyZXR1cm4gLTE7CkBAIC00NDEsNyArNDQyLDggQEAKIAl9CiAKIAlpZiAocGFyc2UucjBraF9pZF9sZW4gIT0gc20tPnIwa2hfaWRfbGVuIHx8Ci0JICAgIG9zX21lbWNtcChwYXJzZS5yMGtoX2lkLCBzbS0+cjBraF9pZCwgcGFyc2UucjBraF9pZF9sZW4pICE9IDApIHsKKwkgICAgb3NfbWVtY21wX2NvbnN0KHBhcnNlLnIwa2hfaWQsIHNtLT5yMGtoX2lkLCBwYXJzZS5yMGtoX2lkX2xlbikgIT0gMCkKKwl7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IFIwS0gtSUQgaW4gRlRJRSBkaWQgbm90IG1hdGNoIHdpdGggIgogCQkJICAgInRoZSBjdXJyZW50IFIwS0gtSUQiKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRlQ6IFIwS0gtSUQgaW4gRlRJRSIsCkBAIC00NTcsNyArNDU5LDggQEAKIAl9CiAKIAlpZiAocGFyc2UucnNuX3Bta2lkID09IE5VTEwgfHwKLQkgICAgb3NfbWVtY21wKHBhcnNlLnJzbl9wbWtpZCwgc20tPnBta19yMF9uYW1lLCBXUEFfUE1LX05BTUVfTEVOKSkgeworCSAgICBvc19tZW1jbXBfY29uc3QocGFyc2UucnNuX3Bta2lkLCBzbS0+cG1rX3IwX25hbWUsIFdQQV9QTUtfTkFNRV9MRU4pKQorCXsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogTm8gbWF0Y2hpbmcgUE1LUjBOYW1lIChQTUtJRCkgaW4gIgogCQkJICAgIlJTTklFIik7CiAJCXJldHVybiAtMTsKQEAgLTUyNiw4ICs1MjksNyBAQAogCWlmIChzbSA9PSBOVUxMKQogCQlyZXR1cm4gMDsKIAotCWlmIChzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX0ZUX0lFRUU4MDIxWCAmJgotCSAgICBzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX0ZUX1BTSykKKwlpZiAoIXdwYV9rZXlfbWdtdF9mdChzbS0+a2V5X21nbXQpKQogCQlyZXR1cm4gMDsKIAogCXJldHVybiBzbS0+ZnRfY29tcGxldGVkOwpAQCAtNjc4LDggKzY4MCw3IEBACiAKIAl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJGVDogUmVzcG9uc2UgSUVzIiwgaWVzLCBpZXNfbGVuKTsKIAotCWlmIChzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX0ZUX0lFRUU4MDIxWCAmJgotCSAgICBzbS0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX0ZUX1BTSykgeworCWlmICghd3BhX2tleV9tZ210X2Z0KHNtLT5rZXlfbWdtdCkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGVDogUmVqZWN0IEZUIElFcyBzaW5jZSBGVCBpcyBub3QgIgogCQkJICAgImVuYWJsZWQgZm9yIHRoaXMgY29ubmVjdGlvbiIpOwogCQlyZXR1cm4gLTE7CkBAIC03MjgsNyArNzI5LDggQEAKIAl9CiAKIAlpZiAocGFyc2UucjBraF9pZF9sZW4gIT0gc20tPnIwa2hfaWRfbGVuIHx8Ci0JICAgIG9zX21lbWNtcChwYXJzZS5yMGtoX2lkLCBzbS0+cjBraF9pZCwgcGFyc2UucjBraF9pZF9sZW4pICE9IDApIHsKKwkgICAgb3NfbWVtY21wX2NvbnN0KHBhcnNlLnIwa2hfaWQsIHNtLT5yMGtoX2lkLCBwYXJzZS5yMGtoX2lkX2xlbikgIT0gMCkKKwl7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IFIwS0gtSUQgaW4gRlRJRSBkaWQgbm90IG1hdGNoIHdpdGggIgogCQkJICAgInRoZSBjdXJyZW50IFIwS0gtSUQiKTsKIAkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRlQ6IFIwS0gtSUQgaW4gRlRJRSIsCkBAIC03NDMsMTQgKzc0NSwxNSBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKG9zX21lbWNtcChwYXJzZS5yMWtoX2lkLCBzbS0+cjFraF9pZCwgRlRfUjFLSF9JRF9MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KHBhcnNlLnIxa2hfaWQsIHNtLT5yMWtoX2lkLCBGVF9SMUtIX0lEX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBVbmtub3duIFIxS0gtSUQgdXNlZCBpbiAiCiAJCQkgICAiUmVhc3NvY1Jlc3AiKTsKIAkJcmV0dXJuIC0xOwogCX0KIAogCWlmIChwYXJzZS5yc25fcG1raWQgPT0gTlVMTCB8fAotCSAgICBvc19tZW1jbXAocGFyc2UucnNuX3Bta2lkLCBzbS0+cG1rX3IxX25hbWUsIFdQQV9QTUtfTkFNRV9MRU4pKSB7CisJICAgIG9zX21lbWNtcF9jb25zdChwYXJzZS5yc25fcG1raWQsIHNtLT5wbWtfcjFfbmFtZSwgV1BBX1BNS19OQU1FX0xFTikpCisJewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZUOiBObyBtYXRjaGluZyBQTUtSMU5hbWUgKFBNS0lEKSBpbiAiCiAJCQkgICAiUlNOSUUgKHBta2lkPSVkKSIsICEhcGFyc2UucnNuX3Bta2lkKTsKIAkJcmV0dXJuIC0xOwpAQCAtNzc2LDcgKzc3OSw3IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQlpZiAob3NfbWVtY21wKG1pYywgZnRpZS0+bWljLCAxNikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QobWljLCBmdGllLT5taWMsIDE2KSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRlQ6IEludmFsaWQgTUlDIGluIEZUSUUiKTsKIAkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJGVDogUmVjZWl2ZWQgTUlDIiwgZnRpZS0+bWljLCAxNik7CiAJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiRlQ6IENhbGN1bGF0ZWQgTUlDIiwgbWljLCAxNik7CmRpZmYgLS1naXQgYS9zcmMvcnNuX3N1cHAvd3BhX2kuaCBiL3NyYy9yc25fc3VwcC93cGFfaS5oCmluZGV4IDBlMGQzNzMuLmUyMGU5ZGEgMTAwNjQ0Ci0tLSBhL3NyYy9yc25fc3VwcC93cGFfaS5oCisrKyBiL3NyYy9yc25fc3VwcC93cGFfaS5oCkBAIC01OCw2ICs1OCw3IEBACiAJdTggc3NpZFszMl07CiAJc2l6ZV90IHNzaWRfbGVuOwogCWludCB3cGFfcHRrX3Jla2V5OworCWludCBwMnA7CiAKIAl1OCBvd25fYWRkcltFVEhfQUxFTl07CiAJY29uc3QgY2hhciAqaWZuYW1lOwpAQCAtMTIyLDYgKzEyMywxMCBAQAogCXU4ICphc3NvY19yZXNwX2llczsgLyogTURJRSBhbmQgRlRJRSBmcm9tIChSZSlBc3NvY2lhdGlvbiBSZXNwb25zZSAqLwogCXNpemVfdCBhc3NvY19yZXNwX2llc19sZW47CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KKworI2lmZGVmIENPTkZJR19QMlAKKwl1OCBwMnBfaXBfYWRkclszICogNF07CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogfTsKIAogCkBAIC0yNjIsMTMgKzI2NywxMyBAQAogCiBzdGF0aWMgaW5saW5lIGludCB3cGFfc21fc2VuZF90ZGxzX21nbXQoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHU4ICpkc3QsCiAJCQkJCXU4IGFjdGlvbl9jb2RlLCB1OCBkaWFsb2dfdG9rZW4sCi0JCQkJCXUxNiBzdGF0dXNfY29kZSwgY29uc3QgdTggKmJ1ZiwKLQkJCQkJc2l6ZV90IGxlbikKKwkJCQkJdTE2IHN0YXR1c19jb2RlLCB1MzIgcGVlcl9jYXBhYiwKKwkJCQkJY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbikKIHsKIAlpZiAoc20tPmN0eC0+c2VuZF90ZGxzX21nbXQpCiAJCXJldHVybiBzbS0+Y3R4LT5zZW5kX3RkbHNfbWdtdChzbS0+Y3R4LT5jdHgsIGRzdCwgYWN0aW9uX2NvZGUsCiAJCQkJCSAgICAgICBkaWFsb2dfdG9rZW4sIHN0YXR1c19jb2RlLAotCQkJCQkgICAgICAgYnVmLCBsZW4pOworCQkJCQkgICAgICAgcGVlcl9jYXBhYiwgYnVmLCBsZW4pOwogCXJldHVybiAtMTsKIH0KIApAQCAtMjg2LDE0ICsyOTEsMjEgQEAKIAkJCXNpemVfdCBzdXBwX3JhdGVzX2xlbiwKIAkJCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwYWJpbGl0aWVzICpodF9jYXBhYiwKIAkJCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyAqdmh0X2NhcGFiLAotCQkJdTggcW9zaW5mbywgY29uc3QgdTggKmV4dF9jYXBhYiwgc2l6ZV90IGV4dF9jYXBhYl9sZW4pCisJCQl1OCBxb3NpbmZvLCBjb25zdCB1OCAqZXh0X2NhcGFiLCBzaXplX3QgZXh0X2NhcGFiX2xlbiwKKwkJCWNvbnN0IHU4ICpzdXBwX2NoYW5uZWxzLCBzaXplX3Qgc3VwcF9jaGFubmVsc19sZW4sCisJCQljb25zdCB1OCAqc3VwcF9vcGVyX2NsYXNzZXMsCisJCQlzaXplX3Qgc3VwcF9vcGVyX2NsYXNzZXNfbGVuKQogewogCWlmIChzbS0+Y3R4LT50ZGxzX3BlZXJfYWRkc2V0KQogCQlyZXR1cm4gc20tPmN0eC0+dGRsc19wZWVyX2FkZHNldChzbS0+Y3R4LT5jdHgsIGFkZHIsIGFkZCwKIAkJCQkJCSBhaWQsIGNhcGFiaWxpdHksIHN1cHBfcmF0ZXMsCiAJCQkJCQkgc3VwcF9yYXRlc19sZW4sIGh0X2NhcGFiLAogCQkJCQkJIHZodF9jYXBhYiwgcW9zaW5mbywKLQkJCQkJCSBleHRfY2FwYWIsIGV4dF9jYXBhYl9sZW4pOworCQkJCQkJIGV4dF9jYXBhYiwgZXh0X2NhcGFiX2xlbiwKKwkJCQkJCSBzdXBwX2NoYW5uZWxzLAorCQkJCQkJIHN1cHBfY2hhbm5lbHNfbGVuLAorCQkJCQkJIHN1cHBfb3Blcl9jbGFzc2VzLAorCQkJCQkJIHN1cHBfb3Blcl9jbGFzc2VzX2xlbik7CiAJcmV0dXJuIC0xOwogfQogI2VuZGlmIC8qIENPTkZJR19URExTICovCkBAIC0zMDksNyArMzIxLDYgQEAKIGludCB3cGFfc3VwcGxpY2FudF9zZW5kXzRfb2ZfNChzdHJ1Y3Qgd3BhX3NtICpzbSwgY29uc3QgdW5zaWduZWQgY2hhciAqZHN0LAogCQkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFfZWFwb2xfa2V5ICprZXksCiAJCQkgICAgICAgdTE2IHZlciwgdTE2IGtleV9pbmZvLAotCQkJICAgICAgIGNvbnN0IHU4ICprZGUsIHNpemVfdCBrZGVfbGVuLAogCQkJICAgICAgIHN0cnVjdCB3cGFfcHRrICpwdGspOwogCiBpbnQgd3BhX2Rlcml2ZV9wdGtfZnQoc3RydWN0IHdwYV9zbSAqc20sIGNvbnN0IHVuc2lnbmVkIGNoYXIgKnNyY19hZGRyLApkaWZmIC0tZ2l0IGEvc3JjL3Jzbl9zdXBwL3dwYV9pZS5jIGIvc3JjL3Jzbl9zdXBwL3dwYV9pZS5jCmluZGV4IDUwYjkyNzIuLjIzMjkwMzMgMTAwNjQ0Ci0tLSBhL3NyYy9yc25fc3VwcC93cGFfaWUuYworKysgYi9zcmMvcnNuX3N1cHAvd3BhX2llLmMKQEAgLTIwMSw3ICsyMDEsNyBAQAogCX0KIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCi0JaWYgKG1nbXRfZ3JvdXBfY2lwaGVyID09IFdQQV9DSVBIRVJfQUVTXzEyOF9DTUFDKSB7CisJaWYgKHdwYV9jaXBoZXJfdmFsaWRfbWdtdF9ncm91cChtZ210X2dyb3VwX2NpcGhlcikpIHsKIAkJaWYgKCFzbS0+Y3VyX3Bta3NhKSB7CiAJCQkvKiBQTUtJRCBDb3VudCAqLwogCQkJV1BBX1BVVF9MRTE2KHBvcywgMCk7CkBAIC0yMDksNyArMjA5LDggQEAKIAkJfQogCiAJCS8qIE1hbmFnZW1lbnQgR3JvdXAgQ2lwaGVyIFN1aXRlICovCi0JCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBSU05fQ0lQSEVSX1NVSVRFX0FFU18xMjhfQ01BQyk7CisJCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCB3cGFfY2lwaGVyX3RvX3N1aXRlKFdQQV9QUk9UT19SU04sCisJCQkJCQkJICBtZ210X2dyb3VwX2NpcGhlcikpOwogCQlwb3MgKz0gUlNOX1NFTEVDVE9SX0xFTjsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KQEAgLTIyMiw2ICsyMjMsNjQgQEAKIH0KIAogCisjaWZkZWYgQ09ORklHX0hTMjAKK3N0YXRpYyBpbnQgd3BhX2dlbl93cGFfaWVfb3Nlbih1OCAqd3BhX2llLCBzaXplX3Qgd3BhX2llX2xlbiwKKwkJCSAgICAgICBpbnQgcGFpcndpc2VfY2lwaGVyLCBpbnQgZ3JvdXBfY2lwaGVyLAorCQkJICAgICAgIGludCBrZXlfbWdtdCkKK3sKKwl1OCAqcG9zLCAqbGVuOworCXUzMiBzdWl0ZTsKKworCWlmICh3cGFfaWVfbGVuIDwgMiArIDQgKyBSU05fU0VMRUNUT1JfTEVOICsKKwkgICAgMiArIFJTTl9TRUxFQ1RPUl9MRU4gKyAyICsgUlNOX1NFTEVDVE9SX0xFTikKKwkJcmV0dXJuIC0xOworCisJcG9zID0gd3BhX2llOworCSpwb3MrKyA9IFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQzsKKwlsZW4gPSBwb3MrKzsgLyogdG8gYmUgZmlsbGVkICovCisJV1BBX1BVVF9CRTI0KHBvcywgT1VJX1dGQSk7CisJcG9zICs9IDM7CisJKnBvcysrID0gSFMyMF9PU0VOX09VSV9UWVBFOworCisJLyogR3JvdXAgRGF0YSBDaXBoZXIgU3VpdGUgKi8KKwlzdWl0ZSA9IHdwYV9jaXBoZXJfdG9fc3VpdGUoV1BBX1BST1RPX1JTTiwgZ3JvdXBfY2lwaGVyKTsKKwlpZiAoc3VpdGUgPT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiSW52YWxpZCBncm91cCBjaXBoZXIgKCVkKS4iLAorCQkJICAgZ3JvdXBfY2lwaGVyKTsKKwkJcmV0dXJuIC0xOworCX0KKwlSU05fU0VMRUNUT1JfUFVUKHBvcywgc3VpdGUpOworCXBvcyArPSBSU05fU0VMRUNUT1JfTEVOOworCisJLyogUGFpcndpc2UgQ2lwaGVyIFN1aXRlIENvdW50IGFuZCBMaXN0ICovCisJV1BBX1BVVF9MRTE2KHBvcywgMSk7CisJcG9zICs9IDI7CisJc3VpdGUgPSB3cGFfY2lwaGVyX3RvX3N1aXRlKFdQQV9QUk9UT19SU04sIHBhaXJ3aXNlX2NpcGhlcik7CisJaWYgKHN1aXRlID09IDAgfHwKKwkgICAgKCF3cGFfY2lwaGVyX3ZhbGlkX3BhaXJ3aXNlKHBhaXJ3aXNlX2NpcGhlcikgJiYKKwkgICAgIHBhaXJ3aXNlX2NpcGhlciAhPSBXUEFfQ0lQSEVSX05PTkUpKSB7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJJbnZhbGlkIHBhaXJ3aXNlIGNpcGhlciAoJWQpLiIsCisJCQkgICBwYWlyd2lzZV9jaXBoZXIpOworCQlyZXR1cm4gLTE7CisJfQorCVJTTl9TRUxFQ1RPUl9QVVQocG9zLCBzdWl0ZSk7CisJcG9zICs9IFJTTl9TRUxFQ1RPUl9MRU47CisKKwkvKiBBS00gU3VpdGUgQ291bnQgYW5kIExpc3QgKi8KKwlXUEFfUFVUX0xFMTYocG9zLCAxKTsKKwlwb3MgKz0gMjsKKwlSU05fU0VMRUNUT1JfUFVUKHBvcywgUlNOX0FVVEhfS0VZX01HTVRfT1NFTik7CisJcG9zICs9IFJTTl9TRUxFQ1RPUl9MRU47CisKKwkqbGVuID0gcG9zIC0gbGVuIC0gMTsKKworCVdQQV9BU1NFUlQoKHNpemVfdCkgKHBvcyAtIHdwYV9pZSkgPD0gd3BhX2llX2xlbik7CisKKwlyZXR1cm4gcG9zIC0gd3BhX2llOworfQorI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisKKwogLyoqCiAgKiB3cGFfZ2VuX3dwYV9pZSAtIEdlbmVyYXRlIFdQQS9SU04gSUUgYmFzZWQgb24gY3VycmVudCBzZWN1cml0eSBwb2xpY3kKICAqIEBzbTogUG9pbnRlciB0byBXUEEgc3RhdGUgbWFjaGluZSBkYXRhIGZyb20gd3BhX3NtX2luaXQoKQpAQCAtMjM3LDYgKzI5NiwxMyBAQAogCQkJCQkgIHNtLT5ncm91cF9jaXBoZXIsCiAJCQkJCSAgc20tPmtleV9tZ210LCBzbS0+bWdtdF9ncm91cF9jaXBoZXIsCiAJCQkJCSAgc20pOworI2lmZGVmIENPTkZJR19IUzIwCisJZWxzZSBpZiAoc20tPnByb3RvID09IFdQQV9QUk9UT19PU0VOKQorCQlyZXR1cm4gd3BhX2dlbl93cGFfaWVfb3Nlbih3cGFfaWUsIHdwYV9pZV9sZW4sCisJCQkJCSAgIHNtLT5wYWlyd2lzZV9jaXBoZXIsCisJCQkJCSAgIHNtLT5ncm91cF9jaXBoZXIsCisJCQkJCSAgIHNtLT5rZXlfbWdtdCk7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAllbHNlCiAJCXJldHVybiB3cGFfZ2VuX3dwYV9pZV93cGEod3BhX2llLCB3cGFfaWVfbGVuLAogCQkJCQkgIHNtLT5wYWlyd2lzZV9jaXBoZXIsCkBAIC0yNDYsNiArMzEyLDQyIEBACiAKIAogLyoqCisgKiB3cGFfcGFyc2VfdmVuZG9yX3NwZWNpZmljIC0gUGFyc2UgVmVuZG9yIFNwZWNpZmljIElFcworICogQHBvczogUG9pbnRlciB0byB0aGUgSUUgaGVhZGVyCisgKiBAZW5kOiBQb2ludGVyIHRvIHRoZSBlbmQgb2YgdGhlIEtleSBEYXRhIGJ1ZmZlcgorICogQGllOiBQb2ludGVyIHRvIHBhcnNlZCBJRSBkYXRhCisgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIDEgaWYgZW5kIG1hcmsgaXMgZm91bmQsIC0xIG9uIGZhaWx1cmUKKyAqLworc3RhdGljIGludCB3cGFfcGFyc2VfdmVuZG9yX3NwZWNpZmljKGNvbnN0IHU4ICpwb3MsIGNvbnN0IHU4ICplbmQsCisJCQkJICAgICBzdHJ1Y3Qgd3BhX2VhcG9sX2llX3BhcnNlICppZSkKK3sKKwl1bnNpZ25lZCBpbnQgb3VpOworCisJaWYgKHBvc1sxXSA8IDQpIHsKKwkJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIlRvbyBzaG9ydCB2ZW5kb3Igc3BlY2lmaWMgSUUgaWdub3JlZCAobGVuPSV1KSIsCisJCQkgICBwb3NbMV0pOworCQlyZXR1cm4gMTsKKwl9CisKKwlvdWkgPSBXUEFfR0VUX0JFMjQoJnBvc1syXSk7CisJaWYgKG91aSA9PSBPVUlfTUlDUk9TT0ZUICYmIHBvc1s1XSA9PSBXTU1fT1VJX1RZUEUgJiYgcG9zWzFdID4gNCkgeworCQlpZiAocG9zWzZdID09IFdNTV9PVUlfU1VCVFlQRV9JTkZPUk1BVElPTl9FTEVNRU5UKSB7CisJCQlpZS0+d21tID0gJnBvc1syXTsKKwkJCWllLT53bW1fbGVuID0gcG9zWzFdOworCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BBOiBXTU0gSUUiLAorCQkJCSAgICBpZS0+d21tLCBpZS0+d21tX2xlbik7CisJCX0gZWxzZSBpZiAocG9zWzZdID09IFdNTV9PVUlfU1VCVFlQRV9QQVJBTUVURVJfRUxFTUVOVCkgeworCQkJaWUtPndtbSA9ICZwb3NbMl07CisJCQlpZS0+d21tX2xlbiA9IHBvc1sxXTsKKwkJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldQQTogV01NIFBhcmFtZXRlciBFbGVtZW50IiwKKwkJCQkgICAgaWUtPndtbSwgaWUtPndtbV9sZW4pOworCQl9CisJfQorCXJldHVybiAwOworfQorCisKKy8qKgogICogd3BhX3BhcnNlX2dlbmVyaWMgLSBQYXJzZSBFQVBPTC1LZXkgS2V5IERhdGEgR2VuZXJpYyBJRXMKICAqIEBwb3M6IFBvaW50ZXIgdG8gdGhlIElFIGhlYWRlcgogICogQGVuZDogUG9pbnRlciB0byB0aGUgZW5kIG9mIHRoZSBLZXkgRGF0YSBidWZmZXIKQEAgLTM0NSw2ICs0NDcsMjUgQEAKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIAorI2lmZGVmIENPTkZJR19QMlAKKwlpZiAocG9zWzFdID49IFJTTl9TRUxFQ1RPUl9MRU4gKyAxICYmCisJICAgIFJTTl9TRUxFQ1RPUl9HRVQocG9zICsgMikgPT0gV0ZBX0tFWV9EQVRBX0lQX0FERFJfUkVRKSB7CisJCWllLT5pcF9hZGRyX3JlcSA9IHBvcyArIDIgKyBSU05fU0VMRUNUT1JfTEVOOworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUEE6IElQIEFkZHJlc3MgUmVxdWVzdCBpbiBFQVBPTC1LZXkiLAorCQkJICAgIGllLT5pcF9hZGRyX3JlcSwgcG9zWzFdIC0gUlNOX1NFTEVDVE9SX0xFTik7CisJCXJldHVybiAwOworCX0KKworCWlmIChwb3NbMV0gPj0gUlNOX1NFTEVDVE9SX0xFTiArIDMgKiA0ICYmCisJICAgIFJTTl9TRUxFQ1RPUl9HRVQocG9zICsgMikgPT0gV0ZBX0tFWV9EQVRBX0lQX0FERFJfQUxMT0MpIHsKKwkJaWUtPmlwX2FkZHJfYWxsb2MgPSBwb3MgKyAyICsgUlNOX1NFTEVDVE9SX0xFTjsKKwkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLAorCQkJICAgICJXUEE6IElQIEFkZHJlc3MgQWxsb2NhdGlvbiBpbiBFQVBPTC1LZXkiLAorCQkJICAgIGllLT5pcF9hZGRyX2FsbG9jLCBwb3NbMV0gLSBSU05fU0VMRUNUT1JfTEVOKTsKKwkJcmV0dXJuIDA7CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKwogCXJldHVybiAwOwogfQogCkBAIC00MzQsNiArNTU1LDIwIEBACiAJCQlpZS0+dmh0X2NhcGFiaWxpdGllc19sZW4gPSBwb3NbMV07CiAJCX0gZWxzZSBpZiAoKnBvcyA9PSBXTEFOX0VJRF9RT1MgJiYgcG9zWzFdID49IDEpIHsKIAkJCWllLT5xb3NpbmZvID0gcG9zWzJdOworCQl9IGVsc2UgaWYgKCpwb3MgPT0gV0xBTl9FSURfU1VQUE9SVEVEX0NIQU5ORUxTKSB7CisJCQlpZS0+c3VwcF9jaGFubmVscyA9IHBvcyArIDI7CisJCQlpZS0+c3VwcF9jaGFubmVsc19sZW4gPSBwb3NbMV07CisJCX0gZWxzZSBpZiAoKnBvcyA9PSBXTEFOX0VJRF9TVVBQT1JURURfT1BFUkFUSU5HX0NMQVNTRVMpIHsKKwkJCS8qCisJCQkgKiBUaGUgdmFsdWUgb2YgdGhlIExlbmd0aCBmaWVsZCBvZiB0aGUgU3VwcG9ydGVkCisJCQkgKiBPcGVyYXRpbmcgQ2xhc3NlcyBlbGVtZW50IGlzIGJldHdlZW4gMiBhbmQgMjUzLgorCQkJICogU2lsZW50bHkgc2tpcCBpbnZhbGlkIGVsZW1lbnRzIHRvIGF2b2lkIGludGVyb3AKKwkJCSAqIGlzc3VlcyB3aGVuIHRyeWluZyB0byB1c2UgdGhlIHZhbHVlLgorCQkJICovCisJCQlpZiAocG9zWzFdID49IDIgJiYgcG9zWzFdIDw9IDI1MykgeworCQkJCWllLT5zdXBwX29wZXJfY2xhc3NlcyA9IHBvcyArIDI7CisJCQkJaWUtPnN1cHBfb3Blcl9jbGFzc2VzX2xlbiA9IHBvc1sxXTsKKwkJCX0KIAkJfSBlbHNlIGlmICgqcG9zID09IFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQykgewogCQkJcmV0ID0gd3BhX3BhcnNlX2dlbmVyaWMocG9zLCBlbmQsIGllKTsKIAkJCWlmIChyZXQgPCAwKQpAQCAtNDQyLDYgKzU3NywxNCBAQAogCQkJCXJldCA9IDA7CiAJCQkJYnJlYWs7CiAJCQl9CisKKwkJCXJldCA9IHdwYV9wYXJzZV92ZW5kb3Jfc3BlY2lmaWMocG9zLCBlbmQsIGllKTsKKwkJCWlmIChyZXQgPCAwKQorCQkJCWJyZWFrOworCQkJaWYgKHJldCA+IDApIHsKKwkJCQlyZXQgPSAwOworCQkJCWJyZWFrOworCQkJfQogCQl9IGVsc2UgewogCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BBOiBVbnJlY29nbml6ZWQgRUFQT0wtS2V5ICIKIAkJCQkgICAgIktleSBEYXRhIElFIiwgcG9zLCAyICsgcG9zWzFdKTsKZGlmZiAtLWdpdCBhL3NyYy9yc25fc3VwcC93cGFfaWUuaCBiL3NyYy9yc25fc3VwcC93cGFfaWUuaAppbmRleCAyYzc4ODAxLi4wZmM0MmNjIDEwMDY0NAotLS0gYS9zcmMvcnNuX3N1cHAvd3BhX2llLmgKKysrIGIvc3JjL3Jzbl9zdXBwL3dwYV9pZS5oCkBAIC01Myw4ICs1MywxOCBAQAogCXNpemVfdCBodF9jYXBhYmlsaXRpZXNfbGVuOwogCWNvbnN0IHU4ICp2aHRfY2FwYWJpbGl0aWVzOwogCXNpemVfdCB2aHRfY2FwYWJpbGl0aWVzX2xlbjsKKwljb25zdCB1OCAqc3VwcF9jaGFubmVsczsKKwlzaXplX3Qgc3VwcF9jaGFubmVsc19sZW47CisJY29uc3QgdTggKnN1cHBfb3Blcl9jbGFzc2VzOworCXNpemVfdCBzdXBwX29wZXJfY2xhc3Nlc19sZW47CiAJdTggcW9zaW5mbzsKIAl1MTYgYWlkOworCWNvbnN0IHU4ICp3bW07CisJc2l6ZV90IHdtbV9sZW47CisjaWZkZWYgQ09ORklHX1AyUAorCWNvbnN0IHU4ICppcF9hZGRyX3JlcTsKKwljb25zdCB1OCAqaXBfYWRkcl9hbGxvYzsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiB9OwogCiBpbnQgd3BhX3N1cHBsaWNhbnRfcGFyc2VfaWVzKGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4sCmRpZmYgLS1naXQgYS9zcmMvdGxzL2FzbjEuYyBiL3NyYy90bHMvYXNuMS5jCmluZGV4IDUzYWNkNTMuLjk3NDYyZmEgMTAwNjQ0Ci0tLSBhL3NyYy90bHMvYXNuMS5jCisrKyBiL3NyYy90bHMvYXNuMS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIEFTTi4xIERFUiBwYXJzaW5nCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTEsNiArMTEsMTcgQEAKICNpbmNsdWRlICJjb21tb24uaCIKICNpbmNsdWRlICJhc24xLmgiCiAKK3N0cnVjdCBhc24xX29pZCBhc24xX3NoYTFfb2lkID0geworCS5vaWQgPSB7IDEsIDMsIDE0LCAzLCAyLCAyNiB9LAorCS5sZW4gPSA2Cit9OworCitzdHJ1Y3QgYXNuMV9vaWQgYXNuMV9zaGEyNTZfb2lkID0geworCS5vaWQgPSB7IDIsIDE2LCA4NDAsIDEsIDEwMSwgMywgNCwgMiwgMSB9LAorCS5sZW4gPSA5Cit9OworCisKIGludCBhc24xX2dldF9uZXh0KGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4sIHN0cnVjdCBhc24xX2hkciAqaGRyKQogewogCWNvbnN0IHU4ICpwb3MsICplbmQ7CkBAIC0xNDAsNyArMTUxLDcgQEAKIH0KIAogCi12b2lkIGFzbjFfb2lkX3RvX3N0cihzdHJ1Y3QgYXNuMV9vaWQgKm9pZCwgY2hhciAqYnVmLCBzaXplX3QgbGVuKQordm9pZCBhc24xX29pZF90b19zdHIoY29uc3Qgc3RydWN0IGFzbjFfb2lkICpvaWQsIGNoYXIgKmJ1Ziwgc2l6ZV90IGxlbikKIHsKIAljaGFyICpwb3MgPSBidWY7CiAJc2l6ZV90IGk7CkBAIC0yMDQsMyArMjE1LDE5IEBACiAKIAlyZXR1cm4gdmFsOwogfQorCisKK2ludCBhc24xX29pZF9lcXVhbChjb25zdCBzdHJ1Y3QgYXNuMV9vaWQgKmEsIGNvbnN0IHN0cnVjdCBhc24xX29pZCAqYikKK3sKKwlzaXplX3QgaTsKKworCWlmIChhLT5sZW4gIT0gYi0+bGVuKQorCQlyZXR1cm4gMDsKKworCWZvciAoaSA9IDA7IGkgPCBhLT5sZW47IGkrKykgeworCQlpZiAoYS0+b2lkW2ldICE9IGItPm9pZFtpXSkKKwkJCXJldHVybiAwOworCX0KKworCXJldHVybiAxOworfQpkaWZmIC0tZ2l0IGEvc3JjL3Rscy9hc24xLmggYi9zcmMvdGxzL2FzbjEuaAppbmRleCA2MzQyYzRjLi43NDc1MDA3IDEwMDY0NAotLS0gYS9zcmMvdGxzL2FzbjEuaAorKysgYi9zcmMvdGxzL2FzbjEuaApAQCAtNjAsNyArNjAsMTEgQEAKIGludCBhc24xX3BhcnNlX29pZChjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuLCBzdHJ1Y3QgYXNuMV9vaWQgKm9pZCk7CiBpbnQgYXNuMV9nZXRfb2lkKGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4sIHN0cnVjdCBhc24xX29pZCAqb2lkLAogCQkgY29uc3QgdTggKipuZXh0KTsKLXZvaWQgYXNuMV9vaWRfdG9fc3RyKHN0cnVjdCBhc24xX29pZCAqb2lkLCBjaGFyICpidWYsIHNpemVfdCBsZW4pOwordm9pZCBhc24xX29pZF90b19zdHIoY29uc3Qgc3RydWN0IGFzbjFfb2lkICpvaWQsIGNoYXIgKmJ1Ziwgc2l6ZV90IGxlbik7CiB1bnNpZ25lZCBsb25nIGFzbjFfYml0X3N0cmluZ190b19sb25nKGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pOworaW50IGFzbjFfb2lkX2VxdWFsKGNvbnN0IHN0cnVjdCBhc24xX29pZCAqYSwgY29uc3Qgc3RydWN0IGFzbjFfb2lkICpiKTsKKworZXh0ZXJuIHN0cnVjdCBhc24xX29pZCBhc24xX3NoYTFfb2lkOworZXh0ZXJuIHN0cnVjdCBhc24xX29pZCBhc24xX3NoYTI1Nl9vaWQ7CiAKICNlbmRpZiAvKiBBU04xX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy90bHMvcGtjczEuYyBiL3NyYy90bHMvcGtjczEuYwppbmRleCBiNmZkZTVlLi4xNDFhYzUwIDEwMDY0NAotLS0gYS9zcmMvdGxzL3BrY3MxLmMKKysrIGIvc3JjL3Rscy9wa2NzMS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFBLQ1MgIzEgKFJTQSBFbmNyeXB0aW9uKQotICogQ29weXJpZ2h0IChjKSAyMDA2LTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtOSw3ICs5LDkgQEAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgogCiAjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAiY3J5cHRvL2NyeXB0by5oIgogI2luY2x1ZGUgInJzYS5oIgorI2luY2x1ZGUgImFzbjEuaCIKICNpbmNsdWRlICJwa2NzMS5oIgogCiAKQEAgLTExMyw2ICsxMTUsMTEgQEAKIAkJcG9zKys7CiAJaWYgKHBvcyA9PSBlbmQpCiAJCXJldHVybiAtMTsKKwlpZiAocG9zIC0gb3V0IC0gMiA8IDgpIHsKKwkJLyogUEtDUyAjMSB2MS41LCA4LjE6IEF0IGxlYXN0IGVpZ2h0IG9jdGV0cyBsb25nIFBTICovCisJCXdwYV9wcmludGYoTVNHX0lORk8sICJMaWJUb21DcnlwdDogVG9vIHNob3J0IHBhZGRpbmciKTsKKwkJcmV0dXJuIC0xOworCX0KIAlwb3MrKzsKIAogCSpvdXRsZW4gLT0gcG9zIC0gb3V0OwpAQCAtMTQyLDM1ICsxNDksMjYgQEAKIAkgKiBCVCA9IDAwIG9yIDAxCiAJICogUFMgPSBrLTMtfHxEfHwgdGltZXMgKDAwIGlmIEJUPTAwKSBvciAoRkYgaWYgQlQ9MDEpCiAJICogayA9IGxlbmd0aCBvZiBtb2R1bHVzIGluIG9jdGV0cworCSAqCisJICogQmFzZWQgb24gMTAuMS4zLCAiVGhlIGJsb2NrIHR5cGUgc2hhbGwgYmUgMDEiIGZvciBhIHNpZ25hdHVyZS4KIAkgKi8KIAogCWlmIChsZW4gPCAzICsgOCArIDE2IC8qIG1pbiBoYXNoIGxlbiAqLyB8fAotCSAgICBwbGFpblswXSAhPSAweDAwIHx8IChwbGFpblsxXSAhPSAweDAwICYmIHBsYWluWzFdICE9IDB4MDEpKSB7CisJICAgIHBsYWluWzBdICE9IDB4MDAgfHwgcGxhaW5bMV0gIT0gMHgwMSkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTGliVG9tQ3J5cHQ6IEludmFsaWQgc2lnbmF0dXJlIEVCICIKIAkJCSAgICJzdHJ1Y3R1cmUiKTsKIAkJcmV0dXJuIC0xOwogCX0KIAogCXBvcyA9IHBsYWluICsgMzsKLQlpZiAocGxhaW5bMV0gPT0gMHgwMCkgewotCQkvKiBCVCA9IDAwICovCi0JCWlmIChwbGFpblsyXSAhPSAweDAwKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTGliVG9tQ3J5cHQ6IEludmFsaWQgc2lnbmF0dXJlICIKLQkJCQkgICAiUFMgKEJUPTAwKSIpOwotCQkJcmV0dXJuIC0xOwotCQl9Ci0JCXdoaWxlIChwb3MgKyAxIDwgcGxhaW4gKyBsZW4gJiYgKnBvcyA9PSAweDAwICYmIHBvc1sxXSA9PSAweDAwKQotCQkJcG9zKys7Ci0JfSBlbHNlIHsKLQkJLyogQlQgPSAwMSAqLwotCQlpZiAocGxhaW5bMl0gIT0gMHhmZikgewotCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkxpYlRvbUNyeXB0OiBJbnZhbGlkIHNpZ25hdHVyZSAiCi0JCQkJICAgIlBTIChCVD0wMSkiKTsKLQkJCXJldHVybiAtMTsKLQkJfQotCQl3aGlsZSAocG9zIDwgcGxhaW4gKyBsZW4gJiYgKnBvcyA9PSAweGZmKQotCQkJcG9zKys7CisJLyogQlQgPSAwMSAqLworCWlmIChwbGFpblsyXSAhPSAweGZmKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJMaWJUb21DcnlwdDogSW52YWxpZCBzaWduYXR1cmUgIgorCQkJICAgIlBTIChCVD0wMSkiKTsKKwkJcmV0dXJuIC0xOwogCX0KKwl3aGlsZSAocG9zIDwgcGxhaW4gKyBsZW4gJiYgKnBvcyA9PSAweGZmKQorCQlwb3MrKzsKIAogCWlmIChwb3MgLSBwbGFpbiAtIDIgPCA4KSB7CiAJCS8qIFBLQ1MgIzEgdjEuNSwgOC4xOiBBdCBsZWFzdCBlaWdodCBvY3RldHMgbG9uZyBQUyAqLwpAQCAtMTkzLDMgKzE5MSwxMzAgQEAKIAogCXJldHVybiAwOwogfQorCisKK2ludCBwa2NzMV92MTVfc2lnX3ZlcihzdHJ1Y3QgY3J5cHRvX3B1YmxpY19rZXkgKnBrLAorCQkgICAgICBjb25zdCB1OCAqcywgc2l6ZV90IHNfbGVuLAorCQkgICAgICBjb25zdCBzdHJ1Y3QgYXNuMV9vaWQgKmhhc2hfYWxnLAorCQkgICAgICBjb25zdCB1OCAqaGFzaCwgc2l6ZV90IGhhc2hfbGVuKQoreworCWludCByZXM7CisJdTggKmRlY3J5cHRlZDsKKwlzaXplX3QgZGVjcnlwdGVkX2xlbjsKKwljb25zdCB1OCAqcG9zLCAqZW5kLCAqbmV4dCwgKmRhX2VuZDsKKwlzdHJ1Y3QgYXNuMV9oZHIgaGRyOworCXN0cnVjdCBhc24xX29pZCBvaWQ7CisKKwlkZWNyeXB0ZWQgPSBvc19tYWxsb2Moc19sZW4pOworCWlmIChkZWNyeXB0ZWQgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWRlY3J5cHRlZF9sZW4gPSBzX2xlbjsKKwlyZXMgPSBjcnlwdG9fcHVibGljX2tleV9kZWNyeXB0X3BrY3MxKHBrLCBzLCBzX2xlbiwgZGVjcnlwdGVkLAorCQkJCQkgICAgICAmZGVjcnlwdGVkX2xlbik7CisJaWYgKHJlcyA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlBLQ1MgIzE6IFJTQSBkZWNyeXB0IGZhaWxlZCIpOworCQlvc19mcmVlKGRlY3J5cHRlZCk7CisJCXJldHVybiAtMTsKKwl9CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRGVjcnlwdGVkKFMpIiwgZGVjcnlwdGVkLCBkZWNyeXB0ZWRfbGVuKTsKKworCS8qCisJICogUEtDUyAjMSB2MS41LCAxMC4xLjI6CisJICoKKwkgKiBEaWdlc3RJbmZvIDo6PSBTRVFVRU5DRSB7CisJICogICAgIGRpZ2VzdEFsZ29yaXRobSBEaWdlc3RBbGdvcml0aG1JZGVudGlmaWVyLAorCSAqICAgICBkaWdlc3QgRGlnZXN0CisJICogfQorCSAqCisJICogRGlnZXN0QWxnb3JpdGhtSWRlbnRpZmllciA6Oj0gQWxnb3JpdGhtSWRlbnRpZmllcgorCSAqCisJICogRGlnZXN0IDo6PSBPQ1RFVCBTVFJJTkcKKwkgKgorCSAqLworCWlmIChhc24xX2dldF9uZXh0KGRlY3J5cHRlZCwgZGVjcnlwdGVkX2xlbiwgJmhkcikgPCAwIHx8CisJICAgIGhkci5jbGFzcyAhPSBBU04xX0NMQVNTX1VOSVZFUlNBTCB8fAorCSAgICBoZHIudGFnICE9IEFTTjFfVEFHX1NFUVVFTkNFKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJICAgIlBLQ1MgIzE6IEV4cGVjdGVkIFNFUVVFTkNFIChEaWdlc3RJbmZvKSAtIGZvdW5kIGNsYXNzICVkIHRhZyAweCV4IiwKKwkJCSAgIGhkci5jbGFzcywgaGRyLnRhZyk7CisJCW9zX2ZyZWUoZGVjcnlwdGVkKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXBvcyA9IGhkci5wYXlsb2FkOworCWVuZCA9IHBvcyArIGhkci5sZW5ndGg7CisKKwkvKgorCSAqIFguNTA5OgorCSAqIEFsZ29yaXRobUlkZW50aWZpZXIgOjo9IFNFUVVFTkNFIHsKKwkgKiAgICAgYWxnb3JpdGhtICAgICAgICAgICAgT0JKRUNUIElERU5USUZJRVIsCisJICogICAgIHBhcmFtZXRlcnMgICAgICAgICAgIEFOWSBERUZJTkVEIEJZIGFsZ29yaXRobSBPUFRJT05BTAorCSAqIH0KKwkgKi8KKworCWlmIChhc24xX2dldF9uZXh0KHBvcywgZW5kIC0gcG9zLCAmaGRyKSA8IDAgfHwKKwkgICAgaGRyLmNsYXNzICE9IEFTTjFfQ0xBU1NfVU5JVkVSU0FMIHx8CisJICAgIGhkci50YWcgIT0gQVNOMV9UQUdfU0VRVUVOQ0UpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAiUEtDUyAjMTogRXhwZWN0ZWQgU0VRVUVOQ0UgKEFsZ29yaXRobUlkZW50aWZpZXIpIC0gZm91bmQgY2xhc3MgJWQgdGFnIDB4JXgiLAorCQkJICAgaGRyLmNsYXNzLCBoZHIudGFnKTsKKwkJb3NfZnJlZShkZWNyeXB0ZWQpOworCQlyZXR1cm4gLTE7CisJfQorCWRhX2VuZCA9IGhkci5wYXlsb2FkICsgaGRyLmxlbmd0aDsKKworCWlmIChhc24xX2dldF9vaWQoaGRyLnBheWxvYWQsIGhkci5sZW5ndGgsICZvaWQsICZuZXh0KSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJQS0NTICMxOiBGYWlsZWQgdG8gcGFyc2UgZGlnZXN0QWxnb3JpdGhtIik7CisJCW9zX2ZyZWUoZGVjcnlwdGVkKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmICghYXNuMV9vaWRfZXF1YWwoJm9pZCwgaGFzaF9hbGcpKSB7CisJCWNoYXIgdHh0WzEwMF0sIHR4dDJbMTAwXTsKKwkJYXNuMV9vaWRfdG9fc3RyKCZvaWQsIHR4dCwgc2l6ZW9mKHR4dCkpOworCQlhc24xX29pZF90b19zdHIoaGFzaF9hbGcsIHR4dDIsIHNpemVvZih0eHQyKSk7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJICAgIlBLQ1MgIzE6IEhhc2ggYWxnIE9JRCBtaXNtYXRjaDogd2FzICVzLCBleHBlY3RlZCAlcyIsCisJCQkgICB0eHQsIHR4dDIpOworCQlvc19mcmVlKGRlY3J5cHRlZCk7CisJCXJldHVybiAtMTsKKwl9CisKKwkvKiBEaWdlc3QgOjo9IE9DVEVUIFNUUklORyAqLworCXBvcyA9IGRhX2VuZDsKKwllbmQgPSBkZWNyeXB0ZWQgKyBkZWNyeXB0ZWRfbGVuOworCisJaWYgKGFzbjFfZ2V0X25leHQocG9zLCBlbmQgLSBwb3MsICZoZHIpIDwgMCB8fAorCSAgICBoZHIuY2xhc3MgIT0gQVNOMV9DTEFTU19VTklWRVJTQUwgfHwKKwkgICAgaGRyLnRhZyAhPSBBU04xX1RBR19PQ1RFVFNUUklORykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJQS0NTICMxOiBFeHBlY3RlZCBPQ1RFVFNUUklORyAoRGlnZXN0KSAtIGZvdW5kIGNsYXNzICVkIHRhZyAweCV4IiwKKwkJCSAgIGhkci5jbGFzcywgaGRyLnRhZyk7CisJCW9zX2ZyZWUoZGVjcnlwdGVkKTsKKwkJcmV0dXJuIC0xOworCX0KKwl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlBLQ1MgIzE6IERlY3J5cHRlZCBEaWdlc3QiLAorCQkgICAgaGRyLnBheWxvYWQsIGhkci5sZW5ndGgpOworCisJaWYgKGhkci5sZW5ndGggIT0gaGFzaF9sZW4gfHwKKwkgICAgb3NfbWVtY21wX2NvbnN0KGhkci5wYXlsb2FkLCBoYXNoLCBoZHIubGVuZ3RoKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJQS0NTICMxOiBEaWdlc3QgdmFsdWUgZG9lcyBub3QgbWF0Y2ggY2FsY3VsYXRlZCBoYXNoIik7CisJCW9zX2ZyZWUoZGVjcnlwdGVkKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9zX2ZyZWUoZGVjcnlwdGVkKTsKKworCWlmIChoZHIucGF5bG9hZCArIGhkci5sZW5ndGggIT0gZW5kKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkgICAiUEtDUyAjMTogRXh0cmEgZGF0YSBhZnRlciBzaWduYXR1cmUgLSByZWplY3QiKTsKKworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJQS0NTICMxOiBFeHRyYSBkYXRhIiwKKwkJCSAgICBoZHIucGF5bG9hZCArIGhkci5sZW5ndGgsCisJCQkgICAgZW5kIC0gaGRyLnBheWxvYWQgLSBoZHIubGVuZ3RoKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvc3JjL3Rscy9wa2NzMS5oIGIvc3JjL3Rscy9wa2NzMS5oCmluZGV4IGVkNjRkZWYuLmYzN2ViZjMgMTAwNjQ0Ci0tLSBhL3NyYy90bHMvcGtjczEuaAorKysgYi9zcmMvdGxzL3BrY3MxLmgKQEAgLTksNiArOSw5IEBACiAjaWZuZGVmIFBLQ1MxX0gKICNkZWZpbmUgUEtDUzFfSAogCitzdHJ1Y3QgY3J5cHRvX3B1YmxpY19rZXk7CitzdHJ1Y3QgYXNuMV9vaWQ7CisKIGludCBwa2NzMV9lbmNyeXB0KGludCBibG9ja190eXBlLCBzdHJ1Y3QgY3J5cHRvX3JzYV9rZXkgKmtleSwKIAkJICBpbnQgdXNlX3ByaXZhdGUsIGNvbnN0IHU4ICppbiwgc2l6ZV90IGlubGVuLAogCQkgIHU4ICpvdXQsIHNpemVfdCAqb3V0bGVuKTsKQEAgLTE4LDUgKzIxLDkgQEAKIGludCBwa2NzMV9kZWNyeXB0X3B1YmxpY19rZXkoc3RydWN0IGNyeXB0b19yc2Ffa2V5ICprZXksCiAJCQkgICAgIGNvbnN0IHU4ICpjcnlwdCwgc2l6ZV90IGNyeXB0X2xlbiwKIAkJCSAgICAgdTggKnBsYWluLCBzaXplX3QgKnBsYWluX2xlbik7CitpbnQgcGtjczFfdjE1X3NpZ192ZXIoc3RydWN0IGNyeXB0b19wdWJsaWNfa2V5ICpwaywKKwkJICAgICAgY29uc3QgdTggKnMsIHNpemVfdCBzX2xlbiwKKwkJICAgICAgY29uc3Qgc3RydWN0IGFzbjFfb2lkICpoYXNoX2FsZywKKwkJICAgICAgY29uc3QgdTggKmhhc2gsIHNpemVfdCBoYXNoX2xlbik7CiAKICNlbmRpZiAvKiBQS0NTMV9IICovCmRpZmYgLS1naXQgYS9zcmMvdGxzL3JzYS5jIGIvc3JjL3Rscy9yc2EuYwppbmRleCAxMjVjNDIwLi4wYjdiNTMwIDEwMDY0NAotLS0gYS9zcmMvdGxzL3JzYS5jCisrKyBiL3NyYy90bHMvcnNhLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogUlNBCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTE2LDYgKzExNiwyOSBAQAogfQogCiAKK3N0cnVjdCBjcnlwdG9fcnNhX2tleSAqCitjcnlwdG9fcnNhX2ltcG9ydF9wdWJsaWNfa2V5X3BhcnRzKGNvbnN0IHU4ICpuLCBzaXplX3Qgbl9sZW4sCisJCQkJICAgY29uc3QgdTggKmUsIHNpemVfdCBlX2xlbikKK3sKKwlzdHJ1Y3QgY3J5cHRvX3JzYV9rZXkgKmtleTsKKworCWtleSA9IG9zX3phbGxvYyhzaXplb2YoKmtleSkpOworCWlmIChrZXkgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlrZXktPm4gPSBiaWdudW1faW5pdCgpOworCWtleS0+ZSA9IGJpZ251bV9pbml0KCk7CisJaWYgKGtleS0+biA9PSBOVUxMIHx8IGtleS0+ZSA9PSBOVUxMIHx8CisJICAgIGJpZ251bV9zZXRfdW5zaWduZWRfYmluKGtleS0+biwgbiwgbl9sZW4pIDwgMCB8fAorCSAgICBiaWdudW1fc2V0X3Vuc2lnbmVkX2JpbihrZXktPmUsIGUsIGVfbGVuKSA8IDApIHsKKwkJY3J5cHRvX3JzYV9mcmVlKGtleSk7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiBrZXk7Cit9CisKKwogLyoqCiAgKiBjcnlwdG9fcnNhX2ltcG9ydF9wcml2YXRlX2tleSAtIEltcG9ydCBhbiBSU0EgcHJpdmF0ZSBrZXkKICAqIEBidWY6IEtleSBidWZmZXIgKERFUiBlbmNvZGVkIFJTQSBwcml2YXRlIGtleSkKZGlmZiAtLWdpdCBhL3NyYy90bHMvcnNhLmggYi9zcmMvdGxzL3JzYS5oCmluZGV4IGMyMzZhOWQuLmI2NTgxOGUgMTAwNjQ0Ci0tLSBhL3NyYy90bHMvcnNhLmgKKysrIGIvc3JjL3Rscy9yc2EuaApAQCAtMTQsNiArMTQsOSBAQAogc3RydWN0IGNyeXB0b19yc2Ffa2V5ICoKIGNyeXB0b19yc2FfaW1wb3J0X3B1YmxpY19rZXkoY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbik7CiBzdHJ1Y3QgY3J5cHRvX3JzYV9rZXkgKgorY3J5cHRvX3JzYV9pbXBvcnRfcHVibGljX2tleV9wYXJ0cyhjb25zdCB1OCAqbiwgc2l6ZV90IG5fbGVuLAorCQkJCSAgIGNvbnN0IHU4ICplLCBzaXplX3QgZV9sZW4pOworc3RydWN0IGNyeXB0b19yc2Ffa2V5ICoKIGNyeXB0b19yc2FfaW1wb3J0X3ByaXZhdGVfa2V5KGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pOwogc2l6ZV90IGNyeXB0b19yc2FfZ2V0X21vZHVsdXNfbGVuKHN0cnVjdCBjcnlwdG9fcnNhX2tleSAqa2V5KTsKIGludCBjcnlwdG9fcnNhX2V4cHRtb2QoY29uc3QgdTggKmluLCBzaXplX3QgaW5sZW4sIHU4ICpvdXQsIHNpemVfdCAqb3V0bGVuLApkaWZmIC0tZ2l0IGEvc3JjL3Rscy90bHN2MV9jbGllbnQuYyBiL3NyYy90bHMvdGxzdjFfY2xpZW50LmMKaW5kZXggMTIxNDhiNi4uNGE0ZjBiNiAxMDA2NDQKLS0tIGEvc3JjL3Rscy90bHN2MV9jbGllbnQuYworKysgYi9zcmMvdGxzL3Rsc3YxX2NsaWVudC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFRMUyB2MS4wL3YxLjEvdjEuMiBjbGllbnQgKFJGQyAyMjQ2LCBSRkMgNDM0NiwgUkZDIDUyNDYpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAxMSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC00NTksMTAgKzQ1OSwxNSBAQAogCiAJY291bnQgPSAwOwogCXN1aXRlcyA9IGNvbm4tPmNpcGhlcl9zdWl0ZXM7CisJc3VpdGVzW2NvdW50KytdID0gVExTX0RIRV9SU0FfV0lUSF9BRVNfMjU2X0NCQ19TSEEyNTY7CiAJc3VpdGVzW2NvdW50KytdID0gVExTX1JTQV9XSVRIX0FFU18yNTZfQ0JDX1NIQTI1NjsKKwlzdWl0ZXNbY291bnQrK10gPSBUTFNfREhFX1JTQV9XSVRIX0FFU18yNTZfQ0JDX1NIQTsKIAlzdWl0ZXNbY291bnQrK10gPSBUTFNfUlNBX1dJVEhfQUVTXzI1Nl9DQkNfU0hBOworCXN1aXRlc1tjb3VudCsrXSA9IFRMU19ESEVfUlNBX1dJVEhfQUVTXzEyOF9DQkNfU0hBMjU2OwogCXN1aXRlc1tjb3VudCsrXSA9IFRMU19SU0FfV0lUSF9BRVNfMTI4X0NCQ19TSEEyNTY7CisJc3VpdGVzW2NvdW50KytdID0gVExTX0RIRV9SU0FfV0lUSF9BRVNfMTI4X0NCQ19TSEE7CiAJc3VpdGVzW2NvdW50KytdID0gVExTX1JTQV9XSVRIX0FFU18xMjhfQ0JDX1NIQTsKKwlzdWl0ZXNbY291bnQrK10gPSBUTFNfREhFX1JTQV9XSVRIXzNERVNfRURFX0NCQ19TSEE7CiAJc3VpdGVzW2NvdW50KytdID0gVExTX1JTQV9XSVRIXzNERVNfRURFX0NCQ19TSEE7CiAJc3VpdGVzW2NvdW50KytdID0gVExTX1JTQV9XSVRIX1JDNF8xMjhfU0hBOwogCXN1aXRlc1tjb3VudCsrXSA9IFRMU19SU0FfV0lUSF9SQzRfMTI4X01ENTsKZGlmZiAtLWdpdCBhL3NyYy90bHMvdGxzdjFfY2xpZW50X3JlYWQuYyBiL3NyYy90bHMvdGxzdjFfY2xpZW50X3JlYWQuYwppbmRleCAzMjY5ZWNmLi40ZjA4ZTBmIDEwMDY0NAotLS0gYS9zcmMvdGxzL3Rsc3YxX2NsaWVudF9yZWFkLmMKKysrIGIvc3JjL3Rscy90bHN2MV9jbGllbnRfcmVhZC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFRMU3YxIGNsaWVudCAtIHJlYWQgaGFuZHNoYWtlIG1lc3NhZ2UKLSAqIENvcHlyaWdodCAoYykgMjAwNi0yMDExLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA2LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTQwOSwxMCArNDA5LDM3IEBACiB9CiAKIAotc3RhdGljIGludCB0bHN2MV9wcm9jZXNzX2RpZmZpZV9oZWxsbWFuKHN0cnVjdCB0bHN2MV9jbGllbnQgKmNvbm4sCi0JCQkJCWNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCitzdGF0aWMgdW5zaWduZWQgaW50IGNvdW50X2JpdHMoY29uc3QgdTggKnZhbCwgc2l6ZV90IGxlbikKIHsKLQljb25zdCB1OCAqcG9zLCAqZW5kOworCXNpemVfdCBpOworCXVuc2lnbmVkIGludCBiaXRzOworCXU4IHRtcDsKKworCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykgeworCQlpZiAodmFsW2ldKQorCQkJYnJlYWs7CisJfQorCWlmIChpID09IGxlbikKKwkJcmV0dXJuIDA7CisKKwliaXRzID0gKGxlbiAtIGkgLSAxKSAqIDg7CisJdG1wID0gdmFsW2ldOworCXdoaWxlICh0bXApIHsKKwkJYml0cysrOworCQl0bXAgPj49IDE7CisJfQorCisJcmV0dXJuIGJpdHM7Cit9CisKKworc3RhdGljIGludCB0bHN2MV9wcm9jZXNzX2RpZmZpZV9oZWxsbWFuKHN0cnVjdCB0bHN2MV9jbGllbnQgKmNvbm4sCisJCQkJCWNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4sCisJCQkJCXRsc19rZXlfZXhjaGFuZ2Uga2V5X2V4Y2hhbmdlKQoreworCWNvbnN0IHU4ICpwb3MsICplbmQsICpzZXJ2ZXJfcGFyYW1zLCAqc2VydmVyX3BhcmFtc19lbmQ7CisJdTggYWxlcnQ7CisJdW5zaWduZWQgaW50IGJpdHM7CiAKIAl0bHN2MV9jbGllbnRfZnJlZV9kaChjb25uKTsKIApAQCAtNDIxLDYgKzQ0OCw3IEBACiAKIAlpZiAoZW5kIC0gcG9zIDwgMykKIAkJZ290byBmYWlsOworCXNlcnZlcl9wYXJhbXMgPSBwb3M7CiAJY29ubi0+ZGhfcF9sZW4gPSBXUEFfR0VUX0JFMTYocG9zKTsKIAlwb3MgKz0gMjsKIAlpZiAoY29ubi0+ZGhfcF9sZW4gPT0gMCB8fCBlbmQgLSBwb3MgPCAoaW50KSBjb25uLT5kaF9wX2xlbikgewpAQCAtNDI4LDYgKzQ1NiwxNCBAQAogCQkJICAgKHVuc2lnbmVkIGxvbmcpIGNvbm4tPmRoX3BfbGVuKTsKIAkJZ290byBmYWlsOwogCX0KKwliaXRzID0gY291bnRfYml0cyhwb3MsIGNvbm4tPmRoX3BfbGVuKTsKKwlpZiAoYml0cyA8IDc2OCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVExTdjE6IFJlamVjdCB1bmRlciA3NjgtYml0IERIIHByaW1lIChpbnNlY3VyZTsgb25seSAldSBiaXRzKSIsCisJCQkgICBiaXRzKTsKKwkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiVExTdjE6IFJlamVjdGVkIERIIHByaW1lIiwKKwkJCSAgICBwb3MsIGNvbm4tPmRoX3BfbGVuKTsKKwkJZ290byBmYWlsOworCX0KIAljb25uLT5kaF9wID0gb3NfbWFsbG9jKGNvbm4tPmRoX3BfbGVuKTsKIAlpZiAoY29ubi0+ZGhfcCA9PSBOVUxMKQogCQlnb3RvIGZhaWw7CkBAIC00NjUsNiArNTAxLDU5IEBACiAJcG9zICs9IGNvbm4tPmRoX3lzX2xlbjsKIAl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJUTFN2MTogREggWXMgKHNlcnZlcidzIHB1YmxpYyB2YWx1ZSkiLAogCQkgICAgY29ubi0+ZGhfeXMsIGNvbm4tPmRoX3lzX2xlbik7CisJc2VydmVyX3BhcmFtc19lbmQgPSBwb3M7CisKKwlpZiAoa2V5X2V4Y2hhbmdlID09IFRMU19LRVlfWF9ESEVfUlNBKSB7CisJCXU4IGhhc2hbTUQ1X01BQ19MRU4gKyBTSEExX01BQ19MRU5dOworCQlpbnQgaGxlbjsKKworCQlpZiAoY29ubi0+cmwudGxzX3ZlcnNpb24gPT0gVExTX1ZFUlNJT05fMV8yKSB7CisjaWZkZWYgQ09ORklHX1RMU1YxMgorCQkJLyoKKwkJCSAqIFJGQyA1MjQ2LCA0Ljc6CisJCQkgKiBUTFMgdjEuMiBhZGRzIGV4cGxpY2l0IGluZGljYXRpb24gb2YgdGhlIHVzZWQKKwkJCSAqIHNpZ25hdHVyZSBhbmQgaGFzaCBhbGdvcml0aG1zLgorCQkJICoKKwkJCSAqIHN0cnVjdCB7CisJCQkgKiAgIEhhc2hBbGdvcml0aG0gaGFzaDsKKwkJCSAqICAgU2lnbmF0dXJlQWxnb3JpdGhtIHNpZ25hdHVyZTsKKwkJCSAqIH0gU2lnbmF0dXJlQW5kSGFzaEFsZ29yaXRobTsKKwkJCSAqLworCQkJaWYgKGVuZCAtIHBvcyA8IDIpCisJCQkJZ290byBmYWlsOworCQkJaWYgKHBvc1swXSAhPSBUTFNfSEFTSF9BTEdfU0hBMjU2IHx8CisJCQkgICAgcG9zWzFdICE9IFRMU19TSUdOX0FMR19SU0EpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxLjI6IFVuc3VwcG9ydGVkIGhhc2goJXUpL3NpZ25hdHVyZSgldSkgYWxnb3JpdGhtIiwKKwkJCQkJICAgcG9zWzBdLCBwb3NbMV0pOworCQkJCWdvdG8gZmFpbDsKKwkJCX0KKwkJCXBvcyArPSAyOworCisJCQlobGVuID0gdGxzdjEyX2tleV94X3NlcnZlcl9wYXJhbXNfaGFzaCgKKwkJCQljb25uLT5ybC50bHNfdmVyc2lvbiwgY29ubi0+Y2xpZW50X3JhbmRvbSwKKwkJCQljb25uLT5zZXJ2ZXJfcmFuZG9tLCBzZXJ2ZXJfcGFyYW1zLAorCQkJCXNlcnZlcl9wYXJhbXNfZW5kIC0gc2VydmVyX3BhcmFtcywgaGFzaCk7CisjZWxzZSAvKiBDT05GSUdfVExTVjEyICovCisJCQlnb3RvIGZhaWw7CisjZW5kaWYgLyogQ09ORklHX1RMU1YxMiAqLworCQl9IGVsc2UgeworCQkJaGxlbiA9IHRsc19rZXlfeF9zZXJ2ZXJfcGFyYW1zX2hhc2goCisJCQkJY29ubi0+cmwudGxzX3ZlcnNpb24sIGNvbm4tPmNsaWVudF9yYW5kb20sCisJCQkJY29ubi0+c2VydmVyX3JhbmRvbSwgc2VydmVyX3BhcmFtcywKKwkJCQlzZXJ2ZXJfcGFyYW1zX2VuZCAtIHNlcnZlcl9wYXJhbXMsIGhhc2gpOworCQl9CisKKwkJaWYgKGhsZW4gPCAwKQorCQkJZ290byBmYWlsOworCQl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlRMU3YxOiBTZXJ2ZXJLZXlFeGNoYW5nZSBoYXNoIiwKKwkJCSAgICBoYXNoLCBobGVuKTsKKworCQlpZiAodGxzX3ZlcmlmeV9zaWduYXR1cmUoY29ubi0+cmwudGxzX3ZlcnNpb24sCisJCQkJCSBjb25uLT5zZXJ2ZXJfcnNhX2tleSwKKwkJCQkJIGhhc2gsIGhsZW4sIHBvcywgZW5kIC0gcG9zLAorCQkJCQkgJmFsZXJ0KSA8IDApCisJCQlnb3RvIGZhaWw7CisJfQogCiAJcmV0dXJuIDA7CiAKQEAgLTU0Myw4ICs2MzIsMTAgQEAKIAogCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlRMU3YxOiBTZXJ2ZXJLZXlFeGNoYW5nZSIsIHBvcywgbGVuKTsKIAlzdWl0ZSA9IHRsc19nZXRfY2lwaGVyX3N1aXRlKGNvbm4tPnJsLmNpcGhlcl9zdWl0ZSk7Ci0JaWYgKHN1aXRlICYmIHN1aXRlLT5rZXlfZXhjaGFuZ2UgPT0gVExTX0tFWV9YX0RIX2Fub24pIHsKLQkJaWYgKHRsc3YxX3Byb2Nlc3NfZGlmZmllX2hlbGxtYW4oY29ubiwgcG9zLCBsZW4pIDwgMCkgeworCWlmIChzdWl0ZSAmJiAoc3VpdGUtPmtleV9leGNoYW5nZSA9PSBUTFNfS0VZX1hfREhfYW5vbiB8fAorCQkgICAgICBzdWl0ZS0+a2V5X2V4Y2hhbmdlID09IFRMU19LRVlfWF9ESEVfUlNBKSkgeworCQlpZiAodGxzdjFfcHJvY2Vzc19kaWZmaWVfaGVsbG1hbihjb25uLCBwb3MsIGxlbiwKKwkJCQkJCSBzdWl0ZS0+a2V5X2V4Y2hhbmdlKSA8IDApIHsKIAkJCXRsc19hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJCXJldHVybiAtMTsKQEAgLTg3MSw4ICs5NjIsMTAgQEAKIAl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiVExTdjE6IHZlcmlmeV9kYXRhIChzZXJ2ZXIpIiwKIAkJCXZlcmlmeV9kYXRhLCBUTFNfVkVSSUZZX0RBVEFfTEVOKTsKIAotCWlmIChvc19tZW1jbXAocG9zLCB2ZXJpZnlfZGF0YSwgVExTX1ZFUklGWV9EQVRBX0xFTikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3QocG9zLCB2ZXJpZnlfZGF0YSwgVExTX1ZFUklGWV9EQVRBX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVExTdjE6IE1pc21hdGNoIGluIHZlcmlmeV9kYXRhIik7CisJCXRsc19hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCisJCQkgIFRMU19BTEVSVF9ERUNSWVBUX0VSUk9SKTsKIAkJcmV0dXJuIC0xOwogCX0KIApkaWZmIC0tZ2l0IGEvc3JjL3Rscy90bHN2MV9jbGllbnRfd3JpdGUuYyBiL3NyYy90bHMvdGxzdjFfY2xpZW50X3dyaXRlLmMKaW5kZXggZDc4OWVmYi4uODM5ZWI5MCAxMDA2NDQKLS0tIGEvc3JjL3Rscy90bHN2MV9jbGllbnRfd3JpdGUuYworKysgYi9zcmMvdGxzL3Rsc3YxX2NsaWVudF93cml0ZS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFRMU3YxIGNsaWVudCAtIHdyaXRlIGhhbmRzaGFrZSBtZXNzYWdlCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAxMSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yMDUsNyArMjA1LDcgQEAKIH0KIAogCi1zdGF0aWMgaW50IHRsc3YxX2tleV94X2Fub25fZGgoc3RydWN0IHRsc3YxX2NsaWVudCAqY29ubiwgdTggKipwb3MsIHU4ICplbmQpCitzdGF0aWMgaW50IHRsc3YxX2tleV94X2RoKHN0cnVjdCB0bHN2MV9jbGllbnQgKmNvbm4sIHU4ICoqcG9zLCB1OCAqZW5kKQogewogCS8qIENsaWVudERpZmZpZUhlbGxtYW5QdWJsaWMgKi8KIAl1OCAqY3NlY3JldCwgKmNzZWNyZXRfc3RhcnQsICpkaF95YywgKnNoYXJlZDsKQEAgLTM5OSw4ICszOTksOCBAQAogCWhzX2xlbmd0aCA9IHBvczsKIAlwb3MgKz0gMzsKIAkvKiBib2R5IC0gQ2xpZW50S2V5RXhjaGFuZ2UgKi8KLQlpZiAoa2V5eCA9PSBUTFNfS0VZX1hfREhfYW5vbikgewotCQlpZiAodGxzdjFfa2V5X3hfYW5vbl9kaChjb25uLCAmcG9zLCBlbmQpIDwgMCkKKwlpZiAoa2V5eCA9PSBUTFNfS0VZX1hfREhfYW5vbiB8fCBrZXl4ID09IFRMU19LRVlfWF9ESEVfUlNBKSB7CisJCWlmICh0bHN2MV9rZXlfeF9kaChjb25uLCAmcG9zLCBlbmQpIDwgMCkKIAkJCXJldHVybiAtMTsKIAl9IGVsc2UgewogCQlpZiAodGxzdjFfa2V5X3hfcnNhKGNvbm4sICZwb3MsIGVuZCkgPCAwKQpkaWZmIC0tZ2l0IGEvc3JjL3Rscy90bHN2MV9jb21tb24uYyBiL3NyYy90bHMvdGxzdjFfY29tbW9uLmMKaW5kZXggZDIxMjg2Mi4uY2VkMjhjZiAxMDA2NDQKLS0tIGEvc3JjL3Rscy90bHN2MV9jb21tb24uYworKysgYi9zcmMvdGxzL3Rsc3YxX2NvbW1vbi5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFRMU3YxIGNvbW1vbiByb3V0aW5lcwotICogQ29weXJpZ2h0IChjKSAyMDA2LTIwMTEsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtOSw2ICs5LDcgQEAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgogCiAjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAiY3J5cHRvL21kNS5oIgogI2luY2x1ZGUgImNyeXB0by9zaGExLmgiCiAjaW5jbHVkZSAiY3J5cHRvL3NoYTI1Ni5oIgogI2luY2x1ZGUgIng1MDl2My5oIgpAQCAtMzMsNiArMzQsMTAgQEAKIAkgIFRMU19IQVNIX1NIQSB9LAogCXsgVExTX1JTQV9XSVRIXzNERVNfRURFX0NCQ19TSEEsIFRMU19LRVlfWF9SU0EsCiAJICBUTFNfQ0lQSEVSXzNERVNfRURFX0NCQywgVExTX0hBU0hfU0hBIH0sCisJeyBUTFNfREhFX1JTQV9XSVRIX0RFU19DQkNfU0hBLCBUTFNfS0VZX1hfREhFX1JTQSwgVExTX0NJUEhFUl9ERVNfQ0JDLAorCSAgVExTX0hBU0hfU0hBfSwKKwl7IFRMU19ESEVfUlNBX1dJVEhfM0RFU19FREVfQ0JDX1NIQSwgVExTX0tFWV9YX0RIRV9SU0EsCisJICBUTFNfQ0lQSEVSXzNERVNfRURFX0NCQywgVExTX0hBU0hfU0hBIH0sCiAgCXsgVExTX0RIX2Fub25fV0lUSF9SQzRfMTI4X01ENSwgVExTX0tFWV9YX0RIX2Fub24sCiAJICBUTFNfQ0lQSEVSX1JDNF8xMjgsIFRMU19IQVNIX01ENSB9LAogIAl7IFRMU19ESF9hbm9uX1dJVEhfREVTX0NCQ19TSEEsIFRMU19LRVlfWF9ESF9hbm9uLApAQCAtNDEsMjQgKzQ2LDMxIEBACiAJICBUTFNfQ0lQSEVSXzNERVNfRURFX0NCQywgVExTX0hBU0hfU0hBIH0sCiAJeyBUTFNfUlNBX1dJVEhfQUVTXzEyOF9DQkNfU0hBLCBUTFNfS0VZX1hfUlNBLCBUTFNfQ0lQSEVSX0FFU18xMjhfQ0JDLAogCSAgVExTX0hBU0hfU0hBIH0sCisJeyBUTFNfREhFX1JTQV9XSVRIX0FFU18xMjhfQ0JDX1NIQSwgVExTX0tFWV9YX0RIRV9SU0EsCisJICBUTFNfQ0lQSEVSX0FFU18xMjhfQ0JDLCBUTFNfSEFTSF9TSEEgfSwKIAl7IFRMU19ESF9hbm9uX1dJVEhfQUVTXzEyOF9DQkNfU0hBLCBUTFNfS0VZX1hfREhfYW5vbiwKIAkgIFRMU19DSVBIRVJfQUVTXzEyOF9DQkMsIFRMU19IQVNIX1NIQSB9LAogCXsgVExTX1JTQV9XSVRIX0FFU18yNTZfQ0JDX1NIQSwgVExTX0tFWV9YX1JTQSwgVExTX0NJUEhFUl9BRVNfMjU2X0NCQywKIAkgIFRMU19IQVNIX1NIQSB9LAorCXsgVExTX0RIRV9SU0FfV0lUSF9BRVNfMjU2X0NCQ19TSEEsIFRMU19LRVlfWF9ESEVfUlNBLAorCSAgVExTX0NJUEhFUl9BRVNfMjU2X0NCQywgVExTX0hBU0hfU0hBIH0sCiAJeyBUTFNfREhfYW5vbl9XSVRIX0FFU18yNTZfQ0JDX1NIQSwgVExTX0tFWV9YX0RIX2Fub24sCiAJICBUTFNfQ0lQSEVSX0FFU18yNTZfQ0JDLCBUTFNfSEFTSF9TSEEgfSwKIAl7IFRMU19SU0FfV0lUSF9BRVNfMTI4X0NCQ19TSEEyNTYsIFRMU19LRVlfWF9SU0EsCiAJICBUTFNfQ0lQSEVSX0FFU18xMjhfQ0JDLCBUTFNfSEFTSF9TSEEyNTYgfSwKIAl7IFRMU19SU0FfV0lUSF9BRVNfMjU2X0NCQ19TSEEyNTYsIFRMU19LRVlfWF9SU0EsCiAJICBUTFNfQ0lQSEVSX0FFU18yNTZfQ0JDLCBUTFNfSEFTSF9TSEEyNTYgfSwKKwl7IFRMU19ESEVfUlNBX1dJVEhfQUVTXzEyOF9DQkNfU0hBMjU2LCBUTFNfS0VZX1hfREhFX1JTQSwKKwkgIFRMU19DSVBIRVJfQUVTXzEyOF9DQkMsIFRMU19IQVNIX1NIQTI1NiB9LAorCXsgVExTX0RIRV9SU0FfV0lUSF9BRVNfMjU2X0NCQ19TSEEyNTYsIFRMU19LRVlfWF9ESEVfUlNBLAorCSAgVExTX0NJUEhFUl9BRVNfMjU2X0NCQywgVExTX0hBU0hfU0hBMjU2IH0sCiAJeyBUTFNfREhfYW5vbl9XSVRIX0FFU18xMjhfQ0JDX1NIQTI1NiwgVExTX0tFWV9YX0RIX2Fub24sCiAJICBUTFNfQ0lQSEVSX0FFU18xMjhfQ0JDLCBUTFNfSEFTSF9TSEEyNTYgfSwKIAl7IFRMU19ESF9hbm9uX1dJVEhfQUVTXzI1Nl9DQkNfU0hBMjU2LCBUTFNfS0VZX1hfREhfYW5vbiwKIAkgIFRMU19DSVBIRVJfQUVTXzI1Nl9DQkMsIFRMU19IQVNIX1NIQTI1NiB9CiB9OwogCi0jZGVmaW5lIE5VTV9FTEVNUyhhKSAoc2l6ZW9mKGEpIC8gc2l6ZW9mKChhKVswXSkpCi0jZGVmaW5lIE5VTV9UTFNfQ0lQSEVSX1NVSVRFUyBOVU1fRUxFTVModGxzX2NpcGhlcl9zdWl0ZXMpCisjZGVmaW5lIE5VTV9UTFNfQ0lQSEVSX1NVSVRFUyBBUlJBWV9TSVpFKHRsc19jaXBoZXJfc3VpdGVzKQogCiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdGxzX2NpcGhlcl9kYXRhIHRsc19jaXBoZXJzW10gPSB7CkBAIC04NCw3ICs5Niw3IEBACiAJICBDUllQVE9fQ0lQSEVSX0FMR19BRVMgfQogfTsKIAotI2RlZmluZSBOVU1fVExTX0NJUEhFUl9EQVRBIE5VTV9FTEVNUyh0bHNfY2lwaGVycykKKyNkZWZpbmUgTlVNX1RMU19DSVBIRVJfREFUQSBBUlJBWV9TSVpFKHRsc19jaXBoZXJzKQogCiAKIC8qKgpAQCAtMzIwLDMgKzMzMiwxNjQgQEAKIAlyZXR1cm4gdGxzX3ByZl9zaGExX21kNShzZWNyZXQsIHNlY3JldF9sZW4sIGxhYmVsLCBzZWVkLCBzZWVkX2xlbiwgb3V0LAogCQkJCW91dGxlbik7CiB9CisKKworI2lmZGVmIENPTkZJR19UTFNWMTIKK2ludCB0bHN2MTJfa2V5X3hfc2VydmVyX3BhcmFtc19oYXNoKHUxNiB0bHNfdmVyc2lvbiwKKwkJCQkgICAgY29uc3QgdTggKmNsaWVudF9yYW5kb20sCisJCQkJICAgIGNvbnN0IHU4ICpzZXJ2ZXJfcmFuZG9tLAorCQkJCSAgICBjb25zdCB1OCAqc2VydmVyX3BhcmFtcywKKwkJCQkgICAgc2l6ZV90IHNlcnZlcl9wYXJhbXNfbGVuLCB1OCAqaGFzaCkKK3sKKwlzaXplX3QgaGxlbjsKKwlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmN0eDsKKworCWN0eCA9IGNyeXB0b19oYXNoX2luaXQoQ1JZUFRPX0hBU0hfQUxHX1NIQTI1NiwgTlVMTCwgMCk7CisJaWYgKGN0eCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJY3J5cHRvX2hhc2hfdXBkYXRlKGN0eCwgY2xpZW50X3JhbmRvbSwgVExTX1JBTkRPTV9MRU4pOworCWNyeXB0b19oYXNoX3VwZGF0ZShjdHgsIHNlcnZlcl9yYW5kb20sIFRMU19SQU5ET01fTEVOKTsKKwljcnlwdG9faGFzaF91cGRhdGUoY3R4LCBzZXJ2ZXJfcGFyYW1zLCBzZXJ2ZXJfcGFyYW1zX2xlbik7CisJaGxlbiA9IFNIQTI1Nl9NQUNfTEVOOworCWlmIChjcnlwdG9faGFzaF9maW5pc2goY3R4LCBoYXNoLCAmaGxlbikgPCAwKQorCQlyZXR1cm4gLTE7CisKKwlyZXR1cm4gaGxlbjsKK30KKyNlbmRpZiAvKiBDT05GSUdfVExTVjEyICovCisKKworaW50IHRsc19rZXlfeF9zZXJ2ZXJfcGFyYW1zX2hhc2godTE2IHRsc192ZXJzaW9uLCBjb25zdCB1OCAqY2xpZW50X3JhbmRvbSwKKwkJCQkgY29uc3QgdTggKnNlcnZlcl9yYW5kb20sCisJCQkJIGNvbnN0IHU4ICpzZXJ2ZXJfcGFyYW1zLAorCQkJCSBzaXplX3Qgc2VydmVyX3BhcmFtc19sZW4sIHU4ICpoYXNoKQoreworCXU4ICpocG9zOworCXNpemVfdCBobGVuOworCWVudW0geyBTSUdOX0FMR19SU0EsIFNJR05fQUxHX0RTQSB9IGFsZyA9IFNJR05fQUxHX1JTQTsKKwlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmN0eDsKKworCWhwb3MgPSBoYXNoOworCisJaWYgKGFsZyA9PSBTSUdOX0FMR19SU0EpIHsKKwkJY3R4ID0gY3J5cHRvX2hhc2hfaW5pdChDUllQVE9fSEFTSF9BTEdfTUQ1LCBOVUxMLCAwKTsKKwkJaWYgKGN0eCA9PSBOVUxMKQorCQkJcmV0dXJuIC0xOworCQljcnlwdG9faGFzaF91cGRhdGUoY3R4LCBjbGllbnRfcmFuZG9tLCBUTFNfUkFORE9NX0xFTik7CisJCWNyeXB0b19oYXNoX3VwZGF0ZShjdHgsIHNlcnZlcl9yYW5kb20sIFRMU19SQU5ET01fTEVOKTsKKwkJY3J5cHRvX2hhc2hfdXBkYXRlKGN0eCwgc2VydmVyX3BhcmFtcywgc2VydmVyX3BhcmFtc19sZW4pOworCQlobGVuID0gTUQ1X01BQ19MRU47CisJCWlmIChjcnlwdG9faGFzaF9maW5pc2goY3R4LCBoYXNoLCAmaGxlbikgPCAwKQorCQkJcmV0dXJuIC0xOworCQlocG9zICs9IGhsZW47CisJfQorCisJY3R4ID0gY3J5cHRvX2hhc2hfaW5pdChDUllQVE9fSEFTSF9BTEdfU0hBMSwgTlVMTCwgMCk7CisJaWYgKGN0eCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJY3J5cHRvX2hhc2hfdXBkYXRlKGN0eCwgY2xpZW50X3JhbmRvbSwgVExTX1JBTkRPTV9MRU4pOworCWNyeXB0b19oYXNoX3VwZGF0ZShjdHgsIHNlcnZlcl9yYW5kb20sIFRMU19SQU5ET01fTEVOKTsKKwljcnlwdG9faGFzaF91cGRhdGUoY3R4LCBzZXJ2ZXJfcGFyYW1zLCBzZXJ2ZXJfcGFyYW1zX2xlbik7CisJaGxlbiA9IGhhc2ggKyBzaXplb2YoaGFzaCkgLSBocG9zOworCWlmIChjcnlwdG9faGFzaF9maW5pc2goY3R4LCBocG9zLCAmaGxlbikgPCAwKQorCQlyZXR1cm4gLTE7CisJaHBvcyArPSBobGVuOworCXJldHVybiBocG9zIC0gaGFzaDsKK30KKworCitpbnQgdGxzX3ZlcmlmeV9zaWduYXR1cmUodTE2IHRsc192ZXJzaW9uLCBzdHJ1Y3QgY3J5cHRvX3B1YmxpY19rZXkgKnBrLAorCQkJIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgZGF0YV9sZW4sCisJCQkgY29uc3QgdTggKnBvcywgc2l6ZV90IGxlbiwgdTggKmFsZXJ0KQoreworCXU4ICpidWY7CisJY29uc3QgdTggKmVuZCA9IHBvcyArIGxlbjsKKwljb25zdCB1OCAqZGVjcnlwdGVkOworCXUxNiBzbGVuOworCXNpemVfdCBidWZsZW47CisKKwlpZiAoZW5kIC0gcG9zIDwgMikgeworCQkqYWxlcnQgPSBUTFNfQUxFUlRfREVDT0RFX0VSUk9SOworCQlyZXR1cm4gLTE7CisJfQorCXNsZW4gPSBXUEFfR0VUX0JFMTYocG9zKTsKKwlwb3MgKz0gMjsKKwlpZiAoZW5kIC0gcG9zIDwgc2xlbikgeworCQkqYWxlcnQgPSBUTFNfQUxFUlRfREVDT0RFX0VSUk9SOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChlbmQgLSBwb3MgPiBzbGVuKSB7CisJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiQWRkaXRpb25hbCBkYXRhIGFmdGVyIFNpZ25hdHVyZSIsCisJCQkgICAgcG9zICsgc2xlbiwgZW5kIC0gcG9zIC0gc2xlbik7CisJCWVuZCA9IHBvcyArIHNsZW47CisJfQorCisJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJUTFN2MTogU2lnbmF0dXJlIiwgcG9zLCBlbmQgLSBwb3MpOworCWlmIChwayA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IE5vIHB1YmxpYyBrZXkgdG8gdmVyaWZ5IHNpZ25hdHVyZSIpOworCQkqYWxlcnQgPSBUTFNfQUxFUlRfSU5URVJOQUxfRVJST1I7CisJCXJldHVybiAtMTsKKwl9CisKKwlidWZsZW4gPSBlbmQgLSBwb3M7CisJYnVmID0gb3NfbWFsbG9jKGVuZCAtIHBvcyk7CisJaWYgKGJ1ZiA9PSBOVUxMKSB7CisJCSphbGVydCA9IFRMU19BTEVSVF9JTlRFUk5BTF9FUlJPUjsKKwkJcmV0dXJuIC0xOworCX0KKwlpZiAoY3J5cHRvX3B1YmxpY19rZXlfZGVjcnlwdF9wa2NzMShwaywgcG9zLCBlbmQgLSBwb3MsIGJ1ZiwgJmJ1ZmxlbikgPAorCSAgICAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEZhaWxlZCB0byBkZWNyeXB0IHNpZ25hdHVyZSIpOworCQlvc19mcmVlKGJ1Zik7CisJCSphbGVydCA9IFRMU19BTEVSVF9ERUNSWVBUX0VSUk9SOworCQlyZXR1cm4gLTE7CisJfQorCWRlY3J5cHRlZCA9IGJ1ZjsKKworCXdwYV9oZXhkdW1wX2tleShNU0dfTVNHRFVNUCwgIlRMU3YxOiBEZWNyeXB0ZWQgU2lnbmF0dXJlIiwKKwkJCWRlY3J5cHRlZCwgYnVmbGVuKTsKKworI2lmZGVmIENPTkZJR19UTFNWMTIKKwlpZiAodGxzX3ZlcnNpb24gPj0gVExTX1ZFUlNJT05fMV8yKSB7CisJCS8qCisJCSAqIFJGQyAzNDQ3LCBBLjIuNCBSU0FTU0EtUEtDUzEtdjFfNQorCQkgKgorCQkgKiBEaWdlc3RJbmZvIDo6PSBTRVFVRU5DRSB7CisJCSAqICAgZGlnZXN0QWxnb3JpdGhtIERpZ2VzdEFsZ29yaXRobSwKKwkJICogICBkaWdlc3QgT0NURVQgU1RSSU5HCisJCSAqIH0KKwkJICoKKwkJICogU0hBLTI1NiBPSUQ6IHNoYTI1NldpdGhSU0FFbmNyeXB0aW9uIDo6PSB7cGtjcy0xIDExfQorCQkgKgorCQkgKiBERVIgZW5jb2RlZCBEaWdlc3RJbmZvIGZvciBTSEEyNTYgcGVyIFJGQyAzNDQ3OgorCQkgKiAzMCAzMSAzMCAwZCAwNiAwOSA2MCA4NiA0OCAwMSA2NSAwMyAwNCAwMiAwMSAwNSAwMCAwNCAyMCB8fAorCQkgKiBICisJCSAqLworCQlpZiAoYnVmbGVuID49IDE5ICsgMzIgJiYKKwkJICAgIG9zX21lbWNtcChidWYsICJceDMwXHgzMVx4MzBceDBkXHgwNlx4MDlceDYwXHg4Nlx4NDhceDAxIgorCQkJICAgICAgIlx4NjVceDAzXHgwNFx4MDJceDAxXHgwNVx4MDBceDA0XHgyMCIsIDE5KSA9PSAwKQorCQl7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxLjI6IERpZ2VzdEFsZ29yaXRobiA9IFNIQS0yNTYiKTsKKwkJCWRlY3J5cHRlZCA9IGJ1ZiArIDE5OworCQkJYnVmbGVuIC09IDE5OworCQl9IGVsc2UgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MS4yOiBVbnJlY29nbml6ZWQgRGlnZXN0SW5mbyIpOworCQkJb3NfZnJlZShidWYpOworCQkJKmFsZXJ0ID0gVExTX0FMRVJUX0RFQ1JZUFRfRVJST1I7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX1RMU1YxMiAqLworCisJaWYgKGJ1ZmxlbiAhPSBkYXRhX2xlbiB8fAorCSAgICBvc19tZW1jbXBfY29uc3QoZGVjcnlwdGVkLCBkYXRhLCBkYXRhX2xlbikgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBJbnZhbGlkIFNpZ25hdHVyZSBpbiBDZXJ0aWZpY2F0ZVZlcmlmeSAtIGRpZCBub3QgbWF0Y2ggY2FsY3VsYXRlZCBoYXNoIik7CisJCW9zX2ZyZWUoYnVmKTsKKwkJKmFsZXJ0ID0gVExTX0FMRVJUX0RFQ1JZUFRfRVJST1I7CisJCXJldHVybiAtMTsKKwl9CisKKwlvc19mcmVlKGJ1Zik7CisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL3NyYy90bHMvdGxzdjFfY29tbW9uLmggYi9zcmMvdGxzL3Rsc3YxX2NvbW1vbi5oCmluZGV4IGYyOGMwY2QuLjI2ZTY4YWYgMTAwNjQ0Ci0tLSBhL3NyYy90bHMvdGxzdjFfY29tbW9uLmgKKysrIGIvc3JjL3Rscy90bHN2MV9jb21tb24uaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBUTFN2MSBjb21tb24gZGVmaW5pdGlvbnMKLSAqIENvcHlyaWdodCAoYykgMjAwNi0yMDExLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA2LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTI1Nyw1ICsyNTcsMTYgQEAKIGNvbnN0IGNoYXIgKiB0bHNfdmVyc2lvbl9zdHIodTE2IHZlcik7CiBpbnQgdGxzX3ByZih1MTYgdmVyLCBjb25zdCB1OCAqc2VjcmV0LCBzaXplX3Qgc2VjcmV0X2xlbiwgY29uc3QgY2hhciAqbGFiZWwsCiAJICAgIGNvbnN0IHU4ICpzZWVkLCBzaXplX3Qgc2VlZF9sZW4sIHU4ICpvdXQsIHNpemVfdCBvdXRsZW4pOworaW50IHRsc3YxMl9rZXlfeF9zZXJ2ZXJfcGFyYW1zX2hhc2godTE2IHRsc192ZXJzaW9uLCBjb25zdCB1OCAqY2xpZW50X3JhbmRvbSwKKwkJCQkgICAgY29uc3QgdTggKnNlcnZlcl9yYW5kb20sCisJCQkJICAgIGNvbnN0IHU4ICpzZXJ2ZXJfcGFyYW1zLAorCQkJCSAgICBzaXplX3Qgc2VydmVyX3BhcmFtc19sZW4sIHU4ICpoYXNoKTsKK2ludCB0bHNfa2V5X3hfc2VydmVyX3BhcmFtc19oYXNoKHUxNiB0bHNfdmVyc2lvbiwgY29uc3QgdTggKmNsaWVudF9yYW5kb20sCisJCQkJIGNvbnN0IHU4ICpzZXJ2ZXJfcmFuZG9tLAorCQkJCSBjb25zdCB1OCAqc2VydmVyX3BhcmFtcywKKwkJCQkgc2l6ZV90IHNlcnZlcl9wYXJhbXNfbGVuLCB1OCAqaGFzaCk7CitpbnQgdGxzX3ZlcmlmeV9zaWduYXR1cmUodTE2IHRsc192ZXJzaW9uLCBzdHJ1Y3QgY3J5cHRvX3B1YmxpY19rZXkgKnBrLAorCQkJIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgZGF0YV9sZW4sCisJCQkgY29uc3QgdTggKnBvcywgc2l6ZV90IGxlbiwgdTggKmFsZXJ0KTsKIAogI2VuZGlmIC8qIFRMU1YxX0NPTU1PTl9IICovCmRpZmYgLS1naXQgYS9zcmMvdGxzL3Rsc3YxX3JlY29yZC5jIGIvc3JjL3Rscy90bHN2MV9yZWNvcmQuYwppbmRleCAzYmVjM2JlLi4wYzY4OTdhIDEwMDY0NAotLS0gYS9zcmMvdGxzL3Rsc3YxX3JlY29yZC5jCisrKyBiL3NyYy90bHMvdGxzdjFfcmVjb3JkLmMKQEAgLTQ1Niw3ICs0NTYsNyBAQAogCQkJcmV0dXJuIC0xOwogCQl9CiAJCWlmIChobGVuICE9IHJsLT5oYXNoX3NpemUgfHwKLQkJICAgIG9zX21lbWNtcChoYXNoLCBvdXRfZGF0YSArIHBsZW4sIGhsZW4pICE9IDAgfHwKKwkJICAgIG9zX21lbWNtcF9jb25zdChoYXNoLCBvdXRfZGF0YSArIHBsZW4sIGhsZW4pICE9IDAgfHwKIAkJICAgIGZvcmNlX21hY19lcnJvcikgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogSW52YWxpZCBITUFDIHZhbHVlIGluICIKIAkJCQkgICAicmVjZWl2ZWQgbWVzc2FnZSAoZm9yY2VfbWFjX2Vycm9yPSVkKSIsCmRpZmYgLS1naXQgYS9zcmMvdGxzL3Rsc3YxX3NlcnZlci5jIGIvc3JjL3Rscy90bHN2MV9zZXJ2ZXIuYwppbmRleCAyODgwMzA5Li4yM2QwYjgxIDEwMDY0NAotLS0gYS9zcmMvdGxzL3Rsc3YxX3NlcnZlci5jCisrKyBiL3NyYy90bHMvdGxzdjFfc2VydmVyLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogVExTIHYxLjAvdjEuMS92MS4yIHNlcnZlciAoUkZDIDIyNDYsIFJGQyA0MzQ2LCBSRkMgNTI0NikKLSAqIENvcHlyaWdodCAoYykgMjAwNi0yMDExLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA2LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTIxLDYgKzIxLDMxIEBACiAgKi8KIAogCit2b2lkIHRsc3YxX3NlcnZlcl9sb2coc3RydWN0IHRsc3YxX3NlcnZlciAqY29ubiwgY29uc3QgY2hhciAqZm10LCAuLi4pCit7CisJdmFfbGlzdCBhcDsKKwljaGFyICpidWY7CisJaW50IGJ1ZmxlbjsKKworCXZhX3N0YXJ0KGFwLCBmbXQpOworCWJ1ZmxlbiA9IHZzbnByaW50ZihOVUxMLCAwLCBmbXQsIGFwKSArIDE7CisJdmFfZW5kKGFwKTsKKworCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuOworCXZhX3N0YXJ0KGFwLCBmbXQpOworCXZzbnByaW50ZihidWYsIGJ1ZmxlbiwgZm10LCBhcCk7CisJdmFfZW5kKGFwKTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6ICVzIiwgYnVmKTsKKwlpZiAoY29ubi0+bG9nX2NiKQorCQljb25uLT5sb2dfY2IoY29ubi0+bG9nX2NiX2N0eCwgYnVmKTsKKworCW9zX2ZyZWUoYnVmKTsKK30KKworCiB2b2lkIHRsc3YxX3NlcnZlcl9hbGVydChzdHJ1Y3QgdGxzdjFfc2VydmVyICpjb25uLCB1OCBsZXZlbCwgdTggZGVzY3JpcHRpb24pCiB7CiAJY29ubi0+YWxlcnRfbGV2ZWwgPSBsZXZlbDsKQEAgLTI1MCw4ICsyNzUsNyBAQAogCQl1c2VkID0gdGxzdjFfcmVjb3JkX3JlY2VpdmUoJmNvbm4tPnJsLCBwb3MsIGluX2VuZCAtIHBvcywKIAkJCQkJICAgIG91dF9wb3MsICZvbGVuLCAmYWxlcnQpOwogCQlpZiAodXNlZCA8IDApIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFJlY29yZCBsYXllciBwcm9jZXNzaW5nICIKLQkJCQkgICAiZmFpbGVkIik7CisJCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJSZWNvcmQgbGF5ZXIgcHJvY2Vzc2luZyBmYWlsZWQiKTsKIAkJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsIGFsZXJ0KTsKIAkJCXJldHVybiAtMTsKIAkJfQpAQCAtMjY1LDE0ICsyODksMTMgQEAKIAogCQlpZiAoY3QgPT0gVExTX0NPTlRFTlRfVFlQRV9BTEVSVCkgewogCQkJaWYgKG9sZW4gPCAyKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogQWxlcnQgIgotCQkJCQkgICAidW5kZXJmbG93Iik7CisJCQkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiQWxlcnQgdW5kZXJmbG93Iik7CiAJCQkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQkJCXJldHVybiAtMTsKIAkJCX0KLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFJlY2VpdmVkIGFsZXJ0ICVkOiVkIiwKLQkJCQkgICBvdXRfcG9zWzBdLCBvdXRfcG9zWzFdKTsKKwkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlJlY2VpdmVkIGFsZXJ0ICVkOiVkIiwKKwkJCQkJIG91dF9wb3NbMF0sIG91dF9wb3NbMV0pOwogCQkJaWYgKG91dF9wb3NbMF0gPT0gVExTX0FMRVJUX0xFVkVMX1dBUk5JTkcpIHsKIAkJCQkvKiBDb250aW51ZSBwcm9jZXNzaW5nICovCiAJCQkJcG9zICs9IHVzZWQ7CkBAIC0yODUsMTMgKzMwOCwyMyBAQAogCQl9CiAKIAkJaWYgKGN0ICE9IFRMU19DT05URU5UX1RZUEVfQVBQTElDQVRJT05fREFUQSkgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogVW5leHBlY3RlZCBjb250ZW50IHR5cGUgIgotCQkJCSAgICIweCV4IiwgcG9zWzBdKTsKKwkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgY29udGVudCB0eXBlIDB4JXgiLAorCQkJCQkgcG9zWzBdKTsKIAkJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJCSAgIFRMU19BTEVSVF9VTkVYUEVDVEVEX01FU1NBR0UpOwogCQkJcmV0dXJuIC0xOwogCQl9CiAKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJCWlmICgoY29ubi0+dGVzdF9mbGFncyAmCisJCSAgICAgKFRMU19CUkVBS19WRVJJRllfREFUQSB8IFRMU19CUkVBS19TUlZfS0VZX1hfSEFTSCB8CisJCSAgICAgIFRMU19CUkVBS19TUlZfS0VZX1hfU0lHTkFUVVJFKSkgJiYKKwkJICAgICFjb25uLT50ZXN0X2ZhaWx1cmVfcmVwb3J0ZWQpIHsKKwkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRFU1QtRkFJTFVSRTogQ2xpZW50IEFwcGxEYXRhIHJlY2VpdmVkIGFmdGVyIGludmFsaWQgaGFuZHNoYWtlIik7CisJCQljb25uLT50ZXN0X2ZhaWx1cmVfcmVwb3J0ZWQgPSAxOworCQl9CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLworCiAJCW91dF9wb3MgKz0gb2xlbjsKIAkJaWYgKG91dF9wb3MgPiBvdXRfZW5kKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBCdWZmZXIgbm90IGxhcmdlIGVub3VnaCAiCkBAIC0zNjEsOCArMzk0LDE1IEBACiAKIAljb3VudCA9IDA7CiAJc3VpdGVzID0gY29ubi0+Y2lwaGVyX3N1aXRlczsKKwlzdWl0ZXNbY291bnQrK10gPSBUTFNfREhFX1JTQV9XSVRIX0FFU18yNTZfQ0JDX1NIQTI1NjsKKwlzdWl0ZXNbY291bnQrK10gPSBUTFNfUlNBX1dJVEhfQUVTXzI1Nl9DQkNfU0hBMjU2OworCXN1aXRlc1tjb3VudCsrXSA9IFRMU19ESEVfUlNBX1dJVEhfQUVTXzI1Nl9DQkNfU0hBOwogCXN1aXRlc1tjb3VudCsrXSA9IFRMU19SU0FfV0lUSF9BRVNfMjU2X0NCQ19TSEE7CisJc3VpdGVzW2NvdW50KytdID0gVExTX0RIRV9SU0FfV0lUSF9BRVNfMTI4X0NCQ19TSEEyNTY7CisJc3VpdGVzW2NvdW50KytdID0gVExTX1JTQV9XSVRIX0FFU18xMjhfQ0JDX1NIQTI1NjsKKwlzdWl0ZXNbY291bnQrK10gPSBUTFNfREhFX1JTQV9XSVRIX0FFU18xMjhfQ0JDX1NIQTsKIAlzdWl0ZXNbY291bnQrK10gPSBUTFNfUlNBX1dJVEhfQUVTXzEyOF9DQkNfU0hBOworCXN1aXRlc1tjb3VudCsrXSA9IFRMU19ESEVfUlNBX1dJVEhfM0RFU19FREVfQ0JDX1NIQTsKIAlzdWl0ZXNbY291bnQrK10gPSBUTFNfUlNBX1dJVEhfM0RFU19FREVfQ0JDX1NIQTsKIAlzdWl0ZXNbY291bnQrK10gPSBUTFNfUlNBX1dJVEhfUkM0XzEyOF9TSEE7CiAJc3VpdGVzW2NvdW50KytdID0gVExTX1JTQV9XSVRIX1JDNF8xMjhfTUQ1OwpAQCAtNjE4LDMgKzY1OCwxMjUgQEAKIAljb25uLT5zZXNzaW9uX3RpY2tldF9jYiA9IGNiOwogCWNvbm4tPnNlc3Npb25fdGlja2V0X2NiX2N0eCA9IGN0eDsKIH0KKworCit2b2lkIHRsc3YxX3NlcnZlcl9zZXRfbG9nX2NiKHN0cnVjdCB0bHN2MV9zZXJ2ZXIgKmNvbm4sCisJCQkgICAgIHZvaWQgKCpjYikodm9pZCAqY3R4LCBjb25zdCBjaGFyICptc2cpLCB2b2lkICpjdHgpCit7CisJY29ubi0+bG9nX2NiID0gY2I7CisJY29ubi0+bG9nX2NiX2N0eCA9IGN0eDsKK30KKworCisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwordm9pZCB0bHN2MV9zZXJ2ZXJfc2V0X3Rlc3RfZmxhZ3Moc3RydWN0IHRsc3YxX3NlcnZlciAqY29ubiwgdTMyIGZsYWdzKQoreworCWNvbm4tPnRlc3RfZmxhZ3MgPSBmbGFnczsKK30KKworCitzdGF0aWMgY29uc3QgdTggdGVzdF90bHNfcHJpbWUxNVsxXSA9IHsKKwkxNQorfTsKKworc3RhdGljIGNvbnN0IHU4IHRlc3RfdGxzX3ByaW1lNTExYls2NF0gPSB7CisJMHg1MCwgMHhmYiwgMHhmMSwgMHhhZSwgMHgwMSwgMHhmMSwgMHhmZSwgMHhlNiwKKwkweGUxLCAweGFlLCAweGRjLCAweDFlLCAweGJlLCAweGZiLCAweDllLCAweDU4LAorCTB4OWEsIDB4ZDcsIDB4NTQsIDB4OWQsIDB4NmIsIDB4YjMsIDB4NzgsIDB4ZTIsCisJMHgzOSwgMHg3ZiwgMHgzMCwgMHgwMSwgMHgyNSwgMHhhMSwgMHhmOSwgMHg3YywKKwkweDU1LCAweDBlLCAweGExLCAweDE1LCAweGNjLCAweDM2LCAweDM0LCAweGJiLAorCTB4NmMsIDB4OGIsIDB4NjQsIDB4NDUsIDB4MTUsIDB4N2YsIDB4ZDMsIDB4ZTcsCisJMHgzMSwgMHhjOCwgMHg4ZSwgMHg1NiwgMHg4ZSwgMHg5NSwgMHhkYywgMHhlYSwKKwkweDllLCAweGRmLCAweGY3LCAweDU2LCAweGRkLCAweGIwLCAweDM0LCAweGRiCit9OworCitzdGF0aWMgY29uc3QgdTggdGVzdF90bHNfcHJpbWU3NjdiWzk2XSA9IHsKKwkweDRjLCAweGRjLCAweGI4LCAweDIxLCAweDIwLCAweDlkLCAweGU4LCAweGEzLAorCTB4NTMsIDB4ZDksIDB4MWMsIDB4MTgsIDB4YzEsIDB4M2EsIDB4NTgsIDB4NjcsCisJMHhhNywgMHg4NSwgMHhmOSwgMHgyOCwgMHg5YiwgMHhjZSwgMHhjMCwgMHhkMSwKKwkweDA1LCAweDg0LCAweDYxLCAweDk3LCAweGIyLCAweDg2LCAweDFjLCAweGQwLAorCTB4ZDEsIDB4OTYsIDB4MjMsIDB4MjksIDB4OGMsIDB4YzUsIDB4MzAsIDB4NjgsCisJMHgzZSwgMHhmOSwgMHgwNSwgMHhiYSwgMHg2MCwgMHhlYiwgMHhkYiwgMHhlZSwKKwkweDJkLCAweGRmLCAweDg0LCAweDY1LCAweDQ5LCAweDg3LCAweDkwLCAweDJhLAorCTB4YzksIDB4OGUsIDB4MzQsIDB4NjMsIDB4NmQsIDB4OWEsIDB4MmQsIDB4MzIsCisJMHgxYywgMHg0NiwgMHhkNSwgMHg0ZSwgMHgyMCwgMHgyMCwgMHg5MCwgMHhhYywKKwkweGQ1LCAweDQ4LCAweDc5LCAweDk5LCAweDBjLCAweGU2LCAweGVkLCAweGJmLAorCTB4NzksIDB4YzIsIDB4NDcsIDB4NTAsIDB4OTUsIDB4MzgsIDB4MzgsIDB4YmMsCisJMHhkZSwgMHhiMCwgMHhkMiwgMHhlOCwgMHg5NywgMHhjYiwgMHgyMiwgMHhiYgorfTsKKworc3RhdGljIGNvbnN0IHU4IHRlc3RfdGxzX3ByaW1lNThbMTI4XSA9IHsKKwkweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLAorCTB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsCisJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLAorCTB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsCisJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLAorCTB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsCisJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLAorCTB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsCisJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLAorCTB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsCisJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkweDAzLCAweGMxLCAweGJhLCAweGM4LCAweDI1LCAweGJlLCAweDJkLCAweGYzCit9OworCitzdGF0aWMgY29uc3QgdTggdGVzdF90bHNfbm9uX3ByaW1lW10gPSB7CisJLyoKKwkgKiBUaGlzIGlzIG5vdCBhIHByaW1lIGFuZCB0aGUgdmFsdWUgaGFzIHRoZSBmb2xsb3dpbmcgZmFjdG9yczoKKwkgKiAxMzczNjc4MzQ4ODcxNjU3OTkyMyAqIDE2MjU0ODYwMTkxNzczNDU2NTYzICogMTgyMjk0MzQ5NzYxNzM2NzA3NjMgKgorCSAqIDExMTEyMzEzMDE4Mjg5MDc5NDE5ICogMTAyNjA4MDIyNzg1ODAyNTMzMzkgKiAxMjM5NDAwOTQ5MTU3NTMxMTQ5OSAqCisJICogMTI0MTkwNTk2Njg3MTEwNjQ3MzkgKiAxNDMxNzk3MzE5MjY4Nzk4NTgyNyAqIDEwNDk4NjA1NDEwNTMzMjAzMTc5ICoKKwkgKiAxNjMzODY4ODc2MDM5MDI0OTAwMyAqIDExMTI4OTYzOTkxMTIzODc4ODgzICogMTI5OTA1MzIyNTgyODAzMDE0MTkgKgorCSAqIDMKKwkgKi8KKwkweDBDLCAweDhDLCAweDM2LCAweDlDLCAweDZGLCAweDcxLCAweDJFLCAweEE3LAorCTB4QUIsIDB4MzIsIDB4RDMsIDB4MEYsIDB4NjgsIDB4M0QsIDB4QjIsIDB4NkQsCisJMHg4MSwgMHhERCwgMHhDNCwgMHg4NCwgMHgwRCwgMHg5QywgMHg2RSwgMHgzNiwKKwkweDI5LCAweDcwLCAweEYzLCAweDFFLCAweDlBLCAweDQyLCAweDBCLCAweDY3LAorCTB4ODIsIDB4NkIsIDB4QjEsIDB4RjIsIDB4QUYsIDB4NTUsIDB4MjgsIDB4RTcsCisJMHhEQiwgMHg2NywgMHg2QywgMHhGNywgMHg2QiwgMHhBQywgMHhBQywgMHhFNSwKKwkweEY3LCAweDlGLCAweEQ0LCAweDYzLCAweDU1LCAweDcwLCAweDMyLCAweDdDLAorCTB4NzAsIDB4RkIsIDB4QUYsIDB4QjgsIDB4RUIsIDB4MzcsIDB4Q0YsIDB4M0YsCisJMHhGRSwgMHg5NCwgMHg3MywgMHhGOSwgMHg3QSwgMHhDNywgMHgxMiwgMHgyRSwKKwkweDlCLCAweEI0LCAweDdELCAweDA4LCAweDYwLCAweDgzLCAweDQzLCAweDUyLAorCTB4ODMsIDB4MUUsIDB4QTUsIDB4RkMsIDB4RkEsIDB4ODcsIDB4MTIsIDB4RjQsCisJMHg2NCwgMHhFMiwgMHhDRSwgMHg3MSwgMHgxNywgMHg3MiwgMHhCNiwgMHhBQgorfTsKKworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKworCit2b2lkIHRsc3YxX3NlcnZlcl9nZXRfZGhfcChzdHJ1Y3QgdGxzdjFfc2VydmVyICpjb25uLCBjb25zdCB1OCAqKmRoX3AsCisJCQkgICBzaXplX3QgKmRoX3BfbGVuKQoreworCSpkaF9wID0gY29ubi0+Y3JlZC0+ZGhfcDsKKwkqZGhfcF9sZW4gPSBjb25uLT5jcmVkLT5kaF9wX2xlbjsKKworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKwlpZiAoY29ubi0+dGVzdF9mbGFncyAmIFRMU19ESEVfUFJJTUVfNTExQikgeworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJURVNUSU5HOiBVc2Ugc2hvcnQgNTExLWJpdCBwcmltZSB3aXRoIERIRSIpOworCQkqZGhfcCA9IHRlc3RfdGxzX3ByaW1lNTExYjsKKwkJKmRoX3BfbGVuID0gc2l6ZW9mKHRlc3RfdGxzX3ByaW1lNTExYik7CisJfSBlbHNlIGlmIChjb25uLT50ZXN0X2ZsYWdzICYgVExTX0RIRV9QUklNRV83NjdCKSB7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRFU1RJTkc6IFVzZSBzaG9ydCA3NjctYml0IHByaW1lIHdpdGggREhFIik7CisJCSpkaF9wID0gdGVzdF90bHNfcHJpbWU3NjdiOworCQkqZGhfcF9sZW4gPSBzaXplb2YodGVzdF90bHNfcHJpbWU3NjdiKTsKKwl9IGVsc2UgaWYgKGNvbm4tPnRlc3RfZmxhZ3MgJiBUTFNfREhFX1BSSU1FXzE1KSB7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRFU1RJTkc6IFVzZSBib2d1cyAxNSBcInByaW1lXCIgd2l0aCBESEUiKTsKKwkJKmRoX3AgPSB0ZXN0X3Rsc19wcmltZTE1OworCQkqZGhfcF9sZW4gPSBzaXplb2YodGVzdF90bHNfcHJpbWUxNSk7CisJfSBlbHNlIGlmIChjb25uLT50ZXN0X2ZsYWdzICYgVExTX0RIRV9QUklNRV81OEIpIHsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVEVTVElORzogVXNlIHNob3J0IDU4LWJpdCBwcmltZSBpbiBsb25nIGNvbnRhaW5lciB3aXRoIERIRSIpOworCQkqZGhfcCA9IHRlc3RfdGxzX3ByaW1lNTg7CisJCSpkaF9wX2xlbiA9IHNpemVvZih0ZXN0X3Rsc19wcmltZTU4KTsKKwl9IGVsc2UgaWYgKGNvbm4tPnRlc3RfZmxhZ3MgJiBUTFNfREhFX05PTl9QUklNRSkgeworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJURVNUSU5HOiBVc2UgY2xhaW0gbm9uLXByaW1lIGFzIHRoZSBESEUgcHJpbWUiKTsKKwkJKmRoX3AgPSB0ZXN0X3Rsc19ub25fcHJpbWU7CisJCSpkaF9wX2xlbiA9IHNpemVvZih0ZXN0X3Rsc19ub25fcHJpbWUpOworCX0KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCit9CmRpZmYgLS1naXQgYS9zcmMvdGxzL3Rsc3YxX3NlcnZlci5oIGIvc3JjL3Rscy90bHN2MV9zZXJ2ZXIuaAppbmRleCBhMThjNjllLi5iMmIyOGQxIDEwMDY0NAotLS0gYS9zcmMvdGxzL3Rsc3YxX3NlcnZlci5oCisrKyBiL3NyYy90bHMvdGxzdjFfc2VydmVyLmgKQEAgLTQ1LDQgKzQ1LDkgQEAKIAkJCQkJdGxzdjFfc2VydmVyX3Nlc3Npb25fdGlja2V0X2NiIGNiLAogCQkJCQl2b2lkICpjdHgpOwogCit2b2lkIHRsc3YxX3NlcnZlcl9zZXRfbG9nX2NiKHN0cnVjdCB0bHN2MV9zZXJ2ZXIgKmNvbm4sCisJCQkgICAgIHZvaWQgKCpjYikodm9pZCAqY3R4LCBjb25zdCBjaGFyICptc2cpLCB2b2lkICpjdHgpOworCit2b2lkIHRsc3YxX3NlcnZlcl9zZXRfdGVzdF9mbGFncyhzdHJ1Y3QgdGxzdjFfc2VydmVyICpjb25uLCB1MzIgZmxhZ3MpOworCiAjZW5kaWYgLyogVExTVjFfU0VSVkVSX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy90bHMvdGxzdjFfc2VydmVyX2kuaCBiL3NyYy90bHMvdGxzdjFfc2VydmVyX2kuaAppbmRleCAxZjYxNTMzLi45NmQ3OWIzIDEwMDY0NAotLS0gYS9zcmMvdGxzL3Rsc3YxX3NlcnZlcl9pLmgKKysrIGIvc3JjL3Rscy90bHN2MV9zZXJ2ZXJfaS5oCkBAIC01MSwxMyArNTEsMjQgQEAKIAl0bHN2MV9zZXJ2ZXJfc2Vzc2lvbl90aWNrZXRfY2Igc2Vzc2lvbl90aWNrZXRfY2I7CiAJdm9pZCAqc2Vzc2lvbl90aWNrZXRfY2JfY3R4OwogCisJdm9pZCAoKmxvZ19jYikodm9pZCAqY3R4LCBjb25zdCBjaGFyICptc2cpOworCXZvaWQgKmxvZ19jYl9jdHg7CisKIAlpbnQgdXNlX3Nlc3Npb25fdGlja2V0OwogCiAJdTggKmRoX3NlY3JldDsKIAlzaXplX3QgZGhfc2VjcmV0X2xlbjsKKworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKwl1MzIgdGVzdF9mbGFnczsKKwlpbnQgdGVzdF9mYWlsdXJlX3JlcG9ydGVkOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KIH07CiAKIAordm9pZCB0bHN2MV9zZXJ2ZXJfbG9nKHN0cnVjdCB0bHN2MV9zZXJ2ZXIgKmNvbm4sIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQorUFJJTlRGX0ZPUk1BVCgyLCAzKTsKKwogdm9pZCB0bHN2MV9zZXJ2ZXJfYWxlcnQoc3RydWN0IHRsc3YxX3NlcnZlciAqY29ubiwgdTggbGV2ZWwsIHU4IGRlc2NyaXB0aW9uKTsKIGludCB0bHN2MV9zZXJ2ZXJfZGVyaXZlX2tleXMoc3RydWN0IHRsc3YxX3NlcnZlciAqY29ubiwKIAkJCSAgICAgY29uc3QgdTggKnByZV9tYXN0ZXJfc2VjcmV0LApAQCAtNjcsNSArNzgsNyBAQAogCQkJICAgICB1OCBkZXNjcmlwdGlvbiwgc2l6ZV90ICpvdXRfbGVuKTsKIGludCB0bHN2MV9zZXJ2ZXJfcHJvY2Vzc19oYW5kc2hha2Uoc3RydWN0IHRsc3YxX3NlcnZlciAqY29ubiwgdTggY3QsCiAJCQkJICAgY29uc3QgdTggKmJ1Ziwgc2l6ZV90ICpsZW4pOwordm9pZCB0bHN2MV9zZXJ2ZXJfZ2V0X2RoX3Aoc3RydWN0IHRsc3YxX3NlcnZlciAqY29ubiwgY29uc3QgdTggKipkaF9wLAorCQkJICAgc2l6ZV90ICpkaF9wX2xlbik7CiAKICNlbmRpZiAvKiBUTFNWMV9TRVJWRVJfSV9IICovCmRpZmYgLS1naXQgYS9zcmMvdGxzL3Rsc3YxX3NlcnZlcl9yZWFkLmMgYi9zcmMvdGxzL3Rsc3YxX3NlcnZlcl9yZWFkLmMKaW5kZXggNmY2NTM5Yi4uNzI4ZTEzNyAxMDA2NDQKLS0tIGEvc3JjL3Rscy90bHN2MV9zZXJ2ZXJfcmVhZC5jCisrKyBiL3NyYy90bHMvdGxzdjFfc2VydmVyX3JlYWQuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBUTFN2MSBzZXJ2ZXIgLSByZWFkIGhhbmRzaGFrZSBtZXNzYWdlCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAxMSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yNyw2ICsyNywyNSBAQAogCQkJCQkgIHNpemVfdCAqaW5fbGVuKTsKIAogCitzdGF0aWMgaW50IHRlc3RpbmdfY2lwaGVyX3N1aXRlX2ZpbHRlcihzdHJ1Y3QgdGxzdjFfc2VydmVyICpjb25uLCB1MTYgc3VpdGUpCit7CisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUworCWlmICgoY29ubi0+dGVzdF9mbGFncyAmCisJICAgICAoVExTX0JSRUFLX1NSVl9LRVlfWF9IQVNIIHwgVExTX0JSRUFLX1NSVl9LRVlfWF9TSUdOQVRVUkUgfAorCSAgICAgIFRMU19ESEVfUFJJTUVfNTExQiB8IFRMU19ESEVfUFJJTUVfNzY3QiB8IFRMU19ESEVfUFJJTUVfMTUgfAorCSAgICAgIFRMU19ESEVfUFJJTUVfNThCIHwgVExTX0RIRV9OT05fUFJJTUUpKSAmJgorCSAgICBzdWl0ZSAhPSBUTFNfREhFX1JTQV9XSVRIX0FFU18yNTZfQ0JDX1NIQTI1NiAmJgorCSAgICBzdWl0ZSAhPSBUTFNfREhFX1JTQV9XSVRIX0FFU18yNTZfQ0JDX1NIQSAmJgorCSAgICBzdWl0ZSAhPSBUTFNfREhFX1JTQV9XSVRIX0FFU18xMjhfQ0JDX1NIQTI1NiAmJgorCSAgICBzdWl0ZSAhPSBUTFNfREhFX1JTQV9XSVRIX0FFU18xMjhfQ0JDX1NIQSAmJgorCSAgICBzdWl0ZSAhPSBUTFNfREhFX1JTQV9XSVRIXzNERVNfRURFX0NCQ19TSEEpCisJCXJldHVybiAxOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKworCXJldHVybiAwOworfQorCisKIHN0YXRpYyBpbnQgdGxzX3Byb2Nlc3NfY2xpZW50X2hlbGxvKHN0cnVjdCB0bHN2MV9zZXJ2ZXIgKmNvbm4sIHU4IGN0LAogCQkJCSAgICBjb25zdCB1OCAqaW5fZGF0YSwgc2l6ZV90ICppbl9sZW4pCiB7CkBAIC0zOCw4ICs1Nyw4IEBACiAJdTE2IGV4dF90eXBlLCBleHRfbGVuOwogCiAJaWYgKGN0ICE9IFRMU19DT05URU5UX1RZUEVfSEFORFNIQUtFKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEV4cGVjdGVkIEhhbmRzaGFrZTsgIgotCQkJICAgInJlY2VpdmVkIGNvbnRlbnQgdHlwZSAweCV4IiwgY3QpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJFeHBlY3RlZCBIYW5kc2hha2U7IHJlY2VpdmVkIGNvbnRlbnQgdHlwZSAweCV4IiwKKwkJCQkgY3QpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9VTkVYUEVDVEVEX01FU1NBR0UpOwogCQlyZXR1cm4gLTE7CkBAIC01MywxMyArNzIsMTMgQEAKIAogCS8qIEhhbmRzaGFrZVR5cGUgbXNnX3R5cGUgKi8KIAlpZiAoKnBvcyAhPSBUTFNfSEFORFNIQUtFX1RZUEVfQ0xJRU5UX0hFTExPKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFJlY2VpdmVkIHVuZXhwZWN0ZWQgaGFuZHNoYWtlICIKLQkJCSAgICJtZXNzYWdlICVkIChleHBlY3RlZCBDbGllbnRIZWxsbykiLCAqcG9zKTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiUmVjZWl2ZWQgdW5leHBlY3RlZCBoYW5kc2hha2UgbWVzc2FnZSAlZCAoZXhwZWN0ZWQgQ2xpZW50SGVsbG8pIiwKKwkJCQkgKnBvcyk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX1VORVhQRUNURURfTUVTU0FHRSk7CiAJCXJldHVybiAtMTsKIAl9Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogUmVjZWl2ZWQgQ2xpZW50SGVsbG8iKTsKKwl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJSZWNlaXZlZCBDbGllbnRIZWxsbyIpOwogCXBvcysrOwogCS8qIHVpbnQyNCBsZW5ndGggKi8KIAlsZW4gPSBXUEFfR0VUX0JFMjQocG9zKTsKQEAgLTc4LDEzICs5NywxMyBAQAogCWlmIChlbmQgLSBwb3MgPCAyKQogCQlnb3RvIGRlY29kZV9lcnJvcjsKIAljb25uLT5jbGllbnRfdmVyc2lvbiA9IFdQQV9HRVRfQkUxNihwb3MpOwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IENsaWVudCB2ZXJzaW9uICVkLiVkIiwKLQkJICAgY29ubi0+Y2xpZW50X3ZlcnNpb24gPj4gOCwgY29ubi0+Y2xpZW50X3ZlcnNpb24gJiAweGZmKTsKKwl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJDbGllbnQgdmVyc2lvbiAlZC4lZCIsCisJCQkgY29ubi0+Y2xpZW50X3ZlcnNpb24gPj4gOCwKKwkJCSBjb25uLT5jbGllbnRfdmVyc2lvbiAmIDB4ZmYpOwogCWlmIChjb25uLT5jbGllbnRfdmVyc2lvbiA8IFRMU19WRVJTSU9OXzEpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogVW5leHBlY3RlZCBwcm90b2NvbCB2ZXJzaW9uIGluICIKLQkJCSAgICJDbGllbnRIZWxsbyAldS4ldSIsCi0JCQkgICBjb25uLT5jbGllbnRfdmVyc2lvbiA+PiA4LAotCQkJICAgY29ubi0+Y2xpZW50X3ZlcnNpb24gJiAweGZmKTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVW5leHBlY3RlZCBwcm90b2NvbCB2ZXJzaW9uIGluIENsaWVudEhlbGxvICV1LiV1IiwKKwkJCQkgY29ubi0+Y2xpZW50X3ZlcnNpb24gPj4gOCwKKwkJCQkgY29ubi0+Y2xpZW50X3ZlcnNpb24gJiAweGZmKTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfUFJPVE9DT0xfVkVSU0lPTik7CiAJCXJldHVybiAtMTsKQEAgLTEwMSw4ICsxMjAsOCBAQAogCQljb25uLT5ybC50bHNfdmVyc2lvbiA9IFRMU19WRVJTSU9OXzFfMTsKIAllbHNlCiAJCWNvbm4tPnJsLnRsc192ZXJzaW9uID0gY29ubi0+Y2xpZW50X3ZlcnNpb247Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogVXNpbmcgVExTIHYlcyIsCi0JCSAgIHRsc192ZXJzaW9uX3N0cihjb25uLT5ybC50bHNfdmVyc2lvbikpOworCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVzaW5nIFRMUyB2JXMiLAorCQkJIHRsc192ZXJzaW9uX3N0cihjb25uLT5ybC50bHNfdmVyc2lvbikpOwogCiAJLyogUmFuZG9tIHJhbmRvbSAqLwogCWlmIChlbmQgLSBwb3MgPCBUTFNfUkFORE9NX0xFTikKQEAgLTEzNyw2ICsxNTYsOCBAQAogCiAJY2lwaGVyX3N1aXRlID0gMDsKIAlmb3IgKGkgPSAwOyAhY2lwaGVyX3N1aXRlICYmIGkgPCBjb25uLT5udW1fY2lwaGVyX3N1aXRlczsgaSsrKSB7CisJCWlmICh0ZXN0aW5nX2NpcGhlcl9zdWl0ZV9maWx0ZXIoY29ubiwgY29ubi0+Y2lwaGVyX3N1aXRlc1tpXSkpCisJCQljb250aW51ZTsKIAkJYyA9IHBvczsKIAkJZm9yIChqID0gMDsgaiA8IG51bV9zdWl0ZXM7IGorKykgewogCQkJdTE2IHRtcCA9IFdQQV9HRVRfQkUxNihjKTsKQEAgLTE0OSw4ICsxNzAsNyBAQAogCX0KIAlwb3MgKz0gbnVtX3N1aXRlcyAqIDI7CiAJaWYgKCFjaXBoZXJfc3VpdGUpIHsKLQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRMU3YxOiBObyBzdXBwb3J0ZWQgY2lwaGVyIHN1aXRlICIKLQkJCSAgICJhdmFpbGFibGUiKTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiTm8gc3VwcG9ydGVkIGNpcGhlciBzdWl0ZSBhdmFpbGFibGUiKTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfSUxMRUdBTF9QQVJBTUVURVIpOwogCQlyZXR1cm4gLTE7CkBAIC0xODAsMTYgKzIwMCwxNSBAQAogCQkJY29tcHJfbnVsbF9mb3VuZCA9IDE7CiAJfQogCWlmICghY29tcHJfbnVsbF9mb3VuZCkgewotCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVExTdjE6IENsaWVudCBkb2VzIG5vdCBhY2NlcHQgTlVMTCAiCi0JCQkgICAiY29tcHJlc3Npb24iKTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiQ2xpZW50IGRvZXMgbm90IGFjY2VwdCBOVUxMIGNvbXByZXNzaW9uIik7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX0lMTEVHQUxfUEFSQU1FVEVSKTsKIAkJcmV0dXJuIC0xOwogCX0KIAogCWlmIChlbmQgLSBwb3MgPT0gMSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBVbmV4cGVjdGVkIGV4dHJhIG9jdGV0IGluIHRoZSAiCi0JCQkgICAgImVuZCBvZiBDbGllbnRIZWxsbzogMHglMDJ4IiwgKnBvcyk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgZXh0cmEgb2N0ZXQgaW4gdGhlIGVuZCBvZiBDbGllbnRIZWxsbzogMHglMDJ4IiwKKwkJCQkgKnBvcyk7CiAJCWdvdG8gZGVjb2RlX2Vycm9yOwogCX0KIApAQCAtMTk4LDEyICsyMTcsMTEgQEAKIAkJZXh0X2xlbiA9IFdQQV9HRVRfQkUxNihwb3MpOwogCQlwb3MgKz0gMjsKIAotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiAldSBieXRlcyBvZiBDbGllbnRIZWxsbyAiCi0JCQkgICAiZXh0ZW5zaW9ucyIsIGV4dF9sZW4pOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICIldSBieXRlcyBvZiBDbGllbnRIZWxsbyBleHRlbnNpb25zIiwKKwkJCQkgZXh0X2xlbik7CiAJCWlmIChlbmQgLSBwb3MgIT0gZXh0X2xlbikgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogSW52YWxpZCBDbGllbnRIZWxsbyAiCi0JCQkJICAgImV4dGVuc2lvbiBsaXN0IGxlbmd0aCAldSAoZXhwZWN0ZWQgJXUpIiwKLQkJCQkgICBleHRfbGVuLCAodW5zaWduZWQgaW50KSAoZW5kIC0gcG9zKSk7CisJCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJJbnZhbGlkIENsaWVudEhlbGxvIGV4dGVuc2lvbiBsaXN0IGxlbmd0aCAldSAoZXhwZWN0ZWQgJXUpIiwKKwkJCQkJIGV4dF9sZW4sICh1bnNpZ25lZCBpbnQpIChlbmQgLSBwb3MpKTsKIAkJCWdvdG8gZGVjb2RlX2Vycm9yOwogCQl9CiAKQEAgLTIxNiw4ICsyMzQsNyBAQAogCiAJCXdoaWxlIChwb3MgPCBlbmQpIHsKIAkJCWlmIChlbmQgLSBwb3MgPCAyKSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogSW52YWxpZCAiCi0JCQkJCSAgICJleHRlbnNpb25fdHlwZSBmaWVsZCIpOworCQkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkludmFsaWQgZXh0ZW5zaW9uX3R5cGUgZmllbGQiKTsKIAkJCQlnb3RvIGRlY29kZV9lcnJvcjsKIAkJCX0KIApAQCAtMjI1LDggKzI0Miw3IEBACiAJCQlwb3MgKz0gMjsKIAogCQkJaWYgKGVuZCAtIHBvcyA8IDIpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBJbnZhbGlkICIKLQkJCQkJICAgImV4dGVuc2lvbl9kYXRhIGxlbmd0aCBmaWVsZCIpOworCQkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkludmFsaWQgZXh0ZW5zaW9uX2RhdGEgbGVuZ3RoIGZpZWxkIik7CiAJCQkJZ290byBkZWNvZGVfZXJyb3I7CiAJCQl9CiAKQEAgLTIzNCwxMyArMjUwLDEyIEBACiAJCQlwb3MgKz0gMjsKIAogCQkJaWYgKGVuZCAtIHBvcyA8IGV4dF9sZW4pIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBJbnZhbGlkICIKLQkJCQkJICAgImV4dGVuc2lvbl9kYXRhIGZpZWxkIik7CisJCQkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiSW52YWxpZCBleHRlbnNpb25fZGF0YSBmaWVsZCIpOwogCQkJCWdvdG8gZGVjb2RlX2Vycm9yOwogCQkJfQogCi0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBDbGllbnRIZWxsbyBFeHRlbnNpb24gIgotCQkJCSAgICJ0eXBlICV1IiwgZXh0X3R5cGUpOworCQkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiQ2xpZW50SGVsbG8gRXh0ZW5zaW9uIHR5cGUgJXUiLAorCQkJCQkgZXh0X3R5cGUpOwogCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJUTFN2MTogQ2xpZW50SGVsbG8gIgogCQkJCSAgICAiRXh0ZW5zaW9uIGRhdGEiLCBwb3MsIGV4dF9sZW4pOwogCkBAIC0yNjAsMTQgKzI3NSwxMyBAQAogCiAJKmluX2xlbiA9IGVuZCAtIGluX2RhdGE7CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBDbGllbnRIZWxsbyBPSyAtIHByb2NlZWQgdG8gIgotCQkgICAiU2VydmVySGVsbG8iKTsKKwl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJDbGllbnRIZWxsbyBPSyAtIHByb2NlZWQgdG8gU2VydmVySGVsbG8iKTsKIAljb25uLT5zdGF0ZSA9IFNFUlZFUl9IRUxMTzsKIAogCXJldHVybiAwOwogCiBkZWNvZGVfZXJyb3I6Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogRmFpbGVkIHRvIGRlY29kZSBDbGllbnRIZWxsbyIpOworCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkZhaWxlZCB0byBkZWNvZGUgQ2xpZW50SGVsbG8iKTsKIAl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJICAgVExTX0FMRVJUX0RFQ09ERV9FUlJPUik7CiAJcmV0dXJuIC0xOwpAQCAtMjg0LDggKzI5OCw4IEBACiAJaW50IHJlYXNvbjsKIAogCWlmIChjdCAhPSBUTFNfQ09OVEVOVF9UWVBFX0hBTkRTSEFLRSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBFeHBlY3RlZCBIYW5kc2hha2U7ICIKLQkJCSAgICJyZWNlaXZlZCBjb250ZW50IHR5cGUgMHgleCIsIGN0KTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiRXhwZWN0ZWQgSGFuZHNoYWtlOyByZWNlaXZlZCBjb250ZW50IHR5cGUgMHgleCIsCisJCQkJIGN0KTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfVU5FWFBFQ1RFRF9NRVNTQUdFKTsKIAkJcmV0dXJuIC0xOwpAQCAtMjk1LDggKzMwOSw4IEBACiAJbGVmdCA9ICppbl9sZW47CiAKIAlpZiAobGVmdCA8IDQpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogVG9vIHNob3J0IENlcnRpZmljYXRlIG1lc3NhZ2UgIgotCQkJICAgIihsZW49JWx1KSIsICh1bnNpZ25lZCBsb25nKSBsZWZ0KTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVG9vIHNob3J0IENlcnRpZmljYXRlIG1lc3NhZ2UgKGxlbj0lbHUpIiwKKwkJCQkgKHVuc2lnbmVkIGxvbmcpIGxlZnQpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQlyZXR1cm4gLTE7CkBAIC0zMDgsOSArMzIyLDggQEAKIAlsZWZ0IC09IDQ7CiAKIAlpZiAobGVuID4gbGVmdCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBVbmV4cGVjdGVkIENlcnRpZmljYXRlIG1lc3NhZ2UgIgotCQkJICAgImxlbmd0aCAobGVuPSVsdSAhPSBsZWZ0PSVsdSkiLAotCQkJICAgKHVuc2lnbmVkIGxvbmcpIGxlbiwgKHVuc2lnbmVkIGxvbmcpIGxlZnQpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJVbmV4cGVjdGVkIENlcnRpZmljYXRlIG1lc3NhZ2UgbGVuZ3RoIChsZW49JWx1ICE9IGxlZnQ9JWx1KSIsCisJCQkJICh1bnNpZ25lZCBsb25nKSBsZW4sICh1bnNpZ25lZCBsb25nKSBsZWZ0KTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJcmV0dXJuIC0xOwpAQCAtMzE4LDggKzMzMSw3IEBACiAKIAlpZiAodHlwZSA9PSBUTFNfSEFORFNIQUtFX1RZUEVfQ0xJRU5UX0tFWV9FWENIQU5HRSkgewogCQlpZiAoY29ubi0+dmVyaWZ5X3BlZXIpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IENsaWVudCBkaWQgbm90IGluY2x1ZGUgIgotCQkJCSAgICJDZXJ0aWZpY2F0ZSIpOworCQkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiQ2xpZW50IGRpZCBub3QgaW5jbHVkZSBDZXJ0aWZpY2F0ZSIpOwogCQkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkJICAgVExTX0FMRVJUX1VORVhQRUNURURfTUVTU0FHRSk7CiAJCQlyZXR1cm4gLTE7CkBAIC0zMjksMTcgKzM0MSwxNSBAQAogCQkJCQkJICAgICAgIGluX2xlbik7CiAJfQogCWlmICh0eXBlICE9IFRMU19IQU5EU0hBS0VfVFlQRV9DRVJUSUZJQ0FURSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBSZWNlaXZlZCB1bmV4cGVjdGVkIGhhbmRzaGFrZSAiCi0JCQkgICAibWVzc2FnZSAlZCAoZXhwZWN0ZWQgQ2VydGlmaWNhdGUvIgotCQkJICAgIkNsaWVudEtleUV4Y2hhbmdlKSIsIHR5cGUpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJSZWNlaXZlZCB1bmV4cGVjdGVkIGhhbmRzaGFrZSBtZXNzYWdlICVkIChleHBlY3RlZCBDZXJ0aWZpY2F0ZS9DbGllbnRLZXlFeGNoYW5nZSkiLAorCQkJCSB0eXBlKTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfVU5FWFBFQ1RFRF9NRVNTQUdFKTsKIAkJcmV0dXJuIC0xOwogCX0KIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLAotCQkgICAiVExTdjE6IFJlY2VpdmVkIENlcnRpZmljYXRlIChjZXJ0aWZpY2F0ZV9saXN0IGxlbiAlbHUpIiwKLQkJICAgKHVuc2lnbmVkIGxvbmcpIGxlbik7CisJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiUmVjZWl2ZWQgQ2VydGlmaWNhdGUgKGNlcnRpZmljYXRlX2xpc3QgbGVuICVsdSkiLAorCQkJICh1bnNpZ25lZCBsb25nKSBsZW4pOwogCiAJLyoKIAkgKiBvcGFxdWUgQVNOLjFDZXJ0PDJeMjQtMT47CkBAIC0zNTIsOCArMzYyLDggQEAKIAllbmQgPSBwb3MgKyBsZW47CiAKIAlpZiAoZW5kIC0gcG9zIDwgMykgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBUb28gc2hvcnQgQ2VydGlmaWNhdGUgIgotCQkJICAgIihsZWZ0PSVsdSkiLCAodW5zaWduZWQgbG9uZykgbGVmdCk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRvbyBzaG9ydCBDZXJ0aWZpY2F0ZSAobGVmdD0lbHUpIiwKKwkJCQkgKHVuc2lnbmVkIGxvbmcpIGxlZnQpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQlyZXR1cm4gLTE7CkBAIC0zNjMsMTAgKzM3Myw5IEBACiAJcG9zICs9IDM7CiAKIAlpZiAoKHNpemVfdCkgKGVuZCAtIHBvcykgIT0gbGlzdF9sZW4pIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogVW5leHBlY3RlZCBjZXJ0aWZpY2F0ZV9saXN0ICIKLQkJCSAgICJsZW5ndGggKGxlbj0lbHUgbGVmdD0lbHUpIiwKLQkJCSAgICh1bnNpZ25lZCBsb25nKSBsaXN0X2xlbiwKLQkJCSAgICh1bnNpZ25lZCBsb25nKSAoZW5kIC0gcG9zKSk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgY2VydGlmaWNhdGVfbGlzdCBsZW5ndGggKGxlbj0lbHUgbGVmdD0lbHUpIiwKKwkJCQkgKHVuc2lnbmVkIGxvbmcpIGxpc3RfbGVuLAorCQkJCSAodW5zaWduZWQgbG9uZykgKGVuZCAtIHBvcykpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQlyZXR1cm4gLTE7CkBAIC0zNzUsOCArMzg0LDcgQEAKIAlpZHggPSAwOwogCXdoaWxlIChwb3MgPCBlbmQpIHsKIAkJaWYgKGVuZCAtIHBvcyA8IDMpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEZhaWxlZCB0byBwYXJzZSAiCi0JCQkJICAgImNlcnRpZmljYXRlX2xpc3QiKTsKKwkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkZhaWxlZCB0byBwYXJzZSBjZXJ0aWZpY2F0ZV9saXN0Iik7CiAJCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCQkgICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJCXg1MDlfY2VydGlmaWNhdGVfY2hhaW5fZnJlZShjaGFpbik7CkBAIC0zODcsMjUgKzM5NSwyMyBAQAogCQlwb3MgKz0gMzsKIAogCQlpZiAoKHNpemVfdCkgKGVuZCAtIHBvcykgPCBjZXJ0X2xlbikgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogVW5leHBlY3RlZCBjZXJ0aWZpY2F0ZSAiCi0JCQkJICAgImxlbmd0aCAobGVuPSVsdSBsZWZ0PSVsdSkiLAotCQkJCSAgICh1bnNpZ25lZCBsb25nKSBjZXJ0X2xlbiwKLQkJCQkgICAodW5zaWduZWQgbG9uZykgKGVuZCAtIHBvcykpOworCQkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVW5leHBlY3RlZCBjZXJ0aWZpY2F0ZSBsZW5ndGggKGxlbj0lbHUgbGVmdD0lbHUpIiwKKwkJCQkJICh1bnNpZ25lZCBsb25nKSBjZXJ0X2xlbiwKKwkJCQkJICh1bnNpZ25lZCBsb25nKSAoZW5kIC0gcG9zKSk7CiAJCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCQkgICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJCXg1MDlfY2VydGlmaWNhdGVfY2hhaW5fZnJlZShjaGFpbik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBDZXJ0aWZpY2F0ZSAlbHUgKGxlbiAlbHUpIiwKLQkJCSAgICh1bnNpZ25lZCBsb25nKSBpZHgsICh1bnNpZ25lZCBsb25nKSBjZXJ0X2xlbik7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkNlcnRpZmljYXRlICVsdSAobGVuICVsdSkiLAorCQkJCSAodW5zaWduZWQgbG9uZykgaWR4LCAodW5zaWduZWQgbG9uZykgY2VydF9sZW4pOwogCiAJCWlmIChpZHggPT0gMCkgewogCQkJY3J5cHRvX3B1YmxpY19rZXlfZnJlZShjb25uLT5jbGllbnRfcnNhX2tleSk7CiAJCQlpZiAodGxzX3BhcnNlX2NlcnQocG9zLCBjZXJ0X2xlbiwKIAkJCQkJICAgJmNvbm4tPmNsaWVudF9yc2Ffa2V5KSkgewotCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEZhaWxlZCB0byBwYXJzZSAiCi0JCQkJCSAgICJ0aGUgY2VydGlmaWNhdGUiKTsKKwkJCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJGYWlsZWQgdG8gcGFyc2UgdGhlIGNlcnRpZmljYXRlIik7CiAJCQkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkJCSAgIFRMU19BTEVSVF9CQURfQ0VSVElGSUNBVEUpOwogCQkJCXg1MDlfY2VydGlmaWNhdGVfY2hhaW5fZnJlZShjaGFpbik7CkBAIC00MTUsOCArNDIxLDcgQEAKIAogCQljZXJ0ID0geDUwOV9jZXJ0aWZpY2F0ZV9wYXJzZShwb3MsIGNlcnRfbGVuKTsKIAkJaWYgKGNlcnQgPT0gTlVMTCkgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogRmFpbGVkIHRvIHBhcnNlICIKLQkJCQkgICAidGhlIGNlcnRpZmljYXRlIik7CisJCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJGYWlsZWQgdG8gcGFyc2UgdGhlIGNlcnRpZmljYXRlIik7CiAJCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCQkgICBUTFNfQUxFUlRfQkFEX0NFUlRJRklDQVRFKTsKIAkJCXg1MDlfY2VydGlmaWNhdGVfY2hhaW5fZnJlZShjaGFpbik7CkBAIC00MzYsOCArNDQxLDggQEAKIAlpZiAoeDUwOV9jZXJ0aWZpY2F0ZV9jaGFpbl92YWxpZGF0ZShjb25uLT5jcmVkLT50cnVzdGVkX2NlcnRzLCBjaGFpbiwKIAkJCQkJICAgICZyZWFzb24sIDApIDwgMCkgewogCQlpbnQgdGxzX3JlYXNvbjsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogU2VydmVyIGNlcnRpZmljYXRlIGNoYWluICIKLQkJCSAgICJ2YWxpZGF0aW9uIGZhaWxlZCAocmVhc29uPSVkKSIsIHJlYXNvbik7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlNlcnZlciBjZXJ0aWZpY2F0ZSBjaGFpbiB2YWxpZGF0aW9uIGZhaWxlZCAocmVhc29uPSVkKSIsCisJCQkJIHJlYXNvbik7CiAJCXN3aXRjaCAocmVhc29uKSB7CiAJCWNhc2UgWDUwOV9WQUxJREFURV9CQURfQ0VSVElGSUNBVEU6CiAJCQl0bHNfcmVhc29uID0gVExTX0FMRVJUX0JBRF9DRVJUSUZJQ0FURTsKQEAgLTQ5NCw5ICs0OTksOCBAQAogCWVuY3JfbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CiAJcG9zICs9IDI7CiAJaWYgKHBvcyArIGVuY3JfbGVuID4gZW5kKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEludmFsaWQgQ2xpZW50S2V5RXhjaGFuZ2UgIgotCQkJICAgImZvcm1hdDogZW5jcl9sZW49JXUgbGVmdD0ldSIsCi0JCQkgICBlbmNyX2xlbiwgKHVuc2lnbmVkIGludCkgKGVuZCAtIHBvcykpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJJbnZhbGlkIENsaWVudEtleUV4Y2hhbmdlIGZvcm1hdDogZW5jcl9sZW49JXUgbGVmdD0ldSIsCisJCQkJIGVuY3JfbGVuLCAodW5zaWduZWQgaW50KSAoZW5kIC0gcG9zKSk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX0RFQ09ERV9FUlJPUik7CiAJCXJldHVybiAtMTsKQEAgLTUzOSwxNSArNTQzLDEzIEBACiAJfQogCiAJaWYgKCF1c2VfcmFuZG9tICYmIG91dGxlbiAhPSBUTFNfUFJFX01BU1RFUl9TRUNSRVRfTEVOKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFVuZXhwZWN0ZWQgUHJlTWFzdGVyU2VjcmV0ICIKLQkJCSAgICJsZW5ndGggJWx1IiwgKHVuc2lnbmVkIGxvbmcpIG91dGxlbik7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgUHJlTWFzdGVyU2VjcmV0IGxlbmd0aCAlbHUiLAorCQkJCSAodW5zaWduZWQgbG9uZykgb3V0bGVuKTsKIAkJdXNlX3JhbmRvbSA9IDE7CiAJfQogCiAJaWYgKCF1c2VfcmFuZG9tICYmIFdQQV9HRVRfQkUxNihvdXQpICE9IGNvbm4tPmNsaWVudF92ZXJzaW9uKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IENsaWVudCB2ZXJzaW9uIGluICIKLQkJCSAgICJDbGllbnRLZXlFeGNoYW5nZSBkb2VzIG5vdCBtYXRjaCB3aXRoIHZlcnNpb24gaW4gIgotCQkJICAgIkNsaWVudEhlbGxvIik7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkNsaWVudCB2ZXJzaW9uIGluIENsaWVudEtleUV4Y2hhbmdlIGRvZXMgbm90IG1hdGNoIHdpdGggdmVyc2lvbiBpbiBDbGllbnRIZWxsbyIpOwogCQl1c2VfcmFuZG9tID0gMTsKIAl9CiAKQEAgLTU4Miw3ICs1ODQsNyBAQAogfQogCiAKLXN0YXRpYyBpbnQgdGxzX3Byb2Nlc3NfY2xpZW50X2tleV9leGNoYW5nZV9kaF9hbm9uKAorc3RhdGljIGludCB0bHNfcHJvY2Vzc19jbGllbnRfa2V5X2V4Y2hhbmdlX2RoKAogCXN0cnVjdCB0bHN2MV9zZXJ2ZXIgKmNvbm4sIGNvbnN0IHU4ICpwb3MsIGNvbnN0IHU4ICplbmQpCiB7CiAJY29uc3QgdTggKmRoX3ljOwpAQCAtNTkwLDYgKzU5Miw4IEBACiAJdTggKnNoYXJlZDsKIAlzaXplX3Qgc2hhcmVkX2xlbjsKIAlpbnQgcmVzOworCWNvbnN0IHU4ICpkaF9wOworCXNpemVfdCBkaF9wX2xlbjsKIAogCS8qCiAJICogc3RydWN0IHsKQEAgLTYwMCw2ICs2MDQsNyBAQAogCSAqIH0gQ2xpZW50RGlmZmllSGVsbG1hblB1YmxpYzsKIAkgKi8KIAorCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkNsaWVudERpZmZpZUhlbGxtYW5QdWJsaWMgcmVjZWl2ZWQiKTsKIAl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlRMU3YxOiBDbGllbnREaWZmaWVIZWxsbWFuUHVibGljIiwKIAkJICAgIHBvcywgZW5kIC0gcG9zKTsKIApAQCAtNjEyLDggKzYxNyw3IEBACiAJfQogCiAJaWYgKGVuZCAtIHBvcyA8IDMpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogSW52YWxpZCBjbGllbnQgcHVibGljIHZhbHVlICIKLQkJCSAgICJsZW5ndGgiKTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiSW52YWxpZCBjbGllbnQgcHVibGljIHZhbHVlIGxlbmd0aCIpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQlyZXR1cm4gLTE7CkBAIC02MjMsOCArNjI3LDggQEAKIAlkaF95YyA9IHBvcyArIDI7CiAKIAlpZiAoZGhfeWMgKyBkaF95Y19sZW4gPiBlbmQpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogQ2xpZW50IHB1YmxpYyB2YWx1ZSBvdmVyZmxvdyAiCi0JCQkgICAiKGxlbmd0aCAlZCkiLCBkaF95Y19sZW4pOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJDbGllbnQgcHVibGljIHZhbHVlIG92ZXJmbG93IChsZW5ndGggJWQpIiwKKwkJCQkgZGhfeWNfbGVuKTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJcmV0dXJuIC0xOwpAQCAtNjQxLDcgKzY0NSw5IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQlzaGFyZWRfbGVuID0gY29ubi0+Y3JlZC0+ZGhfcF9sZW47CisJdGxzdjFfc2VydmVyX2dldF9kaF9wKGNvbm4sICZkaF9wLCAmZGhfcF9sZW4pOworCisJc2hhcmVkX2xlbiA9IGRoX3BfbGVuOwogCXNoYXJlZCA9IG9zX21hbGxvYyhzaGFyZWRfbGVuKTsKIAlpZiAoc2hhcmVkID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogQ291bGQgbm90IGFsbG9jYXRlIG1lbW9yeSBmb3IgIgpAQCAtNjUzLDggKzY1OSw3IEBACiAKIAkvKiBzaGFyZWQgPSBZY15zZWNyZXQgbW9kIHAgKi8KIAlpZiAoY3J5cHRvX21vZF9leHAoZGhfeWMsIGRoX3ljX2xlbiwgY29ubi0+ZGhfc2VjcmV0LAotCQkJICAgY29ubi0+ZGhfc2VjcmV0X2xlbiwKLQkJCSAgIGNvbm4tPmNyZWQtPmRoX3AsIGNvbm4tPmNyZWQtPmRoX3BfbGVuLAorCQkJICAgY29ubi0+ZGhfc2VjcmV0X2xlbiwgZGhfcCwgZGhfcF9sZW4sCiAJCQkgICBzaGFyZWQsICZzaGFyZWRfbGVuKSkgewogCQlvc19mcmVlKHNoYXJlZCk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCkBAIC02OTUsOCArNzAwLDggQEAKIAljb25zdCBzdHJ1Y3QgdGxzX2NpcGhlcl9zdWl0ZSAqc3VpdGU7CiAKIAlpZiAoY3QgIT0gVExTX0NPTlRFTlRfVFlQRV9IQU5EU0hBS0UpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogRXhwZWN0ZWQgSGFuZHNoYWtlOyAiCi0JCQkgICAicmVjZWl2ZWQgY29udGVudCB0eXBlIDB4JXgiLCBjdCk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkV4cGVjdGVkIEhhbmRzaGFrZTsgcmVjZWl2ZWQgY29udGVudCB0eXBlIDB4JXgiLAorCQkJCSBjdCk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX1VORVhQRUNURURfTUVTU0FHRSk7CiAJCXJldHVybiAtMTsKQEAgLTcwNiw4ICs3MTEsOCBAQAogCWxlZnQgPSAqaW5fbGVuOwogCiAJaWYgKGxlZnQgPCA0KSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFRvbyBzaG9ydCBDbGllbnRLZXlFeGNoYW5nZSAiCi0JCQkgICAiKExlZnQ9JWx1KSIsICh1bnNpZ25lZCBsb25nKSBsZWZ0KTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVG9vIHNob3J0IENsaWVudEtleUV4Y2hhbmdlIChMZWZ0PSVsdSkiLAorCQkJCSAodW5zaWduZWQgbG9uZykgbGVmdCk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX0RFQ09ERV9FUlJPUik7CiAJCXJldHVybiAtMTsKQEAgLTcxOSw5ICs3MjQsOCBAQAogCWxlZnQgLT0gNDsKIAogCWlmIChsZW4gPiBsZWZ0KSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IE1pc21hdGNoIGluIENsaWVudEtleUV4Y2hhbmdlICIKLQkJCSAgICJsZW5ndGggKGxlbj0lbHUgIT0gbGVmdD0lbHUpIiwKLQkJCSAgICh1bnNpZ25lZCBsb25nKSBsZW4sICh1bnNpZ25lZCBsb25nKSBsZWZ0KTsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiTWlzbWF0Y2ggaW4gQ2xpZW50S2V5RXhjaGFuZ2UgbGVuZ3RoIChsZW49JWx1ICE9IGxlZnQ9JWx1KSIsCisJCQkJICh1bnNpZ25lZCBsb25nKSBsZW4sICh1bnNpZ25lZCBsb25nKSBsZWZ0KTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJcmV0dXJuIC0xOwpAQCAtNzMwLDE0ICs3MzQsMTQgQEAKIAllbmQgPSBwb3MgKyBsZW47CiAKIAlpZiAodHlwZSAhPSBUTFNfSEFORFNIQUtFX1RZUEVfQ0xJRU5UX0tFWV9FWENIQU5HRSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBSZWNlaXZlZCB1bmV4cGVjdGVkIGhhbmRzaGFrZSAiCi0JCQkgICAibWVzc2FnZSAlZCAoZXhwZWN0ZWQgQ2xpZW50S2V5RXhjaGFuZ2UpIiwgdHlwZSk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlJlY2VpdmVkIHVuZXhwZWN0ZWQgaGFuZHNoYWtlIG1lc3NhZ2UgJWQgKGV4cGVjdGVkIENsaWVudEtleUV4Y2hhbmdlKSIsCisJCQkJIHR5cGUpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9VTkVYUEVDVEVEX01FU1NBR0UpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogUmVjZWl2ZWQgQ2xpZW50S2V5RXhjaGFuZ2UiKTsKKwl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJSZWNlaXZlZCBDbGllbnRLZXlFeGNoYW5nZSIpOwogCiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiVExTdjE6IENsaWVudEtleUV4Y2hhbmdlIiwgcG9zLCBsZW4pOwogCkBAIC03NDcsMTEgKzc1MSwxMSBAQAogCWVsc2UKIAkJa2V5eCA9IHN1aXRlLT5rZXlfZXhjaGFuZ2U7CiAKLQlpZiAoa2V5eCA9PSBUTFNfS0VZX1hfREhfYW5vbiAmJgotCSAgICB0bHNfcHJvY2Vzc19jbGllbnRfa2V5X2V4Y2hhbmdlX2RoX2Fub24oY29ubiwgcG9zLCBlbmQpIDwgMCkKKwlpZiAoKGtleXggPT0gVExTX0tFWV9YX0RIX2Fub24gfHwga2V5eCA9PSBUTFNfS0VZX1hfREhFX1JTQSkgJiYKKwkgICAgdGxzX3Byb2Nlc3NfY2xpZW50X2tleV9leGNoYW5nZV9kaChjb25uLCBwb3MsIGVuZCkgPCAwKQogCQlyZXR1cm4gLTE7CiAKLQlpZiAoa2V5eCAhPSBUTFNfS0VZX1hfREhfYW5vbiAmJgorCWlmIChrZXl4ICE9IFRMU19LRVlfWF9ESF9hbm9uICYmIGtleXggIT0gVExTX0tFWV9YX0RIRV9SU0EgJiYKIAkgICAgdGxzX3Byb2Nlc3NfY2xpZW50X2tleV9leGNoYW5nZV9yc2EoY29ubiwgcG9zLCBlbmQpIDwgMCkKIAkJcmV0dXJuIC0xOwogCkBAIC03NjksMTUgKzc3MywxNCBAQAogCWNvbnN0IHU4ICpwb3MsICplbmQ7CiAJc2l6ZV90IGxlZnQsIGxlbjsKIAl1OCB0eXBlOwotCXNpemVfdCBobGVuLCBidWZsZW47Ci0JdTggaGFzaFtNRDVfTUFDX0xFTiArIFNIQTFfTUFDX0xFTl0sICpocG9zLCAqYnVmOworCXNpemVfdCBobGVuOworCXU4IGhhc2hbTUQ1X01BQ19MRU4gKyBTSEExX01BQ19MRU5dLCAqaHBvczsKIAllbnVtIHsgU0lHTl9BTEdfUlNBLCBTSUdOX0FMR19EU0EgfSBhbGcgPSBTSUdOX0FMR19SU0E7Ci0JdTE2IHNsZW47CisJdTggYWxlcnQ7CiAKIAlpZiAoY3QgPT0gVExTX0NPTlRFTlRfVFlQRV9DSEFOR0VfQ0lQSEVSX1NQRUMpIHsKIAkJaWYgKGNvbm4tPnZlcmlmeV9wZWVyKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBDbGllbnQgZGlkIG5vdCBpbmNsdWRlICIKLQkJCQkgICAiQ2VydGlmaWNhdGVWZXJpZnkiKTsKKwkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkNsaWVudCBkaWQgbm90IGluY2x1ZGUgQ2VydGlmaWNhdGVWZXJpZnkiKTsKIAkJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJCSAgIFRMU19BTEVSVF9VTkVYUEVDVEVEX01FU1NBR0UpOwogCQkJcmV0dXJuIC0xOwpAQCAtNzg4LDggKzc5MSw4IEBACiAJfQogCiAJaWYgKGN0ICE9IFRMU19DT05URU5UX1RZUEVfSEFORFNIQUtFKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEV4cGVjdGVkIEhhbmRzaGFrZTsgIgotCQkJICAgInJlY2VpdmVkIGNvbnRlbnQgdHlwZSAweCV4IiwgY3QpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJFeHBlY3RlZCBIYW5kc2hha2U7IHJlY2VpdmVkIGNvbnRlbnQgdHlwZSAweCV4IiwKKwkJCQkgY3QpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9VTkVYUEVDVEVEX01FU1NBR0UpOwogCQlyZXR1cm4gLTE7CkBAIC03OTksOCArODAyLDggQEAKIAlsZWZ0ID0gKmluX2xlbjsKIAogCWlmIChsZWZ0IDwgNCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBUb28gc2hvcnQgQ2VydGlmaWNhdGVWZXJpZnkgIgotCQkJICAgIm1lc3NhZ2UgKGxlbj0lbHUpIiwgKHVuc2lnbmVkIGxvbmcpIGxlZnQpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJUb28gc2hvcnQgQ2VydGlmaWNhdGVWZXJpZnkgbWVzc2FnZSAobGVuPSVsdSkiLAorCQkJCSAodW5zaWduZWQgbG9uZykgbGVmdCk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX0RFQ09ERV9FUlJPUik7CiAJCXJldHVybiAtMTsKQEAgLTgxMiw5ICs4MTUsOCBAQAogCWxlZnQgLT0gNDsKIAogCWlmIChsZW4gPiBsZWZ0KSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFVuZXhwZWN0ZWQgQ2VydGlmaWNhdGVWZXJpZnkgIgotCQkJICAgIm1lc3NhZ2UgbGVuZ3RoIChsZW49JWx1ICE9IGxlZnQ9JWx1KSIsCi0JCQkgICAodW5zaWduZWQgbG9uZykgbGVuLCAodW5zaWduZWQgbG9uZykgbGVmdCk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgQ2VydGlmaWNhdGVWZXJpZnkgbWVzc2FnZSBsZW5ndGggKGxlbj0lbHUgIT0gbGVmdD0lbHUpIiwKKwkJCQkgKHVuc2lnbmVkIGxvbmcpIGxlbiwgKHVuc2lnbmVkIGxvbmcpIGxlZnQpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQlyZXR1cm4gLTE7CkBAIC04MjMsMTQgKzgyNSwxNCBAQAogCWVuZCA9IHBvcyArIGxlbjsKIAogCWlmICh0eXBlICE9IFRMU19IQU5EU0hBS0VfVFlQRV9DRVJUSUZJQ0FURV9WRVJJRlkpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogUmVjZWl2ZWQgdW5leHBlY3RlZCBoYW5kc2hha2UgIgotCQkJICAgIm1lc3NhZ2UgJWQgKGV4cGVjdGVkIENlcnRpZmljYXRlVmVyaWZ5KSIsIHR5cGUpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJSZWNlaXZlZCB1bmV4cGVjdGVkIGhhbmRzaGFrZSBtZXNzYWdlICVkIChleHBlY3RlZCBDZXJ0aWZpY2F0ZVZlcmlmeSkiLAorCQkJCSB0eXBlKTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfVU5FWFBFQ1RFRF9NRVNTQUdFKTsKIAkJcmV0dXJuIC0xOwogCX0KIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFJlY2VpdmVkIENlcnRpZmljYXRlVmVyaWZ5Iik7CisJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiUmVjZWl2ZWQgQ2VydGlmaWNhdGVWZXJpZnkiKTsKIAogCS8qCiAJICogc3RydWN0IHsKQEAgLTkxNyw4OSArOTE5LDEyIEBACiAKIAl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlRMU3YxOiBDZXJ0aWZpY2F0ZVZlcmlmeSBoYXNoIiwgaGFzaCwgaGxlbik7CiAKLQlpZiAoZW5kIC0gcG9zIDwgMikgewotCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAotCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOworCWlmICh0bHNfdmVyaWZ5X3NpZ25hdHVyZShjb25uLT5ybC50bHNfdmVyc2lvbiwgY29ubi0+Y2xpZW50X3JzYV9rZXksCisJCQkJIGhhc2gsIGhsZW4sIHBvcywgZW5kIC0gcG9zLCAmYWxlcnQpIDwgMCkgeworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJJbnZhbGlkIFNpZ25hdHVyZSBpbiBDZXJ0aWZpY2F0ZVZlcmlmeSIpOworCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLCBhbGVydCk7CiAJCXJldHVybiAtMTsKIAl9Ci0Jc2xlbiA9IFdQQV9HRVRfQkUxNihwb3MpOwotCXBvcyArPSAyOwotCWlmIChlbmQgLSBwb3MgPCBzbGVuKSB7Ci0JCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCi0JCQkJICAgVExTX0FMRVJUX0RFQ09ERV9FUlJPUik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlRMU3YxOiBTaWduYXR1cmUiLCBwb3MsIGVuZCAtIHBvcyk7Ci0JaWYgKGNvbm4tPmNsaWVudF9yc2Ffa2V5ID09IE5VTEwpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogTm8gY2xpZW50IHB1YmxpYyBrZXkgdG8gdmVyaWZ5ICIKLQkJCSAgICJzaWduYXR1cmUiKTsKLQkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKLQkJCQkgICBUTFNfQUxFUlRfSU5URVJOQUxfRVJST1IpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JYnVmbGVuID0gZW5kIC0gcG9zOwotCWJ1ZiA9IG9zX21hbGxvYyhlbmQgLSBwb3MpOwotCWlmIChjcnlwdG9fcHVibGljX2tleV9kZWNyeXB0X3BrY3MxKGNvbm4tPmNsaWVudF9yc2Ffa2V5LAotCQkJCQkgICAgcG9zLCBlbmQgLSBwb3MsIGJ1ZiwgJmJ1ZmxlbikgPCAwKQotCXsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogRmFpbGVkIHRvIGRlY3J5cHQgc2lnbmF0dXJlIik7Ci0JCW9zX2ZyZWUoYnVmKTsKLQkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKLQkJCQkgICBUTFNfQUxFUlRfREVDUllQVF9FUlJPUik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQl3cGFfaGV4ZHVtcF9rZXkoTVNHX01TR0RVTVAsICJUTFN2MTogRGVjcnlwdGVkIFNpZ25hdHVyZSIsCi0JCQlidWYsIGJ1Zmxlbik7Ci0KLSNpZmRlZiBDT05GSUdfVExTVjEyCi0JaWYgKGNvbm4tPnJsLnRsc192ZXJzaW9uID49IFRMU19WRVJTSU9OXzFfMikgewotCQkvKgotCQkgKiBSRkMgMzQ0NywgQS4yLjQgUlNBU1NBLVBLQ1MxLXYxXzUKLQkJICoKLQkJICogRGlnZXN0SW5mbyA6Oj0gU0VRVUVOQ0UgewotCQkgKiAgIGRpZ2VzdEFsZ29yaXRobSBEaWdlc3RBbGdvcml0aG0sCi0JCSAqICAgZGlnZXN0IE9DVEVUIFNUUklORwotCQkgKiB9Ci0JCSAqCi0JCSAqIFNIQS0yNTYgT0lEOiBzaGEyNTZXaXRoUlNBRW5jcnlwdGlvbiA6Oj0ge3BrY3MtMSAxMX0KLQkJICoKLQkJICogREVSIGVuY29kZWQgRGlnZXN0SW5mbyBmb3IgU0hBMjU2IHBlciBSRkMgMzQ0NzoKLQkJICogMzAgMzEgMzAgMGQgMDYgMDkgNjAgODYgNDggMDEgNjUgMDMgMDQgMDIgMDEgMDUgMDAgMDQgMjAgfHwKLQkJICogSAotCQkgKi8KLQkJaWYgKGJ1ZmxlbiA+PSAxOSArIDMyICYmCi0JCSAgICBvc19tZW1jbXAoYnVmLCAiXHgzMFx4MzFceDMwXHgwZFx4MDZceDA5XHg2MFx4ODZceDQ4XHgwMSIKLQkJCSAgICAgICJceDY1XHgwM1x4MDRceDAyXHgwMVx4MDVceDAwXHgwNFx4MjAiLCAxOSkgPT0gMCkKLQkJewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MS4yOiBEaWdlc3RBbGdvcml0aG4gPSAiCi0JCQkJICAgIlNIQS0yNTYiKTsKLQkJCW9zX21lbW1vdmUoYnVmLCBidWYgKyAxOSwgYnVmbGVuIC0gMTkpOwotCQkJYnVmbGVuIC09IDE5OwotCQl9IGVsc2UgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MS4yOiBVbnJlY29nbml6ZWQgIgotCQkJCSAgICJEaWdlc3RJbmZvIik7Ci0JCQlvc19mcmVlKGJ1Zik7Ci0JCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAotCQkJCQkgICBUTFNfQUxFUlRfREVDUllQVF9FUlJPUik7Ci0JCQlyZXR1cm4gLTE7Ci0JCX0KLQl9Ci0jZW5kaWYgLyogQ09ORklHX1RMU1YxMiAqLwotCi0JaWYgKGJ1ZmxlbiAhPSBobGVuIHx8IG9zX21lbWNtcChidWYsIGhhc2gsIGJ1ZmxlbikgIT0gMCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBJbnZhbGlkIFNpZ25hdHVyZSBpbiAiCi0JCQkgICAiQ2VydGlmaWNhdGVWZXJpZnkgLSBkaWQgbm90IG1hdGNoIHdpdGggY2FsY3VsYXRlZCAiCi0JCQkgICAiaGFzaCIpOwotCQlvc19mcmVlKGJ1Zik7Ci0JCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCi0JCQkJICAgVExTX0FMRVJUX0RFQ1JZUFRfRVJST1IpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0Jb3NfZnJlZShidWYpOwogCiAJKmluX2xlbiA9IGVuZCAtIGluX2RhdGE7CiAKQEAgLTEwMTcsOCArOTQyLDggQEAKIAlzaXplX3QgbGVmdDsKIAogCWlmIChjdCAhPSBUTFNfQ09OVEVOVF9UWVBFX0NIQU5HRV9DSVBIRVJfU1BFQykgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBFeHBlY3RlZCBDaGFuZ2VDaXBoZXJTcGVjOyAiCi0JCQkgICAicmVjZWl2ZWQgY29udGVudCB0eXBlIDB4JXgiLCBjdCk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkV4cGVjdGVkIENoYW5nZUNpcGhlclNwZWM7IHJlY2VpdmVkIGNvbnRlbnQgdHlwZSAweCV4IiwKKwkJCQkgY3QpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9VTkVYUEVDVEVEX01FU1NBR0UpOwogCQlyZXR1cm4gLTE7CkBAIC0xMDI4LDIxICs5NTMsMjEgQEAKIAlsZWZ0ID0gKmluX2xlbjsKIAogCWlmIChsZWZ0IDwgMSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBUb28gc2hvcnQgQ2hhbmdlQ2lwaGVyU3BlYyIpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJUb28gc2hvcnQgQ2hhbmdlQ2lwaGVyU3BlYyIpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQlyZXR1cm4gLTE7CiAJfQogCiAJaWYgKCpwb3MgIT0gVExTX0NIQU5HRV9DSVBIRVJfU1BFQykgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBFeHBlY3RlZCBDaGFuZ2VDaXBoZXJTcGVjOyAiCi0JCQkgICAicmVjZWl2ZWQgZGF0YSAweCV4IiwgKnBvcyk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkV4cGVjdGVkIENoYW5nZUNpcGhlclNwZWM7IHJlY2VpdmVkIGRhdGEgMHgleCIsCisJCQkJICpwb3MpOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9VTkVYUEVDVEVEX01FU1NBR0UpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogUmVjZWl2ZWQgQ2hhbmdlQ2lwaGVyU3BlYyIpOworCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlJlY2VpdmVkIENoYW5nZUNpcGhlclNwZWMiKTsKIAlpZiAodGxzdjFfcmVjb3JkX2NoYW5nZV9yZWFkX2NpcGhlcigmY29ubi0+cmwpIDwgMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBGYWlsZWQgdG8gY2hhbmdlIHJlYWQgY2lwaGVyICIKIAkJCSAgICJmb3IgcmVjb3JkIGxheWVyIik7CkBAIC0xMDY3LDkgKzk5Miw0OCBAQAogCXU4IHZlcmlmeV9kYXRhW1RMU19WRVJJRllfREFUQV9MRU5dOwogCXU4IGhhc2hbTUQ1X01BQ19MRU4gKyBTSEExX01BQ19MRU5dOwogCisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUworCWlmICgoY29ubi0+dGVzdF9mbGFncyAmCisJICAgICAoVExTX0JSRUFLX1NSVl9LRVlfWF9IQVNIIHwgVExTX0JSRUFLX1NSVl9LRVlfWF9TSUdOQVRVUkUpKSAmJgorCSAgICAhY29ubi0+dGVzdF9mYWlsdXJlX3JlcG9ydGVkKSB7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRFU1QtRkFJTFVSRTogQ2xpZW50IEZpbmlzaGVkIHJlY2VpdmVkIGFmdGVyIGludmFsaWQgU2VydmVyS2V5RXhjaGFuZ2UiKTsKKwkJY29ubi0+dGVzdF9mYWlsdXJlX3JlcG9ydGVkID0gMTsKKwl9CisKKwlpZiAoKGNvbm4tPnRlc3RfZmxhZ3MgJiBUTFNfREhFX1BSSU1FXzE1KSAmJgorCSAgICAhY29ubi0+dGVzdF9mYWlsdXJlX3JlcG9ydGVkKSB7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRFU1QtRkFJTFVSRTogQ2xpZW50IEZpbmlzaGVkIHJlY2VpdmVkIGFmdGVyIGJvZ3VzIERIRSBcInByaW1lXCIgMTUiKTsKKwkJY29ubi0+dGVzdF9mYWlsdXJlX3JlcG9ydGVkID0gMTsKKwl9CisKKwlpZiAoKGNvbm4tPnRlc3RfZmxhZ3MgJiBUTFNfREhFX1BSSU1FXzU4QikgJiYKKwkgICAgIWNvbm4tPnRlc3RfZmFpbHVyZV9yZXBvcnRlZCkgeworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJURVNULUZBSUxVUkU6IENsaWVudCBGaW5pc2hlZCByZWNlaXZlZCBhZnRlciBzaG9ydCA1OC1iaXQgREhFIHByaW1lIGluIGxvbmcgY29udGFpbmVyIik7CisJCWNvbm4tPnRlc3RfZmFpbHVyZV9yZXBvcnRlZCA9IDE7CisJfQorCisJaWYgKChjb25uLT50ZXN0X2ZsYWdzICYgVExTX0RIRV9QUklNRV81MTFCKSAmJgorCSAgICAhY29ubi0+dGVzdF9mYWlsdXJlX3JlcG9ydGVkKSB7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRFU1QtV0FSTklORzogQ2xpZW50IEZpbmlzaGVkIHJlY2VpdmVkIGFmdGVyIHNob3J0IDUxMS1iaXQgREhFIHByaW1lIChpbnNlY3VyZSkiKTsKKwkJY29ubi0+dGVzdF9mYWlsdXJlX3JlcG9ydGVkID0gMTsKKwl9CisKKwlpZiAoKGNvbm4tPnRlc3RfZmxhZ3MgJiBUTFNfREhFX1BSSU1FXzc2N0IpICYmCisJICAgICFjb25uLT50ZXN0X2ZhaWx1cmVfcmVwb3J0ZWQpIHsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVEVTVC1OT1RFOiBDbGllbnQgRmluaXNoZWQgcmVjZWl2ZWQgYWZ0ZXIgNzY3LWJpdCBESEUgcHJpbWUgKHJlbGF0aXZlbHkgaW5zZWN1cmUpIik7CisJCWNvbm4tPnRlc3RfZmFpbHVyZV9yZXBvcnRlZCA9IDE7CisJfQorCisJaWYgKChjb25uLT50ZXN0X2ZsYWdzICYgVExTX0RIRV9OT05fUFJJTUUpICYmCisJICAgICFjb25uLT50ZXN0X2ZhaWx1cmVfcmVwb3J0ZWQpIHsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVEVTVC1OT1RFOiBDbGllbnQgRmluaXNoZWQgcmVjZWl2ZWQgYWZ0ZXIgbm9uLXByaW1lIGNsYWltZWQgYXMgREhFIHByaW1lIik7CisJCWNvbm4tPnRlc3RfZmFpbHVyZV9yZXBvcnRlZCA9IDE7CisJfQorI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKwogCWlmIChjdCAhPSBUTFNfQ09OVEVOVF9UWVBFX0hBTkRTSEFLRSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBFeHBlY3RlZCBGaW5pc2hlZDsgIgotCQkJICAgInJlY2VpdmVkIGNvbnRlbnQgdHlwZSAweCV4IiwgY3QpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJFeHBlY3RlZCBGaW5pc2hlZDsgcmVjZWl2ZWQgY29udGVudCB0eXBlIDB4JXgiLAorCQkJCSBjdCk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX1VORVhQRUNURURfTUVTU0FHRSk7CiAJCXJldHVybiAtMTsKQEAgLTEwNzksOSArMTA0Myw4IEBACiAJbGVmdCA9ICppbl9sZW47CiAKIAlpZiAobGVmdCA8IDQpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogVG9vIHNob3J0IHJlY29yZCAobGVmdD0lbHUpIGZvciAiCi0JCQkgICAiRmluaXNoZWQiLAotCQkJICAgKHVuc2lnbmVkIGxvbmcpIGxlZnQpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJUb28gc2hvcnQgcmVjb3JkIChsZWZ0PSVsdSkgZm9yRmluaXNoZWQiLAorCQkJCSAodW5zaWduZWQgbG9uZykgbGVmdCk7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJICAgVExTX0FMRVJUX0RFQ09ERV9FUlJPUik7CiAJCXJldHVybiAtMTsKQEAgLTExMDEsMTggKzEwNjQsMTYgQEAKIAlsZWZ0IC09IDQ7CiAKIAlpZiAobGVuID4gbGVmdCkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBUb28gc2hvcnQgYnVmZmVyIGZvciBGaW5pc2hlZCAiCi0JCQkgICAiKGxlbj0lbHUgPiBsZWZ0PSVsdSkiLAotCQkJICAgKHVuc2lnbmVkIGxvbmcpIGxlbiwgKHVuc2lnbmVkIGxvbmcpIGxlZnQpOworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJUb28gc2hvcnQgYnVmZmVyIGZvciBGaW5pc2hlZCAobGVuPSVsdSA+IGxlZnQ9JWx1KSIsCisJCQkJICh1bnNpZ25lZCBsb25nKSBsZW4sICh1bnNpZ25lZCBsb25nKSBsZWZ0KTsKIAkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKIAkJCQkgICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJcmV0dXJuIC0xOwogCX0KIAllbmQgPSBwb3MgKyBsZW47CiAJaWYgKGxlbiAhPSBUTFNfVkVSSUZZX0RBVEFfTEVOKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFVuZXhwZWN0ZWQgdmVyaWZ5X2RhdGEgbGVuZ3RoICIKLQkJCSAgICJpbiBGaW5pc2hlZDogJWx1IChleHBlY3RlZCAlZCkiLAotCQkJICAgKHVuc2lnbmVkIGxvbmcpIGxlbiwgVExTX1ZFUklGWV9EQVRBX0xFTik7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgdmVyaWZ5X2RhdGEgbGVuZ3RoIGluIEZpbmlzaGVkOiAlbHUgKGV4cGVjdGVkICVkKSIsCisJCQkJICh1bnNpZ25lZCBsb25nKSBsZW4sIFRMU19WRVJJRllfREFUQV9MRU4pOwogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9ERUNPREVfRVJST1IpOwogCQlyZXR1cm4gLTE7CkBAIC0xMTc0LDE5ICsxMTM1LDE4IEBACiAJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIlRMU3YxOiB2ZXJpZnlfZGF0YSAoY2xpZW50KSIsCiAJCQl2ZXJpZnlfZGF0YSwgVExTX1ZFUklGWV9EQVRBX0xFTik7CiAKLQlpZiAob3NfbWVtY21wKHBvcywgdmVyaWZ5X2RhdGEsIFRMU19WRVJJRllfREFUQV9MRU4pICE9IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlRMU3YxOiBNaXNtYXRjaCBpbiB2ZXJpZnlfZGF0YSIpOworCWlmIChvc19tZW1jbXBfY29uc3QocG9zLCB2ZXJpZnlfZGF0YSwgVExTX1ZFUklGWV9EQVRBX0xFTikgIT0gMCkgeworCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJNaXNtYXRjaCBpbiB2ZXJpZnlfZGF0YSIpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogUmVjZWl2ZWQgRmluaXNoZWQiKTsKKwl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJSZWNlaXZlZCBGaW5pc2hlZCIpOwogCiAJKmluX2xlbiA9IGVuZCAtIGluX2RhdGE7CiAKIAlpZiAoY29ubi0+dXNlX3Nlc3Npb25fdGlja2V0KSB7CiAJCS8qIEFiYnJldmlhdGVkIGhhbmRzaGFrZSB1c2luZyBzZXNzaW9uIHRpY2tldDsgUkZDIDQ1MDcgKi8KLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogQWJicmV2aWF0ZWQgaGFuZHNoYWtlIGNvbXBsZXRlZCAiCi0JCQkgICAic3VjY2Vzc2Z1bGx5Iik7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIkFiYnJldmlhdGVkIGhhbmRzaGFrZSBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5Iik7CiAJCWNvbm4tPnN0YXRlID0gRVNUQUJMSVNIRUQ7CiAJfSBlbHNlIHsKIAkJLyogRnVsbCBoYW5kc2hha2UgKi8KQEAgLTEyMDIsMTMgKzExNjIsMTIgQEAKIHsKIAlpZiAoY3QgPT0gVExTX0NPTlRFTlRfVFlQRV9BTEVSVCkgewogCQlpZiAoKmxlbiA8IDIpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEFsZXJ0IHVuZGVyZmxvdyIpOworCQkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiQWxlcnQgdW5kZXJmbG93Iik7CiAJCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCQkgICBUTFNfQUxFUlRfREVDT0RFX0VSUk9SKTsKIAkJCXJldHVybiAtMTsKIAkJfQotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBSZWNlaXZlZCBhbGVydCAlZDolZCIsCi0JCQkgICBidWZbMF0sIGJ1ZlsxXSk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlJlY2VpdmVkIGFsZXJ0ICVkOiVkIiwgYnVmWzBdLCBidWZbMV0pOwogCQkqbGVuID0gMjsKIAkJY29ubi0+c3RhdGUgPSBGQUlMRUQ7CiAJCXJldHVybiAtMTsKQEAgLTEyNDAsOSArMTE5OSw4IEBACiAJCQlyZXR1cm4gLTE7CiAJCWJyZWFrOwogCWRlZmF1bHQ6Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFVuZXhwZWN0ZWQgc3RhdGUgJWQgIgotCQkJICAgIndoaWxlIHByb2Nlc3NpbmcgcmVjZWl2ZWQgbWVzc2FnZSIsCi0JCQkgICBjb25uLT5zdGF0ZSk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgc3RhdGUgJWQgd2hpbGUgcHJvY2Vzc2luZyByZWNlaXZlZCBtZXNzYWdlIiwKKwkJCQkgY29ubi0+c3RhdGUpOwogCQlyZXR1cm4gLTE7CiAJfQogCmRpZmYgLS1naXQgYS9zcmMvdGxzL3Rsc3YxX3NlcnZlcl93cml0ZS5jIGIvc3JjL3Rscy90bHN2MV9zZXJ2ZXJfd3JpdGUuYwppbmRleCA2ZDhlNTVlLi4xNWU2NjkyIDEwMDY0NAotLS0gYS9zcmMvdGxzL3Rsc3YxX3NlcnZlcl93cml0ZS5jCisrKyBiL3NyYy90bHMvdGxzdjFfc2VydmVyX3dyaXRlLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogVExTdjEgc2VydmVyIC0gd3JpdGUgaGFuZHNoYWtlIG1lc3NhZ2UKLSAqIENvcHlyaWdodCAoYykgMjAwNi0yMDExLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA2LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTQ4LDcgKzQ4LDcgQEAKIAogCXBvcyA9ICptc2dwb3M7CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBTZW5kIFNlcnZlckhlbGxvIik7CisJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiU2VuZCBTZXJ2ZXJIZWxsbyIpOwogCXJoZHIgPSBwb3M7CiAJcG9zICs9IFRMU19SRUNPUkRfSEVBREVSX0xFTjsKIApAQCAtMTA0LDggKzEwNCw3IEBACiAJCQljb25uLT5jbGllbnRfcmFuZG9tLCBjb25uLT5zZXJ2ZXJfcmFuZG9tLAogCQkJY29ubi0+bWFzdGVyX3NlY3JldCk7CiAJCWlmIChyZXMgPCAwKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBTZXNzaW9uVGlja2V0IGNhbGxiYWNrICIKLQkJCQkgICAiaW5kaWNhdGVkIGZhaWx1cmUiKTsKKwkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlNlc3Npb25UaWNrZXQgY2FsbGJhY2sgaW5kaWNhdGVkIGZhaWx1cmUiKTsKIAkJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCiAJCQkJCSAgIFRMU19BTEVSVF9IQU5EU0hBS0VfRkFJTFVSRSk7CiAJCQlyZXR1cm4gLTE7CkBAIC0xNzAsNyArMTY5LDcgQEAKIAogCXBvcyA9ICptc2dwb3M7CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBTZW5kIENlcnRpZmljYXRlIik7CisJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiU2VuZCBDZXJ0aWZpY2F0ZSIpOwogCXJoZHIgPSBwb3M7CiAJcG9zICs9IFRMU19SRUNPUkRfSEVBREVSX0xFTjsKIApAQCAtMjQ1LDEwICsyNDQsMTIgQEAKIHsKIAl0bHNfa2V5X2V4Y2hhbmdlIGtleXg7CiAJY29uc3Qgc3RydWN0IHRsc19jaXBoZXJfc3VpdGUgKnN1aXRlOwotCXU4ICpwb3MsICpyaGRyLCAqaHNfc3RhcnQsICpoc19sZW5ndGg7CisJdTggKnBvcywgKnJoZHIsICpoc19zdGFydCwgKmhzX2xlbmd0aCwgKnNlcnZlcl9wYXJhbXM7CiAJc2l6ZV90IHJsZW47CiAJdTggKmRoX3lzOwogCXNpemVfdCBkaF95c19sZW47CisJY29uc3QgdTggKmRoX3A7CisJc2l6ZV90IGRoX3BfbGVuOwogCiAJc3VpdGUgPSB0bHNfZ2V0X2NpcGhlcl9zdWl0ZShjb25uLT5ybC5jaXBoZXJfc3VpdGUpOwogCWlmIChzdWl0ZSA9PSBOVUxMKQpAQCAtMjYxLDggKzI2Miw3IEBACiAJCXJldHVybiAwOwogCX0KIAotCWlmIChrZXl4ICE9IFRMU19LRVlfWF9ESF9hbm9uKSB7Ci0JCS8qIFRPRE8/ICovCisJaWYgKGtleXggIT0gVExTX0tFWV9YX0RIX2Fub24gJiYga2V5eCAhPSBUTFNfS0VZX1hfREhFX1JTQSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBTZXJ2ZXJLZXlFeGNoYW5nZSBub3QgeWV0ICIKIAkJCSAgICJzdXBwb3J0ZWQgd2l0aCBrZXkgZXhjaGFuZ2UgdHlwZSAlZCIsIGtleXgpOwogCQlyZXR1cm4gLTE7CkBAIC0yNzUsOCArMjc1LDEwIEBACiAJCXJldHVybiAtMTsKIAl9CiAKKwl0bHN2MV9zZXJ2ZXJfZ2V0X2RoX3AoY29ubiwgJmRoX3AsICZkaF9wX2xlbik7CisKIAlvc19mcmVlKGNvbm4tPmRoX3NlY3JldCk7Ci0JY29ubi0+ZGhfc2VjcmV0X2xlbiA9IGNvbm4tPmNyZWQtPmRoX3BfbGVuOworCWNvbm4tPmRoX3NlY3JldF9sZW4gPSBkaF9wX2xlbjsKIAljb25uLT5kaF9zZWNyZXQgPSBvc19tYWxsb2MoY29ubi0+ZGhfc2VjcmV0X2xlbik7CiAJaWYgKGNvbm4tPmRoX3NlY3JldCA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEZhaWxlZCB0byBhbGxvY2F0ZSAiCkBAIC0yOTUsOCArMjk3LDcgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmIChvc19tZW1jbXAoY29ubi0+ZGhfc2VjcmV0LCBjb25uLT5jcmVkLT5kaF9wLCBjb25uLT5kaF9zZWNyZXRfbGVuKSA+Ci0JICAgIDApCisJaWYgKG9zX21lbWNtcChjb25uLT5kaF9zZWNyZXQsIGRoX3AsIGNvbm4tPmRoX3NlY3JldF9sZW4pID4gMCkKIAkJY29ubi0+ZGhfc2VjcmV0WzBdID0gMDsgLyogbWFrZSBzdXJlIHNlY3JldCA8IHAgKi8KIAogCXBvcyA9IGNvbm4tPmRoX3NlY3JldDsKQEAgLTMxMSw3ICszMTIsNyBAQAogCQkJY29ubi0+ZGhfc2VjcmV0LCBjb25uLT5kaF9zZWNyZXRfbGVuKTsKIAogCS8qIFlzID0gZ15zZWNyZXQgbW9kIHAgKi8KLQlkaF95c19sZW4gPSBjb25uLT5jcmVkLT5kaF9wX2xlbjsKKwlkaF95c19sZW4gPSBkaF9wX2xlbjsKIAlkaF95cyA9IG9zX21hbGxvYyhkaF95c19sZW4pOwogCWlmIChkaF95cyA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yICIKQEAgLTMyMiw4ICszMjMsNyBAQAogCX0KIAlpZiAoY3J5cHRvX21vZF9leHAoY29ubi0+Y3JlZC0+ZGhfZywgY29ubi0+Y3JlZC0+ZGhfZ19sZW4sCiAJCQkgICBjb25uLT5kaF9zZWNyZXQsIGNvbm4tPmRoX3NlY3JldF9sZW4sCi0JCQkgICBjb25uLT5jcmVkLT5kaF9wLCBjb25uLT5jcmVkLT5kaF9wX2xlbiwKLQkJCSAgIGRoX3lzLCAmZGhfeXNfbGVuKSkgeworCQkJICAgZGhfcCwgZGhfcF9sZW4sIGRoX3lzLCAmZGhfeXNfbGVuKSkgewogCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAogCQkJCSAgIFRMU19BTEVSVF9JTlRFUk5BTF9FUlJPUik7CiAJCW9zX2ZyZWUoZGhfeXMpOwpAQCAtMzU0LDcgKzM1NCw3IEBACiAKIAlwb3MgPSAqbXNncG9zOwogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogU2VuZCBTZXJ2ZXJLZXlFeGNoYW5nZSIpOworCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlNlbmQgU2VydmVyS2V5RXhjaGFuZ2UiKTsKIAlyaGRyID0gcG9zOwogCXBvcyArPSBUTFNfUkVDT1JEX0hFQURFUl9MRU47CiAKQEAgLTM2OSw4ICszNjksOSBAQAogCXBvcyArPSAzOwogCiAJLyogYm9keSAtIFNlcnZlckRIUGFyYW1zICovCisJc2VydmVyX3BhcmFtcyA9IHBvczsKIAkvKiBkaF9wICovCi0JaWYgKHBvcyArIDIgKyBjb25uLT5jcmVkLT5kaF9wX2xlbiA+IGVuZCkgeworCWlmIChwb3MgKyAyICsgZGhfcF9sZW4gPiBlbmQpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogTm90IGVub3VnaCBidWZmZXIgc3BhY2UgZm9yICIKIAkJCSAgICJkaF9wIik7CiAJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCkBAIC0zNzgsMTAgKzM3OSwxMCBAQAogCQlvc19mcmVlKGRoX3lzKTsKIAkJcmV0dXJuIC0xOwogCX0KLQlXUEFfUFVUX0JFMTYocG9zLCBjb25uLT5jcmVkLT5kaF9wX2xlbik7CisJV1BBX1BVVF9CRTE2KHBvcywgZGhfcF9sZW4pOwogCXBvcyArPSAyOwotCW9zX21lbWNweShwb3MsIGNvbm4tPmNyZWQtPmRoX3AsIGNvbm4tPmNyZWQtPmRoX3BfbGVuKTsKLQlwb3MgKz0gY29ubi0+Y3JlZC0+ZGhfcF9sZW47CisJb3NfbWVtY3B5KHBvcywgZGhfcCwgZGhfcF9sZW4pOworCXBvcyArPSBkaF9wX2xlbjsKIAogCS8qIGRoX2cgKi8KIAlpZiAocG9zICsgMiArIGNvbm4tPmNyZWQtPmRoX2dfbGVuID4gZW5kKSB7CkBAIC00MTIsNiArNDEzLDEzOCBAQAogCXBvcyArPSBkaF95c19sZW47CiAJb3NfZnJlZShkaF95cyk7CiAKKwkvKgorCSAqIHNlbGVjdCAoU2lnbmF0dXJlQWxnb3JpdGhtKQorCSAqIHsgICBjYXNlIGFub255bW91czogc3RydWN0IHsgfTsKKwkgKiAgICAgY2FzZSByc2E6CisJICogICAgICAgICBkaWdpdGFsbHktc2lnbmVkIHN0cnVjdCB7CisJICogICAgICAgICAgICAgb3BhcXVlIG1kNV9oYXNoWzE2XTsKKwkgKiAgICAgICAgICAgICBvcGFxdWUgc2hhX2hhc2hbMjBdOworCSAqICAgICAgICAgfTsKKwkgKiAgICAgY2FzZSBkc2E6CisJICogICAgICAgICBkaWdpdGFsbHktc2lnbmVkIHN0cnVjdCB7CisJICogICAgICAgICAgICAgb3BhcXVlIHNoYV9oYXNoWzIwXTsKKwkgKiAgICAgICAgIH07CisJICogfSBTaWduYXR1cmU7CisJICoKKwkgKiBtZDVfaGFzaAorCSAqICAgICBNRDUoQ2xpZW50SGVsbG8ucmFuZG9tICsgU2VydmVySGVsbG8ucmFuZG9tICsgU2VydmVyUGFyYW1zKTsKKwkgKgorCSAqIHNoYV9oYXNoCisJICogICAgIFNIQShDbGllbnRIZWxsby5yYW5kb20gKyBTZXJ2ZXJIZWxsby5yYW5kb20gKyBTZXJ2ZXJQYXJhbXMpOworCSAqLworCisJaWYgKGtleXggPT0gVExTX0tFWV9YX0RIRV9SU0EpIHsKKwkJdTggaGFzaFsxMDBdOworCQl1OCAqc2lnbmVkX3N0YXJ0OworCQlzaXplX3QgY2xlbjsKKwkJaW50IGhsZW47CisKKwkJaWYgKGNvbm4tPnJsLnRsc192ZXJzaW9uID49IFRMU19WRVJTSU9OXzFfMikgeworI2lmZGVmIENPTkZJR19UTFNWMTIKKwkJCWhsZW4gPSB0bHN2MTJfa2V5X3hfc2VydmVyX3BhcmFtc19oYXNoKAorCQkJCWNvbm4tPnJsLnRsc192ZXJzaW9uLCBjb25uLT5jbGllbnRfcmFuZG9tLAorCQkJCWNvbm4tPnNlcnZlcl9yYW5kb20sIHNlcnZlcl9wYXJhbXMsCisJCQkJcG9zIC0gc2VydmVyX3BhcmFtcywgaGFzaCArIDE5KTsKKworCQkJLyoKKwkJCSAqIFJGQyA1MjQ2LCA0Ljc6CisJCQkgKiBUTFMgdjEuMiBhZGRzIGV4cGxpY2l0IGluZGljYXRpb24gb2YgdGhlIHVzZWQKKwkJCSAqIHNpZ25hdHVyZSBhbmQgaGFzaCBhbGdvcml0aG1zLgorCQkJICoKKwkJCSAqIHN0cnVjdCB7CisJCQkgKiAgIEhhc2hBbGdvcml0aG0gaGFzaDsKKwkJCSAqICAgU2lnbmF0dXJlQWxnb3JpdGhtIHNpZ25hdHVyZTsKKwkJCSAqIH0gU2lnbmF0dXJlQW5kSGFzaEFsZ29yaXRobTsKKwkJCSAqLworCQkJaWYgKGhsZW4gPCAwIHx8IHBvcyArIDIgPiBlbmQpIHsKKwkJCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAorCQkJCQkJICAgVExTX0FMRVJUX0lOVEVSTkFMX0VSUk9SKTsKKwkJCQlyZXR1cm4gLTE7CisJCQl9CisJCQkqcG9zKysgPSBUTFNfSEFTSF9BTEdfU0hBMjU2OworCQkJKnBvcysrID0gVExTX1NJR05fQUxHX1JTQTsKKworCQkJLyoKKwkJCSAqIFJGQyAzNDQ3LCBBLjIuNCBSU0FTU0EtUEtDUzEtdjFfNQorCQkJICoKKwkJCSAqIERpZ2VzdEluZm8gOjo9IFNFUVVFTkNFIHsKKwkJCSAqICAgZGlnZXN0QWxnb3JpdGhtIERpZ2VzdEFsZ29yaXRobSwKKwkJCSAqICAgZGlnZXN0IE9DVEVUIFNUUklORworCQkJICogfQorCQkJICoKKwkJCSAqIFNIQS0yNTYgT0lEOiBzaGEyNTZXaXRoUlNBRW5jcnlwdGlvbiA6Oj0ge3BrY3MtMSAxMX0KKwkJCSAqCisJCQkgKiBERVIgZW5jb2RlZCBEaWdlc3RJbmZvIGZvciBTSEEyNTYgcGVyIFJGQyAzNDQ3OgorCQkJICogMzAgMzEgMzAgMGQgMDYgMDkgNjAgODYgNDggMDEgNjUgMDMgMDQgMDIgMDEgMDUgMDAKKwkJCSAqIDA0IDIwIHx8IEgKKwkJCSAqLworCQkJaGxlbiArPSAxOTsKKwkJCW9zX21lbWNweShoYXNoLAorCQkJCSAgIlx4MzBceDMxXHgzMFx4MGRceDA2XHgwOVx4NjBceDg2XHg0OFx4MDFceDY1IgorCQkJCSAgIlx4MDNceDA0XHgwMlx4MDFceDA1XHgwMFx4MDRceDIwIiwgMTkpOworCisjZWxzZSAvKiBDT05GSUdfVExTVjEyICovCisJCQl0bHN2MV9zZXJ2ZXJfYWxlcnQoY29ubiwgVExTX0FMRVJUX0xFVkVMX0ZBVEFMLAorCQkJCQkgICBUTFNfQUxFUlRfSU5URVJOQUxfRVJST1IpOworCQkJcmV0dXJuIC0xOworI2VuZGlmIC8qIENPTkZJR19UTFNWMTIgKi8KKwkJfSBlbHNlIHsKKwkJCWhsZW4gPSB0bHNfa2V5X3hfc2VydmVyX3BhcmFtc19oYXNoKAorCQkJCWNvbm4tPnJsLnRsc192ZXJzaW9uLCBjb25uLT5jbGllbnRfcmFuZG9tLAorCQkJCWNvbm4tPnNlcnZlcl9yYW5kb20sIHNlcnZlcl9wYXJhbXMsCisJCQkJcG9zIC0gc2VydmVyX3BhcmFtcywgaGFzaCk7CisJCX0KKworCQlpZiAoaGxlbiA8IDApIHsKKwkJCXRsc3YxX3NlcnZlcl9hbGVydChjb25uLCBUTFNfQUxFUlRfTEVWRUxfRkFUQUwsCisJCQkJCSAgIFRMU19BTEVSVF9JTlRFUk5BTF9FUlJPUik7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlRMUzogU2VydmVyS2V5RXhjaGFuZ2Ugc2lnbmVkX3BhcmFtcyBoYXNoIiwKKwkJCSAgICBoYXNoLCBobGVuKTsKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJCWlmIChjb25uLT50ZXN0X2ZsYWdzICYgVExTX0JSRUFLX1NSVl9LRVlfWF9IQVNIKSB7CisJCQl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJURVNUSU5HOiBCcmVhayBTZXJ2ZXJLZXlFeGNoYW5nZSBzaWduZWQgcGFyYW1zIGhhc2giKTsKKwkJCWhhc2hbaGxlbiAtIDFdIF49IDB4ODA7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCisKKwkJLyoKKwkJICogUkZDIDIyNDYsIDQuNzoKKwkJICogSW4gZGlnaXRhbCBzaWduaW5nLCBvbmUtd2F5IGhhc2ggZnVuY3Rpb25zIGFyZSB1c2VkIGFzIGlucHV0CisJCSAqIGZvciBhIHNpZ25pbmcgYWxnb3JpdGhtLiBBIGRpZ2l0YWxseS1zaWduZWQgZWxlbWVudCBpcworCQkgKiBlbmNvZGVkIGFzIGFuIG9wYXF1ZSB2ZWN0b3IgPDAuLjJeMTYtMT4sIHdoZXJlIHRoZSBsZW5ndGggaXMKKwkJICogc3BlY2lmaWVkIGJ5IHRoZSBzaWduaW5nIGFsZ29yaXRobSBhbmQga2V5LgorCQkgKgorCQkgKiBJbiBSU0Egc2lnbmluZywgYSAzNi1ieXRlIHN0cnVjdHVyZSBvZiB0d28gaGFzaGVzIChvbmUgU0hBCisJCSAqIGFuZCBvbmUgTUQ1KSBpcyBzaWduZWQgKGVuY3J5cHRlZCB3aXRoIHRoZSBwcml2YXRlIGtleSkuIEl0CisJCSAqIGlzIGVuY29kZWQgd2l0aCBQS0NTICMxIGJsb2NrIHR5cGUgMCBvciB0eXBlIDEgYXMgZGVzY3JpYmVkCisJCSAqIGluIFtQS0NTMV0uCisJCSAqLworCQlzaWduZWRfc3RhcnQgPSBwb3M7IC8qIGxlbmd0aCB0byBiZSBmaWxsZWQgKi8KKwkJcG9zICs9IDI7CisJCWNsZW4gPSBlbmQgLSBwb3M7CisJCWlmIChjb25uLT5jcmVkID09IE5VTEwgfHwKKwkJICAgIGNyeXB0b19wcml2YXRlX2tleV9zaWduX3BrY3MxKGNvbm4tPmNyZWQtPmtleSwgaGFzaCwgaGxlbiwKKwkJCQkJCSAgcG9zLCAmY2xlbikgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBGYWlsZWQgdG8gc2lnbiBoYXNoIChQS0NTICMxKSIpOworCQkJdGxzdjFfc2VydmVyX2FsZXJ0KGNvbm4sIFRMU19BTEVSVF9MRVZFTF9GQVRBTCwKKwkJCQkJICAgVExTX0FMRVJUX0lOVEVSTkFMX0VSUk9SKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlXUEFfUFVUX0JFMTYoc2lnbmVkX3N0YXJ0LCBjbGVuKTsKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJCWlmIChjb25uLT50ZXN0X2ZsYWdzICYgVExTX0JSRUFLX1NSVl9LRVlfWF9TSUdOQVRVUkUpIHsKKwkJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlRFU1RJTkc6IEJyZWFrIFNlcnZlcktleUV4Y2hhbmdlIHNpZ25lZCBwYXJhbXMgc2lnbmF0dXJlIik7CisJCQlwb3NbY2xlbiAtIDFdIF49IDB4ODA7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCisKKwkJcG9zICs9IGNsZW47CisJfQorCiAJV1BBX1BVVF9CRTI0KGhzX2xlbmd0aCwgcG9zIC0gaHNfbGVuZ3RoIC0gMyk7CiAKIAlpZiAodGxzdjFfcmVjb3JkX3NlbmQoJmNvbm4tPnJsLCBUTFNfQ09OVEVOVF9UWVBFX0hBTkRTSEFLRSwKQEAgLTQ0NSw3ICs1NzgsNyBAQAogCiAJcG9zID0gKm1zZ3BvczsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFNlbmQgQ2VydGlmaWNhdGVSZXF1ZXN0Iik7CisJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiU2VuZCBDZXJ0aWZpY2F0ZVJlcXVlc3QiKTsKIAlyaGRyID0gcG9zOwogCXBvcyArPSBUTFNfUkVDT1JEX0hFQURFUl9MRU47CiAKQEAgLTUwNSw3ICs2MzgsNyBAQAogCXNpemVfdCBybGVuOwogCXU4IHBheWxvYWRbNF07CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRMU3YxOiBTZW5kIFNlcnZlckhlbGxvRG9uZSIpOworCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlNlbmQgU2VydmVySGVsbG9Eb25lIik7CiAKIAkvKiBvcGFxdWUgZnJhZ21lbnRbVExTUGxhaW50ZXh0Lmxlbmd0aF0gKi8KIApAQCAtNTQxLDcgKzY3NCw3IEBACiAJc2l6ZV90IHJsZW47CiAJdTggcGF5bG9hZFsxXTsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFNlbmQgQ2hhbmdlQ2lwaGVyU3BlYyIpOworCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlNlbmQgQ2hhbmdlQ2lwaGVyU3BlYyIpOwogCiAJcGF5bG9hZFswXSA9IFRMU19DSEFOR0VfQ0lQSEVSX1NQRUM7CiAKQEAgLTU3OCw3ICs3MTEsNyBAQAogCiAJcG9zID0gKm1zZ3BvczsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFNlbmQgRmluaXNoZWQiKTsKKwl0bHN2MV9zZXJ2ZXJfbG9nKGNvbm4sICJTZW5kIEZpbmlzaGVkIik7CiAKIAkvKiBFbmNyeXB0ZWQgSGFuZHNoYWtlIE1lc3NhZ2U6IEZpbmlzaGVkICovCiAKQEAgLTYzNSw2ICs3NjgsMTIgQEAKIAl9CiAJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIlRMU3YxOiB2ZXJpZnlfZGF0YSAoc2VydmVyKSIsCiAJCQl2ZXJpZnlfZGF0YSArIDEgKyAzLCBUTFNfVkVSSUZZX0RBVEFfTEVOKTsKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJaWYgKGNvbm4tPnRlc3RfZmxhZ3MgJiBUTFNfQlJFQUtfVkVSSUZZX0RBVEEpIHsKKwkJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiVEVTVElORzogQnJlYWsgdmVyaWZ5X2RhdGEgKHNlcnZlcikiKTsKKwkJdmVyaWZ5X2RhdGFbMSArIDMgKyAxXSBePSAweDgwOworCX0KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCiAKIAkvKiBIYW5kc2hha2UgKi8KIAlwb3MgPSBoc19zdGFydCA9IHZlcmlmeV9kYXRhOwpAQCAtNzM2LDcgKzg3NSw3IEBACiAKIAkqb3V0X2xlbiA9IHBvcyAtIG1zZzsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IEhhbmRzaGFrZSBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5Iik7CisJdGxzdjFfc2VydmVyX2xvZyhjb25uLCAiSGFuZHNoYWtlIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkiKTsKIAljb25uLT5zdGF0ZSA9IEVTVEFCTElTSEVEOwogCiAJcmV0dXJuIG1zZzsKQEAgLTc1NSw4ICs4OTQsOCBAQAogCQkJLyogQWJicmV2aWF0ZWQgaGFuZHNoYWtlIHdhcyBhbHJlYWR5IGNvbXBsZXRlZC4gKi8KIAkJCXJldHVybiBOVUxMOwogCQl9Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVExTdjE6IFVuZXhwZWN0ZWQgc3RhdGUgJWQgd2hpbGUgIgotCQkJICAgImdlbmVyYXRpbmcgcmVwbHkiLCBjb25uLT5zdGF0ZSk7CisJCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlVuZXhwZWN0ZWQgc3RhdGUgJWQgd2hpbGUgZ2VuZXJhdGluZyByZXBseSIsCisJCQkJIGNvbm4tPnN0YXRlKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogfQpAQCAtNzY3LDcgKzkwNiw3IEBACiB7CiAJdTggKmFsZXJ0LCAqcG9zLCAqbGVuZ3RoOwogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJUTFN2MTogU2VuZCBBbGVydCglZDolZCkiLCBsZXZlbCwgZGVzY3JpcHRpb24pOworCXRsc3YxX3NlcnZlcl9sb2coY29ubiwgIlNlbmQgQWxlcnQoJWQ6JWQpIiwgbGV2ZWwsIGRlc2NyaXB0aW9uKTsKIAkqb3V0X2xlbiA9IDA7CiAKIAlhbGVydCA9IG9zX21hbGxvYygxMCk7CmRpZmYgLS1naXQgYS9zcmMvdGxzL3g1MDl2My5jIGIvc3JjL3Rscy94NTA5djMuYwppbmRleCAwNjU0MGJmLi5lMWU0ZGY4IDEwMDY0NAotLS0gYS9zcmMvdGxzL3g1MDl2My5jCisrKyBiL3NyYy90bHMveDUwOXYzLmMKQEAgLTEzNDgsNyArMTM0OCw4IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiWDUwOTogaXNzdWVyVW5pcXVlSUQiKTsKIAkJLyogVE9ETzogcGFyc2UgVW5pcXVlSWRlbnRpZmllciA6Oj0gQklUIFNUUklORyAqLwogCi0JCWlmIChoZHIucGF5bG9hZCArIGhkci5sZW5ndGggPT0gZW5kKQorCQlwb3MgPSBoZHIucGF5bG9hZCArIGhkci5sZW5ndGg7CisJCWlmIChwb3MgPT0gZW5kKQogCQkJcmV0dXJuIDA7CiAKIAkJaWYgKGFzbjFfZ2V0X25leHQocG9zLCBlbmQgLSBwb3MsICZoZHIpIDwgMCB8fApAQCAtMTM2Niw3ICsxMzY3LDggQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJYNTA5OiBzdWJqZWN0VW5pcXVlSUQiKTsKIAkJLyogVE9ETzogcGFyc2UgVW5pcXVlSWRlbnRpZmllciA6Oj0gQklUIFNUUklORyAqLwogCi0JCWlmIChoZHIucGF5bG9hZCArIGhkci5sZW5ndGggPT0gZW5kKQorCQlwb3MgPSBoZHIucGF5bG9hZCArIGhkci5sZW5ndGg7CisJCWlmIChwb3MgPT0gZW5kKQogCQkJcmV0dXJuIDA7CiAKIAkJaWYgKGFzbjFfZ2V0X25leHQocG9zLCBlbmQgLSBwb3MsICZoZHIpIDwgMCB8fApAQCAtMTc3NCwxMyArMTc3NiwyMiBAQAogCX0KIAogCWlmIChoZHIubGVuZ3RoICE9IGhhc2hfbGVuIHx8Ci0JICAgIG9zX21lbWNtcChoZHIucGF5bG9hZCwgaGFzaCwgaGRyLmxlbmd0aCkgIT0gMCkgeworCSAgICBvc19tZW1jbXBfY29uc3QoaGRyLnBheWxvYWQsIGhhc2gsIGhkci5sZW5ndGgpICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlg1MDk6IENlcnRpZmljYXRlIERpZ2VzdCBkb2VzIG5vdCBtYXRjaCAiCiAJCQkgICAid2l0aCBjYWxjdWxhdGVkIHRic0NlcnRpZmljYXRlIGhhc2giKTsKIAkJb3NfZnJlZShkYXRhKTsKIAkJcmV0dXJuIC0xOwogCX0KIAorCWlmIChoZHIucGF5bG9hZCArIGhkci5sZW5ndGggPCBkYXRhICsgZGF0YV9sZW4pIHsKKwkJd3BhX2hleGR1bXAoTVNHX0lORk8sCisJCQkgICAgIlg1MDk6IEV4dHJhIGRhdGEgYWZ0ZXIgY2VydGlmaWNhdGUgc2lnbmF0dXJlIGhhc2giLAorCQkJICAgIGhkci5wYXlsb2FkICsgaGRyLmxlbmd0aCwKKwkJCSAgICBkYXRhICsgZGF0YV9sZW4gLSBoZHIucGF5bG9hZCAtIGhkci5sZW5ndGgpOworCQlvc19mcmVlKGRhdGEpOworCQlyZXR1cm4gLTE7CisJfQorCiAJb3NfZnJlZShkYXRhKTsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiWDUwOTogQ2VydGlmaWNhdGUgRGlnZXN0IG1hdGNoZXMgd2l0aCAiCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvTWFrZWZpbGUgYi9zcmMvdXRpbHMvTWFrZWZpbGUKaW5kZXggOTQwYjRkOC4uOGFhZDgxMyAxMDA2NDQKLS0tIGEvc3JjL3V0aWxzL01ha2VmaWxlCisrKyBiL3NyYy91dGlscy9NYWtlZmlsZQpAQCAtMSw3ICsxLDcgQEAKIGFsbDogbGlidXRpbHMuYQogCiBjbGVhbjoKLQlybSAtZiAqfiAqLm8gKi5kIGxpYnV0aWxzLmEKKwlybSAtZiAqfiAqLm8gKi5kICouZ2NubyAqLmdjZGEgKi5nY292IGxpYnV0aWxzLmEKIAogaW5zdGFsbDoKIAlAZWNobyBOb3RoaW5nIHRvIGJlIG1hZGUuCkBAIC0xMSw2ICsxMSw3IEBACiAKICNDRkxBR1MgKz0gLURXUEFfVFJBQ0UKIENGTEFHUyArPSAtRENPTkZJR19JUFY2CitDRkxBR1MgKz0gLURDT05GSUdfREVCVUdfRklMRQogCiBMSUJfT0JKUz0gXAogCWJhc2U2NC5vIFwKZGlmZiAtLWdpdCBhL3NyYy91dGlscy9icm93c2VyLWFuZHJvaWQuYyBiL3NyYy91dGlscy9icm93c2VyLWFuZHJvaWQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hMDY2MzkyCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3V0aWxzL2Jyb3dzZXItYW5kcm9pZC5jCkBAIC0wLDAgKzEsMTE3IEBACisvKgorICogSG90c3BvdCAyLjAgY2xpZW50IC0gV2ViIGJyb3dzZXIgdXNpbmcgQW5kcm9pZCBicm93c2VyCisgKiBDb3B5cmlnaHQgKGMpIDIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKKyNpbmNsdWRlICJ3cHMvaHR0cF9zZXJ2ZXIuaCIKKyNpbmNsdWRlICJicm93c2VyLmgiCisKKworc3RydWN0IGJyb3dzZXJfZGF0YSB7CisJaW50IHN1Y2Nlc3M7Cit9OworCisKK3N0YXRpYyB2b2lkIGJyb3dzZXJfdGltZW91dCh2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2N0eCkKK3sKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVGltZW91dCBvbiB3YWl0aW5nIGJyb3dzZXIgaW50ZXJhY3Rpb24gdG8gIgorCQkgICAiY29tcGxldGUiKTsKKwllbG9vcF90ZXJtaW5hdGUoKTsKK30KKworCitzdGF0aWMgdm9pZCBodHRwX3JlcSh2b2lkICpjdHgsIHN0cnVjdCBodHRwX3JlcXVlc3QgKnJlcSkKK3sKKwlzdHJ1Y3QgYnJvd3Nlcl9kYXRhICpkYXRhID0gY3R4OworCXN0cnVjdCB3cGFidWYgKnJlc3A7CisJY29uc3QgY2hhciAqdXJsOworCWludCBkb25lID0gMDsKKworCXVybCA9IGh0dHBfcmVxdWVzdF9nZXRfdXJpKHJlcSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkJyb3dzZXIgcmVzcG9uc2UgcmVjZWl2ZWQ6ICVzIiwgdXJsKTsKKworCWlmIChvc19zdHJjbXAodXJsLCAiLyIpID09IDApIHsKKwkJZGF0YS0+c3VjY2VzcyA9IDE7CisJCWRvbmUgPSAxOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcCh1cmwsICIvb3N1LyIsIDUpID09IDApIHsKKwkJZGF0YS0+c3VjY2VzcyA9IGF0b2kodXJsICsgNSk7CisJCWRvbmUgPSAxOworCX0KKworCXJlc3AgPSB3cGFidWZfYWxsb2MoMSk7CisJaWYgKHJlc3AgPT0gTlVMTCkgeworCQlodHRwX3JlcXVlc3RfZGVpbml0KHJlcSk7CisJCWlmIChkb25lKQorCQkJZWxvb3BfdGVybWluYXRlKCk7CisJCXJldHVybjsKKwl9CisKKwlpZiAoZG9uZSkgeworCQllbG9vcF9jYW5jZWxfdGltZW91dChicm93c2VyX3RpbWVvdXQsIE5VTEwsIE5VTEwpOworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDUwMDAwMCwgYnJvd3Nlcl90aW1lb3V0LCAmZGF0YSwgTlVMTCk7CisJfQorCisJaHR0cF9yZXF1ZXN0X3NlbmRfYW5kX2RlaW5pdChyZXEsIHJlc3ApOworfQorCisKK2ludCBoczIwX3dlYl9icm93c2VyKGNvbnN0IGNoYXIgKnVybCkKK3sKKwljaGFyIGNtZFsyMDAwXTsKKwlpbnQgcmV0OworCXN0cnVjdCBodHRwX3NlcnZlciAqaHR0cDsKKwlzdHJ1Y3QgaW5fYWRkciBhZGRyOworCXN0cnVjdCBicm93c2VyX2RhdGEgZGF0YTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJMYXVuY2hpbmcgQW5kcm9pZCBicm93c2VyIHRvICVzIiwgdXJsKTsKKworCW9zX21lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKKworCXJldCA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksCisJCQkgICJhbSBzdGFydCAtYSBhbmRyb2lkLmludGVudC5hY3Rpb24uVklFVyAtZCAnJXMnICIKKwkJCSAgIi1uIGNvbS5hbmRyb2lkLmJyb3dzZXIvLkJyb3dzZXJBY3Rpdml0eSIsIHVybCk7CisJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IHNpemVvZihjbWQpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiVG9vIGxvbmcgVVJMIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoZWxvb3BfaW5pdCgpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImVsb29wX2luaXQgZmFpbGVkIik7CisJCXJldHVybiAtMTsKKwl9CisJYWRkci5zX2FkZHIgPSBodG9ubCgoMTI3IDw8IDI0KSB8IDEpOworCWh0dHAgPSBodHRwX3NlcnZlcl9pbml0KCZhZGRyLCAxMjM0NSwgaHR0cF9yZXEsICZkYXRhKTsKKwlpZiAoaHR0cCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiaHR0cF9zZXJ2ZXJfaW5pdCBmYWlsZWQiKTsKKwkJZWxvb3BfZGVzdHJveSgpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKHN5c3RlbShjbWQpICE9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkZhaWxlZCB0byBsYXVuY2ggQW5kcm9pZCBicm93c2VyIik7CisJCWVsb29wX2NhbmNlbF90aW1lb3V0KGJyb3dzZXJfdGltZW91dCwgTlVMTCwgTlVMTCk7CisJCWh0dHBfc2VydmVyX2RlaW5pdChodHRwKTsKKwkJZWxvb3BfZGVzdHJveSgpOworCQlyZXR1cm4gLTE7CisJfQorCisJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgzMCwgMCwgYnJvd3Nlcl90aW1lb3V0LCAmZGF0YSwgTlVMTCk7CisJZWxvb3BfcnVuKCk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYnJvd3Nlcl90aW1lb3V0LCAmZGF0YSwgTlVMTCk7CisJaHR0cF9zZXJ2ZXJfZGVpbml0KGh0dHApOworCWVsb29wX2Rlc3Ryb3koKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJDbG9zaW5nIEFuZHJvaWQgYnJvd3NlciIpOworCWlmIChzeXN0ZW0oImlucHV0IGtleWV2ZW50IDMiKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gaW5qZWN0IGtleWV2ZW50Iik7CisJfQorCisJcmV0dXJuIGRhdGEuc3VjY2VzczsKK30KZGlmZiAtLWdpdCBhL3NyYy91dGlscy9icm93c2VyLXN5c3RlbS5jIGIvc3JjL3V0aWxzL2Jyb3dzZXItc3lzdGVtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjg4NGQzNAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy91dGlscy9icm93c2VyLXN5c3RlbS5jCkBAIC0wLDAgKzEsMTEyIEBACisvKgorICogSG90c3BvdCAyLjAgY2xpZW50IC0gV2ViIGJyb3dzZXIgdXNpbmcgc3lzdGVtIGJyb3dzZXIKKyAqIENvcHlyaWdodCAoYykgMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgImluY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgorI2luY2x1ZGUgIndwcy9odHRwX3NlcnZlci5oIgorI2luY2x1ZGUgImJyb3dzZXIuaCIKKworCitzdHJ1Y3QgYnJvd3Nlcl9kYXRhIHsKKwlpbnQgc3VjY2VzczsKK307CisKKworc3RhdGljIHZvaWQgYnJvd3Nlcl90aW1lb3V0KHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfY3R4KQoreworCXdwYV9wcmludGYoTVNHX0lORk8sICJUaW1lb3V0IG9uIHdhaXRpbmcgYnJvd3NlciBpbnRlcmFjdGlvbiB0byAiCisJCSAgICJjb21wbGV0ZSIpOworCWVsb29wX3Rlcm1pbmF0ZSgpOworfQorCisKK3N0YXRpYyB2b2lkIGh0dHBfcmVxKHZvaWQgKmN0eCwgc3RydWN0IGh0dHBfcmVxdWVzdCAqcmVxKQoreworCXN0cnVjdCBicm93c2VyX2RhdGEgKmRhdGEgPSBjdHg7CisJc3RydWN0IHdwYWJ1ZiAqcmVzcDsKKwljb25zdCBjaGFyICp1cmw7CisJaW50IGRvbmUgPSAwOworCisJdXJsID0gaHR0cF9yZXF1ZXN0X2dldF91cmkocmVxKTsKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQnJvd3NlciByZXNwb25zZSByZWNlaXZlZDogJXMiLCB1cmwpOworCisJaWYgKG9zX3N0cmNtcCh1cmwsICIvIikgPT0gMCkgeworCQlkYXRhLT5zdWNjZXNzID0gMTsKKwkJZG9uZSA9IDE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKHVybCwgIi9vc3UvIiwgNSkgPT0gMCkgeworCQlkYXRhLT5zdWNjZXNzID0gYXRvaSh1cmwgKyA1KTsKKwkJZG9uZSA9IDE7CisJfQorCisJcmVzcCA9IHdwYWJ1Zl9hbGxvYygxKTsKKwlpZiAocmVzcCA9PSBOVUxMKSB7CisJCWh0dHBfcmVxdWVzdF9kZWluaXQocmVxKTsKKwkJaWYgKGRvbmUpCisJCQllbG9vcF90ZXJtaW5hdGUoKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChkb25lKSB7CisJCWVsb29wX2NhbmNlbF90aW1lb3V0KGJyb3dzZXJfdGltZW91dCwgTlVMTCwgTlVMTCk7CisJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMCwgNTAwMDAwLCBicm93c2VyX3RpbWVvdXQsICZkYXRhLCBOVUxMKTsKKwl9CisKKwlodHRwX3JlcXVlc3Rfc2VuZF9hbmRfZGVpbml0KHJlcSwgcmVzcCk7Cit9CisKKworaW50IGhzMjBfd2ViX2Jyb3dzZXIoY29uc3QgY2hhciAqdXJsKQoreworCWNoYXIgY21kWzIwMDBdOworCWludCByZXQ7CisJc3RydWN0IGh0dHBfc2VydmVyICpodHRwOworCXN0cnVjdCBpbl9hZGRyIGFkZHI7CisJc3RydWN0IGJyb3dzZXJfZGF0YSBkYXRhOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkxhdW5jaGluZyBBbmRyb2lkIGJyb3dzZXIgdG8gJXMiLCB1cmwpOworCisJb3NfbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOworCisJcmV0ID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIngtd3d3LWJyb3dzZXIgJyVzJyAmIiwgdXJsKTsKKwlpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gc2l6ZW9mKGNtZCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJUb28gbG9uZyBVUkwiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChlbG9vcF9pbml0KCkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiZWxvb3BfaW5pdCBmYWlsZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKwlhZGRyLnNfYWRkciA9IGh0b25sKCgxMjcgPDwgMjQpIHwgMSk7CisJaHR0cCA9IGh0dHBfc2VydmVyX2luaXQoJmFkZHIsIDEyMzQ1LCBodHRwX3JlcSwgJmRhdGEpOworCWlmIChodHRwID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJodHRwX3NlcnZlcl9pbml0IGZhaWxlZCIpOworCQllbG9vcF9kZXN0cm95KCk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoc3lzdGVtKGNtZCkgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIGxhdW5jaCBicm93c2VyIik7CisJCWVsb29wX2NhbmNlbF90aW1lb3V0KGJyb3dzZXJfdGltZW91dCwgTlVMTCwgTlVMTCk7CisJCWh0dHBfc2VydmVyX2RlaW5pdChodHRwKTsKKwkJZWxvb3BfZGVzdHJveSgpOworCQlyZXR1cm4gLTE7CisJfQorCisJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgxMjAsIDAsIGJyb3dzZXJfdGltZW91dCwgJmRhdGEsIE5VTEwpOworCWVsb29wX3J1bigpOworCWVsb29wX2NhbmNlbF90aW1lb3V0KGJyb3dzZXJfdGltZW91dCwgJmRhdGEsIE5VTEwpOworCWh0dHBfc2VydmVyX2RlaW5pdChodHRwKTsKKwllbG9vcF9kZXN0cm95KCk7CisKKwkvKiBUT0RPOiBDbG9zZSBicm93c2VyICovCisKKwlyZXR1cm4gZGF0YS5zdWNjZXNzOworfQpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2Jyb3dzZXItd3BhZGVidWcuYyBiL3NyYy91dGlscy9icm93c2VyLXdwYWRlYnVnLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWViOGY2NQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy91dGlscy9icm93c2VyLXdwYWRlYnVnLmMKQEAgLTAsMCArMSwxMjMgQEAKKy8qCisgKiBIb3RzcG90IDIuMCBjbGllbnQgLSBXZWIgYnJvd3NlciB1c2luZyB3cGFkZWJ1ZyBvbiBBbmRyb2lkCisgKiBDb3B5cmlnaHQgKGMpIDIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKKyNpbmNsdWRlICJ3cHMvaHR0cF9zZXJ2ZXIuaCIKKyNpbmNsdWRlICJicm93c2VyLmgiCisKKworc3RydWN0IGJyb3dzZXJfZGF0YSB7CisJaW50IHN1Y2Nlc3M7Cit9OworCisKK3N0YXRpYyB2b2lkIGJyb3dzZXJfdGltZW91dCh2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2N0eCkKK3sKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiVGltZW91dCBvbiB3YWl0aW5nIGJyb3dzZXIgaW50ZXJhY3Rpb24gdG8gIgorCQkgICAiY29tcGxldGUiKTsKKwllbG9vcF90ZXJtaW5hdGUoKTsKK30KKworCitzdGF0aWMgdm9pZCBodHRwX3JlcSh2b2lkICpjdHgsIHN0cnVjdCBodHRwX3JlcXVlc3QgKnJlcSkKK3sKKwlzdHJ1Y3QgYnJvd3Nlcl9kYXRhICpkYXRhID0gY3R4OworCXN0cnVjdCB3cGFidWYgKnJlc3A7CisJY29uc3QgY2hhciAqdXJsOworCWludCBkb25lID0gMDsKKworCXVybCA9IGh0dHBfcmVxdWVzdF9nZXRfdXJpKHJlcSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkJyb3dzZXIgcmVzcG9uc2UgcmVjZWl2ZWQ6ICVzIiwgdXJsKTsKKworCWlmIChvc19zdHJjbXAodXJsLCAiLyIpID09IDApIHsKKwkJZGF0YS0+c3VjY2VzcyA9IDE7CisJCWRvbmUgPSAxOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcCh1cmwsICIvb3N1LyIsIDUpID09IDApIHsKKwkJZGF0YS0+c3VjY2VzcyA9IGF0b2kodXJsICsgNSk7CisJCWRvbmUgPSAxOworCX0KKworCXJlc3AgPSB3cGFidWZfYWxsb2MoMTAwKTsKKwlpZiAocmVzcCA9PSBOVUxMKSB7CisJCWh0dHBfcmVxdWVzdF9kZWluaXQocmVxKTsKKwkJaWYgKGRvbmUpCisJCQllbG9vcF90ZXJtaW5hdGUoKTsKKwkJcmV0dXJuOworCX0KKwl3cGFidWZfcHV0X3N0cihyZXNwLCAiVXNlciBpbnB1dCBjb21wbGV0ZWQiKTsKKworCWlmIChkb25lKSB7CisJCWVsb29wX2NhbmNlbF90aW1lb3V0KGJyb3dzZXJfdGltZW91dCwgTlVMTCwgTlVMTCk7CisJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMCwgNTAwMDAwLCBicm93c2VyX3RpbWVvdXQsICZkYXRhLCBOVUxMKTsKKwl9CisKKwlodHRwX3JlcXVlc3Rfc2VuZF9hbmRfZGVpbml0KHJlcSwgcmVzcCk7Cit9CisKKworaW50IGhzMjBfd2ViX2Jyb3dzZXIoY29uc3QgY2hhciAqdXJsKQoreworCWNoYXIgY21kWzIwMDBdOworCWludCByZXQ7CisJc3RydWN0IGh0dHBfc2VydmVyICpodHRwOworCXN0cnVjdCBpbl9hZGRyIGFkZHI7CisJc3RydWN0IGJyb3dzZXJfZGF0YSBkYXRhOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkxhdW5jaGluZyB3cGFkZWJ1ZyBicm93c2VyIHRvICVzIiwgdXJsKTsKKworCW9zX21lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKKworCXJldCA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksCisJCQkgICJhbSBzdGFydCAtYSBhbmRyb2lkLmFjdGlvbi5NQUlOICIKKwkJCSAgIi1jIGFuZHJvaWQuaW50ZW50LmNhdGVnb3J5LkxBVU5DSEVSICIKKwkJCSAgIi1uIHcxLmZpLndwYWRlYnVnLy5XcGFXZWJWaWV3QWN0aXZpdHkgIgorCQkJICAiLWUgdzEuZmkud3BhZGVidWcuVVJMICclcyciLCB1cmwpOworCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBzaXplb2YoY21kKSkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIlRvbyBsb25nIFVSTCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGVsb29wX2luaXQoKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJlbG9vcF9pbml0IGZhaWxlZCIpOworCQlyZXR1cm4gLTE7CisJfQorCWFkZHIuc19hZGRyID0gaHRvbmwoKDEyNyA8PCAyNCkgfCAxKTsKKwlodHRwID0gaHR0cF9zZXJ2ZXJfaW5pdCgmYWRkciwgMTIzNDUsIGh0dHBfcmVxLCAmZGF0YSk7CisJaWYgKGh0dHAgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImh0dHBfc2VydmVyX2luaXQgZmFpbGVkIik7CisJCWVsb29wX2Rlc3Ryb3koKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChzeXN0ZW0oY21kKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gbGF1bmNoIHdwYWRlYnVnIGJyb3dzZXIiKTsKKwkJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYnJvd3Nlcl90aW1lb3V0LCBOVUxMLCBOVUxMKTsKKwkJaHR0cF9zZXJ2ZXJfZGVpbml0KGh0dHApOworCQllbG9vcF9kZXN0cm95KCk7CisJCXJldHVybiAtMTsKKwl9CisKKwllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDMwMCwgMCwgYnJvd3Nlcl90aW1lb3V0LCAmZGF0YSwgTlVMTCk7CisJZWxvb3BfcnVuKCk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYnJvd3Nlcl90aW1lb3V0LCAmZGF0YSwgTlVMTCk7CisJaHR0cF9zZXJ2ZXJfZGVpbml0KGh0dHApOworCWVsb29wX2Rlc3Ryb3koKTsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJDbG9zaW5nIEFuZHJvaWQgYnJvd3NlciIpOworCWlmIChzeXN0ZW0oImFtIHN0YXJ0IC1hIGFuZHJvaWQuYWN0aW9uLk1BSU4gIgorCQkgICAiLWMgYW5kcm9pZC5pbnRlbnQuY2F0ZWdvcnkuTEFVTkNIRVIgIgorCQkgICAiLW4gdzEuZmkud3BhZGVidWcvLldwYVdlYlZpZXdBY3Rpdml0eSAiCisJCSAgICItZSB3MS5maS53cGFkZWJ1Zy5VUkwgRklOSVNIIikgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIGNsb3NlIHdwYWRlYnVnIGJyb3dzZXIiKTsKKwl9CisKKwlyZXR1cm4gZGF0YS5zdWNjZXNzOworfQpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2Jyb3dzZXIuYyBiL3NyYy91dGlscy9icm93c2VyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWNmNjE1MgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy91dGlscy9icm93c2VyLmMKQEAgLTAsMCArMSwyMTkgQEAKKy8qCisgKiBIb3RzcG90IDIuMCBjbGllbnQgLSBXZWIgYnJvd3NlciB1c2luZyBXZWJLaXQKKyAqIENvcHlyaWdodCAoYykgMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgImluY2x1ZGVzLmgiCisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdC5oPgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAiYnJvd3Nlci5oIgorCisKK3N0cnVjdCBicm93c2VyX2NvbnRleHQgeworCUd0a1dpZGdldCAqd2luOworCWludCBzdWNjZXNzOworCWludCBwcm9ncmVzczsKKwljaGFyICpob3Zlcl9saW5rOworCWNoYXIgKnRpdGxlOworfTsKKworc3RhdGljIHZvaWQgd2luX2NiX2Rlc3Ryb3koR3RrV2lkZ2V0ICp3aW4sIHN0cnVjdCBicm93c2VyX2NvbnRleHQgKmN0eCkKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkJST1dTRVI6JXMiLCBfX2Z1bmNfXyk7CisJZ3RrX21haW5fcXVpdCgpOworfQorCisKK3N0YXRpYyB2b2lkIGJyb3dzZXJfdXBkYXRlX3RpdGxlKHN0cnVjdCBicm93c2VyX2NvbnRleHQgKmN0eCkKK3sKKwljaGFyIGJ1ZlsxMDBdOworCisJaWYgKGN0eC0+aG92ZXJfbGluaykgeworCQlndGtfd2luZG93X3NldF90aXRsZShHVEtfV0lORE9XKGN0eC0+d2luKSwgY3R4LT5ob3Zlcl9saW5rKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChjdHgtPnByb2dyZXNzID09IDEwMCkgeworCQlndGtfd2luZG93X3NldF90aXRsZShHVEtfV0lORE9XKGN0eC0+d2luKSwKKwkJCQkgICAgIGN0eC0+dGl0bGUgPyBjdHgtPnRpdGxlIDoKKwkJCQkgICAgICJIb3RzcG90IDIuMCBjbGllbnQiKTsKKwkJcmV0dXJuOworCX0KKworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJbJWQlJV0gJXMiLCBjdHgtPnByb2dyZXNzLAorCQkgY3R4LT50aXRsZSA/IGN0eC0+dGl0bGUgOiAiSG90c3BvdCAyLjAgY2xpZW50Iik7CisJZ3RrX3dpbmRvd19zZXRfdGl0bGUoR1RLX1dJTkRPVyhjdHgtPndpbiksIGJ1Zik7Cit9CisKKworc3RhdGljIHZvaWQgdmlld19jYl9ub3RpZnlfcHJvZ3Jlc3MoV2ViS2l0V2ViVmlldyAqdmlldywgR1BhcmFtU3BlYyAqcHNwZWMsCisJCQkJICAgIHN0cnVjdCBicm93c2VyX2NvbnRleHQgKmN0eCkKK3sKKwljdHgtPnByb2dyZXNzID0gMTAwICogd2Via2l0X3dlYl92aWV3X2dldF9wcm9ncmVzcyh2aWV3KTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkJST1dTRVI6JXMgcHJvZ3Jlc3M9JWQiLCBfX2Z1bmNfXywKKwkJICAgY3R4LT5wcm9ncmVzcyk7CisJYnJvd3Nlcl91cGRhdGVfdGl0bGUoY3R4KTsKK30KKworCitzdGF0aWMgdm9pZCB2aWV3X2NiX25vdGlmeV9sb2FkX3N0YXR1cyhXZWJLaXRXZWJWaWV3ICp2aWV3LCBHUGFyYW1TcGVjICpwc3BlYywKKwkJCQkgICAgICAgc3RydWN0IGJyb3dzZXJfY29udGV4dCAqY3R4KQoreworCWludCBzdGF0dXMgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2xvYWRfc3RhdHVzKHZpZXcpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQlJPV1NFUjolcyBsb2FkLXN0YXR1cz0lZCB1cmk9JXMiLAorCQkgICBfX2Z1bmNfXywgc3RhdHVzLCB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3VyaSh2aWV3KSk7Cit9CisKKworc3RhdGljIHZvaWQgdmlld19jYl9yZXNvdXJjZV9yZXF1ZXN0X3N0YXJ0aW5nKFdlYktpdFdlYlZpZXcgKnZpZXcsCisJCQkJCSAgICAgIFdlYktpdFdlYkZyYW1lICpmcmFtZSwKKwkJCQkJICAgICAgV2ViS2l0V2ViUmVzb3VyY2UgKnJlcywKKwkJCQkJICAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QgKnJlcSwKKwkJCQkJICAgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlICpyZXNwLAorCQkJCQkgICAgICBzdHJ1Y3QgYnJvd3Nlcl9jb250ZXh0ICpjdHgpCit7CisJY29uc3QgZ2NoYXIgKnVyaSA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShyZXEpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQlJPV1NFUjolcyB1cmk9JXMiLCBfX2Z1bmNfXywgdXJpKTsKKwlpZiAoZ19zdHJfaGFzX3N1ZmZpeCh1cmksICIvZmF2aWNvbi5pY28iKSkKKwkJd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKHJlcSwgImFib3V0OmJsYW5rIik7CisJaWYgKGdfc3RyX2hhc19wcmVmaXgodXJpLCAib3N1Oi8vIikpIHsKKwkJY3R4LT5zdWNjZXNzID0gYXRvaSh1cmkgKyA2KTsKKwkJZ3RrX21haW5fcXVpdCgpOworCX0KKwlpZiAoZ19zdHJfaGFzX3ByZWZpeCh1cmksICJodHRwOi8vbG9jYWxob3N0OjEyMzQ1IikpIHsKKwkJLyoKKwkJICogVGhpcyBpcyB1c2VkIGFzIGEgc3BlY2lhbCB0cmlnZ2VyIHRvIGluZGljYXRlIHRoYXQgdGhlCisJCSAqIHVzZXIgZXhjaGFuZ2UgaGFzIGJlZW4gY29tcGxldGVkLgorCQkgKi8KKwkJY3R4LT5zdWNjZXNzID0gMTsKKwkJZ3RrX21haW5fcXVpdCgpOworCX0KK30KKworCitzdGF0aWMgZ2Jvb2xlYW4gdmlld19jYl9taW1lX3R5cGVfcG9saWN5X2RlY2lzaW9uKAorCVdlYktpdFdlYlZpZXcgKnZpZXcsIFdlYktpdFdlYkZyYW1lICpmcmFtZSwgV2ViS2l0TmV0d29ya1JlcXVlc3QgKnJlcSwKKwlnY2hhciAqbWltZSwgV2ViS2l0V2ViUG9saWN5RGVjaXNpb24gKnBvbGljeSwKKwlzdHJ1Y3QgYnJvd3Nlcl9jb250ZXh0ICpjdHgpCit7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJCUk9XU0VSOiVzIG1pbWU9JXMiLCBfX2Z1bmNfXywgbWltZSk7CisKKwlpZiAoIXdlYmtpdF93ZWJfdmlld19jYW5fc2hvd19taW1lX3R5cGUodmlldywgbWltZSkpIHsKKwkJd2Via2l0X3dlYl9wb2xpY3lfZGVjaXNpb25fZG93bmxvYWQocG9saWN5KTsKKwkJcmV0dXJuIFRSVUU7CisJfQorCisJcmV0dXJuIEZBTFNFOworfQorCisKK3N0YXRpYyBnYm9vbGVhbiB2aWV3X2NiX2Rvd25sb2FkX3JlcXVlc3RlZChXZWJLaXRXZWJWaWV3ICp2aWV3LAorCQkJCQkgICBXZWJLaXREb3dubG9hZCAqZGwsCisJCQkJCSAgIHN0cnVjdCBicm93c2VyX2NvbnRleHQgKmN0eCkKK3sKKwljb25zdCBnY2hhciAqdXJpOworCXVyaSA9IHdlYmtpdF9kb3dubG9hZF9nZXRfdXJpKGRsKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkJST1dTRVI6JXMgdXJpPSVzIiwgX19mdW5jX18sIHVyaSk7CisJcmV0dXJuIEZBTFNFOworfQorCisKK3N0YXRpYyB2b2lkIHZpZXdfY2JfaG92ZXJpbmdfb3Zlcl9saW5rKFdlYktpdFdlYlZpZXcgKnZpZXcsIGdjaGFyICp0aXRsZSwKKwkJCQkgICAgICAgZ2NoYXIgKnVyaSwgc3RydWN0IGJyb3dzZXJfY29udGV4dCAqY3R4KQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQlJPV1NFUjolcyB0aXRsZT0lcyB1cmk9JXMiLCBfX2Z1bmNfXywgdGl0bGUsCisJCSAgIHVyaSk7CisJb3NfZnJlZShjdHgtPmhvdmVyX2xpbmspOworCWlmICh1cmkpCisJCWN0eC0+aG92ZXJfbGluayA9IG9zX3N0cmR1cCh1cmkpOworCWVsc2UKKwkJY3R4LT5ob3Zlcl9saW5rID0gTlVMTDsKKworCWJyb3dzZXJfdXBkYXRlX3RpdGxlKGN0eCk7Cit9CisKKworc3RhdGljIHZvaWQgdmlld19jYl90aXRsZV9jaGFuZ2VkKFdlYktpdFdlYlZpZXcgKnZpZXcsIFdlYktpdFdlYkZyYW1lICpmcmFtZSwKKwkJCQkgIGNvbnN0IGNoYXIgKnRpdGxlLAorCQkJCSAgc3RydWN0IGJyb3dzZXJfY29udGV4dCAqY3R4KQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQlJPV1NFUjolcyB0aXRsZT0lcyIsIF9fZnVuY19fLCB0aXRsZSk7CisJb3NfZnJlZShjdHgtPnRpdGxlKTsKKwljdHgtPnRpdGxlID0gb3Nfc3RyZHVwKHRpdGxlKTsKKwlicm93c2VyX3VwZGF0ZV90aXRsZShjdHgpOworfQorCisKK2ludCBoczIwX3dlYl9icm93c2VyKGNvbnN0IGNoYXIgKnVybCkKK3sKKwlHdGtXaWRnZXQgKnNjcm9sbDsKKwlTb3VwU2Vzc2lvbiAqczsKKwlXZWJLaXRXZWJWaWV3ICp2aWV3OworCVdlYktpdFdlYlNldHRpbmdzICpzZXR0aW5nczsKKwlzdHJ1Y3QgYnJvd3Nlcl9jb250ZXh0IGN0eDsKKworCW1lbXNldCgmY3R4LCAwLCBzaXplb2YoY3R4KSk7CisJaWYgKCFndGtfaW5pdF9jaGVjayhOVUxMLCBOVUxMKSkKKwkJcmV0dXJuIC0xOworCisJcyA9IHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uKCk7CisJZ19vYmplY3Rfc2V0KEdfT0JKRUNUKHMpLCAic3NsLWNhLWZpbGUiLAorCQkgICAgICIvZXRjL3NzbC9jZXJ0cy9jYS1jZXJ0aWZpY2F0ZXMuY3J0IiwgTlVMTCk7CisJZ19vYmplY3Rfc2V0KEdfT0JKRUNUKHMpLCAic3NsLXN0cmljdCIsIEZBTFNFLCBOVUxMKTsKKworCWN0eC53aW4gPSBndGtfd2luZG93X25ldyhHVEtfV0lORE9XX1RPUExFVkVMKTsKKwlndGtfd2luZG93X3NldF93bWNsYXNzKEdUS19XSU5ET1coY3R4LndpbiksICJIb3RzcG90IDIuMCBjbGllbnQiLAorCQkJICAgICAgICJIb3RzcG90IDIuMCBjbGllbnQiKTsKKwlndGtfd2luZG93X3NldF9kZWZhdWx0X3NpemUoR1RLX1dJTkRPVyhjdHgud2luKSwgODAwLCA2MDApOworCisJc2Nyb2xsID0gZ3RrX3Njcm9sbGVkX3dpbmRvd19uZXcoTlVMTCwgTlVMTCk7CisJZ3RrX3Njcm9sbGVkX3dpbmRvd19zZXRfcG9saWN5KEdUS19TQ1JPTExFRF9XSU5ET1coc2Nyb2xsKSwKKwkJCQkgICAgICAgR1RLX1BPTElDWV9ORVZFUiwgR1RLX1BPTElDWV9ORVZFUik7CisKKwlnX3NpZ25hbF9jb25uZWN0KEdfT0JKRUNUKGN0eC53aW4pLCAiZGVzdHJveSIsCisJCQkgR19DQUxMQkFDSyh3aW5fY2JfZGVzdHJveSksICZjdHgpOworCisJdmlldyA9IFdFQktJVF9XRUJfVklFVyh3ZWJraXRfd2ViX3ZpZXdfbmV3KCkpOworCWdfc2lnbmFsX2Nvbm5lY3QoR19PQkpFQ1QodmlldyksICJub3RpZnk6OnByb2dyZXNzIiwKKwkJCSBHX0NBTExCQUNLKHZpZXdfY2Jfbm90aWZ5X3Byb2dyZXNzKSwgJmN0eCk7CisJZ19zaWduYWxfY29ubmVjdChHX09CSkVDVCh2aWV3KSwgIm5vdGlmeTo6bG9hZC1zdGF0dXMiLAorCQkJIEdfQ0FMTEJBQ0sodmlld19jYl9ub3RpZnlfbG9hZF9zdGF0dXMpLCAmY3R4KTsKKwlnX3NpZ25hbF9jb25uZWN0KEdfT0JKRUNUKHZpZXcpLCAicmVzb3VyY2UtcmVxdWVzdC1zdGFydGluZyIsCisJCQkgR19DQUxMQkFDSyh2aWV3X2NiX3Jlc291cmNlX3JlcXVlc3Rfc3RhcnRpbmcpLCAmY3R4KTsKKwlnX3NpZ25hbF9jb25uZWN0KEdfT0JKRUNUKHZpZXcpLCAibWltZS10eXBlLXBvbGljeS1kZWNpc2lvbi1yZXF1ZXN0ZWQiLAorCQkJIEdfQ0FMTEJBQ0sodmlld19jYl9taW1lX3R5cGVfcG9saWN5X2RlY2lzaW9uKSwgJmN0eCk7CisJZ19zaWduYWxfY29ubmVjdChHX09CSkVDVCh2aWV3KSwgImRvd25sb2FkLXJlcXVlc3RlZCIsCisJCQkgR19DQUxMQkFDSyh2aWV3X2NiX2Rvd25sb2FkX3JlcXVlc3RlZCksICZjdHgpOworCWdfc2lnbmFsX2Nvbm5lY3QoR19PQkpFQ1QodmlldyksICJob3ZlcmluZy1vdmVyLWxpbmsiLAorCQkJIEdfQ0FMTEJBQ0sodmlld19jYl9ob3ZlcmluZ19vdmVyX2xpbmspLCAmY3R4KTsKKwlnX3NpZ25hbF9jb25uZWN0KEdfT0JKRUNUKHZpZXcpLCAidGl0bGUtY2hhbmdlZCIsCisJCQkgR19DQUxMQkFDSyh2aWV3X2NiX3RpdGxlX2NoYW5nZWQpLCAmY3R4KTsKKworCWd0a19jb250YWluZXJfYWRkKEdUS19DT05UQUlORVIoc2Nyb2xsKSwgR1RLX1dJREdFVCh2aWV3KSk7CisJZ3RrX2NvbnRhaW5lcl9hZGQoR1RLX0NPTlRBSU5FUihjdHgud2luKSwgR1RLX1dJREdFVChzY3JvbGwpKTsKKworCWd0a193aWRnZXRfZ3JhYl9mb2N1cyhHVEtfV0lER0VUKHZpZXcpKTsKKwlndGtfd2lkZ2V0X3Nob3dfYWxsKGN0eC53aW4pOworCisJc2V0dGluZ3MgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3NldHRpbmdzKHZpZXcpOworCWdfb2JqZWN0X3NldChHX09CSkVDVChzZXR0aW5ncyksICJ1c2VyLWFnZW50IiwKKwkJICAgICAiTW96aWxsYS81LjAgKFgxMTsgVTsgVW5peDsgZW4tVVMpICIKKwkJICAgICAiQXBwbGVXZWJLaXQvNTM3LjE1IChLSFRNTCwgbGlrZSBHZWNrbykgIgorCQkgICAgICJoczIwLWNsaWVudC8xLjAiLCBOVUxMKTsKKwlnX29iamVjdF9zZXQoR19PQkpFQ1Qoc2V0dGluZ3MpLCAiYXV0by1sb2FkLWltYWdlcyIsIFRSVUUsIE5VTEwpOworCisJd2Via2l0X3dlYl92aWV3X2xvYWRfdXJpKHZpZXcsIHVybCk7CisKKwlndGtfbWFpbigpOworCWd0a193aWRnZXRfZGVzdHJveShjdHgud2luKTsKKwl3aGlsZSAoZ3RrX2V2ZW50c19wZW5kaW5nKCkpCisJCWd0a19tYWluX2l0ZXJhdGlvbigpOworCisJZnJlZShjdHguaG92ZXJfbGluayk7CisJZnJlZShjdHgudGl0bGUpOworCXJldHVybiBjdHguc3VjY2VzczsKK30KZGlmZiAtLWdpdCBhL3NyYy91dGlscy9icm93c2VyLmggYi9zcmMvdXRpbHMvYnJvd3Nlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFhYTBlZWQKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdXRpbHMvYnJvd3Nlci5oCkBAIC0wLDAgKzEsMjEgQEAKKy8qCisgKiBIb3RzcG90IDIuMCBjbGllbnQgLSBXZWIgYnJvd3NlcgorICogQ29weXJpZ2h0IChjKSAyMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIEJST1dTRVJfSAorI2RlZmluZSBCUk9XU0VSX0gKKworI2lmZGVmIENPTkZJR19OT19CUk9XU0VSCitzdGF0aWMgaW5saW5lIGludCBoczIwX3dlYl9icm93c2VyKGNvbnN0IGNoYXIgKnVybCkKK3sKKwlyZXR1cm4gLTE7Cit9CisjZWxzZSAvKiBDT05GSUdfTk9fQlJPV1NFUiAqLworaW50IGhzMjBfd2ViX2Jyb3dzZXIoY29uc3QgY2hhciAqdXJsKTsKKyNlbmRpZiAvKiBDT05GSUdfTk9fQlJPV1NFUiAqLworCisjZW5kaWYgLyogQlJPV1NFUl9IICovCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvY29tbW9uLmMgYi9zcmMvdXRpbHMvY29tbW9uLmMKaW5kZXggYmYzMjZjZC4uNWIwMTdlNSAxMDA2NDQKLS0tIGEvc3JjL3V0aWxzL2NvbW1vbi5jCisrKyBiL3NyYy91dGlscy9jb21tb24uYwpAQCAtMzUwLDcgKzM1MCw3IEBACiAJc2l6ZV90IGk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKLQkJaWYgKHR4dCArIDQgPiBlbmQpCisJCWlmICh0eHQgKyA0ID49IGVuZCkKIAkJCWJyZWFrOwogCiAJCXN3aXRjaCAoZGF0YVtpXSkgewpAQCAtNDAwLDcgKzQwMCw3IEBACiAJaW50IHZhbDsKIAogCXdoaWxlICgqcG9zKSB7Ci0JCWlmIChsZW4gPT0gbWF4bGVuKQorCQlpZiAobGVuICsgMSA+PSBtYXhsZW4pCiAJCQlicmVhazsKIAkJc3dpdGNoICgqcG9zKSB7CiAJCWNhc2UgJ1xcJzoKQEAgLTQ2OCw2ICs0NjgsOCBAQAogCQkJYnJlYWs7CiAJCX0KIAl9CisJaWYgKG1heGxlbiA+IGxlbikKKwkJYnVmW2xlbl0gPSAnXDAnOwogCiAJcmV0dXJuIGxlbjsKIH0KQEAgLTU3Niw2ICs1NzgsMjEgQEAKIH0KIAogCitpbnQgZmluZF9maXJzdF9iaXQodTMyIHZhbHVlKQoreworCWludCBwb3MgPSAwOworCisJd2hpbGUgKHZhbHVlKSB7CisJCWlmICh2YWx1ZSAmIDB4MSkKKwkJCXJldHVybiBwb3M7CisJCXZhbHVlID4+PSAxOworCQlwb3MrKzsKKwl9CisKKwlyZXR1cm4gLTE7Cit9CisKKwogc2l6ZV90IG1lcmdlX2J5dGVfYXJyYXlzKHU4ICpyZXMsIHNpemVfdCByZXNfbGVuLAogCQkJIGNvbnN0IHU4ICpzcmMxLCBzaXplX3Qgc3JjMV9sZW4sCiAJCQkgY29uc3QgdTggKnNyYzIsIHNpemVfdCBzcmMyX2xlbikKQEAgLTYyMiwzICs2MzksMjEwIEBACiAKIAlyZXR1cm4gcmVzOwogfQorCisKK2ludCBmcmVxX3JhbmdlX2xpc3RfcGFyc2Uoc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3QgKnJlcywgY29uc3QgY2hhciAqdmFsdWUpCit7CisJc3RydWN0IHdwYV9mcmVxX3JhbmdlICpmcmVxID0gTlVMTCwgKm47CisJdW5zaWduZWQgaW50IGNvdW50ID0gMDsKKwljb25zdCBjaGFyICpwb3MsICpwb3MyLCAqcG9zMzsKKworCS8qCisJICogQ29tbWEgc2VwYXJhdGVkIGxpc3Qgb2YgZnJlcXVlbmN5IHJhbmdlcy4KKwkgKiBGb3IgZXhhbXBsZTogMjQxMi0yNDMyLDI0NjIsNTAwMC02MDAwCisJICovCisJcG9zID0gdmFsdWU7CisJd2hpbGUgKHBvcyAmJiBwb3NbMF0pIHsKKwkJbiA9IG9zX3JlYWxsb2NfYXJyYXkoZnJlcSwgY291bnQgKyAxLAorCQkJCSAgICAgc2l6ZW9mKHN0cnVjdCB3cGFfZnJlcV9yYW5nZSkpOworCQlpZiAobiA9PSBOVUxMKSB7CisJCQlvc19mcmVlKGZyZXEpOworCQkJcmV0dXJuIC0xOworCQl9CisJCWZyZXEgPSBuOworCQlmcmVxW2NvdW50XS5taW4gPSBhdG9pKHBvcyk7CisJCXBvczIgPSBvc19zdHJjaHIocG9zLCAnLScpOworCQlwb3MzID0gb3Nfc3RyY2hyKHBvcywgJywnKTsKKwkJaWYgKHBvczIgJiYgKCFwb3MzIHx8IHBvczIgPCBwb3MzKSkgeworCQkJcG9zMisrOworCQkJZnJlcVtjb3VudF0ubWF4ID0gYXRvaShwb3MyKTsKKwkJfSBlbHNlCisJCQlmcmVxW2NvdW50XS5tYXggPSBmcmVxW2NvdW50XS5taW47CisJCXBvcyA9IHBvczM7CisJCWlmIChwb3MpCisJCQlwb3MrKzsKKwkJY291bnQrKzsKKwl9CisKKwlvc19mcmVlKHJlcy0+cmFuZ2UpOworCXJlcy0+cmFuZ2UgPSBmcmVxOworCXJlcy0+bnVtID0gY291bnQ7CisKKwlyZXR1cm4gMDsKK30KKworCitpbnQgZnJlcV9yYW5nZV9saXN0X2luY2x1ZGVzKGNvbnN0IHN0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0ICpsaXN0LAorCQkJICAgICB1bnNpZ25lZCBpbnQgZnJlcSkKK3sKKwl1bnNpZ25lZCBpbnQgaTsKKworCWlmIChsaXN0ID09IE5VTEwpCisJCXJldHVybiAwOworCisJZm9yIChpID0gMDsgaSA8IGxpc3QtPm51bTsgaSsrKSB7CisJCWlmIChmcmVxID49IGxpc3QtPnJhbmdlW2ldLm1pbiAmJiBmcmVxIDw9IGxpc3QtPnJhbmdlW2ldLm1heCkKKwkJCXJldHVybiAxOworCX0KKworCXJldHVybiAwOworfQorCisKK2NoYXIgKiBmcmVxX3JhbmdlX2xpc3Rfc3RyKGNvbnN0IHN0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0ICpsaXN0KQoreworCWNoYXIgKmJ1ZiwgKnBvcywgKmVuZDsKKwlzaXplX3QgbWF4bGVuOworCXVuc2lnbmVkIGludCBpOworCWludCByZXM7CisKKwlpZiAobGlzdC0+bnVtID09IDApCisJCXJldHVybiBOVUxMOworCisJbWF4bGVuID0gbGlzdC0+bnVtICogMzA7CisJYnVmID0gb3NfbWFsbG9jKG1heGxlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlwb3MgPSBidWY7CisJZW5kID0gYnVmICsgbWF4bGVuOworCisJZm9yIChpID0gMDsgaSA8IGxpc3QtPm51bTsgaSsrKSB7CisJCXN0cnVjdCB3cGFfZnJlcV9yYW5nZSAqcmFuZ2UgPSAmbGlzdC0+cmFuZ2VbaV07CisKKwkJaWYgKHJhbmdlLT5taW4gPT0gcmFuZ2UtPm1heCkKKwkJCXJlcyA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXMldSIsCisJCQkJCSAgaSA9PSAwID8gIiIgOiAiLCIsIHJhbmdlLT5taW4pOworCQllbHNlCisJCQlyZXMgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzJXUtJXUiLAorCQkJCQkgIGkgPT0gMCA/ICIiIDogIiwiLAorCQkJCQkgIHJhbmdlLT5taW4sIHJhbmdlLT5tYXgpOworCQlpZiAocmVzIDwgMCB8fCByZXMgPiBlbmQgLSBwb3MpIHsKKwkJCW9zX2ZyZWUoYnVmKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJCXBvcyArPSByZXM7CisJfQorCisJcmV0dXJuIGJ1ZjsKK30KKworCitpbnQgaW50X2FycmF5X2xlbihjb25zdCBpbnQgKmEpCit7CisJaW50IGk7CisJZm9yIChpID0gMDsgYSAmJiBhW2ldOyBpKyspCisJCTsKKwlyZXR1cm4gaTsKK30KKworCit2b2lkIGludF9hcnJheV9jb25jYXQoaW50ICoqcmVzLCBjb25zdCBpbnQgKmEpCit7CisJaW50IHJlc2xlbiwgYWxlbiwgaTsKKwlpbnQgKm47CisKKwlyZXNsZW4gPSBpbnRfYXJyYXlfbGVuKCpyZXMpOworCWFsZW4gPSBpbnRfYXJyYXlfbGVuKGEpOworCisJbiA9IG9zX3JlYWxsb2NfYXJyYXkoKnJlcywgcmVzbGVuICsgYWxlbiArIDEsIHNpemVvZihpbnQpKTsKKwlpZiAobiA9PSBOVUxMKSB7CisJCW9zX2ZyZWUoKnJlcyk7CisJCSpyZXMgPSBOVUxMOworCQlyZXR1cm47CisJfQorCWZvciAoaSA9IDA7IGkgPD0gYWxlbjsgaSsrKQorCQluW3Jlc2xlbiArIGldID0gYVtpXTsKKwkqcmVzID0gbjsKK30KKworCitzdGF0aWMgaW50IGZyZXFfY21wKGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIpCit7CisJaW50IF9hID0gKihpbnQgKikgYTsKKwlpbnQgX2IgPSAqKGludCAqKSBiOworCisJaWYgKF9hID09IDApCisJCXJldHVybiAxOworCWlmIChfYiA9PSAwKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIF9hIC0gX2I7Cit9CisKKwordm9pZCBpbnRfYXJyYXlfc29ydF91bmlxdWUoaW50ICphKQoreworCWludCBhbGVuOworCWludCBpLCBqOworCisJaWYgKGEgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJYWxlbiA9IGludF9hcnJheV9sZW4oYSk7CisJcXNvcnQoYSwgYWxlbiwgc2l6ZW9mKGludCksIGZyZXFfY21wKTsKKworCWkgPSAwOworCWogPSAxOworCXdoaWxlIChhW2ldICYmIGFbal0pIHsKKwkJaWYgKGFbaV0gPT0gYVtqXSkgeworCQkJaisrOworCQkJY29udGludWU7CisJCX0KKwkJYVsrK2ldID0gYVtqKytdOworCX0KKwlpZiAoYVtpXSkKKwkJaSsrOworCWFbaV0gPSAwOworfQorCisKK3ZvaWQgaW50X2FycmF5X2FkZF91bmlxdWUoaW50ICoqcmVzLCBpbnQgYSkKK3sKKwlpbnQgcmVzbGVuOworCWludCAqbjsKKworCWZvciAocmVzbGVuID0gMDsgKnJlcyAmJiAoKnJlcylbcmVzbGVuXTsgcmVzbGVuKyspIHsKKwkJaWYgKCgqcmVzKVtyZXNsZW5dID09IGEpCisJCQlyZXR1cm47IC8qIGFscmVhZHkgaW4gdGhlIGxpc3QgKi8KKwl9CisKKwluID0gb3NfcmVhbGxvY19hcnJheSgqcmVzLCByZXNsZW4gKyAyLCBzaXplb2YoaW50KSk7CisJaWYgKG4gPT0gTlVMTCkgeworCQlvc19mcmVlKCpyZXMpOworCQkqcmVzID0gTlVMTDsKKwkJcmV0dXJuOworCX0KKworCW5bcmVzbGVuXSA9IGE7CisJbltyZXNsZW4gKyAxXSA9IDA7CisKKwkqcmVzID0gbjsKK30KKworCit2b2lkIHN0cl9jbGVhcl9mcmVlKGNoYXIgKnN0cikKK3sKKwlpZiAoc3RyKSB7CisJCXNpemVfdCBsZW4gPSBvc19zdHJsZW4oc3RyKTsKKwkJb3NfbWVtc2V0KHN0ciwgMCwgbGVuKTsKKwkJb3NfZnJlZShzdHIpOworCX0KK30KKworCit2b2lkIGJpbl9jbGVhcl9mcmVlKHZvaWQgKmJpbiwgc2l6ZV90IGxlbikKK3sKKwlpZiAoYmluKSB7CisJCW9zX21lbXNldChiaW4sIDAsIGxlbik7CisJCW9zX2ZyZWUoYmluKTsKKwl9Cit9CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvY29tbW9uLmggYi9zcmMvdXRpbHMvY29tbW9uLmgKaW5kZXggMjlmMGI5NS4uMmJjOGZlMSAxMDA2NDQKLS0tIGEvc3JjL3V0aWxzL2NvbW1vbi5oCisrKyBiL3NyYy91dGlscy9jb21tb24uaApAQCAtNDU5LDYgKzQ1OSwxNCBAQAogI2VuZGlmIC8qIF9fR05VQ19fICovCiAjZW5kaWYgLyogX19tdXN0X2NoZWNrICovCiAKKyNpZm5kZWYgX19tYXliZV91bnVzZWQKKyNpZiBfX0dOVUNfXyA+IDMgfHwgKF9fR05VQ19fID09IDMgJiYgX19HTlVDX01JTk9SX18gPj0gNCkKKyNkZWZpbmUgX19tYXliZV91bnVzZWQgX19hdHRyaWJ1dGVfXygodW51c2VkKSkKKyNlbHNlCisjZGVmaW5lIF9fbWF5YmVfdW51c2VkCisjZW5kaWYgLyogX19HTlVDX18gKi8KKyNlbmRpZiAvKiBfX211c3RfY2hlY2sgKi8KKwogaW50IGh3YWRkcl9hdG9uKGNvbnN0IGNoYXIgKnR4dCwgdTggKmFkZHIpOwogaW50IGh3YWRkcl9jb21wYWN0X2F0b24oY29uc3QgY2hhciAqdHh0LCB1OCAqYWRkcik7CiBpbnQgaHdhZGRyX2F0b24yKGNvbnN0IGNoYXIgKnR4dCwgdTggKmFkZHIpOwpAQCAtNDg1LDYgKzQ5Myw3IEBACiAKIGNoYXIgKiB3cGFfY29uZmlnX3BhcnNlX3N0cmluZyhjb25zdCBjaGFyICp2YWx1ZSwgc2l6ZV90ICpsZW4pOwogaW50IGlzX2hleChjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbik7CitpbnQgZmluZF9maXJzdF9iaXQodTMyIHZhbHVlKTsKIHNpemVfdCBtZXJnZV9ieXRlX2FycmF5cyh1OCAqcmVzLCBzaXplX3QgcmVzX2xlbiwKIAkJCSBjb25zdCB1OCAqc3JjMSwgc2l6ZV90IHNyYzFfbGVuLAogCQkJIGNvbnN0IHU4ICpzcmMyLCBzaXplX3Qgc3JjMl9sZW4pOwpAQCAtNTA1LDYgKzUxNCwzMSBAQAogI2luY2x1ZGUgIndwYV9kZWJ1Zy5oIgogCiAKK3N0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0IHsKKwlzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2UgeworCQl1bnNpZ25lZCBpbnQgbWluOworCQl1bnNpZ25lZCBpbnQgbWF4OworCX0gKnJhbmdlOworCXVuc2lnbmVkIGludCBudW07Cit9OworCitpbnQgZnJlcV9yYW5nZV9saXN0X3BhcnNlKHN0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0ICpyZXMsIGNvbnN0IGNoYXIgKnZhbHVlKTsKK2ludCBmcmVxX3JhbmdlX2xpc3RfaW5jbHVkZXMoY29uc3Qgc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3QgKmxpc3QsCisJCQkgICAgIHVuc2lnbmVkIGludCBmcmVxKTsKK2NoYXIgKiBmcmVxX3JhbmdlX2xpc3Rfc3RyKGNvbnN0IHN0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0ICpsaXN0KTsKKworaW50IGludF9hcnJheV9sZW4oY29uc3QgaW50ICphKTsKK3ZvaWQgaW50X2FycmF5X2NvbmNhdChpbnQgKipyZXMsIGNvbnN0IGludCAqYSk7Cit2b2lkIGludF9hcnJheV9zb3J0X3VuaXF1ZShpbnQgKmEpOwordm9pZCBpbnRfYXJyYXlfYWRkX3VuaXF1ZShpbnQgKipyZXMsIGludCBhKTsKKworI2RlZmluZSBBUlJBWV9TSVpFKGEpIChzaXplb2YoYSkgLyBzaXplb2YoKGEpWzBdKSkKKworCit2b2lkIHN0cl9jbGVhcl9mcmVlKGNoYXIgKnN0cik7Cit2b2lkIGJpbl9jbGVhcl9mcmVlKHZvaWQgKmJpbiwgc2l6ZV90IGxlbik7CisKKwogLyoKICAqIGdjYyA0LjQgZW5kcyB1cCBnZW5lcmF0aW5nIHN0cmljdC1hbGlhc2luZyB3YXJuaW5ncyBhYm91dCBzb21lIHZlcnkgY29tbW9uCiAgKiBuZXR3b3JraW5nIHNvY2tldCB1c2VzIHRoYXQgZG8gbm90IHJlYWxseSByZXN1bHQgaW4gYSByZWFsIHByb2JsZW0gYW5kCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvZWRpdC5jIGIvc3JjL3V0aWxzL2VkaXQuYwppbmRleCAxNzdlY2Y0Li5kMzQwYmZhIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvZWRpdC5jCisrKyBiL3NyYy91dGlscy9lZGl0LmMKQEAgLTE0LDcgKzE0LDcgQEAKICNpbmNsdWRlICJsaXN0LmgiCiAjaW5jbHVkZSAiZWRpdC5oIgogCi0jZGVmaW5lIENNRF9CVUZfTEVOIDI1NgorI2RlZmluZSBDTURfQlVGX0xFTiA0MDk2CiBzdGF0aWMgY2hhciBjbWRidWZbQ01EX0JVRl9MRU5dOwogc3RhdGljIGludCBjbWRidWZfcG9zID0gMDsKIHN0YXRpYyBpbnQgY21kYnVmX2xlbiA9IDA7CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvZWRpdF9zaW1wbGUuYyBiL3NyYy91dGlscy9lZGl0X3NpbXBsZS5jCmluZGV4IGEwOTVlYTYuLjEzMTczY2IgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9lZGl0X3NpbXBsZS5jCisrKyBiL3NyYy91dGlscy9lZGl0X3NpbXBsZS5jCkBAIC0xMyw3ICsxMyw3IEBACiAjaW5jbHVkZSAiZWRpdC5oIgogCiAKLSNkZWZpbmUgQ01EX0JVRl9MRU4gMjU2CisjZGVmaW5lIENNRF9CVUZfTEVOIDQwOTYKIHN0YXRpYyBjaGFyIGNtZGJ1ZltDTURfQlVGX0xFTl07CiBzdGF0aWMgaW50IGNtZGJ1Zl9wb3MgPSAwOwogc3RhdGljIGNvbnN0IGNoYXIgKnBzMiA9IE5VTEw7CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvZWxvb3AuYyBiL3NyYy91dGlscy9lbG9vcC5jCmluZGV4IGY2MmUyYjcuLjBkYTZkZTQgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9lbG9vcC5jCisrKyBiL3NyYy91dGlscy9lbG9vcC5jCkBAIC03LDE3ICs3LDI4IEBACiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCisjaW5jbHVkZSA8YXNzZXJ0Lmg+CiAKICNpbmNsdWRlICJjb21tb24uaCIKICNpbmNsdWRlICJ0cmFjZS5oIgogI2luY2x1ZGUgImxpc3QuaCIKICNpbmNsdWRlICJlbG9vcC5oIgogCisjaWYgZGVmaW5lZChDT05GSUdfRUxPT1BfUE9MTCkgJiYgZGVmaW5lZChDT05GSUdfRUxPT1BfRVBPTEwpCisjZXJyb3IgRG8gbm90IGRlZmluZSBib3RoIG9mIHBvbGwgYW5kIGVwb2xsCisjZW5kaWYKKworI2lmICFkZWZpbmVkKENPTkZJR19FTE9PUF9QT0xMKSAmJiAhZGVmaW5lZChDT05GSUdfRUxPT1BfRVBPTEwpCisjZGVmaW5lIENPTkZJR19FTE9PUF9TRUxFQ1QKKyNlbmRpZgorCiAjaWZkZWYgQ09ORklHX0VMT09QX1BPTEwKLSNpbmNsdWRlIDxhc3NlcnQuaD4KICNpbmNsdWRlIDxwb2xsLmg+CiAjZW5kaWYgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KIAorI2lmZGVmIENPTkZJR19FTE9PUF9FUE9MTAorI2luY2x1ZGUgPHN5cy9lcG9sbC5oPgorI2VuZGlmIC8qIENPTkZJR19FTE9PUF9FUE9MTCAqLwogCiBzdHJ1Y3QgZWxvb3Bfc29jayB7CiAJaW50IHNvY2s7CkBAIC0zMSw3ICs0Miw3IEBACiAKIHN0cnVjdCBlbG9vcF90aW1lb3V0IHsKIAlzdHJ1Y3QgZGxfbGlzdCBsaXN0OwotCXN0cnVjdCBvc190aW1lIHRpbWU7CisJc3RydWN0IG9zX3JlbHRpbWUgdGltZTsKIAl2b2lkICplbG9vcF9kYXRhOwogCXZvaWQgKnVzZXJfZGF0YTsKIAllbG9vcF90aW1lb3V0X2hhbmRsZXIgaGFuZGxlcjsKQEAgLTUwLDcgKzYxLDExIEBACiBzdHJ1Y3QgZWxvb3Bfc29ja190YWJsZSB7CiAJaW50IGNvdW50OwogCXN0cnVjdCBlbG9vcF9zb2NrICp0YWJsZTsKKyNpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKKwllbG9vcF9ldmVudF90eXBlIHR5cGU7CisjZWxzZSAvKiBDT05GSUdfRUxPT1BfRVBPTEwgKi8KIAlpbnQgY2hhbmdlZDsKKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfRVBPTEwgKi8KIH07CiAKIHN0cnVjdCBlbG9vcF9kYXRhIHsKQEAgLTYzLDYgKzc4LDEzIEBACiAJc3RydWN0IHBvbGxmZCAqcG9sbGZkczsKIAlzdHJ1Y3QgcG9sbGZkICoqcG9sbGZkc19tYXA7CiAjZW5kaWYgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKKwlpbnQgZXBvbGxmZDsKKwlpbnQgZXBvbGxfbWF4X2V2ZW50X251bTsKKwlpbnQgZXBvbGxfbWF4X2ZkOworCXN0cnVjdCBlbG9vcF9zb2NrICplcG9sbF90YWJsZTsKKwlzdHJ1Y3QgZXBvbGxfZXZlbnQgKmVwb2xsX2V2ZW50czsKKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfRVBPTEwgKi8KIAlzdHJ1Y3QgZWxvb3Bfc29ja190YWJsZSByZWFkZXJzOwogCXN0cnVjdCBlbG9vcF9zb2NrX3RhYmxlIHdyaXRlcnM7CiAJc3RydWN0IGVsb29wX3NvY2tfdGFibGUgZXhjZXB0aW9uczsKQEAgLTc1LDcgKzk3LDYgQEAKIAlpbnQgcGVuZGluZ190ZXJtaW5hdGU7CiAKIAlpbnQgdGVybWluYXRlOwotCWludCByZWFkZXJfdGFibGVfY2hhbmdlZDsKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgZWxvb3BfZGF0YSBlbG9vcDsKQEAgLTEyOCw2ICsxNDksMTcgQEAKIHsKIAlvc19tZW1zZXQoJmVsb29wLCAwLCBzaXplb2YoZWxvb3ApKTsKIAlkbF9saXN0X2luaXQoJmVsb29wLnRpbWVvdXQpOworI2lmZGVmIENPTkZJR19FTE9PUF9FUE9MTAorCWVsb29wLmVwb2xsZmQgPSBlcG9sbF9jcmVhdGUxKDApOworCWlmIChlbG9vcC5lcG9sbGZkIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzOiBlcG9sbF9jcmVhdGUxIGZhaWxlZC4gJXNcbiIsCisJCQkgICBfX2Z1bmNfXywgc3RyZXJyb3IoZXJybm8pKTsKKwkJcmV0dXJuIC0xOworCX0KKwllbG9vcC5yZWFkZXJzLnR5cGUgPSBFVkVOVF9UWVBFX1JFQUQ7CisJZWxvb3Aud3JpdGVycy50eXBlID0gRVZFTlRfVFlQRV9XUklURTsKKwllbG9vcC5leGNlcHRpb25zLnR5cGUgPSBFVkVOVF9UWVBFX0VYQ0VQVElPTjsKKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfRVBPTEwgKi8KICNpZmRlZiBXUEFfVFJBQ0UKIAlzaWduYWwoU0lHU0VHViwgZWxvb3Bfc2lnc2Vndl9oYW5kbGVyKTsKICNlbmRpZiAvKiBXUEFfVFJBQ0UgKi8KQEAgLTEzOSw2ICsxNzEsMTEgQEAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgc29jaywgZWxvb3Bfc29ja19oYW5kbGVyIGhhbmRsZXIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdm9pZCAqZWxvb3BfZGF0YSwgdm9pZCAqdXNlcl9kYXRhKQogeworI2lmZGVmIENPTkZJR19FTE9PUF9FUE9MTAorCXN0cnVjdCBlbG9vcF9zb2NrICp0ZW1wX3RhYmxlOworCXN0cnVjdCBlcG9sbF9ldmVudCBldiwgKnRlbXBfZXZlbnRzOworCWludCBuZXh0OworI2VuZGlmIC8qIENPTkZJR19FTE9PUF9FUE9MTCAqLwogCXN0cnVjdCBlbG9vcF9zb2NrICp0bXA7CiAJaW50IG5ld19tYXhfc29jazsKIApAQCAtMTc0LDYgKzIxMSwzMyBAQAogCQllbG9vcC5wb2xsZmRzID0gbjsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKKwlpZiAobmV3X21heF9zb2NrID49IGVsb29wLmVwb2xsX21heF9mZCkgeworCQluZXh0ID0gZWxvb3AuZXBvbGxfbWF4X2ZkID09IDAgPyAxNiA6IGVsb29wLmVwb2xsX21heF9mZCAqIDI7CisJCXRlbXBfdGFibGUgPSBvc19yZWFsbG9jX2FycmF5KGVsb29wLmVwb2xsX3RhYmxlLCBuZXh0LAorCQkJCQkgICAgICBzaXplb2Yoc3RydWN0IGVsb29wX3NvY2spKTsKKwkJaWYgKHRlbXBfdGFibGUgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKworCQllbG9vcC5lcG9sbF9tYXhfZmQgPSBuZXh0OworCQllbG9vcC5lcG9sbF90YWJsZSA9IHRlbXBfdGFibGU7CisJfQorCisJaWYgKGVsb29wLmNvdW50ICsgMSA+IGVsb29wLmVwb2xsX21heF9ldmVudF9udW0pIHsKKwkJbmV4dCA9IGVsb29wLmVwb2xsX21heF9ldmVudF9udW0gPT0gMCA/IDggOgorCQkJZWxvb3AuZXBvbGxfbWF4X2V2ZW50X251bSAqIDI7CisJCXRlbXBfZXZlbnRzID0gb3NfcmVhbGxvY19hcnJheShlbG9vcC5lcG9sbF9ldmVudHMsIG5leHQsCisJCQkJCSAgICAgICBzaXplb2Yoc3RydWN0IGVwb2xsX2V2ZW50KSk7CisJCWlmICh0ZW1wX2V2ZW50cyA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzOiBtYWxsb2MgZm9yIGVwb2xsIGZhaWxlZC4gIgorCQkJCSAgICIlc1xuIiwgX19mdW5jX18sIHN0cmVycm9yKGVycm5vKSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQllbG9vcC5lcG9sbF9tYXhfZXZlbnRfbnVtID0gbmV4dDsKKwkJZWxvb3AuZXBvbGxfZXZlbnRzID0gdGVtcF9ldmVudHM7CisJfQorI2VuZGlmIC8qIENPTkZJR19FTE9PUF9FUE9MTCAqLwogCiAJZWxvb3BfdHJhY2Vfc29ja19yZW1vdmVfcmVmKHRhYmxlKTsKIAl0bXAgPSBvc19yZWFsbG9jX2FycmF5KHRhYmxlLT50YWJsZSwgdGFibGUtPmNvdW50ICsgMSwKQEAgLTE5MCw5ICsyNTQsMzggQEAKIAl0YWJsZS0+dGFibGUgPSB0bXA7CiAJZWxvb3AubWF4X3NvY2sgPSBuZXdfbWF4X3NvY2s7CiAJZWxvb3AuY291bnQrKzsKKyNpZm5kZWYgQ09ORklHX0VMT09QX0VQT0xMCiAJdGFibGUtPmNoYW5nZWQgPSAxOworI2VuZGlmIC8qIENPTkZJR19FTE9PUF9FUE9MTCAqLwogCWVsb29wX3RyYWNlX3NvY2tfYWRkX3JlZih0YWJsZSk7CiAKKyNpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKKwlvc19tZW1zZXQoJmV2LCAwLCBzaXplb2YoZXYpKTsKKwlzd2l0Y2ggKHRhYmxlLT50eXBlKSB7CisJY2FzZSBFVkVOVF9UWVBFX1JFQUQ6CisJCWV2LmV2ZW50cyA9IEVQT0xMSU47CisJCWJyZWFrOworCWNhc2UgRVZFTlRfVFlQRV9XUklURToKKwkJZXYuZXZlbnRzID0gRVBPTExPVVQ7CisJCWJyZWFrOworCS8qCisJICogRXhjZXB0aW9ucyBhcmUgYWx3YXlzIGNoZWNrZWQgd2hlbiB1c2luZyBlcG9sbCwgYnV0IEkgc3VwcG9zZSBpdCdzCisJICogcG9zc2libGUgdGhhdCBzb21lb25lIHJlZ2lzdGVyZWQgYSBzb2NrZXQgKm9ubHkqIGZvciBleGNlcHRpb24KKwkgKiBoYW5kbGluZy4KKwkgKi8KKwljYXNlIEVWRU5UX1RZUEVfRVhDRVBUSU9OOgorCQlldi5ldmVudHMgPSBFUE9MTEVSUiB8IEVQT0xMSFVQOworCQlicmVhazsKKwl9CisJZXYuZGF0YS5mZCA9IHNvY2s7CisJaWYgKGVwb2xsX2N0bChlbG9vcC5lcG9sbGZkLCBFUE9MTF9DVExfQURELCBzb2NrLCAmZXYpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVzOiBlcG9sbF9jdGwoQUREKSBmb3IgZmQ9JWQgIgorCQkJICAgImZhaWxlZC4gJXNcbiIsIF9fZnVuY19fLCBzb2NrLCBzdHJlcnJvcihlcnJubykpOworCQlyZXR1cm4gLTE7CisJfQorCW9zX21lbWNweSgmZWxvb3AuZXBvbGxfdGFibGVbc29ja10sICZ0YWJsZS0+dGFibGVbdGFibGUtPmNvdW50IC0gMV0sCisJCSAgc2l6ZW9mKHN0cnVjdCBlbG9vcF9zb2NrKSk7CisjZW5kaWYgLyogQ09ORklHX0VMT09QX0VQT0xMICovCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTIxOSw4ICszMTIsMTggQEAKIAl9CiAJdGFibGUtPmNvdW50LS07CiAJZWxvb3AuY291bnQtLTsKKyNpZm5kZWYgQ09ORklHX0VMT09QX0VQT0xMCiAJdGFibGUtPmNoYW5nZWQgPSAxOworI2VuZGlmIC8qIENPTkZJR19FTE9PUF9FUE9MTCAqLwogCWVsb29wX3RyYWNlX3NvY2tfYWRkX3JlZih0YWJsZSk7CisjaWZkZWYgQ09ORklHX0VMT09QX0VQT0xMCisJaWYgKGVwb2xsX2N0bChlbG9vcC5lcG9sbGZkLCBFUE9MTF9DVExfREVMLCBzb2NrLCBOVUxMKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICIlczogZXBvbGxfY3RsKERFTCkgZm9yIGZkPSVkICIKKwkJCSAgICJmYWlsZWQuICVzXG4iLCBfX2Z1bmNfXywgc29jaywgc3RyZXJyb3IoZXJybm8pKTsKKwkJcmV0dXJuOworCX0KKwlvc19tZW1zZXQoJmVsb29wLmVwb2xsX3RhYmxlW3NvY2tdLCAwLCBzaXplb2Yoc3RydWN0IGVsb29wX3NvY2spKTsKKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfRVBPTEwgKi8KIH0KIAogCkBAIC0zNjIsNyArNDY1LDkgQEAKIAkJCQkJbWF4X3BvbGxmZF9tYXAsIFBPTExFUlIgfCBQT0xMSFVQKTsKIH0KIAotI2Vsc2UgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworCisjaWZkZWYgQ09ORklHX0VMT09QX1NFTEVDVAogCiBzdGF0aWMgdm9pZCBlbG9vcF9zb2NrX3RhYmxlX3NldF9mZHMoc3RydWN0IGVsb29wX3NvY2tfdGFibGUgKnRhYmxlLAogCQkJCSAgICAgZmRfc2V0ICpmZHMpCkBAIC0zNzQsOCArNDc5LDEwIEBACiAJaWYgKHRhYmxlLT50YWJsZSA9PSBOVUxMKQogCQlyZXR1cm47CiAKLQlmb3IgKGkgPSAwOyBpIDwgdGFibGUtPmNvdW50OyBpKyspCisJZm9yIChpID0gMDsgaSA8IHRhYmxlLT5jb3VudDsgaSsrKSB7CisJCWFzc2VydCh0YWJsZS0+dGFibGVbaV0uc29jayA+PSAwKTsKIAkJRkRfU0VUKHRhYmxlLT50YWJsZVtpXS5zb2NrLCBmZHMpOworCX0KIH0KIAogCkBAIC0zOTksNyArNTA2LDI0IEBACiAJfQogfQogCi0jZW5kaWYgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfU0VMRUNUICovCisKKworI2lmZGVmIENPTkZJR19FTE9PUF9FUE9MTAorc3RhdGljIHZvaWQgZWxvb3Bfc29ja190YWJsZV9kaXNwYXRjaChzdHJ1Y3QgZXBvbGxfZXZlbnQgKmV2ZW50cywgaW50IG5mZHMpCit7CisJc3RydWN0IGVsb29wX3NvY2sgKnRhYmxlOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IG5mZHM7IGkrKykgeworCQl0YWJsZSA9ICZlbG9vcC5lcG9sbF90YWJsZVtldmVudHNbaV0uZGF0YS5mZF07CisJCWlmICh0YWJsZS0+aGFuZGxlciA9PSBOVUxMKQorCQkJY29udGludWU7CisJCXRhYmxlLT5oYW5kbGVyKHRhYmxlLT5zb2NrLCB0YWJsZS0+ZWxvb3BfZGF0YSwKKwkJCSAgICAgICB0YWJsZS0+dXNlcl9kYXRhKTsKKwl9Cit9CisjZW5kaWYgLyogQ09ORklHX0VMT09QX0VQT0xMICovCiAKIAogc3RhdGljIHZvaWQgZWxvb3Bfc29ja190YWJsZV9kZXN0cm95KHN0cnVjdCBlbG9vcF9zb2NrX3RhYmxlICp0YWJsZSkKQEAgLTQ1OSw2ICs1ODMsNyBAQAogewogCXN0cnVjdCBlbG9vcF9zb2NrX3RhYmxlICp0YWJsZTsKIAorCWFzc2VydChzb2NrID49IDApOwogCXRhYmxlID0gZWxvb3BfZ2V0X3NvY2tfdGFibGUodHlwZSk7CiAJcmV0dXJuIGVsb29wX3NvY2tfdGFibGVfYWRkX3NvY2sodGFibGUsIHNvY2ssIGhhbmRsZXIsCiAJCQkJCSBlbG9vcF9kYXRhLCB1c2VyX2RhdGEpOwpAQCAtNDg0LDcgKzYwOSw3IEBACiAJdGltZW91dCA9IG9zX3phbGxvYyhzaXplb2YoKnRpbWVvdXQpKTsKIAlpZiAodGltZW91dCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7Ci0JaWYgKG9zX2dldF90aW1lKCZ0aW1lb3V0LT50aW1lKSA8IDApIHsKKwlpZiAob3NfZ2V0X3JlbHRpbWUoJnRpbWVvdXQtPnRpbWUpIDwgMCkgewogCQlvc19mcmVlKHRpbWVvdXQpOwogCQlyZXR1cm4gLTE7CiAJfQpAQCAtNTE0LDcgKzYzOSw3IEBACiAKIAkvKiBNYWludGFpbiB0aW1lb3V0cyBpbiBvcmRlciBvZiBpbmNyZWFzaW5nIHRpbWUgKi8KIAlkbF9saXN0X2Zvcl9lYWNoKHRtcCwgJmVsb29wLnRpbWVvdXQsIHN0cnVjdCBlbG9vcF90aW1lb3V0LCBsaXN0KSB7Ci0JCWlmIChvc190aW1lX2JlZm9yZSgmdGltZW91dC0+dGltZSwgJnRtcC0+dGltZSkpIHsKKwkJaWYgKG9zX3JlbHRpbWVfYmVmb3JlKCZ0aW1lb3V0LT50aW1lLCAmdG1wLT50aW1lKSkgewogCQkJZGxfbGlzdF9hZGQodG1wLT5saXN0LnByZXYsICZ0aW1lb3V0LT5saXN0KTsKIAkJCXJldHVybiAwOwogCQl9CkBAIC01NTgsMTMgKzY4MywxMyBAQAogCiBpbnQgZWxvb3BfY2FuY2VsX3RpbWVvdXRfb25lKGVsb29wX3RpbWVvdXRfaGFuZGxlciBoYW5kbGVyLAogCQkJICAgICB2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2RhdGEsCi0JCQkgICAgIHN0cnVjdCBvc190aW1lICpyZW1haW5pbmcpCisJCQkgICAgIHN0cnVjdCBvc19yZWx0aW1lICpyZW1haW5pbmcpCiB7CiAJc3RydWN0IGVsb29wX3RpbWVvdXQgKnRpbWVvdXQsICpwcmV2OwogCWludCByZW1vdmVkID0gMDsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7CisJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CiAJcmVtYWluaW5nLT5zZWMgPSByZW1haW5pbmctPnVzZWMgPSAwOwogCiAJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKHRpbWVvdXQsIHByZXYsICZlbG9vcC50aW1lb3V0LApAQCAtNTczLDggKzY5OCw4IEBACiAJCSAgICAodGltZW91dC0+ZWxvb3BfZGF0YSA9PSBlbG9vcF9kYXRhKSAmJgogCQkgICAgKHRpbWVvdXQtPnVzZXJfZGF0YSA9PSB1c2VyX2RhdGEpKSB7CiAJCQlyZW1vdmVkID0gMTsKLQkJCWlmIChvc190aW1lX2JlZm9yZSgmbm93LCAmdGltZW91dC0+dGltZSkpCi0JCQkJb3NfdGltZV9zdWIoJnRpbWVvdXQtPnRpbWUsICZub3csIHJlbWFpbmluZyk7CisJCQlpZiAob3NfcmVsdGltZV9iZWZvcmUoJm5vdywgJnRpbWVvdXQtPnRpbWUpKQorCQkJCW9zX3JlbHRpbWVfc3ViKCZ0aW1lb3V0LT50aW1lLCAmbm93LCByZW1haW5pbmcpOwogCQkJZWxvb3BfcmVtb3ZlX3RpbWVvdXQodGltZW91dCk7CiAJCQlicmVhazsKIAkJfQpAQCAtNTk5LDYgKzcyNCw3MCBAQAogfQogCiAKK2ludCBlbG9vcF9kZXBsZXRlX3RpbWVvdXQodW5zaWduZWQgaW50IHJlcV9zZWNzLCB1bnNpZ25lZCBpbnQgcmVxX3VzZWNzLAorCQkJICBlbG9vcF90aW1lb3V0X2hhbmRsZXIgaGFuZGxlciwgdm9pZCAqZWxvb3BfZGF0YSwKKwkJCSAgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCBvc19yZWx0aW1lIG5vdywgcmVxdWVzdGVkLCByZW1haW5pbmc7CisJc3RydWN0IGVsb29wX3RpbWVvdXQgKnRtcDsKKworCWRsX2xpc3RfZm9yX2VhY2godG1wLCAmZWxvb3AudGltZW91dCwgc3RydWN0IGVsb29wX3RpbWVvdXQsIGxpc3QpIHsKKwkJaWYgKHRtcC0+aGFuZGxlciA9PSBoYW5kbGVyICYmCisJCSAgICB0bXAtPmVsb29wX2RhdGEgPT0gZWxvb3BfZGF0YSAmJgorCQkgICAgdG1wLT51c2VyX2RhdGEgPT0gdXNlcl9kYXRhKSB7CisJCQlyZXF1ZXN0ZWQuc2VjID0gcmVxX3NlY3M7CisJCQlyZXF1ZXN0ZWQudXNlYyA9IHJlcV91c2VjczsKKwkJCW9zX2dldF9yZWx0aW1lKCZub3cpOworCQkJb3NfcmVsdGltZV9zdWIoJnRtcC0+dGltZSwgJm5vdywgJnJlbWFpbmluZyk7CisJCQlpZiAob3NfcmVsdGltZV9iZWZvcmUoJnJlcXVlc3RlZCwgJnJlbWFpbmluZykpIHsKKwkJCQllbG9vcF9jYW5jZWxfdGltZW91dChoYW5kbGVyLCBlbG9vcF9kYXRhLAorCQkJCQkJICAgICB1c2VyX2RhdGEpOworCQkJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQocmVxdWVzdGVkLnNlYywKKwkJCQkJCSAgICAgICByZXF1ZXN0ZWQudXNlYywKKwkJCQkJCSAgICAgICBoYW5kbGVyLCBlbG9vcF9kYXRhLAorCQkJCQkJICAgICAgIHVzZXJfZGF0YSk7CisJCQkJcmV0dXJuIDE7CisJCQl9CisJCQlyZXR1cm4gMDsKKwkJfQorCX0KKworCXJldHVybiAtMTsKK30KKworCitpbnQgZWxvb3BfcmVwbGVuaXNoX3RpbWVvdXQodW5zaWduZWQgaW50IHJlcV9zZWNzLCB1bnNpZ25lZCBpbnQgcmVxX3VzZWNzLAorCQkJICAgIGVsb29wX3RpbWVvdXRfaGFuZGxlciBoYW5kbGVyLCB2b2lkICplbG9vcF9kYXRhLAorCQkJICAgIHZvaWQgKnVzZXJfZGF0YSkKK3sKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3csIHJlcXVlc3RlZCwgcmVtYWluaW5nOworCXN0cnVjdCBlbG9vcF90aW1lb3V0ICp0bXA7CisKKwlkbF9saXN0X2Zvcl9lYWNoKHRtcCwgJmVsb29wLnRpbWVvdXQsIHN0cnVjdCBlbG9vcF90aW1lb3V0LCBsaXN0KSB7CisJCWlmICh0bXAtPmhhbmRsZXIgPT0gaGFuZGxlciAmJgorCQkgICAgdG1wLT5lbG9vcF9kYXRhID09IGVsb29wX2RhdGEgJiYKKwkJICAgIHRtcC0+dXNlcl9kYXRhID09IHVzZXJfZGF0YSkgeworCQkJcmVxdWVzdGVkLnNlYyA9IHJlcV9zZWNzOworCQkJcmVxdWVzdGVkLnVzZWMgPSByZXFfdXNlY3M7CisJCQlvc19nZXRfcmVsdGltZSgmbm93KTsKKwkJCW9zX3JlbHRpbWVfc3ViKCZ0bXAtPnRpbWUsICZub3csICZyZW1haW5pbmcpOworCQkJaWYgKG9zX3JlbHRpbWVfYmVmb3JlKCZyZW1haW5pbmcsICZyZXF1ZXN0ZWQpKSB7CisJCQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaGFuZGxlciwgZWxvb3BfZGF0YSwKKwkJCQkJCSAgICAgdXNlcl9kYXRhKTsKKwkJCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KHJlcXVlc3RlZC5zZWMsCisJCQkJCQkgICAgICAgcmVxdWVzdGVkLnVzZWMsCisJCQkJCQkgICAgICAgaGFuZGxlciwgZWxvb3BfZGF0YSwKKwkJCQkJCSAgICAgICB1c2VyX2RhdGEpOworCQkJCXJldHVybiAxOworCQkJfQorCQkJcmV0dXJuIDA7CisJCX0KKwl9CisKKwlyZXR1cm4gLTE7Cit9CisKKwogI2lmbmRlZiBDT05GSUdfTkFUSVZFX1dJTkRPV1MKIHN0YXRpYyB2b2lkIGVsb29wX2hhbmRsZV9hbGFybShpbnQgc2lnKQogewpAQCAtNzA5LDIwICs4OTgsMjQgQEAKICNpZmRlZiBDT05GSUdfRUxPT1BfUE9MTAogCWludCBudW1fcG9sbF9mZHM7CiAJaW50IHRpbWVvdXRfbXMgPSAwOwotI2Vsc2UgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworI2lmZGVmIENPTkZJR19FTE9PUF9TRUxFQ1QKIAlmZF9zZXQgKnJmZHMsICp3ZmRzLCAqZWZkczsKIAlzdHJ1Y3QgdGltZXZhbCBfdHY7Ci0jZW5kaWYgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfU0VMRUNUICovCisjaWZkZWYgQ09ORklHX0VMT09QX0VQT0xMCisJaW50IHRpbWVvdXRfbXMgPSAtMTsKKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfRVBPTEwgKi8KIAlpbnQgcmVzOwotCXN0cnVjdCBvc190aW1lIHR2LCBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgdHYsIG5vdzsKIAotI2lmbmRlZiBDT05GSUdfRUxPT1BfUE9MTAorI2lmZGVmIENPTkZJR19FTE9PUF9TRUxFQ1QKIAlyZmRzID0gb3NfbWFsbG9jKHNpemVvZigqcmZkcykpOwogCXdmZHMgPSBvc19tYWxsb2Moc2l6ZW9mKCp3ZmRzKSk7CiAJZWZkcyA9IG9zX21hbGxvYyhzaXplb2YoKmVmZHMpKTsKIAlpZiAocmZkcyA9PSBOVUxMIHx8IHdmZHMgPT0gTlVMTCB8fCBlZmRzID09IE5VTEwpCiAJCWdvdG8gb3V0OwotI2VuZGlmIC8qIENPTkZJR19FTE9PUF9QT0xMICovCisjZW5kaWYgLyogQ09ORklHX0VMT09QX1NFTEVDVCAqLwogCiAJd2hpbGUgKCFlbG9vcC50ZXJtaW5hdGUgJiYKIAkgICAgICAgKCFkbF9saXN0X2VtcHR5KCZlbG9vcC50aW1lb3V0KSB8fCBlbG9vcC5yZWFkZXJzLmNvdW50ID4gMCB8fApAQCAtNzMxLDE3ICs5MjQsMTggQEAKIAkJdGltZW91dCA9IGRsX2xpc3RfZmlyc3QoJmVsb29wLnRpbWVvdXQsIHN0cnVjdCBlbG9vcF90aW1lb3V0LAogCQkJCQlsaXN0KTsKIAkJaWYgKHRpbWVvdXQpIHsKLQkJCW9zX2dldF90aW1lKCZub3cpOwotCQkJaWYgKG9zX3RpbWVfYmVmb3JlKCZub3csICZ0aW1lb3V0LT50aW1lKSkKLQkJCQlvc190aW1lX3N1YigmdGltZW91dC0+dGltZSwgJm5vdywgJnR2KTsKKwkJCW9zX2dldF9yZWx0aW1lKCZub3cpOworCQkJaWYgKG9zX3JlbHRpbWVfYmVmb3JlKCZub3csICZ0aW1lb3V0LT50aW1lKSkKKwkJCQlvc19yZWx0aW1lX3N1YigmdGltZW91dC0+dGltZSwgJm5vdywgJnR2KTsKIAkJCWVsc2UKIAkJCQl0di5zZWMgPSB0di51c2VjID0gMDsKLSNpZmRlZiBDT05GSUdfRUxPT1BfUE9MTAorI2lmIGRlZmluZWQoQ09ORklHX0VMT09QX1BPTEwpIHx8IGRlZmluZWQoQ09ORklHX0VMT09QX0VQT0xMKQogCQkJdGltZW91dF9tcyA9IHR2LnNlYyAqIDEwMDAgKyB0di51c2VjIC8gMTAwMDsKLSNlbHNlIC8qIENPTkZJR19FTE9PUF9QT0xMICovCisjZW5kaWYgLyogZGVmaW5lZChDT05GSUdfRUxPT1BfUE9MTCkgfHwgZGVmaW5lZChDT05GSUdfRUxPT1BfRVBPTEwpICovCisjaWZkZWYgQ09ORklHX0VMT09QX1NFTEVDVAogCQkJX3R2LnR2X3NlYyA9IHR2LnNlYzsKIAkJCV90di50dl91c2VjID0gdHYudXNlYzsKLSNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworI2VuZGlmIC8qIENPTkZJR19FTE9PUF9TRUxFQ1QgKi8KIAkJfQogCiAjaWZkZWYgQ09ORklHX0VMT09QX1BPTEwKQEAgLTc1MSwzMCArOTQ1LDQ0IEBACiAJCQllbG9vcC5tYXhfcG9sbGZkX21hcCk7CiAJCXJlcyA9IHBvbGwoZWxvb3AucG9sbGZkcywgbnVtX3BvbGxfZmRzLAogCQkJICAgdGltZW91dCA/IHRpbWVvdXRfbXMgOiAtMSk7Ci0KLQkJaWYgKHJlcyA8IDAgJiYgZXJybm8gIT0gRUlOVFIgJiYgZXJybm8gIT0gMCkgewotCQkJcGVycm9yKCJwb2xsIik7Ci0JCQlnb3RvIG91dDsKLQkJfQotI2Vsc2UgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworI2lmZGVmIENPTkZJR19FTE9PUF9TRUxFQ1QKIAkJZWxvb3Bfc29ja190YWJsZV9zZXRfZmRzKCZlbG9vcC5yZWFkZXJzLCByZmRzKTsKIAkJZWxvb3Bfc29ja190YWJsZV9zZXRfZmRzKCZlbG9vcC53cml0ZXJzLCB3ZmRzKTsKIAkJZWxvb3Bfc29ja190YWJsZV9zZXRfZmRzKCZlbG9vcC5leGNlcHRpb25zLCBlZmRzKTsKIAkJcmVzID0gc2VsZWN0KGVsb29wLm1heF9zb2NrICsgMSwgcmZkcywgd2ZkcywgZWZkcywKIAkJCSAgICAgdGltZW91dCA/ICZfdHYgOiBOVUxMKTsKKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfU0VMRUNUICovCisjaWZkZWYgQ09ORklHX0VMT09QX0VQT0xMCisJCWlmIChlbG9vcC5jb3VudCA9PSAwKSB7CisJCQlyZXMgPSAwOworCQl9IGVsc2UgeworCQkJcmVzID0gZXBvbGxfd2FpdChlbG9vcC5lcG9sbGZkLCBlbG9vcC5lcG9sbF9ldmVudHMsCisJCQkJCSBlbG9vcC5jb3VudCwgdGltZW91dF9tcyk7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfRVBPTEwgKi8KIAkJaWYgKHJlcyA8IDAgJiYgZXJybm8gIT0gRUlOVFIgJiYgZXJybm8gIT0gMCkgewotCQkJcGVycm9yKCJzZWxlY3QiKTsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiZWxvb3A6ICVzOiAlcyIsCisjaWZkZWYgQ09ORklHX0VMT09QX1BPTEwKKwkJCQkgICAicG9sbCIKKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworI2lmZGVmIENPTkZJR19FTE9PUF9TRUxFQ1QKKwkJCQkgICAic2VsZWN0IgorI2VuZGlmIC8qIENPTkZJR19FTE9PUF9TRUxFQ1QgKi8KKyNpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKKwkJCQkgICAiZXBvbGwiCisjZW5kaWYgLyogQ09ORklHX0VMT09QX0VQT0xMICovCisJCQkJICAgLCBzdHJlcnJvcihlcnJubykpOwogCQkJZ290byBvdXQ7CiAJCX0KLSNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLwogCQllbG9vcF9wcm9jZXNzX3BlbmRpbmdfc2lnbmFscygpOwogCiAJCS8qIGNoZWNrIGlmIHNvbWUgcmVnaXN0ZXJlZCB0aW1lb3V0cyBoYXZlIG9jY3VycmVkICovCiAJCXRpbWVvdXQgPSBkbF9saXN0X2ZpcnN0KCZlbG9vcC50aW1lb3V0LCBzdHJ1Y3QgZWxvb3BfdGltZW91dCwKIAkJCQkJbGlzdCk7CiAJCWlmICh0aW1lb3V0KSB7Ci0JCQlvc19nZXRfdGltZSgmbm93KTsKLQkJCWlmICghb3NfdGltZV9iZWZvcmUoJm5vdywgJnRpbWVvdXQtPnRpbWUpKSB7CisJCQlvc19nZXRfcmVsdGltZSgmbm93KTsKKwkJCWlmICghb3NfcmVsdGltZV9iZWZvcmUoJm5vdywgJnRpbWVvdXQtPnRpbWUpKSB7CiAJCQkJdm9pZCAqZWxvb3BfZGF0YSA9IHRpbWVvdXQtPmVsb29wX2RhdGE7CiAJCQkJdm9pZCAqdXNlcl9kYXRhID0gdGltZW91dC0+dXNlcl9kYXRhOwogCQkJCWVsb29wX3RpbWVvdXRfaGFuZGxlciBoYW5kbGVyID0KQEAgLTc5MiwyMCArMTAwMCwyNCBAQAogCQllbG9vcF9zb2NrX3RhYmxlX2Rpc3BhdGNoKCZlbG9vcC5yZWFkZXJzLCAmZWxvb3Aud3JpdGVycywKIAkJCQkJICAmZWxvb3AuZXhjZXB0aW9ucywgZWxvb3AucG9sbGZkc19tYXAsCiAJCQkJCSAgZWxvb3AubWF4X3BvbGxmZF9tYXApOwotI2Vsc2UgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworI2lmZGVmIENPTkZJR19FTE9PUF9TRUxFQ1QKIAkJZWxvb3Bfc29ja190YWJsZV9kaXNwYXRjaCgmZWxvb3AucmVhZGVycywgcmZkcyk7CiAJCWVsb29wX3NvY2tfdGFibGVfZGlzcGF0Y2goJmVsb29wLndyaXRlcnMsIHdmZHMpOwogCQllbG9vcF9zb2NrX3RhYmxlX2Rpc3BhdGNoKCZlbG9vcC5leGNlcHRpb25zLCBlZmRzKTsKLSNlbmRpZiAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworI2VuZGlmIC8qIENPTkZJR19FTE9PUF9TRUxFQ1QgKi8KKyNpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKKwkJZWxvb3Bfc29ja190YWJsZV9kaXNwYXRjaChlbG9vcC5lcG9sbF9ldmVudHMsIHJlcyk7CisjZW5kaWYgLyogQ09ORklHX0VMT09QX0VQT0xMICovCiAJfQogCiAJZWxvb3AudGVybWluYXRlID0gMDsKIG91dDoKLSNpZm5kZWYgQ09ORklHX0VMT09QX1BPTEwKKyNpZmRlZiBDT05GSUdfRUxPT1BfU0VMRUNUCiAJb3NfZnJlZShyZmRzKTsKIAlvc19mcmVlKHdmZHMpOwogCW9zX2ZyZWUoZWZkcyk7Ci0jZW5kaWYgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNlbmRpZiAvKiBDT05GSUdfRUxPT1BfU0VMRUNUICovCiAJcmV0dXJuOwogfQogCkBAIC04MTksOSArMTAzMSw5IEBACiB2b2lkIGVsb29wX2Rlc3Ryb3kodm9pZCkKIHsKIAlzdHJ1Y3QgZWxvb3BfdGltZW91dCAqdGltZW91dCwgKnByZXY7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAotCW9zX2dldF90aW1lKCZub3cpOworCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCWRsX2xpc3RfZm9yX2VhY2hfc2FmZSh0aW1lb3V0LCBwcmV2LCAmZWxvb3AudGltZW91dCwKIAkJCSAgICAgIHN0cnVjdCBlbG9vcF90aW1lb3V0LCBsaXN0KSB7CiAJCWludCBzZWMsIHVzZWM7CkBAIC04NDksNiArMTA2MSwxMSBAQAogCW9zX2ZyZWUoZWxvb3AucG9sbGZkcyk7CiAJb3NfZnJlZShlbG9vcC5wb2xsZmRzX21hcCk7CiAjZW5kaWYgLyogQ09ORklHX0VMT09QX1BPTEwgKi8KKyNpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKKwlvc19mcmVlKGVsb29wLmVwb2xsX3RhYmxlKTsKKwlvc19mcmVlKGVsb29wLmVwb2xsX2V2ZW50cyk7CisJY2xvc2UoZWxvb3AuZXBvbGxmZCk7CisjZW5kaWYgLyogQ09ORklHX0VMT09QX0VQT0xMICovCiB9CiAKIApAQCAtODcxLDcgKzEwODgsMTMgQEAKIAlwZmQuZXZlbnRzID0gUE9MTElOOwogCiAJcG9sbCgmcGZkLCAxLCAtMSk7Ci0jZWxzZSAvKiBDT05GSUdfRUxPT1BfUE9MTCAqLworI2VuZGlmIC8qIENPTkZJR19FTE9PUF9QT0xMICovCisjaWYgZGVmaW5lZChDT05GSUdfRUxPT1BfU0VMRUNUKSB8fCBkZWZpbmVkKENPTkZJR19FTE9PUF9FUE9MTCkKKwkvKgorCSAqIFdlIGNhbiB1c2UgZXBvbGwoKSBoZXJlLiBCdXQgZXBvbGwoKSByZXF1cmVzIDQgc3lzdGVtIGNhbGxzLgorCSAqIGVwb2xsX2NyZWF0ZTEoKSwgZXBvbGxfY3RsKCkgZm9yIEFERCwgZXBvbGxfd2FpdCwgYW5kIGNsb3NlKCkgZm9yCisJICogZXBvbGwgZmQuIFNvIHNlbGVjdCgpIGlzIGJldHRlciBmb3IgcGVyZm9ybWFuY2UgaGVyZS4KKwkgKi8KIAlmZF9zZXQgcmZkczsKIAogCWlmIChzb2NrIDwgMCkKQEAgLTg4MCw1ICsxMTAzLDkgQEAKIAlGRF9aRVJPKCZyZmRzKTsKIAlGRF9TRVQoc29jaywgJnJmZHMpOwogCXNlbGVjdChzb2NrICsgMSwgJnJmZHMsIE5VTEwsIE5VTEwsIE5VTEwpOwotI2VuZGlmIC8qIENPTkZJR19FTE9PUF9QT0xMICovCisjZW5kaWYgLyogZGVmaW5lZChDT05GSUdfRUxPT1BfU0VMRUNUKSB8fCBkZWZpbmVkKENPTkZJR19FTE9PUF9FUE9MTCkgKi8KIH0KKworI2lmZGVmIENPTkZJR19FTE9PUF9TRUxFQ1QKKyN1bmRlZiBDT05GSUdfRUxPT1BfU0VMRUNUCisjZW5kaWYgLyogQ09ORklHX0VMT09QX1NFTEVDVCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2Vsb29wLmggYi9zcmMvdXRpbHMvZWxvb3AuaAppbmRleCAwMDM3YzYzLi4wN2I4YzBkIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvZWxvb3AuaAorKysgYi9zcmMvdXRpbHMvZWxvb3AuaApAQCAtMjA3LDcgKzIwNyw3IEBACiAgKi8KIGludCBlbG9vcF9jYW5jZWxfdGltZW91dF9vbmUoZWxvb3BfdGltZW91dF9oYW5kbGVyIGhhbmRsZXIsCiAJCQkgICAgIHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfZGF0YSwKLQkJCSAgICAgc3RydWN0IG9zX3RpbWUgKnJlbWFpbmluZyk7CisJCQkgICAgIHN0cnVjdCBvc19yZWx0aW1lICpyZW1haW5pbmcpOwogCiAvKioKICAqIGVsb29wX2lzX3RpbWVvdXRfcmVnaXN0ZXJlZCAtIENoZWNrIGlmIGEgdGltZW91dCBpcyBhbHJlYWR5IHJlZ2lzdGVyZWQKQEAgLTIyMyw2ICsyMjMsNDAgQEAKIAkJCQl2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2RhdGEpOwogCiAvKioKKyAqIGVsb29wX2RlcGxldGVfdGltZW91dCAtIERlcGxldGUgYSB0aW1lb3V0IHRoYXQgaXMgYWxyZWFkeSByZWdpc3RlcmVkCisgKiBAcmVxX3NlY3M6IFJlcXVlc3RlZCBudW1iZXIgb2Ygc2Vjb25kcyB0byB0aGUgdGltZW91dAorICogQHJlcV91c2VjczogUmVxdWVzdGVkIG51bWJlciBvZiBtaWNyb3NlY29uZHMgdG8gdGhlIHRpbWVvdXQKKyAqIEBoYW5kbGVyOiBNYXRjaGluZyBjYWxsYmFjayBmdW5jdGlvbgorICogQGVsb29wX2RhdGE6IE1hdGNoaW5nIGVsb29wX2RhdGEKKyAqIEB1c2VyX2RhdGE6IE1hdGNoaW5nIHVzZXJfZGF0YQorICogUmV0dXJuczogMSBpZiB0aGUgdGltZW91dCBpcyBkZXBsZXRlZCwgMCBpZiBubyBjaGFuZ2UgaXMgbWFkZSwgLTEgaWYgbm8KKyAqIHRpbWVvdXQgbWF0Y2hlZAorICoKKyAqIEZpbmQgYSByZWdpc3RlcmVkIG1hdGNoaW5nIDxoYW5kbGVyLGVsb29wX2RhdGEsdXNlcl9kYXRhPiB0aW1lb3V0LiBJZiBmb3VuZCwKKyAqIGRlcGxldGUgdGhlIHRpbWVvdXQgaWYgcmVtYWluaW5nIHRpbWUgaXMgbW9yZSB0aGFuIHRoZSByZXF1ZXN0ZWQgdGltZS4KKyAqLworaW50IGVsb29wX2RlcGxldGVfdGltZW91dCh1bnNpZ25lZCBpbnQgcmVxX3NlY3MsIHVuc2lnbmVkIGludCByZXFfdXNlY3MsCisJCQkgIGVsb29wX3RpbWVvdXRfaGFuZGxlciBoYW5kbGVyLCB2b2lkICplbG9vcF9kYXRhLAorCQkJICB2b2lkICp1c2VyX2RhdGEpOworCisvKioKKyAqIGVsb29wX3JlcGxlbmlzaF90aW1lb3V0IC0gUmVwbGVuaXNoIGEgdGltZW91dCB0aGF0IGlzIGFscmVhZHkgcmVnaXN0ZXJlZAorICogQHJlcV9zZWNzOiBSZXF1ZXN0ZWQgbnVtYmVyIG9mIHNlY29uZHMgdG8gdGhlIHRpbWVvdXQKKyAqIEByZXFfdXNlY3M6IFJlcXVlc3RlZCBudW1iZXIgb2YgbWljcm9zZWNvbmRzIHRvIHRoZSB0aW1lb3V0CisgKiBAaGFuZGxlcjogTWF0Y2hpbmcgY2FsbGJhY2sgZnVuY3Rpb24KKyAqIEBlbG9vcF9kYXRhOiBNYXRjaGluZyBlbG9vcF9kYXRhCisgKiBAdXNlcl9kYXRhOiBNYXRjaGluZyB1c2VyX2RhdGEKKyAqIFJldHVybnM6IDEgaWYgdGhlIHRpbWVvdXQgaXMgcmVwbGVuaXNoZWQsIDAgaWYgbm8gY2hhbmdlIGlzIG1hZGUsIC0xIGlmIG5vCisgKiB0aW1lb3V0IG1hdGNoZWQKKyAqCisgKiBGaW5kIGEgcmVnaXN0ZXJlZCBtYXRjaGluZyA8aGFuZGxlcixlbG9vcF9kYXRhLHVzZXJfZGF0YT4gdGltZW91dC4gSWYgZm91bmQsCisgKiByZXBsZW5pc2ggdGhlIHRpbWVvdXQgaWYgcmVtYWluaW5nIHRpbWUgaXMgbGVzcyB0aGFuIHRoZSByZXF1ZXN0ZWQgdGltZS4KKyAqLworaW50IGVsb29wX3JlcGxlbmlzaF90aW1lb3V0KHVuc2lnbmVkIGludCByZXFfc2VjcywgdW5zaWduZWQgaW50IHJlcV91c2VjcywKKwkJCSAgICBlbG9vcF90aW1lb3V0X2hhbmRsZXIgaGFuZGxlciwgdm9pZCAqZWxvb3BfZGF0YSwKKwkJCSAgICB2b2lkICp1c2VyX2RhdGEpOworCisvKioKICAqIGVsb29wX3JlZ2lzdGVyX3NpZ25hbCAtIFJlZ2lzdGVyIGhhbmRsZXIgZm9yIHNpZ25hbHMKICAqIEBzaWc6IFNpZ25hbCBudW1iZXIgKGUuZy4sIFNJR0hVUCkKICAqIEBoYW5kbGVyOiBDYWxsYmFjayBmdW5jdGlvbiB0byBiZSBjYWxsZWQgd2hlbiB0aGUgc2lnbmFsIGlzIHJlY2VpdmVkCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvZWxvb3Bfbm9uZS5jIGIvc3JjL3V0aWxzL2Vsb29wX25vbmUuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggY2I1ZTkyMi4uMDAwMDAwMAotLS0gYS9zcmMvdXRpbHMvZWxvb3Bfbm9uZS5jCisrKyAvZGV2L251bGwKQEAgLTEsNDEwICswLDAgQEAKLS8qCi0gKiBFdmVudCBsb29wIC0gZW1wdHkgdGVtcGxhdGUgKGJhc2ljIHN0cnVjdHVyZSwgYnV0IG5vIE9TIHNwZWNpZmljIG9wZXJhdGlvbnMpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KLSAqCi0gKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgotICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgotICovCi0KLSNpbmNsdWRlICJpbmNsdWRlcy5oIgotCi0jaW5jbHVkZSAiY29tbW9uLmgiCi0jaW5jbHVkZSAibGlzdC5oIgotI2luY2x1ZGUgImVsb29wLmgiCi0KLQotc3RydWN0IGVsb29wX3NvY2sgewotCWludCBzb2NrOwotCXZvaWQgKmVsb29wX2RhdGE7Ci0Jdm9pZCAqdXNlcl9kYXRhOwotCWVsb29wX3NvY2tfaGFuZGxlciBoYW5kbGVyOwotfTsKLQotc3RydWN0IGVsb29wX3RpbWVvdXQgewotCXN0cnVjdCBkbF9saXN0IGxpc3Q7Ci0Jc3RydWN0IG9zX3RpbWUgdGltZTsKLQl2b2lkICplbG9vcF9kYXRhOwotCXZvaWQgKnVzZXJfZGF0YTsKLQllbG9vcF90aW1lb3V0X2hhbmRsZXIgaGFuZGxlcjsKLX07Ci0KLXN0cnVjdCBlbG9vcF9zaWduYWwgewotCWludCBzaWc7Ci0Jdm9pZCAqdXNlcl9kYXRhOwotCWVsb29wX3NpZ25hbF9oYW5kbGVyIGhhbmRsZXI7Ci0JaW50IHNpZ25hbGVkOwotfTsKLQotc3RydWN0IGVsb29wX2RhdGEgewotCWludCBtYXhfc29jaywgcmVhZGVyX2NvdW50OwotCXN0cnVjdCBlbG9vcF9zb2NrICpyZWFkZXJzOwotCi0Jc3RydWN0IGRsX2xpc3QgdGltZW91dDsKLQotCWludCBzaWduYWxfY291bnQ7Ci0Jc3RydWN0IGVsb29wX3NpZ25hbCAqc2lnbmFsczsKLQlpbnQgc2lnbmFsZWQ7Ci0JaW50IHBlbmRpbmdfdGVybWluYXRlOwotCi0JaW50IHRlcm1pbmF0ZTsKLQlpbnQgcmVhZGVyX3RhYmxlX2NoYW5nZWQ7Ci19OwotCi1zdGF0aWMgc3RydWN0IGVsb29wX2RhdGEgZWxvb3A7Ci0KLQotaW50IGVsb29wX2luaXQodm9pZCkKLXsKLQlvc19tZW1zZXQoJmVsb29wLCAwLCBzaXplb2YoZWxvb3ApKTsKLQlkbF9saXN0X2luaXQoJmVsb29wLnRpbWVvdXQpOwotCXJldHVybiAwOwotfQotCi0KLWludCBlbG9vcF9yZWdpc3Rlcl9yZWFkX3NvY2soaW50IHNvY2ssIGVsb29wX3NvY2tfaGFuZGxlciBoYW5kbGVyLAotCQkJICAgICB2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2RhdGEpCi17Ci0Jc3RydWN0IGVsb29wX3NvY2sgKnRtcDsKLQotCXRtcCA9IG9zX3JlYWxsb2NfYXJyYXkoZWxvb3AucmVhZGVycywgZWxvb3AucmVhZGVyX2NvdW50ICsgMSwKLQkJCSAgICAgICBzaXplb2Yoc3RydWN0IGVsb29wX3NvY2spKTsKLQlpZiAodG1wID09IE5VTEwpCi0JCXJldHVybiAtMTsKLQotCXRtcFtlbG9vcC5yZWFkZXJfY291bnRdLnNvY2sgPSBzb2NrOwotCXRtcFtlbG9vcC5yZWFkZXJfY291bnRdLmVsb29wX2RhdGEgPSBlbG9vcF9kYXRhOwotCXRtcFtlbG9vcC5yZWFkZXJfY291bnRdLnVzZXJfZGF0YSA9IHVzZXJfZGF0YTsKLQl0bXBbZWxvb3AucmVhZGVyX2NvdW50XS5oYW5kbGVyID0gaGFuZGxlcjsKLQllbG9vcC5yZWFkZXJfY291bnQrKzsKLQllbG9vcC5yZWFkZXJzID0gdG1wOwotCWlmIChzb2NrID4gZWxvb3AubWF4X3NvY2spCi0JCWVsb29wLm1heF9zb2NrID0gc29jazsKLQllbG9vcC5yZWFkZXJfdGFibGVfY2hhbmdlZCA9IDE7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi12b2lkIGVsb29wX3VucmVnaXN0ZXJfcmVhZF9zb2NrKGludCBzb2NrKQotewotCWludCBpOwotCi0JaWYgKGVsb29wLnJlYWRlcnMgPT0gTlVMTCB8fCBlbG9vcC5yZWFkZXJfY291bnQgPT0gMCkKLQkJcmV0dXJuOwotCi0JZm9yIChpID0gMDsgaSA8IGVsb29wLnJlYWRlcl9jb3VudDsgaSsrKSB7Ci0JCWlmIChlbG9vcC5yZWFkZXJzW2ldLnNvY2sgPT0gc29jaykKLQkJCWJyZWFrOwotCX0KLQlpZiAoaSA9PSBlbG9vcC5yZWFkZXJfY291bnQpCi0JCXJldHVybjsKLQlpZiAoaSAhPSBlbG9vcC5yZWFkZXJfY291bnQgLSAxKSB7Ci0JCW9zX21lbW1vdmUoJmVsb29wLnJlYWRlcnNbaV0sICZlbG9vcC5yZWFkZXJzW2kgKyAxXSwKLQkJCSAgIChlbG9vcC5yZWFkZXJfY291bnQgLSBpIC0gMSkgKgotCQkJICAgc2l6ZW9mKHN0cnVjdCBlbG9vcF9zb2NrKSk7Ci0JfQotCWVsb29wLnJlYWRlcl9jb3VudC0tOwotCWVsb29wLnJlYWRlcl90YWJsZV9jaGFuZ2VkID0gMTsKLX0KLQotCi1pbnQgZWxvb3BfcmVnaXN0ZXJfdGltZW91dCh1bnNpZ25lZCBpbnQgc2VjcywgdW5zaWduZWQgaW50IHVzZWNzLAotCQkJICAgZWxvb3BfdGltZW91dF9oYW5kbGVyIGhhbmRsZXIsCi0JCQkgICB2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2RhdGEpCi17Ci0Jc3RydWN0IGVsb29wX3RpbWVvdXQgKnRpbWVvdXQsICp0bXA7Ci0Jb3NfdGltZV90IG5vd19zZWM7Ci0KLQl0aW1lb3V0ID0gb3NfemFsbG9jKHNpemVvZigqdGltZW91dCkpOwotCWlmICh0aW1lb3V0ID09IE5VTEwpCi0JCXJldHVybiAtMTsKLQlpZiAob3NfZ2V0X3RpbWUoJnRpbWVvdXQtPnRpbWUpIDwgMCkgewotCQlvc19mcmVlKHRpbWVvdXQpOwotCQlyZXR1cm4gLTE7Ci0JfQotCW5vd19zZWMgPSB0aW1lb3V0LT50aW1lLnNlYzsKLQl0aW1lb3V0LT50aW1lLnNlYyArPSBzZWNzOwotCWlmICh0aW1lb3V0LT50aW1lLnNlYyA8IG5vd19zZWMpIHsKLQkJLyoKLQkJICogSW50ZWdlciBvdmVyZmxvdyAtIGFzc3VtZSBsb25nIGVub3VnaCB0aW1lb3V0IHRvIGJlIGFzc3VtZWQKLQkJICogdG8gYmUgaW5maW5pdGUsIGkuZS4sIHRoZSB0aW1lb3V0IHdvdWxkIG5ldmVyIGhhcHBlbi4KLQkJICovCi0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUxPT1A6IFRvbyBsb25nIHRpbWVvdXQgKHNlY3M9JXUpIHRvICIKLQkJCSAgICJldmVyIGhhcHBlbiAtIGlnbm9yZSBpdCIsIHNlY3MpOwotCQlvc19mcmVlKHRpbWVvdXQpOwotCQlyZXR1cm4gMDsKLQl9Ci0JdGltZW91dC0+dGltZS51c2VjICs9IHVzZWNzOwotCXdoaWxlICh0aW1lb3V0LT50aW1lLnVzZWMgPj0gMTAwMDAwMCkgewotCQl0aW1lb3V0LT50aW1lLnNlYysrOwotCQl0aW1lb3V0LT50aW1lLnVzZWMgLT0gMTAwMDAwMDsKLQl9Ci0JdGltZW91dC0+ZWxvb3BfZGF0YSA9IGVsb29wX2RhdGE7Ci0JdGltZW91dC0+dXNlcl9kYXRhID0gdXNlcl9kYXRhOwotCXRpbWVvdXQtPmhhbmRsZXIgPSBoYW5kbGVyOwotCi0JLyogTWFpbnRhaW4gdGltZW91dHMgaW4gb3JkZXIgb2YgaW5jcmVhc2luZyB0aW1lICovCi0JZGxfbGlzdF9mb3JfZWFjaCh0bXAsICZlbG9vcC50aW1lb3V0LCBzdHJ1Y3QgZWxvb3BfdGltZW91dCwgbGlzdCkgewotCQlpZiAob3NfdGltZV9iZWZvcmUoJnRpbWVvdXQtPnRpbWUsICZ0bXAtPnRpbWUpKSB7Ci0JCQlkbF9saXN0X2FkZCh0bXAtPmxpc3QucHJldiwgJnRpbWVvdXQtPmxpc3QpOwotCQkJcmV0dXJuIDA7Ci0JCX0KLQl9Ci0JZGxfbGlzdF9hZGRfdGFpbCgmZWxvb3AudGltZW91dCwgJnRpbWVvdXQtPmxpc3QpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLQotc3RhdGljIHZvaWQgZWxvb3BfcmVtb3ZlX3RpbWVvdXQoc3RydWN0IGVsb29wX3RpbWVvdXQgKnRpbWVvdXQpCi17Ci0JZGxfbGlzdF9kZWwoJnRpbWVvdXQtPmxpc3QpOwotCW9zX2ZyZWUodGltZW91dCk7Ci19Ci0KLQotaW50IGVsb29wX2NhbmNlbF90aW1lb3V0KGVsb29wX3RpbWVvdXRfaGFuZGxlciBoYW5kbGVyLAotCQkJIHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfZGF0YSkKLXsKLQlzdHJ1Y3QgZWxvb3BfdGltZW91dCAqdGltZW91dCwgKnByZXY7Ci0JaW50IHJlbW92ZWQgPSAwOwotCi0JZGxfbGlzdF9mb3JfZWFjaF9zYWZlKHRpbWVvdXQsIHByZXYsICZlbG9vcC50aW1lb3V0LAotCQkJICAgICAgc3RydWN0IGVsb29wX3RpbWVvdXQsIGxpc3QpIHsKLQkJaWYgKHRpbWVvdXQtPmhhbmRsZXIgPT0gaGFuZGxlciAmJgotCQkgICAgKHRpbWVvdXQtPmVsb29wX2RhdGEgPT0gZWxvb3BfZGF0YSB8fAotCQkgICAgIGVsb29wX2RhdGEgPT0gRUxPT1BfQUxMX0NUWCkgJiYKLQkJICAgICh0aW1lb3V0LT51c2VyX2RhdGEgPT0gdXNlcl9kYXRhIHx8Ci0JCSAgICAgdXNlcl9kYXRhID09IEVMT09QX0FMTF9DVFgpKSB7Ci0JCQllbG9vcF9yZW1vdmVfdGltZW91dCh0aW1lb3V0KTsKLQkJCXJlbW92ZWQrKzsKLQkJfQotCX0KLQotCXJldHVybiByZW1vdmVkOwotfQotCi0KLWludCBlbG9vcF9jYW5jZWxfdGltZW91dF9vbmUoZWxvb3BfdGltZW91dF9oYW5kbGVyIGhhbmRsZXIsCi0JCQkgICAgIHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfZGF0YSwKLQkJCSAgICAgc3RydWN0IG9zX3RpbWUgKnJlbWFpbmluZykKLXsKLQlzdHJ1Y3QgZWxvb3BfdGltZW91dCAqdGltZW91dCwgKnByZXY7Ci0JaW50IHJlbW92ZWQgPSAwOwotCXN0cnVjdCBvc190aW1lIG5vdzsKLQotCW9zX2dldF90aW1lKCZub3cpOwotCXJlbWFpbmluZy0+c2VjID0gcmVtYWluaW5nLT51c2VjID0gMDsKLQotCWRsX2xpc3RfZm9yX2VhY2hfc2FmZSh0aW1lb3V0LCBwcmV2LCAmZWxvb3AudGltZW91dCwKLQkJCSAgICAgIHN0cnVjdCBlbG9vcF90aW1lb3V0LCBsaXN0KSB7Ci0JCWlmICh0aW1lb3V0LT5oYW5kbGVyID09IGhhbmRsZXIgJiYKLQkJICAgICh0aW1lb3V0LT5lbG9vcF9kYXRhID09IGVsb29wX2RhdGEpICYmCi0JCSAgICAodGltZW91dC0+dXNlcl9kYXRhID09IHVzZXJfZGF0YSkpIHsKLQkJCXJlbW92ZWQgPSAxOwotCQkJaWYgKG9zX3RpbWVfYmVmb3JlKCZub3csICZ0aW1lb3V0LT50aW1lKSkKLQkJCQlvc190aW1lX3N1YigmdGltZW91dC0+dGltZSwgJm5vdywgcmVtYWluaW5nKTsKLQkJCWVsb29wX3JlbW92ZV90aW1lb3V0KHRpbWVvdXQpOwotCQkJYnJlYWs7Ci0JCX0KLQl9Ci0JcmV0dXJuIHJlbW92ZWQ7Ci19Ci0KLQotaW50IGVsb29wX2lzX3RpbWVvdXRfcmVnaXN0ZXJlZChlbG9vcF90aW1lb3V0X2hhbmRsZXIgaGFuZGxlciwKLQkJCQl2b2lkICplbG9vcF9kYXRhLCB2b2lkICp1c2VyX2RhdGEpCi17Ci0Jc3RydWN0IGVsb29wX3RpbWVvdXQgKnRtcDsKLQotCWRsX2xpc3RfZm9yX2VhY2godG1wLCAmZWxvb3AudGltZW91dCwgc3RydWN0IGVsb29wX3RpbWVvdXQsIGxpc3QpIHsKLQkJaWYgKHRtcC0+aGFuZGxlciA9PSBoYW5kbGVyICYmCi0JCSAgICB0bXAtPmVsb29wX2RhdGEgPT0gZWxvb3BfZGF0YSAmJgotCQkgICAgdG1wLT51c2VyX2RhdGEgPT0gdXNlcl9kYXRhKQotCQkJcmV0dXJuIDE7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLQotLyogVE9ETzogcmVwbGFjZSB3aXRoIHN1aXRhYmxlIHNpZ25hbCBoYW5kbGVyICovCi0jaWYgMAotc3RhdGljIHZvaWQgZWxvb3BfaGFuZGxlX3NpZ25hbChpbnQgc2lnKQotewotCWludCBpOwotCi0JZWxvb3Auc2lnbmFsZWQrKzsKLQlmb3IgKGkgPSAwOyBpIDwgZWxvb3Auc2lnbmFsX2NvdW50OyBpKyspIHsKLQkJaWYgKGVsb29wLnNpZ25hbHNbaV0uc2lnID09IHNpZykgewotCQkJZWxvb3Auc2lnbmFsc1tpXS5zaWduYWxlZCsrOwotCQkJYnJlYWs7Ci0JCX0KLQl9Ci19Ci0jZW5kaWYKLQotCi1zdGF0aWMgdm9pZCBlbG9vcF9wcm9jZXNzX3BlbmRpbmdfc2lnbmFscyh2b2lkKQotewotCWludCBpOwotCi0JaWYgKGVsb29wLnNpZ25hbGVkID09IDApCi0JCXJldHVybjsKLQllbG9vcC5zaWduYWxlZCA9IDA7Ci0KLQlpZiAoZWxvb3AucGVuZGluZ190ZXJtaW5hdGUpIHsKLQkJZWxvb3AucGVuZGluZ190ZXJtaW5hdGUgPSAwOwotCX0KLQotCWZvciAoaSA9IDA7IGkgPCBlbG9vcC5zaWduYWxfY291bnQ7IGkrKykgewotCQlpZiAoZWxvb3Auc2lnbmFsc1tpXS5zaWduYWxlZCkgewotCQkJZWxvb3Auc2lnbmFsc1tpXS5zaWduYWxlZCA9IDA7Ci0JCQllbG9vcC5zaWduYWxzW2ldLmhhbmRsZXIoZWxvb3Auc2lnbmFsc1tpXS5zaWcsCi0JCQkJCQkgZWxvb3Auc2lnbmFsc1tpXS51c2VyX2RhdGEpOwotCQl9Ci0JfQotfQotCi0KLWludCBlbG9vcF9yZWdpc3Rlcl9zaWduYWwoaW50IHNpZywgZWxvb3Bfc2lnbmFsX2hhbmRsZXIgaGFuZGxlciwKLQkJCSAgdm9pZCAqdXNlcl9kYXRhKQotewotCXN0cnVjdCBlbG9vcF9zaWduYWwgKnRtcDsKLQotCXRtcCA9IG9zX3JlYWxsb2NfYXJyYXkoZWxvb3Auc2lnbmFscywgZWxvb3Auc2lnbmFsX2NvdW50ICsgMSwKLQkJCSAgICAgICBzaXplb2Yoc3RydWN0IGVsb29wX3NpZ25hbCkpOwotCWlmICh0bXAgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwotCi0JdG1wW2Vsb29wLnNpZ25hbF9jb3VudF0uc2lnID0gc2lnOwotCXRtcFtlbG9vcC5zaWduYWxfY291bnRdLnVzZXJfZGF0YSA9IHVzZXJfZGF0YTsKLQl0bXBbZWxvb3Auc2lnbmFsX2NvdW50XS5oYW5kbGVyID0gaGFuZGxlcjsKLQl0bXBbZWxvb3Auc2lnbmFsX2NvdW50XS5zaWduYWxlZCA9IDA7Ci0JZWxvb3Auc2lnbmFsX2NvdW50Kys7Ci0JZWxvb3Auc2lnbmFscyA9IHRtcDsKLQotCS8qIFRPRE86IHJlZ2lzdGVyIHNpZ25hbCBoYW5kbGVyICovCi0KLQlyZXR1cm4gMDsKLX0KLQotCi1pbnQgZWxvb3BfcmVnaXN0ZXJfc2lnbmFsX3Rlcm1pbmF0ZShlbG9vcF9zaWduYWxfaGFuZGxlciBoYW5kbGVyLAotCQkJCSAgICB2b2lkICp1c2VyX2RhdGEpCi17Ci0jaWYgMAotCS8qIFRPRE86IGZvciBleGFtcGxlICovCi0JaW50IHJldCA9IGVsb29wX3JlZ2lzdGVyX3NpZ25hbChTSUdJTlQsIGhhbmRsZXIsIHVzZXJfZGF0YSk7Ci0JaWYgKHJldCA9PSAwKQotCQlyZXQgPSBlbG9vcF9yZWdpc3Rlcl9zaWduYWwoU0lHVEVSTSwgaGFuZGxlciwgdXNlcl9kYXRhKTsKLQlyZXR1cm4gcmV0OwotI2VuZGlmCi0JcmV0dXJuIDA7Ci19Ci0KLQotaW50IGVsb29wX3JlZ2lzdGVyX3NpZ25hbF9yZWNvbmZpZyhlbG9vcF9zaWduYWxfaGFuZGxlciBoYW5kbGVyLAotCQkJCSAgIHZvaWQgKnVzZXJfZGF0YSkKLXsKLSNpZiAwCi0JLyogVE9ETzogZm9yIGV4YW1wbGUgKi8KLQlyZXR1cm4gZWxvb3BfcmVnaXN0ZXJfc2lnbmFsKFNJR0hVUCwgaGFuZGxlciwgdXNlcl9kYXRhKTsKLSNlbmRpZgotCXJldHVybiAwOwotfQotCi0KLXZvaWQgZWxvb3BfcnVuKHZvaWQpCi17Ci0JaW50IGk7Ci0Jc3RydWN0IG9zX3RpbWUgdHYsIG5vdzsKLQotCXdoaWxlICghZWxvb3AudGVybWluYXRlICYmCi0JCSghZGxfbGlzdF9lbXB0eSgmZWxvb3AudGltZW91dCkgfHwgZWxvb3AucmVhZGVyX2NvdW50ID4gMCkpIHsKLQkJc3RydWN0IGVsb29wX3RpbWVvdXQgKnRpbWVvdXQ7Ci0JCXRpbWVvdXQgPSBkbF9saXN0X2ZpcnN0KCZlbG9vcC50aW1lb3V0LCBzdHJ1Y3QgZWxvb3BfdGltZW91dCwKLQkJCQkJbGlzdCk7Ci0JCWlmICh0aW1lb3V0KSB7Ci0JCQlvc19nZXRfdGltZSgmbm93KTsKLQkJCWlmIChvc190aW1lX2JlZm9yZSgmbm93LCAmdGltZW91dC0+dGltZSkpCi0JCQkJb3NfdGltZV9zdWIoJnRpbWVvdXQtPnRpbWUsICZub3csICZ0dik7Ci0JCQllbHNlCi0JCQkJdHYuc2VjID0gdHYudXNlYyA9IDA7Ci0JCX0KLQotCQkvKgotCQkgKiBUT0RPOiB3YWl0IGZvciBhbnkgZXZlbnQgKHJlYWQgc29ja2V0IHJlYWR5LCB0aW1lb3V0ICh0diksCi0JCSAqIHNpZ25hbAotCQkgKi8KLQkJb3Nfc2xlZXAoMSwgMCk7IC8qIGp1c3QgYSBkdW1teSB3YWl0IGZvciB0ZXN0aW5nICovCi0KLQkJZWxvb3BfcHJvY2Vzc19wZW5kaW5nX3NpZ25hbHMoKTsKLQotCQkvKiBjaGVjayBpZiBzb21lIHJlZ2lzdGVyZWQgdGltZW91dHMgaGF2ZSBvY2N1cnJlZCAqLwotCQl0aW1lb3V0ID0gZGxfbGlzdF9maXJzdCgmZWxvb3AudGltZW91dCwgc3RydWN0IGVsb29wX3RpbWVvdXQsCi0JCQkJCWxpc3QpOwotCQlpZiAodGltZW91dCkgewotCQkJb3NfZ2V0X3RpbWUoJm5vdyk7Ci0JCQlpZiAoIW9zX3RpbWVfYmVmb3JlKCZub3csICZ0aW1lb3V0LT50aW1lKSkgewotCQkJCXZvaWQgKmVsb29wX2RhdGEgPSB0aW1lb3V0LT5lbG9vcF9kYXRhOwotCQkJCXZvaWQgKnVzZXJfZGF0YSA9IHRpbWVvdXQtPnVzZXJfZGF0YTsKLQkJCQllbG9vcF90aW1lb3V0X2hhbmRsZXIgaGFuZGxlciA9Ci0JCQkJCXRpbWVvdXQtPmhhbmRsZXI7Ci0JCQkJZWxvb3BfcmVtb3ZlX3RpbWVvdXQodGltZW91dCk7Ci0JCQkJaGFuZGxlcihlbG9vcF9kYXRhLCB1c2VyX2RhdGEpOwotCQkJfQotCi0JCX0KLQotCQllbG9vcC5yZWFkZXJfdGFibGVfY2hhbmdlZCA9IDA7Ci0JCWZvciAoaSA9IDA7IGkgPCBlbG9vcC5yZWFkZXJfY291bnQ7IGkrKykgewotCQkJLyoKLQkJCSAqIFRPRE86IGNhbGwgZWFjaCBoYW5kbGVyIHRoYXQgaGFzIHBlbmRpbmcgZGF0YSB0bwotCQkJICogcmVhZAotCQkJICovCi0JCQlpZiAoMCAvKiBUT0RPOiBlbG9vcC5yZWFkZXJzW2ldLnNvY2sgcmVhZHkgKi8pIHsKLQkJCQllbG9vcC5yZWFkZXJzW2ldLmhhbmRsZXIoCi0JCQkJCWVsb29wLnJlYWRlcnNbaV0uc29jaywKLQkJCQkJZWxvb3AucmVhZGVyc1tpXS5lbG9vcF9kYXRhLAotCQkJCQllbG9vcC5yZWFkZXJzW2ldLnVzZXJfZGF0YSk7Ci0JCQkJaWYgKGVsb29wLnJlYWRlcl90YWJsZV9jaGFuZ2VkKQotCQkJCQlicmVhazsKLQkJCX0KLQkJfQotCX0KLX0KLQotCi12b2lkIGVsb29wX3Rlcm1pbmF0ZSh2b2lkKQotewotCWVsb29wLnRlcm1pbmF0ZSA9IDE7Ci19Ci0KLQotdm9pZCBlbG9vcF9kZXN0cm95KHZvaWQpCi17Ci0Jc3RydWN0IGVsb29wX3RpbWVvdXQgKnRpbWVvdXQsICpwcmV2OwotCi0JZGxfbGlzdF9mb3JfZWFjaF9zYWZlKHRpbWVvdXQsIHByZXYsICZlbG9vcC50aW1lb3V0LAotCQkJICAgICAgc3RydWN0IGVsb29wX3RpbWVvdXQsIGxpc3QpIHsKLQkJZWxvb3BfcmVtb3ZlX3RpbWVvdXQodGltZW91dCk7Ci0JfQotCW9zX2ZyZWUoZWxvb3AucmVhZGVycyk7Ci0Jb3NfZnJlZShlbG9vcC5zaWduYWxzKTsKLX0KLQotCi1pbnQgZWxvb3BfdGVybWluYXRlZCh2b2lkKQotewotCXJldHVybiBlbG9vcC50ZXJtaW5hdGU7Ci19Ci0KLQotdm9pZCBlbG9vcF93YWl0X2Zvcl9yZWFkX3NvY2soaW50IHNvY2spCi17Ci0JLyoKLQkgKiBUT0RPOiB3YWl0IGZvciB0aGUgZmlsZSBkZXNjcmlwdG9yIHRvIGhhdmUgc29tZXRoaW5nIGF2YWlsYWJsZSBmb3IKLQkgKiByZWFkaW5nCi0JICovCi19CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvZWxvb3Bfd2luLmMgYi9zcmMvdXRpbHMvZWxvb3Bfd2luLmMKaW5kZXggZWRhNDEyZi4uZGU0N2ZiMiAxMDA2NDQKLS0tIGEvc3JjL3V0aWxzL2Vsb29wX3dpbi5jCisrKyBiL3NyYy91dGlscy9lbG9vcF93aW4uYwpAQCAtMzEsNyArMzEsNyBAQAogCiBzdHJ1Y3QgZWxvb3BfdGltZW91dCB7CiAJc3RydWN0IGRsX2xpc3QgbGlzdDsKLQlzdHJ1Y3Qgb3NfdGltZSB0aW1lOworCXN0cnVjdCBvc19yZWx0aW1lIHRpbWU7CiAJdm9pZCAqZWxvb3BfZGF0YTsKIAl2b2lkICp1c2VyX2RhdGE7CiAJZWxvb3BfdGltZW91dF9oYW5kbGVyIGhhbmRsZXI7CkBAIC0yNDQsNyArMjQ0LDcgQEAKIAl0aW1lb3V0ID0gb3NfemFsbG9jKHNpemVvZigqdGltZW91dCkpOwogCWlmICh0aW1lb3V0ID09IE5VTEwpCiAJCXJldHVybiAtMTsKLQlpZiAob3NfZ2V0X3RpbWUoJnRpbWVvdXQtPnRpbWUpIDwgMCkgeworCWlmIChvc19nZXRfcmVsdGltZSgmdGltZW91dC0+dGltZSkgPCAwKSB7CiAJCW9zX2ZyZWUodGltZW91dCk7CiAJCXJldHVybiAtMTsKIAl9CkBAIC0yNzEsNyArMjcxLDcgQEAKIAogCS8qIE1haW50YWluIHRpbWVvdXRzIGluIG9yZGVyIG9mIGluY3JlYXNpbmcgdGltZSAqLwogCWRsX2xpc3RfZm9yX2VhY2godG1wLCAmZWxvb3AudGltZW91dCwgc3RydWN0IGVsb29wX3RpbWVvdXQsIGxpc3QpIHsKLQkJaWYgKG9zX3RpbWVfYmVmb3JlKCZ0aW1lb3V0LT50aW1lLCAmdG1wLT50aW1lKSkgeworCQlpZiAob3NfcmVsdGltZV9iZWZvcmUoJnRpbWVvdXQtPnRpbWUsICZ0bXAtPnRpbWUpKSB7CiAJCQlkbF9saXN0X2FkZCh0bXAtPmxpc3QucHJldiwgJnRpbWVvdXQtPmxpc3QpOwogCQkJcmV0dXJuIDA7CiAJCX0KQEAgLTMxMywxMyArMzEzLDEzIEBACiAKIGludCBlbG9vcF9jYW5jZWxfdGltZW91dF9vbmUoZWxvb3BfdGltZW91dF9oYW5kbGVyIGhhbmRsZXIsCiAJCQkgICAgIHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfZGF0YSwKLQkJCSAgICAgc3RydWN0IG9zX3RpbWUgKnJlbWFpbmluZykKKwkJCSAgICAgc3RydWN0IG9zX3JlbHRpbWUgKnJlbWFpbmluZykKIHsKIAlzdHJ1Y3QgZWxvb3BfdGltZW91dCAqdGltZW91dCwgKnByZXY7CiAJaW50IHJlbW92ZWQgPSAwOwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAlyZW1haW5pbmctPnNlYyA9IHJlbWFpbmluZy0+dXNlYyA9IDA7CiAKIAlkbF9saXN0X2Zvcl9lYWNoX3NhZmUodGltZW91dCwgcHJldiwgJmVsb29wLnRpbWVvdXQsCkBAIC0zMjgsOCArMzI4LDggQEAKIAkJICAgICh0aW1lb3V0LT5lbG9vcF9kYXRhID09IGVsb29wX2RhdGEpICYmCiAJCSAgICAodGltZW91dC0+dXNlcl9kYXRhID09IHVzZXJfZGF0YSkpIHsKIAkJCXJlbW92ZWQgPSAxOwotCQkJaWYgKG9zX3RpbWVfYmVmb3JlKCZub3csICZ0aW1lb3V0LT50aW1lKSkKLQkJCQlvc190aW1lX3N1YigmdGltZW91dC0+dGltZSwgJm5vdywgcmVtYWluaW5nKTsKKwkJCWlmIChvc19yZWx0aW1lX2JlZm9yZSgmbm93LCAmdGltZW91dC0+dGltZSkpCisJCQkJb3NfcmVsdGltZV9zdWIoJnRpbWVvdXQtPnRpbWUsICZub3csIHJlbWFpbmluZyk7CiAJCQllbG9vcF9yZW1vdmVfdGltZW91dCh0aW1lb3V0KTsKIAkJCWJyZWFrOwogCQl9CkBAIC0zNTQsNiArMzU0LDcwIEBACiB9CiAKIAoraW50IGVsb29wX2RlcGxldGVfdGltZW91dCh1bnNpZ25lZCBpbnQgcmVxX3NlY3MsIHVuc2lnbmVkIGludCByZXFfdXNlY3MsCisJCQkgIGVsb29wX3RpbWVvdXRfaGFuZGxlciBoYW5kbGVyLCB2b2lkICplbG9vcF9kYXRhLAorCQkJICB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93LCByZXF1ZXN0ZWQsIHJlbWFpbmluZzsKKwlzdHJ1Y3QgZWxvb3BfdGltZW91dCAqdG1wOworCisJZGxfbGlzdF9mb3JfZWFjaCh0bXAsICZlbG9vcC50aW1lb3V0LCBzdHJ1Y3QgZWxvb3BfdGltZW91dCwgbGlzdCkgeworCQlpZiAodG1wLT5oYW5kbGVyID09IGhhbmRsZXIgJiYKKwkJICAgIHRtcC0+ZWxvb3BfZGF0YSA9PSBlbG9vcF9kYXRhICYmCisJCSAgICB0bXAtPnVzZXJfZGF0YSA9PSB1c2VyX2RhdGEpIHsKKwkJCXJlcXVlc3RlZC5zZWMgPSByZXFfc2VjczsKKwkJCXJlcXVlc3RlZC51c2VjID0gcmVxX3VzZWNzOworCQkJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CisJCQlvc19yZWx0aW1lX3N1YigmdG1wLT50aW1lLCAmbm93LCAmcmVtYWluaW5nKTsKKwkJCWlmIChvc19yZWx0aW1lX2JlZm9yZSgmcmVxdWVzdGVkLCAmcmVtYWluaW5nKSkgeworCQkJCWVsb29wX2NhbmNlbF90aW1lb3V0KGhhbmRsZXIsIGVsb29wX2RhdGEsCisJCQkJCQkgICAgIHVzZXJfZGF0YSk7CisJCQkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChyZXF1ZXN0ZWQuc2VjLAorCQkJCQkJICAgICAgIHJlcXVlc3RlZC51c2VjLAorCQkJCQkJICAgICAgIGhhbmRsZXIsIGVsb29wX2RhdGEsCisJCQkJCQkgICAgICAgdXNlcl9kYXRhKTsKKwkJCQlyZXR1cm4gMTsKKwkJCX0KKwkJCXJldHVybiAwOworCQl9CisJfQorCisJcmV0dXJuIC0xOworfQorCisKK2ludCBlbG9vcF9yZXBsZW5pc2hfdGltZW91dCh1bnNpZ25lZCBpbnQgcmVxX3NlY3MsIHVuc2lnbmVkIGludCByZXFfdXNlY3MsCisJCQkgICAgZWxvb3BfdGltZW91dF9oYW5kbGVyIGhhbmRsZXIsIHZvaWQgKmVsb29wX2RhdGEsCisJCQkgICAgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCBvc19yZWx0aW1lIG5vdywgcmVxdWVzdGVkLCByZW1haW5pbmc7CisJc3RydWN0IGVsb29wX3RpbWVvdXQgKnRtcDsKKworCWRsX2xpc3RfZm9yX2VhY2godG1wLCAmZWxvb3AudGltZW91dCwgc3RydWN0IGVsb29wX3RpbWVvdXQsIGxpc3QpIHsKKwkJaWYgKHRtcC0+aGFuZGxlciA9PSBoYW5kbGVyICYmCisJCSAgICB0bXAtPmVsb29wX2RhdGEgPT0gZWxvb3BfZGF0YSAmJgorCQkgICAgdG1wLT51c2VyX2RhdGEgPT0gdXNlcl9kYXRhKSB7CisJCQlyZXF1ZXN0ZWQuc2VjID0gcmVxX3NlY3M7CisJCQlyZXF1ZXN0ZWQudXNlYyA9IHJlcV91c2VjczsKKwkJCW9zX2dldF9yZWx0aW1lKCZub3cpOworCQkJb3NfcmVsdGltZV9zdWIoJnRtcC0+dGltZSwgJm5vdywgJnJlbWFpbmluZyk7CisJCQlpZiAob3NfcmVsdGltZV9iZWZvcmUoJnJlbWFpbmluZywgJnJlcXVlc3RlZCkpIHsKKwkJCQllbG9vcF9jYW5jZWxfdGltZW91dChoYW5kbGVyLCBlbG9vcF9kYXRhLAorCQkJCQkJICAgICB1c2VyX2RhdGEpOworCQkJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQocmVxdWVzdGVkLnNlYywKKwkJCQkJCSAgICAgICByZXF1ZXN0ZWQudXNlYywKKwkJCQkJCSAgICAgICBoYW5kbGVyLCBlbG9vcF9kYXRhLAorCQkJCQkJICAgICAgIHVzZXJfZGF0YSk7CisJCQkJcmV0dXJuIDE7CisJCQl9CisJCQlyZXR1cm4gMDsKKwkJfQorCX0KKworCXJldHVybiAtMTsKK30KKworCiAvKiBUT0RPOiByZXBsYWNlIHdpdGggc3VpdGFibGUgc2lnbmFsIGhhbmRsZXIgKi8KICNpZiAwCiBzdGF0aWMgdm9pZCBlbG9vcF9oYW5kbGVfc2lnbmFsKGludCBzaWcpCkBAIC00NjgsNyArNTMyLDcgQEAKIAogdm9pZCBlbG9vcF9ydW4odm9pZCkKIHsKLQlzdHJ1Y3Qgb3NfdGltZSB0diwgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIHR2LCBub3c7CiAJRFdPUkQgY291bnQsIHJldCwgdGltZW91dF92YWwsIGVycjsKIAlzaXplX3QgaTsKIApAQCAtNDgwLDkgKzU0NCw5IEBACiAJCXRpbWVvdXQgPSBkbF9saXN0X2ZpcnN0KCZlbG9vcC50aW1lb3V0LCBzdHJ1Y3QgZWxvb3BfdGltZW91dCwKIAkJCQkJbGlzdCk7CiAJCWlmICh0aW1lb3V0KSB7Ci0JCQlvc19nZXRfdGltZSgmbm93KTsKLQkJCWlmIChvc190aW1lX2JlZm9yZSgmbm93LCAmdGltZW91dC0+dGltZSkpCi0JCQkJb3NfdGltZV9zdWIoJnRpbWVvdXQtPnRpbWUsICZub3csICZ0dik7CisJCQlvc19nZXRfcmVsdGltZSgmbm93KTsKKwkJCWlmIChvc19yZWx0aW1lX2JlZm9yZSgmbm93LCAmdGltZW91dC0+dGltZSkpCisJCQkJb3NfcmVsdGltZV9zdWIoJnRpbWVvdXQtPnRpbWUsICZub3csICZ0dik7CiAJCX0KIAogCQljb3VudCA9IDA7CkBAIC01MjEsOCArNTg1LDggQEAKIAkJdGltZW91dCA9IGRsX2xpc3RfZmlyc3QoJmVsb29wLnRpbWVvdXQsIHN0cnVjdCBlbG9vcF90aW1lb3V0LAogCQkJCQlsaXN0KTsKIAkJaWYgKHRpbWVvdXQpIHsKLQkJCW9zX2dldF90aW1lKCZub3cpOwotCQkJaWYgKCFvc190aW1lX2JlZm9yZSgmbm93LCAmdGltZW91dC0+dGltZSkpIHsKKwkJCW9zX2dldF9yZWx0aW1lKCZub3cpOworCQkJaWYgKCFvc19yZWx0aW1lX2JlZm9yZSgmbm93LCAmdGltZW91dC0+dGltZSkpIHsKIAkJCQl2b2lkICplbG9vcF9kYXRhID0gdGltZW91dC0+ZWxvb3BfZGF0YTsKIAkJCQl2b2lkICp1c2VyX2RhdGEgPSB0aW1lb3V0LT51c2VyX2RhdGE7CiAJCQkJZWxvb3BfdGltZW91dF9oYW5kbGVyIGhhbmRsZXIgPQpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2V4dF9wYXNzd29yZF90ZXN0LmMgYi9zcmMvdXRpbHMvZXh0X3Bhc3N3b3JkX3Rlc3QuYwppbmRleCAzODAxYmI4Li5iM2E0NTUyIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvZXh0X3Bhc3N3b3JkX3Rlc3QuYworKysgYi9zcmMvdXRpbHMvZXh0X3Bhc3N3b3JkX3Rlc3QuYwpAQCAtMzYsNyArMzYsNyBAQAogewogCXN0cnVjdCBleHRfcGFzc3dvcmRfdGVzdF9kYXRhICpkYXRhID0gY3R4OwogCi0Jb3NfZnJlZShkYXRhLT5wYXJhbXMpOworCXN0cl9jbGVhcl9mcmVlKGRhdGEtPnBhcmFtcyk7CiAJb3NfZnJlZShkYXRhKTsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2h0dHAtdXRpbHMuaCBiL3NyYy91dGlscy9odHRwLXV0aWxzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGQ0Mzk5YQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy91dGlscy9odHRwLXV0aWxzLmgKQEAgLTAsMCArMSw2MyBAQAorLyoKKyAqIEhUVFAgd3JhcHBlcgorICogQ29weXJpZ2h0IChjKSAyMDEyLTIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgSFRUUF9VVElMU19ICisjZGVmaW5lIEhUVFBfVVRJTFNfSAorCitzdHJ1Y3QgaHR0cF9jdHg7CisKK3N0cnVjdCBodHRwX290aGVybmFtZSB7CisJY2hhciAqb2lkOworCXU4ICpkYXRhOworCXNpemVfdCBsZW47Cit9OworCisjZGVmaW5lIEhUVFBfTUFYX0NFUlRfTE9HT19IQVNIIDMyCisKK3N0cnVjdCBodHRwX2xvZ28geworCWNoYXIgKmFsZ19vaWQ7CisJdTggKmhhc2g7CisJc2l6ZV90IGhhc2hfbGVuOworCWNoYXIgKnVyaTsKK307CisKK3N0cnVjdCBodHRwX2NlcnQgeworCWNoYXIgKipkbnNuYW1lOworCXVuc2lnbmVkIGludCBudW1fZG5zbmFtZTsKKwlzdHJ1Y3QgaHR0cF9vdGhlcm5hbWUgKm90aGVybmFtZTsKKwl1bnNpZ25lZCBpbnQgbnVtX290aGVybmFtZTsKKwlzdHJ1Y3QgaHR0cF9sb2dvICpsb2dvOworCXVuc2lnbmVkIGludCBudW1fbG9nbzsKK307CisKK2ludCBzb2FwX2luaXRfY2xpZW50KHN0cnVjdCBodHRwX2N0eCAqY3R4LCBjb25zdCBjaGFyICphZGRyZXNzLAorCQkgICAgIGNvbnN0IGNoYXIgKmNhX2ZuYW1lLCBjb25zdCBjaGFyICp1c2VybmFtZSwKKwkJICAgICBjb25zdCBjaGFyICpwYXNzd29yZCwgY29uc3QgY2hhciAqY2xpZW50X2NlcnQsCisJCSAgICAgY29uc3QgY2hhciAqY2xpZW50X2tleSk7CitpbnQgc29hcF9yZWluaXRfY2xpZW50KHN0cnVjdCBodHRwX2N0eCAqY3R4KTsKK3htbF9ub2RlX3QgKiBzb2FwX3NlbmRfcmVjZWl2ZShzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSk7CisKK3N0cnVjdCBodHRwX2N0eCAqIGh0dHBfaW5pdF9jdHgodm9pZCAqdXBwZXJfY3R4LCBzdHJ1Y3QgeG1sX25vZGVfY3R4ICp4bWxfY3R4KTsKK3ZvaWQgaHR0cF9vY3NwX3NldChzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgaW50IHZhbCk7Cit2b2lkIGh0dHBfZGVpbml0X2N0eChzdHJ1Y3QgaHR0cF9jdHggKmN0eCk7CisKK2ludCBodHRwX2Rvd25sb2FkX2ZpbGUoc3RydWN0IGh0dHBfY3R4ICpjdHgsIGNvbnN0IGNoYXIgKnVybCwKKwkJICAgICAgIGNvbnN0IGNoYXIgKmZuYW1lLCBjb25zdCBjaGFyICpjYV9mbmFtZSk7CitjaGFyICogaHR0cF9wb3N0KHN0cnVjdCBodHRwX2N0eCAqY3R4LCBjb25zdCBjaGFyICp1cmwsIGNvbnN0IGNoYXIgKmRhdGEsCisJCSBjb25zdCBjaGFyICpjb250ZW50X3R5cGUsIGNvbnN0IGNoYXIgKmV4dF9oZHIsCisJCSBjb25zdCBjaGFyICpjYV9mbmFtZSwKKwkJIGNvbnN0IGNoYXIgKnVzZXJuYW1lLCBjb25zdCBjaGFyICpwYXNzd29yZCwKKwkJIGNvbnN0IGNoYXIgKmNsaWVudF9jZXJ0LCBjb25zdCBjaGFyICpjbGllbnRfa2V5LAorCQkgc2l6ZV90ICpyZXNwX2xlbik7Cit2b2lkIGh0dHBfc2V0X2NlcnRfY2Ioc3RydWN0IGh0dHBfY3R4ICpjdHgsCisJCSAgICAgIGludCAoKmNiKSh2b2lkICpjdHgsIHN0cnVjdCBodHRwX2NlcnQgKmNlcnQpLAorCQkgICAgICB2b2lkICpjYl9jdHgpOworY29uc3QgY2hhciAqIGh0dHBfZ2V0X2VycihzdHJ1Y3QgaHR0cF9jdHggKmN0eCk7Cit2b2lkIGh0dHBfcGFyc2VfeDUwOV9jZXJ0aWZpY2F0ZShzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgY29uc3QgY2hhciAqZm5hbWUpOworCisjZW5kaWYgLyogSFRUUF9VVElMU19IICovCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvaHR0cF9jdXJsLmMgYi9zcmMvdXRpbHMvaHR0cF9jdXJsLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWI3OWI4NgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy91dGlscy9odHRwX2N1cmwuYwpAQCAtMCwwICsxLDE2NDEgQEAKKy8qCisgKiBIVFRQIHdyYXBwZXIgZm9yIGxpYmN1cmwKKyAqIENvcHlyaWdodCAoYykgMjAxMi0yMDE0LCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKyNpbmNsdWRlIDxjdXJsL2N1cmwuaD4KKyNpZmRlZiBFQVBfVExTX09QRU5TU0wKKyNpbmNsdWRlIDxvcGVuc3NsL3NzbC5oPgorI2luY2x1ZGUgPG9wZW5zc2wvYXNuMS5oPgorI2luY2x1ZGUgPG9wZW5zc2wvYXNuMXQuaD4KKyNpbmNsdWRlIDxvcGVuc3NsL3g1MDl2My5oPgorCisjaWZkZWYgU1NMX3NldF90bHNleHRfc3RhdHVzX3R5cGUKKyNpZm5kZWYgT1BFTlNTTF9OT19UTFNFWFQKKyNkZWZpbmUgSEFWRV9PQ1NQCisjaW5jbHVkZSA8b3BlbnNzbC9lcnIuaD4KKyNpbmNsdWRlIDxvcGVuc3NsL29jc3AuaD4KKyNlbmRpZiAvKiBPUEVOU1NMX05PX1RMU0VYVCAqLworI2VuZGlmIC8qIFNTTF9zZXRfdGxzZXh0X3N0YXR1c190eXBlICovCisjZW5kaWYgLyogRUFQX1RMU19PUEVOU1NMICovCisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJ4bWwtdXRpbHMuaCIKKyNpbmNsdWRlICJodHRwLXV0aWxzLmgiCisKKworc3RydWN0IGh0dHBfY3R4IHsKKwl2b2lkICpjdHg7CisJc3RydWN0IHhtbF9ub2RlX2N0eCAqeG1sOworCUNVUkwgKmN1cmw7CisJc3RydWN0IGN1cmxfc2xpc3QgKmN1cmxfaGRyOworCWNoYXIgKnN2Y19hZGRyZXNzOworCWNoYXIgKnN2Y19jYV9mbmFtZTsKKwljaGFyICpzdmNfdXNlcm5hbWU7CisJY2hhciAqc3ZjX3Bhc3N3b3JkOworCWNoYXIgKnN2Y19jbGllbnRfY2VydDsKKwljaGFyICpzdmNfY2xpZW50X2tleTsKKwljaGFyICpjdXJsX2J1ZjsKKwlzaXplX3QgY3VybF9idWZfbGVuOworCisJaW50ICgqY2VydF9jYikodm9pZCAqY3R4LCBzdHJ1Y3QgaHR0cF9jZXJ0ICpjZXJ0KTsKKwl2b2lkICpjZXJ0X2NiX2N0eDsKKworCWVudW0geworCQlOT19PQ1NQLCBPUFRJT05BTF9PQ1NQLCBNQU5EQVRPUllfT0NTUAorCX0gb2NzcDsKKwlYNTA5ICpwZWVyX2NlcnQ7CisJWDUwOSAqcGVlcl9pc3N1ZXI7CisJWDUwOSAqcGVlcl9pc3N1ZXJfaXNzdWVyOworCisJY29uc3QgY2hhciAqbGFzdF9lcnI7Cit9OworCisKK3N0YXRpYyB2b2lkIGNsZWFyX2N1cmwoc3RydWN0IGh0dHBfY3R4ICpjdHgpCit7CisJaWYgKGN0eC0+Y3VybCkgeworCQljdXJsX2Vhc3lfY2xlYW51cChjdHgtPmN1cmwpOworCQljdHgtPmN1cmwgPSBOVUxMOworCX0KKwlpZiAoY3R4LT5jdXJsX2hkcikgeworCQljdXJsX3NsaXN0X2ZyZWVfYWxsKGN0eC0+Y3VybF9oZHIpOworCQljdHgtPmN1cmxfaGRyID0gTlVMTDsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgY2xvbmVfc3RyKGNoYXIgKipkc3QsIGNvbnN0IGNoYXIgKnNyYykKK3sKKwlvc19mcmVlKCpkc3QpOworCWlmIChzcmMpCisJCSpkc3QgPSBvc19zdHJkdXAoc3JjKTsKKwllbHNlCisJCSpkc3QgPSBOVUxMOworfQorCisKK3N0YXRpYyB2b2lkIGRlYnVnX2R1bXAoc3RydWN0IGh0dHBfY3R4ICpjdHgsIGNvbnN0IGNoYXIgKnRpdGxlLAorCQkgICAgICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgbGVuKQoreworCWNoYXIgKnR4dDsKKwlzaXplX3QgaTsKKworCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykgeworCQlpZiAoYnVmW2ldIDwgMzIgJiYgYnVmW2ldICE9ICdcdCcgJiYgYnVmW2ldICE9ICdcbicgJiYKKwkJICAgIGJ1ZltpXSAhPSAnXHInKSB7CisJCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfTVNHRFVNUCwgdGl0bGUsIGJ1ZiwgbGVuKTsKKwkJCXJldHVybjsKKwkJfQorCX0KKworCXR4dCA9IG9zX21hbGxvYyhsZW4gKyAxKTsKKwlpZiAodHh0ID09IE5VTEwpCisJCXJldHVybjsKKwlvc19tZW1jcHkodHh0LCBidWYsIGxlbik7CisJdHh0W2xlbl0gPSAnXDAnOworCXdoaWxlIChsZW4gPiAwKSB7CisJCWxlbi0tOworCQlpZiAodHh0W2xlbl0gPT0gJ1xuJyB8fCB0eHRbbGVuXSA9PSAnXHInKQorCQkJdHh0W2xlbl0gPSAnXDAnOworCQllbHNlCisJCQlicmVhazsKKwl9CisJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIiVzWyVzXSIsIHRpdGxlLCB0eHQpOworCW9zX2ZyZWUodHh0KTsKK30KKworCitzdGF0aWMgaW50IGN1cmxfY2JfZGVidWcoQ1VSTCAqY3VybCwgY3VybF9pbmZvdHlwZSBpbmZvLCBjaGFyICpidWYsIHNpemVfdCBsZW4sCisJCQkgdm9pZCAqdXNlcmRhdGEpCit7CisJc3RydWN0IGh0dHBfY3R4ICpjdHggPSB1c2VyZGF0YTsKKwlzd2l0Y2ggKGluZm8pIHsKKwljYXNlIENVUkxJTkZPX1RFWFQ6CisJCWRlYnVnX2R1bXAoY3R4LCAiQ1VSTElORk9fVEVYVCIsIGJ1ZiwgbGVuKTsKKwkJYnJlYWs7CisJY2FzZSBDVVJMSU5GT19IRUFERVJfSU46CisJCWRlYnVnX2R1bXAoY3R4LCAiQ1VSTElORk9fSEVBREVSX0lOIiwgYnVmLCBsZW4pOworCQlicmVhazsKKwljYXNlIENVUkxJTkZPX0hFQURFUl9PVVQ6CisJCWRlYnVnX2R1bXAoY3R4LCAiQ1VSTElORk9fSEVBREVSX09VVCIsIGJ1ZiwgbGVuKTsKKwkJYnJlYWs7CisJY2FzZSBDVVJMSU5GT19EQVRBX0lOOgorCQlkZWJ1Z19kdW1wKGN0eCwgIkNVUkxJTkZPX0RBVEFfSU4iLCBidWYsIGxlbik7CisJCWJyZWFrOworCWNhc2UgQ1VSTElORk9fREFUQV9PVVQ6CisJCWRlYnVnX2R1bXAoY3R4LCAiQ1VSTElORk9fREFUQV9PVVQiLCBidWYsIGxlbik7CisJCWJyZWFrOworCWNhc2UgQ1VSTElORk9fU1NMX0RBVEFfSU46CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiZGVidWcgLSBDVVJMSU5GT19TU0xfREFUQV9JTiAtICVkIiwKKwkJCSAgIChpbnQpIGxlbik7CisJCWJyZWFrOworCWNhc2UgQ1VSTElORk9fU1NMX0RBVEFfT1VUOgorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImRlYnVnIC0gQ1VSTElORk9fU1NMX0RBVEFfT1VUIC0gJWQiLAorCQkJICAgKGludCkgbGVuKTsKKwkJYnJlYWs7CisJY2FzZSBDVVJMSU5GT19FTkQ6CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiZGVidWcgLSBDVVJMSU5GT19FTkQgLSAlZCIsCisJCQkgICAoaW50KSBsZW4pOworCQlicmVhazsKKwl9CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHNpemVfdCBjdXJsX2NiX3dyaXRlKHZvaWQgKnB0ciwgc2l6ZV90IHNpemUsIHNpemVfdCBubWVtYiwKKwkJCSAgICB2b2lkICp1c2VyZGF0YSkKK3sKKwlzdHJ1Y3QgaHR0cF9jdHggKmN0eCA9IHVzZXJkYXRhOworCWNoYXIgKm47CisJbiA9IG9zX3JlYWxsb2MoY3R4LT5jdXJsX2J1ZiwgY3R4LT5jdXJsX2J1Zl9sZW4gKyBzaXplICogbm1lbWIgKyAxKTsKKwlpZiAobiA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKwljdHgtPmN1cmxfYnVmID0gbjsKKwlvc19tZW1jcHkobiArIGN0eC0+Y3VybF9idWZfbGVuLCBwdHIsIHNpemUgKiBubWVtYik7CisJbltjdHgtPmN1cmxfYnVmX2xlbiArIHNpemUgKiBubWVtYl0gPSAnXDAnOworCWN0eC0+Y3VybF9idWZfbGVuICs9IHNpemUgKiBubWVtYjsKKwlyZXR1cm4gc2l6ZSAqIG5tZW1iOworfQorCisKKyNpZmRlZiBFQVBfVExTX09QRU5TU0wKKworc3RhdGljIHZvaWQgZGVidWdfZHVtcF9jZXJ0KGNvbnN0IGNoYXIgKnRpdGxlLCBYNTA5ICpjZXJ0KQoreworCUJJTyAqb3V0OworCWNoYXIgKnR4dDsKKwlzaXplX3QgcmxlbjsKKworCW91dCA9IEJJT19uZXcoQklPX3NfbWVtKCkpOworCWlmICghb3V0KQorCQlyZXR1cm47CisKKwlYNTA5X3ByaW50X2V4KG91dCwgY2VydCwgWE5fRkxBR19DT01QQVQsIFg1MDlfRkxBR19DT01QQVQpOworCXJsZW4gPSBCSU9fY3RybF9wZW5kaW5nKG91dCk7CisJdHh0ID0gb3NfbWFsbG9jKHJsZW4gKyAxKTsKKwlpZiAodHh0KSB7CisJCWludCByZXMgPSBCSU9fcmVhZChvdXQsIHR4dCwgcmxlbik7CisJCWlmIChyZXMgPiAwKSB7CisJCQl0eHRbcmVzXSA9ICdcMCc7CisJCQl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiJXM6XG4lcyIsIHRpdGxlLCB0eHQpOworCQl9CisJCW9zX2ZyZWUodHh0KTsKKwl9CisJQklPX2ZyZWUob3V0KTsKK30KKworCitzdGF0aWMgdm9pZCBhZGRfYWx0X25hbWVfb3RoZXJuYW1lKHN0cnVjdCBodHRwX2N0eCAqY3R4LCBzdHJ1Y3QgaHR0cF9jZXJ0ICpjZXJ0LAorCQkJCSAgIE9USEVSTkFNRSAqbykKK3sKKwljaGFyIHR4dFsxMDBdOworCWludCByZXM7CisJc3RydWN0IGh0dHBfb3RoZXJuYW1lICpvbjsKKwlBU04xX1RZUEUgKnZhbDsKKworCW9uID0gb3NfcmVhbGxvY19hcnJheShjZXJ0LT5vdGhlcm5hbWUsIGNlcnQtPm51bV9vdGhlcm5hbWUgKyAxLAorCQkJICAgICAgc2l6ZW9mKHN0cnVjdCBodHRwX290aGVybmFtZSkpOworCWlmIChvbiA9PSBOVUxMKQorCQlyZXR1cm47CisJY2VydC0+b3RoZXJuYW1lID0gb247CisJb24gPSAmb25bY2VydC0+bnVtX290aGVybmFtZV07CisJb3NfbWVtc2V0KG9uLCAwLCBzaXplb2YoKm9uKSk7CisKKwlyZXMgPSBPQkpfb2JqMnR4dCh0eHQsIHNpemVvZih0eHQpLCBvLT50eXBlX2lkLCAxKTsKKwlpZiAocmVzIDwgMCB8fCByZXMgPj0gKGludCkgc2l6ZW9mKHR4dCkpCisJCXJldHVybjsKKworCW9uLT5vaWQgPSBvc19zdHJkdXAodHh0KTsKKwlpZiAob24tPm9pZCA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl2YWwgPSBvLT52YWx1ZTsKKwlvbi0+ZGF0YSA9IHZhbC0+dmFsdWUub2N0ZXRfc3RyaW5nLT5kYXRhOworCW9uLT5sZW4gPSB2YWwtPnZhbHVlLm9jdGV0X3N0cmluZy0+bGVuZ3RoOworCisJY2VydC0+bnVtX290aGVybmFtZSsrOworfQorCisKK3N0YXRpYyB2b2lkIGFkZF9hbHRfbmFtZV9kbnMoc3RydWN0IGh0dHBfY3R4ICpjdHgsIHN0cnVjdCBodHRwX2NlcnQgKmNlcnQsCisJCQkgICAgIEFTTjFfU1RSSU5HICpuYW1lKQoreworCWNoYXIgKmJ1ZjsKKwljaGFyICoqbjsKKworCWJ1ZiA9IE5VTEw7CisJaWYgKEFTTjFfU1RSSU5HX3RvX1VURjgoKHVuc2lnbmVkIGNoYXIgKiopICZidWYsIG5hbWUpIDwgMCkKKwkJcmV0dXJuOworCisJbiA9IG9zX3JlYWxsb2NfYXJyYXkoY2VydC0+ZG5zbmFtZSwgY2VydC0+bnVtX2Ruc25hbWUgKyAxLAorCQkJICAgICBzaXplb2YoY2hhciAqKSk7CisJaWYgKG4gPT0gTlVMTCkKKwkJcmV0dXJuOworCisJY2VydC0+ZG5zbmFtZSA9IG47CisJbltjZXJ0LT5udW1fZG5zbmFtZV0gPSBidWY7CisJY2VydC0+bnVtX2Ruc25hbWUrKzsKK30KKworCitzdGF0aWMgdm9pZCBhZGRfYWx0X25hbWUoc3RydWN0IGh0dHBfY3R4ICpjdHgsIHN0cnVjdCBodHRwX2NlcnQgKmNlcnQsCisJCQkgY29uc3QgR0VORVJBTF9OQU1FICpuYW1lKQoreworCXN3aXRjaCAobmFtZS0+dHlwZSkgeworCWNhc2UgR0VOX09USEVSTkFNRToKKwkJYWRkX2FsdF9uYW1lX290aGVybmFtZShjdHgsIGNlcnQsIG5hbWUtPmQub3RoZXJOYW1lKTsKKwkJYnJlYWs7CisJY2FzZSBHRU5fRE5TOgorCQlhZGRfYWx0X25hbWVfZG5zKGN0eCwgY2VydCwgbmFtZS0+ZC5kTlNOYW1lKTsKKwkJYnJlYWs7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIGFkZF9hbHRfbmFtZXMoc3RydWN0IGh0dHBfY3R4ICpjdHgsIHN0cnVjdCBodHRwX2NlcnQgKmNlcnQsCisJCQkgIEdFTkVSQUxfTkFNRVMgKm5hbWVzKQoreworCWludCBudW0sIGk7CisKKwludW0gPSBza19HRU5FUkFMX05BTUVfbnVtKG5hbWVzKTsKKwlmb3IgKGkgPSAwOyBpIDwgbnVtOyBpKyspIHsKKwkJY29uc3QgR0VORVJBTF9OQU1FICpuYW1lOworCQluYW1lID0gc2tfR0VORVJBTF9OQU1FX3ZhbHVlKG5hbWVzLCBpKTsKKwkJYWRkX2FsdF9uYW1lKGN0eCwgY2VydCwgbmFtZSk7CisJfQorfQorCisKKy8qIFJGQyAzNzA5ICovCisKK3R5cGVkZWYgc3RydWN0IHsKKwlYNTA5X0FMR09SICpoYXNoQWxnOworCUFTTjFfT0NURVRfU1RSSU5HICpoYXNoVmFsdWU7Cit9IEhhc2hBbGdBbmRWYWx1ZTsKKwordHlwZWRlZiBzdHJ1Y3QgeworCVNUQUNLX09GKEhhc2hBbGdBbmRWYWx1ZSkgKnJlZlN0cnVjdEhhc2g7CisJU1RBQ0tfT0YoQVNOMV9JQTVTVFJJTkcpICpyZWZTdHJ1Y3RVUkk7Cit9IExvZ290eXBlUmVmZXJlbmNlOworCit0eXBlZGVmIHN0cnVjdCB7CisJQVNOMV9JQTVTVFJJTkcgKm1lZGlhVHlwZTsKKwlTVEFDS19PRihIYXNoQWxnQW5kVmFsdWUpICpsb2dvdHlwZUhhc2g7CisJU1RBQ0tfT0YoQVNOMV9JQTVTVFJJTkcpICpsb2dvdHlwZVVSSTsKK30gTG9nb3R5cGVEZXRhaWxzOworCit0eXBlZGVmIHN0cnVjdCB7CisJaW50IHR5cGU7CisJdW5pb24geworCQlBU04xX0lOVEVHRVIgKm51bUJpdHM7CisJCUFTTjFfSU5URUdFUiAqdGFibGVTaXplOworCX0gZDsKK30gTG9nb3R5cGVJbWFnZVJlc29sdXRpb247CisKK3R5cGVkZWYgc3RydWN0IHsKKwlBU04xX0lOVEVHRVIgKnR5cGU7IC8qIExvZ290eXBlSW1hZ2VUeXBlIDo6PSBJTlRFR0VSICovCisJQVNOMV9JTlRFR0VSICpmaWxlU2l6ZTsKKwlBU04xX0lOVEVHRVIgKnhTaXplOworCUFTTjFfSU5URUdFUiAqeVNpemU7CisJTG9nb3R5cGVJbWFnZVJlc29sdXRpb24gKnJlc29sdXRpb247CisJQVNOMV9JQTVTVFJJTkcgKmxhbmd1YWdlOworfSBMb2dvdHlwZUltYWdlSW5mbzsKKwordHlwZWRlZiBzdHJ1Y3QgeworCUxvZ290eXBlRGV0YWlscyAqaW1hZ2VEZXRhaWxzOworCUxvZ290eXBlSW1hZ2VJbmZvICppbWFnZUluZm87Cit9IExvZ290eXBlSW1hZ2U7CisKK3R5cGVkZWYgc3RydWN0IHsKKwlBU04xX0lOVEVHRVIgKmZpbGVTaXplOworCUFTTjFfSU5URUdFUiAqcGxheVRpbWU7CisJQVNOMV9JTlRFR0VSICpjaGFubmVsczsKKwlBU04xX0lOVEVHRVIgKnNhbXBsZVJhdGU7CisJQVNOMV9JQTVTVFJJTkcgKmxhbmd1YWdlOworfSBMb2dvdHlwZUF1ZGlvSW5mbzsKKwordHlwZWRlZiBzdHJ1Y3QgeworCUxvZ290eXBlRGV0YWlscyAqYXVkaW9EZXRhaWxzOworCUxvZ290eXBlQXVkaW9JbmZvICphdWRpb0luZm87Cit9IExvZ290eXBlQXVkaW87CisKK3R5cGVkZWYgc3RydWN0IHsKKwlTVEFDS19PRihMb2dvdHlwZUltYWdlKSAqaW1hZ2U7CisJU1RBQ0tfT0YoTG9nb3R5cGVBdWRpbykgKmF1ZGlvOworfSBMb2dvdHlwZURhdGE7CisKK3R5cGVkZWYgc3RydWN0IHsKKwlpbnQgdHlwZTsKKwl1bmlvbiB7CisJCUxvZ290eXBlRGF0YSAqZGlyZWN0OworCQlMb2dvdHlwZVJlZmVyZW5jZSAqaW5kaXJlY3Q7CisJfSBkOworfSBMb2dvdHlwZUluZm87CisKK3R5cGVkZWYgc3RydWN0IHsKKwlBU04xX09CSkVDVCAqbG9nb3R5cGVUeXBlOworCUxvZ290eXBlSW5mbyAqaW5mbzsKK30gT3RoZXJMb2dvdHlwZUluZm87CisKK3R5cGVkZWYgc3RydWN0IHsKKwlTVEFDS19PRihMb2dvdHlwZUluZm8pICpjb21tdW5pdHlMb2dvczsKKwlMb2dvdHlwZUluZm8gKmlzc3VlckxvZ287CisJTG9nb3R5cGVJbmZvICpzdWJqZWN0TG9nbzsKKwlTVEFDS19PRihPdGhlckxvZ290eXBlSW5mbykgKm90aGVyTG9nb3M7Cit9IExvZ290eXBlRXh0bjsKKworQVNOMV9TRVFVRU5DRShIYXNoQWxnQW5kVmFsdWUpID0geworCUFTTjFfU0lNUExFKEhhc2hBbGdBbmRWYWx1ZSwgaGFzaEFsZywgWDUwOV9BTEdPUiksCisJQVNOMV9TSU1QTEUoSGFzaEFsZ0FuZFZhbHVlLCBoYXNoVmFsdWUsIEFTTjFfT0NURVRfU1RSSU5HKQorfSBBU04xX1NFUVVFTkNFX0VORChIYXNoQWxnQW5kVmFsdWUpOworCitBU04xX1NFUVVFTkNFKExvZ290eXBlUmVmZXJlbmNlKSA9IHsKKwlBU04xX1NFUVVFTkNFX09GKExvZ290eXBlUmVmZXJlbmNlLCByZWZTdHJ1Y3RIYXNoLCBIYXNoQWxnQW5kVmFsdWUpLAorCUFTTjFfU0VRVUVOQ0VfT0YoTG9nb3R5cGVSZWZlcmVuY2UsIHJlZlN0cnVjdFVSSSwgQVNOMV9JQTVTVFJJTkcpCit9IEFTTjFfU0VRVUVOQ0VfRU5EKExvZ290eXBlUmVmZXJlbmNlKTsKKworQVNOMV9TRVFVRU5DRShMb2dvdHlwZURldGFpbHMpID0geworCUFTTjFfU0lNUExFKExvZ290eXBlRGV0YWlscywgbWVkaWFUeXBlLCBBU04xX0lBNVNUUklORyksCisJQVNOMV9TRVFVRU5DRV9PRihMb2dvdHlwZURldGFpbHMsIGxvZ290eXBlSGFzaCwgSGFzaEFsZ0FuZFZhbHVlKSwKKwlBU04xX1NFUVVFTkNFX09GKExvZ290eXBlRGV0YWlscywgbG9nb3R5cGVVUkksIEFTTjFfSUE1U1RSSU5HKQorfSBBU04xX1NFUVVFTkNFX0VORChMb2dvdHlwZURldGFpbHMpOworCitBU04xX0NIT0lDRShMb2dvdHlwZUltYWdlUmVzb2x1dGlvbikgPSB7CisJQVNOMV9JTVAoTG9nb3R5cGVJbWFnZVJlc29sdXRpb24sIGQubnVtQml0cywgQVNOMV9JTlRFR0VSLCAxKSwKKwlBU04xX0lNUChMb2dvdHlwZUltYWdlUmVzb2x1dGlvbiwgZC50YWJsZVNpemUsIEFTTjFfSU5URUdFUiwgMikKK30gQVNOMV9DSE9JQ0VfRU5EKExvZ290eXBlSW1hZ2VSZXNvbHV0aW9uKTsKKworQVNOMV9TRVFVRU5DRShMb2dvdHlwZUltYWdlSW5mbykgPSB7CisJQVNOMV9JTVBfT1BUKExvZ290eXBlSW1hZ2VJbmZvLCB0eXBlLCBBU04xX0lOVEVHRVIsIDApLAorCUFTTjFfU0lNUExFKExvZ290eXBlSW1hZ2VJbmZvLCBmaWxlU2l6ZSwgQVNOMV9JTlRFR0VSKSwKKwlBU04xX1NJTVBMRShMb2dvdHlwZUltYWdlSW5mbywgeFNpemUsIEFTTjFfSU5URUdFUiksCisJQVNOMV9TSU1QTEUoTG9nb3R5cGVJbWFnZUluZm8sIHlTaXplLCBBU04xX0lOVEVHRVIpLAorCUFTTjFfT1BUKExvZ290eXBlSW1hZ2VJbmZvLCByZXNvbHV0aW9uLCBMb2dvdHlwZUltYWdlUmVzb2x1dGlvbiksCisJQVNOMV9JTVBfT1BUKExvZ290eXBlSW1hZ2VJbmZvLCBsYW5ndWFnZSwgQVNOMV9JQTVTVFJJTkcsIDQpLAorfSBBU04xX1NFUVVFTkNFX0VORChMb2dvdHlwZUltYWdlSW5mbyk7CisKK0FTTjFfU0VRVUVOQ0UoTG9nb3R5cGVJbWFnZSkgPSB7CisJQVNOMV9TSU1QTEUoTG9nb3R5cGVJbWFnZSwgaW1hZ2VEZXRhaWxzLCBMb2dvdHlwZURldGFpbHMpLAorCUFTTjFfT1BUKExvZ290eXBlSW1hZ2UsIGltYWdlSW5mbywgTG9nb3R5cGVJbWFnZUluZm8pCit9IEFTTjFfU0VRVUVOQ0VfRU5EKExvZ290eXBlSW1hZ2UpOworCitBU04xX1NFUVVFTkNFKExvZ290eXBlQXVkaW9JbmZvKSA9IHsKKwlBU04xX1NJTVBMRShMb2dvdHlwZUF1ZGlvSW5mbywgZmlsZVNpemUsIEFTTjFfSU5URUdFUiksCisJQVNOMV9TSU1QTEUoTG9nb3R5cGVBdWRpb0luZm8sIHBsYXlUaW1lLCBBU04xX0lOVEVHRVIpLAorCUFTTjFfU0lNUExFKExvZ290eXBlQXVkaW9JbmZvLCBjaGFubmVscywgQVNOMV9JTlRFR0VSKSwKKwlBU04xX0lNUF9PUFQoTG9nb3R5cGVBdWRpb0luZm8sIHNhbXBsZVJhdGUsIEFTTjFfSU5URUdFUiwgMyksCisJQVNOMV9JTVBfT1BUKExvZ290eXBlQXVkaW9JbmZvLCBsYW5ndWFnZSwgQVNOMV9JQTVTVFJJTkcsIDQpCit9IEFTTjFfU0VRVUVOQ0VfRU5EKExvZ290eXBlQXVkaW9JbmZvKTsKKworQVNOMV9TRVFVRU5DRShMb2dvdHlwZUF1ZGlvKSA9IHsKKwlBU04xX1NJTVBMRShMb2dvdHlwZUF1ZGlvLCBhdWRpb0RldGFpbHMsIExvZ290eXBlRGV0YWlscyksCisJQVNOMV9PUFQoTG9nb3R5cGVBdWRpbywgYXVkaW9JbmZvLCBMb2dvdHlwZUF1ZGlvSW5mbykKK30gQVNOMV9TRVFVRU5DRV9FTkQoTG9nb3R5cGVBdWRpbyk7CisKK0FTTjFfU0VRVUVOQ0UoTG9nb3R5cGVEYXRhKSA9IHsKKwlBU04xX1NFUVVFTkNFX09GX09QVChMb2dvdHlwZURhdGEsIGltYWdlLCBMb2dvdHlwZUltYWdlKSwKKwlBU04xX0lNUF9TRVFVRU5DRV9PRl9PUFQoTG9nb3R5cGVEYXRhLCBhdWRpbywgTG9nb3R5cGVBdWRpbywgMSkKK30gQVNOMV9TRVFVRU5DRV9FTkQoTG9nb3R5cGVEYXRhKTsKKworQVNOMV9DSE9JQ0UoTG9nb3R5cGVJbmZvKSA9IHsKKwlBU04xX0lNUChMb2dvdHlwZUluZm8sIGQuZGlyZWN0LCBMb2dvdHlwZURhdGEsIDApLAorCUFTTjFfSU1QKExvZ290eXBlSW5mbywgZC5pbmRpcmVjdCwgTG9nb3R5cGVSZWZlcmVuY2UsIDEpCit9IEFTTjFfQ0hPSUNFX0VORChMb2dvdHlwZUluZm8pOworCitBU04xX1NFUVVFTkNFKE90aGVyTG9nb3R5cGVJbmZvKSA9IHsKKwlBU04xX1NJTVBMRShPdGhlckxvZ290eXBlSW5mbywgbG9nb3R5cGVUeXBlLCBBU04xX09CSkVDVCksCisJQVNOMV9TSU1QTEUoT3RoZXJMb2dvdHlwZUluZm8sIGluZm8sIExvZ290eXBlSW5mbykKK30gQVNOMV9TRVFVRU5DRV9FTkQoT3RoZXJMb2dvdHlwZUluZm8pOworCitBU04xX1NFUVVFTkNFKExvZ290eXBlRXh0bikgPSB7CisJQVNOMV9FWFBfU0VRVUVOQ0VfT0ZfT1BUKExvZ290eXBlRXh0biwgY29tbXVuaXR5TG9nb3MsIExvZ290eXBlSW5mbywgMCksCisJQVNOMV9FWFBfT1BUKExvZ290eXBlRXh0biwgaXNzdWVyTG9nbywgTG9nb3R5cGVJbmZvLCAxKSwKKwlBU04xX0VYUF9PUFQoTG9nb3R5cGVFeHRuLCBpc3N1ZXJMb2dvLCBMb2dvdHlwZUluZm8sIDIpLAorCUFTTjFfRVhQX1NFUVVFTkNFX09GX09QVChMb2dvdHlwZUV4dG4sIG90aGVyTG9nb3MsIE90aGVyTG9nb3R5cGVJbmZvLCAzKQorfSBBU04xX1NFUVVFTkNFX0VORChMb2dvdHlwZUV4dG4pOworCitJTVBMRU1FTlRfQVNOMV9GVU5DVElPTlMoTG9nb3R5cGVFeHRuKTsKKworI2RlZmluZSBza19Mb2dvdHlwZUluZm9fbnVtKHN0KSBTS01fc2tfbnVtKExvZ290eXBlSW5mbywgKHN0KSkKKyNkZWZpbmUgc2tfTG9nb3R5cGVJbmZvX3ZhbHVlKHN0LCBpKSBTS01fc2tfdmFsdWUoTG9nb3R5cGVJbmZvLCAoc3QpLCAoaSkpCisjZGVmaW5lIHNrX0xvZ290eXBlSW1hZ2VfbnVtKHN0KSBTS01fc2tfbnVtKExvZ290eXBlSW1hZ2UsIChzdCkpCisjZGVmaW5lIHNrX0xvZ290eXBlSW1hZ2VfdmFsdWUoc3QsIGkpIFNLTV9za192YWx1ZShMb2dvdHlwZUltYWdlLCAoc3QpLCAoaSkpCisjZGVmaW5lIHNrX0xvZ290eXBlQXVkaW9fbnVtKHN0KSBTS01fc2tfbnVtKExvZ290eXBlQXVkaW8sIChzdCkpCisjZGVmaW5lIHNrX0xvZ290eXBlQXVkaW9fdmFsdWUoc3QsIGkpIFNLTV9za192YWx1ZShMb2dvdHlwZUF1ZGlvLCAoc3QpLCAoaSkpCisjZGVmaW5lIHNrX0hhc2hBbGdBbmRWYWx1ZV9udW0oc3QpIFNLTV9za19udW0oSGFzaEFsZ0FuZFZhbHVlLCAoc3QpKQorI2RlZmluZSBza19IYXNoQWxnQW5kVmFsdWVfdmFsdWUoc3QsIGkpIFNLTV9za192YWx1ZShIYXNoQWxnQW5kVmFsdWUsIChzdCksIChpKSkKKyNkZWZpbmUgc2tfQVNOMV9JQTVTVFJJTkdfbnVtKHN0KSBTS01fc2tfbnVtKEFTTjFfSUE1U1RSSU5HLCAoc3QpKQorI2RlZmluZSBza19BU04xX0lBNVNUUklOR192YWx1ZShzdCwgaSkgU0tNX3NrX3ZhbHVlKEFTTjFfSUE1U1RSSU5HLCAoc3QpLCAoaSkpCisKKworc3RhdGljIHZvaWQgYWRkX2xvZ28oc3RydWN0IGh0dHBfY3R4ICpjdHgsIHN0cnVjdCBodHRwX2NlcnQgKmhjZXJ0LAorCQkgICAgIEhhc2hBbGdBbmRWYWx1ZSAqaGFzaCwgQVNOMV9JQTVTVFJJTkcgKnVyaSkKK3sKKwljaGFyIHR4dFsxMDBdOworCWludCByZXMsIGxlbjsKKwlzdHJ1Y3QgaHR0cF9sb2dvICpuOworCisJaWYgKGhhc2ggPT0gTlVMTCB8fCB1cmkgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJcmVzID0gT0JKX29iajJ0eHQodHh0LCBzaXplb2YodHh0KSwgaGFzaC0+aGFzaEFsZy0+YWxnb3JpdGhtLCAxKTsKKwlpZiAocmVzIDwgMCB8fCByZXMgPj0gKGludCkgc2l6ZW9mKHR4dCkpCisJCXJldHVybjsKKworCW4gPSBvc19yZWFsbG9jX2FycmF5KGhjZXJ0LT5sb2dvLCBoY2VydC0+bnVtX2xvZ28gKyAxLAorCQkJICAgICBzaXplb2Yoc3RydWN0IGh0dHBfbG9nbykpOworCWlmIChuID09IE5VTEwpCisJCXJldHVybjsKKwloY2VydC0+bG9nbyA9IG47CisJbiA9ICZoY2VydC0+bG9nb1toY2VydC0+bnVtX2xvZ29dOworCW9zX21lbXNldChuLCAwLCBzaXplb2YoKm4pKTsKKworCW4tPmFsZ19vaWQgPSBvc19zdHJkdXAodHh0KTsKKwlpZiAobi0+YWxnX29pZCA9PSBOVUxMKQorCQlyZXR1cm47CisKKwluLT5oYXNoX2xlbiA9IEFTTjFfU1RSSU5HX2xlbmd0aChoYXNoLT5oYXNoVmFsdWUpOworCW4tPmhhc2ggPSBvc19tYWxsb2Mobi0+aGFzaF9sZW4pOworCWlmIChuLT5oYXNoID09IE5VTEwpIHsKKwkJb3NfZnJlZShuLT5hbGdfb2lkKTsKKwkJcmV0dXJuOworCX0KKwlvc19tZW1jcHkobi0+aGFzaCwgQVNOMV9TVFJJTkdfZGF0YShoYXNoLT5oYXNoVmFsdWUpLCBuLT5oYXNoX2xlbik7CisKKwlsZW4gPSBBU04xX1NUUklOR19sZW5ndGgodXJpKTsKKwluLT51cmkgPSBvc19tYWxsb2MobGVuICsgMSk7CisJaWYgKG4tPnVyaSA9PSBOVUxMKSB7CisJCW9zX2ZyZWUobi0+YWxnX29pZCk7CisJCW9zX2ZyZWUobi0+aGFzaCk7CisJCXJldHVybjsKKwl9CisJb3NfbWVtY3B5KG4tPnVyaSwgQVNOMV9TVFJJTkdfZGF0YSh1cmkpLCBsZW4pOworCW4tPnVyaVtsZW5dID0gJ1wwJzsKKworCWhjZXJ0LT5udW1fbG9nbysrOworfQorCisKK3N0YXRpYyB2b2lkIGFkZF9sb2dvX2RpcmVjdChzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgc3RydWN0IGh0dHBfY2VydCAqaGNlcnQsCisJCQkgICAgTG9nb3R5cGVEYXRhICpkYXRhKQoreworCWludCBpLCBudW07CisKKwlpZiAoZGF0YS0+aW1hZ2UgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJbnVtID0gc2tfTG9nb3R5cGVJbWFnZV9udW0oZGF0YS0+aW1hZ2UpOworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQlMb2dvdHlwZUltYWdlICppbWFnZTsKKwkJTG9nb3R5cGVEZXRhaWxzICpkZXRhaWxzOworCQlpbnQgaiwgaGFzaF9udW0sIHVyaV9udW07CisJCUhhc2hBbGdBbmRWYWx1ZSAqZm91bmRfaGFzaCA9IE5VTEw7CisKKwkJaW1hZ2UgPSBza19Mb2dvdHlwZUltYWdlX3ZhbHVlKGRhdGEtPmltYWdlLCBpKTsKKwkJaWYgKGltYWdlID09IE5VTEwpCisJCQljb250aW51ZTsKKworCQlkZXRhaWxzID0gaW1hZ2UtPmltYWdlRGV0YWlsczsKKwkJaWYgKGRldGFpbHMgPT0gTlVMTCkKKwkJCWNvbnRpbnVlOworCisJCWhhc2hfbnVtID0gc2tfSGFzaEFsZ0FuZFZhbHVlX251bShkZXRhaWxzLT5sb2dvdHlwZUhhc2gpOworCQlmb3IgKGogPSAwOyBqIDwgaGFzaF9udW07IGorKykgeworCQkJSGFzaEFsZ0FuZFZhbHVlICpoYXNoOworCQkJY2hhciB0eHRbMTAwXTsKKwkJCWludCByZXM7CisJCQloYXNoID0gc2tfSGFzaEFsZ0FuZFZhbHVlX3ZhbHVlKGRldGFpbHMtPmxvZ290eXBlSGFzaCwKKwkJCQkJCQlqKTsKKwkJCWlmIChoYXNoID09IE5VTEwpCisJCQkJY29udGludWU7CisJCQlyZXMgPSBPQkpfb2JqMnR4dCh0eHQsIHNpemVvZih0eHQpLAorCQkJCQkgIGhhc2gtPmhhc2hBbGctPmFsZ29yaXRobSwgMSk7CisJCQlpZiAocmVzIDwgMCB8fCByZXMgPj0gKGludCkgc2l6ZW9mKHR4dCkpCisJCQkJY29udGludWU7CisJCQlpZiAob3Nfc3RyY21wKHR4dCwgIjIuMTYuODQwLjEuMTAxLjMuNC4yLjEiKSA9PSAwKSB7CisJCQkJZm91bmRfaGFzaCA9IGhhc2g7CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKworCQlpZiAoIWZvdW5kX2hhc2gpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT3BlblNTTDogTm8gU0hBMjU2IGhhc2ggZm91bmQgZm9yIHRoZSBsb2dvIik7CisJCQljb250aW51ZTsKKwkJfQorCisJCXVyaV9udW0gPSBza19BU04xX0lBNVNUUklOR19udW0oZGV0YWlscy0+bG9nb3R5cGVVUkkpOworCQlmb3IgKGogPSAwOyBqIDwgdXJpX251bTsgaisrKSB7CisJCQlBU04xX0lBNVNUUklORyAqdXJpOworCQkJdXJpID0gc2tfQVNOMV9JQTVTVFJJTkdfdmFsdWUoZGV0YWlscy0+bG9nb3R5cGVVUkksIGopOworCQkJYWRkX2xvZ28oY3R4LCBoY2VydCwgZm91bmRfaGFzaCwgdXJpKTsKKwkJfQorCX0KK30KKworCitzdGF0aWMgdm9pZCBhZGRfbG9nb19pbmRpcmVjdChzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgc3RydWN0IGh0dHBfY2VydCAqaGNlcnQsCisJCQkgICAgICBMb2dvdHlwZVJlZmVyZW5jZSAqcmVmKQoreworCWludCBqLCBoYXNoX251bSwgdXJpX251bTsKKworCWhhc2hfbnVtID0gc2tfSGFzaEFsZ0FuZFZhbHVlX251bShyZWYtPnJlZlN0cnVjdEhhc2gpOworCXVyaV9udW0gPSBza19BU04xX0lBNVNUUklOR19udW0ocmVmLT5yZWZTdHJ1Y3RVUkkpOworCWlmIChoYXNoX251bSAhPSB1cmlfbnVtKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJVbmV4cGVjdGVkIExvZ290eXBlUmVmZXJlbmNlIGFycmF5IHNpemUgZGlmZmVyZW5jZSAlZCAhPSAlZCIsCisJCQkgICBoYXNoX251bSwgdXJpX251bSk7CisJCXJldHVybjsKKwl9CisKKwlmb3IgKGogPSAwOyBqIDwgaGFzaF9udW07IGorKykgeworCQlIYXNoQWxnQW5kVmFsdWUgKmhhc2g7CisJCUFTTjFfSUE1U1RSSU5HICp1cmk7CisJCWhhc2ggPSBza19IYXNoQWxnQW5kVmFsdWVfdmFsdWUocmVmLT5yZWZTdHJ1Y3RIYXNoLCBqKTsKKwkJdXJpID0gc2tfQVNOMV9JQTVTVFJJTkdfdmFsdWUocmVmLT5yZWZTdHJ1Y3RVUkksIGopOworCQlhZGRfbG9nbyhjdHgsIGhjZXJ0LCBoYXNoLCB1cmkpOworCX0KK30KKworCitzdGF0aWMgdm9pZCBpMnJfSGFzaEFsZ0FuZFZhbHVlKEhhc2hBbGdBbmRWYWx1ZSAqaGFzaCwgQklPICpvdXQsIGludCBpbmRlbnQpCit7CisJaW50IGk7CisJY29uc3QgdW5zaWduZWQgY2hhciAqZGF0YTsKKworCUJJT19wcmludGYob3V0LCAiJSpzaGFzaEFsZzogIiwgaW5kZW50LCAiIik7CisJaTJhX0FTTjFfT0JKRUNUKG91dCwgaGFzaC0+aGFzaEFsZy0+YWxnb3JpdGhtKTsKKwlCSU9fcHJpbnRmKG91dCwgIlxuIik7CisKKwlCSU9fcHJpbnRmKG91dCwgIiUqc2hhc2hWYWx1ZTogIiwgaW5kZW50LCAiIik7CisJZGF0YSA9IGhhc2gtPmhhc2hWYWx1ZS0+ZGF0YTsKKwlmb3IgKGkgPSAwOyBpIDwgaGFzaC0+aGFzaFZhbHVlLT5sZW5ndGg7IGkrKykKKwkJQklPX3ByaW50ZihvdXQsICIlcyUwMngiLCBpID4gMCA/ICI6IiA6ICIiLCBkYXRhW2ldKTsKKwlCSU9fcHJpbnRmKG91dCwgIlxuIik7Cit9CisKK3N0YXRpYyB2b2lkIGkycl9Mb2dvdHlwZURldGFpbHMoTG9nb3R5cGVEZXRhaWxzICpkZXRhaWxzLCBCSU8gKm91dCwgaW50IGluZGVudCkKK3sKKwlpbnQgaSwgbnVtOworCisJQklPX3ByaW50ZihvdXQsICIlKnNMb2dvdHlwZURldGFpbHNcbiIsIGluZGVudCwgIiIpOworCWlmIChkZXRhaWxzLT5tZWRpYVR5cGUpIHsKKwkJQklPX3ByaW50ZihvdXQsICIlKnNtZWRpYVR5cGU6ICIsIGluZGVudCwgIiIpOworCQlBU04xX1NUUklOR19wcmludChvdXQsIGRldGFpbHMtPm1lZGlhVHlwZSk7CisJCUJJT19wcmludGYob3V0LCAiXG4iKTsKKwl9CisKKwludW0gPSBkZXRhaWxzLT5sb2dvdHlwZUhhc2ggPworCQlza19IYXNoQWxnQW5kVmFsdWVfbnVtKGRldGFpbHMtPmxvZ290eXBlSGFzaCkgOiAwOworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQlIYXNoQWxnQW5kVmFsdWUgKmhhc2g7CisJCWhhc2ggPSBza19IYXNoQWxnQW5kVmFsdWVfdmFsdWUoZGV0YWlscy0+bG9nb3R5cGVIYXNoLCBpKTsKKwkJaTJyX0hhc2hBbGdBbmRWYWx1ZShoYXNoLCBvdXQsIGluZGVudCk7CisJfQorCisJbnVtID0gZGV0YWlscy0+bG9nb3R5cGVVUkkgPworCQlza19BU04xX0lBNVNUUklOR19udW0oZGV0YWlscy0+bG9nb3R5cGVVUkkpIDogMDsKKwlmb3IgKGkgPSAwOyBpIDwgbnVtOyBpKyspIHsKKwkJQVNOMV9JQTVTVFJJTkcgKnVyaTsKKwkJdXJpID0gc2tfQVNOMV9JQTVTVFJJTkdfdmFsdWUoZGV0YWlscy0+bG9nb3R5cGVVUkksIGkpOworCQlCSU9fcHJpbnRmKG91dCwgIiUqc2xvZ290eXBlVVJJOiAiLCBpbmRlbnQsICIiKTsKKwkJQVNOMV9TVFJJTkdfcHJpbnQob3V0LCB1cmkpOworCQlCSU9fcHJpbnRmKG91dCwgIlxuIik7CisJfQorfQorCitzdGF0aWMgdm9pZCBpMnJfTG9nb3R5cGVJbWFnZUluZm8oTG9nb3R5cGVJbWFnZUluZm8gKmluZm8sIEJJTyAqb3V0LCBpbnQgaW5kZW50KQoreworCWxvbmcgdmFsOworCisJQklPX3ByaW50ZihvdXQsICIlKnNMb2dvdHlwZUltYWdlSW5mb1xuIiwgaW5kZW50LCAiIik7CisJaWYgKGluZm8tPnR5cGUpIHsKKwkJdmFsID0gQVNOMV9JTlRFR0VSX2dldChpbmZvLT50eXBlKTsKKwkJQklPX3ByaW50ZihvdXQsICIlKnN0eXBlOiAlbGRcbiIsIGluZGVudCwgIiIsIHZhbCk7CisJfSBlbHNlIHsKKwkJQklPX3ByaW50ZihvdXQsICIlKnN0eXBlOiBkZWZhdWx0ICgxKVxuIiwgaW5kZW50LCAiIik7CisJfQorCXZhbCA9IEFTTjFfSU5URUdFUl9nZXQoaW5mby0+eFNpemUpOworCUJJT19wcmludGYob3V0LCAiJSpzeFNpemU6ICVsZFxuIiwgaW5kZW50LCAiIiwgdmFsKTsKKwl2YWwgPSBBU04xX0lOVEVHRVJfZ2V0KGluZm8tPnlTaXplKTsKKwlCSU9fcHJpbnRmKG91dCwgIiUqc3lTaXplOiAlbGRcbiIsIGluZGVudCwgIiIsIHZhbCk7CisJaWYgKGluZm8tPnJlc29sdXRpb24pIHsKKwkJQklPX3ByaW50ZihvdXQsICIlKnNyZXNvbHV0aW9uXG4iLCBpbmRlbnQsICIiKTsKKwkJLyogVE9ETyAqLworCX0KKwlpZiAoaW5mby0+bGFuZ3VhZ2UpIHsKKwkJQklPX3ByaW50ZihvdXQsICIlKnNsYW5ndWFnZTogIiwgaW5kZW50LCAiIik7CisJCUFTTjFfU1RSSU5HX3ByaW50KG91dCwgaW5mby0+bGFuZ3VhZ2UpOworCQlCSU9fcHJpbnRmKG91dCwgIlxuIik7CisJfQorfQorCitzdGF0aWMgdm9pZCBpMnJfTG9nb3R5cGVJbWFnZShMb2dvdHlwZUltYWdlICppbWFnZSwgQklPICpvdXQsIGludCBpbmRlbnQpCit7CisJQklPX3ByaW50ZihvdXQsICIlKnNMb2dvdHlwZUltYWdlXG4iLCBpbmRlbnQsICIiKTsKKwlpZiAoaW1hZ2UtPmltYWdlRGV0YWlscykgeworCQlpMnJfTG9nb3R5cGVEZXRhaWxzKGltYWdlLT5pbWFnZURldGFpbHMsIG91dCwgaW5kZW50ICsgNCk7CisJfQorCWlmIChpbWFnZS0+aW1hZ2VJbmZvKSB7CisJCWkycl9Mb2dvdHlwZUltYWdlSW5mbyhpbWFnZS0+aW1hZ2VJbmZvLCBvdXQsIGluZGVudCArIDQpOworCX0KK30KKworc3RhdGljIHZvaWQgaTJyX0xvZ290eXBlRGF0YShMb2dvdHlwZURhdGEgKmRhdGEsIGNvbnN0IGNoYXIgKnRpdGxlLCBCSU8gKm91dCwKKwkJCSAgICAgaW50IGluZGVudCkKK3sKKwlpbnQgaSwgbnVtOworCisJQklPX3ByaW50ZihvdXQsICIlKnMlcyAtIExvZ290eXBlRGF0YVxuIiwgaW5kZW50LCAiIiwgdGl0bGUpOworCisJbnVtID0gZGF0YS0+aW1hZ2UgPyBza19Mb2dvdHlwZUltYWdlX251bShkYXRhLT5pbWFnZSkgOiAwOworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQlMb2dvdHlwZUltYWdlICppbWFnZSA9IHNrX0xvZ290eXBlSW1hZ2VfdmFsdWUoZGF0YS0+aW1hZ2UsIGkpOworCQlpMnJfTG9nb3R5cGVJbWFnZShpbWFnZSwgb3V0LCBpbmRlbnQgKyA0KTsKKwl9CisKKwludW0gPSBkYXRhLT5hdWRpbyA/IHNrX0xvZ290eXBlQXVkaW9fbnVtKGRhdGEtPmF1ZGlvKSA6IDA7CisJZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKSB7CisJCUJJT19wcmludGYob3V0LCAiJSpzYXVkaW86IFRPRE9cbiIsIGluZGVudCwgIiIpOworCX0KK30KKworc3RhdGljIHZvaWQgaTJyX0xvZ290eXBlUmVmZXJlbmNlKExvZ290eXBlUmVmZXJlbmNlICpyZWYsIGNvbnN0IGNoYXIgKnRpdGxlLAorCQkJCSAgQklPICpvdXQsIGludCBpbmRlbnQpCit7CisJaW50IGksIGhhc2hfbnVtLCB1cmlfbnVtOworCisJQklPX3ByaW50ZihvdXQsICIlKnMlcyAtIExvZ290eXBlUmVmZXJlbmNlXG4iLCBpbmRlbnQsICIiLCB0aXRsZSk7CisKKwloYXNoX251bSA9IHJlZi0+cmVmU3RydWN0SGFzaCA/CisJCXNrX0hhc2hBbGdBbmRWYWx1ZV9udW0ocmVmLT5yZWZTdHJ1Y3RIYXNoKSA6IDA7CisJdXJpX251bSA9IHJlZi0+cmVmU3RydWN0VVJJID8KKwkJc2tfQVNOMV9JQTVTVFJJTkdfbnVtKHJlZi0+cmVmU3RydWN0VVJJKSA6IDA7CisJaWYgKGhhc2hfbnVtICE9IHVyaV9udW0pIHsKKwkJQklPX3ByaW50ZihvdXQsICIlKnNVbmV4cGVjdGVkIExvZ290eXBlUmVmZXJlbmNlIGFycmF5IHNpemUgZGlmZmVyZW5jZSAlZCAhPSAlZFxuIiwKKwkJCSAgIGluZGVudCwgIiIsIGhhc2hfbnVtLCB1cmlfbnVtKTsKKwkJcmV0dXJuOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBoYXNoX251bTsgaSsrKSB7CisJCUhhc2hBbGdBbmRWYWx1ZSAqaGFzaDsKKwkJQVNOMV9JQTVTVFJJTkcgKnVyaTsKKworCQloYXNoID0gc2tfSGFzaEFsZ0FuZFZhbHVlX3ZhbHVlKHJlZi0+cmVmU3RydWN0SGFzaCwgaSk7CisJCWkycl9IYXNoQWxnQW5kVmFsdWUoaGFzaCwgb3V0LCBpbmRlbnQpOworCisJCXVyaSA9IHNrX0FTTjFfSUE1U1RSSU5HX3ZhbHVlKHJlZi0+cmVmU3RydWN0VVJJLCBpKTsKKwkJQklPX3ByaW50ZihvdXQsICIlKnNyZWZTdHJ1Y3RVUkk6ICIsIGluZGVudCwgIiIpOworCQlBU04xX1NUUklOR19wcmludChvdXQsIHVyaSk7CisJCUJJT19wcmludGYob3V0LCAiXG4iKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGkycl9Mb2dvdHlwZUluZm8oTG9nb3R5cGVJbmZvICppbmZvLCBjb25zdCBjaGFyICp0aXRsZSwgQklPICpvdXQsCisJCQkgICAgIGludCBpbmRlbnQpCit7CisJc3dpdGNoIChpbmZvLT50eXBlKSB7CisJY2FzZSAwOgorCQlpMnJfTG9nb3R5cGVEYXRhKGluZm8tPmQuZGlyZWN0LCB0aXRsZSwgb3V0LCBpbmRlbnQpOworCQlicmVhazsKKwljYXNlIDE6CisJCWkycl9Mb2dvdHlwZVJlZmVyZW5jZShpbmZvLT5kLmluZGlyZWN0LCB0aXRsZSwgb3V0LCBpbmRlbnQpOworCQlicmVhazsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGRlYnVnX3ByaW50X2xvZ290eXBlZXh0KExvZ290eXBlRXh0biAqbG9nbykKK3sKKwlCSU8gKm91dDsKKwlpbnQgaSwgbnVtOworCWludCBpbmRlbnQgPSAwOworCisJb3V0ID0gQklPX25ld19mcChzdGRvdXQsIEJJT19OT0NMT1NFKTsKKwlpZiAob3V0ID09IE5VTEwpCisJCXJldHVybjsKKworCWlmIChsb2dvLT5jb21tdW5pdHlMb2dvcykgeworCQludW0gPSBza19Mb2dvdHlwZUluZm9fbnVtKGxvZ28tPmNvbW11bml0eUxvZ29zKTsKKwkJZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKSB7CisJCQlMb2dvdHlwZUluZm8gKmluZm87CisJCQlpbmZvID0gc2tfTG9nb3R5cGVJbmZvX3ZhbHVlKGxvZ28tPmNvbW11bml0eUxvZ29zLCBpKTsKKwkJCWkycl9Mb2dvdHlwZUluZm8oaW5mbywgImNvbW11bml0eUxvZ28iLCBvdXQsIGluZGVudCk7CisJCX0KKwl9CisKKwlpZiAobG9nby0+aXNzdWVyTG9nbykgeworCQlpMnJfTG9nb3R5cGVJbmZvKGxvZ28tPmlzc3VlckxvZ28sICJpc3N1ZXJMb2dvIiwgb3V0LCBpbmRlbnQgKTsKKwl9CisKKwlpZiAobG9nby0+c3ViamVjdExvZ28pIHsKKwkJaTJyX0xvZ290eXBlSW5mbyhsb2dvLT5zdWJqZWN0TG9nbywgInN1YmplY3RMb2dvIiwgb3V0LCBpbmRlbnQpOworCX0KKworCWlmIChsb2dvLT5vdGhlckxvZ29zKSB7CisJCUJJT19wcmludGYob3V0LCAiJSpzb3RoZXJMb2dvcyAtIFRPRE9cbiIsIGluZGVudCwgIiIpOworCX0KKworCUJJT19mcmVlKG91dCk7Cit9CisKKworc3RhdGljIHZvaWQgYWRkX2xvZ290eXBlX2V4dChzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgc3RydWN0IGh0dHBfY2VydCAqaGNlcnQsCisJCQkgICAgIFg1MDkgKmNlcnQpCit7CisJQVNOMV9PQkpFQ1QgKm9iajsKKwlpbnQgcG9zOworCVg1MDlfRVhURU5TSU9OICpleHQ7CisJQVNOMV9PQ1RFVF9TVFJJTkcgKm9zOworCUxvZ290eXBlRXh0biAqbG9nbzsKKwljb25zdCB1bnNpZ25lZCBjaGFyICpkYXRhOworCWludCBpLCBudW07CisKKwlvYmogPSBPQkpfdHh0Mm9iaigiMS4zLjYuMS41LjUuNy4xLjEyIiwgMCk7CisJaWYgKG9iaiA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlwb3MgPSBYNTA5X2dldF9leHRfYnlfT0JKKGNlcnQsIG9iaiwgLTEpOworCWlmIChwb3MgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJObyBsb2dvdHlwZSBleHRlbnNpb24gaW5jbHVkZWQiKTsKKwkJcmV0dXJuOworCX0KKworCXdwYV9wcmludGYoTVNHX0lORk8sICJQYXJzaW5nIGxvZ290eXBlIGV4dGVuc2lvbiIpOworCWV4dCA9IFg1MDlfZ2V0X2V4dChjZXJ0LCBwb3MpOworCWlmICghZXh0KSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgZ2V0IGxvZ290eXBlIGV4dGVuc2lvbiIpOworCQlyZXR1cm47CisJfQorCisJb3MgPSBYNTA5X0VYVEVOU0lPTl9nZXRfZGF0YShleHQpOworCWlmIChvcyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgZ2V0IGxvZ290eXBlIGV4dGVuc2lvbiBkYXRhIik7CisJCXJldHVybjsKKwl9CisKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJsb2dvdHlwZUV4dG4iLAorCQkgICAgQVNOMV9TVFJJTkdfZGF0YShvcyksIEFTTjFfU1RSSU5HX2xlbmd0aChvcykpOworCisJZGF0YSA9IEFTTjFfU1RSSU5HX2RhdGEob3MpOworCWxvZ28gPSBkMmlfTG9nb3R5cGVFeHRuKE5VTEwsICZkYXRhLCBBU04xX1NUUklOR19sZW5ndGgob3MpKTsKKwlpZiAobG9nbyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJGYWlsZWQgdG8gcGFyc2UgbG9nb3R5cGVFeHRuIik7CisJCXJldHVybjsKKwl9CisKKwlpZiAod3BhX2RlYnVnX2xldmVsIDwgTVNHX0lORk8pCisJCWRlYnVnX3ByaW50X2xvZ290eXBlZXh0KGxvZ28pOworCisJaWYgKCFsb2dvLT5jb21tdW5pdHlMb2dvcykgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gY29tbXVuaXR5TG9nb3MgaW5jbHVkZWQiKTsKKwkJTG9nb3R5cGVFeHRuX2ZyZWUobG9nbyk7CisJCXJldHVybjsKKwl9CisKKwludW0gPSBza19Mb2dvdHlwZUluZm9fbnVtKGxvZ28tPmNvbW11bml0eUxvZ29zKTsKKwlmb3IgKGkgPSAwOyBpIDwgbnVtOyBpKyspIHsKKwkJTG9nb3R5cGVJbmZvICppbmZvOworCQlpbmZvID0gc2tfTG9nb3R5cGVJbmZvX3ZhbHVlKGxvZ28tPmNvbW11bml0eUxvZ29zLCBpKTsKKwkJc3dpdGNoIChpbmZvLT50eXBlKSB7CisJCWNhc2UgMDoKKwkJCWFkZF9sb2dvX2RpcmVjdChjdHgsIGhjZXJ0LCBpbmZvLT5kLmRpcmVjdCk7CisJCQlicmVhazsKKwkJY2FzZSAxOgorCQkJYWRkX2xvZ29faW5kaXJlY3QoY3R4LCBoY2VydCwgaW5mby0+ZC5pbmRpcmVjdCk7CisJCQlicmVhazsKKwkJfQorCX0KKworCUxvZ290eXBlRXh0bl9mcmVlKGxvZ28pOworfQorCisKK3N0YXRpYyB2b2lkIHBhcnNlX2NlcnQoc3RydWN0IGh0dHBfY3R4ICpjdHgsIHN0cnVjdCBodHRwX2NlcnQgKmhjZXJ0LAorCQkgICAgICAgWDUwOSAqY2VydCwgR0VORVJBTF9OQU1FUyAqKm5hbWVzKQoreworCW9zX21lbXNldChoY2VydCwgMCwgc2l6ZW9mKCpoY2VydCkpOworCisJKm5hbWVzID0gWDUwOV9nZXRfZXh0X2QyaShjZXJ0LCBOSURfc3ViamVjdF9hbHRfbmFtZSwgTlVMTCwgTlVMTCk7CisJaWYgKCpuYW1lcykKKwkJYWRkX2FsdF9uYW1lcyhjdHgsIGhjZXJ0LCAqbmFtZXMpOworCisJYWRkX2xvZ290eXBlX2V4dChjdHgsIGhjZXJ0LCBjZXJ0KTsKK30KKworCitzdGF0aWMgdm9pZCBwYXJzZV9jZXJ0X2ZyZWUoc3RydWN0IGh0dHBfY2VydCAqaGNlcnQsIEdFTkVSQUxfTkFNRVMgKm5hbWVzKQoreworCXVuc2lnbmVkIGludCBpOworCisJZm9yIChpID0gMDsgaSA8IGhjZXJ0LT5udW1fZG5zbmFtZTsgaSsrKQorCQlPUEVOU1NMX2ZyZWUoaGNlcnQtPmRuc25hbWVbaV0pOworCW9zX2ZyZWUoaGNlcnQtPmRuc25hbWUpOworCisJZm9yIChpID0gMDsgaSA8IGhjZXJ0LT5udW1fb3RoZXJuYW1lOyBpKyspCisJCW9zX2ZyZWUoaGNlcnQtPm90aGVybmFtZVtpXS5vaWQpOworCW9zX2ZyZWUoaGNlcnQtPm90aGVybmFtZSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgaGNlcnQtPm51bV9sb2dvOyBpKyspIHsKKwkJb3NfZnJlZShoY2VydC0+bG9nb1tpXS5hbGdfb2lkKTsKKwkJb3NfZnJlZShoY2VydC0+bG9nb1tpXS5oYXNoKTsKKwkJb3NfZnJlZShoY2VydC0+bG9nb1tpXS51cmkpOworCX0KKwlvc19mcmVlKGhjZXJ0LT5sb2dvKTsKKworCXNrX0dFTkVSQUxfTkFNRV9wb3BfZnJlZShuYW1lcywgR0VORVJBTF9OQU1FX2ZyZWUpOworfQorCisKK3N0YXRpYyBpbnQgdmFsaWRhdGVfc2VydmVyX2NlcnQoc3RydWN0IGh0dHBfY3R4ICpjdHgsIFg1MDkgKmNlcnQpCit7CisJR0VORVJBTF9OQU1FUyAqbmFtZXM7CisJc3RydWN0IGh0dHBfY2VydCBoY2VydDsKKwlpbnQgcmV0OworCisJaWYgKGN0eC0+Y2VydF9jYiA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKworCWlmICgwKSB7CisJCUJJTyAqb3V0OworCQlvdXQgPSBCSU9fbmV3X2ZwKHN0ZG91dCwgQklPX05PQ0xPU0UpOworCQlYNTA5X3ByaW50X2V4KG91dCwgY2VydCwgWE5fRkxBR19DT01QQVQsIFg1MDlfRkxBR19DT01QQVQpOworCQlCSU9fZnJlZShvdXQpOworCX0KKworCXBhcnNlX2NlcnQoY3R4LCAmaGNlcnQsIGNlcnQsICZuYW1lcyk7CisJcmV0ID0gY3R4LT5jZXJ0X2NiKGN0eC0+Y2VydF9jYl9jdHgsICZoY2VydCk7CisJcGFyc2VfY2VydF9mcmVlKCZoY2VydCwgbmFtZXMpOworCisJcmV0dXJuIHJldDsKK30KKworCit2b2lkIGh0dHBfcGFyc2VfeDUwOV9jZXJ0aWZpY2F0ZShzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgY29uc3QgY2hhciAqZm5hbWUpCit7CisJQklPICppbiwgKm91dDsKKwlYNTA5ICpjZXJ0OworCUdFTkVSQUxfTkFNRVMgKm5hbWVzOworCXN0cnVjdCBodHRwX2NlcnQgaGNlcnQ7CisJdW5zaWduZWQgaW50IGk7CisKKwlpbiA9IEJJT19uZXdfZmlsZShmbmFtZSwgInIiKTsKKwlpZiAoaW4gPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCByZWFkICclcyciLCBmbmFtZSk7CisJCXJldHVybjsKKwl9CisKKwljZXJ0ID0gZDJpX1g1MDlfYmlvKGluLCBOVUxMKTsKKwlCSU9fZnJlZShpbik7CisKKwlpZiAoY2VydCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ291bGQgbm90IHBhcnNlIGNlcnRpZmljYXRlIik7CisJCXJldHVybjsKKwl9CisKKwlvdXQgPSBCSU9fbmV3X2ZwKHN0ZG91dCwgQklPX05PQ0xPU0UpOworCWlmIChvdXQpIHsKKwkJWDUwOV9wcmludF9leChvdXQsIGNlcnQsIFhOX0ZMQUdfQ09NUEFULAorCQkJICAgICAgWDUwOV9GTEFHX0NPTVBBVCk7CisJCUJJT19mcmVlKG91dCk7CisJfQorCisJd3BhX3ByaW50ZihNU0dfSU5GTywgIkFkZGl0aW9uYWwgcGFyc2luZyBpbmZvcm1hdGlvbjoiKTsKKwlwYXJzZV9jZXJ0KGN0eCwgJmhjZXJ0LCBjZXJ0LCAmbmFtZXMpOworCWZvciAoaSA9IDA7IGkgPCBoY2VydC5udW1fb3RoZXJuYW1lOyBpKyspIHsKKwkJaWYgKG9zX3N0cmNtcChoY2VydC5vdGhlcm5hbWVbaV0ub2lkLAorCQkJICAgICAgIjEuMy42LjEuNC4xLjQwODA4LjEuMS4xIikgPT0gMCkgeworCQkJY2hhciAqbmFtZSA9IG9zX3phbGxvYyhoY2VydC5vdGhlcm5hbWVbaV0ubGVuICsgMSk7CisJCQlpZiAobmFtZSkgeworCQkJCW9zX21lbWNweShuYW1lLCBoY2VydC5vdGhlcm5hbWVbaV0uZGF0YSwKKwkJCQkJICBoY2VydC5vdGhlcm5hbWVbaV0ubGVuKTsKKwkJCQl3cGFfcHJpbnRmKE1TR19JTkZPLAorCQkJCQkgICAiaWQtd2ZhLWhvdHNwb3QtZnJpZW5kbHlOYW1lOiAlcyIsCisJCQkJCSAgIG5hbWUpOworCQkJCW9zX2ZyZWUobmFtZSk7CisJCQl9CisJCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfSU5GTywKKwkJCQkJICAiaWQtd2ZhLWhvdHNwb3QtZnJpZW5kbHlOYW1lIiwKKwkJCQkJICBoY2VydC5vdGhlcm5hbWVbaV0uZGF0YSwKKwkJCQkJICBoY2VydC5vdGhlcm5hbWVbaV0ubGVuKTsKKwkJfSBlbHNlIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJzdWJqQWx0TmFtZVtvdGhlcm5hbWVdOiBvaWQ9JXMiLAorCQkJCSAgIGhjZXJ0Lm90aGVybmFtZVtpXS5vaWQpOworCQkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0lORk8sICJ1bmtub3duIG90aGVybmFtZSIsCisJCQkJCSAgaGNlcnQub3RoZXJuYW1lW2ldLmRhdGEsCisJCQkJCSAgaGNlcnQub3RoZXJuYW1lW2ldLmxlbik7CisJCX0KKwl9CisJcGFyc2VfY2VydF9mcmVlKCZoY2VydCwgbmFtZXMpOworCisJWDUwOV9mcmVlKGNlcnQpOworfQorCisKK3N0YXRpYyBpbnQgY3VybF9jYl9zc2xfdmVyaWZ5KGludCBwcmV2ZXJpZnlfb2ssIFg1MDlfU1RPUkVfQ1RYICp4NTA5X2N0eCkKK3sKKwlzdHJ1Y3QgaHR0cF9jdHggKmN0eDsKKwlYNTA5ICpjZXJ0OworCWludCBlcnIsIGRlcHRoOworCWNoYXIgYnVmWzI1Nl07CisJWDUwOV9OQU1FICpuYW1lOworCWNvbnN0IGNoYXIgKmVycl9zdHI7CisJU1NMICpzc2w7CisJU1NMX0NUWCAqc3NsX2N0eDsKKworCXNzbCA9IFg1MDlfU1RPUkVfQ1RYX2dldF9leF9kYXRhKHg1MDlfY3R4LAorCQkJCQkgU1NMX2dldF9leF9kYXRhX1g1MDlfU1RPUkVfQ1RYX2lkeCgpKTsKKwlzc2xfY3R4ID0gc3NsLT5jdHg7CisJY3R4ID0gU1NMX0NUWF9nZXRfYXBwX2RhdGEoc3NsX2N0eCk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgImN1cmxfY2Jfc3NsX3ZlcmlmeSIpOworCisJZXJyID0gWDUwOV9TVE9SRV9DVFhfZ2V0X2Vycm9yKHg1MDlfY3R4KTsKKwllcnJfc3RyID0gWDUwOV92ZXJpZnlfY2VydF9lcnJvcl9zdHJpbmcoZXJyKTsKKwlkZXB0aCA9IFg1MDlfU1RPUkVfQ1RYX2dldF9lcnJvcl9kZXB0aCh4NTA5X2N0eCk7CisJY2VydCA9IFg1MDlfU1RPUkVfQ1RYX2dldF9jdXJyZW50X2NlcnQoeDUwOV9jdHgpOworCWlmICghY2VydCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTm8gc2VydmVyIGNlcnRpZmljYXRlIGF2YWlsYWJsZSIpOworCQljdHgtPmxhc3RfZXJyID0gIk5vIHNlcnZlciBjZXJ0aWZpY2F0ZSBhdmFpbGFibGUiOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAoZGVwdGggPT0gMCkKKwkJY3R4LT5wZWVyX2NlcnQgPSBjZXJ0OworCWVsc2UgaWYgKGRlcHRoID09IDEpCisJCWN0eC0+cGVlcl9pc3N1ZXIgPSBjZXJ0OworCWVsc2UgaWYgKGRlcHRoID09IDIpCisJCWN0eC0+cGVlcl9pc3N1ZXJfaXNzdWVyID0gY2VydDsKKworCW5hbWUgPSBYNTA5X2dldF9zdWJqZWN0X25hbWUoY2VydCk7CisJWDUwOV9OQU1FX29uZWxpbmUobmFtZSwgYnVmLCBzaXplb2YoYnVmKSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNlcnZlciBjZXJ0aWZpY2F0ZSBjaGFpbiAtIGRlcHRoPSVkIGVycj0lZCAoJXMpIHN1YmplY3Q9JXMiLAorCQkgICBkZXB0aCwgZXJyLCBlcnJfc3RyLCBidWYpOworCWRlYnVnX2R1bXBfY2VydCgiU2VydmVyIGNlcnRpZmljYXRlIGNoYWluIC0gY2VydGlmaWNhdGUiLCBjZXJ0KTsKKworCWlmIChkZXB0aCA9PSAwICYmIHByZXZlcmlmeV9vayAmJiB2YWxpZGF0ZV9zZXJ2ZXJfY2VydChjdHgsIGNlcnQpIDwgMCkKKwkJcmV0dXJuIDA7CisKKwlpZiAoIXByZXZlcmlmeV9vaykKKwkJY3R4LT5sYXN0X2VyciA9ICJUTFMgdmFsaWRhdGlvbiBmYWlsZWQiOworCisJcmV0dXJuIHByZXZlcmlmeV9vazsKK30KKworCisjaWZkZWYgSEFWRV9PQ1NQCisKK3N0YXRpYyB2b2lkIG9jc3BfZGVidWdfcHJpbnRfcmVzcChPQ1NQX1JFU1BPTlNFICpyc3ApCit7CisJQklPICpvdXQ7CisJc2l6ZV90IHJsZW47CisJY2hhciAqdHh0OworCWludCByZXM7CisKKwlvdXQgPSBCSU9fbmV3KEJJT19zX21lbSgpKTsKKwlpZiAoIW91dCkKKwkJcmV0dXJuOworCisJT0NTUF9SRVNQT05TRV9wcmludChvdXQsIHJzcCwgMCk7CisJcmxlbiA9IEJJT19jdHJsX3BlbmRpbmcob3V0KTsKKwl0eHQgPSBvc19tYWxsb2MocmxlbiArIDEpOworCWlmICghdHh0KSB7CisJCUJJT19mcmVlKG91dCk7CisJCXJldHVybjsKKwl9CisKKwlyZXMgPSBCSU9fcmVhZChvdXQsIHR4dCwgcmxlbik7CisJaWYgKHJlcyA+IDApIHsKKwkJdHh0W3Jlc10gPSAnXDAnOworCQl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiT3BlblNTTDogT0NTUCBSZXNwb25zZVxuJXMiLCB0eHQpOworCX0KKwlvc19mcmVlKHR4dCk7CisJQklPX2ZyZWUob3V0KTsKK30KKworCitzdGF0aWMgdm9pZCB0bHNfc2hvd19lcnJvcnMoY29uc3QgY2hhciAqZnVuYywgY29uc3QgY2hhciAqdHh0KQoreworCXVuc2lnbmVkIGxvbmcgZXJyOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPcGVuU1NMOiAlcyAtICVzICVzIiwKKwkJICAgZnVuYywgdHh0LCBFUlJfZXJyb3Jfc3RyaW5nKEVSUl9nZXRfZXJyb3IoKSwgTlVMTCkpOworCisJd2hpbGUgKChlcnIgPSBFUlJfZ2V0X2Vycm9yKCkpKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT3BlblNTTDogcGVuZGluZyBlcnJvcjogJXMiLAorCQkJICAgRVJSX2Vycm9yX3N0cmluZyhlcnIsIE5VTEwpKTsKKwl9Cit9CisKKworc3RhdGljIGludCBvY3NwX3Jlc3BfY2IoU1NMICpzLCB2b2lkICphcmcpCit7CisJc3RydWN0IGh0dHBfY3R4ICpjdHggPSBhcmc7CisJY29uc3QgdW5zaWduZWQgY2hhciAqcDsKKwlpbnQgbGVuLCBzdGF0dXMsIHJlYXNvbjsKKwlPQ1NQX1JFU1BPTlNFICpyc3A7CisJT0NTUF9CQVNJQ1JFU1AgKmJhc2ljOworCU9DU1BfQ0VSVElEICppZDsKKwlBU04xX0dFTkVSQUxJWkVEVElNRSAqcHJvZHVjZWRfYXQsICp0aGlzX3VwZGF0ZSwgKm5leHRfdXBkYXRlOworCVg1MDlfU1RPUkUgKnN0b3JlOworCVNUQUNLX09GKFg1MDkpICpjZXJ0cyA9IE5VTEw7CisKKwlsZW4gPSBTU0xfZ2V0X3Rsc2V4dF9zdGF0dXNfb2NzcF9yZXNwKHMsICZwKTsKKwlpZiAoIXApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPcGVuU1NMOiBObyBPQ1NQIHJlc3BvbnNlIHJlY2VpdmVkIik7CisJCWlmIChjdHgtPm9jc3AgPT0gTUFOREFUT1JZX09DU1ApCisJCQljdHgtPmxhc3RfZXJyID0gIk5vIE9DU1AgcmVzcG9uc2UgcmVjZWl2ZWQiOworCQlyZXR1cm4gKGN0eC0+b2NzcCA9PSBNQU5EQVRPUllfT0NTUCkgPyAwIDogMTsKKwl9CisKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJPcGVuU1NMOiBPQ1NQIHJlc3BvbnNlIiwgcCwgbGVuKTsKKworCXJzcCA9IGQyaV9PQ1NQX1JFU1BPTlNFKE5VTEwsICZwLCBsZW4pOworCWlmICghcnNwKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJPcGVuU1NMOiBGYWlsZWQgdG8gcGFyc2UgT0NTUCByZXNwb25zZSIpOworCQljdHgtPmxhc3RfZXJyID0gIkZhaWxlZCB0byBwYXJzZSBPQ1NQIHJlc3BvbnNlIjsKKwkJcmV0dXJuIDA7CisJfQorCisJb2NzcF9kZWJ1Z19wcmludF9yZXNwKHJzcCk7CisKKwlzdGF0dXMgPSBPQ1NQX3Jlc3BvbnNlX3N0YXR1cyhyc3ApOworCWlmIChzdGF0dXMgIT0gT0NTUF9SRVNQT05TRV9TVEFUVVNfU1VDQ0VTU0ZVTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiT3BlblNTTDogT0NTUCByZXNwb25kZXIgZXJyb3IgJWQgKCVzKSIsCisJCQkgICBzdGF0dXMsIE9DU1BfcmVzcG9uc2Vfc3RhdHVzX3N0cihzdGF0dXMpKTsKKwkJY3R4LT5sYXN0X2VyciA9ICJPQ1NQIHJlc3BvbmRlciBlcnJvciI7CisJCXJldHVybiAwOworCX0KKworCWJhc2ljID0gT0NTUF9yZXNwb25zZV9nZXQxX2Jhc2ljKHJzcCk7CisJaWYgKCFiYXNpYykgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiT3BlblNTTDogQ291bGQgbm90IGZpbmQgQmFzaWNPQ1NQUmVzcG9uc2UiKTsKKwkJY3R4LT5sYXN0X2VyciA9ICJDb3VsZCBub3QgZmluZCBCYXNpY09DU1BSZXNwb25zZSI7CisJCXJldHVybiAwOworCX0KKworCXN0b3JlID0gU1NMX0NUWF9nZXRfY2VydF9zdG9yZShzLT5jdHgpOworCWlmIChjdHgtPnBlZXJfaXNzdWVyKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT3BlblNTTDogQWRkIGlzc3VlciIpOworCQlkZWJ1Z19kdW1wX2NlcnQoIk9wZW5TU0w6IElzc3VlciBjZXJ0aWZpY2F0ZSIsCisJCQkJY3R4LT5wZWVyX2lzc3Vlcik7CisKKwkJaWYgKFg1MDlfU1RPUkVfYWRkX2NlcnQoc3RvcmUsIGN0eC0+cGVlcl9pc3N1ZXIpICE9IDEpIHsKKwkJCXRsc19zaG93X2Vycm9ycyhfX2Z1bmNfXywKKwkJCQkJIk9wZW5TU0w6IENvdWxkIG5vdCBhZGQgaXNzdWVyIHRvIGNlcnRpZmljYXRlIHN0b3JlXG4iKTsKKwkJfQorCQljZXJ0cyA9IHNrX1g1MDlfbmV3X251bGwoKTsKKwkJaWYgKGNlcnRzKSB7CisJCQlYNTA5ICpjZXJ0OworCQkJY2VydCA9IFg1MDlfZHVwKGN0eC0+cGVlcl9pc3N1ZXIpOworCQkJaWYgKGNlcnQgJiYgIXNrX1g1MDlfcHVzaChjZXJ0cywgY2VydCkpIHsKKwkJCQl0bHNfc2hvd19lcnJvcnMoCisJCQkJCV9fZnVuY19fLAorCQkJCQkiT3BlblNTTDogQ291bGQgbm90IGFkZCBpc3N1ZXIgdG8gT0NTUCByZXNwb25kZXIgdHJ1c3Qgc3RvcmVcbiIpOworCQkJCVg1MDlfZnJlZShjZXJ0KTsKKwkJCQlza19YNTA5X2ZyZWUoY2VydHMpOworCQkJCWNlcnRzID0gTlVMTDsKKwkJCX0KKwkJCWlmIChjdHgtPnBlZXJfaXNzdWVyX2lzc3VlcikgeworCQkJCVg1MDkgKmNlcnQ7CisJCQkJY2VydCA9IFg1MDlfZHVwKGN0eC0+cGVlcl9pc3N1ZXJfaXNzdWVyKTsKKwkJCQlpZiAoY2VydCAmJiAhc2tfWDUwOV9wdXNoKGNlcnRzLCBjZXJ0KSkgeworCQkJCQl0bHNfc2hvd19lcnJvcnMoCisJCQkJCQlfX2Z1bmNfXywKKwkJCQkJCSJPcGVuU1NMOiBDb3VsZCBub3QgYWRkIGlzc3VlciB0byBPQ1NQIHJlc3BvbmRlciB0cnVzdCBzdG9yZVxuIik7CisJCQkJCVg1MDlfZnJlZShjZXJ0KTsKKwkJCQl9CisJCQl9CisJCX0KKwl9CisKKwlzdGF0dXMgPSBPQ1NQX2Jhc2ljX3ZlcmlmeShiYXNpYywgY2VydHMsIHN0b3JlLCBPQ1NQX1RSVVNUT1RIRVIpOworCXNrX1g1MDlfcG9wX2ZyZWUoY2VydHMsIFg1MDlfZnJlZSk7CisJaWYgKHN0YXR1cyA8PSAwKSB7CisJCXRsc19zaG93X2Vycm9ycyhfX2Z1bmNfXywKKwkJCQkiT3BlblNTTDogT0NTUCByZXNwb25zZSBmYWlsZWQgdmVyaWZpY2F0aW9uIik7CisJCU9DU1BfQkFTSUNSRVNQX2ZyZWUoYmFzaWMpOworCQlPQ1NQX1JFU1BPTlNFX2ZyZWUocnNwKTsKKwkJY3R4LT5sYXN0X2VyciA9ICJPQ1NQIHJlc3BvbnNlIGZhaWxlZCB2ZXJpZmljYXRpb24iOworCQlyZXR1cm4gMDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6IE9DU1AgcmVzcG9uc2UgdmVyaWZpY2F0aW9uIHN1Y2NlZWRlZCIpOworCisJaWYgKCFjdHgtPnBlZXJfY2VydCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6IFBlZXIgY2VydGlmaWNhdGUgbm90IGF2YWlsYWJsZSBmb3IgT0NTUCBzdGF0dXMgY2hlY2siKTsKKwkJT0NTUF9CQVNJQ1JFU1BfZnJlZShiYXNpYyk7CisJCU9DU1BfUkVTUE9OU0VfZnJlZShyc3ApOworCQljdHgtPmxhc3RfZXJyID0gIlBlZXIgY2VydGlmaWNhdGUgbm90IGF2YWlsYWJsZSBmb3IgT0NTUCBzdGF0dXMgY2hlY2siOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAoIWN0eC0+cGVlcl9pc3N1ZXIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPcGVuU1NMOiBQZWVyIGlzc3VlciBjZXJ0aWZpY2F0ZSBub3QgYXZhaWxhYmxlIGZvciBPQ1NQIHN0YXR1cyBjaGVjayIpOworCQlPQ1NQX0JBU0lDUkVTUF9mcmVlKGJhc2ljKTsKKwkJT0NTUF9SRVNQT05TRV9mcmVlKHJzcCk7CisJCWN0eC0+bGFzdF9lcnIgPSAiUGVlciBpc3N1ZXIgY2VydGlmaWNhdGUgbm90IGF2YWlsYWJsZSBmb3IgT0NTUCBzdGF0dXMgY2hlY2siOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZCA9IE9DU1BfY2VydF90b19pZChOVUxMLCBjdHgtPnBlZXJfY2VydCwgY3R4LT5wZWVyX2lzc3Vlcik7CisJaWYgKCFpZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6IENvdWxkIG5vdCBjcmVhdGUgT0NTUCBjZXJ0aWZpY2F0ZSBpZGVudGlmaWVyIik7CisJCU9DU1BfQkFTSUNSRVNQX2ZyZWUoYmFzaWMpOworCQlPQ1NQX1JFU1BPTlNFX2ZyZWUocnNwKTsKKwkJY3R4LT5sYXN0X2VyciA9ICJDb3VsZCBub3QgY3JlYXRlIE9DU1AgY2VydGlmaWNhdGUgaWRlbnRpZmllciI7CisJCXJldHVybiAwOworCX0KKworCWlmICghT0NTUF9yZXNwX2ZpbmRfc3RhdHVzKGJhc2ljLCBpZCwgJnN0YXR1cywgJnJlYXNvbiwgJnByb2R1Y2VkX2F0LAorCQkJCSAgICZ0aGlzX3VwZGF0ZSwgJm5leHRfdXBkYXRlKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiT3BlblNTTDogQ291bGQgbm90IGZpbmQgY3VycmVudCBzZXJ2ZXIgY2VydGlmaWNhdGUgZnJvbSBPQ1NQIHJlc3BvbnNlJXMiLAorCQkJICAgKGN0eC0+b2NzcCA9PSBNQU5EQVRPUllfT0NTUCkgPyAiIiA6CisJCQkgICAiIChPQ1NQIG5vdCByZXF1aXJlZCkiKTsKKwkJT0NTUF9CQVNJQ1JFU1BfZnJlZShiYXNpYyk7CisJCU9DU1BfUkVTUE9OU0VfZnJlZShyc3ApOworCQlpZiAoY3R4LT5vY3NwID09IE1BTkRBVE9SWV9PQ1NQKQorCisJCQljdHgtPmxhc3RfZXJyID0gIkNvdWxkIG5vdCBmaW5kIGN1cnJlbnQgc2VydmVyIGNlcnRpZmljYXRlIGZyb20gT0NTUCByZXNwb25zZSI7CisJCXJldHVybiAoY3R4LT5vY3NwID09IE1BTkRBVE9SWV9PQ1NQKSA/IDAgOiAxOworCX0KKworCWlmICghT0NTUF9jaGVja192YWxpZGl0eSh0aGlzX3VwZGF0ZSwgbmV4dF91cGRhdGUsIDUgKiA2MCwgLTEpKSB7CisJCXRsc19zaG93X2Vycm9ycyhfX2Z1bmNfXywgIk9wZW5TU0w6IE9DU1Agc3RhdHVzIHRpbWVzIGludmFsaWQiKTsKKwkJT0NTUF9CQVNJQ1JFU1BfZnJlZShiYXNpYyk7CisJCU9DU1BfUkVTUE9OU0VfZnJlZShyc3ApOworCQljdHgtPmxhc3RfZXJyID0gIk9DU1Agc3RhdHVzIHRpbWVzIGludmFsaWQiOworCQlyZXR1cm4gMDsKKwl9CisKKwlPQ1NQX0JBU0lDUkVTUF9mcmVlKGJhc2ljKTsKKwlPQ1NQX1JFU1BPTlNFX2ZyZWUocnNwKTsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT3BlblNTTDogT0NTUCBzdGF0dXMgZm9yIHNlcnZlciBjZXJ0aWZpY2F0ZTogJXMiLAorCQkgICBPQ1NQX2NlcnRfc3RhdHVzX3N0cihzdGF0dXMpKTsKKworCWlmIChzdGF0dXMgPT0gVl9PQ1NQX0NFUlRTVEFUVVNfR09PRCkKKwkJcmV0dXJuIDE7CisJaWYgKHN0YXR1cyA9PSBWX09DU1BfQ0VSVFNUQVRVU19SRVZPS0VEKQorCQljdHgtPmxhc3RfZXJyID0gIlNlcnZlciBjZXJ0aWZpY2F0ZSBoYXMgYmVlbiByZXZva2VkIjsKKwkJcmV0dXJuIDA7CisJaWYgKGN0eC0+b2NzcCA9PSBNQU5EQVRPUllfT0NTUCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6IE9DU1Agc3RhdHVzIHVua25vd24sIGJ1dCBPQ1NQIHJlcXVpcmVkIik7CisJCWN0eC0+bGFzdF9lcnIgPSAiT0NTUCBzdGF0dXMgdW5rbm93biI7CisJCXJldHVybiAwOworCX0KKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9wZW5TU0w6IE9DU1Agc3RhdHVzIHVua25vd24sIGJ1dCBPQ1NQIHdhcyBub3QgcmVxdWlyZWQsIHNvIGFsbG93IGNvbm5lY3Rpb24gdG8gY29udGludWUiKTsKKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgU1NMX01FVEhPRCBwYXRjaF9zc2xfbWV0aG9kOworc3RhdGljIGNvbnN0IFNTTF9NRVRIT0QgKnJlYWxfc3NsX21ldGhvZDsKKworc3RhdGljIGludCBjdXJsX3BhdGNoX3NzbF9uZXcoU1NMICpzKQoreworCVNTTF9DVFggKnNzbCA9IHMtPmN0eDsKKwlpbnQgcmV0OworCisJc3NsLT5tZXRob2QgPSByZWFsX3NzbF9tZXRob2Q7CisJcy0+bWV0aG9kID0gcmVhbF9zc2xfbWV0aG9kOworCisJcmV0ID0gcy0+bWV0aG9kLT5zc2xfbmV3KHMpOworCVNTTF9zZXRfdGxzZXh0X3N0YXR1c190eXBlKHMsIFRMU0VYVF9TVEFUVVNUWVBFX29jc3ApOworCisJcmV0dXJuIHJldDsKK30KKworI2VuZGlmIC8qIEhBVkVfT0NTUCAqLworCisKK3N0YXRpYyBDVVJMY29kZSBjdXJsX2NiX3NzbChDVVJMICpjdXJsLCB2b2lkICpzc2xjdHgsIHZvaWQgKnBhcm0pCit7CisJc3RydWN0IGh0dHBfY3R4ICpjdHggPSBwYXJtOworCVNTTF9DVFggKnNzbCA9IHNzbGN0eDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiY3VybF9jYl9zc2wiKTsKKwlTU0xfQ1RYX3NldF9hcHBfZGF0YShzc2wsIGN0eCk7CisJU1NMX0NUWF9zZXRfdmVyaWZ5KHNzbCwgU1NMX1ZFUklGWV9QRUVSLCBjdXJsX2NiX3NzbF92ZXJpZnkpOworCisjaWZkZWYgSEFWRV9PQ1NQCisJaWYgKGN0eC0+b2NzcCAhPSBOT19PQ1NQKSB7CisJCVNTTF9DVFhfc2V0X3Rsc2V4dF9zdGF0dXNfY2Ioc3NsLCBvY3NwX3Jlc3BfY2IpOworCQlTU0xfQ1RYX3NldF90bHNleHRfc3RhdHVzX2FyZyhzc2wsIGN0eCk7CisKKwkJLyoKKwkJICogVXNlIGEgdGVtcG9yYXJ5IFNTTF9NRVRIT0QgdG8gZ2V0IGEgY2FsbGJhY2sgb24gU1NMX25ldygpCisJCSAqIGZyb20gbGliY3VybCBzaW5jZSB0aGVyZSBpcyBubyBwcm9wZXIgY2FsbGJhY2sgcmVnaXN0cmF0aW9uCisJCSAqIGF2YWlsYWJsZSBmb3IgdGhpcy4KKwkJICovCisJCW9zX21lbXNldCgmcGF0Y2hfc3NsX21ldGhvZCwgMCwgc2l6ZW9mKHBhdGNoX3NzbF9tZXRob2QpKTsKKwkJcGF0Y2hfc3NsX21ldGhvZC5zc2xfbmV3ID0gY3VybF9wYXRjaF9zc2xfbmV3OworCQlyZWFsX3NzbF9tZXRob2QgPSBzc2wtPm1ldGhvZDsKKwkJc3NsLT5tZXRob2QgPSAmcGF0Y2hfc3NsX21ldGhvZDsKKwl9CisjZW5kaWYgLyogSEFWRV9PQ1NQICovCisKKwlyZXR1cm4gQ1VSTEVfT0s7Cit9CisKKyNlbmRpZiAvKiBFQVBfVExTX09QRU5TU0wgKi8KKworCitzdGF0aWMgQ1VSTCAqIHNldHVwX2N1cmxfcG9zdChzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgY29uc3QgY2hhciAqYWRkcmVzcywKKwkJCSAgICAgIGNvbnN0IGNoYXIgKmNhX2ZuYW1lLCBjb25zdCBjaGFyICp1c2VybmFtZSwKKwkJCSAgICAgIGNvbnN0IGNoYXIgKnBhc3N3b3JkLCBjb25zdCBjaGFyICpjbGllbnRfY2VydCwKKwkJCSAgICAgIGNvbnN0IGNoYXIgKmNsaWVudF9rZXkpCit7CisJQ1VSTCAqY3VybDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU3RhcnQgSFRUUCBjbGllbnQ6IGFkZHJlc3M9JXMgY2FfZm5hbWU9JXMgIgorCQkgICAidXNlcm5hbWU9JXMiLCBhZGRyZXNzLCBjYV9mbmFtZSwgdXNlcm5hbWUpOworCisJY3VybCA9IGN1cmxfZWFzeV9pbml0KCk7CisJaWYgKGN1cmwgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfVVJMLCBhZGRyZXNzKTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfUE9TVCwgMUwpOworCWlmIChjYV9mbmFtZSkgeworCQljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfQ0FJTkZPLCBjYV9mbmFtZSk7CisJCWN1cmxfZWFzeV9zZXRvcHQoY3VybCwgQ1VSTE9QVF9TU0xfVkVSSUZZUEVFUiwgMUwpOworI2lmZGVmIEVBUF9UTFNfT1BFTlNTTAorCQljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfU1NMX0NUWF9GVU5DVElPTiwgY3VybF9jYl9zc2wpOworCQljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfU1NMX0NUWF9EQVRBLCBjdHgpOworI2VuZGlmIC8qIEVBUF9UTFNfT1BFTlNTTCAqLworCX0gZWxzZSB7CisJCWN1cmxfZWFzeV9zZXRvcHQoY3VybCwgQ1VSTE9QVF9TU0xfVkVSSUZZUEVFUiwgMEwpOworCX0KKwlpZiAoY2xpZW50X2NlcnQgJiYgY2xpZW50X2tleSkgeworCQljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfU1NMQ0VSVCwgY2xpZW50X2NlcnQpOworCQljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfU1NMS0VZLCBjbGllbnRfa2V5KTsKKwl9CisJLyogVE9ETzogdXNlIGN1cmxfZWFzeV9nZXRpbmZvKCkgd2l0aCBDVVJMSU5GT19DRVJUSU5GTyB0byBmZXRjaAorCSAqIGluZm9ybWF0aW9uIGFib3V0IHRoZSBzZXJ2ZXIgY2VydGlmaWNhdGUgKi8KKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfQ0VSVElORk8sIDFMKTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfREVCVUdGVU5DVElPTiwgY3VybF9jYl9kZWJ1Zyk7CisJY3VybF9lYXN5X3NldG9wdChjdXJsLCBDVVJMT1BUX0RFQlVHREFUQSwgY3R4KTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfV1JJVEVGVU5DVElPTiwgY3VybF9jYl93cml0ZSk7CisJY3VybF9lYXN5X3NldG9wdChjdXJsLCBDVVJMT1BUX1dSSVRFREFUQSwgY3R4KTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfVkVSQk9TRSwgMUwpOworCWlmICh1c2VybmFtZSkgeworCQljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfSFRUUEFVVEgsIENVUkxBVVRIX0FOWVNBRkUpOworCQljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfVVNFUk5BTUUsIHVzZXJuYW1lKTsKKwkJY3VybF9lYXN5X3NldG9wdChjdXJsLCBDVVJMT1BUX1BBU1NXT1JELCBwYXNzd29yZCk7CisJfQorCisJcmV0dXJuIGN1cmw7Cit9CisKKworc3RhdGljIGludCBwb3N0X2luaXRfY2xpZW50KHN0cnVjdCBodHRwX2N0eCAqY3R4LCBjb25zdCBjaGFyICphZGRyZXNzLAorCQkJICAgIGNvbnN0IGNoYXIgKmNhX2ZuYW1lLCBjb25zdCBjaGFyICp1c2VybmFtZSwKKwkJCSAgICBjb25zdCBjaGFyICpwYXNzd29yZCwgY29uc3QgY2hhciAqY2xpZW50X2NlcnQsCisJCQkgICAgY29uc3QgY2hhciAqY2xpZW50X2tleSkKK3sKKwljaGFyICpwb3M7CisJaW50IGNvdW50OworCisJY2xvbmVfc3RyKCZjdHgtPnN2Y19hZGRyZXNzLCBhZGRyZXNzKTsKKwljbG9uZV9zdHIoJmN0eC0+c3ZjX2NhX2ZuYW1lLCBjYV9mbmFtZSk7CisJY2xvbmVfc3RyKCZjdHgtPnN2Y191c2VybmFtZSwgdXNlcm5hbWUpOworCWNsb25lX3N0cigmY3R4LT5zdmNfcGFzc3dvcmQsIHBhc3N3b3JkKTsKKwljbG9uZV9zdHIoJmN0eC0+c3ZjX2NsaWVudF9jZXJ0LCBjbGllbnRfY2VydCk7CisJY2xvbmVfc3RyKCZjdHgtPnN2Y19jbGllbnRfa2V5LCBjbGllbnRfa2V5KTsKKworCS8qCisJICogV29ya2Fyb3VuZCBmb3IgQXBhY2hlICJIb3N0bmFtZSAnRk9PJyBwcm92aWRlZCB2aWEgU05JIGFuZCBob3N0bmFtZQorCSAqICdmb28nIHByb3ZpZGVkIHZpYSBIVFRQIGFyZSBkaWZmZXJlbnQuCisJICovCisJZm9yIChjb3VudCA9IDAsIHBvcyA9IGN0eC0+c3ZjX2FkZHJlc3M7IGNvdW50IDwgMyAmJiBwb3MgJiYgKnBvczsKKwkgICAgIHBvcysrKSB7CisJCWlmICgqcG9zID09ICcvJykKKwkJCWNvdW50Kys7CisJCSpwb3MgPSB0b2xvd2VyKCpwb3MpOworCX0KKworCWN0eC0+Y3VybCA9IHNldHVwX2N1cmxfcG9zdChjdHgsIGN0eC0+c3ZjX2FkZHJlc3MsIGNhX2ZuYW1lLCB1c2VybmFtZSwKKwkJCQkgICAgcGFzc3dvcmQsIGNsaWVudF9jZXJ0LCBjbGllbnRfa2V5KTsKKwlpZiAoY3R4LT5jdXJsID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXJldHVybiAwOworfQorCisKK2ludCBzb2FwX2luaXRfY2xpZW50KHN0cnVjdCBodHRwX2N0eCAqY3R4LCBjb25zdCBjaGFyICphZGRyZXNzLAorCQkgICAgIGNvbnN0IGNoYXIgKmNhX2ZuYW1lLCBjb25zdCBjaGFyICp1c2VybmFtZSwKKwkJICAgICBjb25zdCBjaGFyICpwYXNzd29yZCwgY29uc3QgY2hhciAqY2xpZW50X2NlcnQsCisJCSAgICAgY29uc3QgY2hhciAqY2xpZW50X2tleSkKK3sKKwlpZiAocG9zdF9pbml0X2NsaWVudChjdHgsIGFkZHJlc3MsIGNhX2ZuYW1lLCB1c2VybmFtZSwgcGFzc3dvcmQsCisJCQkgICAgIGNsaWVudF9jZXJ0LCBjbGllbnRfa2V5KSA8IDApCisJCXJldHVybiAtMTsKKworCWN0eC0+Y3VybF9oZHIgPSBjdXJsX3NsaXN0X2FwcGVuZChjdHgtPmN1cmxfaGRyLAorCQkJCQkgICJDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL3NvYXAreG1sIik7CisJY3R4LT5jdXJsX2hkciA9IGN1cmxfc2xpc3RfYXBwZW5kKGN0eC0+Y3VybF9oZHIsICJTT0FQQWN0aW9uOiAiKTsKKwljdHgtPmN1cmxfaGRyID0gY3VybF9zbGlzdF9hcHBlbmQoY3R4LT5jdXJsX2hkciwgIkV4cGVjdDoiKTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN0eC0+Y3VybCwgQ1VSTE9QVF9IVFRQSEVBREVSLCBjdHgtPmN1cmxfaGRyKTsKKworCXJldHVybiAwOworfQorCisKK2ludCBzb2FwX3JlaW5pdF9jbGllbnQoc3RydWN0IGh0dHBfY3R4ICpjdHgpCit7CisJY2hhciAqYWRkcmVzcyA9IE5VTEw7CisJY2hhciAqY2FfZm5hbWUgPSBOVUxMOworCWNoYXIgKnVzZXJuYW1lID0gTlVMTDsKKwljaGFyICpwYXNzd29yZCA9IE5VTEw7CisJY2hhciAqY2xpZW50X2NlcnQgPSBOVUxMOworCWNoYXIgKmNsaWVudF9rZXkgPSBOVUxMOworCWludCByZXQ7CisKKwljbGVhcl9jdXJsKGN0eCk7CisKKwljbG9uZV9zdHIoJmFkZHJlc3MsIGN0eC0+c3ZjX2FkZHJlc3MpOworCWNsb25lX3N0cigmY2FfZm5hbWUsIGN0eC0+c3ZjX2NhX2ZuYW1lKTsKKwljbG9uZV9zdHIoJnVzZXJuYW1lLCBjdHgtPnN2Y191c2VybmFtZSk7CisJY2xvbmVfc3RyKCZwYXNzd29yZCwgY3R4LT5zdmNfcGFzc3dvcmQpOworCWNsb25lX3N0cigmY2xpZW50X2NlcnQsIGN0eC0+c3ZjX2NsaWVudF9jZXJ0KTsKKwljbG9uZV9zdHIoJmNsaWVudF9rZXksIGN0eC0+c3ZjX2NsaWVudF9rZXkpOworCisJcmV0ID0gc29hcF9pbml0X2NsaWVudChjdHgsIGFkZHJlc3MsIGNhX2ZuYW1lLCB1c2VybmFtZSwgcGFzc3dvcmQsCisJCQkgICAgICAgY2xpZW50X2NlcnQsIGNsaWVudF9rZXkpOworCW9zX2ZyZWUoYWRkcmVzcyk7CisJb3NfZnJlZShjYV9mbmFtZSk7CisJc3RyX2NsZWFyX2ZyZWUodXNlcm5hbWUpOworCXN0cl9jbGVhcl9mcmVlKHBhc3N3b3JkKTsKKwlvc19mcmVlKGNsaWVudF9jZXJ0KTsKKwlvc19mcmVlKGNsaWVudF9rZXkpOworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIHZvaWQgZnJlZV9jdXJsX2J1ZihzdHJ1Y3QgaHR0cF9jdHggKmN0eCkKK3sKKwlvc19mcmVlKGN0eC0+Y3VybF9idWYpOworCWN0eC0+Y3VybF9idWYgPSBOVUxMOworCWN0eC0+Y3VybF9idWZfbGVuID0gMDsKK30KKworCit4bWxfbm9kZV90ICogc29hcF9zZW5kX3JlY2VpdmUoc3RydWN0IGh0dHBfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJY2hhciAqc3RyOworCXhtbF9ub2RlX3QgKmVudmVsb3BlLCAqcmV0LCAqcmVzcCwgKm47CisJQ1VSTGNvZGUgcmVzOworCWxvbmcgaHR0cCA9IDA7CisKKwljdHgtPmxhc3RfZXJyID0gTlVMTDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU09BUDogU2VuZGluZyBtZXNzYWdlIik7CisJZW52ZWxvcGUgPSBzb2FwX2J1aWxkX2VudmVsb3BlKGN0eC0+eG1sLCBub2RlKTsKKwlzdHIgPSB4bWxfbm9kZV90b19zdHIoY3R4LT54bWwsIGVudmVsb3BlKTsKKwl4bWxfbm9kZV9mcmVlKGN0eC0+eG1sLCBlbnZlbG9wZSk7CisJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIlNPQVBbJXNdIiwgc3RyKTsKKworCWN1cmxfZWFzeV9zZXRvcHQoY3R4LT5jdXJsLCBDVVJMT1BUX1BPU1RGSUVMRFMsIHN0cik7CisJZnJlZV9jdXJsX2J1ZihjdHgpOworCisJcmVzID0gY3VybF9lYXN5X3BlcmZvcm0oY3R4LT5jdXJsKTsKKwlpZiAocmVzICE9IENVUkxFX09LKSB7CisJCWlmICghY3R4LT5sYXN0X2VycikKKwkJCWN0eC0+bGFzdF9lcnIgPSBjdXJsX2Vhc3lfc3RyZXJyb3IocmVzKTsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJjdXJsX2Vhc3lfcGVyZm9ybSgpIGZhaWxlZDogJXMiLAorCQkJICAgY3R4LT5sYXN0X2Vycik7CisJCW9zX2ZyZWUoc3RyKTsKKwkJZnJlZV9jdXJsX2J1ZihjdHgpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJb3NfZnJlZShzdHIpOworCisJY3VybF9lYXN5X2dldGluZm8oY3R4LT5jdXJsLCBDVVJMSU5GT19SRVNQT05TRV9DT0RFLCAmaHR0cCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTT0FQOiBTZXJ2ZXIgcmVzcG9uc2UgY29kZSAlbGQiLCBodHRwKTsKKwlpZiAoaHR0cCAhPSAyMDApIHsKKwkJY3R4LT5sYXN0X2VyciA9ICJIVFRQIGRvd25sb2FkIGZhaWxlZCI7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJIVFRQIGRvd25sb2FkIGZhaWxlZCAtIGNvZGUgJWxkIiwgaHR0cCk7CisJCWZyZWVfY3VybF9idWYoY3R4KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaWYgKGN0eC0+Y3VybF9idWYgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiU2VydmVyIHJlc3BvbnNlOlxuJXMiLCBjdHgtPmN1cmxfYnVmKTsKKwlyZXNwID0geG1sX25vZGVfZnJvbV9idWYoY3R4LT54bWwsIGN0eC0+Y3VybF9idWYpOworCWZyZWVfY3VybF9idWYoY3R4KTsKKwlpZiAocmVzcCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgcGFyc2UgU09BUCByZXNwb25zZSIpOworCQljdHgtPmxhc3RfZXJyID0gIkNvdWxkIG5vdCBwYXJzZSBTT0FQIHJlc3BvbnNlIjsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0ID0gc29hcF9nZXRfYm9keShjdHgtPnhtbCwgcmVzcCk7CisJaWYgKHJldCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJDb3VsZCBub3QgZ2V0IFNPQVAgYm9keSIpOworCQljdHgtPmxhc3RfZXJyID0gIkNvdWxkIG5vdCBnZXQgU09BUCBib2R5IjsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTT0FQIGJvZHkgbG9jYWxuYW1lOiAnJXMnIiwKKwkJICAgeG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgtPnhtbCwgcmV0KSk7CisJbiA9IHhtbF9ub2RlX2NvcHkoY3R4LT54bWwsIHJldCk7CisJeG1sX25vZGVfZnJlZShjdHgtPnhtbCwgcmVzcCk7CisKKwlyZXR1cm4gbjsKK30KKworCitzdHJ1Y3QgaHR0cF9jdHggKiBodHRwX2luaXRfY3R4KHZvaWQgKnVwcGVyX2N0eCwgc3RydWN0IHhtbF9ub2RlX2N0eCAqeG1sX2N0eCkKK3sKKwlzdHJ1Y3QgaHR0cF9jdHggKmN0eDsKKworCWN0eCA9IG9zX3phbGxvYyhzaXplb2YoKmN0eCkpOworCWlmIChjdHggPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJY3R4LT5jdHggPSB1cHBlcl9jdHg7CisJY3R4LT54bWwgPSB4bWxfY3R4OworCWN0eC0+b2NzcCA9IE9QVElPTkFMX09DU1A7CisKKwljdXJsX2dsb2JhbF9pbml0KENVUkxfR0xPQkFMX0FMTCk7CisKKwlyZXR1cm4gY3R4OworfQorCisKK3ZvaWQgaHR0cF9vY3NwX3NldChzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgaW50IHZhbCkKK3sKKwlpZiAodmFsID09IDApCisJCWN0eC0+b2NzcCA9IE5PX09DU1A7CisJZWxzZSBpZiAodmFsID09IDEpCisJCWN0eC0+b2NzcCA9IE9QVElPTkFMX09DU1A7CisJaWYgKHZhbCA9PSAyKQorCQljdHgtPm9jc3AgPSBNQU5EQVRPUllfT0NTUDsKK30KKworCit2b2lkIGh0dHBfZGVpbml0X2N0eChzdHJ1Y3QgaHR0cF9jdHggKmN0eCkKK3sKKwljbGVhcl9jdXJsKGN0eCk7CisJb3NfZnJlZShjdHgtPmN1cmxfYnVmKTsKKwljdXJsX2dsb2JhbF9jbGVhbnVwKCk7CisKKwlvc19mcmVlKGN0eC0+c3ZjX2FkZHJlc3MpOworCW9zX2ZyZWUoY3R4LT5zdmNfY2FfZm5hbWUpOworCXN0cl9jbGVhcl9mcmVlKGN0eC0+c3ZjX3VzZXJuYW1lKTsKKwlzdHJfY2xlYXJfZnJlZShjdHgtPnN2Y19wYXNzd29yZCk7CisJb3NfZnJlZShjdHgtPnN2Y19jbGllbnRfY2VydCk7CisJb3NfZnJlZShjdHgtPnN2Y19jbGllbnRfa2V5KTsKKworCW9zX2ZyZWUoY3R4KTsKK30KKworCitpbnQgaHR0cF9kb3dubG9hZF9maWxlKHN0cnVjdCBodHRwX2N0eCAqY3R4LCBjb25zdCBjaGFyICp1cmwsCisJCSAgICAgICBjb25zdCBjaGFyICpmbmFtZSwgY29uc3QgY2hhciAqY2FfZm5hbWUpCit7CisJQ1VSTCAqY3VybDsKKwlGSUxFICpmOworCUNVUkxjb2RlIHJlczsKKwlsb25nIGh0dHAgPSAwOworCisJY3R4LT5sYXN0X2VyciA9IE5VTEw7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgImN1cmw6IERvd25sb2FkIGZpbGUgZnJvbSAlcyB0byAlcyAoY2E9JXMpIiwKKwkJICAgdXJsLCBmbmFtZSwgY2FfZm5hbWUpOworCWN1cmwgPSBjdXJsX2Vhc3lfaW5pdCgpOworCWlmIChjdXJsID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCWYgPSBmb3BlbihmbmFtZSwgIndiIik7CisJaWYgKGYgPT0gTlVMTCkgeworCQljdXJsX2Vhc3lfY2xlYW51cChjdXJsKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWN1cmxfZWFzeV9zZXRvcHQoY3VybCwgQ1VSTE9QVF9VUkwsIHVybCk7CisJaWYgKGNhX2ZuYW1lKSB7CisJCWN1cmxfZWFzeV9zZXRvcHQoY3VybCwgQ1VSTE9QVF9DQUlORk8sIGNhX2ZuYW1lKTsKKwkJY3VybF9lYXN5X3NldG9wdChjdXJsLCBDVVJMT1BUX1NTTF9WRVJJRllQRUVSLCAxTCk7CisJCWN1cmxfZWFzeV9zZXRvcHQoY3VybCwgQ1VSTE9QVF9DRVJUSU5GTywgMUwpOworCX0gZWxzZSB7CisJCWN1cmxfZWFzeV9zZXRvcHQoY3VybCwgQ1VSTE9QVF9TU0xfVkVSSUZZUEVFUiwgMEwpOworCX0KKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfREVCVUdGVU5DVElPTiwgY3VybF9jYl9kZWJ1Zyk7CisJY3VybF9lYXN5X3NldG9wdChjdXJsLCBDVVJMT1BUX0RFQlVHREFUQSwgY3R4KTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfV1JJVEVGVU5DVElPTiwgZndyaXRlKTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfV1JJVEVEQVRBLCBmKTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfVkVSQk9TRSwgMUwpOworCisJcmVzID0gY3VybF9lYXN5X3BlcmZvcm0oY3VybCk7CisJaWYgKHJlcyAhPSBDVVJMRV9PSykgeworCQlpZiAoIWN0eC0+bGFzdF9lcnIpCisJCQljdHgtPmxhc3RfZXJyID0gY3VybF9lYXN5X3N0cmVycm9yKHJlcyk7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiY3VybF9lYXN5X3BlcmZvcm0oKSBmYWlsZWQ6ICVzIiwKKwkJCSAgIGN0eC0+bGFzdF9lcnIpOworCQljdXJsX2Vhc3lfY2xlYW51cChjdXJsKTsKKwkJZmNsb3NlKGYpOworCQlyZXR1cm4gLTE7CisJfQorCisJY3VybF9lYXN5X2dldGluZm8oY3VybCwgQ1VSTElORk9fUkVTUE9OU0VfQ09ERSwgJmh0dHApOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiY3VybDogU2VydmVyIHJlc3BvbnNlIGNvZGUgJWxkIiwgaHR0cCk7CisJaWYgKGh0dHAgIT0gMjAwKSB7CisJCWN0eC0+bGFzdF9lcnIgPSAiSFRUUCBkb3dubG9hZCBmYWlsZWQiOworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiSFRUUCBkb3dubG9hZCBmYWlsZWQgLSBjb2RlICVsZCIsIGh0dHApOworCQljdXJsX2Vhc3lfY2xlYW51cChjdXJsKTsKKwkJZmNsb3NlKGYpOworCQlyZXR1cm4gLTE7CisJfQorCisJY3VybF9lYXN5X2NsZWFudXAoY3VybCk7CisJZmNsb3NlKGYpOworCisJcmV0dXJuIDA7Cit9CisKKworY2hhciAqIGh0dHBfcG9zdChzdHJ1Y3QgaHR0cF9jdHggKmN0eCwgY29uc3QgY2hhciAqdXJsLCBjb25zdCBjaGFyICpkYXRhLAorCQkgY29uc3QgY2hhciAqY29udGVudF90eXBlLCBjb25zdCBjaGFyICpleHRfaGRyLAorCQkgY29uc3QgY2hhciAqY2FfZm5hbWUsCisJCSBjb25zdCBjaGFyICp1c2VybmFtZSwgY29uc3QgY2hhciAqcGFzc3dvcmQsCisJCSBjb25zdCBjaGFyICpjbGllbnRfY2VydCwgY29uc3QgY2hhciAqY2xpZW50X2tleSwKKwkJIHNpemVfdCAqcmVzcF9sZW4pCit7CisJbG9uZyBodHRwID0gMDsKKwlDVVJMY29kZSByZXM7CisJY2hhciAqcmV0OworCUNVUkwgKmN1cmw7CisJc3RydWN0IGN1cmxfc2xpc3QgKmN1cmxfaGRyID0gTlVMTDsKKworCWN0eC0+bGFzdF9lcnIgPSBOVUxMOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiY3VybDogSFRUUCBQT1NUIHRvICVzIiwgdXJsKTsKKwljdXJsID0gc2V0dXBfY3VybF9wb3N0KGN0eCwgdXJsLCBjYV9mbmFtZSwgdXNlcm5hbWUsIHBhc3N3b3JkLAorCQkJICAgICAgIGNsaWVudF9jZXJ0LCBjbGllbnRfa2V5KTsKKwlpZiAoY3VybCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChjb250ZW50X3R5cGUpIHsKKwkJY2hhciBjdFsyMDBdOworCQlzbnByaW50ZihjdCwgc2l6ZW9mKGN0KSwgIkNvbnRlbnQtVHlwZTogJXMiLCBjb250ZW50X3R5cGUpOworCQljdXJsX2hkciA9IGN1cmxfc2xpc3RfYXBwZW5kKGN1cmxfaGRyLCBjdCk7CisJfQorCWlmIChleHRfaGRyKQorCQljdXJsX2hkciA9IGN1cmxfc2xpc3RfYXBwZW5kKGN1cmxfaGRyLCBleHRfaGRyKTsKKwljdXJsX2Vhc3lfc2V0b3B0KGN1cmwsIENVUkxPUFRfSFRUUEhFQURFUiwgY3VybF9oZHIpOworCisJY3VybF9lYXN5X3NldG9wdChjdXJsLCBDVVJMT1BUX1BPU1RGSUVMRFMsIGRhdGEpOworCWZyZWVfY3VybF9idWYoY3R4KTsKKworCXJlcyA9IGN1cmxfZWFzeV9wZXJmb3JtKGN1cmwpOworCWlmIChyZXMgIT0gQ1VSTEVfT0spIHsKKwkJaWYgKCFjdHgtPmxhc3RfZXJyKQorCQkJY3R4LT5sYXN0X2VyciA9IGN1cmxfZWFzeV9zdHJlcnJvcihyZXMpOworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImN1cmxfZWFzeV9wZXJmb3JtKCkgZmFpbGVkOiAlcyIsCisJCQkgICBjdHgtPmxhc3RfZXJyKTsKKwkJZnJlZV9jdXJsX2J1ZihjdHgpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwljdXJsX2Vhc3lfZ2V0aW5mbyhjdXJsLCBDVVJMSU5GT19SRVNQT05TRV9DT0RFLCAmaHR0cCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJjdXJsOiBTZXJ2ZXIgcmVzcG9uc2UgY29kZSAlbGQiLCBodHRwKTsKKwlpZiAoaHR0cCAhPSAyMDApIHsKKwkJY3R4LT5sYXN0X2VyciA9ICJIVFRQIFBPU1QgZmFpbGVkIjsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkhUVFAgUE9TVCBmYWlsZWQgLSBjb2RlICVsZCIsIGh0dHApOworCQlmcmVlX2N1cmxfYnVmKGN0eCk7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmIChjdHgtPmN1cmxfYnVmID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJcmV0ID0gY3R4LT5jdXJsX2J1ZjsKKwlpZiAocmVzcF9sZW4pCisJCSpyZXNwX2xlbiA9IGN0eC0+Y3VybF9idWZfbGVuOworCWN0eC0+Y3VybF9idWYgPSBOVUxMOworCWN0eC0+Y3VybF9idWZfbGVuID0gMDsKKworCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJTZXJ2ZXIgcmVzcG9uc2U6XG4lcyIsIHJldCk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3ZvaWQgaHR0cF9zZXRfY2VydF9jYihzdHJ1Y3QgaHR0cF9jdHggKmN0eCwKKwkJICAgICAgaW50ICgqY2IpKHZvaWQgKmN0eCwgc3RydWN0IGh0dHBfY2VydCAqY2VydCksCisJCSAgICAgIHZvaWQgKmNiX2N0eCkKK3sKKwljdHgtPmNlcnRfY2IgPSBjYjsKKwljdHgtPmNlcnRfY2JfY3R4ID0gY2JfY3R4OworfQorCisKK2NvbnN0IGNoYXIgKiBodHRwX2dldF9lcnIoc3RydWN0IGh0dHBfY3R4ICpjdHgpCit7CisJcmV0dXJuIGN0eC0+bGFzdF9lcnI7Cit9CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvaXBfYWRkci5jIGIvc3JjL3V0aWxzL2lwX2FkZHIuYwppbmRleCAzNjQ3Yzc2Li45MmEzNTkwIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvaXBfYWRkci5jCisrKyBiL3NyYy91dGlscy9pcF9hZGRyLmMKQEAgLTMzLDMwICszMyw2IEBACiB9CiAKIAotaW50IGhvc3RhcGRfaXBfZGlmZihzdHJ1Y3QgaG9zdGFwZF9pcF9hZGRyICphLCBzdHJ1Y3QgaG9zdGFwZF9pcF9hZGRyICpiKQotewotCWlmIChhID09IE5VTEwgJiYgYiA9PSBOVUxMKQotCQlyZXR1cm4gMDsKLQlpZiAoYSA9PSBOVUxMIHx8IGIgPT0gTlVMTCkKLQkJcmV0dXJuIDE7Ci0KLQlzd2l0Y2ggKGEtPmFmKSB7Ci0JY2FzZSBBRl9JTkVUOgotCQlpZiAoYS0+dS52NC5zX2FkZHIgIT0gYi0+dS52NC5zX2FkZHIpCi0JCQlyZXR1cm4gMTsKLQkJYnJlYWs7Ci0jaWZkZWYgQ09ORklHX0lQVjYKLQljYXNlIEFGX0lORVQ2OgotCQlpZiAob3NfbWVtY21wKCZhLT51LnY2LCAmYi0+dS52Niwgc2l6ZW9mKGEtPnUudjYpKSAhPSAwKQotCQkJcmV0dXJuIDE7Ci0JCWJyZWFrOwotI2VuZGlmIC8qIENPTkZJR19JUFY2ICovCi0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLQogaW50IGhvc3RhcGRfcGFyc2VfaXBfYWRkcihjb25zdCBjaGFyICp0eHQsIHN0cnVjdCBob3N0YXBkX2lwX2FkZHIgKmFkZHIpCiB7CiAjaWZuZGVmIENPTkZJR19OQVRJVkVfV0lORE9XUwpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2lwX2FkZHIuaCBiL3NyYy91dGlscy9pcF9hZGRyLmgKaW5kZXggNzlhYzIwYy4uMDY3MDQxMSAxMDA2NDQKLS0tIGEvc3JjL3V0aWxzL2lwX2FkZHIuaAorKysgYi9zcmMvdXRpbHMvaXBfYWRkci5oCkBAIC0yMiw3ICsyMiw2IEBACiAKIGNvbnN0IGNoYXIgKiBob3N0YXBkX2lwX3R4dChjb25zdCBzdHJ1Y3QgaG9zdGFwZF9pcF9hZGRyICphZGRyLCBjaGFyICpidWYsCiAJCQkgICAgc2l6ZV90IGJ1Zmxlbik7Ci1pbnQgaG9zdGFwZF9pcF9kaWZmKHN0cnVjdCBob3N0YXBkX2lwX2FkZHIgKmEsIHN0cnVjdCBob3N0YXBkX2lwX2FkZHIgKmIpOwogaW50IGhvc3RhcGRfcGFyc2VfaXBfYWRkcihjb25zdCBjaGFyICp0eHQsIHN0cnVjdCBob3N0YXBkX2lwX2FkZHIgKmFkZHIpOwogCiAjZW5kaWYgLyogSVBfQUREUl9IICovCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvb3MuaCBiL3NyYy91dGlscy9vcy5oCmluZGV4IGFkMjA4MzQuLmI5MjQ3ZDggMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9vcy5oCisrKyBiL3NyYy91dGlscy9vcy5oCkBAIC0yMyw2ICsyMywxMSBAQAogCW9zX3RpbWVfdCB1c2VjOwogfTsKIAorc3RydWN0IG9zX3JlbHRpbWUgeworCW9zX3RpbWVfdCBzZWM7CisJb3NfdGltZV90IHVzZWM7Cit9OworCiAvKioKICAqIG9zX2dldF90aW1lIC0gR2V0IGN1cnJlbnQgdGltZSAoc2VjLCB1c2VjKQogICogQHQ6IFBvaW50ZXIgdG8gYnVmZmVyIGZvciB0aGUgdGltZQpAQCAtMzAsMjEgKzM1LDg0IEBACiAgKi8KIGludCBvc19nZXRfdGltZShzdHJ1Y3Qgb3NfdGltZSAqdCk7CiAKKy8qKgorICogb3NfZ2V0X3JlbHRpbWUgLSBHZXQgcmVsYXRpdmUgdGltZSAoc2VjLCB1c2VjKQorICogQHQ6IFBvaW50ZXIgdG8gYnVmZmVyIGZvciB0aGUgdGltZQorICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCisgKi8KK2ludCBvc19nZXRfcmVsdGltZShzdHJ1Y3Qgb3NfcmVsdGltZSAqdCk7CiAKLS8qIEhlbHBlciBtYWNyb3MgZm9yIGhhbmRsaW5nIHN0cnVjdCBvc190aW1lICovCiAKLSNkZWZpbmUgb3NfdGltZV9iZWZvcmUoYSwgYikgXAotCSgoYSktPnNlYyA8IChiKS0+c2VjIHx8IFwKLQkgKChhKS0+c2VjID09IChiKS0+c2VjICYmIChhKS0+dXNlYyA8IChiKS0+dXNlYykpCisvKiBIZWxwZXJzIGZvciBoYW5kbGluZyBzdHJ1Y3Qgb3NfdGltZSAqLwogCi0jZGVmaW5lIG9zX3RpbWVfc3ViKGEsIGIsIHJlcykgZG8geyBcCi0JKHJlcyktPnNlYyA9IChhKS0+c2VjIC0gKGIpLT5zZWM7IFwKLQkocmVzKS0+dXNlYyA9IChhKS0+dXNlYyAtIChiKS0+dXNlYzsgXAotCWlmICgocmVzKS0+dXNlYyA8IDApIHsgXAotCQkocmVzKS0+c2VjLS07IFwKLQkJKHJlcyktPnVzZWMgKz0gMTAwMDAwMDsgXAotCX0gXAotfSB3aGlsZSAoMCkKK3N0YXRpYyBpbmxpbmUgaW50IG9zX3RpbWVfYmVmb3JlKHN0cnVjdCBvc190aW1lICphLCBzdHJ1Y3Qgb3NfdGltZSAqYikKK3sKKwlyZXR1cm4gKGEtPnNlYyA8IGItPnNlYykgfHwKKwkgICAgICAgKGEtPnNlYyA9PSBiLT5zZWMgJiYgYS0+dXNlYyA8IGItPnVzZWMpOworfQorCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBvc190aW1lX3N1YihzdHJ1Y3Qgb3NfdGltZSAqYSwgc3RydWN0IG9zX3RpbWUgKmIsCisJCQkgICAgICAgc3RydWN0IG9zX3RpbWUgKnJlcykKK3sKKwlyZXMtPnNlYyA9IGEtPnNlYyAtIGItPnNlYzsKKwlyZXMtPnVzZWMgPSBhLT51c2VjIC0gYi0+dXNlYzsKKwlpZiAocmVzLT51c2VjIDwgMCkgeworCQlyZXMtPnNlYy0tOworCQlyZXMtPnVzZWMgKz0gMTAwMDAwMDsKKwl9Cit9CisKKworLyogSGVscGVycyBmb3IgaGFuZGxpbmcgc3RydWN0IG9zX3JlbHRpbWUgKi8KKworc3RhdGljIGlubGluZSBpbnQgb3NfcmVsdGltZV9iZWZvcmUoc3RydWN0IG9zX3JlbHRpbWUgKmEsCisJCQkJICAgIHN0cnVjdCBvc19yZWx0aW1lICpiKQoreworCXJldHVybiAoYS0+c2VjIDwgYi0+c2VjKSB8fAorCSAgICAgICAoYS0+c2VjID09IGItPnNlYyAmJiBhLT51c2VjIDwgYi0+dXNlYyk7Cit9CisKKworc3RhdGljIGlubGluZSB2b2lkIG9zX3JlbHRpbWVfc3ViKHN0cnVjdCBvc19yZWx0aW1lICphLCBzdHJ1Y3Qgb3NfcmVsdGltZSAqYiwKKwkJCQkgIHN0cnVjdCBvc19yZWx0aW1lICpyZXMpCit7CisJcmVzLT5zZWMgPSBhLT5zZWMgLSBiLT5zZWM7CisJcmVzLT51c2VjID0gYS0+dXNlYyAtIGItPnVzZWM7CisJaWYgKHJlcy0+dXNlYyA8IDApIHsKKwkJcmVzLT5zZWMtLTsKKwkJcmVzLT51c2VjICs9IDEwMDAwMDA7CisJfQorfQorCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBvc19yZWx0aW1lX2FnZShzdHJ1Y3Qgb3NfcmVsdGltZSAqc3RhcnQsCisJCQkJICBzdHJ1Y3Qgb3NfcmVsdGltZSAqYWdlKQoreworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKKworCW9zX2dldF9yZWx0aW1lKCZub3cpOworCW9zX3JlbHRpbWVfc3ViKCZub3csIHN0YXJ0LCBhZ2UpOworfQorCisKK3N0YXRpYyBpbmxpbmUgaW50IG9zX3JlbHRpbWVfZXhwaXJlZChzdHJ1Y3Qgb3NfcmVsdGltZSAqbm93LAorCQkJCSAgICAgc3RydWN0IG9zX3JlbHRpbWUgKnRzLAorCQkJCSAgICAgb3NfdGltZV90IHRpbWVvdXRfc2VjcykKK3sKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBhZ2U7CisKKwlvc19yZWx0aW1lX3N1Yihub3csIHRzLCAmYWdlKTsKKwlyZXR1cm4gKGFnZS5zZWMgPiB0aW1lb3V0X3NlY3MpIHx8CisJICAgICAgIChhZ2Uuc2VjID09IHRpbWVvdXRfc2VjcyAmJiBhZ2UudXNlYyA+IDApOworfQorCisKK3N0YXRpYyBpbmxpbmUgaW50IG9zX3JlbHRpbWVfaW5pdGlhbGl6ZWQoc3RydWN0IG9zX3JlbHRpbWUgKnQpCit7CisJcmV0dXJuIHQtPnNlYyAhPSAwIHx8IHQtPnVzZWMgIT0gMDsKK30KKwogCiAvKioKICAqIG9zX21rdGltZSAtIENvbnZlcnQgYnJva2VuLWRvd24gdGltZSBpbnRvIHNlY29uZHMgc2luY2UgMTk3MC0wMS0wMQpAQCAtMTcyLDYgKzI0MCwxMyBAQAogY2hhciAqIG9zX3JlYWRmaWxlKGNvbnN0IGNoYXIgKm5hbWUsIHNpemVfdCAqbGVuKTsKIAogLyoqCisgKiBvc19maWxlX2V4aXN0cyAtIENoZWNrIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBmaWxlIGV4aXN0cworICogQGZuYW1lOiBQYXRoIGFuZCBuYW1lIG9mIHRoZSBmaWxlCisgKiBSZXR1cm5zOiAxIGlmIHRoZSBmaWxlIGV4aXN0cyBvciAwIGlmIG5vdAorICovCitpbnQgb3NfZmlsZV9leGlzdHMoY29uc3QgY2hhciAqZm5hbWUpOworCisvKioKICAqIG9zX3phbGxvYyAtIEFsbG9jYXRlIGFuZCB6ZXJvIG1lbW9yeQogICogQHNpemU6IE51bWJlciBvZiBieXRlcyB0byBhbGxvY2F0ZQogICogUmV0dXJuczogUG9pbnRlciB0byBhbGxvY2F0ZWQgYW5kIHplcm9lZCBtZW1vcnkgb3IgJU5VTEwgb24gZmFpbHVyZQpAQCAtMzYxLDE1ICs0MzYsNiBAQAogaW50IG9zX3N0cm5jbXAoY29uc3QgY2hhciAqczEsIGNvbnN0IGNoYXIgKnMyLCBzaXplX3Qgbik7CiAKIC8qKgotICogb3Nfc3RybmNweSAtIENvcHkgYSBzdHJpbmcKLSAqIEBkZXN0OiBEZXN0aW5hdGlvbgotICogQHNyYzogU291cmNlCi0gKiBAbjogTWF4aW11bSBudW1iZXIgb2YgY2hhcmFjdGVycyB0byBjb3B5Ci0gKiBSZXR1cm5zOiBkZXN0Ci0gKi8KLWNoYXIgKiBvc19zdHJuY3B5KGNoYXIgKmRlc3QsIGNvbnN0IGNoYXIgKnNyYywgc2l6ZV90IG4pOwotCi0vKioKICAqIG9zX3N0cnN0ciAtIExvY2F0ZSBhIHN1YnN0cmluZwogICogQGhheXN0YWNrOiBTdHJpbmcgKGhheXN0YWNrKSB0byBzZWFyY2ggZnJvbQogICogQG5lZWRsZTogTmVlZGxlIHRvIHNlYXJjaCBmcm9tIGhheXN0YWNrCkBAIC00NjUsOSArNTMxLDYgQEAKICNpZm5kZWYgb3Nfc3RybmNtcAogI2RlZmluZSBvc19zdHJuY21wKHMxLCBzMiwgbikgc3RybmNtcCgoczEpLCAoczIpLCAobikpCiAjZW5kaWYKLSNpZm5kZWYgb3Nfc3RybmNweQotI2RlZmluZSBvc19zdHJuY3B5KGQsIHMsIG4pIHN0cm5jcHkoKGQpLCAocyksIChuKSkKLSNlbmRpZgogI2lmbmRlZiBvc19zdHJyY2hyCiAjZGVmaW5lIG9zX3N0cnJjaHIocywgYykgc3RycmNocigocyksIChjKSkKICNlbmRpZgpAQCAtNDkzLDYgKzU1NiwyMSBAQAogCXJldHVybiBvc19yZWFsbG9jKHB0ciwgbm1lbWIgKiBzaXplKTsKIH0KIAorLyoqCisgKiBvc19yZW1vdmVfaW5fYXJyYXkgLSBSZW1vdmUgYSBtZW1iZXIgZnJvbSBhbiBhcnJheSBieSBpbmRleAorICogQHB0cjogUG9pbnRlciB0byB0aGUgYXJyYXkKKyAqIEBubWVtYjogQ3VycmVudCBtZW1iZXIgY291bnQgb2YgdGhlIGFycmF5CisgKiBAc2l6ZTogVGhlIHNpemUgcGVyIG1lbWJlciBvZiB0aGUgYXJyYXkKKyAqIEBpZHg6IEluZGV4IG9mIHRoZSBtZW1iZXIgdG8gYmUgcmVtb3ZlZAorICovCitzdGF0aWMgaW5saW5lIHZvaWQgb3NfcmVtb3ZlX2luX2FycmF5KHZvaWQgKnB0ciwgc2l6ZV90IG5tZW1iLCBzaXplX3Qgc2l6ZSwKKwkJCQkgICAgICBzaXplX3QgaWR4KQoreworCWlmIChpZHggPCBubWVtYiAtIDEpCisJCW9zX21lbW1vdmUoKCh1bnNpZ25lZCBjaGFyICopIHB0cikgKyBpZHggKiBzaXplLAorCQkJICAgKCh1bnNpZ25lZCBjaGFyICopIHB0cikgKyAoaWR4ICsgMSkgKiBzaXplLAorCQkJICAgKG5tZW1iIC0gaWR4IC0gMSkgKiBzaXplKTsKK30KIAogLyoqCiAgKiBvc19zdHJsY3B5IC0gQ29weSBhIHN0cmluZyB3aXRoIHNpemUgYm91bmQgYW5kIE5VTC10ZXJtaW5hdGlvbgpAQCAtNTA2LDYgKzU4NCwzMiBAQAogICovCiBzaXplX3Qgb3Nfc3RybGNweShjaGFyICpkZXN0LCBjb25zdCBjaGFyICpzcmMsIHNpemVfdCBzaXopOwogCisvKioKKyAqIG9zX21lbWNtcF9jb25zdCAtIENvbnN0YW50IHRpbWUgbWVtb3J5IGNvbXBhcmlzb24KKyAqIEBhOiBGaXJzdCBidWZmZXIgdG8gY29tcGFyZQorICogQGI6IFNlY29uZCBidWZmZXIgdG8gY29tcGFyZQorICogQGxlbjogTnVtYmVyIG9mIG9jdGV0cyB0byBjb21wYXJlCisgKiBSZXR1cm5zOiAwIGlmIGJ1ZmZlcnMgYXJlIGVxdWFsLCBub24temVybyBpZiBub3QKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGlzIG1lYW50IGZvciBjb21wYXJpbmcgcGFzc3dvcmRzIG9yIGhhc2ggdmFsdWVzIHdoZXJlCisgKiBkaWZmZXJlbmNlIGluIGV4ZWN1dGlvbiB0aW1lIGNvdWxkIHByb3ZpZGUgZXh0ZXJuYWwgb2JzZXJ2ZXIgaW5mb3JtYXRpb24KKyAqIGFib3V0IHRoZSBsb2NhdGlvbiBvZiB0aGUgZGlmZmVyZW5jZSBpbiB0aGUgbWVtb3J5IGJ1ZmZlcnMuIFRoZSByZXR1cm4gdmFsdWUKKyAqIGRvZXMgbm90IGJlaGF2ZSBsaWtlIG9zX21lbWNtcCgpLCBpLmUuLCBvc19tZW1jbXBfY29uc3QoKSBjYW5ub3QgYmUgdXNlZCB0bworICogc29ydCBpdGVtcyBpbnRvIGEgZGVmaW5lZCBvcmRlci4gVW5saWtlIG9zX21lbWNtcCgpLCBleGVjdXRpb24gdGltZSBvZgorICogb3NfbWVtY21wX2NvbnN0KCkgZG9lcyBub3QgZGVwZW5kIG9uIHRoZSBjb250ZW50cyBvZiB0aGUgY29tcGFyZWQgbWVtb3J5CisgKiBidWZmZXJzLCBidXQgb25seSBvbiB0aGUgdG90YWwgY29tcGFyZWQgbGVuZ3RoLgorICovCitpbnQgb3NfbWVtY21wX2NvbnN0KGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIsIHNpemVfdCBsZW4pOworCisvKioKKyAqIG9zX2V4ZWMgLSBFeGVjdXRlIGFuIGV4dGVybmFsIHByb2dyYW0KKyAqIEBwcm9ncmFtOiBQYXRoIHRvIHRoZSBwcm9ncmFtCisgKiBAYXJnOiBDb21tYW5kIGxpbmUgYXJndW1lbnQgc3RyaW5nCisgKiBAd2FpdF9jb21wbGV0aW9uOiBXaGV0aGVyIHRvIHdhaXQgdW50aWwgdGhlIHByb2dyYW0gZXhlY3V0aW9uIGNvbXBsZXRlcworICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBlcnJvcgorICovCitpbnQgb3NfZXhlYyhjb25zdCBjaGFyICpwcm9ncmFtLCBjb25zdCBjaGFyICphcmcsIGludCB3YWl0X2NvbXBsZXRpb24pOworCiAKICNpZmRlZiBPU19SRUpFQ1RfQ19MSUJfRlVOQ1RJT05TCiAjZGVmaW5lIG1hbGxvYyBPU19ET19OT1RfVVNFX21hbGxvYwpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL29zX2ludGVybmFsLmMgYi9zcmMvdXRpbHMvb3NfaW50ZXJuYWwuYwppbmRleCBlNGI3ZmRiLi45MGI2Njg4IDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvb3NfaW50ZXJuYWwuYworKysgYi9zcmMvdXRpbHMvb3NfaW50ZXJuYWwuYwpAQCAtNDEsNiArNDEsMTcgQEAKIH0KIAogCitpbnQgb3NfZ2V0X3JlbHRpbWUoc3RydWN0IG9zX3JlbHRpbWUgKnQpCit7CisJaW50IHJlczsKKwlzdHJ1Y3QgdGltZXZhbCB0djsKKwlyZXMgPSBnZXR0aW1lb2ZkYXkoJnR2LCBOVUxMKTsKKwl0LT5zZWMgPSB0di50dl9zZWM7CisJdC0+dXNlYyA9IHR2LnR2X3VzZWM7CisJcmV0dXJuIHJlczsKK30KKworCiBpbnQgb3NfbWt0aW1lKGludCB5ZWFyLCBpbnQgbW9udGgsIGludCBkYXksIGludCBob3VyLCBpbnQgbWluLCBpbnQgc2VjLAogCSAgICAgIG9zX3RpbWVfdCAqdCkKIHsKQEAgLTQ1Miw2ICs0NjMsMjAgQEAKIH0KIAogCitpbnQgb3NfbWVtY21wX2NvbnN0KGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIsIHNpemVfdCBsZW4pCit7CisJY29uc3QgdTggKmFhID0gYTsKKwljb25zdCB1OCAqYmIgPSBiOworCXNpemVfdCBpOworCXU4IHJlczsKKworCWZvciAocmVzID0gMCwgaSA9IDA7IGkgPCBsZW47IGkrKykKKwkJcmVzIHw9IGFhW2ldIF4gYmJbaV07CisKKwlyZXR1cm4gcmVzOworfQorCisKIGNoYXIgKiBvc19zdHJzdHIoY29uc3QgY2hhciAqaGF5c3RhY2ssIGNvbnN0IGNoYXIgKm5lZWRsZSkKIHsKIAlzaXplX3QgbGVuID0gb3Nfc3RybGVuKG5lZWRsZSk7CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvb3Nfbm9uZS5jIGIvc3JjL3V0aWxzL29zX25vbmUuYwppbmRleCBjYWJmNzNiLi4yNjQ5MTExIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvb3Nfbm9uZS5jCisrKyBiL3NyYy91dGlscy9vc19ub25lLmMKQEAgLTI2LDYgKzI2LDEyIEBACiB9CiAKIAoraW50IG9zX2dldF9yZWx0aW1lKHN0cnVjdCBvc19yZWx0aW1lICp0KQoreworCXJldHVybiAtMTsKK30KKworCiBpbnQgb3NfbWt0aW1lKGludCB5ZWFyLCBpbnQgbW9udGgsIGludCBkYXksIGludCBob3VyLCBpbnQgbWluLCBpbnQgc2VjLAogCSAgICAgIG9zX3RpbWVfdCAqdCkKIHsKQEAgLTIxMiw2ICsyMTgsMTEgQEAKIH0KIAogCitpbnQgb3NfbWVtY21wX2NvbnN0KGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIsIHNpemVfdCBsZW4pCit7CisJcmV0dXJuIDA7Cit9CisKIGNoYXIgKiBvc19zdHJzdHIoY29uc3QgY2hhciAqaGF5c3RhY2ssIGNvbnN0IGNoYXIgKm5lZWRsZSkKIHsKIAlyZXR1cm4gTlVMTDsKZGlmZiAtLWdpdCBhL3NyYy91dGlscy9vc191bml4LmMgYi9zcmMvdXRpbHMvb3NfdW5peC5jCmluZGV4IDEwYjllMGQuLjUyM2E0ZDAgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9vc191bml4LmMKKysrIGIvc3JjL3V0aWxzL29zX3VuaXguYwpAQCAtOSwxOCArOSwxOSBAQAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCiAKICNpbmNsdWRlIDx0aW1lLmg+CisjaW5jbHVkZSA8c3lzL3dhaXQuaD4KIAogI2lmZGVmIEFORFJPSUQKICNpbmNsdWRlIDxzeXMvY2FwYWJpbGl0eS5oPgotI2luY2x1ZGUgPGxpbnV4L3ByY3RsLmg+CisjaW5jbHVkZSA8c3lzL3ByY3RsLmg+CiAjaW5jbHVkZSA8cHJpdmF0ZS9hbmRyb2lkX2ZpbGVzeXN0ZW1fY29uZmlnLmg+CiAjZW5kaWYgLyogQU5EUk9JRCAqLwogCiAjaW5jbHVkZSAib3MuaCIKKyNpbmNsdWRlICJjb21tb24uaCIKIAogI2lmZGVmIFdQQV9UUkFDRQogCi0jaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAid3BhX2RlYnVnLmgiCiAjaW5jbHVkZSAidHJhY2UuaCIKICNpbmNsdWRlICJsaXN0LmgiCkBAIC02MCw2ICs2MSw0MyBAQAogfQogCiAKK2ludCBvc19nZXRfcmVsdGltZShzdHJ1Y3Qgb3NfcmVsdGltZSAqdCkKK3sKKyNpZiBkZWZpbmVkKENMT0NLX0JPT1RUSU1FKQorCXN0YXRpYyBjbG9ja2lkX3QgY2xvY2tfaWQgPSBDTE9DS19CT09UVElNRTsKKyNlbGlmIGRlZmluZWQoQ0xPQ0tfTU9OT1RPTklDKQorCXN0YXRpYyBjbG9ja2lkX3QgY2xvY2tfaWQgPSBDTE9DS19NT05PVE9OSUM7CisjZWxzZQorCXN0YXRpYyBjbG9ja2lkX3QgY2xvY2tfaWQgPSBDTE9DS19SRUFMVElNRTsKKyNlbmRpZgorCXN0cnVjdCB0aW1lc3BlYyB0czsKKwlpbnQgcmVzOworCisJd2hpbGUgKDEpIHsKKwkJcmVzID0gY2xvY2tfZ2V0dGltZShjbG9ja19pZCwgJnRzKTsKKwkJaWYgKHJlcyA9PSAwKSB7CisJCQl0LT5zZWMgPSB0cy50dl9zZWM7CisJCQl0LT51c2VjID0gdHMudHZfbnNlYyAvIDEwMDA7CisJCQlyZXR1cm4gMDsKKwkJfQorCQlzd2l0Y2ggKGNsb2NrX2lkKSB7CisjaWZkZWYgQ0xPQ0tfQk9PVFRJTUUKKwkJY2FzZSBDTE9DS19CT09UVElNRToKKwkJCWNsb2NrX2lkID0gQ0xPQ0tfTU9OT1RPTklDOworCQkJYnJlYWs7CisjZW5kaWYKKyNpZmRlZiBDTE9DS19NT05PVE9OSUMKKwkJY2FzZSBDTE9DS19NT05PVE9OSUM6CisJCQljbG9ja19pZCA9IENMT0NLX1JFQUxUSU1FOworCQkJYnJlYWs7CisjZW5kaWYKKwkJY2FzZSBDTE9DS19SRUFMVElNRToKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KK30KKworCiBpbnQgb3NfbWt0aW1lKGludCB5ZWFyLCBpbnQgbW9udGgsIGludCBkYXksIGludCBob3VyLCBpbnQgbWluLCBpbnQgc2VjLAogCSAgICAgIG9zX3RpbWVfdCAqdCkKIHsKQEAgLTI2OCw3ICszMDYsNyBAQAogCXN0cnVjdCBfX3VzZXJfY2FwX2hlYWRlcl9zdHJ1Y3QgaGVhZGVyOwogCXN0cnVjdCBfX3VzZXJfY2FwX2RhdGFfc3RydWN0IGNhcDsKIAotCXNldGdyb3VwcyhzaXplb2YoZ3JvdXBzKS9zaXplb2YoZ3JvdXBzWzBdKSwgZ3JvdXBzKTsKKwlzZXRncm91cHMoQVJSQVlfU0laRShncm91cHMpLCBncm91cHMpOwogCiAJcHJjdGwoUFJfU0VUX0tFRVBDQVBTLCAxLCAwLCAwLCAwKTsKIApAQCAtMzcwLDYgKzQwOCwxNiBAQAogfQogCiAKK2ludCBvc19maWxlX2V4aXN0cyhjb25zdCBjaGFyICpmbmFtZSkKK3sKKwlGSUxFICpmID0gZm9wZW4oZm5hbWUsICJyYiIpOworCWlmIChmID09IE5VTEwpCisJCXJldHVybiAwOworCWZjbG9zZShmKTsKKwlyZXR1cm4gMTsKK30KKworCiAjaWZuZGVmIFdQQV9UUkFDRQogdm9pZCAqIG9zX3phbGxvYyhzaXplX3Qgc2l6ZSkKIHsKQEAgLTQwMyw2ICs0NTEsMjAgQEAKIH0KIAogCitpbnQgb3NfbWVtY21wX2NvbnN0KGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIsIHNpemVfdCBsZW4pCit7CisJY29uc3QgdTggKmFhID0gYTsKKwljb25zdCB1OCAqYmIgPSBiOworCXNpemVfdCBpOworCXU4IHJlczsKKworCWZvciAocmVzID0gMCwgaSA9IDA7IGkgPCBsZW47IGkrKykKKwkJcmVzIHw9IGFhW2ldIF4gYmJbaV07CisKKwlyZXR1cm4gcmVzOworfQorCisKICNpZmRlZiBXUEFfVFJBQ0UKIAogdm9pZCAqIG9zX21hbGxvYyhzaXplX3Qgc2l6ZSkKQEAgLTQ5MywzICs1NTUsNTcgQEAKIH0KIAogI2VuZGlmIC8qIFdQQV9UUkFDRSAqLworCisKK2ludCBvc19leGVjKGNvbnN0IGNoYXIgKnByb2dyYW0sIGNvbnN0IGNoYXIgKmFyZywgaW50IHdhaXRfY29tcGxldGlvbikKK3sKKwlwaWRfdCBwaWQ7CisJaW50IHBpZF9zdGF0dXM7CisKKwlwaWQgPSBmb3JrKCk7CisJaWYgKHBpZCA8IDApIHsKKwkJcGVycm9yKCJmb3JrIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAocGlkID09IDApIHsKKwkJLyogcnVuIHRoZSBleHRlcm5hbCBjb21tYW5kIGluIHRoZSBjaGlsZCBwcm9jZXNzICovCisJCWNvbnN0IGludCBNQVhfQVJHID0gMzA7CisJCWNoYXIgKl9wcm9ncmFtLCAqX2FyZywgKnBvczsKKwkJY2hhciAqYXJndltNQVhfQVJHICsgMV07CisJCWludCBpOworCisJCV9wcm9ncmFtID0gb3Nfc3RyZHVwKHByb2dyYW0pOworCQlfYXJnID0gb3Nfc3RyZHVwKGFyZyk7CisKKwkJYXJndlswXSA9IF9wcm9ncmFtOworCisJCWkgPSAxOworCQlwb3MgPSBfYXJnOworCQl3aGlsZSAoaSA8IE1BWF9BUkcgJiYgcG9zICYmICpwb3MpIHsKKwkJCXdoaWxlICgqcG9zID09ICcgJykKKwkJCQlwb3MrKzsKKwkJCWlmICgqcG9zID09ICdcMCcpCisJCQkJYnJlYWs7CisJCQlhcmd2W2krK10gPSBwb3M7CisJCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnICcpOworCQkJaWYgKHBvcykKKwkJCQkqcG9zKysgPSAnXDAnOworCQl9CisJCWFyZ3ZbaV0gPSBOVUxMOworCisJCWV4ZWN2KHByb2dyYW0sIGFyZ3YpOworCQlwZXJyb3IoImV4ZWN2Iik7CisJCW9zX2ZyZWUoX3Byb2dyYW0pOworCQlvc19mcmVlKF9hcmcpOworCQlleGl0KDApOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKHdhaXRfY29tcGxldGlvbikgeworCQkvKiB3YWl0IGZvciB0aGUgY2hpbGQgcHJvY2VzcyB0byBjb21wbGV0ZSBpbiB0aGUgcGFyZW50ICovCisJCXdhaXRwaWQocGlkLCAmcGlkX3N0YXR1cywgMCk7CisJfQorCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvb3Nfd2luMzIuYyBiL3NyYy91dGlscy9vc193aW4zMi5jCmluZGV4IDE2M2NlYmUuLjU3ZWUxMzIgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9vc193aW4zMi5jCisrKyBiL3NyYy91dGlscy9vc193aW4zMi5jCkBAIC00Nyw2ICs0NywxNyBAQAogfQogCiAKK2ludCBvc19nZXRfcmVsdGltZShzdHJ1Y3Qgb3NfcmVsdGltZSAqdCkKK3sKKwkvKiBjb25zaWRlciB1c2luZyBwZXJmb3JtYW5jZSBjb3VudGVycyBvciBzbyBpbnN0ZWFkICovCisJc3RydWN0IG9zX3RpbWUgbm93OworCWludCByZXMgPSBvc19nZXRfdGltZSgmbm93KTsKKwl0LT5zZWMgPSBub3cuc2VjOworCXQtPnVzZWMgPSBub3cudXNlYzsKKwlyZXR1cm4gcmVzOworfQorCisKIGludCBvc19ta3RpbWUoaW50IHllYXIsIGludCBtb250aCwgaW50IGRheSwgaW50IGhvdXIsIGludCBtaW4sIGludCBzZWMsCiAJICAgICAgb3NfdGltZV90ICp0KQogewpAQCAtMjMzLDMgKzI0NCwyMyBAQAogCiAJcmV0dXJuIHMgLSBzcmMgLSAxOwogfQorCisKK2ludCBvc19tZW1jbXBfY29uc3QoY29uc3Qgdm9pZCAqYSwgY29uc3Qgdm9pZCAqYiwgc2l6ZV90IGxlbikKK3sKKwljb25zdCB1OCAqYWEgPSBhOworCWNvbnN0IHU4ICpiYiA9IGI7CisJc2l6ZV90IGk7CisJdTggcmVzOworCisJZm9yIChyZXMgPSAwLCBpID0gMDsgaSA8IGxlbjsgaSsrKQorCQlyZXMgfD0gYWFbaV0gXiBiYltpXTsKKworCXJldHVybiByZXM7Cit9CisKKworaW50IG9zX2V4ZWMoY29uc3QgY2hhciAqcHJvZ3JhbSwgY29uc3QgY2hhciAqYXJnLCBpbnQgd2FpdF9jb21wbGV0aW9uKQoreworCXJldHVybiAtMTsKK30KZGlmZiAtLWdpdCBhL3NyYy91dGlscy9wY3NjX2Z1bmNzLmMgYi9zcmMvdXRpbHMvcGNzY19mdW5jcy5jCmluZGV4IDA4NTEwZDAuLmQ5NTVkYzQgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9wY3NjX2Z1bmNzLmMKKysrIGIvc3JjL3V0aWxzL3Bjc2NfZnVuY3MuYwpAQCAtNDg1LDE3ICs0ODUsMTUgQEAKIAogLyoqCiAgKiBzY2FyZF9pbml0IC0gSW5pdGlhbGl6ZSBTSU0vVVNJTSBjb25uZWN0aW9uIHVzaW5nIFBDL1NDCi0gKiBAc2ltX3R5cGU6IEFsbG93ZWQgU0lNIHR5cGVzIChTSU0sIFVTSU0sIG9yIGJvdGgpCiAgKiBAcmVhZGVyOiBSZWFkZXIgbmFtZSBwcmVmaXggdG8gc2VhcmNoIGZvcgogICogUmV0dXJuczogUG9pbnRlciB0byBwcml2YXRlIGRhdGEgc3RydWN0dXJlLCBvciAlTlVMTCBvbiBmYWlsdXJlCiAgKgogICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIGluaXRpYWxpemUgU0lNL1VTSU0gY29ubmVjdGlvbi4gUEMvU0MgaXMgdXNlZCB0bwotICogb3BlbiBjb25uZWN0aW9uIHRvIHRoZSBTSU0vVVNJTSBjYXJkIGFuZCB0aGUgY2FyZCBpcyB2ZXJpZmllZCB0byBzdXBwb3J0IHRoZQotICogc2VsZWN0ZWQgc2ltX3R5cGUuIEluIGFkZGl0aW9uLCBsb2NhbCBmbGFnIGlzIHNldCBpZiBhIFBJTiBpcyBuZWVkZWQgdG8KLSAqIGFjY2VzcyBzb21lIG9mIHRoZSBjYXJkIGZ1bmN0aW9ucy4gT25jZSB0aGUgY29ubmVjdGlvbiBpcyBub3QgbmVlZGVkCi0gKiBhbnltb3JlLCBzY2FyZF9kZWluaXQoKSBjYW4gYmUgdXNlZCB0byBjbG9zZSBpdC4KKyAqIG9wZW4gY29ubmVjdGlvbiB0byB0aGUgU0lNL1VTSU0gY2FyZC4gSW4gYWRkaXRpb24sIGxvY2FsIGZsYWcgaXMgc2V0IGlmIGEKKyAqIFBJTiBpcyBuZWVkZWQgdG8gYWNjZXNzIHNvbWUgb2YgdGhlIGNhcmQgZnVuY3Rpb25zLiBPbmNlIHRoZSBjb25uZWN0aW9uIGlzCisgKiBub3QgbmVlZGVkIGFueW1vcmUsIHNjYXJkX2RlaW5pdCgpIGNhbiBiZSB1c2VkIHRvIGNsb3NlIGl0LgogICovCi1zdHJ1Y3Qgc2NhcmRfZGF0YSAqIHNjYXJkX2luaXQoc2NhcmRfc2ltX3R5cGUgc2ltX3R5cGUsIGNvbnN0IGNoYXIgKnJlYWRlcikKK3N0cnVjdCBzY2FyZF9kYXRhICogc2NhcmRfaW5pdChjb25zdCBjaGFyICpyZWFkZXIpCiB7CiAJbG9uZyByZXQ7CiAJdW5zaWduZWQgbG9uZyBsZW4sIHBvczsKQEAgLTYxMiwyMCArNjEwLDE0IEBACiAKIAlibGVuID0gc2l6ZW9mKGJ1Zik7CiAKLQlzY2FyZC0+c2ltX3R5cGUgPSBTQ0FSRF9HU01fU0lNOwotCWlmIChzaW1fdHlwZSA9PSBTQ0FSRF9VU0lNX09OTFkgfHwgc2ltX3R5cGUgPT0gU0NBUkRfVFJZX0JPVEgpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogdmVyaWZ5aW5nIFVTSU0gc3VwcG9ydCIpOwotCQlpZiAoX3NjYXJkX3NlbGVjdF9maWxlKHNjYXJkLCBTQ0FSRF9GSUxFX01GLCBidWYsICZibGVuLAotCQkJCSAgICAgICBTQ0FSRF9VU0lNLCBOVUxMLCAwKSkgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogVVNJTSBpcyBub3Qgc3VwcG9ydGVkIik7Ci0JCQlpZiAoc2ltX3R5cGUgPT0gU0NBUkRfVVNJTV9PTkxZKQotCQkJCWdvdG8gZmFpbGVkOwotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogVHJ5aW5nIHRvIHVzZSBHU00gU0lNIik7Ci0JCQlzY2FyZC0+c2ltX3R5cGUgPSBTQ0FSRF9HU01fU0lNOwotCQl9IGVsc2UgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogVVNJTSBpcyBzdXBwb3J0ZWQiKTsKLQkJCXNjYXJkLT5zaW1fdHlwZSA9IFNDQVJEX1VTSU07Ci0JCX0KKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNDQVJEOiB2ZXJpZnlpbmcgVVNJTSBzdXBwb3J0Iik7CisJaWYgKF9zY2FyZF9zZWxlY3RfZmlsZShzY2FyZCwgU0NBUkRfRklMRV9NRiwgYnVmLCAmYmxlbiwKKwkJCSAgICAgICBTQ0FSRF9VU0lNLCBOVUxMLCAwKSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNDQVJEOiBVU0lNIGlzIG5vdCBzdXBwb3J0ZWQuIFRyeWluZyB0byB1c2UgR1NNIFNJTSIpOworCQlzY2FyZC0+c2ltX3R5cGUgPSBTQ0FSRF9HU01fU0lNOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU0NBUkQ6IFVTSU0gaXMgc3VwcG9ydGVkIik7CisJCXNjYXJkLT5zaW1fdHlwZSA9IFNDQVJEX1VTSU07CiAJfQogCiAJaWYgKHNjYXJkLT5zaW1fdHlwZSA9PSBTQ0FSRF9HU01fU0lNKSB7CkBAIC0xMjQ1LDYgKzEyMzcsNyBAQAogCQljbWRbNF0gPSAxNzsKIAkJY21kWzVdID0gMTY7CiAJCW9zX21lbWNweShjbWQgKyA2LCBfcmFuZCwgMTYpOworCQlnZXRfcmVzcFswXSA9IFVTSU1fQ0xBOwogCX0KIAlsZW4gPSBzaXplb2YocmVzcCk7CiAJcmV0ID0gc2NhcmRfdHJhbnNtaXQoc2NhcmQsIGNtZCwgY21kbGVuLCByZXNwLCAmbGVuKTsKQEAgLTE0MTMsNiArMTQwNiwxMiBAQAogCQlwb3MgKz0gSUtfTEVOOwogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJTQ0FSRDogSUsiLCBpaywgSUtfTEVOKTsKIAorCQlpZiAoZW5kID4gcG9zKSB7CisJCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsCisJCQkJICAgICJTQ0FSRDogSWdub3JlIGV4dHJhIGRhdGEgaW4gZW5kIiwKKwkJCQkgICAgcG9zLCBlbmQgLSBwb3MpOworCQl9CisKIAkJcmV0dXJuIDA7CiAJfQogCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvcGNzY19mdW5jcy5oIGIvc3JjL3V0aWxzL3Bjc2NfZnVuY3MuaAppbmRleCBiNGViYzk5Li5lYWNkMmEyIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvcGNzY19mdW5jcy5oCisrKyBiL3NyYy91dGlscy9wY3NjX2Z1bmNzLmgKQEAgLTksMTUgKzksOCBAQAogI2lmbmRlZiBQQ1NDX0ZVTkNTX0gKICNkZWZpbmUgUENTQ19GVU5DU19ICiAKLXR5cGVkZWYgZW51bSB7Ci0JU0NBUkRfR1NNX1NJTV9PTkxZLAotCVNDQVJEX1VTSU1fT05MWSwKLQlTQ0FSRF9UUllfQk9USAotfSBzY2FyZF9zaW1fdHlwZTsKLQotCiAjaWZkZWYgUENTQ19GVU5DUwotc3RydWN0IHNjYXJkX2RhdGEgKiBzY2FyZF9pbml0KHNjYXJkX3NpbV90eXBlIHNpbV90eXBlLCBjb25zdCBjaGFyICpyZWFkZXIpOworc3RydWN0IHNjYXJkX2RhdGEgKiBzY2FyZF9pbml0KGNvbnN0IGNoYXIgKnJlYWRlcik7CiB2b2lkIHNjYXJkX2RlaW5pdChzdHJ1Y3Qgc2NhcmRfZGF0YSAqc2NhcmQpOwogCiBpbnQgc2NhcmRfc2V0X3BpbihzdHJ1Y3Qgc2NhcmRfZGF0YSAqc2NhcmQsIGNvbnN0IGNoYXIgKnBpbik7CkBAIC0zNCw3ICsyNyw3IEBACiAKICNlbHNlIC8qIFBDU0NfRlVOQ1MgKi8KIAotI2RlZmluZSBzY2FyZF9pbml0KHMsIHIpIE5VTEwKKyNkZWZpbmUgc2NhcmRfaW5pdChyKSBOVUxMCiAjZGVmaW5lIHNjYXJkX2RlaW5pdChzKSBkbyB7IH0gd2hpbGUgKDApCiAjZGVmaW5lIHNjYXJkX3NldF9waW4ocywgcCkgLTEKICNkZWZpbmUgc2NhcmRfZ2V0X2ltc2kocywgaSwgbCkgLTEKZGlmZiAtLWdpdCBhL3NyYy91dGlscy9wbGF0Zm9ybS5oIGIvc3JjL3V0aWxzL3BsYXRmb3JtLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDZjZmU3OAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy91dGlscy9wbGF0Zm9ybS5oCkBAIC0wLDAgKzEsMjEgQEAKKyNpZm5kZWYgUExBVEZPUk1fSAorI2RlZmluZSBQTEFURk9STV9ICisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorI2luY2x1ZGUgImNvbW1vbi5oIgorCisjZGVmaW5lIGxlMTZfdG9fY3B1CQlsZV90b19ob3N0MTYKKyNkZWZpbmUgbGUzMl90b19jcHUJCWxlX3RvX2hvc3QzMgorCisjZGVmaW5lIGdldF91bmFsaWduZWQocCkJCQkJCVwKKyh7CQkJCQkJCQlcCisJc3RydWN0IHBhY2tlZF9kdW1teV9zdHJ1Y3QgewkJCQlcCisJCXR5cGVvZigqKHApKSBfX3ZhbDsJCQkJXAorCX0gX19hdHRyaWJ1dGVfXygocGFja2VkKSkgKl9fcHRyID0gKHZvaWQgKikgKHApOwlcCisJCQkJCQkJCVwKKwlfX3B0ci0+X192YWw7CQkJCQkJXAorfSkKKyNkZWZpbmUgZ2V0X3VuYWxpZ25lZF9sZTE2KHApCWxlMTZfdG9fY3B1KGdldF91bmFsaWduZWQoKHVpbnQxNl90ICopKHApKSkKKyNkZWZpbmUgZ2V0X3VuYWxpZ25lZF9sZTMyKHApCWxlMzJfdG9fY3B1KGdldF91bmFsaWduZWQoKHVpbnQzMl90ICopKHApKSkKKworI2VuZGlmIC8qIFBMQVRGT1JNX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy91dGlscy9yYWRpb3RhcC5jIGIvc3JjL3V0aWxzL3JhZGlvdGFwLmMKaW5kZXggODA0NDczZi4uMTk3YTRhZiAxMDA2NDQKLS0tIGEvc3JjL3V0aWxzL3JhZGlvdGFwLmMKKysrIGIvc3JjL3V0aWxzL3JhZGlvdGFwLmMKQEAgLTIsNiArMiw3IEBACiAgKiBSYWRpb3RhcCBwYXJzZXIKICAqCiAgKiBDb3B5cmlnaHQgMjAwNwkJQW5keSBHcmVlbiA8YW5keUB3YXJtY2F0LmNvbT4KKyAqIENvcHlyaWdodCAyMDA5CQlKb2hhbm5lcyBCZXJnIDxqb2hhbm5lc0BzaXBzb2x1dGlvbnMubmV0PgogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwpAQCAtMTAsMzQgKzExLDQ0IEBACiAgKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECiAgKiBsaWNlbnNlLgogICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKgotICogTW9kaWZpZWQgZm9yIHVzZXJzcGFjZSBieSBKb2hhbm5lcyBCZXJnIDxqb2hhbm5lc0BzaXBzb2x1dGlvbnMubmV0PgotICogSSBvbmx5IG1vZGlmaWVkIHNvbWUgdGhpbmdzIG9uIHRvcCB0byBlYXNlIHN5bmNpbmcgc2hvdWxkIGJ1Z3MgYmUgZm91bmQuCisgKiBTZWUgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgogICovCi0KLSNpbmNsdWRlICJpbmNsdWRlcy5oIgotCi0jaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAicmFkaW90YXBfaXRlci5oIgotCi0jZGVmaW5lIGxlMTZfdG9fY3B1CQlsZV90b19ob3N0MTYKLSNkZWZpbmUgbGUzMl90b19jcHUJCWxlX3RvX2hvc3QzMgotI2RlZmluZSBfX2xlMzIJCQl1aW50MzJfdAotI2RlZmluZSB1bG9uZwkJCXVuc2lnbmVkIGxvbmcKLSNkZWZpbmUgdW5saWtlbHkoY29uZCkJCShjb25kKQotI2RlZmluZSBnZXRfdW5hbGlnbmVkKHApCQkJCQlcCi0oewkJCQkJCQkJXAotCXN0cnVjdCBwYWNrZWRfZHVtbXlfc3RydWN0IHsJCQkJXAotCQl0eXBlb2YoKihwKSkgX192YWw7CQkJCVwKLQl9IF9fYXR0cmlidXRlX18oKHBhY2tlZCkpICpfX3B0ciA9ICh2b2lkICopIChwKTsJXAotCQkJCQkJCQlcCi0JX19wdHItPl9fdmFsOwkJCQkJCVwKLX0pCisjaW5jbHVkZSAicGxhdGZvcm0uaCIKIAogLyogZnVuY3Rpb24gcHJvdG90eXBlcyBhbmQgcmVsYXRlZCBkZWZzIGFyZSBpbiByYWRpb3RhcF9pdGVyLmggKi8KIAorc3RhdGljIGNvbnN0IHN0cnVjdCByYWRpb3RhcF9hbGlnbl9zaXplIHJ0YXBfbmFtZXNwYWNlX3NpemVzW10gPSB7CisJW0lFRUU4MDIxMV9SQURJT1RBUF9UU0ZUXSA9IHsgLmFsaWduID0gOCwgLnNpemUgPSA4LCB9LAorCVtJRUVFODAyMTFfUkFESU9UQVBfRkxBR1NdID0geyAuYWxpZ24gPSAxLCAuc2l6ZSA9IDEsIH0sCisJW0lFRUU4MDIxMV9SQURJT1RBUF9SQVRFXSA9IHsgLmFsaWduID0gMSwgLnNpemUgPSAxLCB9LAorCVtJRUVFODAyMTFfUkFESU9UQVBfQ0hBTk5FTF0gPSB7IC5hbGlnbiA9IDIsIC5zaXplID0gNCwgfSwKKwlbSUVFRTgwMjExX1JBRElPVEFQX0ZIU1NdID0geyAuYWxpZ24gPSAyLCAuc2l6ZSA9IDIsIH0sCisJW0lFRUU4MDIxMV9SQURJT1RBUF9EQk1fQU5UU0lHTkFMXSA9IHsgLmFsaWduID0gMSwgLnNpemUgPSAxLCB9LAorCVtJRUVFODAyMTFfUkFESU9UQVBfREJNX0FOVE5PSVNFXSA9IHsgLmFsaWduID0gMSwgLnNpemUgPSAxLCB9LAorCVtJRUVFODAyMTFfUkFESU9UQVBfTE9DS19RVUFMSVRZXSA9IHsgLmFsaWduID0gMiwgLnNpemUgPSAyLCB9LAorCVtJRUVFODAyMTFfUkFESU9UQVBfVFhfQVRURU5VQVRJT05dID0geyAuYWxpZ24gPSAyLCAuc2l6ZSA9IDIsIH0sCisJW0lFRUU4MDIxMV9SQURJT1RBUF9EQl9UWF9BVFRFTlVBVElPTl0gPSB7IC5hbGlnbiA9IDIsIC5zaXplID0gMiwgfSwKKwlbSUVFRTgwMjExX1JBRElPVEFQX0RCTV9UWF9QT1dFUl0gPSB7IC5hbGlnbiA9IDEsIC5zaXplID0gMSwgfSwKKwlbSUVFRTgwMjExX1JBRElPVEFQX0FOVEVOTkFdID0geyAuYWxpZ24gPSAxLCAuc2l6ZSA9IDEsIH0sCisJW0lFRUU4MDIxMV9SQURJT1RBUF9EQl9BTlRTSUdOQUxdID0geyAuYWxpZ24gPSAxLCAuc2l6ZSA9IDEsIH0sCisJW0lFRUU4MDIxMV9SQURJT1RBUF9EQl9BTlROT0lTRV0gPSB7IC5hbGlnbiA9IDEsIC5zaXplID0gMSwgfSwKKwlbSUVFRTgwMjExX1JBRElPVEFQX1JYX0ZMQUdTXSA9IHsgLmFsaWduID0gMiwgLnNpemUgPSAyLCB9LAorCVtJRUVFODAyMTFfUkFESU9UQVBfVFhfRkxBR1NdID0geyAuYWxpZ24gPSAyLCAuc2l6ZSA9IDIsIH0sCisJW0lFRUU4MDIxMV9SQURJT1RBUF9SVFNfUkVUUklFU10gPSB7IC5hbGlnbiA9IDEsIC5zaXplID0gMSwgfSwKKwlbSUVFRTgwMjExX1JBRElPVEFQX0RBVEFfUkVUUklFU10gPSB7IC5hbGlnbiA9IDEsIC5zaXplID0gMSwgfSwKKwlbSUVFRTgwMjExX1JBRElPVEFQX01DU10gPSB7IC5hbGlnbiA9IDEsIC5zaXplID0gMywgfSwKKwlbSUVFRTgwMjExX1JBRElPVEFQX0FNUERVX1NUQVRVU10gPSB7IC5hbGlnbiA9IDQsIC5zaXplID0gOCwgfSwKKwkvKgorCSAqIGFkZCBtb3JlIGhlcmUgYXMgdGhleSBhcmUgZGVmaW5lZCBpbiByYWRpb3RhcC5oCisJICovCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9yYWRpb3RhcF9uYW1lc3BhY2UgcmFkaW90YXBfbnMgPSB7CisJLm5fYml0cyA9IHNpemVvZihydGFwX25hbWVzcGFjZV9zaXplcykgLyBzaXplb2YocnRhcF9uYW1lc3BhY2Vfc2l6ZXNbMF0pLAorCS5hbGlnbl9zaXplID0gcnRhcF9uYW1lc3BhY2Vfc2l6ZXMsCit9OworCiAvKioKICAqIGllZWU4MDIxMV9yYWRpb3RhcF9pdGVyYXRvcl9pbml0IC0gcmFkaW90YXAgcGFyc2VyIGl0ZXJhdG9yIGluaXRpYWxpemF0aW9uCiAgKiBAaXRlcmF0b3I6IHJhZGlvdGFwX2l0ZXJhdG9yIHRvIGluaXRpYWxpemUKQEAgLTczLDM4ICs4NCw1MiBAQAogICogZ2V0X3VuYWxpZ25lZCgodHlwZSAqKWl0ZXJhdG9yLnRoaXNfYXJnKSB0byBkZXJlZmVyZW5jZQogICogaXRlcmF0b3IudGhpc19hcmcgZm9yIHR5cGUgInR5cGUiIHNhZmVseSBvbiBhbGwgYXJjaGVzLgogICoKLSAqIEV4YW1wbGUgY29kZToKLSAqIFNlZSBEb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvcmFkaW90YXAtaGVhZGVycy50eHQKKyAqIEV4YW1wbGUgY29kZTogcGFyc2UuYwogICovCiAKIGludCBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3JfaW5pdCgKLSAgICBzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yICppdGVyYXRvciwKLSAgICBzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2hlYWRlciAqcmFkaW90YXBfaGVhZGVyLAotICAgIGludCBtYXhfbGVuZ3RoKQorCXN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3IgKml0ZXJhdG9yLAorCXN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfaGVhZGVyICpyYWRpb3RhcF9oZWFkZXIsCisJaW50IG1heF9sZW5ndGgsIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfdmVuZG9yX25hbWVzcGFjZXMgKnZucykKIHsKKwkvKiBtdXN0IGF0IGxlYXN0IGhhdmUgdGhlIHJhZGlvdGFwIGhlYWRlciAqLworCWlmIChtYXhfbGVuZ3RoIDwgKGludClzaXplb2Yoc3RydWN0IGllZWU4MDIxMV9yYWRpb3RhcF9oZWFkZXIpKQorCQlyZXR1cm4gLUVJTlZBTDsKKwogCS8qIExpbnV4IG9ubHkgc3VwcG9ydHMgdmVyc2lvbiAwIHJhZGlvdGFwIGZvcm1hdCAqLwogCWlmIChyYWRpb3RhcF9oZWFkZXItPml0X3ZlcnNpb24pCiAJCXJldHVybiAtRUlOVkFMOwogCiAJLyogc2FuaXR5IGNoZWNrIGZvciBhbGxvd2VkIGxlbmd0aCBhbmQgcmFkaW90YXAgbGVuZ3RoIGZpZWxkICovCi0JaWYgKG1heF9sZW5ndGggPCBsZTE2X3RvX2NwdShnZXRfdW5hbGlnbmVkKCZyYWRpb3RhcF9oZWFkZXItPml0X2xlbikpKQorCWlmIChtYXhfbGVuZ3RoIDwgZ2V0X3VuYWxpZ25lZF9sZTE2KCZyYWRpb3RhcF9oZWFkZXItPml0X2xlbikpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JaXRlcmF0b3ItPnJ0aGVhZGVyID0gcmFkaW90YXBfaGVhZGVyOwotCWl0ZXJhdG9yLT5tYXhfbGVuZ3RoID0gbGUxNl90b19jcHUoZ2V0X3VuYWxpZ25lZCgKLQkJCQkJCSZyYWRpb3RhcF9oZWFkZXItPml0X2xlbikpOwotCWl0ZXJhdG9yLT5hcmdfaW5kZXggPSAwOwotCWl0ZXJhdG9yLT5iaXRtYXBfc2hpZnRlciA9IGxlMzJfdG9fY3B1KGdldF91bmFsaWduZWQoCi0JCQkJCQkmcmFkaW90YXBfaGVhZGVyLT5pdF9wcmVzZW50KSk7Ci0JaXRlcmF0b3ItPmFyZyA9ICh1OCAqKXJhZGlvdGFwX2hlYWRlciArIHNpemVvZigqcmFkaW90YXBfaGVhZGVyKTsKLQlpdGVyYXRvci0+dGhpc19hcmcgPSBOVUxMOworCWl0ZXJhdG9yLT5fcnRoZWFkZXIgPSByYWRpb3RhcF9oZWFkZXI7CisJaXRlcmF0b3ItPl9tYXhfbGVuZ3RoID0gZ2V0X3VuYWxpZ25lZF9sZTE2KCZyYWRpb3RhcF9oZWFkZXItPml0X2xlbik7CisJaXRlcmF0b3ItPl9hcmdfaW5kZXggPSAwOworCWl0ZXJhdG9yLT5fYml0bWFwX3NoaWZ0ZXIgPSBnZXRfdW5hbGlnbmVkX2xlMzIoJnJhZGlvdGFwX2hlYWRlci0+aXRfcHJlc2VudCk7CisJaXRlcmF0b3ItPl9hcmcgPSAodWludDhfdCAqKXJhZGlvdGFwX2hlYWRlciArIHNpemVvZigqcmFkaW90YXBfaGVhZGVyKTsKKwlpdGVyYXRvci0+X3Jlc2V0X29uX2V4dCA9IDA7CisJaXRlcmF0b3ItPl9uZXh0X2JpdG1hcCA9ICZyYWRpb3RhcF9oZWFkZXItPml0X3ByZXNlbnQ7CisJaXRlcmF0b3ItPl9uZXh0X2JpdG1hcCsrOworCWl0ZXJhdG9yLT5fdm5zID0gdm5zOworCWl0ZXJhdG9yLT5jdXJyZW50X25hbWVzcGFjZSA9ICZyYWRpb3RhcF9uczsKKwlpdGVyYXRvci0+aXNfcmFkaW90YXBfbnMgPSAxOworI2lmZGVmIFJBRElPVEFQX1NVUFBPUlRfT1ZFUlJJREVTCisJaXRlcmF0b3ItPm5fb3ZlcnJpZGVzID0gMDsKKwlpdGVyYXRvci0+b3ZlcnJpZGVzID0gTlVMTDsKKyNlbmRpZgogCiAJLyogZmluZCBwYXlsb2FkIHN0YXJ0IGFsbG93aW5nIGZvciBleHRlbmRlZCBiaXRtYXAocykgKi8KIAotCWlmICh1bmxpa2VseShpdGVyYXRvci0+Yml0bWFwX3NoaWZ0ZXIgJiAoMTw8SUVFRTgwMjExX1JBRElPVEFQX0VYVCkpKSB7Ci0JCXdoaWxlIChsZTMyX3RvX2NwdShnZXRfdW5hbGlnbmVkKChfX2xlMzIgKilpdGVyYXRvci0+YXJnKSkgJgotCQkJCSAgICgxPDxJRUVFODAyMTFfUkFESU9UQVBfRVhUKSkgewotCQkJaXRlcmF0b3ItPmFyZyArPSBzaXplb2YodTMyKTsKKwlpZiAoaXRlcmF0b3ItPl9iaXRtYXBfc2hpZnRlciAmICgxPDxJRUVFODAyMTFfUkFESU9UQVBfRVhUKSkgeworCQlpZiAoKHVuc2lnbmVkIGxvbmcpaXRlcmF0b3ItPl9hcmcgLQorCQkgICAgKHVuc2lnbmVkIGxvbmcpaXRlcmF0b3ItPl9ydGhlYWRlciArIHNpemVvZih1aW50MzJfdCkgPgorCQkgICAgKHVuc2lnbmVkIGxvbmcpaXRlcmF0b3ItPl9tYXhfbGVuZ3RoKQorCQkJcmV0dXJuIC1FSU5WQUw7CisJCXdoaWxlIChnZXRfdW5hbGlnbmVkX2xlMzIoaXRlcmF0b3ItPl9hcmcpICYKKwkJCQkJKDEgPDwgSUVFRTgwMjExX1JBRElPVEFQX0VYVCkpIHsKKwkJCWl0ZXJhdG9yLT5fYXJnICs9IHNpemVvZih1aW50MzJfdCk7CiAKIAkJCS8qCiAJCQkgKiBjaGVjayBmb3IgaW5zYW5pdHkgd2hlcmUgdGhlIHByZXNlbnQgYml0bWFwcwpAQCAtMTEyLDEyICsxMzcsMTQgQEAKIAkJCSAqIHN0YXRlZCByYWRpb3RhcCBoZWFkZXIgbGVuZ3RoCiAJCQkgKi8KIAotCQkJaWYgKCgodWxvbmcpaXRlcmF0b3ItPmFyZyAtICh1bG9uZylpdGVyYXRvci0+cnRoZWFkZXIpCi0JCQkgICAgPiAodWxvbmcpaXRlcmF0b3ItPm1heF9sZW5ndGgpCisJCQlpZiAoKHVuc2lnbmVkIGxvbmcpaXRlcmF0b3ItPl9hcmcgLQorCQkJICAgICh1bnNpZ25lZCBsb25nKWl0ZXJhdG9yLT5fcnRoZWFkZXIgKworCQkJICAgIHNpemVvZih1aW50MzJfdCkgPgorCQkJICAgICh1bnNpZ25lZCBsb25nKWl0ZXJhdG9yLT5fbWF4X2xlbmd0aCkKIAkJCQlyZXR1cm4gLUVJTlZBTDsKIAkJfQogCi0JCWl0ZXJhdG9yLT5hcmcgKz0gc2l6ZW9mKHUzMik7CisJCWl0ZXJhdG9yLT5fYXJnICs9IHNpemVvZih1aW50MzJfdCk7CiAKIAkJLyoKIAkJICogbm8gbmVlZCB0byBjaGVjayBhZ2FpbiBmb3IgYmxvd2luZyBwYXN0IHN0YXRlZCByYWRpb3RhcApAQCAtMTI2LDExICsxNTMsNTcgQEAKIAkJICovCiAJfQogCisJaXRlcmF0b3ItPnRoaXNfYXJnID0gaXRlcmF0b3ItPl9hcmc7CisKIAkvKiB3ZSBhcmUgYWxsIGluaXRpYWxpemVkIGhhcHBpbHkgKi8KIAogCXJldHVybiAwOwogfQogCitzdGF0aWMgdm9pZCBmaW5kX25zKHN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3IgKml0ZXJhdG9yLAorCQkgICAgdWludDMyX3Qgb3VpLCB1aW50OF90IHN1Ym5zKQoreworCWludCBpOworCisJaXRlcmF0b3ItPmN1cnJlbnRfbmFtZXNwYWNlID0gTlVMTDsKKworCWlmICghaXRlcmF0b3ItPl92bnMpCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7IGkgPCBpdGVyYXRvci0+X3Zucy0+bl9uczsgaSsrKSB7CisJCWlmIChpdGVyYXRvci0+X3Zucy0+bnNbaV0ub3VpICE9IG91aSkKKwkJCWNvbnRpbnVlOworCQlpZiAoaXRlcmF0b3ItPl92bnMtPm5zW2ldLnN1Ym5zICE9IHN1Ym5zKQorCQkJY29udGludWU7CisKKwkJaXRlcmF0b3ItPmN1cnJlbnRfbmFtZXNwYWNlID0gJml0ZXJhdG9yLT5fdm5zLT5uc1tpXTsKKwkJYnJlYWs7CisJfQorfQorCisjaWZkZWYgUkFESU9UQVBfU1VQUE9SVF9PVkVSUklERVMKK3N0YXRpYyBpbnQgZmluZF9vdmVycmlkZShzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yICppdGVyYXRvciwKKwkJCSBpbnQgKmFsaWduLCBpbnQgKnNpemUpCit7CisJaW50IGk7CisKKwlpZiAoIWl0ZXJhdG9yLT5vdmVycmlkZXMpCisJCXJldHVybiAwOworCisJZm9yIChpID0gMDsgaSA8IGl0ZXJhdG9yLT5uX292ZXJyaWRlczsgaSsrKSB7CisJCWlmIChpdGVyYXRvci0+X2FyZ19pbmRleCA9PSBpdGVyYXRvci0+b3ZlcnJpZGVzW2ldLmZpZWxkKSB7CisJCQkqYWxpZ24gPSBpdGVyYXRvci0+b3ZlcnJpZGVzW2ldLmFsaWduOworCQkJKnNpemUgPSBpdGVyYXRvci0+b3ZlcnJpZGVzW2ldLnNpemU7CisJCQlpZiAoISphbGlnbikgLyogZXJyb25lb3VzIG92ZXJyaWRlICovCisJCQkJcmV0dXJuIDA7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0KKworCXJldHVybiAwOworfQorI2VuZGlmCisKIAogLyoqCiAgKiBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3JfbmV4dCAtIHJldHVybiBuZXh0IHJhZGlvdGFwIHBhcnNlciBpdGVyYXRvciBhcmcKQEAgLTE1Niw5OSArMjI5LDEwNiBAQAogICovCiAKIGludCBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3JfbmV4dCgKLSAgICBzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yICppdGVyYXRvcikKKwlzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yICppdGVyYXRvcikKIHsKLQotCS8qCi0JICogc21hbGwgbGVuZ3RoIGxvb2t1cCB0YWJsZSBmb3IgYWxsIHJhZGlvdGFwIHR5cGVzIHdlIGhlYXJkIG9mCi0JICogc3RhcnRpbmcgZnJvbSBiMCBpbiB0aGUgYml0bWFwLCBzbyB3ZSBjYW4gd2FsayB0aGUgcGF5bG9hZAotCSAqIGFyZWEgb2YgdGhlIHJhZGlvdGFwIGhlYWRlcgotCSAqCi0JICogVGhlcmUgaXMgYSByZXF1aXJlbWVudCB0byBwYWQgYXJncywgc28gdGhhdCBhcmdzCi0JICogb2YgYSBnaXZlbiBsZW5ndGggbXVzdCBiZWdpbiBhdCBhIGJvdW5kYXJ5IG9mIHRoYXQgbGVuZ3RoCi0JICogLS0gYnV0IG5vdGUgdGhhdCBjb21wb3VuZCBhcmdzIGFyZSBhbGxvd2VkIChlZywgMiB4IHUxNgotCSAqIGZvciBJRUVFODAyMTFfUkFESU9UQVBfQ0hBTk5FTCkgc28gdG90YWwgYXJnIGxlbmd0aCBpcyBub3QKLQkgKiBhIHJlbGlhYmxlIGluZGljYXRvciBvZiBhbGlnbm1lbnQgcmVxdWlyZW1lbnQuCi0JICoKLQkgKiB1cHBlciBueWJibGU6IGNvbnRlbnQgYWxpZ25tZW50IGZvciBhcmcKLQkgKiBsb3dlciBueWJibGU6IGNvbnRlbnQgbGVuZ3RoIGZvciBhcmcKLQkgKi8KLQotCXN0YXRpYyBjb25zdCB1OCBydF9zaXplc1tdID0gewotCQlbSUVFRTgwMjExX1JBRElPVEFQX1RTRlRdID0gMHg4OCwKLQkJW0lFRUU4MDIxMV9SQURJT1RBUF9GTEFHU10gPSAweDExLAotCQlbSUVFRTgwMjExX1JBRElPVEFQX1JBVEVdID0gMHgxMSwKLQkJW0lFRUU4MDIxMV9SQURJT1RBUF9DSEFOTkVMXSA9IDB4MjQsCi0JCVtJRUVFODAyMTFfUkFESU9UQVBfRkhTU10gPSAweDIyLAotCQlbSUVFRTgwMjExX1JBRElPVEFQX0RCTV9BTlRTSUdOQUxdID0gMHgxMSwKLQkJW0lFRUU4MDIxMV9SQURJT1RBUF9EQk1fQU5UTk9JU0VdID0gMHgxMSwKLQkJW0lFRUU4MDIxMV9SQURJT1RBUF9MT0NLX1FVQUxJVFldID0gMHgyMiwKLQkJW0lFRUU4MDIxMV9SQURJT1RBUF9UWF9BVFRFTlVBVElPTl0gPSAweDIyLAotCQlbSUVFRTgwMjExX1JBRElPVEFQX0RCX1RYX0FUVEVOVUFUSU9OXSA9IDB4MjIsCi0JCVtJRUVFODAyMTFfUkFESU9UQVBfREJNX1RYX1BPV0VSXSA9IDB4MTEsCi0JCVtJRUVFODAyMTFfUkFESU9UQVBfQU5URU5OQV0gPSAweDExLAotCQlbSUVFRTgwMjExX1JBRElPVEFQX0RCX0FOVFNJR05BTF0gPSAweDExLAotCQlbSUVFRTgwMjExX1JBRElPVEFQX0RCX0FOVE5PSVNFXSA9IDB4MTEsCi0JCVtJRUVFODAyMTFfUkFESU9UQVBfUlhfRkxBR1NdID0gMHgyMiwKLQkJW0lFRUU4MDIxMV9SQURJT1RBUF9UWF9GTEFHU10gPSAweDIyLAotCQlbSUVFRTgwMjExX1JBRElPVEFQX1JUU19SRVRSSUVTXSA9IDB4MTEsCi0JCVtJRUVFODAyMTFfUkFESU9UQVBfREFUQV9SRVRSSUVTXSA9IDB4MTEsCi0JCS8qCi0JCSAqIGFkZCBtb3JlIGhlcmUgYXMgdGhleSBhcmUgZGVmaW5lZCBpbgotCQkgKiBpbmNsdWRlL25ldC9pZWVlODAyMTFfcmFkaW90YXAuaAotCQkgKi8KLQl9OwotCi0JLyoKLQkgKiBmb3IgZXZlcnkgcmFkaW90YXAgZW50cnkgd2UgY2FuIGF0Ci0JICogbGVhc3Qgc2tpcCAoYnkga25vd2luZyB0aGUgbGVuZ3RoKS4uLgotCSAqLwotCi0Jd2hpbGUgKGl0ZXJhdG9yLT5hcmdfaW5kZXggPCAoaW50KSBzaXplb2YocnRfc2l6ZXMpKSB7CisJd2hpbGUgKDEpIHsKIAkJaW50IGhpdCA9IDA7Ci0JCWludCBwYWQ7CisJCWludCBwYWQsIGFsaWduLCBzaXplLCBzdWJuczsKKwkJdWludDMyX3Qgb3VpOwogCi0JCWlmICghKGl0ZXJhdG9yLT5iaXRtYXBfc2hpZnRlciAmIDEpKQorCQkvKiBpZiBubyBtb3JlIEVYVCBiaXRzLCB0aGF0J3MgaXQgKi8KKwkJaWYgKChpdGVyYXRvci0+X2FyZ19pbmRleCAlIDMyKSA9PSBJRUVFODAyMTFfUkFESU9UQVBfRVhUICYmCisJCSAgICAhKGl0ZXJhdG9yLT5fYml0bWFwX3NoaWZ0ZXIgJiAxKSkKKwkJCXJldHVybiAtRU5PRU5UOworCisJCWlmICghKGl0ZXJhdG9yLT5fYml0bWFwX3NoaWZ0ZXIgJiAxKSkKIAkJCWdvdG8gbmV4dF9lbnRyeTsgLyogYXJnIG5vdCBwcmVzZW50ICovCiAKKwkJLyogZ2V0IGFsaWdubWVudC9zaXplIG9mIGRhdGEgKi8KKwkJc3dpdGNoIChpdGVyYXRvci0+X2FyZ19pbmRleCAlIDMyKSB7CisJCWNhc2UgSUVFRTgwMjExX1JBRElPVEFQX1JBRElPVEFQX05BTUVTUEFDRToKKwkJY2FzZSBJRUVFODAyMTFfUkFESU9UQVBfRVhUOgorCQkJYWxpZ24gPSAxOworCQkJc2l6ZSA9IDA7CisJCQlicmVhazsKKwkJY2FzZSBJRUVFODAyMTFfUkFESU9UQVBfVkVORE9SX05BTUVTUEFDRToKKwkJCWFsaWduID0gMjsKKwkJCXNpemUgPSA2OworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisjaWZkZWYgUkFESU9UQVBfU1VQUE9SVF9PVkVSUklERVMKKwkJCWlmIChmaW5kX292ZXJyaWRlKGl0ZXJhdG9yLCAmYWxpZ24sICZzaXplKSkgeworCQkJCS8qIGFsbCBzZXQgKi8KKwkJCX0gZWxzZQorI2VuZGlmCisJCQlpZiAoIWl0ZXJhdG9yLT5jdXJyZW50X25hbWVzcGFjZSB8fAorCQkJICAgIGl0ZXJhdG9yLT5fYXJnX2luZGV4ID49IGl0ZXJhdG9yLT5jdXJyZW50X25hbWVzcGFjZS0+bl9iaXRzKSB7CisJCQkJaWYgKGl0ZXJhdG9yLT5jdXJyZW50X25hbWVzcGFjZSA9PSAmcmFkaW90YXBfbnMpCisJCQkJCXJldHVybiAtRU5PRU5UOworCQkJCWFsaWduID0gMDsKKwkJCX0gZWxzZSB7CisJCQkJYWxpZ24gPSBpdGVyYXRvci0+Y3VycmVudF9uYW1lc3BhY2UtPmFsaWduX3NpemVbaXRlcmF0b3ItPl9hcmdfaW5kZXhdLmFsaWduOworCQkJCXNpemUgPSBpdGVyYXRvci0+Y3VycmVudF9uYW1lc3BhY2UtPmFsaWduX3NpemVbaXRlcmF0b3ItPl9hcmdfaW5kZXhdLnNpemU7CisJCQl9CisJCQlpZiAoIWFsaWduKSB7CisJCQkJLyogc2tpcCBhbGwgc3Vic2VxdWVudCBkYXRhICovCisJCQkJaXRlcmF0b3ItPl9hcmcgPSBpdGVyYXRvci0+X25leHRfbnNfZGF0YTsKKwkJCQkvKiBnaXZlIHVwIG9uIHRoaXMgbmFtZXNwYWNlICovCisJCQkJaXRlcmF0b3ItPmN1cnJlbnRfbmFtZXNwYWNlID0gTlVMTDsKKwkJCQlnb3RvIG5leHRfZW50cnk7CisJCQl9CisJCQlicmVhazsKKwkJfQorCiAJCS8qCiAJCSAqIGFyZyBpcyBwcmVzZW50LCBhY2NvdW50IGZvciBhbGlnbm1lbnQgcGFkZGluZwotCQkgKiAgOC1iaXQgYXJncyBjYW4gYmUgYXQgYW55IGFsaWdubWVudAotCQkgKiAxNi1iaXQgYXJncyBtdXN0IHN0YXJ0IG9uIDE2LWJpdCBib3VuZGFyeQotCQkgKiAzMi1iaXQgYXJncyBtdXN0IHN0YXJ0IG9uIDMyLWJpdCBib3VuZGFyeQotCQkgKiA2NC1iaXQgYXJncyBtdXN0IHN0YXJ0IG9uIDY0LWJpdCBib3VuZGFyeQogCQkgKgotCQkgKiBub3RlIHRoYXQgdG90YWwgYXJnIHNpemUgY2FuIGRpZmZlciBmcm9tIGFsaWdubWVudCBvZgotCQkgKiBlbGVtZW50cyBpbnNpZGUgYXJnLCBzbyB3ZSB1c2UgdXBwZXIgbnliYmxlIG9mIGxlbmd0aAotCQkgKiB0YWJsZSB0byBiYXNlIGFsaWdubWVudCBvbgotCQkgKgotCQkgKiBhbHNvIG5vdGU6IHRoZXNlIGFsaWdubWVudHMgYXJlICoqIHJlbGF0aXZlIHRvIHRoZQotCQkgKiBzdGFydCBvZiB0aGUgcmFkaW90YXAgaGVhZGVyICoqLiAgVGhlcmUgaXMgbm8gZ3VhcmFudGVlCisJCSAqIE5vdGUgdGhhdCB0aGVzZSBhbGlnbm1lbnRzIGFyZSByZWxhdGl2ZSB0byB0aGUgc3RhcnQKKwkJICogb2YgdGhlIHJhZGlvdGFwIGhlYWRlci4gIFRoZXJlIGlzIG5vIGd1YXJhbnRlZQogCQkgKiB0aGF0IHRoZSByYWRpb3RhcCBoZWFkZXIgaXRzZWxmIGlzIGFsaWduZWQgb24gYW55CiAJCSAqIGtpbmQgb2YgYm91bmRhcnkuCiAJCSAqCi0JCSAqIHRoZSBhYm92ZSBpcyB3aHkgZ2V0X3VuYWxpZ25lZCgpIGlzIHVzZWQgdG8gZGVyZWZlcmVuY2UKLQkJICogbXVsdGlieXRlIGVsZW1lbnRzIGZyb20gdGhlIHJhZGlvdGFwIGFyZWEKKwkJICogVGhlIGFib3ZlIGlzIHdoeSBnZXRfdW5hbGlnbmVkKCkgaXMgdXNlZCB0byBkZXJlZmVyZW5jZQorCQkgKiBtdWx0aWJ5dGUgZWxlbWVudHMgZnJvbSB0aGUgcmFkaW90YXAgYXJlYS4KIAkJICovCiAKLQkJcGFkID0gKCgodWxvbmcpaXRlcmF0b3ItPmFyZykgLQotCQkJKCh1bG9uZylpdGVyYXRvci0+cnRoZWFkZXIpKSAmCi0JCQkoKHJ0X3NpemVzW2l0ZXJhdG9yLT5hcmdfaW5kZXhdID4+IDQpIC0gMSk7CisJCXBhZCA9ICgodW5zaWduZWQgbG9uZylpdGVyYXRvci0+X2FyZyAtCisJCSAgICAgICAodW5zaWduZWQgbG9uZylpdGVyYXRvci0+X3J0aGVhZGVyKSAmIChhbGlnbiAtIDEpOwogCiAJCWlmIChwYWQpCi0JCQlpdGVyYXRvci0+YXJnICs9Ci0JCQkJKHJ0X3NpemVzW2l0ZXJhdG9yLT5hcmdfaW5kZXhdID4+IDQpIC0gcGFkOworCQkJaXRlcmF0b3ItPl9hcmcgKz0gYWxpZ24gLSBwYWQ7CisKKwkJaWYgKGl0ZXJhdG9yLT5fYXJnX2luZGV4ICUgMzIgPT0gSUVFRTgwMjExX1JBRElPVEFQX1ZFTkRPUl9OQU1FU1BBQ0UpIHsKKwkJCWludCB2bnNsZW47CisKKwkJCWlmICgodW5zaWduZWQgbG9uZylpdGVyYXRvci0+X2FyZyArIHNpemUgLQorCQkJICAgICh1bnNpZ25lZCBsb25nKWl0ZXJhdG9yLT5fcnRoZWFkZXIgPgorCQkJICAgICh1bnNpZ25lZCBsb25nKWl0ZXJhdG9yLT5fbWF4X2xlbmd0aCkKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKworCQkJb3VpID0gKCppdGVyYXRvci0+X2FyZyA8PCAxNikgfAorCQkJCSgqKGl0ZXJhdG9yLT5fYXJnICsgMSkgPDwgOCkgfAorCQkJCSooaXRlcmF0b3ItPl9hcmcgKyAyKTsKKwkJCXN1Ym5zID0gKihpdGVyYXRvci0+X2FyZyArIDMpOworCisJCQlmaW5kX25zKGl0ZXJhdG9yLCBvdWksIHN1Ym5zKTsKKworCQkJdm5zbGVuID0gZ2V0X3VuYWxpZ25lZF9sZTE2KGl0ZXJhdG9yLT5fYXJnICsgNCk7CisJCQlpdGVyYXRvci0+X25leHRfbnNfZGF0YSA9IGl0ZXJhdG9yLT5fYXJnICsgc2l6ZSArIHZuc2xlbjsKKwkJCWlmICghaXRlcmF0b3ItPmN1cnJlbnRfbmFtZXNwYWNlKQorCQkJCXNpemUgKz0gdm5zbGVuOworCQl9CiAKIAkJLyoKIAkJICogdGhpcyBpcyB3aGF0IHdlIHdpbGwgcmV0dXJuIHRvIHVzZXIsIGJ1dCB3ZSBuZWVkIHRvCiAJCSAqIG1vdmUgb24gZmlyc3Qgc28gbmV4dCBjYWxsIGhhcyBzb21ldGhpbmcgZnJlc2ggdG8gdGVzdAogCQkgKi8KLQkJaXRlcmF0b3ItPnRoaXNfYXJnX2luZGV4ID0gaXRlcmF0b3ItPmFyZ19pbmRleDsKLQkJaXRlcmF0b3ItPnRoaXNfYXJnID0gaXRlcmF0b3ItPmFyZzsKLQkJaGl0ID0gMTsKKwkJaXRlcmF0b3ItPnRoaXNfYXJnX2luZGV4ID0gaXRlcmF0b3ItPl9hcmdfaW5kZXg7CisJCWl0ZXJhdG9yLT50aGlzX2FyZyA9IGl0ZXJhdG9yLT5fYXJnOworCQlpdGVyYXRvci0+dGhpc19hcmdfc2l6ZSA9IHNpemU7CiAKIAkJLyogaW50ZXJuYWxseSBtb3ZlIG9uIHRoZSBzaXplIG9mIHRoaXMgYXJnICovCi0JCWl0ZXJhdG9yLT5hcmcgKz0gcnRfc2l6ZXNbaXRlcmF0b3ItPmFyZ19pbmRleF0gJiAweDBmOworCQlpdGVyYXRvci0+X2FyZyArPSBzaXplOwogCiAJCS8qCiAJCSAqIGNoZWNrIGZvciBpbnNhbml0eSB3aGVyZSB3ZSBhcmUgZ2l2ZW4gYSBiaXRtYXAgdGhhdApAQCAtMjU3LDMxICszMzcsNTcgQEAKIAkJICogbWF4X2xlbmd0aCBvbiB0aGUgbGFzdCBhcmcsIG5ldmVyIGV4Y2VlZGluZyBpdC4KIAkJICovCiAKLQkJaWYgKCgodWxvbmcpaXRlcmF0b3ItPmFyZyAtICh1bG9uZylpdGVyYXRvci0+cnRoZWFkZXIpID4KLQkJICAgICh1bG9uZykgaXRlcmF0b3ItPm1heF9sZW5ndGgpCisJCWlmICgodW5zaWduZWQgbG9uZylpdGVyYXRvci0+X2FyZyAtCisJCSAgICAodW5zaWduZWQgbG9uZylpdGVyYXRvci0+X3J0aGVhZGVyID4KKwkJICAgICh1bnNpZ25lZCBsb25nKWl0ZXJhdG9yLT5fbWF4X2xlbmd0aCkKIAkJCXJldHVybiAtRUlOVkFMOwogCi0JbmV4dF9lbnRyeToKLQkJaXRlcmF0b3ItPmFyZ19pbmRleCsrOwotCQlpZiAodW5saWtlbHkoKGl0ZXJhdG9yLT5hcmdfaW5kZXggJiAzMSkgPT0gMCkpIHsKLQkJCS8qIGNvbXBsZXRlZCBjdXJyZW50IHUzMiBiaXRtYXAgKi8KLQkJCWlmIChpdGVyYXRvci0+Yml0bWFwX3NoaWZ0ZXIgJiAxKSB7Ci0JCQkJLyogYjMxIHdhcyBzZXQsIHRoZXJlIGlzIG1vcmUgKi8KLQkJCQkvKiBtb3ZlIHRvIG5leHQgdTMyIGJpdG1hcCAqLwotCQkJCWl0ZXJhdG9yLT5iaXRtYXBfc2hpZnRlciA9IGxlMzJfdG9fY3B1KAotCQkJCQlnZXRfdW5hbGlnbmVkKGl0ZXJhdG9yLT5uZXh0X2JpdG1hcCkpOwotCQkJCWl0ZXJhdG9yLT5uZXh0X2JpdG1hcCsrOwotCQkJfSBlbHNlCi0JCQkJLyogbm8gbW9yZSBiaXRtYXBzOiBlbmQgKi8KLQkJCQlpdGVyYXRvci0+YXJnX2luZGV4ID0gc2l6ZW9mKHJ0X3NpemVzKTsKLQkJfSBlbHNlIC8qIGp1c3QgdHJ5IHRoZSBuZXh0IGJpdCAqLwotCQkJaXRlcmF0b3ItPmJpdG1hcF9zaGlmdGVyID4+PSAxOworCQkvKiB0aGVzZSBzcGVjaWFsIG9uZXMgYXJlIHZhbGlkIGluIGVhY2ggYml0bWFwIHdvcmQgKi8KKwkJc3dpdGNoIChpdGVyYXRvci0+X2FyZ19pbmRleCAlIDMyKSB7CisJCWNhc2UgSUVFRTgwMjExX1JBRElPVEFQX1ZFTkRPUl9OQU1FU1BBQ0U6CisJCQlpdGVyYXRvci0+X3Jlc2V0X29uX2V4dCA9IDE7CisKKwkJCWl0ZXJhdG9yLT5pc19yYWRpb3RhcF9ucyA9IDA7CisJCQkvKgorCQkJICogSWYgcGFyc2VyIGRpZG4ndCByZWdpc3RlciB0aGlzIHZlbmRvcgorCQkJICogbmFtZXNwYWNlIHdpdGggdXMsIGFsbG93IGl0IHRvIHNob3cgaXQKKwkJCSAqIGFzICdyYXcuIERvIGRvIHRoYXQsIHNldCBhcmd1bWVudCBpbmRleAorCQkJICogdG8gdmVuZG9yIG5hbWVzcGFjZS4KKwkJCSAqLworCQkJaXRlcmF0b3ItPnRoaXNfYXJnX2luZGV4ID0KKwkJCQlJRUVFODAyMTFfUkFESU9UQVBfVkVORE9SX05BTUVTUEFDRTsKKwkJCWlmICghaXRlcmF0b3ItPmN1cnJlbnRfbmFtZXNwYWNlKQorCQkJCWhpdCA9IDE7CisJCQlnb3RvIG5leHRfZW50cnk7CisJCWNhc2UgSUVFRTgwMjExX1JBRElPVEFQX1JBRElPVEFQX05BTUVTUEFDRToKKwkJCWl0ZXJhdG9yLT5fcmVzZXRfb25fZXh0ID0gMTsKKwkJCWl0ZXJhdG9yLT5jdXJyZW50X25hbWVzcGFjZSA9ICZyYWRpb3RhcF9uczsKKwkJCWl0ZXJhdG9yLT5pc19yYWRpb3RhcF9ucyA9IDE7CisJCQlnb3RvIG5leHRfZW50cnk7CisJCWNhc2UgSUVFRTgwMjExX1JBRElPVEFQX0VYVDoKKwkJCS8qCisJCQkgKiBiaXQgMzEgd2FzIHNldCwgdGhlcmUgaXMgbW9yZQorCQkJICogLS0gbW92ZSB0byBuZXh0IHUzMiBiaXRtYXAKKwkJCSAqLworCQkJaXRlcmF0b3ItPl9iaXRtYXBfc2hpZnRlciA9CisJCQkJZ2V0X3VuYWxpZ25lZF9sZTMyKGl0ZXJhdG9yLT5fbmV4dF9iaXRtYXApOworCQkJaXRlcmF0b3ItPl9uZXh0X2JpdG1hcCsrOworCQkJaWYgKGl0ZXJhdG9yLT5fcmVzZXRfb25fZXh0KQorCQkJCWl0ZXJhdG9yLT5fYXJnX2luZGV4ID0gMDsKKwkJCWVsc2UKKwkJCQlpdGVyYXRvci0+X2FyZ19pbmRleCsrOworCQkJaXRlcmF0b3ItPl9yZXNldF9vbl9leHQgPSAwOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQkvKiB3ZSd2ZSBnb3QgYSBoaXQhICovCisJCQloaXQgPSAxOworIG5leHRfZW50cnk6CisJCQlpdGVyYXRvci0+X2JpdG1hcF9zaGlmdGVyID4+PSAxOworCQkJaXRlcmF0b3ItPl9hcmdfaW5kZXgrKzsKKwkJfQogCiAJCS8qIGlmIHdlIGZvdW5kIGEgdmFsaWQgYXJnIGVhcmxpZXIsIHJldHVybiBpdCBub3cgKi8KIAkJaWYgKGhpdCkKIAkJCXJldHVybiAwOwogCX0KLQotCS8qIHdlIGRvbid0IGtub3cgaG93IHRvIGhhbmRsZSBhbnkgbW9yZSBhcmdzLCB3ZSdyZSBkb25lICovCi0JcmV0dXJuIC1FTk9FTlQ7CiB9CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvcmFkaW90YXAuaCBiL3NyYy91dGlscy9yYWRpb3RhcC5oCmluZGV4IDEzNzI4OGYuLjA1NzJlN2MgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9yYWRpb3RhcC5oCisrKyBiL3NyYy91dGlscy9yYWRpb3RhcC5oCkBAIC0xLDYgKzEsMyBAQAotLyogJEZyZWVCU0Q6IHNyYy9zeXMvbmV0ODAyMTEvaWVlZTgwMjExX3JhZGlvdGFwLmgsdiAxLjUgMjAwNS8wMS8yMiAyMDoxMjowNSBzYW0gRXhwICQgKi8KLS8qICROZXRCU0Q6IGllZWU4MDIxMV9yYWRpb3RhcC5oLHYgMS4xMSAyMDA1LzA2LzIyIDA2OjE2OjAyIGR5b3VuZyBFeHAgJCAqLwotCiAvKi0KICAqIENvcHlyaWdodCAoYykgMjAwMywgMjAwNCBEYXZpZCBZb3VuZy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgpAQCAtMTc4LDYgKzE3NSwxNCBAQAogICoKICAqICAgICBOdW1iZXIgb2YgdW5pY2FzdCByZXRyaWVzIGEgdHJhbnNtaXR0ZWQgZnJhbWUgdXNlZC4KICAqCisgKiBJRUVFODAyMTFfUkFESU9UQVBfTUNTCXU4LCB1OCwgdTgJCXVuaXRsZXNzCisgKgorICogICAgIENvbnRhaW5zIGEgYml0bWFwIG9mIGtub3duIGZpZWxkcy9mbGFncywgdGhlIGZsYWdzLCBhbmQKKyAqICAgICB0aGUgTUNTIGluZGV4LgorICoKKyAqIElFRUU4MDIxMV9SQURJT1RBUF9BTVBEVV9TVEFUVVMJdTMyLCB1MTYsIHU4LCB1OAl1bml0bGVzc3MKKyAqCisgKglDb250YWlucyB0aGUgQU1QRFUgaW5mb3JtYXRpb24gZm9yIHRoZSBzdWJmcmFtZS4KICAqLwogZW51bSBpZWVlODAyMTFfcmFkaW90YXBfdHlwZSB7CiAJSUVFRTgwMjExX1JBRElPVEFQX1RTRlQgPSAwLApAQCAtMTk4LDYgKzIwMywxMyBAQAogCUlFRUU4MDIxMV9SQURJT1RBUF9UWF9GTEFHUyA9IDE1LAogCUlFRUU4MDIxMV9SQURJT1RBUF9SVFNfUkVUUklFUyA9IDE2LAogCUlFRUU4MDIxMV9SQURJT1RBUF9EQVRBX1JFVFJJRVMgPSAxNywKKworCUlFRUU4MDIxMV9SQURJT1RBUF9NQ1MgPSAxOSwKKwlJRUVFODAyMTFfUkFESU9UQVBfQU1QRFVfU1RBVFVTID0gMjAsCisKKwkvKiB2YWxpZCBpbiBldmVyeSBpdF9wcmVzZW50IGJpdG1hcCwgZXZlbiB2ZW5kb3IgbmFtZXNwYWNlcyAqLworCUlFRUU4MDIxMV9SQURJT1RBUF9SQURJT1RBUF9OQU1FU1BBQ0UgPSAyOSwKKwlJRUVFODAyMTFfUkFESU9UQVBfVkVORE9SX05BTUVTUEFDRSA9IDMwLAogCUlFRUU4MDIxMV9SQURJT1RBUF9FWFQgPSAzMQogfTsKIApAQCAtMjMwLDggKzI0MiwxMCBAQAogCQkJCQkJICogODAyLjExIGhlYWRlciBhbmQgcGF5bG9hZAogCQkJCQkJICogKHRvIDMyLWJpdCBib3VuZGFyeSkKIAkJCQkJCSAqLworI2RlZmluZSBJRUVFODAyMTFfUkFESU9UQVBfRl9CQURGQ1MJMHg0MAkvKiBmcmFtZSBmYWlsZWQgRkNTIGNoZWNrICovCisKIC8qIEZvciBJRUVFODAyMTFfUkFESU9UQVBfUlhfRkxBR1MgKi8KLSNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX0ZfUlhfQkFERkNTCTB4MDAwMQkvKiBmcmFtZSBmYWlsZWQgY3JjIGNoZWNrICovCisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9GX1JYX0JBRFBMQ1AJMHgwMDAyIC8qIGJhZCBQTENQICovCiAKIC8qIEZvciBJRUVFODAyMTFfUkFESU9UQVBfVFhfRkxBR1MgKi8KICNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX0ZfVFhfRkFJTAkweDAwMDEJLyogZmFpbGVkIGR1ZSB0byBleGNlc3NpdmUKQEAgLTI0MCw0ICsyNTQsMzggQEAKICNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX0ZfVFhfUlRTCTB4MDAwNAkvKiB1c2VkIHJ0cy9jdHMgaGFuZHNoYWtlICovCiAjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9GX1RYX05PQUNLCTB4MDAwOAkvKiBkb24ndCBleHBlY3QgYW4gQUNLICovCiAKKy8qIEZvciBJRUVFODAyMTFfUkFESU9UQVBfQU1QRFVfU1RBVFVTICovCisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9BTVBEVV9SRVBPUlRfWkVST0xFTgkJMHgwMDAxCisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9BTVBEVV9JU19aRVJPTEVOCQkweDAwMDIKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX0FNUERVX0xBU1RfS05PV04JCTB4MDAwNAorI2RlZmluZSBJRUVFODAyMTFfUkFESU9UQVBfQU1QRFVfSVNfTEFTVAkJMHgwMDA4CisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9BTVBEVV9ERUxJTV9DUkNfRVJSCQkweDAwMTAKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX0FNUERVX0RFTElNX0NSQ19LTk9XTgkweDAwMjAKKworLyogRm9yIElFRUU4MDIxMV9SQURJT1RBUF9NQ1MgKi8KKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX01DU19IQVZFX0JXCQkweDAxCisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9NQ1NfSEFWRV9NQ1MJCTB4MDIKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX01DU19IQVZFX0dJCQkweDA0CisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9NQ1NfSEFWRV9GTVQJCTB4MDgKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX01DU19IQVZFX0ZFQwkJMHgxMAorI2RlZmluZSBJRUVFODAyMTFfUkFESU9UQVBfTUNTX0hBVkVfU1RCQwkweDIwCisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9NQ1NfSEFWRV9ORVNTCTB4NDAKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX01DU19ORVNTX0JJVDEJMHg4MAorCisKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX01DU19CV19NQVNLCQkweDAzCisjZGVmaW5lCQlJRUVFODAyMTFfUkFESU9UQVBfTUNTX0JXXzIwCTAKKyNkZWZpbmUJCUlFRUU4MDIxMV9SQURJT1RBUF9NQ1NfQldfNDAJMQorI2RlZmluZQkJSUVFRTgwMjExX1JBRElPVEFQX01DU19CV18yMEwJMgorI2RlZmluZQkJSUVFRTgwMjExX1JBRElPVEFQX01DU19CV18yMFUJMworI2RlZmluZSBJRUVFODAyMTFfUkFESU9UQVBfTUNTX1NHSQkJMHgwNAorI2RlZmluZSBJRUVFODAyMTFfUkFESU9UQVBfTUNTX0ZNVF9HRgkJMHgwOAorI2RlZmluZSBJRUVFODAyMTFfUkFESU9UQVBfTUNTX0ZFQ19MRFBDCQkweDEwCisjZGVmaW5lIElFRUU4MDIxMV9SQURJT1RBUF9NQ1NfU1RCQ19NQVNLCTB4NjAKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX01DU19TVEJDX1NISUZUCTUKKyNkZWZpbmUJCUlFRUU4MDIxMV9SQURJT1RBUF9NQ1NfU1RCQ18xCTEKKyNkZWZpbmUJCUlFRUU4MDIxMV9SQURJT1RBUF9NQ1NfU1RCQ18yCTIKKyNkZWZpbmUJCUlFRUU4MDIxMV9SQURJT1RBUF9NQ1NfU1RCQ18zCTMKKyNkZWZpbmUgSUVFRTgwMjExX1JBRElPVEFQX01DU19ORVNTX0JJVDAJMHg4MAorCiAjZW5kaWYJCQkJLyogSUVFRTgwMjExX1JBRElPVEFQX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy91dGlscy9yYWRpb3RhcF9pdGVyLmggYi9zcmMvdXRpbHMvcmFkaW90YXBfaXRlci5oCmluZGV4IDJlMGU4NzIuLmI3NjhjODUgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9yYWRpb3RhcF9pdGVyLmgKKysrIGIvc3JjL3V0aWxzL3JhZGlvdGFwX2l0ZXIuaApAQCAtMSw1NiArMSw5NiBAQAotLyoKLSAqIFJhZGlvdGFwIHBhcnNlcgotICoKLSAqIENvcHlyaWdodCAyMDA3CQlBbmR5IEdyZWVuIDxhbmR5QHdhcm1jYXQuY29tPgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCi0gKi8KLQogI2lmbmRlZiBfX1JBRElPVEFQX0lURVJfSAogI2RlZmluZSBfX1JBRElPVEFQX0lURVJfSAogCisjaW5jbHVkZSA8c3RkaW50Lmg+CiAjaW5jbHVkZSAicmFkaW90YXAuaCIKIAogLyogUmFkaW90YXAgaGVhZGVyIGl0ZXJhdGlvbgogICogICBpbXBsZW1lbnRlZCBpbiByYWRpb3RhcC5jCiAgKi8KKworc3RydWN0IHJhZGlvdGFwX292ZXJyaWRlIHsKKwl1aW50OF90IGZpZWxkOworCXVpbnQ4X3QgYWxpZ246NCwgc2l6ZTo0OworfTsKKworc3RydWN0IHJhZGlvdGFwX2FsaWduX3NpemUgeworCXVpbnQ4X3QgYWxpZ246NCwgc2l6ZTo0OworfTsKKworc3RydWN0IGllZWU4MDIxMV9yYWRpb3RhcF9uYW1lc3BhY2UgeworCWNvbnN0IHN0cnVjdCByYWRpb3RhcF9hbGlnbl9zaXplICphbGlnbl9zaXplOworCWludCBuX2JpdHM7CisJdWludDMyX3Qgb3VpOworCXVpbnQ4X3Qgc3VibnM7Cit9OworCitzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX3ZlbmRvcl9uYW1lc3BhY2VzIHsKKwljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX25hbWVzcGFjZSAqbnM7CisJaW50IG5fbnM7Cit9OworCiAvKioKICAqIHN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3IgLSB0cmFja3Mgd2FsayB0aHJ1IHByZXNlbnQgcmFkaW90YXAgYXJncwotICogQHJ0aGVhZGVyOiBwb2ludGVyIHRvIHRoZSByYWRpb3RhcCBoZWFkZXIgd2UgYXJlIHdhbGtpbmcgdGhyb3VnaAotICogQG1heF9sZW5ndGg6IGxlbmd0aCBvZiByYWRpb3RhcCBoZWFkZXIgaW4gY3B1IGJ5dGUgb3JkZXJpbmcKLSAqIEB0aGlzX2FyZ19pbmRleDogSUVFRTgwMjExX1JBRElPVEFQXy4uLiBpbmRleCBvZiBjdXJyZW50IGFyZwotICogQHRoaXNfYXJnOiBwb2ludGVyIHRvIGN1cnJlbnQgcmFkaW90YXAgYXJnCi0gKiBAYXJnX2luZGV4OiBpbnRlcm5hbCBuZXh0IGFyZ3VtZW50IGluZGV4Ci0gKiBAYXJnOiBpbnRlcm5hbCBuZXh0IGFyZ3VtZW50IHBvaW50ZXIKLSAqIEBuZXh0X2JpdG1hcDogaW50ZXJuYWwgcG9pbnRlciB0byBuZXh0IHByZXNlbnQgdTMyCi0gKiBAYml0bWFwX3NoaWZ0ZXI6IGludGVybmFsIHNoaWZ0ZXIgZm9yIGN1cnIgdTMyIGJpdG1hcCwgYjAgc2V0ID09IGFyZyBwcmVzZW50CisgKiBAdGhpc19hcmdfaW5kZXg6IGluZGV4IG9mIGN1cnJlbnQgYXJnLCB2YWxpZCBhZnRlciBlYWNoIHN1Y2Nlc3NmdWwgY2FsbAorICoJdG8gaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yX25leHQoKQorICogQHRoaXNfYXJnOiBwb2ludGVyIHRvIGN1cnJlbnQgcmFkaW90YXAgYXJnOyBpdCBpcyB2YWxpZCBhZnRlciBlYWNoCisgKgljYWxsIHRvIGllZWU4MDIxMV9yYWRpb3RhcF9pdGVyYXRvcl9uZXh0KCkgYnV0IGFsc28gYWZ0ZXIKKyAqCWllZWU4MDIxMV9yYWRpb3RhcF9pdGVyYXRvcl9pbml0KCkgd2hlcmUgaXQgd2lsbCBwb2ludCB0bworICoJdGhlIGJlZ2lubmluZyBvZiB0aGUgYWN0dWFsIGRhdGEgcG9ydGlvbgorICogQHRoaXNfYXJnX3NpemU6IGxlbmd0aCBvZiB0aGUgY3VycmVudCBhcmcsIGZvciBjb252ZW5pZW5jZQorICogQGN1cnJlbnRfbmFtZXNwYWNlOiBwb2ludGVyIHRvIHRoZSBjdXJyZW50IG5hbWVzcGFjZSBkZWZpbml0aW9uCisgKgkob3IgaW50ZXJuYWxseSAlTlVMTCBpZiB0aGUgY3VycmVudCBuYW1lc3BhY2UgaXMgdW5rbm93bikKKyAqIEBpc19yYWRpb3RhcF9uczogaW5kaWNhdGVzIHdoZXRoZXIgdGhlIGN1cnJlbnQgbmFtZXNwYWNlIGlzIHRoZSBkZWZhdWx0CisgKglyYWRpb3RhcCBuYW1lc3BhY2Ugb3Igbm90CisgKgorICogQG92ZXJyaWRlczogb3ZlcnJpZGUgc3RhbmRhcmQgcmFkaW90YXAgZmllbGRzCisgKiBAbl9vdmVycmlkZXM6IG51bWJlciBvZiBvdmVycmlkZXMKKyAqCisgKiBAX3J0aGVhZGVyOiBwb2ludGVyIHRvIHRoZSByYWRpb3RhcCBoZWFkZXIgd2UgYXJlIHdhbGtpbmcgdGhyb3VnaAorICogQF9tYXhfbGVuZ3RoOiBsZW5ndGggb2YgcmFkaW90YXAgaGVhZGVyIGluIGNwdSBieXRlIG9yZGVyaW5nCisgKiBAX2FyZ19pbmRleDogbmV4dCBhcmd1bWVudCBpbmRleAorICogQF9hcmc6IG5leHQgYXJndW1lbnQgcG9pbnRlcgorICogQF9uZXh0X2JpdG1hcDogaW50ZXJuYWwgcG9pbnRlciB0byBuZXh0IHByZXNlbnQgdTMyCisgKiBAX2JpdG1hcF9zaGlmdGVyOiBpbnRlcm5hbCBzaGlmdGVyIGZvciBjdXJyIHUzMiBiaXRtYXAsIGIwIHNldCA9PSBhcmcgcHJlc2VudAorICogQF92bnM6IHZlbmRvciBuYW1lc3BhY2UgZGVmaW5pdGlvbnMKKyAqIEBfbmV4dF9uc19kYXRhOiBiZWdpbm5pbmcgb2YgdGhlIG5leHQgbmFtZXNwYWNlJ3MgZGF0YQorICogQF9yZXNldF9vbl9leHQ6IGludGVybmFsOyByZXNldCB0aGUgYXJnIGluZGV4IHRvIDAgd2hlbiBnb2luZyB0byB0aGUKKyAqCW5leHQgYml0bWFwIHdvcmQKKyAqCisgKiBEZXNjcmliZXMgdGhlIHJhZGlvdGFwIHBhcnNlciBzdGF0ZS4gRmllbGRzIHByZWZpeGVkIHdpdGggYW4gdW5kZXJzY29yZQorICogbXVzdCBub3QgYmUgdXNlZCBieSB1c2VycyBvZiB0aGUgcGFyc2VyLCBvbmx5IGJ5IHRoZSBwYXJzZXIgaW50ZXJuYWxseS4KICAqLwogCiBzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yIHsKLQlzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2hlYWRlciAqcnRoZWFkZXI7Ci0JaW50IG1heF9sZW5ndGg7Ci0JaW50IHRoaXNfYXJnX2luZGV4OwotCXVuc2lnbmVkIGNoYXIgKnRoaXNfYXJnOworCXN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfaGVhZGVyICpfcnRoZWFkZXI7CisJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9yYWRpb3RhcF92ZW5kb3JfbmFtZXNwYWNlcyAqX3ZuczsKKwljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX25hbWVzcGFjZSAqY3VycmVudF9uYW1lc3BhY2U7CiAKLQlpbnQgYXJnX2luZGV4OwotCXVuc2lnbmVkIGNoYXIgKmFyZzsKLQl1aW50MzJfdCAqbmV4dF9iaXRtYXA7Ci0JdWludDMyX3QgYml0bWFwX3NoaWZ0ZXI7CisJdW5zaWduZWQgY2hhciAqX2FyZywgKl9uZXh0X25zX2RhdGE7CisJdWludDMyX3QgKl9uZXh0X2JpdG1hcDsKKworCXVuc2lnbmVkIGNoYXIgKnRoaXNfYXJnOworI2lmZGVmIFJBRElPVEFQX1NVUFBPUlRfT1ZFUlJJREVTCisJY29uc3Qgc3RydWN0IHJhZGlvdGFwX292ZXJyaWRlICpvdmVycmlkZXM7CisJaW50IG5fb3ZlcnJpZGVzOworI2VuZGlmCisJaW50IHRoaXNfYXJnX2luZGV4OworCWludCB0aGlzX2FyZ19zaXplOworCisJaW50IGlzX3JhZGlvdGFwX25zOworCisJaW50IF9tYXhfbGVuZ3RoOworCWludCBfYXJnX2luZGV4OworCXVpbnQzMl90IF9iaXRtYXBfc2hpZnRlcjsKKwlpbnQgX3Jlc2V0X29uX2V4dDsKIH07CiAKIGV4dGVybiBpbnQgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yX2luaXQoCi0gICBzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yICppdGVyYXRvciwKLSAgIHN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfaGVhZGVyICpyYWRpb3RhcF9oZWFkZXIsCi0gICBpbnQgbWF4X2xlbmd0aCk7CisJc3RydWN0IGllZWU4MDIxMV9yYWRpb3RhcF9pdGVyYXRvciAqaXRlcmF0b3IsCisJc3RydWN0IGllZWU4MDIxMV9yYWRpb3RhcF9oZWFkZXIgKnJhZGlvdGFwX2hlYWRlciwKKwlpbnQgbWF4X2xlbmd0aCwgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9yYWRpb3RhcF92ZW5kb3JfbmFtZXNwYWNlcyAqdm5zKTsKIAogZXh0ZXJuIGludCBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3JfbmV4dCgKLSAgIHN0cnVjdCBpZWVlODAyMTFfcmFkaW90YXBfaXRlcmF0b3IgKml0ZXJhdG9yKTsKKwlzdHJ1Y3QgaWVlZTgwMjExX3JhZGlvdGFwX2l0ZXJhdG9yICppdGVyYXRvcik7CiAKICNlbmRpZiAvKiBfX1JBRElPVEFQX0lURVJfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL3RyYWNlLmMgYi9zcmMvdXRpbHMvdHJhY2UuYwppbmRleCA2Nzk1ZDQxLi42MDQ0ZjVmIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvdHJhY2UuYworKysgYi9zcmMvdXRpbHMvdHJhY2UuYwpAQCAtMTgsMTEgKzE4LDkgQEAKIAogI2lmZGVmIFdQQV9UUkFDRV9CRkQKICNpbmNsdWRlIDxiZmQuaD4KLSNpZmRlZiBfX2xpbnV4X18KLSNpbmNsdWRlIDxkZW1hbmdsZS5oPgotI2Vsc2UgLyogX19saW51eF9fICovCi0jaW5jbHVkZSA8bGliaWJlcnR5L2RlbWFuZ2xlLmg+Ci0jZW5kaWYgLyogX19saW51eF9fICovCisKKyNkZWZpbmUgRE1HTF9QQVJBTVMgICAgICAoMSA8PCAwKQorI2RlZmluZSBETUdMX0FOU0kgICAgICAgICgxIDw8IDEpCiAKIHN0YXRpYyBjaGFyICpwcmdfZm5hbWUgPSBOVUxMOwogc3RhdGljIGJmZCAqY2FjaGVkX2FiZmQgPSBOVUxMOwpAQCAtMTg3LDYgKzE4NSw3IEBACiAJCXdwYV9wcmludGYoTVNHX0lORk8sICIgICAgICVzKCkgJXM6JXUiLAogCQkJICAgbmFtZSwgZmlsZW5hbWUsIGRhdGEubGluZSk7CiAJCWZyZWUoYW5hbWUpOworCQlhbmFtZSA9IE5VTEw7CiAKIAkJZGF0YS5mb3VuZCA9IGJmZF9maW5kX2lubGluZXJfaW5mbyhhYmZkLCAmZGF0YS5maWxlbmFtZSwKIAkJCQkJCSAgICZkYXRhLmZ1bmN0aW9uLCAmZGF0YS5saW5lKTsKZGlmZiAtLWdpdCBhL3NyYy91dGlscy91dGlsc19tb2R1bGVfdGVzdHMuYyBiL3NyYy91dGlscy91dGlsc19tb2R1bGVfdGVzdHMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45YTllYzQwCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3V0aWxzL3V0aWxzX21vZHVsZV90ZXN0cy5jCkBAIC0wLDAgKzEsMjY2IEBACisvKgorICogdXRpbHMgbW9kdWxlIHRlc3RzCisgKiBDb3B5cmlnaHQgKGMpIDIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgInV0aWxzL2JpdGZpZWxkLmgiCisjaW5jbHVkZSAidXRpbHMvZXh0X3Bhc3N3b3JkLmgiCisjaW5jbHVkZSAidXRpbHMvdHJhY2UuaCIKKworCitzdHJ1Y3QgcHJpbnRmX3Rlc3RfZGF0YSB7CisJdTggKmRhdGE7CisJc2l6ZV90IGxlbjsKKwljaGFyICplbmNvZGVkOworfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBwcmludGZfdGVzdF9kYXRhIHByaW50Zl90ZXN0c1tdID0geworCXsgKHU4ICopICJhYmNkZSIsIDUsICJhYmNkZSIgfSwKKwl7ICh1OCAqKSAiYVwwYlxuY1xlZFxyZVx0ZlwiXFwiLCAxMywgImFcXDBiXFxuY1xcZWRcXHJlXFx0ZlxcXCJcXFxcIiB9LAorCXsgKHU4ICopICJceDAwXHgzMVx4MDBceDMyXHgwMFx4MzkiLCA2LCAiXFx4MDAxXFwwMDAyXFwwOSIgfSwKKwl7ICh1OCAqKSAiXG5cblxuIiwgMywgIlxuXDEyXHgwYSIgfSwKKwl7ICh1OCAqKSAiXDMwM1wyNDVcMzAzXDI0NFwzMDNcMjY2XDMwM1wyMDVcMzAzXDIwNFwzMDNcMjI2IiwgMTIsCisJICAiXFx4YzNcXHhhNVx4YzNcXHhhNFxceGMzXFx4YjZcXHhjM1xceDg1XFx4YzNcXHg4NFxceGMzXFx4OTYiIH0sCisJeyAodTggKikgIlwzMDNcMjQ1XDMwM1wyNDRcMzAzXDI2NlwzMDNcMjA1XDMwM1wyMDRcMzAzXDIyNiIsIDEyLAorCSAgIlxcMzAzXFwyNDVcXDMwM1xcMjQ0XFwzMDNcXDI2NlxcMzAzXFwyMDVcXDMwM1xcMjA0XFwzMDNcXDIyNiIgfSwKKwl7ICh1OCAqKSAiXHhlNVx4ZTRceGY2XHhjNVx4YzRceGQ2IiwgNiwKKwkgICJcXHhlNVxceGU0XFx4ZjZcXHhjNVxceGM0XFx4ZDYiIH0sCisJeyBOVUxMLCAwLCBOVUxMIH0KK307CisKKworc3RhdGljIGludCBwcmludGZfZW5jb2RlX2RlY29kZV90ZXN0cyh2b2lkKQoreworCWludCBpOworCXNpemVfdCBiaW5sZW47CisJY2hhciBidWZbMTAwXTsKKwl1OCBiaW5bMTAwXTsKKwlpbnQgZXJyb3JzID0gMDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJwcmludGYgZW5jb2RlL2RlY29kZSB0ZXN0cyIpOworCisJZm9yIChpID0gMDsgcHJpbnRmX3Rlc3RzW2ldLmRhdGE7IGkrKykgeworCQljb25zdCBzdHJ1Y3QgcHJpbnRmX3Rlc3RfZGF0YSAqdGVzdCA9ICZwcmludGZfdGVzdHNbaV07CisJCXByaW50Zl9lbmNvZGUoYnVmLCBzaXplb2YoYnVmKSwgdGVzdC0+ZGF0YSwgdGVzdC0+bGVuKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIiVkOiAtPiBcIiVzXCIiLCBpLCBidWYpOworCisJCWJpbmxlbiA9IHByaW50Zl9kZWNvZGUoYmluLCBzaXplb2YoYmluKSwgYnVmKTsKKwkJaWYgKGJpbmxlbiAhPSB0ZXN0LT5sZW4gfHwKKwkJICAgIG9zX21lbWNtcChiaW4sIHRlc3QtPmRhdGEsIGJpbmxlbikgIT0gMCkgeworCQkJd3BhX2hleGR1bXAoTVNHX0VSUk9SLCAiRXJyb3IgaW4gZGVjb2RpbmcjMSIsCisJCQkJICAgIGJpbiwgYmlubGVuKTsKKwkJCWVycm9ycysrOworCQl9CisKKwkJYmlubGVuID0gcHJpbnRmX2RlY29kZShiaW4sIHNpemVvZihiaW4pLCB0ZXN0LT5lbmNvZGVkKTsKKwkJaWYgKGJpbmxlbiAhPSB0ZXN0LT5sZW4gfHwKKwkJICAgIG9zX21lbWNtcChiaW4sIHRlc3QtPmRhdGEsIGJpbmxlbikgIT0gMCkgeworCQkJd3BhX2hleGR1bXAoTVNHX0VSUk9SLCAiRXJyb3IgaW4gZGVjb2RpbmcjMiIsCisJCQkJICAgIGJpbiwgYmlubGVuKTsKKwkJCWVycm9ycysrOworCQl9CisJfQorCisJYnVmWzVdID0gJ0EnOworCXByaW50Zl9lbmNvZGUoYnVmLCA1LCAoY29uc3QgdTggKikgImFiY2RlIiwgNSk7CisJaWYgKGJ1Zls1XSAhPSAnQScpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJFcnJvciBpbiBib3VuZHMgY2hlY2tpbmcjMSIpOworCQllcnJvcnMrKzsKKwl9CisKKwlmb3IgKGkgPSA1OyBpIDwgMTA7IGkrKykgeworCQlidWZbaV0gPSAnQSc7CisJCXByaW50Zl9lbmNvZGUoYnVmLCBpLCAoY29uc3QgdTggKikgIlx4ZGRceGRkXHhkZFx4ZGRceGRkIiwgNSk7CisJCWlmIChidWZbaV0gIT0gJ0EnKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkVycm9yIGluIGJvdW5kcyBjaGVja2luZyMyKCVkKSIsCisJCQkJICAgaSk7CisJCQllcnJvcnMrKzsKKwkJfQorCX0KKworCWlmIChlcnJvcnMpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICIlZCBwcmludGYgdGVzdChzKSBmYWlsZWQiLCBlcnJvcnMpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBiaXRmaWVsZF90ZXN0cyh2b2lkKQoreworCXN0cnVjdCBiaXRmaWVsZCAqYmY7CisJaW50IGk7CisJaW50IGVycm9ycyA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiYml0ZmllbGQgdGVzdHMiKTsKKworCWJmID0gYml0ZmllbGRfYWxsb2MoMTIzKTsKKwlpZiAoYmYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJZm9yIChpID0gMDsgaSA8IDEyMzsgaSsrKSB7CisJCWlmIChiaXRmaWVsZF9pc19zZXQoYmYsIGkpIHx8IGJpdGZpZWxkX2lzX3NldChiZiwgaSArIDEpKQorCQkJZXJyb3JzKys7CisJCWlmIChpID4gMCAmJiBiaXRmaWVsZF9pc19zZXQoYmYsIGkgLSAxKSkKKwkJCWVycm9ycysrOworCQliaXRmaWVsZF9zZXQoYmYsIGkpOworCQlpZiAoIWJpdGZpZWxkX2lzX3NldChiZiwgaSkpCisJCQllcnJvcnMrKzsKKwkJYml0ZmllbGRfY2xlYXIoYmYsIGkpOworCQlpZiAoYml0ZmllbGRfaXNfc2V0KGJmLCBpKSkKKwkJCWVycm9ycysrOworCX0KKworCWZvciAoaSA9IDEyMzsgaSA8IDIwMDsgaSsrKSB7CisJCWlmIChiaXRmaWVsZF9pc19zZXQoYmYsIGkpIHx8IGJpdGZpZWxkX2lzX3NldChiZiwgaSArIDEpKQorCQkJZXJyb3JzKys7CisJCWlmIChpID4gMCAmJiBiaXRmaWVsZF9pc19zZXQoYmYsIGkgLSAxKSkKKwkJCWVycm9ycysrOworCQliaXRmaWVsZF9zZXQoYmYsIGkpOworCQlpZiAoYml0ZmllbGRfaXNfc2V0KGJmLCBpKSkKKwkJCWVycm9ycysrOworCQliaXRmaWVsZF9jbGVhcihiZiwgaSk7CisJCWlmIChiaXRmaWVsZF9pc19zZXQoYmYsIGkpKQorCQkJZXJyb3JzKys7CisJfQorCisJZm9yIChpID0gMDsgaSA8IDEyMzsgaSsrKSB7CisJCWlmIChiaXRmaWVsZF9pc19zZXQoYmYsIGkpIHx8IGJpdGZpZWxkX2lzX3NldChiZiwgaSArIDEpKQorCQkJZXJyb3JzKys7CisJCWJpdGZpZWxkX3NldChiZiwgaSk7CisJCWlmICghYml0ZmllbGRfaXNfc2V0KGJmLCBpKSkKKwkJCWVycm9ycysrOworCX0KKworCWZvciAoaSA9IDA7IGkgPCAxMjM7IGkrKykgeworCQlpZiAoIWJpdGZpZWxkX2lzX3NldChiZiwgaSkpCisJCQllcnJvcnMrKzsKKwkJYml0ZmllbGRfY2xlYXIoYmYsIGkpOworCQlpZiAoYml0ZmllbGRfaXNfc2V0KGJmLCBpKSkKKwkJCWVycm9ycysrOworCX0KKworCWZvciAoaSA9IDA7IGkgPCAxMjM7IGkrKykgeworCQlpZiAoYml0ZmllbGRfZ2V0X2ZpcnN0X3plcm8oYmYpICE9IGkpCisJCQllcnJvcnMrKzsKKwkJYml0ZmllbGRfc2V0KGJmLCBpKTsKKwl9CisJaWYgKGJpdGZpZWxkX2dldF9maXJzdF96ZXJvKGJmKSAhPSAtMSkKKwkJZXJyb3JzKys7CisJZm9yIChpID0gMDsgaSA8IDEyMzsgaSsrKSB7CisJCWlmICghYml0ZmllbGRfaXNfc2V0KGJmLCBpKSkKKwkJCWVycm9ycysrOworCQliaXRmaWVsZF9jbGVhcihiZiwgaSk7CisJCWlmIChiaXRmaWVsZF9nZXRfZmlyc3RfemVybyhiZikgIT0gaSkKKwkJCWVycm9ycysrOworCQliaXRmaWVsZF9zZXQoYmYsIGkpOworCX0KKwlpZiAoYml0ZmllbGRfZ2V0X2ZpcnN0X3plcm8oYmYpICE9IC0xKQorCQllcnJvcnMrKzsKKworCWJpdGZpZWxkX2ZyZWUoYmYpOworCisJaWYgKGVycm9ycykgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIiVkIGJpdGZpZWxkIHRlc3QocykgZmFpbGVkIiwgZXJyb3JzKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgaW50X2FycmF5X3Rlc3RzKHZvaWQpCit7CisJaW50IHRlc3QxW10gPSB7IDEsIDIsIDMsIDQsIDUsIDYsIDAgfTsKKwlpbnQgdGVzdDJbXSA9IHsgMSwgLTEsIDAgfTsKKwlpbnQgdGVzdDNbXSA9IHsgMSwgMSwgMSwgLTEsIDIsIDMsIDQsIDEsIDIsIDAgfTsKKwlpbnQgdGVzdDNfcmVzW10gPSB7IC0xLCAxLCAyLCAzLCA0LCAwIH07CisJaW50IGVycm9ycyA9IDA7CisJaW50IGxlbjsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJpbnRfYXJyYXkgdGVzdHMiKTsKKworCWlmIChpbnRfYXJyYXlfbGVuKHRlc3QxKSAhPSA2IHx8CisJICAgIGludF9hcnJheV9sZW4odGVzdDIpICE9IDIpCisJCWVycm9ycysrOworCisJaW50X2FycmF5X3NvcnRfdW5pcXVlKHRlc3QzKTsKKwlsZW4gPSBpbnRfYXJyYXlfbGVuKHRlc3QzX3Jlcyk7CisJaWYgKGludF9hcnJheV9sZW4odGVzdDMpICE9IGxlbikKKwkJZXJyb3JzKys7CisJZWxzZSBpZiAob3NfbWVtY21wKHRlc3QzLCB0ZXN0M19yZXMsIGxlbiAqIHNpemVvZihpbnQpKSAhPSAwKQorCQllcnJvcnMrKzsKKworCWlmIChlcnJvcnMpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICIlZCBpbnRfYXJyYXkgdGVzdChzKSBmYWlsZWQiLCBlcnJvcnMpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBleHRfcGFzc3dvcmRfdGVzdHModm9pZCkKK3sKKwlzdHJ1Y3QgZXh0X3Bhc3N3b3JkX2RhdGEgKmRhdGE7CisJaW50IHJldCA9IDA7CisJc3RydWN0IHdwYWJ1ZiAqcHc7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiZXh0X3Bhc3N3b3JkIHRlc3RzIik7CisKKwlkYXRhID0gZXh0X3Bhc3N3b3JkX2luaXQoInVua25vd24iLCAiZm9vIik7CisJaWYgKGRhdGEgIT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJZGF0YSA9IGV4dF9wYXNzd29yZF9pbml0KCJ0ZXN0IiwgTlVMTCk7CisJaWYgKGRhdGEgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXB3ID0gZXh0X3Bhc3N3b3JkX2dldChkYXRhLCAiZm9vIik7CisJaWYgKHB3ICE9IE5VTEwpCisJCXJldCA9IC0xOworCWV4dF9wYXNzd29yZF9mcmVlKHB3KTsKKworCWV4dF9wYXNzd29yZF9kZWluaXQoZGF0YSk7CisKKwlwdyA9IGV4dF9wYXNzd29yZF9nZXQoTlVMTCwgImZvbyIpOworCWlmIChwdyAhPSBOVUxMKQorCQlyZXQgPSAtMTsKKwlleHRfcGFzc3dvcmRfZnJlZShwdyk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgdHJhY2VfdGVzdHModm9pZCkKK3sKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAidHJhY2UgdGVzdHMiKTsKKworCXdwYV90cmFjZV9zaG93KCJ0ZXN0IGJhY2t0cmFjZSIpOworCXdwYV90cmFjZV9kdW1wX2Z1bmNuYW1lKCJ0ZXN0IGZ1bmNuYW1lIiwgdHJhY2VfdGVzdHMpOworCisJcmV0dXJuIDA7Cit9CisKKworaW50IHV0aWxzX21vZHVsZV90ZXN0cyh2b2lkKQoreworCWludCByZXQgPSAwOworCisJd3BhX3ByaW50ZihNU0dfSU5GTywgInV0aWxzIG1vZHVsZSB0ZXN0cyIpOworCisJaWYgKHByaW50Zl9lbmNvZGVfZGVjb2RlX3Rlc3RzKCkgPCAwIHx8CisJICAgIGV4dF9wYXNzd29yZF90ZXN0cygpIDwgMCB8fAorCSAgICB0cmFjZV90ZXN0cygpIDwgMCB8fAorCSAgICBiaXRmaWVsZF90ZXN0cygpIDwgMCB8fAorCSAgICBpbnRfYXJyYXlfdGVzdHMoKSA8IDApCisJCXJldCA9IC0xOworCisJcmV0dXJuIHJldDsKK30KZGlmZiAtLWdpdCBhL3NyYy91dGlscy93cGFfZGVidWcuYyBiL3NyYy91dGlscy93cGFfZGVidWcuYwppbmRleCAzOGVhOGFhLi42OGNiYWNlIDEwMDY0NAotLS0gYS9zcmMvdXRpbHMvd3BhX2RlYnVnLmMKKysrIGIvc3JjL3V0aWxzL3dwYV9kZWJ1Zy5jCkBAIC0zNzUsMTkgKzM3NSwxOSBAQAogI2VuZGlmIC8qIENPTkZJR19BTkRST0lEX0xPRyAqLwogfQogCi12b2lkIHdwYV9oZXhkdW1wKGludCBsZXZlbCwgY29uc3QgY2hhciAqdGl0bGUsIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCit2b2lkIHdwYV9oZXhkdW1wKGludCBsZXZlbCwgY29uc3QgY2hhciAqdGl0bGUsIGNvbnN0IHZvaWQgKmJ1Ziwgc2l6ZV90IGxlbikKIHsKIAlfd3BhX2hleGR1bXAobGV2ZWwsIHRpdGxlLCBidWYsIGxlbiwgMSk7CiB9CiAKIAotdm9pZCB3cGFfaGV4ZHVtcF9rZXkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbikKK3ZvaWQgd3BhX2hleGR1bXBfa2V5KGludCBsZXZlbCwgY29uc3QgY2hhciAqdGl0bGUsIGNvbnN0IHZvaWQgKmJ1Ziwgc2l6ZV90IGxlbikKIHsKIAlfd3BhX2hleGR1bXAobGV2ZWwsIHRpdGxlLCBidWYsIGxlbiwgd3BhX2RlYnVnX3Nob3dfa2V5cyk7CiB9CiAKIAotc3RhdGljIHZvaWQgX3dwYV9oZXhkdW1wX2FzY2lpKGludCBsZXZlbCwgY29uc3QgY2hhciAqdGl0bGUsIGNvbnN0IHU4ICpidWYsCitzdGF0aWMgdm9pZCBfd3BhX2hleGR1bXBfYXNjaWkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3Qgdm9pZCAqYnVmLAogCQkJICAgICAgIHNpemVfdCBsZW4sIGludCBzaG93KQogewogCXNpemVfdCBpLCBsbGVuOwpAQCAtNDA3LDcgKzQwNyw3IEBACiAJCQkvKiBjYW4gZG8gYXNjaWkgcHJvY2Vzc2luZyBpbiB1c2Vyc3BhY2UgKi8KIAkJCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykKIAkJCQlmcHJpbnRmKHdwYV9kZWJ1Z190cmFjaW5nX2ZpbGUsCi0JCQkJCSIgJTAyeCIsIGJ1ZltpXSk7CisJCQkJCSIgJTAyeCIsIHBvc1tpXSk7CiAJCX0KIAkJZmZsdXNoKHdwYV9kZWJ1Z190cmFjaW5nX2ZpbGUpOwogCX0KQEAgLTQ5NSwxMyArNDk1LDE0IEBACiB9CiAKIAotdm9pZCB3cGFfaGV4ZHVtcF9hc2NpaShpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKnRpdGxlLCBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKQordm9pZCB3cGFfaGV4ZHVtcF9hc2NpaShpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKnRpdGxlLCBjb25zdCB2b2lkICpidWYsCisJCSAgICAgICBzaXplX3QgbGVuKQogewogCV93cGFfaGV4ZHVtcF9hc2NpaShsZXZlbCwgdGl0bGUsIGJ1ZiwgbGVuLCAxKTsKIH0KIAogCi12b2lkIHdwYV9oZXhkdW1wX2FzY2lpX2tleShpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKnRpdGxlLCBjb25zdCB1OCAqYnVmLAordm9pZCB3cGFfaGV4ZHVtcF9hc2NpaV9rZXkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3Qgdm9pZCAqYnVmLAogCQkJICAgc2l6ZV90IGxlbikKIHsKIAlfd3BhX2hleGR1bXBfYXNjaWkobGV2ZWwsIHRpdGxlLCBidWYsIGxlbiwgd3BhX2RlYnVnX3Nob3dfa2V5cyk7CkBAIC01OTUsMTAgKzU5NiwxNCBAQAogewogCXZhX2xpc3QgYXA7CiAJY2hhciAqYnVmOwotCWNvbnN0IGludCBidWZsZW4gPSAyMDQ4OworCWludCBidWZsZW47CiAJaW50IGxlbjsKIAljaGFyIHByZWZpeFsxMzBdOwogCisJdmFfc3RhcnQoYXAsIGZtdCk7CisJYnVmbGVuID0gdnNucHJpbnRmKE5VTEwsIDAsIGZtdCwgYXApICsgMTsKKwl2YV9lbmQoYXApOworCiAJYnVmID0gb3NfbWFsbG9jKGJ1Zmxlbik7CiAJaWYgKGJ1ZiA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAid3BhX21zZzogRmFpbGVkIHRvIGFsbG9jYXRlIG1lc3NhZ2UgIgpAQCAtNjI5LDEyICs2MzQsMTYgQEAKIHsKIAl2YV9saXN0IGFwOwogCWNoYXIgKmJ1ZjsKLQljb25zdCBpbnQgYnVmbGVuID0gMjA0ODsKKwlpbnQgYnVmbGVuOwogCWludCBsZW47CiAKIAlpZiAoIXdwYV9tc2dfY2IpCiAJCXJldHVybjsKIAorCXZhX3N0YXJ0KGFwLCBmbXQpOworCWJ1ZmxlbiA9IHZzbnByaW50ZihOVUxMLCAwLCBmbXQsIGFwKSArIDE7CisJdmFfZW5kKGFwKTsKKwogCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOwogCWlmIChidWYgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIndwYV9tc2dfY3RybDogRmFpbGVkIHRvIGFsbG9jYXRlICIKQEAgLTY1Myw5ICs2NjIsMTMgQEAKIHsKIAl2YV9saXN0IGFwOwogCWNoYXIgKmJ1ZjsKLQljb25zdCBpbnQgYnVmbGVuID0gMjA0ODsKKwlpbnQgYnVmbGVuOwogCWludCBsZW47CiAKKwl2YV9zdGFydChhcCwgZm10KTsKKwlidWZsZW4gPSB2c25wcmludGYoTlVMTCwgMCwgZm10LCBhcCkgKyAxOworCXZhX2VuZChhcCk7CisKIAlidWYgPSBvc19tYWxsb2MoYnVmbGVuKTsKIAlpZiAoYnVmID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJ3cGFfbXNnX2dsb2JhbDogRmFpbGVkIHRvIGFsbG9jYXRlICIKQEAgLTY3MiwxMyArNjg1LDQ1IEBACiB9CiAKIAordm9pZCB3cGFfbXNnX2dsb2JhbF9jdHJsKHZvaWQgKmN0eCwgaW50IGxldmVsLCBjb25zdCBjaGFyICpmbXQsIC4uLikKK3sKKwl2YV9saXN0IGFwOworCWNoYXIgKmJ1ZjsKKwlpbnQgYnVmbGVuOworCWludCBsZW47CisKKwlpZiAoIXdwYV9tc2dfY2IpCisJCXJldHVybjsKKworCXZhX3N0YXJ0KGFwLCBmbXQpOworCWJ1ZmxlbiA9IHZzbnByaW50ZihOVUxMLCAwLCBmbXQsIGFwKSArIDE7CisJdmFfZW5kKGFwKTsKKworCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOworCWlmIChidWYgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwKKwkJCSAgICJ3cGFfbXNnX2dsb2JhbF9jdHJsOiBGYWlsZWQgdG8gYWxsb2NhdGUgbWVzc2FnZSBidWZmZXIiKTsKKwkJcmV0dXJuOworCX0KKwl2YV9zdGFydChhcCwgZm10KTsKKwlsZW4gPSB2c25wcmludGYoYnVmLCBidWZsZW4sIGZtdCwgYXApOworCXZhX2VuZChhcCk7CisJd3BhX21zZ19jYihjdHgsIGxldmVsLCAxLCBidWYsIGxlbik7CisJb3NfZnJlZShidWYpOworfQorCisKIHZvaWQgd3BhX21zZ19ub19nbG9iYWwodm9pZCAqY3R4LCBpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQogewogCXZhX2xpc3QgYXA7CiAJY2hhciAqYnVmOwotCWNvbnN0IGludCBidWZsZW4gPSAyMDQ4OworCWludCBidWZsZW47CiAJaW50IGxlbjsKIAorCXZhX3N0YXJ0KGFwLCBmbXQpOworCWJ1ZmxlbiA9IHZzbnByaW50ZihOVUxMLCAwLCBmbXQsIGFwKSArIDE7CisJdmFfZW5kKGFwKTsKKwogCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOwogCWlmIChidWYgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIndwYV9tc2dfbm9fZ2xvYmFsOiBGYWlsZWQgdG8gYWxsb2NhdGUgIgpAQCAtNzExLDkgKzc1NiwxMyBAQAogewogCXZhX2xpc3QgYXA7CiAJY2hhciAqYnVmOwotCWNvbnN0IGludCBidWZsZW4gPSAyMDQ4OworCWludCBidWZsZW47CiAJaW50IGxlbjsKIAorCXZhX3N0YXJ0KGFwLCBmbXQpOworCWJ1ZmxlbiA9IHZzbnByaW50ZihOVUxMLCAwLCBmbXQsIGFwKSArIDE7CisJdmFfZW5kKGFwKTsKKwogCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOwogCWlmIChidWYgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImhvc3RhcGRfbG9nZ2VyOiBGYWlsZWQgdG8gYWxsb2NhdGUgIgpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL3dwYV9kZWJ1Zy5oIGIvc3JjL3V0aWxzL3dwYV9kZWJ1Zy5oCmluZGV4IDJlZDFiZDguLjM5MWYxOTcgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy93cGFfZGVidWcuaAorKysgYi9zcmMvdXRpbHMvd3BhX2RlYnVnLmgKQEAgLTExLDYgKzExLDEwIEBACiAKICNpbmNsdWRlICJ3cGFidWYuaCIKIAorZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7CitleHRlcm4gaW50IHdwYV9kZWJ1Z19zaG93X2tleXM7CitleHRlcm4gaW50IHdwYV9kZWJ1Z190aW1lc3RhbXA7CisKIC8qIERlYnVnZ2luZyBmdW5jdGlvbiAtIGNvbmRpdGlvbmFsIHByaW50ZiBhbmQgaGV4IGR1bXAuIERyaXZlciB3cmFwcGVycyBjYW4KICAqIHVzZSB0aGVzZSBmb3IgZGVidWdnaW5nIHB1cnBvc2VzLiAqLwogCkBAIC03Nyw3ICs4MSw3IEBACiAgKiBvdXRwdXQgbWF5IGJlIGRpcmVjdGVkIHRvIHN0ZG91dCwgc3RkZXJyLCBhbmQvb3Igc3lzbG9nIGJhc2VkIG9uCiAgKiBjb25maWd1cmF0aW9uLiBUaGUgY29udGVudHMgb2YgYnVmIGlzIHByaW50ZWQgb3V0IGhhcyBoZXggZHVtcC4KICAqLwotdm9pZCB3cGFfaGV4ZHVtcChpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKnRpdGxlLCBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKTsKK3ZvaWQgd3BhX2hleGR1bXAoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3Qgdm9pZCAqYnVmLCBzaXplX3QgbGVuKTsKIAogc3RhdGljIGlubGluZSB2b2lkIHdwYV9oZXhkdW1wX2J1ZihpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKnRpdGxlLAogCQkJCSAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmJ1ZikKQEAgLTk5LDcgKzEwMyw3IEBACiAgKiBsaWtlIHdwYV9oZXhkdW1wKCksIGJ1dCBieSBkZWZhdWx0LCBkb2VzIG5vdCBpbmNsdWRlIHNlY3JldCBrZXlzIChwYXNzd29yZHMsCiAgKiBldGMuKSBpbiBkZWJ1ZyBvdXRwdXQuCiAgKi8KLXZvaWQgd3BhX2hleGR1bXBfa2V5KGludCBsZXZlbCwgY29uc3QgY2hhciAqdGl0bGUsIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pOwordm9pZCB3cGFfaGV4ZHVtcF9rZXkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3Qgdm9pZCAqYnVmLCBzaXplX3QgbGVuKTsKIAogc3RhdGljIGlubGluZSB2b2lkIHdwYV9oZXhkdW1wX2J1Zl9rZXkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwKIAkJCQkgICAgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYnVmKQpAQCAtMTIxLDcgKzEyNSw3IEBACiAgKiB0aGUgaGV4IG51bWJlcnMgYW5kIEFTQ0lJIGNoYXJhY3RlcnMgKGZvciBwcmludGFibGUgcmFuZ2UpIGFyZSBzaG93bi4gMTYKICAqIGJ5dGVzIHBlciBsaW5lIHdpbGwgYmUgc2hvd24uCiAgKi8KLXZvaWQgd3BhX2hleGR1bXBfYXNjaWkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3QgdTggKmJ1ZiwKK3ZvaWQgd3BhX2hleGR1bXBfYXNjaWkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3Qgdm9pZCAqYnVmLAogCQkgICAgICAgc2l6ZV90IGxlbik7CiAKIC8qKgpAQCAtMTM4LDcgKzE0Miw3IEBACiAgKiBieXRlcyBwZXIgbGluZSB3aWxsIGJlIHNob3duLiBUaGlzIHdvcmtzIGxpa2Ugd3BhX2hleGR1bXBfYXNjaWkoKSwgYnV0IGJ5CiAgKiBkZWZhdWx0LCBkb2VzIG5vdCBpbmNsdWRlIHNlY3JldCBrZXlzIChwYXNzd29yZHMsIGV0Yy4pIGluIGRlYnVnIG91dHB1dC4KICAqLwotdm9pZCB3cGFfaGV4ZHVtcF9hc2NpaV9rZXkoaW50IGxldmVsLCBjb25zdCBjaGFyICp0aXRsZSwgY29uc3QgdTggKmJ1ZiwKK3ZvaWQgd3BhX2hleGR1bXBfYXNjaWlfa2V5KGludCBsZXZlbCwgY29uc3QgY2hhciAqdGl0bGUsIGNvbnN0IHZvaWQgKmJ1ZiwKIAkJCSAgIHNpemVfdCBsZW4pOwogCiAvKgpAQCAtMTU2LDYgKzE2MCw3IEBACiAjZGVmaW5lIHdwYV9tc2coYXJncy4uLikgZG8geyB9IHdoaWxlICgwKQogI2RlZmluZSB3cGFfbXNnX2N0cmwoYXJncy4uLikgZG8geyB9IHdoaWxlICgwKQogI2RlZmluZSB3cGFfbXNnX2dsb2JhbChhcmdzLi4uKSBkbyB7IH0gd2hpbGUgKDApCisjZGVmaW5lIHdwYV9tc2dfZ2xvYmFsX2N0cmwoYXJncy4uLikgZG8geyB9IHdoaWxlICgwKQogI2RlZmluZSB3cGFfbXNnX25vX2dsb2JhbChhcmdzLi4uKSBkbyB7IH0gd2hpbGUgKDApCiAjZGVmaW5lIHdwYV9tc2dfcmVnaXN0ZXJfY2IoZikgZG8geyB9IHdoaWxlICgwKQogI2RlZmluZSB3cGFfbXNnX3JlZ2lzdGVyX2lmbmFtZV9jYihmKSBkbyB7IH0gd2hpbGUgKDApCkBAIC0yMDgsNiArMjEzLDIxIEBACiBQUklOVEZfRk9STUFUKDMsIDQpOwogCiAvKioKKyAqIHdwYV9tc2dfZ2xvYmFsX2N0cmwgLSBDb25kaXRpb25hbCBnbG9iYWwgcHJpbnRmIGZvciBjdHJsX2lmYWNlIG1vbml0b3JzCisgKiBAY3R4OiBQb2ludGVyIHRvIGNvbnRleHQgZGF0YTsgdGhpcyBpcyB0aGUgY3R4IHZhcmlhYmxlIHJlZ2lzdGVyZWQKKyAqCXdpdGggc3RydWN0IHdwYV9kcml2ZXJfb3BzOjppbml0KCkKKyAqIEBsZXZlbDogcHJpb3JpdHkgbGV2ZWwgKE1TR18qKSBvZiB0aGUgbWVzc2FnZQorICogQGZtdDogcHJpbnRmIGZvcm1hdCBzdHJpbmcsIGZvbGxvd2VkIGJ5IG9wdGlvbmFsIGFyZ3VtZW50cworICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byBwcmludCBjb25kaXRpb25hbCBkZWJ1Z2dpbmcgYW5kIGVycm9yIG1lc3NhZ2VzLgorICogVGhpcyBmdW5jdGlvbiBpcyBsaWtlIHdwYV9tc2dfZ2xvYmFsKCksIGJ1dCBpdCBzZW5kcyB0aGUgb3V0cHV0IG9ubHkgdG8gdGhlCisgKiBhdHRhY2hlZCBnbG9iYWwgY3RybF9pZmFjZSBtb25pdG9ycy4gSW4gb3RoZXIgd29yZHMsIGl0IGNhbiBiZSB1c2VkIGZvcgorICogZnJlcXVlbnQgZXZlbnRzIHRoYXQgZG8gbm90IG5lZWQgdG8gYmUgc2VudCB0byBzeXNsb2cuCisgKi8KK3ZvaWQgd3BhX21zZ19nbG9iYWxfY3RybCh2b2lkICpjdHgsIGludCBsZXZlbCwgY29uc3QgY2hhciAqZm10LCAuLi4pCitQUklOVEZfRk9STUFUKDMsIDQpOworCisvKioKICAqIHdwYV9tc2dfbm9fZ2xvYmFsIC0gQ29uZGl0aW9uYWwgcHJpbnRmIGZvciBjdHJsX2lmYWNlIG1vbml0b3JzCiAgKiBAY3R4OiBQb2ludGVyIHRvIGNvbnRleHQgZGF0YTsgdGhpcyBpcyB0aGUgY3R4IHZhcmlhYmxlIHJlZ2lzdGVyZWQKICAqCXdpdGggc3RydWN0IHdwYV9kcml2ZXJfb3BzOjppbml0KCkKZGlmZiAtLWdpdCBhL3NyYy91dGlscy94bWwtdXRpbHMuYyBiL3NyYy91dGlscy94bWwtdXRpbHMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40OTE2ZDI5Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3V0aWxzL3htbC11dGlscy5jCkBAIC0wLDAgKzEsNDcxIEBACisvKgorICogR2VuZXJpYyBYTUwgaGVscGVyIGZ1bmN0aW9ucworICogQ29weXJpZ2h0IChjKSAyMDEyLTIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAieG1sLXV0aWxzLmgiCisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBnZXRfbm9kZV91cmlfaXRlcihzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICAgICAgeG1sX25vZGVfdCAqcm9vdCwgY2hhciAqdXJpKQoreworCWNoYXIgKmVuZDsKKwl4bWxfbm9kZV90ICpub2RlOworCWNvbnN0IGNoYXIgKm5hbWU7CisKKwllbmQgPSBzdHJjaHIodXJpLCAnLycpOworCWlmIChlbmQpCisJCSplbmQrKyA9ICdcMCc7CisKKwlub2RlID0gcm9vdDsKKwl4bWxfbm9kZV9mb3JfZWFjaF9zaWJsaW5nKGN0eCwgbm9kZSkgeworCQl4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgsIG5vZGUpOworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgsIG5vZGUpOworCQlpZiAoc3RyY2FzZWNtcChuYW1lLCB1cmkpID09IDApCisJCQlicmVhazsKKwl9CisKKwlpZiAobm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChlbmQpIHsKKwkJcmV0dXJuIGdldF9ub2RlX3VyaV9pdGVyKGN0eCwgeG1sX25vZGVfZmlyc3RfY2hpbGQoY3R4LCBub2RlKSwKKwkJCQkJIGVuZCk7CisJfQorCisJcmV0dXJuIG5vZGU7Cit9CisKKworeG1sX25vZGVfdCAqIGdldF9ub2RlX3VyaShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKnJvb3QsCisJCQkgIGNvbnN0IGNoYXIgKnVyaSkKK3sKKwljaGFyICpzZWFyY2g7CisJeG1sX25vZGVfdCAqbm9kZTsKKworCXNlYXJjaCA9IG9zX3N0cmR1cCh1cmkpOworCWlmIChzZWFyY2ggPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlub2RlID0gZ2V0X25vZGVfdXJpX2l0ZXIoY3R4LCByb290LCBzZWFyY2gpOworCisJb3NfZnJlZShzZWFyY2gpOworCXJldHVybiBub2RlOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogZ2V0X25vZGVfaXRlcihzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICB4bWxfbm9kZV90ICpyb290LCBjb25zdCBjaGFyICpwYXRoKQoreworCWNoYXIgKmVuZDsKKwl4bWxfbm9kZV90ICpub2RlOworCWNvbnN0IGNoYXIgKm5hbWU7CisKKwllbmQgPSBvc19zdHJjaHIocGF0aCwgJy8nKTsKKwlpZiAoZW5kKQorCQkqZW5kKysgPSAnXDAnOworCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LCBub2RlLCByb290KSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eCwgbm9kZSk7CisJCW5hbWUgPSB4bWxfbm9kZV9nZXRfbG9jYWxuYW1lKGN0eCwgbm9kZSk7CisJCWlmIChvc19zdHJjYXNlY21wKG5hbWUsIHBhdGgpID09IDApCisJCQlicmVhazsKKwl9CisKKwlpZiAobm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlpZiAoZW5kKQorCQlyZXR1cm4gZ2V0X25vZGVfaXRlcihjdHgsIG5vZGUsIGVuZCk7CisJcmV0dXJuIG5vZGU7Cit9CisKKworeG1sX25vZGVfdCAqIGdldF9ub2RlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqcm9vdCwKKwkJICAgICAgY29uc3QgY2hhciAqcGF0aCkKK3sKKwljaGFyICpzZWFyY2g7CisJeG1sX25vZGVfdCAqbm9kZTsKKworCXNlYXJjaCA9IG9zX3N0cmR1cChwYXRoKTsKKwlpZiAoc2VhcmNoID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJbm9kZSA9IGdldF9ub2RlX2l0ZXIoY3R4LCByb290LCBzZWFyY2gpOworCisJb3NfZnJlZShzZWFyY2gpOworCXJldHVybiBub2RlOworfQorCisKK3htbF9ub2RlX3QgKiBnZXRfY2hpbGRfbm9kZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKnJvb3QsCisJCQkgICAgY29uc3QgY2hhciAqcGF0aCkKK3sKKwl4bWxfbm9kZV90ICpub2RlOworCXhtbF9ub2RlX3QgKm1hdGNoOworCisJeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LCBub2RlLCByb290KSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eCwgbm9kZSk7CisJCW1hdGNoID0gZ2V0X25vZGUoY3R4LCBub2RlLCBwYXRoKTsKKwkJaWYgKG1hdGNoKQorCQkJcmV0dXJuIG1hdGNoOworCX0KKworCXJldHVybiBOVUxMOworfQorCisKK3htbF9ub2RlX3QgKiBub2RlX2Zyb21fZmlsZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIGNvbnN0IGNoYXIgKm5hbWUpCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKwljaGFyICpidWYsICpidWYyLCAqc3RhcnQ7CisJc2l6ZV90IGxlbjsKKworCWJ1ZiA9IG9zX3JlYWRmaWxlKG5hbWUsICZsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJYnVmMiA9IG9zX3JlYWxsb2MoYnVmLCBsZW4gKyAxKTsKKwlpZiAoYnVmMiA9PSBOVUxMKSB7CisJCW9zX2ZyZWUoYnVmKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCWJ1ZiA9IGJ1ZjI7CisJYnVmW2xlbl0gPSAnXDAnOworCisJc3RhcnQgPSBvc19zdHJzdHIoYnVmLCAiPCFET0NUWVBFICIpOworCWlmIChzdGFydCkgeworCQljaGFyICpwb3MgPSBzdGFydCArIDE7CisJCWludCBjb3VudCA9IDE7CisJCXdoaWxlICgqcG9zKSB7CisJCQlpZiAoKnBvcyA9PSAnPCcpCisJCQkJY291bnQrKzsKKwkJCWVsc2UgaWYgKCpwb3MgPT0gJz4nKSB7CisJCQkJY291bnQtLTsKKwkJCQlpZiAoY291bnQgPT0gMCkgeworCQkJCQlwb3MrKzsKKwkJCQkJYnJlYWs7CisJCQkJfQorCQkJfQorCQkJcG9zKys7CisJCX0KKwkJaWYgKGNvdW50ID09IDApIHsKKwkJCS8qIFJlbW92ZSBET0NUWVBFIHRvIGFsbG93IHRoZSBmaWxlIHRvIGJlIHBhcnNlZCAqLworCQkJb3NfbWVtc2V0KHN0YXJ0LCAnICcsIHBvcyAtIHN0YXJ0KTsKKwkJfQorCX0KKworCW5vZGUgPSB4bWxfbm9kZV9mcm9tX2J1ZihjdHgsIGJ1Zik7CisJb3NfZnJlZShidWYpOworCisJcmV0dXJuIG5vZGU7Cit9CisKKworaW50IG5vZGVfdG9fZmlsZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIGNvbnN0IGNoYXIgKmZuYW1lLCB4bWxfbm9kZV90ICpub2RlKQoreworCUZJTEUgKmY7CisJY2hhciAqc3RyOworCisJc3RyID0geG1sX25vZGVfdG9fc3RyKGN0eCwgbm9kZSk7CisJaWYgKHN0ciA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlmID0gZm9wZW4oZm5hbWUsICJ3Iik7CisJaWYgKCFmKSB7CisJCW9zX2ZyZWUoc3RyKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWZwcmludGYoZiwgIiVzXG4iLCBzdHIpOworCW9zX2ZyZWUoc3RyKTsKKwlmY2xvc2UoZik7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgY2hhciAqIGdldF92YWwoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKQoreworCWNoYXIgKnZhbCwgKnBvczsKKworCXZhbCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eCwgbm9kZSk7CisJaWYgKHZhbCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlwb3MgPSB2YWw7CisJd2hpbGUgKCpwb3MpIHsKKwkJaWYgKCpwb3MgIT0gJyAnICYmICpwb3MgIT0gJ1x0JyAmJiAqcG9zICE9ICdccicgJiYgKnBvcyAhPSAnXG4nKQorCQkJcmV0dXJuIHZhbDsKKwkJcG9zKys7CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKKworc3RhdGljIGNoYXIgKiBhZGRfcGF0aChjb25zdCBjaGFyICpwcmV2LCBjb25zdCBjaGFyICpsZWFmKQoreworCXNpemVfdCBsZW47CisJY2hhciAqbmV3X3VyaTsKKworCWlmIChwcmV2ID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJbGVuID0gb3Nfc3RybGVuKHByZXYpICsgMSArIG9zX3N0cmxlbihsZWFmKSArIDE7CisJbmV3X3VyaSA9IG9zX21hbGxvYyhsZW4pOworCWlmIChuZXdfdXJpKQorCQlvc19zbnByaW50ZihuZXdfdXJpLCBsZW4sICIlcy8lcyIsIHByZXYsIGxlYWYpOworCisJcmV0dXJuIG5ld191cmk7Cit9CisKKworc3RhdGljIHZvaWQgbm9kZV90b190bmRzKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqb3V0LAorCQkJIHhtbF9ub2RlX3QgKmluLCBjb25zdCBjaGFyICp1cmkpCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKwl4bWxfbm9kZV90ICp0bmRzOworCWNvbnN0IGNoYXIgKm5hbWU7CisJY2hhciAqdmFsOworCWNoYXIgKm5ld191cmk7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgsIG5vZGUsIGluKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eCwgbm9kZSk7CisJCW5hbWUgPSB4bWxfbm9kZV9nZXRfbG9jYWxuYW1lKGN0eCwgbm9kZSk7CisKKwkJdG5kcyA9IHhtbF9ub2RlX2NyZWF0ZShjdHgsIG91dCwgTlVMTCwgIk5vZGUiKTsKKwkJaWYgKHRuZHMgPT0gTlVMTCkKKwkJCXJldHVybjsKKwkJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LCB0bmRzLCBOVUxMLCAiTm9kZU5hbWUiLCBuYW1lKTsKKworCQlpZiAodXJpKQorCQkJeG1sX25vZGVfY3JlYXRlX3RleHQoY3R4LCB0bmRzLCBOVUxMLCAiUGF0aCIsIHVyaSk7CisKKwkJdmFsID0gZ2V0X3ZhbChjdHgsIG5vZGUpOworCQlpZiAodmFsKSB7CisJCQl4bWxfbm9kZV9jcmVhdGVfdGV4dChjdHgsIHRuZHMsIE5VTEwsICJWYWx1ZSIsIHZhbCk7CisJCQl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eCwgdmFsKTsKKwkJfQorCisJCW5ld191cmkgPSBhZGRfcGF0aCh1cmksIG5hbWUpOworCQlub2RlX3RvX3RuZHMoY3R4LCBuZXdfdXJpID8gb3V0IDogdG5kcywgbm9kZSwgbmV3X3VyaSk7CisJCW9zX2ZyZWUobmV3X3VyaSk7CisJfQorfQorCisKK3N0YXRpYyBpbnQgYWRkX2RkZm5hbWUoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpwYXJlbnQsCisJCSAgICAgICBjb25zdCBjaGFyICp1cm4pCit7CisJeG1sX25vZGVfdCAqbm9kZTsKKworCW5vZGUgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LCBwYXJlbnQsIE5VTEwsICJSVFByb3BlcnRpZXMiKTsKKwlpZiAobm9kZSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZShjdHgsIG5vZGUsIE5VTEwsICJUeXBlIik7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eCwgbm9kZSwgTlVMTCwgIkRERk5hbWUiLCB1cm4pOworCXJldHVybiAwOworfQorCisKK3htbF9ub2RlX3QgKiBtb190b190bmRzKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbW8sCisJCQlpbnQgdXNlX3BhdGgsIGNvbnN0IGNoYXIgKnVybiwgY29uc3QgY2hhciAqbnNfdXJpKQoreworCXhtbF9ub2RlX3QgKnJvb3Q7CisJeG1sX25vZGVfdCAqbm9kZTsKKwljb25zdCBjaGFyICpuYW1lOworCisJcm9vdCA9IHhtbF9ub2RlX2NyZWF0ZV9yb290KGN0eCwgbnNfdXJpLCBOVUxMLCBOVUxMLCAiTWdtdFRyZWUiKTsKKwlpZiAocm9vdCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eCwgcm9vdCwgTlVMTCwgIlZlckRURCIsICIxLjIiKTsKKworCW5hbWUgPSB4bWxfbm9kZV9nZXRfbG9jYWxuYW1lKGN0eCwgbW8pOworCisJbm9kZSA9IHhtbF9ub2RlX2NyZWF0ZShjdHgsIHJvb3QsIE5VTEwsICJOb2RlIik7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJZ290byBmYWlsOworCXhtbF9ub2RlX2NyZWF0ZV90ZXh0KGN0eCwgbm9kZSwgTlVMTCwgIk5vZGVOYW1lIiwgbmFtZSk7CisJaWYgKHVybikKKwkJYWRkX2RkZm5hbWUoY3R4LCBub2RlLCB1cm4pOworCisJbm9kZV90b190bmRzKGN0eCwgdXNlX3BhdGggPyByb290IDogbm9kZSwgbW8sIHVzZV9wYXRoID8gbmFtZSA6IE5VTEwpOworCisJcmV0dXJuIHJvb3Q7CisKK2ZhaWw6CisJeG1sX25vZGVfZnJlZShjdHgsIHJvb3QpOworCXJldHVybiBOVUxMOworfQorCisKK3N0YXRpYyB4bWxfbm9kZV90ICogZ2V0X2ZpcnN0X2NoaWxkX25vZGUoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LAorCQkJCQkgeG1sX25vZGVfdCAqbm9kZSwKKwkJCQkJIGNvbnN0IGNoYXIgKm5hbWUpCit7CisJY29uc3QgY2hhciAqbG5hbWU7CisJeG1sX25vZGVfdCAqY2hpbGQ7CisKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgsIGNoaWxkLCBub2RlKSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eCwgY2hpbGQpOworCQlsbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LCBjaGlsZCk7CisJCWlmIChvc19zdHJjYXNlY21wKGxuYW1lLCBuYW1lKSA9PSAwKQorCQkJcmV0dXJuIGNoaWxkOworCX0KKworCXJldHVybiBOVUxMOworfQorCisKK3N0YXRpYyBjaGFyICogZ2V0X25vZGVfdGV4dChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCQkgICAgY29uc3QgY2hhciAqbm9kZV9uYW1lKQoreworCW5vZGUgPSBnZXRfZmlyc3RfY2hpbGRfbm9kZShjdHgsIG5vZGUsIG5vZGVfbmFtZSk7CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJcmV0dXJuIHhtbF9ub2RlX2dldF90ZXh0KGN0eCwgbm9kZSk7Cit9CisKKworc3RhdGljIHhtbF9ub2RlX3QgKiBhZGRfbW9fbm9kZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKnJvb3QsCisJCQkJeG1sX25vZGVfdCAqbm9kZSwgY29uc3QgY2hhciAqdXJpKQoreworCWNoYXIgKm5vZGVuYW1lLCAqdmFsdWUsICpwYXRoOworCXhtbF9ub2RlX3QgKnBhcmVudDsKKworCW5vZGVuYW1lID0gZ2V0X25vZGVfdGV4dChjdHgsIG5vZGUsICJOb2RlTmFtZSIpOworCWlmIChub2RlbmFtZSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwl2YWx1ZSA9IGdldF9ub2RlX3RleHQoY3R4LCBub2RlLCAiVmFsdWUiKTsKKworCWlmIChyb290ID09IE5VTEwpIHsKKwkJcm9vdCA9IHhtbF9ub2RlX2NyZWF0ZV9yb290KGN0eCwgTlVMTCwgTlVMTCwgTlVMTCwKKwkJCQkJICAgIG5vZGVuYW1lKTsKKwkJaWYgKHJvb3QgJiYgdmFsdWUpCisJCQl4bWxfbm9kZV9zZXRfdGV4dChjdHgsIHJvb3QsIHZhbHVlKTsKKwl9IGVsc2UgeworCQlpZiAodXJpID09IE5VTEwpIHsKKwkJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LCBub2RlbmFtZSk7CisJCQl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eCwgdmFsdWUpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwkJcGF0aCA9IGdldF9ub2RlX3RleHQoY3R4LCBub2RlLCAiUGF0aCIpOworCQlpZiAocGF0aCkKKwkJCXVyaSA9IHBhdGg7CisJCXBhcmVudCA9IGdldF9ub2RlX3VyaShjdHgsIHJvb3QsIHVyaSk7CisJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LCBwYXRoKTsKKwkJaWYgKHBhcmVudCA9PSBOVUxMKSB7CisJCQlwcmludGYoIkNvdWxkIG5vdCBmaW5kIFVSSSAnJXMnXG4iLCB1cmkpOworCQkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgsIG5vZGVuYW1lKTsKKwkJCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LCB2YWx1ZSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlpZiAodmFsdWUpCisJCQl4bWxfbm9kZV9jcmVhdGVfdGV4dChjdHgsIHBhcmVudCwgTlVMTCwgbm9kZW5hbWUsCisJCQkJCSAgICAgdmFsdWUpOworCQllbHNlCisJCQl4bWxfbm9kZV9jcmVhdGUoY3R4LCBwYXJlbnQsIE5VTEwsIG5vZGVuYW1lKTsKKwl9CisKKwl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eCwgbm9kZW5hbWUpOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LCB2YWx1ZSk7CisKKwlyZXR1cm4gcm9vdDsKK30KKworCitzdGF0aWMgeG1sX25vZGVfdCAqIHRuZHNfdG9fbW9faXRlcihzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKnJvb3QsCisJCQkJICAgIHhtbF9ub2RlX3QgKm5vZGUsIGNvbnN0IGNoYXIgKnVyaSkKK3sKKwl4bWxfbm9kZV90ICpjaGlsZDsKKwljb25zdCBjaGFyICpuYW1lOworCWNoYXIgKm5vZGVuYW1lOworCisJeG1sX25vZGVfZm9yX2VhY2hfc2libGluZyhjdHgsIG5vZGUpIHsKKwkJeG1sX25vZGVfZm9yX2VhY2hfY2hlY2soY3R4LCBub2RlKTsKKworCQlub2RlbmFtZSA9IGdldF9ub2RlX3RleHQoY3R4LCBub2RlLCAiTm9kZU5hbWUiKTsKKwkJaWYgKG5vZGVuYW1lID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKworCQluYW1lID0geG1sX25vZGVfZ2V0X2xvY2FsbmFtZShjdHgsIG5vZGUpOworCQlpZiAoc3RyY21wKG5hbWUsICJOb2RlIikgPT0gMCkgeworCQkJaWYgKHJvb3QgJiYgIXVyaSkgeworCQkJCXByaW50ZigiSW52YWxpZCBUTkRTIHRyZWUgc3RydWN0dXJlIC0gIgorCQkJCSAgICAgICAibXVsdGlwbGUgdG9wIGxldmVsIG5vZGVzXG4iKTsKKwkJCQl4bWxfbm9kZV9nZXRfdGV4dF9mcmVlKGN0eCwgbm9kZW5hbWUpOworCQkJCXJldHVybiBOVUxMOworCQkJfQorCQkJcm9vdCA9IGFkZF9tb19ub2RlKGN0eCwgcm9vdCwgbm9kZSwgdXJpKTsKKwkJfQorCisJCWNoaWxkID0gZ2V0X2ZpcnN0X2NoaWxkX25vZGUoY3R4LCBub2RlLCAiTm9kZSIpOworCQlpZiAoY2hpbGQpIHsKKwkJCWlmICh1cmkgPT0gTlVMTCkKKwkJCQl0bmRzX3RvX21vX2l0ZXIoY3R4LCByb290LCBjaGlsZCwgbm9kZW5hbWUpOworCQkJZWxzZSB7CisJCQkJY2hhciAqbmV3X3VyaTsKKwkJCQluZXdfdXJpID0gYWRkX3BhdGgodXJpLCBub2RlbmFtZSk7CisJCQkJdG5kc190b19tb19pdGVyKGN0eCwgcm9vdCwgY2hpbGQsIG5ld191cmkpOworCQkJCW9zX2ZyZWUobmV3X3VyaSk7CisJCQl9CisJCX0KKwkJeG1sX25vZGVfZ2V0X3RleHRfZnJlZShjdHgsIG5vZGVuYW1lKTsKKwl9CisKKwlyZXR1cm4gcm9vdDsKK30KKworCit4bWxfbm9kZV90ICogdG5kc190b19tbyhzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKnRuZHMpCit7CisJY29uc3QgY2hhciAqbmFtZTsKKwl4bWxfbm9kZV90ICpub2RlOworCisJbmFtZSA9IHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoY3R4LCB0bmRzKTsKKwlpZiAobmFtZSA9PSBOVUxMIHx8IG9zX3N0cmNtcChuYW1lLCAiTWdtdFRyZWUiKSAhPSAwKQorCQlyZXR1cm4gTlVMTDsKKworCW5vZGUgPSBnZXRfZmlyc3RfY2hpbGRfbm9kZShjdHgsIHRuZHMsICJOb2RlIik7CisJaWYgKCFub2RlKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gdG5kc190b19tb19pdGVyKGN0eCwgTlVMTCwgbm9kZSwgTlVMTCk7Cit9CisKKworeG1sX25vZGVfdCAqIHNvYXBfYnVpbGRfZW52ZWxvcGUoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKQoreworCXhtbF9ub2RlX3QgKmVudmVsb3BlLCAqYm9keTsKKwl4bWxfbmFtZXNwYWNlX3QgKm5zOworCisJZW52ZWxvcGUgPSB4bWxfbm9kZV9jcmVhdGVfcm9vdCgKKwkJY3R4LCAiaHR0cDovL3d3dy53My5vcmcvMjAwMy8wNS9zb2FwLWVudmVsb3BlIiwgInNvYXAxMiIsICZucywKKwkJIkVudmVsb3BlIik7CisJaWYgKGVudmVsb3BlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCWJvZHkgPSB4bWxfbm9kZV9jcmVhdGUoY3R4LCBlbnZlbG9wZSwgbnMsICJCb2R5Iik7CisJeG1sX25vZGVfYWRkX2NoaWxkKGN0eCwgYm9keSwgbm9kZSk7CisJcmV0dXJuIGVudmVsb3BlOworfQorCisKK3htbF9ub2RlX3QgKiBzb2FwX2dldF9ib2R5KHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqc29hcCkKK3sKKwl4bWxfbm9kZV90ICpib2R5LCAqY2hpbGQ7CisKKwlib2R5ID0gZ2V0X25vZGVfdXJpKGN0eCwgc29hcCwgIkVudmVsb3BlL0JvZHkiKTsKKwlpZiAoYm9keSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwl4bWxfbm9kZV9mb3JfZWFjaF9jaGlsZChjdHgsIGNoaWxkLCBib2R5KSB7CisJCXhtbF9ub2RlX2Zvcl9lYWNoX2NoZWNrKGN0eCwgY2hpbGQpOworCQlyZXR1cm4gY2hpbGQ7CisJfQorCXJldHVybiBOVUxMOworfQpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL3htbC11dGlscy5oIGIvc3JjL3V0aWxzL3htbC11dGlscy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZiNjIwOGMKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdXRpbHMveG1sLXV0aWxzLmgKQEAgLTAsMCArMSw5NyBAQAorLyoKKyAqIEdlbmVyaWMgWE1MIGhlbHBlciBmdW5jdGlvbnMKKyAqIENvcHlyaWdodCAoYykgMjAxMi0yMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIFhNTF9VVElMU19ICisjZGVmaW5lIFhNTF9VVElMU19ICisKK3N0cnVjdCB4bWxfbm9kZV9jdHg7Cit0eXBlZGVmIHN0cnVjdCB4bWxfbm9kZSB4bWxfbm9kZV90OwordHlwZWRlZiBzdHJ1Y3QgeG1sX25hbWVzcGFjZV9mb28geG1sX25hbWVzcGFjZV90OworCisvKiBYTUwgbGlicmFyeSB3cmFwcGVycyAqLworCitpbnQgeG1sX3ZhbGlkYXRlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJIGNvbnN0IGNoYXIgKnhtbF9zY2hlbWFfZm5hbWUsIGNoYXIgKipyZXRfZXJyKTsKK2ludCB4bWxfdmFsaWRhdGVfZHRkKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJICAgICBjb25zdCBjaGFyICpkdGRfZm5hbWUsIGNoYXIgKipyZXRfZXJyKTsKK3ZvaWQgeG1sX25vZGVfZnJlZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUpOworeG1sX25vZGVfdCAqIHhtbF9ub2RlX2dldF9wYXJlbnQoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKTsKK3htbF9ub2RlX3QgKiB4bWxfbm9kZV9mcm9tX2J1ZihzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIGNvbnN0IGNoYXIgKmJ1Zik7Citjb25zdCBjaGFyICogeG1sX25vZGVfZ2V0X2xvY2FsbmFtZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICAgIHhtbF9ub2RlX3QgKm5vZGUpOworY2hhciAqIHhtbF9ub2RlX3RvX3N0cihzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUpOwordm9pZCB4bWxfbm9kZV9kZXRhY2goc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKTsKK3ZvaWQgeG1sX25vZGVfYWRkX2NoaWxkKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJeG1sX25vZGVfdCAqY2hpbGQpOworeG1sX25vZGVfdCAqIHhtbF9ub2RlX2NyZWF0ZV9yb290KHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgY29uc3QgY2hhciAqbnNfdXJpLAorCQkJCSAgY29uc3QgY2hhciAqbnNfcHJlZml4LAorCQkJCSAgeG1sX25hbWVzcGFjZV90ICoqcmV0X25zLCBjb25zdCBjaGFyICpuYW1lKTsKK3htbF9ub2RlX3QgKiB4bWxfbm9kZV9jcmVhdGUoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpwYXJlbnQsCisJCQkgICAgIHhtbF9uYW1lc3BhY2VfdCAqbnMsIGNvbnN0IGNoYXIgKm5hbWUpOworeG1sX25vZGVfdCAqIHhtbF9ub2RlX2NyZWF0ZV90ZXh0KHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwKKwkJCQkgIHhtbF9ub2RlX3QgKnBhcmVudCwgeG1sX25hbWVzcGFjZV90ICpucywKKwkJCQkgIGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIgKnZhbHVlKTsKK3htbF9ub2RlX3QgKiB4bWxfbm9kZV9jcmVhdGVfdGV4dF9ucyhzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICAgICB4bWxfbm9kZV90ICpwYXJlbnQsIGNvbnN0IGNoYXIgKm5zX3VyaSwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIgKnZhbHVlKTsKK3ZvaWQgeG1sX25vZGVfc2V0X3RleHQoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlLAorCQkgICAgICAgY29uc3QgY2hhciAqdmFsdWUpOworaW50IHhtbF9ub2RlX2FkZF9hdHRyKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJICAgICAgeG1sX25hbWVzcGFjZV90ICpucywgY29uc3QgY2hhciAqbmFtZSwgY29uc3QgY2hhciAqdmFsdWUpOworY2hhciAqIHhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJCSAgICAgICBjaGFyICpuYW1lKTsKK2NoYXIgKiB4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9ucyhzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCQkJICBjb25zdCBjaGFyICpuc191cmksIGNoYXIgKm5hbWUpOwordm9pZCB4bWxfbm9kZV9nZXRfYXR0cl92YWx1ZV9mcmVlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgY2hhciAqdmFsKTsKK3htbF9ub2RlX3QgKiB4bWxfbm9kZV9maXJzdF9jaGlsZChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICB4bWxfbm9kZV90ICpwYXJlbnQpOworeG1sX25vZGVfdCAqIHhtbF9ub2RlX25leHRfc2libGluZyhzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICAgeG1sX25vZGVfdCAqbm9kZSk7CitpbnQgeG1sX25vZGVfaXNfZWxlbWVudChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUpOworY2hhciAqIHhtbF9ub2RlX2dldF90ZXh0KHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSk7Cit2b2lkIHhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCBjaGFyICp2YWwpOworY2hhciAqIHhtbF9ub2RlX2dldF9iYXNlNjRfdGV4dChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCQkJaW50ICpyZXRfbGVuKTsKK3htbF9ub2RlX3QgKiB4bWxfbm9kZV9jb3B5KHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSk7CisKKyNkZWZpbmUgeG1sX25vZGVfZm9yX2VhY2hfY2hpbGQoY3R4LCBjaGlsZCwgcGFyZW50KSBcCitmb3IgKGNoaWxkID0geG1sX25vZGVfZmlyc3RfY2hpbGQoY3R4LCBwYXJlbnQpOyBcCisgICAgIGNoaWxkOyBcCisgICAgIGNoaWxkID0geG1sX25vZGVfbmV4dF9zaWJsaW5nKGN0eCwgY2hpbGQpKQorCisjZGVmaW5lIHhtbF9ub2RlX2Zvcl9lYWNoX3NpYmxpbmcoY3R4LCBub2RlKSBcCitmb3IgKDsgXAorICAgICBub2RlOyBcCisgICAgIG5vZGUgPSB4bWxfbm9kZV9uZXh0X3NpYmxpbmcoY3R4LCBub2RlKSkKKworI2RlZmluZSB4bWxfbm9kZV9mb3JfZWFjaF9jaGVjayhjdHgsIGNoaWxkKSBcCitpZiAoIXhtbF9ub2RlX2lzX2VsZW1lbnQoY3R4LCBjaGlsZCkpIFwKKwljb250aW51ZQorCisKK3N0cnVjdCB4bWxfbm9kZV9jdHggKiB4bWxfbm9kZV9pbml0X2N0eCh2b2lkICp1cHBlcl9jdHgsCisJCQkJCWNvbnN0IHZvaWQgKmVudik7Cit2b2lkIHhtbF9ub2RlX2RlaW5pdF9jdHgoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4KTsKKworCit4bWxfbm9kZV90ICogZ2V0X25vZGVfdXJpKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqcm9vdCwKKwkJCSAgY29uc3QgY2hhciAqdXJpKTsKK3htbF9ub2RlX3QgKiBnZXRfbm9kZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKnJvb3QsCisJCSAgICAgIGNvbnN0IGNoYXIgKnBhdGgpOworeG1sX25vZGVfdCAqIGdldF9jaGlsZF9ub2RlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqcm9vdCwKKwkJCSAgICBjb25zdCBjaGFyICpwYXRoKTsKK3htbF9ub2RlX3QgKiBub2RlX2Zyb21fZmlsZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIGNvbnN0IGNoYXIgKm5hbWUpOworaW50IG5vZGVfdG9fZmlsZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIGNvbnN0IGNoYXIgKmZuYW1lLCB4bWxfbm9kZV90ICpub2RlKTsKK3htbF9ub2RlX3QgKiBtb190b190bmRzKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbW8sCisJCQlpbnQgdXNlX3BhdGgsIGNvbnN0IGNoYXIgKnVybiwgY29uc3QgY2hhciAqbnNfdXJpKTsKK3htbF9ub2RlX3QgKiB0bmRzX3RvX21vKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqdG5kcyk7CisKK3htbF9ub2RlX3QgKiBzb2FwX2J1aWxkX2VudmVsb3BlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSk7Cit4bWxfbm9kZV90ICogc29hcF9nZXRfYm9keShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKnNvYXApOworCisjZW5kaWYgLyogWE1MX1VUSUxTX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy91dGlscy94bWxfbGlieG1sMi5jIGIvc3JjL3V0aWxzL3htbF9saWJ4bWwyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzkyODM5NAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy91dGlscy94bWxfbGlieG1sMi5jCkBAIC0wLDAgKzEsNDU3IEBACisvKgorICogWE1MIHdyYXBwZXIgZm9yIGxpYnhtbDIKKyAqIENvcHlyaWdodCAoYykgMjAxMi0yMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKyNkZWZpbmUgTElCWE1MX1ZBTElEX0VOQUJMRUQKKyNpbmNsdWRlIDxsaWJ4bWwvdHJlZS5oPgorI2luY2x1ZGUgPGxpYnhtbC94bWxzY2hlbWFzdHlwZXMuaD4KKworI2luY2x1ZGUgImNvbW1vbi5oIgorI2luY2x1ZGUgImJhc2U2NC5oIgorI2luY2x1ZGUgInhtbC11dGlscy5oIgorCisKK3N0cnVjdCB4bWxfbm9kZV9jdHggeworCXZvaWQgKmN0eDsKK307CisKKworc3RydWN0IHN0cl9idWYgeworCWNoYXIgKmJ1ZjsKKwlzaXplX3QgbGVuOworfTsKKworI2RlZmluZSBNQVhfU1RSIDEwMDAKKworc3RhdGljIHZvaWQgYWRkX3N0cih2b2lkICpjdHhfcHRyLCBjb25zdCBjaGFyICpmbXQsIC4uLikKK3sKKwlzdHJ1Y3Qgc3RyX2J1ZiAqc3RyID0gY3R4X3B0cjsKKwl2YV9saXN0IGFwOworCWNoYXIgKm47CisJaW50IGxlbjsKKworCW4gPSBvc19yZWFsbG9jKHN0ci0+YnVmLCBzdHItPmxlbiArIE1BWF9TVFIgKyAyKTsKKwlpZiAobiA9PSBOVUxMKQorCQlyZXR1cm47CisJc3RyLT5idWYgPSBuOworCisJdmFfc3RhcnQoYXAsIGZtdCk7CisJbGVuID0gdnNucHJpbnRmKHN0ci0+YnVmICsgc3RyLT5sZW4sIE1BWF9TVFIsIGZtdCwgYXApOworCXZhX2VuZChhcCk7CisJaWYgKGxlbiA+PSBNQVhfU1RSKQorCQlsZW4gPSBNQVhfU1RSIC0gMTsKKwlzdHItPmxlbiArPSBsZW47CisJc3RyLT5idWZbc3RyLT5sZW5dID0gJ1wwJzsKK30KKworCitpbnQgeG1sX3ZhbGlkYXRlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJIGNvbnN0IGNoYXIgKnhtbF9zY2hlbWFfZm5hbWUsIGNoYXIgKipyZXRfZXJyKQoreworCXhtbERvY1B0ciBkb2M7CisJeG1sTm9kZVB0ciBuOworCXhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eDsKKwl4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eDsKKwl4bWxTY2hlbWFQdHIgc2NoZW1hOworCWludCByZXQ7CisJc3RydWN0IHN0cl9idWYgZXJyb3JzOworCisJaWYgKHJldF9lcnIpCisJCSpyZXRfZXJyID0gTlVMTDsKKworCWRvYyA9IHhtbE5ld0RvYygoeG1sQ2hhciAqKSAiMS4wIik7CisJaWYgKGRvYyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJbiA9IHhtbERvY0NvcHlOb2RlKCh4bWxOb2RlUHRyKSBub2RlLCBkb2MsIDEpOworCWlmIChuID09IE5VTEwpIHsKKwkJeG1sRnJlZURvYyhkb2MpOworCQlyZXR1cm4gLTE7CisJfQorCXhtbERvY1NldFJvb3RFbGVtZW50KGRvYywgbik7CisKKwlvc19tZW1zZXQoJmVycm9ycywgMCwgc2l6ZW9mKGVycm9ycykpOworCisJcGN0eCA9IHhtbFNjaGVtYU5ld1BhcnNlckN0eHQoeG1sX3NjaGVtYV9mbmFtZSk7CisJeG1sU2NoZW1hU2V0UGFyc2VyRXJyb3JzKHBjdHgsICh4bWxTY2hlbWFWYWxpZGl0eUVycm9yRnVuYykgYWRkX3N0ciwKKwkJCQkgKHhtbFNjaGVtYVZhbGlkaXR5V2FybmluZ0Z1bmMpIGFkZF9zdHIsCisJCQkJICZlcnJvcnMpOworCXNjaGVtYSA9IHhtbFNjaGVtYVBhcnNlKHBjdHgpOworCXhtbFNjaGVtYUZyZWVQYXJzZXJDdHh0KHBjdHgpOworCisJdmN0eCA9IHhtbFNjaGVtYU5ld1ZhbGlkQ3R4dChzY2hlbWEpOworCXhtbFNjaGVtYVNldFZhbGlkRXJyb3JzKHZjdHgsICh4bWxTY2hlbWFWYWxpZGl0eUVycm9yRnVuYykgYWRkX3N0ciwKKwkJCQkoeG1sU2NoZW1hVmFsaWRpdHlXYXJuaW5nRnVuYykgYWRkX3N0ciwKKwkJCQkmZXJyb3JzKTsKKworCXJldCA9IHhtbFNjaGVtYVZhbGlkYXRlRG9jKHZjdHgsIGRvYyk7CisJeG1sU2NoZW1hRnJlZVZhbGlkQ3R4dCh2Y3R4KTsKKwl4bWxGcmVlRG9jKGRvYyk7CisJeG1sU2NoZW1hRnJlZShzY2hlbWEpOworCisJaWYgKHJldCA9PSAwKSB7CisJCW9zX2ZyZWUoZXJyb3JzLmJ1Zik7CisJCXJldHVybiAwOworCX0gZWxzZSBpZiAocmV0ID4gMCkgeworCQlpZiAocmV0X2VycikKKwkJCSpyZXRfZXJyID0gZXJyb3JzLmJ1ZjsKKwkJZWxzZQorCQkJb3NfZnJlZShlcnJvcnMuYnVmKTsKKwkJcmV0dXJuIC0xOworCX0gZWxzZSB7CisJCWlmIChyZXRfZXJyKQorCQkJKnJldF9lcnIgPSBlcnJvcnMuYnVmOworCQllbHNlCisJCQlvc19mcmVlKGVycm9ycy5idWYpOworCQlyZXR1cm4gLTE7CisJfQorfQorCisKK2ludCB4bWxfdmFsaWRhdGVfZHRkKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJICAgICBjb25zdCBjaGFyICpkdGRfZm5hbWUsIGNoYXIgKipyZXRfZXJyKQoreworCXhtbERvY1B0ciBkb2M7CisJeG1sTm9kZVB0ciBuOworCXhtbFZhbGlkQ3R4dCB2Y3R4OworCXhtbER0ZFB0ciBkdGQ7CisJaW50IHJldDsKKwlzdHJ1Y3Qgc3RyX2J1ZiBlcnJvcnM7CisKKwlpZiAocmV0X2VycikKKwkJKnJldF9lcnIgPSBOVUxMOworCisJZG9jID0geG1sTmV3RG9jKCh4bWxDaGFyICopICIxLjAiKTsKKwlpZiAoZG9jID09IE5VTEwpCisJCXJldHVybiAtMTsKKwluID0geG1sRG9jQ29weU5vZGUoKHhtbE5vZGVQdHIpIG5vZGUsIGRvYywgMSk7CisJaWYgKG4gPT0gTlVMTCkgeworCQl4bWxGcmVlRG9jKGRvYyk7CisJCXJldHVybiAtMTsKKwl9CisJeG1sRG9jU2V0Um9vdEVsZW1lbnQoZG9jLCBuKTsKKworCW9zX21lbXNldCgmZXJyb3JzLCAwLCBzaXplb2YoZXJyb3JzKSk7CisKKwlkdGQgPSB4bWxQYXJzZURURChOVUxMLCAoY29uc3QgeG1sQ2hhciAqKSBkdGRfZm5hbWUpOworCWlmIChkdGQgPT0gTlVMTCkgeworCQl4bWxGcmVlRG9jKGRvYyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlvc19tZW1zZXQoJnZjdHgsIDAsIHNpemVvZih2Y3R4KSk7CisJdmN0eC51c2VyRGF0YSA9ICZlcnJvcnM7CisJdmN0eC5lcnJvciA9IGFkZF9zdHI7CisJdmN0eC53YXJuaW5nID0gYWRkX3N0cjsKKwlyZXQgPSB4bWxWYWxpZGF0ZUR0ZCgmdmN0eCwgZG9jLCBkdGQpOworCXhtbEZyZWVEb2MoZG9jKTsKKwl4bWxGcmVlRHRkKGR0ZCk7CisKKwlpZiAocmV0ID09IDEpIHsKKwkJb3NfZnJlZShlcnJvcnMuYnVmKTsKKwkJcmV0dXJuIDA7CisJfSBlbHNlIHsKKwkJaWYgKHJldF9lcnIpCisJCQkqcmV0X2VyciA9IGVycm9ycy5idWY7CisJCWVsc2UKKwkJCW9zX2ZyZWUoZXJyb3JzLmJ1Zik7CisJCXJldHVybiAtMTsKKwl9Cit9CisKKwordm9pZCB4bWxfbm9kZV9mcmVlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwl4bWxGcmVlTm9kZSgoeG1sTm9kZVB0cikgbm9kZSk7Cit9CisKKworeG1sX25vZGVfdCAqIHhtbF9ub2RlX2dldF9wYXJlbnQoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKQoreworCXJldHVybiAoeG1sX25vZGVfdCAqKSAoKHhtbE5vZGVQdHIpIG5vZGUpLT5wYXJlbnQ7Cit9CisKKworeG1sX25vZGVfdCAqIHhtbF9ub2RlX2Zyb21fYnVmKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgY29uc3QgY2hhciAqYnVmKQoreworCXhtbERvY1B0ciBkb2M7CisJeG1sTm9kZVB0ciBub2RlOworCisJZG9jID0geG1sUGFyc2VNZW1vcnkoYnVmLCBzdHJsZW4oYnVmKSk7CisJaWYgKGRvYyA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlub2RlID0geG1sRG9jR2V0Um9vdEVsZW1lbnQoZG9jKTsKKwlub2RlID0geG1sQ29weU5vZGUobm9kZSwgMSk7CisJeG1sRnJlZURvYyhkb2MpOworCisJcmV0dXJuICh4bWxfbm9kZV90ICopIG5vZGU7Cit9CisKKworY29uc3QgY2hhciAqIHhtbF9ub2RlX2dldF9sb2NhbG5hbWUoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LAorCQkJCSAgICB4bWxfbm9kZV90ICpub2RlKQoreworCXJldHVybiAoY29uc3QgY2hhciAqKSAoKHhtbE5vZGVQdHIpIG5vZGUpLT5uYW1lOworfQorCisKK2NoYXIgKiB4bWxfbm9kZV90b19zdHIoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKQoreworCXhtbENoYXIgKmJ1ZjsKKwlpbnQgYnVmc2l6OworCWNoYXIgKnJldCwgKnBvczsKKwl4bWxOb2RlUHRyIG4gPSAoeG1sTm9kZVB0cikgbm9kZTsKKwl4bWxEb2NQdHIgZG9jOworCisJZG9jID0geG1sTmV3RG9jKCh4bWxDaGFyICopICIxLjAiKTsKKwluID0geG1sRG9jQ29weU5vZGUobiwgZG9jLCAxKTsKKwl4bWxEb2NTZXRSb290RWxlbWVudChkb2MsIG4pOworCXhtbERvY0R1bXBGb3JtYXRNZW1vcnkoZG9jLCAmYnVmLCAmYnVmc2l6LCAwKTsKKwl4bWxGcmVlRG9jKGRvYyk7CisJcG9zID0gKGNoYXIgKikgYnVmOworCWlmIChzdHJuY21wKHBvcywgIjw/eG1sIiwgNSkgPT0gMCkgeworCQlwb3MgPSBzdHJjaHIocG9zLCAnPicpOworCQlpZiAocG9zKQorCQkJcG9zKys7CisJCXdoaWxlIChwb3MgJiYgKCpwb3MgPT0gJ1xyJyB8fCAqcG9zID09ICdcbicpKQorCQkJcG9zKys7CisJfQorCWlmIChwb3MpCisJCXJldCA9IG9zX3N0cmR1cChwb3MpOworCWVsc2UKKwkJcmV0ID0gTlVMTDsKKwl4bWxGcmVlKGJ1Zik7CisKKwlpZiAocmV0KSB7CisJCXBvcyA9IHJldDsKKwkJaWYgKHBvc1swXSkgeworCQkJd2hpbGUgKHBvc1sxXSkKKwkJCQlwb3MrKzsKKwkJfQorCQl3aGlsZSAocG9zID49IHJldCAmJiAqcG9zID09ICdcbicpCisJCQkqcG9zLS0gPSAnXDAnOworCX0KKworCXJldHVybiByZXQ7Cit9CisKKwordm9pZCB4bWxfbm9kZV9kZXRhY2goc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKQoreworCXhtbFVubGlua05vZGUoKHhtbE5vZGVQdHIpIG5vZGUpOworfQorCisKK3ZvaWQgeG1sX25vZGVfYWRkX2NoaWxkKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJeG1sX25vZGVfdCAqY2hpbGQpCit7CisJeG1sQWRkQ2hpbGQoKHhtbE5vZGVQdHIpIHBhcmVudCwgKHhtbE5vZGVQdHIpIGNoaWxkKTsKK30KKworCit4bWxfbm9kZV90ICogeG1sX25vZGVfY3JlYXRlX3Jvb3Qoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCBjb25zdCBjaGFyICpuc191cmksCisJCQkJICBjb25zdCBjaGFyICpuc19wcmVmaXgsCisJCQkJICB4bWxfbmFtZXNwYWNlX3QgKipyZXRfbnMsIGNvbnN0IGNoYXIgKm5hbWUpCit7CisJeG1sTm9kZVB0ciBub2RlOworCXhtbE5zUHRyIG5zID0gTlVMTDsKKworCW5vZGUgPSB4bWxOZXdOb2RlKE5VTEwsIChjb25zdCB4bWxDaGFyICopIG5hbWUpOworCWlmIChub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCWlmIChuc191cmkpIHsKKwkJbnMgPSB4bWxOZXdOcyhub2RlLCAoY29uc3QgeG1sQ2hhciAqKSBuc191cmksCisJCQkgICAgICAoY29uc3QgeG1sQ2hhciAqKSBuc19wcmVmaXgpOworCQl4bWxTZXROcyhub2RlLCBucyk7CisJfQorCisJaWYgKHJldF9ucykKKwkJKnJldF9ucyA9ICh4bWxfbmFtZXNwYWNlX3QgKikgbnM7CisKKwlyZXR1cm4gKHhtbF9ub2RlX3QgKikgbm9kZTsKK30KKworCit4bWxfbm9kZV90ICogeG1sX25vZGVfY3JlYXRlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqcGFyZW50LAorCQkJICAgICB4bWxfbmFtZXNwYWNlX3QgKm5zLCBjb25zdCBjaGFyICpuYW1lKQoreworCXhtbE5vZGVQdHIgbm9kZTsKKwlub2RlID0geG1sTmV3Q2hpbGQoKHhtbE5vZGVQdHIpIHBhcmVudCwgKHhtbE5zUHRyKSBucywKKwkJCSAgIChjb25zdCB4bWxDaGFyICopIG5hbWUsIE5VTEwpOworCXJldHVybiAoeG1sX25vZGVfdCAqKSBub2RlOworfQorCisKK3htbF9ub2RlX3QgKiB4bWxfbm9kZV9jcmVhdGVfdGV4dChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICB4bWxfbm9kZV90ICpwYXJlbnQsIHhtbF9uYW1lc3BhY2VfdCAqbnMsCisJCQkJICBjb25zdCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwl4bWxOb2RlUHRyIG5vZGU7CisJbm9kZSA9IHhtbE5ld1RleHRDaGlsZCgoeG1sTm9kZVB0cikgcGFyZW50LCAoeG1sTnNQdHIpIG5zLAorCQkJICAgICAgIChjb25zdCB4bWxDaGFyICopIG5hbWUsIChjb25zdCB4bWxDaGFyICopIHZhbHVlKTsKKwlyZXR1cm4gKHhtbF9ub2RlX3QgKikgbm9kZTsKK30KKworCit4bWxfbm9kZV90ICogeG1sX25vZGVfY3JlYXRlX3RleHRfbnMoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LAorCQkJCSAgICAgeG1sX25vZGVfdCAqcGFyZW50LCBjb25zdCBjaGFyICpuc191cmksCisJCQkJICAgICBjb25zdCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwl4bWxOb2RlUHRyIG5vZGU7CisJeG1sTnNQdHIgbnM7CisKKwlub2RlID0geG1sTmV3VGV4dENoaWxkKCh4bWxOb2RlUHRyKSBwYXJlbnQsIE5VTEwsCisJCQkgICAgICAgKGNvbnN0IHhtbENoYXIgKikgbmFtZSwgKGNvbnN0IHhtbENoYXIgKikgdmFsdWUpOworCW5zID0geG1sTmV3TnMobm9kZSwgKGNvbnN0IHhtbENoYXIgKikgbnNfdXJpLCBOVUxMKTsKKwl4bWxTZXROcyhub2RlLCBucyk7CisJcmV0dXJuICh4bWxfbm9kZV90ICopIG5vZGU7Cit9CisKKwordm9pZCB4bWxfbm9kZV9zZXRfdGV4dChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCSAgICAgICBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwkvKiBUT0RPOiBlc2NhcGUgWE1MIHNwZWNpYWwgY2hhcnMgaW4gdmFsdWUgKi8KKwl4bWxOb2RlU2V0Q29udGVudCgoeG1sTm9kZVB0cikgbm9kZSwgKHhtbENoYXIgKikgdmFsdWUpOworfQorCisKK2ludCB4bWxfbm9kZV9hZGRfYXR0cihzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCSAgICAgIHhtbF9uYW1lc3BhY2VfdCAqbnMsIGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIgKnZhbHVlKQoreworCXhtbEF0dHJQdHIgYXR0cjsKKworCWlmIChucykgeworCQlhdHRyID0geG1sTmV3TnNQcm9wKCh4bWxOb2RlUHRyKSBub2RlLCAoeG1sTnNQdHIpIG5zLAorCQkJCSAgICAoY29uc3QgeG1sQ2hhciAqKSBuYW1lLAorCQkJCSAgICAoY29uc3QgeG1sQ2hhciAqKSB2YWx1ZSk7CisJfSBlbHNlIHsKKwkJYXR0ciA9IHhtbE5ld1Byb3AoKHhtbE5vZGVQdHIpIG5vZGUsIChjb25zdCB4bWxDaGFyICopIG5hbWUsCisJCQkJICAoY29uc3QgeG1sQ2hhciAqKSB2YWx1ZSk7CisJfQorCisJcmV0dXJuIGF0dHIgPyAwIDogLTE7Cit9CisKKworY2hhciAqIHhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJCSAgICAgICBjaGFyICpuYW1lKQoreworCXJldHVybiAoY2hhciAqKSB4bWxHZXROb05zUHJvcCgoeG1sTm9kZVB0cikgbm9kZSwKKwkJCQkgICAgICAgKGNvbnN0IHhtbENoYXIgKikgbmFtZSk7Cit9CisKKworY2hhciAqIHhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX25zKHN0cnVjdCB4bWxfbm9kZV9jdHggKmN0eCwgeG1sX25vZGVfdCAqbm9kZSwKKwkJCQkgIGNvbnN0IGNoYXIgKm5zX3VyaSwgY2hhciAqbmFtZSkKK3sKKwlyZXR1cm4gKGNoYXIgKikgeG1sR2V0TnNQcm9wKCh4bWxOb2RlUHRyKSBub2RlLCAoY29uc3QgeG1sQ2hhciAqKSBuYW1lLAorCQkJCSAgICAgKGNvbnN0IHhtbENoYXIgKikgbnNfdXJpKTsKK30KKworCit2b2lkIHhtbF9ub2RlX2dldF9hdHRyX3ZhbHVlX2ZyZWUoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCBjaGFyICp2YWwpCit7CisJaWYgKHZhbCkKKwkJeG1sRnJlZSgoeG1sQ2hhciAqKSB2YWwpOworfQorCisKK3htbF9ub2RlX3QgKiB4bWxfbm9kZV9maXJzdF9jaGlsZChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICB4bWxfbm9kZV90ICpwYXJlbnQpCit7CisJcmV0dXJuICh4bWxfbm9kZV90ICopICgoeG1sTm9kZVB0cikgcGFyZW50KS0+Y2hpbGRyZW47Cit9CisKKworeG1sX25vZGVfdCAqIHhtbF9ub2RlX25leHRfc2libGluZyhzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsCisJCQkJICAgeG1sX25vZGVfdCAqbm9kZSkKK3sKKwlyZXR1cm4gKHhtbF9ub2RlX3QgKikgKCh4bWxOb2RlUHRyKSBub2RlKS0+bmV4dDsKK30KKworCitpbnQgeG1sX25vZGVfaXNfZWxlbWVudChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUpCit7CisJcmV0dXJuICgoeG1sTm9kZVB0cikgbm9kZSktPnR5cGUgPT0gWE1MX0VMRU1FTlRfTk9ERTsKK30KKworCitjaGFyICogeG1sX25vZGVfZ2V0X3RleHQoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKQoreworCWlmICh4bWxDaGlsZEVsZW1lbnRDb3VudCgoeG1sTm9kZVB0cikgbm9kZSkgPiAwKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gKGNoYXIgKikgeG1sTm9kZUdldENvbnRlbnQoKHhtbE5vZGVQdHIpIG5vZGUpOworfQorCisKK3ZvaWQgeG1sX25vZGVfZ2V0X3RleHRfZnJlZShzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIGNoYXIgKnZhbCkKK3sKKwlpZiAodmFsKQorCQl4bWxGcmVlKCh4bWxDaGFyICopIHZhbCk7Cit9CisKKworY2hhciAqIHhtbF9ub2RlX2dldF9iYXNlNjRfdGV4dChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgsIHhtbF9ub2RlX3QgKm5vZGUsCisJCQkJaW50ICpyZXRfbGVuKQoreworCWNoYXIgKnR4dDsKKwl1bnNpZ25lZCBjaGFyICpyZXQ7CisJc2l6ZV90IGxlbjsKKworCXR4dCA9IHhtbF9ub2RlX2dldF90ZXh0KGN0eCwgbm9kZSk7CisJaWYgKHR4dCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXJldCA9IGJhc2U2NF9kZWNvZGUoKHVuc2lnbmVkIGNoYXIgKikgdHh0LCBzdHJsZW4odHh0KSwgJmxlbik7CisJaWYgKHJldF9sZW4pCisJCSpyZXRfbGVuID0gbGVuOworCXhtbF9ub2RlX2dldF90ZXh0X2ZyZWUoY3R4LCB0eHQpOworCWlmIChyZXQgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJdHh0ID0gb3NfbWFsbG9jKGxlbiArIDEpOworCWlmICh0eHQgPT0gTlVMTCkgeworCQlvc19mcmVlKHJldCk7CisJCXJldHVybiBOVUxMOworCX0KKwlvc19tZW1jcHkodHh0LCByZXQsIGxlbik7CisJdHh0W2xlbl0gPSAnXDAnOworCXJldHVybiB0eHQ7Cit9CisKKworeG1sX25vZGVfdCAqIHhtbF9ub2RlX2NvcHkoc3RydWN0IHhtbF9ub2RlX2N0eCAqY3R4LCB4bWxfbm9kZV90ICpub2RlKQoreworCWlmIChub2RlID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCXJldHVybiAoeG1sX25vZGVfdCAqKSB4bWxDb3B5Tm9kZSgoeG1sTm9kZVB0cikgbm9kZSwgMSk7Cit9CisKKworc3RydWN0IHhtbF9ub2RlX2N0eCAqIHhtbF9ub2RlX2luaXRfY3R4KHZvaWQgKnVwcGVyX2N0eCwKKwkJCQkJY29uc3Qgdm9pZCAqZW52KQoreworCXN0cnVjdCB4bWxfbm9kZV9jdHggKnhjdHg7CisKKwl4Y3R4ID0gb3NfemFsbG9jKHNpemVvZigqeGN0eCkpOworCWlmICh4Y3R4ID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCXhjdHgtPmN0eCA9IHVwcGVyX2N0eDsKKworCUxJQlhNTF9URVNUX1ZFUlNJT04KKworCXJldHVybiB4Y3R4OworfQorCisKK3ZvaWQgeG1sX25vZGVfZGVpbml0X2N0eChzdHJ1Y3QgeG1sX25vZGVfY3R4ICpjdHgpCit7CisJeG1sU2NoZW1hQ2xlYW51cFR5cGVzKCk7CisJeG1sQ2xlYW51cFBhcnNlcigpOworCXhtbE1lbW9yeUR1bXAoKTsKKwlvc19mcmVlKGN0eCk7Cit9CmRpZmYgLS1naXQgYS9zcmMvd3BzL01ha2VmaWxlIGIvc3JjL3dwcy9NYWtlZmlsZQppbmRleCA5YzQxOTYyLi5hZGZkM2RmIDEwMDY0NAotLS0gYS9zcmMvd3BzL01ha2VmaWxlCisrKyBiL3NyYy93cHMvTWFrZWZpbGUKQEAgLTIsNyArMiw3IEBACiAJQGVjaG8gTm90aGluZyB0byBiZSBtYWRlLgogCiBjbGVhbjoKLQlybSAtZiAqfiAqLm8gKi5kCisJcm0gLWYgKn4gKi5vICouZCAqLmdjbm8gKi5nY2RhICouZ2NvdgogCiBpbnN0YWxsOgogCUBlY2hvIE5vdGhpbmcgdG8gYmUgbWFkZS4KZGlmZiAtLWdpdCBhL3NyYy93cHMvaHR0cF9zZXJ2ZXIuYyBiL3NyYy93cHMvaHR0cF9zZXJ2ZXIuYwppbmRleCA2Y2EzMjE0Li5hYzA4OGM0IDEwMDY0NAotLS0gYS9zcmMvd3BzL2h0dHBfc2VydmVyLmMKKysrIGIvc3JjL3dwcy9odHRwX3NlcnZlci5jCkBAIC0yMzIsNiArMjMyLDcgQEAKIHsKIAlzdHJ1Y3Qgc29ja2FkZHJfaW4gc2luOwogCXN0cnVjdCBodHRwX3NlcnZlciAqc3J2OworCWludCBvbiA9IDE7CiAKIAlzcnYgPSBvc196YWxsb2Moc2l6ZW9mKCpzcnYpKTsKIAlpZiAoc3J2ID09IE5VTEwpCkBAIC0yNDIsNiArMjQzLDE1IEBACiAJc3J2LT5mZCA9IHNvY2tldChBRl9JTkVULCBTT0NLX1NUUkVBTSwgMCk7CiAJaWYgKHNydi0+ZmQgPCAwKQogCQlnb3RvIGZhaWw7CisKKwlpZiAoc2V0c29ja29wdChzcnYtPmZkLCBTT0xfU09DS0VULCBTT19SRVVTRUFERFIsICZvbiwgc2l6ZW9mKG9uKSkgPCAwKQorCXsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAiSFRUUDogc2V0c29ja29wdChTT19SRVVTRUFERFIpIGZhaWxlZDogJXMiLAorCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKKwkJLyogdHJ5IHRvIGNvbnRpbnVlIGFueXdheSAqLworCX0KKwogCWlmIChmY250bChzcnYtPmZkLCBGX1NFVEZMLCBPX05PTkJMT0NLKSA8IDApCiAJCWdvdG8gZmFpbDsKIAlpZiAocG9ydCA8IDApCmRpZmYgLS1naXQgYS9zcmMvd3BzL2h0dHByZWFkLmMgYi9zcmMvd3BzL2h0dHByZWFkLmMKaW5kZXggYWQ0ZjRhMS4uMmYwOGYzNyAxMDA2NDQKLS0tIGEvc3JjL3dwcy9odHRwcmVhZC5jCisrKyBiL3NyYy93cHMvaHR0cHJlYWQuYwpAQCAtNjcsOCArNjcsNiBAQAogCWludCB0aW1lb3V0X3NlY29uZHM7ICAgICAgICAgICAgLyogMCBvciB0b3RhbCBkdXJhdGlvbiB0aW1lb3V0IHBlcmlvZCAqLwogCiAJLyogZHluYW1pY2FsbHkgdXNlZCBpbmZvcm1hdGlvbiBmb2xsb3dzICovCi0JaW50IHNkX3JlZ2lzdGVyZWQ7ICAgICAgLyogbm9uemVybyBpZiB3ZSBuZWVkIHRvIHVucmVnaXN0ZXIgc29ja2V0ICovCi0JaW50IHRvX3JlZ2lzdGVyZWQ7ICAgICAgLyogbm9uemVybyBpZiB3ZSBuZWVkIHRvIHVucmVnaXN0ZXIgdGltZW91dCAqLwogCiAJaW50IGdvdF9oZHI7ICAgICAgICAgICAgLyogbm9uemVybyB3aGVuIGhlYWRlciBpcyBmaW5hbGl6ZWQgKi8KIAljaGFyIGhkcltIVFRQUkVBRF9IRUFERVJfTUFYX1NJWkUrMV07ICAgLyogaGVhZGVycyBzdG9yZWQgaGVyZSAqLwpAQCAtMTI5LDE5ICsxMjcsNiBAQAogfQogCiAKLS8qIGNvbnZlcnQgaGV4IHRvIGJpbmFyeQotICogUmVxdWlyZXMgdGhhdCBjIGhhdmUgYmVlbiBwcmV2aW91c2x5IHRlc3RlZCB0cnVlIHdpdGggaXN4ZGlnaXQoKS4KLSAqLwotc3RhdGljIGludCBoZXhfdmFsdWUoaW50IGMpCi17Ci0JaWYgKGlzZGlnaXQoYykpCi0JCXJldHVybiBjIC0gJzAnOwotCWlmIChpc2xvd2VyKGMpKQotCQlyZXR1cm4gMTAgKyBjIC0gJ2EnOwotCXJldHVybiAxMCArIGMgLSAnQSc7Ci19Ci0KLQogc3RhdGljIHZvaWQgaHR0cHJlYWRfdGltZW91dF9oYW5kbGVyKHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfY3R4KTsKIAogLyogaHR0cHJlYWRfZGVzdHJveSAtLSBpZiBoIGlzIG5vbi1OVUxMLCBjbGVhbiB1cApAQCAtMTU2LDEyICsxNDEsOCBAQAogCWlmICghaCkKIAkJcmV0dXJuOwogCi0JaWYgKGgtPnRvX3JlZ2lzdGVyZWQpCi0JCWVsb29wX2NhbmNlbF90aW1lb3V0KGh0dHByZWFkX3RpbWVvdXRfaGFuZGxlciwgTlVMTCwgaCk7Ci0JaC0+dG9fcmVnaXN0ZXJlZCA9IDA7Ci0JaWYgKGgtPnNkX3JlZ2lzdGVyZWQpCi0JCWVsb29wX3VucmVnaXN0ZXJfc29jayhoLT5zZCwgRVZFTlRfVFlQRV9SRUFEKTsKLQloLT5zZF9yZWdpc3RlcmVkID0gMDsKKwllbG9vcF9jYW5jZWxfdGltZW91dChodHRwcmVhZF90aW1lb3V0X2hhbmRsZXIsIE5VTEwsIGgpOworCWVsb29wX3VucmVnaXN0ZXJfc29jayhoLT5zZCwgRVZFTlRfVFlQRV9SRUFEKTsKIAlvc19mcmVlKGgtPmJvZHkpOwogCW9zX2ZyZWUoaC0+dXJpKTsKIAlvc19tZW1zZXQoaCwgMCwgc2l6ZW9mKCpoKSk7ICAvKiBhaWQgZGVidWdnaW5nICovCkBAIC0xNzYsNyArMTU3LDYgQEAKIHsKIAlzdHJ1Y3QgaHR0cHJlYWQgKmggPSB1c2VyX2N0eDsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgImh0dHByZWFkIHRpbWVvdXQgKCVwKSIsIGgpOwotCWgtPnRvX3JlZ2lzdGVyZWQgPSAwOyAgIC8qIGlzIHNlbGYtY2FuY2VsbGluZyAqLwogCSgqaC0+Y2IpKGgsIGgtPmNvb2tpZSwgSFRUUFJFQURfRVZFTlRfVElNRU9VVCk7CiB9CiAKQEAgLTI5NSw4ICsyNzUsNyBAQAogCQkJaW50IGMgPSAqcmF3dXJpOwogCQkJaWYgKGMgPT0gJyUnICYmCiAJCQkgICAgaXN4ZGlnaXQocmF3dXJpWzFdKSAmJiBpc3hkaWdpdChyYXd1cmlbMl0pKSB7Ci0JCQkJKnVyaSsrID0gKGhleF92YWx1ZShyYXd1cmlbMV0pIDw8IDQpIHwKLQkJCQkJaGV4X3ZhbHVlKHJhd3VyaVsyXSk7CisJCQkJKnVyaSsrID0gaGV4MmJ5dGUocmF3dXJpICsgMSk7CiAJCQkJcmF3dXJpICs9IDM7CiAJCQl9IGVsc2UgewogCQkJCSp1cmkrKyA9IGM7CkBAIC00MzQsOCArNDEzLDggQEAKIAkJICovCiAJCWlmIChodHRwcmVhZF9kZWJ1ZyA+PSAxMCkKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiaHR0cHJlYWQgb2sgZW9mKCVwKSIsIGgpOwotCQkJaC0+Z290X2JvZHkgPSAxOwotCQkJZ290byBnb3RfZmlsZTsKKwkJaC0+Z290X2JvZHkgPSAxOworCQlnb3RvIGdvdF9maWxlOwogCX0KIAlyYnAgPSByZWFkYnVmOwogCkBAIC02MzgsNyArNjE3LDYgQEAKIAkJICogV2UgZG8gTk9UIHN1cHBvcnQgdHJhaWxlcnMgZXhjZXB0IHRvIHNraXAgdGhlbSAtLQogCQkgKiB0aGlzIGlzIHN1cHBvcnRlZCAoZ2VuZXJhbGx5KSBieSB0aGUgaHR0cCBzcGVjLgogCQkgKi8KLQkJYmJwID0gaC0+Ym9keSArIGgtPmJvZHlfbmJ5dGVzOwogCQlmb3IgKDs7KSB7CiAJCQlpbnQgYzsKIAkJCWlmIChucmVhZCA8PSAwKQpAQCAtNzAzLDE1ICs2ODEsMTEgQEAKIAkgKiBhbmQganVzdCBpbiBjYXNlIHNvbWVob3cgd2UgZG9uJ3QgZ2V0IGRlc3Ryb3llZCByaWdodCBhd2F5LAogCSAqIHVucmVnaXN0ZXIgbm93LgogCSAqLwotCWlmIChoLT5zZF9yZWdpc3RlcmVkKQotCQllbG9vcF91bnJlZ2lzdGVyX3NvY2soaC0+c2QsIEVWRU5UX1RZUEVfUkVBRCk7Ci0JaC0+c2RfcmVnaXN0ZXJlZCA9IDA7CisJZWxvb3BfdW5yZWdpc3Rlcl9zb2NrKGgtPnNkLCBFVkVOVF9UWVBFX1JFQUQpOwogCS8qIFRoZSBhcHBsaWNhdGlvbiBjYW4gZGVzdHJveSB1cyB3aGVuZXZlciB0aGV5IGZlZWwgbGlrZS4uLgogCSAqIGNhbmNlbCB0aW1lb3V0LgogCSAqLwotCWlmIChoLT50b19yZWdpc3RlcmVkKQotCQllbG9vcF9jYW5jZWxfdGltZW91dChodHRwcmVhZF90aW1lb3V0X2hhbmRsZXIsIE5VTEwsIGgpOwotCWgtPnRvX3JlZ2lzdGVyZWQgPSAwOworCWVsb29wX2NhbmNlbF90aW1lb3V0KGh0dHByZWFkX3RpbWVvdXRfaGFuZGxlciwgTlVMTCwgaCk7CiAJKCpoLT5jYikoaCwgaC0+Y29va2llLCBIVFRQUkVBRF9FVkVOVF9GSUxFX1JFQURZKTsKIH0KIApAQCAtNzQ5LDIxICs3MjMsMTcgQEAKIAloLT5tYXhfYnl0ZXMgPSBtYXhfYnl0ZXM7CiAJaC0+dGltZW91dF9zZWNvbmRzID0gdGltZW91dF9zZWNvbmRzOwogCi0JaWYgKHRpbWVvdXRfc2Vjb25kcyA+IDApIHsKLQkJaWYgKGVsb29wX3JlZ2lzdGVyX3RpbWVvdXQodGltZW91dF9zZWNvbmRzLCAwLAotCQkJCQkgICBodHRwcmVhZF90aW1lb3V0X2hhbmRsZXIsCi0JCQkJCSAgIE5VTEwsIGgpKSB7Ci0JCQkvKiBObyB3YXkgdG8gcmVjb3ZlciAoZnJvbSBtYWxsb2MgZmFpbHVyZSkgKi8KLQkJCWdvdG8gZmFpbDsKLQkJfQotCQloLT50b19yZWdpc3RlcmVkID0gMTsKKwlpZiAodGltZW91dF9zZWNvbmRzID4gMCAmJgorCSAgICBlbG9vcF9yZWdpc3Rlcl90aW1lb3V0KHRpbWVvdXRfc2Vjb25kcywgMCwKKwkJCQkgICBodHRwcmVhZF90aW1lb3V0X2hhbmRsZXIsIE5VTEwsIGgpKSB7CisJCS8qIE5vIHdheSB0byByZWNvdmVyIChmcm9tIG1hbGxvYyBmYWlsdXJlKSAqLworCQlnb3RvIGZhaWw7CiAJfQogCWlmIChlbG9vcF9yZWdpc3Rlcl9zb2NrKHNkLCBFVkVOVF9UWVBFX1JFQUQsIGh0dHByZWFkX3JlYWRfaGFuZGxlciwKIAkJCQlOVUxMLCBoKSkgewogCQkvKiBObyB3YXkgdG8gcmVjb3ZlciAoZnJvbSBtYWxsb2MgZmFpbHVyZSkgKi8KIAkJZ290byBmYWlsOwogCX0KLQloLT5zZF9yZWdpc3RlcmVkID0gMTsKIAlyZXR1cm4gaDsKIAogZmFpbDoKZGlmZiAtLWdpdCBhL3NyYy93cHMvbmRlZi5jIGIvc3JjL3dwcy9uZGVmLmMKaW5kZXggOTY2ODVkMi4uZDQ1ZGZjOCAxMDA2NDQKLS0tIGEvc3JjL3dwcy9uZGVmLmMKKysrIGIvc3JjL3dwcy9uZGVmLmMKQEAgLTMwLDYgKzMwLDcgQEAKIH07CiAKIHN0YXRpYyBjaGFyIHdpZmlfaGFuZG92ZXJfdHlwZVtdID0gImFwcGxpY2F0aW9uL3ZuZC53ZmEud3NjIjsKK3N0YXRpYyBjaGFyIHAycF9oYW5kb3Zlcl90eXBlW10gPSAiYXBwbGljYXRpb24vdm5kLndmYS5wMnAiOwogCiBzdGF0aWMgaW50IG5kZWZfcGFyc2VfcmVjb3JkKGNvbnN0IHU4ICpkYXRhLCB1MzIgc2l6ZSwKIAkJCSAgICAgc3RydWN0IG5kZWZfcmVjb3JkICpyZWNvcmQpCkBAIC0xNDcsNyArMTQ4LDggQEAKIAogc3RhdGljIGludCB3aWZpX2ZpbHRlcihzdHJ1Y3QgbmRlZl9yZWNvcmQgKnJlY29yZCkKIHsKLQlpZiAocmVjb3JkLT50eXBlX2xlbmd0aCAhPSBvc19zdHJsZW4od2lmaV9oYW5kb3Zlcl90eXBlKSkKKwlpZiAocmVjb3JkLT50eXBlID09IE5VTEwgfHwKKwkgICAgcmVjb3JkLT50eXBlX2xlbmd0aCAhPSBvc19zdHJsZW4od2lmaV9oYW5kb3Zlcl90eXBlKSkKIAkJcmV0dXJuIDA7CiAJaWYgKG9zX21lbWNtcChyZWNvcmQtPnR5cGUsIHdpZmlfaGFuZG92ZXJfdHlwZSwKIAkJICAgICAgb3Nfc3RybGVuKHdpZmlfaGFuZG92ZXJfdHlwZSkpICE9IDApCkBAIC0xNzAsODUgKzE3MiwyNyBAQAogfQogCiAKLXN0cnVjdCB3cGFidWYgKiBuZGVmX2J1aWxkX3dpZmlfaGMoaW50IGJlZ2luKQorc3RhdGljIGludCBwMnBfZmlsdGVyKHN0cnVjdCBuZGVmX3JlY29yZCAqcmVjb3JkKQogewotCXN0cnVjdCB3cGFidWYgKmhjLCAqY2FycmllcjsKLQotCWNhcnJpZXIgPSB3cGFidWZfYWxsb2MoMiArIG9zX3N0cmxlbih3aWZpX2hhbmRvdmVyX3R5cGUpKTsKLQlpZiAoY2FycmllciA9PSBOVUxMKQotCQlyZXR1cm4gTlVMTDsKLQl3cGFidWZfcHV0X3U4KGNhcnJpZXIsIDB4MDIpOyAvKiBDYXJyaWVyIFR5cGUgRm9ybWF0ICovCi0Jd3BhYnVmX3B1dF91OChjYXJyaWVyLCBvc19zdHJsZW4od2lmaV9oYW5kb3Zlcl90eXBlKSk7Ci0Jd3BhYnVmX3B1dF9zdHIoY2Fycmllciwgd2lmaV9oYW5kb3Zlcl90eXBlKTsKLQotCWhjID0gbmRlZl9idWlsZF9yZWNvcmQoKGJlZ2luID8gRkxBR19NRVNTQUdFX0JFR0lOIDogMCkgfAotCQkJICAgICAgIEZMQUdfTUVTU0FHRV9FTkQgfCBGTEFHX1RORl9ORkNfRk9SVU0sICJIYyIsIDIsCi0JCQkgICAgICAgIjAiLCAxLCBjYXJyaWVyKTsKLQl3cGFidWZfZnJlZShjYXJyaWVyKTsKLQotCXJldHVybiBoYzsKKwlpZiAocmVjb3JkLT50eXBlID09IE5VTEwgfHwKKwkgICAgcmVjb3JkLT50eXBlX2xlbmd0aCAhPSBvc19zdHJsZW4ocDJwX2hhbmRvdmVyX3R5cGUpKQorCQlyZXR1cm4gMDsKKwlpZiAob3NfbWVtY21wKHJlY29yZC0+dHlwZSwgcDJwX2hhbmRvdmVyX3R5cGUsCisJCSAgICAgIG9zX3N0cmxlbihwMnBfaGFuZG92ZXJfdHlwZSkpICE9IDApCisJCXJldHVybiAwOworCXJldHVybiAxOwogfQogCiAKLXN0cnVjdCB3cGFidWYgKiBuZGVmX2J1aWxkX3dpZmlfaHIodm9pZCkKK3N0cnVjdCB3cGFidWYgKiBuZGVmX3BhcnNlX3AycChjb25zdCBzdHJ1Y3Qgd3BhYnVmICpidWYpCiB7Ci0Jc3RydWN0IHdwYWJ1ZiAqcm4sICpjciwgKmFjX3BheWxvYWQsICphYywgKmhyX3BheWxvYWQsICpocjsKLQlzdHJ1Y3Qgd3BhYnVmICpoYzsKKwlyZXR1cm4gbmRlZl9wYXJzZV9yZWNvcmRzKGJ1ZiwgcDJwX2ZpbHRlcik7Cit9CiAKLQlybiA9IHdwYWJ1Zl9hbGxvYygyKTsKLQlpZiAocm4gPT0gTlVMTCkKLQkJcmV0dXJuIE5VTEw7Ci0Jd3BhYnVmX3B1dF9iZTE2KHJuLCBvc19yYW5kb20oKSAmIDB4ZmZmZik7CiAKLQljciA9IG5kZWZfYnVpbGRfcmVjb3JkKEZMQUdfTUVTU0FHRV9CRUdJTiB8IEZMQUdfVE5GX05GQ19GT1JVTSwgImNyIiwgMiwKLQkJCSAgICAgICBOVUxMLCAwLCBybik7Ci0Jd3BhYnVmX2ZyZWUocm4pOwotCi0JaWYgKGNyID09IE5VTEwpCi0JCXJldHVybiBOVUxMOwotCi0JYWNfcGF5bG9hZCA9IHdwYWJ1Zl9hbGxvYyg0KTsKLQlpZiAoYWNfcGF5bG9hZCA9PSBOVUxMKSB7Ci0JCXdwYWJ1Zl9mcmVlKGNyKTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCXdwYWJ1Zl9wdXRfdTgoYWNfcGF5bG9hZCwgMHgwMSk7IC8qIENhcnJpZXIgRmxhZ3M6IENSUz0xICJhY3RpdmUiICovCi0Jd3BhYnVmX3B1dF91OChhY19wYXlsb2FkLCAweDAxKTsgLyogQ2FycmllciBEYXRhIFJlZmVyZW5jZSBMZW5ndGggKi8KLQl3cGFidWZfcHV0X3U4KGFjX3BheWxvYWQsICcwJyk7IC8qIENhcnJpZXIgRGF0YSBSZWZlcmVuY2U6ICIwIiAqLwotCXdwYWJ1Zl9wdXRfdTgoYWNfcGF5bG9hZCwgMCk7IC8qIEF1eCBEYXRhIFJlZmVyZW5jZSBDb3VudCAqLwotCi0JYWMgPSBuZGVmX2J1aWxkX3JlY29yZChGTEFHX01FU1NBR0VfRU5EIHwgRkxBR19UTkZfTkZDX0ZPUlVNLCAiYWMiLCAyLAotCQkJICAgICAgIE5VTEwsIDAsIGFjX3BheWxvYWQpOwotCXdwYWJ1Zl9mcmVlKGFjX3BheWxvYWQpOwotCWlmIChhYyA9PSBOVUxMKSB7Ci0JCXdwYWJ1Zl9mcmVlKGNyKTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCi0JaHJfcGF5bG9hZCA9IHdwYWJ1Zl9hbGxvYygxICsgd3BhYnVmX2xlbihjcikgKyB3cGFidWZfbGVuKGFjKSk7Ci0JaWYgKGhyX3BheWxvYWQgPT0gTlVMTCkgewotCQl3cGFidWZfZnJlZShjcik7Ci0JCXdwYWJ1Zl9mcmVlKGFjKTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCi0Jd3BhYnVmX3B1dF91OChocl9wYXlsb2FkLCAweDEyKTsgLyogQ29ubmVjdGlvbiBIYW5kb3ZlciBWZXJzaW9uIDEuMiAqLwotCXdwYWJ1Zl9wdXRfYnVmKGhyX3BheWxvYWQsIGNyKTsKLQl3cGFidWZfcHV0X2J1Zihocl9wYXlsb2FkLCBhYyk7Ci0Jd3BhYnVmX2ZyZWUoY3IpOwotCXdwYWJ1Zl9mcmVlKGFjKTsKLQotCWhyID0gbmRlZl9idWlsZF9yZWNvcmQoRkxBR19NRVNTQUdFX0JFR0lOIHwgRkxBR19UTkZfTkZDX0ZPUlVNLCAiSHIiLCAyLAotCQkJICAgICAgIE5VTEwsIDAsIGhyX3BheWxvYWQpOwotCXdwYWJ1Zl9mcmVlKGhyX3BheWxvYWQpOwotCWlmIChociA9PSBOVUxMKQotCQlyZXR1cm4gTlVMTDsKLQotCWhjID0gbmRlZl9idWlsZF93aWZpX2hjKDApOwotCWlmIChoYyA9PSBOVUxMKSB7Ci0JCXdwYWJ1Zl9mcmVlKGhyKTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCi0JcmV0dXJuIHdwYWJ1Zl9jb25jYXQoaHIsIGhjKTsKK3N0cnVjdCB3cGFidWYgKiBuZGVmX2J1aWxkX3AycChjb25zdCBzdHJ1Y3Qgd3BhYnVmICpidWYpCit7CisJcmV0dXJuIG5kZWZfYnVpbGRfcmVjb3JkKEZMQUdfTUVTU0FHRV9CRUdJTiB8IEZMQUdfTUVTU0FHRV9FTkQgfAorCQkJCSBGTEFHX1RORl9SRkMyMDQ2LCBwMnBfaGFuZG92ZXJfdHlwZSwKKwkJCQkgb3Nfc3RybGVuKHAycF9oYW5kb3Zlcl90eXBlKSwgTlVMTCwgMCwgYnVmKTsKIH0KZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzLmMgYi9zcmMvd3BzL3dwcy5jCmluZGV4IDIyZDdlZWEuLmIwZjY4ODcgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzLmMKKysrIGIvc3JjL3dwcy93cHMuYwpAQCAtMTgsNiArMTgsNyBAQAogI2lmZGVmIENPTkZJR19XUFNfVEVTVElORwogaW50IHdwc192ZXJzaW9uX251bWJlciA9IDB4MjA7CiBpbnQgd3BzX3Rlc3RpbmdfZHVtbXlfY3JlZCA9IDA7CitpbnQgd3BzX2NvcnJ1cHRfcGtoYXNoID0gMDsKICNlbmRpZiAvKiBDT05GSUdfV1BTX1RFU1RJTkcgKi8KIAogCkBAIC01OCw2ICs1OSwxMCBAQAogCX0KIAogI2lmZGVmIENPTkZJR19XUFNfTkZDCisJaWYgKGNmZy0+cGluID09IE5VTEwgJiYKKwkgICAgY2ZnLT5kZXZfcHdfaWQgPT0gREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSKQorCQlkYXRhLT5kZXZfcHdfaWQgPSBjZmctPmRldl9wd19pZDsKKwogCWlmIChjZmctPndwcy0+YXAgJiYgIWNmZy0+cmVnaXN0cmFyICYmIGNmZy0+d3BzLT5hcF9uZmNfZGV2X3B3X2lkKSB7CiAJCS8qIEtlZXAgQVAgUElOIGFzIGFsdGVybmF0aXZlIERldmljZSBQYXNzd29yZCAqLwogCQlkYXRhLT5hbHRfZGV2X3B3X2lkID0gZGF0YS0+ZGV2X3B3X2lkOwpAQCAtODQsNyArODksNyBAQAogCWlmIChjZmctPnBiYykgewogCQkvKiBVc2Ugc3BlY2lhbCBQSU4gJzAwMDAwMDAwJyBmb3IgUEJDICovCiAJCWRhdGEtPmRldl9wd19pZCA9IERFVl9QV19QVVNIQlVUVE9OOwotCQlvc19mcmVlKGRhdGEtPmRldl9wYXNzd29yZCk7CisJCWJpbl9jbGVhcl9mcmVlKGRhdGEtPmRldl9wYXNzd29yZCwgZGF0YS0+ZGV2X3Bhc3N3b3JkX2xlbik7CiAJCWRhdGEtPmRldl9wYXNzd29yZCA9ICh1OCAqKSBvc19zdHJkdXAoIjAwMDAwMDAwIik7CiAJCWlmIChkYXRhLT5kZXZfcGFzc3dvcmQgPT0gTlVMTCkgewogCQkJb3NfZnJlZShkYXRhKTsKQEAgLTExNyw3ICsxMjIsOCBAQAogCQlkYXRhLT5uZXdfYXBfc2V0dGluZ3MgPQogCQkJb3NfbWFsbG9jKHNpemVvZigqZGF0YS0+bmV3X2FwX3NldHRpbmdzKSk7CiAJCWlmIChkYXRhLT5uZXdfYXBfc2V0dGluZ3MgPT0gTlVMTCkgewotCQkJb3NfZnJlZShkYXRhLT5kZXZfcGFzc3dvcmQpOworCQkJYmluX2NsZWFyX2ZyZWUoZGF0YS0+ZGV2X3Bhc3N3b3JkLAorCQkJCSAgICAgICBkYXRhLT5kZXZfcGFzc3dvcmRfbGVuKTsKIAkJCW9zX2ZyZWUoZGF0YSk7CiAJCQlyZXR1cm4gTlVMTDsKIAkJfQpAQCAtMTMzLDYgKzEzOSwxMiBAQAogCWRhdGEtPnVzZV9wc2tfa2V5ID0gY2ZnLT51c2VfcHNrX2tleTsKIAlkYXRhLT5wYmNfaW5fbTEgPSBjZmctPnBiY19pbl9tMTsKIAorCWlmIChjZmctPnBlZXJfcHVia2V5X2hhc2gpIHsKKwkJb3NfbWVtY3B5KGRhdGEtPnBlZXJfcHVia2V5X2hhc2gsIGNmZy0+cGVlcl9wdWJrZXlfaGFzaCwKKwkJCSAgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCQlkYXRhLT5wZWVyX3B1YmtleV9oYXNoX3NldCA9IDE7CisJfQorCiAJcmV0dXJuIGRhdGE7CiB9CiAKQEAgLTE2MiwxMyArMTc0LDEyIEBACiAJd3BhYnVmX2ZyZWUoZGF0YS0+ZGhfcHVia2V5X2UpOwogCXdwYWJ1Zl9mcmVlKGRhdGEtPmRoX3B1YmtleV9yKTsKIAl3cGFidWZfZnJlZShkYXRhLT5sYXN0X21zZyk7Ci0Jb3NfZnJlZShkYXRhLT5kZXZfcGFzc3dvcmQpOwotCW9zX2ZyZWUoZGF0YS0+YWx0X2Rldl9wYXNzd29yZCk7Ci0Jb3NfZnJlZShkYXRhLT5uZXdfcHNrKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLT5kZXZfcGFzc3dvcmQsIGRhdGEtPmRldl9wYXNzd29yZF9sZW4pOworCWJpbl9jbGVhcl9mcmVlKGRhdGEtPmFsdF9kZXZfcGFzc3dvcmQsIGRhdGEtPmFsdF9kZXZfcGFzc3dvcmRfbGVuKTsKKwliaW5fY2xlYXJfZnJlZShkYXRhLT5uZXdfcHNrLCBkYXRhLT5uZXdfcHNrX2xlbik7CiAJd3BzX2RldmljZV9kYXRhX2ZyZWUoJmRhdGEtPnBlZXJfZGV2KTsKLQlvc19mcmVlKGRhdGEtPm5ld19hcF9zZXR0aW5ncyk7CisJYmluX2NsZWFyX2ZyZWUoZGF0YS0+bmV3X2FwX3NldHRpbmdzLCBzaXplb2YoKmRhdGEtPm5ld19hcF9zZXR0aW5ncykpOwogCWRoNV9mcmVlKGRhdGEtPmRoX2N0eCk7Ci0Jb3NfZnJlZShkYXRhLT5uZmNfcHdfdG9rZW4pOwogCW9zX2ZyZWUoZGF0YSk7CiB9CiAKQEAgLTUwMSwxMyArNTEyLDExIEBACiAJICAgIHdwc19idWlsZF9hc3NvY19zdGF0ZShOVUxMLCBpZSkgfHwKIAkgICAgd3BzX2J1aWxkX2NvbmZpZ19lcnJvcihpZSwgV1BTX0NGR19OT19FUlJPUikgfHwKIAkgICAgd3BzX2J1aWxkX2Rldl9wYXNzd29yZF9pZChpZSwgcHdfaWQpIHx8Ci0jaWZkZWYgQ09ORklHX1dQUzIKIAkgICAgd3BzX2J1aWxkX21hbnVmYWN0dXJlcihkZXYsIGllKSB8fAogCSAgICB3cHNfYnVpbGRfbW9kZWxfbmFtZShkZXYsIGllKSB8fAogCSAgICB3cHNfYnVpbGRfbW9kZWxfbnVtYmVyKGRldiwgaWUpIHx8CiAJICAgIHdwc19idWlsZF9kZXZfbmFtZShkZXYsIGllKSB8fAogCSAgICB3cHNfYnVpbGRfd2ZhX2V4dChpZSwgcmVxX3R5cGUgPT0gV1BTX1JFUV9FTlJPTExFRSwgTlVMTCwgMCkgfHwKLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogCSAgICB3cHNfYnVpbGRfcmVxX2Rldl90eXBlKGRldiwgaWUsIG51bV9yZXFfZGV2X3R5cGVzLCByZXFfZGV2X3R5cGVzKQogCSAgICB8fAogCSAgICB3cHNfYnVpbGRfc2Vjb25kYXJ5X2Rldl90eXBlKGRldiwgaWUpCkBAIC01MTYsMTMgKzUyNSw2IEBACiAJCXJldHVybiBOVUxMOwogCX0KIAotI2lmbmRlZiBDT05GSUdfV1BTMgotCWlmIChkZXYtPnAycCAmJiB3cHNfYnVpbGRfZGV2X25hbWUoZGV2LCBpZSkpIHsKLQkJd3BhYnVmX2ZyZWUoaWUpOwotCQlyZXR1cm4gTlVMTDsKLQl9Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KLQogCXJldHVybiB3cHNfaWVfZW5jYXBzdWxhdGUoaWUpOwogfQogCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwcy5oIGIvc3JjL3dwcy93cHMuaAppbmRleCAxNTEzN2E4Li4xOTJkMjgzIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwcy5oCisrKyBiL3NyYy93cHMvd3BzLmgKQEAgLTQyLDcgKzQyLDYgQEAKICAqIEBjcmVkX2F0dHI6IFVucGFyc2VkIENyZWRlbnRpYWwgYXR0cmlidXRlIGRhdGEgKHVzZWQgb25seSBpbiBjcmVkX2NiKCkpOwogICoJdGhpcyBtYXkgYmUgJU5VTEwsIGlmIG5vdCB1c2VkCiAgKiBAY3JlZF9hdHRyX2xlbjogTGVuZ3RoIG9mIGNyZWRfYXR0ciBpbiBvY3RldHMKLSAqIEBhcF9jaGFubmVsOiBBUCBjaGFubmVsCiAgKi8KIHN0cnVjdCB3cHNfY3JlZGVudGlhbCB7CiAJdTggc3NpZFszMl07CkBAIC01NSw3ICs1NCw2IEBACiAJdTggbWFjX2FkZHJbRVRIX0FMRU5dOwogCWNvbnN0IHU4ICpjcmVkX2F0dHI7CiAJc2l6ZV90IGNyZWRfYXR0cl9sZW47Ci0JdTE2IGFwX2NoYW5uZWw7CiB9OwogCiAjZGVmaW5lIFdQU19ERVZfVFlQRV9MRU4gOApAQCAtMTgzLDYgKzE4MSwxMSBAQAogCSAqIFBCQyB3aXRoIHRoZSBBUC4KIAkgKi8KIAlpbnQgcGJjX2luX20xOworCisJLyoqCisJICogcGVlcl9wdWJrZXlfaGFzaCAtIFBlZXIgcHVibGljIGtleSBoYXNoIG9yICVOVUxMIGlmIG5vdCBrbm93bgorCSAqLworCWNvbnN0IHU4ICpwZWVyX3B1YmtleV9oYXNoOwogfTsKIAogc3RydWN0IHdwc19kYXRhICogd3BzX2luaXQoY29uc3Qgc3RydWN0IHdwc19jb25maWcgKmNmZyk7CkBAIC02NjUsNiArNjY4LDE2IEBACiAJdTE2IGF1dGhfdHlwZXM7CiAKIAkvKioKKwkgKiBlbmNyX3R5cGVzIC0gQ3VycmVudCBBUCBlbmNyeXB0aW9uIHR5cGUgKFdQU19FTkNSXyopCisJICovCisJdTE2IGFwX2VuY3JfdHlwZTsKKworCS8qKgorCSAqIGFwX2F1dGhfdHlwZSAtIEN1cnJlbnQgQVAgYXV0aGVudGljYXRpb24gdHlwZXMgKFdQU19BVVRIXyopCisJICovCisJdTE2IGFwX2F1dGhfdHlwZTsKKworCS8qKgogCSAqIG5ldHdvcmtfa2V5IC0gVGhlIGN1cnJlbnQgTmV0d29yayBLZXkgKFBTSykgb3IgJU5VTEwgdG8gZ2VuZXJhdGUgbmV3CiAJICoKIAkgKiBJZiAlTlVMTCwgUmVnaXN0cmFyIHdpbGwgZ2VuZXJhdGUgcGVyLWRldmljZSBQU0suIEluIGFkZGl0aW9uLCBBUApAQCAtODAxLDcgKzgxNCw4IEBACiAJCQkgICAgc3RydWN0IHdwc19jcmVkZW50aWFsICpjcmVkKTsKIGludCB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcHdfdG9rZW4oc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywKIAkJCQkgICBjb25zdCB1OCAqcHVia2V5X2hhc2gsIHUxNiBwd19pZCwKLQkJCQkgICBjb25zdCB1OCAqZGV2X3B3LCBzaXplX3QgZGV2X3B3X2xlbik7CisJCQkJICAgY29uc3QgdTggKmRldl9wdywgc2l6ZV90IGRldl9wd19sZW4sCisJCQkJICAgaW50IHBrX2hhc2hfcHJvdmlkZWRfb29iKTsKIGludCB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcGFzc3dvcmRfdG9rZW4oc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywKIAkJCQkJIGNvbnN0IHU4ICpvb2JfZGV2X3B3LAogCQkJCQkgc2l6ZV90IG9vYl9kZXZfcHdfbGVuKTsKQEAgLTgxNSw3ICs4MjksOCBAQAogaW50IHdwc19waW5fc3RyX3ZhbGlkKGNvbnN0IGNoYXIgKnBpbik7CiB2b2lkIHdwc19mcmVlX3BlbmRpbmdfbXNncyhzdHJ1Y3QgdXBucF9wZW5kaW5nX21lc3NhZ2UgKm1zZ3MpOwogCi1zdHJ1Y3Qgd3BhYnVmICogd3BzX2dldF9vb2JfY3JlZChzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcyk7CitzdHJ1Y3Qgd3BhYnVmICogd3BzX2dldF9vb2JfY3JlZChzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgaW50IHJmX2JhbmQsCisJCQkJIGludCBjaGFubmVsKTsKIGludCB3cHNfb29iX3VzZV9jcmVkKHN0cnVjdCB3cHNfY29udGV4dCAqd3BzLCBzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgKmF0dHIpOwogaW50IHdwc19hdHRyX3RleHQoc3RydWN0IHdwYWJ1ZiAqZGF0YSwgY2hhciAqYnVmLCBjaGFyICplbmQpOwogY29uc3QgY2hhciAqIHdwc19laV9zdHIoZW51bSB3cHNfZXJyb3JfaW5kaWNhdGlvbiBlaSk7CkBAIC04MzksNiArODU0LDkgQEAKIAkJCQkJICAgICAgc3RydWN0IHdwc19jcmVkZW50aWFsICpjcmVkKTsKIHN0cnVjdCB3cGFidWYgKiB3cHNfZXJfbmZjX2NvbmZpZ190b2tlbihzdHJ1Y3Qgd3BzX2VyICplciwgY29uc3QgdTggKnV1aWQsCiAJCQkJCWNvbnN0IHU4ICphZGRyKTsKK3N0cnVjdCB3cGFidWYgKiB3cHNfZXJfbmZjX2hhbmRvdmVyX3NlbChzdHJ1Y3Qgd3BzX2VyICplciwKKwkJCQkJc3RydWN0IHdwc19jb250ZXh0ICp3cHMsIGNvbnN0IHU4ICp1dWlkLAorCQkJCQljb25zdCB1OCAqYWRkciwgc3RydWN0IHdwYWJ1ZiAqcHVia2V5KTsKIAogaW50IHdwc19kZXZfdHlwZV9zdHIyYmluKGNvbnN0IGNoYXIgKnN0ciwgdTggZGV2X3R5cGVbV1BTX0RFVl9UWVBFX0xFTl0pOwogY2hhciAqIHdwc19kZXZfdHlwZV9iaW4yc3RyKGNvbnN0IHU4IGRldl90eXBlW1dQU19ERVZfVFlQRV9MRU5dLCBjaGFyICpidWYsCkBAIC04NTAsMTUgKzg2OCwyNyBAQAogCQkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpkZXZfcHcpOwogc3RydWN0IHdwYWJ1ZiAqIHdwc19uZmNfdG9rZW5fYnVpbGQoaW50IG5kZWYsIGludCBpZCwgc3RydWN0IHdwYWJ1ZiAqcHVia2V5LAogCQkJCSAgICBzdHJ1Y3Qgd3BhYnVmICpkZXZfcHcpOworaW50IHdwc19uZmNfZ2VuX2RoKHN0cnVjdCB3cGFidWYgKipwdWJrZXksIHN0cnVjdCB3cGFidWYgKipwcml2a2V5KTsKIHN0cnVjdCB3cGFidWYgKiB3cHNfbmZjX3Rva2VuX2dlbihpbnQgbmRlZiwgaW50ICppZCwgc3RydWN0IHdwYWJ1ZiAqKnB1YmtleSwKIAkJCQkgIHN0cnVjdCB3cGFidWYgKipwcml2a2V5LAogCQkJCSAgc3RydWN0IHdwYWJ1ZiAqKmRldl9wdyk7CitzdHJ1Y3Qgd3BhYnVmICogd3BzX2J1aWxkX25mY19oYW5kb3Zlcl9yZXEoc3RydWN0IHdwc19jb250ZXh0ICpjdHgsCisJCQkJCSAgIHN0cnVjdCB3cGFidWYgKm5mY19kaF9wdWJrZXkpOworc3RydWN0IHdwYWJ1ZiAqIHdwc19idWlsZF9uZmNfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cHNfY29udGV4dCAqY3R4LAorCQkJCQkgICBzdHJ1Y3Qgd3BhYnVmICpuZmNfZGhfcHVia2V5LAorCQkJCQkgICBjb25zdCB1OCAqYnNzaWQsIGludCBmcmVxKTsKK3N0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfbmZjX2hhbmRvdmVyX3JlcV9wMnAoc3RydWN0IHdwc19jb250ZXh0ICpjdHgsCisJCQkJCSAgICAgICBzdHJ1Y3Qgd3BhYnVmICpuZmNfZGhfcHVia2V5KTsKK3N0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfbmZjX2hhbmRvdmVyX3NlbF9wMnAoc3RydWN0IHdwc19jb250ZXh0ICpjdHgsCisJCQkJCSAgICAgICBpbnQgbmZjX2Rldl9wd19pZCwKKwkJCQkJICAgICAgIHN0cnVjdCB3cGFidWYgKm5mY19kaF9wdWJrZXksCisJCQkJCSAgICAgICBzdHJ1Y3Qgd3BhYnVmICpuZmNfZGV2X3B3KTsKIAogLyogbmRlZi5jICovCiBzdHJ1Y3Qgd3BhYnVmICogbmRlZl9wYXJzZV93aWZpKGNvbnN0IHN0cnVjdCB3cGFidWYgKmJ1Zik7CiBzdHJ1Y3Qgd3BhYnVmICogbmRlZl9idWlsZF93aWZpKGNvbnN0IHN0cnVjdCB3cGFidWYgKmJ1Zik7Ci1zdHJ1Y3Qgd3BhYnVmICogbmRlZl9idWlsZF93aWZpX2hjKGludCBiZWdpbik7Ci1zdHJ1Y3Qgd3BhYnVmICogbmRlZl9idWlsZF93aWZpX2hyKHZvaWQpOworc3RydWN0IHdwYWJ1ZiAqIG5kZWZfcGFyc2VfcDJwKGNvbnN0IHN0cnVjdCB3cGFidWYgKmJ1Zik7CitzdHJ1Y3Qgd3BhYnVmICogbmRlZl9idWlsZF9wMnAoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYnVmKTsKIAogI2lmZGVmIENPTkZJR19XUFNfU1RSSUNUCiBpbnQgd3BzX3ZhbGlkYXRlX2JlYWNvbihjb25zdCBzdHJ1Y3Qgd3BhYnVmICp3cHNfaWUpOwpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfYXR0cl9idWlsZC5jIGIvc3JjL3dwcy93cHNfYXR0cl9idWlsZC5jCmluZGV4IGFjOWJiMWUuLmI2ODkzNTcgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX2F0dHJfYnVpbGQuYworKysgYi9zcmMvd3BzL3dwc19hdHRyX2J1aWxkLmMKQEAgLTM4LDggKzM4LDE1IEBACiAJCXdwcy0+d3BzLT5kaF9jdHggPSBOVUxMOwogCQlwdWJrZXkgPSB3cGFidWZfZHVwKHdwcy0+d3BzLT5kaF9wdWJrZXkpOwogI2lmZGVmIENPTkZJR19XUFNfTkZDCi0JfSBlbHNlIGlmICh3cHMtPmRldl9wd19pZCA+PSAweDEwICYmIHdwcy0+d3BzLT5hcCAmJgotCQkgICB3cHMtPmRldl9wd19pZCA9PSB3cHMtPndwcy0+YXBfbmZjX2Rldl9wd19pZCkgeworCX0gZWxzZSBpZiAoKHdwcy0+ZGV2X3B3X2lkID49IDB4MTAgfHwKKwkJICAgIHdwcy0+ZGV2X3B3X2lkID09IERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUikgJiYKKwkJICAgKHdwcy0+d3BzLT5hcCB8fAorCQkgICAgKHdwcy0+d3BzLT5hcF9uZmNfZGhfcHVia2V5ICYmCisJCSAgICAgd3BzLT53cHMtPmFwX25mY19kZXZfcHdfaWQgPT0KKwkJICAgICBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIgJiYKKwkJICAgICB3cHMtPmRldl9wd19pZCA9PSBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIpKSAmJgorCQkgICAod3BzLT5kZXZfcHdfaWQgPT0gd3BzLT53cHMtPmFwX25mY19kZXZfcHdfaWQgfHwKKwkJICAgIHdwcy0+d3BzLT5hcF9uZmNfZGhfcHVia2V5KSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVXNpbmcgTkZDIHBhc3N3b3JkIHRva2VuIERIIGtleXMiKTsKIAkJaWYgKHdwcy0+d3BzLT5hcF9uZmNfZGhfcHJpdmtleSA9PSBOVUxMKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKQEAgLTExOCw2ICsxMjUsOCBAQAogCiBpbnQgd3BzX2J1aWxkX3V1aWRfZShzdHJ1Y3Qgd3BhYnVmICptc2csIGNvbnN0IHU4ICp1dWlkKQogeworCWlmICh3cGFidWZfdGFpbHJvb20obXNnKSA8IDQgKyBXUFNfVVVJRF9MRU4pCisJCXJldHVybiAtMTsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogVVVJRC1FIik7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgQVRUUl9VVUlEX0UpOwogCXdwYWJ1Zl9wdXRfYmUxNihtc2csIFdQU19VVUlEX0xFTik7CkBAIC0xODMsNiArMTkyLDggQEAKIAkgKiBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSByZWFzb25zLiBUaGUgcmVhbCB2ZXJzaW9uIG5lZ290aWF0aW9uIGlzCiAJICogZG9uZSB3aXRoIFZlcnNpb24yLgogCSAqLworCWlmICh3cGFidWZfdGFpbHJvb20obXNnKSA8IDUpCisJCXJldHVybiAtMTsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogVmVyc2lvbiAoaGFyZGNvZGVkIDB4MTApIik7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgQVRUUl9WRVJTSU9OKTsKIAl3cGFidWZfcHV0X2JlMTYobXNnLCAxKTsKQEAgLTE5NCw5ICsyMDUsMTcgQEAKIGludCB3cHNfYnVpbGRfd2ZhX2V4dChzdHJ1Y3Qgd3BhYnVmICptc2csIGludCByZXFfdG9fZW5yb2xsLAogCQkgICAgICBjb25zdCB1OCAqYXV0aF9tYWNzLCBzaXplX3QgYXV0aF9tYWNzX2NvdW50KQogewotI2lmZGVmIENPTkZJR19XUFMyCiAJdTggKmxlbjsKIAorI2lmZGVmIENPTkZJR19XUFNfVEVTVElORworCWlmIChXUFNfVkVSU0lPTiA9PSAweDEwKQorCQlyZXR1cm4gMDsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX1RFU1RJTkcgKi8KKworCWlmICh3cGFidWZfdGFpbHJvb20obXNnKSA8CisJICAgIDcgKyAzICsgKHJlcV90b19lbnJvbGwgPyAzIDogMCkgKworCSAgICAoYXV0aF9tYWNzID8gMiArIGF1dGhfbWFjc19jb3VudCAqIEVUSF9BTEVOIDogMCkpCisJCXJldHVybiAtMTsKIAl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX1ZFTkRPUl9FWFQpOwogCWxlbiA9IHdwYWJ1Zl9wdXQobXNnLCAyKTsgLyogdG8gYmUgZmlsbGVkICovCiAJd3BhYnVmX3B1dF9iZTI0KG1zZywgV1BTX1ZFTkRPUl9JRF9XRkEpOwpAQCAtMjI2LDEwICsyNDUsMTEgQEAKIAl9CiAKIAlXUEFfUFVUX0JFMTYobGVuLCAodTggKikgd3BhYnVmX3B1dChtc2csIDApIC0gbGVuIC0gMik7Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIAogI2lmZGVmIENPTkZJR19XUFNfVEVTVElORwogCWlmIChXUFNfVkVSU0lPTiA+IDB4MjApIHsKKwkJaWYgKHdwYWJ1Zl90YWlscm9vbShtc2cpIDwgNSkKKwkJCXJldHVybiAtMTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6ICAqIEV4dGVuc2liaWxpdHkgVGVzdGluZyAtIGV4dHJhICIKIAkJCSAgICJhdHRyaWJ1dGUiKTsKIAkJd3BhYnVmX3B1dF9iZTE2KG1zZywgQVRUUl9FWFRFTlNJQklMSVRZX1RFU1QpOwpAQCAtMjc0LDkgKzI5NCwxMCBAQAogaW50IHdwc19idWlsZF9hdXRoX3R5cGVfZmxhZ3Moc3RydWN0IHdwc19kYXRhICp3cHMsIHN0cnVjdCB3cGFidWYgKm1zZykKIHsKIAl1MTYgYXV0aF90eXBlcyA9IFdQU19BVVRIX1RZUEVTOwotI2lmZGVmIENPTkZJR19XUFMyCisJLyogV1BBL1dQQTItRW50ZXJwcmlzZSBlbnJvbGxtZW50IG5vdCBzdXBwb3J0ZWQgdGhyb3VnaCBXUFMgKi8KKwlhdXRoX3R5cGVzICY9IH5XUFNfQVVUSF9XUEE7CisJYXV0aF90eXBlcyAmPSB+V1BTX0FVVEhfV1BBMjsKIAlhdXRoX3R5cGVzICY9IH5XUFNfQVVUSF9TSEFSRUQ7Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogQXV0aGVudGljYXRpb24gVHlwZSBGbGFncyIpOwogCXdwYWJ1Zl9wdXRfYmUxNihtc2csIEFUVFJfQVVUSF9UWVBFX0ZMQUdTKTsKIAl3cGFidWZfcHV0X2JlMTYobXNnLCAyKTsKQEAgLTI4OCw5ICszMDksNyBAQAogaW50IHdwc19idWlsZF9lbmNyX3R5cGVfZmxhZ3Moc3RydWN0IHdwc19kYXRhICp3cHMsIHN0cnVjdCB3cGFidWYgKm1zZykKIHsKIAl1MTYgZW5jcl90eXBlcyA9IFdQU19FTkNSX1RZUEVTOwotI2lmZGVmIENPTkZJR19XUFMyCiAJZW5jcl90eXBlcyAmPSB+V1BTX0VOQ1JfV0VQOwotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6ICAqIEVuY3J5cHRpb24gVHlwZSBGbGFncyIpOwogCXdwYWJ1Zl9wdXRfYmUxNihtc2csIEFUVFJfRU5DUl9UWVBFX0ZMQUdTKTsKIAl3cGFidWZfcHV0X2JlMTYobXNnLCAyKTsKQEAgLTM3MiwxNSArMzkxLDMxIEBACiAJY29uc3QgdTggKmFkZHJbMV07CiAJdTggcHVia2V5X2hhc2hbV1BTX0hBU0hfTEVOXTsKIAorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBPT0IgRGV2aWNlIFBhc3N3b3JkIChkZXZfcHdfaWQ9JXUpIiwKKwkJICAgZGV2X3B3X2lkKTsKIAlhZGRyWzBdID0gd3BhYnVmX2hlYWQocHVia2V5KTsKIAloYXNoX2xlbiA9IHdwYWJ1Zl9sZW4ocHVia2V5KTsKIAlzaGEyNTZfdmVjdG9yKDEsIGFkZHIsICZoYXNoX2xlbiwgcHVia2V5X2hhc2gpOworI2lmZGVmIENPTkZJR19XUFNfVEVTVElORworCWlmICh3cHNfY29ycnVwdF9wa2hhc2gpIHsKKwkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBSZWFsIFB1YmxpYyBLZXkgSGFzaCIsCisJCQkgICAgcHVia2V5X2hhc2gsIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOKTsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUzogVGVzdGluZyAtIGNvcnJ1cHQgcHVibGljIGtleSBoYXNoIik7CisJCXB1YmtleV9oYXNoW1dQU19PT0JfUFVCS0VZX0hBU0hfTEVOIC0gMl0rKzsKKwl9CisjZW5kaWYgLyogQ09ORklHX1dQU19URVNUSU5HICovCiAKIAl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX09PQl9ERVZJQ0VfUEFTU1dPUkQpOwogCXdwYWJ1Zl9wdXRfYmUxNihtc2csIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOICsgMiArIGRldl9wd19sZW4pOworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldQUzogUHVibGljIEtleSBIYXNoIiwKKwkJICAgIHB1YmtleV9oYXNoLCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTik7CiAJd3BhYnVmX3B1dF9kYXRhKG1zZywgcHVia2V5X2hhc2gsIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOKTsKIAl3cGFidWZfcHV0X2JlMTYobXNnLCBkZXZfcHdfaWQpOwotCXdwYWJ1Zl9wdXRfZGF0YShtc2csIGRldl9wdywgZGV2X3B3X2xlbik7CisJaWYgKGRldl9wdykgeworCQl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiV1BTOiBPT0IgRGV2aWNlIFBhc3N3b3JkIiwKKwkJCQlkZXZfcHcsIGRldl9wd19sZW4pOworCQl3cGFidWZfcHV0X2RhdGEobXNnLCBkZXZfcHcsIGRldl9wd19sZW4pOworCX0KIAogCXJldHVybiAwOwogfQpAQCAtNDI4LDMgKzQ2MywyMyBAQAogCXdwYWJ1Zl9wdXRfZGF0YShtc2csIGFkZHIsIEVUSF9BTEVOKTsKIAlyZXR1cm4gMDsKIH0KKworCitpbnQgd3BzX2J1aWxkX3JmX2JhbmRzX2F0dHIoc3RydWN0IHdwYWJ1ZiAqbXNnLCB1OCByZl9iYW5kcykKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogUkYgQmFuZHMgKCV4KSIsIHJmX2JhbmRzKTsKKwl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX1JGX0JBTkRTKTsKKwl3cGFidWZfcHV0X2JlMTYobXNnLCAxKTsKKwl3cGFidWZfcHV0X3U4KG1zZywgcmZfYmFuZHMpOworCXJldHVybiAwOworfQorCisKK2ludCB3cHNfYnVpbGRfYXBfY2hhbm5lbChzdHJ1Y3Qgd3BhYnVmICptc2csIHUxNiBhcF9jaGFubmVsKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBBUCBDaGFubmVsICgldSkiLCBhcF9jaGFubmVsKTsKKwl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX0FQX0NIQU5ORUwpOworCXdwYWJ1Zl9wdXRfYmUxNihtc2csIDIpOworCXdwYWJ1Zl9wdXRfYmUxNihtc2csIGFwX2NoYW5uZWwpOworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfYXR0cl9wYXJzZS5jIGIvc3JjL3dwcy93cHNfYXR0cl9wYXJzZS5jCmluZGV4IDM5OTliMWIuLjQwYmMxYWQgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX2F0dHJfcGFyc2UuYworKysgYi9zcmMvd3BzL3dwc19hdHRyX3BhcnNlLmMKQEAgLTU5LDYgKzU5LDE0IEBACiAJCX0KIAkJYXR0ci0+c2V0dGluZ3NfZGVsYXlfdGltZSA9IHBvczsKIAkJYnJlYWs7CisJY2FzZSBXRkFfRUxFTV9SRUdJU1RSQVJfQ09ORklHVVJBVElPTl9NRVRIT0RTOgorCQlpZiAobGVuICE9IDIpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBJbnZhbGlkIFJlZ2lzdHJhciBDb25maWd1cmF0aW9uIE1ldGhvZHMgbGVuZ3RoICV1IiwKKwkJCQkgICBsZW4pOworCQkJcmV0dXJuIC0xOworCQl9CisJCWF0dHItPnJlZ2lzdHJhcl9jb25maWd1cmF0aW9uX21ldGhvZHMgPSBwb3M7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJXUFM6IFNraXBwZWQgdW5rbm93biBXRkEgVmVuZG9yICIKIAkJCSAgICJFeHRlbnNpb24gc3ViZWxlbWVudCAldSIsIGlkKTsKQEAgLTc1LDcgKzgzLDcgQEAKIAljb25zdCB1OCAqZW5kID0gcG9zICsgbGVuOwogCXU4IGlkLCBlbGVuOwogCi0Jd2hpbGUgKHBvcyArIDIgPCBlbmQpIHsKKwl3aGlsZSAocG9zICsgMiA8PSBlbmQpIHsKIAkJaWQgPSAqcG9zKys7CiAJCWVsZW4gPSAqcG9zKys7CiAJCWlmIChwb3MgKyBlbGVuID4gZW5kKQpAQCAtMjYzLDEwICsyNzEsMTMgQEAKIAkJYXR0ci0+ZGV2X3Bhc3N3b3JkX2lkID0gcG9zOwogCQlicmVhazsKIAljYXNlIEFUVFJfT09CX0RFVklDRV9QQVNTV09SRDoKLQkJaWYgKGxlbiA8IFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOICsgMiArCi0JCSAgICBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9NSU5fTEVOIHx8CisJCWlmIChsZW4gPCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiArIDIgfHwKIAkJICAgIGxlbiA+IFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOICsgMiArCi0JCSAgICBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4pIHsKKwkJICAgIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0xFTiB8fAorCQkgICAgKGxlbiA8IFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOICsgMiArCisJCSAgICAgV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTUlOX0xFTiAmJgorCQkgICAgIFdQQV9HRVRfQkUxNihwb3MgKyBXUFNfT09CX1BVQktFWV9IQVNIX0xFTikgIT0KKwkJICAgICBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIpKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSW52YWxpZCBPT0IgRGV2aWNlICIKIAkJCQkgICAiUGFzc3dvcmQgbGVuZ3RoICV1IiwgbGVuKTsKIAkJCXJldHVybiAtMTsKQEAgLTQxMCwyMiArNDIxLDYgQEAKIAkJfQogCQlhdHRyLT5tYWNfYWRkciA9IHBvczsKIAkJYnJlYWs7Ci0JY2FzZSBBVFRSX0tFWV9QUk9WSURFRF9BVVRPOgotCQlpZiAobGVuICE9IDEpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBJbnZhbGlkIEtleSBQcm92aWRlZCAiCi0JCQkJICAgIkF1dG9tYXRpY2FsbHkgbGVuZ3RoICV1IiwgbGVuKTsKLQkJCXJldHVybiAtMTsKLQkJfQotCQlhdHRyLT5rZXlfcHJvdl9hdXRvID0gcG9zOwotCQlicmVhazsKLQljYXNlIEFUVFJfODAyXzFYX0VOQUJMRUQ6Ci0JCWlmIChsZW4gIT0gMSkgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEludmFsaWQgODAyLjFYIEVuYWJsZWQgIgotCQkJCSAgICJsZW5ndGggJXUiLCBsZW4pOwotCQkJcmV0dXJuIC0xOwotCQl9Ci0JCWF0dHItPmRvdDF4X2VuYWJsZWQgPSBwb3M7Ci0JCWJyZWFrOwogCWNhc2UgQVRUUl9TRUxFQ1RFRF9SRUdJU1RSQVI6CiAJCWlmIChsZW4gIT0gMSkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEludmFsaWQgU2VsZWN0ZWQgUmVnaXN0cmFyIgpAQCAtNDk3LDE0ICs0OTIsNiBAQAogCQlhdHRyLT5uZXR3b3JrX2tleSA9IHBvczsKIAkJYXR0ci0+bmV0d29ya19rZXlfbGVuID0gbGVuOwogCQlicmVhazsKLQljYXNlIEFUVFJfRUFQX1RZUEU6Ci0JCWF0dHItPmVhcF90eXBlID0gcG9zOwotCQlhdHRyLT5lYXBfdHlwZV9sZW4gPSBsZW47Ci0JCWJyZWFrOwotCWNhc2UgQVRUUl9FQVBfSURFTlRJVFk6Ci0JCWF0dHItPmVhcF9pZGVudGl0eSA9IHBvczsKLQkJYXR0ci0+ZWFwX2lkZW50aXR5X2xlbiA9IGxlbjsKLQkJYnJlYWs7CiAJY2FzZSBBVFRSX0FQX1NFVFVQX0xPQ0tFRDoKIAkJaWYgKGxlbiAhPSAxKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSW52YWxpZCBBUCBTZXR1cCBMb2NrZWQgIgpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfYXR0cl9wYXJzZS5oIGIvc3JjL3dwcy93cHNfYXR0cl9wYXJzZS5oCmluZGV4IDg4ZTUxYTQuLjgyYzQ3MzkgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX2F0dHJfcGFyc2UuaAorKysgYi9zcmMvd3BzL3dwc19hdHRyX3BhcnNlLmgKQEAgLTQ3LDggKzQ3LDYgQEAKIAljb25zdCB1OCAqbmV0d29ya19pZHg7IC8qIDEgb2N0ZXQgKi8KIAljb25zdCB1OCAqbmV0d29ya19rZXlfaWR4OyAvKiAxIG9jdGV0ICovCiAJY29uc3QgdTggKm1hY19hZGRyOyAvKiBFVEhfQUxFTiAoNikgb2N0ZXRzICovCi0JY29uc3QgdTggKmtleV9wcm92X2F1dG87IC8qIDEgb2N0ZXQgKEJvb2wpICovCi0JY29uc3QgdTggKmRvdDF4X2VuYWJsZWQ7IC8qIDEgb2N0ZXQgKEJvb2wpICovCiAJY29uc3QgdTggKnNlbGVjdGVkX3JlZ2lzdHJhcjsgLyogMSBvY3RldCAoQm9vbCkgKi8KIAljb25zdCB1OCAqcmVxdWVzdF90eXBlOyAvKiAxIG9jdGV0ICovCiAJY29uc3QgdTggKnJlc3BvbnNlX3R5cGU7IC8qIDEgb2N0ZXQgKi8KQEAgLTU3LDYgKzU1LDcgQEAKIAljb25zdCB1OCAqbmV0d29ya19rZXlfc2hhcmVhYmxlOyAvKiAxIG9jdGV0IChCb29sKSAqLwogCWNvbnN0IHU4ICpyZXF1ZXN0X3RvX2Vucm9sbDsgLyogMSBvY3RldCAoQm9vbCkgKi8KIAljb25zdCB1OCAqYXBfY2hhbm5lbDsgLyogMiBvY3RldHMgKi8KKwljb25zdCB1OCAqcmVnaXN0cmFyX2NvbmZpZ3VyYXRpb25fbWV0aG9kczsgLyogMiBvY3RldHMgKi8KIAogCS8qIHZhcmlhYmxlIGxlbmd0aCBmaWVsZHMgKi8KIAljb25zdCB1OCAqbWFudWZhY3R1cmVyOwpAQCAtNzcsMTAgKzc2LDYgQEAKIAlzaXplX3Qgc3NpZF9sZW47CiAJY29uc3QgdTggKm5ldHdvcmtfa2V5OyAvKiA8PSA2NCBvY3RldHMgKi8KIAlzaXplX3QgbmV0d29ya19rZXlfbGVuOwotCWNvbnN0IHU4ICplYXBfdHlwZTsgLyogPD0gOCBvY3RldHMgKi8KLQlzaXplX3QgZWFwX3R5cGVfbGVuOwotCWNvbnN0IHU4ICplYXBfaWRlbnRpdHk7IC8qIDw9IDY0IG9jdGV0cyAqLwotCXNpemVfdCBlYXBfaWRlbnRpdHlfbGVuOwogCWNvbnN0IHU4ICphdXRob3JpemVkX21hY3M7IC8qIDw9IDMwIG9jdGV0cyAqLwogCXNpemVfdCBhdXRob3JpemVkX21hY3NfbGVuOwogCWNvbnN0IHU4ICpzZWNfZGV2X3R5cGVfbGlzdDsgLyogPD0gMTI4IG9jdGV0cyAqLwpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfYXR0cl9wcm9jZXNzLmMgYi9zcmMvd3BzL3dwc19hdHRyX3Byb2Nlc3MuYwppbmRleCBiODFmMTA2Li5lYWRiMjJmIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19hdHRyX3Byb2Nlc3MuYworKysgYi9zcmMvd3BzL3dwc19hdHRyX3Byb2Nlc3MuYwpAQCAtNDEsNyArNDEsNyBAQAogCWxlblsxXSA9IHdwYWJ1Zl9sZW4obXNnKSAtIDQgLSBXUFNfQVVUSEVOVElDQVRPUl9MRU47CiAJaG1hY19zaGEyNTZfdmVjdG9yKHdwcy0+YXV0aGtleSwgV1BTX0FVVEhLRVlfTEVOLCAyLCBhZGRyLCBsZW4sIGhhc2gpOwogCi0JaWYgKG9zX21lbWNtcChoYXNoLCBhdXRoZW50aWNhdG9yLCBXUFNfQVVUSEVOVElDQVRPUl9MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KGhhc2gsIGF1dGhlbnRpY2F0b3IsIFdQU19BVVRIRU5USUNBVE9SX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSW5jb3JyZWN0IEF1dGhlbnRpY2F0b3IiKTsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTcxLDcgKzcxLDcgQEAKIAl9CiAKIAlobWFjX3NoYTI1Nih3cHMtPmF1dGhrZXksIFdQU19BVVRIS0VZX0xFTiwgaGVhZCwgbGVuLCBoYXNoKTsKLQlpZiAob3NfbWVtY21wKGhhc2gsIGtleV93cmFwX2F1dGgsIFdQU19LV0FfTEVOKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdChoYXNoLCBrZXlfd3JhcF9hdXRoLCBXUFNfS1dBX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSW52YWxpZCBLV0EiKTsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTIwNyw3MCArMjA3LDYgQEAKIH0KIAogCi1zdGF0aWMgaW50IHdwc19wcm9jZXNzX2NyZWRfZWFwX3R5cGUoc3RydWN0IHdwc19jcmVkZW50aWFsICpjcmVkLAotCQkJCSAgICAgY29uc3QgdTggKmVhcF90eXBlLCBzaXplX3QgZWFwX3R5cGVfbGVuKQotewotCWlmIChlYXBfdHlwZSA9PSBOVUxMKQotCQlyZXR1cm4gMDsgLyogb3B0aW9uYWwgYXR0cmlidXRlICovCi0KLQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUFM6IEVBUCBUeXBlIiwgZWFwX3R5cGUsIGVhcF90eXBlX2xlbik7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi1zdGF0aWMgaW50IHdwc19wcm9jZXNzX2NyZWRfZWFwX2lkZW50aXR5KHN0cnVjdCB3cHNfY3JlZGVudGlhbCAqY3JlZCwKLQkJCQkJIGNvbnN0IHU4ICppZGVudGl0eSwKLQkJCQkJIHNpemVfdCBpZGVudGl0eV9sZW4pCi17Ci0JaWYgKGlkZW50aXR5ID09IE5VTEwpCi0JCXJldHVybiAwOyAvKiBvcHRpb25hbCBhdHRyaWJ1dGUgKi8KLQotCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIldQUzogRUFQIElkZW50aXR5IiwKLQkJCSAgaWRlbnRpdHksIGlkZW50aXR5X2xlbik7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi1zdGF0aWMgaW50IHdwc19wcm9jZXNzX2NyZWRfa2V5X3Byb3ZfYXV0byhzdHJ1Y3Qgd3BzX2NyZWRlbnRpYWwgKmNyZWQsCi0JCQkJCSAgY29uc3QgdTggKmtleV9wcm92X2F1dG8pCi17Ci0JaWYgKGtleV9wcm92X2F1dG8gPT0gTlVMTCkKLQkJcmV0dXJuIDA7IC8qIG9wdGlvbmFsIGF0dHJpYnV0ZSAqLwotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEtleSBQcm92aWRlZCBBdXRvbWF0aWNhbGx5OiAlZCIsCi0JCSAgICprZXlfcHJvdl9hdXRvKTsKLQotCXJldHVybiAwOwotfQotCi0KLXN0YXRpYyBpbnQgd3BzX3Byb2Nlc3NfY3JlZF84MDJfMXhfZW5hYmxlZChzdHJ1Y3Qgd3BzX2NyZWRlbnRpYWwgKmNyZWQsCi0JCQkJCSAgIGNvbnN0IHU4ICpkb3QxeF9lbmFibGVkKQotewotCWlmIChkb3QxeF9lbmFibGVkID09IE5VTEwpCi0JCXJldHVybiAwOyAvKiBvcHRpb25hbCBhdHRyaWJ1dGUgKi8KLQotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiA4MDIuMVggRW5hYmxlZDogJWQiLCAqZG90MXhfZW5hYmxlZCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi1zdGF0aWMgaW50IHdwc19wcm9jZXNzX2NyZWRfYXBfY2hhbm5lbChzdHJ1Y3Qgd3BzX2NyZWRlbnRpYWwgKmNyZWQsCi0JCQkJICAgICAgIGNvbnN0IHU4ICphcF9jaGFubmVsKQotewotCWlmIChhcF9jaGFubmVsID09IE5VTEwpCi0JCXJldHVybiAwOyAvKiBvcHRpb25hbCBhdHRyaWJ1dGUgKi8KLQotCWNyZWQtPmFwX2NoYW5uZWwgPSBXUEFfR0VUX0JFMTYoYXBfY2hhbm5lbCk7Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEFQIENoYW5uZWw6ICV1IiwgY3JlZC0+YXBfY2hhbm5lbCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCiBzdGF0aWMgaW50IHdwc193b3JrYXJvdW5kX2NyZWRfa2V5KHN0cnVjdCB3cHNfY3JlZGVudGlhbCAqY3JlZCkKIHsKIAlpZiAoY3JlZC0+YXV0aF90eXBlICYgKFdQU19BVVRIX1dQQVBTSyB8IFdQU19BVVRIX1dQQTJQU0spICYmCkBAIC0zMTAsMTQgKzI0Niw3IEBACiAJICAgIHdwc19wcm9jZXNzX2NyZWRfbmV0d29ya19rZXlfaWR4KGNyZWQsIGF0dHItPm5ldHdvcmtfa2V5X2lkeCkgfHwKIAkgICAgd3BzX3Byb2Nlc3NfY3JlZF9uZXR3b3JrX2tleShjcmVkLCBhdHRyLT5uZXR3b3JrX2tleSwKIAkJCQkJIGF0dHItPm5ldHdvcmtfa2V5X2xlbikgfHwKLQkgICAgd3BzX3Byb2Nlc3NfY3JlZF9tYWNfYWRkcihjcmVkLCBhdHRyLT5tYWNfYWRkcikgfHwKLQkgICAgd3BzX3Byb2Nlc3NfY3JlZF9lYXBfdHlwZShjcmVkLCBhdHRyLT5lYXBfdHlwZSwKLQkJCQkgICAgICBhdHRyLT5lYXBfdHlwZV9sZW4pIHx8Ci0JICAgIHdwc19wcm9jZXNzX2NyZWRfZWFwX2lkZW50aXR5KGNyZWQsIGF0dHItPmVhcF9pZGVudGl0eSwKLQkJCQkJICBhdHRyLT5lYXBfaWRlbnRpdHlfbGVuKSB8fAotCSAgICB3cHNfcHJvY2Vzc19jcmVkX2tleV9wcm92X2F1dG8oY3JlZCwgYXR0ci0+a2V5X3Byb3ZfYXV0bykgfHwKLQkgICAgd3BzX3Byb2Nlc3NfY3JlZF84MDJfMXhfZW5hYmxlZChjcmVkLCBhdHRyLT5kb3QxeF9lbmFibGVkKSB8fAotCSAgICB3cHNfcHJvY2Vzc19jcmVkX2FwX2NoYW5uZWwoY3JlZCwgYXR0ci0+YXBfY2hhbm5lbCkpCisJICAgIHdwc19wcm9jZXNzX2NyZWRfbWFjX2FkZHIoY3JlZCwgYXR0ci0+bWFjX2FkZHIpKQogCQlyZXR1cm4gLTE7CiAKIAlyZXR1cm4gd3BzX3dvcmthcm91bmRfY3JlZF9rZXkoY3JlZCk7CmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19jb21tb24uYyBiL3NyYy93cHMvd3BzX2NvbW1vbi5jCmluZGV4IDRiNDMxYWQuLmEyODIzNDggMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX2NvbW1vbi5jCisrKyBiL3NyYy93cHMvd3BzX2NvbW1vbi5jCkBAIC05LDYgKzksOCBAQAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCiAKICNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJjb21tb24vZGVmcy5oIgorI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIgogI2luY2x1ZGUgImNyeXB0by9hZXNfd3JhcC5oIgogI2luY2x1ZGUgImNyeXB0by9jcnlwdG8uaCIKICNpbmNsdWRlICJjcnlwdG8vZGhfZ3JvdXA1LmgiCkBAIC0xNiw2ICsxOCw3IEBACiAjaW5jbHVkZSAiY3J5cHRvL3NoYTI1Ni5oIgogI2luY2x1ZGUgImNyeXB0by9yYW5kb20uaCIKICNpbmNsdWRlICJ3cHNfaS5oIgorI2luY2x1ZGUgIndwc19kZXZfYXR0ci5oIgogCiAKIHZvaWQgd3BzX2tkZihjb25zdCB1OCAqa2V5LCBjb25zdCB1OCAqbGFiZWxfcHJlZml4LCBzaXplX3QgbGFiZWxfcHJlZml4X2xlbiwKQEAgLTM0OSw3ICszNTIsOCBAQAogCiAjaWZkZWYgQ09ORklHX1dQU19PT0IKIAotc3RydWN0IHdwYWJ1ZiAqIHdwc19nZXRfb29iX2NyZWQoc3RydWN0IHdwc19jb250ZXh0ICp3cHMpCitzdHJ1Y3Qgd3BhYnVmICogd3BzX2dldF9vb2JfY3JlZChzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgaW50IHJmX2JhbmQsCisJCQkJIGludCBjaGFubmVsKQogewogCXN0cnVjdCB3cHNfZGF0YSBkYXRhOwogCXN0cnVjdCB3cGFidWYgKnBsYWluOwpAQCAtMzY1LDggKzM2OSwxMCBAQAogCWRhdGEud3BzID0gd3BzOwogCWRhdGEuYXV0aF90eXBlID0gd3BzLT5hdXRoX3R5cGVzOwogCWRhdGEuZW5jcl90eXBlID0gd3BzLT5lbmNyX3R5cGVzOwotCWlmICh3cHNfYnVpbGRfdmVyc2lvbihwbGFpbikgfHwKLQkgICAgd3BzX2J1aWxkX2NyZWQoJmRhdGEsIHBsYWluKSB8fAorCWlmICh3cHNfYnVpbGRfY3JlZCgmZGF0YSwgcGxhaW4pIHx8CisJICAgIChyZl9iYW5kICYmIHdwc19idWlsZF9yZl9iYW5kc19hdHRyKHBsYWluLCByZl9iYW5kKSkgfHwKKwkgICAgKGNoYW5uZWwgJiYgd3BzX2J1aWxkX2FwX2NoYW5uZWwocGxhaW4sIGNoYW5uZWwpKSB8fAorCSAgICB3cHNfYnVpbGRfbWFjX2FkZHIocGxhaW4sIHdwcy0+ZGV2Lm1hY19hZGRyKSB8fAogCSAgICB3cHNfYnVpbGRfd2ZhX2V4dChwbGFpbiwgMCwgTlVMTCwgMCkpIHsKIAkJb3NfZnJlZShkYXRhLm5ld19wc2spOwogCQl3cGFidWZfZnJlZShwbGFpbik7CkBAIC00MTIsOCArNDE4LDcgQEAKIAlpZiAoZGF0YSA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAotCWlmICh3cHNfYnVpbGRfdmVyc2lvbihkYXRhKSB8fAotCSAgICB3cHNfYnVpbGRfb29iX2Rldl9wdyhkYXRhLCBkZXZfcHdfaWQsIHB1YmtleSwKKwlpZiAod3BzX2J1aWxkX29vYl9kZXZfcHcoZGF0YSwgZGV2X3B3X2lkLCBwdWJrZXksCiAJCQkJIHdwYWJ1Zl9oZWFkKGRldl9wdyksIHdwYWJ1Zl9sZW4oZGV2X3B3KSkgfHwKIAkgICAgd3BzX2J1aWxkX3dmYV9leHQoZGF0YSwgMCwgTlVMTCwgMCkpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IEZhaWxlZCB0byBidWlsZCBORkMgcGFzc3dvcmQgIgpAQCAtNTI2LDkgKzUzMSw3IEBACiAJaWYgKHN0ciA9PSBOVUxMKSB7CiAJCS8qIERlZmF1bHQgdG8gZW5hYmxpbmcgbWV0aG9kcyBiYXNlZCBvbiBidWlsZCBjb25maWd1cmF0aW9uICovCiAJCW1ldGhvZHMgfD0gV1BTX0NPTkZJR19ESVNQTEFZIHwgV1BTX0NPTkZJR19LRVlQQUQ7Ci0jaWZkZWYgQ09ORklHX1dQUzIKIAkJbWV0aG9kcyB8PSBXUFNfQ09ORklHX1ZJUlRfRElTUExBWTsKLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogI2lmZGVmIENPTkZJR19XUFNfTkZDCiAJCW1ldGhvZHMgfD0gV1BTX0NPTkZJR19ORkNfSU5URVJGQUNFOwogI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCkBAIC01NDksNyArNTUyLDYgQEAKIAkJCW1ldGhvZHMgfD0gV1BTX0NPTkZJR19QVVNIQlVUVE9OOwogCQlpZiAob3Nfc3Ryc3RyKHN0ciwgImtleXBhZCIpKQogCQkJbWV0aG9kcyB8PSBXUFNfQ09ORklHX0tFWVBBRDsKLSNpZmRlZiBDT05GSUdfV1BTMgogCQlpZiAob3Nfc3Ryc3RyKHN0ciwgInZpcnR1YWxfZGlzcGxheSIpKQogCQkJbWV0aG9kcyB8PSBXUFNfQ09ORklHX1ZJUlRfRElTUExBWTsKIAkJaWYgKG9zX3N0cnN0cihzdHIsICJwaHlzaWNhbF9kaXNwbGF5IikpCkBAIC01NTgsNyArNTYwLDYgQEAKIAkJCW1ldGhvZHMgfD0gV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT047CiAJCWlmIChvc19zdHJzdHIoc3RyLCAicGh5c2ljYWxfcHVzaF9idXR0b24iKSkKIAkJCW1ldGhvZHMgfD0gV1BTX0NPTkZJR19QSFlfUFVTSEJVVFRPTjsKLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogCX0KIAogCXJldHVybiBtZXRob2RzOwpAQCAtNjM2LDEyICs2MzcsMzYgQEAKIH0KIAogCitpbnQgd3BzX25mY19nZW5fZGgoc3RydWN0IHdwYWJ1ZiAqKnB1YmtleSwgc3RydWN0IHdwYWJ1ZiAqKnByaXZrZXkpCit7CisJc3RydWN0IHdwYWJ1ZiAqcHJpdiA9IE5VTEwsICpwdWIgPSBOVUxMOworCXZvaWQgKmRoX2N0eDsKKworCWRoX2N0eCA9IGRoNV9pbml0KCZwcml2LCAmcHViKTsKKwlpZiAoZGhfY3R4ID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlwdWIgPSB3cGFidWZfemVyb3BhZChwdWIsIDE5Mik7CisJaWYgKHB1YiA9PSBOVUxMKSB7CisJCXdwYWJ1Zl9mcmVlKHByaXYpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9oZXhkdW1wX2J1ZihNU0dfREVCVUcsICJXUFM6IEdlbmVyYXRlZCBuZXcgREggcHVia2V5IiwgcHViKTsKKwlkaDVfZnJlZShkaF9jdHgpOworCisJd3BhYnVmX2ZyZWUoKnB1YmtleSk7CisJKnB1YmtleSA9IHB1YjsKKwl3cGFidWZfZnJlZSgqcHJpdmtleSk7CisJKnByaXZrZXkgPSBwcml2OworCisJcmV0dXJuIDA7Cit9CisKKwogc3RydWN0IHdwYWJ1ZiAqIHdwc19uZmNfdG9rZW5fZ2VuKGludCBuZGVmLCBpbnQgKmlkLCBzdHJ1Y3Qgd3BhYnVmICoqcHVia2V5LAogCQkJCSAgc3RydWN0IHdwYWJ1ZiAqKnByaXZrZXksCiAJCQkJICBzdHJ1Y3Qgd3BhYnVmICoqZGV2X3B3KQogewotCXN0cnVjdCB3cGFidWYgKnByaXYgPSBOVUxMLCAqcHViID0gTlVMTCwgKnB3OwotCXZvaWQgKmRoX2N0eDsKKwlzdHJ1Y3Qgd3BhYnVmICpwdzsKIAl1MTYgdmFsOwogCiAJcHcgPSB3cGFidWZfYWxsb2MoV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOKTsKQEAgLTY1NSwyMiArNjgwLDIyMyBAQAogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlkaF9jdHggPSBkaDVfaW5pdCgmcHJpdiwgJnB1Yik7Ci0JaWYgKGRoX2N0eCA9PSBOVUxMKSB7CisJaWYgKHdwc19uZmNfZ2VuX2RoKHB1YmtleSwgcHJpdmtleSkgPCAwKSB7CiAJCXdwYWJ1Zl9mcmVlKHB3KTsKIAkJcmV0dXJuIE5VTEw7CiAJfQotCWRoNV9mcmVlKGRoX2N0eCk7CiAKIAkqaWQgPSAweDEwICsgdmFsICUgMHhmZmYwOwotCXdwYWJ1Zl9mcmVlKCpwdWJrZXkpOwotCSpwdWJrZXkgPSBwdWI7Ci0Jd3BhYnVmX2ZyZWUoKnByaXZrZXkpOwotCSpwcml2a2V5ID0gcHJpdjsKIAl3cGFidWZfZnJlZSgqZGV2X3B3KTsKIAkqZGV2X3B3ID0gcHc7CiAKIAlyZXR1cm4gd3BzX25mY190b2tlbl9idWlsZChuZGVmLCAqaWQsICpwdWJrZXksICpkZXZfcHcpOwogfQogCisKK3N0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfbmZjX2hhbmRvdmVyX3JlcShzdHJ1Y3Qgd3BzX2NvbnRleHQgKmN0eCwKKwkJCQkJICAgc3RydWN0IHdwYWJ1ZiAqbmZjX2RoX3B1YmtleSkKK3sKKwlzdHJ1Y3Qgd3BhYnVmICptc2c7CisJdm9pZCAqbGVuOworCisJaWYgKGN0eCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBCdWlsZGluZyBhdHRyaWJ1dGVzIGZvciBORkMgY29ubmVjdGlvbiAiCisJCSAgICJoYW5kb3ZlciByZXF1ZXN0Iik7CisKKwlpZiAobmZjX2RoX3B1YmtleSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBORkMgT09CIERldmljZSBQYXNzd29yZCAiCisJCQkgICAiY29uZmlndXJlZCIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwltc2cgPSB3cGFidWZfYWxsb2MoMTAwMCk7CisJaWYgKG1zZyA9PSBOVUxMKQorCQlyZXR1cm4gbXNnOworCWxlbiA9IHdwYWJ1Zl9wdXQobXNnLCAyKTsKKworCWlmICh3cHNfYnVpbGRfb29iX2Rldl9wdyhtc2csIERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUiwKKwkJCQkgbmZjX2RoX3B1YmtleSwgTlVMTCwgMCkgfHwKKwkgICAgd3BzX2J1aWxkX3V1aWRfZShtc2csIGN0eC0+dXVpZCkgfHwKKwkgICAgd3BzX2J1aWxkX3dmYV9leHQobXNnLCAwLCBOVUxMLCAwKSkgeworCQl3cGFidWZfZnJlZShtc2cpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlXUEFfUFVUX0JFMTYobGVuLCB3cGFidWZfbGVuKG1zZykgLSAyKTsKKworCXJldHVybiBtc2c7Cit9CisKKworc3RhdGljIGludCB3cHNfYnVpbGRfc3NpZChzdHJ1Y3Qgd3BhYnVmICptc2csIHN0cnVjdCB3cHNfY29udGV4dCAqd3BzKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBTU0lEIik7CisJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiV1BTOiBTU0lEIGluIENvbm5lY3Rpb24gSGFuZG92ZXIgU2VsZWN0IiwKKwkJCSAgd3BzLT5zc2lkLCB3cHMtPnNzaWRfbGVuKTsKKwl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX1NTSUQpOworCXdwYWJ1Zl9wdXRfYmUxNihtc2csIHdwcy0+c3NpZF9sZW4pOworCXdwYWJ1Zl9wdXRfZGF0YShtc2csIHdwcy0+c3NpZCwgd3BzLT5zc2lkX2xlbik7CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cHNfYnVpbGRfYXBfZnJlcShzdHJ1Y3Qgd3BhYnVmICptc2csIGludCBmcmVxKQoreworCWVudW0gaG9zdGFwZF9od19tb2RlIG1vZGU7CisJdTggY2hhbm5lbCwgcmZfYmFuZDsKKwl1MTYgYXBfY2hhbm5lbDsKKworCWlmIChmcmVxIDw9IDApCisJCXJldHVybiAwOworCisJbW9kZSA9IGllZWU4MDIxMV9mcmVxX3RvX2NoYW4oZnJlcSwgJmNoYW5uZWwpOworCWlmIChtb2RlID09IE5VTV9IT1NUQVBEX01PREVTKQorCQlyZXR1cm4gMDsgLyogVW5rbm93biBjaGFubmVsICovCisKKwlpZiAobW9kZSA9PSBIT1NUQVBEX01PREVfSUVFRTgwMjExRyB8fCBtb2RlID09IEhPU1RBUERfTU9ERV9JRUVFODAyMTFCKQorCQlyZl9iYW5kID0gV1BTX1JGXzI0R0haOworCWVsc2UgaWYgKG1vZGUgPT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEpCisJCXJmX2JhbmQgPSBXUFNfUkZfNTBHSFo7CisJZWxzZQorCQlyZXR1cm4gMDsgLyogVW5rbm93biBiYW5kICovCisJYXBfY2hhbm5lbCA9IGNoYW5uZWw7CisKKwlpZiAod3BzX2J1aWxkX3JmX2JhbmRzX2F0dHIobXNnLCByZl9iYW5kKSB8fAorCSAgICB3cHNfYnVpbGRfYXBfY2hhbm5lbChtc2csIGFwX2NoYW5uZWwpKQorCQlyZXR1cm4gLTE7CisKKwlyZXR1cm4gMDsKK30KKworCitzdHJ1Y3Qgd3BhYnVmICogd3BzX2J1aWxkX25mY19oYW5kb3Zlcl9zZWwoc3RydWN0IHdwc19jb250ZXh0ICpjdHgsCisJCQkJCSAgIHN0cnVjdCB3cGFidWYgKm5mY19kaF9wdWJrZXksCisJCQkJCSAgIGNvbnN0IHU4ICpic3NpZCwgaW50IGZyZXEpCit7CisJc3RydWN0IHdwYWJ1ZiAqbXNnOworCXZvaWQgKmxlbjsKKworCWlmIChjdHggPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogQnVpbGRpbmcgYXR0cmlidXRlcyBmb3IgTkZDIGNvbm5lY3Rpb24gIgorCQkgICAiaGFuZG92ZXIgc2VsZWN0Iik7CisKKwlpZiAobmZjX2RoX3B1YmtleSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBORkMgT09CIERldmljZSBQYXNzd29yZCAiCisJCQkgICAiY29uZmlndXJlZCIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwltc2cgPSB3cGFidWZfYWxsb2MoMTAwMCk7CisJaWYgKG1zZyA9PSBOVUxMKQorCQlyZXR1cm4gbXNnOworCWxlbiA9IHdwYWJ1Zl9wdXQobXNnLCAyKTsKKworCWlmICh3cHNfYnVpbGRfb29iX2Rldl9wdyhtc2csIERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUiwKKwkJCQkgbmZjX2RoX3B1YmtleSwgTlVMTCwgMCkgfHwKKwkgICAgd3BzX2J1aWxkX3NzaWQobXNnLCBjdHgpIHx8CisJICAgIHdwc19idWlsZF9hcF9mcmVxKG1zZywgZnJlcSkgfHwKKwkgICAgKGJzc2lkICYmIHdwc19idWlsZF9tYWNfYWRkcihtc2csIGJzc2lkKSkgfHwKKwkgICAgd3BzX2J1aWxkX3dmYV9leHQobXNnLCAwLCBOVUxMLCAwKSkgeworCQl3cGFidWZfZnJlZShtc2cpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlXUEFfUFVUX0JFMTYobGVuLCB3cGFidWZfbGVuKG1zZykgLSAyKTsKKworCXJldHVybiBtc2c7Cit9CisKKworc3RydWN0IHdwYWJ1ZiAqIHdwc19idWlsZF9uZmNfaGFuZG92ZXJfcmVxX3AycChzdHJ1Y3Qgd3BzX2NvbnRleHQgKmN0eCwKKwkJCQkJICAgICAgIHN0cnVjdCB3cGFidWYgKm5mY19kaF9wdWJrZXkpCit7CisJc3RydWN0IHdwYWJ1ZiAqbXNnOworCisJaWYgKGN0eCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBCdWlsZGluZyBhdHRyaWJ1dGVzIGZvciBORkMgY29ubmVjdGlvbiAiCisJCSAgICJoYW5kb3ZlciByZXF1ZXN0IChQMlApIik7CisKKwlpZiAobmZjX2RoX3B1YmtleSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBORkMgREggUHVibGljIEtleSBjb25maWd1cmVkIik7CisJCXJldHVybiBOVUxMOworCX0KKworCW1zZyA9IHdwYWJ1Zl9hbGxvYygxMDAwKTsKKwlpZiAobXNnID09IE5VTEwpCisJCXJldHVybiBtc2c7CisKKwlpZiAod3BzX2J1aWxkX21hbnVmYWN0dXJlcigmY3R4LT5kZXYsIG1zZykgfHwKKwkgICAgd3BzX2J1aWxkX21vZGVsX25hbWUoJmN0eC0+ZGV2LCBtc2cpIHx8CisJICAgIHdwc19idWlsZF9tb2RlbF9udW1iZXIoJmN0eC0+ZGV2LCBtc2cpIHx8CisJICAgIHdwc19idWlsZF9vb2JfZGV2X3B3KG1zZywgREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSLAorCQkJCSBuZmNfZGhfcHVia2V5LCBOVUxMLCAwKSB8fAorCSAgICB3cHNfYnVpbGRfcmZfYmFuZHMoJmN0eC0+ZGV2LCBtc2csIDApIHx8CisJICAgIHdwc19idWlsZF9zZXJpYWxfbnVtYmVyKCZjdHgtPmRldiwgbXNnKSB8fAorCSAgICB3cHNfYnVpbGRfdXVpZF9lKG1zZywgY3R4LT51dWlkKSB8fAorCSAgICB3cHNfYnVpbGRfd2ZhX2V4dChtc2csIDAsIE5VTEwsIDApKSB7CisJCXdwYWJ1Zl9mcmVlKG1zZyk7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiBtc2c7Cit9CisKKworc3RydWN0IHdwYWJ1ZiAqIHdwc19idWlsZF9uZmNfaGFuZG92ZXJfc2VsX3AycChzdHJ1Y3Qgd3BzX2NvbnRleHQgKmN0eCwKKwkJCQkJICAgICAgIGludCBuZmNfZGV2X3B3X2lkLAorCQkJCQkgICAgICAgc3RydWN0IHdwYWJ1ZiAqbmZjX2RoX3B1YmtleSwKKwkJCQkJICAgICAgIHN0cnVjdCB3cGFidWYgKm5mY19kZXZfcHcpCit7CisJc3RydWN0IHdwYWJ1ZiAqbXNnOworCWNvbnN0IHU4ICpkZXZfcHc7CisJc2l6ZV90IGRldl9wd19sZW47CisKKwlpZiAoY3R4ID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEJ1aWxkaW5nIGF0dHJpYnV0ZXMgZm9yIE5GQyBjb25uZWN0aW9uICIKKwkJICAgImhhbmRvdmVyIHNlbGVjdCAoUDJQKSIpOworCisJaWYgKG5mY19kaF9wdWJrZXkgPT0gTlVMTCB8fAorCSAgICAobmZjX2Rldl9wd19pZCAhPSBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIgJiYKKwkgICAgIG5mY19kZXZfcHcgPT0gTlVMTCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IE5vIE5GQyBPT0IgRGV2aWNlIFBhc3N3b3JkICIKKwkJCSAgICJjb25maWd1cmVkIik7CisJCXJldHVybiBOVUxMOworCX0KKworCW1zZyA9IHdwYWJ1Zl9hbGxvYygxMDAwKTsKKwlpZiAobXNnID09IE5VTEwpCisJCXJldHVybiBtc2c7CisKKwlpZiAobmZjX2Rldl9wdykgeworCQlkZXZfcHcgPSB3cGFidWZfaGVhZChuZmNfZGV2X3B3KTsKKwkJZGV2X3B3X2xlbiA9IHdwYWJ1Zl9sZW4obmZjX2Rldl9wdyk7CisJfSBlbHNlIHsKKwkJZGV2X3B3ID0gTlVMTDsKKwkJZGV2X3B3X2xlbiA9IDA7CisJfQorCisJaWYgKHdwc19idWlsZF9tYW51ZmFjdHVyZXIoJmN0eC0+ZGV2LCBtc2cpIHx8CisJICAgIHdwc19idWlsZF9tb2RlbF9uYW1lKCZjdHgtPmRldiwgbXNnKSB8fAorCSAgICB3cHNfYnVpbGRfbW9kZWxfbnVtYmVyKCZjdHgtPmRldiwgbXNnKSB8fAorCSAgICB3cHNfYnVpbGRfb29iX2Rldl9wdyhtc2csIG5mY19kZXZfcHdfaWQsIG5mY19kaF9wdWJrZXksCisJCQkJIGRldl9wdywgZGV2X3B3X2xlbikgfHwKKwkgICAgd3BzX2J1aWxkX3JmX2JhbmRzKCZjdHgtPmRldiwgbXNnLCAwKSB8fAorCSAgICB3cHNfYnVpbGRfc2VyaWFsX251bWJlcigmY3R4LT5kZXYsIG1zZykgfHwKKwkgICAgd3BzX2J1aWxkX3V1aWRfZShtc2csIGN0eC0+dXVpZCkgfHwKKwkgICAgd3BzX2J1aWxkX3dmYV9leHQobXNnLCAwLCBOVUxMLCAwKSkgeworCQl3cGFidWZfZnJlZShtc2cpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXR1cm4gbXNnOworfQorCiAjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX2RlZnMuaCBiL3NyYy93cHMvd3BzX2RlZnMuaAppbmRleCAzNDIxYWM1Li5mNDgzZTJlIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19kZWZzLmgKKysrIGIvc3JjL3dwcy93cHNfZGVmcy5oCkBAIC0xMywxNSArMTMsMTIgQEAKIAogZXh0ZXJuIGludCB3cHNfdmVyc2lvbl9udW1iZXI7CiBleHRlcm4gaW50IHdwc190ZXN0aW5nX2R1bW15X2NyZWQ7CitleHRlcm4gaW50IHdwc19jb3JydXB0X3BraGFzaDsKICNkZWZpbmUgV1BTX1ZFUlNJT04gd3BzX3ZlcnNpb25fbnVtYmVyCiAKICNlbHNlIC8qIENPTkZJR19XUFNfVEVTVElORyAqLwogCi0jaWZkZWYgQ09ORklHX1dQUzIKICNkZWZpbmUgV1BTX1ZFUlNJT04gMHgyMAotI2Vsc2UgLyogQ09ORklHX1dQUzIgKi8KLSNkZWZpbmUgV1BTX1ZFUlNJT04gMHgxMAotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAKICNlbmRpZiAvKiBDT05GSUdfV1BTX1RFU1RJTkcgKi8KIApAQCAtMTQ1LDcgKzE0Miw4IEBACiAJV0ZBX0VMRU1fQVVUSE9SSVpFRE1BQ1MgPSAweDAxLAogCVdGQV9FTEVNX05FVFdPUktfS0VZX1NIQVJFQUJMRSA9IDB4MDIsCiAJV0ZBX0VMRU1fUkVRVUVTVF9UT19FTlJPTEwgPSAweDAzLAotCVdGQV9FTEVNX1NFVFRJTkdTX0RFTEFZX1RJTUUgPSAweDA0CisJV0ZBX0VMRU1fU0VUVElOR1NfREVMQVlfVElNRSA9IDB4MDQsCisJV0ZBX0VMRU1fUkVHSVNUUkFSX0NPTkZJR1VSQVRJT05fTUVUSE9EUyA9IDB4MDUKIH07CiAKIC8qIERldmljZSBQYXNzd29yZCBJRCAqLwpAQCAtMTU1LDcgKzE1Myw4IEBACiAJREVWX1BXX01BQ0hJTkVfU1BFQ0lGSUVEID0gMHgwMDAyLAogCURFVl9QV19SRUtFWSA9IDB4MDAwMywKIAlERVZfUFdfUFVTSEJVVFRPTiA9IDB4MDAwNCwKLQlERVZfUFdfUkVHSVNUUkFSX1NQRUNJRklFRCA9IDB4MDAwNQorCURFVl9QV19SRUdJU1RSQVJfU1BFQ0lGSUVEID0gMHgwMDA1LAorCURFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUiA9IDB4MDAwNwogfTsKIAogLyogTWVzc2FnZSBUeXBlICovCkBAIC0xODAsNyArMTc5LDcgQEAKIC8qIEF1dGhlbnRpY2F0aW9uIFR5cGUgRmxhZ3MgKi8KICNkZWZpbmUgV1BTX0FVVEhfT1BFTiAweDAwMDEKICNkZWZpbmUgV1BTX0FVVEhfV1BBUFNLIDB4MDAwMgotI2RlZmluZSBXUFNfQVVUSF9TSEFSRUQgMHgwMDA0CisjZGVmaW5lIFdQU19BVVRIX1NIQVJFRCAweDAwMDQgLyogZGVwcmVjYXRlZCAqLwogI2RlZmluZSBXUFNfQVVUSF9XUEEgMHgwMDA4CiAjZGVmaW5lIFdQU19BVVRIX1dQQTIgMHgwMDEwCiAjZGVmaW5lIFdQU19BVVRIX1dQQTJQU0sgMHgwMDIwCkBAIC0xODksNyArMTg4LDcgQEAKIAogLyogRW5jcnlwdGlvbiBUeXBlIEZsYWdzICovCiAjZGVmaW5lIFdQU19FTkNSX05PTkUgMHgwMDAxCi0jZGVmaW5lIFdQU19FTkNSX1dFUCAweDAwMDIKKyNkZWZpbmUgV1BTX0VOQ1JfV0VQIDB4MDAwMiAvKiBkZXByZWNhdGVkICovCiAjZGVmaW5lIFdQU19FTkNSX1RLSVAgMHgwMDA0CiAjZGVmaW5lIFdQU19FTkNSX0FFUyAweDAwMDgKICNkZWZpbmUgV1BTX0VOQ1JfVFlQRVMgKFdQU19FTkNSX05PTkUgfCBXUFNfRU5DUl9XRVAgfCBXUFNfRU5DUl9US0lQIHwgXApAQCAtMjE1LDcgKzIxNCw5IEBACiAJV1BTX0NGR19TRVRVUF9MT0NLRUQgPSAxNSwKIAlXUFNfQ0ZHX01TR19USU1FT1VUID0gMTYsCiAJV1BTX0NGR19SRUdfU0VTU19USU1FT1VUID0gMTcsCi0JV1BTX0NGR19ERVZfUEFTU1dPUkRfQVVUSF9GQUlMVVJFID0gMTgKKwlXUFNfQ0ZHX0RFVl9QQVNTV09SRF9BVVRIX0ZBSUxVUkUgPSAxOCwKKwlXUFNfQ0ZHXzYwR19DSEFOX05PVF9TVVBQT1JURUQgPSAxOSwKKwlXUFNfQ0ZHX1BVQkxJQ19LRVlfSEFTSF9NSVNNQVRDSCA9IDIwCiB9OwogCiAvKiBWZW5kb3Igc3BlY2lmaWMgRXJyb3IgSW5kaWNhdGlvbiBmb3IgV1BTIGV2ZW50IG1lc3NhZ2VzICovCkBAIC0yNDEsMTIgKzI0MiwxMCBAQAogI2RlZmluZSBXUFNfQ09ORklHX05GQ19JTlRFUkZBQ0UgMHgwMDQwCiAjZGVmaW5lIFdQU19DT05GSUdfUFVTSEJVVFRPTiAweDAwODAKICNkZWZpbmUgV1BTX0NPTkZJR19LRVlQQUQgMHgwMTAwCi0jaWZkZWYgQ09ORklHX1dQUzIKICNkZWZpbmUgV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT04gMHgwMjgwCiAjZGVmaW5lIFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT04gMHgwNDgwCiAjZGVmaW5lIFdQU19DT05GSUdfVklSVF9ESVNQTEFZIDB4MjAwOAogI2RlZmluZSBXUFNfQ09ORklHX1BIWV9ESVNQTEFZIDB4NDAwOAotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAKIC8qIENvbm5lY3Rpb24gVHlwZSBGbGFncyAqLwogI2RlZmluZSBXUFNfQ09OTl9FU1MgMHgwMQpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfZGV2X2F0dHIuYyBiL3NyYy93cHMvd3BzX2Rldl9hdHRyLmMKaW5kZXggMWIxMmI1YS4uMGQwMTIxMSAxMDA2NDQKLS0tIGEvc3JjL3dwcy93cHNfZGV2X2F0dHIuYworKysgYi9zcmMvd3BzL3dwc19kZXZfYXR0ci5jCkBAIC04NSw4ICs4NSw3IEBACiB9CiAKIAotc3RhdGljIGludCB3cHNfYnVpbGRfc2VyaWFsX251bWJlcihzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsCi0JCQkJICAgc3RydWN0IHdwYWJ1ZiAqbXNnKQoraW50IHdwc19idWlsZF9zZXJpYWxfbnVtYmVyKHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRldiwgc3RydWN0IHdwYWJ1ZiAqbXNnKQogewogCXNpemVfdCBsZW47CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6ICAqIFNlcmlhbCBOdW1iZXIiKTsKQEAgLTIyMCwxMSArMjE5LDcgQEAKIGludCB3cHNfYnVpbGRfcmZfYmFuZHMoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LCBzdHJ1Y3Qgd3BhYnVmICptc2csCiAJCSAgICAgICB1OCByZl9iYW5kKQogewotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBSRiBCYW5kcyAoJXgpIiwgZGV2LT5yZl9iYW5kcyk7Ci0Jd3BhYnVmX3B1dF9iZTE2KG1zZywgQVRUUl9SRl9CQU5EUyk7Ci0Jd3BhYnVmX3B1dF9iZTE2KG1zZywgMSk7Ci0Jd3BhYnVmX3B1dF91OChtc2csIHJmX2JhbmQgPyByZl9iYW5kIDogZGV2LT5yZl9iYW5kcyk7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHdwc19idWlsZF9yZl9iYW5kc19hdHRyKG1zZywgcmZfYmFuZCA/IHJmX2JhbmQgOiBkZXYtPnJmX2JhbmRzKTsKIH0KIAogCkBAIC00MDksMjUgKzQwNCw2IEBACiB9CiAKIAotdm9pZCB3cHNfZGV2aWNlX2RhdGFfZHVwKHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRzdCwKLQkJCSBjb25zdCBzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpzcmMpCi17Ci0JaWYgKHNyYy0+ZGV2aWNlX25hbWUpCi0JCWRzdC0+ZGV2aWNlX25hbWUgPSBvc19zdHJkdXAoc3JjLT5kZXZpY2VfbmFtZSk7Ci0JaWYgKHNyYy0+bWFudWZhY3R1cmVyKQotCQlkc3QtPm1hbnVmYWN0dXJlciA9IG9zX3N0cmR1cChzcmMtPm1hbnVmYWN0dXJlcik7Ci0JaWYgKHNyYy0+bW9kZWxfbmFtZSkKLQkJZHN0LT5tb2RlbF9uYW1lID0gb3Nfc3RyZHVwKHNyYy0+bW9kZWxfbmFtZSk7Ci0JaWYgKHNyYy0+bW9kZWxfbnVtYmVyKQotCQlkc3QtPm1vZGVsX251bWJlciA9IG9zX3N0cmR1cChzcmMtPm1vZGVsX251bWJlcik7Ci0JaWYgKHNyYy0+c2VyaWFsX251bWJlcikKLQkJZHN0LT5zZXJpYWxfbnVtYmVyID0gb3Nfc3RyZHVwKHNyYy0+c2VyaWFsX251bWJlcik7Ci0Jb3NfbWVtY3B5KGRzdC0+cHJpX2Rldl90eXBlLCBzcmMtPnByaV9kZXZfdHlwZSwgV1BTX0RFVl9UWVBFX0xFTik7Ci0JZHN0LT5vc192ZXJzaW9uID0gc3JjLT5vc192ZXJzaW9uOwotCWRzdC0+cmZfYmFuZHMgPSBzcmMtPnJmX2JhbmRzOwotfQotCi0KIHZvaWQgd3BzX2RldmljZV9kYXRhX2ZyZWUoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2KQogewogCW9zX2ZyZWUoZGV2LT5kZXZpY2VfbmFtZSk7CmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19kZXZfYXR0ci5oIGIvc3JjL3dwcy93cHNfZGV2X2F0dHIuaAppbmRleCAwMTU4Y2RjLi5jOTAzNGFkIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19kZXZfYXR0ci5oCisrKyBiL3NyYy93cHMvd3BzX2Rldl9hdHRyLmgKQEAgLTE0LDYgKzE0LDcgQEAKIGludCB3cHNfYnVpbGRfbWFudWZhY3R1cmVyKHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRldiwgc3RydWN0IHdwYWJ1ZiAqbXNnKTsKIGludCB3cHNfYnVpbGRfbW9kZWxfbmFtZShzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZyk7CiBpbnQgd3BzX2J1aWxkX21vZGVsX251bWJlcihzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZyk7CitpbnQgd3BzX2J1aWxkX3NlcmlhbF9udW1iZXIoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LCBzdHJ1Y3Qgd3BhYnVmICptc2cpOwogaW50IHdwc19idWlsZF9kZXZfbmFtZShzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZyk7CiBpbnQgd3BzX2J1aWxkX2RldmljZV9hdHRycyhzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZyk7CiBpbnQgd3BzX2J1aWxkX29zX3ZlcnNpb24oc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LCBzdHJ1Y3Qgd3BhYnVmICptc2cpOwpAQCAtMjksOCArMzAsNiBAQAogCQkJICAgICBzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgKmF0dHIpOwogaW50IHdwc19wcm9jZXNzX29zX3ZlcnNpb24oc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LCBjb25zdCB1OCAqdmVyKTsKIGludCB3cHNfcHJvY2Vzc19yZl9iYW5kcyhzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIGNvbnN0IHU4ICpiYW5kcyk7Ci12b2lkIHdwc19kZXZpY2VfZGF0YV9kdXAoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZHN0LAotCQkJIGNvbnN0IHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKnNyYyk7CiB2b2lkIHdwc19kZXZpY2VfZGF0YV9mcmVlKHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRldik7CiBpbnQgd3BzX2J1aWxkX3ZlbmRvcl9leHQoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LCBzdHJ1Y3Qgd3BhYnVmICptc2cpOwogaW50IHdwc19idWlsZF9yZXFfZGV2X3R5cGUoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LCBzdHJ1Y3Qgd3BhYnVmICptc2csCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19lbnJvbGxlZS5jIGIvc3JjL3dwcy93cHNfZW5yb2xsZWUuYwppbmRleCBkMDJiYTMwLi5mN2Q0MWI0IDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19lbnJvbGxlZS5jCisrKyBiL3NyYy93cHMvd3BzX2Vucm9sbGVlLmMKQEAgLTEzMCwxMCArMTMwLDggQEAKIAkJICogd29ya2Fyb3VuZC4KIAkJICovCiAJCWNvbmZpZ19tZXRob2RzICY9IH5XUFNfQ09ORklHX1BVU0hCVVRUT047Ci0jaWZkZWYgQ09ORklHX1dQUzIKIAkJY29uZmlnX21ldGhvZHMgJj0gfihXUFNfQ09ORklHX1ZJUlRfUFVTSEJVVFRPTiB8CiAJCQkJICAgIFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT04pOwotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAJfQogCiAJaWYgKHdwc19idWlsZF92ZXJzaW9uKG1zZykgfHwKQEAgLTI0Myw1NCArMjQxLDUzIEBACiAKIHN0YXRpYyBpbnQgd3BzX2J1aWxkX2NyZWRfYXV0aF90eXBlKHN0cnVjdCB3cHNfZGF0YSAqd3BzLCBzdHJ1Y3Qgd3BhYnVmICptc2cpCiB7Ci0JdTE2IGF1dGhfdHlwZSA9IHdwcy0+d3BzLT5hdXRoX3R5cGVzOwotCi0JLyogU2VsZWN0IHRoZSBiZXN0IGF1dGhlbnRpY2F0aW9uIHR5cGUgKi8KLQlpZiAoYXV0aF90eXBlICYgV1BTX0FVVEhfV1BBMlBTSykKLQkJYXV0aF90eXBlID0gV1BTX0FVVEhfV1BBMlBTSzsKLQllbHNlIGlmIChhdXRoX3R5cGUgJiBXUFNfQVVUSF9XUEFQU0spCi0JCWF1dGhfdHlwZSA9IFdQU19BVVRIX1dQQVBTSzsKLQllbHNlIGlmIChhdXRoX3R5cGUgJiBXUFNfQVVUSF9PUEVOKQotCQlhdXRoX3R5cGUgPSBXUFNfQVVUSF9PUEVOOwotCWVsc2UgaWYgKGF1dGhfdHlwZSAmIFdQU19BVVRIX1NIQVJFRCkKLQkJYXV0aF90eXBlID0gV1BTX0FVVEhfU0hBUkVEOwotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6ICAqIEF1dGhlbnRpY2F0aW9uIFR5cGUgKDB4JXgpIiwgYXV0aF90eXBlKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogQXV0aGVudGljYXRpb24gVHlwZSAoMHgleCkiLAorCQkgICB3cHMtPndwcy0+YXBfYXV0aF90eXBlKTsKIAl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX0FVVEhfVFlQRSk7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgMik7Ci0Jd3BhYnVmX3B1dF9iZTE2KG1zZywgYXV0aF90eXBlKTsKKwl3cGFidWZfcHV0X2JlMTYobXNnLCB3cHMtPndwcy0+YXBfYXV0aF90eXBlKTsKIAlyZXR1cm4gMDsKIH0KIAogCiBzdGF0aWMgaW50IHdwc19idWlsZF9jcmVkX2VuY3JfdHlwZShzdHJ1Y3Qgd3BzX2RhdGEgKndwcywgc3RydWN0IHdwYWJ1ZiAqbXNnKQogewotCXUxNiBlbmNyX3R5cGUgPSB3cHMtPndwcy0+ZW5jcl90eXBlczsKLQotCS8qIFNlbGVjdCB0aGUgYmVzdCBlbmNyeXB0aW9uIHR5cGUgKi8KLQlpZiAod3BzLT53cHMtPmF1dGhfdHlwZXMgJiAoV1BTX0FVVEhfV1BBMlBTSyB8IFdQU19BVVRIX1dQQVBTSykpIHsKLQkJaWYgKGVuY3JfdHlwZSAmIFdQU19FTkNSX0FFUykKLQkJCWVuY3JfdHlwZSA9IFdQU19FTkNSX0FFUzsKLQkJZWxzZSBpZiAoZW5jcl90eXBlICYgV1BTX0VOQ1JfVEtJUCkKLQkJCWVuY3JfdHlwZSA9IFdQU19FTkNSX1RLSVA7Ci0JfSBlbHNlIHsKLQkJaWYgKGVuY3JfdHlwZSAmIFdQU19FTkNSX1dFUCkKLQkJCWVuY3JfdHlwZSA9IFdQU19FTkNSX1dFUDsKLQkJZWxzZSBpZiAoZW5jcl90eXBlICYgV1BTX0VOQ1JfTk9ORSkKLQkJCWVuY3JfdHlwZSA9IFdQU19FTkNSX05PTkU7Ci0JfQotCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6ICAqIEVuY3J5cHRpb24gVHlwZSAoMHgleCkiLCBlbmNyX3R5cGUpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBFbmNyeXB0aW9uIFR5cGUgKDB4JXgpIiwKKwkJICAgd3BzLT53cHMtPmFwX2VuY3JfdHlwZSk7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgQVRUUl9FTkNSX1RZUEUpOwogCXdwYWJ1Zl9wdXRfYmUxNihtc2csIDIpOwotCXdwYWJ1Zl9wdXRfYmUxNihtc2csIGVuY3JfdHlwZSk7CisJd3BhYnVmX3B1dF9iZTE2KG1zZywgd3BzLT53cHMtPmFwX2VuY3JfdHlwZSk7CiAJcmV0dXJuIDA7CiB9CiAKIAogc3RhdGljIGludCB3cHNfYnVpbGRfY3JlZF9uZXR3b3JrX2tleShzdHJ1Y3Qgd3BzX2RhdGEgKndwcywgc3RydWN0IHdwYWJ1ZiAqbXNnKQogewotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBOZXR3b3JrIEtleSIpOworCWlmICgod3BzLT53cHMtPmFwX2F1dGhfdHlwZSAmIChXUFNfQVVUSF9XUEFQU0sgfCBXUFNfQVVUSF9XUEEyUFNLKSkgJiYKKwkgICAgd3BzLT53cHMtPm5ldHdvcmtfa2V5X2xlbiA9PSAwKSB7CisJCWNoYXIgaGV4WzY1XTsKKwkJdTggcHNrWzMyXTsKKwkJLyogR2VuZXJhdGUgYSByYW5kb20gcGVyLWRldmljZSBQU0sgKi8KKwkJaWYgKHJhbmRvbV9nZXRfYnl0ZXMocHNrLCBzaXplb2YocHNrKSkgPCAwKQorCQkJcmV0dXJuIC0xOworCQl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiV1BTOiBHZW5lcmF0ZWQgcGVyLWRldmljZSBQU0siLAorCQkJCXBzaywgc2l6ZW9mKHBzaykpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogTmV0d29yayBLZXkgKGxlbj0ldSkiLAorCQkJICAgKHVuc2lnbmVkIGludCkgd3BzLT5uZXdfcHNrX2xlbiAqIDIpOworCQl3cGFfc25wcmludGZfaGV4KGhleCwgc2l6ZW9mKGhleCksIHBzaywgc2l6ZW9mKHBzaykpOworCQl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX05FVFdPUktfS0VZKTsKKwkJd3BhYnVmX3B1dF9iZTE2KG1zZywgc2l6ZW9mKHBzaykgKiAyKTsKKwkJd3BhYnVmX3B1dF9kYXRhKG1zZywgaGV4LCBzaXplb2YocHNrKSAqIDIpOworCQlpZiAod3BzLT53cHMtPnJlZ2lzdHJhcikgeworCQkJd3BzX2NiX25ld19wc2sod3BzLT53cHMtPnJlZ2lzdHJhciwKKwkJCQkgICAgICAgd3BzLT5wZWVyX2Rldi5tYWNfYWRkciwKKwkJCQkgICAgICAgd3BzLT5wMnBfZGV2X2FkZHIsIHBzaywgc2l6ZW9mKHBzaykpOworCQl9CisJCXJldHVybiAwOworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBOZXR3b3JrIEtleSAobGVuPSV1KSIsCisJCSAgICh1bnNpZ25lZCBpbnQpIHdwcy0+d3BzLT5uZXR3b3JrX2tleV9sZW4pOwogCXdwYWJ1Zl9wdXRfYmUxNihtc2csIEFUVFJfTkVUV09SS19LRVkpOwogCXdwYWJ1Zl9wdXRfYmUxNihtc2csIHdwcy0+d3BzLT5uZXR3b3JrX2tleV9sZW4pOwogCXdwYWJ1Zl9wdXRfZGF0YShtc2csIHdwcy0+d3BzLT5uZXR3b3JrX2tleSwgd3BzLT53cHMtPm5ldHdvcmtfa2V5X2xlbik7CkBAIC0zMTAsNiArMzA3LDkgQEAKIAogc3RhdGljIGludCB3cHNfYnVpbGRfYXBfc2V0dGluZ3Moc3RydWN0IHdwc19kYXRhICp3cHMsIHN0cnVjdCB3cGFidWYgKnBsYWluKQogeworCWNvbnN0IHU4ICpzdGFydCwgKmVuZDsKKwlpbnQgcmV0OworCiAJaWYgKHdwcy0+d3BzLT5hcF9zZXR0aW5ncykgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogQVAgU2V0dGluZ3MgKHByZS1jb25maWd1cmVkKSIpOwogCQl3cGFidWZfcHV0X2RhdGEocGxhaW4sIHdwcy0+d3BzLT5hcF9zZXR0aW5ncywKQEAgLTMxNywxMSArMzE3LDE5IEBACiAJCXJldHVybiAwOwogCX0KIAotCXJldHVybiB3cHNfYnVpbGRfY3JlZF9zc2lkKHdwcywgcGxhaW4pIHx8CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6ICAqIEFQIFNldHRpbmdzIGJhc2VkIG9uIGN1cnJlbnQgY29uZmlndXJhdGlvbiIpOworCXN0YXJ0ID0gd3BhYnVmX3B1dChwbGFpbiwgMCk7CisJcmV0ID0gd3BzX2J1aWxkX2NyZWRfc3NpZCh3cHMsIHBsYWluKSB8fAogCQl3cHNfYnVpbGRfY3JlZF9tYWNfYWRkcih3cHMsIHBsYWluKSB8fAogCQl3cHNfYnVpbGRfY3JlZF9hdXRoX3R5cGUod3BzLCBwbGFpbikgfHwKIAkJd3BzX2J1aWxkX2NyZWRfZW5jcl90eXBlKHdwcywgcGxhaW4pIHx8CiAJCXdwc19idWlsZF9jcmVkX25ldHdvcmtfa2V5KHdwcywgcGxhaW4pOworCWVuZCA9IHdwYWJ1Zl9wdXQocGxhaW4sIDApOworCisJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIldQUzogUGxhaW50ZXh0IEFQIFNldHRpbmdzIiwKKwkJCXN0YXJ0LCBlbmQgLSBzdGFydCk7CisKKwlyZXR1cm4gcmV0OwogfQogCiAKQEAgLTUxNCw2ICs1MjIsMjQgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAorCWlmICh3cHMtPnBlZXJfcHVia2V5X2hhc2hfc2V0KSB7CisJCXU4IGhhc2hbV1BTX0hBU0hfTEVOXTsKKwkJc2hhMjU2X3ZlY3RvcigxLCAmcGssICZwa19sZW4sIGhhc2gpOworCQlpZiAob3NfbWVtY21wX2NvbnN0KGhhc2gsIHdwcy0+cGVlcl9wdWJrZXlfaGFzaCwKKwkJCQkgICAgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pICE9IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV1BTOiBQdWJsaWMgS2V5IGhhc2ggbWlzbWF0Y2giKTsKKwkJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldQUzogUmVjZWl2ZWQgcHVibGljIGtleSIsCisJCQkJICAgIHBrLCBwa19sZW4pOworCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBDYWxjdWxhdGVkIHB1YmxpYyBrZXkgIgorCQkJCSAgICAiaGFzaCIsIGhhc2gsIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOKTsKKwkJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldQUzogRXhwZWN0ZWQgcHVibGljIGtleSBoYXNoIiwKKwkJCQkgICAgd3BzLT5wZWVyX3B1YmtleV9oYXNoLAorCQkJCSAgICBXUFNfT09CX1BVQktFWV9IQVNIX0xFTik7CisJCQl3cHMtPmNvbmZpZ19lcnJvciA9IFdQU19DRkdfUFVCTElDX0tFWV9IQVNIX01JU01BVENIOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorCiAJd3BhYnVmX2ZyZWUod3BzLT5kaF9wdWJrZXlfcik7CiAJd3BzLT5kaF9wdWJrZXlfciA9IHdwYWJ1Zl9hbGxvY19jb3B5KHBrLCBwa19sZW4pOwogCWlmICh3cHMtPmRoX3B1YmtleV9yID09IE5VTEwpCkBAIC01NzksNyArNjA1LDcgQEAKIAlsZW5bM10gPSB3cGFidWZfbGVuKHdwcy0+ZGhfcHVia2V5X3IpOwogCWhtYWNfc2hhMjU2X3ZlY3Rvcih3cHMtPmF1dGhrZXksIFdQU19BVVRIS0VZX0xFTiwgNCwgYWRkciwgbGVuLCBoYXNoKTsKIAotCWlmIChvc19tZW1jbXAod3BzLT5wZWVyX2hhc2gxLCBoYXNoLCBXUFNfSEFTSF9MRU4pICE9IDApIHsKKwlpZiAob3NfbWVtY21wX2NvbnN0KHdwcy0+cGVlcl9oYXNoMSwgaGFzaCwgV1BTX0hBU0hfTEVOKSAhPSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBSLUhhc2gxIGRlcml2ZWQgZnJvbSBSLVMxIGRvZXMgIgogCQkJICAgIm5vdCBtYXRjaCB3aXRoIHRoZSBwcmUtY29tbWl0dGVkIHZhbHVlIik7CiAJCXdwcy0+Y29uZmlnX2Vycm9yID0gV1BTX0NGR19ERVZfUEFTU1dPUkRfQVVUSF9GQUlMVVJFOwpAQCAtNjE5LDcgKzY0NSw3IEBACiAJbGVuWzNdID0gd3BhYnVmX2xlbih3cHMtPmRoX3B1YmtleV9yKTsKIAlobWFjX3NoYTI1Nl92ZWN0b3Iod3BzLT5hdXRoa2V5LCBXUFNfQVVUSEtFWV9MRU4sIDQsIGFkZHIsIGxlbiwgaGFzaCk7CiAKLQlpZiAob3NfbWVtY21wKHdwcy0+cGVlcl9oYXNoMiwgaGFzaCwgV1BTX0hBU0hfTEVOKSAhPSAwKSB7CisJaWYgKG9zX21lbWNtcF9jb25zdCh3cHMtPnBlZXJfaGFzaDIsIGhhc2gsIFdQU19IQVNIX0xFTikgIT0gMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogUi1IYXNoMiBkZXJpdmVkIGZyb20gUi1TMiBkb2VzICIKIAkJCSAgICJub3QgbWF0Y2ggd2l0aCB0aGUgcHJlLWNvbW1pdHRlZCB2YWx1ZSIpOwogCQl3cHMtPmNvbmZpZ19lcnJvciA9IFdQU19DRkdfREVWX1BBU1NXT1JEX0FVVEhfRkFJTFVSRTsKQEAgLTY3MCw3ICs2OTYsNiBAQAogI2VuZGlmIC8qIENPTkZJR19XUFNfU1RSSUNUICovCiAJfQogCi0jaWZkZWYgQ09ORklHX1dQUzIKIAlpZiAoISh3cHMtPmNyZWQuZW5jcl90eXBlICYKIAkgICAgICAoV1BTX0VOQ1JfTk9ORSB8IFdQU19FTkNSX1RLSVAgfCBXUFNfRU5DUl9BRVMpKSkgewogCQlpZiAod3BzLT5jcmVkLmVuY3JfdHlwZSAmIFdQU19FTkNSX1dFUCkgewpAQCAtNjg0LDcgKzcwOSw2IEBACiAJCQkgICAiaW52YWxpZCBlbmNyX3R5cGUgMHgleCIsIHdwcy0+Y3JlZC5lbmNyX3R5cGUpOwogCQlyZXR1cm4gLTE7CiAJfQotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAKIAlpZiAod3BzLT53cHMtPmNyZWRfY2IpIHsKIAkJd3BzLT5jcmVkLmNyZWRfYXR0ciA9IGNyZWQgLSA0OwpAQCAtNzcxLDcgKzc5NSw2IEBACiAjZW5kaWYgLyogQ09ORklHX1dQU19TVFJJQ1QgKi8KIAl9CiAKLSNpZmRlZiBDT05GSUdfV1BTMgogCWlmICghKGNyZWQuZW5jcl90eXBlICYgKFdQU19FTkNSX05PTkUgfCBXUFNfRU5DUl9US0lQIHwgV1BTX0VOQ1JfQUVTKSkpCiAJewogCQlpZiAoY3JlZC5lbmNyX3R5cGUgJiBXUFNfRU5DUl9XRVApIHsKQEAgLTc4NSw3ICs4MDgsNiBAQAogCQkJICAgImludmFsaWQgZW5jcl90eXBlIDB4JXgiLCBjcmVkLmVuY3JfdHlwZSk7CiAJCXJldHVybiAtMTsKIAl9Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIAogI2lmZGVmIENPTkZJR19XUFNfU1RSSUNUCiAJaWYgKHdwczIpIHsKQEAgLTgwMiw3ICs4MjQsNiBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfV1BTX1NUUklDVCAqLwogCi0jaWZkZWYgQ09ORklHX1dQUzIKIAlpZiAoKGNyZWQuZW5jcl90eXBlICYgKFdQU19FTkNSX1RLSVAgfCBXUFNfRU5DUl9BRVMpKSA9PSBXUFNfRU5DUl9US0lQKQogCXsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFVwZ3JhZGUgZW5jcl90eXBlIFRLSVAgLT4gIgpAQCAtODE2LDcgKzgzNyw2IEBACiAJCQkgICAiV1BBUFNLK1dQQTJQU0siKTsKIAkJY3JlZC5hdXRoX3R5cGUgfD0gV1BTX0FVVEhfV1BBMlBTSzsKIAl9Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIAogCWlmICh3cHMtPndwcy0+Y3JlZF9jYikgewogCQljcmVkLmNyZWRfYXR0ciA9IHdwYWJ1Zl9oZWFkKGF0dHJzKTsKQEAgLTg2NCw5ICs4ODQsMTUgQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogUmVnaXN0cmFyIHRyeWluZyB0byBjaGFuZ2UgRGV2aWNlIFBhc3N3b3JkICIKIAkJICAgIklEIGZyb20gJXUgdG8gJXUiLCB3cHMtPmRldl9wd19pZCwgaWQpOwogCisJaWYgKHdwcy0+ZGV2X3B3X2lkID09IERFVl9QV19QVVNIQlVUVE9OICYmIGlkID09IERFVl9QV19ERUZBVUxUKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJICAgIldQUzogV29ya2Fyb3VuZCAtIGlnbm9yZSBQQkMtdG8tUElOIGNoYW5nZSIpOworCQlyZXR1cm4gMDsKKwl9CisKIAlpZiAod3BzLT5hbHRfZGV2X3Bhc3N3b3JkICYmIHdwcy0+YWx0X2Rldl9wd19pZCA9PSBpZCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogRm91bmQgYSBtYXRjaGluZyBEZXZpY2UgUGFzc3dvcmQiKTsKLQkJb3NfZnJlZSh3cHMtPmRldl9wYXNzd29yZCk7CisJCWJpbl9jbGVhcl9mcmVlKHdwcy0+ZGV2X3Bhc3N3b3JkLCB3cHMtPmRldl9wYXNzd29yZF9sZW4pOwogCQl3cHMtPmRldl9wd19pZCA9IHdwcy0+YWx0X2Rldl9wd19pZDsKIAkJd3BzLT5kZXZfcGFzc3dvcmQgPSB3cHMtPmFsdF9kZXZfcGFzc3dvcmQ7CiAJCXdwcy0+ZGV2X3Bhc3N3b3JkX2xlbiA9IHdwcy0+YWx0X2Rldl9wYXNzd29yZF9sZW47CkBAIC05MjMsNiArOTQ5LDM4IEBACiAJCXJldHVybiBXUFNfQ09OVElOVUU7CiAJfQogCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwlpZiAod3BzLT5wZWVyX3B1YmtleV9oYXNoX3NldCkgeworCQlzdHJ1Y3Qgd3BhYnVmICpkZWNyeXB0ZWQ7CisJCXN0cnVjdCB3cHNfcGFyc2VfYXR0ciBlYXR0cjsKKworCQlkZWNyeXB0ZWQgPSB3cHNfZGVjcnlwdF9lbmNyX3NldHRpbmdzKHdwcywgYXR0ci0+ZW5jcl9zZXR0aW5ncywKKwkJCQkJCSAgICAgIGF0dHItPmVuY3Jfc2V0dGluZ3NfbGVuKTsKKwkJaWYgKGRlY3J5cHRlZCA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogRmFpbGVkIHRvIGRlY3J5cHQgIgorCQkJCSAgICJFbmNyeXB0ZWQgU2V0dGluZ3MgYXR0cmlidXRlIik7CisJCQl3cHMtPnN0YXRlID0gU0VORF9XU0NfTkFDSzsKKwkJCXJldHVybiBXUFNfQ09OVElOVUU7CisJCX0KKworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogUHJvY2Vzc2luZyBkZWNyeXB0ZWQgRW5jcnlwdGVkICIKKwkJCSAgICJTZXR0aW5ncyBhdHRyaWJ1dGUiKTsKKwkJaWYgKHdwc19wYXJzZV9tc2coZGVjcnlwdGVkLCAmZWF0dHIpIDwgMCB8fAorCQkgICAgd3BzX3Byb2Nlc3Nfa2V5X3dyYXBfYXV0aCh3cHMsIGRlY3J5cHRlZCwKKwkJCQkJICAgICAgZWF0dHIua2V5X3dyYXBfYXV0aCkgfHwKKwkJICAgIHdwc19wcm9jZXNzX2NyZWRzKHdwcywgZWF0dHIuY3JlZCwgZWF0dHIuY3JlZF9sZW4sCisJCQkJICAgICAgZWF0dHIubnVtX2NyZWQsIGF0dHItPnZlcnNpb24yICE9IE5VTEwpKSB7CisJCQl3cGFidWZfZnJlZShkZWNyeXB0ZWQpOworCQkJd3BzLT5zdGF0ZSA9IFNFTkRfV1NDX05BQ0s7CisJCQlyZXR1cm4gV1BTX0NPTlRJTlVFOworCQl9CisJCXdwYWJ1Zl9mcmVlKGRlY3J5cHRlZCk7CisKKwkJd3BzLT5zdGF0ZSA9IFdQU19NU0dfRE9ORTsKKwkJcmV0dXJuIFdQU19DT05USU5VRTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKwogCXdwcy0+c3RhdGUgPSBTRU5EX00zOwogCXJldHVybiBXUFNfQ09OVElOVUU7CiB9CmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19lci5jIGIvc3JjL3dwcy93cHNfZXIuYwppbmRleCA1Njk0OTk3Li4wNzhmZjcyIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19lci5jCisrKyBiL3NyYy93cHMvd3BzX2VyLmMKQEAgLTE4NSwxMCArMTg1LDggQEAKIAlkbF9saXN0X2RlbCgmYXAtPmxpc3QpOwogCXdwc19lcl9hcF9mcmVlKGFwKTsKIAotCWlmIChlci0+ZGVpbml0aWFsaXppbmcgJiYgZGxfbGlzdF9lbXB0eSgmZXItPmFwX3Vuc3Vic2NyaWJpbmcpKSB7Ci0JCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwc19lcl9kZWluaXRfZmluaXNoLCBlciwgTlVMTCk7CisJaWYgKGVyLT5kZWluaXRpYWxpemluZyAmJiBkbF9saXN0X2VtcHR5KCZlci0+YXBfdW5zdWJzY3JpYmluZykpCiAJCXdwc19lcl9kZWluaXRfZmluaXNoKGVyLCBOVUxMKTsKLQl9CiB9CiAKIApAQCAtNTgxLDEyICs1NzksMTUgQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBFUjogc2VyaWFsTnVtYmVyPSclcyciLCBhcC0+c2VyaWFsX251bWJlcik7CiAKIAlhcC0+dWRuID0geG1sX2dldF9maXJzdF9pdGVtKGRhdGEsICJVRE4iKTsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBFUjogVUROPSclcyciLCBhcC0+dWRuKTsKLQlwb3MgPSBvc19zdHJzdHIoYXAtPnVkbiwgInV1aWQ6Iik7Ci0JaWYgKHBvcykgewotCQlwb3MgKz0gNTsKLQkJaWYgKHV1aWRfc3RyMmJpbihwb3MsIGFwLT51dWlkKSA8IDApCi0JCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBFUjogSW52YWxpZCBVVUlEIGluIFVETiIpOworCWlmIChhcC0+dWRuKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTIEVSOiBVRE49JyVzJyIsIGFwLT51ZG4pOworCQlwb3MgPSBvc19zdHJzdHIoYXAtPnVkbiwgInV1aWQ6Iik7CisJCWlmIChwb3MpIHsKKwkJCXBvcyArPSA1OworCQkJaWYgKHV1aWRfc3RyMmJpbihwb3MsIGFwLT51dWlkKSA8IDApCisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkJCSAgICJXUFMgRVI6IEludmFsaWQgVVVJRCBpbiBVRE4iKTsKKwkJfQogCX0KIAogCWFwLT51cGMgPSB4bWxfZ2V0X2ZpcnN0X2l0ZW0oZGF0YSwgIlVQQyIpOwpAQCAtMTM0Nyw5ICsxMzQ4LDE5IEBACiAJc3RydWN0IHdwc19lciAqZXIgPSBlbG9vcF9kYXRhOwogCXZvaWQgKCpkZWluaXRfZG9uZV9jYikodm9pZCAqY3R4KTsKIAl2b2lkICpkZWluaXRfZG9uZV9jdHg7CisJc3RydWN0IHdwc19lcl9hcCAqYXAsICp0bXA7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBFUjogRmluaXNoaW5nIGRlaW5pdCIpOwogCisJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKGFwLCB0bXAsICZlci0+YXBfdW5zdWJzY3JpYmluZywgc3RydWN0IHdwc19lcl9hcCwKKwkJCSAgICAgIGxpc3QpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFMgRVI6IEFQIGVudHJ5IGZvciAlcyAoJXMpIHN0aWxsIGluIGFwX3Vuc3Vic2NyaWJpbmcgbGlzdCAtIGZyZWUgaXQiLAorCQkJICAgaW5ldF9udG9hKGFwLT5hZGRyKSwgYXAtPmxvY2F0aW9uKTsKKwkJZGxfbGlzdF9kZWwoJmFwLT5saXN0KTsKKwkJd3BzX2VyX2FwX2ZyZWUoYXApOworCX0KKworCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwc19lcl9kZWluaXRfZmluaXNoLCBlciwgTlVMTCk7CiAJZGVpbml0X2RvbmVfY2IgPSBlci0+ZGVpbml0X2RvbmVfY2I7CiAJZGVpbml0X2RvbmVfY3R4ID0gZXItPmRlaW5pdF9kb25lX2N0eDsKIAlvc19mcmVlKGVyLT5pcF9hZGRyX3RleHQpOwpAQCAtMTQ4MiwxMSArMTQ5Myw5IEBACiAKIHN0YXRpYyBpbnQgd3BzX2VyX2J1aWxkX3V1aWRfcihzdHJ1Y3Qgd3BhYnVmICptc2csIGNvbnN0IHU4ICp1dWlkX3IpCiB7Ci0jaWZkZWYgQ09ORklHX1dQUzIKIAl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX1VVSURfUik7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgV1BTX1VVSURfTEVOKTsKIAl3cGFidWZfcHV0X2RhdGEobXNnLCB1dWlkX3IsIFdQU19VVUlEX0xFTik7Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIAlyZXR1cm4gMDsKIH0KIApAQCAtMTQ5OCw5ICsxNTA3LDcgQEAKIAlzdHJ1Y3Qgd3BzX2VyX2FwICphcDsKIAlzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnID0gZXItPndwcy0+cmVnaXN0cmFyOwogCWNvbnN0IHU4ICphdXRoX21hY3M7Ci0jaWZkZWYgQ09ORklHX1dQUzIKIAl1OCBiY2FzdFtFVEhfQUxFTl07Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIAlzaXplX3QgY291bnQ7CiAJdW5pb24gd3BzX2V2ZW50X2RhdGEgZGF0YTsKIApAQCAtMTUxNCwxMyArMTUyMSwxMSBAQAogCQlyZXR1cm47CiAKIAlhdXRoX21hY3MgPSB3cHNfYXV0aG9yaXplZF9tYWNzKHJlZywgJmNvdW50KTsKLSNpZmRlZiBDT05GSUdfV1BTMgogCWlmIChjb3VudCA9PSAwKSB7CiAJCW9zX21lbXNldChiY2FzdCwgMHhmZiwgRVRIX0FMRU4pOwogCQlhdXRoX21hY3MgPSBiY2FzdDsKIAkJY291bnQgPSAxOwogCX0KLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogCiAJaWYgKHdwc19idWlsZF92ZXJzaW9uKG1zZykgfHwKIAkgICAgd3BzX2VyX2J1aWxkX3NlbGVjdGVkX3JlZ2lzdHJhcihtc2csIHNlbF9yZWcpIHx8CkBAIC0yMDMyLDggKzIwMzcsNyBAQAogCW9zX21lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKIAlkYXRhLndwcyA9IHdwczsKIAlkYXRhLnVzZV9jcmVkID0gY3JlZDsKLQlpZiAod3BzX2J1aWxkX3ZlcnNpb24ocmV0KSB8fAotCSAgICB3cHNfYnVpbGRfY3JlZCgmZGF0YSwgcmV0KSB8fAorCWlmICh3cHNfYnVpbGRfY3JlZCgmZGF0YSwgcmV0KSB8fAogCSAgICB3cHNfYnVpbGRfd2ZhX2V4dChyZXQsIDAsIE5VTEwsIDApKSB7CiAJCXdwYWJ1Zl9mcmVlKHJldCk7CiAJCXJldHVybiBOVUxMOwpAQCAtMjA2Myw0ICsyMDY3LDI5IEBACiAJcmV0dXJuIHdwc19lcl9jb25maWdfdG9rZW5fZnJvbV9jcmVkKGVyLT53cHMsIGFwLT5hcF9zZXR0aW5ncyk7CiB9CiAKKworc3RydWN0IHdwYWJ1ZiAqIHdwc19lcl9uZmNfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cHNfZXIgKmVyLAorCQkJCQlzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgY29uc3QgdTggKnV1aWQsCisJCQkJCWNvbnN0IHU4ICphZGRyLCBzdHJ1Y3Qgd3BhYnVmICpwdWJrZXkpCit7CisJc3RydWN0IHdwc19lcl9hcCAqYXA7CisKKwlpZiAoZXIgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlhcCA9IHdwc19lcl9hcF9nZXQoZXIsIE5VTEwsIHV1aWQsIGFkZHIpOworCWlmIChhcCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlpZiAoYXAtPmFwX3NldHRpbmdzID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFMgRVI6IE5vIHNldHRpbmdzIGtub3duIGZvciB0aGUgIgorCQkJICAgInNlbGVjdGVkIEFQIik7CisJCXJldHVybiBOVUxMOworCX0KKworCW9zX21lbWNweSh3cHMtPnNzaWQsIGFwLT5hcF9zZXR0aW5ncy0+c3NpZCwgYXAtPmFwX3NldHRpbmdzLT5zc2lkX2xlbik7CisJd3BzLT5zc2lkX2xlbiA9IGFwLT5hcF9zZXR0aW5ncy0+c3NpZF9sZW47CisKKwlyZXR1cm4gd3BzX2J1aWxkX25mY19oYW5kb3Zlcl9zZWwod3BzLCBwdWJrZXksIGFkZHIsIDApOworfQorCiAjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX2kuaCBiL3NyYy93cHMvd3BzX2kuaAppbmRleCBkYWMxMjUwLi5mNzE1NGY4IDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19pLmgKKysrIGIvc3JjL3dwcy93cHNfaS5oCkBAIC03NSw2ICs3NSw5IEBACiAJc2l6ZV90IGFsdF9kZXZfcGFzc3dvcmRfbGVuOwogCXUxNiBhbHRfZGV2X3B3X2lkOwogCisJdTggcGVlcl9wdWJrZXlfaGFzaFtXUFNfT09CX1BVQktFWV9IQVNIX0xFTl07CisJaW50IHBlZXJfcHVia2V5X2hhc2hfc2V0OworCiAJLyoqCiAJICogcmVxdWVzdF90eXBlIC0gUmVxdWVzdCBUeXBlIGF0dHJpYnV0ZSBmcm9tIChSZSlBc3NvY1JlcQogCSAqLwpAQCAtMTczLDYgKzE3Niw4IEBACiAJCQkgc2l6ZV90IGRldl9wd19sZW4pOwogc3RydWN0IHdwYWJ1ZiAqIHdwc19pZV9lbmNhcHN1bGF0ZShzdHJ1Y3Qgd3BhYnVmICpkYXRhKTsKIGludCB3cHNfYnVpbGRfbWFjX2FkZHIoc3RydWN0IHdwYWJ1ZiAqbXNnLCBjb25zdCB1OCAqYWRkcik7CitpbnQgd3BzX2J1aWxkX3JmX2JhbmRzX2F0dHIoc3RydWN0IHdwYWJ1ZiAqbXNnLCB1OCByZl9iYW5kcyk7CitpbnQgd3BzX2J1aWxkX2FwX2NoYW5uZWwoc3RydWN0IHdwYWJ1ZiAqbXNnLCB1MTYgYXBfY2hhbm5lbCk7CiAKIC8qIHdwc19hdHRyX3Byb2Nlc3MuYyAqLwogaW50IHdwc19wcm9jZXNzX2F1dGhlbnRpY2F0b3Ioc3RydWN0IHdwc19kYXRhICp3cHMsIGNvbnN0IHU4ICphdXRoZW50aWNhdG9yLApAQCAtMjA3LDUgKzIxMiw3IEBACiAJCQkgICAgICBjb25zdCB1OCAqYWRkciwgY29uc3QgdTggKnV1aWRfZSk7CiB2b2lkIHdwc19yZWdpc3RyYXJfcmVtb3ZlX25mY19wd190b2tlbihzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLAogCQkJCSAgICAgICBzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiAqdG9rZW4pOworaW50IHdwc19jYl9uZXdfcHNrKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWcsIGNvbnN0IHU4ICptYWNfYWRkciwKKwkJICAgY29uc3QgdTggKnAycF9kZXZfYWRkciwgY29uc3QgdTggKnBzaywgc2l6ZV90IHBza19sZW4pOwogCiAjZW5kaWYgLyogV1BTX0lfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfbW9kdWxlX3Rlc3RzLmMgYi9zcmMvd3BzL3dwc19tb2R1bGVfdGVzdHMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ODAwZTg2Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3dwcy93cHNfbW9kdWxlX3Rlc3RzLmMKQEAgLTAsMCArMSwzMzcgQEAKKy8qCisgKiBXUFMgbW9kdWxlIHRlc3RzCisgKiBDb3B5cmlnaHQgKGMpIDIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgIndwc19hdHRyX3BhcnNlLmgiCisKK3N0cnVjdCB3cHNfYXR0cl9wYXJzZV90ZXN0IHsKKwljb25zdCBjaGFyICpkYXRhOworCWludCByZXN1bHQ7CisJaW50IGV4dHJhOworfTsKKworc3RydWN0IHdwc19hdHRyX3BhcnNlX3Rlc3Qgd3BzX2F0dHJfcGFyc2VfdGVzdF9jYXNlc1tdID0geworCS8qIEVtcHR5IG1lc3NhZ2UgKi8KKwl7ICIiLCAwLCAwIH0sCisJLyogVHJ1bmNhdGVkIGF0dHJpYnV0ZSBoZWFkZXIgKi8KKwl7ICIxMCIsIC0xLCAwIH0sCisJeyAiMTAxMCIsIC0xLCAwIH0sCisJeyAiMTAxMDAwIiwgLTEsIDAgfSwKKwkvKiBBdHRyaWJ1dGUgb3ZlcmZsb3cgKi8KKwl7ICIxMDEwMDAwMSIsIC0xLCAwIH0sCisjaWZkZWYgQ09ORklHX1dQU19TVFJJQ1QKKwl7ICIxMDI3MDAwMDAwMTA1NzAwMDEwMSIsIC0xLCAwIH0sCisJeyAiMTAyNzAwMDAxMDU3MDAwMTAxMDAwMDAwMDAwMCIsIC0xLCAwIH0sCisjZWxzZSAvKiBDT05GSUdfV1BTX1NUUklDVCAqLworCS8qIE5ldHdvcmsgS2V5IHdvcmthcm91bmQgKi8KKwl7ICIxMDI3MDAwMDAwMTA1NzAwMDEwMSIsIDAsIDEgfSwKKwl7ICIxMDIzMDAwMDAwMTA1NzAwMDEwMSIsIC0xLCAwIH0sCisJeyAiMTAyNzAwMDAxMDEwNTcwMDAxMDEiLCAtMSwgMCB9LAorCS8qIE1hYyBPUyBYIDEwLjYgcGFkZGluZyB3b3JrYXJvdW5kICovCisJeyAiMTAyNzAwMDAxMDU3MDAwMTAxMDAwMDAwMDAwMCIsIDAsIDEgfSwKKwl7ICIxMDI3MDAwMDEwNTcwMDAxMDEwMDAwMDAwMDAwMDAwMDAxMDAwMDAwIiwgLTEsIDAgfSwKKyNlbmRpZiAvKiBDT05GSUdfV1BTX1NUUklDVCAqLworCS8qIFZlcnNpb24gKi8KKwl7ICIxMDRhMDAwMTEwIiwgMCwgMCB9LAorCXsgIjEwNGEwMDAwIiwgLTEsIDAgfSwKKwkvKiBNZXNzYWdlIFR5cGUgKi8KKwl7ICIxMDIyMDAwMTAxIiwgMCwgMCB9LAorCXsgIjEwMjIwMDAwIiwgLTEsIDAgfSwKKwkvKiBFbnJvbGxlZSBOb25jZSAqLworCXsgIjEwMWEwMDEwMDAxMTIyMzM0NDU1NjY3Nzg4OTlhYWJiY2NkZGVlZmYiLCAwLCAwIH0sCisJeyAiMTAxYTAwMTExMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3IiwgLTEsIDAgfSwKKwkvKiBSZWdpc3RyYXIgTm9uY2UgKi8KKwl7ICIxMDM5MDAxMDAwMTEyMjMzNDQ1NTY2Nzc4ODk5YWFiYmNjZGRlZWZmIiwgMCwgMCB9LAorCXsgIjEwMzkwMDExMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3NyIsIC0xLCAwIH0sCisJLyogVVVJRC1FICovCisJeyAiMTA0NzAwMTAwMDExMjIzMzQ0NTU2Njc3ODg5OWFhYmJjY2RkZWVmZiIsIDAsIDAgfSwKKwl7ICIxMDQ3MDAwMCIsIC0xLCAwIH0sCisJeyAiMTA0NzAwMTExMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3IiwgLTEsIDAgfSwKKwkvKiBVVUlELVIgKi8KKwl7ICIxMDQ4MDAxMDAwMTEyMjMzNDQ1NTY2Nzc4ODk5YWFiYmNjZGRlZWZmIiwgMCwgMCB9LAorCXsgIjEwNDgwMDAwIiwgLTEsIDAgfSwKKwl7ICIxMDQ4MDAxMTExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2NzciLCAtMSwgMCB9LAorCS8qIEF1dGggVHlwZSBGbGFncyAqLworCXsgIjEwMDQwMDAyMTEyMiIsIDAsIDAgfSwKKwl7ICIxMDA0MDAwMWZmIiwgLTEsIDAgfSwKKwkvKiBFbmNyIFR5cGUgRmxhZ3MgKi8KKwl7ICIxMDEwMDAwMjExMjIiLCAwLCAwIH0sCisJeyAiMTAxMDAwMDFmZiIsIC0xLCAwIH0sCisJLyogQ29ubmVjdGlvbiBUeXBlIEZsYWdzICovCisJeyAiMTAwZDAwMDFmZiIsIDAsIDAgfSwKKwl7ICIxMDBkMDAwMmZmZmYiLCAtMSwgMCB9LAorCS8qIENvbmZpZyBNZXRob2RzICovCisJeyAiMTAwODAwMDJmZmZmIiwgMCwgMCB9LAorCXsgIjEwMDgwMDAxZmYiLCAtMSwgMCB9LAorCS8qIFNlbGVjdGVkIFJlZ2lzdHJhciBDb25maWcgTWV0aG9kcyAqLworCXsgIjEwNTMwMDAyZmZmZiIsIDAsIDAgfSwKKwl7ICIxMDUzMDAwMWZmIiwgLTEsIDAgfSwKKwkvKiBQcmltYXJ5IERldmljZSBUeXBlICovCisJeyAiMTA1NDAwMDgxMTIyMzM0NDU1NjY3Nzg4IiwgMCwgMCB9LAorCXsgIjEwNTQwMDExMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3NyIsIC0xLCAwIH0sCisJLyogUkYgQmFuZHMgKi8KKwl7ICIxMDNjMDAwMWZmIiwgMCwgMCB9LAorCXsgIjEwM2MwMDAyZmZmZiIsIC0xLCAwIH0sCisJLyogQXNzb2NpYXRpb24gU3RhdGUgKi8KKwl7ICIxMDAyMDAwMmZmZmYiLCAwLCAwIH0sCisJeyAiMTAwMjAwMDFmZiIsIC0xLCAwIH0sCisJLyogQ29uZmlnIEVycm9yICovCisJeyAiMTAwOTAwMDIwMDAxIiwgMCwgMCB9LAorCXsgIjEwMDkwMDAxZmYiLCAtMSwgMCB9LAorCS8qIERldmljZSBQYXNzd29yZCBJRCAqLworCXsgIjEwMTIwMDAyMDAwNCIsIDAsIDAgfSwKKwl7ICIxMDEyMDAwMWZmIiwgLTEsIDAgfSwKKwkvKiBPT0IgRGV2aWNlIFBhc3N3b3JkICovCisJeyAiMTAyYzAwMTYxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMDAwNyIsIDAsIDAgfSwKKwl7ICIxMDJjMDAzNjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NCIsIDAsIDAgfSwKKwl7ICIxMDJjMDAwMWZmIiwgLTEsIDAgfSwKKwl7ICIxMDJjMDAzNzExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1IiwgLTEsIDAgfSwKKwl7ICIxMDJjMDAyNTExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3IiwgLTEsIDAgfSwKKwkvKiBPUyBWZXJzaW9uICovCisJeyAiMTAyZDAwMDQxMTIyMzM0NCIsIDAsIDAgfSwKKwl7ICIxMDJkMDAxMTExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2NzciLCAtMSwgMCB9LAorCS8qIFdQUyBTdGF0ZSAqLworCXsgIjEwNDQwMDAxMDEiLCAwLCAwIH0sCisJeyAiMTA0NDAwMDJmZmZmIiwgLTEsIDAgfSwKKwkvKiBBdXRoZW50aWNhdG9yICovCisJeyAiMTAwNTAwMDgxMTIyMzM0NDU1NjY3Nzg4IiwgMCwgMCB9LAorCXsgIjEwMDUwMDAwIiwgLTEsIDAgfSwKKwl7ICIxMDA1MDAxMTExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2NzciLCAtMSwgMCB9LAorCS8qIFItSGFzaDEgKi8KKwl7ICIxMDNkMDAyMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIiLCAwLCAwIH0sCisJeyAiMTAzZDAwMDAiLCAtMSwgMCB9LAorCXsgIjEwM2QwMDIxMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzIiwgLTEsIDAgfSwKKwkvKiBSLUhhc2gyICovCisJeyAiMTAzZTAwMjAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyIiwgMCwgMCB9LAorCXsgIjEwM2UwMDAwIiwgLTEsIDAgfSwKKwl7ICIxMDNlMDAyMTExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMyIsIC0xLCAwIH0sCisJLyogRS1IYXNoMSAqLworCXsgIjEwMTQwMDIwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMiIsIDAsIDAgfSwKKwl7ICIxMDE0MDAwMCIsIC0xLCAwIH0sCisJeyAiMTAxNDAwMjExMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzMiLCAtMSwgMCB9LAorCS8qIEUtSGFzaDIgKi8KKwl7ICIxMDE1MDAyMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIiLCAwLCAwIH0sCisJeyAiMTAxNTAwMDAiLCAtMSwgMCB9LAorCXsgIjEwMTUwMDIxMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzIiwgLTEsIDAgfSwKKwkvKiBSLVNOb25jZTEgKi8KKwl7ICIxMDNmMDAxMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2IiwgMCwgMCB9LAorCXsgIjEwM2YwMDAwIiwgLTEsIDAgfSwKKwl7ICIxMDNmMDAxMTExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2NzciLCAtMSwgMCB9LAorCS8qIFItU05vbmNlMiAqLworCXsgIjEwNDAwMDEwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjYiLCAwLCAwIH0sCisJeyAiMTA0MDAwMDAiLCAtMSwgMCB9LAorCXsgIjEwNDAwMDExMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3NyIsIC0xLCAwIH0sCisJLyogRS1TTm9uY2UxICovCisJeyAiMTAxNjAwMTAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2NiIsIDAsIDAgfSwKKwl7ICIxMDE2MDAwMCIsIC0xLCAwIH0sCisJeyAiMTAxNjAwMTExMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3IiwgLTEsIDAgfSwKKwkvKiBFLVNOb25jZTIgKi8KKwl7ICIxMDE3MDAxMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2IiwgMCwgMCB9LAorCXsgIjEwMTcwMDAwIiwgLTEsIDAgfSwKKwl7ICIxMDE3MDAxMTExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2NzciLCAtMSwgMCB9LAorCS8qIEtleSBXcmFwIEF1dGhlbnRpY2F0b3IgKi8KKwl7ICIxMDFlMDAwODExMjIzMzQ0NTU2Njc3ODgiLCAwLCAwIH0sCisJeyAiMTAxZTAwMDAiLCAtMSwgMCB9LAorCXsgIjEwMWUwMDA5MTEyMjMzNDQ1NTY2Nzc4ODk5IiwgLTEsIDAgfSwKKwkvKiBBdXRoZW50aWNhdGlvbiBUeXBlICovCisJeyAiMTAwMzAwMDIwMDAxIiwgMCwgMCB9LAorCXsgIjEwMDMwMDAxZmYiLCAtMSwgMCB9LAorCS8qIEVuY3J5cHRpb24gVHlwZSAqLworCXsgIjEwMGYwMDAyMDAwMSIsIDAsIDAgfSwKKwl7ICIxMDBmMDAwMWZmIiwgLTEsIDAgfSwKKwkvKiBOZXR3b3JrIEluZGV4ICovCisJeyAiMTAyNjAwMDEwMSIsIDAsIDAgfSwKKwl7ICIxMDI2MDAwMmZmZmYiLCAtMSwgMCB9LAorCS8qIE5ldHdvcmsgS2V5IEluZGV4ICovCisJeyAiMTAyODAwMDEwMSIsIDAsIDMgfSwKKwl7ICIxMDI4MDAwMmZmZmYiLCAtMSwgMCB9LAorCS8qIE1BQyBBZGRyZXNzICovCisJeyAiMTAyMDAwMDYxMTIyMzM0NDU1NjYiLCAwLCAwIH0sCisJeyAiMTAyMDAwMDAiLCAtMSwgMCB9LAorCXsgIjEwMjAwMDA3MTEyMjMzNDQ1NTY2NzciLCAtMSwgMCB9LAorCS8qIFNlbGVjdGVkIFJlZ2lzdHJhciAqLworCXsgIjEwNDEwMDAxMDEiLCAwLCAwIH0sCisJeyAiMTA0MTAwMDJmZmZmIiwgLTEsIDAgfSwKKwkvKiBSZXF1ZXN0IFR5cGUgKi8KKwl7ICIxMDNhMDAwMTAxIiwgMCwgMCB9LAorCXsgIjEwM2EwMDAyZmZmZiIsIC0xLCAwIH0sCisJLyogUmVzcG9uc2UgVHlwZSAqLworCXsgIjEwM2IwMDAxMDEiLCAwLCAwIH0sCisJeyAiMTAzYjAwMDJmZmZmIiwgLTEsIDAgfSwKKwkvKiBNYW51ZmFjdHVyZXIgKi8KKwl7ICIxMDIxMDAwMCIsIDAsIDAgfSwKKwkvKiBNb2RlbCBOYW1lICovCisJeyAiMTAyMzAwMDAiLCAwLCAwIH0sCisJLyogTW9kZWwgTnVtYmVyICovCisJeyAiMTAyNDAwMDAiLCAwLCAwIH0sCisJLyogU2VyaWFsIE51bWJlciAqLworCXsgIjEwNDIwMDAwIiwgMCwgMCB9LAorCS8qIERldmljZSBOYW1lICovCisJeyAiMTAxMTAwMDAiLCAwLCAwIH0sCisJLyogUHVibGljIEtleSAqLworCXsgIjEwMzIwMDAwIiwgMCwgMCB9LAorCS8qIEVuYyBTZXR0aW5ncyAqLworCXsgIjEwMTgwMDAwIiwgMCwgMCB9LAorCS8qIFNTSUQgKi8KKwl7ICIxMDQ1MDAwMCIsIDAsIDAgfSwKKwkvKiBBUCBTZXR1cCBMb2NrZWQgKi8KKwl7ICIxMDU3MDAwMTAxIiwgMCwgMCB9LAorCXsgIjEwNTcwMDAyZmZmZiIsIC0xLCAwIH0sCisJLyogUmVxdWVzdGVkIERldmljZSBUeXBlICovCisJeyAiMTA2YTAwMDgxMTIyMzM0NDU1NjY3Nzg4IiwgMCwgMCB9LAorCXsgIjEwNmEwMDAwIiwgLTEsIDAgfSwKKwl7ICIxMDZhMDAwOTExMjIzMzQ0NTU2Njc3ODg5OSIsIC0xLCAwIH0sCisJLyogTW9yZSB0aGFuIG1heGltdW0gUmVxdWVzdGVkIERldmljZSBUeXBlIGF0dHJpYnV0ZXMgKi8KKwl7ICIxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgxMDZhMDAwODExMjIzMzQ0NTU2Njc3ODgiLCAwLCA0IH0sCisJLyogU2Vjb25kYXJ5IERldmljZSBUeXBlIExpc3QgKi8KKwl7ICIxMDU1MDAwODExMjIzMzQ0NTU2Njc3ODgiLCAwLCAwIH0sCisJeyAiMTA1NTAwMDcxMTIyMzM0NDU1NjY3NyIsIC0xLCAwIH0sCisJeyAiMTA1NTAwODgxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2NiIsIC0xLCAwIH0sCisJLyogQVAgQ2hhbm5lbCAqLworCXsgIjEwMDEwMDAyMDAwMSIsIDAsIDAgfSwKKwl7ICIxMDAxMDAwMTAxIiwgLTEsIDAgfSwKKwkvKiBTa2lwIGludmFsaWQgVmVuZG9yIEV4dGVuc2lvbiAqLworCXsgIjEwNDkwMDAwIiwgMCwgMCB9LAorCXsgIjEwNDkwMDAxMDAiLCAwLCAwIH0sCisJeyAiMTA0OTAwMDIwMDAwIiwgMCwgMCB9LAorCS8qIFRvbyBsb25nIHVua25vd24gdmVuZG9yIGV4dGVuc2lvbiAqLworCXsgIjEwNDkwNDAxIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAiCisJICAiMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMDExMjIzMzQ0NTU2Njc3ODg5OTAwIgorCSAgIjExMjIzMzQ0NTU2Njc3ODg5OTAwMTEyMjMzNDQ1NTY2Nzc4ODk5MDAxMTIyMzM0NDU1NjY3Nzg4OTkwMCIKKwkgICIxMTIyMzM0NDU1IiwgLTEsIDAgfSwKKwkvKiBNYXhpbXVtIHVua25vd24gdmVuZG9yIGV4dGVuc2lvbnMgKi8KKwl7ICIxMDQ5MDAwMzExMTExMTEwNDkwMDAzMjIyMjIyMTA0OTAwMDMzMzMzMzMxMDQ5MDAwMzQ0NDQ0NDEwNDkwMDAzNTU1NTU1MTA0OTAwMDM2NjY2NjYxMDQ5MDAwMzc3Nzc3NzEwNDkwMDAzODg4ODg4MTA0OTAwMDM5OTk5OTkxMDQ5MDAwM0FBQUFBQSIsIDAsIDUgfSwKKwkvKiBNb3JlIHRoYW4gbWF4aW11bSB1bmtub3duIHZlbmRvciBleHRlbnNpb25zICovCisJeyAiMTA0OTAwMDMxMTExMTExMDQ5MDAwMzIyMjIyMjEwNDkwMDAzMzMzMzMzMTA0OTAwMDM0NDQ0NDQxMDQ5MDAwMzU1NTU1NTEwNDkwMDAzNjY2NjY2MTA0OTAwMDM3Nzc3NzcxMDQ5MDAwMzg4ODg4ODEwNDkwMDAzOTk5OTk5MTA0OTAwMDNBQUFBQUExMDQ5MDAwM0JCQkJCQiIsIC0xLCAwIH0sCisJLyogV0ZBIHZlbmRvciBleHRlbnNpb25zICovCisJeyAiMTA0OTAwMDMwMDM3MmEiLCAwLCAwIH0sCisJeyAiMTA0OTAwMDQwMDM3MmEwMCIsIDAsIDAgfSwKKwl7ICIxMDQ5MDAwNTAwMzcyYTAwMDEiLCAwLCAwIH0sCisJeyAiMTA0OTAwMTYwMDM3MmEwMDAxZmYwMTAwMDIwMTAxMDMwMTAxMDQwMTAxZmYwMGZlMDEwMSIsIDAsIDYgfSwKKwkvKiBJbnZhbGlkIFZlcnNpb24yIGxlbmd0aCAqLworCXsgIjEwNDkwMDA1MDAzNzJhMDAwMCIsIC0xLCAwIH0sCisJLyogSW52YWxpZCBOZXR3b3JrIEtleSBTaGFyZWFibGUgbGVuZ3RoICovCisJeyAiMTA0OTAwMDUwMDM3MmEwMjAwIiwgLTEsIDAgfSwKKwkvKiBJbnZhbGlkIFJlcXVlZHQgVG8gRW5yb2xsIGxlbmd0aCAqLworCXsgIjEwNDkwMDA1MDAzNzJhMDMwMCIsIC0xLCAwIH0sCisJLyogSW52YWxpZCBTZXR0aW5ncyBEZWxheSBUaW1lIGxlbmd0aCAqLworCXsgIjEwNDkwMDA1MDAzNzJhMDQwMCIsIC0xLCAwIH0sCisJLyogTW9yZSB0aGFuIG1heGltdW0gQ3JlZGVudGlhbCBhdHRyaWJ1dGVzICovCisJeyAiMTAwZTAwMDAxMDBlMDAwMDEwMGUwMDAwMTAwZTAwMDAxMDBlMDAwMDEwMGUwMDAwMTAwZTAwMDAxMDBlMDAwMDEwMGUwMDAwMTAwZTAwMDAxMDBlMDAwMDEwMGUwMDAwIiwgMCwgMiB9LAorfTsKKworCitzdGF0aWMgaW50IHdwc19hdHRyX3BhcnNlX3Rlc3RzKHZvaWQpCit7CisJc3RydWN0IHdwc19wYXJzZV9hdHRyIGF0dHI7CisJdW5zaWduZWQgaW50IGk7CisJaW50IHJldCA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV1BTIGF0dHJpYnV0ZSBwYXJzaW5nIHRlc3RzIik7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh3cHNfYXR0cl9wYXJzZV90ZXN0X2Nhc2VzKTsgaSsrKSB7CisJCXN0cnVjdCB3cGFidWYgKmJ1ZjsKKwkJc2l6ZV90IGxlbjsKKwkJc3RydWN0IHdwc19hdHRyX3BhcnNlX3Rlc3QgKnRlc3QgPQorCQkJJndwc19hdHRyX3BhcnNlX3Rlc3RfY2FzZXNbaV07CisKKwkJbGVuID0gb3Nfc3RybGVuKHRlc3QtPmRhdGEpIC8gMjsKKwkJYnVmID0gd3BhYnVmX2FsbG9jKGxlbik7CisJCWlmIChidWYgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJaWYgKGhleHN0cjJiaW4odGVzdC0+ZGF0YSwgd3BhYnVmX3B1dChidWYsIGxlbiksIGxlbikgPCAwKSB7CisJCQl3cGFidWZfZnJlZShidWYpOworCQkJcmV0dXJuIC0xOworCQl9CisJCWlmICh3cHNfcGFyc2VfbXNnKGJ1ZiwgJmF0dHIpICE9IHRlc3QtPnJlc3VsdCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFMgYXR0cmlidXRlIHBhcnNpbmcgdGVzdCAldSBmYWlsZWQ6ICVzIiwKKwkJCQkgICBpLCB0ZXN0LT5kYXRhKTsKKwkJCXJldCA9IC0xOworCQl9CisJCXN3aXRjaCAodGVzdC0+ZXh0cmEpIHsKKwkJY2FzZSAxOgorCQkJaWYgKCFhdHRyLm5ldHdvcmtfa2V5IHx8ICFhdHRyLmFwX3NldHVwX2xvY2tlZCkKKwkJCQlyZXQgPSAtMTsKKwkJCWJyZWFrOworCQljYXNlIDI6CisJCQlpZiAoYXR0ci5udW1fY3JlZCAhPSBNQVhfQ1JFRF9DT1VOVCkKKwkJCQlyZXQgPSAtMTsKKwkJCWJyZWFrOworCQljYXNlIDM6CisJCQlpZiAoIWF0dHIubmV0d29ya19rZXlfaWR4KQorCQkJCXJldCA9IC0xOworCQkJYnJlYWs7CisJCWNhc2UgNDoKKwkJCWlmIChhdHRyLm51bV9yZXFfZGV2X3R5cGUgIT0gTUFYX1JFUV9ERVZfVFlQRV9DT1VOVCkKKwkJCQlyZXQgPSAtMTsKKwkJCWJyZWFrOworCQljYXNlIDU6CisJCQlpZiAoYXR0ci5udW1fdmVuZG9yX2V4dCAhPSBNQVhfV1BTX1BBUlNFX1ZFTkRPUl9FWFQpCisJCQkJcmV0ID0gLTE7CisJCQlicmVhazsKKwkJY2FzZSA2OgorCQkJaWYgKCFhdHRyLnZlcnNpb24yIHx8CisJCQkgICAgIWF0dHIuYXV0aG9yaXplZF9tYWNzIHx8CisJCQkgICAgIWF0dHIubmV0d29ya19rZXlfc2hhcmVhYmxlIHx8CisJCQkgICAgIWF0dHIucmVxdWVzdF90b19lbnJvbGwgfHwKKwkJCSAgICAhYXR0ci5zZXR0aW5nc19kZWxheV90aW1lKQorCQkJCXJldCA9IC0xOworCQkJYnJlYWs7CisJCX0KKwkJd3BhYnVmX2ZyZWUoYnVmKTsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisKK2ludCB3cHNfbW9kdWxlX3Rlc3RzKHZvaWQpCit7CisJaW50IHJldCA9IDA7CisKKwl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV1BTIG1vZHVsZSB0ZXN0cyIpOworCisJaWYgKHdwc19hdHRyX3BhcnNlX3Rlc3RzKCkgPCAwKQorCQlyZXQgPSAtMTsKKworCXJldHVybiByZXQ7Cit9CmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19yZWdpc3RyYXIuYyBiL3NyYy93cHMvd3BzX3JlZ2lzdHJhci5jCmluZGV4IGI3ZmNkOWMuLjAwYzgyOTkgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX3JlZ2lzdHJhci5jCisrKyBiL3NyYy93cHMvd3BzX3JlZ2lzdHJhci5jCkBAIC0zMSwxNiArMzEsMTggQEAKIHN0cnVjdCB3cHNfbmZjX3B3X3Rva2VuIHsKIAlzdHJ1Y3QgZGxfbGlzdCBsaXN0OwogCXU4IHB1YmtleV9oYXNoW1dQU19PT0JfUFVCS0VZX0hBU0hfTEVOXTsKKwl1bnNpZ25lZCBpbnQgcGVlcl9wa19oYXNoX2tub3duOjE7CiAJdTE2IHB3X2lkOwogCXU4IGRldl9wd1tXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4gKiAyICsgMV07CiAJc2l6ZV90IGRldl9wd19sZW47CisJaW50IHBrX2hhc2hfcHJvdmlkZWRfb29iOyAvKiB3aGV0aGVyIG93biBQSyBoYXNoIHdhcyBwcm92aWRlZCBPT0IgKi8KIH07CiAKIAogc3RhdGljIHZvaWQgd3BzX3JlbW92ZV9uZmNfcHdfdG9rZW4oc3RydWN0IHdwc19uZmNfcHdfdG9rZW4gKnRva2VuKQogewogCWRsX2xpc3RfZGVsKCZ0b2tlbi0+bGlzdCk7Ci0Jb3NfZnJlZSh0b2tlbik7CisJYmluX2NsZWFyX2ZyZWUodG9rZW4sIHNpemVvZigqdG9rZW4pKTsKIH0KIAogCkBAIC04MiwxNCArODQsMTQgQEAKICNkZWZpbmUgUElOX0xPQ0tFRCBCSVQoMCkKICNkZWZpbmUgUElOX0VYUElSRVMgQklUKDEpCiAJaW50IGZsYWdzOwotCXN0cnVjdCBvc190aW1lIGV4cGlyYXRpb247CisJc3RydWN0IG9zX3JlbHRpbWUgZXhwaXJhdGlvbjsKIAl1OCBlbnJvbGxlZV9hZGRyW0VUSF9BTEVOXTsKIH07CiAKIAogc3RhdGljIHZvaWQgd3BzX2ZyZWVfcGluKHN0cnVjdCB3cHNfdXVpZF9waW4gKnBpbikKIHsKLQlvc19mcmVlKHBpbi0+cGluKTsKKwliaW5fY2xlYXJfZnJlZShwaW4tPnBpbiwgcGluLT5waW5fbGVuKTsKIAlvc19mcmVlKHBpbik7CiB9CiAKQEAgLTExMyw3ICsxMTUsNyBAQAogCXN0cnVjdCB3cHNfcGJjX3Nlc3Npb24gKm5leHQ7CiAJdTggYWRkcltFVEhfQUxFTl07CiAJdTggdXVpZF9lW1dQU19VVUlEX0xFTl07Ci0Jc3RydWN0IG9zX3RpbWUgdGltZXN0YW1wOworCXN0cnVjdCBvc19yZWx0aW1lIHRpbWVzdGFtcDsKIH07CiAKIApAQCAtMTgzLDcgKzE4NSw5IEBACiAJdTggcDJwX2Rldl9hZGRyW0VUSF9BTEVOXTsKIAogCXU4IHBiY19pZ25vcmVfdXVpZFtXUFNfVVVJRF9MRU5dOwotCXN0cnVjdCBvc190aW1lIHBiY19pZ25vcmVfc3RhcnQ7CisjaWZkZWYgV1BTX1dPUktBUk9VTkRTCisJc3RydWN0IG9zX3JlbHRpbWUgcGJjX2lnbm9yZV9zdGFydDsKKyNlbmRpZiAvKiBXUFNfV09SS0FST1VORFMgKi8KIH07CiAKIApAQCAtMzExLDkgKzMxNSw5IEBACiAJCQkJCSAgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICp1dWlkX2UpCiB7CiAJc3RydWN0IHdwc19wYmNfc2Vzc2lvbiAqcGJjLCAqcHJldiA9IE5VTEw7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAotCW9zX2dldF90aW1lKCZub3cpOworCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCiAJcGJjID0gcmVnLT5wYmNfc2Vzc2lvbnM7CiAJd2hpbGUgKHBiYykgewpAQCAtMzQ3LDcgKzM1MSw4IEBACiAJcGJjID0gcGJjLT5uZXh0OwogCiAJd2hpbGUgKHBiYykgewotCQlpZiAobm93LnNlYyA+IHBiYy0+dGltZXN0YW1wLnNlYyArIFdQU19QQkNfV0FMS19USU1FKSB7CisJCWlmIChvc19yZWx0aW1lX2V4cGlyZWQoJm5vdywgJnBiYy0+dGltZXN0YW1wLAorCQkJCSAgICAgICBXUFNfUEJDX1dBTEtfVElNRSkpIHsKIAkJCXByZXYtPm5leHQgPSBOVUxMOwogCQkJd3BzX2ZyZWVfcGJjX3Nlc3Npb25zKHBiYyk7CiAJCQlicmVhazsKQEAgLTM2NywxMyArMzcyLDggQEAKIAlwYmMgPSByZWctPnBiY19zZXNzaW9uczsKIAl3aGlsZSAocGJjKSB7CiAJCWlmIChvc19tZW1jbXAocGJjLT51dWlkX2UsIHV1aWRfZSwgV1BTX1VVSURfTEVOKSA9PSAwIHx8Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQkJICAgIChwMnBfZGV2X2FkZHIgJiYgIWlzX3plcm9fZXRoZXJfYWRkcihwYmMtPmFkZHIpICYmCi0JCSAgICAgb3NfbWVtY21wKHBiYy0+YWRkciwgcDJwX2Rldl9hZGRyLCBFVEhfQUxFTikgPT0KLSNlbHNlCiAJCSAgICAocDJwX2Rldl9hZGRyICYmICFpc196ZXJvX2V0aGVyX2FkZHIocmVnLT5wMnBfZGV2X2FkZHIpICYmCiAJCSAgICAgb3NfbWVtY21wKHJlZy0+cDJwX2Rldl9hZGRyLCBwMnBfZGV2X2FkZHIsIEVUSF9BTEVOKSA9PQotI2VuZGlmCiAJCSAgICAgMCkpIHsKIAkJCWlmIChwcmV2KQogCQkJCXByZXYtPm5leHQgPSBwYmMtPm5leHQ7CkBAIC00MDAsOSArNDAwLDkgQEAKIAlpbnQgY291bnQgPSAwOwogCXN0cnVjdCB3cHNfcGJjX3Nlc3Npb24gKnBiYzsKIAlzdHJ1Y3Qgd3BzX3BiY19zZXNzaW9uICpmaXJzdCA9IE5VTEw7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAotCW9zX2dldF90aW1lKCZub3cpOworCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IENoZWNraW5nIGFjdGl2ZSBQQkMgc2Vzc2lvbnMgZm9yIG92ZXJsYXAiKTsKIApAQCAtNDE4LDkgKzQxOCw5IEBACiAJCQkgICBNQUMyU1RSKHBiYy0+YWRkcikpOwogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUFM6IFVVSUQtRSIsCiAJCQkgICAgcGJjLT51dWlkX2UsIFdQU19VVUlEX0xFTik7Ci0JCWlmIChub3cuc2VjID4gcGJjLT50aW1lc3RhbXAuc2VjICsgV1BTX1BCQ19XQUxLX1RJTUUpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBQQkMgd2FsayB0aW1lIGhhcyAiCi0JCQkJICAgImV4cGlyZWQiKTsKKwkJaWYgKG9zX3JlbHRpbWVfZXhwaXJlZCgmbm93LCAmcGJjLT50aW1lc3RhbXAsCisJCQkJICAgICAgIFdQU19QQkNfV0FMS19USU1FKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFBCQyB3YWxrIHRpbWUgaGFzIGV4cGlyZWQiKTsKIAkJCWJyZWFrOwogCQl9CiAJCWlmIChmaXJzdCAmJgpAQCAtNTM4LDcgKzUzOCw2IEBACiBzdGF0aWMgdm9pZCB3cHNfc2V0X3B1c2hidXR0b24odTE2ICptZXRob2RzLCB1MTYgY29uZl9tZXRob2RzKQogewogCSptZXRob2RzIHw9IFdQU19DT05GSUdfUFVTSEJVVFRPTjsKLSNpZmRlZiBDT05GSUdfV1BTMgogCWlmICgoY29uZl9tZXRob2RzICYgV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT04pID09CiAJICAgIFdQU19DT05GSUdfVklSVF9QVVNIQlVUVE9OKQogCQkqbWV0aG9kcyB8PSBXUFNfQ09ORklHX1ZJUlRfUFVTSEJVVFRPTjsKQEAgLTU1Niw3ICs1NTUsNiBAQAogCQkgKi8KIAkJKm1ldGhvZHMgfD0gV1BTX0NPTkZJR19QSFlfUFVTSEJVVFRPTjsKIAl9Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIH0KIAogCkBAIC01NjgsMTAgKzU2Niw4IEBACiAJCXJldHVybiAwOwogCW1ldGhvZHMgPSByZWctPndwcy0+Y29uZmlnX21ldGhvZHM7CiAJbWV0aG9kcyAmPSB+V1BTX0NPTkZJR19QVVNIQlVUVE9OOwotI2lmZGVmIENPTkZJR19XUFMyCiAJbWV0aG9kcyAmPSB+KFdQU19DT05GSUdfVklSVF9QVVNIQlVUVE9OIHwKIAkJICAgICBXUFNfQ09ORklHX1BIWV9QVVNIQlVUVE9OKTsKLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogCWlmIChyZWctPnBiYykKIAkJd3BzX3NldF9wdXNoYnV0dG9uKCZtZXRob2RzLCByZWctPndwcy0+Y29uZmlnX21ldGhvZHMpOwogCWlmIChyZWctPnNlbF9yZWdfY29uZmlnX21ldGhvZHNfb3ZlcnJpZGUgPj0gMCkKQEAgLTU5NCwxMCArNTkwLDggQEAKIAkgKiBleHRlcm5hbCBSZWdpc3RyYXJzLgogCSAqLwogCW1ldGhvZHMgPSByZWctPndwcy0+Y29uZmlnX21ldGhvZHMgJiB+V1BTX0NPTkZJR19QVVNIQlVUVE9OOwotI2lmZGVmIENPTkZJR19XUFMyCiAJbWV0aG9kcyAmPSB+KFdQU19DT05GSUdfVklSVF9QVVNIQlVUVE9OIHwKIAkJICAgICBXUFNfQ09ORklHX1BIWV9QVVNIQlVUVE9OKTsKLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBDb25maWcgTWV0aG9kcyAoJXgpIiwgbWV0aG9kcyk7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgQVRUUl9DT05GSUdfTUVUSE9EUyk7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgMik7CkBAIC02MTcsMTMgKzYxMSwxMSBAQAogewogCSpjb3VudCA9IDA7CiAKLSNpZmRlZiBDT05GSUdfV1BTMgogCXdoaWxlICgqY291bnQgPCBXUFNfTUFYX0FVVEhPUklaRURfTUFDUykgewogCQlpZiAoaXNfemVyb19ldGhlcl9hZGRyKHJlZy0+YXV0aG9yaXplZF9tYWNzX3VuaW9uWypjb3VudF0pKQogCQkJYnJlYWs7CiAJCSgqY291bnQpKys7CiAJfQotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAKIAlyZXR1cm4gKGNvbnN0IHU4ICopIHJlZy0+YXV0aG9yaXplZF9tYWNzX3VuaW9uOwogfQpAQCAtNzUzLDcgKzc0NSw3IEBACiAKIAlpZiAodGltZW91dCkgewogCQlwLT5mbGFncyB8PSBQSU5fRVhQSVJFUzsKLQkJb3NfZ2V0X3RpbWUoJnAtPmV4cGlyYXRpb24pOworCQlvc19nZXRfcmVsdGltZSgmcC0+ZXhwaXJhdGlvbik7CiAJCXAtPmV4cGlyYXRpb24uc2VjICs9IHRpbWVvdXQ7CiAJfQogCkBAIC04MDIsMTMgKzc5NCwxMyBAQAogc3RhdGljIHZvaWQgd3BzX3JlZ2lzdHJhcl9leHBpcmVfcGlucyhzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnKQogewogCXN0cnVjdCB3cHNfdXVpZF9waW4gKnBpbiwgKnByZXY7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAotCW9zX2dldF90aW1lKCZub3cpOworCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCWRsX2xpc3RfZm9yX2VhY2hfc2FmZShwaW4sIHByZXYsICZyZWctPnBpbnMsIHN0cnVjdCB3cHNfdXVpZF9waW4sIGxpc3QpCiAJewogCQlpZiAoKHBpbi0+ZmxhZ3MgJiBQSU5fRVhQSVJFUykgJiYKLQkJICAgIG9zX3RpbWVfYmVmb3JlKCZwaW4tPmV4cGlyYXRpb24sICZub3cpKSB7CisJCSAgICBvc19yZWx0aW1lX2JlZm9yZSgmcGluLT5leHBpcmF0aW9uLCAmbm93KSkgewogCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBFeHBpcmVkIFBJTiBmb3IgVVVJRCIsCiAJCQkJICAgIHBpbi0+dXVpZCwgV1BTX1VVSURfTEVOKTsKIAkJCXdwc19yZWdpc3RyYXJfcmVtb3ZlX3BpbihyZWcsIHBpbik7CkBAIC04MzQsNyArODI2LDcgQEAKIAl7CiAJCWlmIChkZXZfcHcgJiYgcGluLT5waW4gJiYKIAkJICAgIChkZXZfcHdfbGVuICE9IHBpbi0+cGluX2xlbiB8fAotCQkgICAgIG9zX21lbWNtcChkZXZfcHcsIHBpbi0+cGluLCBkZXZfcHdfbGVuKSAhPSAwKSkKKwkJICAgICBvc19tZW1jbXBfY29uc3QoZGV2X3B3LCBwaW4tPnBpbiwgZGV2X3B3X2xlbikgIT0gMCkpCiAJCQljb250aW51ZTsgLyogZGlmZmVyZW50IFBJTiAqLwogCQlpZiAocGluLT53aWxkY2FyZF91dWlkKSB7CiAJCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUFM6IEludmFsaWRhdGVkIFBJTiBmb3IgVVVJRCIsCkBAIC0xMDQyLDcgKzEwMzQsOSBAQAogCQl3cHNfcmVnaXN0cmFyX3JlbW92ZV9wYmNfc2Vzc2lvbihyZWdpc3RyYXIsCiAJCQkJCQkgdXVpZF9lLCBOVUxMKTsKIAkJd3BzX3JlZ2lzdHJhcl9wYmNfY29tcGxldGVkKHJlZ2lzdHJhcik7Ci0JCW9zX2dldF90aW1lKCZyZWdpc3RyYXItPnBiY19pZ25vcmVfc3RhcnQpOworI2lmZGVmIFdQU19XT1JLQVJPVU5EUworCQlvc19nZXRfcmVsdGltZSgmcmVnaXN0cmFyLT5wYmNfaWdub3JlX3N0YXJ0KTsKKyNlbmRpZiAvKiBXUFNfV09SS0FST1VORFMgKi8KIAkJb3NfbWVtY3B5KHJlZ2lzdHJhci0+cGJjX2lnbm9yZV91dWlkLCB1dWlkX2UsIFdQU19VVUlEX0xFTik7CiAJfSBlbHNlIHsKIAkJd3BzX3JlZ2lzdHJhcl9waW5fY29tcGxldGVkKHJlZ2lzdHJhcik7CkBAIC0xMTQ1LDkgKzExMzksOSBAQAogI2lmZGVmIFdQU19XT1JLQVJPVU5EUwogCWlmIChyZWctPnBiY19pZ25vcmVfc3RhcnQuc2VjICYmCiAJICAgIG9zX21lbWNtcChhdHRyLnV1aWRfZSwgcmVnLT5wYmNfaWdub3JlX3V1aWQsIFdQU19VVUlEX0xFTikgPT0gMCkgewotCQlzdHJ1Y3Qgb3NfdGltZSBub3csIGR1cjsKLQkJb3NfZ2V0X3RpbWUoJm5vdyk7Ci0JCW9zX3RpbWVfc3ViKCZub3csICZyZWctPnBiY19pZ25vcmVfc3RhcnQsICZkdXIpOworCQlzdHJ1Y3Qgb3NfcmVsdGltZSBub3csIGR1cjsKKwkJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CisJCW9zX3JlbHRpbWVfc3ViKCZub3csICZyZWctPnBiY19pZ25vcmVfc3RhcnQsICZkdXIpOwogCQlpZiAoZHVyLnNlYyA+PSAwICYmIGR1ci5zZWMgPCA1KSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSWdub3JlIFBCQyBhY3RpdmF0aW9uICIKIAkJCQkgICAiYmFzZWQgb24gUHJvYmUgUmVxdWVzdCBmcm9tIHRoZSBFbnJvbGxlZSAiCkBAIC0xMTY4LDggKzExNjIsOCBAQAogfQogCiAKLXN0YXRpYyBpbnQgd3BzX2NiX25ld19wc2soc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywgY29uc3QgdTggKm1hY19hZGRyLAotCQkJICBjb25zdCB1OCAqcDJwX2Rldl9hZGRyLCBjb25zdCB1OCAqcHNrLCBzaXplX3QgcHNrX2xlbikKK2ludCB3cHNfY2JfbmV3X3BzayhzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLCBjb25zdCB1OCAqbWFjX2FkZHIsCisJCSAgIGNvbnN0IHU4ICpwMnBfZGV2X2FkZHIsIGNvbnN0IHU4ICpwc2ssIHNpemVfdCBwc2tfbGVuKQogewogCWlmIChyZWctPm5ld19wc2tfY2IgPT0gTlVMTCkKIAkJcmV0dXJuIDA7CkBAIC0xMjE1LDEwICsxMjA5LDggQEAKIAogCWlmIChyZWctPnNlbGVjdGVkX3JlZ2lzdHJhcikgewogCQltZXRob2RzID0gcmVnLT53cHMtPmNvbmZpZ19tZXRob2RzICYgfldQU19DT05GSUdfUFVTSEJVVFRPTjsKLSNpZmRlZiBDT05GSUdfV1BTMgogCQltZXRob2RzICY9IH4oV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT04gfAogCQkJICAgICBXUFNfQ09ORklHX1BIWV9QVVNIQlVUVE9OKTsKLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogCQlpZiAocmVnLT5wYmMpCiAJCQl3cHNfc2V0X3B1c2hidXR0b24oJm1ldGhvZHMsIHJlZy0+d3BzLT5jb25maWdfbWV0aG9kcyk7CiAJfQpAQCAtMTM1MSw3ICsxMzQzLDcgQEAKIAljb25zdCB1OCAqcGluOwogCXNpemVfdCBwaW5fbGVuID0gMDsKIAotCW9zX2ZyZWUod3BzLT5kZXZfcGFzc3dvcmQpOworCWJpbl9jbGVhcl9mcmVlKHdwcy0+ZGV2X3Bhc3N3b3JkLCB3cHMtPmRldl9wYXNzd29yZF9sZW4pOwogCXdwcy0+ZGV2X3Bhc3N3b3JkID0gTlVMTDsKIAogCWlmICh3cHMtPnBiYykgewpAQCAtMTM2MCwxMCArMTM1MiwyMyBAQAogCQlwaW5fbGVuID0gODsKICNpZmRlZiBDT05GSUdfV1BTX05GQwogCX0gZWxzZSBpZiAod3BzLT5uZmNfcHdfdG9rZW4pIHsKKwkJaWYgKHdwcy0+bmZjX3B3X3Rva2VuLT5wd19pZCA9PSBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIpCisJCXsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVc2luZyBORkMgY29ubmVjdGlvbiAiCisJCQkJICAgImhhbmRvdmVyIGFuZCBhYmJyZXZpYXRlZCBXUFMgaGFuZHNoYWtlICIKKwkJCQkgICAid2l0aG91dCBEZXZpY2UgUGFzc3dvcmQiKTsKKwkJCXJldHVybiAwOworCQl9CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVc2UgT09CIERldmljZSBQYXNzd29yZCBmcm9tIE5GQyAiCiAJCQkgICAiUGFzc3dvcmQgVG9rZW4iKTsKIAkJcGluID0gd3BzLT5uZmNfcHdfdG9rZW4tPmRldl9wdzsKIAkJcGluX2xlbiA9IHdwcy0+bmZjX3B3X3Rva2VuLT5kZXZfcHdfbGVuOworCX0gZWxzZSBpZiAod3BzLT5kZXZfcHdfaWQgPj0gMHgxMCAmJgorCQkgICB3cHMtPndwcy0+YXBfbmZjX2Rldl9wd19pZCA9PSB3cHMtPmRldl9wd19pZCAmJgorCQkgICB3cHMtPndwcy0+YXBfbmZjX2Rldl9wdykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVXNlIE9PQiBEZXZpY2UgUGFzc3dvcmQgZnJvbSBvd24gTkZDIFBhc3N3b3JkIFRva2VuIik7CisJCXBpbiA9IHdwYWJ1Zl9oZWFkKHdwcy0+d3BzLT5hcF9uZmNfZGV2X3B3KTsKKwkJcGluX2xlbiA9IHdwYWJ1Zl9sZW4od3BzLT53cHMtPmFwX25mY19kZXZfcHcpOwogI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCiAJfSBlbHNlIHsKIAkJcGluID0gd3BzX3JlZ2lzdHJhcl9nZXRfcGluKHdwcy0+d3BzLT5yZWdpc3RyYXIsIHdwcy0+dXVpZF9lLApAQCAtMTM3OSw3ICsxMzg0LDggQEAKIAl9CiAJaWYgKHBpbiA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBEZXZpY2UgUGFzc3dvcmQgYXZhaWxhYmxlIGZvciAiCi0JCQkgICAidGhlIEVucm9sbGVlIik7CisJCQkgICAidGhlIEVucm9sbGVlIChjb250ZXh0ICVwIHJlZ2lzdHJhciAlcCkiLAorCQkJICAgd3BzLT53cHMsIHdwcy0+d3BzLT5yZWdpc3RyYXIpOwogCQl3cHNfY2JfcGluX25lZWRlZCh3cHMtPndwcy0+cmVnaXN0cmFyLCB3cHMtPnV1aWRfZSwKIAkJCQkgICZ3cHMtPnBlZXJfZGV2KTsKIAkJcmV0dXJuIC0xOwpAQCAtMTU5Myw4ICsxNTk5LDYgQEAKIAkJd3BzLT5hdXRoX3R5cGUgPSBXUFNfQVVUSF9XUEFQU0s7CiAJZWxzZSBpZiAod3BzLT5hdXRoX3R5cGUgJiBXUFNfQVVUSF9PUEVOKQogCQl3cHMtPmF1dGhfdHlwZSA9IFdQU19BVVRIX09QRU47Ci0JZWxzZSBpZiAod3BzLT5hdXRoX3R5cGUgJiBXUFNfQVVUSF9TSEFSRUQpCi0JCXdwcy0+YXV0aF90eXBlID0gV1BTX0FVVEhfU0hBUkVEOwogCWVsc2UgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVW5zdXBwb3J0ZWQgYXV0aF90eXBlIDB4JXgiLAogCQkJICAgd3BzLT5hdXRoX3R5cGUpOwpAQCAtMTYxNCwxMCArMTYxOCwxMiBAQAogCQkJcmV0dXJuIC0xOwogCQl9CiAJfSBlbHNlIHsKLQkJaWYgKHdwcy0+ZW5jcl90eXBlICYgV1BTX0VOQ1JfV0VQKQotCQkJd3BzLT5lbmNyX3R5cGUgPSBXUFNfRU5DUl9XRVA7Ci0JCWVsc2UgaWYgKHdwcy0+ZW5jcl90eXBlICYgV1BTX0VOQ1JfTk9ORSkKKwkJaWYgKHdwcy0+ZW5jcl90eXBlICYgV1BTX0VOQ1JfTk9ORSkKIAkJCXdwcy0+ZW5jcl90eXBlID0gV1BTX0VOQ1JfTk9ORTsKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJCWVsc2UgaWYgKHdwcy0+ZW5jcl90eXBlICYgV1BTX0VOQ1JfV0VQKQorCQkJd3BzLT5lbmNyX3R5cGUgPSBXUFNfRU5DUl9XRVA7CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLwogCQllbHNlIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBzdWl0YWJsZSBlbmNyeXB0aW9uICIKIAkJCQkgICAidHlwZSBmb3Igbm9uLVdQQS9XUEEyIG1vZGUiKTsKQEAgLTE3NzYsNiArMTc4Miw3IEBACiBzdGF0aWMgc3RydWN0IHdwYWJ1ZiAqIHdwc19idWlsZF9tMihzdHJ1Y3Qgd3BzX2RhdGEgKndwcykKIHsKIAlzdHJ1Y3Qgd3BhYnVmICptc2c7CisJaW50IGNvbmZpZ19pbl9tMiA9IDA7CiAKIAlpZiAocmFuZG9tX2dldF9ieXRlcyh3cHMtPm5vbmNlX3IsIFdQU19OT05DRV9MRU4pIDwgMCkKIAkJcmV0dXJuIE5VTEw7CkBAIC0xODA2LDE0ICsxODEzLDQxIEBACiAJICAgIHdwc19idWlsZF9jb25maWdfZXJyb3IobXNnLCBXUFNfQ0ZHX05PX0VSUk9SKSB8fAogCSAgICB3cHNfYnVpbGRfZGV2X3Bhc3N3b3JkX2lkKG1zZywgd3BzLT5kZXZfcHdfaWQpIHx8CiAJICAgIHdwc19idWlsZF9vc192ZXJzaW9uKCZ3cHMtPndwcy0+ZGV2LCBtc2cpIHx8Ci0JICAgIHdwc19idWlsZF93ZmFfZXh0KG1zZywgMCwgTlVMTCwgMCkgfHwKLQkgICAgd3BzX2J1aWxkX2F1dGhlbnRpY2F0b3Iod3BzLCBtc2cpKSB7CisJICAgIHdwc19idWlsZF93ZmFfZXh0KG1zZywgMCwgTlVMTCwgMCkpIHsKKwkJd3BhYnVmX2ZyZWUobXNnKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwlpZiAod3BzLT5uZmNfcHdfdG9rZW4gJiYgd3BzLT5uZmNfcHdfdG9rZW4tPnBrX2hhc2hfcHJvdmlkZWRfb29iICYmCisJICAgIHdwcy0+bmZjX3B3X3Rva2VuLT5wd19pZCA9PSBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIpIHsKKwkJLyoKKwkJICogVXNlIGFiYnJldmlhdGVkIGhhbmRzaGFrZSBzaW5jZSBwdWJsaWMga2V5IGhhc2ggYWxsb3dlZAorCQkgKiBFbnJvbGxlZSB0byB2YWxpZGF0ZSBvdXIgcHVibGljIGtleSBzaW1pbGFybHkgdG8gaG93IEVucm9sbGVlCisJCSAqIHB1YmxpYyBrZXkgd2FzIHZhbGlkYXRlZC4gVGhlcmUgaXMgbm8gbmVlZCB0byB2YWxpZGF0ZSBEZXZpY2UKKwkJICogUGFzc3dvcmQgaW4gdGhpcyBjYXNlLgorCQkgKi8KKwkJc3RydWN0IHdwYWJ1ZiAqcGxhaW4gPSB3cGFidWZfYWxsb2MoNTAwKTsKKwkJaWYgKHBsYWluID09IE5VTEwgfHwKKwkJICAgIHdwc19idWlsZF9jcmVkKHdwcywgcGxhaW4pIHx8CisJCSAgICB3cHNfYnVpbGRfa2V5X3dyYXBfYXV0aCh3cHMsIHBsYWluKSB8fAorCQkgICAgd3BzX2J1aWxkX2VuY3Jfc2V0dGluZ3Mod3BzLCBtc2csIHBsYWluKSkgeworCQkJd3BhYnVmX2ZyZWUobXNnKTsKKwkJCXdwYWJ1Zl9mcmVlKHBsYWluKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJCXdwYWJ1Zl9mcmVlKHBsYWluKTsKKwkJY29uZmlnX2luX20yID0gMTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKworCWlmICh3cHNfYnVpbGRfYXV0aGVudGljYXRvcih3cHMsIG1zZykpIHsKIAkJd3BhYnVmX2ZyZWUobXNnKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCiAJd3BzLT5pbnRfcmVnID0gMTsKLQl3cHMtPnN0YXRlID0gUkVDVl9NMzsKKwl3cHMtPnN0YXRlID0gY29uZmlnX2luX20yID8gUkVDVl9ET05FIDogUkVDVl9NMzsKIAlyZXR1cm4gbXNnOwogfQogCkBAIC0yMTc3LDcgKzIyMTEsNyBAQAogCWxlblszXSA9IHdwYWJ1Zl9sZW4od3BzLT5kaF9wdWJrZXlfcik7CiAJaG1hY19zaGEyNTZfdmVjdG9yKHdwcy0+YXV0aGtleSwgV1BTX0FVVEhLRVlfTEVOLCA0LCBhZGRyLCBsZW4sIGhhc2gpOwogCi0JaWYgKG9zX21lbWNtcCh3cHMtPnBlZXJfaGFzaDEsIGhhc2gsIFdQU19IQVNIX0xFTikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3Qod3BzLT5wZWVyX2hhc2gxLCBoYXNoLCBXUFNfSEFTSF9MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEUtSGFzaDEgZGVyaXZlZCBmcm9tIEUtUzEgZG9lcyAiCiAJCQkgICAibm90IG1hdGNoIHdpdGggdGhlIHByZS1jb21taXR0ZWQgdmFsdWUiKTsKIAkJd3BzLT5jb25maWdfZXJyb3IgPSBXUFNfQ0ZHX0RFVl9QQVNTV09SRF9BVVRIX0ZBSUxVUkU7CkBAIC0yMjE3LDcgKzIyNTEsNyBAQAogCWxlblszXSA9IHdwYWJ1Zl9sZW4od3BzLT5kaF9wdWJrZXlfcik7CiAJaG1hY19zaGEyNTZfdmVjdG9yKHdwcy0+YXV0aGtleSwgV1BTX0FVVEhLRVlfTEVOLCA0LCBhZGRyLCBsZW4sIGhhc2gpOwogCi0JaWYgKG9zX21lbWNtcCh3cHMtPnBlZXJfaGFzaDIsIGhhc2gsIFdQU19IQVNIX0xFTikgIT0gMCkgeworCWlmIChvc19tZW1jbXBfY29uc3Qod3BzLT5wZWVyX2hhc2gyLCBoYXNoLCBXUFNfSEFTSF9MRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEUtSGFzaDIgZGVyaXZlZCBmcm9tIEUtUzIgZG9lcyAiCiAJCQkgICAibm90IG1hdGNoIHdpdGggdGhlIHByZS1jb21taXR0ZWQgdmFsdWUiKTsKIAkJd3BzX3JlZ2lzdHJhcl9pbnZhbGlkYXRlX3Bpbih3cHMtPndwcy0+cmVnaXN0cmFyLCB3cHMtPnV1aWRfZSk7CkBAIC0yNTI3LDYgKzI1NjEsOSBAQAogCSAgICB3cHMtPmRldl9wd19pZCAhPSBERVZfUFdfVVNFUl9TUEVDSUZJRUQgJiYKIAkgICAgd3BzLT5kZXZfcHdfaWQgIT0gREVWX1BXX01BQ0hJTkVfU1BFQ0lGSUVEICYmCiAJICAgIHdwcy0+ZGV2X3B3X2lkICE9IERFVl9QV19SRUdJU1RSQVJfU1BFQ0lGSUVEICYmCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwkgICAgd3BzLT5kZXZfcHdfaWQgIT0gREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSICYmCisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KIAkgICAgKHdwcy0+ZGV2X3B3X2lkICE9IERFVl9QV19QVVNIQlVUVE9OIHx8CiAJICAgICAhd3BzLT53cHMtPnJlZ2lzdHJhci0+cGJjKSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVW5zdXBwb3J0ZWQgRGV2aWNlIFBhc3N3b3JkIElEICVkIiwKQEAgLTI1MzYsMTQgKzI1NzMsMTcgQEAKIAl9CiAKICNpZmRlZiBDT05GSUdfV1BTX05GQwotCWlmICh3cHMtPmRldl9wd19pZCA+PSAweDEwKSB7CisJaWYgKHdwcy0+ZGV2X3B3X2lkID49IDB4MTAgfHwKKwkgICAgd3BzLT5kZXZfcHdfaWQgPT0gREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSKSB7CiAJCXN0cnVjdCB3cHNfbmZjX3B3X3Rva2VuICp0b2tlbjsKIAkJY29uc3QgdTggKmFkZHJbMV07CiAJCXU4IGhhc2hbV1BTX0hBU0hfTEVOXTsKIAorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogU2VhcmNoaW5nIGZvciBORkMgdG9rZW4gbWF0Y2ggZm9yIGlkPSVkIChjdHggJXAgcmVnaXN0cmFyICVwKSIsCisJCQkgICB3cHMtPmRldl9wd19pZCwgd3BzLT53cHMsIHdwcy0+d3BzLT5yZWdpc3RyYXIpOwogCQl0b2tlbiA9IHdwc19nZXRfbmZjX3B3X3Rva2VuKAogCQkJJndwcy0+d3BzLT5yZWdpc3RyYXItPm5mY19wd190b2tlbnMsIHdwcy0+ZGV2X3B3X2lkKTsKLQkJaWYgKHRva2VuKSB7CisJCWlmICh0b2tlbiAmJiB0b2tlbi0+cGVlcl9wa19oYXNoX2tub3duKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogRm91bmQgbWF0Y2hpbmcgTkZDICIKIAkJCQkgICAiUGFzc3dvcmQgVG9rZW4iKTsKIAkJCWRsX2xpc3RfZGVsKCZ0b2tlbi0+bGlzdCk7CkBAIC0yNTUxLDEyICsyNTkxLDI0IEBACiAKIAkJCWFkZHJbMF0gPSBhdHRyLT5wdWJsaWNfa2V5OwogCQkJc2hhMjU2X3ZlY3RvcigxLCBhZGRyLCAmYXR0ci0+cHVibGljX2tleV9sZW4sIGhhc2gpOwotCQkJaWYgKG9zX21lbWNtcChoYXNoLCB3cHMtPm5mY19wd190b2tlbi0+cHVia2V5X2hhc2gsCi0JCQkJICAgICAgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pICE9IDApIHsKKwkJCWlmIChvc19tZW1jbXBfY29uc3QoaGFzaCwKKwkJCQkJICAgIHdwcy0+bmZjX3B3X3Rva2VuLT5wdWJrZXlfaGFzaCwKKwkJCQkJICAgIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOKSAhPSAwKSB7CiAJCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IFB1YmxpYyBLZXkgaGFzaCAiCiAJCQkJCSAgICJtaXNtYXRjaCIpOwotCQkJCXJldHVybiBXUFNfRkFJTFVSRTsKKwkJCQl3cHMtPnN0YXRlID0gU0VORF9NMkQ7CisJCQkJd3BzLT5jb25maWdfZXJyb3IgPQorCQkJCQlXUFNfQ0ZHX1BVQkxJQ19LRVlfSEFTSF9NSVNNQVRDSDsKKwkJCQlyZXR1cm4gV1BTX0NPTlRJTlVFOwogCQkJfQorCQl9IGVsc2UgaWYgKHRva2VuKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogRm91bmQgbWF0Y2hpbmcgTkZDICIKKwkJCQkgICAiUGFzc3dvcmQgVG9rZW4gKG5vIHBlZXIgUEsgaGFzaCkiKTsKKwkJCXdwcy0+bmZjX3B3X3Rva2VuID0gdG9rZW47CisJCX0gZWxzZSBpZiAod3BzLT5kZXZfcHdfaWQgPj0gMHgxMCAmJgorCQkJICAgd3BzLT53cHMtPmFwX25mY19kZXZfcHdfaWQgPT0gd3BzLT5kZXZfcHdfaWQgJiYKKwkJCSAgIHdwcy0+d3BzLT5hcF9uZmNfZGV2X3B3KSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogRm91bmQgbWF0Y2ggd2l0aCBvd24gTkZDIFBhc3N3b3JkIFRva2VuIik7CiAJCX0KIAl9CiAjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KQEAgLTMxOTEsNyArMzI0Myw5IEBACiAJCQkJCQkgd3BzLT51dWlkX2UsCiAJCQkJCQkgd3BzLT5wMnBfZGV2X2FkZHIpOwogCQl3cHNfcmVnaXN0cmFyX3BiY19jb21wbGV0ZWQod3BzLT53cHMtPnJlZ2lzdHJhcik7Ci0JCW9zX2dldF90aW1lKCZ3cHMtPndwcy0+cmVnaXN0cmFyLT5wYmNfaWdub3JlX3N0YXJ0KTsKKyNpZmRlZiBXUFNfV09SS0FST1VORFMKKwkJb3NfZ2V0X3JlbHRpbWUoJndwcy0+d3BzLT5yZWdpc3RyYXItPnBiY19pZ25vcmVfc3RhcnQpOworI2VuZGlmIC8qIFdQU19XT1JLQVJPVU5EUyAqLwogCQlvc19tZW1jcHkod3BzLT53cHMtPnJlZ2lzdHJhci0+cGJjX2lnbm9yZV91dWlkLCB3cHMtPnV1aWRfZSwKIAkJCSAgV1BTX1VVSURfTEVOKTsKIAl9IGVsc2UgewpAQCAtMzM4MywxMCArMzQzNyw4IEBACiAJCXUxNiBtZXRob2RzOwogCiAJCW1ldGhvZHMgPSByZWctPndwcy0+Y29uZmlnX21ldGhvZHMgJiB+V1BTX0NPTkZJR19QVVNIQlVUVE9OOwotI2lmZGVmIENPTkZJR19XUFMyCiAJCW1ldGhvZHMgJj0gfihXUFNfQ09ORklHX1ZJUlRfUFVTSEJVVFRPTiB8CiAJCQkgICAgIFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT04pOwotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAJCWlmIChyZWctPnBiYykgewogCQkJcmVnLT5zZWxfcmVnX2Rldl9wYXNzd29yZF9pZF9vdmVycmlkZSA9CiAJCQkJREVWX1BXX1BVU0hCVVRUT047CkBAIC0zNDQ3LDggKzM0OTksNyBAQAogaW50IHdwc19yZWdpc3RyYXJfY29uZmlnX2FwKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWcsCiAJCQkgICAgc3RydWN0IHdwc19jcmVkZW50aWFsICpjcmVkKQogewotI2lmZGVmIENPTkZJR19XUFMyCi0JcHJpbnRmKCJlbmNyX3R5cGU9MHgleFxuIiwgY3JlZC0+ZW5jcl90eXBlKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogZW5jcl90eXBlPTB4JXgiLCBjcmVkLT5lbmNyX3R5cGUpOwogCWlmICghKGNyZWQtPmVuY3JfdHlwZSAmIChXUFNfRU5DUl9OT05FIHwgV1BTX0VOQ1JfVEtJUCB8CiAJCQkJIFdQU19FTkNSX0FFUykpKSB7CiAJCWlmIChjcmVkLT5lbmNyX3R5cGUgJiBXUFNfRU5DUl9XRVApIHsKQEAgLTM0NzUsNyArMzUyNiw2IEBACiAJCQkgICAiV1BBUFNLK1dQQTJQU0siKTsKIAkJY3JlZC0+YXV0aF90eXBlIHw9IFdQU19BVVRIX1dQQTJQU0s7CiAJfQotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAKIAlpZiAocmVnLT53cHMtPmNyZWRfY2IpCiAJCXJldHVybiByZWctPndwcy0+Y3JlZF9jYihyZWctPndwcy0+Y2JfY3R4LCBjcmVkKTsKQEAgLTM0ODgsMjUgKzM1MzgsMzkgQEAKIAogaW50IHdwc19yZWdpc3RyYXJfYWRkX25mY19wd190b2tlbihzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLAogCQkJCSAgIGNvbnN0IHU4ICpwdWJrZXlfaGFzaCwgdTE2IHB3X2lkLAotCQkJCSAgIGNvbnN0IHU4ICpkZXZfcHcsIHNpemVfdCBkZXZfcHdfbGVuKQorCQkJCSAgIGNvbnN0IHU4ICpkZXZfcHcsIHNpemVfdCBkZXZfcHdfbGVuLAorCQkJCSAgIGludCBwa19oYXNoX3Byb3ZpZGVkX29vYikKIHsKIAlzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiAqdG9rZW47CiAKIAlpZiAoZGV2X3B3X2xlbiA+IFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0xFTikKIAkJcmV0dXJuIC0xOwogCisJaWYgKHB3X2lkID09IERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUiAmJgorCSAgICAocHVia2V5X2hhc2ggPT0gTlVMTCB8fCAhcGtfaGFzaF9wcm92aWRlZF9vb2IpKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVbmV4cGVjdGVkIE5GQyBQYXNzd29yZCBUb2tlbiAiCisJCQkgICAiYWRkaXRpb24gLSBtaXNzaW5nIHB1YmxpYyBrZXkgaGFzaCIpOworCQlyZXR1cm4gLTE7CisJfQorCiAJd3BzX2ZyZWVfbmZjX3B3X3Rva2VucygmcmVnLT5uZmNfcHdfdG9rZW5zLCBwd19pZCk7CiAKIAl0b2tlbiA9IG9zX3phbGxvYyhzaXplb2YoKnRva2VuKSk7CiAJaWYgKHRva2VuID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAotCW9zX21lbWNweSh0b2tlbi0+cHVia2V5X2hhc2gsIHB1YmtleV9oYXNoLCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTik7CisJdG9rZW4tPnBlZXJfcGtfaGFzaF9rbm93biA9IHB1YmtleV9oYXNoICE9IE5VTEw7CisJaWYgKHB1YmtleV9oYXNoKQorCQlvc19tZW1jcHkodG9rZW4tPnB1YmtleV9oYXNoLCBwdWJrZXlfaGFzaCwKKwkJCSAgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOwogCXRva2VuLT5wd19pZCA9IHB3X2lkOwotCXdwYV9zbnByaW50Zl9oZXhfdXBwZXJjYXNlKChjaGFyICopIHRva2VuLT5kZXZfcHcsCi0JCQkJICAgc2l6ZW9mKHRva2VuLT5kZXZfcHcpLAotCQkJCSAgIGRldl9wdywgZGV2X3B3X2xlbik7Ci0JdG9rZW4tPmRldl9wd19sZW4gPSBkZXZfcHdfbGVuICogMjsKKwl0b2tlbi0+cGtfaGFzaF9wcm92aWRlZF9vb2IgPSBwa19oYXNoX3Byb3ZpZGVkX29vYjsKKwlpZiAoZGV2X3B3KSB7CisJCXdwYV9zbnByaW50Zl9oZXhfdXBwZXJjYXNlKChjaGFyICopIHRva2VuLT5kZXZfcHcsCisJCQkJCSAgIHNpemVvZih0b2tlbi0+ZGV2X3B3KSwKKwkJCQkJICAgZGV2X3B3LCBkZXZfcHdfbGVuKTsKKwkJdG9rZW4tPmRldl9wd19sZW4gPSBkZXZfcHdfbGVuICogMjsKKwl9CiAKIAlkbF9saXN0X2FkZCgmcmVnLT5uZmNfcHdfdG9rZW5zLCAmdG9rZW4tPmxpc3QpOwogCkBAIC0zNTM1LDggKzM1OTksNyBAQAogCXUxNiBpZDsKIAlzaXplX3QgZGV2X3B3X2xlbjsKIAotCWlmIChvb2JfZGV2X3B3X2xlbiA8IFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOICsgMiArCi0JICAgIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX01JTl9MRU4gfHwKKwlpZiAob29iX2Rldl9wd19sZW4gPCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiArIDIgfHwKIAkgICAgb29iX2Rldl9wd19sZW4gPiBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiArIDIgKwogCSAgICBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4pCiAJCXJldHVybiAtMTsKQEAgLTM1NTUsNyArMzYxOCw3IEBACiAJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIldQUzogRGV2aWNlIFBhc3N3b3JkIiwgZGV2X3B3LCBkZXZfcHdfbGVuKTsKIAogCXJldHVybiB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcHdfdG9rZW4ocmVnLCBoYXNoLCBpZCwgZGV2X3B3LAotCQkJCQkgICAgICBkZXZfcHdfbGVuKTsKKwkJCQkJICAgICAgZGV2X3B3X2xlbiwgMCk7CiB9CiAKIApAQCAtMzU2NSw2ICszNjI4LDE0IEBACiAJd3BzX3JlZ2lzdHJhcl9yZW1vdmVfYXV0aG9yaXplZF9tYWMocmVnLAogCQkJCQkgICAgKHU4ICopICJceGZmXHhmZlx4ZmZceGZmXHhmZlx4ZmYiKTsKIAl3cHNfcmVnaXN0cmFyX3NlbGVjdGVkX3JlZ2lzdHJhcl9jaGFuZ2VkKHJlZywgMCk7CisKKwkvKgorCSAqIEZyZWUgdGhlIE5GQyBwYXNzd29yZCB0b2tlbiBpZiBpdCB3YXMgdXNlZCBvbmx5IGZvciBhIHNpbmdsZSBwcm90b2NvbAorCSAqIHJ1bi4gVGhlIHN0YXRpYyBoYW5kb3ZlciBjYXNlIHVzZXMgdGhlIHNhbWUgcGFzc3dvcmQgdG9rZW4gbXVsdGlwbGUKKwkgKiB0aW1lcywgc28gZG8gbm90IGZyZWUgdGhhdCBjYXNlIGhlcmUuCisJICovCisJaWYgKHRva2VuLT5wZWVyX3BrX2hhc2hfa25vd24pCisJCW9zX2ZyZWUodG9rZW4pOwogfQogCiAjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX3VwbnAuYyBiL3NyYy93cHMvd3BzX3VwbnAuYwppbmRleCBiZWEyYjMzLi5hZTk0YTlmIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc191cG5wLmMKKysrIGIvc3JjL3dwcy93cHNfdXBucC5jCkBAIC0yMjcsNiArMjI3LDggQEAKIAogCXQgPSB0aW1lKE5VTEwpOwogCWRhdGUgPSBnbXRpbWUoJnQpOworCWlmIChkYXRlID09IE5VTEwpCisJCXJldHVybjsKIAl3cGFidWZfcHJpbnRmKGJ1ZiwgIiVzLCAlMDJkICVzICVkICUwMmQ6JTAyZDolMDJkIEdNVCIsCiAJCSAgICAgICZ3ZWVrZGF5X3N0cltkYXRlLT50bV93ZGF5ICogNF0sIGRhdGUtPnRtX21kYXksCiAJCSAgICAgICZtb250aF9zdHJbZGF0ZS0+dG1fbW9uICogNF0sIGRhdGUtPnRtX3llYXIgKyAxOTAwLApAQCAtNDMyLDIzICs0MzQsNiBAQAogfQogCiAKLWludCBzZW5kX3dwYWJ1ZihpbnQgZmQsIHN0cnVjdCB3cGFidWYgKmJ1ZikKLXsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBVUG5QOiBTZW5kICVsdSBieXRlIG1lc3NhZ2UiLAotCQkgICAodW5zaWduZWQgbG9uZykgd3BhYnVmX2xlbihidWYpKTsKLQllcnJubyA9IDA7Ci0JaWYgKHdyaXRlKGZkLCB3cGFidWZfaGVhZChidWYpLCB3cGFidWZfbGVuKGJ1ZikpICE9Ci0JICAgIChpbnQpIHdwYWJ1Zl9sZW4oYnVmKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIldQUyBVUG5QOiBGYWlsZWQgdG8gc2VuZCBidWZmZXI6ICIKLQkJCSAgICJlcnJubz0lZCAoJXMpIiwKLQkJCSAgIGVycm5vLCBzdHJlcnJvcihlcnJubykpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLQogc3RhdGljIHZvaWQgd3BhYnVmX3B1dF9wcm9wZXJ0eShzdHJ1Y3Qgd3BhYnVmICpidWYsIGNvbnN0IGNoYXIgKm5hbWUsCiAJCQkJY29uc3QgY2hhciAqdmFsdWUpCiB7CkBAIC00ODAsMTQgKzQ2NSwxNCBAQAogCQkiPD94bWwgdmVyc2lvbj1cIjEuMFwiIGVuY29kaW5nPVwidXRmLThcIj8+XG4iCiAJCSI8ZTpwcm9wZXJ0eXNldCB4bWxuczplPVwidXJuOnNjaGVtYXMtdXBucC1vcmc6ZXZlbnQtMS0wXCI+XG4iOwogCWNvbnN0IGNoYXIgKmZvcm1hdF90YWlsID0gIjwvZTpwcm9wZXJ0eXNldD5cbiI7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAogCWlmIChkbF9saXN0X2VtcHR5KCZzbS0+c3Vic2NyaXB0aW9ucykpIHsKIAkJLyogb3B0aW1pemUgKi8KIAkJcmV0dXJuOwogCX0KIAotCWlmIChvc19nZXRfdGltZSgmbm93KSA9PSAwKSB7CisJaWYgKG9zX2dldF9yZWx0aW1lKCZub3cpID09IDApIHsKIAkJaWYgKG5vdy5zZWMgIT0gc20tPmxhc3RfZXZlbnRfc2VjKSB7CiAJCQlzbS0+bGFzdF9ldmVudF9zZWMgPSBub3cuc2VjOwogCQkJc20tPm51bV9ldmVudHNfaW5fc2VjID0gMTsKQEAgLTYxMSw3ICs1OTYsMTAgQEAKIAl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX1JFR0lTVFJBUl9OT05DRSk7CiAJd3BhYnVmX3B1dF9iZTE2KG1zZywgV1BTX05PTkNFX0xFTik7CiAJd3BhYnVmX3B1dChtc2csIFdQU19OT05DRV9MRU4pOwotCXdwc19idWlsZF93ZmFfZXh0KG1zZywgMCwgTlVMTCwgMCk7CisJaWYgKHdwc19idWlsZF93ZmFfZXh0KG1zZywgMCwgTlVMTCwgMCkpIHsKKwkJd3BhYnVmX2ZyZWUobXNnKTsKKwkJcmV0dXJuIE5VTEw7CisJfQogCXJldHVybiBtc2c7CiB9CiAKZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX3VwbnBfYXAuYyBiL3NyYy93cHMvd3BzX3VwbnBfYXAuYwppbmRleCA0ZjFkZDhmLi4yOTQ5ZjE0IDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc191cG5wX2FwLmMKKysrIGIvc3JjL3dwcy93cHNfdXBucF9hcC5jCkBAIC02MSwxMSArNjEsOSBAQAogCQkJb3NfbWVtY3B5KHMtPmF1dGhvcml6ZWRfbWFjcywgYXR0ci5hdXRob3JpemVkX21hY3MsCiAJCQkJICBjb3VudCAqIEVUSF9BTEVOKTsKIAkJfSBlbHNlIGlmICghYXR0ci52ZXJzaW9uMikgewotI2lmZGVmIENPTkZJR19XUFMyCiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogQWRkIGJyb2FkY2FzdCAiCiAJCQkJICAgIkF1dGhvcml6ZWRNQUNzIGZvciBXUFMgMS4wIEVSIik7CiAJCQlvc19tZW1zZXQocy0+YXV0aG9yaXplZF9tYWNzLCAweGZmLCBFVEhfQUxFTik7Ci0jZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KIAkJfQogCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KFdQU19QQkNfV0FMS19USU1FLCAwLAogCQkJCSAgICAgICB1cG5wX2VyX3NldF9zZWxlY3RlZF90aW1lb3V0LCBzLCByZWcpOwpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfdXBucF9pLmggYi9zcmMvd3BzL3dwc191cG5wX2kuaAppbmRleCA1YzM5ZjdlLi5mMjg5ZmU2IDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc191cG5wX2kuaAorKysgYi9zcmMvd3BzL3dwc191cG5wX2kuaApAQCAtMTU4LDcgKzE1OCw2IEBACiBzdHJ1Y3Qgc3Vic2NyaXB0aW9uICogc3Vic2NyaXB0aW9uX2ZpbmQoc3RydWN0IHVwbnBfd3BzX2RldmljZV9zbSAqc20sCiAJCQkJCWNvbnN0IHU4IHV1aWRbVVVJRF9MRU5dKTsKIHZvaWQgc3Vic2NyX2FkZHJfZGVsZXRlKHN0cnVjdCBzdWJzY3JfYWRkciAqYSk7Ci1pbnQgc2VuZF93cGFidWYoaW50IGZkLCBzdHJ1Y3Qgd3BhYnVmICpidWYpOwogaW50IGdldF9uZXRpZl9pbmZvKGNvbnN0IGNoYXIgKm5ldF9pZiwgdW5zaWduZWQgKmlwX2FkZHIsIGNoYXIgKippcF9hZGRyX3RleHQsCiAJCSAgIHU4IG1hY1tFVEhfQUxFTl0pOwogCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc191cG5wX3NzZHAuYyBiL3NyYy93cHMvd3BzX3VwbnBfc3NkcC5jCmluZGV4IDQxNjk2MWMuLjA5ODU3MWMgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX3VwbnBfc3NkcC5jCisrKyBiL3NyYy93cHMvd3BzX3VwbnBfc3NkcC5jCkBAIC0xMzQsNiArMTM0LDggQEAKIAkqaXNsYXN0ID0gMDsKIAlpZmFjZSA9IGRsX2xpc3RfZmlyc3QoJnNtLT5pbnRlcmZhY2VzLAogCQkJICAgICAgc3RydWN0IHVwbnBfd3BzX2RldmljZV9pbnRlcmZhY2UsIGxpc3QpOworCWlmICghaWZhY2UpCisJCXJldHVybiBOVUxMOwogCXV1aWRfYmluMnN0cihpZmFjZS0+d3BzLT51dWlkLCB1dWlkX3N0cmluZywgc2l6ZW9mKHV1aWRfc3RyaW5nKSk7CiAJbXNnID0gd3BhYnVmX2FsbG9jKDgwMCk7IC8qIG1vcmUgdGhhbiBiaWcgZW5vdWdoICovCiAJaWYgKG1zZyA9PSBOVUxMKQpAQCAtNTg3LDYgKzU4OSw4IEBACiAJCQkJCSZzbS0+aW50ZXJmYWNlcywKIAkJCQkJc3RydWN0IHVwbnBfd3BzX2RldmljZV9pbnRlcmZhY2UsCiAJCQkJCWxpc3QpOworCQkJCWlmICghaWZhY2UpCisJCQkJCWNvbnRpbnVlOwogCQkJCWRhdGEgKz0gb3Nfc3RybGVuKCJ1dWlkOiIpOwogCQkJCXV1aWRfYmluMnN0cihpZmFjZS0+d3BzLT51dWlkLCB1dWlkX3N0cmluZywKIAkJCQkJICAgICBzaXplb2YodXVpZF9zdHJpbmcpKTsKZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX3VwbnBfd2ViLmMgYi9zcmMvd3BzL3dwc191cG5wX3dlYi5jCmluZGV4IDExMzg2ZDguLmIxY2Y1NzEgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX3VwbnBfd2ViLmMKKysrIGIvc3JjL3dwcy93cHNfdXBucF93ZWIuYwpAQCAtMTc5LDE1ICsxNzksMTIgQEAKIC8qIGZvcm1hdF93cHNfZGV2aWNlX3htbCAtLSBwcm9kdWNlIGNvbnRlbnQgb2YgImZpbGUiIHdwc19kZXZpY2UueG1sCiAgKiAoVVBOUF9XUFNfREVWSUNFX1hNTF9GSUxFKQogICovCi1zdGF0aWMgdm9pZCBmb3JtYXRfd3BzX2RldmljZV94bWwoc3RydWN0IHVwbnBfd3BzX2RldmljZV9zbSAqc20sCitzdGF0aWMgdm9pZCBmb3JtYXRfd3BzX2RldmljZV94bWwoc3RydWN0IHVwbnBfd3BzX2RldmljZV9pbnRlcmZhY2UgKmlmYWNlLAorCQkJCSAgc3RydWN0IHVwbnBfd3BzX2RldmljZV9zbSAqc20sCiAJCQkJICBzdHJ1Y3Qgd3BhYnVmICpidWYpCiB7CiAJY29uc3QgY2hhciAqczsKIAljaGFyIHV1aWRfc3RyaW5nWzgwXTsKLQlzdHJ1Y3QgdXBucF93cHNfZGV2aWNlX2ludGVyZmFjZSAqaWZhY2U7Ci0KLQlpZmFjZSA9IGRsX2xpc3RfZmlyc3QoJnNtLT5pbnRlcmZhY2VzLAotCQkJICAgICAgc3RydWN0IHVwbnBfd3BzX2RldmljZV9pbnRlcmZhY2UsIGxpc3QpOwogCiAJd3BhYnVmX3B1dF9zdHIoYnVmLCB3cHNfZGV2aWNlX3htbF9wcmVmaXgpOwogCkBAIC0zMTksMTMgKzMxNiwxNSBAQAogCiAJaWZhY2UgPSBkbF9saXN0X2ZpcnN0KCZzbS0+aW50ZXJmYWNlcywKIAkJCSAgICAgIHN0cnVjdCB1cG5wX3dwc19kZXZpY2VfaW50ZXJmYWNlLCBsaXN0KTsKKwlpZiAoaWZhY2UgPT0gTlVMTCkgeworCQlodHRwX3JlcXVlc3RfZGVpbml0KGhyZXEpOworCQlyZXR1cm47CisJfQogCiAJLyoKIAkgKiBJdCBpcyBub3QgcmVxdWlyZWQgdGhhdCBmaWxlbmFtZXMgYmUgY2FzZSBpbnNlbnNpdGl2ZSBidXQgaXQgaXMKIAkgKiBhbGxvd2VkIGFuZCBjYW5ub3QgaHVydCBoZXJlLgogCSAqLwotCWlmIChmaWxlbmFtZSA9PSBOVUxMKQotCQlmaWxlbmFtZSA9ICIobnVsbCkiOyAvKiBqdXN0IGluIGNhc2UgKi8KIAlpZiAob3Nfc3RyY2FzZWNtcChmaWxlbmFtZSwgVVBOUF9XUFNfREVWSUNFX1hNTF9GSUxFKSA9PSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTIFVQblA6IEhUVFAgR0VUIGZvciBkZXZpY2UgWE1MIik7CiAJCXJlcSA9IEdFVF9ERVZJQ0VfWE1MX0ZJTEU7CkBAIC0zOTMsNyArMzkyLDcgQEAKIAogCXN3aXRjaCAocmVxKSB7CiAJY2FzZSBHRVRfREVWSUNFX1hNTF9GSUxFOgotCQlmb3JtYXRfd3BzX2RldmljZV94bWwoc20sIGJ1Zik7CisJCWZvcm1hdF93cHNfZGV2aWNlX3htbChpZmFjZSwgc20sIGJ1Zik7CiAJCWJyZWFrOwogCWNhc2UgR0VUX1NDUERfWE1MX0ZJTEU6CiAJCXdwYWJ1Zl9wdXRfc3RyKGJ1Ziwgd3BzX3NjcGRfeG1sKTsKQEAgLTQyMSwxMyArNDIwLDE0IEBACiAKIAlpZmFjZSA9IGRsX2xpc3RfZmlyc3QoJnNtLT5pbnRlcmZhY2VzLAogCQkJICAgICAgc3RydWN0IHVwbnBfd3BzX2RldmljZV9pbnRlcmZhY2UsIGxpc3QpOwotCXBlZXIgPSAmaWZhY2UtPnBlZXI7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBVUG5QOiBHZXREZXZpY2VJbmZvIik7CiAKLQlpZiAoaWZhY2UtPmN0eC0+YXBfcGluID09IE5VTEwpCisJaWYgKCFpZmFjZSB8fCBpZmFjZS0+Y3R4LT5hcF9waW4gPT0gTlVMTCkKIAkJcmV0dXJuIEhUVFBfSU5URVJOQUxfU0VSVkVSX0VSUk9SOwogCisJcGVlciA9ICZpZmFjZS0+cGVlcjsKKwogCS8qCiAJICogUmVxdWVzdCBmb3IgRGV2aWNlSW5mbywgaS5lLiwgTTEgVExWcy4gVGhpcyBpcyBhIHN0YXJ0IG9mIFdQUwogCSAqIHJlZ2lzdHJhdGlvbiBvdmVyIFVQblAgd2l0aCB0aGUgQVAgYWN0aW5nIGFzIGFuIEVucm9sbGVlLiBJdCBzaG91bGQKQEAgLTQ3NSw2ICs0NzUsOCBAQAogCiAJaWZhY2UgPSBkbF9saXN0X2ZpcnN0KCZzbS0+aW50ZXJmYWNlcywKIAkJCSAgICAgIHN0cnVjdCB1cG5wX3dwc19kZXZpY2VfaW50ZXJmYWNlLCBsaXN0KTsKKwlpZiAoIWlmYWNlKQorCQlyZXR1cm4gSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CiAKIAkvKgogCSAqIFB1dE1lc3NhZ2UgaXMgdXNlZCBieSBleHRlcm5hbCBVUG5QLWJhc2VkIFJlZ2lzdHJhciB0byBwZXJmb3JtIFdQUwpAQCAtOTQ4LDcgKzk1MCw3IEBACiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFMgVVBuUDogSFRUUCBTVUJTQ1JJQkUgZm9yIGV2ZW50Iik7CiAJZW5kID0gb3Nfc3RyY2hyKGgsICdcbicpOwogCi0JZm9yICg7IGVuZCAhPSBOVUxMOyBoID0gZW5kICsgMSkgeworCXdoaWxlIChlbmQpIHsKIAkJLyogT3B0aW9uIGxpbmUgYnkgb3B0aW9uIGxpbmUgKi8KIAkJaCA9IGVuZCArIDE7CiAJCWVuZCA9IG9zX3N0cmNocihoLCAnXG4nKTsKQEAgLTExNTUsNyArMTE1Nyw3IEBACiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFMgVVBuUDogSFRUUCBVTlNVQlNDUklCRSBmb3IgZXZlbnQiKTsKIAllbmQgPSBvc19zdHJjaHIoaCwgJ1xuJyk7CiAKLQlmb3IgKDsgZW5kICE9IE5VTEw7IGggPSBlbmQgKyAxKSB7CisJd2hpbGUgKGVuZCkgewogCQkvKiBPcHRpb24gbGluZSBieSBvcHRpb24gbGluZSAqLwogCQloID0gZW5kICsgMTsKIAkJZW5kID0gb3Nfc3RyY2hyKGgsICdcbicpOwpAQCAtMTE3Myw3ICsxMTc1LDYgQEAKIAkJCS4uLi4uCiAJCX0KICNlbmRpZgotCQkvKiBTSUQgaXMgb25seSBmb3IgcmVuZXdhbCAqLwogCQltYXRjaCA9ICJTSUQ6IjsKIAkJbWF0Y2hfbGVuID0gb3Nfc3RybGVuKG1hdGNoKTsKIAkJaWYgKG9zX3N0cm5jYXNlY21wKGgsIG1hdGNoLCBtYXRjaF9sZW4pID09IDApIHsKQEAgLTExOTYsNiArMTE5NywyMCBAQAogCQkJZ290X3V1aWQgPSAxOwogCQkJY29udGludWU7CiAJCX0KKworCQltYXRjaCA9ICJOVDoiOworCQltYXRjaF9sZW4gPSBvc19zdHJsZW4obWF0Y2gpOworCQlpZiAob3Nfc3RybmNhc2VjbXAoaCwgbWF0Y2gsIG1hdGNoX2xlbikgPT0gMCkgeworCQkJcmV0ID0gSFRUUF9CQURfUkVRVUVTVDsKKwkJCWdvdG8gc2VuZF9tc2c7CisJCX0KKworCQltYXRjaCA9ICJDQUxMQkFDSzoiOworCQltYXRjaF9sZW4gPSBvc19zdHJsZW4obWF0Y2gpOworCQlpZiAob3Nfc3RybmNhc2VjbXAoaCwgbWF0Y2gsIG1hdGNoX2xlbikgPT0gMCkgeworCQkJcmV0ID0gSFRUUF9CQURfUkVRVUVTVDsKKwkJCWdvdG8gc2VuZF9tc2c7CisJCX0KIAl9CiAKIAlpZiAoZ290X3V1aWQpIHsKQEAgLTEyMDksNiArMTIyNCwxMCBAQAogCQkJCSAgIHNhLT5kb21haW5fYW5kX3BvcnQgOiAiLW51bGwtIik7CiAJCQlkbF9saXN0X2RlbCgmcy0+bGlzdCk7CiAJCQlzdWJzY3JpcHRpb25fZGVzdHJveShzKTsKKwkJfSBlbHNlIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJXUFMgVVBuUDogQ291bGQgbm90IGZpbmQgbWF0Y2hpbmcgc3Vic2NyaXB0aW9uIHRvIHVuc3Vic2NyaWJlIik7CisJCQlyZXQgPSBIVFRQX1BSRUNPTkRJVElPTl9GQUlMRUQ7CisJCQlnb3RvIHNlbmRfbXNnOwogCQl9CiAJfSBlbHNlIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUyBVUG5QOiBVbnN1YnNjcmliZSBmYWlscyAobm90ICIKZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX3ZhbGlkYXRlLmMgYi9zcmMvd3BzL3dwc192YWxpZGF0ZS5jCmluZGV4IGUzNjYyNTYuLjFjNmExNGIgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX3ZhbGlkYXRlLmMKKysrIGIvc3JjL3dwcy93cHNfdmFsaWRhdGUuYwpAQCAtMjY3LDcgKzI2Nyw3IEBACiAJCXJldHVybiAwOwogCX0KIAl2YWwgPSBXUEFfR0VUX0JFMTYoY29uZmlnX2Vycm9yKTsKLQlpZiAodmFsID4gMTgpIHsKKwlpZiAodmFsID4gMjApIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUy1TVFJJQ1Q6IEludmFsaWQgQ29uZmlndXJhdGlvbiBFcnJvciAiCiAJCQkgICAiYXR0cmlidXRlIHZhbHVlIDB4JTA0eCIsIHZhbCk7CiAJCXJldHVybiAtMTsKQEAgLTI5MCw3ICsyOTAsNyBAQAogCQlyZXR1cm4gMDsKIAl9CiAJdmFsID0gV1BBX0dFVF9CRTE2KGRldl9wYXNzd29yZF9pZCk7Ci0JaWYgKHZhbCA+PSAweDAwMDYgJiYgdmFsIDw9IDB4MDAwZikgeworCWlmICh2YWwgPj0gMHgwMDA4ICYmIHZhbCA8PSAweDAwMGYpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUy1TVFJJQ1Q6IEludmFsaWQgRGV2aWNlIFBhc3N3b3JkIElEICIKIAkJCSAgICJhdHRyaWJ1dGUgdmFsdWUgMHglMDR4IiwgdmFsKTsKIAkJcmV0dXJuIC0xOwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvQW5kcm9pZC5tayBiL3dwYV9zdXBwbGljYW50L0FuZHJvaWQubWsKaW5kZXggODUxNWI1YS4uNDNjM2VlZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvQW5kcm9pZC5taworKysgYi93cGFfc3VwcGxpY2FudC9BbmRyb2lkLm1rCkBAIC0yNCwyNCArMjQsMjAgQEAKICMgU2V0IEFuZHJvaWQgbG9nIG5hbWUKIExfQ0ZMQUdTICs9IC1EQU5EUk9JRF9MT0dfTkFNRT1cIndwYV9zdXBwbGljYW50XCIKIAorIyBEaXNhYmxlIHVudXNlZCBwYXJhbWV0ZXIgd2FybmluZ3MKK0xfQ0ZMQUdTICs9IC1Xbm8tdW51c2VkLXBhcmFtZXRlcgorCisjIFNldCBBbmRyb2lkIGV4dGVuZGVkIFAyUCBmdW5jdGlvbmFsaXR5CitMX0NGTEFHUyArPSAtREFORFJPSURfUDJQCitpZmVxICgkKEJPQVJEX1dQQV9TVVBQTElDQU5UX1BSSVZBVEVfTElCKSwpCitMX0NGTEFHUyArPSAtREFORFJPSURfUDJQX1NUVUIKK2VuZGlmCisKICMgRGlzYWJsZSByb2FtaW5nIGluIHdwYV9zdXBwbGljYW50CiBpZmRlZiBDT05GSUdfTk9fUk9BTUlORwogTF9DRkxBR1MgKz0gLURDT05GSUdfTk9fUk9BTUlORwogZW5kaWYKIAotaWZlcSAoJChCT0FSRF9XTEFOX0RFVklDRSksIGJjbWRoZCkKLUxfQ0ZMQUdTICs9IC1EQU5EUk9JRF9QMlAKLUxfQ0ZMQUdTICs9IC1EUDJQX0NPTkNVUlJFTlRfU0VBUkNIX0RFTEFZPTAKLWVuZGlmCi0KLWlmZXEgKCQoQk9BUkRfV0xBTl9ERVZJQ0UpLCBxY3djbikKLUxfQ0ZMQUdTICs9IC1EQU5EUk9JRF9QMlAKLWVuZGlmCi0KLWlmZXEgKCQoQk9BUkRfV0xBTl9ERVZJQ0UpLCBtcnZsKQotTF9DRkxBR1MgKz0gLURBTkRST0lEX1AyUAotZW5kaWYKLQogIyBVc2UgQW5kcm9pZCBzcGVjaWZpYyBkaXJlY3RvcnkgZm9yIGNvbnRyb2wgaW50ZXJmYWNlIHNvY2tldHMKIExfQ0ZMQUdTICs9IC1EQ09ORklHX0NUUkxfSUZBQ0VfQ0xJRU5UX0RJUj1cIi9kYXRhL21pc2Mvd2lmaS9zb2NrZXRzXCIKIExfQ0ZMQUdTICs9IC1EQ09ORklHX0NUUkxfSUZBQ0VfRElSPVwiL2RhdGEvc3lzdGVtL3dwYV9zdXBwbGljYW50XCIKQEAgLTUxLDkgKzQ3LDYgQEAKIExfQ0ZMQUdTICs9IC1tYWJpPWFhcGNzLWxpbnV4CiBlbmRpZgogCi0jIFRvIGFsbG93IG5vbi1BU0NJSSBjaGFyYWN0ZXJzIGluIFNTSUQKLUxfQ0ZMQUdTICs9IC1EV1BBX1VOSUNPREVfU1NJRAotCiBJTkNMVURFUyA9ICQoTE9DQUxfUEFUSCkKIElOQ0xVREVTICs9ICQoTE9DQUxfUEFUSCkvc3JjCiBJTkNMVURFUyArPSAkKExPQ0FMX1BBVEgpL3NyYy9jb21tb24KQEAgLTcxLDEwICs2NCwxNCBAQAogSU5DTFVERVMgKz0gJChMT0NBTF9QQVRIKS9zcmMvdXRpbHMKIElOQ0xVREVTICs9ICQoTE9DQUxfUEFUSCkvc3JjL3dwcwogSU5DTFVERVMgKz0gZXh0ZXJuYWwvb3BlbnNzbC9pbmNsdWRlCi1JTkNMVURFUyArPSBzeXN0ZW0vc2VjdXJpdHkva2V5c3RvcmUKK0lOQ0xVREVTICs9IHN5c3RlbS9zZWN1cml0eS9rZXlzdG9yZS9pbmNsdWRlCiBpZmRlZiBDT05GSUdfRFJJVkVSX05MODAyMTEKK2lmbmVxICgkKHdpbGRjYXJkIGV4dGVybmFsL2xpYm5sKSwpCitJTkNMVURFUyArPSBleHRlcm5hbC9saWJubC9pbmNsdWRlCitlbHNlCiBJTkNMVURFUyArPSBleHRlcm5hbC9saWJubC1oZWFkZXJzCiBlbmRpZgorZW5kaWYKIAogaWZkZWYgQ09ORklHX0ZJUFMKIENPTkZJR19OT19SQU5ET01fUE9PTD0KQEAgLTEzOSw2ICsxMzYsMTAgQEAKIExfQ0ZMQUdTICs9IC1EQ09ORklHX0VMT09QX1BPTEwKIGVuZGlmCiAKK2lmZGVmIENPTkZJR19FTE9PUF9FUE9MTAorTF9DRkxBR1MgKz0gLURDT05GSUdfRUxPT1BfRVBPTEwKK2VuZGlmCisKIGlmZGVmIENPTkZJR19FQVBPTF9URVNUCiBMX0NGTEFHUyArPSAtV2Vycm9yIC1ERUFQT0xfVEVTVAogZW5kaWYKQEAgLTI1OCw2ICsyNTksNyBAQAogT0JKUyArPSBzcmMvcDJwL3AycF9kZXZfZGlzYy5jCiBPQkpTICs9IHNyYy9wMnAvcDJwX2dyb3VwLmMKIE9CSlMgKz0gc3JjL2FwL3AycF9ob3N0YXBkLmMKK09CSlMgKz0gc3JjL3V0aWxzL2JpdGZpZWxkLmMKIExfQ0ZMQUdTICs9IC1EQ09ORklHX1AyUAogTkVFRF9HQVM9eQogTkVFRF9PRkZDSEFOTkVMPXkKQEAgLTI3OCw2ICsyODAsNyBAQAogT0JKUyArPSBoczIwX3N1cHBsaWNhbnQuYwogTF9DRkxBR1MgKz0gLURDT05GSUdfSFMyMAogQ09ORklHX0lOVEVSV09SS0lORz15CitORUVEX0FFU19PTUFDMT15CiBlbmRpZgogCiBpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCkBAIC01MDcsNyArNTEwLDcgQEAKIGlmZGVmIENPTkZJR19FQVBfUFJPWFkKIExfQ0ZMQUdTICs9IC1EQ09ORklHX0VBUF9QUk9YWQogT0JKUyArPSBzcmMvZWFwX3BlZXIvZWFwX3Byb3h5XyQoQ09ORklHX0VBUF9QUk9YWSkuYwotaW5jbHVkZSBlYXBfcHJveHlfJChDT05GSUdfRUFQX1BST1hZKS5taworaW5jbHVkZSAkKExPQ0FMX1BBVEgpL2VhcF9wcm94eV8kKENPTkZJR19FQVBfUFJPWFkpLm1rCiBDT05GSUdfSUVFRTgwMjFYX0VBUE9MPXkKIGVuZGlmCiAKQEAgLTYxNCwxMCArNjE3LDYgQEAKIGVuZGlmCiAKIGlmZGVmIENPTkZJR19XUFMKLWlmZGVmIENPTkZJR19XUFMyCi1MX0NGTEFHUyArPSAtRENPTkZJR19XUFMyCi1lbmRpZgotCiAjIEVBUC1XU0MKIExfQ0ZMQUdTICs9IC1EQ09ORklHX1dQUyAtREVBUF9XU0MKIE9CSlMgKz0gd3BzX3N1cHBsaWNhbnQuYwpAQCAtNzcyLDYgKzc3MSw5IEBACiBPQkpTICs9IHNyYy9hcC9lYXBfdXNlcl9kYi5jCiBpZmRlZiBDT05GSUdfSUVFRTgwMjExTgogT0JKUyArPSBzcmMvYXAvaWVlZTgwMl8xMV9odC5jCitpZmRlZiBDT05GSUdfSUVFRTgwMjExQUMKK09CSlMgKz0gc3JjL2FwL2llZWU4MDJfMTFfdmh0LmMKK2VuZGlmCiBlbmRpZgogaWZkZWYgQ09ORklHX1dOTQogT0JKUyArPSBzcmMvYXAvd25tX2FwLmMKQEAgLTc4Nyw2ICs3ODksOSBAQAogCiBpZmRlZiBDT05GSUdfSUVFRTgwMjExTgogTF9DRkxBR1MgKz0gLURDT05GSUdfSUVFRTgwMjExTgoraWZkZWYgQ09ORklHX0lFRUU4MDIxMUFDCitMX0NGTEFHUyArPSAtRENPTkZJR19JRUVFODAyMTFBQworZW5kaWYKIGVuZGlmCiAKIGlmZGVmIE5FRURfQVBfTUxNRQpAQCAtNzk0LDYgKzc5OSw3IEBACiBPQkpTICs9IHNyYy9hcC9hcF9saXN0LmMKIE9CSlMgKz0gc3JjL2FwL2llZWU4MDJfMTEuYwogT0JKUyArPSBzcmMvYXAvaHdfZmVhdHVyZXMuYworT0JKUyArPSBzcmMvYXAvZGZzLmMKIExfQ0ZMQUdTICs9IC1ETkVFRF9BUF9NTE1FCiBlbmRpZgogaWZkZWYgQ09ORklHX1dQUwpAQCAtOTUyLDcgKzk1OCw4IEBACiBPQkpTICs9IHNyYy9jcnlwdG8vY3J5cHRvX2dudXRscy5jCiBPQkpTX3AgKz0gc3JjL2NyeXB0by9jcnlwdG9fZ251dGxzLmMKIGlmZGVmIE5FRURfRklQUzE4Nl8yX1BSRgotT0JKUyArPSBzcmMvY3J5cHRvL2ZpcHNfcHJmX2dudXRscy5jCitPQkpTICs9IHNyYy9jcnlwdG8vZmlwc19wcmZfaW50ZXJuYWwuYworT0JKUyArPSBzcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwuYwogZW5kaWYKIExJQlMgKz0gLWxnY3J5cHQKIExJQlNfcCArPSAtbGdjcnlwdApAQCAtOTY4LDcgKzk3NSw4IEBACiBPQkpTICs9IHNyYy9jcnlwdG8vY3J5cHRvX2NyeXB0b2FwaS5jCiBPQkpTX3AgKz0gc3JjL2NyeXB0by9jcnlwdG9fY3J5cHRvYXBpLmMKIGlmZGVmIE5FRURfRklQUzE4Nl8yX1BSRgotT0JKUyArPSBzcmMvY3J5cHRvL2ZpcHNfcHJmX2NyeXB0b2FwaS5jCitPQkpTICs9IHNyYy9jcnlwdG8vZmlwc19wcmZfaW50ZXJuYWwuYworT0JKUyArPSBzcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwuYwogZW5kaWYKIENPTkZJR19JTlRFUk5BTF9TSEEyNTY9eQogQ09ORklHX0lOVEVSTkFMX1JDND15CkBAIC05ODMsNyArOTkxLDggQEAKIE9CSlMgKz0gc3JjL2NyeXB0by9jcnlwdG9fbnNzLmMKIE9CSlNfcCArPSBzcmMvY3J5cHRvL2NyeXB0b19uc3MuYwogaWZkZWYgTkVFRF9GSVBTMTg2XzJfUFJGCi1PQkpTICs9IHNyYy9jcnlwdG8vZmlwc19wcmZfbnNzLmMKK09CSlMgKz0gc3JjL2NyeXB0by9maXBzX3ByZl9pbnRlcm5hbC5jCitPQkpTICs9IHNyYy9jcnlwdG8vc2hhMS1pbnRlcm5hbC5jCiBlbmRpZgogTElCUyArPSAtbG5zczMKIExJQlNfcCArPSAtbG5zczMKQEAgLTExMjIsNyArMTEzMSw3IEBACiBpZmRlZiBORUVEX0FFU19PTUFDMQogTkVFRF9BRVNfRU5DPXkKIGlmZGVmIENPTkZJR19PUEVOU1NMX0NNQUMKLUNGTEFHUyArPSAtRENPTkZJR19PUEVOU1NMX0NNQUMKK0xfQ0ZMQUdTICs9IC1EQ09ORklHX09QRU5TU0xfQ01BQwogZWxzZQogQUVTT0JKUyArPSBzcmMvY3J5cHRvL2Flcy1vbWFjMS5jCiBlbmRpZgpAQCAtMTE3MSw3ICsxMTgwLDEwIEBACiBlbmRpZgogZW5kaWYKIAotTUQ1T0JKUyA9IHNyYy9jcnlwdG8vbWQ1LmMKK01ENU9CSlMgPQoraWZuZGVmIENPTkZJR19GSVBTCitNRDVPQkpTICs9IHNyYy9jcnlwdG8vbWQ1LmMKK2VuZGlmCiBpZmRlZiBORUVEX01ENQogaWZkZWYgQ09ORklHX0lOVEVSTkFMX01ENQogTUQ1T0JKUyArPSBzcmMvY3J5cHRvL21kNS1pbnRlcm5hbC5jCkBAIC0xNDI1LDcgKzE0MzcsNyBAQAogZW5kaWYKIAogaWZkZWYgQ09ORklHX0FVVE9TQ0FOX1BFUklPRElDCi1DRkxBR1MgKz0gLURDT05GSUdfQVVUT1NDQU5fUEVSSU9ESUMKK0xfQ0ZMQUdTICs9IC1EQ09ORklHX0FVVE9TQ0FOX1BFUklPRElDCiBPQkpTICs9IGF1dG9zY2FuX3BlcmlvZGljLmMKIE5FRURfQVVUT1NDQU49eQogZW5kaWYKQEAgLTE1NTIsMTIgKzE1NjQsMjAgQEAKIExPQ0FMX1NUQVRJQ19MSUJSQVJJRVMgKz0gJChCT0FSRF9XUEFfU1VQUExJQ0FOVF9QUklWQVRFX0xJQikKIGVuZGlmCiBMT0NBTF9TSEFSRURfTElCUkFSSUVTIDo9IGxpYmMgbGliY3V0aWxzIGxpYmxvZworaWZkZWYgQ09ORklHX0VBUF9QUk9YWQorTE9DQUxfU1RBVElDX0xJQlJBUklFUyArPSAkKExJQl9TVEFUSUNfRUFQX1BST1hZKQorTE9DQUxfU0hBUkVEX0xJQlJBUklFUyArPSAkKExJQl9TSEFSRURfRUFQX1BST1hZKQorZW5kaWYKIGlmZXEgKCQoQ09ORklHX1RMUyksIG9wZW5zc2wpCiBMT0NBTF9TSEFSRURfTElCUkFSSUVTICs9IGxpYmNyeXB0byBsaWJzc2wgbGlia2V5c3RvcmVfYmluZGVyCiBlbmRpZgogaWZkZWYgQ09ORklHX0RSSVZFUl9OTDgwMjExCitpZm5lcSAoJCh3aWxkY2FyZCBleHRlcm5hbC9saWJubCksKQorTE9DQUxfU0hBUkVEX0xJQlJBUklFUyArPSBsaWJubAorZWxzZQogTE9DQUxfU1RBVElDX0xJQlJBUklFUyArPSBsaWJubF8yCiBlbmRpZgorZW5kaWYKIExPQ0FMX0NGTEFHUyA6PSAkKExfQ0ZMQUdTKQogTE9DQUxfU1JDX0ZJTEVTIDo9ICQoT0JKUykKIExPQ0FMX0NfSU5DTFVERVMgOj0gJChJTkNMVURFUykKQEAgLTE1OTcsNCArMTYxNyw1IEBACiBMT0NBTF9TSEFSRURfTElCUkFSSUVTIDo9IGxpYmN1dGlscyBsaWJsb2cKIExPQ0FMX0NPUFlfSEVBREVSU19UTyA6PSBsaWJ3cGFfY2xpZW50CiBMT0NBTF9DT1BZX0hFQURFUlMgOj0gc3JjL2NvbW1vbi93cGFfY3RybC5oCitMT0NBTF9DT1BZX0hFQURFUlMgKz0gc3JjL2NvbW1vbi9xY2EtdmVuZG9yLmgKIGluY2x1ZGUgJChCVUlMRF9TSEFSRURfTElCUkFSWSkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L0NoYW5nZUxvZyBiL3dwYV9zdXBwbGljYW50L0NoYW5nZUxvZwppbmRleCAzZjEwZTExLi41NTU4YTVlIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9DaGFuZ2VMb2cKKysrIGIvd3BhX3N1cHBsaWNhbnQvQ2hhbmdlTG9nCkBAIC0xLDggKzEsMjMzIEBACiBDaGFuZ2VMb2cgZm9yIHdwYV9zdXBwbGljYW50CiAKLT8/Pz8tPz8tPz8gLSB2Mi4xCi0JKiBhZGRlZCBzdXBwb3J0IGZvciBzaW11bGF0YW5lb3VzIGF1dGhlbnRpY2F0aW9uIG9mIGVxdWFscyAoU0FFKSBmb3IKKzIwMTQtMDYtMDQgLSB2Mi4yCisJKiBhZGRlZCBERlMgaW5kaWNhdG9yIHRvIGdldF9jYXBhYmlsaXR5IGZyZXEKKwkqIGFkZGVkL2ZpeGVkIG5sODAyMTEgZnVuY3Rpb25hbGl0eQorCSAgLSBCU1NJRC9mcmVxdWVuY3kgaGludCBmb3IgZHJpdmVyLWJhc2VkIEJTUyBzZWxlY3Rpb24KKwkgIC0gZml4IHRlYXJpbmcgZG93biBXRFMgU1RBIGludGVyZmFjZXMKKwkgIC0gc3VwcG9ydCB2ZW5kb3Igc3BlY2lmaWMgZHJpdmVyIGNvbW1hbmQKKwkgICAgKFZFTkRPUiA8dmVuZG9yIGlkPiA8c3ViIGNvbW1hbmQgaWQ+IFs8aGV4IGZvcm1hdHRlZCBkYXRhPl0pCisJICAtIEdPIGludGVyZmFjZSB0ZWFyZG93biBvcHRpbWl6YXRpb24KKwkgIC0gYWxsb3cgYmVhY29uIGludGVydmFsIHRvIGJlIGNvbmZpZ3VyZWQgZm9yIElCU1MKKwkgIC0gYWRkIFNIQTI1Ni1iYXNlZCBBS00gc3VpdGVzIHRvIENPTk5FQ1QvQVNTT0NJQVRFIGNvbW1hbmRzCisJKiByZW1vdmVkIHVudXNlZCBORkNfUlhfSEFORE9WRVJfUkVRIGFuZCBORkNfUlhfSEFORE9WRVJfU0VMIGNvbnRyb2wKKwkgIGludGVyZmFjZSBjb21tYW5kcyAodGhlIG1vcmUgZ2VuZXJpYyBORkNfUkVQT1JUX0hBTkRPVkVSIGlzIG5vdyB1c2VkKQorCSogZml4ZWQgTVNDSEFQIFVURi04IHRvIFVDUy0yIGNvbnZlcnNpb24gZm9yIHRocmVlLWJ5dGUgZW5jb2Rpbmc7CisJICB0aGlzIGZpeGVzIHBhc3N3b3JkIHdpdGggaW5jbHVkZSBVVEYtOCBjaGFyYWN0ZXJzIHRoYXQgdXNlCisJICB0aHJlZS1ieXRlIGVuY29kaW5nIEVBUCBtZXRob2RzIHRoYXQgdXNlIE50UGFzc3dvcmRIYXNoCisJKiBmaXhlZCBjb3VwbGUgb2Ygc2VxdWVuY2llcyB3aGVyZSByYWRpbyB3b3JrIGl0ZW1zIGNvdWxkIGdldCBzdHVjaywKKwkgIGUuZy4sIHdoZW4gcmZraWxsIGJsb2NraW5nIGhhcHBlbnMgZHVyaW5nIHNjYW5uaW5nIG9yIHdoZW4KKwkgIHNjYW4tZm9yLWF1dGggd29ya2Fyb3VuZCBpcyB1c2VkCisJKiBQMlAgZW5oYW5jZW1lbnRzL2ZpeGVzCisJICAtIGVuYWJsZSBlbmFibGUgVS1BUFNEIG9uIEdPIGF1dG9tYXRpY2FsbHkgaWYgdGhlIGRyaXZlciBpbmRpY2F0ZXMKKwkgICAgc3VwcG9ydCBmb3IgdGhpcworCSAgLSBmaXhlZCBzb21lIHNlcnZpY2UgZGlzY292ZXJ5IGNhc2VzIHdpdGggYnJvYWRjYXN0IHF1ZXJpZXMgbm90IGJlaW5nCisJICAgIHNlbnQgdG8gYWxsIHN0YXRpb25zCisJICAtIGZpeGVkIFByb2JlIFJlcXVlc3QgZnJhbWUgdHJpZ2dlcmluZyBpbnZpdGF0aW9uIHRvIHRyaWdnZXIgb25seSBhCisJICAgIHNpbmdsZSBpbnZpdGF0aW9uIGluc3RhbmNlIGV2ZW4gaWYgbXVsdGlwbGUgUHJvYmUgUmVxdWVzdCBmcmFtZXMgYXJlCisJICAgIHJlY2VpdmVkCisJICAtIGZpeGVkIGEgcG90ZW50aWFsIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSBjcmFzaCB3aGVuIHByb2Nlc3NpbmcgYW4KKwkgICAgaW52YWxpZCBJbnZpdGF0aW9uIFJlcXVlc3QgZnJhbWUKKwkgIC0gYWRkIG9wdGlvbmFsIGNvbmZpZ3VyYXRpb24gZmlsZSBmb3IgdGhlIFAyUF9ERVZJQ0UgcGFyYW1ldGVycworCSAgLSBvcHRpbWl6ZSBzY2FuIGZvciBHTyBkdXJpbmcgcGVyc2lzdGVudCBncm91cCBpbnZvY2F0aW9uCisJICAtIGZpeCBwb3NzaWJsZSBzZWdtZW50YXRpb24gZmF1bHQgd2hlbiBQQkMgb3ZlcmxhcCBpcyBkZXRlY3RlZCB3aGlsZQorCSAgICB1c2luZyBhIHNlcGFyYXRlIFAyUCBncm91cCBpbnRlcmZhY2UKKwkgIC0gaW1wcm92ZSBHTyBOZWdvdGlhdGlvbiByb2J1c3RuZXNzIGJ5IGFsbG93aW5nIEdPIE5lZ290aWF0aW9uCisJICAgIENvbmZpcm1hdGlvbiB0byBiZSByZXRyYW5zbWl0dGVkCisJICAtIGRvIHVzZSBmcmVlZCBtZW1vcnkgb24gZGV2aWNlIGZvdW5kIGV2ZW50IHdoZW4gUDJQIE5GQworCSogYWRkZWQgcGhhc2UxIG5ldHdvcmsgcGFyYW1ldGVyIG9wdGlvbnMgZm9yIGRpc2FibGluZyBUTFMgdjEuMSBhbmQgdjEuMgorCSAgdG8gYWxsb3cgd29ya2Fyb3VuZHMgd2l0aCBtaXNiZWhhdmluZyBBQUEgc2VydmVycworCSAgKHRsc19kaXNhYmxlX3Rsc3YxXzE9MSBhbmQgdGxzX2Rpc2FibGVfdGxzdjFfMj0xKQorCSogYWRkZWQgc3VwcG9ydCBmb3IgT0NTUCBzdGFwbGluZyB0byB2YWxpZGF0ZSBBQUEgc2VydmVyIGNlcnRpZmljYXRlCisJICBkdXJpbmcgVExTIGV4Y2hhbmdlCisJKiBJbnRlcndvcmtpbmcvSG90c3BvdCAyLjAgZW5oYW5jZW1lbnRzCisJICAtIHByZWZlciB0aGUgbGFzdCBhZGRlZCBuZXR3b3JrIGluIEludGVyd29ya2luZyBjb25uZWN0aW9uIHRvIG1ha2UgdGhlCisJICAgIGJlaGF2aW9yIG1vcmUgY29uc2lzdGVudCB3aXRoIGxpa2VseSB1c2VyIGV4cGVjdGF0aW9uCisJICAtIHJvYW1pbmcgcGFydG5lciBjb25maWd1cmF0aW9uIChyb2FtaW5nX3BhcnRuZXIgd2l0aGluIGEgY3JlZCBibG9jaykKKwkgIC0gc3VwcG9ydCBIb3RzcG90IDIuMCBSZWxlYXNlIDIKKwkgICAgKiAiaHMyMF9hbnFwX2dldCA8QlNTSUQ+IDgiIHRvIHJlcXVlc3QgT1NVIFByb3ZpZGVycyBsaXN0CisJICAgICogImhzMjBfaWNvbl9yZXF1ZXN0IDxCU1NJRD4gPGljb24gZmlsZW5hbWU+IiB0byByZXF1ZXN0IGljb24gZmlsZXMKKwkgICAgKiAiZmV0Y2hfb3N1IiBhbmQgImNhbmNlbF9vc3VfZmV0Y2giIHRvIHN0YXJ0L3N0b3AgZnVsbCBPU1UgcHJvdmlkZXIKKwkgICAgICBzZWFyY2ggKGFsbCBzdWl0YWJsZSBBUHMgaW4gc2NhbiByZXN1bHRzKQorCSAgICAqIE9TRU4gbmV0d29yayBmb3Igb25saW5lIHNpZ251cCBjb25uZWN0aW9uCisJICAgICogbWluX3tkbCx1bH1fYmFuZHdpZHRoX3tob21lLHJvYW1pbmd9IGNyZWQgcGFyYW1ldGVycworCSAgICAqIG1heF9ic3NfbG9hZCBjcmVkIHBhcmFtZXRlcgorCSAgICAqIHJlcV9jb25uX2NhcGFiIGNyZWQgcGFyYW1ldGVyCisJICAgICogc3BfcHJpb3JpdHkgY3JlZCBwYXJhbWV0ZXIKKwkgICAgKiBvY3NwIGNyZWQgcGFyYW1ldGVyCisJICAgICogc2xvdyBkb3duIGF1dG9tYXRpYyBjb25uZWN0aW9uIGF0dGVtcHRzIG9uIEVBUCBmYWlsdXJlIHRvIG1lZXQKKwkgICAgICByZXF1aXJlZCBiZWhhdmlvciAobm8gbW9yZSB0aGFuIDEwIHJldHJpZXMgd2l0aGluIGEgMTAtbWludXRlCisJICAgICAgaW50ZXJ2YWwpCisJICAgICogc2FtcGxlIGltcGxlbWVudGF0aW9uIG9mIG9ubGluZSBzaWdudXAgY2xpZW50IChib3RoIFNQUCBhbmQKKwkgICAgICBPTUEtRE0gcHJvdG9jb2xzKSAoaHMyMC9jbGllbnQvKikKKwkgIC0gZml4ZWQgR0FTIGluZGljYXRpb24gZm9yIGFkZGl0aW9uYWwgY29tZWJhY2sgZGVsYXkgd2l0aCBzdGF0dXMKKwkgICAgY29kZSA5NQorCSAgLSBleHRlbmQgQU5RUF9HRVQgdG8gYWNjZXB0IEhvdHNwb3QgMi4wIHN1YnR5cGVzCisJICAgIEFOUVBfR0VUIDxhZGRyPiA8aW5mbyBpZD5bLDxpbmZvIGlkPl0uLi4KKwkgICAgWyxoczIwOjxzdWJ0eXBlPl1bLi4uLGhzMjA6PHN1YnR5cGU+XQorCSAgLSBhZGQgY29udHJvbCBpbnRlcmZhY2UgZXZlbnRzIENSRUQtQURERUQgPGlkPiwKKwkgICAgQ1JFRC1NT0RJRklFRCA8aWQ+IDxmaWVsZD4sIENSRUQtUkVNT1ZFRCA8aWQ+CisJICAtIGFkZCAiR0VUX0NSRUQgPGlkPiA8ZmllbGQ+IiBjb21tYW5kCisJICAtIGVuYWJsZSBGVCBmb3IgdGhlIGNvbm5lY3Rpb24gYXV0b21hdGljYWxseSBpZiB0aGUgQVAgYWR2ZXJ0aXNlcworCSAgICBzdXBwb3J0IGZvciB0aGlzCisJICAtIGZpeCBhIGNhc2Ugd2hlcmUgYXV0b19pbnRlcndvcmtpbmc9MSBjb3VsZCBlbmQgdXAgc3RvcHBpbmcgc2Nhbm5pbmcKKwkqIGZpeGVkIFRETFMgaW50ZXJvcGVyYWJpbGl0eSBpc3N1ZXMgd2l0aCBzdXBwb3J0ZWQgb3BlcmF0aW5nIGNsYXNzIGluCisJICBzb21lIGRlcGxveWVkIHN0YXRpb25zCisJKiBpbnRlcm5hbCBUTFMgaW1wbGVtZW50YXRpb24gZW5oYW5jZW1lbnRzL2ZpeGVzCisJICAtIGFkZCBTSEEyNTYtYmFzZWQgY2lwaGVyIHN1aXRlcworCSAgLSBhZGQgREhFLVJTQSBjaXBoZXIgc3VpdGVzCisJICAtIGZpeCBYLjUwOSB2YWxpZGF0aW9uIG9mIFBLQ1MjMSBzaWduYXR1cmUgdG8gY2hlY2sgZm9yIGV4dHJhIGRhdGEKKwkqIGZpeGVkIFBUSyBkZXJpdmF0aW9uIGZvciBDQ01QLTI1NiBhbmQgR0NNUC0yNTYKKwkqIGFkZGVkICJyZWF0dGFjaCIgY29tbWFuZCBmb3IgZmFzdCByZWFzc29jaWF0ZS1iYWNrLXRvLXNhbWUtQlNTCisJKiBhbGxvdyBQTUYgdG8gYmUgZW5hYmxlZCBmb3IgQVAgbW9kZSBvcGVyYXRpb24gd2l0aCB0aGUgaWVlZTgwMjExdworCSAgcGFyYW1ldGVyCisJKiBhZGRlZCAiZ2V0X2NhcGFiaWxpdHkgdGRscyIgY29tbWFuZAorCSogYWRkZWQgb3B0aW9uIHRvIHNldCBjb25maWcgYmxvYnMgdGhyb3VnaCBjb250cm9sIGludGVyZmFjZSB3aXRoCisJICAiU0VUIGJsb2IgPG5hbWU+IDxoZXhkdW1wPiIKKwkqIEQtQnVzIGludGVyZmFjZSBleHRlbnNpb25zL2ZpeGVzCisJICAtIG1ha2UgcDJwX25vX2dyb3VwX2lmYWNlIGNvbmZpZ3VyYWJsZQorCSAgLSBkZWNsYXJlIFNlcnZpY2VEaXNjb3ZlcnlSZXF1ZXN0IG1ldGhvZCBwcm9wZXJseQorCSAgLSBleHBvcnQgcGVlcidzIGRldmljZSBhZGRyZXNzIGFzIGEgcHJvcGVydHkKKwkgIC0gbWFrZSByZWFzc29jaWF0ZSBjb21tYW5kIGJlaGF2ZSBsaWtlIHRoZSBjb250cm9sIGludGVyZmFjZSBvbmUsCisJICAgIGkuZS4sIHRvIGFsbG93IGNvbm5lY3Rpb24gZnJvbSBkaXNjb25uZWN0ZWQgc3RhdGUKKwkqIGFkZGVkIG9wdGlvbmFsICJmcmVxPTxjaGFubmVsIHJhbmdlcz4iIHBhcmFtZXRlciB0byBTRVQgcG5vCisJKiBhZGRlZCBvcHRpb25hbCAiZnJlcT08Y2hhbm5lbCByYW5nZXM+IiBwYXJhbWV0ZXIgdG8gU0VMRUNUX05FVFdPUksKKwkqIGZpeGVkIE9CU1Mgc2NhbiByZXN1bHQgcHJvY2Vzc2luZyBmb3IgMjAvNDAgTUh6IGNvLWV4IHJlcG9ydAorCSogcmVtb3ZlIFdQUyAxLjAgb25seSBzdXBwb3J0LCBpLmUuLCBXU0MgMi4wIHN1cHBvcnQgaXMgbm93IGVuYWJsZWQKKwkgIHdoZW5ldmVyIENPTkZJR19XUFM9eSBpcyBzZXQKKwkqIGZpeGVkIHJlZ3Jlc3Npb24gaW4gcGFyc2luZyBvZiBXTk0gU2xlZXAgTW9kZSBleGl0IGtleSBkYXRhCisJKiBmaXhlZCBwb3RlbnRpYWwgc2VnbWVudGF0aW9uIGZhdWx0IGFuZCBtZW1vcnkgbGVha3MgaW4gV05NIG5laWdoYm9yCisJICByZXBvcnQgcHJvY2Vzc2luZworCSogRUFQLXB3ZCBmaXhlcworCSAgLSBmcmFnbWVudGF0aW9uIG9mIFBXRC1Db25maXJtLVJlc3AKKwkgIC0gZml4IG1lbW9yeSBsZWFrIHdoZW4gZnJhZ21lbnRhdGlvbiBpcyB1c2VkCisJICAtIGZpeCBwb3NzaWJsZSBzZWdtZW50YXRpb24gZmF1bHQgb24gRUFQIG1ldGhvZCBkZWluaXQgaWYgYW4gaW52YWxpZAorCSAgICBncm91cCBpcyBuZWdvdGlhdGVkCisJKiBhZGRlZCBNQUNzZWMvSUVFRSBTdGQgODAyLjFYLTIwMTAgUEFFIGltcGxlbWVudGF0aW9uIChjdXJyZW50bHkKKwkgIGF2YWlsYWJsZSBvbmx5IHdpdGggdGhlIG1hY3NlY19xY2EgZHJpdmVyIHdyYXBwZXIpCisJKiBmaXhlZCBFQVAtU0lNIGNvdW50ZXItdG9vLXNtYWxsIG1lc3NhZ2UKKwkqIGFkZGVkICdkdXBfbmV0d29yayA8aWRfcz4gPGlkX2Q+IDxuYW1lPicgY29tbWFuZDsgdGhpcyBjYW4gYmUgdXNlZCB0bworCSAgY2xvbmUgdGhlIHBzayBmaWVsZCB3aXRob3V0IGhhdmluZyB0b2V4dHJhY3QgaXQgZnJvbSB3cGFfc3VwcGxpY2FudAorCSogZml4ZWQgR1NNIGF1dGhlbnRpY2F0aW9uIG9uIFVTSU0KKwkqIGFkZGVkIHN1cHBvcnQgZm9yIHVzaW4gZXBvbGwgaW4gZWxvb3AgKENPTkZJR19FTE9PUF9FUE9MTD15KQorCSogZml4ZWQgc29tZSBjb25jdXJyZW50IHZpcnR1YWwgaW50ZXJmYWNlIGNhc2VzIHdpdGggZGVkaWNhdGVkIFAyUAorCSAgbWFuYWdlbWVudCBpbnRlcmZhY2UgdG8gbm90IGNhdGNoIGV2ZW50cyBmcm9tIHJlbW92ZWQgaW50ZXJmYWNlICh0aGlzCisJICBjb3VsZCByZXN1bHQgaW4gdGhlIG1hbmFnZW1lbnQgaW50ZXJmYWNlIGdldHRpbmcgZGlzYWJsZWQpCisJKiBmaXhlZCBhIG1lbW9yeSBsZWFrIGluIFNBRSByYW5kb20gbnVtYmVyIGdlbmVyYXRpb24KKwkqIGZpeGVkIG9mZi1ieS1vbmUgYm91bmRzIGNoZWNraW5nIGluIHByaW50Zl9lbmNvZGUoKQorCSAgLSB0aGlzIGNvdWxkIHJlc3VsdCBpbiBzb21lIGNvbnRyb2wgaW50ZXJmYWNlIEFUVEFDSCBjb21tYW5kIGNhc2VzCisJICAgIHRlcm1pbmF0aW5nIHdwYV9zdXBwbGljYW50CisJKiBmaXhlZCBFQVBPTC1LZXkgZXhjaGFuZ2Ugd2hlbiBHQ01QIGlzIHVzZWQgd2l0aCBTSEEyNTYtYmFzZWQgQUtNCisJKiB2YXJpb3VzIGJ1ZyBmaXhlcworCisyMDE0LTAyLTA0IC0gdjIuMQorCSogYWRkZWQgc3VwcG9ydCBmb3Igc2ltdWx0YW5lb3VzIGF1dGhlbnRpY2F0aW9uIG9mIGVxdWFscyAoU0FFKSBmb3IKIAkgIHN0cm9uZ2VyIHBhc3N3b3JkLWJhc2VkIGF1dGhlbnRpY2F0aW9uIHdpdGggV1BBMi1QZXJzb25hbAorCSogaW1wcm92ZWQgUDJQIG5lZ290aWF0aW9uIGFuZCBncm91cCBmb3JtYXRpb24gcm9idXN0bmVzcworCSAgLSBhdm9pZCB1bm5lY2Vzc2FyeSBEaWFsb2cgVG9rZW4gdmFsdWUgY2hhbmdlcyBkdXJpbmcgcmV0cmllcworCSAgLSBhdm9pZCBtb3JlIGNvbmN1cnJlbnQgc2Nhbm5pbmcgY2FzZXMgZHVyaW5nIGZ1bGwgZ3JvdXAgZm9ybWF0aW9uCisJICAgIHNlcXVlbmNlCisJICAtIGRvIG5vdCB1c2UgcG90ZW50aWFsbHkgb2Jzb2xldGUgc2NhbiByZXN1bHQgZGF0YSBmcm9tIGRyaXZlcgorCSAgICBjYWNoZSBmb3IgcGVlciBkaXNjb3ZlcnkvdXBkYXRlcworCSAgLSBhdm9pZCB1bmRlc2lyZWQgcmUtc3RhcnRpbmcgb2YgR08gbmVnb3RpYXRpb24gYmFzZWQgb24gUHJvYmUKKwkgICAgUmVxdWVzdCBmcmFtZXMKKwkgIC0gaW5jcmVhc2UgR08gTmVnb3RpYXRpb24gYW5kIEludml0YXRpb24gdGltZW91dHMgdG8gYWRkcmVzcyBidXN5CisJICAgIGVudmlyb25tZW50cyBhbmQgcGVlcnMgdGhhdCB0YWtlIGxvbmcgdGltZSB0byByZWFjdCB0byBtZXNzYWdlcywKKwkgICAgZS5nLiwgZHVlIHRvIHBvd2VyIHNhdmluZworCSAgLSBQMlAgRGV2aWNlIGludGVyZmFjZSB0eXBlCisJKiBpbXByb3ZlZCBQMlAgY2hhbm5lbCBzZWxlY3Rpb24gKHVzZSBtb3JlIHBlZXIgaW5mb3JtYXRpb24gYW5kIGFsbG93CisJICBtb3JlIGxvY2FsIG9wdGlvbnMpCisJKiBhZGRlZCBzdXBwb3J0IGZvciBvcHRpb25hbCBwZXItZGV2aWNlIFBTSyBhc3NpZ25tZW50IGJ5IFAyUCBHTworCSAgKHdwYV9jbGkgcDJwX3NldCBwZXJfc3RhX3BzayA8MC8xPikKKwkqIGFkZGVkIFAyUF9SRU1PVkVfQ0xJRU5UIGZvciByZW1vdmluZyBhIGNsaWVudCBmcm9tIFAyUCBncm91cHMKKwkgIChpbmNsdWRpbmcgcGVyc2lzdGVudCBncm91cHMpOyB0aGlzIGNhbiBiZSB1c2VkIHRvIHNlY3VyZWx5IHJlbW92ZQorCSAgYSBjbGllbnQgZnJvbSBhIGdyb3VwIGlmIHBlci1kZXZpY2UgUFNLcyBhcmUgdXNlZAorCSogYWRkZWQgbW9yZSBjb25maWd1cmF0aW9uIGZsZXhpYmlsaXR5IGZvciBhbGxvd2VkIFAyUCBHTy9jbGllbnQKKwkgIGNoYW5uZWxzIChwMnBfbm9fZ29fZnJlcSBsaXN0IGFuZCBwMnBfYWRkX2NsaV9jaGFuPTAvMSkKKwkqIGFkZGVkIG5sODAyMTEgZnVuY3Rpb25hbGl0eQorCSAgLSBWSFQgY29uZmlndXJhdGlvbiBmb3Igbmw4MDIxMQorCSAgLSBNRlAgKElFRUUgODAyLjExdykgaW5mb3JtYXRpb24gZm9yIG5sODAyMTEgY29tbWFuZCBBUEkKKwkgIC0gc3VwcG9ydCBzcGxpdCB3aXBoeSBkdW1wCisJICAtIEZUIChJRUVFIDgwMi4xMXIpIHdpdGggZHJpdmVyLWJhc2VkIFNNRQorCSAgLSB1c2UgYWR2ZXJ0aXNlZCBudW1iZXIgb2Ygc3VwcG9ydGVkIGNvbmN1cnJlbnQgY2hhbm5lbHMKKwkgIC0gUW9TIE1hcHBpbmcgY29uZmlndXJhdGlvbgorCSogaW1wcm92ZWQgVERMUyBuZWdvdGlhdGlvbiByb2J1c3RuZXNzCisJKiBhZGRlZCBtb3JlIFRETFMgcGVlciBwYXJhbWV0ZXJzIHRvIGJlIGNvbmZpZ3VyZWQgdG8gdGhlIGRyaXZlcgorCSogb3B0aW1pemVkIGNvbm5lY3Rpb24gdGltZSBieSBhbGxvd2luZyByZWNlbnRseSByZWNlaXZlZCBzY2FuIHJlc3VsdHMKKwkgIHRvIGJlIHVzZWQgaW5zdGVhZCBvZiBoYXZpbmcgdG8gcnVuIHRocm91Z2ggYSBuZXcgc2NhbgorCSogZml4ZWQgY3RybF9pZmFjZSBCU1MgY29tbWFuZCBpdGVyYXRpb24gd2l0aCBSQU5HRSBhcmd1bWVudCBhbmQgbm8KKwkgIGV4YWN0IG1hdGNoZXM7IGFsc28gZml4ZWQgYXJndW1lbnQgcGFyc2luZyBmb3Igc29tZSBjYXNlcyB3aXRoCisJICBtdWx0aXBsZSBhcmd1bWVudHMKKwkqIGFkZGVkICdTQ0FOIFRZUEU9T05MWScgY3RybF9pZmFjZSBjb21tYW5kIHRvIHJlcXVlc3QgbWFudWFsIHNjYW4KKwkgIHdpdGhvdXQgZXhlY3V0aW5nIHJvYW1pbmcvbmV0d29yayByZS1zZWxlY3Rpb24gb24gc2NhbiByZXN1bHRzCisJKiBhZGRlZCBTZXNzaW9uLUlkIGRlcml2YXRpb24gZm9yIEVBUCBwZWVyIG1ldGhvZHMKKwkqIGFkZGVkIGZ1bGx5IGF1dG9tYXRlZCByZWdyZXNzaW9uIHRlc3Rpbmcgd2l0aCBtYWM4MDIxMV9od3NpbQorCSogY2hhbmdlZCBjb25maWd1cmF0aW9uIHBhcnNlciB0byByZWplY3QgaW52YWxpZCBpbnRlZ2VyIHZhbHVlcworCSogYWxsb3cgQVAvRW5yb2xsZWUgdG8gYmUgc3BlY2lmaWVkIHdpdGggQlNTSUQgaW5zdGVhZCBvZiBVVUlEIGZvcgorCSAgV1BTIEVSIG9wZXJhdGlvbnMKKwkqIGRpc2FibGUgbmV0d29yayBibG9jayB0ZW1wb3JhcmlseSBvbiByZXBlYXRlZCBjb25uZWN0aW9uIGZhaWx1cmVzCisJKiBjaGFuZ2VkIHRoZSBkZWZhdWx0IGRyaXZlciBpbnRlcmZhY2UgZnJvbSB3ZXh0IHRvIG5sODAyMTEgaWYgYm90aCBhcmUKKwkgIGluY2x1ZGVkIGluIHRoZSBidWlsZAorCSogcmVtb3ZlIGR1cGxpY2F0ZSBuZXR3b3JrcyBpZiBXUFMgcHJvdmlzaW9uaW5nIGlzIHJ1biBtdWx0aXBsZSB0aW1lcworCSogcmVtb3ZlIGR1cGxpY2F0ZSBuZXR3b3JrcyB3aGVuIEludGVyd29ya2luZyBuZXR3b3JrIHNlbGVjdGlvbiB1c2VzIHRoZQorCSAgc2FtZSBuZXR3b3JrCisJKiBhZGRlZCBnbG9iYWwgZnJlcV9saXN0IGNvbmZpZ3VyYXRpb24gdG8gYWxsb3cgc2NhbiBmcmVxdWVuY2llcyB0byBiZQorCSAgbGltaXRlZCBmb3IgYWxsIGNhc2VzIGluc3RlYWQgb2YganVzdCBmb3IgYSBzcGVjaWZpYyBuZXR3b3JrIGJsb2NrCisJKiBhZGRlZCBzdXBwb3J0IGZvciBCU1MgVHJhbnNpdGlvbiBNYW5hZ2VtZW50CisJKiBhZGRlZCBvcHRpb24gdG8gdXNlICJJRk5BTUU9PGlmbmFtZT4gIiBwcmVmaXggdG8gdXNlIHRoZSBnbG9iYWwKKwkgIGNvbnRyb2wgaW50ZXJmYWNlIGNvbm5lY3Rpb24gdG8gcGVyZm9ybSBwZXItaW50ZXJmYWNlIGNvbW1hbmRzOworCSAgc2ltaWxhcmx5LCBhbGxvdyBnbG9iYWwgY29udHJvbCBpbnRlcmZhY2UgdG8gYmUgdXNlZCBhcyBhIG1vbml0b3IKKwkgIGludGVyZmFjZSB0byByZWNlaXZlIGV2ZW50cyBmcm9tIGFsbCBpbnRlcmZhY2VzCisJKiBmaXhlZCBPS0MtYmFzZWQgUE1LU0EgY2FjaGUgZW50cnkgY2xlYXJpbmcKKwkqIGZpeGVkIFRLSVAgZ3JvdXAga2V5IGNvbmZpZ3VyYXRpb24gd2l0aCBGVAorCSogYWRkZWQgc3VwcG9ydCBmb3IgdXNpbmcgT0NTUCBzdGFwbGluZyB0byB2YWxpZGF0ZSBzZXJ2ZXIgY2VydGlmaWNhdGUKKwkgIChvY3NwPTEgYXMgb3B0aW9uYWwgYW5kIG9jc3A9MiBhcyBtYW5kYXRvcnkpCisJKiBhZGRlZCBFQVAtRUtFIHBlZXIKKwkqIGFkZGVkIHBlZXIgcmVzdGFydCBkZXRlY3Rpb24gZm9yIElCU1MgUlNOCisJKiBhZGRlZCBkb21haW5fc3VmZml4X21hdGNoIChhbmQgZG9tYWluX3N1ZmZpeF9tYXRjaDIgZm9yIFBoYXNlIDIKKwkgIEVBUC1UTFMpIHRvIHNwZWNpZnkgYWRkaXRpb25hbCBjb25zdHJhaW50IGZvciB0aGUgc2VydmVyIGNlcnRpZmljYXRlCisJICBkb21haW4gbmFtZQorCSogYWRkZWQgc3VwcG9ydCBmb3IgZXh0ZXJuYWwgU0lNL1VTSU0gcHJvY2Vzc2luZyBpbiBFQVAtU0lNLCBFQVAtQUtBLAorCSAgYW5kIEVBUC1BS0EnIChDVFJMLVJFUS1TSU0gYW5kIENUUkwtUlNQLVNJTSBjb21tYW5kcyBvdmVyIGNvbnRyb2wKKwkgIGludGVyZmFjZSkKKwkqIGFkZGVkIGdsb2JhbCBiZ3NjYW4gY29uZmlndXJhdGlvbiBvcHRpb24gYXMgYSBkZWZhdWx0IGZvciBhbGwgbmV0d29yaworCSAgYmxvY2tzIHRoYXQgZG8gbm90IHNwZWNpZnkgdGhlaXIgb3duIGJnc2NhbiBwYXJhbWV0ZXJzCisJKiBhZGRlZCBELUJ1cyBtZXRob2RzIGZvciBURExTCisJKiBhZGRlZCBtb3JlIGNvbnRyb2wgdG8gc2NhbiByZXF1ZXN0cworCSAgLSAiU0NBTiBmcmVxPTxmcmVxIGxpc3Q+IiBjYW4gYmUgdXNlZCB0byBzcGVjaWZ5IHdoaWNoIGNoYW5uZWxzIGFyZQorCSAgICBzY2FubmVkIChjb21tYS1zZXBhcmF0ZWQgZnJlcXVlbmN5IHJhbmdlcyBpbiBNSHopCisJICAtICJTQ0FOIHBhc3NpdmU9MSIgY2FuIGJlIHVzZWQgdG8gcmVxdWVzdCBhIHBhc3NpdmUgc2NhbiAobm8gUHJvYmUKKwkgICAgUmVxdWVzdCBmcmFtZXMgYXJlIHNlbnQpCisJICAtICJTQ0FOIHVzZV9pZCIgY2FuIGJlIHVzZWQgdG8gcmVxdWVzdCBhIHNjYW4gaWQgdG8gYmUgcmV0dXJuZWQgYW5kCisJICAgIGluY2x1ZGVkIGluIGV2ZW50IG1lc3NhZ2VzIHJlbGF0ZWQgdG8gdGhpcyBzcGVjaWZpYyBzY2FuIG9wZXJhdGlvbgorCSAgLSAiU0NBTiBvbmx5X25ldz0xIiBjYW4gYmUgdXNlZCB0byByZXF1ZXN0IHRoZSBkcml2ZXIvY2ZnODAyMTEgdG8KKwkgICAgcmVwb3J0IG9ubHkgQlNTIGVudHJpZXMgdGhhdCBoYXZlIGJlZW4gdXBkYXRlZCBkdXJpbmcgdGhpcyBzY2FuCisJICAgIHJvdW5kCisJICAtIHRoZXNlIG9wdGlvbmFsIGFyZ3VtZW50cyB0byB0aGUgU0NBTiBjb21tYW5kIGNhbiBiZSBjb21iaW5lZCB3aXRoCisJICAgIGVhY2ggb3RoZXIKKwkqIG1vZGlmaWVkIGJlaGF2aW9yIG9uIGV4dGVybmFsbHkgdHJpZ2dlcmVkIHNjYW5zCisJICAtIGF2b2lkIGNvbmN1cnJlbnQgb3BlcmF0aW9ucyByZXF1aXJpbmcgZnVsbCBjb250cm9sIG9mIHRoZSByYWRpbyB3aGVuCisJICAgIGFuIGV4dGVybmFsbHkgdHJpZ2dlcmVkIHNjYW4gaXMgZGV0ZWN0ZWQKKwkgIC0gZG8gbm90IHVzZSByZXN1bHRzIGZvciBpbnRlcm5hbCByb2FtaW5nIGRlY2lzaW9uCisJKiBhZGRlZCBhIG5ldyBjcmVkIGJsb2NrIHBhcmFtZXRlciAndGVtcG9yYXJ5JyB0byBhbGxvdyBjcmVkZW50aWFsCisJICBibG9ja3MgdG8gYmUgc3RvcmVkIHNlcGFyYXRlbHkgZXZlbiBpZiB3cGFfc3VwcGxpY2FudCBjb25maWd1cmF0aW9uCisJICBmaWxlIGlzIHVzZWQgdG8gbWFpbnRhaW4gb3RoZXIgbmV0d29yayBpbmZvcm1hdGlvbgorCSogYWRkZWQgInJhZGlvIHdvcmsiIGZyYW1ld29yayB0byBzY2hlZHVsZSBleGNsdXNpdmUgcmFkaW8gb3BlcmF0aW9ucworCSAgZm9yIG9mZi1jaGFubmVsIGZ1bmN0aW9uYWxpdHkKKwkgIC0gcmVkdWNlIGlzc3VlcyB3aXRoIGNvbmN1cnJlbnQgb3BlcmF0aW9ucyB0aGF0IHRyeSB0byBjb250cm9sIHdoaWNoCisJICAgIGNoYW5uZWwgaXMgdXNlZAorCSAgLSBhbGxvdyBleHRlcm5hbCBwcm9ncmFtcyB0byByZXF1ZXN0IGV4Y2x1c2l2ZSByYWRpbyBjb250cm9sIGluIGEgd2F5CisJICAgIHRoYXQgYXZvaWRzIGNvbmZsaWN0cyB3aXRoIHdwYV9zdXBwbGljYW50CisJKiBhZGRlZCBzdXBwb3J0IGZvciB1c2luZyBQcm90ZWN0ZWQgRHVhbCBvZiBQdWJsaWMgQWN0aW9uIGZyYW1lcyBmb3IKKwkgIEdBUy9BTlFQIGV4Y2hhbmdlcyB3aGVuIGFzc29jaWF0ZWQgd2l0aCBQTUYKKwkqIGFkZGVkIHN1cHBvcnQgZm9yIFdQUytORkMgdXBkYXRlcyBhbmQgUDJQK05GQworCSAgLSBpbXByb3ZlZCBwcm90b2NvbCBmb3IgV1BTCisJICAtIFAyUCBncm91cCBmb3JtYXRpb24vam9pbiBiYXNlZCBvbiBORkMgY29ubmVjdGlvbiBoYW5kb3ZlcgorCSAgLSBuZXcgSVB2NCBhZGRyZXNzIGFzc2lnbm1lbnQgZm9yIFAyUCBncm91cHMgKGlwX2FkZHJfKiBjb25maWd1cmF0aW9uCisJICAgIHBhcmFtZXRlcnMgb24gdGhlIEdPKSB0byByZXBsYWNlIERIQ1AKKwkgIC0gb3B0aW9uIHRvIGZldGNoIGFuZCByZXBvcnQgYWx0ZXJuYXRpdmUgY2FycmllciByZWNvcmRzIGZvciBleHRlcm5hbAorCSAgICBORkMgb3BlcmF0aW9ucworCSogdmFyaW91cyBidWcgZml4ZXMKIAogMjAxMy0wMS0xMiAtIHYyLjAKIAkqIHJlbW92ZWQgUXQzLWJhc2VkIHdwYV9ndWkgKG9ic29sZXRlZCBieSB3cGFfcXVpLXF0NCkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L01ha2VmaWxlIGIvd3BhX3N1cHBsaWNhbnQvTWFrZWZpbGUKaW5kZXggNTY5ODYxOS4uOGY3YzIzZiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvTWFrZWZpbGUKKysrIGIvd3BhX3N1cHBsaWNhbnQvTWFrZWZpbGUKQEAgLTEwLDExICsxMCwxNyBAQAogZXhwb3J0IEJJTkRJUiA/PSAvdXNyL2xvY2FsL3NiaW4vCiBQS0dfQ09ORklHID89IHBrZy1jb25maWcKIAotQ0ZMQUdTICs9IC1JLi4vc3JjCi1DRkxBR1MgKz0gLUkuLi9zcmMvdXRpbHMKK0NGTEFHUyArPSAtSSQoYWJzcGF0aCAuLi9zcmMpCitDRkxBR1MgKz0gLUkkKGFic3BhdGggLi4vc3JjL3V0aWxzKQogCiAtaW5jbHVkZSAuY29uZmlnCiAKK2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKK0NGTEFHUyArPSAtRENPTkZJR19URVNUSU5HX09QVElPTlMKK0NPTkZJR19XUFNfVEVTVElORz15CitDT05GSUdfVERMU19URVNUSU5HPXkKK2VuZGlmCisKIEJJTkFMTD13cGFfc3VwcGxpY2FudCB3cGFfY2xpCiAKIGlmbmRlZiBDT05GSUdfTk9fV1BBX1BBU1NQSFJBU0UKQEAgLTEwMCwxMCArMTA2LDEwIEBACiBMREZMQUdTICs9IC1yZHluYW1pYwogQ0ZMQUdTICs9IC1mdW53aW5kLXRhYmxlcwogaWZkZWYgQ09ORklHX1dQQV9UUkFDRV9CRkQKLUNGTEFHUyArPSAtRFdQQV9UUkFDRV9CRkQKLUxJQlMgKz0gLWxiZmQKLUxJQlNfcCArPSAtbGJmZAotTElCU19jICs9IC1sYmZkCitDRkxBR1MgKz0gLURQQUNLQUdFPSJ3cGFfc3VwcGxpY2FudCIgLURXUEFfVFJBQ0VfQkZECitMSUJTICs9IC1sYmZkIC1sZGwgLWxpYmVydHkgLWx6CitMSUJTX3AgKz0gLWxiZmQgLWxkbCAtbGliZXJ0eSAtbHoKK0xJQlNfYyArPSAtbGJmZCAtbGRsIC1saWJlcnR5IC1segogZW5kaWYKIGVuZGlmCiAKQEAgLTExMywxNSArMTE5LDMyIEBACiBPQkpTICs9IC4uL3NyYy91dGlscy8kKENPTkZJR19FTE9PUCkubwogT0JKU19jICs9IC4uL3NyYy91dGlscy8kKENPTkZJR19FTE9PUCkubwogCitpZmVxICgkKENPTkZJR19FTE9PUCksIGVsb29wKQorIyBVc2luZyBnbGliYyA8IDIuMTcgcmVxdWlyZXMgLWxydCBmb3IgY2xvY2tfZ2V0dGltZSgpCitMSUJTICs9IC1scnQKK0xJQlNfYyArPSAtbHJ0CitMSUJTX3AgKz0gLWxydAorZW5kaWYKKwogaWZkZWYgQ09ORklHX0VMT09QX1BPTEwKIENGTEFHUyArPSAtRENPTkZJR19FTE9PUF9QT0xMCiBlbmRpZgogCitpZmRlZiBDT05GSUdfRUxPT1BfRVBPTEwKK0NGTEFHUyArPSAtRENPTkZJR19FTE9PUF9FUE9MTAorZW5kaWYKIAogaWZkZWYgQ09ORklHX0VBUE9MX1RFU1QKIENGTEFHUyArPSAtV2Vycm9yIC1ERUFQT0xfVEVTVAogZW5kaWYKIAoraWZkZWYgQ09ORklHX0NPREVfQ09WRVJBR0UKK0NGTEFHUyArPSAtTzAgLWZwcm9maWxlLWFyY3MgLWZ0ZXN0LWNvdmVyYWdlCitMSUJTICs9IC1sZ2NvdgorTElCU19jICs9IC1sZ2NvdgorTElCU19wICs9IC1sZ2NvdgorZW5kaWYKKwogaWZkZWYgQ09ORklHX0hUX09WRVJSSURFUwogQ0ZMQUdTICs9IC1EQ09ORklHX0hUX09WRVJSSURFUwogZW5kaWYKQEAgLTIzNyw2ICsyNjAsNyBAQAogT0JKUyArPSAuLi9zcmMvcDJwL3AycF9kZXZfZGlzYy5vCiBPQkpTICs9IC4uL3NyYy9wMnAvcDJwX2dyb3VwLm8KIE9CSlMgKz0gLi4vc3JjL2FwL3AycF9ob3N0YXBkLm8KK09CSlMgKz0gLi4vc3JjL3V0aWxzL2JpdGZpZWxkLm8KIENGTEFHUyArPSAtRENPTkZJR19QMlAKIE5FRURfR0FTPXkKIE5FRURfT0ZGQ0hBTk5FTD15CkBAIC0yNTcsNiArMjgxLDcgQEAKIE9CSlMgKz0gaHMyMF9zdXBwbGljYW50Lm8KIENGTEFHUyArPSAtRENPTkZJR19IUzIwCiBDT05GSUdfSU5URVJXT1JLSU5HPXkKK05FRURfQUVTX09NQUMxPXkKIGVuZGlmCiAKIGlmZGVmIENPTkZJR19JTlRFUldPUktJTkcKQEAgLTQ4NSw3ICs1MTAsNyBAQAogaWZkZWYgQ09ORklHX0VBUF9QUk9YWQogQ0ZMQUdTICs9IC1EQ09ORklHX0VBUF9QUk9YWQogT0JKUyArPSAuLi9zcmMvZWFwX3BlZXIvZWFwX3Byb3h5XyQoQ09ORklHX0VBUF9QUk9YWSkubwotaW5jbHVkZSBlYXBfcHJveHlfJChDT05GSUdfRUFQX1BST1hZKS5taworaW5jbHVkZSBlYXBfcHJveHlfJChDT05GSUdfRUFQX1BST1hZKS5tYWsKIENPTkZJR19JRUVFODAyMVhfRUFQT0w9eQogZW5kaWYKIApAQCAtNTkyLDEwICs2MTcsNiBAQAogZW5kaWYKIAogaWZkZWYgQ09ORklHX1dQUwotaWZkZWYgQ09ORklHX1dQUzIKLUNGTEFHUyArPSAtRENPTkZJR19XUFMyCi1lbmRpZgotCiAjIEVBUC1XU0MKIENGTEFHUyArPSAtRENPTkZJR19XUFMgLURFQVBfV1NDCiBPQkpTICs9IHdwc19zdXBwbGljYW50Lm8KQEAgLTcyMiw2ICs3NDMsMTkgQEAKIGVuZGlmCiBlbmRpZgogCitpZmRlZiBDT05GSUdfTUFDU0VDCitDRkxBR1MgKz0gLURDT05GSUdfTUFDU0VDCitORUVEX0FFU19FTkNCTE9DSz15CitORUVEX0FFU19VTldSQVA9eQorTkVFRF9BRVNfV1JBUD15CitORUVEX0FFU19PTUFDMT15CitPQkpTICs9IHdwYXNfa2F5Lm8KK09CSlMgKz0gLi4vc3JjL3BhZS9pZWVlODAyXzF4X2NwLm8KK09CSlMgKz0gLi4vc3JjL3BhZS9pZWVlODAyXzF4X2theS5vCitPQkpTICs9IC4uL3NyYy9wYWUvaWVlZTgwMl8xeF9rZXkubworT0JKUyArPSAuLi9zcmMvcGFlL2llZWU4MDJfMXhfc2VjeV9vcHMubworZW5kaWYKKwogaWZkZWYgQ09ORklHX0FQCiBORUVEXzgwMjExX0NPTU1PTj15CiBORUVEX0VBUF9DT01NT049eQpAQCAtNzUwLDYgKzc4NCw5IEBACiBPQkpTICs9IC4uL3NyYy9hcC9lYXBfdXNlcl9kYi5vCiBpZmRlZiBDT05GSUdfSUVFRTgwMjExTgogT0JKUyArPSAuLi9zcmMvYXAvaWVlZTgwMl8xMV9odC5vCitpZmRlZiBDT05GSUdfSUVFRTgwMjExQUMKK09CSlMgKz0gLi4vc3JjL2FwL2llZWU4MDJfMTFfdmh0Lm8KK2VuZGlmCiBlbmRpZgogaWZkZWYgQ09ORklHX1dOTQogT0JKUyArPSAuLi9zcmMvYXAvd25tX2FwLm8KQEAgLTc2NSw2ICs4MDIsOSBAQAogCiBpZmRlZiBDT05GSUdfSUVFRTgwMjExTgogQ0ZMQUdTICs9IC1EQ09ORklHX0lFRUU4MDIxMU4KK2lmZGVmIENPTkZJR19JRUVFODAyMTFBQworQ0ZMQUdTICs9IC1EQ09ORklHX0lFRUU4MDIxMUFDCitlbmRpZgogZW5kaWYKIAogaWZkZWYgTkVFRF9BUF9NTE1FCkBAIC03NzIsNiArODEyLDcgQEAKIE9CSlMgKz0gLi4vc3JjL2FwL2FwX2xpc3QubwogT0JKUyArPSAuLi9zcmMvYXAvaWVlZTgwMl8xMS5vCiBPQkpTICs9IC4uL3NyYy9hcC9od19mZWF0dXJlcy5vCitPQkpTICs9IC4uL3NyYy9hcC9kZnMubwogQ0ZMQUdTICs9IC1ETkVFRF9BUF9NTE1FCiBlbmRpZgogaWZkZWYgQ09ORklHX1dQUwpAQCAtOTMwLDcgKzk3MSw4IEBACiBPQkpTICs9IC4uL3NyYy9jcnlwdG8vY3J5cHRvX2dudXRscy5vCiBPQkpTX3AgKz0gLi4vc3JjL2NyeXB0by9jcnlwdG9fZ251dGxzLm8KIGlmZGVmIE5FRURfRklQUzE4Nl8yX1BSRgotT0JKUyArPSAuLi9zcmMvY3J5cHRvL2ZpcHNfcHJmX2dudXRscy5vCitPQkpTICs9IC4uL3NyYy9jcnlwdG8vZmlwc19wcmZfaW50ZXJuYWwubworU0hBMU9CSlMgKz0gLi4vc3JjL2NyeXB0by9zaGExLWludGVybmFsLm8KIGVuZGlmCiBMSUJTICs9IC1sZ2NyeXB0CiBMSUJTX3AgKz0gLWxnY3J5cHQKQEAgLTk0Niw3ICs5ODgsOCBAQAogT0JKUyArPSAuLi9zcmMvY3J5cHRvL2NyeXB0b19jcnlwdG9hcGkubwogT0JKU19wICs9IC4uL3NyYy9jcnlwdG8vY3J5cHRvX2NyeXB0b2FwaS5vCiBpZmRlZiBORUVEX0ZJUFMxODZfMl9QUkYKLU9CSlMgKz0gLi4vc3JjL2NyeXB0by9maXBzX3ByZl9jcnlwdG9hcGkubworT0JKUyArPSAuLi9zcmMvY3J5cHRvL2ZpcHNfcHJmX2ludGVybmFsLm8KK1NIQTFPQkpTICs9IC4uL3NyYy9jcnlwdG8vc2hhMS1pbnRlcm5hbC5vCiBlbmRpZgogQ09ORklHX0lOVEVSTkFMX1NIQTI1Nj15CiBDT05GSUdfSU5URVJOQUxfUkM0PXkKQEAgLTk2MSw3ICsxMDA0LDggQEAKIE9CSlMgKz0gLi4vc3JjL2NyeXB0by9jcnlwdG9fbnNzLm8KIE9CSlNfcCArPSAuLi9zcmMvY3J5cHRvL2NyeXB0b19uc3MubwogaWZkZWYgTkVFRF9GSVBTMTg2XzJfUFJGCi1PQkpTICs9IC4uL3NyYy9jcnlwdG8vZmlwc19wcmZfbnNzLm8KK09CSlMgKz0gLi4vc3JjL2NyeXB0by9maXBzX3ByZl9pbnRlcm5hbC5vCitTSEExT0JKUyArPSAuLi9zcmMvY3J5cHRvL3NoYTEtaW50ZXJuYWwubwogZW5kaWYKIExJQlMgKz0gLWxuc3MzCiBMSUJTX3AgKz0gLWxuc3MzCkBAIC0xMjMxLDYgKzEyNzUsMTEgQEAKIGlmZXEgKCQoQ09ORklHX0NUUkxfSUZBQ0UpLCB1ZHApCiBDRkxBR1MgKz0gLURDT05GSUdfQ1RSTF9JRkFDRV9VRFAKIGVuZGlmCitpZmVxICgkKENPTkZJR19DVFJMX0lGQUNFKSwgdWRwNikKK0NPTkZJR19DVFJMX0lGQUNFPXVkcAorQ0ZMQUdTICs9IC1EQ09ORklHX0NUUkxfSUZBQ0VfVURQCitDRkxBR1MgKz0gLURDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNgorZW5kaWYKIGlmZXEgKCQoQ09ORklHX0NUUkxfSUZBQ0UpLCBuYW1lZF9waXBlKQogQ0ZMQUdTICs9IC1EQ09ORklHX0NUUkxfSUZBQ0VfTkFNRURfUElQRQogZW5kaWYKQEAgLTEyMzksNiArMTI4OCwxMiBAQAogQ0ZMQUdTICs9IC1EQ09ORklHX0NUUkxfSUZBQ0VfVURQCiBDRkxBR1MgKz0gLURDT05GSUdfQ1RSTF9JRkFDRV9VRFBfUkVNT1RFCiBlbmRpZgoraWZlcSAoJChDT05GSUdfQ1RSTF9JRkFDRSksIHVkcDYtcmVtb3RlKQorQ09ORklHX0NUUkxfSUZBQ0U9dWRwCitDRkxBR1MgKz0gLURDT05GSUdfQ1RSTF9JRkFDRV9VRFAKK0NGTEFHUyArPSAtRENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUKK0NGTEFHUyArPSAtRENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CitlbmRpZgogT0JKUyArPSBjdHJsX2lmYWNlLm8gY3RybF9pZmFjZV8kKENPTkZJR19DVFJMX0lGQUNFKS5vCiBlbmRpZgogCkBAIC0xNDM2LDYgKzE0OTEsMTkgQEAKIENGTEFHUyArPSAtRENPTkZJR19PRkZDSEFOTkVMCiBlbmRpZgogCitpZmRlZiBDT05GSUdfTU9EVUxFX1RFU1RTCitDRkxBR1MgKz0gLURDT05GSUdfTU9EVUxFX1RFU1RTCitPQkpTICs9IHdwYXNfbW9kdWxlX3Rlc3RzLm8KK09CSlMgKz0gLi4vc3JjL3V0aWxzL3V0aWxzX21vZHVsZV90ZXN0cy5vCitPQkpTICs9IC4uL3NyYy9jb21tb24vY29tbW9uX21vZHVsZV90ZXN0cy5vCitpZmRlZiBDT05GSUdfV1BTCitPQkpTICs9IC4uL3NyYy93cHMvd3BzX21vZHVsZV90ZXN0cy5vCitlbmRpZgoraWZuZGVmIENPTkZJR19QMlAKK09CSlMgKz0gLi4vc3JjL3V0aWxzL2JpdGZpZWxkLm8KK2VuZGlmCitlbmRpZgorCiBPQkpTICs9IC4uL3NyYy9kcml2ZXJzL2RyaXZlcl9jb21tb24ubwogT0JKU19wcml2ICs9IC4uL3NyYy9kcml2ZXJzL2RyaXZlcl9jb21tb24ubwogCkBAIC0xNjAxLDkgKzE2NjksMTUgQEAKIAkkKENDKSAkKExERkxBR1MpIC1vICRAICQoQ0ZMQUdTKSAtc2hhcmVkIC1yZHluYW1pYyAtZlBJQyAkPCBcCiAJCS1EJCgqRjplYXBfJT1lYXBfcGVlcl8lKV9yZWdpc3Rlcj1lYXBfcGVlcl9tZXRob2RfZHluYW1pY19pbml0CiAKK2lmZGVmIENPTkZJR19DT0RFX0NPVkVSQUdFCislLm86ICUuYworCUAkKEUpICIgIENDICIgJDwKKwkkKFEpY2QgJChkaXIgJEApOyAkKENDKSAtYyAtbyAkKG5vdGRpciAkQCkgJChDRkxBR1MpICQobm90ZGlyICQ8KQorZWxzZQogJS5vOiAlLmMKIAkkKFEpJChDQykgLWMgLW8gJEAgJChDRkxBR1MpICQ8CiAJQCQoRSkgIiAgQ0MgIiAkPAorZW5kaWYKIAogJS5zZXJ2aWNlOiAlLnNlcnZpY2UuaW4KIAlzZWQgLWUgJ3N8XEBCSU5ESVJcQHwkKEJJTkRJUil8ZycgJDwgPiRACkBAIC0xNjU1LDExICsxNzI5LDE4IEBACiBmaXBzOgogCSQoTUFLRSkgQ0M9JChGSVBTTEQpIEZJUFNMRF9DQz0iJChDQykiCiAKK2xjb3YtaHRtbDogd3BhX3N1cHBsaWNhbnQuZ2NkYQorCWxjb3YgLWMgLWQgLi4gPiBsY292LmluZm8KKwlnZW5odG1sIGxjb3YuaW5mbyAtLW91dHB1dC1kaXJlY3RvcnkgbGNvdi1odG1sCisKIGNsZWFuOgogCSQoTUFLRSkgLUMgLi4vc3JjIGNsZWFuCiAJJChNQUtFKSAtQyBkYnVzIGNsZWFuCi0Jcm0gLWYgY29yZSAqfiAqLm8gKi5kIGVhcF8qLnNvICQoQUxMKSAkKFdJTkFMTCkgZWFwb2xfdGVzdCBwcmVhdXRoX3Rlc3QKKwlybSAtZiBjb3JlICp+ICoubyAqLmQgKi5nY25vICouZ2NkYSAqLmdjb3YKKwlybSAtZiBlYXBfKi5zbyAkKEFMTCkgJChXSU5BTEwpIGVhcG9sX3Rlc3QgcHJlYXV0aF90ZXN0CiAJcm0gLWYgd3BhX3ByaXYKIAlybSAtZiBuZmNfcHdfdG9rZW4KKwlybSAtZiBsY292LmluZm8KKwlybSAtcmYgbGNvdi1odG1sCiAKIC1pbmNsdWRlICQoT0JKUzolLm89JS5kKQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvUkVBRE1FIGIvd3BhX3N1cHBsaWNhbnQvUkVBRE1FCmluZGV4IDc4ZGY4OWUuLjY1Mzg0OGUgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L1JFQURNRQorKysgYi93cGFfc3VwcGxpY2FudC9SRUFETUUKQEAgLTEsNyArMSw3IEBACiBXUEEgU3VwcGxpY2FudAogPT09PT09PT09PT09PT0KIAotQ29weXJpZ2h0IChjKSAyMDAzLTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+IGFuZCBjb250cmlidXRvcnMKK0NvcHlyaWdodCAoYykgMjAwMy0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPiBhbmQgY29udHJpYnV0b3JzCiBBbGwgUmlnaHRzIFJlc2VydmVkLgogCiBUaGlzIHByb2dyYW0gaXMgbGljZW5zZWQgdW5kZXIgdGhlIEJTRCBsaWNlbnNlICh0aGUgb25lIHdpdGgKQEAgLTQxMyw3ICs0MTMsNyBAQAogICAgICAgICBbLUc8Z3JvdXA+XSBcCiAgICAgICAgIC1pPGlmbmFtZT4gLWM8Y29uZmlnIGZpbGU+IFstQzxjdHJsPl0gWy1EPGRyaXZlcj5dIFstcDxkcml2ZXJfcGFyYW0+XSBcCiAgICAgICAgIFstYjxicl9pZm5hbWU+IFstTiAtaTxpZm5hbWU+IC1jPGNvbmY+IFstQzxjdHJsPl0gWy1EPGRyaXZlcj5dIFwKLSAgICAgICAgWy1wPGRyaXZlcl9wYXJhbT5dIFstYjxicl9pZm5hbWU+XSAuLi5dCisgICAgICAgIFstcDxkcml2ZXJfcGFyYW0+XSBbLWI8YnJfaWZuYW1lPl0gWy1tPFAyUCBEZXZpY2UgY29uZmlnIGZpbGU+XSAuLi4KIAogb3B0aW9uczoKICAgLWIgPSBvcHRpb25hbCBicmlkZ2UgaW50ZXJmYWNlIG5hbWUKQEAgLTQzOCw2ICs0MzgsNyBAQAogICAtdyA9IHdhaXQgZm9yIGludGVyZmFjZSB0byBiZSBhZGRlZCwgaWYgbmVlZGVkCiAgIC1XID0gd2FpdCBmb3IgYSBjb250cm9sIGludGVyZmFjZSBtb25pdG9yIGJlZm9yZSBzdGFydGluZwogICAtTiA9IHN0YXJ0IGRlc2NyaWJpbmcgbmV3IGludGVyZmFjZQorICAtbSA9IENvbmZpZ3VyYXRpb24gZmlsZSBmb3IgdGhlIFAyUCBEZXZpY2UKIAogZHJpdmVyczoKICAgbmw4MDIxMSA9IExpbnV4IG5sODAyMTEvY2ZnODAyMTEKQEAgLTk0OSwzICs5NTAsMTA1IEBACiB3cGFfcHJpdiBjYW4gY29udHJvbCBtdWx0aXBsZSBpbnRlcmZhY2Ugd2l0aCBvbmUgcHJvY2VzcywgYnV0IGl0IGlzCiBhbHNvIHBvc3NpYmxlIHRvIHJ1biBtdWx0aXBsZSB3cGFfcHJpdiBwcm9jZXNzZXMgYXQgdGhlIHNhbWUgdGltZSwgaWYKIGRlc2lyZWQuCisKKworTGludXggY2FwYWJpbGl0aWVzIGluc3RlYWQgb2YgcHJpdmlsZWdlZCBwcm9jZXNzCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKword3BhX3N1cHBsaWNhbnQgcGVyZm9ybXMgb3BlcmF0aW9ucyB0aGF0IG5lZWQgc3BlY2lhbCBwZXJtaXNzaW9ucywgZS5nLiwKK3RvIGNvbnRyb2wgdGhlIG5ldHdvcmsgY29ubmVjdGlvbi4gVHJhZGl0aW9uYWxseSB0aGlzIGhhcyBiZWVuIGFjaGlldmVkCitieSBydW5uaW5nIHdwYV9zdXBwbGljYW50IGFzIGEgcHJpdmlsZWdlZCBwcm9jZXNzIHdpdGggZWZmZWN0aXZlIHVzZXIgaWQKKzAgKHJvb3QpLiBMaW51eCBjYXBhYmlsaXRpZXMgY2FuIGJlIHVzZWQgdG8gcHJvdmlkZSByZXN0cmljdGVkIHNldCBvZgorY2FwYWJpbGl0aWVzIHRvIG1hdGNoIHRoZSBmdW5jdGlvbnMgbmVlZGVkIGJ5IHdwYV9zdXBwbGljYW50LiBUaGUKK21pbmltdW0gc2V0IG9mIGNhcGFiaWxpdGllcyBuZWVkZWQgZm9yIHRoZSBvcGVyYXRpb25zIGlzIENBUF9ORVRfQURNSU4KK2FuZCBDQVBfTkVUX1JBVy4KKworc2V0Y2FwKDgpIGNhbiBiZSB1c2VkIHRvIHNldCBmaWxlIGNhcGFiaWxpdGllcy4gRm9yIGV4YW1wbGU6CisKK3N1ZG8gc2V0Y2FwIGNhcF9uZXRfcmF3LGNhcF9uZXRfYWRtaW4rZXAgd3BhX3N1cHBsaWNhbnQKKworUGxlYXNlIG5vdGUgdGhhdCB0aGlzIHdvdWxkIGdpdmUgYW55b25lIGJlaW5nIGFibGUgdG8gcnVuIHRoYXQKK3dwYV9zdXBwbGljYW50IGJpbmFyeSBhY2Nlc3MgdG8gdGhlIGFkZGl0aW9uYWwgY2FwYWJpbGl0aWVzLiBUaGlzIGNhbgorZnVydGhlciBiZSBsaW1pdGVkIGJ5IGZpbGUgb3duZXIvZ3JvdXAgYW5kIG1vZGUgYml0cy4gRm9yIGV4YW1wbGU6CisKK3N1ZG8gY2hvd24gd3BhcyB3cGFfc3VwcGxpY2FudAorc3VkbyBjaG1vZCAwMTAwIHdwYV9zdXBwbGljYW50CisKK1RoaXMgY29tYmluYXRpb24gb2Ygc2V0Y2FwLCBjaG93biwgYW5kIGNobW9kIGNvbW1hbmRzIHdvdWxkIGFsbG93IHdwYXMKK3VzZXIgdG8gZXhlY3V0ZSB3cGFfc3VwcGxpY2FudCB3aXRoIGFkZGl0aW9uYWwgbmV0d29yayBhZG1pbi9yYXcKK2NhcGFiaWxpdGllcy4KKworQ29tbW9uIHdheSBzdHlsZSBvZiBjcmVhdGluZyBhIGNvbnRyb2wgaW50ZXJmYWNlIHNvY2tldCBpbgorL3Zhci9ydW4vd3BhX3N1cHBsaWNhbnQgY291bGQgbm90IGJlIGRvbmUgYnkgdGhpcyB1c2VyLCBidXQgdGhpcworZGlyZWN0b3J5IGNvdWxkIGJlIGNyZWF0ZWQgYmVmb3JlIHN0YXJ0aW5nIHRoZSB3cGFfc3VwcGxpY2FudCBhbmQgc2V0IHRvCitzdWl0YWJsZSBtb2RlIHRvIGFsbG93IHdwYV9zdXBwbGljYW50IHRvIGNyZWF0ZSBzb2NrZXRzCit0aGVyZS4gQWx0ZXJuYXRpdmVseSwgb3RoZXIgZGlyZWN0b3J5IG9yIGFic3RyYWN0IHNvY2tldCBuYW1lc3BhY2UgY291bGQKK2JlIHVzZWQgZm9yIHRoZSBjb250cm9sIGludGVyZmFjZS4KKworCitFeHRlcm5hbCByZXF1ZXN0cyBmb3IgcmFkaW8gY29udHJvbAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworRXh0ZXJuYWwgcHJvZ3JhbXMgY2FuIHJlcXVlc3Qgd3BhX3N1cHBsaWNhbnQgdG8gbm90IHN0YXJ0IG9mZmNoYW5uZWwKK29wZXJhdGlvbnMgZHVyaW5nIG90aGVyIHRhc2tzIHRoYXQgbWF5IG5lZWQgZXhjbHVzaXZlIGNvbnRyb2wgb2YgdGhlCityYWRpby4gVGhlIFJBRElPX1dPUksgY29udHJvbCBpbnRlcmZhY2UgY29tbWFuZCBjYW4gYmUgdXNlZCBmb3IgdGhpcy4KKworIlJBRElPX1dPUksgYWRkIDxuYW1lPiBbZnJlcT08TUh6Pl0gW3RpbWVvdXQ9PHNlY29uZHM+XSIgY29tbWFuZCBjYW4gYmUKK3VzZWQgdG8gcmVzZXJ2ZSBhIHNsb3QgZm9yIHJhZGlvIGFjY2Vzcy4gSWYgZnJlcSBpcyBzcGVjaWZpZWQsIG90aGVyCityYWRpbyB3b3JrIGl0ZW1zIG9uIHRoZSBzYW1lIGNoYW5uZWwgbWF5IGJlIGNvbXBsZXRlZCBpbgorcGFyYWxsZWwuIE90aGVyd2lzZSwgYWxsIG90aGVyIHJhZGlvIHdvcmsgaXRlbXMgYXJlIGJsb2NrZWQgZHVyaW5nCitleGVjdXRpb24uIFRpbWVvdXQgaXMgc2V0IHRvIDEwIHNlY29uZHMgYnkgZGVmYXVsdCB0byBhdm9pZCBibG9ja2luZword3BhX3N1cHBsaWNhbnQgb3BlcmF0aW9ucyBmb3IgZXhjZXNzaXZlIHRpbWUuIElmIGEgbG9uZ2VyIChvciBzaG9ydGVyKQorc2FmZXR5IHRpbWVvdXQgaXMgbmVlZGVkLCB0aGF0IGNhbiBiZSBzcGVjaWZpZWQgd2l0aCB0aGUgb3B0aW9uYWwKK3RpbWVvdXQgcGFyYW1ldGVyLiBUaGlzIGNvbW1hbmQgcmV0dXJucyBhbiBpZGVudGlmaWVyIGZvciB0aGUgcmFkaW8gd29yaworaXRlbS4KKworT25jZSB0aGUgcmFkaW8gd29yayBpdGVtIGhhcyBiZWVuIHN0YXJ0ZWQsICJFWFQtUkFESU8tV09SSy1TVEFSVCA8aWQ+IgorZXZlbnQgbWVzc2FnZSBpcyBpbmRpY2F0ZWQgdGhhdCB0aGUgZXh0ZXJuYWwgcHJvY2Vzc2luZyBjYW4gc3RhcnQuIE9uY2UKK3RoZSBvcGVyYXRpb24gaGFzIGJlZW4gY29tcGxldGVkLCAiUkFESU9fV09SSyBkb25lIDxpZD4iIGlzIHVzZWQgdG8KK2luZGljYXRlIHRoYXQgdG8gd3BhX3N1cHBsaWNhbnQuIFRoaXMgYWxsb3dzIG90aGVyIHJhZGlvIHdvcmtzIHRvIGJlCitwZXJmb3JtZWQuIElmIHRoaXMgY29tbWFuZCBpcyBmb3Jnb3R0ZW4gKGUuZy4sIGR1ZSB0byB0aGUgZXh0ZXJuYWwKK3Byb2dyYW0gdGVybWluYXRpbmcpLCB3cGFfc3VwcGxpY2FudCB3aWxsIHRpbWUgb3V0IHRoZSByYWRpbyBvd3JrIGl0ZW0KK2FuZCBzZW5kICJFWFQtUkFESU8tV09SSy1USU1FT1VUIDxpZD4iIGV2ZW50IG90IGluZGljYXRlIHRoYXQgdGhpcyBoYXMKK2hhcHBlbmVkLiAiUkFESU9fV09SSyBkb25lIDxpZD4iIGNhbiBhbHNvIGJlIHVzZWQgdG8gY2FuY2VsIGl0ZW1zIHRoYXQKK2hhdmUgbm90IHlldCBiZWVuIHN0YXJ0ZWQuCisKK0ZvciBleGFtcGxlLCBpbiB3cGFfY2xpIGludGVyYWN0aXZlIG1vZGU6CisKKz4gcmFkaW9fd29yayBhZGQgdGVzdAorMQorPDM+RVhULVJBRElPLVdPUkstU1RBUlQgMQorPiByYWRpb193b3JrIHNob3cKK2V4dDp0ZXN0QHdsYW4wOjA6MToyLjQ4Nzc5NworPiByYWRpb193b3JrIGRvbmUgMQorT0sKKz4gcmFkaW9fd29yayBzaG93CisKKworPiByYWRpb193b3JrIGRvbmUgMworT0sKKz4gcmFkaW9fd29yayBzaG93CitleHQ6dGVzdCBmcmVxPTI0MTIgdGltZW91dD0zMEB3bGFuMDoyNDEyOjE6MjguNTgzNDgzCis8Mz5FWFQtUkFESU8tV09SSy1USU1FT1VUIDIKKworCis+IHJhZGlvX3dvcmsgYWRkIHRlc3QyIGZyZXE9MjQxMiB0aW1lb3V0PTYwCis1Cis8Mz5FWFQtUkFESU8tV09SSy1TVEFSVCA1Cis+IHJhZGlvX3dvcmsgYWRkIHRlc3QzCis2Cis+IHJhZGlvX3dvcmsgYWRkIHRlc3Q0Cis3Cis+IHJhZGlvX3dvcmsgc2hvdworZXh0OnRlc3QyIGZyZXE9MjQxMiB0aW1lb3V0PTYwQHdsYW4wOjI0MTI6MTo5Ljc1MTg0NAorZXh0OnRlc3QzQHdsYW4wOjA6MDo1LjA3MTgxMgorZXh0OnRlc3Q0QHdsYW4wOjA6MDozLjE0Mzg3MAorPiByYWRpb193b3JrIGRvbmUgNgorT0sKKz4gcmFkaW9fd29yayBzaG93CitleHQ6dGVzdDIgZnJlcT0yNDEyIHRpbWVvdXQ9NjBAd2xhbjA6MjQxMjoxOjE2LjI4Nzg2OQorZXh0OnRlc3Q0QHdsYW4wOjA6MDo5LjY3OTg5NQorPiByYWRpb193b3JrIGRvbmUgNQorT0sKKzwzPkVYVC1SQURJTy1XT1JLLVNUQVJUIDcKKzwzPkVYVC1SQURJTy1XT1JLLVRJTUVPVVQgNwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLUhTMjAgYi93cGFfc3VwcGxpY2FudC9SRUFETUUtSFMyMAppbmRleCA1NjY5YzU1Li41OGMyNDc1IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9SRUFETUUtSFMyMAorKysgYi93cGFfc3VwcGxpY2FudC9SRUFETUUtSFMyMApAQCAtMTA5LDYgKzEwOSw4IEBACiAjCiAjIGNyZWRlbnRpYWwgZmllbGRzOgogIworIyB0ZW1wb3Jhcnk6IFdoZXRoZXIgdGhpcyBjcmVkZW50aWFsIGlzIHRlbXBvcmFyeSBhbmQgbm90IHRvIGJlIHNhdmVkCisjCiAjIHByaW9yaXR5OiBQcmlvcml0eSBncm91cAogIwlCeSBkZWZhdWx0LCBhbGwgbmV0d29ya3MgYW5kIGNyZWRlbnRpYWxzIGdldCB0aGUgc2FtZSBwcmlvcml0eSBncm91cAogIwkoMCkuIFRoaXMgZmllbGQgY2FuIGJlIHVzZWQgdG8gZ2l2ZSBoaWdoZXIgcHJpb3JpdHkgZm9yIGNyZWRlbnRpYWxzCkBAIC0xNjYsOSArMTY4LDI1IEBACiAjIG1pbGVuYWdlOiBNaWxlbmFnZSBwYXJhbWV0ZXJzIGZvciBTSU0vVVNJTSBzaW11bGF0b3IgaW4gPEtpPjo8T1BjPjo8U1FOPgogIwlmb3JtYXQKICMKLSMgZG9tYWluOiBIb21lIHNlcnZpY2UgcHJvdmlkZXIgRlFETgorIyBkb21haW5fc3VmZml4X21hdGNoOiBDb25zdHJhaW50IGZvciBzZXJ2ZXIgZG9tYWluIG5hbWUKKyMJSWYgc2V0LCB0aGlzIEZRRE4gaXMgdXNlZCBhcyBhIHN1ZmZpeCBtYXRjaCByZXF1aXJlbWVudCBmb3IgdGhlIEFBQQorIwlzZXJ2ZXIgY2VydGlmaWNhdGUgaW4gU3ViamVjdEFsdE5hbWUgZE5TTmFtZSBlbGVtZW50KHMpLiBJZiBhCisjCW1hdGNoaW5nIGROU05hbWUgaXMgZm91bmQsIHRoaXMgY29uc3RyYWludCBpcyBtZXQuIElmIG5vIGROU05hbWUKKyMJdmFsdWVzIGFyZSBwcmVzZW50LCB0aGlzIGNvbnN0cmFpbnQgaXMgbWF0Y2hlZCBhZ2FpbnN0IFN1YmpldE5hbWUgQ04KKyMJdXNpbmcgc2FtZSBzdWZmaXggbWF0Y2ggY29tcGFyaXNvbi4gU3VmZml4IG1hdGNoIGhlcmUgbWVhbnMgdGhhdCB0aGUKKyMJaG9zdC9kb21haW4gbmFtZSBpcyBjb21wYXJlZCBvbmUgbGFiZWwgYXQgYSB0aW1lIHN0YXJ0aW5nIGZyb20gdGhlCisjCXRvcC1sZXZlbCBkb21haW4gYW5kIGFsbCB0aGUgbGFiZWxzIGluIEBkb21haW5fc3VmZml4X21hdGNoIHNoYWxsIGJlCisjCWluY2x1ZGVkIGluIHRoZSBjZXJ0aWZpY2F0ZS4gVGhlIGNlcnRpZmljYXRlIG1heSBpbmNsdWRlIGFkZGl0aW9uYWwKKyMJc3ViLWxldmVsIGxhYmVscyBpbiBhZGRpdGlvbiB0byB0aGUgcmVxdWlyZWQgbGFiZWxzLgorIworIwlGb3IgZXhhbXBsZSwgZG9tYWluX3N1ZmZpeF9tYXRjaD1leGFtcGxlLmNvbSB3b3VsZCBtYXRjaAorIwl0ZXN0LmV4YW1wbGUuY29tIGJ1dCB3b3VsZCBub3QgbWF0Y2ggdGVzdC1leGFtcGxlLmNvbS4KKyMKKyMgZG9tYWluOiBIb21lIHNlcnZpY2UgcHJvdmlkZXIgRlFETihzKQogIwlUaGlzIGlzIHVzZWQgdG8gY29tcGFyZSBhZ2FpbnN0IHRoZSBEb21haW4gTmFtZSBMaXN0IHRvIGZpZ3VyZSBvdXQKLSMJd2hldGhlciB0aGUgQVAgaXMgb3BlcmF0ZWQgYnkgdGhlIEhvbWUgU1AuCisjCXdoZXRoZXIgdGhlIEFQIGlzIG9wZXJhdGVkIGJ5IHRoZSBIb21lIFNQLiBNdWx0aXBsZSBkb21haW4gZW50cmllcyBjYW4KKyMJYmUgdXNlZCB0byBjb25maWd1cmUgYWx0ZXJuYXRpdmUgRlFETnMgdGhhdCB3aWxsIGJlIGNvbnNpZGVyZWQgaG9tZQorIwluZXR3b3Jrcy4KICMKICMgcm9hbWluZ19jb25zb3J0aXVtOiBSb2FtaW5nIENvbnNvcnRpdW0gT0kKICMJSWYgcm9hbWluZ19jb25zb3J0aXVtX2xlbiBpcyBub24temVybywgdGhpcyBmaWVsZCBjb250YWlucyB0aGUKQEAgLTE5NSw2ICsyMTMsNjUgQEAKICMJbWF0Y2hpbmcgd2l0aCB0aGUgbmV0d29yay4gTXVsdGlwbGUgZW50cmllcyBjYW4gYmUgdXNlZCB0byBzcGVjaWZ5IG1vcmUKICMJdGhhbiBvbmUgU1NJRC4KICMKKyMgcm9hbWluZ19wYXJ0bmVyOiBSb2FtaW5nIHBhcnRuZXIgaW5mb3JtYXRpb24KKyMJVGhpcyBvcHRpb25hbCBmaWVsZCBjYW4gYmUgdXNlZCB0byBjb25maWd1cmUgcHJlZmVyZW5jZXMgYmV0d2VlbiByb2FtaW5nCisjCXBhcnRuZXJzLiBUaGUgZmllbGQgaXMgYSBzdHJpbmcgaW4gZm9sbG93aW5nIGZvcm1hdDoKKyMJPEZRRE4+LDwwLzEgZXhhY3QgbWF0Y2g+LDxwcmlvcml0eT4sPCogb3IgY291bnRyeSBjb2RlPgorIwkobm9uLWV4YWN0IG1hdGNoIG1lYW5zIGFueSBzdWJkb21haW4gbWF0Y2hlcyB0aGUgZW50cnk7IHByaW9yaXR5IGlzIGluCisjCTAuLjI1NSByYW5nZSB3aXRoIDAgYmVpbmcgdGhlIGhpZ2hlc3QgcHJpb3JpdHkpCisjCisjIHVwZGF0ZV9pZGVudGlmaWVyOiBQUFMgTU8gSUQKKyMJKEhvdHNwb3QgMi4wIFBlclByb3ZpZGVyU3Vic2NyaXB0aW9uL1VwZGF0ZUlkZW50aWZpZXIpCisjCisjIHByb3Zpc2lvbmluZ19zcDogRlFETiBvZiB0aGUgU1AgdGhhdCBwcm92aXNpb25lZCB0aGUgY3JlZGVudGlhbAorIwlUaGlzIG9wdGlvbmFsIGZpZWxkIGNhbiBiZSB1c2VkIHRvIGtlZXAgdHJhY2sgb2YgdGhlIFNQIHRoYXQgcHJvdmlzaW9uZWQKKyMJdGhlIGNyZWRlbnRpYWwgdG8gZmluZCB0aGUgUFBTIE1PICguL1dpLUZpLzxwcm92aXNpb25pbmdfc3A+KS4KKyMKKyMgc3BfcHJpb3JpdHk6IENyZWRlbnRpYWwgcHJpb3JpdHkgd2l0aGluIGEgcHJvdmlzaW9uaW5nIFNQCisjCVRoaXMgaXMgdGhlIHByaW9yaXR5IG9mIHRoZSBjcmVkZW50aWFsIGFtb25nIGFsbCBjcmVkZW50aWFscworIwlwcm92aXNpb25pbmVkIGJ5IHRoZSBzYW1lIFNQIChpLmUuLCBmb3IgZW50cmllcyB0aGF0IGhhdmUgaWRlbnRpY2FsCisjCXByb3Zpc2lvbmluZ19zcCB2YWx1ZSkuIFRoZSByYW5nZSBvZiB0aGlzIHByaW9yaXR5IGlzIDAtMjU1IHdpdGggMAorIwliZWluZyB0aGUgaGlnaGVzdCBhbmQgMjU1IHRoZSBsb3dlciBwcmlvcml0eS4KKyMKKyMgTWluaW11bSBiYWNraGF1bCB0aHJlc2hvbGQgKFBQUy88WCs+L1BvbGljeS9NaW5CYWNraGF1bGRUaHJlc2hvbGQvKikKKyMJVGhlc2UgZmllbGRzIGNhbiBiZSB1c2VkIHRvIHNwZWNpZnkgbWluaW11bSBkb3dubG9hZC91cGxvYWQgYmFja2hhdWwKKyMJYmFuZHdpZHRoIHRoYXQgaXMgcHJlZmVycmVkIGZvciB0aGUgY3JlZGVudGlhbC4gVGhpcyBjb25zdHJhaW50IGlzCisjCWlnbm9yZWQgaWYgdGhlIEFQIGRvZXMgbm90IGFkdmVydGlzZSBXQU4gTWV0cmljcyBpbmZvcm1hdGlvbiBvciBpZiB0aGUKKyMJbGltaXQgd291bGQgcHJldmVudCBhbnkgY29ubmVjdGlvbi4gVmFsdWVzIGFyZSBpbiBraWxvYml0cyBwZXIgc2Vjb25kLgorIyBtaW5fZGxfYmFuZHdpZHRoX2hvbWUKKyMgbWluX3VsX2JhbmR3aWR0aF9ob21lCisjIG1pbl9kbF9iYW5kd2lkdGhfcm9hbWluZworIyBtaW5fdWxfYmFuZHdpZHRoX3JvYW1pbmcKKyMKKyMgbWF4X2Jzc19sb2FkOiBNYXhpbXVtIEJTUyBMb2FkIENoYW5uZWwgVXRpbGl6YXRpb24gKDEuLjI1NSkKKyMJKFBQUy88WCs+L1BvbGljeS9NYXhpbXVtQlNTTG9hZFZhbHVlKQorIwlUaGlzIHZhbHVlIGlzIHVzZWQgYXMgdGhlIG1heGltdW0gY2hhbm5lbCB1dGlsaXphdGlvbiBmb3IgbmV0d29yaworIwlzZWxlY3Rpb24gcHVycG9zZXMgZm9yIGhvbWUgbmV0d29ya3MuIElmIHRoZSBBUCBkb2VzIG5vdCBhZHZlcnRpc2UKKyMJQlNTIExvYWQgb3IgaWYgdGhlIGxpbWl0IHdvdWxkIHByZXZlbnQgYW55IGNvbm5lY3Rpb24sIHRoaXMgY29uc3RyYWludAorIwl3aWxsIGJlIGlnbm9yZWQuCisjCisjIHJlcV9jb25uX2NhcGFiOiBSZXF1aXJlZCBjb25uZWN0aW9uIGNhcGFiaWxpdHkKKyMJKFBQUy88WCs+L1BvbGljeS9SZXF1aXJlZFByb3RvUG9ydFR1cGxlKQorIwlUaGlzIHZhbHVlIGlzIHVzZWQgdG8gY29uZmlndXJlIHNldCBvZiByZXF1aXJlZCBwcm90b2NvbC9wb3J0IHBhaXJzIHRoYXQKKyMJYSByb2FtaW5nIG5ldHdvcmsgc2hhbGwgc3VwcG9ydCAoaW5jbHVkZSBleHBsaWNpdGx5IGluIENvbm5lY3Rpb24KKyMJQ2FwYWJpbGl0eSBBTlFQIGVsZW1lbnQpLiBUaGlzIGNvbnN0cmFpbnQgaXMgaWdub3JlZCBpZiB0aGUgQVAgZG9lcyBub3QKKyMJYWR2ZXJ0aXNlIENvbm5lY3Rpb24gQ2FwYWJpbGl0eSBvciBpZiB0aGlzIGNvbnN0cmFpbnQgd291bGQgcHJldmVudCBhbnkKKyMJbmV0d29yayBjb25uZWN0aW9uLiBUaGlzIHBvbGljeSBpcyBub3QgdXNlZCBpbiBob21lIG5ldHdvcmtzLgorIwlGb3JtYXQ6IDxwcm90b2NvbD5bOjxjb21tYS1zZXBhcmF0ZWQgbGlzdCBvZiBwb3J0c10KKyMJTXVsdGlwbGUgZW50cmllcyBjYW4gYmUgdXNlZCB0byBsaXN0IG11bHRpcGxlIHJlcXVpcmVtZW50cy4KKyMJRm9yIGV4YW1wbGUsIG51bWJlciBvZiBjb21tb24gVENQIHByb3RvY29sczoKKyMJcmVxX2Nvbm5fY2FwYWI9NjoyMiw4MCw0NDMKKyMJRm9yIGV4YW1wbGUsIElQU2VjL0lLRToKKyMJcmVxX2Nvbm5fY2FwYWI9MTc6NTAwCisjCXJlcV9jb25uX2NhcGFiPTUwCisjCisjIG9jc3A6IFdoZXRoZXIgdG8gdXNlL3JlcXVpcmUgT0NTUCB0byBjaGVjayBzZXJ2ZXIgY2VydGlmaWNhdGUKKyMJMCA9IGRvIG5vdCB1c2UgT0NTUCBzdGFwbGluZyAoVExTIGNlcnRpZmljYXRlIHN0YXR1cyBleHRlbnNpb24pCisjCTEgPSB0cnkgdG8gdXNlIE9DU1Agc3RhcGxpbmcsIGJ1dCBub3QgcmVxdWlyZSByZXNwb25zZQorIwkyID0gcmVxdWlyZSB2YWxpZCBPQ1NQIHN0YXBsaW5nIHJlc3BvbnNlCisjCisjIHNpbV9udW06IElkZW50aWZpZXIgZm9yIHdoaWNoIFNJTSB0byB1c2UgaW4gbXVsdGktU0lNIGRldmljZXMKKyMKICMgZm9yIGV4YW1wbGU6CiAjCiAjY3JlZD17CkBAIC0yMDMsNiArMjgwLDcgQEAKICMJcGFzc3dvcmQ9InBhc3N3b3JkIgogIwljYV9jZXJ0PSIvZXRjL3dwYV9zdXBwbGljYW50L2NhLnBlbSIKICMJZG9tYWluPSJleGFtcGxlLmNvbSIKKyMJZG9tYWluX3N1ZmZpeF9tYXRjaD0iZXhhbXBsZS5jb20iCiAjfQogIwogI2NyZWQ9ewpAQCAtMjUyLDYgKzMzMCw4IEBACiBPSwogPiBzZXRfY3JlZCAwIHByaW9yaXR5IDEKIE9LCis+IHNldF9jcmVkIDAgdGVtcG9yYXJ5IDEKK09LCiAKIEFkZCBhIFNJTSBjcmVkZW50aWFsIHVzaW5nIGEgc2ltdWxhdGVkIFNJTS9VU0lNIGNhcmQgZm9yIHRlc3Rpbmc6CiAKQEAgLTI2Nyw2ICszNDcsMTcgQEAKIE5vdGU6IHRoZSByZXR1cm4gdmFsdWUgb2YgYWRkX2NyZWQgaXMgdXNlZCBhcyB0aGUgZmlyc3QgYXJndW1lbnQgdG8KIHRoZSBmb2xsb3dpbmcgc2V0X2NyZWQgY29tbWFuZHMuCiAKK0FkZCBhIFNJTSBjcmVkZW50aWFsIHVzaW5nIGEgZXh0ZXJuYWwgU0lNL1VTSU0gcHJvY2Vzc2luZzoKKworPiBzZXQgZXh0ZXJuYWxfc2ltIDEKK09LCis+IGFkZF9jcmVkCisxCis+IHNldF9jcmVkIDEgaW1zaSAiMjM0NTYtMDAwMDAwMDAwMCIKK09LCis+IHNldF9jcmVkIDEgZWFwIFNJTQorT0sKKwogCiBBZGQgYSBXUEEyLUVudGVycHJpc2UgbmV0d29yazoKIApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLVAyUCBiL3dwYV9zdXBwbGljYW50L1JFQURNRS1QMlAKaW5kZXggNzZmODIxOS4uNWMxZTRmOSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLVAyUAorKysgYi93cGFfc3VwcGxpY2FudC9SRUFETUUtUDJQCkBAIC03Miw3ICs3Miw4IEBACiBEZXZpY2UgRGlzY292ZXJ5CiAKIHAycF9maW5kIFt0aW1lb3V0IGluIHNlY29uZHNdIFt0eXBlPTxzb2NpYWx8cHJvZ3Jlc3NpdmU+XSBcCi0JW2Rldl9pZD08YWRkcj5dIFtkZWxheT08c2VhcmNoIGRlbGF5IGluIG1zPl0KKwlbZGV2X2lkPTxhZGRyPl0gW2Rldl90eXBlPTxkZXZpY2UgdHlwZT5dIFwKKwlbZGVsYXk9PHNlYXJjaCBkZWxheSBpbiBtcz5dCiAKIFRoZSBkZWZhdWx0IGJlaGF2aW9yIGlzIHRvIHJ1biBhIHNpbmdsZSBmdWxsIHNjYW4gaW4gdGhlIGJlZ2lubmluZyBhbmQKIHRoZW4gc2NhbiBvbmx5IHNvY2lhbCBjaGFubmVscy4gdHlwZT1zb2NpYWwgd2lsbCBzY2FuIG9ubHkgc29jaWFsCkBAIC04Nyw2ICs4OCwxMCBAQAogZGVsYXkgdG8gYmUgdXNlZCBiZXR3ZWVuIHNlYXJjaCBpdGVyYXRpb25zIChlLmcuLCB0byBmcmVlIHVwIHJhZGlvCiByZXNvdXJjZXMgZm9yIGNvbmN1cnJlbnQgb3BlcmF0aW9ucykuCiAKK1RoZSBvcHRpb25hbCBkZXZfdHlwZSBvcHRpb24gY2FuIGJlIHVzZWQgdG8gc3BlY2lmeSBhIHNpbmdsZSBkZXZpY2UgdHlwZQorKHByaW1hcnkgb3Igc2Vjb25kYXJ5KSB0byBzZWFyY2ggZm9yLCBlLmcuLAorInAycF9maW5kIGRldl90eXBlPTEtMDA1MEYyMDQtMSIuCisKIHAycF9saXN0ZW4gW3RpbWVvdXQgaW4gc2Vjb25kc10KIAogU3RhcnQgTGlzdGVuLW9ubHkgc3RhdGUgKGJlY29tZSBkaXNjb3ZlcmFibGUgd2l0aG91dCBzZWFyY2hpbmcgZm9yCkBAIC0xMjUsNyArMTMwLDcgQEAKIAogcDJwX2Nvbm5lY3QgPHBlZXIgZGV2aWNlIGFkZHJlc3M+IDxwYmN8cGlufFBJTiM+IFtkaXNwbGF5fGtleXBhZF0KIAlbcGVyc2lzdGVudHxwZXJzaXN0ZW50PTxuZXR3b3JrIGlkPl0gW2pvaW58YXV0aF0KLQlbZ29faW50ZW50PTwwLi4xNT5dIFtmcmVxPTxpbiBNSHo+XSBbaHQ0MF0gW3Byb3ZkaXNjXQorCVtnb19pbnRlbnQ9PDAuLjE1Pl0gW2ZyZXE9PGluIE1Iej5dIFtodDQwXSBbdmh0XSBbcHJvdmRpc2NdCiAKIFN0YXJ0IFAyUCBncm91cCBmb3JtYXRpb24gd2l0aCBhIGRpc2NvdmVyZWQgUDJQIHBlZXIuIFRoaXMgaW5jbHVkZXMKIG9wdGlvbmFsIGdyb3VwIG93bmVyIG5lZ290aWF0aW9uLCBncm91cCBpbnRlcmZhY2Ugc2V0dXAsIHByb3Zpc2lvbmluZywKQEAgLTE2Niw3ICsxNzEsOCBAQAogUDJQIGltcGxlbWVudGF0aW9ucyB0aGF0IHJlcXVpcmUgdGhpcyB0byBhbGxvdyB0aGUgdXNlciB0byBhY2NlcHQgdGhlCiBjb25uZWN0aW9uLgogCi1wMnBfZ3JvdXBfYWRkIFtwZXJzaXN0ZW50fHBlcnNpc3RlbnQ9PG5ldHdvcmsgaWQ+XSBbZnJlcT08ZnJlcSBpbiBNSHo+XSBbaHQ0MF0KK3AycF9ncm91cF9hZGQgW3BlcnNpc3RlbnR8cGVyc2lzdGVudD08bmV0d29yayBpZD5dIFtmcmVxPTxmcmVxIGluIE1Iej5dCisJW2h0NDBdIFt2aHRdCiAKIFNldCB1cCBhIFAyUCBncm91cCBvd25lciBtYW51YWxseSAoaS5lLiwgd2l0aG91dCBncm91cCBvd25lcgogbmVnb3RpYXRpb24gd2l0aCBhIHNwZWNpZmljIHBlZXIpLiBUaGlzIGlzIGFsc28ga25vd24gYXMgYXV0b25vbW91cwpAQCAtMjI0LDkgKzIzMCw4IEBACiBwZWVycyAobm90ZTogdGhpcyBjYW4gcmVzdWx0IGluIGxvbmcgcmVzcG9uc2UgZnJhbWVzKS4gVGhlIHBlbmRpbmcKIHJlcXVlc3RzIGFyZSBzZW50IGR1cmluZyBkZXZpY2UgZGlzY292ZXJ5IChzZWUgcDJwX2ZpbmQpLgogCi1Pbmx5IGEgc2luZ2xlIHBlbmRpbmcgd2lsZGNhcmQgcXVlcnkgaXMgc3VwcG9ydGVkLCBidXQgdGhlcmUgY2FuIGJlCi1tdWx0aXBsZSBwZW5kaW5nIHBlZXIgZGV2aWNlIHNwZWNpZmljIHF1ZXJpZXMgKGVhY2ggd2lsbCBiZSBzZW50IGluCi1zZXF1ZW5jZSB3aGVuZXZlciB0aGUgcGVlciBpcyBmb3VuZCkuCitUaGVyZSBjYW4gYmUgbXVsdGlwbGUgcGVuZGluZyBwZWVyIGRldmljZSBzcGVjaWZpYyBxdWVyaWVzIChlYWNoIHdpbGwgYmUKK3NlbnQgaW4gc2VxdWVuY2Ugd2hlbmV2ZXIgdGhlIHBlZXIgaXMgZm91bmQpLgogCiBUaGlzIGNvbW1hbmQgcmV0dXJucyBhbiBpZGVudGlmaWVyIGZvciB0aGUgcGVuZGluZyBxdWVyeSAoZS5nLiwKICIxZjc3NjI4IikgdGhhdCBjYW4gYmUgdXNlZCB0byBjYW5jZWwgdGhlIHJlcXVlc3QuIERpcmVjdGVkIHJlcXVlc3RzCkBAIC0zNzMsNyArMzc4LDggQEAKIEludml0YXRpb24KIAogcDJwX2ludml0ZSBbcGVyc2lzdGVudD08bmV0d29yayBpZD58Z3JvdXA9PGdyb3VwIGlmbmFtZT5dIFtwZWVyPWFkZHJlc3NdCi0JW2dvX2Rldl9hZGRyPWFkZHJlc3NdIFtmcmVxPTxmcmVxIGluIE1Iej5dIFtodDQwXSBbcHJlZj08TUh6Pl0KKwlbZ29fZGV2X2FkZHI9YWRkcmVzc10gW2ZyZXE9PGZyZXEgaW4gTUh6Pl0gW2h0NDBdIFt2aHRdCisJW3ByZWY9PE1Iej5dCiAKIEludml0ZSBhIHBlZXIgdG8gam9pbiBhIGdyb3VwIChlLmcuLCBncm91cD13bGFuMSkgb3IgdG8gcmVpbnZva2UgYQogcGVyc2lzdGVudCBncm91cCAoZS5nLiwgcGVyc2lzdGVudD00KS4gSWYgdGhlIHBlZXIgZGV2aWNlIGlzIHRoZSBHTyBvZgpAQCAtNDE2LDkgKzQyMiwxMSBAQAogU2VuZCBhIFAyUCBQcmVzZW5jZSBSZXF1ZXN0IHRvIHRoZSBHTyAodGhpcyBpcyBvbmx5IGF2YWlsYWJsZSB3aGVuCiBhY3RpbmcgYXMgYSBQMlAgY2xpZW50KS4gSWYgbm8gZHVyYXRpb24vaW50ZXJ2YWwgcGFpcnMgYXJlIGdpdmVuLCB0aGUKIHJlcXVlc3QgaW5kaWNhdGVzIHRoYXQgdGhpcyBjbGllbnQgaGFzIG5vIHNwZWNpYWwgbmVlZHMgZm9yIEdPCi1wcmVzZW5jZS4gdGhlIGZpcnN0IHBhcmFtZXRlciBwYWlyIGdpdmVzIHRoZSBwcmVmZXJyZWQgZHVyYXRpb24gYW5kCitwcmVzZW5jZS4gVGhlIGZpcnN0IHBhcmFtZXRlciBwYWlyIGdpdmVzIHRoZSBwcmVmZXJyZWQgZHVyYXRpb24gYW5kCiBpbnRlcnZhbCB2YWx1ZXMgaW4gbWljcm9zZWNvbmRzLiBJZiB0aGUgc2Vjb25kIHBhaXIgaXMgaW5jbHVkZWQsIHRoYXQKLWluZGljYXRlcyB3aGljaCB2YWx1ZSB3b3VsZCBiZSBhY2NlcHRhYmxlLgoraW5kaWNhdGVzIHdoaWNoIHZhbHVlIHdvdWxkIGJlIGFjY2VwdGFibGUuIFRoaXMgY29tbWFuZCByZXR1cm5zIE9LCitpbW1lZGlhdGVseSBhbmQgdGhlIHJlc3BvbnNlIGZyb20gdGhlIEdPIGlzIGluZGljYXRlZCBpbiBhCitQMlAtUFJFU0VOQ0UtUkVTUE9OU0UgZXZlbnQgbWVzc2FnZS4KIAogUGFyYW1ldGVycwogCkBAIC01NDYsNiArNTU0LDEzIEBACiAKIFNldCBjb3VudHJ5IGNvZGUgKHRoaXMgaXMgaW5jbHVkZWQgaW4gc29tZSBQMlAgbWVzc2FnZXMpLgogCitzZXQgcDJwX3NlYXJjaF9kZWxheSA8ZGVsYXk+CisKK1NldCBwMnBfc2VhcmNoX2RlbGF5IHdoaWNoIGFkZHMgZXh0cmEgZGVsYXkgaW4gbWlsbGlzZWNvbmRzIGJldHdlZW4KK2NvbmN1cnJlbnQgc2VhcmNoIGl0ZXJhdGlvbnMgdG8gbWFrZSBwMnBfZmluZCBmcmllbmRsaWVyIHRvIGNvbmN1cnJlbnQKK29wZXJhdGlvbnMgYnkgYXZvaWRpbmcgaXQgZnJvbSB0YWtpbmcgMTAwJSBvZiByYWRpbyByZXNvdXJjZXMuIFRoZQorZGVmYXVsdCB2YWx1ZSBpcyA1MDAgbXMuCisKIFN0YXR1cwogCiBwMnBfcGVlcnMgW2Rpc2NvdmVyZWRdCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9SRUFETUUtV1BTIGIvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLVdQUwppbmRleCAzZDA3MTA5Li5iODg0ZjY3IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9SRUFETUUtV1BTCisrKyBiL3dwYV9zdXBwbGljYW50L1JFQURNRS1XUFMKQEAgLTYwLDcgKzYwLDYgQEAKIAogQ09ORklHX0RSSVZFUl9OTDgwMjExPXkKIENPTkZJR19XUFM9eQotQ09ORklHX1dQUzI9eQogCiBJZiB5b3Ugd2FudCB0byBlbmFibGUgV1BTIGV4dGVybmFsIHJlZ2lzdHJhciAoRVIpIGZ1bmN0aW9uYWxpdHksIHlvdQogd2lsbCBhbHNvIG5lZWQgdG8gYWRkIGZvbGxvd2luZyBsaW5lOgpAQCAtMzY2LDExICszNjUsMTEgQEAKIHRva2VuIGlzIHVzZWQgdG8gZW5hYmxlIGVucm9sbG1lbnQgb2YgYSBuZXcgc3RhdGlvbiAodGhhdCB3YXMgdGhlIHNvdXJjZQogb2YgdGhlIE5GQyBwYXNzd29yZCB0b2tlbikuCiAKLSJuZmNfZ2V0X2hhbmRvdmVyX3JlcSA8TkRFRj4gPFdQUz4iIGNvbW1hbmQgY2FuIGJlIHVzZWQgdG8gYnVpbGQgdGhlCi1jb250ZW50cyBvZiBhIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSBmb3IgY29ubmVjdGlvbiBoYW5kb3Zlci4gVGhlCi1maXJzdCBhcmd1bWVudCBzZWxlY3RzIHRoZSBmb3JtYXQgb2YgdGhlIG91dHB1dCBkYXRhIGFuZCB0aGUgc2Vjb25kCi1hcmd1bWVudCBzZWxlY3RzIHdoaWNoIHR5cGUgb2YgY29ubmVjdGlvbiBoYW5kb3ZlciBpcyByZXF1ZXN0ZWQgKFdQUyA9Ci1XaS1GaSBoYW5kb3ZlciBhcyBzcGVjaWZpZWQgaW4gV1NDIDIuMCkuCisibmZjX2dldF9oYW5kb3Zlcl9yZXEgPE5ERUY+IDxXUFMtQ1I+IiBjb21tYW5kIGNhbiBiZSB1c2VkIHRvIGJ1aWxkIHRoZQorV1BTIGNhcnJpZXIgcmVjb3JkIGZvciBhIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSBmb3IgY29ubmVjdGlvbgoraGFuZG92ZXIuIFRoZSBmaXJzdCBhcmd1bWVudCBzZWxlY3RzIHRoZSBmb3JtYXQgb2YgdGhlIG91dHB1dCBkYXRhIGFuZAordGhlIHNlY29uZCBhcmd1bWVudCBzZWxlY3RzIHdoaWNoIHR5cGUgb2YgY29ubmVjdGlvbiBoYW5kb3ZlciBpcworcmVxdWVzdGVkIChXUFMtQ1IgPSBXaS1GaSBoYW5kb3ZlciBhcyBzcGVjaWZpZWQgaW4gV1NDIDIuMCkuCiAKICJuZmNfZ2V0X2hhbmRvdmVyX3NlbCA8TkRFRj4gPFdQUz4gW1VVSUR8QlNTSURdIiBjb21tYW5kIGNhbiBiZSB1c2VkIHRvCiBidWlsZCB0aGUgY29udGVudHMgb2YgYSBIYW5kb3ZlciBTZWxlY3QgTWVzc2FnZSBmb3IgY29ubmVjdGlvbiBoYW5kb3ZlcgpAQCAtMzgyLDE3ICszODEsNiBAQAogbWVzc2FnZSBmb3IgdGhlIHNwZWNpZmllZCBBUCB3aGVuIHdwYV9zdXBwbGljYW50IGlzIG9wZXJhdGluZyBhcyBhIFdQUwogRVIuCiAKLSJuZmNfcnhfaGFuZG92ZXJfcmVxIDxoZXhkdW1wIG9mIHBheWxvYWQ+IiBpcyB1c2VkIHRvIGluZGljYXRlIHJlY2VpcHQKLW9mIE5GQyBjb25uZWN0aW9uIGhhbmRvdmVyIHJlcXVlc3QuIFRoZSBwYXlsb2FkIG1heSBpbmNsdWRlIG11bHRpcGxlCi1jYXJyaWVycyB0aGUgdGhlIGFwcGxpY2FibGUgb25lcyBhcmUgbWF0Y2hlZCBiYXNlZCBvbiB0aGUgbWVkaWEKLXR5cGUuIFRoZSByZXBseSBkYXRhIGlzIGNvbnRlbnRzIGZvciB0aGUgSGFuZG92ZXIgU2VsZWN0IE1lc3NhZ2UKLShoZXhkdW1wKS4KLQotIm5mY19yeF9oYW5kb3Zlcl9zZWwgPGhleGR1bXAgb2YgcGF5bG9hZD4iIGlzIHVzZWQgdG8gaW5kaWNhdGUgcmVjZWlwdAotb2YgTkZDIGNvbm5lY3Rpb24gaGFuZG92ZXIgc2VsZWN0LiBUaGUgcGF5bG9hZCBtYXkgaW5jbHVkZSBtdWx0aXBsZQotY2FycmllcnMgdGhlIHRoZSBhcHBsaWNhYmxlIG9uZXMgYXJlIG1hdGNoZWQgYmFzZWQgb24gdGhlIG1lZGlhCi10eXBlLgotCiAibmZjX3JlcG9ydF9oYW5kb3ZlciA8SU5JVC9SRVNQPiBXUFMgPGNhcnJpZXIgZnJvbSBoYW5kb3ZlciByZXF1ZXN0PgogPGNhcnJpZXIgZnJvbSBoYW5kb3ZlciBzZWxlY3Q+IiBjYW4gYmUgdXNlZCBhcyBhbiBhbHRlcm5hdGl2ZSB3YXkgZm9yCiByZXBvcnRpbmcgY29tcGxldGVkIE5GQyBjb25uZWN0aW9uIGhhbmRvdmVyLiBUaGUgZmlyc3QgcGFyYW1ldGVyCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9hbmRyb2lkLmNvbmZpZyBiL3dwYV9zdXBwbGljYW50L2FuZHJvaWQuY29uZmlnCmluZGV4IDhiM2Q2YjQuLjNlZDczNGQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2FuZHJvaWQuY29uZmlnCisrKyBiL3dwYV9zdXBwbGljYW50L2FuZHJvaWQuY29uZmlnCkBAIC0yMCw2MyArMjAsNiBAQAogIyB1c2VkIHRvIGZpeCBidWlsZCBpc3N1ZXMgb24gc3VjaCBzeXN0ZW1zIChrcmI1Lmggbm90IGZvdW5kKS4KICNDRkxBR1MgKz0gLUkvdXNyL2luY2x1ZGUva2VyYmVyb3MKIAotIyBFeGFtcGxlIGNvbmZpZ3VyYXRpb24gZm9yIHZhcmlvdXMgY3Jvc3MtY29tcGlsYXRpb24gcGxhdGZvcm1zCi0KLSMjIyMgc3ZlYXNvZnQgKGUuZy4sIGZvciBMaW5rc3lzIFdSVDU0RykgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLSNDQz1taXBzZWwtdWNsaWJjLWdjYwotI0NDPS9vcHQvYnJjbS9obmR0b29scy1taXBzZWwtdWNsaWJjL2Jpbi9taXBzZWwtdWNsaWJjLWdjYwotI0NGTEFHUyArPSAtT3MKLSNDUFBGTEFHUyArPSAtSS4uL3NyYy9pbmNsdWRlIC1JLi4vLi4vc3JjL3JvdXRlci9vcGVuc3NsL2luY2x1ZGUKLSNMSUJTICs9IC1ML29wdC9icmNtL2huZHRvb2xzLW1pcHNlbC11Y2xpYmMtMC45LjE5L2xpYiAtbHNzbAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0jIyMjIG9wZW53cnQgKGUuZy4sIGZvciBMaW5rc3lzIFdSVDU0RykgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jQ0M9bWlwc2VsLXVjbGliYy1nY2MKLSNDQz0vb3B0L2JyY20vaG5kdG9vbHMtbWlwc2VsLXVjbGliYy9iaW4vbWlwc2VsLXVjbGliYy1nY2MKLSNDRkxBR1MgKz0gLU9zCi0jQ1BQRkxBR1M9LUkuLi9zcmMvaW5jbHVkZSAtSS4uL29wZW5zc2wtMC45LjdkL2luY2x1ZGUgXAotIwktSS4uL1dSVDU0R1MvcmVsZWFzZS9zcmMvaW5jbHVkZQotI0xJQlMgPSAtbHNzbAotIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotCi0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgSG9zdCBBUCBkcml2ZXIKLSNDT05GSUdfRFJJVkVSX0hPU1RBUD15Ci0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgQWdlcmUgZHJpdmVyCi0jQ09ORklHX0RSSVZFUl9IRVJNRVM9eQotIyBDaGFuZ2UgaW5jbHVkZSBkaXJlY3RvcmllcyB0byBtYXRjaCB3aXRoIHRoZSBsb2NhbCBzZXR1cAotI0NGTEFHUyArPSAtSS4uLy4uL2hjZiAtSS4uLy4uL2luY2x1ZGUgLUkuLi8uLi9pbmNsdWRlL2hjZgotI0NGTEFHUyArPSAtSS4uLy4uL2luY2x1ZGUvd2lyZWxlc3MKLQotIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBtYWR3aWZpIGRyaXZlcgotIyBEZXByZWNhdGVkOyB1c2UgQ09ORklHX0RSSVZFUl9XRVhUPXkgaW5zdGVhZC4KLSNDT05GSUdfRFJJVkVSX01BRFdJRkk9eQotIyBTZXQgaW5jbHVkZSBkaXJlY3RvcnkgdG8gdGhlIG1hZHdpZmkgc291cmNlIHRyZWUKLSNDRkxBR1MgKz0gLUkuLi8uLi9tYWR3aWZpCi0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgbmRpc3dyYXBwZXIKLSMgRGVwcmVjYXRlZDsgdXNlIENPTkZJR19EUklWRVJfV0VYVD15IGluc3RlYWQuCi0jQ09ORklHX0RSSVZFUl9ORElTV1JBUFBFUj15Ci0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgQXRtZWwgZHJpdmVyCi0jQ09ORklHX0RSSVZFUl9BVE1FTD15Ci0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3Igb2xkIEJyb2FkY29tIGRyaXZlcgotIyBQbGVhc2Ugbm90ZSB0aGF0IHRoZSBuZXdlciBCcm9hZGNvbSBkcml2ZXIgKCJoeWJyaWQgTGludXggZHJpdmVyIikgc3VwcG9ydHMKLSMgTGludXggd2lyZWxlc3MgZXh0ZW5zaW9ucyBhbmQgZG9lcyBub3QgbmVlZCAob3IgZXZlbiB3b3JrKSB3aXRoIHRoZSBvbGQKLSMgZHJpdmVyIHdyYXBwZXIuIFVzZSBDT05GSUdfRFJJVkVSX1dFWFQ9eSB3aXRoIHRoYXQgZHJpdmVyLgotI0NPTkZJR19EUklWRVJfQlJPQURDT009eQotIyBFeGFtcGxlIHBhdGggZm9yIHdsaW9jdGwuaDsgY2hhbmdlIHRvIG1hdGNoIHlvdXIgY29uZmlndXJhdGlvbgotI0NGTEFHUyArPSAtSS9vcHQvV1JUNTRHUy9yZWxlYXNlL3NyYy9pbmNsdWRlCi0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgSW50ZWwgaXB3MjEwMC8yMjAwIGRyaXZlcgotIyBEZXByZWNhdGVkOyB1c2UgQ09ORklHX0RSSVZFUl9XRVhUPXkgaW5zdGVhZC4KLSNDT05GSUdfRFJJVkVSX0lQVz15Ci0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgUmFsaW5rIGRyaXZlcgotI0NPTkZJR19EUklWRVJfUkFMSU5LPXkKLQogIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBnZW5lcmljIExpbnV4IHdpcmVsZXNzIGV4dGVuc2lvbnMKICMgTm90ZTogV0VYVCBpcyBkZXByZWNhdGVkIGluIHRoZSBjdXJyZW50IExpbnV4IGtlcm5lbCB2ZXJzaW9uIGFuZCBubyBuZXcKICMgZnVuY3Rpb25hbGl0eSBpcyBhZGRlZCB0byBpdC4gbmw4MDIxMS1iYXNlZCBpbnRlcmZhY2UgaXMgdGhlIG5ldwpAQCAtMTgwLDcgKzEyMyw3IEBACiAKICMgRUFQLUFLQScgKGVuYWJsZSBDT05GSUdfUENTQywgaWYgRUFQLUFLQScgaXMgdXNlZCkuCiAjIFRoaXMgcmVxdWlyZXMgQ09ORklHX0VBUF9BS0EgdG8gYmUgZW5hYmxlZCwgdG9vLgotI0NPTkZJR19FQVBfQUtBX1BSSU1FPXkKK0NPTkZJR19FQVBfQUtBX1BSSU1FPXkKIAogIyBFbmFibGUgVVNJTSBzaW11bGF0b3IgKE1pbGVuYWdlKSBmb3IgRUFQLUFLQQogI0NPTkZJR19VU0lNX1NJTVVMQVRPUj15CkBAIC0xOTgsOCArMTQxLDYgQEAKIAogIyBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAgKFdQUykKIENPTkZJR19XUFM9eQotIyBFbmFibGUgV1NDIDIuMCBzdXBwb3J0Ci1DT05GSUdfV1BTMj15CiAjIEVuYWJsZSBXUFMgZXh0ZXJuYWwgcmVnaXN0cmFyIGZ1bmN0aW9uYWxpdHkKIENPTkZJR19XUFNfRVI9eQogIyBEaXNhYmxlIGNyZWRlbnRpYWxzIGZvciBhbiBvcGVuIG5ldHdvcmsgYnkgZGVmYXVsdCB3aGVuIGFjdGluZyBhcyBhIFdQUwpAQCAtMjk2LDcgKzIzNyw3IEBACiAjIG1haW5fbm9uZSA9IFZlcnkgYmFzaWMgZXhhbXBsZSAoZGV2ZWxvcG1lbnQgdXNlIG9ubHkpCiAjQ09ORklHX01BSU49bWFpbgogCi0jIFNlbGVjdCB3cmFwcGVyIGZvciBvcGVyYXRpbnMgc3lzdGVtIGFuZCBDIGxpYnJhcnkgc3BlY2lmaWMgZnVuY3Rpb25zCisjIFNlbGVjdCB3cmFwcGVyIGZvciBvcGVyYXRpbmcgc3lzdGVtIGFuZCBDIGxpYnJhcnkgc3BlY2lmaWMgZnVuY3Rpb25zCiAjIHVuaXggPSBVTklYL1BPU0lYIGxpa2Ugc3lzdGVtcyAoZGVmYXVsdCkKICMgd2luMzIgPSBXaW5kb3dzIHN5c3RlbXMKICMgbm9uZSA9IEVtcHR5IHRlbXBsYXRlCkBAIC0zMDUsMTIgKzI0NiwxNCBAQAogIyBTZWxlY3QgZXZlbnQgbG9vcCBpbXBsZW1lbnRhdGlvbgogIyBlbG9vcCA9IHNlbGVjdCgpIGxvb3AgKGRlZmF1bHQpCiAjIGVsb29wX3dpbiA9IFdpbmRvd3MgZXZlbnRzIGFuZCBXYWl0Rm9yTXVsdGlwbGVPYmplY3QoKSBsb29wCi0jIGVsb29wX25vbmUgPSBFbXB0eSB0ZW1wbGF0ZQogQ09ORklHX0VMT09QPWVsb29wCiAKICMgU2hvdWxkIHdlIHVzZSBwb2xsIGluc3RlYWQgb2Ygc2VsZWN0PyBTZWxlY3QgaXMgdXNlZCBieSBkZWZhdWx0LgogI0NPTkZJR19FTE9PUF9QT0xMPXkKIAorIyBTaG91bGQgd2UgdXNlIGVwb2xsIGluc3RlYWQgb2Ygc2VsZWN0PyBTZWxlY3QgaXMgdXNlZCBieSBkZWZhdWx0LgorI0NPTkZJR19FTE9PUF9FUE9MTD15CisKICMgU2VsZWN0IGxheWVyIDIgcGFja2V0IGltcGxlbWVudGF0aW9uCiAjIGxpbnV4ID0gTGludXggcGFja2V0IHNvY2tldCAoZGVmYXVsdCkKICMgcGNhcCA9IGxpYnBjYXAvbGliZG5ldC9XaW5QY2FwCkBAIC0zMjUsNyArMjY4LDcgQEAKIAogIyBJRUVFIDgwMi4xMXcgKG1hbmFnZW1lbnQgZnJhbWUgcHJvdGVjdGlvbiksIGFsc28ga25vd24gYXMgUE1GCiAjIERyaXZlciBzdXBwb3J0IGlzIGFsc28gbmVlZGVkIGZvciBJRUVFIDgwMi4xMXcuCi0jQ09ORklHX0lFRUU4MDIxMVc9eQorQ09ORklHX0lFRUU4MDIxMVc9eQogCiAjIFNlbGVjdCBUTFMgaW1wbGVtZW50YXRpb24KICMgb3BlbnNzbCA9IE9wZW5TU0wgKGRlZmF1bHQpCkBAIC00MDMsNyArMzQ2LDcgQEAKICNDT05GSUdfRFlOQU1JQ19FQVBfTUVUSE9EUz15CiAKICMgSUVFRSBTdGQgODAyLjExci0yMDA4IChGYXN0IEJTUyBUcmFuc2l0aW9uKQotI0NPTkZJR19JRUVFODAyMTFSPXkKK0NPTkZJR19JRUVFODAyMTFSPXkKIAogIyBBZGQgc3VwcG9ydCBmb3Igd3JpdGluZyBkZWJ1ZyBsb2cgdG8gYSBmaWxlICgvdG1wL3dwYV9zdXBwbGljYW50LWxvZy0jLnR4dCkKICNDT05GSUdfREVCVUdfRklMRT15CkBAIC00ODQsMTYgKzQyNywxNiBAQAogCiAjIFdpcmVsZXNzIE5ldHdvcmsgTWFuYWdlbWVudCAoSUVFRSBTdGQgODAyLjExdi0yMDExKQogIyBOb3RlOiBUaGlzIGlzIGV4cGVyaW1lbnRhbCBhbmQgbm90IGNvbXBsZXRlIGltcGxlbWVudGF0aW9uLgotI0NPTkZJR19XTk09eQorQ09ORklHX1dOTT15CiAKICMgSW50ZXJ3b3JraW5nIChJRUVFIDgwMi4xMXUpCiAjIFRoaXMgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIGZ1bmN0aW9uYWxpdHkgdG8gaW1wcm92ZSBpbnRlcndvcmtpbmcgd2l0aAogIyBleHRlcm5hbCBuZXR3b3JrcyAoR0FTL0FOUVAgdG8gbGVhcm4gbW9yZSBhYm91dCB0aGUgbmV0d29ya3MgYW5kIG5ldHdvcmsKICMgc2VsZWN0aW9uIGJhc2VkIG9uIGF2YWlsYWJsZSBjcmVkZW50aWFscykuCi0jQ09ORklHX0lOVEVSV09SS0lORz15CitDT05GSUdfSU5URVJXT1JLSU5HPXkKIAogIyBIb3RzcG90IDIuMAotI0NPTkZJR19IUzIwPXkKK0NPTkZJR19IUzIwPXkKIAogIyBEaXNhYmxlIHJvYW1pbmcgaW4gd3BhX3N1cHBsaWNhbnQKIENPTkZJR19OT19ST0FNSU5HPXkKQEAgLTUxMCwxNCArNDUzLDE3IEBACiAjIG1vcmUgaW5mb3JtYXRpb24gb24gUDJQIG9wZXJhdGlvbnMuCiBDT05GSUdfUDJQPXkKIAorIyBFbmFibGUgVERMUyBzdXBwb3J0CiBDT05GSUdfVERMUz15CiAKLSNFbmFibGUgV2lmaSBEaXNwbGF5CisjIFdpLUZpIERpcmVjdAorIyBUaGlzIGNhbiBiZSB1c2VkIHRvIGVuYWJsZSBXaS1GaSBEaXJlY3QgZXh0ZW5zaW9ucyBmb3IgUDJQIHVzaW5nIGFuIGV4dGVybmFsCisjIHByb2dyYW0gdG8gY29udHJvbCB0aGUgYWRkaXRpb25hbCBpbmZvcm1hdGlvbiBleGNoYW5nZXMgaW4gdGhlIG1lc3NhZ2VzLgogQ09ORklHX1dJRklfRElTUExBWT15CiAKICMgQXV0b3NjYW4KICMgVGhpcyBjYW4gYmUgdXNlZCB0byBlbmFibGUgYXV0b21hdGljIHNjYW4gc3VwcG9ydCBpbiB3cGFfc3VwcGxpY2FudC4KLSOgU2VlIHdwYV9zdXBwbGljYW50LmNvbmYgZm9yIG1vcmUgaW5mb3JtYXRpb24gb24gYXV0b3NjYW4gdXNhZ2UuCisjIFNlZSB3cGFfc3VwcGxpY2FudC5jb25mIGZvciBtb3JlIGluZm9ybWF0aW9uIG9uIGF1dG9zY2FuIHVzYWdlLgogIwogIyBFbmFibGluZyBkaXJlY3RseSBhIG1vZHVsZSB3aWxsIGVuYWJsZSBhdXRvc2NhbiBzdXBwb3J0LgogIyBGb3IgZXhwb25lbnRpYWwgbW9kdWxlOgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvYXAuYyBiL3dwYV9zdXBwbGljYW50L2FwLmMKaW5kZXggZmRiZTI0OC4uZjlhYTgwNyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvYXAuYworKysgYi93cGFfc3VwcGxpY2FudC9hcC5jCkBAIC0xNSw2ICsxNSw3IEBACiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgImVhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5oIgorI2luY2x1ZGUgImNyeXB0by9kaF9ncm91cDUuaCIKICNpbmNsdWRlICJhcC9ob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXAvYXBfY29uZmlnLmgiCiAjaW5jbHVkZSAiYXAvYXBfZHJ2X29wcy5oIgpAQCAtNDIsMTEgKzQzLDQzIEBACiAjZW5kaWYgLyogQ09ORklHX1dQUyAqLwogCiAKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExTgorc3RhdGljIHZvaWQgd3Bhc19jb25mX2FwX3ZodChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJICAgICBzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmNvbmYsCisJCQkgICAgIHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlKQoreworI2lmZGVmIENPTkZJR19QMlAKKwl1OCBjZW50ZXJfY2hhbiA9IDA7CisJdTggY2hhbm5lbCA9IGNvbmYtPmNoYW5uZWw7CisKKwlpZiAoIWNvbmYtPnNlY29uZGFyeV9jaGFubmVsKQorCQlnb3RvIG5vX3ZodDsKKworCWNlbnRlcl9jaGFuID0gd3Bhc19wMnBfZ2V0X3ZodDgwX2NlbnRlcih3cGFfcywgbW9kZSwgY2hhbm5lbCk7CisJaWYgKCFjZW50ZXJfY2hhbikKKwkJZ290byBub192aHQ7CisKKwkvKiBVc2UgODAgTUh6IGNoYW5uZWwgKi8KKwljb25mLT52aHRfb3Blcl9jaHdpZHRoID0gMTsKKwljb25mLT52aHRfb3Blcl9jZW50cl9mcmVxX3NlZzBfaWR4ID0gY2VudGVyX2NoYW47CisJcmV0dXJuOworCitub192aHQ6CisJY29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9CisJCWNoYW5uZWwgKyBjb25mLT5zZWNvbmRhcnlfY2hhbm5lbCAqIDI7CisjZWxzZSAvKiBDT05GSUdfUDJQICovCisJY29uZi0+dmh0X29wZXJfY2VudHJfZnJlcV9zZWcwX2lkeCA9CisJCWNvbmYtPmNoYW5uZWwgKyBjb25mLT5zZWNvbmRhcnlfY2hhbm5lbCAqIDI7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFOICovCisKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jb25mX2FwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsCiAJCQkJICBzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmNvbmYpCiB7Ci0Jc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzID0gJmNvbmYtPmJzc1swXTsKKwlzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MgPSBjb25mLT5ic3NbMF07CiAKIAljb25mLT5kcml2ZXIgPSB3cGFfcy0+ZHJpdmVyOwogCkBAIC0xMTQsNiArMTQ3LDExIEBACiAJCQkJIEhUX0NBUF9JTkZPX1NIT1JUX0dJNDBNSFogfAogCQkJCSBIVF9DQVBfSU5GT19SWF9TVEJDX01BU0sgfAogCQkJCSBIVF9DQVBfSU5GT19NQVhfQU1TRFVfU0laRSk7CisKKwkJCWlmIChtb2RlLT52aHRfY2FwYWIgJiYgc3NpZC0+dmh0KSB7CisJCQkJY29uZi0+aWVlZTgwMjExYWMgPSAxOworCQkJCXdwYXNfY29uZl9hcF92aHQod3BhX3MsIGNvbmYsIG1vZGUpOworCQkJfQogCQl9CiAJfQogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFOICovCkBAIC0xNDksNiArMTg3LDE2IEBACiAKIAlic3MtPmlzb2xhdGUgPSAhd3BhX3MtPmNvbmYtPnAycF9pbnRyYV9ic3M7CiAJYnNzLT5mb3JjZV9wZXJfZW5yb2xsZWVfcHNrID0gd3BhX3MtPmdsb2JhbC0+cDJwX3Blcl9zdGFfcHNrOworCisJaWYgKHNzaWQtPnAycF9ncm91cCkgeworCQlvc19tZW1jcHkoYnNzLT5pcF9hZGRyX2dvLCB3cGFfcy0+cGFyZW50LT5jb25mLT5pcF9hZGRyX2dvLCA0KTsKKwkJb3NfbWVtY3B5KGJzcy0+aXBfYWRkcl9tYXNrLCB3cGFfcy0+cGFyZW50LT5jb25mLT5pcF9hZGRyX21hc2ssCisJCQkgIDQpOworCQlvc19tZW1jcHkoYnNzLT5pcF9hZGRyX3N0YXJ0LAorCQkJICB3cGFfcy0+cGFyZW50LT5jb25mLT5pcF9hZGRyX3N0YXJ0LCA0KTsKKwkJb3NfbWVtY3B5KGJzcy0+aXBfYWRkcl9lbmQsIHdwYV9zLT5wYXJlbnQtPmNvbmYtPmlwX2FkZHJfZW5kLAorCQkJICA0KTsKKwl9CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAJaWYgKHNzaWQtPnNzaWRfbGVuID09IDApIHsKQEAgLTI0NCw3ICsyOTIsOSBAQAogCiAJaWYgKGJzcy0+d3BhX2dyb3VwX3Jla2V5IDwgODY0MDAgJiYgKGJzcy0+d3BhICYgMikgJiYKIAkgICAgKGJzcy0+d3BhX2dyb3VwID09IFdQQV9DSVBIRVJfQ0NNUCB8fAotCSAgICAgYnNzLT53cGFfZ3JvdXAgPT0gV1BBX0NJUEhFUl9HQ01QKSkgeworCSAgICAgYnNzLT53cGFfZ3JvdXAgPT0gV1BBX0NJUEhFUl9HQ01QIHx8CisJICAgICBic3MtPndwYV9ncm91cCA9PSBXUEFfQ0lQSEVSX0NDTVBfMjU2IHx8CisJICAgICBic3MtPndwYV9ncm91cCA9PSBXUEFfQ0lQSEVSX0dDTVBfMjU2KSkgewogCQkvKgogCQkgKiBTdHJvbmcgY2lwaGVycyBkbyBub3QgbmVlZCBmcmVxdWVudCByZWtleWluZywgc28gaW5jcmVhc2UKIAkJICogdGhlIGRlZmF1bHQgR1RLIHJla2V5aW5nIHBlcmlvZCB0byAyNCBob3Vycy4KQEAgLTI1Miw2ICszMDIsMTEgQEAKIAkJYnNzLT53cGFfZ3JvdXBfcmVrZXkgPSA4NjQwMDsKIAl9CiAKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExVworCWlmIChzc2lkLT5pZWVlODAyMTF3ICE9IE1HTVRfRlJBTUVfUFJPVEVDVElPTl9ERUZBVUxUKQorCQlic3MtPmllZWU4MDIxMXcgPSBzc2lkLT5pZWVlODAyMTF3OworI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCisKICNpZmRlZiBDT05GSUdfV1BTCiAJLyoKIAkgKiBFbmFibGUgV1BTIGJ5IGRlZmF1bHQgZm9yIG9wZW4gYW5kIFdQQS9XUEEyLVBlcnNvbmFsIG5ldHdvcmssIGJ1dApAQCAtMjYxLDEyICszMTYsMTAgQEAKIAlpZiAoYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSAhPSBTRUNVUklUWV9XUEFfUFNLICYmCiAJICAgIGJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgIT0gU0VDVVJJVFlfUExBSU5URVhUKQogCQlnb3RvIG5vX3dwczsKLSNpZmRlZiBDT05GSUdfV1BTMgogCWlmIChic3MtPnNzaWQuc2VjdXJpdHlfcG9saWN5ID09IFNFQ1VSSVRZX1dQQV9QU0sgJiYKIAkgICAgKCEoYnNzLT5yc25fcGFpcndpc2UgJiBXUEFfQ0lQSEVSX0NDTVApIHx8ICEoYnNzLT53cGEgJiAyKSkpCiAJCWdvdG8gbm9fd3BzOyAvKiBXUFMyIGRvZXMgbm90IGFsbG93IFdQQS9US0lQLW9ubHkKIAkJCSAgICAgICogY29uZmlndXJhdGlvbiAqLwotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAJYnNzLT5lYXBfc2VydmVyID0gMTsKIAogCWlmICghc3NpZC0+aWdub3JlX2Jyb2FkY2FzdF9zc2lkKQpAQCAtMzIwLDE2ICszNzMsMTYgQEAKICNpZmRlZiBDT05GSUdfUDJQCiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKIAljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7Ci0Jc2l6ZV90IGhkcl9sZW47CiAKIAltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBidWY7Ci0JaGRyX2xlbiA9IChjb25zdCB1OCAqKSAmbWdtdC0+dS5hY3Rpb24udS52c19wdWJsaWNfYWN0aW9uLmFjdGlvbiAtIGJ1ZjsKLQlpZiAoaGRyX2xlbiA+IGxlbikKKwlpZiAobGVuIDwgSUVFRTgwMjExX0hEUkxFTiArIDEpCisJCXJldHVybjsKKwlpZiAobWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgIT0gV0xBTl9BQ1RJT05fUFVCTElDKQogCQlyZXR1cm47CiAJd3Bhc19wMnBfcnhfYWN0aW9uKHdwYV9zLCBtZ210LT5kYSwgbWdtdC0+c2EsIG1nbXQtPmJzc2lkLAogCQkJICAgbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnksCi0JCQkgICAmbWdtdC0+dS5hY3Rpb24udS52c19wdWJsaWNfYWN0aW9uLmFjdGlvbiwKLQkJCSAgIGxlbiAtIGhkcl9sZW4sIGZyZXEpOworCQkJICAgYnVmICsgSUVFRTgwMjExX0hEUkxFTiArIDEsCisJCQkgICBsZW4gLSBJRUVFODAyMTFfSERSTEVOIC0gMSwgZnJlcSk7CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogfQogCkBAIC0zODUsMTYgKzQzOCwxNCBAQAogI2lmZGVmIENPTkZJR19QMlAKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKLQlzaXplX3QgaGRyX2xlbjsKIAogCW1nbXQgPSAoY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICopIGJ1ZjsKLQloZHJfbGVuID0gKGNvbnN0IHU4ICopICZtZ210LT51LmFjdGlvbi51LnZzX3B1YmxpY19hY3Rpb24uYWN0aW9uIC0gYnVmOwotCWlmIChoZHJfbGVuID4gbGVuKQorCWlmIChsZW4gPCBJRUVFODAyMTFfSERSTEVOICsgMSkKIAkJcmV0dXJuIC0xOwogCXdwYXNfcDJwX3J4X2FjdGlvbih3cGFfcywgbWdtdC0+ZGEsIG1nbXQtPnNhLCBtZ210LT5ic3NpZCwKIAkJCSAgIG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5LAotCQkJICAgJm1nbXQtPnUuYWN0aW9uLnUudnNfcHVibGljX2FjdGlvbi5hY3Rpb24sCi0JCQkgICBsZW4gLSBoZHJfbGVuLCBmcmVxKTsKKwkJCSAgIGJ1ZiArIElFRUU4MDIxMV9IRFJMRU4gKyAxLAorCQkJICAgbGVuIC0gSUVFRTgwMjExX0hEUkxFTiAtIDEsIGZyZXEpOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAlyZXR1cm4gMDsKIH0KQEAgLTQwNCwyMyArNDU1LDE3IEBACiAJCQkgICBjb25zdCB1OCAqYnNzaWQsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwKIAkJCSAgIGludCBzc2lfc2lnbmFsKQogewotI2lmZGVmIENPTkZJR19QMlAKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCXJldHVybiB3cGFzX3AycF9wcm9iZV9yZXFfcngod3BhX3MsIHNhLCBkYSwgYnNzaWQsIGllLCBpZV9sZW4sCiAJCQkJICAgICBzc2lfc2lnbmFsKTsKLSNlbHNlIC8qIENPTkZJR19QMlAgKi8KLQlyZXR1cm4gMDsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCiB9CiAKIAogc3RhdGljIHZvaWQgYXBfd3BzX3JlZ19zdWNjZXNzX2NiKHZvaWQgKmN0eCwgY29uc3QgdTggKm1hY19hZGRyLAogCQkJCSAgY29uc3QgdTggKnV1aWRfZSkKIHsKLSNpZmRlZiBDT05GSUdfUDJQCiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKIAl3cGFzX3AycF93cHNfc3VjY2Vzcyh3cGFfcywgbWFjX2FkZHIsIDEpOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIH0KIAogCkBAIC00NTgsMTcgKzUwMywxMyBAQAogCXBhcmFtcy5zc2lkID0gc3NpZC0+c3NpZDsKIAlwYXJhbXMuc3NpZF9sZW4gPSBzc2lkLT5zc2lkX2xlbjsKIAlzd2l0Y2ggKHNzaWQtPm1vZGUpIHsKLQljYXNlIFdQQVNfTU9ERV9JTkZSQToKLQkJcGFyYW1zLm1vZGUgPSBJRUVFODAyMTFfTU9ERV9JTkZSQTsKLQkJYnJlYWs7Ci0JY2FzZSBXUEFTX01PREVfSUJTUzoKLQkJcGFyYW1zLm1vZGUgPSBJRUVFODAyMTFfTU9ERV9JQlNTOwotCQlicmVhazsKIAljYXNlIFdQQVNfTU9ERV9BUDoKIAljYXNlIFdQQVNfTU9ERV9QMlBfR086CiAJY2FzZSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTjoKIAkJcGFyYW1zLm1vZGUgPSBJRUVFODAyMTFfTU9ERV9BUDsKIAkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0dXJuIC0xOwogCX0KIAlpZiAoc3NpZC0+ZnJlcXVlbmN5ID09IDApCiAJCXNzaWQtPmZyZXF1ZW5jeSA9IDI0NjI7IC8qIGRlZmF1bHQgY2hhbm5lbCAxMSAqLwpAQCAtNDc5LDcgKzUyMCw3IEBACiAJCXdwYV9zLT5rZXlfbWdtdCA9IFdQQV9LRVlfTUdNVF9QU0s7CiAJZWxzZQogCQl3cGFfcy0+a2V5X21nbXQgPSBXUEFfS0VZX01HTVRfTk9ORTsKLQlwYXJhbXMua2V5X21nbXRfc3VpdGUgPSBrZXlfbWdtdDJkcml2ZXIod3BhX3MtPmtleV9tZ210KTsKKwlwYXJhbXMua2V5X21nbXRfc3VpdGUgPSB3cGFfcy0+a2V5X21nbXQ7CiAKIAl3cGFfcy0+cGFpcndpc2VfY2lwaGVyID0gd3BhX3BpY2tfcGFpcndpc2VfY2lwaGVyKHNzaWQtPnBhaXJ3aXNlX2NpcGhlciwKIAkJCQkJCQkgIDEpOwpAQCAtNDg4LDggKzUyOSw3IEBACiAJCQkgICAiY2lwaGVyLiIpOwogCQlyZXR1cm4gLTE7CiAJfQotCXBhcmFtcy5wYWlyd2lzZV9zdWl0ZSA9Ci0JCXdwYV9jaXBoZXJfdG9fc3VpdGVfZHJpdmVyKHdwYV9zLT5wYWlyd2lzZV9jaXBoZXIpOworCXBhcmFtcy5wYWlyd2lzZV9zdWl0ZSA9IHdwYV9zLT5wYWlyd2lzZV9jaXBoZXI7CiAJcGFyYW1zLmdyb3VwX3N1aXRlID0gcGFyYW1zLnBhaXJ3aXNlX3N1aXRlOwogCiAjaWZkZWYgQ09ORklHX1AyUApAQCAtNTAwLDYgKzU0MCw4IEBACiAKIAlpZiAod3BhX3MtPnBhcmVudC0+c2V0X2FwX3VhcHNkKQogCQlwYXJhbXMudWFwc2QgPSB3cGFfcy0+cGFyZW50LT5hcF91YXBzZDsKKwllbHNlIGlmIChwYXJhbXMucDJwICYmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19BUF9VQVBTRCkpCisJCXBhcmFtcy51YXBzZCA9IDE7IC8qIG1hbmRhdG9yeSBmb3IgUDJQIEdPICovCiAJZWxzZQogCQlwYXJhbXMudWFwc2QgPSAtMTsKIApAQCAtNTI5LDggKzU3MSw4IEBACiAJCSAgc2l6ZW9mKHdwYV9zLT5jb25mLT53bW1fYWNfcGFyYW1zKSk7CiAKIAlpZiAocGFyYW1zLnVhcHNkID4gMCkgewotCQljb25mLT5ic3MtPndtbV9lbmFibGVkID0gMTsKLQkJY29uZi0+YnNzLT53bW1fdWFwc2QgPSAxOworCQljb25mLT5ic3NbMF0tPndtbV9lbmFibGVkID0gMTsKKwkJY29uZi0+YnNzWzBdLT53bW1fdWFwc2QgPSAxOwogCX0KIAogCWlmICh3cGFfc3VwcGxpY2FudF9jb25mX2FwKHdwYV9zLCBzc2lkLCBjb25mKSkgewpAQCAtNTQxLDkgKzU4Myw5IEBACiAKICNpZmRlZiBDT05GSUdfUDJQCiAJaWYgKHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX1AyUF9HTykKLQkJY29uZi0+YnNzWzBdLnAycCA9IFAyUF9FTkFCTEVEIHwgUDJQX0dST1VQX09XTkVSOworCQljb25mLT5ic3NbMF0tPnAycCA9IFAyUF9FTkFCTEVEIHwgUDJQX0dST1VQX09XTkVSOwogCWVsc2UgaWYgKHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX1AyUF9HUk9VUF9GT1JNQVRJT04pCi0JCWNvbmYtPmJzc1swXS5wMnAgPSBQMlBfRU5BQkxFRCB8IFAyUF9HUk9VUF9PV05FUiB8CisJCWNvbmYtPmJzc1swXS0+cDJwID0gUDJQX0VOQUJMRUQgfCBQMlBfR1JPVVBfT1dORVIgfAogCQkJUDJQX0dST1VQX0ZPUk1BVElPTjsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKQEAgLTU1OCw3ICs2MDAsNyBAQAogCWZvciAoaSA9IDA7IGkgPCBjb25mLT5udW1fYnNzOyBpKyspIHsKIAkJaGFwZF9pZmFjZS0+YnNzW2ldID0KIAkJCWhvc3RhcGRfYWxsb2NfYnNzX2RhdGEoaGFwZF9pZmFjZSwgY29uZiwKLQkJCQkJICAgICAgICZjb25mLT5ic3NbaV0pOworCQkJCQkgICAgICAgY29uZi0+YnNzW2ldKTsKIAkJaWYgKGhhcGRfaWZhY2UtPmJzc1tpXSA9PSBOVUxMKSB7CiAJCQl3cGFfc3VwcGxpY2FudF9hcF9kZWluaXQod3BhX3MpOwogCQkJcmV0dXJuIC0xOwpAQCAtNjIwLDExICs2NjIsMTAgQEAKIAl3cGFfcy0+Y3VycmVudF9zc2lkID0gTlVMTDsKIAllYXBvbF9zbV9ub3RpZnlfY29uZmlnKHdwYV9zLT5lYXBvbCwgTlVMTCwgTlVMTCk7CiAJd3BhX3MtPmFzc29jX2ZyZXEgPSAwOwotI2lmZGVmIENPTkZJR19QMlAKLQlpZiAod3BhX3MtPmFwX2lmYWNlLT5ic3MpCi0JCXdwYV9zLT5hcF9pZmFjZS0+YnNzWzBdLT5wMnBfZ3JvdXAgPSBOVUxMOwotCXdwYXNfcDJwX2dyb3VwX2RlaW5pdCh3cGFfcyk7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLworCXdwYXNfcDJwX2FwX2RlaW5pdCh3cGFfcyk7CisJd3BhX3MtPmFwX2lmYWNlLT5kcml2ZXJfYXBfdGVhcmRvd24gPQorCQkhISh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19BUF9URUFSRE9XTl9TVVBQT1JUKTsKKwogCWhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdCh3cGFfcy0+YXBfaWZhY2UpOwogCWhvc3RhcGRfaW50ZXJmYWNlX2ZyZWUod3BhX3MtPmFwX2lmYWNlKTsKIAl3cGFfcy0+YXBfaWZhY2UgPSBOVUxMOwpAQCAtNjQ3LDYgKzY4OCw4IEBACiB7CiAjaWZkZWYgTkVFRF9BUF9NTE1FCiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKKwlpZiAoIXdwYV9zLT5hcF9pZmFjZSkKKwkJcmV0dXJuOwogCWhvc3RhcGRfdHhfc3RhdHVzKHdwYV9zLT5hcF9pZmFjZS0+YnNzWzBdLCBkc3QsIGRhdGEsIGxlbiwgYWNrKTsKICNlbmRpZiAvKiBORUVEX0FQX01MTUUgKi8KIH0KQEAgLTkwOSw2ICs5NTIsMTkgQEAKIAlyZXR1cm4gaG9zdGFwZF93cHNfbmZjX2hzX2NyKGhhcGQsIG5kZWYpOwogfQogCisKK2ludCB3cGFzX2FwX3dwc19uZmNfcmVwb3J0X2hhbmRvdmVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnJlcSwKKwkJCQkgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqc2VsKQoreworCXN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQ7CisKKwlpZiAod3BhX3MtPmFwX2lmYWNlID09IE5VTEwpCisJCXJldHVybiAtMTsKKwloYXBkID0gd3BhX3MtPmFwX2lmYWNlLT5ic3NbMF07CisJcmV0dXJuIGhvc3RhcGRfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIoaGFwZCwgcmVxLCBzZWwpOworfQorCiAjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KIAogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KQEAgLTEwMTAsOSArMTA2Niw5IEBACiAKICNpZmRlZiBDT05GSUdfUDJQCiAJaWYgKHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX1AyUF9HTykKLQkJaWZhY2UtPmNvbmYtPmJzc1swXS5wMnAgPSBQMlBfRU5BQkxFRCB8IFAyUF9HUk9VUF9PV05FUjsKKwkJaWZhY2UtPmNvbmYtPmJzc1swXS0+cDJwID0gUDJQX0VOQUJMRUQgfCBQMlBfR1JPVVBfT1dORVI7CiAJZWxzZSBpZiAoc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTikKLQkJaWZhY2UtPmNvbmYtPmJzc1swXS5wMnAgPSBQMlBfRU5BQkxFRCB8IFAyUF9HUk9VUF9PV05FUiB8CisJCWlmYWNlLT5jb25mLT5ic3NbMF0tPnAycCA9IFAyUF9FTkFCTEVEIHwgUDJQX0dST1VQX09XTkVSIHwKIAkJCVAyUF9HUk9VUF9GT1JNQVRJT047CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCkBAIC0xMDI2LDE0ICsxMDgyLDQwIEBACiB9CiAKIAoraW50IGFwX3N3aXRjaF9jaGFubmVsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCSAgICAgIHN0cnVjdCBjc2Ffc2V0dGluZ3MgKnNldHRpbmdzKQoreworI2lmZGVmIE5FRURfQVBfTUxNRQorCWlmICghd3BhX3MtPmFwX2lmYWNlIHx8ICF3cGFfcy0+YXBfaWZhY2UtPmJzc1swXSkKKwkJcmV0dXJuIC0xOworCisJcmV0dXJuIGhvc3RhcGRfc3dpdGNoX2NoYW5uZWwod3BhX3MtPmFwX2lmYWNlLT5ic3NbMF0sIHNldHRpbmdzKTsKKyNlbHNlIC8qIE5FRURfQVBfTUxNRSAqLworCXJldHVybiAtMTsKKyNlbmRpZiAvKiBORUVEX0FQX01MTUUgKi8KK30KKworCitpbnQgYXBfY3RybF9pZmFjZV9jaGFuc3dpdGNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKnBvcykKK3sKKwlzdHJ1Y3QgY3NhX3NldHRpbmdzIHNldHRpbmdzOworCWludCByZXQgPSBob3N0YXBkX3BhcnNlX2NzYV9zZXR0aW5ncyhwb3MsICZzZXR0aW5ncyk7CisKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJcmV0dXJuIGFwX3N3aXRjaF9jaGFubmVsKHdwYV9zLCAmc2V0dGluZ3MpOworfQorCisKIHZvaWQgd3Bhc19hcF9jaF9zd2l0Y2goc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEsIGludCBodCwKLQkJICAgICAgIGludCBvZmZzZXQpCisJCSAgICAgICBpbnQgb2Zmc2V0LCBpbnQgd2lkdGgsIGludCBjZjEsIGludCBjZjIpCiB7CiAJaWYgKCF3cGFfcy0+YXBfaWZhY2UpCiAJCXJldHVybjsKIAogCXdwYV9zLT5hc3NvY19mcmVxID0gZnJlcTsKLQlob3N0YXBkX2V2ZW50X2NoX3N3aXRjaCh3cGFfcy0+YXBfaWZhY2UtPmJzc1swXSwgZnJlcSwgaHQsIG9mZnNldCk7CisJaG9zdGFwZF9ldmVudF9jaF9zd2l0Y2god3BhX3MtPmFwX2lmYWNlLT5ic3NbMF0sIGZyZXEsIGh0LCBvZmZzZXQsIHdpZHRoLCBjZjEsIGNmMSk7CiB9CiAKIApAQCAtMTA3NiwzICsxMTU4LDQ4IEBACiAKIAlyZXR1cm4gMDsKIH0KKworCisjaWZkZWYgQ09ORklHX1dQU19ORkMKK2ludCB3cGFzX2FwX3dwc19hZGRfbmZjX3B3KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHUxNiBwd19pZCwKKwkJCSAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnB3LCBjb25zdCB1OCAqcHVia2V5X2hhc2gpCit7CisJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZDsKKwlzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwczsKKworCWlmICghd3BhX3MtPmFwX2lmYWNlKQorCQlyZXR1cm4gLTE7CisJaGFwZCA9IHdwYV9zLT5hcF9pZmFjZS0+YnNzWzBdOworCXdwcyA9IGhhcGQtPndwczsKKworCWlmICh3cGFfcy0+cGFyZW50LT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSA9PSBOVUxMIHx8CisJICAgIHdwYV9zLT5wYXJlbnQtPmNvbmYtPndwc19uZmNfZGhfcHJpdmtleSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBObyBORkMgREgga2V5IGtub3duIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlkaDVfZnJlZSh3cHMtPmRoX2N0eCk7CisJd3BhYnVmX2ZyZWUod3BzLT5kaF9wdWJrZXkpOworCXdwYWJ1Zl9mcmVlKHdwcy0+ZGhfcHJpdmtleSk7CisJd3BzLT5kaF9wcml2a2V5ID0gd3BhYnVmX2R1cCgKKwkJd3BhX3MtPnBhcmVudC0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5KTsKKwl3cHMtPmRoX3B1YmtleSA9IHdwYWJ1Zl9kdXAoCisJCXdwYV9zLT5wYXJlbnQtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5KTsKKwlpZiAod3BzLT5kaF9wcml2a2V5ID09IE5VTEwgfHwgd3BzLT5kaF9wdWJrZXkgPT0gTlVMTCkgeworCQl3cHMtPmRoX2N0eCA9IE5VTEw7CisJCXdwYWJ1Zl9mcmVlKHdwcy0+ZGhfcHVia2V5KTsKKwkJd3BzLT5kaF9wdWJrZXkgPSBOVUxMOworCQl3cGFidWZfZnJlZSh3cHMtPmRoX3ByaXZrZXkpOworCQl3cHMtPmRoX3ByaXZrZXkgPSBOVUxMOworCQlyZXR1cm4gLTE7CisJfQorCXdwcy0+ZGhfY3R4ID0gZGg1X2luaXRfZml4ZWQod3BzLT5kaF9wcml2a2V5LCB3cHMtPmRoX3B1YmtleSk7CisJaWYgKHdwcy0+ZGhfY3R4ID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXJldHVybiB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcHdfdG9rZW4oaGFwZC0+d3BzLT5yZWdpc3RyYXIsIHB1YmtleV9oYXNoLAorCQkJCQkgICAgICBwd19pZCwKKwkJCQkJICAgICAgcHcgPyB3cGFidWZfaGVhZChwdykgOiBOVUxMLAorCQkJCQkgICAgICBwdyA/IHdwYWJ1Zl9sZW4ocHcpIDogMCwgMSk7Cit9CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2FwLmggYi93cGFfc3VwcGxpY2FudC9hcC5oCmluZGV4IDc0YTBiMTguLjhhYTVmZmEgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2FwLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvYXAuaApAQCAtNTAsOCArNTAsMTEgQEAKIGludCB3cGFfc3VwcGxpY2FudF9hcF9tYWNfYWRkcl9maWx0ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgICBjb25zdCB1OCAqYWRkcik7CiB2b2lkIHdwYV9zdXBwbGljYW50X2FwX3B3ZF9hdXRoX2ZhaWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CitpbnQgYXBfc3dpdGNoX2NoYW5uZWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJICAgICAgc3RydWN0IGNzYV9zZXR0aW5ncyAqc2V0dGluZ3MpOworaW50IGFwX2N0cmxfaWZhY2VfY2hhbnN3aXRjaChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCBjaGFyICp0eHRhZGRyKTsKIHZvaWQgd3Bhc19hcF9jaF9zd2l0Y2goc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEsIGludCBodCwKLQkJICAgICAgIGludCBvZmZzZXQpOworCQkgICAgICAgaW50IG9mZnNldCwgaW50IHdpZHRoLCBpbnQgY2YxLCBpbnQgY2YyKTsKIHN0cnVjdCB3cGFidWYgKiB3cGFzX2FwX3dwc19uZmNfY29uZmlnX3Rva2VuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSAgICAgaW50IG5kZWYpOwogI2lmZGVmIENPTkZJR19BUApAQCAtNjYsNCArNjksMTAgQEAKIH0KICNlbmRpZiAvKiBDT05GSUdfQVAgKi8KIAoraW50IHdwYXNfYXBfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcmVxLAorCQkJCSAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpzZWwpOworaW50IHdwYXNfYXBfd3BzX2FkZF9uZmNfcHcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgdTE2IHB3X2lkLAorCQkJICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcHcsIGNvbnN0IHU4ICpwdWJrZXlfaGFzaCk7CisKICNlbmRpZiAvKiBBUF9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9iZ3NjYW4uYyBiL3dwYV9zdXBwbGljYW50L2Jnc2Nhbi5jCmluZGV4IDlhOWJkNTIuLmY3NGNkYmYgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2Jnc2Nhbi5jCisrKyBiL3dwYV9zdXBwbGljYW50L2Jnc2Nhbi5jCkBAIC0zMSw5ICszMSw5IEBACiB9OwogCiAKLWludCBiZ3NjYW5faW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCitpbnQgYmdzY2FuX2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9zc2lkICpzc2lkLAorCQljb25zdCBjaGFyICpuYW1lKQogewotCWNvbnN0IGNoYXIgKm5hbWUgPSBzc2lkLT5iZ3NjYW47CiAJY29uc3QgY2hhciAqcGFyYW1zOwogCXNpemVfdCBubGVuOwogCWludCBpOwpAQCAtNDEsNyArNDEsNyBAQAogCiAJYmdzY2FuX2RlaW5pdCh3cGFfcyk7CiAJaWYgKG5hbWUgPT0gTlVMTCkKLQkJcmV0dXJuIDA7CisJCXJldHVybiAtMTsKIAogCXBhcmFtcyA9IG9zX3N0cmNocihuYW1lLCAnOicpOwogCWlmIChwYXJhbXMgPT0gTlVMTCkgewpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvYmdzY2FuLmggYi93cGFfc3VwcGxpY2FudC9iZ3NjYW4uaAppbmRleCBlOWQxNWZjLi45MTMxZTRlIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9iZ3NjYW4uaAorKysgYi93cGFfc3VwcGxpY2FudC9iZ3NjYW4uaApAQCAtMjksNyArMjksOCBAQAogCiAjaWZkZWYgQ09ORklHX0JHU0NBTgogCi1pbnQgYmdzY2FuX2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9zc2lkICpzc2lkKTsKK2ludCBiZ3NjYW5faW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsCisJCWNvbnN0IGNoYXIgKm5hbWUpOwogdm9pZCBiZ3NjYW5fZGVpbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogaW50IGJnc2Nhbl9ub3RpZnlfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkgICAgICAgc3RydWN0IHdwYV9zY2FuX3Jlc3VsdHMgKnNjYW5fcmVzKTsKQEAgLTQxLDcgKzQyLDcgQEAKICNlbHNlIC8qIENPTkZJR19CR1NDQU4gKi8KIAogc3RhdGljIGlubGluZSBpbnQgYmdzY2FuX2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCSAgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKKwkJCSAgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCwgY29uc3QgY2hhciBuYW1lKQogewogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvYmdzY2FuX2xlYXJuLmMgYi93cGFfc3VwcGxpY2FudC9iZ3NjYW5fbGVhcm4uYwppbmRleCAwN2QzMWU0Li42YTkyYjczIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9iZ3NjYW5fbGVhcm4uYworKysgYi93cGFfc3VwcGxpY2FudC9iZ3NjYW5fbGVhcm4uYwpAQCAtMzQsNyArMzQsNyBAQAogCWludCBzaWduYWxfdGhyZXNob2xkOwogCWludCBzaG9ydF9pbnRlcnZhbDsgLyogdXNlIGlmIHNpZ25hbCA8IHRocmVzaG9sZCAqLwogCWludCBsb25nX2ludGVydmFsOyAvKiB1c2UgaWYgc2lnbmFsID4gdGhyZXNob2xkICovCi0Jc3RydWN0IG9zX3RpbWUgbGFzdF9iZ3NjYW47CisJc3RydWN0IG9zX3JlbHRpbWUgbGFzdF9iZ3NjYW47CiAJY2hhciAqZm5hbWU7CiAJc3RydWN0IGRsX2xpc3QgYnNzOwogCWludCAqc3VwcF9mcmVxczsKQEAgLTI0MCwxNyArMjQwLDE0IEBACiAJaWYgKGRhdGEtPnN1cHBfZnJlcXMgPT0gTlVMTCkKIAkJcmV0dXJuIGZyZXFzOwogCi0JaWR4ID0gZGF0YS0+cHJvYmVfaWR4ICsgMTsKLQl3aGlsZSAoaWR4ICE9IGRhdGEtPnByb2JlX2lkeCkgewotCQlpZiAoZGF0YS0+c3VwcF9mcmVxc1tpZHhdID09IDApIHsKLQkJCWlmIChkYXRhLT5wcm9iZV9pZHggPT0gMCkKLQkJCQlicmVhazsKLQkJCWlkeCA9IDA7Ci0JCX0KKwlpZHggPSBkYXRhLT5wcm9iZV9pZHg7CisJZG8gewogCQlpZiAoIWluX2FycmF5KGZyZXFzLCBkYXRhLT5zdXBwX2ZyZXFzW2lkeF0pKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImJnc2NhbiBsZWFybjogUHJvYmUgbmV3IGZyZXEgIgogCQkJCSAgICIldSIsIGRhdGEtPnN1cHBfZnJlcXNbaWR4XSk7Ci0JCQlkYXRhLT5wcm9iZV9pZHggPSBpZHg7CisJCQlkYXRhLT5wcm9iZV9pZHggPSBpZHggKyAxOworCQkJaWYgKGRhdGEtPnN1cHBfZnJlcXNbZGF0YS0+cHJvYmVfaWR4XSA9PSAwKQorCQkJCWRhdGEtPnByb2JlX2lkeCA9IDA7CiAJCQluID0gb3NfcmVhbGxvY19hcnJheShmcmVxcywgY291bnQgKyAyLCBzaXplb2YoaW50KSk7CiAJCQlpZiAobiA9PSBOVUxMKQogCQkJCXJldHVybiBmcmVxczsKQEAgLTI2Miw3ICsyNTksOSBAQAogCQl9CiAKIAkJaWR4Kys7Ci0JfQorCQlpZiAoZGF0YS0+c3VwcF9mcmVxc1tpZHhdID09IDApCisJCQlpZHggPSAwOworCX0gd2hpbGUgKGlkeCAhPSBkYXRhLT5wcm9iZV9pZHgpOwogCiAJcmV0dXJuIGZyZXFzOwogfQpAQCAtMzExLDcgKzMxMCw3IEBACiAJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoZGF0YS0+c2Nhbl9pbnRlcnZhbCwgMCwKIAkJCQkgICAgICAgYmdzY2FuX2xlYXJuX3RpbWVvdXQsIGRhdGEsIE5VTEwpOwogCX0gZWxzZQotCQlvc19nZXRfdGltZSgmZGF0YS0+bGFzdF9iZ3NjYW4pOworCQlvc19nZXRfcmVsdGltZSgmZGF0YS0+bGFzdF9iZ3NjYW4pOwogCW9zX2ZyZWUoZnJlcXMpOwogfQogCkBAIC0zNjMsNiArMzYyLDkgQEAKIAkJZm9yIChqID0gMDsgaiA8IG1vZGVzW2ldLm51bV9jaGFubmVsczsgaisrKSB7CiAJCQlpZiAobW9kZXNbaV0uY2hhbm5lbHNbal0uZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKIAkJCQljb250aW51ZTsKKwkJCS8qIHNvbWUgaHcgbW9kZXMgKGUuZy4gMTFiICYgMTFnKSBjb250YWluIHNhbWUgZnJlcXMgKi8KKwkJCWlmIChpbl9hcnJheShmcmVxcywgbW9kZXNbaV0uY2hhbm5lbHNbal0uZnJlcSkpCisJCQkJY29udGludWU7CiAJCQluID0gb3NfcmVhbGxvY19hcnJheShmcmVxcywgY291bnQgKyAyLCBzaXplb2YoaW50KSk7CiAJCQlpZiAobiA9PSBOVUxMKQogCQkJCWNvbnRpbnVlOwpAQCAtNDE5LDYgKzQyMSwxNCBAQAogCiAJZGF0YS0+c3VwcF9mcmVxcyA9IGJnc2Nhbl9sZWFybl9nZXRfc3VwcF9mcmVxcyh3cGFfcyk7CiAJZGF0YS0+c2Nhbl9pbnRlcnZhbCA9IGRhdGEtPnNob3J0X2ludGVydmFsOworCWlmIChkYXRhLT5zaWduYWxfdGhyZXNob2xkKSB7CisJCS8qIFBvbGwgZm9yIHNpZ25hbCBpbmZvIHRvIHNldCBpbml0aWFsIHNjYW4gaW50ZXJ2YWwgKi8KKwkJc3RydWN0IHdwYV9zaWduYWxfaW5mbyBzaWdpbmZvOworCQlpZiAod3BhX2Rydl9zaWduYWxfcG9sbCh3cGFfcywgJnNpZ2luZm8pID09IDAgJiYKKwkJICAgIHNpZ2luZm8uY3VycmVudF9zaWduYWwgPj0gZGF0YS0+c2lnbmFsX3RocmVzaG9sZCkKKwkJCWRhdGEtPnNjYW5faW50ZXJ2YWwgPSBkYXRhLT5sb25nX2ludGVydmFsOworCX0KKwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoZGF0YS0+c2Nhbl9pbnRlcnZhbCwgMCwgYmdzY2FuX2xlYXJuX3RpbWVvdXQsCiAJCQkgICAgICAgZGF0YSwgTlVMTCk7CiAKQEAgLTQyOCw3ICs0MzgsNyBAQAogCSAqIHVzIHNraXAgYW4gaW1tZWRpYXRlIG5ldyBzY2FuIGluIGNhc2VzIHdoZXJlIHRoZSBjdXJyZW50IHNpZ25hbAogCSAqIGxldmVsIGlzIGJlbG93IHRoZSBiZ3NjYW4gdGhyZXNob2xkLgogCSAqLwotCW9zX2dldF90aW1lKCZkYXRhLT5sYXN0X2Jnc2Nhbik7CisJb3NfZ2V0X3JlbHRpbWUoJmRhdGEtPmxhc3RfYmdzY2FuKTsKIAogCXJldHVybiBkYXRhOwogfQpAQCAtNTU1LDcgKzU2NSw3IEBACiB7CiAJc3RydWN0IGJnc2Nhbl9sZWFybl9kYXRhICpkYXRhID0gcHJpdjsKIAlpbnQgc2NhbiA9IDA7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAogCWlmIChkYXRhLT5zaG9ydF9pbnRlcnZhbCA9PSBkYXRhLT5sb25nX2ludGVydmFsIHx8CiAJICAgIGRhdGEtPnNpZ25hbF90aHJlc2hvbGQgPT0gMCkKQEAgLTU2OSw3ICs1NzksNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImJnc2NhbiBsZWFybjogU3RhcnQgdXNpbmcgc2hvcnQgYmdzY2FuICIKIAkJCSAgICJpbnRlcnZhbCIpOwogCQlkYXRhLT5zY2FuX2ludGVydmFsID0gZGF0YS0+c2hvcnRfaW50ZXJ2YWw7Ci0JCW9zX2dldF90aW1lKCZub3cpOworCQlvc19nZXRfcmVsdGltZSgmbm93KTsKIAkJaWYgKG5vdy5zZWMgPiBkYXRhLT5sYXN0X2Jnc2Nhbi5zZWMgKyAxKQogCQkJc2NhbiA9IDE7CiAJfSBlbHNlIGlmIChkYXRhLT5zY2FuX2ludGVydmFsID09IGRhdGEtPnNob3J0X2ludGVydmFsICYmIGFib3ZlKSB7CkBAIC01ODQsNyArNTk0LDcgQEAKIAkJICogU2lnbmFsIGRyb3BwZWQgZnVydGhlciA0IGRCLiBSZXF1ZXN0IGEgbmV3IHNjYW4gaWYgd2UgaGF2ZQogCQkgKiBub3QgeWV0IHNjYW5uZWQgaW4gYSB3aGlsZS4KIAkJICovCi0JCW9zX2dldF90aW1lKCZub3cpOworCQlvc19nZXRfcmVsdGltZSgmbm93KTsKIAkJaWYgKG5vdy5zZWMgPiBkYXRhLT5sYXN0X2Jnc2Nhbi5zZWMgKyAxMCkKIAkJCXNjYW4gPSAxOwogCX0KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2Jnc2Nhbl9zaW1wbGUuYyBiL3dwYV9zdXBwbGljYW50L2Jnc2Nhbl9zaW1wbGUuYwppbmRleCA0NzlmNzAzLi5hNDY3Y2M1IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9iZ3NjYW5fc2ltcGxlLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvYmdzY2FuX3NpbXBsZS5jCkBAIC0yNiw3ICsyNiw3IEBACiAJaW50IG1heF9zaG9ydF9zY2FuczsgLyogbWF4aW11bSB0aW1lcyB3ZSBzaG9ydC1zY2FuIGJlZm9yZSBiYWNrLW9mZiAqLwogCWludCBzaG9ydF9pbnRlcnZhbDsgLyogdXNlIGlmIHNpZ25hbCA8IHRocmVzaG9sZCAqLwogCWludCBsb25nX2ludGVydmFsOyAvKiB1c2UgaWYgc2lnbmFsID4gdGhyZXNob2xkICovCi0Jc3RydWN0IG9zX3RpbWUgbGFzdF9iZ3NjYW47CisJc3RydWN0IG9zX3JlbHRpbWUgbGFzdF9iZ3NjYW47CiB9OwogCiAKQEAgLTc1LDcgKzc1LDcgQEAKIAkJCSAqLwogCQkJZGF0YS0+c2hvcnRfc2Nhbl9jb3VudC0tOwogCQl9Ci0JCW9zX2dldF90aW1lKCZkYXRhLT5sYXN0X2Jnc2Nhbik7CisJCW9zX2dldF9yZWx0aW1lKCZkYXRhLT5sYXN0X2Jnc2Nhbik7CiAJfQogfQogCkBAIC0xNTksNyArMTU5LDcgQEAKIAkgKiB1cyBza2lwIGFuIGltbWVkaWF0ZSBuZXcgc2NhbiBpbiBjYXNlcyB3aGVyZSB0aGUgY3VycmVudCBzaWduYWwKIAkgKiBsZXZlbCBpcyBiZWxvdyB0aGUgYmdzY2FuIHRocmVzaG9sZC4KIAkgKi8KLQlvc19nZXRfdGltZSgmZGF0YS0+bGFzdF9iZ3NjYW4pOworCW9zX2dldF9yZWx0aW1lKCZkYXRhLT5sYXN0X2Jnc2Nhbik7CiAKIAlyZXR1cm4gZGF0YTsKIH0KQEAgLTIxMSw3ICsyMTEsNyBAQAogewogCXN0cnVjdCBiZ3NjYW5fc2ltcGxlX2RhdGEgKmRhdGEgPSBwcml2OwogCWludCBzY2FuID0gMDsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCiAJaWYgKGRhdGEtPnNob3J0X2ludGVydmFsID09IGRhdGEtPmxvbmdfaW50ZXJ2YWwgfHwKIAkgICAgZGF0YS0+c2lnbmFsX3RocmVzaG9sZCA9PSAwKQpAQCAtMjI1LDcgKzIyNSw3IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiYmdzY2FuIHNpbXBsZTogU3RhcnQgdXNpbmcgc2hvcnQgIgogCQkJICAgImJnc2NhbiBpbnRlcnZhbCIpOwogCQlkYXRhLT5zY2FuX2ludGVydmFsID0gZGF0YS0+c2hvcnRfaW50ZXJ2YWw7Ci0JCW9zX2dldF90aW1lKCZub3cpOworCQlvc19nZXRfcmVsdGltZSgmbm93KTsKIAkJaWYgKG5vdy5zZWMgPiBkYXRhLT5sYXN0X2Jnc2Nhbi5zZWMgKyAxICYmCiAJCSAgICBkYXRhLT5zaG9ydF9zY2FuX2NvdW50IDw9IGRhdGEtPm1heF9zaG9ydF9zY2FucykKIAkJCS8qCkBAIC0yNTksNyArMjU5LDcgQEAKIAkJICogU2lnbmFsIGRyb3BwZWQgZnVydGhlciA0IGRCLiBSZXF1ZXN0IGEgbmV3IHNjYW4gaWYgd2UgaGF2ZQogCQkgKiBub3QgeWV0IHNjYW5uZWQgaW4gYSB3aGlsZS4KIAkJICovCi0JCW9zX2dldF90aW1lKCZub3cpOworCQlvc19nZXRfcmVsdGltZSgmbm93KTsKIAkJaWYgKG5vdy5zZWMgPiBkYXRhLT5sYXN0X2Jnc2Nhbi5zZWMgKyAxMCkKIAkJCXNjYW4gPSAxOwogCX0KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2Jzcy5jIGIvd3BhX3N1cHBsaWNhbnQvYnNzLmMKaW5kZXggNjdhOWY5Ny4uZjk5YThhNyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvYnNzLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvYnNzLmMKQEAgLTk4LDYgKzk4LDcgQEAKIAlBTlFQX0RVUChoczIwX3dhbl9tZXRyaWNzKTsKIAlBTlFQX0RVUChoczIwX2Nvbm5lY3Rpb25fY2FwYWJpbGl0eSk7CiAJQU5RUF9EVVAoaHMyMF9vcGVyYXRpbmdfY2xhc3MpOworCUFOUVBfRFVQKGhzMjBfb3N1X3Byb3ZpZGVyc19saXN0KTsKICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogI3VuZGVmIEFOUVBfRFVQCiAKQEAgLTE2Niw2ICsxNjcsNyBAQAogCXdwYWJ1Zl9mcmVlKGFucXAtPmhzMjBfd2FuX21ldHJpY3MpOwogCXdwYWJ1Zl9mcmVlKGFucXAtPmhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5KTsKIAl3cGFidWZfZnJlZShhbnFwLT5oczIwX29wZXJhdGluZ19jbGFzcyk7CisJd3BhYnVmX2ZyZWUoYW5xcC0+aHMyMF9vc3VfcHJvdmlkZXJzX2xpc3QpOwogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKIAlvc19mcmVlKGFucXApOwpAQCAtMjI0LDkgKzIyNiw5IEBACiB9CiAKIAotc3RhdGljIHZvaWQgY2FsY3VsYXRlX3VwZGF0ZV90aW1lKGNvbnN0IHN0cnVjdCBvc190aW1lICpmZXRjaF90aW1lLAorc3RhdGljIHZvaWQgY2FsY3VsYXRlX3VwZGF0ZV90aW1lKGNvbnN0IHN0cnVjdCBvc19yZWx0aW1lICpmZXRjaF90aW1lLAogCQkJCSAgdW5zaWduZWQgaW50IGFnZV9tcywKLQkJCQkgIHN0cnVjdCBvc190aW1lICp1cGRhdGVfdGltZSkKKwkJCQkgIHN0cnVjdCBvc19yZWx0aW1lICp1cGRhdGVfdGltZSkKIHsKIAlvc190aW1lX3QgdXNlYzsKIApAQCAtMjQzLDcgKzI0NSw3IEBACiAKIAogc3RhdGljIHZvaWQgd3BhX2Jzc19jb3B5X3JlcyhzdHJ1Y3Qgd3BhX2JzcyAqZHN0LCBzdHJ1Y3Qgd3BhX3NjYW5fcmVzICpzcmMsCi0JCQkgICAgIHN0cnVjdCBvc190aW1lICpmZXRjaF90aW1lKQorCQkJICAgICBzdHJ1Y3Qgb3NfcmVsdGltZSAqZmV0Y2hfdGltZSkKIHsKIAlkc3QtPmZsYWdzID0gc3JjLT5mbGFnczsKIAlvc19tZW1jcHkoZHN0LT5ic3NpZCwgc3JjLT5ic3NpZCwgRVRIX0FMRU4pOwpAQCAtMzI2LDcgKzMyOCw3IEBACiBzdGF0aWMgc3RydWN0IHdwYV9ic3MgKiB3cGFfYnNzX2FkZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgICBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuLAogCQkJCSAgICBzdHJ1Y3Qgd3BhX3NjYW5fcmVzICpyZXMsCi0JCQkJICAgIHN0cnVjdCBvc190aW1lICpmZXRjaF90aW1lKQorCQkJCSAgICBzdHJ1Y3Qgb3NfcmVsdGltZSAqZmV0Y2hfdGltZSkKIHsKIAlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOwogCkBAIC00OTIsNyArNDk0LDcgQEAKIAogc3RhdGljIHN0cnVjdCB3cGFfYnNzICoKIHdwYV9ic3NfdXBkYXRlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MsCi0JICAgICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXMgKnJlcywgc3RydWN0IG9zX3RpbWUgKmZldGNoX3RpbWUpCisJICAgICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXMgKnJlcywgc3RydWN0IG9zX3JlbHRpbWUgKmZldGNoX3RpbWUpCiB7CiAJdTMyIGNoYW5nZXM7CiAKQEAgLTUwMiw2ICs1MDQsMjIgQEAKIAl3cGFfYnNzX2NvcHlfcmVzKGJzcywgcmVzLCBmZXRjaF90aW1lKTsKIAkvKiBNb3ZlIHRoZSBlbnRyeSB0byB0aGUgZW5kIG9mIHRoZSBsaXN0ICovCiAJZGxfbGlzdF9kZWwoJmJzcy0+bGlzdCk7CisjaWZkZWYgQ09ORklHX1AyUAorCWlmICh3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBQMlBfSUVfVkVORE9SX1RZUEUpICYmCisJICAgICF3cGFfc2Nhbl9nZXRfdmVuZG9yX2llKHJlcywgUDJQX0lFX1ZFTkRPUl9UWVBFKSkgeworCQkvKgorCQkgKiBUaGlzIGNhbiBoYXBwZW4gd2hlbiBub24tUDJQIHN0YXRpb24gaW50ZXJmYWNlIHJ1bnMgYSBzY2FuCisJCSAqIHdpdGhvdXQgUDJQIElFIGluIHRoZSBQcm9iZSBSZXF1ZXN0IGZyYW1lLiBQMlAgR08gd291bGQgcmVwbHkKKwkJICogdG8gdGhhdCB3aXRoIGEgUHJvYmUgUmVzcG9uc2UgdGhhdCBkb2VzIG5vdCBpbmNsdWRlIFAyUCBJRS4KKwkJICogRG8gbm90IHVwZGF0ZSB0aGUgSUVzIGluIHRoaXMgQlNTIGVudHJ5IHRvIGF2b2lkIHN1Y2ggbG9zcyBvZgorCQkgKiBpbmZvcm1hdGlvbiB0aGF0IG1heSBiZSBuZWVkZWQgZm9yIFAyUCBvcGVyYXRpb25zIHRvCisJCSAqIGRldGVybWluZSBncm91cCBpbmZvcm1hdGlvbi4KKwkJICovCisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkJTUzogRG8gbm90IHVwZGF0ZSBzY2FuIElFcyBmb3IgIgorCQkJTUFDU1RSICIgc2luY2UgdGhhdCB3b3VsZCByZW1vdmUgUDJQIElFIGluZm9ybWF0aW9uIiwKKwkJCU1BQzJTVFIoYnNzLT5ic3NpZCkpOworCX0gZWxzZQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAlpZiAoYnNzLT5pZV9sZW4gKyBic3MtPmJlYWNvbl9pZV9sZW4gPj0KIAkgICAgcmVzLT5pZV9sZW4gKyByZXMtPmJlYWNvbl9pZV9sZW4pIHsKIAkJb3NfbWVtY3B5KGJzcyArIDEsIHJlcyArIDEsIHJlcy0+aWVfbGVuICsgcmVzLT5iZWFjb25faWVfbGVuKTsKQEAgLTU3MSwxNyArNTg5LDE4IEBACiAgKi8KIHZvaWQgd3BhX2Jzc191cGRhdGVfc2Nhbl9yZXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgICAgc3RydWN0IHdwYV9zY2FuX3JlcyAqcmVzLAotCQkJICAgICBzdHJ1Y3Qgb3NfdGltZSAqZmV0Y2hfdGltZSkKKwkJCSAgICAgc3RydWN0IG9zX3JlbHRpbWUgKmZldGNoX3RpbWUpCiB7CiAJY29uc3QgdTggKnNzaWQsICpwMnA7CiAJc3RydWN0IHdwYV9ic3MgKmJzczsKIAogCWlmICh3cGFfcy0+Y29uZi0+aWdub3JlX29sZF9zY2FuX3JlcykgewotCQlzdHJ1Y3Qgb3NfdGltZSB1cGRhdGU7CisJCXN0cnVjdCBvc19yZWx0aW1lIHVwZGF0ZTsKIAkJY2FsY3VsYXRlX3VwZGF0ZV90aW1lKGZldGNoX3RpbWUsIHJlcy0+YWdlLCAmdXBkYXRlKTsKLQkJaWYgKG9zX3RpbWVfYmVmb3JlKCZ1cGRhdGUsICZ3cGFfcy0+c2Nhbl90cmlnZ2VyX3RpbWUpKSB7Ci0JCQlzdHJ1Y3Qgb3NfdGltZSBhZ2U7Ci0JCQlvc190aW1lX3N1Yigmd3BhX3MtPnNjYW5fdHJpZ2dlcl90aW1lLCAmdXBkYXRlLCAmYWdlKTsKKwkJaWYgKG9zX3JlbHRpbWVfYmVmb3JlKCZ1cGRhdGUsICZ3cGFfcy0+c2Nhbl90cmlnZ2VyX3RpbWUpKSB7CisJCQlzdHJ1Y3Qgb3NfcmVsdGltZSBhZ2U7CisJCQlvc19yZWx0aW1lX3N1Yigmd3BhX3MtPnNjYW5fdHJpZ2dlcl90aW1lLCAmdXBkYXRlLAorCQkJCSAgICAgICAmYWdlKTsKIAkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkJTUzogSWdub3JlIGRyaXZlciBCU1MgIgogCQkJCSJ0YWJsZSBlbnRyeSB0aGF0IGlzICV1LiUwNnUgc2Vjb25kcyBvbGRlciAiCiAJCQkJInRoYW4gb3VyIHNjYW4gdHJpZ2dlciIsCkBAIC02MjUsOCArNjQ0LDE4IEBACiAJYnNzID0gd3BhX2Jzc19nZXQod3BhX3MsIHJlcy0+YnNzaWQsIHNzaWQgKyAyLCBzc2lkWzFdKTsKIAlpZiAoYnNzID09IE5VTEwpCiAJCWJzcyA9IHdwYV9ic3NfYWRkKHdwYV9zLCBzc2lkICsgMiwgc3NpZFsxXSwgcmVzLCBmZXRjaF90aW1lKTsKLQllbHNlCisJZWxzZSB7CiAJCWJzcyA9IHdwYV9ic3NfdXBkYXRlKHdwYV9zLCBic3MsIHJlcywgZmV0Y2hfdGltZSk7CisJCWlmICh3cGFfcy0+bGFzdF9zY2FuX3JlcykgeworCQkJdW5zaWduZWQgaW50IGk7CisJCQlmb3IgKGkgPSAwOyBpIDwgd3BhX3MtPmxhc3Rfc2Nhbl9yZXNfdXNlZDsgaSsrKSB7CisJCQkJaWYgKGJzcyA9PSB3cGFfcy0+bGFzdF9zY2FuX3Jlc1tpXSkgeworCQkJCQkvKiBBbHJlYWR5IGluIHRoZSBsaXN0ICovCisJCQkJCXJldHVybjsKKwkJCQl9CisJCQl9CisJCX0KKwl9CiAKIAlpZiAoYnNzID09IE5VTEwpCiAJCXJldHVybjsKQEAgLTY0NSw3ICs2NzQsOCBAQAogCQl3cGFfcy0+bGFzdF9zY2FuX3Jlc19zaXplID0gc2l6OwogCX0KIAotCXdwYV9zLT5sYXN0X3NjYW5fcmVzW3dwYV9zLT5sYXN0X3NjYW5fcmVzX3VzZWQrK10gPSBic3M7CisJaWYgKHdwYV9zLT5sYXN0X3NjYW5fcmVzKQorCQl3cGFfcy0+bGFzdF9zY2FuX3Jlc1t3cGFfcy0+bGFzdF9zY2FuX3Jlc191c2VkKytdID0gYnNzOwogfQogCiAKQEAgLTcwNSwyNiArNzM1LDEwIEBACiB7CiAJc3RydWN0IHdwYV9ic3MgKmJzcywgKm47CiAKLQl3cGFfcy0+bGFzdF9zY2FuX2Z1bGwgPSAwOwotCW9zX2dldF90aW1lKCZ3cGFfcy0+bGFzdF9zY2FuKTsKKwlvc19nZXRfcmVsdGltZSgmd3BhX3MtPmxhc3Rfc2Nhbik7CiAJaWYgKCFuZXdfc2NhbikKIAkJcmV0dXJuOyAvKiBkbyBub3QgZXhwaXJlIGVudHJpZXMgd2l0aG91dCBuZXcgc2NhbiAqLwogCi0JaWYgKGluZm8gJiYgIWluZm8tPmFib3J0ZWQgJiYgIWluZm8tPmZyZXFzKSB7Ci0JCXNpemVfdCBpOwotCQlpZiAoaW5mby0+bnVtX3NzaWRzID09IDApIHsKLQkJCXdwYV9zLT5sYXN0X3NjYW5fZnVsbCA9IDE7Ci0JCX0gZWxzZSB7Ci0JCQlmb3IgKGkgPSAwOyBpIDwgaW5mby0+bnVtX3NzaWRzOyBpKyspIHsKLQkJCQlpZiAoaW5mby0+c3NpZHNbaV0uc3NpZCA9PSBOVUxMIHx8Ci0JCQkJICAgIGluZm8tPnNzaWRzW2ldLnNzaWRfbGVuID09IDApIHsKLQkJCQkJd3BhX3MtPmxhc3Rfc2Nhbl9mdWxsID0gMTsKLQkJCQkJYnJlYWs7Ci0JCQkJfQotCQkJfQotCQl9Ci0JfQotCiAJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKGJzcywgbiwgJndwYV9zLT5ic3MsIHN0cnVjdCB3cGFfYnNzLCBsaXN0KSB7CiAJCWlmICh3cGFfYnNzX2luX3VzZSh3cGFfcywgYnNzKSkKIAkJCWNvbnRpbnVlOwpAQCAtNzM4LDEwICs3NTIsOCBAQAogCQl9CiAJfQogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJCU1M6IGxhc3Rfc2Nhbl9yZXNfdXNlZD0ldS8ldSAiCi0JCSAgICJsYXN0X3NjYW5fZnVsbD0lZCIsCi0JCSAgIHdwYV9zLT5sYXN0X3NjYW5fcmVzX3VzZWQsIHdwYV9zLT5sYXN0X3NjYW5fcmVzX3NpemUsCi0JCSAgIHdwYV9zLT5sYXN0X3NjYW5fZnVsbCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJCU1M6IGxhc3Rfc2Nhbl9yZXNfdXNlZD0ldS8ldSIsCisJCSAgIHdwYV9zLT5sYXN0X3NjYW5fcmVzX3VzZWQsIHdwYV9zLT5sYXN0X3NjYW5fcmVzX3NpemUpOwogfQogCiAKQEAgLTc1NSwxOSArNzY3LDE5IEBACiB2b2lkIHdwYV9ic3NfZmx1c2hfYnlfYWdlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBhZ2UpCiB7CiAJc3RydWN0IHdwYV9ic3MgKmJzcywgKm47Ci0Jc3RydWN0IG9zX3RpbWUgdDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSB0OwogCiAJaWYgKGRsX2xpc3RfZW1wdHkoJndwYV9zLT5ic3MpKQogCQlyZXR1cm47CiAKLQlvc19nZXRfdGltZSgmdCk7CisJb3NfZ2V0X3JlbHRpbWUoJnQpOwogCXQuc2VjIC09IGFnZTsKIAogCWRsX2xpc3RfZm9yX2VhY2hfc2FmZShic3MsIG4sICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgewogCQlpZiAod3BhX2Jzc19pbl91c2Uod3BhX3MsIGJzcykpCiAJCQljb250aW51ZTsKIAotCQlpZiAob3NfdGltZV9iZWZvcmUoJmJzcy0+bGFzdF91cGRhdGUsICZ0KSkgeworCQlpZiAob3NfcmVsdGltZV9iZWZvcmUoJmJzcy0+bGFzdF91cGRhdGUsICZ0KSkgewogCQkJd3BhX2Jzc19yZW1vdmUod3BhX3MsIGJzcywgX19mdW5jX18pOwogCQl9IGVsc2UKIAkJCWJyZWFrOwpAQCAtODExLDYgKzgyMyw4IEBACiB7CiAJc3RydWN0IHdwYV9ic3MgKmJzcywgKm47CiAKKwl3cGFfcy0+Y2xlYXJfZHJpdmVyX3NjYW5fY2FjaGUgPSAxOworCiAJaWYgKHdwYV9zLT5ic3MubmV4dCA9PSBOVUxMKQogCQlyZXR1cm47IC8qIEJTUyB0YWJsZSBub3QgeWV0IGluaXRpYWxpemVkICovCiAKQEAgLTg3NCw3ICs4ODgsNyBAQAogCQlpZiAob3NfbWVtY21wKGJzcy0+YnNzaWQsIGJzc2lkLCBFVEhfQUxFTikgIT0gMCkKIAkJCWNvbnRpbnVlOwogCQlpZiAoZm91bmQgPT0gTlVMTCB8fAotCQkgICAgb3NfdGltZV9iZWZvcmUoJmZvdW5kLT5sYXN0X3VwZGF0ZSwgJmJzcy0+bGFzdF91cGRhdGUpKQorCQkgICAgb3NfcmVsdGltZV9iZWZvcmUoJmZvdW5kLT5sYXN0X3VwZGF0ZSwgJmJzcy0+bGFzdF91cGRhdGUpKQogCQkJZm91bmQgPSBic3M7CiAJfQogCXJldHVybiBmb3VuZDsKQEAgLTEwMDIsNiArMTAxNiw0MyBAQAogCiAKIC8qKgorICogd3BhX2Jzc19nZXRfdmVuZG9yX2llX2JlYWNvbiAtIEZldGNoIGEgdmVuZG9yIGluZm9ybWF0aW9uIGZyb20gYSBCU1MgZW50cnkKKyAqIEBic3M6IEJTUyB0YWJsZSBlbnRyeQorICogQHZlbmRvcl90eXBlOiBWZW5kb3IgdHlwZSAoZm91ciBvY3RldHMgc3RhcnRpbmcgdGhlIElFIHBheWxvYWQpCisgKiBSZXR1cm5zOiBQb2ludGVyIHRvIHRoZSBpbmZvcm1hdGlvbiBlbGVtZW50IChpZCBmaWVsZCkgb3IgJU5VTEwgaWYgbm90IGZvdW5kCisgKgorICogVGhpcyBmdW5jdGlvbiByZXR1cm5zIHRoZSBmaXJzdCBtYXRjaGluZyBpbmZvcm1hdGlvbiBlbGVtZW50IGluIHRoZSBCU1MKKyAqIGVudHJ5LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgbGlrZSB3cGFfYnNzX2dldF92ZW5kb3JfaWUoKSwgYnV0IHVzZXMgSUUgYnVmZmVyIG9ubHkKKyAqIGZyb20gQmVhY29uIGZyYW1lcyBpbnN0ZWFkIG9mIGVpdGhlciBCZWFjb24gb3IgUHJvYmUgUmVzcG9uc2UgZnJhbWVzLgorICovCitjb25zdCB1OCAqIHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZV9iZWFjb24oY29uc3Qgc3RydWN0IHdwYV9ic3MgKmJzcywKKwkJCQkJdTMyIHZlbmRvcl90eXBlKQoreworCWNvbnN0IHU4ICplbmQsICpwb3M7CisKKwlpZiAoYnNzLT5iZWFjb25faWVfbGVuID09IDApCisJCXJldHVybiBOVUxMOworCisJcG9zID0gKGNvbnN0IHU4ICopIChic3MgKyAxKTsKKwlwb3MgKz0gYnNzLT5pZV9sZW47CisJZW5kID0gcG9zICsgYnNzLT5iZWFjb25faWVfbGVuOworCisJd2hpbGUgKHBvcyArIDEgPCBlbmQpIHsKKwkJaWYgKHBvcyArIDIgKyBwb3NbMV0gPiBlbmQpCisJCQlicmVhazsKKwkJaWYgKHBvc1swXSA9PSBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUMgJiYgcG9zWzFdID49IDQgJiYKKwkJICAgIHZlbmRvcl90eXBlID09IFdQQV9HRVRfQkUzMigmcG9zWzJdKSkKKwkJCXJldHVybiBwb3M7CisJCXBvcyArPSAyICsgcG9zWzFdOworCX0KKworCXJldHVybiBOVUxMOworfQorCisKKy8qKgogICogd3BhX2Jzc19nZXRfdmVuZG9yX2llX211bHRpIC0gRmV0Y2ggdmVuZG9yIElFIGRhdGEgZnJvbSBhIEJTUyBlbnRyeQogICogQGJzczogQlNTIHRhYmxlIGVudHJ5CiAgKiBAdmVuZG9yX3R5cGU6IFZlbmRvciB0eXBlIChmb3VyIG9jdGV0cyBzdGFydGluZyB0aGUgSUUgcGF5bG9hZCkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2Jzcy5oIGIvd3BhX3N1cHBsaWNhbnQvYnNzLmgKaW5kZXggMmI0MTk0OC4uNGE2MjRjNSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvYnNzLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvYnNzLmgKQEAgLTM5LDYgKzM5LDcgQEAKIAlzdHJ1Y3Qgd3BhYnVmICpoczIwX3dhbl9tZXRyaWNzOwogCXN0cnVjdCB3cGFidWYgKmhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5OwogCXN0cnVjdCB3cGFidWYgKmhzMjBfb3BlcmF0aW5nX2NsYXNzOworCXN0cnVjdCB3cGFidWYgKmhzMjBfb3N1X3Byb3ZpZGVyc19saXN0OwogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiB9OwogCkBAIC04NCw3ICs4NSw3IEBACiAJLyoqIFRpbWVzdGFtcCBvZiBsYXN0IEJlYWNvbi9Qcm9iZSBSZXNwb25zZSBmcmFtZSAqLwogCXU2NCB0c2Y7CiAJLyoqIFRpbWUgb2YgdGhlIGxhc3QgdXBkYXRlIChpLmUuLCBCZWFjb24gb3IgUHJvYmUgUmVzcG9uc2UgUlgpICovCi0Jc3RydWN0IG9zX3RpbWUgbGFzdF91cGRhdGU7CisJc3RydWN0IG9zX3JlbHRpbWUgbGFzdF91cGRhdGU7CiAJLyoqIEFOUVAgZGF0YSAqLwogCXN0cnVjdCB3cGFfYnNzX2FucXAgKmFucXA7CiAJLyoqIExlbmd0aCBvZiB0aGUgZm9sbG93aW5nIElFIGZpZWxkIGluIG9jdGV0cyAoZnJvbSBQcm9iZSBSZXNwb25zZSkgKi8KQEAgLTk4LDcgKzk5LDcgQEAKIHZvaWQgd3BhX2Jzc191cGRhdGVfc3RhcnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIHdwYV9ic3NfdXBkYXRlX3NjYW5fcmVzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkgICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXMgKnJlcywKLQkJCSAgICAgc3RydWN0IG9zX3RpbWUgKmZldGNoX3RpbWUpOworCQkJICAgICBzdHJ1Y3Qgb3NfcmVsdGltZSAqZmV0Y2hfdGltZSk7CiB2b2lkIHdwYV9ic3NfdXBkYXRlX2VuZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgc2Nhbl9pbmZvICppbmZvLAogCQkJaW50IG5ld19zY2FuKTsKIGludCB3cGFfYnNzX2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CkBAIC0xMTgsNiArMTE5LDggQEAKIAkJCQkgICAgICB1bnNpZ25lZCBpbnQgaWRmLCB1bnNpZ25lZCBpbnQgaWRsKTsKIGNvbnN0IHU4ICogd3BhX2Jzc19nZXRfaWUoY29uc3Qgc3RydWN0IHdwYV9ic3MgKmJzcywgdTggaWUpOwogY29uc3QgdTggKiB3cGFfYnNzX2dldF92ZW5kb3JfaWUoY29uc3Qgc3RydWN0IHdwYV9ic3MgKmJzcywgdTMyIHZlbmRvcl90eXBlKTsKK2NvbnN0IHU4ICogd3BhX2Jzc19nZXRfdmVuZG9yX2llX2JlYWNvbihjb25zdCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzLAorCQkJCQl1MzIgdmVuZG9yX3R5cGUpOwogc3RydWN0IHdwYWJ1ZiAqIHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZV9tdWx0aShjb25zdCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzLAogCQkJCQkgICAgdTMyIHZlbmRvcl90eXBlKTsKIHN0cnVjdCB3cGFidWYgKiB3cGFfYnNzX2dldF92ZW5kb3JfaWVfbXVsdGlfYmVhY29uKGNvbnN0IHN0cnVjdCB3cGFfYnNzICpic3MsCkBAIC0xMjcsNCArMTMwLDkgQEAKIHN0cnVjdCB3cGFfYnNzX2FucXAgKiB3cGFfYnNzX2FucXBfYWxsb2Modm9pZCk7CiBpbnQgd3BhX2Jzc19hbnFwX3Vuc2hhcmVfYWxsb2Moc3RydWN0IHdwYV9ic3MgKmJzcyk7CiAKK3N0YXRpYyBpbmxpbmUgaW50IGJzc19pc19kbWcoY29uc3Qgc3RydWN0IHdwYV9ic3MgKmJzcykKK3sKKwlyZXR1cm4gYnNzLT5mcmVxID4gNDUwMDA7Cit9CisKICNlbmRpZiAvKiBCU1NfSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvY29uZmlnLmMgYi93cGFfc3VwcGxpY2FudC9jb25maWcuYwppbmRleCA2OWY5MjBkLi44Y2Q0YTJmIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jb25maWcuYworKysgYi93cGFfc3VwcGxpY2FudC9jb25maWcuYwpAQCAtMTAsNiArMTAsNyBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAjaW5jbHVkZSAidXRpbHMvdXVpZC5oIgorI2luY2x1ZGUgInV0aWxzL2lwX2FkZHIuaCIKICNpbmNsdWRlICJjcnlwdG8vc2hhMS5oIgogI2luY2x1ZGUgInJzbl9zdXBwL3dwYS5oIgogI2luY2x1ZGUgImVhcF9wZWVyL2VhcC5oIgpAQCAtMjg1LDcgKzI4Niw3IEBACiB7CiAjaWZkZWYgQ09ORklHX0VYVF9QQVNTV09SRAogCWlmIChvc19zdHJuY21wKHZhbHVlLCAiZXh0OiIsIDQpID09IDApIHsKLQkJb3NfZnJlZShzc2lkLT5wYXNzcGhyYXNlKTsKKwkJc3RyX2NsZWFyX2ZyZWUoc3NpZC0+cGFzc3BocmFzZSk7CiAJCXNzaWQtPnBhc3NwaHJhc2UgPSBOVUxMOwogCQlzc2lkLT5wc2tfc2V0ID0gMDsKIAkJb3NfZnJlZShzc2lkLT5leHRfcHNrKTsKQEAgLTMyMSw3ICszMjIsNyBAQAogCQkgICAgb3NfbWVtY21wKHNzaWQtPnBhc3NwaHJhc2UsIHZhbHVlLCBsZW4pID09IDApCiAJCQlyZXR1cm4gMDsKIAkJc3NpZC0+cHNrX3NldCA9IDA7Ci0JCW9zX2ZyZWUoc3NpZC0+cGFzc3BocmFzZSk7CisJCXN0cl9jbGVhcl9mcmVlKHNzaWQtPnBhc3NwaHJhc2UpOwogCQlzc2lkLT5wYXNzcGhyYXNlID0gZHVwX2JpbnN0cih2YWx1ZSwgbGVuKTsKIAkJaWYgKHNzaWQtPnBhc3NwaHJhc2UgPT0gTlVMTCkKIAkJCXJldHVybiAtMTsKQEAgLTM0MCw3ICszNDEsNyBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0Jb3NfZnJlZShzc2lkLT5wYXNzcGhyYXNlKTsKKwlzdHJfY2xlYXJfZnJlZShzc2lkLT5wYXNzcGhyYXNlKTsKIAlzc2lkLT5wYXNzcGhyYXNlID0gTlVMTDsKIAogCXNzaWQtPnBza19zZXQgPSAxOwpAQCAtNDA0LDYgKzQwNSw4IEBACiAJCWVsc2UgaWYgKG9zX3N0cmNtcChzdGFydCwgIlJTTiIpID09IDAgfHwKIAkJCSBvc19zdHJjbXAoc3RhcnQsICJXUEEyIikgPT0gMCkKIAkJCXZhbCB8PSBXUEFfUFJPVE9fUlNOOworCQllbHNlIGlmIChvc19zdHJjbXAoc3RhcnQsICJPU0VOIikgPT0gMCkKKwkJCXZhbCB8PSBXUEFfUFJPVE9fT1NFTjsKIAkJZWxzZSB7CiAJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgcHJvdG8gJyVzJyIsCiAJCQkJICAgbGluZSwgc3RhcnQpOwpAQCAtNDMyLDI4ICs0MzUsNDEgQEAKIHN0YXRpYyBjaGFyICogd3BhX2NvbmZpZ193cml0ZV9wcm90byhjb25zdCBzdHJ1Y3QgcGFyc2VfZGF0YSAqZGF0YSwKIAkJCQkgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKIHsKLQlpbnQgZmlyc3QgPSAxLCByZXQ7CisJaW50IHJldDsKIAljaGFyICpidWYsICpwb3MsICplbmQ7CiAKLQlwb3MgPSBidWYgPSBvc196YWxsb2MoMTApOworCXBvcyA9IGJ1ZiA9IG9zX3phbGxvYygyMCk7CiAJaWYgKGJ1ZiA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKLQllbmQgPSBidWYgKyAxMDsKKwllbmQgPSBidWYgKyAyMDsKIAogCWlmIChzc2lkLT5wcm90byAmIFdQQV9QUk9UT19XUEEpIHsKLQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1dQQSIsIGZpcnN0ID8gIiIgOiAiICIpOworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzV1BBIiwKKwkJCQkgIHBvcyA9PSBidWYgPyAiIiA6ICIgIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gYnVmOwogCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7CiAJfQogCiAJaWYgKHNzaWQtPnByb3RvICYgV1BBX1BST1RPX1JTTikgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzUlNOIiwgZmlyc3QgPyAiIiA6ICIgIik7CisJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNSU04iLAorCQkJCSAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCXJldHVybiBidWY7CiAJCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKKwl9CisKKwlpZiAoc3NpZC0+cHJvdG8gJiBXUEFfUFJPVE9fT1NFTikgeworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzT1NFTiIsCisJCQkJICBwb3MgPT0gYnVmID8gIiIgOiAiICIpOworCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJcmV0dXJuIGJ1ZjsKKwkJcG9zICs9IHJldDsKKwl9CisKKwlpZiAocG9zID09IGJ1ZikgeworCQlvc19mcmVlKGJ1Zik7CisJCWJ1ZiA9IE5VTEw7CiAJfQogCiAJcmV0dXJuIGJ1ZjsKQEAgLTUxNSw2ICs1MzEsMTAgQEAKIAkJZWxzZSBpZiAob3Nfc3RyY21wKHN0YXJ0LCAiRlQtU0FFIikgPT0gMCkKIAkJCXZhbCB8PSBXUEFfS0VZX01HTVRfRlRfU0FFOwogI2VuZGlmIC8qIENPTkZJR19TQUUgKi8KKyNpZmRlZiBDT05GSUdfSFMyMAorCQllbHNlIGlmIChvc19zdHJjbXAoc3RhcnQsICJPU0VOIikgPT0gMCkKKwkJCXZhbCB8PSBXUEFfS0VZX01HTVRfT1NFTjsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCQllbHNlIHsKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBrZXlfbWdtdCAnJXMnIiwKIAkJCQkgICBsaW5lLCBzdGFydCk7CkBAIC01NDYsMTAgKzU2NiwxMCBAQAogCWNoYXIgKmJ1ZiwgKnBvcywgKmVuZDsKIAlpbnQgcmV0OwogCi0JcG9zID0gYnVmID0gb3NfemFsbG9jKDUwKTsKKwlwb3MgPSBidWYgPSBvc196YWxsb2MoMTAwKTsKIAlpZiAoYnVmID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwotCWVuZCA9IGJ1ZiArIDUwOworCWVuZCA9IGJ1ZiArIDEwMDsKIAogCWlmIChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9QU0spIHsKIAkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1dQQS1QU0siLApAQCAtNjAyLDMxICs2MjIsNjYgQEAKIAl9CiAKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgotCWlmIChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9GVF9QU0spCi0JCXBvcyArPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzRlQtUFNLIiwKLQkJCQkgICBwb3MgPT0gYnVmID8gIiIgOiAiICIpOworCWlmIChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9GVF9QU0spIHsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0ZULVBTSyIsCisJCQkJICBwb3MgPT0gYnVmID8gIiIgOiAiICIpOworCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKSB7CisJCQllbmRbLTFdID0gJ1wwJzsKKwkJCXJldHVybiBidWY7CisJCX0KKwkJcG9zICs9IHJldDsKKwl9CiAKLQlpZiAoc3NpZC0+a2V5X21nbXQgJiBXUEFfS0VZX01HTVRfRlRfSUVFRTgwMjFYKQotCQlwb3MgKz0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0ZULUVBUCIsCi0JCQkJICAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKKwlpZiAoc3NpZC0+a2V5X21nbXQgJiBXUEFfS0VZX01HTVRfRlRfSUVFRTgwMjFYKSB7CisJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNGVC1FQVAiLAorCQkJCSAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykgeworCQkJZW5kWy0xXSA9ICdcMCc7CisJCQlyZXR1cm4gYnVmOworCQl9CisJCXBvcyArPSByZXQ7CisJfQogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiAKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwotCWlmIChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9QU0tfU0hBMjU2KQotCQlwb3MgKz0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1dQQS1QU0stU0hBMjU2IiwKLQkJCQkgICBwb3MgPT0gYnVmID8gIiIgOiAiICIpOworCWlmIChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9QU0tfU0hBMjU2KSB7CisJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNXUEEtUFNLLVNIQTI1NiIsCisJCQkJICBwb3MgPT0gYnVmID8gIiIgOiAiICIpOworCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKSB7CisJCQllbmRbLTFdID0gJ1wwJzsKKwkJCXJldHVybiBidWY7CisJCX0KKwkJcG9zICs9IHJldDsKKwl9CiAKLQlpZiAoc3NpZC0+a2V5X21nbXQgJiBXUEFfS0VZX01HTVRfSUVFRTgwMjFYX1NIQTI1NikKLQkJcG9zICs9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNXUEEtRUFQLVNIQTI1NiIsCi0JCQkJICAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKKwlpZiAoc3NpZC0+a2V5X21nbXQgJiBXUEFfS0VZX01HTVRfSUVFRTgwMjFYX1NIQTI1NikgeworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzV1BBLUVBUC1TSEEyNTYiLAorCQkJCSAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykgeworCQkJZW5kWy0xXSA9ICdcMCc7CisJCQlyZXR1cm4gYnVmOworCQl9CisJCXBvcyArPSByZXQ7CisJfQogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAKICNpZmRlZiBDT05GSUdfV1BTCi0JaWYgKHNzaWQtPmtleV9tZ210ICYgV1BBX0tFWV9NR01UX1dQUykKLQkJcG9zICs9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNXUFMiLAotCQkJCSAgIHBvcyA9PSBidWYgPyAiIiA6ICIgIik7CisJaWYgKHNzaWQtPmtleV9tZ210ICYgV1BBX0tFWV9NR01UX1dQUykgeworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzV1BTIiwKKwkJCQkgIHBvcyA9PSBidWYgPyAiIiA6ICIgIik7CisJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpIHsKKwkJCWVuZFstMV0gPSAnXDAnOworCQkJcmV0dXJuIGJ1ZjsKKwkJfQorCQlwb3MgKz0gcmV0OworCX0KICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAKKwlpZiAocG9zID09IGJ1ZikgeworCQlvc19mcmVlKGJ1Zik7CisJCWJ1ZiA9IE5VTEw7CisJfQorCiAJcmV0dXJuIGJ1ZjsKIH0KICNlbmRpZiAvKiBOT19DT05GSUdfV1JJVEUgKi8KQEAgLTgxOCw2ICs4NzMsMTEgQEAKIAkJcG9zICs9IHJldDsKIAl9CiAKKwlpZiAocG9zID09IGJ1ZikgeworCQlvc19mcmVlKGJ1Zik7CisJCWJ1ZiA9IE5VTEw7CisJfQorCiAJcmV0dXJuIGJ1ZjsKIH0KICNlbmRpZiAvKiBOT19DT05GSUdfV1JJVEUgKi8KQEAgLTg3Myw2ICs5MzMsMTAgQEAKIAlmcmVxcyA9IHdwYV9jb25maWdfcGFyc2VfaW50X2FycmF5KHZhbHVlKTsKIAlpZiAoZnJlcXMgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOworCWlmIChmcmVxc1swXSA9PSAwKSB7CisJCW9zX2ZyZWUoZnJlcXMpOworCQlmcmVxcyA9IE5VTEw7CisJfQogCW9zX2ZyZWUoc3NpZC0+c2Nhbl9mcmVxKTsKIAlzc2lkLT5zY2FuX2ZyZXEgPSBmcmVxczsKIApAQCAtODg5LDYgKzk1MywxMCBAQAogCWZyZXFzID0gd3BhX2NvbmZpZ19wYXJzZV9pbnRfYXJyYXkodmFsdWUpOwogCWlmIChmcmVxcyA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CisJaWYgKGZyZXFzWzBdID09IDApIHsKKwkJb3NfZnJlZShmcmVxcyk7CisJCWZyZXFzID0gTlVMTDsKKwl9CiAJb3NfZnJlZShzc2lkLT5mcmVxX2xpc3QpOwogCXNzaWQtPmZyZXFfbGlzdCA9IGZyZXFzOwogCkBAIC0xMDYyLDcgKzExMzAsNyBAQAogCiAJaWYgKG9zX3N0cmNtcCh2YWx1ZSwgIk5VTEwiKSA9PSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVW5zZXQgY29uZmlndXJhdGlvbiBzdHJpbmcgJ3Bhc3N3b3JkJyIpOwotCQlvc19mcmVlKHNzaWQtPmVhcC5wYXNzd29yZCk7CisJCWJpbl9jbGVhcl9mcmVlKHNzaWQtPmVhcC5wYXNzd29yZCwgc3NpZC0+ZWFwLnBhc3N3b3JkX2xlbik7CiAJCXNzaWQtPmVhcC5wYXNzd29yZCA9IE5VTEw7CiAJCXNzaWQtPmVhcC5wYXNzd29yZF9sZW4gPSAwOwogCQlyZXR1cm4gMDsKQEAgLTEwNzMsNyArMTE0MSw3IEBACiAJCWNoYXIgKm5hbWUgPSBvc19zdHJkdXAodmFsdWUgKyA0KTsKIAkJaWYgKG5hbWUgPT0gTlVMTCkKIAkJCXJldHVybiAtMTsKLQkJb3NfZnJlZShzc2lkLT5lYXAucGFzc3dvcmQpOworCQliaW5fY2xlYXJfZnJlZShzc2lkLT5lYXAucGFzc3dvcmQsIHNzaWQtPmVhcC5wYXNzd29yZF9sZW4pOwogCQlzc2lkLT5lYXAucGFzc3dvcmQgPSAodTggKikgbmFtZTsKIAkJc3NpZC0+ZWFwLnBhc3N3b3JkX2xlbiA9IG9zX3N0cmxlbihuYW1lKTsKIAkJc3NpZC0+ZWFwLmZsYWdzICY9IH5FQVBfQ09ORklHX0ZMQUdTX1BBU1NXT1JEX05USEFTSDsKQEAgLTEwOTUsNyArMTE2Myw3IEBACiAJCXdwYV9oZXhkdW1wX2FzY2lpX2tleShNU0dfTVNHRFVNUCwgZGF0YS0+bmFtZSwKIAkJCQkgICAgICAodTggKikgdG1wLCByZXNfbGVuKTsKIAotCQlvc19mcmVlKHNzaWQtPmVhcC5wYXNzd29yZCk7CisJCWJpbl9jbGVhcl9mcmVlKHNzaWQtPmVhcC5wYXNzd29yZCwgc3NpZC0+ZWFwLnBhc3N3b3JkX2xlbik7CiAJCXNzaWQtPmVhcC5wYXNzd29yZCA9ICh1OCAqKSB0bXA7CiAJCXNzaWQtPmVhcC5wYXNzd29yZF9sZW4gPSByZXNfbGVuOwogCQlzc2lkLT5lYXAuZmxhZ3MgJj0gfkVBUF9DT05GSUdfRkxBR1NfUEFTU1dPUkRfTlRIQVNIOwpAQCAtMTEyNCw3ICsxMTkyLDcgQEAKIAogCXdwYV9oZXhkdW1wX2tleShNU0dfTVNHRFVNUCwgZGF0YS0+bmFtZSwgaGFzaCwgMTYpOwogCi0Jb3NfZnJlZShzc2lkLT5lYXAucGFzc3dvcmQpOworCWJpbl9jbGVhcl9mcmVlKHNzaWQtPmVhcC5wYXNzd29yZCwgc3NpZC0+ZWFwLnBhc3N3b3JkX2xlbik7CiAJc3NpZC0+ZWFwLnBhc3N3b3JkID0gaGFzaDsKIAlzc2lkLT5lYXAucGFzc3dvcmRfbGVuID0gMTY7CiAJc3NpZC0+ZWFwLmZsYWdzIHw9IEVBUF9DT05GSUdfRkxBR1NfUEFTU1dPUkRfTlRIQVNIOwpAQCAtMTE5NCw3ICsxMjYyLDcgQEAKIAkJCSAgIGxpbmUsICh1bnNpZ25lZCBpbnQpICpsZW4pOwogCX0KIAlvc19tZW1jcHkoa2V5LCBidWYsICpsZW4pOwotCW9zX2ZyZWUoYnVmKTsKKwlzdHJfY2xlYXJfZnJlZShidWYpOwogCXJlcyA9IG9zX3NucHJpbnRmKHRpdGxlLCBzaXplb2YodGl0bGUpLCAid2VwX2tleSVkIiwgaWR4KTsKIAlpZiAocmVzID49IDAgJiYgKHNpemVfdCkgcmVzIDwgc2l6ZW9mKHRpdGxlKSkKIAkJd3BhX2hleGR1bXBfa2V5KE1TR19NU0dEVU1QLCB0aXRsZSwga2V5LCAqbGVuKTsKQEAgLTEyODMsNiArMTM1MSw1MiBAQAogCiAjaWZkZWYgQ09ORklHX1AyUAogCitzdGF0aWMgaW50IHdwYV9jb25maWdfcGFyc2VfZ29fcDJwX2Rldl9hZGRyKGNvbnN0IHN0cnVjdCBwYXJzZV9kYXRhICpkYXRhLAorCQkJCQkgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkLCBpbnQgbGluZSwKKwkJCQkJICAgIGNvbnN0IGNoYXIgKnZhbHVlKQoreworCWlmICh2YWx1ZVswXSA9PSAnXDAnIHx8IG9zX3N0cmNtcCh2YWx1ZSwgIlwiXCIiKSA9PSAwIHx8CisJICAgIG9zX3N0cmNtcCh2YWx1ZSwgImFueSIpID09IDApIHsKKwkJb3NfbWVtc2V0KHNzaWQtPmdvX3AycF9kZXZfYWRkciwgMCwgRVRIX0FMRU4pOworCQl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiR08gUDJQIERldmljZSBBZGRyZXNzIGFueSIpOworCQlyZXR1cm4gMDsKKwl9CisJaWYgKGh3YWRkcl9hdG9uKHZhbHVlLCBzc2lkLT5nb19wMnBfZGV2X2FkZHIpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBHTyBQMlAgRGV2aWNlIEFkZHJlc3MgJyVzJy4iLAorCQkJICAgbGluZSwgdmFsdWUpOworCQlyZXR1cm4gLTE7CisJfQorCXNzaWQtPmJzc2lkX3NldCA9IDE7CisJd3BhX3ByaW50ZihNU0dfTVNHRFVNUCwgIkdPIFAyUCBEZXZpY2UgQWRkcmVzcyAiIE1BQ1NUUiwKKwkJICAgTUFDMlNUUihzc2lkLT5nb19wMnBfZGV2X2FkZHIpKTsKKwlyZXR1cm4gMDsKK30KKworCisjaWZuZGVmIE5PX0NPTkZJR19XUklURQorc3RhdGljIGNoYXIgKiB3cGFfY29uZmlnX3dyaXRlX2dvX3AycF9kZXZfYWRkcihjb25zdCBzdHJ1Y3QgcGFyc2VfZGF0YSAqZGF0YSwKKwkJCQkJICAgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKK3sKKwljaGFyICp2YWx1ZTsKKwlpbnQgcmVzOworCisJaWYgKGlzX3plcm9fZXRoZXJfYWRkcihzc2lkLT5nb19wMnBfZGV2X2FkZHIpKQorCQlyZXR1cm4gTlVMTDsKKworCXZhbHVlID0gb3NfbWFsbG9jKDIwKTsKKwlpZiAodmFsdWUgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJcmVzID0gb3Nfc25wcmludGYodmFsdWUsIDIwLCBNQUNTVFIsIE1BQzJTVFIoc3NpZC0+Z29fcDJwX2Rldl9hZGRyKSk7CisJaWYgKHJlcyA8IDAgfHwgcmVzID49IDIwKSB7CisJCW9zX2ZyZWUodmFsdWUpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJdmFsdWVbMjAgLSAxXSA9ICdcMCc7CisJcmV0dXJuIHZhbHVlOworfQorI2VuZGlmIC8qIE5PX0NPTkZJR19XUklURSAqLworCisKIHN0YXRpYyBpbnQgd3BhX2NvbmZpZ19wYXJzZV9wMnBfY2xpZW50X2xpc3QoY29uc3Qgc3RydWN0IHBhcnNlX2RhdGEgKmRhdGEsCiAJCQkJCSAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsIGludCBsaW5lLAogCQkJCQkgICAgY29uc3QgY2hhciAqdmFsdWUpCkBAIC0xNTQxLDYgKzE2NTUsNyBAQAogCXsgU1RSZShkaF9maWxlKSB9LAogCXsgU1RSZShzdWJqZWN0X21hdGNoKSB9LAogCXsgU1RSZShhbHRzdWJqZWN0X21hdGNoKSB9LAorCXsgU1RSZShkb21haW5fc3VmZml4X21hdGNoKSB9LAogCXsgU1RSZShjYV9jZXJ0MikgfSwKIAl7IFNUUmUoY2FfcGF0aDIpIH0sCiAJeyBTVFJlKGNsaWVudF9jZXJ0MikgfSwKQEAgLTE1NDksNiArMTY2NCw3IEBACiAJeyBTVFJlKGRoX2ZpbGUyKSB9LAogCXsgU1RSZShzdWJqZWN0X21hdGNoMikgfSwKIAl7IFNUUmUoYWx0c3ViamVjdF9tYXRjaDIpIH0sCisJeyBTVFJlKGRvbWFpbl9zdWZmaXhfbWF0Y2gyKSB9LAogCXsgU1RSZShwaGFzZTEpIH0sCiAJeyBTVFJlKHBoYXNlMikgfSwKIAl7IFNUUmUocGNzYykgfSwKQEAgLTE1NjUsNiArMTY4MSw3IEBACiAJeyBJTlRlKGVuZ2luZSkgfSwKIAl7IElOVGUoZW5naW5lMikgfSwKIAl7IElOVChlYXBvbF9mbGFncykgfSwKKwl7IElOVGUoc2ltX251bSkgfSwKICNlbmRpZiAvKiBJRUVFODAyMVhfRUFQT0wgKi8KIAl7IEZVTkNfS0VZKHdlcF9rZXkwKSB9LAogCXsgRlVOQ19LRVkod2VwX2tleTEpIH0sCkBAIC0xNTkyLDYgKzE3MDksNyBAQAogCXsgU1RSKGJnc2NhbikgfSwKIAl7IElOVF9SQU5HRShpZ25vcmVfYnJvYWRjYXN0X3NzaWQsIDAsIDIpIH0sCiAjaWZkZWYgQ09ORklHX1AyUAorCXsgRlVOQyhnb19wMnBfZGV2X2FkZHIpIH0sCiAJeyBGVU5DKHAycF9jbGllbnRfbGlzdCkgfSwKIAl7IEZVTkMocHNrX2xpc3QpIH0sCiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwpAQCAtMTU5OSw2ICsxNzE3LDggQEAKIAl7IElOVF9SQU5HRShkaXNhYmxlX2h0LCAwLCAxKSB9LAogCXsgSU5UX1JBTkdFKGRpc2FibGVfaHQ0MCwgLTEsIDEpIH0sCiAJeyBJTlRfUkFOR0UoZGlzYWJsZV9zZ2ksIDAsIDEpIH0sCisJeyBJTlRfUkFOR0UoZGlzYWJsZV9sZHBjLCAwLCAxKSB9LAorCXsgSU5UX1JBTkdFKGh0NDBfaW50b2xlcmFudCwgMCwgMSkgfSwKIAl7IElOVF9SQU5HRShkaXNhYmxlX21heF9hbXNkdSwgLTEsIDEpIH0sCiAJeyBJTlRfUkFOR0UoYW1wZHVfZmFjdG9yLCAtMSwgMykgfSwKIAl7IElOVF9SQU5HRShhbXBkdV9kZW5zaXR5LCAtMSwgNykgfSwKQEAgLTE2MjgsNiArMTc0OCwxMiBAQAogCXsgSU5UKGFwX21heF9pbmFjdGl2aXR5KSB9LAogCXsgSU5UKGR0aW1fcGVyaW9kKSB9LAogCXsgSU5UKGJlYWNvbl9pbnQpIH0sCisjaWZkZWYgQ09ORklHX01BQ1NFQworCXsgSU5UX1JBTkdFKG1hY3NlY19wb2xpY3ksIDAsIDEpIH0sCisjZW5kaWYgLyogQ09ORklHX01BQ1NFQyAqLworI2lmZGVmIENPTkZJR19IUzIwCisJeyBJTlQodXBkYXRlX2lkZW50aWZpZXIpIH0sCisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIH07CiAKICN1bmRlZiBPRkZTRVQKQEAgLTE2NDYsNyArMTc3Miw3IEBACiAjdW5kZWYgX0ZVTkMKICN1bmRlZiBGVU5DCiAjdW5kZWYgRlVOQ19LRVkKLSNkZWZpbmUgTlVNX1NTSURfRklFTERTIChzaXplb2Yoc3NpZF9maWVsZHMpIC8gc2l6ZW9mKHNzaWRfZmllbGRzWzBdKSkKKyNkZWZpbmUgTlVNX1NTSURfRklFTERTIEFSUkFZX1NJWkUoc3NpZF9maWVsZHMpCiAKIAogLyoqCkBAIC0xNzM3LDI5ICsxODYzLDMxIEBACiBzdGF0aWMgdm9pZCBlYXBfcGVlcl9jb25maWdfZnJlZShzdHJ1Y3QgZWFwX3BlZXJfY29uZmlnICplYXApCiB7CiAJb3NfZnJlZShlYXAtPmVhcF9tZXRob2RzKTsKLQlvc19mcmVlKGVhcC0+aWRlbnRpdHkpOworCWJpbl9jbGVhcl9mcmVlKGVhcC0+aWRlbnRpdHksIGVhcC0+aWRlbnRpdHlfbGVuKTsKIAlvc19mcmVlKGVhcC0+YW5vbnltb3VzX2lkZW50aXR5KTsKLQlvc19mcmVlKGVhcC0+cGFzc3dvcmQpOworCWJpbl9jbGVhcl9mcmVlKGVhcC0+cGFzc3dvcmQsIGVhcC0+cGFzc3dvcmRfbGVuKTsKIAlvc19mcmVlKGVhcC0+Y2FfY2VydCk7CiAJb3NfZnJlZShlYXAtPmNhX3BhdGgpOwogCW9zX2ZyZWUoZWFwLT5jbGllbnRfY2VydCk7CiAJb3NfZnJlZShlYXAtPnByaXZhdGVfa2V5KTsKLQlvc19mcmVlKGVhcC0+cHJpdmF0ZV9rZXlfcGFzc3dkKTsKKwlzdHJfY2xlYXJfZnJlZShlYXAtPnByaXZhdGVfa2V5X3Bhc3N3ZCk7CiAJb3NfZnJlZShlYXAtPmRoX2ZpbGUpOwogCW9zX2ZyZWUoZWFwLT5zdWJqZWN0X21hdGNoKTsKIAlvc19mcmVlKGVhcC0+YWx0c3ViamVjdF9tYXRjaCk7CisJb3NfZnJlZShlYXAtPmRvbWFpbl9zdWZmaXhfbWF0Y2gpOwogCW9zX2ZyZWUoZWFwLT5jYV9jZXJ0Mik7CiAJb3NfZnJlZShlYXAtPmNhX3BhdGgyKTsKIAlvc19mcmVlKGVhcC0+Y2xpZW50X2NlcnQyKTsKIAlvc19mcmVlKGVhcC0+cHJpdmF0ZV9rZXkyKTsKLQlvc19mcmVlKGVhcC0+cHJpdmF0ZV9rZXkyX3Bhc3N3ZCk7CisJc3RyX2NsZWFyX2ZyZWUoZWFwLT5wcml2YXRlX2tleTJfcGFzc3dkKTsKIAlvc19mcmVlKGVhcC0+ZGhfZmlsZTIpOwogCW9zX2ZyZWUoZWFwLT5zdWJqZWN0X21hdGNoMik7CiAJb3NfZnJlZShlYXAtPmFsdHN1YmplY3RfbWF0Y2gyKTsKKwlvc19mcmVlKGVhcC0+ZG9tYWluX3N1ZmZpeF9tYXRjaDIpOwogCW9zX2ZyZWUoZWFwLT5waGFzZTEpOwogCW9zX2ZyZWUoZWFwLT5waGFzZTIpOwogCW9zX2ZyZWUoZWFwLT5wY3NjKTsKLQlvc19mcmVlKGVhcC0+cGluKTsKKwlzdHJfY2xlYXJfZnJlZShlYXAtPnBpbik7CiAJb3NfZnJlZShlYXAtPmVuZ2luZV9pZCk7CiAJb3NfZnJlZShlYXAtPmtleV9pZCk7CiAJb3NfZnJlZShlYXAtPmNlcnRfaWQpOwpAQCAtMTc2NywxMiArMTg5NSwxMyBAQAogCW9zX2ZyZWUoZWFwLT5rZXkyX2lkKTsKIAlvc19mcmVlKGVhcC0+Y2VydDJfaWQpOwogCW9zX2ZyZWUoZWFwLT5jYV9jZXJ0Ml9pZCk7Ci0Jb3NfZnJlZShlYXAtPnBpbjIpOworCXN0cl9jbGVhcl9mcmVlKGVhcC0+cGluMik7CiAJb3NfZnJlZShlYXAtPmVuZ2luZTJfaWQpOwogCW9zX2ZyZWUoZWFwLT5vdHApOwogCW9zX2ZyZWUoZWFwLT5wZW5kaW5nX3JlcV9vdHApOwogCW9zX2ZyZWUoZWFwLT5wYWNfZmlsZSk7Ci0Jb3NfZnJlZShlYXAtPm5ld19wYXNzd29yZCk7CisJYmluX2NsZWFyX2ZyZWUoZWFwLT5uZXdfcGFzc3dvcmQsIGVhcC0+bmV3X3Bhc3N3b3JkX2xlbik7CisJc3RyX2NsZWFyX2ZyZWUoZWFwLT5leHRlcm5hbF9zaW1fcmVzcCk7CiB9CiAjZW5kaWYgLyogSUVFRTgwMjFYX0VBUE9MICovCiAKQEAgLTE3ODksNyArMTkxOCw4IEBACiAJc3RydWN0IHBza19saXN0X2VudHJ5ICpwc2s7CiAKIAlvc19mcmVlKHNzaWQtPnNzaWQpOwotCW9zX2ZyZWUoc3NpZC0+cGFzc3BocmFzZSk7CisJb3NfbWVtc2V0KHNzaWQtPnBzaywgMCwgc2l6ZW9mKHNzaWQtPnBzaykpOworCXN0cl9jbGVhcl9mcmVlKHNzaWQtPnBhc3NwaHJhc2UpOwogCW9zX2ZyZWUoc3NpZC0+ZXh0X3Bzayk7CiAjaWZkZWYgSUVFRTgwMjFYX0VBUE9MCiAJZWFwX3BlZXJfY29uZmlnX2ZyZWUoJnNzaWQtPmVhcCk7CkBAIC0xODEzLDI0ICsxOTQzLDUxIEBACiAKIHZvaWQgd3BhX2NvbmZpZ19mcmVlX2NyZWQoc3RydWN0IHdwYV9jcmVkICpjcmVkKQogeworCXNpemVfdCBpOworCiAJb3NfZnJlZShjcmVkLT5yZWFsbSk7Ci0Jb3NfZnJlZShjcmVkLT51c2VybmFtZSk7Ci0Jb3NfZnJlZShjcmVkLT5wYXNzd29yZCk7CisJc3RyX2NsZWFyX2ZyZWUoY3JlZC0+dXNlcm5hbWUpOworCXN0cl9jbGVhcl9mcmVlKGNyZWQtPnBhc3N3b3JkKTsKIAlvc19mcmVlKGNyZWQtPmNhX2NlcnQpOwogCW9zX2ZyZWUoY3JlZC0+Y2xpZW50X2NlcnQpOwogCW9zX2ZyZWUoY3JlZC0+cHJpdmF0ZV9rZXkpOwotCW9zX2ZyZWUoY3JlZC0+cHJpdmF0ZV9rZXlfcGFzc3dkKTsKKwlzdHJfY2xlYXJfZnJlZShjcmVkLT5wcml2YXRlX2tleV9wYXNzd2QpOwogCW9zX2ZyZWUoY3JlZC0+aW1zaSk7Ci0Jb3NfZnJlZShjcmVkLT5taWxlbmFnZSk7CisJc3RyX2NsZWFyX2ZyZWUoY3JlZC0+bWlsZW5hZ2UpOworCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5udW1fZG9tYWluOyBpKyspCisJCW9zX2ZyZWUoY3JlZC0+ZG9tYWluW2ldKTsKIAlvc19mcmVlKGNyZWQtPmRvbWFpbik7CisJb3NfZnJlZShjcmVkLT5kb21haW5fc3VmZml4X21hdGNoKTsKIAlvc19mcmVlKGNyZWQtPmVhcF9tZXRob2QpOwogCW9zX2ZyZWUoY3JlZC0+cGhhc2UxKTsKIAlvc19mcmVlKGNyZWQtPnBoYXNlMik7CiAJb3NfZnJlZShjcmVkLT5leGNsdWRlZF9zc2lkKTsKKwlvc19mcmVlKGNyZWQtPnJvYW1pbmdfcGFydG5lcik7CisJb3NfZnJlZShjcmVkLT5wcm92aXNpb25pbmdfc3ApOworCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5udW1fcmVxX2Nvbm5fY2FwYWI7IGkrKykKKwkJb3NfZnJlZShjcmVkLT5yZXFfY29ubl9jYXBhYl9wb3J0W2ldKTsKKwlvc19mcmVlKGNyZWQtPnJlcV9jb25uX2NhcGFiX3BvcnQpOworCW9zX2ZyZWUoY3JlZC0+cmVxX2Nvbm5fY2FwYWJfcHJvdG8pOwogCW9zX2ZyZWUoY3JlZCk7CiB9CiAKIAordm9pZCB3cGFfY29uZmlnX2ZsdXNoX2Jsb2JzKHN0cnVjdCB3cGFfY29uZmlnICpjb25maWcpCit7CisjaWZuZGVmIENPTkZJR19OT19DT05GSUdfQkxPQlMKKwlzdHJ1Y3Qgd3BhX2NvbmZpZ19ibG9iICpibG9iLCAqcHJldjsKKworCWJsb2IgPSBjb25maWctPmJsb2JzOworCWNvbmZpZy0+YmxvYnMgPSBOVUxMOworCXdoaWxlIChibG9iKSB7CisJCXByZXYgPSBibG9iOworCQlibG9iID0gYmxvYi0+bmV4dDsKKwkJd3BhX2NvbmZpZ19mcmVlX2Jsb2IocHJldik7CisJfQorI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfQkxPQlMgKi8KK30KKworCiAvKioKICAqIHdwYV9jb25maWdfZnJlZSAtIEZyZWUgY29uZmlndXJhdGlvbiBkYXRhCiAgKiBAY29uZmlnOiBDb25maWd1cmF0aW9uIGRhdGEgZnJvbSB3cGFfY29uZmlnX3JlYWQoKQpAQCAtMTg0MCw5ICsxOTk3LDYgQEAKICAqLwogdm9pZCB3cGFfY29uZmlnX2ZyZWUoc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZykKIHsKLSNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19CTE9CUwotCXN0cnVjdCB3cGFfY29uZmlnX2Jsb2IgKmJsb2IsICpwcmV2YmxvYjsKLSNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX0JMT0JTICovCiAJc3RydWN0IHdwYV9zc2lkICpzc2lkLCAqcHJldiA9IE5VTEw7CiAJc3RydWN0IHdwYV9jcmVkICpjcmVkLCAqY3ByZXY7CiAKQEAgLTE4NjAsMTUgKzIwMTQsNyBAQAogCQl3cGFfY29uZmlnX2ZyZWVfY3JlZChjcHJldik7CiAJfQogCi0jaWZuZGVmIENPTkZJR19OT19DT05GSUdfQkxPQlMKLQlibG9iID0gY29uZmlnLT5ibG9iczsKLQlwcmV2YmxvYiA9IE5VTEw7Ci0Jd2hpbGUgKGJsb2IpIHsKLQkJcHJldmJsb2IgPSBibG9iOwotCQlibG9iID0gYmxvYi0+bmV4dDsKLQkJd3BhX2NvbmZpZ19mcmVlX2Jsb2IocHJldmJsb2IpOwotCX0KLSNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX0JMT0JTICovCisJd3BhX2NvbmZpZ19mbHVzaF9ibG9icyhjb25maWcpOwogCiAJd3BhYnVmX2ZyZWUoY29uZmlnLT53cHNfdmVuZG9yX2V4dF9tMSk7CiAJb3NfZnJlZShjb25maWctPmN0cmxfaW50ZXJmYWNlKTsKQEAgLTE4NzcsNyArMjAyMyw3IEBACiAJb3NfZnJlZShjb25maWctPnBrY3MxMV9lbmdpbmVfcGF0aCk7CiAJb3NfZnJlZShjb25maWctPnBrY3MxMV9tb2R1bGVfcGF0aCk7CiAJb3NfZnJlZShjb25maWctPnBjc2NfcmVhZGVyKTsKLQlvc19mcmVlKGNvbmZpZy0+cGNzY19waW4pOworCXN0cl9jbGVhcl9mcmVlKGNvbmZpZy0+cGNzY19waW4pOwogCW9zX2ZyZWUoY29uZmlnLT5kcml2ZXJfcGFyYW0pOwogCW9zX2ZyZWUoY29uZmlnLT5kZXZpY2VfbmFtZSk7CiAJb3NfZnJlZShjb25maWctPm1hbnVmYWN0dXJlcik7CkBAIC0xODg4LDYgKzIwMzQsNyBAQAogCW9zX2ZyZWUoY29uZmlnLT5wMnBfc3NpZF9wb3N0Zml4KTsKIAlvc19mcmVlKGNvbmZpZy0+cHNzaWQpOwogCW9zX2ZyZWUoY29uZmlnLT5wMnBfcHJlZl9jaGFuKTsKKwlvc19mcmVlKGNvbmZpZy0+cDJwX25vX2dvX2ZyZXEucmFuZ2UpOwogCW9zX2ZyZWUoY29uZmlnLT5hdXRvc2Nhbik7CiAJb3NfZnJlZShjb25maWctPmZyZXFfbGlzdCk7CiAJd3BhYnVmX2ZyZWUoY29uZmlnLT53cHNfbmZjX2RoX3B1YmtleSk7CkBAIC0xODk2LDYgKzIwNDMsOCBAQAogCW9zX2ZyZWUoY29uZmlnLT5leHRfcGFzc3dvcmRfYmFja2VuZCk7CiAJb3NfZnJlZShjb25maWctPnNhZV9ncm91cHMpOwogCXdwYWJ1Zl9mcmVlKGNvbmZpZy0+YXBfdmVuZG9yX2VsZW1lbnRzKTsKKwlvc19mcmVlKGNvbmZpZy0+b3N1X2Rpcik7CisJb3NfZnJlZShjb25maWctPndvd2xhbl90cmlnZ2Vycyk7CiAJb3NfZnJlZShjb25maWcpOwogfQogCkBAIC0yMDI5LDExICsyMTc4LDEzIEBACiAJc3NpZC0+ZWFwb2xfZmxhZ3MgPSBERUZBVUxUX0VBUE9MX0ZMQUdTOwogCXNzaWQtPmVhcF93b3JrYXJvdW5kID0gREVGQVVMVF9FQVBfV09SS0FST1VORDsKIAlzc2lkLT5lYXAuZnJhZ21lbnRfc2l6ZSA9IERFRkFVTFRfRlJBR01FTlRfU0laRTsKKwlzc2lkLT5lYXAuc2ltX251bSA9IERFRkFVTFRfVVNFUl9TRUxFQ1RFRF9TSU07CiAjZW5kaWYgLyogSUVFRTgwMjFYX0VBUE9MICovCiAjaWZkZWYgQ09ORklHX0hUX09WRVJSSURFUwogCXNzaWQtPmRpc2FibGVfaHQgPSBERUZBVUxUX0RJU0FCTEVfSFQ7CiAJc3NpZC0+ZGlzYWJsZV9odDQwID0gREVGQVVMVF9ESVNBQkxFX0hUNDA7CiAJc3NpZC0+ZGlzYWJsZV9zZ2kgPSBERUZBVUxUX0RJU0FCTEVfU0dJOworCXNzaWQtPmRpc2FibGVfbGRwYyA9IERFRkFVTFRfRElTQUJMRV9MRFBDOwogCXNzaWQtPmRpc2FibGVfbWF4X2Ftc2R1ID0gREVGQVVMVF9ESVNBQkxFX01BWF9BTVNEVTsKIAlzc2lkLT5hbXBkdV9mYWN0b3IgPSBERUZBVUxUX0FNUERVX0ZBQ1RPUjsKIAlzc2lkLT5hbXBkdV9kZW5zaXR5ID0gREVGQVVMVF9BTVBEVV9ERU5TSVRZOwpAQCAtMjI1Niw3ICsyNDA3LDcgQEAKIAkJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEbyBub3QgYWxsb3cgIgogCQkJCQkJICAgImtleV9kYXRhIGZpZWxkIHRvIGJlICIKIAkJCQkJCSAgICJleHBvc2VkIik7Ci0JCQkJCW9zX2ZyZWUocmVzKTsKKwkJCQkJc3RyX2NsZWFyX2ZyZWUocmVzKTsKIAkJCQkJcmV0dXJuIG9zX3N0cmR1cCgiKiIpOwogCQkJCX0KIApAQCAtMjI5MSwxNyArMjQ0Miw5MyBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX2NvbmZpZ19zZXRfY3JlZF9yZXFfY29ubl9jYXBhYihzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsCisJCQkJCSAgICAgIGNvbnN0IGNoYXIgKnZhbHVlKQoreworCXU4ICpwcm90bzsKKwlpbnQgKipwb3J0OworCWludCAqcG9ydHMsICpucG9ydHM7CisJY29uc3QgY2hhciAqcG9zOworCXVuc2lnbmVkIGludCBudW1fcG9ydHM7CisKKwlwcm90byA9IG9zX3JlYWxsb2NfYXJyYXkoY3JlZC0+cmVxX2Nvbm5fY2FwYWJfcHJvdG8sCisJCQkJIGNyZWQtPm51bV9yZXFfY29ubl9jYXBhYiArIDEsIHNpemVvZih1OCkpOworCWlmIChwcm90byA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJY3JlZC0+cmVxX2Nvbm5fY2FwYWJfcHJvdG8gPSBwcm90bzsKKworCXBvcnQgPSBvc19yZWFsbG9jX2FycmF5KGNyZWQtPnJlcV9jb25uX2NhcGFiX3BvcnQsCisJCQkJY3JlZC0+bnVtX3JlcV9jb25uX2NhcGFiICsgMSwgc2l6ZW9mKGludCAqKSk7CisJaWYgKHBvcnQgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWNyZWQtPnJlcV9jb25uX2NhcGFiX3BvcnQgPSBwb3J0OworCisJcHJvdG9bY3JlZC0+bnVtX3JlcV9jb25uX2NhcGFiXSA9IGF0b2kodmFsdWUpOworCisJcG9zID0gb3Nfc3RyY2hyKHZhbHVlLCAnOicpOworCWlmIChwb3MgPT0gTlVMTCkgeworCQlwb3J0W2NyZWQtPm51bV9yZXFfY29ubl9jYXBhYl0gPSBOVUxMOworCQljcmVkLT5udW1fcmVxX2Nvbm5fY2FwYWIrKzsKKwkJcmV0dXJuIDA7CisJfQorCXBvcysrOworCisJcG9ydHMgPSBOVUxMOworCW51bV9wb3J0cyA9IDA7CisKKwl3aGlsZSAoKnBvcykgeworCQlucG9ydHMgPSBvc19yZWFsbG9jX2FycmF5KHBvcnRzLCBudW1fcG9ydHMgKyAxLCBzaXplb2YoaW50KSk7CisJCWlmIChucG9ydHMgPT0gTlVMTCkgeworCQkJb3NfZnJlZShwb3J0cyk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJcG9ydHMgPSBucG9ydHM7CisJCXBvcnRzW251bV9wb3J0cysrXSA9IGF0b2kocG9zKTsKKworCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOworCQlpZiAocG9zID09IE5VTEwpCisJCQlicmVhazsKKwkJcG9zKys7CisJfQorCisJbnBvcnRzID0gb3NfcmVhbGxvY19hcnJheShwb3J0cywgbnVtX3BvcnRzICsgMSwgc2l6ZW9mKGludCkpOworCWlmIChucG9ydHMgPT0gTlVMTCkgeworCQlvc19mcmVlKHBvcnRzKTsKKwkJcmV0dXJuIC0xOworCX0KKwlwb3J0cyA9IG5wb3J0czsKKwlwb3J0c1tudW1fcG9ydHNdID0gLTE7CisKKwlwb3J0W2NyZWQtPm51bV9yZXFfY29ubl9jYXBhYl0gPSBwb3J0czsKKwljcmVkLT5udW1fcmVxX2Nvbm5fY2FwYWIrKzsKKwlyZXR1cm4gMDsKK30KKworCiBpbnQgd3BhX2NvbmZpZ19zZXRfY3JlZChzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsIGNvbnN0IGNoYXIgKnZhciwKIAkJCWNvbnN0IGNoYXIgKnZhbHVlLCBpbnQgbGluZSkKIHsKIAljaGFyICp2YWw7CiAJc2l6ZV90IGxlbjsKIAorCWlmIChvc19zdHJjbXAodmFyLCAidGVtcG9yYXJ5IikgPT0gMCkgeworCQljcmVkLT50ZW1wb3JhcnkgPSBhdG9pKHZhbHVlKTsKKwkJcmV0dXJuIDA7CisJfQorCiAJaWYgKG9zX3N0cmNtcCh2YXIsICJwcmlvcml0eSIpID09IDApIHsKIAkJY3JlZC0+cHJpb3JpdHkgPSBhdG9pKHZhbHVlKTsKIAkJcmV0dXJuIDA7CiAJfQogCisJaWYgKG9zX3N0cmNtcCh2YXIsICJzcF9wcmlvcml0eSIpID09IDApIHsKKwkJaW50IHByaW8gPSBhdG9pKHZhbHVlKTsKKwkJaWYgKHByaW8gPCAwIHx8IHByaW8gPiAyNTUpCisJCQlyZXR1cm4gLTE7CisJCWNyZWQtPnNwX3ByaW9yaXR5ID0gcHJpbzsKKwkJcmV0dXJuIDA7CisJfQorCiAJaWYgKG9zX3N0cmNtcCh2YXIsICJwY3NjIikgPT0gMCkgewogCQljcmVkLT5wY3NjID0gYXRvaSh2YWx1ZSk7CiAJCXJldHVybiAwOwpAQCAtMjMyNiwxMiArMjU1Myw1NSBAQAogCiAJaWYgKG9zX3N0cmNtcCh2YXIsICJwYXNzd29yZCIpID09IDAgJiYKIAkgICAgb3Nfc3RybmNtcCh2YWx1ZSwgImV4dDoiLCA0KSA9PSAwKSB7Ci0JCW9zX2ZyZWUoY3JlZC0+cGFzc3dvcmQpOworCQlzdHJfY2xlYXJfZnJlZShjcmVkLT5wYXNzd29yZCk7CiAJCWNyZWQtPnBhc3N3b3JkID0gb3Nfc3RyZHVwKHZhbHVlKTsKIAkJY3JlZC0+ZXh0X3Bhc3N3b3JkID0gMTsKIAkJcmV0dXJuIDA7CiAJfQogCisJaWYgKG9zX3N0cmNtcCh2YXIsICJ1cGRhdGVfaWRlbnRpZmllciIpID09IDApIHsKKwkJY3JlZC0+dXBkYXRlX2lkZW50aWZpZXIgPSBhdG9pKHZhbHVlKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtaW5fZGxfYmFuZHdpZHRoX2hvbWUiKSA9PSAwKSB7CisJCWNyZWQtPm1pbl9kbF9iYW5kd2lkdGhfaG9tZSA9IGF0b2kodmFsdWUpOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgIm1pbl91bF9iYW5kd2lkdGhfaG9tZSIpID09IDApIHsKKwkJY3JlZC0+bWluX3VsX2JhbmR3aWR0aF9ob21lID0gYXRvaSh2YWx1ZSk7CisJCXJldHVybiAwOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAibWluX2RsX2JhbmR3aWR0aF9yb2FtaW5nIikgPT0gMCkgeworCQljcmVkLT5taW5fZGxfYmFuZHdpZHRoX3JvYW1pbmcgPSBhdG9pKHZhbHVlKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtaW5fdWxfYmFuZHdpZHRoX3JvYW1pbmciKSA9PSAwKSB7CisJCWNyZWQtPm1pbl91bF9iYW5kd2lkdGhfcm9hbWluZyA9IGF0b2kodmFsdWUpOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgIm1heF9ic3NfbG9hZCIpID09IDApIHsKKwkJY3JlZC0+bWF4X2Jzc19sb2FkID0gYXRvaSh2YWx1ZSk7CisJCXJldHVybiAwOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAicmVxX2Nvbm5fY2FwYWIiKSA9PSAwKQorCQlyZXR1cm4gd3BhX2NvbmZpZ19zZXRfY3JlZF9yZXFfY29ubl9jYXBhYihjcmVkLCB2YWx1ZSk7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgIm9jc3AiKSA9PSAwKSB7CisJCWNyZWQtPm9jc3AgPSBhdG9pKHZhbHVlKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJzaW1fbnVtIikgPT0gMCkgeworCQljcmVkLT5zaW1fbnVtID0gYXRvaSh2YWx1ZSk7CisJCXJldHVybiAwOworCX0KKwogCXZhbCA9IHdwYV9jb25maWdfcGFyc2Vfc3RyaW5nKHZhbHVlLCAmbGVuKTsKIAlpZiAodmFsID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkIGZpZWxkICclcycgc3RyaW5nICIKQEAgLTIzNDYsMTMgKzI2MTYsMTMgQEAKIAl9CiAKIAlpZiAob3Nfc3RyY21wKHZhciwgInVzZXJuYW1lIikgPT0gMCkgewotCQlvc19mcmVlKGNyZWQtPnVzZXJuYW1lKTsKKwkJc3RyX2NsZWFyX2ZyZWUoY3JlZC0+dXNlcm5hbWUpOwogCQljcmVkLT51c2VybmFtZSA9IHZhbDsKIAkJcmV0dXJuIDA7CiAJfQogCiAJaWYgKG9zX3N0cmNtcCh2YXIsICJwYXNzd29yZCIpID09IDApIHsKLQkJb3NfZnJlZShjcmVkLT5wYXNzd29yZCk7CisJCXN0cl9jbGVhcl9mcmVlKGNyZWQtPnBhc3N3b3JkKTsKIAkJY3JlZC0+cGFzc3dvcmQgPSB2YWw7CiAJCWNyZWQtPmV4dF9wYXNzd29yZCA9IDA7CiAJCXJldHVybiAwOwpAQCAtMjM3Nyw3ICsyNjQ3LDcgQEAKIAl9CiAKIAlpZiAob3Nfc3RyY21wKHZhciwgInByaXZhdGVfa2V5X3Bhc3N3ZCIpID09IDApIHsKLQkJb3NfZnJlZShjcmVkLT5wcml2YXRlX2tleV9wYXNzd2QpOworCQlzdHJfY2xlYXJfZnJlZShjcmVkLT5wcml2YXRlX2tleV9wYXNzd2QpOwogCQljcmVkLT5wcml2YXRlX2tleV9wYXNzd2QgPSB2YWw7CiAJCXJldHVybiAwOwogCX0KQEAgLTIzODksMTQgKzI2NTksMjggQEAKIAl9CiAKIAlpZiAob3Nfc3RyY21wKHZhciwgIm1pbGVuYWdlIikgPT0gMCkgewotCQlvc19mcmVlKGNyZWQtPm1pbGVuYWdlKTsKKwkJc3RyX2NsZWFyX2ZyZWUoY3JlZC0+bWlsZW5hZ2UpOwogCQljcmVkLT5taWxlbmFnZSA9IHZhbDsKIAkJcmV0dXJuIDA7CiAJfQogCisJaWYgKG9zX3N0cmNtcCh2YXIsICJkb21haW5fc3VmZml4X21hdGNoIikgPT0gMCkgeworCQlvc19mcmVlKGNyZWQtPmRvbWFpbl9zdWZmaXhfbWF0Y2gpOworCQljcmVkLT5kb21haW5fc3VmZml4X21hdGNoID0gdmFsOworCQlyZXR1cm4gMDsKKwl9CisKIAlpZiAob3Nfc3RyY21wKHZhciwgImRvbWFpbiIpID09IDApIHsKLQkJb3NfZnJlZShjcmVkLT5kb21haW4pOwotCQljcmVkLT5kb21haW4gPSB2YWw7CisJCWNoYXIgKipuZXdfZG9tYWluOworCQluZXdfZG9tYWluID0gb3NfcmVhbGxvY19hcnJheShjcmVkLT5kb21haW4sCisJCQkJCSAgICAgIGNyZWQtPm51bV9kb21haW4gKyAxLAorCQkJCQkgICAgICBzaXplb2YoY2hhciAqKSk7CisJCWlmIChuZXdfZG9tYWluID09IE5VTEwpIHsKKwkJCW9zX2ZyZWUodmFsKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQluZXdfZG9tYWluW2NyZWQtPm51bV9kb21haW4rK10gPSB2YWw7CisJCWNyZWQtPmRvbWFpbiA9IG5ld19kb21haW47CiAJCXJldHVybiAwOwogCX0KIApAQCAtMjQyNiw2ICsyNzEwLDIxIEBACiAJCXJldHVybiAwOwogCX0KIAorCWlmIChvc19zdHJjbXAodmFyLCAicmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtIikgPT0gMCkgeworCQlpZiAobGVuIDwgMyB8fCBsZW4gPiBzaXplb2YoY3JlZC0+cmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtKSkKKwkJeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKKwkJCQkgICAicmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtIGxlbmd0aCAlZCAiCisJCQkJICAgIigzLi4xNSBleHBlY3RlZCkiLCBsaW5lLCAoaW50KSBsZW4pOworCQkJb3NfZnJlZSh2YWwpOworCQkJcmV0dXJuIC0xOworCQl9CisJCW9zX21lbWNweShjcmVkLT5yZXF1aXJlZF9yb2FtaW5nX2NvbnNvcnRpdW0sIHZhbCwgbGVuKTsKKwkJY3JlZC0+cmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtX2xlbiA9IGxlbjsKKwkJb3NfZnJlZSh2YWwpOworCQlyZXR1cm4gMDsKKwl9CisKIAlpZiAob3Nfc3RyY21wKHZhciwgImV4Y2x1ZGVkX3NzaWQiKSA9PSAwKSB7CiAJCXN0cnVjdCBleGNsdWRlZF9zc2lkICplOwogCkBAIC0yNDU0LDYgKzI3NTMsNjkgQEAKIAkJcmV0dXJuIDA7CiAJfQogCisJaWYgKG9zX3N0cmNtcCh2YXIsICJyb2FtaW5nX3BhcnRuZXIiKSA9PSAwKSB7CisJCXN0cnVjdCByb2FtaW5nX3BhcnRuZXIgKnA7CisJCWNoYXIgKnBvczsKKworCQlwID0gb3NfcmVhbGxvY19hcnJheShjcmVkLT5yb2FtaW5nX3BhcnRuZXIsCisJCQkJICAgICBjcmVkLT5udW1fcm9hbWluZ19wYXJ0bmVyICsgMSwKKwkJCQkgICAgIHNpemVvZihzdHJ1Y3Qgcm9hbWluZ19wYXJ0bmVyKSk7CisJCWlmIChwID09IE5VTEwpIHsKKwkJCW9zX2ZyZWUodmFsKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQljcmVkLT5yb2FtaW5nX3BhcnRuZXIgPSBwOworCisJCXAgPSAmY3JlZC0+cm9hbWluZ19wYXJ0bmVyW2NyZWQtPm51bV9yb2FtaW5nX3BhcnRuZXJdOworCisJCXBvcyA9IG9zX3N0cmNocih2YWwsICcsJyk7CisJCWlmIChwb3MgPT0gTlVMTCkgeworCQkJb3NfZnJlZSh2YWwpOworCQkJcmV0dXJuIC0xOworCQl9CisJCSpwb3MrKyA9ICdcMCc7CisJCWlmIChwb3MgLSB2YWwgLSAxID49IChpbnQpIHNpemVvZihwLT5mcWRuKSkgeworCQkJb3NfZnJlZSh2YWwpOworCQkJcmV0dXJuIC0xOworCQl9CisJCW9zX21lbWNweShwLT5mcWRuLCB2YWwsIHBvcyAtIHZhbCk7CisKKwkJcC0+ZXhhY3RfbWF0Y2ggPSBhdG9pKHBvcyk7CisKKwkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJywnKTsKKwkJaWYgKHBvcyA9PSBOVUxMKSB7CisJCQlvc19mcmVlKHZhbCk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJKnBvcysrID0gJ1wwJzsKKworCQlwLT5wcmlvcml0eSA9IGF0b2kocG9zKTsKKworCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOworCQlpZiAocG9zID09IE5VTEwpIHsKKwkJCW9zX2ZyZWUodmFsKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQkqcG9zKysgPSAnXDAnOworCisJCWlmIChvc19zdHJsZW4ocG9zKSA+PSBzaXplb2YocC0+Y291bnRyeSkpIHsKKwkJCW9zX2ZyZWUodmFsKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlvc19tZW1jcHkocC0+Y291bnRyeSwgcG9zLCBvc19zdHJsZW4ocG9zKSArIDEpOworCisJCWNyZWQtPm51bV9yb2FtaW5nX3BhcnRuZXIrKzsKKwkJb3NfZnJlZSh2YWwpOworCisJCXJldHVybiAwOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAicHJvdmlzaW9uaW5nX3NwIikgPT0gMCkgeworCQlvc19mcmVlKGNyZWQtPnByb3Zpc2lvbmluZ19zcCk7CisJCWNyZWQtPnByb3Zpc2lvbmluZ19zcCA9IHZhbDsKKwkJcmV0dXJuIDA7CisJfQorCiAJaWYgKGxpbmUpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiB1bmtub3duIGNyZWQgZmllbGQgJyVzJy4iLAogCQkJICAgbGluZSwgdmFyKTsKQEAgLTI0NjUsNiArMjgyNywyNzUgQEAKIH0KIAogCitzdGF0aWMgY2hhciAqIGFsbG9jX2ludF9zdHIoaW50IHZhbCkKK3sKKwljaGFyICpidWY7CisKKwlidWYgPSBvc19tYWxsb2MoMjApOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJb3Nfc25wcmludGYoYnVmLCAyMCwgIiVkIiwgdmFsKTsKKwlyZXR1cm4gYnVmOworfQorCisKK3N0YXRpYyBjaGFyICogYWxsb2Nfc3RyZHVwKGNvbnN0IGNoYXIgKnN0cikKK3sKKwlpZiAoc3RyID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCXJldHVybiBvc19zdHJkdXAoc3RyKTsKK30KKworCitjaGFyICogd3BhX2NvbmZpZ19nZXRfY3JlZF9ub19rZXkoc3RydWN0IHdwYV9jcmVkICpjcmVkLCBjb25zdCBjaGFyICp2YXIpCit7CisJaWYgKG9zX3N0cmNtcCh2YXIsICJ0ZW1wb3JhcnkiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT50ZW1wb3JhcnkpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJwcmlvcml0eSIpID09IDApCisJCXJldHVybiBhbGxvY19pbnRfc3RyKGNyZWQtPnByaW9yaXR5KTsKKworCWlmIChvc19zdHJjbXAodmFyLCAic3BfcHJpb3JpdHkiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5zcF9wcmlvcml0eSk7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInBjc2MiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5wY3NjKTsKKworCWlmIChvc19zdHJjbXAodmFyLCAiZWFwIikgPT0gMCkgeworCQlpZiAoIWNyZWQtPmVhcF9tZXRob2QpCisJCQlyZXR1cm4gTlVMTDsKKwkJcmV0dXJuIGFsbG9jX3N0cmR1cChlYXBfZ2V0X25hbWUoY3JlZC0+ZWFwX21ldGhvZFswXS52ZW5kb3IsCisJCQkJCQkgY3JlZC0+ZWFwX21ldGhvZFswXS5tZXRob2QpKTsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInVwZGF0ZV9pZGVudGlmaWVyIikgPT0gMCkKKwkJcmV0dXJuIGFsbG9jX2ludF9zdHIoY3JlZC0+dXBkYXRlX2lkZW50aWZpZXIpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtaW5fZGxfYmFuZHdpZHRoX2hvbWUiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5taW5fZGxfYmFuZHdpZHRoX2hvbWUpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtaW5fdWxfYmFuZHdpZHRoX2hvbWUiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5taW5fdWxfYmFuZHdpZHRoX2hvbWUpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtaW5fZGxfYmFuZHdpZHRoX3JvYW1pbmciKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5taW5fZGxfYmFuZHdpZHRoX3JvYW1pbmcpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtaW5fdWxfYmFuZHdpZHRoX3JvYW1pbmciKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5taW5fdWxfYmFuZHdpZHRoX3JvYW1pbmcpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtYXhfYnNzX2xvYWQiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5tYXhfYnNzX2xvYWQpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJyZXFfY29ubl9jYXBhYiIpID09IDApIHsKKwkJdW5zaWduZWQgaW50IGk7CisJCWNoYXIgKmJ1ZiwgKmVuZCwgKnBvczsKKwkJaW50IHJldDsKKworCQlpZiAoIWNyZWQtPm51bV9yZXFfY29ubl9jYXBhYikKKwkJCXJldHVybiBOVUxMOworCisJCWJ1ZiA9IG9zX21hbGxvYyg0MDAwKTsKKwkJaWYgKGJ1ZiA9PSBOVUxMKQorCQkJcmV0dXJuIE5VTEw7CisJCXBvcyA9IGJ1ZjsKKwkJZW5kID0gcG9zICsgNDAwMDsKKwkJZm9yIChpID0gMDsgaSA8IGNyZWQtPm51bV9yZXFfY29ubl9jYXBhYjsgaSsrKSB7CisJCQlpbnQgKnBvcnRzOworCisJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzJXUiLAorCQkJCQkgIGkgPiAwID8gIlxuIiA6ICIiLAorCQkJCQkgIGNyZWQtPnJlcV9jb25uX2NhcGFiX3Byb3RvW2ldKTsKKwkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCisJCQkJcmV0dXJuIGJ1ZjsKKwkJCXBvcyArPSByZXQ7CisKKwkJCXBvcnRzID0gY3JlZC0+cmVxX2Nvbm5fY2FwYWJfcG9ydFtpXTsKKwkJCWlmIChwb3J0cykgeworCQkJCWludCBqOworCQkJCWZvciAoaiA9IDA7IHBvcnRzW2pdICE9IC0xOyBqKyspIHsKKwkJCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsCisJCQkJCQkJICAiJXMlZCIsCisJCQkJCQkJICBqID4gMCA/ICIsIiA6ICI6IiwKKwkJCQkJCQkgIHBvcnRzW2pdKTsKKwkJCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQkJCXJldHVybiBidWY7CisJCQkJCXBvcyArPSByZXQ7CisJCQkJfQorCQkJfQorCQl9CisKKwkJcmV0dXJuIGJ1ZjsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgIm9jc3AiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2NfaW50X3N0cihjcmVkLT5vY3NwKTsKKworCWlmIChvc19zdHJjbXAodmFyLCAicmVhbG0iKSA9PSAwKQorCQlyZXR1cm4gYWxsb2Nfc3RyZHVwKGNyZWQtPnJlYWxtKTsKKworCWlmIChvc19zdHJjbXAodmFyLCAidXNlcm5hbWUiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2Nfc3RyZHVwKGNyZWQtPnVzZXJuYW1lKTsKKworCWlmIChvc19zdHJjbXAodmFyLCAicGFzc3dvcmQiKSA9PSAwKSB7CisJCWlmICghY3JlZC0+cGFzc3dvcmQpCisJCQlyZXR1cm4gTlVMTDsKKwkJcmV0dXJuIGFsbG9jX3N0cmR1cCgiKiIpOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAiY2FfY2VydCIpID09IDApCisJCXJldHVybiBhbGxvY19zdHJkdXAoY3JlZC0+Y2FfY2VydCk7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgImNsaWVudF9jZXJ0IikgPT0gMCkKKwkJcmV0dXJuIGFsbG9jX3N0cmR1cChjcmVkLT5jbGllbnRfY2VydCk7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInByaXZhdGVfa2V5IikgPT0gMCkKKwkJcmV0dXJuIGFsbG9jX3N0cmR1cChjcmVkLT5wcml2YXRlX2tleSk7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInByaXZhdGVfa2V5X3Bhc3N3ZCIpID09IDApIHsKKwkJaWYgKCFjcmVkLT5wcml2YXRlX2tleV9wYXNzd2QpCisJCQlyZXR1cm4gTlVMTDsKKwkJcmV0dXJuIGFsbG9jX3N0cmR1cCgiKiIpOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAiaW1zaSIpID09IDApCisJCXJldHVybiBhbGxvY19zdHJkdXAoY3JlZC0+aW1zaSk7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgIm1pbGVuYWdlIikgPT0gMCkgeworCQlpZiAoIShjcmVkLT5taWxlbmFnZSkpCisJCQlyZXR1cm4gTlVMTDsKKwkJcmV0dXJuIGFsbG9jX3N0cmR1cCgiKiIpOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAiZG9tYWluX3N1ZmZpeF9tYXRjaCIpID09IDApCisJCXJldHVybiBhbGxvY19zdHJkdXAoY3JlZC0+ZG9tYWluX3N1ZmZpeF9tYXRjaCk7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgImRvbWFpbiIpID09IDApIHsKKwkJdW5zaWduZWQgaW50IGk7CisJCWNoYXIgKmJ1ZiwgKmVuZCwgKnBvczsKKwkJaW50IHJldDsKKworCQlpZiAoIWNyZWQtPm51bV9kb21haW4pCisJCQlyZXR1cm4gTlVMTDsKKworCQlidWYgPSBvc19tYWxsb2MoNDAwMCk7CisJCWlmIChidWYgPT0gTlVMTCkKKwkJCXJldHVybiBOVUxMOworCQlwb3MgPSBidWY7CisJCWVuZCA9IHBvcyArIDQwMDA7CisKKwkJZm9yIChpID0gMDsgaSA8IGNyZWQtPm51bV9kb21haW47IGkrKykgeworCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlcyVzIiwKKwkJCQkJICBpID4gMCA/ICJcbiIgOiAiIiwgY3JlZC0+ZG9tYWluW2ldKTsKKwkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCisJCQkJcmV0dXJuIGJ1ZjsKKwkJCXBvcyArPSByZXQ7CisJCX0KKworCQlyZXR1cm4gYnVmOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAicGhhc2UxIikgPT0gMCkKKwkJcmV0dXJuIGFsbG9jX3N0cmR1cChjcmVkLT5waGFzZTEpOworCisJaWYgKG9zX3N0cmNtcCh2YXIsICJwaGFzZTIiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2Nfc3RyZHVwKGNyZWQtPnBoYXNlMik7CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInJvYW1pbmdfY29uc29ydGl1bSIpID09IDApIHsKKwkJc2l6ZV90IGJ1ZmxlbjsKKwkJY2hhciAqYnVmOworCisJCWlmICghY3JlZC0+cm9hbWluZ19jb25zb3J0aXVtX2xlbikKKwkJCXJldHVybiBOVUxMOworCQlidWZsZW4gPSBjcmVkLT5yb2FtaW5nX2NvbnNvcnRpdW1fbGVuICogMiArIDE7CisJCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOworCQlpZiAoYnVmID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKwkJd3BhX3NucHJpbnRmX2hleChidWYsIGJ1ZmxlbiwgY3JlZC0+cm9hbWluZ19jb25zb3J0aXVtLAorCQkJCSBjcmVkLT5yb2FtaW5nX2NvbnNvcnRpdW1fbGVuKTsKKwkJcmV0dXJuIGJ1ZjsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInJlcXVpcmVkX3JvYW1pbmdfY29uc29ydGl1bSIpID09IDApIHsKKwkJc2l6ZV90IGJ1ZmxlbjsKKwkJY2hhciAqYnVmOworCisJCWlmICghY3JlZC0+cmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtX2xlbikKKwkJCXJldHVybiBOVUxMOworCQlidWZsZW4gPSBjcmVkLT5yZXF1aXJlZF9yb2FtaW5nX2NvbnNvcnRpdW1fbGVuICogMiArIDE7CisJCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOworCQlpZiAoYnVmID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKwkJd3BhX3NucHJpbnRmX2hleChidWYsIGJ1ZmxlbiwgY3JlZC0+cmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtLAorCQkJCSBjcmVkLT5yZXF1aXJlZF9yb2FtaW5nX2NvbnNvcnRpdW1fbGVuKTsKKwkJcmV0dXJuIGJ1ZjsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgImV4Y2x1ZGVkX3NzaWQiKSA9PSAwKSB7CisJCXVuc2lnbmVkIGludCBpOworCQljaGFyICpidWYsICplbmQsICpwb3M7CisKKwkJaWYgKCFjcmVkLT5udW1fZXhjbHVkZWRfc3NpZCkKKwkJCXJldHVybiBOVUxMOworCisJCWJ1ZiA9IG9zX21hbGxvYyg0MDAwKTsKKwkJaWYgKGJ1ZiA9PSBOVUxMKQorCQkJcmV0dXJuIE5VTEw7CisJCXBvcyA9IGJ1ZjsKKwkJZW5kID0gcG9zICsgNDAwMDsKKworCQlmb3IgKGkgPSAwOyBpIDwgY3JlZC0+bnVtX2V4Y2x1ZGVkX3NzaWQ7IGkrKykgeworCQkJc3RydWN0IGV4Y2x1ZGVkX3NzaWQgKmU7CisJCQlpbnQgcmV0OworCisJCQllID0gJmNyZWQtPmV4Y2x1ZGVkX3NzaWRbaV07CisJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzJXMiLAorCQkJCQkgIGkgPiAwID8gIlxuIiA6ICIiLAorCQkJCQkgIHdwYV9zc2lkX3R4dChlLT5zc2lkLCBlLT5zc2lkX2xlbikpOworCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQlyZXR1cm4gYnVmOworCQkJcG9zICs9IHJldDsKKwkJfQorCisJCXJldHVybiBidWY7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJyb2FtaW5nX3BhcnRuZXIiKSA9PSAwKSB7CisJCXVuc2lnbmVkIGludCBpOworCQljaGFyICpidWYsICplbmQsICpwb3M7CisKKwkJaWYgKCFjcmVkLT5udW1fcm9hbWluZ19wYXJ0bmVyKQorCQkJcmV0dXJuIE5VTEw7CisKKwkJYnVmID0gb3NfbWFsbG9jKDQwMDApOworCQlpZiAoYnVmID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKwkJcG9zID0gYnVmOworCQllbmQgPSBwb3MgKyA0MDAwOworCisJCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5udW1fcm9hbWluZ19wYXJ0bmVyOyBpKyspIHsKKwkJCXN0cnVjdCByb2FtaW5nX3BhcnRuZXIgKnA7CisJCQlpbnQgcmV0OworCisJCQlwID0gJmNyZWQtPnJvYW1pbmdfcGFydG5lcltpXTsKKwkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXMlcywlZCwldSwlcyIsCisJCQkJCSAgaSA+IDAgPyAiXG4iIDogIiIsCisJCQkJCSAgcC0+ZnFkbiwgcC0+ZXhhY3RfbWF0Y2gsIHAtPnByaW9yaXR5LAorCQkJCQkgIHAtPmNvdW50cnkpOworCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQlyZXR1cm4gYnVmOworCQkJcG9zICs9IHJldDsKKwkJfQorCisJCXJldHVybiBidWY7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJwcm92aXNpb25pbmdfc3AiKSA9PSAwKQorCQlyZXR1cm4gYWxsb2Nfc3RyZHVwKGNyZWQtPnByb3Zpc2lvbmluZ19zcCk7CisKKwlyZXR1cm4gTlVMTDsKK30KKworCiBzdHJ1Y3Qgd3BhX2NyZWQgKiB3cGFfY29uZmlnX2dldF9jcmVkKHN0cnVjdCB3cGFfY29uZmlnICpjb25maWcsIGludCBpZCkKIHsKIAlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQ7CkBAIC0yNDk5LDYgKzMxMzAsNyBAQAogCWlmIChjcmVkID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwogCWNyZWQtPmlkID0gaWQ7CisJY3JlZC0+c2ltX251bSA9IERFRkFVTFRfVVNFUl9TRUxFQ1RFRF9TSU07CiAJaWYgKGxhc3QpCiAJCWxhc3QtPm5leHQgPSBjcmVkOwogCWVsc2UKQEAgLTI1NzksNyArMzIxMSw3IEBACiB7CiAJaWYgKGJsb2IpIHsKIAkJb3NfZnJlZShibG9iLT5uYW1lKTsKLQkJb3NfZnJlZShibG9iLT5kYXRhKTsKKwkJYmluX2NsZWFyX2ZyZWUoYmxvYi0+ZGF0YSwgYmxvYi0+bGVuKTsKIAkJb3NfZnJlZShibG9iKTsKIAl9CiB9CkBAIC0yNjQzLDYgKzMyNzUsNyBAQAogCWNvbmZpZy0+cDJwX2dvX2ludGVudCA9IERFRkFVTFRfUDJQX0dPX0lOVEVOVDsKIAljb25maWctPnAycF9pbnRyYV9ic3MgPSBERUZBVUxUX1AyUF9JTlRSQV9CU1M7CiAJY29uZmlnLT5wMnBfZ29fbWF4X2luYWN0aXZpdHkgPSBERUZBVUxUX1AyUF9HT19NQVhfSU5BQ1RJVklUWTsKKwljb25maWctPnAycF9vcHRpbWl6ZV9saXN0ZW5fY2hhbiA9IERFRkFVTFRfUDJQX09QVElNSVpFX0xJU1RFTl9DSEFOOwogCWNvbmZpZy0+YnNzX21heF9jb3VudCA9IERFRkFVTFRfQlNTX01BWF9DT1VOVDsKIAljb25maWctPmJzc19leHBpcmF0aW9uX2FnZSA9IERFRkFVTFRfQlNTX0VYUElSQVRJT05fQUdFOwogCWNvbmZpZy0+YnNzX2V4cGlyYXRpb25fc2Nhbl9jb3VudCA9IERFRkFVTFRfQlNTX0VYUElSQVRJT05fU0NBTl9DT1VOVDsKQEAgLTI2NTMsNiArMzI4Niw3IEBACiAJY29uZmlnLT53bW1fYWNfcGFyYW1zWzFdID0gYWNfYms7CiAJY29uZmlnLT53bW1fYWNfcGFyYW1zWzJdID0gYWNfdmk7CiAJY29uZmlnLT53bW1fYWNfcGFyYW1zWzNdID0gYWNfdm87CisJY29uZmlnLT5wMnBfc2VhcmNoX2RlbGF5ID0gREVGQVVMVF9QMlBfU0VBUkNIX0RFTEFZOwogCiAJaWYgKGN0cmxfaW50ZXJmYWNlKQogCQljb25maWctPmN0cmxfaW50ZXJmYWNlID0gb3Nfc3RyZHVwKGN0cmxfaW50ZXJmYWNlKTsKQEAgLTI3NzAsNiArMzQwNCwyNyBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX2NvbmZpZ19wcm9jZXNzX2Jnc2Nhbihjb25zdCBzdHJ1Y3QgZ2xvYmFsX3BhcnNlX2RhdGEgKmRhdGEsCisJCQkJICAgICBzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnLCBpbnQgbGluZSwKKwkJCQkgICAgIGNvbnN0IGNoYXIgKnBvcykKK3sKKwlzaXplX3QgbGVuOworCWNoYXIgKnRtcDsKKwlpbnQgcmVzOworCisJdG1wID0gd3BhX2NvbmZpZ19wYXJzZV9zdHJpbmcocG9zLCAmbGVuKTsKKwlpZiAodG1wID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBmYWlsZWQgdG8gcGFyc2UgJXMiLAorCQkJICAgbGluZSwgZGF0YS0+bmFtZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXMgPSB3cGFfZ2xvYmFsX2NvbmZpZ19wYXJzZV9zdHIoZGF0YSwgY29uZmlnLCBsaW5lLCB0bXApOworCW9zX2ZyZWUodG1wKTsKKwlyZXR1cm4gcmVzOworfQorCisKIHN0YXRpYyBpbnQgd3BhX2dsb2JhbF9jb25maWdfcGFyc2VfYmluKGNvbnN0IHN0cnVjdCBnbG9iYWxfcGFyc2VfZGF0YSAqZGF0YSwKIAkJCQkgICAgICAgc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZywgaW50IGxpbmUsCiAJCQkJICAgICAgIGNvbnN0IGNoYXIgKnBvcykKQEAgLTI4MDgsMTIgKzM0NjMsMzkgQEAKIAlmcmVxcyA9IHdwYV9jb25maWdfcGFyc2VfaW50X2FycmF5KHZhbHVlKTsKIAlpZiAoZnJlcXMgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOworCWlmIChmcmVxc1swXSA9PSAwKSB7CisJCW9zX2ZyZWUoZnJlcXMpOworCQlmcmVxcyA9IE5VTEw7CisJfQogCW9zX2ZyZWUoY29uZmlnLT5mcmVxX2xpc3QpOwogCWNvbmZpZy0+ZnJlcV9saXN0ID0gZnJlcXM7CiAJcmV0dXJuIDA7CiB9CiAKIAorI2lmZGVmIENPTkZJR19QMlAKK3N0YXRpYyBpbnQgd3BhX2dsb2JhbF9jb25maWdfcGFyc2VfaXB2NChjb25zdCBzdHJ1Y3QgZ2xvYmFsX3BhcnNlX2RhdGEgKmRhdGEsCisJCQkJCXN0cnVjdCB3cGFfY29uZmlnICpjb25maWcsIGludCBsaW5lLAorCQkJCQljb25zdCBjaGFyICpwb3MpCit7CisJdTMyICpkc3Q7CisJc3RydWN0IGhvc3RhcGRfaXBfYWRkciBhZGRyOworCisJaWYgKGhvc3RhcGRfcGFyc2VfaXBfYWRkcihwb3MsICZhZGRyKSA8IDApCisJCXJldHVybiAtMTsKKwlpZiAoYWRkci5hZiAhPSBBRl9JTkVUKQorCQlyZXR1cm4gLTE7CisKKwlkc3QgPSAodTMyICopICgoKHU4ICopIGNvbmZpZykgKyAobG9uZykgZGF0YS0+cGFyYW0xKTsKKwlvc19tZW1jcHkoZHN0LCAmYWRkci51LnY0LnNfYWRkciwgNCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyA9IDB4JXgiLCBkYXRhLT5uYW1lLAorCQkgICBXUEFfR0VUX0JFMzIoKHU4ICopIGRzdCkpOworCisJcmV0dXJuIDA7Cit9CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCisKIHN0YXRpYyBpbnQgd3BhX2NvbmZpZ19wcm9jZXNzX2NvdW50cnkoY29uc3Qgc3RydWN0IGdsb2JhbF9wYXJzZV9kYXRhICpkYXRhLAogCQkJCSAgICAgIHN0cnVjdCB3cGFfY29uZmlnICpjb25maWcsIGludCBsaW5lLAogCQkJCSAgICAgIGNvbnN0IGNoYXIgKnBvcykKQEAgLTI5OTgsNiArMzY4MCwyNiBAQAogCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogSW52YWxpZCBwMnBfcHJlZl9jaGFuIGxpc3QiLCBsaW5lKTsKIAlyZXR1cm4gLTE7CiB9CisKKworc3RhdGljIGludCB3cGFfY29uZmlnX3Byb2Nlc3NfcDJwX25vX2dvX2ZyZXEoCisJY29uc3Qgc3RydWN0IGdsb2JhbF9wYXJzZV9kYXRhICpkYXRhLAorCXN0cnVjdCB3cGFfY29uZmlnICpjb25maWcsIGludCBsaW5lLCBjb25zdCBjaGFyICpwb3MpCit7CisJaW50IHJldDsKKworCXJldCA9IGZyZXFfcmFuZ2VfbGlzdF9wYXJzZSgmY29uZmlnLT5wMnBfbm9fZ29fZnJlcSwgcG9zKTsKKwlpZiAocmV0IDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgcDJwX25vX2dvX2ZyZXEiLCBsaW5lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBwMnBfbm9fZ29fZnJlcSB3aXRoICV1IGl0ZW1zIiwKKwkJICAgY29uZmlnLT5wMnBfbm9fZ29fZnJlcS5udW0pOworCisJcmV0dXJuIDA7Cit9CisKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKIApAQCAtMzA3MCw2ICszNzcyLDE5IEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFCitzdGF0aWMgaW50IHdwYV9jb25maWdfcHJvY2Vzc19ub19jdHJsX2ludGVyZmFjZSgKKwljb25zdCBzdHJ1Y3QgZ2xvYmFsX3BhcnNlX2RhdGEgKmRhdGEsCisJc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZywgaW50IGxpbmUsIGNvbnN0IGNoYXIgKnBvcykKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5vX2N0cmxfaW50ZXJmYWNlIC0+IGN0cmxfaW50ZXJmYWNlPU5VTEwiKTsKKwlvc19mcmVlKGNvbmZpZy0+Y3RybF9pbnRlcmZhY2UpOworCWNvbmZpZy0+Y3RybF9pbnRlcmZhY2UgPSBOVUxMOworCXJldHVybiAwOworfQorI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFICovCisKKwogI2lmZGVmIE9GRlNFVAogI3VuZGVmIE9GRlNFVAogI2VuZGlmIC8qIE9GRlNFVCAqLwpAQCAtMzA4NSwxNCArMzgwMCwyMSBAQAogI2RlZmluZSBTVFIoZikgX1NUUihmKSwgTlVMTCwgTlVMTAogI2RlZmluZSBTVFJfUkFOR0UoZiwgbWluLCBtYXgpIF9TVFIoZiksICh2b2lkICopIG1pbiwgKHZvaWQgKikgbWF4CiAjZGVmaW5lIEJJTihmKSAjZiwgd3BhX2dsb2JhbF9jb25maWdfcGFyc2VfYmluLCBPRkZTRVQoZiksIE5VTEwsIE5VTEwKKyNkZWZpbmUgSVBWNChmKSAjZiwgd3BhX2dsb2JhbF9jb25maWdfcGFyc2VfaXB2NCwgT0ZGU0VUKGYpLCBOVUxMLCBOVUxMCiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZ2xvYmFsX3BhcnNlX2RhdGEgZ2xvYmFsX2ZpZWxkc1tdID0gewogI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFCiAJeyBTVFIoY3RybF9pbnRlcmZhY2UpLCAwIH0sCisJeyBGVU5DX05PX1ZBUihub19jdHJsX2ludGVyZmFjZSksIDAgfSwKIAl7IFNUUihjdHJsX2ludGVyZmFjZV9ncm91cCksIDAgfSAvKiBkZXByZWNhdGVkICovLAogI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFICovCisjaWZkZWYgQ09ORklHX01BQ1NFQworCXsgSU5UX1JBTkdFKGVhcG9sX3ZlcnNpb24sIDEsIDMpLCAwIH0sCisjZWxzZSAvKiBDT05GSUdfTUFDU0VDICovCiAJeyBJTlRfUkFOR0UoZWFwb2xfdmVyc2lvbiwgMSwgMiksIDAgfSwKKyNlbmRpZiAvKiBDT05GSUdfTUFDU0VDICovCiAJeyBJTlQoYXBfc2NhbiksIDAgfSwKKwl7IEZVTkMoYmdzY2FuKSwgMCB9LAogCXsgSU5UKGRpc2FibGVfc2Nhbl9vZmZsb2FkKSwgMCB9LAogCXsgSU5UKGZhc3RfcmVhdXRoKSwgMCB9LAogCXsgU1RSKG9wZW5zY19lbmdpbmVfcGF0aCksIDAgfSwKQEAgLTMxMDAsNiArMzgyMiw3IEBACiAJeyBTVFIocGtjczExX21vZHVsZV9wYXRoKSwgMCB9LAogCXsgU1RSKHBjc2NfcmVhZGVyKSwgMCB9LAogCXsgU1RSKHBjc2NfcGluKSwgMCB9LAorCXsgSU5UKGV4dGVybmFsX3NpbSksIDAgfSwKIAl7IFNUUihkcml2ZXJfcGFyYW0pLCAwIH0sCiAJeyBJTlQoZG90MTFSU05BQ29uZmlnUE1LTGlmZXRpbWUpLCAwIH0sCiAJeyBJTlQoZG90MTFSU05BQ29uZmlnUE1LUmVhdXRoVGhyZXNob2xkKSwgMCB9LApAQCAtMzEyNSwxOCArMzg0OCwyOCBAQAogCXsgRlVOQyhzZWNfZGV2aWNlX3R5cGUpLCBDRkdfQ0hBTkdFRF9TRUNfREVWSUNFX1RZUEUgfSwKIAl7IElOVChwMnBfbGlzdGVuX3JlZ19jbGFzcyksIDAgfSwKIAl7IElOVChwMnBfbGlzdGVuX2NoYW5uZWwpLCAwIH0sCi0JeyBJTlQocDJwX29wZXJfcmVnX2NsYXNzKSwgMCB9LAotCXsgSU5UKHAycF9vcGVyX2NoYW5uZWwpLCAwIH0sCisJeyBJTlQocDJwX29wZXJfcmVnX2NsYXNzKSwgQ0ZHX0NIQU5HRURfUDJQX09QRVJfQ0hBTk5FTCB9LAorCXsgSU5UKHAycF9vcGVyX2NoYW5uZWwpLCBDRkdfQ0hBTkdFRF9QMlBfT1BFUl9DSEFOTkVMIH0sCiAJeyBJTlRfUkFOR0UocDJwX2dvX2ludGVudCwgMCwgMTUpLCAwIH0sCiAJeyBTVFIocDJwX3NzaWRfcG9zdGZpeCksIENGR19DSEFOR0VEX1AyUF9TU0lEX1BPU1RGSVggfSwKIAl7IElOVF9SQU5HRShwZXJzaXN0ZW50X3JlY29ubmVjdCwgMCwgMSksIDAgfSwKIAl7IElOVF9SQU5HRShwMnBfaW50cmFfYnNzLCAwLCAxKSwgQ0ZHX0NIQU5HRURfUDJQX0lOVFJBX0JTUyB9LAogCXsgSU5UKHAycF9ncm91cF9pZGxlKSwgMCB9LAorCXsgSU5UX1JBTkdFKHAycF9wYXNzcGhyYXNlX2xlbiwgOCwgNjMpLAorCSAgQ0ZHX0NIQU5HRURfUDJQX1BBU1NQSFJBU0VfTEVOIH0sCiAJeyBGVU5DKHAycF9wcmVmX2NoYW4pLCBDRkdfQ0hBTkdFRF9QMlBfUFJFRl9DSEFOIH0sCisJeyBGVU5DKHAycF9ub19nb19mcmVxKSwgQ0ZHX0NIQU5HRURfUDJQX1BSRUZfQ0hBTiB9LAorCXsgSU5UX1JBTkdFKHAycF9hZGRfY2xpX2NoYW4sIDAsIDEpLCAwIH0sCisJeyBJTlRfUkFOR0UocDJwX29wdGltaXplX2xpc3Rlbl9jaGFuLCAwLCAxKSwgMCB9LAogCXsgSU5UKHAycF9nb19odDQwKSwgMCB9LAorCXsgSU5UKHAycF9nb192aHQpLCAwIH0sCiAJeyBJTlQocDJwX2Rpc2FibGVkKSwgMCB9LAogCXsgSU5UKHAycF9ub19ncm91cF9pZmFjZSksIDAgfSwKIAl7IElOVF9SQU5HRShwMnBfaWdub3JlX3NoYXJlZF9mcmVxLCAwLCAxKSwgMCB9LAorCXsgSVBWNChpcF9hZGRyX2dvKSwgMCB9LAorCXsgSVBWNChpcF9hZGRyX21hc2spLCAwIH0sCisJeyBJUFY0KGlwX2FkZHJfc3RhcnQpLCAwIH0sCisJeyBJUFY0KGlwX2FkZHJfZW5kKSwgMCB9LAogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAl7IEZVTkMoY291bnRyeSksIENGR19DSEFOR0VEX0NPVU5UUlkgfSwKIAl7IElOVChic3NfbWF4X2NvdW50KSwgMCB9LApAQCAtMzE3Myw2ICszOTA2LDkgQEAKIAl7IElOVChzY2FuX2N1cl9mcmVxKSwgMCB9LAogCXsgSU5UKHNjaGVkX3NjYW5faW50ZXJ2YWwpLCAwIH0sCiAJeyBJTlQodGRsc19leHRlcm5hbF9jb250cm9sKSwgMH0sCisJeyBTVFIob3N1X2RpciksIDAgfSwKKwl7IFNUUih3b3dsYW5fdHJpZ2dlcnMpLCAwIH0sCisJeyBJTlQocDJwX3NlYXJjaF9kZWxheSksIDB9LAogfTsKIAogI3VuZGVmIEZVTkMKQEAgLTMxODMsNyArMzkxOSw4IEBACiAjdW5kZWYgU1RSCiAjdW5kZWYgU1RSX1JBTkdFCiAjdW5kZWYgQklOCi0jZGVmaW5lIE5VTV9HTE9CQUxfRklFTERTIChzaXplb2YoZ2xvYmFsX2ZpZWxkcykgLyBzaXplb2YoZ2xvYmFsX2ZpZWxkc1swXSkpCisjdW5kZWYgSVBWNAorI2RlZmluZSBOVU1fR0xPQkFMX0ZJRUxEUyBBUlJBWV9TSVpFKGdsb2JhbF9maWVsZHMpCiAKIAogaW50IHdwYV9jb25maWdfcHJvY2Vzc19nbG9iYWwoc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZywgY2hhciAqcG9zLCBpbnQgbGluZSkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2NvbmZpZy5oIGIvd3BhX3N1cHBsaWNhbnQvY29uZmlnLmgKaW5kZXggM2ZlNDZlMy4uNTJhZGQ5ZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvY29uZmlnLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvY29uZmlnLmgKQEAgLTE5LDEyICsxOSwxNCBAQAogI2RlZmluZSBERUZBVUxUX1AyUF9HT19JTlRFTlQgNwogI2RlZmluZSBERUZBVUxUX1AyUF9JTlRSQV9CU1MgMQogI2RlZmluZSBERUZBVUxUX1AyUF9HT19NQVhfSU5BQ1RJVklUWSAoNSAqIDYwKQorI2RlZmluZSBERUZBVUxUX1AyUF9PUFRJTUlaRV9MSVNURU5fQ0hBTiAwCiAjZGVmaW5lIERFRkFVTFRfQlNTX01BWF9DT1VOVCAyMDAKICNkZWZpbmUgREVGQVVMVF9CU1NfRVhQSVJBVElPTl9BR0UgMTgwCiAjZGVmaW5lIERFRkFVTFRfQlNTX0VYUElSQVRJT05fU0NBTl9DT1VOVCAyCiAjZGVmaW5lIERFRkFVTFRfTUFYX05VTV9TVEEgMTI4CiAjZGVmaW5lIERFRkFVTFRfQUNDRVNTX05FVFdPUktfVFlQRSAxNQogI2RlZmluZSBERUZBVUxUX1NDQU5fQ1VSX0ZSRVEgMAorI2RlZmluZSBERUZBVUxUX1AyUF9TRUFSQ0hfREVMQVkgNTAwCiAKICNpbmNsdWRlICJjb25maWdfc3NpZC5oIgogI2luY2x1ZGUgIndwcy93cHMuaCIKQEAgLTUyLDYgKzU0LDExIEBACiAJaW50IGlkOwogCiAJLyoqCisJICogdGVtcG9yYXJ5IC0gV2hldGhlciB0aGlzIGNyZWRlbnRpYWwgaXMgdGVtcG9yYXJ5IGFuZCBub3QgdG8gYmUgc2F2ZWQKKwkgKi8KKwlpbnQgdGVtcG9yYXJ5OworCisJLyoqCiAJICogcHJpb3JpdHkgLSBQcmlvcml0eSBncm91cAogCSAqCiAJICogQnkgZGVmYXVsdCwgYWxsIG5ldHdvcmtzIGFuZCBjcmVkZW50aWFscyBnZXQgdGhlIHNhbWUgcHJpb3JpdHkgZ3JvdXAKQEAgLTE1MCwxMiArMTU3LDM3IEBACiAJY2hhciAqbWlsZW5hZ2U7CiAKIAkvKioKLQkgKiBkb21haW4gLSBIb21lIHNlcnZpY2UgcHJvdmlkZXIgRlFETgorCSAqIGRvbWFpbl9zdWZmaXhfbWF0Y2ggLSBDb25zdHJhaW50IGZvciBzZXJ2ZXIgZG9tYWluIG5hbWUKKwkgKgorCSAqIElmIHNldCwgdGhpcyBGUUROIGlzIHVzZWQgYXMgYSBzdWZmaXggbWF0Y2ggcmVxdWlyZW1lbnQgZm9yIHRoZSBBQUEKKwkgKiBzZXJ2ZXIgY2VydGlmaWNhdGUgaW4gU3ViamVjdEFsdE5hbWUgZE5TTmFtZSBlbGVtZW50KHMpLiBJZiBhCisJICogbWF0Y2hpbmcgZE5TTmFtZSBpcyBmb3VuZCwgdGhpcyBjb25zdHJhaW50IGlzIG1ldC4gSWYgbm8gZE5TTmFtZQorCSAqIHZhbHVlcyBhcmUgcHJlc2VudCwgdGhpcyBjb25zdHJhaW50IGlzIG1hdGNoZWQgYWdhaW5zdCBTdWJqZXROYW1lIENOCisJICogdXNpbmcgc2FtZSBzdWZmaXggbWF0Y2ggY29tcGFyaXNvbi4gU3VmZml4IG1hdGNoIGhlcmUgbWVhbnMgdGhhdCB0aGUKKwkgKiBob3N0L2RvbWFpbiBuYW1lIGlzIGNvbXBhcmVkIG9uZSBsYWJlbCBhdCBhIHRpbWUgc3RhcnRpbmcgZnJvbSB0aGUKKwkgKiB0b3AtbGV2ZWwgZG9tYWluIGFuZCBhbGwgdGhlIGxhYmVscyBpbiBAZG9tYWluX3N1ZmZpeF9tYXRjaCBzaGFsbCBiZQorCSAqIGluY2x1ZGVkIGluIHRoZSBjZXJ0aWZpY2F0ZS4gVGhlIGNlcnRpZmljYXRlIG1heSBpbmNsdWRlIGFkZGl0aW9uYWwKKwkgKiBzdWItbGV2ZWwgbGFiZWxzIGluIGFkZGl0aW9uIHRvIHRoZSByZXF1aXJlZCBsYWJlbHMuCisJICoKKwkgKiBGb3IgZXhhbXBsZSwgZG9tYWluX3N1ZmZpeF9tYXRjaD1leGFtcGxlLmNvbSB3b3VsZCBtYXRjaAorCSAqIHRlc3QuZXhhbXBsZS5jb20gYnV0IHdvdWxkIG5vdCBtYXRjaCB0ZXN0LWV4YW1wbGUuY29tLgorCSAqLworCWNoYXIgKmRvbWFpbl9zdWZmaXhfbWF0Y2g7CisKKwkvKioKKwkgKiBkb21haW4gLSBIb21lIHNlcnZpY2UgcHJvdmlkZXIgRlFETihzKQogCSAqCiAJICogVGhpcyBpcyB1c2VkIHRvIGNvbXBhcmUgYWdhaW5zdCB0aGUgRG9tYWluIE5hbWUgTGlzdCB0byBmaWd1cmUgb3V0Ci0JICogd2hldGhlciB0aGUgQVAgaXMgb3BlcmF0ZWQgYnkgdGhlIEhvbWUgU1AuCisJICogd2hldGhlciB0aGUgQVAgaXMgb3BlcmF0ZWQgYnkgdGhlIEhvbWUgU1AuIE11bHRpcGxlIGRvbWFpbiBlbnRyaWVzCisJICogY2FuIGJlIHVzZWQgdG8gY29uZmlndXJlIGFsdGVybmF0aXZlIEZRRE5zIHRoYXQgd2lsbCBiZSBjb25zaWRlcmVkCisJICogaG9tZSBuZXR3b3Jrcy4KIAkgKi8KLQljaGFyICpkb21haW47CisJY2hhciAqKmRvbWFpbjsKKworCS8qKgorCSAqIG51bV9kb21haW4gLSBOdW1iZXIgb2YgRlFETnMgaW4gdGhlIGRvbWFpbiBhcnJheQorCSAqLworCXNpemVfdCBudW1fZG9tYWluOwogCiAJLyoqCiAJICogcm9hbWluZ19jb25zb3J0aXVtIC0gUm9hbWluZyBDb25zb3J0aXVtIE9JCkBAIC0xNzUsNiArMjA3LDkgQEAKIAkgKi8KIAlzaXplX3Qgcm9hbWluZ19jb25zb3J0aXVtX2xlbjsKIAorCXU4IHJlcXVpcmVkX3JvYW1pbmdfY29uc29ydGl1bVsxNV07CisJc2l6ZV90IHJlcXVpcmVkX3JvYW1pbmdfY29uc29ydGl1bV9sZW47CisKIAkvKioKIAkgKiBlYXBfbWV0aG9kIC0gRUFQIG1ldGhvZCB0byB1c2UKIAkgKgpAQCAtMjAzLDYgKzIzOCw2NiBAQAogCQlzaXplX3Qgc3NpZF9sZW47CiAJfSAqZXhjbHVkZWRfc3NpZDsKIAlzaXplX3QgbnVtX2V4Y2x1ZGVkX3NzaWQ7CisKKwlzdHJ1Y3Qgcm9hbWluZ19wYXJ0bmVyIHsKKwkJY2hhciBmcWRuWzEyOF07CisJCWludCBleGFjdF9tYXRjaDsKKwkJdTggcHJpb3JpdHk7CisJCWNoYXIgY291bnRyeVszXTsKKwl9ICpyb2FtaW5nX3BhcnRuZXI7CisJc2l6ZV90IG51bV9yb2FtaW5nX3BhcnRuZXI7CisKKwlpbnQgdXBkYXRlX2lkZW50aWZpZXI7CisKKwkvKioKKwkgKiBwcm92aXNpb25pbmdfc3AgLSBGUUROIG9mIHRoZSBTUCB0aGF0IHByb3Zpc2lvbmVkIHRoZSBjcmVkZW50aWFsCisJICovCisJY2hhciAqcHJvdmlzaW9uaW5nX3NwOworCisJLyoqCisJICogc3BfcHJpb3JpdHkgLSBDcmVkZW50aWFsIHByaW9yaXR5IHdpdGhpbiBhIHByb3Zpc2lvbmluZyBTUAorCSAqCisJICogVGhpcyBpcyB0aGUgcHJpb3JpdHkgb2YgdGhlIGNyZWRlbnRpYWwgYW1vbmcgYWxsIGNyZWRlbnRpYWxzCisJICogcHJvdmlzaW9uaW5lZCBieSB0aGUgc2FtZSBTUCAoaS5lLiwgZm9yIGVudHJpZXMgdGhhdCBoYXZlIGlkZW50aWNhbAorCSAqIHByb3Zpc2lvbmluZ19zcCB2YWx1ZSkuIFRoZSByYW5nZSBvZiB0aGlzIHByaW9yaXR5IGlzIDAtMjU1IHdpdGggMAorCSAqIGJlaW5nIHRoZSBoaWdoZXN0IGFuZCAyNTUgdGhlIGxvd2VyIHByaW9yaXR5LgorCSAqLworCWludCBzcF9wcmlvcml0eTsKKworCXVuc2lnbmVkIGludCBtaW5fZGxfYmFuZHdpZHRoX2hvbWU7CisJdW5zaWduZWQgaW50IG1pbl91bF9iYW5kd2lkdGhfaG9tZTsKKwl1bnNpZ25lZCBpbnQgbWluX2RsX2JhbmR3aWR0aF9yb2FtaW5nOworCXVuc2lnbmVkIGludCBtaW5fdWxfYmFuZHdpZHRoX3JvYW1pbmc7CisKKwkvKioKKwkgKiBtYXhfYnNzX2xvYWQgLSBNYXhpbXVtIEJTUyBMb2FkIENoYW5uZWwgVXRpbGl6YXRpb24gKDEuLjI1NSkKKwkgKiBUaGlzIHZhbHVlIGlzIHVzZWQgYXMgdGhlIG1heGltdW0gY2hhbm5lbCB1dGlsaXphdGlvbiBmb3IgbmV0d29yaworCSAqIHNlbGVjdGlvbiBwdXJwb3NlcyBmb3IgaG9tZSBuZXR3b3Jrcy4gSWYgdGhlIEFQIGRvZXMgbm90IGFkdmVydGlzZQorCSAqIEJTUyBMb2FkIG9yIGlmIHRoZSBsaW1pdCB3b3VsZCBwcmV2ZW50IGFueSBjb25uZWN0aW9uLCB0aGlzCisJICogY29uc3RyYWludCB3aWxsIGJlIGlnbm9yZWQuCisJICovCisJdW5zaWduZWQgaW50IG1heF9ic3NfbG9hZDsKKworCXVuc2lnbmVkIGludCBudW1fcmVxX2Nvbm5fY2FwYWI7CisJdTggKnJlcV9jb25uX2NhcGFiX3Byb3RvOworCWludCAqKnJlcV9jb25uX2NhcGFiX3BvcnQ7CisKKwkvKioKKwkgKiBvY3NwIC0gV2hldGhlciB0byB1c2UvcmVxdWlyZSBPQ1NQIHRvIGNoZWNrIHNlcnZlciBjZXJ0aWZpY2F0ZQorCSAqCisJICogMCA9IGRvIG5vdCB1c2UgT0NTUCBzdGFwbGluZyAoVExTIGNlcnRpZmljYXRlIHN0YXR1cyBleHRlbnNpb24pCisJICogMSA9IHRyeSB0byB1c2UgT0NTUCBzdGFwbGluZywgYnV0IG5vdCByZXF1aXJlIHJlc3BvbnNlCisJICogMiA9IHJlcXVpcmUgdmFsaWQgT0NTUCBzdGFwbGluZyByZXNwb25zZQorCSAqLworCWludCBvY3NwOworCisJLyoqCisJICogc2ltX251bSAtIFVzZXIgc2VsZWN0ZWQgU0lNIGlkZW50aWZpZXIKKwkgKgorCSAqIFRoaXMgdmFyaWFibGUgaXMgdXNlZCBmb3IgaWRlbnRpZnlpbmcgd2hpY2ggU0lNIGlzIHVzZWQgaWYgdGhlIHN5c3RlbQorCSAqIGhhcyBtb3JlIHRoYW4gb25lLgorCSAqLworCWludCBzaW1fbnVtOwogfTsKIAogCkBAIC0yMjIsNiArMzE3LDcgQEAKICNkZWZpbmUgQ0ZHX0NIQU5HRURfUDJQX1BSRUZfQ0hBTiBCSVQoMTMpCiAjZGVmaW5lIENGR19DSEFOR0VEX0VYVF9QV19CQUNLRU5EIEJJVCgxNCkKICNkZWZpbmUgQ0ZHX0NIQU5HRURfTkZDX1BBU1NXT1JEX1RPS0VOIEJJVCgxNSkKKyNkZWZpbmUgQ0ZHX0NIQU5HRURfUDJQX1BBU1NQSFJBU0VfTEVOIEJJVCgxNikKIAogLyoqCiAgKiBzdHJ1Y3Qgd3BhX2NvbmZpZyAtIHdwYV9zdXBwbGljYW50IGNvbmZpZ3VyYXRpb24gZGF0YQpAQCAtMzAxLDYgKzM5NywxOCBAQAogCWludCBhcF9zY2FuOwogCiAJLyoqCisJICogYmdzY2FuIC0gQmFja2dyb3VuZCBzY2FuIGFuZCByb2FtaW5nIHBhcmFtZXRlcnMgb3IgJU5VTEwgaWYgbm9uZQorCSAqCisJICogVGhpcyBpcyBhbiBvcHRpb25hbCBzZXQgb2YgcGFyYW1ldGVycyBmb3IgYmFja2dyb3VuZCBzY2FubmluZyBhbmQKKwkgKiByb2FtaW5nIHdpdGhpbiBhIG5ldHdvcmsgKEVTUykuIEZvciBtb3JlIGRldGFpbGVkIGluZm9ybWF0aW9uIHNlZQorCSAqIHNzaWQgYmxvY2sgZG9jdW1lbnRhdGlvbi4KKwkgKgorCSAqIFRoZSB2YXJpYWJsZSBkZWZpbmVzIGRlZmF1bHQgYmdzY2FuIGJlaGF2aW9yIGZvciBhbGwgQlNTIHN0YXRpb24KKwkgKiBuZXR3b3JrcyBleGNlcHQgZm9yIHRob3NlIHdoaWNoIGhhdmUgdGhlaXIgb3duIGJnc2NhbiBjb25maWd1cmF0aW9uLgorCSAqLworCSBjaGFyICpiZ3NjYW47CisKKwkvKioKIAkgKiBkaXNhYmxlX3NjYW5fb2ZmbG9hZCAtIERpc2FibGUgYXV0b21hdGljIG9mZmxvYWRpbmcgb2Ygc2NhbiByZXF1ZXN0cwogCSAqCiAJICogQnkgZGVmYXVsdCwgJXdwYV9zdXBwbGljYW50IHRyaWVzIHRvIG9mZmxvYWQgc2Nhbm5pbmcgaWYgdGhlIGRyaXZlcgpAQCAtNDI1LDYgKzUzMywxMSBAQAogCWNoYXIgKnBjc2NfcGluOwogCiAJLyoqCisJICogZXh0ZXJuYWxfc2ltIC0gVXNlIGV4dGVybmFsIHByb2Nlc3NpbmcgZm9yIFNJTS9VU0lNIG9wZXJhdGlvbnMKKwkgKi8KKwlpbnQgZXh0ZXJuYWxfc2ltOworCisJLyoqCiAJICogZHJpdmVyX3BhcmFtIC0gRHJpdmVyIGludGVyZmFjZSBwYXJhbWV0ZXJzCiAJICoKIAkgKiBUaGlzIHRleHQgc3RyaW5nIGlzIHBhc3NlZCB0byB0aGUgc2VsZWN0ZWQgZHJpdmVyIGludGVyZmFjZSB3aXRoIHRoZQpAQCAtNTcyLDcgKzY4NSwxMCBAQAogCWludCBwMnBfaW50cmFfYnNzOwogCXVuc2lnbmVkIGludCBudW1fcDJwX3ByZWZfY2hhbjsKIAlzdHJ1Y3QgcDJwX2NoYW5uZWwgKnAycF9wcmVmX2NoYW47CisJc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3QgcDJwX25vX2dvX2ZyZXE7CisJaW50IHAycF9hZGRfY2xpX2NoYW47CiAJaW50IHAycF9pZ25vcmVfc2hhcmVkX2ZyZXE7CisJaW50IHAycF9vcHRpbWl6ZV9saXN0ZW5fY2hhbjsKIAogCXN0cnVjdCB3cGFidWYgKndwc192ZW5kb3JfZXh0X20xOwogCkBAIC02MDEsNiArNzE3LDE0IEBACiAJaW50IHAycF9ncm91cF9pZGxlOwogCiAJLyoqCisJICogcDJwX3Bhc3NwaHJhc2VfbGVuIC0gUGFzc3BocmFzZSBsZW5ndGggKDguLjYzKSBmb3IgUDJQIEdPCisJICoKKwkgKiBUaGlzIHBhcmFtZXRlciBjb250cm9scyB0aGUgbGVuZ3RoIG9mIHRoZSByYW5kb20gcGFzc3BocmFzZSB0aGF0IGlzCisJICogZ2VuZXJhdGVkIGF0IHRoZSBHTy4KKwkgKi8KKwl1bnNpZ25lZCBpbnQgcDJwX3Bhc3NwaHJhc2VfbGVuOworCisJLyoqCiAJICogYnNzX21heF9jb3VudCAtIE1heGltdW0gbnVtYmVyIG9mIEJTUyBlbnRyaWVzIHRvIGtlZXAgaW4gbWVtb3J5CiAJICovCiAJdW5zaWduZWQgaW50IGJzc19tYXhfY291bnQ7CkBAIC03OTMsNiArOTE3LDE2IEBACiAJaW50IHAycF9nb19odDQwOwogCiAJLyoqCisJICogcDJwX2dvX3ZodCAtIERlZmF1bHQgbW9kZSBmb3IgVkhUIGVuYWJsZSB3aGVuIG9wZXJhdGluZyBhcyBHTworCSAqCisJICogVGhpcyB3aWxsIHRha2UgZWZmZWN0IGZvciBwMnBfZ3JvdXBfYWRkLCBwMnBfY29ubmVjdCwgYW5kIHAycF9pbnZpdGUuCisJICogTm90ZSB0aGF0IHJlZ3VsYXRvcnkgY29uc3RyYWludHMgYW5kIGRyaXZlciBjYXBhYmlsaXRpZXMgYXJlCisJICogY29uc3VsdGVkIGFueXdheSwgc28gc2V0dGluZyBpdCB0byAxIGNhbid0IGRvIHJlYWwgaGFybS4KKwkgKiBCeSBkZWZhdWx0OiAwIChkaXNhYmxlZCkKKwkgKi8KKwlpbnQgcDJwX2dvX3ZodDsKKworCS8qKgogCSAqIHAycF9kaXNhYmxlZCAtIFdoZXRoZXIgUDJQIG9wZXJhdGlvbnMgYXJlIGRpc2FibGVkIGZvciB0aGlzIGludGVyZmFjZQogCSAqLwogCWludCBwMnBfZGlzYWJsZWQ7CkBAIC04ODQsOSArMTAxOCwzOSBAQAogCSAqIHRvIHNwZWNpZnkgdGhlIFRETFMgbGluayB0byBnZXQgZXN0YWJsaXNoZWQgdG8gdGhlIGRyaXZlci4gVGhlCiAJICogZHJpdmVyIHJlcXVlc3RzIHRoZSBURExTIHNldHVwIHRvIHRoZSBzdXBwbGljYW50IG9ubHkgZm9yIHRoZQogCSAqIHNwZWNpZmllZCBURExTIHBlZXJzLgotCSAqCiAJICovCiAJaW50IHRkbHNfZXh0ZXJuYWxfY29udHJvbDsKKworCXU4IGlwX2FkZHJfZ29bNF07CisJdTggaXBfYWRkcl9tYXNrWzRdOworCXU4IGlwX2FkZHJfc3RhcnRbNF07CisJdTggaXBfYWRkcl9lbmRbNF07CisKKwkvKioKKwkgKiBvc3VfZGlyIC0gT1NVIHByb3ZpZGVyIGluZm9ybWF0aW9uIGRpcmVjdG9yeQorCSAqCisJICogSWYgc2V0LCBhbGxvdyBGRVRDSF9PU1UgY29udHJvbCBpbnRlcmZhY2UgY29tbWFuZCB0byBiZSB1c2VkIHRvIGZldGNoCisJICogT1NVIHByb3ZpZGVyIGluZm9ybWF0aW9uIGludG8gYWxsIEFQcyBhbmQgc3RvcmUgdGhlIHJlc3VsdHMgaW4gdGhpcworCSAqIGRpcmVjdG9yeS4KKwkgKi8KKwljaGFyICpvc3VfZGlyOworCisJLyoqCisJICogd293bGFuX3RyaWdnZXJzIC0gV2FrZS1vbi1XTEFOIHRyaWdnZXJzCisJICoKKwkgKiBJZiBzZXQsIHRoZXNlIHdvd2xhbiB0cmlnZ2VycyB3aWxsIGJlIGNvbmZpZ3VyZWQuCisJICovCisJY2hhciAqd293bGFuX3RyaWdnZXJzOworCisJLyoqCisJICogcDJwX3NlYXJjaF9kZWxheSAtIEV4dHJhIGRlbGF5IGJldHdlZW4gY29uY3VycmVudCBzZWFyY2ggaXRlcmF0aW9ucworCSAqCisJICogQWRkIGV4dHJhIGRlbGF5IChpbiBtaWxsaXNlY29uZHMpIGJldHdlZW4gc2VhcmNoIGl0ZXJhdGlvbnMgd2hlbgorCSAqIHRoZXJlIGlzIGEgY29uY3VycmVudCBvcGVyYXRpb24gdG8gbWFrZSBwMnBfZmluZCBmcmllbmRsaWVyIHRvCisJICogY29uY3VycmVudCBvcGVyYXRpb25zIGJ5IGF2b2lkaW5nIGl0IGZyb20gdGFraW5nIDEwMCUgb2YgcmFkaW8KKwkgKiByZXNvdXJjZXMuCisJICovCisJdW5zaWduZWQgaW50IHAycF9zZWFyY2hfZGVsYXk7CiB9OwogCiAKQEAgLTkxOCw2ICsxMDgyLDcgQEAKIAkJCSBzdHJ1Y3Qgd3BhX2NvbmZpZ19ibG9iICpibG9iKTsKIHZvaWQgd3BhX2NvbmZpZ19mcmVlX2Jsb2Ioc3RydWN0IHdwYV9jb25maWdfYmxvYiAqYmxvYik7CiBpbnQgd3BhX2NvbmZpZ19yZW1vdmVfYmxvYihzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnLCBjb25zdCBjaGFyICpuYW1lKTsKK3ZvaWQgd3BhX2NvbmZpZ19mbHVzaF9ibG9icyhzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnKTsKIAogc3RydWN0IHdwYV9jcmVkICogd3BhX2NvbmZpZ19nZXRfY3JlZChzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnLCBpbnQgaWQpOwogc3RydWN0IHdwYV9jcmVkICogd3BhX2NvbmZpZ19hZGRfY3JlZChzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnKTsKQEAgLTkyNSw2ICsxMDkwLDcgQEAKIHZvaWQgd3BhX2NvbmZpZ19mcmVlX2NyZWQoc3RydWN0IHdwYV9jcmVkICpjcmVkKTsKIGludCB3cGFfY29uZmlnX3NldF9jcmVkKHN0cnVjdCB3cGFfY3JlZCAqY3JlZCwgY29uc3QgY2hhciAqdmFyLAogCQkJY29uc3QgY2hhciAqdmFsdWUsIGludCBsaW5lKTsKK2NoYXIgKiB3cGFfY29uZmlnX2dldF9jcmVkX25vX2tleShzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsIGNvbnN0IGNoYXIgKnZhcik7CiAKIHN0cnVjdCB3cGFfY29uZmlnICogd3BhX2NvbmZpZ19hbGxvY19lbXB0eShjb25zdCBjaGFyICpjdHJsX2ludGVyZmFjZSwKIAkJCQkJICAgY29uc3QgY2hhciAqZHJpdmVyX3BhcmFtKTsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2NvbmZpZ19maWxlLmMgYi93cGFfc3VwcGxpY2FudC9jb25maWdfZmlsZS5jCmluZGV4IGJiMGU1MzYuLjczYWQ1N2EgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2NvbmZpZ19maWxlLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvY29uZmlnX2ZpbGUuYwpAQCAtMjE5LDYgKzIxOSw3IEBACiAJaWYgKGNyZWQgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAJY3JlZC0+aWQgPSBpZDsKKwljcmVkLT5zaW1fbnVtID0gREVGQVVMVF9VU0VSX1NFTEVDVEVEX1NJTTsKIAogCXdoaWxlICh3cGFfY29uZmlnX2dldF9saW5lKGJ1Ziwgc2l6ZW9mKGJ1ZiksIGYsIGxpbmUsICZwb3MpKSB7CiAJCWlmIChvc19zdHJjbXAocG9zLCAifSIpID09IDApIHsKQEAgLTM1MSw4ICszNTIsOCBAQAogCUZJTEUgKmY7CiAJY2hhciBidWZbNTEyXSwgKnBvczsKIAlpbnQgZXJyb3JzID0gMCwgbGluZSA9IDA7Ci0Jc3RydWN0IHdwYV9zc2lkICpzc2lkLCAqdGFpbCA9IE5VTEwsICpoZWFkID0gTlVMTDsKLQlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpjcmVkX3RhaWwgPSBOVUxMLCAqY3JlZF9oZWFkID0gTlVMTDsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsICp0YWlsLCAqaGVhZDsKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpjcmVkX3RhaWwsICpjcmVkX2hlYWQ7CiAJc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZzsKIAlpbnQgaWQgPSAwOwogCWludCBjcmVkX2lkID0gMDsKQEAgLTM2OCw4ICszNjksMTIgQEAKIAkJCSAgICJzdHJ1Y3R1cmUiKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQotCWhlYWQgPSBjb25maWctPnNzaWQ7Ci0JY3JlZF9oZWFkID0gY29uZmlnLT5jcmVkOworCXRhaWwgPSBoZWFkID0gY29uZmlnLT5zc2lkOworCXdoaWxlICh0YWlsICYmIHRhaWwtPm5leHQpCisJCXRhaWwgPSB0YWlsLT5uZXh0OworCWNyZWRfdGFpbCA9IGNyZWRfaGVhZCA9IGNvbmZpZy0+Y3JlZDsKKwl3aGlsZSAoY3JlZF90YWlsICYmIGNyZWRfdGFpbC0+bmV4dCkKKwkJY3JlZF90YWlsID0gY3JlZF90YWlsLT5uZXh0OwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSZWFkaW5nIGNvbmZpZ3VyYXRpb24gZmlsZSAnJXMnIiwgbmFtZSk7CiAJZiA9IGZvcGVuKG5hbWUsICJyIik7CkBAIC02MDYsNiArNjExLDE1IEBACiAKICNpZmRlZiBDT05GSUdfUDJQCiAKK3N0YXRpYyB2b2lkIHdyaXRlX2dvX3AycF9kZXZfYWRkcihGSUxFICpmLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCit7CisJY2hhciAqdmFsdWUgPSB3cGFfY29uZmlnX2dldChzc2lkLCAiZ29fcDJwX2Rldl9hZGRyIik7CisJaWYgKHZhbHVlID09IE5VTEwpCisJCXJldHVybjsKKwlmcHJpbnRmKGYsICJcdGdvX3AycF9kZXZfYWRkcj0lc1xuIiwgdmFsdWUpOworCW9zX2ZyZWUodmFsdWUpOworfQorCiBzdGF0aWMgdm9pZCB3cml0ZV9wMnBfY2xpZW50X2xpc3QoRklMRSAqZiwgc3RydWN0IHdwYV9zc2lkICpzc2lkKQogewogCWNoYXIgKnZhbHVlID0gd3BhX2NvbmZpZ19nZXQoc3NpZCwgInAycF9jbGllbnRfbGlzdCIpOwpAQCAtNjUzLDYgKzY2Nyw3IEBACiAJd3JpdGVfYXV0aF9hbGcoZiwgc3NpZCk7CiAJU1RSKGJnc2Nhbik7CiAJU1RSKGF1dG9zY2FuKTsKKwlTVFIoc2Nhbl9mcmVxKTsKICNpZmRlZiBJRUVFODAyMVhfRUFQT0wKIAl3cml0ZV9lYXAoZiwgc3NpZCk7CiAJU1RSKGlkZW50aXR5KTsKQEAgLTY2Niw2ICs2ODEsNyBAQAogCVNUUihkaF9maWxlKTsKIAlTVFIoc3ViamVjdF9tYXRjaCk7CiAJU1RSKGFsdHN1YmplY3RfbWF0Y2gpOworCVNUUihkb21haW5fc3VmZml4X21hdGNoKTsKIAlTVFIoY2FfY2VydDIpOwogCVNUUihjYV9wYXRoMik7CiAJU1RSKGNsaWVudF9jZXJ0Mik7CkBAIC02NzQsNiArNjkwLDcgQEAKIAlTVFIoZGhfZmlsZTIpOwogCVNUUihzdWJqZWN0X21hdGNoMik7CiAJU1RSKGFsdHN1YmplY3RfbWF0Y2gyKTsKKwlTVFIoZG9tYWluX3N1ZmZpeF9tYXRjaDIpOwogCVNUUihwaGFzZTEpOwogCVNUUihwaGFzZTIpOwogCVNUUihwY3NjKTsKQEAgLTY5OSw2ICs3MTYsOCBAQAogCUlOVF9ERUYoZWFwX3dvcmthcm91bmQsIERFRkFVTFRfRUFQX1dPUktBUk9VTkQpOwogCVNUUihwYWNfZmlsZSk7CiAJSU5UX0RFRmUoZnJhZ21lbnRfc2l6ZSwgREVGQVVMVF9GUkFHTUVOVF9TSVpFKTsKKwlJTlRlKG9jc3ApOworCUlOVF9ERUZlKHNpbV9udW0sIERFRkFVTFRfVVNFUl9TRUxFQ1RFRF9TSU0pOwogI2VuZGlmIC8qIElFRUU4MDIxWF9FQVBPTCAqLwogCUlOVChtb2RlKTsKIAlJTlQoZnJlcXVlbmN5KTsKQEAgLTcxMSwxMSArNzMwLDE4IEBACiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIAlTVFIoaWRfc3RyKTsKICNpZmRlZiBDT05GSUdfUDJQCisJd3JpdGVfZ29fcDJwX2Rldl9hZGRyKGYsIHNzaWQpOwogCXdyaXRlX3AycF9jbGllbnRfbGlzdChmLCBzc2lkKTsKIAl3cml0ZV9wc2tfbGlzdChmLCBzc2lkKTsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJSU5UKGR0aW1fcGVyaW9kKTsKIAlJTlQoYmVhY29uX2ludCk7CisjaWZkZWYgQ09ORklHX01BQ1NFQworCUlOVChtYWNzZWNfcG9saWN5KTsKKyNlbmRpZiAvKiBDT05GSUdfTUFDU0VDICovCisjaWZkZWYgQ09ORklHX0hTMjAKKwlJTlQodXBkYXRlX2lkZW50aWZpZXIpOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKICN1bmRlZiBTVFIKICN1bmRlZiBJTlQKQEAgLTcyNSw2ICs3NTEsOCBAQAogCiBzdGF0aWMgdm9pZCB3cGFfY29uZmlnX3dyaXRlX2NyZWQoRklMRSAqZiwgc3RydWN0IHdwYV9jcmVkICpjcmVkKQogeworCXNpemVfdCBpOworCiAJaWYgKGNyZWQtPnByaW9yaXR5KQogCQlmcHJpbnRmKGYsICJcdHByaW9yaXR5PSVkXG4iLCBjcmVkLT5wcmlvcml0eSk7CiAJaWYgKGNyZWQtPnBjc2MpCkBAIC03NTAsMTAgKzc3OCwxMiBAQAogCQlmcHJpbnRmKGYsICJcdGltc2k9XCIlc1wiXG4iLCBjcmVkLT5pbXNpKTsKIAlpZiAoY3JlZC0+bWlsZW5hZ2UpCiAJCWZwcmludGYoZiwgIlx0bWlsZW5hZ2U9XCIlc1wiXG4iLCBjcmVkLT5taWxlbmFnZSk7Ci0JaWYgKGNyZWQtPmRvbWFpbikKLQkJZnByaW50ZihmLCAiXHRkb21haW49XCIlc1wiXG4iLCBjcmVkLT5kb21haW4pOworCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5udW1fZG9tYWluOyBpKyspCisJCWZwcmludGYoZiwgIlx0ZG9tYWluPVwiJXNcIlxuIiwgY3JlZC0+ZG9tYWluW2ldKTsKKwlpZiAoY3JlZC0+ZG9tYWluX3N1ZmZpeF9tYXRjaCkKKwkJZnByaW50ZihmLCAiXHRkb21haW5fc3VmZml4X21hdGNoPVwiJXNcIlxuIiwKKwkJCWNyZWQtPmRvbWFpbl9zdWZmaXhfbWF0Y2gpOwogCWlmIChjcmVkLT5yb2FtaW5nX2NvbnNvcnRpdW1fbGVuKSB7Ci0JCXNpemVfdCBpOwogCQlmcHJpbnRmKGYsICJcdHJvYW1pbmdfY29uc29ydGl1bT0iKTsKIAkJZm9yIChpID0gMDsgaSA8IGNyZWQtPnJvYW1pbmdfY29uc29ydGl1bV9sZW47IGkrKykKIAkJCWZwcmludGYoZiwgIiUwMngiLCBjcmVkLT5yb2FtaW5nX2NvbnNvcnRpdW1baV0pOwpAQCAtNzYzLDE0ICs3OTMsMTUgQEAKIAkJY29uc3QgY2hhciAqbmFtZTsKIAkJbmFtZSA9IGVhcF9nZXRfbmFtZShjcmVkLT5lYXBfbWV0aG9kWzBdLnZlbmRvciwKIAkJCQkgICAgY3JlZC0+ZWFwX21ldGhvZFswXS5tZXRob2QpOwotCQlmcHJpbnRmKGYsICJcdGVhcD0lc1xuIiwgbmFtZSk7CisJCWlmIChuYW1lKQorCQkJZnByaW50ZihmLCAiXHRlYXA9JXNcbiIsIG5hbWUpOwogCX0KIAlpZiAoY3JlZC0+cGhhc2UxKQogCQlmcHJpbnRmKGYsICJcdHBoYXNlMT1cIiVzXCJcbiIsIGNyZWQtPnBoYXNlMSk7CiAJaWYgKGNyZWQtPnBoYXNlMikKIAkJZnByaW50ZihmLCAiXHRwaGFzZTI9XCIlc1wiXG4iLCBjcmVkLT5waGFzZTIpOwogCWlmIChjcmVkLT5leGNsdWRlZF9zc2lkKSB7Ci0JCXNpemVfdCBpLCBqOworCQlzaXplX3QgajsKIAkJZm9yIChpID0gMDsgaSA8IGNyZWQtPm51bV9leGNsdWRlZF9zc2lkOyBpKyspIHsKIAkJCXN0cnVjdCBleGNsdWRlZF9zc2lkICplID0gJmNyZWQtPmV4Y2x1ZGVkX3NzaWRbaV07CiAJCQlmcHJpbnRmKGYsICJcdGV4Y2x1ZGVkX3NzaWQ9Iik7CkBAIC03NzksNiArODEwLDcwIEBACiAJCQlmcHJpbnRmKGYsICJcbiIpOwogCQl9CiAJfQorCWlmIChjcmVkLT5yb2FtaW5nX3BhcnRuZXIpIHsKKwkJZm9yIChpID0gMDsgaSA8IGNyZWQtPm51bV9yb2FtaW5nX3BhcnRuZXI7IGkrKykgeworCQkJc3RydWN0IHJvYW1pbmdfcGFydG5lciAqcCA9ICZjcmVkLT5yb2FtaW5nX3BhcnRuZXJbaV07CisJCQlmcHJpbnRmKGYsICJcdHJvYW1pbmdfcGFydG5lcj1cIiVzLCVkLCV1LCVzXCJcbiIsCisJCQkJcC0+ZnFkbiwgcC0+ZXhhY3RfbWF0Y2gsIHAtPnByaW9yaXR5LAorCQkJCXAtPmNvdW50cnkpOworCQl9CisJfQorCWlmIChjcmVkLT51cGRhdGVfaWRlbnRpZmllcikKKwkJZnByaW50ZihmLCAiXHR1cGRhdGVfaWRlbnRpZmllcj0lZFxuIiwgY3JlZC0+dXBkYXRlX2lkZW50aWZpZXIpOworCisJaWYgKGNyZWQtPnByb3Zpc2lvbmluZ19zcCkKKwkJZnByaW50ZihmLCAiXHRwcm92aXNpb25pbmdfc3A9XCIlc1wiXG4iLCBjcmVkLT5wcm92aXNpb25pbmdfc3ApOworCWlmIChjcmVkLT5zcF9wcmlvcml0eSkKKwkJZnByaW50ZihmLCAiXHRzcF9wcmlvcml0eT0lZFxuIiwgY3JlZC0+c3BfcHJpb3JpdHkpOworCisJaWYgKGNyZWQtPm1pbl9kbF9iYW5kd2lkdGhfaG9tZSkKKwkJZnByaW50ZihmLCAiXHRtaW5fZGxfYmFuZHdpZHRoX2hvbWU9JXVcbiIsCisJCQljcmVkLT5taW5fZGxfYmFuZHdpZHRoX2hvbWUpOworCWlmIChjcmVkLT5taW5fdWxfYmFuZHdpZHRoX2hvbWUpCisJCWZwcmludGYoZiwgIlx0bWluX3VsX2JhbmR3aWR0aF9ob21lPSV1XG4iLAorCQkJY3JlZC0+bWluX3VsX2JhbmR3aWR0aF9ob21lKTsKKwlpZiAoY3JlZC0+bWluX2RsX2JhbmR3aWR0aF9yb2FtaW5nKQorCQlmcHJpbnRmKGYsICJcdG1pbl9kbF9iYW5kd2lkdGhfcm9hbWluZz0ldVxuIiwKKwkJCWNyZWQtPm1pbl9kbF9iYW5kd2lkdGhfcm9hbWluZyk7CisJaWYgKGNyZWQtPm1pbl91bF9iYW5kd2lkdGhfcm9hbWluZykKKwkJZnByaW50ZihmLCAiXHRtaW5fdWxfYmFuZHdpZHRoX3JvYW1pbmc9JXVcbiIsCisJCQljcmVkLT5taW5fdWxfYmFuZHdpZHRoX3JvYW1pbmcpOworCisJaWYgKGNyZWQtPm1heF9ic3NfbG9hZCkKKwkJZnByaW50ZihmLCAiXHRtYXhfYnNzX2xvYWQ9JXVcbiIsCisJCQljcmVkLT5tYXhfYnNzX2xvYWQpOworCisJaWYgKGNyZWQtPm9jc3ApCisJCWZwcmludGYoZiwgIlx0b2NzcD0lZFxuIiwgY3JlZC0+b2NzcCk7CisKKwlpZiAoY3JlZC0+bnVtX3JlcV9jb25uX2NhcGFiKSB7CisJCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5udW1fcmVxX2Nvbm5fY2FwYWI7IGkrKykgeworCQkJaW50ICpwb3J0czsKKworCQkJZnByaW50ZihmLCAiXHRyZXFfY29ubl9jYXBhYj0ldSIsCisJCQkJY3JlZC0+cmVxX2Nvbm5fY2FwYWJfcHJvdG9baV0pOworCQkJcG9ydHMgPSBjcmVkLT5yZXFfY29ubl9jYXBhYl9wb3J0W2ldOworCQkJaWYgKHBvcnRzKSB7CisJCQkJaW50IGo7CisJCQkJZm9yIChqID0gMDsgcG9ydHNbal0gIT0gLTE7IGorKykgeworCQkJCQlmcHJpbnRmKGYsICIlcyVkIiwgaiA+IDAgPyAiLCIgOiAiOiIsCisJCQkJCQlwb3J0c1tqXSk7CisJCQkJfQorCQkJfQorCQkJZnByaW50ZihmLCAiXG4iKTsKKwkJfQorCX0KKworCWlmIChjcmVkLT5yZXF1aXJlZF9yb2FtaW5nX2NvbnNvcnRpdW1fbGVuKSB7CisJCWZwcmludGYoZiwgIlx0cmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtPSIpOworCQlmb3IgKGkgPSAwOyBpIDwgY3JlZC0+cmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtX2xlbjsgaSsrKQorCQkJZnByaW50ZihmLCAiJTAyeCIsCisJCQkJY3JlZC0+cmVxdWlyZWRfcm9hbWluZ19jb25zb3J0aXVtW2ldKTsKKwkJZnByaW50ZihmLCAiXG4iKTsKKwl9CisKKwlpZiAoY3JlZC0+c2ltX251bSAhPSBERUZBVUxUX1VTRVJfU0VMRUNURURfU0lNKQorCQlmcHJpbnRmKGYsICJcdHNpbV9udW09JWRcbiIsIGNyZWQtPnNpbV9udW0pOwogfQogCiAKQEAgLTkyNCw2ICsxMDE5LDkgQEAKIAkJZnByaW50ZihmLCAicDJwX2ludHJhX2Jzcz0ldVxuIiwgY29uZmlnLT5wMnBfaW50cmFfYnNzKTsKIAlpZiAoY29uZmlnLT5wMnBfZ3JvdXBfaWRsZSkKIAkJZnByaW50ZihmLCAicDJwX2dyb3VwX2lkbGU9JXVcbiIsIGNvbmZpZy0+cDJwX2dyb3VwX2lkbGUpOworCWlmIChjb25maWctPnAycF9wYXNzcGhyYXNlX2xlbikKKwkJZnByaW50ZihmLCAicDJwX3Bhc3NwaHJhc2VfbGVuPSV1XG4iLAorCQkJY29uZmlnLT5wMnBfcGFzc3BocmFzZV9sZW4pOwogCWlmIChjb25maWctPnAycF9wcmVmX2NoYW4pIHsKIAkJdW5zaWduZWQgaW50IGk7CiAJCWZwcmludGYoZiwgInAycF9wcmVmX2NoYW49Iik7CkBAIC05MzQsOCArMTAzMiwyMyBAQAogCQl9CiAJCWZwcmludGYoZiwgIlxuIik7CiAJfQorCWlmIChjb25maWctPnAycF9ub19nb19mcmVxLm51bSkgeworCQljaGFyICp2YWwgPSBmcmVxX3JhbmdlX2xpc3Rfc3RyKCZjb25maWctPnAycF9ub19nb19mcmVxKTsKKwkJaWYgKHZhbCkgeworCQkJZnByaW50ZihmLCAicDJwX25vX2dvX2ZyZXE9JXNcbiIsIHZhbCk7CisJCQlvc19mcmVlKHZhbCk7CisJCX0KKwl9CisJaWYgKGNvbmZpZy0+cDJwX2FkZF9jbGlfY2hhbikKKwkJZnByaW50ZihmLCAicDJwX2FkZF9jbGlfY2hhbj0lZFxuIiwgY29uZmlnLT5wMnBfYWRkX2NsaV9jaGFuKTsKKwlpZiAoY29uZmlnLT5wMnBfb3B0aW1pemVfbGlzdGVuX2NoYW4gIT0KKwkgICAgREVGQVVMVF9QMlBfT1BUSU1JWkVfTElTVEVOX0NIQU4pCisJCWZwcmludGYoZiwgInAycF9vcHRpbWl6ZV9saXN0ZW5fY2hhbj0lZFxuIiwKKwkJCWNvbmZpZy0+cDJwX29wdGltaXplX2xpc3Rlbl9jaGFuKTsKIAlpZiAoY29uZmlnLT5wMnBfZ29faHQ0MCkKIAkJZnByaW50ZihmLCAicDJwX2dvX2h0NDA9JXVcbiIsIGNvbmZpZy0+cDJwX2dvX2h0NDApOworCWlmIChjb25maWctPnAycF9nb192aHQpCisJCWZwcmludGYoZiwgInAycF9nb192aHQ9JXVcbiIsIGNvbmZpZy0+cDJwX2dvX3ZodCk7CiAJaWYgKGNvbmZpZy0+cDJwX2Rpc2FibGVkKQogCQlmcHJpbnRmKGYsICJwMnBfZGlzYWJsZWQ9JXVcbiIsIGNvbmZpZy0+cDJwX2Rpc2FibGVkKTsKIAlpZiAoY29uZmlnLT5wMnBfbm9fZ3JvdXBfaWZhY2UpCkBAIC0xMDQ5LDkgKzExNjIsMjMgQEAKIAkJZnByaW50ZihmLCAic2NoZWRfc2Nhbl9pbnRlcnZhbD0ldVxuIiwKIAkJCWNvbmZpZy0+c2NoZWRfc2Nhbl9pbnRlcnZhbCk7CiAKKwlpZiAoY29uZmlnLT5leHRlcm5hbF9zaW0pCisJCWZwcmludGYoZiwgImV4dGVybmFsX3NpbT0lZFxuIiwgY29uZmlnLT5leHRlcm5hbF9zaW0pOworCiAJaWYgKGNvbmZpZy0+dGRsc19leHRlcm5hbF9jb250cm9sKQotCQlmcHJpbnRmKGYsICJ0ZGxzX2V4dGVybmFsX2NvbnRyb2w9JXVcbiIsCisJCWZwcmludGYoZiwgInRkbHNfZXh0ZXJuYWxfY29udHJvbD0lZFxuIiwKIAkJCWNvbmZpZy0+dGRsc19leHRlcm5hbF9jb250cm9sKTsKKworCWlmIChjb25maWctPndvd2xhbl90cmlnZ2VycykKKwkJZnByaW50ZihmLCAid293bGFuX3RyaWdnZXJzPSVzXG4iLAorCQkJY29uZmlnLT53b3dsYW5fdHJpZ2dlcnMpOworCisJaWYgKGNvbmZpZy0+YmdzY2FuKQorCQlmcHJpbnRmKGYsICJiZ3NjYW49XCIlc1wiXG4iLCBjb25maWctPmJnc2Nhbik7CisKKwlpZiAoY29uZmlnLT5wMnBfc2VhcmNoX2RlbGF5ICE9IERFRkFVTFRfUDJQX1NFQVJDSF9ERUxBWSkKKwkJZnByaW50ZihmLCAicDJwX3NlYXJjaF9kZWxheT0ldVxuIiwKKwkJCWNvbmZpZy0+cDJwX3NlYXJjaF9kZWxheSk7CiB9CiAKICNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX1dSSVRFICovCkBAIC0xMDc5LDYgKzEyMDYsOCBAQAogCXdwYV9jb25maWdfd3JpdGVfZ2xvYmFsKGYsIGNvbmZpZyk7CiAKIAlmb3IgKGNyZWQgPSBjb25maWctPmNyZWQ7IGNyZWQ7IGNyZWQgPSBjcmVkLT5uZXh0KSB7CisJCWlmIChjcmVkLT50ZW1wb3JhcnkpCisJCQljb250aW51ZTsKIAkJZnByaW50ZihmLCAiXG5jcmVkPXtcbiIpOwogCQl3cGFfY29uZmlnX3dyaXRlX2NyZWQoZiwgY3JlZCk7CiAJCWZwcmludGYoZiwgIn1cbiIpOwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvY29uZmlnX3NzaWQuaCBiL3dwYV9zdXBwbGljYW50L2NvbmZpZ19zc2lkLmgKaW5kZXggYzZlYTk2My4uYWI0NzRmZiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvY29uZmlnX3NzaWQuaAorKysgYi93cGFfc3VwcGxpY2FudC9jb25maWdfc3NpZC5oCkBAIC0zMCw5ICszMCwxMSBAQAogI2RlZmluZSBERUZBVUxUX0RJU0FCTEVfSFQgMAogI2RlZmluZSBERUZBVUxUX0RJU0FCTEVfSFQ0MCAwCiAjZGVmaW5lIERFRkFVTFRfRElTQUJMRV9TR0kgMAorI2RlZmluZSBERUZBVUxUX0RJU0FCTEVfTERQQyAwCiAjZGVmaW5lIERFRkFVTFRfRElTQUJMRV9NQVhfQU1TRFUgLTEgLyogbm8gY2hhbmdlICovCiAjZGVmaW5lIERFRkFVTFRfQU1QRFVfRkFDVE9SIC0xIC8qIG5vIGNoYW5nZSAqLwogI2RlZmluZSBERUZBVUxUX0FNUERVX0RFTlNJVFkgLTEgLyogbm8gY2hhbmdlICovCisjZGVmaW5lIERFRkFVTFRfVVNFUl9TRUxFQ1RFRF9TSU0gMQogCiBzdHJ1Y3QgcHNrX2xpc3RfZW50cnkgewogCXN0cnVjdCBkbF9saXN0IGxpc3Q7CkBAIC0xMzEsNiArMTMzLDExIEBACiAJaW50IGJzc2lkX3NldDsKIAogCS8qKgorCSAqIGdvX3AycF9kZXZfYWRkciAtIEdPJ3MgUDJQIERldmljZSBBZGRyZXNzIG9yIGFsbCB6ZXJvcyBpZiBub3Qgc2V0CisJICovCisJdTggZ29fcDJwX2Rldl9hZGRyW0VUSF9BTEVOXTsKKworCS8qKgogCSAqIHBzayAtIFdQQSBwcmUtc2hhcmVkIGtleSAoMjU2IGJpdHMpCiAJICovCiAJdTggcHNrWzMyXTsKQEAgLTMxMCwxMiArMzE3LDEzIEBACiAJICogNCA9IFAyUCBHcm91cCBGb3JtYXRpb24gKHVzZWQgaW50ZXJuYWxseTsgbm90IGluIGNvbmZpZ3VyYXRpb24KIAkgKiBmaWxlcykKIAkgKgotCSAqIE5vdGU6IElCU1MgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIGtleV9tZ210IE5PTkUgKHBsYWludGV4dCBhbmQKLQkgKiBzdGF0aWMgV0VQKSBhbmQga2V5X21nbXQ9V1BBLU5PTkUgKGZpeGVkIGdyb3VwIGtleSBUS0lQL0NDTVApLiBJbgotCSAqIGFkZGl0aW9uLCBhcF9zY2FuIGhhcyB0byBiZSBzZXQgdG8gMiBmb3IgSUJTUy4gV1BBLU5vbmUgcmVxdWlyZXMKLQkgKiBmb2xsb3dpbmcgbmV0d29yayBibG9jayBvcHRpb25zOiBwcm90bz1XUEEsIGtleV9tZ210PVdQQS1OT05FLAotCSAqIHBhaXJ3aXNlPU5PTkUsIGdyb3VwPVRLSVAgKG9yIENDTVAsIGJ1dCBub3QgYm90aCksIGFuZCBwc2sgbXVzdCBhbHNvCi0JICogYmUgc2V0IChlaXRoZXIgZGlyZWN0bHkgb3IgdXNpbmcgQVNDSUkgcGFzc3BocmFzZSkuCisJICogTm90ZTogSUJTUyBjYW4gb25seSBiZSB1c2VkIHdpdGgga2V5X21nbXQgTk9ORSAocGxhaW50ZXh0IGFuZCBzdGF0aWMKKwkgKiBXRVApIGFuZCBXUEEtUFNLICh3aXRoIHByb3RvPVJTTikuIEluIGFkZGl0aW9uLCBrZXlfbWdtdD1XUEEtTk9ORQorCSAqIChmaXhlZCBncm91cCBrZXkgVEtJUC9DQ01QKSBpcyBhdmFpbGFibGUgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LAorCSAqIGJ1dCBpdHMgdXNlIGlzIGRlcHJlY2F0ZWQuIFdQQS1Ob25lIHJlcXVpcmVzIGZvbGxvd2luZyBuZXR3b3JrIGJsb2NrCisJICogb3B0aW9uczogcHJvdG89V1BBLCBrZXlfbWdtdD1XUEEtTk9ORSwgcGFpcndpc2U9Tk9ORSwgZ3JvdXA9VEtJUCAob3IKKwkgKiBDQ01QLCBidXQgbm90IGJvdGgpLCBhbmQgcHNrIG11c3QgYWxzbyBiZSBzZXQgKGVpdGhlciBkaXJlY3RseSBvcgorCSAqIHVzaW5nIEFTQ0lJIHBhc3NwaHJhc2UpLgogCSAqLwogCWVudW0gd3Bhc19tb2RlIHsKIAkJV1BBU19NT0RFX0lORlJBID0gMCwKQEAgLTM5NCw2ICs0MDIsOCBAQAogCiAJaW50IGh0NDA7CiAKKwlpbnQgdmh0OworCiAJLyoqCiAJICogd3BhX3B0a19yZWtleSAtIE1heGltdW0gbGlmZXRpbWUgZm9yIFBUSyBpbiBzZWNvbmRzCiAJICoKQEAgLTQ5MSwxMyArNTAxLDYgQEAKIAkgKi8KIAlpbnQgZXhwb3J0X2tleXM7CiAKLSNpZmRlZiBBTkRST0lEX1AyUAotCS8qKgotCSAqIGFzc29jX3JldHJ5IC0gTnVtYmVyIG9mIHRpbWVzIGFzc29jaWF0aW9uIHNob3VsZCBiZSByZXRyaWVkLgotCSAqLwotCWludCBhc3NvY19yZXRyeTsKLSNlbmRpZgotCiAjaWZkZWYgQ09ORklHX0hUX09WRVJSSURFUwogCS8qKgogCSAqIGRpc2FibGVfaHQgLSBEaXNhYmxlIEhUIChJRUVFIDgwMi4xMW4pIGZvciB0aGlzIG5ldHdvcmsKQEAgLTUyNCw2ICs1MjcsMTkgQEAKIAlpbnQgZGlzYWJsZV9zZ2k7CiAKIAkvKioKKwkgKiBkaXNhYmxlX2xkcGMgLSBEaXNhYmxlIExEUEMgZm9yIHRoaXMgbmV0d29yaworCSAqCisJICogQnkgZGVmYXVsdCwgdXNlIGl0IGlmIGl0IGlzIGF2YWlsYWJsZSwgYnV0IHRoaXMgY2FuIGJlIGNvbmZpZ3VyZWQKKwkgKiB0byAxIHRvIGhhdmUgaXQgZGlzYWJsZWQuCisJICovCisJaW50IGRpc2FibGVfbGRwYzsKKworCS8qKgorCSAqIGh0NDBfaW50b2xlcmFudCAtIEluZGljYXRlIDQwIE1IeiBpbnRvbGVyYW50IGZvciB0aGlzIG5ldHdvcmsKKwkgKi8KKwlpbnQgaHQ0MF9pbnRvbGVyYW50OworCisJLyoqCiAJICogZGlzYWJsZV9tYXhfYW1zZHUgLSBEaXNhYmxlIE1BWCBBLU1TRFUKIAkgKgogCSAqIEEtTURTVSB3aWxsIGJlIDM4MzkgYnl0ZXMgd2hlbiBkaXNhYmxlZCwgb3IgNzkzNQpAQCAtNjEwLDcgKzYyNiw3IEBACiAJLyoqCiAJICogZGlzYWJsZWRfdW50aWwgLSBOZXR3b3JrIGJsb2NrIGRpc2FibGVkIHVudGlsIHRoaXMgdGltZSBpZiBub24temVybwogCSAqLwotCXN0cnVjdCBvc190aW1lIGRpc2FibGVkX3VudGlsOworCXN0cnVjdCBvc19yZWx0aW1lIGRpc2FibGVkX3VudGlsOwogCiAJLyoqCiAJICogcGFyZW50X2NyZWQgLSBQb2ludGVyIHRvIHBhcmVudCB3cGFfY3JlZCBlbnRyeQpAQCAtNjIwLDYgKzYzNiwyMSBAQAogCSAqIGRlcmVmZXJlbmNlcyBzaW5jZSBpdCBtYXkgbm90IGJlIHVwZGF0ZWQgaW4gYWxsIGNhc2VzLgogCSAqLwogCXZvaWQgKnBhcmVudF9jcmVkOworCisjaWZkZWYgQ09ORklHX01BQ1NFQworCS8qKgorCSAqIG1hY3NlY19wb2xpY3kgLSBEZXRlcm1pbmVzIHRoZSBwb2xpY3kgZm9yIE1BQ3NlYyBzZWN1cmUgc2Vzc2lvbgorCSAqCisJICogMDogTUFDc2VjIG5vdCBpbiB1c2UgKGRlZmF1bHQpCisJICogMTogTUFDc2VjIGVuYWJsZWQgLSBTaG91bGQgc2VjdXJlLCBhY2NlcHQga2V5IHNlcnZlcidzIGFkdmljZSB0bworCSAqICAgIGRldGVybWluZSB3aGV0aGVyIHRvIHVzZSBhIHNlY3VyZSBzZXNzaW9uIG9yIG5vdC4KKwkgKi8KKwlpbnQgbWFjc2VjX3BvbGljeTsKKyNlbmRpZiAvKiBDT05GSUdfTUFDU0VDICovCisKKyNpZmRlZiBDT05GSUdfSFMyMAorCWludCB1cGRhdGVfaWRlbnRpZmllcjsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogfTsKIAogI2VuZGlmIC8qIENPTkZJR19TU0lEX0ggKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2NvbmZpZ193aW5yZWcuYyBiL3dwYV9zdXBwbGljYW50L2NvbmZpZ193aW5yZWcuYwppbmRleCAxYjVlMjM3Li4xOTlmMDRmIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jb25maWdfd2lucmVnLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvY29uZmlnX3dpbnJlZy5jCkBAIC02MjMsNiArNjIzLDkgQEAKIAl3cGFfY29uZmlnX3dyaXRlX3JlZ19kd29yZChoaywgVEVYVCgib2tjIiksIGNvbmZpZy0+b2tjLCAwKTsKIAl3cGFfY29uZmlnX3dyaXRlX3JlZ19kd29yZChoaywgVEVYVCgicG1mIiksIGNvbmZpZy0+cG1mLCAwKTsKIAorCXdwYV9jb25maWdfd3JpdGVfcmVnX2R3b3JkKGhrLCBURVhUKCJleHRlcm5hbF9zaW0iKSwKKwkJCQkgICBjb25maWctPmV4dGVybmFsX3NpbSwgMCk7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtOTI3LDYgKzkzMCw5IEBACiAJCSAgTUdNVF9GUkFNRV9QUk9URUNUSU9OX0RFRkFVTFQpOwogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAJU1RSKGlkX3N0cik7CisjaWZkZWYgQ09ORklHX0hTMjAKKwlJTlQodXBkYXRlX2lkZW50aWZpZXIpOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKICN1bmRlZiBTVFIKICN1bmRlZiBJTlQKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2UuYyBiL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2UuYwppbmRleCA2MzM1NjA1Li43OTgwNmQ5IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvY3RybF9pZmFjZS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC8gQ29udHJvbCBpbnRlcmZhY2UgKHNoYXJlZCBjb2RlIGZvciBhbGwgYmFja2VuZHMpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xMCw2ICsxMCw3IEBACiAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKICNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgorI2luY2x1ZGUgInV0aWxzL3V1aWQuaCIKICNpbmNsdWRlICJjb21tb24vdmVyc2lvbi5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9jb21tb24uaCIKQEAgLTM5LDEwNCArNDAsMTQgQEAKICNpbmNsdWRlICJibGFja2xpc3QuaCIKICNpbmNsdWRlICJhdXRvc2Nhbi5oIgogI2luY2x1ZGUgIndubV9zdGEuaCIKLQotZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyAqd3BhX2RyaXZlcnNbXTsKKyNpbmNsdWRlICJvZmZjaGFubmVsLmgiCiAKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2lmYWNlX2xpc3Qoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwKIAkJCQkJICAgIGNoYXIgKmJ1ZiwgaW50IGxlbik7CiBzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2dsb2JhbF9pZmFjZV9pbnRlcmZhY2VzKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCiAJCQkJCQkgIGNoYXIgKmJ1ZiwgaW50IGxlbik7Ci0KLQotc3RhdGljIGludCBwbm9fc3RhcnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKLXsKLQlpbnQgcmV0OwotCXNpemVfdCBpLCBudW1fc3NpZDsKLQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7Ci0Jc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgcGFyYW1zOwotCi0JaWYgKHdwYV9zLT5wbm8pCi0JCXJldHVybiAwOwotCi0JaWYgKCh3cGFfcy0+d3BhX3N0YXRlID4gV1BBX1NDQU5OSU5HKSAmJgotCSAgICAod3BhX3MtPndwYV9zdGF0ZSA8PSBXUEFfQ09NUExFVEVEKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIlBOTzogSW4gYXNzb2MgcHJvY2VzcyIpOwotCQlyZXR1cm4gLUVBR0FJTjsKLQl9Ci0KLQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfU0NBTk5JTkcpIHsKLQkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjaGVkX3NjYW4od3BhX3MpOwotCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2Nhbih3cGFfcyk7Ci0JfQotCi0Jb3NfbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKLQotCW51bV9zc2lkID0gMDsKLQlzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7Ci0Jd2hpbGUgKHNzaWQpIHsKLQkJaWYgKCF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIHNzaWQpKQotCQkJbnVtX3NzaWQrKzsKLQkJc3NpZCA9IHNzaWQtPm5leHQ7Ci0JfQotCWlmIChudW1fc3NpZCA+IFdQQVNfTUFYX1NDQU5fU1NJRFMpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQTk86IFVzZSBvbmx5IHRoZSBmaXJzdCAldSBTU0lEcyBmcm9tICIKLQkJCSAgICIldSIsIFdQQVNfTUFYX1NDQU5fU1NJRFMsICh1bnNpZ25lZCBpbnQpIG51bV9zc2lkKTsKLQkJbnVtX3NzaWQgPSBXUEFTX01BWF9TQ0FOX1NTSURTOwotCX0KLQotCWlmIChudW1fc3NpZCA9PSAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUE5POiBObyBjb25maWd1cmVkIFNTSURzIik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlwYXJhbXMuZmlsdGVyX3NzaWRzID0gb3NfbWFsbG9jKHNpemVvZihzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX2ZpbHRlcikgKgotCQkJCQludW1fc3NpZCk7Ci0JaWYgKHBhcmFtcy5maWx0ZXJfc3NpZHMgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwotCWkgPSAwOwotCXNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKLQl3aGlsZSAoc3NpZCkgewotCQlpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkpIHsKLQkJCXBhcmFtcy5zc2lkc1tpXS5zc2lkID0gc3NpZC0+c3NpZDsKLQkJCXBhcmFtcy5zc2lkc1tpXS5zc2lkX2xlbiA9IHNzaWQtPnNzaWRfbGVuOwotCQkJcGFyYW1zLm51bV9zc2lkcysrOwotCQkJb3NfbWVtY3B5KHBhcmFtcy5maWx0ZXJfc3NpZHNbaV0uc3NpZCwgc3NpZC0+c3NpZCwKLQkJCQkgIHNzaWQtPnNzaWRfbGVuKTsKLQkJCXBhcmFtcy5maWx0ZXJfc3NpZHNbaV0uc3NpZF9sZW4gPSBzc2lkLT5zc2lkX2xlbjsKLQkJCXBhcmFtcy5udW1fZmlsdGVyX3NzaWRzKys7Ci0JCQlpKys7Ci0JCQlpZiAoaSA9PSBudW1fc3NpZCkKLQkJCQlicmVhazsKLQkJfQotCQlzc2lkID0gc3NpZC0+bmV4dDsKLQl9Ci0KLQlpZiAod3BhX3MtPmNvbmYtPmZpbHRlcl9yc3NpKQotCQlwYXJhbXMuZmlsdGVyX3Jzc2kgPSB3cGFfcy0+Y29uZi0+ZmlsdGVyX3Jzc2k7Ci0KLQlyZXQgPSB3cGFfZHJ2X3NjaGVkX3NjYW4od3BhX3MsICZwYXJhbXMsIDEwICogMTAwMCk7Ci0Jb3NfZnJlZShwYXJhbXMuZmlsdGVyX3NzaWRzKTsKLQlpZiAocmV0ID09IDApCi0JCXdwYV9zLT5wbm8gPSAxOwotCXJldHVybiByZXQ7Ci19Ci0KLQotc3RhdGljIGludCBwbm9fc3RvcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQotewotCWludCByZXQgPSAwOwotCi0JaWYgKHdwYV9zLT5wbm8pIHsKLQkJd3BhX3MtPnBubyA9IDA7Ci0JCXJldCA9IHdwYV9kcnZfc3RvcF9zY2hlZF9zY2FuKHdwYV9zKTsKLQl9Ci0KLQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfU0NBTk5JTkcpCi0JCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKLQotCXJldHVybiByZXQ7Ci19Ci0KK3N0YXRpYyBpbnQgKiBmcmVxX3JhbmdlX3RvX2NoYW5uZWxfbGlzdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQljaGFyICp2YWwpOwogCiBzdGF0aWMgaW50IHNldF9ic3NpZF9maWx0ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqdmFsKQogewpAQCAtMTg0LDcgKzk1LDcgQEAKIAlzdHJ1Y3Qgd3BhX3NzaWQgKmM7CiAKIAkvKgotCSAqIGRpc2FsbG93X2xpc3QgOjo9IDxzc2lkX3NwZWM+IHwgPGJzc2lkX3NwZWM+IHwgPGRpc2FsbG93X2xpc3Q+IHwgk5QKKwkgKiBkaXNhbGxvd19saXN0IDo6PSA8c3NpZF9zcGVjPiB8IDxic3NpZF9zcGVjPiB8IDxkaXNhbGxvd19saXN0PiB8ICIiCiAJICogU1NJRF9TUEVDIDo6PSBzc2lkIDxTU0lEX0hFWD4KIAkgKiBCU1NJRF9TUEVDIDo6PSBic3NpZCA8QlNTSURfSEVYPgogCSAqLwpAQCAtMjk3LDYgKzIwOCw3MiBAQAogfQogCiAKKyNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19CTE9CUworc3RhdGljIGludCB3cGFzX2N0cmxfc2V0X2Jsb2Ioc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqcG9zKQoreworCWNoYXIgKm5hbWUgPSBwb3M7CisJc3RydWN0IHdwYV9jb25maWdfYmxvYiAqYmxvYjsKKwlzaXplX3QgbGVuOworCisJcG9zID0gb3Nfc3RyY2hyKHBvcywgJyAnKTsKKwlpZiAocG9zID09IE5VTEwpCisJCXJldHVybiAtMTsKKwkqcG9zKysgPSAnXDAnOworCWxlbiA9IG9zX3N0cmxlbihwb3MpOworCWlmIChsZW4gJiAxKQorCQlyZXR1cm4gLTE7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkw6IFNldCBibG9iICclcyciLCBuYW1lKTsKKwlibG9iID0gb3NfemFsbG9jKHNpemVvZigqYmxvYikpOworCWlmIChibG9iID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlibG9iLT5uYW1lID0gb3Nfc3RyZHVwKG5hbWUpOworCWJsb2ItPmRhdGEgPSBvc19tYWxsb2MobGVuIC8gMik7CisJaWYgKGJsb2ItPm5hbWUgPT0gTlVMTCB8fCBibG9iLT5kYXRhID09IE5VTEwpIHsKKwkJd3BhX2NvbmZpZ19mcmVlX2Jsb2IoYmxvYik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoaGV4c3RyMmJpbihwb3MsIGJsb2ItPmRhdGEsIGxlbiAvIDIpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkw6IEludmFsaWQgYmxvYiBoZXggZGF0YSIpOworCQl3cGFfY29uZmlnX2ZyZWVfYmxvYihibG9iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlibG9iLT5sZW4gPSBsZW4gLyAyOworCisJd3BhX2NvbmZpZ19zZXRfYmxvYih3cGFfcy0+Y29uZiwgYmxvYik7CisKKwlyZXR1cm4gMDsKK30KKyNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX0JMT0JTICovCisKKworc3RhdGljIGludCB3cGFzX2N0cmxfcG5vKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKK3sKKwljaGFyICpwYXJhbXM7CisJY2hhciAqcG9zOworCWludCAqZnJlcXMgPSBOVUxMOworCWludCByZXQ7CisKKwlpZiAoYXRvaShjbWQpKSB7CisJCXBhcmFtcyA9IG9zX3N0cmNocihjbWQsICcgJyk7CisJCW9zX2ZyZWUod3BhX3MtPm1hbnVhbF9zY2hlZF9zY2FuX2ZyZXFzKTsKKwkJaWYgKHBhcmFtcykgeworCQkJcGFyYW1zKys7CisJCQlwb3MgPSBvc19zdHJzdHIocGFyYW1zLCAiZnJlcT0iKTsKKwkJCWlmIChwb3MpCisJCQkJZnJlcXMgPSBmcmVxX3JhbmdlX3RvX2NoYW5uZWxfbGlzdCh3cGFfcywKKwkJCQkJCQkJICAgcG9zICsgNSk7CisJCX0KKwkJd3BhX3MtPm1hbnVhbF9zY2hlZF9zY2FuX2ZyZXFzID0gZnJlcXM7CisJCXJldCA9IHdwYXNfc3RhcnRfcG5vKHdwYV9zKTsKKwl9IGVsc2UgeworCQlyZXQgPSB3cGFzX3N0b3BfcG5vKHdwYV9zKTsKKwl9CisJcmV0dXJuIHJldDsKK30KKworCiBzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2V0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSBjaGFyICpjbWQpCiB7CkBAIC0zNTQsMTcgKzMzMSwyMSBAQAogCQl3cHNfdGVzdGluZ19kdW1teV9jcmVkID0gYXRvaSh2YWx1ZSk7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBUZXN0aW5nIC0gZHVtbXlfY3JlZD0lZCIsCiAJCQkgICB3cHNfdGVzdGluZ19kdW1teV9jcmVkKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAid3BzX2NvcnJ1cHRfcGtoYXNoIikgPT0gMCkgeworCQl3cHNfY29ycnVwdF9wa2hhc2ggPSBhdG9pKHZhbHVlKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFRlc3RpbmcgLSB3cHNfY29ycnVwdF9wa2hhc2g9JWQiLAorCQkJICAgd3BzX2NvcnJ1cHRfcGtoYXNoKTsKICNlbmRpZiAvKiBDT05GSUdfV1BTX1RFU1RJTkcgKi8KIAl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAiYW1wZHUiKSA9PSAwKSB7CiAJCWlmICh3cGFfZHJ2X2FtcGR1KHdwYV9zLCBhdG9pKHZhbHVlKSkgPCAwKQogCQkJcmV0ID0gLTE7CisjaWZkZWYgQ09ORklHX1RETFMKICNpZmRlZiBDT05GSUdfVERMU19URVNUSU5HCiAJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgInRkbHNfdGVzdGluZyIpID09IDApIHsKIAkJZXh0ZXJuIHVuc2lnbmVkIGludCB0ZGxzX3Rlc3Rpbmc7CiAJCXRkbHNfdGVzdGluZyA9IHN0cnRvbCh2YWx1ZSwgTlVMTCwgMCk7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiVERMUzogdGRsc190ZXN0aW5nPTB4JXgiLCB0ZGxzX3Rlc3RpbmcpOwogI2VuZGlmIC8qIENPTkZJR19URExTX1RFU1RJTkcgKi8KLSNpZmRlZiBDT05GSUdfVERMUwogCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJ0ZGxzX2Rpc2FibGVkIikgPT0gMCkgewogCQlpbnQgZGlzYWJsZWQgPSBhdG9pKHZhbHVlKTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJURExTOiB0ZGxzX2Rpc2FibGVkPSVkIiwgZGlzYWJsZWQpOwpAQCAtMzc2LDEwICszNTcsNyBAQAogCQl3cGFfdGRsc19lbmFibGUod3BhX3MtPndwYSwgIWRpc2FibGVkKTsKICNlbmRpZiAvKiBDT05GSUdfVERMUyAqLwogCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJwbm8iKSA9PSAwKSB7Ci0JCWlmIChhdG9pKHZhbHVlKSkKLQkJCXJldCA9IHBub19zdGFydCh3cGFfcyk7Ci0JCWVsc2UKLQkJCXJldCA9IHBub19zdG9wKHdwYV9zKTsKKwkJcmV0ID0gd3Bhc19jdHJsX3Bubyh3cGFfcywgdmFsdWUpOwogCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJyYWRpb19kaXNhYmxlZCIpID09IDApIHsKIAkJaW50IGRpc2FibGVkID0gYXRvaSh2YWx1ZSk7CiAJCWlmICh3cGFfZHJ2X3JhZGlvX2Rpc2FibGUod3BhX3MsIGRpc2FibGVkKSA8IDApCkBAIC00MjYsNyArNDA0LDExIEBACiAJCXJldCA9IHdwYV9kcnZfc2V0X3AycF9wb3dlcnNhdmUod3BhX3MsIGF0b2kodmFsdWUpLCAtMSwgLTEpOwogI2lmZGVmIENPTkZJR19XSUZJX0RJU1BMQVkKIAl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAid2lmaV9kaXNwbGF5IikgPT0gMCkgewotCQl3aWZpX2Rpc3BsYXlfZW5hYmxlKHdwYV9zLT5nbG9iYWwsICEhYXRvaSh2YWx1ZSkpOworCQlpbnQgZW5hYmxlZCA9ICEhYXRvaSh2YWx1ZSk7CisJCWlmIChlbmFibGVkICYmICF3cGFfcy0+Z2xvYmFsLT5wMnApCisJCQlyZXQgPSAtMTsKKwkJZWxzZQorCQkJd2lmaV9kaXNwbGF5X2VuYWJsZSh3cGFfcy0+Z2xvYmFsLCBlbmFibGVkKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCiAJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImJzc2lkX2ZpbHRlciIpID09IDApIHsKIAkJcmV0ID0gc2V0X2Jzc2lkX2ZpbHRlcih3cGFfcywgdmFsdWUpOwpAQCAtNDM0LDYgKzQxNiwxNCBAQAogCQlyZXQgPSBzZXRfZGlzYWxsb3dfYXBzKHdwYV9zLCB2YWx1ZSk7CiAJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgIm5vX2tlZXBfYWxpdmUiKSA9PSAwKSB7CiAJCXdwYV9zLT5ub19rZWVwX2FsaXZlID0gISFhdG9pKHZhbHVlKTsKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImV4dF9tZ210X2ZyYW1lX2hhbmRsaW5nIikgPT0gMCkgeworCQl3cGFfcy0+ZXh0X21nbXRfZnJhbWVfaGFuZGxpbmcgPSAhIWF0b2kodmFsdWUpOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKyNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19CTE9CUworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgImJsb2IiKSA9PSAwKSB7CisJCXJldCA9IHdwYXNfY3RybF9zZXRfYmxvYih3cGFfcywgdmFsdWUpOworI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfQkxPQlMgKi8KIAl9IGVsc2UgewogCQl2YWx1ZVstMV0gPSAnPSc7CiAJCXJldCA9IHdwYV9jb25maWdfcHJvY2Vzc19nbG9iYWwod3BhX3MtPmNvbmYsIGNtZCwgLTEpOwpAQCAtNDYxLDggKzQ1MSwxMyBAQAogCQkJCQkgIHdwYV9zLT5jb25mLT5jb3VudHJ5WzFdKTsKICNpZmRlZiBDT05GSUdfV0lGSV9ESVNQTEFZCiAJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgIndpZmlfZGlzcGxheSIpID09IDApIHsKLQkJcmVzID0gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICIlZCIsCi0JCQkJICB3cGFfcy0+Z2xvYmFsLT53aWZpX2Rpc3BsYXkpOworCQlpbnQgZW5hYmxlZDsKKwkJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMIHx8CisJCSAgICB3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQpCisJCQllbmFibGVkID0gMDsKKwkJZWxzZQorCQkJZW5hYmxlZCA9IHdwYV9zLT5nbG9iYWwtPndpZmlfZGlzcGxheTsKKwkJcmVzID0gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICIlZCIsIGVuYWJsZWQpOwogCQlpZiAocmVzIDwgMCB8fCAodW5zaWduZWQgaW50KSByZXMgPj0gYnVmbGVuKQogCQkJcmV0dXJuIC0xOwogCQlyZXR1cm4gcmVzOwpAQCAtNTY5LDkgKzU2NCw4IEBACiAJCSAgIE1BQzJTVFIocGVlcikpOwogCiAJaWYgKCh3cGFfcy0+Y29uZi0+dGRsc19leHRlcm5hbF9jb250cm9sKSAmJgotCSAgICAgd3BhX3RkbHNfaXNfZXh0ZXJuYWxfc2V0dXAod3BhX3MtPndwYSkpIHsKKwkgICAgd3BhX3RkbHNfaXNfZXh0ZXJuYWxfc2V0dXAod3BhX3MtPndwYSkpCiAJCXJldHVybiB3cGFfZHJ2X3RkbHNfb3Blcih3cGFfcywgVERMU19TRVRVUCwgcGVlcik7Ci0JfQogCiAJd3BhX3RkbHNfcmVtb3ZlKHdwYV9zLT53cGEsIHBlZXIpOwogCkBAIC01OTAsNiArNTg0LDEzIEBACiAJdTggcGVlcltFVEhfQUxFTl07CiAJaW50IHJldDsKIAorCWlmIChvc19zdHJjbXAoYWRkciwgIioiKSA9PSAwKSB7CisJCS8qIHJlbW92ZSBldmVyeW9uZSAqLworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgVERMU19URUFSRE9XTiAqIik7CisJCXdwYV90ZGxzX3RlYXJkb3duX3BlZXJzKHdwYV9zLT53cGEpOworCQlyZXR1cm4gMDsKKwl9CisKIAlpZiAoaHdhZGRyX2F0b24oYWRkciwgcGVlcikpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFRETFNfVEVBUkRPV046IGludmFsaWQgIgogCQkJICAgImFkZHJlc3MgJyVzJyIsIGFkZHIpOwpAQCAtNjAwLDkgKzYwMSw4IEBACiAJCSAgIE1BQzJTVFIocGVlcikpOwogCiAJaWYgKCh3cGFfcy0+Y29uZi0+dGRsc19leHRlcm5hbF9jb250cm9sKSAmJgotCSAgICAgd3BhX3RkbHNfaXNfZXh0ZXJuYWxfc2V0dXAod3BhX3MtPndwYSkpIHsKKwkgICAgd3BhX3RkbHNfaXNfZXh0ZXJuYWxfc2V0dXAod3BhX3MtPndwYSkpCiAJCXJldHVybiB3cGFfZHJ2X3RkbHNfb3Blcih3cGFfcywgVERMU19URUFSRE9XTiwgcGVlcik7Ci0JfQogCiAJaWYgKHdwYV90ZGxzX2lzX2V4dGVybmFsX3NldHVwKHdwYV9zLT53cGEpKQogCQlyZXQgPSB3cGFfdGRsc190ZWFyZG93bl9saW5rKApAQCAtNjE0LDYgKzYxNCwyMiBAQAogCXJldHVybiByZXQ7CiB9CiAKKworc3RhdGljIGludCBjdHJsX2lmYWNlX2dldF9jYXBhYmlsaXR5X3RkbHMoCisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQoreworCWludCByZXQ7CisKKwlyZXQgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzXG4iLAorCQkJICB3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19URExTX1NVUFBPUlQgPworCQkJICAod3BhX3MtPmRydl9mbGFncyAmCisJCQkgICBXUEFfRFJJVkVSX0ZMQUdTX1RETFNfRVhURVJOQUxfU0VUVVAgPworCQkJICAgIkVYVEVSTkFMIiA6ICJJTlRFUk5BTCIpIDogIlVOU1VQUE9SVEVEIik7CisJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID4gYnVmbGVuKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHJldDsKK30KKwogI2VuZGlmIC8qIENPTkZJR19URExTICovCiAKIApAQCAtNjU2LDcgKzY3Miw3IEBACiAJdTggKl9wMnBfZGV2X2FkZHIgPSBOVUxMOwogI2VuZGlmIC8qIENPTkZJR19BUCAqLwogCi0JaWYgKGNtZCA9PSBOVUxMIHx8IG9zX3N0cmNtcChjbWQsICJhbnkiKSA9PSAwIHx8IGNtZFswXSA9PSAnXDAnKSB7CisJaWYgKGNtZCA9PSBOVUxMIHx8IG9zX3N0cmNtcChjbWQsICJhbnkiKSA9PSAwKSB7CiAJCV9ic3NpZCA9IE5VTEw7CiAjaWZkZWYgQ09ORklHX1AyUAogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChjbWQsICJwMnBfZGV2X2FkZHI9IiwgMTMpID09IDApIHsKQEAgLTgwNSw3ICs4MjEsOCBAQAogCWVsc2UgaWYgKGh3YWRkcl9hdG9uKGNtZCwgYnNzaWQpKQogCQlyZXR1cm4gLTE7CiAKLQlyZXR1cm4gd3Bhc193cHNfc3RhcnRfbmZjKHdwYV9zLCBfYnNzaWQpOworCXJldHVybiB3cGFzX3dwc19zdGFydF9uZmMod3BhX3MsIE5VTEwsIF9ic3NpZCwgTlVMTCwgMCwgMCwgTlVMTCwgTlVMTCwKKwkJCQkgIDAsIDApOwogfQogCiAKQEAgLTg3Nyw2ICs4OTQsMTUgQEAKIAlzaXplX3QgbGVuOwogCXN0cnVjdCB3cGFidWYgKmJ1ZjsKIAlpbnQgcmV0OworCWNoYXIgKmZyZXE7CisJaW50IGZvcmNlZF9mcmVxID0gMDsKKworCWZyZXEgPSBzdHJzdHIocG9zLCAiIGZyZXE9Iik7CisJaWYgKGZyZXEpIHsKKwkJKmZyZXEgPSAnXDAnOworCQlmcmVxICs9IDY7CisJCWZvcmNlZF9mcmVxID0gYXRvaShmcmVxKTsKKwl9CiAKIAlsZW4gPSBvc19zdHJsZW4ocG9zKTsKIAlpZiAobGVuICYgMHgwMSkKQEAgLTg5MSw3ICs5MTcsNyBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JcmV0ID0gd3Bhc193cHNfbmZjX3RhZ19yZWFkKHdwYV9zLCBidWYpOworCXJldCA9IHdwYXNfd3BzX25mY190YWdfcmVhZCh3cGFfcywgYnVmLCBmb3JjZWRfZnJlcSk7CiAJd3BhYnVmX2ZyZWUoYnVmKTsKIAogCXJldHVybiByZXQ7CkBAIC05MDAsMTIgKzkyNiwxMiBAQAogCiBzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3JlcV93cHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICAgICAgY2hhciAqcmVwbHksIHNpemVfdCBtYXhfbGVuLAotCQkJCQkgICAgICBpbnQgY3IpCisJCQkJCSAgICAgIGludCBuZGVmKQogewogCXN0cnVjdCB3cGFidWYgKmJ1ZjsKIAlpbnQgcmVzOwogCi0JYnVmID0gd3Bhc193cHNfbmZjX2hhbmRvdmVyX3JlcSh3cGFfcywgY3IpOworCWJ1ZiA9IHdwYXNfd3BzX25mY19oYW5kb3Zlcl9yZXEod3BhX3MsIG5kZWYpOwogCWlmIChidWYgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCkBAIC05MjAsMjUgKzk0Niw2NSBAQAogfQogCiAKKyNpZmRlZiBDT05GSUdfUDJQCitzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3JlcV9wMnAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICAgY2hhciAqcmVwbHksIHNpemVfdCBtYXhfbGVuLAorCQkJCQkgICAgICBpbnQgbmRlZikKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJaW50IHJlczsKKworCWJ1ZiA9IHdwYXNfcDJwX25mY19oYW5kb3Zlcl9yZXEod3BhX3MsIG5kZWYpOworCWlmIChidWYgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ291bGQgbm90IGdlbmVyYXRlIE5GQyBoYW5kb3ZlciByZXF1ZXN0Iik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXMgPSB3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShyZXBseSwgbWF4X2xlbiwgd3BhYnVmX2hlYWQoYnVmKSwKKwkJCQkJIHdwYWJ1Zl9sZW4oYnVmKSk7CisJcmVwbHlbcmVzKytdID0gJ1xuJzsKKwlyZXBseVtyZXNdID0gJ1wwJzsKKworCXdwYWJ1Zl9mcmVlKGJ1Zik7CisKKwlyZXR1cm4gcmVzOworfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCiBzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgIGNoYXIgKmNtZCwgY2hhciAqcmVwbHksCiAJCQkJCSAgc2l6ZV90IG1heF9sZW4pCiB7CiAJY2hhciAqcG9zOworCWludCBuZGVmOwogCiAJcG9zID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKIAlpZiAocG9zID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAkqcG9zKysgPSAnXDAnOwogCi0JaWYgKG9zX3N0cmNtcChjbWQsICJOREVGIikgIT0gMCkKKwlpZiAob3Nfc3RyY21wKGNtZCwgIldQUyIpID09IDApCisJCW5kZWYgPSAwOworCWVsc2UgaWYgKG9zX3N0cmNtcChjbWQsICJOREVGIikgPT0gMCkKKwkJbmRlZiA9IDE7CisJZWxzZQogCQlyZXR1cm4gLTE7CiAKIAlpZiAob3Nfc3RyY21wKHBvcywgIldQUyIpID09IDAgfHwgb3Nfc3RyY21wKHBvcywgIldQUy1DUiIpID09IDApIHsKKwkJaWYgKCFuZGVmKQorCQkJcmV0dXJuIC0xOwogCQlyZXR1cm4gd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfcmVxX3dwcygKLQkJCXdwYV9zLCByZXBseSwgbWF4X2xlbiwgb3Nfc3RyY21wKHBvcywgIldQUy1DUiIpID09IDApOworCQkJd3BhX3MsIHJlcGx5LCBtYXhfbGVuLCBuZGVmKTsKIAl9CiAKKyNpZmRlZiBDT05GSUdfUDJQCisJaWYgKG9zX3N0cmNtcChwb3MsICJQMlAtQ1IiKSA9PSAwKSB7CisJCXJldHVybiB3cGFzX2N0cmxfbmZjX2dldF9oYW5kb3Zlcl9yZXFfcDJwKAorCQkJd3BhX3MsIHJlcGx5LCBtYXhfbGVuLCBuZGVmKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCiAJcmV0dXJuIC0xOwogfQogCkBAIC05NjUsNiArMTAzMSwzMCBAQAogfQogCiAKKyNpZmRlZiBDT05GSUdfUDJQCitzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3NlbF9wMnAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICAgY2hhciAqcmVwbHksIHNpemVfdCBtYXhfbGVuLAorCQkJCQkgICAgICBpbnQgbmRlZiwgaW50IHRhZykKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJaW50IHJlczsKKworCWJ1ZiA9IHdwYXNfcDJwX25mY19oYW5kb3Zlcl9zZWwod3BhX3MsIG5kZWYsIHRhZyk7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlyZXMgPSB3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShyZXBseSwgbWF4X2xlbiwgd3BhYnVmX2hlYWQoYnVmKSwKKwkJCQkJIHdwYWJ1Zl9sZW4oYnVmKSk7CisJcmVwbHlbcmVzKytdID0gJ1xuJzsKKwlyZXBseVtyZXNdID0gJ1wwJzsKKworCXdwYWJ1Zl9mcmVlKGJ1Zik7CisKKwlyZXR1cm4gcmVzOworfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCiBzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3NlbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgIGNoYXIgKmNtZCwgY2hhciAqcmVwbHksCiAJCQkJCSAgc2l6ZV90IG1heF9sZW4pCkBAIC05ODgsNzAgKzEwNzgsMjkgQEAKIAlpZiAocG9zMikKIAkJKnBvczIrKyA9ICdcMCc7CiAJaWYgKG9zX3N0cmNtcChwb3MsICJXUFMiKSA9PSAwIHx8IG9zX3N0cmNtcChwb3MsICJXUFMtQ1IiKSA9PSAwKSB7CisJCWlmICghbmRlZikKKwkJCXJldHVybiAtMTsKIAkJcmV0dXJuIHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3NlbF93cHMoCiAJCQl3cGFfcywgcmVwbHksIG1heF9sZW4sIG5kZWYsCiAJCQlvc19zdHJjbXAocG9zLCAiV1BTLUNSIikgPT0gMCwgcG9zMik7CiAJfQogCisjaWZkZWYgQ09ORklHX1AyUAorCWlmIChvc19zdHJjbXAocG9zLCAiUDJQLUNSIikgPT0gMCkgeworCQlyZXR1cm4gd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfc2VsX3AycCgKKwkJCXdwYV9zLCByZXBseSwgbWF4X2xlbiwgbmRlZiwgMCk7CisJfQorCisJaWYgKG9zX3N0cmNtcChwb3MsICJQMlAtQ1ItVEFHIikgPT0gMCkgeworCQlyZXR1cm4gd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfc2VsX3AycCgKKwkJCXdwYV9zLCByZXBseSwgbWF4X2xlbiwgbmRlZiwgMSk7CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKwogCXJldHVybiAtMTsKIH0KIAogCi1zdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfcnhfaGFuZG92ZXJfcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSBjaGFyICpjbWQsIGNoYXIgKnJlcGx5LAotCQkJCQkgc2l6ZV90IG1heF9sZW4pCi17Ci0Jc2l6ZV90IGxlbjsKLQlzdHJ1Y3Qgd3BhYnVmICpidWY7Ci0JaW50IHJldDsKLQotCWxlbiA9IG9zX3N0cmxlbihjbWQpOwotCWlmIChsZW4gJiAweDAxKQotCQlyZXR1cm4gLTE7Ci0JbGVuIC89IDI7Ci0KLQlidWYgPSB3cGFidWZfYWxsb2MobGVuKTsKLQlpZiAoYnVmID09IE5VTEwpCi0JCXJldHVybiAtMTsKLQlpZiAoaGV4c3RyMmJpbihjbWQsIHdwYWJ1Zl9wdXQoYnVmLCBsZW4pLCBsZW4pIDwgMCkgewotCQl3cGFidWZfZnJlZShidWYpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcmV0ID0gd3Bhc193cHNfbmZjX3J4X2hhbmRvdmVyX3JlcSh3cGFfcywgYnVmKTsKLQl3cGFidWZfZnJlZShidWYpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotCi1zdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfcnhfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSBjaGFyICpjbWQpCi17Ci0Jc2l6ZV90IGxlbjsKLQlzdHJ1Y3Qgd3BhYnVmICpidWY7Ci0JaW50IHJldDsKLQotCWxlbiA9IG9zX3N0cmxlbihjbWQpOwotCWlmIChsZW4gJiAweDAxKQotCQlyZXR1cm4gLTE7Ci0JbGVuIC89IDI7Ci0KLQlidWYgPSB3cGFidWZfYWxsb2MobGVuKTsKLQlpZiAoYnVmID09IE5VTEwpCi0JCXJldHVybiAtMTsKLQlpZiAoaGV4c3RyMmJpbihjbWQsIHdwYWJ1Zl9wdXQoYnVmLCBsZW4pLCBsZW4pIDwgMCkgewotCQl3cGFidWZfZnJlZShidWYpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JcmV0ID0gd3Bhc193cHNfbmZjX3J4X2hhbmRvdmVyX3NlbCh3cGFfcywgYnVmKTsKLQl3cGFidWZfZnJlZShidWYpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotCiBzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfcmVwb3J0X2hhbmRvdmVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSBjaGFyICpjbWQpCiB7CkBAIC0xMDU5LDM5ICsxMTA4LDYyIEBACiAJc3RydWN0IHdwYWJ1ZiAqcmVxLCAqc2VsOwogCWludCByZXQ7CiAJY2hhciAqcG9zLCAqcm9sZSwgKnR5cGUsICpwb3MyOworI2lmZGVmIENPTkZJR19QMlAKKwljaGFyICpmcmVxOworCWludCBmb3JjZWRfZnJlcSA9IDA7CisKKwlmcmVxID0gc3Ryc3RyKGNtZCwgIiBmcmVxPSIpOworCWlmIChmcmVxKSB7CisJCSpmcmVxID0gJ1wwJzsKKwkJZnJlcSArPSA2OworCQlmb3JjZWRfZnJlcSA9IGF0b2koZnJlcSk7CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCXJvbGUgPSBjbWQ7CiAJcG9zID0gb3Nfc3RyY2hyKHJvbGUsICcgJyk7Ci0JaWYgKHBvcyA9PSBOVUxMKQorCWlmIChwb3MgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogTWlzc2luZyB0eXBlIGluIGhhbmRvdmVyIHJlcG9ydCIpOwogCQlyZXR1cm4gLTE7CisJfQogCSpwb3MrKyA9ICdcMCc7CiAKIAl0eXBlID0gcG9zOwogCXBvcyA9IG9zX3N0cmNocih0eXBlLCAnICcpOwotCWlmIChwb3MgPT0gTlVMTCkKKwlpZiAocG9zID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJORkM6IE1pc3NpbmcgcmVxdWVzdCBtZXNzYWdlIGluIGhhbmRvdmVyIHJlcG9ydCIpOwogCQlyZXR1cm4gLTE7CisJfQogCSpwb3MrKyA9ICdcMCc7CiAKIAlwb3MyID0gb3Nfc3RyY2hyKHBvcywgJyAnKTsKLQlpZiAocG9zMiA9PSBOVUxMKQorCWlmIChwb3MyID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJORkM6IE1pc3Npbmcgc2VsZWN0IG1lc3NhZ2UgaW4gaGFuZG92ZXIgcmVwb3J0Iik7CiAJCXJldHVybiAtMTsKKwl9CiAJKnBvczIrKyA9ICdcMCc7CiAKIAlsZW4gPSBvc19zdHJsZW4ocG9zKTsKLQlpZiAobGVuICYgMHgwMSkKKwlpZiAobGVuICYgMHgwMSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogSW52YWxpZCByZXF1ZXN0IG1lc3NhZ2UgbGVuZ3RoIGluIGhhbmRvdmVyIHJlcG9ydCIpOwogCQlyZXR1cm4gLTE7CisJfQogCWxlbiAvPSAyOwogCiAJcmVxID0gd3BhYnVmX2FsbG9jKGxlbik7Ci0JaWYgKHJlcSA9PSBOVUxMKQorCWlmIChyZXEgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogRmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IgcmVxdWVzdCBtZXNzYWdlIik7CiAJCXJldHVybiAtMTsKKwl9CiAJaWYgKGhleHN0cjJiaW4ocG9zLCB3cGFidWZfcHV0KHJlcSwgbGVuKSwgbGVuKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJORkM6IEludmFsaWQgcmVxdWVzdCBtZXNzYWdlIGhleGR1bXAgaW4gaGFuZG92ZXIgcmVwb3J0Iik7CiAJCXdwYWJ1Zl9mcmVlKHJlcSk7CiAJCXJldHVybiAtMTsKIAl9CiAKIAlsZW4gPSBvc19zdHJsZW4ocG9zMik7CiAJaWYgKGxlbiAmIDB4MDEpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJORkM6IEludmFsaWQgc2VsZWN0IG1lc3NhZ2UgbGVuZ3RoIGluIGhhbmRvdmVyIHJlcG9ydCIpOwogCQl3cGFidWZfZnJlZShyZXEpOwogCQlyZXR1cm4gLTE7CiAJfQpAQCAtMTA5OSwxNyArMTE3MSwzOCBAQAogCiAJc2VsID0gd3BhYnVmX2FsbG9jKGxlbik7CiAJaWYgKHNlbCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTkZDOiBGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBzZWxlY3QgbWVzc2FnZSIpOwogCQl3cGFidWZfZnJlZShyZXEpOwogCQlyZXR1cm4gLTE7CiAJfQogCWlmIChoZXhzdHIyYmluKHBvczIsIHdwYWJ1Zl9wdXQoc2VsLCBsZW4pLCBsZW4pIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogSW52YWxpZCBzZWxlY3QgbWVzc2FnZSBoZXhkdW1wIGluIGhhbmRvdmVyIHJlcG9ydCIpOwogCQl3cGFidWZfZnJlZShyZXEpOwogCQl3cGFidWZfZnJlZShzZWwpOwogCQlyZXR1cm4gLTE7CiAJfQogCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJORkM6IENvbm5lY3Rpb24gaGFuZG92ZXIgcmVwb3J0ZWQgLSByb2xlPSVzIHR5cGU9JXMgcmVxX2xlbj0lZCBzZWxfbGVuPSVkIiwKKwkJICAgcm9sZSwgdHlwZSwgKGludCkgd3BhYnVmX2xlbihyZXEpLCAoaW50KSB3cGFidWZfbGVuKHNlbCkpOworCiAJaWYgKG9zX3N0cmNtcChyb2xlLCAiSU5JVCIpID09IDAgJiYgb3Nfc3RyY21wKHR5cGUsICJXUFMiKSA9PSAwKSB7CiAJCXJldCA9IHdwYXNfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIod3BhX3MsIHJlcSwgc2VsKTsKKyNpZmRlZiBDT05GSUdfQVAKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChyb2xlLCAiUkVTUCIpID09IDAgJiYgb3Nfc3RyY21wKHR5cGUsICJXUFMiKSA9PSAwKQorCXsKKwkJcmV0ID0gd3Bhc19hcF93cHNfbmZjX3JlcG9ydF9oYW5kb3Zlcih3cGFfcywgcmVxLCBzZWwpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldCA9IHdwYXNfZXJfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIod3BhX3MsIHJlcSwgc2VsKTsKKyNlbmRpZiAvKiBDT05GSUdfQVAgKi8KKyNpZmRlZiBDT05GSUdfUDJQCisJfSBlbHNlIGlmIChvc19zdHJjbXAocm9sZSwgIklOSVQiKSA9PSAwICYmIG9zX3N0cmNtcCh0eXBlLCAiUDJQIikgPT0gMCkKKwl7CisJCXJldCA9IHdwYXNfcDJwX25mY19yZXBvcnRfaGFuZG92ZXIod3BhX3MsIDEsIHJlcSwgc2VsLCAwKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChyb2xlLCAiUkVTUCIpID09IDAgJiYgb3Nfc3RyY21wKHR5cGUsICJQMlAiKSA9PSAwKQorCXsKKwkJcmV0ID0gd3Bhc19wMnBfbmZjX3JlcG9ydF9oYW5kb3Zlcih3cGFfcywgMCwgcmVxLCBzZWwsCisJCQkJCQkgICBmb3JjZWRfZnJlcSk7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCX0gZWxzZSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTkZDOiBVbnN1cHBvcnRlZCBjb25uZWN0aW9uIGhhbmRvdmVyICIKIAkJCSAgICJyZXBvcnRlZDogcm9sZT0lcyB0eXBlPSVzIiwgcm9sZSwgdHlwZSk7CkBAIC0xMTE4LDYgKzEyMTEsOSBAQAogCXdwYWJ1Zl9mcmVlKHJlcSk7CiAJd3BhYnVmX2ZyZWUoc2VsKTsKIAorCWlmIChyZXQpCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTkZDOiBGYWlsZWQgdG8gcHJvY2VzcyByZXBvcnRlZCBoYW5kb3ZlciBtZXNzYWdlcyIpOworCiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMTQyNiw3ICsxNTIyLDEyIEBACiB7CiAJY2hhciAqcG9zLCAqZW5kLCB0bXBbMzBdOwogCWludCByZXMsIHZlcmJvc2UsIHdwcywgcmV0OworI2lmZGVmIENPTkZJR19IUzIwCisJY29uc3QgdTggKmhzMjA7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAorCWlmIChvc19zdHJjbXAocGFyYW1zLCAiLURSSVZFUiIpID09IDApCisJCXJldHVybiB3cGFfZHJ2X3N0YXR1cyh3cGFfcywgYnVmLCBidWZsZW4pOwogCXZlcmJvc2UgPSBvc19zdHJjbXAocGFyYW1zLCAiLVZFUkJPU0UiKSA9PSAwOwogCXdwcyA9IG9zX3N0cmNtcChwYXJhbXMsICItV1BTIikgPT0gMDsKIAlwb3MgPSBidWY7CkBAIC0xNTYyLDEwICsxNjYzLDE2IEBACiAKICNpZmRlZiBDT05GSUdfSFMyMAogCWlmICh3cGFfcy0+Y3VycmVudF9ic3MgJiYKLQkgICAgd3BhX2Jzc19nZXRfdmVuZG9yX2llKHdwYV9zLT5jdXJyZW50X2JzcywgSFMyMF9JRV9WRU5ET1JfVFlQRSkgJiYKKwkgICAgKGhzMjAgPSB3cGFfYnNzX2dldF92ZW5kb3JfaWUod3BhX3MtPmN1cnJlbnRfYnNzLAorCQkJCQkgIEhTMjBfSUVfVkVORE9SX1RZUEUpKSAmJgogCSAgICB3cGFfcy0+d3BhX3Byb3RvID09IFdQQV9QUk9UT19SU04gJiYKIAkgICAgd3BhX2tleV9tZ210X3dwYV9pZWVlODAyMXgod3BhX3MtPmtleV9tZ210KSkgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgImhzMjA9MVxuIik7CisJCWludCByZWxlYXNlID0gMTsKKwkJaWYgKGhzMjBbMV0gPj0gNSkgeworCQkJdTggcmVsX251bSA9IChoczIwWzZdICYgMHhmMCkgPj4gNDsKKwkJCXJlbGVhc2UgPSByZWxfbnVtICsgMTsKKwkJfQorCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgImhzMjA9JWRcbiIsIHJlbGVhc2UpOwogCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQogCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKIAkJcG9zICs9IHJldDsKQEAgLTE1NzYsMTcgKzE2ODMsNDMgQEAKIAkJY2hhciAqdHlwZTsKIAogCQlmb3IgKGNyZWQgPSB3cGFfcy0+Y29uZi0+Y3JlZDsgY3JlZDsgY3JlZCA9IGNyZWQtPm5leHQpIHsKKwkJCXNpemVfdCBpOworCiAJCQlpZiAod3BhX3MtPmN1cnJlbnRfc3NpZC0+cGFyZW50X2NyZWQgIT0gY3JlZCkKIAkJCQljb250aW51ZTsKLQkJCWlmICghY3JlZC0+ZG9tYWluKQotCQkJCWNvbnRpbnVlOwogCisJCQlpZiAoY3JlZC0+cHJvdmlzaW9uaW5nX3NwKSB7CisJCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsCisJCQkJCQkgICJwcm92aXNpb25pbmdfc3A9JXNcbiIsCisJCQkJCQkgIGNyZWQtPnByb3Zpc2lvbmluZ19zcCk7CisJCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwkJCQlwb3MgKz0gcmV0OworCQkJfQorCisJCQlpZiAoIWNyZWQtPmRvbWFpbikKKwkJCQlnb3RvIG5vX2RvbWFpbjsKKworCQkJaSA9IDA7CisJCQlpZiAod3BhX3MtPmN1cnJlbnRfYnNzICYmIHdwYV9zLT5jdXJyZW50X2Jzcy0+YW5xcCkgeworCQkJCXN0cnVjdCB3cGFidWYgKm5hbWVzID0KKwkJCQkJd3BhX3MtPmN1cnJlbnRfYnNzLT5hbnFwLT5kb21haW5fbmFtZTsKKwkJCQlmb3IgKGkgPSAwOyBuYW1lcyAmJiBpIDwgY3JlZC0+bnVtX2RvbWFpbjsgaSsrKQorCQkJCXsKKwkJCQkJaWYgKGRvbWFpbl9uYW1lX2xpc3RfY29udGFpbnMoCisJCQkJCQkgICAgbmFtZXMsIGNyZWQtPmRvbWFpbltpXSwgMSkpCisJCQkJCQlicmVhazsKKwkJCQl9CisJCQkJaWYgKGkgPT0gY3JlZC0+bnVtX2RvbWFpbikKKwkJCQkJaSA9IDA7IC8qIHNob3cgZmlyc3QgZW50cnkgYnkgZGVmYXVsdCAqLworCQkJfQogCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJob21lX3NwPSVzXG4iLAotCQkJCQkgIGNyZWQtPmRvbWFpbik7CisJCQkJCSAgY3JlZC0+ZG9tYWluW2ldKTsKIAkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKIAkJCXBvcyArPSByZXQ7CiAKKwkJbm9fZG9tYWluOgogCQkJaWYgKHdwYV9zLT5jdXJyZW50X2JzcyA9PSBOVUxMIHx8CiAJCQkgICAgd3BhX3MtPmN1cnJlbnRfYnNzLT5hbnFwID09IE5VTEwpCiAJCQkJcmVzID0gLTE7CkBAIC0xNjIzLDIyICsxNzU2LDQxIEBACiAJaWYgKHJlcyA+PSAwKQogCQlwb3MgKz0gcmVzOwogCisjaWZkZWYgQ09ORklHX1dQUworCXsKKwkJY2hhciB1dWlkX3N0clsxMDBdOworCQl1dWlkX2JpbjJzdHIod3BhX3MtPndwcy0+dXVpZCwgdXVpZF9zdHIsIHNpemVvZih1dWlkX3N0cikpOworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgInV1aWQ9JXNcbiIsIHV1aWRfc3RyKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCXJldHVybiBwb3MgLSBidWY7CisJCXBvcyArPSByZXQ7CisJfQorI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KKwogI2lmZGVmIEFORFJPSUQKLQl3cGFfbXNnX2N0cmwod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfU1RBVEVfQ0hBTkdFCi0JCSAgICAgImlkPSVkIHN0YXRlPSVkIEJTU0lEPSIgTUFDU1RSICIgU1NJRD0lcyIsCi0JCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZCA/IHdwYV9zLT5jdXJyZW50X3NzaWQtPmlkIDogLTEsCi0JCSAgICAgd3BhX3MtPndwYV9zdGF0ZSwKLQkJICAgICBNQUMyU1RSKHdwYV9zLT5ic3NpZCksCi0JCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkID8KLQkJICAgICB3cGFfc3NpZF90eHQod3BhX3MtPmN1cnJlbnRfc3NpZC0+c3NpZCwKLQkJICAgICB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkX2xlbikgOiAiIik7Ci0JaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0NPTVBMRVRFRCkgewotCQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOwotCQl3cGFfbXNnX2N0cmwod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfQ09OTkVDVEVEICItIGNvbm5lY3Rpb24gdG8gIgotCQkJTUFDU1RSICIgY29tcGxldGVkICVzIFtpZD0lZCBpZF9zdHI9JXNdIiwKLQkJCU1BQzJTVFIod3BhX3MtPmJzc2lkKSwgIihhdXRoKSIsCi0JCQlzc2lkID8gc3NpZC0+aWQgOiAtMSwKLQkJCXNzaWQgJiYgc3NpZC0+aWRfc3RyID8gc3NpZC0+aWRfc3RyIDogIiIpOworCS8qCisJICogQWxsb3cgdXNpbmcgdGhlIFNUQVRVUyBjb21tYW5kIHdpdGggZGVmYXVsdCBiZWhhdmlvciwgc2F5IGZvciBkZWJ1ZywKKwkgKiBpLmUuLCBkb24ndCBnZW5lcmF0ZSBhICJmYWtlIiBDT05ORUNUSU9OIGFuZCBTVVBQTElDQU5UX1NUQVRFX0NIQU5HRQorCSAqIGV2ZW50cyB3aXRoIFNUQVRVUy1OT19FVkVOVFMuCisJICovCisJaWYgKG9zX3N0cmNtcChwYXJhbXMsICItTk9fRVZFTlRTIikpIHsKKwkJd3BhX21zZ19jdHJsKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX1NUQVRFX0NIQU5HRQorCQkJICAgICAiaWQ9JWQgc3RhdGU9JWQgQlNTSUQ9IiBNQUNTVFIgIiBTU0lEPSVzIiwKKwkJCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZCA/IHdwYV9zLT5jdXJyZW50X3NzaWQtPmlkIDogLTEsCisJCQkgICAgIHdwYV9zLT53cGFfc3RhdGUsCisJCQkgICAgIE1BQzJTVFIod3BhX3MtPmJzc2lkKSwKKwkJCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkID8KKwkJCSAgICAgd3BhX3NzaWRfdHh0KHdwYV9zLT5jdXJyZW50X3NzaWQtPnNzaWQsCisJCQkJCSAgd3BhX3MtPmN1cnJlbnRfc3NpZC0+c3NpZF9sZW4pIDogIiIpOworCQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfQ09NUExFVEVEKSB7CisJCQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOworCQkJd3BhX21zZ19jdHJsKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX0NPTk5FQ1RFRAorCQkJCSAgICAgIi0gY29ubmVjdGlvbiB0byAiIE1BQ1NUUgorCQkJCSAgICAgIiBjb21wbGV0ZWQgJXMgW2lkPSVkIGlkX3N0cj0lc10iLAorCQkJCSAgICAgTUFDMlNUUih3cGFfcy0+YnNzaWQpLCAiKGF1dGgpIiwKKwkJCQkgICAgIHNzaWQgPyBzc2lkLT5pZCA6IC0xLAorCQkJCSAgICAgc3NpZCAmJiBzc2lkLT5pZF9zdHIgPyBzc2lkLT5pZF9zdHIgOiAiIik7CisJCX0KIAl9CiAjZW5kaWYgLyogQU5EUk9JRCAqLwogCkBAIC0xNzIzLDE5ICsxODc1LDE2IEBACiAJICogc2tpcHBlZCB3aGVuIHByb2Nlc3Npbmcgc2NhbiByZXN1bHRzLgogCSAqLwogCXJldCA9IHdwYV9ibGFja2xpc3RfYWRkKHdwYV9zLCBic3NpZCk7Ci0JaWYgKHJldCAhPSAwKQorCWlmIChyZXQgPCAwKQogCQlyZXR1cm4gLTE7CiAJcmV0ID0gd3BhX2JsYWNrbGlzdF9hZGQod3BhX3MsIGJzc2lkKTsKLQlpZiAocmV0ICE9IDApCisJaWYgKHJldCA8IDApCiAJCXJldHVybiAtMTsKIAlvc19tZW1jcHkoYnVmLCAiT0tcbiIsIDMpOwogCXJldHVybiAzOwogfQogCiAKLWV4dGVybiBpbnQgd3BhX2RlYnVnX2xldmVsOwotZXh0ZXJuIGludCB3cGFfZGVidWdfdGltZXN0YW1wOwotCiBzdGF0aWMgY29uc3QgY2hhciAqIGRlYnVnX2xldmVsX3N0cihpbnQgbGV2ZWwpCiB7CiAJc3dpdGNoIChsZXZlbCkgewpAQCAtMTkwMCw3ICsyMDQ5LDggQEAKIAkJCQkgICAgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuKQogewogCXN0cnVjdCB3cGFfaWVfZGF0YSBkYXRhOwotCWludCBmaXJzdCwgcmV0OworCWNoYXIgKnN0YXJ0OworCWludCByZXQ7CiAKIAlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlslcy0iLCBwcm90byk7CiAJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKQEAgLTE5MTUsNjIgKzIwNjUsNTggQEAKIAkJcmV0dXJuIHBvczsKIAl9CiAKLQlmaXJzdCA9IDE7CisJc3RhcnQgPSBwb3M7CiAJaWYgKGRhdGEua2V5X21nbXQgJiBXUEFfS0VZX01HTVRfSUVFRTgwMjFYKSB7Ci0JCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNFQVAiLCBmaXJzdCA/ICIiIDogIisiKTsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0VBUCIsCisJCQkJICBwb3MgPT0gc3RhcnQgPyAiIiA6ICIrIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gcG9zOwogCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7CiAJfQogCWlmIChkYXRhLmtleV9tZ210ICYgV1BBX0tFWV9NR01UX1BTSykgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzUFNLIiwgZmlyc3QgPyAiIiA6ICIrIik7CisJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNQU0siLAorCQkJCSAgcG9zID09IHN0YXJ0ID8gIiIgOiAiKyIpOwogCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQogCQkJcmV0dXJuIHBvczsKIAkJcG9zICs9IHJldDsKLQkJZmlyc3QgPSAwOwogCX0KIAlpZiAoZGF0YS5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9XUEFfTk9ORSkgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzTm9uZSIsIGZpcnN0ID8gIiIgOiAiKyIpOworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzTm9uZSIsCisJCQkJICBwb3MgPT0gc3RhcnQgPyAiIiA6ICIrIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gcG9zOwogCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7CiAJfQogI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCiAJaWYgKGRhdGEua2V5X21nbXQgJiBXUEFfS0VZX01HTVRfRlRfSUVFRTgwMjFYKSB7CiAJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNGVC9FQVAiLAotCQkJCSAgZmlyc3QgPyAiIiA6ICIrIik7CisJCQkJICBwb3MgPT0gc3RhcnQgPyAiIiA6ICIrIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gcG9zOwogCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7CiAJfQogCWlmIChkYXRhLmtleV9tZ210ICYgV1BBX0tFWV9NR01UX0ZUX1BTSykgewogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzRlQvUFNLIiwKLQkJCQkgIGZpcnN0ID8gIiIgOiAiKyIpOworCQkJCSAgcG9zID09IHN0YXJ0ID8gIiIgOiAiKyIpOwogCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQogCQkJcmV0dXJuIHBvczsKIAkJcG9zICs9IHJldDsKLQkJZmlyc3QgPSAwOwogCX0KICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiAqLwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiAJaWYgKGRhdGEua2V5X21nbXQgJiBXUEFfS0VZX01HTVRfSUVFRTgwMjFYX1NIQTI1NikgewogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzRUFQLVNIQTI1NiIsCi0JCQkJICBmaXJzdCA/ICIiIDogIisiKTsKKwkJCQkgIHBvcyA9PSBzdGFydCA/ICIiIDogIisiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCXJldHVybiBwb3M7CiAJCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKIAl9CiAJaWYgKGRhdGEua2V5X21nbXQgJiBXUEFfS0VZX01HTVRfUFNLX1NIQTI1NikgewogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzUFNLLVNIQTI1NiIsCi0JCQkJICBmaXJzdCA/ICIiIDogIisiKTsKKwkJCQkgIHBvcyA9PSBzdGFydCA/ICIiIDogIisiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCXJldHVybiBwb3M7CiAJCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIApAQCAtMjAwNCwxMCArMjE1MCw4IEBACiAJCXJldHVybiBwb3M7CiAJaWYgKHdwc19pc19zZWxlY3RlZF9wYmNfcmVnaXN0cmFyKHdwc19pZSkpCiAJCXR4dCA9ICJbV1BTLVBCQ10iOwotI2lmZGVmIENPTkZJR19XUFMyCiAJZWxzZSBpZiAod3BzX2lzX2FkZHJfYXV0aG9yaXplZCh3cHNfaWUsIHdwYV9zLT5vd25fYWRkciwgMCkpCiAJCXR4dCA9ICJbV1BTLUFVVEhdIjsKLSNlbmRpZiAvKiBDT05GSUdfV1BTMiAqLwogCWVsc2UgaWYgKHdwc19pc19zZWxlY3RlZF9waW5fcmVnaXN0cmFyKHdwc19pZSkpCiAJCXR4dCA9ICJbV1BTLVBJTl0iOwogCWVsc2UKQEAgLTIwNDYsNiArMjE5MCw4IEBACiAJY29uc3QgdTggKmllLCAqaWUyLCAqcDJwOwogCiAJcDJwID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKKwlpZiAoIXAycCkKKwkJcDJwID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llX2JlYWNvbihic3MsIFAyUF9JRV9WRU5ET1JfVFlQRSk7CiAJaWYgKHAycCAmJiBic3MtPnNzaWRfbGVuID09IFAyUF9XSUxEQ0FSRF9TU0lEX0xFTiAmJgogCSAgICBvc19tZW1jbXAoYnNzLT5zc2lkLCBQMlBfV0lMRENBUkRfU1NJRCwgUDJQX1dJTERDQVJEX1NTSURfTEVOKSA9PQogCSAgICAwKQpAQCAtMjA3MiwxNyArMjIxOCw0MyBAQAogCQkJcmV0dXJuIC0xOwogCQlwb3MgKz0gcmV0OwogCX0KLQlpZiAoYnNzLT5jYXBzICYgSUVFRTgwMjExX0NBUF9JQlNTKSB7Ci0JCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiW0lCU1NdIik7CisJaWYgKGJzc19pc19kbWcoYnNzKSkgeworCQljb25zdCBjaGFyICpzOworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltETUddIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gLTE7CiAJCXBvcyArPSByZXQ7Ci0JfQotCWlmIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX0VTUykgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltFU1NdIik7CisJCXN3aXRjaCAoYnNzLT5jYXBzICYgSUVFRTgwMjExX0NBUF9ETUdfTUFTSykgeworCQljYXNlIElFRUU4MDIxMV9DQVBfRE1HX0lCU1M6CisJCQlzID0gIltJQlNTXSI7CisJCQlicmVhazsKKwkJY2FzZSBJRUVFODAyMTFfQ0FQX0RNR19BUDoKKwkJCXMgPSAiW0VTU10iOworCQkJYnJlYWs7CisJCWNhc2UgSUVFRTgwMjExX0NBUF9ETUdfUEJTUzoKKwkJCXMgPSAiW1BCU1NdIjsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJcyA9ICIiOworCQkJYnJlYWs7CisJCX0KKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlcyIsIHMpOwogCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQogCQkJcmV0dXJuIC0xOwogCQlwb3MgKz0gcmV0OworCX0gZWxzZSB7CisJCWlmIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX0lCU1MpIHsKKwkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiW0lCU1NdIik7CisJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJCXJldHVybiAtMTsKKwkJCXBvcyArPSByZXQ7CisJCX0KKwkJaWYgKGJzcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfRVNTKSB7CisJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltFU1NdIik7CisJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJCXJldHVybiAtMTsKKwkJCXBvcyArPSByZXQ7CisJCX0KIAl9CiAJaWYgKHAycCkgewogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltQMlBdIik7CkBAIC0yMTQ2LDkgKzIzMTgsMTAgQEAKIHsKIAlpbnQgaWQ7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOworCWNoYXIgKnBvczsKIAogCS8qIGNtZDogIjxuZXR3b3JrIGlkPiIgb3IgImFueSIgKi8KLQlpZiAob3Nfc3RyY21wKGNtZCwgImFueSIpID09IDApIHsKKwlpZiAob3Nfc3RybmNtcChjbWQsICJhbnkiLCAzKSA9PSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogU0VMRUNUX05FVFdPUksgYW55Iik7CiAJCXNzaWQgPSBOVUxMOwogCX0gZWxzZSB7CkBAIC0yMTY4LDYgKzIzNDEsMTYgQEAKIAkJfQogCX0KIAorCXBvcyA9IG9zX3N0cnN0cihjbWQsICIgZnJlcT0iKTsKKwlpZiAocG9zKSB7CisJCWludCAqZnJlcXMgPSBmcmVxX3JhbmdlX3RvX2NoYW5uZWxfbGlzdCh3cGFfcywgcG9zICsgNik7CisJCWlmIChmcmVxcykgeworCQkJd3BhX3MtPnNjYW5fcmVxID0gTUFOVUFMX1NDQU5fUkVROworCQkJb3NfZnJlZSh3cGFfcy0+bWFudWFsX3NjYW5fZnJlcXMpOworCQkJd3BhX3MtPm1hbnVhbF9zY2FuX2ZyZXFzID0gZnJlcXM7CisJCX0KKwl9CisKIAl3cGFfc3VwcGxpY2FudF9zZWxlY3RfbmV0d29yayh3cGFfcywgc3NpZCk7CiAKIAlyZXR1cm4gMDsKQEAgLTIzNTIsNiArMjUzNSwzOSBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV91cGRhdGVfbmV0d29yaygKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsCisJY2hhciAqbmFtZSwgY2hhciAqdmFsdWUpCit7CisJaWYgKHdwYV9jb25maWdfc2V0KHNzaWQsIG5hbWUsIHZhbHVlLCAwKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBGYWlsZWQgdG8gc2V0IG5ldHdvcmsgIgorCQkJICAgInZhcmlhYmxlICclcyciLCBuYW1lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChvc19zdHJjbXAobmFtZSwgImJzc2lkIikgIT0gMCAmJgorCSAgICBvc19zdHJjbXAobmFtZSwgInByaW9yaXR5IikgIT0gMCkKKwkJd3BhX3NtX3Bta3NhX2NhY2hlX2ZsdXNoKHdwYV9zLT53cGEsIHNzaWQpOworCisJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gc3NpZCB8fCB3cGFfcy0+Y3VycmVudF9zc2lkID09IE5VTEwpIHsKKwkJLyoKKwkJICogSW52YWxpZGF0ZSB0aGUgRUFQIHNlc3Npb24gY2FjaGUgaWYgYW55dGhpbmcgaW4gdGhlIGN1cnJlbnQKKwkJICogb3IgcHJldmlvdXNseSB1c2VkIGNvbmZpZ3VyYXRpb24gY2hhbmdlcy4KKwkJICovCisJCWVhcG9sX3NtX2ludmFsaWRhdGVfY2FjaGVkX3Nlc3Npb24od3BhX3MtPmVhcG9sKTsKKwl9CisKKwlpZiAoKG9zX3N0cmNtcChuYW1lLCAicHNrIikgPT0gMCAmJgorCSAgICAgdmFsdWVbMF0gPT0gJyInICYmIHNzaWQtPnNzaWRfbGVuKSB8fAorCSAgICAob3Nfc3RyY21wKG5hbWUsICJzc2lkIikgPT0gMCAmJiBzc2lkLT5wYXNzcGhyYXNlKSkKKwkJd3BhX2NvbmZpZ191cGRhdGVfcHNrKHNzaWQpOworCWVsc2UgaWYgKG9zX3N0cmNtcChuYW1lLCAicHJpb3JpdHkiKSA9PSAwKQorCQl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOworCisJcmV0dXJuIDA7Cit9CisKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NldF9uZXR3b3JrKAogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKIHsKQEAgLTIzODMsMzIgKzI1OTksOCBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKHdwYV9jb25maWdfc2V0KHNzaWQsIG5hbWUsIHZhbHVlLCAwKSA8IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBGYWlsZWQgdG8gc2V0IG5ldHdvcmsgIgotCQkJICAgInZhcmlhYmxlICclcyciLCBuYW1lKTsKLQkJcmV0dXJuIC0xOwotCX0KLQotCWlmIChvc19zdHJjbXAobmFtZSwgImJzc2lkIikgIT0gMCAmJgotCSAgICBvc19zdHJjbXAobmFtZSwgInByaW9yaXR5IikgIT0gMCkKLQkJd3BhX3NtX3Bta3NhX2NhY2hlX2ZsdXNoKHdwYV9zLT53cGEsIHNzaWQpOwotCi0JaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gc3NpZCB8fCB3cGFfcy0+Y3VycmVudF9zc2lkID09IE5VTEwpIHsKLQkJLyoKLQkJICogSW52YWxpZGF0ZSB0aGUgRUFQIHNlc3Npb24gY2FjaGUgaWYgYW55dGhpbmcgaW4gdGhlIGN1cnJlbnQKLQkJICogb3IgcHJldmlvdXNseSB1c2VkIGNvbmZpZ3VyYXRpb24gY2hhbmdlcy4KLQkJICovCi0JCWVhcG9sX3NtX2ludmFsaWRhdGVfY2FjaGVkX3Nlc3Npb24od3BhX3MtPmVhcG9sKTsKLQl9Ci0KLQlpZiAoKG9zX3N0cmNtcChuYW1lLCAicHNrIikgPT0gMCAmJgotCSAgICAgdmFsdWVbMF0gPT0gJyInICYmIHNzaWQtPnNzaWRfbGVuKSB8fAotCSAgICAob3Nfc3RyY21wKG5hbWUsICJzc2lkIikgPT0gMCAmJiBzc2lkLT5wYXNzcGhyYXNlKSkKLQkJd3BhX2NvbmZpZ191cGRhdGVfcHNrKHNzaWQpOwotCWVsc2UgaWYgKG9zX3N0cmNtcChuYW1lLCAicHJpb3JpdHkiKSA9PSAwKQotCQl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOwotCi0JcmV0dXJuIDA7CisJcmV0dXJuIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfdXBkYXRlX25ldHdvcmsod3BhX3MsIHNzaWQsIG5hbWUsCisJCQkJCQkJdmFsdWUpOwogfQogCiAKQEAgLTI0NTYsNiArMjY0OCw1OSBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9kdXBfbmV0d29yaygKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCit7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkX3MsICpzc2lkX2Q7CisJY2hhciAqbmFtZSwgKmlkLCAqdmFsdWU7CisJaW50IGlkX3MsIGlkX2QsIHJldDsKKworCS8qIGNtZDogIjxzcmMgbmV0d29yayBpZD4gPGRzdCBuZXR3b3JrIGlkPiA8dmFyaWFibGUgbmFtZT4iICovCisJaWQgPSBvc19zdHJjaHIoY21kLCAnICcpOworCWlmIChpZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJKmlkKysgPSAnXDAnOworCisJbmFtZSA9IG9zX3N0cmNocihpZCwgJyAnKTsKKwlpZiAobmFtZSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJKm5hbWUrKyA9ICdcMCc7CisKKwlpZF9zID0gYXRvaShjbWQpOworCWlkX2QgPSBhdG9pKGlkKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IERVUF9ORVRXT1JLIGlkPSVkIC0+ICVkIG5hbWU9JyVzJyIsCisJCSAgIGlkX3MsIGlkX2QsIG5hbWUpOworCisJc3NpZF9zID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwgaWRfcyk7CisJaWYgKHNzaWRfcyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogQ291bGQgbm90IGZpbmQgIgorCQkJICAgIm5ldHdvcmsgaWQ9JWQiLCBpZF9zKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXNzaWRfZCA9IHdwYV9jb25maWdfZ2V0X25ldHdvcmsod3BhX3MtPmNvbmYsIGlkX2QpOworCWlmIChzc2lkX2QgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IENvdWxkIG5vdCBmaW5kICIKKwkJCSAgICJuZXR3b3JrIGlkPSVkIiwgaWRfcyk7CisJCXJldHVybiAtMTsKKwl9CisKKwl2YWx1ZSA9IHdwYV9jb25maWdfZ2V0KHNzaWRfcywgbmFtZSk7CisJaWYgKHZhbHVlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBGYWlsZWQgdG8gZ2V0IG5ldHdvcmsgIgorCQkJICAgInZhcmlhYmxlICclcyciLCBuYW1lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldCA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfdXBkYXRlX25ldHdvcmsod3BhX3MsIHNzaWRfZCwgbmFtZSwKKwkJCQkJCSAgICAgICB2YWx1ZSk7CisKKwlvc19mcmVlKHZhbHVlKTsKKworCXJldHVybiByZXQ7Cit9CisKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2xpc3RfY3JlZHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJCWNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKIHsKQEAgLTI0NzYsNyArMjcyMSw3IEBACiAJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJWRcdCVzXHQlc1x0JXNcdCVzXG4iLAogCQkJCSAgY3JlZC0+aWQsIGNyZWQtPnJlYWxtID8gY3JlZC0+cmVhbG0gOiAiIiwKIAkJCQkgIGNyZWQtPnVzZXJuYW1lID8gY3JlZC0+dXNlcm5hbWUgOiAiIiwKLQkJCQkgIGNyZWQtPmRvbWFpbiA/IGNyZWQtPmRvbWFpbiA6ICIiLAorCQkJCSAgY3JlZC0+ZG9tYWluID8gY3JlZC0+ZG9tYWluWzBdIDogIiIsCiAJCQkJICBjcmVkLT5pbXNpID8gY3JlZC0+aW1zaSA6ICIiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCXJldHVybiBwb3MgLSBidWY7CkBAIC0yNTAxLDYgKzI3NDYsOCBAQAogCWlmIChjcmVkID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAorCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBDUkVEX0FEREVEICIlZCIsIGNyZWQtPmlkKTsKKwogCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJWRcbiIsIGNyZWQtPmlkKTsKIAlpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gYnVmbGVuKQogCQlyZXR1cm4gLTE7CkBAIC0yNTEzLDEyICsyNzYwLDIxIEBACiB7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwogCWNoYXIgc3RyWzIwXTsKKwlpbnQgaWQ7CiAKLQlpZiAoY3JlZCA9PSBOVUxMIHx8IHdwYV9jb25maWdfcmVtb3ZlX2NyZWQod3BhX3MtPmNvbmYsIGNyZWQtPmlkKSA8IDApIHsKKwlpZiAoY3JlZCA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogQ291bGQgbm90IGZpbmQgY3JlZCIpOwogCQlyZXR1cm4gLTE7CiAJfQogCisJaWQgPSBjcmVkLT5pZDsKKwlpZiAod3BhX2NvbmZpZ19yZW1vdmVfY3JlZCh3cGFfcy0+Y29uZiwgaWQpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IENvdWxkIG5vdCBmaW5kIGNyZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBDUkVEX1JFTU9WRUQgIiVkIiwgaWQpOworCiAJLyogUmVtb3ZlIGFueSBuZXR3b3JrIGVudHJ5IGNyZWF0ZWQgYmFzZWQgb24gdGhlIHJlbW92ZWQgY3JlZGVudGlhbCAqLwogCXNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKIAl3aGlsZSAoc3NpZCkgewpAQCAtMjU0Miw3ICsyNzk4LDggQEAKIAlpbnQgaWQ7CiAJc3RydWN0IHdwYV9jcmVkICpjcmVkLCAqcHJldjsKIAotCS8qIGNtZDogIjxjcmVkIGlkPiIsICJhbGwiLCBvciAic3BfZnFkbj08RlFETj4iICovCisJLyogY21kOiAiPGNyZWQgaWQ+IiwgImFsbCIsICJzcF9mcWRuPTxGUUROPiIsIG9yCisJICogInByb3Zpc2lvbmluZ19zcD08RlFETj4gKi8KIAlpZiAob3Nfc3RyY21wKGNtZCwgImFsbCIpID09IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBSRU1PVkVfQ1JFRCBhbGwiKTsKIAkJY3JlZCA9IHdwYV9zLT5jb25mLT5jcmVkOwpAQCAtMjU2MSw4ICsyODE4LDI5IEBACiAJCXdoaWxlIChjcmVkKSB7CiAJCQlwcmV2ID0gY3JlZDsKIAkJCWNyZWQgPSBjcmVkLT5uZXh0OwotCQkJaWYgKHByZXYtPmRvbWFpbiAmJgotCQkJICAgIG9zX3N0cmNtcChwcmV2LT5kb21haW4sIGNtZCArIDgpID09IDApCisJCQlpZiAocHJldi0+ZG9tYWluKSB7CisJCQkJc2l6ZV90IGk7CisJCQkJZm9yIChpID0gMDsgaSA8IHByZXYtPm51bV9kb21haW47IGkrKykgeworCQkJCQlpZiAob3Nfc3RyY21wKHByZXYtPmRvbWFpbltpXSwgY21kICsgOCkKKwkJCQkJICAgICE9IDApCisJCQkJCQljb250aW51ZTsKKwkJCQkJd3Bhc19jdHJsX3JlbW92ZV9jcmVkKHdwYV9zLCBwcmV2KTsKKwkJCQkJYnJlYWs7CisJCQkJfQorCQkJfQorCQl9CisJCXJldHVybiAwOworCX0KKworCWlmIChvc19zdHJuY21wKGNtZCwgInByb3Zpc2lvbmluZ19zcD0iLCAxNikgPT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFJFTU9WRV9DUkVEIHByb3Zpc2lvbmluZyBTUCBGUUROICclcyciLAorCQkJICAgY21kICsgMTYpOworCQljcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7CisJCXdoaWxlIChjcmVkKSB7CisJCQlwcmV2ID0gY3JlZDsKKwkJCWNyZWQgPSBjcmVkLT5uZXh0OworCQkJaWYgKHByZXYtPnByb3Zpc2lvbmluZ19zcCAmJgorCQkJICAgIG9zX3N0cmNtcChwcmV2LT5wcm92aXNpb25pbmdfc3AsIGNtZCArIDE2KSA9PSAwKQogCQkJCXdwYXNfY3RybF9yZW1vdmVfY3JlZCh3cGFfcywgcHJldik7CiAJCX0KIAkJcmV0dXJuIDA7CkBAIC0yNjEzLDEwICsyODkxLDU3IEBACiAJCXJldHVybiAtMTsKIAl9CiAKKwl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgQ1JFRF9NT0RJRklFRCAiJWQgJXMiLCBjcmVkLT5pZCwgbmFtZSk7CisKIAlyZXR1cm4gMDsKIH0KIAogCitzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZ2V0X2NyZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICAgY2hhciAqY21kLCBjaGFyICpidWYsCisJCQkJCSAgICAgIHNpemVfdCBidWZsZW4pCit7CisJaW50IGlkOworCXNpemVfdCByZXM7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkOworCWNoYXIgKm5hbWUsICp2YWx1ZTsKKworCS8qIGNtZDogIjxjcmVkIGlkPiA8dmFyaWFibGUgbmFtZT4iICovCisJbmFtZSA9IG9zX3N0cmNocihjbWQsICcgJyk7CisJaWYgKG5hbWUgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCSpuYW1lKysgPSAnXDAnOworCisJaWQgPSBhdG9pKGNtZCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBHRVRfQ1JFRCBpZD0lZCBuYW1lPSclcyciLAorCQkgICBpZCwgbmFtZSk7CisKKwljcmVkID0gd3BhX2NvbmZpZ19nZXRfY3JlZCh3cGFfcy0+Y29uZiwgaWQpOworCWlmIChjcmVkID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBjcmVkIGlkPSVkIiwKKwkJCSAgIGlkKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXZhbHVlID0gd3BhX2NvbmZpZ19nZXRfY3JlZF9ub19rZXkoY3JlZCwgbmFtZSk7CisJaWYgKHZhbHVlID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBGYWlsZWQgdG8gZ2V0IGNyZWQgdmFyaWFibGUgJyVzJyIsCisJCQkgICBuYW1lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJlcyA9IG9zX3N0cmxjcHkoYnVmLCB2YWx1ZSwgYnVmbGVuKTsKKwlpZiAocmVzID49IGJ1ZmxlbikgeworCQlvc19mcmVlKHZhbHVlKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9zX2ZyZWUodmFsdWUpOworCisJcmV0dXJuIHJlczsKK30KKworCiAjaWZuZGVmIENPTkZJR19OT19DT05GSUdfV1JJVEUKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zYXZlX2NvbmZpZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewpAQCAtMjY0MiwxMyArMjk2NywzMiBAQAogI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfV1JJVEUgKi8KIAogCitzdHJ1Y3QgY2lwaGVyX2luZm8geworCXVuc2lnbmVkIGludCBjYXBhOworCWNvbnN0IGNoYXIgKm5hbWU7CisJaW50IGdyb3VwX29ubHk7Cit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGNpcGhlcl9pbmZvIGNpcGhlcnNbXSA9IHsKKwl7IFdQQV9EUklWRVJfQ0FQQV9FTkNfQ0NNUF8yNTYsICJDQ01QLTI1NiIsIDAgfSwKKwl7IFdQQV9EUklWRVJfQ0FQQV9FTkNfR0NNUF8yNTYsICJHQ01QLTI1NiIsIDAgfSwKKwl7IFdQQV9EUklWRVJfQ0FQQV9FTkNfQ0NNUCwgIkNDTVAiLCAwIH0sCisJeyBXUEFfRFJJVkVSX0NBUEFfRU5DX0dDTVAsICJHQ01QIiwgMCB9LAorCXsgV1BBX0RSSVZFUl9DQVBBX0VOQ19US0lQLCAiVEtJUCIsIDAgfSwKKwl7IFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEFfTk9ORSwgIk5PTkUiLCAwIH0sCisJeyBXUEFfRFJJVkVSX0NBUEFfRU5DX1dFUDEwNCwgIldFUDEwNCIsIDEgfSwKKwl7IFdQQV9EUklWRVJfQ0FQQV9FTkNfV0VQNDAsICJXRVA0MCIsIDEgfQorfTsKKworCiBzdGF0aWMgaW50IGN0cmxfaWZhY2VfZ2V0X2NhcGFiaWxpdHlfcGFpcndpc2UoaW50IHJlcywgY2hhciAqc3RyaWN0LAogCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhLAogCQkJCQkgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCiB7Ci0JaW50IHJldCwgZmlyc3QgPSAxOworCWludCByZXQ7CiAJY2hhciAqcG9zLCAqZW5kOwogCXNpemVfdCBsZW47CisJdW5zaWduZWQgaW50IGk7CiAKIAlwb3MgPSBidWY7CiAJZW5kID0gcG9zICsgYnVmbGVuOwpAQCAtMjY2MiwzNiArMzAwNiwxNSBAQAogCQlyZXR1cm4gbGVuOwogCX0KIAotCWlmIChjYXBhLT5lbmMgJiBXUEFfRFJJVkVSX0NBUEFfRU5DX0NDTVApIHsKLQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0NDTVAiLCBmaXJzdCA/ICIiIDogIiAiKTsKLQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKLQkJCXJldHVybiBwb3MgLSBidWY7Ci0JCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKLQl9Ci0KLQlpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19HQ01QKSB7Ci0JCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNHQ01QIiwgZmlyc3QgPyAiIiA6ICIgIik7Ci0JCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCi0JCQlyZXR1cm4gcG9zIC0gYnVmOwotCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7Ci0JfQotCi0JaWYgKGNhcGEtPmVuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfVEtJUCkgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzVEtJUCIsIGZpcnN0ID8gIiIgOiAiICIpOwotCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQotCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKLQkJcG9zICs9IHJldDsKLQkJZmlyc3QgPSAwOwotCX0KLQotCWlmIChjYXBhLT5rZXlfbWdtdCAmIFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEFfTk9ORSkgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzTk9ORSIsIGZpcnN0ID8gIiIgOiAiICIpOwotCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQotCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKLQkJcG9zICs9IHJldDsKLQkJZmlyc3QgPSAwOworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGNpcGhlcnMpOyBpKyspIHsKKwkJaWYgKCFjaXBoZXJzW2ldLmdyb3VwX29ubHkgJiYgY2FwYS0+ZW5jICYgY2lwaGVyc1tpXS5jYXBhKSB7CisJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzJXMiLAorCQkJCQkgIHBvcyA9PSBidWYgPyAiIiA6ICIgIiwKKwkJCQkJICBjaXBoZXJzW2ldLm5hbWUpOworCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQlyZXR1cm4gcG9zIC0gYnVmOworCQkJcG9zICs9IHJldDsKKwkJfQogCX0KIAogCXJldHVybiBwb3MgLSBidWY7CkBAIC0yNzAyLDkgKzMwMjUsMTAgQEAKIAkJCQkJICAgc3RydWN0IHdwYV9kcml2ZXJfY2FwYSAqY2FwYSwKIAkJCQkJICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQogewotCWludCByZXQsIGZpcnN0ID0gMTsKKwlpbnQgcmV0OwogCWNoYXIgKnBvcywgKmVuZDsKIAlzaXplX3QgbGVuOworCXVuc2lnbmVkIGludCBpOwogCiAJcG9zID0gYnVmOwogCWVuZCA9IHBvcyArIGJ1ZmxlbjsKQEAgLTI3MTgsNDUgKzMwNDIsMTUgQEAKIAkJcmV0dXJuIGxlbjsKIAl9CiAKLQlpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19DQ01QKSB7Ci0JCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNDQ01QIiwgZmlyc3QgPyAiIiA6ICIgIik7Ci0JCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCi0JCQlyZXR1cm4gcG9zIC0gYnVmOwotCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7Ci0JfQotCi0JaWYgKGNhcGEtPmVuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfR0NNUCkgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzR0NNUCIsIGZpcnN0ID8gIiIgOiAiICIpOwotCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQotCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKLQkJcG9zICs9IHJldDsKLQkJZmlyc3QgPSAwOwotCX0KLQotCWlmIChjYXBhLT5lbmMgJiBXUEFfRFJJVkVSX0NBUEFfRU5DX1RLSVApIHsKLQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1RLSVAiLCBmaXJzdCA/ICIiIDogIiAiKTsKLQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKLQkJCXJldHVybiBwb3MgLSBidWY7Ci0JCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKLQl9Ci0KLQlpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19XRVAxMDQpIHsKLQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1dFUDEwNCIsCi0JCQkJICBmaXJzdCA/ICIiIDogIiAiKTsKLQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKLQkJCXJldHVybiBwb3MgLSBidWY7Ci0JCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKLQl9Ci0KLQlpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19XRVA0MCkgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzV0VQNDAiLCBmaXJzdCA/ICIiIDogIiAiKTsKLQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKLQkJCXJldHVybiBwb3MgLSBidWY7Ci0JCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShjaXBoZXJzKTsgaSsrKSB7CisJCWlmIChjYXBhLT5lbmMgJiBjaXBoZXJzW2ldLmNhcGEpIHsKKwkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXMlcyIsCisJCQkJCSAgcG9zID09IGJ1ZiA/ICIiIDogIiAiLAorCQkJCQkgIGNpcGhlcnNbaV0ubmFtZSk7CisJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJCXJldHVybiBwb3MgLSBidWY7CisJCQlwb3MgKz0gcmV0OworCQl9CiAJfQogCiAJcmV0dXJuIHBvcyAtIGJ1ZjsKQEAgLTI4MjAsNyArMzExNCw3IEBACiAJCQkJCSAgIHN0cnVjdCB3cGFfZHJpdmVyX2NhcGEgKmNhcGEsCiAJCQkJCSAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKIHsKLQlpbnQgcmV0LCBmaXJzdCA9IDE7CisJaW50IHJldDsKIAljaGFyICpwb3MsICplbmQ7CiAJc2l6ZV90IGxlbjsKIApAQCAtMjgzOCwyMCArMzEzMiwyMCBAQAogCiAJaWYgKGNhcGEtPmtleV9tZ210ICYgKFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEEyIHwKIAkJCSAgICAgIFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEEyX1BTSykpIHsKLQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1JTTiIsIGZpcnN0ID8gIiIgOiAiICIpOworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzUlNOIiwKKwkJCQkgIHBvcyA9PSBidWYgPyAiIiA6ICIgIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gcG9zIC0gYnVmOwogCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7CiAJfQogCiAJaWYgKGNhcGEtPmtleV9tZ210ICYgKFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEEgfAogCQkJICAgICAgV1BBX0RSSVZFUl9DQVBBX0tFWV9NR01UX1dQQV9QU0spKSB7Ci0JCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNXUEEiLCBmaXJzdCA/ICIiIDogIiAiKTsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1dQQSIsCisJCQkJICBwb3MgPT0gYnVmID8gIiIgOiAiICIpOwogCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQogCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKIAkJcG9zICs9IHJldDsKLQkJZmlyc3QgPSAwOwogCX0KIAogCXJldHVybiBwb3MgLSBidWY7CkBAIC0yODYyLDcgKzMxNTYsNyBAQAogCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhLAogCQkJCQkgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCiB7Ci0JaW50IHJldCwgZmlyc3QgPSAxOworCWludCByZXQ7CiAJY2hhciAqcG9zLCAqZW5kOwogCXNpemVfdCBsZW47CiAKQEAgLTI4NzksMjggKzMxNzMsMjcgQEAKIAl9CiAKIAlpZiAoY2FwYS0+YXV0aCAmIChXUEFfRFJJVkVSX0FVVEhfT1BFTikpIHsKLQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc09QRU4iLCBmaXJzdCA/ICIiIDogIiAiKTsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc09QRU4iLAorCQkJCSAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCXJldHVybiBwb3MgLSBidWY7CiAJCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKIAl9CiAKIAlpZiAoY2FwYS0+YXV0aCAmIChXUEFfRFJJVkVSX0FVVEhfU0hBUkVEKSkgewogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzU0hBUkVEIiwKLQkJCQkgIGZpcnN0ID8gIiIgOiAiICIpOworCQkJCSAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCXJldHVybiBwb3MgLSBidWY7CiAJCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKIAl9CiAKIAlpZiAoY2FwYS0+YXV0aCAmIChXUEFfRFJJVkVSX0FVVEhfTEVBUCkpIHsKLQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0xFQVAiLCBmaXJzdCA/ICIiIDogIiAiKTsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0xFQVAiLAorCQkJCSAgcG9zID09IGJ1ZiA/ICIiIDogIiAiKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCXJldHVybiBwb3MgLSBidWY7CiAJCXBvcyArPSByZXQ7Ci0JCWZpcnN0ID0gMDsKIAl9CiAKIAlyZXR1cm4gcG9zIC0gYnVmOwpAQCAtMjkxMSw3ICszMjA0LDcgQEAKIAkJCQkJICAgc3RydWN0IHdwYV9kcml2ZXJfY2FwYSAqY2FwYSwKIAkJCQkJICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQogewotCWludCByZXQsIGZpcnN0ID0gMTsKKwlpbnQgcmV0OwogCWNoYXIgKnBvcywgKmVuZDsKIAlzaXplX3QgbGVuOwogCkBAIC0yOTI4LDE5ICszMjIxLDE5IEBACiAJfQogCiAJaWYgKGNhcGEtPmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19JQlNTKSB7Ci0JCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNJQlNTIiwgZmlyc3QgPyAiIiA6ICIgIik7CisJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNJQlNTIiwKKwkJCQkgIHBvcyA9PSBidWYgPyAiIiA6ICIgIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gcG9zIC0gYnVmOwogCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7CiAJfQogCiAJaWYgKGNhcGEtPmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19BUCkgewotCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzQVAiLCBmaXJzdCA/ICIiIDogIiAiKTsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0FQIiwKKwkJCQkgIHBvcyA9PSBidWYgPyAiIiA6ICIgIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQlyZXR1cm4gcG9zIC0gYnVmOwogCQlwb3MgKz0gcmV0OwotCQlmaXJzdCA9IDA7CiAJfQogCiAJcmV0dXJuIHBvcyAtIGJ1ZjsKQEAgLTMwMzMsMTAgKzMzMjYsMTMgQEAKIAkJZm9yIChpID0gMDsgaSA8IHdwYV9zLT5ody5tb2Rlc1tqXS5udW1fY2hhbm5lbHM7IGkrKykgewogCQkJaWYgKGNobmxbaV0uZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKIAkJCQljb250aW51ZTsKLQkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiICVkID0gJWQgTUh6JXNcbiIsCisJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiAlZCA9ICVkIE1IeiVzJXNcbiIsCiAJCQkJCSAgY2hubFtpXS5jaGFuLCBjaG5sW2ldLmZyZXEsCiAJCQkJCSAgY2hubFtpXS5mbGFnICYgSE9TVEFQRF9DSEFOX05PX0lCU1MgPwotCQkJCQkgICIgKE5PX0lCU1MpIiA6ICIiKTsKKwkJCQkJICAiIChOT19JQlNTKSIgOiAiIiwKKwkJCQkJICBjaG5sW2ldLmZsYWcgJiBIT1NUQVBEX0NIQU5fUkFEQVIgPworCQkJCQkgICIgKERGUykiIDogIiIpOworCiAJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQogCQkJCXJldHVybiBwb3MgLSBidWY7CiAJCQlwb3MgKz0gcmV0OwpAQCAtMzExMSw2ICszNDA3LDExIEBACiAJaWYgKG9zX3N0cmNtcChmaWVsZCwgImZyZXEiKSA9PSAwKQogCQlyZXR1cm4gY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9mcmVxKHdwYV9zLCBidWYsIGJ1Zmxlbik7CiAKKyNpZmRlZiBDT05GSUdfVERMUworCWlmIChvc19zdHJjbXAoZmllbGQsICJ0ZGxzIikgPT0gMCkKKwkJcmV0dXJuIGN0cmxfaWZhY2VfZ2V0X2NhcGFiaWxpdHlfdGRscyh3cGFfcywgYnVmLCBidWZsZW4pOworI2VuZGlmIC8qIENPTkZJR19URExTICovCisKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFVua25vd24gR0VUX0NBUEFCSUxJVFkgZmllbGQgJyVzJyIsCiAJCSAgIGZpZWxkKTsKIApAQCAtMzIzMiw5ICszNTMzLDkgQEAKIAl9CiAKIAlpZiAobWFzayAmIFdQQV9CU1NfTUFTS19BR0UpIHsKLQkJc3RydWN0IG9zX3RpbWUgbm93OworCQlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKLQkJb3NfZ2V0X3RpbWUoJm5vdyk7CisJCW9zX2dldF9yZWx0aW1lKCZub3cpOwogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgImFnZT0lZFxuIiwKIAkJCQkgIChpbnQpIChub3cuc2VjIC0gYnNzLT5sYXN0X3VwZGF0ZS5zZWMpKTsKIAkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKQEAgLTMyODMsMTkgKzM1ODQsNDYgQEAKIAkJCQlyZXR1cm4gMDsKIAkJCXBvcyArPSByZXQ7CiAJCX0KLQkJaWYgKGJzcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfSUJTUykgewotCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbSUJTU10iKTsKKwkJaWYgKGJzc19pc19kbWcoYnNzKSkgeworCQkJY29uc3QgY2hhciAqczsKKwkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiW0RNR10iKTsKIAkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQkJcmV0dXJuIDA7CiAJCQlwb3MgKz0gcmV0OwotCQl9Ci0JCWlmIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX0VTUykgewotCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbRVNTXSIpOworCQkJc3dpdGNoIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX0RNR19NQVNLKSB7CisJCQljYXNlIElFRUU4MDIxMV9DQVBfRE1HX0lCU1M6CisJCQkJcyA9ICJbSUJTU10iOworCQkJCWJyZWFrOworCQkJY2FzZSBJRUVFODAyMTFfQ0FQX0RNR19BUDoKKwkJCQlzID0gIltFU1NdIjsKKwkJCQlicmVhazsKKwkJCWNhc2UgSUVFRTgwMjExX0NBUF9ETUdfUEJTUzoKKwkJCQlzID0gIltQQlNTXSI7CisJCQkJYnJlYWs7CisJCQlkZWZhdWx0OgorCQkJCXMgPSAiIjsKKwkJCQlicmVhazsKKwkJCX0KKwkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXMiLCBzKTsKIAkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCiAJCQkJcmV0dXJuIDA7CiAJCQlwb3MgKz0gcmV0OworCQl9IGVsc2UgeworCQkJaWYgKGJzcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfSUJTUykgeworCQkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiW0lCU1NdIik7CisJCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQkJcmV0dXJuIDA7CisJCQkJcG9zICs9IHJldDsKKwkJCX0KKwkJCWlmIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX0VTUykgeworCQkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiW0VTU10iKTsKKwkJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJCQlyZXR1cm4gMDsKKwkJCQlwb3MgKz0gcmV0OworCQkJfQogCQl9Ci0JCWlmICh3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBQMlBfSUVfVkVORE9SX1RZUEUpKSB7CisJCWlmICh3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBQMlBfSUVfVkVORE9SX1RZUEUpIHx8CisJCSAgICB3cGFfYnNzX2dldF92ZW5kb3JfaWVfYmVhY29uKGJzcywgUDJQX0lFX1ZFTkRPUl9UWVBFKSkgewogCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbUDJQXSIpOwogCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKIAkJCQlyZXR1cm4gMDsKQEAgLTMzNTIsOCArMzY4MCwxMCBAQAogCQkJCQkJICBXRkRfSUVfVkVORE9SX1RZUEUpOwogCQlpZiAod2ZkKSB7CiAJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIndmZF9zdWJlbGVtcz0iKTsKLQkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCisJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKSB7CisJCQkJd3BhYnVmX2ZyZWUod2ZkKTsKIAkJCQlyZXR1cm4gMDsKKwkJCX0KIAkJCXBvcyArPSByZXQ7CiAKIAkJCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLApAQCAtMzM5Miw2ICszNzIyLDEwIEBACiAJCQkJICAgYW5xcC0+aHMyMF93YW5fbWV0cmljcyk7CiAJCXBvcyA9IGFucXBfYWRkX2hleChwb3MsIGVuZCwgImhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5IiwKIAkJCQkgICBhbnFwLT5oczIwX2Nvbm5lY3Rpb25fY2FwYWJpbGl0eSk7CisJCXBvcyA9IGFucXBfYWRkX2hleChwb3MsIGVuZCwgImhzMjBfb3BlcmF0aW5nX2NsYXNzIiwKKwkJCQkgICBhbnFwLT5oczIwX29wZXJhdGluZ19jbGFzcyk7CisJCXBvcyA9IGFucXBfYWRkX2hleChwb3MsIGVuZCwgImhzMjBfb3N1X3Byb3ZpZGVyc19saXN0IiwKKwkJCQkgICBhbnFwLT5oczIwX29zdV9wcm92aWRlcnNfbGlzdCk7CiAjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAl9CiAjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwpAQCAtMzU4Niw2ICszOTIwLDcgQEAKIH0KIAogCisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwogc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9kcm9wX3NhKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEcm9wcGluZyBTQSB3aXRob3V0IGRlYXV0aGVudGljYXRpb24iKTsKQEAgLTM2MDcsNiArMzk0Miw3IEBACiAJCQkJICAgTUxNRV9TRVRQUk9URUNUSU9OX0tFWV9UWVBFX1BBSVJXSVNFKTsKIAl3cGFfc21fZHJvcF9zYSh3cGFfcy0+d3BhKTsKIH0KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCiAKIAogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3JvYW0oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKQEAgLTM2NTksOSArMzk5NSwxNSBAQAogCXVuc2lnbmVkIGludCB0aW1lb3V0ID0gYXRvaShjbWQpOwogCWVudW0gcDJwX2Rpc2NvdmVyeV90eXBlIHR5cGUgPSBQMlBfRklORF9TVEFSVF9XSVRIX0ZVTEw7CiAJdTggZGV2X2lkW0VUSF9BTEVOXSwgKl9kZXZfaWQgPSBOVUxMOworCXU4IGRldl90eXBlW1dQU19ERVZfVFlQRV9MRU5dLCAqX2Rldl90eXBlID0gTlVMTDsKIAljaGFyICpwb3M7CiAJdW5zaWduZWQgaW50IHNlYXJjaF9kZWxheTsKIAorCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0lORk8sCisJCQkiUmVqZWN0IFAyUF9GSU5EIHNpbmNlIGludGVyZmFjZSBpcyBkaXNhYmxlZCIpOworCQlyZXR1cm4gLTE7CisJfQogCWlmIChvc19zdHJzdHIoY21kLCAidHlwZT1zb2NpYWwiKSkKIAkJdHlwZSA9IFAyUF9GSU5EX09OTFlfU09DSUFMOwogCWVsc2UgaWYgKG9zX3N0cnN0cihjbWQsICJ0eXBlPXByb2dyZXNzaXZlIikpCkBAIC0zNjc1LDYgKzQwMTcsMTQgQEAKIAkJX2Rldl9pZCA9IGRldl9pZDsKIAl9CiAKKwlwb3MgPSBvc19zdHJzdHIoY21kLCAiZGV2X3R5cGU9Iik7CisJaWYgKHBvcykgeworCQlwb3MgKz0gOTsKKwkJaWYgKHdwc19kZXZfdHlwZV9zdHIyYmluKHBvcywgZGV2X3R5cGUpIDwgMCkKKwkJCXJldHVybiAtMTsKKwkJX2Rldl90eXBlID0gZGV2X3R5cGU7CisJfQorCiAJcG9zID0gb3Nfc3Ryc3RyKGNtZCwgImRlbGF5PSIpOwogCWlmIChwb3MpIHsKIAkJcG9zICs9IDY7CkBAIC0zNjgyLDggKzQwMzIsOCBAQAogCX0gZWxzZQogCQlzZWFyY2hfZGVsYXkgPSB3cGFzX3AycF9zZWFyY2hfZGVsYXkod3BhX3MpOwogCi0JcmV0dXJuIHdwYXNfcDJwX2ZpbmQod3BhX3MsIHRpbWVvdXQsIHR5cGUsIDAsIE5VTEwsIF9kZXZfaWQsCi0JCQkgICAgIHNlYXJjaF9kZWxheSk7CisJcmV0dXJuIHdwYXNfcDJwX2ZpbmQod3BhX3MsIHRpbWVvdXQsIHR5cGUsIF9kZXZfdHlwZSAhPSBOVUxMLCBfZGV2X3R5cGUsCisJCQkgICAgIF9kZXZfaWQsIHNlYXJjaF9kZWxheSk7CiB9CiAKIApAQCAtMzcwMywxMiArNDA1MywxMiBAQAogCWludCBnb19pbnRlbnQgPSAtMTsKIAlpbnQgZnJlcSA9IDA7CiAJaW50IHBkOwotCWludCBodDQwOworCWludCBodDQwLCB2aHQ7CiAKIAkvKiA8YWRkcj4gPCJwYmMiIHwgInBpbiIgfCBQSU4+IFtsYWJlbHxkaXNwbGF5fGtleXBhZF0KIAkgKiBbcGVyc2lzdGVudHxwZXJzaXN0ZW50PTxuZXR3b3JrIGlkPl0KIAkgKiBbam9pbl0gW2F1dGhdIFtnb19pbnRlbnQ9PDAuLjE1Pl0gW2ZyZXE9PGluIE1Iej5dIFtwcm92ZGlzY10KLQkgKiBbaHQ0MF0gKi8KKwkgKiBbaHQ0MF0gW3ZodF0gKi8KIAogCWlmIChod2FkZHJfYXRvbihjbWQsIGFkZHIpKQogCQlyZXR1cm4gLTE7CkBAIC0zNzM2LDcgKzQwODYsOSBAQAogCWF1dGggPSBvc19zdHJzdHIocG9zLCAiIGF1dGgiKSAhPSBOVUxMOwogCWF1dG9tYXRpYyA9IG9zX3N0cnN0cihwb3MsICIgYXV0byIpICE9IE5VTEw7CiAJcGQgPSBvc19zdHJzdHIocG9zLCAiIHByb3ZkaXNjIikgIT0gTlVMTDsKLQlodDQwID0gKG9zX3N0cnN0cihjbWQsICIgaHQ0MCIpICE9IE5VTEwpIHx8IHdwYV9zLT5jb25mLT5wMnBfZ29faHQ0MDsKKwl2aHQgPSAob3Nfc3Ryc3RyKGNtZCwgIiB2aHQiKSAhPSBOVUxMKSB8fCB3cGFfcy0+Y29uZi0+cDJwX2dvX3ZodDsKKwlodDQwID0gKG9zX3N0cnN0cihjbWQsICIgaHQ0MCIpICE9IE5VTEwpIHx8IHdwYV9zLT5jb25mLT5wMnBfZ29faHQ0MCB8fAorCQl2aHQ7CiAKIAlwb3MyID0gb3Nfc3Ryc3RyKHBvcywgIiBnb19pbnRlbnQ9Iik7CiAJaWYgKHBvczIpIHsKQEAgLTM3NzcsNyArNDEyOSw3IEBACiAJbmV3X3BpbiA9IHdwYXNfcDJwX2Nvbm5lY3Qod3BhX3MsIGFkZHIsIHBpbiwgd3BzX21ldGhvZCwKIAkJCQkgICBwZXJzaXN0ZW50X2dyb3VwLCBhdXRvbWF0aWMsIGpvaW4sCiAJCQkJICAgYXV0aCwgZ29faW50ZW50LCBmcmVxLCBwZXJzaXN0ZW50X2lkLCBwZCwKLQkJCQkgICBodDQwKTsKKwkJCQkgICBodDQwLCB2aHQpOwogCWlmIChuZXdfcGluID09IC0yKSB7CiAJCW9zX21lbWNweShidWYsICJGQUlMLUNIQU5ORUwtVU5BVkFJTEFCTEVcbiIsIDI1KTsKIAkJcmV0dXJuIDI1OwpAQCAtMzgwMyw2ICs0MTU1LDExIEBACiBzdGF0aWMgaW50IHAycF9jdHJsX2xpc3RlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCiB7CiAJdW5zaWduZWQgaW50IHRpbWVvdXQgPSBhdG9pKGNtZCk7CisJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCkgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfSU5GTywKKwkJCSJSZWplY3QgUDJQX0xJU1RFTiBzaW5jZSBpbnRlcmZhY2UgaXMgZGlzYWJsZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KIAlyZXR1cm4gd3Bhc19wMnBfbGlzdGVuKHdwYV9zLCB0aW1lb3V0KTsKIH0KIApAQCAtNDE0MSw3ICs0NDk4LDcgQEAKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CiAJdTggKl9wZWVyID0gTlVMTCwgcGVlcltFVEhfQUxFTl07CiAJaW50IGZyZXEgPSAwLCBwcmVmX2ZyZXEgPSAwOwotCWludCBodDQwOworCWludCBodDQwLCB2aHQ7CiAKIAlpZCA9IGF0b2koY21kKTsKIAlwb3MgPSBvc19zdHJzdHIoY21kLCAiIHBlZXI9Iik7CkBAIC00MTc1LDkgKzQ1MzIsMTIgQEAKIAkJCXJldHVybiAtMTsKIAl9CiAKLQlodDQwID0gKG9zX3N0cnN0cihjbWQsICIgaHQ0MCIpICE9IE5VTEwpIHx8IHdwYV9zLT5jb25mLT5wMnBfZ29faHQ0MDsKKwl2aHQgPSAob3Nfc3Ryc3RyKGNtZCwgIiB2aHQiKSAhPSBOVUxMKSB8fCB3cGFfcy0+Y29uZi0+cDJwX2dvX3ZodDsKKwlodDQwID0gKG9zX3N0cnN0cihjbWQsICIgaHQ0MCIpICE9IE5VTEwpIHx8IHdwYV9zLT5jb25mLT5wMnBfZ29faHQ0MCB8fAorCQl2aHQ7CiAKLQlyZXR1cm4gd3Bhc19wMnBfaW52aXRlKHdwYV9zLCBfcGVlciwgc3NpZCwgTlVMTCwgZnJlcSwgaHQ0MCwgcHJlZl9mcmVxKTsKKwlyZXR1cm4gd3Bhc19wMnBfaW52aXRlKHdwYV9zLCBfcGVlciwgc3NpZCwgTlVMTCwgZnJlcSwgaHQ0MCwgdmh0LAorCQkJICAgICAgIHByZWZfZnJlcSk7CiB9CiAKIApAQCAtNDIyNCw3ICs0NTg0LDggQEAKIAogCiBzdGF0aWMgaW50IHAycF9jdHJsX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSBjaGFyICpjbWQsIGludCBmcmVxLCBpbnQgaHQ0MCkKKwkJCQkJIGNoYXIgKmNtZCwgaW50IGZyZXEsIGludCBodDQwLAorCQkJCQkgaW50IHZodCkKIHsKIAlpbnQgaWQ7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwpAQCAtNDIzOCwzMSArNDU5OSwzNCBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JcmV0dXJuIHdwYXNfcDJwX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHdwYV9zLCBzc2lkLCAwLCBmcmVxLCBodDQwLCBOVUxMKTsKKwlyZXR1cm4gd3Bhc19wMnBfZ3JvdXBfYWRkX3BlcnNpc3RlbnQod3BhX3MsIHNzaWQsIDAsIGZyZXEsIDAsIGh0NDAsIHZodCwKKwkJCQkJICAgICBOVUxMLCAwKTsKIH0KIAogCiBzdGF0aWMgaW50IHAycF9jdHJsX2dyb3VwX2FkZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCiB7Ci0JaW50IGZyZXEgPSAwLCBodDQwOworCWludCBmcmVxID0gMCwgaHQ0MCwgdmh0OwogCWNoYXIgKnBvczsKIAogCXBvcyA9IG9zX3N0cnN0cihjbWQsICJmcmVxPSIpOwogCWlmIChwb3MpCiAJCWZyZXEgPSBhdG9pKHBvcyArIDUpOwogCi0JaHQ0MCA9IChvc19zdHJzdHIoY21kLCAiaHQ0MCIpICE9IE5VTEwpIHx8IHdwYV9zLT5jb25mLT5wMnBfZ29faHQ0MDsKKwl2aHQgPSAob3Nfc3Ryc3RyKGNtZCwgInZodCIpICE9IE5VTEwpIHx8IHdwYV9zLT5jb25mLT5wMnBfZ29fdmh0OworCWh0NDAgPSAob3Nfc3Ryc3RyKGNtZCwgImh0NDAiKSAhPSBOVUxMKSB8fCB3cGFfcy0+Y29uZi0+cDJwX2dvX2h0NDAgfHwKKwkJdmh0OwogCiAJaWYgKG9zX3N0cm5jbXAoY21kLCAicGVyc2lzdGVudD0iLCAxMSkgPT0gMCkKIAkJcmV0dXJuIHAycF9jdHJsX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHdwYV9zLCBjbWQgKyAxMSwgZnJlcSwKLQkJCQkJCSAgICAgaHQ0MCk7CisJCQkJCQkgICAgIGh0NDAsIHZodCk7CiAJaWYgKG9zX3N0cmNtcChjbWQsICJwZXJzaXN0ZW50IikgPT0gMCB8fAogCSAgICBvc19zdHJuY21wKGNtZCwgInBlcnNpc3RlbnQgIiwgMTEpID09IDApCi0JCXJldHVybiB3cGFzX3AycF9ncm91cF9hZGQod3BhX3MsIDEsIGZyZXEsIGh0NDApOworCQlyZXR1cm4gd3Bhc19wMnBfZ3JvdXBfYWRkKHdwYV9zLCAxLCBmcmVxLCBodDQwLCB2aHQpOwogCWlmIChvc19zdHJuY21wKGNtZCwgImZyZXE9IiwgNSkgPT0gMCkKLQkJcmV0dXJuIHdwYXNfcDJwX2dyb3VwX2FkZCh3cGFfcywgMCwgZnJlcSwgaHQ0MCk7CisJCXJldHVybiB3cGFzX3AycF9ncm91cF9hZGQod3BhX3MsIDAsIGZyZXEsIGh0NDAsIHZodCk7CiAJaWYgKGh0NDApCi0JCXJldHVybiB3cGFzX3AycF9ncm91cF9hZGQod3BhX3MsIDAsIGZyZXEsIGh0NDApOworCQlyZXR1cm4gd3Bhc19wMnBfZ3JvdXBfYWRkKHdwYV9zLCAwLCBmcmVxLCBodDQwLCB2aHQpOwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMOiBJbnZhbGlkIFAyUF9HUk9VUF9BREQgcGFyYW1ldGVycyAnJXMnIiwKIAkJICAgY21kKTsKQEAgLTQzNTgsNiArNDcyMiwyMiBAQAogCQlyZXR1cm4gcG9zIC0gYnVmOwogCXBvcyArPSByZXM7CiAKKwlpZiAoaW5mby0+dmVuZG9yX2VsZW1zKSB7CisJCXJlcyA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAidmVuZG9yX2VsZW1zPSIpOworCQlpZiAocmVzIDwgMCB8fCByZXMgPj0gZW5kIC0gcG9zKQorCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwkJcG9zICs9IHJlczsKKworCQlwb3MgKz0gd3BhX3NucHJpbnRmX2hleChwb3MsIGVuZCAtIHBvcywKKwkJCQkJd3BhYnVmX2hlYWQoaW5mby0+dmVuZG9yX2VsZW1zKSwKKwkJCQkJd3BhYnVmX2xlbihpbmZvLT52ZW5kb3JfZWxlbXMpKTsKKworCQlyZXMgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlxuIik7CisJCWlmIChyZXMgPCAwIHx8IHJlcyA+PSBlbmQgLSBwb3MpCisJCQlyZXR1cm4gcG9zIC0gYnVmOworCQlwb3MgKz0gcmVzOworCX0KKwogCXJldHVybiBwb3MgLSBidWY7CiB9CiAKQEAgLTQzNjUsNDggKzQ3NDUsMjEgQEAKIHN0YXRpYyBpbnQgcDJwX2N0cmxfZGlzYWxsb3dfZnJlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgY29uc3QgY2hhciAqcGFyYW0pCiB7Ci0Jc3RydWN0IHdwYV9mcmVxX3JhbmdlICpmcmVxID0gTlVMTCwgKm47Ci0JdW5zaWduZWQgaW50IGNvdW50ID0gMCwgaTsKLQljb25zdCBjaGFyICpwb3MsICpwb3MyLCAqcG9zMzsKKwl1bnNpZ25lZCBpbnQgaTsKIAogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCi0JLyoKLQkgKiBwYXJhbSBpbmNsdWRlcyBjb21tYSBzZXBhcmF0ZWQgZnJlcXVlbmN5IHJhbmdlLgotCSAqIEZvciBleGFtcGxlOiAyNDEyLTI0MzIsMjQ2Miw1MDAwLTYwMDAKLQkgKi8KLQlwb3MgPSBwYXJhbTsKLQl3aGlsZSAocG9zICYmIHBvc1swXSkgewotCQluID0gb3NfcmVhbGxvY19hcnJheShmcmVxLCBjb3VudCArIDEsCi0JCQkJICAgICBzaXplb2Yoc3RydWN0IHdwYV9mcmVxX3JhbmdlKSk7Ci0JCWlmIChuID09IE5VTEwpIHsKLQkJCW9zX2ZyZWUoZnJlcSk7Ci0JCQlyZXR1cm4gLTE7Ci0JCX0KLQkJZnJlcSA9IG47Ci0JCWZyZXFbY291bnRdLm1pbiA9IGF0b2kocG9zKTsKLQkJcG9zMiA9IG9zX3N0cmNocihwb3MsICctJyk7Ci0JCXBvczMgPSBvc19zdHJjaHIocG9zLCAnLCcpOwotCQlpZiAocG9zMiAmJiAoIXBvczMgfHwgcG9zMiA8IHBvczMpKSB7Ci0JCQlwb3MyKys7Ci0JCQlmcmVxW2NvdW50XS5tYXggPSBhdG9pKHBvczIpOwotCQl9IGVsc2UKLQkJCWZyZXFbY291bnRdLm1heCA9IGZyZXFbY291bnRdLm1pbjsKLQkJcG9zID0gcG9zMzsKLQkJaWYgKHBvcykKLQkJCXBvcysrOwotCQljb3VudCsrOwotCX0KKwlpZiAoZnJlcV9yYW5nZV9saXN0X3BhcnNlKCZ3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWxsb3dfZnJlcSwgcGFyYW0pIDwgMCkKKwkJcmV0dXJuIC0xOwogCi0JZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKKwlmb3IgKGkgPSAwOyBpIDwgd3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXEubnVtOyBpKyspIHsKKwkJc3RydWN0IHdwYV9mcmVxX3JhbmdlICpmcmVxOworCQlmcmVxID0gJndwYV9zLT5nbG9iYWwtPnAycF9kaXNhbGxvd19mcmVxLnJhbmdlW2ldOwogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRGlzYWxsb3dlZCBmcmVxdWVuY3kgcmFuZ2UgJXUtJXUiLAotCQkJICAgZnJlcVtpXS5taW4sIGZyZXFbaV0ubWF4KTsKKwkJCSAgIGZyZXEtPm1pbiwgZnJlcS0+bWF4KTsKIAl9CiAKLQlvc19mcmVlKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhbGxvd19mcmVxKTsKLQl3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWxsb3dfZnJlcSA9IGZyZXE7Ci0Jd3BhX3MtPmdsb2JhbC0+bnVtX3AycF9kaXNhbGxvd19mcmVxID0gY291bnQ7CiAJd3Bhc19wMnBfdXBkYXRlX2NoYW5uZWxfbGlzdCh3cGFfcyk7CiAJcmV0dXJuIDA7CiB9CkBAIC00NDM3LDcgKzQ3OTAsNyBAQAogCiAJaWYgKG9zX3N0cmNtcChjbWQsICJsaXN0ZW5fY2hhbm5lbCIpID09IDApIHsKIAkJcmV0dXJuIHAycF9zZXRfbGlzdGVuX2NoYW5uZWwod3BhX3MtPmdsb2JhbC0+cDJwLCA4MSwKLQkJCQkJICAgICAgYXRvaShwYXJhbSkpOworCQkJCQkgICAgICBhdG9pKHBhcmFtKSwgMSk7CiAJfQogCiAJaWYgKG9zX3N0cmNtcChjbWQsICJzc2lkX3Bvc3RmaXgiKSA9PSAwKSB7CkBAIC00NjAyLDYgKzQ5NTUsMTYgQEAKIAkJcmV0dXJuIDA7CiAJfQogCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwlpZiAob3Nfc3RyY21wKGNtZCwgIm5mY190YWciKSA9PSAwKQorCQlyZXR1cm4gd3Bhc19wMnBfbmZjX3RhZ19lbmFibGVkKHdwYV9zLCAhIWF0b2kocGFyYW0pKTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCisJaWYgKG9zX3N0cmNtcChjbWQsICJkaXNhYmxlX2lwX2FkZHJfcmVxIikgPT0gMCkgeworCQl3cGFfcy0+cDJwX2Rpc2FibGVfaXBfYWRkcl9yZXEgPSAhIWF0b2kocGFyYW0pOworCQlyZXR1cm4gMDsKKwl9CisKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFVua25vd24gUDJQX1NFVCBmaWVsZCB2YWx1ZSAnJXMnIiwKIAkJICAgY21kKTsKIApAQCAtNDY4OSw3ICs1MDUyLDY4IEBACiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAKK3N0YXRpYyBpbnQgKiBmcmVxX3JhbmdlX3RvX2NoYW5uZWxfbGlzdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICp2YWwpCit7CisJc3RydWN0IHdwYV9mcmVxX3JhbmdlX2xpc3QgcmFuZ2VzOworCWludCAqZnJlcXMgPSBOVUxMOworCXN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlOworCXUxNiBpOworCisJaWYgKHdwYV9zLT5ody5tb2RlcyA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCW9zX21lbXNldCgmcmFuZ2VzLCAwLCBzaXplb2YocmFuZ2VzKSk7CisJaWYgKGZyZXFfcmFuZ2VfbGlzdF9wYXJzZSgmcmFuZ2VzLCB2YWwpIDwgMCkKKwkJcmV0dXJuIE5VTEw7CisKKwlmb3IgKGkgPSAwOyBpIDwgd3BhX3MtPmh3Lm51bV9tb2RlczsgaSsrKSB7CisJCWludCBqOworCisJCW1vZGUgPSAmd3BhX3MtPmh3Lm1vZGVzW2ldOworCQlmb3IgKGogPSAwOyBqIDwgbW9kZS0+bnVtX2NoYW5uZWxzOyBqKyspIHsKKwkJCXVuc2lnbmVkIGludCBmcmVxOworCisJCQlpZiAobW9kZS0+Y2hhbm5lbHNbal0uZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKKwkJCQljb250aW51ZTsKKworCQkJZnJlcSA9IG1vZGUtPmNoYW5uZWxzW2pdLmZyZXE7CisJCQlpZiAoIWZyZXFfcmFuZ2VfbGlzdF9pbmNsdWRlcygmcmFuZ2VzLCBmcmVxKSkKKwkJCQljb250aW51ZTsKKworCQkJaW50X2FycmF5X2FkZF91bmlxdWUoJmZyZXFzLCBmcmVxKTsKKwkJfQorCX0KKworCW9zX2ZyZWUocmFuZ2VzLnJhbmdlKTsKKwlyZXR1cm4gZnJlcXM7Cit9CisKKwogI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKworc3RhdGljIGludCBjdHJsX2ludGVyd29ya2luZ19zZWxlY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqcGFyYW0pCit7CisJaW50IGF1dG9fc2VsID0gMDsKKwlpbnQgKmZyZXFzID0gTlVMTDsKKworCWlmIChwYXJhbSkgeworCQljaGFyICpwb3M7CisKKwkJYXV0b19zZWwgPSBvc19zdHJzdHIocGFyYW0sICJhdXRvIikgIT0gTlVMTDsKKworCQlwb3MgPSBvc19zdHJzdHIocGFyYW0sICJmcmVxPSIpOworCQlpZiAocG9zKSB7CisJCQlmcmVxcyA9IGZyZXFfcmFuZ2VfdG9fY2hhbm5lbF9saXN0KHdwYV9zLCBwb3MgKyA1KTsKKwkJCWlmIChmcmVxcyA9PSBOVUxMKQorCQkJCXJldHVybiAtMTsKKwkJfQorCisJfQorCisJcmV0dXJuIGludGVyd29ya2luZ19zZWxlY3Qod3BhX3MsIGF1dG9fc2VsLCBmcmVxcyk7Cit9CisKKwogc3RhdGljIGludCBjdHJsX2ludGVyd29ya2luZ19jb25uZWN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmRzdCkKIHsKIAl1OCBic3NpZFtFVEhfQUxFTl07CkBAIC00NzE5LDE1ICs1MTQzLDI3IEBACiAjZGVmaW5lIE1BWF9BTlFQX0lORk9fSUQgMTAwCiAJdTE2IGlkW01BWF9BTlFQX0lORk9fSURdOwogCXNpemVfdCBudW1faWQgPSAwOworCXUzMiBzdWJ0eXBlcyA9IDA7CiAKIAl1c2VkID0gaHdhZGRyX2F0b24yKGRzdCwgZHN0X2FkZHIpOwogCWlmICh1c2VkIDwgMCkKIAkJcmV0dXJuIC0xOwogCXBvcyA9IGRzdCArIHVzZWQ7CiAJd2hpbGUgKG51bV9pZCA8IE1BWF9BTlFQX0lORk9fSUQpIHsKLQkJaWRbbnVtX2lkXSA9IGF0b2kocG9zKTsKLQkJaWYgKGlkW251bV9pZF0pCi0JCQludW1faWQrKzsKKwkJaWYgKG9zX3N0cm5jbXAocG9zLCAiaHMyMDoiLCA1KSA9PSAwKSB7CisjaWZkZWYgQ09ORklHX0hTMjAKKwkJCWludCBudW0gPSBhdG9pKHBvcyArIDUpOworCQkJaWYgKG51bSA8PSAwIHx8IG51bSA+IDMxKQorCQkJCXJldHVybiAtMTsKKwkJCXN1YnR5cGVzIHw9IEJJVChudW0pOworI2Vsc2UgLyogQ09ORklHX0hTMjAgKi8KKwkJCXJldHVybiAtMTsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLworCQl9IGVsc2UgeworCQkJaWRbbnVtX2lkXSA9IGF0b2kocG9zKTsKKwkJCWlmIChpZFtudW1faWRdKQorCQkJCW51bV9pZCsrOworCQl9CiAJCXBvcyA9IG9zX3N0cmNocihwb3MgKyAxLCAnLCcpOwogCQlpZiAocG9zID09IE5VTEwpCiAJCQlicmVhazsKQEAgLTQ3MzcsNyArNTE3Myw3IEBACiAJaWYgKG51bV9pZCA9PSAwKQogCQlyZXR1cm4gLTE7CiAKLQlyZXR1cm4gYW5xcF9zZW5kX3JlcSh3cGFfcywgZHN0X2FkZHIsIGlkLCBudW1faWQpOworCXJldHVybiBhbnFwX3NlbmRfcmVxKHdwYV9zLCBkc3RfYWRkciwgaWQsIG51bV9pZCwgc3VidHlwZXMpOwogfQogCiAKQEAgLTQ4MTMsOSArNTI0OSw4IEBACiAJaW50IHVzZWQ7CiAJY2hhciAqcG9zOwogCXNpemVfdCByZXNwX2xlbiwgc3RhcnQsIHJlcXVlc3RlZF9sZW47Ci0KLQlpZiAoIXdwYV9zLT5sYXN0X2dhc19yZXNwKQotCQlyZXR1cm4gLTE7CisJc3RydWN0IHdwYWJ1ZiAqcmVzcDsKKwlpbnQgcmV0OwogCiAJdXNlZCA9IGh3YWRkcl9hdG9uMihjbWQsIGFkZHIpOwogCWlmICh1c2VkIDwgMCkKQEAgLTQ4MjYsMTEgKzUyNjEsMTggQEAKIAkJcG9zKys7CiAJZGlhbG9nX3Rva2VuID0gYXRvaShwb3MpOwogCi0JaWYgKG9zX21lbWNtcChhZGRyLCB3cGFfcy0+bGFzdF9nYXNfYWRkciwgRVRIX0FMRU4pICE9IDAgfHwKLQkgICAgZGlhbG9nX3Rva2VuICE9IHdwYV9zLT5sYXN0X2dhc19kaWFsb2dfdG9rZW4pCisJaWYgKHdwYV9zLT5sYXN0X2dhc19yZXNwICYmCisJICAgIG9zX21lbWNtcChhZGRyLCB3cGFfcy0+bGFzdF9nYXNfYWRkciwgRVRIX0FMRU4pID09IDAgJiYKKwkgICAgZGlhbG9nX3Rva2VuID09IHdwYV9zLT5sYXN0X2dhc19kaWFsb2dfdG9rZW4pCisJCXJlc3AgPSB3cGFfcy0+bGFzdF9nYXNfcmVzcDsKKwllbHNlIGlmICh3cGFfcy0+cHJldl9nYXNfcmVzcCAmJgorCQkgb3NfbWVtY21wKGFkZHIsIHdwYV9zLT5wcmV2X2dhc19hZGRyLCBFVEhfQUxFTikgPT0gMCAmJgorCQkgZGlhbG9nX3Rva2VuID09IHdwYV9zLT5wcmV2X2dhc19kaWFsb2dfdG9rZW4pCisJCXJlc3AgPSB3cGFfcy0+cHJldl9nYXNfcmVzcDsKKwllbHNlCiAJCXJldHVybiAtMTsKIAotCXJlc3BfbGVuID0gd3BhYnVmX2xlbih3cGFfcy0+bGFzdF9nYXNfcmVzcCk7CisJcmVzcF9sZW4gPSB3cGFidWZfbGVuKHJlc3ApOwogCXN0YXJ0ID0gMDsKIAlyZXF1ZXN0ZWRfbGVuID0gcmVzcF9sZW47CiAKQEAgLTQ4NTEsOSArNTI5MywyNCBAQAogCWlmIChyZXF1ZXN0ZWRfbGVuICogMiArIDEgPiBidWZsZW4pCiAJCXJldHVybiBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIkZBSUwtVG9vIGxvbmcgcmVzcG9uc2UiKTsKIAotCXJldHVybiB3cGFfc25wcmludGZfaGV4KGJ1ZiwgYnVmbGVuLAotCQkJCXdwYWJ1Zl9oZWFkX3U4KHdwYV9zLT5sYXN0X2dhc19yZXNwKSArIHN0YXJ0LAotCQkJCXJlcXVlc3RlZF9sZW4pOworCXJldCA9IHdwYV9zbnByaW50Zl9oZXgoYnVmLCBidWZsZW4sIHdwYWJ1Zl9oZWFkX3U4KHJlc3ApICsgc3RhcnQsCisJCQkgICAgICAgcmVxdWVzdGVkX2xlbik7CisKKwlpZiAoc3RhcnQgKyByZXF1ZXN0ZWRfbGVuID09IHJlc3BfbGVuKSB7CisJCS8qCisJCSAqIEZyZWUgbWVtb3J5IGJ5IGRyb3BwaW5nIHRoZSByZXNwb25zZSBhZnRlciBpdCBoYXMgYmVlbgorCQkgKiBmZXRjaGVkLgorCQkgKi8KKwkJaWYgKHJlc3AgPT0gd3BhX3MtPnByZXZfZ2FzX3Jlc3ApIHsKKwkJCXdwYWJ1Zl9mcmVlKHdwYV9zLT5wcmV2X2dhc19yZXNwKTsKKwkJCXdwYV9zLT5wcmV2X2dhc19yZXNwID0gTlVMTDsKKwkJfSBlbHNlIHsKKwkJCXdwYWJ1Zl9mcmVlKHdwYV9zLT5sYXN0X2dhc19yZXNwKTsKKwkJCXdwYV9zLT5sYXN0X2dhc19yZXNwID0gTlVMTDsKKwkJfQorCX0KKworCXJldHVybiByZXQ7CiB9CiAjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwogCkBAIC00OTQxLDcgKzUzOTgsNyBAQAogCWlmIChsZW4gPT0gMCAmJiBjcmVkICYmIGNyZWQtPnJlYWxtKQogCQlyZXR1cm4gaHMyMF9uYWlfaG9tZV9yZWFsbV9saXN0KHdwYV9zLCBkc3RfYWRkciwgY3JlZC0+cmVhbG0pOwogCi0JaWYgKGxlbiAlIDEpCisJaWYgKGxlbiAmIDEpCiAJCXJldHVybiAtMTsKIAlsZW4gLz0gMjsKIAlidWYgPSBvc19tYWxsb2MobGVuKTsKQEAgLTQ5NjAsNiArNTQxNywyNiBAQAogCXJldHVybiByZXQ7CiB9CiAKKworc3RhdGljIGludCBoczIwX2ljb25fcmVxdWVzdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCit7CisJdTggZHN0X2FkZHJbRVRIX0FMRU5dOworCWludCB1c2VkOworCWNoYXIgKmljb247CisKKwl1c2VkID0gaHdhZGRyX2F0b24yKGNtZCwgZHN0X2FkZHIpOworCWlmICh1c2VkIDwgMCkKKwkJcmV0dXJuIC0xOworCisJd2hpbGUgKGNtZFt1c2VkXSA9PSAnICcpCisJCXVzZWQrKzsKKwlpY29uID0gJmNtZFt1c2VkXTsKKworCXdwYV9zLT5mZXRjaF9vc3VfaWNvbl9pbl9wcm9ncmVzcyA9IDA7CisJcmV0dXJuIGhzMjBfYW5xcF9zZW5kX3JlcSh3cGFfcywgZHN0X2FkZHIsIEJJVChIUzIwX1NUWVBFX0lDT05fUkVRVUVTVCksCisJCQkJICAodTggKikgaWNvbiwgb3Nfc3RybGVuKGljb24pKTsKK30KKwogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKIApAQCAtNTE3NywxMSArNTY1NCw2OCBAQAogCQkJCXAycF9zZXRfY291bnRyeShwMnAsIGNvdW50cnkpOwogCQkJfQogCQl9Ci0JCXJldCA9IHNwcmludGYoYnVmLCAiJXNcbiIsICJPSyIpOworCQlyZXQgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzXG4iLCAiT0siKTsKIAl9CiAJcmV0dXJuIHJldDsKIH0KLSNlbmRpZgorI2VuZGlmIC8qIEFORFJPSUQgKi8KKworCitzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X3ZlbmRvcl9jbWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kLAorCQkJCSAgICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQoreworCWludCByZXQ7CisJY2hhciAqcG9zOworCXU4ICpkYXRhID0gTlVMTDsKKwl1bnNpZ25lZCBpbnQgdmVuZG9yX2lkLCBzdWJjbWQ7CisJc3RydWN0IHdwYWJ1ZiAqcmVwbHk7CisJc2l6ZV90IGRhdGFfbGVuID0gMDsKKworCS8qIGNtZDogPHZlbmRvciBpZD4gPHN1YmNvbW1hbmQgaWQ+IFs8aGV4IGZvcm1hdHRlZCBkYXRhPl0gKi8KKwl2ZW5kb3JfaWQgPSBzdHJ0b3VsKGNtZCwgJnBvcywgMTYpOworCWlmICghaXNibGFuaygqcG9zKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzdWJjbWQgPSBzdHJ0b3VsKHBvcywgJnBvcywgMTApOworCisJaWYgKCpwb3MgIT0gJ1wwJykgeworCQlpZiAoIWlzYmxhbmsoKnBvcysrKSkKKwkJCXJldHVybiAtRUlOVkFMOworCQlkYXRhX2xlbiA9IG9zX3N0cmxlbihwb3MpOworCX0KKworCWlmIChkYXRhX2xlbikgeworCQlkYXRhX2xlbiAvPSAyOworCQlkYXRhID0gb3NfbWFsbG9jKGRhdGFfbGVuKTsKKwkJaWYgKCFkYXRhKQorCQkJcmV0dXJuIC0xOworCisJCWlmIChoZXhzdHIyYmluKHBvcywgZGF0YSwgZGF0YV9sZW4pKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCQkgICAiVmVuZG9yIGNvbW1hbmQ6IHdyb25nIHBhcmFtZXRlciBmb3JtYXQiKTsKKwkJCW9zX2ZyZWUoZGF0YSk7CisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCX0KKworCXJlcGx5ID0gd3BhYnVmX2FsbG9jKChidWZsZW4gLSAxKSAvIDIpOworCWlmICghcmVwbHkpIHsKKwkJb3NfZnJlZShkYXRhKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldCA9IHdwYV9kcnZfdmVuZG9yX2NtZCh3cGFfcywgdmVuZG9yX2lkLCBzdWJjbWQsIGRhdGEsIGRhdGFfbGVuLAorCQkJCSByZXBseSk7CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IHdwYV9zbnByaW50Zl9oZXgoYnVmLCBidWZsZW4sIHdwYWJ1Zl9oZWFkX3U4KHJlcGx5KSwKKwkJCQkgICAgICAgd3BhYnVmX2xlbihyZXBseSkpOworCisJd3BhYnVmX2ZyZWUocmVwbHkpOworCW9zX2ZyZWUoZGF0YSk7CisKKwlyZXR1cm4gcmV0OworfQogCiAKIHN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZmx1c2goc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKQEAgLTUxODksMjQgKzU3MjMsMzYgQEAKIAl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJGbHVzaCBhbGwgd3BhX3N1cHBsaWNhbnQgc3RhdGUiKTsKIAogI2lmZGVmIENPTkZJR19QMlAKKwl3cGFzX3AycF9jYW5jZWwod3BhX3MpOwogCXdwYXNfcDJwX3N0b3BfZmluZCh3cGFfcyk7CiAJcDJwX2N0cmxfZmx1c2god3BhX3MpOwogCXdwYXNfcDJwX2dyb3VwX3JlbW92ZSh3cGFfcywgIioiKTsKKwl3cGFzX3AycF9zZXJ2aWNlX2ZsdXNoKHdwYV9zKTsKKwl3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgPSAwOworCXdwYV9zLT5nbG9iYWwtPnAycF9wZXJfc3RhX3BzayA9IDA7CisJd3BhX3MtPmNvbmYtPm51bV9zZWNfZGV2aWNlX3R5cGVzID0gMDsKKwl3cGFfcy0+cDJwX2Rpc2FibGVfaXBfYWRkcl9yZXEgPSAwOworCW9zX2ZyZWUod3BhX3MtPmdsb2JhbC0+cDJwX2dvX2F2b2lkX2ZyZXEucmFuZ2UpOworCXdwYV9zLT5nbG9iYWwtPnAycF9nb19hdm9pZF9mcmVxLnJhbmdlID0gTlVMTDsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKICNpZmRlZiBDT05GSUdfV1BTX1RFU1RJTkcKIAl3cHNfdmVyc2lvbl9udW1iZXIgPSAweDIwOwogCXdwc190ZXN0aW5nX2R1bW15X2NyZWQgPSAwOworCXdwc19jb3JydXB0X3BraGFzaCA9IDA7CiAjZW5kaWYgLyogQ09ORklHX1dQU19URVNUSU5HICovCiAjaWZkZWYgQ09ORklHX1dQUworCXdwYV9zLT53cHNfZnJhZ21lbnRfc2l6ZSA9IDA7CiAJd3Bhc193cHNfY2FuY2VsKHdwYV9zKTsKICNlbmRpZiAvKiBDT05GSUdfV1BTICovCisJd3BhX3MtPmFmdGVyX3dwcyA9IDA7CisJd3BhX3MtPmtub3duX3dwc19mcmVxID0gMDsKIAorI2lmZGVmIENPTkZJR19URExTCiAjaWZkZWYgQ09ORklHX1RETFNfVEVTVElORwogCWV4dGVybiB1bnNpZ25lZCBpbnQgdGRsc190ZXN0aW5nOwogCXRkbHNfdGVzdGluZyA9IDA7CiAjZW5kaWYgLyogQ09ORklHX1RETFNfVEVTVElORyAqLwotI2lmZGVmIENPTkZJR19URExTCiAJd3BhX2Rydl90ZGxzX29wZXIod3BhX3MsIFRETFNfRU5BQkxFLCBOVUxMKTsKIAl3cGFfdGRsc19lbmFibGUod3BhX3MtPndwYSwgMSk7CiAjZW5kaWYgLyogQ09ORklHX1RETFMgKi8KQEAgLTUyMzMsNiArNTc3OSw2NzggQEAKIAl3cGFfcy0+ZXh0cmFfYmxhY2tsaXN0X2NvdW50ID0gMDsKIAl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3JlbW92ZV9uZXR3b3JrKHdwYV9zLCAiYWxsIik7CiAJd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9yZW1vdmVfY3JlZCh3cGFfcywgImFsbCIpOworCXdwYV9jb25maWdfZmx1c2hfYmxvYnMod3BhX3MtPmNvbmYpOworCXdwYV9zLT5jb25mLT5hdXRvX2ludGVyd29ya2luZyA9IDA7CisJd3BhX3MtPmNvbmYtPm9rYyA9IDA7CisKKwl3cGFfc21fc2V0X3BhcmFtKHdwYV9zLT53cGEsIFJTTkFfUE1LX0xJRkVUSU1FLCA0MzIwMCk7CisJd3BhX3NtX3NldF9wYXJhbSh3cGFfcy0+d3BhLCBSU05BX1BNS19SRUFVVEhfVEhSRVNIT0xELCA3MCk7CisJd3BhX3NtX3NldF9wYXJhbSh3cGFfcy0+d3BhLCBSU05BX1NBX1RJTUVPVVQsIDYwKTsKKwllYXBvbF9zbV9ub3RpZnlfbG9nb2ZmKHdwYV9zLT5lYXBvbCwgRkFMU0UpOworCisJcmFkaW9fcmVtb3ZlX3dvcmtzKHdwYV9zLCBOVUxMLCAxKTsKKworCXdwYV9zLT5uZXh0X3NzaWQgPSBOVUxMOworCisjaWZkZWYgQ09ORklHX0lOVEVSV09SS0lORworCWhzMjBfY2FuY2VsX2ZldGNoX29zdSh3cGFfcyk7CisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLworCisJd3BhX3MtPmV4dF9tZ210X2ZyYW1lX2hhbmRsaW5nID0gMDsKK30KKworCitzdGF0aWMgaW50IHdwYXNfY3RybF9yYWRpb193b3JrX3Nob3coc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKK3sKKwlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcms7CisJY2hhciAqcG9zLCAqZW5kOworCXN0cnVjdCBvc19yZWx0aW1lIG5vdywgZGlmZjsKKworCXBvcyA9IGJ1ZjsKKwllbmQgPSBidWYgKyBidWZsZW47CisKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKKworCWRsX2xpc3RfZm9yX2VhY2god29yaywgJndwYV9zLT5yYWRpby0+d29yaywgc3RydWN0IHdwYV9yYWRpb193b3JrLCBsaXN0KQorCXsKKwkJaW50IHJldDsKKworCQlvc19yZWx0aW1lX3N1Yigmbm93LCAmd29yay0+dGltZSwgJmRpZmYpOworCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzQCVzOiV1OiV1OiVsZC4lMDZsZFxuIiwKKwkJCQkgIHdvcmstPnR5cGUsIHdvcmstPndwYV9zLT5pZm5hbWUsIHdvcmstPmZyZXEsCisJCQkJICB3b3JrLT5zdGFydGVkLCBkaWZmLnNlYywgZGlmZi51c2VjKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCWJyZWFrOworCQlwb3MgKz0gcmV0OworCX0KKworCXJldHVybiBwb3MgLSBidWY7Cit9CisKKworc3RhdGljIHZvaWQgd3Bhc19jdHJsX3JhZGlvX3dvcmtfdGltZW91dCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQoreworCXN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yayA9IGVsb29wX2N0eDsKKwlzdHJ1Y3Qgd3BhX2V4dGVybmFsX3dvcmsgKmV3b3JrID0gd29yay0+Y3R4OworCisJd3BhX2RiZyh3b3JrLT53cGFfcywgTVNHX0RFQlVHLAorCQkiVGltaW5nIG91dCBleHRlcm5hbCByYWRpbyB3b3JrICV1ICglcykiLAorCQlld29yay0+aWQsIHdvcmstPnR5cGUpOworCXdwYV9tc2cod29yay0+d3BhX3MsIE1TR19JTkZPLCBFWFRfUkFESU9fV09SS19USU1FT1VUICIldSIsIGV3b3JrLT5pZCk7CisJcmFkaW9fd29ya19kb25lKHdvcmspOworCW9zX2ZyZWUoZXdvcmspOworfQorCisKK3N0YXRpYyB2b2lkIHdwYXNfY3RybF9yYWRpb193b3JrX2NiKHN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yaywgaW50IGRlaW5pdCkKK3sKKwlzdHJ1Y3Qgd3BhX2V4dGVybmFsX3dvcmsgKmV3b3JrID0gd29yay0+Y3R4OworCisJaWYgKGRlaW5pdCkgeworCQlpZiAod29yay0+c3RhcnRlZCkKKwkJCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfY3RybF9yYWRpb193b3JrX3RpbWVvdXQsCisJCQkJCSAgICAgd29yaywgTlVMTCk7CisKKwkJb3NfZnJlZShld29yayk7CisJCXJldHVybjsKKwl9CisKKwl3cGFfZGJnKHdvcmstPndwYV9zLCBNU0dfREVCVUcsICJTdGFydGluZyBleHRlcm5hbCByYWRpbyB3b3JrICV1ICglcykiLAorCQlld29yay0+aWQsIGV3b3JrLT50eXBlKTsKKwl3cGFfbXNnKHdvcmstPndwYV9zLCBNU0dfSU5GTywgRVhUX1JBRElPX1dPUktfU1RBUlQgIiV1IiwgZXdvcmstPmlkKTsKKwlpZiAoIWV3b3JrLT50aW1lb3V0KQorCQlld29yay0+dGltZW91dCA9IDEwOworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoZXdvcmstPnRpbWVvdXQsIDAsIHdwYXNfY3RybF9yYWRpb193b3JrX3RpbWVvdXQsCisJCQkgICAgICAgd29yaywgTlVMTCk7Cit9CisKKworc3RhdGljIGludCB3cGFzX2N0cmxfcmFkaW9fd29ya19hZGQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kLAorCQkJCSAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCit7CisJc3RydWN0IHdwYV9leHRlcm5hbF93b3JrICpld29yazsKKwljaGFyICpwb3MsICpwb3MyOworCXNpemVfdCB0eXBlX2xlbjsKKwlpbnQgcmV0OworCXVuc2lnbmVkIGludCBmcmVxID0gMDsKKworCS8qIGZvcm1hdDogPG5hbWU+IFtmcmVxPTxNSHo+XSBbdGltZW91dD08c2Vjb25kcz5dICovCisKKwlld29yayA9IG9zX3phbGxvYyhzaXplb2YoKmV3b3JrKSk7CisJaWYgKGV3b3JrID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXBvcyA9IG9zX3N0cmNocihjbWQsICcgJyk7CisJaWYgKHBvcykgeworCQl0eXBlX2xlbiA9IHBvcyAtIGNtZDsKKwkJcG9zKys7CisKKwkJcG9zMiA9IG9zX3N0cnN0cihwb3MsICJmcmVxPSIpOworCQlpZiAocG9zMikKKwkJCWZyZXEgPSBhdG9pKHBvczIgKyA1KTsKKworCQlwb3MyID0gb3Nfc3Ryc3RyKHBvcywgInRpbWVvdXQ9Iik7CisJCWlmIChwb3MyKQorCQkJZXdvcmstPnRpbWVvdXQgPSBhdG9pKHBvczIgKyA4KTsKKwl9IGVsc2UgeworCQl0eXBlX2xlbiA9IG9zX3N0cmxlbihjbWQpOworCX0KKwlpZiAoNCArIHR5cGVfbGVuID49IHNpemVvZihld29yay0+dHlwZSkpCisJCXR5cGVfbGVuID0gc2l6ZW9mKGV3b3JrLT50eXBlKSAtIDQgLSAxOworCW9zX3N0cmxjcHkoZXdvcmstPnR5cGUsICJleHQ6Iiwgc2l6ZW9mKGV3b3JrLT50eXBlKSk7CisJb3NfbWVtY3B5KGV3b3JrLT50eXBlICsgNCwgY21kLCB0eXBlX2xlbik7CisJZXdvcmstPnR5cGVbNCArIHR5cGVfbGVuXSA9ICdcMCc7CisKKwl3cGFfcy0+ZXh0X3dvcmtfaWQrKzsKKwlpZiAod3BhX3MtPmV4dF93b3JrX2lkID09IDApCisJCXdwYV9zLT5leHRfd29ya19pZCsrOworCWV3b3JrLT5pZCA9IHdwYV9zLT5leHRfd29ya19pZDsKKworCWlmIChyYWRpb19hZGRfd29yayh3cGFfcywgZnJlcSwgZXdvcmstPnR5cGUsIDAsIHdwYXNfY3RybF9yYWRpb193b3JrX2NiLAorCQkJICAgZXdvcmspIDwgMCkgeworCQlvc19mcmVlKGV3b3JrKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJXUiLCBld29yay0+aWQpOworCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4pCisJCXJldHVybiAtMTsKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19jdHJsX3JhZGlvX3dvcmtfZG9uZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCit7CisJc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrOworCXVuc2lnbmVkIGludCBpZCA9IGF0b2koY21kKTsKKworCWRsX2xpc3RfZm9yX2VhY2god29yaywgJndwYV9zLT5yYWRpby0+d29yaywgc3RydWN0IHdwYV9yYWRpb193b3JrLCBsaXN0KQorCXsKKwkJc3RydWN0IHdwYV9leHRlcm5hbF93b3JrICpld29yazsKKworCQlpZiAob3Nfc3RybmNtcCh3b3JrLT50eXBlLCAiZXh0OiIsIDQpICE9IDApCisJCQljb250aW51ZTsKKwkJZXdvcmsgPSB3b3JrLT5jdHg7CisJCWlmIChpZCAmJiBld29yay0+aWQgIT0gaWQpCisJCQljb250aW51ZTsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAorCQkJIkNvbXBsZXRlZCBleHRlcm5hbCByYWRpbyB3b3JrICV1ICglcykiLAorCQkJZXdvcmstPmlkLCBld29yay0+dHlwZSk7CisJCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfY3RybF9yYWRpb193b3JrX3RpbWVvdXQsIHdvcmssIE5VTEwpOworCQlyYWRpb193b3JrX2RvbmUod29yayk7CisJCW9zX2ZyZWUoZXdvcmspOworCQlyZXR1cm4gMzsgLyogIk9LXG4iICovCisJfQorCisJcmV0dXJuIC0xOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19jdHJsX3JhZGlvX3dvcmsoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kLAorCQkJCWNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKK3sKKwlpZiAob3Nfc3RyY21wKGNtZCwgInNob3ciKSA9PSAwKQorCQlyZXR1cm4gd3Bhc19jdHJsX3JhZGlvX3dvcmtfc2hvdyh3cGFfcywgYnVmLCBidWZsZW4pOworCWlmIChvc19zdHJuY21wKGNtZCwgImFkZCAiLCA0KSA9PSAwKQorCQlyZXR1cm4gd3Bhc19jdHJsX3JhZGlvX3dvcmtfYWRkKHdwYV9zLCBjbWQgKyA0LCBidWYsIGJ1Zmxlbik7CisJaWYgKG9zX3N0cm5jbXAoY21kLCAiZG9uZSAiLCA1KSA9PSAwKQorCQlyZXR1cm4gd3Bhc19jdHJsX3JhZGlvX3dvcmtfZG9uZSh3cGFfcywgY21kICsgNCk7CisJcmV0dXJuIC0xOworfQorCisKK3ZvaWQgd3Bhc19jdHJsX3JhZGlvX3dvcmtfZmx1c2goc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcmssICp0bXA7CisKKwlpZiAoIXdwYV9zIHx8ICF3cGFfcy0+cmFkaW8pCisJCXJldHVybjsKKworCWRsX2xpc3RfZm9yX2VhY2hfc2FmZSh3b3JrLCB0bXAsICZ3cGFfcy0+cmFkaW8tPndvcmssCisJCQkgICAgICBzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmssIGxpc3QpIHsKKwkJc3RydWN0IHdwYV9leHRlcm5hbF93b3JrICpld29yazsKKworCQlpZiAob3Nfc3RybmNtcCh3b3JrLT50eXBlLCAiZXh0OiIsIDQpICE9IDApCisJCQljb250aW51ZTsKKwkJZXdvcmsgPSB3b3JrLT5jdHg7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywKKwkJCSJGbHVzaGluZyVzIGV4dGVybmFsIHJhZGlvIHdvcmsgJXUgKCVzKSIsCisJCQl3b3JrLT5zdGFydGVkID8gIiBzdGFydGVkIiA6ICIiLCBld29yay0+aWQsCisJCQlld29yay0+dHlwZSk7CisJCWlmICh3b3JrLT5zdGFydGVkKQorCQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19jdHJsX3JhZGlvX3dvcmtfdGltZW91dCwKKwkJCQkJICAgICB3b3JrLCBOVUxMKTsKKwkJcmFkaW9fd29ya19kb25lKHdvcmspOworCQlvc19mcmVlKGV3b3JrKTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgd3Bhc19jdHJsX2VhcG9sX3Jlc3BvbnNlKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKKwllYXBvbF9zbV9ub3RpZnlfY3RybF9yZXNwb25zZSh3cGFfcy0+ZWFwb2wpOworfQorCisKK3N0YXRpYyBpbnQgc2V0X3NjYW5fZnJlcXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqdmFsKQoreworCWludCAqZnJlcXMgPSBOVUxMOworCisJZnJlcXMgPSBmcmVxX3JhbmdlX3RvX2NoYW5uZWxfbGlzdCh3cGFfcywgdmFsKTsKKwlpZiAoZnJlcXMgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJb3NfZnJlZSh3cGFfcy0+bWFudWFsX3NjYW5fZnJlcXMpOworCXdwYV9zLT5tYW51YWxfc2Nhbl9mcmVxcyA9IGZyZXFzOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBzY2FuX2lkX2xpc3RfcGFyc2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgY2hhciAqdmFsdWUpCit7CisJY29uc3QgY2hhciAqcG9zID0gdmFsdWU7CisKKwl3aGlsZSAocG9zKSB7CisJCWlmICgqcG9zID09ICcgJyB8fCAqcG9zID09ICdcMCcpCisJCQlicmVhazsKKwkJaWYgKHdwYV9zLT5zY2FuX2lkX2NvdW50ID09IE1BWF9TQ0FOX0lEKQorCQkJcmV0dXJuIC0xOworCQl3cGFfcy0+c2Nhbl9pZFt3cGFfcy0+c2Nhbl9pZF9jb3VudCsrXSA9IGF0b2kocG9zKTsKKwkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJywnKTsKKwkJaWYgKHBvcykKKwkJCXBvcysrOworCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyB2b2lkIHdwYXNfY3RybF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKnBhcmFtcywKKwkJCSAgIGNoYXIgKnJlcGx5LCBpbnQgcmVwbHlfc2l6ZSwgaW50ICpyZXBseV9sZW4pCit7CisJY2hhciAqcG9zOworCisJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCkgeworCQkqcmVwbHlfbGVuID0gLTE7CisJCXJldHVybjsKKwl9CisKKwl3cGFfcy0+bWFudWFsX3NjYW5fcGFzc2l2ZSA9IDA7CisJd3BhX3MtPm1hbnVhbF9zY2FuX3VzZV9pZCA9IDA7CisJd3BhX3MtPm1hbnVhbF9zY2FuX29ubHlfbmV3ID0gMDsKKwl3cGFfcy0+c2Nhbl9pZF9jb3VudCA9IDA7CisKKwlpZiAocGFyYW1zKSB7CisJCWlmIChvc19zdHJuY2FzZWNtcChwYXJhbXMsICJUWVBFPU9OTFkiLCA5KSA9PSAwKQorCQkJd3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPSBzY2FuX29ubHlfaGFuZGxlcjsKKworCQlwb3MgPSBvc19zdHJzdHIocGFyYW1zLCAiZnJlcT0iKTsKKwkJaWYgKHBvcyAmJiBzZXRfc2Nhbl9mcmVxcyh3cGFfcywgcG9zICsgNSkgPCAwKSB7CisJCQkqcmVwbHlfbGVuID0gLTE7CisJCQlyZXR1cm47CisJCX0KKworCQlwb3MgPSBvc19zdHJzdHIocGFyYW1zLCAicGFzc2l2ZT0iKTsKKwkJaWYgKHBvcykKKwkJCXdwYV9zLT5tYW51YWxfc2Nhbl9wYXNzaXZlID0gISFhdG9pKHBvcyArIDgpOworCisJCXBvcyA9IG9zX3N0cnN0cihwYXJhbXMsICJ1c2VfaWQ9Iik7CisJCWlmIChwb3MpCisJCQl3cGFfcy0+bWFudWFsX3NjYW5fdXNlX2lkID0gYXRvaShwb3MgKyA3KTsKKworCQlwb3MgPSBvc19zdHJzdHIocGFyYW1zLCAib25seV9uZXc9MSIpOworCQlpZiAocG9zKQorCQkJd3BhX3MtPm1hbnVhbF9zY2FuX29ubHlfbmV3ID0gMTsKKworCQlwb3MgPSBvc19zdHJzdHIocGFyYW1zLCAic2Nhbl9pZD0iKTsKKwkJaWYgKHBvcyAmJiBzY2FuX2lkX2xpc3RfcGFyc2Uod3BhX3MsIHBvcyArIDgpIDwgMCkgeworCQkJKnJlcGx5X2xlbiA9IC0xOworCQkJcmV0dXJuOworCQl9CisJfSBlbHNlIHsKKwkJb3NfZnJlZSh3cGFfcy0+bWFudWFsX3NjYW5fZnJlcXMpOworCQl3cGFfcy0+bWFudWFsX3NjYW5fZnJlcXMgPSBOVUxMOworCQlpZiAod3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPT0gc2Nhbl9vbmx5X2hhbmRsZXIpCisJCQl3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlciA9IE5VTEw7CisJfQorCisJaWYgKCF3cGFfcy0+c2NoZWRfc2Nhbm5pbmcgJiYgIXdwYV9zLT5zY2FubmluZyAmJgorCSAgICAoKHdwYV9zLT53cGFfc3RhdGUgPD0gV1BBX1NDQU5OSU5HKSB8fAorCSAgICAgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0NPTVBMRVRFRCkpKSB7CisJCXdwYV9zLT5ub3JtYWxfc2NhbnMgPSAwOworCQl3cGFfcy0+c2Nhbl9yZXEgPSBNQU5VQUxfU0NBTl9SRVE7CisJCXdwYV9zLT5hZnRlcl93cHMgPSAwOworCQl3cGFfcy0+a25vd25fd3BzX2ZyZXEgPSAwOworCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7CisJCWlmICh3cGFfcy0+bWFudWFsX3NjYW5fdXNlX2lkKSB7CisJCQl3cGFfcy0+bWFudWFsX3NjYW5faWQrKzsKKwkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkFzc2lnbmVkIHNjYW4gaWQgJXUiLAorCQkJCXdwYV9zLT5tYW51YWxfc2Nhbl9pZCk7CisJCQkqcmVwbHlfbGVuID0gb3Nfc25wcmludGYocmVwbHksIHJlcGx5X3NpemUsICIldVxuIiwKKwkJCQkJCSB3cGFfcy0+bWFudWFsX3NjYW5faWQpOworCQl9CisJfSBlbHNlIGlmICh3cGFfcy0+c2NoZWRfc2Nhbm5pbmcpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTdG9wIG9uZ29pbmcgc2NoZWRfc2NhbiB0byBhbGxvdyByZXF1ZXN0ZWQgZnVsbCBzY2FuIHRvIHByb2NlZWQiKTsKKwkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjaGVkX3NjYW4od3BhX3MpOworCQl3cGFfcy0+c2Nhbl9yZXEgPSBNQU5VQUxfU0NBTl9SRVE7CisJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKKwkJaWYgKHdwYV9zLT5tYW51YWxfc2Nhbl91c2VfaWQpIHsKKwkJCXdwYV9zLT5tYW51YWxfc2Nhbl9pZCsrOworCQkJKnJlcGx5X2xlbiA9IG9zX3NucHJpbnRmKHJlcGx5LCByZXBseV9zaXplLCAiJXVcbiIsCisJCQkJCQkgd3BhX3MtPm1hbnVhbF9zY2FuX2lkKTsKKwkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkFzc2lnbmVkIHNjYW4gaWQgJXUiLAorCQkJCXdwYV9zLT5tYW51YWxfc2Nhbl9pZCk7CisJCX0KKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9uZ29pbmcgc2NhbiBhY3Rpb24gLSByZWplY3QgbmV3IHJlcXVlc3QiKTsKKwkJKnJlcGx5X2xlbiA9IG9zX3NucHJpbnRmKHJlcGx5LCByZXBseV9zaXplLCAiRkFJTC1CVVNZXG4iKTsKKwl9Cit9CisKKworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKKworc3RhdGljIHZvaWQgd3Bhc19jdHJsX2lmYWNlX21nbXRfdHhfY2Ioc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgICAgdW5zaWduZWQgaW50IGZyZXEsIGNvbnN0IHU4ICpkc3QsCisJCQkJICAgICAgIGNvbnN0IHU4ICpzcmMsIGNvbnN0IHU4ICpic3NpZCwKKwkJCQkgICAgICAgY29uc3QgdTggKmRhdGEsIHNpemVfdCBkYXRhX2xlbiwKKwkJCQkgICAgICAgZW51bSBvZmZjaGFubmVsX3NlbmRfYWN0aW9uX3Jlc3VsdAorCQkJCSAgICAgICByZXN1bHQpCit7CisJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sICJNR01ULVRYLVNUQVRVUyBmcmVxPSV1IGRzdD0iIE1BQ1NUUgorCQkiIHNyYz0iIE1BQ1NUUiAiIGJzc2lkPSIgTUFDU1RSICIgcmVzdWx0PSVzIiwKKwkJZnJlcSwgTUFDMlNUUihkc3QpLCBNQUMyU1RSKHNyYyksIE1BQzJTVFIoYnNzaWQpLAorCQlyZXN1bHQgPT0gT0ZGQ0hBTk5FTF9TRU5EX0FDVElPTl9TVUNDRVNTID8KKwkJIlNVQ0NFU1MiIDogKHJlc3VsdCA9PSBPRkZDSEFOTkVMX1NFTkRfQUNUSU9OX05PX0FDSyA/CisJCQkgICAgICJOT19BQ0siIDogIkZBSUxFRCIpKTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfY3RybF9pZmFjZV9tZ210X3R4KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKK3sKKwljaGFyICpwb3MsICpwYXJhbTsKKwlzaXplX3QgbGVuOworCXU4ICpidWYsIGRhW0VUSF9BTEVOXSwgYnNzaWRbRVRIX0FMRU5dOworCWludCByZXMsIHVzZWQ7CisJaW50IGZyZXEgPSAwLCBub19jY2sgPSAwLCB3YWl0X3RpbWUgPSAwOworCisJLyogPERBPiA8QlNTSUQ+IFtmcmVxPTxNSHo+XSBbd2FpdF90aW1lPTxtcz5dIFtub19jY2s9MV0KKwkgKiAgICA8YWN0aW9uPUFjdGlvbiBmcmFtZSBwYXlsb2FkPiAqLworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFeHRlcm5hbCBNR01UIFRYOiAlcyIsIGNtZCk7CisKKwlwb3MgPSBjbWQ7CisJdXNlZCA9IGh3YWRkcl9hdG9uMihwb3MsIGRhKTsKKwlpZiAodXNlZCA8IDApCisJCXJldHVybiAtMTsKKwlwb3MgKz0gdXNlZDsKKwl3aGlsZSAoKnBvcyA9PSAnICcpCisJCXBvcysrOworCXVzZWQgPSBod2FkZHJfYXRvbjIocG9zLCBic3NpZCk7CisJaWYgKHVzZWQgPCAwKQorCQlyZXR1cm4gLTE7CisJcG9zICs9IHVzZWQ7CisKKwlwYXJhbSA9IG9zX3N0cnN0cihwb3MsICIgZnJlcT0iKTsKKwlpZiAocGFyYW0pIHsKKwkJcGFyYW0gKz0gNjsKKwkJZnJlcSA9IGF0b2kocGFyYW0pOworCX0KKworCXBhcmFtID0gb3Nfc3Ryc3RyKHBvcywgIiBub19jY2s9Iik7CisJaWYgKHBhcmFtKSB7CisJCXBhcmFtICs9IDg7CisJCW5vX2NjayA9IGF0b2kocGFyYW0pOworCX0KKworCXBhcmFtID0gb3Nfc3Ryc3RyKHBvcywgIiB3YWl0X3RpbWU9Iik7CisJaWYgKHBhcmFtKSB7CisJCXBhcmFtICs9IDExOworCQl3YWl0X3RpbWUgPSBhdG9pKHBhcmFtKTsKKwl9CisKKwlwYXJhbSA9IG9zX3N0cnN0cihwb3MsICIgYWN0aW9uPSIpOworCWlmIChwYXJhbSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJcGFyYW0gKz0gODsKKworCWxlbiA9IG9zX3N0cmxlbihwYXJhbSk7CisJaWYgKGxlbiAmIDEpCisJCXJldHVybiAtMTsKKwlsZW4gLz0gMjsKKworCWJ1ZiA9IG9zX21hbGxvYyhsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJaWYgKGhleHN0cjJiaW4ocGFyYW0sIGJ1ZiwgbGVuKSA8IDApIHsKKwkJb3NfZnJlZShidWYpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gb2ZmY2hhbm5lbF9zZW5kX2FjdGlvbih3cGFfcywgZnJlcSwgZGEsIHdwYV9zLT5vd25fYWRkciwgYnNzaWQsCisJCQkJICAgICBidWYsIGxlbiwgd2FpdF90aW1lLAorCQkJCSAgICAgd3Bhc19jdHJsX2lmYWNlX21nbXRfdHhfY2IsIG5vX2Njayk7CisJb3NfZnJlZShidWYpOworCXJldHVybiByZXM7Cit9CisKKworc3RhdGljIHZvaWQgd3Bhc19jdHJsX2lmYWNlX21nbXRfdHhfZG9uZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRXh0ZXJuYWwgTUdNVCBUWCAtIGRvbmUgd2FpdGluZyIpOworCW9mZmNoYW5uZWxfc2VuZF9hY3Rpb25fZG9uZSh3cGFfcyk7Cit9CisKKworc3RhdGljIGludCB3cGFzX2N0cmxfaWZhY2VfZHJpdmVyX2V2ZW50KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKK3sKKwljaGFyICpwb3MsICpwYXJhbTsKKwl1bmlvbiB3cGFfZXZlbnRfZGF0YSBldmVudDsKKwllbnVtIHdwYV9ldmVudF90eXBlIGV2OworCisJLyogPGV2ZW50IG5hbWU+IFtwYXJhbWV0ZXJzLi5dICovCisKKwl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJUZXN0aW5nIC0gZXh0ZXJuYWwgZHJpdmVyIGV2ZW50OiAlcyIsIGNtZCk7CisKKwlwb3MgPSBjbWQ7CisJcGFyYW0gPSBvc19zdHJjaHIocG9zLCAnICcpOworCWlmIChwYXJhbSkKKwkJKnBhcmFtKysgPSAnXDAnOworCisJb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7CisKKwlpZiAob3Nfc3RyY21wKGNtZCwgIklOVEVSRkFDRV9FTkFCTEVEIikgPT0gMCkgeworCQlldiA9IEVWRU5UX0lOVEVSRkFDRV9FTkFCTEVEOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgIklOVEVSRkFDRV9ESVNBQkxFRCIpID09IDApIHsKKwkJZXYgPSBFVkVOVF9JTlRFUkZBQ0VfRElTQUJMRUQ7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoY21kLCAiQVZPSURfRlJFUVVFTkNJRVMiKSA9PSAwKSB7CisJCWV2ID0gRVZFTlRfQVZPSURfRlJFUVVFTkNJRVM7CisJCWlmIChwYXJhbSA9PSBOVUxMKQorCQkJcGFyYW0gPSAiIjsKKwkJaWYgKGZyZXFfcmFuZ2VfbGlzdF9wYXJzZSgmZXZlbnQuZnJlcV9yYW5nZSwgcGFyYW0pIDwgMCkKKwkJCXJldHVybiAtMTsKKwkJd3BhX3N1cHBsaWNhbnRfZXZlbnQod3BhX3MsIGV2LCAmZXZlbnQpOworCQlvc19mcmVlKGV2ZW50LmZyZXFfcmFuZ2UucmFuZ2UpOworCQlyZXR1cm4gMDsKKwl9IGVsc2UgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJUZXN0aW5nIC0gdW5rbm93biBkcml2ZXIgZXZlbnQ6ICVzIiwKKwkJCWNtZCk7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfc3VwcGxpY2FudF9ldmVudCh3cGFfcywgZXYsICZldmVudCk7CisKKwlyZXR1cm4gMDsKK30KKworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKworCitzdGF0aWMgdm9pZCB3cGFzX2N0cmxfdmVuZG9yX2VsZW1fdXBkYXRlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJdW5zaWduZWQgaW50IGk7CisJY2hhciBidWZbMzBdOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVcGRhdGUgdmVuZG9yIGVsZW1lbnRzIik7CisKKwlmb3IgKGkgPSAwOyBpIDwgTlVNX1ZFTkRPUl9FTEVNX0ZSQU1FUzsgaSsrKSB7CisJCWlmICh3cGFfcy0+dmVuZG9yX2VsZW1baV0pIHsKKwkJCW9zX3NucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJmcmFtZVsldV0iLCBpKTsKKwkJCXdwYV9oZXhkdW1wX2J1ZihNU0dfREVCVUcsIGJ1Ziwgd3BhX3MtPnZlbmRvcl9lbGVtW2ldKTsKKwkJfQorCX0KKworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAod3BhX3MtPnBhcmVudCA9PSB3cGFfcyAmJgorCSAgICB3cGFfcy0+Z2xvYmFsLT5wMnAgJiYKKwkgICAgIXdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCkKKwkJcDJwX3NldF92ZW5kb3JfZWxlbXMod3BhX3MtPmdsb2JhbC0+cDJwLCB3cGFfcy0+dmVuZG9yX2VsZW0pOworI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KK30KKworCitzdGF0aWMgc3RydWN0IHdwYV9zdXBwbGljYW50ICoKK3dwYXNfY3RybF92ZW5kb3JfZWxlbV9pZmFjZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJICAgIGVudW0gd3BhX3ZlbmRvcl9lbGVtX2ZyYW1lIGZyYW1lKQoreworCXN3aXRjaCAoZnJhbWUpIHsKKyNpZmRlZiBDT05GSUdfUDJQCisJY2FzZSBWRU5ET1JfRUxFTV9QUk9CRV9SRVFfUDJQOgorCWNhc2UgVkVORE9SX0VMRU1fUFJPQkVfUkVTUF9QMlA6CisJY2FzZSBWRU5ET1JfRUxFTV9QUk9CRV9SRVNQX1AyUF9HTzoKKwljYXNlIFZFTkRPUl9FTEVNX0JFQUNPTl9QMlBfR086CisJY2FzZSBWRU5ET1JfRUxFTV9QMlBfUERfUkVROgorCWNhc2UgVkVORE9SX0VMRU1fUDJQX1BEX1JFU1A6CisJY2FzZSBWRU5ET1JfRUxFTV9QMlBfR09fTkVHX1JFUToKKwljYXNlIFZFTkRPUl9FTEVNX1AyUF9HT19ORUdfUkVTUDoKKwljYXNlIFZFTkRPUl9FTEVNX1AyUF9HT19ORUdfQ09ORjoKKwljYXNlIFZFTkRPUl9FTEVNX1AyUF9JTlZfUkVROgorCWNhc2UgVkVORE9SX0VMRU1fUDJQX0lOVl9SRVNQOgorCWNhc2UgVkVORE9SX0VMRU1fUDJQX0FTU09DX1JFUToKKwkJcmV0dXJuIHdwYV9zLT5wYXJlbnQ7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCWRlZmF1bHQ6CisJCXJldHVybiB3cGFfczsKKwl9Cit9CisKKworc3RhdGljIGludCB3cGFzX2N0cmxfdmVuZG9yX2VsZW1fYWRkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKK3sKKwljaGFyICpwb3MgPSBjbWQ7CisJaW50IGZyYW1lOworCXNpemVfdCBsZW47CisJc3RydWN0IHdwYWJ1ZiAqYnVmOworCXN0cnVjdCBpZWVlODAyXzExX2VsZW1zIGVsZW1zOworCisJZnJhbWUgPSBhdG9pKHBvcyk7CisJaWYgKGZyYW1lIDwgMCB8fCBmcmFtZSA+PSBOVU1fVkVORE9SX0VMRU1fRlJBTUVTKQorCQlyZXR1cm4gLTE7CisJd3BhX3MgPSB3cGFzX2N0cmxfdmVuZG9yX2VsZW1faWZhY2Uod3BhX3MsIGZyYW1lKTsKKworCXBvcyA9IG9zX3N0cmNocihwb3MsICcgJyk7CisJaWYgKHBvcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJcG9zKys7CisKKwlsZW4gPSBvc19zdHJsZW4ocG9zKTsKKwlpZiAobGVuID09IDApCisJCXJldHVybiAwOworCWlmIChsZW4gJiAxKQorCQlyZXR1cm4gLTE7CisJbGVuIC89IDI7CisKKwlidWYgPSB3cGFidWZfYWxsb2MobGVuKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCWlmIChoZXhzdHIyYmluKHBvcywgd3BhYnVmX3B1dChidWYsIGxlbiksIGxlbikgPCAwKSB7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoaWVlZTgwMl8xMV9wYXJzZV9lbGVtcyh3cGFidWZfaGVhZF91OChidWYpLCBsZW4sICZlbGVtcywgMCkgPT0KKwkgICAgUGFyc2VGYWlsZWQpIHsKKwkJd3BhYnVmX2ZyZWUoYnVmKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmICh3cGFfcy0+dmVuZG9yX2VsZW1bZnJhbWVdID09IE5VTEwpIHsKKwkJd3BhX3MtPnZlbmRvcl9lbGVtW2ZyYW1lXSA9IGJ1ZjsKKwkJd3Bhc19jdHJsX3ZlbmRvcl9lbGVtX3VwZGF0ZSh3cGFfcyk7CisJCXJldHVybiAwOworCX0KKworCWlmICh3cGFidWZfcmVzaXplKCZ3cGFfcy0+dmVuZG9yX2VsZW1bZnJhbWVdLCBsZW4pIDwgMCkgeworCQl3cGFidWZfZnJlZShidWYpOworCQlyZXR1cm4gLTE7CisJfQorCisJd3BhYnVmX3B1dF9idWYod3BhX3MtPnZlbmRvcl9lbGVtW2ZyYW1lXSwgYnVmKTsKKwl3cGFidWZfZnJlZShidWYpOworCXdwYXNfY3RybF92ZW5kb3JfZWxlbV91cGRhdGUod3BhX3MpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cGFzX2N0cmxfdmVuZG9yX2VsZW1fZ2V0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCwKKwkJCQkgICAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKK3sKKwlpbnQgZnJhbWUgPSBhdG9pKGNtZCk7CisKKwlpZiAoZnJhbWUgPCAwIHx8IGZyYW1lID49IE5VTV9WRU5ET1JfRUxFTV9GUkFNRVMpCisJCXJldHVybiAtMTsKKwl3cGFfcyA9IHdwYXNfY3RybF92ZW5kb3JfZWxlbV9pZmFjZSh3cGFfcywgZnJhbWUpOworCisJaWYgKHdwYV9zLT52ZW5kb3JfZWxlbVtmcmFtZV0gPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gd3BhX3NucHJpbnRmX2hleChidWYsIGJ1ZmxlbiwKKwkJCQl3cGFidWZfaGVhZF91OCh3cGFfcy0+dmVuZG9yX2VsZW1bZnJhbWVdKSwKKwkJCQl3cGFidWZfbGVuKHdwYV9zLT52ZW5kb3JfZWxlbVtmcmFtZV0pKTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfY3RybF92ZW5kb3JfZWxlbV9yZW1vdmUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQoreworCWNoYXIgKnBvcyA9IGNtZDsKKwlpbnQgZnJhbWU7CisJc2l6ZV90IGxlbjsKKwl1OCAqYnVmOworCXN0cnVjdCBpZWVlODAyXzExX2VsZW1zIGVsZW1zOworCXU4ICppZSwgKmVuZDsKKworCWZyYW1lID0gYXRvaShwb3MpOworCWlmIChmcmFtZSA8IDAgfHwgZnJhbWUgPj0gTlVNX1ZFTkRPUl9FTEVNX0ZSQU1FUykKKwkJcmV0dXJuIC0xOworCXdwYV9zID0gd3Bhc19jdHJsX3ZlbmRvcl9lbGVtX2lmYWNlKHdwYV9zLCBmcmFtZSk7CisKKwlwb3MgPSBvc19zdHJjaHIocG9zLCAnICcpOworCWlmIChwb3MgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXBvcysrOworCisJaWYgKCpwb3MgPT0gJyonKSB7CisJCXdwYWJ1Zl9mcmVlKHdwYV9zLT52ZW5kb3JfZWxlbVtmcmFtZV0pOworCQl3cGFfcy0+dmVuZG9yX2VsZW1bZnJhbWVdID0gTlVMTDsKKwkJd3Bhc19jdHJsX3ZlbmRvcl9lbGVtX3VwZGF0ZSh3cGFfcyk7CisJCXJldHVybiAwOworCX0KKworCWlmICh3cGFfcy0+dmVuZG9yX2VsZW1bZnJhbWVdID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCWxlbiA9IG9zX3N0cmxlbihwb3MpOworCWlmIChsZW4gPT0gMCkKKwkJcmV0dXJuIDA7CisJaWYgKGxlbiAmIDEpCisJCXJldHVybiAtMTsKKwlsZW4gLz0gMjsKKworCWJ1ZiA9IG9zX21hbGxvYyhsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJaWYgKGhleHN0cjJiaW4ocG9zLCBidWYsIGxlbikgPCAwKSB7CisJCW9zX2ZyZWUoYnVmKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChpZWVlODAyXzExX3BhcnNlX2VsZW1zKGJ1ZiwgbGVuLCAmZWxlbXMsIDApID09IFBhcnNlRmFpbGVkKSB7CisJCW9zX2ZyZWUoYnVmKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWllID0gd3BhYnVmX21oZWFkX3U4KHdwYV9zLT52ZW5kb3JfZWxlbVtmcmFtZV0pOworCWVuZCA9IGllICsgd3BhYnVmX2xlbih3cGFfcy0+dmVuZG9yX2VsZW1bZnJhbWVdKTsKKworCWZvciAoOyBpZSArIDEgPCBlbmQ7IGllICs9IDIgKyBpZVsxXSkgeworCQlpZiAoaWUgKyBsZW4gPiBlbmQpCisJCQlicmVhazsKKwkJaWYgKG9zX21lbWNtcChpZSwgYnVmLCBsZW4pICE9IDApCisJCQljb250aW51ZTsKKworCQlpZiAod3BhYnVmX2xlbih3cGFfcy0+dmVuZG9yX2VsZW1bZnJhbWVdKSA9PSBsZW4pIHsKKwkJCXdwYWJ1Zl9mcmVlKHdwYV9zLT52ZW5kb3JfZWxlbVtmcmFtZV0pOworCQkJd3BhX3MtPnZlbmRvcl9lbGVtW2ZyYW1lXSA9IE5VTEw7CisJCX0gZWxzZSB7CisJCQlvc19tZW1tb3ZlKGllLCBpZSArIGxlbiwKKwkJCQkgICB3cGFidWZfbGVuKHdwYV9zLT52ZW5kb3JfZWxlbVtmcmFtZV0pIC0gbGVuKTsKKwkJCXdwYV9zLT52ZW5kb3JfZWxlbVtmcmFtZV0tPnVzZWQgLT0gbGVuOworCQl9CisJCW9zX2ZyZWUoYnVmKTsKKwkJd3Bhc19jdHJsX3ZlbmRvcl9lbGVtX3VwZGF0ZSh3cGFfcyk7CisJCXJldHVybiAwOworCX0KKworCW9zX2ZyZWUoYnVmKTsKKworCXJldHVybiAtMTsKIH0KIAogCkBAIC01MjQxLDIyICs2NDU5LDI3IEBACiB7CiAJY2hhciAqcmVwbHk7CiAJY29uc3QgaW50IHJlcGx5X3NpemUgPSA0MDk2OwotCWludCBjdHJsX3JzcCA9IDA7CiAJaW50IHJlcGx5X2xlbjsKIAogCWlmIChvc19zdHJuY21wKGJ1ZiwgV1BBX0NUUkxfUlNQLCBvc19zdHJsZW4oV1BBX0NUUkxfUlNQKSkgPT0gMCB8fAotCSAgICBvc19zdHJuY21wKGJ1ZiwgIlNFVF9ORVRXT1JLICIsIDEyKSA9PSAwIHx8Ci0JICAgIG9zX3N0cm5jbXAoYnVmLCAiV1BTX05GQ19UQUdfUkVBRCIsIDE2KSA9PSAwIHx8Ci0JICAgIG9zX3N0cm5jbXAoYnVmLCAiTkZDX1JFUE9SVF9IQU5ET1ZFUiIsIDE5KSA9PSAwIHx8Ci0JICAgIG9zX3N0cm5jbXAoYnVmLCAiTkZDX1JYX0hBTkRPVkVSX1NFTCIsIDE5KSA9PSAwKSB7CisJICAgIG9zX3N0cm5jbXAoYnVmLCAiU0VUX05FVFdPUksgIiwgMTIpID09IDApIHsKKwkJaWYgKHdwYV9kZWJ1Z19zaG93X2tleXMpCisJCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsCisJCQkJIkNvbnRyb2wgaW50ZXJmYWNlIGNvbW1hbmQgJyVzJyIsIGJ1Zik7CisJCWVsc2UKKwkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywKKwkJCQkiQ29udHJvbCBpbnRlcmZhY2UgY29tbWFuZCAnJXMgW1JFTU9WRURdJyIsCisJCQkJb3Nfc3RybmNtcChidWYsIFdQQV9DVFJMX1JTUCwKKwkJCQkJICAgb3Nfc3RybGVuKFdQQV9DVFJMX1JTUCkpID09IDAgPworCQkJCVdQQV9DVFJMX1JTUCA6ICJTRVRfTkVUV09SSyIpOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDX1RBR19SRUFEIiwgMTYpID09IDAgfHwKKwkJICAgb3Nfc3RybmNtcChidWYsICJORkNfUkVQT1JUX0hBTkRPVkVSIiwgMTkpID09IDApIHsKIAkJd3BhX2hleGR1bXBfYXNjaWlfa2V5KE1TR19ERUJVRywgIlJYIGN0cmxfaWZhY2UiLAogCQkJCSAgICAgIChjb25zdCB1OCAqKSBidWYsIG9zX3N0cmxlbihidWYpKTsKIAl9IGVsc2UgewogCQlpbnQgbGV2ZWwgPSBNU0dfREVCVUc7CiAJCWlmIChvc19zdHJjbXAoYnVmLCAiUElORyIpID09IDApCiAJCQlsZXZlbCA9IE1TR19FWENFU1NJVkU7Ci0JCXdwYV9oZXhkdW1wX2FzY2lpKGxldmVsLCAiUlggY3RybF9pZmFjZSIsCi0JCQkJICAoY29uc3QgdTggKikgYnVmLCBvc19zdHJsZW4oYnVmKSk7CiAJCXdwYV9kYmcod3BhX3MsIGxldmVsLCAiQ29udHJvbCBpbnRlcmZhY2UgY29tbWFuZCAnJXMnIiwgYnVmKTsKIAl9CiAKQEAgLTUzMTIsNiArNjUzNSwxNCBAQAogCQkJcmVwbHlfbGVuID0gLTE7CiAJCWVsc2UKIAkJCXdwYXNfcmVxdWVzdF9jb25uZWN0aW9uKHdwYV9zKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJSRUFUVEFDSCIpID09IDApIHsKKwkJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCB8fAorCQkgICAgIXdwYV9zLT5jdXJyZW50X3NzaWQpCisJCQlyZXBseV9sZW4gPSAtMTsKKwkJZWxzZSB7CisJCQl3cGFfcy0+cmVhdHRhY2ggPSAxOworCQkJd3Bhc19yZXF1ZXN0X2Nvbm5lY3Rpb24od3BhX3MpOworCQl9CiAJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUkVDT05ORUNUIikgPT0gMCkgewogCQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfSU5URVJGQUNFX0RJU0FCTEVEKQogCQkJcmVwbHlfbGVuID0gLTE7CkBAIC01MzgwLDEyICs2NjExLDYgQEAKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiTkZDX0dFVF9IQU5ET1ZFUl9TRUwgIiwgMjEpID09IDApIHsKIAkJcmVwbHlfbGVuID0gd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfc2VsKAogCQkJd3BhX3MsIGJ1ZiArIDIxLCByZXBseSwgcmVwbHlfc2l6ZSk7Ci0JfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIk5GQ19SWF9IQU5ET1ZFUl9SRVEgIiwgMjApID09IDApIHsKLQkJcmVwbHlfbGVuID0gd3Bhc19jdHJsX25mY19yeF9oYW5kb3Zlcl9yZXEoCi0JCQl3cGFfcywgYnVmICsgMjAsIHJlcGx5LCByZXBseV9zaXplKTsKLQl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiTkZDX1JYX0hBTkRPVkVSX1NFTCAiLCAyMCkgPT0gMCkgewotCQlpZiAod3Bhc19jdHJsX25mY19yeF9oYW5kb3Zlcl9zZWwod3BhX3MsIGJ1ZiArIDIwKSkKLQkJCXJlcGx5X2xlbiA9IC0xOwogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJORkNfUkVQT1JUX0hBTkRPVkVSICIsIDIwKSA9PSAwKSB7CiAJCWlmICh3cGFzX2N0cmxfbmZjX3JlcG9ydF9oYW5kb3Zlcih3cGFfcywgYnVmICsgMjApKQogCQkJcmVwbHlfbGVuID0gLTE7CkBAIC01NDY4LDcgKzY2OTMsNyBAQAogCQlpZiAod3Bhc19wMnBfZ3JvdXBfcmVtb3ZlKHdwYV9zLCBidWYgKyAxNykpCiAJCQlyZXBseV9sZW4gPSAtMTsKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJQMlBfR1JPVVBfQUREIikgPT0gMCkgewotCQlpZiAod3Bhc19wMnBfZ3JvdXBfYWRkKHdwYV9zLCAwLCAwLCAwKSkKKwkJaWYgKHdwYXNfcDJwX2dyb3VwX2FkZCh3cGFfcywgMCwgMCwgMCwgMCkpCiAJCQlyZXBseV9sZW4gPSAtMTsKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX0dST1VQX0FERCAiLCAxNCkgPT0gMCkgewogCQlpZiAocDJwX2N0cmxfZ3JvdXBfYWRkKHdwYV9zLCBidWYgKyAxNCkpCkBAIC01NTUwLDkgKzY3NzUsMTEgQEAKIAkJCXJlcGx5X2xlbiA9IC0xOwogCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlNUT1BfRkVUQ0hfQU5RUCIpID09IDApIHsKIAkJaW50ZXJ3b3JraW5nX3N0b3BfZmV0Y2hfYW5xcCh3cGFfcyk7Ci0JfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIklOVEVSV09SS0lOR19TRUxFQ1QiLCAxOSkgPT0gMCkgewotCQlpZiAoaW50ZXJ3b3JraW5nX3NlbGVjdCh3cGFfcywgb3Nfc3Ryc3RyKGJ1ZiArIDE5LCAiYXV0byIpICE9Ci0JCQkJCU5VTEwpIDwgMCkKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJJTlRFUldPUktJTkdfU0VMRUNUIikgPT0gMCkgeworCQlpZiAoY3RybF9pbnRlcndvcmtpbmdfc2VsZWN0KHdwYV9zLCBOVUxMKSA8IDApCisJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiSU5URVJXT1JLSU5HX1NFTEVDVCAiLCAyMCkgPT0gMCkgeworCQlpZiAoY3RybF9pbnRlcndvcmtpbmdfc2VsZWN0KHdwYV9zLCBidWYgKyAyMCkgPCAwKQogCQkJcmVwbHlfbGVuID0gLTE7CiAJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIklOVEVSV09SS0lOR19DT05ORUNUICIsIDIxKSA9PSAwKSB7CiAJCWlmIChjdHJsX2ludGVyd29ya2luZ19jb25uZWN0KHdwYV9zLCBidWYgKyAyMSkgPCAwKQpAQCAtNTU3NCwxNCArNjgwMSwyOCBAQAogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJIUzIwX0dFVF9OQUlfSE9NRV9SRUFMTV9MSVNUICIsIDI5KSA9PSAwKSB7CiAJCWlmIChoczIwX2dldF9uYWlfaG9tZV9yZWFsbV9saXN0KHdwYV9zLCBidWYgKyAyOSkgPCAwKQogCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkhTMjBfSUNPTl9SRVFVRVNUICIsIDE4KSA9PSAwKSB7CisJCWlmIChoczIwX2ljb25fcmVxdWVzdCh3cGFfcywgYnVmICsgMTgpIDwgMCkKKwkJCXJlcGx5X2xlbiA9IC0xOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIkZFVENIX09TVSIpID09IDApIHsKKwkJaWYgKGhzMjBfZmV0Y2hfb3N1KHdwYV9zKSA8IDApCisJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJDQU5DRUxfRkVUQ0hfT1NVIikgPT0gMCkgeworCQloczIwX2NhbmNlbF9mZXRjaF9vc3Uod3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgV1BBX0NUUkxfUlNQLCBvc19zdHJsZW4oV1BBX0NUUkxfUlNQKSkgPT0gMCkKIAl7CiAJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2N0cmxfcnNwKAogCQkJICAgIHdwYV9zLCBidWYgKyBvc19zdHJsZW4oV1BBX0NUUkxfUlNQKSkpCiAJCQlyZXBseV9sZW4gPSAtMTsKLQkJZWxzZQotCQkJY3RybF9yc3AgPSAxOworCQllbHNlIHsKKwkJCS8qCisJCQkgKiBOb3RpZnkgcmVzcG9uc2UgZnJvbSB0aW1lb3V0IHRvIGFsbG93IHRoZSBjb250cm9sCisJCQkgKiBpbnRlcmZhY2UgcmVzcG9uc2UgdG8gYmUgc2VudCBmaXJzdC4KKwkJCSAqLworCQkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLCB3cGFzX2N0cmxfZWFwb2xfcmVzcG9uc2UsCisJCQkJCSAgICAgICB3cGFfcywgTlVMTCk7CisJCX0KIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJSRUNPTkZJR1VSRSIpID09IDApIHsKIAkJaWYgKHdwYV9zdXBwbGljYW50X3JlbG9hZF9jb25maWd1cmF0aW9uKHdwYV9zKSkKIAkJCXJlcGx5X2xlbiA9IC0xOwpAQCAtNTYwOSwzNCArNjg1MCwxMCBAQAogCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2Nhbih3cGFfcyk7CiAJCXdwYV9zdXBwbGljYW50X2RlYXV0aGVudGljYXRlKHdwYV9zLAogCQkJCQkgICAgICBXTEFOX1JFQVNPTl9ERUFVVEhfTEVBVklORyk7Ci0JfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0NBTiIpID09IDAgfHwKLQkJICAgb3Nfc3RybmNtcChidWYsICJTQ0FOICIsIDUpID09IDApIHsKLQkJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCkKLQkJCXJlcGx5X2xlbiA9IC0xOwotCQllbHNlIHsKLQkJCWlmIChvc19zdHJsZW4oYnVmKSA+IDQgJiYKLQkJCSAgICBvc19zdHJuY2FzZWNtcChidWYgKyA1LCAiVFlQRT1PTkxZIiwgOSkgPT0gMCkKLQkJCQl3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlciA9IHNjYW5fb25seV9oYW5kbGVyOwotCQkJaWYgKCF3cGFfcy0+c2NoZWRfc2Nhbm5pbmcgJiYgIXdwYV9zLT5zY2FubmluZyAmJgotCQkJICAgICgod3BhX3MtPndwYV9zdGF0ZSA8PSBXUEFfU0NBTk5JTkcpIHx8Ci0JCQkgICAgICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9DT01QTEVURUQpKSkgewotCQkJCXdwYV9zLT5ub3JtYWxfc2NhbnMgPSAwOwotCQkJCXdwYV9zLT5zY2FuX3JlcSA9IE1BTlVBTF9TQ0FOX1JFUTsKLQkJCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7Ci0JCQl9IGVsc2UgaWYgKHdwYV9zLT5zY2hlZF9zY2FubmluZykgewotCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU3RvcCBvbmdvaW5nICIKLQkJCQkJICAgInNjaGVkX3NjYW4gdG8gYWxsb3cgcmVxdWVzdGVkICIKLQkJCQkJICAgImZ1bGwgc2NhbiB0byBwcm9jZWVkIik7Ci0JCQkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjaGVkX3NjYW4od3BhX3MpOwotCQkJCXdwYV9zLT5zY2FuX3JlcSA9IE1BTlVBTF9TQ0FOX1JFUTsKLQkJCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7Ci0JCQl9IGVsc2UgewotCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT25nb2luZyBzY2FuIGFjdGlvbiAtICIKLQkJCQkJICAgInJlamVjdCBuZXcgcmVxdWVzdCIpOwotCQkJCXJlcGx5X2xlbiA9IG9zX3NucHJpbnRmKHJlcGx5LCByZXBseV9zaXplLAotCQkJCQkJCSJGQUlMLUJVU1lcbiIpOwotCQkJfQotCQl9CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0NBTiIpID09IDApIHsKKwkJd3Bhc19jdHJsX3NjYW4od3BhX3MsIE5VTEwsIHJlcGx5LCByZXBseV9zaXplLCAmcmVwbHlfbGVuKTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU0NBTiAiLCA1KSA9PSAwKSB7CisJCXdwYXNfY3RybF9zY2FuKHdwYV9zLCBidWYgKyA1LCByZXBseSwgcmVwbHlfc2l6ZSwgJnJlcGx5X2xlbik7CiAJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0NBTl9SRVNVTFRTIikgPT0gMCkgewogCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NjYW5fcmVzdWx0cygKIAkJCXdwYV9zLCByZXBseSwgcmVwbHlfc2l6ZSk7CkBAIC01NjYxLDYgKzY4NzgsOSBAQAogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJHRVRfTkVUV09SSyAiLCAxMikgPT0gMCkgewogCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2dldF9uZXR3b3JrKAogCQkJd3BhX3MsIGJ1ZiArIDEyLCByZXBseSwgcmVwbHlfc2l6ZSk7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkRVUF9ORVRXT1JLICIsIDEyKSA9PSAwKSB7CisJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2R1cF9uZXR3b3JrKHdwYV9zLCBidWYgKyAxMikpCisJCQlyZXBseV9sZW4gPSAtMTsKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJMSVNUX0NSRURTIikgPT0gMCkgewogCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2xpc3RfY3JlZHMoCiAJCQl3cGFfcywgcmVwbHksIHJlcGx5X3NpemUpOwpAQCAtNTY3Myw2ICs2ODkzLDEwIEBACiAJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNFVF9DUkVEICIsIDkpID09IDApIHsKIAkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2V0X2NyZWQod3BhX3MsIGJ1ZiArIDkpKQogCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkdFVF9DUkVEICIsIDkpID09IDApIHsKKwkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9nZXRfY3JlZCh3cGFfcywgYnVmICsgOSwKKwkJCQkJCQkgICAgICAgcmVwbHksCisJCQkJCQkJICAgICAgIHJlcGx5X3NpemUpOwogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX1dSSVRFCiAJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0FWRV9DT05GSUciKSA9PSAwKSB7CiAJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NhdmVfY29uZmlnKHdwYV9zKSkKQEAgLTU3MTEsMTMgKzY5MzUsMTggQEAKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiRElTQVNTT0NJQVRFICIsIDEzKSA9PSAwKSB7CiAJCWlmIChhcF9jdHJsX2lmYWNlX3N0YV9kaXNhc3NvY2lhdGUod3BhX3MsIGJ1ZiArIDEzKSkKIAkJCXJlcGx5X2xlbiA9IC0xOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJDSEFOX1NXSVRDSCAiLCAxMikgPT0gMCkgeworCQlpZiAoYXBfY3RybF9pZmFjZV9jaGFuc3dpdGNoKHdwYV9zLCBidWYgKyAxMikpCisJCQlyZXBseV9sZW4gPSAtMTsKICNlbmRpZiAvKiBDT05GSUdfQVAgKi8KIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJTVVNQRU5EIikgPT0gMCkgewogCQl3cGFzX25vdGlmeV9zdXNwZW5kKHdwYV9zLT5nbG9iYWwpOwogCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlJFU1VNRSIpID09IDApIHsKIAkJd3Bhc19ub3RpZnlfcmVzdW1lKHdwYV9zLT5nbG9iYWwpOworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJEUk9QX1NBIikgPT0gMCkgewogCQl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2Ryb3Bfc2Eod3BhX3MpOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUk9BTSAiLCA1KSA9PSAwKSB7CiAJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3JvYW0od3BhX3MsIGJ1ZiArIDUpKQogCQkJcmVwbHlfbGVuID0gLTE7CkBAIC01NzYwLDcgKzY5ODksMTAgQEAKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiRFJJVkVSICIsIDcpID09IDApIHsKIAkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfZHJpdmVyX2NtZCh3cGFfcywgYnVmICsgNywgcmVwbHksCiAJCQkJCQkgICAgICByZXBseV9zaXplKTsKLSNlbmRpZgorI2VuZGlmIC8qIEFORFJPSUQgKi8KKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiVkVORE9SICIsIDcpID09IDApIHsKKwkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfdmVuZG9yX2NtZCh3cGFfcywgYnVmICsgNywgcmVwbHksCisJCQkJCQkgICAgICByZXBseV9zaXplKTsKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJSRUFVVEhFTlRJQ0FURSIpID09IDApIHsKIAkJcG1rc2FfY2FjaGVfY2xlYXJfY3VycmVudCh3cGFfcy0+d3BhKTsKIAkJZWFwb2xfc21fcmVxdWVzdF9yZWF1dGgod3BhX3MtPmVhcG9sKTsKQEAgLTU3NzQsNiArNzAwNiwyOCBAQAogI2VuZGlmIC8qIENPTkZJR19XTk0gKi8KIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJGTFVTSCIpID09IDApIHsKIAkJd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9mbHVzaCh3cGFfcyk7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlJBRElPX1dPUksgIiwgMTEpID09IDApIHsKKwkJcmVwbHlfbGVuID0gd3Bhc19jdHJsX3JhZGlvX3dvcmsod3BhX3MsIGJ1ZiArIDExLCByZXBseSwKKwkJCQkJCSByZXBseV9zaXplKTsKKyNpZmRlZiBDT05GSUdfVEVTVElOR19PUFRJT05TCisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIk1HTVRfVFggIiwgOCkgPT0gMCkgeworCQlpZiAod3Bhc19jdHJsX2lmYWNlX21nbXRfdHgod3BhX3MsIGJ1ZiArIDgpIDwgMCkKKwkJCXJlcGx5X2xlbiA9IC0xOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIk1HTVRfVFhfRE9ORSIpID09IDApIHsKKwkJd3Bhc19jdHJsX2lmYWNlX21nbXRfdHhfZG9uZSh3cGFfcyk7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkRSSVZFUl9FVkVOVCAiLCAxMykgPT0gMCkgeworCQlpZiAod3Bhc19jdHJsX2lmYWNlX2RyaXZlcl9ldmVudCh3cGFfcywgYnVmICsgMTMpIDwgMCkKKwkJCXJlcGx5X2xlbiA9IC0xOworI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX09QVElPTlMgKi8KKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiVkVORE9SX0VMRU1fQUREICIsIDE2KSA9PSAwKSB7CisJCWlmICh3cGFzX2N0cmxfdmVuZG9yX2VsZW1fYWRkKHdwYV9zLCBidWYgKyAxNikgPCAwKQorCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlZFTkRPUl9FTEVNX0dFVCAiLCAxNikgPT0gMCkgeworCQlyZXBseV9sZW4gPSB3cGFzX2N0cmxfdmVuZG9yX2VsZW1fZ2V0KHdwYV9zLCBidWYgKyAxNiwgcmVwbHksCisJCQkJCQkgICAgICByZXBseV9zaXplKTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiVkVORE9SX0VMRU1fUkVNT1ZFICIsIDE5KSA9PSAwKSB7CisJCWlmICh3cGFzX2N0cmxfdmVuZG9yX2VsZW1fcmVtb3ZlKHdwYV9zLCBidWYgKyAxOSkgPCAwKQorCQkJcmVwbHlfbGVuID0gLTE7CiAJfSBlbHNlIHsKIAkJb3NfbWVtY3B5KHJlcGx5LCAiVU5LTk9XTiBDT01NQU5EXG4iLCAxNik7CiAJCXJlcGx5X2xlbiA9IDE2OwpAQCAtNTc4NCw5ICs3MDM4LDYgQEAKIAkJcmVwbHlfbGVuID0gNTsKIAl9CiAKLQlpZiAoY3RybF9yc3ApCi0JCWVhcG9sX3NtX25vdGlmeV9jdHJsX3Jlc3BvbnNlKHdwYV9zLT5lYXBvbCk7Ci0KIAkqcmVzcF9sZW4gPSByZXBseV9sZW47CiAJcmV0dXJuIHJlcGx5OwogfQpAQCAtNTk5MywxMCArNzI0NCw3IEBACiB7CiAjaWZkZWYgQ09ORklHX1AyUAogCXN0YXRpYyBjb25zdCBjaGFyICogY21kW10gPSB7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKIAkJIkxJU1RfTkVUV09SS1MiLAotCQkiU0FWRV9DT05GSUciLAotI2VuZGlmCiAJCSJQMlBfRklORCIsCiAJCSJQMlBfU1RPUF9GSU5EIiwKIAkJIlAyUF9MSVNURU4iLApAQCAtNjAxMSwxMiArNzI1OSwxMSBAQAogCQlOVUxMCiAJfTsKIAlzdGF0aWMgY29uc3QgY2hhciAqIHByZWZpeFtdID0gewotI2lmZGVmIEFORFJPSURfUDJQCisjaWZkZWYgQU5EUk9JRAogCQkiRFJJVkVSICIsCisjZW5kaWYgLyogQU5EUk9JRCAqLwogCQkiR0VUX05FVFdPUksgIiwKIAkJIlJFTU9WRV9ORVRXT1JLICIsCi0JCSJTRVQgIiwKLSNlbmRpZgogCQkiUDJQX0ZJTkQgIiwKIAkJIlAyUF9DT05ORUNUICIsCiAJCSJQMlBfTElTVEVOICIsCkBAIC02MDM3LDYgKzcyODQsOSBAQAogCQkiUDJQX1BSRVNFTkNFX1JFUSAiLAogCQkiUDJQX0VYVF9MSVNURU4gIiwKIAkJIlAyUF9SRU1PVkVfQ0xJRU5UICIsCisJCSJORkNfR0VUX0hBTkRPVkVSX1NFTCAiLAorCQkiTkZDX0dFVF9IQU5ET1ZFUl9SRVEgIiwKKwkJIk5GQ19SRVBPUlRfSEFORE9WRVIgIiwKIAkJTlVMTAogCX07CiAJaW50IGZvdW5kID0gMDsKQEAgLTYxMTMsNiArNzM2Myw5IEBACiAJfQogI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KIAorCS8qIFJlc3RvcmUgY21kIHRvIGl0cyBvcmlnaW5hbCB2YWx1ZSB0byBhbGxvdyByZWRpcmVjdGlvbiAqLworCXZhbHVlWy0xXSA9ICcgJzsKKwogCXJldHVybiAtMTsKIH0KIApAQCAtNjEyMCw3ICs3MzczLDcgQEAKICNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19XUklURQogc3RhdGljIGludCB3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX3NhdmVfY29uZmlnKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwpCiB7Ci0JaW50IHJldCA9IDA7CisJaW50IHJldCA9IDAsIHNhdmVkID0gMDsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zOwogCiAJZm9yICh3cGFfcyA9IGdsb2JhbC0+aWZhY2VzOyB3cGFfczsgd3BhX3MgPSB3cGFfcy0+bmV4dCkgewpAQCAtNjEzNCw5ICs3Mzg3LDE2IEBACiAJCQlyZXQgPSAxOwogCQl9IGVsc2UgewogCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogU0FWRV9DT05GSUcgLSBDb25maWd1cmF0aW9uIHVwZGF0ZWQiKTsKKwkJCXNhdmVkKys7CiAJCX0KIAl9CiAKKwlpZiAoIXNhdmVkICYmICFyZXQpIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAorCQkJIkNUUkxfSUZBQ0U6IFNBVkVfQ09ORklHIC0gTm8gY29uZmlndXJhdGlvbiBmaWxlcyBjb3VsZCBiZSB1cGRhdGVkIik7CisJCXJldCA9IDE7CisJfQorCiAJcmV0dXJuIHJldDsKIH0KICNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX1dSSVRFICovCkBAIC02MjQ5LDggKzc1MDksMTkgQEAKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJSRVNVTUUiKSA9PSAwKSB7CiAJCXdwYXNfbm90aWZ5X3Jlc3VtZShnbG9iYWwpOwogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJTRVQgIiwgNCkgPT0gMCkgewotCQlpZiAod3Bhc19nbG9iYWxfY3RybF9pZmFjZV9zZXQoZ2xvYmFsLCBidWYgKyA0KSkKKwkJaWYgKHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2Vfc2V0KGdsb2JhbCwgYnVmICsgNCkpIHsKKyNpZmRlZiBDT05GSUdfUDJQCisJCQlpZiAoZ2xvYmFsLT5wMnBfaW5pdF93cGFfcykgeworCQkJCW9zX2ZyZWUocmVwbHkpOworCQkJCS8qIENoZWNrIGlmIFAyUCByZWRpcmVjdGlvbiB3b3VsZCB3b3JrIGZvciB0aGlzCisJCQkJICogY29tbWFuZC4gKi8KKwkJCQlyZXR1cm4gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9wcm9jZXNzKAorCQkJCQlnbG9iYWwtPnAycF9pbml0X3dwYV9zLAorCQkJCQlidWYsIHJlc3BfbGVuKTsKKwkJCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJCQlyZXBseV9sZW4gPSAtMTsKKwkJfQogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX1dSSVRFCiAJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0FWRV9DT05GSUciKSA9PSAwKSB7CiAJCWlmICh3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX3NhdmVfY29uZmlnKGdsb2JhbCkpCkBAIC02MjU5LDYgKzc1MzAsMTIgQEAKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJTVEFUVVMiKSA9PSAwKSB7CiAJCXJlcGx5X2xlbiA9IHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2Vfc3RhdHVzKGdsb2JhbCwgcmVwbHksCiAJCQkJCQkJICByZXBseV9zaXplKTsKKyNpZmRlZiBDT05GSUdfTU9EVUxFX1RFU1RTCisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiTU9EVUxFX1RFU1RTIikgPT0gMCkgeworCQlpbnQgd3Bhc19tb2R1bGVfdGVzdHModm9pZCk7CisJCWlmICh3cGFzX21vZHVsZV90ZXN0cygpIDwgMCkKKwkJCXJlcGx5X2xlbiA9IC0xOworI2VuZGlmIC8qIENPTkZJR19NT0RVTEVfVEVTVFMgKi8KIAl9IGVsc2UgewogCQlvc19tZW1jcHkocmVwbHksICJVTktOT1dOIENPTU1BTkRcbiIsIDE2KTsKIAkJcmVwbHlfbGVuID0gMTY7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlLmggYi93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlLmgKaW5kZXggYTMyOWVmMy4uZDU0Y2MwNyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvY3RybF9pZmFjZS5oCisrKyBiL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2UuaApAQCAtMzIsNyArMzIsNyBAQAogCQkJCQkgY2hhciAqYnVmLCBzaXplX3QgKnJlc3BfbGVuKTsKIAogLyoqCi0gKiB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3Byb2Nlc3MgLSBQcm9jZXNzIGdsb2JhbCBjdHJsX2lmYWNlIGNvbW1hbmQKKyAqIHdwYV9zdXBwbGljYW50X2dsb2JhbF9jdHJsX2lmYWNlX3Byb2Nlc3MgLSBQcm9jZXNzIGdsb2JhbCBjdHJsX2lmYWNlIGNvbW1hbmQKICAqIEBnbG9iYWw6IFBvaW50ZXIgdG8gZ2xvYmFsIGRhdGEgZnJvbSB3cGFfc3VwcGxpY2FudF9pbml0KCkKICAqIEBidWY6IFJlY2VpdmVkIGNvbW1hbmQgYnVmZmVyIChudWwgdGVybWluYXRlZCBzdHJpbmcpCiAgKiBAcmVzcF9sZW46IFZhcmlhYmxlIHRvIGJlIHNldCB0byB0aGUgcmVzcG9uc2UgbGVuZ3RoCkBAIC0xMTMsNiArMTEzLDggQEAKIHZvaWQgd3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2N0cmxfaWZhY2VfZGVpbml0KAogCXN0cnVjdCBjdHJsX2lmYWNlX2dsb2JhbF9wcml2ICpwcml2KTsKIAordm9pZCB3cGFzX2N0cmxfcmFkaW9fd29ya19mbHVzaChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKKwogI2Vsc2UgLyogQ09ORklHX0NUUkxfSUZBQ0UgKi8KIAogc3RhdGljIGlubGluZSBzdHJ1Y3QgY3RybF9pZmFjZV9wcml2ICoKQEAgLTE0OCw2ICsxNTAsMTAgQEAKIHsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIHdwYXNfY3RybF9yYWRpb193b3JrX2ZsdXNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7Cit9CisKICNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRSAqLwogCiAjZW5kaWYgLyogQ1RSTF9JRkFDRV9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlX3VkcC5jIGIvd3BhX3N1cHBsaWNhbnQvY3RybF9pZmFjZV91ZHAuYwppbmRleCA4YzA5YmExLi45ZDA2NzRkIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlX3VkcC5jCisrKyBiL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2VfdWRwLmMKQEAgLTMwLDcgKzMwLDExIEBACiAgKi8KIHN0cnVjdCB3cGFfY3RybF9kc3QgewogCXN0cnVjdCB3cGFfY3RybF9kc3QgKm5leHQ7CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwlzdHJ1Y3Qgc29ja2FkZHJfaW42IGFkZHI7CisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCXN0cnVjdCBzb2NrYWRkcl9pbiBhZGRyOworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJc29ja2xlbl90IGFkZHJsZW47CiAJaW50IGRlYnVnX2xldmVsOwogCWludCBlcnJvcnM7CkBAIC01MSwzOCArNTUsNjggQEAKIAogCiBzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYXR0YWNoKHN0cnVjdCBjdHJsX2lmYWNlX3ByaXYgKnByaXYsCisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwkJCQkJICAgIHN0cnVjdCBzb2NrYWRkcl9pbjYgKmZyb20sCisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCQkJCQkgICAgc3RydWN0IHNvY2thZGRyX2luICpmcm9tLAorI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJCQkJCSAgICBzb2NrbGVuX3QgZnJvbWxlbikKIHsKIAlzdHJ1Y3Qgd3BhX2N0cmxfZHN0ICpkc3Q7CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwljaGFyIGFkZHJbSU5FVDZfQUREUlNUUkxFTl07CisjZW5kaWYgLyogQ09ORklHX1VEUF9JUFY2ICovCiAKIAlkc3QgPSBvc196YWxsb2Moc2l6ZW9mKCpkc3QpKTsKIAlpZiAoZHN0ID09IE5VTEwpCiAJCXJldHVybiAtMTsKLQlvc19tZW1jcHkoJmRzdC0+YWRkciwgZnJvbSwgc2l6ZW9mKHN0cnVjdCBzb2NrYWRkcl9pbikpOworCW9zX21lbWNweSgmZHN0LT5hZGRyLCBmcm9tLCBzaXplb2YoKmZyb20pKTsKIAlkc3QtPmFkZHJsZW4gPSBmcm9tbGVuOwogCWRzdC0+ZGVidWdfbGV2ZWwgPSBNU0dfSU5GTzsKIAlkc3QtPm5leHQgPSBwcml2LT5jdHJsX2RzdDsKIAlwcml2LT5jdHJsX2RzdCA9IGRzdDsKKyNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNgorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBtb25pdG9yIGF0dGFjaGVkICVzOiVkIiwKKwkJICAgaW5ldF9udG9wKEFGX0lORVQ2LCAmZnJvbS0+c2luNl9hZGRyLCBhZGRyLCBzaXplb2YoKmZyb20pKSwKKwkJICAgbnRvaHMoZnJvbS0+c2luNl9wb3J0KSk7CisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBtb25pdG9yIGF0dGFjaGVkICVzOiVkIiwKIAkJICAgaW5ldF9udG9hKGZyb20tPnNpbl9hZGRyKSwgbnRvaHMoZnJvbS0+c2luX3BvcnQpKTsKKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCXJldHVybiAwOwogfQogCiAKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9kZXRhY2goc3RydWN0IGN0cmxfaWZhY2VfcHJpdiAqcHJpdiwKKyNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNgorCQkJCQkgICAgc3RydWN0IHNvY2thZGRyX2luNiAqZnJvbSwKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJCQkJCSAgICBzdHJ1Y3Qgc29ja2FkZHJfaW4gKmZyb20sCisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAkJCQkJICAgIHNvY2tsZW5fdCBmcm9tbGVuKQogewogCXN0cnVjdCB3cGFfY3RybF9kc3QgKmRzdCwgKnByZXYgPSBOVUxMOworI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJY2hhciBhZGRyW0lORVQ2X0FERFJTVFJMRU5dOworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAKIAlkc3QgPSBwcml2LT5jdHJsX2RzdDsKIAl3aGlsZSAoZHN0KSB7CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwkJaWYgKGZyb20tPnNpbjZfcG9ydCA9PSBkc3QtPmFkZHIuc2luNl9wb3J0ICYmCisJCSAgICAhb3NfbWVtY21wKCZmcm9tLT5zaW42X2FkZHIsICZkc3QtPmFkZHIuc2luNl9hZGRyLAorCQkJICAgICAgIHNpemVvZihmcm9tLT5zaW42X2FkZHIpKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIG1vbml0b3IgZGV0YWNoZWQgJXM6JWQiLAorCQkJCSAgIGluZXRfbnRvcChBRl9JTkVUNiwgJmZyb20tPnNpbjZfYWRkciwgYWRkciwKKwkJCQkJICAgICBzaXplb2YoKmZyb20pKSwKKwkJCQkgICBudG9ocyhmcm9tLT5zaW42X3BvcnQpKTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJCWlmIChmcm9tLT5zaW5fYWRkci5zX2FkZHIgPT0gZHN0LT5hZGRyLnNpbl9hZGRyLnNfYWRkciAmJgogCQkgICAgZnJvbS0+c2luX3BvcnQgPT0gZHN0LT5hZGRyLnNpbl9wb3J0KSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgbW9uaXRvciBkZXRhY2hlZCAiCiAJCQkJICAgIiVzOiVkIiwgaW5ldF9udG9hKGZyb20tPnNpbl9hZGRyKSwKIAkJCQkgICBudG9ocyhmcm9tLT5zaW5fcG9ydCkpOworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJCQlpZiAocHJldiA9PSBOVUxMKQogCQkJCXByaXYtPmN0cmxfZHN0ID0gZHN0LT5uZXh0OwogCQkJZWxzZQpAQCAtOTgsMjEgKzEzMiwzOCBAQAogCiAKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9sZXZlbChzdHJ1Y3QgY3RybF9pZmFjZV9wcml2ICpwcml2LAorI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJCQkJCSAgIHN0cnVjdCBzb2NrYWRkcl9pbjYgKmZyb20sCisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCQkJCQkgICBzdHJ1Y3Qgc29ja2FkZHJfaW4gKmZyb20sCisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAkJCQkJICAgc29ja2xlbl90IGZyb21sZW4sCiAJCQkJCSAgIGNoYXIgKmxldmVsKQogewogCXN0cnVjdCB3cGFfY3RybF9kc3QgKmRzdDsKKyNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNgorCWNoYXIgYWRkcltJTkVUNl9BRERSU1RSTEVOXTsKKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIExFVkVMICVzIiwgbGV2ZWwpOwogCiAJZHN0ID0gcHJpdi0+Y3RybF9kc3Q7CiAJd2hpbGUgKGRzdCkgeworI2lmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJCWlmIChmcm9tLT5zaW42X3BvcnQgPT0gZHN0LT5hZGRyLnNpbjZfcG9ydCAmJgorCQkgICAgIW9zX21lbWNtcCgmZnJvbS0+c2luNl9hZGRyLCAmZHN0LT5hZGRyLnNpbjZfYWRkciwKKwkJCSAgICAgICBzaXplb2YoZnJvbS0+c2luNl9hZGRyKSkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBjaGFuZ2VkIG1vbml0b3IgbGV2ZWwgJXM6JWQiLAorCQkJCSAgIGluZXRfbnRvcChBRl9JTkVUNiwgJmZyb20tPnNpbjZfYWRkciwgYWRkciwKKwkJCQkJICAgICBzaXplb2YoKmZyb20pKSwKKwkJCQkgICBudG9ocyhmcm9tLT5zaW42X3BvcnQpKTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJCWlmIChmcm9tLT5zaW5fYWRkci5zX2FkZHIgPT0gZHN0LT5hZGRyLnNpbl9hZGRyLnNfYWRkciAmJgogCQkgICAgZnJvbS0+c2luX3BvcnQgPT0gZHN0LT5hZGRyLnNpbl9wb3J0KSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgY2hhbmdlZCBtb25pdG9yICIKIAkJCQkgICAibGV2ZWwgJXM6JWQiLCBpbmV0X250b2EoZnJvbS0+c2luX2FkZHIpLAogCQkJCSAgIG50b2hzKGZyb20tPnNpbl9wb3J0KSk7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAkJCWRzdC0+ZGVidWdfbGV2ZWwgPSBhdG9pKGxldmVsKTsKIAkJCXJldHVybiAwOwogCQl9CkBAIC0xNTAsNyArMjAxLDE0IEBACiAJc3RydWN0IGN0cmxfaWZhY2VfcHJpdiAqcHJpdiA9IHNvY2tfY3R4OwogCWNoYXIgYnVmWzI1Nl0sICpwb3M7CiAJaW50IHJlczsKKyNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNgorCXN0cnVjdCBzb2NrYWRkcl9pbjYgZnJvbTsKKyNpZm5kZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX1JFTU9URQorCWNoYXIgYWRkcltJTkVUNl9BRERSU1RSTEVOXTsKKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfUkVNT1RFICovCisjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCXN0cnVjdCBzb2NrYWRkcl9pbiBmcm9tOworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJc29ja2xlbl90IGZyb21sZW4gPSBzaXplb2YoZnJvbSk7CiAJY2hhciAqcmVwbHkgPSBOVUxMOwogCXNpemVfdCByZXBseV9sZW4gPSAwOwpAQCAtMTY1LDYgKzIyMywxMyBAQAogCX0KIAogI2lmbmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfUkVNT1RFCisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwlpbmV0X250b3AoQUZfSU5FVDYsICZmcm9tLnNpbjZfYWRkciwgYWRkciwgc2l6ZW9mKGZyb20pKTsKKwlpZiAob3Nfc3RyY21wKGFkZHIsICI6OjEiKSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkw6IERyb3AgcGFja2V0IGZyb20gdW5leHBlY3RlZCBzb3VyY2UgJXMiLAorCQkJICAgYWRkcik7CisJfQorI2Vsc2UgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAlpZiAoZnJvbS5zaW5fYWRkci5zX2FkZHIgIT0gaHRvbmwoKDEyNyA8PCAyNCkgfCAxKSkgewogCQkvKgogCQkgKiBUaGUgT1MgbmV0d29ya2luZyBzdGFjayBpcyBleHBlY3RlZCB0byBkcm9wIHRoaXMga2luZCBvZgpAQCAtMTc2LDYgKzI0MSw3IEBACiAJCQkgICAic291cmNlICVzIiwgaW5ldF9udG9hKGZyb20uc2luX2FkZHIpKTsKIAkJcmV0dXJuOwogCX0KKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUgKi8KIAogCWJ1ZltyZXNdID0gJ1wwJzsKQEAgLTI2OSw4ICszMzUsMTQgQEAKIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCXN0cnVjdCBjdHJsX2lmYWNlX3ByaXYgKnByaXY7Ci0Jc3RydWN0IHNvY2thZGRyX2luIGFkZHI7CiAJaW50IHBvcnQgPSBXUEFfQ1RSTF9JRkFDRV9QT1JUOworI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJc3RydWN0IHNvY2thZGRyX2luNiBhZGRyOworCWludCBkb21haW4gPSBQRl9JTkVUNjsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCisJc3RydWN0IHNvY2thZGRyX2luIGFkZHI7CisJaW50IGRvbWFpbiA9IFBGX0lORVQ7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAogCXByaXYgPSBvc196YWxsb2Moc2l6ZW9mKCpwcml2KSk7CiAJaWYgKHByaXYgPT0gTlVMTCkKQEAgLTI4MiwyMSArMzU0LDM0IEBACiAJaWYgKHdwYV9zLT5jb25mLT5jdHJsX2ludGVyZmFjZSA9PSBOVUxMKQogCQlyZXR1cm4gcHJpdjsKIAotCXByaXYtPnNvY2sgPSBzb2NrZXQoUEZfSU5FVCwgU09DS19ER1JBTSwgMCk7CisJcHJpdi0+c29jayA9IHNvY2tldChkb21haW4sIFNPQ0tfREdSQU0sIDApOwogCWlmIChwcml2LT5zb2NrIDwgMCkgewogCQlwZXJyb3IoInNvY2tldChQRl9JTkVUKSIpOwogCQlnb3RvIGZhaWw7CiAJfQogCiAJb3NfbWVtc2V0KCZhZGRyLCAwLCBzaXplb2YoYWRkcikpOworI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJYWRkci5zaW42X2ZhbWlseSA9IEFGX0lORVQ2OworI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUKKwlhZGRyLnNpbjZfYWRkciA9IGluNmFkZHJfYW55OworI2Vsc2UgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX1JFTU9URSAqLworCWluZXRfcHRvbihBRl9JTkVUNiwgIjo6MSIsICZhZGRyLnNpbjZfYWRkcik7CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX1JFTU9URSAqLworI2Vsc2UgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAlhZGRyLnNpbl9mYW1pbHkgPSBBRl9JTkVUOwogI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUKIAlhZGRyLnNpbl9hZGRyLnNfYWRkciA9IElOQUREUl9BTlk7CiAjZWxzZSAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfUkVNT1RFICovCiAJYWRkci5zaW5fYWRkci5zX2FkZHIgPSBodG9ubCgoMTI3IDw8IDI0KSB8IDEpOwogI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9SRU1PVEUgKi8KKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogdHJ5X2FnYWluOgorI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2CisJYWRkci5zaW42X3BvcnQgPSBodG9ucyhwb3J0KTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJYWRkci5zaW5fcG9ydCA9IGh0b25zKHBvcnQpOworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJaWYgKGJpbmQocHJpdi0+c29jaywgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApIHsKIAkJcG9ydC0tOwogCQlpZiAoKFdQQV9DVFJMX0lGQUNFX1BPUlQgLSBwb3J0KSA8IFdQQV9DVFJMX0lGQUNFX1BPUlRfTElNSVQpCkBAIC0zNjIsNiArNDQ3LDkgQEAKIAlpbnQgaWR4OwogCWNoYXIgKnNidWY7CiAJaW50IGxsZW47CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwljaGFyIGFkZHJbSU5FVDZfQUREUlNUUkxFTl07CisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYgKi8KIAogCWRzdCA9IHByaXYtPmN0cmxfZHN0OwogCWlmIChwcml2LT5zb2NrIDwgMCB8fCBkc3QgPT0gTlVMTCkKQEAgLTM4MSw5ICs0NjksMTYgQEAKIAl3aGlsZSAoZHN0KSB7CiAJCW5leHQgPSBkc3QtPm5leHQ7CiAJCWlmIChsZXZlbCA+PSBkc3QtPmRlYnVnX2xldmVsKSB7CisjaWZkZWYgQ09ORklHX0NUUkxfSUZBQ0VfVURQX0lQVjYKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBtb25pdG9yIHNlbmQgJXM6JWQiLAorCQkJCSAgIGluZXRfbnRvcChBRl9JTkVUNiwgJmRzdC0+YWRkci5zaW42X2FkZHIsCisJCQkJCSAgICAgYWRkciwgc2l6ZW9mKGRzdC0+YWRkcikpLAorCQkJCSAgIG50b2hzKGRzdC0+YWRkci5zaW42X3BvcnQpKTsKKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX1VEUF9JUFY2ICovCiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgbW9uaXRvciBzZW5kICVzOiVkIiwKIAkJCQkgICBpbmV0X250b2EoZHN0LT5hZGRyLnNpbl9hZGRyKSwKIAkJCQkgICBudG9ocyhkc3QtPmFkZHIuc2luX3BvcnQpKTsKKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRV9VRFBfSVBWNiAqLwogCQkJaWYgKHNlbmR0byhwcml2LT5zb2NrLCBzYnVmLCBsbGVuICsgbGVuLCAwLAogCQkJCSAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmRzdC0+YWRkciwKIAkJCQkgICBzaXplb2YoZHN0LT5hZGRyKSkgPCAwKSB7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlX3VuaXguYyBiL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2VfdW5peC5jCmluZGV4IGUzNWQyYzMuLjQwMDgyZTIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2VfdW5peC5jCisrKyBiL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2VfdW5peC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC8gVU5JWCBkb21haW4gc29ja2V0IC1iYXNlZCBjb250cm9sIGludGVyZmFjZQotICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNTcsMTAgKzU3LDE3IEBACiB9OwogCiAKLXN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2VuZChjb25zdCBjaGFyICppZm5hbWUsIGludCBzb2NrLAorc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zZW5kKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgIGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50IHNvY2ssCiAJCQkJCSAgIHN0cnVjdCBkbF9saXN0ICpjdHJsX2RzdCwKIAkJCQkJICAgaW50IGxldmVsLCBjb25zdCBjaGFyICpidWYsCi0JCQkJCSAgIHNpemVfdCBsZW4pOworCQkJCQkgICBzaXplX3QgbGVuLAorCQkJCQkgICBzdHJ1Y3QgY3RybF9pZmFjZV9wcml2ICpwcml2LAorCQkJCQkgICBzdHJ1Y3QgY3RybF9pZmFjZV9nbG9iYWxfcHJpdiAqZ3ApOworc3RhdGljIGludCB3cGFzX2N0cmxfaWZhY2VfcmVpbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICBzdHJ1Y3QgY3RybF9pZmFjZV9wcml2ICpwcml2KTsKK3N0YXRpYyBpbnQgd3Bhc19jdHJsX2lmYWNlX2dsb2JhbF9yZWluaXQoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwKKwkJCQkJIHN0cnVjdCBjdHJsX2lmYWNlX2dsb2JhbF9wcml2ICpwcml2KTsKIAogCiBzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYXR0YWNoKHN0cnVjdCBkbF9saXN0ICpjdHJsX2RzdCwKQEAgLTY4LDYgKzc1LDcgQEAKIAkJCQkJICAgIHNvY2tsZW5fdCBmcm9tbGVuKQogewogCXN0cnVjdCB3cGFfY3RybF9kc3QgKmRzdDsKKwljaGFyIGFkZHJfdHh0WzIwMF07CiAKIAlkc3QgPSBvc196YWxsb2Moc2l6ZW9mKCpkc3QpKTsKIAlpZiAoZHN0ID09IE5VTEwpCkBAIC03Niw5ICs4NCwxMCBAQAogCWRzdC0+YWRkcmxlbiA9IGZyb21sZW47CiAJZHN0LT5kZWJ1Z19sZXZlbCA9IE1TR19JTkZPOwogCWRsX2xpc3RfYWRkKGN0cmxfZHN0LCAmZHN0LT5saXN0KTsKLQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJDVFJMX0lGQUNFIG1vbml0b3IgYXR0YWNoZWQiLAotCQkgICAgKHU4ICopIGZyb20tPnN1bl9wYXRoLAotCQkgICAgZnJvbWxlbiAtIG9mZnNldG9mKHN0cnVjdCBzb2NrYWRkcl91biwgc3VuX3BhdGgpKTsKKwlwcmludGZfZW5jb2RlKGFkZHJfdHh0LCBzaXplb2YoYWRkcl90eHQpLAorCQkgICAgICAodTggKikgZnJvbS0+c3VuX3BhdGgsCisJCSAgICAgIGZyb21sZW4gLSBvZmZzZXRvZihzdHJ1Y3Qgc29ja2FkZHJfdW4sIHN1bl9wYXRoKSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIG1vbml0b3IgYXR0YWNoZWQgJXMiLCBhZGRyX3R4dCk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTk0LDEwICsxMDMsMTMgQEAKIAkJICAgIG9zX21lbWNtcChmcm9tLT5zdW5fcGF0aCwgZHN0LT5hZGRyLnN1bl9wYXRoLAogCQkJICAgICAgZnJvbWxlbiAtIG9mZnNldG9mKHN0cnVjdCBzb2NrYWRkcl91biwgc3VuX3BhdGgpKQogCQkgICAgPT0gMCkgewotCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBtb25pdG9yIGRldGFjaGVkIiwKLQkJCQkgICAgKHU4ICopIGZyb20tPnN1bl9wYXRoLAotCQkJCSAgICBmcm9tbGVuIC0KLQkJCQkgICAgb2Zmc2V0b2Yoc3RydWN0IHNvY2thZGRyX3VuLCBzdW5fcGF0aCkpOworCQkJY2hhciBhZGRyX3R4dFsyMDBdOworCQkJcHJpbnRmX2VuY29kZShhZGRyX3R4dCwgc2l6ZW9mKGFkZHJfdHh0KSwKKwkJCQkgICAgICAodTggKikgZnJvbS0+c3VuX3BhdGgsCisJCQkJICAgICAgZnJvbWxlbiAtCisJCQkJICAgICAgb2Zmc2V0b2Yoc3RydWN0IHNvY2thZGRyX3VuLCBzdW5fcGF0aCkpOworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIG1vbml0b3IgZGV0YWNoZWQgJXMiLAorCQkJCSAgIGFkZHJfdHh0KTsKIAkJCWRsX2xpc3RfZGVsKCZkc3QtPmxpc3QpOwogCQkJb3NfZnJlZShkc3QpOwogCQkJcmV0dXJuIDA7CkBAIC0xMjEsMTEgKzEzMywxMyBAQAogCQkgICAgb3NfbWVtY21wKGZyb20tPnN1bl9wYXRoLCBkc3QtPmFkZHIuc3VuX3BhdGgsCiAJCQkgICAgICBmcm9tbGVuIC0gb2Zmc2V0b2Yoc3RydWN0IHNvY2thZGRyX3VuLCBzdW5fcGF0aCkpCiAJCSAgICA9PSAwKSB7Ci0JCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJDVFJMX0lGQUNFIGNoYW5nZWQgbW9uaXRvciAiCi0JCQkJICAgICJsZXZlbCIsICh1OCAqKSBmcm9tLT5zdW5fcGF0aCwKLQkJCQkgICAgZnJvbWxlbiAtCi0JCQkJICAgIG9mZnNldG9mKHN0cnVjdCBzb2NrYWRkcl91biwgc3VuX3BhdGgpKTsKKwkJCWNoYXIgYWRkcl90eHRbMjAwXTsKIAkJCWRzdC0+ZGVidWdfbGV2ZWwgPSBhdG9pKGxldmVsKTsKKwkJCXByaW50Zl9lbmNvZGUoYWRkcl90eHQsIHNpemVvZihhZGRyX3R4dCksCisJCQkJICAgICAgKHU4ICopIGZyb20tPnN1bl9wYXRoLCBmcm9tbGVuIC0KKwkJCQkgICAgICBvZmZzZXRvZihzdHJ1Y3Qgc29ja2FkZHJfdW4sIHN1bl9wYXRoKSk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgY2hhbmdlZCBtb25pdG9yIGxldmVsIHRvICVkIGZvciAlcyIsCisJCQkJICAgZHN0LT5kZWJ1Z19sZXZlbCwgYWRkcl90eHQpOwogCQkJcmV0dXJuIDA7CiAJCX0KIAl9CkBAIC0xNDMsNyArMTU3LDcgQEAKIAlpbnQgcmVzOwogCXN0cnVjdCBzb2NrYWRkcl91biBmcm9tOwogCXNvY2tsZW5fdCBmcm9tbGVuID0gc2l6ZW9mKGZyb20pOwotCWNoYXIgKnJlcGx5ID0gTlVMTDsKKwljaGFyICpyZXBseSA9IE5VTEwsICpyZXBseV9idWYgPSBOVUxMOwogCXNpemVfdCByZXBseV9sZW4gPSAwOwogCWludCBuZXdfYXR0YWNoZWQgPSAwOwogCkBAIC0xNzcsMjEgKzE5MSw0OSBAQAogCQllbHNlCiAJCQlyZXBseV9sZW4gPSAyOwogCX0gZWxzZSB7Ci0JCXJlcGx5ID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9wcm9jZXNzKHdwYV9zLCBidWYsCi0JCQkJCQkJICAmcmVwbHlfbGVuKTsKKwkJcmVwbHlfYnVmID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9wcm9jZXNzKHdwYV9zLCBidWYsCisJCQkJCQkJICAgICAgJnJlcGx5X2xlbik7CisJCXJlcGx5ID0gcmVwbHlfYnVmOworCX0KKworCWlmICghcmVwbHkgJiYgcmVwbHlfbGVuID09IDEpIHsKKwkJcmVwbHkgPSAiRkFJTFxuIjsKKwkJcmVwbHlfbGVuID0gNTsKKwl9IGVsc2UgaWYgKCFyZXBseSAmJiByZXBseV9sZW4gPT0gMikgeworCQlyZXBseSA9ICJPS1xuIjsKKwkJcmVwbHlfbGVuID0gMzsKIAl9CiAKIAlpZiAocmVwbHkpIHsKLQkJc2VuZHRvKHNvY2ssIHJlcGx5LCByZXBseV9sZW4sIDAsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sCi0JCSAgICAgICBmcm9tbGVuKTsKLQkJb3NfZnJlZShyZXBseSk7Ci0JfSBlbHNlIGlmIChyZXBseV9sZW4gPT0gMSkgewotCQlzZW5kdG8oc29jaywgIkZBSUxcbiIsIDUsIDAsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sCi0JCSAgICAgICBmcm9tbGVuKTsKLQl9IGVsc2UgaWYgKHJlcGx5X2xlbiA9PSAyKSB7Ci0JCXNlbmR0byhzb2NrLCAiT0tcbiIsIDMsIDAsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sCi0JCSAgICAgICBmcm9tbGVuKTsKKwkJaWYgKHNlbmR0byhzb2NrLCByZXBseSwgcmVwbHlfbGVuLCAwLCAoc3RydWN0IHNvY2thZGRyICopICZmcm9tLAorCQkJICAgZnJvbWxlbikgPCAwKSB7CisJCQlpbnQgX2Vycm5vID0gZXJybm87CisJCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsCisJCQkJImN0cmxfaWZhY2Ugc2VuZHRvIGZhaWxlZDogJWQgLSAlcyIsCisJCQkJX2Vycm5vLCBzdHJlcnJvcihfZXJybm8pKTsKKwkJCWlmIChfZXJybm8gPT0gRU5PQlVGUyB8fCBfZXJybm8gPT0gRUFHQUlOKSB7CisJCQkJLyoKKwkJCQkgKiBUaGUgc29ja2V0IHNlbmQgYnVmZmVyIGNvdWxkIGJlIGZ1bGwuIFRoaXMKKwkJCQkgKiBtYXkgaGFwcGVuIGlmIGNsaWVudCBwcm9ncmFtcyBhcmUgbm90CisJCQkJICogcmVjZWl2aW5nIHRoZWlyIHBlbmRpbmcgbWVzc2FnZXMuIENsb3NlIGFuZAorCQkJCSAqIHJlb3BlbiB0aGUgc29ja2V0IGFzIGEgd29ya2Fyb3VuZCB0byBhdm9pZAorCQkJCSAqIGdldHRpbmcgc3R1Y2sgYmVpbmcgdW5hYmxlIHRvIHNlbmQgYW55IG5ldworCQkJCSAqIHJlc3BvbnNlcy4KKwkJCQkgKi8KKwkJCQlzb2NrID0gd3Bhc19jdHJsX2lmYWNlX3JlaW5pdCh3cGFfcywgcHJpdik7CisJCQkJaWYgKHNvY2sgPCAwKSB7CisJCQkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkZhaWxlZCB0byByZWluaXRpYWxpemUgY3RybF9pZmFjZSBzb2NrZXQiKTsKKwkJCQl9CisJCQl9CisJCQlpZiAobmV3X2F0dGFjaGVkKSB7CisJCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiRmFpbGVkIHRvIHNlbmQgcmVzcG9uc2UgdG8gQVRUQUNIIC0gZGV0YWNoaW5nIik7CisJCQkJbmV3X2F0dGFjaGVkID0gMDsKKwkJCQl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2RldGFjaCgKKwkJCQkJJnByaXYtPmN0cmxfZHN0LCAmZnJvbSwgZnJvbWxlbik7CisJCQl9CisJCX0KIAl9CisJb3NfZnJlZShyZXBseV9idWYpOwogCiAJaWYgKG5ld19hdHRhY2hlZCkKIAkJZWFwb2xfc21fbm90aWZ5X2N0cmxfYXR0YWNoZWQod3BhX3MtPmVhcG9sKTsKQEAgLTIwMiw3ICsyNDQsNyBAQAogewogCWNoYXIgKmJ1ZjsKIAlzaXplX3QgbGVuOwotCWNoYXIgKnBidWYsICpkaXIgPSBOVUxMLCAqZ2lkX3N0ciA9IE5VTEw7CisJY2hhciAqcGJ1ZiwgKmRpciA9IE5VTEw7CiAJaW50IHJlczsKIAogCWlmICh3cGFfcy0+Y29uZi0+Y3RybF9pbnRlcmZhY2UgPT0gTlVMTCkKQEAgLTIxMiwxMiArMjU0LDExIEBACiAJaWYgKHBidWYgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAJaWYgKG9zX3N0cm5jbXAocGJ1ZiwgIkRJUj0iLCA0KSA9PSAwKSB7CisJCWNoYXIgKmdpZF9zdHI7CiAJCWRpciA9IHBidWYgKyA0OwogCQlnaWRfc3RyID0gb3Nfc3Ryc3RyKGRpciwgIiBHUk9VUD0iKTsKLQkJaWYgKGdpZF9zdHIpIHsKKwkJaWYgKGdpZF9zdHIpCiAJCQkqZ2lkX3N0ciA9ICdcMCc7Ci0JCQlnaWRfc3RyICs9IDc7Ci0JCX0KIAl9IGVsc2UKIAkJZGlyID0gcGJ1ZjsKIApAQCAtMjYyLDI2ICszMDMsMjcgQEAKIAlpZiAoZ2xvYmFsICE9IDIgJiYgd3BhX3MtPmdsb2JhbC0+Y3RybF9pZmFjZSkgewogCQlzdHJ1Y3QgY3RybF9pZmFjZV9nbG9iYWxfcHJpdiAqcHJpdiA9IHdwYV9zLT5nbG9iYWwtPmN0cmxfaWZhY2U7CiAJCWlmICghZGxfbGlzdF9lbXB0eSgmcHJpdi0+Y3RybF9kc3QpKSB7Ci0JCQl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NlbmQoZ2xvYmFsID8gTlVMTCA6CisJCQl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NlbmQod3BhX3MsIGdsb2JhbCA/IE5VTEwgOgogCQkJCQkJICAgICAgIHdwYV9zLT5pZm5hbWUsCiAJCQkJCQkgICAgICAgcHJpdi0+c29jaywKIAkJCQkJCSAgICAgICAmcHJpdi0+Y3RybF9kc3QsCi0JCQkJCQkgICAgICAgbGV2ZWwsIHR4dCwgbGVuKTsKKwkJCQkJCSAgICAgICBsZXZlbCwgdHh0LCBsZW4sIE5VTEwsCisJCQkJCQkgICAgICAgcHJpdik7CiAJCX0KIAl9CiAKIAlpZiAod3BhX3MtPmN0cmxfaWZhY2UgPT0gTlVMTCkKIAkJcmV0dXJuOwotCXdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2VuZChOVUxMLCB3cGFfcy0+Y3RybF9pZmFjZS0+c29jaywKKwl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NlbmQod3BhX3MsIE5VTEwsIHdwYV9zLT5jdHJsX2lmYWNlLT5zb2NrLAogCQkJCSAgICAgICAmd3BhX3MtPmN0cmxfaWZhY2UtPmN0cmxfZHN0LAotCQkJCSAgICAgICBsZXZlbCwgdHh0LCBsZW4pOworCQkJCSAgICAgICBsZXZlbCwgdHh0LCBsZW4sIHdwYV9zLT5jdHJsX2lmYWNlLAorCQkJCSAgICAgICBOVUxMKTsKIH0KIAogCi1zdHJ1Y3QgY3RybF9pZmFjZV9wcml2ICoKLXdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQorc3RhdGljIGludCB3cGFzX2N0cmxfaWZhY2Vfb3Blbl9zb2NrKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICBzdHJ1Y3QgY3RybF9pZmFjZV9wcml2ICpwcml2KQogewotCXN0cnVjdCBjdHJsX2lmYWNlX3ByaXYgKnByaXY7CiAJc3RydWN0IHNvY2thZGRyX3VuIGFkZHI7CiAJY2hhciAqZm5hbWUgPSBOVUxMOwogCWdpZF90IGdpZCA9IDA7CkBAIC0yOTEsMTYgKzMzMyw2IEBACiAJY2hhciAqZW5kcDsKIAlpbnQgZmxhZ3M7CiAKLQlwcml2ID0gb3NfemFsbG9jKHNpemVvZigqcHJpdikpOwotCWlmIChwcml2ID09IE5VTEwpCi0JCXJldHVybiBOVUxMOwotCWRsX2xpc3RfaW5pdCgmcHJpdi0+Y3RybF9kc3QpOwotCXByaXYtPndwYV9zID0gd3BhX3M7Ci0JcHJpdi0+c29jayA9IC0xOwotCi0JaWYgKHdwYV9zLT5jb25mLT5jdHJsX2ludGVyZmFjZSA9PSBOVUxMKQotCQlyZXR1cm4gcHJpdjsKLQogCWJ1ZiA9IG9zX3N0cmR1cCh3cGFfcy0+Y29uZi0+Y3RybF9pbnRlcmZhY2UpOwogCWlmIChidWYgPT0gTlVMTCkKIAkJZ290byBmYWlsOwpAQCAtNDc2LDE4ICs1MDgsNjEgQEAKIAl3cGFfbXNnX3JlZ2lzdGVyX2NiKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfbXNnX2NiKTsKIAogCW9zX2ZyZWUoYnVmKTsKLQlyZXR1cm4gcHJpdjsKKwlyZXR1cm4gMDsKIAogZmFpbDoKLQlpZiAocHJpdi0+c29jayA+PSAwKQorCWlmIChwcml2LT5zb2NrID49IDApIHsKIAkJY2xvc2UocHJpdi0+c29jayk7Ci0Jb3NfZnJlZShwcml2KTsKKwkJcHJpdi0+c29jayA9IC0xOworCX0KIAlpZiAoZm5hbWUpIHsKIAkJdW5saW5rKGZuYW1lKTsKIAkJb3NfZnJlZShmbmFtZSk7CiAJfQogCW9zX2ZyZWUoYnVmKTsKLQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gLTE7Cit9CisKKworc3RydWN0IGN0cmxfaWZhY2VfcHJpdiAqCit3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlzdHJ1Y3QgY3RybF9pZmFjZV9wcml2ICpwcml2OworCisJcHJpdiA9IG9zX3phbGxvYyhzaXplb2YoKnByaXYpKTsKKwlpZiAocHJpdiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlkbF9saXN0X2luaXQoJnByaXYtPmN0cmxfZHN0KTsKKwlwcml2LT53cGFfcyA9IHdwYV9zOworCXByaXYtPnNvY2sgPSAtMTsKKworCWlmICh3cGFfcy0+Y29uZi0+Y3RybF9pbnRlcmZhY2UgPT0gTlVMTCkKKwkJcmV0dXJuIHByaXY7CisKKwlpZiAod3Bhc19jdHJsX2lmYWNlX29wZW5fc29jayh3cGFfcywgcHJpdikgPCAwKSB7CisJCW9zX2ZyZWUocHJpdik7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiBwcml2OworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19jdHJsX2lmYWNlX3JlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgc3RydWN0IGN0cmxfaWZhY2VfcHJpdiAqcHJpdikKK3sKKwlpbnQgcmVzOworCisJaWYgKHByaXYtPnNvY2sgPD0gMCkKKwkJcmV0dXJuIC0xOworCisJZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2socHJpdi0+c29jayk7CisJY2xvc2UocHJpdi0+c29jayk7CisJcHJpdi0+c29jayA9IC0xOworCXJlcyA9IHdwYXNfY3RybF9pZmFjZV9vcGVuX3NvY2sod3BhX3MsIHByaXYpOworCWlmIChyZXMgPCAwKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHByaXYtPnNvY2s7CiB9CiAKIApAQCAtNDk3LDcgKzU3Miw3IEBACiAKIAlpZiAocHJpdi0+c29jayA+IC0xKSB7CiAJCWNoYXIgKmZuYW1lOwotCQljaGFyICpidWYsICpkaXIgPSBOVUxMLCAqZ2lkX3N0ciA9IE5VTEw7CisJCWNoYXIgKmJ1ZiwgKmRpciA9IE5VTEw7CiAJCWVsb29wX3VucmVnaXN0ZXJfcmVhZF9zb2NrKHByaXYtPnNvY2spOwogCQlpZiAoIWRsX2xpc3RfZW1wdHkoJnByaXYtPmN0cmxfZHN0KSkgewogCQkJLyoKQEAgLTUxNywxNiArNTkyLDE3IEBACiAJCQlvc19mcmVlKGZuYW1lKTsKIAkJfQogCisJCWlmIChwcml2LT53cGFfcy0+Y29uZi0+Y3RybF9pbnRlcmZhY2UgPT0gTlVMTCkKKwkJCWdvdG8gZnJlZV9kc3Q7CiAJCWJ1ZiA9IG9zX3N0cmR1cChwcml2LT53cGFfcy0+Y29uZi0+Y3RybF9pbnRlcmZhY2UpOwogCQlpZiAoYnVmID09IE5VTEwpCiAJCQlnb3RvIGZyZWVfZHN0OwogCQlpZiAob3Nfc3RybmNtcChidWYsICJESVI9IiwgNCkgPT0gMCkgeworCQkJY2hhciAqZ2lkX3N0cjsKIAkJCWRpciA9IGJ1ZiArIDQ7CiAJCQlnaWRfc3RyID0gb3Nfc3Ryc3RyKGRpciwgIiBHUk9VUD0iKTsKLQkJCWlmIChnaWRfc3RyKSB7CisJCQlpZiAoZ2lkX3N0cikKIAkJCQkqZ2lkX3N0ciA9ICdcMCc7Ci0JCQkJZ2lkX3N0ciArPSA3OwotCQkJfQogCQl9IGVsc2UKIAkJCWRpciA9IGJ1ZjsKIApAQCAtNTYzLDEwICs2MzksMTMgQEAKICAqCiAgKiBTZW5kIGEgcGFja2V0IHRvIGFsbCBtb25pdG9yIHByb2dyYW1zIGF0dGFjaGVkIHRvIHRoZSBjb250cm9sIGludGVyZmFjZS4KICAqLwotc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zZW5kKGNvbnN0IGNoYXIgKmlmbmFtZSwgaW50IHNvY2ssCitzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NlbmQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgY29uc3QgY2hhciAqaWZuYW1lLCBpbnQgc29jaywKIAkJCQkJICAgc3RydWN0IGRsX2xpc3QgKmN0cmxfZHN0LAogCQkJCQkgICBpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKmJ1ZiwKLQkJCQkJICAgc2l6ZV90IGxlbikKKwkJCQkJICAgc2l6ZV90IGxlbiwKKwkJCQkJICAgc3RydWN0IGN0cmxfaWZhY2VfcHJpdiAqcHJpdiwKKwkJCQkJICAgc3RydWN0IGN0cmxfaWZhY2VfZ2xvYmFsX3ByaXYgKmdwKQogewogCXN0cnVjdCB3cGFfY3RybF9kc3QgKmRzdCwgKm5leHQ7CiAJY2hhciBsZXZlbHN0clsxMF07CkBAIC02MDIsMzEgKzY4MSw1OCBAQAogCW1zZy5tc2dfaW92ID0gaW87CiAJbXNnLm1zZ19pb3ZsZW4gPSBpZHg7CiAKLQlpZHggPSAwOwogCWRsX2xpc3RfZm9yX2VhY2hfc2FmZShkc3QsIG5leHQsIGN0cmxfZHN0LCBzdHJ1Y3Qgd3BhX2N0cmxfZHN0LCBsaXN0KSB7Ci0JCWlmIChsZXZlbCA+PSBkc3QtPmRlYnVnX2xldmVsKSB7Ci0JCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJDVFJMX0lGQUNFIG1vbml0b3Igc2VuZCIsCi0JCQkJICAgICh1OCAqKSBkc3QtPmFkZHIuc3VuX3BhdGgsIGRzdC0+YWRkcmxlbiAtCi0JCQkJICAgIG9mZnNldG9mKHN0cnVjdCBzb2NrYWRkcl91biwgc3VuX3BhdGgpKTsKLQkJCW1zZy5tc2dfbmFtZSA9ICh2b2lkICopICZkc3QtPmFkZHI7Ci0JCQltc2cubXNnX25hbWVsZW4gPSBkc3QtPmFkZHJsZW47Ci0JCQlpZiAoc2VuZG1zZyhzb2NrLCAmbXNnLCBNU0dfRE9OVFdBSVQpIDwgMCkgewotCQkJCWludCBfZXJybm8gPSBlcnJubzsKLQkJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQ1RSTF9JRkFDRSBtb25pdG9yWyVkXTogIgotCQkJCQkgICAiJWQgLSAlcyIsCi0JCQkJCSAgIGlkeCwgZXJybm8sIHN0cmVycm9yKGVycm5vKSk7Ci0JCQkJZHN0LT5lcnJvcnMrKzsKLQkJCQlpZiAoZHN0LT5lcnJvcnMgPiAxMDAwIHx8Ci0JCQkJICAgIChfZXJybm8gIT0gRU5PQlVGUyAmJiBkc3QtPmVycm9ycyA+IDEwKSB8fAotCQkJCSAgICBfZXJybm8gPT0gRU5PRU5UKSB7Ci0JCQkJCXdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZGV0YWNoKAotCQkJCQkJY3RybF9kc3QsICZkc3QtPmFkZHIsCi0JCQkJCQlkc3QtPmFkZHJsZW4pOwotCQkJCX0KLQkJCX0gZWxzZQotCQkJCWRzdC0+ZXJyb3JzID0gMDsKKwkJaW50IF9lcnJubzsKKwkJY2hhciBhZGRyX3R4dFsyMDBdOworCisJCWlmIChsZXZlbCA8IGRzdC0+ZGVidWdfbGV2ZWwpCisJCQljb250aW51ZTsKKworCQlwcmludGZfZW5jb2RlKGFkZHJfdHh0LCBzaXplb2YoYWRkcl90eHQpLAorCQkJICAgICAgKHU4ICopIGRzdC0+YWRkci5zdW5fcGF0aCwgZHN0LT5hZGRybGVuIC0KKwkJCSAgICAgIG9mZnNldG9mKHN0cnVjdCBzb2NrYWRkcl91biwgc3VuX3BhdGgpKTsKKwkJbXNnLm1zZ19uYW1lID0gKHZvaWQgKikgJmRzdC0+YWRkcjsKKwkJbXNnLm1zZ19uYW1lbGVuID0gZHN0LT5hZGRybGVuOworCQlpZiAoc2VuZG1zZyhzb2NrLCAmbXNnLCBNU0dfRE9OVFdBSVQpID49IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBtb25pdG9yIHNlbnQgc3VjY2Vzc2Z1bGx5IHRvICVzIiwKKwkJCQkgICBhZGRyX3R4dCk7CisJCQlkc3QtPmVycm9ycyA9IDA7CisJCQljb250aW51ZTsKIAkJfQotCQlpZHgrKzsKKworCQlfZXJybm8gPSBlcnJubzsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIG1vbml0b3JbJXNdOiAlZCAtICVzIiwKKwkJCSAgIGFkZHJfdHh0LCBlcnJubywgc3RyZXJyb3IoZXJybm8pKTsKKwkJZHN0LT5lcnJvcnMrKzsKKworCQlpZiAoZHN0LT5lcnJvcnMgPiAxMCB8fCBfZXJybm8gPT0gRU5PRU5UIHx8IF9lcnJubyA9PSBFUEVSTSkgeworCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkNUUkxfSUZBQ0U6IERldGFjaCBtb25pdG9yICVzIHRoYXQgY2Fubm90IHJlY2VpdmUgbWVzc2FnZXMiLAorCQkJCWFkZHJfdHh0KTsKKwkJCXdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZGV0YWNoKGN0cmxfZHN0LCAmZHN0LT5hZGRyLAorCQkJCQkJCSBkc3QtPmFkZHJsZW4pOworCQl9CisKKwkJaWYgKF9lcnJubyA9PSBFTk9CVUZTIHx8IF9lcnJubyA9PSBFQUdBSU4pIHsKKwkJCS8qCisJCQkgKiBUaGUgc29ja2V0IHNlbmQgYnVmZmVyIGNvdWxkIGJlIGZ1bGwuIFRoaXMgbWF5IGhhcHBlbgorCQkJICogaWYgY2xpZW50IHByb2dyYW1zIGFyZSBub3QgcmVjZWl2aW5nIHRoZWlyIHBlbmRpbmcKKwkJCSAqIG1lc3NhZ2VzLiBDbG9zZSBhbmQgcmVvcGVuIHRoZSBzb2NrZXQgYXMgYSB3b3JrYXJvdW5kCisJCQkgKiB0byBhdm9pZCBnZXR0aW5nIHN0dWNrIGJlaW5nIHVuYWJsZSB0byBzZW5kIGFueSBuZXcKKwkJCSAqIHJlc3BvbnNlcy4KKwkJCSAqLworCQkJaWYgKHByaXYpCisJCQkJc29jayA9IHdwYXNfY3RybF9pZmFjZV9yZWluaXQod3BhX3MsIHByaXYpOworCQkJZWxzZSBpZiAoZ3ApCisJCQkJc29jayA9IHdwYXNfY3RybF9pZmFjZV9nbG9iYWxfcmVpbml0KAorCQkJCQl3cGFfcy0+Z2xvYmFsLCBncCk7CisJCQllbHNlCisJCQkJYnJlYWs7CisJCQlpZiAoc29jayA8IDApIHsKKwkJCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsCisJCQkJCSJGYWlsZWQgdG8gcmVpbml0aWFsaXplIGN0cmxfaWZhY2Ugc29ja2V0Iik7CisJCQkJYnJlYWs7CisJCQl9CisJCX0KIAl9CiB9CiAKQEAgLTY1NiwxOCArNzYyLDMwIEBACiAJCQkvKiBoYW5kbGUgQVRUQUNIIHNpZ25hbCBvZiBmaXJzdCBtb25pdG9yIGludGVyZmFjZSAqLwogCQkJaWYgKCF3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2F0dGFjaCgmcHJpdi0+Y3RybF9kc3QsCiAJCQkJCQkJICAgICAgJmZyb20sIGZyb21sZW4pKSB7Ci0JCQkJc2VuZHRvKHByaXYtPnNvY2ssICJPS1xuIiwgMywgMCwKLQkJCQkgICAgICAgKHN0cnVjdCBzb2NrYWRkciAqKSAmZnJvbSwgZnJvbWxlbik7CisJCQkJaWYgKHNlbmR0byhwcml2LT5zb2NrLCAiT0tcbiIsIDMsIDAsCisJCQkJCSAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sIGZyb21sZW4pIDwKKwkJCQkgICAgMCkgeworCQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImN0cmxfaWZhY2Ugc2VuZHRvIGZhaWxlZDogJXMiLAorCQkJCQkJICAgc3RyZXJyb3IoZXJybm8pKTsKKwkJCQl9CiAJCQkJLyogT0sgdG8gY29udGludWUgKi8KIAkJCQlyZXR1cm47CiAJCQl9IGVsc2UgewotCQkJCXNlbmR0byhwcml2LT5zb2NrLCAiRkFJTFxuIiwgNSwgMCwKLQkJCQkgICAgICAgKHN0cnVjdCBzb2NrYWRkciAqKSAmZnJvbSwgZnJvbWxlbik7CisJCQkJaWYgKHNlbmR0byhwcml2LT5zb2NrLCAiRkFJTFxuIiwgNSwgMCwKKwkJCQkJICAgKHN0cnVjdCBzb2NrYWRkciAqKSAmZnJvbSwgZnJvbWxlbikgPAorCQkJCSAgICAwKSB7CisJCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiY3RybF9pZmFjZSBzZW5kdG8gZmFpbGVkOiAlcyIsCisJCQkJCQkgICBzdHJlcnJvcihlcnJubykpOworCQkJCX0KIAkJCX0KIAkJfSBlbHNlIHsKIAkJCS8qIHJldHVybiBGQUlMIGZvciBhbGwgb3RoZXIgc2lnbmFscyAqLwotCQkJc2VuZHRvKHByaXYtPnNvY2ssICJGQUlMXG4iLCA1LCAwLAotCQkJICAgICAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sIGZyb21sZW4pOworCQkJaWYgKHNlbmR0byhwcml2LT5zb2NrLCAiRkFJTFxuIiwgNSwgMCwKKwkJCQkgICAoc3RydWN0IHNvY2thZGRyICopICZmcm9tLCBmcm9tbGVuKSA8IDApIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCQkJICAgImN0cmxfaWZhY2Ugc2VuZHRvIGZhaWxlZDogJXMiLAorCQkJCQkgICBzdHJlcnJvcihlcnJubykpOworCQkJfQogCQl9CiAJfQogfQpAQCAtNjgwLDExICs3OTgsMTEgQEAKIHsKIAlzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsID0gZWxvb3BfY3R4OwogCXN0cnVjdCBjdHJsX2lmYWNlX2dsb2JhbF9wcml2ICpwcml2ID0gc29ja19jdHg7Ci0JY2hhciBidWZbMjU2XTsKKwljaGFyIGJ1Zls0MDk2XTsKIAlpbnQgcmVzOwogCXN0cnVjdCBzb2NrYWRkcl91biBmcm9tOwogCXNvY2tsZW5fdCBmcm9tbGVuID0gc2l6ZW9mKGZyb20pOwotCWNoYXIgKnJlcGx5ID0gTlVMTDsKKwljaGFyICpyZXBseSA9IE5VTEwsICpyZXBseV9idWYgPSBOVUxMOwogCXNpemVfdCByZXBseV9sZW47CiAKIAlyZXMgPSByZWN2ZnJvbShzb2NrLCBidWYsIHNpemVvZihidWYpIC0gMSwgMCwKQEAgLTcwOSw0MSArODI3LDM3IEBACiAJCWVsc2UKIAkJCXJlcGx5X2xlbiA9IDI7CiAJfSBlbHNlIHsKLQkJcmVwbHkgPSB3cGFfc3VwcGxpY2FudF9nbG9iYWxfY3RybF9pZmFjZV9wcm9jZXNzKGdsb2JhbCwgYnVmLAotCQkJCQkJCQkgJnJlcGx5X2xlbik7CisJCXJlcGx5X2J1ZiA9IHdwYV9zdXBwbGljYW50X2dsb2JhbF9jdHJsX2lmYWNlX3Byb2Nlc3MoCisJCQlnbG9iYWwsIGJ1ZiwgJnJlcGx5X2xlbik7CisJCXJlcGx5ID0gcmVwbHlfYnVmOworCX0KKworCWlmICghcmVwbHkgJiYgcmVwbHlfbGVuID09IDEpIHsKKwkJcmVwbHkgPSAiRkFJTFxuIjsKKwkJcmVwbHlfbGVuID0gNTsKKwl9IGVsc2UgaWYgKCFyZXBseSAmJiByZXBseV9sZW4gPT0gMikgeworCQlyZXBseSA9ICJPS1xuIjsKKwkJcmVwbHlfbGVuID0gMzsKIAl9CiAKIAlpZiAocmVwbHkpIHsKLQkJc2VuZHRvKHNvY2ssIHJlcGx5LCByZXBseV9sZW4sIDAsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sCi0JCSAgICAgICBmcm9tbGVuKTsKLQkJb3NfZnJlZShyZXBseSk7Ci0JfSBlbHNlIGlmIChyZXBseV9sZW4gPT0gMSkgewotCQlzZW5kdG8oc29jaywgIkZBSUxcbiIsIDUsIDAsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sCi0JCSAgICAgICBmcm9tbGVuKTsKLQl9IGVsc2UgaWYgKHJlcGx5X2xlbiA9PSAyKSB7Ci0JCXNlbmR0byhzb2NrLCAiT0tcbiIsIDMsIDAsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sIGZyb21sZW4pOworCQlpZiAoc2VuZHRvKHNvY2ssIHJlcGx5LCByZXBseV9sZW4sIDAsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20sCisJCQkgICBmcm9tbGVuKSA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiY3RybF9pZmFjZSBzZW5kdG8gZmFpbGVkOiAlcyIsCisJCQkJc3RyZXJyb3IoZXJybm8pKTsKKwkJfQogCX0KKwlvc19mcmVlKHJlcGx5X2J1Zik7CiB9CiAKIAotc3RydWN0IGN0cmxfaWZhY2VfZ2xvYmFsX3ByaXYgKgotd3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2N0cmxfaWZhY2VfaW5pdChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsKQorc3RhdGljIGludCB3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX29wZW5fc29jayhzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsLAorCQkJCQkgICAgc3RydWN0IGN0cmxfaWZhY2VfZ2xvYmFsX3ByaXYgKnByaXYpCiB7Ci0Jc3RydWN0IGN0cmxfaWZhY2VfZ2xvYmFsX3ByaXYgKnByaXY7CiAJc3RydWN0IHNvY2thZGRyX3VuIGFkZHI7CiAJY29uc3QgY2hhciAqY3RybCA9IGdsb2JhbC0+cGFyYW1zLmN0cmxfaW50ZXJmYWNlOwogCWludCBmbGFnczsKIAotCXByaXYgPSBvc196YWxsb2Moc2l6ZW9mKCpwcml2KSk7Ci0JaWYgKHByaXYgPT0gTlVMTCkKLQkJcmV0dXJuIE5VTEw7Ci0JZGxfbGlzdF9pbml0KCZwcml2LT5jdHJsX2RzdCk7Ci0JcHJpdi0+Z2xvYmFsID0gZ2xvYmFsOwotCXByaXYtPnNvY2sgPSAtMTsKLQotCWlmIChjdHJsID09IE5VTEwpCi0JCXJldHVybiBwcml2OwotCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHbG9iYWwgY29udHJvbCBpbnRlcmZhY2UgJyVzJyIsIGN0cmwpOwogCiAjaWZkZWYgQU5EUk9JRApAQCAtODc2LDcgKzk5MCwxMyBAQAogCQkJZ290byBmYWlsOwogCQl9CiAJfSBlbHNlIHsKLQkJY2htb2QoY3RybCwgU19JUldYVSk7CisJCWlmIChjaG1vZChjdHJsLCBTX0lSV1hVKSA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJjaG1vZFtnbG9iYWxfY3RybF9pbnRlcmZhY2U9JXNdKFNfSVJXWFUpOiAlcyIsCisJCQkJICAgY3RybCwgc3RyZXJyb3IoZXJybm8pKTsKKwkJCS8qIGNvbnRpbnVlIGFueXdheSBzaW5jZSBncm91cCBjaGFuZ2Ugd2FzIG5vdCByZXF1aXJlZAorCQkJICovCisJCX0KIAl9CiAKIGhhdmVzb2NrOgpAQCAtODk5LDEzICsxMDE5LDU4IEBACiAJCQkJIHdwYV9zdXBwbGljYW50X2dsb2JhbF9jdHJsX2lmYWNlX3JlY2VpdmUsCiAJCQkJIGdsb2JhbCwgcHJpdik7CiAKLQlyZXR1cm4gcHJpdjsKKwlyZXR1cm4gMDsKIAogZmFpbDoKLQlpZiAocHJpdi0+c29jayA+PSAwKQorCWlmIChwcml2LT5zb2NrID49IDApIHsKIAkJY2xvc2UocHJpdi0+c29jayk7Ci0Jb3NfZnJlZShwcml2KTsKLQlyZXR1cm4gTlVMTDsKKwkJcHJpdi0+c29jayA9IC0xOworCX0KKwlyZXR1cm4gLTE7Cit9CisKKworc3RydWN0IGN0cmxfaWZhY2VfZ2xvYmFsX3ByaXYgKgord3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2N0cmxfaWZhY2VfaW5pdChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsKQoreworCXN0cnVjdCBjdHJsX2lmYWNlX2dsb2JhbF9wcml2ICpwcml2OworCisJcHJpdiA9IG9zX3phbGxvYyhzaXplb2YoKnByaXYpKTsKKwlpZiAocHJpdiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlkbF9saXN0X2luaXQoJnByaXYtPmN0cmxfZHN0KTsKKwlwcml2LT5nbG9iYWwgPSBnbG9iYWw7CisJcHJpdi0+c29jayA9IC0xOworCisJaWYgKGdsb2JhbC0+cGFyYW1zLmN0cmxfaW50ZXJmYWNlID09IE5VTEwpCisJCXJldHVybiBwcml2OworCisJaWYgKHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2Vfb3Blbl9zb2NrKGdsb2JhbCwgcHJpdikgPCAwKSB7CisJCW9zX2ZyZWUocHJpdik7CisJCXJldHVybiBOVUxMOworCX0KKworCXdwYV9tc2dfcmVnaXN0ZXJfY2Iod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9tc2dfY2IpOworCisJcmV0dXJuIHByaXY7Cit9CisKKworc3RhdGljIGludCB3cGFzX2N0cmxfaWZhY2VfZ2xvYmFsX3JlaW5pdChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsLAorCQkJCQkgc3RydWN0IGN0cmxfaWZhY2VfZ2xvYmFsX3ByaXYgKnByaXYpCit7CisJaW50IHJlczsKKworCWlmIChwcml2LT5zb2NrIDw9IDApCisJCXJldHVybiAtMTsKKworCWVsb29wX3VucmVnaXN0ZXJfcmVhZF9zb2NrKHByaXYtPnNvY2spOworCWNsb3NlKHByaXYtPnNvY2spOworCXByaXYtPnNvY2sgPSAtMTsKKwlyZXMgPSB3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX29wZW5fc29jayhnbG9iYWwsIHByaXYpOworCWlmIChyZXMgPCAwKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHByaXYtPnNvY2s7CiB9CiAKIApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9NYWtlZmlsZSBiL3dwYV9zdXBwbGljYW50L2RidXMvTWFrZWZpbGUKaW5kZXggZDY0YzY1Yy4uZjM1NWViZSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9NYWtlZmlsZQorKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL01ha2VmaWxlCkBAIC0xLDcgKzEsNyBAQAogYWxsOiBsaWJ3cGFkYnVzLmEKIAogY2xlYW46Ci0Jcm0gLWYgKn4gKi5vICouZAorCXJtIC1mICp+ICoubyAqLmQgKi5nY25vICouZ2NkYSAqLmdjb3YKIAlybSAtZiBsaWJ3cGFkYnVzLmEKIAogaW5zdGFsbDoKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19jb21tb24uYyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19jb21tb24uYwppbmRleCA2Y2FmNzQwLi41Y2MxNTA1IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfY29tbW9uLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2NvbW1vbi5jCkBAIC0zMjAsNiArMzIwLDggQEAKIAlpZiAocHJpdi0+Y29uKSB7CiAJCWVsb29wX2NhbmNlbF90aW1lb3V0KGRpc3BhdGNoX2luaXRpYWxfZGJ1c19tZXNzYWdlcywKIAkJCQkgICAgIHByaXYtPmNvbiwgTlVMTCk7CisJCWVsb29wX2NhbmNlbF90aW1lb3V0KHByb2Nlc3NfdGltZW91dCwgcHJpdiwgRUxPT1BfQUxMX0NUWCk7CisKIAkJZGJ1c19jb25uZWN0aW9uX3NldF93YXRjaF9mdW5jdGlvbnMocHJpdi0+Y29uLCBOVUxMLCBOVUxMLAogCQkJCQkJICAgIE5VTEwsIE5VTEwsIE5VTEwpOwogCQlkYnVzX2Nvbm5lY3Rpb25fc2V0X3RpbWVvdXRfZnVuY3Rpb25zKHByaXYtPmNvbiwgTlVMTCwgTlVMTCwKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19kaWN0X2hlbHBlcnMuYyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19kaWN0X2hlbHBlcnMuYwppbmRleCA2MWE5NDMwLi45NDljZTdjIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfZGljdF9oZWxwZXJzLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2RpY3RfaGVscGVycy5jCkBAIC04ODEsNiArODgxLDggQEAKIAkJfQogCiAJCWRidXNfbWVzc2FnZV9pdGVyX3JlY3Vyc2UoaXRlciwgJml0ZXJfYXJyYXkpOworCQlvc19tZW1zZXQoJnRtcGVudHJ5LCAwLCBzaXplb2YodG1wZW50cnkpKTsKKwkJdG1wZW50cnkudHlwZSA9IERCVVNfVFlQRV9BUlJBWTsKIAkJaWYgKF93cGFfZGJ1c19kaWN0X2VudHJ5X2dldF9ieXRlX2FycmF5KCZpdGVyX2FycmF5LCAmdG1wZW50cnkpCiAJCQkJCT09IEZBTFNFKQogCQkJZ290byBjbGVhbnVwOwpAQCAtOTMyLDYgKzkzNCw3IEBACiAJCWJyZWFrOwogCWNhc2UgREJVU19UWVBFX0FSUkFZOgogCQlzdWNjZXNzID0gX3dwYV9kYnVzX2RpY3RfZW50cnlfZ2V0X2JpbmFycmF5KCZpdGVyX2FycmF5LCBlbnRyeSk7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCWJyZWFrOwogCX0KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXcuYyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXcuYwppbmRleCBkZGQyYzgyLi5lOWY2NTg5IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3LmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ldy5jCkBAIC0yNCw2ICsyNCw3IEBACiAjaW5jbHVkZSAiZGJ1c19jb21tb25faS5oIgogI2luY2x1ZGUgImRidXNfbmV3X2hhbmRsZXJzX3AycC5oIgogI2luY2x1ZGUgInAycC9wMnAuaCIKKyNpbmNsdWRlICIuLi9wMnBfc3VwcGxpY2FudC5oIgogCiAjaWZkZWYgQ09ORklHX0FQIC8qIHVudGlsIG5lZWRlZCBieSBzb21ldGhpbmcgZWxzZSAqLwogCkBAIC03MDksOSArNzEwLDkgQEAKIAlEQnVzTWVzc2FnZSAqbXNnOwogCURCdXNNZXNzYWdlSXRlciBpdGVyLCBkaWN0X2l0ZXI7CiAJc3RydWN0IHdwYXNfZGJ1c19wcml2ICppZmFjZTsKLQljaGFyICphdXRoX3R5cGVbNl07IC8qIHdlIGhhdmUgc2l4IHBvc3NpYmxlIGF1dGhvcml6YXRpb24gdHlwZXMgKi8KKwljaGFyICphdXRoX3R5cGVbNV07IC8qIHdlIGhhdmUgZml2ZSBwb3NzaWJsZSBhdXRoZW50aWNhdGlvbiB0eXBlcyAqLwogCWludCBhdF9udW0gPSAwOwotCWNoYXIgKmVuY3JfdHlwZVs0XTsgLyogd2UgaGF2ZSBmb3VyIHBvc3NpYmxlIGVuY3J5cHRpb24gdHlwZXMgKi8KKwljaGFyICplbmNyX3R5cGVbM107IC8qIHdlIGhhdmUgdGhyZWUgcG9zc2libGUgZW5jcnlwdGlvbiB0eXBlcyAqLwogCWludCBldF9udW0gPSAwOwogCiAJaWZhY2UgPSB3cGFfcy0+Z2xvYmFsLT5kYnVzOwpAQCAtNzM0LDIwICs3MzUsMTUgQEAKIAkJYXV0aF90eXBlW2F0X251bSsrXSA9ICJvcGVuIjsKIAlpZiAoY3JlZC0+YXV0aF90eXBlICYgV1BTX0FVVEhfV1BBUFNLKQogCQlhdXRoX3R5cGVbYXRfbnVtKytdID0gIndwYS1wc2siOwotCWlmIChjcmVkLT5hdXRoX3R5cGUgJiBXUFNfQVVUSF9TSEFSRUQpCi0JCWF1dGhfdHlwZVthdF9udW0rK10gPSAic2hhcmVkIjsKIAlpZiAoY3JlZC0+YXV0aF90eXBlICYgV1BTX0FVVEhfV1BBKQogCQlhdXRoX3R5cGVbYXRfbnVtKytdID0gIndwYS1lYXAiOwogCWlmIChjcmVkLT5hdXRoX3R5cGUgJiBXUFNfQVVUSF9XUEEyKQogCQlhdXRoX3R5cGVbYXRfbnVtKytdID0gIndwYTItZWFwIjsKIAlpZiAoY3JlZC0+YXV0aF90eXBlICYgV1BTX0FVVEhfV1BBMlBTSykKLQkJYXV0aF90eXBlW2F0X251bSsrXSA9Ci0JCSJ3cGEyLXBzayI7CisJCWF1dGhfdHlwZVthdF9udW0rK10gPSAid3BhMi1wc2siOwogCiAJaWYgKGNyZWQtPmVuY3JfdHlwZSAmIFdQU19FTkNSX05PTkUpCiAJCWVuY3JfdHlwZVtldF9udW0rK10gPSAibm9uZSI7Ci0JaWYgKGNyZWQtPmVuY3JfdHlwZSAmIFdQU19FTkNSX1dFUCkKLQkJZW5jcl90eXBlW2V0X251bSsrXSA9ICJ3ZXAiOwogCWlmIChjcmVkLT5lbmNyX3R5cGUgJiBXUFNfRU5DUl9US0lQKQogCQllbmNyX3R5cGVbZXRfbnVtKytdID0gInRraXAiOwogCWlmIChjcmVkLT5lbmNyX3R5cGUgJiBXUFNfRU5DUl9BRVMpCkBAIC05NTAsMzcgKzk0Niw0OSBAQAogdm9pZCB3cGFzX2RidXNfc2lnbmFsX3AycF9ncm91cF9yZW1vdmVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCWNvbnN0IGNoYXIgKnJvbGUpCiB7Ci0KKwlpbnQgZXJyb3IgPSAxOwogCURCdXNNZXNzYWdlICptc2c7Ci0JREJ1c01lc3NhZ2VJdGVyIGl0ZXI7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXIsIGRpY3RfaXRlcjsKIAlzdHJ1Y3Qgd3Bhc19kYnVzX3ByaXYgKmlmYWNlID0gd3BhX3MtPmdsb2JhbC0+ZGJ1czsKLQljaGFyICppZm5hbWUgPSB3cGFfcy0+aWZuYW1lOwogCiAJLyogRG8gbm90aGluZyBpZiB0aGUgY29udHJvbCBpbnRlcmZhY2UgaXMgbm90IHR1cm5lZCBvbiAqLwogCWlmIChpZmFjZSA9PSBOVUxMKQogCQlyZXR1cm47CiAKLQltc2cgPSBkYnVzX21lc3NhZ2VfbmV3X3NpZ25hbCh3cGFfcy0+ZGJ1c19uZXdfcGF0aCwKKwlpZiAoIXdwYV9zLT5kYnVzX2dyb3Vwb2JqX3BhdGgpCisJCXJldHVybjsKKworCW1zZyA9IGRidXNfbWVzc2FnZV9uZXdfc2lnbmFsKHdwYV9zLT5wYXJlbnQtPmRidXNfbmV3X3BhdGgsCiAJCQkJICAgICAgV1BBU19EQlVTX05FV19JRkFDRV9QMlBERVZJQ0UsCiAJCQkJICAgICAgIkdyb3VwRmluaXNoZWQiKTsKIAlpZiAobXNnID09IE5VTEwpCiAJCXJldHVybjsKIAogCWRidXNfbWVzc2FnZV9pdGVyX2luaXRfYXBwZW5kKG1zZywgJml0ZXIpOworCWlmICghd3BhX2RidXNfZGljdF9vcGVuX3dyaXRlKCZpdGVyLCAmZGljdF9pdGVyKSkKKwkJZ290byBub21lbTsKIAotCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljKCZpdGVyLCBEQlVTX1RZUEVfU1RSSU5HLCAmaWZuYW1lKSkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImRidXM6IEZhaWxlZCB0byBjb25zdHJ1Y3QgR3JvdXBGaW5pc2hlZCIKLQkJCQkgICAgICAic2lnbmFsIC1ub3QgZW5vdWdoIG1lbW9yeSBmb3IgaWZuYW1lICIpOwotCQlnb3RvIGVycjsKLQl9CisJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF9vYmplY3RfcGF0aCgmZGljdF9pdGVyLAorCQkJCQkgICAgICAiaW50ZXJmYWNlX29iamVjdCIsCisJCQkJCSAgICAgIHdwYV9zLT5kYnVzX25ld19wYXRoKSkKKwkJZ290byBub21lbTsKIAotCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljKCZpdGVyLCBEQlVTX1RZUEVfU1RSSU5HLCAmcm9sZSkpCi0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiZGJ1czogRmFpbGVkIHRvIGNvbnN0cnVjdCBHcm91cEZpbmlzaGVkIgotCQkJCSAgICAgICJzaWduYWwgLW5vdCBlbm91Z2ggbWVtb3J5IGZvciByb2xlICIpOwotCWVsc2UKLQkJZGJ1c19jb25uZWN0aW9uX3NlbmQoaWZhY2UtPmNvbiwgbXNnLCBOVUxMKTsKKwlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX3N0cmluZygmZGljdF9pdGVyLCAicm9sZSIsIHJvbGUpKQorCQlnb3RvIG5vbWVtOwogCi1lcnI6CisJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF9vYmplY3RfcGF0aCgmZGljdF9pdGVyLCAiZ3JvdXBfb2JqZWN0IiwKKwkJCQkJICAgICAgd3BhX3MtPmRidXNfZ3JvdXBvYmpfcGF0aCkgfHwKKwkgICAgIXdwYV9kYnVzX2RpY3RfY2xvc2Vfd3JpdGUoJml0ZXIsICZkaWN0X2l0ZXIpKQorCQlnb3RvIG5vbWVtOworCisJZXJyb3IgPSAwOworCWRidXNfY29ubmVjdGlvbl9zZW5kKGlmYWNlLT5jb24sIG1zZywgTlVMTCk7CisKK25vbWVtOgorCWlmIChlcnJvciA+IDApCisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgImRidXM6IEZhaWxlZCB0byBjb25zdHJ1Y3QgR3JvdXBGaW5pc2hlZCIpOworCiAJZGJ1c19tZXNzYWdlX3VucmVmKG1zZyk7CiB9CiAKQEAgLTExNTYsNiArMTE2NCw2OSBAQAogfQogCiAKK3N0cnVjdCBncm91cF9jaGFuZ2VkX2RhdGEgeworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3M7CisJc3RydWN0IHAycF9wZWVyX2luZm8gKmluZm87Cit9OworCisKK3N0YXRpYyBpbnQgbWF0Y2hfZ3JvdXBfd2hlcmVfcGVlcl9pc19jbGllbnQoc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsCisJCQkJCSAgICB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IGdyb3VwX2NoYW5nZWRfZGF0YSAqZGF0YSA9IHVzZXJfZGF0YTsKKwljb25zdCBzdHJ1Y3QgcDJwX2dyb3VwX2NvbmZpZyAqY2ZnOworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3NfZ287CisKKwlpZiAoIXAycF9ncm91cF9pc19jbGllbnRfY29ubmVjdGVkKGdyb3VwLCBkYXRhLT5pbmZvLT5wMnBfZGV2aWNlX2FkZHIpKQorCQlyZXR1cm4gMTsKKworCWNmZyA9IHAycF9ncm91cF9nZXRfY29uZmlnKGdyb3VwKTsKKworCXdwYV9zX2dvID0gd3Bhc19nZXRfcDJwX2dvX2lmYWNlKGRhdGEtPndwYV9zLCBjZmctPnNzaWQsCisJCQkJCSBjZmctPnNzaWRfbGVuKTsKKwlpZiAod3BhX3NfZ28gIT0gTlVMTCAmJiB3cGFfc19nbyA9PSBkYXRhLT53cGFfcykgeworCQl3cGFzX2RidXNfc2lnbmFsX3BlZXJfZ3JvdXBzX2NoYW5nZWQoCisJCQlkYXRhLT53cGFfcy0+cGFyZW50LCBkYXRhLT5pbmZvLT5wMnBfZGV2aWNlX2FkZHIpOworCQlyZXR1cm4gMDsKKwl9CisKKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgdm9pZCBzaWduYWxfcGVlcl9ncm91cHNfY2hhbmdlZChzdHJ1Y3QgcDJwX3BlZXJfaW5mbyAqaW5mbywKKwkJCQkgICAgICAgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCBncm91cF9jaGFuZ2VkX2RhdGEgKmRhdGEgPSB1c2VyX2RhdGE7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfc19nbzsKKworCXdwYV9zX2dvID0gd3Bhc19nZXRfcDJwX2NsaWVudF9pZmFjZShkYXRhLT53cGFfcywKKwkJCQkJICAgICBpbmZvLT5wMnBfZGV2aWNlX2FkZHIpOworCWlmICh3cGFfc19nbyAhPSBOVUxMICYmIHdwYV9zX2dvID09IGRhdGEtPndwYV9zKSB7CisJCXdwYXNfZGJ1c19zaWduYWxfcGVlcl9ncm91cHNfY2hhbmdlZChkYXRhLT53cGFfcy0+cGFyZW50LAorCQkJCQkJICAgICBpbmZvLT5wMnBfZGV2aWNlX2FkZHIpOworCQlyZXR1cm47CisJfQorCisJZGF0YS0+aW5mbyA9IGluZm87CisJcDJwX2xvb3Bfb25fYWxsX2dyb3VwcyhkYXRhLT53cGFfcy0+Z2xvYmFsLT5wMnAsCisJCQkgICAgICAgbWF0Y2hfZ3JvdXBfd2hlcmVfcGVlcl9pc19jbGllbnQsIGRhdGEpOworCWRhdGEtPmluZm8gPSBOVUxMOworfQorCisKK3N0YXRpYyB2b2lkIHBlZXJfZ3JvdXBzX2NoYW5nZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlzdHJ1Y3QgZ3JvdXBfY2hhbmdlZF9kYXRhIGRhdGE7CisKKwlvc19tZW1zZXQoJmRhdGEsIDAsIHNpemVvZihkYXRhKSk7CisJZGF0YS53cGFfcyA9IHdwYV9zOworCisJcDJwX2xvb3Bfb25fa25vd25fcGVlcnMod3BhX3MtPmdsb2JhbC0+cDJwLAorCQkJCXNpZ25hbF9wZWVyX2dyb3Vwc19jaGFuZ2VkLCAmZGF0YSk7Cit9CisKKwogLyoqCiAgKiB3cGFzX2RidXNfc2lnbmFsX3AycF9ncm91cF9zdGFydGVkIC0gU2lnbmFscyBQMlAgZ3JvdXAgaGFzCiAgKiBzdGFydGVkLiBFbWl0dGVkIHdoZW4gYSBncm91cCBpcyBzdWNjZXNzZnVsbHkgc3RhcnRlZApAQCAtMTE3NCw3ICsxMjQ1LDYgQEAKIAlEQnVzTWVzc2FnZSAqbXNnOwogCURCdXNNZXNzYWdlSXRlciBpdGVyLCBkaWN0X2l0ZXI7CiAJc3RydWN0IHdwYXNfZGJ1c19wcml2ICppZmFjZTsKLQljaGFyIGdyb3VwX29ial9wYXRoW1dQQVNfREJVU19PQkpFQ1RfUEFUSF9NQVhdOwogCiAJaWZhY2UgPSB3cGFfcy0+cGFyZW50LT5nbG9iYWwtPmRidXM7CiAKQEAgLTExODIsMTQgKzEyNTIsMTMgQEAKIAlpZiAoaWZhY2UgPT0gTlVMTCkKIAkJcmV0dXJuOwogCi0JaWYgKHdwYXNfZGJ1c19nZXRfZ3JvdXBfb2JqX3BhdGgod3BhX3MsIHNzaWQsIGdyb3VwX29ial9wYXRoKSA8IDApCisJaWYgKHdwYV9zLT5kYnVzX2dyb3Vwb2JqX3BhdGggPT0gTlVMTCkKIAkJcmV0dXJuOwogCiAJLyogTmV3IGludGVyZmFjZSBoYXMgYmVlbiBjcmVhdGVkIGZvciB0aGlzIGdyb3VwICovCiAJbXNnID0gZGJ1c19tZXNzYWdlX25ld19zaWduYWwod3BhX3MtPnBhcmVudC0+ZGJ1c19uZXdfcGF0aCwKIAkJCQkgICAgICBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUERFVklDRSwKIAkJCQkgICAgICAiR3JvdXBTdGFydGVkIik7Ci0KIAlpZiAobXNnID09IE5VTEwpCiAJCXJldHVybjsKIApAQCAtMTIxMiwxMiArMTI4MSwxNSBAQAogCQlnb3RvIG5vbWVtOwogCiAJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF9vYmplY3RfcGF0aCgmZGljdF9pdGVyLCAiZ3JvdXBfb2JqZWN0IiwKLQkJCQkJICAgICBncm91cF9vYmpfcGF0aCkgfHwKKwkJCQkJICAgICAgd3BhX3MtPmRidXNfZ3JvdXBvYmpfcGF0aCkgfHwKIAkgICAhd3BhX2RidXNfZGljdF9jbG9zZV93cml0ZSgmaXRlciwgJmRpY3RfaXRlcikpCiAJCWdvdG8gbm9tZW07CiAKIAlkYnVzX2Nvbm5lY3Rpb25fc2VuZChpZmFjZS0+Y29uLCBtc2csIE5VTEwpOwogCisJaWYgKGNsaWVudCkKKwkJcGVlcl9ncm91cHNfY2hhbmdlZCh3cGFfcyk7CisKIG5vbWVtOgogCWRidXNfbWVzc2FnZV91bnJlZihtc2cpOwogfQpAQCAtMTIyNSw3ICsxMjk3LDcgQEAKIAogLyoqCiAgKgotICogTWV0aG9kIHRvIGVtaXQgR09OZW9ndGlhdGlvbiBTdWNjZXNzIG9yIEZhaWx1cmUgc2lnbmFscyBiYXNlZAorICogTWV0aG9kIHRvIGVtaXQgR09OZWdvdGlhdGlvbiBTdWNjZXNzIG9yIEZhaWx1cmUgc2lnbmFscyBiYXNlZAogICogb24gc3RhdHVzLgogICogQHN0YXR1czogU3RhdHVzIG9mIHRoZSBHTyBuZWcgcmVxdWVzdC4gMCBmb3Igc3VjY2Vzcywgb3RoZXIgZm9yIGVycm9ycy4KICAqLwpAQCAtMTM2Miw3ICsxNDM0LDcgQEAKIAlEQnVzTWVzc2FnZUl0ZXIgaXRlciwgZGljdF9pdGVyOwogCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqaWZhY2U7CiAKLQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiJXNcbiIsIF9fZnVuY19fKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIiwgX19mdW5jX18pOwogCiAJaWZhY2UgPSB3cGFfcy0+Z2xvYmFsLT5kYnVzOwogCS8qIERvIG5vdGhpbmcgaWYgdGhlIGNvbnRyb2wgaW50ZXJmYWNlIGlzIG5vdCB0dXJuZWQgb24gKi8KQEAgLTE0MDUsMTUgKzE0NzcsMTUgQEAKICAqIGNvbnN0cnVjdGVkIHVzaW5nIHAycCBpL2YgYWRkciB1c2VkIGZvciBjb25uZWN0aW5nLgogICoKICAqIEB3cGFfczogJXdwYV9zdXBwbGljYW50IG5ldHdvcmsgaW50ZXJmYWNlIGRhdGEKLSAqIEBtZW1iZXJfYWRkcjogYWRkciAocDJwIGkvZikgb2YgdGhlIHBlZXIgam9pbmluZyB0aGUgZ3JvdXAKKyAqIEBwZWVyX2FkZHI6IFAyUCBEZXZpY2UgQWRkcmVzcyBvZiB0aGUgcGVlciBqb2luaW5nIHRoZSBncm91cAogICovCiB2b2lkIHdwYXNfZGJ1c19zaWduYWxfcDJwX3BlZXJfam9pbmVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgICAgY29uc3QgdTggKm1lbWJlcikKKwkJCQkgICAgICBjb25zdCB1OCAqcGVlcl9hZGRyKQogewogCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqaWZhY2U7CiAJREJ1c01lc3NhZ2UgKm1zZzsKIAlEQnVzTWVzc2FnZUl0ZXIgaXRlcjsKLQljaGFyIGdyb3VwbWVtYmVyX29ial9wYXRoW1dQQVNfREJVU19PQkpFQ1RfUEFUSF9NQVhdLCAqcGF0aDsKKwljaGFyIHBlZXJfb2JqX3BhdGhbV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWF0sICpwYXRoOwogCiAJaWZhY2UgPSB3cGFfcy0+Z2xvYmFsLT5kYnVzOwogCkBAIC0xNDI0LDEwICsxNDk2LDEwIEBACiAJaWYgKCF3cGFfcy0+ZGJ1c19ncm91cG9ial9wYXRoKQogCQlyZXR1cm47CiAKLQlvc19zbnByaW50Zihncm91cG1lbWJlcl9vYmpfcGF0aCwgV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWCwKLQkJCSIlcy8iICBXUEFTX0RCVVNfTkVXX1AyUF9HUk9VUE1FTUJFUlNfUEFSVCAiLyIKKwlvc19zbnByaW50ZihwZWVyX29ial9wYXRoLCBXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYLAorCQkJIiVzLyIgV1BBU19EQlVTX05FV19QMlBfUEVFUlNfUEFSVCAiLyIKIAkJCUNPTVBBQ1RfTUFDU1RSLAotCQkJd3BhX3MtPmRidXNfZ3JvdXBvYmpfcGF0aCwgTUFDMlNUUihtZW1iZXIpKTsKKwkJCXdwYV9zLT5wYXJlbnQtPmRidXNfbmV3X3BhdGgsIE1BQzJTVFIocGVlcl9hZGRyKSk7CiAKIAltc2cgPSBkYnVzX21lc3NhZ2VfbmV3X3NpZ25hbCh3cGFfcy0+ZGJ1c19ncm91cG9ial9wYXRoLAogCQkJCSAgICAgIFdQQVNfREJVU19ORVdfSUZBQ0VfUDJQX0dST1VQLApAQCAtMTQzNiwxNCArMTUwOCwxNiBAQAogCQlyZXR1cm47CiAKIAlkYnVzX21lc3NhZ2VfaXRlcl9pbml0X2FwcGVuZChtc2csICZpdGVyKTsKLQlwYXRoID0gZ3JvdXBtZW1iZXJfb2JqX3BhdGg7CisJcGF0aCA9IHBlZXJfb2JqX3BhdGg7CiAJaWYgKCFkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMoJml0ZXIsIERCVVNfVFlQRV9PQkpFQ1RfUEFUSCwKIAkJCQkJICAgICZwYXRoKSkKIAkJZ290byBlcnI7CiAKIAlkYnVzX2Nvbm5lY3Rpb25fc2VuZChpZmFjZS0+Y29uLCBtc2csIE5VTEwpOwotCiAJZGJ1c19tZXNzYWdlX3VucmVmKG1zZyk7CisKKwl3cGFzX2RidXNfc2lnbmFsX3BlZXJfZ3JvdXBzX2NoYW5nZWQod3BhX3MtPnBhcmVudCwgcGVlcl9hZGRyKTsKKwogCXJldHVybjsKIAogZXJyOgpAQCAtMTQ1NiwxOCArMTUzMCwxOCBAQAogICoKICAqIE1ldGhvZCB0byBlbWl0IGEgc2lnbmFsIGZvciBhIHBlZXIgZGlzY29ubmVjdGluZyB0aGUgZ3JvdXAuCiAgKiBUaGUgc2lnbmFsIHdpbGwgY2FycnkgcGF0aCB0byB0aGUgZ3JvdXAgbWVtYmVyIG9iamVjdAotICogY29uc3RydWN0ZWQgdXNpbmcgcDJwIGkvZiBhZGRyIHVzZWQgZm9yIGNvbm5lY3RpbmcuCisgKiBjb25zdHJ1Y3RlZCB1c2luZyB0aGUgUDJQIERldmljZSBBZGRyZXNzIG9mIHRoZSBwZWVyLgogICoKICAqIEB3cGFfczogJXdwYV9zdXBwbGljYW50IG5ldHdvcmsgaW50ZXJmYWNlIGRhdGEKLSAqIEBtZW1iZXJfYWRkcjogYWRkciAocDJwIGkvZikgb2YgdGhlIHBlZXIgam9pbmluZyB0aGUgZ3JvdXAKKyAqIEBwZWVyX2FkZHI6IFAyUCBEZXZpY2UgQWRkcmVzcyBvZiB0aGUgcGVlciBqb2luaW5nIHRoZSBncm91cAogICovCiB2b2lkIHdwYXNfZGJ1c19zaWduYWxfcDJwX3BlZXJfZGlzY29ubmVjdGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgICAgY29uc3QgdTggKm1lbWJlcikKKwkJCQkJICAgIGNvbnN0IHU4ICpwZWVyX2FkZHIpCiB7CiAJc3RydWN0IHdwYXNfZGJ1c19wcml2ICppZmFjZTsKIAlEQnVzTWVzc2FnZSAqbXNnOwogCURCdXNNZXNzYWdlSXRlciBpdGVyOwotCWNoYXIgZ3JvdXBtZW1iZXJfb2JqX3BhdGhbV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWF0sICpwYXRoOworCWNoYXIgcGVlcl9vYmpfcGF0aFtXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYXSwgKnBhdGg7CiAKIAlpZmFjZSA9IHdwYV9zLT5nbG9iYWwtPmRidXM7CiAKQEAgLTE0NzgsMTAgKzE1NTIsMTAgQEAKIAlpZiAoIXdwYV9zLT5kYnVzX2dyb3Vwb2JqX3BhdGgpCiAJCXJldHVybjsKIAotCW9zX3NucHJpbnRmKGdyb3VwbWVtYmVyX29ial9wYXRoLCBXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYLAotCQkJIiVzLyIgIFdQQVNfREJVU19ORVdfUDJQX0dST1VQTUVNQkVSU19QQVJUICIvIgorCW9zX3NucHJpbnRmKHBlZXJfb2JqX3BhdGgsIFdQQVNfREJVU19PQkpFQ1RfUEFUSF9NQVgsCisJCQkiJXMvIiBXUEFTX0RCVVNfTkVXX1AyUF9QRUVSU19QQVJUICIvIgogCQkJQ09NUEFDVF9NQUNTVFIsCi0JCQl3cGFfcy0+ZGJ1c19ncm91cG9ial9wYXRoLCBNQUMyU1RSKG1lbWJlcikpOworCQkJd3BhX3MtPmRidXNfZ3JvdXBvYmpfcGF0aCwgTUFDMlNUUihwZWVyX2FkZHIpKTsKIAogCW1zZyA9IGRidXNfbWVzc2FnZV9uZXdfc2lnbmFsKHdwYV9zLT5kYnVzX2dyb3Vwb2JqX3BhdGgsCiAJCQkJICAgICAgV1BBU19EQlVTX05FV19JRkFDRV9QMlBfR1JPVVAsCkBAIC0xNDkwLDE0ICsxNTY0LDE2IEBACiAJCXJldHVybjsKIAogCWRidXNfbWVzc2FnZV9pdGVyX2luaXRfYXBwZW5kKG1zZywgJml0ZXIpOwotCXBhdGggPSBncm91cG1lbWJlcl9vYmpfcGF0aDsKKwlwYXRoID0gcGVlcl9vYmpfcGF0aDsKIAlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYygmaXRlciwgREJVU19UWVBFX09CSkVDVF9QQVRILAogCQkJCQkgICAgJnBhdGgpKQogCQlnb3RvIGVycjsKIAogCWRidXNfY29ubmVjdGlvbl9zZW5kKGlmYWNlLT5jb24sIG1zZywgTlVMTCk7Ci0KIAlkYnVzX21lc3NhZ2VfdW5yZWYobXNnKTsKKworCXdwYXNfZGJ1c19zaWduYWxfcGVlcl9ncm91cHNfY2hhbmdlZCh3cGFfcy0+cGFyZW50LCBwZWVyX2FkZHIpOworCiAJcmV0dXJuOwogCiBlcnI6CkBAIC0yNDYyLDYgKzI1MzgsMTIgQEAKIAkJICBFTkRfQVJHUwogCSAgfQogCX0sCisJeyAiUmVhdHRhY2giLCBXUEFTX0RCVVNfTkVXX0lGQUNFX0lOVEVSRkFDRSwKKwkgIChXUEFEQnVzTWV0aG9kSGFuZGxlcikgJndwYXNfZGJ1c19oYW5kbGVyX3JlYXR0YWNoLAorCSAgeworCQkgIEVORF9BUkdTCisJICB9CisJfSwKIAl7ICJSZW1vdmVOZXR3b3JrIiwgV1BBU19EQlVTX05FV19JRkFDRV9JTlRFUkZBQ0UsCiAJICAoV1BBREJ1c01ldGhvZEhhbmRsZXIpICZ3cGFzX2RidXNfaGFuZGxlcl9yZW1vdmVfbmV0d29yaywKIAkgIHsKQEAgLTI1MTYsNiArMjU5OCwxNSBAQAogCSAgfQogCX0sCiAjZW5kaWYgLyogQ09ORklHX05PX0NPTkZJR19CTE9CUyAqLworCXsgIlNldFBLQ1MxMUVuZ2luZUFuZE1vZHVsZVBhdGgiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX0lOVEVSRkFDRSwKKwkgIChXUEFEQnVzTWV0aG9kSGFuZGxlcikKKwkgICZ3cGFzX2RidXNfaGFuZGxlcl9zZXRfcGtjczExX2VuZ2luZV9hbmRfbW9kdWxlX3BhdGgsCisJICB7CisJCSAgeyAicGtjczExX2VuZ2luZV9wYXRoIiwgInMiLCBBUkdfSU4gfSwKKwkJICB7ICJwa2NzMTFfbW9kdWxlX3BhdGgiLCAicyIsIEFSR19JTiB9LAorCQkgIEVORF9BUkdTCisJICB9CisJfSwKICNpZmRlZiBDT05GSUdfV1BTCiAJeyAiU3RhcnQiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1dQUywKIAkgIChXUEFEQnVzTWV0aG9kSGFuZGxlcikgJndwYXNfZGJ1c19oYW5kbGVyX3dwc19zdGFydCwKQEAgLTI2MzQsNiArMjcyNSw3IEBACiAJICAoV1BBREJ1c01ldGhvZEhhbmRsZXIpd3Bhc19kYnVzX2hhbmRsZXJfcDJwX3NlcnZpY2Vfc2RfcmVxLAogCSAgewogCQkgIHsgImFyZ3MiLCAiYXtzdn0iLCBBUkdfSU4gfSwKKwkJICB7ICJyZWYiLCAidCIsIEFSR19PVVQgfSwKIAkJICBFTkRfQVJHUwogCSAgfQogCX0sCkBAIC0yNjY0LDEzICsyNzU2LDYgQEAKIAkJICBFTkRfQVJHUwogCSAgfQogCX0sCi0JeyAiU2VydmljZURpc2NvdmVyeUV4dGVybmFsIiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBERVZJQ0UsCi0JICAoV1BBREJ1c01ldGhvZEhhbmRsZXIpd3Bhc19kYnVzX2hhbmRsZXJfcDJwX3NlcnZfZGlzY19leHRlcm5hbCwKLQkgIHsKLQkJICB7ICJhcmciLCAiaSIsIEFSR19JTiB9LAotCQkgIEVORF9BUkdTCi0JICB9Ci0JfSwKIAl7ICJBZGRQZXJzaXN0ZW50R3JvdXAiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUERFVklDRSwKIAkgIChXUEFEQnVzTWV0aG9kSGFuZGxlcikgd3Bhc19kYnVzX2hhbmRsZXJfYWRkX3BlcnNpc3RlbnRfZ3JvdXAsCiAJICB7CkBAIC0yNzM2LDYgKzI4MjEsMzcgQEAKIAkgIH0KIAl9LAogI2VuZGlmIC8qIENPTkZJR19BVVRPU0NBTiAqLworI2lmZGVmIENPTkZJR19URExTCisJeyAiVERMU0Rpc2NvdmVyIiwgV1BBU19EQlVTX05FV19JRkFDRV9JTlRFUkZBQ0UsCisJICAoV1BBREJ1c01ldGhvZEhhbmRsZXIpIHdwYXNfZGJ1c19oYW5kbGVyX3RkbHNfZGlzY292ZXIsCisJICB7CisJCSAgeyAicGVlcl9hZGRyZXNzIiwgInMiLCBBUkdfSU4gfSwKKwkJICBFTkRfQVJHUworCSAgfQorCX0sCisJeyAiVERMU1NldHVwIiwgV1BBU19EQlVTX05FV19JRkFDRV9JTlRFUkZBQ0UsCisJICAoV1BBREJ1c01ldGhvZEhhbmRsZXIpIHdwYXNfZGJ1c19oYW5kbGVyX3RkbHNfc2V0dXAsCisJICB7CisJCSAgeyAicGVlcl9hZGRyZXNzIiwgInMiLCBBUkdfSU4gfSwKKwkJICBFTkRfQVJHUworCSAgfQorCX0sCisJeyAiVERMU1N0YXR1cyIsIFdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLAorCSAgKFdQQURCdXNNZXRob2RIYW5kbGVyKSB3cGFzX2RidXNfaGFuZGxlcl90ZGxzX3N0YXR1cywKKwkgIHsKKwkJICB7ICJwZWVyX2FkZHJlc3MiLCAicyIsIEFSR19JTiB9LAorCQkgIHsgInN0YXR1cyIsICJzIiwgQVJHX09VVCB9LAorCQkgIEVORF9BUkdTCisJICB9CisJfSwKKwl7ICJURExTVGVhcmRvd24iLCBXUEFTX0RCVVNfTkVXX0lGQUNFX0lOVEVSRkFDRSwKKwkgIChXUEFEQnVzTWV0aG9kSGFuZGxlcikgd3Bhc19kYnVzX2hhbmRsZXJfdGRsc190ZWFyZG93biwKKwkgIHsKKwkJICB7ICJwZWVyX2FkZHJlc3MiLCAicyIsIEFSR19JTiB9LAorCQkgIEVORF9BUkdTCisJICB9CisJfSwKKyNlbmRpZiAvKiBDT05GSUdfVERMUyAqLwogCXsgTlVMTCwgTlVMTCwgTlVMTCwgeyBFTkRfQVJHUyB9IH0KIH07CiAKQEAgLTI4MTIsNiArMjkyOCwxNCBAQAogCSAgd3Bhc19kYnVzX2dldHRlcl9zY2FuX2ludGVydmFsLAogCSAgd3Bhc19kYnVzX3NldHRlcl9zY2FuX2ludGVydmFsCiAJfSwKKwl7ICJQS0NTMTFFbmdpbmVQYXRoIiwgV1BBU19EQlVTX05FV19JRkFDRV9JTlRFUkZBQ0UsICJzIiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfcGtjczExX2VuZ2luZV9wYXRoLAorCSAgTlVMTAorCX0sCisJeyAiUEtDUzExTW9kdWxlUGF0aCIsIFdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLCAicyIsCisJICB3cGFzX2RidXNfZ2V0dGVyX3BrY3MxMV9tb2R1bGVfcGF0aCwKKwkgIE5VTEwKKwl9LAogI2lmZGVmIENPTkZJR19XUFMKIAl7ICJQcm9jZXNzQ3JlZGVudGlhbHMiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1dQUywgImIiLAogCSAgd3Bhc19kYnVzX2dldHRlcl9wcm9jZXNzX2NyZWRlbnRpYWxzLApAQCAtMjk0MSw3ICszMDY1LDYgQEAKIAl7ICJEZXZpY2VGb3VuZCIsIFdQQVNfREJVU19ORVdfSUZBQ0VfUDJQREVWSUNFLAogCSAgewogCQkgIHsgInBhdGgiLCAibyIsIEFSR19PVVQgfSwKLQkJICB7ICJwcm9wZXJ0aWVzIiwgImF7c3Z9IiwgQVJHX09VVCB9LAogCQkgIEVORF9BUkdTCiAJICB9CiAJfSwKQEAgLTMwMDQsMTIgKzMxMjcsMTMgQEAKIAl9LAogCXsgIkdPTmVnb3RpYXRpb25TdWNjZXNzIiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBERVZJQ0UsCiAJICB7CisJCSAgeyAicHJvcGVydGllcyIsICJhe3N2fSIsIEFSR19PVVQgfSwKIAkJICBFTkRfQVJHUwogCSAgfQogCX0sCiAJeyAiR09OZWdvdGlhdGlvbkZhaWx1cmUiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUERFVklDRSwKIAkgIHsKLQkJICB7ICJzdGF0dXMiLCAiaSIsIEFSR19PVVQgfSwKKwkJICB7ICJwcm9wZXJ0aWVzIiwgImF7c3Z9IiwgQVJHX09VVCB9LAogCQkgIEVORF9BUkdTCiAJICB9CiAJfSwKQEAgLTMwMjgsOCArMzE1Miw3IEBACiAJfSwKIAl7ICJHcm91cEZpbmlzaGVkIiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBERVZJQ0UsCiAJICB7Ci0JCSAgeyAiaWZuYW1lIiwgInMiLCBBUkdfT1VUIH0sCi0JCSAgeyAicm9sZSIsICJzIiwgQVJHX09VVCB9LAorCQkgIHsgInByb3BlcnRpZXMiLCAiYXtzdn0iLCBBUkdfT1VUIH0sCiAJCSAgRU5EX0FSR1MKIAkgIH0KIAl9LApAQCAtMzIyNiwxMSArMzM0OSwyNSBAQAogCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfcGVlcl9pZXMsCiAJICBOVUxMCiAJfSwKKwl7ICJEZXZpY2VBZGRyZXNzIiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBfUEVFUiwgImF5IiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX3BlZXJfZGV2aWNlX2FkZHJlc3MsCisJICBOVUxMCisJfSwKKwl7ICJHcm91cHMiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9QRUVSLCAiYW8iLAorCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfcGVlcl9ncm91cHMsCisJICBOVUxMCisJfSwKIAl7IE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwgfQogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCB3cGFfZGJ1c19zaWduYWxfZGVzYyB3cGFzX2RidXNfcDJwX3BlZXJfc2lnbmFsc1tdID0gewotCisJLyogRGVwcmVjYXRlZDogdXNlIG9yZy5mcmVlZGVza3RvcC5EQnVzLlByb3BlcnRpZXMuUHJvcGVydGllc0NoYW5nZWQgKi8KKwl7ICJQcm9wZXJ0aWVzQ2hhbmdlZCIsIFdQQVNfREJVU19ORVdfSUZBQ0VfUDJQX1BFRVIsCisJICB7CisJCSAgeyAicHJvcGVydGllcyIsICJhe3N2fSIsIEFSR19PVVQgfSwKKwkJICBFTkRfQVJHUworCSAgfQorCX0sCiAJeyBOVUxMLCBOVUxMLCB7IEVORF9BUkdTIH0gfQogfTsKIApAQCAtMzQxNCw2ICszNTUxLDIwIEBACiB9CiAKIAordm9pZCB3cGFzX2RidXNfc2lnbmFsX3BlZXJfZ3JvdXBzX2NoYW5nZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICBjb25zdCB1OCAqZGV2X2FkZHIpCit7CisJY2hhciBwZWVyX29ial9wYXRoW1dQQVNfREJVU19PQkpFQ1RfUEFUSF9NQVhdOworCisJb3Nfc25wcmludGYocGVlcl9vYmpfcGF0aCwgV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWCwKKwkJICAgICIlcy8iIFdQQVNfREJVU19ORVdfUDJQX1BFRVJTX1BBUlQgIi8iIENPTVBBQ1RfTUFDU1RSLAorCQkgICAgd3BhX3MtPmRidXNfbmV3X3BhdGgsIE1BQzJTVFIoZGV2X2FkZHIpKTsKKworCXdwYV9kYnVzX21hcmtfcHJvcGVydHlfY2hhbmdlZCh3cGFfcy0+Z2xvYmFsLT5kYnVzLCBwZWVyX29ial9wYXRoLAorCQkJCSAgICAgICBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9QRUVSLCAiR3JvdXBzIik7Cit9CisKKwogc3RhdGljIGNvbnN0IHN0cnVjdCB3cGFfZGJ1c19wcm9wZXJ0eV9kZXNjIHdwYXNfZGJ1c19wMnBfZ3JvdXBfcHJvcGVydGllc1tdID0gewogCXsgIk1lbWJlcnMiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9HUk9VUCwgImFvIiwKIAkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX21lbWJlcnMsCkBAIC0zNTU5LDYgKzM3MTAsOCBAQAogCQlyZXR1cm47CiAJfQogCisJcGVlcl9ncm91cHNfY2hhbmdlZCh3cGFfcyk7CisKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgImRidXM6IFVucmVnaXN0ZXIgZ3JvdXAgb2JqZWN0ICclcyciLAogCQkgICB3cGFfcy0+ZGJ1c19ncm91cG9ial9wYXRoKTsKIApAQCAtMzU3MCwxMDkgKzM3MjMsNiBAQAogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHdwYV9kYnVzX3Byb3BlcnR5X2Rlc2MKLXdwYXNfZGJ1c19wMnBfZ3JvdXBtZW1iZXJfcHJvcGVydGllc1tdID0gewotCXsgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCB9Ci19OwotCi0vKioKLSAqIHdwYXNfZGJ1c19yZWdpc3Rlcl9wMnBfZ3JvdXBtZW1iZXIgLSBSZWdpc3RlciBhIHAycCBncm91cG1lbWJlcgotICogb2JqZWN0IHdpdGggZGJ1cwotICogQHdwYV9zOiB3cGFfc3VwcGxpY2FudCBpbnRlcmZhY2Ugc3RydWN0dXJlCi0gKiBAcDJwX2lmX2FkZHI6IGkvZiBhZGRyIG9mIHRoZSBkZXZpY2Ugam9pbmluZyB0aGlzIGdyb3VwCi0gKgotICogUmVnaXN0ZXJzIHAycCBncm91cG1lbWJlciByZXByZXNlbnRpbmcgb2JqZWN0IHdpdGggZGJ1cwotICovCi12b2lkIHdwYXNfZGJ1c19yZWdpc3Rlcl9wMnBfZ3JvdXBtZW1iZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkJY29uc3QgdTggKnAycF9pZl9hZGRyKQotewotCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqY3RybF9pZmFjZTsKLQlzdHJ1Y3Qgd3BhX2RidXNfb2JqZWN0X2Rlc2MgKm9ial9kZXNjID0gTlVMTDsKLQlzdHJ1Y3QgZ3JvdXBtZW1iZXJfaGFuZGxlcl9hcmdzICphcmc7Ci0JY2hhciBncm91cG1lbWJlcl9vYmpfcGF0aFtXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYXTsKLQotCS8qIERvIG5vdGhpbmcgaWYgdGhlIGNvbnRyb2wgaW50ZXJmYWNlIGlzIG5vdCB0dXJuZWQgb24gKi8KLQlpZiAod3BhX3MgPT0gTlVMTCB8fCB3cGFfcy0+Z2xvYmFsID09IE5VTEwpCi0JCXJldHVybjsKLQotCWN0cmxfaWZhY2UgPSB3cGFfcy0+Z2xvYmFsLT5kYnVzOwotCWlmIChjdHJsX2lmYWNlID09IE5VTEwpCi0JCXJldHVybjsKLQotCWlmICghd3BhX3MtPmRidXNfZ3JvdXBvYmpfcGF0aCkKLQkJcmV0dXJuOwotCi0Jb3Nfc25wcmludGYoZ3JvdXBtZW1iZXJfb2JqX3BhdGgsIFdQQVNfREJVU19PQkpFQ1RfUEFUSF9NQVgsCi0JCSIlcy8iIFdQQVNfREJVU19ORVdfUDJQX0dST1VQTUVNQkVSU19QQVJUICIvIiBDT01QQUNUX01BQ1NUUiwKLQkJd3BhX3MtPmRidXNfZ3JvdXBvYmpfcGF0aCwgTUFDMlNUUihwMnBfaWZfYWRkcikpOwotCi0Jb2JqX2Rlc2MgPSBvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCB3cGFfZGJ1c19vYmplY3RfZGVzYykpOwotCWlmICghb2JqX2Rlc2MpIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJOb3QgZW5vdWdoIG1lbW9yeSAiCi0JCQkgICAidG8gY3JlYXRlIG9iamVjdCBkZXNjcmlwdGlvbiIpOwotCQlnb3RvIGVycjsKLQl9Ci0KLQkvKiBhbGxvY2F0ZSBtZW1vcnkgZm9yIGhhbmRsZXJzIGFyZ3VtZW50cyAqLwotCWFyZyA9IG9zX3phbGxvYyhzaXplb2Yoc3RydWN0IGdyb3VwbWVtYmVyX2hhbmRsZXJfYXJncykpOwotCWlmICghYXJnKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTm90IGVub3VnaCBtZW1vcnkgIgotCQkJICAgInRvIGNyZWF0ZSBhcmd1bWVudHMgZm9yIG1ldGhvZCIpOwotCQlnb3RvIGVycjsKLQl9Ci0KLQlhcmctPndwYV9zID0gd3BhX3M7Ci0Jb3NfbWVtY3B5KGFyZy0+bWVtYmVyX2FkZHIsIHAycF9pZl9hZGRyLCBFVEhfQUxFTik7Ci0KLQl3cGFzX2RidXNfcmVnaXN0ZXIob2JqX2Rlc2MsIGFyZywgd3BhX2RidXNfZnJlZSwgTlVMTCwKLQkJCSAgIHdwYXNfZGJ1c19wMnBfZ3JvdXBtZW1iZXJfcHJvcGVydGllcywgTlVMTCk7Ci0KLQlpZiAod3BhX2RidXNfcmVnaXN0ZXJfb2JqZWN0X3Blcl9pZmFjZShjdHJsX2lmYWNlLCBncm91cG1lbWJlcl9vYmpfcGF0aCwKLQkJCQkJICAgICAgIHdwYV9zLT5pZm5hbWUsIG9ial9kZXNjKSkKLQkJZ290byBlcnI7Ci0KLQl3cGFfcHJpbnRmKE1TR19JTkZPLAotCQkgICAiZGJ1czogUmVnaXN0ZXJlZCBncm91cCBtZW1iZXIgb2JqZWN0ICclcycgc3VjY2Vzc2Z1bGx5IiwKLQkJICAgZ3JvdXBtZW1iZXJfb2JqX3BhdGgpOwotCXJldHVybjsKLQotZXJyOgotCWZyZWVfZGJ1c19vYmplY3RfZGVzYyhvYmpfZGVzYyk7Ci19Ci0KLS8qKgotICogd3Bhc19kYnVzX3VucmVnaXN0ZXJfcDJwX2dyb3VwbWVtYmVyIC0gVW5yZWdpc3RlciBhIHAycCBncm91cG1lbWJlcgotICogb2JqZWN0IHdpdGggZGJ1cwotICogQHdwYV9zOiB3cGFfc3VwcGxpY2FudCBpbnRlcmZhY2Ugc3RydWN0dXJlCi0gKiBAcDJwX2lmX2FkZHI6IGkvZiBhZGRyIG9mIHRoZSBkZXZpY2Ugam9pbmluZyB0aGlzIGdyb3VwCi0gKgotICogVW5yZWdpc3RlcnMgcDJwIGdyb3VwbWVtYmVyIHJlcHJlc2VudGluZyBvYmplY3Qgd2l0aCBkYnVzCi0gKi8KLXZvaWQgd3Bhc19kYnVzX3VucmVnaXN0ZXJfcDJwX2dyb3VwbWVtYmVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgY29uc3QgdTggKnAycF9pZl9hZGRyKQotewotCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqY3RybF9pZmFjZTsKLQljaGFyIGdyb3VwbWVtYmVyX29ial9wYXRoW1dQQVNfREJVU19PQkpFQ1RfUEFUSF9NQVhdOwotCi0JLyogRG8gbm90aGluZyBpZiB0aGUgY29udHJvbCBpbnRlcmZhY2UgaXMgbm90IHR1cm5lZCBvbiAqLwotCWlmICh3cGFfcyA9PSBOVUxMIHx8IHdwYV9zLT5nbG9iYWwgPT0gTlVMTCkKLQkJcmV0dXJuOwotCi0JY3RybF9pZmFjZSA9IHdwYV9zLT5nbG9iYWwtPmRidXM7Ci0JaWYgKGN0cmxfaWZhY2UgPT0gTlVMTCkKLQkJcmV0dXJuOwotCi0JaWYgKCF3cGFfcy0+ZGJ1c19ncm91cG9ial9wYXRoKQotCQlyZXR1cm47Ci0KLQlvc19zbnByaW50Zihncm91cG1lbWJlcl9vYmpfcGF0aCwgV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWCwKLQkJIiVzLyIgV1BBU19EQlVTX05FV19QMlBfR1JPVVBNRU1CRVJTX1BBUlQgIi8iIENPTVBBQ1RfTUFDU1RSLAotCQl3cGFfcy0+ZGJ1c19ncm91cG9ial9wYXRoLCBNQUMyU1RSKHAycF9pZl9hZGRyKSk7Ci0KLQl3cGFfZGJ1c191bnJlZ2lzdGVyX29iamVjdF9wZXJfaWZhY2UoY3RybF9pZmFjZSwgZ3JvdXBtZW1iZXJfb2JqX3BhdGgpOwotfQotCi0KLXN0YXRpYyBjb25zdCBzdHJ1Y3Qgd3BhX2RidXNfcHJvcGVydHlfZGVzYwogCXdwYXNfZGJ1c19wZXJzaXN0ZW50X2dyb3VwX3Byb3BlcnRpZXNbXSA9IHsKIAl7ICJQcm9wZXJ0aWVzIiwgV1BBU19EQlVTX05FV19JRkFDRV9QRVJTSVNURU5UX0dST1VQLCAiYXtzdn0iLAogCSAgd3Bhc19kYnVzX2dldHRlcl9wZXJzaXN0ZW50X2dyb3VwX3Byb3BlcnRpZXMsCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3LmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3LmgKaW5kZXggNjFjNDgwYS4uODgxZDM1MSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ldy5oCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXcuaApAQCAtNzksMTEgKzc5LDcgQEAKICNkZWZpbmUgV1BBU19EQlVTX05FV19QMlBfUEVFUlNfUEFSVAkiUGVlcnMiCiAjZGVmaW5lCVdQQVNfREJVU19ORVdfSUZBQ0VfUDJQX1BFRVIgV1BBU19EQlVTX05FV19JTlRFUkZBQ0UgIi5QZWVyIgogCi0jZGVmaW5lIFdQQVNfREJVU19ORVdfUDJQX0dST1VQTUVNQkVSU19QQVJUCSJNZW1iZXJzIgotI2RlZmluZQlXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9HUk9VUE1FTUJFUiBcCi0JV1BBU19EQlVTX05FV19JTlRFUkZBQ0UgIi5Hcm91cE1lbWJlciIKLQotLyogRXJyb3JzICovCisvKiBUb3AtbGV2ZWwgRXJyb3JzICovCiAjZGVmaW5lIFdQQVNfREJVU19FUlJPUl9VTktOT1dOX0VSUk9SIFwKIAlXUEFTX0RCVVNfTkVXX0lOVEVSRkFDRSAiLlVua25vd25FcnJvciIKICNkZWZpbmUgV1BBU19EQlVTX0VSUk9SX0lOVkFMSURfQVJHUyBcCkBAIC05MSw2ICs4Nyw4IEBACiAKICNkZWZpbmUgV1BBU19EQlVTX0VSUk9SX0lGQUNFX0VYSVNUUyBcCiAJV1BBU19EQlVTX05FV19JTlRFUkZBQ0UgIi5JbnRlcmZhY2VFeGlzdHMiCisjZGVmaW5lIFdQQVNfREJVU19FUlJPUl9JRkFDRV9ESVNBQkxFRCAgICAgICAgICAgIFwKKwlXUEFTX0RCVVNfTkVXX0lOVEVSRkFDRSAiLkludGVyZmFjZURpc2FibGVkIgogI2RlZmluZSBXUEFTX0RCVVNfRVJST1JfSUZBQ0VfVU5LTk9XTiBcCiAJV1BBU19EQlVTX05FV19JTlRFUkZBQ0UgIi5JbnRlcmZhY2VVbmtub3duIgogCkBAIC0xMTgsNiArMTE2LDkgQEAKICNkZWZpbmUgV1BBU19EQlVTX0VSUk9SX1NVQlNDUklQVElPTl9FUEVSTSBcCiAJV1BBU19EQlVTX05FV19JTlRFUkZBQ0UgIi5TdWJzY3JpcHRpb25Ob3RZb3UiCiAKKy8qIEludGVyZmFjZS1sZXZlbCBlcnJvcnMgKi8KKyNkZWZpbmUgV1BBU19EQlVTX0VSUk9SX0lGQUNFX1NDQU5fRVJST1IgXAorCVdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFICIuU2NhbkVycm9yIgogCiB2b2lkIHdwYXNfZGJ1c19zdWJzY3JpYmVfbm9jKHN0cnVjdCB3cGFzX2RidXNfcHJpdiAqcHJpdik7CiB2b2lkIHdwYXNfZGJ1c191bnN1YnNjcmliZV9ub2Moc3RydWN0IHdwYXNfZGJ1c19wcml2ICpwcml2KTsKQEAgLTE3Miw2ICsxNzMsOCBAQAogCQkJCSAgY29uc3QgdTggKmRldl9hZGRyKTsKIHZvaWQgd3Bhc19kYnVzX3NpZ25hbF9wZWVyX2RldmljZV9sb3N0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSAgIGNvbnN0IHU4ICpkZXZfYWRkcik7Cit2b2lkIHdwYXNfZGJ1c19zaWduYWxfcGVlcl9ncm91cHNfY2hhbmdlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgIGNvbnN0IHU4ICpkZXZfYWRkcik7CiB2b2lkIHdwYXNfZGJ1c19zaWduYWxfcDJwX2dyb3VwX3JlbW92ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJY29uc3QgY2hhciAqcm9sZSk7CiB2b2lkIHdwYXNfZGJ1c19zaWduYWxfcDJwX3Byb3Zpc2lvbl9kaXNjb3Zlcnkoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKQEAgLTE5NiwxMCArMTk5LDYgQEAKIAkJCQkJICBpbnQgbmlkKTsKIHZvaWQgd3Bhc19kYnVzX3NpZ25hbF9wMnBfaW52aXRhdGlvbl9yZXN1bHQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICAgIGludCBzdGF0dXMsIGNvbnN0IHU4ICpic3NpZCk7Ci12b2lkIHdwYXNfZGJ1c19yZWdpc3Rlcl9wMnBfZ3JvdXBtZW1iZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkJY29uc3QgdTggKnAycF9pZl9hZGRyKTsKLXZvaWQgd3Bhc19kYnVzX3VucmVnaXN0ZXJfcDJwX2dyb3VwbWVtYmVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgY29uc3QgdTggKnAycF9pZl9hZGRyKTsKIHZvaWQgd3Bhc19kYnVzX3NpZ25hbF9wMnBfcGVlcl9kaXNjb25uZWN0ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICAgIGNvbnN0IHU4ICptZW1iZXIpOwogdm9pZCB3cGFzX2RidXNfc2lnbmFsX3AycF9zZF9yZXF1ZXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCkBAIC0zNTUsNiArMzU0LDEyIEBACiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZAord3Bhc19kYnVzX3NpZ25hbF9wZWVyX2dyb3Vwc19jaGFuZ2VkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICBjb25zdCB1OCAqZGV2X2FkZHIpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAogd3Bhc19kYnVzX3NpZ25hbF9wMnBfZ3JvdXBfcmVtb3ZlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgIGNvbnN0IGNoYXIgKnJvbGUpCiB7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzLmMgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzLmMKaW5kZXggNDc4ZDAyZi4uNmRjNWY3NiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVycy5jCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnMuYwpAQCAtMjgsMTAgKzI4LDYgQEAKICNpbmNsdWRlICJkYnVzX2RpY3RfaGVscGVycy5oIgogI2luY2x1ZGUgImRidXNfY29tbW9uX2kuaCIKIAotZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7Ci1leHRlcm4gaW50IHdwYV9kZWJ1Z19zaG93X2tleXM7Ci1leHRlcm4gaW50IHdwYV9kZWJ1Z190aW1lc3RhbXA7Ci0KIHN0YXRpYyBjb25zdCBjaGFyICpkZWJ1Z19zdHJpbmdzW10gPSB7CiAJImV4Y2Vzc2l2ZSIsICJtc2dkdW1wIiwgImRlYnVnIiwgImluZm8iLCAid2FybmluZyIsICJlcnJvciIsIE5VTEwKIH07CkBAIC0xMjAsNiArMTE2LDI3IEBACiB9CiAKIAorLyoqCisgKiB3cGFzX2RidXNfZXJyb3Jfc2Nhbl9lcnJvciAtIFJldHVybiBhIG5ldyBTY2FuRXJyb3IgZXJyb3IgbWVzc2FnZQorICogQG1lc3NhZ2U6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlIHRoaXMgZXJyb3IgcmVmZXJzIHRvCisgKiBAZXJyb3I6IE9wdGlvbmFsIHN0cmluZyB0byBiZSB1c2VkIGFzIHRoZSBlcnJvciBtZXNzYWdlCisgKiBSZXR1cm5zOiBhIGRidXMgZXJyb3IgbWVzc2FnZQorICoKKyAqIENvbnZlbmllbmNlIGZ1bmN0aW9uIHRvIGNyZWF0ZSBhbmQgcmV0dXJuIGEgc2NhbiBlcnJvcgorICovCitEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19lcnJvcl9zY2FuX2Vycm9yKERCdXNNZXNzYWdlICptZXNzYWdlLAorCQkJCQkgY29uc3QgY2hhciAqZXJyb3IpCit7CisJREJ1c01lc3NhZ2UgKnJlcGx5OworCisJcmVwbHkgPSBkYnVzX21lc3NhZ2VfbmV3X2Vycm9yKG1lc3NhZ2UsCisJCQkJICAgICAgIFdQQVNfREJVU19FUlJPUl9JRkFDRV9TQ0FOX0VSUk9SLAorCQkJCSAgICAgICBlcnJvcik7CisKKwlyZXR1cm4gcmVwbHk7Cit9CisKKwogc3RhdGljIGNvbnN0IGNoYXIgKmRvbnRfcXVvdGVbXSA9IHsKIAkia2V5X21nbXQiLCAicHJvdG8iLCAicGFpcndpc2UiLCAiYXV0aF9hbGciLCAiZ3JvdXAiLCAiZWFwIiwKIAkib3BlbnNjX2VuZ2luZV9wYXRoIiwgInBrY3MxMV9lbmdpbmVfcGF0aCIsICJwa2NzMTFfbW9kdWxlX3BhdGgiLApAQCAtMjU0LDYgKzI3MSw3IEBACiAJCQl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOwogCiAJCW9zX2ZyZWUodmFsdWUpOworCQl2YWx1ZSA9IE5VTEw7CiAJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKIAl9CiAKQEAgLTQyMiw4ICs0NDAsMTMgQEAKIAl9CiAKIAlmb3IgKGkgPSAwOyBpIDwgYXJyYXlfbGVuOyBpKyspIHsKLQkJZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljKCZhcnJheV9pdGVyLCB0eXBlLAotCQkJCQkgICAgICAgYXJyYXkgKyBpICogZWxlbWVudF9zaXplKTsKKwkJaWYgKCFkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMoJmFycmF5X2l0ZXIsIHR5cGUsCisJCQkJCQkgICAgYXJyYXkgKyBpICogZWxlbWVudF9zaXplKSkgeworCQkJZGJ1c19zZXRfZXJyb3IoZXJyb3IsIERCVVNfRVJST1JfRkFJTEVELAorCQkJCSAgICAgICAiJXM6IGZhaWxlZCB0byBjb25zdHJ1Y3QgbWVzc2FnZSAyLjUiLAorCQkJCSAgICAgICBfX2Z1bmNfXyk7CisJCQlyZXR1cm4gRkFMU0U7CisJCX0KIAl9CiAKIAlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lcigmdmFyaWFudF9pdGVyLCAmYXJyYXlfaXRlcikpIHsKQEAgLTQ4OSw3ICs1MTIsNyBAQAogCQlyZXR1cm4gRkFMU0U7CiAJfQogCi0JZm9yIChpID0gMDsgaSA8IGFycmF5X2xlbjsgaSsrKSB7CisJZm9yIChpID0gMDsgaSA8IGFycmF5X2xlbiAmJiBhcnJheVtpXTsgaSsrKSB7CiAJCXdwYV9kYnVzX2RpY3RfYmluX2FycmF5X2FkZF9lbGVtZW50KCZhcnJheV9pdGVyLAogCQkJCQkJICAgIHdwYWJ1Zl9oZWFkKGFycmF5W2ldKSwKIAkJCQkJCSAgICB3cGFidWZfbGVuKGFycmF5W2ldKSk7CkBAIC01NDQsMjQgKzU2NywyOCBAQAogCQkJZ290byBlcnJvcjsKIAkJaWYgKCFvc19zdHJjbXAoZW50cnkua2V5LCAiRHJpdmVyIikgJiYKIAkJICAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CisJCQlvc19mcmVlKGRyaXZlcik7CiAJCQlkcml2ZXIgPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKIAkJCWlmIChkcml2ZXIgPT0gTlVMTCkKIAkJCQlnb3RvIGVycm9yOwogCQl9IGVsc2UgaWYgKCFvc19zdHJjbXAoZW50cnkua2V5LCAiSWZuYW1lIikgJiYKIAkJCSAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CisJCQlvc19mcmVlKGlmbmFtZSk7CiAJCQlpZm5hbWUgPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKIAkJCWlmIChpZm5hbWUgPT0gTlVMTCkKIAkJCQlnb3RvIGVycm9yOwogCQl9IGVsc2UgaWYgKCFvc19zdHJjbXAoZW50cnkua2V5LCAiQ29uZmlnRmlsZSIpICYmCiAJCQkgICAoZW50cnkudHlwZSA9PSBEQlVTX1RZUEVfU1RSSU5HKSkgeworCQkJb3NfZnJlZShjb25mbmFtZSk7CiAJCQljb25mbmFtZSA9IG9zX3N0cmR1cChlbnRyeS5zdHJfdmFsdWUpOwogCQkJd3BhX2RidXNfZGljdF9lbnRyeV9jbGVhcigmZW50cnkpOwogCQkJaWYgKGNvbmZuYW1lID09IE5VTEwpCiAJCQkJZ290byBlcnJvcjsKIAkJfSBlbHNlIGlmICghb3Nfc3RyY21wKGVudHJ5LmtleSwgIkJyaWRnZUlmbmFtZSIpICYmCiAJCQkgICAoZW50cnkudHlwZSA9PSBEQlVTX1RZUEVfU1RSSU5HKSkgeworCQkJb3NfZnJlZShicmlkZ2VfaWZuYW1lKTsKIAkJCWJyaWRnZV9pZm5hbWUgPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKIAkJCWlmIChicmlkZ2VfaWZuYW1lID09IE5VTEwpCkBAIC0xMjM2LDYgKzEyNjMsMjMgQEAKIH0KIAogCitzdGF0aWMgaW50IHdwYXNfZGJ1c19nZXRfc2Nhbl9hbGxvd19yb2FtKERCdXNNZXNzYWdlICptZXNzYWdlLAorCQkJCQkgREJ1c01lc3NhZ2VJdGVyICp2YXIsCisJCQkJCSBkYnVzX2Jvb2xfdCAqYWxsb3csCisJCQkJCSBEQnVzTWVzc2FnZSAqKnJlcGx5KQoreworCWlmIChkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYXJnX3R5cGUodmFyKSAhPSBEQlVTX1RZUEVfQk9PTEVBTikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIndwYXNfZGJ1c19oYW5kbGVyX3NjYW5bZGJ1c106ICIKKwkJCSAgICJUeXBlIG11c3QgYmUgYSBib29sZWFuIik7CisJCSpyZXBseSA9IHdwYXNfZGJ1c19lcnJvcl9pbnZhbGlkX2FyZ3MoCisJCQltZXNzYWdlLCAiV3JvbmcgVHlwZSB2YWx1ZSB0eXBlLiBCb29sZWFuIHJlcXVpcmVkIik7CisJCXJldHVybiAtMTsKKwl9CisJZGJ1c19tZXNzYWdlX2l0ZXJfZ2V0X2Jhc2ljKHZhciwgYWxsb3cpOworCXJldHVybiAwOworfQorCisKIC8qKgogICogd3Bhc19kYnVzX2hhbmRsZXJfc2NhbiAtIFJlcXVlc3QgYSB3aXJlbGVzcyBzY2FuIG9uIGFuIGludGVyZmFjZQogICogQG1lc3NhZ2U6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlCkBAIC0xMjU0LDYgKzEyOTgsNyBAQAogCWNoYXIgKmtleSA9IE5VTEwsICp0eXBlID0gTlVMTDsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7CiAJc2l6ZV90IGk7CisJZGJ1c19ib29sX3QgYWxsb3dfcm9hbSA9IDE7CiAKIAlvc19tZW1zZXQoJnBhcmFtcywgMCwgc2l6ZW9mKHBhcmFtcykpOwogCkBAIC0xMjg0LDYgKzEzMjksMTIgQEAKIAkJCWlmICh3cGFzX2RidXNfZ2V0X3NjYW5fY2hhbm5lbHMobWVzc2FnZSwgJnZhcmlhbnRfaXRlciwKIAkJCQkJCQkmcGFyYW1zLCAmcmVwbHkpIDwgMCkKIAkJCQlnb3RvIG91dDsKKwkJfSBlbHNlIGlmIChvc19zdHJjbXAoa2V5LCAiQWxsb3dSb2FtIikgPT0gMCkgeworCQkJaWYgKHdwYXNfZGJ1c19nZXRfc2Nhbl9hbGxvd19yb2FtKG1lc3NhZ2UsCisJCQkJCQkJICAmdmFyaWFudF9pdGVyLAorCQkJCQkJCSAgJmFsbG93X3JvYW0sCisJCQkJCQkJICAmcmVwbHkpIDwgMCkKKwkJCQlnb3RvIG91dDsKIAkJfSBlbHNlIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAid3Bhc19kYnVzX2hhbmRsZXJfc2NhbltkYnVzXTogIgogCQkJCSAgICJVbmtub3duIGFyZ3VtZW50ICVzIiwga2V5KTsKQEAgLTEzMTAsNyArMTM2MSwxMCBAQAogCQkJCSJwYXNzaXZlIHNjYW4iKTsKIAkJCWdvdG8gb3V0OwogCQl9IGVsc2UgaWYgKHBhcmFtcy5mcmVxcyAmJiBwYXJhbXMuZnJlcXNbMF0pIHsKLQkJCXdwYV9zdXBwbGljYW50X3RyaWdnZXJfc2Nhbih3cGFfcywgJnBhcmFtcyk7CisJCQlpZiAod3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHdwYV9zLCAmcGFyYW1zKSkgeworCQkJCXJlcGx5ID0gd3Bhc19kYnVzX2Vycm9yX3NjYW5fZXJyb3IoCisJCQkJCW1lc3NhZ2UsICJTY2FuIHJlcXVlc3QgcmVqZWN0ZWQiKTsKKwkJCX0KIAkJfSBlbHNlIHsKIAkJCXdwYV9zLT5zY2FuX3JlcSA9IE1BTlVBTF9TQ0FOX1JFUTsKIAkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKQEAgLTEzMjMsNyArMTM3NywxMCBAQAogI2lmZGVmIENPTkZJR19BVVRPU0NBTgogCQlhdXRvc2Nhbl9kZWluaXQod3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19BVVRPU0NBTiAqLwotCQl3cGFfc3VwcGxpY2FudF90cmlnZ2VyX3NjYW4od3BhX3MsICZwYXJhbXMpOworCQlpZiAod3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHdwYV9zLCAmcGFyYW1zKSkgeworCQkJcmVwbHkgPSB3cGFzX2RidXNfZXJyb3Jfc2Nhbl9lcnJvcigKKwkJCQltZXNzYWdlLCAiU2NhbiByZXF1ZXN0IHJlamVjdGVkIik7CisJCX0KIAl9IGVsc2UgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIndwYXNfZGJ1c19oYW5kbGVyX3NjYW5bZGJ1c106ICIKIAkJCSAgICJVbmtub3duIHNjYW4gdHlwZTogJXMiLCB0eXBlKTsKQEAgLTEzMzIsNiArMTM4OSw5IEBACiAJCWdvdG8gb3V0OwogCX0KIAorCWlmICghYWxsb3dfcm9hbSkKKwkJd3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPSBzY2FuX29ubHlfaGFuZGxlcjsKKwogb3V0OgogCWZvciAoaSA9IDA7IGkgPCBXUEFTX01BWF9TQ0FOX1NTSURTOyBpKyspCiAJCW9zX2ZyZWUoKHU4ICopIHBhcmFtcy5zc2lkc1tpXS5zc2lkKTsKQEAgLTE0NDIsMTAgKzE1MDIsMTAgQEAKIAogCiAvKioKLSAqIHdwYXNfZGJ1c19oYW5kbGVyX3JlYXNzb2NpYXRlIC0gUmVhc3NvY2lhdGUgdG8gY3VycmVudCBBUAorICogd3Bhc19kYnVzX2hhbmRsZXJfcmVhc3NvY2lhdGUgLSBSZWFzc29jaWF0ZQogICogQG1lc3NhZ2U6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlCiAgKiBAd3BhX3M6IHdwYV9zdXBwbGljYW50IHN0cnVjdHVyZSBmb3IgYSBuZXR3b3JrIGludGVyZmFjZQotICogUmV0dXJuczogTm90Q29ubmVjdGVkIERCdXMgZXJyb3IgbWVzc2FnZSBpZiBub3QgY29ubmVjdGVkCisgKiBSZXR1cm5zOiBJbnRlcmZhY2VEaXNhYmxlZCBEQnVzIGVycm9yIG1lc3NhZ2UgaWYgZGlzYWJsZWQKICAqIG9yIE5VTEwgb3RoZXJ3aXNlLgogICoKICAqIEhhbmRsZXIgZnVuY3Rpb24gZm9yICJSZWFzc29jaWF0ZSIgbWV0aG9kIGNhbGwgb2YgbmV0d29yayBpbnRlcmZhY2UuCkBAIC0xNDUzLDcgKzE1MTMsMzAgQEAKIERCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfcmVhc3NvY2lhdGUoREJ1c01lc3NhZ2UgKm1lc3NhZ2UsCiAJCQkJCSAgICBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogeworCWlmICh3cGFfcy0+d3BhX3N0YXRlICE9IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpIHsKKwkJd3Bhc19yZXF1ZXN0X2Nvbm5lY3Rpb24od3BhX3MpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXR1cm4gZGJ1c19tZXNzYWdlX25ld19lcnJvcihtZXNzYWdlLCBXUEFTX0RCVVNfRVJST1JfSUZBQ0VfRElTQUJMRUQsCisJCQkJICAgICAgIlRoaXMgaW50ZXJmYWNlIGlzIGRpc2FibGVkIik7Cit9CisKKworLyoqCisgKiB3cGFzX2RidXNfaGFuZGxlcl9yZWF0dGFjaCAtIFJlYXR0YWNoIHRvIGN1cnJlbnQgQVAKKyAqIEBtZXNzYWdlOiBQb2ludGVyIHRvIGluY29taW5nIGRidXMgbWVzc2FnZQorICogQHdwYV9zOiB3cGFfc3VwcGxpY2FudCBzdHJ1Y3R1cmUgZm9yIGEgbmV0d29yayBpbnRlcmZhY2UKKyAqIFJldHVybnM6IE5vdENvbm5lY3RlZCBEQnVzIGVycm9yIG1lc3NhZ2UgaWYgbm90IGNvbm5lY3RlZAorICogb3IgTlVMTCBvdGhlcndpc2UuCisgKgorICogSGFuZGxlciBmdW5jdGlvbiBmb3IgIlJlYXR0YWNoIiBtZXRob2QgY2FsbCBvZiBuZXR3b3JrIGludGVyZmFjZS4KKyAqLworREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl9yZWF0dGFjaChEQnVzTWVzc2FnZSAqbWVzc2FnZSwKKwkJCQkJIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CiAJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgIT0gTlVMTCkgeworCQl3cGFfcy0+cmVhdHRhY2ggPSAxOwogCQl3cGFzX3JlcXVlc3RfY29ubmVjdGlvbih3cGFfcyk7CiAJCXJldHVybiBOVUxMOwogCX0KQEAgLTE1MTAsMTYgKzE1OTMsNiBAQAogCiAJd3Bhc19ub3RpZnlfbmV0d29ya19yZW1vdmVkKHdwYV9zLCBzc2lkKTsKIAotCWlmICh3cGFfY29uZmlnX3JlbW92ZV9uZXR3b3JrKHdwYV9zLT5jb25mLCBpZCkgPCAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0VSUk9SLAotCQkJICAgIndwYXNfZGJ1c19oYW5kbGVyX3JlbW92ZV9uZXR3b3JrW2RidXNdOiAiCi0JCQkgICAiZXJyb3Igb2NjdXJyZWQgd2hlbiByZW1vdmluZyBuZXR3b3JrICVkIiwgaWQpOwotCQlyZXBseSA9IHdwYXNfZGJ1c19lcnJvcl91bmtub3duX2Vycm9yKAotCQkJbWVzc2FnZSwgImVycm9yIHJlbW92aW5nIHRoZSBzcGVjaWZpZWQgbmV0d29yayBvbiAiCi0JCQkidGhpcyBpbnRlcmZhY2UuIik7Ci0JCWdvdG8gb3V0OwotCX0KLQogCWlmIChzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQpCiAJCXdwYV9zdXBwbGljYW50X2RlYXV0aGVudGljYXRlKHdwYV9zLAogCQkJCQkgICAgICBXTEFOX1JFQVNPTl9ERUFVVEhfTEVBVklORyk7CkBAIC0xNTMwLDYgKzE2MDMsMTUgQEAKIAkJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDAsIDApOwogCX0KIAorCWlmICh3cGFfY29uZmlnX3JlbW92ZV9uZXR3b3JrKHdwYV9zLT5jb25mLCBpZCkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLAorCQkJICAgIndwYXNfZGJ1c19oYW5kbGVyX3JlbW92ZV9uZXR3b3JrW2RidXNdOiAiCisJCQkgICAiZXJyb3Igb2NjdXJyZWQgd2hlbiByZW1vdmluZyBuZXR3b3JrICVkIiwgaWQpOworCQlyZXBseSA9IHdwYXNfZGJ1c19lcnJvcl91bmtub3duX2Vycm9yKAorCQkJbWVzc2FnZSwgImVycm9yIHJlbW92aW5nIHRoZSBzcGVjaWZpZWQgbmV0d29yayBvbiAiCisJCQkidGhpcyBpbnRlcmZhY2UuIik7CisJCWdvdG8gb3V0OworCX0KIAogb3V0OgogCW9zX2ZyZWUoaWZhY2UpOwpAQCAtMTk3MCw2ICsyMDUyLDIyNyBAQAogfQogCiAKKyNpZmRlZiBDT05GSUdfVERMUworCitzdGF0aWMgaW50IGdldF9wZWVyX2h3YWRkcl9oZWxwZXIoREJ1c01lc3NhZ2UgKm1lc3NhZ2UsIGNvbnN0IGNoYXIgKmZ1bmNfbmFtZSwKKwkJCQkgIHU4ICpwZWVyX2FkZHJlc3MsIERCdXNNZXNzYWdlICoqZXJyb3IpCit7CisJY29uc3QgY2hhciAqcGVlcl9zdHJpbmc7CisKKwkqZXJyb3IgPSBOVUxMOworCisJaWYgKCFkYnVzX21lc3NhZ2VfZ2V0X2FyZ3MobWVzc2FnZSwgTlVMTCwKKwkJCQkgICBEQlVTX1RZUEVfU1RSSU5HLCAmcGVlcl9zdHJpbmcsCisJCQkJICAgREJVU19UWVBFX0lOVkFMSUQpKSB7CisJCSplcnJvciA9IHdwYXNfZGJ1c19lcnJvcl9pbnZhbGlkX2FyZ3MobWVzc2FnZSwgTlVMTCk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoaHdhZGRyX2F0b24ocGVlcl9zdHJpbmcsIHBlZXJfYWRkcmVzcykpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogaW52YWxpZCBhZGRyZXNzICclcyciLAorCQkJICAgZnVuY19uYW1lLCBwZWVyX3N0cmluZyk7CisJCSplcnJvciA9IHdwYXNfZGJ1c19lcnJvcl9pbnZhbGlkX2FyZ3MoCisJCQltZXNzYWdlLCAiSW52YWxpZCBoYXJkd2FyZSBhZGRyZXNzIGZvcm1hdCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworLyoKKyAqIHdwYXNfZGJ1c19oYW5kbGVyX3RkbHNfZGlzY292ZXIgLSBEaXNjb3ZlciBURExTIHBlZXIKKyAqIEBtZXNzYWdlOiBQb2ludGVyIHRvIGluY29taW5nIGRidXMgbWVzc2FnZQorICogQHdwYV9zOiB3cGFfc3VwcGxpY2FudCBzdHJ1Y3R1cmUgZm9yIGEgbmV0d29yayBpbnRlcmZhY2UKKyAqIFJldHVybnM6IE5VTEwgaW5kaWNhdGluZyBzdWNjZXNzIG9yIERCdXMgZXJyb3IgbWVzc2FnZSBvbiBmYWlsdXJlCisgKgorICogSGFuZGxlciBmdW5jdGlvbiBmb3IgIlRETFNEaXNjb3ZlciIgbWV0aG9kIGNhbGwgb2YgbmV0d29yayBpbnRlcmZhY2UuCisgKi8KK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfdGRsc19kaXNjb3ZlcihEQnVzTWVzc2FnZSAqbWVzc2FnZSwKKwkJCQkJICAgICAgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwl1OCBwZWVyW0VUSF9BTEVOXTsKKwlEQnVzTWVzc2FnZSAqZXJyb3JfcmVwbHk7CisJaW50IHJldDsKKworCWlmIChnZXRfcGVlcl9od2FkZHJfaGVscGVyKG1lc3NhZ2UsIF9fZnVuY19fLCBwZWVyLCAmZXJyb3JfcmVwbHkpIDwgMCkKKwkJcmV0dXJuIGVycm9yX3JlcGx5OworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEQlVTIFRETFNfRElTQ09WRVIgIiBNQUNTVFIsIE1BQzJTVFIocGVlcikpOworCisJaWYgKHdwYV90ZGxzX2lzX2V4dGVybmFsX3NldHVwKHdwYV9zLT53cGEpKQorCQlyZXQgPSB3cGFfdGRsc19zZW5kX2Rpc2NvdmVyeV9yZXF1ZXN0KHdwYV9zLT53cGEsIHBlZXIpOworCWVsc2UKKwkJcmV0ID0gd3BhX2Rydl90ZGxzX29wZXIod3BhX3MsIFRETFNfRElTQ09WRVJZX1JFUSwgcGVlcik7CisKKwlpZiAocmV0KSB7CisJCXJldHVybiB3cGFzX2RidXNfZXJyb3JfdW5rbm93bl9lcnJvcigKKwkJCW1lc3NhZ2UsICJlcnJvciBwZXJmb3JtaW5nIFRETFMgZGlzY292ZXJ5Iik7CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKKworLyoKKyAqIHdwYXNfZGJ1c19oYW5kbGVyX3RkbHNfc2V0dXAgLSBTZXR1cCBURExTIHNlc3Npb24KKyAqIEBtZXNzYWdlOiBQb2ludGVyIHRvIGluY29taW5nIGRidXMgbWVzc2FnZQorICogQHdwYV9zOiB3cGFfc3VwcGxpY2FudCBzdHJ1Y3R1cmUgZm9yIGEgbmV0d29yayBpbnRlcmZhY2UKKyAqIFJldHVybnM6IE5VTEwgaW5kaWNhdGluZyBzdWNjZXNzIG9yIERCdXMgZXJyb3IgbWVzc2FnZSBvbiBmYWlsdXJlCisgKgorICogSGFuZGxlciBmdW5jdGlvbiBmb3IgIlRETFNTZXR1cCIgbWV0aG9kIGNhbGwgb2YgbmV0d29yayBpbnRlcmZhY2UuCisgKi8KK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfdGRsc19zZXR1cChEQnVzTWVzc2FnZSAqbWVzc2FnZSwKKwkJCQkJICAgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwl1OCBwZWVyW0VUSF9BTEVOXTsKKwlEQnVzTWVzc2FnZSAqZXJyb3JfcmVwbHk7CisJaW50IHJldDsKKworCWlmIChnZXRfcGVlcl9od2FkZHJfaGVscGVyKG1lc3NhZ2UsIF9fZnVuY19fLCBwZWVyLCAmZXJyb3JfcmVwbHkpIDwgMCkKKwkJcmV0dXJuIGVycm9yX3JlcGx5OworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEQlVTIFRETFNfU0VUVVAgIiBNQUNTVFIsIE1BQzJTVFIocGVlcikpOworCisJd3BhX3RkbHNfcmVtb3ZlKHdwYV9zLT53cGEsIHBlZXIpOworCWlmICh3cGFfdGRsc19pc19leHRlcm5hbF9zZXR1cCh3cGFfcy0+d3BhKSkKKwkJcmV0ID0gd3BhX3RkbHNfc3RhcnQod3BhX3MtPndwYSwgcGVlcik7CisJZWxzZQorCQlyZXQgPSB3cGFfZHJ2X3RkbHNfb3Blcih3cGFfcywgVERMU19TRVRVUCwgcGVlcik7CisKKwlpZiAocmV0KSB7CisJCXJldHVybiB3cGFzX2RidXNfZXJyb3JfdW5rbm93bl9lcnJvcigKKwkJCW1lc3NhZ2UsICJlcnJvciBwZXJmb3JtaW5nIFRETFMgc2V0dXAiKTsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworCisvKgorICogd3Bhc19kYnVzX2hhbmRsZXJfdGRsc19zdGF0dXMgLSBSZXR1cm4gVERMUyBzZXNzaW9uIHN0YXR1cworICogQG1lc3NhZ2U6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlCisgKiBAd3BhX3M6IHdwYV9zdXBwbGljYW50IHN0cnVjdHVyZSBmb3IgYSBuZXR3b3JrIGludGVyZmFjZQorICogUmV0dXJuczogQSBzdHJpbmcgcmVwcmVzZW50aW5nIHRoZSBzdGF0ZSBvZiB0aGUgbGluayB0byB0aGlzIFRETFMgcGVlcgorICoKKyAqIEhhbmRsZXIgZnVuY3Rpb24gZm9yICJURExTU3RhdHVzIiBtZXRob2QgY2FsbCBvZiBuZXR3b3JrIGludGVyZmFjZS4KKyAqLworREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl90ZGxzX3N0YXR1cyhEQnVzTWVzc2FnZSAqbWVzc2FnZSwKKwkJCQkJICAgIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJdTggcGVlcltFVEhfQUxFTl07CisJREJ1c01lc3NhZ2UgKnJlcGx5OworCWNvbnN0IGNoYXIgKnRkbHNfc3RhdHVzOworCisJaWYgKGdldF9wZWVyX2h3YWRkcl9oZWxwZXIobWVzc2FnZSwgX19mdW5jX18sIHBlZXIsICZyZXBseSkgPCAwKQorCQlyZXR1cm4gcmVwbHk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRCVVMgVERMU19TVEFUVVMgIiBNQUNTVFIsIE1BQzJTVFIocGVlcikpOworCisJdGRsc19zdGF0dXMgPSB3cGFfdGRsc19nZXRfbGlua19zdGF0dXMod3BhX3MtPndwYSwgcGVlcik7CisKKwlyZXBseSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX3JldHVybihtZXNzYWdlKTsKKwlkYnVzX21lc3NhZ2VfYXBwZW5kX2FyZ3MocmVwbHksIERCVVNfVFlQRV9TVFJJTkcsCisJCQkJICZ0ZGxzX3N0YXR1cywgREJVU19UWVBFX0lOVkFMSUQpOworCXJldHVybiByZXBseTsKK30KKworCisvKgorICogd3Bhc19kYnVzX2hhbmRsZXJfdGRsc190ZWFyZG93biAtIFRlYXJkb3duIFRETFMgc2Vzc2lvbgorICogQG1lc3NhZ2U6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlCisgKiBAd3BhX3M6IHdwYV9zdXBwbGljYW50IHN0cnVjdHVyZSBmb3IgYSBuZXR3b3JrIGludGVyZmFjZQorICogUmV0dXJuczogTlVMTCBpbmRpY2F0aW5nIHN1Y2Nlc3Mgb3IgREJ1cyBlcnJvciBtZXNzYWdlIG9uIGZhaWx1cmUKKyAqCisgKiBIYW5kbGVyIGZ1bmN0aW9uIGZvciAiVERMU1RlYXJkb3duIiBtZXRob2QgY2FsbCBvZiBuZXR3b3JrIGludGVyZmFjZS4KKyAqLworREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl90ZGxzX3RlYXJkb3duKERCdXNNZXNzYWdlICptZXNzYWdlLAorCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXU4IHBlZXJbRVRIX0FMRU5dOworCURCdXNNZXNzYWdlICplcnJvcl9yZXBseTsKKwlpbnQgcmV0OworCisJaWYgKGdldF9wZWVyX2h3YWRkcl9oZWxwZXIobWVzc2FnZSwgX19mdW5jX18sIHBlZXIsICZlcnJvcl9yZXBseSkgPCAwKQorCQlyZXR1cm4gZXJyb3JfcmVwbHk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRCVVMgVERMU19URUFSRE9XTiAiIE1BQ1NUUiwgTUFDMlNUUihwZWVyKSk7CisKKwlpZiAod3BhX3RkbHNfaXNfZXh0ZXJuYWxfc2V0dXAod3BhX3MtPndwYSkpCisJCXJldCA9IHdwYV90ZGxzX3RlYXJkb3duX2xpbmsoCisJCQl3cGFfcy0+d3BhLCBwZWVyLAorCQkJV0xBTl9SRUFTT05fVERMU19URUFSRE9XTl9VTlNQRUNJRklFRCk7CisJZWxzZQorCQlyZXQgPSB3cGFfZHJ2X3RkbHNfb3Blcih3cGFfcywgVERMU19URUFSRE9XTiwgcGVlcik7CisKKwlpZiAocmV0KSB7CisJCXJldHVybiB3cGFzX2RidXNfZXJyb3JfdW5rbm93bl9lcnJvcigKKwkJCW1lc3NhZ2UsICJlcnJvciBwZXJmb3JtaW5nIFRETFMgdGVhcmRvd24iKTsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworI2VuZGlmIC8qIENPTkZJR19URExTICovCisKKworLyoqCisgKiB3cGFzX2RidXNfaGFuZGxlcl9zZXRfcGtjczExX2VuZ2luZV9hbmRfbW9kdWxlX3BhdGggLSBTZXQgUEtDUyAjMTEgZW5naW5lIGFuZCBtb2R1bGUgcGF0aAorICogQG1lc3NhZ2U6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlCisgKiBAd3BhX3M6ICV3cGFfc3VwcGxpY2FudCBkYXRhIHN0cnVjdHVyZQorICogUmV0dXJuczogQSBkYnVzIG1lc3NhZ2UgY29udGFpbmluZyBhbiBlcnJvciBvbiBmYWlsdXJlIG9yIE5VTEwgb24gc3VjY2VzcworICoKKyAqIFNldHMgdGhlIFBLQ1MgIzExIGVuZ2luZSBhbmQgbW9kdWxlIHBhdGguCisgKi8KK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfc2V0X3BrY3MxMV9lbmdpbmVfYW5kX21vZHVsZV9wYXRoKAorCURCdXNNZXNzYWdlICptZXNzYWdlLCBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCWNoYXIgKnZhbHVlID0gTlVMTDsKKwljaGFyICpwa2NzMTFfZW5naW5lX3BhdGggPSBOVUxMOworCWNoYXIgKnBrY3MxMV9tb2R1bGVfcGF0aCA9IE5VTEw7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9pbml0KG1lc3NhZ2UsICZpdGVyKTsKKwlkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYmFzaWMoJml0ZXIsICZ2YWx1ZSk7CisJaWYgKHZhbHVlID09IE5VTEwpIHsKKwkJcmV0dXJuIGRidXNfbWVzc2FnZV9uZXdfZXJyb3IoCisJCQltZXNzYWdlLCBEQlVTX0VSUk9SX0lOVkFMSURfQVJHUywKKwkJCSJJbnZhbGlkIHBrY3MxMV9lbmdpbmVfcGF0aCBhcmd1bWVudCIpOworCX0KKwkvKiBFbXB0eSBwYXRoIGRlZmF1bHRzIHRvIE5VTEwgKi8KKwlpZiAob3Nfc3RybGVuKHZhbHVlKSkKKwkJcGtjczExX2VuZ2luZV9wYXRoID0gdmFsdWU7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9uZXh0KCZpdGVyKTsKKwlkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYmFzaWMoJml0ZXIsICZ2YWx1ZSk7CisJaWYgKHZhbHVlID09IE5VTEwpIHsKKwkJb3NfZnJlZShwa2NzMTFfZW5naW5lX3BhdGgpOworCQlyZXR1cm4gZGJ1c19tZXNzYWdlX25ld19lcnJvcigKKwkJCW1lc3NhZ2UsIERCVVNfRVJST1JfSU5WQUxJRF9BUkdTLAorCQkJIkludmFsaWQgcGtjczExX21vZHVsZV9wYXRoIGFyZ3VtZW50Iik7CisJfQorCS8qIEVtcHR5IHBhdGggZGVmYXVsdHMgdG8gTlVMTCAqLworCWlmIChvc19zdHJsZW4odmFsdWUpKQorCQlwa2NzMTFfbW9kdWxlX3BhdGggPSB2YWx1ZTsKKworCWlmICh3cGFzX3NldF9wa2NzMTFfZW5naW5lX2FuZF9tb2R1bGVfcGF0aCh3cGFfcywgcGtjczExX2VuZ2luZV9wYXRoLAorCQkJCQkJICAgcGtjczExX21vZHVsZV9wYXRoKSkKKwkJcmV0dXJuIGRidXNfbWVzc2FnZV9uZXdfZXJyb3IoCisJCQltZXNzYWdlLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCSJSZWluaXQgb2YgdGhlIEVBUE9MIHN0YXRlIG1hY2hpbmUgd2l0aCB0aGUgbmV3IFBLQ1MgIgorCQkJIiMxMSBlbmdpbmUgYW5kIG1vZHVsZSBwYXRoIGZhaWxlZC4iKTsKKworCXdwYV9kYnVzX21hcmtfcHJvcGVydHlfY2hhbmdlZCgKKwkJd3BhX3MtPmdsb2JhbC0+ZGJ1cywgd3BhX3MtPmRidXNfbmV3X3BhdGgsCisJCVdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLCAiUEtDUzExRW5naW5lUGF0aCIpOworCXdwYV9kYnVzX21hcmtfcHJvcGVydHlfY2hhbmdlZCgKKwkJd3BhX3MtPmdsb2JhbC0+ZGJ1cywgd3BhX3MtPmRidXNfbmV3X3BhdGgsCisJCVdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLCAiUEtDUzExTW9kdWxlUGF0aCIpOworCisJcmV0dXJuIE5VTEw7Cit9CisKKwogLyoqCiAgKiB3cGFzX2RidXNfZ2V0dGVyX2NhcGFiaWxpdGllcyAtIFJldHVybiBpbnRlcmZhY2UgY2FwYWJpbGl0aWVzCiAgKiBAaXRlcjogUG9pbnRlciB0byBpbmNvbWluZyBkYnVzIG1lc3NhZ2UgaXRlcgpAQCAtMjAwMyw3ICsyMzA2LDcgQEAKIAkJY29uc3QgY2hhciAqYXJnc1tdID0geyJjY21wIiwgInRraXAiLCAibm9uZSJ9OwogCQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX3N0cmluZ19hcnJheSgKIAkJCSAgICAmaXRlcl9kaWN0LCAiUGFpcndpc2UiLCBhcmdzLAotCQkJICAgIHNpemVvZihhcmdzKSAvIHNpemVvZihjaGFyKikpKQorCQkJICAgIEFSUkFZX1NJWkUoYXJncykpKQogCQkJZ290byBub21lbTsKIAl9IGVsc2UgewogCQlpZiAoIXdwYV9kYnVzX2RpY3RfYmVnaW5fc3RyaW5nX2FycmF5KCZpdGVyX2RpY3QsICJQYWlyd2lzZSIsCkBAIC0yMDEyLDYgKzIzMTUsMTggQEAKIAkJCQkJCSAgICAgICZpdGVyX2FycmF5KSkKIAkJCWdvdG8gbm9tZW07CiAKKwkJaWYgKGNhcGEuZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19DQ01QXzI1NikgeworCQkJaWYgKCF3cGFfZGJ1c19kaWN0X3N0cmluZ19hcnJheV9hZGRfZWxlbWVudCgKKwkJCQkgICAgJml0ZXJfYXJyYXksICJjY21wLTI1NiIpKQorCQkJCWdvdG8gbm9tZW07CisJCX0KKworCQlpZiAoY2FwYS5lbmMgJiBXUEFfRFJJVkVSX0NBUEFfRU5DX0dDTVBfMjU2KSB7CisJCQlpZiAoIXdwYV9kYnVzX2RpY3Rfc3RyaW5nX2FycmF5X2FkZF9lbGVtZW50KAorCQkJCSAgICAmaXRlcl9hcnJheSwgImdjbXAtMjU2IikpCisJCQkJZ290byBub21lbTsKKwkJfQorCiAJCWlmIChjYXBhLmVuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfQ0NNUCkgewogCQkJaWYgKCF3cGFfZGJ1c19kaWN0X3N0cmluZ19hcnJheV9hZGRfZWxlbWVudCgKIAkJCQkgICAgJml0ZXJfYXJyYXksICJjY21wIikpCkBAIC0yMDUwLDcgKzIzNjUsNyBAQAogCQl9OwogCQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX3N0cmluZ19hcnJheSgKIAkJCSAgICAmaXRlcl9kaWN0LCAiR3JvdXAiLCBhcmdzLAotCQkJICAgIHNpemVvZihhcmdzKSAvIHNpemVvZihjaGFyKikpKQorCQkJICAgIEFSUkFZX1NJWkUoYXJncykpKQogCQkJZ290byBub21lbTsKIAl9IGVsc2UgewogCQlpZiAoIXdwYV9kYnVzX2RpY3RfYmVnaW5fc3RyaW5nX2FycmF5KCZpdGVyX2RpY3QsICJHcm91cCIsCkBAIC0yMDU5LDYgKzIzNzQsMTggQEAKIAkJCQkJCSAgICAgICZpdGVyX2FycmF5KSkKIAkJCWdvdG8gbm9tZW07CiAKKwkJaWYgKGNhcGEuZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19DQ01QXzI1NikgeworCQkJaWYgKCF3cGFfZGJ1c19kaWN0X3N0cmluZ19hcnJheV9hZGRfZWxlbWVudCgKKwkJCQkgICAgJml0ZXJfYXJyYXksICJjY21wLTI1NiIpKQorCQkJCWdvdG8gbm9tZW07CisJCX0KKworCQlpZiAoY2FwYS5lbmMgJiBXUEFfRFJJVkVSX0NBUEFfRU5DX0dDTVBfMjU2KSB7CisJCQlpZiAoIXdwYV9kYnVzX2RpY3Rfc3RyaW5nX2FycmF5X2FkZF9lbGVtZW50KAorCQkJCSAgICAmaXRlcl9hcnJheSwgImdjbXAtMjU2IikpCisJCQkJZ290byBub21lbTsKKwkJfQorCiAJCWlmIChjYXBhLmVuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfQ0NNUCkgewogCQkJaWYgKCF3cGFfZGJ1c19kaWN0X3N0cmluZ19hcnJheV9hZGRfZWxlbWVudCgKIAkJCQkgICAgJml0ZXJfYXJyYXksICJjY21wIikpCkBAIC0yMTA3LDcgKzI0MzQsNyBAQAogCQl9OwogCQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX3N0cmluZ19hcnJheSgKIAkJCSAgICAmaXRlcl9kaWN0LCAiS2V5TWdtdCIsIGFyZ3MsCi0JCQkgICAgc2l6ZW9mKGFyZ3MpIC8gc2l6ZW9mKGNoYXIqKSkpCisJCQkgICAgQVJSQVlfU0laRShhcmdzKSkpCiAJCQlnb3RvIG5vbWVtOwogCX0gZWxzZSB7CiAJCWlmICghd3BhX2RidXNfZGljdF9iZWdpbl9zdHJpbmdfYXJyYXkoJml0ZXJfZGljdCwgIktleU1nbXQiLApAQCAtMjE4Nyw3ICsyNTE0LDcgQEAKIAkJY29uc3QgY2hhciAqYXJnc1tdID0geyAicnNuIiwgIndwYSIgfTsKIAkJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF9zdHJpbmdfYXJyYXkoCiAJCQkgICAgJml0ZXJfZGljdCwgIlByb3RvY29sIiwgYXJncywKLQkJCSAgICBzaXplb2YoYXJncykgLyBzaXplb2YoY2hhciopKSkKKwkJCSAgICBBUlJBWV9TSVpFKGFyZ3MpKSkKIAkJCWdvdG8gbm9tZW07CiAJfSBlbHNlIHsKIAkJaWYgKCF3cGFfZGJ1c19kaWN0X2JlZ2luX3N0cmluZ19hcnJheSgmaXRlcl9kaWN0LCAiUHJvdG9jb2wiLApAQCAtMjIyMiw3ICsyNTQ5LDcgQEAKIAkJY29uc3QgY2hhciAqYXJnc1tdID0geyAib3BlbiIsICJzaGFyZWQiLCAibGVhcCIgfTsKIAkJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF9zdHJpbmdfYXJyYXkoCiAJCQkgICAgJml0ZXJfZGljdCwgIkF1dGhBbGciLCBhcmdzLAotCQkJICAgIHNpemVvZihhcmdzKSAvIHNpemVvZihjaGFyKikpKQorCQkJICAgIEFSUkFZX1NJWkUoYXJncykpKQogCQkJZ290byBub21lbTsKIAl9IGVsc2UgewogCQlpZiAoIXdwYV9kYnVzX2RpY3RfYmVnaW5fc3RyaW5nX2FycmF5KCZpdGVyX2RpY3QsICJBdXRoQWxnIiwKQEAgLTIyNTgsNyArMjU4NSw3IEBACiAKIAkvKioqKiogU2NhbiAqLwogCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfc3RyaW5nX2FycmF5KCZpdGVyX2RpY3QsICJTY2FuIiwgc2NhbnMsCi0JCQkJCSAgICAgICBzaXplb2Yoc2NhbnMpIC8gc2l6ZW9mKGNoYXIgKikpKQorCQkJCQkgICAgICAgQVJSQVlfU0laRShzY2FucykpKQogCQlnb3RvIG5vbWVtOwogCiAJLyoqKioqIE1vZGVzICovCkBAIC0yOTg2LDYgKzMzMTMsNzYgQEAKIAogCiAvKioKKyAqIHdwYXNfZGJ1c19nZXR0ZXJfcGtjczExX2VuZ2luZV9wYXRoIC0gR2V0IFBLQ1MgIzExIGVuZ2luZSBwYXRoCisgKiBAaXRlcjogUG9pbnRlciB0byBpbmNvbWluZyBkYnVzIG1lc3NhZ2UgaXRlcgorICogQGVycm9yOiBMb2NhdGlvbiB0byBzdG9yZSBlcnJvciBvbiBmYWlsdXJlCisgKiBAdXNlcl9kYXRhOiBGdW5jdGlvbiBzcGVjaWZpYyBkYXRhCisgKiBSZXR1cm5zOiBBIGRidXMgbWVzc2FnZSBjb250YWluaW5nIHRoZSBQS0NTICMxMSBlbmdpbmUgcGF0aAorICoKKyAqIEdldHRlciBmb3IgIlBLQ1MxMUVuZ2luZVBhdGgiIHByb3BlcnR5LgorICovCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3BrY3MxMV9lbmdpbmVfcGF0aChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCQlEQnVzRXJyb3IgKmVycm9yLAorCQkJCQkJdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSB1c2VyX2RhdGE7CisJY29uc3QgY2hhciAqcGtjczExX2VuZ2luZV9wYXRoOworCisJaWYgKHdwYV9zLT5jb25mID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAid3Bhc19kYnVzX2dldHRlcl9wa2NzMTFfZW5naW5lX3BhdGhbZGJ1c106IEFuICIKKwkJCSAgICJlcnJvciBvY2N1cnJlZCBnZXR0aW5nIHRoZSBQS0NTICMxMSBlbmdpbmUgcGF0aC4iKTsKKwkJZGJ1c19zZXRfZXJyb3JfY29uc3QoCisJCQllcnJvciwgREJVU19FUlJPUl9GQUlMRUQsCisJCQkiQW4gZXJyb3Igb2NjdXJlZCBnZXR0aW5nIHRoZSBQS0NTICMxMSBlbmdpbmUgcGF0aC4iKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCWlmICh3cGFfcy0+Y29uZi0+cGtjczExX2VuZ2luZV9wYXRoID09IE5VTEwpCisJCXBrY3MxMV9lbmdpbmVfcGF0aCA9ICIiOworCWVsc2UKKwkJcGtjczExX2VuZ2luZV9wYXRoID0gd3BhX3MtPmNvbmYtPnBrY3MxMV9lbmdpbmVfcGF0aDsKKwlyZXR1cm4gd3Bhc19kYnVzX3NpbXBsZV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwgREJVU19UWVBFX1NUUklORywKKwkJCQkJCSZwa2NzMTFfZW5naW5lX3BhdGgsIGVycm9yKTsKK30KKworCisvKioKKyAqIHdwYXNfZGJ1c19nZXR0ZXJfcGtjczExX21vZHVsZV9wYXRoIC0gR2V0IFBLQ1MgIzExIG1vZHVsZSBwYXRoCisgKiBAaXRlcjogUG9pbnRlciB0byBpbmNvbWluZyBkYnVzIG1lc3NhZ2UgaXRlcgorICogQGVycm9yOiBMb2NhdGlvbiB0byBzdG9yZSBlcnJvciBvbiBmYWlsdXJlCisgKiBAdXNlcl9kYXRhOiBGdW5jdGlvbiBzcGVjaWZpYyBkYXRhCisgKiBSZXR1cm5zOiBBIGRidXMgbWVzc2FnZSBjb250YWluaW5nIHRoZSBQS0NTICMxMSBtb2R1bGUgcGF0aAorICoKKyAqIEdldHRlciBmb3IgIlBLQ1MxMU1vZHVsZVBhdGgiIHByb3BlcnR5LgorICovCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3BrY3MxMV9tb2R1bGVfcGF0aChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCQlEQnVzRXJyb3IgKmVycm9yLAorCQkJCQkJdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSB1c2VyX2RhdGE7CisJY29uc3QgY2hhciAqcGtjczExX21vZHVsZV9wYXRoOworCisJaWYgKHdwYV9zLT5jb25mID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAid3Bhc19kYnVzX2dldHRlcl9wa2NzMTFfbW9kdWxlX3BhdGhbZGJ1c106IEFuICIKKwkJCSAgICJlcnJvciBvY2N1cnJlZCBnZXR0aW5nIHRoZSBQS0NTICMxMSBtb2R1bGUgcGF0aC4iKTsKKwkJZGJ1c19zZXRfZXJyb3JfY29uc3QoCisJCQllcnJvciwgREJVU19FUlJPUl9GQUlMRUQsCisJCQkiQW4gZXJyb3Igb2NjdXJlZCBnZXR0aW5nIHRoZSBQS0NTICMxMSBtb2R1bGUgcGF0aC4iKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCWlmICh3cGFfcy0+Y29uZi0+cGtjczExX21vZHVsZV9wYXRoID09IE5VTEwpCisJCXBrY3MxMV9tb2R1bGVfcGF0aCA9ICIiOworCWVsc2UKKwkJcGtjczExX21vZHVsZV9wYXRoID0gd3BhX3MtPmNvbmYtPnBrY3MxMV9tb2R1bGVfcGF0aDsKKwlyZXR1cm4gd3Bhc19kYnVzX3NpbXBsZV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwgREJVU19UWVBFX1NUUklORywKKwkJCQkJCSZwa2NzMTFfbW9kdWxlX3BhdGgsIGVycm9yKTsKK30KKworCisvKioKICAqIHdwYXNfZGJ1c19nZXR0ZXJfYmxvYnMgLSBHZXQgYWxsIGJsb2JzIGRlZmluZWQgZm9yIHRoaXMgaW50ZXJmYWNlCiAgKiBAaXRlcjogUG9pbnRlciB0byBpbmNvbWluZyBkYnVzIG1lc3NhZ2UgaXRlcgogICogQGVycm9yOiBMb2NhdGlvbiB0byBzdG9yZSBlcnJvciBvbiBmYWlsdXJlCkBAIC0zMTU5LDExICszNTU2LDIyIEBACiAJcmVzID0gZ2V0X2Jzc19oZWxwZXIoYXJncywgZXJyb3IsIF9fZnVuY19fKTsKIAlpZiAoIXJlcykKIAkJcmV0dXJuIEZBTFNFOwotCi0JaWYgKHJlcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfSUJTUykKLQkJbW9kZSA9ICJhZC1ob2MiOwotCWVsc2UKLQkJbW9kZSA9ICJpbmZyYXN0cnVjdHVyZSI7CisJaWYgKGJzc19pc19kbWcocmVzKSkgeworCQlzd2l0Y2ggKHJlcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfRE1HX01BU0spIHsKKwkJY2FzZSBJRUVFODAyMTFfQ0FQX0RNR19QQlNTOgorCQljYXNlIElFRUU4MDIxMV9DQVBfRE1HX0lCU1M6CisJCQltb2RlID0gImFkLWhvYyI7CisJCQlicmVhazsKKwkJY2FzZSBJRUVFODAyMTFfQ0FQX0RNR19BUDoKKwkJCW1vZGUgPSAiaW5mcmFzdHJ1Y3R1cmUiOworCQkJYnJlYWs7CisJCX0KKwl9IGVsc2UgeworCQlpZiAocmVzLT5jYXBzICYgSUVFRTgwMjExX0NBUF9JQlNTKQorCQkJbW9kZSA9ICJhZC1ob2MiOworCQllbHNlCisJCQltb2RlID0gImluZnJhc3RydWN0dXJlIjsKKwl9CiAKIAlyZXR1cm4gd3Bhc19kYnVzX3NpbXBsZV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwgREJVU19UWVBFX1NUUklORywKIAkJCQkJCSZtb2RlLCBlcnJvcik7CkBAIC0zMjgzLDcgKzM2OTEsNyBAQAogewogCURCdXNNZXNzYWdlSXRlciBpdGVyX2RpY3QsIHZhcmlhbnRfaXRlcjsKIAljb25zdCBjaGFyICpncm91cDsKLQljb25zdCBjaGFyICpwYWlyd2lzZVszXTsgLyogbWF4IDMgcGFpcndpc2UgY2lwaGVycyBpcyBzdXBwb3J0ZWQgKi8KKwljb25zdCBjaGFyICpwYWlyd2lzZVs1XTsgLyogbWF4IDUgcGFpcndpc2UgY2lwaGVycyBpcyBzdXBwb3J0ZWQgKi8KIAljb25zdCBjaGFyICprZXlfbWdtdFs3XTsgLyogbWF4IDcga2V5IG1hbmFnZW1lbnRzIG1heSBiZSBzdXBwb3J0ZWQgKi8KIAlpbnQgbjsKIApAQCAtMzMzMiw2ICszNzQwLDEyIEBACiAJY2FzZSBXUEFfQ0lQSEVSX1dFUDEwNDoKIAkJZ3JvdXAgPSAid2VwMTA0IjsKIAkJYnJlYWs7CisJY2FzZSBXUEFfQ0lQSEVSX0NDTVBfMjU2OgorCQlncm91cCA9ICJjY21wLTI1NiI7CisJCWJyZWFrOworCWNhc2UgV1BBX0NJUEhFUl9HQ01QXzI1NjoKKwkJZ3JvdXAgPSAiZ2NtcC0yNTYiOworCQlicmVhazsKIAlkZWZhdWx0OgogCQlncm91cCA9ICIiOwogCQlicmVhazsKQEAgLTMzNDgsNiArMzc2MiwxMCBAQAogCQlwYWlyd2lzZVtuKytdID0gImNjbXAiOwogCWlmIChpZV9kYXRhLT5wYWlyd2lzZV9jaXBoZXIgJiBXUEFfQ0lQSEVSX0dDTVApCiAJCXBhaXJ3aXNlW24rK10gPSAiZ2NtcCI7CisJaWYgKGllX2RhdGEtPnBhaXJ3aXNlX2NpcGhlciAmIFdQQV9DSVBIRVJfQ0NNUF8yNTYpCisJCXBhaXJ3aXNlW24rK10gPSAiY2NtcC0yNTYiOworCWlmIChpZV9kYXRhLT5wYWlyd2lzZV9jaXBoZXIgJiBXUEFfQ0lQSEVSX0dDTVBfMjU2KQorCQlwYWlyd2lzZVtuKytdID0gImdjbXAtMjU2IjsKIAogCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfc3RyaW5nX2FycmF5KCZpdGVyX2RpY3QsICJQYWlyd2lzZSIsCiAJCQkJCSAgICAgICBwYWlyd2lzZSwgbikpCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzLmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzLmgKaW5kZXggZmJjODM1OC4uNDYxOTcwZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVycy5oCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnMuaApAQCAtMTAxLDYgKzEwMSw5IEBACiBEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19oYW5kbGVyX3JlYXNzb2NpYXRlKERCdXNNZXNzYWdlICptZXNzYWdlLAogCQkJCQkgICAgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiAKK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfcmVhdHRhY2goREJ1c01lc3NhZ2UgKm1lc3NhZ2UsCisJCQkJCSBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKKwogREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl9yZW1vdmVfbmV0d29yayhEQnVzTWVzc2FnZSAqbWVzc2FnZSwKIAkJCQkJICAgICAgIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogCkBAIC0xMjIsNiArMTI1LDkgQEAKIERCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfcmVtb3ZlX2Jsb2IoREJ1c01lc3NhZ2UgKm1lc3NhZ2UsCiAJCQkJCSAgICBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIAorREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl9zZXRfcGtjczExX2VuZ2luZV9hbmRfbW9kdWxlX3BhdGgoCisJREJ1c01lc3NhZ2UgKm1lc3NhZ2UsIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworCiBEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19oYW5kbGVyX2ZsdXNoX2JzcyhEQnVzTWVzc2FnZSAqbWVzc2FnZSwKIAkJCQkJICBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIApAQCAtMjE4LDYgKzIyNCwxNCBAQAogZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9uZXR3b3JrcyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsIERCdXNFcnJvciAqZXJyb3IsCiAJCQkJICAgICAgdm9pZCAqdXNlcl9kYXRhKTsKIAorZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wa2NzMTFfZW5naW5lX3BhdGgoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkJREJ1c0Vycm9yICplcnJvciwKKwkJCQkJCXZvaWQgKnVzZXJfZGF0YSk7CisKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcGtjczExX21vZHVsZV9wYXRoKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJCURCdXNFcnJvciAqZXJyb3IsCisJCQkJCQl2b2lkICp1c2VyX2RhdGEpOworCiBkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX2Jsb2JzKERCdXNNZXNzYWdlSXRlciAqaXRlciwgREJ1c0Vycm9yICplcnJvciwKIAkJCQkgICB2b2lkICp1c2VyX2RhdGEpOwogCkBAIC0yNzgsNiArMjkyLDE1IEBACiAJCQkJCQkgREJ1c0Vycm9yICplcnJvciwKIAkJCQkJCSB2b2lkICp1c2VyX2RhdGEpOwogCitEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19oYW5kbGVyX3RkbHNfZGlzY292ZXIoREJ1c01lc3NhZ2UgKm1lc3NhZ2UsCisJCQkJCSAgICAgIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl90ZGxzX3NldHVwKERCdXNNZXNzYWdlICptZXNzYWdlLAorCQkJCQkgICBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfdGRsc19zdGF0dXMoREJ1c01lc3NhZ2UgKm1lc3NhZ2UsCisJCQkJCSAgICBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfdGRsc190ZWFyZG93bihEQnVzTWVzc2FnZSAqbWVzc2FnZSwKKwkJCQkJICAgICAgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CisKIERCdXNNZXNzYWdlICogd3Bhc19kYnVzX2Vycm9yX2ludmFsaWRfYXJncyhEQnVzTWVzc2FnZSAqbWVzc2FnZSwKIAkJCQkJICAgY29uc3QgY2hhciAqYXJnKTsKIERCdXNNZXNzYWdlICogd3Bhc19kYnVzX2Vycm9yX3Vua25vd25fZXJyb3IoREJ1c01lc3NhZ2UgKm1lc3NhZ2UsCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzX3AycC5jIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVyc19wMnAuYwppbmRleCA2ZWM5NmRmLi5jOWVjYzdiIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzX3AycC5jCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfcDJwLmMKQEAgLTM0NiwxNCArMzQ2LDE0IEBACiAJCWlmIChzc2lkID09IE5VTEwgfHwgc3NpZC0+ZGlzYWJsZWQgIT0gMikKIAkJCWdvdG8gaW52X2FyZ3M7CiAKLQkJaWYgKHdwYXNfcDJwX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHdwYV9zLCBzc2lkLCAwLCBmcmVxLCAwLAotCQkJCQkJICBOVUxMKSkgeworCQlpZiAod3Bhc19wMnBfZ3JvdXBfYWRkX3BlcnNpc3RlbnQod3BhX3MsIHNzaWQsIDAsIGZyZXEsIDAsIDAsIDAsCisJCQkJCQkgIE5VTEwsIDApKSB7CiAJCQlyZXBseSA9IHdwYXNfZGJ1c19lcnJvcl91bmtub3duX2Vycm9yKAogCQkJCW1lc3NhZ2UsCiAJCQkJIkZhaWxlZCB0byByZWludm9rZSBhIHBlcnNpc3RlbnQgZ3JvdXAiKTsKIAkJCWdvdG8gb3V0OwogCQl9Ci0JfSBlbHNlIGlmICh3cGFzX3AycF9ncm91cF9hZGQod3BhX3MsIHBlcnNpc3RlbnRfZ3JvdXAsIGZyZXEsIDApKQorCX0gZWxzZSBpZiAod3Bhc19wMnBfZ3JvdXBfYWRkKHdwYV9zLCBwZXJzaXN0ZW50X2dyb3VwLCBmcmVxLCAwLCAwKSkKIAkJZ290byBpbnZfYXJnczsKIAogb3V0OgpAQCAtNTA1LDcgKzUwNSw3IEBACiAKIAluZXdfcGluID0gd3Bhc19wMnBfY29ubmVjdCh3cGFfcywgYWRkciwgcGluLCB3cHNfbWV0aG9kLAogCQkJCSAgIHBlcnNpc3RlbnRfZ3JvdXAsIDAsIGpvaW4sIGF1dGhvcml6ZV9vbmx5LAotCQkJCSAgIGdvX2ludGVudCwgZnJlcSwgLTEsIDAsIDApOworCQkJCSAgIGdvX2ludGVudCwgZnJlcSwgLTEsIDAsIDAsIDApOwogCiAJaWYgKG5ld19waW4gPj0gMCkgewogCQljaGFyIG5waW5bOV07CkBAIC02MzEsOCArNjMxLDggQEAKIAkJaWYgKHNzaWQgPT0gTlVMTCB8fCBzc2lkLT5kaXNhYmxlZCAhPSAyKQogCQkJZ290byBlcnI7CiAKLQkJaWYgKHdwYXNfcDJwX2ludml0ZSh3cGFfcywgcGVlcl9hZGRyLCBzc2lkLCBOVUxMLCAwLCAwLCAwKSA8IDApCi0JCXsKKwkJaWYgKHdwYXNfcDJwX2ludml0ZSh3cGFfcywgcGVlcl9hZGRyLCBzc2lkLCBOVUxMLCAwLCAwLCAwLCAwKSA8CisJCSAgICAwKSB7CiAJCQlyZXBseSA9IHdwYXNfZGJ1c19lcnJvcl91bmtub3duX2Vycm9yKAogCQkJCW1lc3NhZ2UsCiAJCQkJIkZhaWxlZCB0byByZWludm9rZSBhIHBlcnNpc3RlbnQgZ3JvdXAiKTsKQEAgLTgyNSw2ICs4MjUsMTYgQEAKIAkJCQkJIHdwYV9zLT5jb25mLT5kaXNhc3NvY19sb3dfYWNrKSkKIAkJZ290byBlcnJfbm9fbWVtOwogCisJLyogTm8gR3JvdXAgSWZhY2UgKi8KKwlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX2Jvb2woJmRpY3RfaXRlciwgIk5vR3JvdXBJZmFjZSIsCisJCQkJICAgICAgIHdwYV9zLT5jb25mLT5wMnBfbm9fZ3JvdXBfaWZhY2UpKQorCQlnb3RvIGVycl9ub19tZW07CisKKwkvKiBQMlAgU2VhcmNoIERlbGF5ICovCisJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF91aW50MzIoJmRpY3RfaXRlciwgInAycF9zZWFyY2hfZGVsYXkiLAorCQkJCQkgd3BhX3MtPmNvbmYtPnAycF9zZWFyY2hfZGVsYXkpKQorCQlnb3RvIGVycl9ub19tZW07CisKIAlpZiAoIXdwYV9kYnVzX2RpY3RfY2xvc2Vfd3JpdGUoJnZhcmlhbnRfaXRlciwgJmRpY3RfaXRlcikgfHwKIAkgICAgIWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lcihpdGVyLCAmdmFyaWFudF9pdGVyKSkKIAkJZ290byBlcnJfbm9fbWVtOwpAQCAtOTc0LDYgKzk4NCwxMiBAQAogCQllbHNlIGlmIChvc19zdHJjbXAoZW50cnkua2V5LCAiZGlzYXNzb2NfbG93X2FjayIpID09IDAgJiYKIAkJCSBlbnRyeS50eXBlID09IERCVVNfVFlQRV9VSU5UMzIpCiAJCQl3cGFfcy0+Y29uZi0+ZGlzYXNzb2NfbG93X2FjayA9IGVudHJ5LnVpbnQzMl92YWx1ZTsKKwkJZWxzZSBpZiAob3Nfc3RyY21wKGVudHJ5LmtleSwgIk5vR3JvdXBJZmFjZSIpID09IDAgJiYKKwkJCSBlbnRyeS50eXBlID09IERCVVNfVFlQRV9CT09MRUFOKQorCQkJd3BhX3MtPmNvbmYtPnAycF9ub19ncm91cF9pZmFjZSA9IGVudHJ5LmJvb2xfdmFsdWU7CisJCWVsc2UgaWYgKG9zX3N0cmNtcChlbnRyeS5rZXksICJwMnBfc2VhcmNoX2RlbGF5IikgPT0gMCAmJgorCQkJIGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX1VJTlQzMikKKwkJCXdwYV9zLT5jb25mLT5wMnBfc2VhcmNoX2RlbGF5ID0gZW50cnkudWludDMyX3ZhbHVlOwogCQllbHNlCiAJCQlnb3RvIGVycm9yOwogCkBAIC0xMTI3LDYgKzExNDMsNyBAQAogCQlicmVhazsKIAlkZWZhdWx0OgogCQlzdHIgPSAiZGV2aWNlIjsKKwkJYnJlYWs7CiAJfQogCiAJcmV0dXJuIHdwYXNfZGJ1c19zaW1wbGVfcHJvcGVydHlfZ2V0dGVyKGl0ZXIsIERCVVNfVFlQRV9TVFJJTkcsICZzdHIsCkBAIC0xNDM4LDcgKzE0NTUsNyBAQAogCQkJCQkJICAgICAgIHZvaWQgKnVzZXJfZGF0YSkKIHsKIAlzdHJ1Y3Qgd3BhYnVmICp2ZW5kb3JfZXh0ZW5zaW9uW1AyUF9NQVhfV1BTX1ZFTkRPUl9FWFRdOwotCWludCBpLCBudW07CisJdW5zaWduZWQgaW50IGksIG51bSA9IDA7CiAJc3RydWN0IHBlZXJfaGFuZGxlcl9hcmdzICpwZWVyX2FyZ3MgPSB1c2VyX2RhdGE7CiAJY29uc3Qgc3RydWN0IHAycF9wZWVyX2luZm8gKmluZm87CiAKQEAgLTE0NTEsNyArMTQ2OCw4IEBACiAJfQogCiAJLyogQWRkIFdQUyB2ZW5kb3IgZXh0ZW5zaW9ucyBhdHRyaWJ1dGUgKi8KLQlmb3IgKGkgPSAwLCBudW0gPSAwOyBpIDwgUDJQX01BWF9XUFNfVkVORE9SX0VYVDsgaSsrKSB7CisJb3NfbWVtc2V0KHZlbmRvcl9leHRlbnNpb24sIDAsIHNpemVvZih2ZW5kb3JfZXh0ZW5zaW9uKSk7CisJZm9yIChpID0gMDsgaSA8IFAyUF9NQVhfV1BTX1ZFTkRPUl9FWFQ7IGkrKykgewogCQlpZiAoaW5mby0+d3BzX3ZlbmRvcl9leHRbaV0gPT0gTlVMTCkKIAkJCWNvbnRpbnVlOwogCQl2ZW5kb3JfZXh0ZW5zaW9uW251bV0gPSBpbmZvLT53cHNfdmVuZG9yX2V4dFtpXTsKQEAgLTE0NzAsMTEgKzE0ODgsMTQ1IEBACiBkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9wZWVyX2llcyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCiAJCQkJCSAgREJ1c0Vycm9yICplcnJvciwgdm9pZCAqdXNlcl9kYXRhKQogewotCWRidXNfYm9vbF90IHN1Y2Nlc3M7Ci0JLyogc3RydWN0IHBlZXJfaGFuZGxlcl9hcmdzICpwZWVyX2FyZ3MgPSB1c2VyX2RhdGE7ICovCisJc3RydWN0IHBlZXJfaGFuZGxlcl9hcmdzICpwZWVyX2FyZ3MgPSB1c2VyX2RhdGE7CisJY29uc3Qgc3RydWN0IHAycF9wZWVyX2luZm8gKmluZm87CiAKLQlzdWNjZXNzID0gd3Bhc19kYnVzX3NpbXBsZV9hcnJheV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwgREJVU19UWVBFX0JZVEUsCi0JCQkJCQkJIE5VTEwsIDAsIGVycm9yKTsKKwlpbmZvID0gcDJwX2dldF9wZWVyX2ZvdW5kKHBlZXJfYXJncy0+d3BhX3MtPmdsb2JhbC0+cDJwLAorCQkJCSAgcGVlcl9hcmdzLT5wMnBfZGV2aWNlX2FkZHIsIDApOworCWlmIChpbmZvID09IE5VTEwpIHsKKwkJZGJ1c19zZXRfZXJyb3IoZXJyb3IsIERCVVNfRVJST1JfRkFJTEVELAorCQkJICAgICAgICJmYWlsZWQgdG8gZmluZCBwZWVyIik7CisJCXJldHVybiBGQUxTRTsKKwl9CisKKwlpZiAoaW5mby0+d2ZkX3N1YmVsZW1zID09IE5VTEwpCisJCXJldHVybiB3cGFzX2RidXNfc2ltcGxlX2FycmF5X3Byb3BlcnR5X2dldHRlcihpdGVyLAorCQkJCQkJCSAgICAgIERCVVNfVFlQRV9CWVRFLAorCQkJCQkJCSAgICAgIE5VTEwsIDAsIGVycm9yKTsKKworCXJldHVybiB3cGFzX2RidXNfc2ltcGxlX2FycmF5X3Byb3BlcnR5X2dldHRlcigKKwkJaXRlciwgREJVU19UWVBFX0JZVEUsIChjaGFyICopIGluZm8tPndmZF9zdWJlbGVtcy0+YnVmLAorCQlpbmZvLT53ZmRfc3ViZWxlbXMtPnVzZWQsIGVycm9yKTsKK30KKworCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9wZWVyX2RldmljZV9hZGRyZXNzKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJCSAgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJCSAgICAgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCBwZWVyX2hhbmRsZXJfYXJncyAqcGVlcl9hcmdzID0gdXNlcl9kYXRhOworCWNvbnN0IHN0cnVjdCBwMnBfcGVlcl9pbmZvICppbmZvOworCisJaW5mbyA9IHAycF9nZXRfcGVlcl9mb3VuZChwZWVyX2FyZ3MtPndwYV9zLT5nbG9iYWwtPnAycCwKKwkJCQkgIHBlZXJfYXJncy0+cDJwX2RldmljZV9hZGRyLCAwKTsKKwlpZiAoaW5mbyA9PSBOVUxMKSB7CisJCWRidXNfc2V0X2Vycm9yKGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCSAgICAgICAiZmFpbGVkIHRvIGZpbmQgcGVlciIpOworCQlyZXR1cm4gRkFMU0U7CisJfQorCisJcmV0dXJuIHdwYXNfZGJ1c19zaW1wbGVfYXJyYXlfcHJvcGVydHlfZ2V0dGVyKAorCQlpdGVyLCBEQlVTX1RZUEVfQllURSwgKGNoYXIgKikgaW5mby0+cDJwX2RldmljZV9hZGRyLAorCQlFVEhfQUxFTiwgZXJyb3IpOworfQorCisKK3N0cnVjdCBwZWVyX2dyb3VwX2RhdGEgeworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3M7CisJY29uc3Qgc3RydWN0IHAycF9wZWVyX2luZm8gKmluZm87CisJY2hhciAqKnBhdGhzOworCXVuc2lnbmVkIGludCBuYl9wYXRoczsKKwlpbnQgZXJyb3I7Cit9OworCisKK3N0YXRpYyBpbnQgbWF0Y2hfZ3JvdXBfd2hlcmVfcGVlcl9pc19jbGllbnQoc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsCisJCQkJCSAgICB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IHBlZXJfZ3JvdXBfZGF0YSAqZGF0YSA9IHVzZXJfZGF0YTsKKwljb25zdCBzdHJ1Y3QgcDJwX2dyb3VwX2NvbmZpZyAqY2ZnOworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3NfZ287CisJY2hhciAqKnBhdGhzOworCisJaWYgKCFwMnBfZ3JvdXBfaXNfY2xpZW50X2Nvbm5lY3RlZChncm91cCwgZGF0YS0+aW5mby0+cDJwX2RldmljZV9hZGRyKSkKKwkJcmV0dXJuIDE7CisKKwljZmcgPSBwMnBfZ3JvdXBfZ2V0X2NvbmZpZyhncm91cCk7CisKKwl3cGFfc19nbyA9IHdwYXNfZ2V0X3AycF9nb19pZmFjZShkYXRhLT53cGFfcywgY2ZnLT5zc2lkLAorCQkJCQkgY2ZnLT5zc2lkX2xlbik7CisJaWYgKHdwYV9zX2dvID09IE5VTEwpCisJCXJldHVybiAxOworCisJcGF0aHMgPSBvc19yZWFsbG9jX2FycmF5KGRhdGEtPnBhdGhzLCBkYXRhLT5uYl9wYXRocyArIDEsCisJCQkJIHNpemVvZihjaGFyICopKTsKKwlpZiAocGF0aHMgPT0gTlVMTCkKKwkJZ290byBvdXRfb2ZfbWVtb3J5OworCisJZGF0YS0+cGF0aHMgPSBwYXRoczsKKwlkYXRhLT5wYXRoc1tkYXRhLT5uYl9wYXRoc10gPSB3cGFfc19nby0+ZGJ1c19ncm91cG9ial9wYXRoOworCWRhdGEtPm5iX3BhdGhzKys7CisKKwlyZXR1cm4gMTsKKworb3V0X29mX21lbW9yeToKKwlkYXRhLT5lcnJvciA9IEVOT01FTTsKKwlyZXR1cm4gMDsKK30KKworCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9wZWVyX2dyb3VwcyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCSAgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgICB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IHBlZXJfaGFuZGxlcl9hcmdzICpwZWVyX2FyZ3MgPSB1c2VyX2RhdGE7CisJY29uc3Qgc3RydWN0IHAycF9wZWVyX2luZm8gKmluZm87CisJc3RydWN0IHBlZXJfZ3JvdXBfZGF0YSBkYXRhOworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3NfZ287CisJZGJ1c19ib29sX3Qgc3VjY2VzcyA9IEZBTFNFOworCisJaW5mbyA9IHAycF9nZXRfcGVlcl9mb3VuZChwZWVyX2FyZ3MtPndwYV9zLT5nbG9iYWwtPnAycCwKKwkJCQkgIHBlZXJfYXJncy0+cDJwX2RldmljZV9hZGRyLCAwKTsKKwlpZiAoaW5mbyA9PSBOVUxMKSB7CisJCWRidXNfc2V0X2Vycm9yKGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCSAgICAgICAiZmFpbGVkIHRvIGZpbmQgcGVlciIpOworCQlyZXR1cm4gRkFMU0U7CisJfQorCisJb3NfbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOworCXdwYV9zX2dvID0gd3Bhc19nZXRfcDJwX2NsaWVudF9pZmFjZShwZWVyX2FyZ3MtPndwYV9zLAorCQkJCQkgICAgIGluZm8tPnAycF9kZXZpY2VfYWRkcik7CisJaWYgKHdwYV9zX2dvKSB7CisJCWRhdGEucGF0aHMgPSBvc19jYWxsb2MoMSwgc2l6ZW9mKGNoYXIgKikpOworCQlpZiAoZGF0YS5wYXRocyA9PSBOVUxMKQorCQkJZ290byBvdXRfb2ZfbWVtb3J5OworCQlkYXRhLnBhdGhzWzBdID0gd3BhX3NfZ28tPmRidXNfZ3JvdXBvYmpfcGF0aDsKKwkJZGF0YS5uYl9wYXRocyA9IDE7CisJfQorCisJZGF0YS53cGFfcyA9IHBlZXJfYXJncy0+d3BhX3M7CisJZGF0YS5pbmZvID0gaW5mbzsKKworCXAycF9sb29wX29uX2FsbF9ncm91cHMocGVlcl9hcmdzLT53cGFfcy0+Z2xvYmFsLT5wMnAsCisJCQkgICAgICAgbWF0Y2hfZ3JvdXBfd2hlcmVfcGVlcl9pc19jbGllbnQsICZkYXRhKTsKKwlpZiAoZGF0YS5lcnJvcikKKwkJZ290byBvdXRfb2ZfbWVtb3J5OworCisJaWYgKGRhdGEucGF0aHMgPT0gTlVMTCkgeworCQlyZXR1cm4gd3Bhc19kYnVzX3NpbXBsZV9hcnJheV9wcm9wZXJ0eV9nZXR0ZXIoCisJCQlpdGVyLCBEQlVTX1RZUEVfT0JKRUNUX1BBVEgsIE5VTEwsIDAsIGVycm9yKTsKKwl9CisKKwlzdWNjZXNzID0gd3Bhc19kYnVzX3NpbXBsZV9hcnJheV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwKKwkJCQkJCQkgREJVU19UWVBFX09CSkVDVF9QQVRILAorCQkJCQkJCSBkYXRhLnBhdGhzLAorCQkJCQkJCSBkYXRhLm5iX3BhdGhzLCBlcnJvcik7CisJZ290byBvdXQ7CisKK291dF9vZl9tZW1vcnk6CisJZGJ1c19zZXRfZXJyb3JfY29uc3QoZXJyb3IsIERCVVNfRVJST1JfTk9fTUVNT1JZLCAibm8gbWVtb3J5Iik7CitvdXQ6CisJb3NfZnJlZShkYXRhLnBhdGhzKTsKIAlyZXR1cm4gc3VjY2VzczsKIH0KIApAQCAtMTgyOCw5ICsxOTgwLDkgQEAKIAkJaWYgKCFwYXRoc1tpXSkKIAkJCWdvdG8gb3V0X29mX21lbW9yeTsKIAkJb3Nfc25wcmludGYocGF0aHNbaV0sIFdQQVNfREJVU19PQkpFQ1RfUEFUSF9NQVgsCi0JCQkgICAgIiVzLyIgV1BBU19EQlVTX05FV19QMlBfR1JPVVBNRU1CRVJTX1BBUlQKKwkJCSAgICAiJXMvIiBXUEFTX0RCVVNfTkVXX1AyUF9QRUVSU19QQVJUCiAJCQkgICAgIi8iIENPTVBBQ1RfTUFDU1RSLAotCQkJICAgIHdwYV9zLT5kYnVzX2dyb3Vwb2JqX3BhdGgsIE1BQzJTVFIoYWRkcikpOworCQkJICAgIHdwYV9zLT5wYXJlbnQtPmRidXNfbmV3X3BhdGgsIE1BQzJTVFIoYWRkcikpOwogCQlpKys7CiAJfQogCkBAIC0xOTY0LDggKzIxMTYsOSBAQAogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSB1c2VyX2RhdGE7CiAJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZDsKIAlzdHJ1Y3Qgd3BhYnVmICp2ZW5kb3JfZXh0W01BWF9XUFNfVkVORE9SX0VYVEVOU0lPTlNdOwotCWludCBudW1fdmVuZG9yX2V4dCA9IDA7Ci0JaW50IGk7CisJdW5zaWduZWQgaW50IGksIG51bV92ZW5kb3JfZXh0ID0gMDsKKworCW9zX21lbXNldCh2ZW5kb3JfZXh0LCAwLCBzaXplb2YodmVuZG9yX2V4dCkpOwogCiAJLyogVmVyaWZ5IGNvcnJlY3Qgcm9sZSBmb3IgdGhpcyBwcm9wZXJ0eSAqLwogCWlmICh3cGFzX2dldF9wMnBfcm9sZSh3cGFfcykgPT0gV1BBU19QMlBfUk9MRV9HTykgewpAQCAtMTk3NiwxMSArMjEyOSw5IEBACiAJCS8qIFBhcnNlIFdQUyBWZW5kb3IgRXh0ZW5zaW9ucyBzZW50IGluIEJlYWNvbi9Qcm9iZSBSZXNwb25zZSAqLwogCQlmb3IgKGkgPSAwOyBpIDwgTUFYX1dQU19WRU5ET1JfRVhURU5TSU9OUzsgaSsrKSB7CiAJCQlpZiAoaGFwZC0+Y29uZi0+d3BzX3ZlbmRvcl9leHRbaV0gPT0gTlVMTCkKLQkJCQl2ZW5kb3JfZXh0W2ldID0gTlVMTDsKLQkJCWVsc2UgewotCQkJCXZlbmRvcl9leHRbbnVtX3ZlbmRvcl9leHQrK10gPQotCQkJCQloYXBkLT5jb25mLT53cHNfdmVuZG9yX2V4dFtpXTsKLQkJCX0KKwkJCQljb250aW51ZTsKKwkJCXZlbmRvcl9leHRbbnVtX3ZlbmRvcl9leHQrK10gPQorCQkJCWhhcGQtPmNvbmYtPndwc192ZW5kb3JfZXh0W2ldOwogCQl9CiAJfQogCkBAIC0xOTg5LDcgKzIxNDAsNyBAQAogCQkJCQkJCSAgICBEQlVTX1RZUEVfQllURSwKIAkJCQkJCQkgICAgdmVuZG9yX2V4dCwKIAkJCQkJCQkgICAgbnVtX3ZlbmRvcl9leHQsCi0JCQkJCQkgZXJyb3IpOworCQkJCQkJCSAgICBlcnJvcik7CiB9CiAKIApAQCAtMjQwNyw3ICsyNTU4LDcgQEAKIAlpZiAocmVxID09IDApCiAJCWdvdG8gZXJyb3I7CiAKLQlpZiAoIXdwYXNfcDJwX3NkX2NhbmNlbF9yZXF1ZXN0KHdwYV9zLCByZXEpKQorCWlmICh3cGFzX3AycF9zZF9jYW5jZWxfcmVxdWVzdCh3cGFfcywgcmVxKSA8IDApCiAJCWdvdG8gZXJyb3I7CiAKIAlyZXR1cm4gTlVMTDsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfcDJwLmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzX3AycC5oCmluZGV4IGExMWIzYzguLjY3ZGJmYzkgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfcDJwLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVyc19wMnAuaApAQCAtMTQsMTEgKzE0LDYgQEAKIAl1OCBwMnBfZGV2aWNlX2FkZHJbRVRIX0FMRU5dOwogfTsKIAotc3RydWN0IGdyb3VwbWVtYmVyX2hhbmRsZXJfYXJncyB7Ci0Jc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfczsKLQl1OCBtZW1iZXJfYWRkcltFVEhfQUxFTl07Ci19OwotCiAvKgogICogUDJQIERldmljZSBtZXRob2RzCiAgKi8KQEAgLTE0Nyw2ICsxNDIsMTQgQEAKIAkJCQkJICBEQnVzRXJyb3IgKmVycm9yLAogCQkJCQkgIHZvaWQgKnVzZXJfZGF0YSk7CiAKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcDJwX3BlZXJfZGV2aWNlX2FkZHJlc3MoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkJICAgICBEQnVzRXJyb3IgKmVycm9yLAorCQkJCQkJICAgICB2b2lkICp1c2VyX2RhdGEpOworCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9wZWVyX2dyb3VwcyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCSAgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgICB2b2lkICp1c2VyX2RhdGEpOworCiAvKgogICogUDJQIEdyb3VwIHByb3BlcnRpZXMKICAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oZWxwZXJzLmMgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuYwppbmRleCBlMjYwODZkLi43NTA1MjJkIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuYworKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuYwpAQCAtMzgsMjcgKzM4LDI1IEBACiAKIAkJaWYgKCFkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lcihkaWN0X2l0ZXIsCiAJCQkJCQkgICAgICBEQlVTX1RZUEVfRElDVF9FTlRSWSwKLQkJCQkJCSAgICAgIE5VTEwsICZlbnRyeV9pdGVyKSkgewotCQkJZGJ1c19zZXRfZXJyb3JfY29uc3QoZXJyb3IsIERCVVNfRVJST1JfTk9fTUVNT1JZLAotCQkJICAgICAgICAgICAgICAgICAgICAgIm5vIG1lbW9yeSIpOwotCQkJcmV0dXJuIEZBTFNFOwotCQl9Ci0JCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljKCZlbnRyeV9pdGVyLAorCQkJCQkJICAgICAgTlVMTCwgJmVudHJ5X2l0ZXIpIHx8CisJCSAgICAhZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljKCZlbnRyeV9pdGVyLAogCQkJCQkJICAgIERCVVNfVFlQRV9TVFJJTkcsCi0JCQkJCQkgICAgJmRzYy0+ZGJ1c19wcm9wZXJ0eSkpIHsKLQkJCWRidXNfc2V0X2Vycm9yX2NvbnN0KGVycm9yLCBEQlVTX0VSUk9SX05PX01FTU9SWSwKLQkJCSAgICAgICAgICAgICAgICAgICAgICJubyBtZW1vcnkiKTsKLQkJCXJldHVybiBGQUxTRTsKLQkJfQorCQkJCQkJICAgICZkc2MtPmRidXNfcHJvcGVydHkpKQorCQkJZ290byBlcnJvcjsKIAogCQkvKiBBbiBlcnJvciBnZXR0aW5nIGEgcHJvcGVydHkgZmFpbHMgdGhlIHJlcXVlc3QgZW50aXJlbHkgKi8KIAkJaWYgKCFkc2MtPmdldHRlcigmZW50cnlfaXRlciwgZXJyb3IsIHVzZXJfZGF0YSkpCiAJCQlyZXR1cm4gRkFMU0U7CiAKLQkJZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyKGRpY3RfaXRlciwgJmVudHJ5X2l0ZXIpOworCQlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lcihkaWN0X2l0ZXIsICZlbnRyeV9pdGVyKSkKKwkJCWdvdG8gZXJyb3I7CiAJfQogCiAJcmV0dXJuIFRSVUU7CisKK2Vycm9yOgorCWRidXNfc2V0X2Vycm9yX2NvbnN0KGVycm9yLCBEQlVTX0VSUk9SX05PX01FTU9SWSwgIm5vIG1lbW9yeSIpOworCXJldHVybiBGQUxTRTsKIH0KIAogCkBAIC0xMTEsNyArMTA5LDEyIEBACiAJCXJldHVybiByZXBseTsKIAl9CiAKLQl3cGFfZGJ1c19kaWN0X2Nsb3NlX3dyaXRlKCZpdGVyLCAmZGljdF9pdGVyKTsKKwlpZiAoIXdwYV9kYnVzX2RpY3RfY2xvc2Vfd3JpdGUoJml0ZXIsICZkaWN0X2l0ZXIpKSB7CisJCWRidXNfbWVzc2FnZV91bnJlZihyZXBseSk7CisJCXJldHVybiBkYnVzX21lc3NhZ2VfbmV3X2Vycm9yKG1lc3NhZ2UsIERCVVNfRVJST1JfTk9fTUVNT1JZLAorCQkJCQkgICAgICAib3V0IG9mIG1lbW9yeSIpOworCX0KKwogCXJldHVybiByZXBseTsKIH0KIApAQCAtODQwLDcgKzg0Myw2IEBACiAJCXJldHVybjsKIAllbG9vcF9jYW5jZWxfdGltZW91dChmbHVzaF9vYmplY3RfdGltZW91dF9oYW5kbGVyLCBjb24sIG9ial9kZXNjKTsKIAotCWRzYyA9IG9ial9kZXNjLT5wcm9wZXJ0aWVzOwogCWZvciAoZHNjID0gb2JqX2Rlc2MtPnByb3BlcnRpZXMsIGkgPSAwOyBkc2MgJiYgZHNjLT5kYnVzX3Byb3BlcnR5OwogCSAgICAgZHNjKyssIGkrKykgewogCQlpZiAob2JqX2Rlc2MtPnByb3BfY2hhbmdlZF9mbGFncyA9PSBOVUxMIHx8CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkX2hhbmRsZXJzLmMgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkX2hhbmRsZXJzLmMKaW5kZXggZTU2NWRlOS4uMDQ4MTU4ZiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX29sZF9oYW5kbGVycy5jCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGRfaGFuZGxlcnMuYwpAQCAtMjUsMTAgKzI1LDYgQEAKICNpbmNsdWRlICJkYnVzX29sZF9oYW5kbGVycy5oIgogI2luY2x1ZGUgImRidXNfZGljdF9oZWxwZXJzLmgiCiAKLWV4dGVybiBpbnQgd3BhX2RlYnVnX2xldmVsOwotZXh0ZXJuIGludCB3cGFfZGVidWdfc2hvd19rZXlzOwotZXh0ZXJuIGludCB3cGFfZGVidWdfdGltZXN0YW1wOwotCiAvKioKICAqIHdwYXNfZGJ1c19uZXdfaW52YWxpZF9vcHRzX2Vycm9yIC0gUmV0dXJuIGEgbmV3IGludmFsaWQgb3B0aW9ucyBlcnJvciBtZXNzYWdlCiAgKiBAbWVzc2FnZTogUG9pbnRlciB0byBpbmNvbWluZyBkYnVzIG1lc3NhZ2UgdGhpcyBlcnJvciByZWZlcnMgdG8KQEAgLTExNywyNCArMTEzLDI4IEBACiAJCQkJZ290byBlcnJvcjsKIAkJCWlmICghc3RyY21wKGVudHJ5LmtleSwgImRyaXZlciIpICYmCiAJCQkgICAgKGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX1NUUklORykpIHsKKwkJCQlvc19mcmVlKGRyaXZlcik7CiAJCQkJZHJpdmVyID0gb3Nfc3RyZHVwKGVudHJ5LnN0cl92YWx1ZSk7CiAJCQkJd3BhX2RidXNfZGljdF9lbnRyeV9jbGVhcigmZW50cnkpOwogCQkJCWlmIChkcml2ZXIgPT0gTlVMTCkKIAkJCQkJZ290byBlcnJvcjsKIAkJCX0gZWxzZSBpZiAoIXN0cmNtcChlbnRyeS5rZXksICJkcml2ZXItcGFyYW1zIikgJiYKIAkJCQkgICAoZW50cnkudHlwZSA9PSBEQlVTX1RZUEVfU1RSSU5HKSkgeworCQkJCW9zX2ZyZWUoZHJpdmVyX3BhcmFtKTsKIAkJCQlkcml2ZXJfcGFyYW0gPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCQl3cGFfZGJ1c19kaWN0X2VudHJ5X2NsZWFyKCZlbnRyeSk7CiAJCQkJaWYgKGRyaXZlcl9wYXJhbSA9PSBOVUxMKQogCQkJCQlnb3RvIGVycm9yOwogCQkJfSBlbHNlIGlmICghc3RyY21wKGVudHJ5LmtleSwgImNvbmZpZy1maWxlIikgJiYKIAkJCQkgICAoZW50cnkudHlwZSA9PSBEQlVTX1RZUEVfU1RSSU5HKSkgeworCQkJCW9zX2ZyZWUoY29uZm5hbWUpOwogCQkJCWNvbmZuYW1lID0gb3Nfc3RyZHVwKGVudHJ5LnN0cl92YWx1ZSk7CiAJCQkJd3BhX2RidXNfZGljdF9lbnRyeV9jbGVhcigmZW50cnkpOwogCQkJCWlmIChjb25mbmFtZSA9PSBOVUxMKQogCQkJCQlnb3RvIGVycm9yOwogCQkJfSBlbHNlIGlmICghc3RyY21wKGVudHJ5LmtleSwgImJyaWRnZS1pZm5hbWUiKSAmJgogCQkJCSAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CisJCQkJb3NfZnJlZShicmlkZ2VfaWZuYW1lKTsKIAkJCQlicmlkZ2VfaWZuYW1lID0gb3Nfc3RyZHVwKGVudHJ5LnN0cl92YWx1ZSk7CiAJCQkJd3BhX2RidXNfZGljdF9lbnRyeV9jbGVhcigmZW50cnkpOwogCQkJCWlmIChicmlkZ2VfaWZuYW1lID09IE5VTEwpCkBAIC0zNTAsNyArMzUwLDcgQEAKIERCdXNNZXNzYWdlICogd3Bhc19kYnVzX2lmYWNlX3NjYW5fcmVzdWx0cyhEQnVzTWVzc2FnZSAqbWVzc2FnZSwKIAkJCQkJICAgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKLQlEQnVzTWVzc2FnZSAqcmVwbHkgPSBOVUxMOworCURCdXNNZXNzYWdlICpyZXBseTsKIAlEQnVzTWVzc2FnZUl0ZXIgaXRlcjsKIAlEQnVzTWVzc2FnZUl0ZXIgc3ViX2l0ZXI7CiAJc3RydWN0IHdwYV9ic3MgKmJzczsKQEAgLTM1OCw5ICszNTgsMTAgQEAKIAkvKiBDcmVhdGUgYW5kIGluaXRpYWxpemUgdGhlIHJldHVybiBtZXNzYWdlICovCiAJcmVwbHkgPSBkYnVzX21lc3NhZ2VfbmV3X21ldGhvZF9yZXR1cm4obWVzc2FnZSk7CiAJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdF9hcHBlbmQocmVwbHksICZpdGVyKTsKLQlkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lcigmaXRlciwgREJVU19UWVBFX0FSUkFZLAotCQkJCQkgREJVU19UWVBFX09CSkVDVF9QQVRIX0FTX1NUUklORywKLQkJCQkJICZzdWJfaXRlcik7CisJaWYgKCFkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lcigmaXRlciwgREJVU19UWVBFX0FSUkFZLAorCQkJCQkgICAgICBEQlVTX1RZUEVfT0JKRUNUX1BBVEhfQVNfU1RSSU5HLAorCQkJCQkgICAgICAmc3ViX2l0ZXIpKQorCQlnb3RvIGVycm9yOwogCiAJLyogTG9vcCB0aHJvdWdoIHNjYW4gcmVzdWx0cyBhbmQgYXBwZW5kIGVhY2ggcmVzdWx0J3Mgb2JqZWN0IHBhdGggKi8KIAlkbF9saXN0X2Zvcl9lYWNoKGJzcywgJndwYV9zLT5ic3NfaWQsIHN0cnVjdCB3cGFfYnNzLCBsaXN0X2lkKSB7CkBAIC0zNzQsMTMgKzM3NSwyMSBAQAogCQkJICAgICIlcy8iIFdQQVNfREJVU19CU1NJRFNfUEFSVCAiLyIKIAkJCSAgICBXUEFTX0RCVVNfQlNTSURfRk9STUFULAogCQkJICAgIHdwYV9zLT5kYnVzX3BhdGgsIE1BQzJTVFIoYnNzLT5ic3NpZCkpOwotCQlkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMoJnN1Yl9pdGVyLAotCQkJCQkgICAgICAgREJVU19UWVBFX09CSkVDVF9QQVRILCAmcGF0aCk7CisJCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljKCZzdWJfaXRlciwKKwkJCQkJCSAgICBEQlVTX1RZUEVfT0JKRUNUX1BBVEgsCisJCQkJCQkgICAgJnBhdGgpKQorCQkJZ290byBlcnJvcjsKIAl9CiAKLQlkYnVzX21lc3NhZ2VfaXRlcl9jbG9zZV9jb250YWluZXIoJml0ZXIsICZzdWJfaXRlcik7CisJaWYgKCFkYnVzX21lc3NhZ2VfaXRlcl9jbG9zZV9jb250YWluZXIoJml0ZXIsICZzdWJfaXRlcikpCisJCWdvdG8gZXJyb3I7CiAKIAlyZXR1cm4gcmVwbHk7CisKK2Vycm9yOgorCWRidXNfbWVzc2FnZV91bnJlZihyZXBseSk7CisJcmV0dXJuIGRidXNfbWVzc2FnZV9uZXdfZXJyb3IobWVzc2FnZSwgV1BBU19FUlJPUl9JTlRFUk5BTF9FUlJPUiwKKwkJCQkgICAgICAiYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJyZWQgcmV0dXJuaW5nIHNjYW4gcmVzdWx0cyIpOwogfQogCiAKQEAgLTQxOSw3ICs0MjgsNyBAQAogCQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX2J5dGVfYXJyYXkoJml0ZXJfZGljdCwgInNzaWQiLAogCQkJCQkJICAgICAoY29uc3QgY2hhciAqKSAoaWUgKyAyKSwKIAkJCQkJCSAgICAgaWVbMV0pKQotCQlnb3RvIGVycm9yOworCQkJZ290byBlcnJvcjsKIAl9CiAKIAlpZSA9IHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZShic3MsIFdQQV9JRV9WRU5ET1JfVFlQRSk7CkBAIC01MzksNyArNTQ4LDcgQEAKIAkJCWNvbnN0IGNoYXIgKmFyZ3NbXSA9IHsiQ0NNUCIsICJUS0lQIiwgIk5PTkUifTsKIAkJCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfc3RyaW5nX2FycmF5KAogCQkJCSAgICAmaXRlcl9kaWN0LCAicGFpcndpc2UiLCBhcmdzLAotCQkJCSAgICBzaXplb2YoYXJncykgLyBzaXplb2YoY2hhciopKSkKKwkJCQkgICAgQVJSQVlfU0laRShhcmdzKSkpCiAJCQkJZ290byBlcnJvcjsKIAkJfQogCX0gZWxzZSB7CkBAIC01ODIsNyArNTkxLDcgQEAKIAkJCX07CiAJCQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX3N0cmluZ19hcnJheSgKIAkJCQkgICAgJml0ZXJfZGljdCwgImdyb3VwIiwgYXJncywKLQkJCQkgICAgc2l6ZW9mKGFyZ3MpIC8gc2l6ZW9mKGNoYXIqKSkpCisJCQkJICAgIEFSUkFZX1NJWkUoYXJncykpKQogCQkJCWdvdG8gZXJyb3I7CiAJCX0KIAl9IGVsc2UgewpAQCAtNjMyLDcgKzY0MSw3IEBACiAJCQl9OwogCQkJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF9zdHJpbmdfYXJyYXkoCiAJCQkJICAgICZpdGVyX2RpY3QsICJrZXlfbWdtdCIsIGFyZ3MsCi0JCQkJICAgIHNpemVvZihhcmdzKSAvIHNpemVvZihjaGFyKikpKQorCQkJCSAgICBBUlJBWV9TSVpFKGFyZ3MpKSkKIAkJCQlnb3RvIGVycm9yOwogCQl9CiAJfSBlbHNlIHsKQEAgLTY4Myw3ICs2OTIsNyBAQAogCQkJY29uc3QgY2hhciAqYXJnc1tdID0geyAiUlNOIiwgIldQQSIgfTsKIAkJCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfc3RyaW5nX2FycmF5KAogCQkJCSAgICAmaXRlcl9kaWN0LCAicHJvdG8iLCBhcmdzLAotCQkJCSAgICBzaXplb2YoYXJncykgLyBzaXplb2YoY2hhciopKSkKKwkJCQkgICAgQVJSQVlfU0laRShhcmdzKSkpCiAJCQkJZ290byBlcnJvcjsKIAkJfQogCX0gZWxzZSB7CkBAIC03MjAsNyArNzI5LDcgQEAKIAkJCWNvbnN0IGNoYXIgKmFyZ3NbXSA9IHsgIk9QRU4iLCAiU0hBUkVEIiwgIkxFQVAiIH07CiAJCQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX3N0cmluZ19hcnJheSgKIAkJCQkgICAgJml0ZXJfZGljdCwgImF1dGhfYWxnIiwgYXJncywKLQkJCQkgICAgc2l6ZW9mKGFyZ3MpIC8gc2l6ZW9mKGNoYXIqKSkpCisJCQkJICAgIEFSUkFZX1NJWkUoYXJncykpKQogCQkJCWdvdG8gZXJyb3I7CiAJCX0KIAl9IGVsc2UgewpAQCAtMTIwNCwxNiArMTIxMywxOSBAQAogCQkJZ290byBlcnJvcjsKIAkJaWYgKCFzdHJjbXAoZW50cnkua2V5LCAib3BlbnNjX2VuZ2luZV9wYXRoIikgJiYKIAkJICAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CisJCQlvc19mcmVlKG9wZW5zY19lbmdpbmVfcGF0aCk7CiAJCQlvcGVuc2NfZW5naW5lX3BhdGggPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCWlmIChvcGVuc2NfZW5naW5lX3BhdGggPT0gTlVMTCkKIAkJCQlnb3RvIGVycm9yOwogCQl9IGVsc2UgaWYgKCFzdHJjbXAoZW50cnkua2V5LCAicGtjczExX2VuZ2luZV9wYXRoIikgJiYKIAkJCSAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CisJCQlvc19mcmVlKHBrY3MxMV9lbmdpbmVfcGF0aCk7CiAJCQlwa2NzMTFfZW5naW5lX3BhdGggPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCWlmIChwa2NzMTFfZW5naW5lX3BhdGggPT0gTlVMTCkKIAkJCQlnb3RvIGVycm9yOwogCQl9IGVsc2UgaWYgKCFzdHJjbXAoZW50cnkua2V5LCAicGtjczExX21vZHVsZV9wYXRoIikgJiYKIAkJCQkgKGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX1NUUklORykpIHsKKwkJCW9zX2ZyZWUocGtjczExX21vZHVsZV9wYXRoKTsKIAkJCXBrY3MxMV9tb2R1bGVfcGF0aCA9IG9zX3N0cmR1cChlbnRyeS5zdHJfdmFsdWUpOwogCQkJaWYgKHBrY3MxMV9tb2R1bGVfcGF0aCA9PSBOVUxMKQogCQkJCWdvdG8gZXJyb3I7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kZWZjb25maWcgYi93cGFfc3VwcGxpY2FudC9kZWZjb25maWcKaW5kZXggYWE2MDA1Zi4uOTRjOTRiMSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGVmY29uZmlnCisrKyBiL3dwYV9zdXBwbGljYW50L2RlZmNvbmZpZwpAQCAtMjAsNjMgKzIwLDYgQEAKICMgdXNlZCB0byBmaXggYnVpbGQgaXNzdWVzIG9uIHN1Y2ggc3lzdGVtcyAoa3JiNS5oIG5vdCBmb3VuZCkuCiAjQ0ZMQUdTICs9IC1JL3Vzci9pbmNsdWRlL2tlcmJlcm9zCiAKLSMgRXhhbXBsZSBjb25maWd1cmF0aW9uIGZvciB2YXJpb3VzIGNyb3NzLWNvbXBpbGF0aW9uIHBsYXRmb3JtcwotCi0jIyMjIHN2ZWFzb2Z0IChlLmcuLCBmb3IgTGlua3N5cyBXUlQ1NEcpICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCi0jQ0M9bWlwc2VsLXVjbGliYy1nY2MKLSNDQz0vb3B0L2JyY20vaG5kdG9vbHMtbWlwc2VsLXVjbGliYy9iaW4vbWlwc2VsLXVjbGliYy1nY2MKLSNDRkxBR1MgKz0gLU9zCi0jQ1BQRkxBR1MgKz0gLUkuLi9zcmMvaW5jbHVkZSAtSS4uLy4uL3NyYy9yb3V0ZXIvb3BlbnNzbC9pbmNsdWRlCi0jTElCUyArPSAtTC9vcHQvYnJjbS9obmR0b29scy1taXBzZWwtdWNsaWJjLTAuOS4xOS9saWIgLWxzc2wKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotIyMjIyBvcGVud3J0IChlLmcuLCBmb3IgTGlua3N5cyBXUlQ1NEcpICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwotI0NDPW1pcHNlbC11Y2xpYmMtZ2NjCi0jQ0M9L29wdC9icmNtL2huZHRvb2xzLW1pcHNlbC11Y2xpYmMvYmluL21pcHNlbC11Y2xpYmMtZ2NjCi0jQ0ZMQUdTICs9IC1PcwotI0NQUEZMQUdTPS1JLi4vc3JjL2luY2x1ZGUgLUkuLi9vcGVuc3NsLTAuOS43ZC9pbmNsdWRlIFwKLSMJLUkuLi9XUlQ1NEdTL3JlbGVhc2Uvc3JjL2luY2x1ZGUKLSNMSUJTID0gLWxzc2wKLSMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKLQotCi0jIERyaXZlciBpbnRlcmZhY2UgZm9yIEhvc3QgQVAgZHJpdmVyCi1DT05GSUdfRFJJVkVSX0hPU1RBUD15Ci0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgQWdlcmUgZHJpdmVyCi0jQ09ORklHX0RSSVZFUl9IRVJNRVM9eQotIyBDaGFuZ2UgaW5jbHVkZSBkaXJlY3RvcmllcyB0byBtYXRjaCB3aXRoIHRoZSBsb2NhbCBzZXR1cAotI0NGTEFHUyArPSAtSS4uLy4uL2hjZiAtSS4uLy4uL2luY2x1ZGUgLUkuLi8uLi9pbmNsdWRlL2hjZgotI0NGTEFHUyArPSAtSS4uLy4uL2luY2x1ZGUvd2lyZWxlc3MKLQotIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBtYWR3aWZpIGRyaXZlcgotIyBEZXByZWNhdGVkOyB1c2UgQ09ORklHX0RSSVZFUl9XRVhUPXkgaW5zdGVhZC4KLSNDT05GSUdfRFJJVkVSX01BRFdJRkk9eQotIyBTZXQgaW5jbHVkZSBkaXJlY3RvcnkgdG8gdGhlIG1hZHdpZmkgc291cmNlIHRyZWUKLSNDRkxBR1MgKz0gLUkuLi8uLi9tYWR3aWZpCi0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgbmRpc3dyYXBwZXIKLSMgRGVwcmVjYXRlZDsgdXNlIENPTkZJR19EUklWRVJfV0VYVD15IGluc3RlYWQuCi0jQ09ORklHX0RSSVZFUl9ORElTV1JBUFBFUj15Ci0KLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgQXRtZWwgZHJpdmVyCi1DT05GSUdfRFJJVkVSX0FUTUVMPXkKLQotIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBvbGQgQnJvYWRjb20gZHJpdmVyCi0jIFBsZWFzZSBub3RlIHRoYXQgdGhlIG5ld2VyIEJyb2FkY29tIGRyaXZlciAoImh5YnJpZCBMaW51eCBkcml2ZXIiKSBzdXBwb3J0cwotIyBMaW51eCB3aXJlbGVzcyBleHRlbnNpb25zIGFuZCBkb2VzIG5vdCBuZWVkIChvciBldmVuIHdvcmspIHdpdGggdGhlIG9sZAotIyBkcml2ZXIgd3JhcHBlci4gVXNlIENPTkZJR19EUklWRVJfV0VYVD15IHdpdGggdGhhdCBkcml2ZXIuCi0jQ09ORklHX0RSSVZFUl9CUk9BRENPTT15Ci0jIEV4YW1wbGUgcGF0aCBmb3Igd2xpb2N0bC5oOyBjaGFuZ2UgdG8gbWF0Y2ggeW91ciBjb25maWd1cmF0aW9uCi0jQ0ZMQUdTICs9IC1JL29wdC9XUlQ1NEdTL3JlbGVhc2Uvc3JjL2luY2x1ZGUKLQotIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBJbnRlbCBpcHcyMTAwLzIyMDAgZHJpdmVyCi0jIERlcHJlY2F0ZWQ7IHVzZSBDT05GSUdfRFJJVkVSX1dFWFQ9eSBpbnN0ZWFkLgotI0NPTkZJR19EUklWRVJfSVBXPXkKLQotIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBSYWxpbmsgZHJpdmVyCi0jQ09ORklHX0RSSVZFUl9SQUxJTks9eQotCiAjIERyaXZlciBpbnRlcmZhY2UgZm9yIGdlbmVyaWMgTGludXggd2lyZWxlc3MgZXh0ZW5zaW9ucwogIyBOb3RlOiBXRVhUIGlzIGRlcHJlY2F0ZWQgaW4gdGhlIGN1cnJlbnQgTGludXgga2VybmVsIHZlcnNpb24gYW5kIG5vIG5ldwogIyBmdW5jdGlvbmFsaXR5IGlzIGFkZGVkIHRvIGl0LiBubDgwMjExLWJhc2VkIGludGVyZmFjZSBpcyB0aGUgbmV3CkBAIC04OCw2ICszMSwxOSBAQAogIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBMaW51eCBkcml2ZXJzIHVzaW5nIHRoZSBubDgwMjExIGtlcm5lbCBpbnRlcmZhY2UKIENPTkZJR19EUklWRVJfTkw4MDIxMT15CiAKKyMgZHJpdmVyX25sODAyMTEuYyByZXF1aXJlcyBsaWJubC4gSWYgeW91IGFyZSBjb21waWxpbmcgaXQgeW91cnNlbGYKKyMgeW91IG1heSBuZWVkIHRvIHBvaW50IGhvc3RhcGQgdG8geW91ciB2ZXJzaW9uIG9mIGxpYm5sLgorIworI0NGTEFHUyArPSAtSSQ8cGF0aCB0byBsaWJubCBpbmNsdWRlIGZpbGVzPgorI0xJQlMgKz0gLUwkPHBhdGggdG8gbGlibmwgbGlicmFyeSBmaWxlcz4KKworIyBVc2UgbGlibmwgdjIuMCAob3IgMy4wKSBsaWJyYXJpZXMuCisjQ09ORklHX0xJQk5MMjA9eQorCisjIFVzZSBsaWJubCAzLjIgbGlicmFyaWVzIChpZiB0aGlzIGlzIHNlbGVjdGVkLCBDT05GSUdfTElCTkwyMCBpcyBpZ25vcmVkKQorI0NPTkZJR19MSUJOTDMyPXkKKworCiAjIERyaXZlciBpbnRlcmZhY2UgZm9yIEZyZWVCU0QgbmV0ODAyMTEgbGF5ZXIgKGUuZy4sIEF0aGVyb3MgZHJpdmVyKQogI0NPTkZJR19EUklWRVJfQlNEPXkKICNDRkxBR1MgKz0gLUkvdXNyL2xvY2FsL2luY2x1ZGUKQEAgLTE0NywxMCArMTAzLDkgQEAKIENPTkZJR19FQVBfVFRMUz15CiAKICMgRUFQLUZBU1QKLSMgTm90ZTogRGVmYXVsdCBPcGVuU1NMIHBhY2thZ2UgZG9lcyBub3QgaW5jbHVkZSBzdXBwb3J0IGZvciBhbGwgdGhlCi0jIGZ1bmN0aW9uYWxpdHkgbmVlZGVkIGZvciBFQVAtRkFTVC4gSWYgRUFQLUZBU1QgaXMgZW5hYmxlZCB3aXRoIE9wZW5TU0wsCi0jIHRoZSBPcGVuU1NMIGxpYnJhcnkgbXVzdCBiZSBwYXRjaGVkIChvcGVuc3NsLTAuOS44ZC10bHMtZXh0ZW5zaW9ucy5wYXRjaCkKLSMgdG8gYWRkIHRoZSBuZWVkZWQgZnVuY3Rpb25zLgorIyBOb3RlOiBJZiBPcGVuU1NMIGlzIHVzZWQgYXMgdGhlIFRMUyBsaWJyYXJ5LCBPcGVuU1NMIDEuMCBvciBuZXdlciBpcyBuZWVkZWQKKyMgZm9yIEVBUC1GQVNUIHN1cHBvcnQuIE9sZGVyIE9wZW5TU0wgcmVsZWFzZXMgd291bGQgbmVlZCB0byBiZSBwYXRjaGVkLCBlLmcuLAorIyB3aXRoIG9wZW5zc2wtMC45Ljh4LXRscy1leHRlbnNpb25zLnBhdGNoLCB0byBhZGQgdGhlIG5lZWRlZCBmdW5jdGlvbnMuCiAjQ09ORklHX0VBUF9GQVNUPXkKIAogIyBFQVAtR1RDCkBAIC0xOTcsOCArMTUyLDYgQEAKIAogIyBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAgKFdQUykKICNDT05GSUdfV1BTPXkKLSMgRW5hYmxlIFdTQyAyLjAgc3VwcG9ydAotI0NPTkZJR19XUFMyPXkKICMgRW5hYmxlIFdQUyBleHRlcm5hbCByZWdpc3RyYXIgZnVuY3Rpb25hbGl0eQogI0NPTkZJR19XUFNfRVI9eQogIyBEaXNhYmxlIGNyZWRlbnRpYWxzIGZvciBhbiBvcGVuIG5ldHdvcmsgYnkgZGVmYXVsdCB3aGVuIGFjdGluZyBhcyBhIFdQUwpAQCAtMjM3LDggKzE5MCwxMCBAQAogIyBTZWxlY3QgY29udHJvbCBpbnRlcmZhY2UgYmFja2VuZCBmb3IgZXh0ZXJuYWwgcHJvZ3JhbXMsIGUuZywgd3BhX2NsaToKICMgdW5peCA9IFVOSVggZG9tYWluIHNvY2tldHMgKGRlZmF1bHQgZm9yIExpbnV4LypCU0QpCiAjIHVkcCA9IFVEUCBzb2NrZXRzIHVzaW5nIGxvY2FsaG9zdCAoMTI3LjAuMC4xKQorIyB1ZHA2ID0gVURQIElQdjYgc29ja2V0cyB1c2luZyBsb2NhbGhvc3QgKDo6MSkKICMgbmFtZWRfcGlwZSA9IFdpbmRvd3MgTmFtZWQgUGlwZSAoZGVmYXVsdCBmb3IgV2luZG93cykKICMgdWRwLXJlbW90ZSA9IFVEUCBzb2NrZXRzIHdpdGggcmVtb3RlIGFjY2VzcyAob25seSBmb3IgdGVzdHMgc3lzdGVtcy9wdXJwb3NlKQorIyB1ZHA2LXJlbW90ZSA9IFVEUCBJUHY2IHNvY2tldHMgd2l0aCByZW1vdGUgYWNjZXNzIChvbmx5IGZvciB0ZXN0cyBwdXJwb3NlKQogIyB5ID0gdXNlIGRlZmF1bHQgKGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5KQogIyBJZiB0aGlzIG9wdGlvbiBpcyBjb21tZW50ZWQgb3V0LCBjb250cm9sIGludGVyZmFjZSBpcyBub3QgaW5jbHVkZWQgaW4gdGhlCiAjIGJ1aWxkLgpAQCAtMjk4LDcgKzI1Myw3IEBACiAjIG1haW5fbm9uZSA9IFZlcnkgYmFzaWMgZXhhbXBsZSAoZGV2ZWxvcG1lbnQgdXNlIG9ubHkpCiAjQ09ORklHX01BSU49bWFpbgogCi0jIFNlbGVjdCB3cmFwcGVyIGZvciBvcGVyYXRpbnMgc3lzdGVtIGFuZCBDIGxpYnJhcnkgc3BlY2lmaWMgZnVuY3Rpb25zCisjIFNlbGVjdCB3cmFwcGVyIGZvciBvcGVyYXRpbmcgc3lzdGVtIGFuZCBDIGxpYnJhcnkgc3BlY2lmaWMgZnVuY3Rpb25zCiAjIHVuaXggPSBVTklYL1BPU0lYIGxpa2Ugc3lzdGVtcyAoZGVmYXVsdCkKICMgd2luMzIgPSBXaW5kb3dzIHN5c3RlbXMKICMgbm9uZSA9IEVtcHR5IHRlbXBsYXRlCkBAIC0zMDcsMTIgKzI2MiwxNCBAQAogIyBTZWxlY3QgZXZlbnQgbG9vcCBpbXBsZW1lbnRhdGlvbgogIyBlbG9vcCA9IHNlbGVjdCgpIGxvb3AgKGRlZmF1bHQpCiAjIGVsb29wX3dpbiA9IFdpbmRvd3MgZXZlbnRzIGFuZCBXYWl0Rm9yTXVsdGlwbGVPYmplY3QoKSBsb29wCi0jIGVsb29wX25vbmUgPSBFbXB0eSB0ZW1wbGF0ZQogI0NPTkZJR19FTE9PUD1lbG9vcAogCiAjIFNob3VsZCB3ZSB1c2UgcG9sbCBpbnN0ZWFkIG9mIHNlbGVjdD8gU2VsZWN0IGlzIHVzZWQgYnkgZGVmYXVsdC4KICNDT05GSUdfRUxPT1BfUE9MTD15CiAKKyMgU2hvdWxkIHdlIHVzZSBlcG9sbCBpbnN0ZWFkIG9mIHNlbGVjdD8gU2VsZWN0IGlzIHVzZWQgYnkgZGVmYXVsdC4KKyNDT05GSUdfRUxPT1BfRVBPTEw9eQorCiAjIFNlbGVjdCBsYXllciAyIHBhY2tldCBpbXBsZW1lbnRhdGlvbgogIyBsaW51eCA9IExpbnV4IHBhY2tldCBzb2NrZXQgKGRlZmF1bHQpCiAjIHBjYXAgPSBsaWJwY2FwL2xpYmRuZXQvV2luUGNhcApAQCAtNDg0LDYgKzQ0MSwxMCBAQAogIyBJRUVFIDgwMi4xMW4gKEhpZ2ggVGhyb3VnaHB1dCkgc3VwcG9ydCAobWFpbmx5IGZvciBBUCBtb2RlKQogI0NPTkZJR19JRUVFODAyMTFOPXkKIAorIyBJRUVFIDgwMi4xMWFjIChWZXJ5IEhpZ2ggVGhyb3VnaHB1dCkgc3VwcG9ydCAobWFpbmx5IGZvciBBUCBtb2RlKQorIyAoZGVwZW5kcyBvbiBDT05GSUdfSUVFRTgwMjExTikKKyNDT05GSUdfSUVFRTgwMjExQUM9eQorCiAjIFdpcmVsZXNzIE5ldHdvcmsgTWFuYWdlbWVudCAoSUVFRSBTdGQgODAyLjExdi0yMDExKQogIyBOb3RlOiBUaGlzIGlzIGV4cGVyaW1lbnRhbCBhbmQgbm90IGNvbXBsZXRlIGltcGxlbWVudGF0aW9uLgogI0NPTkZJR19XTk09eQpAQCAtNTE1LDkgKzQ3NiwxNCBAQAogIyBFbmFibGUgVERMUyBzdXBwb3J0CiAjQ09ORklHX1RETFM9eQogCisjIFdpLUZpIERpcmVjdAorIyBUaGlzIGNhbiBiZSB1c2VkIHRvIGVuYWJsZSBXaS1GaSBEaXJlY3QgZXh0ZW5zaW9ucyBmb3IgUDJQIHVzaW5nIGFuIGV4dGVybmFsCisjIHByb2dyYW0gdG8gY29udHJvbCB0aGUgYWRkaXRpb25hbCBpbmZvcm1hdGlvbiBleGNoYW5nZXMgaW4gdGhlIG1lc3NhZ2VzLgorI0NPTkZJR19XSUZJX0RJU1BMQVk9eQorCiAjIEF1dG9zY2FuCiAjIFRoaXMgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIGF1dG9tYXRpYyBzY2FuIHN1cHBvcnQgaW4gd3BhX3N1cHBsaWNhbnQuCi0jwqBTZWUgd3BhX3N1cHBsaWNhbnQuY29uZiBmb3IgbW9yZSBpbmZvcm1hdGlvbiBvbiBhdXRvc2NhbiB1c2FnZS4KKyMgU2VlIHdwYV9zdXBwbGljYW50LmNvbmYgZm9yIG1vcmUgaW5mb3JtYXRpb24gb24gYXV0b3NjYW4gdXNhZ2UuCiAjCiAjIEVuYWJsaW5nIGRpcmVjdGx5IGEgbW9kdWxlIHdpbGwgZW5hYmxlIGF1dG9zY2FuIHN1cHBvcnQuCiAjIEZvciBleHBvbmVudGlhbCBtb2R1bGU6CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay9NYWtlZmlsZSBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL01ha2VmaWxlCmluZGV4IGFhZWVlMmUuLjgyZjlkZTMgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL01ha2VmaWxlCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL01ha2VmaWxlCkBAIC03LDYgKzcsNyBAQAogRklMRVMgKz0gd3BhX3ByaXYKIEZJTEVTICs9IHdwYV9zdXBwbGljYW50LmNvbmYKIEZJTEVTICs9IHdwYV9zdXBwbGljYW50CitGSUxFUyArPSBlYXBvbF90ZXN0CiAKIG1hbjoKIAlmb3IgaSBpbiAkKEZJTEVTKTsgZG8gZG9jYm9vazJtYW4gJCRpLnNnbWw7IGRvbmUKQEAgLTIwLDcgKzIxLDcgQEAKIAogCiBjbGVhbjoKLQlybSAtZiB3cGFfYmFja2dyb3VuZC44IHdwYV9jbGkuOCB3cGFfZ3VpLjggd3BhX3Bhc3NwaHJhc2UuOCB3cGFfcHJpdi44IHdwYV9zdXBwbGljYW50LjgKKwlybSAtZiB3cGFfYmFja2dyb3VuZC44IHdwYV9jbGkuOCB3cGFfZ3VpLjggd3BhX3Bhc3NwaHJhc2UuOCB3cGFfcHJpdi44IHdwYV9zdXBwbGljYW50LjggZWFwb2xfdGVzdC44CiAJcm0gLWYgd3BhX3N1cHBsaWNhbnQuY29uZi41CiAJcm0gLWYgbWFucGFnZS5saW5rcyBtYW5wYWdlLnJlZnMKIAlybSAtZiAkKEZJTEVTOiU9JS5wZGYpCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay9lYXBvbF90ZXN0LnNnbWwgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay9lYXBvbF90ZXN0LnNnbWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmVjMTc0YgotLS0gL2Rldi9udWxsCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL2VhcG9sX3Rlc3Quc2dtbApAQCAtMCwwICsxLDIwNSBAQAorPCFkb2N0eXBlIHJlZmVudHJ5IFBVQkxJQyAiLS8vT0FTSVMvL0RURCBEb2NCb29rIFY0LjEvL0VOIj4KKworPHJlZmVudHJ5PgorICA8cmVmbWV0YT4KKyAgICA8cmVmZW50cnl0aXRsZT5lYXBvbF90ZXN0PC9yZWZlbnRyeXRpdGxlPgorICAgIDxtYW52b2xudW0+ODwvbWFudm9sbnVtPgorICA8L3JlZm1ldGE+CisgIDxyZWZuYW1lZGl2PgorICAgIDxyZWZuYW1lPmVhcG9sX3Rlc3Q8L3JlZm5hbWU+CisKKyAgICA8cmVmcHVycG9zZT5FQVAgcGVlciBhbmQgUkFESVVTIGNsaWVudCB0ZXN0aW5nPC9yZWZwdXJwb3NlPgorICA8L3JlZm5hbWVkaXY+CisKKyAgPHJlZnN5bm9wc2lzZGl2PgorICAgIDxjbWRzeW5vcHNpcz4KKyAgICAgIDxjb21tYW5kPmVhcG9sX3Rlc3Q8L2NvbW1hbmQ+CisgICAgICA8YXJnPi1uV1M8L2FyZz4KKyAgICAgIDxhcmc+LWM8cmVwbGFjZWFibGU+Y29uZmlnIGZpbGU8L3JlcGxhY2VhYmxlPjwvYXJnPgorICAgICAgPGFyZz4tYTxyZXBsYWNlYWJsZT5zZXJ2ZXIgSVAgYWRkcmVzczwvcmVwbGFjZWFibGU+PC9hcmc+CisgICAgICA8YXJnPi1BPHJlcGxhY2VhYmxlPmNsaWVudCBJUCBhZGRyZXNzPC9yZXBsYWNlYWJsZT48L2FyZz4KKyAgICAgIDxhcmc+LXA8cmVwbGFjZWFibGU+VURQIHBvcnQ8L3JlcGxhY2VhYmxlPjwvYXJnPgorICAgICAgPGFyZz4tczxyZXBsYWNlYWJsZT5zaGFyZWQgc2VjcmV0PC9yZXBsYWNlYWJsZT48L2FyZz4KKyAgICAgIDxhcmc+LXI8cmVwbGFjZWFibGU+cmUtYXV0aGVudGljYXRpb25zPC9yZXBsYWNlYWJsZT48L2FyZz4KKyAgICAgIDxhcmc+LXQ8cmVwbGFjZWFibGU+dGltZW91dDwvcmVwbGFjZWFibGU+PC9hcmc+CisgICAgICA8YXJnPi1DPHJlcGxhY2VhYmxlPkNvbm5lY3QtSW5mbzwvcmVwbGFjZWFibGU+PC9hcmc+CisgICAgICA8YXJnPi1NPHJlcGxhY2VhYmxlPk1BQyBhZGRyZXNzPC9yZXBsYWNlYWJsZT48L2FyZz4KKyAgICAgIDxhcmc+LW88cmVwbGFjZWFibGU+ZmlsZTwvcmVwbGFjZWFibGU+PC9hcmc+CisgICAgICA8YXJnPi1OPHJlcGxhY2VhYmxlPmF0dHIgc3BlYzwvcmVwbGFjZWFibGU+PC9hcmc+CisgICAgPC9jbWRzeW5vcHNpcz4KKyAgICA8Y21kc3lub3BzaXM+CisgICAgICA8Y29tbWFuZD5lYXBvbF90ZXN0IHNjYXJkPC9jb21tYW5kPgorICAgIDwvY21kc3lub3BzaXM+CisgICAgPGNtZHN5bm9wc2lzPgorICAgICAgPGNvbW1hbmQ+ZWFwb2xfdGVzdCBzaW08L2NvbW1hbmQ+CisgICAgICA8YXJnPlBJTjwvYXJnPgorICAgICAgPGFyZz5udW0gdHJpcGxldHM8L2FyZz4KKyAgICA8L2NtZHN5bm9wc2lzPgorICA8L3JlZnN5bm9wc2lzZGl2PgorCisgIDxyZWZzZWN0MT4KKyAgICA8dGl0bGU+T3ZlcnZpZXc8L3RpdGxlPgorCisgICAgPHBhcmE+ZWFwb2xfdGVzdCBpcyBhIHByb2dyYW0gdGhhdCBsaW5rcyB0b2dldGhlciB0aGUgc2FtZSBFQVAKKyAgICBwZWVyIGltcGxlbWVudGF0aW9uIHRoYXQgd3BhX3N1cHBsaWNhbnQgaXMgdXNpbmcgYW5kIHRoZSBSQURJVVMKKyAgICBhdXRoZW50aWNhdGlvbiBjbGllbnQgY29kZSBmcm9tIGhvc3RhcGQuIEluIGFkZGl0aW9uLCBpdCBoYXMKKyAgICBtaW5pbWFsIGdsdWUgY29kZSB0byBjb21iaW5lIHRoZXNlIHR3byBjb21wb25lbnRzIGluIHNpbWlsYXIKKyAgICB3YXlzIHRvIElFRUUgODAyLjFYL0VBUE9MIEF1dGhlbnRpY2F0b3Igc3RhdGUgbWFjaGluZXMuIEluIG90aGVyCisgICAgd29yZHMsIGl0IGludGVncmF0ZXMgSUVFRSA4MDIuMVggQXV0aGVudGljYXRvciAobm9ybWFsbHksIGFuCisgICAgYWNjZXNzIHBvaW50KSBhbmQgSUVFRSA4MDIuMVggU3VwcGxpY2FudCAobm9ybWFsbHksIGEgd2lyZWxlc3MKKyAgICBjbGllbnQpIHRvZ2V0aGVyIHRvIGdlbmVyYXRlIGEgc2luZ2xlIHByb2dyYW0gdGhhdCBjYW4gYmUgdXNlZCB0bworICAgIHRlc3QgRUFQIG1ldGhvZHMgd2l0aG91dCBoYXZpbmcgdG8gc2V0dXAgYW4gYWNjZXNzIHBvaW50IGFuZCBhCisgICAgd2lyZWxlc3MgY2xpZW50LjwvcGFyYT4KKworICAgIDxwYXJhPlRoZSBtYWluIHVzZXMgZm9yIGVhcG9sX3Rlc3QgYXJlIGluIGludGVyb3BlcmFiaWxpdHkgdGVzdGluZworICAgIG9mIEVBUCBtZXRob2RzIGFnYWluc3QgUkFESVVTIHNlcnZlcnMgYW5kIGluIGRldmVsb3BtZW50IHRlc3RpbmcKKyAgICBmb3IgbmV3IEVBUCBtZXRob2RzLiBJdCBjYW4gYmUgZWFzaWx5IHVzZWQgdG8gYXV0b21hdGUgRUFQIHRlc3RpbmcKKyAgICBmb3IgaW50ZXJvcGVyYWJpbGl0eSBhbmQgcmVncmVzc2lvbiBzaW5jZSB0aGUgcHJvZ3JhbSBjYW4gYmUgcnVuCisgICAgZnJvbSBzaGVsbCBzY3JpcHRzIHdpdGhvdXQgcmVxdWlyZSBhZGRpdGlvbmFsIHRlc3QgY29tcG9uZW50cyBhcGFydAorICAgIGZyb20gYSBSQURJVVMgc2VydmVyLiBGb3IgZXhhbXBsZSwgdGhlIGF1dG9tYXRlZCBFQVAgdGVzdHMgZGVzY3JpYmVkCisgICAgaW4gZWFwX3Rlc3RpbmcudHh0IGFyZSBpbXBsZW1lbnRlZCB3aXRoIGVhcG9sX3Rlc3QuIFNpbWlsYXJseSwKKyAgICBlYXBvbF90ZXN0IGNvdWxkIGJlIHVzZWQgdG8gaW1wbGVtZW50IGFuIGF1dG9tYXRlZCByZWdyZXNzaW9uCisgICAgdGVzdCBzdWl0ZSBmb3IgYSBSQURJVVMgYXV0aGVudGljYXRpb24gc2VydmVyLjwvcGFyYT4KKworCisgICAgPHBhcmE+QXMgYW4gZXhhbXBsZTo8L3BhcmE+CisKKzxibG9ja3F1b3RlPjxwcm9ncmFtbGlzdGluZz4KK2VhcG9sX3Rlc3QgLWN0ZXN0LmNvbmYgLWExMjcuMC4wLjEgLXAxODEyIC1zc2VjcmV0IC1yMQorPC9wcm9ncmFtbGlzdGluZz48L2Jsb2NrcXVvdGU+CisKKyAgICA8cGFyYT50cmllcyB0byBjb21wbGV0ZSBFQVAgYXV0aGVudGljYXRpb24gYmFzZWQgb24gdGhlIG5ldHdvcmsKKyAgICBjb25maWd1cmF0aW9uIGZyb20gdGVzdC5jb25mIGFnYWluc3QgdGhlIFJBRElVUyBzZXJ2ZXIgcnVubmluZworICAgIG9uIHRoZSBsb2NhbCBob3N0LiBBIHJlLWF1dGhlbnRpY2F0aW9uIGlzIHRyaWdnZXJlZCB0byB0ZXN0IGZhc3QKKyAgICByZS1hdXRoZW50aWNhdGlvbi4gVGhlIGNvbmZpZ3VyYXRpb24gZmlsZSB1c2VzIHRoZSBzYW1lIGZvcm1hdCBmb3IKKyAgICBuZXR3b3JrIGJsb2NrcyBhcyB3cGFfc3VwcGxpY2FudC48L3BhcmE+CisKKyAgPC9yZWZzZWN0MT4KKyAgPHJlZnNlY3QxPgorICAgIDx0aXRsZT5Db21tYW5kIEFyZ3VtZW50czwvdGl0bGU+CisgICAgPHZhcmlhYmxlbGlzdD4KKyAgICAgIDx2YXJsaXN0ZW50cnk+CisJPHRlcm0+LWMgY29uZmlndXJhdGlvbiBmaWxlIHBhdGg8L3Rlcm0+CisKKwk8bGlzdGl0ZW0+PHBhcmE+QSBjb25maWd1cmF0aW9uIHRvIHVzZS4gIFRoZSBjb25maWd1cmF0aW9uIHNob3VsZAorCXVzZSB0aGUgc2FtZSBmb3JtYXQgZm9yIG5ldHdvcmsgYmxvY2tzIGFzIHdwYV9zdXBwbGljYW50LgorCTwvcGFyYT48L2xpc3RpdGVtPgorICAgICAgPC92YXJsaXN0ZW50cnk+CisKKyAgICAgIDx2YXJsaXN0ZW50cnk+CisJPHRlcm0+LWEgQVMgYWRkcmVzczwvdGVybT4KKworCTxsaXN0aXRlbT48cGFyYT5JUCBhZGRyZXNzIG9mIHRoZSBhdXRoZW50aWNhdGlvbiBzZXJ2ZXIuICBUaGUKKwlkZWZhdWx0IGlzICcxMjcuMC4wLjEnLjwvcGFyYT48L2xpc3RpdGVtPgorICAgICAgPC92YXJsaXN0ZW50cnk+CisKKyAgICAgIDx2YXJsaXN0ZW50cnk+CisJPHRlcm0+LUEgY2xpZW50IGFkZHJlc3M8L3Rlcm0+CisKKwk8bGlzdGl0ZW0+PHBhcmE+SVAgYWRkcmVzcyBvZiB0aGUgY2xpZW50LiAgVGhlIGRlZmF1bHQgaXMgdG8KKwlzZWxlY3QgYW4gYWRkcmVzcyBhdXRvbWF0aWNhbGx5LjwvcGFyYT48L2xpc3RpdGVtPgorICAgICAgPC92YXJsaXN0ZW50cnk+CisKKyAgICAgIDx2YXJsaXN0ZW50cnk+CisJPHRlcm0+LXAgQVMgcG9ydDwvdGVybT4KKworCTxsaXN0aXRlbT48cGFyYT5VRFAgcG9ydCBvZiB0aGUgYXV0aGVudGljYXRpb24gc2VydmVyLiBUaGUKKwlkZWZhdWx0IGlzICcxODEyJy48L3BhcmE+PC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi1zIEFTIHNlY3JldDwvdGVybT4KKworCTxsaXN0aXRlbT48cGFyYT5TaGFyZWQgc2VjcmV0IHdpdGggdGhlIGF1dGhlbnRpY2F0aW9uIHNlcnZlci4KKwlUaGUgZGVmYXVsdCBpcyAncmFkaXVzJy48L3BhcmE+PC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi1yIGNvdW50PC90ZXJtPgorCisJPGxpc3RpdGVtPjxwYXJhPk51bWJlciBvZiByZWF1dGhlbnRpY2F0aW9ucy48L3BhcmE+PC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi10IHRpbWVvdXQ8L3Rlcm0+CisKKwk8bGlzdGl0ZW0+PHBhcmE+VGltZW91dCBpbiBzZWNvbmRzLiBUaGUgZGVmYXVsdCBpcyAzMC48L3BhcmE+PC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi1DIGluZm88L3Rlcm0+CisKKwk8bGlzdGl0ZW0+PHBhcmE+UkFESVVTIENvbm5lY3QtSW5mby4gIFRoZSBkZWZhdWx0IGlzCisJJ0NPTk5FQ1QgMTFNYnBzIDgwMi4xMWInLjwvcGFyYT48L2xpc3RpdGVtPgorICAgICAgPC92YXJsaXN0ZW50cnk+CisKKworICAgICAgPHZhcmxpc3RlbnRyeT4KKwk8dGVybT4tTSBtYWMgYWRkcmVzczwvdGVybT4KKworCTxsaXN0aXRlbT48cGFyYT5DbGllbnQgTUFDIGFkZHJlc3MgKENhbGxpbmctU3RhdGlvbi1JZCkuICBUaGUKKwlkZWZhdWx0IGlzICcwMjowMDowMDowMDowMDowMScuPC9wYXJhPjwvbGlzdGl0ZW0+CisgICAgICA8L3Zhcmxpc3RlbnRyeT4KKworICAgICAgPHZhcmxpc3RlbnRyeT4KKwk8dGVybT4tbyBmaWxlPC90ZXJtPgorCisJPGxpc3RpdGVtPjxwYXJhPkxvY2F0aW9uIHRvIHdyaXRlIG91dCBzZXJ2ZXIgY2VydGlmaWNhdGUuCisJPC9wYXJhPjwvbGlzdGl0ZW0+CisgICAgICA8L3Zhcmxpc3RlbnRyeT4KKworICAgICAgPHZhcmxpc3RlbnRyeT4KKwk8dGVybT4tTiBhdHRyIHNwZWM8L3Rlcm0+CisKKwk8bGlzdGl0ZW0+PHBhcmE+U2VuZCBhcmJpdHJhcnkgYXR0cmlidXRlIHNwZWNpZmljIGJ5CisJYXR0cl9pZDpzeW50YXg6dmFsdWUsIG9yIGF0dHJfaWQgYWxvbmUuICBhdHRyX2lkIHNob3VsZCBiZSB0aGUgbnVtZXJpYworCUlEIG9mIHRoZSBhdHRyaWJ1dGUsIGFuZCBzeW50YXggc2hvdWxkIGJlIG9uZSBvZiAncycgKHN0cmluZyksCisJJ2QnIChpbnRlZ2VyKSwgb3IgJ3gnIChvY3RldCBzdHJpbmcpLiBUaGUgdmFsdWUgaXMgdGhlIGF0dHJpYnV0ZSB2YWx1ZQorCXRvIHNlbmQuICBXaGVuIGF0dHJfaWQgaXMgZ2l2ZW4gYWxvbmUsIE5VTEwgaXMgdXNlZCBhcyB0aGUgYXR0cmlidXRlCisJdmFsdWUuICBNdWx0aXBsZSBhdHRyaWJ1dGVzIGNhbiBiZSBzcGVjaWZpZWQgYnkgdXNpbmcgdGhlIG9wdGlvbgorCXNldmVyYWwgdGltZXMuPC9wYXJhPjwvbGlzdGl0ZW0+CisgICAgICA8L3Zhcmxpc3RlbnRyeT4KKworICAgICAgPHZhcmxpc3RlbnRyeT4KKwk8dGVybT4tbjwvdGVybT4KKworCTxsaXN0aXRlbT48cGFyYT5JbmRpY2F0ZXMgdGhhdCBubyBNUFBFIGtleXMgYXJlIGV4cGVjdGVkLgorCTwvcGFyYT48L2xpc3RpdGVtPgorICAgICAgPC92YXJsaXN0ZW50cnk+CisKKyAgICAgIDx2YXJsaXN0ZW50cnk+CisJPHRlcm0+LVc8L3Rlcm0+CisKKwk8bGlzdGl0ZW0+PHBhcmE+V2FpdCBmb3IgYSBjb250cm9sIGludGVyZmFjZSBtb25pdG9yIGJlZm9yZSBzdGFydGluZy4KKwk8L3BhcmE+PC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi1TPC90ZXJtPgorCisJPGxpc3RpdGVtPjxwYXJhPlNhdmUgY29uZmlndXJhdGlvbiBhZnRlciBhdXRoZW50aWNhdGlvbi4KKwk8L3BhcmE+PC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgPC92YXJpYWJsZWxpc3Q+CisgIDwvcmVmc2VjdDE+CisgIDxyZWZzZWN0MT4KKyAgICA8dGl0bGU+U2VlIEFsc288L3RpdGxlPgorICAgIDxwYXJhPgorICAgICAgPGNpdGVyZWZlbnRyeT4KKwk8cmVmZW50cnl0aXRsZT53cGFfc3VwcGxpY2FudDwvcmVmZW50cnl0aXRsZT4KKwk8bWFudm9sbnVtPjg8L21hbnZvbG51bT4KKyAgICAgIDwvY2l0ZXJlZmVudHJ5PgorICAgIDwvcGFyYT4KKyAgPC9yZWZzZWN0MT4KKyAgPHJlZnNlY3QxPgorICAgIDx0aXRsZT5MZWdhbDwvdGl0bGU+CisgICAgPHBhcmE+d3BhX3N1cHBsaWNhbnQgaXMgY29weXJpZ2h0IChjKSAyMDAzLTIwMTQsCisgICAgSm91bmkgTWFsaW5lbiA8ZW1haWw+akB3MS5maTwvZW1haWw+IGFuZAorICAgIGNvbnRyaWJ1dG9ycy4KKyAgICBBbGwgUmlnaHRzIFJlc2VydmVkLjwvcGFyYT4KKworICAgIDxwYXJhPlRoaXMgcHJvZ3JhbSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQlNEIGxpY2Vuc2UgKHRoZSBvbmUgd2l0aAorICAgIGFkdmVydGlzZW1lbnQgY2xhdXNlIHJlbW92ZWQpLjwvcGFyYT4KKyAgPC9yZWZzZWN0MT4KKzwvcmVmZW50cnk+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfYmFja2dyb3VuZC5zZ21sIGIvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2JhY2tncm91bmQuc2dtbAppbmRleCBlYjNhMDg5Li44NjBiNWEwIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfYmFja2dyb3VuZC5zZ21sCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9iYWNrZ3JvdW5kLnNnbWwKQEAgLTkwLDcgKzkwLDcgQEAKIAogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2NsaS5zZ21sIGIvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2NsaS5zZ21sCmluZGV4IGMwODBjMDcuLjE0MmUxYWIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9jbGkuc2dtbAorKysgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfY2xpLnNnbWwKQEAgLTE1LDEwICsxNSwxMiBAQAogICAgIDxjbWRzeW5vcHNpcz4KICAgICAgIDxjb21tYW5kPndwYV9jbGk8L2NvbW1hbmQ+CiAgICAgICA8YXJnPi1wIDxyZXBsYWNlYWJsZT5wYXRoIHRvIGN0cmwgc29ja2V0czwvcmVwbGFjZWFibGU+PC9hcmc+CisgICAgICA8YXJnPi1nIDxyZXBsYWNlYWJsZT5wYXRoIHRvIGdsb2JhbCBjdHJsX2ludGVyZmFjZSBzb2NrZXQ8L3JlcGxhY2VhYmxlPjwvYXJnPgogICAgICAgPGFyZz4taSA8cmVwbGFjZWFibGU+aWZuYW1lPC9yZXBsYWNlYWJsZT48L2FyZz4KICAgICAgIDxhcmc+LWh2QjwvYXJnPgogICAgICAgPGFyZz4tYSA8cmVwbGFjZWFibGU+YWN0aW9uIGZpbGU8L3JlcGxhY2VhYmxlPjwvYXJnPgogICAgICAgPGFyZz4tUCA8cmVwbGFjZWFibGU+cGlkIGZpbGU8L3JlcGxhY2VhYmxlPjwvYXJnPgorICAgICAgPGFyZz4tRyA8cmVwbGFjZWFibGU+cGluZyBpbnRlcnZhbDwvcmVwbGFjZWFibGU+PC9hcmc+CiAgICAgICA8YXJnPjxyZXBsYWNlYWJsZT5jb21tYW5kIC4uLjwvcmVwbGFjZWFibGU+PC9hcmc+CiAgICAgPC9jbWRzeW5vcHNpcz4KICAgPC9yZWZzeW5vcHNpc2Rpdj4KQEAgLTExMSw2ICsxMTMsMTQgQEAKICAgICAgIDwvdmFybGlzdGVudHJ5PgogCiAgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi1nIGNvbnRyb2wgc29ja2V0IHBhdGg8L3Rlcm0+CisKKwk8bGlzdGl0ZW0+PHBhcmE+Q29ubmVjdCB0byB0aGUgZ2xvYmFsIGNvbnRyb2wgc29ja2V0IGF0IHRoZQorCWluZGljYXRlZCBwYXRoIHJhdGhlciB0aGFuIGFuIGludGVyZmFjZS1zcGVjaWZpYyBjb250cm9sCisJc29ja2V0LjwvcGFyYT48L2xpc3RpdGVtPgorICAgICAgPC92YXJsaXN0ZW50cnk+CisKKyAgICAgIDx2YXJsaXN0ZW50cnk+CiAJPHRlcm0+LWkgaWZuYW1lPC90ZXJtPgogCiAgICAgICAgIDxsaXN0aXRlbT48cGFyYT5TcGVjaWZ5IHRoZSBpbnRlcmZhY2UgdGhhdCBpcyBiZWluZwpAQCAtMTYxLDYgKzE3MSwxMyBAQAogICAgICAgPC92YXJsaXN0ZW50cnk+CiAKICAgICAgIDx2YXJsaXN0ZW50cnk+CisJPHRlcm0+LUcgcGluZyBpbnRlcnZhbDwvdGVybT4KKworCTxsaXN0aXRlbT48cGFyYT5TZXQgdGhlIGludGVydmFsIChpbiBzZWNvbmRzKSBhdCB3aGljaAorCXdwYV9jbGkgcGluZ3MgdGhlIHN1cHBsaWNhbnQuPC9wYXJhPjwvbGlzdGl0ZW0+CisgICAgICA8L3Zhcmxpc3RlbnRyeT4KKworICAgICAgPHZhcmxpc3RlbnRyeT4KIAk8dGVybT5jb21tYW5kPC90ZXJtPgogCiAJPGxpc3RpdGVtPjxwYXJhPlJ1biBhIGNvbW1hbmQuICBUaGUgYXZhaWxhYmxlIGNvbW1hbmRzIGFyZQpAQCAtMzI4LDcgKzM0NSw3IEBACiAgIDwvcmVmc2VjdDE+CiAgIDxyZWZzZWN0MT4KICAgICA8dGl0bGU+TGVnYWw8L3RpdGxlPgotICAgIDxwYXJhPndwYV9zdXBwbGljYW50IGlzIGNvcHlyaWdodCAoYykgMjAwMy0yMDEyLAorICAgIDxwYXJhPndwYV9zdXBwbGljYW50IGlzIGNvcHlyaWdodCAoYykgMjAwMy0yMDE0LAogICAgIEpvdW5pIE1hbGluZW4gPGVtYWlsPmpAdzEuZmk8L2VtYWlsPiBhbmQKICAgICBjb250cmlidXRvcnMuCiAgICAgQWxsIFJpZ2h0cyBSZXNlcnZlZC48L3BhcmE+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfZ3VpLnNnbWwgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfZ3VpLnNnbWwKaW5kZXggMGFiNjQxOS4uZjZlZjhmMSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2d1aS5zZ21sCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9ndWkuc2dtbApAQCAtNzQsNyArNzQsNyBAQAogICA8L3JlZnNlY3QxPgogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3Bhc3NwaHJhc2Uuc2dtbCBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9wYXNzcGhyYXNlLnNnbWwKaW5kZXggMzM2YzAzYi4uM2I0MzYwYiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3Bhc3NwaHJhc2Uuc2dtbAorKysgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfcGFzc3BocmFzZS5zZ21sCkBAIC02Miw3ICs2Miw3IEBACiAgIDwvcmVmc2VjdDE+CiAgIDxyZWZzZWN0MT4KICAgICA8dGl0bGU+TGVnYWw8L3RpdGxlPgotICAgIDxwYXJhPndwYV9zdXBwbGljYW50IGlzIGNvcHlyaWdodCAoYykgMjAwMy0yMDEyLAorICAgIDxwYXJhPndwYV9zdXBwbGljYW50IGlzIGNvcHlyaWdodCAoYykgMjAwMy0yMDE0LAogICAgIEpvdW5pIE1hbGluZW4gPGVtYWlsPmpAdzEuZmk8L2VtYWlsPiBhbmQKICAgICBjb250cmlidXRvcnMuCiAgICAgQWxsIFJpZ2h0cyBSZXNlcnZlZC48L3BhcmE+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfcHJpdi5zZ21sIGIvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3ByaXYuc2dtbAppbmRleCBlYjkwN2E4Li45YzExNGNjIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfcHJpdi5zZ21sCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9wcml2LnNnbWwKQEAgLTEzNyw3ICsxMzcsNyBAQAogICA8L3JlZnNlY3QxPgogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3N1cHBsaWNhbnQuc2dtbCBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9zdXBwbGljYW50LnNnbWwKaW5kZXggYWEyMGU1Ny4uMTgyMDYwZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3N1cHBsaWNhbnQuc2dtbAorKysgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfc3VwcGxpY2FudC5zZ21sCkBAIC0xMiw3ICsxMiw3IEBACiAgIDxyZWZzeW5vcHNpc2Rpdj4KICAgICA8Y21kc3lub3BzaXM+CiAgICAgICA8Y29tbWFuZD53cGFfc3VwcGxpY2FudDwvY29tbWFuZD4KLSAgICAgIDxhcmc+LUJkZGZoS0xxcXR1dlc8L2FyZz4KKyAgICAgIDxhcmc+LUJkZGZoS0xxcXNUdHV2VzwvYXJnPgogICAgICAgPGFyZz4taTxyZXBsYWNlYWJsZT5pZm5hbWU8L3JlcGxhY2VhYmxlPjwvYXJnPgogICAgICAgPGFyZz4tYzxyZXBsYWNlYWJsZT5jb25maWcgZmlsZTwvcmVwbGFjZWFibGU+PC9hcmc+CiAgICAgICA8YXJnPi1EPHJlcGxhY2VhYmxlPmRyaXZlcjwvcmVwbGFjZWFibGU+PC9hcmc+CkBAIC0zNDQsOSArMzQ0LDIwIEBACiAgICAgICA8L3Zhcmxpc3RlbnRyeT4KIAogICAgICAgPHZhcmxpc3RlbnRyeT4KKwk8dGVybT4tZSBlbnRyb3B5IGZpbGU8L3Rlcm0+CisJPGxpc3RpdGVtPgorCSAgPHBhcmE+RmlsZSBmb3IgPGNvbW1hbmQ+d3BhX3N1cHBsaWNhbnQ8L2NvbW1hbmQ+IHRvIHVzZSB0bworCSAgbWFpbnRhaW4gaXRzIGludGVybmFsIGVudHJvcHkgc3RvcmUgaW4gb3ZlciByZXN0YXJ0cy48L3BhcmE+CisJPC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgogCTx0ZXJtPi1mIG91dHB1dCBmaWxlPC90ZXJtPgogCTxsaXN0aXRlbT4KLQkgIDxwYXJhPkxvZyBvdXRwdXQgdG8gc3BlY2lmaWVkIGZpbGUgaW5zdGVhZCBvZiBzdGRvdXQuPC9wYXJhPgorCSAgPHBhcmE+TG9nIG91dHB1dCB0byBzcGVjaWZpZWQgZmlsZSBpbnN0ZWFkIG9mIHN0ZG91dC4gKFRoaXMKKwkgIGlzIG9ubHkgYXZhaWxhYmxlIGlmIDxjb21tYW5kPndwYV9zdXBwbGljYW50PC9jb21tYW5kPiB3YXMKKwkgIGJ1aWx0IHdpdGggdGhlIDxsaXRlcmFsPkNPTkZJR19ERUJVR19GSUxFPC9saXRlcmFsPgorCSAgb3B0aW9uLik8L3BhcmE+CiAJPC9saXN0aXRlbT4KICAgICAgIDwvdmFybGlzdGVudHJ5PgogCkBAIC0zODcsNiArMzk4LDIyIEBACiAgICAgICA8L3Zhcmxpc3RlbnRyeT4KIAogICAgICAgPHZhcmxpc3RlbnRyeT4KKwk8dGVybT4tbyBvdmVycmlkZSBkcml2ZXI8L3Rlcm0+CisJPGxpc3RpdGVtPgorCSAgPHBhcmE+T3ZlcnJpZGUgdGhlIGRyaXZlciBwYXJhbWV0ZXIgZm9yIG5ldworCSAgaW50ZXJmYWNlcy48L3BhcmE+CisJPC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi1PIG92ZXJyaWRlIGN0cmxfaW50ZXJmYWNlPC90ZXJtPgorCTxsaXN0aXRlbT4KKwkgIDxwYXJhPk92ZXJyaWRlIHRoZSBjdHJsX2ludGVyZmFjZSBwYXJhbWV0ZXIgZm9yIG5ldworCSAgaW50ZXJmYWNlcy48L3BhcmE+CisJPC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgogCTx0ZXJtPi1wPC90ZXJtPgogCTxsaXN0aXRlbT4KIAkgIDxwYXJhPkRyaXZlciBwYXJhbWV0ZXJzLiAoUGVyIGludGVyZmFjZSk8L3BhcmE+CkBAIC00MDksMTAgKzQzNiw0MCBAQAogICAgICAgPC92YXJsaXN0ZW50cnk+CiAKICAgICAgIDx2YXJsaXN0ZW50cnk+CisJPHRlcm0+LXM8L3Rlcm0+CisJPGxpc3RpdGVtPgorCSAgPHBhcmE+TG9nIG91dHB1dCB0byBzeXNsb2cgaW5zdGVhZCBvZiBzdGRvdXQuIChUaGlzIGlzIG9ubHkKKwkgIGF2YWlsYWJsZSBpZiA8Y29tbWFuZD53cGFfc3VwcGxpY2FudDwvY29tbWFuZD4gd2FzIGJ1aWx0CisJICB3aXRoIHRoZSA8bGl0ZXJhbD5DT05GSUdfREVCVUdfU1lTTE9HPC9saXRlcmFsPgorCSAgb3B0aW9uLik8L3BhcmE+CisJPC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi1UPC90ZXJtPgorCTxsaXN0aXRlbT4KKwkgIDxwYXJhPkxvZyBvdXRwdXQgdG8gTGludXggdHJhY2luZyBpbiBhZGRpdGlvbiB0byBhbnkgb3RoZXIKKwkgIGRlc3RpbmF0aW9ucy4gKFRoaXMgaXMgb25seSBhdmFpbGFibGUKKwkgIGlmIDxjb21tYW5kPndwYV9zdXBwbGljYW50PC9jb21tYW5kPiB3YXMgYnVpbHQgd2l0aAorCSAgdGhlIDxsaXRlcmFsPkNPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HPC9saXRlcmFsPgorCSAgb3B0aW9uLik8L3BhcmE+CisJPC9saXN0aXRlbT4KKyAgICAgIDwvdmFybGlzdGVudHJ5PgorCisgICAgICA8dmFybGlzdGVudHJ5PgorCTx0ZXJtPi10PC90ZXJtPgorCTxsaXN0aXRlbT4KKwkgIDxwYXJhPkluY2x1ZGUgdGltZXN0YW1wIGluIGRlYnVnIG1lc3NhZ2VzLjwvcGFyYT4KKwk8L2xpc3RpdGVtPgorICAgICAgPC92YXJsaXN0ZW50cnk+CisKKyAgICAgIDx2YXJsaXN0ZW50cnk+CiAJPHRlcm0+LXU8L3Rlcm0+CiAJPGxpc3RpdGVtPgotCSAgPHBhcmE+RW5hYmxlZCBEQnVzIGNvbnRyb2wgaW50ZXJmYWNlLiBJZiBlbmFibGVkLCBpbnRlcmZhY2UKLQkgIGRlZmluaXRpb25zIG1heSBiZSBvbWl0dGVkLjwvcGFyYT4KKwkgIDxwYXJhPkVuYWJsZSBEQnVzIGNvbnRyb2wgaW50ZXJmYWNlLiBJZiBlbmFibGVkLCBpbnRlcmZhY2UKKwkgIGRlZmluaXRpb25zIG1heSBiZSBvbWl0dGVkLiAoVGhpcyBpcyBvbmx5IGF2YWlsYWJsZQorCSAgaWYgPGNvbW1hbmQ+d3BhX3N1cHBsaWNhbnQ8L2NvbW1hbmQ+IHdhcyBidWlsdCB3aXRoCisJICB0aGUgPGxpdGVyYWw+Q09ORklHX0RCVVM8L2xpdGVyYWw+IG9wdGlvbi4pPC9wYXJhPjAKIAk8L2xpc3RpdGVtPgogICAgICAgPC92YXJsaXN0ZW50cnk+CiAKQEAgLTY3OSw3ICs3MzYsNyBAQAogICA8L3JlZnNlY3QxPgogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZHJpdmVyX2kuaCBiL3dwYV9zdXBwbGljYW50L2RyaXZlcl9pLmgKaW5kZXggNWU3ZGJmNy4uMDA3MDNkOSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZHJpdmVyX2kuaAorKysgYi93cGFfc3VwcGxpY2FudC9kcml2ZXJfaS5oCkBAIC0xMTcsMTEgKzExNywxNiBAQAogc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9zZXRfa2V5KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJICBlbnVtIHdwYV9hbGcgYWxnLCBjb25zdCB1OCAqYWRkciwKIAkJCQkgIGludCBrZXlfaWR4LCBpbnQgc2V0X3R4LAotCQkJCSAgIGNvbnN0IHU4ICpzZXEsIHNpemVfdCBzZXFfbGVuLAotCQkJCSAgIGNvbnN0IHU4ICprZXksIHNpemVfdCBrZXlfbGVuKQorCQkJCSAgY29uc3QgdTggKnNlcSwgc2l6ZV90IHNlcV9sZW4sCisJCQkJICBjb25zdCB1OCAqa2V5LCBzaXplX3Qga2V5X2xlbikKIHsKKwlpZiAoYWxnICE9IFdQQV9BTEdfTk9ORSkgeworCQlpZiAoa2V5X2lkeCA+PSAwICYmIGtleV9pZHggPD0gNikKKwkJCXdwYV9zLT5rZXlzX2NsZWFyZWQgJj0gfkJJVChrZXlfaWR4KTsKKwkJZWxzZQorCQkJd3BhX3MtPmtleXNfY2xlYXJlZCA9IDA7CisJfQogCWlmICh3cGFfcy0+ZHJpdmVyLT5zZXRfa2V5KSB7Ci0JCXdwYV9zLT5rZXlzX2NsZWFyZWQgPSAwOwogCQlyZXR1cm4gd3BhX3MtPmRyaXZlci0+c2V0X2tleSh3cGFfcy0+aWZuYW1lLCB3cGFfcy0+ZHJ2X3ByaXYsCiAJCQkJCSAgICAgIGFsZywgYWRkciwga2V5X2lkeCwgc2V0X3R4LAogCQkJCQkgICAgICBzZXEsIHNlcV9sZW4sIGtleSwga2V5X2xlbik7CkBAIC0yMDEsNiArMjA2LDE0IEBACiAJcmV0dXJuIE5VTEw7CiB9CiAKK3N0YXRpYyBpbmxpbmUgY29uc3QgY2hhciAqCit3cGFfZHJpdmVyX2dldF9yYWRpb19uYW1lKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJaWYgKHdwYV9zLT5kcml2ZXItPmdldF9yYWRpb19uYW1lKQorCQlyZXR1cm4gd3BhX3MtPmRyaXZlci0+Z2V0X3JhZGlvX25hbWUod3BhX3MtPmRydl9wcml2KTsKKwlyZXR1cm4gTlVMTDsKK30KKwogc3RhdGljIGlubGluZSBjb25zdCB1OCAqIHdwYV9kcnZfZ2V0X21hY19hZGRyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJaWYgKHdwYV9zLT5kcml2ZXItPmdldF9tYWNfYWRkcikgewpAQCAtMzgwLDcgKzM5Myw3IEBACiAJaWYgKHdwYV9zLT5kcml2ZXItPmlmX2FkZCkKIAkJcmV0dXJuIHdwYV9zLT5kcml2ZXItPmlmX2FkZCh3cGFfcy0+ZHJ2X3ByaXYsIHR5cGUsIGlmbmFtZSwKIAkJCQkJICAgICBhZGRyLCBic3NfY3R4LCBOVUxMLCBmb3JjZV9pZm5hbWUsCi0JCQkJCSAgICAgaWZfYWRkciwgYnJpZGdlKTsKKwkJCQkJICAgICBpZl9hZGRyLCBicmlkZ2UsIDApOwogCXJldHVybiAtMTsKIH0KIApAQCAtNTE2LDE0MyArNTI5LDE3IEBACiAJcmV0dXJuIHdwYV9zLT5kcml2ZXItPmFtcGR1KHdwYV9zLT5kcnZfcHJpdiwgYW1wZHUpOwogfQogCi1zdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X3AycF9maW5kKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgdW5zaWduZWQgaW50IHRpbWVvdXQsIGludCB0eXBlKQotewotCWlmICghd3BhX3MtPmRyaXZlci0+cDJwX2ZpbmQpCi0JCXJldHVybiAtMTsKLQlyZXR1cm4gd3BhX3MtPmRyaXZlci0+cDJwX2ZpbmQod3BhX3MtPmRydl9wcml2LCB0aW1lb3V0LCB0eXBlKTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9wMnBfc3RvcF9maW5kKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCi17Ci0JaWYgKCF3cGFfcy0+ZHJpdmVyLT5wMnBfc3RvcF9maW5kKQotCQlyZXR1cm4gLTE7Ci0JcmV0dXJuIHdwYV9zLT5kcml2ZXItPnAycF9zdG9wX2ZpbmQod3BhX3MtPmRydl9wcml2KTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9wMnBfbGlzdGVuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgICB1bnNpZ25lZCBpbnQgdGltZW91dCkKLXsKLQlpZiAoIXdwYV9zLT5kcml2ZXItPnAycF9saXN0ZW4pCi0JCXJldHVybiAtMTsKLQlyZXR1cm4gd3BhX3MtPmRyaXZlci0+cDJwX2xpc3Rlbih3cGFfcy0+ZHJ2X3ByaXYsIHRpbWVvdXQpOwotfQotCi1zdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X3AycF9jb25uZWN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgICAgY29uc3QgdTggKnBlZXJfYWRkciwgaW50IHdwc19tZXRob2QsCi0JCQkJICAgICAgaW50IGdvX2ludGVudCwKLQkJCQkgICAgICBjb25zdCB1OCAqb3duX2ludGVyZmFjZV9hZGRyLAotCQkJCSAgICAgIHVuc2lnbmVkIGludCBmb3JjZV9mcmVxLAotCQkJCSAgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwKQotewotCWlmICghd3BhX3MtPmRyaXZlci0+cDJwX2Nvbm5lY3QpCi0JCXJldHVybiAtMTsKLQlyZXR1cm4gd3BhX3MtPmRyaXZlci0+cDJwX2Nvbm5lY3Qod3BhX3MtPmRydl9wcml2LCBwZWVyX2FkZHIsCi0JCQkJCSAgd3BzX21ldGhvZCwgZ29faW50ZW50LAotCQkJCQkgIG93bl9pbnRlcmZhY2VfYWRkciwgZm9yY2VfZnJlcSwKLQkJCQkJICBwZXJzaXN0ZW50X2dyb3VwKTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl93cHNfc3VjY2Vzc19jYihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJCQkgY29uc3QgdTggKnBlZXJfYWRkcikKLXsKLQlpZiAoIXdwYV9zLT5kcml2ZXItPndwc19zdWNjZXNzX2NiKQotCQlyZXR1cm4gLTE7Ci0JcmV0dXJuIHdwYV9zLT5kcml2ZXItPndwc19zdWNjZXNzX2NiKHdwYV9zLT5kcnZfcHJpdiwgcGVlcl9hZGRyKTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQKLXdwYV9kcnZfcDJwX2dyb3VwX2Zvcm1hdGlvbl9mYWlsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKLXsKLQlpZiAoIXdwYV9zLT5kcml2ZXItPnAycF9ncm91cF9mb3JtYXRpb25fZmFpbGVkKQotCQlyZXR1cm4gLTE7Ci0JcmV0dXJuIHdwYV9zLT5kcml2ZXItPnAycF9ncm91cF9mb3JtYXRpb25fZmFpbGVkKHdwYV9zLT5kcnZfcHJpdik7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfcDJwX3NldF9wYXJhbXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkJIGNvbnN0IHN0cnVjdCBwMnBfcGFyYW1zICpwYXJhbXMpCi17Ci0JaWYgKCF3cGFfcy0+ZHJpdmVyLT5wMnBfc2V0X3BhcmFtcykKLQkJcmV0dXJuIC0xOwotCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5wMnBfc2V0X3BhcmFtcyh3cGFfcy0+ZHJ2X3ByaXYsIHBhcmFtcyk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfcDJwX3Byb3ZfZGlzY19yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkJICAgIGNvbnN0IHU4ICpwZWVyX2FkZHIsCi0JCQkJCSAgICB1MTYgY29uZmlnX21ldGhvZHMsIGludCBqb2luKQotewotCWlmICghd3BhX3MtPmRyaXZlci0+cDJwX3Byb3ZfZGlzY19yZXEpCi0JCXJldHVybiAtMTsKLQlyZXR1cm4gd3BhX3MtPmRyaXZlci0+cDJwX3Byb3ZfZGlzY19yZXEod3BhX3MtPmRydl9wcml2LCBwZWVyX2FkZHIsCi0JCQkJCQljb25maWdfbWV0aG9kcywgam9pbik7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdTY0IHdwYV9kcnZfcDJwX3NkX3JlcXVlc3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkJIGNvbnN0IHU4ICpkc3QsCi0JCQkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICp0bHZzKQotewotCWlmICghd3BhX3MtPmRyaXZlci0+cDJwX3NkX3JlcXVlc3QpCi0JCXJldHVybiAwOwotCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5wMnBfc2RfcmVxdWVzdCh3cGFfcy0+ZHJ2X3ByaXYsIGRzdCwgdGx2cyk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfcDJwX3NkX2NhbmNlbF9yZXF1ZXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCQl1NjQgcmVxKQotewotCWlmICghd3BhX3MtPmRyaXZlci0+cDJwX3NkX2NhbmNlbF9yZXF1ZXN0KQotCQlyZXR1cm4gLTE7Ci0JcmV0dXJuIHdwYV9zLT5kcml2ZXItPnAycF9zZF9jYW5jZWxfcmVxdWVzdCh3cGFfcy0+ZHJ2X3ByaXYsIHJlcSk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfcDJwX3NkX3Jlc3BvbnNlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgaW50IGZyZXEsIGNvbnN0IHU4ICpkc3QsCi0JCQkJCSAgdTggZGlhbG9nX3Rva2VuLAotCQkJCQkgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnJlc3BfdGx2cykKLXsKLQlpZiAoIXdwYV9zLT5kcml2ZXItPnAycF9zZF9yZXNwb25zZSkKLQkJcmV0dXJuIC0xOwotCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5wMnBfc2RfcmVzcG9uc2Uod3BhX3MtPmRydl9wcml2LCBmcmVxLCBkc3QsCi0JCQkJCSAgICAgIGRpYWxvZ190b2tlbiwgcmVzcF90bHZzKTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9wMnBfc2VydmljZV91cGRhdGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKLXsKLQlpZiAoIXdwYV9zLT5kcml2ZXItPnAycF9zZXJ2aWNlX3VwZGF0ZSkKLQkJcmV0dXJuIC0xOwotCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5wMnBfc2VydmljZV91cGRhdGUod3BhX3MtPmRydl9wcml2KTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9wMnBfcmVqZWN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgICBjb25zdCB1OCAqYWRkcikKLXsKLQlpZiAoIXdwYV9zLT5kcml2ZXItPnAycF9yZWplY3QpCi0JCXJldHVybiAtMTsKLQlyZXR1cm4gd3BhX3MtPmRyaXZlci0+cDJwX3JlamVjdCh3cGFfcy0+ZHJ2X3ByaXYsIGFkZHIpOwotfQotCi1zdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X3AycF9pbnZpdGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgICAgIGNvbnN0IHU4ICpwZWVyLCBpbnQgcm9sZSwgY29uc3QgdTggKmJzc2lkLAotCQkJCSAgICAgY29uc3QgdTggKnNzaWQsIHNpemVfdCBzc2lkX2xlbiwKLQkJCQkgICAgIGNvbnN0IHU4ICpnb19kZXZfYWRkciwKLQkJCQkgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwKQotewotCWlmICghd3BhX3MtPmRyaXZlci0+cDJwX2ludml0ZSkKLQkJcmV0dXJuIC0xOwotCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5wMnBfaW52aXRlKHdwYV9zLT5kcnZfcHJpdiwgcGVlciwgcm9sZSwgYnNzaWQsCi0JCQkJCSBzc2lkLCBzc2lkX2xlbiwgZ29fZGV2X2FkZHIsCi0JCQkJCSBwZXJzaXN0ZW50X2dyb3VwKTsKLX0KLQogc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9zZW5kX3RkbHNfbWdtdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgY29uc3QgdTggKmRzdCwgdTggYWN0aW9uX2NvZGUsCiAJCQkJCSB1OCBkaWFsb2dfdG9rZW4sIHUxNiBzdGF0dXNfY29kZSwKLQkJCQkJIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCisJCQkJCSB1MzIgcGVlcl9jYXBhYiwgY29uc3QgdTggKmJ1ZiwKKwkJCQkJIHNpemVfdCBsZW4pCiB7CiAJaWYgKHdwYV9zLT5kcml2ZXItPnNlbmRfdGRsc19tZ210KSB7CiAJCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5zZW5kX3RkbHNfbWdtdCh3cGFfcy0+ZHJ2X3ByaXYsIGRzdCwKIAkJCQkJCSAgICAgYWN0aW9uX2NvZGUsIGRpYWxvZ190b2tlbiwKLQkJCQkJCSAgICAgc3RhdHVzX2NvZGUsIGJ1ZiwgbGVuKTsKKwkJCQkJCSAgICAgc3RhdHVzX2NvZGUsIHBlZXJfY2FwYWIsCisJCQkJCQkgICAgIGJ1ZiwgbGVuKTsKIAl9CiAJcmV0dXJuIC0xOwogfQpAQCAtNjczLDcgKzU2MCw3IEBACiAJCXJldHVybiAtMTsKIAlyZXR1cm4gd3BhX3MtPmRyaXZlci0+ZHJpdmVyX2NtZCh3cGFfcy0+ZHJ2X3ByaXYsIGNtZCwgYnVmLCBidWZfbGVuKTsKIH0KLSNlbmRpZgorI2VuZGlmIC8qIEFORFJPSUQgKi8KIAogc3RhdGljIGlubGluZSB2b2lkIHdwYV9kcnZfc2V0X3Jla2V5X2luZm8oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICBjb25zdCB1OCAqa2VrLCBjb25zdCB1OCAqa2NrLApAQCAtNjkzLDExICs1ODAsMTEgQEAKIH0KIAogc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9zd2l0Y2hfY2hhbm5lbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJCQkgdW5zaWduZWQgaW50IGZyZXEpCisJCQkJCSBzdHJ1Y3QgY3NhX3NldHRpbmdzICpzZXR0aW5ncykKIHsKIAlpZiAoIXdwYV9zLT5kcml2ZXItPnN3aXRjaF9jaGFubmVsKQogCQlyZXR1cm4gLTE7Ci0JcmV0dXJuIHdwYV9zLT5kcml2ZXItPnN3aXRjaF9jaGFubmVsKHdwYV9zLT5kcnZfcHJpdiwgZnJlcSk7CisJcmV0dXJuIHdwYV9zLT5kcml2ZXItPnN3aXRjaF9jaGFubmVsKHdwYV9zLT5kcnZfcHJpdiwgc2V0dGluZ3MpOwogfQogCiBzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X3dubV9vcGVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCkBAIC03MTAsNCArNTk3LDIzNCBAQAogCQkJCSAgICAgICBidWZfbGVuKTsKIH0KIAorc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9zdGF0dXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+c3RhdHVzKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHdwYV9zLT5kcml2ZXItPnN0YXR1cyh3cGFfcy0+ZHJ2X3ByaXYsIGJ1ZiwgYnVmbGVuKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9zZXRfcW9zX21hcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgIGNvbnN0IHU4ICpxb3NfbWFwX3NldCwgdTggcW9zX21hcF9zZXRfbGVuKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+c2V0X3Fvc19tYXApCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+c2V0X3Fvc19tYXAod3BhX3MtPmRydl9wcml2LCBxb3NfbWFwX3NldCwKKwkJCQkJICBxb3NfbWFwX3NldF9sZW4pOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X3dvd2xhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSBjb25zdCBzdHJ1Y3Qgd293bGFuX3RyaWdnZXJzICp0cmlnZ2VycykKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPnNldF93b3dsYW4pCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+c2V0X3dvd2xhbih3cGFfcy0+ZHJ2X3ByaXYsIHRyaWdnZXJzKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl92ZW5kb3JfY21kKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICBpbnQgdmVuZG9yX2lkLCBpbnQgc3ViY21kLCBjb25zdCB1OCAqZGF0YSwKKwkJCQkgICAgIHNpemVfdCBkYXRhX2xlbiwgc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+dmVuZG9yX2NtZCkKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT52ZW5kb3JfY21kKHdwYV9zLT5kcnZfcHJpdiwgdmVuZG9yX2lkLCBzdWJjbWQsCisJCQkJCSBkYXRhLCBkYXRhX2xlbiwgYnVmKTsKK30KKworCisjaWZkZWYgQ09ORklHX01BQ1NFQworCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X21hY3NlY19pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICAgc3RydWN0IG1hY3NlY19pbml0X3BhcmFtcyAqcGFyYW1zKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+bWFjc2VjX2luaXQpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+bWFjc2VjX2luaXQod3BhX3MtPmRydl9wcml2LCBwYXJhbXMpOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X21hY3NlY19kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPm1hY3NlY19kZWluaXQpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+bWFjc2VjX2RlaW5pdCh3cGFfcy0+ZHJ2X3ByaXYpOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X2VuYWJsZV9wcm90ZWN0X2ZyYW1lcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkJQm9vbGVhbiBlbmFibGVkKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+ZW5hYmxlX3Byb3RlY3RfZnJhbWVzKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHdwYV9zLT5kcml2ZXItPmVuYWJsZV9wcm90ZWN0X2ZyYW1lcyh3cGFfcy0+ZHJ2X3ByaXYsIGVuYWJsZWQpOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X3NldF9yZXBsYXlfcHJvdGVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgIEJvb2xlYW4gZW5hYmxlZCwgdTMyIHdpbmRvdykKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPnNldF9yZXBsYXlfcHJvdGVjdCkKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5zZXRfcmVwbGF5X3Byb3RlY3Qod3BhX3MtPmRydl9wcml2LCBlbmFibGVkLAorCQkJCQkJIHdpbmRvdyk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfc2V0X2N1cnJlbnRfY2lwaGVyX3N1aXRlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQkgICBjb25zdCB1OCAqY3MsIHNpemVfdCBjc19sZW4pCit7CisJaWYgKCF3cGFfcy0+ZHJpdmVyLT5zZXRfY3VycmVudF9jaXBoZXJfc3VpdGUpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+c2V0X2N1cnJlbnRfY2lwaGVyX3N1aXRlKHdwYV9zLT5kcnZfcHJpdiwgY3MsCisJCQkJCQkgICAgICAgY3NfbGVuKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9lbmFibGVfY29udHJvbGxlZF9wb3J0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQkgQm9vbGVhbiBlbmFibGVkKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+ZW5hYmxlX2NvbnRyb2xsZWRfcG9ydCkKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5lbmFibGVfY29udHJvbGxlZF9wb3J0KHdwYV9zLT5kcnZfcHJpdiwgZW5hYmxlZCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfZ2V0X3JlY2VpdmVfbG93ZXN0X3BuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQl1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJCQl1MzIgKmxvd2VzdF9wbikKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPmdldF9yZWNlaXZlX2xvd2VzdF9wbikKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5nZXRfcmVjZWl2ZV9sb3dlc3RfcG4od3BhX3MtPmRydl9wcml2LCBjaGFubmVsLAorCQkJCQkJICAgIGFuLCBsb3dlc3RfcG4pOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X2dldF90cmFuc21pdF9uZXh0X3BuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQl1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJCQl1MzIgKm5leHRfcG4pCit7CisJaWYgKCF3cGFfcy0+ZHJpdmVyLT5nZXRfdHJhbnNtaXRfbmV4dF9wbikKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5nZXRfdHJhbnNtaXRfbmV4dF9wbih3cGFfcy0+ZHJ2X3ByaXYsIGNoYW5uZWwsCisJCQkJCQkgICAgYW4sIG5leHRfcG4pOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X3NldF90cmFuc21pdF9uZXh0X3BuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQl1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJCQl1MzIgbmV4dF9wbikKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPnNldF90cmFuc21pdF9uZXh0X3BuKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHdwYV9zLT5kcml2ZXItPnNldF90cmFuc21pdF9uZXh0X3BuKHdwYV9zLT5kcnZfcHJpdiwgY2hhbm5lbCwKKwkJCQkJCSAgICBhbiwgbmV4dF9wbik7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfZ2V0X2F2YWlsYWJsZV9yZWNlaXZlX3NjKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQkgICB1MzIgKmNoYW5uZWwpCit7CisJaWYgKCF3cGFfcy0+ZHJpdmVyLT5nZXRfYXZhaWxhYmxlX3JlY2VpdmVfc2MpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+Z2V0X2F2YWlsYWJsZV9yZWNlaXZlX3NjKHdwYV9zLT5kcnZfcHJpdiwKKwkJCQkJCSAgICAgICBjaGFubmVsKTsKK30KKworc3RhdGljIGlubGluZSBpbnQKK3dwYV9kcnZfY3JlYXRlX3JlY2VpdmVfc2Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgdTMyIGNoYW5uZWwsCisJCQkgIGNvbnN0IHU4ICpzY2lfYWRkciwgdTE2IHNjaV9wb3J0LAorCQkJICB1bnNpZ25lZCBpbnQgY29uZl9vZmZzZXQsIGludCB2YWxpZGF0aW9uKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+Y3JlYXRlX3JlY2VpdmVfc2MpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+Y3JlYXRlX3JlY2VpdmVfc2Mod3BhX3MtPmRydl9wcml2LCBjaGFubmVsLAorCQkJCQkJc2NpX2FkZHIsIHNjaV9wb3J0LCBjb25mX29mZnNldCwKKwkJCQkJCXZhbGlkYXRpb24pOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X2RlbGV0ZV9yZWNlaXZlX3NjKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICB1MzIgY2hhbm5lbCkKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPmRlbGV0ZV9yZWNlaXZlX3NjKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHdwYV9zLT5kcml2ZXItPmRlbGV0ZV9yZWNlaXZlX3NjKHdwYV9zLT5kcnZfcHJpdiwgY2hhbm5lbCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfY3JlYXRlX3JlY2VpdmVfc2Eoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgIHUzMiBjaGFubmVsLCB1OCBhbiwKKwkJCQkJICAgIHUzMiBsb3dlc3RfcG4sIGNvbnN0IHU4ICpzYWspCit7CisJaWYgKCF3cGFfcy0+ZHJpdmVyLT5jcmVhdGVfcmVjZWl2ZV9zYSkKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5jcmVhdGVfcmVjZWl2ZV9zYSh3cGFfcy0+ZHJ2X3ByaXYsIGNoYW5uZWwsIGFuLAorCQkJCQkJbG93ZXN0X3BuLCBzYWspOworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFfZHJ2X2VuYWJsZV9yZWNlaXZlX3NhKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICB1MzIgY2hhbm5lbCwgdTggYW4pCit7CisJaWYgKCF3cGFfcy0+ZHJpdmVyLT5lbmFibGVfcmVjZWl2ZV9zYSkKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5lbmFibGVfcmVjZWl2ZV9zYSh3cGFfcy0+ZHJ2X3ByaXYsIGNoYW5uZWwsIGFuKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9kaXNhYmxlX3JlY2VpdmVfc2Eoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICB1MzIgY2hhbm5lbCwgdTggYW4pCit7CisJaWYgKCF3cGFfcy0+ZHJpdmVyLT5kaXNhYmxlX3JlY2VpdmVfc2EpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+ZGlzYWJsZV9yZWNlaXZlX3NhKHdwYV9zLT5kcnZfcHJpdiwgY2hhbm5lbCwgYW4pOworfQorCitzdGF0aWMgaW5saW5lIGludAord3BhX2Rydl9nZXRfYXZhaWxhYmxlX3RyYW5zbWl0X3NjKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHUzMiAqY2hhbm5lbCkKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPmdldF9hdmFpbGFibGVfdHJhbnNtaXRfc2MpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+Z2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYyh3cGFfcy0+ZHJ2X3ByaXYsCisJCQkJCQkJY2hhbm5lbCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50Cit3cGFfZHJ2X2NyZWF0ZV90cmFuc21pdF9zYyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCB1MzIgY2hhbm5lbCwKKwkJCSAgIGNvbnN0IHU4ICpzY2lfYWRkciwgdTE2IHNjaV9wb3J0LAorCQkJICAgdW5zaWduZWQgaW50IGNvbmZfb2Zmc2V0KQoreworCWlmICghd3BhX3MtPmRyaXZlci0+Y3JlYXRlX3RyYW5zbWl0X3NjKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHdwYV9zLT5kcml2ZXItPmNyZWF0ZV90cmFuc21pdF9zYyh3cGFfcy0+ZHJ2X3ByaXYsIGNoYW5uZWwsCisJCQkJCQkgc2NpX2FkZHIsIHNjaV9wb3J0LAorCQkJCQkJIGNvbmZfb2Zmc2V0KTsKK30KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9kZWxldGVfdHJhbnNtaXRfc2Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICB1MzIgY2hhbm5lbCkKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPmRlbGV0ZV90cmFuc21pdF9zYykKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5kZWxldGVfdHJhbnNtaXRfc2Mod3BhX3MtPmRydl9wcml2LCBjaGFubmVsKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9jcmVhdGVfdHJhbnNtaXRfc2Eoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICB1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJCSAgICAgdTMyIG5leHRfcG4sCisJCQkJCSAgICAgQm9vbGVhbiBjb25maWRlbnRpYWxpdHksCisJCQkJCSAgICAgY29uc3QgdTggKnNhaykKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPmNyZWF0ZV90cmFuc21pdF9zYSkKKwkJcmV0dXJuIC0xOworCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5jcmVhdGVfdHJhbnNtaXRfc2Eod3BhX3MtPmRydl9wcml2LCBjaGFubmVsLCBhbiwKKwkJCQkJCSBuZXh0X3BuLCBjb25maWRlbnRpYWxpdHksIHNhayk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYV9kcnZfZW5hYmxlX3RyYW5zbWl0X3NhKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICAgdTMyIGNoYW5uZWwsIHU4IGFuKQoreworCWlmICghd3BhX3MtPmRyaXZlci0+ZW5hYmxlX3RyYW5zbWl0X3NhKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHdwYV9zLT5kcml2ZXItPmVuYWJsZV90cmFuc21pdF9zYSh3cGFfcy0+ZHJ2X3ByaXYsIGNoYW5uZWwsIGFuKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9kaXNhYmxlX3RyYW5zbWl0X3NhKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICAgIHUzMiBjaGFubmVsLCB1OCBhbikKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPmRpc2FibGVfdHJhbnNtaXRfc2EpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+ZGlzYWJsZV90cmFuc21pdF9zYSh3cGFfcy0+ZHJ2X3ByaXYsIGNoYW5uZWwsIGFuKTsKK30KKyNlbmRpZiAvKiBDT05GSUdfTUFDU0VDICovCisKICNlbmRpZiAvKiBEUklWRVJfSV9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9lYXBfcmVnaXN0ZXIuYyBiL3dwYV9zdXBwbGljYW50L2VhcF9yZWdpc3Rlci5jCmluZGV4IDZjZDJmYzUuLmVjZTU3MTYgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2VhcF9yZWdpc3Rlci5jCisrKyBiL3dwYV9zdXBwbGljYW50L2VhcF9yZWdpc3Rlci5jCkBAIC00MCw2ICs0MCwxMyBAQAogCQlyZXQgPSBlYXBfcGVlcl91bmF1dGhfdGxzX3JlZ2lzdGVyKCk7CiAjZW5kaWYgLyogRUFQX1VOQVVUSF9UTFMgKi8KIAorI2lmZGVmIEVBUF9UTFMKKyNpZmRlZiBDT05GSUdfSFMyMAorCWlmIChyZXQgPT0gMCkKKwkJcmV0ID0gZWFwX3BlZXJfd2ZhX3VuYXV0aF90bHNfcmVnaXN0ZXIoKTsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLworI2VuZGlmIC8qIEVBUF9UTFMgKi8KKwogI2lmZGVmIEVBUF9NU0NIQVB2MgogCWlmIChyZXQgPT0gMCkKIAkJcmV0ID0gZWFwX3BlZXJfbXNjaGFwdjJfcmVnaXN0ZXIoKTsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2VhcG9sX3Rlc3QuYyBiL3dwYV9zdXBwbGljYW50L2VhcG9sX3Rlc3QuYwppbmRleCBkYWQyNzY1Li5lMTk3ODJmIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9lYXBvbF90ZXN0LmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvZWFwb2xfdGVzdC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC0gdGVzdCBjb2RlCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwMy0yMDEzLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yNywxMSArMjcsOSBAQAogI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgImN0cmxfaWZhY2UuaCIKICNpbmNsdWRlICJwY3NjX2Z1bmNzLmgiCisjaW5jbHVkZSAid3Bhc19nbHVlLmgiCiAKIAotZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7Ci1leHRlcm4gaW50IHdwYV9kZWJ1Z19zaG93X2tleXM7Ci0KIHN0cnVjdCB3cGFfZHJpdmVyX29wcyAqd3BhX2RyaXZlcnNbXSA9IHsgTlVMTCB9OwogCiAKQEAgLTQ4LDYgKzQ2LDcgQEAKIAlpbnQgZWFwb2xfdGVzdF9udW1fcmVhdXRoczsKIAlpbnQgbm9fbXBwZV9rZXlzOwogCWludCBudW1fbXBwZV9vaywgbnVtX21wcGVfbWlzbWF0Y2g7CisJaW50IHJlcV9lYXBfa2V5X25hbWU7CiAKIAl1OCByYWRpdXNfaWRlbnRpZmllcjsKIAlzdHJ1Y3QgcmFkaXVzX21zZyAqbGFzdF9yZWN2X3JhZGl1czsKQEAgLTYwLDYgKzU5LDggQEAKIAogCXU4IGF1dGhlbnRpY2F0b3JfcG1rW1BNS19MRU5dOwogCXNpemVfdCBhdXRoZW50aWNhdG9yX3Bta19sZW47CisJdTggYXV0aGVudGljYXRvcl9lYXBfa2V5X25hbWVbMjU2XTsKKwlzaXplX3QgYXV0aGVudGljYXRvcl9lYXBfa2V5X25hbWVfbGVuOwogCWludCByYWRpdXNfYWNjZXNzX2FjY2VwdF9yZWNlaXZlZDsKIAlpbnQgcmFkaXVzX2FjY2Vzc19yZWplY3RfcmVjZWl2ZWQ7CiAJaW50IGF1dGhfdGltZWRfb3V0OwpAQCAtNzIsNiArNzMsOSBAQAogCXN0cnVjdCBleHRyYV9yYWRpdXNfYXR0ciAqZXh0cmFfYXR0cnM7CiAKIAlGSUxFICpzZXJ2ZXJfY2VydF9maWxlOworCisJY29uc3QgY2hhciAqcGNzY19yZWFkZXI7CisJY29uc3QgY2hhciAqcGNzY19waW47CiB9OwogCiBzdGF0aWMgc3RydWN0IGVhcG9sX3Rlc3RfZGF0YSBlYXBvbF90ZXN0OwpAQCAtMjEwLDYgKzIxNCwxMyBAQAogCQlnb3RvIGZhaWw7CiAJfQogCisJaWYgKGUtPnJlcV9lYXBfa2V5X25hbWUgJiYKKwkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9FQVBfS0VZX05BTUUsICh1OCAqKSAiXDAiLAorCQkJCSAxKSkgeworCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgRUFQLUtleS1OYW1lXG4iKTsKKwkJZ290byBmYWlsOworCX0KKwogCWlmICghZmluZF9leHRyYV9hdHRyKGUtPmV4dHJhX2F0dHJzLCBSQURJVVNfQVRUUl9OQVNfSVBfQUREUkVTUykgJiYKIAkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9OQVNfSVBfQUREUkVTUywKIAkJCQkgKHU4ICopICZlLT5vd25faXBfYWRkciwgNCkpIHsKQEAgLTMzNSw2ICszNDYsOCBAQAogewogCXU4IHBta1tQTUtfTEVOXTsKIAlpbnQgcmV0ID0gMTsKKwljb25zdCB1OCAqc2Vzc19pZDsKKwlzaXplX3Qgc2Vzc19pZF9sZW47CiAKIAlpZiAoZWFwb2xfc21fZ2V0X2tleShlLT53cGFfcy0+ZWFwb2wsIHBtaywgUE1LX0xFTikgPT0gMCkgewogCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJQTUsgZnJvbSBFQVBPTCIsIHBtaywgUE1LX0xFTik7CkBAIC0zNjMsMTQgKzM3NiwzNyBAQAogCWVsc2UgaWYgKCFlLT5ub19tcHBlX2tleXMpCiAJCWUtPm51bV9tcHBlX29rKys7CiAKKwlzZXNzX2lkID0gZWFwb2xfc21fZ2V0X3Nlc3Npb25faWQoZS0+d3BhX3MtPmVhcG9sLCAmc2Vzc19pZF9sZW4pOworCWlmICghc2Vzc19pZCkKKwkJcmV0dXJuIHJldDsKKwlpZiAoZS0+YXV0aGVudGljYXRvcl9lYXBfa2V5X25hbWVfbGVuID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIEVBUC1LZXktTmFtZSByZWNlaXZlZCBmcm9tIHNlcnZlciIpOworCQlyZXR1cm4gcmV0OworCX0KKworCWlmIChlLT5hdXRoZW50aWNhdG9yX2VhcF9rZXlfbmFtZV9sZW4gIT0gc2Vzc19pZF9sZW4gfHwKKwkgICAgb3NfbWVtY21wKGUtPmF1dGhlbnRpY2F0b3JfZWFwX2tleV9uYW1lLCBzZXNzX2lkLCBzZXNzX2lkX2xlbikgIT0gMCkKKwl7CisJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkgICAiTG9jYWxseSBkZXJpdmVkIEVBUCBTZXNzaW9uLUlkIGRvZXMgbm90IG1hdGNoIEVBUC1LZXktTmFtZSBmcm9tIHNlcnZlciIpOworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJFQVAgU2Vzc2lvbi1JZCIsIHNlc3NfaWQsIHNlc3NfaWRfbGVuKTsKKwkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiRUFQLUtleS1OYW1lIGZyb20gc2VydmVyIiwKKwkJCSAgICBlLT5hdXRoZW50aWNhdG9yX2VhcF9rZXlfbmFtZSwKKwkJCSAgICBlLT5hdXRoZW50aWNhdG9yX2VhcF9rZXlfbmFtZV9sZW4pOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sCisJCQkgICAiTG9jYWxseSBkZXJpdmVkIEVBUCBTZXNzaW9uLUlkIG1hdGNoZXMgRUFQLUtleS1OYW1lIGZyb20gc2VydmVyIik7CisJfQorCiAJcmV0dXJuIHJldDsKIH0KIAogCi1zdGF0aWMgdm9pZCBlYXBvbF9zbV9jYihzdHJ1Y3QgZWFwb2xfc20gKmVhcG9sLCBpbnQgc3VjY2Vzcywgdm9pZCAqY3R4KQorc3RhdGljIHZvaWQgZWFwb2xfc21fY2Ioc3RydWN0IGVhcG9sX3NtICplYXBvbCwgZW51bSBlYXBvbF9zdXBwX3Jlc3VsdCByZXN1bHQsCisJCQl2b2lkICpjdHgpCiB7CiAJc3RydWN0IGVhcG9sX3Rlc3RfZGF0YSAqZSA9IGN0eDsKLQlwcmludGYoImVhcG9sX3NtX2NiOiBzdWNjZXNzPSVkXG4iLCBzdWNjZXNzKTsKKwlwcmludGYoImVhcG9sX3NtX2NiOiByZXN1bHQ9JWRcbiIsIHJlc3VsdCk7CiAJZS0+ZWFwb2xfdGVzdF9udW1fcmVhdXRocy0tOwogCWlmIChlLT5lYXBvbF90ZXN0X251bV9yZWF1dGhzIDwgMCkKIAkJZWxvb3BfdGVybWluYXRlKCk7CkBAIC0zOTUsNiArNDMxLDU0IEBACiB9CiAKIAorI2lmIGRlZmluZWQoQ09ORklHX0NUUkxfSUZBQ0UpIHx8ICFkZWZpbmVkKENPTkZJR19OT19TVERPVVRfREVCVUcpCitzdGF0aWMgdm9pZCBlYXBvbF90ZXN0X2VhcF9wYXJhbV9uZWVkZWQodm9pZCAqY3R4LCBlbnVtIHdwYV9jdHJsX3JlcV90eXBlIGZpZWxkLAorCQkJCQljb25zdCBjaGFyICpkZWZhdWx0X3R4dCkKK3sKKwlzdHJ1Y3QgZWFwb2xfdGVzdF9kYXRhICplID0gY3R4OworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBlLT53cGFfczsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOworCWNvbnN0IGNoYXIgKmZpZWxkX25hbWUsICp0eHQgPSBOVUxMOworCWNoYXIgKmJ1ZjsKKwlzaXplX3QgYnVmbGVuOworCWludCBsZW47CisKKwlpZiAoc3NpZCA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlmaWVsZF9uYW1lID0gd3BhX3N1cHBsaWNhbnRfY3RybF9yZXFfdG9fc3RyaW5nKGZpZWxkLCBkZWZhdWx0X3R4dCwKKwkJCQkJCSAgICAgICAmdHh0KTsKKwlpZiAoZmllbGRfbmFtZSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJVbmhhbmRsZWQgRUFQIHBhcmFtICVkIG5lZWRlZCIsCisJCQkgICBmaWVsZCk7CisJCXJldHVybjsKKwl9CisKKwlidWZsZW4gPSAxMDAgKyBvc19zdHJsZW4odHh0KSArIHNzaWQtPnNzaWRfbGVuOworCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuOworCWxlbiA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLAorCQkJICBXUEFfQ1RSTF9SRVEgIiVzLSVkOiVzIG5lZWRlZCBmb3IgU1NJRCAiLAorCQkJICBmaWVsZF9uYW1lLCBzc2lkLT5pZCwgdHh0KTsKKwlpZiAobGVuIDwgMCB8fCAoc2l6ZV90KSBsZW4gPj0gYnVmbGVuKSB7CisJCW9zX2ZyZWUoYnVmKTsKKwkJcmV0dXJuOworCX0KKwlpZiAoc3NpZC0+c3NpZCAmJiBidWZsZW4gPiBsZW4gKyBzc2lkLT5zc2lkX2xlbikgeworCQlvc19tZW1jcHkoYnVmICsgbGVuLCBzc2lkLT5zc2lkLCBzc2lkLT5zc2lkX2xlbik7CisJCWxlbiArPSBzc2lkLT5zc2lkX2xlbjsKKwkJYnVmW2xlbl0gPSAnXDAnOworCX0KKwlidWZbYnVmbGVuIC0gMV0gPSAnXDAnOworCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiJXMiLCBidWYpOworCW9zX2ZyZWUoYnVmKTsKK30KKyNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFIHx8ICFDT05GSUdfTk9fU1RET1VUX0RFQlVHICovCisjZGVmaW5lIGVhcG9sX3Rlc3RfZWFwX3BhcmFtX25lZWRlZCBOVUxMCisjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0UgfHwgIUNPTkZJR19OT19TVERPVVRfREVCVUcgKi8KKworCiBzdGF0aWMgdm9pZCBlYXBvbF90ZXN0X2NlcnRfY2Iodm9pZCAqY3R4LCBpbnQgZGVwdGgsIGNvbnN0IGNoYXIgKnN1YmplY3QsCiAJCQkgICAgICAgY29uc3QgY2hhciAqY2VydF9oYXNoLAogCQkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmNlcnQpCkBAIC00ODQsNiArNTY4LDcgQEAKIAljdHgtPm9wZW5zY19lbmdpbmVfcGF0aCA9IHdwYV9zLT5jb25mLT5vcGVuc2NfZW5naW5lX3BhdGg7CiAJY3R4LT5wa2NzMTFfZW5naW5lX3BhdGggPSB3cGFfcy0+Y29uZi0+cGtjczExX2VuZ2luZV9wYXRoOwogCWN0eC0+cGtjczExX21vZHVsZV9wYXRoID0gd3BhX3MtPmNvbmYtPnBrY3MxMV9tb2R1bGVfcGF0aDsKKwljdHgtPmVhcF9wYXJhbV9uZWVkZWQgPSBlYXBvbF90ZXN0X2VhcF9wYXJhbV9uZWVkZWQ7CiAJY3R4LT5jZXJ0X2NiID0gZWFwb2xfdGVzdF9jZXJ0X2NiOwogCWN0eC0+Y2VydF9pbl9jYiA9IDE7CiAJY3R4LT5zZXRfYW5vbl9pZCA9IGVhcG9sX3Rlc3Rfc2V0X2Fub25faWQ7CkBAIC01MDEsNiArNTg2LDcgQEAKIAllYXBvbF9jb25mLnJlcXVpcmVkX2tleXMgPSAwOwogCWVhcG9sX2NvbmYuZmFzdF9yZWF1dGggPSB3cGFfcy0+Y29uZi0+ZmFzdF9yZWF1dGg7CiAJZWFwb2xfY29uZi53b3JrYXJvdW5kID0gc3NpZC0+ZWFwX3dvcmthcm91bmQ7CisJZWFwb2xfY29uZi5leHRlcm5hbF9zaW0gPSB3cGFfcy0+Y29uZi0+ZXh0ZXJuYWxfc2ltOwogCWVhcG9sX3NtX25vdGlmeV9jb25maWcod3BhX3MtPmVhcG9sLCAmc3NpZC0+ZWFwLCAmZWFwb2xfY29uZik7CiAJZWFwb2xfc21fcmVnaXN0ZXJfc2NhcmRfY3R4KHdwYV9zLT5lYXBvbCwgd3BhX3MtPnNjYXJkKTsKIApAQCAtNzAwLDYgKzc4Niw4IEBACiAJCQkJc2l6ZV90IHNoYXJlZF9zZWNyZXRfbGVuKQogewogCXN0cnVjdCByYWRpdXNfbXNfbXBwZV9rZXlzICprZXlzOworCXU4ICpidWY7CisJc2l6ZV90IGxlbjsKIAogCWtleXMgPSByYWRpdXNfbXNnX2dldF9tc19rZXlzKG1zZywgcmVxLCBzaGFyZWRfc2VjcmV0LAogCQkJCSAgICAgIHNoYXJlZF9zZWNyZXRfbGVuKTsKQEAgLTczOCw2ICs4MjYsMTQgQEAKIAkJb3NfZnJlZShrZXlzLT5yZWN2KTsKIAkJb3NfZnJlZShrZXlzKTsKIAl9CisKKwlpZiAocmFkaXVzX21zZ19nZXRfYXR0cl9wdHIobXNnLCBSQURJVVNfQVRUUl9FQVBfS0VZX05BTUUsICZidWYsICZsZW4sCisJCQkJICAgIE5VTEwpID09IDApIHsKKwkJb3NfbWVtY3B5KGUtPmF1dGhlbnRpY2F0b3JfZWFwX2tleV9uYW1lLCBidWYsIGxlbik7CisJCWUtPmF1dGhlbnRpY2F0b3JfZWFwX2tleV9uYW1lX2xlbiA9IGxlbjsKKwl9IGVsc2UgeworCQllLT5hdXRoZW50aWNhdG9yX2VhcF9rZXlfbmFtZV9sZW4gPSAwOworCX0KIH0KIAogCkBAIC04NjEsNyArOTU3LDcgQEAKIH0KIAogCi1zdGF0aWMgaW50IHNjYXJkX3Rlc3Qodm9pZCkKK3N0YXRpYyBpbnQgc2NhcmRfdGVzdChzdHJ1Y3QgZWFwb2xfdGVzdF9kYXRhICplKQogewogCXN0cnVjdCBzY2FyZF9kYXRhICpzY2FyZDsKIAlzaXplX3QgbGVuOwpAQCAtODkyLDEwICs5ODgsMTAgQEAKIAl1bnNpZ25lZCBjaGFyIGFrYV9pa1tJS19MRU5dOwogCXVuc2lnbmVkIGNoYXIgYWthX2NrW0NLX0xFTl07CiAKLQlzY2FyZCA9IHNjYXJkX2luaXQoU0NBUkRfVFJZX0JPVEgsIE5VTEwpOworCXNjYXJkID0gc2NhcmRfaW5pdChlLT5wY3NjX3JlYWRlcik7CiAJaWYgKHNjYXJkID09IE5VTEwpCiAJCXJldHVybiAtMTsKLQlpZiAoc2NhcmRfc2V0X3BpbihzY2FyZCwgIjEyMzQiKSkgeworCWlmIChzY2FyZF9zZXRfcGluKHNjYXJkLCBlLT5wY3NjX3BpbikpIHsKIAkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIlBJTiB2YWxpZGF0aW9uIGZhaWxlZCIpOwogCQlzY2FyZF9kZWluaXQoc2NhcmQpOwogCQlyZXR1cm4gLTE7CkBAIC05NzAsNyArMTA2Niw3IEBACiB9CiAKIAotc3RhdGljIGludCBzY2FyZF9nZXRfdHJpcGxldHMoaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3N0YXRpYyBpbnQgc2NhcmRfZ2V0X3RyaXBsZXRzKHN0cnVjdCBlYXBvbF90ZXN0X2RhdGEgKmUsIGludCBhcmdjLCBjaGFyICphcmd2W10pCiB7CiAJc3RydWN0IHNjYXJkX2RhdGEgKnNjYXJkOwogCXNpemVfdCBsZW47CkBAIC05OTIsNyArMTA4OCw3IEBACiAJCXdwYV9kZWJ1Z19sZXZlbCA9IDk5OwogCX0KIAotCXNjYXJkID0gc2NhcmRfaW5pdChTQ0FSRF9HU01fU0lNX09OTFksIE5VTEwpOworCXNjYXJkID0gc2NhcmRfaW5pdChlLT5wY3NjX3JlYWRlcik7CiAJaWYgKHNjYXJkID09IE5VTEwpIHsKIAkJcHJpbnRmKCJGYWlsZWQgdG8gb3BlbiBzbWFydGNhcmQgY29ubmVjdGlvblxuIik7CiAJCXJldHVybiAtMTsKQEAgLTEwNDYsMTEgKzExNDIsMTIgQEAKIHN0YXRpYyB2b2lkIHVzYWdlKHZvaWQpCiB7CiAJcHJpbnRmKCJ1c2FnZTpcbiIKLQkgICAgICAgImVhcG9sX3Rlc3QgWy1uV1NdIC1jPGNvbmY+IFstYTxBUyBJUD5dIFstcDxBUyBwb3J0Pl0gIgorCSAgICAgICAiZWFwb2xfdGVzdCBbLWVuV1NdIC1jPGNvbmY+IFstYTxBUyBJUD5dIFstcDxBUyBwb3J0Pl0gIgogCSAgICAgICAiWy1zPEFTIHNlY3JldD5dXFxcbiIKIAkgICAgICAgIiAgICAgICAgICAgWy1yPGNvdW50Pl0gWy10PHRpbWVvdXQ+XSBbLUM8Q29ubmVjdC1JbmZvPl0gXFxcbiIKIAkgICAgICAgIiAgICAgICAgICAgWy1NPGNsaWVudCBNQUMgYWRkcmVzcz5dIFstbzxzZXJ2ZXIgY2VydCBmaWxlXSBcXFxuIgotCSAgICAgICAiICAgICAgICAgICBbLU48YXR0ciBzcGVjPl0gXFxcbiIKKwkgICAgICAgIiAgICAgICAgICAgWy1OPGF0dHIgc3BlYz5dIFstUjxQQy9TQyByZWFkZXI+XSAiCisJICAgICAgICJbLVA8UEMvU0MgUElOPl0gXFxcbiIKIAkgICAgICAgIiAgICAgICAgICAgWy1BPGNsaWVudCBJUD5dXG4iCiAJICAgICAgICJlYXBvbF90ZXN0IHNjYXJkXG4iCiAJICAgICAgICJlYXBvbF90ZXN0IHNpbSA8UElOPiA8bnVtIHRyaXBsZXRzPiBbZGVidWddXG4iCkBAIC0xMDY2LDYgKzExNjMsNyBAQAogCSAgICAgICAiICAtQTxjbGllbnQgSVA+ID0gSVAgYWRkcmVzcyBvZiB0aGUgY2xpZW50LCBkZWZhdWx0OiBzZWxlY3QgIgogCSAgICAgICAiYXV0b21hdGljYWxseVxuIgogCSAgICAgICAiICAtcjxjb3VudD4gPSBudW1iZXIgb2YgcmUtYXV0aGVudGljYXRpb25zXG4iCisJICAgICAgICIgIC1lID0gUmVxdWVzdCBFQVAtS2V5LU5hbWVcbiIKIAkgICAgICAgIiAgLVcgPSB3YWl0IGZvciBhIGNvbnRyb2wgaW50ZXJmYWNlIG1vbml0b3IgYmVmb3JlIHN0YXJ0aW5nXG4iCiAJICAgICAgICIgIC1TID0gc2F2ZSBjb25maWd1cmF0aW9uIGFmdGVyIGF1dGhlbnRpY2F0aW9uXG4iCiAJICAgICAgICIgIC1uID0gbm8gTVBQRSBrZXlzIGV4cGVjdGVkXG4iCkBAIC0xMDk0LDYgKzExOTIsNyBAQAogCiBpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKQogeworCXN0cnVjdCB3cGFfZ2xvYmFsIGdsb2JhbDsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgd3BhX3M7CiAJaW50IGMsIHJldCA9IDEsIHdhaXRfZm9yX21vbml0b3IgPSAwLCBzYXZlX2NvbmZpZyA9IDA7CiAJY2hhciAqYXNfYWRkciA9ICIxMjcuMC4wLjEiOwpAQCAtMTExMywxMiArMTIxMiwxMyBAQAogCW9zX21lbXNldCgmZWFwb2xfdGVzdCwgMCwgc2l6ZW9mKGVhcG9sX3Rlc3QpKTsKIAllYXBvbF90ZXN0LmNvbm5lY3RfaW5mbyA9ICJDT05ORUNUIDExTWJwcyA4MDIuMTFiIjsKIAlvc19tZW1jcHkoZWFwb2xfdGVzdC5vd25fYWRkciwgIlx4MDJceDAwXHgwMFx4MDBceDAwXHgwMSIsIEVUSF9BTEVOKTsKKwllYXBvbF90ZXN0LnBjc2NfcGluID0gIjEyMzQiOwogCiAJd3BhX2RlYnVnX2xldmVsID0gMDsKIAl3cGFfZGVidWdfc2hvd19rZXlzID0gMTsKIAogCWZvciAoOzspIHsKLQkJYyA9IGdldG9wdChhcmdjLCBhcmd2LCAiYTpBOmM6QzpNOm5OOm86cDpyOnM6U3Q6VyIpOworCQljID0gZ2V0b3B0KGFyZ2MsIGFyZ3YsICJhOkE6YzpDOmVNOm5OOm86cDpQOnI6UjpzOlN0OlciKTsKIAkJaWYgKGMgPCAwKQogCQkJYnJlYWs7CiAJCXN3aXRjaCAoYykgewpAQCAtMTEzNCw2ICsxMjM0LDkgQEAKIAkJY2FzZSAnQyc6CiAJCQllYXBvbF90ZXN0LmNvbm5lY3RfaW5mbyA9IG9wdGFyZzsKIAkJCWJyZWFrOworCQljYXNlICdlJzoKKwkJCWVhcG9sX3Rlc3QucmVxX2VhcF9rZXlfbmFtZSA9IDE7CisJCQlicmVhazsKIAkJY2FzZSAnTSc6CiAJCQlpZiAoaHdhZGRyX2F0b24ob3B0YXJnLCBlYXBvbF90ZXN0Lm93bl9hZGRyKSkgewogCQkJCXVzYWdlKCk7CkBAIC0xMTU2LDkgKzEyNTksMTUgQEAKIAkJY2FzZSAncCc6CiAJCQlhc19wb3J0ID0gYXRvaShvcHRhcmcpOwogCQkJYnJlYWs7CisJCWNhc2UgJ1AnOgorCQkJZWFwb2xfdGVzdC5wY3NjX3BpbiA9IG9wdGFyZzsKKwkJCWJyZWFrOwogCQljYXNlICdyJzoKIAkJCWVhcG9sX3Rlc3QuZWFwb2xfdGVzdF9udW1fcmVhdXRocyA9IGF0b2kob3B0YXJnKTsKIAkJCWJyZWFrOworCQljYXNlICdSJzoKKwkJCWVhcG9sX3Rlc3QucGNzY19yZWFkZXIgPSBvcHRhcmc7CisJCQlicmVhazsKIAkJY2FzZSAncyc6CiAJCQlhc19zZWNyZXQgPSBvcHRhcmc7CiAJCQlicmVhazsKQEAgLTEyMDYsMTEgKzEzMTUsMTEgQEAKIAl9CiAKIAlpZiAoYXJnYyA+IG9wdGluZCAmJiBvc19zdHJjbXAoYXJndltvcHRpbmRdLCAic2NhcmQiKSA9PSAwKSB7Ci0JCXJldHVybiBzY2FyZF90ZXN0KCk7CisJCXJldHVybiBzY2FyZF90ZXN0KCZlYXBvbF90ZXN0KTsKIAl9CiAKIAlpZiAoYXJnYyA+IG9wdGluZCAmJiBvc19zdHJjbXAoYXJndltvcHRpbmRdLCAic2ltIikgPT0gMCkgewotCQlyZXR1cm4gc2NhcmRfZ2V0X3RyaXBsZXRzKGFyZ2MgLSBvcHRpbmQgLSAxLAorCQlyZXR1cm4gc2NhcmRfZ2V0X3RyaXBsZXRzKCZlYXBvbF90ZXN0LCBhcmdjIC0gb3B0aW5kIC0gMSwKIAkJCQkJICAmYXJndltvcHRpbmQgKyAxXSk7CiAJfQogCkBAIC0xMjMwLDggKzEzMzksMTIgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAorCW9zX21lbXNldCgmZ2xvYmFsLCAwLCBzaXplb2YoZ2xvYmFsKSk7CiAJb3NfbWVtc2V0KCZ3cGFfcywgMCwgc2l6ZW9mKHdwYV9zKSk7CisJd3BhX3MuZ2xvYmFsID0gJmdsb2JhbDsKIAllYXBvbF90ZXN0LndwYV9zID0gJndwYV9zOworCWRsX2xpc3RfaW5pdCgmd3BhX3MuYnNzKTsKKwlkbF9saXN0X2luaXQoJndwYV9zLmJzc19pZCk7CiAJd3BhX3MuY29uZiA9IHdwYV9jb25maWdfcmVhZChjb25mLCBOVUxMKTsKIAlpZiAod3BhX3MuY29uZiA9PSBOVUxMKSB7CiAJCXByaW50ZigiRmFpbGVkIHRvIHBhcnNlIGNvbmZpZ3VyYXRpb24gZmlsZSAnJXMnLlxuIiwgY29uZik7CkBAIC0xMjQyLDYgKzEzNTUsMTEgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAorCWlmIChlYXBvbF90ZXN0LnBjc2NfcmVhZGVyKSB7CisJCW9zX2ZyZWUod3BhX3MuY29uZi0+cGNzY19yZWFkZXIpOworCQl3cGFfcy5jb25mLT5wY3NjX3JlYWRlciA9IG9zX3N0cmR1cChlYXBvbF90ZXN0LnBjc2NfcmVhZGVyKTsKKwl9CisKIAl3cGFfaW5pdF9jb25mKCZlYXBvbF90ZXN0LCAmd3BhX3MsIGFzX2FkZHIsIGFzX3BvcnQsIGFzX3NlY3JldCwKIAkJICAgICAgY2xpX2FkZHIpOwogCXdwYV9zLmN0cmxfaWZhY2UgPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2luaXQoJndwYV9zKTsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2V2ZW50cy5jIGIvd3BhX3N1cHBsaWNhbnQvZXZlbnRzLmMKaW5kZXggOWRlOGQ3Zi4uYmE5ZTA4MyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZXZlbnRzLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvZXZlbnRzLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogV1BBIFN1cHBsaWNhbnQgLSBEcml2ZXIgZXZlbnQgcHJvY2Vzc2luZwotICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNDYsMTkgKzQ2LDE5IEBACiAKICNpZm5kZWYgQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORwogc3RhdGljIGludCB3cGFzX3NlbGVjdF9uZXR3b3JrX2Zyb21fbGFzdF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgICAgIGludCBuZXdfc2Nhbik7CisJCQkJCSAgICAgIGludCBuZXdfc2NhbiwgaW50IG93bl9yZXF1ZXN0KTsKICNlbmRpZiAvKiBDT05GSUdfTk9fU0NBTl9QUk9DRVNTSU5HICovCiAKIAogc3RhdGljIGludCB3cGFzX3RlbXBfZGlzYWJsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKIHsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCiAJaWYgKHNzaWQgPT0gTlVMTCB8fCBzc2lkLT5kaXNhYmxlZF91bnRpbC5zZWMgPT0gMCkKIAkJcmV0dXJuIDA7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAlpZiAoc3NpZC0+ZGlzYWJsZWRfdW50aWwuc2VjID4gbm93LnNlYykKIAkJcmV0dXJuIHNzaWQtPmRpc2FibGVkX3VudGlsLnNlYyAtIG5vdy5zZWM7CiAKQEAgLTY4LDEzICs2OCw0NiBAQAogfQogCiAKK3N0YXRpYyBzdHJ1Y3Qgd3BhX2JzcyAqIHdwYV9zdXBwbGljYW50X2dldF9uZXdfYnNzKAorCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpic3NpZCkKK3sKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gTlVMTDsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOworCisJaWYgKHNzaWQtPnNzaWRfbGVuID4gMCkKKwkJYnNzID0gd3BhX2Jzc19nZXQod3BhX3MsIGJzc2lkLCBzc2lkLT5zc2lkLCBzc2lkLT5zc2lkX2xlbik7CisJaWYgKCFic3MpCisJCWJzcyA9IHdwYV9ic3NfZ2V0X2Jzc2lkKHdwYV9zLCBic3NpZCk7CisKKwlyZXR1cm4gYnNzOworfQorCisKK3N0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X3VwZGF0ZV9jdXJyZW50X2JzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXN0cnVjdCB3cGFfYnNzICpic3MgPSB3cGFfc3VwcGxpY2FudF9nZXRfbmV3X2Jzcyh3cGFfcywgd3BhX3MtPmJzc2lkKTsKKworCWlmICghYnNzKSB7CisJCXdwYV9zdXBwbGljYW50X3VwZGF0ZV9zY2FuX3Jlc3VsdHMod3BhX3MpOworCisJCS8qIEdldCB0aGUgQlNTIGZyb20gdGhlIG5ldyBzY2FuIHJlc3VsdHMgKi8KKwkJYnNzID0gd3BhX3N1cHBsaWNhbnRfZ2V0X25ld19ic3Mod3BhX3MsIHdwYV9zLT5ic3NpZCk7CisJfQorCisJaWYgKGJzcykKKwkJd3BhX3MtPmN1cnJlbnRfYnNzID0gYnNzOworfQorCisKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfc2VsZWN0X2NvbmZpZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCwgKm9sZF9zc2lkOwogCWludCByZXM7CiAKLQlpZiAod3BhX3MtPmNvbmYtPmFwX3NjYW4gPT0gMSAmJiB3cGFfcy0+Y3VycmVudF9zc2lkKQorCWlmICh3cGFfcy0+Y29uZi0+YXBfc2NhbiA9PSAxICYmIHdwYV9zLT5jdXJyZW50X3NzaWQpIHsKKwkJd3BhX3N1cHBsaWNhbnRfdXBkYXRlX2N1cnJlbnRfYnNzKHdwYV9zKTsKIAkJcmV0dXJuIDA7CisJfQogCiAJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiU2VsZWN0IG5ldHdvcmsgYmFzZWQgb24gYXNzb2NpYXRpb24gIgogCQkiaW5mb3JtYXRpb24iKTsKQEAgLTExOSw2ICsxNTIsOSBAQAogCQllYXBvbF9zbV9pbnZhbGlkYXRlX2NhY2hlZF9zZXNzaW9uKHdwYV9zLT5lYXBvbCk7CiAJb2xkX3NzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOwogCXdwYV9zLT5jdXJyZW50X3NzaWQgPSBzc2lkOworCisJd3BhX3N1cHBsaWNhbnRfdXBkYXRlX2N1cnJlbnRfYnNzKHdwYV9zKTsKKwogCXdwYV9zdXBwbGljYW50X3Jzbl9zdXBwX3NldF9jb25maWcod3BhX3MsIHdwYV9zLT5jdXJyZW50X3NzaWQpOwogCXdwYV9zdXBwbGljYW50X2luaXRpYXRlX2VhcG9sKHdwYV9zKTsKIAlpZiAob2xkX3NzaWQgIT0gd3BhX3MtPmN1cnJlbnRfc3NpZCkKQEAgLTE2MCw5ICsxOTYsNiBAQAogCQlyZXR1cm47CiAKIAl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9ESVNDT05ORUNURUQpOwotI2lmZGVmIEFORFJPSUQKLQl3cGFfcy0+Y29uZi0+YXBfc2NhbiA9IERFRkFVTFRfQVBfU0NBTjsKLSNlbmRpZgogCWJzc2lkX2NoYW5nZWQgPSAhaXNfemVyb19ldGhlcl9hZGRyKHdwYV9zLT5ic3NpZCk7CiAJb3NfbWVtc2V0KHdwYV9zLT5ic3NpZCwgMCwgRVRIX0FMRU4pOwogCW9zX21lbXNldCh3cGFfcy0+cGVuZGluZ19ic3NpZCwgMCwgRVRIX0FMRU4pOwpAQCAtMjc4LDEwICszMTEsMTEgQEAKICNpZmRlZiBQQ1NDX0ZVTkNTCiAJaW50IGFrYSA9IDAsIHNpbSA9IDA7CiAKLQlpZiAoc3NpZC0+ZWFwLnBjc2MgPT0gTlVMTCB8fCB3cGFfcy0+c2NhcmQgIT0gTlVMTCkKKwlpZiAoKHNzaWQgIT0gTlVMTCAmJiBzc2lkLT5lYXAucGNzYyA9PSBOVUxMKSB8fAorCSAgICB3cGFfcy0+c2NhcmQgIT0gTlVMTCB8fCB3cGFfcy0+Y29uZi0+ZXh0ZXJuYWxfc2ltKQogCQlyZXR1cm4gMDsKIAotCWlmIChzc2lkLT5lYXAuZWFwX21ldGhvZHMgPT0gTlVMTCkgeworCWlmIChzc2lkID09IE5VTEwgfHwgc3NpZC0+ZWFwLmVhcF9tZXRob2RzID09IE5VTEwpIHsKIAkJc2ltID0gMTsKIAkJYWthID0gMTsKIAl9IGVsc2UgewpAQCAtMzE2LDggKzM1MCw3IEBACiAJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiU2VsZWN0ZWQgbmV0d29yayBpcyBjb25maWd1cmVkIHRvIHVzZSBTSU0gIgogCQkiKHNpbT0lZCBha2E9JWQpIC0gaW5pdGlhbGl6ZSBQQ1NDIiwgc2ltLCBha2EpOwogCi0Jd3BhX3MtPnNjYXJkID0gc2NhcmRfaW5pdCgoIXNpbSAmJiBha2EpID8gU0NBUkRfVVNJTV9PTkxZIDoKLQkJCQkgIFNDQVJEX1RSWV9CT1RILCBOVUxMKTsKKwl3cGFfcy0+c2NhcmQgPSBzY2FyZF9pbml0KHdwYV9zLT5jb25mLT5wY3NjX3JlYWRlcik7CiAJaWYgKHdwYV9zLT5zY2FyZCA9PSBOVUxMKSB7CiAJCXdwYV9tc2cod3BhX3MsIE1TR19XQVJOSU5HLCAiRmFpbGVkIHRvIGluaXRpYWxpemUgU0lNICIKIAkJCSIocGNzYy1saXRlKSIpOwpAQCAtMzczLDYgKzQwNiw5IEBACiAJaWYgKHdwYV9rZXlfbWdtdF93cGEoc3NpZC0+a2V5X21nbXQpKQogCQlwcml2YWN5ID0gMTsKIAorCWlmIChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9PU0VOKQorCQlwcml2YWN5ID0gMTsKKwogCWlmIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX1BSSVZBQ1kpCiAJCXJldHVybiBwcml2YWN5OwogCXJldHVybiAhcHJpdmFjeTsKQEAgLTUxNCw2ICs1NTAsMTIgQEAKIAkJcmV0dXJuIDA7CiAJfQogCisJaWYgKChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9PU0VOKSAmJgorCSAgICB3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBPU0VOX0lFX1ZFTkRPUl9UWVBFKSkgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICIgICBhbGxvdyBpbiBPU0VOIik7CisJCXJldHVybiAxOworCX0KKwogCWlmICghd3BhX2tleV9tZ210X3dwYShzc2lkLT5rZXlfbWdtdCkpIHsKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiICAgYWxsb3cgaW4gbm9uLVdQQS9XUEEyIik7CiAJCXJldHVybiAxOwpAQCAtNjc5LDEyICs3MjEsNiBAQAogfQogCiAKLXN0YXRpYyBpbnQgYnNzX2lzX2RtZyhzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQotewotCXJldHVybiBic3MtPmZyZXEgPiA0NTAwMDsKLX0KLQotCiAvKgogICogVGVzdCB3aGV0aGVyIEJTUyBpcyBpbiBhbiBFU1MuCiAgKiBUaGlzIGlzIGRvbmUgZGlmZmVyZW50bHkgaW4gRE1HICg2MCBHSHopIGFuZCBub24tRE1HIGJhbmRzCkBAIC03MDMsMTMgKzczOSwxNSBAQAogCiBzdGF0aWMgc3RydWN0IHdwYV9zc2lkICogd3BhX3NjYW5fcmVzX21hdGNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSAgICBpbnQgaSwgc3RydWN0IHdwYV9ic3MgKmJzcywKLQkJCQkJICAgIHN0cnVjdCB3cGFfc3NpZCAqZ3JvdXApCisJCQkJCSAgICBzdHJ1Y3Qgd3BhX3NzaWQgKmdyb3VwLAorCQkJCQkgICAgaW50IG9ubHlfZmlyc3Rfc3NpZCkKIHsKIAl1OCB3cGFfaWVfbGVuLCByc25faWVfbGVuOwogCWludCB3cGE7CiAJc3RydWN0IHdwYV9ibGFja2xpc3QgKmU7CiAJY29uc3QgdTggKmllOwogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKKwlpbnQgb3NlbjsKIAogCWllID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgV1BBX0lFX1ZFTkRPUl9UWVBFKTsKIAl3cGFfaWVfbGVuID0gaWUgPyBpZVsxXSA6IDA7CkBAIC03MTcsMTEgKzc1NSwxOCBAQAogCWllID0gd3BhX2Jzc19nZXRfaWUoYnNzLCBXTEFOX0VJRF9SU04pOwogCXJzbl9pZV9sZW4gPSBpZSA/IGllWzFdIDogMDsKIAorCWllID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgT1NFTl9JRV9WRU5ET1JfVFlQRSk7CisJb3NlbiA9IGllICE9IE5VTEw7CisKIAl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICIlZDogIiBNQUNTVFIgIiBzc2lkPSclcycgIgotCQkid3BhX2llX2xlbj0ldSByc25faWVfbGVuPSV1IGNhcHM9MHgleCBsZXZlbD0lZCVzIiwKKwkJIndwYV9pZV9sZW49JXUgcnNuX2llX2xlbj0ldSBjYXBzPTB4JXggbGV2ZWw9JWQlcyVzJXMiLAogCQlpLCBNQUMyU1RSKGJzcy0+YnNzaWQpLCB3cGFfc3NpZF90eHQoYnNzLT5zc2lkLCBic3MtPnNzaWRfbGVuKSwKIAkJd3BhX2llX2xlbiwgcnNuX2llX2xlbiwgYnNzLT5jYXBzLCBic3MtPmxldmVsLAotCQl3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBXUFNfSUVfVkVORE9SX1RZUEUpID8gIiB3cHMiIDogIiIpOworCQl3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBXUFNfSUVfVkVORE9SX1RZUEUpID8gIiB3cHMiIDogIiIsCisJCSh3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBQMlBfSUVfVkVORE9SX1RZUEUpIHx8CisJCSB3cGFfYnNzX2dldF92ZW5kb3JfaWVfYmVhY29uKGJzcywgUDJQX0lFX1ZFTkRPUl9UWVBFKSkgPworCQkiIHAycCIgOiAiIiwKKwkJb3NlbiA/ICIgb3Nlbj0xIiA6ICIiKTsKIAogCWUgPSB3cGFfYmxhY2tsaXN0X2dldCh3cGFfcywgYnNzLT5ic3NpZCk7CiAJaWYgKGUpIHsKQEAgLTc2MSw3ICs4MDYsNyBAQAogCiAJd3BhID0gd3BhX2llX2xlbiA+IDAgfHwgcnNuX2llX2xlbiA+IDA7CiAKLQlmb3IgKHNzaWQgPSBncm91cDsgc3NpZDsgc3NpZCA9IHNzaWQtPnBuZXh0KSB7CisJZm9yIChzc2lkID0gZ3JvdXA7IHNzaWQ7IHNzaWQgPSBvbmx5X2ZpcnN0X3NzaWQgPyBOVUxMIDogc3NpZC0+cG5leHQpIHsKIAkJaW50IGNoZWNrX3NzaWQgPSB3cGEgPyAxIDogKHNzaWQtPnNzaWRfbGVuICE9IDApOwogCQlpbnQgcmVzOwogCkBAIC04MTksNyArODY0LDcgQEAKIAkJaWYgKCF3cGFfc3VwcGxpY2FudF9zc2lkX2Jzc19tYXRjaCh3cGFfcywgc3NpZCwgYnNzKSkKIAkJCWNvbnRpbnVlOwogCi0JCWlmICghd3BhICYmCisJCWlmICghb3NlbiAmJiAhd3BhICYmCiAJCSAgICAhKHNzaWQtPmtleV9tZ210ICYgV1BBX0tFWV9NR01UX05PTkUpICYmCiAJCSAgICAhKHNzaWQtPmtleV9tZ210ICYgV1BBX0tFWV9NR01UX1dQUykgJiYKIAkJICAgICEoc3NpZC0+a2V5X21nbXQgJiBXUEFfS0VZX01HTVRfSUVFRTgwMjFYX05PX1dQQSkpIHsKQEAgLTgzNCw2ICs4NzksMTIgQEAKIAkJCWNvbnRpbnVlOwogCQl9CiAKKwkJaWYgKChzc2lkLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9PU0VOKSAmJiAhb3NlbikgeworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiICAgc2tpcCAtIG5vbi1PU0VOIG5ldHdvcmsgIgorCQkJCSJub3QgYWxsb3dlZCIpOworCQkJY29udGludWU7CisJCX0KKwogCQlpZiAoIXdwYV9zdXBwbGljYW50X21hdGNoX3ByaXZhY3koYnNzLCBzc2lkKSkgewogCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiICAgc2tpcCAtIHByaXZhY3kgIgogCQkJCSJtaXNtYXRjaCIpOwpAQCAtODU4LDYgKzkwOSwzOSBAQAogCQl9CiAKICNpZmRlZiBDT05GSUdfUDJQCisJCWlmIChzc2lkLT5wMnBfZ3JvdXAgJiYKKwkJICAgICF3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBQMlBfSUVfVkVORE9SX1RZUEUpICYmCisJCSAgICAhd3BhX2Jzc19nZXRfdmVuZG9yX2llX2JlYWNvbihic3MsIFAyUF9JRV9WRU5ET1JfVFlQRSkpIHsKKwkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIiAgIHNraXAgLSBubyBQMlAgSUUgc2VlbiIpOworCQkJY29udGludWU7CisJCX0KKworCQlpZiAoIWlzX3plcm9fZXRoZXJfYWRkcihzc2lkLT5nb19wMnBfZGV2X2FkZHIpKSB7CisJCQlzdHJ1Y3Qgd3BhYnVmICpwMnBfaWU7CisJCQl1OCBkZXZfYWRkcltFVEhfQUxFTl07CisKKwkJCWllID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKKwkJCWlmIChpZSA9PSBOVUxMKSB7CisJCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiICAgc2tpcCAtIG5vIFAyUCBlbGVtZW50Iik7CisJCQkJY29udGludWU7CisJCQl9CisJCQlwMnBfaWUgPSB3cGFfYnNzX2dldF92ZW5kb3JfaWVfbXVsdGkoCisJCQkJYnNzLCBQMlBfSUVfVkVORE9SX1RZUEUpOworCQkJaWYgKHAycF9pZSA9PSBOVUxMKSB7CisJCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiICAgc2tpcCAtIGNvdWxkIG5vdCBmZXRjaCBQMlAgZWxlbWVudCIpOworCQkJCWNvbnRpbnVlOworCQkJfQorCisJCQlpZiAocDJwX3BhcnNlX2Rldl9hZGRyX2luX3AycF9pZShwMnBfaWUsIGRldl9hZGRyKSA8IDAKKwkJCSAgICB8fCBvc19tZW1jbXAoZGV2X2FkZHIsIHNzaWQtPmdvX3AycF9kZXZfYWRkciwKKwkJCQkJIEVUSF9BTEVOKSAhPSAwKSB7CisJCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiICAgc2tpcCAtIG5vIG1hdGNoaW5nIEdPIFAyUCBEZXZpY2UgQWRkcmVzcyBpbiBQMlAgZWxlbWVudCIpOworCQkJCXdwYWJ1Zl9mcmVlKHAycF9pZSk7CisJCQkJY29udGludWU7CisJCQl9CisJCQl3cGFidWZfZnJlZShwMnBfaWUpOworCQl9CisKIAkJLyoKIAkJICogVE9ETzogc2tpcCB0aGUgQVAgaWYgaXRzIFAyUCBJRSBoYXMgR3JvdXAgRm9ybWF0aW9uCiAJCSAqIGJpdCBzZXQgaW4gdGhlIFAyUCBHcm91cCBDYXBhYmlsaXR5IEJpdG1hcCBhbmQgd2UKQEAgLTg3NywxNiArOTYxLDIyIEBACiBzdGF0aWMgc3RydWN0IHdwYV9ic3MgKgogd3BhX3N1cHBsaWNhbnRfc2VsZWN0X2JzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJICBzdHJ1Y3Qgd3BhX3NzaWQgKmdyb3VwLAotCQkJICBzdHJ1Y3Qgd3BhX3NzaWQgKipzZWxlY3RlZF9zc2lkKQorCQkJICBzdHJ1Y3Qgd3BhX3NzaWQgKipzZWxlY3RlZF9zc2lkLAorCQkJICBpbnQgb25seV9maXJzdF9zc2lkKQogewogCXVuc2lnbmVkIGludCBpOwogCi0Jd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiU2VsZWN0aW5nIEJTUyBmcm9tIHByaW9yaXR5IGdyb3VwICVkIiwKLQkJZ3JvdXAtPnByaW9yaXR5KTsKKwlpZiAob25seV9maXJzdF9zc2lkKQorCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJUcnkgdG8gZmluZCBCU1MgbWF0Y2hpbmcgcHJlLXNlbGVjdGVkIG5ldHdvcmsgaWQ9JWQiLAorCQkJZ3JvdXAtPmlkKTsKKwllbHNlCisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlNlbGVjdGluZyBCU1MgZnJvbSBwcmlvcml0eSBncm91cCAlZCIsCisJCQlncm91cC0+cHJpb3JpdHkpOwogCiAJZm9yIChpID0gMDsgaSA8IHdwYV9zLT5sYXN0X3NjYW5fcmVzX3VzZWQ7IGkrKykgewogCQlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gd3BhX3MtPmxhc3Rfc2Nhbl9yZXNbaV07Ci0JCSpzZWxlY3RlZF9zc2lkID0gd3BhX3NjYW5fcmVzX21hdGNoKHdwYV9zLCBpLCBic3MsIGdyb3VwKTsKKwkJKnNlbGVjdGVkX3NzaWQgPSB3cGFfc2Nhbl9yZXNfbWF0Y2god3BhX3MsIGksIGJzcywgZ3JvdXAsCisJCQkJCQkgICAgb25seV9maXJzdF9zc2lkKTsKIAkJaWYgKCEqc2VsZWN0ZWRfc3NpZCkKIAkJCWNvbnRpbnVlOwogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICIgICBzZWxlY3RlZCBCU1MgIiBNQUNTVFIKQEAgLTkwNSwxNiArOTk1LDM2IEBACiB7CiAJc3RydWN0IHdwYV9ic3MgKnNlbGVjdGVkID0gTlVMTDsKIAlpbnQgcHJpbzsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKm5leHRfc3NpZCA9IE5VTEw7CiAKIAlpZiAod3BhX3MtPmxhc3Rfc2Nhbl9yZXMgPT0gTlVMTCB8fAogCSAgICB3cGFfcy0+bGFzdF9zY2FuX3Jlc191c2VkID09IDApCiAJCXJldHVybiBOVUxMOyAvKiBubyBzY2FuIHJlc3VsdHMgZnJvbSBsYXN0IHVwZGF0ZSAqLwogCisJaWYgKHdwYV9zLT5uZXh0X3NzaWQpIHsKKwkJc3RydWN0IHdwYV9zc2lkICpzc2lkOworCisJCS8qIGNoZWNrIHRoYXQgbmV4dF9zc2lkIGlzIHN0aWxsIHZhbGlkICovCisJCWZvciAoc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOyBzc2lkOyBzc2lkID0gc3NpZC0+bmV4dCkgeworCQkJaWYgKHNzaWQgPT0gd3BhX3MtPm5leHRfc3NpZCkKKwkJCQlicmVhazsKKwkJfQorCQluZXh0X3NzaWQgPSBzc2lkOworCQl3cGFfcy0+bmV4dF9zc2lkID0gTlVMTDsKKwl9CisKIAl3aGlsZSAoc2VsZWN0ZWQgPT0gTlVMTCkgewogCQlmb3IgKHByaW8gPSAwOyBwcmlvIDwgd3BhX3MtPmNvbmYtPm51bV9wcmlvOyBwcmlvKyspIHsKKwkJCWlmIChuZXh0X3NzaWQgJiYgbmV4dF9zc2lkLT5wcmlvcml0eSA9PQorCQkJICAgIHdwYV9zLT5jb25mLT5wc3NpZFtwcmlvXS0+cHJpb3JpdHkpIHsKKwkJCQlzZWxlY3RlZCA9IHdwYV9zdXBwbGljYW50X3NlbGVjdF9ic3MoCisJCQkJCXdwYV9zLCBuZXh0X3NzaWQsIHNlbGVjdGVkX3NzaWQsIDEpOworCQkJCWlmIChzZWxlY3RlZCkKKwkJCQkJYnJlYWs7CisJCQl9CiAJCQlzZWxlY3RlZCA9IHdwYV9zdXBwbGljYW50X3NlbGVjdF9ic3MoCiAJCQkJd3BhX3MsIHdwYV9zLT5jb25mLT5wc3NpZFtwcmlvXSwKLQkJCQlzZWxlY3RlZF9zc2lkKTsKKwkJCQlzZWxlY3RlZF9zc2lkLCAwKTsKIAkJCWlmIChzZWxlY3RlZCkKIAkJCQlicmVhazsKIAkJfQpAQCAtOTQ1LDkgKzEwNTUsNiBAQAogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJTaG9ydC1jaXJjdWl0IG5ldyBzY2FuIHJlcXVlc3QgIgogCQkJInNpbmNlIHRoZXJlIGFyZSBubyBlbmFibGVkIG5ldHdvcmtzIik7CiAJCXdwYV9zdXBwbGljYW50X3NldF9zdGF0ZSh3cGFfcywgV1BBX0lOQUNUSVZFKTsKLSNpZmRlZiBDT05GSUdfUDJQCi0JCXdwYV9zLT5zdGFfc2Nhbl9wZW5kaW5nID0gMDsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJCXJldHVybjsKIAl9CiAKQEAgLTk2NCw4ICsxMDcxLDEyIEBACiAJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBXUFNfRVZFTlRfT1ZFUkxBUAogCQkJIlBCQyBzZXNzaW9uIG92ZXJsYXAiKTsKICNpZmRlZiBDT05GSUdfUDJQCi0JCWlmICh3cGFzX3AycF9ub3RpZl9wYmNfb3ZlcmxhcCh3cGFfcykgPT0gMSkKKwkJaWYgKHdwYV9zLT5wMnBfZ3JvdXBfaW50ZXJmYWNlID09IFAyUF9HUk9VUF9JTlRFUkZBQ0VfQ0xJRU5UIHx8CisJCSAgICB3cGFfcy0+cDJwX2luX3Byb3Zpc2lvbmluZykgeworCQkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLCB3cGFzX3AycF9wYmNfb3ZlcmxhcF9jYiwKKwkJCQkJICAgICAgIHdwYV9zLCBOVUxMKTsKIAkJCXJldHVybiAtMTsKKwkJfQogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogI2lmZGVmIENPTkZJR19XUFMKQEAgLTExNDgsNyArMTI1OSw4IEBACiAJCQkJCSAgICAgIHVuaW9uIHdwYV9ldmVudF9kYXRhICpkYXRhLAogCQkJCQkgICAgICBpbnQgb3duX3JlcXVlc3QpCiB7Ci0Jc3RydWN0IHdwYV9zY2FuX3Jlc3VsdHMgKnNjYW5fcmVzOworCXN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3JlcyA9IE5VTEw7CisJaW50IHJldCA9IDA7CiAJaW50IGFwID0gMDsKICNpZm5kZWYgQ09ORklHX05PX1JBTkRPTV9QT09MCiAJc2l6ZV90IGksIG51bTsKQEAgLTExNjEsMjMgKzEyNzMsNiBAQAogCiAJd3BhX3N1cHBsaWNhbnRfbm90aWZ5X3NjYW5uaW5nKHdwYV9zLCAwKTsKIAotI2lmZGVmIENPTkZJR19QMlAKLQlpZiAob3duX3JlcXVlc3QgJiYgd3BhX3MtPmdsb2JhbC0+cDJwX2NiX29uX3NjYW5fY29tcGxldGUgJiYKLQkgICAgIXdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCAmJgotCSAgICB3cGFfcy0+Z2xvYmFsLT5wMnAgIT0gTlVMTCAmJiAhd3BhX3MtPnN0YV9zY2FuX3BlbmRpbmcgJiYKLQkgICAgIXdwYV9zLT5zY2FuX3Jlc19oYW5kbGVyKSB7Ci0JCXdwYV9zLT5nbG9iYWwtPnAycF9jYl9vbl9zY2FuX2NvbXBsZXRlID0gMDsKLQkJaWYgKHAycF9vdGhlcl9zY2FuX2NvbXBsZXRlZCh3cGFfcy0+Z2xvYmFsLT5wMnApID09IDEpIHsKLQkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlAyUDogUGVuZGluZyBQMlAgb3BlcmF0aW9uICIKLQkJCQkic3RvcHBlZCBzY2FuIHByb2Nlc3NpbmciKTsKLQkJCXdwYV9zLT5zdGFfc2Nhbl9wZW5kaW5nID0gMTsKLQkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCA1LCAwKTsKLQkJCXJldHVybiAtMTsKLQkJfQotCX0KLQl3cGFfcy0+c3RhX3NjYW5fcGVuZGluZyA9IDA7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwotCiAJc2Nhbl9yZXMgPSB3cGFfc3VwcGxpY2FudF9nZXRfc2Nhbl9yZXN1bHRzKHdwYV9zLAogCQkJCQkJICAgZGF0YSA/ICZkYXRhLT5zY2FuX2luZm8gOgogCQkJCQkJICAgTlVMTCwgMSk7CkBAIC0xMTkwLDcgKzEyODUsOCBAQAogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJGYWlsZWQgdG8gZ2V0IHNjYW4gcmVzdWx0cyAtIHRyeSAiCiAJCQkic2Nhbm5pbmcgYWdhaW4iKTsKIAkJd3BhX3N1cHBsaWNhbnRfcmVxX25ld19zY2FuKHdwYV9zLCAxLCAwKTsKLQkJcmV0dXJuIC0xOworCQlyZXQgPSAtMTsKKwkJZ290byBzY2FuX3dvcmtfZG9uZTsKIAl9CiAKICNpZm5kZWYgQ09ORklHX05PX1JBTkRPTV9QT09MCkBAIC0xMjA5LDE2ICsxMzA1LDE2IEBACiAJfQogI2VuZGlmIC8qIENPTkZJR19OT19SQU5ET01fUE9PTCAqLwogCi0JaWYgKG93bl9yZXF1ZXN0ICYmIHdwYV9zLT5zY2FuX3Jlc19oYW5kbGVyKSB7CisJaWYgKG93bl9yZXF1ZXN0ICYmIHdwYV9zLT5zY2FuX3Jlc19oYW5kbGVyICYmCisJICAgICh3cGFfcy0+b3duX3NjYW5fcnVubmluZyB8fCAhd3BhX3MtPmV4dGVybmFsX3NjYW5fcnVubmluZykpIHsKIAkJdm9pZCAoKnNjYW5fcmVzX2hhbmRsZXIpKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSBzdHJ1Y3Qgd3BhX3NjYW5fcmVzdWx0cyAqc2Nhbl9yZXMpOwogCiAJCXNjYW5fcmVzX2hhbmRsZXIgPSB3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlcjsKIAkJd3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPSBOVUxMOwogCQlzY2FuX3Jlc19oYW5kbGVyKHdwYV9zLCBzY2FuX3Jlcyk7Ci0KLQkJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKLQkJcmV0dXJuIC0yOworCQlyZXQgPSAtMjsKKwkJZ290byBzY2FuX3dvcmtfZG9uZTsKIAl9CiAKIAlpZiAoYXApIHsKQEAgLTEyMjcsNTMgKzEzMjMsNzIgQEAKIAkJaWYgKHdwYV9zLT5hcF9pZmFjZS0+c2Nhbl9jYikKIAkJCXdwYV9zLT5hcF9pZmFjZS0+c2Nhbl9jYih3cGFfcy0+YXBfaWZhY2UpOwogI2VuZGlmIC8qIENPTkZJR19BUCAqLwotCQl3cGFfc2Nhbl9yZXN1bHRzX2ZyZWUoc2Nhbl9yZXMpOwotCQlyZXR1cm4gMDsKKwkJZ290byBzY2FuX3dvcmtfZG9uZTsKIAl9CiAKLQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJOZXcgc2NhbiByZXN1bHRzIGF2YWlsYWJsZSIpOwotCXdwYV9tc2dfY3RybCh3cGFfcywgTVNHX0lORk8sIFdQQV9FVkVOVF9TQ0FOX1JFU1VMVFMpOworCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIk5ldyBzY2FuIHJlc3VsdHMgYXZhaWxhYmxlIChvd249JXUgZXh0PSV1KSIsCisJCXdwYV9zLT5vd25fc2Nhbl9ydW5uaW5nLCB3cGFfcy0+ZXh0ZXJuYWxfc2Nhbl9ydW5uaW5nKTsKKwlpZiAod3BhX3MtPmxhc3Rfc2Nhbl9yZXEgPT0gTUFOVUFMX1NDQU5fUkVRICYmCisJICAgIHdwYV9zLT5tYW51YWxfc2Nhbl91c2VfaWQgJiYgd3BhX3MtPm93bl9zY2FuX3J1bm5pbmcpIHsKKwkJd3BhX21zZ19jdHJsKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX1NDQU5fUkVTVUxUUyAiaWQ9JXUiLAorCQkJICAgICB3cGFfcy0+bWFudWFsX3NjYW5faWQpOworCQl3cGFfcy0+bWFudWFsX3NjYW5fdXNlX2lkID0gMDsKKwl9IGVsc2UgeworCQl3cGFfbXNnX2N0cmwod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfU0NBTl9SRVNVTFRTKTsKKwl9CiAJd3Bhc19ub3RpZnlfc2Nhbl9yZXN1bHRzKHdwYV9zKTsKIAogCXdwYXNfbm90aWZ5X3NjYW5fZG9uZSh3cGFfcywgMSk7CiAKLQlpZiAoc21lX3Byb2Nfb2Jzc19zY2FuKHdwYV9zKSA+IDApIHsKKwlpZiAoIXdwYV9zLT5vd25fc2Nhbl9ydW5uaW5nICYmIHdwYV9zLT5leHRlcm5hbF9zY2FuX3J1bm5pbmcpIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiRG8gbm90IHVzZSByZXN1bHRzIGZyb20gZXh0ZXJuYWxseSByZXF1ZXN0ZWQgc2NhbiBvcGVyYXRpb24gZm9yIG5ldHdvcmsgc2VsZWN0aW9uIik7CiAJCXdwYV9zY2FuX3Jlc3VsdHNfZnJlZShzY2FuX3Jlcyk7CiAJCXJldHVybiAwOwogCX0KIAotCWlmICgod3BhX3MtPmNvbmYtPmFwX3NjYW4gPT0gMiAmJiAhd3Bhc193cHNfc2VhcmNoaW5nKHdwYV9zKSkpIHsKLQkJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKLQkJcmV0dXJuIDA7Ci0JfQorCWlmIChzbWVfcHJvY19vYnNzX3NjYW4od3BhX3MpID4gMCkKKwkJZ290byBzY2FuX3dvcmtfZG9uZTsKIAotCWlmIChhdXRvc2Nhbl9ub3RpZnlfc2Nhbih3cGFfcywgc2Nhbl9yZXMpKSB7Ci0JCXdwYV9zY2FuX3Jlc3VsdHNfZnJlZShzY2FuX3Jlcyk7Ci0JCXJldHVybiAwOwotCX0KKwlpZiAoKHdwYV9zLT5jb25mLT5hcF9zY2FuID09IDIgJiYgIXdwYXNfd3BzX3NlYXJjaGluZyh3cGFfcykpKQorCQlnb3RvIHNjYW5fd29ya19kb25lOworCisJaWYgKGF1dG9zY2FuX25vdGlmeV9zY2FuKHdwYV9zLCBzY2FuX3JlcykpCisJCWdvdG8gc2Nhbl93b3JrX2RvbmU7CiAKIAlpZiAod3BhX3MtPmRpc2Nvbm5lY3RlZCkgewogCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9ESVNDT05ORUNURUQpOwotCQl3cGFfc2Nhbl9yZXN1bHRzX2ZyZWUoc2Nhbl9yZXMpOwotCQlyZXR1cm4gMDsKKwkJZ290byBzY2FuX3dvcmtfZG9uZTsKIAl9CiAKIAlpZiAoIXdwYXNfZHJpdmVyX2Jzc19zZWxlY3Rpb24od3BhX3MpICYmCi0JICAgIGJnc2Nhbl9ub3RpZnlfc2Nhbih3cGFfcywgc2Nhbl9yZXMpID09IDEpIHsKLQkJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKLQkJcmV0dXJuIDA7Ci0JfQorCSAgICBiZ3NjYW5fbm90aWZ5X3NjYW4od3BhX3MsIHNjYW5fcmVzKSA9PSAxKQorCQlnb3RvIHNjYW5fd29ya19kb25lOwogCiAJd3Bhc193cHNfdXBkYXRlX2FwX2luZm8od3BhX3MsIHNjYW5fcmVzKTsKIAogCXdwYV9zY2FuX3Jlc3VsdHNfZnJlZShzY2FuX3Jlcyk7CiAKLQlyZXR1cm4gd3Bhc19zZWxlY3RfbmV0d29ya19mcm9tX2xhc3Rfc2Nhbih3cGFfcywgMSk7CisJaWYgKHdwYV9zLT5zY2FuX3dvcmspIHsKKwkJc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrID0gd3BhX3MtPnNjYW5fd29yazsKKwkJd3BhX3MtPnNjYW5fd29yayA9IE5VTEw7CisJCXJhZGlvX3dvcmtfZG9uZSh3b3JrKTsKKwl9CisKKwlyZXR1cm4gd3Bhc19zZWxlY3RfbmV0d29ya19mcm9tX2xhc3Rfc2Nhbih3cGFfcywgMSwgb3duX3JlcXVlc3QpOworCitzY2FuX3dvcmtfZG9uZToKKwl3cGFfc2Nhbl9yZXN1bHRzX2ZyZWUoc2Nhbl9yZXMpOworCWlmICh3cGFfcy0+c2Nhbl93b3JrKSB7CisJCXN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yayA9IHdwYV9zLT5zY2FuX3dvcms7CisJCXdwYV9zLT5zY2FuX3dvcmsgPSBOVUxMOworCQlyYWRpb193b3JrX2RvbmUod29yayk7CisJfQorCXJldHVybiByZXQ7CiB9CiAKIAogc3RhdGljIGludCB3cGFzX3NlbGVjdF9uZXR3b3JrX2Zyb21fbGFzdF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgICAgIGludCBuZXdfc2NhbikKKwkJCQkJICAgICAgaW50IG5ld19zY2FuLCBpbnQgb3duX3JlcXVlc3QpCiB7CiAJc3RydWN0IHdwYV9ic3MgKnNlbGVjdGVkOwogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IE5VTEw7CkBAIC0xMzA4LDE3ICsxNDIzLDI1IEBACiAJCQl3cGFfc3VwcGxpY2FudF9hc3NvY2lhdGUod3BhX3MsIE5VTEwsIHNzaWQpOwogCQkJaWYgKG5ld19zY2FuKQogCQkJCXdwYV9zdXBwbGljYW50X3Jzbl9wcmVhdXRoX3NjYW5fcmVzdWx0cyh3cGFfcyk7Ci0JCX0gZWxzZSB7CisJCX0gZWxzZSBpZiAob3duX3JlcXVlc3QpIHsKKwkJCS8qCisJCQkgKiBObyBTU0lEIGZvdW5kLiBJZiBTQ0FOIHJlc3VsdHMgYXJlIGFzIGEgcmVzdWx0IG9mCisJCQkgKiBvd24gc2NhbiByZXF1ZXN0IGFuZCBub3QgZHVlIHRvIGEgc2NhbiByZXF1ZXN0IG9uCisJCQkgKiBhbm90aGVyIHNoYXJlZCBpbnRlcmZhY2UsIHRyeSBhbm90aGVyIHNjYW4uCisJCQkgKi8KIAkJCWludCB0aW1lb3V0X3NlYyA9IHdwYV9zLT5zY2FuX2ludGVydmFsOwogCQkJaW50IHRpbWVvdXRfdXNlYyA9IDA7CiAjaWZkZWYgQ09ORklHX1AyUAogCQkJaWYgKHdwYXNfcDJwX3NjYW5fbm9fZ29fc2Vlbih3cGFfcykgPT0gMSkKIAkJCQlyZXR1cm4gMDsKIAotCQkJaWYgKHdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nKSB7CisJCQlpZiAod3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcgfHwKKwkJCSAgICB3cGFfcy0+c2hvd19ncm91cF9zdGFydGVkIHx8CisJCQkgICAgd3BhX3MtPnAycF9pbl9pbnZpdGF0aW9uKSB7CiAJCQkJLyoKIAkJCQkgKiBVc2Ugc2hvcnRlciB3YWl0IGR1cmluZyBQMlAgUHJvdmlzaW9uaW5nCi0JCQkJICogc3RhdGUgdG8gc3BlZWQgdXAgZ3JvdXAgZm9ybWF0aW9uLgorCQkJCSAqIHN0YXRlIGFuZCBkdXJpbmcgUDJQIGpvaW4tYS1ncm91cCBvcGVyYXRpb24KKwkJCQkgKiB0byBzcGVlZCB1cCBncm91cCBmb3JtYXRpb24uCiAJCQkJICovCiAJCQkJdGltZW91dF9zZWMgPSAwOwogCQkJCXRpbWVvdXRfdXNlYyA9IDI1MDAwMDsKQEAgLTEzNDAsNiArMTQ2MywxNiBAQAogCQkJCXJldHVybiAxOwogCQkJfQogI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KKyNpZmRlZiBDT05GSUdfV1BTCisJCQlpZiAod3BhX3MtPmFmdGVyX3dwcyA+IDAgfHwgd3Bhc193cHNfc2VhcmNoaW5nKHdwYV9zKSkgeworCQkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlVzZSBzaG9ydGVyIHdhaXQgZHVyaW5nIFdQUyBwcm9jZXNzaW5nIik7CisJCQkJdGltZW91dF9zZWMgPSAwOworCQkJCXRpbWVvdXRfdXNlYyA9IDUwMDAwMDsKKwkJCQl3cGFfc3VwcGxpY2FudF9yZXFfbmV3X3NjYW4od3BhX3MsIHRpbWVvdXRfc2VjLAorCQkJCQkJCSAgICB0aW1lb3V0X3VzZWMpOworCQkJCXJldHVybiAwOworCQkJfQorI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAkJCWlmICh3cGFfc3VwcGxpY2FudF9yZXFfc2NoZWRfc2Nhbih3cGFfcykpCiAJCQkJd3BhX3N1cHBsaWNhbnRfcmVxX25ld19zY2FuKHdwYV9zLCB0aW1lb3V0X3NlYywKIAkJCQkJCQkgICAgdGltZW91dF91c2VjKTsKQEAgLTEzNTIsNyArMTQ4NSw2IEBACiBzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9ldmVudF9zY2FuX3Jlc3VsdHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICAgICAgdW5pb24gd3BhX2V2ZW50X2RhdGEgKmRhdGEpCiB7Ci0JY29uc3QgY2hhciAqcm4sICpybjI7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICppZnM7CiAKIAlpZiAoX3dwYV9zdXBwbGljYW50X2V2ZW50X3NjYW5fcmVzdWx0cyh3cGFfcywgZGF0YSwgMSkgIT0gMCkgewpAQCAtMTM2NywyNSArMTQ5OSwxMiBAQAogCX0KIAogCS8qCi0JICogQ2hlY2sgb3RoZXIgaW50ZXJmYWNlcyB0byBzZWUgaWYgdGhleSBoYXZlIHRoZSBzYW1lIHJhZGlvLW5hbWUuIElmCisJICogQ2hlY2sgb3RoZXIgaW50ZXJmYWNlcyB0byBzZWUgaWYgdGhleSBzaGFyZSB0aGUgc2FtZSByYWRpby4gSWYKIAkgKiBzbywgdGhleSBnZXQgdXBkYXRlZCB3aXRoIHRoaXMgc2FtZSBzY2FuIGluZm8uCiAJICovCi0JaWYgKCF3cGFfcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSkKLQkJcmV0dXJuOwotCi0Jcm4gPSB3cGFfcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSh3cGFfcy0+ZHJ2X3ByaXYpOwotCWlmIChybiA9PSBOVUxMIHx8IHJuWzBdID09ICdcMCcpCi0JCXJldHVybjsKLQotCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkNoZWNraW5nIGZvciBvdGhlciB2aXJ0dWFsIGludGVyZmFjZXMgIgotCQkic2hhcmluZyBzYW1lIHJhZGlvICglcykgaW4gZXZlbnRfc2Nhbl9yZXN1bHRzIiwgcm4pOwotCi0JZm9yIChpZnMgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IGlmczsgaWZzID0gaWZzLT5uZXh0KSB7Ci0JCWlmIChpZnMgPT0gd3BhX3MgfHwgIWlmcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSkKLQkJCWNvbnRpbnVlOwotCi0JCXJuMiA9IGlmcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZShpZnMtPmRydl9wcml2KTsKLQkJaWYgKHJuMiAmJiBvc19zdHJjbXAocm4sIHJuMikgPT0gMCkgeworCWRsX2xpc3RfZm9yX2VhY2goaWZzLCAmd3BhX3MtPnJhZGlvLT5pZmFjZXMsIHN0cnVjdCB3cGFfc3VwcGxpY2FudCwKKwkJCSByYWRpb19saXN0KSB7CisJCWlmIChpZnMgIT0gd3BhX3MpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IFVwZGF0aW5nIHNjYW4gcmVzdWx0cyBmcm9tICIKIAkJCQkgICAic2libGluZyIsIGlmcy0+aWZuYW1lKTsKIAkJCV93cGFfc3VwcGxpY2FudF9ldmVudF9zY2FuX3Jlc3VsdHMoaWZzLCBkYXRhLCAwKTsKQEAgLTE0MDEsMTggKzE1MjAsMTggQEAKICNpZmRlZiBDT05GSUdfTk9fU0NBTl9QUk9DRVNTSU5HCiAJcmV0dXJuIC0xOwogI2Vsc2UgLyogQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORyAqLwotCXN0cnVjdCBvc190aW1lIG5vdzsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKIAlpZiAod3BhX3MtPmxhc3Rfc2Nhbl9yZXNfdXNlZCA8PSAwKQogCQlyZXR1cm4gLTE7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKLQlpZiAobm93LnNlYyAtIHdwYV9zLT5sYXN0X3NjYW4uc2VjID4gNSkgeworCW9zX2dldF9yZWx0aW1lKCZub3cpOworCWlmIChvc19yZWx0aW1lX2V4cGlyZWQoJm5vdywgJndwYV9zLT5sYXN0X3NjYW4sIDUpKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRmFzdCBhc3NvY2lhdGU6IE9sZCBzY2FuIHJlc3VsdHMiKTsKIAkJcmV0dXJuIC0xOwogCX0KIAotCXJldHVybiB3cGFzX3NlbGVjdF9uZXR3b3JrX2Zyb21fbGFzdF9zY2FuKHdwYV9zLCAwKTsKKwlyZXR1cm4gd3Bhc19zZWxlY3RfbmV0d29ya19mcm9tX2xhc3Rfc2Nhbih3cGFfcywgMCwgMSk7CiAjZW5kaWYgLyogQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORyAqLwogfQogCkBAIC0xNDk2LDYgKzE2MTUsNDMgQEAKIH0KIAogCisjaWZkZWYgQ09ORklHX0lOVEVSV09SS0lORworCitzdGF0aWMgaW50IHdwYXNfcW9zX21hcF9zZXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKnFvc19tYXAsCisJCQkgICAgc2l6ZV90IGxlbikKK3sKKwlpbnQgcmVzOworCisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBRb1MgTWFwIFNldCIsIHFvc19tYXAsIGxlbik7CisJcmVzID0gd3BhX2Rydl9zZXRfcW9zX21hcCh3cGFfcywgcW9zX21hcCwgbGVuKTsKKwlpZiAocmVzKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBGYWlsZWQgdG8gY29uZmlndXJlIFFvUyBNYXAgU2V0IHRvIHRoZSBkcml2ZXIiKTsKKwl9CisKKwlyZXR1cm4gcmVzOworfQorCisKK3N0YXRpYyB2b2lkIGludGVyd29ya2luZ19wcm9jZXNzX2Fzc29jX3Jlc3Aoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgIGNvbnN0IHU4ICppZXMsIHNpemVfdCBpZXNfbGVuKQoreworCXN0cnVjdCBpZWVlODAyXzExX2VsZW1zIGVsZW1zOworCisJaWYgKGllcyA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlpZiAoaWVlZTgwMl8xMV9wYXJzZV9lbGVtcyhpZXMsIGllc19sZW4sICZlbGVtcywgMSkgPT0gUGFyc2VGYWlsZWQpCisJCXJldHVybjsKKworCWlmIChlbGVtcy5xb3NfbWFwX3NldCkgeworCQl3cGFzX3Fvc19tYXBfc2V0KHdwYV9zLCBlbGVtcy5xb3NfbWFwX3NldCwKKwkJCQkgZWxlbXMucW9zX21hcF9zZXRfbGVuKTsKKwl9Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCisKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9ldmVudF9hc3NvY2luZm8oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICB1bmlvbiB3cGFfZXZlbnRfZGF0YSAqZGF0YSkKIHsKQEAgLTE1MjAsNiArMTY3NiwxMCBAQAogCQl3bm1fcHJvY2Vzc19hc3NvY19yZXNwKHdwYV9zLCBkYXRhLT5hc3NvY19pbmZvLnJlc3BfaWVzLAogCQkJCSAgICAgICBkYXRhLT5hc3NvY19pbmZvLnJlc3BfaWVzX2xlbik7CiAjZW5kaWYgLyogQ09ORklHX1dOTSAqLworI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKwkJaW50ZXJ3b3JraW5nX3Byb2Nlc3NfYXNzb2NfcmVzcCh3cGFfcywgZGF0YS0+YXNzb2NfaW5mby5yZXNwX2llcywKKwkJCQkJCWRhdGEtPmFzc29jX2luZm8ucmVzcF9pZXNfbGVuKTsKKyNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAJfQogCWlmIChkYXRhLT5hc3NvY19pbmZvLmJlYWNvbl9pZXMpCiAJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgImJlYWNvbl9pZXMiLApAQCAtMTY4OCwyMSArMTg0OCw2IEBACiB9CiAKIAotc3RhdGljIHN0cnVjdCB3cGFfYnNzICogd3BhX3N1cHBsaWNhbnRfZ2V0X25ld19ic3MoCi0Jc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmJzc2lkKQotewotCXN0cnVjdCB3cGFfYnNzICpic3MgPSBOVUxMOwotCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7Ci0KLQlpZiAoc3NpZC0+c3NpZF9sZW4gPiAwKQotCQlic3MgPSB3cGFfYnNzX2dldCh3cGFfcywgYnNzaWQsIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKLQlpZiAoIWJzcykKLQkJYnNzID0gd3BhX2Jzc19nZXRfYnNzaWQod3BhX3MsIGJzc2lkKTsKLQotCXJldHVybiBic3M7Ci19Ci0KLQogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9hc3NvY191cGRhdGVfaWUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKIAljb25zdCB1OCAqYnNzX3dwYSA9IE5VTEwsICpic3NfcnNuID0gTlVMTDsKQEAgLTE3MzUsNiArMTg4MCw4IEBACiAKICNpZmRlZiBDT05GSUdfQVAKIAlpZiAod3BhX3MtPmFwX2lmYWNlKSB7CisJCWlmICghZGF0YSkKKwkJCXJldHVybjsKIAkJaG9zdGFwZF9ub3RpZl9hc3NvYyh3cGFfcy0+YXBfaWZhY2UtPmJzc1swXSwKIAkJCQkgICAgZGF0YS0+YXNzb2NfaW5mby5hZGRyLAogCQkJCSAgICBkYXRhLT5hc3NvY19pbmZvLnJlcV9pZXMsCkBAIC0xNzcyLDIwICsxOTE5LDYgQEAKIAkJCQl3cGFfcywgV0xBTl9SRUFTT05fREVBVVRIX0xFQVZJTkcpOwogCQkJcmV0dXJuOwogCQl9Ci0JCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkKSB7Ci0JCQlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gTlVMTDsKLQotCQkJYnNzID0gd3BhX3N1cHBsaWNhbnRfZ2V0X25ld19ic3Mod3BhX3MsIGJzc2lkKTsKLQkJCWlmICghYnNzKSB7Ci0JCQkJd3BhX3N1cHBsaWNhbnRfdXBkYXRlX3NjYW5fcmVzdWx0cyh3cGFfcyk7Ci0KLQkJCQkvKiBHZXQgdGhlIEJTUyBmcm9tIHRoZSBuZXcgc2NhbiByZXN1bHRzICovCi0JCQkJYnNzID0gd3BhX3N1cHBsaWNhbnRfZ2V0X25ld19ic3Mod3BhX3MsIGJzc2lkKTsKLQkJCX0KLQotCQkJaWYgKGJzcykKLQkJCQl3cGFfcy0+Y3VycmVudF9ic3MgPSBic3M7Ci0JCX0KIAogI2lmZGVmIEFORFJPSUQKIAkJaWYgKHdwYV9zLT5jb25mLT5hcF9zY2FuID09IDEpIHsKQEAgLTE4MDIsNiArMTkzNSw3IEBACiAjaWZkZWYgQ09ORklHX1NNRQogCW9zX21lbWNweSh3cGFfcy0+c21lLnByZXZfYnNzaWQsIGJzc2lkLCBFVEhfQUxFTik7CiAJd3BhX3MtPnNtZS5wcmV2X2Jzc2lkX3NldCA9IDE7CisJd3BhX3MtPnNtZS5sYXN0X3VucHJvdF9kaXNjb25uZWN0LnNlYyA9IDA7CiAjZW5kaWYgLyogQ09ORklHX1NNRSAqLwogCiAJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sICJBc3NvY2lhdGVkIHdpdGggIiBNQUNTVFIsIE1BQzJTVFIoYnNzaWQpKTsKQEAgLTE4MzcsNyArMTk3MSw4IEBACiAJICAgIHdwYV9zLT5rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfV1BBX05PTkUgfHwKIAkgICAgKHdwYV9zLT5jdXJyZW50X3NzaWQgJiYKIAkgICAgIHdwYV9zLT5jdXJyZW50X3NzaWQtPm1vZGUgPT0gSUVFRTgwMjExX01PREVfSUJTUykpIHsKLQkJaWYgKHdwYV9zLT5rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfV1BBX05PTkUgJiYKKwkJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgJiYKKwkJICAgIHdwYV9zLT5rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfV1BBX05PTkUgJiYKIAkJICAgICh3cGFfcy0+ZHJ2X2ZsYWdzICYKIAkJICAgICBXUEFfRFJJVkVSX0ZMQUdTX1NFVF9LRVlTX0FGVEVSX0FTU09DX0RPTkUpKSB7CiAJCQkvKgpAQCAtMTg4Nyw5ICsyMDIyLDkgQEAKIAl3cGFfcy0+bGFzdF9lYXBvbF9tYXRjaGVzX2Jzc2lkID0gMDsKIAogCWlmICh3cGFfcy0+cGVuZGluZ19lYXBvbF9yeCkgewotCQlzdHJ1Y3Qgb3NfdGltZSBub3csIGFnZTsKLQkJb3NfZ2V0X3RpbWUoJm5vdyk7Ci0JCW9zX3RpbWVfc3ViKCZub3csICZ3cGFfcy0+cGVuZGluZ19lYXBvbF9yeF90aW1lLCAmYWdlKTsKKwkJc3RydWN0IG9zX3JlbHRpbWUgbm93LCBhZ2U7CisJCW9zX2dldF9yZWx0aW1lKCZub3cpOworCQlvc19yZWx0aW1lX3N1Yigmbm93LCAmd3BhX3MtPnBlbmRpbmdfZWFwb2xfcnhfdGltZSwgJmFnZSk7CiAJCWlmIChhZ2Uuc2VjID09IDAgJiYgYWdlLnVzZWMgPCAxMDAwMDAgJiYKIAkJICAgIG9zX21lbWNtcCh3cGFfcy0+cGVuZGluZ19lYXBvbF9yeF9zcmMsIGJzc2lkLCBFVEhfQUxFTikgPT0KIAkJICAgIDApIHsKQEAgLTIwMDIsOSArMjEzNyw3IEBACiAJaW50IGF1dGhlbnRpY2F0aW5nOwogCXU4IHByZXZfcGVuZGluZ19ic3NpZFtFVEhfQUxFTl07CiAJc3RydWN0IHdwYV9ic3MgKmZhc3RfcmVjb25uZWN0ID0gTlVMTDsKLSNpZm5kZWYgQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORwogCXN0cnVjdCB3cGFfc3NpZCAqZmFzdF9yZWNvbm5lY3Rfc3NpZCA9IE5VTEw7Ci0jZW5kaWYgLyogQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORyAqLwogCXN0cnVjdCB3cGFfc3NpZCAqbGFzdF9zc2lkOwogCiAJYXV0aGVudGljYXRpbmcgPSB3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9BVVRIRU5USUNBVElORzsKQEAgLTIwMjYsNyArMjE1OSw3IEBACiAJCQkicHJlLXNoYXJlZCBrZXkgbWF5IGJlIGluY29ycmVjdCIpOwogCQlpZiAod3Bhc19wMnBfNHdheV9oc19mYWlsZWQod3BhX3MpID4gMCkKIAkJCXJldHVybjsgLyogUDJQIGdyb3VwIHJlbW92ZWQgKi8KLQkJd3Bhc19hdXRoX2ZhaWxlZCh3cGFfcyk7CisJCXdwYXNfYXV0aF9mYWlsZWQod3BhX3MsICJXUk9OR19LRVkiKTsKIAl9CiAJaWYgKCF3cGFfcy0+ZGlzY29ubmVjdGVkICYmCiAJICAgICghd3BhX3MtPmF1dG9fcmVjb25uZWN0X2Rpc2FibGVkIHx8CkBAIC0yMDQ3LDE1ICsyMTgwLDkgQEAKIAkJCSAqIHRpbWUgZm9yIHNvbWUgY29tbW9uIGNhc2VzLgogCQkJICovCiAJCQlmYXN0X3JlY29ubmVjdCA9IHdwYV9zLT5jdXJyZW50X2JzczsKLSNpZm5kZWYgQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORwogCQkJZmFzdF9yZWNvbm5lY3Rfc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7Ci0jZW5kaWYgLyogQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORyAqLwogCQl9IGVsc2UgaWYgKHdwYV9zLT53cGFfc3RhdGUgPj0gV1BBX0FTU09DSUFUSU5HKQotI2lmZGVmIEFORFJPSUQKLQkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCA1MDAwMDApOwotI2Vsc2UKIAkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAxMDAwMDApOwotI2VuZGlmCiAJCWVsc2UKIAkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkRvIG5vdCByZXF1ZXN0IG5ldyAiCiAJCQkJImltbWVkaWF0ZSBzY2FuIik7CkBAIC0yMDc5LDcgKzIyMDYsNiBAQAogCXdwYXNfbm90aWZ5X2Rpc2Nvbm5lY3RfcmVhc29uKHdwYV9zKTsKIAlpZiAod3BhX3N1cHBsaWNhbnRfZHluYW1pY19rZXlzKHdwYV9zKSkgewogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJEaXNjb25uZWN0IGV2ZW50IC0gcmVtb3ZlIGtleXMiKTsKLQkJd3BhX3MtPmtleXNfY2xlYXJlZCA9IDA7CiAJCXdwYV9jbGVhcl9rZXlzKHdwYV9zLCB3cGFfcy0+YnNzaWQpOwogCX0KIAlsYXN0X3NzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOwpAQCAtMjA5MCw3ICsyMjE2LDEyIEBACiAJCXdwYV9zLT5jdXJyZW50X3NzaWQgPSBsYXN0X3NzaWQ7CiAJfQogCi0JaWYgKGZhc3RfcmVjb25uZWN0KSB7CisJaWYgKGZhc3RfcmVjb25uZWN0ICYmCisJICAgICF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIGZhc3RfcmVjb25uZWN0X3NzaWQpICYmCisJICAgICFkaXNhbGxvd2VkX2Jzc2lkKHdwYV9zLCBmYXN0X3JlY29ubmVjdC0+YnNzaWQpICYmCisJICAgICFkaXNhbGxvd2VkX3NzaWQod3BhX3MsIGZhc3RfcmVjb25uZWN0LT5zc2lkLAorCQkJICAgICBmYXN0X3JlY29ubmVjdC0+c3NpZF9sZW4pICYmCisJICAgICF3cGFzX3RlbXBfZGlzYWJsZWQod3BhX3MsIGZhc3RfcmVjb25uZWN0X3NzaWQpKSB7CiAjaWZuZGVmIENPTkZJR19OT19TQ0FOX1BST0NFU1NJTkcKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiVHJ5IHRvIHJlY29ubmVjdCB0byB0aGUgc2FtZSBCU1MiKTsKIAkJaWYgKHdwYV9zdXBwbGljYW50X2Nvbm5lY3Qod3BhX3MsIGZhc3RfcmVjb25uZWN0LApAQCAtMjA5OSw2ICsyMjMwLDE0IEBACiAJCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMTAwMDAwKTsKIAkJfQogI2VuZGlmIC8qIENPTkZJR19OT19TQ0FOX1BST0NFU1NJTkcgKi8KKwl9IGVsc2UgaWYgKGZhc3RfcmVjb25uZWN0KSB7CisJCS8qCisJCSAqIENvdWxkIG5vdCByZWNvbm5lY3QgdG8gdGhlIHNhbWUgQlNTIGR1ZSB0byBuZXR3b3JrIGJlaW5nCisJCSAqIGRpc2FibGVkLiBVc2UgYSBuZXcgc2NhbiB0byBtYXRjaCB0aGUgYWx0ZXJuYXRpdmUgYmVoYXZpb3IKKwkJICogYWJvdmUsIGkuZS4sIHRvIGNvbnRpbnVlIGF1dG9tYXRpYyByZWNvbm5lY3Rpb24gYXR0ZW1wdCBpbiBhCisJCSAqIHdheSB0aGF0IGVuZm9yY2VzIGRpc2FibGVkIG5ldHdvcmsgcnVsZXMuCisJCSAqLworCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMTAwMDAwKTsKIAl9CiB9CiAKQEAgLTIxMjMsMTMgKzIyNjIsMTMgQEAKIAkJCQkJIHVuaW9uIHdwYV9ldmVudF9kYXRhICpkYXRhKQogewogCWludCBwYWlyd2lzZTsKLQlzdHJ1Y3Qgb3NfdGltZSB0OworCXN0cnVjdCBvc19yZWx0aW1lIHQ7CiAKIAl3cGFfbXNnKHdwYV9zLCBNU0dfV0FSTklORywgIk1pY2hhZWwgTUlDIGZhaWx1cmUgZGV0ZWN0ZWQiKTsKIAlwYWlyd2lzZSA9IChkYXRhICYmIGRhdGEtPm1pY2hhZWxfbWljX2ZhaWx1cmUudW5pY2FzdCk7Ci0Jb3NfZ2V0X3RpbWUoJnQpOwotCWlmICgod3BhX3MtPmxhc3RfbWljaGFlbF9taWNfZXJyb3IgJiYKLQkgICAgIHQuc2VjIC0gd3BhX3MtPmxhc3RfbWljaGFlbF9taWNfZXJyb3IgPD0gNjApIHx8CisJb3NfZ2V0X3JlbHRpbWUoJnQpOworCWlmICgod3BhX3MtPmxhc3RfbWljaGFlbF9taWNfZXJyb3Iuc2VjICYmCisJICAgICAhb3NfcmVsdGltZV9leHBpcmVkKCZ0LCAmd3BhX3MtPmxhc3RfbWljaGFlbF9taWNfZXJyb3IsIDYwKSkgfHwKIAkgICAgd3BhX3MtPnBlbmRpbmdfbWljX2Vycm9yX3JlcG9ydCkgewogCQlpZiAod3BhX3MtPnBlbmRpbmdfbWljX2Vycm9yX3JlcG9ydCkgewogCQkJLyoKQEAgLTIyMDcsNyArMjM0Niw3IEBACiAJCXdwYV9zbV9rZXlfcmVxdWVzdCh3cGFfcy0+d3BhLCAxLCBwYWlyd2lzZSk7CiAjZW5kaWYgLyogQ09ORklHX0RFTEFZRURfTUlDX0VSUk9SX1JFUE9SVCAqLwogCX0KLQl3cGFfcy0+bGFzdF9taWNoYWVsX21pY19lcnJvciA9IHQuc2VjOworCXdwYV9zLT5sYXN0X21pY2hhZWxfbWljX2Vycm9yID0gdDsKIAl3cGFfcy0+bWljX2Vycm9yc19zZWVuKys7CiB9CiAKQEAgLTIyNDIsNyArMjM4MSw2IEBACiAJCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIkZhaWxlZCB0byBpbml0aWFsaXplIHRoZSAiCiAJCQkJImRyaXZlciBhZnRlciBpbnRlcmZhY2Ugd2FzIGFkZGVkIik7CiAJCX0KLQkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfRElTQ09OTkVDVEVEKTsKIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9JTlRFUkZBQ0VfUkVNT1ZFRDoKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQ29uZmlndXJlZCBpbnRlcmZhY2Ugd2FzIHJlbW92ZWQiKTsKQEAgLTIyNTEsMTAgKzIzODksNiBAQAogCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpOwogCQlsMl9wYWNrZXRfZGVpbml0KHdwYV9zLT5sMik7CiAJCXdwYV9zLT5sMiA9IE5VTEw7Ci0jaWZkZWYgQ09ORklHX0lCU1NfUlNOCi0JCWlic3NfcnNuX2RlaW5pdCh3cGFfcy0+aWJzc19yc24pOwotCQl3cGFfcy0+aWJzc19yc24gPSBOVUxMOwotI2VuZGlmIC8qIENPTkZJR19JQlNTX1JTTiAqLwogI2lmZGVmIENPTkZJR19URVJNSU5BVEVfT05MQVNUSUYKIAkJLyogY2hlY2sgaWYgbGFzdCBpbnRlcmZhY2UgKi8KIAkJaWYgKCFhbnlfaW50ZXJmYWNlcyh3cGFfcy0+Z2xvYmFsLT5pZmFjZXMpKQpAQCAtMjQ3OCwxMSArMjYxMiwxMiBAQAogCiAJd3BhX3N1cHBsaWNhbnRfZXZlbnRfZGlzYXNzb2Mod3BhX3MsIHJlYXNvbl9jb2RlLCBsb2NhbGx5X2dlbmVyYXRlZCk7CiAKLQlpZiAocmVhc29uX2NvZGUgPT0gV0xBTl9SRUFTT05fSUVFRV84MDJfMVhfQVVUSF9GQUlMRUQgfHwKLQkgICAgKCh3cGFfa2V5X21nbXRfd3BhX2llZWU4MDIxeCh3cGFfcy0+a2V5X21nbXQpIHx8Ci0JICAgICAgKHdwYV9zLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfTk9fV1BBKSkgJiYKLQkgICAgIGVhcG9sX3NtX2ZhaWxlZCh3cGFfcy0+ZWFwb2wpKSkKLQkJd3Bhc19hdXRoX2ZhaWxlZCh3cGFfcyk7CisJaWYgKCgocmVhc29uX2NvZGUgPT0gV0xBTl9SRUFTT05fSUVFRV84MDJfMVhfQVVUSF9GQUlMRUQgfHwKKwkgICAgICAoKHdwYV9rZXlfbWdtdF93cGFfaWVlZTgwMjF4KHdwYV9zLT5rZXlfbWdtdCkgfHwKKwkJKHdwYV9zLT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfTk9fV1BBKSkgJiYKKwkgICAgICAgZWFwb2xfc21fZmFpbGVkKHdwYV9zLT5lYXBvbCkpKSAmJgorCSAgICAgIXdwYV9zLT5lYXBfZXhwZWN0ZWRfZmFpbHVyZSkpCisJCXdwYXNfYXV0aF9mYWlsZWQod3BhX3MsICJBVVRIX0ZBSUxFRCIpOwogCiAjaWZkZWYgQ09ORklHX1AyUAogCWlmIChkZWF1dGggJiYgcmVhc29uX2NvZGUgPiAwKSB7CkBAIC0yNTkxLDYgKzI3MjYsMjEyIEBACiB9CiAKIAorc3RhdGljIGNvbnN0IGNoYXIgKiByZWdfaW5pdF9zdHIoZW51bSByZWdfY2hhbmdlX2luaXRpYXRvciBpbml0KQoreworCXN3aXRjaCAoaW5pdCkgeworCWNhc2UgUkVHRE9NX1NFVF9CWV9DT1JFOgorCQlyZXR1cm4gIkNPUkUiOworCWNhc2UgUkVHRE9NX1NFVF9CWV9VU0VSOgorCQlyZXR1cm4gIlVTRVIiOworCWNhc2UgUkVHRE9NX1NFVF9CWV9EUklWRVI6CisJCXJldHVybiAiRFJJVkVSIjsKKwljYXNlIFJFR0RPTV9TRVRfQllfQ09VTlRSWV9JRToKKwkJcmV0dXJuICJDT1VOVFJZX0lFIjsKKwljYXNlIFJFR0RPTV9CRUFDT05fSElOVDoKKwkJcmV0dXJuICJCRUFDT05fSElOVCI7CisJfQorCXJldHVybiAiPyI7Cit9CisKKworc3RhdGljIGNvbnN0IGNoYXIgKiByZWdfdHlwZV9zdHIoZW51bSByZWdfdHlwZSB0eXBlKQoreworCXN3aXRjaCAodHlwZSkgeworCWNhc2UgUkVHRE9NX1RZUEVfVU5LTk9XTjoKKwkJcmV0dXJuICJVTktOT1dOIjsKKwljYXNlIFJFR0RPTV9UWVBFX0NPVU5UUlk6CisJCXJldHVybiAiQ09VTlRSWSI7CisJY2FzZSBSRUdET01fVFlQRV9XT1JMRDoKKwkJcmV0dXJuICJXT1JMRCI7CisJY2FzZSBSRUdET01fVFlQRV9DVVNUT01fV09STEQ6CisJCXJldHVybiAiQ1VTVE9NX1dPUkxEIjsKKwljYXNlIFJFR0RPTV9UWVBFX0lOVEVSU0VDVElPTjoKKwkJcmV0dXJuICJJTlRFUlNFQ1RJT04iOworCX0KKwlyZXR1cm4gIj8iOworfQorCisKK3N0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X3VwZGF0ZV9jaGFubmVsX2xpc3QoCisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IGNoYW5uZWxfbGlzdF9jaGFuZ2VkICppbmZvKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqaWZzOworCisJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIFdQQV9FVkVOVF9SRUdET01fQ0hBTkdFICJpbml0PSVzIHR5cGU9JXMlcyVzIiwKKwkJcmVnX2luaXRfc3RyKGluZm8tPmluaXRpYXRvciksIHJlZ190eXBlX3N0cihpbmZvLT50eXBlKSwKKwkJaW5mby0+YWxwaGEyWzBdID8gIiBhbHBoYTI9IiA6ICIiLAorCQlpbmZvLT5hbHBoYTJbMF0gPyBpbmZvLT5hbHBoYTIgOiAiIik7CisKKwlpZiAod3BhX3MtPmRydl9wcml2ID09IE5VTEwpCisJCXJldHVybjsgLyogSWdub3JlIGV2ZW50IGR1cmluZyBkcnYgaW5pdGlhbGl6YXRpb24gKi8KKworCWZyZWVfaHdfZmVhdHVyZXMod3BhX3MpOworCXdwYV9zLT5ody5tb2RlcyA9IHdwYV9kcnZfZ2V0X2h3X2ZlYXR1cmVfZGF0YSgKKwkJd3BhX3MsICZ3cGFfcy0+aHcubnVtX21vZGVzLCAmd3BhX3MtPmh3LmZsYWdzKTsKKworCXdwYXNfcDJwX3VwZGF0ZV9jaGFubmVsX2xpc3Qod3BhX3MpOworCisJLyoKKwkgKiBDaGVjayBvdGhlciBpbnRlcmZhY2VzIHRvIHNlZSBpZiB0aGV5IHNoYXJlIHRoZSBzYW1lIHJhZGlvLiBJZgorCSAqIHNvLCB0aGV5IGdldCB1cGRhdGVkIHdpdGggdGhpcyBzYW1lIGh3IG1vZGUgaW5mby4KKwkgKi8KKwlkbF9saXN0X2Zvcl9lYWNoKGlmcywgJndwYV9zLT5yYWRpby0+aWZhY2VzLCBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQsCisJCQkgcmFkaW9fbGlzdCkgeworCQlpZiAoaWZzICE9IHdwYV9zKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBVcGRhdGluZyBodyBtb2RlIiwKKwkJCQkgICBpZnMtPmlmbmFtZSk7CisJCQlmcmVlX2h3X2ZlYXR1cmVzKGlmcyk7CisJCQlpZnMtPmh3Lm1vZGVzID0gd3BhX2Rydl9nZXRfaHdfZmVhdHVyZV9kYXRhKAorCQkJCWlmcywgJmlmcy0+aHcubnVtX21vZGVzLCAmaWZzLT5ody5mbGFncyk7CisJCX0KKwl9Cit9CisKKworc3RhdGljIHZvaWQgd3Bhc19ldmVudF9yeF9tZ210X2FjdGlvbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgIGNvbnN0IHU4ICpmcmFtZSwgc2l6ZV90IGxlbiwgaW50IGZyZXEpCit7CisJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210OworCWNvbnN0IHU4ICpwYXlsb2FkOworCXNpemVfdCBwbGVuOworCXU4IGNhdGVnb3J5OworCisJaWYgKGxlbiA8IElFRUU4MDIxMV9IRFJMRU4gKyAyKQorCQlyZXR1cm47CisKKwltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBmcmFtZTsKKwlwYXlsb2FkID0gZnJhbWUgKyBJRUVFODAyMTFfSERSTEVOOworCWNhdGVnb3J5ID0gKnBheWxvYWQrKzsKKwlwbGVuID0gbGVuIC0gSUVFRTgwMjExX0hEUkxFTiAtIDE7CisKKwl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJSZWNlaXZlZCBBY3Rpb24gZnJhbWU6IFNBPSIgTUFDU1RSCisJCSIgQ2F0ZWdvcnk9JXUgRGF0YUxlbj0lZCBmcmVxPSVkIE1IeiIsCisJCU1BQzJTVFIobWdtdC0+c2EpLCBjYXRlZ29yeSwgKGludCkgcGxlbiwgZnJlcSk7CisKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgorCWlmIChjYXRlZ29yeSA9PSBXTEFOX0FDVElPTl9GVCkgeworCQlmdF9yeF9hY3Rpb24od3BhX3MsIHBheWxvYWQsIHBsZW4pOworCQlyZXR1cm47CisJfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCisKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExVworI2lmZGVmIENPTkZJR19TTUUKKwlpZiAoY2F0ZWdvcnkgPT0gV0xBTl9BQ1RJT05fU0FfUVVFUlkpIHsKKwkJc21lX3NhX3F1ZXJ5X3J4KHdwYV9zLCBtZ210LT5zYSwgcGF5bG9hZCwgcGxlbik7CisJCXJldHVybjsKKwl9CisjZW5kaWYgLyogQ09ORklHX1NNRSAqLworI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCisKKyNpZmRlZiBDT05GSUdfV05NCisJaWYgKG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ID09IFdMQU5fQUNUSU9OX1dOTSkgeworCQlpZWVlODAyXzExX3J4X3dubV9hY3Rpb24od3BhX3MsIG1nbXQsIGxlbik7CisJCXJldHVybjsKKwl9CisjZW5kaWYgLyogQ09ORklHX1dOTSAqLworCisjaWZkZWYgQ09ORklHX0dBUworCWlmICgobWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgPT0gV0xBTl9BQ1RJT05fUFVCTElDIHx8CisJICAgICBtZ210LT51LmFjdGlvbi5jYXRlZ29yeSA9PSBXTEFOX0FDVElPTl9QUk9URUNURURfRFVBTCkgJiYKKwkgICAgZ2FzX3F1ZXJ5X3J4KHdwYV9zLT5nYXMsIG1nbXQtPmRhLCBtZ210LT5zYSwgbWdtdC0+YnNzaWQsCisJCQkgbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnksCisJCQkgcGF5bG9hZCwgcGxlbiwgZnJlcSkgPT0gMCkKKwkJcmV0dXJuOworI2VuZGlmIC8qIENPTkZJR19HQVMgKi8KKworI2lmZGVmIENPTkZJR19URExTCisJaWYgKGNhdGVnb3J5ID09IFdMQU5fQUNUSU9OX1BVQkxJQyAmJiBwbGVuID49IDQgJiYKKwkgICAgcGF5bG9hZFswXSA9PSBXTEFOX1RETFNfRElTQ09WRVJZX1JFU1BPTlNFKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywKKwkJCSJURExTOiBSZWNlaXZlZCBEaXNjb3ZlcnkgUmVzcG9uc2UgZnJvbSAiIE1BQ1NUUiwKKwkJCU1BQzJTVFIobWdtdC0+c2EpKTsKKwkJcmV0dXJuOworCX0KKyNlbmRpZiAvKiBDT05GSUdfVERMUyAqLworCisjaWZkZWYgQ09ORklHX0lOVEVSV09SS0lORworCWlmIChjYXRlZ29yeSA9PSBXTEFOX0FDVElPTl9RT1MgJiYgcGxlbiA+PSAxICYmCisJICAgIHBheWxvYWRbMF0gPT0gUU9TX1FPU19NQVBfQ09ORklHKSB7CisJCWNvbnN0IHU4ICpwb3MgPSBwYXlsb2FkICsgMTsKKwkJc2l6ZV90IHFsZW4gPSBwbGVuIC0gMTsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBSZWNlaXZlZCBRb1MgTWFwIENvbmZpZ3VyZSBmcmFtZSBmcm9tICIKKwkJCU1BQ1NUUiwgTUFDMlNUUihtZ210LT5zYSkpOworCQlpZiAob3NfbWVtY21wKG1nbXQtPnNhLCB3cGFfcy0+YnNzaWQsIEVUSF9BTEVOKSA9PSAwICYmCisJCSAgICBxbGVuID4gMiAmJiBwb3NbMF0gPT0gV0xBTl9FSURfUU9TX01BUF9TRVQgJiYKKwkJICAgIHBvc1sxXSA8PSBxbGVuIC0gMiAmJiBwb3NbMV0gPj0gMTYpCisJCQl3cGFzX3Fvc19tYXBfc2V0KHdwYV9zLCBwb3MgKyAyLCBwb3NbMV0pOworCQlyZXR1cm47CisJfQorI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KKworCXdwYXNfcDJwX3J4X2FjdGlvbih3cGFfcywgbWdtdC0+ZGEsIG1nbXQtPnNhLCBtZ210LT5ic3NpZCwKKwkJCSAgIGNhdGVnb3J5LCBwYXlsb2FkLCBwbGVuLCBmcmVxKTsKK30KKworCitzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9ub3RpZnlfYXZvaWRfZnJlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgIHVuaW9uIHdwYV9ldmVudF9kYXRhICpldmVudCkKK3sKKyNpZmRlZiBDT05GSUdfUDJQCisJc3RydWN0IHdwYV9zdXBwbGljYW50ICppZnM7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCXN0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0ICpsaXN0OworCWNoYXIgKnN0ciA9IE5VTEw7CisKKwlsaXN0ID0gJmV2ZW50LT5mcmVxX3JhbmdlOworCisJaWYgKGxpc3QtPm51bSkKKwkJc3RyID0gZnJlcV9yYW5nZV9saXN0X3N0cihsaXN0KTsKKwl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX0FWT0lEX0ZSRVEgInJhbmdlcz0lcyIsCisJCXN0ciA/IHN0ciA6ICIiKTsKKworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAoZnJlcV9yYW5nZV9saXN0X3BhcnNlKCZ3cGFfcy0+Z2xvYmFsLT5wMnBfZ29fYXZvaWRfZnJlcSwgc3RyKSkgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfRVJST1IsICIlczogRmFpbGVkIHRvIHBhcnNlIGZyZXEgcmFuZ2UiLAorCQkJX19mdW5jX18pOworCX0gZWxzZSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlAyUDogVXBkYXRlIGNoYW5uZWwgbGlzdCBiYXNlZCBvbiBmcmVxdWVuY3kgYXZvaWQgZXZlbnQiKTsKKwkJd3Bhc19wMnBfdXBkYXRlX2NoYW5uZWxfbGlzdCh3cGFfcyk7CisJfQorCisJZm9yIChpZnMgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IGlmczsgaWZzID0gaWZzLT5uZXh0KSB7CisJCWludCBmcmVxOworCQlpZiAoIWlmcy0+Y3VycmVudF9zc2lkIHx8CisJCSAgICAhaWZzLT5jdXJyZW50X3NzaWQtPnAycF9ncm91cCB8fAorCQkgICAgKGlmcy0+Y3VycmVudF9zc2lkLT5tb2RlICE9IFdQQVNfTU9ERV9QMlBfR08gJiYKKwkJICAgICBpZnMtPmN1cnJlbnRfc3NpZC0+bW9kZSAhPSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTikpCisJCQljb250aW51ZTsKKworCQlmcmVxID0gaWZzLT5jdXJyZW50X3NzaWQtPmZyZXF1ZW5jeTsKKwkJaWYgKCFmcmVxX3JhbmdlX2xpc3RfaW5jbHVkZXMobGlzdCwgZnJlcSkpIHsKKwkJCXdwYV9kYmcoaWZzLCBNU0dfREVCVUcsICJQMlAgR08gb3BlcmF0aW5nIGZyZXF1ZW5jeSAlZCBNSHogaW4gc2FmZSByYW5nZSIsCisJCQkJZnJlcSk7CisJCQljb250aW51ZTsKKwkJfQorCisJCXdwYV9kYmcoaWZzLCBNU0dfREVCVUcsICJQMlAgR08gb3BlcmF0aW5nIGluIHVuc2FmZSBmcmVxdWVuY3kgJWQgTUh6IiwKKwkJCWZyZXEpOworCQkvKiBUT0RPOiBDb25zaWRlciB1c2luZyBDU0Egb3IgcmVtb3ZpbmcgdGhlIGdyb3VwIHdpdGhpbgorCQkgKiB3cGFfc3VwcGxpY2FudCAqLworCQl3cGFfbXNnKGlmcywgTVNHX0lORk8sIFAyUF9FVkVOVF9SRU1PVkVfQU5EX1JFRk9STV9HUk9VUCk7CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCW9zX2ZyZWUoc3RyKTsKK30KKworCiB2b2lkIHdwYV9zdXBwbGljYW50X2V2ZW50KHZvaWQgKmN0eCwgZW51bSB3cGFfZXZlbnRfdHlwZSBldmVudCwKIAkJCSAgdW5pb24gd3BhX2V2ZW50X2RhdGEgKmRhdGEpCiB7CkBAIC0yNjQ0LDExICsyOTg1LDQ0IEBACiAJCXdwYV9zdXBwbGljYW50X2V2ZW50X21pY2hhZWxfbWljX2ZhaWx1cmUod3BhX3MsIGRhdGEpOwogCQlicmVhazsKICNpZm5kZWYgQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORworCWNhc2UgRVZFTlRfU0NBTl9TVEFSVEVEOgorCQlvc19nZXRfcmVsdGltZSgmd3BhX3MtPnNjYW5fc3RhcnRfdGltZSk7CisJCWlmICh3cGFfcy0+b3duX3NjYW5fcmVxdWVzdGVkKSB7CisJCQlzdHJ1Y3Qgb3NfcmVsdGltZSBkaWZmOworCisJCQlvc19yZWx0aW1lX3N1Yigmd3BhX3MtPnNjYW5fc3RhcnRfdGltZSwKKwkJCQkgICAgICAgJndwYV9zLT5zY2FuX3RyaWdnZXJfdGltZSwgJmRpZmYpOworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiT3duIHNjYW4gcmVxdWVzdCBzdGFydGVkIGEgc2NhbiBpbiAlbGQuJTA2bGQgc2Vjb25kcyIsCisJCQkJZGlmZi5zZWMsIGRpZmYudXNlYyk7CisJCQl3cGFfcy0+b3duX3NjYW5fcmVxdWVzdGVkID0gMDsKKwkJCXdwYV9zLT5vd25fc2Nhbl9ydW5uaW5nID0gMTsKKwkJCWlmICh3cGFfcy0+bGFzdF9zY2FuX3JlcSA9PSBNQU5VQUxfU0NBTl9SRVEgJiYKKwkJCSAgICB3cGFfcy0+bWFudWFsX3NjYW5fdXNlX2lkKSB7CisJCQkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIFdQQV9FVkVOVF9TQ0FOX1NUQVJURUQgImlkPSV1IiwKKwkJCQkJd3BhX3MtPm1hbnVhbF9zY2FuX2lkKTsKKwkJCX0gZWxzZSB7CisJCQkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIFdQQV9FVkVOVF9TQ0FOX1NUQVJURUQpOworCQkJfQorCQl9IGVsc2UgeworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiRXh0ZXJuYWwgcHJvZ3JhbSBzdGFydGVkIGEgc2NhbiIpOworCQkJd3BhX3MtPmV4dGVybmFsX3NjYW5fcnVubmluZyA9IDE7CisJCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX1NDQU5fU1RBUlRFRCk7CisJCX0KKwkJYnJlYWs7CiAJY2FzZSBFVkVOVF9TQ0FOX1JFU1VMVFM6CisJCWlmIChvc19yZWx0aW1lX2luaXRpYWxpemVkKCZ3cGFfcy0+c2Nhbl9zdGFydF90aW1lKSkgeworCQkJc3RydWN0IG9zX3JlbHRpbWUgbm93LCBkaWZmOworCQkJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CisJCQlvc19yZWx0aW1lX3N1Yigmbm93LCAmd3BhX3MtPnNjYW5fc3RhcnRfdGltZSwgJmRpZmYpOworCQkJd3BhX3MtPnNjYW5fc3RhcnRfdGltZS5zZWMgPSAwOworCQkJd3BhX3MtPnNjYW5fc3RhcnRfdGltZS51c2VjID0gMDsKKwkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlNjYW4gY29tcGxldGVkIGluICVsZC4lMDZsZCBzZWNvbmRzIiwKKwkJCQlkaWZmLnNlYywgZGlmZi51c2VjKTsKKwkJfQogCQl3cGFfc3VwcGxpY2FudF9ldmVudF9zY2FuX3Jlc3VsdHMod3BhX3MsIGRhdGEpOwotCQlpZiAod3BhX3MtPndwYV9zdGF0ZSAhPSBXUEFfQVVUSEVOVElDQVRJTkcgJiYKLQkJICAgIHdwYV9zLT53cGFfc3RhdGUgIT0gV1BBX0FTU09DSUFUSU5HKQotCQkJd3Bhc19wMnBfY29udGludWVfYWZ0ZXJfc2Nhbih3cGFfcyk7CisJCXdwYV9zLT5vd25fc2Nhbl9ydW5uaW5nID0gMDsKKwkJd3BhX3MtPmV4dGVybmFsX3NjYW5fcnVubmluZyA9IDA7CisJCXJhZGlvX3dvcmtfY2hlY2tfbmV4dCh3cGFfcyk7CiAJCWJyZWFrOwogI2VuZGlmIC8qIENPTkZJR19OT19TQ0FOX1BST0NFU1NJTkcgKi8KIAljYXNlIEVWRU5UX0FTU09DSU5GTzoKQEAgLTI2OTgsNTIgKzMwNzIsMTEgQEAKIAkJaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1NNRSkKIAkJCXNtZV9ldmVudF9hc3NvY19yZWplY3Qod3BhX3MsIGRhdGEpOwogCQllbHNlIHsKLSNpZmRlZiBBTkRST0lEX1AyUAotCQkJaWYoIXdwYV9zLT5jdXJyZW50X3NzaWQpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImN1cnJlbnRfc3NpZCA9PSBOVUxMIik7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCQkvKiBJZiBhc3NvYyByZWplY3QgaXMgcmVwb3J0ZWQgYnkgdGhlIGRyaXZlciwgdGhlbiBhdm9pZAotCQkJICogd2FpdGluZyBmb3IgIHRoZSBhdXRoZW50aWNhdGlvbiB0aW1lb3V0LiBDYW5jZWwgdGhlCi0JCQkgKiBhdXRoZW50aWNhdGlvbiB0aW1lb3V0IGFuZCByZXRyeSB0aGUgYXNzb2MuCi0JCQkgKi8KLQkJCWlmKHdwYV9zLT5jdXJyZW50X3NzaWQtPmFzc29jX3JldHJ5KysgPCAxMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUmV0cnlpbmcgYXNzb2M6ICVkICIsCi0JCQkJCQkJCXdwYV9zLT5jdXJyZW50X3NzaWQtPmFzc29jX3JldHJ5KTsKLQotCQkJCXdwYV9zdXBwbGljYW50X2NhbmNlbF9hdXRoX3RpbWVvdXQod3BhX3MpOwotCi0JCQkJLyogQ2xlYXIgdGhlIHN0YXRlcyAqLwotCQkJCXdwYV9zbV9ub3RpZnlfZGlzYXNzb2Mod3BhX3MtPndwYSk7Ci0JCQkJd3BhX3N1cHBsaWNhbnRfZGVhdXRoZW50aWNhdGUod3BhX3MsIFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HKTsKLQotCQkJCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7Ci0JCQkJaWYgKHdwYV9zLT5wMnBfZ3JvdXBfaW50ZXJmYWNlID09IE5PVF9QMlBfR1JPVVBfSU5URVJGQUNFKSB7Ci0JCQkJCWNvbnN0IHU4ICpibF9ic3NpZCA9IGRhdGEtPmFzc29jX3JlamVjdC5ic3NpZDsKLQkJCQkJaWYgKCFibF9ic3NpZCB8fCBpc196ZXJvX2V0aGVyX2FkZHIoYmxfYnNzaWQpKQotCQkJCQkJYmxfYnNzaWQgPSB3cGFfcy0+cGVuZGluZ19ic3NpZDsKLQkJCQkJd3BhX2JsYWNrbGlzdF9hZGQod3BhX3MsIGJsX2Jzc2lkKTsKLQkJCQkJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDAsIDApOwotCQkJCX0gZWxzZSB7Ci0JCQkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAxLCAwKTsKLQkJCQl9Ci0JCQl9IGVsc2UgaWYgKHdwYV9zLT5wMnBfZ3JvdXBfaW50ZXJmYWNlICE9IE5PVF9QMlBfR1JPVVBfSU5URVJGQUNFKSB7Ci0JCQkJLyogSWYgd2UgQVNTT0NfUkVKRUNUJ3MgaGl0cyB0aHJlc2hvbGQsIGRpc2FibGUgdGhlIAotCQkJIAkgKiBuZXR3b3JrCi0JCQkgCSAqLwotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQXNzb2MgcmV0cnkgdGhyZXNob2xkIHJlYWNoZWQuICIKLQkJCQkiRGlzYWJsaW5nIHRoZSBuZXR3b3JrIik7Ci0JCQkJd3BhX3MtPmN1cnJlbnRfc3NpZC0+YXNzb2NfcmV0cnkgPSAwOwotCQkJCXdwYV9zdXBwbGljYW50X2Rpc2FibGVfbmV0d29yayh3cGFfcywgd3BhX3MtPmN1cnJlbnRfc3NpZCk7Ci0JCQkJd3Bhc19wMnBfZ3JvdXBfcmVtb3ZlKHdwYV9zLCB3cGFfcy0+aWZuYW1lKTsKLQkJCX0KLSNlbHNlCiAJCQljb25zdCB1OCAqYnNzaWQgPSBkYXRhLT5hc3NvY19yZWplY3QuYnNzaWQ7CiAJCQlpZiAoYnNzaWQgPT0gTlVMTCB8fCBpc196ZXJvX2V0aGVyX2FkZHIoYnNzaWQpKQogCQkJCWJzc2lkID0gd3BhX3MtPnBlbmRpbmdfYnNzaWQ7CiAJCQl3cGFzX2Nvbm5lY3Rpb25fZmFpbGVkKHdwYV9zLCBic3NpZCk7CiAJCQl3cGFfc3VwcGxpY2FudF9tYXJrX2Rpc2Fzc29jKHdwYV9zKTsKLSNlbmRpZiAvKiBBTkRST0lEX1AyUCAqLwogCQl9CiAJCWJyZWFrOwogCWNhc2UgRVZFTlRfQVVUSF9USU1FRF9PVVQ6CkBAIC0yODQwLDE0ICszMTczLDMzIEBACiAKIAkJd3Bhc19hcF9jaF9zd2l0Y2god3BhX3MsIGRhdGEtPmNoX3N3aXRjaC5mcmVxLAogCQkJCSAgZGF0YS0+Y2hfc3dpdGNoLmh0X2VuYWJsZWQsCi0JCQkJICBkYXRhLT5jaF9zd2l0Y2guY2hfb2Zmc2V0KTsKKwkJCQkgIGRhdGEtPmNoX3N3aXRjaC5jaF9vZmZzZXQsCisJCQkJICBkYXRhLT5jaF9zd2l0Y2guY2hfd2lkdGgsCisJCQkJICBkYXRhLT5jaF9zd2l0Y2guY2YxLAorCQkJCSAgZGF0YS0+Y2hfc3dpdGNoLmNmMik7CiAJCWJyZWFrOwogI2VuZGlmIC8qIENPTkZJR19BUCAqLwotI2lmIGRlZmluZWQoQ09ORklHX0FQKSB8fCBkZWZpbmVkKENPTkZJR19JQlNTX1JTTikKIAljYXNlIEVWRU5UX1JYX01HTVQ6IHsKIAkJdTE2IGZjLCBzdHlwZTsKIAkJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210OwogCisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUworCQlpZiAod3BhX3MtPmV4dF9tZ210X2ZyYW1lX2hhbmRsaW5nKSB7CisJCQlzdHJ1Y3QgcnhfbWdtdCAqcnggPSAmZGF0YS0+cnhfbWdtdDsKKwkJCXNpemVfdCBoZXhfbGVuID0gMiAqIHJ4LT5mcmFtZV9sZW4gKyAxOworCQkJY2hhciAqaGV4ID0gb3NfbWFsbG9jKGhleF9sZW4pOworCQkJaWYgKGhleCkgeworCQkJCXdwYV9zbnByaW50Zl9oZXgoaGV4LCBoZXhfbGVuLAorCQkJCQkJIHJ4LT5mcmFtZSwgcngtPmZyYW1lX2xlbik7CisJCQkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sICJNR01ULVJYIGZyZXE9JWQgZGF0YXJhdGU9JXUgc3NpX3NpZ25hbD0lZCAlcyIsCisJCQkJCXJ4LT5mcmVxLCByeC0+ZGF0YXJhdGUsIHJ4LT5zc2lfc2lnbmFsLAorCQkJCQloZXgpOworCQkJCW9zX2ZyZWUoaGV4KTsKKwkJCX0KKwkJCWJyZWFrOworCQl9CisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLworCiAJCW1nbXQgPSAoY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICopCiAJCQlkYXRhLT5yeF9tZ210LmZyYW1lOwogCQlmYyA9IGxlX3RvX2hvc3QxNihtZ210LT5mcmFtZV9jb250cm9sKTsKQEAgLTI4NzgsNiArMzIzMCwxNSBAQAogCQkJCWJyZWFrOwogCQkJfQogI2VuZGlmIC8qIENPTkZJR19JQlNTX1JTTiAqLworCisJCQlpZiAoc3R5cGUgPT0gV0xBTl9GQ19TVFlQRV9BQ1RJT04pIHsKKwkJCQl3cGFzX2V2ZW50X3J4X21nbXRfYWN0aW9uKAorCQkJCQl3cGFfcywgZGF0YS0+cnhfbWdtdC5mcmFtZSwKKwkJCQkJZGF0YS0+cnhfbWdtdC5mcmFtZV9sZW4sCisJCQkJCWRhdGEtPnJ4X21nbXQuZnJlcSk7CisJCQkJYnJlYWs7CisJCQl9CisKIAkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkFQOiBpZ25vcmUgcmVjZWl2ZWQgIgogCQkJCSJtYW5hZ2VtZW50IGZyYW1lIGluIG5vbi1BUCBtb2RlIik7CiAJCQlicmVhazsKQEAgLTI5MDAsNjMgKzMyNjEsNiBAQAogI2VuZGlmIC8qIENPTkZJR19BUCAqLwogCQlicmVhazsKIAkJfQotI2VuZGlmIC8qIENPTkZJR19BUCB8fCBDT05GSUdfSUJTU19SU04gKi8KLQljYXNlIEVWRU5UX1JYX0FDVElPTjoKLQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUmVjZWl2ZWQgQWN0aW9uIGZyYW1lOiBTQT0iIE1BQ1NUUgotCQkJIiBDYXRlZ29yeT0ldSBEYXRhTGVuPSVkIGZyZXE9JWQgTUh6IiwKLQkJCU1BQzJTVFIoZGF0YS0+cnhfYWN0aW9uLnNhKSwKLQkJCWRhdGEtPnJ4X2FjdGlvbi5jYXRlZ29yeSwgKGludCkgZGF0YS0+cnhfYWN0aW9uLmxlbiwKLQkJCWRhdGEtPnJ4X2FjdGlvbi5mcmVxKTsKLSNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgotCQlpZiAoZGF0YS0+cnhfYWN0aW9uLmNhdGVnb3J5ID09IFdMQU5fQUNUSU9OX0ZUKSB7Ci0JCQlmdF9yeF9hY3Rpb24od3BhX3MsIGRhdGEtPnJ4X2FjdGlvbi5kYXRhLAotCQkJCSAgICAgZGF0YS0+cnhfYWN0aW9uLmxlbik7Ci0JCQlicmVhazsKLQkJfQotI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCi0jaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKLSNpZmRlZiBDT05GSUdfU01FCi0JCWlmIChkYXRhLT5yeF9hY3Rpb24uY2F0ZWdvcnkgPT0gV0xBTl9BQ1RJT05fU0FfUVVFUlkpIHsKLQkJCXNtZV9zYV9xdWVyeV9yeCh3cGFfcywgZGF0YS0+cnhfYWN0aW9uLnNhLAotCQkJCQlkYXRhLT5yeF9hY3Rpb24uZGF0YSwKLQkJCQkJZGF0YS0+cnhfYWN0aW9uLmxlbik7Ci0JCQlicmVhazsKLQkJfQotI2VuZGlmIC8qIENPTkZJR19TTUUgKi8KLSNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwotI2lmZGVmIENPTkZJR19XTk0KLQkJaWYgKGRhdGEtPnJ4X2FjdGlvbi5jYXRlZ29yeSA9PSBXTEFOX0FDVElPTl9XTk0pIHsKLQkJCWllZWU4MDJfMTFfcnhfd25tX2FjdGlvbih3cGFfcywgJmRhdGEtPnJ4X2FjdGlvbik7Ci0JCQlicmVhazsKLQkJfQotI2VuZGlmIC8qIENPTkZJR19XTk0gKi8KLSNpZmRlZiBDT05GSUdfR0FTCi0JCWlmIChkYXRhLT5yeF9hY3Rpb24uY2F0ZWdvcnkgPT0gV0xBTl9BQ1RJT05fUFVCTElDICYmCi0JCSAgICBnYXNfcXVlcnlfcngod3BhX3MtPmdhcywgZGF0YS0+cnhfYWN0aW9uLmRhLAotCQkJCSBkYXRhLT5yeF9hY3Rpb24uc2EsIGRhdGEtPnJ4X2FjdGlvbi5ic3NpZCwKLQkJCQkgZGF0YS0+cnhfYWN0aW9uLmRhdGEsIGRhdGEtPnJ4X2FjdGlvbi5sZW4sCi0JCQkJIGRhdGEtPnJ4X2FjdGlvbi5mcmVxKSA9PSAwKQotCQkJYnJlYWs7Ci0jZW5kaWYgLyogQ09ORklHX0dBUyAqLwotI2lmZGVmIENPTkZJR19URExTCi0JCWlmIChkYXRhLT5yeF9hY3Rpb24uY2F0ZWdvcnkgPT0gV0xBTl9BQ1RJT05fUFVCTElDICYmCi0JCSAgICBkYXRhLT5yeF9hY3Rpb24ubGVuID49IDQgJiYKLQkJICAgIGRhdGEtPnJ4X2FjdGlvbi5kYXRhWzBdID09IFdMQU5fVERMU19ESVNDT1ZFUllfUkVTUE9OU0UpIHsKLQkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlRETFM6IFJlY2VpdmVkIERpc2NvdmVyeSAiCi0JCQkJIlJlc3BvbnNlIGZyb20gIiBNQUNTVFIsCi0JCQkJTUFDMlNUUihkYXRhLT5yeF9hY3Rpb24uc2EpKTsKLQkJCWJyZWFrOwotCQl9Ci0jZW5kaWYgLyogQ09ORklHX1RETFMgKi8KLSNpZmRlZiBDT05GSUdfUDJQCi0JCXdwYXNfcDJwX3J4X2FjdGlvbih3cGFfcywgZGF0YS0+cnhfYWN0aW9uLmRhLAotCQkJCSAgIGRhdGEtPnJ4X2FjdGlvbi5zYSwKLQkJCQkgICBkYXRhLT5yeF9hY3Rpb24uYnNzaWQsCi0JCQkJICAgZGF0YS0+cnhfYWN0aW9uLmNhdGVnb3J5LAotCQkJCSAgIGRhdGEtPnJ4X2FjdGlvbi5kYXRhLAotCQkJCSAgIGRhdGEtPnJ4X2FjdGlvbi5sZW4sIGRhdGEtPnJ4X2FjdGlvbi5mcmVxKTsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCi0JCWJyZWFrOwogCWNhc2UgRVZFTlRfUlhfUFJPQkVfUkVROgogCQlpZiAoZGF0YS0+cnhfcHJvYmVfcmVxLnNhID09IE5VTEwgfHwKIAkJICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZSA9PSBOVUxMKQpAQCAtMjk3MywxNCArMzI3NywxMiBAQAogCQkJYnJlYWs7CiAJCX0KICNlbmRpZiAvKiBDT05GSUdfQVAgKi8KLSNpZmRlZiBDT05GSUdfUDJQCiAJCXdwYXNfcDJwX3Byb2JlX3JlcV9yeCh3cGFfcywgZGF0YS0+cnhfcHJvYmVfcmVxLnNhLAogCQkJCSAgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5kYSwKIAkJCQkgICAgICBkYXRhLT5yeF9wcm9iZV9yZXEuYnNzaWQsCiAJCQkJICAgICAgZGF0YS0+cnhfcHJvYmVfcmVxLmllLAogCQkJCSAgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZV9sZW4sCiAJCQkJICAgICAgZGF0YS0+cnhfcHJvYmVfcmVxLnNzaV9zaWduYWwpOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9SRU1BSU5fT05fQ0hBTk5FTDoKICNpZmRlZiBDT05GSUdfT0ZGQ0hBTk5FTApAQCAtMjk4OCw5MyArMzI5MCwzMCBAQAogCQkJd3BhX3MsIGRhdGEtPnJlbWFpbl9vbl9jaGFubmVsLmZyZXEsCiAJCQlkYXRhLT5yZW1haW5fb25fY2hhbm5lbC5kdXJhdGlvbik7CiAjZW5kaWYgLyogQ09ORklHX09GRkNIQU5ORUwgKi8KLSNpZmRlZiBDT05GSUdfUDJQCiAJCXdwYXNfcDJwX3JlbWFpbl9vbl9jaGFubmVsX2NiKAogCQkJd3BhX3MsIGRhdGEtPnJlbWFpbl9vbl9jaGFubmVsLmZyZXEsCiAJCQlkYXRhLT5yZW1haW5fb25fY2hhbm5lbC5kdXJhdGlvbik7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCQlicmVhazsKIAljYXNlIEVWRU5UX0NBTkNFTF9SRU1BSU5fT05fQ0hBTk5FTDoKICNpZmRlZiBDT05GSUdfT0ZGQ0hBTk5FTAogCQlvZmZjaGFubmVsX2NhbmNlbF9yZW1haW5fb25fY2hhbm5lbF9jYigKIAkJCXdwYV9zLCBkYXRhLT5yZW1haW5fb25fY2hhbm5lbC5mcmVxKTsKICNlbmRpZiAvKiBDT05GSUdfT0ZGQ0hBTk5FTCAqLwotI2lmZGVmIENPTkZJR19QMlAKIAkJd3Bhc19wMnBfY2FuY2VsX3JlbWFpbl9vbl9jaGFubmVsX2NiKAogCQkJd3BhX3MsIGRhdGEtPnJlbWFpbl9vbl9jaGFubmVsLmZyZXEpOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJYnJlYWs7Ci0jaWZkZWYgQ09ORklHX1AyUAotCWNhc2UgRVZFTlRfUDJQX0RFVl9GT1VORDogewotCQlzdHJ1Y3QgcDJwX3BlZXJfaW5mbyBwZWVyX2luZm87Ci0KLQkJb3NfbWVtc2V0KCZwZWVyX2luZm8sIDAsIHNpemVvZihwZWVyX2luZm8pKTsKLQkJaWYgKGRhdGEtPnAycF9kZXZfZm91bmQuZGV2X2FkZHIpCi0JCQlvc19tZW1jcHkocGVlcl9pbmZvLnAycF9kZXZpY2VfYWRkciwKLQkJCQkgIGRhdGEtPnAycF9kZXZfZm91bmQuZGV2X2FkZHIsIEVUSF9BTEVOKTsKLQkJaWYgKGRhdGEtPnAycF9kZXZfZm91bmQucHJpX2Rldl90eXBlKQotCQkJb3NfbWVtY3B5KHBlZXJfaW5mby5wcmlfZGV2X3R5cGUsCi0JCQkJICBkYXRhLT5wMnBfZGV2X2ZvdW5kLnByaV9kZXZfdHlwZSwKLQkJCQkgIHNpemVvZihwZWVyX2luZm8ucHJpX2Rldl90eXBlKSk7Ci0JCWlmIChkYXRhLT5wMnBfZGV2X2ZvdW5kLmRldl9uYW1lKQotCQkJb3Nfc3RybGNweShwZWVyX2luZm8uZGV2aWNlX25hbWUsCi0JCQkJICAgZGF0YS0+cDJwX2Rldl9mb3VuZC5kZXZfbmFtZSwKLQkJCQkgICBzaXplb2YocGVlcl9pbmZvLmRldmljZV9uYW1lKSk7Ci0JCXBlZXJfaW5mby5jb25maWdfbWV0aG9kcyA9IGRhdGEtPnAycF9kZXZfZm91bmQuY29uZmlnX21ldGhvZHM7Ci0JCXBlZXJfaW5mby5kZXZfY2FwYWIgPSBkYXRhLT5wMnBfZGV2X2ZvdW5kLmRldl9jYXBhYjsKLQkJcGVlcl9pbmZvLmdyb3VwX2NhcGFiID0gZGF0YS0+cDJwX2Rldl9mb3VuZC5ncm91cF9jYXBhYjsKLQotCQkvKgotCQkgKiBGSVg6IG5ld19kZXZpY2U9MSBpcyBub3QgbmVjZXNzYXJpbHkgY29ycmVjdC4gV2Ugc2hvdWxkCi0JCSAqIG1haW50YWluIGEgUDJQIHBlZXIgZGF0YWJhc2UgaW4gd3BhX3N1cHBsaWNhbnQgYW5kIHVwZGF0ZQotCQkgKiB0aGlzIGluZm9ybWF0aW9uIGJhc2VkIG9uIHdoZXRoZXIgdGhlIHBlZXIgaXMgdHJ1bHkgbmV3LgotCQkgKi8KLQkJd3Bhc19kZXZfZm91bmQod3BhX3MsIGRhdGEtPnAycF9kZXZfZm91bmQuYWRkciwgJnBlZXJfaW5mbywgMSk7Ci0JCWJyZWFrOwotCQl9Ci0JY2FzZSBFVkVOVF9QMlBfR09fTkVHX1JFUV9SWDoKLQkJd3Bhc19nb19uZWdfcmVxX3J4KHdwYV9zLCBkYXRhLT5wMnBfZ29fbmVnX3JlcV9yeC5zcmMsCi0JCQkJICAgZGF0YS0+cDJwX2dvX25lZ19yZXFfcnguZGV2X3Bhc3N3ZF9pZCk7Ci0JCWJyZWFrOwotCWNhc2UgRVZFTlRfUDJQX0dPX05FR19DT01QTEVURUQ6Ci0JCXdwYXNfZ29fbmVnX2NvbXBsZXRlZCh3cGFfcywgZGF0YS0+cDJwX2dvX25lZ19jb21wbGV0ZWQucmVzKTsKLQkJYnJlYWs7Ci0JY2FzZSBFVkVOVF9QMlBfUFJPVl9ESVNDX1JFUVVFU1Q6Ci0JCXdwYXNfcHJvdl9kaXNjX3JlcSh3cGFfcywgZGF0YS0+cDJwX3Byb3ZfZGlzY19yZXEucGVlciwKLQkJCQkgICBkYXRhLT5wMnBfcHJvdl9kaXNjX3JlcS5jb25maWdfbWV0aG9kcywKLQkJCQkgICBkYXRhLT5wMnBfcHJvdl9kaXNjX3JlcS5kZXZfYWRkciwKLQkJCQkgICBkYXRhLT5wMnBfcHJvdl9kaXNjX3JlcS5wcmlfZGV2X3R5cGUsCi0JCQkJICAgZGF0YS0+cDJwX3Byb3ZfZGlzY19yZXEuZGV2X25hbWUsCi0JCQkJICAgZGF0YS0+cDJwX3Byb3ZfZGlzY19yZXEuc3VwcF9jb25maWdfbWV0aG9kcywKLQkJCQkgICBkYXRhLT5wMnBfcHJvdl9kaXNjX3JlcS5kZXZfY2FwYWIsCi0JCQkJICAgZGF0YS0+cDJwX3Byb3ZfZGlzY19yZXEuZ3JvdXBfY2FwYWIsCi0JCQkJICAgTlVMTCwgMCk7Ci0JCWJyZWFrOwotCWNhc2UgRVZFTlRfUDJQX1BST1ZfRElTQ19SRVNQT05TRToKLQkJd3Bhc19wcm92X2Rpc2NfcmVzcCh3cGFfcywgZGF0YS0+cDJwX3Byb3ZfZGlzY19yZXNwLnBlZXIsCi0JCQkJICAgIGRhdGEtPnAycF9wcm92X2Rpc2NfcmVzcC5jb25maWdfbWV0aG9kcyk7Ci0JCWJyZWFrOwotCWNhc2UgRVZFTlRfUDJQX1NEX1JFUVVFU1Q6Ci0JCXdwYXNfc2RfcmVxdWVzdCh3cGFfcywgZGF0YS0+cDJwX3NkX3JlcS5mcmVxLAotCQkJCWRhdGEtPnAycF9zZF9yZXEuc2EsCi0JCQkJZGF0YS0+cDJwX3NkX3JlcS5kaWFsb2dfdG9rZW4sCi0JCQkJZGF0YS0+cDJwX3NkX3JlcS51cGRhdGVfaW5kaWMsCi0JCQkJZGF0YS0+cDJwX3NkX3JlcS50bHZzLAotCQkJCWRhdGEtPnAycF9zZF9yZXEudGx2c19sZW4pOwotCQlicmVhazsKLQljYXNlIEVWRU5UX1AyUF9TRF9SRVNQT05TRToKLQkJd3Bhc19zZF9yZXNwb25zZSh3cGFfcywgZGF0YS0+cDJwX3NkX3Jlc3Auc2EsCi0JCQkJIGRhdGEtPnAycF9zZF9yZXNwLnVwZGF0ZV9pbmRpYywKLQkJCQkgZGF0YS0+cDJwX3NkX3Jlc3AudGx2cywKLQkJCQkgZGF0YS0+cDJwX3NkX3Jlc3AudGx2c19sZW4pOwotCQlicmVhazsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJY2FzZSBFVkVOVF9FQVBPTF9SWDoKIAkJd3BhX3N1cHBsaWNhbnRfcnhfZWFwb2wod3BhX3MsIGRhdGEtPmVhcG9sX3J4LnNyYywKIAkJCQkJZGF0YS0+ZWFwb2xfcnguZGF0YSwKIAkJCQkJZGF0YS0+ZWFwb2xfcnguZGF0YV9sZW4pOwogCQlicmVhazsKIAljYXNlIEVWRU5UX1NJR05BTF9DSEFOR0U6CisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfU0lHTkFMX0NIQU5HRQorCQkJImFib3ZlPSVkIHNpZ25hbD0lZCBub2lzZT0lZCB0eHJhdGU9JWQiLAorCQkJZGF0YS0+c2lnbmFsX2NoYW5nZS5hYm92ZV90aHJlc2hvbGQsCisJCQlkYXRhLT5zaWduYWxfY2hhbmdlLmN1cnJlbnRfc2lnbmFsLAorCQkJZGF0YS0+c2lnbmFsX2NoYW5nZS5jdXJyZW50X25vaXNlLAorCQkJZGF0YS0+c2lnbmFsX2NoYW5nZS5jdXJyZW50X3R4cmF0ZSk7CiAJCWJnc2Nhbl9ub3RpZnlfc2lnbmFsX2NoYW5nZSgKIAkJCXdwYV9zLCBkYXRhLT5zaWduYWxfY2hhbmdlLmFib3ZlX3RocmVzaG9sZCwKIAkJCWRhdGEtPnNpZ25hbF9jaGFuZ2UuY3VycmVudF9zaWduYWwsCkBAIC0zMDg1LDYgKzMzMjQsMTIgQEAKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiSW50ZXJmYWNlIHdhcyBlbmFibGVkIik7CiAJCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpIHsKIAkJCXdwYV9zdXBwbGljYW50X3VwZGF0ZV9tYWNfYWRkcih3cGFfcyk7CisJCQlpZiAod3BhX3MtPnAycF9tZ210KSB7CisJCQkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLAorCQkJCQkJCSBXUEFfRElTQ09OTkVDVEVEKTsKKwkJCQlicmVhazsKKwkJCX0KKwogI2lmZGVmIENPTkZJR19BUAogCQkJaWYgKCF3cGFfcy0+YXBfaWZhY2UpIHsKIAkJCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsCkBAIC0zMTAxLDI1ICszMzQ2LDQ2IEBACiAJCWJyZWFrOwogCWNhc2UgRVZFTlRfSU5URVJGQUNFX0RJU0FCTEVEOgogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJJbnRlcmZhY2Ugd2FzIGRpc2FibGVkIik7CisjaWZkZWYgQ09ORklHX1AyUAorCQlpZiAod3BhX3MtPnAycF9ncm91cF9pbnRlcmZhY2UgPT0gUDJQX0dST1VQX0lOVEVSRkFDRV9HTyB8fAorCQkgICAgKHdwYV9zLT5jdXJyZW50X3NzaWQgJiYgd3BhX3MtPmN1cnJlbnRfc3NpZC0+cDJwX2dyb3VwICYmCisJCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dPKSkgeworCQkJLyoKKwkJCSAqIFRoZSBpbnRlcmZhY2Ugd2FzIGV4dGVybmFsbHkgZGlzYWJsZWQuIFJlbW92ZQorCQkJICogaXQgYXNzdW1pbmcgYW4gZXh0ZXJuYWwgZW50aXR5IHdpbGwgc3RhcnQgYQorCQkJICogbmV3IHNlc3Npb24gaWYgbmVlZGVkLgorCQkJICovCisJCQl3cGFzX3AycF9kaXNjb25uZWN0KHdwYV9zKTsKKwkJCWJyZWFrOworCQl9CisJCWlmICh3cGFfcy0+cDJwX3NjYW5fd29yayAmJiB3cGFfcy0+Z2xvYmFsLT5wMnAgJiYKKwkJICAgIHAycF9pbl9wcm9ncmVzcyh3cGFfcy0+Z2xvYmFsLT5wMnApID4gMSkgeworCQkJLyogVGhpcyByYWRpbyB3b3JrIHdpbGwgYmUgY2FuY2VsbGVkLCBzbyBjbGVhciBQMlAKKwkJCSAqIHN0YXRlIGFzIHdlbGwuCisJCQkgKi8KKwkJCXAycF9zdG9wX2ZpbmQod3BhX3MtPmdsb2JhbC0+cDJwKTsKKwkJfQorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCQlpZiAod3BhX3MtPndwYV9zdGF0ZSA+PSBXUEFfQVVUSEVOVElDQVRJTkcpIHsKKwkJCS8qCisJCQkgKiBJbmRpY2F0ZSBkaXNjb25uZWN0aW9uIHRvIGtlZXAgY3RybF9pZmFjZSBldmVudHMKKwkJCSAqIGNvbnNpc3RlbnQuCisJCQkgKi8KKwkJCXdwYV9zdXBwbGljYW50X2V2ZW50X2Rpc2Fzc29jKAorCQkJCXdwYV9zLCBXTEFOX1JFQVNPTl9ERUFVVEhfTEVBVklORywgMSk7CisJCX0KIAkJd3BhX3N1cHBsaWNhbnRfbWFya19kaXNhc3NvYyh3cGFfcyk7CisJCXJhZGlvX3JlbW92ZV93b3Jrcyh3cGFfcywgTlVMTCwgMCk7CisKIAkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfSU5URVJGQUNFX0RJU0FCTEVEKTsKIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9DSEFOTkVMX0xJU1RfQ0hBTkdFRDoKLQkJaWYgKHdwYV9zLT5kcnZfcHJpdiA9PSBOVUxMKQotCQkJYnJlYWs7IC8qIElnbm9yZSBldmVudCBkdXJpbmcgZHJ2IGluaXRpYWxpemF0aW9uICovCi0KLQkJZnJlZV9od19mZWF0dXJlcyh3cGFfcyk7Ci0JCXdwYV9zLT5ody5tb2RlcyA9IHdwYV9kcnZfZ2V0X2h3X2ZlYXR1cmVfZGF0YSgKLQkJCXdwYV9zLCAmd3BhX3MtPmh3Lm51bV9tb2RlcywgJndwYV9zLT5ody5mbGFncyk7Ci0KLSNpZmRlZiBDT05GSUdfUDJQCi0JCXdwYXNfcDJwX3VwZGF0ZV9jaGFubmVsX2xpc3Qod3BhX3MpOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKwkJd3BhX3N1cHBsaWNhbnRfdXBkYXRlX2NoYW5uZWxfbGlzdCgKKwkJCXdwYV9zLCAmZGF0YS0+Y2hhbm5lbF9saXN0X2NoYW5nZWQpOwogCQlicmVhazsKIAljYXNlIEVWRU5UX0lOVEVSRkFDRV9VTkFWQUlMQUJMRToKLSNpZmRlZiBDT05GSUdfUDJQCiAJCXdwYXNfcDJwX2ludGVyZmFjZV91bmF2YWlsYWJsZSh3cGFfcyk7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCQlicmVhazsKIAljYXNlIEVWRU5UX0JFU1RfQ0hBTk5FTDoKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQmVzdCBjaGFubmVsIGV2ZW50IHJlY2VpdmVkICIKQEAgLTMxMjksMTEgKzMzOTUsOSBAQAogCQl3cGFfcy0+YmVzdF8yNF9mcmVxID0gZGF0YS0+YmVzdF9jaGFuLmZyZXFfMjQ7CiAJCXdwYV9zLT5iZXN0XzVfZnJlcSA9IGRhdGEtPmJlc3RfY2hhbi5mcmVxXzU7CiAJCXdwYV9zLT5iZXN0X292ZXJhbGxfZnJlcSA9IGRhdGEtPmJlc3RfY2hhbi5mcmVxX292ZXJhbGw7Ci0jaWZkZWYgQ09ORklHX1AyUAogCQl3cGFzX3AycF91cGRhdGVfYmVzdF9jaGFubmVscyh3cGFfcywgZGF0YS0+YmVzdF9jaGFuLmZyZXFfMjQsCiAJCQkJCSAgICAgIGRhdGEtPmJlc3RfY2hhbi5mcmVxXzUsCiAJCQkJCSAgICAgIGRhdGEtPmJlc3RfY2hhbi5mcmVxX292ZXJhbGwpOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9VTlBST1RfREVBVVRIOgogCQl3cGFfc3VwcGxpY2FudF9ldmVudF91bnByb3RfZGVhdXRoKHdwYV9zLApAQCAtMzE1MSw3ICszNDE1LDggQEAKICNlbmRpZiAvKiBDT05GSUdfQVAgKi8KICNpZmRlZiBDT05GSUdfVERMUwogCQlpZiAoZGF0YSkKLQkJCXdwYV90ZGxzX2Rpc2FibGVfbGluayh3cGFfcy0+d3BhLCBkYXRhLT5sb3dfYWNrLmFkZHIpOworCQkJd3BhX3RkbHNfZGlzYWJsZV91bnJlYWNoYWJsZV9saW5rKHdwYV9zLT53cGEsCisJCQkJCQkJICBkYXRhLT5sb3dfYWNrLmFkZHIpOwogI2VuZGlmIC8qIENPTkZJR19URExTICovCiAJCWJyZWFrOwogCWNhc2UgRVZFTlRfSUJTU19QRUVSX0xPU1Q6CkBAIC0zMTY5LDYgKzM0MzQsNyBAQAogCQkJCQkgZGF0YS0+ZHJpdmVyX2d0a19yZWtleS5yZXBsYXlfY3RyKTsKIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9TQ0hFRF9TQ0FOX1NUT1BQRUQ6CisJCXdwYV9zLT5wbm8gPSAwOwogCQl3cGFfcy0+c2NoZWRfc2Nhbm5pbmcgPSAwOwogCQl3cGFfc3VwcGxpY2FudF9ub3RpZnlfc2Nhbm5pbmcod3BhX3MsIDApOwogCkBAIC0zMTc2LDE3ICszNDQyLDI1IEBACiAJCQlicmVhazsKIAogCQkvKgotCQkgKiBJZiB3ZSB0aW1lZCBvdXQsIHN0YXJ0IGEgbmV3IHNjaGVkIHNjYW4gdG8gY29udGludWUKLQkJICogc2VhcmNoaW5nIGZvciBtb3JlIFNTSURzLgorCQkgKiBTdGFydCBhIG5ldyBzY2hlZCBzY2FuIHRvIGNvbnRpbnVlIHNlYXJjaGluZyBmb3IgbW9yZSBTU0lEcworCQkgKiBlaXRoZXIgaWYgdGltZWQgb3V0IG9yIFBOTyBzY2hlZHVsZSBzY2FuIGlzIHBlbmRpbmcuCiAJCSAqLwotCQlpZiAod3BhX3MtPnNjaGVkX3NjYW5fdGltZWRfb3V0KQorCQlpZiAod3BhX3MtPnNjaGVkX3NjYW5fdGltZWRfb3V0KSB7CiAJCQl3cGFfc3VwcGxpY2FudF9yZXFfc2NoZWRfc2Nhbih3cGFfcyk7CisJCX0gZWxzZSBpZiAod3BhX3MtPnBub19zY2hlZF9wZW5kaW5nKSB7CisJCQl3cGFfcy0+cG5vX3NjaGVkX3BlbmRpbmcgPSAwOworCQkJd3Bhc19zdGFydF9wbm8od3BhX3MpOworCQl9CisKIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9XUFNfQlVUVE9OX1BVU0hFRDoKICNpZmRlZiBDT05GSUdfV1BTCiAJCXdwYXNfd3BzX3N0YXJ0X3BiYyh3cGFfcywgTlVMTCwgMCk7CiAjZW5kaWYgLyogQ09ORklHX1dQUyAqLwogCQlicmVhazsKKwljYXNlIEVWRU5UX0FWT0lEX0ZSRVFVRU5DSUVTOgorCQl3cGFfc3VwcGxpY2FudF9ub3RpZnlfYXZvaWRfZnJlcSh3cGFfcywgZGF0YSk7CisJCWJyZWFrOwogCWNhc2UgRVZFTlRfQ09OTkVDVF9GQUlMRURfUkVBU09OOgogI2lmZGVmIENPTkZJR19BUAogCQlpZiAoIXdwYV9zLT5hcF9pZmFjZSB8fCAhZGF0YSkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2V4YW1wbGVzL3AycC1hY3Rpb24uc2ggYi93cGFfc3VwcGxpY2FudC9leGFtcGxlcy9wMnAtYWN0aW9uLnNoCmluZGV4IDg3NTlmNTQuLjc5N2Q0M2EgMTAwNzU1Ci0tLSBhL3dwYV9zdXBwbGljYW50L2V4YW1wbGVzL3AycC1hY3Rpb24uc2gKKysrIGIvd3BhX3N1cHBsaWNhbnQvZXhhbXBsZXMvcDJwLWFjdGlvbi5zaApAQCAtMzQsMTMgKzM0LDI2IEBACiAJICAgICMgc3RhcnQgd2l0aCAteiB0byBhdm9pZCB0aGF0CiAJICAgIGRuc21hc3EgLXggL3Zhci9ydW4vZG5zbWFzcS5waWQtJEdJRk5BTUUgXAogCQktaSAkR0lGTkFNRSBcCi0JCS1GMTkyLjE2OC40Mi4xMSwxOTIuMTY4LjQyLjk5IC0tbGlzdGVuLWFkZHJlc3MgMTkyLjE2OC40Mi4xIC16CisJCS1GMTkyLjE2OC40Mi4xMSwxOTIuMTY4LjQyLjk5IC0tbGlzdGVuLWFkZHJlc3MgMTkyLjE2OC40Mi4xIC16IC1wIDAKIAlmaQogICAgIGZpCiAgICAgaWYgWyAiJDQiID0gImNsaWVudCIgXTsgdGhlbgogCWtpbGxfZGFlbW9uIGRoY2xpZW50IC92YXIvcnVuL2RoY2xpZW50LSRHSUZOQU1FLnBpZAogCXJtIC92YXIvcnVuL2RoY2xpZW50LmxlYXNlcy0kR0lGTkFNRQogCWtpbGxfZGFlbW9uIGRuc21hc3EgL3Zhci9ydW4vZG5zbWFzcS5waWQtJEdJRk5BTUUKKwlpcGFkZHI9YGVjaG8gIiQqIiB8IHNlZCAncy8uKiBpcF9hZGRyPVwoW14gXSpcKS4qL1wxLydgCisJaXBtYXNrPWBlY2hvICIkKiIgfCBzZWQgJ3MvLiogaXBfbWFzaz1cKFteIF0qXCkuKi9cMS8nYAorCWdvaXBhZGRyPWBlY2hvICIkKiIgfCBzZWQgJ3MvLiogZ29faXBfYWRkcj1cKFteIF0qXCkuKi9cMS8nYAorCWlmIGVjaG8gIiRpcGFkZHIkaXBtYXNrJGdvaXBhZGRyIiB8IGdyZXAgLXEgJyAnOyB0aGVuCisJICAgIGlwYWRkcj0iIgorCSAgICBpcG1hc2s9IiIKKwkgICAgZ29pcGFkZHI9IiIKKwlmaQorCWlmIFsgLW4gIiRpcGFkZHIiIF07IHRoZW4KKwkgICAgc3VkbyBpZmNvbmZpZyAkR0lGTkFNRSAiJGlwYWRkciIgbmV0bWFzayAiJGlwbWFzayIKKwkgICAgc3VkbyBpcCBybyByZSBkZWZhdWx0IHZpYSAiJGdvaXBhZGRyIgorCSAgICBleGl0IDAKKwlmaQogCWRoY2xpZW50IC1wZiAvdmFyL3J1bi9kaGNsaWVudC0kR0lGTkFNRS5waWQgXAogCSAgICAtbGYgL3Zhci9ydW4vZGhjbGllbnQubGVhc2VzLSRHSUZOQU1FIFwKIAkgICAgLW53IFwKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2V4YW1wbGVzL3AycC1uZmMucHkgYi93cGFfc3VwcGxpY2FudC9leGFtcGxlcy9wMnAtbmZjLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjkxZWJhMjgKLS0tIC9kZXYvbnVsbAorKysgYi93cGFfc3VwcGxpY2FudC9leGFtcGxlcy9wMnAtbmZjLnB5CkBAIC0wLDAgKzEsNjU0IEBACisjIS91c3IvYmluL3B5dGhvbgorIworIyBFeGFtcGxlIG5mY3B5IHRvIHdwYV9zdXBwbGljYW50IHdyYXBwZXIgZm9yIFAyUCBORkMgb3BlcmF0aW9ucworIyBDb3B5cmlnaHQgKGMpIDIwMTItMjAxMywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyMKKyMgVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyMgU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorCitpbXBvcnQgb3MKK2ltcG9ydCBzeXMKK2ltcG9ydCB0aW1lCitpbXBvcnQgcmFuZG9tCitpbXBvcnQgdGhyZWFkaW5nCitpbXBvcnQgYXJncGFyc2UKKworaW1wb3J0IG5mYworaW1wb3J0IG5mYy5uZGVmCitpbXBvcnQgbmZjLmxsY3AKK2ltcG9ydCBuZmMuaGFuZG92ZXIKKworaW1wb3J0IGxvZ2dpbmcKKworaW1wb3J0IHdwYXNweQorCit3cGFzX2N0cmwgPSAnL3Zhci9ydW4vd3BhX3N1cHBsaWNhbnQnCitpZm5hbWUgPSBOb25lCitpbml0X29uX3RvdWNoID0gRmFsc2UKK2luX3Jhd19tb2RlID0gRmFsc2UKK3ByZXZfdGNnZXRhdHRyID0gMAoraW5jbHVkZV93cHNfcmVxID0gVHJ1ZQoraW5jbHVkZV9wMnBfcmVxID0gVHJ1ZQorbm9faW5wdXQgPSBGYWxzZQorc3J2ID0gTm9uZQorY29udGludWVfbG9vcCA9IFRydWUKK3Rlcm1pbmF0ZV9ub3cgPSBGYWxzZQorc3VtbWFyeV9maWxlID0gTm9uZQorc3VjY2Vzc19maWxlID0gTm9uZQorCitkZWYgc3VtbWFyeSh0eHQpOgorICAgIHByaW50IHR4dAorICAgIGlmIHN1bW1hcnlfZmlsZToKKyAgICAgICAgd2l0aCBvcGVuKHN1bW1hcnlfZmlsZSwgJ2EnKSBhcyBmOgorICAgICAgICAgICAgZi53cml0ZSh0eHQgKyAiXG4iKQorCitkZWYgc3VjY2Vzc19yZXBvcnQodHh0KToKKyAgICBzdW1tYXJ5KHR4dCkKKyAgICBpZiBzdWNjZXNzX2ZpbGU6CisgICAgICAgIHdpdGggb3BlbihzdWNjZXNzX2ZpbGUsICdhJykgYXMgZjoKKyAgICAgICAgICAgIGYud3JpdGUodHh0ICsgIlxuIikKKworZGVmIHdwYXNfY29ubmVjdCgpOgorICAgIGlmYWNlcyA9IFtdCisgICAgaWYgb3MucGF0aC5pc2Rpcih3cGFzX2N0cmwpOgorICAgICAgICB0cnk6CisgICAgICAgICAgICBpZmFjZXMgPSBbb3MucGF0aC5qb2luKHdwYXNfY3RybCwgaSkgZm9yIGkgaW4gb3MubGlzdGRpcih3cGFzX2N0cmwpXQorICAgICAgICBleGNlcHQgT1NFcnJvciwgZXJyb3I6CisgICAgICAgICAgICBwcmludCAiQ291bGQgbm90IGZpbmQgd3BhX3N1cHBsaWNhbnQ6ICIsIGVycm9yCisgICAgICAgICAgICByZXR1cm4gTm9uZQorCisgICAgaWYgbGVuKGlmYWNlcykgPCAxOgorICAgICAgICBwcmludCAiTm8gd3BhX3N1cHBsaWNhbnQgY29udHJvbCBpbnRlcmZhY2UgZm91bmQiCisgICAgICAgIHJldHVybiBOb25lCisKKyAgICBmb3IgY3RybCBpbiBpZmFjZXM6CisgICAgICAgIGlmIGlmbmFtZToKKyAgICAgICAgICAgIGlmIGlmbmFtZSBub3QgaW4gY3RybDoKKyAgICAgICAgICAgICAgICBjb250aW51ZQorICAgICAgICB0cnk6CisgICAgICAgICAgICBwcmludCAiVHJ5aW5nIHRvIHVzZSBjb250cm9sIGludGVyZmFjZSAiICsgY3RybAorICAgICAgICAgICAgd3BhcyA9IHdwYXNweS5DdHJsKGN0cmwpCisgICAgICAgICAgICByZXR1cm4gd3BhcworICAgICAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICAgICAgcGFzcworICAgIHJldHVybiBOb25lCisKKworZGVmIHdwYXNfdGFnX3JlYWQobWVzc2FnZSk6CisgICAgd3BhcyA9IHdwYXNfY29ubmVjdCgpCisgICAgaWYgKHdwYXMgPT0gTm9uZSk6CisgICAgICAgIHJldHVybiBGYWxzZQorICAgIGNtZCA9ICJXUFNfTkZDX1RBR19SRUFEICIgKyBzdHIobWVzc2FnZSkuZW5jb2RlKCJoZXgiKQorICAgIGdsb2JhbCBmb3JjZV9mcmVxCisgICAgaWYgZm9yY2VfZnJlcToKKyAgICAgICAgY21kID0gY21kICsgIiBmcmVxPSIgKyBmb3JjZV9mcmVxCisgICAgaWYgIkZBSUwiIGluIHdwYXMucmVxdWVzdChjbWQpOgorICAgICAgICByZXR1cm4gRmFsc2UKKyAgICByZXR1cm4gVHJ1ZQorCisKK2RlZiB3cGFzX2dldF9oYW5kb3Zlcl9yZXEoKToKKyAgICB3cGFzID0gd3Bhc19jb25uZWN0KCkKKyAgICBpZiAod3BhcyA9PSBOb25lKToKKyAgICAgICAgcmV0dXJuIE5vbmUKKyAgICByZXMgPSB3cGFzLnJlcXVlc3QoIk5GQ19HRVRfSEFORE9WRVJfUkVRIE5ERUYgUDJQLUNSIikucnN0cmlwKCkKKyAgICBpZiAiRkFJTCIgaW4gcmVzOgorICAgICAgICByZXR1cm4gTm9uZQorICAgIHJldHVybiByZXMuZGVjb2RlKCJoZXgiKQorCitkZWYgd3Bhc19nZXRfaGFuZG92ZXJfcmVxX3dwcygpOgorICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQorICAgIGlmICh3cGFzID09IE5vbmUpOgorICAgICAgICByZXR1cm4gTm9uZQorICAgIHJlcyA9IHdwYXMucmVxdWVzdCgiTkZDX0dFVF9IQU5ET1ZFUl9SRVEgTkRFRiBXUFMtQ1IiKS5yc3RyaXAoKQorICAgIGlmICJGQUlMIiBpbiByZXM6CisgICAgICAgIHJldHVybiBOb25lCisgICAgcmV0dXJuIHJlcy5kZWNvZGUoImhleCIpCisKKworZGVmIHdwYXNfZ2V0X2hhbmRvdmVyX3NlbCh0YWc9RmFsc2UpOgorICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQorICAgIGlmICh3cGFzID09IE5vbmUpOgorICAgICAgICByZXR1cm4gTm9uZQorICAgIGlmIHRhZzoKKyAgICAgICAgcmVzID0gd3Bhcy5yZXF1ZXN0KCJORkNfR0VUX0hBTkRPVkVSX1NFTCBOREVGIFAyUC1DUi1UQUciKS5yc3RyaXAoKQorICAgIGVsc2U6CisJcmVzID0gd3Bhcy5yZXF1ZXN0KCJORkNfR0VUX0hBTkRPVkVSX1NFTCBOREVGIFAyUC1DUiIpLnJzdHJpcCgpCisgICAgaWYgIkZBSUwiIGluIHJlczoKKyAgICAgICAgcmV0dXJuIE5vbmUKKyAgICByZXR1cm4gcmVzLmRlY29kZSgiaGV4IikKKworCitkZWYgd3Bhc19nZXRfaGFuZG92ZXJfc2VsX3dwcygpOgorICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQorICAgIGlmICh3cGFzID09IE5vbmUpOgorICAgICAgICByZXR1cm4gTm9uZQorICAgIHJlcyA9IHdwYXMucmVxdWVzdCgiTkZDX0dFVF9IQU5ET1ZFUl9TRUwgTkRFRiBXUFMtQ1IiKTsKKyAgICBpZiAiRkFJTCIgaW4gcmVzOgorICAgICAgICByZXR1cm4gTm9uZQorICAgIHJldHVybiByZXMucnN0cmlwKCkuZGVjb2RlKCJoZXgiKQorCisKK2RlZiB3cGFzX3JlcG9ydF9oYW5kb3ZlcihyZXEsIHNlbCwgdHlwZSk6CisgICAgd3BhcyA9IHdwYXNfY29ubmVjdCgpCisgICAgaWYgKHdwYXMgPT0gTm9uZSk6CisgICAgICAgIHJldHVybiBOb25lCisgICAgY21kID0gIk5GQ19SRVBPUlRfSEFORE9WRVIgIiArIHR5cGUgKyAiIFAyUCAiICsgc3RyKHJlcSkuZW5jb2RlKCJoZXgiKSArICIgIiArIHN0cihzZWwpLmVuY29kZSgiaGV4IikKKyAgICBnbG9iYWwgZm9yY2VfZnJlcQorICAgIGlmIGZvcmNlX2ZyZXE6CisgICAgICAgIGNtZCA9IGNtZCArICIgZnJlcT0iICsgZm9yY2VfZnJlcQorICAgIHJldHVybiB3cGFzLnJlcXVlc3QoY21kKQorCisKK2RlZiB3cGFzX3JlcG9ydF9oYW5kb3Zlcl93c2MocmVxLCBzZWwsIHR5cGUpOgorICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQorICAgIGlmICh3cGFzID09IE5vbmUpOgorICAgICAgICByZXR1cm4gTm9uZQorICAgIGNtZCA9ICJORkNfUkVQT1JUX0hBTkRPVkVSICIgKyB0eXBlICsgIiBXUFMgIiArIHN0cihyZXEpLmVuY29kZSgiaGV4IikgKyAiICIgKyBzdHIoc2VsKS5lbmNvZGUoImhleCIpCisgICAgaWYgZm9yY2VfZnJlcToKKyAgICAgICAgY21kID0gY21kICsgIiBmcmVxPSIgKyBmb3JjZV9mcmVxCisgICAgcmV0dXJuIHdwYXMucmVxdWVzdChjbWQpCisKKworZGVmIHAycF9oYW5kb3Zlcl9jbGllbnQobGxjKToKKyAgICBtZXNzYWdlID0gbmZjLm5kZWYuSGFuZG92ZXJSZXF1ZXN0TWVzc2FnZSh2ZXJzaW9uPSIxLjIiKQorICAgIG1lc3NhZ2Uubm9uY2UgPSByYW5kb20ucmFuZGludCgwLCAweGZmZmYpCisKKyAgICBnbG9iYWwgaW5jbHVkZV9wMnBfcmVxCisgICAgaWYgaW5jbHVkZV9wMnBfcmVxOgorICAgICAgICBkYXRhID0gd3Bhc19nZXRfaGFuZG92ZXJfcmVxKCkKKyAgICAgICAgaWYgKGRhdGEgPT0gTm9uZSk6CisgICAgICAgICAgICBzdW1tYXJ5KCJDb3VsZCBub3QgZ2V0IGhhbmRvdmVyIHJlcXVlc3QgY2FycmllciByZWNvcmQgZnJvbSB3cGFfc3VwcGxpY2FudCIpCisgICAgICAgICAgICByZXR1cm4KKyAgICAgICAgcHJpbnQgIkhhbmRvdmVyIHJlcXVlc3QgY2FycmllciByZWNvcmQgZnJvbSB3cGFfc3VwcGxpY2FudDogIiArIGRhdGEuZW5jb2RlKCJoZXgiKQorICAgICAgICBkYXRhbXNnID0gbmZjLm5kZWYuTWVzc2FnZShkYXRhKQorICAgICAgICBtZXNzYWdlLmFkZF9jYXJyaWVyKGRhdGFtc2dbMF0sICJhY3RpdmUiLCBkYXRhbXNnWzE6XSkKKworICAgIGdsb2JhbCBpbmNsdWRlX3dwc19yZXEKKyAgICBpZiBpbmNsdWRlX3dwc19yZXE6CisgICAgICAgIHByaW50ICJIYW5kb3ZlciByZXF1ZXN0IChwcmUtV1BTKToiCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHByaW50IG1lc3NhZ2UucHJldHR5KCkKKyAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgICAgIHByaW50IGUKKworICAgICAgICBkYXRhID0gd3Bhc19nZXRfaGFuZG92ZXJfcmVxX3dwcygpCisgICAgICAgIGlmIGRhdGE6CisgICAgICAgICAgICBwcmludCAiQWRkIFdQUyByZXF1ZXN0IGluIGFkZGl0aW9uIHRvIFAyUCIKKyAgICAgICAgICAgIGRhdGFtc2cgPSBuZmMubmRlZi5NZXNzYWdlKGRhdGEpCisgICAgICAgICAgICBtZXNzYWdlLmFkZF9jYXJyaWVyKGRhdGFtc2dbMF0sICJhY3RpdmUiLCBkYXRhbXNnWzE6XSkKKworICAgIHByaW50ICJIYW5kb3ZlciByZXF1ZXN0OiIKKyAgICB0cnk6CisgICAgICAgIHByaW50IG1lc3NhZ2UucHJldHR5KCkKKyAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICBwcmludCBlCisgICAgcHJpbnQgc3RyKG1lc3NhZ2UpLmVuY29kZSgiaGV4IikKKworICAgIGNsaWVudCA9IG5mYy5oYW5kb3Zlci5IYW5kb3ZlckNsaWVudChsbGMpCisgICAgdHJ5OgorICAgICAgICBzdW1tYXJ5KCJUcnlpbmcgdG8gaW5pdGlhdGUgTkZDIGNvbm5lY3Rpb24gaGFuZG92ZXIiKQorICAgICAgICBjbGllbnQuY29ubmVjdCgpCisgICAgICAgIHN1bW1hcnkoIkNvbm5lY3RlZCBmb3IgaGFuZG92ZXIiKQorICAgIGV4Y2VwdCBuZmMubGxjcC5Db25uZWN0UmVmdXNlZDoKKyAgICAgICAgc3VtbWFyeSgiSGFuZG92ZXIgY29ubmVjdGlvbiByZWZ1c2VkIikKKyAgICAgICAgY2xpZW50LmNsb3NlKCkKKyAgICAgICAgcmV0dXJuCisgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgc3VtbWFyeSgiT3RoZXIgZXhjZXB0aW9uOiAiICsgc3RyKGUpKQorICAgICAgICBjbGllbnQuY2xvc2UoKQorICAgICAgICByZXR1cm4KKworICAgIHN1bW1hcnkoIlNlbmRpbmcgaGFuZG92ZXIgcmVxdWVzdCIpCisKKyAgICBpZiBub3QgY2xpZW50LnNlbmQobWVzc2FnZSk6CisgICAgICAgIHN1bW1hcnkoIkZhaWxlZCB0byBzZW5kIGhhbmRvdmVyIHJlcXVlc3QiKQorICAgICAgICBjbGllbnQuY2xvc2UoKQorICAgICAgICByZXR1cm4KKworICAgIHN1bW1hcnkoIlJlY2VpdmluZyBoYW5kb3ZlciByZXNwb25zZSIpCisgICAgbWVzc2FnZSA9IGNsaWVudC5fcmVjdigpCisgICAgaWYgbWVzc2FnZSBpcyBOb25lOgorICAgICAgICBzdW1tYXJ5KCJObyByZXNwb25zZSByZWNlaXZlZCIpCisgICAgICAgIGNsaWVudC5jbG9zZSgpCisgICAgICAgIHJldHVybgorICAgIGlmIG1lc3NhZ2UudHlwZSAhPSAidXJuOm5mYzp3a3Q6SHMiOgorICAgICAgICBzdW1tYXJ5KCJSZXNwb25zZSB3YXMgbm90IEhzIC0gcmVjZWl2ZWQ6ICIgKyBtZXNzYWdlLnR5cGUpCisgICAgICAgIGNsaWVudC5jbG9zZSgpCisgICAgICAgIHJldHVybgorCisgICAgcHJpbnQgIlJlY2VpdmVkIG1lc3NhZ2UiCisgICAgdHJ5OgorICAgICAgICBwcmludCBtZXNzYWdlLnByZXR0eSgpCisgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgcHJpbnQgZQorICAgIHByaW50IHN0cihtZXNzYWdlKS5lbmNvZGUoImhleCIpCisgICAgbWVzc2FnZSA9IG5mYy5uZGVmLkhhbmRvdmVyU2VsZWN0TWVzc2FnZShtZXNzYWdlKQorICAgIHN1bW1hcnkoIkhhbmRvdmVyIHNlbGVjdCByZWNlaXZlZCIpCisgICAgdHJ5OgorICAgICAgICBwcmludCBtZXNzYWdlLnByZXR0eSgpCisgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgcHJpbnQgZQorCisgICAgZm9yIGNhcnJpZXIgaW4gbWVzc2FnZS5jYXJyaWVyczoKKyAgICAgICAgcHJpbnQgIlJlbW90ZSBjYXJyaWVyIHR5cGU6ICIgKyBjYXJyaWVyLnR5cGUKKyAgICAgICAgaWYgY2Fycmllci50eXBlID09ICJhcHBsaWNhdGlvbi92bmQud2ZhLnAycCI6CisgICAgICAgICAgICBwcmludCAiUDJQIGNhcnJpZXIgdHlwZSBtYXRjaCAtIHNlbmQgdG8gd3BhX3N1cHBsaWNhbnQiCisgICAgICAgICAgICBpZiAiT0siIGluIHdwYXNfcmVwb3J0X2hhbmRvdmVyKGRhdGEsIGNhcnJpZXIucmVjb3JkLCAiSU5JVCIpOgorICAgICAgICAgICAgICAgIHN1Y2Nlc3NfcmVwb3J0KCJQMlAgaGFuZG92ZXIgcmVwb3J0ZWQgc3VjY2Vzc2Z1bGx5IChpbml0aWF0b3IpIikKKyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgc3VtbWFyeSgiUDJQIGhhbmRvdmVyIHJlcG9ydCByZWplY3RlZCIpCisgICAgICAgICAgICBicmVhaworCisgICAgcHJpbnQgIlJlbW92ZSBwZWVyIgorICAgIGNsaWVudC5jbG9zZSgpCisgICAgcHJpbnQgIkRvbmUgd2l0aCBoYW5kb3ZlciIKKyAgICBnbG9iYWwgb25seV9vbmUKKyAgICBpZiBvbmx5X29uZToKKyAgICAgICAgcHJpbnQgIm9ubHlfb25lIC0+IHN0b3AgbG9vcCIKKyAgICAgICAgZ2xvYmFsIGNvbnRpbnVlX2xvb3AKKyAgICAgICAgY29udGludWVfbG9vcCA9IEZhbHNlCisKKyAgICBnbG9iYWwgbm9fd2FpdAorICAgIGlmIG5vX3dhaXQ6CisgICAgICAgIHByaW50ICJUcnlpbmcgdG8gZXhpdC4uIgorICAgICAgICBnbG9iYWwgdGVybWluYXRlX25vdworICAgICAgICB0ZXJtaW5hdGVfbm93ID0gVHJ1ZQorCisKK2NsYXNzIEhhbmRvdmVyU2VydmVyKG5mYy5oYW5kb3Zlci5IYW5kb3ZlclNlcnZlcik6CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIGxsYyk6CisgICAgICAgIHN1cGVyKEhhbmRvdmVyU2VydmVyLCBzZWxmKS5fX2luaXRfXyhsbGMpCisgICAgICAgIHNlbGYuc2VudF9jYXJyaWVyID0gTm9uZQorICAgICAgICBzZWxmLmhvX3NlcnZlcl9wcm9jZXNzaW5nID0gRmFsc2UKKyAgICAgICAgc2VsZi5zdWNjZXNzID0gRmFsc2UKKworICAgICMgb3ZlcnJpZGUgdG8gYXZvaWQgcGFyc2VyIGVycm9yIGluIHJlcXVlc3QvcmVzcG9uc2UucHJldHR5KCkgaW4gbmZjcHkKKyAgICAjIGR1ZSB0byBuZXcgV1NDIGhhbmRvdmVyIGZvcm1hdAorICAgIGRlZiBfcHJvY2Vzc19yZXF1ZXN0KHNlbGYsIHJlcXVlc3QpOgorICAgICAgICBzdW1tYXJ5KCJyZWNlaXZlZCBoYW5kb3ZlciByZXF1ZXN0IHt9Ii5mb3JtYXQocmVxdWVzdC50eXBlKSkKKyAgICAgICAgcmVzcG9uc2UgPSBuZmMubmRlZi5NZXNzYWdlKCJceGQxXHgwMlx4MDFIc1x4MTIiKQorICAgICAgICBpZiBub3QgcmVxdWVzdC50eXBlID09ICd1cm46bmZjOndrdDpIcic6CisgICAgICAgICAgICBzdW1tYXJ5KCJub3QgYSBoYW5kb3ZlciByZXF1ZXN0IikKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICByZXF1ZXN0ID0gbmZjLm5kZWYuSGFuZG92ZXJSZXF1ZXN0TWVzc2FnZShyZXF1ZXN0KQorICAgICAgICAgICAgZXhjZXB0IG5mYy5uZGVmLkRlY29kZUVycm9yIGFzIGU6CisgICAgICAgICAgICAgICAgc3VtbWFyeSgiZXJyb3IgZGVjb2RpbmcgJ0hyJyBtZXNzYWdlOiB7fSIuZm9ybWF0KGUpKQorICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICByZXNwb25zZSA9IHNlbGYucHJvY2Vzc19yZXF1ZXN0KHJlcXVlc3QpCisgICAgICAgIHN1bW1hcnkoInNlbmQgaGFuZG92ZXIgcmVzcG9uc2Uge30iLmZvcm1hdChyZXNwb25zZS50eXBlKSkKKyAgICAgICAgcmV0dXJuIHJlc3BvbnNlCisKKyAgICBkZWYgcHJvY2Vzc19yZXF1ZXN0KHNlbGYsIHJlcXVlc3QpOgorICAgICAgICBzZWxmLmhvX3NlcnZlcl9wcm9jZXNzaW5nID0gVHJ1ZQorICAgICAgICBjbGVhcl9yYXdfbW9kZSgpCisgICAgICAgIHByaW50ICJIYW5kb3ZlclNlcnZlciAtIHJlcXVlc3QgcmVjZWl2ZWQiCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHByaW50ICJQYXJzZWQgaGFuZG92ZXIgcmVxdWVzdDogIiArIHJlcXVlc3QucHJldHR5KCkKKyAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgICAgIHByaW50IGUKKworICAgICAgICBzZWwgPSBuZmMubmRlZi5IYW5kb3ZlclNlbGVjdE1lc3NhZ2UodmVyc2lvbj0iMS4yIikKKworICAgICAgICBmb3VuZCA9IEZhbHNlCisKKyAgICAgICAgZm9yIGNhcnJpZXIgaW4gcmVxdWVzdC5jYXJyaWVyczoKKyAgICAgICAgICAgIHByaW50ICJSZW1vdGUgY2FycmllciB0eXBlOiAiICsgY2Fycmllci50eXBlCisgICAgICAgICAgICBpZiBjYXJyaWVyLnR5cGUgPT0gImFwcGxpY2F0aW9uL3ZuZC53ZmEucDJwIjoKKyAgICAgICAgICAgICAgICBwcmludCAiUDJQIGNhcnJpZXIgdHlwZSBtYXRjaCAtIGFkZCBQMlAgY2FycmllciByZWNvcmQiCisgICAgICAgICAgICAgICAgZm91bmQgPSBUcnVlCisgICAgICAgICAgICAgICAgc2VsZi5yZWNlaXZlZF9jYXJyaWVyID0gY2Fycmllci5yZWNvcmQKKyAgICAgICAgICAgICAgICBwcmludCAiQ2FycmllciByZWNvcmQ6IgorICAgICAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICAgICAgcHJpbnQgY2Fycmllci5yZWNvcmQucHJldHR5KCkKKyAgICAgICAgICAgICAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICAgICAgICAgICAgICBwcmludCBlCisgICAgICAgICAgICAgICAgZGF0YSA9IHdwYXNfZ2V0X2hhbmRvdmVyX3NlbCgpCisgICAgICAgICAgICAgICAgaWYgZGF0YSBpcyBOb25lOgorICAgICAgICAgICAgICAgICAgICBwcmludCAiQ291bGQgbm90IGdldCBoYW5kb3ZlciBzZWxlY3QgY2FycmllciByZWNvcmQgZnJvbSB3cGFfc3VwcGxpY2FudCIKKyAgICAgICAgICAgICAgICAgICAgY29udGludWUKKyAgICAgICAgICAgICAgICBwcmludCAiSGFuZG92ZXIgc2VsZWN0IGNhcnJpZXIgcmVjb3JkIGZyb20gd3BhX3N1cHBsaWNhbnQ6IgorICAgICAgICAgICAgICAgIHByaW50IGRhdGEuZW5jb2RlKCJoZXgiKQorICAgICAgICAgICAgICAgIHNlbGYuc2VudF9jYXJyaWVyID0gZGF0YQorICAgICAgICAgICAgICAgIGlmICJPSyIgaW4gd3Bhc19yZXBvcnRfaGFuZG92ZXIoc2VsZi5yZWNlaXZlZF9jYXJyaWVyLCBzZWxmLnNlbnRfY2FycmllciwgIlJFU1AiKToKKyAgICAgICAgICAgICAgICAgICAgc3VjY2Vzc19yZXBvcnQoIlAyUCBoYW5kb3ZlciByZXBvcnRlZCBzdWNjZXNzZnVsbHkgKHJlc3BvbmRlcikiKQorICAgICAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgICAgIHN1bW1hcnkoIlAyUCBoYW5kb3ZlciByZXBvcnQgcmVqZWN0ZWQiKQorICAgICAgICAgICAgICAgICAgICBicmVhaworCisgICAgICAgICAgICAgICAgbWVzc2FnZSA9IG5mYy5uZGVmLk1lc3NhZ2UoZGF0YSk7CisgICAgICAgICAgICAgICAgc2VsLmFkZF9jYXJyaWVyKG1lc3NhZ2VbMF0sICJhY3RpdmUiLCBtZXNzYWdlWzE6XSkKKyAgICAgICAgICAgICAgICBicmVhaworCisgICAgICAgIGZvciBjYXJyaWVyIGluIHJlcXVlc3QuY2FycmllcnM6CisgICAgICAgICAgICBpZiBmb3VuZDoKKyAgICAgICAgICAgICAgICBicmVhaworICAgICAgICAgICAgcHJpbnQgIlJlbW90ZSBjYXJyaWVyIHR5cGU6ICIgKyBjYXJyaWVyLnR5cGUKKyAgICAgICAgICAgIGlmIGNhcnJpZXIudHlwZSA9PSAiYXBwbGljYXRpb24vdm5kLndmYS53c2MiOgorICAgICAgICAgICAgICAgIHByaW50ICJXU0MgY2FycmllciB0eXBlIG1hdGNoIC0gYWRkIFdTQyBjYXJyaWVyIHJlY29yZCIKKyAgICAgICAgICAgICAgICBmb3VuZCA9IFRydWUKKyAgICAgICAgICAgICAgICBzZWxmLnJlY2VpdmVkX2NhcnJpZXIgPSBjYXJyaWVyLnJlY29yZAorICAgICAgICAgICAgICAgIHByaW50ICJDYXJyaWVyIHJlY29yZDoiCisgICAgICAgICAgICAgICAgdHJ5OgorICAgICAgICAgICAgICAgICAgICBwcmludCBjYXJyaWVyLnJlY29yZC5wcmV0dHkoKQorICAgICAgICAgICAgICAgIGV4Y2VwdCBFeGNlcHRpb24sIGU6CisgICAgICAgICAgICAgICAgICAgIHByaW50IGUKKyAgICAgICAgICAgICAgICBkYXRhID0gd3Bhc19nZXRfaGFuZG92ZXJfc2VsX3dwcygpCisgICAgICAgICAgICAgICAgaWYgZGF0YSBpcyBOb25lOgorICAgICAgICAgICAgICAgICAgICBwcmludCAiQ291bGQgbm90IGdldCBoYW5kb3ZlciBzZWxlY3QgY2FycmllciByZWNvcmQgZnJvbSB3cGFfc3VwcGxpY2FudCIKKyAgICAgICAgICAgICAgICAgICAgY29udGludWUKKyAgICAgICAgICAgICAgICBwcmludCAiSGFuZG92ZXIgc2VsZWN0IGNhcnJpZXIgcmVjb3JkIGZyb20gd3BhX3N1cHBsaWNhbnQ6IgorICAgICAgICAgICAgICAgIHByaW50IGRhdGEuZW5jb2RlKCJoZXgiKQorICAgICAgICAgICAgICAgIHNlbGYuc2VudF9jYXJyaWVyID0gZGF0YQorICAgICAgICAgICAgICAgIGlmICJPSyIgaW4gd3Bhc19yZXBvcnRfaGFuZG92ZXJfd3NjKHNlbGYucmVjZWl2ZWRfY2Fycmllciwgc2VsZi5zZW50X2NhcnJpZXIsICJSRVNQIik6CisgICAgICAgICAgICAgICAgICAgIHN1Y2Nlc3NfcmVwb3J0KCJXU0MgaGFuZG92ZXIgcmVwb3J0ZWQgc3VjY2Vzc2Z1bGx5IikKKyAgICAgICAgICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAgICAgICBzdW1tYXJ5KCJXU0MgaGFuZG92ZXIgcmVwb3J0IHJlamVjdGVkIikKKyAgICAgICAgICAgICAgICAgICAgYnJlYWsKKworICAgICAgICAgICAgICAgIG1lc3NhZ2UgPSBuZmMubmRlZi5NZXNzYWdlKGRhdGEpOworICAgICAgICAgICAgICAgIHNlbC5hZGRfY2FycmllcihtZXNzYWdlWzBdLCAiYWN0aXZlIiwgbWVzc2FnZVsxOl0pCisgICAgICAgICAgICAgICAgZm91bmQgPSBUcnVlCisgICAgICAgICAgICAgICAgYnJlYWsKKworICAgICAgICBwcmludCAiSGFuZG92ZXIgc2VsZWN0OiIKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgcHJpbnQgc2VsLnByZXR0eSgpCisgICAgICAgIGV4Y2VwdCBFeGNlcHRpb24sIGU6CisgICAgICAgICAgICBwcmludCBlCisgICAgICAgIHByaW50IHN0cihzZWwpLmVuY29kZSgiaGV4IikKKworICAgICAgICBzdW1tYXJ5KCJTZW5kaW5nIGhhbmRvdmVyIHNlbGVjdCIpCisgICAgICAgIHNlbGYuc3VjY2VzcyA9IFRydWUKKyAgICAgICAgcmV0dXJuIHNlbAorCisKK2RlZiBjbGVhcl9yYXdfbW9kZSgpOgorICAgIGltcG9ydCBzeXMsIHR0eSwgdGVybWlvcworICAgIGdsb2JhbCBwcmV2X3RjZ2V0YXR0ciwgaW5fcmF3X21vZGUKKyAgICBpZiBub3QgaW5fcmF3X21vZGU6CisgICAgICAgIHJldHVybgorICAgIGZkID0gc3lzLnN0ZGluLmZpbGVubygpCisgICAgdGVybWlvcy50Y3NldGF0dHIoZmQsIHRlcm1pb3MuVENTQURSQUlOLCBwcmV2X3RjZ2V0YXR0cikKKyAgICBpbl9yYXdfbW9kZSA9IEZhbHNlCisKKworZGVmIGdldGNoKCk6CisgICAgaW1wb3J0IHN5cywgdHR5LCB0ZXJtaW9zLCBzZWxlY3QKKyAgICBnbG9iYWwgcHJldl90Y2dldGF0dHIsIGluX3Jhd19tb2RlCisgICAgZmQgPSBzeXMuc3RkaW4uZmlsZW5vKCkKKyAgICBwcmV2X3RjZ2V0YXR0ciA9IHRlcm1pb3MudGNnZXRhdHRyKGZkKQorICAgIGNoID0gTm9uZQorICAgIHRyeToKKyAgICAgICAgdHR5LnNldHJhdyhmZCkKKyAgICAgICAgaW5fcmF3X21vZGUgPSBUcnVlCisgICAgICAgIFtpLCBvLCBlXSA9IHNlbGVjdC5zZWxlY3QoW2ZkXSwgW10sIFtdLCAwLjA1KQorICAgICAgICBpZiBpOgorICAgICAgICAgICAgY2ggPSBzeXMuc3RkaW4ucmVhZCgxKQorICAgIGZpbmFsbHk6CisgICAgICAgIHRlcm1pb3MudGNzZXRhdHRyKGZkLCB0ZXJtaW9zLlRDU0FEUkFJTiwgcHJldl90Y2dldGF0dHIpCisgICAgICAgIGluX3Jhd19tb2RlID0gRmFsc2UKKyAgICByZXR1cm4gY2gKKworCitkZWYgcDJwX3RhZ19yZWFkKHRhZyk6CisgICAgc3VjY2VzcyA9IEZhbHNlCisgICAgaWYgbGVuKHRhZy5uZGVmLm1lc3NhZ2UpOgorICAgICAgICBmb3IgcmVjb3JkIGluIHRhZy5uZGVmLm1lc3NhZ2U6CisgICAgICAgICAgICBwcmludCAicmVjb3JkIHR5cGUgIiArIHJlY29yZC50eXBlCisgICAgICAgICAgICBpZiByZWNvcmQudHlwZSA9PSAiYXBwbGljYXRpb24vdm5kLndmYS53c2MiOgorICAgICAgICAgICAgICAgIHN1bW1hcnkoIldQUyB0YWcgLSBzZW5kIHRvIHdwYV9zdXBwbGljYW50IikKKyAgICAgICAgICAgICAgICBzdWNjZXNzID0gd3Bhc190YWdfcmVhZCh0YWcubmRlZi5tZXNzYWdlKQorICAgICAgICAgICAgICAgIGJyZWFrCisgICAgICAgICAgICBpZiByZWNvcmQudHlwZSA9PSAiYXBwbGljYXRpb24vdm5kLndmYS5wMnAiOgorICAgICAgICAgICAgICAgIHN1bW1hcnkoIlAyUCB0YWcgLSBzZW5kIHRvIHdwYV9zdXBwbGljYW50IikKKyAgICAgICAgICAgICAgICBzdWNjZXNzID0gd3Bhc190YWdfcmVhZCh0YWcubmRlZi5tZXNzYWdlKQorICAgICAgICAgICAgICAgIGJyZWFrCisgICAgZWxzZToKKyAgICAgICAgc3VtbWFyeSgiRW1wdHkgdGFnIikKKworICAgIGlmIHN1Y2Nlc3M6CisgICAgICAgIHN1Y2Nlc3NfcmVwb3J0KCJUYWcgcmVhZCBzdWNjZWVkZWQiKQorCisgICAgcmV0dXJuIHN1Y2Nlc3MKKworCitkZWYgcmR3cl9jb25uZWN0ZWRfcDJwX3dyaXRlKHRhZyk6CisgICAgc3VtbWFyeSgiVGFnIGZvdW5kIC0gd3JpdGluZyAtICIgKyBzdHIodGFnKSkKKyAgICBnbG9iYWwgcDJwX3NlbF9kYXRhCisgICAgdGFnLm5kZWYubWVzc2FnZSA9IHN0cihwMnBfc2VsX2RhdGEpCisgICAgc3VjY2Vzc19yZXBvcnQoIlRhZyB3cml0ZSBzdWNjZWVkZWQiKQorICAgIHByaW50ICJEb25lIC0gcmVtb3ZlIHRhZyIKKyAgICBnbG9iYWwgb25seV9vbmUKKyAgICBpZiBvbmx5X29uZToKKyAgICAgICAgZ2xvYmFsIGNvbnRpbnVlX2xvb3AKKyAgICAgICAgY29udGludWVfbG9vcCA9IEZhbHNlCisgICAgZ2xvYmFsIHAycF9zZWxfd2FpdF9yZW1vdmUKKyAgICByZXR1cm4gcDJwX3NlbF93YWl0X3JlbW92ZQorCitkZWYgd3BzX3dyaXRlX3AycF9oYW5kb3Zlcl9zZWwoY2xmLCB3YWl0X3JlbW92ZT1UcnVlKToKKyAgICBwcmludCAiV3JpdGUgUDJQIGhhbmRvdmVyIHNlbGVjdCIKKyAgICBkYXRhID0gd3Bhc19nZXRfaGFuZG92ZXJfc2VsKHRhZz1UcnVlKQorICAgIGlmIChkYXRhID09IE5vbmUpOgorICAgICAgICBzdW1tYXJ5KCJDb3VsZCBub3QgZ2V0IFAyUCBoYW5kb3ZlciBzZWxlY3QgZnJvbSB3cGFfc3VwcGxpY2FudCIpCisgICAgICAgIHJldHVybgorCisgICAgZ2xvYmFsIHAycF9zZWxfd2FpdF9yZW1vdmUKKyAgICBwMnBfc2VsX3dhaXRfcmVtb3ZlID0gd2FpdF9yZW1vdmUKKyAgICBnbG9iYWwgcDJwX3NlbF9kYXRhCisgICAgcDJwX3NlbF9kYXRhID0gbmZjLm5kZWYuSGFuZG92ZXJTZWxlY3RNZXNzYWdlKHZlcnNpb249IjEuMiIpCisgICAgbWVzc2FnZSA9IG5mYy5uZGVmLk1lc3NhZ2UoZGF0YSk7CisgICAgcDJwX3NlbF9kYXRhLmFkZF9jYXJyaWVyKG1lc3NhZ2VbMF0sICJhY3RpdmUiLCBtZXNzYWdlWzE6XSkKKyAgICBwcmludCAiSGFuZG92ZXIgc2VsZWN0OiIKKyAgICB0cnk6CisgICAgICAgIHByaW50IHAycF9zZWxfZGF0YS5wcmV0dHkoKQorICAgIGV4Y2VwdCBFeGNlcHRpb24sIGU6CisgICAgICAgIHByaW50IGUKKyAgICBwcmludCBzdHIocDJwX3NlbF9kYXRhKS5lbmNvZGUoImhleCIpCisKKyAgICBwcmludCAiVG91Y2ggYW4gTkZDIHRhZyIKKyAgICBjbGYuY29ubmVjdChyZHdyPXsnb24tY29ubmVjdCc6IHJkd3JfY29ubmVjdGVkX3AycF93cml0ZX0pCisKKworZGVmIHJkd3JfY29ubmVjdGVkKHRhZyk6CisgICAgZ2xvYmFsIG9ubHlfb25lLCBub193YWl0CisgICAgc3VtbWFyeSgiVGFnIGNvbm5lY3RlZDogIiArIHN0cih0YWcpKQorCisgICAgaWYgdGFnLm5kZWY6CisgICAgICAgIHByaW50ICJOREVGIHRhZzogIiArIHRhZy50eXBlCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHByaW50IHRhZy5uZGVmLm1lc3NhZ2UucHJldHR5KCkKKyAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgICAgIHByaW50IGUKKyAgICAgICAgc3VjY2VzcyA9IHAycF90YWdfcmVhZCh0YWcpCisgICAgICAgIGlmIG9ubHlfb25lIGFuZCBzdWNjZXNzOgorICAgICAgICAgICAgZ2xvYmFsIGNvbnRpbnVlX2xvb3AKKyAgICAgICAgICAgIGNvbnRpbnVlX2xvb3AgPSBGYWxzZQorICAgIGVsc2U6CisgICAgICAgIHN1bW1hcnkoIk5vdCBhbiBOREVGIHRhZyAtIHJlbW92ZSB0YWciKQorICAgICAgICByZXR1cm4gVHJ1ZQorCisgICAgcmV0dXJuIG5vdCBub193YWl0CisKKworZGVmIGxsY3Bfd29ya2VyKGxsYyk6CisgICAgZ2xvYmFsIGluaXRfb25fdG91Y2gKKyAgICBpZiBpbml0X29uX3RvdWNoOgorICAgICAgICAgICAgcHJpbnQgIlN0YXJ0aW5nIGhhbmRvdmVyIGNsaWVudCIKKyAgICAgICAgICAgIHAycF9oYW5kb3Zlcl9jbGllbnQobGxjKQorICAgICAgICAgICAgcmV0dXJuCisKKyAgICBnbG9iYWwgbm9faW5wdXQKKyAgICBpZiBub19pbnB1dDoKKyAgICAgICAgcHJpbnQgIldhaXQgZm9yIGhhbmRvdmVyIHRvIGNvbXBsZXRlIgorICAgIGVsc2U6CisgICAgICAgIHByaW50ICJXYWl0IGZvciBoYW5kb3ZlciB0byBjb21wbGV0ZSAtIHByZXNzICdpJyB0byBpbml0aWF0ZSAoJ3cnIGZvciBXUFMgb25seSwgJ3AnIGZvciBQMlAgb25seSkiCisgICAgZ2xvYmFsIHNydgorICAgIGdsb2JhbCB3YWl0X2Nvbm5lY3Rpb24KKyAgICB3aGlsZSBub3Qgd2FpdF9jb25uZWN0aW9uIGFuZCBzcnYuc2VudF9jYXJyaWVyIGlzIE5vbmU6CisgICAgICAgIGlmIHNydi5ob19zZXJ2ZXJfcHJvY2Vzc2luZzoKKyAgICAgICAgICAgIHRpbWUuc2xlZXAoMC4wMjUpCisgICAgICAgIGVsaWYgbm9faW5wdXQ6CisgICAgICAgICAgICB0aW1lLnNsZWVwKDAuNSkKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIGdsb2JhbCBpbmNsdWRlX3dwc19yZXEsIGluY2x1ZGVfcDJwX3JlcQorICAgICAgICAgICAgcmVzID0gZ2V0Y2goKQorICAgICAgICAgICAgaWYgcmVzID09ICdpJzoKKyAgICAgICAgICAgICAgICBpbmNsdWRlX3dwc19yZXEgPSBUcnVlCisgICAgICAgICAgICAgICAgaW5jbHVkZV9wMnBfcmVxID0gVHJ1ZQorICAgICAgICAgICAgZWxpZiByZXMgPT0gJ3AnOgorICAgICAgICAgICAgICAgIGluY2x1ZGVfd3BzX3JlcSA9IEZhbHNlCisgICAgICAgICAgICAgICAgaW5jbHVkZV9wMnBfcmVxID0gVHJ1ZQorICAgICAgICAgICAgZWxpZiByZXMgPT0gJ3cnOgorICAgICAgICAgICAgICAgIGluY2x1ZGVfd3BzX3JlcSA9IFRydWUKKyAgICAgICAgICAgICAgICBpbmNsdWRlX3AycF9yZXEgPSBGYWxzZQorICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICBjb250aW51ZQorICAgICAgICAgICAgY2xlYXJfcmF3X21vZGUoKQorICAgICAgICAgICAgcHJpbnQgIlN0YXJ0aW5nIGhhbmRvdmVyIGNsaWVudCIKKyAgICAgICAgICAgIHAycF9oYW5kb3Zlcl9jbGllbnQobGxjKQorICAgICAgICAgICAgcmV0dXJuCisgICAgICAgICAgICAKKyAgICBjbGVhcl9yYXdfbW9kZSgpCisgICAgcHJpbnQgIkV4aXRpbmcgbGxjcF93b3JrZXIgdGhyZWFkIgorCitkZWYgbGxjcF9zdGFydHVwKGNsZiwgbGxjKToKKyAgICBwcmludCAiU3RhcnQgTExDUCBzZXJ2ZXIiCisgICAgZ2xvYmFsIHNydgorICAgIHNydiA9IEhhbmRvdmVyU2VydmVyKGxsYykKKyAgICByZXR1cm4gbGxjCisKK2RlZiBsbGNwX2Nvbm5lY3RlZChsbGMpOgorICAgIHByaW50ICJQMlAgTExDUCBjb25uZWN0ZWQiCisgICAgZ2xvYmFsIHdhaXRfY29ubmVjdGlvbgorICAgIHdhaXRfY29ubmVjdGlvbiA9IEZhbHNlCisgICAgZ2xvYmFsIGluaXRfb25fdG91Y2gKKyAgICBpZiBub3QgaW5pdF9vbl90b3VjaDoKKyAgICAgICAgZ2xvYmFsIHNydgorICAgICAgICBzcnYuc3RhcnQoKQorICAgIGlmIGluaXRfb25fdG91Y2ggb3Igbm90IG5vX2lucHV0OgorICAgICAgICB0aHJlYWRpbmcuVGhyZWFkKHRhcmdldD1sbGNwX3dvcmtlciwgYXJncz0obGxjLCkpLnN0YXJ0KCkKKyAgICByZXR1cm4gVHJ1ZQorCitkZWYgdGVybWluYXRlX2xvb3AoKToKKyAgICBnbG9iYWwgdGVybWluYXRlX25vdworICAgIHJldHVybiB0ZXJtaW5hdGVfbm93CisKK2RlZiBtYWluKCk6CisgICAgY2xmID0gbmZjLkNvbnRhY3RsZXNzRnJvbnRlbmQoKQorCisgICAgcGFyc2VyID0gYXJncGFyc2UuQXJndW1lbnRQYXJzZXIoZGVzY3JpcHRpb249J25mY3B5IHRvIHdwYV9zdXBwbGljYW50IGludGVncmF0aW9uIGZvciBQMlAgYW5kIFdQUyBORkMgb3BlcmF0aW9ucycpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLWQnLCBjb25zdD1sb2dnaW5nLkRFQlVHLCBkZWZhdWx0PWxvZ2dpbmcuSU5GTywKKyAgICAgICAgICAgICAgICAgICAgICAgIGFjdGlvbj0nc3RvcmVfY29uc3QnLCBkZXN0PSdsb2dsZXZlbCcsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSd2ZXJib3NlIGRlYnVnIG91dHB1dCcpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLXEnLCBjb25zdD1sb2dnaW5nLldBUk5JTkcsIGFjdGlvbj0nc3RvcmVfY29uc3QnLAorICAgICAgICAgICAgICAgICAgICAgICAgZGVzdD0nbG9nbGV2ZWwnLCBoZWxwPSdiZSBxdWlldCcpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1vbmx5LW9uZScsICctMScsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdydW4gb25seSBvbmUgb3BlcmF0aW9uIGFuZCBleGl0JykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLWluaXQtb24tdG91Y2gnLCAnLUknLCBhY3Rpb249J3N0b3JlX3RydWUnLAorICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0naW5pdGlhdGUgaGFuZG92ZXIgb24gdG91Y2gnKQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tbm8td2FpdCcsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdkbyBub3Qgd2FpdCBmb3IgdGFnIHRvIGJlIHJlbW92ZWQgYmVmb3JlIGV4aXRpbmcnKQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0taWZuYW1lJywgJy1pJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J25ldHdvcmsgaW50ZXJmYWNlIG5hbWUnKQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tbm8td3BzLXJlcScsICctTicsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdkbyBub3QgaW5jbHVkZSBXUFMgY2FycmllciByZWNvcmQgaW4gcmVxdWVzdCcpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1uby1pbnB1dCcsICctYScsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdkbyBub3QgdXNlIHN0ZG91dCBpbnB1dCB0byBpbml0aWF0ZSBoYW5kb3ZlcicpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS10YWctcmVhZC1vbmx5JywgJy10JywgYWN0aW9uPSdzdG9yZV90cnVlJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3RhZyByZWFkIG9ubHkgKGRvIG5vdCBhbGxvdyBjb25uZWN0aW9uIGhhbmRvdmVyKScpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1oYW5kb3Zlci1vbmx5JywgYWN0aW9uPSdzdG9yZV90cnVlJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Nvbm5lY3Rpb24gaGFuZG92ZXIgb25seSAoZG8gbm90IGFsbG93IHRhZyByZWFkKScpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1mcmVxJywgJy1mJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2ZvcmNlZCBmcmVxdWVuY3kgb2Ygb3BlcmF0aW5nIGNoYW5uZWwgaW4gTUh6JykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLXN1bW1hcnknLAorICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nc3VtbWFyeSBmaWxlIGZvciB3cml0aW5nIHN0YXR1cyB1cGRhdGVzJykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLXN1Y2Nlc3MnLAorICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nc3VjY2VzcyBmaWxlIGZvciB3cml0aW5nIHN1Y2Nlc3MgdXBkYXRlJykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCdjb21tYW5kJywgY2hvaWNlcz1bJ3dyaXRlLXAycC1zZWwnXSwKKyAgICAgICAgICAgICAgICAgICAgICAgIG5hcmdzPSc/JykKKyAgICBhcmdzID0gcGFyc2VyLnBhcnNlX2FyZ3MoKQorCisgICAgZ2xvYmFsIG9ubHlfb25lCisgICAgb25seV9vbmUgPSBhcmdzLm9ubHlfb25lCisKKyAgICBnbG9iYWwgbm9fd2FpdAorICAgIG5vX3dhaXQgPSBhcmdzLm5vX3dhaXQKKworICAgIGdsb2JhbCBmb3JjZV9mcmVxCisgICAgZm9yY2VfZnJlcSA9IGFyZ3MuZnJlcQorCisgICAgbG9nZ2luZy5iYXNpY0NvbmZpZyhsZXZlbD1hcmdzLmxvZ2xldmVsKQorCisgICAgZ2xvYmFsIGluaXRfb25fdG91Y2gKKyAgICBpbml0X29uX3RvdWNoID0gYXJncy5pbml0X29uX3RvdWNoCisKKyAgICBpZiBhcmdzLmlmbmFtZToKKyAgICAgICAgZ2xvYmFsIGlmbmFtZQorICAgICAgICBpZm5hbWUgPSBhcmdzLmlmbmFtZQorICAgICAgICBwcmludCAiU2VsZWN0ZWQgaWZuYW1lICIgKyBpZm5hbWUKKworICAgIGlmIGFyZ3Mubm9fd3BzX3JlcToKKyAgICAgICAgZ2xvYmFsIGluY2x1ZGVfd3BzX3JlcQorICAgICAgICBpbmNsdWRlX3dwc19yZXEgPSBGYWxzZQorCisgICAgaWYgYXJncy5zdW1tYXJ5OgorICAgICAgICBnbG9iYWwgc3VtbWFyeV9maWxlCisgICAgICAgIHN1bW1hcnlfZmlsZSA9IGFyZ3Muc3VtbWFyeQorCisgICAgaWYgYXJncy5zdWNjZXNzOgorICAgICAgICBnbG9iYWwgc3VjY2Vzc19maWxlCisgICAgICAgIHN1Y2Nlc3NfZmlsZSA9IGFyZ3Muc3VjY2VzcworCisgICAgaWYgYXJncy5ub19pbnB1dDoKKyAgICAgICAgZ2xvYmFsIG5vX2lucHV0CisgICAgICAgIG5vX2lucHV0ID0gVHJ1ZQorCisgICAgY2xmID0gbmZjLkNvbnRhY3RsZXNzRnJvbnRlbmQoKQorICAgIGdsb2JhbCB3YWl0X2Nvbm5lY3Rpb24KKworICAgIHRyeToKKyAgICAgICAgaWYgbm90IGNsZi5vcGVuKCJ1c2IiKToKKyAgICAgICAgICAgIHByaW50ICJDb3VsZCBub3Qgb3BlbiBjb25uZWN0aW9uIHdpdGggYW4gTkZDIGRldmljZSIKKyAgICAgICAgICAgIHJhaXNlIFN5c3RlbUV4aXQKKworICAgICAgICBpZiBhcmdzLmNvbW1hbmQgPT0gIndyaXRlLXAycC1zZWwiOgorICAgICAgICAgICAgd3BzX3dyaXRlX3AycF9oYW5kb3Zlcl9zZWwoY2xmLCB3YWl0X3JlbW92ZT1ub3QgYXJncy5ub193YWl0KQorICAgICAgICAgICAgcmFpc2UgU3lzdGVtRXhpdAorCisgICAgICAgIGdsb2JhbCBjb250aW51ZV9sb29wCisgICAgICAgIHdoaWxlIGNvbnRpbnVlX2xvb3A6CisgICAgICAgICAgICBwcmludCAiV2FpdGluZyBmb3IgYSB0YWcgb3IgcGVlciB0byBiZSB0b3VjaGVkIgorICAgICAgICAgICAgd2FpdF9jb25uZWN0aW9uID0gVHJ1ZQorICAgICAgICAgICAgdHJ5OgorICAgICAgICAgICAgICAgIGlmIGFyZ3MudGFnX3JlYWRfb25seToKKyAgICAgICAgICAgICAgICAgICAgaWYgbm90IGNsZi5jb25uZWN0KHJkd3I9eydvbi1jb25uZWN0JzogcmR3cl9jb25uZWN0ZWR9KToKKyAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrCisgICAgICAgICAgICAgICAgZWxpZiBhcmdzLmhhbmRvdmVyX29ubHk6CisgICAgICAgICAgICAgICAgICAgIGlmIG5vdCBjbGYuY29ubmVjdChsbGNwPXsnb24tc3RhcnR1cCc6IGxsY3Bfc3RhcnR1cCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdvbi1jb25uZWN0JzogbGxjcF9jb25uZWN0ZWR9LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGVybWluYXRlPXRlcm1pbmF0ZV9sb29wKToKKyAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrCisgICAgICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICAgICAgaWYgbm90IGNsZi5jb25uZWN0KHJkd3I9eydvbi1jb25uZWN0JzogcmR3cl9jb25uZWN0ZWR9LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbGxjcD17J29uLXN0YXJ0dXAnOiBsbGNwX3N0YXJ0dXAsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnb24tY29ubmVjdCc6IGxsY3BfY29ubmVjdGVkfSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlcm1pbmF0ZT10ZXJtaW5hdGVfbG9vcCk6CisgICAgICAgICAgICAgICAgICAgICAgICBicmVhaworICAgICAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgICAgICAgICBwcmludCAiY2xmLmNvbm5lY3QgZmFpbGVkIgorCisgICAgICAgICAgICBnbG9iYWwgc3J2CisgICAgICAgICAgICBpZiBvbmx5X29uZSBhbmQgc3J2IGFuZCBzcnYuc3VjY2VzczoKKyAgICAgICAgICAgICAgICByYWlzZSBTeXN0ZW1FeGl0CisKKyAgICBleGNlcHQgS2V5Ym9hcmRJbnRlcnJ1cHQ6CisgICAgICAgIHJhaXNlIFN5c3RlbUV4aXQKKyAgICBmaW5hbGx5OgorICAgICAgICBjbGYuY2xvc2UoKQorCisgICAgcmFpc2UgU3lzdGVtRXhpdAorCitpZiBfX25hbWVfXyA9PSAnX19tYWluX18nOgorICAgIG1haW4oKQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZXhhbXBsZXMvd3BzLW5mYy5weSBiL3dwYV9zdXBwbGljYW50L2V4YW1wbGVzL3dwcy1uZmMucHkKaW5kZXggZDZkZWM4NS4uNzQ1OWViOSAxMDA3NTUKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZXhhbXBsZXMvd3BzLW5mYy5weQorKysgYi93cGFfc3VwcGxpY2FudC9leGFtcGxlcy93cHMtbmZjLnB5CkBAIC0xMCw3ICsxMCw4IEBACiBpbXBvcnQgc3lzCiBpbXBvcnQgdGltZQogaW1wb3J0IHJhbmRvbQotaW1wb3J0IFN0cmluZ0lPCitpbXBvcnQgdGhyZWFkaW5nCitpbXBvcnQgYXJncGFyc2UKIAogaW1wb3J0IG5mYwogaW1wb3J0IG5mYy5uZGVmCkBAIC0xOCwxMSArMTksMjcgQEAKIGltcG9ydCBuZmMuaGFuZG92ZXIKIAogaW1wb3J0IGxvZ2dpbmcKLWxvZ2dpbmcuYmFzaWNDb25maWcoKQogCiBpbXBvcnQgd3Bhc3B5CiAKIHdwYXNfY3RybCA9ICcvdmFyL3J1bi93cGFfc3VwcGxpY2FudCcKK3NydiA9IE5vbmUKK2NvbnRpbnVlX2xvb3AgPSBUcnVlCit0ZXJtaW5hdGVfbm93ID0gRmFsc2UKK3N1bW1hcnlfZmlsZSA9IE5vbmUKK3N1Y2Nlc3NfZmlsZSA9IE5vbmUKKworZGVmIHN1bW1hcnkodHh0KToKKyAgICBwcmludCB0eHQKKyAgICBpZiBzdW1tYXJ5X2ZpbGU6CisgICAgICAgIHdpdGggb3BlbihzdW1tYXJ5X2ZpbGUsICdhJykgYXMgZjoKKyAgICAgICAgICAgIGYud3JpdGUodHh0ICsgIlxuIikKKworZGVmIHN1Y2Nlc3NfcmVwb3J0KHR4dCk6CisgICAgc3VtbWFyeSh0eHQpCisgICAgaWYgc3VjY2Vzc19maWxlOgorICAgICAgICB3aXRoIG9wZW4oc3VjY2Vzc19maWxlLCAnYScpIGFzIGY6CisgICAgICAgICAgICBmLndyaXRlKHR4dCArICJcbiIpCiAKIGRlZiB3cGFzX2Nvbm5lY3QoKToKICAgICBpZmFjZXMgPSBbXQpAQCAtNTAsNyArNjcsNyBAQAogICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQogICAgIGlmICh3cGFzID09IE5vbmUpOgogICAgICAgICByZXR1cm4gRmFsc2UKLSAgICBpZiAiRkFJTCIgaW4gd3Bhcy5yZXF1ZXN0KCJXUFNfTkZDX1RBR19SRUFEICIgKyBtZXNzYWdlLmVuY29kZSgiaGV4IikpOgorICAgIGlmICJGQUlMIiBpbiB3cGFzLnJlcXVlc3QoIldQU19ORkNfVEFHX1JFQUQgIiArIHN0cihtZXNzYWdlKS5lbmNvZGUoImhleCIpKToKICAgICAgICAgcmV0dXJuIEZhbHNlCiAgICAgcmV0dXJuIFRydWUKIApAQCAtNzEsMjEgKzg4LDI5IEBACiAgICAgd3BhcyA9IHdwYXNfY29ubmVjdCgpCiAgICAgaWYgKHdwYXMgPT0gTm9uZSk6CiAgICAgICAgIHJldHVybiBOb25lCi0gICAgcmV0dXJuIHdwYXMucmVxdWVzdCgiV1BTX0VSX05GQ19DT05GSUdfVE9LRU4gTkRFRiAiICsgdXVpZCkucnN0cmlwKCkuZGVjb2RlKCJoZXgiKQorICAgIHJldCA9IHdwYXMucmVxdWVzdCgiV1BTX0VSX05GQ19DT05GSUdfVE9LRU4gTkRFRiAiICsgdXVpZCkKKyAgICBpZiAiRkFJTCIgaW4gcmV0OgorICAgICAgICByZXR1cm4gTm9uZQorICAgIHJldHVybiByZXQucnN0cmlwKCkuZGVjb2RlKCJoZXgiKQogCiAKIGRlZiB3cGFzX2dldF9wYXNzd29yZF90b2tlbigpOgogICAgIHdwYXMgPSB3cGFzX2Nvbm5lY3QoKQogICAgIGlmICh3cGFzID09IE5vbmUpOgogICAgICAgICByZXR1cm4gTm9uZQotICAgIHJldHVybiB3cGFzLnJlcXVlc3QoIldQU19ORkNfVE9LRU4gTkRFRiIpLnJzdHJpcCgpLmRlY29kZSgiaGV4IikKLQorICAgIHJldCA9IHdwYXMucmVxdWVzdCgiV1BTX05GQ19UT0tFTiBOREVGIikKKyAgICBpZiAiRkFJTCIgaW4gcmV0OgorICAgICAgICByZXR1cm4gTm9uZQorICAgIHJldHVybiByZXQucnN0cmlwKCkuZGVjb2RlKCJoZXgiKQogCiBkZWYgd3Bhc19nZXRfaGFuZG92ZXJfcmVxKCk6CiAgICAgd3BhcyA9IHdwYXNfY29ubmVjdCgpCiAgICAgaWYgKHdwYXMgPT0gTm9uZSk6CiAgICAgICAgIHJldHVybiBOb25lCi0gICAgcmV0dXJuIHdwYXMucmVxdWVzdCgiTkZDX0dFVF9IQU5ET1ZFUl9SRVEgTkRFRiBXUFMtQ1IiKS5yc3RyaXAoKS5kZWNvZGUoImhleCIpCisgICAgcmV0ID0gd3Bhcy5yZXF1ZXN0KCJORkNfR0VUX0hBTkRPVkVSX1JFUSBOREVGIFdQUy1DUiIpCisgICAgaWYgIkZBSUwiIGluIHJldDoKKyAgICAgICAgcmV0dXJuIE5vbmUKKyAgICByZXR1cm4gcmV0LnJzdHJpcCgpLmRlY29kZSgiaGV4IikKIAogCiBkZWYgd3Bhc19nZXRfaGFuZG92ZXJfc2VsKHV1aWQpOgpAQCAtOTMsOCArMTE4LDEyIEBACiAgICAgaWYgKHdwYXMgPT0gTm9uZSk6CiAgICAgICAgIHJldHVybiBOb25lCiAgICAgaWYgdXVpZCBpcyBOb25lOgotICAgICAgICByZXR1cm4gd3Bhcy5yZXF1ZXN0KCJORkNfR0VUX0hBTkRPVkVSX1NFTCBOREVGIFdQUy1DUiIpLnJzdHJpcCgpLmRlY29kZSgiaGV4IikKLSAgICByZXR1cm4gd3Bhcy5yZXF1ZXN0KCJORkNfR0VUX0hBTkRPVkVSX1NFTCBOREVGIFdQUy1DUiAiICsgdXVpZCkucnN0cmlwKCkuZGVjb2RlKCJoZXgiKQorICAgICAgICByZXMgPSB3cGFzLnJlcXVlc3QoIk5GQ19HRVRfSEFORE9WRVJfU0VMIE5ERUYgV1BTLUNSIikucnN0cmlwKCkKKyAgICBlbHNlOgorCXJlcyA9IHdwYXMucmVxdWVzdCgiTkZDX0dFVF9IQU5ET1ZFUl9TRUwgTkRFRiBXUFMtQ1IgIiArIHV1aWQpLnJzdHJpcCgpCisgICAgaWYgIkZBSUwiIGluIHJlczoKKwlyZXR1cm4gTm9uZQorICAgIHJldHVybiByZXMuZGVjb2RlKCJoZXgiKQogCiAKIGRlZiB3cGFzX3JlcG9ydF9oYW5kb3ZlcihyZXEsIHNlbCwgdHlwZSk6CkBAIC0xMDcsMTU5ICsxMzYsMTc2IEBACiAKIAogY2xhc3MgSGFuZG92ZXJTZXJ2ZXIobmZjLmhhbmRvdmVyLkhhbmRvdmVyU2VydmVyKToKLSAgICBkZWYgX19pbml0X18oc2VsZik6Ci0gICAgICAgIHN1cGVyKEhhbmRvdmVyU2VydmVyLCBzZWxmKS5fX2luaXRfXygpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIGxsYyk6CisgICAgICAgIHN1cGVyKEhhbmRvdmVyU2VydmVyLCBzZWxmKS5fX2luaXRfXyhsbGMpCisgICAgICAgIHNlbGYuc2VudF9jYXJyaWVyID0gTm9uZQorICAgICAgICBzZWxmLmhvX3NlcnZlcl9wcm9jZXNzaW5nID0gRmFsc2UKKyAgICAgICAgc2VsZi5zdWNjZXNzID0gRmFsc2UKKworICAgICMgb3ZlcnJpZGUgdG8gYXZvaWQgcGFyc2VyIGVycm9yIGluIHJlcXVlc3QvcmVzcG9uc2UucHJldHR5KCkgaW4gbmZjcHkKKyAgICAjIGR1ZSB0byBuZXcgV1NDIGhhbmRvdmVyIGZvcm1hdAorICAgIGRlZiBfcHJvY2Vzc19yZXF1ZXN0KHNlbGYsIHJlcXVlc3QpOgorICAgICAgICBzdW1tYXJ5KCJyZWNlaXZlZCBoYW5kb3ZlciByZXF1ZXN0IHt9Ii5mb3JtYXQocmVxdWVzdC50eXBlKSkKKyAgICAgICAgcmVzcG9uc2UgPSBuZmMubmRlZi5NZXNzYWdlKCJceGQxXHgwMlx4MDFIc1x4MTIiKQorICAgICAgICBpZiBub3QgcmVxdWVzdC50eXBlID09ICd1cm46bmZjOndrdDpIcic6CisgICAgICAgICAgICBzdW1tYXJ5KCJub3QgYSBoYW5kb3ZlciByZXF1ZXN0IikKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICByZXF1ZXN0ID0gbmZjLm5kZWYuSGFuZG92ZXJSZXF1ZXN0TWVzc2FnZShyZXF1ZXN0KQorICAgICAgICAgICAgZXhjZXB0IG5mYy5uZGVmLkRlY29kZUVycm9yIGFzIGU6CisgICAgICAgICAgICAgICAgc3VtbWFyeSgiZXJyb3IgZGVjb2RpbmcgJ0hyJyBtZXNzYWdlOiB7fSIuZm9ybWF0KGUpKQorICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICByZXNwb25zZSA9IHNlbGYucHJvY2Vzc19yZXF1ZXN0KHJlcXVlc3QpCisgICAgICAgIHN1bW1hcnkoInNlbmQgaGFuZG92ZXIgcmVzcG9uc2Uge30iLmZvcm1hdChyZXNwb25zZS50eXBlKSkKKyAgICAgICAgcmV0dXJuIHJlc3BvbnNlCiAKICAgICBkZWYgcHJvY2Vzc19yZXF1ZXN0KHNlbGYsIHJlcXVlc3QpOgotICAgICAgICBwcmludCAiSGFuZG92ZXJTZXJ2ZXIgLSByZXF1ZXN0IHJlY2VpdmVkIgotICAgICAgICBwcmludCAiUGFyc2VkIGhhbmRvdmVyIHJlcXVlc3Q6ICIgKyByZXF1ZXN0LnByZXR0eSgpCisgICAgICAgIHNlbGYuaG9fc2VydmVyX3Byb2Nlc3NpbmcgPSBUcnVlCisgICAgICAgIHN1bW1hcnkoIkhhbmRvdmVyU2VydmVyIC0gcmVxdWVzdCByZWNlaXZlZCIpCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHByaW50ICJQYXJzZWQgaGFuZG92ZXIgcmVxdWVzdDogIiArIHJlcXVlc3QucHJldHR5KCkKKyAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgICAgIHByaW50IGUKIAogICAgICAgICBzZWwgPSBuZmMubmRlZi5IYW5kb3ZlclNlbGVjdE1lc3NhZ2UodmVyc2lvbj0iMS4yIikKIAogICAgICAgICBmb3IgY2FycmllciBpbiByZXF1ZXN0LmNhcnJpZXJzOgogICAgICAgICAgICAgcHJpbnQgIlJlbW90ZSBjYXJyaWVyIHR5cGU6ICIgKyBjYXJyaWVyLnR5cGUKICAgICAgICAgICAgIGlmIGNhcnJpZXIudHlwZSA9PSAiYXBwbGljYXRpb24vdm5kLndmYS53c2MiOgotICAgICAgICAgICAgICAgIHByaW50ICJXUFMgY2FycmllciB0eXBlIG1hdGNoIC0gYWRkIFdQUyBjYXJyaWVyIHJlY29yZCIKLSAgICAgICAgICAgICAgICBzZWxmLnJlY2VpdmVkX2NhcnJpZXIgPSBjYXJyaWVyLnJlY29yZAorICAgICAgICAgICAgICAgIHN1bW1hcnkoIldQUyBjYXJyaWVyIHR5cGUgbWF0Y2ggLSBhZGQgV1BTIGNhcnJpZXIgcmVjb3JkIikKICAgICAgICAgICAgICAgICBkYXRhID0gd3Bhc19nZXRfaGFuZG92ZXJfc2VsKHNlbGYudXVpZCkKICAgICAgICAgICAgICAgICBpZiBkYXRhIGlzIE5vbmU6Ci0gICAgICAgICAgICAgICAgICAgIHByaW50ICJDb3VsZCBub3QgZ2V0IGhhbmRvdmVyIHNlbGVjdCBjYXJyaWVyIHJlY29yZCBmcm9tIHdwYV9zdXBwbGljYW50IgorICAgICAgICAgICAgICAgICAgICBzdW1tYXJ5KCJDb3VsZCBub3QgZ2V0IGhhbmRvdmVyIHNlbGVjdCBjYXJyaWVyIHJlY29yZCBmcm9tIHdwYV9zdXBwbGljYW50IikKICAgICAgICAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgICAgICBwcmludCAiSGFuZG92ZXIgc2VsZWN0IGNhcnJpZXIgcmVjb3JkIGZyb20gd3BhX3N1cHBsaWNhbnQ6IgogICAgICAgICAgICAgICAgIHByaW50IGRhdGEuZW5jb2RlKCJoZXgiKQogICAgICAgICAgICAgICAgIHNlbGYuc2VudF9jYXJyaWVyID0gZGF0YQorICAgICAgICAgICAgICAgIGlmICJPSyIgaW4gd3Bhc19yZXBvcnRfaGFuZG92ZXIoY2Fycmllci5yZWNvcmQsIHNlbGYuc2VudF9jYXJyaWVyLCAiUkVTUCIpOgorICAgICAgICAgICAgICAgICAgICBzdWNjZXNzX3JlcG9ydCgiSGFuZG92ZXIgcmVwb3J0ZWQgc3VjY2Vzc2Z1bGx5IChyZXNwb25kZXIpIikKKyAgICAgICAgICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAgICAgICBzdW1tYXJ5KCJIYW5kb3ZlciByZXBvcnQgcmVqZWN0ZWQgKHJlc3BvbmRlcikiKQogCiAgICAgICAgICAgICAgICAgbWVzc2FnZSA9IG5mYy5uZGVmLk1lc3NhZ2UoZGF0YSk7CiAgICAgICAgICAgICAgICAgc2VsLmFkZF9jYXJyaWVyKG1lc3NhZ2VbMF0sICJhY3RpdmUiLCBtZXNzYWdlWzE6XSkKIAogICAgICAgICBwcmludCAiSGFuZG92ZXIgc2VsZWN0OiIKLSAgICAgICAgcHJpbnQgc2VsLnByZXR0eSgpCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHByaW50IHNlbC5wcmV0dHkoKQorICAgICAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICAgICAgcHJpbnQgZQogICAgICAgICBwcmludCBzdHIoc2VsKS5lbmNvZGUoImhleCIpCiAKLSAgICAgICAgcHJpbnQgIlNlbmRpbmcgaGFuZG92ZXIgc2VsZWN0IgorICAgICAgICBzdW1tYXJ5KCJTZW5kaW5nIGhhbmRvdmVyIHNlbGVjdCIpCisgICAgICAgIHNlbGYuc3VjY2VzcyA9IFRydWUKICAgICAgICAgcmV0dXJuIHNlbAogCiAKLWRlZiB3cHNfaGFuZG92ZXJfcmVzcChwZWVyLCB1dWlkKToKLSAgICBpZiB1dWlkIGlzIE5vbmU6Ci0gICAgICAgIHByaW50ICJUcnlpbmcgdG8gaGFuZGxlIFdQUyBoYW5kb3ZlciIKLSAgICBlbHNlOgotICAgICAgICBwcmludCAiVHJ5aW5nIHRvIGhhbmRsZSBXUFMgaGFuZG92ZXIgd2l0aCBBUCAiICsgdXVpZAotCi0gICAgc3J2ID0gSGFuZG92ZXJTZXJ2ZXIoKQotICAgIHNydi5zZW50X2NhcnJpZXIgPSBOb25lCi0gICAgc3J2LnV1aWQgPSB1dWlkCi0KLSAgICBuZmMubGxjcC5hY3RpdmF0ZShwZWVyKTsKLQotICAgIHRyeToKLSAgICAgICAgcHJpbnQgIlRyeWluZyBoYW5kb3ZlciI7Ci0gICAgICAgIHNydi5zdGFydCgpCi0gICAgICAgIHByaW50ICJXYWl0IGZvciBkaXNjb25uZWN0IgotICAgICAgICB3aGlsZSBuZmMubGxjcC5jb25uZWN0ZWQoKToKLSAgICAgICAgICAgIHRpbWUuc2xlZXAoMC4xKQotICAgICAgICBwcmludCAiRGlzY29ubmVjdGVkIGFmdGVyIGhhbmRvdmVyIgotICAgIGV4Y2VwdCBuZmMubGxjcC5Db25uZWN0UmVmdXNlZDoKLSAgICAgICAgcHJpbnQgIkhhbmRvdmVyIGNvbm5lY3Rpb24gcmVmdXNlZCIKLSAgICAgICAgbmZjLmxsY3Auc2h1dGRvd24oKQotICAgICAgICByZXR1cm4KLQotICAgIGlmIHNydi5zZW50X2NhcnJpZXI6Ci0gICAgICAgIHdwYXNfcmVwb3J0X2hhbmRvdmVyKHNydi5yZWNlaXZlZF9jYXJyaWVyLCBzcnYuc2VudF9jYXJyaWVyLCAiUkVTUCIpCi0KLSAgICBwcmludCAiUmVtb3ZlIHBlZXIiCi0gICAgbmZjLmxsY3Auc2h1dGRvd24oKQotICAgIHByaW50ICJEb25lIHdpdGggaGFuZG92ZXIiCi0gICAgdGltZS5zbGVlcCgxKQotCi0KLWRlZiB3cHNfaGFuZG92ZXJfaW5pdChwZWVyKToKLSAgICBwcmludCAiVHJ5aW5nIHRvIGluaXRpYXRlIFdQUyBoYW5kb3ZlciIKK2RlZiB3cHNfaGFuZG92ZXJfaW5pdChsbGMpOgorICAgIHN1bW1hcnkoIlRyeWluZyB0byBpbml0aWF0ZSBXUFMgaGFuZG92ZXIiKQogCiAgICAgZGF0YSA9IHdwYXNfZ2V0X2hhbmRvdmVyX3JlcSgpCiAgICAgaWYgKGRhdGEgPT0gTm9uZSk6Ci0gICAgICAgIHByaW50ICJDb3VsZCBub3QgZ2V0IGhhbmRvdmVyIHJlcXVlc3QgY2FycmllciByZWNvcmQgZnJvbSB3cGFfc3VwcGxpY2FudCIKKyAgICAgICAgc3VtbWFyeSgiQ291bGQgbm90IGdldCBoYW5kb3ZlciByZXF1ZXN0IGNhcnJpZXIgcmVjb3JkIGZyb20gd3BhX3N1cHBsaWNhbnQiKQogICAgICAgICByZXR1cm4KICAgICBwcmludCAiSGFuZG92ZXIgcmVxdWVzdCBjYXJyaWVyIHJlY29yZCBmcm9tIHdwYV9zdXBwbGljYW50OiAiICsgZGF0YS5lbmNvZGUoImhleCIpCi0gICAgcmVjb3JkID0gbmZjLm5kZWYuUmVjb3JkKCkKLSAgICBmID0gU3RyaW5nSU8uU3RyaW5nSU8oZGF0YSkKLSAgICByZWNvcmQuX3JlYWQoZikKLSAgICByZWNvcmQgPSBuZmMubmRlZi5IYW5kb3ZlckNhcnJpZXJSZWNvcmQocmVjb3JkKQotICAgIHByaW50ICJQYXJzZWQgaGFuZG92ZXIgcmVxdWVzdCBjYXJyaWVyIHJlY29yZDoiCi0gICAgcHJpbnQgcmVjb3JkLnByZXR0eSgpCiAKICAgICBtZXNzYWdlID0gbmZjLm5kZWYuSGFuZG92ZXJSZXF1ZXN0TWVzc2FnZSh2ZXJzaW9uPSIxLjIiKQogICAgIG1lc3NhZ2Uubm9uY2UgPSByYW5kb20ucmFuZGludCgwLCAweGZmZmYpCi0gICAgbWVzc2FnZS5hZGRfY2FycmllcihyZWNvcmQsICJhY3RpdmUiKQorICAgIGRhdGFtc2cgPSBuZmMubmRlZi5NZXNzYWdlKGRhdGEpCisgICAgbWVzc2FnZS5hZGRfY2FycmllcihkYXRhbXNnWzBdLCAiYWN0aXZlIiwgZGF0YW1zZ1sxOl0pCiAKICAgICBwcmludCAiSGFuZG92ZXIgcmVxdWVzdDoiCi0gICAgcHJpbnQgbWVzc2FnZS5wcmV0dHkoKQotCi0gICAgbmZjLmxsY3AuYWN0aXZhdGUocGVlcik7Ci0KLSAgICBjbGllbnQgPSBuZmMuaGFuZG92ZXIuSGFuZG92ZXJDbGllbnQoKQogICAgIHRyeToKLSAgICAgICAgcHJpbnQgIlRyeWluZyBoYW5kb3ZlciI7CisgICAgICAgIHByaW50IG1lc3NhZ2UucHJldHR5KCkKKyAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICBwcmludCBlCisgICAgcHJpbnQgc3RyKG1lc3NhZ2UpLmVuY29kZSgiaGV4IikKKworICAgIGNsaWVudCA9IG5mYy5oYW5kb3Zlci5IYW5kb3ZlckNsaWVudChsbGMpCisgICAgdHJ5OgorICAgICAgICBzdW1tYXJ5KCJUcnlpbmcgdG8gaW5pdGlhdGUgTkZDIGNvbm5lY3Rpb24gaGFuZG92ZXIiKQogICAgICAgICBjbGllbnQuY29ubmVjdCgpCi0gICAgICAgIHByaW50ICJDb25uZWN0ZWQgZm9yIGhhbmRvdmVyIgorICAgICAgICBzdW1tYXJ5KCJDb25uZWN0ZWQgZm9yIGhhbmRvdmVyIikKICAgICBleGNlcHQgbmZjLmxsY3AuQ29ubmVjdFJlZnVzZWQ6Ci0gICAgICAgIHByaW50ICJIYW5kb3ZlciBjb25uZWN0aW9uIHJlZnVzZWQiCi0gICAgICAgIG5mYy5sbGNwLnNodXRkb3duKCkKKyAgICAgICAgc3VtbWFyeSgiSGFuZG92ZXIgY29ubmVjdGlvbiByZWZ1c2VkIikKKyAgICAgICAgY2xpZW50LmNsb3NlKCkKKyAgICAgICAgcmV0dXJuCisgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgc3VtbWFyeSgiT3RoZXIgZXhjZXB0aW9uOiAiICsgc3RyKGUpKQogICAgICAgICBjbGllbnQuY2xvc2UoKQogICAgICAgICByZXR1cm4KIAotICAgIHByaW50ICJTZW5kaW5nIGhhbmRvdmVyIHJlcXVlc3QiCisgICAgc3VtbWFyeSgiU2VuZGluZyBoYW5kb3ZlciByZXF1ZXN0IikKIAogICAgIGlmIG5vdCBjbGllbnQuc2VuZChtZXNzYWdlKToKLSAgICAgICAgcHJpbnQgIkZhaWxlZCB0byBzZW5kIGhhbmRvdmVyIHJlcXVlc3QiCisgICAgICAgIHN1bW1hcnkoIkZhaWxlZCB0byBzZW5kIGhhbmRvdmVyIHJlcXVlc3QiKQorICAgICAgICBjbGllbnQuY2xvc2UoKQorICAgICAgICByZXR1cm4KIAotICAgIHByaW50ICJSZWNlaXZpbmcgaGFuZG92ZXIgcmVzcG9uc2UiCisgICAgc3VtbWFyeSgiUmVjZWl2aW5nIGhhbmRvdmVyIHJlc3BvbnNlIikKICAgICBtZXNzYWdlID0gY2xpZW50Ll9yZWN2KCkKICAgICBpZiBtZXNzYWdlIGlzIE5vbmU6Ci0gICAgICAgIHByaW50ICJObyByZXNwb25zZSByZWNlaXZlZCIKLSAgICAgICAgbmZjLmxsY3Auc2h1dGRvd24oKQorICAgICAgICBzdW1tYXJ5KCJObyByZXNwb25zZSByZWNlaXZlZCIpCiAgICAgICAgIGNsaWVudC5jbG9zZSgpCiAgICAgICAgIHJldHVybgogICAgIGlmIG1lc3NhZ2UudHlwZSAhPSAidXJuOm5mYzp3a3Q6SHMiOgotICAgICAgICBwcmludCAiUmVzcG9uc2Ugd2FzIG5vdCBIcyAtIHJlY2VpdmVkOiAiICsgbWVzc2FnZS50eXBlCi0gICAgICAgIG5mYy5sbGNwLnNodXRkb3duKCkKKyAgICAgICAgc3VtbWFyeSgiUmVzcG9uc2Ugd2FzIG5vdCBIcyAtIHJlY2VpdmVkOiAiICsgbWVzc2FnZS50eXBlKQogICAgICAgICBjbGllbnQuY2xvc2UoKQogICAgICAgICByZXR1cm4KIAogICAgIHByaW50ICJSZWNlaXZlZCBtZXNzYWdlIgotICAgIHByaW50IG1lc3NhZ2UucHJldHR5KCkKKyAgICB0cnk6CisgICAgICAgIHByaW50IG1lc3NhZ2UucHJldHR5KCkKKyAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICBwcmludCBlCisgICAgcHJpbnQgc3RyKG1lc3NhZ2UpLmVuY29kZSgiaGV4IikKICAgICBtZXNzYWdlID0gbmZjLm5kZWYuSGFuZG92ZXJTZWxlY3RNZXNzYWdlKG1lc3NhZ2UpCi0gICAgcHJpbnQgIkhhbmRvdmVyIHNlbGVjdCByZWNlaXZlZCIKLSAgICBwcmludCBtZXNzYWdlLnByZXR0eSgpCisgICAgc3VtbWFyeSgiSGFuZG92ZXIgc2VsZWN0IHJlY2VpdmVkIikKKyAgICB0cnk6CisgICAgICAgIHByaW50IG1lc3NhZ2UucHJldHR5KCkKKyAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAgICBwcmludCBlCiAKICAgICBmb3IgY2FycmllciBpbiBtZXNzYWdlLmNhcnJpZXJzOgogICAgICAgICBwcmludCAiUmVtb3RlIGNhcnJpZXIgdHlwZTogIiArIGNhcnJpZXIudHlwZQogICAgICAgICBpZiBjYXJyaWVyLnR5cGUgPT0gImFwcGxpY2F0aW9uL3ZuZC53ZmEud3NjIjoKICAgICAgICAgICAgIHByaW50ICJXUFMgY2FycmllciB0eXBlIG1hdGNoIC0gc2VuZCB0byB3cGFfc3VwcGxpY2FudCIKLSAgICAgICAgICAgIHdwYXNfcmVwb3J0X2hhbmRvdmVyKGRhdGEsIGNhcnJpZXIucmVjb3JkLCAiSU5JVCIpCi0gICAgICAgICAgICB3aWZpID0gbmZjLm5kZWYuV2lmaUNvbmZpZ1JlY29yZChjYXJyaWVyLnJlY29yZCkKLSAgICAgICAgICAgIHByaW50IHdpZmkucHJldHR5KCkKKyAgICAgICAgICAgIGlmICJPSyIgaW4gd3Bhc19yZXBvcnRfaGFuZG92ZXIoZGF0YSwgY2Fycmllci5yZWNvcmQsICJJTklUIik6CisgICAgICAgICAgICAgICAgc3VjY2Vzc19yZXBvcnQoIkhhbmRvdmVyIHJlcG9ydGVkIHN1Y2Nlc3NmdWxseSAoaW5pdGlhdG9yKSIpCisgICAgICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAgIHN1bW1hcnkoIkhhbmRvdmVyIHJlcG9ydCByZWplY3RlZCAoaW5pdGlhdG9yKSIpCisgICAgICAgICAgICAjIG5mY3B5IGRvZXMgbm90IHN1cHBvcnQgdGhlIG5ldyBmb3JtYXQuLgorICAgICAgICAgICAgI3dpZmkgPSBuZmMubmRlZi5XaWZpQ29uZmlnUmVjb3JkKGNhcnJpZXIucmVjb3JkKQorICAgICAgICAgICAgI3ByaW50IHdpZmkucHJldHR5KCkKIAogICAgIHByaW50ICJSZW1vdmUgcGVlciIKLSAgICBuZmMubGxjcC5zaHV0ZG93bigpCiAgICAgY2xpZW50LmNsb3NlKCkKICAgICBwcmludCAiRG9uZSB3aXRoIGhhbmRvdmVyIgorICAgIGdsb2JhbCBvbmx5X29uZQorICAgIGlmIG9ubHlfb25lOgorICAgICAgICBnbG9iYWwgY29udGludWVfbG9vcAorICAgICAgICBjb250aW51ZV9sb29wID0gRmFsc2UKIAorICAgIGdsb2JhbCBub193YWl0CisgICAgaWYgbm9fd2FpdDoKKyAgICAgICAgcHJpbnQgIlRyeWluZyB0byBleGl0Li4iCisgICAgICAgIGdsb2JhbCB0ZXJtaW5hdGVfbm93CisgICAgICAgIHRlcm1pbmF0ZV9ub3cgPSBUcnVlCiAKIGRlZiB3cHNfdGFnX3JlYWQodGFnLCB3YWl0X3JlbW92ZT1UcnVlKToKICAgICBzdWNjZXNzID0gRmFsc2UKICAgICBpZiBsZW4odGFnLm5kZWYubWVzc2FnZSk6Ci0gICAgICAgIG1lc3NhZ2UgPSBuZmMubmRlZi5NZXNzYWdlKHRhZy5uZGVmLm1lc3NhZ2UpCi0gICAgICAgIHByaW50ICJtZXNzYWdlIHR5cGUgIiArIG1lc3NhZ2UudHlwZQotCi0gICAgICAgIGZvciByZWNvcmQgaW4gbWVzc2FnZToKKyAgICAgICAgZm9yIHJlY29yZCBpbiB0YWcubmRlZi5tZXNzYWdlOgogICAgICAgICAgICAgcHJpbnQgInJlY29yZCB0eXBlICIgKyByZWNvcmQudHlwZQogICAgICAgICAgICAgaWYgcmVjb3JkLnR5cGUgPT0gImFwcGxpY2F0aW9uL3ZuZC53ZmEud3NjIjoKLSAgICAgICAgICAgICAgICBwcmludCAiV1BTIHRhZyAtIHNlbmQgdG8gd3BhX3N1cHBsaWNhbnQiCisgICAgICAgICAgICAgICAgc3VtbWFyeSgiV1BTIHRhZyAtIHNlbmQgdG8gd3BhX3N1cHBsaWNhbnQiKQogICAgICAgICAgICAgICAgIHN1Y2Nlc3MgPSB3cGFzX3RhZ19yZWFkKHRhZy5uZGVmLm1lc3NhZ2UpCiAgICAgICAgICAgICAgICAgYnJlYWsKICAgICBlbHNlOgotICAgICAgICBwcmludCAiRW1wdHkgdGFnIgorICAgICAgICBzdW1tYXJ5KCJFbXB0eSB0YWciKQorCisgICAgaWYgc3VjY2VzczoKKyAgICAgICAgc3VjY2Vzc19yZXBvcnQoIlRhZyByZWFkIHN1Y2NlZWRlZCIpCiAKICAgICBpZiB3YWl0X3JlbW92ZToKICAgICAgICAgcHJpbnQgIlJlbW92ZSB0YWciCkBAIC0yNjksMTY2ICszMTUsMjA0IEBACiAgICAgcmV0dXJuIHN1Y2Nlc3MKIAogCitkZWYgcmR3cl9jb25uZWN0ZWRfd3JpdGUodGFnKToKKyAgICBzdW1tYXJ5KCJUYWcgZm91bmQgLSB3cml0aW5nIC0gIiArIHN0cih0YWcpKQorICAgIGdsb2JhbCB3cml0ZV9kYXRhCisgICAgdGFnLm5kZWYubWVzc2FnZSA9IHN0cih3cml0ZV9kYXRhKQorICAgIHN1Y2Nlc3NfcmVwb3J0KCJUYWcgd3JpdGUgc3VjY2VlZGVkIikKKyAgICBwcmludCAiRG9uZSAtIHJlbW92ZSB0YWciCisgICAgZ2xvYmFsIG9ubHlfb25lCisgICAgaWYgb25seV9vbmU6CisgICAgICAgIGdsb2JhbCBjb250aW51ZV9sb29wCisgICAgICAgIGNvbnRpbnVlX2xvb3AgPSBGYWxzZQorICAgIGdsb2JhbCB3cml0ZV93YWl0X3JlbW92ZQorICAgIHdoaWxlIHdyaXRlX3dhaXRfcmVtb3ZlIGFuZCB0YWcuaXNfcHJlc2VudDoKKyAgICAgICAgdGltZS5zbGVlcCgwLjEpCisKIGRlZiB3cHNfd3JpdGVfY29uZmlnX3RhZyhjbGYsIGlkPU5vbmUsIHdhaXRfcmVtb3ZlPVRydWUpOgogICAgIHByaW50ICJXcml0ZSBXUFMgY29uZmlnIHRva2VuIgotICAgIGRhdGEgPSB3cGFzX2dldF9jb25maWdfdG9rZW4oaWQpCi0gICAgaWYgKGRhdGEgPT0gTm9uZSk6CisgICAgZ2xvYmFsIHdyaXRlX2RhdGEsIHdyaXRlX3dhaXRfcmVtb3ZlCisgICAgd3JpdGVfd2FpdF9yZW1vdmUgPSB3YWl0X3JlbW92ZQorICAgIHdyaXRlX2RhdGEgPSB3cGFzX2dldF9jb25maWdfdG9rZW4oaWQpCisgICAgaWYgd3JpdGVfZGF0YSA9PSBOb25lOgogICAgICAgICBwcmludCAiQ291bGQgbm90IGdldCBXUFMgY29uZmlnIHRva2VuIGZyb20gd3BhX3N1cHBsaWNhbnQiCiAgICAgICAgIHN5cy5leGl0KDEpCiAgICAgICAgIHJldHVybgotCiAgICAgcHJpbnQgIlRvdWNoIGFuIE5GQyB0YWciCi0gICAgd2hpbGUgVHJ1ZToKLSAgICAgICAgdGFnID0gY2xmLnBvbGwoKQotICAgICAgICBpZiB0YWcgPT0gTm9uZToKLSAgICAgICAgICAgIHRpbWUuc2xlZXAoMC4xKQotICAgICAgICAgICAgY29udGludWUKLSAgICAgICAgYnJlYWsKLQotICAgIHByaW50ICJUYWcgZm91bmQgLSB3cml0aW5nIgotICAgIHRhZy5uZGVmLm1lc3NhZ2UgPSBkYXRhCi0gICAgcHJpbnQgIkRvbmUgLSByZW1vdmUgdGFnIgotICAgIHdoaWxlIHdhaXRfcmVtb3ZlIGFuZCB0YWcuaXNfcHJlc2VudDoKLSAgICAgICAgdGltZS5zbGVlcCgwLjEpCisgICAgY2xmLmNvbm5lY3QocmR3cj17J29uLWNvbm5lY3QnOiByZHdyX2Nvbm5lY3RlZF93cml0ZX0pCiAKIAotZGVmIHdwc193cml0ZV9lcl9jb25maWdfdGFnKGNsZiwgdXVpZCk6CitkZWYgd3BzX3dyaXRlX2VyX2NvbmZpZ190YWcoY2xmLCB1dWlkLCB3YWl0X3JlbW92ZT1UcnVlKToKICAgICBwcmludCAiV3JpdGUgV1BTIEVSIGNvbmZpZyB0b2tlbiIKLSAgICBkYXRhID0gd3Bhc19nZXRfZXJfY29uZmlnX3Rva2VuKHV1aWQpCi0gICAgaWYgKGRhdGEgPT0gTm9uZSk6CisgICAgZ2xvYmFsIHdyaXRlX2RhdGEsIHdyaXRlX3dhaXRfcmVtb3ZlCisgICAgd3JpdGVfd2FpdF9yZW1vdmUgPSB3YWl0X3JlbW92ZQorICAgIHdyaXRlX2RhdGEgPSB3cGFzX2dldF9lcl9jb25maWdfdG9rZW4odXVpZCkKKyAgICBpZiB3cml0ZV9kYXRhID09IE5vbmU6CiAgICAgICAgIHByaW50ICJDb3VsZCBub3QgZ2V0IFdQUyBjb25maWcgdG9rZW4gZnJvbSB3cGFfc3VwcGxpY2FudCIKICAgICAgICAgcmV0dXJuCiAKICAgICBwcmludCAiVG91Y2ggYW4gTkZDIHRhZyIKLSAgICB3aGlsZSBUcnVlOgotICAgICAgICB0YWcgPSBjbGYucG9sbCgpCi0gICAgICAgIGlmIHRhZyA9PSBOb25lOgotICAgICAgICAgICAgdGltZS5zbGVlcCgwLjEpCi0gICAgICAgICAgICBjb250aW51ZQotICAgICAgICBicmVhawotCi0gICAgcHJpbnQgIlRhZyBmb3VuZCAtIHdyaXRpbmciCi0gICAgdGFnLm5kZWYubWVzc2FnZSA9IGRhdGEKLSAgICBwcmludCAiRG9uZSAtIHJlbW92ZSB0YWciCi0gICAgd2hpbGUgdGFnLmlzX3ByZXNlbnQ6Ci0gICAgICAgIHRpbWUuc2xlZXAoMC4xKQorICAgIGNsZi5jb25uZWN0KHJkd3I9eydvbi1jb25uZWN0JzogcmR3cl9jb25uZWN0ZWRfd3JpdGV9KQogCiAKIGRlZiB3cHNfd3JpdGVfcGFzc3dvcmRfdGFnKGNsZiwgd2FpdF9yZW1vdmU9VHJ1ZSk6CiAgICAgcHJpbnQgIldyaXRlIFdQUyBwYXNzd29yZCB0b2tlbiIKLSAgICBkYXRhID0gd3Bhc19nZXRfcGFzc3dvcmRfdG9rZW4oKQotICAgIGlmIChkYXRhID09IE5vbmUpOgorICAgIGdsb2JhbCB3cml0ZV9kYXRhLCB3cml0ZV93YWl0X3JlbW92ZQorICAgIHdyaXRlX3dhaXRfcmVtb3ZlID0gd2FpdF9yZW1vdmUKKyAgICB3cml0ZV9kYXRhID0gd3Bhc19nZXRfcGFzc3dvcmRfdG9rZW4oKQorICAgIGlmIHdyaXRlX2RhdGEgPT0gTm9uZToKICAgICAgICAgcHJpbnQgIkNvdWxkIG5vdCBnZXQgV1BTIHBhc3N3b3JkIHRva2VuIGZyb20gd3BhX3N1cHBsaWNhbnQiCiAgICAgICAgIHJldHVybgogCiAgICAgcHJpbnQgIlRvdWNoIGFuIE5GQyB0YWciCi0gICAgd2hpbGUgVHJ1ZToKLSAgICAgICAgdGFnID0gY2xmLnBvbGwoKQotICAgICAgICBpZiB0YWcgPT0gTm9uZToKLSAgICAgICAgICAgIHRpbWUuc2xlZXAoMC4xKQotICAgICAgICAgICAgY29udGludWUKLSAgICAgICAgYnJlYWsKLQotICAgIHByaW50ICJUYWcgZm91bmQgLSB3cml0aW5nIgotICAgIHRhZy5uZGVmLm1lc3NhZ2UgPSBkYXRhCi0gICAgcHJpbnQgIkRvbmUgLSByZW1vdmUgdGFnIgotICAgIHdoaWxlIHdhaXRfcmVtb3ZlIGFuZCB0YWcuaXNfcHJlc2VudDoKLSAgICAgICAgdGltZS5zbGVlcCgwLjEpCisgICAgY2xmLmNvbm5lY3QocmR3cj17J29uLWNvbm5lY3QnOiByZHdyX2Nvbm5lY3RlZF93cml0ZX0pCiAKIAotZGVmIGZpbmRfcGVlcihjbGYpOgotICAgIHdoaWxlIFRydWU6Ci0gICAgICAgIGlmIG5mYy5sbGNwLmNvbm5lY3RlZCgpOgotICAgICAgICAgICAgcHJpbnQgIkxMQ1AgY29ubmVjdGVkIgotICAgICAgICBnZW5lcmFsX2J5dGVzID0gbmZjLmxsY3Auc3RhcnR1cCh7fSkKLSAgICAgICAgcGVlciA9IGNsZi5saXN0ZW4ob3JkKG9zLnVyYW5kb20oMSkpICsgMjUwLCBnZW5lcmFsX2J5dGVzKQotICAgICAgICBpZiBpc2luc3RhbmNlKHBlZXIsIG5mYy5ERVApOgotICAgICAgICAgICAgcHJpbnQgImxpc3RlbiAtPiBERVAiOwotICAgICAgICAgICAgaWYgcGVlci5nZW5lcmFsX2J5dGVzLnN0YXJ0c3dpdGgoIkZmbSIpOgotICAgICAgICAgICAgICAgIHByaW50ICJGb3VuZCBERVAiCi0gICAgICAgICAgICAgICAgcmV0dXJuIHBlZXIKLSAgICAgICAgICAgIHByaW50ICJtaXNtYXRjaCBpbiBnZW5lcmFsX2J5dGVzIgotICAgICAgICAgICAgcHJpbnQgcGVlci5nZW5lcmFsX2J5dGVzCitkZWYgcmR3cl9jb25uZWN0ZWQodGFnKToKKyAgICBnbG9iYWwgb25seV9vbmUsIG5vX3dhaXQKKyAgICBzdW1tYXJ5KCJUYWcgY29ubmVjdGVkOiAiICsgc3RyKHRhZykpCiAKLSAgICAgICAgcGVlciA9IGNsZi5wb2xsKGdlbmVyYWxfYnl0ZXMpCi0gICAgICAgIGlmIGlzaW5zdGFuY2UocGVlciwgbmZjLkRFUCk6Ci0gICAgICAgICAgICBwcmludCAicG9sbCAtPiBERVAiOwotICAgICAgICAgICAgaWYgcGVlci5nZW5lcmFsX2J5dGVzLnN0YXJ0c3dpdGgoIkZmbSIpOgotICAgICAgICAgICAgICAgIHByaW50ICJGb3VuZCBERVAiCi0gICAgICAgICAgICAgICAgcmV0dXJuIHBlZXIKLSAgICAgICAgICAgIHByaW50ICJtaXNtYXRjaCBpbiBnZW5lcmFsX2J5dGVzIgotICAgICAgICAgICAgcHJpbnQgcGVlci5nZW5lcmFsX2J5dGVzCisgICAgaWYgdGFnLm5kZWY6CisgICAgICAgIHByaW50ICJOREVGIHRhZzogIiArIHRhZy50eXBlCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHByaW50IHRhZy5uZGVmLm1lc3NhZ2UucHJldHR5KCkKKyAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZToKKyAgICAgICAgICAgIHByaW50IGUKKyAgICAgICAgc3VjY2VzcyA9IHdwc190YWdfcmVhZCh0YWcsIG5vdCBvbmx5X29uZSkKKyAgICAgICAgaWYgb25seV9vbmUgYW5kIHN1Y2Nlc3M6CisgICAgICAgICAgICBnbG9iYWwgY29udGludWVfbG9vcAorICAgICAgICAgICAgY29udGludWVfbG9vcCA9IEZhbHNlCisgICAgZWxzZToKKyAgICAgICAgc3VtbWFyeSgiTm90IGFuIE5ERUYgdGFnIC0gcmVtb3ZlIHRhZyIpCisgICAgICAgIHJldHVybiBUcnVlCiAKLSAgICAgICAgaWYgcGVlcjoKLSAgICAgICAgICAgIHByaW50ICJGb3VuZCB0YWciCi0gICAgICAgICAgICByZXR1cm4gcGVlcgorICAgIHJldHVybiBub3Qgbm9fd2FpdAogCiAKK2RlZiBsbGNwX3dvcmtlcihsbGMpOgorICAgIGdsb2JhbCBhcmdfdXVpZAorICAgIGlmIGFyZ191dWlkIGlzIE5vbmU6CisgICAgICAgIHdwc19oYW5kb3Zlcl9pbml0KGxsYykKKyAgICAgICAgcHJpbnQgIkV4aXRpbmcgbGxjcF93b3JrZXIgdGhyZWFkIgorICAgICAgICByZXR1cm4KKworICAgIGdsb2JhbCBzcnYKKyAgICBnbG9iYWwgd2FpdF9jb25uZWN0aW9uCisgICAgd2hpbGUgbm90IHdhaXRfY29ubmVjdGlvbiBhbmQgc3J2LnNlbnRfY2FycmllciBpcyBOb25lOgorICAgICAgICBpZiBzcnYuaG9fc2VydmVyX3Byb2Nlc3Npbmc6CisgICAgICAgICAgICB0aW1lLnNsZWVwKDAuMDI1KQorCitkZWYgbGxjcF9zdGFydHVwKGNsZiwgbGxjKToKKyAgICBnbG9iYWwgYXJnX3V1aWQKKyAgICBpZiBhcmdfdXVpZDoKKyAgICAgICAgcHJpbnQgIlN0YXJ0IExMQ1Agc2VydmVyIgorICAgICAgICBnbG9iYWwgc3J2CisgICAgICAgIHNydiA9IEhhbmRvdmVyU2VydmVyKGxsYykKKyAgICAgICAgaWYgYXJnX3V1aWQgaXMgImFwIjoKKyAgICAgICAgICAgIHByaW50ICJUcnlpbmcgdG8gaGFuZGxlIFdQUyBoYW5kb3ZlciIKKyAgICAgICAgICAgIHNydi51dWlkID0gTm9uZQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgcHJpbnQgIlRyeWluZyB0byBoYW5kbGUgV1BTIGhhbmRvdmVyIHdpdGggQVAgIiArIGFyZ191dWlkCisgICAgICAgICAgICBzcnYudXVpZCA9IGFyZ191dWlkCisgICAgcmV0dXJuIGxsYworCitkZWYgbGxjcF9jb25uZWN0ZWQobGxjKToKKyAgICBwcmludCAiUDJQIExMQ1AgY29ubmVjdGVkIgorICAgIGdsb2JhbCB3YWl0X2Nvbm5lY3Rpb24KKyAgICB3YWl0X2Nvbm5lY3Rpb24gPSBGYWxzZQorICAgIGdsb2JhbCBhcmdfdXVpZAorICAgIGlmIGFyZ191dWlkOgorICAgICAgICBnbG9iYWwgc3J2CisgICAgICAgIHNydi5zdGFydCgpCisgICAgZWxzZToKKyAgICAgICAgdGhyZWFkaW5nLlRocmVhZCh0YXJnZXQ9bGxjcF93b3JrZXIsIGFyZ3M9KGxsYywpKS5zdGFydCgpCisgICAgcHJpbnQgImxsY3BfY29ubmVjdGVkIHJldHVybmluZyIKKyAgICByZXR1cm4gVHJ1ZQorCisKK2RlZiB0ZXJtaW5hdGVfbG9vcCgpOgorICAgIGdsb2JhbCB0ZXJtaW5hdGVfbm93CisgICAgcmV0dXJuIHRlcm1pbmF0ZV9ub3cKKwogZGVmIG1haW4oKToKICAgICBjbGYgPSBuZmMuQ29udGFjdGxlc3NGcm9udGVuZCgpCiAKKyAgICBwYXJzZXIgPSBhcmdwYXJzZS5Bcmd1bWVudFBhcnNlcihkZXNjcmlwdGlvbj0nbmZjcHkgdG8gd3BhX3N1cHBsaWNhbnQgaW50ZWdyYXRpb24gZm9yIFdQUyBORkMgb3BlcmF0aW9ucycpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLWQnLCBjb25zdD1sb2dnaW5nLkRFQlVHLCBkZWZhdWx0PWxvZ2dpbmcuSU5GTywKKyAgICAgICAgICAgICAgICAgICAgICAgIGFjdGlvbj0nc3RvcmVfY29uc3QnLCBkZXN0PSdsb2dsZXZlbCcsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSd2ZXJib3NlIGRlYnVnIG91dHB1dCcpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLXEnLCBjb25zdD1sb2dnaW5nLldBUk5JTkcsIGFjdGlvbj0nc3RvcmVfY29uc3QnLAorICAgICAgICAgICAgICAgICAgICAgICAgZGVzdD0nbG9nbGV2ZWwnLCBoZWxwPSdiZSBxdWlldCcpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1vbmx5LW9uZScsICctMScsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdydW4gb25seSBvbmUgb3BlcmF0aW9uIGFuZCBleGl0JykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLW5vLXdhaXQnLCBhY3Rpb249J3N0b3JlX3RydWUnLAorICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nZG8gbm90IHdhaXQgZm9yIHRhZyB0byBiZSByZW1vdmVkIGJlZm9yZSBleGl0aW5nJykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLXV1aWQnLAorICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nVVVJRCBvZiBhbiBBUCAodXNlZCBmb3IgV1BTIEVSIG9wZXJhdGlvbnMpJykKKyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLWlkJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J25ldHdvcmsgaWQgKHVzZWQgZm9yIFdQUyBFUiBvcGVyYXRpb25zKScpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1zdW1tYXJ5JywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3N1bW1hcnkgZmlsZSBmb3Igd3JpdGluZyBzdGF0dXMgdXBkYXRlcycpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1zdWNjZXNzJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3N1Y2Nlc3MgZmlsZSBmb3Igd3JpdGluZyBzdWNjZXNzIHVwZGF0ZScpCisgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnY29tbWFuZCcsIGNob2ljZXM9Wyd3cml0ZS1jb25maWcnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnd3JpdGUtZXItY29uZmlnJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ3dyaXRlLXBhc3N3b3JkJ10sCisgICAgICAgICAgICAgICAgICAgICAgICBuYXJncz0nPycpCisgICAgYXJncyA9IHBhcnNlci5wYXJzZV9hcmdzKCkKKworICAgIGdsb2JhbCBhcmdfdXVpZAorICAgIGFyZ191dWlkID0gYXJncy51dWlkCisKKyAgICBnbG9iYWwgb25seV9vbmUKKyAgICBvbmx5X29uZSA9IGFyZ3Mub25seV9vbmUKKworICAgIGdsb2JhbCBub193YWl0CisgICAgbm9fd2FpdCA9IGFyZ3Mubm9fd2FpdAorCisgICAgaWYgYXJncy5zdW1tYXJ5OgorICAgICAgICBnbG9iYWwgc3VtbWFyeV9maWxlCisgICAgICAgIHN1bW1hcnlfZmlsZSA9IGFyZ3Muc3VtbWFyeQorCisgICAgaWYgYXJncy5zdWNjZXNzOgorICAgICAgICBnbG9iYWwgc3VjY2Vzc19maWxlCisgICAgICAgIHN1Y2Nlc3NfZmlsZSA9IGFyZ3Muc3VjY2VzcworCisgICAgbG9nZ2luZy5iYXNpY0NvbmZpZyhsZXZlbD1hcmdzLmxvZ2xldmVsKQorCiAgICAgdHJ5OgotICAgICAgICBhcmdfdXVpZCA9IE5vbmUKLSAgICAgICAgaWYgbGVuKHN5cy5hcmd2KSA+IDEgYW5kIHN5cy5hcmd2WzFdICE9ICctMSc6Ci0gICAgICAgICAgICBhcmdfdXVpZCA9IHN5cy5hcmd2WzFdCi0KLSAgICAgICAgaWYgbGVuKHN5cy5hcmd2KSA+IDEgYW5kIHN5cy5hcmd2WzFdID09ICctMSc6Ci0gICAgICAgICAgICBvbmx5X29uZSA9IFRydWUKLSAgICAgICAgZWxzZToKLSAgICAgICAgICAgIG9ubHlfb25lID0gRmFsc2UKLQotICAgICAgICBpZiBsZW4oc3lzLmFyZ3YpID4gMSBhbmQgc3lzLmFyZ3ZbMV0gPT0gIndyaXRlLWNvbmZpZyI6Ci0gICAgICAgICAgICB3cHNfd3JpdGVfY29uZmlnX3RhZyhjbGYpCisgICAgICAgIGlmIG5vdCBjbGYub3BlbigidXNiIik6CisgICAgICAgICAgICBwcmludCAiQ291bGQgbm90IG9wZW4gY29ubmVjdGlvbiB3aXRoIGFuIE5GQyBkZXZpY2UiCiAgICAgICAgICAgICByYWlzZSBTeXN0ZW1FeGl0CiAKLSAgICAgICAgaWYgbGVuKHN5cy5hcmd2KSA+IDEgYW5kIHN5cy5hcmd2WzFdID09ICJ3cml0ZS1jb25maWctbm8td2FpdCI6Ci0gICAgICAgICAgICB3cHNfd3JpdGVfY29uZmlnX3RhZyhjbGYsIHdhaXRfcmVtb3ZlPUZhbHNlKQorICAgICAgICBpZiBhcmdzLmNvbW1hbmQgPT0gIndyaXRlLWNvbmZpZyI6CisgICAgICAgICAgICB3cHNfd3JpdGVfY29uZmlnX3RhZyhjbGYsIGlkPWFyZ3MuaWQsIHdhaXRfcmVtb3ZlPW5vdCBhcmdzLm5vX3dhaXQpCiAgICAgICAgICAgICByYWlzZSBTeXN0ZW1FeGl0CiAKLSAgICAgICAgaWYgbGVuKHN5cy5hcmd2KSA+IDIgYW5kIHN5cy5hcmd2WzFdID09ICJ3cml0ZS1jb25maWctaWQiOgotICAgICAgICAgICAgd3BzX3dyaXRlX2NvbmZpZ190YWcoY2xmLCBzeXMuYXJndlsyXSkKKyAgICAgICAgaWYgYXJncy5jb21tYW5kID09ICJ3cml0ZS1lci1jb25maWciOgorICAgICAgICAgICAgd3BzX3dyaXRlX2VyX2NvbmZpZ190YWcoY2xmLCBhcmdzLnV1aWQsIHdhaXRfcmVtb3ZlPW5vdCBhcmdzLm5vX3dhaXQpCiAgICAgICAgICAgICByYWlzZSBTeXN0ZW1FeGl0CiAKLSAgICAgICAgaWYgbGVuKHN5cy5hcmd2KSA+IDIgYW5kIHN5cy5hcmd2WzFdID09ICJ3cml0ZS1lci1jb25maWciOgotICAgICAgICAgICAgd3BzX3dyaXRlX2VyX2NvbmZpZ190YWcoY2xmLCBzeXMuYXJndlsyXSkKKyAgICAgICAgaWYgYXJncy5jb21tYW5kID09ICJ3cml0ZS1wYXNzd29yZCI6CisgICAgICAgICAgICB3cHNfd3JpdGVfcGFzc3dvcmRfdGFnKGNsZiwgd2FpdF9yZW1vdmU9bm90IGFyZ3Mubm9fd2FpdCkKICAgICAgICAgICAgIHJhaXNlIFN5c3RlbUV4aXQKIAotICAgICAgICBpZiBsZW4oc3lzLmFyZ3YpID4gMSBhbmQgc3lzLmFyZ3ZbMV0gPT0gIndyaXRlLXBhc3N3b3JkIjoKLSAgICAgICAgICAgIHdwc193cml0ZV9wYXNzd29yZF90YWcoY2xmKQotICAgICAgICAgICAgcmFpc2UgU3lzdGVtRXhpdAotCi0gICAgICAgIGlmIGxlbihzeXMuYXJndikgPiAxIGFuZCBzeXMuYXJndlsxXSA9PSAid3JpdGUtcGFzc3dvcmQtbm8td2FpdCI6Ci0gICAgICAgICAgICB3cHNfd3JpdGVfcGFzc3dvcmRfdGFnKGNsZiwgd2FpdF9yZW1vdmU9RmFsc2UpCi0gICAgICAgICAgICByYWlzZSBTeXN0ZW1FeGl0Ci0KLSAgICAgICAgd2hpbGUgVHJ1ZToKKyAgICAgICAgZ2xvYmFsIGNvbnRpbnVlX2xvb3AKKyAgICAgICAgd2hpbGUgY29udGludWVfbG9vcDoKICAgICAgICAgICAgIHByaW50ICJXYWl0aW5nIGZvciBhIHRhZyBvciBwZWVyIHRvIGJlIHRvdWNoZWQiCi0KLSAgICAgICAgICAgIHRhZyA9IGZpbmRfcGVlcihjbGYpCi0gICAgICAgICAgICBpZiBpc2luc3RhbmNlKHRhZywgbmZjLkRFUCk6Ci0gICAgICAgICAgICAgICAgaWYgYXJnX3V1aWQgaXMgTm9uZToKLSAgICAgICAgICAgICAgICAgICAgd3BzX2hhbmRvdmVyX2luaXQodGFnKQotICAgICAgICAgICAgICAgIGVsaWYgYXJnX3V1aWQgaXMgImFwIjoKLSAgICAgICAgICAgICAgICAgICAgd3BzX2hhbmRvdmVyX3Jlc3AodGFnLCBOb25lKQotICAgICAgICAgICAgICAgIGVsc2U6Ci0gICAgICAgICAgICAgICAgICAgIHdwc19oYW5kb3Zlcl9yZXNwKHRhZywgYXJnX3V1aWQpCi0gICAgICAgICAgICAgICAgaWYgb25seV9vbmU6CisgICAgICAgICAgICB3YWl0X2Nvbm5lY3Rpb24gPSBUcnVlCisgICAgICAgICAgICB0cnk6CisgICAgICAgICAgICAgICAgaWYgbm90IGNsZi5jb25uZWN0KHJkd3I9eydvbi1jb25uZWN0JzogcmR3cl9jb25uZWN0ZWR9LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsbGNwPXsnb24tc3RhcnR1cCc6IGxsY3Bfc3RhcnR1cCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ29uLWNvbm5lY3QnOiBsbGNwX2Nvbm5lY3RlZH0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlcm1pbmF0ZT10ZXJtaW5hdGVfbG9vcCk6CiAgICAgICAgICAgICAgICAgICAgIGJyZWFrCi0gICAgICAgICAgICAgICAgY29udGludWUKKyAgICAgICAgICAgIGV4Y2VwdCBFeGNlcHRpb24sIGU6CisgICAgICAgICAgICAgICAgcHJpbnQgImNsZi5jb25uZWN0IGZhaWxlZCIKIAotICAgICAgICAgICAgaWYgdGFnLm5kZWY6Ci0gICAgICAgICAgICAgICAgc3VjY2VzcyA9IHdwc190YWdfcmVhZCh0YWcsIG5vdCBvbmx5X29uZSkKLSAgICAgICAgICAgICAgICBpZiBvbmx5X29uZToKLSAgICAgICAgICAgICAgICAgICAgaWYgbm90IHN1Y2Nlc3M6Ci0gICAgICAgICAgICAgICAgICAgICAgICBzeXMuZXhpdCgxKQotICAgICAgICAgICAgICAgICAgICBicmVhawotICAgICAgICAgICAgICAgIGNvbnRpbnVlCi0KLSAgICAgICAgICAgIHByaW50ICJOb3QgYW4gTkRFRiB0YWcgLSByZW1vdmUgdGFnIgotICAgICAgICAgICAgaWYgb25seV9vbmU6Ci0gICAgICAgICAgICAgICAgc3lzLmV4aXQoMSkKLSAgICAgICAgICAgIHdoaWxlIHRhZy5pc19wcmVzZW50OgotICAgICAgICAgICAgICAgIHRpbWUuc2xlZXAoMC4xKQorICAgICAgICAgICAgZ2xvYmFsIHNydgorICAgICAgICAgICAgaWYgb25seV9vbmUgYW5kIHNydiBhbmQgc3J2LnN1Y2Nlc3M6CisgICAgICAgICAgICAgICAgcmFpc2UgU3lzdGVtRXhpdAogCiAgICAgZXhjZXB0IEtleWJvYXJkSW50ZXJydXB0OgogICAgICAgICByYWlzZSBTeXN0ZW1FeGl0CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9nYXNfcXVlcnkuYyBiL3dwYV9zdXBwbGljYW50L2dhc19xdWVyeS5jCmluZGV4IDA2YTk3ZDMuLjM5ODYyNjggMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2dhc19xdWVyeS5jCisrKyBiL3dwYV9zdXBwbGljYW50L2dhc19xdWVyeS5jCkBAIC0xLDcgKzEsOCBAQAogLyoKICAqIEdlbmVyaWMgYWR2ZXJ0aXNlbWVudCBzZXJ2aWNlIChHQVMpIHF1ZXJ5CiAgKiBDb3B5cmlnaHQgKGMpIDIwMDksIEF0aGVyb3MgQ29tbXVuaWNhdGlvbnMKLSAqIENvcHlyaWdodCAoYykgMjAxMSwgUXVhbGNvbW0gQXRoZXJvcworICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTQsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAxMS0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xMyw2ICsxNCw4IEBACiAjaW5jbHVkZSAidXRpbHMvZWxvb3AuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCiAjaW5jbHVkZSAiY29tbW9uL2dhcy5oIgorI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgorI2luY2x1ZGUgInJzbl9zdXBwL3dwYS5oIgogI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKICNpbmNsdWRlICJkcml2ZXJfaS5oIgogI2luY2x1ZGUgIm9mZmNoYW5uZWwuaCIKQEAgLTI4LDYgKzMxLDcgQEAKICAqLwogc3RydWN0IGdhc19xdWVyeV9wZW5kaW5nIHsKIAlzdHJ1Y3QgZGxfbGlzdCBsaXN0OworCXN0cnVjdCBnYXNfcXVlcnkgKmdhczsKIAl1OCBhZGRyW0VUSF9BTEVOXTsKIAl1OCBkaWFsb2dfdG9rZW47CiAJdTggbmV4dF9mcmFnX2lkOwpAQCAtMzUsOCArMzksMTAgQEAKIAl1bnNpZ25lZCBpbnQgb2ZmY2hhbm5lbF90eF9zdGFydGVkOjE7CiAJaW50IGZyZXE7CiAJdTE2IHN0YXR1c19jb2RlOworCXN0cnVjdCB3cGFidWYgKnJlcTsKIAlzdHJ1Y3Qgd3BhYnVmICphZHZfcHJvdG87CiAJc3RydWN0IHdwYWJ1ZiAqcmVzcDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBsYXN0X29wZXI7CiAJdm9pZCAoKmNiKSh2b2lkICpjdHgsIGNvbnN0IHU4ICpkc3QsIHU4IGRpYWxvZ190b2tlbiwKIAkJICAgZW51bSBnYXNfcXVlcnlfcmVzdWx0IHJlc3VsdCwKIAkJICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYWR2X3Byb3RvLApAQCAtNTAsNiArNTYsOCBAQAogc3RydWN0IGdhc19xdWVyeSB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfczsKIAlzdHJ1Y3QgZGxfbGlzdCBwZW5kaW5nOyAvKiBzdHJ1Y3QgZ2FzX3F1ZXJ5X3BlbmRpbmcgKi8KKwlzdHJ1Y3QgZ2FzX3F1ZXJ5X3BlbmRpbmcgKmN1cnJlbnQ7CisJc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrOwogfTsKIAogCkBAIC01Nyw2ICs2NSwxNiBAQAogc3RhdGljIHZvaWQgZ2FzX3F1ZXJ5X3RpbWVvdXQodm9pZCAqZWxvb3BfZGF0YSwgdm9pZCAqdXNlcl9jdHgpOwogCiAKK3N0YXRpYyBpbnQgbXNfZnJvbV90aW1lKHN0cnVjdCBvc19yZWx0aW1lICpsYXN0KQoreworCXN0cnVjdCBvc19yZWx0aW1lIG5vdywgcmVzOworCisJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CisJb3NfcmVsdGltZV9zdWIoJm5vdywgbGFzdCwgJnJlcyk7CisJcmV0dXJuIHJlcy5zZWMgKiAxMDAwICsgcmVzLnVzZWMgLyAxMDAwOworfQorCisKIC8qKgogICogZ2FzX3F1ZXJ5X2luaXQgLSBJbml0aWFsaXplIEdBUyBxdWVyeSBjb21wb25lbnQKICAqIEB3cGFfczogUG9pbnRlciB0byB3cGFfc3VwcGxpY2FudCBkYXRhCkBAIC03NywxMCArOTUsNTggQEAKIH0KIAogCitzdGF0aWMgY29uc3QgY2hhciAqIGdhc19yZXN1bHRfdHh0KGVudW0gZ2FzX3F1ZXJ5X3Jlc3VsdCByZXN1bHQpCit7CisJc3dpdGNoIChyZXN1bHQpIHsKKwljYXNlIEdBU19RVUVSWV9TVUNDRVNTOgorCQlyZXR1cm4gIlNVQ0NFU1MiOworCWNhc2UgR0FTX1FVRVJZX0ZBSUxVUkU6CisJCXJldHVybiAiRkFJTFVSRSI7CisJY2FzZSBHQVNfUVVFUllfVElNRU9VVDoKKwkJcmV0dXJuICJUSU1FT1VUIjsKKwljYXNlIEdBU19RVUVSWV9QRUVSX0VSUk9SOgorCQlyZXR1cm4gIlBFRVJfRVJST1IiOworCWNhc2UgR0FTX1FVRVJZX0lOVEVSTkFMX0VSUk9SOgorCQlyZXR1cm4gIklOVEVSTkFMX0VSUk9SIjsKKwljYXNlIEdBU19RVUVSWV9DQU5DRUxMRUQ6CisJCXJldHVybiAiQ0FOQ0VMTEVEIjsKKwljYXNlIEdBU19RVUVSWV9ERUxFVEVEX0FUX0RFSU5JVDoKKwkJcmV0dXJuICJERUxFVEVEX0FUX0RFSU5JVCI7CisJfQorCisJcmV0dXJuICJOL0EiOworfQorCisKK3N0YXRpYyB2b2lkIGdhc19xdWVyeV9mcmVlKHN0cnVjdCBnYXNfcXVlcnlfcGVuZGluZyAqcXVlcnksIGludCBkZWxfbGlzdCkKK3sKKwlzdHJ1Y3QgZ2FzX3F1ZXJ5ICpnYXMgPSBxdWVyeS0+Z2FzOworCisJaWYgKGRlbF9saXN0KQorCQlkbF9saXN0X2RlbCgmcXVlcnktPmxpc3QpOworCisJaWYgKGdhcy0+d29yayAmJiBnYXMtPndvcmstPmN0eCA9PSBxdWVyeSkgeworCQlyYWRpb193b3JrX2RvbmUoZ2FzLT53b3JrKTsKKwkJZ2FzLT53b3JrID0gTlVMTDsKKwl9CisKKwl3cGFidWZfZnJlZShxdWVyeS0+cmVxKTsKKwl3cGFidWZfZnJlZShxdWVyeS0+YWR2X3Byb3RvKTsKKwl3cGFidWZfZnJlZShxdWVyeS0+cmVzcCk7CisJb3NfZnJlZShxdWVyeSk7Cit9CisKKwogc3RhdGljIHZvaWQgZ2FzX3F1ZXJ5X2RvbmUoc3RydWN0IGdhc19xdWVyeSAqZ2FzLAogCQkJICAgc3RydWN0IGdhc19xdWVyeV9wZW5kaW5nICpxdWVyeSwKIAkJCSAgIGVudW0gZ2FzX3F1ZXJ5X3Jlc3VsdCByZXN1bHQpCiB7CisJd3BhX21zZyhnYXMtPndwYV9zLCBNU0dfSU5GTywgR0FTX1FVRVJZX0RPTkUgImFkZHI9IiBNQUNTVFIKKwkJIiBkaWFsb2dfdG9rZW49JXUgZnJlcT0lZCBzdGF0dXNfY29kZT0ldSByZXN1bHQ9JXMiLAorCQlNQUMyU1RSKHF1ZXJ5LT5hZGRyKSwgcXVlcnktPmRpYWxvZ190b2tlbiwgcXVlcnktPmZyZXEsCisJCXF1ZXJ5LT5zdGF0dXNfY29kZSwgZ2FzX3Jlc3VsdF90eHQocmVzdWx0KSk7CisJaWYgKGdhcy0+Y3VycmVudCA9PSBxdWVyeSkKKwkJZ2FzLT5jdXJyZW50ID0gTlVMTDsKIAlpZiAocXVlcnktPm9mZmNoYW5uZWxfdHhfc3RhcnRlZCkKIAkJb2ZmY2hhbm5lbF9zZW5kX2FjdGlvbl9kb25lKGdhcy0+d3BhX3MpOwogCWVsb29wX2NhbmNlbF90aW1lb3V0KGdhc19xdWVyeV90eF9jb21lYmFja190aW1lb3V0LCBnYXMsIHF1ZXJ5KTsKQEAgLTg4LDkgKzE1NCw3IEBACiAJZGxfbGlzdF9kZWwoJnF1ZXJ5LT5saXN0KTsKIAlxdWVyeS0+Y2IocXVlcnktPmN0eCwgcXVlcnktPmFkZHIsIHF1ZXJ5LT5kaWFsb2dfdG9rZW4sIHJlc3VsdCwKIAkJICBxdWVyeS0+YWR2X3Byb3RvLCBxdWVyeS0+cmVzcCwgcXVlcnktPnN0YXR1c19jb2RlKTsKLQl3cGFidWZfZnJlZShxdWVyeS0+YWR2X3Byb3RvKTsKLQl3cGFidWZfZnJlZShxdWVyeS0+cmVzcCk7Ci0Jb3NfZnJlZShxdWVyeSk7CisJZ2FzX3F1ZXJ5X2ZyZWUocXVlcnksIDApOwogfQogCiAKQEAgLTEzOCwxNyArMjAyLDc5IEBACiB9CiAKIAorc3RhdGljIHZvaWQgZ2FzX3F1ZXJ5X3R4X3N0YXR1cyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCXVuc2lnbmVkIGludCBmcmVxLCBjb25zdCB1OCAqZHN0LAorCQkJCWNvbnN0IHU4ICpzcmMsIGNvbnN0IHU4ICpic3NpZCwKKwkJCQljb25zdCB1OCAqZGF0YSwgc2l6ZV90IGRhdGFfbGVuLAorCQkJCWVudW0gb2ZmY2hhbm5lbF9zZW5kX2FjdGlvbl9yZXN1bHQgcmVzdWx0KQoreworCXN0cnVjdCBnYXNfcXVlcnlfcGVuZGluZyAqcXVlcnk7CisJc3RydWN0IGdhc19xdWVyeSAqZ2FzID0gd3BhX3MtPmdhczsKKwlpbnQgZHVyOworCisJaWYgKGdhcy0+Y3VycmVudCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBVbmV4cGVjdGVkIFRYIHN0YXR1czogZnJlcT0ldSBkc3Q9IgorCQkJICAgTUFDU1RSICIgcmVzdWx0PSVkIC0gbm8gcXVlcnkgaW4gcHJvZ3Jlc3MiLAorCQkJICAgZnJlcSwgTUFDMlNUUihkc3QpLCByZXN1bHQpOworCQlyZXR1cm47CisJfQorCisJcXVlcnkgPSBnYXMtPmN1cnJlbnQ7CisKKwlkdXIgPSBtc19mcm9tX3RpbWUoJnF1ZXJ5LT5sYXN0X29wZXIpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBUWCBzdGF0dXM6IGZyZXE9JXUgZHN0PSIgTUFDU1RSCisJCSAgICIgcmVzdWx0PSVkIHF1ZXJ5PSVwIGRpYWxvZ190b2tlbj0ldSBkdXI9JWQgbXMiLAorCQkgICBmcmVxLCBNQUMyU1RSKGRzdCksIHJlc3VsdCwgcXVlcnksIHF1ZXJ5LT5kaWFsb2dfdG9rZW4sIGR1cik7CisJaWYgKG9zX21lbWNtcChkc3QsIHF1ZXJ5LT5hZGRyLCBFVEhfQUxFTikgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogVFggc3RhdHVzIGZvciB1bmV4cGVjdGVkIGRlc3RpbmF0aW9uIik7CisJCXJldHVybjsKKwl9CisJb3NfZ2V0X3JlbHRpbWUoJnF1ZXJ5LT5sYXN0X29wZXIpOworCisJaWYgKHJlc3VsdCA9PSBPRkZDSEFOTkVMX1NFTkRfQUNUSU9OX1NVQ0NFU1MpIHsKKwkJZWxvb3BfY2FuY2VsX3RpbWVvdXQoZ2FzX3F1ZXJ5X3RpbWVvdXQsIGdhcywgcXVlcnkpOworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KEdBU19RVUVSWV9USU1FT1VUX1BFUklPRCwgMCwKKwkJCQkgICAgICAgZ2FzX3F1ZXJ5X3RpbWVvdXQsIGdhcywgcXVlcnkpOworCX0KKwlpZiAocmVzdWx0ID09IE9GRkNIQU5ORUxfU0VORF9BQ1RJT05fRkFJTEVEKSB7CisJCWVsb29wX2NhbmNlbF90aW1lb3V0KGdhc19xdWVyeV90aW1lb3V0LCBnYXMsIHF1ZXJ5KTsKKwkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLCBnYXNfcXVlcnlfdGltZW91dCwgZ2FzLCBxdWVyeSk7CisJfQorfQorCisKK3N0YXRpYyBpbnQgcG1mX2luX3VzZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYWRkcikKK3sKKwlpZiAod3BhX3MtPmN1cnJlbnRfc3NpZCA9PSBOVUxMIHx8CisJICAgIHdwYV9zLT53cGFfc3RhdGUgPCBXUEFfNFdBWV9IQU5EU0hBS0UgfHwKKwkgICAgb3NfbWVtY21wKGFkZHIsIHdwYV9zLT5ic3NpZCwgRVRIX0FMRU4pICE9IDApCisJCXJldHVybiAwOworCXJldHVybiB3cGFfc21fcG1mX2VuYWJsZWQod3BhX3MtPndwYSk7Cit9CisKKwogc3RhdGljIGludCBnYXNfcXVlcnlfdHgoc3RydWN0IGdhc19xdWVyeSAqZ2FzLCBzdHJ1Y3QgZ2FzX3F1ZXJ5X3BlbmRpbmcgKnF1ZXJ5LAogCQkJc3RydWN0IHdwYWJ1ZiAqcmVxKQogewotCWludCByZXM7CisJdW5zaWduZWQgaW50IHdhaXRfdGltZTsKKwlpbnQgcmVzLCBwcm90ID0gcG1mX2luX3VzZShnYXMtPndwYV9zLCBxdWVyeS0+YWRkcik7CisKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogU2VuZCBhY3Rpb24gZnJhbWUgdG8gIiBNQUNTVFIgIiBsZW49JXUgIgotCQkgICAiZnJlcT0lZCIsIE1BQzJTVFIocXVlcnktPmFkZHIpLAotCQkgICAodW5zaWduZWQgaW50KSB3cGFidWZfbGVuKHJlcSksIHF1ZXJ5LT5mcmVxKTsKKwkJICAgImZyZXE9JWQgcHJvdD0lZCIsIE1BQzJTVFIocXVlcnktPmFkZHIpLAorCQkgICAodW5zaWduZWQgaW50KSB3cGFidWZfbGVuKHJlcSksIHF1ZXJ5LT5mcmVxLCBwcm90KTsKKwlpZiAocHJvdCkgeworCQl1OCAqY2F0ZWcgPSB3cGFidWZfbWhlYWRfdTgocmVxKTsKKwkJKmNhdGVnID0gV0xBTl9BQ1RJT05fUFJPVEVDVEVEX0RVQUw7CisJfQorCW9zX2dldF9yZWx0aW1lKCZxdWVyeS0+bGFzdF9vcGVyKTsKKwl3YWl0X3RpbWUgPSAxMDAwOworCWlmIChnYXMtPndwYV9zLT5tYXhfcmVtYWluX29uX2NoYW4gJiYKKwkgICAgd2FpdF90aW1lID4gZ2FzLT53cGFfcy0+bWF4X3JlbWFpbl9vbl9jaGFuKQorCQl3YWl0X3RpbWUgPSBnYXMtPndwYV9zLT5tYXhfcmVtYWluX29uX2NoYW47CiAJcmVzID0gb2ZmY2hhbm5lbF9zZW5kX2FjdGlvbihnYXMtPndwYV9zLCBxdWVyeS0+ZnJlcSwgcXVlcnktPmFkZHIsCiAJCQkJICAgICBnYXMtPndwYV9zLT5vd25fYWRkciwgcXVlcnktPmFkZHIsCi0JCQkJICAgICB3cGFidWZfaGVhZChyZXEpLCB3cGFidWZfbGVuKHJlcSksIDEwMDAsCi0JCQkJICAgICBOVUxMLCAwKTsKKwkJCQkgICAgIHdwYWJ1Zl9oZWFkKHJlcSksIHdwYWJ1Zl9sZW4ocmVxKSwKKwkJCQkgICAgIHdhaXRfdGltZSwgZ2FzX3F1ZXJ5X3R4X3N0YXR1cywgMCk7CiAJaWYgKHJlcyA9PSAwKQogCQlxdWVyeS0+b2ZmY2hhbm5lbF90eF9zdGFydGVkID0gMTsKIAlyZXR1cm4gcmVzOwpAQCAtMjk2LDI3ICs0MjIsNDEgQEAKIAogCiAvKioKLSAqIGdhc19xdWVyeV9yeCAtIEluZGljYXRlIHJlY2VwdGlvbiBvZiBhIFB1YmxpYyBBY3Rpb24gZnJhbWUKKyAqIGdhc19xdWVyeV9yeCAtIEluZGljYXRlIHJlY2VwdGlvbiBvZiBhIFB1YmxpYyBBY3Rpb24gb3IgUHJvdGVjdGVkIER1YWwgZnJhbWUKICAqIEBnYXM6IEdBUyBxdWVyeSBkYXRhIGZyb20gZ2FzX3F1ZXJ5X2luaXQoKQogICogQGRhOiBEZXN0aW5hdGlvbiBNQUMgYWRkcmVzcyBvZiB0aGUgQWN0aW9uIGZyYW1lCiAgKiBAc2E6IFNvdXJjZSBNQUMgYWRkcmVzcyBvZiB0aGUgQWN0aW9uIGZyYW1lCiAgKiBAYnNzaWQ6IEJTU0lEIG9mIHRoZSBBY3Rpb24gZnJhbWUKKyAqIEBjYXRlZzogQ2F0ZWdvcnkgb2YgdGhlIEFjdGlvbiBmcmFtZQogICogQGRhdGE6IFBheWxvYWQgb2YgdGhlIEFjdGlvbiBmcmFtZQogICogQGxlbjogTGVuZ3RoIG9mIEBkYXRhCiAgKiBAZnJlcTogRnJlcXVlbmN5IChpbiBNSHopIG9uIHdoaWNoIHRoZSBmcmFtZSB3YXMgcmVjZWl2ZWQKICAqIFJldHVybnM6IDAgaWYgdGhlIFB1YmxpYyBBY3Rpb24gZnJhbWUgd2FzIGEgR0FTIGZyYW1lIG9yIC0xIGlmIG5vdAogICovCiBpbnQgZ2FzX3F1ZXJ5X3J4KHN0cnVjdCBnYXNfcXVlcnkgKmdhcywgY29uc3QgdTggKmRhLCBjb25zdCB1OCAqc2EsCi0JCSBjb25zdCB1OCAqYnNzaWQsIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuLCBpbnQgZnJlcSkKKwkJIGNvbnN0IHU4ICpic3NpZCwgdTggY2F0ZWcsIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuLAorCQkgaW50IGZyZXEpCiB7CiAJc3RydWN0IGdhc19xdWVyeV9wZW5kaW5nICpxdWVyeTsKIAl1OCBhY3Rpb24sIGRpYWxvZ190b2tlbiwgZnJhZ19pZCA9IDAsIG1vcmVfZnJhZ3MgPSAwOwogCXUxNiBjb21lYmFja19kZWxheSwgcmVzcF9sZW47CiAJY29uc3QgdTggKnBvcywgKmFkdl9wcm90bzsKKwlpbnQgcHJvdCwgcG1mOwogCiAJaWYgKGdhcyA9PSBOVUxMIHx8IGxlbiA8IDQpCiAJCXJldHVybiAtMTsKIAorCXByb3QgPSBjYXRlZyA9PSBXTEFOX0FDVElPTl9QUk9URUNURURfRFVBTDsKKwlwbWYgPSBwbWZfaW5fdXNlKGdhcy0+d3BhX3MsIGJzc2lkKTsKKwlpZiAocHJvdCAmJiAhcG1mKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBEcm9wIHVuZXhwZWN0ZWQgcHJvdGVjdGVkIEdBUyBmcmFtZSB3aGVuIFBNRiBpcyBkaXNhYmxlZCIpOworCQlyZXR1cm4gMDsKKwl9CisJaWYgKCFwcm90ICYmIHBtZikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogRHJvcCB1bmV4cGVjdGVkIHVucHJvdGVjdGVkIEdBUyBmcmFtZSB3aGVuIFBNRiBpcyBlbmFibGVkIik7CisJCXJldHVybiAwOworCX0KKwogCXBvcyA9IGRhdGE7CiAJYWN0aW9uID0gKnBvcysrOwogCWRpYWxvZ190b2tlbiA9ICpwb3MrKzsKQEAgLTMzMiw2ICs0NzIsOSBAQAogCQlyZXR1cm4gLTE7CiAJfQogCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IFJlc3BvbnNlIGluICVkIG1zIGZyb20gIiBNQUNTVFIsCisJCSAgIG1zX2Zyb21fdGltZSgmcXVlcnktPmxhc3Rfb3BlciksIE1BQzJTVFIoc2EpKTsKKwogCWlmIChxdWVyeS0+d2FpdF9jb21lYmFjayAmJiBhY3Rpb24gPT0gV0xBTl9QQV9HQVNfSU5JVElBTF9SRVNQKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBVbmV4cGVjdGVkIGluaXRpYWwgcmVzcG9uc2UgZnJvbSAiCiAJCQkgICBNQUNTVFIgIiBkaWFsb2cgdG9rZW4gJXUgd2hlbiB3YWl0aW5nIGZvciBjb21lYmFjayAiCkBAIC0zNDksNyArNDkyLDEwIEBACiAJcXVlcnktPnN0YXR1c19jb2RlID0gV1BBX0dFVF9MRTE2KHBvcyk7CiAJcG9zICs9IDI7CiAKLQlpZiAocXVlcnktPnN0YXR1c19jb2RlICE9IFdMQU5fU1RBVFVTX1NVQ0NFU1MpIHsKKwlpZiAocXVlcnktPnN0YXR1c19jb2RlID09IFdMQU5fU1RBVFVTX1FVRVJZX1JFU1BfT1VUU1RBTkRJTkcgJiYKKwkgICAgYWN0aW9uID09IFdMQU5fUEFfR0FTX0NPTUVCQUNLX1JFU1ApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IEFsbG93IG5vbi16ZXJvIHN0YXR1cyBmb3Igb3V0c3RhbmRpbmcgY29tZWJhY2sgcmVzcG9uc2UiKTsKKwl9IGVsc2UgaWYgKHF1ZXJ5LT5zdGF0dXNfY29kZSAhPSBXTEFOX1NUQVRVU19TVUNDRVNTKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBRdWVyeSB0byAiIE1BQ1NUUiAiIGRpYWxvZyB0b2tlbiAiCiAJCQkgICAiJXUgZmFpbGVkIC0gc3RhdHVzIGNvZGUgJXUiLAogCQkJICAgTUFDMlNUUihzYSksIGRpYWxvZ190b2tlbiwgcXVlcnktPnN0YXR1c19jb2RlKTsKQEAgLTQyNiw4ICs1NzIsOSBAQAogCXN0cnVjdCBnYXNfcXVlcnkgKmdhcyA9IGVsb29wX2RhdGE7CiAJc3RydWN0IGdhc19xdWVyeV9wZW5kaW5nICpxdWVyeSA9IHVzZXJfY3R4OwogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IE5vIHJlc3BvbnNlIHJlY2VpdmVkIGZvciBxdWVyeSB0byAiIE1BQ1NUUiwKLQkJICAgTUFDMlNUUihxdWVyeS0+YWRkcikpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBObyByZXNwb25zZSByZWNlaXZlZCBmb3IgcXVlcnkgdG8gIiBNQUNTVFIKKwkJICAgIiBkaWFsb2cgdG9rZW4gJXUiLAorCQkgICBNQUMyU1RSKHF1ZXJ5LT5hZGRyKSwgcXVlcnktPmRpYWxvZ190b2tlbik7CiAJZ2FzX3F1ZXJ5X2RvbmUoZ2FzLCBxdWVyeSwgR0FTX1FVRVJZX1RJTUVPVVQpOwogfQogCkBAIC00NDYsMTIgKzU5Myw0NyBAQAogfQogCiAKK3N0YXRpYyB2b2lkIGdhc19xdWVyeV9zdGFydF9jYihzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcmssIGludCBkZWluaXQpCit7CisJc3RydWN0IGdhc19xdWVyeV9wZW5kaW5nICpxdWVyeSA9IHdvcmstPmN0eDsKKwlzdHJ1Y3QgZ2FzX3F1ZXJ5ICpnYXMgPSBxdWVyeS0+Z2FzOworCisJaWYgKGRlaW5pdCkgeworCQlpZiAod29yay0+c3RhcnRlZCkgeworCQkJZ2FzLT53b3JrID0gTlVMTDsKKwkJCWdhc19xdWVyeV9kb25lKGdhcywgcXVlcnksIEdBU19RVUVSWV9ERUxFVEVEX0FUX0RFSU5JVCk7CisJCQlyZXR1cm47CisJCX0KKworCQlnYXNfcXVlcnlfZnJlZShxdWVyeSwgMSk7CisJCXJldHVybjsKKwl9CisKKwlnYXMtPndvcmsgPSB3b3JrOworCisJaWYgKGdhc19xdWVyeV90eChnYXMsIHF1ZXJ5LCBxdWVyeS0+cmVxKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IEZhaWxlZCB0byBzZW5kIEFjdGlvbiBmcmFtZSB0byAiCisJCQkgICBNQUNTVFIsIE1BQzJTVFIocXVlcnktPmFkZHIpKTsKKwkJZ2FzX3F1ZXJ5X2ZyZWUocXVlcnksIDEpOworCQlyZXR1cm47CisJfQorCWdhcy0+Y3VycmVudCA9IHF1ZXJ5OworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IFN0YXJ0aW5nIHF1ZXJ5IHRpbWVvdXQgZm9yIGRpYWxvZyB0b2tlbiAldSIsCisJCSAgIHF1ZXJ5LT5kaWFsb2dfdG9rZW4pOworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoR0FTX1FVRVJZX1RJTUVPVVRfUEVSSU9ELCAwLAorCQkJICAgICAgIGdhc19xdWVyeV90aW1lb3V0LCBnYXMsIHF1ZXJ5KTsKKworfQorCisKIC8qKgogICogZ2FzX3F1ZXJ5X3JlcSAtIFJlcXVlc3QgYSBHQVMgcXVlcnkKICAqIEBnYXM6IEdBUyBxdWVyeSBkYXRhIGZyb20gZ2FzX3F1ZXJ5X2luaXQoKQogICogQGRzdDogRGVzdGluYXRpb24gTUFDIGFkZHJlc3MgZm9yIHRoZSBxdWVyeQogICogQGZyZXE6IEZyZXF1ZW5jeSAoaW4gTUh6KSBmb3IgdGhlIGNoYW5uZWwgb24gd2hpY2ggdG8gc2VuZCB0aGUgcXVlcnkKLSAqIEByZXE6IEdBUyBxdWVyeSBwYXlsb2FkCisgKiBAcmVxOiBHQVMgcXVlcnkgcGF5bG9hZCAodG8gYmUgZnJlZWQgYnkgZ2FzX3F1ZXJ5IG1vZHVsZSBpbiBjYXNlIG9mIHN1Y2Nlc3MKKyAqCXJldHVybikKICAqIEBjYjogQ2FsbGJhY2sgZnVuY3Rpb24gZm9yIHJlcG9ydGluZyBHQVMgcXVlcnkgcmVzdWx0IGFuZCByZXNwb25zZQogICogQGN0eDogQ29udGV4dCBwb2ludGVyIHRvIHVzZSB3aXRoIHRoZSBAY2IgY2FsbAogICogUmV0dXJuczogZGlhbG9nIHRva2VuICg+PSAwKSBvbiBzdWNjZXNzIG9yIC0xIG9uIGZhaWx1cmUKQEAgLTQ4NSwyOCArNjY3LDI3IEBACiAJaWYgKHF1ZXJ5ID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAorCXF1ZXJ5LT5nYXMgPSBnYXM7CiAJb3NfbWVtY3B5KHF1ZXJ5LT5hZGRyLCBkc3QsIEVUSF9BTEVOKTsKIAlxdWVyeS0+ZGlhbG9nX3Rva2VuID0gZGlhbG9nX3Rva2VuOwogCXF1ZXJ5LT5mcmVxID0gZnJlcTsKIAlxdWVyeS0+Y2IgPSBjYjsKIAlxdWVyeS0+Y3R4ID0gY3R4OworCXF1ZXJ5LT5yZXEgPSByZXE7CiAJZGxfbGlzdF9hZGQoJmdhcy0+cGVuZGluZywgJnF1ZXJ5LT5saXN0KTsKIAogCSood3BhYnVmX21oZWFkX3U4KHJlcSkgKyAyKSA9IGRpYWxvZ190b2tlbjsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBTdGFydGluZyByZXF1ZXN0IGZvciAiIE1BQ1NUUgotCQkgICAiIGRpYWxvZ190b2tlbiAldSIsIE1BQzJTVFIoZHN0KSwgZGlhbG9nX3Rva2VuKTsKLQlpZiAoZ2FzX3F1ZXJ5X3R4KGdhcywgcXVlcnksIHJlcSkgPCAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBGYWlsZWQgdG8gc2VuZCBBY3Rpb24gZnJhbWUgdG8gIgotCQkJICAgTUFDU1RSLCBNQUMyU1RSKHF1ZXJ5LT5hZGRyKSk7Ci0JCWRsX2xpc3RfZGVsKCZxdWVyeS0+bGlzdCk7Ci0JCW9zX2ZyZWUocXVlcnkpOworCXdwYV9tc2coZ2FzLT53cGFfcywgTVNHX0lORk8sIEdBU19RVUVSWV9TVEFSVCAiYWRkcj0iIE1BQ1NUUgorCQkiIGRpYWxvZ190b2tlbj0ldSBmcmVxPSVkIiwKKwkJTUFDMlNUUihxdWVyeS0+YWRkciksIHF1ZXJ5LT5kaWFsb2dfdG9rZW4sIHF1ZXJ5LT5mcmVxKTsKKworCWlmIChyYWRpb19hZGRfd29yayhnYXMtPndwYV9zLCBmcmVxLCAiZ2FzLXF1ZXJ5IiwgMCwgZ2FzX3F1ZXJ5X3N0YXJ0X2NiLAorCQkJICAgcXVlcnkpIDwgMCkgeworCQlnYXNfcXVlcnlfZnJlZShxdWVyeSwgMSk7CiAJCXJldHVybiAtMTsKIAl9CiAKLQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KEdBU19RVUVSWV9USU1FT1VUX1BFUklPRCwgMCwgZ2FzX3F1ZXJ5X3RpbWVvdXQsCi0JCQkgICAgICAgZ2FzLCBxdWVyeSk7Ci0KIAlyZXR1cm4gZGlhbG9nX3Rva2VuOwogfQogCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9nYXNfcXVlcnkuaCBiL3dwYV9zdXBwbGljYW50L2dhc19xdWVyeS5oCmluZGV4IDVjM2QxNjEuLmFkMTM0OTAgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2dhc19xdWVyeS5oCisrKyBiL3dwYV9zdXBwbGljYW50L2dhc19xdWVyeS5oCkBAIC0xNyw3ICsxNyw4IEBACiBzdHJ1Y3QgZ2FzX3F1ZXJ5ICogZ2FzX3F1ZXJ5X2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIGdhc19xdWVyeV9kZWluaXQoc3RydWN0IGdhc19xdWVyeSAqZ2FzKTsKIGludCBnYXNfcXVlcnlfcngoc3RydWN0IGdhc19xdWVyeSAqZ2FzLCBjb25zdCB1OCAqZGEsIGNvbnN0IHU4ICpzYSwKLQkJIGNvbnN0IHU4ICpic3NpZCwgY29uc3QgdTggKmRhdGEsIHNpemVfdCBsZW4sIGludCBmcmVxKTsKKwkJIGNvbnN0IHU4ICpic3NpZCwgdTggY2F0ZWcsIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuLAorCQkgaW50IGZyZXEpOwogCiAvKioKICAqIGVudW0gZ2FzX3F1ZXJ5X3Jlc3VsdCAtIEdBUyBxdWVyeSByZXN1bHQKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2hzMjBfc3VwcGxpY2FudC5jIGIvd3BhX3N1cHBsaWNhbnQvaHMyMF9zdXBwbGljYW50LmMKaW5kZXggNDA0OGNmNy4uMjU3YWE2ZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvaHMyMF9zdXBwbGljYW50LmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvaHMyMF9zdXBwbGljYW50LmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChjKSAyMDA5LCBBdGhlcm9zIENvbW11bmljYXRpb25zLCBJbmMuCi0gKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMiwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTMsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTQsMjIgKzE0LDY1IEBACiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImNvbW1vbi9nYXMuaCIKICNpbmNsdWRlICJjb21tb24vd3BhX2N0cmwuaCIKKyNpbmNsdWRlICJyc25fc3VwcC93cGEuaCIKICNpbmNsdWRlICJ3cGFfc3VwcGxpY2FudF9pLmgiCiAjaW5jbHVkZSAiZHJpdmVyX2kuaCIKICNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJzY2FuLmgiCiAjaW5jbHVkZSAiYnNzLmgiCisjaW5jbHVkZSAiYmxhY2tsaXN0LmgiCiAjaW5jbHVkZSAiZ2FzX3F1ZXJ5LmgiCiAjaW5jbHVkZSAiaW50ZXJ3b3JraW5nLmgiCiAjaW5jbHVkZSAiaHMyMF9zdXBwbGljYW50LmgiCiAKIAotdm9pZCB3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oc3RydWN0IHdwYWJ1ZiAqYnVmKQorI2RlZmluZSBPU1VfTUFYX0lURU1TIDEwCisKK3N0cnVjdCBvc3VfbGFuZ19zdHJpbmcgeworCWNoYXIgbGFuZ1s0XTsKKwljaGFyIHRleHRbMjUzXTsKK307CisKK3N0cnVjdCBvc3VfaWNvbiB7CisJdTE2IHdpZHRoOworCXUxNiBoZWlnaHQ7CisJY2hhciBsYW5nWzRdOworCWNoYXIgaWNvbl90eXBlWzI1Nl07CisJY2hhciBmaWxlbmFtZVsyNTZdOworCXVuc2lnbmVkIGludCBpZDsKKwl1bnNpZ25lZCBpbnQgZmFpbGVkOjE7Cit9OworCitzdHJ1Y3Qgb3N1X3Byb3ZpZGVyIHsKKwl1OCBic3NpZFtFVEhfQUxFTl07CisJdTggb3N1X3NzaWRbMzJdOworCXU4IG9zdV9zc2lkX2xlbjsKKwljaGFyIHNlcnZlcl91cmlbMjU2XTsKKwl1MzIgb3N1X21ldGhvZHM7IC8qIGJpdCAwID0gT01BLURNLCBiaXQgMSA9IFNPQVAtWE1MIFNQUCAqLworCWNoYXIgb3N1X25haVsyNTZdOworCXN0cnVjdCBvc3VfbGFuZ19zdHJpbmcgZnJpZW5kbHlfbmFtZVtPU1VfTUFYX0lURU1TXTsKKwlzaXplX3QgZnJpZW5kbHlfbmFtZV9jb3VudDsKKwlzdHJ1Y3Qgb3N1X2xhbmdfc3RyaW5nIHNlcnZfZGVzY1tPU1VfTUFYX0lURU1TXTsKKwlzaXplX3Qgc2Vydl9kZXNjX2NvdW50OworCXN0cnVjdCBvc3VfaWNvbiBpY29uW09TVV9NQVhfSVRFTVNdOworCXNpemVfdCBpY29uX2NvdW50OworfTsKKworCit2b2lkIHdwYXNfaHMyMF9hZGRfaW5kaWNhdGlvbihzdHJ1Y3Qgd3BhYnVmICpidWYsIGludCBwcHNfbW9faWQpCiB7CisJdTggY29uZjsKKwogCXdwYWJ1Zl9wdXRfdTgoYnVmLCBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUMpOwotCXdwYWJ1Zl9wdXRfdTgoYnVmLCA1KTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgcHBzX21vX2lkID49IDAgPyA3IDogNSk7CiAJd3BhYnVmX3B1dF9iZTI0KGJ1ZiwgT1VJX1dGQSk7CiAJd3BhYnVmX3B1dF91OChidWYsIEhTMjBfSU5ESUNBVElPTl9PVUlfVFlQRSk7Ci0Jd3BhYnVmX3B1dF91OChidWYsIDB4MDApOyAvKiBIb3RzcG90IENvbmZpZ3VyYXRpb24gKi8KKwljb25mID0gSFMyMF9WRVJTSU9OOworCWlmIChwcHNfbW9faWQgPj0gMCkKKwkJY29uZiB8PSBIUzIwX1BQU19NT19JRF9QUkVTRU5UOworCXdwYWJ1Zl9wdXRfdTgoYnVmLCBjb25mKTsKKwlpZiAocHBzX21vX2lkID49IDApCisJCXdwYWJ1Zl9wdXRfbGUxNihidWYsIHBwc19tb19pZCk7CiB9CiAKIApAQCAtNjIsMTUgKzEwNSwzNSBAQAogfQogCiAKLXN0cnVjdCB3cGFidWYgKiBoczIwX2J1aWxkX2FucXBfcmVxKHUzMiBzdHlwZXMsIGNvbnN0IHU4ICpwYXlsb2FkLAotCQkJCSAgICBzaXplX3QgcGF5bG9hZF9sZW4pCitpbnQgaHMyMF9nZXRfcHBzX21vX2lkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKIHsKLQlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkOworCisJaWYgKHNzaWQgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisKKwlpZiAoc3NpZC0+dXBkYXRlX2lkZW50aWZpZXIpCisJCXJldHVybiBzc2lkLT51cGRhdGVfaWRlbnRpZmllcjsKKworCWlmIChzc2lkLT5wYXJlbnRfY3JlZCA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKworCWZvciAoY3JlZCA9IHdwYV9zLT5jb25mLT5jcmVkOyBjcmVkOyBjcmVkID0gY3JlZC0+bmV4dCkgeworCQlpZiAoc3NpZC0+cGFyZW50X2NyZWQgPT0gY3JlZCkKKwkJCXJldHVybiBjcmVkLT51cGRhdGVfaWRlbnRpZmllcjsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCit2b2lkIGhzMjBfcHV0X2FucXBfcmVxKHUzMiBzdHlwZXMsIGNvbnN0IHU4ICpwYXlsb2FkLCBzaXplX3QgcGF5bG9hZF9sZW4sCisJCSAgICAgICBzdHJ1Y3Qgd3BhYnVmICpidWYpCit7CiAJdTggKmxlbl9wb3M7CiAKLQlidWYgPSBnYXNfYW5xcF9idWlsZF9pbml0aWFsX3JlcSgwLCAxMDAgKyBwYXlsb2FkX2xlbik7CiAJaWYgKGJ1ZiA9PSBOVUxMKQotCQlyZXR1cm4gTlVMTDsKKwkJcmV0dXJuOwogCiAJbGVuX3BvcyA9IGdhc19hbnFwX2FkZF9lbGVtZW50KGJ1ZiwgQU5RUF9WRU5ET1JfU1BFQ0lGSUMpOwogCXdwYWJ1Zl9wdXRfYmUyNChidWYsIE9VSV9XRkEpOwpAQCAtODAsNiArMTQzLDExIEBACiAJCXdwYWJ1Zl9wdXRfdTgoYnVmLCAwKTsgLyogUmVzZXJ2ZWQgKi8KIAkJaWYgKHBheWxvYWQpCiAJCQl3cGFidWZfcHV0X2RhdGEoYnVmLCBwYXlsb2FkLCBwYXlsb2FkX2xlbik7CisJfSBlbHNlIGlmIChzdHlwZXMgPT0gQklUKEhTMjBfU1RZUEVfSUNPTl9SRVFVRVNUKSkgeworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgSFMyMF9TVFlQRV9JQ09OX1JFUVVFU1QpOworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgMCk7IC8qIFJlc2VydmVkICovCisJCWlmIChwYXlsb2FkKQorCQkJd3BhYnVmX3B1dF9kYXRhKGJ1ZiwgcGF5bG9hZCwgcGF5bG9hZF9sZW4pOwogCX0gZWxzZSB7CiAJCXU4IGk7CiAJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBIUzIwX1NUWVBFX1FVRVJZX0xJU1QpOwpAQCAtOTIsNiArMTYwLDE5IEBACiAJZ2FzX2FucXBfc2V0X2VsZW1lbnRfbGVuKGJ1ZiwgbGVuX3Bvcyk7CiAKIAlnYXNfYW5xcF9zZXRfbGVuKGJ1Zik7Cit9CisKKworc3RydWN0IHdwYWJ1ZiAqIGhzMjBfYnVpbGRfYW5xcF9yZXEodTMyIHN0eXBlcywgY29uc3QgdTggKnBheWxvYWQsCisJCQkJICAgIHNpemVfdCBwYXlsb2FkX2xlbikKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisKKwlidWYgPSBnYXNfYW5xcF9idWlsZF9pbml0aWFsX3JlcSgwLCAxMDAgKyBwYXlsb2FkX2xlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWhzMjBfcHV0X2FucXBfcmVxKHN0eXBlcywgcGF5bG9hZCwgcGF5bG9hZF9sZW4sIGJ1Zik7CiAKIAlyZXR1cm4gYnVmOwogfQpAQCAtMTI1LDE2ICsyMDYsMTI2IEBACiAJcmVzID0gZ2FzX3F1ZXJ5X3JlcSh3cGFfcy0+Z2FzLCBkc3QsIGZyZXEsIGJ1ZiwgYW5xcF9yZXNwX2NiLCB3cGFfcyk7CiAJaWYgKHJlcyA8IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiBGYWlsZWQgdG8gc2VuZCBRdWVyeSBSZXF1ZXN0Iik7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CiAJCXJldCA9IC0xOwogCX0gZWxzZQogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IFF1ZXJ5IHN0YXJ0ZWQgd2l0aCBkaWFsb2cgdG9rZW4gIgogCQkJICAgIiV1IiwgcmVzKTsKIAotCXdwYWJ1Zl9mcmVlKGJ1Zik7CiAJcmV0dXJuIHJldDsKIH0KIAogCitzdGF0aWMgaW50IGhzMjBfcHJvY2Vzc19pY29uX2JpbmFyeV9maWxlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSBjb25zdCB1OCAqc2EsIGNvbnN0IHU4ICpwb3MsCisJCQkJCSBzaXplX3Qgc2xlbikKK3sKKwljaGFyIGZuYW1lWzI1Nl07CisJaW50IHBuZzsKKwlGSUxFICpmOworCXUxNiBkYXRhX2xlbjsKKworCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiUlgtSFMyMC1BTlFQICIgTUFDU1RSICIgSWNvbiBCaW5hcnkgRmlsZSIsCisJCU1BQzJTVFIoc2EpKTsKKworCWlmIChzbGVuIDwgNCkgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJIUyAyLjA6IFRvbyBzaG9ydCBJY29uIEJpbmFyeSBGaWxlICIKKwkJCSJ2YWx1ZSBmcm9tICIgTUFDU1RSLCBNQUMyU1RSKHNhKSk7CisJCXJldHVybiAtMTsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogRG93bmxvYWQgU3RhdHVzIENvZGUgJXUiLCAqcG9zKTsKKwlpZiAoKnBvcyAhPSAwKQorCQlyZXR1cm4gLTE7CisJcG9zKys7CisJc2xlbi0tOworCisJaWYgKChzaXplX3QpIDEgKyBwb3NbMF0gPiBzbGVuKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkhTIDIuMDogVG9vIHNob3J0IEljb24gQmluYXJ5IEZpbGUgIgorCQkJInZhbHVlIGZyb20gIiBNQUNTVFIsIE1BQzJTVFIoc2EpKTsKKwkJcmV0dXJuIC0xOworCX0KKwl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJJY29uIFR5cGUiLCBwb3MgKyAxLCBwb3NbMF0pOworCXBuZyA9IG9zX3N0cm5jYXNlY21wKChjaGFyICopIHBvcyArIDEsICJpbWFnZS9wbmciLCA5KSA9PSAwOworCXNsZW4gLT0gMSArIHBvc1swXTsKKwlwb3MgKz0gMSArIHBvc1swXTsKKworCWlmIChzbGVuIDwgMikgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJIUyAyLjA6IFRvbyBzaG9ydCBJY29uIEJpbmFyeSBGaWxlICIKKwkJCSJ2YWx1ZSBmcm9tICIgTUFDU1RSLCBNQUMyU1RSKHNhKSk7CisJCXJldHVybiAtMTsKKwl9CisJZGF0YV9sZW4gPSBXUEFfR0VUX0xFMTYocG9zKTsKKwlwb3MgKz0gMjsKKwlzbGVuIC09IDI7CisKKwlpZiAoZGF0YV9sZW4gPiBzbGVuKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkhTIDIuMDogVG9vIHNob3J0IEljb24gQmluYXJ5IEZpbGUgIgorCQkJInZhbHVlIGZyb20gIiBNQUNTVFIsIE1BQzJTVFIoc2EpKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSWNvbiBCaW5hcnkgRGF0YTogJXUgYnl0ZXMiLCBkYXRhX2xlbik7CisJaWYgKHdwYV9zLT5jb25mLT5vc3VfZGlyID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXdwYV9zLT5vc3VfaWNvbl9pZCsrOworCWlmICh3cGFfcy0+b3N1X2ljb25faWQgPT0gMCkKKwkJd3BhX3MtPm9zdV9pY29uX2lkKys7CisJc25wcmludGYoZm5hbWUsIHNpemVvZihmbmFtZSksICIlcy9vc3UtaWNvbi0ldS4lcyIsCisJCSB3cGFfcy0+Y29uZi0+b3N1X2Rpciwgd3BhX3MtPm9zdV9pY29uX2lkLAorCQkgcG5nID8gInBuZyIgOiAiaWNvbiIpOworCWYgPSBmb3BlbihmbmFtZSwgIndiIik7CisJaWYgKGYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWlmIChmd3JpdGUocG9zLCBzbGVuLCAxLCBmKSAhPSAxKSB7CisJCWZjbG9zZShmKTsKKwkJdW5saW5rKGZuYW1lKTsKKwkJcmV0dXJuIC0xOworCX0KKwlmY2xvc2UoZik7CisKKwl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIlJYLUhTMjAtQU5RUC1JQ09OICVzIiwgZm5hbWUpOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyB2b2lkIGhzMjBfY29udGludWVfaWNvbl9mZXRjaCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnNvY2tfY3R4KQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBlbG9vcF9jdHg7CisJaWYgKHdwYV9zLT5mZXRjaF9vc3VfaWNvbl9pbl9wcm9ncmVzcykKKwkJaHMyMF9uZXh0X29zdV9pY29uKHdwYV9zKTsKK30KKworCitzdGF0aWMgdm9pZCBoczIwX29zdV9pY29uX2ZldGNoX3Jlc3VsdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgcmVzKQoreworCXNpemVfdCBpLCBqOworCXN0cnVjdCBvc19yZWx0aW1lIG5vdywgdG1wOworCWludCBkdXI7CisKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKKwlvc19yZWx0aW1lX3N1Yigmbm93LCAmd3BhX3MtPm9zdV9pY29uX2ZldGNoX3N0YXJ0LCAmdG1wKTsKKwlkdXIgPSB0bXAuc2VjICogMTAwMCArIHRtcC51c2VjIC8gMTAwMDsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogSWNvbiBmZXRjaCBkdXI9JWQgbXMgcmVzPSVkIiwKKwkJICAgZHVyLCByZXMpOworCisJZm9yIChpID0gMDsgaSA8IHdwYV9zLT5vc3VfcHJvdl9jb3VudDsgaSsrKSB7CisJCXN0cnVjdCBvc3VfcHJvdmlkZXIgKm9zdSA9ICZ3cGFfcy0+b3N1X3Byb3ZbaV07CisJCWZvciAoaiA9IDA7IGogPCBvc3UtPmljb25fY291bnQ7IGorKykgeworCQkJc3RydWN0IG9zdV9pY29uICppY29uID0gJm9zdS0+aWNvbltqXTsKKwkJCWlmIChpY29uLT5pZCB8fCBpY29uLT5mYWlsZWQpCisJCQkJY29udGludWU7CisJCQlpZiAocmVzIDwgMCkKKwkJCQlpY29uLT5mYWlsZWQgPSAxOworCQkJZWxzZQorCQkJCWljb24tPmlkID0gd3BhX3MtPm9zdV9pY29uX2lkOworCQkJcmV0dXJuOworCQl9CisJfQorfQorCisKIHZvaWQgaHMyMF9wYXJzZV9yeF9oczIwX2FucXBfcmVzcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgY29uc3QgdTggKnNhLCBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IHNsZW4pCiB7CkBAIC0xNDIsNiArMzMzLDcgQEAKIAl1OCBzdWJ0eXBlOwogCXN0cnVjdCB3cGFfYnNzICpic3MgPSB3cGFfYnNzX2dldF9ic3NpZCh3cGFfcywgc2EpOwogCXN0cnVjdCB3cGFfYnNzX2FucXAgKmFucXAgPSBOVUxMOworCWludCByZXQ7CiAKIAlpZiAoc2xlbiA8IDIpCiAJCXJldHVybjsKQEAgLTIwNyw4ICszOTksNTM3IEBACiAJCQkJd3BhYnVmX2FsbG9jX2NvcHkocG9zLCBzbGVuKTsKIAkJfQogCQlicmVhazsKKwljYXNlIEhTMjBfU1RZUEVfT1NVX1BST1ZJREVSU19MSVNUOgorCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIlJYLUhTMjAtQU5RUCAiIE1BQ1NUUgorCQkJIiBPU1UgUHJvdmlkZXJzIGxpc3QiLCBNQUMyU1RSKHNhKSk7CisJCXdwYV9zLT5udW1fcHJvdl9mb3VuZCsrOworCQlpZiAoYW5xcCkgeworCQkJd3BhYnVmX2ZyZWUoYW5xcC0+aHMyMF9vc3VfcHJvdmlkZXJzX2xpc3QpOworCQkJYW5xcC0+aHMyMF9vc3VfcHJvdmlkZXJzX2xpc3QgPQorCQkJCXdwYWJ1Zl9hbGxvY19jb3B5KHBvcywgc2xlbik7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBIUzIwX1NUWVBFX0lDT05fQklOQVJZX0ZJTEU6CisJCXJldCA9IGhzMjBfcHJvY2Vzc19pY29uX2JpbmFyeV9maWxlKHdwYV9zLCBzYSwgcG9zLCBzbGVuKTsKKwkJaWYgKHdwYV9zLT5mZXRjaF9vc3VfaWNvbl9pbl9wcm9ncmVzcykgeworCQkJaHMyMF9vc3VfaWNvbl9mZXRjaF9yZXN1bHQod3BhX3MsIHJldCk7CisJCQllbG9vcF9jYW5jZWxfdGltZW91dChoczIwX2NvbnRpbnVlX2ljb25fZmV0Y2gsCisJCQkJCSAgICAgd3BhX3MsIE5VTEwpOworCQkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLCBoczIwX2NvbnRpbnVlX2ljb25fZmV0Y2gsCisJCQkJCSAgICAgICB3cGFfcywgTlVMTCk7CisJCX0KKwkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUzIwOiBVbnN1cHBvcnRlZCBzdWJ0eXBlICV1Iiwgc3VidHlwZSk7CiAJCWJyZWFrOwogCX0KIH0KKworCit2b2lkIGhzMjBfbm90aWZ5X3BhcnNlX2RvbmUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAoIXdwYV9zLT5mZXRjaF9vc3VfaWNvbl9pbl9wcm9ncmVzcykKKwkJcmV0dXJuOworCWlmIChlbG9vcF9pc190aW1lb3V0X3JlZ2lzdGVyZWQoaHMyMF9jb250aW51ZV9pY29uX2ZldGNoLCB3cGFfcywgTlVMTCkpCisJCXJldHVybjsKKwkvKgorCSAqIFdlIGFyZSBnb2luZyB0aHJvdWdoIGljb24gZmV0Y2gsIGJ1dCBubyBpY29uIHJlc3BvbnNlIHdhcyByZWNlaXZlZC4KKwkgKiBBc3N1bWUgdGhpcyBtZWFucyB0aGUgY3VycmVudCBBUCBjb3VsZCBub3QgcHJvdmlkZSBhbiBhbnN3ZXIgdG8gYXZvaWQKKwkgKiBnZXR0aW5nIHN0dWNrIGluIGZldGNoIGl0ZXJhdGlvbi4KKwkgKi8KKwloczIwX2ljb25fZmV0Y2hfZmFpbGVkKHdwYV9zKTsKK30KKworCitzdGF0aWMgdm9pZCBoczIwX2ZyZWVfb3N1X3Byb3ZfZW50cnkoc3RydWN0IG9zdV9wcm92aWRlciAqcHJvdikKK3sKK30KKworCit2b2lkIGhzMjBfZnJlZV9vc3VfcHJvdihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXNpemVfdCBpOworCWZvciAoaSA9IDA7IGkgPCB3cGFfcy0+b3N1X3Byb3ZfY291bnQ7IGkrKykKKwkJaHMyMF9mcmVlX29zdV9wcm92X2VudHJ5KCZ3cGFfcy0+b3N1X3Byb3ZbaV0pOworCW9zX2ZyZWUod3BhX3MtPm9zdV9wcm92KTsKKwl3cGFfcy0+b3N1X3Byb3YgPSBOVUxMOworCXdwYV9zLT5vc3VfcHJvdl9jb3VudCA9IDA7Cit9CisKKworc3RhdGljIHZvaWQgaHMyMF9vc3VfZmV0Y2hfZG9uZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWNoYXIgZm5hbWVbMjU2XTsKKwlGSUxFICpmOworCXNpemVfdCBpLCBqOworCisJd3BhX3MtPmZldGNoX29zdV9pbmZvID0gMDsKKwl3cGFfcy0+ZmV0Y2hfb3N1X2ljb25faW5fcHJvZ3Jlc3MgPSAwOworCisJaWYgKHdwYV9zLT5jb25mLT5vc3VfZGlyID09IE5VTEwpIHsKKwkJaHMyMF9mcmVlX29zdV9wcm92KHdwYV9zKTsKKwkJd3BhX3MtPmZldGNoX2FucXBfaW5fcHJvZ3Jlc3MgPSAwOworCQlyZXR1cm47CisJfQorCisJc25wcmludGYoZm5hbWUsIHNpemVvZihmbmFtZSksICIlcy9vc3UtcHJvdmlkZXJzLnR4dCIsCisJCSB3cGFfcy0+Y29uZi0+b3N1X2Rpcik7CisJZiA9IGZvcGVuKGZuYW1lLCAidyIpOworCWlmIChmID09IE5VTEwpIHsKKwkJaHMyMF9mcmVlX29zdV9wcm92KHdwYV9zKTsKKwkJcmV0dXJuOworCX0KKwlmb3IgKGkgPSAwOyBpIDwgd3BhX3MtPm9zdV9wcm92X2NvdW50OyBpKyspIHsKKwkJc3RydWN0IG9zdV9wcm92aWRlciAqb3N1ID0gJndwYV9zLT5vc3VfcHJvdltpXTsKKwkJaWYgKGkgPiAwKQorCQkJZnByaW50ZihmLCAiXG4iKTsKKwkJZnByaW50ZihmLCAiT1NVLVBST1ZJREVSICIgTUFDU1RSICJcbiIKKwkJCSJ1cmk9JXNcbiIKKwkJCSJtZXRob2RzPSUwOHhcbiIsCisJCQlNQUMyU1RSKG9zdS0+YnNzaWQpLCBvc3UtPnNlcnZlcl91cmksIG9zdS0+b3N1X21ldGhvZHMpOworCQlpZiAob3N1LT5vc3Vfc3NpZF9sZW4pIHsKKwkJCWZwcmludGYoZiwgIm9zdV9zc2lkPSVzXG4iLAorCQkJCXdwYV9zc2lkX3R4dChvc3UtPm9zdV9zc2lkLAorCQkJCQkgICAgIG9zdS0+b3N1X3NzaWRfbGVuKSk7CisJCX0KKwkJaWYgKG9zdS0+b3N1X25haVswXSkKKwkJCWZwcmludGYoZiwgIm9zdV9uYWk9JXNcbiIsIG9zdS0+b3N1X25haSk7CisJCWZvciAoaiA9IDA7IGogPCBvc3UtPmZyaWVuZGx5X25hbWVfY291bnQ7IGorKykgeworCQkJZnByaW50ZihmLCAiZnJpZW5kbHlfbmFtZT0lczolc1xuIiwKKwkJCQlvc3UtPmZyaWVuZGx5X25hbWVbal0ubGFuZywKKwkJCQlvc3UtPmZyaWVuZGx5X25hbWVbal0udGV4dCk7CisJCX0KKwkJZm9yIChqID0gMDsgaiA8IG9zdS0+c2Vydl9kZXNjX2NvdW50OyBqKyspIHsKKwkJCWZwcmludGYoZiwgImRlc2M9JXM6JXNcbiIsCisJCQkJb3N1LT5zZXJ2X2Rlc2Nbal0ubGFuZywKKwkJCQlvc3UtPnNlcnZfZGVzY1tqXS50ZXh0KTsKKwkJfQorCQlmb3IgKGogPSAwOyBqIDwgb3N1LT5pY29uX2NvdW50OyBqKyspIHsKKwkJCXN0cnVjdCBvc3VfaWNvbiAqaWNvbiA9ICZvc3UtPmljb25bal07CisJCQlpZiAoaWNvbi0+ZmFpbGVkKQorCQkJCWNvbnRpbnVlOyAvKiBjb3VsZCBub3QgZmV0Y2ggaWNvbiAqLworCQkJZnByaW50ZihmLCAiaWNvbj0ldToldToldTolczolczolc1xuIiwKKwkJCQlpY29uLT5pZCwgaWNvbi0+d2lkdGgsIGljb24tPmhlaWdodCwgaWNvbi0+bGFuZywKKwkJCQlpY29uLT5pY29uX3R5cGUsIGljb24tPmZpbGVuYW1lKTsKKwkJfQorCX0KKwlmY2xvc2UoZik7CisJaHMyMF9mcmVlX29zdV9wcm92KHdwYV9zKTsKKworCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiT1NVIHByb3ZpZGVyIGZldGNoIGNvbXBsZXRlZCIpOworCXdwYV9zLT5mZXRjaF9hbnFwX2luX3Byb2dyZXNzID0gMDsKK30KKworCit2b2lkIGhzMjBfbmV4dF9vc3VfaWNvbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXNpemVfdCBpLCBqOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IFJlYWR5IHRvIGZldGNoIG5leHQgaWNvbiIpOworCisJZm9yIChpID0gMDsgaSA8IHdwYV9zLT5vc3VfcHJvdl9jb3VudDsgaSsrKSB7CisJCXN0cnVjdCBvc3VfcHJvdmlkZXIgKm9zdSA9ICZ3cGFfcy0+b3N1X3Byb3ZbaV07CisJCWZvciAoaiA9IDA7IGogPCBvc3UtPmljb25fY291bnQ7IGorKykgeworCQkJc3RydWN0IG9zdV9pY29uICppY29uID0gJm9zdS0+aWNvbltqXTsKKwkJCWlmIChpY29uLT5pZCB8fCBpY29uLT5mYWlsZWQpCisJCQkJY29udGludWU7CisKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBUcnkgdG8gZmV0Y2ggaWNvbiAnJXMnICIKKwkJCQkgICAiZnJvbSAiIE1BQ1NUUiwgaWNvbi0+ZmlsZW5hbWUsCisJCQkJICAgTUFDMlNUUihvc3UtPmJzc2lkKSk7CisJCQlvc19nZXRfcmVsdGltZSgmd3BhX3MtPm9zdV9pY29uX2ZldGNoX3N0YXJ0KTsKKwkJCWlmIChoczIwX2FucXBfc2VuZF9yZXEod3BhX3MsIG9zdS0+YnNzaWQsCisJCQkJCSAgICAgICBCSVQoSFMyMF9TVFlQRV9JQ09OX1JFUVVFU1QpLAorCQkJCQkgICAgICAgKHU4ICopIGljb24tPmZpbGVuYW1lLAorCQkJCQkgICAgICAgb3Nfc3RybGVuKGljb24tPmZpbGVuYW1lKSkgPCAwKSB7CisJCQkJaWNvbi0+ZmFpbGVkID0gMTsKKwkJCQljb250aW51ZTsKKwkJCX0KKwkJCXJldHVybjsKKwkJfQorCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBObyBtb3JlIGljb25zIHRvIGZldGNoIik7CisJaHMyMF9vc3VfZmV0Y2hfZG9uZSh3cGFfcyk7Cit9CisKKworc3RhdGljIHZvaWQgaHMyMF9vc3VfYWRkX3Byb3Yoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9ic3MgKmJzcywKKwkJCSAgICAgIGNvbnN0IHU4ICpvc3Vfc3NpZCwgdTggb3N1X3NzaWRfbGVuLAorCQkJICAgICAgY29uc3QgdTggKnBvcywgc2l6ZV90IGxlbikKK3sKKwlzdHJ1Y3Qgb3N1X3Byb3ZpZGVyICpwcm92OworCWNvbnN0IHU4ICplbmQgPSBwb3MgKyBsZW47CisJdTE2IGxlbjI7CisJY29uc3QgdTggKnBvczI7CisKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJIUyAyLjA6IFBhcnNpbmcgT1NVIFByb3ZpZGVyIiwgcG9zLCBsZW4pOworCXByb3YgPSBvc19yZWFsbG9jX2FycmF5KHdwYV9zLT5vc3VfcHJvdiwKKwkJCQl3cGFfcy0+b3N1X3Byb3ZfY291bnQgKyAxLAorCQkJCXNpemVvZigqcHJvdikpOworCWlmIChwcm92ID09IE5VTEwpCisJCXJldHVybjsKKwl3cGFfcy0+b3N1X3Byb3YgPSBwcm92OworCXByb3YgPSAmcHJvdlt3cGFfcy0+b3N1X3Byb3ZfY291bnRdOworCW9zX21lbXNldChwcm92LCAwLCBzaXplb2YoKnByb3YpKTsKKworCW9zX21lbWNweShwcm92LT5ic3NpZCwgYnNzLT5ic3NpZCwgRVRIX0FMRU4pOworCW9zX21lbWNweShwcm92LT5vc3Vfc3NpZCwgb3N1X3NzaWQsIG9zdV9zc2lkX2xlbik7CisJcHJvdi0+b3N1X3NzaWRfbGVuID0gb3N1X3NzaWRfbGVuOworCisJLyogT1NVIEZyaWVuZGx5IE5hbWUgTGVuZ3RoICovCisJaWYgKHBvcyArIDIgPiBlbmQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IE5vdCBlbm91Z2ggcm9vbSBmb3IgT1NVICIKKwkJCSAgICJGcmllbmRseSBOYW1lIExlbmd0aCIpOworCQlyZXR1cm47CisJfQorCWxlbjIgPSBXUEFfR0VUX0xFMTYocG9zKTsKKwlwb3MgKz0gMjsKKwlpZiAocG9zICsgbGVuMiA+IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm90IGVub3VnaCByb29tIGZvciBPU1UgIgorCQkJICAgIkZyaWVuZGx5IE5hbWUgRHVwbGVzIik7CisJCXJldHVybjsKKwl9CisJcG9zMiA9IHBvczsKKwlwb3MgKz0gbGVuMjsKKworCS8qIE9TVSBGcmllbmRseSBOYW1lIER1cGxlcyAqLworCXdoaWxlIChwb3MyICsgNCA8PSBwb3MgJiYgcHJvdi0+ZnJpZW5kbHlfbmFtZV9jb3VudCA8IE9TVV9NQVhfSVRFTVMpIHsKKwkJc3RydWN0IG9zdV9sYW5nX3N0cmluZyAqZjsKKwkJaWYgKHBvczIgKyAxICsgcG9zMlswXSA+IHBvcyB8fCBwb3MyWzBdIDwgMykgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnZhbGlkIE9TVSBGcmllbmRseSBOYW1lIik7CisJCQlicmVhazsKKwkJfQorCQlmID0gJnByb3YtPmZyaWVuZGx5X25hbWVbcHJvdi0+ZnJpZW5kbHlfbmFtZV9jb3VudCsrXTsKKwkJb3NfbWVtY3B5KGYtPmxhbmcsIHBvczIgKyAxLCAzKTsKKwkJb3NfbWVtY3B5KGYtPnRleHQsIHBvczIgKyAxICsgMywgcG9zMlswXSAtIDMpOworCQlwb3MyICs9IDEgKyBwb3MyWzBdOworCX0KKworCS8qIE9TVSBTZXJ2ZXIgVVJJICovCisJaWYgKHBvcyArIDEgPiBlbmQgfHwgcG9zICsgMSArIHBvc1swXSA+IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm90IGVub3VnaCByb29tIGZvciBPU1UgU2VydmVyICIKKwkJCSAgICJVUkkiKTsKKwkJcmV0dXJuOworCX0KKwlvc19tZW1jcHkocHJvdi0+c2VydmVyX3VyaSwgcG9zICsgMSwgcG9zWzBdKTsKKwlwb3MgKz0gMSArIHBvc1swXTsKKworCS8qIE9TVSBNZXRob2QgbGlzdCAqLworCWlmIChwb3MgKyAxID4gZW5kIHx8IHBvcyArIDEgKyBwb3NbMF0gPiBlbmQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IE5vdCBlbm91Z2ggcm9vbSBmb3IgT1NVIE1ldGhvZCAiCisJCQkgICAibGlzdCIpOworCQlyZXR1cm47CisJfQorCXBvczIgPSBwb3MgKyAxOworCXBvcyArPSAxICsgcG9zWzBdOworCXdoaWxlIChwb3MyIDwgcG9zKSB7CisJCWlmICgqcG9zMiA8IDMyKQorCQkJcHJvdi0+b3N1X21ldGhvZHMgfD0gQklUKCpwb3MyKTsKKwkJcG9zMisrOworCX0KKworCS8qIEljb25zIEF2YWlsYWJsZSBMZW5ndGggKi8KKwlpZiAocG9zICsgMiA+IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm90IGVub3VnaCByb29tIGZvciBJY29ucyAiCisJCQkgICAiQXZhaWxhYmxlIExlbmd0aCIpOworCQlyZXR1cm47CisJfQorCWxlbjIgPSBXUEFfR0VUX0xFMTYocG9zKTsKKwlwb3MgKz0gMjsKKwlpZiAocG9zICsgbGVuMiA+IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm90IGVub3VnaCByb29tIGZvciBJY29ucyAiCisJCQkgICAiQXZhaWxhYmxlIik7CisJCXJldHVybjsKKwl9CisJcG9zMiA9IHBvczsKKwlwb3MgKz0gbGVuMjsKKworCS8qIEljb25zIEF2YWlsYWJsZSAqLworCXdoaWxlIChwb3MyIDwgcG9zKSB7CisJCXN0cnVjdCBvc3VfaWNvbiAqaWNvbiA9ICZwcm92LT5pY29uW3Byb3YtPmljb25fY291bnRdOworCQlpZiAocG9zMiArIDIgKyAyICsgMyArIDEgKyAxID4gcG9zKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogSW52YWxpZCBJY29uIE1ldGFkYXRhIik7CisJCQlicmVhazsKKwkJfQorCisJCWljb24tPndpZHRoID0gV1BBX0dFVF9MRTE2KHBvczIpOworCQlwb3MyICs9IDI7CisJCWljb24tPmhlaWdodCA9IFdQQV9HRVRfTEUxNihwb3MyKTsKKwkJcG9zMiArPSAyOworCQlvc19tZW1jcHkoaWNvbi0+bGFuZywgcG9zMiwgMyk7CisJCXBvczIgKz0gMzsKKworCQlpZiAocG9zMiArIDEgKyBwb3MyWzBdID4gcG9zKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm90IHJvb20gZm9yIEljb24gVHlwZSIpOworCQkJYnJlYWs7CisJCX0KKwkJb3NfbWVtY3B5KGljb24tPmljb25fdHlwZSwgcG9zMiArIDEsIHBvczJbMF0pOworCQlwb3MyICs9IDEgKyBwb3MyWzBdOworCisJCWlmIChwb3MyICsgMSArIHBvczJbMF0gPiBwb3MpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBOb3Qgcm9vbSBmb3IgSWNvbiAiCisJCQkJICAgIkZpbGVuYW1lIik7CisJCQlicmVhazsKKwkJfQorCQlvc19tZW1jcHkoaWNvbi0+ZmlsZW5hbWUsIHBvczIgKyAxLCBwb3MyWzBdKTsKKwkJcG9zMiArPSAxICsgcG9zMlswXTsKKworCQlwcm92LT5pY29uX2NvdW50Kys7CisJfQorCisJLyogT1NVX05BSSAqLworCWlmIChwb3MgKyAxID4gZW5kIHx8IHBvcyArIDEgKyBwb3NbMF0gPiBlbmQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IE5vdCBlbm91Z2ggcm9vbSBmb3IgT1NVX05BSSIpOworCQlyZXR1cm47CisJfQorCW9zX21lbWNweShwcm92LT5vc3VfbmFpLCBwb3MgKyAxLCBwb3NbMF0pOworCXBvcyArPSAxICsgcG9zWzBdOworCisJLyogT1NVIFNlcnZpY2UgRGVzY3JpcHRpb24gTGVuZ3RoICovCisJaWYgKHBvcyArIDIgPiBlbmQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IE5vdCBlbm91Z2ggcm9vbSBmb3IgT1NVICIKKwkJCSAgICJTZXJ2aWNlIERlc2NyaXB0aW9uIExlbmd0aCIpOworCQlyZXR1cm47CisJfQorCWxlbjIgPSBXUEFfR0VUX0xFMTYocG9zKTsKKwlwb3MgKz0gMjsKKwlpZiAocG9zICsgbGVuMiA+IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm90IGVub3VnaCByb29tIGZvciBPU1UgIgorCQkJICAgIlNlcnZpY2UgRGVzY3JpcHRpb24gRHVwbGVzIik7CisJCXJldHVybjsKKwl9CisJcG9zMiA9IHBvczsKKwlwb3MgKz0gbGVuMjsKKworCS8qIE9TVSBTZXJ2aWNlIERlc2NyaXB0aW9uIER1cGxlcyAqLworCXdoaWxlIChwb3MyICsgNCA8PSBwb3MgJiYgcHJvdi0+c2Vydl9kZXNjX2NvdW50IDwgT1NVX01BWF9JVEVNUykgeworCQlzdHJ1Y3Qgb3N1X2xhbmdfc3RyaW5nICpmOworCQlpZiAocG9zMiArIDEgKyBwb3MyWzBdID4gcG9zIHx8IHBvczJbMF0gPCAzKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludmFsaWQgT1NVIFNlcnZpY2UgIgorCQkJCSAgICJEZXNjcmlwdGlvbiIpOworCQkJYnJlYWs7CisJCX0KKwkJZiA9ICZwcm92LT5zZXJ2X2Rlc2NbcHJvdi0+c2Vydl9kZXNjX2NvdW50KytdOworCQlvc19tZW1jcHkoZi0+bGFuZywgcG9zMiArIDEsIDMpOworCQlvc19tZW1jcHkoZi0+dGV4dCwgcG9zMiArIDEgKyAzLCBwb3MyWzBdIC0gMyk7CisJCXBvczIgKz0gMSArIHBvczJbMF07CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IEFkZGVkIE9TVSBQcm92aWRlciB0aHJvdWdoICIgTUFDU1RSLAorCQkgICBNQUMyU1RSKGJzcy0+YnNzaWQpKTsKKwl3cGFfcy0+b3N1X3Byb3ZfY291bnQrKzsKK30KKworCit2b2lkIGhzMjBfb3N1X2ljb25fZmV0Y2goc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOworCXN0cnVjdCB3cGFidWYgKnByb3ZfYW5xcDsKKwljb25zdCB1OCAqcG9zLCAqZW5kOworCXUxNiBsZW47CisJY29uc3QgdTggKm9zdV9zc2lkOworCXU4IG9zdV9zc2lkX2xlbjsKKwl1OCBudW1fcHJvdmlkZXJzOworCisJaHMyMF9mcmVlX29zdV9wcm92KHdwYV9zKTsKKworCWRsX2xpc3RfZm9yX2VhY2goYnNzLCAmd3BhX3MtPmJzcywgc3RydWN0IHdwYV9ic3MsIGxpc3QpIHsKKwkJaWYgKGJzcy0+YW5xcCA9PSBOVUxMKQorCQkJY29udGludWU7CisJCXByb3ZfYW5xcCA9IGJzcy0+YW5xcC0+aHMyMF9vc3VfcHJvdmlkZXJzX2xpc3Q7CisJCWlmIChwcm92X2FucXAgPT0gTlVMTCkKKwkJCWNvbnRpbnVlOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogUGFyc2luZyBPU1UgUHJvdmlkZXJzIGxpc3QgZnJvbSAiCisJCQkgICBNQUNTVFIsIE1BQzJTVFIoYnNzLT5ic3NpZCkpOworCQl3cGFfaGV4ZHVtcF9idWYoTVNHX0RFQlVHLCAiSFMgMi4wOiBPU1UgUHJvdmlkZXJzIGxpc3QiLAorCQkJCXByb3ZfYW5xcCk7CisJCXBvcyA9IHdwYWJ1Zl9oZWFkKHByb3ZfYW5xcCk7CisJCWVuZCA9IHBvcyArIHdwYWJ1Zl9sZW4ocHJvdl9hbnFwKTsKKworCQkvKiBPU1UgU1NJRCAqLworCQlpZiAocG9zICsgMSA+IGVuZCkKKwkJCWNvbnRpbnVlOworCQlpZiAocG9zICsgMSArIHBvc1swXSA+IGVuZCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IE5vdCBlbm91Z2ggcm9vbSBmb3IgIgorCQkJCSAgICJPU1UgU1NJRCIpOworCQkJY29udGludWU7CisJCX0KKwkJb3N1X3NzaWRfbGVuID0gKnBvcysrOworCQlpZiAob3N1X3NzaWRfbGVuID4gMzIpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBJbnZhbGlkIE9TVSBTU0lEICIKKwkJCQkgICAiTGVuZ3RoICV1Iiwgb3N1X3NzaWRfbGVuKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCW9zdV9zc2lkID0gcG9zOworCQlwb3MgKz0gb3N1X3NzaWRfbGVuOworCisJCWlmIChwb3MgKyAxID4gZW5kKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm90IGVub3VnaCByb29tIGZvciAiCisJCQkJICAgIk51bWJlciBvZiBPU1UgUHJvdmlkZXJzIik7CisJCQljb250aW51ZTsKKwkJfQorCQludW1fcHJvdmlkZXJzID0gKnBvcysrOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTnVtYmVyIG9mIE9TVSBQcm92aWRlcnM6ICV1IiwKKwkJCSAgIG51bV9wcm92aWRlcnMpOworCisJCS8qIE9TVSBQcm92aWRlcnMgKi8KKwkJd2hpbGUgKHBvcyArIDIgPCBlbmQgJiYgbnVtX3Byb3ZpZGVycyA+IDApIHsKKwkJCW51bV9wcm92aWRlcnMtLTsKKwkJCWxlbiA9IFdQQV9HRVRfTEUxNihwb3MpOworCQkJcG9zICs9IDI7CisJCQlpZiAocG9zICsgbGVuID4gZW5kKQorCQkJCWJyZWFrOworCQkJaHMyMF9vc3VfYWRkX3Byb3Yod3BhX3MsIGJzcywgb3N1X3NzaWQsCisJCQkJCSAgb3N1X3NzaWRfbGVuLCBwb3MsIGxlbik7CisJCQlwb3MgKz0gbGVuOworCQl9CisKKwkJaWYgKHBvcyAhPSBlbmQpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBJZ25vcmVkICVkIGJ5dGVzIG9mICIKKwkJCQkgICAiZXh0cmEgZGF0YSBhZnRlciBPU1UgUHJvdmlkZXJzIiwKKwkJCQkgICAoaW50KSAoZW5kIC0gcG9zKSk7CisJCX0KKwl9CisKKwl3cGFfcy0+ZmV0Y2hfb3N1X2ljb25faW5fcHJvZ3Jlc3MgPSAxOworCWhzMjBfbmV4dF9vc3VfaWNvbih3cGFfcyk7Cit9CisKKworc3RhdGljIHZvaWQgaHMyMF9vc3Vfc2Nhbl9yZXNfaGFuZGxlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3JlcykKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk9TVSBwcm92aXNpb25pbmcgZmV0Y2ggc2NhbiBjb21wbGV0ZWQiKTsKKwl3cGFfcy0+bmV0d29ya19zZWxlY3QgPSAwOworCXdwYV9zLT5mZXRjaF9hbGxfYW5xcCA9IDE7CisJd3BhX3MtPmZldGNoX29zdV9pbmZvID0gMTsKKwl3cGFfcy0+ZmV0Y2hfb3N1X2ljb25faW5fcHJvZ3Jlc3MgPSAwOworCisJaW50ZXJ3b3JraW5nX3N0YXJ0X2ZldGNoX2FucXAod3BhX3MpOworfQorCisKK2ludCBoczIwX2ZldGNoX29zdShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IENhbm5vdCBzdGFydCBmZXRjaF9vc3UgLSAiCisJCQkgICAiaW50ZXJmYWNlIGRpc2FibGVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAod3BhX3MtPnNjYW5uaW5nKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBDYW5ub3Qgc3RhcnQgZmV0Y2hfb3N1IC0gIgorCQkJICAgInNjYW5uaW5nIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAod3BhX3MtPmNvbmYtPm9zdV9kaXIgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogQ2Fubm90IHN0YXJ0IGZldGNoX29zdSAtICIKKwkJCSAgICJvc3VfZGlyIG5vdCBjb25maWd1cmVkIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAod3BhX3MtPmZldGNoX2FucXBfaW5fcHJvZ3Jlc3MgfHwgd3BhX3MtPm5ldHdvcmtfc2VsZWN0KSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBDYW5ub3Qgc3RhcnQgZmV0Y2hfb3N1IC0gIgorCQkJICAgImZldGNoIGluIHByb2dyZXNzICglZCwgJWQpIiwKKwkJCSAgIHdwYV9zLT5mZXRjaF9hbnFwX2luX3Byb2dyZXNzLAorCQkJICAgd3BhX3MtPm5ldHdvcmtfc2VsZWN0KTsKKwkJcmV0dXJuIC0xOworCX0KKworCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiU3RhcnRpbmcgT1NVIHByb3Zpc2lvbmluZyBpbmZvcm1hdGlvbiBmZXRjaCIpOworCXdwYV9zLT5udW1fb3N1X3NjYW5zID0gMDsKKwl3cGFfcy0+bnVtX3Byb3ZfZm91bmQgPSAwOworCWhzMjBfc3RhcnRfb3N1X3NjYW4od3BhX3MpOworCisJcmV0dXJuIDA7Cit9CisKKwordm9pZCBoczIwX3N0YXJ0X29zdV9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJd3BhX3MtPm51bV9vc3Vfc2NhbnMrKzsKKwl3cGFfcy0+c2Nhbl9yZXEgPSBNQU5VQUxfU0NBTl9SRVE7CisJd3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPSBoczIwX29zdV9zY2FuX3Jlc19oYW5kbGVyOworCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKK30KKworCit2b2lkIGhzMjBfY2FuY2VsX2ZldGNoX29zdShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ2FuY2VsIE9TVSBmZXRjaCIpOworCWludGVyd29ya2luZ19zdG9wX2ZldGNoX2FucXAod3BhX3MpOworCXdwYV9zLT5uZXR3b3JrX3NlbGVjdCA9IDA7CisJd3BhX3MtPmZldGNoX29zdV9pbmZvID0gMDsKKwl3cGFfcy0+ZmV0Y2hfb3N1X2ljb25faW5fcHJvZ3Jlc3MgPSAwOworfQorCisKK3ZvaWQgaHMyMF9pY29uX2ZldGNoX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWhzMjBfb3N1X2ljb25fZmV0Y2hfcmVzdWx0KHdwYV9zLCAtMSk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaHMyMF9jb250aW51ZV9pY29uX2ZldGNoLCB3cGFfcywgTlVMTCk7CisJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLCBoczIwX2NvbnRpbnVlX2ljb25fZmV0Y2gsIHdwYV9zLCBOVUxMKTsKK30KKworCit2b2lkIGhzMjBfcnhfc3Vic2NyaXB0aW9uX3JlbWVkaWF0aW9uKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICAgY29uc3QgY2hhciAqdXJsLCB1OCBvc3VfbWV0aG9kKQoreworCWlmICh1cmwpCisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBIUzIwX1NVQlNDUklQVElPTl9SRU1FRElBVElPTiAiJXUgJXMiLAorCQkJb3N1X21ldGhvZCwgdXJsKTsKKwllbHNlCisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBIUzIwX1NVQlNDUklQVElPTl9SRU1FRElBVElPTik7Cit9CisKKwordm9pZCBoczIwX3J4X2RlYXV0aF9pbW1pbmVudF9ub3RpY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgdTggY29kZSwKKwkJCQkgICAgdTE2IHJlYXV0aF9kZWxheSwgY29uc3QgY2hhciAqdXJsKQoreworCWlmICghd3BhX3NtX3BtZl9lbmFibGVkKHdwYV9zLT53cGEpKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBJZ25vcmUgZGVhdXRoZW50aWNhdGlvbiBpbW1pbmVudCBub3RpY2Ugc2luY2UgUE1GIHdhcyBub3QgZW5hYmxlZCIpOworCQlyZXR1cm47CisJfQorCisJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIEhTMjBfREVBVVRIX0lNTUlORU5UX05PVElDRSAiJXUgJXUgJXMiLAorCQljb2RlLCByZWF1dGhfZGVsYXksIHVybCk7CisKKwlpZiAoY29kZSA9PSBIUzIwX0RFQVVUSF9SRUFTT05fQ09ERV9CU1MpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUyAyLjA6IEFkZCBCU1MgdG8gYmxhY2tsaXN0Iik7CisJCXdwYV9ibGFja2xpc3RfYWRkKHdwYV9zLCB3cGFfcy0+YnNzaWQpOworCQkvKiBUT0RPOiBGb3Igbm93LCBkaXNhYmxlIGZ1bGwgRVNTIHNpbmNlIHNvbWUgZHJpdmVycyBtYXkgbm90CisJCSAqIHN1cHBvcnQgZGlzYWJsaW5nIHBlciBCU1MuICovCisJCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkKSB7CisJCQlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CisJCQlvc19nZXRfcmVsdGltZSgmbm93KTsKKwkJCWlmIChub3cuc2VjICsgcmVhdXRoX2RlbGF5IDw9CisJCQkgICAgd3BhX3MtPmN1cnJlbnRfc3NpZC0+ZGlzYWJsZWRfdW50aWwuc2VjKQorCQkJCXJldHVybjsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMgMi4wOiBEaXNhYmxlIG5ldHdvcmsgZm9yICV1IHNlY29uZHMgKEJTUykiLAorCQkJCSAgIHJlYXV0aF9kZWxheSk7CisJCQl3cGFfcy0+Y3VycmVudF9zc2lkLT5kaXNhYmxlZF91bnRpbC5zZWMgPQorCQkJCW5vdy5zZWMgKyByZWF1dGhfZGVsYXk7CisJCX0KKwl9CisKKwlpZiAoY29kZSA9PSBIUzIwX0RFQVVUSF9SRUFTT05fQ09ERV9FU1MgJiYgd3BhX3MtPmN1cnJlbnRfc3NpZCkgeworCQlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CisJCW9zX2dldF9yZWx0aW1lKCZub3cpOworCQlpZiAobm93LnNlYyArIHJlYXV0aF9kZWxheSA8PQorCQkgICAgd3BhX3MtPmN1cnJlbnRfc3NpZC0+ZGlzYWJsZWRfdW50aWwuc2VjKQorCQkJcmV0dXJuOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogRGlzYWJsZSBuZXR3b3JrIGZvciAldSBzZWNvbmRzIiwKKwkJCSAgIHJlYXV0aF9kZWxheSk7CisJCXdwYV9zLT5jdXJyZW50X3NzaWQtPmRpc2FibGVkX3VudGlsLnNlYyA9CisJCQlub3cuc2VjICsgcmVhdXRoX2RlbGF5OworCX0KK30KKworCit2b2lkIGhzMjBfZGVpbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaHMyMF9jb250aW51ZV9pY29uX2ZldGNoLCB3cGFfcywgTlVMTCk7CisJaHMyMF9mcmVlX29zdV9wcm92KHdwYV9zKTsKK30KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2hzMjBfc3VwcGxpY2FudC5oIGIvd3BhX3N1cHBsaWNhbnQvaHMyMF9zdXBwbGljYW50LmgKaW5kZXggMWM4NDgxYi4uMDY3MzlmNSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvaHMyMF9zdXBwbGljYW50LmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvaHMyMF9zdXBwbGljYW50LmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTIsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEzLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTgsMTUgKzgsMzMgQEAKICNpZm5kZWYgSFMyMF9TVVBQTElDQU5UX0gKICNkZWZpbmUgSFMyMF9TVVBQTElDQU5UX0gKIAotdm9pZCB3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oc3RydWN0IHdwYWJ1ZiAqYnVmKTsKK3ZvaWQgd3Bhc19oczIwX2FkZF9pbmRpY2F0aW9uKHN0cnVjdCB3cGFidWYgKmJ1ZiwgaW50IHBwc19tb19pZCk7CiAKIGludCBoczIwX2FucXBfc2VuZF9yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmRzdCwgdTMyIHN0eXBlcywKIAkJICAgICAgIGNvbnN0IHU4ICpwYXlsb2FkLCBzaXplX3QgcGF5bG9hZF9sZW4pOwogc3RydWN0IHdwYWJ1ZiAqIGhzMjBfYnVpbGRfYW5xcF9yZXEodTMyIHN0eXBlcywgY29uc3QgdTggKnBheWxvYWQsCiAJCQkJICAgIHNpemVfdCBwYXlsb2FkX2xlbik7Cit2b2lkIGhzMjBfcHV0X2FucXBfcmVxKHUzMiBzdHlwZXMsIGNvbnN0IHU4ICpwYXlsb2FkLCBzaXplX3QgcGF5bG9hZF9sZW4sCisJCSAgICAgICBzdHJ1Y3Qgd3BhYnVmICpidWYpOwogdm9pZCBoczIwX3BhcnNlX3J4X2hzMjBfYW5xcF9yZXNwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJICBjb25zdCB1OCAqc2EsIGNvbnN0IHU4ICpkYXRhLCBzaXplX3Qgc2xlbik7CiBpbnQgaXNfaHMyMF9uZXR3b3JrKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCwKIAkJICAgIHN0cnVjdCB3cGFfYnNzICpic3MpOworaW50IGhzMjBfZ2V0X3Bwc19tb19pZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpOwordm9pZCBoczIwX25vdGlmeV9wYXJzZV9kb25lKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworCit2b2lkIGhzMjBfcnhfc3Vic2NyaXB0aW9uX3JlbWVkaWF0aW9uKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICAgY29uc3QgY2hhciAqdXJsLCB1OCBvc3VfbWV0aG9kKTsKK3ZvaWQgaHMyMF9yeF9kZWF1dGhfaW1taW5lbnRfbm90aWNlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHU4IGNvZGUsCisJCQkJICAgIHUxNiByZWF1dGhfZGVsYXksIGNvbnN0IGNoYXIgKnVybCk7CisKK3ZvaWQgaHMyMF9mcmVlX29zdV9wcm92KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwordm9pZCBoczIwX25leHRfb3N1X2ljb24oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIGhzMjBfb3N1X2ljb25fZmV0Y2goc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CitpbnQgaHMyMF9mZXRjaF9vc3Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIGhzMjBfY2FuY2VsX2ZldGNoX29zdShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3ZvaWQgaHMyMF9pY29uX2ZldGNoX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3ZvaWQgaHMyMF9zdGFydF9vc3Vfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3ZvaWQgaHMyMF9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiAKICNlbmRpZiAvKiBIUzIwX1NVUFBMSUNBTlRfSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvaWJzc19yc24uYyBiL3dwYV9zdXBwbGljYW50L2lic3NfcnNuLmMKaW5kZXggNDdlZjM1ZS4uMzA4M2RkOCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvaWJzc19yc24uYworKysgYi93cGFfc3VwcGxpY2FudC9pYnNzX3Jzbi5jCkBAIC01OTAsNyArNTkwLDcgQEAKIAkJcGVlci0+YXV0aGVudGljYXRpb25fc3RhdHVzIHw9IElCU1NfUlNOX0FVVEhfQllfVVM7CiAJCXJldHVybiBpYnNzX3Jzbl9hdXRoX2luaXQoaWJzc19yc24sIHBlZXIpOwogCX0gZWxzZSB7Ci0JCW9zX2dldF90aW1lKCZwZWVyLT5vd25fYXV0aF90eCk7CisJCW9zX2dldF9yZWx0aW1lKCZwZWVyLT5vd25fYXV0aF90eCk7CiAJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMSwgMCwgaWJzc19yc25fYXV0aF90aW1lb3V0LCBwZWVyLCBOVUxMKTsKIAl9CiAKQEAgLTgzNCw5ICs4MzQsOSBAQAogCWlmIChwZWVyICYmCiAJICAgIHBlZXItPmF1dGhlbnRpY2F0aW9uX3N0YXR1cyAmIElCU1NfUlNOX0FVVEhfRUFQT0xfQllfUEVFUikgewogCQlpZiAocGVlci0+b3duX2F1dGhfdHguc2VjKSB7Ci0JCQlzdHJ1Y3Qgb3NfdGltZSBub3csIGRpZmY7Ci0JCQlvc19nZXRfdGltZSgmbm93KTsKLQkJCW9zX3RpbWVfc3ViKCZub3csICZwZWVyLT5vd25fYXV0aF90eCwgJmRpZmYpOworCQkJc3RydWN0IG9zX3JlbHRpbWUgbm93LCBkaWZmOworCQkJb3NfZ2V0X3JlbHRpbWUoJm5vdyk7CisJCQlvc19yZWx0aW1lX3N1Yigmbm93LCAmcGVlci0+b3duX2F1dGhfdHgsICZkaWZmKTsKIAkJCWlmIChkaWZmLnNlYyA9PSAwICYmIGRpZmYudXNlYyA8IDUwMDAwMCkgewogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUlNOOiBTa2lwIElCU1MgcmVpbml0IHNpbmNlIG9ubHkgJXUgdXNlYyBmcm9tIG93biBBdXRoIGZyYW1lIFRYIiwKIAkJCQkJICAgKGludCkgZGlmZi51c2VjKTsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2lic3NfcnNuLmggYi93cGFfc3VwcGxpY2FudC9pYnNzX3Jzbi5oCmluZGV4IDMwODkyODMuLjY3ZmFlMmQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2lic3NfcnNuLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvaWJzc19yc24uaApAQCAtNDAsNyArNDAsNyBAQAogCXN0cnVjdCB3cGFfc3RhdGVfbWFjaGluZSAqYXV0aDsKIAlpbnQgYXV0aGVudGljYXRpb25fc3RhdHVzOwogCi0Jc3RydWN0IG9zX3RpbWUgb3duX2F1dGhfdHg7CisJc3RydWN0IG9zX3JlbHRpbWUgb3duX2F1dGhfdHg7CiB9OwogCiBzdHJ1Y3QgaWJzc19yc24gewpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvaW50ZXJ3b3JraW5nLmMgYi93cGFfc3VwcGxpY2FudC9pbnRlcndvcmtpbmcuYwppbmRleCAzNmY3NWExLi4xOWI2ZTM4IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9pbnRlcndvcmtpbmcuYworKysgYi93cGFfc3VwcGxpY2FudC9pbnRlcndvcmtpbmcuYwpAQCAtMSw2ICsxLDcgQEAKIC8qCiAgKiBJbnRlcndvcmtpbmcgKElFRUUgODAyLjExdSkKLSAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEyLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMywgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTE4LDEyICsxOSwxNSBAQAogI2luY2x1ZGUgImVhcF9jb21tb24vZWFwX2RlZnMuaCIKICNpbmNsdWRlICJlYXBfcGVlci9lYXAuaCIKICNpbmNsdWRlICJlYXBfcGVlci9lYXBfbWV0aG9kcy5oIgorI2luY2x1ZGUgImVhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5oIgorI2luY2x1ZGUgInJzbl9zdXBwL3dwYS5oIgogI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJjb25maWdfc3NpZC5oIgogI2luY2x1ZGUgImJzcy5oIgogI2luY2x1ZGUgInNjYW4uaCIKICNpbmNsdWRlICJub3RpZnkuaCIKKyNpbmNsdWRlICJkcml2ZXJfaS5oIgogI2luY2x1ZGUgImdhc19xdWVyeS5oIgogI2luY2x1ZGUgImhzMjBfc3VwcGxpY2FudC5oIgogI2luY2x1ZGUgImludGVyd29ya2luZy5oIgpAQCAtNDMsOSArNDcsMjggQEAKIAogc3RhdGljIHZvaWQgaW50ZXJ3b3JraW5nX25leHRfYW5xcF9mZXRjaChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIHN0YXRpYyBzdHJ1Y3Qgd3BhX2NyZWQgKiBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JlYWxtKAotCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpOworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MsIGludCBpZ25vcmVfYncsCisJaW50ICpleGNsdWRlZCk7CiBzdGF0aWMgc3RydWN0IHdwYV9jcmVkICogaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV8zZ3BwKAotCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpOworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MsIGludCBpZ25vcmVfYncsCisJaW50ICpleGNsdWRlZCk7CisKKworc3RhdGljIGludCBjcmVkX3ByaW9fY21wKGNvbnN0IHN0cnVjdCB3cGFfY3JlZCAqYSwgY29uc3Qgc3RydWN0IHdwYV9jcmVkICpiKQoreworCWlmIChhLT5wcmlvcml0eSA+IGItPnByaW9yaXR5KQorCQlyZXR1cm4gMTsKKwlpZiAoYS0+cHJpb3JpdHkgPCBiLT5wcmlvcml0eSkKKwkJcmV0dXJuIC0xOworCWlmIChhLT5wcm92aXNpb25pbmdfc3AgPT0gTlVMTCB8fCBiLT5wcm92aXNpb25pbmdfc3AgPT0gTlVMTCB8fAorCSAgICBvc19zdHJjbXAoYS0+cHJvdmlzaW9uaW5nX3NwLCBiLT5wcm92aXNpb25pbmdfc3ApICE9IDApCisJCXJldHVybiAwOworCWlmIChhLT5zcF9wcmlvcml0eSA8IGItPnNwX3ByaW9yaXR5KQorCQlyZXR1cm4gMTsKKwlpZiAoYS0+c3BfcHJpb3JpdHkgPiBiLT5zcF9wcmlvcml0eSkKKwkJcmV0dXJuIC0xOworCXJldHVybiAwOworfQogCiAKIHN0YXRpYyB2b2lkIGludGVyd29ya2luZ19yZWNvbm5lY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKQEAgLTk5LDYgKzEyMiw5IEBACiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKIAorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogUmVzcG9uc2UgY2FsbGJhY2sgZHN0PSIgTUFDU1RSCisJCSAgICIgZGlhbG9nX3Rva2VuPSV1IHJlc3VsdD0lZCBzdGF0dXNfY29kZT0ldSIsCisJCSAgIE1BQzJTVFIoZHN0KSwgZGlhbG9nX3Rva2VuLCByZXN1bHQsIHN0YXR1c19jb2RlKTsKIAlhbnFwX3Jlc3BfY2Iod3BhX3MsIGRzdCwgZGlhbG9nX3Rva2VuLCByZXN1bHQsIGFkdl9wcm90bywgcmVzcCwKIAkJICAgICBzdGF0dXNfY29kZSk7CiAJaW50ZXJ3b3JraW5nX25leHRfYW5xcF9mZXRjaCh3cGFfcyk7CkBAIC0xMTIsNiArMTM4LDggQEAKIAlmb3IgKGNyZWQgPSB3cGFfcy0+Y29uZi0+Y3JlZDsgY3JlZDsgY3JlZCA9IGNyZWQtPm5leHQpIHsKIAkJaWYgKGNyZWQtPnJvYW1pbmdfY29uc29ydGl1bV9sZW4pCiAJCQlyZXR1cm4gMTsKKwkJaWYgKGNyZWQtPnJlcXVpcmVkX3JvYW1pbmdfY29uc29ydGl1bV9sZW4pCisJCQlyZXR1cm4gMTsKIAl9CiAJcmV0dXJuIDA7CiB9CkBAIC0xNTAsMTMgKzE3OCw0NSBAQAogCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKIAogCWZvciAoY3JlZCA9IHdwYV9zLT5jb25mLT5jcmVkOyBjcmVkOyBjcmVkID0gY3JlZC0+bmV4dCkgewotCQlpZiAoY3JlZC0+ZG9tYWluIHx8IGNyZWQtPnBjc2MgfHwgY3JlZC0+aW1zaSkKKwkJaWYgKGNyZWQtPmRvbWFpbiB8fCBjcmVkLT5wY3NjIHx8IGNyZWQtPmltc2kgfHwKKwkJICAgIGNyZWQtPnJvYW1pbmdfcGFydG5lcikKIAkJCXJldHVybiAxOwogCX0KIAlyZXR1cm4gMDsKIH0KIAogCisjaWZkZWYgQ09ORklHX0hTMjAKKworc3RhdGljIGludCBjcmVkX3dpdGhfbWluX2JhY2toYXVsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkOworCisJZm9yIChjcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7IGNyZWQ7IGNyZWQgPSBjcmVkLT5uZXh0KSB7CisJCWlmIChjcmVkLT5taW5fZGxfYmFuZHdpZHRoX2hvbWUgfHwKKwkJICAgIGNyZWQtPm1pbl91bF9iYW5kd2lkdGhfaG9tZSB8fAorCQkgICAgY3JlZC0+bWluX2RsX2JhbmR3aWR0aF9yb2FtaW5nIHx8CisJCSAgICBjcmVkLT5taW5fdWxfYmFuZHdpZHRoX3JvYW1pbmcpCisJCQlyZXR1cm4gMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBjcmVkX3dpdGhfY29ubl9jYXBhYihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKKworCWZvciAoY3JlZCA9IHdwYV9zLT5jb25mLT5jcmVkOyBjcmVkOyBjcmVkID0gY3JlZC0+bmV4dCkgeworCQlpZiAoY3JlZC0+bnVtX3JlcV9jb25uX2NhcGFiKQorCQkJcmV0dXJuIDE7CisJfQorCXJldHVybiAwOworfQorCisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKworCiBzdGF0aWMgaW50IGFkZGl0aW9uYWxfcm9hbWluZ19jb25zb3J0aXVtcyhzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQogewogCWNvbnN0IHU4ICppZTsKQEAgLTIwMSw4ICsyNjEsMTAgQEAKIAkJaW5mb19pZHNbbnVtX2luZm9faWRzKytdID0gQU5RUF9JUF9BRERSX1RZUEVfQVZBSUxBQklMSVRZOwogCWlmIChhbGwgfHwgY3JlZF93aXRoX25haV9yZWFsbSh3cGFfcykpCiAJCWluZm9faWRzW251bV9pbmZvX2lkcysrXSA9IEFOUVBfTkFJX1JFQUxNOwotCWlmIChhbGwgfHwgY3JlZF93aXRoXzNncHAod3BhX3MpKQorCWlmIChhbGwgfHwgY3JlZF93aXRoXzNncHAod3BhX3MpKSB7CiAJCWluZm9faWRzW251bV9pbmZvX2lkcysrXSA9IEFOUVBfM0dQUF9DRUxMVUxBUl9ORVRXT1JLOworCQl3cGFfc3VwcGxpY2FudF9zY2FyZF9pbml0KHdwYV9zLCBOVUxMKTsKKwl9CiAJaWYgKGFsbCB8fCBjcmVkX3dpdGhfZG9tYWluKHdwYV9zKSkKIAkJaW5mb19pZHNbbnVtX2luZm9faWRzKytdID0gQU5RUF9ET01BSU5fTkFNRTsKIAl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IEFOUVAgUXVlcnkgaW5mbyIsCkBAIC0yMjIsMTMgKzI4NCwxNyBAQAogCQl3cGFidWZfcHV0X3U4KGV4dHJhLCBIUzIwX1NUWVBFX1FVRVJZX0xJU1QpOwogCQl3cGFidWZfcHV0X3U4KGV4dHJhLCAwKTsgLyogUmVzZXJ2ZWQgKi8KIAkJd3BhYnVmX3B1dF91OChleHRyYSwgSFMyMF9TVFlQRV9DQVBBQklMSVRZX0xJU1QpOwotCQlpZiAoYWxsKSB7CisJCWlmIChhbGwpCiAJCQl3cGFidWZfcHV0X3U4KGV4dHJhLAogCQkJCSAgICAgIEhTMjBfU1RZUEVfT1BFUkFUT1JfRlJJRU5ETFlfTkFNRSk7CisJCWlmIChhbGwgfHwgY3JlZF93aXRoX21pbl9iYWNraGF1bCh3cGFfcykpCiAJCQl3cGFidWZfcHV0X3U4KGV4dHJhLCBIUzIwX1NUWVBFX1dBTl9NRVRSSUNTKTsKKwkJaWYgKGFsbCB8fCBjcmVkX3dpdGhfY29ubl9jYXBhYih3cGFfcykpCiAJCQl3cGFidWZfcHV0X3U4KGV4dHJhLCBIUzIwX1NUWVBFX0NPTk5FQ1RJT05fQ0FQQUJJTElUWSk7CisJCWlmIChhbGwpCiAJCQl3cGFidWZfcHV0X3U4KGV4dHJhLCBIUzIwX1NUWVBFX09QRVJBVElOR19DTEFTUyk7Ci0JCX0KKwkJaWYgKGFsbCkKKwkJCXdwYWJ1Zl9wdXRfdTgoZXh0cmEsIEhTMjBfU1RZUEVfT1NVX1BST1ZJREVSU19MSVNUKTsKIAkJZ2FzX2FucXBfc2V0X2VsZW1lbnRfbGVuKGV4dHJhLCBsZW5fcG9zKTsKIAl9CiAjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KQEAgLTI0Miw2ICszMDgsNyBAQAogCQkJICAgIGludGVyd29ya2luZ19hbnFwX3Jlc3BfY2IsIHdwYV9zKTsKIAlpZiAocmVzIDwgMCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IEZhaWxlZCB0byBzZW5kIFF1ZXJ5IFJlcXVlc3QiKTsKKwkJd3BhYnVmX2ZyZWUoYnVmKTsKIAkJcmV0ID0gLTE7CiAJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMCwgMCwgaW50ZXJ3b3JraW5nX2NvbnRpbnVlX2FucXAsIHdwYV9zLAogCQkJCSAgICAgICBOVUxMKTsKQEAgLTI0OSw3ICszMTYsNiBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IFF1ZXJ5IHN0YXJ0ZWQgd2l0aCBkaWFsb2cgdG9rZW4gIgogCQkJICAgIiV1IiwgcmVzKTsKIAotCXdwYWJ1Zl9mcmVlKGJ1Zik7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtNTE2LDEyICs1ODIsMTMgQEAKIAlpZiAoZWFwX2dldF9uYW1lKEVBUF9WRU5ET1JfSUVURiwgZWFwLT5tZXRob2QpID09IE5VTEwpCiAJCXJldHVybiAwOyAvKiBtZXRob2Qgbm90IHN1cHBvcnRlZCAqLwogCi0JaWYgKGVhcC0+bWV0aG9kICE9IEVBUF9UWVBFX1RUTFMgJiYgZWFwLT5tZXRob2QgIT0gRUFQX1RZUEVfUEVBUCkgeworCWlmIChlYXAtPm1ldGhvZCAhPSBFQVBfVFlQRV9UVExTICYmIGVhcC0+bWV0aG9kICE9IEVBUF9UWVBFX1BFQVAgJiYKKwkgICAgZWFwLT5tZXRob2QgIT0gRUFQX1RZUEVfRkFTVCkgewogCQkvKiBPbmx5IHR1bm5lbGVkIG1ldGhvZHMgd2l0aCB1c2VybmFtZS9wYXNzd29yZCBzdXBwb3J0ZWQgKi8KIAkJcmV0dXJuIDA7CiAJfQogCi0JaWYgKGVhcC0+bWV0aG9kID09IEVBUF9UWVBFX1BFQVApIHsKKwlpZiAoZWFwLT5tZXRob2QgPT0gRUFQX1RZUEVfUEVBUCB8fCBlYXAtPm1ldGhvZCA9PSBFQVBfVFlQRV9GQVNUKSB7CiAJCWlmIChlYXAtPmlubmVyX21ldGhvZCAmJgogCQkgICAgZWFwX2dldF9uYW1lKEVBUF9WRU5ET1JfSUVURiwgZWFwLT5pbm5lcl9tZXRob2QpID09IE5VTEwpCiAJCQlyZXR1cm4gMDsKQEAgLTcyOSw4ICs3OTYsOCBAQAogCQkqcG9zKysgPSBpbXNpWzRdOwogCQkqcG9zKysgPSBpbXNpWzVdOwogCX0KLQlwb3MgKz0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIubWNjJWMlYyVjLjNncHBuZXR3b3JrLm9yZyIsCi0JCQkgICBpbXNpWzBdLCBpbXNpWzFdLCBpbXNpWzJdKTsKKwlvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIi5tY2MlYyVjJWMuM2dwcG5ldHdvcmsub3JnIiwKKwkJICAgIGltc2lbMF0sIGltc2lbMV0sIGltc2lbMl0pOwogCiAJcmV0dXJuIDA7CiB9CkBAIC03NDcsMTIgKzgxNCw4NSBAQAogI2VuZGlmIC8qIElOVEVSV09SS0lOR18zR1BQICovCiAKIAorc3RhdGljIGludCBhbHJlYWR5X2Nvbm5lY3RlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJICAgICBzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsIHN0cnVjdCB3cGFfYnNzICpic3MpCit7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkLCAqc2VsX3NzaWQ7CisJc3RydWN0IHdwYV9ic3MgKnNlbGVjdGVkOworCisJaWYgKHdwYV9zLT53cGFfc3RhdGUgPCBXUEFfQVNTT0NJQVRFRCB8fCB3cGFfcy0+Y3VycmVudF9zc2lkID09IE5VTEwpCisJCXJldHVybiAwOworCisJc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CisJaWYgKHNzaWQtPnBhcmVudF9jcmVkICE9IGNyZWQpCisJCXJldHVybiAwOworCisJaWYgKHNzaWQtPnNzaWRfbGVuICE9IGJzcy0+c3NpZF9sZW4gfHwKKwkgICAgb3NfbWVtY21wKHNzaWQtPnNzaWQsIGJzcy0+c3NpZCwgYnNzLT5zc2lkX2xlbikgIT0gMCkKKwkJcmV0dXJuIDA7CisKKwlzZWxfc3NpZCA9IE5VTEw7CisJc2VsZWN0ZWQgPSB3cGFfc3VwcGxpY2FudF9waWNrX25ldHdvcmsod3BhX3MsICZzZWxfc3NpZCk7CisJaWYgKHNlbGVjdGVkICYmIHNlbF9zc2lkICYmIHNlbF9zc2lkLT5wcmlvcml0eSA+IHNzaWQtPnByaW9yaXR5KQorCQlyZXR1cm4gMDsgLyogaGlnaGVyIHByaW9yaXR5IG5ldHdvcmsgaW4gc2NhbiByZXN1bHRzICovCisKKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgdm9pZCByZW1vdmVfZHVwbGljYXRlX25ldHdvcmsoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgIHN0cnVjdCB3cGFfY3JlZCAqY3JlZCwKKwkJCQkgICAgIHN0cnVjdCB3cGFfYnNzICpic3MpCit7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkOworCisJZm9yIChzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7IHNzaWQ7IHNzaWQgPSBzc2lkLT5uZXh0KSB7CisJCWlmIChzc2lkLT5wYXJlbnRfY3JlZCAhPSBjcmVkKQorCQkJY29udGludWU7CisJCWlmIChzc2lkLT5zc2lkX2xlbiAhPSBic3MtPnNzaWRfbGVuIHx8CisJCSAgICBvc19tZW1jbXAoc3NpZC0+c3NpZCwgYnNzLT5zc2lkLCBic3MtPnNzaWRfbGVuKSAhPSAwKQorCQkJY29udGludWU7CisKKwkJYnJlYWs7CisJfQorCisJaWYgKHNzaWQgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFJlbW92ZSBkdXBsaWNhdGUgbmV0d29yayBlbnRyeSBmb3IgdGhlIHNhbWUgY3JlZGVudGlhbCIpOworCisJaWYgKHNzaWQgPT0gd3BhX3MtPmN1cnJlbnRfc3NpZCkgeworCQl3cGFfc21fc2V0X2NvbmZpZyh3cGFfcy0+d3BhLCBOVUxMKTsKKwkJZWFwb2xfc21fbm90aWZ5X2NvbmZpZyh3cGFfcy0+ZWFwb2wsIE5VTEwsIE5VTEwpOworCQl3cGFfc3VwcGxpY2FudF9kZWF1dGhlbnRpY2F0ZSh3cGFfcywKKwkJCQkJICAgICAgV0xBTl9SRUFTT05fREVBVVRIX0xFQVZJTkcpOworCX0KKworCXdwYXNfbm90aWZ5X25ldHdvcmtfcmVtb3ZlZCh3cGFfcywgc3NpZCk7CisJd3BhX2NvbmZpZ19yZW1vdmVfbmV0d29yayh3cGFfcy0+Y29uZiwgc3NpZC0+aWQpOworfQorCisKIHN0YXRpYyBpbnQgaW50ZXJ3b3JraW5nX3NldF9oczIwX3BhcmFtcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCiB7Ci0JaWYgKHdwYV9jb25maWdfc2V0KHNzaWQsICJrZXlfbWdtdCIsCi0JCQkgICB3cGFfcy0+Y29uZi0+cG1mICE9IE5PX01HTVRfRlJBTUVfUFJPVEVDVElPTiA/Ci0JCQkgICAiV1BBLUVBUCBXUEEtRUFQLVNIQTI1NiIgOiAiV1BBLUVBUCIsIDApIDwgMCkKKwljb25zdCBjaGFyICprZXlfbWdtdCA9IE5VTEw7CisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKKwlpbnQgcmVzOworCXN0cnVjdCB3cGFfZHJpdmVyX2NhcGEgY2FwYTsKKworCXJlcyA9IHdwYV9kcnZfZ2V0X2NhcGEod3BhX3MsICZjYXBhKTsKKwlpZiAocmVzID09IDAgJiYgY2FwYS5rZXlfbWdtdCAmIFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9GVCkgeworCQlrZXlfbWdtdCA9IHdwYV9zLT5jb25mLT5wbWYgIT0gTk9fTUdNVF9GUkFNRV9QUk9URUNUSU9OID8KKwkJCSJXUEEtRUFQIFdQQS1FQVAtU0hBMjU2IEZULUVBUCIgOgorCQkJIldQQS1FQVAgRlQtRUFQIjsKKwl9CisjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KKworCWlmICgha2V5X21nbXQpCisJCWtleV9tZ210ID0gd3BhX3MtPmNvbmYtPnBtZiAhPSBOT19NR01UX0ZSQU1FX1BST1RFQ1RJT04gPworCQkJIldQQS1FQVAgV1BBLUVBUC1TSEEyNTYiIDogIldQQS1FQVAiOworCWlmICh3cGFfY29uZmlnX3NldChzc2lkLCAia2V5X21nbXQiLCBrZXlfbWdtdCwgMCkgPCAwKQogCQlyZXR1cm4gLTE7CiAJaWYgKHdwYV9jb25maWdfc2V0KHNzaWQsICJwcm90byIsICJSU04iLCAwKSA8IDApCiAJCXJldHVybiAtMTsKQEAgLTc2OCw3ICs5MDgsNiBAQAogewogI2lmZGVmIElOVEVSV09SS0lOR18zR1BQCiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwotCWNvbnN0IHU4ICppZTsKIAlpbnQgZWFwX3R5cGU7CiAJaW50IHJlczsKIAljaGFyIHByZWZpeDsKQEAgLTc3NiwxMiArOTE1LDE3IEBACiAJaWYgKGJzcy0+YW5xcCA9PSBOVUxMIHx8IGJzcy0+YW5xcC0+YW5xcF8zZ3BwID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAotCWllID0gd3BhX2Jzc19nZXRfaWUoYnNzLCBXTEFOX0VJRF9TU0lEKTsKLQlpZiAoaWUgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBDb25uZWN0IHdpdGggIiBNQUNTVFIgIiAoM0dQUCkiLAogCQkgICBNQUMyU1RSKGJzcy0+YnNzaWQpKTsKIAorCWlmIChhbHJlYWR5X2Nvbm5lY3RlZCh3cGFfcywgY3JlZCwgYnNzKSkgeworCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgSU5URVJXT1JLSU5HX0FMUkVBRFlfQ09OTkVDVEVEIE1BQ1NUUiwKKwkJCU1BQzJTVFIoYnNzLT5ic3NpZCkpOworCQlyZXR1cm4gMDsKKwl9CisKKwlyZW1vdmVfZHVwbGljYXRlX25ldHdvcmsod3BhX3MsIGNyZWQsIGJzcyk7CisKIAlzc2lkID0gd3BhX2NvbmZpZ19hZGRfbmV0d29yayh3cGFfcy0+Y29uZik7CiAJaWYgKHNzaWQgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwpAQCAtNzkxLDExICs5MzUsMTIgQEAKIAl3cGFfY29uZmlnX3NldF9uZXR3b3JrX2RlZmF1bHRzKHNzaWQpOwogCXNzaWQtPnByaW9yaXR5ID0gY3JlZC0+cHJpb3JpdHk7CiAJc3NpZC0+dGVtcG9yYXJ5ID0gMTsKLQlzc2lkLT5zc2lkID0gb3NfemFsbG9jKGllWzFdICsgMSk7CisJc3NpZC0+c3NpZCA9IG9zX3phbGxvYyhic3MtPnNzaWRfbGVuICsgMSk7CiAJaWYgKHNzaWQtPnNzaWQgPT0gTlVMTCkKIAkJZ290byBmYWlsOwotCW9zX21lbWNweShzc2lkLT5zc2lkLCBpZSArIDIsIGllWzFdKTsKLQlzc2lkLT5zc2lkX2xlbiA9IGllWzFdOworCW9zX21lbWNweShzc2lkLT5zc2lkLCBic3MtPnNzaWQsIGJzcy0+c3NpZF9sZW4pOworCXNzaWQtPnNzaWRfbGVuID0gYnNzLT5zc2lkX2xlbjsKKwlzc2lkLT5lYXAuc2ltX251bSA9IGNyZWQtPnNpbV9udW07CiAKIAlpZiAoaW50ZXJ3b3JraW5nX3NldF9oczIwX3BhcmFtcyh3cGFfcywgc3NpZCkgPCAwKQogCQlnb3RvIGZhaWw7CkBAIC04NTEsMTAgKzk5Niw3IEBACiAJCQlnb3RvIGZhaWw7CiAJfQogCi0JaWYgKGNyZWQtPnBhc3N3b3JkICYmIGNyZWQtPnBhc3N3b3JkWzBdICYmCi0JICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAicGFzc3dvcmQiLCBjcmVkLT5wYXNzd29yZCkgPCAwKQotCQlnb3RvIGZhaWw7Ci0KKwl3cGFfcy0+bmV4dF9zc2lkID0gc3NpZDsKIAl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOwogCWludGVyd29ya2luZ19yZWNvbm5lY3Qod3BhX3MpOwogCkBAIC05NDQsNiArMTA4NiwyNyBAQAogfQogCiAKK3N0YXRpYyBpbnQgY3JlZF9ub19yZXF1aXJlZF9vaV9tYXRjaChzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsIHN0cnVjdCB3cGFfYnNzICpic3MpCit7CisJY29uc3QgdTggKmllOworCisJaWYgKGNyZWQtPnJlcXVpcmVkX3JvYW1pbmdfY29uc29ydGl1bV9sZW4gPT0gMCkKKwkJcmV0dXJuIDA7CisKKwlpZSA9IHdwYV9ic3NfZ2V0X2llKGJzcywgV0xBTl9FSURfUk9BTUlOR19DT05TT1JUSVVNKTsKKworCWlmIChpZSA9PSBOVUxMICYmCisJICAgIChic3MtPmFucXAgPT0gTlVMTCB8fCBic3MtPmFucXAtPnJvYW1pbmdfY29uc29ydGl1bSA9PSBOVUxMKSkKKwkJcmV0dXJuIDE7CisKKwlyZXR1cm4gIXJvYW1pbmdfY29uc29ydGl1bV9tYXRjaChpZSwKKwkJCQkJIGJzcy0+YW5xcCA/CisJCQkJCSBic3MtPmFucXAtPnJvYW1pbmdfY29uc29ydGl1bSA6IE5VTEwsCisJCQkJCSBjcmVkLT5yZXF1aXJlZF9yb2FtaW5nX2NvbnNvcnRpdW0sCisJCQkJCSBjcmVkLT5yZXF1aXJlZF9yb2FtaW5nX2NvbnNvcnRpdW1fbGVuKTsKK30KKworCiBzdGF0aWMgaW50IGNyZWRfZXhjbHVkZWRfc3NpZChzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsIHN0cnVjdCB3cGFfYnNzICpic3MpCiB7CiAJc2l6ZV90IGk7CkBAIC05NjIsMTEgKzExMjUsMTY0IEBACiB9CiAKIAorc3RhdGljIGludCBjcmVkX2JlbG93X21pbl9iYWNraGF1bChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgIHN0cnVjdCB3cGFfY3JlZCAqY3JlZCwgc3RydWN0IHdwYV9ic3MgKmJzcykKK3sKKwlpbnQgcmVzOworCXVuc2lnbmVkIGludCBkbF9iYW5kd2lkdGgsIHVsX2JhbmR3aWR0aDsKKwljb25zdCB1OCAqd2FuOworCXU4IHdhbl9pbmZvLCBkbF9sb2FkLCB1bF9sb2FkOworCXUxNiBsbWQ7CisJdTMyIHVsX3NwZWVkLCBkbF9zcGVlZDsKKworCWlmICghY3JlZC0+bWluX2RsX2JhbmR3aWR0aF9ob21lICYmCisJICAgICFjcmVkLT5taW5fdWxfYmFuZHdpZHRoX2hvbWUgJiYKKwkgICAgIWNyZWQtPm1pbl9kbF9iYW5kd2lkdGhfcm9hbWluZyAmJgorCSAgICAhY3JlZC0+bWluX3VsX2JhbmR3aWR0aF9yb2FtaW5nKQorCQlyZXR1cm4gMDsgLyogTm8gYmFuZHdpZHRoIGNvbnN0cmFpbnQgc3BlY2lmaWVkICovCisKKwlpZiAoYnNzLT5hbnFwID09IE5VTEwgfHwgYnNzLT5hbnFwLT5oczIwX3dhbl9tZXRyaWNzID09IE5VTEwpCisJCXJldHVybiAwOyAvKiBObyBXQU4gTWV0cmljcyBrbm93biAtIGlnbm9yZSBjb25zdHJhaW50ICovCisKKwl3YW4gPSB3cGFidWZfaGVhZChic3MtPmFucXAtPmhzMjBfd2FuX21ldHJpY3MpOworCXdhbl9pbmZvID0gd2FuWzBdOworCWlmICh3YW5faW5mbyAmIEJJVCgzKSkKKwkJcmV0dXJuIDE7IC8qIFdBTiBsaW5rIGF0IGNhcGFjaXR5ICovCisJbG1kID0gV1BBX0dFVF9MRTE2KHdhbiArIDExKTsKKwlpZiAobG1kID09IDApCisJCXJldHVybiAwOyAvKiBEb3dubGluay9VcGxpbmsgTG9hZCB3YXMgbm90IG1lYXN1cmVkICovCisJZGxfc3BlZWQgPSBXUEFfR0VUX0xFMzIod2FuICsgMSk7CisJdWxfc3BlZWQgPSBXUEFfR0VUX0xFMzIod2FuICsgNSk7CisJZGxfbG9hZCA9IHdhbls5XTsKKwl1bF9sb2FkID0gd2FuWzEwXTsKKworCWlmIChkbF9zcGVlZCA+PSAweGZmZmZmZikKKwkJZGxfYmFuZHdpZHRoID0gZGxfc3BlZWQgLyAyNTUgKiAoMjU1IC0gZGxfbG9hZCk7CisJZWxzZQorCQlkbF9iYW5kd2lkdGggPSBkbF9zcGVlZCAqICgyNTUgLSBkbF9sb2FkKSAvIDI1NTsKKworCWlmICh1bF9zcGVlZCA+PSAweGZmZmZmZikKKwkJdWxfYmFuZHdpZHRoID0gdWxfc3BlZWQgLyAyNTUgKiAoMjU1IC0gdWxfbG9hZCk7CisJZWxzZQorCQl1bF9iYW5kd2lkdGggPSB1bF9zcGVlZCAqICgyNTUgLSB1bF9sb2FkKSAvIDI1NTsKKworCXJlcyA9IGludGVyd29ya2luZ19ob21lX3NwX2NyZWQod3BhX3MsIGNyZWQsIGJzcy0+YW5xcCA/CisJCQkJCWJzcy0+YW5xcC0+ZG9tYWluX25hbWUgOiBOVUxMKTsKKwlpZiAocmVzID4gMCkgeworCQlpZiAoY3JlZC0+bWluX2RsX2JhbmR3aWR0aF9ob21lID4gZGxfYmFuZHdpZHRoKQorCQkJcmV0dXJuIDE7CisJCWlmIChjcmVkLT5taW5fdWxfYmFuZHdpZHRoX2hvbWUgPiB1bF9iYW5kd2lkdGgpCisJCQlyZXR1cm4gMTsKKwl9IGVsc2UgeworCQlpZiAoY3JlZC0+bWluX2RsX2JhbmR3aWR0aF9yb2FtaW5nID4gZGxfYmFuZHdpZHRoKQorCQkJcmV0dXJuIDE7CisJCWlmIChjcmVkLT5taW5fdWxfYmFuZHdpZHRoX3JvYW1pbmcgPiB1bF9iYW5kd2lkdGgpCisJCQlyZXR1cm4gMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IGNyZWRfb3Zlcl9tYXhfYnNzX2xvYWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgIHN0cnVjdCB3cGFfY3JlZCAqY3JlZCwgc3RydWN0IHdwYV9ic3MgKmJzcykKK3sKKwljb25zdCB1OCAqaWU7CisJaW50IHJlczsKKworCWlmICghY3JlZC0+bWF4X2Jzc19sb2FkKQorCQlyZXR1cm4gMDsgLyogTm8gQlNTIExvYWQgY29uc3RyYWludCBzcGVjaWZpZWQgKi8KKworCWllID0gd3BhX2Jzc19nZXRfaWUoYnNzLCBXTEFOX0VJRF9CU1NfTE9BRCk7CisJaWYgKGllID09IE5VTEwgfHwgaWVbMV0gPCAzKQorCQlyZXR1cm4gMDsgLyogTm8gQlNTIExvYWQgYWR2ZXJ0aXNlZCAqLworCisJcmVzID0gaW50ZXJ3b3JraW5nX2hvbWVfc3BfY3JlZCh3cGFfcywgY3JlZCwgYnNzLT5hbnFwID8KKwkJCQkJYnNzLT5hbnFwLT5kb21haW5fbmFtZSA6IE5VTEwpOworCWlmIChyZXMgPD0gMCkKKwkJcmV0dXJuIDA7IC8qIE5vdCBhIGhvbWUgbmV0d29yayAqLworCisJcmV0dXJuIGllWzRdID4gY3JlZC0+bWF4X2Jzc19sb2FkOworfQorCisKK3N0YXRpYyBpbnQgaGFzX3Byb3RvX21hdGNoKGNvbnN0IHU4ICpwb3MsIGNvbnN0IHU4ICplbmQsIHU4IHByb3RvKQoreworCXdoaWxlIChwb3MgKyA0IDw9IGVuZCkgeworCQlpZiAocG9zWzBdID09IHByb3RvICYmIHBvc1szXSA9PSAxIC8qIE9wZW4gKi8pCisJCQlyZXR1cm4gMTsKKwkJcG9zICs9IDQ7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBoYXNfcHJvdG9fcG9ydF9tYXRjaChjb25zdCB1OCAqcG9zLCBjb25zdCB1OCAqZW5kLCB1OCBwcm90bywKKwkJCQl1MTYgcG9ydCkKK3sKKwl3aGlsZSAocG9zICsgNCA8PSBlbmQpIHsKKwkJaWYgKHBvc1swXSA9PSBwcm90byAmJiBXUEFfR0VUX0xFMTYoJnBvc1sxXSkgPT0gcG9ydCAmJgorCQkgICAgcG9zWzNdID09IDEgLyogT3BlbiAqLykKKwkJCXJldHVybiAxOworCQlwb3MgKz0gNDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IGNyZWRfY29ubl9jYXBhYl9taXNzaW5nKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgc3RydWN0IHdwYV9jcmVkICpjcmVkLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQoreworCWludCByZXM7CisJY29uc3QgdTggKmNhcGFiLCAqZW5kOworCXVuc2lnbmVkIGludCBpLCBqOworCWludCAqcG9ydHM7CisKKwlpZiAoIWNyZWQtPm51bV9yZXFfY29ubl9jYXBhYikKKwkJcmV0dXJuIDA7IC8qIE5vIGNvbm5lY3Rpb24gY2FwYWJpbGl0eSBjb25zdHJhaW50IHNwZWNpZmllZCAqLworCisJaWYgKGJzcy0+YW5xcCA9PSBOVUxMIHx8IGJzcy0+YW5xcC0+aHMyMF9jb25uZWN0aW9uX2NhcGFiaWxpdHkgPT0gTlVMTCkKKwkJcmV0dXJuIDA7IC8qIE5vIENvbm5lY3Rpb24gQ2FwYWJpbGl0eSBrbm93biAtIGlnbm9yZSBjb25zdHJhaW50CisJCQkgICAqLworCisJcmVzID0gaW50ZXJ3b3JraW5nX2hvbWVfc3BfY3JlZCh3cGFfcywgY3JlZCwgYnNzLT5hbnFwID8KKwkJCQkJYnNzLT5hbnFwLT5kb21haW5fbmFtZSA6IE5VTEwpOworCWlmIChyZXMgPiAwKQorCQlyZXR1cm4gMDsgLyogTm8gY29uc3RyYWludCBpbiBob21lIG5ldHdvcmsgKi8KKworCWNhcGFiID0gd3BhYnVmX2hlYWQoYnNzLT5hbnFwLT5oczIwX2Nvbm5lY3Rpb25fY2FwYWJpbGl0eSk7CisJZW5kID0gY2FwYWIgKyB3cGFidWZfbGVuKGJzcy0+YW5xcC0+aHMyMF9jb25uZWN0aW9uX2NhcGFiaWxpdHkpOworCisJZm9yIChpID0gMDsgaSA8IGNyZWQtPm51bV9yZXFfY29ubl9jYXBhYjsgaSsrKSB7CisJCXBvcnRzID0gY3JlZC0+cmVxX2Nvbm5fY2FwYWJfcG9ydFtpXTsKKwkJaWYgKCFwb3J0cykgeworCQkJaWYgKCFoYXNfcHJvdG9fbWF0Y2goY2FwYWIsIGVuZCwKKwkJCQkJICAgICBjcmVkLT5yZXFfY29ubl9jYXBhYl9wcm90b1tpXSkpCisJCQkJcmV0dXJuIDE7CisJCX0gZWxzZSB7CisJCQlmb3IgKGogPSAwOyBwb3J0c1tqXSA+IC0xOyBqKyspIHsKKwkJCQlpZiAoIWhhc19wcm90b19wb3J0X21hdGNoKAorCQkJCQkgICAgY2FwYWIsIGVuZCwKKwkJCQkJICAgIGNyZWQtPnJlcV9jb25uX2NhcGFiX3Byb3RvW2ldLAorCQkJCQkgICAgcG9ydHNbal0pKQorCQkJCQlyZXR1cm4gMTsKKwkJCX0KKwkJfQorCX0KKworCXJldHVybiAwOworfQorCisKIHN0YXRpYyBzdHJ1Y3Qgd3BhX2NyZWQgKiBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JvYW1pbmdfY29uc29ydGl1bSgKLQlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQorCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MsIGludCBpZ25vcmVfYncsCisJaW50ICpleGNsdWRlZCkKIHsKIAlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpzZWxlY3RlZCA9IE5VTEw7CiAJY29uc3QgdTggKmllOworCWludCBpc19leGNsdWRlZCA9IDA7CiAKIAlpZSA9IHdwYV9ic3NfZ2V0X2llKGJzcywgV0xBTl9FSURfUk9BTUlOR19DT05TT1JUSVVNKTsKIApAQCAtOTg5LDE0ICsxMzA1LDMzIEBACiAJCQkJCSAgICAgIGNyZWQtPnJvYW1pbmdfY29uc29ydGl1bV9sZW4pKQogCQkJY29udGludWU7CiAKLQkJaWYgKGNyZWRfZXhjbHVkZWRfc3NpZChjcmVkLCBic3MpKQorCQlpZiAoY3JlZF9ub19yZXF1aXJlZF9vaV9tYXRjaChjcmVkLCBic3MpKQogCQkJY29udGludWU7Ci0KLQkJaWYgKHNlbGVjdGVkID09IE5VTEwgfHwKLQkJICAgIHNlbGVjdGVkLT5wcmlvcml0eSA8IGNyZWQtPnByaW9yaXR5KQotCQkJc2VsZWN0ZWQgPSBjcmVkOworCQlpZiAoIWlnbm9yZV9idyAmJiBjcmVkX2JlbG93X21pbl9iYWNraGF1bCh3cGFfcywgY3JlZCwgYnNzKSkKKwkJCWNvbnRpbnVlOworCQlpZiAoIWlnbm9yZV9idyAmJiBjcmVkX292ZXJfbWF4X2Jzc19sb2FkKHdwYV9zLCBjcmVkLCBic3MpKQorCQkJY29udGludWU7CisJCWlmICghaWdub3JlX2J3ICYmIGNyZWRfY29ubl9jYXBhYl9taXNzaW5nKHdwYV9zLCBjcmVkLCBic3MpKQorCQkJY29udGludWU7CisJCWlmIChjcmVkX2V4Y2x1ZGVkX3NzaWQoY3JlZCwgYnNzKSkgeworCQkJaWYgKGV4Y2x1ZGVkID09IE5VTEwpCisJCQkJY29udGludWU7CisJCQlpZiAoc2VsZWN0ZWQgPT0gTlVMTCkgeworCQkJCXNlbGVjdGVkID0gY3JlZDsKKwkJCQlpc19leGNsdWRlZCA9IDE7CisJCQl9CisJCX0gZWxzZSB7CisJCQlpZiAoc2VsZWN0ZWQgPT0gTlVMTCB8fCBpc19leGNsdWRlZCB8fAorCQkJICAgIGNyZWRfcHJpb19jbXAoc2VsZWN0ZWQsIGNyZWQpIDwgMCkgeworCQkJCXNlbGVjdGVkID0gY3JlZDsKKwkJCQlpc19leGNsdWRlZCA9IDA7CisJCQl9CisJCX0KIAl9CiAKKwlpZiAoZXhjbHVkZWQpCisJCSpleGNsdWRlZCA9IGlzX2V4Y2x1ZGVkOworCiAJcmV0dXJuIHNlbGVjdGVkOwogfQogCkBAIC0xMTAwLDE5ICsxNDM1LDM0IEBACiAJICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAiY2FfY2VydCIsIGNyZWQtPmNhX2NlcnQpIDwgMCkKIAkJcmV0dXJuIC0xOwogCisJaWYgKGNyZWQtPmRvbWFpbl9zdWZmaXhfbWF0Y2ggJiYgY3JlZC0+ZG9tYWluX3N1ZmZpeF9tYXRjaFswXSAmJgorCSAgICB3cGFfY29uZmlnX3NldF9xdW90ZWQoc3NpZCwgImRvbWFpbl9zdWZmaXhfbWF0Y2giLAorCQkJCSAgY3JlZC0+ZG9tYWluX3N1ZmZpeF9tYXRjaCkgPCAwKQorCQlyZXR1cm4gLTE7CisKKwlzc2lkLT5lYXAub2NzcCA9IGNyZWQtPm9jc3A7CisKIAlyZXR1cm4gMDsKIH0KIAogCiBzdGF0aWMgaW50IGludGVyd29ya2luZ19jb25uZWN0X3JvYW1pbmdfY29uc29ydGl1bSgKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsCi0Jc3RydWN0IHdwYV9ic3MgKmJzcywgY29uc3QgdTggKnNzaWRfaWUpCisJc3RydWN0IHdwYV9ic3MgKmJzcykKIHsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogQ29ubmVjdCB3aXRoICIgTUFDU1RSICIgYmFzZWQgb24gIgogCQkgICAicm9hbWluZyBjb25zb3J0aXVtIG1hdGNoIiwgTUFDMlNUUihic3MtPmJzc2lkKSk7CiAKKwlpZiAoYWxyZWFkeV9jb25uZWN0ZWQod3BhX3MsIGNyZWQsIGJzcykpIHsKKwkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIElOVEVSV09SS0lOR19BTFJFQURZX0NPTk5FQ1RFRCBNQUNTVFIsCisJCQlNQUMyU1RSKGJzcy0+YnNzaWQpKTsKKwkJcmV0dXJuIDA7CisJfQorCisJcmVtb3ZlX2R1cGxpY2F0ZV9uZXR3b3JrKHdwYV9zLCBjcmVkLCBic3MpOworCiAJc3NpZCA9IHdwYV9jb25maWdfYWRkX25ldHdvcmsod3BhX3MtPmNvbmYpOwogCWlmIChzc2lkID09IE5VTEwpCiAJCXJldHVybiAtMTsKQEAgLTExMjEsMTEgKzE0NzEsMTEgQEAKIAl3cGFfY29uZmlnX3NldF9uZXR3b3JrX2RlZmF1bHRzKHNzaWQpOwogCXNzaWQtPnByaW9yaXR5ID0gY3JlZC0+cHJpb3JpdHk7CiAJc3NpZC0+dGVtcG9yYXJ5ID0gMTsKLQlzc2lkLT5zc2lkID0gb3NfemFsbG9jKHNzaWRfaWVbMV0gKyAxKTsKKwlzc2lkLT5zc2lkID0gb3NfemFsbG9jKGJzcy0+c3NpZF9sZW4gKyAxKTsKIAlpZiAoc3NpZC0+c3NpZCA9PSBOVUxMKQogCQlnb3RvIGZhaWw7Ci0Jb3NfbWVtY3B5KHNzaWQtPnNzaWQsIHNzaWRfaWUgKyAyLCBzc2lkX2llWzFdKTsKLQlzc2lkLT5zc2lkX2xlbiA9IHNzaWRfaWVbMV07CisJb3NfbWVtY3B5KHNzaWQtPnNzaWQsIGJzcy0+c3NpZCwgYnNzLT5zc2lkX2xlbik7CisJc3NpZC0+c3NpZF9sZW4gPSBic3MtPnNzaWRfbGVuOwogCiAJaWYgKGludGVyd29ya2luZ19zZXRfaHMyMF9wYXJhbXMod3BhX3MsIHNzaWQpIDwgMCkKIAkJZ290byBmYWlsOwpAQCAtMTE0Miw2ICsxNDkyLDcgQEAKIAkJICAgIGNyZWQtPmVhcF9tZXRob2QtPm1ldGhvZCA9PSBFQVBfVFlQRV9UVExTKSA8IDApCiAJCWdvdG8gZmFpbDsKIAorCXdwYV9zLT5uZXh0X3NzaWQgPSBzc2lkOwogCXdwYV9jb25maWdfdXBkYXRlX3ByaW9fbGlzdCh3cGFfcy0+Y29uZik7CiAJaW50ZXJ3b3JraW5nX3JlY29ubmVjdCh3cGFfcyk7CiAKQEAgLTExNTQsNyArMTUwNSw4IEBACiB9CiAKIAotaW50IGludGVyd29ya2luZ19jb25uZWN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpCitzdGF0aWMgaW50IGludGVyd29ya2luZ19jb25uZWN0X2hlbHBlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgICBzdHJ1Y3Qgd3BhX2JzcyAqYnNzLCBpbnQgYWxsb3dfZXhjbHVkZWQpCiB7CiAJc3RydWN0IHdwYV9jcmVkICpjcmVkLCAqY3JlZF9yYywgKmNyZWRfM2dwcDsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CkBAIC0xMTYyLDE3ICsxNTE0LDIyIEBACiAJc3RydWN0IG5haV9yZWFsbV9lYXAgKmVhcCA9IE5VTEw7CiAJdTE2IGNvdW50LCBpOwogCWNoYXIgYnVmWzEwMF07Ci0JY29uc3QgdTggKmllOworCWludCBleGNsdWRlZCA9IDAsICpleGNsID0gYWxsb3dfZXhjbHVkZWQgPyAmZXhjbHVkZWQgOiBOVUxMOworCWNvbnN0IGNoYXIgKm5hbWU7CiAKIAlpZiAod3BhX3MtPmNvbmYtPmNyZWQgPT0gTlVMTCB8fCBic3MgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwotCWllID0gd3BhX2Jzc19nZXRfaWUoYnNzLCBXTEFOX0VJRF9TU0lEKTsKLQlpZiAoaWUgPT0gTlVMTCB8fCBpZVsxXSA9PSAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBObyBTU0lEIGtub3duIGZvciAiCisJaWYgKGRpc2FsbG93ZWRfYnNzaWQod3BhX3MsIGJzcy0+YnNzaWQpIHx8CisJICAgIGRpc2FsbG93ZWRfc3NpZCh3cGFfcywgYnNzLT5zc2lkLCBic3MtPnNzaWRfbGVuKSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogUmVqZWN0IGNvbm5lY3Rpb24gdG8gZGlzYWxsb3dlZCBCU1MgIgogCQkJICAgTUFDU1RSLCBNQUMyU1RSKGJzcy0+YnNzaWQpKTsKIAkJcmV0dXJuIC0xOwogCX0KIAorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBDb25zaWRlcmluZyBCU1MgIiBNQUNTVFIKKwkJICAgIiBmb3IgY29ubmVjdGlvbiAoYWxsb3dfZXhjbHVkZWQ9JWQpIiwKKwkJICAgTUFDMlNUUihic3MtPmJzc2lkKSwgYWxsb3dfZXhjbHVkZWQpOworCiAJaWYgKCF3cGFfYnNzX2dldF9pZShic3MsIFdMQU5fRUlEX1JTTikpIHsKIAkJLyoKIAkJICogV2UgY3VycmVudGx5IHN1cHBvcnQgb25seSBIUyAyLjAgbmV0d29ya3MgYW5kIHRob3NlIGFyZQpAQCAtMTE4MywzNSArMTU0MCw4MCBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JY3JlZF9yYyA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfcm9hbWluZ19jb25zb3J0aXVtKHdwYV9zLAotCQkJCQkJCQkJYnNzKTsKKwljcmVkX3JjID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV9yb2FtaW5nX2NvbnNvcnRpdW0oCisJCXdwYV9zLCBic3MsIDAsIGV4Y2wpOwogCWlmIChjcmVkX3JjKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBIaWdoZXN0IHJvYW1pbmcgIgotCQkJICAgImNvbnNvcnRpdW0gbWF0Y2hpbmcgY3JlZGVudGlhbCBwcmlvcml0eSAlZCIsCi0JCQkgICBjcmVkX3JjLT5wcmlvcml0eSk7CisJCQkgICAiY29uc29ydGl1bSBtYXRjaGluZyBjcmVkZW50aWFsIHByaW9yaXR5ICVkICIKKwkJCSAgICJzcF9wcmlvcml0eSAlZCIsCisJCQkgICBjcmVkX3JjLT5wcmlvcml0eSwgY3JlZF9yYy0+c3BfcHJpb3JpdHkpOworCQlpZiAoYWxsb3dfZXhjbHVkZWQgJiYgZXhjbCAmJiAhKCpleGNsKSkKKwkJCWV4Y2wgPSBOVUxMOwogCX0KIAotCWNyZWQgPSBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JlYWxtKHdwYV9zLCBic3MpOworCWNyZWQgPSBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JlYWxtKHdwYV9zLCBic3MsIDAsIGV4Y2wpOwogCWlmIChjcmVkKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBIaWdoZXN0IE5BSSBSZWFsbSBsaXN0ICIKLQkJCSAgICJtYXRjaGluZyBjcmVkZW50aWFsIHByaW9yaXR5ICVkIiwKLQkJCSAgIGNyZWQtPnByaW9yaXR5KTsKKwkJCSAgICJtYXRjaGluZyBjcmVkZW50aWFsIHByaW9yaXR5ICVkIHNwX3ByaW9yaXR5ICVkIiwKKwkJCSAgIGNyZWQtPnByaW9yaXR5LCBjcmVkLT5zcF9wcmlvcml0eSk7CisJCWlmIChhbGxvd19leGNsdWRlZCAmJiBleGNsICYmICEoKmV4Y2wpKQorCQkJZXhjbCA9IE5VTEw7CiAJfQogCi0JY3JlZF8zZ3BwID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV8zZ3BwKHdwYV9zLCBic3MpOworCWNyZWRfM2dwcCA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfM2dwcCh3cGFfcywgYnNzLCAwLAorCQkJCQkJCSAgICBleGNsKTsKIAlpZiAoY3JlZF8zZ3BwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBIaWdoZXN0IDNHUFAgbWF0Y2hpbmcgIgotCQkJICAgImNyZWRlbnRpYWwgcHJpb3JpdHkgJWQiLCBjcmVkXzNncHAtPnByaW9yaXR5KTsKKwkJCSAgICJjcmVkZW50aWFsIHByaW9yaXR5ICVkIHNwX3ByaW9yaXR5ICVkIiwKKwkJCSAgIGNyZWRfM2dwcC0+cHJpb3JpdHksIGNyZWRfM2dwcC0+c3BfcHJpb3JpdHkpOworCQlpZiAoYWxsb3dfZXhjbHVkZWQgJiYgZXhjbCAmJiAhKCpleGNsKSkKKwkJCWV4Y2wgPSBOVUxMOworCX0KKworCWlmICghY3JlZF9yYyAmJiAhY3JlZCAmJiAhY3JlZF8zZ3BwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBObyBmdWxsIGNyZWRlbnRpYWwgbWF0Y2hlcyAtIGNvbnNpZGVyIG9wdGlvbnMgd2l0aG91dCBCVyhldGMuKSBsaW1pdHMiKTsKKwkJY3JlZF9yYyA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfcm9hbWluZ19jb25zb3J0aXVtKAorCQkJd3BhX3MsIGJzcywgMSwgZXhjbCk7CisJCWlmIChjcmVkX3JjKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogSGlnaGVzdCByb2FtaW5nICIKKwkJCQkgICAiY29uc29ydGl1bSBtYXRjaGluZyBjcmVkZW50aWFsIHByaW9yaXR5ICVkICIKKwkJCQkgICAic3BfcHJpb3JpdHkgJWQgKGlnbm9yZSBCVykiLAorCQkJCSAgIGNyZWRfcmMtPnByaW9yaXR5LCBjcmVkX3JjLT5zcF9wcmlvcml0eSk7CisJCQlpZiAoYWxsb3dfZXhjbHVkZWQgJiYgZXhjbCAmJiAhKCpleGNsKSkKKwkJCQlleGNsID0gTlVMTDsKKwkJfQorCisJCWNyZWQgPSBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JlYWxtKHdwYV9zLCBic3MsIDEsCisJCQkJCQkJCWV4Y2wpOworCQlpZiAoY3JlZCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IEhpZ2hlc3QgTkFJIFJlYWxtICIKKwkJCQkgICAibGlzdCBtYXRjaGluZyBjcmVkZW50aWFsIHByaW9yaXR5ICVkICIKKwkJCQkgICAic3BfcHJpb3JpdHkgJWQgKGlnbm9yZSBCVykiLAorCQkJCSAgIGNyZWQtPnByaW9yaXR5LCBjcmVkLT5zcF9wcmlvcml0eSk7CisJCQlpZiAoYWxsb3dfZXhjbHVkZWQgJiYgZXhjbCAmJiAhKCpleGNsKSkKKwkJCQlleGNsID0gTlVMTDsKKwkJfQorCisJCWNyZWRfM2dwcCA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfM2dwcCh3cGFfcywgYnNzLAorCQkJCQkJCQkgICAgMSwgZXhjbCk7CisJCWlmIChjcmVkXzNncHApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBIaWdoZXN0IDNHUFAgIgorCQkJCSAgICJtYXRjaGluZyBjcmVkZW50aWFsIHByaW9yaXR5ICVkICIKKwkJCQkgICAic3BfcHJpb3JpdHkgJWQgKGlnbm9yZSBCVykiLAorCQkJCSAgIGNyZWRfM2dwcC0+cHJpb3JpdHksIGNyZWRfM2dwcC0+c3BfcHJpb3JpdHkpOworCQkJaWYgKGFsbG93X2V4Y2x1ZGVkICYmIGV4Y2wgJiYgISgqZXhjbCkpCisJCQkJZXhjbCA9IE5VTEw7CisJCX0KIAl9CiAKIAlpZiAoY3JlZF9yYyAmJgotCSAgICAoY3JlZCA9PSBOVUxMIHx8IGNyZWRfcmMtPnByaW9yaXR5ID49IGNyZWQtPnByaW9yaXR5KSAmJgotCSAgICAoY3JlZF8zZ3BwID09IE5VTEwgfHwgY3JlZF9yYy0+cHJpb3JpdHkgPj0gY3JlZF8zZ3BwLT5wcmlvcml0eSkpCisJICAgIChjcmVkID09IE5VTEwgfHwgY3JlZF9wcmlvX2NtcChjcmVkX3JjLCBjcmVkKSA+PSAwKSAmJgorCSAgICAoY3JlZF8zZ3BwID09IE5VTEwgfHwgY3JlZF9wcmlvX2NtcChjcmVkX3JjLCBjcmVkXzNncHApID49IDApKQogCQlyZXR1cm4gaW50ZXJ3b3JraW5nX2Nvbm5lY3Rfcm9hbWluZ19jb25zb3J0aXVtKHdwYV9zLCBjcmVkX3JjLAotCQkJCQkJCSAgICAgICBic3MsIGllKTsKKwkJCQkJCQkgICAgICAgYnNzKTsKIAogCWlmIChjcmVkXzNncHAgJiYKLQkgICAgKGNyZWQgPT0gTlVMTCB8fCBjcmVkXzNncHAtPnByaW9yaXR5ID49IGNyZWQtPnByaW9yaXR5KSkgeworCSAgICAoY3JlZCA9PSBOVUxMIHx8IGNyZWRfcHJpb19jbXAoY3JlZF8zZ3BwLCBjcmVkKSA+PSAwKSkgewogCQlyZXR1cm4gaW50ZXJ3b3JraW5nX2Nvbm5lY3RfM2dwcCh3cGFfcywgY3JlZF8zZ3BwLCBic3MpOwogCX0KIApAQCAtMTI0OCw2ICsxNjUwLDE1IEBACiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IENvbm5lY3Qgd2l0aCAiIE1BQ1NUUiwKIAkJICAgTUFDMlNUUihic3MtPmJzc2lkKSk7CiAKKwlpZiAoYWxyZWFkeV9jb25uZWN0ZWQod3BhX3MsIGNyZWQsIGJzcykpIHsKKwkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIElOVEVSV09SS0lOR19BTFJFQURZX0NPTk5FQ1RFRCBNQUNTVFIsCisJCQlNQUMyU1RSKGJzcy0+YnNzaWQpKTsKKwkJbmFpX3JlYWxtX2ZyZWUocmVhbG0sIGNvdW50KTsKKwkJcmV0dXJuIDA7CisJfQorCisJcmVtb3ZlX2R1cGxpY2F0ZV9uZXR3b3JrKHdwYV9zLCBjcmVkLCBic3MpOworCiAJc3NpZCA9IHdwYV9jb25maWdfYWRkX25ldHdvcmsod3BhX3MtPmNvbmYpOwogCWlmIChzc2lkID09IE5VTEwpIHsKIAkJbmFpX3JlYWxtX2ZyZWUocmVhbG0sIGNvdW50KTsKQEAgLTEyNTgsMTEgKzE2NjksMTEgQEAKIAl3cGFfY29uZmlnX3NldF9uZXR3b3JrX2RlZmF1bHRzKHNzaWQpOwogCXNzaWQtPnByaW9yaXR5ID0gY3JlZC0+cHJpb3JpdHk7CiAJc3NpZC0+dGVtcG9yYXJ5ID0gMTsKLQlzc2lkLT5zc2lkID0gb3NfemFsbG9jKGllWzFdICsgMSk7CisJc3NpZC0+c3NpZCA9IG9zX3phbGxvYyhic3MtPnNzaWRfbGVuICsgMSk7CiAJaWYgKHNzaWQtPnNzaWQgPT0gTlVMTCkKIAkJZ290byBmYWlsOwotCW9zX21lbWNweShzc2lkLT5zc2lkLCBpZSArIDIsIGllWzFdKTsKLQlzc2lkLT5zc2lkX2xlbiA9IGllWzFdOworCW9zX21lbWNweShzc2lkLT5zc2lkLCBic3MtPnNzaWQsIGJzcy0+c3NpZF9sZW4pOworCXNzaWQtPnNzaWRfbGVuID0gYnNzLT5zc2lkX2xlbjsKIAogCWlmIChpbnRlcndvcmtpbmdfc2V0X2hzMjBfcGFyYW1zKHdwYV9zLCBzc2lkKSA8IDApCiAJCWdvdG8gZmFpbDsKQEAgLTEzMTEsMTEgKzE3MjIsMTkgQEAKIAkJfQogCQlicmVhazsKIAljYXNlIEVBUF9UWVBFX1BFQVA6Ci0JCW9zX3NucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJcImF1dGg9JXNcIiIsCi0JCQkgICAgZWFwX2dldF9uYW1lKEVBUF9WRU5ET1JfSUVURiwKLQkJCQkJIGVhcC0+aW5uZXJfbWV0aG9kID8KLQkJCQkJIGVhcC0+aW5uZXJfbWV0aG9kIDoKLQkJCQkJIEVBUF9UWVBFX01TQ0hBUFYyKSk7CisJY2FzZSBFQVBfVFlQRV9GQVNUOgorCQlpZiAod3BhX2NvbmZpZ19zZXQoc3NpZCwgInBoYXNlMSIsICJcImZhc3RfcHJvdmlzaW9uaW5nPTJcIiIsCisJCQkJICAgMCkgPCAwKQorCQkJZ290byBmYWlsOworCQlpZiAod3BhX2NvbmZpZ19zZXQoc3NpZCwgInBhY19maWxlIiwKKwkJCQkgICAiXCJibG9iOi8vcGFjX2ludGVyd29ya2luZ1wiIiwgMCkgPCAwKQorCQkJZ290byBmYWlsOworCQluYW1lID0gZWFwX2dldF9uYW1lKEVBUF9WRU5ET1JfSUVURiwKKwkJCQkgICAgZWFwLT5pbm5lcl9tZXRob2QgPyBlYXAtPmlubmVyX21ldGhvZCA6CisJCQkJICAgIEVBUF9UWVBFX01TQ0hBUFYyKTsKKwkJaWYgKG5hbWUgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbDsKKwkJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIlwiYXV0aD0lc1wiIiwgbmFtZSk7CiAJCWlmICh3cGFfY29uZmlnX3NldChzc2lkLCAicGhhc2UyIiwgYnVmLCAwKSA8IDApCiAJCQlnb3RvIGZhaWw7CiAJCWJyZWFrOwpAQCAtMTMyOSw2ICsxNzQ4LDcgQEAKIAogCW5haV9yZWFsbV9mcmVlKHJlYWxtLCBjb3VudCk7CiAKKwl3cGFfcy0+bmV4dF9zc2lkID0gc3NpZDsKIAl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOwogCWludGVyd29ya2luZ19yZWNvbm5lY3Qod3BhX3MpOwogCkBAIC0xMzQyLDE3ICsxNzYyLDY3IEBACiB9CiAKIAoraW50IGludGVyd29ya2luZ19jb25uZWN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpCit7CisJcmV0dXJuIGludGVyd29ya2luZ19jb25uZWN0X2hlbHBlcih3cGFfcywgYnNzLCAxKTsKK30KKworCisjaWZkZWYgUENTQ19GVU5DUworc3RhdGljIGludCBpbnRlcndvcmtpbmdfcGNzY19yZWFkX2ltc2koc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlzaXplX3QgbGVuOworCisJaWYgKHdwYV9zLT5pbXNpWzBdICYmIHdwYV9zLT5tbmNfbGVuKQorCQlyZXR1cm4gMDsKKworCWxlbiA9IHNpemVvZih3cGFfcy0+aW1zaSkgLSAxOworCWlmIChzY2FyZF9nZXRfaW1zaSh3cGFfcy0+c2NhcmQsIHdwYV9zLT5pbXNpLCAmbGVuKSkgeworCQlzY2FyZF9kZWluaXQod3BhX3MtPnNjYXJkKTsKKwkJd3BhX3MtPnNjYXJkID0gTlVMTDsKKwkJd3BhX21zZyh3cGFfcywgTVNHX0VSUk9SLCAiQ291bGQgbm90IHJlYWQgSU1TSSIpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9zLT5pbXNpW2xlbl0gPSAnXDAnOworCXdwYV9zLT5tbmNfbGVuID0gc2NhcmRfZ2V0X21uY19sZW4od3BhX3MtPnNjYXJkKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNDQVJEOiBJTVNJICVzIChNTkMgbGVuZ3RoICVkKSIsCisJCSAgIHdwYV9zLT5pbXNpLCB3cGFfcy0+bW5jX2xlbik7CisKKwlyZXR1cm4gMDsKK30KKyNlbmRpZiAvKiBQQ1NDX0ZVTkNTICovCisKKwogc3RhdGljIHN0cnVjdCB3cGFfY3JlZCAqIGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfM2dwcCgKLQlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQorCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MsIGludCBpZ25vcmVfYncsCisJaW50ICpleGNsdWRlZCkKIHsKIAlzdHJ1Y3Qgd3BhX2NyZWQgKnNlbGVjdGVkID0gTlVMTDsKICNpZmRlZiBJTlRFUldPUktJTkdfM0dQUAogCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKIAlpbnQgcmV0OworCWludCBpc19leGNsdWRlZCA9IDA7CiAKIAlpZiAoYnNzLT5hbnFwID09IE5VTEwgfHwgYnNzLT5hbnFwLT5hbnFwXzNncHAgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAKKyNpZmRlZiBDT05GSUdfRUFQX1BST1hZCisJaWYgKCF3cGFfcy0+aW1zaVswXSkgeworCQlzaXplX3QgbGVuOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogSU1TSSBub3QgYXZhaWxhYmxlIC0gdHJ5IHRvIHJlYWQgYWdhaW4gdGhyb3VnaCBlYXBfcHJveHkiKTsKKwkJd3BhX3MtPm1uY19sZW4gPSBlYXBvbF9zbV9nZXRfZWFwX3Byb3h5X2ltc2kod3BhX3MtPmVhcG9sLAorCQkJCQkJCSAgICAgd3BhX3MtPmltc2ksCisJCQkJCQkJICAgICAmbGVuKTsKKwkJaWYgKHdwYV9zLT5tbmNfbGVuID4gMCkgeworCQkJd3BhX3MtPmltc2lbbGVuXSA9ICdcMCc7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImVhcF9wcm94eTogSU1TSSAlcyAoTU5DIGxlbmd0aCAlZCkiLAorCQkJCSAgIHdwYV9zLT5pbXNpLCB3cGFfcy0+bW5jX2xlbik7CisJCX0gZWxzZSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImVhcF9wcm94eTogSU1TSSBub3QgYXZhaWxhYmxlIik7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX0VBUF9QUk9YWSAqLworCiAJZm9yIChjcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7IGNyZWQ7IGNyZWQgPSBjcmVkLT5uZXh0KSB7CiAJCWNoYXIgKnNlcDsKIAkJY29uc3QgY2hhciAqaW1zaTsKQEAgLTEzNjEsOCArMTgzMSw5IEBACiAJCXNpemVfdCBtc2luX2xlbjsKIAogI2lmZGVmIFBDU0NfRlVOQ1MKLQkJaWYgKGNyZWQtPnBjc2MgJiYgd3BhX3MtPmNvbmYtPnBjc2NfcmVhZGVyICYmIHdwYV9zLT5zY2FyZCAmJgotCQkgICAgd3BhX3MtPmltc2lbMF0pIHsKKwkJaWYgKGNyZWQtPnBjc2MgJiYgd3BhX3MtPnNjYXJkKSB7CisJCQlpZiAoaW50ZXJ3b3JraW5nX3Bjc2NfcmVhZF9pbXNpKHdwYV9zKSA8IDApCisJCQkJY29udGludWU7CiAJCQlpbXNpID0gd3BhX3MtPmltc2k7CiAJCQltbmNfbGVuID0gd3BhX3MtPm1uY19sZW47CiAJCQlnb3RvIGNvbXBhcmU7CkBAIC0xMzc3LDcgKzE4NDgsOCBAQAogI2VuZGlmIC8qIENPTkZJR19FQVBfUFJPWFkgKi8KIAogCQlpZiAoY3JlZC0+aW1zaSA9PSBOVUxMIHx8ICFjcmVkLT5pbXNpWzBdIHx8Ci0JCSAgICBjcmVkLT5taWxlbmFnZSA9PSBOVUxMIHx8ICFjcmVkLT5taWxlbmFnZVswXSkKKwkJICAgICghd3BhX3MtPmNvbmYtPmV4dGVybmFsX3NpbSAmJgorCQkgICAgIChjcmVkLT5taWxlbmFnZSA9PSBOVUxMIHx8ICFjcmVkLT5taWxlbmFnZVswXSkpKQogCQkJY29udGludWU7CiAKIAkJc2VwID0gb3Nfc3RyY2hyKGNyZWQtPmltc2ksICctJyk7CkBAIC0xNDAyLDI0ICsxODc0LDQ5IEBACiAJCXJldCA9IHBsbW5faWRfbWF0Y2goYnNzLT5hbnFwLT5hbnFwXzNncHAsIGltc2ksIG1uY19sZW4pOwogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlBMTU4gbWF0Y2ggJXNmb3VuZCIsIHJldCA/ICIiIDogIm5vdCAiKTsKIAkJaWYgKHJldCkgewotCQkJaWYgKGNyZWRfZXhjbHVkZWRfc3NpZChjcmVkLCBic3MpKQorCQkJaWYgKGNyZWRfbm9fcmVxdWlyZWRfb2lfbWF0Y2goY3JlZCwgYnNzKSkKIAkJCQljb250aW51ZTsKLQkJCWlmIChzZWxlY3RlZCA9PSBOVUxMIHx8Ci0JCQkgICAgc2VsZWN0ZWQtPnByaW9yaXR5IDwgY3JlZC0+cHJpb3JpdHkpCi0JCQkJc2VsZWN0ZWQgPSBjcmVkOworCQkJaWYgKCFpZ25vcmVfYncgJiYKKwkJCSAgICBjcmVkX2JlbG93X21pbl9iYWNraGF1bCh3cGFfcywgY3JlZCwgYnNzKSkKKwkJCQljb250aW51ZTsKKwkJCWlmICghaWdub3JlX2J3ICYmCisJCQkgICAgY3JlZF9vdmVyX21heF9ic3NfbG9hZCh3cGFfcywgY3JlZCwgYnNzKSkKKwkJCQljb250aW51ZTsKKwkJCWlmICghaWdub3JlX2J3ICYmCisJCQkgICAgY3JlZF9jb25uX2NhcGFiX21pc3Npbmcod3BhX3MsIGNyZWQsIGJzcykpCisJCQkJY29udGludWU7CisJCQlpZiAoY3JlZF9leGNsdWRlZF9zc2lkKGNyZWQsIGJzcykpIHsKKwkJCQlpZiAoZXhjbHVkZWQgPT0gTlVMTCkKKwkJCQkJY29udGludWU7CisJCQkJaWYgKHNlbGVjdGVkID09IE5VTEwpIHsKKwkJCQkJc2VsZWN0ZWQgPSBjcmVkOworCQkJCQlpc19leGNsdWRlZCA9IDE7CisJCQkJfQorCQkJfSBlbHNlIHsKKwkJCQlpZiAoc2VsZWN0ZWQgPT0gTlVMTCB8fCBpc19leGNsdWRlZCB8fAorCQkJCSAgICBjcmVkX3ByaW9fY21wKHNlbGVjdGVkLCBjcmVkKSA8IDApIHsKKwkJCQkJc2VsZWN0ZWQgPSBjcmVkOworCQkJCQlpc19leGNsdWRlZCA9IDA7CisJCQkJfQorCQkJfQogCQl9CiAJfQorCisJaWYgKGV4Y2x1ZGVkKQorCQkqZXhjbHVkZWQgPSBpc19leGNsdWRlZDsKICNlbmRpZiAvKiBJTlRFUldPUktJTkdfM0dQUCAqLwogCXJldHVybiBzZWxlY3RlZDsKIH0KIAogCiBzdGF0aWMgc3RydWN0IHdwYV9jcmVkICogaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV9yZWFsbSgKLQlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQorCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MsIGludCBpZ25vcmVfYncsCisJaW50ICpleGNsdWRlZCkKIHsKIAlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpzZWxlY3RlZCA9IE5VTEw7CiAJc3RydWN0IG5haV9yZWFsbSAqcmVhbG07CiAJdTE2IGNvdW50LCBpOworCWludCBpc19leGNsdWRlZCA9IDA7CiAKIAlpZiAoYnNzLT5hbnFwID09IE5VTEwgfHwgYnNzLT5hbnFwLT5uYWlfcmVhbG0gPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CkBAIC0xNDQ0LDExICsxOTQxLDMyIEBACiAJCQlpZiAoIW5haV9yZWFsbV9tYXRjaCgmcmVhbG1baV0sIGNyZWQtPnJlYWxtKSkKIAkJCQljb250aW51ZTsKIAkJCWlmIChuYWlfcmVhbG1fZmluZF9lYXAoY3JlZCwgJnJlYWxtW2ldKSkgewotCQkJCWlmIChjcmVkX2V4Y2x1ZGVkX3NzaWQoY3JlZCwgYnNzKSkKKwkJCQlpZiAoY3JlZF9ub19yZXF1aXJlZF9vaV9tYXRjaChjcmVkLCBic3MpKQogCQkJCQljb250aW51ZTsKLQkJCQlpZiAoc2VsZWN0ZWQgPT0gTlVMTCB8fAotCQkJCSAgICBzZWxlY3RlZC0+cHJpb3JpdHkgPCBjcmVkLT5wcmlvcml0eSkKLQkJCQkJc2VsZWN0ZWQgPSBjcmVkOworCQkJCWlmICghaWdub3JlX2J3ICYmCisJCQkJICAgIGNyZWRfYmVsb3dfbWluX2JhY2toYXVsKHdwYV9zLCBjcmVkLCBic3MpKQorCQkJCQljb250aW51ZTsKKwkJCQlpZiAoIWlnbm9yZV9idyAmJgorCQkJCSAgICBjcmVkX292ZXJfbWF4X2Jzc19sb2FkKHdwYV9zLCBjcmVkLCBic3MpKQorCQkJCQljb250aW51ZTsKKwkJCQlpZiAoIWlnbm9yZV9idyAmJgorCQkJCSAgICBjcmVkX2Nvbm5fY2FwYWJfbWlzc2luZyh3cGFfcywgY3JlZCwgYnNzKSkKKwkJCQkJY29udGludWU7CisJCQkJaWYgKGNyZWRfZXhjbHVkZWRfc3NpZChjcmVkLCBic3MpKSB7CisJCQkJCWlmIChleGNsdWRlZCA9PSBOVUxMKQorCQkJCQkJY29udGludWU7CisJCQkJCWlmIChzZWxlY3RlZCA9PSBOVUxMKSB7CisJCQkJCQlzZWxlY3RlZCA9IGNyZWQ7CisJCQkJCQlpc19leGNsdWRlZCA9IDE7CisJCQkJCX0KKwkJCQl9IGVsc2UgeworCQkJCQlpZiAoc2VsZWN0ZWQgPT0gTlVMTCB8fCBpc19leGNsdWRlZCB8fAorCQkJCQkgICAgY3JlZF9wcmlvX2NtcChzZWxlY3RlZCwgY3JlZCkgPCAwKQorCQkJCQl7CisJCQkJCQlzZWxlY3RlZCA9IGNyZWQ7CisJCQkJCQlpc19leGNsdWRlZCA9IDA7CisJCQkJCX0KKwkJCQl9CiAJCQkJYnJlYWs7CiAJCQl9CiAJCX0KQEAgLTE0NTYsMzUgKzE5NzQsNzcgQEAKIAogCW5haV9yZWFsbV9mcmVlKHJlYWxtLCBjb3VudCk7CiAKKwlpZiAoZXhjbHVkZWQpCisJCSpleGNsdWRlZCA9IGlzX2V4Y2x1ZGVkOworCiAJcmV0dXJuIHNlbGVjdGVkOwogfQogCiAKLXN0YXRpYyBzdHJ1Y3Qgd3BhX2NyZWQgKiBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlKAotCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpCitzdGF0aWMgc3RydWN0IHdwYV9jcmVkICogaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV9oZWxwZXIoCisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9ic3MgKmJzcywgaW50IGlnbm9yZV9idywKKwlpbnQgKmV4Y2x1ZGVkKQogewogCXN0cnVjdCB3cGFfY3JlZCAqY3JlZCwgKmNyZWQyOworCWludCBleGNsdWRlZDEsIGV4Y2x1ZGVkMjsKIAotCWNyZWQgPSBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JlYWxtKHdwYV9zLCBic3MpOwotCWNyZWQyID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV8zZ3BwKHdwYV9zLCBic3MpOwotCWlmIChjcmVkICYmIGNyZWQyICYmIGNyZWQyLT5wcmlvcml0eSA+PSBjcmVkLT5wcmlvcml0eSkKLQkJY3JlZCA9IGNyZWQyOwotCWlmICghY3JlZCkKLQkJY3JlZCA9IGNyZWQyOworCWlmIChkaXNhbGxvd2VkX2Jzc2lkKHdwYV9zLCBic3MtPmJzc2lkKSB8fAorCSAgICBkaXNhbGxvd2VkX3NzaWQod3BhX3MsIGJzcy0+c3NpZCwgYnNzLT5zc2lkX2xlbikpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IElnbm9yZSBkaXNhbGxvd2VkIEJTUyAiCisJCQkgICBNQUNTVFIsIE1BQzJTVFIoYnNzLT5ic3NpZCkpOworCQlyZXR1cm4gTlVMTDsKKwl9CiAKLQljcmVkMiA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfcm9hbWluZ19jb25zb3J0aXVtKHdwYV9zLAotCQkJCQkJCQkgICAgICBic3MpOwotCWlmIChjcmVkICYmIGNyZWQyICYmIGNyZWQyLT5wcmlvcml0eSA+PSBjcmVkLT5wcmlvcml0eSkKKwljcmVkID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV9yZWFsbSh3cGFfcywgYnNzLCBpZ25vcmVfYncsCisJCQkJCQkJJmV4Y2x1ZGVkMSk7CisJY3JlZDIgPSBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlXzNncHAod3BhX3MsIGJzcywgaWdub3JlX2J3LAorCQkJCQkJCSZleGNsdWRlZDIpOworCWlmIChjcmVkICYmIGNyZWQyICYmCisJICAgIChjcmVkX3ByaW9fY21wKGNyZWQyLCBjcmVkKSA+PSAwIHx8ICghZXhjbHVkZWQyICYmIGV4Y2x1ZGVkMSkpKSB7CiAJCWNyZWQgPSBjcmVkMjsKLQlpZiAoIWNyZWQpCisJCWV4Y2x1ZGVkMSA9IGV4Y2x1ZGVkMjsKKwl9CisJaWYgKCFjcmVkKSB7CiAJCWNyZWQgPSBjcmVkMjsKKwkJZXhjbHVkZWQxID0gZXhjbHVkZWQyOworCX0KIAorCWNyZWQyID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV9yb2FtaW5nX2NvbnNvcnRpdW0oCisJCXdwYV9zLCBic3MsIGlnbm9yZV9idywgJmV4Y2x1ZGVkMik7CisJaWYgKGNyZWQgJiYgY3JlZDIgJiYKKwkgICAgKGNyZWRfcHJpb19jbXAoY3JlZDIsIGNyZWQpID49IDAgfHwgKCFleGNsdWRlZDIgJiYgZXhjbHVkZWQxKSkpIHsKKwkJY3JlZCA9IGNyZWQyOworCQlleGNsdWRlZDEgPSBleGNsdWRlZDI7CisJfQorCWlmICghY3JlZCkgeworCQljcmVkID0gY3JlZDI7CisJCWV4Y2x1ZGVkMSA9IGV4Y2x1ZGVkMjsKKwl9CisKKwlpZiAoZXhjbHVkZWQpCisJCSpleGNsdWRlZCA9IGV4Y2x1ZGVkMTsKIAlyZXR1cm4gY3JlZDsKIH0KIAogCi1zdGF0aWMgaW50IGRvbWFpbl9uYW1lX2xpc3RfY29udGFpbnMoc3RydWN0IHdwYWJ1ZiAqZG9tYWluX25hbWVzLAotCQkJCSAgICAgY29uc3QgY2hhciAqZG9tYWluKQorc3RhdGljIHN0cnVjdCB3cGFfY3JlZCAqIGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGUoCisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9ic3MgKmJzcywgaW50ICpleGNsdWRlZCkKK3sKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQ7CisKKwlpZiAoZXhjbHVkZWQpCisJCSpleGNsdWRlZCA9IDA7CisJY3JlZCA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfaGVscGVyKHdwYV9zLCBic3MsIDAsCisJCQkJCQkJIGV4Y2x1ZGVkKTsKKwlpZiAoY3JlZCkKKwkJcmV0dXJuIGNyZWQ7CisJcmV0dXJuIGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfaGVscGVyKHdwYV9zLCBic3MsIDEsCisJCQkJCQkJIGV4Y2x1ZGVkKTsKK30KKworCitpbnQgZG9tYWluX25hbWVfbGlzdF9jb250YWlucyhzdHJ1Y3Qgd3BhYnVmICpkb21haW5fbmFtZXMsCisJCQkgICAgICBjb25zdCBjaGFyICpkb21haW4sIGludCBleGFjdF9tYXRjaCkKIHsKIAljb25zdCB1OCAqcG9zLCAqZW5kOwogCXNpemVfdCBsZW47CkBAIC0xNTAyLDYgKzIwNjIsMTIgQEAKIAkJaWYgKHBvc1swXSA9PSBsZW4gJiYKIAkJICAgIG9zX3N0cm5jYXNlY21wKGRvbWFpbiwgKGNvbnN0IGNoYXIgKikgKHBvcyArIDEpLCBsZW4pID09IDApCiAJCQlyZXR1cm4gMTsKKwkJaWYgKCFleGFjdF9tYXRjaCAmJiBwb3NbMF0gPiBsZW4gJiYgcG9zW3Bvc1swXSAtIGxlbl0gPT0gJy4nKSB7CisJCQljb25zdCBjaGFyICphcCA9IChjb25zdCBjaGFyICopIChwb3MgKyAxKTsKKwkJCWludCBvZmZzZXQgPSBwb3NbMF0gLSBsZW47CisJCQlpZiAob3Nfc3RybmNhc2VjbXAoZG9tYWluLCBhcCArIG9mZnNldCwgbGVuKSA9PSAwKQorCQkJCXJldHVybiAxOworCQl9CiAKIAkJcG9zICs9IDEgKyBwb3NbMF07CiAJfQpAQCAtMTUxNCw2ICsyMDgwLDggQEAKIAkJCSAgICAgIHN0cnVjdCB3cGFfY3JlZCAqY3JlZCwKIAkJCSAgICAgIHN0cnVjdCB3cGFidWYgKmRvbWFpbl9uYW1lcykKIHsKKwlzaXplX3QgaTsKKwlpbnQgcmV0ID0gLTE7CiAjaWZkZWYgSU5URVJXT1JLSU5HXzNHUFAKIAljaGFyIG5haVsxMDBdLCAqcmVhbG07CiAKQEAgLTE1MjEsMTMgKzIwODksMjAgQEAKIAlpbnQgbW5jX2xlbiA9IDA7CiAJaWYgKGNyZWQtPmltc2kpCiAJCWltc2kgPSBjcmVkLT5pbXNpOwotI2lmZGVmIENPTkZJR19QQ1NDCi0JZWxzZSBpZiAoY3JlZC0+cGNzYyAmJiB3cGFfcy0+Y29uZi0+cGNzY19yZWFkZXIgJiYKLQkJIHdwYV9zLT5zY2FyZCAmJiB3cGFfcy0+aW1zaVswXSkgeworI2lmZGVmIFBDU0NfRlVOQ1MKKwllbHNlIGlmIChjcmVkLT5wY3NjICYmIHdwYV9zLT5zY2FyZCkgeworCQlpZiAoaW50ZXJ3b3JraW5nX3Bjc2NfcmVhZF9pbXNpKHdwYV9zKSA8IDApCisJCQlyZXR1cm4gLTE7CiAJCWltc2kgPSB3cGFfcy0+aW1zaTsKIAkJbW5jX2xlbiA9IHdwYV9zLT5tbmNfbGVuOwogCX0KLSNlbmRpZiAvKiBDT05GSUdfUENTQyAqLworI2VuZGlmIC8qIFBDU0NfRlVOQ1MgKi8KKyNpZmRlZiBDT05GSUdfRUFQX1BST1hZCisJZWxzZSBpZiAoY3JlZC0+cGNzYyAmJiB3cGFfcy0+bW5jX2xlbiA+IDAgJiYgd3BhX3MtPmltc2lbMF0pIHsKKwkJaW1zaSA9IHdwYV9zLT5pbXNpOworCQltbmNfbGVuID0gd3BhX3MtPm1uY19sZW47CisJfQorI2VuZGlmIC8qIENPTkZJR19FQVBfUFJPWFkgKi8KIAlpZiAoZG9tYWluX25hbWVzICYmCiAJICAgIGltc2kgJiYgYnVpbGRfcm9vdF9uYWkobmFpLCBzaXplb2YobmFpKSwgaW1zaSwgbW5jX2xlbiwgMCkgPT0gMCkgewogCQlyZWFsbSA9IG9zX3N0cmNocihuYWksICdAJyk7CkBAIC0xNTM2LDE4ICsyMTExLDIyIEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBTZWFyY2ggZm9yIG1hdGNoICIKIAkJCSAgICJ3aXRoIFNJTS9VU0lNIGRvbWFpbiAlcyIsIHJlYWxtKTsKIAkJaWYgKHJlYWxtICYmCi0JCSAgICBkb21haW5fbmFtZV9saXN0X2NvbnRhaW5zKGRvbWFpbl9uYW1lcywgcmVhbG0pKQorCQkgICAgZG9tYWluX25hbWVfbGlzdF9jb250YWlucyhkb21haW5fbmFtZXMsIHJlYWxtLCAxKSkKIAkJCXJldHVybiAxOworCQlpZiAocmVhbG0pCisJCQlyZXQgPSAwOwogCX0KICNlbmRpZiAvKiBJTlRFUldPUktJTkdfM0dQUCAqLwogCiAJaWYgKGRvbWFpbl9uYW1lcyA9PSBOVUxMIHx8IGNyZWQtPmRvbWFpbiA9PSBOVUxMKQotCQlyZXR1cm4gMDsKKwkJcmV0dXJuIHJldDsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBTZWFyY2ggZm9yIG1hdGNoIHdpdGggIgotCQkgICAiaG9tZSBTUCBGUUROICVzIiwgY3JlZC0+ZG9tYWluKTsKLQlpZiAoZG9tYWluX25hbWVfbGlzdF9jb250YWlucyhkb21haW5fbmFtZXMsIGNyZWQtPmRvbWFpbikpCi0JCXJldHVybiAxOworCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5udW1fZG9tYWluOyBpKyspIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFNlYXJjaCBmb3IgbWF0Y2ggd2l0aCAiCisJCQkgICAiaG9tZSBTUCBGUUROICVzIiwgY3JlZC0+ZG9tYWluW2ldKTsKKwkJaWYgKGRvbWFpbl9uYW1lX2xpc3RfY29udGFpbnMoZG9tYWluX25hbWVzLCBjcmVkLT5kb21haW5baV0sIDEpKQorCQkJcmV0dXJuIDE7CisJfQogCiAJcmV0dXJuIDA7CiB9CkBAIC0xNTk3LDE5ICsyMTc2LDEyNyBAQAogfQogCiAKK3N0YXRpYyBpbnQgcm9hbWluZ19wYXJ0bmVyX21hdGNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJIHN0cnVjdCByb2FtaW5nX3BhcnRuZXIgKnBhcnRuZXIsCisJCQkJIHN0cnVjdCB3cGFidWYgKmRvbWFpbl9uYW1lcykKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogQ29tcGFyaW5nIHJvYW1pbmdfcGFydG5lciBpbmZvIGZxZG49JyVzJyBleGFjdF9tYXRjaD0lZCBwcmlvcml0eT0ldSBjb3VudHJ5PSclcyciLAorCQkgICBwYXJ0bmVyLT5mcWRuLCBwYXJ0bmVyLT5leGFjdF9tYXRjaCwgcGFydG5lci0+cHJpb3JpdHksCisJCSAgIHBhcnRuZXItPmNvdW50cnkpOworCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIkludGVyd29ya2luZzogRG9tYWluIG5hbWVzIiwKKwkJCSAgd3BhYnVmX2hlYWQoZG9tYWluX25hbWVzKSwKKwkJCSAgd3BhYnVmX2xlbihkb21haW5fbmFtZXMpKTsKKwlpZiAoIWRvbWFpbl9uYW1lX2xpc3RfY29udGFpbnMoZG9tYWluX25hbWVzLCBwYXJ0bmVyLT5mcWRuLAorCQkJCSAgICAgICBwYXJ0bmVyLT5leGFjdF9tYXRjaCkpCisJCXJldHVybiAwOworCS8qIFRPRE86IG1hdGNoIENvdW50cnkgKi8KKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgdTggcm9hbWluZ19wcmlvKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfY3JlZCAqY3JlZCwKKwkJICAgICAgIHN0cnVjdCB3cGFfYnNzICpic3MpCit7CisJc2l6ZV90IGk7CisKKwlpZiAoYnNzLT5hbnFwID09IE5VTEwgfHwgYnNzLT5hbnFwLT5kb21haW5fbmFtZSA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBObyBBTlFQIGRvbWFpbiBuYW1lIGluZm8gLT4gdXNlIGRlZmF1bHQgcm9hbWluZyBwYXJ0bmVyIHByaW9yaXR5IDEyOCIpOworCQlyZXR1cm4gMTI4OyAvKiBjYW5ub3QgY2hlY2sgcHJlZmVyZW5jZSB3aXRoIGRvbWFpbiBuYW1lICovCisJfQorCisJaWYgKGludGVyd29ya2luZ19ob21lX3NwX2NyZWQod3BhX3MsIGNyZWQsIGJzcy0+YW5xcC0+ZG9tYWluX25hbWUpID4gMCkKKwl7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBEZXRlcm1pbmVkIHRvIGJlIGhvbWUgU1AgLT4gdXNlIG1heGltdW0gcHJlZmVyZW5jZSAwIGFzIHJvYW1pbmcgcGFydG5lciBwcmlvcml0eSIpOworCQlyZXR1cm4gMDsgLyogbWF4IHByZWZlcmVuY2UgZm9yIGhvbWUgU1AgbmV0d29yayAqLworCX0KKworCWZvciAoaSA9IDA7IGkgPCBjcmVkLT5udW1fcm9hbWluZ19wYXJ0bmVyOyBpKyspIHsKKwkJaWYgKHJvYW1pbmdfcGFydG5lcl9tYXRjaCh3cGFfcywgJmNyZWQtPnJvYW1pbmdfcGFydG5lcltpXSwKKwkJCQkJICBic3MtPmFucXAtPmRvbWFpbl9uYW1lKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFJvYW1pbmcgcGFydG5lciBwcmVmZXJlbmNlIG1hdGNoIC0gcHJpb3JpdHkgJXUiLAorCQkJCSAgIGNyZWQtPnJvYW1pbmdfcGFydG5lcltpXS5wcmlvcml0eSk7CisJCQlyZXR1cm4gY3JlZC0+cm9hbWluZ19wYXJ0bmVyW2ldLnByaW9yaXR5OworCQl9CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IE5vIHJvYW1pbmcgcGFydG5lciBwcmVmZXJlbmNlIG1hdGNoIC0gdXNlIGRlZmF1bHQgcm9hbWluZyBwYXJ0bmVyIHByaW9yaXR5IDEyOCIpOworCXJldHVybiAxMjg7Cit9CisKKworc3RhdGljIHN0cnVjdCB3cGFfYnNzICogcGlja19iZXN0X3JvYW1pbmdfcGFydG5lcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkJICBzdHJ1Y3Qgd3BhX2JzcyAqc2VsZWN0ZWQsCisJCQkJCQkgIHN0cnVjdCB3cGFfY3JlZCAqY3JlZCkKK3sKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOworCXU4IGJlc3RfcHJpbywgcHJpbzsKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQyOworCisJLyoKKwkgKiBDaGVjayBpZiBhbnkgb3RoZXIgQlNTIGlzIG9wZXJhdGVkIGJ5IGEgbW9yZSBwcmVmZXJyZWQgcm9hbWluZworCSAqIHBhcnRuZXIuCisJICovCisKKwliZXN0X3ByaW8gPSByb2FtaW5nX3ByaW8od3BhX3MsIGNyZWQsIHNlbGVjdGVkKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogcm9hbWluZ19wcmlvPSV1IGZvciBzZWxlY3RlZCBCU1MgIgorCQkgICBNQUNTVFIgIiAoY3JlZD0lZCkiLCBiZXN0X3ByaW8sIE1BQzJTVFIoc2VsZWN0ZWQtPmJzc2lkKSwKKwkJICAgY3JlZC0+aWQpOworCisJZGxfbGlzdF9mb3JfZWFjaChic3MsICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgeworCQlpZiAoYnNzID09IHNlbGVjdGVkKQorCQkJY29udGludWU7CisJCWNyZWQyID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZSh3cGFfcywgYnNzLCBOVUxMKTsKKwkJaWYgKCFjcmVkMikKKwkJCWNvbnRpbnVlOworCQlpZiAoIXdwYV9ic3NfZ2V0X2llKGJzcywgV0xBTl9FSURfUlNOKSkKKwkJCWNvbnRpbnVlOworCQlwcmlvID0gcm9hbWluZ19wcmlvKHdwYV9zLCBjcmVkMiwgYnNzKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IHJvYW1pbmdfcHJpbz0ldSBmb3IgQlNTICIKKwkJCSAgIE1BQ1NUUiAiIChjcmVkPSVkKSIsIHByaW8sIE1BQzJTVFIoYnNzLT5ic3NpZCksCisJCQkgICBjcmVkMi0+aWQpOworCQlpZiAocHJpbyA8IGJlc3RfcHJpbykgeworCQkJaW50IGJoMSwgYmgyLCBsb2FkMSwgbG9hZDIsIGNvbm4xLCBjb25uMjsKKwkJCWJoMSA9IGNyZWRfYmVsb3dfbWluX2JhY2toYXVsKHdwYV9zLCBjcmVkLCBzZWxlY3RlZCk7CisJCQlsb2FkMSA9IGNyZWRfb3Zlcl9tYXhfYnNzX2xvYWQod3BhX3MsIGNyZWQsIHNlbGVjdGVkKTsKKwkJCWNvbm4xID0gY3JlZF9jb25uX2NhcGFiX21pc3Npbmcod3BhX3MsIGNyZWQsIHNlbGVjdGVkKTsKKwkJCWJoMiA9IGNyZWRfYmVsb3dfbWluX2JhY2toYXVsKHdwYV9zLCBjcmVkMiwgYnNzKTsKKwkJCWxvYWQyID0gY3JlZF9vdmVyX21heF9ic3NfbG9hZCh3cGFfcywgY3JlZDIsIGJzcyk7CisJCQljb25uMiA9IGNyZWRfY29ubl9jYXBhYl9taXNzaW5nKHdwYV9zLCBjcmVkMiwgYnNzKTsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBvbGQ6ICVkICVkICVkICBuZXc6ICVkICVkICVkIiwKKwkJCQkgICBiaDEsIGxvYWQxLCBjb25uMSwgYmgyLCBsb2FkMiwgY29ubjIpOworCQkJaWYgKGJoMSB8fCBsb2FkMSB8fCBjb25uMSB8fCAhKGJoMiB8fCBsb2FkMiB8fCBjb25uMikpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogQmV0dGVyIHJvYW1pbmcgcGFydG5lciAiIE1BQ1NUUiAiIHNlbGVjdGVkIiwgTUFDMlNUUihic3MtPmJzc2lkKSk7CisJCQkJYmVzdF9wcmlvID0gcHJpbzsKKwkJCQlzZWxlY3RlZCA9IGJzczsKKwkJCX0KKwkJfQorCX0KKworCXJldHVybiBzZWxlY3RlZDsKK30KKworCiBzdGF0aWMgdm9pZCBpbnRlcndvcmtpbmdfc2VsZWN0X25ldHdvcmsoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKIAlzdHJ1Y3Qgd3BhX2JzcyAqYnNzLCAqc2VsZWN0ZWQgPSBOVUxMLCAqc2VsZWN0ZWRfaG9tZSA9IE5VTEw7Ci0JaW50IHNlbGVjdGVkX3ByaW8gPSAtOTk5OTk5LCBzZWxlY3RlZF9ob21lX3ByaW8gPSAtOTk5OTk5OworCXN0cnVjdCB3cGFfYnNzICpzZWxlY3RlZDIgPSBOVUxMLCAqc2VsZWN0ZWQyX2hvbWUgPSBOVUxMOwogCXVuc2lnbmVkIGludCBjb3VudCA9IDA7CiAJY29uc3QgY2hhciAqdHlwZTsKIAlpbnQgcmVzOwotCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpzZWxlY3RlZF9jcmVkID0gTlVMTDsKKwlzdHJ1Y3Qgd3BhX2NyZWQgKnNlbGVjdGVkX2hvbWVfY3JlZCA9IE5VTEw7CisJc3RydWN0IHdwYV9jcmVkICpzZWxlY3RlZDJfY3JlZCA9IE5VTEw7CisJc3RydWN0IHdwYV9jcmVkICpzZWxlY3RlZDJfaG9tZV9jcmVkID0gTlVMTDsKIAogCXdwYV9zLT5uZXR3b3JrX3NlbGVjdCA9IDA7CiAKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogU2VsZWN0IG5ldHdvcmsgKGF1dG9fc2VsZWN0PSVkKSIsCisJCSAgIHdwYV9zLT5hdXRvX3NlbGVjdCk7CiAJZGxfbGlzdF9mb3JfZWFjaChic3MsICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgewotCQljcmVkID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZSh3cGFfcywgYnNzKTsKKwkJaW50IGV4Y2x1ZGVkID0gMDsKKwkJaW50IGJoLCBic3NfbG9hZCwgY29ubl9jYXBhYjsKKwkJY3JlZCA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGUod3BhX3MsIGJzcywKKwkJCQkJCQkgICZleGNsdWRlZCk7CiAJCWlmICghY3JlZCkKIAkJCWNvbnRpbnVlOwogCQlpZiAoIXdwYV9ic3NfZ2V0X2llKGJzcywgV0xBTl9FSURfUlNOKSkgewpAQCAtMTYyMiw3ICsyMzA5LDggQEAKIAkJCQkgICAiUlNOIiwgTUFDMlNUUihic3MtPmJzc2lkKSk7CiAJCQljb250aW51ZTsKIAkJfQotCQljb3VudCsrOworCQlpZiAoIWV4Y2x1ZGVkKQorCQkJY291bnQrKzsKIAkJcmVzID0gaW50ZXJ3b3JraW5nX2hvbWVfc3Aod3BhX3MsIGJzcy0+YW5xcCA/CiAJCQkJCSAgIGJzcy0+YW5xcC0+ZG9tYWluX25hbWUgOiBOVUxMKTsKIAkJaWYgKHJlcyA+IDApCkBAIC0xNjMxLDI5ICsyMzE5LDc1IEBACiAJCQl0eXBlID0gInJvYW1pbmciOwogCQllbHNlCiAJCQl0eXBlID0gInVua25vd24iOwotCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgSU5URVJXT1JLSU5HX0FQIE1BQ1NUUiAiIHR5cGU9JXMiLAotCQkJTUFDMlNUUihic3MtPmJzc2lkKSwgdHlwZSk7CisJCWJoID0gY3JlZF9iZWxvd19taW5fYmFja2hhdWwod3BhX3MsIGNyZWQsIGJzcyk7CisJCWJzc19sb2FkID0gY3JlZF9vdmVyX21heF9ic3NfbG9hZCh3cGFfcywgY3JlZCwgYnNzKTsKKwkJY29ubl9jYXBhYiA9IGNyZWRfY29ubl9jYXBhYl9taXNzaW5nKHdwYV9zLCBjcmVkLCBic3MpOworCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIiVzIiBNQUNTVFIgIiB0eXBlPSVzJXMlcyVzIGlkPSVkIHByaW9yaXR5PSVkIHNwX3ByaW9yaXR5PSVkIiwKKwkJCWV4Y2x1ZGVkID8gSU5URVJXT1JLSU5HX0JMQUNLTElTVEVEIDogSU5URVJXT1JLSU5HX0FQLAorCQkJTUFDMlNUUihic3MtPmJzc2lkKSwgdHlwZSwKKwkJCWJoID8gIiBiZWxvd19taW5fYmFja2hhdWw9MSIgOiAiIiwKKwkJCWJzc19sb2FkID8gIiBvdmVyX21heF9ic3NfbG9hZD0xIiA6ICIiLAorCQkJY29ubl9jYXBhYiA/ICIgY29ubl9jYXBhYl9taXNzaW5nPTEiIDogIiIsCisJCQljcmVkLT5pZCwgY3JlZC0+cHJpb3JpdHksIGNyZWQtPnNwX3ByaW9yaXR5KTsKKwkJaWYgKGV4Y2x1ZGVkKQorCQkJY29udGludWU7CiAJCWlmICh3cGFfcy0+YXV0b19zZWxlY3QgfHwKIAkJICAgICh3cGFfcy0+Y29uZi0+YXV0b19pbnRlcndvcmtpbmcgJiYKIAkJICAgICB3cGFfcy0+YXV0b19uZXR3b3JrX3NlbGVjdCkpIHsKLQkJCWlmIChzZWxlY3RlZCA9PSBOVUxMIHx8Ci0JCQkgICAgY3JlZC0+cHJpb3JpdHkgPiBzZWxlY3RlZF9wcmlvKSB7Ci0JCQkJc2VsZWN0ZWQgPSBic3M7Ci0JCQkJc2VsZWN0ZWRfcHJpbyA9IGNyZWQtPnByaW9yaXR5OwotCQkJfQotCQkJaWYgKHJlcyA+IDAgJiYKLQkJCSAgICAoc2VsZWN0ZWRfaG9tZSA9PSBOVUxMIHx8Ci0JCQkgICAgIGNyZWQtPnByaW9yaXR5ID4gc2VsZWN0ZWRfaG9tZV9wcmlvKSkgewotCQkJCXNlbGVjdGVkX2hvbWUgPSBic3M7Ci0JCQkJc2VsZWN0ZWRfaG9tZV9wcmlvID0gY3JlZC0+cHJpb3JpdHk7CisJCQlpZiAoYmggfHwgYnNzX2xvYWQgfHwgY29ubl9jYXBhYikgeworCQkJCWlmIChzZWxlY3RlZDJfY3JlZCA9PSBOVUxMIHx8CisJCQkJICAgIGNyZWRfcHJpb19jbXAoY3JlZCwgc2VsZWN0ZWQyX2NyZWQpID4gMCkgeworCQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogTWFyayBhcyBzZWxlY3RlZDIiKTsKKwkJCQkJc2VsZWN0ZWQyID0gYnNzOworCQkJCQlzZWxlY3RlZDJfY3JlZCA9IGNyZWQ7CisJCQkJfQorCQkJCWlmIChyZXMgPiAwICYmCisJCQkJICAgIChzZWxlY3RlZDJfaG9tZV9jcmVkID09IE5VTEwgfHwKKwkJCQkgICAgIGNyZWRfcHJpb19jbXAoY3JlZCwgc2VsZWN0ZWQyX2hvbWVfY3JlZCkgPgorCQkJCSAgICAgMCkpIHsKKwkJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IE1hcmsgYXMgc2VsZWN0ZWQyX2hvbWUiKTsKKwkJCQkJc2VsZWN0ZWQyX2hvbWUgPSBic3M7CisJCQkJCXNlbGVjdGVkMl9ob21lX2NyZWQgPSBjcmVkOworCQkJCX0KKwkJCX0gZWxzZSB7CisJCQkJaWYgKHNlbGVjdGVkX2NyZWQgPT0gTlVMTCB8fAorCQkJCSAgICBjcmVkX3ByaW9fY21wKGNyZWQsIHNlbGVjdGVkX2NyZWQpID4gMCkgeworCQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogTWFyayBhcyBzZWxlY3RlZCIpOworCQkJCQlzZWxlY3RlZCA9IGJzczsKKwkJCQkJc2VsZWN0ZWRfY3JlZCA9IGNyZWQ7CisJCQkJfQorCQkJCWlmIChyZXMgPiAwICYmCisJCQkJICAgIChzZWxlY3RlZF9ob21lX2NyZWQgPT0gTlVMTCB8fAorCQkJCSAgICAgY3JlZF9wcmlvX2NtcChjcmVkLCBzZWxlY3RlZF9ob21lX2NyZWQpID4KKwkJCQkgICAgIDApKSB7CisJCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBNYXJrIGFzIHNlbGVjdGVkX2hvbWUiKTsKKwkJCQkJc2VsZWN0ZWRfaG9tZSA9IGJzczsKKwkJCQkJc2VsZWN0ZWRfaG9tZV9jcmVkID0gY3JlZDsKKwkJCQl9CiAJCQl9CiAJCX0KIAl9CiAKIAlpZiAoc2VsZWN0ZWRfaG9tZSAmJiBzZWxlY3RlZF9ob21lICE9IHNlbGVjdGVkICYmCi0JICAgIHNlbGVjdGVkX2hvbWVfcHJpbyA+PSBzZWxlY3RlZF9wcmlvKSB7CisJICAgIHNlbGVjdGVkX2hvbWVfY3JlZCAmJgorCSAgICAoc2VsZWN0ZWRfY3JlZCA9PSBOVUxMIHx8CisJICAgICBjcmVkX3ByaW9fY21wKHNlbGVjdGVkX2hvbWVfY3JlZCwgc2VsZWN0ZWRfY3JlZCkgPj0gMCkpIHsKIAkJLyogUHJlZmVyIG5ldHdvcmsgb3BlcmF0ZWQgYnkgdGhlIEhvbWUgU1AgKi8KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IE92ZXJyaWRlZCBzZWxlY3RlZCB3aXRoIHNlbGVjdGVkX2hvbWUiKTsKIAkJc2VsZWN0ZWQgPSBzZWxlY3RlZF9ob21lOworCQlzZWxlY3RlZF9jcmVkID0gc2VsZWN0ZWRfaG9tZV9jcmVkOworCX0KKworCWlmICghc2VsZWN0ZWQpIHsKKwkJaWYgKHNlbGVjdGVkMl9ob21lKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogVXNlIGhvbWUgQlNTIHdpdGggQlcgbGltaXQgbWlzbWF0Y2ggc2luY2Ugbm8gb3RoZXIgbmV0d29yayBjb3VsZCBiZSBzZWxlY3RlZCIpOworCQkJc2VsZWN0ZWQgPSBzZWxlY3RlZDJfaG9tZTsKKwkJCXNlbGVjdGVkX2NyZWQgPSBzZWxlY3RlZDJfaG9tZV9jcmVkOworCQl9IGVsc2UgaWYgKHNlbGVjdGVkMikgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFVzZSB2aXNpdGVkIEJTUyB3aXRoIEJXIGxpbWl0IG1pc21hdGNoIHNpbmNlIG5vIG90aGVyIG5ldHdvcmsgY291bGQgYmUgc2VsZWN0ZWQiKTsKKwkJCXNlbGVjdGVkID0gc2VsZWN0ZWQyOworCQkJc2VsZWN0ZWRfY3JlZCA9IHNlbGVjdGVkMl9jcmVkOworCQl9CiAJfQogCiAJaWYgKGNvdW50ID09IDApIHsKQEAgLTE2NjUsOSArMjM5OSwxMCBAQAogCQlpZiAoaW50ZXJ3b3JraW5nX2ZpbmRfbmV0d29ya19tYXRjaCh3cGFfcykpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBQb3NzaWJsZSBCU1MgIgogCQkJCSAgICJtYXRjaCBmb3IgZW5hYmxlZCBuZXR3b3JrIGNvbmZpZ3VyYXRpb25zIik7Ci0JCQlpZiAod3BhX3MtPmF1dG9fc2VsZWN0KQorCQkJaWYgKHdwYV9zLT5hdXRvX3NlbGVjdCkgewogCQkJCWludGVyd29ya2luZ19yZWNvbm5lY3Qod3BhX3MpOwotCQkJcmV0dXJuOworCQkJCXJldHVybjsKKwkJCX0KIAkJfQogCiAJCWlmICh3cGFfcy0+YXV0b19uZXR3b3JrX3NlbGVjdCkgewpAQCAtMTY4Miw4ICsyNDE3LDE4IEBACiAJCQkid2l0aCBtYXRjaGluZyBjcmVkZW50aWFscyBmb3VuZCIpOwogCX0KIAotCWlmIChzZWxlY3RlZCkKKwlpZiAoc2VsZWN0ZWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFNlbGVjdGVkICIgTUFDU1RSLAorCQkJICAgTUFDMlNUUihzZWxlY3RlZC0+YnNzaWQpKTsKKwkJc2VsZWN0ZWQgPSBwaWNrX2Jlc3Rfcm9hbWluZ19wYXJ0bmVyKHdwYV9zLCBzZWxlY3RlZCwKKwkJCQkJCSAgICAgc2VsZWN0ZWRfY3JlZCk7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBTZWxlY3RlZCAiIE1BQ1NUUgorCQkJICAgIiAoYWZ0ZXIgYmVzdCByb2FtaW5nIHBhcnRuZXIgc2VsZWN0aW9uKSIsCisJCQkgICBNQUMyU1RSKHNlbGVjdGVkLT5ic3NpZCkpOworCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgSU5URVJXT1JLSU5HX1NFTEVDVEVEIE1BQ1NUUiwKKwkJCU1BQzJTVFIoc2VsZWN0ZWQtPmJzc2lkKSk7CiAJCWludGVyd29ya2luZ19jb25uZWN0KHdwYV9zLCBzZWxlY3RlZCk7CisJfQogfQogCiAKQEAgLTE3MzAsOCArMjQ3NSwyMSBAQAogCWludCBmb3VuZCA9IDA7CiAJY29uc3QgdTggKmllOwogCi0JaWYgKGVsb29wX3Rlcm1pbmF0ZWQoKSB8fCAhd3BhX3MtPmZldGNoX2FucXBfaW5fcHJvZ3Jlc3MpCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IG5leHRfYW5xcF9mZXRjaCAtICIKKwkJICAgImZldGNoX2FucXBfaW5fcHJvZ3Jlc3M9JWQgZmV0Y2hfb3N1X2ljb25faW5fcHJvZ3Jlc3M9JWQiLAorCQkgICB3cGFfcy0+ZmV0Y2hfYW5xcF9pbl9wcm9ncmVzcywKKwkJICAgd3BhX3MtPmZldGNoX29zdV9pY29uX2luX3Byb2dyZXNzKTsKKworCWlmIChlbG9vcF90ZXJtaW5hdGVkKCkgfHwgIXdwYV9zLT5mZXRjaF9hbnFwX2luX3Byb2dyZXNzKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBTdG9wIG5leHQtQU5RUC1mZXRjaCIpOwogCQlyZXR1cm47CisJfQorCisJaWYgKHdwYV9zLT5mZXRjaF9vc3VfaWNvbl9pbl9wcm9ncmVzcykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogTmV4dCBpY29uIChpbiBwcm9ncmVzcykiKTsKKwkJaHMyMF9uZXh0X29zdV9pY29uKHdwYV9zKTsKKwkJcmV0dXJuOworCX0KIAogCWRsX2xpc3RfZm9yX2VhY2goYnNzLCAmd3BhX3MtPmJzcywgc3RydWN0IHdwYV9ic3MsIGxpc3QpIHsKIAkJaWYgKCEoYnNzLT5jYXBzICYgSUVFRTgwMjExX0NBUF9FU1MpKQpAQCAtMTczOSw2ICsyNDk3LDkgQEAKIAkJaWUgPSB3cGFfYnNzX2dldF9pZShic3MsIFdMQU5fRUlEX0VYVF9DQVBBQik7CiAJCWlmIChpZSA9PSBOVUxMIHx8IGllWzFdIDwgNCB8fCAhKGllWzVdICYgMHg4MCkpCiAJCQljb250aW51ZTsgLyogQVAgZG9lcyBub3Qgc3VwcG9ydCBJbnRlcndvcmtpbmcgKi8KKwkJaWYgKGRpc2FsbG93ZWRfYnNzaWQod3BhX3MsIGJzcy0+YnNzaWQpIHx8CisJCSAgICBkaXNhbGxvd2VkX3NzaWQod3BhX3MsIGJzcy0+c3NpZCwgYnNzLT5zc2lkX2xlbikpCisJCQljb250aW51ZTsgLyogRGlzYWxsb3dlZCBCU1MgKi8KIAogCQlpZiAoIShic3MtPmZsYWdzICYgV1BBX0JTU19BTlFQX0ZFVENIX1RSSUVEKSkgewogCQkJaWYgKGJzcy0+YW5xcCA9PSBOVUxMKSB7CkBAIC0xNzYyLDYgKzI1MjMsMTcgQEAKIAl9CiAKIAlpZiAoZm91bmQgPT0gMCkgeworCQlpZiAod3BhX3MtPmZldGNoX29zdV9pbmZvKSB7CisJCQlpZiAod3BhX3MtPm51bV9wcm92X2ZvdW5kID09IDAgJiYKKwkJCSAgICB3cGFfcy0+bnVtX29zdV9zY2FucyA8IDMpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkhTIDIuMDogTm8gT1NVIHByb3ZpZGVycyBzZWVuIC0gdHJ5IHRvIHNjYW4gYWdhaW4iKTsKKwkJCQloczIwX3N0YXJ0X29zdV9zY2FuKHdwYV9zKTsKKwkJCQlyZXR1cm47CisJCQl9CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogTmV4dCBpY29uIik7CisJCQloczIwX29zdV9pY29uX2ZldGNoKHdwYV9zKTsKKwkJCXJldHVybjsKKwkJfQogCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIkFOUVAgZmV0Y2ggY29tcGxldGVkIik7CiAJCXdwYV9zLT5mZXRjaF9hbnFwX2luX3Byb2dyZXNzID0gMDsKIAkJaWYgKHdwYV9zLT5uZXR3b3JrX3NlbGVjdCkKQEAgLTE3ODksNiArMjU2MSw3IEBACiAKIAl3cGFfcy0+bmV0d29ya19zZWxlY3QgPSAwOwogCXdwYV9zLT5mZXRjaF9hbGxfYW5xcCA9IDE7CisJd3BhX3MtPmZldGNoX29zdV9pbmZvID0gMDsKIAogCWludGVyd29ya2luZ19zdGFydF9mZXRjaF9hbnFwKHdwYV9zKTsKIApAQCAtMTgwNiw5ICsyNTc5LDEwIEBACiAKIAogaW50IGFucXBfc2VuZF9yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmRzdCwKLQkJICB1MTYgaW5mb19pZHNbXSwgc2l6ZV90IG51bV9pZHMpCisJCSAgdTE2IGluZm9faWRzW10sIHNpemVfdCBudW1faWRzLCB1MzIgc3VidHlwZXMpCiB7CiAJc3RydWN0IHdwYWJ1ZiAqYnVmOworCXN0cnVjdCB3cGFidWYgKmhzMjBfYnVmID0gTlVMTDsKIAlpbnQgcmV0ID0gMDsKIAlpbnQgZnJlcTsKIAlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOwpAQCAtMTgyNiwxOSArMjYwMCwyOSBAQAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogUXVlcnkgUmVxdWVzdCB0byAiIE1BQ1NUUiAiIGZvciAldSBpZChzKSIsCiAJCSAgIE1BQzJTVFIoZHN0KSwgKHVuc2lnbmVkIGludCkgbnVtX2lkcyk7CiAKLQlidWYgPSBhbnFwX2J1aWxkX3JlcShpbmZvX2lkcywgbnVtX2lkcywgTlVMTCk7CisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAoc3VidHlwZXMgIT0gMCkgeworCQloczIwX2J1ZiA9IHdwYWJ1Zl9hbGxvYygxMDApOworCQlpZiAoaHMyMF9idWYgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJaHMyMF9wdXRfYW5xcF9yZXEoc3VidHlwZXMsIE5VTEwsIDAsIGhzMjBfYnVmKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKworCWJ1ZiA9IGFucXBfYnVpbGRfcmVxKGluZm9faWRzLCBudW1faWRzLCBoczIwX2J1Zik7CisJd3BhYnVmX2ZyZWUoaHMyMF9idWYpOwogCWlmIChidWYgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCiAJcmVzID0gZ2FzX3F1ZXJ5X3JlcSh3cGFfcy0+Z2FzLCBkc3QsIGZyZXEsIGJ1ZiwgYW5xcF9yZXNwX2NiLCB3cGFfcyk7CiAJaWYgKHJlcyA8IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiBGYWlsZWQgdG8gc2VuZCBRdWVyeSBSZXF1ZXN0Iik7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CiAJCXJldCA9IC0xOwogCX0gZWxzZQogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IFF1ZXJ5IHN0YXJ0ZWQgd2l0aCBkaWFsb2cgdG9rZW4gIgogCQkJICAgIiV1IiwgcmVzKTsKIAotCXdwYWJ1Zl9mcmVlKGJ1Zik7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMTk4NiwxNCArMjc3MCwyMiBAQAogCXUxNiBzbGVuOwogCXN0cnVjdCB3cGFfYnNzICpic3MgPSBOVUxMLCAqdG1wOwogCi0JaWYgKHJlc3VsdCAhPSBHQVNfUVVFUllfU1VDQ0VTUykKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogYW5xcF9yZXNwX2NiIGRzdD0iIE1BQ1NUUgorCQkgICAiIGRpYWxvZ190b2tlbj0ldSByZXN1bHQ9JWQgc3RhdHVzX2NvZGU9JXUiLAorCQkgICBNQUMyU1RSKGRzdCksIGRpYWxvZ190b2tlbiwgcmVzdWx0LCBzdGF0dXNfY29kZSk7CisJaWYgKHJlc3VsdCAhPSBHQVNfUVVFUllfU1VDQ0VTUykgeworCQlpZiAod3BhX3MtPmZldGNoX29zdV9pY29uX2luX3Byb2dyZXNzKQorCQkJaHMyMF9pY29uX2ZldGNoX2ZhaWxlZCh3cGFfcyk7CiAJCXJldHVybjsKKwl9CiAKIAlwb3MgPSB3cGFidWZfaGVhZChhZHZfcHJvdG8pOwogCWlmICh3cGFidWZfbGVuKGFkdl9wcm90bykgPCA0IHx8IHBvc1swXSAhPSBXTEFOX0VJRF9BRFZfUFJPVE8gfHwKIAkgICAgcG9zWzFdIDwgMiB8fCBwb3NbM10gIT0gQUNDRVNTX05FVFdPUktfUVVFUllfUFJPVE9DT0wpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiBVbmV4cGVjdGVkIEFkdmVydGlzZW1lbnQgIgogCQkJICAgIlByb3RvY29sIGluIHJlc3BvbnNlIik7CisJCWlmICh3cGFfcy0+ZmV0Y2hfb3N1X2ljb25faW5fcHJvZ3Jlc3MpCisJCQloczIwX2ljb25fZmV0Y2hfZmFpbGVkKHdwYV9zKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMjAzMyw2ICsyODI1LDggQEAKIAkJCQkJCXNsZW4pOwogCQlwb3MgKz0gc2xlbjsKIAl9CisKKwloczIwX25vdGlmeV9wYXJzZV9kb25lKHdwYV9zKTsKIH0KIAogCkBAIC0yMDQ1LDE3ICsyODM5LDI0IEBACiB9CiAKIAotaW50IGludGVyd29ya2luZ19zZWxlY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGF1dG9fc2VsZWN0KQoraW50IGludGVyd29ya2luZ19zZWxlY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGF1dG9fc2VsZWN0LAorCQkJaW50ICpmcmVxcykKIHsKIAlpbnRlcndvcmtpbmdfc3RvcF9mZXRjaF9hbnFwKHdwYV9zKTsKIAl3cGFfcy0+bmV0d29ya19zZWxlY3QgPSAxOwogCXdwYV9zLT5hdXRvX25ldHdvcmtfc2VsZWN0ID0gMDsKIAl3cGFfcy0+YXV0b19zZWxlY3QgPSAhIWF1dG9fc2VsZWN0OwogCXdwYV9zLT5mZXRjaF9hbGxfYW5xcCA9IDA7CisJd3BhX3MtPmZldGNoX29zdV9pbmZvID0gMDsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogU3RhcnQgc2NhbiBmb3IgbmV0d29yayAiCiAJCSAgICJzZWxlY3Rpb24iKTsKIAl3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlciA9IGludGVyd29ya2luZ19zY2FuX3Jlc19oYW5kbGVyOworCXdwYV9zLT5ub3JtYWxfc2NhbnMgPSAwOwogCXdwYV9zLT5zY2FuX3JlcSA9IE1BTlVBTF9TQ0FOX1JFUTsKKwlvc19mcmVlKHdwYV9zLT5tYW51YWxfc2Nhbl9mcmVxcyk7CisJd3BhX3MtPm1hbnVhbF9zY2FuX2ZyZXFzID0gZnJlcXM7CisJd3BhX3MtPmFmdGVyX3dwcyA9IDA7CisJd3BhX3MtPmtub3duX3dwc19mcmVxID0gMDsKIAl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7CiAKIAlyZXR1cm4gMDsKQEAgLTIwNjgsNiArMjg2OSw3IEBACiAJCQljb25zdCBzdHJ1Y3Qgd3BhYnVmICpyZXNwLCB1MTYgc3RhdHVzX2NvZGUpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKKwlzdHJ1Y3Qgd3BhYnVmICpuOwogCiAJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIEdBU19SRVNQT05TRV9JTkZPICJhZGRyPSIgTUFDU1RSCiAJCSIgZGlhbG9nX3Rva2VuPSVkIHN0YXR1c19jb2RlPSVkIHJlc3BfbGVuPSVkIiwKQEAgLTIwNzYsMTAgKzI4NzgsMTQgQEAKIAlpZiAoIXJlc3ApCiAJCXJldHVybjsKIAotCXdwYWJ1Zl9mcmVlKHdwYV9zLT5sYXN0X2dhc19yZXNwKTsKLQl3cGFfcy0+bGFzdF9nYXNfcmVzcCA9IHdwYWJ1Zl9kdXAocmVzcCk7Ci0JaWYgKHdwYV9zLT5sYXN0X2dhc19yZXNwID09IE5VTEwpCisJbiA9IHdwYWJ1Zl9kdXAocmVzcCk7CisJaWYgKG4gPT0gTlVMTCkKIAkJcmV0dXJuOworCXdwYWJ1Zl9mcmVlKHdwYV9zLT5wcmV2X2dhc19yZXNwKTsKKwl3cGFfcy0+cHJldl9nYXNfcmVzcCA9IHdwYV9zLT5sYXN0X2dhc19yZXNwOworCW9zX21lbWNweSh3cGFfcy0+cHJldl9nYXNfYWRkciwgd3BhX3MtPmxhc3RfZ2FzX2FkZHIsIEVUSF9BTEVOKTsKKwl3cGFfcy0+cHJldl9nYXNfZGlhbG9nX3Rva2VuID0gd3BhX3MtPmxhc3RfZ2FzX2RpYWxvZ190b2tlbjsKKwl3cGFfcy0+bGFzdF9nYXNfcmVzcCA9IG47CiAJb3NfbWVtY3B5KHdwYV9zLT5sYXN0X2dhc19hZGRyLCBhZGRyLCBFVEhfQUxFTik7CiAJd3BhX3MtPmxhc3RfZ2FzX2RpYWxvZ190b2tlbiA9IGRpYWxvZ190b2tlbjsKIH0KQEAgLTIwOTUsNyArMjkwMSw3IEBACiAJc3RydWN0IHdwYV9ic3MgKmJzczsKIAlpbnQgcmVzOwogCXNpemVfdCBsZW47Ci0JdTggcXVlcnlfcmVzcF9sZW5fbGltaXQgPSAwLCBwYW1lX2JpID0gMDsKKwl1OCBxdWVyeV9yZXNwX2xlbl9saW1pdCA9IDA7CiAKIAlmcmVxID0gd3BhX3MtPmFzc29jX2ZyZXE7CiAJYnNzID0gd3BhX2Jzc19nZXRfYnNzaWQod3BhX3MsIGRzdCk7CkBAIC0yMTE5LDggKzI5MjUsNyBAQAogCS8qIEFkdmVydGlzZW1lbnQgUHJvdG9jb2wgSUUgKi8KIAl3cGFidWZfcHV0X3U4KGJ1ZiwgV0xBTl9FSURfQURWX1BST1RPKTsKIAl3cGFidWZfcHV0X3U4KGJ1ZiwgMSArIHdwYWJ1Zl9sZW4oYWR2X3Byb3RvKSk7IC8qIExlbmd0aCAqLwotCXdwYWJ1Zl9wdXRfdTgoYnVmLCAocXVlcnlfcmVzcF9sZW5fbGltaXQgJiAweDdmKSB8Ci0JCSAgICAgIChwYW1lX2JpID8gMHg4MCA6IDApKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgcXVlcnlfcmVzcF9sZW5fbGltaXQgJiAweDdmKTsKIAl3cGFidWZfcHV0X2J1ZihidWYsIGFkdl9wcm90byk7CiAKIAkvKiBHQVMgUXVlcnkgKi8KQEAgLTIxMzMsMTEgKzI5MzgsMTEgQEAKIAlyZXMgPSBnYXNfcXVlcnlfcmVxKHdwYV9zLT5nYXMsIGRzdCwgZnJlcSwgYnVmLCBnYXNfcmVzcF9jYiwgd3BhX3MpOwogCWlmIChyZXMgPCAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBGYWlsZWQgdG8gc2VuZCBRdWVyeSBSZXF1ZXN0Iik7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CiAJCXJldCA9IC0xOwogCX0gZWxzZQogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogUXVlcnkgc3RhcnRlZCB3aXRoIGRpYWxvZyB0b2tlbiAiCiAJCQkgICAiJXUiLCByZXMpOwogCi0Jd3BhYnVmX2ZyZWUoYnVmKTsKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvaW50ZXJ3b3JraW5nLmggYi93cGFfc3VwcGxpY2FudC9pbnRlcndvcmtpbmcuaAppbmRleCA0YTRhZjgyLi4zOGVmNzQ1IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9pbnRlcndvcmtpbmcuaAorKysgYi93cGFfc3VwcGxpY2FudC9pbnRlcndvcmtpbmcuaApAQCAtMTIsNyArMTIsNyBAQAogZW51bSBnYXNfcXVlcnlfcmVzdWx0OwogCiBpbnQgYW5xcF9zZW5kX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqZHN0LAotCQkgIHUxNiBpbmZvX2lkc1tdLCBzaXplX3QgbnVtX2lkcyk7CisJCSAgdTE2IGluZm9faWRzW10sIHNpemVfdCBudW1faWRzLCB1MzIgc3VidHlwZXMpOwogdm9pZCBhbnFwX3Jlc3BfY2Iodm9pZCAqY3R4LCBjb25zdCB1OCAqZHN0LCB1OCBkaWFsb2dfdG9rZW4sCiAJCSAgZW51bSBnYXNfcXVlcnlfcmVzdWx0IHJlc3VsdCwKIAkJICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICphZHZfcHJvdG8sCkBAIC0yMiwxMSArMjIsMTQgQEAKIAkJICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpxdWVyeSk7CiBpbnQgaW50ZXJ3b3JraW5nX2ZldGNoX2FucXAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIGludGVyd29ya2luZ19zdG9wX2ZldGNoX2FucXAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci1pbnQgaW50ZXJ3b3JraW5nX3NlbGVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgYXV0b19zZWxlY3QpOworaW50IGludGVyd29ya2luZ19zZWxlY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGF1dG9fc2VsZWN0LAorCQkJaW50ICpmcmVxcyk7CiBpbnQgaW50ZXJ3b3JraW5nX2Nvbm5lY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9ic3MgKmJzcyk7CiB2b2lkIGludGVyd29ya2luZ19zdGFydF9mZXRjaF9hbnFwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogaW50IGludGVyd29ya2luZ19ob21lX3NwX2NyZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgICAgIHN0cnVjdCB3cGFfY3JlZCAqY3JlZCwKIAkJCSAgICAgIHN0cnVjdCB3cGFidWYgKmRvbWFpbl9uYW1lcyk7CitpbnQgZG9tYWluX25hbWVfbGlzdF9jb250YWlucyhzdHJ1Y3Qgd3BhYnVmICpkb21haW5fbmFtZXMsCisJCQkgICAgICBjb25zdCBjaGFyICpkb21haW4sIGludCBleGFjdF9tYXRjaCk7CiAKICNlbmRpZiAvKiBJTlRFUldPUktJTkdfSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvbWFpbi5jIGIvd3BhX3N1cHBsaWNhbnQvbWFpbi5jCmluZGV4IDM5YjgzN2UuLmQyZTgzOWQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L21haW4uYworKysgYi93cGFfc3VwcGxpY2FudC9tYWluLmMKQEAgLTE2LDI0ICsxNiwzNiBAQAogI2luY2x1ZGUgImRyaXZlcl9pLmgiCiAjaW5jbHVkZSAicDJwX3N1cHBsaWNhbnQuaCIKIAotZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyAqd3BhX2RyaXZlcnNbXTsKLQogCiBzdGF0aWMgdm9pZCB1c2FnZSh2b2lkKQogewogCWludCBpOwogCXByaW50ZigiJXNcblxuJXNcbiIKIAkgICAgICAgInVzYWdlOlxuIgotCSAgICAgICAiICB3cGFfc3VwcGxpY2FudCBbLUJkZGhLTHFxc3R1dlddIFstUDxwaWQgZmlsZT5dICIKKwkgICAgICAgIiAgd3BhX3N1cHBsaWNhbnQgWy1CZGRoS0xxcSIKKyNpZmRlZiBDT05GSUdfREVCVUdfU1lTTE9HCisJICAgICAgICJzIgorI2VuZGlmIC8qIENPTkZJR19ERUJVR19TWVNMT0cgKi8KKwkgICAgICAgInQiCisjaWZkZWYgQ09ORklHX0RCVVMKKwkgICAgICAgInUiCisjZW5kaWYgLyogQ09ORklHX0RCVVMgKi8KKwkgICAgICAgInZXXSBbLVA8cGlkIGZpbGU+XSAiCiAJICAgICAgICJbLWc8Z2xvYmFsIGN0cmw+XSBcXFxuIgogCSAgICAgICAiICAgICAgICBbLUc8Z3JvdXA+XSBcXFxuIgogCSAgICAgICAiICAgICAgICAtaTxpZm5hbWU+IC1jPGNvbmZpZyBmaWxlPiBbLUM8Y3RybD5dIFstRDxkcml2ZXI+XSAiCiAJICAgICAgICJbLXA8ZHJpdmVyX3BhcmFtPl0gXFxcbiIKLQkgICAgICAgIiAgICAgICAgWy1iPGJyX2lmbmFtZT5dIFstZjxkZWJ1ZyBmaWxlPl0gWy1lPGVudHJvcHkgZmlsZT5dICIKLQkgICAgICAgIlxcXG4iCisJICAgICAgICIgICAgICAgIFstYjxicl9pZm5hbWU+XSBbLWU8ZW50cm9weSBmaWxlPl0iCisjaWZkZWYgQ09ORklHX0RFQlVHX0ZJTEUKKwkgICAgICAgIiBbLWY8ZGVidWcgZmlsZT5dIgorI2VuZGlmIC8qIENPTkZJR19ERUJVR19GSUxFICovCisJICAgICAgICIgXFxcbiIKIAkgICAgICAgIiAgICAgICAgWy1vPG92ZXJyaWRlIGRyaXZlcj5dIFstTzxvdmVycmlkZSBjdHJsPl0gXFxcbiIKIAkgICAgICAgIiAgICAgICAgWy1OIC1pPGlmbmFtZT4gLWM8Y29uZj4gWy1DPGN0cmw+XSAiCiAJICAgICAgICJbLUQ8ZHJpdmVyPl0gXFxcbiIKKyNpZmRlZiBDT05GSUdfUDJQCisJICAgICAgICIgICAgICAgIFstbTxQMlAgRGV2aWNlIGNvbmZpZyBmaWxlPl0gXFxcbiIKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJICAgICAgICIgICAgICAgIFstcDxkcml2ZXJfcGFyYW0+XSBbLWI8YnJfaWZuYW1lPl0gWy1JPGNvbmZpZyBmaWxlPl0gIgogCSAgICAgICAiLi4uXVxuIgogCSAgICAgICAiXG4iCkBAIC04Myw2ICs5NSw5IEBACiAjZW5kaWYgLyogQ09ORklHX0RCVVMgKi8KIAlwcmludGYoIiAgLXYgPSBzaG93IHZlcnNpb25cbiIKIAkgICAgICAgIiAgLVcgPSB3YWl0IGZvciBhIGNvbnRyb2wgaW50ZXJmYWNlIG1vbml0b3IgYmVmb3JlIHN0YXJ0aW5nXG4iCisjaWZkZWYgQ09ORklHX1AyUAorCSAgICAgICAiICAtbSA9IENvbmZpZ3VyYXRpb24gZmlsZSBmb3IgdGhlIFAyUCBEZXZpY2UgaW50ZXJmYWNlXG4iCisjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCSAgICAgICAiICAtTiA9IHN0YXJ0IGRlc2NyaWJpbmcgbmV3IGludGVyZmFjZVxuIik7CiAKIAlwcmludGYoImV4YW1wbGU6XG4iCkBAIC0xNjAsNyArMTc1LDcgQEAKIAogCWZvciAoOzspIHsKIAkJYyA9IGdldG9wdChhcmdjLCBhcmd2LAotCQkJICAgImI6QmM6QzpEOmRlOmY6ZzpHOmhpOkk6S0xObzpPOnA6UDpxc1R0dXZXIik7CisJCQkgICAiYjpCYzpDOkQ6ZGU6ZjpnOkc6aGk6STpLTG06Tm86TzpwOlA6cXNUdHV2VyIpOwogCQlpZiAoYyA8IDApCiAJCQlicmVhazsKIAkJc3dpdGNoIChjKSB7CkBAIC0yMjAsNiArMjM1LDExIEBACiAJCQlsaWNlbnNlKCk7CiAJCQlleGl0Y29kZSA9IDA7CiAJCQlnb3RvIG91dDsKKyNpZmRlZiBDT05GSUdfUDJQCisJCWNhc2UgJ20nOgorCQkJaWZhY2UtPmNvbmZfcDJwX2RldiA9IG9wdGFyZzsKKwkJCWJyZWFrOworI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJY2FzZSAnbyc6CiAJCQlwYXJhbXMub3ZlcnJpZGVfZHJpdmVyID0gb3B0YXJnOwogCQkJYnJlYWs7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9ub3RpZnkuYyBiL3dwYV9zdXBwbGljYW50L25vdGlmeS5jCmluZGV4IGFiNjJiZWEuLjNiNzMwY2YgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L25vdGlmeS5jCisrKyBiL3dwYV9zdXBwbGljYW50L25vdGlmeS5jCkBAIC03OSwxMiArNzksMTAgQEAKIAkvKiBub3RpZnkgdGhlIG5ldyBEQnVzIEFQSSAqLwogCXdwYXNfZGJ1c19zaWduYWxfcHJvcF9jaGFuZ2VkKHdwYV9zLCBXUEFTX0RCVVNfUFJPUF9TVEFURSk7CiAKLSNpZmRlZiBDT05GSUdfUDJQCiAJaWYgKG5ld19zdGF0ZSA9PSBXUEFfQ09NUExFVEVEKQogCQl3cGFzX3AycF9ub3RpZl9jb25uZWN0ZWQod3BhX3MpOwogCWVsc2UgaWYgKG9sZF9zdGF0ZSA+PSBXUEFfQVNTT0NJQVRFRCAmJiBuZXdfc3RhdGUgPCBXUEFfQVNTT0NJQVRFRCkKIAkJd3Bhc19wMnBfbm90aWZfZGlzY29ubmVjdGVkKHdwYV9zKTsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKIAlzbWVfc3RhdGVfY2hhbmdlZCh3cGFfcyk7CiAKQEAgLTk2LDcgKzk0LDcgQEAKIAkJICAgICBNQUMyU1RSKHdwYV9zLT5ic3NpZCksCiAJCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkID8KIAkJICAgICB3cGFfc3NpZF90eHQod3BhX3MtPmN1cnJlbnRfc3NpZC0+c3NpZCwKLQkJICAgICB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkX2xlbik6ICIiKTsKKwkJCQkgIHdwYV9zLT5jdXJyZW50X3NzaWQtPnNzaWRfbGVuKSA6ICIiKTsKICNlbmRpZiAvKiBBTkRST0lEICovCiB9CiAKQEAgLTI1MiwxMyArMjUwLDEzIEBACiB2b2lkIHdwYXNfbm90aWZ5X25ldHdvcmtfcmVtb3ZlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCiB7CisJaWYgKHdwYV9zLT5uZXh0X3NzaWQgPT0gc3NpZCkKKwkJd3BhX3MtPm5leHRfc3NpZCA9IE5VTEw7CiAJaWYgKHdwYV9zLT53cGEpCiAJCXdwYV9zbV9wbWtzYV9jYWNoZV9mbHVzaCh3cGFfcy0+d3BhLCBzc2lkKTsKIAlpZiAoIXNzaWQtPnAycF9ncm91cCAmJiB3cGFfcy0+Z2xvYmFsLT5wMnBfZ3JvdXBfZm9ybWF0aW9uICE9IHdwYV9zKQogCQl3cGFzX2RidXNfdW5yZWdpc3Rlcl9uZXR3b3JrKHdwYV9zLCBzc2lkLT5pZCk7Ci0jaWZkZWYgQ09ORklHX1AyUAogCXdwYXNfcDJwX25ldHdvcmtfcmVtb3ZlZCh3cGFfcywgc3NpZCk7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwogfQogCiAKQEAgLTQ0MCw5ICs0MzgsOSBAQAogCQkJCSAgIGNvbnN0IHN0cnVjdCB3cGFfc3NpZCAqc3NpZCwKIAkJCQkgICBjb25zdCBjaGFyICpyb2xlKQogewotCXdwYXNfZGJ1c191bnJlZ2lzdGVyX3AycF9ncm91cCh3cGFfcywgc3NpZCk7Ci0KIAl3cGFzX2RidXNfc2lnbmFsX3AycF9ncm91cF9yZW1vdmVkKHdwYV9zLCByb2xlKTsKKworCXdwYXNfZGJ1c191bnJlZ2lzdGVyX3AycF9ncm91cCh3cGFfcywgc3NpZCk7CiB9CiAKIApAQCAtNTM5LDE3ICs1MzcsMTAgQEAKIAl3cGFzX3AycF9ub3RpZnlfYXBfc3RhX2F1dGhvcml6ZWQod3BhX3MsIHAycF9kZXZfYWRkcik7CiAKIAkvKgotCSAqIFJlZ2lzdGVyIGEgZ3JvdXAgbWVtYmVyIG9iamVjdCBjb3JyZXNwb25kaW5nIHRvIHRoaXMgcGVlciBhbmQKLQkgKiBlbWl0IGEgUGVlckpvaW5lZCBzaWduYWwuIFRoaXMgd2lsbCBjaGVjayBpZiBpdCByZWFsbHkgaXMgYQotCSAqIFAyUCBncm91cC4KLQkgKi8KLQl3cGFzX2RidXNfcmVnaXN0ZXJfcDJwX2dyb3VwbWVtYmVyKHdwYV9zLCBzdGEpOwotCi0JLyoKIAkgKiBDcmVhdGUgJ3BlZXItam9pbmVkJyBzaWduYWwgb24gZ3JvdXAgb2JqZWN0IC0tIHdpbGwgYWxzbwogCSAqIGNoZWNrIFAyUCBpdHNlbGYuCiAJICovCi0Jd3Bhc19kYnVzX3NpZ25hbF9wMnBfcGVlcl9qb2luZWQod3BhX3MsIHN0YSk7CisJd3Bhc19kYnVzX3NpZ25hbF9wMnBfcGVlcl9qb2luZWQod3BhX3MsIHAycF9kZXZfYWRkcik7CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAJLyogTm90aWZ5IGxpc3RlbmVycyBhIG5ldyBzdGF0aW9uIGhhcyBiZWVuIGF1dGhvcml6ZWQgKi8KQEAgLTU1OCwyMCArNTQ5LDE1IEBACiAKIAogc3RhdGljIHZvaWQgd3Bhc19ub3RpZnlfYXBfc3RhX2RlYXV0aG9yaXplZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJCQkgICAgY29uc3QgdTggKnN0YSkKKwkJCQkJICAgIGNvbnN0IHU4ICpzdGEsCisJCQkJCSAgICBjb25zdCB1OCAqcDJwX2Rldl9hZGRyKQogewogI2lmZGVmIENPTkZJR19QMlAKIAkvKgotCSAqIFVucmVnaXN0ZXIgYSBncm91cCBtZW1iZXIgb2JqZWN0IGNvcnJlc3BvbmRpbmcgdG8gdGhpcyBwZWVyCi0JICogaWYgdGhpcyBpcyBhIFAyUCBncm91cC4KLQkgKi8KLQl3cGFzX2RidXNfdW5yZWdpc3Rlcl9wMnBfZ3JvdXBtZW1iZXIod3BhX3MsIHN0YSk7Ci0KLQkvKgogCSAqIENyZWF0ZSAncGVlci1kaXNjb25uZWN0ZWQnIHNpZ25hbCBvbiBncm91cCBvYmplY3QgaWYgdGhpcwogCSAqIGlzIGEgUDJQIGdyb3VwLgogCSAqLwotCXdwYXNfZGJ1c19zaWduYWxfcDJwX3BlZXJfZGlzY29ubmVjdGVkKHdwYV9zLCBzdGEpOworCXdwYXNfZGJ1c19zaWduYWxfcDJwX3BlZXJfZGlzY29ubmVjdGVkKHdwYV9zLCBwMnBfZGV2X2FkZHIpOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCS8qIE5vdGlmeSBsaXN0ZW5lcnMgYSBzdGF0aW9uIGhhcyBiZWVuIGRlYXV0aG9yaXplZCAqLwpAQCAtNTg2LDcgKzU3Miw3IEBACiAJaWYgKGF1dGhvcml6ZWQpCiAJCXdwYXNfbm90aWZ5X2FwX3N0YV9hdXRob3JpemVkKHdwYV9zLCBtYWNfYWRkciwgcDJwX2Rldl9hZGRyKTsKIAllbHNlCi0JCXdwYXNfbm90aWZ5X2FwX3N0YV9kZWF1dGhvcml6ZWQod3BhX3MsIG1hY19hZGRyKTsKKwkJd3Bhc19ub3RpZnlfYXBfc3RhX2RlYXV0aG9yaXplZCh3cGFfcywgbWFjX2FkZHIsIHAycF9kZXZfYWRkcik7CiB9CiAKIApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvb2ZmY2hhbm5lbC5jIGIvd3BhX3N1cHBsaWNhbnQvb2ZmY2hhbm5lbC5jCmluZGV4IGQ5NDQwN2MuLjE3Njg5YzUgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L29mZmNoYW5uZWwuYworKysgYi93cGFfc3VwcGxpY2FudC9vZmZjaGFubmVsLmMKQEAgLTEyLDYgKzEyLDcgQEAKICNpbmNsdWRlICJjb21tb24uaCIKICNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgogI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKKyNpbmNsdWRlICJwMnBfc3VwcGxpY2FudC5oIgogI2luY2x1ZGUgImRyaXZlcl9pLmgiCiAjaW5jbHVkZSAib2ZmY2hhbm5lbC5oIgogCkBAIC01NSwxMSArNTYsMTIgQEAKIAogCXdpdGhvdXRfcm9jID0gd3BhX3MtPnBlbmRpbmdfYWN0aW9uX3dpdGhvdXRfcm9jOwogCXdwYV9zLT5wZW5kaW5nX2FjdGlvbl93aXRob3V0X3JvYyA9IDA7Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJPZmYtY2hhbm5lbDogU2VuZCBBY3Rpb24gY2FsbGJhY2sgIgotCQkgICAiKHdpdGhvdXRfcm9jPSVkIHBlbmRpbmdfYWN0aW9uX3R4PSVwKSIsCi0JCSAgIHdpdGhvdXRfcm9jLCB3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHgpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkgICAiT2ZmLWNoYW5uZWw6IFNlbmQgQWN0aW9uIGNhbGxiYWNrICh3aXRob3V0X3JvYz0lZCBwZW5kaW5nX2FjdGlvbl90eD0lcCBwZW5kaW5nX2FjdGlvbl90eF9kb25lPSVkKSIsCisJCSAgIHdpdGhvdXRfcm9jLCB3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHgsCisJCSAgICEhd3BhX3MtPnBlbmRpbmdfYWN0aW9uX3R4X2RvbmUpOwogCi0JaWYgKHdwYV9zLT5wZW5kaW5nX2FjdGlvbl90eCA9PSBOVUxMKQorCWlmICh3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHggPT0gTlVMTCB8fCB3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHhfZG9uZSkKIAkJcmV0dXJuOwogCiAJLyoKQEAgLTE1OSw2ICsxNjEsMjEgQEAKIAkJcmV0dXJuOwogCX0KIAorCS8qIEFjY2VwdCByZXBvcnQgb25seSBpZiB0aGUgY29udGVudHMgb2YgdGhlIGZyYW1lIG1hdGNoZXMgKi8KKwlpZiAoZGF0YV9sZW4gLSB3cGFidWZfbGVuKHdwYV9zLT5wZW5kaW5nX2FjdGlvbl90eCkgIT0gMjQgfHwKKwkgICAgb3NfbWVtY21wKGRhdGEgKyAyNCwgd3BhYnVmX2hlYWQod3BhX3MtPnBlbmRpbmdfYWN0aW9uX3R4KSwKKwkJICAgICAgd3BhYnVmX2xlbih3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHgpKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT2ZmLWNoYW5uZWw6IElnbm9yZSBBY3Rpb24gVFggc3RhdHVzIC0gIgorCQkJCSAgICJtaXNtYXRjaGluZyBjb250ZW50cyB3aXRoIHBlbmRpbmcgZnJhbWUiKTsKKwkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJUWCBzdGF0dXMgZnJhbWUgZGF0YSIsCisJCQkgICAgZGF0YSwgZGF0YV9sZW4pOworCQl3cGFfaGV4ZHVtcF9idWYoTVNHX01TR0RVTVAsICJQZW5kaW5nIFRYIGZyYW1lIiwKKwkJCQl3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHgpOworCQlyZXR1cm47CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPZmYtY2hhbm5lbDogRGVsZXRlIG1hdGNoaW5nIHBlbmRpbmcgYWN0aW9uIGZyYW1lIik7CisKIAl3cGFidWZfZnJlZSh3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHgpOwogCXdwYV9zLT5wZW5kaW5nX2FjdGlvbl90eCA9IE5VTEw7CiAKQEAgLTE3Miw2ICsxODksMTIgQEAKIAkJCXdwYV9zLT5wZW5kaW5nX2FjdGlvbl9ic3NpZCwKIAkJCWRhdGEsIGRhdGFfbGVuLCByZXN1bHQpOwogCX0KKworCWlmICh3cGFfcy0+cDJwX2xvbmdfbGlzdGVuID4gMCkgeworCQkvKiBDb250aW51ZSB0aGUgbGlzdGVuICovCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDb250aW51aW5nIGxvbmcgTGlzdGVuIHN0YXRlIik7CisJCXdwYXNfcDJwX2xpc3Rlbl9zdGFydCh3cGFfcywgd3BhX3MtPnAycF9sb25nX2xpc3Rlbik7CisJfQogfQogCiAKQEAgLTIyMCw2ICsyNDMsNyBAQAogCQkJICAgTUFDMlNUUih3cGFfcy0+cGVuZGluZ19hY3Rpb25fZHN0KSk7CiAJCXdwYWJ1Zl9mcmVlKHdwYV9zLT5wZW5kaW5nX2FjdGlvbl90eCk7CiAJfQorCXdwYV9zLT5wZW5kaW5nX2FjdGlvbl90eF9kb25lID0gMDsKIAl3cGFfcy0+cGVuZGluZ19hY3Rpb25fdHggPSB3cGFidWZfYWxsb2MobGVuKTsKIAlpZiAod3BhX3MtPnBlbmRpbmdfYWN0aW9uX3R4ID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJPZmYtY2hhbm5lbDogRmFpbGVkIHRvIGFsbG9jYXRlIEFjdGlvbiAiCkBAIC0yMzYsMTggKzI2MCwyMiBAQAogCiAJaWYgKGZyZXEgIT0gMCAmJiB3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19PRkZDSEFOTkVMX1RYKSB7CiAJCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqaWZhY2U7CisJCWludCByZXQ7CiAKIAkJaWZhY2UgPSB3cGFzX2dldF90eF9pbnRlcmZhY2Uod3BhX3MsCiAJCQkJCSAgICAgIHdwYV9zLT5wZW5kaW5nX2FjdGlvbl9zcmMpOwogCQl3cGFfcy0+YWN0aW9uX3R4X3dhaXRfdGltZSA9IHdhaXRfdGltZTsKIAotCQlyZXR1cm4gd3BhX2Rydl9zZW5kX2FjdGlvbigKKwkJcmV0ID0gd3BhX2Rydl9zZW5kX2FjdGlvbigKIAkJCWlmYWNlLCB3cGFfcy0+cGVuZGluZ19hY3Rpb25fZnJlcSwKIAkJCXdhaXRfdGltZSwgd3BhX3MtPnBlbmRpbmdfYWN0aW9uX2RzdCwKIAkJCXdwYV9zLT5wZW5kaW5nX2FjdGlvbl9zcmMsIHdwYV9zLT5wZW5kaW5nX2FjdGlvbl9ic3NpZCwKIAkJCXdwYWJ1Zl9oZWFkKHdwYV9zLT5wZW5kaW5nX2FjdGlvbl90eCksCiAJCQl3cGFidWZfbGVuKHdwYV9zLT5wZW5kaW5nX2FjdGlvbl90eCksCiAJCQl3cGFfcy0+cGVuZGluZ19hY3Rpb25fbm9fY2NrKTsKKwkJaWYgKHJldCA9PSAwKQorCQkJd3BhX3MtPnBlbmRpbmdfYWN0aW9uX3R4X2RvbmUgPSAxOworCQlyZXR1cm4gcmV0OwogCX0KIAogCWlmIChmcmVxKSB7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9wMnBfc3VwcGxpY2FudC5jIGIvd3BhX3N1cHBsaWNhbnQvcDJwX3N1cHBsaWNhbnQuYwppbmRleCBkN2IzMTg5Li4zZWVhOWU4IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9wMnBfc3VwcGxpY2FudC5jCisrKyBiL3dwYV9zdXBwbGljYW50L3AycF9zdXBwbGljYW50LmMKQEAgLTEsNiArMSw3IEBACiAvKgogICogd3BhX3N1cHBsaWNhbnQgLSBQMlAKICAqIENvcHlyaWdodCAoYykgMjAwOS0yMDEwLCBBdGhlcm9zIENvbW11bmljYXRpb25zCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTksNiArMjAsNyBAQAogI2luY2x1ZGUgImFwL2FwX2NvbmZpZy5oIgogI2luY2x1ZGUgImFwL3N0YV9pbmZvLmgiCiAjaW5jbHVkZSAiYXAvYXBfZHJ2X29wcy5oIgorI2luY2x1ZGUgImFwL3dwc19ob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXAvcDJwX2hvc3RhcGQuaCIKICNpbmNsdWRlICJlYXBvbF9zdXBwL2VhcG9sX3N1cHBfc20uaCIKICNpbmNsdWRlICJyc25fc3VwcC93cGEuaCIKQEAgLTMzLDYgKzM1LDcgQEAKICNpbmNsdWRlICJvZmZjaGFubmVsLmgiCiAjaW5jbHVkZSAid3BzX3N1cHBsaWNhbnQuaCIKICNpbmNsdWRlICJwMnBfc3VwcGxpY2FudC5oIgorI2luY2x1ZGUgIndpZmlfZGlzcGxheS5oIgogCiAKIC8qCkBAIC00OCwxNyArNTEsMTQgQEAKICAqIEhvdyBtYW55IHNlY29uZHMgdG8gdHJ5IHRvIHJlY29ubmVjdCB0byB0aGUgR08gd2hlbiBjb25uZWN0aW9uIGluIFAyUCBjbGllbnQKICAqIHJvbGUgaGFzIGJlZW4gbG9zdC4KICAqLwotI2lmZGVmIEFORFJPSURfUDJQCi0jZGVmaW5lIFAyUF9NQVhfQ0xJRU5UX0lETEUgMjAKLSNlbHNlCiAjZGVmaW5lIFAyUF9NQVhfQ0xJRU5UX0lETEUgMTAKLSNlbmRpZiAvKiBBTkRST0lEX1AyUCAqLwogI2VuZGlmIC8qIFAyUF9NQVhfQ0xJRU5UX0lETEUgKi8KIAogI2lmbmRlZiBQMlBfTUFYX0lOSVRJQUxfQ09OTl9XQUlUCiAvKgogICogSG93IG1hbnkgc2Vjb25kcyB0byB3YWl0IGZvciBpbml0aWFsIDQtd2F5IGhhbmRzaGFrZSB0byBnZXQgY29tcGxldGVkIGFmdGVyCi0gKiBXUFMgcHJvdmlzaW9uaW5nIHN0ZXAuCisgKiBXUFMgcHJvdmlzaW9uaW5nIHN0ZXAgb3IgYWZ0ZXIgdGhlIHJlLWludm9jYXRpb24gb2YgYSBwZXJzaXN0ZW50IGdyb3VwIG9uIGEKKyAqIFAyUCBDbGllbnQuCiAgKi8KICNkZWZpbmUgUDJQX01BWF9JTklUSUFMX0NPTk5fV0FJVCAxMAogI2VuZGlmIC8qIFAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVQgKi8KQEAgLTczLDkgKzczLDE0IEBACiAjZGVmaW5lIFAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVRfR08gMTAKICNlbmRpZiAvKiBQMlBfTUFYX0lOSVRJQUxfQ09OTl9XQUlUX0dPICovCiAKLSNpZm5kZWYgUDJQX0NPTkNVUlJFTlRfU0VBUkNIX0RFTEFZCi0jZGVmaW5lIFAyUF9DT05DVVJSRU5UX1NFQVJDSF9ERUxBWSA1MDAKLSNlbmRpZiAvKiBQMlBfQ09OQ1VSUkVOVF9TRUFSQ0hfREVMQVkgKi8KKyNpZm5kZWYgUDJQX01BWF9JTklUSUFMX0NPTk5fV0FJVF9HT19SRUlOVk9LRQorLyoKKyAqIEhvdyBtYW55IHNlY29uZHMgdG8gd2FpdCBmb3IgaW5pdGlhbCA0LXdheSBoYW5kc2hha2UgdG8gZ2V0IGNvbXBsZXRlZCBhZnRlcgorICogcmUtaW52b2NhdGlvbiBvZiBhIHBlcnNpc3RlbnQgZ3JvdXAgb24gdGhlIEdPIHdoZW4gdGhlIGNsaWVudCBpcyBleHBlY3RlZAorICogdG8gY29ubmVjdCBhdXRvbWF0aWNhbGx5IChubyB1c2VyIGludGVyYWN0aW9uKS4KKyAqLworI2RlZmluZSBQMlBfTUFYX0lOSVRJQUxfQ09OTl9XQUlUX0dPX1JFSU5WT0tFIDE1CisjZW5kaWYgLyogUDJQX01BWF9JTklUSUFMX0NPTk5fV0FJVF9HT19SRUlOVk9LRSAqLwogCiAjZGVmaW5lIFAyUF9NR01UX0RFVklDRV9QUkVGSVgJCSJwMnAtZGV2LSIKIApAQCAtODgsOSArOTMsNyBAQAogCVAyUF9HUk9VUF9SRU1PVkFMX1VOQVZBSUxBQkxFLAogCVAyUF9HUk9VUF9SRU1PVkFMX0dPX0VORElOR19TRVNTSU9OLAogCVAyUF9HUk9VUF9SRU1PVkFMX1BTS19GQUlMVVJFLAotI2lmZGVmIEFORFJPSURfUDJQCiAJUDJQX0dST1VQX1JFTU9WQUxfRlJFUV9DT05GTElDVAotI2VuZGlmCiB9OwogCiAKQEAgLTk4LDI0ICsxMDEsMjggQEAKIHN0YXRpYyBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKgogd3Bhc19wMnBfZ2V0X2dyb3VwX2lmYWNlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBhZGRyX2FsbG9jYXRlZCwKIAkJCSBpbnQgZ28pOwotc3RhdGljIGludCB3cGFzX3AycF9qb2luX3N0YXJ0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwotc3RhdGljIHZvaWQgd3Bhc19wMnBfam9pbl9zY2FuX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgZnJlcSk7CitzdGF0aWMgaW50IHdwYXNfcDJwX2pvaW5fc3RhcnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEsCisJCQkgICAgICAgY29uc3QgdTggKnNzaWQsIHNpemVfdCBzc2lkX2xlbik7CitzdGF0aWMgdm9pZCB3cGFzX3AycF9qb2luX3NjYW5fcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBmcmVxLAorCQkJCSAgIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pOwogc3RhdGljIHZvaWQgd3Bhc19wMnBfam9pbl9zY2FuKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOwogc3RhdGljIGludCB3cGFzX3AycF9qb2luKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICppZmFjZV9hZGRyLAogCQkJIGNvbnN0IHU4ICpkZXZfYWRkciwgZW51bSBwMnBfd3BzX21ldGhvZCB3cHNfbWV0aG9kLAotCQkJIGludCBhdXRvX2pvaW4pOworCQkJIGludCBhdXRvX2pvaW4sIGludCBmcmVxLAorCQkJIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pOwogc3RhdGljIGludCB3cGFzX3AycF9jcmVhdGVfaWZhY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiBzdGF0aWMgdm9pZCB3cGFzX3AycF9jcm9zc19jb25uZWN0X3NldHVwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogc3RhdGljIHZvaWQgd3Bhc19wMnBfZ3JvdXBfaWRsZV90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOwogc3RhdGljIHZvaWQgd3Bhc19wMnBfc2V0X2dyb3VwX2lkbGVfdGltZW91dChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwKIAkJCQkJICAgICB2b2lkICp0aW1lb3V0X2N0eCk7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX2dyb3VwX2ZyZXFfY29uZmxpY3Qodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCk7Ci0jZW5kaWYKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX2ZhbGxiYWNrX3RvX2dvX25lZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQlpbnQgZ3JvdXBfYWRkZWQpOwogc3RhdGljIGludCB3cGFzX3AycF9zdG9wX2ZpbmRfb3BlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3N0YXRpYyB2b2lkIHdwYXNfc3RvcF9saXN0ZW4odm9pZCAqY3R4KTsKK3N0YXRpYyB2b2lkIHdwYXNfcDJwX3Bza19mYWlsdXJlX3JlbW92YWwodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCk7CitzdGF0aWMgdm9pZCB3cGFzX3AycF9ncm91cF9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiAKIAogLyoKQEAgLTEyNSw3ICsxMzIsNyBAQAogc3RhdGljIGludCB3cGFzX3AycF9udW1fdW51c2VkX2NoYW5uZWxzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJaW50ICpmcmVxczsKLQlpbnQgbnVtOworCWludCBudW0sIHVudXNlZDsKIAogCWZyZXFzID0gb3NfY2FsbG9jKHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQsIHNpemVvZihpbnQpKTsKIAlpZiAoIWZyZXFzKQpAQCAtMTM1LDcgKzE0Miw5IEBACiAJCQkJICAgICB3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50KTsKIAlvc19mcmVlKGZyZXFzKTsKIAotCXJldHVybiB3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50IC0gbnVtOworCXVudXNlZCA9IHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQgLSBudW07CisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBudW1fdW51c2VkX2NoYW5uZWxzOiAlZCIsIHVudXNlZCk7CisJcmV0dXJuIHVudXNlZDsKIH0KIAogCkBAIC0xNDMsMjggKzE1MiwzMyBAQAogICogR2V0IHRoZSBmcmVxdWVuY2llcyB0aGF0IGFyZSBjdXJyZW50bHkgaW4gdXNlIGJ5IG9uZSBvciBtb3JlIG9mIHRoZSB2aXJ0dWFsCiAgKiBpbnRlcmZhY2VzLCBhbmQgdGhhdCBhcmUgYWxzbyB2YWxpZCBmb3IgUDJQIG9wZXJhdGlvbi4KICAqLwotc3RhdGljIGludCB3cGFzX3AycF92YWxpZF9vcGVyX2ZyZXFzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgICBpbnQgKnAycF9mcmVxcywgdW5zaWduZWQgaW50IGxlbikKK3N0YXRpYyB1bnNpZ25lZCBpbnQKK3dwYXNfcDJwX3ZhbGlkX29wZXJfZnJlcXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqcDJwX2ZyZXFzLAorCQkJICB1bnNpZ25lZCBpbnQgbGVuKQogewotCWludCAqZnJlcXM7CisJc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqZnJlcXM7CiAJdW5zaWduZWQgaW50IG51bSwgaSwgajsKIAotCWZyZXFzID0gb3NfY2FsbG9jKHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQsIHNpemVvZihpbnQpKTsKKwlmcmVxcyA9IG9zX2NhbGxvYyh3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50LAorCQkJICBzaXplb2Yoc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSkpOwogCWlmICghZnJlcXMpCi0JCXJldHVybiAtMTsKKwkJcmV0dXJuIDA7CiAKLQludW0gPSBnZXRfc2hhcmVkX3JhZGlvX2ZyZXFzKHdwYV9zLCBmcmVxcywKLQkJCQkgICAgIHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQpOworCW51bSA9IGdldF9zaGFyZWRfcmFkaW9fZnJlcXNfZGF0YSh3cGFfcywgZnJlcXMsCisJCQkJCSAgd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCk7CiAKLQlvc19tZW1zZXQocDJwX2ZyZXFzLCAwLCBzaXplb2YoaW50KSAqIGxlbik7CisJb3NfbWVtc2V0KHAycF9mcmVxcywgMCwgc2l6ZW9mKHN0cnVjdCB3cGFfdXNlZF9mcmVxX2RhdGEpICogbGVuKTsKIAogCWZvciAoaSA9IDAsIGogPSAwOyBpIDwgbnVtICYmIGogPCBsZW47IGkrKykgewotCQlpZiAocDJwX3N1cHBvcnRlZF9mcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcXNbaV0pKQorCQlpZiAocDJwX3N1cHBvcnRlZF9mcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcXNbaV0uZnJlcSkpCiAJCQlwMnBfZnJlcXNbaisrXSA9IGZyZXFzW2ldOwogCX0KIAogCW9zX2ZyZWUoZnJlcXMpOwogCisJZHVtcF9mcmVxX2RhdGEod3BhX3MsICJ2YWxpZCBmb3IgUDJQIiwgcDJwX2ZyZXFzLCBqKTsKKwogCXJldHVybiBqOwogfQogCkBAIC0xNzQsMTAgKzE4OCwxMyBAQAogewogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybjsKLQlpZiAoZnJlcSA+IDAgJiYgd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCA+IDEgJiYKLQkgICAgd3Bhc19wMnBfbnVtX3VudXNlZF9jaGFubmVscyh3cGFfcykgPiAwICYmCi0JICAgIHdwYV9zLT5wYXJlbnQtPmNvbmYtPnAycF9pZ25vcmVfc2hhcmVkX2ZyZXEpCisJaWYgKHdwYV9zLT5wYXJlbnQtPmNvbmYtPnAycF9pZ25vcmVfc2hhcmVkX2ZyZXEgJiYKKwkgICAgZnJlcSA+IDAgJiYgd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCA+IDEgJiYKKwkgICAgd3Bhc19wMnBfbnVtX3VudXNlZF9jaGFubmVscyh3cGFfcykgPiAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBJZ25vcmUgb3duIGNoYW5uZWwgcHJlZmVyZW5jZSAlZCBNSHogZHVlIHRvIHAycF9pZ25vcmVfc2hhcmVkX2ZyZXE9MSBjb25maWd1cmF0aW9uIiwKKwkJCSAgIGZyZXEpOwogCQlmcmVxID0gMDsKKwl9CiAJcDJwX3NldF9vd25fZnJlcV9wcmVmZXJlbmNlKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcSk7CiB9CiAKQEAgLTE4Nyw2ICsyMDQsMTIgQEAKIHsKIAlzaXplX3QgaTsKIAorCWlmICh3cGFfcy0+cDJwX3NjYW5fd29yaykgeworCQlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcmsgPSB3cGFfcy0+cDJwX3NjYW5fd29yazsKKwkJd3BhX3MtPnAycF9zY2FuX3dvcmsgPSBOVUxMOworCQlyYWRpb193b3JrX2RvbmUod29yayk7CisJfQorCiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKIAkJcmV0dXJuOwogCkBAIC0xOTUsMTQgKzIxOCwyOSBAQAogCiAJZm9yIChpID0gMDsgaSA8IHNjYW5fcmVzLT5udW07IGkrKykgewogCQlzdHJ1Y3Qgd3BhX3NjYW5fcmVzICpic3MgPSBzY2FuX3Jlcy0+cmVzW2ldOwotCQlzdHJ1Y3Qgb3NfdGltZSB0aW1lX3RtcF9hZ2UsIGVudHJ5X3RzOworCQlzdHJ1Y3Qgb3NfcmVsdGltZSB0aW1lX3RtcF9hZ2UsIGVudHJ5X3RzOworCQljb25zdCB1OCAqaWVzOworCQlzaXplX3QgaWVzX2xlbjsKKwogCQl0aW1lX3RtcF9hZ2Uuc2VjID0gYnNzLT5hZ2UgLyAxMDAwOwogCQl0aW1lX3RtcF9hZ2UudXNlYyA9IChic3MtPmFnZSAlIDEwMDApICogMTAwMDsKLQkJb3NfdGltZV9zdWIoJnNjYW5fcmVzLT5mZXRjaF90aW1lLCAmdGltZV90bXBfYWdlLCAmZW50cnlfdHMpOworCQlvc19yZWx0aW1lX3N1Yigmc2Nhbl9yZXMtPmZldGNoX3RpbWUsICZ0aW1lX3RtcF9hZ2UsICZlbnRyeV90cyk7CisKKwkJaWVzID0gKGNvbnN0IHU4ICopIChic3MgKyAxKTsKKwkJaWVzX2xlbiA9IGJzcy0+aWVfbGVuOworCQlpZiAoYnNzLT5iZWFjb25faWVfbGVuID4gMCAmJgorCQkgICAgIXdwYV9zY2FuX2dldF92ZW5kb3JfaWUoYnNzLCBQMlBfSUVfVkVORE9SX1RZUEUpICYmCisJCSAgICB3cGFfc2Nhbl9nZXRfdmVuZG9yX2llX2JlYWNvbihic3MsIFAyUF9JRV9WRU5ET1JfVFlQRSkpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBVc2UgUDJQIElFKHMpIGZyb20gQmVhY29uIGZyYW1lIHNpbmNlIG5vIFAyUCBJRShzKSBpbiBQcm9iZSBSZXNwb25zZSBmcmFtZXMgcmVjZWl2ZWQgZm9yICIKKwkJCQkgICBNQUNTVFIsIE1BQzJTVFIoYnNzLT5ic3NpZCkpOworCQkJaWVzID0gaWVzICsgaWVzX2xlbjsKKwkJCWllc19sZW4gPSBic3MtPmJlYWNvbl9pZV9sZW47CisJCX0KKworCiAJCWlmIChwMnBfc2Nhbl9yZXNfaGFuZGxlcih3cGFfcy0+Z2xvYmFsLT5wMnAsIGJzcy0+YnNzaWQsCiAJCQkJCSBic3MtPmZyZXEsICZlbnRyeV90cywgYnNzLT5sZXZlbCwKLQkJCQkJIChjb25zdCB1OCAqKSAoYnNzICsgMSksCi0JCQkJCSBic3MtPmllX2xlbikgPiAwKQorCQkJCQkgaWVzLCBpZXNfbGVuKSA+IDApCiAJCQlicmVhazsKIAl9CiAKQEAgLTIxMCw5NCArMjQ4LDEzMCBAQAogfQogCiAKK3N0YXRpYyB2b2lkIHdwYXNfcDJwX3RyaWdnZXJfc2Nhbl9jYihzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcmssIGludCBkZWluaXQpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHdvcmstPndwYV9zOworCXN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpwYXJhbXMgPSB3b3JrLT5jdHg7CisJaW50IHJldDsKKworCWlmIChkZWluaXQpIHsKKwkJaWYgKCF3b3JrLT5zdGFydGVkKSB7CisJCQl3cGFfc2Nhbl9mcmVlX3BhcmFtcyhwYXJhbXMpOworCQkJcmV0dXJuOworCQl9CisKKwkJd3BhX3MtPnAycF9zY2FuX3dvcmsgPSBOVUxMOworCQlyZXR1cm47CisJfQorCisJcmV0ID0gd3BhX2Rydl9zY2FuKHdwYV9zLCBwYXJhbXMpOworCXdwYV9zY2FuX2ZyZWVfcGFyYW1zKHBhcmFtcyk7CisJd29yay0+Y3R4ID0gTlVMTDsKKwlpZiAocmV0KSB7CisJCXJhZGlvX3dvcmtfZG9uZSh3b3JrKTsKKwkJcmV0dXJuOworCX0KKworCW9zX2dldF9yZWx0aW1lKCZ3cGFfcy0+c2Nhbl90cmlnZ2VyX3RpbWUpOworCXdwYV9zLT5zY2FuX3Jlc19oYW5kbGVyID0gd3Bhc19wMnBfc2Nhbl9yZXNfaGFuZGxlcjsKKwl3cGFfcy0+b3duX3NjYW5fcmVxdWVzdGVkID0gMTsKKwl3cGFfcy0+cDJwX3NjYW5fd29yayA9IHdvcms7Cit9CisKKwogc3RhdGljIGludCB3cGFzX3AycF9zY2FuKHZvaWQgKmN0eCwgZW51bSBwMnBfc2Nhbl90eXBlIHR5cGUsIGludCBmcmVxLAogCQkJIHVuc2lnbmVkIGludCBudW1fcmVxX2Rldl90eXBlcywKIAkJCSBjb25zdCB1OCAqcmVxX2Rldl90eXBlcywgY29uc3QgdTggKmRldl9pZCwgdTE2IHB3X2lkKQogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7Ci0Jc3RydWN0IHdwYV9zdXBwbGljYW50ICppZnM7Ci0Jc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgcGFyYW1zOwotCWludCByZXQ7CisJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgKnBhcmFtcyA9IE5VTEw7CiAJc3RydWN0IHdwYWJ1ZiAqd3BzX2llLCAqaWVzOwotCWludCBzb2NpYWxfY2hhbm5lbHNbXSA9IHsgMjQxMiwgMjQzNywgMjQ2MiwgMCwgMCB9OwogCXNpemVfdCBpZWxlbjsKKwl1OCAqbjsKIAogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAotCWZvciAoaWZzID0gd3BhX3MtPmdsb2JhbC0+aWZhY2VzOyBpZnM7IGlmcyA9IGlmcy0+bmV4dCkgewotCQlpZiAoaWZzLT5zdGFfc2Nhbl9wZW5kaW5nICYmCi0JCSAgICAod3Bhc19zY2FuX3NjaGVkdWxlZChpZnMpIHx8IGlmcy0+c2Nhbm5pbmcpICYmCi0JCSAgICB3cGFzX3AycF9pbl9wcm9ncmVzcyh3cGFfcykgPT0gMikgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEZWxheWluZyBQMlAgc2NhbiB0byBhbGxvdyAiCi0JCQkJICAgInBlbmRpbmcgc3RhdGlvbiBtb2RlIHNjYW4gdG8gYmUgIgotCQkJCSAgICJjb21wbGV0ZWQgb24gaW50ZXJmYWNlICVzIiwgaWZzLT5pZm5hbWUpOwotCQkJd3BhX3MtPmdsb2JhbC0+cDJwX2NiX29uX3NjYW5fY29tcGxldGUgPSAxOwotCQkJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4oaWZzLCAwLCAwKTsKLQkJCXJldHVybiAxOwotCQl9CisJaWYgKHdwYV9zLT5wMnBfc2Nhbl93b3JrKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19JTkZPLCAiUDJQOiBSZWplY3Qgc2NhbiB0cmlnZ2VyIHNpbmNlIG9uZSBpcyBhbHJlYWR5IHBlbmRpbmciKTsKKwkJcmV0dXJuIC0xOwogCX0KIAotCW9zX21lbXNldCgmcGFyYW1zLCAwLCBzaXplb2YocGFyYW1zKSk7CisJcGFyYW1zID0gb3NfemFsbG9jKHNpemVvZigqcGFyYW1zKSk7CisJaWYgKHBhcmFtcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CiAKIAkvKiBQMlAgV2lsZGNhcmQgU1NJRCAqLwotCXBhcmFtcy5udW1fc3NpZHMgPSAxOwotCXBhcmFtcy5zc2lkc1swXS5zc2lkID0gKHU4ICopIFAyUF9XSUxEQ0FSRF9TU0lEOwotCXBhcmFtcy5zc2lkc1swXS5zc2lkX2xlbiA9IFAyUF9XSUxEQ0FSRF9TU0lEX0xFTjsKKwlwYXJhbXMtPm51bV9zc2lkcyA9IDE7CisJbiA9IG9zX21hbGxvYyhQMlBfV0lMRENBUkRfU1NJRF9MRU4pOworCWlmIChuID09IE5VTEwpCisJCWdvdG8gZmFpbDsKKwlvc19tZW1jcHkobiwgUDJQX1dJTERDQVJEX1NTSUQsIFAyUF9XSUxEQ0FSRF9TU0lEX0xFTik7CisJcGFyYW1zLT5zc2lkc1swXS5zc2lkID0gbjsKKwlwYXJhbXMtPnNzaWRzWzBdLnNzaWRfbGVuID0gUDJQX1dJTERDQVJEX1NTSURfTEVOOwogCiAJd3BhX3MtPndwcy0+ZGV2LnAycCA9IDE7CiAJd3BzX2llID0gd3BzX2J1aWxkX3Byb2JlX3JlcV9pZShwd19pZCwgJndwYV9zLT53cHMtPmRldiwKIAkJCQkJd3BhX3MtPndwcy0+dXVpZCwgV1BTX1JFUV9FTlJPTExFRSwKIAkJCQkJbnVtX3JlcV9kZXZfdHlwZXMsIHJlcV9kZXZfdHlwZXMpOwogCWlmICh3cHNfaWUgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOworCQlnb3RvIGZhaWw7CiAKIAlpZWxlbiA9IHAycF9zY2FuX2llX2J1Zl9sZW4od3BhX3MtPmdsb2JhbC0+cDJwKTsKIAlpZXMgPSB3cGFidWZfYWxsb2Mod3BhYnVmX2xlbih3cHNfaWUpICsgaWVsZW4pOwogCWlmIChpZXMgPT0gTlVMTCkgewogCQl3cGFidWZfZnJlZSh3cHNfaWUpOwotCQlyZXR1cm4gLTE7CisJCWdvdG8gZmFpbDsKIAl9CiAJd3BhYnVmX3B1dF9idWYoaWVzLCB3cHNfaWUpOwogCXdwYWJ1Zl9mcmVlKHdwc19pZSk7CiAKIAlwMnBfc2Nhbl9pZSh3cGFfcy0+Z2xvYmFsLT5wMnAsIGllcywgZGV2X2lkKTsKIAotCXBhcmFtcy5wMnBfcHJvYmUgPSAxOwotCXBhcmFtcy5leHRyYV9pZXMgPSB3cGFidWZfaGVhZChpZXMpOwotCXBhcmFtcy5leHRyYV9pZXNfbGVuID0gd3BhYnVmX2xlbihpZXMpOworCXBhcmFtcy0+cDJwX3Byb2JlID0gMTsKKwluID0gb3NfbWFsbG9jKHdwYWJ1Zl9sZW4oaWVzKSk7CisJaWYgKG4gPT0gTlVMTCkgeworCQl3cGFidWZfZnJlZShpZXMpOworCQlnb3RvIGZhaWw7CisJfQorCW9zX21lbWNweShuLCB3cGFidWZfaGVhZChpZXMpLCB3cGFidWZfbGVuKGllcykpOworCXBhcmFtcy0+ZXh0cmFfaWVzID0gbjsKKwlwYXJhbXMtPmV4dHJhX2llc19sZW4gPSB3cGFidWZfbGVuKGllcyk7CisJd3BhYnVmX2ZyZWUoaWVzKTsKIAogCXN3aXRjaCAodHlwZSkgewogCWNhc2UgUDJQX1NDQU5fU09DSUFMOgotCQlwYXJhbXMuZnJlcXMgPSBzb2NpYWxfY2hhbm5lbHM7CisJCXBhcmFtcy0+ZnJlcXMgPSBvc19tYWxsb2MoNCAqIHNpemVvZihpbnQpKTsKKwkJaWYgKHBhcmFtcy0+ZnJlcXMgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbDsKKwkJcGFyYW1zLT5mcmVxc1swXSA9IDI0MTI7CisJCXBhcmFtcy0+ZnJlcXNbMV0gPSAyNDM3OworCQlwYXJhbXMtPmZyZXFzWzJdID0gMjQ2MjsKKwkJcGFyYW1zLT5mcmVxc1szXSA9IDA7CiAJCWJyZWFrOwogCWNhc2UgUDJQX1NDQU5fRlVMTDoKIAkJYnJlYWs7CiAJY2FzZSBQMlBfU0NBTl9TT0NJQUxfUExVU19PTkU6Ci0JCXNvY2lhbF9jaGFubmVsc1szXSA9IGZyZXE7Ci0JCXBhcmFtcy5mcmVxcyA9IHNvY2lhbF9jaGFubmVsczsKKwkJcGFyYW1zLT5mcmVxcyA9IG9zX21hbGxvYyg1ICogc2l6ZW9mKGludCkpOworCQlpZiAocGFyYW1zLT5mcmVxcyA9PSBOVUxMKQorCQkJZ290byBmYWlsOworCQlwYXJhbXMtPmZyZXFzWzBdID0gMjQxMjsKKwkJcGFyYW1zLT5mcmVxc1sxXSA9IDI0Mzc7CisJCXBhcmFtcy0+ZnJlcXNbMl0gPSAyNDYyOworCQlwYXJhbXMtPmZyZXFzWzNdID0gZnJlcTsKKwkJcGFyYW1zLT5mcmVxc1s0XSA9IDA7CiAJCWJyZWFrOwogCX0KIAotCXJldCA9IHdwYV9kcnZfc2Nhbih3cGFfcywgJnBhcmFtcyk7CisJcmFkaW9fcmVtb3ZlX3dvcmtzKHdwYV9zLCAicDJwLXNjYW4iLCAwKTsKKwlpZiAocmFkaW9fYWRkX3dvcmsod3BhX3MsIDAsICJwMnAtc2NhbiIsIDAsIHdwYXNfcDJwX3RyaWdnZXJfc2Nhbl9jYiwKKwkJCSAgIHBhcmFtcykgPCAwKQorCQlnb3RvIGZhaWw7CisJcmV0dXJuIDA7CiAKLQl3cGFidWZfZnJlZShpZXMpOwotCi0JaWYgKHJldCkgewotCQlmb3IgKGlmcyA9IHdwYV9zLT5nbG9iYWwtPmlmYWNlczsgaWZzOyBpZnMgPSBpZnMtPm5leHQpIHsKLQkJCWlmIChpZnMtPnNjYW5uaW5nIHx8Ci0JCQkgICAgaWZzLT5zY2FuX3Jlc19oYW5kbGVyID09IHdwYXNfcDJwX3NjYW5fcmVzX2hhbmRsZXIpIHsKLQkJCQl3cGFfcy0+Z2xvYmFsLT5wMnBfY2Jfb25fc2Nhbl9jb21wbGV0ZSA9IDE7Ci0JCQkJcmV0ID0gMTsKLQkJCQlicmVhazsKLQkJCX0KLQkJfQotCX0gZWxzZSB7Ci0JCW9zX2dldF90aW1lKCZ3cGFfcy0+c2Nhbl90cmlnZ2VyX3RpbWUpOwotCQl3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlciA9IHdwYXNfcDJwX3NjYW5fcmVzX2hhbmRsZXI7Ci0JfQotCi0JcmV0dXJuIHJldDsKK2ZhaWw6CisJd3BhX3NjYW5fZnJlZV9wYXJhbXMocGFyYW1zKTsKKwlyZXR1cm4gLTE7CiB9CiAKIApAQCAtNDA1LDExICs0NzksOSBAQAogCWNhc2UgUDJQX0dST1VQX1JFTU9WQUxfUFNLX0ZBSUxVUkU6CiAJCXJlYXNvbiA9ICIgcmVhc29uPVBTS19GQUlMVVJFIjsKIAkJYnJlYWs7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKIAljYXNlIFAyUF9HUk9VUF9SRU1PVkFMX0ZSRVFfQ09ORkxJQ1Q6CiAJCXJlYXNvbiA9ICIgcmVhc29uPUZSRVFfQ09ORkxJQ1QiOwogCQlicmVhazsKLSNlbmRpZgogCWRlZmF1bHQ6CiAJCXJlYXNvbiA9ICIiOwogCQlicmVhazsKQEAgLTQyMCw5ICs0OTIsOCBAQAogCQkJICAgICAgIHdwYV9zLT5pZm5hbWUsIGd0eXBlLCByZWFzb24pOwogCX0KIAotI2lmZGVmIEFORFJPSURfUDJQCi0JZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfZnJlcV9jb25mbGljdCwgd3BhX3MsIE5VTEwpOwotI2VuZGlmCisJaWYgKGVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2ZyZXFfY29uZmxpY3QsIHdwYV9zLCBOVUxMKSA+IDApCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDYW5jZWxsZWQgUDJQIGdyb3VwIGZyZXFfY29uZmxpY3QgdGltZW91dCIpOwogCWlmIChlbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9ncm91cF9pZGxlX3RpbWVvdXQsIHdwYV9zLCBOVUxMKSA+IDApCiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDYW5jZWxsZWQgUDJQIGdyb3VwIGlkbGUgdGltZW91dCIpOwogCWlmIChlbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9ncm91cF9mb3JtYXRpb25fdGltZW91dCwKQEAgLTQzMiw2ICs1MDMsMTQgQEAKIAkJd3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcgPSAwOwogCX0KIAorCXdwYV9zLT5wMnBfaW5faW52aXRhdGlvbiA9IDA7CisKKwkvKgorCSAqIE1ha2Ugc3VyZSB3YWl0IGZvciB0aGUgZmlyc3QgY2xpZW50IGRvZXMgbm90IHJlbWFpbiBhY3RpdmUgYWZ0ZXIgdGhlCisJICogZ3JvdXAgaGFzIGJlZW4gcmVtb3ZlZC4KKwkgKi8KKwl3cGFfcy0+Z2xvYmFsLT5wMnBfZ29fd2FpdF9jbGllbnQuc2VjID0gMDsKKwogCWlmIChyZW1vdmFsX3JlYXNvbiAhPSBQMlBfR1JPVVBfUkVNT1ZBTF9TSUxFTlQgJiYgc3NpZCkKIAkJd3Bhc19ub3RpZnlfcDJwX2dyb3VwX3JlbW92ZWQod3BhX3MsIHNzaWQsIGd0eXBlKTsKIApAQCAtNDUyLDYgKzUzMSwxNyBAQAogCQlyZXR1cm4gMTsKIAl9CiAKKwlpZiAoIXdwYV9zLT5wMnBfZ29fZ3JvdXBfZm9ybWF0aW9uX2NvbXBsZXRlZCkgeworCQl3cGFfcy0+Z2xvYmFsLT5wMnBfZ3JvdXBfZm9ybWF0aW9uID0gTlVMTDsKKwkJd3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcgPSAwOworCX0KKworCXdwYV9zLT5zaG93X2dyb3VwX3N0YXJ0ZWQgPSAwOworCW9zX2ZyZWUod3BhX3MtPmdvX3BhcmFtcyk7CisJd3BhX3MtPmdvX3BhcmFtcyA9IE5VTEw7CisKKwl3cGFfcy0+d2FpdGluZ19wcmVzZW5jZV9yZXNwID0gMDsKKwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBSZW1vdmUgdGVtcG9yYXJ5IGdyb3VwIG5ldHdvcmsiKTsKIAlpZiAoc3NpZCAmJiAoc3NpZC0+cDJwX2dyb3VwIHx8CiAJCSAgICAgc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTiB8fApAQCAtNDc0LDcgKzU2NCw2IEBACiAJCXdwYV9jb25maWdfcmVtb3ZlX25ldHdvcmsod3BhX3MtPmNvbmYsIGlkKTsKIAkJd3BhX3N1cHBsaWNhbnRfY2xlYXJfc3RhdHVzKHdwYV9zKTsKIAkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjaGVkX3NjYW4od3BhX3MpOwotCQl3cGFfcy0+c3RhX3NjYW5fcGVuZGluZyA9IDA7CiAJfSBlbHNlIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRlbXBvcmFyeSBncm91cCBuZXR3b3JrIG5vdCAiCiAJCQkgICAiZm91bmQiKTsKQEAgLTUwNCw2ICs1OTMsMTAgQEAKIAkJYnNzaWQgPSB3cGFfcy0+YnNzaWQ7CiAKIAlic3MgPSB3cGFfYnNzX2dldCh3cGFfcywgYnNzaWQsIHNzaWQsIHNzaWRfbGVuKTsKKwlpZiAoYnNzID09IE5VTEwgJiYgd3BhX3MtPmdvX3BhcmFtcyAmJgorCSAgICAhaXNfemVyb19ldGhlcl9hZGRyKHdwYV9zLT5nb19wYXJhbXMtPnBlZXJfZGV2aWNlX2FkZHIpKQorCQlic3MgPSB3cGFfYnNzX2dldF9wMnBfZGV2X2FkZHIoCisJCQl3cGFfcywgd3BhX3MtPmdvX3BhcmFtcy0+cGVlcl9kZXZpY2VfYWRkcik7CiAJaWYgKGJzcyA9PSBOVUxMKSB7CiAJCXU4IGlmYWNlX2FkZHJbRVRIX0FMRU5dOwogCQlpZiAocDJwX2dldF9pbnRlcmZhY2VfYWRkcih3cGFfcy0+Z2xvYmFsLT5wMnAsIGJzc2lkLApAQCAtNTE4LDYgKzYxMSw5IEBACiAJfQogCiAJcDJwID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llX211bHRpKGJzcywgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKKwlpZiAocDJwID09IE5VTEwpCisJCXAycCA9IHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZV9tdWx0aV9iZWFjb24oYnNzLAorCQkJCQkJCSBQMlBfSUVfVkVORE9SX1RZUEUpOwogCWlmIChwMnAgPT0gTlVMTCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ291bGQgbm90IGZpZ3VyZSBvdXQgd2hldGhlciAiCiAJCQkgICAiZ3JvdXAgaXMgcGVyc2lzdGVudCAtIEJTUyAiIE1BQ1NUUgpAQCAtNjMwLDEyICs3MjYsMTAgQEAKIAkJY2hhbmdlZCA9IDE7CiAJfQogCi0jaWZuZGVmIENPTkZJR19OT19DT05GSUdfV1JJVEUKIAlpZiAoY2hhbmdlZCAmJiB3cGFfcy0+Y29uZi0+dXBkYXRlX2NvbmZpZyAmJgogCSAgICB3cGFfY29uZmlnX3dyaXRlKHdwYV9zLT5jb25mbmFtZSwgd3BhX3MtPmNvbmYpKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGYWlsZWQgdG8gdXBkYXRlIGNvbmZpZ3VyYXRpb24iKTsKIAl9Ci0jZW5kaWYgLyogQ09ORklHX05PX0NPTkZJR19XUklURSAqLwogCiAJcmV0dXJuIHMtPmlkOwogfQpAQCAtNjkyLDcgKzc4Niw3IEBACiAJCW9zX21lbWNweShuICsgcy0+bnVtX3AycF9jbGllbnRzICogRVRIX0FMRU4sIGFkZHIsIEVUSF9BTEVOKTsKIAkJcy0+cDJwX2NsaWVudF9saXN0ID0gbjsKIAkJcy0+bnVtX3AycF9jbGllbnRzKys7Ci0JfSBlbHNlIGlmICghZm91bmQpIHsKKwl9IGVsc2UgaWYgKCFmb3VuZCAmJiBzLT5wMnBfY2xpZW50X2xpc3QpIHsKIAkJLyogTm90IGVub3VnaCByb29tIGZvciBhbiBhZGRpdGlvbmFsIGVudHJ5IC0gZHJvcCB0aGUgb2xkZXN0CiAJCSAqIGVudHJ5ICovCiAJCW9zX21lbW1vdmUocy0+cDJwX2NsaWVudF9saXN0LApAQCAtNzAzLDExICs3OTcsNTQgQEAKIAkJCSAgYWRkciwgRVRIX0FMRU4pOwogCX0KIAotI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX1dSSVRFCiAJaWYgKHdwYV9zLT5wYXJlbnQtPmNvbmYtPnVwZGF0ZV9jb25maWcgJiYKIAkgICAgd3BhX2NvbmZpZ193cml0ZSh3cGFfcy0+cGFyZW50LT5jb25mbmFtZSwgd3BhX3MtPnBhcmVudC0+Y29uZikpCiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGYWlsZWQgdG8gdXBkYXRlIGNvbmZpZ3VyYXRpb24iKTsKLSNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX1dSSVRFICovCit9CisKKworc3RhdGljIHZvaWQgd3Bhc19wMnBfZ3JvdXBfc3RhcnRlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgIGludCBnbywgc3RydWN0IHdwYV9zc2lkICpzc2lkLCBpbnQgZnJlcSwKKwkJCQkgICBjb25zdCB1OCAqcHNrLCBjb25zdCBjaGFyICpwYXNzcGhyYXNlLAorCQkJCSAgIGNvbnN0IHU4ICpnb19kZXZfYWRkciwgaW50IHBlcnNpc3RlbnQsCisJCQkJICAgY29uc3QgY2hhciAqZXh0cmEpCit7CisJY29uc3QgY2hhciAqc3NpZF90eHQ7CisJY2hhciBwc2tfdHh0WzY1XTsKKworCWlmIChwc2spCisJCXdwYV9zbnByaW50Zl9oZXgocHNrX3R4dCwgc2l6ZW9mKHBza190eHQpLCBwc2ssIDMyKTsKKwllbHNlCisJCXBza190eHRbMF0gPSAnXDAnOworCisJaWYgKHNzaWQpCisJCXNzaWRfdHh0ID0gd3BhX3NzaWRfdHh0KHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKKwllbHNlCisJCXNzaWRfdHh0ID0gIiI7CisKKwlpZiAocGFzc3BocmFzZSAmJiBwYXNzcGhyYXNlWzBdID09ICdcMCcpCisJCXBhc3NwaHJhc2UgPSBOVUxMOworCisJLyoKKwkgKiBJbmNsdWRlIFBTSy9wYXNzcGhyYXNlIG9ubHkgaW4gdGhlIGNvbnRyb2wgaW50ZXJmYWNlIG1lc3NhZ2UgYW5kCisJICogbGVhdmUgaXQgb3V0IGZyb20gdGhlIGRlYnVnIGxvZyBlbnRyeS4KKwkgKi8KKwl3cGFfbXNnX2dsb2JhbF9jdHJsKHdwYV9zLT5wYXJlbnQsIE1TR19JTkZPLAorCQkJICAgIFAyUF9FVkVOVF9HUk9VUF9TVEFSVEVECisJCQkgICAgIiVzICVzIHNzaWQ9XCIlc1wiIGZyZXE9JWQlcyVzJXMlcyVzIGdvX2Rldl9hZGRyPSIKKwkJCSAgICBNQUNTVFIgIiVzJXMiLAorCQkJICAgIHdwYV9zLT5pZm5hbWUsIGdvID8gIkdPIiA6ICJjbGllbnQiLCBzc2lkX3R4dCwgZnJlcSwKKwkJCSAgICBwc2sgPyAiIHBzaz0iIDogIiIsIHBza190eHQsCisJCQkgICAgcGFzc3BocmFzZSA/ICIgcGFzc3BocmFzZT1cIiIgOiAiIiwKKwkJCSAgICBwYXNzcGhyYXNlID8gcGFzc3BocmFzZSA6ICIiLAorCQkJICAgIHBhc3NwaHJhc2UgPyAiXCIiIDogIiIsCisJCQkgICAgTUFDMlNUUihnb19kZXZfYWRkciksCisJCQkgICAgcGVyc2lzdGVudCA/ICIgW1BFUlNJU1RFTlRdIiA6ICIiLCBleHRyYSk7CisJd3BhX3ByaW50ZihNU0dfSU5GTywgUDJQX0VWRU5UX0dST1VQX1NUQVJURUQKKwkJICAgIiVzICVzIHNzaWQ9XCIlc1wiIGZyZXE9JWQgZ29fZGV2X2FkZHI9IiBNQUNTVFIgIiVzJXMiLAorCQkgICB3cGFfcy0+aWZuYW1lLCBnbyA/ICJHTyIgOiAiY2xpZW50Iiwgc3NpZF90eHQsIGZyZXEsCisJCSAgIE1BQzJTVFIoZ29fZGV2X2FkZHIpLCBwZXJzaXN0ZW50ID8gIiBbUEVSU0lTVEVOVF0iIDogIiIsCisJCSAgIGV4dHJhKTsKIH0KIAogCkBAIC03MTUsNyArODUyLDYgQEAKIAkJCQkJICAgaW50IHN1Y2Nlc3MpCiB7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwotCWNvbnN0IGNoYXIgKnNzaWRfdHh0OwogCWludCBjbGllbnQ7CiAJaW50IHBlcnNpc3RlbnQ7CiAJdTggZ29fZGV2X2FkZHJbRVRIX0FMRU5dOwpAQCAtNzI4LDggKzg2NCwxMSBAQAogCSAqLwogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZ3JvdXBfZm9ybWF0aW9uKQogCQl3cGFfcyA9IHdwYV9zLT5nbG9iYWwtPnAycF9ncm91cF9mb3JtYXRpb247Ci0Jd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiA9IE5VTEw7Ci0Jd3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcgPSAwOworCWlmICh3cGFfcy0+cDJwX2dvX2dyb3VwX2Zvcm1hdGlvbl9jb21wbGV0ZWQpIHsKKwkJd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiA9IE5VTEw7CisJCXdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nID0gMDsKKwl9CisJd3BhX3MtPnAycF9pbl9pbnZpdGF0aW9uID0gMDsKIAogCWlmICghc3VjY2VzcykgewogCQl3cGFfbXNnX2dsb2JhbCh3cGFfcy0+cGFyZW50LCBNU0dfSU5GTywKQEAgLTc1MSw3ICs4OTAsNiBAQAogCiAJcGVyc2lzdGVudCA9IDA7CiAJaWYgKHNzaWQpIHsKLQkJc3NpZF90eHQgPSB3cGFfc3NpZF90eHQoc3NpZC0+c3NpZCwgc3NpZC0+c3NpZF9sZW4pOwogCQljbGllbnQgPSBzc2lkLT5tb2RlID09IFdQQVNfTU9ERV9JTkZSQTsKIAkJaWYgKHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX1AyUF9HTykgewogCQkJcGVyc2lzdGVudCA9IHNzaWQtPnAycF9wZXJzaXN0ZW50X2dyb3VwOwpAQCAtNzYzLDcgKzkwMSw2IEBACiAJCQkJCQkJICAgICAgIHNzaWQtPnNzaWQsCiAJCQkJCQkJICAgICAgIHNzaWQtPnNzaWRfbGVuKTsKIAl9IGVsc2UgewotCQlzc2lkX3R4dCA9ICIiOwogCQljbGllbnQgPSB3cGFfcy0+cDJwX2dyb3VwX2ludGVyZmFjZSA9PQogCQkJUDJQX0dST1VQX0lOVEVSRkFDRV9DTElFTlQ7CiAJCW9zX21lbXNldChnb19kZXZfYWRkciwgMCwgRVRIX0FMRU4pOwpAQCAtNzc3LDMzICs5MTQsMTMgQEAKIAkJICogcGFja2V0cy4KIAkJICovCiAJCXdwYV9zLT5zaG93X2dyb3VwX3N0YXJ0ZWQgPSAxOwotI2lmZGVmIEFORFJPSURfUDJQCi0JCS8qIEZvciBjbGllbnQgU2Vjb25kIHBoYXNlIG9mIEdyb3VwIGZvcm1hdGlvbiAoNC13YXkgaGFuZHNoYWtlKSBjYW4gYmUgc3RpbGwgcGVuZGluZwotCQkgKiBTbyB3ZSBuZWVkIHRvIHJlc3RvcmUgd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiAqLwotCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiUmVzdG9yaW5nIGJhY2sgd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiB0byB3cGFfcyAlcFxuIiwgd3BhX3MpOwotCQl3cGFfcy0+Z2xvYmFsLT5wMnBfZ3JvdXBfZm9ybWF0aW9uID0gd3BhX3M7Ci0jZW5kaWYKLQotCX0gZWxzZSBpZiAoc3NpZCAmJiBzc2lkLT5wYXNzcGhyYXNlID09IE5VTEwgJiYgc3NpZC0+cHNrX3NldCkgewotCQljaGFyIHBza1s2NV07Ci0JCXdwYV9zbnByaW50Zl9oZXgocHNrLCBzaXplb2YocHNrKSwgc3NpZC0+cHNrLCAzMik7Ci0JCXdwYV9tc2dfZ2xvYmFsKHdwYV9zLT5wYXJlbnQsIE1TR19JTkZPLCBQMlBfRVZFTlRfR1JPVVBfU1RBUlRFRAotCQkJICAgICAgICIlcyBHTyBzc2lkPVwiJXNcIiBmcmVxPSVkIHBzaz0lcyBnb19kZXZfYWRkcj0iCi0JCQkgICAgICAgTUFDU1RSICIlcyIsCi0JCQkgICAgICAgd3BhX3MtPmlmbmFtZSwgc3NpZF90eHQsIHNzaWQtPmZyZXF1ZW5jeSwgcHNrLAotCQkJICAgICAgIE1BQzJTVFIoZ29fZGV2X2FkZHIpLAotCQkJICAgICAgIHBlcnNpc3RlbnQgPyAiIFtQRVJTSVNURU5UXSIgOiAiIik7Ci0JCXdwYXNfcDJwX2Nyb3NzX2Nvbm5lY3Rfc2V0dXAod3BhX3MpOwotCQl3cGFzX3AycF9zZXRfZ3JvdXBfaWRsZV90aW1lb3V0KHdwYV9zKTsKIAl9IGVsc2UgewotCQl3cGFfbXNnX2dsb2JhbCh3cGFfcy0+cGFyZW50LCBNU0dfSU5GTywgUDJQX0VWRU5UX0dST1VQX1NUQVJURUQKLQkJCSAgICAgICAiJXMgR08gc3NpZD1cIiVzXCIgZnJlcT0lZCBwYXNzcGhyYXNlPVwiJXNcIiAiCi0JCQkgICAgICAgImdvX2Rldl9hZGRyPSIgTUFDU1RSICIlcyIsCi0JCQkgICAgICAgd3BhX3MtPmlmbmFtZSwgc3NpZF90eHQsCi0JCQkgICAgICAgc3NpZCA/IHNzaWQtPmZyZXF1ZW5jeSA6IDAsCi0JCQkgICAgICAgc3NpZCAmJiBzc2lkLT5wYXNzcGhyYXNlID8gc3NpZC0+cGFzc3BocmFzZSA6ICIiLAotCQkJICAgICAgIE1BQzJTVFIoZ29fZGV2X2FkZHIpLAotCQkJICAgICAgIHBlcnNpc3RlbnQgPyAiIFtQRVJTSVNURU5UXSIgOiAiIik7CisJCXdwYXNfcDJwX2dyb3VwX3N0YXJ0ZWQod3BhX3MsIDEsIHNzaWQsCisJCQkJICAgICAgIHNzaWQgPyBzc2lkLT5mcmVxdWVuY3kgOiAwLAorCQkJCSAgICAgICBzc2lkICYmIHNzaWQtPnBhc3NwaHJhc2UgPT0gTlVMTCAmJgorCQkJCSAgICAgICBzc2lkLT5wc2tfc2V0ID8gc3NpZC0+cHNrIDogTlVMTCwKKwkJCQkgICAgICAgc3NpZCA/IHNzaWQtPnBhc3NwaHJhc2UgOiBOVUxMLAorCQkJCSAgICAgICBnb19kZXZfYWRkciwgcGVyc2lzdGVudCwgIiIpOwogCQl3cGFzX3AycF9jcm9zc19jb25uZWN0X3NldHVwKHdwYV9zKTsKIAkJd3Bhc19wMnBfc2V0X2dyb3VwX2lkbGVfdGltZW91dCh3cGFfcyk7CiAJfQpAQCAtODE5LDcgKzkzNiw2MCBAQAogCQluZXR3b3JrX2lkID0gc3NpZC0+aWQ7CiAJaWYgKCFjbGllbnQpIHsKIAkJd3Bhc19ub3RpZnlfcDJwX2dyb3VwX3N0YXJ0ZWQod3BhX3MsIHNzaWQsIG5ldHdvcmtfaWQsIDApOwotCQlvc19nZXRfdGltZSgmd3BhX3MtPmdsb2JhbC0+cDJwX2dvX3dhaXRfY2xpZW50KTsKKwkJb3NfZ2V0X3JlbHRpbWUoJndwYV9zLT5nbG9iYWwtPnAycF9nb193YWl0X2NsaWVudCk7CisJfQorfQorCisKK3N0cnVjdCBzZW5kX2FjdGlvbl93b3JrIHsKKwl1bnNpZ25lZCBpbnQgZnJlcTsKKwl1OCBkc3RbRVRIX0FMRU5dOworCXU4IHNyY1tFVEhfQUxFTl07CisJdTggYnNzaWRbRVRIX0FMRU5dOworCXNpemVfdCBsZW47CisJdW5zaWduZWQgaW50IHdhaXRfdGltZTsKKwl1OCBidWZbMF07Cit9OworCisKK3N0YXRpYyB2b2lkIHdwYXNfcDJwX3NlbmRfYWN0aW9uX3dvcmtfdGltZW91dCh2b2lkICplbG9vcF9jdHgsCisJCQkJCSAgICAgIHZvaWQgKnRpbWVvdXRfY3R4KQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBlbG9vcF9jdHg7CisKKwlpZiAoIXdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yaykKKwkJcmV0dXJuOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNlbmQgQWN0aW9uIGZyYW1lIHJhZGlvIHdvcmsgdGltZWQgb3V0Iik7CisJb3NfZnJlZSh3cGFfcy0+cDJwX3NlbmRfYWN0aW9uX3dvcmstPmN0eCk7CisJcmFkaW9fd29ya19kb25lKHdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yayk7CisJd3BhX3MtPnAycF9zZW5kX2FjdGlvbl93b3JrID0gTlVMTDsKK30KKworCitzdGF0aWMgdm9pZCB3cGFzX3AycF9hY3Rpb25fdHhfY2xlYXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAod3BhX3MtPnAycF9zZW5kX2FjdGlvbl93b3JrKSB7CisJCXN0cnVjdCBzZW5kX2FjdGlvbl93b3JrICphd29yazsKKwkJYXdvcmsgPSB3cGFfcy0+cDJwX3NlbmRfYWN0aW9uX3dvcmstPmN0eDsKKwkJaWYgKGF3b3JrLT53YWl0X3RpbWUgPT0gMCkgeworCQkJb3NfZnJlZShhd29yayk7CisJCQlyYWRpb193b3JrX2RvbmUod3BhX3MtPnAycF9zZW5kX2FjdGlvbl93b3JrKTsKKwkJCXdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yayA9IE5VTEw7CisJCX0gZWxzZSB7CisJCQkvKgorCQkJICogSW4gdGhlb3J5LCB0aGlzIHNob3VsZCBub3QgYmUgbmVlZGVkLCBidXQgbnVtYmVyIG9mCisJCQkgKiBwbGFjZXMgaW4gdGhlIFAyUCBjb2RlIGlzIHN0aWxsIHVzaW5nIG5vbi16ZXJvIHdhaXQKKwkJCSAqIHRpbWUgZm9yIHRoZSBsYXN0IEFjdGlvbiBmcmFtZSBpbiB0aGUgc2VxdWVuY2UgYW5kCisJCQkgKiBzb21lIG9mIHRoZXNlIGRvIG5vdCBjYWxsIHNlbmRfYWN0aW9uX2RvbmUoKS4KKwkJCSAqLworCQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfc2VuZF9hY3Rpb25fd29ya190aW1lb3V0LAorCQkJCQkgICAgIHdwYV9zLCBOVUxMKTsKKwkJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoCisJCQkJMCwgYXdvcmstPndhaXRfdGltZSAqIDEwMDAsCisJCQkJd3Bhc19wMnBfc2VuZF9hY3Rpb25fd29ya190aW1lb3V0LAorCQkJCXdwYV9zLCBOVUxMKTsKKwkJfQogCX0KIH0KIApAQCAtODM0LDEwICsxMDA0LDEwIEBACiB7CiAJZW51bSBwMnBfc2VuZF9hY3Rpb25fcmVzdWx0IHJlcyA9IFAyUF9TRU5EX0FDVElPTl9TVUNDRVNTOwogCisJd3Bhc19wMnBfYWN0aW9uX3R4X2NsZWFyKHdwYV9zKTsKKwogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQpCiAJCXJldHVybjsKLQlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQpCi0JCXJldHVybjsKIAogCXN3aXRjaCAocmVzdWx0KSB7CiAJY2FzZSBPRkZDSEFOTkVMX1NFTkRfQUNUSU9OX1NVQ0NFU1M6CkBAIC04NjcsMTEgKzEwMzcsODcgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFzX3NlbmRfYWN0aW9uX2NiKHN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yaywgaW50IGRlaW5pdCkKK3sKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gd29yay0+d3BhX3M7CisJc3RydWN0IHNlbmRfYWN0aW9uX3dvcmsgKmF3b3JrID0gd29yay0+Y3R4OworCisJaWYgKGRlaW5pdCkgeworCQlpZiAod29yay0+c3RhcnRlZCkgeworCQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfc2VuZF9hY3Rpb25fd29ya190aW1lb3V0LAorCQkJCQkgICAgIHdwYV9zLCBOVUxMKTsKKwkJCXdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yayA9IE5VTEw7CisJCQlvZmZjaGFubmVsX3NlbmRfYWN0aW9uX2RvbmUod3BhX3MpOworCQl9CisJCW9zX2ZyZWUoYXdvcmspOworCQlyZXR1cm47CisJfQorCisJaWYgKG9mZmNoYW5uZWxfc2VuZF9hY3Rpb24od3BhX3MsIGF3b3JrLT5mcmVxLCBhd29yay0+ZHN0LCBhd29yay0+c3JjLAorCQkJCSAgIGF3b3JrLT5ic3NpZCwgYXdvcmstPmJ1ZiwgYXdvcmstPmxlbiwKKwkJCQkgICBhd29yay0+d2FpdF90aW1lLAorCQkJCSAgIHdwYXNfcDJwX3NlbmRfYWN0aW9uX3R4X3N0YXR1cywgMSkgPCAwKSB7CisJCW9zX2ZyZWUoYXdvcmspOworCQlyYWRpb193b3JrX2RvbmUod29yayk7CisJCXJldHVybjsKKwl9CisJd3BhX3MtPnAycF9zZW5kX2FjdGlvbl93b3JrID0gd29yazsKK30KKworCitzdGF0aWMgaW50IHdwYXNfc2VuZF9hY3Rpb25fd29yayhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSB1bnNpZ25lZCBpbnQgZnJlcSwgY29uc3QgdTggKmRzdCwKKwkJCQkgY29uc3QgdTggKnNyYywgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqYnVmLAorCQkJCSBzaXplX3QgbGVuLCB1bnNpZ25lZCBpbnQgd2FpdF90aW1lKQoreworCXN0cnVjdCBzZW5kX2FjdGlvbl93b3JrICphd29yazsKKworCWlmICh3cGFfcy0+cDJwX3NlbmRfYWN0aW9uX3dvcmspIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENhbm5vdCBzY2hlZHVsZSBuZXcgcDJwLXNlbmQtYWN0aW9uIHdvcmsgc2luY2Ugb25lIGlzIGFscmVhZHkgcGVuZGluZyIpOworCQlyZXR1cm4gLTE7CisJfQorCisJYXdvcmsgPSBvc196YWxsb2Moc2l6ZW9mKCphd29yaykgKyBsZW4pOworCWlmIChhd29yayA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlhd29yay0+ZnJlcSA9IGZyZXE7CisJb3NfbWVtY3B5KGF3b3JrLT5kc3QsIGRzdCwgRVRIX0FMRU4pOworCW9zX21lbWNweShhd29yay0+c3JjLCBzcmMsIEVUSF9BTEVOKTsKKwlvc19tZW1jcHkoYXdvcmstPmJzc2lkLCBic3NpZCwgRVRIX0FMRU4pOworCWF3b3JrLT5sZW4gPSBsZW47CisJYXdvcmstPndhaXRfdGltZSA9IHdhaXRfdGltZTsKKwlvc19tZW1jcHkoYXdvcmstPmJ1ZiwgYnVmLCBsZW4pOworCisJaWYgKHJhZGlvX2FkZF93b3JrKHdwYV9zLCBmcmVxLCAicDJwLXNlbmQtYWN0aW9uIiwgMCwKKwkJCSAgIHdwYXNfc2VuZF9hY3Rpb25fY2IsIGF3b3JrKSA8IDApIHsKKwkJb3NfZnJlZShhd29yayk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCiBzdGF0aWMgaW50IHdwYXNfc2VuZF9hY3Rpb24odm9pZCAqY3R4LCB1bnNpZ25lZCBpbnQgZnJlcSwgY29uc3QgdTggKmRzdCwKIAkJCSAgICBjb25zdCB1OCAqc3JjLCBjb25zdCB1OCAqYnNzaWQsIGNvbnN0IHU4ICpidWYsCiAJCQkgICAgc2l6ZV90IGxlbiwgdW5zaWduZWQgaW50IHdhaXRfdGltZSkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OworCWludCBsaXN0ZW5fZnJlcSA9IC0xLCBzZW5kX2ZyZXEgPSAtMTsKKworCWlmICh3cGFfcy0+cDJwX2xpc3Rlbl93b3JrKQorCQlsaXN0ZW5fZnJlcSA9IHdwYV9zLT5wMnBfbGlzdGVuX3dvcmstPmZyZXE7CisJaWYgKHdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yaykKKwkJc2VuZF9mcmVxID0gd3BhX3MtPnAycF9zZW5kX2FjdGlvbl93b3JrLT5mcmVxOworCWlmIChsaXN0ZW5fZnJlcSAhPSAoaW50KSBmcmVxICYmIHNlbmRfZnJlcSAhPSAoaW50KSBmcmVxKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBTY2hlZHVsZSBuZXcgcmFkaW8gd29yayBmb3IgQWN0aW9uIGZyYW1lIFRYIChsaXN0ZW5fZnJlcT0lZCBzZW5kX2ZyZXE9JWQpIiwKKwkJCSAgIGxpc3Rlbl9mcmVxLCBzZW5kX2ZyZXEpOworCQlyZXR1cm4gd3Bhc19zZW5kX2FjdGlvbl93b3JrKHdwYV9zLCBmcmVxLCBkc3QsIHNyYywgYnNzaWQsIGJ1ZiwKKwkJCQkJICAgICBsZW4sIHdhaXRfdGltZSk7CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFVzZSBvbmdvaW5nIHJhZGlvIHdvcmsgZm9yIEFjdGlvbiBmcmFtZSBUWCIpOwogCXJldHVybiBvZmZjaGFubmVsX3NlbmRfYWN0aW9uKHdwYV9zLCBmcmVxLCBkc3QsIHNyYywgYnNzaWQsIGJ1ZiwgbGVuLAogCQkJCSAgICAgIHdhaXRfdGltZSwKIAkJCQkgICAgICB3cGFzX3AycF9zZW5kX2FjdGlvbl90eF9zdGF0dXMsIDEpOwpAQCAtODgxLDYgKzExMjcsMTUgQEAKIHN0YXRpYyB2b2lkIHdwYXNfc2VuZF9hY3Rpb25fZG9uZSh2b2lkICpjdHgpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKKworCWlmICh3cGFfcy0+cDJwX3NlbmRfYWN0aW9uX3dvcmspIHsKKwkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfc2VuZF9hY3Rpb25fd29ya190aW1lb3V0LAorCQkJCSAgICAgd3BhX3MsIE5VTEwpOworCQlvc19mcmVlKHdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yay0+Y3R4KTsKKwkJcmFkaW9fd29ya19kb25lKHdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yayk7CisJCXdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yayA9IE5VTEw7CisJfQorCiAJb2ZmY2hhbm5lbF9zZW5kX2FjdGlvbl9kb25lKHdwYV9zKTsKIH0KIApAQCAtOTAxLDE1ICsxMTU2LDI5IEBACiBzdGF0aWMgdm9pZCB3cGFzX3N0YXJ0X3dwc19lbnJvbGxlZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgICBzdHJ1Y3QgcDJwX2dvX25lZ19yZXN1bHRzICpyZXMpCiB7Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFN0YXJ0IFdQUyBFbnJvbGxlZSBmb3IgcGVlciAiIE1BQ1NUUiwKLQkJICAgTUFDMlNUUihyZXMtPnBlZXJfaW50ZXJmYWNlX2FkZHIpKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogU3RhcnQgV1BTIEVucm9sbGVlIGZvciBwZWVyICIgTUFDU1RSCisJCSAgICIgZGV2X2FkZHIgIiBNQUNTVFIgIiB3cHNfbWV0aG9kICVkIiwKKwkJICAgTUFDMlNUUihyZXMtPnBlZXJfaW50ZXJmYWNlX2FkZHIpLAorCQkgICBNQUMyU1RSKHJlcy0+cGVlcl9kZXZpY2VfYWRkciksIHJlcy0+d3BzX21ldGhvZCk7CiAJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiUDJQOiBTdGFydCBXUFMgRW5yb2xsZWUgZm9yIFNTSUQiLAogCQkJICByZXMtPnNzaWQsIHJlcy0+c3NpZF9sZW4pOwogCXdwYV9zdXBwbGljYW50X2FwX2RlaW5pdCh3cGFfcyk7CiAJd3Bhc19jb3B5X2dvX25lZ19yZXN1bHRzKHdwYV9zLCByZXMpOwotCWlmIChyZXMtPndwc19tZXRob2QgPT0gV1BTX1BCQykKKwlpZiAocmVzLT53cHNfbWV0aG9kID09IFdQU19QQkMpIHsKIAkJd3Bhc193cHNfc3RhcnRfcGJjKHdwYV9zLCByZXMtPnBlZXJfaW50ZXJmYWNlX2FkZHIsIDEpOwotCWVsc2UgeworI2lmZGVmIENPTkZJR19XUFNfTkZDCisJfSBlbHNlIGlmIChyZXMtPndwc19tZXRob2QgPT0gV1BTX05GQykgeworCQl3cGFzX3dwc19zdGFydF9uZmMod3BhX3MsIHJlcy0+cGVlcl9kZXZpY2VfYWRkciwKKwkJCQkgICByZXMtPnBlZXJfaW50ZXJmYWNlX2FkZHIsCisJCQkJICAgd3BhX3MtPnBhcmVudC0+cDJwX29vYl9kZXZfcHcsCisJCQkJICAgd3BhX3MtPnBhcmVudC0+cDJwX29vYl9kZXZfcHdfaWQsIDEsCisJCQkJICAgd3BhX3MtPnBhcmVudC0+cDJwX29vYl9kZXZfcHdfaWQgPT0KKwkJCQkgICBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIgPworCQkJCSAgIHdwYV9zLT5wYXJlbnQtPnAycF9wZWVyX29vYl9wdWJrZXlfaGFzaCA6CisJCQkJICAgTlVMTCwKKwkJCQkgICBOVUxMLCAwLCAwKTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCX0gZWxzZSB7CiAJCXUxNiBkZXZfcHdfaWQgPSBERVZfUFdfREVGQVVMVDsKIAkJaWYgKHdwYV9zLT5wMnBfd3BzX21ldGhvZCA9PSBXUFNfUElOX0tFWVBBRCkKIAkJCWRldl9wd19pZCA9IERFVl9QV19SRUdJU1RSQVJfU1BFQ0lGSUVEOwpAQCAtOTY5LDMzICsxMjM4LDE0IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBHcm91cCBzZXR1cCB3aXRob3V0IHByb3Zpc2lvbmluZyIpOwogCQlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiA9PSB3cGFfcykKIAkJCXdwYV9zLT5nbG9iYWwtPnAycF9ncm91cF9mb3JtYXRpb24gPSBOVUxMOwotCQlpZiAob3Nfc3RybGVuKHBhcmFtcy0+cGFzc3BocmFzZSkgPiAwKSB7Ci0JCQl3cGFfbXNnX2dsb2JhbCh3cGFfcy0+cGFyZW50LCBNU0dfSU5GTywKLQkJCQkgICAgICAgUDJQX0VWRU5UX0dST1VQX1NUQVJURUQKLQkJCQkgICAgICAgIiVzIEdPIHNzaWQ9XCIlc1wiIGZyZXE9JWQgIgotCQkJCSAgICAgICAicGFzc3BocmFzZT1cIiVzXCIgZ29fZGV2X2FkZHI9IiBNQUNTVFIKLQkJCQkgICAgICAgIiVzIiwgd3BhX3MtPmlmbmFtZSwKLQkJCQkgICAgICAgd3BhX3NzaWRfdHh0KHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKSwKLQkJCQkgICAgICAgc3NpZC0+ZnJlcXVlbmN5LCBwYXJhbXMtPnBhc3NwaHJhc2UsCi0JCQkJICAgICAgIE1BQzJTVFIod3BhX3MtPmdsb2JhbC0+cDJwX2Rldl9hZGRyKSwKLQkJCQkgICAgICAgcGFyYW1zLT5wZXJzaXN0ZW50X2dyb3VwID8KLQkJCQkgICAgICAgIiBbUEVSU0lTVEVOVF0iIDogIiIpOwotCQl9IGVsc2UgewotCQkJY2hhciBwc2tbNjVdOwotCQkJd3BhX3NucHJpbnRmX2hleChwc2ssIHNpemVvZihwc2spLCBwYXJhbXMtPnBzaywKLQkJCQkJIHNpemVvZihwYXJhbXMtPnBzaykpOwotCQkJd3BhX21zZ19nbG9iYWwod3BhX3MtPnBhcmVudCwgTVNHX0lORk8sCi0JCQkJICAgICAgIFAyUF9FVkVOVF9HUk9VUF9TVEFSVEVECi0JCQkJICAgICAgICIlcyBHTyBzc2lkPVwiJXNcIiBmcmVxPSVkIHBzaz0lcyAiCi0JCQkJICAgICAgICJnb19kZXZfYWRkcj0iIE1BQ1NUUiAiJXMiLAotCQkJCSAgICAgICB3cGFfcy0+aWZuYW1lLAotCQkJCSAgICAgICB3cGFfc3NpZF90eHQoc3NpZC0+c3NpZCwgc3NpZC0+c3NpZF9sZW4pLAotCQkJCSAgICAgICBzc2lkLT5mcmVxdWVuY3ksIHBzaywKLQkJCQkgICAgICAgTUFDMlNUUih3cGFfcy0+Z2xvYmFsLT5wMnBfZGV2X2FkZHIpLAotCQkJCSAgICAgICBwYXJhbXMtPnBlcnNpc3RlbnRfZ3JvdXAgPwotCQkJCSAgICAgICAiIFtQRVJTSVNURU5UXSIgOiAiIik7Ci0JCX0KKwkJd3Bhc19wMnBfZ3JvdXBfc3RhcnRlZCh3cGFfcywgMSwgc3NpZCwgc3NpZC0+ZnJlcXVlbmN5LAorCQkJCSAgICAgICBwYXJhbXMtPnBhc3NwaHJhc2VbMF0gPT0gJ1wwJyA/CisJCQkJICAgICAgIHBhcmFtcy0+cHNrIDogTlVMTCwKKwkJCQkgICAgICAgcGFyYW1zLT5wYXNzcGhyYXNlLAorCQkJCSAgICAgICB3cGFfcy0+Z2xvYmFsLT5wMnBfZGV2X2FkZHIsCisJCQkJICAgICAgIHBhcmFtcy0+cGVyc2lzdGVudF9ncm91cCwgIiIpOwogCisJCW9zX2dldF9yZWx0aW1lKCZ3cGFfcy0+Z2xvYmFsLT5wMnBfZ29fd2FpdF9jbGllbnQpOwogCQlpZiAocGFyYW1zLT5wZXJzaXN0ZW50X2dyb3VwKSB7CiAJCQluZXR3b3JrX2lkID0gd3Bhc19wMnBfc3RvcmVfcGVyc2lzdGVudF9ncm91cCgKIAkJCQl3cGFfcy0+cGFyZW50LCBzc2lkLApAQCAtMTAwNyw2ICsxMjU3LDIxIEBACiAJCXdwYXNfbm90aWZ5X3AycF9ncm91cF9zdGFydGVkKHdwYV9zLCBzc2lkLCBuZXR3b3JrX2lkLCAwKTsKIAkJd3Bhc19wMnBfY3Jvc3NfY29ubmVjdF9zZXR1cCh3cGFfcyk7CiAJCXdwYXNfcDJwX3NldF9ncm91cF9pZGxlX3RpbWVvdXQod3BhX3MpOworCisJCWlmICh3cGFfcy0+cDJwX2ZpcnN0X2Nvbm5lY3Rpb25fdGltZW91dCkgeworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAorCQkJCSJQMlA6IFN0YXJ0IGdyb3VwIGZvcm1hdGlvbiB0aW1lb3V0IG9mICVkIHNlY29uZHMgdW50aWwgZmlyc3QgZGF0YSBjb25uZWN0aW9uIG9uIEdPIiwKKwkJCQl3cGFfcy0+cDJwX2ZpcnN0X2Nvbm5lY3Rpb25fdGltZW91dCk7CisJCQl3cGFfcy0+cDJwX2dvX2dyb3VwX2Zvcm1hdGlvbl9jb21wbGV0ZWQgPSAwOworCQkJd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiA9IHdwYV9zOworCQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsCisJCQkJCSAgICAgd3BhX3MtPnBhcmVudCwgTlVMTCk7CisJCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KAorCQkJCXdwYV9zLT5wMnBfZmlyc3RfY29ubmVjdGlvbl90aW1lb3V0LCAwLAorCQkJCXdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LAorCQkJCXdwYV9zLT5wYXJlbnQsIE5VTEwpOworCQl9CisKIAkJcmV0dXJuOwogCX0KIApAQCAtMTAxNywxMCArMTI4MiwyNCBAQAogCQkJICAgImZpbHRlcmluZyIpOwogCQlyZXR1cm47CiAJfQotCWlmIChwYXJhbXMtPndwc19tZXRob2QgPT0gV1BTX1BCQykKKwlpZiAocGFyYW1zLT53cHNfbWV0aG9kID09IFdQU19QQkMpIHsKIAkJd3BhX3N1cHBsaWNhbnRfYXBfd3BzX3BiYyh3cGFfcywgcGFyYW1zLT5wZWVyX2ludGVyZmFjZV9hZGRyLAogCQkJCQkgIHBhcmFtcy0+cGVlcl9kZXZpY2VfYWRkcik7Ci0JZWxzZSBpZiAod3BhX3MtPnAycF9waW5bMF0pCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwl9IGVsc2UgaWYgKHBhcmFtcy0+d3BzX21ldGhvZCA9PSBXUFNfTkZDKSB7CisJCWlmICh3cGFfcy0+cGFyZW50LT5wMnBfb29iX2Rldl9wd19pZCAhPQorCQkgICAgREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSICYmCisJCSAgICAhd3BhX3MtPnBhcmVudC0+cDJwX29vYl9kZXZfcHcpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBObyBORkMgRGV2IFB3IGtub3duIik7CisJCQlyZXR1cm47CisJCX0KKwkJd3Bhc19hcF93cHNfYWRkX25mY19wdygKKwkJCXdwYV9zLCB3cGFfcy0+cGFyZW50LT5wMnBfb29iX2Rldl9wd19pZCwKKwkJCXdwYV9zLT5wYXJlbnQtPnAycF9vb2JfZGV2X3B3LAorCQkJd3BhX3MtPnBhcmVudC0+cDJwX3BlZXJfb29iX3BrX2hhc2hfa25vd24gPworCQkJd3BhX3MtPnBhcmVudC0+cDJwX3BlZXJfb29iX3B1YmtleV9oYXNoIDogTlVMTCk7CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKwl9IGVsc2UgaWYgKHdwYV9zLT5wMnBfcGluWzBdKQogCQl3cGFfc3VwcGxpY2FudF9hcF93cHNfcGluKHdwYV9zLCBwYXJhbXMtPnBlZXJfaW50ZXJmYWNlX2FkZHIsCiAJCQkJCSAgd3BhX3MtPnAycF9waW4sIE5VTEwsIDAsIDApOwogCW9zX2ZyZWUod3BhX3MtPmdvX3BhcmFtcyk7CkBAIC0xMDU3LDYgKzEzMzYsNyBAQAogCQlXUEFTX01PREVfUDJQX0dPOwogCXNzaWQtPmZyZXF1ZW5jeSA9IHBhcmFtcy0+ZnJlcTsKIAlzc2lkLT5odDQwID0gcGFyYW1zLT5odDQwOworCXNzaWQtPnZodCA9IHBhcmFtcy0+dmh0OwogCXNzaWQtPnNzaWQgPSBvc196YWxsb2MocGFyYW1zLT5zc2lkX2xlbiArIDEpOwogCWlmIChzc2lkLT5zc2lkKSB7CiAJCW9zX21lbWNweShzc2lkLT5zc2lkLCBwYXJhbXMtPnNzaWQsIHBhcmFtcy0+c3NpZF9sZW4pOwpAQCAtMTA4Niw2ICsxMzY2LDcgQEAKIAl3cGFfcy0+YXBfY29uZmlndXJlZF9jYiA9IHAycF9nb19jb25maWd1cmVkOwogCXdwYV9zLT5hcF9jb25maWd1cmVkX2NiX2N0eCA9IHdwYV9zOwogCXdwYV9zLT5hcF9jb25maWd1cmVkX2NiX2RhdGEgPSB3cGFfcy0+Z29fcGFyYW1zOworCXdwYV9zLT5zY2FuX3JlcSA9IE5PUk1BTF9TQ0FOX1JFUTsKIAl3cGFfcy0+Y29ubmVjdF93aXRob3V0X3NjYW4gPSBzc2lkOwogCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7CiAJd3BhX3MtPmRpc2Nvbm5lY3RlZCA9IDA7CkBAIC0xMTI1LDcgKzE0MDYsMTQgQEAKIAlkLT5wYmNfaW5fbTEgPSBzLT5wYmNfaW5fbTE7CiAJZC0+aWdub3JlX29sZF9zY2FuX3JlcyA9IHMtPmlnbm9yZV9vbGRfc2Nhbl9yZXM7CiAJZC0+YmVhY29uX2ludCA9IHMtPmJlYWNvbl9pbnQ7CisJZC0+ZHRpbV9wZXJpb2QgPSBzLT5kdGltX3BlcmlvZDsKIAlkLT5kaXNhc3NvY19sb3dfYWNrID0gcy0+ZGlzYXNzb2NfbG93X2FjazsKKwlkLT5kaXNhYmxlX3NjYW5fb2ZmbG9hZCA9IHMtPmRpc2FibGVfc2Nhbl9vZmZsb2FkOworCisJaWYgKHMtPndwc19uZmNfZGhfcHJpdmtleSAmJiBzLT53cHNfbmZjX2RoX3B1YmtleSkgeworCQlkLT53cHNfbmZjX2RoX3ByaXZrZXkgPSB3cGFidWZfZHVwKHMtPndwc19uZmNfZGhfcHJpdmtleSk7CisJCWQtPndwc19uZmNfZGhfcHVia2V5ID0gd3BhYnVmX2R1cChzLT53cHNfbmZjX2RoX3B1YmtleSk7CisJfQogfQogCiAKQEAgLTExNDMsOCArMTQzMSw3IEBACiAJaWYgKG9zX3N0cmxlbihpZm5hbWUpID49IElGTkFNU0laICYmCiAJICAgIG9zX3N0cmxlbih3cGFfcy0+aWZuYW1lKSA8IElGTkFNU0laKSB7CiAJCS8qIFRyeSB0byBhdm9pZCBnb2luZyBvdmVyIHRoZSBJRk5BTVNJWiBsZW5ndGggbGltaXQgKi8KLQkJb3Nfc25wcmludGYoaWZuYW1lLCBzaXplb2YoaWZuYW1lKSwgInAycC0lZCIsCi0JCQkgICAgd3BhX3MtPnAycF9ncm91cF9pZHgpOworCQlvc19zbnByaW50ZihpZm5hbWUsIGxlbiwgInAycC0lZCIsIHdwYV9zLT5wMnBfZ3JvdXBfaWR4KTsKIAl9CiB9CiAKQEAgLTEyNzcsMTIgKzE1NjQsMjEgQEAKIAkJCSAgICAgd3BhX3MtPnBhcmVudCwgTlVMTCk7CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCkKIAkJcDJwX2dyb3VwX2Zvcm1hdGlvbl9mYWlsZWQod3BhX3MtPmdsb2JhbC0+cDJwKTsKLQllbHNlIGlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJd3BhX2Rydl9wMnBfZ3JvdXBfZm9ybWF0aW9uX2ZhaWxlZCh3cGFfcyk7CiAJd3Bhc19ncm91cF9mb3JtYXRpb25fY29tcGxldGVkKHdwYV9zLCAwKTsKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFzX3AycF9ncnBmb3JtX2ZhaWxfYWZ0ZXJfd3BzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFJlamVjdCBncm91cCBmb3JtYXRpb24gZHVlIHRvIFdQUyBwcm92aXNpb25pbmcgZmFpbHVyZSIpOworCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LAorCQkJICAgICB3cGFfcy0+cGFyZW50LCBOVUxMKTsKKwllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDAsIHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LAorCQkJICAgICAgIHdwYV9zLT5wYXJlbnQsIE5VTEwpOworCXdwYV9zLT5nbG9iYWwtPnAycF9mYWlsX29uX3dwc19jb21wbGV0ZSA9IDA7Cit9CisKKwogdm9pZCB3cGFzX3AycF9hcF9zZXR1cF9mYWlsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiAhPSB3cGFfcykKQEAgLTEyOTUsNyArMTU5MSw3IEBACiB9CiAKIAotdm9pZCB3cGFzX2dvX25lZ19jb21wbGV0ZWQodm9pZCAqY3R4LCBzdHJ1Y3QgcDJwX2dvX25lZ19yZXN1bHRzICpyZXMpCitzdGF0aWMgdm9pZCB3cGFzX2dvX25lZ19jb21wbGV0ZWQodm9pZCAqY3R4LCBzdHJ1Y3QgcDJwX2dvX25lZ19yZXN1bHRzICpyZXMpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKIApAQCAtMTMxNiw2ICsxNjEyLDggQEAKIAogCWlmICh3cGFfcy0+cDJwX2dvX2h0NDApCiAJCXJlcy0+aHQ0MCA9IDE7CisJaWYgKHdwYV9zLT5wMnBfZ29fdmh0KQorCQlyZXMtPnZodCA9IDE7CiAKIAl3cGFfbXNnX2dsb2JhbCh3cGFfcywgTVNHX0lORk8sIFAyUF9FVkVOVF9HT19ORUdfU1VDQ0VTUyAicm9sZT0lcyAiCiAJCSAgICAgICAiZnJlcT0lZCBodDQwPSVkIHBlZXJfZGV2PSIgTUFDU1RSICIgcGVlcl9pZmFjZT0iIE1BQ1NUUgpAQCAtMTM0NSw2ICsxNjQzLDkgQEAKIAkJCXdwYXNfcDJwX2luaXRfZ3JvdXBfaW50ZXJmYWNlKHdwYV9zLCByZXMtPnJvbGVfZ28pOwogCQlpZiAoZ3JvdXBfd3BhX3MgPT0gTlVMTCkgewogCQkJd3Bhc19wMnBfcmVtb3ZlX3BlbmRpbmdfZ3JvdXBfaW50ZXJmYWNlKHdwYV9zKTsKKwkJCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2xvbmdfbGlzdGVuX3RpbWVvdXQsCisJCQkJCSAgICAgd3BhX3MsIE5VTEwpOworCQkJd3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX2ZhaWxlZCh3cGFfcyk7CiAJCQlyZXR1cm47CiAJCX0KIAkJaWYgKGdyb3VwX3dwYV9zICE9IHdwYV9zKSB7CkBAIC0xMzgwLDcgKzE2ODEsNyBAQAogfQogCiAKLXZvaWQgd3Bhc19nb19uZWdfcmVxX3J4KHZvaWQgKmN0eCwgY29uc3QgdTggKnNyYywgdTE2IGRldl9wYXNzd2RfaWQpCitzdGF0aWMgdm9pZCB3cGFzX2dvX25lZ19yZXFfcngodm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjLCB1MTYgZGV2X3Bhc3N3ZF9pZCkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCXdwYV9tc2dfZ2xvYmFsKHdwYV9zLCBNU0dfSU5GTywgUDJQX0VWRU5UX0dPX05FR19SRVFVRVNUIE1BQ1NUUgpAQCAtMTM5MCwzMyArMTY5MSwzNCBAQAogfQogCiAKLXZvaWQgd3Bhc19kZXZfZm91bmQodm9pZCAqY3R4LCBjb25zdCB1OCAqYWRkciwKLQkJICAgIGNvbnN0IHN0cnVjdCBwMnBfcGVlcl9pbmZvICppbmZvLAotCQkgICAgaW50IG5ld19kZXZpY2UpCitzdGF0aWMgdm9pZCB3cGFzX2Rldl9mb3VuZCh2b2lkICpjdHgsIGNvbnN0IHU4ICphZGRyLAorCQkJICAgY29uc3Qgc3RydWN0IHAycF9wZWVyX2luZm8gKmluZm8sCisJCQkgICBpbnQgbmV3X2RldmljZSkKIHsKICNpZm5kZWYgQ09ORklHX05PX1NURE9VVF9ERUJVRwogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CiAJY2hhciBkZXZ0eXBlW1dQU19ERVZfVFlQRV9CVUZTSVpFXTsKLSNkZWZpbmUgV0ZEX0RFVl9JTkZPX1NJWkUgOQotCWNoYXIgd2ZkX2Rldl9pbmZvX2hleFsyICogV0ZEX0RFVl9JTkZPX1NJWkUgKyAxXTsKLQlvc19tZW1zZXQod2ZkX2Rldl9pbmZvX2hleCwgMCwgc2l6ZW9mKHdmZF9kZXZfaW5mb19oZXgpKTsKKwljaGFyICp3ZmRfZGV2X2luZm9faGV4ID0gTlVMTDsKKwogI2lmZGVmIENPTkZJR19XSUZJX0RJU1BMQVkKLQlpZiAoaW5mby0+d2ZkX3N1YmVsZW1zKSB7Ci0JCXdwYV9zbnByaW50Zl9oZXgod2ZkX2Rldl9pbmZvX2hleCwgc2l6ZW9mKHdmZF9kZXZfaW5mb19oZXgpLAotCQkJCQl3cGFidWZfaGVhZChpbmZvLT53ZmRfc3ViZWxlbXMpLAotCQkJCQlXRkRfREVWX0lORk9fU0laRSk7Ci0JfQorCXdmZF9kZXZfaW5mb19oZXggPSB3aWZpX2Rpc3BsYXlfc3ViZWxlbV9oZXgoaW5mby0+d2ZkX3N1YmVsZW1zLAorCQkJCQkJICAgIFdGRF9TVUJFTEVNX0RFVklDRV9JTkZPKTsKICNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCisKIAl3cGFfbXNnX2dsb2JhbCh3cGFfcywgTVNHX0lORk8sIFAyUF9FVkVOVF9ERVZJQ0VfRk9VTkQgTUFDU1RSCiAJCSAgICAgICAiIHAycF9kZXZfYWRkcj0iIE1BQ1NUUgogCQkgICAgICAgIiBwcmlfZGV2X3R5cGU9JXMgbmFtZT0nJXMnIGNvbmZpZ19tZXRob2RzPTB4JXggIgotCQkgICAgICAgImRldl9jYXBhYj0weCV4IGdyb3VwX2NhcGFiPTB4JXglcyVzIiwKKwkJICAgICAgICJkZXZfY2FwYWI9MHgleCBncm91cF9jYXBhYj0weCV4JXMlcyVzIiwKIAkJICAgICAgIE1BQzJTVFIoYWRkciksIE1BQzJTVFIoaW5mby0+cDJwX2RldmljZV9hZGRyKSwKIAkJICAgICAgIHdwc19kZXZfdHlwZV9iaW4yc3RyKGluZm8tPnByaV9kZXZfdHlwZSwgZGV2dHlwZSwKIAkJCQkJICAgIHNpemVvZihkZXZ0eXBlKSksCiAJCSAgICAgICBpbmZvLT5kZXZpY2VfbmFtZSwgaW5mby0+Y29uZmlnX21ldGhvZHMsCiAJCSAgICAgICBpbmZvLT5kZXZfY2FwYWIsIGluZm8tPmdyb3VwX2NhcGFiLAotCQkgICAgICAgd2ZkX2Rldl9pbmZvX2hleFswXSA/ICIgd2ZkX2Rldl9pbmZvPTB4IiA6ICIiLCB3ZmRfZGV2X2luZm9faGV4KTsKKwkJICAgICAgIHdmZF9kZXZfaW5mb19oZXggPyAiIHdmZF9kZXZfaW5mbz0weCIgOiAiIiwKKwkJICAgICAgIHdmZF9kZXZfaW5mb19oZXggPyB3ZmRfZGV2X2luZm9faGV4IDogIiIsCisJCSAgICAgICBpbmZvLT52ZW5kb3JfZWxlbXMgPyAiIHZlbmRvcl9lbGVtcz0xIiA6ICIiKTsKKworCW9zX2ZyZWUod2ZkX2Rldl9pbmZvX2hleCk7CiAjZW5kaWYgLyogQ09ORklHX05PX1NURE9VVF9ERUJVRyAqLwogCiAJd3Bhc19ub3RpZnlfcDJwX2RldmljZV9mb3VuZChjdHgsIGluZm8tPnAycF9kZXZpY2VfYWRkciwgbmV3X2RldmljZSk7CkBAIC0xNDQxLDMyICsxNzQzLDEwOCBAQAogfQogCiAKK3N0cnVjdCB3cGFzX3AycF9saXN0ZW5fd29yayB7CisJdW5zaWduZWQgaW50IGZyZXE7CisJdW5zaWduZWQgaW50IGR1cmF0aW9uOworCXN0cnVjdCB3cGFidWYgKnByb2JlX3Jlc3BfaWU7Cit9OworCisKK3N0YXRpYyB2b2lkIHdwYXNfcDJwX2xpc3Rlbl93b3JrX2ZyZWUoc3RydWN0IHdwYXNfcDJwX2xpc3Rlbl93b3JrICpsd29yaykKK3sKKwlpZiAobHdvcmsgPT0gTlVMTCkKKwkJcmV0dXJuOworCXdwYWJ1Zl9mcmVlKGx3b3JrLT5wcm9iZV9yZXNwX2llKTsKKwlvc19mcmVlKGx3b3JrKTsKK30KKworCitzdGF0aWMgdm9pZCB3cGFzX3AycF9saXN0ZW5fd29ya19kb25lKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJc3RydWN0IHdwYXNfcDJwX2xpc3Rlbl93b3JrICpsd29yazsKKworCWlmICghd3BhX3MtPnAycF9saXN0ZW5fd29yaykKKwkJcmV0dXJuOworCisJbHdvcmsgPSB3cGFfcy0+cDJwX2xpc3Rlbl93b3JrLT5jdHg7CisJd3Bhc19wMnBfbGlzdGVuX3dvcmtfZnJlZShsd29yayk7CisJcmFkaW9fd29ya19kb25lKHdwYV9zLT5wMnBfbGlzdGVuX3dvcmspOworCXdwYV9zLT5wMnBfbGlzdGVuX3dvcmsgPSBOVUxMOworfQorCisKK3N0YXRpYyB2b2lkIHdwYXNfc3RhcnRfbGlzdGVuX2NiKHN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yaywgaW50IGRlaW5pdCkKK3sKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gd29yay0+d3BhX3M7CisJc3RydWN0IHdwYXNfcDJwX2xpc3Rlbl93b3JrICpsd29yayA9IHdvcmstPmN0eDsKKworCWlmIChkZWluaXQpIHsKKwkJaWYgKHdvcmstPnN0YXJ0ZWQpIHsKKwkJCXdwYV9zLT5wMnBfbGlzdGVuX3dvcmsgPSBOVUxMOworCQkJd3Bhc19zdG9wX2xpc3Rlbih3cGFfcyk7CisJCX0KKwkJd3Bhc19wMnBfbGlzdGVuX3dvcmtfZnJlZShsd29yayk7CisJCXJldHVybjsKKwl9CisKKwl3cGFfcy0+cDJwX2xpc3Rlbl93b3JrID0gd29yazsKKworCXdwYV9kcnZfc2V0X2FwX3dwc19pZSh3cGFfcywgTlVMTCwgbHdvcmstPnByb2JlX3Jlc3BfaWUsIE5VTEwpOworCisJaWYgKHdwYV9kcnZfcHJvYmVfcmVxX3JlcG9ydCh3cGFfcywgMSkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGYWlsZWQgdG8gcmVxdWVzdCB0aGUgZHJpdmVyIHRvICIKKwkJCSAgICJyZXBvcnQgcmVjZWl2ZWQgUHJvYmUgUmVxdWVzdCBmcmFtZXMiKTsKKwkJd3Bhc19wMnBfbGlzdGVuX3dvcmtfZG9uZSh3cGFfcyk7CisJCXJldHVybjsKKwl9CisKKwl3cGFfcy0+cGVuZGluZ19saXN0ZW5fZnJlcSA9IGx3b3JrLT5mcmVxOworCXdwYV9zLT5wZW5kaW5nX2xpc3Rlbl9kdXJhdGlvbiA9IGx3b3JrLT5kdXJhdGlvbjsKKworCWlmICh3cGFfZHJ2X3JlbWFpbl9vbl9jaGFubmVsKHdwYV9zLCBsd29yay0+ZnJlcSwgbHdvcmstPmR1cmF0aW9uKSA8IDApCisJeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRmFpbGVkIHRvIHJlcXVlc3QgdGhlIGRyaXZlciAiCisJCQkgICAidG8gcmVtYWluIG9uIGNoYW5uZWwgKCV1IE1IeikgZm9yIExpc3RlbiAiCisJCQkgICAic3RhdGUiLCBsd29yay0+ZnJlcSk7CisJCXdwYXNfcDJwX2xpc3Rlbl93b3JrX2RvbmUod3BhX3MpOworCQl3cGFfcy0+cGVuZGluZ19saXN0ZW5fZnJlcSA9IDA7CisJCXJldHVybjsKKwl9CisJd3BhX3MtPm9mZl9jaGFubmVsX2ZyZXEgPSAwOworCXdwYV9zLT5yb2Nfd2FpdGluZ19kcnZfZnJlcSA9IGx3b3JrLT5mcmVxOworfQorCisKIHN0YXRpYyBpbnQgd3Bhc19zdGFydF9saXN0ZW4odm9pZCAqY3R4LCB1bnNpZ25lZCBpbnQgZnJlcSwKIAkJCSAgICAgdW5zaWduZWQgaW50IGR1cmF0aW9uLAogCQkJICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwcm9iZV9yZXNwX2llKQogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CisJc3RydWN0IHdwYXNfcDJwX2xpc3Rlbl93b3JrICpsd29yazsKIAotCXdwYV9kcnZfc2V0X2FwX3dwc19pZSh3cGFfcywgTlVMTCwgcHJvYmVfcmVzcF9pZSwgTlVMTCk7Ci0KLQlpZiAod3BhX2Rydl9wcm9iZV9yZXFfcmVwb3J0KHdwYV9zLCAxKSA8IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEZhaWxlZCB0byByZXF1ZXN0IHRoZSBkcml2ZXIgdG8gIgotCQkJICAgInJlcG9ydCByZWNlaXZlZCBQcm9iZSBSZXF1ZXN0IGZyYW1lcyIpOworCWlmICh3cGFfcy0+cDJwX2xpc3Rlbl93b3JrKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBSZWplY3Qgc3RhcnRfbGlzdGVuIHNpbmNlIHAycF9saXN0ZW5fd29yayBhbHJlYWR5IGV4aXN0cyIpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0Jd3BhX3MtPnBlbmRpbmdfbGlzdGVuX2ZyZXEgPSBmcmVxOwotCXdwYV9zLT5wZW5kaW5nX2xpc3Rlbl9kdXJhdGlvbiA9IGR1cmF0aW9uOworCWx3b3JrID0gb3NfemFsbG9jKHNpemVvZigqbHdvcmspKTsKKwlpZiAobHdvcmsgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWx3b3JrLT5mcmVxID0gZnJlcTsKKwlsd29yay0+ZHVyYXRpb24gPSBkdXJhdGlvbjsKKwlpZiAocHJvYmVfcmVzcF9pZSkgeworCQlsd29yay0+cHJvYmVfcmVzcF9pZSA9IHdwYWJ1Zl9kdXAocHJvYmVfcmVzcF9pZSk7CisJCWlmIChsd29yay0+cHJvYmVfcmVzcF9pZSA9PSBOVUxMKSB7CisJCQl3cGFzX3AycF9saXN0ZW5fd29ya19mcmVlKGx3b3JrKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KIAotCWlmICh3cGFfZHJ2X3JlbWFpbl9vbl9jaGFubmVsKHdwYV9zLCBmcmVxLCBkdXJhdGlvbikgPCAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGYWlsZWQgdG8gcmVxdWVzdCB0aGUgZHJpdmVyICIKLQkJCSAgICJ0byByZW1haW4gb24gY2hhbm5lbCAoJXUgTUh6KSBmb3IgTGlzdGVuICIKLQkJCSAgICJzdGF0ZSIsIGZyZXEpOwotCQl3cGFfcy0+cGVuZGluZ19saXN0ZW5fZnJlcSA9IDA7CisJaWYgKHJhZGlvX2FkZF93b3JrKHdwYV9zLCBmcmVxLCAicDJwLWxpc3RlbiIsIDAsIHdwYXNfc3RhcnRfbGlzdGVuX2NiLAorCQkJICAgbHdvcmspIDwgMCkgeworCQl3cGFzX3AycF9saXN0ZW5fd29ya19mcmVlKGx3b3JrKTsKIAkJcmV0dXJuIC0xOwogCX0KLQl3cGFfcy0+b2ZmX2NoYW5uZWxfZnJlcSA9IDA7Ci0Jd3BhX3MtPnJvY193YWl0aW5nX2Rydl9mcmVxID0gZnJlcTsKIAogCXJldHVybiAwOwogfQpAQCAtMTQ4Miw2ICsxODYwLDcgQEAKIAl9CiAJd3BhX2Rydl9zZXRfYXBfd3BzX2llKHdwYV9zLCBOVUxMLCBOVUxMLCBOVUxMKTsKIAl3cGFfZHJ2X3Byb2JlX3JlcV9yZXBvcnQod3BhX3MsIDApOworCXdwYXNfcDJwX2xpc3Rlbl93b3JrX2RvbmUod3BhX3MpOwogfQogCiAKQEAgLTE5ODIsOCArMjM2MSw4IEBACiAjZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwogCiAKLXZvaWQgd3Bhc19zZF9yZXF1ZXN0KHZvaWQgKmN0eCwgaW50IGZyZXEsIGNvbnN0IHU4ICpzYSwgdTggZGlhbG9nX3Rva2VuLAotCQkgICAgIHUxNiB1cGRhdGVfaW5kaWMsIGNvbnN0IHU4ICp0bHZzLCBzaXplX3QgdGx2c19sZW4pCitzdGF0aWMgdm9pZCB3cGFzX3NkX3JlcXVlc3Qodm9pZCAqY3R4LCBpbnQgZnJlcSwgY29uc3QgdTggKnNhLCB1OCBkaWFsb2dfdG9rZW4sCisJCQkgICAgdTE2IHVwZGF0ZV9pbmRpYywgY29uc3QgdTggKnRsdnMsIHNpemVfdCB0bHZzX2xlbikKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCWNvbnN0IHU4ICpwb3MgPSB0bHZzOwpAQCAtMjEwMCw4ICsyNDc5LDggQEAKIH0KIAogCi12b2lkIHdwYXNfc2RfcmVzcG9uc2Uodm9pZCAqY3R4LCBjb25zdCB1OCAqc2EsIHUxNiB1cGRhdGVfaW5kaWMsCi0JCSAgICAgIGNvbnN0IHU4ICp0bHZzLCBzaXplX3QgdGx2c19sZW4pCitzdGF0aWMgdm9pZCB3cGFzX3NkX3Jlc3BvbnNlKHZvaWQgKmN0eCwgY29uc3QgdTggKnNhLCB1MTYgdXBkYXRlX2luZGljLAorCQkJICAgICBjb25zdCB1OCAqdGx2cywgc2l6ZV90IHRsdnNfbGVuKQogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CiAJY29uc3QgdTggKnBvcyA9IHRsdnM7CkBAIC0yMTY4LDggKzI1NDcsNiBAQAogdTY0IHdwYXNfcDJwX3NkX3JlcXVlc3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmRzdCwKIAkJCWNvbnN0IHN0cnVjdCB3cGFidWYgKnRsdnMpCiB7Ci0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKQotCQlyZXR1cm4gd3BhX2Rydl9wMnBfc2RfcmVxdWVzdCh3cGFfcywgZHN0LCB0bHZzKTsKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm4gMDsKIAlyZXR1cm4gKHVpbnRwdHJfdCkgcDJwX3NkX3JlcXVlc3Qod3BhX3MtPmdsb2JhbC0+cDJwLCBkc3QsIHRsdnMpOwpAQCAtMjIwMSw4ICsyNTc4LDYgQEAKIHN0YXRpYyB1NjQgd3Bhc19wMnBfc2RfcmVxdWVzdF93ZmQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmRzdCwKIAkJCQkgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICp0bHZzKQogewotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJcmV0dXJuIDA7CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKIAkJcmV0dXJuIDA7CiAJcmV0dXJuICh1aW50cHRyX3QpIHAycF9zZF9yZXF1ZXN0X3dmZCh3cGFfcy0+Z2xvYmFsLT5wMnAsIGRzdCwgdGx2cyk7CkBAIC0yMjgwLDggKzI2NTUsNiBAQAogCiBpbnQgd3Bhc19wMnBfc2RfY2FuY2VsX3JlcXVlc3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgdTY0IHJlcSkKIHsKLQlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQpCi0JCXJldHVybiB3cGFfZHJ2X3AycF9zZF9jYW5jZWxfcmVxdWVzdCh3cGFfcywgcmVxKTsKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAJcmV0dXJuIHAycF9zZF9jYW5jZWxfcmVxdWVzdCh3cGFfcy0+Z2xvYmFsLT5wMnAsCkBAIC0yMjkzLDExICsyNjY2LDYgQEAKIAkJCSAgY29uc3QgdTggKmRzdCwgdTggZGlhbG9nX3Rva2VuLAogCQkJICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpyZXNwX3RsdnMpCiB7Ci0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKSB7Ci0JCXdwYV9kcnZfcDJwX3NkX3Jlc3BvbnNlKHdwYV9zLCBmcmVxLCBkc3QsIGRpYWxvZ190b2tlbiwKLQkJCQkJcmVzcF90bHZzKTsKLQkJcmV0dXJuOwotCX0KIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm47CiAJcDJwX3NkX3Jlc3BvbnNlKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcSwgZHN0LCBkaWFsb2dfdG9rZW4sCkBAIC0yMzA3LDEwICsyNjc1LDYgQEAKIAogdm9pZCB3cGFzX3AycF9zZF9zZXJ2aWNlX3VwZGF0ZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkgewotCQl3cGFfZHJ2X3AycF9zZXJ2aWNlX3VwZGF0ZSh3cGFfcyk7Ci0JCXJldHVybjsKLQl9CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCkKIAkJcDJwX3NkX3NlcnZpY2VfdXBkYXRlKHdwYV9zLT5nbG9iYWwtPnAycCk7CiB9CkBAIC0yNDM1LDExICsyNzk5LDExIEBACiB9CiAKIAotdm9pZCB3cGFzX3Byb3ZfZGlzY19yZXEodm9pZCAqY3R4LCBjb25zdCB1OCAqcGVlciwgdTE2IGNvbmZpZ19tZXRob2RzLAotCQkJY29uc3QgdTggKmRldl9hZGRyLCBjb25zdCB1OCAqcHJpX2Rldl90eXBlLAotCQkJY29uc3QgY2hhciAqZGV2X25hbWUsIHUxNiBzdXBwX2NvbmZpZ19tZXRob2RzLAotCQkJdTggZGV2X2NhcGFiLCB1OCBncm91cF9jYXBhYiwgY29uc3QgdTggKmdyb3VwX2lkLAotCQkJc2l6ZV90IGdyb3VwX2lkX2xlbikKK3N0YXRpYyB2b2lkIHdwYXNfcHJvdl9kaXNjX3JlcSh2b2lkICpjdHgsIGNvbnN0IHU4ICpwZWVyLCB1MTYgY29uZmlnX21ldGhvZHMsCisJCQkgICAgICAgY29uc3QgdTggKmRldl9hZGRyLCBjb25zdCB1OCAqcHJpX2Rldl90eXBlLAorCQkJICAgICAgIGNvbnN0IGNoYXIgKmRldl9uYW1lLCB1MTYgc3VwcF9jb25maWdfbWV0aG9kcywKKwkJCSAgICAgICB1OCBkZXZfY2FwYWIsIHU4IGdyb3VwX2NhcGFiLCBjb25zdCB1OCAqZ3JvdXBfaWQsCisJCQkgICAgICAgc2l6ZV90IGdyb3VwX2lkX2xlbikKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCWNoYXIgZGV2dHlwZVtXUFNfREVWX1RZUEVfQlVGU0laRV07CkBAIC0yNDkyLDcgKzI4NTYsNyBAQAogfQogCiAKLXZvaWQgd3Bhc19wcm92X2Rpc2NfcmVzcCh2b2lkICpjdHgsIGNvbnN0IHU4ICpwZWVyLCB1MTYgY29uZmlnX21ldGhvZHMpCitzdGF0aWMgdm9pZCB3cGFzX3Byb3ZfZGlzY19yZXNwKHZvaWQgKmN0eCwgY29uc3QgdTggKnBlZXIsIHUxNiBjb25maWdfbWV0aG9kcykKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCXVuc2lnbmVkIGludCBnZW5lcmF0ZWRfcGluID0gMDsKQEAgLTI1MDQsNyArMjg2OCw3IEBACiAJCXdwYV9zLT5wZW5kaW5nX3BkX2JlZm9yZV9qb2luID0gMDsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFN0YXJ0aW5nIHBlbmRpbmcgIgogCQkJICAgImpvaW4tZXhpc3RpbmctZ3JvdXAgb3BlcmF0aW9uIik7Ci0JCXdwYXNfcDJwX2pvaW5fc3RhcnQod3BhX3MpOworCQl3cGFzX3AycF9qb2luX3N0YXJ0KHdwYV9zLCAwLCBOVUxMLCAwKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMjU0OCw3ICsyOTEyLDcgQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFN0YXJ0aW5nIHBlbmRpbmcgIgogCQkJICAgImpvaW4tZXhpc3RpbmctZ3JvdXAgb3BlcmF0aW9uIChubyBBQ0sgZm9yIFBEICIKIAkJCSAgICJSZXEgYXR0ZW1wdHMpIik7Ci0JCXdwYXNfcDJwX2pvaW5fc3RhcnQod3BhX3MpOworCQl3cGFzX3AycF9qb2luX3N0YXJ0KHdwYV9zLCAwLCBOVUxMLCAwKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMjU3MCwyMCArMjkzNCw2MiBAQAogfQogCiAKKy8qKgorICogUGljayB0aGUgYmVzdCBmcmVxdWVuY3kgdG8gdXNlIGZyb20gYWxsIHRoZSBjdXJyZW50bHkgdXNlZCBmcmVxdWVuY2llcy4KKyAqLworc3RhdGljIGludCB3cGFzX3AycF9waWNrX2Jlc3RfdXNlZF9mcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCXN0cnVjdCB3cGFfdXNlZF9mcmVxX2RhdGEgKmZyZXFzLAorCQkJCQl1bnNpZ25lZCBpbnQgbnVtKQoreworCXVuc2lnbmVkIGludCBpLCBjOworCisJLyogZmluZCBhIGNhbmRpZGF0ZSBmcmVxIHRoYXQgaXMgc3VwcG9ydGVkIGJ5IFAyUCAqLworCWZvciAoYyA9IDA7IGMgPCBudW07IGMrKykKKwkJaWYgKHAycF9zdXBwb3J0ZWRfZnJlcSh3cGFfcy0+Z2xvYmFsLT5wMnAsIGZyZXFzW2NdLmZyZXEpKQorCQkJYnJlYWs7CisKKwlpZiAoYyA9PSBudW0pCisJCXJldHVybiAwOworCisJLyogb25jZSB3ZSBoYXZlIGEgY2FuZGlkYXRlLCB0cnkgdG8gZmluZCBhICdiZXR0ZXInIG9uZSAqLworCWZvciAoaSA9IGMgKyAxOyBpIDwgbnVtOyBpKyspIHsKKwkJaWYgKCFwMnBfc3VwcG9ydGVkX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLCBmcmVxc1tpXS5mcmVxKSkKKwkJCWNvbnRpbnVlOworCisJCS8qCisJCSAqIDEuIEluZnJhc3RydWN0dXJlIHN0YXRpb24gaW50ZXJmYWNlcyBoYXZlIGhpZ2hlciBwcmVmZXJlbmNlLgorCQkgKiAyLiBQMlAgQ2xpZW50cyBoYXZlIGhpZ2hlciBwcmVmZXJlbmNlLgorCQkgKiAzLiBBbGwgb3RoZXJzLgorCQkgKi8KKwkJaWYgKGZyZXFzW2ldLmZsYWdzICYgV1BBX0ZSRVFfVVNFRF9CWV9JTkZSQV9TVEFUSU9OKSB7CisJCQljID0gaTsKKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKChmcmVxc1tpXS5mbGFncyAmIFdQQV9GUkVRX1VTRURfQllfUDJQX0NMSUVOVCkpCisJCQljID0gaTsKKwl9CisJcmV0dXJuIGZyZXFzW2NdLmZyZXE7Cit9CisKKwogc3RhdGljIHU4IHdwYXNfaW52aXRhdGlvbl9wcm9jZXNzKHZvaWQgKmN0eCwgY29uc3QgdTggKnNhLCBjb25zdCB1OCAqYnNzaWQsCiAJCQkJICBjb25zdCB1OCAqZ29fZGV2X2FkZHIsIGNvbnN0IHU4ICpzc2lkLAogCQkJCSAgc2l6ZV90IHNzaWRfbGVuLCBpbnQgKmdvLCB1OCAqZ3JvdXBfYnNzaWQsCiAJCQkJICBpbnQgKmZvcmNlX2ZyZXEsIGludCBwZXJzaXN0ZW50X2dyb3VwLAotCQkJCSAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2hhbm5lbHMpCisJCQkJICBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscywKKwkJCQkgIGludCBkZXZfcHdfaWQpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnM7Ci0JaW50IHJlczsKKwlzdHJ1Y3Qgd3BhX3VzZWRfZnJlcV9kYXRhICpmcmVxczsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKmdycDsKKwlpbnQgYmVzdF9mcmVxOwogCiAJaWYgKCFwZXJzaXN0ZW50X2dyb3VwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBJbnZpdGF0aW9uIGZyb20gIiBNQUNTVFIKLQkJCSAgICIgdG8gam9pbiBhbiBhY3RpdmUgZ3JvdXAiLCBNQUMyU1RSKHNhKSk7CisJCQkgICAiIHRvIGpvaW4gYW4gYWN0aXZlIGdyb3VwIChTU0lEOiAlcykiLAorCQkJICAgTUFDMlNUUihzYSksIHdwYV9zc2lkX3R4dChzc2lkLCBzc2lkX2xlbikpOwogCQlpZiAoIWlzX3plcm9fZXRoZXJfYWRkcih3cGFfcy0+cDJwX2F1dGhfaW52aXRlKSAmJgogCQkgICAgKG9zX21lbWNtcChnb19kZXZfYWRkciwgd3BhX3MtPnAycF9hdXRoX2ludml0ZSwgRVRIX0FMRU4pCiAJCSAgICAgPT0gMCB8fApAQCAtMjU5Miw2ICsyOTk4LDIxIEBACiAJCQkJICAgImF1dGhvcml6ZWQgaW52aXRhdGlvbiIpOwogCQkJZ290byBhY2NlcHRfaW52OwogCQl9CisKKyNpZmRlZiBDT05GSUdfV1BTX05GQworCQlpZiAoZGV2X3B3X2lkID49IDAgJiYgd3BhX3MtPnBhcmVudC0+cDJwX25mY190YWdfZW5hYmxlZCAmJgorCQkgICAgZGV2X3B3X2lkID09IHdwYV9zLT5wYXJlbnQtPnAycF9vb2JfZGV2X3B3X2lkKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQWNjZXB0IGludml0YXRpb24gYmFzZWQgb24gbG9jYWwgZW5hYmxlZCBORkMgVGFnIik7CisJCQl3cGFfcy0+cGFyZW50LT5wMnBfd3BzX21ldGhvZCA9IFdQU19ORkM7CisJCQl3cGFfcy0+cGFyZW50LT5wZW5kaW5nX2pvaW5fd3BzX21ldGhvZCA9IFdQU19ORkM7CisJCQlvc19tZW1jcHkod3BhX3MtPnBhcmVudC0+cGVuZGluZ19qb2luX2Rldl9hZGRyLAorCQkJCSAgZ29fZGV2X2FkZHIsIEVUSF9BTEVOKTsKKwkJCW9zX21lbWNweSh3cGFfcy0+cGFyZW50LT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkciwKKwkJCQkgIGJzc2lkLCBFVEhfQUxFTik7CisJCQlnb3RvIGFjY2VwdF9pbnY7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCiAJCS8qCiAJCSAqIERvIG5vdCBhY2NlcHQgdGhlIGludml0YXRpb24gYXV0b21hdGljYWxseTsgbm90aWZ5IHVzZXIgYW5kCiAJCSAqIHJlcXVlc3QgYXBwcm92YWwuCkBAIC0yNjEyLDYgKzMwMzMsNyBAQAogCSAgICBvc19tZW1jbXAoc2EsIHdwYV9zLT5wMnBfYXV0aF9pbnZpdGUsIEVUSF9BTEVOKSA9PSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBBY2NlcHQgcHJldmlvdXNseSBpbml0aWF0ZWQgIgogCQkJICAgImludml0YXRpb24gdG8gcmUtaW52b2tlIGEgcGVyc2lzdGVudCBncm91cCIpOworCQlvc19tZW1zZXQod3BhX3MtPnAycF9hdXRoX2ludml0ZSwgMCwgRVRIX0FMRU4pOwogCX0gZWxzZSBpZiAoIXdwYV9zLT5jb25mLT5wZXJzaXN0ZW50X3JlY29ubmVjdCkKIAkJcmV0dXJuIFAyUF9TQ19GQUlMX0lORk9fQ1VSUkVOVExZX1VOQVZBSUxBQkxFOwogCkBAIC0yNjU0LDExICszMDc2LDI2IEBACiBhY2NlcHRfaW52OgogCXdwYXNfcDJwX3NldF9vd25fZnJlcV9wcmVmZXJlbmNlKHdwYV9zLCAwKTsKIAorCWJlc3RfZnJlcSA9IDA7CisJZnJlcXMgPSBvc19jYWxsb2Mod3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCwKKwkJCSAgc2l6ZW9mKHN0cnVjdCB3cGFfdXNlZF9mcmVxX2RhdGEpKTsKKwlpZiAoZnJlcXMpIHsKKwkJaW50IG51bV9jaGFubmVscyA9IHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQ7CisJCWludCBudW0gPSB3cGFzX3AycF92YWxpZF9vcGVyX2ZyZXFzKHdwYV9zLCBmcmVxcywgbnVtX2NoYW5uZWxzKTsKKwkJYmVzdF9mcmVxID0gd3Bhc19wMnBfcGlja19iZXN0X3VzZWRfZnJlcSh3cGFfcywgZnJlcXMsIG51bSk7CisJCW9zX2ZyZWUoZnJlcXMpOworCX0KKwogCS8qIEdldCBvbmUgb2YgdGhlIGZyZXF1ZW5jaWVzIGN1cnJlbnRseSBpbiB1c2UgKi8KLQlpZiAod3Bhc19wMnBfdmFsaWRfb3Blcl9mcmVxcyh3cGFfcywgJnJlcywgMSkgPiAwKSB7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBUcnlpbmcgdG8gZm9yY2UgY2hhbm5lbCB0byBtYXRjaCBhIGNoYW5uZWwgYWxyZWFkeSB1c2VkIGJ5IG9uZSBvZiB0aGUgaW50ZXJmYWNlcyIpOwotCQkqZm9yY2VfZnJlcSA9IHJlczsKLQkJd3Bhc19wMnBfc2V0X293bl9mcmVxX3ByZWZlcmVuY2Uod3BhX3MsIHJlcyk7CisJaWYgKGJlc3RfZnJlcSA+IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRyeWluZyB0byBwcmVmZXIgYSBjaGFubmVsIGFscmVhZHkgdXNlZCBieSBvbmUgb2YgdGhlIGludGVyZmFjZXMiKTsKKwkJd3Bhc19wMnBfc2V0X293bl9mcmVxX3ByZWZlcmVuY2Uod3BhX3MsIGJlc3RfZnJlcSk7CisKKwkJaWYgKHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQgPCAyIHx8CisJCSAgICB3cGFzX3AycF9udW1fdW51c2VkX2NoYW5uZWxzKHdwYV9zKSA8IDEpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBObyBleHRyYSBjaGFubmVscyBhdmFpbGFibGUgLSB0cnlpbmcgdG8gZm9yY2UgY2hhbm5lbCB0byBtYXRjaCBhIGNoYW5uZWwgYWxyZWFkeSB1c2VkIGJ5IG9uZSBvZiB0aGUgaW50ZXJmYWNlcyIpOworCQkJKmZvcmNlX2ZyZXEgPSBiZXN0X2ZyZXE7CisJCX0KIAl9CiAKIAlpZiAoKmZvcmNlX2ZyZXEgPiAwICYmIHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQgPiAxICYmCkBAIC0yNzAxLDE2ICszMTM4LDE4IEBACiAKIAlpZiAoc3RhdHVzID09IFAyUF9TQ19TVUNDRVNTKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBJbnZpdGF0aW9uIGZyb20gcGVlciAiIE1BQ1NUUgotCQkJICAgIiB3YXMgYWNjZXB0ZWQ7IG9wX2ZyZXE9JWQgTUh6IiwKLQkJCSAgIE1BQzJTVFIoc2EpLCBvcF9mcmVxKTsKKwkJCSAgICIgd2FzIGFjY2VwdGVkOyBvcF9mcmVxPSVkIE1IeiwgU1NJRD0lcyIsCisJCQkgICBNQUMyU1RSKHNhKSwgb3BfZnJlcSwgd3BhX3NzaWRfdHh0KHNzaWQsIHNzaWRfbGVuKSk7CiAJCWlmIChzKSB7CiAJCQlpbnQgZ28gPSBzLT5tb2RlID09IFdQQVNfTU9ERV9QMlBfR087CiAJCQl3cGFzX3AycF9ncm91cF9hZGRfcGVyc2lzdGVudCgKLQkJCQl3cGFfcywgcywgZ28sIGdvID8gb3BfZnJlcSA6IDAsIDAsIE5VTEwpOworCQkJCXdwYV9zLCBzLCBnbywgMCwgb3BfZnJlcSwgMCwgMCwgTlVMTCwKKwkJCQlnbyA/IFAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVRfR09fUkVJTlZPS0UgOiAwKTsKIAkJfSBlbHNlIGlmIChic3NpZCkgewogCQkJd3BhX3MtPnVzZXJfaW5pdGlhdGVkX3BkID0gMDsKIAkJCXdwYXNfcDJwX2pvaW4od3BhX3MsIGJzc2lkLCBnb19kZXZfYWRkciwKLQkJCQkgICAgICB3cGFfcy0+cDJwX3dwc19tZXRob2QsIDApOworCQkJCSAgICAgIHdwYV9zLT5wMnBfd3BzX21ldGhvZCwgMCwgb3BfZnJlcSwKKwkJCQkgICAgICBzc2lkLCBzc2lkX2xlbik7CiAJCX0KIAkJcmV0dXJuOwogCX0KQEAgLTI3NjUsNyArMzIwNCw3IEBACiAJCQkgICAgICBFVEhfQUxFTikgPT0gMCkKIAkJCWJyZWFrOwogCX0KLQlpZiAoaSA+PSBzc2lkLT5udW1fcDJwX2NsaWVudHMpIHsKKwlpZiAoaSA+PSBzc2lkLT5udW1fcDJwX2NsaWVudHMgfHwgIXNzaWQtPnAycF9jbGllbnRfbGlzdCkgewogCQlpZiAoc3NpZC0+bW9kZSAhPSBXUEFTX01PREVfUDJQX0dPICYmCiAJCSAgICBvc19tZW1jbXAoc3NpZC0+YnNzaWQsIHBlZXIsIEVUSF9BTEVOKSA9PSAwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogUmVtb3ZlIHBlcnNpc3RlbnQgZ3JvdXAgJWQgIgpAQCAtMjc4NSwxMSArMzIyNCw5IEBACiAJCSAgIHNzaWQtPnAycF9jbGllbnRfbGlzdCArIChpICsgMSkgKiBFVEhfQUxFTiwKIAkJICAgKHNzaWQtPm51bV9wMnBfY2xpZW50cyAtIGkgLSAxKSAqIEVUSF9BTEVOKTsKIAlzc2lkLT5udW1fcDJwX2NsaWVudHMtLTsKLSNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19XUklURQogCWlmICh3cGFfcy0+cGFyZW50LT5jb25mLT51cGRhdGVfY29uZmlnICYmCiAJICAgIHdwYV9jb25maWdfd3JpdGUod3BhX3MtPnBhcmVudC0+Y29uZm5hbWUsIHdwYV9zLT5wYXJlbnQtPmNvbmYpKQogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRmFpbGVkIHRvIHVwZGF0ZSBjb25maWd1cmF0aW9uIik7Ci0jZW5kaWYgLyogQ09ORklHX05PX0NPTkZJR19XUklURSAqLwogfQogCiAKQEAgLTI4MTMsMTAgKzMyNTAsMTIgQEAKIAogc3RhdGljIHZvaWQgd3Bhc19pbnZpdGF0aW9uX3Jlc3VsdCh2b2lkICpjdHgsIGludCBzdGF0dXMsIGNvbnN0IHU4ICpic3NpZCwKIAkJCQkgICBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscywKLQkJCQkgICBjb25zdCB1OCAqcGVlcikKKwkJCQkgICBjb25zdCB1OCAqcGVlciwgaW50IG5lZ19mcmVxLAorCQkJCSAgIGludCBwZWVyX29wZXJfZnJlcSkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKKwlpbnQgZnJlcTsKIAogCWlmIChic3NpZCkgewogCQl3cGFfbXNnX2dsb2JhbCh3cGFfcywgTVNHX0lORk8sIFAyUF9FVkVOVF9JTlZJVEFUSU9OX1JFU1VMVApAQCAtMjg2OCwzOCArMzMwNywzOSBAQAogCSAqIHRoZSBwZXJzaXN0ZW50IGdyb3VwIHNvIHRoYXQgd2Ugd2lsbCByZW1haW4gb24gdGhlIGN1cnJlbnQgY2hhbm5lbCB0bwogCSAqIGFja25vd2xlZGdlIGFueSBwb3NzaWJsZSByZXRyYW5zbWlzc2lvbiBmcm9tIHRoZSBwZWVyLgogCSAqLwotI2lmbmRlZiBBTkRST0lEX1AyUAogCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlAyUDogNTAgbXMgd2FpdCBvbiBjdXJyZW50IGNoYW5uZWwgYmVmb3JlICIKIAkJInN0YXJ0aW5nIHBlcnNpc3RlbnQgZ3JvdXAiKTsKIAlvc19zbGVlcCgwLCA1MDAwMCk7Ci0jZWxzZQotCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlAyUDogMTAwIG1zIHdhaXQgb24gY3VycmVudCBjaGFubmVsIGJlZm9yZSAiCi0JCSJzdGFydGluZyBwZXJzaXN0ZW50IGdyb3VwIik7Ci0Jb3Nfc2xlZXAoMCwgMTAwMDAwKTsKLSNlbmRpZgogCisJaWYgKG5lZ19mcmVxID4gMCAmJiBzc2lkLT5tb2RlID09IFdQQVNfTU9ERV9QMlBfR08gJiYKKwkgICAgZnJlcV9pbmNsdWRlZChjaGFubmVscywgbmVnX2ZyZXEpKQorCQlmcmVxID0gbmVnX2ZyZXE7CisJZWxzZSBpZiAocGVlcl9vcGVyX2ZyZXEgPiAwICYmIHNzaWQtPm1vZGUgIT0gV1BBU19NT0RFX1AyUF9HTyAmJgorCQkgZnJlcV9pbmNsdWRlZChjaGFubmVscywgcGVlcl9vcGVyX2ZyZXEpKQorCQlmcmVxID0gcGVlcl9vcGVyX2ZyZXE7CisJZWxzZQorCQlmcmVxID0gMDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBQZXJzaXN0ZW50IGdyb3VwIGludml0YXRpb24gc3VjY2VzcyAtIG9wX2ZyZXE9JWQgTUh6IFNTSUQ9JXMiLAorCQkgICBmcmVxLCB3cGFfc3NpZF90eHQoc3NpZC0+c3NpZCwgc3NpZC0+c3NpZF9sZW4pKTsKIAl3cGFzX3AycF9ncm91cF9hZGRfcGVyc2lzdGVudCh3cGFfcywgc3NpZCwKIAkJCQkgICAgICBzc2lkLT5tb2RlID09IFdQQVNfTU9ERV9QMlBfR08sCiAJCQkJICAgICAgd3BhX3MtPnAycF9wZXJzaXN0ZW50X2dvX2ZyZXEsCi0JCQkJICAgICAgd3BhX3MtPnAycF9nb19odDQwLCBjaGFubmVscyk7CisJCQkJICAgICAgZnJlcSwKKwkJCQkgICAgICB3cGFfcy0+cDJwX2dvX2h0NDAsIHdwYV9zLT5wMnBfZ29fdmh0LAorCQkJCSAgICAgIGNoYW5uZWxzLAorCQkJCSAgICAgIHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX1AyUF9HTyA/CisJCQkJICAgICAgUDJQX01BWF9JTklUSUFMX0NPTk5fV0FJVF9HT19SRUlOVk9LRSA6CisJCQkJICAgICAgMCk7CiB9CiAKIAogc3RhdGljIGludCB3cGFzX3AycF9kaXNhbGxvd2VkX2ZyZXEoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwKIAkJCQkgICAgdW5zaWduZWQgaW50IGZyZXEpCiB7Ci0JdW5zaWduZWQgaW50IGk7Ci0KLQlpZiAoZ2xvYmFsLT5wMnBfZGlzYWxsb3dfZnJlcSA9PSBOVUxMKQotCQlyZXR1cm4gMDsKLQotCWZvciAoaSA9IDA7IGkgPCBnbG9iYWwtPm51bV9wMnBfZGlzYWxsb3dfZnJlcTsgaSsrKSB7Ci0JCWlmIChmcmVxID49IGdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXFbaV0ubWluICYmCi0JCSAgICBmcmVxIDw9IGdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXFbaV0ubWF4KQotCQkJcmV0dXJuIDE7Ci0JfQotCi0JcmV0dXJuIDA7CisJaWYgKGZyZXFfcmFuZ2VfbGlzdF9pbmNsdWRlcygmZ2xvYmFsLT5wMnBfZ29fYXZvaWRfZnJlcSwgZnJlcSkpCisJCXJldHVybiAxOworCXJldHVybiBmcmVxX3JhbmdlX2xpc3RfaW5jbHVkZXMoJmdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXEsIGZyZXEpOwogfQogCiAKQEAgLTI5MTEsMTAgKzMzNTEsMTMgQEAKIAogCiBzdGF0aWMgaW50IHdwYXNfcDJwX2RlZmF1bHRfY2hhbm5lbHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgICAgIHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW4pCisJCQkJICAgICBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFuLAorCQkJCSAgICAgc3RydWN0IHAycF9jaGFubmVscyAqY2xpX2NoYW4pCiB7CiAJaW50IGksIGNsYSA9IDA7CiAKKwlvc19tZW1zZXQoY2xpX2NoYW4sIDAsIHNpemVvZigqY2xpX2NoYW4pKTsKKwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBFbmFibGUgb3BlcmF0aW5nIGNsYXNzZXMgZm9yIDIuNCBHSHogIgogCQkgICAiYmFuZCIpOwogCkBAIC0yOTgyLDYgKzM0MjUsMTAgQEAKIH0KIAogCitlbnVtIGNoYW5fYWxsb3dlZCB7CisJTk9UX0FMTE9XRUQsIFBBU1NJVkVfT05MWSwgQUxMT1dFRAorfTsKKwogc3RhdGljIGludCBoYXNfY2hhbm5lbChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsLAogCQkgICAgICAgc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGUsIHU4IGNoYW4sIGludCAqZmxhZ3MpCiB7CkBAIC0yOTkxLDIxICszNDM4LDI1IEBACiAJZnJlcSA9IChtb2RlLT5tb2RlID09IEhPU1RBUERfTU9ERV9JRUVFODAyMTFBID8gNTAwMCA6IDI0MDcpICsKIAkJY2hhbiAqIDU7CiAJaWYgKHdwYXNfcDJwX2Rpc2FsbG93ZWRfZnJlcShnbG9iYWwsIGZyZXEpKQotCQlyZXR1cm4gMDsKKwkJcmV0dXJuIE5PVF9BTExPV0VEOwogCiAJZm9yIChpID0gMDsgaSA8IG1vZGUtPm51bV9jaGFubmVsczsgaSsrKSB7CiAJCWlmIChtb2RlLT5jaGFubmVsc1tpXS5jaGFuID09IGNoYW4pIHsKIAkJCWlmIChmbGFncykKIAkJCQkqZmxhZ3MgPSBtb2RlLT5jaGFubmVsc1tpXS5mbGFnOwotCQkJcmV0dXJuICEobW9kZS0+Y2hhbm5lbHNbaV0uZmxhZyAmCi0JCQkJIChIT1NUQVBEX0NIQU5fRElTQUJMRUQgfAotCQkJCSAgSE9TVEFQRF9DSEFOX1BBU1NJVkVfU0NBTiB8Ci0JCQkJICBIT1NUQVBEX0NIQU5fTk9fSUJTUyB8Ci0JCQkJICBIT1NUQVBEX0NIQU5fUkFEQVIpKTsKKwkJCWlmIChtb2RlLT5jaGFubmVsc1tpXS5mbGFnICYKKwkJCSAgICAoSE9TVEFQRF9DSEFOX0RJU0FCTEVEIHwKKwkJCSAgICAgSE9TVEFQRF9DSEFOX1JBREFSKSkKKwkJCQlyZXR1cm4gTk9UX0FMTE9XRUQ7CisJCQlpZiAobW9kZS0+Y2hhbm5lbHNbaV0uZmxhZyAmCisJCQkgICAgKEhPU1RBUERfQ0hBTl9QQVNTSVZFX1NDQU4gfAorCQkJICAgICBIT1NUQVBEX0NIQU5fTk9fSUJTUykpCisJCQkJcmV0dXJuIFBBU1NJVkVfT05MWTsKKwkJCXJldHVybiBBTExPV0VEOwogCQl9CiAJfQogCi0JcmV0dXJuIDA7CisJcmV0dXJuIE5PVF9BTExPV0VEOwogfQogCiAKQEAgLTMwMTUsNyArMzQ2Niw3IEBACiAJdTggbWluX2NoYW47CiAJdTggbWF4X2NoYW47CiAJdTggaW5jOwotCWVudW0geyBCVzIwLCBCVzQwUExVUywgQlc0ME1JTlVTIH0gYnc7CisJZW51bSB7IEJXMjAsIEJXNDBQTFVTLCBCVzQwTUlOVVMsIEJXODAgfSBidzsKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgcDJwX29wZXJfY2xhc3NfbWFwIG9wX2NsYXNzW10gPSB7CkBAIC0zMDMwLDczICszNDgxLDE3MSBAQAogCXsgSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEsIDExNywgNDAsIDQ4LCA4LCBCVzQwTUlOVVMgfSwKIAl7IEhPU1RBUERfTU9ERV9JRUVFODAyMTFBLCAxMjYsIDE0OSwgMTU3LCA4LCBCVzQwUExVUyB9LAogCXsgSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUEsIDEyNywgMTUzLCAxNjEsIDgsIEJXNDBNSU5VUyB9LAorCisJLyoKKwkgKiBJRUVFIFA4MDIuMTFhYy9ENy4wIFRhYmxlIEUtNCBhY3R1YWxseSB0YWxrcyBhYm91dCBjaGFubmVsIGNlbnRlcgorCSAqIGZyZXF1ZW5jeSBpbmRleCA0MiwgNTgsIDEwNiwgMTIyLCAxMzgsIDE1NSB3aXRoIGNoYW5uZWwgc3BhY2luZyBvZgorCSAqIDgwIE1IeiwgYnV0IGN1cnJlbnRseSB1c2UgdGhlIGZvbGxvd2luZyBkZWZpbml0aW9uIGZvciBzaW1wbGljaXR5CisJICogKHRoZXNlIGNlbnRlciBmcmVxdWVuY2llcyBhcmUgbm90IGFjdHVhbCBjaGFubmVscywgd2hpY2ggbWFrZXMKKwkgKiBoYXNfY2hhbm5lbCgpIGZhaWwpLiB3cGFzX3AycF92ZXJpZnlfODBtaHooKSBzaG91bGQgdGFrZSBjYXJlIG9mCisJICogcmVtb3ZpbmcgaW52YWxpZCBjaGFubmVscy4KKwkgKi8KKwl7IEhPU1RBUERfTU9ERV9JRUVFODAyMTFBLCAxMjgsIDM2LCAxNjEsIDQsIEJXODAgfSwKIAl7IC0xLCAwLCAwLCAwLCAwLCBCVzIwIH0KIH07CiAKIAotc3RhdGljIGludCB3cGFzX3AycF92ZXJpZnlfY2hhbm5lbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJCSAgIHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlLAotCQkJCSAgIHU4IGNoYW5uZWwsIHU4IGJ3KQorc3RhdGljIGludCB3cGFzX3AycF9nZXRfY2VudGVyXzgwbWh6KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICBzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZSwKKwkJCQkgICAgIHU4IGNoYW5uZWwpCiB7Ci0JaW50IGZsYWc7CisJdTggY2VudGVyX2NoYW5uZWxzW10gPSB7IDQyLCA1OCwgMTA2LCAxMjIsIDEzOCwgMTU1IH07CisJdW5zaWduZWQgaW50IGk7CiAKLQlpZiAoIWhhc19jaGFubmVsKHdwYV9zLT5nbG9iYWwsIG1vZGUsIGNoYW5uZWwsICZmbGFnKSkKLQkJcmV0dXJuIC0xOwotCWlmIChidyA9PSBCVzQwTUlOVVMgJiYKLQkgICAgKCEoZmxhZyAmIEhPU1RBUERfQ0hBTl9IVDQwTUlOVVMpIHx8Ci0JICAgICAhaGFzX2NoYW5uZWwod3BhX3MtPmdsb2JhbCwgbW9kZSwgY2hhbm5lbCAtIDQsIE5VTEwpKSkKKwlpZiAobW9kZS0+bW9kZSAhPSBIT1NUQVBEX01PREVfSUVFRTgwMjExQSkKIAkJcmV0dXJuIDA7Ci0JaWYgKGJ3ID09IEJXNDBQTFVTICYmCi0JICAgICghKGZsYWcgJiBIT1NUQVBEX0NIQU5fSFQ0MFBMVVMpIHx8Ci0JICAgICAhaGFzX2NoYW5uZWwod3BhX3MtPmdsb2JhbCwgbW9kZSwgY2hhbm5lbCArIDQsIE5VTEwpKSkKLQkJcmV0dXJuIDA7Ci0JcmV0dXJuIDE7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShjZW50ZXJfY2hhbm5lbHMpOyBpKyspCisJCS8qCisJCSAqIEluIDgwIE1IeiwgdGhlIGJhbmR3aWR0aCAic3BhbnMiIDEyIGNoYW5uZWxzIChlLmcuLCAzNi00OCksCisJCSAqIHNvIHRoZSBjZW50ZXIgY2hhbm5lbCBpcyA2IGNoYW5uZWxzIGF3YXkgZnJvbSB0aGUgc3RhcnQvZW5kLgorCQkgKi8KKwkJaWYgKGNoYW5uZWwgPj0gY2VudGVyX2NoYW5uZWxzW2ldIC0gNiAmJgorCQkgICAgY2hhbm5lbCA8PSBjZW50ZXJfY2hhbm5lbHNbaV0gKyA2KQorCQkJcmV0dXJuIGNlbnRlcl9jaGFubmVsc1tpXTsKKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBlbnVtIGNoYW5fYWxsb3dlZCB3cGFzX3AycF92ZXJpZnlfODBtaHooc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICAgIHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlLAorCQkJCQkgICAgICAgdTggY2hhbm5lbCwgdTggYncpCit7CisJdTggY2VudGVyX2NoYW47CisJaW50IGksIGZsYWdzOworCWVudW0gY2hhbl9hbGxvd2VkIHJlcywgcmV0ID0gQUxMT1dFRDsKKworCWNlbnRlcl9jaGFuID0gd3Bhc19wMnBfZ2V0X2NlbnRlcl84MG1oeih3cGFfcywgbW9kZSwgY2hhbm5lbCk7CisJaWYgKCFjZW50ZXJfY2hhbikKKwkJcmV0dXJuIE5PVF9BTExPV0VEOworCWlmIChjZW50ZXJfY2hhbiA+PSA1OCAmJiBjZW50ZXJfY2hhbiA8PSAxMzgpCisJCXJldHVybiBOT1RfQUxMT1dFRDsgLyogRG8gbm90IGFsbG93IERGUyBjaGFubmVscyBmb3IgUDJQICovCisKKwkvKiBjaGVjayBhbGwgdGhlIGNoYW5uZWxzIGFyZSBhdmFpbGFibGUgKi8KKwlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKSB7CisJCWludCBhZGpfY2hhbiA9IGNlbnRlcl9jaGFuIC0gNiArIGkgKiA0OworCisJCXJlcyA9IGhhc19jaGFubmVsKHdwYV9zLT5nbG9iYWwsIG1vZGUsIGFkal9jaGFuLCAmZmxhZ3MpOworCQlpZiAocmVzID09IE5PVF9BTExPV0VEKQorCQkJcmV0dXJuIE5PVF9BTExPV0VEOworCQlpZiAocmVzID09IFBBU1NJVkVfT05MWSkKKwkJCXJldCA9IFBBU1NJVkVfT05MWTsKKworCQlpZiAoaSA9PSAwICYmICEoZmxhZ3MgJiBIT1NUQVBEX0NIQU5fVkhUXzEwXzcwKSkKKwkJCXJldHVybiBOT1RfQUxMT1dFRDsKKwkJaWYgKGkgPT0gMSAmJiAhKGZsYWdzICYgSE9TVEFQRF9DSEFOX1ZIVF8zMF81MCkpCisJCQlyZXR1cm4gTk9UX0FMTE9XRUQ7CisJCWlmIChpID09IDIgJiYgIShmbGFncyAmIEhPU1RBUERfQ0hBTl9WSFRfNTBfMzApKQorCQkJcmV0dXJuIE5PVF9BTExPV0VEOworCQlpZiAoaSA9PSAzICYmICEoZmxhZ3MgJiBIT1NUQVBEX0NIQU5fVkhUXzcwXzEwKSkKKwkJCXJldHVybiBOT1RfQUxMT1dFRDsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBlbnVtIGNoYW5fYWxsb3dlZCB3cGFzX3AycF92ZXJpZnlfY2hhbm5lbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkJIHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlLAorCQkJCQkJIHU4IGNoYW5uZWwsIHU4IGJ3KQoreworCWludCBmbGFnID0gMDsKKwllbnVtIGNoYW5fYWxsb3dlZCByZXMsIHJlczI7CisKKwlyZXMyID0gcmVzID0gaGFzX2NoYW5uZWwod3BhX3MtPmdsb2JhbCwgbW9kZSwgY2hhbm5lbCwgJmZsYWcpOworCWlmIChidyA9PSBCVzQwTUlOVVMpIHsKKwkJaWYgKCEoZmxhZyAmIEhPU1RBUERfQ0hBTl9IVDQwTUlOVVMpKQorCQkJcmV0dXJuIE5PVF9BTExPV0VEOworCQlyZXMyID0gaGFzX2NoYW5uZWwod3BhX3MtPmdsb2JhbCwgbW9kZSwgY2hhbm5lbCAtIDQsIE5VTEwpOworCX0gZWxzZSBpZiAoYncgPT0gQlc0MFBMVVMpIHsKKwkJaWYgKCEoZmxhZyAmIEhPU1RBUERfQ0hBTl9IVDQwUExVUykpCisJCQlyZXR1cm4gTk9UX0FMTE9XRUQ7CisJCXJlczIgPSBoYXNfY2hhbm5lbCh3cGFfcy0+Z2xvYmFsLCBtb2RlLCBjaGFubmVsICsgNCwgTlVMTCk7CisJfSBlbHNlIGlmIChidyA9PSBCVzgwKSB7CisJCXJlczIgPSB3cGFzX3AycF92ZXJpZnlfODBtaHood3BhX3MsIG1vZGUsIGNoYW5uZWwsIGJ3KTsKKwl9CisKKwlpZiAocmVzID09IE5PVF9BTExPV0VEIHx8IHJlczIgPT0gTk9UX0FMTE9XRUQpCisJCXJldHVybiBOT1RfQUxMT1dFRDsKKwlpZiAocmVzID09IFBBU1NJVkVfT05MWSB8fCByZXMyID09IFBBU1NJVkVfT05MWSkKKwkJcmV0dXJuIFBBU1NJVkVfT05MWTsKKwlyZXR1cm4gcmVzOwogfQogCiAKIHN0YXRpYyBpbnQgd3Bhc19wMnBfc2V0dXBfY2hhbm5lbHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgICBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFuKQorCQkJCSAgIHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW4sCisJCQkJICAgc3RydWN0IHAycF9jaGFubmVscyAqY2xpX2NoYW4pCiB7CiAJc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGU7Ci0JaW50IGNsYSwgb3A7CisJaW50IGNsYSwgb3AsIGNsaV9jbGE7CiAKIAlpZiAod3BhX3MtPmh3Lm1vZGVzID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IERyaXZlciBkaWQgbm90IHN1cHBvcnQgZmV0Y2hpbmcgIgogCQkJICAgIm9mIGFsbCBzdXBwb3J0ZWQgY2hhbm5lbHM7IGFzc3VtZSBkdWFsYmFuZCAiCiAJCQkgICAic3VwcG9ydCIpOwotCQlyZXR1cm4gd3Bhc19wMnBfZGVmYXVsdF9jaGFubmVscyh3cGFfcywgY2hhbik7CisJCXJldHVybiB3cGFzX3AycF9kZWZhdWx0X2NoYW5uZWxzKHdwYV9zLCBjaGFuLCBjbGlfY2hhbik7CiAJfQogCi0JY2xhID0gMDsKKwljbGEgPSBjbGlfY2xhID0gMDsKIAogCWZvciAob3AgPSAwOyBvcF9jbGFzc1tvcF0ub3BfY2xhc3M7IG9wKyspIHsKIAkJc3RydWN0IHAycF9vcGVyX2NsYXNzX21hcCAqbyA9ICZvcF9jbGFzc1tvcF07CiAJCXU4IGNoOwotCQlzdHJ1Y3QgcDJwX3JlZ19jbGFzcyAqcmVnID0gTlVMTDsKKwkJc3RydWN0IHAycF9yZWdfY2xhc3MgKnJlZyA9IE5VTEwsICpjbGlfcmVnID0gTlVMTDsKIAogCQltb2RlID0gZ2V0X21vZGUod3BhX3MtPmh3Lm1vZGVzLCB3cGFfcy0+aHcubnVtX21vZGVzLCBvLT5tb2RlKTsKIAkJaWYgKG1vZGUgPT0gTlVMTCkKIAkJCWNvbnRpbnVlOwogCQlmb3IgKGNoID0gby0+bWluX2NoYW47IGNoIDw9IG8tPm1heF9jaGFuOyBjaCArPSBvLT5pbmMpIHsKLQkJCWlmICh3cGFzX3AycF92ZXJpZnlfY2hhbm5lbCh3cGFfcywgbW9kZSwgY2gsIG8tPmJ3KSA8IDEpCi0JCQkJY29udGludWU7Ci0JCQlpZiAocmVnID09IE5VTEwpIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQWRkIG9wZXJhdGluZyAiCi0JCQkJCSAgICJjbGFzcyAldSIsIG8tPm9wX2NsYXNzKTsKLQkJCQlyZWcgPSAmY2hhbi0+cmVnX2NsYXNzW2NsYV07Ci0JCQkJY2xhKys7Ci0JCQkJcmVnLT5yZWdfY2xhc3MgPSBvLT5vcF9jbGFzczsKKwkJCWVudW0gY2hhbl9hbGxvd2VkIHJlczsKKwkJCXJlcyA9IHdwYXNfcDJwX3ZlcmlmeV9jaGFubmVsKHdwYV9zLCBtb2RlLCBjaCwgby0+YncpOworCQkJaWYgKHJlcyA9PSBBTExPV0VEKSB7CisJCQkJaWYgKHJlZyA9PSBOVUxMKSB7CisJCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBBZGQgb3BlcmF0aW5nIGNsYXNzICV1IiwKKwkJCQkJCSAgIG8tPm9wX2NsYXNzKTsKKwkJCQkJcmVnID0gJmNoYW4tPnJlZ19jbGFzc1tjbGFdOworCQkJCQljbGErKzsKKwkJCQkJcmVnLT5yZWdfY2xhc3MgPSBvLT5vcF9jbGFzczsKKwkJCQl9CisJCQkJcmVnLT5jaGFubmVsW3JlZy0+Y2hhbm5lbHNdID0gY2g7CisJCQkJcmVnLT5jaGFubmVscysrOworCQkJfSBlbHNlIGlmIChyZXMgPT0gUEFTU0lWRV9PTkxZICYmCisJCQkJICAgd3BhX3MtPmNvbmYtPnAycF9hZGRfY2xpX2NoYW4pIHsKKwkJCQlpZiAoY2xpX3JlZyA9PSBOVUxMKSB7CisJCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBBZGQgb3BlcmF0aW5nIGNsYXNzICV1IChjbGllbnQgb25seSkiLAorCQkJCQkJICAgby0+b3BfY2xhc3MpOworCQkJCQljbGlfcmVnID0gJmNsaV9jaGFuLT5yZWdfY2xhc3NbY2xpX2NsYV07CisJCQkJCWNsaV9jbGErKzsKKwkJCQkJY2xpX3JlZy0+cmVnX2NsYXNzID0gby0+b3BfY2xhc3M7CisJCQkJfQorCQkJCWNsaV9yZWctPmNoYW5uZWxbY2xpX3JlZy0+Y2hhbm5lbHNdID0gY2g7CisJCQkJY2xpX3JlZy0+Y2hhbm5lbHMrKzsKIAkJCX0KLQkJCXJlZy0+Y2hhbm5lbFtyZWctPmNoYW5uZWxzXSA9IGNoOwotCQkJcmVnLT5jaGFubmVscysrOwogCQl9CiAJCWlmIChyZWcpIHsKIAkJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlAyUDogQ2hhbm5lbHMiLAogCQkJCSAgICByZWctPmNoYW5uZWwsIHJlZy0+Y2hhbm5lbHMpOwogCQl9CisJCWlmIChjbGlfcmVnKSB7CisJCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJQMlA6IENoYW5uZWxzIChjbGllbnQgb25seSkiLAorCQkJCSAgICBjbGlfcmVnLT5jaGFubmVsLCBjbGlfcmVnLT5jaGFubmVscyk7CisJCX0KIAl9CiAKIAljaGFuLT5yZWdfY2xhc3NlcyA9IGNsYTsKKwljbGlfY2hhbi0+cmVnX2NsYXNzZXMgPSBjbGlfY2xhOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0zMTA1LDcgKzM2NTQsOCBAQAogaW50IHdwYXNfcDJwX2dldF9odDQwX21vZGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgIHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlLCB1OCBjaGFubmVsKQogewotCWludCBvcCwgcmV0OworCWludCBvcDsKKwllbnVtIGNoYW5fYWxsb3dlZCByZXQ7CiAKIAlmb3IgKG9wID0gMDsgb3BfY2xhc3Nbb3BdLm9wX2NsYXNzOyBvcCsrKSB7CiAJCXN0cnVjdCBwMnBfb3Blcl9jbGFzc19tYXAgKm8gPSAmb3BfY2xhc3Nbb3BdOwpAQCAtMzExNiwxOCArMzY2NiwyNCBAQAogCQkJICAgIG8tPmJ3ID09IEJXMjAgfHwgY2ggIT0gY2hhbm5lbCkKIAkJCQljb250aW51ZTsKIAkJCXJldCA9IHdwYXNfcDJwX3ZlcmlmeV9jaGFubmVsKHdwYV9zLCBtb2RlLCBjaCwgby0+YncpOwotCQkJaWYgKHJldCA8IDApCi0JCQkJY29udGludWU7Ci0JCQllbHNlIGlmIChyZXQgPiAwKQorCQkJaWYgKHJldCA9PSBBTExPV0VEKQogCQkJCXJldHVybiAoby0+YncgPT0gQlc0ME1JTlVTKSA/IC0xIDogMTsKLQkJCWVsc2UKLQkJCQlyZXR1cm4gMDsKIAkJfQogCX0KIAlyZXR1cm4gMDsKIH0KIAogCitpbnQgd3Bhc19wMnBfZ2V0X3ZodDgwX2NlbnRlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJICAgICAgc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGUsIHU4IGNoYW5uZWwpCit7CisJaWYgKCF3cGFzX3AycF92ZXJpZnlfY2hhbm5lbCh3cGFfcywgbW9kZSwgY2hhbm5lbCwgQlc4MCkpCisJCXJldHVybiAwOworCisJcmV0dXJuIHdwYXNfcDJwX2dldF9jZW50ZXJfODBtaHood3BhX3MsIG1vZGUsIGNoYW5uZWwpOworfQorCisKIHN0YXRpYyBpbnQgd3Bhc19nZXRfbm9hKHZvaWQgKmN0eCwgY29uc3QgdTggKmludGVyZmFjZV9hZGRyLCB1OCAqYnVmLAogCQkJc2l6ZV90IGJ1Zl9sZW4pCiB7CkBAIC0zMTQ0LDEwICszNzAwLDMxIEBACiB9CiAKIAotc3RhdGljIGludCB3cGFzX2dvX2Nvbm5lY3RlZCh2b2lkICpjdHgsIGNvbnN0IHU4ICpkZXZfYWRkcikKK3N0cnVjdCB3cGFfc3VwcGxpY2FudCAqIHdwYXNfZ2V0X3AycF9nb19pZmFjZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgICBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuKQogewotCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CisJZm9yICh3cGFfcyA9IHdwYV9zLT5nbG9iYWwtPmlmYWNlczsgd3BhX3M7IHdwYV9zID0gd3BhX3MtPm5leHQpIHsKKwkJc3RydWN0IHdwYV9zc2lkICpzID0gd3BhX3MtPmN1cnJlbnRfc3NpZDsKKwkJaWYgKHMgPT0gTlVMTCkKKwkJCWNvbnRpbnVlOworCQlpZiAocy0+bW9kZSAhPSBXUEFTX01PREVfUDJQX0dPICYmCisJCSAgICBzLT5tb2RlICE9IFdQQVNfTU9ERV9BUCAmJgorCQkgICAgcy0+bW9kZSAhPSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTikKKwkJCWNvbnRpbnVlOworCQlpZiAocy0+c3NpZF9sZW4gIT0gc3NpZF9sZW4gfHwKKwkJICAgIG9zX21lbWNtcChzc2lkLCBzLT5zc2lkLCBzc2lkX2xlbikgIT0gMCkKKwkJCWNvbnRpbnVlOworCQlyZXR1cm4gd3BhX3M7CisJfQogCisJcmV0dXJuIE5VTEw7CisKK30KKworCitzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKiB3cGFzX2dldF9wMnBfY2xpZW50X2lmYWNlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQkgIGNvbnN0IHU4ICpwZWVyX2Rldl9hZGRyKQorewogCWZvciAod3BhX3MgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IHdwYV9zOyB3cGFfcyA9IHdwYV9zLT5uZXh0KSB7CiAJCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CiAJCWlmIChzc2lkID09IE5VTEwpCkBAIC0zMTU3LDEwICszNzM0LDMzIEBACiAJCWlmICh3cGFfcy0+d3BhX3N0YXRlICE9IFdQQV9DT01QTEVURUQgJiYKIAkJICAgIHdwYV9zLT53cGFfc3RhdGUgIT0gV1BBX0dST1VQX0hBTkRTSEFLRSkKIAkJCWNvbnRpbnVlOwotCQlpZiAob3NfbWVtY21wKHdwYV9zLT5nb19kZXZfYWRkciwgZGV2X2FkZHIsIEVUSF9BTEVOKSA9PSAwKQotCQkJcmV0dXJuIDE7CisJCWlmIChvc19tZW1jbXAod3BhX3MtPmdvX2Rldl9hZGRyLCBwZWVyX2Rldl9hZGRyLCBFVEhfQUxFTikgPT0gMCkKKwkJCXJldHVybiB3cGFfczsKIAl9CiAKKwlyZXR1cm4gTlVMTDsKK30KKworCitzdGF0aWMgaW50IHdwYXNfZ29fY29ubmVjdGVkKHZvaWQgKmN0eCwgY29uc3QgdTggKmRldl9hZGRyKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CisKKwlyZXR1cm4gd3Bhc19nZXRfcDJwX2NsaWVudF9pZmFjZSh3cGFfcywgZGV2X2FkZHIpICE9IE5VTEw7Cit9CisKKworc3RhdGljIGludCB3cGFzX2lzX2NvbmN1cnJlbnRfc2Vzc2lvbl9hY3RpdmUodm9pZCAqY3R4KQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICppZnM7CisKKwlmb3IgKGlmcyA9IHdwYV9zLT5nbG9iYWwtPmlmYWNlczsgaWZzOyBpZnMgPSBpZnMtPm5leHQpIHsKKwkJaWYgKGlmcyA9PSB3cGFfcykKKwkJCWNvbnRpbnVlOworCQlpZiAoaWZzLT53cGFfc3RhdGUgPiBXUEFfQVNTT0NJQVRFRCkKKwkJCXJldHVybiAxOworCX0KIAlyZXR1cm4gMDsKIH0KIApAQCAtMzE5OCw3ICszNzk4LDIwIEBACiAJaWZhY2UuaWZuYW1lID0gd3BhX3MtPnBlbmRpbmdfaW50ZXJmYWNlX25hbWU7CiAJaWZhY2UuZHJpdmVyID0gd3BhX3MtPmRyaXZlci0+bmFtZTsKIAlpZmFjZS5kcml2ZXJfcGFyYW0gPSB3cGFfcy0+Y29uZi0+ZHJpdmVyX3BhcmFtOwotCWlmYWNlLmNvbmZuYW1lID0gd3BhX3MtPmNvbmZuYW1lOworCisJLyoKKwkgKiBJZiBhIFAyUCBEZXZpY2UgY29uZmlndXJhdGlvbiBmaWxlIHdhcyBnaXZlbiwgdXNlIGl0IGFzIHRoZSBpbnRlcmZhY2UKKwkgKiBjb25maWd1cmF0aW9uIGZpbGUgKGluc3RlYWQgb2YgdXNpbmcgcGFyZW50J3MgY29uZmlndXJhdGlvbiBmaWxlLgorCSAqLworCWlmICh3cGFfcy0+Y29uZl9wMnBfZGV2KSB7CisJCWlmYWNlLmNvbmZuYW1lID0gd3BhX3MtPmNvbmZfcDJwX2RldjsKKwkJaWZhY2UuY3RybF9pbnRlcmZhY2UgPSBOVUxMOworCX0gZWxzZSB7CisJCWlmYWNlLmNvbmZuYW1lID0gd3BhX3MtPmNvbmZuYW1lOworCQlpZmFjZS5jdHJsX2ludGVyZmFjZSA9IHdwYV9zLT5jb25mLT5jdHJsX2ludGVyZmFjZTsKKwl9CisJaWZhY2UuY29uZl9wMnBfZGV2ID0gTlVMTDsKKwogCXAycGRldl93cGFfcyA9IHdwYV9zdXBwbGljYW50X2FkZF9pZmFjZSh3cGFfcy0+Z2xvYmFsLCAmaWZhY2UpOwogCWlmICghcDJwZGV2X3dwYV9zKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGYWlsZWQgdG8gYWRkIFAyUCBEZXZpY2UgaW50ZXJmYWNlIik7CkBAIC0zMjExLDYgKzM4MjQsMzUgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFzX3ByZXNlbmNlX3Jlc3Aodm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjLCB1OCBzdGF0dXMsCisJCQkgICAgICAgY29uc3QgdTggKm5vYSwgc2l6ZV90IG5vYV9sZW4pCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgKmludGYgPSBjdHg7CisJY2hhciBoZXhbMTAwXTsKKworCWZvciAod3BhX3MgPSBpbnRmLT5nbG9iYWwtPmlmYWNlczsgd3BhX3M7IHdwYV9zID0gd3BhX3MtPm5leHQpIHsKKwkJaWYgKHdwYV9zLT53YWl0aW5nX3ByZXNlbmNlX3Jlc3ApCisJCQlicmVhazsKKwl9CisJaWYgKCF3cGFfcykgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IE5vIGdyb3VwIGludGVyZmFjZSB3YXMgd2FpdGluZyBmb3IgcHJlc2VuY2UgcmVzcG9uc2UiKTsKKwkJcmV0dXJuOworCX0KKwl3cGFfcy0+d2FpdGluZ19wcmVzZW5jZV9yZXNwID0gMDsKKworCXdwYV9zbnByaW50Zl9oZXgoaGV4LCBzaXplb2YoaGV4KSwgbm9hLCBub2FfbGVuKTsKKwl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgUDJQX0VWRU5UX1BSRVNFTkNFX1JFU1BPTlNFICJzcmM9IiBNQUNTVFIKKwkJIiBzdGF0dXM9JXUgbm9hPSVzIiwgTUFDMlNUUihzcmMpLCBzdGF0dXMsIGhleCk7Cit9CisKKworc3RhdGljIGludCBfd3Bhc19wMnBfaW5fcHJvZ3Jlc3Modm9pZCAqY3R4KQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CisJcmV0dXJuIHdwYXNfcDJwX2luX3Byb2dyZXNzKHdwYV9zKTsKK30KKworCiAvKioKICAqIHdwYXNfcDJwX2luaXQgLSBJbml0aWFsaXplIFAyUCBtb2R1bGUgZm9yICV3cGFfc3VwcGxpY2FudAogICogQGdsb2JhbDogUG9pbnRlciB0byBnbG9iYWwgZGF0YSBmcm9tIHdwYV9zdXBwbGljYW50X2luaXQoKQpAQCAtMzIzMiwyNSArMzg3NCw2IEBACiAJaWYgKGdsb2JhbC0+cDJwKQogCQlyZXR1cm4gMDsKIAotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkgewotCQlzdHJ1Y3QgcDJwX3BhcmFtcyBwYXJhbXM7Ci0KLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFVzZSBkcml2ZXItYmFzZWQgUDJQIG1hbmFnZW1lbnQiKTsKLQkJb3NfbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKLQkJcGFyYW1zLmRldl9uYW1lID0gd3BhX3MtPmNvbmYtPmRldmljZV9uYW1lOwotCQlvc19tZW1jcHkocGFyYW1zLnByaV9kZXZfdHlwZSwgd3BhX3MtPmNvbmYtPmRldmljZV90eXBlLAotCQkJICBXUFNfREVWX1RZUEVfTEVOKTsKLQkJcGFyYW1zLm51bV9zZWNfZGV2X3R5cGVzID0gd3BhX3MtPmNvbmYtPm51bV9zZWNfZGV2aWNlX3R5cGVzOwotCQlvc19tZW1jcHkocGFyYW1zLnNlY19kZXZfdHlwZSwKLQkJCSAgd3BhX3MtPmNvbmYtPnNlY19kZXZpY2VfdHlwZSwKLQkJCSAgcGFyYW1zLm51bV9zZWNfZGV2X3R5cGVzICogV1BTX0RFVl9UWVBFX0xFTik7Ci0KLQkJaWYgKHdwYV9kcnZfcDJwX3NldF9wYXJhbXMod3BhX3MsICZwYXJhbXMpIDwgMCkKLQkJCXJldHVybiAtMTsKLQotCQlyZXR1cm4gMDsKLQl9Ci0KIAlvc19tZW1zZXQoJnAycCwgMCwgc2l6ZW9mKHAycCkpOwogCXAycC5jYl9jdHggPSB3cGFfczsKIAlwMnAuZGVidWdfcHJpbnQgPSB3cGFzX3AycF9kZWJ1Z19wcmludDsKQEAgLTMyNzUsNiArMzg5OCw5IEBACiAJcDJwLmludml0YXRpb25fcmVzdWx0ID0gd3Bhc19pbnZpdGF0aW9uX3Jlc3VsdDsKIAlwMnAuZ2V0X25vYSA9IHdwYXNfZ2V0X25vYTsKIAlwMnAuZ29fY29ubmVjdGVkID0gd3Bhc19nb19jb25uZWN0ZWQ7CisJcDJwLnByZXNlbmNlX3Jlc3AgPSB3cGFzX3ByZXNlbmNlX3Jlc3A7CisJcDJwLmlzX2NvbmN1cnJlbnRfc2Vzc2lvbl9hY3RpdmUgPSB3cGFzX2lzX2NvbmN1cnJlbnRfc2Vzc2lvbl9hY3RpdmU7CisJcDJwLmlzX3AycF9pbl9wcm9ncmVzcyA9IF93cGFzX3AycF9pbl9wcm9ncmVzczsKIAogCW9zX21lbWNweSh3cGFfcy0+Z2xvYmFsLT5wMnBfZGV2X2FkZHIsIHdwYV9zLT5vd25fYWRkciwgRVRIX0FMRU4pOwogCW9zX21lbWNweShwMnAuZGV2X2FkZHIsIHdwYV9zLT5nbG9iYWwtPnAycF9kZXZfYWRkciwgRVRIX0FMRU4pOwpAQCAtMzI5Miw2ICszOTE4LDcgQEAKIAkgICAgd3BhX3MtPmNvbmYtPnAycF9saXN0ZW5fY2hhbm5lbCkgewogCQlwMnAucmVnX2NsYXNzID0gd3BhX3MtPmNvbmYtPnAycF9saXN0ZW5fcmVnX2NsYXNzOwogCQlwMnAuY2hhbm5lbCA9IHdwYV9zLT5jb25mLT5wMnBfbGlzdGVuX2NoYW5uZWw7CisJCXAycC5jaGFubmVsX2ZvcmNlZCA9IDE7CiAJfSBlbHNlIHsKIAkJcDJwLnJlZ19jbGFzcyA9IDgxOwogCQkvKgpAQCAtMzMwMCw2ICszOTI3LDcgQEAKIAkJICovCiAJCW9zX2dldF9yYW5kb20oKHU4ICopICZyLCBzaXplb2YocikpOwogCQlwMnAuY2hhbm5lbCA9IDEgKyAociAlIDMpICogNTsKKwkJcDJwLmNoYW5uZWxfZm9yY2VkID0gMDsKIAl9CiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IE93biBsaXN0ZW4gY2hhbm5lbDogJWQiLCBwMnAuY2hhbm5lbCk7CiAKQEAgLTMzMzUsNyArMzk2Myw3IEBACiAJfSBlbHNlCiAJCW9zX21lbWNweShwMnAuY291bnRyeSwgIlhYXHgwNCIsIDMpOwogCi0JaWYgKHdwYXNfcDJwX3NldHVwX2NoYW5uZWxzKHdwYV9zLCAmcDJwLmNoYW5uZWxzKSkgeworCWlmICh3cGFzX3AycF9zZXR1cF9jaGFubmVscyh3cGFfcywgJnAycC5jaGFubmVscywgJnAycC5jbGlfY2hhbm5lbHMpKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUDJQOiBGYWlsZWQgdG8gY29uZmlndXJlIHN1cHBvcnRlZCAiCiAJCQkgICAiY2hhbm5lbCBsaXN0Iik7CiAJCXJldHVybiAtMTsKQEAgLTMzNjYsNiArMzk5NCwxMiBAQAogCiAJcDJwLm1heF9saXN0ZW4gPSB3cGFfcy0+bWF4X3JlbWFpbl9vbl9jaGFuOwogCisJaWYgKHdwYV9zLT5jb25mLT5wMnBfcGFzc3BocmFzZV9sZW4gPj0gOCAmJgorCSAgICB3cGFfcy0+Y29uZi0+cDJwX3Bhc3NwaHJhc2VfbGVuIDw9IDYzKQorCQlwMnAucGFzc3BocmFzZV9sZW4gPSB3cGFfcy0+Y29uZi0+cDJwX3Bhc3NwaHJhc2VfbGVuOworCWVsc2UKKwkJcDJwLnBhc3NwaHJhc2VfbGVuID0gODsKKwogCWdsb2JhbC0+cDJwID0gcDJwX2luaXQoJnAycCk7CiAJaWYgKGdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybiAtMTsKQEAgLTMzNzgsNiArNDAxMiw4IEBACiAJCQlnbG9iYWwtPnAycCwgd3BhX3MtPmNvbmYtPndwc192ZW5kb3JfZXh0W2ldKTsKIAl9CiAKKwlwMnBfc2V0X25vX2dvX2ZyZXEoZ2xvYmFsLT5wMnAsICZ3cGFfcy0+Y29uZi0+cDJwX25vX2dvX2ZyZXEpOworCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTM0MDIsMTUgKzQwMzgsMjQgQEAKIAogCW9zX2ZyZWUod3BhX3MtPmdvX3BhcmFtcyk7CiAJd3BhX3MtPmdvX3BhcmFtcyA9IE5VTEw7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9ncm91cF9mcmVxX2NvbmZsaWN0LCB3cGFfcywgTlVMTCk7Ci0jZW5kaWYKKwllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9wc2tfZmFpbHVyZV9yZW1vdmFsLCB3cGFfcywgTlVMTCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsIHdwYV9zLCBOVUxMKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9qb2luX3NjYW4sIHdwYV9zLCBOVUxMKTsKIAl3cGFfcy0+cDJwX2xvbmdfbGlzdGVuID0gMDsKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9sb25nX2xpc3Rlbl90aW1lb3V0LCB3cGFfcywgTlVMTCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfaWRsZV90aW1lb3V0LCB3cGFfcywgTlVMTCk7CiAJd3Bhc19wMnBfcmVtb3ZlX3BlbmRpbmdfZ3JvdXBfaW50ZXJmYWNlKHdwYV9zKTsKKwllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9ncm91cF9mcmVxX2NvbmZsaWN0LCB3cGFfcywgTlVMTCk7CisJd3Bhc19wMnBfbGlzdGVuX3dvcmtfZG9uZSh3cGFfcyk7CisJaWYgKHdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yaykgeworCQlvc19mcmVlKHdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yay0+Y3R4KTsKKwkJcmFkaW9fd29ya19kb25lKHdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yayk7CisJCXdwYV9zLT5wMnBfc2VuZF9hY3Rpb25fd29yayA9IE5VTEw7CisJfQorCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX3NlbmRfYWN0aW9uX3dvcmtfdGltZW91dCwgd3BhX3MsIE5VTEwpOworCisJd3BhYnVmX2ZyZWUod3BhX3MtPnAycF9vb2JfZGV2X3B3KTsKKwl3cGFfcy0+cDJwX29vYl9kZXZfcHcgPSBOVUxMOwogCiAJLyogVE9ETzogcmVtb3ZlIGdyb3VwIGludGVyZmFjZSBmcm9tIHRoZSBkcml2ZXIgaWYgdGhpcyB3cGFfcyBpbnN0YW5jZQogCSAqIGlzIG9uIHRvcCBvZiBhIFAyUCBncm91cCBpbnRlcmZhY2UgKi8KQEAgLTM0MjMsNyArNDA2OCw3IEBACiAgKgogICogVGhpcyBmdW5jdGlvbiBkZWluaXRpYWxpemVzIHRoZSBnbG9iYWwgKHBlciBkZXZpY2UpIFAyUCBtb2R1bGUuCiAgKi8KLXZvaWQgd3Bhc19wMnBfZGVpbml0X2dsb2JhbChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsKQorc3RhdGljIHZvaWQgd3Bhc19wMnBfZGVpbml0X2dsb2JhbChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsKQogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsICp0bXA7CiAKQEAgLTM0OTUsMTIgKzQxNDAsNiBAQAogCWlmIChwZXJzaXN0ZW50X2dyb3VwICYmIHdwYV9zLT5jb25mLT5wZXJzaXN0ZW50X3JlY29ubmVjdCkKIAkJcGVyc2lzdGVudF9ncm91cCA9IDI7CiAKLQlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQpIHsKLQkJcmV0dXJuIHdwYV9kcnZfcDJwX2Nvbm5lY3Qod3BhX3MsIHBlZXJfYWRkciwgd3BzX21ldGhvZCwKLQkJCQkJICAgZ29faW50ZW50LCBvd25faW50ZXJmYWNlX2FkZHIsCi0JCQkJCSAgIGZvcmNlX2ZyZXEsIHBlcnNpc3RlbnRfZ3JvdXApOwotCX0KLQogCS8qCiAJICogSW5jcmVhc2UgR08gY29uZmlnIHRpbWVvdXQgaWYgSFQ0MCBpcyB1c2VkIHNpbmNlIGl0IHRha2VzIHNvbWUgdGltZQogCSAqIHRvIHNjYW4gY2hhbm5lbHMgZm9yIGNvZXggcHVycG9zZXMgYmVmb3JlIHRoZSBCU1MgY2FuIGJlIHN0YXJ0ZWQuCkBAIC0zNTEyLDcgKzQxNTEsOSBAQAogCQkJICAgZ29faW50ZW50LCBvd25faW50ZXJmYWNlX2FkZHIsIGZvcmNlX2ZyZXEsCiAJCQkgICBwZXJzaXN0ZW50X2dyb3VwLCBzc2lkID8gc3NpZC0+c3NpZCA6IE5VTEwsCiAJCQkgICBzc2lkID8gc3NpZC0+c3NpZF9sZW4gOiAwLAotCQkJICAgd3BhX3MtPnAycF9wZF9iZWZvcmVfZ29fbmVnLCBwcmVmX2ZyZXEpOworCQkJICAgd3BhX3MtPnAycF9wZF9iZWZvcmVfZ29fbmVnLCBwcmVmX2ZyZXEsCisJCQkgICB3cHNfbWV0aG9kID09IFdQU19ORkMgPyB3cGFfcy0+cDJwX29vYl9kZXZfcHdfaWQgOgorCQkJICAgMCk7CiB9CiAKIApAQCAtMzUyNiwxMyArNDE2NywxMiBAQAogCWlmIChwZXJzaXN0ZW50X2dyb3VwICYmIHdwYV9zLT5jb25mLT5wZXJzaXN0ZW50X3JlY29ubmVjdCkKIAkJcGVyc2lzdGVudF9ncm91cCA9IDI7CiAKLQlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQpCi0JCXJldHVybiAtMTsKLQogCXJldHVybiBwMnBfYXV0aG9yaXplKHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyLCB3cHNfbWV0aG9kLAogCQkJICAgICBnb19pbnRlbnQsIG93bl9pbnRlcmZhY2VfYWRkciwgZm9yY2VfZnJlcSwKIAkJCSAgICAgcGVyc2lzdGVudF9ncm91cCwgc3NpZCA/IHNzaWQtPnNzaWQgOiBOVUxMLAotCQkJICAgICBzc2lkID8gc3NpZC0+c3NpZF9sZW4gOiAwLCBwcmVmX2ZyZXEpOworCQkJICAgICBzc2lkID8gc3NpZC0+c3NpZF9sZW4gOiAwLCBwcmVmX2ZyZXEsCisJCQkgICAgIHdwc19tZXRob2QgPT0gV1BTX05GQyA/IHdwYV9zLT5wMnBfb29iX2Rldl9wd19pZCA6CisJCQkgICAgIDApOwogfQogCiAKQEAgLTM1NjIsMjYgKzQyMDIsMjUgQEAKIAogc3RhdGljIGludCB3cGFzX2NoZWNrX2ZyZXFfY29uZmxpY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEpCiB7Ci0JaW50ICpmcmVxcywgcmVzLCBudW0sIGk7CisJaW50IHJlczsKKwl1bnNpZ25lZCBpbnQgbnVtLCBpOworCXN0cnVjdCB3cGFfdXNlZF9mcmVxX2RhdGEgKmZyZXFzOwogCiAJaWYgKHdwYXNfcDJwX251bV91bnVzZWRfY2hhbm5lbHMod3BhX3MpID4gMCkgewogCQkvKiBNdWx0aXBsZSBjaGFubmVscyBhcmUgc3VwcG9ydGVkIGFuZCBub3QgYWxsIGFyZSBpbiB1c2UgKi8KIAkJcmV0dXJuIDA7CiAJfQogCi0JZnJlcXMgPSBvc19jYWxsb2Mod3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCwgc2l6ZW9mKGludCkpOworCWZyZXFzID0gb3NfY2FsbG9jKHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQsCisJCQkgIHNpemVvZihzdHJ1Y3Qgd3BhX3VzZWRfZnJlcV9kYXRhKSk7CiAJaWYgKCFmcmVxcykKIAkJcmV0dXJuIDE7CiAKIAludW0gPSB3cGFzX3AycF92YWxpZF9vcGVyX2ZyZXFzKHdwYV9zLCBmcmVxcywKIAkJCQkJd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCk7Ci0JaWYgKG51bSA8IDApIHsKLQkJcmVzID0gMTsKLQkJZ290byBleGl0X2ZyZWU7Ci0JfQogCiAJZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKSB7Ci0JCWlmIChmcmVxc1tpXSA9PSBmcmVxKSB7CisJCWlmIChmcmVxc1tpXS5mcmVxID09IGZyZXEpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGcmVxdWVuY3kgJWQgTUh6IGluIHVzZSBieSBhbm90aGVyIHZpcnR1YWwgaW50ZXJmYWNlIGFuZCBjYW4gYmUgdXNlZCIsCiAJCQkJICAgZnJlcSk7CiAJCQlyZXMgPSAwOwpAQCAtMzU4OSw2ICs0MjI4LDcgQEAKIAkJfQogCX0KIAorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBObyB2YWxpZCBvcGVyYXRpbmcgZnJlcXVlbmNpZXMiKTsKIAlyZXMgPSAxOwogCiBleGl0X2ZyZWU6CkBAIC0zNjEyLDcgKzQyNTIsOCBAQAogCQlyZXR1cm4gMDsKIAl9CiAKLQl1cGRhdGVkID0gb3NfdGltZV9iZWZvcmUoJndwYV9zLT5wMnBfYXV0b19zdGFydGVkLCAmYnNzLT5sYXN0X3VwZGF0ZSk7CisJdXBkYXRlZCA9IG9zX3JlbHRpbWVfYmVmb3JlKCZ3cGFfcy0+cDJwX2F1dG9fc3RhcnRlZCwKKwkJCQkgICAgJmJzcy0+bGFzdF91cGRhdGUpOwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDdXJyZW50IEJTUyBlbnRyeSBmb3IgcGVlciB1cGRhdGVkIGF0ICIKIAkJICAgIiVsZC4lMDZsZCAoJXN1cGRhdGVkIGluIGxhc3Qgc2NhbikiLAogCQkgICBic3MtPmxhc3RfdXBkYXRlLnNlYywgYnNzLT5sYXN0X3VwZGF0ZS51c2VjLApAQCAtMzYyNSw3ICs0MjY2LDcgQEAKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX3NjYW5fcmVzX2pvaW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICBzdHJ1Y3Qgd3BhX3NjYW5fcmVzdWx0cyAqc2Nhbl9yZXMpCiB7Ci0Jc3RydWN0IHdwYV9ic3MgKmJzczsKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gTlVMTDsKIAlpbnQgZnJlcTsKIAl1OCBpZmFjZV9hZGRyW0VUSF9BTEVOXTsKIApAQCAtMzY1Nyw3ICs0Mjk4LDcgQEAKIAkJCQkJICAgTUFDMlNUUih3cGFfcy0+CiAJCQkJCQkgICBwZW5kaW5nX2pvaW5fZGV2X2FkZHIpLAogCQkJCQkgICBmcmVxKTsKLQkJCQl3cGFzX3AycF9qb2luX3NjYW5fcmVxKHdwYV9zLCBmcmVxKTsKKwkJCQl3cGFzX3AycF9qb2luX3NjYW5fcmVxKHdwYV9zLCBmcmVxLCBOVUxMLCAwKTsKIAkJCQlyZXR1cm47CiAJCQl9CiAJCX0KQEAgLTM2OTUsNyArNDMzNiw4IEBACiAJCQkJCSB3cGFfcy0+cDJwX2Nvbm5lY3RfZnJlcSwKIAkJCQkJIHdwYV9zLT5wMnBfcGVyc2lzdGVudF9pZCwKIAkJCQkJIHdwYV9zLT5wMnBfcGRfYmVmb3JlX2dvX25lZywKLQkJCQkJIHdwYV9zLT5wMnBfZ29faHQ0MCk7CisJCQkJCSB3cGFfcy0+cDJwX2dvX2h0NDAsCisJCQkJCSB3cGFfcy0+cDJwX2dvX3ZodCk7CiAJCQlyZXR1cm47CiAJCX0KIApAQCAtMzcyOSwxMSArNDM3MSwyNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVGFyZ2V0IEdPIG9wZXJhdGluZyBmcmVxdWVuY3kgIgogCQkJICAgImZyb20gUDJQIHBlZXIgdGFibGU6ICVkIE1IeiIsIGZyZXEpOwogCX0KLQlic3MgPSB3cGFfYnNzX2dldF9ic3NpZF9sYXRlc3Qod3BhX3MsIHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkcik7CisJaWYgKHdwYV9zLT5wMnBfam9pbl9zc2lkX2xlbikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVHJ5aW5nIHRvIGZpbmQgdGFyZ2V0IEdPIEJTUyBlbnRyeSBiYXNlZCBvbiBCU1NJRCAiCisJCQkgICBNQUNTVFIgIiBhbmQgU1NJRCAlcyIsCisJCQkgICBNQUMyU1RSKHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkciksCisJCQkgICB3cGFfc3NpZF90eHQod3BhX3MtPnAycF9qb2luX3NzaWQsCisJCQkJCXdwYV9zLT5wMnBfam9pbl9zc2lkX2xlbikpOworCQlic3MgPSB3cGFfYnNzX2dldCh3cGFfcywgd3BhX3MtPnBlbmRpbmdfam9pbl9pZmFjZV9hZGRyLAorCQkJCSAgd3BhX3MtPnAycF9qb2luX3NzaWQsCisJCQkJICB3cGFfcy0+cDJwX2pvaW5fc3NpZF9sZW4pOworCX0KKwlpZiAoIWJzcykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVHJ5aW5nIHRvIGZpbmQgdGFyZ2V0IEdPIEJTUyBlbnRyeSBiYXNlZCBvbiBCU1NJRCAiCisJCQkgICBNQUNTVFIsIE1BQzJTVFIod3BhX3MtPnBlbmRpbmdfam9pbl9pZmFjZV9hZGRyKSk7CisJCWJzcyA9IHdwYV9ic3NfZ2V0X2Jzc2lkX2xhdGVzdCh3cGFfcywKKwkJCQkJICAgICAgIHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkcik7CisJfQogCWlmIChic3MpIHsKIAkJZnJlcSA9IGJzcy0+ZnJlcTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRhcmdldCBHTyBvcGVyYXRpbmcgZnJlcXVlbmN5ICIKLQkJCSAgICJmcm9tIEJTUyB0YWJsZTogJWQgTUh6IiwgZnJlcSk7CisJCQkgICAiZnJvbSBCU1MgdGFibGU6ICVkIE1IeiAoU1NJRCAlcykiLCBmcmVxLAorCQkJICAgd3BhX3NzaWRfdHh0KGJzcy0+c3NpZCwgYnNzLT5zc2lkX2xlbikpOwogCX0KIAlpZiAoZnJlcSA+IDApIHsKIAkJdTE2IG1ldGhvZDsKQEAgLTM4MDEsMzQgKzQ0NTksMzMgQEAKIAogc3RhcnQ6CiAJLyogU3RhcnQgam9pbiBvcGVyYXRpb24gaW1tZWRpYXRlbHkgKi8KLQl3cGFzX3AycF9qb2luX3N0YXJ0KHdwYV9zKTsKKwl3cGFzX3AycF9qb2luX3N0YXJ0KHdwYV9zLCAwLCBOVUxMLCAwKTsKIH0KIAogCi1zdGF0aWMgdm9pZCB3cGFzX3AycF9qb2luX3NjYW5fcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBmcmVxKQorc3RhdGljIHZvaWQgd3Bhc19wMnBfam9pbl9zY2FuX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgZnJlcSwKKwkJCQkgICBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuKQogewogCWludCByZXQ7CiAJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgcGFyYW1zOwogCXN0cnVjdCB3cGFidWYgKndwc19pZSwgKmllczsKIAlzaXplX3QgaWVsZW47CiAJaW50IGZyZXFzWzJdID0geyAwLCAwIH07Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQlpbnQgb3Blcl9mcmVxOwogCi0JLyogSWYgZnJlcSBpcyBub3QgcHJvdmlkZWQsIGNoZWNrIHRoZSBvcGVyYXRpbmcgZnJlcSBvZiB0aGUgR08gYW5kIGRvIGEKLQkgKiBhIGRpcmVjdGVkIHNjYW4gdG8gc2F2ZSB0aW1lCi0JICovCi0JaWYoIWZyZXEpIHsKLQkJZnJlcSA9IChvcGVyX2ZyZXEgPSBwMnBfZ2V0X29wZXJfZnJlcSh3cGFfcy0+Z2xvYmFsLT5wMnAsCi0JCQkgd3BhX3MtPnBlbmRpbmdfam9pbl9pZmFjZV9hZGRyKSA9PSAtMSkgPyAwIDogb3Blcl9mcmVxOyAKLQl9Ci0jZW5kaWYKIAlvc19tZW1zZXQoJnBhcmFtcywgMCwgc2l6ZW9mKHBhcmFtcykpOwogCiAJLyogUDJQIFdpbGRjYXJkIFNTSUQgKi8KIAlwYXJhbXMubnVtX3NzaWRzID0gMTsKLQlwYXJhbXMuc3NpZHNbMF0uc3NpZCA9ICh1OCAqKSBQMlBfV0lMRENBUkRfU1NJRDsKLQlwYXJhbXMuc3NpZHNbMF0uc3NpZF9sZW4gPSBQMlBfV0lMRENBUkRfU1NJRF9MRU47CisJaWYgKHNzaWQgJiYgc3NpZF9sZW4pIHsKKwkJcGFyYW1zLnNzaWRzWzBdLnNzaWQgPSBzc2lkOworCQlwYXJhbXMuc3NpZHNbMF0uc3NpZF9sZW4gPSBzc2lkX2xlbjsKKwkJb3NfbWVtY3B5KHdwYV9zLT5wMnBfam9pbl9zc2lkLCBzc2lkLCBzc2lkX2xlbik7CisJCXdwYV9zLT5wMnBfam9pbl9zc2lkX2xlbiA9IHNzaWRfbGVuOworCX0gZWxzZSB7CisJCXBhcmFtcy5zc2lkc1swXS5zc2lkID0gKHU4ICopIFAyUF9XSUxEQ0FSRF9TU0lEOworCQlwYXJhbXMuc3NpZHNbMF0uc3NpZF9sZW4gPSBQMlBfV0lMRENBUkRfU1NJRF9MRU47CisJCXdwYV9zLT5wMnBfam9pbl9zc2lkX2xlbiA9IDA7CisJfQogCiAJd3BhX3MtPndwcy0+ZGV2LnAycCA9IDE7CiAJd3BzX2llID0gd3BzX2J1aWxkX3Byb2JlX3JlcV9pZShERVZfUFdfREVGQVVMVCwgJndwYV9zLT53cHMtPmRldiwKQEAgLTM4NTQsNiArNDUxMSwxOCBAQAogCXBhcmFtcy5wMnBfcHJvYmUgPSAxOwogCXBhcmFtcy5leHRyYV9pZXMgPSB3cGFidWZfaGVhZChpZXMpOwogCXBhcmFtcy5leHRyYV9pZXNfbGVuID0gd3BhYnVmX2xlbihpZXMpOworCisJaWYgKCFmcmVxKSB7CisJCWludCBvcGVyX2ZyZXE7CisJCS8qCisJCSAqIElmIGZyZXEgaXMgbm90IHByb3ZpZGVkLCBjaGVjayB0aGUgb3BlcmF0aW5nIGZyZXEgb2YgdGhlIEdPCisJCSAqIGFuZCB1c2UgYSBzaW5nbGUgY2hhbm5lbCBzY2FuIG9uIGlmIHBvc3NpYmxlLgorCQkgKi8KKwkJb3Blcl9mcmVxID0gcDJwX2dldF9vcGVyX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLAorCQkJCQkgICAgICB3cGFfcy0+cGVuZGluZ19qb2luX2lmYWNlX2FkZHIpOworCQlpZiAob3Blcl9mcmVxID4gMCkKKwkJCWZyZXEgPSBvcGVyX2ZyZXE7CisJfQogCWlmIChmcmVxID4gMCkgewogCQlmcmVxc1swXSA9IGZyZXE7CiAJCXBhcmFtcy5mcmVxcyA9IGZyZXFzOwpAQCAtMzg2NSw4ICs0NTM0LDkgQEAKIAkgKi8KIAlyZXQgPSB3cGFfZHJ2X3NjYW4od3BhX3MsICZwYXJhbXMpOwogCWlmICghcmV0KSB7Ci0JCW9zX2dldF90aW1lKCZ3cGFfcy0+c2Nhbl90cmlnZ2VyX3RpbWUpOworCQlvc19nZXRfcmVsdGltZSgmd3BhX3MtPnNjYW5fdHJpZ2dlcl90aW1lKTsKIAkJd3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPSB3cGFzX3AycF9zY2FuX3Jlc19qb2luOworCQl3cGFfcy0+b3duX3NjYW5fcmVxdWVzdGVkID0gMTsKIAl9CiAKIAl3cGFidWZfZnJlZShpZXMpOwpAQCAtMzg4NCwxOCArNDU1NCwyMyBAQAogc3RhdGljIHZvaWQgd3Bhc19wMnBfam9pbl9zY2FuKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKLQl3cGFzX3AycF9qb2luX3NjYW5fcmVxKHdwYV9zLCAwKTsKKwl3cGFzX3AycF9qb2luX3NjYW5fcmVxKHdwYV9zLCAwLCBOVUxMLCAwKTsKIH0KIAogCiBzdGF0aWMgaW50IHdwYXNfcDJwX2pvaW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmlmYWNlX2FkZHIsCiAJCQkgY29uc3QgdTggKmRldl9hZGRyLCBlbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QsCi0JCQkgaW50IGF1dG9fam9pbikKKwkJCSBpbnQgYXV0b19qb2luLCBpbnQgb3BfZnJlcSwKKwkJCSBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuKQogewogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBSZXF1ZXN0IHRvIGpvaW4gZXhpc3RpbmcgZ3JvdXAgKGlmYWNlICIKLQkJICAgTUFDU1RSICIgZGV2ICIgTUFDU1RSICIpJXMiLAotCQkgICBNQUMyU1RSKGlmYWNlX2FkZHIpLCBNQUMyU1RSKGRldl9hZGRyKSwKKwkJICAgTUFDU1RSICIgZGV2ICIgTUFDU1RSICIgb3BfZnJlcT0lZCklcyIsCisJCSAgIE1BQzJTVFIoaWZhY2VfYWRkciksIE1BQzJTVFIoZGV2X2FkZHIpLCBvcF9mcmVxLAogCQkgICBhdXRvX2pvaW4gPyAiIChhdXRvX2pvaW4pIiA6ICIiKTsKKwlpZiAoc3NpZCAmJiBzc2lkX2xlbikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogR3JvdXAgU1NJRCBzcGVjaWZpZWQ6ICVzIiwKKwkJCSAgIHdwYV9zc2lkX3R4dChzc2lkLCBzc2lkX2xlbikpOworCX0KIAogCXdwYV9zLT5wMnBfYXV0b19wZCA9IDA7CiAJd3BhX3MtPnAycF9hdXRvX2pvaW4gPSAhIWF1dG9fam9pbjsKQEAgLTM5MDcsMTIgKzQ1ODIsMTMgQEAKIAl3cGFzX3AycF9zdG9wX2ZpbmQod3BhX3MpOwogCiAJd3BhX3MtPnAycF9qb2luX3NjYW5fY291bnQgPSAwOwotCXdwYXNfcDJwX2pvaW5fc2Nhbih3cGFfcywgTlVMTCk7CisJd3Bhc19wMnBfam9pbl9zY2FuX3JlcSh3cGFfcywgb3BfZnJlcSwgc3NpZCwgc3NpZF9sZW4pOwogCXJldHVybiAwOwogfQogCiAKLXN0YXRpYyBpbnQgd3Bhc19wMnBfam9pbl9zdGFydChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQorc3RhdGljIGludCB3cGFzX3AycF9qb2luX3N0YXJ0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBmcmVxLAorCQkJICAgICAgIGNvbnN0IHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICpncm91cDsKIAlzdHJ1Y3QgcDJwX2dvX25lZ19yZXN1bHRzIHJlczsKQEAgLTM5NDAsMTQgKzQ2MTYsMjUgQEAKIAlncm91cC0+cDJwX2ZhbGxiYWNrX3RvX2dvX25lZyA9IHdwYV9zLT5wMnBfZmFsbGJhY2tfdG9fZ29fbmVnOwogCiAJb3NfbWVtc2V0KCZyZXMsIDAsIHNpemVvZihyZXMpKTsKKwlvc19tZW1jcHkocmVzLnBlZXJfZGV2aWNlX2FkZHIsIHdwYV9zLT5wZW5kaW5nX2pvaW5fZGV2X2FkZHIsIEVUSF9BTEVOKTsKIAlvc19tZW1jcHkocmVzLnBlZXJfaW50ZXJmYWNlX2FkZHIsIHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkciwKIAkJICBFVEhfQUxFTik7CiAJcmVzLndwc19tZXRob2QgPSB3cGFfcy0+cGVuZGluZ19qb2luX3dwc19tZXRob2Q7Ci0JYnNzID0gd3BhX2Jzc19nZXRfYnNzaWRfbGF0ZXN0KHdwYV9zLCB3cGFfcy0+cGVuZGluZ19qb2luX2lmYWNlX2FkZHIpOwotCWlmIChic3MpIHsKLQkJcmVzLmZyZXEgPSBic3MtPmZyZXE7Ci0JCXJlcy5zc2lkX2xlbiA9IGJzcy0+c3NpZF9sZW47Ci0JCW9zX21lbWNweShyZXMuc3NpZCwgYnNzLT5zc2lkLCBic3MtPnNzaWRfbGVuKTsKKwlpZiAoZnJlcSAmJiBzc2lkICYmIHNzaWRfbGVuKSB7CisJCXJlcy5mcmVxID0gZnJlcTsKKwkJcmVzLnNzaWRfbGVuID0gc3NpZF9sZW47CisJCW9zX21lbWNweShyZXMuc3NpZCwgc3NpZCwgc3NpZF9sZW4pOworCX0gZWxzZSB7CisJCWJzcyA9IHdwYV9ic3NfZ2V0X2Jzc2lkX2xhdGVzdCh3cGFfcywKKwkJCQkJICAgICAgIHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkcik7CisJCWlmIChic3MpIHsKKwkJCXJlcy5mcmVxID0gYnNzLT5mcmVxOworCQkJcmVzLnNzaWRfbGVuID0gYnNzLT5zc2lkX2xlbjsKKwkJCW9zX21lbWNweShyZXMuc3NpZCwgYnNzLT5zc2lkLCBic3MtPnNzaWRfbGVuKTsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBKb2luIHRhcmdldCBHTyBvcGVyYXRpbmcgZnJlcXVlbmN5IGZyb20gQlNTIHRhYmxlOiAlZCBNSHogKFNTSUQgJXMpIiwKKwkJCQkgICBic3MtPmZyZXEsCisJCQkJICAgd3BhX3NzaWRfdHh0KGJzcy0+c3NpZCwgYnNzLT5zc2lkX2xlbikpOworCQl9CiAJfQogCiAJaWYgKHdwYV9zLT5vZmZfY2hhbm5lbF9mcmVxIHx8IHdwYV9zLT5yb2Nfd2FpdGluZ19kcnZfZnJlcSkgewpAQCAtMzk3MywyMyArNDY2MCwzOCBAQAogCiAKIHN0YXRpYyBpbnQgd3Bhc19wMnBfc2V0dXBfZnJlcXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEsCi0JCQkJaW50ICpmb3JjZV9mcmVxLCBpbnQgKnByZWZfZnJlcSkKKwkJCQlpbnQgKmZvcmNlX2ZyZXEsIGludCAqcHJlZl9mcmVxLCBpbnQgZ28pCiB7Ci0JaW50ICpmcmVxcywgcmVzOworCXN0cnVjdCB3cGFfdXNlZF9mcmVxX2RhdGEgKmZyZXFzOworCWludCByZXMsIGJlc3RfZnJlcSwgbnVtX3VudXNlZDsKIAl1bnNpZ25lZCBpbnQgZnJlcV9pbl91c2UgPSAwLCBudW0sIGk7CiAKLQlmcmVxcyA9IG9zX2NhbGxvYyh3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50LCBzaXplb2YoaW50KSk7CisJZnJlcXMgPSBvc19jYWxsb2Mod3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCwKKwkJCSAgc2l6ZW9mKHN0cnVjdCB3cGFfdXNlZF9mcmVxX2RhdGEpKTsKIAlpZiAoIWZyZXFzKQogCQlyZXR1cm4gLTE7CiAKLQludW0gPSBnZXRfc2hhcmVkX3JhZGlvX2ZyZXFzKHdwYV9zLCBmcmVxcywKLQkJCQkgICAgIHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQpOworCW51bSA9IHdwYXNfcDJwX3ZhbGlkX29wZXJfZnJlcXMod3BhX3MsIGZyZXFzLAorCQkJCQl3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50KTsKKworCS8qCisJICogSXQgaXMgcG9zc2libGUgdGhhdCB0aGUgdG90YWwgbnVtYmVyIG9mIHVzZWQgZnJlcXVlbmNpZXMgaXMgYmlnZ2VyCisJICogdGhhbiB0aGUgbnVtYmVyIG9mIGZyZXF1ZW5jaWVzIHVzZWQgZm9yIFAyUCwgc28gZ2V0IHRoZSBzeXN0ZW0gd2lkZQorCSAqIG51bWJlciBvZiB1bnVzZWQgZnJlcXVlbmNpZXMuCisJICovCisJbnVtX3VudXNlZCA9IHdwYXNfcDJwX251bV91bnVzZWRfY2hhbm5lbHMod3BhX3MpOworCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsCi0JCSAgICJQMlA6IFNldHVwIGZyZXFzOiBmcmVxPSVkIG51bV9NQ0M9JWQgc2hhcmVkX2ZyZXFzPSV1IiwKLQkJICAgZnJlcSwgd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCwgbnVtKTsKKwkJICAgIlAyUDogU2V0dXAgZnJlcXM6IGZyZXE9JWQgbnVtX01DQz0lZCBzaGFyZWRfZnJlcXM9JXUgbnVtX3VudXNlZD0lZCIsCisJCSAgIGZyZXEsIHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQsIG51bSwgbnVtX3VudXNlZCk7CiAKIAlpZiAoZnJlcSA+IDApIHsKLQkJaWYgKCFwMnBfc3VwcG9ydGVkX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLCBmcmVxKSkgeworCQlpbnQgcmV0OworCQlpZiAoZ28pCisJCQlyZXQgPSBwMnBfc3VwcG9ydGVkX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLCBmcmVxKTsKKwkJZWxzZQorCQkJcmV0ID0gcDJwX3N1cHBvcnRlZF9mcmVxX2NsaSh3cGFfcy0+Z2xvYmFsLT5wMnAsIGZyZXEpOworCQlpZiAoIXJldCkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRoZSBmb3JjZWQgY2hhbm5lbCAiCiAJCQkJICAgIigldSBNSHopIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIFAyUCB1c2VzIiwKIAkJCQkgICBmcmVxKTsKQEAgLTM5OTgsMTEgKzQ3MDAsMTEgQEAKIAkJfQogCiAJCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgewotCQkJaWYgKGZyZXFzW2ldID09IGZyZXEpCisJCQlpZiAoZnJlcXNbaV0uZnJlcSA9PSBmcmVxKQogCQkJCWZyZXFfaW5fdXNlID0gMTsKIAkJfQogCi0JCWlmIChudW0gPT0gd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCAmJiAhZnJlcV9pbl91c2UpIHsKKwkJaWYgKG51bV91bnVzZWQgPD0gMCAmJiAhZnJlcV9pbl91c2UpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDYW5ub3Qgc3RhcnQgUDJQIGdyb3VwIG9uICV1IE1IeiBhcyB0aGVyZSBhcmUgbm8gYXZhaWxhYmxlIGNoYW5uZWxzIiwKIAkJCQkgICBmcmVxKTsKIAkJCXJlcyA9IC0yOwpAQCAtNDAxNCwzOCArNDcxNiwyOCBAQAogCQlnb3RvIGV4aXRfb2s7CiAJfQogCi0JZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKSB7Ci0JCWlmICghcDJwX3N1cHBvcnRlZF9mcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcXNbaV0pKQotCQkJY29udGludWU7CisJYmVzdF9mcmVxID0gd3Bhc19wMnBfcGlja19iZXN0X3VzZWRfZnJlcSh3cGFfcywgZnJlcXMsIG51bSk7CiAKLSNpZm5kZWYgQU5EUk9JRF9QMlAKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRyeSB0byBmb3JjZSB1cyB0byB1c2UgZnJlcXVlbmN5ICgldSBNSHopIHdoaWNoIGlzIGFscmVhZHkgaW4gdXNlIiwKLQkJCSAgICpmb3JjZV9mcmVxKTsKLQkJKmZvcmNlX2ZyZXEgPSBmcmVxc1tpXTsKLSNlbmRpZgotCi0JCWlmICgqcHJlZl9mcmVxID09IDAgJiYgbnVtIDwgd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCkgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRyeSB0byBwcmVmZXIgYSBmcmVxdWVuY3kgd2UgYXJlIGFscmVhZHkgdXNpbmciKTsKLQkJCSpwcmVmX2ZyZXEgPSBmcmVxc1tpXTsKLSNpZmRlZiBBTkRST0lEX1AyUAorCS8qIFdlIGhhdmUgYSBjYW5kaWRhdGUgZnJlcXVlbmN5IHRvIHVzZSAqLworCWlmIChiZXN0X2ZyZXEgPiAwKSB7CisJCWlmICgqcHJlZl9mcmVxID09IDAgJiYgbnVtX3VudXNlZCA+IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBUcnkgdG8gcHJlZmVyIGEgZnJlcXVlbmN5ICgldSBNSHopIHdlIGFyZSBhbHJlYWR5IHVzaW5nIiwKKwkJCQkgICBiZXN0X2ZyZXEpOworCQkJKnByZWZfZnJlcSA9IGJlc3RfZnJlcTsKIAkJfSBlbHNlIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBUcnkgdG8gZm9yY2UgdXMgdG8gdXNlIGZyZXF1ZW5jeSAoJXUgTUh6KSB3aGljaCBpcyBhbHJlYWR5IGluIHVzZSIsCi0JCQkJICAgKmZvcmNlX2ZyZXEpOwotCQkJKmZvcmNlX2ZyZXEgPSBmcmVxc1tpXTsKLSNlbmRpZgorCQkJCSAgIGJlc3RfZnJlcSk7CisJCQkqZm9yY2VfZnJlcSA9IGJlc3RfZnJlcTsKIAkJfQotCQlicmVhazsKLQl9Ci0KLQlpZiAoaSA9PSBudW0pIHsKLQkJaWYgKG51bSA8IHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDdXJyZW50IG9wZXJhdGluZyBjaGFubmVscyBhcmUgbm90IGF2YWlsYWJsZSBmb3IgUDJQLiBUcnkgdG8gdXNlIGFub3RoZXIgY2hhbm5lbCIpOwotCQkJKmZvcmNlX2ZyZXEgPSAwOwotCQl9IGVsc2UgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEFsbCBjaGFubmVscyBhcmUgaW4gdXNlIGFuZCBub25lIG9mIHRoZW0gYXJlIFAyUCBlbmFibGVkLiBDYW5ub3Qgc3RhcnQgUDJQIGdyb3VwIik7Ci0JCQlyZXMgPSAtMjsKLQkJCWdvdG8gZXhpdF9mcmVlOwotCQl9CisJfSBlbHNlIGlmIChudW1fdW51c2VkID4gMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJQMlA6IEN1cnJlbnQgb3BlcmF0aW5nIGNoYW5uZWxzIGFyZSBub3QgYXZhaWxhYmxlIGZvciBQMlAuIFRyeSB0byB1c2UgYW5vdGhlciBjaGFubmVsIik7CisJCSpmb3JjZV9mcmVxID0gMDsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJQMlA6IEFsbCBjaGFubmVscyBhcmUgaW4gdXNlIGFuZCBub25lIG9mIHRoZW0gYXJlIFAyUCBlbmFibGVkLiBDYW5ub3Qgc3RhcnQgUDJQIGdyb3VwIik7CisJCXJlcyA9IC0yOworCQlnb3RvIGV4aXRfZnJlZTsKIAl9CiAKIGV4aXRfb2s6CkBAIC00MDc0LDYgKzQ3NjYsNyBAQAogICogQHBkOiBXaGV0aGVyIHRvIHNlbmQgUHJvdmlzaW9uIERpc2NvdmVyeSBwcmlvciB0byBHTyBOZWdvdGlhdGlvbiBhcyBhbgogICoJaW50ZXJvcGVyYWJpbGl0eSB3b3JrYXJvdW5kIHdoZW4gaW5pdGlhdGluZyBncm91cCBmb3JtYXRpb24KICAqIEBodDQwOiBTdGFydCBHTyB3aXRoIDQwIE1IeiBjaGFubmVsIHdpZHRoCisgKiBAdmh0OiAgU3RhcnQgR08gd2l0aCBWSFQgc3VwcG9ydAogICogUmV0dXJuczogMCBvciBuZXcgUElOIChpZiBwaW4gd2FzICVOVUxMKSBvbiBzdWNjZXNzLCAtMSBvbiB1bnNwZWNpZmllZAogICoJZmFpbHVyZSwgLTIgb24gZmFpbHVyZSBkdWUgdG8gY2hhbm5lbCBub3QgY3VycmVudGx5IGF2YWlsYWJsZSwKICAqCS0zIGlmIGZvcmNlZCBjaGFubmVsIGlzIG5vdCBzdXBwb3J0ZWQKQEAgLTQwODIsNyArNDc3NSw3IEBACiAJCSAgICAgY29uc3QgY2hhciAqcGluLCBlbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QsCiAJCSAgICAgaW50IHBlcnNpc3RlbnRfZ3JvdXAsIGludCBhdXRvX2pvaW4sIGludCBqb2luLCBpbnQgYXV0aCwKIAkJICAgICBpbnQgZ29faW50ZW50LCBpbnQgZnJlcSwgaW50IHBlcnNpc3RlbnRfaWQsIGludCBwZCwKLQkJICAgICBpbnQgaHQ0MCkKKwkJICAgICBpbnQgaHQ0MCwgaW50IHZodCkKIHsKIAlpbnQgZm9yY2VfZnJlcSA9IDAsIHByZWZfZnJlcSA9IDA7CiAJaW50IHJldCA9IDAsIHJlczsKQEAgLTQxMDMsNiArNDc5Niw4IEBACiAJb3NfZnJlZSh3cGFfcy0+Z2xvYmFsLT5hZGRfcHNrKTsKIAl3cGFfcy0+Z2xvYmFsLT5hZGRfcHNrID0gTlVMTDsKIAorCXdwYV9zLT5nbG9iYWwtPnAycF9mYWlsX29uX3dwc19jb21wbGV0ZSA9IDA7CisKIAlpZiAoZ29faW50ZW50IDwgMCkKIAkJZ29faW50ZW50ID0gd3BhX3MtPmNvbmYtPnAycF9nb19pbnRlbnQ7CiAKQEAgLTQxMTcsNiArNDgxMiw3IEBACiAJd3BhX3MtPnAycF9mYWxsYmFja190b19nb19uZWcgPSAwOwogCXdwYV9zLT5wMnBfcGRfYmVmb3JlX2dvX25lZyA9ICEhcGQ7CiAJd3BhX3MtPnAycF9nb19odDQwID0gISFodDQwOworCXdwYV9zLT5wMnBfZ29fdmh0ID0gISF2aHQ7CiAKIAlpZiAocGluKQogCQlvc19zdHJsY3B5KHdwYV9zLT5wMnBfcGluLCBwaW4sIHNpemVvZih3cGFfcy0+cDJwX3BpbikpOwpAQCAtNDE0Niw3ICs0ODQyLDcgQEAKIAkJCQkJIGRldl9hZGRyKTsKIAkJfQogCQlpZiAoYXV0b19qb2luKSB7Ci0JCQlvc19nZXRfdGltZSgmd3BhX3MtPnAycF9hdXRvX3N0YXJ0ZWQpOworCQkJb3NfZ2V0X3JlbHRpbWUoJndwYV9zLT5wMnBfYXV0b19zdGFydGVkKTsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBBdXRvIGpvaW4gc3RhcnRlZCBhdCAiCiAJCQkJICAgIiVsZC4lMDZsZCIsCiAJCQkJICAgd3BhX3MtPnAycF9hdXRvX3N0YXJ0ZWQuc2VjLApAQCAtNDE1NCwxNSArNDg1MCwxNyBAQAogCQl9CiAJCXdwYV9zLT51c2VyX2luaXRpYXRlZF9wZCA9IDE7CiAJCWlmICh3cGFzX3AycF9qb2luKHdwYV9zLCBpZmFjZV9hZGRyLCBkZXZfYWRkciwgd3BzX21ldGhvZCwKLQkJCQkgIGF1dG9fam9pbikgPCAwKQorCQkJCSAgYXV0b19qb2luLCBmcmVxLCBOVUxMLCAwKSA8IDApCiAJCQlyZXR1cm4gLTE7CiAJCXJldHVybiByZXQ7CiAJfQogCi0JcmVzID0gd3Bhc19wMnBfc2V0dXBfZnJlcXMod3BhX3MsIGZyZXEsICZmb3JjZV9mcmVxLCAmcHJlZl9mcmVxKTsKKwlyZXMgPSB3cGFzX3AycF9zZXR1cF9mcmVxcyh3cGFfcywgZnJlcSwgJmZvcmNlX2ZyZXEsICZwcmVmX2ZyZXEsCisJCQkJICAgZ29faW50ZW50ID09IDE1KTsKIAlpZiAocmVzKQogCQlyZXR1cm4gcmVzOwotCXdwYXNfcDJwX3NldF9vd25fZnJlcV9wcmVmZXJlbmNlKHdwYV9zLCBmb3JjZV9mcmVxKTsKKwl3cGFzX3AycF9zZXRfb3duX2ZyZXFfcHJlZmVyZW5jZSh3cGFfcywKKwkJCQkJIGZvcmNlX2ZyZXEgPyBmb3JjZV9mcmVxIDogcHJlZl9mcmVxKTsKIAogCXdwYV9zLT5jcmVhdGVfcDJwX2lmYWNlID0gd3Bhc19wMnBfY3JlYXRlX2lmYWNlKHdwYV9zKTsKIApAQCAtNDIxOSwyMCArNDkxNywyMCBAQAogCQlwMnBfbGlzdGVuX2NiKHdwYV9zLT5nbG9iYWwtPnAycCwgd3BhX3MtPnBlbmRpbmdfbGlzdGVuX2ZyZXEsCiAJCQkgICAgICB3cGFfcy0+cGVuZGluZ19saXN0ZW5fZHVyYXRpb24pOwogCQl3cGFfcy0+cGVuZGluZ19saXN0ZW5fZnJlcSA9IDA7CisJfSBlbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IElnbm9yZSByZW1haW4tb24tY2hhbm5lbCBjYWxsYmFjayAob2ZmX2NoYW5uZWxfZnJlcT0ldSBwZW5kaW5nX2xpc3Rlbl9mcmVxPSVkIGZyZXE9JXUgZHVyYXRpb249JXUpIiwKKwkJCSAgIHdwYV9zLT5vZmZfY2hhbm5lbF9mcmVxLCB3cGFfcy0+cGVuZGluZ19saXN0ZW5fZnJlcSwKKwkJCSAgIGZyZXEsIGR1cmF0aW9uKTsKIAl9CiB9CiAKIAotc3RhdGljIGludCB3cGFzX3AycF9saXN0ZW5fc3RhcnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgdW5zaWduZWQgaW50IHRpbWVvdXQpCitpbnQgd3Bhc19wMnBfbGlzdGVuX3N0YXJ0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHVuc2lnbmVkIGludCB0aW1lb3V0KQogewogCS8qIExpbWl0IG1heGltdW0gTGlzdGVuIHN0YXRlIHRpbWUgYmFzZWQgb24gZHJpdmVyIGxpbWl0YXRpb24uICovCiAJaWYgKHRpbWVvdXQgPiB3cGFfcy0+bWF4X3JlbWFpbl9vbl9jaGFuKQogCQl0aW1lb3V0ID0gd3BhX3MtPm1heF9yZW1haW5fb25fY2hhbjsKIAotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJcmV0dXJuIHdwYV9kcnZfcDJwX2xpc3Rlbih3cGFfcywgdGltZW91dCk7Ci0KIAlyZXR1cm4gcDJwX2xpc3Rlbih3cGFfcy0+Z2xvYmFsLT5wMnAsIHRpbWVvdXQpOwogfQogCkBAIC00MjUyLDE0ICs0OTUwLDE1IEBACiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENhbmNlbCByZW1haW4tb24tY2hhbm5lbCBjYWxsYmFjayAiCiAJCSAgICIocDJwX2xvbmdfbGlzdGVuPSVkIG1zIHBlbmRpbmdfYWN0aW9uX3R4PSVwKSIsCiAJCSAgIHdwYV9zLT5wMnBfbG9uZ19saXN0ZW4sIG9mZmNoYW5uZWxfcGVuZGluZ19hY3Rpb25fdHgod3BhX3MpKTsKKwl3cGFzX3AycF9saXN0ZW5fd29ya19kb25lKHdwYV9zKTsKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm47CisJaWYgKHdwYV9zLT5wMnBfbG9uZ19saXN0ZW4gPiAwKQorCQl3cGFfcy0+cDJwX2xvbmdfbGlzdGVuIC09IHdwYV9zLT5tYXhfcmVtYWluX29uX2NoYW47CiAJaWYgKHAycF9saXN0ZW5fZW5kKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcSkgPiAwKQogCQlyZXR1cm47IC8qIFAyUCBtb2R1bGUgc3RhcnRlZCBhIG5ldyBvcGVyYXRpb24gKi8KIAlpZiAob2ZmY2hhbm5lbF9wZW5kaW5nX2FjdGlvbl90eCh3cGFfcykpCiAJCXJldHVybjsKLQlpZiAod3BhX3MtPnAycF9sb25nX2xpc3RlbiA+IDApCi0JCXdwYV9zLT5wMnBfbG9uZ19saXN0ZW4gLT0gd3BhX3MtPm1heF9yZW1haW5fb25fY2hhbjsKIAlpZiAod3BhX3MtPnAycF9sb25nX2xpc3RlbiA+IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENvbnRpbnVpbmcgbG9uZyBMaXN0ZW4gc3RhdGUiKTsKIAkJd3Bhc19wMnBfbGlzdGVuX3N0YXJ0KHdwYV9zLCB3cGFfcy0+cDJwX2xvbmdfbGlzdGVuKTsKQEAgLTQzMjIsOCArNTAyMSw4IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBSZXF1ZXN0IHRvIHN0YXJ0IEdPIG9uIDIuNCBHSHogIgogCQkJICAgImJhbmQiKTsKIAkJaWYgKHdwYV9zLT5iZXN0XzI0X2ZyZXEgPiAwICYmCi0JCSAgICBwMnBfc3VwcG9ydGVkX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLAotCQkJCSAgICAgICB3cGFfcy0+YmVzdF8yNF9mcmVxKSkgeworCQkgICAgcDJwX3N1cHBvcnRlZF9mcmVxX2dvKHdwYV9zLT5nbG9iYWwtPnAycCwKKwkJCQkJICB3cGFfcy0+YmVzdF8yNF9mcmVxKSkgewogCQkJZnJlcSA9IHdwYV9zLT5iZXN0XzI0X2ZyZXE7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVXNlIGJlc3QgMi40IEdIeiBiYW5kICIKIAkJCQkgICAiY2hhbm5lbDogJWQgTUh6IiwgZnJlcSk7CkBAIC00MzM5LDcgKzUwMzgsNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogUmVxdWVzdCB0byBzdGFydCBHTyBvbiA1IEdIeiAiCiAJCQkgICAiYmFuZCIpOwogCQlpZiAod3BhX3MtPmJlc3RfNV9mcmVxID4gMCAmJgotCQkgICAgcDJwX3N1cHBvcnRlZF9mcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwKKwkJICAgIHAycF9zdXBwb3J0ZWRfZnJlcV9nbyh3cGFfcy0+Z2xvYmFsLT5wMnAsCiAJCQkJICAgICAgIHdwYV9zLT5iZXN0XzVfZnJlcSkpIHsKIAkJCWZyZXEgPSB3cGFfcy0+YmVzdF81X2ZyZXE7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVXNlIGJlc3QgNSBHSHogYmFuZCAiCkBAIC00MzQ3LDcgKzUwNDYsNyBAQAogCQl9IGVsc2UgewogCQkJb3NfZ2V0X3JhbmRvbSgodTggKikgJnIsIHNpemVvZihyKSk7CiAJCQlmcmVxID0gNTE4MCArIChyICUgNCkgKiAyMDsKLQkJCWlmICghcDJwX3N1cHBvcnRlZF9mcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcSkpIHsKKwkJCWlmICghcDJwX3N1cHBvcnRlZF9mcmVxX2dvKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcSkpIHsKIAkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ291bGQgbm90IHNlbGVjdCAiCiAJCQkJCSAgICI1IEdIeiBjaGFubmVsIGZvciBQMlAgZ3JvdXAiKTsKIAkJCQlyZXR1cm4gLTE7CkBAIC00MzU3LDcgKzUwNTYsNyBAQAogCQl9CiAJfQogCi0JaWYgKGZyZXEgPiAwICYmICFwMnBfc3VwcG9ydGVkX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLCBmcmVxKSkgeworCWlmIChmcmVxID4gMCAmJiAhcDJwX3N1cHBvcnRlZF9mcmVxX2dvKHdwYV9zLT5nbG9iYWwtPnAycCwgZnJlcSkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRoZSBmb3JjZWQgY2hhbm5lbCBmb3IgR08gIgogCQkJICAgIigldSBNSHopIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIFAyUCB1c2VzIiwKIAkJCSAgIGZyZXEpOwpAQCAtNDM2OCwxOCArNTA2Nyw1MiBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3Bhc19wMnBfc2VsZWN0X2ZyZXFfbm9fcHJlZihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQlzdHJ1Y3QgcDJwX2dvX25lZ19yZXN1bHRzICpwYXJhbXMsCisJCQkJCWNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW5uZWxzKQoreworCXVuc2lnbmVkIGludCBpLCByOworCisJLyogZmlyc3QgdHJ5IHNvbWUgcmFuZG9tIHNlbGVjdGlvbiBvZiB0aGUgc29jaWFsIGNoYW5uZWxzICovCisJb3NfZ2V0X3JhbmRvbSgodTggKikgJnIsIHNpemVvZihyKSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgMzsgaSsrKSB7CisJCXBhcmFtcy0+ZnJlcSA9IDI0MTIgKyAoKHIgKyBpKSAlIDMpICogMjU7CisJCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIHBhcmFtcy0+ZnJlcSkgJiYKKwkJICAgIGZyZXFfaW5jbHVkZWQoY2hhbm5lbHMsIHBhcmFtcy0+ZnJlcSkpCisJCQlnb3RvIG91dDsKKwl9CisKKwkvKiB0cnkgYWxsIGNoYW5uZWxzIGluIHJlZy4gY2xhc3MgODEgKi8KKwlmb3IgKGkgPSAwOyBpIDwgMTE7IGkrKykgeworCQlwYXJhbXMtPmZyZXEgPSAyNDEyICsgaSAqIDU7CisJCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIHBhcmFtcy0+ZnJlcSkgJiYKKwkJICAgIGZyZXFfaW5jbHVkZWQoY2hhbm5lbHMsIHBhcmFtcy0+ZnJlcSkpCisJCQlnb3RvIG91dDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogTm8gMi40IEdIeiBjaGFubmVsIGFsbG93ZWQiKTsKKwlyZXR1cm4gLTE7CitvdXQ6CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNldCBHTyBmcmVxICVkIE1IeiAobm8gcHJlZmVyZW5jZSBrbm93bikiLAorCQkgICBwYXJhbXMtPmZyZXEpOworCXJldHVybiAwOworfQorCisKIHN0YXRpYyBpbnQgd3Bhc19wMnBfaW5pdF9nb19wYXJhbXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICBzdHJ1Y3QgcDJwX2dvX25lZ19yZXN1bHRzICpwYXJhbXMsCi0JCQkJICAgaW50IGZyZXEsIGludCBodDQwLAorCQkJCSAgIGludCBmcmVxLCBpbnQgaHQ0MCwgaW50IHZodCwKIAkJCQkgICBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscykKIHsKLQlpbnQgcmVzLCAqZnJlcXM7Ci0JdW5zaWduZWQgaW50IHByZWZfZnJlcTsKKwlzdHJ1Y3Qgd3BhX3VzZWRfZnJlcV9kYXRhICpmcmVxczsKKwl1bnNpZ25lZCBpbnQgcHJlZl9mcmVxLCBjYW5kX2ZyZXE7CiAJdW5zaWduZWQgaW50IG51bSwgaTsKIAogCW9zX21lbXNldChwYXJhbXMsIDAsIHNpemVvZigqcGFyYW1zKSk7CiAJcGFyYW1zLT5yb2xlX2dvID0gMTsKIAlwYXJhbXMtPmh0NDAgPSBodDQwOworCXBhcmFtcy0+dmh0ID0gdmh0OwogCWlmIChmcmVxKSB7CiAJCWlmICghZnJlcV9pbmNsdWRlZChjaGFubmVscywgZnJlcSkpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGb3JjZWQgR08gZnJlcSAlZCBNSHogbm90ICIKQEAgLTQ0MTAsMjQgKzUxNDMsMjQgQEAKIAkJCSAgICJmcmVxdWVuY3kgJWQgTUh6IiwgcGFyYW1zLT5mcmVxKTsKIAl9IGVsc2UgaWYgKHdwYV9zLT5jb25mLT5wMnBfb3Blcl9jaGFubmVsID09IDAgJiYKIAkJICAgd3BhX3MtPmJlc3Rfb3ZlcmFsbF9mcmVxID4gMCAmJgotCQkgICBwMnBfc3VwcG9ydGVkX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLAotCQkJCSAgICAgIHdwYV9zLT5iZXN0X292ZXJhbGxfZnJlcSkgJiYKKwkJICAgcDJwX3N1cHBvcnRlZF9mcmVxX2dvKHdwYV9zLT5nbG9iYWwtPnAycCwKKwkJCQkJIHdwYV9zLT5iZXN0X292ZXJhbGxfZnJlcSkgJiYKIAkJICAgZnJlcV9pbmNsdWRlZChjaGFubmVscywgd3BhX3MtPmJlc3Rfb3ZlcmFsbF9mcmVxKSkgewogCQlwYXJhbXMtPmZyZXEgPSB3cGFfcy0+YmVzdF9vdmVyYWxsX2ZyZXE7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBTZXQgR08gZnJlcSBiYXNlZCBvbiBiZXN0IG92ZXJhbGwgIgogCQkJICAgImNoYW5uZWwgJWQgTUh6IiwgcGFyYW1zLT5mcmVxKTsKIAl9IGVsc2UgaWYgKHdwYV9zLT5jb25mLT5wMnBfb3Blcl9jaGFubmVsID09IDAgJiYKIAkJICAgd3BhX3MtPmJlc3RfMjRfZnJlcSA+IDAgJiYKLQkJICAgcDJwX3N1cHBvcnRlZF9mcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwKLQkJCQkgICAgICB3cGFfcy0+YmVzdF8yNF9mcmVxKSAmJgorCQkgICBwMnBfc3VwcG9ydGVkX2ZyZXFfZ28od3BhX3MtPmdsb2JhbC0+cDJwLAorCQkJCQkgd3BhX3MtPmJlc3RfMjRfZnJlcSkgJiYKIAkJICAgZnJlcV9pbmNsdWRlZChjaGFubmVscywgd3BhX3MtPmJlc3RfMjRfZnJlcSkpIHsKIAkJcGFyYW1zLT5mcmVxID0gd3BhX3MtPmJlc3RfMjRfZnJlcTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNldCBHTyBmcmVxIGJhc2VkIG9uIGJlc3QgMi40IEdIeiAiCiAJCQkgICAiY2hhbm5lbCAlZCBNSHoiLCBwYXJhbXMtPmZyZXEpOwogCX0gZWxzZSBpZiAod3BhX3MtPmNvbmYtPnAycF9vcGVyX2NoYW5uZWwgPT0gMCAmJgogCQkgICB3cGFfcy0+YmVzdF81X2ZyZXEgPiAwICYmCi0JCSAgIHAycF9zdXBwb3J0ZWRfZnJlcSh3cGFfcy0+Z2xvYmFsLT5wMnAsCi0JCQkJICAgICAgd3BhX3MtPmJlc3RfNV9mcmVxKSAmJgorCQkgICBwMnBfc3VwcG9ydGVkX2ZyZXFfZ28od3BhX3MtPmdsb2JhbC0+cDJwLAorCQkJCQkgd3BhX3MtPmJlc3RfNV9mcmVxKSAmJgogCQkgICBmcmVxX2luY2x1ZGVkKGNoYW5uZWxzLCB3cGFfcy0+YmVzdF81X2ZyZXEpKSB7CiAJCXBhcmFtcy0+ZnJlcSA9IHdwYV9zLT5iZXN0XzVfZnJlcTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNldCBHTyBmcmVxIGJhc2VkIG9uIGJlc3QgNSBHSHogIgpAQCAtNDQzOCw0NyArNTE3MSwzNyBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogU2V0IEdPIGZyZXEgJWQgTUh6IGZyb20gcHJlZmVycmVkICIKIAkJCSAgICJjaGFubmVscyIsIHBhcmFtcy0+ZnJlcSk7CiAJfSBlbHNlIHsKLQkJaW50IGNoYW47Ci0JCWZvciAoY2hhbiA9IDA7IGNoYW4gPCAxMTsgY2hhbisrKSB7Ci0JCQlwYXJhbXMtPmZyZXEgPSAyNDEyICsgY2hhbiAqIDU7Ci0JCQlpZiAoIXdwYXNfcDJwX2Rpc2FsbG93ZWRfZnJlcSh3cGFfcy0+Z2xvYmFsLAotCQkJCQkJICAgICAgcGFyYW1zLT5mcmVxKSAmJgotCQkJICAgIGZyZXFfaW5jbHVkZWQoY2hhbm5lbHMsIHBhcmFtcy0+ZnJlcSkpCi0JCQkJYnJlYWs7Ci0JCX0KLQkJaWYgKGNoYW4gPT0gMTEpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBObyAyLjQgR0h6IGNoYW5uZWwgIgotCQkJCSAgICJhbGxvd2VkIik7CisJCS8qIG5vIHByZWZlcmVuY2UsIHNlbGVjdCBzb21lIGNoYW5uZWwgKi8KKwkJaWYgKHdwYXNfcDJwX3NlbGVjdF9mcmVxX25vX3ByZWYod3BhX3MsIHBhcmFtcywgY2hhbm5lbHMpIDwgMCkKIAkJCXJldHVybiAtMTsKLQkJfQotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogU2V0IEdPIGZyZXEgJWQgTUh6IChubyBwcmVmZXJlbmNlICIKLQkJCSAgICJrbm93bikiLCBwYXJhbXMtPmZyZXEpOwogCX0KIAotCWZyZXFzID0gb3NfY2FsbG9jKHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQsIHNpemVvZihpbnQpKTsKKwlmcmVxcyA9IG9zX2NhbGxvYyh3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50LAorCQkJICBzaXplb2Yoc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSkpOwogCWlmICghZnJlcXMpCiAJCXJldHVybiAtMTsKIAotCXJlcyA9IHdwYXNfcDJwX3ZhbGlkX29wZXJfZnJlcXMod3BhX3MsIGZyZXFzLAorCW51bSA9IHdwYXNfcDJwX3ZhbGlkX29wZXJfZnJlcXMod3BhX3MsIGZyZXFzLAogCQkJCQl3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50KTsKLQlpZiAocmVzIDwgMCkgewotCQlvc19mcmVlKGZyZXFzKTsKLQkJcmV0dXJuIC0xOwotCX0KLQludW0gPSByZXM7CiAKLQlpZiAoIWZyZXEpIHsKKwljYW5kX2ZyZXEgPSB3cGFzX3AycF9waWNrX2Jlc3RfdXNlZF9mcmVxKHdwYV9zLCBmcmVxcywgbnVtKTsKKworCS8qIEZpcnN0IHRyeSB0aGUgYmVzdCB1c2VkIGZyZXF1ZW5jeSBpZiBwb3NzaWJsZSAqLworCWlmICghZnJlcSAmJiBjYW5kX2ZyZXEgPiAwICYmIGZyZXFfaW5jbHVkZWQoY2hhbm5lbHMsIGNhbmRfZnJlcSkpIHsKKwkJcGFyYW1zLT5mcmVxID0gY2FuZF9mcmVxOworCX0gZWxzZSBpZiAoIWZyZXEpIHsKKwkJLyogVHJ5IGFueSBvZiB0aGUgdXNlZCBmcmVxdWVuY2llcyAqLwogCQlmb3IgKGkgPSAwOyBpIDwgbnVtOyBpKyspIHsKLQkJCWlmIChmcmVxX2luY2x1ZGVkKGNoYW5uZWxzLCBmcmVxc1tpXSkpIHsKKwkJCWlmIChmcmVxX2luY2x1ZGVkKGNoYW5uZWxzLCBmcmVxc1tpXS5mcmVxKSkgewogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGb3JjZSBHTyBvbiBhIGNoYW5uZWwgd2UgYXJlIGFscmVhZHkgdXNpbmcgKCV1IE1IeikiLAotCQkJCQkgICBmcmVxc1tpXSk7Ci0JCQkJcGFyYW1zLT5mcmVxID0gZnJlcXNbaV07CisJCQkJCSAgIGZyZXFzW2ldLmZyZXEpOworCQkJCXBhcmFtcy0+ZnJlcSA9IGZyZXFzW2ldLmZyZXE7CiAJCQkJYnJlYWs7CiAJCQl9CiAJCX0KIAogCQlpZiAoaSA9PSBudW0pIHsKLQkJCWlmIChudW0gPT0gd3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCkgeworCQkJaWYgKHdwYXNfcDJwX251bV91bnVzZWRfY2hhbm5lbHMod3BhX3MpIDw9IDApIHsKIAkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ2Fubm90IGZvcmNlIEdPIG9uIGFueSBvZiB0aGUgY2hhbm5lbHMgd2UgYXJlIGFscmVhZHkgdXNpbmciKTsKIAkJCQlvc19mcmVlKGZyZXFzKTsKIAkJCQlyZXR1cm4gLTE7CkBAIC00NDg4LDIwICs1MjExLDIyIEBACiAJCX0KIAl9IGVsc2UgewogCQlmb3IgKGkgPSAwOyBpIDwgbnVtOyBpKyspIHsKLQkJCWlmIChmcmVxc1tpXSA9PSBmcmVxKQorCQkJaWYgKGZyZXFzW2ldLmZyZXEgPT0gZnJlcSkKIAkJCQlicmVhazsKIAkJfQogCiAJCWlmIChpID09IG51bSkgewotCQkJaWYgKG51bSA9PSB3cGFfcy0+bnVtX211bHRpY2hhbl9jb25jdXJyZW50KSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENhbm5vdCBmb3JjZSBHTyBvbiBmcmVxICgldSBNSHopIGFzIGFsbCB0aGUgY2hhbm5lbHMgYXJlIGluIHVzZSIsIGZyZXEpOworCQkJaWYgKHdwYXNfcDJwX251bV91bnVzZWRfY2hhbm5lbHMod3BhX3MpIDw9IDApIHsKKwkJCQlpZiAoZnJlcSkKKwkJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENhbm5vdCBmb3JjZSBHTyBvbiBmcmVxICgldSBNSHopIGFzIGFsbCB0aGUgY2hhbm5lbHMgYXJlIGluIHVzZSIsIGZyZXEpOwogCQkJCW9zX2ZyZWUoZnJlcXMpOwogCQkJCXJldHVybiAtMTsKIAkJCX0gZWxzZSB7Ci0JCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENhbm5vdCBmb3JjZSBHTyBvbiBhbnkgb2YgdGhlIGNoYW5uZWxzIHdlIGFyZSBhbHJlYWR5IHVzaW5nLiBVc2Ugb25lIG9mIHRoZSBmcmVlIGNoYW5uZWxzIik7CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFVzZSBvbmUgb2YgdGhlIGZyZWUgY2hhbm5lbHMiKTsKIAkJCX0KIAkJfQogCX0KKwogCW9zX2ZyZWUoZnJlcXMpOwogCXJldHVybiAwOwogfQpAQCAtNDUxNiw2ICs1MjQxLDcgQEAKIAlpZiAoIXdwYXNfcDJwX2NyZWF0ZV9pZmFjZSh3cGFfcykpIHsKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBVc2Ugc2FtZSBpbnRlcmZhY2UgZm9yIGdyb3VwICIKIAkJCSJvcGVyYXRpb25zIik7CisJCXdwYV9zLT5wMnBfZmlyc3RfY29ubmVjdGlvbl90aW1lb3V0ID0gMDsKIAkJcmV0dXJuIHdwYV9zOwogCX0KIApAQCAtNDUzNSw2ICs1MjYxLDcgQEAKIAogCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlAyUDogVXNlIHNlcGFyYXRlIGdyb3VwIGludGVyZmFjZSAlcyIsCiAJCWdyb3VwX3dwYV9zLT5pZm5hbWUpOworCWdyb3VwX3dwYV9zLT5wMnBfZmlyc3RfY29ubmVjdGlvbl90aW1lb3V0ID0gMDsKIAlyZXR1cm4gZ3JvdXBfd3BhX3M7CiB9CiAKQEAgLTQ1NDQsMTMgKzUyNzEsMTUgQEAKICAqIEB3cGFfczogUG9pbnRlciB0byB3cGFfc3VwcGxpY2FudCBkYXRhIGZyb20gd3BhX3N1cHBsaWNhbnRfYWRkX2lmYWNlKCkKICAqIEBwZXJzaXN0ZW50X2dyb3VwOiBXaGV0aGVyIHRvIGNyZWF0ZSBhIHBlcnNpc3RlbnQgZ3JvdXAKICAqIEBmcmVxOiBGcmVxdWVuY3kgZm9yIHRoZSBncm91cCBvciAwIHRvIGluZGljYXRlIG5vIGhhcmRjb2RpbmcKKyAqIEBodDQwOiBTdGFydCBHTyB3aXRoIDQwIE1IeiBjaGFubmVsIHdpZHRoCisgKiBAdmh0OiAgU3RhcnQgR08gd2l0aCBWSFQgc3VwcG9ydAogICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCiAgKgogICogVGhpcyBmdW5jdGlvbiBjcmVhdGVzIGEgbmV3IFAyUCBncm91cCB3aXRoIHRoZSBsb2NhbCBlbmQgYXMgdGhlIEdyb3VwIE93bmVyLAogICogaS5lLiwgd2l0aG91dCB1c2luZyBHcm91cCBPd25lciBOZWdvdGlhdGlvbi4KICAqLwogaW50IHdwYXNfcDJwX2dyb3VwX2FkZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgcGVyc2lzdGVudF9ncm91cCwKLQkJICAgICAgIGludCBmcmVxLCBpbnQgaHQ0MCkKKwkJICAgICAgIGludCBmcmVxLCBpbnQgaHQ0MCwgaW50IHZodCkKIHsKIAlzdHJ1Y3QgcDJwX2dvX25lZ19yZXN1bHRzIHBhcmFtczsKIApAQCAtNDU2OCwxMCArNTI5NywxMCBAQAogCWlmIChmcmVxIDwgMCkKIAkJcmV0dXJuIC0xOwogCi0JaWYgKHdwYXNfcDJwX2luaXRfZ29fcGFyYW1zKHdwYV9zLCAmcGFyYW1zLCBmcmVxLCBodDQwLCBOVUxMKSkKKwlpZiAod3Bhc19wMnBfaW5pdF9nb19wYXJhbXMod3BhX3MsICZwYXJhbXMsIGZyZXEsIGh0NDAsIHZodCwgTlVMTCkpCiAJCXJldHVybiAtMTsKIAlpZiAocGFyYW1zLmZyZXEgJiYKLQkgICAgIXAycF9zdXBwb3J0ZWRfZnJlcSh3cGFfcy0+Z2xvYmFsLT5wMnAsIHBhcmFtcy5mcmVxKSkgeworCSAgICAhcDJwX3N1cHBvcnRlZF9mcmVxX2dvKHdwYV9zLT5nbG9iYWwtPnAycCwgcGFyYW1zLmZyZXEpKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBUaGUgc2VsZWN0ZWQgY2hhbm5lbCBmb3IgR08gIgogCQkJICAgIigldSBNSHopIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIFAyUCB1c2VzIiwKIAkJCSAgIHBhcmFtcy5mcmVxKTsKQEAgLTQ1OTAsNyArNTMxOSw4IEBACiAKIAogc3RhdGljIGludCB3cGFzX3N0YXJ0X3AycF9jbGllbnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgc3RydWN0IHdwYV9zc2lkICpwYXJhbXMsIGludCBhZGRyX2FsbG9jYXRlZCkKKwkJCQkgc3RydWN0IHdwYV9zc2lkICpwYXJhbXMsIGludCBhZGRyX2FsbG9jYXRlZCwKKwkJCQkgaW50IGZyZXEpCiB7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwogCkBAIC00NjI2LDkgKzUzNTYsMTYgQEAKIAlpZiAocGFyYW1zLT5wYXNzcGhyYXNlKQogCQlzc2lkLT5wYXNzcGhyYXNlID0gb3Nfc3RyZHVwKHBhcmFtcy0+cGFzc3BocmFzZSk7CiAKLQl3cGFfc3VwcGxpY2FudF9zZWxlY3RfbmV0d29yayh3cGFfcywgc3NpZCk7Ci0KIAl3cGFfcy0+c2hvd19ncm91cF9zdGFydGVkID0gMTsKKwl3cGFfcy0+cDJwX2luX2ludml0YXRpb24gPSAxOworCXdwYV9zLT5wMnBfaW52aXRlX2dvX2ZyZXEgPSBmcmVxOworCisJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsIHdwYV9zLT5wYXJlbnQsCisJCQkgICAgIE5VTEwpOworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoUDJQX01BWF9JTklUSUFMX0NPTk5fV0FJVCwgMCwKKwkJCSAgICAgICB3cGFzX3AycF9ncm91cF9mb3JtYXRpb25fdGltZW91dCwKKwkJCSAgICAgICB3cGFfcy0+cGFyZW50LCBOVUxMKTsKKwl3cGFfc3VwcGxpY2FudF9zZWxlY3RfbmV0d29yayh3cGFfcywgc3NpZCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTQ2MzYsMTEgKzUzNzMsMTIgQEAKIAogaW50IHdwYXNfcDJwX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsIGludCBhZGRyX2FsbG9jYXRlZCwKLQkJCQkgIGludCBmcmVxLCBpbnQgaHQ0MCwKLQkJCQkgIGNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW5uZWxzKQorCQkJCSAgaW50IGZvcmNlX2ZyZXEsIGludCBuZWdfZnJlcSwgaW50IGh0NDAsCisJCQkJICBpbnQgdmh0LCBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscywKKwkJCQkgIGludCBjb25uZWN0aW9uX3RpbWVvdXQpCiB7CiAJc3RydWN0IHAycF9nb19uZWdfcmVzdWx0cyBwYXJhbXM7Ci0JaW50IGdvID0gMDsKKwlpbnQgZ28gPSAwLCBmcmVxOwogCiAJaWYgKHNzaWQtPmRpc2FibGVkICE9IDIgfHwgc3NpZC0+c3NpZCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CkBAIC00NjYwLDE3ICs1Mzk4LDIzIEBACiAKIAl3cGFfcy0+cDJwX2ZhbGxiYWNrX3RvX2dvX25lZyA9IDA7CiAKKwlpZiAoZm9yY2VfZnJlcSA+IDApIHsKKwkJZnJlcSA9IHdwYXNfcDJwX3NlbGVjdF9nb19mcmVxKHdwYV9zLCBmb3JjZV9mcmVxKTsKKwkJaWYgKGZyZXEgPCAwKQorCQkJcmV0dXJuIC0xOworCX0gZWxzZSB7CisJCWZyZXEgPSB3cGFzX3AycF9zZWxlY3RfZ29fZnJlcSh3cGFfcywgbmVnX2ZyZXEpOworCQlpZiAoZnJlcSA8IDAgfHwgKGZyZXEgPiAwICYmICFmcmVxX2luY2x1ZGVkKGNoYW5uZWxzLCBmcmVxKSkpCisJCQlmcmVxID0gMDsKKwl9CisKIAlpZiAoc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfSU5GUkEpCi0JCXJldHVybiB3cGFzX3N0YXJ0X3AycF9jbGllbnQod3BhX3MsIHNzaWQsIGFkZHJfYWxsb2NhdGVkKTsKKwkJcmV0dXJuIHdwYXNfc3RhcnRfcDJwX2NsaWVudCh3cGFfcywgc3NpZCwgYWRkcl9hbGxvY2F0ZWQsIGZyZXEpOwogCiAJaWYgKHNzaWQtPm1vZGUgIT0gV1BBU19NT0RFX1AyUF9HTykKIAkJcmV0dXJuIC0xOwogCi0JZnJlcSA9IHdwYXNfcDJwX3NlbGVjdF9nb19mcmVxKHdwYV9zLCBmcmVxKTsKLQlpZiAoZnJlcSA8IDApCi0JCXJldHVybiAtMTsKLQotCWlmICh3cGFzX3AycF9pbml0X2dvX3BhcmFtcyh3cGFfcywgJnBhcmFtcywgZnJlcSwgaHQ0MCwgY2hhbm5lbHMpKQorCWlmICh3cGFzX3AycF9pbml0X2dvX3BhcmFtcyh3cGFfcywgJnBhcmFtcywgZnJlcSwgaHQ0MCwgdmh0LCBjaGFubmVscykpCiAJCXJldHVybiAtMTsKIAogCXBhcmFtcy5yb2xlX2dvID0gMTsKQEAgLTQ2OTQsNiArNTQzOCw3IEBACiAJaWYgKHdwYV9zID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAorCXdwYV9zLT5wMnBfZmlyc3RfY29ubmVjdGlvbl90aW1lb3V0ID0gY29ubmVjdGlvbl90aW1lb3V0OwogCXdwYXNfc3RhcnRfd3BzX2dvKHdwYV9zLCAmcGFyYW1zLCAwKTsKIAogCXJldHVybiAwOwpAQCAtNDczMSw5ICs1NDc2LDE0IEBACiAJaWYgKCF3cGFfcy0+YXBfaWZhY2UpCiAJCXJldHVybjsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogR08gLSBncm91cCAlc2lkbGUiLCBpZGxlID8gIiIgOiAibm90ICIpOwotCWlmIChpZGxlKQorCWlmIChpZGxlKSB7CisJCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZmFpbF9vbl93cHNfY29tcGxldGUgJiYKKwkJICAgIHdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nKSB7CisJCQl3cGFzX3AycF9ncnBmb3JtX2ZhaWxfYWZ0ZXJfd3BzKHdwYV9zKTsKKwkJCXJldHVybjsKKwkJfQogCQl3cGFzX3AycF9zZXRfZ3JvdXBfaWRsZV90aW1lb3V0KHdwYV9zKTsKLQllbHNlCisJfSBlbHNlCiAJCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2lkbGVfdGltZW91dCwgd3BhX3MsIE5VTEwpOwogfQogCkBAIC00NzQ0LDggKzU0OTQsNiBAQAogCXN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwOwogCXN0cnVjdCBwMnBfZ3JvdXBfY29uZmlnICpjZmc7CiAKLQlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQpCi0JCXJldHVybiBOVUxMOwogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwogCkBAIC00NzY1LDYgKzU1MTMsNyBAQAogCQljZmctPm1heF9jbGllbnRzID0gd3BhX3MtPmNvbmYtPm1heF9udW1fc3RhOwogCW9zX21lbWNweShjZmctPnNzaWQsIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKIAljZmctPnNzaWRfbGVuID0gc3NpZC0+c3NpZF9sZW47CisJY2ZnLT5mcmVxID0gc3NpZC0+ZnJlcXVlbmN5OwogCWNmZy0+Y2JfY3R4ID0gd3BhX3M7CiAJY2ZnLT5pZV91cGRhdGUgPSB3cGFzX3AycF9pZV91cGRhdGU7CiAJY2ZnLT5pZGxlX3VwZGF0ZSA9IHdwYXNfcDJwX2lkbGVfdXBkYXRlOwpAQCAtNDgwMSw2ICs1NTUwLDcgQEAKIAogCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LCB3cGFfcy0+cGFyZW50LAogCQkJICAgICBOVUxMKTsKKwl3cGFfcy0+cDJwX2dvX2dyb3VwX2Zvcm1hdGlvbl9jb21wbGV0ZWQgPSAxOwogCWlmIChzc2lkICYmIHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX0lORlJBKSB7CiAJCS8qCiAJCSAqIFVzZSBhIHNlcGFyYXRlIHRpbWVvdXQgZm9yIGluaXRpYWwgZGF0YSBjb25uZWN0aW9uIHRvCkBAIC00ODA4LDE0ICs1NTU4LDMxIEBACiAJCSAqIHNvbWV0aGluZyBnb2VzIHdyb25nIGluIHRoaXMgc3RlcCBiZWZvcmUgdGhlIFAyUCBncm91cCBpZGxlCiAJCSAqIHRpbWVvdXQgbWVjaGFuaXNtIGlzIHRha2VuIGludG8gdXNlLgogCQkgKi8KKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAorCQkJIlAyUDogUmUtc3RhcnQgZ3JvdXAgZm9ybWF0aW9uIHRpbWVvdXQgKCVkIHNlY29uZHMpIGFzIGNsaWVudCBmb3IgaW5pdGlhbCBjb25uZWN0aW9uIiwKKwkJCVAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVQpOwogCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KFAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVQsIDAsCiAJCQkJICAgICAgIHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LAogCQkJCSAgICAgICB3cGFfcy0+cGFyZW50LCBOVUxMKTsKKwl9IGVsc2UgaWYgKHNzaWQpIHsKKwkJLyoKKwkJICogVXNlIGEgc2VwYXJhdGUgdGltZW91dCBmb3IgaW5pdGlhbCBkYXRhIGNvbm5lY3Rpb24gdG8KKwkJICogY29tcGxldGUgdG8gYWxsb3cgdGhlIGdyb3VwIHRvIGJlIHJlbW92ZWQgYXV0b21hdGljYWxseSBpZgorCQkgKiB0aGUgY2xpZW50IGRvZXMgbm90IGNvbXBsZXRlIGRhdGEgY29ubmVjdGlvbiBzdWNjZXNzZnVsbHkuCisJCSAqLworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsCisJCQkiUDJQOiBSZS1zdGFydCBncm91cCBmb3JtYXRpb24gdGltZW91dCAoJWQgc2Vjb25kcykgYXMgR08gZm9yIGluaXRpYWwgY29ubmVjdGlvbiIsCisJCQlQMlBfTUFYX0lOSVRJQUxfQ09OTl9XQUlUX0dPKTsKKwkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChQMlBfTUFYX0lOSVRJQUxfQ09OTl9XQUlUX0dPLCAwLAorCQkJCSAgICAgICB3cGFzX3AycF9ncm91cF9mb3JtYXRpb25fdGltZW91dCwKKwkJCQkgICAgICAgd3BhX3MtPnBhcmVudCwgTlVMTCk7CisJCS8qCisJCSAqIENvbXBsZXRlIGdyb3VwIGZvcm1hdGlvbiBvbiBmaXJzdCBzdWNjZXNzZnVsIGRhdGEgY29ubmVjdGlvbgorCQkgKi8KKwkJd3BhX3MtPnAycF9nb19ncm91cF9mb3JtYXRpb25fY29tcGxldGVkID0gMDsKIAl9CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCkKIAkJcDJwX3dwc19zdWNjZXNzX2NiKHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyKTsKLQllbHNlIGlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJd3BhX2Rydl93cHNfc3VjY2Vzc19jYih3cGFfcywgcGVlcl9hZGRyKTsKIAl3cGFzX2dyb3VwX2Zvcm1hdGlvbl9jb21wbGV0ZWQod3BhX3MsIDEpOwogfQogCkBAIC00ODM2LDYgKzU2MDMsMzEgQEAKIAl9CiAKIAl3cGFzX25vdGlmeV9wMnBfd3BzX2ZhaWxlZCh3cGFfcywgZmFpbCk7CisKKwlpZiAod3BhX3MgPT0gd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbikgeworCQkvKgorCQkgKiBBbGxvdyBzb21lIHRpbWUgZm9yIHRoZSBmYWlsZWQgV1BTIG5lZ290aWF0aW9uIGV4Y2hhbmdlIHRvCisJCSAqIGNvbXBsZXRlLCBidXQgcmVtb3ZlIHRoZSBncm91cCBzaW5jZSBncm91cCBmb3JtYXRpb24gY2Fubm90CisJCSAqIHN1Y2NlZWQgYWZ0ZXIgcHJvdmlzaW9uaW5nIGZhaWx1cmUuCisJCSAqLworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogV1BTIHN0ZXAgZmFpbGVkIGR1cmluZyBncm91cCBmb3JtYXRpb24gLSByZWplY3QgY29ubmVjdGlvbiBmcm9tIHRpbWVvdXQiKTsKKwkJd3BhX3MtPmdsb2JhbC0+cDJwX2ZhaWxfb25fd3BzX2NvbXBsZXRlID0gMTsKKwkJZWxvb3BfZGVwbGV0ZV90aW1lb3V0KDAsIDUwMDAwLAorCQkJCSAgICAgIHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LAorCQkJCSAgICAgIHdwYV9zLT5wYXJlbnQsIE5VTEwpOworCX0KK30KKworCitpbnQgd3Bhc19wMnBfd3BzX2VhcG9sX2NiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJaWYgKCF3cGFfcy0+Z2xvYmFsLT5wMnBfZmFpbF9vbl93cHNfY29tcGxldGUgfHwKKwkgICAgIXdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nKQorCQlyZXR1cm4gMDsKKworCXdwYXNfcDJwX2dycGZvcm1fZmFpbF9hZnRlcl93cHMod3BhX3MpOworCisJcmV0dXJuIDE7CiB9CiAKIApAQCAtNDg2OCw3ICs1NjYwLDcgQEAKIAkJd3BhX3MtPmF1dG9fcGRfc2Nhbl9yZXRyeSA9IDA7CiAJCXdwYXNfcDJwX3N0b3BfZmluZCh3cGFfcyk7CiAJCXdwYV9zLT5wMnBfam9pbl9zY2FuX2NvdW50ID0gMDsKLQkJb3NfZ2V0X3RpbWUoJndwYV9zLT5wMnBfYXV0b19zdGFydGVkKTsKKwkJb3NfZ2V0X3JlbHRpbWUoJndwYV9zLT5wMnBfYXV0b19zdGFydGVkKTsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEF1dG8gUEQgc3RhcnRlZCBhdCAlbGQuJTA2bGQiLAogCQkJICAgd3BhX3MtPnAycF9hdXRvX3N0YXJ0ZWQuc2VjLAogCQkJICAgd3BhX3MtPnAycF9hdXRvX3N0YXJ0ZWQudXNlYyk7CkBAIC00ODc2LDEyICs1NjY4LDYgQEAKIAkJcmV0dXJuIDA7CiAJfQogCi0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKSB7Ci0JCXJldHVybiB3cGFfZHJ2X3AycF9wcm92X2Rpc2NfcmVxKHdwYV9zLCBwZWVyX2FkZHIsCi0JCQkJCQkgY29uZmlnX21ldGhvZHMsCi0JCQkJCQkgdXNlID09IFdQQVNfUDJQX1BEX0ZPUl9KT0lOKTsKLQl9Ci0KIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwgfHwgd3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkKQogCQlyZXR1cm4gLTE7CiAKQEAgLTQ5MDMsNiArNTY4OSw4IEBACiAJaWYgKCFvZmZjaGFubmVsX3BlbmRpbmdfYWN0aW9uX3R4KHdwYV9zKSkKIAkJcmV0dXJuOwogCisJd3Bhc19wMnBfYWN0aW9uX3R4X2NsZWFyKHdwYV9zKTsKKwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBEcm9wIHBlbmRpbmcgQWN0aW9uIFRYIGR1ZSB0byBuZXcgIgogCQkgICAib3BlcmF0aW9uIHJlcXVlc3QiKTsKIAlvZmZjaGFubmVsX2NsZWFyX3BlbmRpbmdfYWN0aW9uX3R4KHdwYV9zKTsKQEAgLTQ5MTcsOSArNTcwNSw2IEBACiAJd3Bhc19wMnBfY2xlYXJfcGVuZGluZ19hY3Rpb25fdHgod3BhX3MpOwogCXdwYV9zLT5wMnBfbG9uZ19saXN0ZW4gPSAwOwogCi0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKQotCQlyZXR1cm4gd3BhX2Rydl9wMnBfZmluZCh3cGFfcywgdGltZW91dCwgdHlwZSk7Ci0KIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMIHx8CiAJICAgIHdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nKQogCQlyZXR1cm4gLTE7CkBAIC00OTM4LDEyICs1NzIzLDYgQEAKIAl3cGFfcy0+cDJwX2xvbmdfbGlzdGVuID0gMDsKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9sb25nX2xpc3Rlbl90aW1lb3V0LCB3cGFfcywgTlVMTCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfam9pbl9zY2FuLCB3cGFfcywgTlVMTCk7Ci0Jd3BhX3MtPmdsb2JhbC0+cDJwX2NiX29uX3NjYW5fY29tcGxldGUgPSAwOwotCi0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKSB7Ci0JCXdwYV9kcnZfcDJwX3N0b3BfZmluZCh3cGFfcyk7Ci0JCXJldHVybiAxOwotCX0KIAogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnApCiAJCXAycF9zdG9wX2ZpbmQod3BhX3MtPmdsb2JhbC0+cDJwKTsKQEAgLTUwODEsNyArNTg2MCw3IEBACiB9CiAKIAotdm9pZCB3cGFzX3AycF9ncm91cF9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3N0YXRpYyB2b2lkIHdwYXNfcDJwX2dyb3VwX2RlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCXAycF9ncm91cF9kZWluaXQod3BhX3MtPnAycF9ncm91cCk7CiAJd3BhX3MtPnAycF9ncm91cCA9IE5VTEw7CkBAIC01MDk3LDkgKzU4NzYsNiBAQAogewogCXdwYV9zLT5wMnBfbG9uZ19saXN0ZW4gPSAwOwogCi0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKQotCQlyZXR1cm4gd3BhX2Rydl9wMnBfcmVqZWN0KHdwYV9zLCBhZGRyKTsKLQogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybiAtMTsKIApAQCAtNTExMCwxMiArNTg4NiwxMyBAQAogLyogSW52aXRlIHRvIHJlaW52b2tlIGEgcGVyc2lzdGVudCBncm91cCAqLwogaW50IHdwYXNfcDJwX2ludml0ZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqcGVlcl9hZGRyLAogCQkgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkLCBjb25zdCB1OCAqZ29fZGV2X2FkZHIsIGludCBmcmVxLAotCQkgICAgaW50IGh0NDAsIGludCBwcmVmX2ZyZXEpCisJCSAgICBpbnQgaHQ0MCwgaW50IHZodCwgaW50IHByZWZfZnJlcSkKIHsKIAllbnVtIHAycF9pbnZpdGVfcm9sZSByb2xlOwogCXU4ICpic3NpZCA9IE5VTEw7CiAJaW50IGZvcmNlX2ZyZXEgPSAwOwogCWludCByZXM7CisJaW50IG5vX3ByZWZfZnJlcV9naXZlbiA9IHByZWZfZnJlcSA9PSAwOwogCiAJd3BhX3MtPmdsb2JhbC0+cDJwX2ludml0ZV9ncm91cCA9IE5VTEw7CiAJaWYgKHBlZXJfYWRkcikKQEAgLTUxNDksMjEgKzU5MjYsMjYgQEAKIAl9CiAJd3BhX3MtPnBlbmRpbmdfaW52aXRlX3NzaWRfaWQgPSBzc2lkLT5pZDsKIAotCXJlcyA9IHdwYXNfcDJwX3NldHVwX2ZyZXFzKHdwYV9zLCBmcmVxLCAmZm9yY2VfZnJlcSwgJnByZWZfZnJlcSk7CisJcmVzID0gd3Bhc19wMnBfc2V0dXBfZnJlcXMod3BhX3MsIGZyZXEsICZmb3JjZV9mcmVxLCAmcHJlZl9mcmVxLAorCQkJCSAgIHJvbGUgPT0gUDJQX0lOVklURV9ST0xFX0dPKTsKIAlpZiAocmVzKQogCQlyZXR1cm4gcmVzOwogCi0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKQotCQlyZXR1cm4gd3BhX2Rydl9wMnBfaW52aXRlKHdwYV9zLCBwZWVyX2FkZHIsIHJvbGUsIGJzc2lkLAotCQkJCQkgIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuLAotCQkJCQkgIGdvX2Rldl9hZGRyLCAxKTsKLQogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAorCWlmICh3cGFfcy0+cGFyZW50LT5jb25mLT5wMnBfaWdub3JlX3NoYXJlZF9mcmVxICYmCisJICAgIG5vX3ByZWZfZnJlcV9naXZlbiAmJiBwcmVmX2ZyZXEgPiAwICYmCisJICAgIHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQgPiAxICYmCisJICAgIHdwYXNfcDJwX251bV91bnVzZWRfY2hhbm5lbHMod3BhX3MpID4gMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogSWdub3JlIG93biBjaGFubmVsIHByZWZlcmVuY2UgJWQgTUh6IGZvciBpbnZpdGF0aW9uIGR1ZSB0byBwMnBfaWdub3JlX3NoYXJlZF9mcmVxPTEgY29uZmlndXJhdGlvbiIsCisJCQkgICBwcmVmX2ZyZXEpOworCQlwcmVmX2ZyZXEgPSAwOworCX0KKwogCXJldHVybiBwMnBfaW52aXRlKHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyLCByb2xlLCBic3NpZCwKIAkJCSAgc3NpZC0+c3NpZCwgc3NpZC0+c3NpZF9sZW4sIGZvcmNlX2ZyZXEsIGdvX2Rldl9hZGRyLAotCQkJICAxLCBwcmVmX2ZyZXEpOworCQkJICAxLCBwcmVmX2ZyZXEsIC0xKTsKIH0KIAogCkBAIC01MTc2LDExICs1OTU4LDEyIEBACiAJdTggKmJzc2lkID0gTlVMTDsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CiAJaW50IHBlcnNpc3RlbnQ7Ci0JaW50IGZvcmNlX2ZyZXEgPSAwLCBwcmVmX2ZyZXEgPSAwOworCWludCBmcmVxID0gMCwgZm9yY2VfZnJlcSA9IDAsIHByZWZfZnJlcSA9IDA7CiAJaW50IHJlczsKIAogCXdwYV9zLT5wMnBfcGVyc2lzdGVudF9nb19mcmVxID0gMDsKIAl3cGFfcy0+cDJwX2dvX2h0NDAgPSAwOworCXdwYV9zLT5wMnBfZ29fdmh0ID0gMDsKIAogCWZvciAod3BhX3MgPSBnbG9iYWwtPmlmYWNlczsgd3BhX3M7IHdwYV9zID0gd3BhX3MtPm5leHQpIHsKIAkJaWYgKG9zX3N0cmNtcCh3cGFfcy0+aWZuYW1lLCBpZm5hbWUpID09IDApCkBAIC01MjA4LDYgKzU5OTEsNyBAQAogCQlic3NpZCA9IHdwYV9zLT5vd25fYWRkcjsKIAkJaWYgKGdvX2Rldl9hZGRyID09IE5VTEwpCiAJCQlnb19kZXZfYWRkciA9IHdwYV9zLT5nbG9iYWwtPnAycF9kZXZfYWRkcjsKKwkJZnJlcSA9IHNzaWQtPmZyZXF1ZW5jeTsKIAl9IGVsc2UgewogCQlyb2xlID0gUDJQX0lOVklURV9ST0xFX0NMSUVOVDsKIAkJaWYgKHdwYV9zLT53cGFfc3RhdGUgPCBXUEFfQVNTT0NJQVRFRCkgewpAQCAtNTIxOSwzNiArNjAwMywzNSBAQAogCQlpZiAoZ29fZGV2X2FkZHIgPT0gTlVMTCAmJgogCQkgICAgIWlzX3plcm9fZXRoZXJfYWRkcih3cGFfcy0+Z29fZGV2X2FkZHIpKQogCQkJZ29fZGV2X2FkZHIgPSB3cGFfcy0+Z29fZGV2X2FkZHI7CisJCWZyZXEgPSB3cGFfcy0+Y3VycmVudF9ic3MgPyB3cGFfcy0+Y3VycmVudF9ic3MtPmZyZXEgOgorCQkJKGludCkgd3BhX3MtPmFzc29jX2ZyZXE7CiAJfQogCXdwYV9zLT5wYXJlbnQtPnBlbmRpbmdfaW52aXRlX3NzaWRfaWQgPSAtMTsKIAotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJcmV0dXJuIHdwYV9kcnZfcDJwX2ludml0ZSh3cGFfcywgcGVlcl9hZGRyLCByb2xlLCBic3NpZCwKLQkJCQkJICBzc2lkLT5zc2lkLCBzc2lkLT5zc2lkX2xlbiwKLQkJCQkJICBnb19kZXZfYWRkciwgcGVyc2lzdGVudCk7Ci0KIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAKLQlyZXMgPSB3cGFzX3AycF9zZXR1cF9mcmVxcyh3cGFfcywgMCwgJmZvcmNlX2ZyZXEsICZwcmVmX2ZyZXEpOworCXJlcyA9IHdwYXNfcDJwX3NldHVwX2ZyZXFzKHdwYV9zLCBmcmVxLCAmZm9yY2VfZnJlcSwgJnByZWZfZnJlcSwKKwkJCQkgICByb2xlID09IFAyUF9JTlZJVEVfUk9MRV9BQ1RJVkVfR08pOwogCWlmIChyZXMpCiAJCXJldHVybiByZXM7CiAJd3Bhc19wMnBfc2V0X293bl9mcmVxX3ByZWZlcmVuY2Uod3BhX3MsIGZvcmNlX2ZyZXEpOwogCiAJcmV0dXJuIHAycF9pbnZpdGUod3BhX3MtPmdsb2JhbC0+cDJwLCBwZWVyX2FkZHIsIHJvbGUsIGJzc2lkLAogCQkJICBzc2lkLT5zc2lkLCBzc2lkLT5zc2lkX2xlbiwgZm9yY2VfZnJlcSwKLQkJCSAgZ29fZGV2X2FkZHIsIHBlcnNpc3RlbnQsIHByZWZfZnJlcSk7CisJCQkgIGdvX2Rldl9hZGRyLCBwZXJzaXN0ZW50LCBwcmVmX2ZyZXEsIC0xKTsKIH0KIAogCiB2b2lkIHdwYXNfcDJwX2NvbXBsZXRlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7Ci0JY29uc3QgY2hhciAqc3NpZF90eHQ7CiAJdTggZ29fZGV2X2FkZHJbRVRIX0FMRU5dOwogCWludCBuZXR3b3JrX2lkID0gLTE7CiAJaW50IHBlcnNpc3RlbnQ7CiAJaW50IGZyZXE7CisJdTggaXBbMyAqIDRdOworCWNoYXIgaXBfYWRkclsxMDBdOwogCiAJaWYgKHNzaWQgPT0gTlVMTCB8fCBzc2lkLT5tb2RlICE9IFdQQVNfTU9ERV9QMlBfR1JPVVBfRk9STUFUSU9OKSB7CiAJCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LApAQCAtNTI1NiwxMSArNjAzOSwxMCBAQAogCX0KIAogCWlmICghd3BhX3MtPnNob3dfZ3JvdXBfc3RhcnRlZCB8fCAhc3NpZCkKLQkJZ290byBkb25lOworCQlyZXR1cm47CiAKIAl3cGFfcy0+c2hvd19ncm91cF9zdGFydGVkID0gMDsKIAotCXNzaWRfdHh0ID0gd3BhX3NzaWRfdHh0KHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKIAlvc19tZW1zZXQoZ29fZGV2X2FkZHIsIDAsIEVUSF9BTEVOKTsKIAlpZiAoc3NpZC0+YnNzaWRfc2V0KQogCQlvc19tZW1jcHkoZ29fZGV2X2FkZHIsIHNzaWQtPmJzc2lkLCBFVEhfQUxFTik7CkBAIC01MjczLDQyICs2MDU1LDM2IEBACiAKIAlmcmVxID0gd3BhX3MtPmN1cnJlbnRfYnNzID8gd3BhX3MtPmN1cnJlbnRfYnNzLT5mcmVxIDoKIAkJKGludCkgd3BhX3MtPmFzc29jX2ZyZXE7Ci0JaWYgKHNzaWQtPnBhc3NwaHJhc2UgPT0gTlVMTCAmJiBzc2lkLT5wc2tfc2V0KSB7Ci0JCWNoYXIgcHNrWzY1XTsKLQkJd3BhX3NucHJpbnRmX2hleChwc2ssIHNpemVvZihwc2spLCBzc2lkLT5wc2ssIDMyKTsKLQkJd3BhX21zZ19nbG9iYWwod3BhX3MtPnBhcmVudCwgTVNHX0lORk8sIFAyUF9FVkVOVF9HUk9VUF9TVEFSVEVECi0JCQkgICAgICAgIiVzIGNsaWVudCBzc2lkPVwiJXNcIiBmcmVxPSVkIHBzaz0lcyAiCi0JCQkgICAgICAgImdvX2Rldl9hZGRyPSIgTUFDU1RSICIlcyIsCi0JCQkgICAgICAgd3BhX3MtPmlmbmFtZSwgc3NpZF90eHQsIGZyZXEsIHBzaywKLQkJCSAgICAgICBNQUMyU1RSKGdvX2Rldl9hZGRyKSwKLQkJCSAgICAgICBwZXJzaXN0ZW50ID8gIiBbUEVSU0lTVEVOVF0iIDogIiIpOwotCX0gZWxzZSB7Ci0JCXdwYV9tc2dfZ2xvYmFsKHdwYV9zLT5wYXJlbnQsIE1TR19JTkZPLCBQMlBfRVZFTlRfR1JPVVBfU1RBUlRFRAotCQkJICAgICAgICIlcyBjbGllbnQgc3NpZD1cIiVzXCIgZnJlcT0lZCAiCi0JCQkgICAgICAgInBhc3NwaHJhc2U9XCIlc1wiIGdvX2Rldl9hZGRyPSIgTUFDU1RSICIlcyIsCi0JCQkgICAgICAgd3BhX3MtPmlmbmFtZSwgc3NpZF90eHQsIGZyZXEsCi0JCQkgICAgICAgc3NpZC0+cGFzc3BocmFzZSA/IHNzaWQtPnBhc3NwaHJhc2UgOiAiIiwKLQkJCSAgICAgICBNQUMyU1RSKGdvX2Rldl9hZGRyKSwKLQkJCSAgICAgICBwZXJzaXN0ZW50ID8gIiBbUEVSU0lTVEVOVF0iIDogIiIpOworCisJaXBfYWRkclswXSA9ICdcMCc7CisJaWYgKHdwYV9zbV9nZXRfcDJwX2lwX2FkZHIod3BhX3MtPndwYSwgaXApID09IDApIHsKKwkJb3Nfc25wcmludGYoaXBfYWRkciwgc2l6ZW9mKGlwX2FkZHIpLCAiIGlwX2FkZHI9JXUuJXUuJXUuJXUgIgorCQkJICAgICJpcF9tYXNrPSV1LiV1LiV1LiV1IGdvX2lwX2FkZHI9JXUuJXUuJXUuJXUiLAorCQkJICAgIGlwWzBdLCBpcFsxXSwgaXBbMl0sIGlwWzNdLAorCQkJICAgIGlwWzRdLCBpcFs1XSwgaXBbNl0sIGlwWzddLAorCQkJICAgIGlwWzhdLCBpcFs5XSwgaXBbMTBdLCBpcFsxMV0pOwogCX0KIAorCXdwYXNfcDJwX2dyb3VwX3N0YXJ0ZWQod3BhX3MsIDAsIHNzaWQsIGZyZXEsCisJCQkgICAgICAgc3NpZC0+cGFzc3BocmFzZSA9PSBOVUxMICYmIHNzaWQtPnBza19zZXQgPworCQkJICAgICAgIHNzaWQtPnBzayA6IE5VTEwsCisJCQkgICAgICAgc3NpZC0+cGFzc3BocmFzZSwgZ29fZGV2X2FkZHIsIHBlcnNpc3RlbnQsCisJCQkgICAgICAgaXBfYWRkcik7CisKIAlpZiAocGVyc2lzdGVudCkKIAkJbmV0d29ya19pZCA9IHdwYXNfcDJwX3N0b3JlX3BlcnNpc3RlbnRfZ3JvdXAod3BhX3MtPnBhcmVudCwKIAkJCQkJCQkgICAgIHNzaWQsIGdvX2Rldl9hZGRyKTsKIAlpZiAobmV0d29ya19pZCA8IDApCiAJCW5ldHdvcmtfaWQgPSBzc2lkLT5pZDsKIAl3cGFzX25vdGlmeV9wMnBfZ3JvdXBfc3RhcnRlZCh3cGFfcywgc3NpZCwgbmV0d29ya19pZCwgMSk7Ci0KLWRvbmU6Ci0Jd3Bhc19wMnBfY29udGludWVfYWZ0ZXJfc2Nhbih3cGFfcyk7CiB9CiAKIAogaW50IHdwYXNfcDJwX3ByZXNlbmNlX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCB1MzIgZHVyYXRpb24xLAogCQkJICB1MzIgaW50ZXJ2YWwxLCB1MzIgZHVyYXRpb24yLCB1MzIgaW50ZXJ2YWwyKQogewotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJcmV0dXJuIC0xOworCWludCByZXQ7CisKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAKQEAgLTUzMTcsMTggKzYwOTMsMTkgQEAKIAkgICAgd3BhX3MtPmN1cnJlbnRfc3NpZC0+bW9kZSAhPSBXUEFTX01PREVfSU5GUkEpCiAJCXJldHVybiAtMTsKIAotCXJldHVybiBwMnBfcHJlc2VuY2VfcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgd3BhX3MtPmJzc2lkLAotCQkJCXdwYV9zLT5vd25fYWRkciwgd3BhX3MtPmFzc29jX2ZyZXEsCi0JCQkJZHVyYXRpb24xLCBpbnRlcnZhbDEsIGR1cmF0aW9uMiwgaW50ZXJ2YWwyKTsKKwlyZXQgPSBwMnBfcHJlc2VuY2VfcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgd3BhX3MtPmJzc2lkLAorCQkJICAgICAgIHdwYV9zLT5vd25fYWRkciwgd3BhX3MtPmFzc29jX2ZyZXEsCisJCQkgICAgICAgZHVyYXRpb24xLCBpbnRlcnZhbDEsIGR1cmF0aW9uMiwgaW50ZXJ2YWwyKTsKKwlpZiAocmV0ID09IDApCisJCXdwYV9zLT53YWl0aW5nX3ByZXNlbmNlX3Jlc3AgPSAxOworCisJcmV0dXJuIHJldDsKIH0KIAogCiBpbnQgd3Bhc19wMnBfZXh0X2xpc3RlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCB1bnNpZ25lZCBpbnQgcGVyaW9kLAogCQkJdW5zaWduZWQgaW50IGludGVydmFsKQogewotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJcmV0dXJuIC0xOwotCiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCkBAIC01NDMwLDggKzYyMDcsNiBAQAogewogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybiAwOwotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJcmV0dXJuIDA7CiAKIAlpZiAoIWxvY2FsbHlfZ2VuZXJhdGVkKQogCQlwMnBfZGVhdXRoX25vdGlmKHdwYV9zLT5nbG9iYWwtPnAycCwgYnNzaWQsIHJlYXNvbl9jb2RlLCBpZSwKQEAgLTU0NTksOCArNjIzNCw2IEBACiB7CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKIAkJcmV0dXJuOwotCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKLQkJcmV0dXJuOwogCiAJaWYgKCFsb2NhbGx5X2dlbmVyYXRlZCkKIAkJcDJwX2Rpc2Fzc29jX25vdGlmKHdwYV9zLT5nbG9iYWwtPnAycCwgYnNzaWQsIHJlYXNvbl9jb2RlLCBpZSwKQEAgLTU1MzcsMTAgKzYzMTAsMTMgQEAKIAkJdTggcmVnX2NsYXNzLCBjaGFubmVsOwogCQlpbnQgcmV0OwogCQl1bnNpZ25lZCBpbnQgcjsKKwkJdTggY2hhbm5lbF9mb3JjZWQ7CisKIAkJaWYgKHdwYV9zLT5jb25mLT5wMnBfbGlzdGVuX3JlZ19jbGFzcyAmJgogCQkgICAgd3BhX3MtPmNvbmYtPnAycF9saXN0ZW5fY2hhbm5lbCkgewogCQkJcmVnX2NsYXNzID0gd3BhX3MtPmNvbmYtPnAycF9saXN0ZW5fcmVnX2NsYXNzOwogCQkJY2hhbm5lbCA9IHdwYV9zLT5jb25mLT5wMnBfbGlzdGVuX2NoYW5uZWw7CisJCQljaGFubmVsX2ZvcmNlZCA9IDE7CiAJCX0gZWxzZSB7CiAJCQlyZWdfY2xhc3MgPSA4MTsKIAkJCS8qCkBAIC01NTQ5LDggKzYzMjUsMTAgQEAKIAkJCSAqLwogCQkJb3NfZ2V0X3JhbmRvbSgodTggKikgJnIsIHNpemVvZihyKSk7CiAJCQljaGFubmVsID0gMSArIChyICUgMykgKiA1OworCQkJY2hhbm5lbF9mb3JjZWQgPSAwOwogCQl9Ci0JCXJldCA9IHAycF9zZXRfbGlzdGVuX2NoYW5uZWwocDJwLCByZWdfY2xhc3MsIGNoYW5uZWwpOworCQlyZXQgPSBwMnBfc2V0X2xpc3Rlbl9jaGFubmVsKHAycCwgcmVnX2NsYXNzLCBjaGFubmVsLAorCQkJCQkgICAgIGNoYW5uZWxfZm9yY2VkKTsKIAkJaWYgKHJldCkKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUDJQOiBPd24gbGlzdGVuIGNoYW5uZWwgdXBkYXRlICIKIAkJCQkgICAiZmFpbGVkOiAlZCIsIHJldCk7CkBAIC01NTg3LDcgKzYzNjUsMTUgQEAKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUDJQOiBQcmVmZXJyZWQgY2hhbm5lbCBsaXN0ICIKIAkJCQkgICAidXBkYXRlIGZhaWxlZCIpOwogCQl9CisKKwkJaWYgKHAycF9zZXRfbm9fZ29fZnJlcShwMnAsICZ3cGFfcy0+Y29uZi0+cDJwX25vX2dvX2ZyZXEpIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJQMlA6IE5vIEdPIGNoYW5uZWwgbGlzdCAiCisJCQkJICAgInVwZGF0ZSBmYWlsZWQiKTsKKwkJfQogCX0KKworCWlmICh3cGFfcy0+Y29uZi0+Y2hhbmdlZF9wYXJhbWV0ZXJzICYgQ0ZHX0NIQU5HRURfUDJQX1BBU1NQSFJBU0VfTEVOKQorCQlwMnBfc2V0X3Bhc3NwaHJhc2VfbGVuKHAycCwgd3BhX3MtPmNvbmYtPnAycF9wYXNzcGhyYXNlX2xlbik7CiB9CiAKIApAQCAtNTYwNSw4ICs2MzkxLDYgQEAKIHsKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7Ci0JaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKQotCQlyZXR1cm4gLTE7CiAKIAl3cGFfcy0+Z2xvYmFsLT5jcm9zc19jb25uZWN0aW9uID0gZW5hYmxlZDsKIAlwMnBfc2V0X2Nyb3NzX2Nvbm5lY3Qod3BhX3MtPmdsb2JhbC0+cDJwLCBlbmFibGVkKTsKQEAgLTU3NTYsMjEgKzY1NDAsNTIgQEAKIH0KIAogCit2b2lkIHdwYXNfcDJwX3BiY19vdmVybGFwX2NiKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKKwl3cGFzX3AycF9ub3RpZl9wYmNfb3ZlcmxhcCh3cGFfcyk7Cit9CisKKwogdm9pZCB3cGFzX3AycF91cGRhdGVfY2hhbm5lbF9saXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7Ci0Jc3RydWN0IHAycF9jaGFubmVscyBjaGFuOworCXN0cnVjdCBwMnBfY2hhbm5lbHMgY2hhbiwgY2xpX2NoYW47CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICppZnM7CiAKIAlpZiAod3BhX3MtPmdsb2JhbCA9PSBOVUxMIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm47CiAKIAlvc19tZW1zZXQoJmNoYW4sIDAsIHNpemVvZihjaGFuKSk7Ci0JaWYgKHdwYXNfcDJwX3NldHVwX2NoYW5uZWxzKHdwYV9zLCAmY2hhbikpIHsKKwlvc19tZW1zZXQoJmNsaV9jaGFuLCAwLCBzaXplb2YoY2xpX2NoYW4pKTsKKwlpZiAod3Bhc19wMnBfc2V0dXBfY2hhbm5lbHMod3BhX3MsICZjaGFuLCAmY2xpX2NoYW4pKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUDJQOiBGYWlsZWQgdG8gdXBkYXRlIHN1cHBvcnRlZCAiCiAJCQkgICAiY2hhbm5lbCBsaXN0Iik7CiAJCXJldHVybjsKIAl9CiAKLQlwMnBfdXBkYXRlX2NoYW5uZWxfbGlzdCh3cGFfcy0+Z2xvYmFsLT5wMnAsICZjaGFuKTsKKwlwMnBfdXBkYXRlX2NoYW5uZWxfbGlzdCh3cGFfcy0+Z2xvYmFsLT5wMnAsICZjaGFuLCAmY2xpX2NoYW4pOworCisJZm9yIChpZnMgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IGlmczsgaWZzID0gaWZzLT5uZXh0KSB7CisJCWludCBmcmVxOworCQlpZiAoIWlmcy0+Y3VycmVudF9zc2lkIHx8CisJCSAgICAhaWZzLT5jdXJyZW50X3NzaWQtPnAycF9ncm91cCB8fAorCQkgICAgKGlmcy0+Y3VycmVudF9zc2lkLT5tb2RlICE9IFdQQVNfTU9ERV9QMlBfR08gJiYKKwkJICAgICBpZnMtPmN1cnJlbnRfc3NpZC0+bW9kZSAhPSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTikpCisJCQkJY29udGludWU7CisJCWZyZXEgPSBpZnMtPmN1cnJlbnRfc3NpZC0+ZnJlcXVlbmN5OworCQlpZiAoZnJlcV9pbmNsdWRlZCgmY2hhbiwgZnJlcSkpIHsKKwkJCXdwYV9kYmcoaWZzLCBNU0dfREVCVUcsCisJCQkJIlAyUCBHTyBvcGVyYXRpbmcgZnJlcXVlbmN5ICVkIE1IeiBpbiB2YWxpZCByYW5nZSIsCisJCQkJZnJlcSk7CisJCQljb250aW51ZTsKKwkJfQorCisJCXdwYV9kYmcoaWZzLCBNU0dfREVCVUcsCisJCQkiUDJQIEdPIG9wZXJhdGluZyBpbiBpbnZhbGlkIGZyZXF1ZW5jeSAlZCBNSHoiLAlmcmVxKTsKKwkJLyogVE9ETzogQ29uc2lkZXIgdXNpbmcgQ1NBIG9yIHJlbW92aW5nIHRoZSBncm91cCB3aXRoaW4KKwkJICogd3BhX3N1cHBsaWNhbnQgKi8KKwkJd3BhX21zZyhpZnMsIE1TR19JTkZPLCBQMlBfRVZFTlRfUkVNT1ZFX0FORF9SRUZPUk1fR1JPVVApOworCX0KIH0KIAogCkBAIC01ODM2LDYgKzY2NTEsMTEgQEAKIAkJCXdwYXNfcDJwX2dyb3VwX2RlbGV0ZSh3cGFfcywKIAkJCQkJICAgICAgUDJQX0dST1VQX1JFTU9WQUxfUkVRVUVTVEVEKTsKIAkJCWJyZWFrOworCQl9IGVsc2UgaWYgKHdwYV9zLT5wMnBfaW5faW52aXRhdGlvbikgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEludGVyZmFjZSAlcyBpbiBpbnZpdGF0aW9uIGZvdW5kIC0gY2FuY2VsbGluZyIsCisJCQkJICAgd3BhX3MtPmlmbmFtZSk7CisJCQlmb3VuZCA9IDE7CisJCQl3cGFzX3AycF9ncm91cF9mb3JtYXRpb25fZmFpbGVkKHdwYV9zKTsKIAkJfQogCX0KIApAQCAtNTg2Myw3ICs2NjgzLDcgQEAKIAkJCQkgICBpbnQgZnJlcV8yNCwgaW50IGZyZXFfNSwgaW50IGZyZXFfb3ZlcmFsbCkKIHsKIAlzdHJ1Y3QgcDJwX2RhdGEgKnAycCA9IHdwYV9zLT5nbG9iYWwtPnAycDsKLQlpZiAocDJwID09IE5VTEwgfHwgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKSkKKwlpZiAocDJwID09IE5VTEwpCiAJCXJldHVybjsKIAlwMnBfc2V0X2Jlc3RfY2hhbm5lbHMocDJwLCBmcmVxXzI0LCBmcmVxXzUsIGZyZXFfb3ZlcmFsbCk7CiB9CkBAIC01ODc0LDcgKzY2OTQsNyBAQAogCXU4IHBlZXJbRVRIX0FMRU5dOwogCXN0cnVjdCBwMnBfZGF0YSAqcDJwID0gd3BhX3MtPmdsb2JhbC0+cDJwOwogCi0JaWYgKHAycCA9PSBOVUxMIHx8ICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkpCisJaWYgKHAycCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAKIAlpZiAoaHdhZGRyX2F0b24oYWRkciwgcGVlcikpCkBAIC01OTMxLDEwICs2NzUxLDEwIEBACiAJfQogCiAJaWYgKCFyZXQgJiYgd3BhX3MtPmdsb2JhbC0+cDJwX2dvX3dhaXRfY2xpZW50LnNlYykgewotCQlzdHJ1Y3Qgb3NfdGltZSBub3c7Ci0JCW9zX2dldF90aW1lKCZub3cpOwotCQlpZiAobm93LnNlYyA+IHdwYV9zLT5nbG9iYWwtPnAycF9nb193YWl0X2NsaWVudC5zZWMgKwotCQkgICAgUDJQX01BWF9JTklUSUFMX0NPTk5fV0FJVF9HTykgeworCQlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CisJCW9zX2dldF9yZWx0aW1lKCZub3cpOworCQlpZiAob3NfcmVsdGltZV9leHBpcmVkKCZub3csICZ3cGFfcy0+Z2xvYmFsLT5wMnBfZ29fd2FpdF9jbGllbnQsCisJCQkJICAgICAgIFAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVRfR08pKSB7CiAJCQkvKiBXYWl0IGZvciB0aGUgZmlyc3QgY2xpZW50IGhhcyBleHBpcmVkICovCiAJCQl3cGFfcy0+Z2xvYmFsLT5wMnBfZ29fd2FpdF9jbGllbnQuc2VjID0gMDsKIAkJfSBlbHNlIHsKQEAgLTYwMDcsNiArNjgyNywyNiBAQAogdm9pZCB3cGFzX3AycF9ub3RpZnlfYXBfc3RhX2F1dGhvcml6ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgICAgY29uc3QgdTggKmFkZHIpCiB7CisJaWYgKGVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LAorCQkJCSB3cGFfcy0+cGFyZW50LCBOVUxMKSA+IDApIHsKKwkJLyoKKwkJICogVGhpcyBjYW4gaGFwcGVuIGlmIFdQUyBwcm92aXNpb25pbmcgc3RlcCBpcyBub3QgdGVybWluYXRlZAorCQkgKiBjbGVhbmx5IChlLmcuLCBQMlAgQ2xpZW50IGRvZXMgbm90IHNlbmQgV1NDX0RvbmUpLiBTaW5jZSB0aGUKKwkJICogcGVlciB3YXMgYWJsZSB0byBjb25uZWN0LCB0aGVyZSBpcyBubyBuZWVkIHRvIHRpbWUgb3V0IGdyb3VwCisJCSAqIGZvcm1hdGlvbiBhZnRlciB0aGlzLCB0aG91Z2guIEluIGFkZGl0aW9uLCB0aGlzIGlzIHVzZWQgd2l0aAorCQkgKiB0aGUgaW5pdGlhbCBjb25uZWN0aW9uIHdhaXQgb24gdGhlIEdPIGFzIGEgc2VwYXJhdGUgZm9ybWF0aW9uCisJCSAqIHRpbWVvdXQgYW5kIGFzIHN1Y2gsIGV4cGVjdGVkIHRvIGJlIGhpdCBhZnRlciB0aGUgaW5pdGlhbCBXUFMKKwkJICogcHJvdmlzaW9uaW5nIHN0ZXAuCisJCSAqLworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ2FuY2VsZWQgUDJQIGdyb3VwIGZvcm1hdGlvbiB0aW1lb3V0IG9uIGRhdGEgY29ubmVjdGlvbiIpOworCX0KKwlpZiAoIXdwYV9zLT5wMnBfZ29fZ3JvdXBfZm9ybWF0aW9uX2NvbXBsZXRlZCkgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IE1hcmtpbmcgZ3JvdXAgZm9ybWF0aW9uIGNvbXBsZXRlZCBvbiBHTyBvbiBmaXJzdCBkYXRhIGNvbm5lY3Rpb24iKTsKKwkJd3BhX3MtPnAycF9nb19ncm91cF9mb3JtYXRpb25fY29tcGxldGVkID0gMTsKKwkJd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbiA9IE5VTEw7CisJCXdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nID0gMDsKKwkJd3BhX3MtPnAycF9pbl9pbnZpdGF0aW9uID0gMDsKKwl9CiAJd3BhX3MtPmdsb2JhbC0+cDJwX2dvX3dhaXRfY2xpZW50LnNlYyA9IDA7CiAJaWYgKGFkZHIgPT0gTlVMTCkKIAkJcmV0dXJuOwpAQCAtNjAzMCw3ICs2ODcwLDggQEAKIAkJCSAwLCAwLCB3cGFfcy0+cDJwX2dvX2ludGVudCwgd3BhX3MtPnAycF9jb25uZWN0X2ZyZXEsCiAJCQkgd3BhX3MtPnAycF9wZXJzaXN0ZW50X2lkLAogCQkJIHdwYV9zLT5wMnBfcGRfYmVmb3JlX2dvX25lZywKLQkJCSB3cGFfcy0+cDJwX2dvX2h0NDApOworCQkJIHdwYV9zLT5wMnBfZ29faHQ0MCwKKwkJCSB3cGFfcy0+cDJwX2dvX3ZodCk7CiB9CiAKIApAQCAtNjA1MywzNSArNjg5NCwyNCBAQAogCiB1bnNpZ25lZCBpbnQgd3Bhc19wMnBfc2VhcmNoX2RlbGF5KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7Ci0JY29uc3QgY2hhciAqcm4sICpybjI7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICppZnM7CiAKIAlpZiAod3BhX3MtPndwYV9zdGF0ZSA+IFdQQV9TQ0FOTklORykgewogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IFVzZSAldSBtcyBzZWFyY2ggZGVsYXkgZHVlIHRvICIKIAkJCSJjb25jdXJyZW50IG9wZXJhdGlvbiIsCi0JCQlQMlBfQ09OQ1VSUkVOVF9TRUFSQ0hfREVMQVkpOwotCQlyZXR1cm4gUDJQX0NPTkNVUlJFTlRfU0VBUkNIX0RFTEFZOworCQkJd3BhX3MtPmNvbmYtPnAycF9zZWFyY2hfZGVsYXkpOworCQlyZXR1cm4gd3BhX3MtPmNvbmYtPnAycF9zZWFyY2hfZGVsYXk7CiAJfQogCi0JaWYgKCF3cGFfcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSkKLQkJcmV0dXJuIDA7Ci0Jcm4gPSB3cGFfcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSh3cGFfcy0+ZHJ2X3ByaXYpOwotCWlmIChybiA9PSBOVUxMIHx8IHJuWzBdID09ICdcMCcpCi0JCXJldHVybiAwOwotCi0JZm9yIChpZnMgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IGlmczsgaWZzID0gaWZzLT5uZXh0KSB7Ci0JCWlmIChpZnMgPT0gd3BhX3MgfHwgIWlmcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSkKLQkJCWNvbnRpbnVlOwotCi0JCXJuMiA9IGlmcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZShpZnMtPmRydl9wcml2KTsKLQkJaWYgKCFybjIgfHwgb3Nfc3RyY21wKHJuLCBybjIpICE9IDApCi0JCQljb250aW51ZTsKLQkJaWYgKGlmcy0+d3BhX3N0YXRlID4gV1BBX1NDQU5OSU5HKSB7CisJZGxfbGlzdF9mb3JfZWFjaChpZnMsICZ3cGFfcy0+cmFkaW8tPmlmYWNlcywgc3RydWN0IHdwYV9zdXBwbGljYW50LAorCQkJIHJhZGlvX2xpc3QpIHsKKwkJaWYgKGlmcyAhPSB3cGFfcyAmJiBpZnMtPndwYV9zdGF0ZSA+IFdQQV9TQ0FOTklORykgewogCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBVc2UgJXUgbXMgc2VhcmNoICIKIAkJCQkiZGVsYXkgZHVlIHRvIGNvbmN1cnJlbnQgb3BlcmF0aW9uIG9uICIKIAkJCQkiaW50ZXJmYWNlICVzIiwKLQkJCQlQMlBfQ09OQ1VSUkVOVF9TRUFSQ0hfREVMQVksIGlmcy0+aWZuYW1lKTsKLQkJCXJldHVybiBQMlBfQ09OQ1VSUkVOVF9TRUFSQ0hfREVMQVk7CisJCQkJd3BhX3MtPmNvbmYtPnAycF9zZWFyY2hfZGVsYXksCisJCQkJaWZzLT5pZm5hbWUpOworCQkJcmV0dXJuIHdwYV9zLT5jb25mLT5wMnBfc2VhcmNoX2RlbGF5OwogCQl9CiAJfQogCkBAIC02MDg5LDMwICs2OTE5LDYgQEAKIH0KIAogCi12b2lkIHdwYXNfcDJwX2NvbnRpbnVlX2FmdGVyX3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKLXsKLQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IFN0YXRpb24gbW9kZSBzY2FuIG9wZXJhdGlvbiBub3QgIgotCQkicGVuZGluZyBhbnltb3JlIChzdGFfc2Nhbl9wZW5kaW5nPSVkICIKLQkJInAycF9jYl9vbl9zY2FuX2NvbXBsZXRlPSVkKSIsIHdwYV9zLT5zdGFfc2Nhbl9wZW5kaW5nLAotCQl3cGFfcy0+Z2xvYmFsLT5wMnBfY2Jfb25fc2Nhbl9jb21wbGV0ZSk7Ci0Jd3BhX3MtPnN0YV9zY2FuX3BlbmRpbmcgPSAwOwotCi0JaWYgKCF3cGFfcy0+Z2xvYmFsLT5wMnBfY2Jfb25fc2Nhbl9jb21wbGV0ZSkKLQkJcmV0dXJuOwotCXdwYV9zLT5nbG9iYWwtPnAycF9jYl9vbl9zY2FuX2NvbXBsZXRlID0gMDsKLQotCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCi0JCXJldHVybjsKLQotCWlmIChwMnBfb3RoZXJfc2Nhbl9jb21wbGV0ZWQod3BhX3MtPmdsb2JhbC0+cDJwKSA9PSAxKSB7Ci0JCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlAyUDogUGVuZGluZyBQMlAgb3BlcmF0aW9uICIKLQkJCSJjb250aW51ZWQgYWZ0ZXIgc3VjY2Vzc2Z1bCBjb25uZWN0aW9uIik7Ci0JCXAycF9pbmNyZWFzZV9zZWFyY2hfZGVsYXkod3BhX3MtPmdsb2JhbC0+cDJwLAotCQkJCQkgIHdwYXNfcDJwX3NlYXJjaF9kZWxheSh3cGFfcykpOwotCX0KLX0KLQotCiBzdGF0aWMgaW50IHdwYXNfcDJwX3JlbW92ZV9wc2tfZW50cnkoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgIHN0cnVjdCB3cGFfc3NpZCAqcywgY29uc3QgdTggKmFkZHIsCiAJCQkJICAgICBpbnQgaWZhY2VfYWRkcikKQEAgLTYxNDYsNyArNjk1Miw3IEBACiB7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkID0gd3BhX3MtPmN1cnJlbnRfc3NpZDsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnBlcnNpc3RlbnQ7Ci0Jc3RydWN0IHBza19saXN0X2VudHJ5ICpwOworCXN0cnVjdCBwc2tfbGlzdF9lbnRyeSAqcCwgKmxhc3Q7CiAKIAlpZiAocHNrX2xlbiAhPSBzaXplb2YocC0+cHNrKSkKIAkJcmV0dXJuOwpAQCAtNjIwNiwxMCArNzAxMiw5IEBACiAJfQogCW9zX21lbWNweShwLT5wc2ssIHBzaywgcHNrX2xlbik7CiAKLQlpZiAoZGxfbGlzdF9sZW4oJnBlcnNpc3RlbnQtPnBza19saXN0KSA+IFAyUF9NQVhfU1RPUkVEX0NMSUVOVFMpIHsKLQkJc3RydWN0IHBza19saXN0X2VudHJ5ICpsYXN0OwotCQlsYXN0ID0gZGxfbGlzdF9sYXN0KCZwZXJzaXN0ZW50LT5wc2tfbGlzdCwKLQkJCQkgICAgc3RydWN0IHBza19saXN0X2VudHJ5LCBsaXN0KTsKKwlpZiAoZGxfbGlzdF9sZW4oJnBlcnNpc3RlbnQtPnBza19saXN0KSA+IFAyUF9NQVhfU1RPUkVEX0NMSUVOVFMgJiYKKwkgICAgKGxhc3QgPSBkbF9saXN0X2xhc3QoJnBlcnNpc3RlbnQtPnBza19saXN0LAorCQkJCSBzdHJ1Y3QgcHNrX2xpc3RfZW50cnksIGxpc3QpKSkgewogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IFJlbW92ZSBvbGRlc3QgUFNLIGVudHJ5IGZvciAiCiAJCQlNQUNTVFIgIiAocDJwPSV1KSB0byBtYWtlIHJvb20gZm9yIGEgbmV3IG9uZSIsCiAJCQlNQUMyU1RSKGxhc3QtPmFkZHIpLCBsYXN0LT5wMnApOwpAQCAtNjIyOSwxMSArNzAzNCw5IEBACiAJfQogCWRsX2xpc3RfYWRkKCZwZXJzaXN0ZW50LT5wc2tfbGlzdCwgJnAtPmxpc3QpOwogCi0jaWZuZGVmIENPTkZJR19OT19DT05GSUdfV1JJVEUKIAlpZiAod3BhX3MtPnBhcmVudC0+Y29uZi0+dXBkYXRlX2NvbmZpZyAmJgogCSAgICB3cGFfY29uZmlnX3dyaXRlKHdwYV9zLT5wYXJlbnQtPmNvbmZuYW1lLCB3cGFfcy0+cGFyZW50LT5jb25mKSkKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEZhaWxlZCB0byB1cGRhdGUgY29uZmlndXJhdGlvbiIpOwotI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfV1JJVEUgKi8KIH0KIAogCkBAIC02MjQ0LDE0ICs3MDQ3LDEwIEBACiAJaW50IHJlczsKIAogCXJlcyA9IHdwYXNfcDJwX3JlbW92ZV9wc2tfZW50cnkod3BhX3MsIHMsIGFkZHIsIGlmYWNlX2FkZHIpOwotCWlmIChyZXMgPiAwKSB7Ci0jaWZuZGVmIENPTkZJR19OT19DT05GSUdfV1JJVEUKLQkJaWYgKHdwYV9zLT5jb25mLT51cGRhdGVfY29uZmlnICYmCi0JCSAgICB3cGFfY29uZmlnX3dyaXRlKHdwYV9zLT5jb25mbmFtZSwgd3BhX3MtPmNvbmYpKQotCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAotCQkJCSJQMlA6IEZhaWxlZCB0byB1cGRhdGUgY29uZmlndXJhdGlvbiIpOwotI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfV1JJVEUgKi8KLQl9CisJaWYgKHJlcyA+IDAgJiYgd3BhX3MtPmNvbmYtPnVwZGF0ZV9jb25maWcgJiYKKwkgICAgd3BhX2NvbmZpZ193cml0ZSh3cGFfcy0+Y29uZm5hbWUsIHdwYV9zLT5jb25mKSkKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAorCQkJIlAyUDogRmFpbGVkIHRvIHVwZGF0ZSBjb25maWd1cmF0aW9uIik7CiB9CiAKIApAQCAtNjMzNiw2ICs3MTM1LDYzIEBACiB9CiAKIAorc3RhdGljIHZvaWQgd3Bhc19wMnBfZ3JvdXBfZnJlcV9jb25mbGljdCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBlbG9vcF9jdHg7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRnJlcXVlbmN5IGNvbmZsaWN0IC0gdGVybWluYXRlIGdyb3VwIik7CisJd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKHdwYV9zLCBQMlBfR1JPVVBfUkVNT1ZBTF9GUkVRX0NPTkZMSUNUKTsKK30KKworCitpbnQgd3Bhc19wMnBfaGFuZGxlX2ZyZXF1ZW5jeV9jb25mbGljdHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEsCisJCQkJCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKK3sKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKmlmYWNlOworCisJZm9yIChpZmFjZSA9IHdwYV9zLT5nbG9iYWwtPmlmYWNlczsgaWZhY2U7IGlmYWNlID0gaWZhY2UtPm5leHQpIHsKKwkJaWYgKCFpZmFjZS0+Y3VycmVudF9zc2lkIHx8CisJCSAgICBpZmFjZS0+Y3VycmVudF9zc2lkLT5mcmVxdWVuY3kgPT0gZnJlcSB8fAorCQkgICAgKGlmYWNlLT5wMnBfZ3JvdXBfaW50ZXJmYWNlID09IE5PVF9QMlBfR1JPVVBfSU5URVJGQUNFICYmCisJCSAgICAgIWlmYWNlLT5jdXJyZW50X3NzaWQtPnAycF9ncm91cCkpCisJCQljb250aW51ZTsKKworCQkvKiBSZW1vdmUgdGhlIGNvbm5lY3Rpb24gd2l0aCBsZWFzdCBwcmlvcml0eSAqLworCQlpZiAoIXdwYXNfaXNfcDJwX3ByaW9yaXRpemVkKGlmYWNlKSkgeworCQkJLyogU1RBIGNvbm5lY3Rpb24gaGFzIHByaW9yaXR5IG92ZXIgZXhpc3RpbmcKKwkJCSAqIFAyUCBjb25uZWN0aW9uLCBzbyByZW1vdmUgdGhlIGludGVyZmFjZS4gKi8KKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBSZW1vdmluZyBQMlAgY29ubmVjdGlvbiBkdWUgdG8gc2luZ2xlIGNoYW5uZWwgY29uY3VycmVudCBtb2RlIGZyZXF1ZW5jeSBjb25mbGljdCIpOworCQkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLAorCQkJCQkgICAgICAgd3Bhc19wMnBfZ3JvdXBfZnJlcV9jb25mbGljdCwKKwkJCQkJICAgICAgIGlmYWNlLCBOVUxMKTsKKwkJCS8qIElmIGNvbm5lY3Rpb24gaW4gcHJvZ3Jlc3MgaXMgUDJQIGNvbm5lY3Rpb24sIGRvIG5vdAorCQkJICogcHJvY2VlZCBmb3IgdGhlIGNvbm5lY3Rpb24uICovCisJCQlpZiAod3BhX3MgPT0gaWZhY2UpCisJCQkJcmV0dXJuIC0xOworCQkJZWxzZQorCQkJCXJldHVybiAwOworCQl9IGVsc2UgeworCQkJLyogUDJQIGNvbm5lY3Rpb24gaGFzIHByaW9yaXR5LCBkaXNhYmxlIHRoZSBTVEEgbmV0d29yaworCQkJICovCisJCQl3cGFfc3VwcGxpY2FudF9kaXNhYmxlX25ldHdvcmsod3BhX3MtPmdsb2JhbC0+aWZhY2VzLAorCQkJCQkJICAgICAgIHNzaWQpOworCQkJd3BhX21zZyh3cGFfcy0+Z2xvYmFsLT5pZmFjZXMsIE1TR19JTkZPLAorCQkJCVdQQV9FVkVOVF9GUkVRX0NPTkZMSUNUICIgaWQ9JWQiLCBzc2lkLT5pZCk7CisJCQlvc19tZW1zZXQod3BhX3MtPmdsb2JhbC0+aWZhY2VzLT5wZW5kaW5nX2Jzc2lkLCAwLAorCQkJCSAgRVRIX0FMRU4pOworCQkJLyogSWYgUDJQIGNvbm5lY3Rpb24gaXMgaW4gcHJvZ3Jlc3MsIGNvbnRpbnVlCisJCQkgKiBjb25uZWN0aW5nLi4uKi8KKwkJCWlmICh3cGFfcyA9PSBpZmFjZSkKKwkJCQlyZXR1cm4gMDsKKwkJCWVsc2UKKwkJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlyZXR1cm4gMDsKK30KKworCiBpbnQgd3Bhc19wMnBfNHdheV9oc19mYWlsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOwpAQCAtNjM4Myw3MiArNzIzOSw2NTUgQEAKIAlyZXR1cm4gMDsKIH0KIAotI2lmZGVmIEFORFJPSURfUDJQCi1zdGF0aWMgdm9pZCB3cGFzX3AycF9ncm91cF9mcmVxX2NvbmZsaWN0KHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCi17Ci0Jc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBGcmVxdWVuY3kgY29uZmxpY3QgLSB0ZXJtaW5hdGUgZ3JvdXAiKTsKLQl3cGFzX3AycF9ncm91cF9kZWxldGUod3BhX3MsIFAyUF9HUk9VUF9SRU1PVkFMX0ZSRVFfQ09ORkxJQ1QpOworI2lmZGVmIENPTkZJR19XUFNfTkZDCisKK3N0YXRpYyBzdHJ1Y3Qgd3BhYnVmICogd3Bhc19wMnBfbmZjX2hhbmRvdmVyKGludCBuZGVmLCBzdHJ1Y3Qgd3BhYnVmICp3c2MsCisJCQkJCSAgICAgc3RydWN0IHdwYWJ1ZiAqcDJwKQoreworCXN0cnVjdCB3cGFidWYgKnJldDsKKwlzaXplX3Qgd3NjX2xlbjsKKworCWlmIChwMnAgPT0gTlVMTCkgeworCQl3cGFidWZfZnJlZSh3c2MpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogTm8gcDJwIGJ1ZmZlciBmb3IgaGFuZG92ZXIiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJd3NjX2xlbiA9IHdzYyA/IHdwYWJ1Zl9sZW4od3NjKSA6IDA7CisJcmV0ID0gd3BhYnVmX2FsbG9jKDIgKyB3c2NfbGVuICsgMiArIHdwYWJ1Zl9sZW4ocDJwKSk7CisJaWYgKHJldCA9PSBOVUxMKSB7CisJCXdwYWJ1Zl9mcmVlKHdzYyk7CisJCXdwYWJ1Zl9mcmVlKHAycCk7CisJCXJldHVybiBOVUxMOworCX0KKworCXdwYWJ1Zl9wdXRfYmUxNihyZXQsIHdzY19sZW4pOworCWlmICh3c2MpCisJCXdwYWJ1Zl9wdXRfYnVmKHJldCwgd3NjKTsKKwl3cGFidWZfcHV0X2JlMTYocmV0LCB3cGFidWZfbGVuKHAycCkpOworCXdwYWJ1Zl9wdXRfYnVmKHJldCwgcDJwKTsKKworCXdwYWJ1Zl9mcmVlKHdzYyk7CisJd3BhYnVmX2ZyZWUocDJwKTsKKwl3cGFfaGV4ZHVtcF9idWYoTVNHX0RFQlVHLAorCQkJIlAyUDogR2VuZXJhdGVkIE5GQyBjb25uZWN0aW9uIGhhbmRvdmVyIG1lc3NhZ2UiLCByZXQpOworCisJaWYgKG5kZWYgJiYgcmV0KSB7CisJCXN0cnVjdCB3cGFidWYgKnRtcDsKKwkJdG1wID0gbmRlZl9idWlsZF9wMnAocmV0KTsKKwkJd3BhYnVmX2ZyZWUocmV0KTsKKwkJaWYgKHRtcCA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRmFpbGVkIHRvIE5ERUYgZW5jYXBzdWxhdGUgaGFuZG92ZXIgcmVxdWVzdCIpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwkJcmV0ID0gdG1wOworCX0KKworCXJldHVybiByZXQ7CiB9CiAKLWludCB3cGFzX3AycF9oYW5kbGVfZnJlcXVlbmN5X2NvbmZsaWN0cyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgZnJlcSwKLQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCisKK3N0YXRpYyBpbnQgd3Bhc19wMnBfY2xpX2ZyZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgICAgc3RydWN0IHdwYV9zc2lkICoqc3NpZCwgdTggKmdvX2Rldl9hZGRyKQogewotCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqaWZhY2UgPSBOVUxMOwotCXN0cnVjdCBwMnBfZGF0YSAqcDJwID0gd3BhX3MtPmdsb2JhbC0+cDJwOworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqaWZhY2U7CiAKKwlpZiAoZ29fZGV2X2FkZHIpCisJCW9zX21lbXNldChnb19kZXZfYWRkciwgMCwgRVRIX0FMRU4pOworCWlmIChzc2lkKQorCQkqc3NpZCA9IE5VTEw7CiAJZm9yIChpZmFjZSA9IHdwYV9zLT5nbG9iYWwtPmlmYWNlczsgaWZhY2U7IGlmYWNlID0gaWZhY2UtPm5leHQpIHsKLQkJaWYgKChpZmFjZS0+Y3VycmVudF9zc2lkKSAmJgotCQkgICAgKGlmYWNlLT5jdXJyZW50X3NzaWQtPmZyZXF1ZW5jeSAhPSBmcmVxKSAmJgotCQkgICAgKChpZmFjZS0+cDJwX2dyb3VwX2ludGVyZmFjZSkgfHwKLQkJICAgICAoaWZhY2UtPmN1cnJlbnRfc3NpZC0+cDJwX2dyb3VwKSkpIHsKLQotCQkJaWYgKChpZmFjZS0+cDJwX2dyb3VwX2ludGVyZmFjZSA9PSBQMlBfR1JPVVBfSU5URVJGQUNFX0dPKSAgfHwKLQkJCSAgICAoaWZhY2UtPmN1cnJlbnRfc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dPKSkgewotCQkJCS8qIFRyeSB0byBzZWUgd2hldGhlciB3ZSBjYW4gbW92ZSB0aGUgR08uIElmIGl0Ci0JCQkJICogaXMgbm90IHBvc3NpYmxlLCByZW1vdmUgdGhlIEdPIGludGVyZmFjZQotCQkJCSAqLwotCQkJCWlmICh3cGFfZHJ2X3N3aXRjaF9jaGFubmVsKGlmYWNlLCBmcmVxKSA9PSAwKSB7Ci0JCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUDJQOiBHTyBNb3ZlZCB0byBmcmVxKCVkKSIsIGZyZXEpOwotCQkJCQlpZmFjZS0+Y3VycmVudF9zc2lkLT5mcmVxdWVuY3kgPSBmcmVxOwotCQkJCQljb250aW51ZTsKLQkJCQl9Ci0JCQl9Ci0KLQkJCS8qIElmIEdPIGNhbm5vdCBiZSBtb3ZlZCBvciBpZiB0aGUgY29uZmxpY3RpbmcgaW50ZXJmYWNlIGlzIGEKLQkJCSAqIFAyUCBDbGllbnQsIHJlbW92ZSB0aGUgaW50ZXJmYWNlIGRlcGVuZGluZyB1cCBvbiB0aGUgY29ubmVjdGlvbgotCQkJICogcHJpb3JpdHkgKi8KLQkJCWlmKCF3cGFzX2lzX3AycF9wcmlvcml0aXplZChpZmFjZSkpIHsKLQkJCQkvKiBTVEEgY29ubmVjdGlvbiBoYXMgcHJpb3JpdHkgb3ZlciBleGlzdGluZwotCQkJCSAqIFAyUCBjb25uZWN0aW9uLiBTbyByZW1vdmUgdGhlIGludGVyZmFjZSAqLwotCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBSZW1vdmluZyBQMlAgY29ubmVjdGlvbiBkdWUgdG8gU2luZ2xlIGNoYW5uZWwiCi0JCQkJCQkiY29uY3VycmVudCBtb2RlIGZyZXF1ZW5jeSBjb25mbGljdCIpOwotCQkJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMCwgMCwgd3Bhc19wMnBfZ3JvdXBfZnJlcV9jb25mbGljdCwKLQkJCQkJCSAgICAgICBpZmFjZSwgTlVMTCk7Ci0JCQkJLyogSWYgY29ubmVjdGlvbiBpbiBwcm9ncmVzcyBpcyBwMnAgY29ubmVjdGlvbiwgZG8gbm90IHByb2NlZWQgZm9yIHRoZSBjb25uZWN0aW9uICovCi0JCQkJaWYgKHdwYV9zID09IGlmYWNlKQotCQkJCQlyZXR1cm4gLTE7Ci0JCQkJZWxzZQotCQkJCQkvKiBJZiBjb25uZWN0aW9uIGluIHByb2dyZXNzIGlzIFNUQSBjb25uZWN0aW9uLCBwcm9jZWVkIGZvciB0aGUgY29ubmVjdGlvbiAqLwotCQkJCQlyZXR1cm4gMDsKLQkJCX0gZWxzZSB7Ci0JCQkJLyogUDJwIGNvbm5lY3Rpb24gaGFzIHByaW9yaXR5LCBkaXNhYmxlIHRoZSBTVEEgbmV0d29yayovCi0JCQkJd3BhX3N1cHBsaWNhbnRfZGlzYWJsZV9uZXR3b3JrKHdwYV9zLT5nbG9iYWwtPmlmYWNlcywgc3NpZCk7Ci0JCQkJd3BhX21zZyh3cGFfcy0+Z2xvYmFsLT5pZmFjZXMsIE1TR19JTkZPLCBXUEFfRVZFTlRfRlJFUV9DT05GTElDVAotCQkJCQkiIGlkPSVkIiwgc3NpZC0+aWQpOwotCQkJCW9zX21lbXNldCh3cGFfcy0+Z2xvYmFsLT5pZmFjZXMtPnBlbmRpbmdfYnNzaWQsIDAsIEVUSF9BTEVOKTsKLQkJCQlpZiAod3BhX3MgPT0gaWZhY2UpIHsKLQkJCQkJLyogcDJwIGNvbm5lY3Rpb24gaXMgaW4gcHJvZ3Jlc3MsIGNvbnRpbnVlIGNvbm5lY3RpbmcuLi4qLwotCQkJCQlyZXR1cm4gMDsKLQkJCQl9Ci0JCQkJZWxzZSB7Ci0JCQkJCS8qIFNUQSBjb25uZWN0aW9uIGlzIGluIHByb2dyZXNzLCBkbyBub3QgYWxsb3cgdG8gY29udGludWUgKi8KLQkJCQkJcmV0dXJuIC0xOwotCQkJCX0KLQkJCX0KLQkJfQorCQlpZiAoaWZhY2UtPndwYV9zdGF0ZSA8IFdQQV9BU1NPQ0lBVElORyB8fAorCQkgICAgaWZhY2UtPmN1cnJlbnRfc3NpZCA9PSBOVUxMIHx8IGlmYWNlLT5hc3NvY19mcmVxID09IDAgfHwKKwkJICAgICFpZmFjZS0+Y3VycmVudF9zc2lkLT5wMnBfZ3JvdXAgfHwKKwkJICAgIGlmYWNlLT5jdXJyZW50X3NzaWQtPm1vZGUgIT0gV1BBU19NT0RFX0lORlJBKQorCQkJY29udGludWU7CisJCWlmIChzc2lkKQorCQkJKnNzaWQgPSBpZmFjZS0+Y3VycmVudF9zc2lkOworCQlpZiAoZ29fZGV2X2FkZHIpCisJCQlvc19tZW1jcHkoZ29fZGV2X2FkZHIsIGlmYWNlLT5nb19kZXZfYWRkciwgRVRIX0FMRU4pOworCQlyZXR1cm4gaWZhY2UtPmFzc29jX2ZyZXE7CiAJfQogCXJldHVybiAwOwogfQotI2VuZGlmCisKKworc3RydWN0IHdwYWJ1ZiAqIHdwYXNfcDJwX25mY19oYW5kb3Zlcl9yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICBpbnQgbmRlZikKK3sKKwlzdHJ1Y3Qgd3BhYnVmICp3c2MsICpwMnA7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkOworCXU4IGdvX2Rldl9hZGRyW0VUSF9BTEVOXTsKKwlpbnQgY2xpX2ZyZXEgPSB3cGFzX3AycF9jbGlfZnJlcSh3cGFfcywgJnNzaWQsIGdvX2Rldl9hZGRyKTsKKworCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFAyUCBkaXNhYmxlZCAtIGNhbm5vdCBidWlsZCBoYW5kb3ZlciByZXF1ZXN0Iik7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmICh3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkgPT0gTlVMTCAmJgorCSAgICB3cHNfbmZjX2dlbl9kaCgmd3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5LAorCQkJICAgJndwYV9zLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkpIDwgMCkgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IE5vIERIIGtleSBhdmFpbGFibGUgZm9yIGhhbmRvdmVyIHJlcXVlc3QiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaWYgKGNsaV9mcmVxID09IDApIHsKKwkJd3NjID0gd3BzX2J1aWxkX25mY19oYW5kb3Zlcl9yZXFfcDJwKAorCQkJd3BhX3MtPnBhcmVudC0+d3BzLCB3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkpOworCX0gZWxzZQorCQl3c2MgPSBOVUxMOworCXAycCA9IHAycF9idWlsZF9uZmNfaGFuZG92ZXJfcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgY2xpX2ZyZXEsCisJCQkJCSBnb19kZXZfYWRkciwgc3NpZCA/IHNzaWQtPnNzaWQgOiBOVUxMLAorCQkJCQkgc3NpZCA/IHNzaWQtPnNzaWRfbGVuIDogMCk7CisKKwlyZXR1cm4gd3Bhc19wMnBfbmZjX2hhbmRvdmVyKG5kZWYsIHdzYywgcDJwKTsKK30KKworCitzdHJ1Y3Qgd3BhYnVmICogd3Bhc19wMnBfbmZjX2hhbmRvdmVyX3NlbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgIGludCBuZGVmLCBpbnQgdGFnKQoreworCXN0cnVjdCB3cGFidWYgKndzYywgKnAycDsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CisJdTggZ29fZGV2X2FkZHJbRVRIX0FMRU5dOworCWludCBjbGlfZnJlcSA9IHdwYXNfcDJwX2NsaV9mcmVxKHdwYV9zLCAmc3NpZCwgZ29fZGV2X2FkZHIpOworCisJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAoIXRhZyAmJiB3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkgPT0gTlVMTCAmJgorCSAgICB3cHNfbmZjX2dlbl9kaCgmd3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5LAorCQkJICAgJndwYV9zLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkpIDwgMCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAoY2xpX2ZyZXEgPT0gMCkgeworCQl3c2MgPSB3cHNfYnVpbGRfbmZjX2hhbmRvdmVyX3NlbF9wMnAoCisJCQl3cGFfcy0+cGFyZW50LT53cHMsCisJCQl0YWcgPyB3cGFfcy0+Y29uZi0+d3BzX25mY19kZXZfcHdfaWQgOgorCQkJREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSLAorCQkJd3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5LAorCQkJdGFnID8gd3BhX3MtPmNvbmYtPndwc19uZmNfZGV2X3B3IDogTlVMTCk7CisJfSBlbHNlCisJCXdzYyA9IE5VTEw7CisJcDJwID0gcDJwX2J1aWxkX25mY19oYW5kb3Zlcl9zZWwod3BhX3MtPmdsb2JhbC0+cDJwLCBjbGlfZnJlcSwKKwkJCQkJIGdvX2Rldl9hZGRyLCBzc2lkID8gc3NpZC0+c3NpZCA6IE5VTEwsCisJCQkJCSBzc2lkID8gc3NpZC0+c3NpZF9sZW4gOiAwKTsKKworCXJldHVybiB3cGFzX3AycF9uZmNfaGFuZG92ZXIobmRlZiwgd3NjLCBwMnApOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19wMnBfbmZjX2pvaW5fZ3JvdXAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICBzdHJ1Y3QgcDJwX25mY19wYXJhbXMgKnBhcmFtcykKK3sKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogSW5pdGlhdGUgam9pbi1ncm91cCBiYXNlZCBvbiBORkMgIgorCQkgICAiY29ubmVjdGlvbiBoYW5kb3ZlciAoZnJlcT0lZCkiLAorCQkgICBwYXJhbXMtPmdvX2ZyZXEpOworCisJaWYgKHBhcmFtcy0+Z29fZnJlcSAmJiBwYXJhbXMtPmdvX3NzaWRfbGVuKSB7CisJCXdwYV9zLT5wMnBfd3BzX21ldGhvZCA9IFdQU19ORkM7CisJCXdwYV9zLT5wZW5kaW5nX2pvaW5fd3BzX21ldGhvZCA9IFdQU19ORkM7CisJCW9zX21lbXNldCh3cGFfcy0+cGVuZGluZ19qb2luX2lmYWNlX2FkZHIsIDAsIEVUSF9BTEVOKTsKKwkJb3NfbWVtY3B5KHdwYV9zLT5wZW5kaW5nX2pvaW5fZGV2X2FkZHIsIHBhcmFtcy0+Z29fZGV2X2FkZHIsCisJCQkgIEVUSF9BTEVOKTsKKwkJcmV0dXJuIHdwYXNfcDJwX2pvaW5fc3RhcnQod3BhX3MsIHBhcmFtcy0+Z29fZnJlcSwKKwkJCQkJICAgcGFyYW1zLT5nb19zc2lkLAorCQkJCQkgICBwYXJhbXMtPmdvX3NzaWRfbGVuKTsKKwl9CisKKwlyZXR1cm4gd3Bhc19wMnBfY29ubmVjdCh3cGFfcywgcGFyYW1zLT5wZWVyLT5wMnBfZGV2aWNlX2FkZHIsIE5VTEwsCisJCQkJV1BTX05GQywgMCwgMCwgMSwgMCwgd3BhX3MtPmNvbmYtPnAycF9nb19pbnRlbnQsCisJCQkJcGFyYW1zLT5nb19mcmVxLCAtMSwgMCwgMSwgMSk7Cit9CisKKworc3RhdGljIGludCB3cGFzX3AycF9uZmNfYXV0aF9qb2luKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICBzdHJ1Y3QgcDJwX25mY19wYXJhbXMgKnBhcmFtcywgaW50IHRhZykKK3sKKwlpbnQgcmVzLCBwZXJzaXN0ZW50OworCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBBdXRob3JpemUgam9pbi1ncm91cCBiYXNlZCBvbiBORkMgIgorCQkgICAiY29ubmVjdGlvbiBoYW5kb3ZlciIpOworCWZvciAod3BhX3MgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IHdwYV9zOyB3cGFfcyA9IHdwYV9zLT5uZXh0KSB7CisJCXNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOworCQlpZiAoc3NpZCA9PSBOVUxMKQorCQkJY29udGludWU7CisJCWlmIChzc2lkLT5tb2RlICE9IFdQQVNfTU9ERV9QMlBfR08pCisJCQljb250aW51ZTsKKwkJaWYgKHdwYV9zLT5hcF9pZmFjZSA9PSBOVUxMKQorCQkJY29udGludWU7CisJCWJyZWFrOworCX0KKwlpZiAod3BhX3MgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ291bGQgbm90IGZpbmQgR08gaW50ZXJmYWNlIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAod3BhX3MtPnBhcmVudC0+cDJwX29vYl9kZXZfcHdfaWQgIT0KKwkgICAgREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSICYmCisJICAgICF3cGFfcy0+cGFyZW50LT5wMnBfb29iX2Rldl9wdykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogTm8gTkZDIERldiBQdyBrbm93biIpOworCQlyZXR1cm4gLTE7CisJfQorCXJlcyA9IHdwYXNfYXBfd3BzX2FkZF9uZmNfcHcoCisJCXdwYV9zLCB3cGFfcy0+cGFyZW50LT5wMnBfb29iX2Rldl9wd19pZCwKKwkJd3BhX3MtPnBhcmVudC0+cDJwX29vYl9kZXZfcHcsCisJCXdwYV9zLT5wYXJlbnQtPnAycF9wZWVyX29vYl9wa19oYXNoX2tub3duID8KKwkJd3BhX3MtPnBhcmVudC0+cDJwX3BlZXJfb29iX3B1YmtleV9oYXNoIDogTlVMTCk7CisJaWYgKHJlcykKKwkJcmV0dXJuIHJlczsKKworCWlmICghdGFnKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBOZWdvdGlhdGVkIGhhbmRvdmVyIC0gd2FpdCBmb3IgcGVlciB0byBqb2luIHdpdGhvdXQgaW52aXRhdGlvbiIpOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAoIXBhcmFtcy0+cGVlciB8fAorCSAgICAhKHBhcmFtcy0+cGVlci0+ZGV2X2NhcGFiICYgUDJQX0RFVl9DQVBBQl9JTlZJVEFUSU9OX1BST0NFRFVSRSkpCisJCXJldHVybiAwOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFN0YXRpYyBoYW5kb3ZlciAtIGludml0ZSBwZWVyICIgTUFDU1RSCisJCSAgICIgdG8gam9pbiIsIE1BQzJTVFIocGFyYW1zLT5wZWVyLT5wMnBfZGV2aWNlX2FkZHIpKTsKKworCXdwYV9zLT5nbG9iYWwtPnAycF9pbnZpdGVfZ3JvdXAgPSB3cGFfczsKKwlwZXJzaXN0ZW50ID0gc3NpZC0+cDJwX3BlcnNpc3RlbnRfZ3JvdXAgJiYKKwkJd3Bhc19wMnBfZ2V0X3BlcnNpc3RlbnQod3BhX3MtPnBhcmVudCwKKwkJCQkJcGFyYW1zLT5wZWVyLT5wMnBfZGV2aWNlX2FkZHIsCisJCQkJCXNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKKwl3cGFfcy0+cGFyZW50LT5wZW5kaW5nX2ludml0ZV9zc2lkX2lkID0gLTE7CisKKwlyZXR1cm4gcDJwX2ludml0ZSh3cGFfcy0+Z2xvYmFsLT5wMnAsIHBhcmFtcy0+cGVlci0+cDJwX2RldmljZV9hZGRyLAorCQkJICBQMlBfSU5WSVRFX1JPTEVfQUNUSVZFX0dPLCB3cGFfcy0+b3duX2FkZHIsCisJCQkgIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuLCBzc2lkLT5mcmVxdWVuY3ksCisJCQkgIHdwYV9zLT5nbG9iYWwtPnAycF9kZXZfYWRkciwgcGVyc2lzdGVudCwgMCwKKwkJCSAgd3BhX3MtPnBhcmVudC0+cDJwX29vYl9kZXZfcHdfaWQpOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19wMnBfbmZjX2luaXRfZ29fbmVnKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgIHN0cnVjdCBwMnBfbmZjX3BhcmFtcyAqcGFyYW1zLAorCQkJCSAgICBpbnQgZm9yY2VkX2ZyZXEpCit7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEluaXRpYXRlIEdPIE5lZ290aWF0aW9uIGJhc2VkIG9uIE5GQyAiCisJCSAgICJjb25uZWN0aW9uIGhhbmRvdmVyIik7CisJcmV0dXJuIHdwYXNfcDJwX2Nvbm5lY3Qod3BhX3MsIHBhcmFtcy0+cGVlci0+cDJwX2RldmljZV9hZGRyLCBOVUxMLAorCQkJCVdQU19ORkMsIDAsIDAsIDAsIDAsIHdwYV9zLT5jb25mLT5wMnBfZ29faW50ZW50LAorCQkJCWZvcmNlZF9mcmVxLCAtMSwgMCwgMSwgMSk7Cit9CisKKworc3RhdGljIGludCB3cGFzX3AycF9uZmNfcmVzcF9nb19uZWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgc3RydWN0IHAycF9uZmNfcGFyYW1zICpwYXJhbXMsCisJCQkJICAgIGludCBmb3JjZWRfZnJlcSkKK3sKKwlpbnQgcmVzOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEF1dGhvcml6ZSBHTyBOZWdvdGlhdGlvbiBiYXNlZCBvbiBORkMgIgorCQkgICAiY29ubmVjdGlvbiBoYW5kb3ZlciIpOworCXJlcyA9IHdwYXNfcDJwX2Nvbm5lY3Qod3BhX3MsIHBhcmFtcy0+cGVlci0+cDJwX2RldmljZV9hZGRyLCBOVUxMLAorCQkJICAgICAgIFdQU19ORkMsIDAsIDAsIDAsIDEsIHdwYV9zLT5jb25mLT5wMnBfZ29faW50ZW50LAorCQkJICAgICAgIGZvcmNlZF9mcmVxLCAtMSwgMCwgMSwgMSk7CisJaWYgKHJlcykKKwkJcmV0dXJuIHJlczsKKworCXJlcyA9IHdwYXNfcDJwX2xpc3Rlbih3cGFfcywgNjApOworCWlmIChyZXMpIHsKKwkJcDJwX3VuYXV0aG9yaXplKHdwYV9zLT5nbG9iYWwtPnAycCwKKwkJCQlwYXJhbXMtPnBlZXItPnAycF9kZXZpY2VfYWRkcik7CisJfQorCisJcmV0dXJuIHJlczsKK30KKworCitzdGF0aWMgaW50IHdwYXNfcDJwX25mY19jb25uZWN0aW9uX2hhbmRvdmVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpkYXRhLAorCQkJCQkgICAgaW50IHNlbCwgaW50IHRhZywgaW50IGZvcmNlZF9mcmVxKQoreworCWNvbnN0IHU4ICpwb3MsICplbmQ7CisJdTE2IGxlbiwgaWQ7CisJc3RydWN0IHAycF9uZmNfcGFyYW1zIHBhcmFtczsKKwlpbnQgcmVzOworCisJb3NfbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKKwlwYXJhbXMuc2VsID0gc2VsOworCisJd3BhX2hleGR1bXBfYnVmKE1TR19ERUJVRywgIlAyUDogUmVjZWl2ZWQgTkZDIHRhZyBwYXlsb2FkIiwgZGF0YSk7CisKKwlwb3MgPSB3cGFidWZfaGVhZChkYXRhKTsKKwllbmQgPSBwb3MgKyB3cGFidWZfbGVuKGRhdGEpOworCisJaWYgKGVuZCAtIHBvcyA8IDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IE5vdCBlbm91Z2ggZGF0YSBmb3IgTGVuZ3RoIG9mIFdTQyAiCisJCQkgICAiYXR0cmlidXRlcyIpOworCQlyZXR1cm4gLTE7CisJfQorCWxlbiA9IFdQQV9HRVRfQkUxNihwb3MpOworCXBvcyArPSAyOworCWlmIChwb3MgKyBsZW4gPiBlbmQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IE5vdCBlbm91Z2ggZGF0YSBmb3IgV1NDICIKKwkJCSAgICJhdHRyaWJ1dGVzIik7CisJCXJldHVybiAtMTsKKwl9CisJcGFyYW1zLndzY19hdHRyID0gcG9zOworCXBhcmFtcy53c2NfbGVuID0gbGVuOworCXBvcyArPSBsZW47CisKKwlpZiAoZW5kIC0gcG9zIDwgMikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogTm90IGVub3VnaCBkYXRhIGZvciBMZW5ndGggb2YgUDJQICIKKwkJCSAgICJhdHRyaWJ1dGVzIik7CisJCXJldHVybiAtMTsKKwl9CisJbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CisJcG9zICs9IDI7CisJaWYgKHBvcyArIGxlbiA+IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogTm90IGVub3VnaCBkYXRhIGZvciBQMlAgIgorCQkJICAgImF0dHJpYnV0ZXMiKTsKKwkJcmV0dXJuIC0xOworCX0KKwlwYXJhbXMucDJwX2F0dHIgPSBwb3M7CisJcGFyYW1zLnAycF9sZW4gPSBsZW47CisJcG9zICs9IGxlbjsKKworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlAyUDogV1NDIGF0dHJpYnV0ZXMiLAorCQkgICAgcGFyYW1zLndzY19hdHRyLCBwYXJhbXMud3NjX2xlbik7CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUDJQOiBQMlAgYXR0cmlidXRlcyIsCisJCSAgICBwYXJhbXMucDJwX2F0dHIsIHBhcmFtcy5wMnBfbGVuKTsKKwlpZiAocG9zIDwgZW5kKSB7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywKKwkJCSAgICAiUDJQOiBJZ25vcmVkIGV4dHJhIGRhdGEgYWZ0ZXIgUDJQIGF0dHJpYnV0ZXMiLAorCQkJICAgIHBvcywgZW5kIC0gcG9zKTsKKwl9CisKKwlyZXMgPSBwMnBfcHJvY2Vzc19uZmNfY29ubmVjdGlvbl9oYW5kb3Zlcih3cGFfcy0+Z2xvYmFsLT5wMnAsICZwYXJhbXMpOworCWlmIChyZXMpCisJCXJldHVybiByZXM7CisKKwlpZiAocGFyYW1zLm5leHRfc3RlcCA9PSBOT19BQ1RJT04pCisJCXJldHVybiAwOworCisJaWYgKHBhcmFtcy5uZXh0X3N0ZXAgPT0gQk9USF9HTykgeworCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgUDJQX0VWRU5UX05GQ19CT1RIX0dPICJwZWVyPSIgTUFDU1RSLAorCQkJTUFDMlNUUihwYXJhbXMucGVlci0+cDJwX2RldmljZV9hZGRyKSk7CisJCXJldHVybiAwOworCX0KKworCWlmIChwYXJhbXMubmV4dF9zdGVwID09IFBFRVJfQ0xJRU5UKSB7CisJCWlmICghaXNfemVyb19ldGhlcl9hZGRyKHBhcmFtcy5nb19kZXZfYWRkcikpIHsKKwkJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBQMlBfRVZFTlRfTkZDX1BFRVJfQ0xJRU5UCisJCQkJInBlZXI9IiBNQUNTVFIgIiBmcmVxPSVkIGdvX2Rldl9hZGRyPSIgTUFDU1RSCisJCQkJIiBzc2lkPVwiJXNcIiIsCisJCQkJTUFDMlNUUihwYXJhbXMucGVlci0+cDJwX2RldmljZV9hZGRyKSwKKwkJCQlwYXJhbXMuZ29fZnJlcSwKKwkJCQlNQUMyU1RSKHBhcmFtcy5nb19kZXZfYWRkciksCisJCQkJd3BhX3NzaWRfdHh0KHBhcmFtcy5nb19zc2lkLAorCQkJCQkgICAgIHBhcmFtcy5nb19zc2lkX2xlbikpOworCQl9IGVsc2UgeworCQkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIFAyUF9FVkVOVF9ORkNfUEVFUl9DTElFTlQKKwkJCQkicGVlcj0iIE1BQ1NUUiAiIGZyZXE9JWQiLAorCQkJCU1BQzJTVFIocGFyYW1zLnBlZXItPnAycF9kZXZpY2VfYWRkciksCisJCQkJcGFyYW1zLmdvX2ZyZXEpOworCQl9CisJCXJldHVybiAwOworCX0KKworCWlmICh3cGFzX3AycF9jbGlfZnJlcSh3cGFfcywgTlVMTCwgTlVMTCkpIHsKKwkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIFAyUF9FVkVOVF9ORkNfV0hJTEVfQ0xJRU5UICJwZWVyPSIKKwkJCU1BQ1NUUiwgTUFDMlNUUihwYXJhbXMucGVlci0+cDJwX2RldmljZV9hZGRyKSk7CisJCXJldHVybiAwOworCX0KKworCXdwYWJ1Zl9mcmVlKHdwYV9zLT5wMnBfb29iX2Rldl9wdyk7CisJd3BhX3MtPnAycF9vb2JfZGV2X3B3ID0gTlVMTDsKKworCWlmIChwYXJhbXMub29iX2Rldl9wd19sZW4gPCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiArIDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IE5vIHBlZXIgT09CIERldiBQdyAiCisJCQkgICAicmVjZWl2ZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlkID0gV1BBX0dFVF9CRTE2KHBhcmFtcy5vb2JfZGV2X3B3ICsgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBQZWVyIE9PQiBEZXYgUHcgJXUiLCBpZCk7CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUDJQOiBQZWVyIE9PQiBQdWJsaWMgS2V5IGhhc2giLAorCQkgICAgcGFyYW1zLm9vYl9kZXZfcHcsIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOKTsKKwlvc19tZW1jcHkod3BhX3MtPnAycF9wZWVyX29vYl9wdWJrZXlfaGFzaCwKKwkJICBwYXJhbXMub29iX2Rldl9wdywgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCXdwYV9zLT5wMnBfcGVlcl9vb2JfcGtfaGFzaF9rbm93biA9IDE7CisKKwlpZiAodGFnKSB7CisJCWlmIChpZCA8IDB4MTApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBTdGF0aWMgaGFuZG92ZXIgLSBpbnZhbGlkICIKKwkJCQkgICAicGVlciBPT0IgRGV2aWNlIFBhc3N3b3JkIElkICV1IiwgaWQpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBTdGF0aWMgaGFuZG92ZXIgLSB1c2UgcGVlciBPT0IgIgorCQkJICAgIkRldmljZSBQYXNzd29yZCBJZCAldSIsIGlkKTsKKwkJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIlAyUDogUGVlciBPT0IgRGV2aWNlIFBhc3N3b3JkIiwKKwkJCQlwYXJhbXMub29iX2Rldl9wdyArIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOICsgMiwKKwkJCQlwYXJhbXMub29iX2Rldl9wd19sZW4gLQorCQkJCVdQU19PT0JfUFVCS0VZX0hBU0hfTEVOIC0gMik7CisJCXdwYV9zLT5wMnBfb29iX2Rldl9wd19pZCA9IGlkOworCQl3cGFfcy0+cDJwX29vYl9kZXZfcHcgPSB3cGFidWZfYWxsb2NfY29weSgKKwkJCXBhcmFtcy5vb2JfZGV2X3B3ICsgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gKyAyLAorCQkJcGFyYW1zLm9vYl9kZXZfcHdfbGVuIC0KKwkJCVdQU19PT0JfUFVCS0VZX0hBU0hfTEVOIC0gMik7CisJCWlmICh3cGFfcy0+cDJwX29vYl9kZXZfcHcgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKworCQlpZiAod3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5ID09IE5VTEwgJiYKKwkJICAgIHdwc19uZmNfZ2VuX2RoKCZ3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXksCisJCQkJICAgJndwYV9zLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkpIDwgMCkKKwkJCXJldHVybiAtMTsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVXNpbmcgYWJicmV2aWF0ZWQgV1BTIGhhbmRzaGFrZSAiCisJCQkgICAid2l0aG91dCBEZXZpY2UgUGFzc3dvcmQiKTsKKwkJd3BhX3MtPnAycF9vb2JfZGV2X3B3X2lkID0gREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSOworCX0KKworCXN3aXRjaCAocGFyYW1zLm5leHRfc3RlcCkgeworCWNhc2UgTk9fQUNUSU9OOgorCWNhc2UgQk9USF9HTzoKKwljYXNlIFBFRVJfQ0xJRU5UOgorCQkvKiBhbHJlYWR5IGNvdmVyZWQgYWJvdmUgKi8KKwkJcmV0dXJuIDA7CisJY2FzZSBKT0lOX0dST1VQOgorCQlyZXR1cm4gd3Bhc19wMnBfbmZjX2pvaW5fZ3JvdXAod3BhX3MsICZwYXJhbXMpOworCWNhc2UgQVVUSF9KT0lOOgorCQlyZXR1cm4gd3Bhc19wMnBfbmZjX2F1dGhfam9pbih3cGFfcywgJnBhcmFtcywgdGFnKTsKKwljYXNlIElOSVRfR09fTkVHOgorCQlyZXR1cm4gd3Bhc19wMnBfbmZjX2luaXRfZ29fbmVnKHdwYV9zLCAmcGFyYW1zLCBmb3JjZWRfZnJlcSk7CisJY2FzZSBSRVNQX0dPX05FRzoKKwkJLyogVE9ETzogdXNlIG93biBPT0IgRGV2IFB3ICovCisJCXJldHVybiB3cGFzX3AycF9uZmNfcmVzcF9nb19uZWcod3BhX3MsICZwYXJhbXMsIGZvcmNlZF9mcmVxKTsKKwl9CisKKwlyZXR1cm4gLTE7Cit9CisKKworaW50IHdwYXNfcDJwX25mY190YWdfcHJvY2VzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpkYXRhLCBpbnQgZm9yY2VkX2ZyZXEpCit7CisJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJcmV0dXJuIHdwYXNfcDJwX25mY19jb25uZWN0aW9uX2hhbmRvdmVyKHdwYV9zLCBkYXRhLCAxLCAxLCBmb3JjZWRfZnJlcSk7Cit9CisKKworaW50IHdwYXNfcDJwX25mY19yZXBvcnRfaGFuZG92ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGluaXQsCisJCQkJIGNvbnN0IHN0cnVjdCB3cGFidWYgKnJlcSwKKwkJCQkgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqc2VsLCBpbnQgZm9yY2VkX2ZyZXEpCit7CisJc3RydWN0IHdwYWJ1ZiAqdG1wOworCWludCByZXQ7CisKKwlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogUDJQIGNvbm5lY3Rpb24gaGFuZG92ZXIgcmVwb3J0ZWQiKTsKKworCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIk5GQzogUmVxIiwKKwkJCSAgd3BhYnVmX2hlYWQocmVxKSwgd3BhYnVmX2xlbihyZXEpKTsKKwl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJORkM6IFNlbCIsCisJCQkgIHdwYWJ1Zl9oZWFkKHNlbCksIHdwYWJ1Zl9sZW4oc2VsKSk7CisJaWYgKGZvcmNlZF9mcmVxKQorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogRm9yY2VkIGZyZXEgJWQiLCBmb3JjZWRfZnJlcSk7CisJdG1wID0gbmRlZl9wYXJzZV9wMnAoaW5pdCA/IHNlbCA6IHJlcSk7CisJaWYgKHRtcCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDb3VsZCBub3QgcGFyc2UgTkRFRiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0ID0gd3Bhc19wMnBfbmZjX2Nvbm5lY3Rpb25faGFuZG92ZXIod3BhX3MsIHRtcCwgaW5pdCwgMCwKKwkJCQkJICAgICAgIGZvcmNlZF9mcmVxKTsKKwl3cGFidWZfZnJlZSh0bXApOworCisJcmV0dXJuIHJldDsKK30KKworCitpbnQgd3Bhc19wMnBfbmZjX3RhZ19lbmFibGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBlbmFibGVkKQoreworCWNvbnN0IHU4ICppZl9hZGRyOworCWludCBnb19pbnRlbnQgPSB3cGFfcy0+Y29uZi0+cDJwX2dvX2ludGVudDsKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKmlmYWNlOworCisJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpZiAoIWVuYWJsZWQpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IERpc2FibGUgdXNlIG9mIG93biBORkMgVGFnIik7CisJCWZvciAoaWZhY2UgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IGlmYWNlOyBpZmFjZSA9IGlmYWNlLT5uZXh0KQorCQl7CisJCQlpZiAoIWlmYWNlLT5hcF9pZmFjZSkKKwkJCQljb250aW51ZTsKKwkJCWhvc3RhcGRfd3BzX25mY190b2tlbl9kaXNhYmxlKGlmYWNlLT5hcF9pZmFjZS0+YnNzWzBdKTsKKwkJfQorCQlwMnBfc2V0X2F1dGhvcml6ZWRfb29iX2Rldl9wd19pZCh3cGFfcy0+Z2xvYmFsLT5wMnAsIDAsCisJCQkJCQkgMCwgTlVMTCk7CisJCWlmICh3cGFfcy0+cDJwX25mY190YWdfZW5hYmxlZCkKKwkJCXdwYXNfcDJwX3JlbW92ZV9wZW5kaW5nX2dyb3VwX2ludGVyZmFjZSh3cGFfcyk7CisJCXdwYV9zLT5wMnBfbmZjX3RhZ19lbmFibGVkID0gMDsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCkKKwkJcmV0dXJuIC0xOworCisJaWYgKHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSA9PSBOVUxMIHx8CisJICAgIHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkgPT0gTlVMTCB8fAorCSAgICB3cGFfcy0+Y29uZi0+d3BzX25mY19kZXZfcHcgPT0gTlVMTCB8fAorCSAgICB3cGFfcy0+Y29uZi0+d3BzX25mY19kZXZfcHdfaWQgPCAweDEwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBORkMgcGFzc3dvcmQgdG9rZW4gbm90IGNvbmZpZ3VyZWQgIgorCQkJICAgInRvIGFsbG93IHN0YXRpYyBoYW5kb3ZlciBjYXNlcyIpOworCQlyZXR1cm4gLTE7CisJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEVuYWJsZSB1c2Ugb2Ygb3duIE5GQyBUYWciKTsKKworCXdwYV9zLT5wMnBfb29iX2Rldl9wd19pZCA9IHdwYV9zLT5jb25mLT53cHNfbmZjX2Rldl9wd19pZDsKKwl3cGFidWZfZnJlZSh3cGFfcy0+cDJwX29vYl9kZXZfcHcpOworCXdwYV9zLT5wMnBfb29iX2Rldl9wdyA9IHdwYWJ1Zl9kdXAod3BhX3MtPmNvbmYtPndwc19uZmNfZGV2X3B3KTsKKwlpZiAod3BhX3MtPnAycF9vb2JfZGV2X3B3ID09IE5VTEwpCisJCXJldHVybiAtMTsKKwl3cGFfcy0+cDJwX3BlZXJfb29iX3BrX2hhc2hfa25vd24gPSAwOworCisJaWYgKHdwYV9zLT5wMnBfZ3JvdXBfaW50ZXJmYWNlID09IFAyUF9HUk9VUF9JTlRFUkZBQ0VfR08gfHwKKwkgICAgd3BhX3MtPnAycF9ncm91cF9pbnRlcmZhY2UgPT0gUDJQX0dST1VQX0lOVEVSRkFDRV9DTElFTlQpIHsKKwkJLyoKKwkJICogUDJQIEdyb3VwIEludGVyZmFjZSBwcmVzZW50IGFuZCB0aGUgY29tbWFuZCBjYW1lIG9uIGdyb3VwCisJCSAqIGludGVyZmFjZSwgc28gZW5hYmxlIHRoZSB0b2tlbiBmb3IgdGhlIGN1cnJlbnQgaW50ZXJmYWNlLgorCQkgKi8KKwkJd3BhX3MtPmNyZWF0ZV9wMnBfaWZhY2UgPSAwOworCX0gZWxzZSB7CisJCXdwYV9zLT5jcmVhdGVfcDJwX2lmYWNlID0gd3Bhc19wMnBfY3JlYXRlX2lmYWNlKHdwYV9zKTsKKwl9CisKKwlpZiAod3BhX3MtPmNyZWF0ZV9wMnBfaWZhY2UpIHsKKwkJZW51bSB3cGFfZHJpdmVyX2lmX3R5cGUgaWZ0eXBlOworCQkvKiBQcmVwYXJlIHRvIGFkZCBhIG5ldyBpbnRlcmZhY2UgZm9yIHRoZSBncm91cCAqLworCQlpZnR5cGUgPSBXUEFfSUZfUDJQX0dST1VQOworCQlpZiAoZ29faW50ZW50ID09IDE1KQorCQkJaWZ0eXBlID0gV1BBX0lGX1AyUF9HTzsKKwkJaWYgKHdwYXNfcDJwX2FkZF9ncm91cF9pbnRlcmZhY2Uod3BhX3MsIGlmdHlwZSkgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIlAyUDogRmFpbGVkIHRvIGFsbG9jYXRlIGEgbmV3ICIKKwkJCQkgICAiaW50ZXJmYWNlIGZvciB0aGUgZ3JvdXAiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCisJCWlmX2FkZHIgPSB3cGFfcy0+cGVuZGluZ19pbnRlcmZhY2VfYWRkcjsKKwl9IGVsc2UKKwkJaWZfYWRkciA9IHdwYV9zLT5vd25fYWRkcjsKKworCXdwYV9zLT5wMnBfbmZjX3RhZ19lbmFibGVkID0gZW5hYmxlZDsKKworCWZvciAoaWZhY2UgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IGlmYWNlOyBpZmFjZSA9IGlmYWNlLT5uZXh0KSB7CisJCXN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQ7CisJCWlmIChpZmFjZS0+YXBfaWZhY2UgPT0gTlVMTCkKKwkJCWNvbnRpbnVlOworCQloYXBkID0gaWZhY2UtPmFwX2lmYWNlLT5ic3NbMF07CisJCXdwYWJ1Zl9mcmVlKGhhcGQtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5KTsKKwkJaGFwZC0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkgPQorCQkJd3BhYnVmX2R1cCh3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkpOworCQl3cGFidWZfZnJlZShoYXBkLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkpOworCQloYXBkLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkgPQorCQkJd3BhYnVmX2R1cCh3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5KTsKKwkJd3BhYnVmX2ZyZWUoaGFwZC0+Y29uZi0+d3BzX25mY19kZXZfcHcpOworCQloYXBkLT5jb25mLT53cHNfbmZjX2Rldl9wdyA9CisJCQl3cGFidWZfZHVwKHdwYV9zLT5jb25mLT53cHNfbmZjX2Rldl9wdyk7CisJCWhhcGQtPmNvbmYtPndwc19uZmNfZGV2X3B3X2lkID0gd3BhX3MtPmNvbmYtPndwc19uZmNfZGV2X3B3X2lkOworCisJCWlmIChob3N0YXBkX3dwc19uZmNfdG9rZW5fZW5hYmxlKGlmYWNlLT5hcF9pZmFjZS0+YnNzWzBdKSA8IDApIHsKKwkJCXdwYV9kYmcoaWZhY2UsIE1TR19ERUJVRywKKwkJCQkiUDJQOiBGYWlsZWQgdG8gZW5hYmxlIE5GQyBUYWcgZm9yIEdPIik7CisJCX0KKwl9CisJcDJwX3NldF9hdXRob3JpemVkX29vYl9kZXZfcHdfaWQoCisJCXdwYV9zLT5nbG9iYWwtPnAycCwgd3BhX3MtPmNvbmYtPndwc19uZmNfZGV2X3B3X2lkLCBnb19pbnRlbnQsCisJCWlmX2FkZHIpOworCisJcmV0dXJuIDA7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCisKK3N0YXRpYyB2b2lkIHdwYXNfcDJwX29wdGltaXplX2xpc3Rlbl9jaGFubmVsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICAgc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqZnJlcXMsCisJCQkJCSAgICAgdW5zaWduZWQgaW50IG51bSkKK3sKKwl1OCBjdXJyX2NoYW4sIGNhbmQsIGNoYW47CisJdW5zaWduZWQgaW50IGk7CisKKwljdXJyX2NoYW4gPSBwMnBfZ2V0X2xpc3Rlbl9jaGFubmVsKHdwYV9zLT5nbG9iYWwtPnAycCk7CisJZm9yIChpID0gMCwgY2FuZCA9IDA7IGkgPCBudW07IGkrKykgeworCQlpZWVlODAyMTFfZnJlcV90b19jaGFuKGZyZXFzW2ldLmZyZXEsICZjaGFuKTsKKwkJaWYgKGN1cnJfY2hhbiA9PSBjaGFuKSB7CisJCQljYW5kID0gMDsKKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKGNoYW4gPT0gMSB8fCBjaGFuID09IDYgfHwgY2hhbiA9PSAxMSkKKwkJCWNhbmQgPSBjaGFuOworCX0KKworCWlmIChjYW5kKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywKKwkJCSJQMlA6IFVwZGF0ZSBMaXN0ZW4gY2hhbm5lbCB0byAldSBiYWFzZWQgb24gb3BlcmF0aW5nIGNoYW5uZWwiLAorCQkJY2FuZCk7CisJCXAycF9zZXRfbGlzdGVuX2NoYW5uZWwod3BhX3MtPmdsb2JhbC0+cDJwLCA4MSwgY2FuZCwgMCk7CisJfQorfQorCisKK3ZvaWQgd3Bhc19wMnBfaW5kaWNhdGVfc3RhdGVfY2hhbmdlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqZnJlcXM7CisJdW5zaWduZWQgaW50IG51bSA9IHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQ7CisKKwlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQorCQlyZXR1cm47CisKKwkvKgorCSAqIElmIHBvc3NpYmxlLCBvcHRpbWl6ZSB0aGUgTGlzdGVuIGNoYW5uZWwgdG8gYmUgYSBjaGFubmVsIHRoYXQgaXMKKwkgKiBhbHJlYWR5IHVzZWQgYnkgb25lIG9mIHRoZSBvdGhlciBpbnRlcmZhY2VzLgorCSAqLworCWlmICghd3BhX3MtPmNvbmYtPnAycF9vcHRpbWl6ZV9saXN0ZW5fY2hhbikKKwkJcmV0dXJuOworCisJaWYgKCF3cGFfcy0+Y3VycmVudF9zc2lkIHx8IHdwYV9zLT53cGFfc3RhdGUgIT0gV1BBX0NPTVBMRVRFRCkKKwkJcmV0dXJuOworCisJZnJlcXMgPSBvc19jYWxsb2MobnVtLCBzaXplb2Yoc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSkpOworCWlmICghZnJlcXMpCisJCXJldHVybjsKKworCW51bSA9IGdldF9zaGFyZWRfcmFkaW9fZnJlcXNfZGF0YSh3cGFfcywgZnJlcXMsIG51bSk7CisKKwl3cGFzX3AycF9vcHRpbWl6ZV9saXN0ZW5fY2hhbm5lbCh3cGFfcywgZnJlcXMsIG51bSk7CisJb3NfZnJlZShmcmVxcyk7Cit9CisKKwordm9pZCB3cGFzX3AycF9kZWluaXRfaWZhY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAod3BhX3MgPT0gd3BhX3MtPnBhcmVudCkKKwkJd3Bhc19wMnBfZ3JvdXBfcmVtb3ZlKHdwYV9zLCAiKiIpOworCWlmICh3cGFfcyA9PSB3cGFfcy0+Z2xvYmFsLT5wMnBfaW5pdF93cGFfcyAmJiB3cGFfcy0+Z2xvYmFsLT5wMnApIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBEaXNhYmxlIFAyUCBzaW5jZSByZW1vdmluZyAiCisJCQkidGhlIG1hbmFnZW1lbnQgaW50ZXJmYWNlIGlzIGJlaW5nIHJlbW92ZWQiKTsKKwkJd3Bhc19wMnBfZGVpbml0X2dsb2JhbCh3cGFfcy0+Z2xvYmFsKTsKKwl9Cit9CisKKwordm9pZCB3cGFzX3AycF9hcF9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAod3BhX3MtPmFwX2lmYWNlLT5ic3MpCisJCXdwYV9zLT5hcF9pZmFjZS0+YnNzWzBdLT5wMnBfZ3JvdXAgPSBOVUxMOworCXdwYXNfcDJwX2dyb3VwX2RlaW5pdCh3cGFfcyk7Cit9CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9wMnBfc3VwcGxpY2FudC5oIGIvd3BhX3N1cHBsaWNhbnQvcDJwX3N1cHBsaWNhbnQuaAppbmRleCA2NWNjYmY5Li5kNzllYzAzIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9wMnBfc3VwcGxpY2FudC5oCisrKyBiL3dwYV9zdXBwbGljYW50L3AycF9zdXBwbGljYW50LmgKQEAgLTE2LDM0ICsxNiwyOCBAQAogc3RydWN0IHAycF9jaGFubmVsczsKIHN0cnVjdCB3cHNfZXZlbnRfZmFpbDsKIAotaW50IHdwYXNfcDJwX2luaXQoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci12b2lkIHdwYXNfcDJwX2RlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKLXZvaWQgd3Bhc19wMnBfZGVpbml0X2dsb2JhbChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsKTsKIGludCB3cGFzX3AycF9hZGRfcDJwZGV2X2ludGVyZmFjZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3N0cnVjdCB3cGFfc3VwcGxpY2FudCAqIHdwYXNfZ2V0X3AycF9nb19pZmFjZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgICBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuKTsKK3N0cnVjdCB3cGFfc3VwcGxpY2FudCAqIHdwYXNfZ2V0X3AycF9jbGllbnRfaWZhY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJCSAgY29uc3QgdTggKnBlZXJfZGV2X2FkZHIpOwogaW50IHdwYXNfcDJwX2Nvbm5lY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKnBlZXJfYWRkciwKIAkJICAgICBjb25zdCBjaGFyICpwaW4sIGVudW0gcDJwX3dwc19tZXRob2Qgd3BzX21ldGhvZCwKIAkJICAgICBpbnQgcGVyc2lzdGVudF9ncm91cCwgaW50IGF1dG9fam9pbiwgaW50IGpvaW4sCiAJCSAgICAgaW50IGF1dGgsIGludCBnb19pbnRlbnQsIGludCBmcmVxLCBpbnQgcGVyc2lzdGVudF9pZCwKLQkJICAgICBpbnQgcGQsIGludCBodDQwKTsKLXZvaWQgd3Bhc19wMnBfcmVtYWluX29uX2NoYW5uZWxfY2Ioc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgICB1bnNpZ25lZCBpbnQgZnJlcSwgdW5zaWduZWQgaW50IGR1cmF0aW9uKTsKLXZvaWQgd3Bhc19wMnBfY2FuY2VsX3JlbWFpbl9vbl9jaGFubmVsX2NiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgdW5zaWduZWQgaW50IGZyZXEpOwotI2lmZGVmIEFORFJPSURfUDJQCisJCSAgICAgaW50IHBkLCBpbnQgaHQ0MCwgaW50IHZodCk7CiBpbnQgd3Bhc19wMnBfaGFuZGxlX2ZyZXF1ZW5jeV9jb25mbGljdHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludCBmcmVxLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpOwotI2VuZGlmCiBpbnQgd3Bhc19wMnBfZ3JvdXBfcmVtb3ZlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKmlmbmFtZSk7CiBpbnQgd3Bhc19wMnBfZ3JvdXBfYWRkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBwZXJzaXN0ZW50X2dyb3VwLAotCQkgICAgICAgaW50IGZyZXEsIGludCBodDQwKTsKKwkJICAgICAgIGludCBmcmVxLCBpbnQgaHQ0MCwgaW50IHZodCk7CiBpbnQgd3Bhc19wMnBfZ3JvdXBfYWRkX3BlcnNpc3RlbnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCwgaW50IGFkZHJfYWxsb2NhdGVkLAotCQkJCSAgaW50IGZyZXEsIGludCBodDQwLAotCQkJCSAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVscyAqY2hhbm5lbHMpOworCQkJCSAgaW50IGZvcmNlX2ZyZXEsIGludCBuZWdfZnJlcSwgaW50IGh0NDAsCisJCQkJICBpbnQgdmh0LCBjb25zdCBzdHJ1Y3QgcDJwX2NoYW5uZWxzICpjaGFubmVscywKKwkJCQkgIGludCBjb25uZWN0aW9uX3RpbWVvdXQpOwogc3RydWN0IHAycF9ncm91cCAqIHdwYXNfcDJwX2dyb3VwX2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkKTsKLXZvaWQgd3Bhc19wMnBfd3BzX3N1Y2Nlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKnBlZXJfYWRkciwKLQkJCSAgaW50IHJlZ2lzdHJhcik7CiBlbnVtIHdwYXNfcDJwX3Byb3ZfZGlzY191c2UgewogCVdQQVNfUDJQX1BEX0ZPUl9HT19ORUcsCiAJV1BBU19QMlBfUERfRk9SX0pPSU4sCkBAIC02NCwzMyArNTgsMTEgQEAKIAkJICBjb25zdCB1OCAqZGV2X2lkLCB1bnNpZ25lZCBpbnQgc2VhcmNoX2RlbGF5KTsKIHZvaWQgd3Bhc19wMnBfc3RvcF9maW5kKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogaW50IHdwYXNfcDJwX2xpc3RlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCB1bnNpZ25lZCBpbnQgdGltZW91dCk7CitpbnQgd3Bhc19wMnBfbGlzdGVuX3N0YXJ0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHVuc2lnbmVkIGludCB0aW1lb3V0KTsKIGludCB3cGFzX3AycF9hc3NvY19yZXFfaWUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9ic3MgKmJzcywKIAkJCSAgdTggKmJ1Ziwgc2l6ZV90IGxlbiwgaW50IHAycF9ncm91cCk7Ci1pbnQgd3Bhc19wMnBfcHJvYmVfcmVxX3J4KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICphZGRyLAotCQkJICBjb25zdCB1OCAqZHN0LCBjb25zdCB1OCAqYnNzaWQsCi0JCQkgIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwKLQkJCSAgaW50IHNzaV9zaWduYWwpOwotdm9pZCB3cGFzX3AycF9yeF9hY3Rpb24oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmRhLAotCQkJY29uc3QgdTggKnNhLCBjb25zdCB1OCAqYnNzaWQsCi0JCQl1OCBjYXRlZ29yeSwgY29uc3QgdTggKmRhdGEsIHNpemVfdCBsZW4sIGludCBmcmVxKTsKIHZvaWQgd3Bhc19wMnBfc2Nhbl9pZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhYnVmICppZXMpOwotdm9pZCB3cGFzX3AycF9ncm91cF9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci12b2lkIHdwYXNfZGV2X2ZvdW5kKHZvaWQgKmN0eCwgY29uc3QgdTggKmFkZHIsCi0JCSAgICBjb25zdCBzdHJ1Y3QgcDJwX3BlZXJfaW5mbyAqaW5mbywKLQkJICAgIGludCBuZXdfZGV2aWNlKTsKIHZvaWQgd3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKLXZvaWQgd3Bhc19nb19uZWdfY29tcGxldGVkKHZvaWQgKmN0eCwgc3RydWN0IHAycF9nb19uZWdfcmVzdWx0cyAqcmVzKTsKLXZvaWQgd3Bhc19nb19uZWdfcmVxX3J4KHZvaWQgKmN0eCwgY29uc3QgdTggKnNyYywgdTE2IGRldl9wYXNzd2RfaWQpOwotdm9pZCB3cGFzX3Byb3ZfZGlzY19yZXEodm9pZCAqY3R4LCBjb25zdCB1OCAqcGVlciwgdTE2IGNvbmZpZ19tZXRob2RzLAotCQkJY29uc3QgdTggKmRldl9hZGRyLCBjb25zdCB1OCAqcHJpX2Rldl90eXBlLAotCQkJY29uc3QgY2hhciAqZGV2X25hbWUsIHUxNiBzdXBwX2NvbmZpZ19tZXRob2RzLAotCQkJdTggZGV2X2NhcGFiLCB1OCBncm91cF9jYXBhYiwgY29uc3QgdTggKmdyb3VwX2lkLAotCQkJc2l6ZV90IGdyb3VwX2lkX2xlbik7Ci12b2lkIHdwYXNfcHJvdl9kaXNjX3Jlc3Aodm9pZCAqY3R4LCBjb25zdCB1OCAqcGVlciwgdTE2IGNvbmZpZ19tZXRob2RzKTsKLXZvaWQgd3Bhc19zZF9yZXF1ZXN0KHZvaWQgKmN0eCwgaW50IGZyZXEsIGNvbnN0IHU4ICpzYSwgdTggZGlhbG9nX3Rva2VuLAotCQkgICAgIHUxNiB1cGRhdGVfaW5kaWMsIGNvbnN0IHU4ICp0bHZzLCBzaXplX3QgdGx2c19sZW4pOwotdm9pZCB3cGFzX3NkX3Jlc3BvbnNlKHZvaWQgKmN0eCwgY29uc3QgdTggKnNhLCB1MTYgdXBkYXRlX2luZGljLAotCQkgICAgICBjb25zdCB1OCAqdGx2cywgc2l6ZV90IHRsdnNfbGVuKTsKIHU2NCB3cGFzX3AycF9zZF9yZXF1ZXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpkc3QsCiAJCQljb25zdCBzdHJ1Y3Qgd3BhYnVmICp0bHZzKTsKIHU2NCB3cGFzX3AycF9zZF9yZXF1ZXN0X3VwbnAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmRzdCwKQEAgLTExNCwxMCArODYsOSBAQAogaW50IHdwYXNfcDJwX3JlamVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYWRkcik7CiBpbnQgd3Bhc19wMnBfaW52aXRlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpwZWVyX2FkZHIsCiAJCSAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsIGNvbnN0IHU4ICpnb19kZXZfYWRkciwgaW50IGZyZXEsCi0JCSAgICBpbnQgaHQ0MCwgaW50IHByZWZfZnJlcSk7CisJCSAgICBpbnQgaHQ0MCwgaW50IHZodCwgaW50IHByZWZfZnJlcSk7CiBpbnQgd3Bhc19wMnBfaW52aXRlX2dyb3VwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKmlmbmFtZSwKIAkJCSAgY29uc3QgdTggKnBlZXJfYWRkciwgY29uc3QgdTggKmdvX2Rldl9hZGRyKTsKLXZvaWQgd3Bhc19wMnBfY29tcGxldGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogaW50IHdwYXNfcDJwX3ByZXNlbmNlX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCB1MzIgZHVyYXRpb24xLAogCQkJICB1MzIgaW50ZXJ2YWwxLCB1MzIgZHVyYXRpb24yLCB1MzIgaW50ZXJ2YWwyKTsKIGludCB3cGFzX3AycF9leHRfbGlzdGVuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHVuc2lnbmVkIGludCBwZXJpb2QsCkBAIC0xMjgsMjUgKzk5LDEyIEBACiB2b2lkIHdwYXNfcDJwX2Rpc2Fzc29jX25vdGlmKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpic3NpZCwKIAkJCSAgICAgdTE2IHJlYXNvbl9jb2RlLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCiAJCQkgICAgIGludCBsb2NhbGx5X2dlbmVyYXRlZCk7Ci12b2lkIHdwYXNfcDJwX3VwZGF0ZV9jb25maWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiBpbnQgd3Bhc19wMnBfc2V0X25vYShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCB1OCBjb3VudCwgaW50IHN0YXJ0LAogCQkgICAgIGludCBkdXJhdGlvbik7CiBpbnQgd3Bhc19wMnBfc2V0X2Nyb3NzX2Nvbm5lY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGVuYWJsZWQpOwotdm9pZCB3cGFzX3AycF9ub3RpZl9jb25uZWN0ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci12b2lkIHdwYXNfcDJwX25vdGlmX2Rpc2Nvbm5lY3RlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKLWludCB3cGFzX3AycF9ub3RpZl9wYmNfb3ZlcmxhcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKLXZvaWQgd3Bhc19wMnBfdXBkYXRlX2NoYW5uZWxfbGlzdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIGludCB3cGFzX3AycF9jYW5jZWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci12b2lkIHdwYXNfcDJwX2ludGVyZmFjZV91bmF2YWlsYWJsZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKLXZvaWQgd3Bhc19wMnBfdXBkYXRlX2Jlc3RfY2hhbm5lbHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgICBpbnQgZnJlcV8yNCwgaW50IGZyZXFfNSwgaW50IGZyZXFfb3ZlcmFsbCk7CiBpbnQgd3Bhc19wMnBfdW5hdXRob3JpemUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgY2hhciAqYWRkcik7CiBpbnQgd3Bhc19wMnBfZGlzY29ubmVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKLXZvaWQgd3Bhc19wMnBfd3BzX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJIHN0cnVjdCB3cHNfZXZlbnRfZmFpbCAqZmFpbCk7Ci1pbnQgd3Bhc19wMnBfaW5fcHJvZ3Jlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci12b2lkIHdwYXNfcDJwX25ldHdvcmtfcmVtb3ZlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJICAgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkKTsKIHN0cnVjdCB3cGFfc3NpZCAqIHdwYXNfcDJwX2dldF9wZXJzaXN0ZW50KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSAgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpzc2lkLAogCQkJCQkgIHNpemVfdCBzc2lkX2xlbik7CkBAIC0xNTUsMjAgKzExMywxNDMgQEAKIGludCB3cGFzX3AycF9zY2FuX25vX2dvX3NlZW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiBpbnQgd3Bhc19wMnBfZ2V0X2h0NDBfbW9kZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJICAgc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGUsIHU4IGNoYW5uZWwpOworaW50IHdwYXNfcDJwX2dldF92aHQ4MF9jZW50ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgICAgIHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICptb2RlLCB1OCBjaGFubmVsKTsKIHVuc2lnbmVkIGludCB3cGFzX3AycF9zZWFyY2hfZGVsYXkoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIHdwYXNfcDJwX25ld19wc2tfY2Ioc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKm1hY19hZGRyLAogCQkJIGNvbnN0IHU4ICpwMnBfZGV2X2FkZHIsCiAJCQkgY29uc3QgdTggKnBzaywgc2l6ZV90IHBza19sZW4pOwogdm9pZCB3cGFzX3AycF9yZW1vdmVfY2xpZW50KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpwZWVyLAogCQkJICAgIGludCBpZmFjZV9hZGRyKTsKK3N0cnVjdCB3cGFidWYgKiB3cGFzX3AycF9uZmNfaGFuZG92ZXJfcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgaW50IG5kZWYpOworc3RydWN0IHdwYWJ1ZiAqIHdwYXNfcDJwX25mY19oYW5kb3Zlcl9zZWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICBpbnQgbmRlZiwgaW50IHRhZyk7CitpbnQgd3Bhc19wMnBfbmZjX3RhZ19wcm9jZXNzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRhdGEsIGludCBmb3JjZWRfZnJlcSk7CitpbnQgd3Bhc19wMnBfbmZjX3JlcG9ydF9oYW5kb3ZlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgaW5pdCwKKwkJCQkgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcmVxLAorCQkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpzZWwsIGludCBmb3JjZWRfZnJlcSk7CitpbnQgd3Bhc19wMnBfbmZjX3RhZ19lbmFibGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBlbmFibGVkKTsKK3ZvaWQgd3Bhc19wMnBfcGJjX292ZXJsYXBfY2Iodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCk7CiAKICNpZmRlZiBDT05GSUdfUDJQCi12b2lkIHdwYXNfcDJwX2NvbnRpbnVlX2FmdGVyX3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CisKK2ludCB3cGFzX3AycF9pbml0KHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwordm9pZCB3cGFzX3AycF9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIHdwYXNfcDJwX2NvbXBsZXRlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3ZvaWQgd3Bhc19wMnBfdXBkYXRlX2NvbmZpZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK2ludCB3cGFzX3AycF9wcm9iZV9yZXFfcngoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmFkZHIsCisJCQkgIGNvbnN0IHU4ICpkc3QsIGNvbnN0IHU4ICpic3NpZCwKKwkJCSAgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuLAorCQkJICBpbnQgc3NpX3NpZ25hbCk7Cit2b2lkIHdwYXNfcDJwX3dwc19zdWNjZXNzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpwZWVyX2FkZHIsCisJCQkgIGludCByZWdpc3RyYXIpOwordm9pZCB3cGFzX3AycF91cGRhdGVfY2hhbm5lbF9saXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwordm9pZCB3cGFzX3AycF91cGRhdGVfYmVzdF9jaGFubmVscyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgIGludCBmcmVxXzI0LCBpbnQgZnJlcV81LCBpbnQgZnJlcV9vdmVyYWxsKTsKK3ZvaWQgd3Bhc19wMnBfcnhfYWN0aW9uKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpkYSwKKwkJCWNvbnN0IHU4ICpzYSwgY29uc3QgdTggKmJzc2lkLAorCQkJdTggY2F0ZWdvcnksIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuLCBpbnQgZnJlcSk7Cit2b2lkIHdwYXNfcDJwX3JlbWFpbl9vbl9jaGFubmVsX2NiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgdW5zaWduZWQgaW50IGZyZXEsIHVuc2lnbmVkIGludCBkdXJhdGlvbik7Cit2b2lkIHdwYXNfcDJwX2NhbmNlbF9yZW1haW5fb25fY2hhbm5lbF9jYihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgIHVuc2lnbmVkIGludCBmcmVxKTsKK3ZvaWQgd3Bhc19wMnBfaW50ZXJmYWNlX3VuYXZhaWxhYmxlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwordm9pZCB3cGFzX3AycF9ub3RpZl9jb25uZWN0ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIHdwYXNfcDJwX25vdGlmX2Rpc2Nvbm5lY3RlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK2ludCB3cGFzX3AycF9ub3RpZl9wYmNfb3ZlcmxhcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIGludCB3cGFzX3AycF80d2F5X2hzX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIHZvaWQgd3Bhc19wMnBfYXBfc2V0dXBfZmFpbGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwordm9pZCB3cGFzX3AycF9pbmRpY2F0ZV9zdGF0ZV9jaGFuZ2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIHdwYXNfcDJwX2RlaW5pdF9pZmFjZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3ZvaWQgd3Bhc19wMnBfYXBfZGVpbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwordm9pZCB3cGFzX3AycF9uZXR3b3JrX3JlbW92ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCk7CitpbnQgd3Bhc19wMnBfaW5fcHJvZ3Jlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CitpbnQgd3Bhc19wMnBfd3BzX2VhcG9sX2NiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwordm9pZCB3cGFzX3AycF93cHNfZmFpbGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgc3RydWN0IHdwc19ldmVudF9mYWlsICpmYWlsKTsKKwogI2Vsc2UgLyogQ09ORklHX1AyUCAqLwotc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX2NvbnRpbnVlX2FmdGVyX3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKKworc3RhdGljIGlubGluZSBpbnQKK3dwYXNfcDJwX2luaXQoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX2RlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3Bhc19wMnBfY29tcGxldGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB3cGFzX3AycF91cGRhdGVfY29uZmlnKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYXNfcDJwX3Byb2JlX3JlcV9yeChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQljb25zdCB1OCAqYWRkciwKKwkJCQkJY29uc3QgdTggKmRzdCwgY29uc3QgdTggKmJzc2lkLAorCQkJCQljb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCisJCQkJCWludCBzc2lfc2lnbmFsKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3Bhc19wMnBfd3BzX3N1Y2Nlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJY29uc3QgdTggKnBlZXJfYWRkciwgaW50IHJlZ2lzdHJhcikKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX3VwZGF0ZV9jaGFubmVsX2xpc3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX3VwZGF0ZV9iZXN0X2NoYW5uZWxzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCQkgaW50IGZyZXFfMjQsIGludCBmcmVxXzUsCisJCQkJCQkgaW50IGZyZXFfb3ZlcmFsbCkKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX3J4X2FjdGlvbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgIGNvbnN0IHU4ICpkYSwKKwkJCQkgICAgICBjb25zdCB1OCAqc2EsIGNvbnN0IHU4ICpic3NpZCwKKwkJCQkgICAgICB1OCBjYXRlZ29yeSwgY29uc3QgdTggKmRhdGEsIHNpemVfdCBsZW4sCisJCQkJICAgICAgaW50IGZyZXEpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB3cGFzX3AycF9yZW1haW5fb25fY2hhbm5lbF9jYihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkJIHVuc2lnbmVkIGludCBmcmVxLAorCQkJCQkJIHVuc2lnbmVkIGludCBkdXJhdGlvbikKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkCit3cGFzX3AycF9jYW5jZWxfcmVtYWluX29uX2NoYW5uZWxfY2Ioc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgIHVuc2lnbmVkIGludCBmcmVxKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3Bhc19wMnBfaW50ZXJmYWNlX3VuYXZhaWxhYmxlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB3cGFzX3AycF9ub3RpZl9jb25uZWN0ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX25vdGlmX2Rpc2Nvbm5lY3RlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworfQorCitzdGF0aWMgaW5saW5lIGludCB3cGFzX3AycF9ub3RpZl9wYmNfb3ZlcmxhcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW5saW5lIGludCB3cGFzX3AycF80d2F5X2hzX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQpAQCAtMTc5LDYgKzI2MCwzOSBAQAogc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX2FwX3NldHVwX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3Bhc19wMnBfaW5kaWNhdGVfc3RhdGVfY2hhbmdlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB3cGFzX3AycF9kZWluaXRfaWZhY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdwYXNfcDJwX2FwX2RlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3Bhc19wMnBfbmV0d29ya19yZW1vdmVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYXNfcDJwX2luX3Byb2dyZXNzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHdwYXNfcDJwX3dwc19lYXBvbF9jYihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3Bhc19wMnBfd3BzX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgICBzdHJ1Y3Qgd3BzX2V2ZW50X2ZhaWwgKmZhaWwpCit7Cit9CisKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKICNlbmRpZiAvKiBQMlBfU1VQUExJQ0FOVF9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9wcmVhdXRoX3Rlc3QuYyBiL3dwYV9zdXBwbGljYW50L3ByZWF1dGhfdGVzdC5jCmluZGV4IGZmMmFlNzQuLmVkNTcwODUgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3ByZWF1dGhfdGVzdC5jCisrKyBiL3dwYV9zdXBwbGljYW50L3ByZWF1dGhfdGVzdC5jCkBAIC0yNyw5ICsyNyw2IEBACiAjaW5jbHVkZSAiZHJpdmVycy9kcml2ZXIuaCIKIAogCi1leHRlcm4gaW50IHdwYV9kZWJ1Z19sZXZlbDsKLWV4dGVybiBpbnQgd3BhX2RlYnVnX3Nob3dfa2V5czsKLQogc3RydWN0IHdwYV9kcml2ZXJfb3BzICp3cGFfZHJpdmVyc1tdID0geyBOVUxMIH07CiAKIApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvc2Nhbi5jIGIvd3BhX3N1cHBsaWNhbnQvc2Nhbi5jCmluZGV4IGEwZjUxZDAuLjQwZWI4ZDggMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3NjYW4uYworKysgYi93cGFfc3VwcGxpY2FudC9zY2FuLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogV1BBIFN1cHBsaWNhbnQgLSBTY2FubmluZwotICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTQxLDcxICsxNDEsNDMgQEAKIH0KIAogCi1zdGF0aWMgaW50IGludF9hcnJheV9sZW4oY29uc3QgaW50ICphKQorc3RhdGljIHZvaWQgd3Bhc190cmlnZ2VyX3NjYW5fY2Ioc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrLCBpbnQgZGVpbml0KQogewotCWludCBpOwotCWZvciAoaSA9IDA7IGEgJiYgYVtpXTsgaSsrKQotCQk7Ci0JcmV0dXJuIGk7Ci19CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHdvcmstPndwYV9zOworCXN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpwYXJhbXMgPSB3b3JrLT5jdHg7CisJaW50IHJldDsKIAotCi1zdGF0aWMgdm9pZCBpbnRfYXJyYXlfY29uY2F0KGludCAqKnJlcywgY29uc3QgaW50ICphKQotewotCWludCByZXNsZW4sIGFsZW4sIGk7Ci0JaW50ICpuOwotCi0JcmVzbGVuID0gaW50X2FycmF5X2xlbigqcmVzKTsKLQlhbGVuID0gaW50X2FycmF5X2xlbihhKTsKLQotCW4gPSBvc19yZWFsbG9jX2FycmF5KCpyZXMsIHJlc2xlbiArIGFsZW4gKyAxLCBzaXplb2YoaW50KSk7Ci0JaWYgKG4gPT0gTlVMTCkgewotCQlvc19mcmVlKCpyZXMpOwotCQkqcmVzID0gTlVMTDsKLQkJcmV0dXJuOwotCX0KLQlmb3IgKGkgPSAwOyBpIDw9IGFsZW47IGkrKykKLQkJbltyZXNsZW4gKyBpXSA9IGFbaV07Ci0JKnJlcyA9IG47Ci19Ci0KLQotc3RhdGljIGludCBmcmVxX2NtcChjb25zdCB2b2lkICphLCBjb25zdCB2b2lkICpiKQotewotCWludCBfYSA9ICooaW50ICopIGE7Ci0JaW50IF9iID0gKihpbnQgKikgYjsKLQotCWlmIChfYSA9PSAwKQotCQlyZXR1cm4gMTsKLQlpZiAoX2IgPT0gMCkKLQkJcmV0dXJuIC0xOwotCXJldHVybiBfYSAtIF9iOwotfQotCi0KLXN0YXRpYyB2b2lkIGludF9hcnJheV9zb3J0X3VuaXF1ZShpbnQgKmEpCi17Ci0JaW50IGFsZW47Ci0JaW50IGksIGo7Ci0KLQlpZiAoYSA9PSBOVUxMKQotCQlyZXR1cm47Ci0KLQlhbGVuID0gaW50X2FycmF5X2xlbihhKTsKLQlxc29ydChhLCBhbGVuLCBzaXplb2YoaW50KSwgZnJlcV9jbXApOwotCi0JaSA9IDA7Ci0JaiA9IDE7Ci0Jd2hpbGUgKGFbaV0gJiYgYVtqXSkgewotCQlpZiAoYVtpXSA9PSBhW2pdKSB7Ci0JCQlqKys7Ci0JCQljb250aW51ZTsKKwlpZiAoZGVpbml0KSB7CisJCWlmICghd29yay0+c3RhcnRlZCkgeworCQkJd3BhX3NjYW5fZnJlZV9wYXJhbXMocGFyYW1zKTsKKwkJCXJldHVybjsKIAkJfQotCQlhWysraV0gPSBhW2orK107CisJCXdwYV9zdXBwbGljYW50X25vdGlmeV9zY2FubmluZyh3cGFfcywgMCk7CisJCXdwYXNfbm90aWZ5X3NjYW5fZG9uZSh3cGFfcywgMCk7CisJCXdwYV9zLT5zY2FuX3dvcmsgPSBOVUxMOworCQlyZXR1cm47CiAJfQotCWlmIChhW2ldKQotCQlpKys7Ci0JYVtpXSA9IDA7CisKKwl3cGFfc3VwcGxpY2FudF9ub3RpZnlfc2Nhbm5pbmcod3BhX3MsIDEpOworCisJaWYgKHdwYV9zLT5jbGVhcl9kcml2ZXJfc2Nhbl9jYWNoZSkKKwkJcGFyYW1zLT5vbmx5X25ld19yZXN1bHRzID0gMTsKKwlyZXQgPSB3cGFfZHJ2X3NjYW4od3BhX3MsIHBhcmFtcyk7CisJd3BhX3NjYW5fZnJlZV9wYXJhbXMocGFyYW1zKTsKKwl3b3JrLT5jdHggPSBOVUxMOworCWlmIChyZXQpIHsKKwkJd3BhX3N1cHBsaWNhbnRfbm90aWZ5X3NjYW5uaW5nKHdwYV9zLCAwKTsKKwkJd3Bhc19ub3RpZnlfc2Nhbl9kb25lKHdwYV9zLCAwKTsKKwkJcmFkaW9fd29ya19kb25lKHdvcmspOworCQlyZXR1cm47CisJfQorCisJb3NfZ2V0X3JlbHRpbWUoJndwYV9zLT5zY2FuX3RyaWdnZXJfdGltZSk7CisJd3BhX3MtPnNjYW5fcnVucysrOworCXdwYV9zLT5ub3JtYWxfc2NhbnMrKzsKKwl3cGFfcy0+b3duX3NjYW5fcmVxdWVzdGVkID0gMTsKKwl3cGFfcy0+Y2xlYXJfZHJpdmVyX3NjYW5fY2FjaGUgPSAwOworCXdwYV9zLT5zY2FuX3dvcmsgPSB3b3JrOwogfQogCiAKQEAgLTIxOCwyMSArMTkwLDI0IEBACiBpbnQgd3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgKnBhcmFtcykKIHsKLQlpbnQgcmV0OworCXN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpjdHg7CiAKLQl3cGFfc3VwcGxpY2FudF9ub3RpZnlfc2Nhbm5pbmcod3BhX3MsIDEpOwotCi0JcmV0ID0gd3BhX2Rydl9zY2FuKHdwYV9zLCBwYXJhbXMpOwotCWlmIChyZXQpIHsKLQkJd3BhX3N1cHBsaWNhbnRfbm90aWZ5X3NjYW5uaW5nKHdwYV9zLCAwKTsKLQkJd3Bhc19ub3RpZnlfc2Nhbl9kb25lKHdwYV9zLCAwKTsKLQl9IGVsc2UgewotCQlvc19nZXRfdGltZSgmd3BhX3MtPnNjYW5fdHJpZ2dlcl90aW1lKTsKLQkJd3BhX3MtPnNjYW5fcnVucysrOwotCQl3cGFfcy0+bm9ybWFsX3NjYW5zKys7CisJaWYgKHdwYV9zLT5zY2FuX3dvcmspIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0lORk8sICJSZWplY3Qgc2NhbiB0cmlnZ2VyIHNpbmNlIG9uZSBpcyBhbHJlYWR5IHBlbmRpbmciKTsKKwkJcmV0dXJuIC0xOwogCX0KIAotCXJldHVybiByZXQ7CisJY3R4ID0gd3BhX3NjYW5fY2xvbmVfcGFyYW1zKHBhcmFtcyk7CisJaWYgKGN0eCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpZiAocmFkaW9fYWRkX3dvcmsod3BhX3MsIDAsICJzY2FuIiwgMCwgd3Bhc190cmlnZ2VyX3NjYW5fY2IsIGN0eCkgPCAwKQorCXsKKwkJd3BhX3NjYW5fZnJlZV9wYXJhbXMoY3R4KTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOwogfQogCiAKQEAgLTI2MCwxMCArMjM1LDkgQEAKIH0KIAogCi1zdGF0aWMgaW50Ci13cGFfc3VwcGxpY2FudF9zdGFydF9zY2hlZF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgKnBhcmFtcywKLQkJCQlpbnQgaW50ZXJ2YWwpCitpbnQgd3BhX3N1cHBsaWNhbnRfc3RhcnRfc2NoZWRfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqcGFyYW1zLAorCQkJCSAgICBpbnQgaW50ZXJ2YWwpCiB7CiAJaW50IHJldDsKIApAQCAtMjcxLDE1ICsyNDUsMTQgQEAKIAlyZXQgPSB3cGFfZHJ2X3NjaGVkX3NjYW4od3BhX3MsIHBhcmFtcywgaW50ZXJ2YWwgKiAxMDAwKTsKIAlpZiAocmV0KQogCQl3cGFfc3VwcGxpY2FudF9ub3RpZnlfc2Nhbm5pbmcod3BhX3MsIDApOwotCWVsc2UgeworCWVsc2UKIAkJd3BhX3MtPnNjaGVkX3NjYW5uaW5nID0gMTsKLQl9CiAKIAlyZXR1cm4gcmV0OwogfQogCiAKLXN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfc3RvcF9zY2hlZF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCitpbnQgd3BhX3N1cHBsaWNhbnRfc3RvcF9zY2hlZF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJaW50IHJldDsKIApAQCAtMzUzLDYgKzMyNiwzMiBAQAogCQl9CiAJCXdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nKys7CiAJfQorCisJaWYgKHBhcmFtcy0+ZnJlcXMgPT0gTlVMTCAmJiB3cGFfcy0+cDJwX2luX2ludml0YXRpb24pIHsKKwkJLyoKKwkJICogT3B0aW1pemUgc2NhbiBiYXNlZCBvbiBHTyBpbmZvcm1hdGlvbiBkdXJpbmcgcGVyc2lzdGVudAorCQkgKiBncm91cCByZWludm9jYXRpb24KKwkJICovCisJCWlmICh3cGFfcy0+cDJwX2luX2ludml0YXRpb24gPCA1ICYmCisJCSAgICB3cGFfcy0+cDJwX2ludml0ZV9nb19mcmVxID4gMCkgeworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBTY2FuIG9ubHkgR08gcHJlZmVycmVkIGZyZXF1ZW5jeSAlZCBNSHogZHVyaW5nIGludml0YXRpb24iLAorCQkJCXdwYV9zLT5wMnBfaW52aXRlX2dvX2ZyZXEpOworCQkJcGFyYW1zLT5mcmVxcyA9IG9zX3phbGxvYygyICogc2l6ZW9mKGludCkpOworCQkJaWYgKHBhcmFtcy0+ZnJlcXMpCisJCQkJcGFyYW1zLT5mcmVxc1swXSA9IHdwYV9zLT5wMnBfaW52aXRlX2dvX2ZyZXE7CisJCX0KKwkJd3BhX3MtPnAycF9pbl9pbnZpdGF0aW9uKys7CisJCWlmICh3cGFfcy0+cDJwX2luX2ludml0YXRpb24gPiAyMCkgeworCQkJLyoKKwkJCSAqIFRoaXMgc2hvdWxkIG5vdCByZWFsbHkgaGFwcGVuIHNpbmNlIHRoZSB2YXJpYWJsZSBpcworCQkJICogY2xlYXJlZCBvbiBncm91cCByZW1vdmFsLCBidXQgaWYgaXQgZG9lcyBoYXBwZW4sIG1ha2UKKwkJCSAqIHN1cmUgd2UgZG8gbm90IGdldCBzdHVjayBpbiBzcGVjaWFsIGludml0YXRpb24gc2NhbgorCQkJICogbW9kZS4KKwkJCSAqLworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBDbGVhciBwMnBfaW5faW52aXRhdGlvbiIpOworCQkJd3BhX3MtPnAycF9pbl9pbnZpdGF0aW9uID0gMDsKKwkJfQorCX0KICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKICNpZmRlZiBDT05GSUdfV1BTCkBAIC0zNjcsNyArMzY2LDggQEAKIAkJaWYgKHBhcmFtcy0+ZnJlcXMpCiAJCQlwYXJhbXMtPmZyZXFzWzBdID0gd3BhX3MtPndwc19mcmVxOwogCQl3cGFfcy0+YWZ0ZXJfd3BzLS07Ci0JfQorCX0gZWxzZSBpZiAod3BhX3MtPmFmdGVyX3dwcykKKwkJd3BhX3MtPmFmdGVyX3dwcy0tOwogCiAJaWYgKHBhcmFtcy0+ZnJlcXMgPT0gTlVMTCAmJiB3cGFfcy0+a25vd25fd3BzX2ZyZXEgJiYgd3BhX3MtPndwc19mcmVxKQogCXsKQEAgLTM5MSwxMSArMzkxLDE3IEBACiAJCXJldHVybjsKIAogCXdwYWJ1Zl9wdXRfdTgoYnVmLCBXTEFOX0VJRF9FWFRfQ0FQQUIpOwotCXdwYWJ1Zl9wdXRfdTgoYnVmLCA0KTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgNik7CiAJd3BhYnVmX3B1dF91OChidWYsIDB4MDApOwogCXdwYWJ1Zl9wdXRfdTgoYnVmLCAweDAwKTsKIAl3cGFidWZfcHV0X3U4KGJ1ZiwgMHgwMCk7CiAJd3BhYnVmX3B1dF91OChidWYsIDB4ODApOyAvKiBCaXQgMzEgLSBJbnRlcndvcmtpbmcgKi8KKwl3cGFidWZfcHV0X3U4KGJ1ZiwgMHgwMCk7CisjaWZkZWYgQ09ORklHX0hTMjAKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgMHg0MCk7IC8qIEJpdCA0NiAtIFdOTS1Ob3RpZmljYXRpb24gKi8KKyNlbHNlIC8qIENPTkZJR19IUzIwICovCisJd3BhYnVmX3B1dF91OChidWYsIDB4MDApOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKIAl3cGFidWZfcHV0X3U4KGJ1ZiwgV0xBTl9FSURfSU5URVJXT1JLSU5HKTsKIAl3cGFidWZfcHV0X3U4KGJ1ZiwgaXNfemVyb19ldGhlcl9hZGRyKHdwYV9zLT5jb25mLT5oZXNzaWQpID8gMSA6CkBAIC00NTEsNyArNDU3LDcgQEAKIAogI2lmZGVmIENPTkZJR19IUzIwCiAJaWYgKHdwYV9zLT5jb25mLT5oczIwICYmIHdwYWJ1Zl9yZXNpemUoJmV4dHJhX2llLCA3KSA9PSAwKQotCQl3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oZXh0cmFfaWUpOworCQl3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oZXh0cmFfaWUsIC0xKTsKICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCiAJcmV0dXJuIGV4dHJhX2llOwpAQCAtNTQyLDExICs1NDgsNTEgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFfc2V0X3NjYW5fc3NpZHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgICAgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqcGFyYW1zLAorCQkJICAgICAgIHNpemVfdCBtYXhfc3NpZHMpCit7CisJdW5zaWduZWQgaW50IGk7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkOworCisJZm9yIChpID0gMDsgaSA8IHdwYV9zLT5zY2FuX2lkX2NvdW50OyBpKyspIHsKKwkJdW5zaWduZWQgaW50IGo7CisKKwkJc3NpZCA9IHdwYV9jb25maWdfZ2V0X25ldHdvcmsod3BhX3MtPmNvbmYsIHdwYV9zLT5zY2FuX2lkW2ldKTsKKwkJaWYgKCFzc2lkIHx8ICFzc2lkLT5zY2FuX3NzaWQpCisJCQljb250aW51ZTsKKworCQlmb3IgKGogPSAwOyBqIDwgcGFyYW1zLT5udW1fc3NpZHM7IGorKykgeworCQkJaWYgKHBhcmFtcy0+c3NpZHNbal0uc3NpZF9sZW4gPT0gc3NpZC0+c3NpZF9sZW4gJiYKKwkJCSAgICBwYXJhbXMtPnNzaWRzW2pdLnNzaWQgJiYKKwkJCSAgICBvc19tZW1jbXAocGFyYW1zLT5zc2lkc1tqXS5zc2lkLCBzc2lkLT5zc2lkLAorCQkJCSAgICAgIHNzaWQtPnNzaWRfbGVuKSA9PSAwKQorCQkJCWJyZWFrOworCQl9CisJCWlmIChqIDwgcGFyYW1zLT5udW1fc3NpZHMpCisJCQljb250aW51ZTsgLyogYWxyZWFkeSBpbiB0aGUgbGlzdCAqLworCisJCWlmIChwYXJhbXMtPm51bV9zc2lkcyArIDEgPiBtYXhfc3NpZHMpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJPdmVyIG1heCBzY2FuIFNTSURzIGZvciBtYW51YWwgcmVxdWVzdCIpOworCQkJYnJlYWs7CisJCX0KKworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNjYW4gU1NJRCAobWFudWFsIHJlcXVlc3QpOiAlcyIsCisJCQkgICB3cGFfc3NpZF90eHQoc3NpZC0+c3NpZCwgc3NpZC0+c3NpZF9sZW4pKTsKKwkJcGFyYW1zLT5zc2lkc1twYXJhbXMtPm51bV9zc2lkc10uc3NpZCA9IHNzaWQtPnNzaWQ7CisJCXBhcmFtcy0+c3NpZHNbcGFyYW1zLT5udW1fc3NpZHNdLnNzaWRfbGVuID0gc3NpZC0+c3NpZF9sZW47CisJCXBhcmFtcy0+bnVtX3NzaWRzKys7CisJfQorCisJd3BhX3MtPnNjYW5faWRfY291bnQgPSAwOworfQorCisKIHN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X3NjYW4odm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gZWxvb3BfY3R4OwogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKLQllbnVtIHNjYW5fcmVxX3R5cGUgc2Nhbl9yZXEgPSBOT1JNQUxfU0NBTl9SRVE7CiAJaW50IHJldDsKIAlzdHJ1Y3Qgd3BhYnVmICpleHRyYV9pZSA9IE5VTEw7CiAJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgcGFyYW1zOwpAQCAtNTU0LDMwICs2MDAsMzYgQEAKIAlzaXplX3QgbWF4X3NzaWRzOwogCWVudW0gd3BhX3N0YXRlcyBwcmV2X3N0YXRlOwogCisJaWYgKHdwYV9zLT5wbm8gfHwgd3BhX3MtPnBub19zY2hlZF9wZW5kaW5nKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlNraXAgc2NhbiAtIFBOTyBpcyBpbiBwcm9ncmVzcyIpOworCQlyZXR1cm47CisJfQorCiAJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCkgewogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJTa2lwIHNjYW4gLSBpbnRlcmZhY2UgZGlzYWJsZWQiKTsKLQkJd3Bhc19wMnBfY29udGludWVfYWZ0ZXJfc2Nhbih3cGFfcyk7CiAJCXJldHVybjsKIAl9CiAKIAlpZiAod3BhX3MtPmRpc2Nvbm5lY3RlZCAmJiB3cGFfcy0+c2Nhbl9yZXEgPT0gTk9STUFMX1NDQU5fUkVRKSB7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkRpc2Nvbm5lY3RlZCAtIGRvIG5vdCBzY2FuIik7CiAJCXdwYV9zdXBwbGljYW50X3NldF9zdGF0ZSh3cGFfcywgV1BBX0RJU0NPTk5FQ1RFRCk7Ci0JCXdwYXNfcDJwX2NvbnRpbnVlX2FmdGVyX3NjYW4od3BhX3MpOwogCQlyZXR1cm47CiAJfQotI2lmZGVmIEFORFJPSUQKKwogCWlmICh3cGFfcy0+c2Nhbm5pbmcpIHsKLQkJLyogSWYgd2UgYXJlIGFscmVhZHkgaW4gc2Nhbm5pbmcgc3RhdGUsIHdlIHNoYWxsIGlnbm9yZSB0aGlzIG5ldyBzY2FuIHJlcXVlc3QqLwotCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJTa2lwIHNjYW4gLSBhbHJlYWR5IHNjYW5uaW5nIik7CisJCS8qCisJCSAqIElmIHdlIGFyZSBhbHJlYWR5IGluIHNjYW5uaW5nIHN0YXRlLCB3ZSBzaGFsbCByZXNjaGVkdWxlIHRoZQorCQkgKiB0aGUgaW5jb21pbmcgc2NhbiByZXF1ZXN0LgorCQkgKi8KKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQWxyZWFkeSBzY2FubmluZyAtIFJlc2NoZWR1bGUgdGhlIGluY29taW5nIHNjYW4gcmVxIik7CisJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAxLCAwKTsKIAkJcmV0dXJuOwogCX0KLSNlbmRpZgorCiAJaWYgKCF3cGFfc3VwcGxpY2FudF9lbmFibGVkX25ldHdvcmtzKHdwYV9zKSAmJgogCSAgICB3cGFfcy0+c2Nhbl9yZXEgPT0gTk9STUFMX1NDQU5fUkVRKSB7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIk5vIGVuYWJsZWQgbmV0d29ya3MgLSBkbyBub3Qgc2NhbiIpOwogCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9JTkFDVElWRSk7Ci0JCXdwYXNfcDJwX2NvbnRpbnVlX2FmdGVyX3NjYW4od3BhX3MpOwogCQlyZXR1cm47CiAJfQogCkBAIC01OTQsMjIgKzY0NiwxMSBAQAogCQlyZXR1cm47CiAJfQogCi0jaWZkZWYgQ09ORklHX1AyUAotCWlmICh3cGFzX3AycF9pbl9wcm9ncmVzcyh3cGFfcykgfHwgd3Bhc193cGFfaXNfaW5fcHJvZ3Jlc3Mod3BhX3MpKSB7Ci0JCWlmICh3cGFfcy0+c3RhX3NjYW5fcGVuZGluZyAmJgotCQkgICAgd3Bhc19wMnBfaW5fcHJvZ3Jlc3Mod3BhX3MpID09IDIgJiYKLQkJICAgIHdwYV9zLT5nbG9iYWwtPnAycF9jYl9vbl9zY2FuX2NvbXBsZXRlKSB7Ci0JCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQcm9jZXNzIHBlbmRpbmcgc3RhdGlvbiAiCi0JCQkJIm1vZGUgc2NhbiBkdXJpbmcgUDJQIHNlYXJjaCIpOwotCQl9IGVsc2UgewotCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiRGVsYXkgc3RhdGlvbiBtb2RlIHNjYW4gIgotCQkJCSJ3aGlsZSBQMlAgb3BlcmF0aW9uIGlzIGluIHByb2dyZXNzIik7Ci0JCQl3cGFfcy0+c3RhX3NjYW5fcGVuZGluZyA9IDE7Ci0JCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgNSwgMCk7Ci0JCQlyZXR1cm47Ci0JCX0KKwlpZiAod3Bhc19wMnBfaW5fcHJvZ3Jlc3Mod3BhX3MpKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkRlbGF5IHN0YXRpb24gbW9kZSBzY2FuIHdoaWxlIFAyUCBvcGVyYXRpb24gaXMgaW4gcHJvZ3Jlc3MiKTsKKwkJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDUsIDApOworCQlyZXR1cm47CiAJfQotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCWlmICh3cGFfcy0+Y29uZi0+YXBfc2NhbiA9PSAyKQogCQltYXhfc3NpZHMgPSAxOwpAQCAtNjE5LDcgKzY2MCw3IEBACiAJCQltYXhfc3NpZHMgPSBXUEFTX01BWF9TQ0FOX1NTSURTOwogCX0KIAotCXNjYW5fcmVxID0gd3BhX3MtPnNjYW5fcmVxOworCXdwYV9zLT5sYXN0X3NjYW5fcmVxID0gd3BhX3MtPnNjYW5fcmVxOwogCXdwYV9zLT5zY2FuX3JlcSA9IE5PUk1BTF9TQ0FOX1JFUTsKIAogCW9zX21lbXNldCgmcGFyYW1zLCAwLCBzaXplb2YocGFyYW1zKSk7CkBAIC02MzcsNyArNjc4LDggQEAKIAkJZ290byBzY2FuOwogCX0KIAotCWlmIChzY2FuX3JlcSAhPSBNQU5VQUxfU0NBTl9SRVEgJiYgd3BhX3MtPmNvbm5lY3Rfd2l0aG91dF9zY2FuKSB7CisJaWYgKHdwYV9zLT5sYXN0X3NjYW5fcmVxICE9IE1BTlVBTF9TQ0FOX1JFUSAmJgorCSAgICB3cGFfcy0+Y29ubmVjdF93aXRob3V0X3NjYW4pIHsKIAkJZm9yIChzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7IHNzaWQ7IHNzaWQgPSBzc2lkLT5uZXh0KSB7CiAJCQlpZiAoc3NpZCA9PSB3cGFfcy0+Y29ubmVjdF93aXRob3V0X3NjYW4pCiAJCQkJYnJlYWs7CkBAIC02NTQsMTMgKzY5NiwyNyBAQAogI2lmZGVmIENPTkZJR19QMlAKIAlpZiAoKHdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nIHx8IHdwYV9zLT5zaG93X2dyb3VwX3N0YXJ0ZWQpICYmCiAJICAgIHdwYV9zLT5nb19wYXJhbXMpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFVzZSBzcGVjaWZpYyBTU0lEIGZvciBzY2FuIGR1cmluZyAiCi0JCQkgICAiUDJQIGdyb3VwIGZvcm1hdGlvbiIpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVXNlIHNwZWNpZmljIFNTSUQgZm9yIHNjYW4gZHVyaW5nIFAyUCBncm91cCBmb3JtYXRpb24gKHAycF9pbl9wcm92aXNpb25pbmc9JWQgc2hvd19ncm91cF9zdGFydGVkPSVkKSIsCisJCQkgICB3cGFfcy0+cDJwX2luX3Byb3Zpc2lvbmluZywKKwkJCSAgIHdwYV9zLT5zaG93X2dyb3VwX3N0YXJ0ZWQpOwogCQlwYXJhbXMuc3NpZHNbMF0uc3NpZCA9IHdwYV9zLT5nb19wYXJhbXMtPnNzaWQ7CiAJCXBhcmFtcy5zc2lkc1swXS5zc2lkX2xlbiA9IHdwYV9zLT5nb19wYXJhbXMtPnNzaWRfbGVuOwogCQlwYXJhbXMubnVtX3NzaWRzID0gMTsKIAkJZ290byBzc2lkX2xpc3Rfc2V0OwogCX0KKworCWlmICh3cGFfcy0+cDJwX2luX2ludml0YXRpb24pIHsKKwkJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBVc2Ugc3BlY2lmaWMgU1NJRCBmb3Igc2NhbiBkdXJpbmcgaW52aXRhdGlvbiIpOworCQkJcGFyYW1zLnNzaWRzWzBdLnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkOworCQkJcGFyYW1zLnNzaWRzWzBdLnNzaWRfbGVuID0KKwkJCQl3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkX2xlbjsKKwkJCXBhcmFtcy5udW1fc3NpZHMgPSAxOworCQl9IGVsc2UgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IE5vIHNwZWNpZmljIFNTSUQga25vd24gZm9yIHNjYW4gZHVyaW5nIGludml0YXRpb24iKTsKKwkJfQorCQlnb3RvIHNzaWRfbGlzdF9zZXQ7CisJfQogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCS8qIEZpbmQgdGhlIHN0YXJ0aW5nIHBvaW50IGZyb20gd2hpY2ggdG8gY29udGludWUgc2Nhbm5pbmcgKi8KQEAgLTY3NSwxOSArNzMxLDQ4IEBACiAJCX0KIAl9CiAKLQlpZiAoc2Nhbl9yZXEgIT0gTUFOVUFMX1NDQU5fUkVRICYmIHdwYV9zLT5jb25mLT5hcF9zY2FuID09IDIpIHsKKwlpZiAod3BhX3MtPmxhc3Rfc2Nhbl9yZXEgIT0gTUFOVUFMX1NDQU5fUkVRICYmCisJICAgIHdwYV9zLT5jb25mLT5hcF9zY2FuID09IDIpIHsKIAkJd3BhX3MtPmNvbm5lY3Rfd2l0aG91dF9zY2FuID0gTlVMTDsKIAkJd3BhX3MtPnByZXZfc2Nhbl93aWxkY2FyZCA9IDA7CiAJCXdwYV9zdXBwbGljYW50X2Fzc29jX3RyeSh3cGFfcywgc3NpZCk7CiAJCXJldHVybjsKLSNpZm5kZWYgQU5EUk9JRAogCX0gZWxzZSBpZiAod3BhX3MtPmNvbmYtPmFwX3NjYW4gPT0gMikgewogCQkvKgogCQkgKiBVc2VyLWluaXRpYXRlZCBzY2FuIHJlcXVlc3QgaW4gYXBfc2NhbiA9PSAyOyBzY2FuIHdpdGgKIAkJICogd2lsZGNhcmQgU1NJRC4KIAkJICovCiAJCXNzaWQgPSBOVUxMOwotI2VuZGlmCisJfSBlbHNlIGlmICh3cGFfcy0+cmVhdHRhY2ggJiYgd3BhX3MtPmN1cnJlbnRfc3NpZCAhPSBOVUxMKSB7CisJCS8qCisJCSAqIFBlcmZvcm0gc2luZ2xlLWNoYW5uZWwgc2luZ2xlLVNTSUQgc2NhbiBmb3IKKwkJICogcmVhc3NvY2lhdGUtdG8tc2FtZS1CU1Mgb3BlcmF0aW9uLgorCQkgKi8KKwkJLyogU2V0dXAgU1NJRCAqLworCQlzc2lkID0gd3BhX3MtPmN1cnJlbnRfc3NpZDsKKwkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiU2NhbiBTU0lEIiwKKwkJCQkgIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKKwkJcGFyYW1zLnNzaWRzWzBdLnNzaWQgPSBzc2lkLT5zc2lkOworCQlwYXJhbXMuc3NpZHNbMF0uc3NpZF9sZW4gPSBzc2lkLT5zc2lkX2xlbjsKKwkJcGFyYW1zLm51bV9zc2lkcyA9IDE7CisKKwkJLyoKKwkJICogQWxsb2NhdGUgbWVtb3J5IGZvciBmcmVxdWVuY3kgYXJyYXksIGFsbG9jYXRlIG9uZSBleHRyYQorCQkgKiBzbG90IGZvciB0aGUgemVyby10ZXJtaW5hdG9yLgorCQkgKi8KKwkJcGFyYW1zLmZyZXFzID0gb3NfbWFsbG9jKHNpemVvZihpbnQpICogMik7CisJCWlmIChwYXJhbXMuZnJlcXMgPT0gTlVMTCkgeworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0VSUk9SLCAiTWVtb3J5IGFsbG9jYXRpb24gZmFpbGVkIik7CisJCQlyZXR1cm47CisJCX0KKwkJcGFyYW1zLmZyZXFzWzBdID0gd3BhX3MtPmFzc29jX2ZyZXE7CisJCXBhcmFtcy5mcmVxc1sxXSA9IDA7CisKKwkJLyoKKwkJICogUmVzZXQgdGhlIHJlYXR0YWNoIGZsYWcgc28gdGhhdCB3ZSBmYWxsIGJhY2sgdG8gZnVsbCBzY2FuIGlmCisJCSAqIHRoaXMgc2NhbiBmYWlscy4KKwkJICovCisJCXdwYV9zLT5yZWF0dGFjaCA9IDA7CiAJfSBlbHNlIHsKIAkJc3RydWN0IHdwYV9zc2lkICpzdGFydCA9IHNzaWQsICp0c3NpZDsKIAkJaW50IGZyZXFzX3NldCA9IDA7CkBAIC03MTQsNiArNzk5LDEwIEBACiAJCQkJc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOwogCQl9CiAKKwkJaWYgKHdwYV9zLT5zY2FuX2lkX2NvdW50ICYmCisJCSAgICB3cGFfcy0+bGFzdF9zY2FuX3JlcSA9PSBNQU5VQUxfU0NBTl9SRVEpCisJCQl3cGFfc2V0X3NjYW5fc3NpZHMod3BhX3MsICZwYXJhbXMsIG1heF9zc2lkcyk7CisKIAkJZm9yICh0c3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOyB0c3NpZDsgdHNzaWQgPSB0c3NpZC0+bmV4dCkgewogCQkJaWYgKHdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgdHNzaWQpKQogCQkJCWNvbnRpbnVlOwpAQCAtNzU1LDYgKzg0NCw5IEBACiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkluY2x1ZGUgd2lsZGNhcmQgU1NJRCBpbiAiCiAJCQkidGhlIHNjYW4gcmVxdWVzdCIpOwogCQlwYXJhbXMubnVtX3NzaWRzKys7CisJfSBlbHNlIGlmICh3cGFfcy0+bGFzdF9zY2FuX3JlcSA9PSBNQU5VQUxfU0NBTl9SRVEgJiYKKwkJICAgd3BhX3MtPm1hbnVhbF9zY2FuX3Bhc3NpdmUgJiYgcGFyYW1zLm51bV9zc2lkcyA9PSAwKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlVzZSBwYXNzaXZlIHNjYW4gYmFzZWQgb24gbWFudWFsIHJlcXVlc3QiKTsKIAl9IGVsc2UgewogCQl3cGFfcy0+cHJldl9zY2FuX3NzaWQgPSBXSUxEQ0FSRF9TU0lEX1NDQU47CiAJCXBhcmFtcy5udW1fc3NpZHMrKzsKQEAgLTc2OCw2ICs4NjAsMTcgQEAKIAl3cGFfc3VwcGxpY2FudF9vcHRpbWl6ZV9mcmVxcyh3cGFfcywgJnBhcmFtcyk7CiAJZXh0cmFfaWUgPSB3cGFfc3VwcGxpY2FudF9leHRyYV9pZXMod3BhX3MpOwogCisJaWYgKHdwYV9zLT5sYXN0X3NjYW5fcmVxID09IE1BTlVBTF9TQ0FOX1JFUSAmJgorCSAgICB3cGFfcy0+bWFudWFsX3NjYW5fb25seV9uZXcpCisJCXBhcmFtcy5vbmx5X25ld19yZXN1bHRzID0gMTsKKworCWlmICh3cGFfcy0+bGFzdF9zY2FuX3JlcSA9PSBNQU5VQUxfU0NBTl9SRVEgJiYgcGFyYW1zLmZyZXFzID09IE5VTEwgJiYKKwkgICAgd3BhX3MtPm1hbnVhbF9zY2FuX2ZyZXFzKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkxpbWl0IG1hbnVhbCBzY2FuIHRvIHNwZWNpZmllZCBjaGFubmVscyIpOworCQlwYXJhbXMuZnJlcXMgPSB3cGFfcy0+bWFudWFsX3NjYW5fZnJlcXM7CisJCXdwYV9zLT5tYW51YWxfc2Nhbl9mcmVxcyA9IE5VTEw7CisJfQorCiAJaWYgKHBhcmFtcy5mcmVxcyA9PSBOVUxMICYmIHdwYV9zLT5uZXh0X3NjYW5fZnJlcXMpIHsKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiT3B0aW1pemUgc2NhbiBiYXNlZCBvbiBwcmV2aW91c2x5ICIKIAkJCSJnZW5lcmF0ZWQgZnJlcXVlbmN5IGxpc3QiKTsKQEAgLTgxMCw3ICs5MTMsNyBAQAogCX0KIAogI2lmZGVmIENPTkZJR19QMlAKLQlpZiAod3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcgfHwKKwlpZiAod3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcgfHwgd3BhX3MtPnAycF9pbl9pbnZpdGF0aW9uIHx8CiAJICAgICh3cGFfcy0+c2hvd19ncm91cF9zdGFydGVkICYmIHdwYV9zLT5nb19wYXJhbXMpKSB7CiAJCS8qCiAJCSAqIFRoZSBpbnRlcmZhY2UgbWF5IG5vdCB5ZXQgYmUgaW4gUDJQIG1vZGUsIHNvIHdlIGhhdmUgdG8KQEAgLTgzMyw3ICs5MzYsOCBAQAogCSAqIHN0YXRpb24gaW50ZXJmYWNlIHdoZW4gd2UgYXJlIG5vdCBjb25maWd1cmVkIHRvIHByZWZlciBzdGF0aW9uCiAJICogY29ubmVjdGlvbiBhbmQgYSBjb25jdXJyZW50IG9wZXJhdGlvbiBpcyBhbHJlYWR5IGluIHByb2Nlc3MuCiAJICovCi0JaWYgKHdwYV9zLT5zY2FuX2Zvcl9jb25uZWN0aW9uICYmIHNjYW5fcmVxID09IE5PUk1BTF9TQ0FOX1JFUSAmJgorCWlmICh3cGFfcy0+c2Nhbl9mb3JfY29ubmVjdGlvbiAmJgorCSAgICB3cGFfcy0+bGFzdF9zY2FuX3JlcSA9PSBOT1JNQUxfU0NBTl9SRVEgJiYKIAkgICAgIXNjYW5fcGFyYW1zLT5mcmVxcyAmJiAhcGFyYW1zLmZyZXFzICYmCiAJICAgIHdwYXNfaXNfcDJwX3ByaW9yaXRpemVkKHdwYV9zKSAmJgogCSAgICB3cGFfcy0+cDJwX2dyb3VwX2ludGVyZmFjZSA9PSBOT1RfUDJQX0dST1VQX0lOVEVSRkFDRSAmJgpAQCAtODU1LDYgKzk1OSwxMyBAQAogCiAJcmV0ID0gd3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHdwYV9zLCBzY2FuX3BhcmFtcyk7CiAKKwlpZiAocmV0ICYmIHdwYV9zLT5sYXN0X3NjYW5fcmVxID09IE1BTlVBTF9TQ0FOX1JFUSAmJiBwYXJhbXMuZnJlcXMgJiYKKwkgICAgIXdwYV9zLT5tYW51YWxfc2Nhbl9mcmVxcykgeworCQkvKiBSZXN0b3JlIG1hbnVhbF9zY2FuX2ZyZXFzIGZvciB0aGUgbmV4dCBhdHRlbXB0ICovCisJCXdwYV9zLT5tYW51YWxfc2Nhbl9mcmVxcyA9IHBhcmFtcy5mcmVxczsKKwkJcGFyYW1zLmZyZXFzID0gTlVMTDsKKwl9CisKIAl3cGFidWZfZnJlZShleHRyYV9pZSk7CiAJb3NfZnJlZShwYXJhbXMuZnJlcXMpOwogCW9zX2ZyZWUocGFyYW1zLmZpbHRlcl9zc2lkcyk7CkBAIC04NjQsNyArOTc1LDcgQEAKIAkJaWYgKHByZXZfc3RhdGUgIT0gd3BhX3MtPndwYV9zdGF0ZSkKIAkJCXdwYV9zdXBwbGljYW50X3NldF9zdGF0ZSh3cGFfcywgcHJldl9zdGF0ZSk7CiAJCS8qIFJlc3RvcmUgc2Nhbl9yZXEgc2luY2Ugd2Ugd2lsbCB0cnkgdG8gc2NhbiBhZ2FpbiAqLwotCQl3cGFfcy0+c2Nhbl9yZXEgPSBzY2FuX3JlcTsKKwkJd3BhX3MtPnNjYW5fcmVxID0gd3BhX3MtPmxhc3Rfc2Nhbl9yZXE7CiAJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAxLCAwKTsKIAl9IGVsc2UgewogCQl3cGFfcy0+c2Nhbl9mb3JfY29ubmVjdGlvbiA9IDA7CkBAIC04NzQsNyArOTg1LDcgQEAKIAogdm9pZCB3cGFfc3VwcGxpY2FudF91cGRhdGVfc2Nhbl9pbnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IHNlYykKIHsKLQlzdHJ1Y3Qgb3NfdGltZSByZW1haW5pbmcsIG5ld19pbnQ7CisJc3RydWN0IG9zX3JlbHRpbWUgcmVtYWluaW5nLCBuZXdfaW50OwogCWludCBjYW5jZWxsZWQ7CiAKIAljYW5jZWxsZWQgPSBlbG9vcF9jYW5jZWxfdGltZW91dF9vbmUod3BhX3N1cHBsaWNhbnRfc2Nhbiwgd3BhX3MsIE5VTEwsCkBAIC04ODIsMTMgKzk5MywxNSBAQAogCiAJbmV3X2ludC5zZWMgPSBzZWM7CiAJbmV3X2ludC51c2VjID0gMDsKLQlpZiAoY2FuY2VsbGVkICYmIG9zX3RpbWVfYmVmb3JlKCZyZW1haW5pbmcsICZuZXdfaW50KSkgeworCWlmIChjYW5jZWxsZWQgJiYgb3NfcmVsdGltZV9iZWZvcmUoJnJlbWFpbmluZywgJm5ld19pbnQpKSB7CiAJCW5ld19pbnQuc2VjID0gcmVtYWluaW5nLnNlYzsKIAkJbmV3X2ludC51c2VjID0gcmVtYWluaW5nLnVzZWM7CiAJfQogCi0JZWxvb3BfcmVnaXN0ZXJfdGltZW91dChuZXdfaW50LnNlYywgbmV3X2ludC51c2VjLCB3cGFfc3VwcGxpY2FudF9zY2FuLAotCQkJICAgICAgIHdwYV9zLCBOVUxMKTsKKwlpZiAoY2FuY2VsbGVkKSB7CisJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQobmV3X2ludC5zZWMsIG5ld19pbnQudXNlYywKKwkJCQkgICAgICAgd3BhX3N1cHBsaWNhbnRfc2Nhbiwgd3BhX3MsIE5VTEwpOworCX0KIAl3cGFfcy0+c2Nhbl9pbnRlcnZhbCA9IHNlYzsKIH0KIApAQCAtOTA0LDM0ICsxMDE3LDE5IEBACiAgKi8KIHZvaWQgd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IHNlYywgaW50IHVzZWMpCiB7Ci0jaWZuZGVmIEFORFJPSUQKLQkvKiBJZiB0aGVyZSdzIGF0IGxlYXN0IG9uZSBuZXR3b3JrIHRoYXQgc2hvdWxkIGJlIHNwZWNpZmljYWxseSBzY2FubmVkCi0JICogdGhlbiBkb24ndCBjYW5jZWwgdGhlIHNjYW4gYW5kIHJlc2NoZWR1bGUuICBTb21lIGRyaXZlcnMgZG8KLQkgKiBiYWNrZ3JvdW5kIHNjYW5uaW5nIHdoaWNoIGdlbmVyYXRlcyBmcmVxdWVudCBzY2FuIHJlc3VsdHMsIGFuZCB0aGF0Ci0JICogY2F1c2VzIHRoZSBzcGVjaWZpYyBTU0lEIHNjYW4gdG8gZ2V0IGNvbnRpbnVhbGx5IHB1c2hlZCBiYWNrIGFuZAotCSAqIG5ldmVyIGhhcHBlbiwgd2hpY2ggY2F1c2VzIGhpZGRlbiBBUHMgdG8gbmV2ZXIgZ2V0IHByb2JlLXNjYW5uZWQuCi0JICovCi0JaWYgKGVsb29wX2lzX3RpbWVvdXRfcmVnaXN0ZXJlZCh3cGFfc3VwcGxpY2FudF9zY2FuLCB3cGFfcywgTlVMTCkgJiYKLQkgICAgd3BhX3MtPmNvbmYtPmFwX3NjYW4gPT0gMSkgewotCQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKLQotCQl3aGlsZSAoc3NpZCkgewotCQkJaWYgKCF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIHNzaWQpICYmCi0JCQkgICAgc3NpZC0+c2Nhbl9zc2lkKQotCQkJCWJyZWFrOwotCQkJc3NpZCA9IHNzaWQtPm5leHQ7Ci0JCX0KLQkJaWYgKHNzaWQpIHsKLQkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIk5vdCByZXNjaGVkdWxpbmcgc2NhbiB0byAiCi0JCQkgICAgICAgICJlbnN1cmUgdGhhdCBzcGVjaWZpYyBTU0lEIHNjYW5zIG9jY3VyIik7Ci0JCQlyZXR1cm47Ci0JCX0KKwlpbnQgcmVzID0gZWxvb3BfZGVwbGV0ZV90aW1lb3V0KHNlYywgdXNlYywgd3BhX3N1cHBsaWNhbnRfc2Nhbiwgd3BhX3MsCisJCQkJCU5VTEwpOworCWlmIChyZXMgPT0gMSkgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJSZXNjaGVkdWxpbmcgc2NhbiByZXF1ZXN0OiAlZC4lMDZkIHNlYyIsCisJCQlzZWMsIHVzZWMpOworCX0gZWxzZSBpZiAocmVzID09IDApIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiSWdub3JlIG5ldyBzY2FuIHJlcXVlc3QgZm9yICVkLiUwNmQgc2VjIHNpbmNlIGFuIGVhcmxpZXIgcmVxdWVzdCBpcyBzY2hlZHVsZWQgdG8gdHJpZ2dlciBzb29uZXIiLAorCQkJc2VjLCB1c2VjKTsKKwl9IGVsc2UgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJTZXR0aW5nIHNjYW4gcmVxdWVzdDogJWQuJTA2ZCBzZWMiLAorCQkJc2VjLCB1c2VjKTsKKwkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChzZWMsIHVzZWMsIHdwYV9zdXBwbGljYW50X3NjYW4sIHdwYV9zLCBOVUxMKTsKIAl9Ci0jZW5kaWYKLQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJTZXR0aW5nIHNjYW4gcmVxdWVzdDogJWQgc2VjICVkIHVzZWMiLAotCQlzZWMsIHVzZWMpOwotCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYV9zdXBwbGljYW50X3NjYW4sIHdwYV9zLCBOVUxMKTsKLQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KHNlYywgdXNlYywgd3BhX3N1cHBsaWNhbnRfc2Nhbiwgd3BhX3MsIE5VTEwpOwogfQogCiAKQEAgLTExNDMsNiArMTI0MSw5IEBACiAJCXBhcmFtcy5leHRyYV9pZXNfbGVuID0gd3BhYnVmX2xlbihleHRyYV9pZSk7CiAJfQogCisJaWYgKHdwYV9zLT5jb25mLT5maWx0ZXJfcnNzaSkKKwkJcGFyYW1zLmZpbHRlcl9yc3NpID0gd3BhX3MtPmNvbmYtPmZpbHRlcl9yc3NpOworCiAJc2Nhbl9wYXJhbXMgPSAmcGFyYW1zOwogCiBzY2FuOgpAQCAtMTIwMywxMCArMTMwNCw2IEBACiB7CiAJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQ2FuY2VsbGluZyBzY2FuIHJlcXVlc3QiKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFfc3VwcGxpY2FudF9zY2FuLCB3cGFfcywgTlVMTCk7Ci0Jd3Bhc19wMnBfY29udGludWVfYWZ0ZXJfc2Nhbih3cGFfcyk7Ci0jaWZkZWYgQU5EUk9JRAotCXdwYV9zdXBwbGljYW50X25vdGlmeV9zY2FubmluZyh3cGFfcywgMCk7Ci0jZW5kaWYKIH0KIAogCkBAIC0xMzQ1LDYgKzE0NDIsNDMgQEAKIAogCiAvKioKKyAqIHdwYV9zY2FuX2dldF92ZW5kb3JfaWVfYmVhY29uIC0gRmV0Y2ggdmVuZG9yIGluZm9ybWF0aW9uIGZyb20gYSBzY2FuIHJlc3VsdAorICogQHJlczogU2NhbiByZXN1bHQgZW50cnkKKyAqIEB2ZW5kb3JfdHlwZTogVmVuZG9yIHR5cGUgKGZvdXIgb2N0ZXRzIHN0YXJ0aW5nIHRoZSBJRSBwYXlsb2FkKQorICogUmV0dXJuczogUG9pbnRlciB0byB0aGUgaW5mb3JtYXRpb24gZWxlbWVudCAoaWQgZmllbGQpIG9yICVOVUxMIGlmIG5vdCBmb3VuZAorICoKKyAqIFRoaXMgZnVuY3Rpb24gcmV0dXJucyB0aGUgZmlyc3QgbWF0Y2hpbmcgaW5mb3JtYXRpb24gZWxlbWVudCBpbiB0aGUgc2NhbgorICogcmVzdWx0LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgbGlrZSB3cGFfc2Nhbl9nZXRfdmVuZG9yX2llKCksIGJ1dCB1c2VzIElFIGJ1ZmZlciBvbmx5CisgKiBmcm9tIEJlYWNvbiBmcmFtZXMgaW5zdGVhZCBvZiBlaXRoZXIgQmVhY29uIG9yIFByb2JlIFJlc3BvbnNlIGZyYW1lcy4KKyAqLworY29uc3QgdTggKiB3cGFfc2Nhbl9nZXRfdmVuZG9yX2llX2JlYWNvbihjb25zdCBzdHJ1Y3Qgd3BhX3NjYW5fcmVzICpyZXMsCisJCQkJCSB1MzIgdmVuZG9yX3R5cGUpCit7CisJY29uc3QgdTggKmVuZCwgKnBvczsKKworCWlmIChyZXMtPmJlYWNvbl9pZV9sZW4gPT0gMCkKKwkJcmV0dXJuIE5VTEw7CisKKwlwb3MgPSAoY29uc3QgdTggKikgKHJlcyArIDEpOworCXBvcyArPSByZXMtPmllX2xlbjsKKwllbmQgPSBwb3MgKyByZXMtPmJlYWNvbl9pZV9sZW47CisKKwl3aGlsZSAocG9zICsgMSA8IGVuZCkgeworCQlpZiAocG9zICsgMiArIHBvc1sxXSA+IGVuZCkKKwkJCWJyZWFrOworCQlpZiAocG9zWzBdID09IFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQyAmJiBwb3NbMV0gPj0gNCAmJgorCQkgICAgdmVuZG9yX3R5cGUgPT0gV1BBX0dFVF9CRTMyKCZwb3NbMl0pKQorCQkJcmV0dXJuIHBvczsKKwkJcG9zICs9IDIgKyBwb3NbMV07CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKKworLyoqCiAgKiB3cGFfc2Nhbl9nZXRfdmVuZG9yX2llX211bHRpIC0gRmV0Y2ggdmVuZG9yIElFIGRhdGEgZnJvbSBhIHNjYW4gcmVzdWx0CiAgKiBAcmVzOiBTY2FuIHJlc3VsdCBlbnRyeQogICogQHZlbmRvcl90eXBlOiBWZW5kb3IgdHlwZSAoZm91ciBvY3RldHMgc3RhcnRpbmcgdGhlIElFIHBheWxvYWQpCkBAIC0xNjMyLDEyICsxNzY2LDEyIEBACiAJCSAqIE1ha2Ugc3VyZSB3ZSBoYXZlIGEgdmFsaWQgdGltZXN0YW1wIGlmIHRoZSBkcml2ZXIgd3JhcHBlcgogCQkgKiBkb2VzIG5vdCBzZXQgdGhpcy4KIAkJICovCi0JCW9zX2dldF90aW1lKCZzY2FuX3Jlcy0+ZmV0Y2hfdGltZSk7CisJCW9zX2dldF9yZWx0aW1lKCZzY2FuX3Jlcy0+ZmV0Y2hfdGltZSk7CiAJfQogCWZpbHRlcl9zY2FuX3Jlcyh3cGFfcywgc2Nhbl9yZXMpOwogCiAjaWZkZWYgQ09ORklHX1dQUwotCWlmICh3cGFzX3dwc19pbl9wcm9ncmVzcyh3cGFfcykpIHsKKwlpZiAod3Bhc193cHNfc2VhcmNoaW5nKHdwYV9zKSkgewogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJXUFM6IE9yZGVyIHNjYW4gcmVzdWx0cyB3aXRoIFdQUyAiCiAJCQkicHJvdmlzaW9uaW5nIHJ1bGVzIik7CiAJCWNvbXBhciA9IHdwYV9zY2FuX3Jlc3VsdF93cHNfY29tcGFyOwpAQCAtMTY4OSw5ICsxODIzLDIxIEBACiAJCSAgICAgICBzdHJ1Y3Qgd3BhX3NjYW5fcmVzdWx0cyAqc2Nhbl9yZXMpCiB7CiAJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiU2Nhbi1vbmx5IHJlc3VsdHMgcmVjZWl2ZWQiKTsKLQl3cGFfbXNnX2N0cmwod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfU0NBTl9SRVNVTFRTKTsKKwlpZiAod3BhX3MtPmxhc3Rfc2Nhbl9yZXEgPT0gTUFOVUFMX1NDQU5fUkVRICYmCisJICAgIHdwYV9zLT5tYW51YWxfc2Nhbl91c2VfaWQgJiYgd3BhX3MtPm93bl9zY2FuX3J1bm5pbmcpIHsKKwkJd3BhX21zZ19jdHJsKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX1NDQU5fUkVTVUxUUyAiaWQ9JXUiLAorCQkJICAgICB3cGFfcy0+bWFudWFsX3NjYW5faWQpOworCQl3cGFfcy0+bWFudWFsX3NjYW5fdXNlX2lkID0gMDsKKwl9IGVsc2UgeworCQl3cGFfbXNnX2N0cmwod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfU0NBTl9SRVNVTFRTKTsKKwl9CiAJd3Bhc19ub3RpZnlfc2Nhbl9yZXN1bHRzKHdwYV9zKTsKIAl3cGFzX25vdGlmeV9zY2FuX2RvbmUod3BhX3MsIDEpOworCWlmICh3cGFfcy0+c2Nhbl93b3JrKSB7CisJCXN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yayA9IHdwYV9zLT5zY2FuX3dvcms7CisJCXdwYV9zLT5zY2FuX3dvcmsgPSBOVUxMOworCQlyYWRpb193b3JrX2RvbmUod29yayk7CisJfQogfQogCiAKQEAgLTE2OTksMyArMTg0NSwyMTMgQEAKIHsKIAlyZXR1cm4gZWxvb3BfaXNfdGltZW91dF9yZWdpc3RlcmVkKHdwYV9zdXBwbGljYW50X3NjYW4sIHdwYV9zLCBOVUxMKTsKIH0KKworCitzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqCit3cGFfc2Nhbl9jbG9uZV9wYXJhbXMoY29uc3Qgc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgKnNyYykKK3sKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqcGFyYW1zOworCXNpemVfdCBpOworCXU4ICpuOworCisJcGFyYW1zID0gb3NfemFsbG9jKHNpemVvZigqcGFyYW1zKSk7CisJaWYgKHBhcmFtcyA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWZvciAoaSA9IDA7IGkgPCBzcmMtPm51bV9zc2lkczsgaSsrKSB7CisJCWlmIChzcmMtPnNzaWRzW2ldLnNzaWQpIHsKKwkJCW4gPSBvc19tYWxsb2Moc3JjLT5zc2lkc1tpXS5zc2lkX2xlbik7CisJCQlpZiAobiA9PSBOVUxMKQorCQkJCWdvdG8gZmFpbGVkOworCQkJb3NfbWVtY3B5KG4sIHNyYy0+c3NpZHNbaV0uc3NpZCwKKwkJCQkgIHNyYy0+c3NpZHNbaV0uc3NpZF9sZW4pOworCQkJcGFyYW1zLT5zc2lkc1tpXS5zc2lkID0gbjsKKwkJCXBhcmFtcy0+c3NpZHNbaV0uc3NpZF9sZW4gPSBzcmMtPnNzaWRzW2ldLnNzaWRfbGVuOworCQl9CisJfQorCXBhcmFtcy0+bnVtX3NzaWRzID0gc3JjLT5udW1fc3NpZHM7CisKKwlpZiAoc3JjLT5leHRyYV9pZXMpIHsKKwkJbiA9IG9zX21hbGxvYyhzcmMtPmV4dHJhX2llc19sZW4pOworCQlpZiAobiA9PSBOVUxMKQorCQkJZ290byBmYWlsZWQ7CisJCW9zX21lbWNweShuLCBzcmMtPmV4dHJhX2llcywgc3JjLT5leHRyYV9pZXNfbGVuKTsKKwkJcGFyYW1zLT5leHRyYV9pZXMgPSBuOworCQlwYXJhbXMtPmV4dHJhX2llc19sZW4gPSBzcmMtPmV4dHJhX2llc19sZW47CisJfQorCisJaWYgKHNyYy0+ZnJlcXMpIHsKKwkJaW50IGxlbiA9IGludF9hcnJheV9sZW4oc3JjLT5mcmVxcyk7CisJCXBhcmFtcy0+ZnJlcXMgPSBvc19tYWxsb2MoKGxlbiArIDEpICogc2l6ZW9mKGludCkpOworCQlpZiAocGFyYW1zLT5mcmVxcyA9PSBOVUxMKQorCQkJZ290byBmYWlsZWQ7CisJCW9zX21lbWNweShwYXJhbXMtPmZyZXFzLCBzcmMtPmZyZXFzLCAobGVuICsgMSkgKiBzaXplb2YoaW50KSk7CisJfQorCisJaWYgKHNyYy0+ZmlsdGVyX3NzaWRzKSB7CisJCXBhcmFtcy0+ZmlsdGVyX3NzaWRzID0gb3NfbWFsbG9jKHNpemVvZigqcGFyYW1zLT5maWx0ZXJfc3NpZHMpICoKKwkJCQkJCSBzcmMtPm51bV9maWx0ZXJfc3NpZHMpOworCQlpZiAocGFyYW1zLT5maWx0ZXJfc3NpZHMgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbGVkOworCQlvc19tZW1jcHkocGFyYW1zLT5maWx0ZXJfc3NpZHMsIHNyYy0+ZmlsdGVyX3NzaWRzLAorCQkJICBzaXplb2YoKnBhcmFtcy0+ZmlsdGVyX3NzaWRzKSAqCisJCQkgIHNyYy0+bnVtX2ZpbHRlcl9zc2lkcyk7CisJCXBhcmFtcy0+bnVtX2ZpbHRlcl9zc2lkcyA9IHNyYy0+bnVtX2ZpbHRlcl9zc2lkczsKKwl9CisKKwlwYXJhbXMtPmZpbHRlcl9yc3NpID0gc3JjLT5maWx0ZXJfcnNzaTsKKwlwYXJhbXMtPnAycF9wcm9iZSA9IHNyYy0+cDJwX3Byb2JlOworCXBhcmFtcy0+b25seV9uZXdfcmVzdWx0cyA9IHNyYy0+b25seV9uZXdfcmVzdWx0czsKKwlwYXJhbXMtPmxvd19wcmlvcml0eSA9IHNyYy0+bG93X3ByaW9yaXR5OworCisJcmV0dXJuIHBhcmFtczsKKworZmFpbGVkOgorCXdwYV9zY2FuX2ZyZWVfcGFyYW1zKHBhcmFtcyk7CisJcmV0dXJuIE5VTEw7Cit9CisKKwordm9pZCB3cGFfc2Nhbl9mcmVlX3BhcmFtcyhzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqcGFyYW1zKQoreworCXNpemVfdCBpOworCisJaWYgKHBhcmFtcyA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlmb3IgKGkgPSAwOyBpIDwgcGFyYW1zLT5udW1fc3NpZHM7IGkrKykKKwkJb3NfZnJlZSgodTggKikgcGFyYW1zLT5zc2lkc1tpXS5zc2lkKTsKKwlvc19mcmVlKCh1OCAqKSBwYXJhbXMtPmV4dHJhX2llcyk7CisJb3NfZnJlZShwYXJhbXMtPmZyZXFzKTsKKwlvc19mcmVlKHBhcmFtcy0+ZmlsdGVyX3NzaWRzKTsKKwlvc19mcmVlKHBhcmFtcyk7Cit9CisKKworaW50IHdwYXNfc3RhcnRfcG5vKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJaW50IHJldCwgaW50ZXJ2YWw7CisJc2l6ZV90IGksIG51bV9zc2lkLCBudW1fbWF0Y2hfc3NpZDsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CisJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgcGFyYW1zOworCisJaWYgKCF3cGFfcy0+c2NoZWRfc2Nhbl9zdXBwb3J0ZWQpCisJCXJldHVybiAtMTsKKworCWlmICh3cGFfcy0+cG5vIHx8IHdwYV9zLT5wbm9fc2NoZWRfcGVuZGluZykKKwkJcmV0dXJuIDA7CisKKwlpZiAoKHdwYV9zLT53cGFfc3RhdGUgPiBXUEFfU0NBTk5JTkcpICYmCisJICAgICh3cGFfcy0+d3BhX3N0YXRlIDw9IFdQQV9DT01QTEVURUQpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUE5POiBJbiBhc3NvYyBwcm9jZXNzIik7CisJCXJldHVybiAtRUFHQUlOOworCX0KKworCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9TQ0FOTklORykgeworCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2Nhbih3cGFfcyk7CisJCWlmICh3cGFfcy0+c2NoZWRfc2Nhbm5pbmcpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU2NoZWR1bGUgUE5PIG9uIGNvbXBsZXRpb24gb2YgIgorCQkJCSAgICJvbmdvaW5nIHNjaGVkIHNjYW4iKTsKKwkJCXdwYV9zdXBwbGljYW50X2NhbmNlbF9zY2hlZF9zY2FuKHdwYV9zKTsKKwkJCXdwYV9zLT5wbm9fc2NoZWRfcGVuZGluZyA9IDE7CisJCQlyZXR1cm4gMDsKKwkJfQorCX0KKworCW9zX21lbXNldCgmcGFyYW1zLCAwLCBzaXplb2YocGFyYW1zKSk7CisKKwludW1fc3NpZCA9IG51bV9tYXRjaF9zc2lkID0gMDsKKwlzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7CisJd2hpbGUgKHNzaWQpIHsKKwkJaWYgKCF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIHNzaWQpKSB7CisJCQludW1fbWF0Y2hfc3NpZCsrOworCQkJaWYgKHNzaWQtPnNjYW5fc3NpZCkKKwkJCQludW1fc3NpZCsrOworCQl9CisJCXNzaWQgPSBzc2lkLT5uZXh0OworCX0KKworCWlmIChudW1fbWF0Y2hfc3NpZCA9PSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUE5POiBObyBjb25maWd1cmVkIFNTSURzIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAobnVtX21hdGNoX3NzaWQgPiBudW1fc3NpZCkgeworCQlwYXJhbXMubnVtX3NzaWRzKys7IC8qIHdpbGRjYXJkICovCisJCW51bV9zc2lkKys7CisJfQorCisJaWYgKG51bV9zc2lkID4gV1BBU19NQVhfU0NBTl9TU0lEUykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlBOTzogVXNlIG9ubHkgdGhlIGZpcnN0ICV1IFNTSURzIGZyb20gIgorCQkJICAgIiV1IiwgV1BBU19NQVhfU0NBTl9TU0lEUywgKHVuc2lnbmVkIGludCkgbnVtX3NzaWQpOworCQludW1fc3NpZCA9IFdQQVNfTUFYX1NDQU5fU1NJRFM7CisJfQorCisJaWYgKG51bV9tYXRjaF9zc2lkID4gd3BhX3MtPm1heF9tYXRjaF9zZXRzKSB7CisJCW51bV9tYXRjaF9zc2lkID0gd3BhX3MtPm1heF9tYXRjaF9zZXRzOworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQTk86IFRvbyBtYW55IFNTSURzIHRvIG1hdGNoIik7CisJfQorCXBhcmFtcy5maWx0ZXJfc3NpZHMgPSBvc19jYWxsb2MobnVtX21hdGNoX3NzaWQsCisJCQkJCXNpemVvZihzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX2ZpbHRlcikpOworCWlmIChwYXJhbXMuZmlsdGVyX3NzaWRzID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlpID0gMDsKKwlzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7CisJd2hpbGUgKHNzaWQpIHsKKwkJaWYgKCF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIHNzaWQpKSB7CisJCQlpZiAoc3NpZC0+c2Nhbl9zc2lkICYmIHBhcmFtcy5udW1fc3NpZHMgPCBudW1fc3NpZCkgeworCQkJCXBhcmFtcy5zc2lkc1twYXJhbXMubnVtX3NzaWRzXS5zc2lkID0KKwkJCQkJc3NpZC0+c3NpZDsKKwkJCQlwYXJhbXMuc3NpZHNbcGFyYW1zLm51bV9zc2lkc10uc3NpZF9sZW4gPQorCQkJCQkgc3NpZC0+c3NpZF9sZW47CisJCQkJcGFyYW1zLm51bV9zc2lkcysrOworCQkJfQorCQkJb3NfbWVtY3B5KHBhcmFtcy5maWx0ZXJfc3NpZHNbaV0uc3NpZCwgc3NpZC0+c3NpZCwKKwkJCQkgIHNzaWQtPnNzaWRfbGVuKTsKKwkJCXBhcmFtcy5maWx0ZXJfc3NpZHNbaV0uc3NpZF9sZW4gPSBzc2lkLT5zc2lkX2xlbjsKKwkJCXBhcmFtcy5udW1fZmlsdGVyX3NzaWRzKys7CisJCQlpKys7CisJCQlpZiAoaSA9PSBudW1fbWF0Y2hfc3NpZCkKKwkJCQlicmVhazsKKwkJfQorCQlzc2lkID0gc3NpZC0+bmV4dDsKKwl9CisKKwlpZiAod3BhX3MtPmNvbmYtPmZpbHRlcl9yc3NpKQorCQlwYXJhbXMuZmlsdGVyX3Jzc2kgPSB3cGFfcy0+Y29uZi0+ZmlsdGVyX3Jzc2k7CisKKwlpbnRlcnZhbCA9IHdwYV9zLT5jb25mLT5zY2hlZF9zY2FuX2ludGVydmFsID8KKwkJd3BhX3MtPmNvbmYtPnNjaGVkX3NjYW5faW50ZXJ2YWwgOiAxMDsKKworCWlmIChwYXJhbXMuZnJlcXMgPT0gTlVMTCAmJiB3cGFfcy0+bWFudWFsX3NjaGVkX3NjYW5fZnJlcXMpIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiTGltaXQgc2NoZWQgc2NhbiB0byBzcGVjaWZpZWQgY2hhbm5lbHMiKTsKKwkJcGFyYW1zLmZyZXFzID0gd3BhX3MtPm1hbnVhbF9zY2hlZF9zY2FuX2ZyZXFzOworCX0KKworCXJldCA9IHdwYV9zdXBwbGljYW50X3N0YXJ0X3NjaGVkX3NjYW4od3BhX3MsICZwYXJhbXMsIGludGVydmFsKTsKKwlvc19mcmVlKHBhcmFtcy5maWx0ZXJfc3NpZHMpOworCWlmIChyZXQgPT0gMCkKKwkJd3BhX3MtPnBubyA9IDE7CisJZWxzZQorCQl3cGFfbXNnKHdwYV9zLCBNU0dfRVJST1IsICJGYWlsZWQgdG8gc2NoZWR1bGUgUE5PIik7CisJcmV0dXJuIHJldDsKK30KKworCitpbnQgd3Bhc19zdG9wX3BubyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWludCByZXQgPSAwOworCisJaWYgKCF3cGFfcy0+cG5vKQorCQlyZXR1cm4gMDsKKworCXJldCA9IHdwYV9zdXBwbGljYW50X3N0b3Bfc2NoZWRfc2Nhbih3cGFfcyk7CisKKwl3cGFfcy0+cG5vID0gMDsKKwl3cGFfcy0+cG5vX3NjaGVkX3BlbmRpbmcgPSAwOworCisJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX1NDQU5OSU5HKQorCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7CisKKwlyZXR1cm4gcmV0OworfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvc2Nhbi5oIGIvd3BhX3N1cHBsaWNhbnQvc2Nhbi5oCmluZGV4IDIxNDQ3ODcuLjk0NmQyYjMgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3NjYW4uaAorKysgYi93cGFfc3VwcGxpY2FudC9zY2FuLmgKQEAgLTEsNiArMSw2IEBACiAvKgogICogV1BBIFN1cHBsaWNhbnQgLSBTY2FubmluZwotICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTAsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMjksNiArMjksOCBAQAogY29uc3QgdTggKiB3cGFfc2Nhbl9nZXRfaWUoY29uc3Qgc3RydWN0IHdwYV9zY2FuX3JlcyAqcmVzLCB1OCBpZSk7CiBjb25zdCB1OCAqIHdwYV9zY2FuX2dldF92ZW5kb3JfaWUoY29uc3Qgc3RydWN0IHdwYV9zY2FuX3JlcyAqcmVzLAogCQkJCSAgdTMyIHZlbmRvcl90eXBlKTsKK2NvbnN0IHU4ICogd3BhX3NjYW5fZ2V0X3ZlbmRvcl9pZV9iZWFjb24oY29uc3Qgc3RydWN0IHdwYV9zY2FuX3JlcyAqcmVzLAorCQkJCQkgdTMyIHZlbmRvcl90eXBlKTsKIHN0cnVjdCB3cGFidWYgKiB3cGFfc2Nhbl9nZXRfdmVuZG9yX2llX211bHRpKGNvbnN0IHN0cnVjdCB3cGFfc2Nhbl9yZXMgKnJlcywKIAkJCQkJICAgICB1MzIgdmVuZG9yX3R5cGUpOwogaW50IHdwYV9zdXBwbGljYW50X2ZpbHRlcl9ic3NpZF9tYXRjaChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLApAQCAtMzcsNSArMzksMTQgQEAKIHZvaWQgc2Nhbl9vbmx5X2hhbmRsZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJICAgICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3Jlcyk7CiBpbnQgd3Bhc19zY2FuX3NjaGVkdWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK2ludCB3cGFfc3VwcGxpY2FudF9zdGFydF9zY2hlZF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgIHN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpwYXJhbXMsCisJCQkJICAgIGludCBpbnRlcnZhbCk7CitpbnQgd3BhX3N1cHBsaWNhbnRfc3RvcF9zY2hlZF9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgKgord3BhX3NjYW5fY2xvbmVfcGFyYW1zKGNvbnN0IHN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpzcmMpOwordm9pZCB3cGFfc2Nhbl9mcmVlX3BhcmFtcyhzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqcGFyYW1zKTsKK2ludCB3cGFzX3N0YXJ0X3BubyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK2ludCB3cGFzX3N0b3BfcG5vKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogCiAjZW5kaWYgLyogU0NBTl9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9zbWUuYyBiL3dwYV9zdXBwbGljYW50L3NtZS5jCmluZGV4IDkyNWQxMzIuLjUxODhiOWYgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3NtZS5jCisrKyBiL3dwYV9zdXBwbGljYW50L3NtZS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIHdwYV9zdXBwbGljYW50IC0gU01FCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDktMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwOS0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC00Niw3ICs0Niw3IEBACiB7CiAJaW50IGk7CiAJZm9yIChpID0gMDsgaSA8IGlkeDsgaSsrKSB7Ci0JCWlmIChhcnJheVtpXSA9PSAtMSkKKwkJaWYgKGFycmF5W2ldIDw9IDApCiAJCQlyZXR1cm4gMDsKIAl9CiAJcmV0dXJuIDE7CkBAIC01Niw5ICs1Niw5IEBACiBzdGF0aWMgaW50IHNtZV9zZXRfc2FlX2dyb3VwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJaW50ICpncm91cHMgPSB3cGFfcy0+Y29uZi0+c2FlX2dyb3VwczsKLQlpbnQgZGVmYXVsdF9ncm91cHNbXSA9IHsgMTksIDIwLCAyMSwgMjUsIDI2IH07CisJaW50IGRlZmF1bHRfZ3JvdXBzW10gPSB7IDE5LCAyMCwgMjEsIDI1LCAyNiwgMCB9OwogCi0JaWYgKCFncm91cHMpCisJaWYgKCFncm91cHMgfHwgZ3JvdXBzWzBdIDw9IDApCiAJCWdyb3VwcyA9IGRlZmF1bHRfZ3JvdXBzOwogCiAJLyogQ29uZmlndXJhdGlvbiBtYXkgaGF2ZSBjaGFuZ2VkLCBzbyB2YWxpZGF0ZSBjdXJyZW50IGluZGV4ICovCkBAIC0xNTEsMTIgKzE1MSwxMyBAQAogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiAJaW50IGksIGJzc2lkX2NoYW5nZWQ7CiAJc3RydWN0IHdwYWJ1ZiAqcmVzcCA9IE5VTEw7Ci0JdTggZXh0X2NhcGFiWzEwXTsKKwl1OCBleHRfY2FwYWJbMThdOwogCWludCBleHRfY2FwYWJfbGVuOwogCiAJaWYgKGJzcyA9PSBOVUxMKSB7CiAJCXdwYV9tc2cod3BhX3MsIE1TR19FUlJPUiwgIlNNRTogTm8gc2NhbiByZXN1bHQgYXZhaWxhYmxlIGZvciAiCiAJCQkidGhlIG5ldHdvcmsiKTsKKwkJd3Bhc19jb25uZWN0X3dvcmtfZG9uZSh3cGFfcyk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTI0NCw2ICsyNDUsNyBAQAogCQkJCQkgICAgICAmd3BhX3MtPnNtZS5hc3NvY19yZXFfaWVfbGVuKSkgewogCQkJd3BhX21zZyh3cGFfcywgTVNHX1dBUk5JTkcsICJTTUU6IEZhaWxlZCB0byBzZXQgV1BBICIKIAkJCQkia2V5IG1hbmFnZW1lbnQgYW5kIGVuY3J5cHRpb24gc3VpdGVzIik7CisJCQl3cGFzX2Nvbm5lY3Rfd29ya19kb25lKHdwYV9zKTsKIAkJCXJldHVybjsKIAkJfQogCX0gZWxzZSBpZiAoKHNzaWQtPmtleV9tZ210ICYgV1BBX0tFWV9NR01UX0lFRUU4MDIxWF9OT19XUEEpICYmCkBAIC0yNjMsNiArMjY1LDcgQEAKIAkJCXdwYV9tc2cod3BhX3MsIE1TR19XQVJOSU5HLCAiU01FOiBGYWlsZWQgdG8gc2V0IFdQQSAiCiAJCQkJImtleSBtYW5hZ2VtZW50IGFuZCBlbmNyeXB0aW9uIHN1aXRlcyAobm8gIgogCQkJCSJzY2FuIHJlc3VsdHMpIik7CisJCQl3cGFzX2Nvbm5lY3Rfd29ya19kb25lKHdwYV9zKTsKIAkJCXJldHVybjsKIAkJfQogI2lmZGVmIENPTkZJR19XUFMKQEAgLTM1NywxNyArMzYwLDI1IEBACiAJCXN0cnVjdCB3cGFidWYgKmhzMjA7CiAJCWhzMjAgPSB3cGFidWZfYWxsb2MoMjApOwogCQlpZiAoaHMyMCkgewotCQkJd3Bhc19oczIwX2FkZF9pbmRpY2F0aW9uKGhzMjApOwotCQkJb3NfbWVtY3B5KHdwYV9zLT5zbWUuYXNzb2NfcmVxX2llICsKLQkJCQkgIHdwYV9zLT5zbWUuYXNzb2NfcmVxX2llX2xlbiwKLQkJCQkgIHdwYWJ1Zl9oZWFkKGhzMjApLCB3cGFidWZfbGVuKGhzMjApKTsKLQkJCXdwYV9zLT5zbWUuYXNzb2NfcmVxX2llX2xlbiArPSB3cGFidWZfbGVuKGhzMjApOworCQkJaW50IHBwc19tb19pZCA9IGhzMjBfZ2V0X3Bwc19tb19pZCh3cGFfcywgc3NpZCk7CisJCQlzaXplX3QgbGVuOworCisJCQl3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oaHMyMCwgcHBzX21vX2lkKTsKKwkJCWxlbiA9IHNpemVvZih3cGFfcy0+c21lLmFzc29jX3JlcV9pZSkgLQorCQkJCXdwYV9zLT5zbWUuYXNzb2NfcmVxX2llX2xlbjsKKwkJCWlmICh3cGFidWZfbGVuKGhzMjApIDw9IGxlbikgeworCQkJCW9zX21lbWNweSh3cGFfcy0+c21lLmFzc29jX3JlcV9pZSArCisJCQkJCSAgd3BhX3MtPnNtZS5hc3NvY19yZXFfaWVfbGVuLAorCQkJCQkgIHdwYWJ1Zl9oZWFkKGhzMjApLCB3cGFidWZfbGVuKGhzMjApKTsKKwkJCQl3cGFfcy0+c21lLmFzc29jX3JlcV9pZV9sZW4gKz0gd3BhYnVmX2xlbihoczIwKTsKKwkJCX0KIAkJCXdwYWJ1Zl9mcmVlKGhzMjApOwogCQl9CiAJfQogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKLQlleHRfY2FwYWJfbGVuID0gd3Bhc19idWlsZF9leHRfY2FwYWIod3BhX3MsIGV4dF9jYXBhYik7CisJZXh0X2NhcGFiX2xlbiA9IHdwYXNfYnVpbGRfZXh0X2NhcGFiKHdwYV9zLCBleHRfY2FwYWIsCisJCQkJCSAgICAgc2l6ZW9mKGV4dF9jYXBhYikpOwogCWlmIChleHRfY2FwYWJfbGVuID4gMCkgewogCQl1OCAqcG9zID0gd3BhX3MtPnNtZS5hc3NvY19yZXFfaWU7CiAJCWlmICh3cGFfcy0+c21lLmFzc29jX3JlcV9pZV9sZW4gPiAwICYmIHBvc1swXSA9PSBXTEFOX0VJRF9SU04pCkBAIC0zODYsOCArMzk3LDEwIEBACiAJCQkJCQkJIGJzcy0+YnNzaWQpOwogCQllbHNlCiAJCQlyZXNwID0gc21lX2F1dGhfYnVpbGRfc2FlX2NvbmZpcm0od3BhX3MpOwotCQlpZiAocmVzcCA9PSBOVUxMKQorCQlpZiAocmVzcCA9PSBOVUxMKSB7CisJCQl3cGFzX2Nvbm5lY3Rfd29ya19kb25lKHdwYV9zKTsKIAkJCXJldHVybjsKKwkJfQogCQlwYXJhbXMuc2FlX2RhdGEgPSB3cGFidWZfaGVhZChyZXNwKTsKIAkJcGFyYW1zLnNhZV9kYXRhX2xlbiA9IHdwYWJ1Zl9sZW4ocmVzcCk7CiAJCXdwYV9zLT5zbWUuc2FlLnN0YXRlID0gc3RhcnQgPyBTQUVfQ09NTUlUVEVEIDogU0FFX0NPTkZJUk1FRDsKQEAgLTQxMCw2ICs0MjMsMzIgQEAKIAlpZiAob2xkX3NzaWQgIT0gd3BhX3MtPmN1cnJlbnRfc3NpZCkKIAkJd3Bhc19ub3RpZnlfbmV0d29ya19jaGFuZ2VkKHdwYV9zKTsKIAorI2lmZGVmIENPTkZJR19QMlAKKwkvKgorCSAqIElmIG11bHRpLWNoYW5uZWwgY29uY3VycmVuY3kgaXMgbm90IHN1cHBvcnRlZCwgY2hlY2sgZm9yIGFueQorCSAqIGZyZXF1ZW5jeSBjb25mbGljdC4gSW4gY2FzZSBvZiBhbnkgZnJlcXVlbmN5IGNvbmZsaWN0LCByZW1vdmUgdGhlCisJICogbGVhc3QgcHJpb3JpdGl6ZWQgY29ubmVjdGlvbi4KKwkgKi8KKwlpZiAod3BhX3MtPm51bV9tdWx0aWNoYW5fY29uY3VycmVudCA8IDIpIHsKKwkJaW50IGZyZXEsIG51bTsKKwkJbnVtID0gZ2V0X3NoYXJlZF9yYWRpb19mcmVxcyh3cGFfcywgJmZyZXEsIDEpOworCQlpZiAobnVtID4gMCAmJiBmcmVxID4gMCAmJiBmcmVxICE9IHBhcmFtcy5mcmVxKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCQkgICAiQ29uZmxpY3RpbmcgZnJlcXVlbmN5IGZvdW5kICglZCAhPSAlZCkiLAorCQkJCSAgIGZyZXEsIHBhcmFtcy5mcmVxKTsKKwkJCWlmICh3cGFzX3AycF9oYW5kbGVfZnJlcXVlbmN5X2NvbmZsaWN0cyh3cGFfcywKKwkJCQkJCQkJcGFyYW1zLmZyZXEsCisJCQkJCQkJCXNzaWQpIDwgMCkgeworCQkJCXdwYXNfY29ubmVjdGlvbl9mYWlsZWQod3BhX3MsIGJzcy0+YnNzaWQpOworCQkJCXdwYV9zdXBwbGljYW50X21hcmtfZGlzYXNzb2Mod3BhX3MpOworCQkJCXdwYWJ1Zl9mcmVlKHJlc3ApOworCQkJCXdwYXNfY29ubmVjdF93b3JrX2RvbmUod3BhX3MpOworCQkJCXJldHVybjsKKwkJCX0KKwkJfQorCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKIAl3cGFfcy0+c21lLmF1dGhfYWxnID0gcGFyYW1zLmF1dGhfYWxnOwogCWlmICh3cGFfZHJ2X2F1dGhlbnRpY2F0ZSh3cGFfcywgJnBhcmFtcykgPCAwKSB7CiAJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiU01FOiBBdXRoZW50aWNhdGlvbiByZXF1ZXN0IHRvIHRoZSAiCkBAIC00MTcsNiArNDU2LDcgQEAKIAkJd3Bhc19jb25uZWN0aW9uX2ZhaWxlZCh3cGFfcywgYnNzLT5ic3NpZCk7CiAJCXdwYV9zdXBwbGljYW50X21hcmtfZGlzYXNzb2Mod3BhX3MpOwogCQl3cGFidWZfZnJlZShyZXNwKTsKKwkJd3Bhc19jb25uZWN0X3dvcmtfZG9uZSh3cGFfcyk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTQzMiwxNCArNDcyLDcwIEBACiB9CiAKIAorc3RhdGljIHZvaWQgc21lX2F1dGhfc3RhcnRfY2Ioc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrLCBpbnQgZGVpbml0KQoreworCXN0cnVjdCB3cGFfY29ubmVjdF93b3JrICpjd29yayA9IHdvcmstPmN0eDsKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gd29yay0+d3BhX3M7CisKKwlpZiAoZGVpbml0KSB7CisJCWlmICh3b3JrLT5zdGFydGVkKQorCQkJd3BhX3MtPmNvbm5lY3Rfd29yayA9IE5VTEw7CisKKwkJd3Bhc19jb25uZWN0X3dvcmtfZnJlZShjd29yayk7CisJCXJldHVybjsKKwl9CisKKwl3cGFfcy0+Y29ubmVjdF93b3JrID0gd29yazsKKworCWlmICghd3Bhc192YWxpZF9ic3Nfc3NpZCh3cGFfcywgY3dvcmstPmJzcywgY3dvcmstPnNzaWQpKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlNNRTogQlNTL1NTSUQgZW50cnkgZm9yIGF1dGhlbnRpY2F0aW9uIG5vdCB2YWxpZCBhbnltb3JlIC0gZHJvcCBjb25uZWN0aW9uIGF0dGVtcHQiKTsKKwkJd3Bhc19jb25uZWN0X3dvcmtfZG9uZSh3cGFfcyk7CisJCXJldHVybjsKKwl9CisKKwlzbWVfc2VuZF9hdXRoZW50aWNhdGlvbih3cGFfcywgY3dvcmstPmJzcywgY3dvcmstPnNzaWQsIDEpOworfQorCisKIHZvaWQgc21lX2F1dGhlbnRpY2F0ZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkgICAgICBzdHJ1Y3Qgd3BhX2JzcyAqYnNzLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCiB7CisJc3RydWN0IHdwYV9jb25uZWN0X3dvcmsgKmN3b3JrOworCisJaWYgKGJzcyA9PSBOVUxMIHx8IHNzaWQgPT0gTlVMTCkKKwkJcmV0dXJuOworCWlmICh3cGFfcy0+Y29ubmVjdF93b3JrKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlNNRTogUmVqZWN0IHNtZV9hdXRoZW50aWNhdGUoKSBjYWxsIHNpbmNlIGNvbm5lY3Rfd29yayBleGlzdCIpOworCQlyZXR1cm47CisJfQorCisJaWYgKHJhZGlvX3dvcmtfcGVuZGluZyh3cGFfcywgInNtZS1jb25uZWN0IikpIHsKKwkJLyoKKwkJICogVGhlIHByZXZpb3VzIHNtZS1jb25uZWN0IHdvcmsgbWlnaHQgbm8gbG9uZ2VyIGJlIHZhbGlkIGR1ZSB0bworCQkgKiB0aGUgZmFjdCB0aGF0IHRoZSBCU1MgbGlzdCB3YXMgdXBkYXRlZC4gSW4gYWRkaXRpb24sIGl0IG1ha2VzCisJCSAqIHNlbnNlIHRvIGFkaGVyZSB0byB0aGUgJ25ld2VyJyBkZWNpc2lvbi4KKwkJICovCisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywKKwkJCSJTTUU6IFJlbW92ZSBwcmV2aW91cyBwZW5kaW5nIHNtZS1jb25uZWN0Iik7CisJCXJhZGlvX3JlbW92ZV93b3Jrcyh3cGFfcywgInNtZS1jb25uZWN0IiwgMCk7CisJfQorCisJY3dvcmsgPSBvc196YWxsb2Moc2l6ZW9mKCpjd29yaykpOworCWlmIChjd29yayA9PSBOVUxMKQorCQlyZXR1cm47CisJY3dvcmstPmJzcyA9IGJzczsKKwljd29yay0+c3NpZCA9IHNzaWQ7CisJY3dvcmstPnNtZSA9IDE7CisKICNpZmRlZiBDT05GSUdfU0FFCiAJd3BhX3MtPnNtZS5zYWUuc3RhdGUgPSBTQUVfTk9USElORzsKIAl3cGFfcy0+c21lLnNhZS5zZW5kX2NvbmZpcm0gPSAwOworCXdwYV9zLT5zbWUuc2FlX2dyb3VwX2luZGV4ID0gMDsKICNlbmRpZiAvKiBDT05GSUdfU0FFICovCi0Jc21lX3NlbmRfYXV0aGVudGljYXRpb24od3BhX3MsIGJzcywgc3NpZCwgMSk7CisKKwlpZiAocmFkaW9fYWRkX3dvcmsod3BhX3MsIGJzcy0+ZnJlcSwgInNtZS1jb25uZWN0IiwgMSwKKwkJCSAgIHNtZV9hdXRoX3N0YXJ0X2NiLCBjd29yaykgPCAwKQorCQl3cGFzX2Nvbm5lY3Rfd29ya19mcmVlKGN3b3JrKTsKIH0KIAogCkBAIC00ODIsMTUgKzU3OCwxOCBAQAogCQlyZXR1cm4gLTE7CiAKIAlpZiAoYXV0aF90cmFuc2FjdGlvbiA9PSAxKSB7CisJCWludCAqZ3JvdXBzID0gd3BhX3MtPmNvbmYtPnNhZV9ncm91cHM7CisKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiU01FIFNBRSBjb21taXQiKTsKIAkJaWYgKHdwYV9zLT5jdXJyZW50X2JzcyA9PSBOVUxMIHx8CiAJCSAgICB3cGFfcy0+Y3VycmVudF9zc2lkID09IE5VTEwpCiAJCQlyZXR1cm4gLTE7CiAJCWlmICh3cGFfcy0+c21lLnNhZS5zdGF0ZSAhPSBTQUVfQ09NTUlUVEVEKQogCQkJcmV0dXJuIC0xOworCQlpZiAoZ3JvdXBzICYmIGdyb3Vwc1swXSA8PSAwKQorCQkJZ3JvdXBzID0gTlVMTDsKIAkJaWYgKHNhZV9wYXJzZV9jb21taXQoJndwYV9zLT5zbWUuc2FlLCBkYXRhLCBsZW4sIE5VTEwsIE5VTEwsCi0JCQkJICAgICB3cGFfcy0+Y29uZi0+c2FlX2dyb3VwcykgIT0KLQkJICAgIFdMQU5fU1RBVFVTX1NVQ0NFU1MpCisJCQkJICAgICBncm91cHMpICE9IFdMQU5fU1RBVFVTX1NVQ0NFU1MpCiAJCQlyZXR1cm4gLTE7CiAKIAkJaWYgKHNhZV9wcm9jZXNzX2NvbW1pdCgmd3BhX3MtPnNtZS5zYWUpIDwgMCkgewpAQCAtNTg1LDYgKzY4NCw4IEBACiAJCQlyZXR1cm47CiAJCX0KIAorCQl3cGFzX2Nvbm5lY3Rfd29ya19kb25lKHdwYV9zKTsKKwogCQlzd2l0Y2ggKGRhdGEtPmF1dGguYXV0aF90eXBlKSB7CiAJCWNhc2UgV0xBTl9BVVRIX09QRU46CiAJCQl3cGFfcy0+Y3VycmVudF9zc2lkLT5hdXRoX2FsZyA9IFdQQV9BVVRIX0FMR19TSEFSRUQ7CkBAIC02NDcsOSArNzQ4LDEwIEBACiAJcGFyYW1zLndwYV9pZSA9IHdwYV9zLT5zbWUuYXNzb2NfcmVxX2llX2xlbiA/CiAJCXdwYV9zLT5zbWUuYXNzb2NfcmVxX2llIDogTlVMTDsKIAlwYXJhbXMud3BhX2llX2xlbiA9IHdwYV9zLT5zbWUuYXNzb2NfcmVxX2llX2xlbjsKLQlwYXJhbXMucGFpcndpc2Vfc3VpdGUgPQotCQl3cGFfY2lwaGVyX3RvX3N1aXRlX2RyaXZlcih3cGFfcy0+cGFpcndpc2VfY2lwaGVyKTsKLQlwYXJhbXMuZ3JvdXBfc3VpdGUgPSB3cGFfY2lwaGVyX3RvX3N1aXRlX2RyaXZlcih3cGFfcy0+Z3JvdXBfY2lwaGVyKTsKKwlwYXJhbXMucGFpcndpc2Vfc3VpdGUgPSB3cGFfcy0+cGFpcndpc2VfY2lwaGVyOworCXBhcmFtcy5ncm91cF9zdWl0ZSA9IHdwYV9zLT5ncm91cF9jaXBoZXI7CisJcGFyYW1zLmtleV9tZ210X3N1aXRlID0gd3BhX3MtPmtleV9tZ210OworCXBhcmFtcy53cGFfcHJvdG8gPSB3cGFfcy0+d3BhX3Byb3RvOwogI2lmZGVmIENPTkZJR19IVF9PVkVSUklERVMKIAlvc19tZW1zZXQoJmh0Y2FwcywgMCwgc2l6ZW9mKGh0Y2FwcykpOwogCW9zX21lbXNldCgmaHRjYXBzX21hc2ssIDAsIHNpemVvZihodGNhcHNfbWFzaykpOwpAQCAtNjk2LDYgKzc5OCwxMCBAQAogCQlwYXJhbXMud3BhX3Byb3RvID0gV1BBX1BST1RPX1dQQTsKIAkJd3BhX3NtX3NldF9hc3NvY193cGFfaWUod3BhX3MtPndwYSwgZWxlbXMud3BhX2llIC0gMiwKIAkJCQkJZWxlbXMud3BhX2llX2xlbiArIDIpOworCX0gZWxzZSBpZiAoZWxlbXMub3NlbikgeworCQlwYXJhbXMud3BhX3Byb3RvID0gV1BBX1BST1RPX09TRU47CisJCXdwYV9zbV9zZXRfYXNzb2Nfd3BhX2llKHdwYV9zLT53cGEsIGVsZW1zLm9zZW4gLSAyLAorCQkJCQllbGVtcy5vc2VuX2xlbiArIDIpOwogCX0gZWxzZQogCQl3cGFfc21fc2V0X2Fzc29jX3dwYV9pZSh3cGFfcy0+d3BhLCBOVUxMLCAwKTsKIAlpZiAod3BhX3MtPmN1cnJlbnRfc3NpZCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkLT5wMnBfZ3JvdXApCkBAIC05MDMsOCArMTAwOSwxMSBAQAogCXN0cnVjdCBpZWVlODAyMTFfMjA0MF9pbnRvbF9jaGFuX3JlcG9ydCAqaWNfcmVwb3J0OwogCXN0cnVjdCB3cGFidWYgKmJ1ZjsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU01FOiBTZW5kIDIwLzQwIEJTUyBDb2V4aXN0ZW5jZSB0byAiIE1BQ1NUUiwKLQkJICAgTUFDMlNUUih3cGFfcy0+YnNzaWQpKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNNRTogU2VuZCAyMC80MCBCU1MgQ29leGlzdGVuY2UgdG8gIiBNQUNTVFIKKwkJICAgIiAobnVtX2NoYW5uZWxzPSV1IG51bV9pbnRvbD0ldSkiLAorCQkgICBNQUMyU1RSKHdwYV9zLT5ic3NpZCksIG51bV9jaGFubmVscywgbnVtX2ludG9sKTsKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJTTUU6IDIwLzQwIEJTUyBJbnRvbGVyYW50IENoYW5uZWxzIiwKKwkJICAgIGNoYW5fbGlzdCwgbnVtX2NoYW5uZWxzKTsKIAogCWJ1ZiA9IHdwYWJ1Zl9hbGxvYygyICsgLyogYWN0aW9uLmNhdGVnb3J5ICsgYWN0aW9uX2NvZGUgKi8KIAkJCSAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExXzIwNDBfYnNzX2NvZXhfaWUpICsKQEAgLTk4Niw4ICsxMDk1LDE0IEBACiAKIAkJaWUgPSB3cGFfYnNzX2dldF9pZShic3MsIFdMQU5fRUlEX0hUX0NBUCk7CiAJCWh0X2NhcCA9IChpZSAmJiAoaWVbMV0gPT0gMjYpKSA/IFdQQV9HRVRfTEUxNihpZSArIDIpIDogMDsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTTUUgT0JTUyBzY2FuIEJTUyAiIE1BQ1NUUgorCQkJICAgIiBmcmVxPSV1IGNoYW49JXUgaHRfY2FwPTB4JXgiLAorCQkJICAgTUFDMlNUUihic3MtPmJzc2lkKSwgYnNzLT5mcmVxLCBjaGFubmVsLCBodF9jYXApOwogCiAJCWlmICghaHRfY2FwIHx8IChodF9jYXAgJiBIVF9DQVBfSU5GT180ME1IWl9JTlRPTEVSQU5UKSkgeworCQkJaWYgKGh0X2NhcCAmIEhUX0NBUF9JTkZPXzQwTUhaX0lOVE9MRVJBTlQpCisJCQkJbnVtX2ludG9sKys7CisKIAkJCS8qIENoZWNrIHdoZXRoZXIgdGhlIGNoYW5uZWwgaXMgYWxyZWFkeSBjb25zaWRlcmVkICovCiAJCQlmb3IgKGkgPSAwOyBpIDwgbnVtX2NoYW5uZWxzOyBpKyspIHsKIAkJCQlpZiAoY2hhbm5lbCA9PSBjaGFuX2xpc3RbaV0pCkBAIC05OTYsOSArMTExMSw2IEBACiAJCQlpZiAoaSAhPSBudW1fY2hhbm5lbHMpCiAJCQkJY29udGludWU7CiAKLQkJCWlmIChodF9jYXAgJiBIVF9DQVBfSU5GT180ME1IWl9JTlRPTEVSQU5UKQotCQkJCW51bV9pbnRvbCsrOwotCiAJCQljaGFuX2xpc3RbbnVtX2NoYW5uZWxzKytdID0gY2hhbm5lbDsKIAkJfQogCX0KQEAgLTEwNjEsNiArMTE3Myw3IEBACiAKIAlvc19tZW1zZXQoJnBhcmFtcywgMCwgc2l6ZW9mKHBhcmFtcykpOwogCXdwYV9zZXRiYW5kX3NjYW5fZnJlcXNfbGlzdCh3cGFfcywgSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcsICZwYXJhbXMpOworCXBhcmFtcy5sb3dfcHJpb3JpdHkgPSAxOwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU01FIE9CU1M6IFJlcXVlc3QgYW4gT0JTUyBzY2FuIik7CiAKIAlpZiAod3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHdwYV9zLCAmcGFyYW1zKSkKQEAgLTExNDcsOSArMTI2MCw5IEBACiBzdGF0aWMgaW50IHNtZV9jaGVja19zYV9xdWVyeV90aW1lb3V0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJdTMyIHR1OwotCXN0cnVjdCBvc190aW1lIG5vdywgcGFzc2VkOwotCW9zX2dldF90aW1lKCZub3cpOwotCW9zX3RpbWVfc3ViKCZub3csICZ3cGFfcy0+c21lLnNhX3F1ZXJ5X3N0YXJ0LCAmcGFzc2VkKTsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3csIHBhc3NlZDsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKKwlvc19yZWx0aW1lX3N1Yigmbm93LCAmd3BhX3MtPnNtZS5zYV9xdWVyeV9zdGFydCwgJnBhc3NlZCk7CiAJdHUgPSAocGFzc2VkLnNlYyAqIDEwMDAwMDAgKyBwYXNzZWQudXNlYykgLyAxMDI0OwogCWlmIChzYV9xdWVyeV9tYXhfdGltZW91dCA8IHR1KSB7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlNNRTogU0EgUXVlcnkgdGltZWQgb3V0Iik7CkBAIC0xMTk5LDcgKzEzMTIsNyBAQAogCQlyZXR1cm47CiAJaWYgKHdwYV9zLT5zbWUuc2FfcXVlcnlfY291bnQgPT0gMCkgewogCQkvKiBTdGFydGluZyBhIG5ldyBTQSBRdWVyeSBwcm9jZWR1cmUgKi8KLQkJb3NfZ2V0X3RpbWUoJndwYV9zLT5zbWUuc2FfcXVlcnlfc3RhcnQpOworCQlvc19nZXRfcmVsdGltZSgmd3BhX3MtPnNtZS5zYV9xdWVyeV9zdGFydCk7CiAJfQogCXRyYW5zX2lkID0gbmJ1ZiArIHdwYV9zLT5zbWUuc2FfcXVlcnlfY291bnQgKiBXTEFOX1NBX1FVRVJZX1RSX0lEX0xFTjsKIAl3cGFfcy0+c21lLnNhX3F1ZXJ5X3RyYW5zX2lkID0gbmJ1ZjsKQEAgLTEyMzgsNiArMTM1MSw3IEBACiAJCQkJIGNvbnN0IHU4ICpkYSwgdTE2IHJlYXNvbl9jb2RlKQogewogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBub3c7CiAKIAlpZiAod3BhX3MtPndwYV9zdGF0ZSAhPSBXUEFfQ09NUExFVEVEKQogCQlyZXR1cm47CkBAIC0xMjU0LDYgKzEzNjgsMTIgQEAKIAlpZiAod3BhX3MtPnNtZS5zYV9xdWVyeV9jb3VudCA+IDApCiAJCXJldHVybjsKIAorCW9zX2dldF9yZWx0aW1lKCZub3cpOworCWlmICh3cGFfcy0+c21lLmxhc3RfdW5wcm90X2Rpc2Nvbm5lY3Quc2VjICYmCisJICAgICFvc19yZWx0aW1lX2V4cGlyZWQoJm5vdywgJndwYV9zLT5zbWUubGFzdF91bnByb3RfZGlzY29ubmVjdCwgMTApKQorCQlyZXR1cm47IC8qIGxpbWl0IFNBIFF1ZXJ5IHByb2NlZHVyZSBmcmVxdWVuY3kgKi8KKwl3cGFfcy0+c21lLmxhc3RfdW5wcm90X2Rpc2Nvbm5lY3QgPSBub3c7CisKIAl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJTTUU6IFVucHJvdGVjdGVkIGRpc2Nvbm5lY3QgZHJvcHBlZCAtICIKIAkJInBvc3NpYmxlIEFQL1NUQSBzdGF0ZSBtaXNtYXRjaCAtIHRyaWdnZXIgU0EgUXVlcnkiKTsKIAlzbWVfc3RhcnRfc2FfcXVlcnkod3BhX3MpOwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvdGVzdHMvdGVzdF93cGEuYyBiL3dwYV9zdXBwbGljYW50L3Rlc3RzL3Rlc3Rfd3BhLmMKaW5kZXggNDg0YTQwNi4uMzk5NzFmMiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvdGVzdHMvdGVzdF93cGEuYworKysgYi93cGFfc3VwcGxpY2FudC90ZXN0cy90ZXN0X3dwYS5jCkBAIC0xNywxMCArMTcsNiBAQAogI2luY2x1ZGUgImFwL3dwYV9hdXRoLmgiCiAKIAotZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7Ci1leHRlcm4gaW50IHdwYV9kZWJ1Z19zaG93X2tleXM7Ci0KLQogc3RydWN0IHdwYSB7CiAJdTggYXV0aF9hZGRyW0VUSF9BTEVOXTsKIAl1OCBzdXBwX2FkZHJbRVRIX0FMRU5dOwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd2lmaV9kaXNwbGF5LmMgYi93cGFfc3VwcGxpY2FudC93aWZpX2Rpc3BsYXkuYwppbmRleCA5MmNhNTM2Li5iNmY5MjM2IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC93aWZpX2Rpc3BsYXkuYworKysgYi93cGFfc3VwcGxpY2FudC93aWZpX2Rpc3BsYXkuYwpAQCAtMTYsNiArMTYsOSBAQAogI2luY2x1ZGUgIndpZmlfZGlzcGxheS5oIgogCiAKKyNkZWZpbmUgV0lGSV9ESVNQTEFZX1NVQkVMRU1fSEVBREVSX0xFTiAzCisKKwogaW50IHdpZmlfZGlzcGxheV9pbml0KHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwpCiB7CiAJZ2xvYmFsLT53aWZpX2Rpc3BsYXkgPSAxOwpAQCAtMzgsNiArNDEsOSBAQAogCXN0cnVjdCB3cGFidWYgKmllLCAqYnVmOwogCXNpemVfdCBsZW4sIHBsZW47CiAKKwlpZiAoZ2xvYmFsLT5wMnAgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldGRDogVXBkYXRlIFdGRCBJRSIpOwogCiAJaWYgKCFnbG9iYWwtPndpZmlfZGlzcGxheSkgewpAQCAtMjQ5LDMgKzI1NSw1MyBAQAogCQkJCTEsCiAJCQkJd3BhYnVmX2xlbihnbG9iYWwtPndmZF9zdWJlbGVtW3N1YmVsZW1dKSAtIDEpOwogfQorCisKK2NoYXIgKiB3aWZpX2Rpc3BsYXlfc3ViZWxlbV9oZXgoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqd2ZkX3N1YmVsZW1zLCB1OCBpZCkKK3sKKwljaGFyICpzdWJlbGVtID0gTlVMTDsKKwljb25zdCB1OCAqYnVmOworCXNpemVfdCBidWZsZW47CisJc2l6ZV90IGkgPSAwOworCXUxNiBlbGVuOworCisJaWYgKCF3ZmRfc3ViZWxlbXMpCisJCXJldHVybiBOVUxMOworCisJYnVmID0gd3BhYnVmX2hlYWRfdTgod2ZkX3N1YmVsZW1zKTsKKwlpZiAoIWJ1ZikKKwkJcmV0dXJuIE5VTEw7CisKKwlidWZsZW4gPSB3cGFidWZfbGVuKHdmZF9zdWJlbGVtcyk7CisKKwl3aGlsZSAoaSArIFdJRklfRElTUExBWV9TVUJFTEVNX0hFQURFUl9MRU4gPCBidWZsZW4pIHsKKwkJZWxlbiA9IFdQQV9HRVRfQkUxNihidWYgKyBpICsgMSk7CisJCWlmIChpICsgV0lGSV9ESVNQTEFZX1NVQkVMRU1fSEVBREVSX0xFTiArIGVsZW4gPiBidWZsZW4pCisJCQlicmVhazsgLyogdHJ1bmNhdGVkIHN1YmVsZW1lbnQgKi8KKworCQlpZiAoYnVmW2ldID09IGlkKSB7CisJCQkvKgorCQkJICogTGltaXQgZXhwbGljaXRseSB0byBhbiBhcmJpdHJhcnkgbGVuZ3RoIHRvIGF2b2lkCisJCQkgKiB1bm5lY2Vzc2FyaWx5IGxhcmdlIGFsbG9jYXRpb25zLiBJbiBwcmFjdGljZSwgdGhpcworCQkJICogaXMgbGltaXRlZCB0byBtYXhpbXVtIGZyYW1lIGxlbmd0aCBhbnl3YXksIHNvIHRoZQorCQkJICogbWF4aW11bSBtZW1vcnkgYWxsb2NhdGlvbiBoZXJlIGlzIG5vdCByZWFsbHkgdGhhdAorCQkJICogbGFyZ2UuIEFueXdheSwgdGhlIFdpLUZpIERpc3BsYXkgc3ViZWxlbWVudHMgdGhhdAorCQkJICogYXJlIGZldGNoZWQgd2l0aCB0aGlzIGZ1bmN0aW9uIGFyZSBldmVuIHNob3J0ZXIuCisJCQkgKi8KKwkJCWlmIChlbGVuID4gMTAwMCkKKwkJCQlicmVhazsKKwkJCXN1YmVsZW0gPSBvc196YWxsb2MoMiAqIGVsZW4gKyAxKTsKKwkJCWlmICghc3ViZWxlbSkKKwkJCQlyZXR1cm4gTlVMTDsKKwkJCXdwYV9zbnByaW50Zl9oZXgoc3ViZWxlbSwgMiAqIGVsZW4gKyAxLAorCQkJCQkgYnVmICsgaSArCisJCQkJCSBXSUZJX0RJU1BMQVlfU1VCRUxFTV9IRUFERVJfTEVOLAorCQkJCQkgZWxlbik7CisJCQlicmVhazsKKwkJfQorCisJCWkgKz0gZWxlbiArIFdJRklfRElTUExBWV9TVUJFTEVNX0hFQURFUl9MRU47CisJfQorCisJcmV0dXJuIHN1YmVsZW07Cit9CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93aWZpX2Rpc3BsYXkuaCBiL3dwYV9zdXBwbGljYW50L3dpZmlfZGlzcGxheS5oCmluZGV4IGI3NWQ0ZjIuLjc1NTQ4MTcgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dpZmlfZGlzcGxheS5oCisrKyBiL3dwYV9zdXBwbGljYW50L3dpZmlfZGlzcGxheS5oCkBAIC0xNiw1ICsxNiw2IEBACiBpbnQgd2lmaV9kaXNwbGF5X3N1YmVsZW1fc2V0KHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsIGNoYXIgKmNtZCk7CiBpbnQgd2lmaV9kaXNwbGF5X3N1YmVsZW1fZ2V0KHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsIGNoYXIgKmNtZCwKIAkJCSAgICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKTsKK2NoYXIgKiB3aWZpX2Rpc3BsYXlfc3ViZWxlbV9oZXgoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqd2ZkX3N1YmVsZW1zLCB1OCBpZCk7CiAKICNlbmRpZiAvKiBXSUZJX0RJU1BMQVlfSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd25tX3N0YS5jIGIvd3BhX3N1cHBsaWNhbnQvd25tX3N0YS5jCmluZGV4IDRmOGQ4OTUuLjRhNzkyYzQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dubV9zdGEuYworKysgYi93cGFfc3VwcGxpY2FudC93bm1fc3RhLmMKQEAgLTE4LDYgKzE4LDcgQEAKICNpbmNsdWRlICJjdHJsX2lmYWNlLmgiCiAjaW5jbHVkZSAiYnNzLmgiCiAjaW5jbHVkZSAid25tX3N0YS5oIgorI2luY2x1ZGUgImhzMjBfc3VwcGxpY2FudC5oIgogCiAjZGVmaW5lIE1BWF9URlNfSUVfTEVOICAxMDI0CiAjZGVmaW5lIFdOTV9NQVhfTkVJR0hCT1JfUkVQT1JUIDEwCkBAIC0xODEsNyArMTgyLDcgQEAKIAkvKiBJbnN0YWxsIEdUSy9JR1RLICovCiAKIAkvKiBwb2ludCB0byBrZXkgZGF0YSBmaWVsZCAqLwotCXB0ciA9ICh1OCAqKSBmcm0gKyAxICsgMSArIDI7CisJcHRyID0gKHU4ICopIGZybSArIDEgKyAyOwogCWVuZCA9IHB0ciArIGtleV9sZW5fdG90YWw7CiAJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIldOTTogS2V5IERhdGEiLCBwdHIsIGtleV9sZW5fdG90YWwpOwogCkBAIC0yMzQsMTkgKzIzNSwyMyBAQAogCQkJCQljb25zdCB1OCAqZnJtLCBpbnQgbGVuKQogewogCS8qCi0JICogQWN0aW9uIFsxXSB8IERpYWdsb2cgVG9rZW4gWzFdIHwgS2V5IERhdGEgTGVuIFsyXSB8IEtleSBEYXRhIHwKKwkgKiBBY3Rpb24gWzFdIHwgRGlhbG9nIFRva2VuIFsxXSB8IEtleSBEYXRhIExlbiBbMl0gfCBLZXkgRGF0YSB8CiAJICogV05NLVNsZWVwIE1vZGUgSUUgfCBURlMgUmVzcG9uc2UgSUUKIAkgKi8KLQl1OCAqcG9zID0gKHU4ICopIGZybTsgLyogcG9pbnQgdG8gYWN0aW9uIGZpZWxkICovCi0JdTE2IGtleV9sZW5fdG90YWwgPSBsZV90b19ob3N0MTYoKigodTE2ICopKGZybSsyKSkpOworCXU4ICpwb3MgPSAodTggKikgZnJtOyAvKiBwb2ludCB0byBwYXlsb2FkIGFmdGVyIHRoZSBhY3Rpb24gZmllbGQgKi8KKwl1MTYga2V5X2xlbl90b3RhbDsKIAlzdHJ1Y3Qgd25tX3NsZWVwX2VsZW1lbnQgKndubXNsZWVwX2llID0gTlVMTDsKIAkvKiBtdWx0aXBsZSBURlMgUmVzcCBJRSAoYXNzdW1pbmcgY29uc2VjdXRpdmUpICovCiAJdTggKnRmc3Jlc3BfaWVfc3RhcnQgPSBOVUxMOwogCXU4ICp0ZnNyZXNwX2llX2VuZCA9IE5VTEw7CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImFjdGlvbj0lZCB0b2tlbiA9ICVkIGtleV9sZW5fdG90YWwgPSAlZCIsCi0JCSAgIGZybVswXSwgZnJtWzFdLCBrZXlfbGVuX3RvdGFsKTsKLQlwb3MgKz0gNCArIGtleV9sZW5fdG90YWw7CisJaWYgKGxlbiA8IDMpCisJCXJldHVybjsKKwlrZXlfbGVuX3RvdGFsID0gV1BBX0dFVF9MRTE2KGZybSArIDEpOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk0tU2xlZXAgTW9kZSBSZXNwb25zZSB0b2tlbj0ldSBrZXlfbGVuX3RvdGFsPSVkIiwKKwkJICAgZnJtWzBdLCBrZXlfbGVuX3RvdGFsKTsKKwlwb3MgKz0gMyArIGtleV9sZW5fdG90YWw7CiAJaWYgKHBvcyA+IGZybSArIGxlbikgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV05NOiBUb28gc2hvcnQgZnJhbWUgZm9yIEtleSBEYXRhIGZpZWxkIik7CiAJCXJldHVybjsKQEAgLTMxNCw2ICszMTksNyBAQAogCQlvc19mcmVlKHdwYV9zLT53bm1fbmVpZ2hib3JfcmVwb3J0X2VsZW1lbnRzW2ldLm11bF9ic3NpZCk7CiAJfQogCisJd3BhX3MtPndubV9udW1fbmVpZ2hib3JfcmVwb3J0ID0gMDsKIAlvc19mcmVlKHdwYV9zLT53bm1fbmVpZ2hib3JfcmVwb3J0X2VsZW1lbnRzKTsKIAl3cGFfcy0+d25tX25laWdoYm9yX3JlcG9ydF9lbGVtZW50cyA9IE5VTEw7CiB9CkBAIC0zMjgsMTAgKzMzNCwxMCBAQAogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IFRvbyBzaG9ydCBUU0YiKTsKIAkJCWJyZWFrOwogCQl9CisJCW9zX2ZyZWUocmVwLT50c2ZfaW5mbyk7CiAJCXJlcC0+dHNmX2luZm8gPSBvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCB0c2ZfaW5mbykpOwogCQlpZiAocmVwLT50c2ZfaW5mbyA9PSBOVUxMKQogCQkJYnJlYWs7Ci0JCXJlcC0+dHNmX2luZm8tPnByZXNlbnQgPSAxOwogCQlvc19tZW1jcHkocmVwLT50c2ZfaW5mby0+dHNmX29mZnNldCwgcG9zLCAyKTsKIAkJb3NfbWVtY3B5KHJlcC0+dHNmX2luZm8tPmJlYWNvbl9pbnRlcnZhbCwgcG9zICsgMiwgMik7CiAJCWJyZWFrOwpAQCAtMzQxLDExICszNDcsMTEgQEAKIAkJCQkgICAiY291bnRyeSBzdHJpbmciKTsKIAkJCWJyZWFrOwogCQl9CisJCW9zX2ZyZWUocmVwLT5jb25fY291bl9zdHIpOwogCQlyZXAtPmNvbl9jb3VuX3N0ciA9CiAJCQlvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCBjb25kZW5zZWRfY291bnRyeV9zdHJpbmcpKTsKIAkJaWYgKHJlcC0+Y29uX2NvdW5fc3RyID09IE5VTEwpCiAJCQlicmVhazsKLQkJcmVwLT5jb25fY291bl9zdHItPnByZXNlbnQgPSAxOwogCQlvc19tZW1jcHkocmVwLT5jb25fY291bl9zdHItPmNvdW50cnlfc3RyaW5nLCBwb3MsIDIpOwogCQlicmVhazsKIAljYXNlIFdOTV9ORUlHSEJPUl9CU1NfVFJBTlNJVElPTl9DQU5ESURBVEU6CkBAIC0zNTQsMjUgKzM2MCwyNSBAQAogCQkJCSAgICJjYW5kaWRhdGUiKTsKIAkJCWJyZWFrOwogCQl9CisJCW9zX2ZyZWUocmVwLT5ic3NfdHJhbl9jYW4pOwogCQlyZXAtPmJzc190cmFuX2NhbiA9CiAJCQlvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCBic3NfdHJhbnNpdGlvbl9jYW5kaWRhdGUpKTsKIAkJaWYgKHJlcC0+YnNzX3RyYW5fY2FuID09IE5VTEwpCiAJCQlicmVhazsKLQkJcmVwLT5ic3NfdHJhbl9jYW4tPnByZXNlbnQgPSAxOwogCQlyZXAtPmJzc190cmFuX2Nhbi0+cHJlZmVyZW5jZSA9IHBvc1swXTsKIAkJYnJlYWs7CiAJY2FzZSBXTk1fTkVJR0hCT1JfQlNTX1RFUk1JTkFUSU9OX0RVUkFUSU9OOgotCQlpZiAoZWxlbiA8IDEyKSB7CisJCWlmIChlbGVuIDwgMTApIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBUb28gc2hvcnQgQlNTIHRlcm1pbmF0aW9uICIKIAkJCQkgICAiZHVyYXRpb24iKTsKIAkJCWJyZWFrOwogCQl9CisJCW9zX2ZyZWUocmVwLT5ic3NfdGVybV9kdXIpOwogCQlyZXAtPmJzc190ZXJtX2R1ciA9CiAJCQlvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCBic3NfdGVybWluYXRpb25fZHVyYXRpb24pKTsKIAkJaWYgKHJlcC0+YnNzX3Rlcm1fZHVyID09IE5VTEwpCiAJCQlicmVhazsKLQkJcmVwLT5ic3NfdGVybV9kdXItPnByZXNlbnQgPSAxOwotCQlvc19tZW1jcHkocmVwLT5ic3NfdGVybV9kdXItPmR1cmF0aW9uLCBwb3MsIDEyKTsKKwkJb3NfbWVtY3B5KHJlcC0+YnNzX3Rlcm1fZHVyLT5kdXJhdGlvbiwgcG9zLCAxMCk7CiAJCWJyZWFrOwogCWNhc2UgV05NX05FSUdIQk9SX0JFQVJJTkc6CiAJCWlmIChlbGVuIDwgOCkgewpAQCAtMzgwLDUxICszODYsNTEgQEAKIAkJCQkgICAiYmVhcmluZyIpOwogCQkJYnJlYWs7CiAJCX0KKwkJb3NfZnJlZShyZXAtPmJlYXJpbmcpOwogCQlyZXAtPmJlYXJpbmcgPSBvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCBiZWFyaW5nKSk7CiAJCWlmIChyZXAtPmJlYXJpbmcgPT0gTlVMTCkKIAkJCWJyZWFrOwotCQlyZXAtPmJlYXJpbmctPnByZXNlbnQgPSAxOwogCQlvc19tZW1jcHkocmVwLT5iZWFyaW5nLT5iZWFyaW5nLCBwb3MsIDgpOwogCQlicmVhazsKIAljYXNlIFdOTV9ORUlHSEJPUl9NRUFTVVJFTUVOVF9QSUxPVDoKLQkJaWYgKGVsZW4gPCAyKSB7CisJCWlmIChlbGVuIDwgMSkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IFRvbyBzaG9ydCBtZWFzdXJlbWVudCAiCiAJCQkJICAgInBpbG90Iik7CiAJCQlicmVhazsKIAkJfQorCQlvc19mcmVlKHJlcC0+bWVhc19waWxvdCk7CiAJCXJlcC0+bWVhc19waWxvdCA9IG9zX3phbGxvYyhzaXplb2Yoc3RydWN0IG1lYXN1cmVtZW50X3BpbG90KSk7CiAJCWlmIChyZXAtPm1lYXNfcGlsb3QgPT0gTlVMTCkKIAkJCWJyZWFrOwotCQlyZXAtPm1lYXNfcGlsb3QtPnByZXNlbnQgPSAxOwogCQlyZXAtPm1lYXNfcGlsb3QtPm1lYXN1cmVtZW50X3BpbG90ID0gcG9zWzBdOwotCQlyZXAtPm1lYXNfcGlsb3QtPm51bV92ZW5kb3Jfc3BlY2lmaWMgPSBwb3NbMV07Ci0JCW9zX21lbWNweShyZXAtPm1lYXNfcGlsb3QtPnZlbmRvcl9zcGVjaWZpYywgcG9zICsgMiwgZWxlbiAtIDIpOworCQlyZXAtPm1lYXNfcGlsb3QtPnN1YmVsZW1fbGVuID0gZWxlbiAtIDE7CisJCW9zX21lbWNweShyZXAtPm1lYXNfcGlsb3QtPnN1YmVsZW1zLCBwb3MgKyAxLCBlbGVuIC0gMSk7CiAJCWJyZWFrOwogCWNhc2UgV05NX05FSUdIQk9SX1JSTV9FTkFCTEVEX0NBUEFCSUxJVElFUzoKLQkJaWYgKGVsZW4gPCA0KSB7CisJCWlmIChlbGVuIDwgNSkgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IFRvbyBzaG9ydCBSUk0gZW5hYmxlZCAiCiAJCQkJICAgImNhcGFiaWxpdGllcyIpOwogCQkJYnJlYWs7CiAJCX0KKwkJb3NfZnJlZShyZXAtPnJybV9jYXApOwogCQlyZXAtPnJybV9jYXAgPQogCQkJb3NfemFsbG9jKHNpemVvZihzdHJ1Y3QgcnJtX2VuYWJsZWRfY2FwYWJpbGl0aWVzKSk7CiAJCWlmIChyZXAtPnJybV9jYXAgPT0gTlVMTCkKIAkJCWJyZWFrOwotCQlyZXAtPnJybV9jYXAtPnByZXNlbnQgPSAxOwotCQlvc19tZW1jcHkocmVwLT5ycm1fY2FwLT5jYXBhYmlsaXRpZXMsIHBvcywgNCk7CisJCW9zX21lbWNweShyZXAtPnJybV9jYXAtPmNhcGFiaWxpdGllcywgcG9zLCA1KTsKIAkJYnJlYWs7CiAJY2FzZSBXTk1fTkVJR0hCT1JfTVVMVElQTEVfQlNTSUQ6Ci0JCWlmIChlbGVuIDwgMikgeworCQlpZiAoZWxlbiA8IDEpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBUb28gc2hvcnQgbXVsdGlwbGUgQlNTSUQiKTsKIAkJCWJyZWFrOwogCQl9CisJCW9zX2ZyZWUocmVwLT5tdWxfYnNzaWQpOwogCQlyZXAtPm11bF9ic3NpZCA9IG9zX3phbGxvYyhzaXplb2Yoc3RydWN0IG11bHRpcGxlX2Jzc2lkKSk7CiAJCWlmIChyZXAtPm11bF9ic3NpZCA9PSBOVUxMKQogCQkJYnJlYWs7Ci0JCXJlcC0+bXVsX2Jzc2lkLT5wcmVzZW50ID0gMTsKIAkJcmVwLT5tdWxfYnNzaWQtPm1heF9ic3NpZF9pbmRpY2F0b3IgPSBwb3NbMF07Ci0JCXJlcC0+bXVsX2Jzc2lkLT5udW1fdmVuZG9yX3NwZWNpZmljID0gcG9zWzFdOwotCQlvc19tZW1jcHkocmVwLT5tdWxfYnNzaWQtPnZlbmRvcl9zcGVjaWZpYywgcG9zICsgMiwgZWxlbiAtIDIpOworCQlyZXAtPm11bF9ic3NpZC0+c3ViZWxlbV9sZW4gPSBlbGVuIC0gMTsKKwkJb3NfbWVtY3B5KHJlcC0+bXVsX2Jzc2lkLT5zdWJlbGVtcywgcG9zICsgMSwgZWxlbiAtIDEpOwogCQlicmVhazsKIAl9CiB9CkBAIC00NTUsOCArNDYxLDE1IEBACiAKIAkJaWQgPSAqcG9zKys7CiAJCWVsZW4gPSAqcG9zKys7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBTdWJlbGVtZW50IGlkPSV1IGxlbj0ldSIsIGlkLCBlbGVuKTsKKwkJbGVmdCAtPSAyOworCQlpZiAoZWxlbiA+IGxlZnQpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLAorCQkJCSAgICJXTk06IFRydW5jYXRlZCBuZWlnaGJvciByZXBvcnQgc3ViZWxlbWVudCIpOworCQkJYnJlYWs7CisJCX0KIAkJd25tX3BhcnNlX25laWdoYm9yX3JlcG9ydF9lbGVtKHJlcCwgaWQsIGVsZW4sIHBvcyk7Ci0JCWxlZnQgLT0gMiArIGVsZW47CisJCWxlZnQgLT0gZWxlbjsKIAkJcG9zICs9IGVsZW47CiAJfQogfQpAQCAtNDcwLDkgKzQ4MywxMiBAQAogCiAJdTggaSwgajsKIAotCWlmIChzY2FuX3JlcyA9PSBOVUxMIHx8IG51bV9uZWlnaF9yZXAgPT0gMCkKKwlpZiAoc2Nhbl9yZXMgPT0gTlVMTCB8fCBudW1fbmVpZ2hfcmVwID09IDAgfHwgIXdwYV9zLT5jdXJyZW50X2JzcykKIAkJcmV0dXJuIDA7CiAKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogQ3VycmVudCBCU1MgIiBNQUNTVFIgIiBSU1NJICVkIiwKKwkJICAgTUFDMlNUUih3cGFfcy0+YnNzaWQpLCB3cGFfcy0+Y3VycmVudF9ic3MtPmxldmVsKTsKKwogCWZvciAoaSA9IDA7IGkgPCBudW1fbmVpZ2hfcmVwOyBpKyspIHsKIAkJZm9yIChqID0gMDsgaiA8IHNjYW5fcmVzLT5udW07IGorKykgewogCQkJLyogQ2hlY2sgZm9yIGEgYmV0dGVyIFJTU0kgQVAgKi8KQEAgLTQ4Myw4ICs0OTksMTYgQEAKIAkJCQkvKiBHb3QgYSBCU1NJRCB3aXRoIGJldHRlciBSU1NJIHZhbHVlICovCiAJCQkJb3NfbWVtY3B5KGJzc2lkX3RvX2Nvbm5lY3QsIG5laWdoX3JlcFtpXS5ic3NpZCwKIAkJCQkJICBFVEhfQUxFTik7CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGb3VuZCBhIEJTUyAiIE1BQ1NUUgorCQkJCQkgICAiIHdpdGggYmV0dGVyIHNjYW4gUlNTSSAlZCIsCisJCQkJCSAgIE1BQzJTVFIoc2Nhbl9yZXMtPnJlc1tqXS0+YnNzaWQpLAorCQkJCQkgICBzY2FuX3Jlcy0+cmVzW2pdLT5sZXZlbCk7CiAJCQkJcmV0dXJuIDE7CiAJCQl9CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgInNjYW5fcmVzWyVkXSAiIE1BQ1NUUgorCQkJCSAgICIgUlNTSSAlZCIsIGosCisJCQkJICAgTUFDMlNUUihzY2FuX3Jlcy0+cmVzW2pdLT5ic3NpZCksCisJCQkJICAgc2Nhbl9yZXMtPnJlc1tqXS0+bGV2ZWwpOwogCQl9CiAJfQogCkBAIC01MjEsNiArNTQ1LDE0IEBACiAJaWYgKHRhcmdldF9ic3NpZCkgewogCQlvc19tZW1jcHkocG9zLCB0YXJnZXRfYnNzaWQsIEVUSF9BTEVOKTsKIAkJcG9zICs9IEVUSF9BTEVOOworCX0gZWxzZSBpZiAoc3RhdHVzID09IFdOTV9CU1NfVE1fQUNDRVBUKSB7CisJCS8qCisJCSAqIFA4MDIuMTEtUkVWbWMgY2xhcmlmaWVzIHRoYXQgdGhlIFRhcmdldCBCU1NJRCBmaWVsZCBpcyBhbHdheXMKKwkJICogcHJlc2VudCB3aGVuIHN0YXR1cyBjb2RlIGlzIHplcm8sIHNvIHVzZSBhIGZha2UgdmFsdWUgaGVyZSBpZgorCQkgKiBubyBCU1NJRCBpcyB5ZXQga25vd24uCisJCSAqLworCQlvc19tZW1zZXQocG9zLCAwLCBFVEhfQUxFTik7CisJCXBvcyArPSBFVEhfQUxFTjsKIAl9CiAKIAlsZW4gPSBwb3MgLSAodTggKikgJm1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5OwpAQCAtNTYyLDcgKzU5NCw3IEBACiAJCQl3bm1fc2VuZF9ic3NfdHJhbnNpdGlvbl9tZ210X3Jlc3Aod3BhX3MsCiAJCQkJCQkgIHdwYV9zLT53bm1fZGlhbG9nX3Rva2VuLAogCQkJCQkJICBXTk1fQlNTX1RNX0FDQ0VQVCwKLQkJCQkJCSAgMCwgTlVMTCk7CisJCQkJCQkgIDAsIGJzc2lkKTsKIAkJfQogCiAJCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7CkBAIC02NzAsMTAgKzcwMiwxMiBAQAogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBUcnVuY2F0ZWQgcmVxdWVzdCIpOwogCQkJCXJldHVybjsKIAkJCX0KLQkJCXdubV9wYXJzZV9uZWlnaGJvcl9yZXBvcnQoCi0JCQkJd3BhX3MsIHBvcywgbGVuLAotCQkJCSZ3cGFfcy0+d25tX25laWdoYm9yX3JlcG9ydF9lbGVtZW50c1sKLQkJCQkJd3BhX3MtPndubV9udW1fbmVpZ2hib3JfcmVwb3J0XSk7CisJCQlpZiAodGFnID09IFdMQU5fRUlEX05FSUdIQk9SX1JFUE9SVCkgeworCQkJCXN0cnVjdCBuZWlnaGJvcl9yZXBvcnQgKnJlcDsKKwkJCQlyZXAgPSAmd3BhX3MtPndubV9uZWlnaGJvcl9yZXBvcnRfZWxlbWVudHNbCisJCQkJCXdwYV9zLT53bm1fbnVtX25laWdoYm9yX3JlcG9ydF07CisJCQkJd25tX3BhcnNlX25laWdoYm9yX3JlcG9ydCh3cGFfcywgcG9zLCBsZW4sIHJlcCk7CisJCQl9CiAKIAkJCXBvcyArPSBsZW47CiAJCQl3cGFfcy0+d25tX251bV9uZWlnaGJvcl9yZXBvcnQrKzsKQEAgLTcxNyw3ICs3NTEsNyBAQAogCQkJCQkgICBXTEFOX0ZDX1NUWVBFX0FDVElPTik7CiAJbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgPSBXTEFOX0FDVElPTl9XTk07CiAJbWdtdC0+dS5hY3Rpb24udS5ic3NfdG1fcXVlcnkuYWN0aW9uID0gV05NX0JTU19UUkFOU19NR01UX1FVRVJZOwotCW1nbXQtPnUuYWN0aW9uLnUuYnNzX3RtX3F1ZXJ5LmRpYWxvZ190b2tlbiA9IDA7CisJbWdtdC0+dS5hY3Rpb24udS5ic3NfdG1fcXVlcnkuZGlhbG9nX3Rva2VuID0gMTsKIAltZ210LT51LmFjdGlvbi51LmJzc190bV9xdWVyeS5xdWVyeV9yZWFzb24gPSBxdWVyeV9yZWFzb247CiAJcG9zID0gbWdtdC0+dS5hY3Rpb24udS5ic3NfdG1fcXVlcnkudmFyaWFibGU7CiAKQEAgLTczMSwyMyArNzY1LDE3MCBAQAogfQogCiAKK3N0YXRpYyB2b2lkIGllZWU4MDJfMTFfcnhfd25tX25vdGlmX3JlcV93ZmEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgIGNvbnN0IHU4ICpzYSwgY29uc3QgdTggKmRhdGEsCisJCQkJCSAgICBpbnQgbGVuKQoreworCWNvbnN0IHU4ICpwb3MsICplbmQsICpuZXh0OworCXU4IGllLCBpZV9sZW47CisKKwlwb3MgPSBkYXRhOworCWVuZCA9IGRhdGEgKyBsZW47CisKKwl3aGlsZSAocG9zICsgMSA8IGVuZCkgeworCQlpZSA9ICpwb3MrKzsKKwkJaWVfbGVuID0gKnBvcysrOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogV0ZBIHN1YmVsZW1lbnQgJXUgbGVuICV1IiwKKwkJCSAgIGllLCBpZV9sZW4pOworCQlpZiAoaWVfbGVuID4gZW5kIC0gcG9zKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogTm90IGVub3VnaCByb29tIGZvciAiCisJCQkJICAgInN1YmVsZW1lbnQiKTsKKwkJCWJyZWFrOworCQl9CisJCW5leHQgPSBwb3MgKyBpZV9sZW47CisJCWlmIChpZV9sZW4gPCA0KSB7CisJCQlwb3MgPSBuZXh0OworCQkJY29udGludWU7CisJCX0KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IFN1YmVsZW1lbnQgT1VJICUwNnggdHlwZSAldSIsCisJCQkgICBXUEFfR0VUX0JFMjQocG9zKSwgcG9zWzNdKTsKKworI2lmZGVmIENPTkZJR19IUzIwCisJCWlmIChpZSA9PSBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUMgJiYgaWVfbGVuID49IDUgJiYKKwkJICAgIFdQQV9HRVRfQkUyNChwb3MpID09IE9VSV9XRkEgJiYKKwkJICAgIHBvc1szXSA9PSBIUzIwX1dOTV9TVUJfUkVNX05FRURFRCkgeworCQkJLyogU3Vic2NyaXB0aW9uIFJlbWVkaWF0aW9uIHN1YmVsZW1lbnQgKi8KKwkJCWNvbnN0IHU4ICppZV9lbmQ7CisJCQl1OCB1cmxfbGVuOworCQkJY2hhciAqdXJsOworCQkJdTggb3N1X21ldGhvZDsKKworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IFN1YnNjcmlwdGlvbiBSZW1lZGlhdGlvbiAiCisJCQkJICAgInN1YmVsZW1lbnQiKTsKKwkJCWllX2VuZCA9IHBvcyArIGllX2xlbjsKKwkJCXBvcyArPSA0OworCQkJdXJsX2xlbiA9ICpwb3MrKzsKKwkJCWlmICh1cmxfbGVuID09IDApIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogTm8gU2VydmVyIFVSTCBpbmNsdWRlZCIpOworCQkJCXVybCA9IE5VTEw7CisJCQkJb3N1X21ldGhvZCA9IDE7CisJCQl9IGVsc2UgeworCQkJCWlmIChwb3MgKyB1cmxfbGVuICsgMSA+IGllX2VuZCkgeworCQkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogTm90IGVub3VnaCByb29tIGZvciBTZXJ2ZXIgVVJMIChsZW49JXUpIGFuZCBTZXJ2ZXIgTWV0aG9kIChsZWZ0ICVkKSIsCisJCQkJCQkgICB1cmxfbGVuLAorCQkJCQkJICAgKGludCkgKGllX2VuZCAtIHBvcykpOworCQkJCQlicmVhazsKKwkJCQl9CisJCQkJdXJsID0gb3NfbWFsbG9jKHVybF9sZW4gKyAxKTsKKwkJCQlpZiAodXJsID09IE5VTEwpCisJCQkJCWJyZWFrOworCQkJCW9zX21lbWNweSh1cmwsIHBvcywgdXJsX2xlbik7CisJCQkJdXJsW3VybF9sZW5dID0gJ1wwJzsKKwkJCQlvc3VfbWV0aG9kID0gcG9zW3VybF9sZW5dOworCQkJfQorCQkJaHMyMF9yeF9zdWJzY3JpcHRpb25fcmVtZWRpYXRpb24od3BhX3MsIHVybCwKKwkJCQkJCQkgb3N1X21ldGhvZCk7CisJCQlvc19mcmVlKHVybCk7CisJCQlwb3MgPSBuZXh0OworCQkJY29udGludWU7CisJCX0KKworCQlpZiAoaWUgPT0gV0xBTl9FSURfVkVORE9SX1NQRUNJRklDICYmIGllX2xlbiA+PSA4ICYmCisJCSAgICBXUEFfR0VUX0JFMjQocG9zKSA9PSBPVUlfV0ZBICYmCisJCSAgICBwb3NbM10gPT0gSFMyMF9XTk1fREVBVVRIX0lNTUlORU5UX05PVElDRSkgeworCQkJY29uc3QgdTggKmllX2VuZDsKKwkJCXU4IHVybF9sZW47CisJCQljaGFyICp1cmw7CisJCQl1OCBjb2RlOworCQkJdTE2IHJlYXV0aF9kZWxheTsKKworCQkJaWVfZW5kID0gcG9zICsgaWVfbGVuOworCQkJcG9zICs9IDQ7CisJCQljb2RlID0gKnBvcysrOworCQkJcmVhdXRoX2RlbGF5ID0gV1BBX0dFVF9MRTE2KHBvcyk7CisJCQlwb3MgKz0gMjsKKwkJCXVybF9sZW4gPSAqcG9zKys7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogSFMgMi4wIERlYXV0aGVudGljYXRpb24gIgorCQkJCSAgICJJbW1pbmVudCAtIFJlYXNvbiBDb2RlICV1ICAgIgorCQkJCSAgICJSZS1BdXRoIERlbGF5ICV1ICBVUkwgTGVuZ3RoICV1IiwKKwkJCQkgICBjb2RlLCByZWF1dGhfZGVsYXksIHVybF9sZW4pOworCQkJaWYgKHBvcyArIHVybF9sZW4gPiBpZV9lbmQpCisJCQkJYnJlYWs7CisJCQl1cmwgPSBvc19tYWxsb2ModXJsX2xlbiArIDEpOworCQkJaWYgKHVybCA9PSBOVUxMKQorCQkJCWJyZWFrOworCQkJb3NfbWVtY3B5KHVybCwgcG9zLCB1cmxfbGVuKTsKKwkJCXVybFt1cmxfbGVuXSA9ICdcMCc7CisJCQloczIwX3J4X2RlYXV0aF9pbW1pbmVudF9ub3RpY2Uod3BhX3MsIGNvZGUsCisJCQkJCQkgICAgICAgcmVhdXRoX2RlbGF5LCB1cmwpOworCQkJb3NfZnJlZSh1cmwpOworCQkJcG9zID0gbmV4dDsKKwkJCWNvbnRpbnVlOworCQl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKworCQlwb3MgPSBuZXh0OworCX0KK30KKworCitzdGF0aWMgdm9pZCBpZWVlODAyXzExX3J4X3dubV9ub3RpZl9yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJY29uc3QgdTggKnNhLCBjb25zdCB1OCAqZnJtLCBpbnQgbGVuKQoreworCWNvbnN0IHU4ICpwb3MsICplbmQ7CisJdTggZGlhbG9nX3Rva2VuLCB0eXBlOworCisJLyogRGlhbG9nIFRva2VuIFsxXSB8IFR5cGUgWzFdIHwgU3ViZWxlbWVudHMgKi8KKworCWlmIChsZW4gPCAyIHx8IHNhID09IE5VTEwpCisJCXJldHVybjsKKwllbmQgPSBmcm0gKyBsZW47CisJcG9zID0gZnJtOworCWRpYWxvZ190b2tlbiA9ICpwb3MrKzsKKwl0eXBlID0gKnBvcysrOworCisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiV05NOiBSZWNlaXZlZCBXTk0tTm90aWZpY2F0aW9uIFJlcXVlc3QgIgorCQkiKGRpYWxvZ190b2tlbiAldSB0eXBlICV1IHNhICIgTUFDU1RSICIpIiwKKwkJZGlhbG9nX3Rva2VuLCB0eXBlLCBNQUMyU1RSKHNhKSk7CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV05NLU5vdGlmaWNhdGlvbiBSZXF1ZXN0IHN1YmVsZW1lbnRzIiwKKwkJICAgIHBvcywgZW5kIC0gcG9zKTsKKworCWlmICh3cGFfcy0+d3BhX3N0YXRlICE9IFdQQV9DT01QTEVURUQgfHwKKwkgICAgb3NfbWVtY21wKHNhLCB3cGFfcy0+YnNzaWQsIEVUSF9BTEVOKSAhPSAwKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIldOTTogV05NLU5vdGlmaWNhdGlvbiBmcmFtZSBub3QgIgorCQkJImZyb20gb3VyIEFQIC0gaWdub3JlIGl0Iik7CisJCXJldHVybjsKKwl9CisKKwlzd2l0Y2ggKHR5cGUpIHsKKwljYXNlIDE6CisJCWllZWU4MDJfMTFfcnhfd25tX25vdGlmX3JlcV93ZmEod3BhX3MsIHNhLCBwb3MsIGVuZCAtIHBvcyk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIldOTTogSWdub3JlIHVua25vd24gIgorCQkJIldOTS1Ob3RpZmljYXRpb24gdHlwZSAldSIsIHR5cGUpOworCQlicmVhazsKKwl9Cit9CisKKwogdm9pZCBpZWVlODAyXzExX3J4X3dubV9hY3Rpb24oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCSAgICAgIHN0cnVjdCByeF9hY3Rpb24gKmFjdGlvbikKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdCwgc2l6ZV90IGxlbikKIHsKIAljb25zdCB1OCAqcG9zLCAqZW5kOwogCXU4IGFjdDsKIAotCWlmIChhY3Rpb24tPmRhdGEgPT0gTlVMTCB8fCBhY3Rpb24tPmxlbiA9PSAwKQorCWlmIChsZW4gPCBJRUVFODAyMTFfSERSTEVOICsgMikKIAkJcmV0dXJuOwogCi0JcG9zID0gYWN0aW9uLT5kYXRhOwotCWVuZCA9IHBvcyArIGFjdGlvbi0+bGVuOworCXBvcyA9ICgoY29uc3QgdTggKikgbWdtdCkgKyBJRUVFODAyMTFfSERSTEVOICsgMTsKIAlhY3QgPSAqcG9zKys7CisJZW5kID0gKChjb25zdCB1OCAqKSBtZ210KSArIGxlbjsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBSWCBhY3Rpb24gJXUgZnJvbSAiIE1BQ1NUUiwKLQkJICAgYWN0LCBNQUMyU1RSKGFjdGlvbi0+c2EpKTsKKwkJICAgYWN0LCBNQUMyU1RSKG1nbXQtPnNhKSk7CiAJaWYgKHdwYV9zLT53cGFfc3RhdGUgPCBXUEFfQVNTT0NJQVRFRCB8fAotCSAgICBvc19tZW1jbXAoYWN0aW9uLT5zYSwgd3BhX3MtPmJzc2lkLCBFVEhfQUxFTikgIT0gMCkgeworCSAgICBvc19tZW1jbXAobWdtdC0+c2EsIHdwYV9zLT5ic3NpZCwgRVRIX0FMRU4pICE9IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXTk06IElnbm9yZSB1bmV4cGVjdGVkIFdOTSBBY3Rpb24gIgogCQkJICAgImZyYW1lIik7CiAJCXJldHVybjsKQEAgLTc1NiwxMCArOTM3LDEzIEBACiAJc3dpdGNoIChhY3QpIHsKIAljYXNlIFdOTV9CU1NfVFJBTlNfTUdNVF9SRVE6CiAJCWllZWU4MDJfMTFfcnhfYnNzX3RyYW5zX21nbXRfcmVxKHdwYV9zLCBwb3MsIGVuZCwKLQkJCQkJCSAhKGFjdGlvbi0+ZGFbMF0gJiAweDAxKSk7CisJCQkJCQkgIShtZ210LT5kYVswXSAmIDB4MDEpKTsKIAkJYnJlYWs7CiAJY2FzZSBXTk1fU0xFRVBfTU9ERV9SRVNQOgotCQlpZWVlODAyXzExX3J4X3dubXNsZWVwX3Jlc3Aod3BhX3MsIGFjdGlvbi0+ZGF0YSwgYWN0aW9uLT5sZW4pOworCQlpZWVlODAyXzExX3J4X3dubXNsZWVwX3Jlc3Aod3BhX3MsIHBvcywgZW5kIC0gcG9zKTsKKwkJYnJlYWs7CisJY2FzZSBXTk1fTk9USUZJQ0FUSU9OX1JFUToKKwkJaWVlZTgwMl8xMV9yeF93bm1fbm90aWZfcmVxKHdwYV9zLCBtZ210LT5zYSwgcG9zLCBlbmQgLSBwb3MpOwogCQlicmVhazsKIAlkZWZhdWx0OgogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIldOTTogVW5rbm93biByZXF1ZXN0Iik7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93bm1fc3RhLmggYi93cGFfc3VwcGxpY2FudC93bm1fc3RhLmgKaW5kZXggMjkzMzkyNi4uZDJlYjk2ZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvd25tX3N0YS5oCisrKyBiL3dwYV9zdXBwbGljYW50L3dubV9zdGEuaApAQCAtOSw1MiArOSw0MSBAQAogI2lmbmRlZiBXTk1fU1RBX0gKICNkZWZpbmUgV05NX1NUQV9ICiAKLXN0cnVjdCByeF9hY3Rpb247Ci1zdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQ7Ci0KIHN0cnVjdCB0c2ZfaW5mbyB7Ci0JdTggcHJlc2VudDsKIAl1OCB0c2Zfb2Zmc2V0WzJdOwogCXU4IGJlYWNvbl9pbnRlcnZhbFsyXTsKIH07CiAKIHN0cnVjdCBjb25kZW5zZWRfY291bnRyeV9zdHJpbmcgewotCXU4IHByZXNlbnQ7CiAJdTggY291bnRyeV9zdHJpbmdbMl07CiB9OwogCiBzdHJ1Y3QgYnNzX3RyYW5zaXRpb25fY2FuZGlkYXRlIHsKLQl1OCBwcmVzZW50OwogCXU4IHByZWZlcmVuY2U7CiB9OwogCiBzdHJ1Y3QgYnNzX3Rlcm1pbmF0aW9uX2R1cmF0aW9uIHsKLQl1OCBwcmVzZW50OwotCXU4IGR1cmF0aW9uWzEyXTsKKwl1OCBkdXJhdGlvblsxMF07CiB9OwogCiBzdHJ1Y3QgYmVhcmluZyB7Ci0JdTggcHJlc2VudDsKIAl1OCBiZWFyaW5nWzhdOwogfTsKIAogc3RydWN0IG1lYXN1cmVtZW50X3BpbG90IHsKLQl1OCBwcmVzZW50OwogCXU4IG1lYXN1cmVtZW50X3BpbG90OwotCXU4IG51bV92ZW5kb3Jfc3BlY2lmaWM7Ci0JdTggdmVuZG9yX3NwZWNpZmljWzI1NV07CisJdTggc3ViZWxlbV9sZW47CisJdTggc3ViZWxlbXNbMjU1XTsKIH07CiAKIHN0cnVjdCBycm1fZW5hYmxlZF9jYXBhYmlsaXRpZXMgewotCXU4IHByZXNlbnQ7Ci0JdTggY2FwYWJpbGl0aWVzWzRdOworCXU4IGNhcGFiaWxpdGllc1s1XTsKIH07CiAKIHN0cnVjdCBtdWx0aXBsZV9ic3NpZCB7Ci0JdTggcHJlc2VudDsKIAl1OCBtYXhfYnNzaWRfaW5kaWNhdG9yOwotCXU4IG51bV92ZW5kb3Jfc3BlY2lmaWM7Ci0JdTggdmVuZG9yX3NwZWNpZmljWzI1NV07CisJdTggc3ViZWxlbV9sZW47CisJdTggc3ViZWxlbXNbMjU1XTsKIH07CiAKIHN0cnVjdCBuZWlnaGJvcl9yZXBvcnQgewpAQCAtNzgsNyArNjcsNyBAQAogCQkJCSB1OCBhY3Rpb24sIHUxNiBpbnR2YWwsIHN0cnVjdCB3cGFidWYgKnRmc19yZXEpOwogCiB2b2lkIGllZWU4MDJfMTFfcnhfd25tX2FjdGlvbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJICAgICAgc3RydWN0IHJ4X2FjdGlvbiAqYWN0aW9uKTsKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdCwgc2l6ZV90IGxlbik7CiAKIHZvaWQgd25tX3NjYW5fcmVzcG9uc2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJICAgICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3Jlcyk7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93cGFfY2xpLmMgYi93cGFfc3VwcGxpY2FudC93cGFfY2xpLmMKaW5kZXggYTM3OWQ2NS4uMGFkNjE4NyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvd3BhX2NsaS5jCisrKyBiL3dwYV9zdXBwbGljYW50L3dwYV9jbGkuYwpAQCAtMjgsNyArMjgsNyBAQAogCiBzdGF0aWMgY29uc3QgY2hhciAqd3BhX2NsaV92ZXJzaW9uID0KICJ3cGFfY2xpIHYiIFZFUlNJT05fU1RSICJcbiIKLSJDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4gYW5kIGNvbnRyaWJ1dG9ycyI7CisiQ29weXJpZ2h0IChjKSAyMDA0LTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+IGFuZCBjb250cmlidXRvcnMiOwogCiAKIHN0YXRpYyBjb25zdCBjaGFyICp3cGFfY2xpX2xpY2Vuc2UgPQpAQCAtNDk2LDYgKzQ5Niw4IEBACiAJCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsICJTVEFUVVMtVkVSQk9TRSIpOwogCWlmIChhcmdjID4gMCAmJiBvc19zdHJjbXAoYXJndlswXSwgIndwcyIpID09IDApCiAJCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsICJTVEFUVVMtV1BTIik7CisJaWYgKGFyZ2MgPiAwICYmIG9zX3N0cmNtcChhcmd2WzBdLCAiZHJpdmVyIikgPT0gMCkKKwkJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgIlNUQVRVUy1EUklWRVIiKTsKIAlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCAiU1RBVFVTIik7CiB9CiAKQEAgLTYxMyw3ICs2MTUsOSBAQAogCQkicDJwX29wZXJfcmVnX2NsYXNzIiwgInAycF9vcGVyX2NoYW5uZWwiLAogCQkicDJwX2dvX2ludGVudCIsICJwMnBfc3NpZF9wb3N0Zml4IiwgInBlcnNpc3RlbnRfcmVjb25uZWN0IiwKIAkJInAycF9pbnRyYV9ic3MiLCAicDJwX2dyb3VwX2lkbGUiLCAicDJwX3ByZWZfY2hhbiIsCisJCSJwMnBfbm9fZ29fZnJlcSIsCiAJCSJwMnBfZ29faHQ0MCIsICJwMnBfZGlzYWJsZWQiLCAicDJwX25vX2dyb3VwX2lmYWNlIiwKKwkJInAycF9nb192aHQiLAogCQkicDJwX2lnbm9yZV9zaGFyZWRfZnJlcSIsICJjb3VudHJ5IiwgImJzc19tYXhfY291bnQiLAogCQkiYnNzX2V4cGlyYXRpb25fYWdlIiwgImJzc19leHBpcmF0aW9uX3NjYW5fY291bnQiLAogCQkiZmlsdGVyX3NzaWRzIiwgImZpbHRlcl9yc3NpIiwgIm1heF9udW1fc3RhIiwKQEAgLTYyMyw5ICs2MjcsMTAgQEAKIAkJIndwc19uZmNfZGV2X3B3IiwgImV4dF9wYXNzd29yZF9iYWNrZW5kIiwKIAkJInAycF9nb19tYXhfaW5hY3Rpdml0eSIsICJhdXRvX2ludGVyd29ya2luZyIsICJva2MiLCAicG1mIiwKIAkJInNhZV9ncm91cHMiLCAiZHRpbV9wZXJpb2QiLCAiYmVhY29uX2ludCIsICJhcF92ZW5kb3JfZWxlbWVudHMiLAotCQkiaWdub3JlX29sZF9zY2FuX3JlcyIsICJmcmVxX2xpc3QiCisJCSJpZ25vcmVfb2xkX3NjYW5fcmVzIiwgImZyZXFfbGlzdCIsICJleHRlcm5hbF9zaW0iLAorCQkidGRsc19leHRlcm5hbF9jb250cm9sIiwgInAycF9zZWFyY2hfZGVsYXkiCiAJfTsKLQlpbnQgaSwgbnVtX2ZpZWxkcyA9IHNpemVvZihmaWVsZHMpIC8gc2l6ZW9mKGZpZWxkc1swXSk7CisJaW50IGksIG51bV9maWVsZHMgPSBBUlJBWV9TSVpFKGZpZWxkcyk7CiAKIAlpZiAoYXJnID09IDEpIHsKIAkJY2hhciAqKnJlcyA9IG9zX2NhbGxvYyhudW1fZmllbGRzICsgMSwgc2l6ZW9mKGNoYXIgKikpOwpAQCAtNjcxLDYgKzY3NiwxMiBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX2NsaV9jbWRfcmVhdHRhY2goc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQoreworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsICJSRUFUVEFDSCIpOworfQorCisKIHN0YXRpYyBpbnQgd3BhX2NsaV9jbWRfcHJlYXV0aGVudGljYXRlKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCiAJCQkJICAgICAgIGNoYXIgKmFyZ3ZbXSkKIHsKQEAgLTgzMSw1OCArODQyLDYgQEAKIH0KIAogCi1zdGF0aWMgaW50IHdwYV9jbGlfY21kX25mY19yeF9oYW5kb3Zlcl9yZXEoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKLQkJCQkJICAgY2hhciAqYXJndltdKQotewotCWludCByZXQ7Ci0JY2hhciAqYnVmOwotCXNpemVfdCBidWZsZW47Ci0KLQlpZiAoYXJnYyAhPSAxKSB7Ci0JCXByaW50ZigiSW52YWxpZCAnbmZjX3J4X2hhbmRvdmVyX3JlcScgY29tbWFuZCAtIG9uZSBhcmd1bWVudCAiCi0JCSAgICAgICAiaXMgcmVxdWlyZWQuXG4iKTsKLQkJcmV0dXJuIC0xOwotCX0KLQotCWJ1ZmxlbiA9IDIxICsgb3Nfc3RybGVuKGFyZ3ZbMF0pOwotCWJ1ZiA9IG9zX21hbGxvYyhidWZsZW4pOwotCWlmIChidWYgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwotCW9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiTkZDX1JYX0hBTkRPVkVSX1JFUSAlcyIsIGFyZ3ZbMF0pOwotCi0JcmV0ID0gd3BhX2N0cmxfY29tbWFuZChjdHJsLCBidWYpOwotCW9zX2ZyZWUoYnVmKTsKLQotCXJldHVybiByZXQ7Ci19Ci0KLQotc3RhdGljIGludCB3cGFfY2xpX2NtZF9uZmNfcnhfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCi0JCQkJCSAgIGNoYXIgKmFyZ3ZbXSkKLXsKLQlpbnQgcmV0OwotCWNoYXIgKmJ1ZjsKLQlzaXplX3QgYnVmbGVuOwotCi0JaWYgKGFyZ2MgIT0gMSkgewotCQlwcmludGYoIkludmFsaWQgJ25mY19yeF9oYW5kb3Zlcl9zZWwnIGNvbW1hbmQgLSBvbmUgYXJndW1lbnQgIgotCQkgICAgICAgImlzIHJlcXVpcmVkLlxuIik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlidWZsZW4gPSAyMSArIG9zX3N0cmxlbihhcmd2WzBdKTsKLQlidWYgPSBvc19tYWxsb2MoYnVmbGVuKTsKLQlpZiAoYnVmID09IE5VTEwpCi0JCXJldHVybiAtMTsKLQlvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIk5GQ19SWF9IQU5ET1ZFUl9TRUwgJXMiLCBhcmd2WzBdKTsKLQotCXJldCA9IHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgYnVmKTsKLQlvc19mcmVlKGJ1Zik7Ci0KLQlyZXR1cm4gcmV0OwotfQotCi0KIHN0YXRpYyBpbnQgd3BhX2NsaV9jbWRfbmZjX3JlcG9ydF9oYW5kb3ZlcihzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLAogCQkJCQkgICBjaGFyICphcmd2W10pCiB7CkBAIC0xMjY4LDYgKzEyMjcsMzggQEAKIH0KIAogCitzdGF0aWMgaW50IHdwYV9jbGlfY21kX3NpbShzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLCBjaGFyICphcmd2W10pCit7CisJY2hhciBjbWRbMjU2XSwgKnBvcywgKmVuZDsKKwlpbnQgaSwgcmV0OworCisJaWYgKGFyZ2MgPCAyKSB7CisJCXByaW50ZigiSW52YWxpZCBTSU0gY29tbWFuZDogbmVlZHMgdHdvIGFyZ3VtZW50cyAiCisJCSAgICAgICAiKG5ldHdvcmsgaWQgYW5kIFNJTSBvcGVyYXRpb24gcmVzcG9uc2UpXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWVuZCA9IGNtZCArIHNpemVvZihjbWQpOworCXBvcyA9IGNtZDsKKwlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgV1BBX0NUUkxfUlNQICJTSU0tJXM6JXMiLAorCQkJICBhcmd2WzBdLCBhcmd2WzFdKTsKKwlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKSB7CisJCXByaW50ZigiVG9vIGxvbmcgU0lNIGNvbW1hbmQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlwb3MgKz0gcmV0OworCWZvciAoaSA9IDI7IGkgPCBhcmdjOyBpKyspIHsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgJXMiLCBhcmd2W2ldKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykgeworCQkJcHJpbnRmKCJUb28gbG9uZyBTSU0gY29tbWFuZC5cbiIpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXBvcyArPSByZXQ7CisJfQorCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGNtZCk7Cit9CisKKwogc3RhdGljIGludCB3cGFfY2xpX2NtZF9wYXNzcGhyYXNlKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCiAJCQkJICBjaGFyICphcmd2W10pCiB7CkBAIC0xNDI1LDYgKzE0MTYsMjQgQEAKIH0KIAogCitzdGF0aWMgaW50IHdwYV9jbGlfY21kX2R1cF9uZXR3b3JrKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJICAgY2hhciAqYXJndltdKQoreworCWlmIChhcmdjID09IDApIHsKKwkJd3BhX2NsaV9zaG93X25ldHdvcmtfdmFyaWFibGVzKCk7CisJCXJldHVybiAwOworCX0KKworCWlmIChhcmdjIDwgMykgeworCQlwcmludGYoIkludmFsaWQgRFVQX05FVFdPUksgY29tbWFuZDogbmVlZHMgdGhyZWUgYXJndW1lbnRzXG4iCisJCSAgICAgICAiKHNyYyBuZXRpZCwgZGVzdCBuZXRpZCwgYW5kIHZhcmlhYmxlIG5hbWUpXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiB3cGFfY2xpX2NtZChjdHJsLCAiRFVQX05FVFdPUksiLCAzLCBhcmdjLCBhcmd2KTsKK30KKworCiBzdGF0aWMgaW50IHdwYV9jbGlfY21kX2xpc3RfY3JlZHMoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKIAkJCQkgIGNoYXIgKmFyZ3ZbXSkKIHsKQEAgLTE0NTcsNiArMTQ2NiwxOCBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX2NsaV9jbWRfZ2V0X2NyZWQoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQoreworCWlmIChhcmdjICE9IDIpIHsKKwkJcHJpbnRmKCJJbnZhbGlkIEdFVF9DUkVEIGNvbW1hbmQ6IG5lZWRzIHR3byBhcmd1bWVudHNcbiIKKwkJICAgICAgICIoY3JlZCBpZCwgdmFyaWFibGUgbmFtZSlcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIHdwYV9jbGlfY21kKGN0cmwsICJHRVRfQ1JFRCIsIDIsIGFyZ2MsIGFyZ3YpOworfQorCisKIHN0YXRpYyBpbnQgd3BhX2NsaV9jbWRfZGlzY29ubmVjdChzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLAogCQkJCSAgY2hhciAqYXJndltdKQogewpAQCAtMTU0OSw3ICsxNTcwLDcgQEAKIAlvc19mcmVlKGN0cmxfaWZuYW1lKTsKIAljdHJsX2lmbmFtZSA9IG9zX3N0cmR1cChhcmd2WzBdKTsKIAotCWlmICh3cGFfY2xpX29wZW5fY29ubmVjdGlvbihjdHJsX2lmbmFtZSwgMSkpIHsKKwlpZiAod3BhX2NsaV9vcGVuX2Nvbm5lY3Rpb24oY3RybF9pZm5hbWUsIDEpID09IDApIHsKIAkJcHJpbnRmKCJDb25uZWN0ZWQgdG8gaW50ZXJmYWNlICclcy5cbiIsIGN0cmxfaWZuYW1lKTsKIAl9IGVsc2UgewogCQlwcmludGYoIkNvdWxkIG5vdCBjb25uZWN0IHRvIGludGVyZmFjZSAnJXMnIC0gcmUtdHJ5aW5nXG4iLApAQCAtMTY4Nyw2ICsxNzA4LDEzIEBACiB7CiAJcmV0dXJuIHdwYV9jbGlfY21kKGN0cmwsICJESVNBU1NPQ0lBVEUiLCAxLCBhcmdjLCBhcmd2KTsKIH0KKworc3RhdGljIGludCB3cGFfY2xpX2NtZF9jaGFuc3dpdGNoKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJICAgIGNoYXIgKmFyZ3ZbXSkKK3sKKwlyZXR1cm4gd3BhX2NsaV9jbWQoY3RybCwgIkNIQU5fU1dJVENIIiwgMiwgYXJnYywgYXJndik7Cit9CisKICNlbmRpZiAvKiBDT05GSUdfQVAgKi8KIAogCkBAIC0xNzAyLDEwICsxNzMwLDEyIEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKIHN0YXRpYyBpbnQgd3BhX2NsaV9jbWRfZHJvcF9zYShzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLCBjaGFyICphcmd2W10pCiB7CiAJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgIkRST1BfU0EiKTsKIH0KKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCiAKIAogc3RhdGljIGludCB3cGFfY2xpX2NtZF9yb2FtKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKQEAgLTIwNzgsNyArMjEwOCw3IEBACiAJCSJkaXNjX2ludCIsCiAJCSJwZXJfc3RhX3BzayIsCiAJfTsKLQlpbnQgaSwgbnVtX2ZpZWxkcyA9IHNpemVvZihmaWVsZHMpIC8gc2l6ZW9mKGZpZWxkc1swXSk7CisJaW50IGksIG51bV9maWVsZHMgPSBBUlJBWV9TSVpFKGZpZWxkcyk7CiAKIAlpZiAoYXJnID09IDEpIHsKIAkJY2hhciAqKnJlcyA9IG9zX2NhbGxvYyhudW1fZmllbGRzICsgMSwgc2l6ZW9mKGNoYXIgKikpOwpAQCAtMjI4MCw2ICsyMzEwLDM3IEBACiAJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgY21kKTsKIH0KIAorCitzdGF0aWMgaW50IHdwYV9jbGlfY21kX2hzMjBfaWNvbl9yZXF1ZXN0KHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJCSBjaGFyICphcmd2W10pCit7CisJY2hhciBjbWRbNTEyXTsKKworCWlmIChhcmdjIDwgMikgeworCQlwcmludGYoIkNvbW1hbmQgbmVlZHMgdHdvIGFyZ3VtZW50cyAoZHN0IG1hYyBhZGRyIGFuZCAiCisJCSAgICAgICAiaWNvbiBuYW1lKVxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAod3JpdGVfY21kKGNtZCwgc2l6ZW9mKGNtZCksICJIUzIwX0lDT05fUkVRVUVTVCIsIGFyZ2MsIGFyZ3YpIDwgMCkKKwkJcmV0dXJuIC0xOworCisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgY21kKTsKK30KKworCitzdGF0aWMgaW50IHdwYV9jbGlfY21kX2ZldGNoX29zdShzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLCBjaGFyICphcmd2W10pCit7CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgIkZFVENIX09TVSIpOworfQorCisKK3N0YXRpYyBpbnQgd3BhX2NsaV9jbWRfY2FuY2VsX2ZldGNoX29zdShzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLAorCQkJCQljaGFyICphcmd2W10pCit7CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgIkNBTkNFTF9GRVRDSF9PU1UiKTsKK30KKwogI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAKIApAQCAtMjM3MiwyMyArMjQzMywxNSBAQAogI2lmZGVmIEFORFJPSUQKIHN0YXRpYyBpbnQgd3BhX2NsaV9jbWRfZHJpdmVyKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIHsKLQljaGFyIGNtZFsyNTZdOwotCWludCBpOwotCWludCBsZW47Ci0KLQlpZiAoYXJnYyA8IDEpIHsKLQkJcHJpbnRmKCJJbnZhbGlkIERSSVZFUiBjb21tYW5kOiBuZWVkcyBvbmUgYXJndW1lbnQgKGNtZClcbiIpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JbGVuID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIkRSSVZFUiAlcyIsIGFyZ3ZbMF0pOwotCWZvciAoaT0xOyBpIDwgYXJnYzsgaSsrKQotCQlsZW4gKz0gb3Nfc25wcmludGYoY21kICsgbGVuLCBzaXplb2YoY21kKSAtIGxlbiwgIiAlcyIsIGFyZ3ZbaV0pOwotCWNtZFtzaXplb2YoY21kKSAtIDFdID0gJ1wwJzsKLQlwcmludGYoIiVzOiAlc1xuIiwgX19mdW5jX18sIGNtZCk7Ci0JcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgY21kKTsKKwlyZXR1cm4gd3BhX2NsaV9jbWQoY3RybCwgIkRSSVZFUiIsIDEsIGFyZ2MsIGFyZ3YpOwogfQotI2VuZGlmCisjZW5kaWYgLyogQU5EUk9JRCAqLworCisKK3N0YXRpYyBpbnQgd3BhX2NsaV9jbWRfdmVuZG9yKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwlyZXR1cm4gd3BhX2NsaV9jbWQoY3RybCwgIlZFTkRPUiIsIDEsIGFyZ2MsIGFyZ3YpOworfQogCiAKIHN0YXRpYyBpbnQgd3BhX2NsaV9jbWRfZmx1c2goc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQpAQCAtMjM5Nyw2ICsyNDUwLDEyIEBACiB9CiAKIAorc3RhdGljIGludCB3cGFfY2xpX2NtZF9yYWRpb193b3JrKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwlyZXR1cm4gd3BhX2NsaV9jbWQoY3RybCwgIlJBRElPX1dPUksiLCAxLCBhcmdjLCBhcmd2KTsKK30KKworCiBlbnVtIHdwYV9jbGlfY21kX2ZsYWdzIHsKIAljbGlfY21kX2ZsYWdfbm9uZQkJPSAweDAwLAogCWNsaV9jbWRfZmxhZ19zZW5zaXRpdmUJCT0gMHgwMQpAQCAtMjQ2Myw2ICsyNTIyLDkgQEAKIAl7ICJyZWFzc29jaWF0ZSIsIHdwYV9jbGlfY21kX3JlYXNzb2NpYXRlLCBOVUxMLAogCSAgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPSBmb3JjZSByZWFzc29jaWF0aW9uIiB9LAorCXsgInJlYXR0YWNoIiwgd3BhX2NsaV9jbWRfcmVhdHRhY2gsIE5VTEwsCisJICBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI9IGZvcmNlIHJlYXNzb2NpYXRpb24gYmFjayB0byB0aGUgc2FtZSBCU1MiIH0sCiAJeyAicHJlYXV0aGVudGljYXRlIiwgd3BhX2NsaV9jbWRfcHJlYXV0aGVudGljYXRlLCB3cGFfY2xpX2NvbXBsZXRlX2JzcywKIAkgIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIjxCU1NJRD4gPSBmb3JjZSBwcmVhdXRoZW50aWNhdGlvbiIgfSwKQEAgLTI0ODYsNiArMjU0OCw5IEBACiAJICBjbGlfY21kX2ZsYWdfc2Vuc2l0aXZlLAogCSAgIjxuZXR3b3JrIGlkPiA8cGFzc3BocmFzZT4gPSBjb25maWd1cmUgcHJpdmF0ZSBrZXkgcGFzc3BocmFzZVxuIgogCSAgIiAgZm9yIGFuIFNTSUQiIH0sCisJeyAic2ltIiwgd3BhX2NsaV9jbWRfc2ltLCBOVUxMLAorCSAgY2xpX2NtZF9mbGFnX3NlbnNpdGl2ZSwKKwkgICI8bmV0d29yayBpZD4gPHBpbj4gPSByZXBvcnQgU0lNIG9wZXJhdGlvbiByZXN1bHQiIH0sCiAJeyAiYnNzaWQiLCB3cGFfY2xpX2NtZF9ic3NpZCwgTlVMTCwKIAkgIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIjxuZXR3b3JrIGlkPiA8QlNTSUQ+ID0gc2V0IHByZWZlcnJlZCBCU1NJRCBmb3IgYW4gU1NJRCIgfSwKQEAgLTI1MjMsNiArMjU4OCwxMCBAQAogCXsgImdldF9uZXR3b3JrIiwgd3BhX2NsaV9jbWRfZ2V0X25ldHdvcmssIE5VTEwsCiAJICBjbGlfY21kX2ZsYWdfbm9uZSwKIAkgICI8bmV0d29yayBpZD4gPHZhcmlhYmxlPiA9IGdldCBuZXR3b3JrIHZhcmlhYmxlcyIgfSwKKwl7ICJkdXBfbmV0d29yayIsIHdwYV9jbGlfY21kX2R1cF9uZXR3b3JrLCBOVUxMLAorCSAgY2xpX2NtZF9mbGFnX25vbmUsCisJICAiPHNyYyBuZXR3b3JrIGlkPiA8ZHN0IG5ldHdvcmsgaWQ+IDx2YXJpYWJsZT4gPSBkdXBsaWNhdGUgbmV0d29yayB2YXJpYWJsZXMiCisJfSwKIAl7ICJsaXN0X2NyZWRzIiwgd3BhX2NsaV9jbWRfbGlzdF9jcmVkcywgTlVMTCwKIAkgIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIj0gbGlzdCBjb25maWd1cmVkIGNyZWRlbnRpYWxzIiB9LApAQCAtMjUzNSw2ICsyNjA0LDkgQEAKIAl7ICJzZXRfY3JlZCIsIHdwYV9jbGlfY21kX3NldF9jcmVkLCBOVUxMLAogCSAgY2xpX2NtZF9mbGFnX3NlbnNpdGl2ZSwKIAkgICI8Y3JlZCBpZD4gPHZhcmlhYmxlPiA8dmFsdWU+ID0gc2V0IGNyZWRlbnRpYWwgdmFyaWFibGVzIiB9LAorCXsgImdldF9jcmVkIiwgd3BhX2NsaV9jbWRfZ2V0X2NyZWQsIE5VTEwsCisJICBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI8Y3JlZCBpZD4gPHZhcmlhYmxlPiA9IGdldCBjcmVkZW50aWFsIHZhcmlhYmxlcyIgfSwKIAl7ICJzYXZlX2NvbmZpZyIsIHdwYV9jbGlfY21kX3NhdmVfY29uZmlnLCBOVUxMLAogCSAgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPSBzYXZlIHRoZSBjdXJyZW50IGNvbmZpZ3VyYXRpb24iIH0sCkBAIC0yNjI4LDEyICsyNzAwLDYgQEAKIAl7ICJuZmNfZ2V0X2hhbmRvdmVyX3NlbCIsIHdwYV9jbGlfY21kX25mY19nZXRfaGFuZG92ZXJfc2VsLCBOVUxMLAogCSAgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPE5ERUY+IDxXUFM+ID0gY3JlYXRlIE5GQyBoYW5kb3ZlciBzZWxlY3QiIH0sCi0JeyAibmZjX3J4X2hhbmRvdmVyX3JlcSIsIHdwYV9jbGlfY21kX25mY19yeF9oYW5kb3Zlcl9yZXEsIE5VTEwsCi0JICBjbGlfY21kX2ZsYWdfbm9uZSwKLQkgICI8aGV4ZHVtcCBvZiBwYXlsb2FkPiA9IHJlcG9ydCByZWNlaXZlZCBORkMgaGFuZG92ZXIgcmVxdWVzdCIgfSwKLQl7ICJuZmNfcnhfaGFuZG92ZXJfc2VsIiwgd3BhX2NsaV9jbWRfbmZjX3J4X2hhbmRvdmVyX3NlbCwgTlVMTCwKLQkgIGNsaV9jbWRfZmxhZ19ub25lLAotCSAgIjxoZXhkdW1wIG9mIHBheWxvYWQ+ID0gcmVwb3J0IHJlY2VpdmVkIE5GQyBoYW5kb3ZlciBzZWxlY3QiIH0sCiAJeyAibmZjX3JlcG9ydF9oYW5kb3ZlciIsIHdwYV9jbGlfY21kX25mY19yZXBvcnRfaGFuZG92ZXIsIE5VTEwsCiAJICBjbGlfY21kX2ZsYWdfbm9uZSwKIAkgICI8cm9sZT4gPHR5cGU+IDxoZXhkdW1wIG9mIHJlcT4gPGhleGR1bXAgb2Ygc2VsPiA9IHJlcG9ydCBjb21wbGV0ZWQgIgpAQCAtMjY4NywxMyArMjc1MywyMCBAQAogCXsgImRpc2Fzc29jaWF0ZSIsIHdwYV9jbGlfY21kX2Rpc2Fzc29jaWF0ZSwgTlVMTCwKIAkgIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIjxhZGRyPiA9IGRpc2Fzc29jaWF0ZSBhIHN0YXRpb24iIH0sCisJeyAiY2hhbl9zd2l0Y2giLCB3cGFfY2xpX2NtZF9jaGFuc3dpdGNoLCBOVUxMLAorCSAgY2xpX2NtZF9mbGFnX25vbmUsCisJICAiPGNzX2NvdW50PiA8ZnJlcT4gW3NlY19jaGFubmVsX29mZnNldD1dIFtjZW50ZXJfZnJlcTE9XSIKKwkgICIgW2NlbnRlcl9mcmVxMj1dIFtiYW5kd2lkdGg9XSBbYmxvY2t0eF0gW2h0fHZodF0iCisJICAiID0gQ1NBIHBhcmFtZXRlcnMiIH0sCiAjZW5kaWYgLyogQ09ORklHX0FQICovCiAJeyAic3VzcGVuZCIsIHdwYV9jbGlfY21kX3N1c3BlbmQsIE5VTEwsIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIj0gbm90aWZpY2F0aW9uIG9mIHN1c3BlbmQvaGliZXJuYXRlIiB9LAogCXsgInJlc3VtZSIsIHdwYV9jbGlfY21kX3Jlc3VtZSwgTlVMTCwgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPSBub3RpZmljYXRpb24gb2YgcmVzdW1lL3RoYXciIH0sCisjaWZkZWYgQ09ORklHX1RFU1RJTkdfT1BUSU9OUwogCXsgImRyb3Bfc2EiLCB3cGFfY2xpX2NtZF9kcm9wX3NhLCBOVUxMLCBjbGlfY21kX2ZsYWdfbm9uZSwKIAkgICI9IGRyb3AgU0Egd2l0aG91dCBkZWF1dGgvZGlzYXNzb2MgKHRlc3QgY29tbWFuZCkiIH0sCisjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfT1BUSU9OUyAqLwogCXsgInJvYW0iLCB3cGFfY2xpX2NtZF9yb2FtLCB3cGFfY2xpX2NvbXBsZXRlX2JzcywKIAkgIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIjxhZGRyPiA9IHJvYW0gdG8gdGhlIHNwZWNpZmllZCBCU1MiIH0sCkBAIC0yODE2LDYgKzI4ODksMTQgQEAKIAl7ICJuYWlfaG9tZV9yZWFsbV9saXN0Iiwgd3BhX2NsaV9jbWRfZ2V0X25haV9ob21lX3JlYWxtX2xpc3QsCiAJICB3cGFfY2xpX2NvbXBsZXRlX2JzcywgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPGFkZHI+IDxob21lIHJlYWxtPiA9IGdldCBIUzIwIG5haSBob21lIHJlYWxtIGxpc3QiIH0sCisJeyAiaHMyMF9pY29uX3JlcXVlc3QiLCB3cGFfY2xpX2NtZF9oczIwX2ljb25fcmVxdWVzdCwKKwkgIHdwYV9jbGlfY29tcGxldGVfYnNzLCBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI8YWRkcj4gPGljb24gbmFtZT4gPSBnZXQgSG90c3BvdCAyLjAgT1NVIGljb24iIH0sCisJeyAiZmV0Y2hfb3N1Iiwgd3BhX2NsaV9jbWRfZmV0Y2hfb3N1LCBOVUxMLCBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI9IGZldGNoIE9TVSBwcm92aWRlciBpbmZvcm1hdGlvbiBmcm9tIGFsbCBBUHMiIH0sCisJeyAiY2FuY2VsX2ZldGNoX29zdSIsIHdwYV9jbGlfY21kX2NhbmNlbF9mZXRjaF9vc3UsIE5VTEwsCisJICBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI9IGNhbmNlbCBmZXRjaF9vc3UgY29tbWFuZCIgfSwKICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCXsgInN0YV9hdXRvY29ubmVjdCIsIHdwYV9jbGlfY21kX3N0YV9hdXRvY29ubmVjdCwgTlVMTCwKIAkgIGNsaV9jbWRfZmxhZ19ub25lLApAQCAtMjg1MywxMCArMjkzNCwxNCBAQAogCXsgImZsdXNoIiwgd3BhX2NsaV9jbWRfZmx1c2gsIE5VTEwsIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIj0gZmx1c2ggd3BhX3N1cHBsaWNhbnQgc3RhdGUiIH0sCiAjaWZkZWYgQU5EUk9JRAotCXsgImRyaXZlciIsIHdwYV9jbGlfY21kX2RyaXZlciwgTlVMTCwKLQkgIGNsaV9jbWRfZmxhZ19ub25lLAorCXsgImRyaXZlciIsIHdwYV9jbGlfY21kX2RyaXZlciwgTlVMTCwgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPGNvbW1hbmQ+ID0gZHJpdmVyIHByaXZhdGUgY29tbWFuZHMiIH0sCi0jZW5kaWYKKyNlbmRpZiAvKiBBTkRST0lEICovCisJeyAicmFkaW9fd29yayIsIHdwYV9jbGlfY21kX3JhZGlvX3dvcmssIE5VTEwsIGNsaV9jbWRfZmxhZ19ub25lLAorCSAgIj0gcmFkaW9fd29yayA8c2hvdy9hZGQvZG9uZT4iIH0sCisJeyAidmVuZG9yIiwgd3BhX2NsaV9jbWRfdmVuZG9yLCBOVUxMLCBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI8dmVuZG9yIGlkPiA8Y29tbWFuZCBpZD4gWzxoZXggZm9ybWF0dGVkIGNvbW1hbmQgYXJndW1lbnQ+XSA9IFNlbmQgdmVuZG9yIGNvbW1hbmQiCisJfSwKIAl7IE5VTEwsIE5VTEwsIE5VTEwsIGNsaV9jbWRfZmxhZ19ub25lLCBOVUxMIH0KIH07CiAKQEAgLTI5MTcsNyArMzAwMiw3IEBACiAJaW50IGksIGNvdW50OwogCXN0cnVjdCBjbGlfdHh0X2VudHJ5ICplOwogCi0JY291bnQgPSBzaXplb2Yod3BhX2NsaV9jb21tYW5kcykgLyBzaXplb2Yod3BhX2NsaV9jb21tYW5kc1swXSk7CisJY291bnQgPSBBUlJBWV9TSVpFKHdwYV9jbGlfY29tbWFuZHMpOwogCWNvdW50ICs9IGRsX2xpc3RfbGVuKCZwMnBfZ3JvdXBzKTsKIAljb3VudCArPSBkbF9saXN0X2xlbigmaWZuYW1lcyk7CiAJcmVzID0gb3NfY2FsbG9jKGNvdW50ICsgMSwgc2l6ZW9mKGNoYXIgKikpOwpAQCAtMzA2NCwyOCArMzE0OSwxOSBAQAogc3RhdGljIGludCB3cGFfY2xpX2V4ZWMoY29uc3QgY2hhciAqcHJvZ3JhbSwgY29uc3QgY2hhciAqYXJnMSwKIAkJCWNvbnN0IGNoYXIgKmFyZzIpCiB7Ci0JY2hhciAqY21kOworCWNoYXIgKmFyZzsKIAlzaXplX3QgbGVuOwogCWludCByZXM7Ci0JaW50IHJldCA9IDA7CiAKLQlsZW4gPSBvc19zdHJsZW4ocHJvZ3JhbSkgKyBvc19zdHJsZW4oYXJnMSkgKyBvc19zdHJsZW4oYXJnMikgKyAzOwotCWNtZCA9IG9zX21hbGxvYyhsZW4pOwotCWlmIChjbWQgPT0gTlVMTCkKKwlsZW4gPSBvc19zdHJsZW4oYXJnMSkgKyBvc19zdHJsZW4oYXJnMikgKyAyOworCWFyZyA9IG9zX21hbGxvYyhsZW4pOworCWlmIChhcmcgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwotCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgbGVuLCAiJXMgJXMgJXMiLCBwcm9ncmFtLCBhcmcxLCBhcmcyKTsKLQlpZiAocmVzIDwgMCB8fCAoc2l6ZV90KSByZXMgPj0gbGVuKSB7Ci0JCW9zX2ZyZWUoY21kKTsKLQkJcmV0dXJuIC0xOwotCX0KLQljbWRbbGVuIC0gMV0gPSAnXDAnOwotI2lmbmRlZiBfV0lOMzJfV0NFCi0JaWYgKHN5c3RlbShjbWQpIDwgMCkKLQkJcmV0ID0gLTE7Ci0jZW5kaWYgLyogX1dJTjMyX1dDRSAqLwotCW9zX2ZyZWUoY21kKTsKKwlvc19zbnByaW50ZihhcmcsIGxlbiwgIiVzICVzIiwgYXJnMSwgYXJnMik7CisJcmVzID0gb3NfZXhlYyhwcm9ncmFtLCBhcmcsIDEpOworCW9zX2ZyZWUoYXJnKTsKIAotCXJldHVybiByZXQ7CisJcmV0dXJuIHJlczsKIH0KIAogCkBAIC0zMTY1LDYgKzMyNDEsMTAgQEAKIAkJd3BhX2NsaV9leGVjKGFjdGlvbl9maWxlLCBjdHJsX2lmbmFtZSwgcG9zKTsKIAl9IGVsc2UgaWYgKHN0cl9tYXRjaChwb3MsIEVTU19ESVNBU1NPQ19JTU1JTkVOVCkpIHsKIAkJd3BhX2NsaV9leGVjKGFjdGlvbl9maWxlLCBjdHJsX2lmbmFtZSwgcG9zKTsKKwl9IGVsc2UgaWYgKHN0cl9tYXRjaChwb3MsIEhTMjBfU1VCU0NSSVBUSU9OX1JFTUVESUFUSU9OKSkgeworCQl3cGFfY2xpX2V4ZWMoYWN0aW9uX2ZpbGUsIGN0cmxfaWZuYW1lLCBwb3MpOworCX0gZWxzZSBpZiAoc3RyX21hdGNoKHBvcywgSFMyMF9ERUFVVEhfSU1NSU5FTlRfTk9USUNFKSkgeworCQl3cGFfY2xpX2V4ZWMoYWN0aW9uX2ZpbGUsIGN0cmxfaWZuYW1lLCBwb3MpOwogCX0gZWxzZSBpZiAoc3RyX21hdGNoKHBvcywgV1BBX0VWRU5UX1RFUk1JTkFUSU5HKSkgewogCQlwcmludGYoIndwYV9zdXBwbGljYW50IGlzIHRlcm1pbmF0aW5nIC0gc3RvcCBtb25pdG9yaW5nXG4iKTsKIAkJd3BhX2NsaV9xdWl0ID0gMTsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYV9wcml2LmMgYi93cGFfc3VwcGxpY2FudC93cGFfcHJpdi5jCmluZGV4IDRhZmFhZTkuLjU0MjYxNzcgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwYV9wcml2LmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BhX3ByaXYuYwpAQCAtNTUyLDggKzU1Miw2IEBACiB9CiAKIAotZXh0ZXJuIHN0cnVjdCB3cGFfZHJpdmVyX29wcyAqd3BhX2RyaXZlcnNbXTsKLQogc3RhdGljIHN0cnVjdCB3cGFfcHJpdl9pbnRlcmZhY2UgKgogd3BhX3ByaXZfaW50ZXJmYWNlX2luaXQoY29uc3QgY2hhciAqZGlyLCBjb25zdCBjaGFyICpwYXJhbXMpCiB7CkBAIC05NDYsOCArOTQ0LDYgQEAKIH0KIAogCi1leHRlcm4gaW50IHdwYV9kZWJ1Z19sZXZlbDsKLQogaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIHsKIAlpbnQgYywgaTsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50LmMgYi93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudC5jCmluZGV4IGI0MzE2NjIuLjlkMjFmZTAgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50LmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnQuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBXUEEgU3VwcGxpY2FudAotICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNTEsMTAgKzUxLDExIEBACiAjaW5jbHVkZSAib2ZmY2hhbm5lbC5oIgogI2luY2x1ZGUgImhzMjBfc3VwcGxpY2FudC5oIgogI2luY2x1ZGUgIndubV9zdGEuaCIKKyNpbmNsdWRlICJ3cGFzX2theS5oIgogCiBjb25zdCBjaGFyICp3cGFfc3VwcGxpY2FudF92ZXJzaW9uID0KICJ3cGFfc3VwcGxpY2FudCB2IiBWRVJTSU9OX1NUUiAiXG4iCi0iQ29weXJpZ2h0IChjKSAyMDAzLTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+IGFuZCBjb250cmlidXRvcnMiOworIkNvcHlyaWdodCAoYykgMjAwMy0yMDE0LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPiBhbmQgY29udHJpYnV0b3JzIjsKIAogY29uc3QgY2hhciAqd3BhX3N1cHBsaWNhbnRfbGljZW5zZSA9CiAiVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS5cbiIKQEAgLTEwNCwxMCArMTA1LDggQEAKICJcbiI7CiAjZW5kaWYgLyogQ09ORklHX05PX1NURE9VVF9ERUJVRyAqLwogCi1leHRlcm4gaW50IHdwYV9kZWJ1Z19sZXZlbDsKLWV4dGVybiBpbnQgd3BhX2RlYnVnX3Nob3dfa2V5czsKLWV4dGVybiBpbnQgd3BhX2RlYnVnX3RpbWVzdGFtcDsKLWV4dGVybiBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgKndwYV9kcml2ZXJzW107CitzdHJ1Y3Qgd293bGFuX3RyaWdnZXJzICp3cGFfZ2V0X3dvd2xhbl90cmlnZ2Vycyhjb25zdCBjaGFyICp3b3dsYW5fdHJpZ2dlcnMsCisJCQkJCQlzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhKTsKIAogLyogQ29uZmlndXJlIGRlZmF1bHQvZ3JvdXAgV0VQIGtleXMgZm9yIHN0YXRpYyBXRVAgKi8KIGludCB3cGFfc2V0X3dlcF9rZXlzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKQEAgLTIwMCw4ICsxOTksNiBAQAogCSAqIFNvLCB3YWl0IGEgc2Vjb25kIHVudGlsIHNjYW5uaW5nIGFnYWluLgogCSAqLwogCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAxLCAwKTsKLQotCXdwYXNfcDJwX2NvbnRpbnVlX2FmdGVyX3NjYW4od3BhX3MpOwogfQogCiAKQEAgLTIxNyw3ICsyMTQsNyBAQAogdm9pZCB3cGFfc3VwcGxpY2FudF9yZXFfYXV0aF90aW1lb3V0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJICAgICBpbnQgc2VjLCBpbnQgdXNlYykKIHsKLQlpZiAod3BhX3MtPmNvbmYgJiYgd3BhX3MtPmNvbmYtPmFwX3NjYW4gPT0gMCAmJgorCWlmICh3cGFfcy0+Y29uZi0+YXBfc2NhbiA9PSAwICYmCiAJICAgICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19XSVJFRCkpCiAJCXJldHVybjsKIApAQCAtMjkzLDE4ICsyOTAsMjAgQEAKIAkJCQlFQVBPTF9SRVFVSVJFX0tFWV9CUk9BRENBU1Q7CiAJCX0KIAotCQlpZiAod3BhX3MtPmNvbmYgJiYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1dJUkVEKSkKKwkJaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1dJUkVEKQogCQkJZWFwb2xfY29uZi5yZXF1aXJlZF9rZXlzID0gMDsKIAl9Ci0JaWYgKHdwYV9zLT5jb25mKQotCQllYXBvbF9jb25mLmZhc3RfcmVhdXRoID0gd3BhX3MtPmNvbmYtPmZhc3RfcmVhdXRoOworCWVhcG9sX2NvbmYuZmFzdF9yZWF1dGggPSB3cGFfcy0+Y29uZi0+ZmFzdF9yZWF1dGg7CiAJZWFwb2xfY29uZi53b3JrYXJvdW5kID0gc3NpZC0+ZWFwX3dvcmthcm91bmQ7CiAJZWFwb2xfY29uZi5lYXBfZGlzYWJsZWQgPQogCQkhd3BhX2tleV9tZ210X3dwYV9pZWVlODAyMXgod3BhX3MtPmtleV9tZ210KSAmJgogCQl3cGFfcy0+a2V5X21nbXQgIT0gV1BBX0tFWV9NR01UX0lFRUU4MDIxWF9OT19XUEEgJiYKIAkJd3BhX3MtPmtleV9tZ210ICE9IFdQQV9LRVlfTUdNVF9XUFM7CisJZWFwb2xfY29uZi5leHRlcm5hbF9zaW0gPSB3cGFfcy0+Y29uZi0+ZXh0ZXJuYWxfc2ltOwogCWVhcG9sX3NtX25vdGlmeV9jb25maWcod3BhX3MtPmVhcG9sLCAmc3NpZC0+ZWFwLCAmZWFwb2xfY29uZik7CiAjZW5kaWYgLyogSUVFRTgwMjFYX0VBUE9MICovCisKKwlpZWVlODAyXzF4X2FsbG9jX2theV9zbSh3cGFfcywgc3NpZCk7CiB9CiAKIApAQCAtMzc5LDYgKzM3OCw4IEBACiAKIHN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X2NsZWFudXAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKKwlpbnQgaTsKKwogCWJnc2Nhbl9kZWluaXQod3BhX3MpOwogCWF1dG9zY2FuX2RlaW5pdCh3cGFfcyk7CiAJc2NhcmRfZGVpbml0KHdwYV9zLT5zY2FyZCk7CkBAIC00MDQsNiArNDA1LDExIEBACiAJb3NfZnJlZSh3cGFfcy0+Y29uZmFub3RoZXIpOwogCXdwYV9zLT5jb25mYW5vdGhlciA9IE5VTEw7CiAKKyNpZmRlZiBDT05GSUdfUDJQCisJb3NfZnJlZSh3cGFfcy0+Y29uZl9wMnBfZGV2KTsKKwl3cGFfcy0+Y29uZl9wMnBfZGV2ID0gTlVMTDsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKIAl3cGFfc21fc2V0X2VhcG9sKHdwYV9zLT53cGEsIE5VTEwpOwogCWVhcG9sX3NtX2RlaW5pdCh3cGFfcy0+ZWFwb2wpOwogCXdwYV9zLT5lYXBvbCA9IE5VTEw7CkBAIC00NDYsOSArNDUyLDcgQEAKIAl3cGFfc3VwcGxpY2FudF9hcF9kZWluaXQod3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19BUCAqLwogCi0jaWZkZWYgQ09ORklHX1AyUAogCXdwYXNfcDJwX2RlaW5pdCh3cGFfcyk7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAjaWZkZWYgQ09ORklHX09GRkNIQU5ORUwKIAlvZmZjaGFubmVsX2RlaW5pdCh3cGFfcyk7CkBAIC00NTksMTEgKzQ2MywxOSBAQAogCW9zX2ZyZWUod3BhX3MtPm5leHRfc2Nhbl9mcmVxcyk7CiAJd3BhX3MtPm5leHRfc2Nhbl9mcmVxcyA9IE5VTEw7CiAKKwlvc19mcmVlKHdwYV9zLT5tYW51YWxfc2Nhbl9mcmVxcyk7CisJd3BhX3MtPm1hbnVhbF9zY2FuX2ZyZXFzID0gTlVMTDsKKworCW9zX2ZyZWUod3BhX3MtPm1hbnVhbF9zY2hlZF9zY2FuX2ZyZXFzKTsKKwl3cGFfcy0+bWFudWFsX3NjaGVkX3NjYW5fZnJlcXMgPSBOVUxMOworCiAJZ2FzX3F1ZXJ5X2RlaW5pdCh3cGFfcy0+Z2FzKTsKIAl3cGFfcy0+Z2FzID0gTlVMTDsKIAogCWZyZWVfaHdfZmVhdHVyZXMod3BhX3MpOwogCisJaWVlZTgwMl8xeF9kZWFsbG9jX2theV9zbSh3cGFfcyk7CisKIAlvc19mcmVlKHdwYV9zLT5ic3NpZF9maWx0ZXIpOwogCXdwYV9zLT5ic3NpZF9maWx0ZXIgPSBOVUxMOwogCkBAIC00ODEsOSArNDkzLDIxIEBACiAJd3BhX3MtPmV4dF9wdyA9IE5VTEw7CiAKIAl3cGFidWZfZnJlZSh3cGFfcy0+bGFzdF9nYXNfcmVzcCk7CisJd3BhX3MtPmxhc3RfZ2FzX3Jlc3AgPSBOVUxMOworCXdwYWJ1Zl9mcmVlKHdwYV9zLT5wcmV2X2dhc19yZXNwKTsKKwl3cGFfcy0+cHJldl9nYXNfcmVzcCA9IE5VTEw7CiAKIAlvc19mcmVlKHdwYV9zLT5sYXN0X3NjYW5fcmVzKTsKIAl3cGFfcy0+bGFzdF9zY2FuX3JlcyA9IE5VTEw7CisKKyNpZmRlZiBDT05GSUdfSFMyMAorCWhzMjBfZGVpbml0KHdwYV9zKTsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLworCisJZm9yIChpID0gMDsgaSA8IE5VTV9WRU5ET1JfRUxFTV9GUkFNRVM7IGkrKykgeworCQl3cGFidWZfZnJlZSh3cGFfcy0+dmVuZG9yX2VsZW1baV0pOworCQl3cGFfcy0+dmVuZG9yX2VsZW1baV0gPSBOVUxMOworCX0KIH0KIAogCkBAIC00OTcsMjkgKzUyMSwyMyBAQAogICovCiB2b2lkIHdwYV9jbGVhcl9rZXlzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICphZGRyKQogewotCWlmICh3cGFfcy0+a2V5c19jbGVhcmVkKSB7Ci0JCS8qIFNvbWUgZHJpdmVycyAoZS5nLiwgbmRpc3dyYXBwZXIgJiBORElTIGRyaXZlcnMpIHNlZW0gdG8gaGF2ZQotCQkgKiB0aW1pbmcgaXNzdWVzIHdpdGgga2V5cyBiZWluZyBjbGVhcmVkIGp1c3QgYmVmb3JlIG5ldyBrZXlzCi0JCSAqIGFyZSBzZXQgb3IganVzdCBhZnRlciBhc3NvY2lhdGlvbiBvciBzb21ldGhpbmcgc2ltaWxhci4gVGhpcwotCQkgKiBzaG93cyB1cCBpbiBncm91cCBrZXkgaGFuZHNoYWtlIGZhaWxpbmcgb2Z0ZW4gYmVjYXVzZSBvZiB0aGUKLQkJICogY2xpZW50IG5vdCByZWNlaXZpbmcgdGhlIGZpcnN0IGVuY3J5cHRlZCBwYWNrZXRzIGNvcnJlY3RseS4KLQkJICogU2tpcHBpbmcgc29tZSBvZiB0aGUgZXh0cmEga2V5IGNsZWFyaW5nIHN0ZXBzIHNlZW1zIHRvIGhlbHAKLQkJICogaW4gY29tcGxldGluZyBncm91cCBrZXkgaGFuZHNoYWtlIG1vcmUgcmVsaWFibHkuICovCi0JCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIk5vIGtleXMgaGF2ZSBiZWVuIGNvbmZpZ3VyZWQgLSAiCi0JCQkic2tpcCBrZXkgY2xlYXJpbmciKTsKLQkJcmV0dXJuOwotCX0KKwlpbnQgaSwgbWF4OworCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKKwltYXggPSA2OworI2Vsc2UgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KKwltYXggPSA0OworI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCiAKIAkvKiBNTE1FLURFTEVURUtFWVMucmVxdWVzdCAqLwotCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBOVUxMLCAwLCAwLCBOVUxMLCAwLCBOVUxMLCAwKTsKLQl3cGFfZHJ2X3NldF9rZXkod3BhX3MsIFdQQV9BTEdfTk9ORSwgTlVMTCwgMSwgMCwgTlVMTCwgMCwgTlVMTCwgMCk7Ci0Jd3BhX2Rydl9zZXRfa2V5KHdwYV9zLCBXUEFfQUxHX05PTkUsIE5VTEwsIDIsIDAsIE5VTEwsIDAsIE5VTEwsIDApOwotCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBOVUxMLCAzLCAwLCBOVUxMLCAwLCBOVUxMLCAwKTsKLSNpZmRlZiBDT05GSUdfSUVFRTgwMjExVwotCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBOVUxMLCA0LCAwLCBOVUxMLCAwLCBOVUxMLCAwKTsKLQl3cGFfZHJ2X3NldF9rZXkod3BhX3MsIFdQQV9BTEdfTk9ORSwgTlVMTCwgNSwgMCwgTlVMTCwgMCwgTlVMTCwgMCk7Ci0jZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KLQlpZiAoYWRkcikgeworCWZvciAoaSA9IDA7IGkgPCBtYXg7IGkrKykgeworCQlpZiAod3BhX3MtPmtleXNfY2xlYXJlZCAmIEJJVChpKSkKKwkJCWNvbnRpbnVlOworCQl3cGFfZHJ2X3NldF9rZXkod3BhX3MsIFdQQV9BTEdfTk9ORSwgTlVMTCwgaSwgMCwgTlVMTCwgMCwKKwkJCQlOVUxMLCAwKTsKKwl9CisJaWYgKCEod3BhX3MtPmtleXNfY2xlYXJlZCAmIEJJVCgwKSkgJiYgYWRkciAmJgorCSAgICAhaXNfemVyb19ldGhlcl9hZGRyKGFkZHIpKSB7CiAJCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBhZGRyLCAwLCAwLCBOVUxMLCAwLCBOVUxMLAogCQkJCTApOwogCQkvKiBNTE1FLVNFVFBST1RFQ1RJT04ucmVxdWVzdChOb25lKSAqLwpAQCAtNTI4LDcgKzU0Niw3IEBACiAJCQlNTE1FX1NFVFBST1RFQ1RJT05fUFJPVEVDVF9UWVBFX05PTkUsCiAJCQlNTE1FX1NFVFBST1RFQ1RJT05fS0VZX1RZUEVfUEFJUldJU0UpOwogCX0KLQl3cGFfcy0+a2V5c19jbGVhcmVkID0gMTsKKwl3cGFfcy0+a2V5c19jbGVhcmVkID0gKHUzMikgLTE7CiB9CiAKIApAQCAtNTcwLDE0ICs1ODgsMjYgQEAKIAogc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfc3RhcnRfYmdzY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CisJY29uc3QgY2hhciAqbmFtZTsKKworCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkICYmIHdwYV9zLT5jdXJyZW50X3NzaWQtPmJnc2NhbikKKwkJbmFtZSA9IHdwYV9zLT5jdXJyZW50X3NzaWQtPmJnc2NhbjsKKwllbHNlCisJCW5hbWUgPSB3cGFfcy0+Y29uZi0+YmdzY2FuOworCWlmIChuYW1lID09IE5VTEwgfHwgbmFtZVswXSA9PSAnXDAnKQorCQlyZXR1cm47CiAJaWYgKHdwYXNfZHJpdmVyX2Jzc19zZWxlY3Rpb24od3BhX3MpKQogCQlyZXR1cm47CiAJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gd3BhX3MtPmJnc2Nhbl9zc2lkKQogCQlyZXR1cm47CisjaWZkZWYgQ09ORklHX1AyUAorCWlmICh3cGFfcy0+cDJwX2dyb3VwX2ludGVyZmFjZSAhPSBOT1RfUDJQX0dST1VQX0lOVEVSRkFDRSkKKwkJcmV0dXJuOworI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCWJnc2Nhbl9kZWluaXQod3BhX3MpOwotCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkICYmIHdwYV9zLT5jdXJyZW50X3NzaWQtPmJnc2NhbikgewotCQlpZiAoYmdzY2FuX2luaXQod3BhX3MsIHdwYV9zLT5jdXJyZW50X3NzaWQpKSB7CisJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQpIHsKKwkJaWYgKGJnc2Nhbl9pbml0KHdwYV9zLCB3cGFfcy0+Y3VycmVudF9zc2lkLCBuYW1lKSkgewogCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiRmFpbGVkIHRvIGluaXRpYWxpemUgIgogCQkJCSJiZ3NjYW4iKTsKIAkJCS8qCkBAIC02NTEsMTEgKzY4MSwxNiBAQAogCQl3cGFfc3VwcGxpY2FudF9zdGF0ZV90eHQod3BhX3MtPndwYV9zdGF0ZSksCiAJCXdwYV9zdXBwbGljYW50X3N0YXRlX3R4dChzdGF0ZSkpOwogCi0jaWZkZWYgQU5EUk9JRF9QMlAKLQlpZihzdGF0ZSA9PSBXUEFfQVNTT0NJQVRFRCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkKSB7Ci0JCXdwYV9zLT5jdXJyZW50X3NzaWQtPmFzc29jX3JldHJ5ID0gMDsKKwlpZiAoc3RhdGUgPT0gV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCkgeworCQkvKiBBc3N1cmUgbm9ybWFsIHNjYW4gd2hlbiBpbnRlcmZhY2UgaXMgcmVzdG9yZWQgKi8KKwkJd3BhX3MtPm5vcm1hbF9zY2FucyA9IDA7CiAJfQotI2VuZGlmIC8qIEFORFJPSURfUDJQICovCisKKwlpZiAoc3RhdGUgPT0gV1BBX0NPTVBMRVRFRCkgeworCQl3cGFzX2Nvbm5lY3Rfd29ya19kb25lKHdwYV9zKTsKKwkJLyogUmVpbml0aWFsaXplIG5vcm1hbF9zY2FuIGNvdW50ZXIgKi8KKwkJd3BhX3MtPm5vcm1hbF9zY2FucyA9IDA7CisJfQogCiAJaWYgKHN0YXRlICE9IFdQQV9TQ0FOTklORykKIAkJd3BhX3N1cHBsaWNhbnRfbm90aWZ5X3NjYW5uaW5nKHdwYV9zLCAwKTsKQEAgLTY2NCw3ICs2OTksNyBAQAogCQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOwogI2lmIGRlZmluZWQoQ09ORklHX0NUUkxfSUZBQ0UpIHx8ICFkZWZpbmVkKENPTkZJR19OT19TVERPVVRfREVCVUcpCiAJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfQ09OTkVDVEVEICItIENvbm5lY3Rpb24gdG8gIgotCQkJTUFDU1RSICIgY29tcGxldGVkIChhdXRoKSBbaWQ9JWQgaWRfc3RyPSVzXSIsCisJCQlNQUNTVFIgIiBjb21wbGV0ZWQgW2lkPSVkIGlkX3N0cj0lc10iLAogCQkJTUFDMlNUUih3cGFfcy0+YnNzaWQpLAogCQkJc3NpZCA/IHNzaWQtPmlkIDogLTEsCiAJCQlzc2lkICYmIHNzaWQtPmlkX3N0ciA/IHNzaWQtPmlkX3N0ciA6ICIiKTsKQEAgLTY3Nyw5ICs3MTIsOCBAQAogCQl3cGFfZHJ2X3NldF9zdXBwX3BvcnQod3BhX3MsIDEpOwogI2VuZGlmIC8qIElFRUU4MDIxWF9FQVBPTCAqLwogCQl3cGFfcy0+YWZ0ZXJfd3BzID0gMDsKLSNpZmRlZiBDT05GSUdfUDJQCisJCXdwYV9zLT5rbm93bl93cHNfZnJlcSA9IDA7CiAJCXdwYXNfcDJwX2NvbXBsZXRlZCh3cGFfcyk7Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAJCXNtZV9zY2hlZF9vYnNzX3NjYW4od3BhX3MsIDEpOwogCX0gZWxzZSBpZiAoc3RhdGUgPT0gV1BBX0RJU0NPTk5FQ1RFRCB8fCBzdGF0ZSA9PSBXUEFfQVNTT0NJQVRJTkcgfHwKQEAgLTY5Niw3ICs3MzAsNyBAQAogI2lmZGVmIENPTkZJR19CR1NDQU4KIAlpZiAoc3RhdGUgPT0gV1BBX0NPTVBMRVRFRCkKIAkJd3BhX3N1cHBsaWNhbnRfc3RhcnRfYmdzY2FuKHdwYV9zKTsKLQllbHNlCisJZWxzZSBpZiAoc3RhdGUgPCBXUEFfQVNTT0NJQVRFRCkKIAkJd3BhX3N1cHBsaWNhbnRfc3RvcF9iZ3NjYW4od3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19CR1NDQU4gKi8KIApAQCAtNzA5LDYgKzc0MywxMiBAQAogCWlmICh3cGFfcy0+d3BhX3N0YXRlICE9IG9sZF9zdGF0ZSkgewogCQl3cGFzX25vdGlmeV9zdGF0ZV9jaGFuZ2VkKHdwYV9zLCB3cGFfcy0+d3BhX3N0YXRlLCBvbGRfc3RhdGUpOwogCisJCS8qCisJCSAqIE5vdGlmeSB0aGUgUDJQIERldmljZSBpbnRlcmZhY2UgYWJvdXQgYSBzdGF0ZSBjaGFuZ2UgaW4gb25lCisJCSAqIG9mIHRoZSBpbnRlcmZhY2VzLgorCQkgKi8KKwkJd3Bhc19wMnBfaW5kaWNhdGVfc3RhdGVfY2hhbmdlKHdwYV9zKTsKKwogCQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfQ09NUExFVEVEIHx8CiAJCSAgICBvbGRfc3RhdGUgPT0gV1BBX0NPTVBMRVRFRCkKIAkJCXdwYXNfbm90aWZ5X2F1dGhfY2hhbmdlZCh3cGFfcyk7CkBAIC03MjIsOSArNzYyLDE1IEBACiAjaWZkZWYgQ09ORklHX1dQUwogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBnbG9iYWwtPmlmYWNlczsKIAl3aGlsZSAod3BhX3MpIHsKKwkJc3RydWN0IHdwYV9zdXBwbGljYW50ICpuZXh0ID0gd3BhX3MtPm5leHQ7CiAJCWlmICh3cGFzX3dwc190ZXJtaW5hdGVfcGVuZGluZyh3cGFfcykgPT0gMSkKIAkJCXBlbmRpbmcgPSAxOwotCQl3cGFfcyA9IHdwYV9zLT5uZXh0OworI2lmZGVmIENPTkZJR19QMlAKKwkJaWYgKHdwYV9zLT5wMnBfZ3JvdXBfaW50ZXJmYWNlICE9IE5PVF9QMlBfR1JPVVBfSU5URVJGQUNFIHx8CisJCSAgICAod3BhX3MtPmN1cnJlbnRfc3NpZCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkLT5wMnBfZ3JvdXApKQorCQkJd3Bhc19wMnBfZGlzY29ubmVjdCh3cGFfcyk7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCQl3cGFfcyA9IG5leHQ7CiAJfQogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAlpZiAocGVuZGluZykKQEAgLTg1MywzNCArODk5LDYgQEAKIH0KIAogCi1lbnVtIHdwYV9rZXlfbWdtdCBrZXlfbWdtdDJkcml2ZXIoaW50IGtleV9tZ210KQotewotCXN3aXRjaCAoa2V5X21nbXQpIHsKLQljYXNlIFdQQV9LRVlfTUdNVF9OT05FOgotCQlyZXR1cm4gS0VZX01HTVRfTk9ORTsKLQljYXNlIFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfTk9fV1BBOgotCQlyZXR1cm4gS0VZX01HTVRfODAyXzFYX05PX1dQQTsKLQljYXNlIFdQQV9LRVlfTUdNVF9JRUVFODAyMVg6Ci0JCXJldHVybiBLRVlfTUdNVF84MDJfMVg7Ci0JY2FzZSBXUEFfS0VZX01HTVRfV1BBX05PTkU6Ci0JCXJldHVybiBLRVlfTUdNVF9XUEFfTk9ORTsKLQljYXNlIFdQQV9LRVlfTUdNVF9GVF9JRUVFODAyMVg6Ci0JCXJldHVybiBLRVlfTUdNVF9GVF84MDJfMVg7Ci0JY2FzZSBXUEFfS0VZX01HTVRfRlRfUFNLOgotCQlyZXR1cm4gS0VZX01HTVRfRlRfUFNLOwotCWNhc2UgV1BBX0tFWV9NR01UX0lFRUU4MDIxWF9TSEEyNTY6Ci0JCXJldHVybiBLRVlfTUdNVF84MDJfMVhfU0hBMjU2OwotCWNhc2UgV1BBX0tFWV9NR01UX1BTS19TSEEyNTY6Ci0JCXJldHVybiBLRVlfTUdNVF9QU0tfU0hBMjU2OwotCWNhc2UgV1BBX0tFWV9NR01UX1dQUzoKLQkJcmV0dXJuIEtFWV9NR01UX1dQUzsKLQljYXNlIFdQQV9LRVlfTUdNVF9QU0s6Ci0JZGVmYXVsdDoKLQkJcmV0dXJuIEtFWV9NR01UX1BTSzsKLQl9Ci19Ci0KLQogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9zdWl0ZXNfZnJvbV9haShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgc3RydWN0IHdwYV9zc2lkICpzc2lkLAogCQkJCQkgc3RydWN0IHdwYV9pZV9kYXRhICppZSkKQEAgLTk1MSwxMyArOTY5LDE0IEBACiB7CiAJc3RydWN0IHdwYV9pZV9kYXRhIGllOwogCWludCBzZWwsIHByb3RvOwotCWNvbnN0IHU4ICpic3Nfd3BhLCAqYnNzX3JzbjsKKwljb25zdCB1OCAqYnNzX3dwYSwgKmJzc19yc24sICpic3Nfb3NlbjsKIAogCWlmIChic3MpIHsKIAkJYnNzX3dwYSA9IHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZShic3MsIFdQQV9JRV9WRU5ET1JfVFlQRSk7CiAJCWJzc19yc24gPSB3cGFfYnNzX2dldF9pZShic3MsIFdMQU5fRUlEX1JTTik7CisJCWJzc19vc2VuID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgT1NFTl9JRV9WRU5ET1JfVFlQRSk7CiAJfSBlbHNlCi0JCWJzc193cGEgPSBic3NfcnNuID0gTlVMTDsKKwkJYnNzX3dwYSA9IGJzc19yc24gPSBic3Nfb3NlbiA9IE5VTEw7CiAKIAlpZiAoYnNzX3JzbiAmJiAoc3NpZC0+cHJvdG8gJiBXUEFfUFJPVE9fUlNOKSAmJgogCSAgICB3cGFfcGFyc2Vfd3BhX2llKGJzc19yc24sIDIgKyBic3NfcnNuWzFdLCAmaWUpID09IDAgJiYKQEAgLTk3MywxMSArOTkyLDIzIEBACiAJCSAgIChpZS5rZXlfbWdtdCAmIHNzaWQtPmtleV9tZ210KSkgewogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJXUEE6IHVzaW5nIElFRUUgODAyLjExaS9EMy4wIik7CiAJCXByb3RvID0gV1BBX1BST1RPX1dQQTsKKyNpZmRlZiBDT05GSUdfSFMyMAorCX0gZWxzZSBpZiAoYnNzX29zZW4gJiYgKHNzaWQtPnByb3RvICYgV1BBX1BST1RPX09TRU4pKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkhTIDIuMDogdXNpbmcgT1NFTiIpOworCQkvKiBUT0RPOiBwYXJzZSBPU0VOIGVsZW1lbnQgKi8KKwkJb3NfbWVtc2V0KCZpZSwgMCwgc2l6ZW9mKGllKSk7CisJCWllLmdyb3VwX2NpcGhlciA9IFdQQV9DSVBIRVJfQ0NNUDsKKwkJaWUucGFpcndpc2VfY2lwaGVyID0gV1BBX0NJUEhFUl9DQ01QOworCQlpZS5rZXlfbWdtdCA9IFdQQV9LRVlfTUdNVF9PU0VOOworCQlwcm90byA9IFdQQV9QUk9UT19PU0VOOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJfSBlbHNlIGlmIChic3MpIHsKIAkJd3BhX21zZyh3cGFfcywgTVNHX1dBUk5JTkcsICJXUEE6IEZhaWxlZCB0byBzZWxlY3QgV1BBL1JTTiIpOwogCQlyZXR1cm4gLTE7CiAJfSBlbHNlIHsKLQkJaWYgKHNzaWQtPnByb3RvICYgV1BBX1BST1RPX1JTTikKKwkJaWYgKHNzaWQtPnByb3RvICYgV1BBX1BST1RPX09TRU4pCisJCQlwcm90byA9IFdQQV9QUk9UT19PU0VOOworCQllbHNlIGlmIChzc2lkLT5wcm90byAmIFdQQV9QUk9UT19SU04pCiAJCQlwcm90byA9IFdQQV9QUk9UT19SU047CiAJCWVsc2UKIAkJCXByb3RvID0gV1BBX1BST1RPX1dQQTsKQEAgLTEwMTAsNyArMTA0MSw3IEBACiAJd3BhX3MtPndwYV9wcm90byA9IHByb3RvOwogCXdwYV9zbV9zZXRfcGFyYW0od3BhX3MtPndwYSwgV1BBX1BBUkFNX1BST1RPLCBwcm90byk7CiAJd3BhX3NtX3NldF9wYXJhbSh3cGFfcy0+d3BhLCBXUEFfUEFSQU1fUlNOX0VOQUJMRUQsCi0JCQkgISEoc3NpZC0+cHJvdG8gJiBXUEFfUFJPVE9fUlNOKSk7CisJCQkgISEoc3NpZC0+cHJvdG8gJiAoV1BBX1BST1RPX1JTTiB8IFdQQV9QUk9UT19PU0VOKSkpOwogCiAJaWYgKGJzcyB8fCAhd3BhX3MtPmFwX2llc19mcm9tX2Fzc29jaW5mbykgewogCQlpZiAod3BhX3NtX3NldF9hcF93cGFfaWUod3BhX3MtPndwYSwgYnNzX3dwYSwKQEAgLTEwODEsNiArMTExMiwxMSBAQAogCX0gZWxzZSBpZiAoc2VsICYgV1BBX0tFWV9NR01UX1dQQV9OT05FKSB7CiAJCXdwYV9zLT5rZXlfbWdtdCA9IFdQQV9LRVlfTUdNVF9XUEFfTk9ORTsKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiV1BBOiB1c2luZyBLRVlfTUdNVCBXUEEtTk9ORSIpOworI2lmZGVmIENPTkZJR19IUzIwCisJfSBlbHNlIGlmIChzZWwgJiBXUEFfS0VZX01HTVRfT1NFTikgeworCQl3cGFfcy0+a2V5X21nbXQgPSBXUEFfS0VZX01HTVRfT1NFTjsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiSFMgMi4wOiB1c2luZyBLRVlfTUdNVCBPU0VOIik7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAl9IGVsc2UgewogCQl3cGFfbXNnKHdwYV9zLCBNU0dfV0FSTklORywgIldQQTogRmFpbGVkIHRvIHNlbGVjdCAiCiAJCQkiYXV0aGVudGljYXRlZCBrZXkgbWFuYWdlbWVudCB0eXBlIik7CkBAIC0xMTAyLDYgKzExMzgsMTggQEAKIAkJd3BhX3MtPm1nbXRfZ3JvdXBfY2lwaGVyID0gV1BBX0NJUEhFUl9BRVNfMTI4X0NNQUM7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIldQQTogdXNpbmcgTUdNVCBncm91cCBjaXBoZXIgIgogCQkJIkFFUy0xMjgtQ01BQyIpOworCX0gZWxzZSBpZiAoc2VsICYgV1BBX0NJUEhFUl9CSVBfR01BQ18xMjgpIHsKKwkJd3BhX3MtPm1nbXRfZ3JvdXBfY2lwaGVyID0gV1BBX0NJUEhFUl9CSVBfR01BQ18xMjg7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIldQQTogdXNpbmcgTUdNVCBncm91cCBjaXBoZXIgIgorCQkJIkJJUC1HTUFDLTEyOCIpOworCX0gZWxzZSBpZiAoc2VsICYgV1BBX0NJUEhFUl9CSVBfR01BQ18yNTYpIHsKKwkJd3BhX3MtPm1nbXRfZ3JvdXBfY2lwaGVyID0gV1BBX0NJUEhFUl9CSVBfR01BQ18yNTY7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIldQQTogdXNpbmcgTUdNVCBncm91cCBjaXBoZXIgIgorCQkJIkJJUC1HTUFDLTI1NiIpOworCX0gZWxzZSBpZiAoc2VsICYgV1BBX0NJUEhFUl9CSVBfQ01BQ18yNTYpIHsKKwkJd3BhX3MtPm1nbXRfZ3JvdXBfY2lwaGVyID0gV1BBX0NJUEhFUl9CSVBfQ01BQ18yNTY7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIldQQTogdXNpbmcgTUdNVCBncm91cCBjaXBoZXIgIgorCQkJIkJJUC1DTUFDLTI1NiIpOwogCX0gZWxzZSB7CiAJCXdwYV9zLT5tZ210X2dyb3VwX2NpcGhlciA9IDA7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIldQQTogbm90IHVzaW5nIE1HTVQgZ3JvdXAgY2lwaGVyIik7CkBAIC0xMjIwLDggKzEyNjgsMTYgQEAKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAJCWJyZWFrOwogCWNhc2UgNDogLyogQml0cyAzMi0zOSAqLworI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKwkJaWYgKHdwYV9zLT5kcnZfZmxhZ3MgLyBXUEFfRFJJVkVSX0ZMQUdTX1FPU19NQVBQSU5HKQorCQkJKnBvcyB8PSAweDAxOyAvKiBCaXQgMzIgLSBRb1MgTWFwICovCisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwogCQlicmVhazsKIAljYXNlIDU6IC8qIEJpdHMgNDAtNDcgKi8KKyNpZmRlZiBDT05GSUdfSFMyMAorCQlpZiAod3BhX3MtPmNvbmYtPmhzMjApCisJCQkqcG9zIHw9IDB4NDA7IC8qIEJpdCA0NiAtIFdOTS1Ob3RpZmljYXRpb24gKi8KKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCQlicmVhazsKIAljYXNlIDY6IC8qIEJpdHMgNDgtNTUgKi8KIAkJYnJlYWs7CkBAIC0xMjI5LDEzICsxMjg1LDE4IEBACiB9CiAKIAotaW50IHdwYXNfYnVpbGRfZXh0X2NhcGFiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHU4ICpidWYpCitpbnQgd3Bhc19idWlsZF9leHRfY2FwYWIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgdTggKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKIHsKIAl1OCAqcG9zID0gYnVmOwotCXU4IGxlbiA9IDQsIGk7CisJdTggbGVuID0gNiwgaTsKIAogCWlmIChsZW4gPCB3cGFfcy0+ZXh0ZW5kZWRfY2FwYV9sZW4pCiAJCWxlbiA9IHdwYV9zLT5leHRlbmRlZF9jYXBhX2xlbjsKKwlpZiAoYnVmbGVuIDwgKHNpemVfdCkgbGVuICsgMikgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLAorCQkJICAgIk5vdCBlbm91Z2ggcm9vbSBmb3IgYnVpbGRpbmcgZXh0ZW5kZWQgY2FwYWJpbGl0aWVzIGVsZW1lbnQiKTsKKwkJcmV0dXJuIC0xOworCX0KIAogCSpwb3MrKyA9IFdMQU5fRUlEX0VYVF9DQVBBQjsKIAkqcG9zKysgPSBsZW47CkBAIC0xMjU5LDYgKzEzMjAsNzAgQEAKIH0KIAogCitzdGF0aWMgaW50IHdwYXNfdmFsaWRfYnNzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgIHN0cnVjdCB3cGFfYnNzICp0ZXN0X2JzcykKK3sKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOworCisJZGxfbGlzdF9mb3JfZWFjaChic3MsICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgeworCQlpZiAoYnNzID09IHRlc3RfYnNzKQorCQkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cGFzX3ZhbGlkX3NzaWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgIHN0cnVjdCB3cGFfc3NpZCAqdGVzdF9zc2lkKQoreworCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKKworCWZvciAoc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOyBzc2lkOyBzc2lkID0gc3NpZC0+bmV4dCkgeworCQlpZiAoc3NpZCA9PSB0ZXN0X3NzaWQpCisJCQlyZXR1cm4gMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCitpbnQgd3Bhc192YWxpZF9ic3Nfc3NpZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqdGVzdF9ic3MsCisJCQlzdHJ1Y3Qgd3BhX3NzaWQgKnRlc3Rfc3NpZCkKK3sKKwlpZiAodGVzdF9ic3MgJiYgIXdwYXNfdmFsaWRfYnNzKHdwYV9zLCB0ZXN0X2JzcykpCisJCXJldHVybiAwOworCisJcmV0dXJuIHRlc3Rfc3NpZCA9PSBOVUxMIHx8IHdwYXNfdmFsaWRfc3NpZCh3cGFfcywgdGVzdF9zc2lkKTsKK30KKworCit2b2lkIHdwYXNfY29ubmVjdF93b3JrX2ZyZWUoc3RydWN0IHdwYV9jb25uZWN0X3dvcmsgKmN3b3JrKQoreworCWlmIChjd29yayA9PSBOVUxMKQorCQlyZXR1cm47CisJb3NfZnJlZShjd29yayk7Cit9CisKKwordm9pZCB3cGFzX2Nvbm5lY3Rfd29ya19kb25lKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJc3RydWN0IHdwYV9jb25uZWN0X3dvcmsgKmN3b3JrOworCXN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yayA9IHdwYV9zLT5jb25uZWN0X3dvcms7CisKKwlpZiAoIXdvcmspCisJCXJldHVybjsKKworCXdwYV9zLT5jb25uZWN0X3dvcmsgPSBOVUxMOworCWN3b3JrID0gd29yay0+Y3R4OworCXdvcmstPmN0eCA9IE5VTEw7CisJd3Bhc19jb25uZWN0X3dvcmtfZnJlZShjd29yayk7CisJcmFkaW9fd29ya19kb25lKHdvcmspOworfQorCisKK3N0YXRpYyB2b2lkIHdwYXNfc3RhcnRfYXNzb2NfY2Ioc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrLCBpbnQgZGVpbml0KTsKKwogLyoqCiAgKiB3cGFfc3VwcGxpY2FudF9hc3NvY2lhdGUgLSBSZXF1ZXN0IGFzc29jaWF0aW9uCiAgKiBAd3BhX3M6IFBvaW50ZXIgdG8gd3BhX3N1cHBsaWNhbnQgZGF0YQpAQCAtMTI3MCwyOSArMTM5NSwxMiBAQAogdm9pZCB3cGFfc3VwcGxpY2FudF9hc3NvY2lhdGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgICAgIHN0cnVjdCB3cGFfYnNzICpic3MsIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKIHsKLQl1OCB3cGFfaWVbMjAwXTsKLQlzaXplX3Qgd3BhX2llX2xlbjsKLQlpbnQgdXNlX2NyeXB0LCByZXQsIGksIGJzc2lkX2NoYW5nZWQ7Ci0JaW50IGFsZ3MgPSBXUEFfQVVUSF9BTEdfT1BFTjsKLQllbnVtIHdwYV9jaXBoZXIgY2lwaGVyX3BhaXJ3aXNlLCBjaXBoZXJfZ3JvdXA7Ci0Jc3RydWN0IHdwYV9kcml2ZXJfYXNzb2NpYXRlX3BhcmFtcyBwYXJhbXM7Ci0JaW50IHdlcF9rZXlzX3NldCA9IDA7Ci0JaW50IGFzc29jX2ZhaWxlZCA9IDA7Ci0Jc3RydWN0IHdwYV9zc2lkICpvbGRfc3NpZDsKLQl1OCBleHRfY2FwYWJbMTBdOwotCWludCBleHRfY2FwYWJfbGVuOwotI2lmZGVmIENPTkZJR19IVF9PVkVSUklERVMKLQlzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyBodGNhcHM7Ci0Jc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgaHRjYXBzX21hc2s7Ci0jZW5kaWYgLyogQ09ORklHX0hUX09WRVJSSURFUyAqLworCXN0cnVjdCB3cGFfY29ubmVjdF93b3JrICpjd29yazsKIAogI2lmZGVmIENPTkZJR19JQlNTX1JTTgogCWlic3NfcnNuX2RlaW5pdCh3cGFfcy0+aWJzc19yc24pOwogCXdwYV9zLT5pYnNzX3JzbiA9IE5VTEw7CiAjZW5kaWYgLyogQ09ORklHX0lCU1NfUlNOICovCi0jaWZkZWYgQU5EUk9JRF9QMlAKLQlpbnQgZnJlcSA9IDA7Ci0jZW5kaWYKIAogCWlmIChzc2lkLT5tb2RlID09IFdQQVNfTU9ERV9BUCB8fCBzc2lkLT5tb2RlID09IFdQQVNfTU9ERV9QMlBfR08gfHwKIAkgICAgc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTikgewpAQCAtMTMyOCw4ICsxNDM2LDc3IEBACiAJCXJldHVybjsKIAl9CiAKKwlpZiAod3BhX3MtPmNvbm5lY3Rfd29yaykgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJSZWplY3Qgd3BhX3N1cHBsaWNhbnRfYXNzb2NpYXRlKCkgY2FsbCBzaW5jZSBjb25uZWN0X3dvcmsgZXhpc3QiKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChyYWRpb193b3JrX3BlbmRpbmcod3BhX3MsICJjb25uZWN0IikpIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUmVqZWN0IHdwYV9zdXBwbGljYW50X2Fzc29jaWF0ZSgpIGNhbGwgc2luY2UgcGVuZGluZyB3b3JrIGV4aXN0Iik7CisJCXJldHVybjsKKwl9CisKKwljd29yayA9IG9zX3phbGxvYyhzaXplb2YoKmN3b3JrKSk7CisJaWYgKGN3b3JrID09IE5VTEwpCisJCXJldHVybjsKKworCWN3b3JrLT5ic3MgPSBic3M7CisJY3dvcmstPnNzaWQgPSBzc2lkOworCisJaWYgKHJhZGlvX2FkZF93b3JrKHdwYV9zLCBic3MgPyBic3MtPmZyZXEgOiAwLCAiY29ubmVjdCIsIDEsCisJCQkgICB3cGFzX3N0YXJ0X2Fzc29jX2NiLCBjd29yaykgPCAwKSB7CisJCW9zX2ZyZWUoY3dvcmspOworCX0KK30KKworCitzdGF0aWMgdm9pZCB3cGFzX3N0YXJ0X2Fzc29jX2NiKHN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yaywgaW50IGRlaW5pdCkKK3sKKwlzdHJ1Y3Qgd3BhX2Nvbm5lY3Rfd29yayAqY3dvcmsgPSB3b3JrLT5jdHg7CisJc3RydWN0IHdwYV9ic3MgKmJzcyA9IGN3b3JrLT5ic3M7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkID0gY3dvcmstPnNzaWQ7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHdvcmstPndwYV9zOworCXU4IHdwYV9pZVsyMDBdOworCXNpemVfdCB3cGFfaWVfbGVuOworCWludCB1c2VfY3J5cHQsIHJldCwgaSwgYnNzaWRfY2hhbmdlZDsKKwlpbnQgYWxncyA9IFdQQV9BVVRIX0FMR19PUEVOOworCXVuc2lnbmVkIGludCBjaXBoZXJfcGFpcndpc2UsIGNpcGhlcl9ncm91cDsKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9hc3NvY2lhdGVfcGFyYW1zIHBhcmFtczsKKwlpbnQgd2VwX2tleXNfc2V0ID0gMDsKKwlpbnQgYXNzb2NfZmFpbGVkID0gMDsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKm9sZF9zc2lkOworI2lmZGVmIENPTkZJR19IVF9PVkVSUklERVMKKwlzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyBodGNhcHM7CisJc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgaHRjYXBzX21hc2s7CisjZW5kaWYgLyogQ09ORklHX0hUX09WRVJSSURFUyAqLworI2lmZGVmIENPTkZJR19WSFRfT1ZFUlJJREVTCisgICAgICAgc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzIHZodGNhcHM7CisgICAgICAgc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzIHZodGNhcHNfbWFzazsKKyNlbmRpZiAvKiBDT05GSUdfVkhUX09WRVJSSURFUyAqLworCisJaWYgKGRlaW5pdCkgeworCQlpZiAod29yay0+c3RhcnRlZCkgeworCQkJd3BhX3MtPmNvbm5lY3Rfd29yayA9IE5VTEw7CisKKwkJCS8qIGNhbmNlbCBwb3NzaWJsZSBhdXRoLiB0aW1lb3V0ICovCisJCQllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFfc3VwcGxpY2FudF90aW1lb3V0LCB3cGFfcywKKwkJCQkJICAgICBOVUxMKTsKKwkJfQorCQl3cGFzX2Nvbm5lY3Rfd29ya19mcmVlKGN3b3JrKTsKKwkJcmV0dXJuOworCX0KKworCXdwYV9zLT5jb25uZWN0X3dvcmsgPSB3b3JrOworCisJaWYgKCF3cGFzX3ZhbGlkX2Jzc19zc2lkKHdwYV9zLCBic3MsIHNzaWQpKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkJTUy9TU0lEIGVudHJ5IGZvciBhc3NvY2lhdGlvbiBub3QgdmFsaWQgYW55bW9yZSAtIGRyb3AgY29ubmVjdGlvbiBhdHRlbXB0Iik7CisJCXdwYXNfY29ubmVjdF93b3JrX2RvbmUod3BhX3MpOworCQlyZXR1cm47CisJfQorCiAJb3NfbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKIAl3cGFfcy0+cmVhc3NvY2lhdGUgPSAwOworCXdwYV9zLT5lYXBfZXhwZWN0ZWRfZmFpbHVyZSA9IDA7CiAJaWYgKGJzcyAmJiAhd3Bhc19kcml2ZXJfYnNzX3NlbGVjdGlvbih3cGFfcykpIHsKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgogCQljb25zdCB1OCAqaWUsICptZCA9IE5VTEw7CkBAIC0xNDc5LDYgKzE2NTYsOCBAQAogCQkJCSJkaXNhbGxvd3MiIDogImFsbG93cyIpOwogCQl9CiAJfQorCisJb3NfbWVtc2V0KHdwYV9zLT5wMnBfaXBfYWRkcl9pbmZvLCAwLCBzaXplb2Yod3BhX3MtPnAycF9pcF9hZGRyX2luZm8pKTsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKICNpZmRlZiBDT05GSUdfSFMyMApAQCAtMTQ4NiwzMCArMTY2NSw0OSBAQAogCQlzdHJ1Y3Qgd3BhYnVmICpoczIwOwogCQloczIwID0gd3BhYnVmX2FsbG9jKDIwKTsKIAkJaWYgKGhzMjApIHsKLQkJCXdwYXNfaHMyMF9hZGRfaW5kaWNhdGlvbihoczIwKTsKLQkJCW9zX21lbWNweSh3cGFfaWUgKyB3cGFfaWVfbGVuLCB3cGFidWZfaGVhZChoczIwKSwKLQkJCQkgIHdwYWJ1Zl9sZW4oaHMyMCkpOwotCQkJd3BhX2llX2xlbiArPSB3cGFidWZfbGVuKGhzMjApOworCQkJaW50IHBwc19tb19pZCA9IGhzMjBfZ2V0X3Bwc19tb19pZCh3cGFfcywgc3NpZCk7CisJCQlzaXplX3QgbGVuOworCisJCQl3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oaHMyMCwgcHBzX21vX2lkKTsKKwkJCWxlbiA9IHNpemVvZih3cGFfaWUpIC0gd3BhX2llX2xlbjsKKwkJCWlmICh3cGFidWZfbGVuKGhzMjApIDw9IGxlbikgeworCQkJCW9zX21lbWNweSh3cGFfaWUgKyB3cGFfaWVfbGVuLAorCQkJCQkgIHdwYWJ1Zl9oZWFkKGhzMjApLCB3cGFidWZfbGVuKGhzMjApKTsKKwkJCQl3cGFfaWVfbGVuICs9IHdwYWJ1Zl9sZW4oaHMyMCk7CisJCQl9CiAJCQl3cGFidWZfZnJlZShoczIwKTsKIAkJfQogCX0KICNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCi0JZXh0X2NhcGFiX2xlbiA9IHdwYXNfYnVpbGRfZXh0X2NhcGFiKHdwYV9zLCBleHRfY2FwYWIpOwotCWlmIChleHRfY2FwYWJfbGVuID4gMCkgewotCQl1OCAqcG9zID0gd3BhX2llOwotCQlpZiAod3BhX2llX2xlbiA+IDAgJiYgcG9zWzBdID09IFdMQU5fRUlEX1JTTikKLQkJCXBvcyArPSAyICsgcG9zWzFdOwotCQlvc19tZW1tb3ZlKHBvcyArIGV4dF9jYXBhYl9sZW4sIHBvcywKLQkJCSAgIHdwYV9pZV9sZW4gLSAocG9zIC0gd3BhX2llKSk7Ci0JCXdwYV9pZV9sZW4gKz0gZXh0X2NhcGFiX2xlbjsKLQkJb3NfbWVtY3B5KHBvcywgZXh0X2NhcGFiLCBleHRfY2FwYWJfbGVuKTsKKwkvKgorCSAqIFdvcmthcm91bmQ6IEFkZCBFeHRlbmRlZCBDYXBhYmlsaXRpZXMgZWxlbWVudCBvbmx5IGlmIHRoZSBBUAorCSAqIGluY2x1ZGVkIHRoaXMgZWxlbWVudCBpbiBCZWFjb24vUHJvYmUgUmVzcG9uc2UgZnJhbWVzLiBTb21lIG9sZGVyCisJICogQVBzIHNlZW0gdG8gaGF2ZSBpbnRlcm9wZXJhYmlsaXR5IGlzc3VlcyBpZiB0aGlzIGVsZW1lbnQgaXMKKwkgKiBpbmNsdWRlZCwgc28gd2hpbGUgdGhlIHN0YW5kYXJkIG1heSByZXF1aXJlIHVzIHRvIGluY2x1ZGUgdGhlCisJICogZWxlbWVudCBpbiBhbGwgY2FzZXMsIGl0IGlzIGp1c3RpZmlhYmxlIHRvIHNraXAgaXQgdG8gYXZvaWQKKwkgKiBpbnRlcm9wZXJhYmlsaXR5IGlzc3Vlcy4KKwkgKi8KKwlpZiAoIWJzcyB8fCB3cGFfYnNzX2dldF9pZShic3MsIFdMQU5fRUlEX0VYVF9DQVBBQikpIHsKKwkJdTggZXh0X2NhcGFiWzE4XTsKKwkJaW50IGV4dF9jYXBhYl9sZW47CisJCWV4dF9jYXBhYl9sZW4gPSB3cGFzX2J1aWxkX2V4dF9jYXBhYih3cGFfcywgZXh0X2NhcGFiLAorCQkJCQkJICAgICBzaXplb2YoZXh0X2NhcGFiKSk7CisJCWlmIChleHRfY2FwYWJfbGVuID4gMCkgeworCQkJdTggKnBvcyA9IHdwYV9pZTsKKwkJCWlmICh3cGFfaWVfbGVuID4gMCAmJiBwb3NbMF0gPT0gV0xBTl9FSURfUlNOKQorCQkJCXBvcyArPSAyICsgcG9zWzFdOworCQkJb3NfbWVtbW92ZShwb3MgKyBleHRfY2FwYWJfbGVuLCBwb3MsCisJCQkJICAgd3BhX2llX2xlbiAtIChwb3MgLSB3cGFfaWUpKTsKKwkJCXdwYV9pZV9sZW4gKz0gZXh0X2NhcGFiX2xlbjsKKwkJCW9zX21lbWNweShwb3MsIGV4dF9jYXBhYiwgZXh0X2NhcGFiX2xlbik7CisJCX0KIAl9CiAKIAl3cGFfY2xlYXJfa2V5cyh3cGFfcywgYnNzID8gYnNzLT5ic3NpZCA6IE5VTEwpOwogCXVzZV9jcnlwdCA9IDE7Ci0JY2lwaGVyX3BhaXJ3aXNlID0gd3BhX2NpcGhlcl90b19zdWl0ZV9kcml2ZXIod3BhX3MtPnBhaXJ3aXNlX2NpcGhlcik7Ci0JY2lwaGVyX2dyb3VwID0gd3BhX2NpcGhlcl90b19zdWl0ZV9kcml2ZXIod3BhX3MtPmdyb3VwX2NpcGhlcik7CisJY2lwaGVyX3BhaXJ3aXNlID0gd3BhX3MtPnBhaXJ3aXNlX2NpcGhlcjsKKwljaXBoZXJfZ3JvdXAgPSB3cGFfcy0+Z3JvdXBfY2lwaGVyOwogCWlmICh3cGFfcy0+a2V5X21nbXQgPT0gV1BBX0tFWV9NR01UX05PTkUgfHwKIAkgICAgd3BhX3MtPmtleV9tZ210ID09IFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfTk9fV1BBKSB7CiAJCWlmICh3cGFfcy0+a2V5X21nbXQgPT0gV1BBX0tFWV9NR01UX05PTkUpCkBAIC0xNTMzLDcgKzE3MzEsNyBAQAogCQkJLyogQXNzdW1lIHRoYXQgZHluYW1pYyBXRVAtMTA0IGtleXMgd2lsbCBiZSB1c2VkIGFuZAogCQkJICogc2V0IGNpcGhlciBzdWl0ZXMgaW4gb3JkZXIgZm9yIGRyaXZlcnMgdG8gZXhwZWN0CiAJCQkgKiBlbmNyeXB0aW9uLiAqLwotCQkJY2lwaGVyX3BhaXJ3aXNlID0gY2lwaGVyX2dyb3VwID0gQ0lQSEVSX1dFUDEwNDsKKwkJCWNpcGhlcl9wYWlyd2lzZSA9IGNpcGhlcl9ncm91cCA9IFdQQV9DSVBIRVJfV0VQMTA0OwogCQl9CiAJfQogI2VuZGlmIC8qIElFRUU4MDIxWF9FQVBPTCAqLwpAQCAtMTU1Niw2ICsxNzU0LDggQEAKIAkJCXBhcmFtcy5ic3NpZCA9IGJzcy0+YnNzaWQ7CiAJCQlwYXJhbXMuZnJlcSA9IGJzcy0+ZnJlcTsKIAkJfQorCQlwYXJhbXMuYnNzaWRfaGludCA9IGJzcy0+YnNzaWQ7CisJCXBhcmFtcy5mcmVxX2hpbnQgPSBic3MtPmZyZXE7CiAJfSBlbHNlIHsKIAkJcGFyYW1zLnNzaWQgPSBzc2lkLT5zc2lkOwogCQlwYXJhbXMuc3NpZF9sZW4gPSBzc2lkLT5zc2lkX2xlbjsKQEAgLTE1NzAsMTEgKzE3NzAsMTkgQEAKIAlpZiAoc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfSUJTUyAmJiBzc2lkLT5mcmVxdWVuY3kgPiAwICYmCiAJICAgIHBhcmFtcy5mcmVxID09IDApCiAJCXBhcmFtcy5mcmVxID0gc3NpZC0+ZnJlcXVlbmN5OyAvKiBJbml0aWFsIGNoYW5uZWwgZm9yIElCU1MgKi8KKworCWlmIChzc2lkLT5tb2RlID09IFdQQVNfTU9ERV9JQlNTKSB7CisJCWlmIChzc2lkLT5iZWFjb25faW50KQorCQkJcGFyYW1zLmJlYWNvbl9pbnQgPSBzc2lkLT5iZWFjb25faW50OworCQllbHNlCisJCQlwYXJhbXMuYmVhY29uX2ludCA9IHdwYV9zLT5jb25mLT5iZWFjb25faW50OworCX0KKwogCXBhcmFtcy53cGFfaWUgPSB3cGFfaWU7CiAJcGFyYW1zLndwYV9pZV9sZW4gPSB3cGFfaWVfbGVuOwogCXBhcmFtcy5wYWlyd2lzZV9zdWl0ZSA9IGNpcGhlcl9wYWlyd2lzZTsKIAlwYXJhbXMuZ3JvdXBfc3VpdGUgPSBjaXBoZXJfZ3JvdXA7Ci0JcGFyYW1zLmtleV9tZ210X3N1aXRlID0ga2V5X21nbXQyZHJpdmVyKHdwYV9zLT5rZXlfbWdtdCk7CisJcGFyYW1zLmtleV9tZ210X3N1aXRlID0gd3BhX3MtPmtleV9tZ210OwogCXBhcmFtcy53cGFfcHJvdG8gPSB3cGFfcy0+d3BhX3Byb3RvOwogCXBhcmFtcy5hdXRoX2FsZyA9IGFsZ3M7CiAJcGFyYW1zLm1vZGUgPSBzc2lkLT5tb2RlOwpAQCAtMTU4Nyw4ICsxNzk1LDggQEAKIAlwYXJhbXMud2VwX3R4X2tleWlkeCA9IHNzaWQtPndlcF90eF9rZXlpZHg7CiAKIAlpZiAoKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTXzRXQVlfSEFORFNIQUtFKSAmJgotCSAgICAocGFyYW1zLmtleV9tZ210X3N1aXRlID09IEtFWV9NR01UX1BTSyB8fAotCSAgICAgcGFyYW1zLmtleV9tZ210X3N1aXRlID09IEtFWV9NR01UX0ZUX1BTSykpIHsKKwkgICAgKHBhcmFtcy5rZXlfbWdtdF9zdWl0ZSA9PSBXUEFfS0VZX01HTVRfUFNLIHx8CisJICAgICBwYXJhbXMua2V5X21nbXRfc3VpdGUgPT0gV1BBX0tFWV9NR01UX0ZUX1BTSykpIHsKIAkJcGFyYW1zLnBhc3NwaHJhc2UgPSBzc2lkLT5wYXNzcGhyYXNlOwogCQlpZiAoc3NpZC0+cHNrX3NldCkKIAkJCXBhcmFtcy5wc2sgPSBzc2lkLT5wc2s7CkBAIC0xNjI4LDE5ICsxODM2LDM1IEBACiAJcGFyYW1zLmh0Y2Fwc19tYXNrID0gKHU4ICopICZodGNhcHNfbWFzazsKIAl3cGFfc3VwcGxpY2FudF9hcHBseV9odF9vdmVycmlkZXMod3BhX3MsIHNzaWQsICZwYXJhbXMpOwogI2VuZGlmIC8qIENPTkZJR19IVF9PVkVSUklERVMgKi8KKyNpZmRlZiBDT05GSUdfVkhUX09WRVJSSURFUworCW9zX21lbXNldCgmdmh0Y2FwcywgMCwgc2l6ZW9mKHZodGNhcHMpKTsKKwlvc19tZW1zZXQoJnZodGNhcHNfbWFzaywgMCwgc2l6ZW9mKHZodGNhcHNfbWFzaykpOworCXBhcmFtcy52aHRjYXBzID0gJnZodGNhcHM7CisJcGFyYW1zLnZodGNhcHNfbWFzayA9ICZ2aHRjYXBzX21hc2s7CisJd3BhX3N1cHBsaWNhbnRfYXBwbHlfdmh0X292ZXJyaWRlcyh3cGFfcywgd3BhX3MtPmN1cnJlbnRfc3NpZCwgJnBhcmFtcyk7CisjZW5kaWYgLyogQ09ORklHX1ZIVF9PVkVSUklERVMgKi8KIAotI2lmZGVmIEFORFJPSURfUDJQCi0JLyogSWYgbXVsdGljaGFubmVsIGNvbmN1cnJlbmN5IGlzIG5vdCBzdXBwb3J0ZWQsIGNoZWNrIGZvciBhbnkgZnJlcXVlbmN5Ci0JICogY29uZmxpY3QgYW5kIHRha2UgYXBwcm9wcmlhdGUgYWN0aW9uLgorI2lmZGVmIENPTkZJR19QMlAKKwkvKgorCSAqIElmIG11bHRpLWNoYW5uZWwgY29uY3VycmVuY3kgaXMgbm90IHN1cHBvcnRlZCwgY2hlY2sgZm9yIGFueQorCSAqIGZyZXF1ZW5jeSBjb25mbGljdC4gSW4gY2FzZSBvZiBhbnkgZnJlcXVlbmN5IGNvbmZsaWN0LCByZW1vdmUgdGhlCisJICogbGVhc3QgcHJpb3JpdGl6ZWQgY29ubmVjdGlvbi4KIAkgKi8KLQlpZiAoKHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQgPCAyKSAmJgotCQkoKGZyZXEgPSB3cGFfZHJ2X3NoYXJlZF9mcmVxKHdwYV9zKSkgPiAwKSAmJiAoZnJlcSAhPSBwYXJhbXMuZnJlcSkpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTaGFyZWQgaW50ZXJmYWNlIHdpdGggY29uZmxpY3RpbmcgZnJlcXVlbmN5IGZvdW5kICglZCAhPSAlZCkiCi0JCQkJCQkJCQkJCQkJCQkJLCBmcmVxLCBwYXJhbXMuZnJlcSk7Ci0JCWlmICh3cGFzX3AycF9oYW5kbGVfZnJlcXVlbmN5X2NvbmZsaWN0cyh3cGFfcywgcGFyYW1zLmZyZXEsIHNzaWQpIDwgMCkgCi0JCQlyZXR1cm47CisJaWYgKHdwYV9zLT5udW1fbXVsdGljaGFuX2NvbmN1cnJlbnQgPCAyKSB7CisJCWludCBmcmVxLCBudW07CisJCW51bSA9IGdldF9zaGFyZWRfcmFkaW9fZnJlcXMod3BhX3MsICZmcmVxLCAxKTsKKwkJaWYgKG51bSA+IDAgJiYgZnJlcSA+IDAgJiYgZnJlcSAhPSBwYXJhbXMuZnJlcSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkJICAgIkFzc29jIGNvbmZsaWN0aW5nIGZyZXEgZm91bmQgKCVkICE9ICVkKSIsCisJCQkJICAgZnJlcSwgcGFyYW1zLmZyZXEpOworCQkJaWYgKHdwYXNfcDJwX2hhbmRsZV9mcmVxdWVuY3lfY29uZmxpY3RzKHdwYV9zLAorCQkJCQkJCQlwYXJhbXMuZnJlcSwKKwkJCQkJCQkJc3NpZCkgPCAwKQorCQkJCXJldHVybjsKKwkJfQogCX0KLSNlbmRpZgorI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKwogCXJldCA9IHdwYV9kcnZfYXNzb2NpYXRlKHdwYV9zLCAmcGFyYW1zKTsKIAlpZiAocmV0IDwgMCkgewogCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIkFzc29jaWF0aW9uIHJlcXVlc3QgdG8gdGhlIGRyaXZlciAiCkBAIC0xOTUyLDYgKzIxNzYsNTkgQEAKIAogCiAvKioKKyAqIHdwYXNfc2V0X3BrY3MxMV9lbmdpbmVfYW5kX21vZHVsZV9wYXRoIC0gU2V0IFBLQ1MgIzExIGVuZ2luZSBhbmQgbW9kdWxlIHBhdGgKKyAqIEB3cGFfczogd3BhX3N1cHBsaWNhbnQgc3RydWN0dXJlIGZvciBhIG5ldHdvcmsgaW50ZXJmYWNlCisgKiBAcGtjczExX2VuZ2luZV9wYXRoOiBQS0NTICMxMSBlbmdpbmUgcGF0aCBvciBOVUxMCisgKiBAcGtjczExX21vZHVsZV9wYXRoOiBQS0NTICMxMSBtb2R1bGUgcGF0aCBvciBOVUxMCisgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3M7IC0xIG9uIGZhaWx1cmUKKyAqCisgKiBTZXRzIHRoZSBQS0NTICMxMSBlbmdpbmUgYW5kIG1vZHVsZSBwYXRoLiBCb3RoIGhhdmUgdG8gYmUgTlVMTCBvciBhIHZhbGlkCisgKiBwYXRoLiBJZiByZXNldHRpbmcgdGhlIEVBUE9MIHN0YXRlIG1hY2hpbmUgd2l0aCB0aGUgbmV3IFBLQ1MgIzExIGVuZ2luZSBhbmQKKyAqIG1vZHVsZSBwYXRoIGZhaWxzIHRoZSBwYXRocyB3aWxsIGJlIHJlc2V0IHRvIHRoZSBkZWZhdWx0IHZhbHVlIChOVUxMKS4KKyAqLworaW50IHdwYXNfc2V0X3BrY3MxMV9lbmdpbmVfYW5kX21vZHVsZV9wYXRoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgIGNvbnN0IGNoYXIgKnBrY3MxMV9lbmdpbmVfcGF0aCwKKwkJCQkJICAgY29uc3QgY2hhciAqcGtjczExX21vZHVsZV9wYXRoKQoreworCWNoYXIgKnBrY3MxMV9lbmdpbmVfcGF0aF9jb3B5ID0gTlVMTDsKKwljaGFyICpwa2NzMTFfbW9kdWxlX3BhdGhfY29weSA9IE5VTEw7CisKKwlpZiAocGtjczExX2VuZ2luZV9wYXRoICE9IE5VTEwpIHsKKwkJcGtjczExX2VuZ2luZV9wYXRoX2NvcHkgPSBvc19zdHJkdXAocGtjczExX2VuZ2luZV9wYXRoKTsKKwkJaWYgKHBrY3MxMV9lbmdpbmVfcGF0aF9jb3B5ID09IE5VTEwpCisJCQlyZXR1cm4gLTE7CisJfQorCWlmIChwa2NzMTFfbW9kdWxlX3BhdGggIT0gTlVMTCkgeworCQlwa2NzMTFfbW9kdWxlX3BhdGhfY29weSA9IG9zX3N0cmR1cChwa2NzMTFfbW9kdWxlX3BhdGgpOworCQlpZiAocGtjczExX21vZHVsZV9wYXRoX2NvcHkgPT0gTlVMTCkgeworCQkJb3NfZnJlZShwa2NzMTFfZW5naW5lX3BhdGhfY29weSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisKKwlvc19mcmVlKHdwYV9zLT5jb25mLT5wa2NzMTFfZW5naW5lX3BhdGgpOworCW9zX2ZyZWUod3BhX3MtPmNvbmYtPnBrY3MxMV9tb2R1bGVfcGF0aCk7CisJd3BhX3MtPmNvbmYtPnBrY3MxMV9lbmdpbmVfcGF0aCA9IHBrY3MxMV9lbmdpbmVfcGF0aF9jb3B5OworCXdwYV9zLT5jb25mLT5wa2NzMTFfbW9kdWxlX3BhdGggPSBwa2NzMTFfbW9kdWxlX3BhdGhfY29weTsKKworCXdwYV9zbV9zZXRfZWFwb2wod3BhX3MtPndwYSwgTlVMTCk7CisJZWFwb2xfc21fZGVpbml0KHdwYV9zLT5lYXBvbCk7CisJd3BhX3MtPmVhcG9sID0gTlVMTDsKKwlpZiAod3BhX3N1cHBsaWNhbnRfaW5pdF9lYXBvbCh3cGFfcykpIHsKKwkJLyogRXJyb3IgLT4gUmVzZXQgcGF0aHMgdG8gdGhlIGRlZmF1bHQgdmFsdWUgKE5VTEwpIG9uY2UuICovCisJCWlmIChwa2NzMTFfZW5naW5lX3BhdGggIT0gTlVMTCAmJiBwa2NzMTFfbW9kdWxlX3BhdGggIT0gTlVMTCkKKwkJCXdwYXNfc2V0X3BrY3MxMV9lbmdpbmVfYW5kX21vZHVsZV9wYXRoKHdwYV9zLCBOVUxMLAorCQkJCQkJCSAgICAgICBOVUxMKTsKKworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9zbV9zZXRfZWFwb2wod3BhX3MtPndwYSwgd3BhX3MtPmVhcG9sKTsKKworCXJldHVybiAwOworfQorCisKKy8qKgogICogd3BhX3N1cHBsaWNhbnRfc2V0X2FwX3NjYW4gLSBTZXQgQVAgc2NhbiBtb2RlIGZvciBpbnRlcmZhY2UKICAqIEB3cGFfczogd3BhX3N1cHBsaWNhbnQgc3RydWN0dXJlIGZvciBhIG5ldHdvcmsgaW50ZXJmYWNlCiAgKiBAYXBfc2NhbjogQVAgc2NhbiBtb2RlCkBAIC0yMjQ1LDYgKzI1MjIsMTYgQEAKIAl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJSWCBFQVBPTCBmcm9tICIgTUFDU1RSLCBNQUMyU1RSKHNyY19hZGRyKSk7CiAJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJSWCBFQVBPTCIsIGJ1ZiwgbGVuKTsKIAorI2lmZGVmIENPTkZJR19QRUVSS0VZCisJaWYgKHdwYV9zLT53cGFfc3RhdGUgPiBXUEFfQVNTT0NJQVRFRCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkICYmCisJICAgIHdwYV9zLT5jdXJyZW50X3NzaWQtPnBlZXJrZXkgJiYKKwkgICAgISh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU180V0FZX0hBTkRTSEFLRSkgJiYKKwkgICAgd3BhX3NtX3J4X2VhcG9sX3BlZXJrZXkod3BhX3MtPndwYSwgc3JjX2FkZHIsIGJ1ZiwgbGVuKSA9PSAxKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlJTTjogUHJvY2Vzc2VkIFBlZXJLZXkgRUFQT0wtS2V5Iik7CisJCXJldHVybjsKKwl9CisjZW5kaWYgLyogQ09ORklHX1BFRVJLRVkgKi8KKwogCWlmICh3cGFfcy0+d3BhX3N0YXRlIDwgV1BBX0FTU09DSUFURUQgfHwKIAkgICAgKHdwYV9zLT5sYXN0X2VhcG9sX21hdGNoZXNfYnNzaWQgJiYKICNpZmRlZiBDT05GSUdfQVAKQEAgLTIyNzAsNyArMjU1Nyw3IEBACiAJCXdwYWJ1Zl9mcmVlKHdwYV9zLT5wZW5kaW5nX2VhcG9sX3J4KTsKIAkJd3BhX3MtPnBlbmRpbmdfZWFwb2xfcnggPSB3cGFidWZfYWxsb2NfY29weShidWYsIGxlbik7CiAJCWlmICh3cGFfcy0+cGVuZGluZ19lYXBvbF9yeCkgewotCQkJb3NfZ2V0X3RpbWUoJndwYV9zLT5wZW5kaW5nX2VhcG9sX3J4X3RpbWUpOworCQkJb3NfZ2V0X3JlbHRpbWUoJndwYV9zLT5wZW5kaW5nX2VhcG9sX3J4X3RpbWUpOwogCQkJb3NfbWVtY3B5KHdwYV9zLT5wZW5kaW5nX2VhcG9sX3J4X3NyYywgc3JjX2FkZHIsCiAJCQkJICBFVEhfQUxFTik7CiAJCX0KQEAgLTI0NTUsOSArMjc0MiwxNSBAQAogCXdwYV9zLT5wcmV2X3NjYW5fd2lsZGNhcmQgPSAwOwogCiAJaWYgKHdwYV9zdXBwbGljYW50X2VuYWJsZWRfbmV0d29ya3Mod3BhX3MpKSB7Ci0JCWlmICh3cGFfc3VwcGxpY2FudF9kZWxheWVkX3NjaGVkX3NjYW4od3BhX3MsIGludGVyZmFjZV9jb3VudCwKKwkJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCkgeworCQkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfRElTQ09OTkVDVEVEKTsKKwkJCWludGVyZmFjZV9jb3VudCA9IDA7CisJCX0KKwkJaWYgKCF3cGFfcy0+cDJwX21nbXQgJiYKKwkJICAgIHdwYV9zdXBwbGljYW50X2RlbGF5ZWRfc2NoZWRfc2Nhbih3cGFfcywKKwkJCQkJCSAgICAgIGludGVyZmFjZV9jb3VudCAlIDMsCiAJCQkJCQkgICAgICAxMDAwMDApKQotCQkJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIGludGVyZmFjZV9jb3VudCwKKwkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCBpbnRlcmZhY2VfY291bnQgJSAzLAogCQkJCQkJMTAwMDAwKTsKIAkJaW50ZXJmYWNlX2NvdW50Kys7CiAJfSBlbHNlCkBAIC0yNTUyLDcgKzI4NDUsNyBAQAogCQkJCSBzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyAqaHRjYXBzX21hc2ssCiAJCQkJIGludCBkaXNhYmxlZCkKIHsKLQl1MTYgbXNrOworCWxlMTYgbXNrOwogCiAJd3BhX21zZyh3cGFfcywgTVNHX0RFQlVHLCAic2V0X2Rpc2FibGVfbWF4X2Ftc2R1OiAlZCIsIGRpc2FibGVkKTsKIApAQCAtMjYyNSw4ICsyOTE4LDggQEAKIAkJCQlpbnQgZGlzYWJsZWQpCiB7CiAJLyogTWFza2luZyB0aGVzZSBvdXQgZGlzYWJsZXMgSFQ0MCAqLwotCXUxNiBtc2sgPSBob3N0X3RvX2xlMTYoSFRfQ0FQX0lORk9fU1VQUF9DSEFOTkVMX1dJRFRIX1NFVCB8Ci0JCQkgICAgICAgSFRfQ0FQX0lORk9fU0hPUlRfR0k0ME1IWik7CisJbGUxNiBtc2sgPSBob3N0X3RvX2xlMTYoSFRfQ0FQX0lORk9fU1VQUF9DSEFOTkVMX1dJRFRIX1NFVCB8CisJCQkJSFRfQ0FQX0lORk9fU0hPUlRfR0k0ME1IWik7CiAKIAl3cGFfbXNnKHdwYV9zLCBNU0dfREVCVUcsICJzZXRfZGlzYWJsZV9odDQwOiAlZCIsIGRpc2FibGVkKTsKIApAQCAtMjY0Nyw4ICsyOTQwLDggQEAKIAkJCSAgICAgICBpbnQgZGlzYWJsZWQpCiB7CiAJLyogTWFza2luZyB0aGVzZSBvdXQgZGlzYWJsZXMgU0dJICovCi0JdTE2IG1zayA9IGhvc3RfdG9fbGUxNihIVF9DQVBfSU5GT19TSE9SVF9HSTIwTUhaIHwKLQkJCSAgICAgICBIVF9DQVBfSU5GT19TSE9SVF9HSTQwTUhaKTsKKwlsZTE2IG1zayA9IGhvc3RfdG9fbGUxNihIVF9DQVBfSU5GT19TSE9SVF9HSTIwTUhaIHwKKwkJCQlIVF9DQVBfSU5GT19TSE9SVF9HSTQwTUhaKTsKIAogCXdwYV9tc2cod3BhX3MsIE1TR19ERUJVRywgInNldF9kaXNhYmxlX3NnaTogJWQiLCBkaXNhYmxlZCk7CiAKQEAgLTI2NjMsNiArMjk1NiwyNyBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX3NldF9kaXNhYmxlX2xkcGMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgICAgICBzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcGFiaWxpdGllcyAqaHRjYXBzLAorCQkJICAgICAgIHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwYWJpbGl0aWVzICpodGNhcHNfbWFzaywKKwkJCSAgICAgICBpbnQgZGlzYWJsZWQpCit7CisJLyogTWFza2luZyB0aGVzZSBvdXQgZGlzYWJsZXMgTERQQyAqLworCWxlMTYgbXNrID0gaG9zdF90b19sZTE2KEhUX0NBUF9JTkZPX0xEUENfQ09ESU5HX0NBUCk7CisKKwl3cGFfbXNnKHdwYV9zLCBNU0dfREVCVUcsICJzZXRfZGlzYWJsZV9sZHBjOiAlZCIsIGRpc2FibGVkKTsKKworCWlmIChkaXNhYmxlZCkKKwkJaHRjYXBzLT5odF9jYXBhYmlsaXRpZXNfaW5mbyAmPSB+bXNrOworCWVsc2UKKwkJaHRjYXBzLT5odF9jYXBhYmlsaXRpZXNfaW5mbyB8PSBtc2s7CisKKwlodGNhcHNfbWFzay0+aHRfY2FwYWJpbGl0aWVzX2luZm8gfD0gbXNrOworCisJcmV0dXJuIDA7Cit9CisKKwogdm9pZCB3cGFfc3VwcGxpY2FudF9hcHBseV9odF9vdmVycmlkZXMoCiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9zc2lkICpzc2lkLAogCXN0cnVjdCB3cGFfZHJpdmVyX2Fzc29jaWF0ZV9wYXJhbXMgKnBhcmFtcykKQEAgLTI2ODYsNiArMzAwMCwxMyBAQAogCXdwYV9zZXRfYW1wZHVfZGVuc2l0eSh3cGFfcywgaHRjYXBzLCBodGNhcHNfbWFzaywgc3NpZC0+YW1wZHVfZGVuc2l0eSk7CiAJd3BhX3NldF9kaXNhYmxlX2h0NDAod3BhX3MsIGh0Y2FwcywgaHRjYXBzX21hc2ssIHNzaWQtPmRpc2FibGVfaHQ0MCk7CiAJd3BhX3NldF9kaXNhYmxlX3NnaSh3cGFfcywgaHRjYXBzLCBodGNhcHNfbWFzaywgc3NpZC0+ZGlzYWJsZV9zZ2kpOworCXdwYV9zZXRfZGlzYWJsZV9sZHBjKHdwYV9zLCBodGNhcHMsIGh0Y2Fwc19tYXNrLCBzc2lkLT5kaXNhYmxlX2xkcGMpOworCisJaWYgKHNzaWQtPmh0NDBfaW50b2xlcmFudCkgeworCQlsZTE2IGJpdCA9IGhvc3RfdG9fbGUxNihIVF9DQVBfSU5GT180ME1IWl9JTlRPTEVSQU5UKTsKKwkJaHRjYXBzLT5odF9jYXBhYmlsaXRpZXNfaW5mbyB8PSBiaXQ7CisJCWh0Y2Fwc19tYXNrLT5odF9jYXBhYmlsaXRpZXNfaW5mbyB8PSBiaXQ7CisJfQogfQogCiAjZW5kaWYgLyogQ09ORklHX0hUX09WRVJSSURFUyAqLwpAQCAtMjY5OCw2ICszMDE5LDEwIEBACiB7CiAJc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzICp2aHRjYXBzOwogCXN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyAqdmh0Y2Fwc19tYXNrOworI2lmZGVmIENPTkZJR19IVF9PVkVSUklERVMKKwlpbnQgbWF4X2FtcGR1OworCWNvbnN0IHUzMiBtYXhfYW1wZHVfbWFzayA9IFZIVF9DQVBfTUFYX0FfTVBEVV9MRU5HVEhfRVhQT05FTlRfTUFYOworI2VuZGlmIC8qIENPTkZJR19IVF9PVkVSUklERVMgKi8KIAogCWlmICghc3NpZCkKIAkJcmV0dXJuOwpAQCAtMjcxMyw2ICszMDM4LDIwIEBACiAJdmh0Y2Fwcy0+dmh0X2NhcGFiaWxpdGllc19pbmZvID0gc3NpZC0+dmh0X2NhcGE7CiAJdmh0Y2Fwc19tYXNrLT52aHRfY2FwYWJpbGl0aWVzX2luZm8gPSBzc2lkLT52aHRfY2FwYV9tYXNrOwogCisjaWZkZWYgQ09ORklHX0hUX09WRVJSSURFUworCS8qIGlmIG1heCBhbXBkdSBpcyA8PSAzLCB3ZSBoYXZlIHRvIG1ha2UgdGhlIEhUIGNhcCB0aGUgc2FtZSAqLworCWlmIChzc2lkLT52aHRfY2FwYV9tYXNrICYgbWF4X2FtcGR1X21hc2spIHsKKwkJbWF4X2FtcGR1ID0gKHNzaWQtPnZodF9jYXBhICYgbWF4X2FtcGR1X21hc2spID4+CisJCQlmaW5kX2ZpcnN0X2JpdChtYXhfYW1wZHVfbWFzayk7CisKKwkJbWF4X2FtcGR1ID0gbWF4X2FtcGR1IDwgMyA/IG1heF9hbXBkdSA6IDM7CisJCXdwYV9zZXRfYW1wZHVfZmFjdG9yKHdwYV9zLAorCQkJCSAgICAgKHZvaWQgKikgcGFyYW1zLT5odGNhcHMsCisJCQkJICAgICAodm9pZCAqKSBwYXJhbXMtPmh0Y2Fwc19tYXNrLAorCQkJCSAgICAgbWF4X2FtcGR1KTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0hUX09WRVJSSURFUyAqLworCiAjZGVmaW5lIE9WRVJSSURFX01DUyhpKQkJCQkJCQlcCiAJaWYgKHNzaWQtPnZodF90eF9tY3NfbnNzXyAjI2kgPj0gMCkgewkJCQlcCiAJCXZodGNhcHNfbWFzay0+dmh0X3N1cHBvcnRlZF9tY3Nfc2V0LnR4X21hcCB8PQkJXApAQCAtMjc0Nyw3ICszMDg2LDcgQEAKIAlpZiAoIXdwYV9zLT5jb25mLT5wY3NjX3JlYWRlcikKIAkJcmV0dXJuIDA7CiAKLQl3cGFfcy0+c2NhcmQgPSBzY2FyZF9pbml0KFNDQVJEX1RSWV9CT1RILCB3cGFfcy0+Y29uZi0+cGNzY19yZWFkZXIpOworCXdwYV9zLT5zY2FyZCA9IHNjYXJkX2luaXQod3BhX3MtPmNvbmYtPnBjc2NfcmVhZGVyKTsKIAlpZiAoIXdwYV9zLT5zY2FyZCkKIAkJcmV0dXJuIDE7CiAKQEAgLTI4MTMsMTAgKzMxNTIsMzI5IEBACiB9CiAKIAorc3RhdGljIGludCB3cGFzX3NldF93b3dsYW5fdHJpZ2dlcnMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgc3RydWN0IHdwYV9kcml2ZXJfY2FwYSAqY2FwYSkKK3sKKwlzdHJ1Y3Qgd293bGFuX3RyaWdnZXJzICp0cmlnZ2VyczsKKwlpbnQgcmV0ID0gMDsKKworCWlmICghd3BhX3MtPmNvbmYtPndvd2xhbl90cmlnZ2VycykKKwkJcmV0dXJuIDA7CisKKwl0cmlnZ2VycyA9IHdwYV9nZXRfd293bGFuX3RyaWdnZXJzKHdwYV9zLT5jb25mLT53b3dsYW5fdHJpZ2dlcnMsIGNhcGEpOworCWlmICh0cmlnZ2VycykgeworCQlyZXQgPSB3cGFfZHJ2X3dvd2xhbih3cGFfcywgdHJpZ2dlcnMpOworCQlvc19mcmVlKHRyaWdnZXJzKTsKKwl9CisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgc3RydWN0IHdwYV9yYWRpbyAqIHJhZGlvX2FkZF9pbnRlcmZhY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICAgY29uc3QgY2hhciAqcm4pCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICppZmFjZSA9IHdwYV9zLT5nbG9iYWwtPmlmYWNlczsKKwlzdHJ1Y3Qgd3BhX3JhZGlvICpyYWRpbzsKKworCXdoaWxlIChybiAmJiBpZmFjZSkgeworCQlyYWRpbyA9IGlmYWNlLT5yYWRpbzsKKwkJaWYgKHJhZGlvICYmIG9zX3N0cmNtcChybiwgcmFkaW8tPm5hbWUpID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQWRkIGludGVyZmFjZSAlcyB0byBleGlzdGluZyByYWRpbyAlcyIsCisJCQkJICAgd3BhX3MtPmlmbmFtZSwgcm4pOworCQkJZGxfbGlzdF9hZGQoJnJhZGlvLT5pZmFjZXMsICZ3cGFfcy0+cmFkaW9fbGlzdCk7CisJCQlyZXR1cm4gcmFkaW87CisJCX0KKworCQlpZmFjZSA9IGlmYWNlLT5uZXh0OworCX0KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQWRkIGludGVyZmFjZSAlcyB0byBhIG5ldyByYWRpbyAlcyIsCisJCSAgIHdwYV9zLT5pZm5hbWUsIHJuID8gcm4gOiAiTi9BIik7CisJcmFkaW8gPSBvc196YWxsb2Moc2l6ZW9mKCpyYWRpbykpOworCWlmIChyYWRpbyA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChybikKKwkJb3Nfc3RybGNweShyYWRpby0+bmFtZSwgcm4sIHNpemVvZihyYWRpby0+bmFtZSkpOworCWRsX2xpc3RfaW5pdCgmcmFkaW8tPmlmYWNlcyk7CisJZGxfbGlzdF9pbml0KCZyYWRpby0+d29yayk7CisJZGxfbGlzdF9hZGQoJnJhZGlvLT5pZmFjZXMsICZ3cGFfcy0+cmFkaW9fbGlzdCk7CisKKwlyZXR1cm4gcmFkaW87Cit9CisKKworc3RhdGljIHZvaWQgcmFkaW9fd29ya19mcmVlKHN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yaykKK3sKKwlpZiAod29yay0+d3BhX3MtPnNjYW5fd29yayA9PSB3b3JrKSB7CisJCS8qIFRoaXMgc2hvdWxkIG5vdCByZWFsbHkgaGFwcGVuLiAqLworCQl3cGFfZGJnKHdvcmstPndwYV9zLCBNU0dfSU5GTywgIkZyZWVpbmcgcmFkaW8gd29yayAnJXMnQCVwIChzdGFydGVkPSVkKSB0aGF0IGlzIG1hcmtlZCBhcyBzY2FuX3dvcmsiLAorCQkJd29yay0+dHlwZSwgd29yaywgd29yay0+c3RhcnRlZCk7CisJCXdvcmstPndwYV9zLT5zY2FuX3dvcmsgPSBOVUxMOworCX0KKworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAod29yay0+d3BhX3MtPnAycF9zY2FuX3dvcmsgPT0gd29yaykgeworCQkvKiBUaGlzIHNob3VsZCBub3QgcmVhbGx5IGhhcHBlbi4gKi8KKwkJd3BhX2RiZyh3b3JrLT53cGFfcywgTVNHX0lORk8sICJGcmVlaW5nIHJhZGlvIHdvcmsgJyVzJ0AlcCAoc3RhcnRlZD0lZCkgdGhhdCBpcyBtYXJrZWQgYXMgcDJwX3NjYW5fd29yayIsCisJCQl3b3JrLT50eXBlLCB3b3JrLCB3b3JrLT5zdGFydGVkKTsKKwkJd29yay0+d3BhX3MtPnAycF9zY2FuX3dvcmsgPSBOVUxMOworCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKKwlkbF9saXN0X2RlbCgmd29yay0+bGlzdCk7CisJb3NfZnJlZSh3b3JrKTsKK30KKworCitzdGF0aWMgdm9pZCByYWRpb19zdGFydF9uZXh0X3dvcmsodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKK3sKKwlzdHJ1Y3Qgd3BhX3JhZGlvICpyYWRpbyA9IGVsb29wX2N0eDsKKwlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcms7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93LCBkaWZmOworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3M7CisKKwl3b3JrID0gZGxfbGlzdF9maXJzdCgmcmFkaW8tPndvcmssIHN0cnVjdCB3cGFfcmFkaW9fd29yaywgbGlzdCk7CisJaWYgKHdvcmsgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJaWYgKHdvcmstPnN0YXJ0ZWQpCisJCXJldHVybjsgLyogYWxyZWFkeSBzdGFydGVkIGFuZCBzdGlsbCBpbiBwcm9ncmVzcyAqLworCisJd3BhX3MgPSBkbF9saXN0X2ZpcnN0KCZyYWRpby0+aWZhY2VzLCBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQsCisJCQkgICAgICByYWRpb19saXN0KTsKKwlpZiAod3BhX3MgJiYgd3BhX3MtPmV4dGVybmFsX3NjYW5fcnVubmluZykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRlbGF5IHJhZGlvIHdvcmsgc3RhcnQgdW50aWwgZXh0ZXJuYWxseSB0cmlnZ2VyZWQgc2NhbiBjb21wbGV0ZXMiKTsKKwkJcmV0dXJuOworCX0KKworCW9zX2dldF9yZWx0aW1lKCZub3cpOworCW9zX3JlbHRpbWVfc3ViKCZub3csICZ3b3JrLT50aW1lLCAmZGlmZik7CisJd3BhX2RiZyh3b3JrLT53cGFfcywgTVNHX0RFQlVHLCAiU3RhcnRpbmcgcmFkaW8gd29yayAnJXMnQCVwIGFmdGVyICVsZC4lMDZsZCBzZWNvbmQgd2FpdCIsCisJCXdvcmstPnR5cGUsIHdvcmssIGRpZmYuc2VjLCBkaWZmLnVzZWMpOworCXdvcmstPnN0YXJ0ZWQgPSAxOworCXdvcmstPnRpbWUgPSBub3c7CisJd29yay0+Y2Iod29yaywgMCk7Cit9CisKKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gcmVtb3ZlcyBib3RoIHN0YXJ0ZWQgYW5kIHBlbmRpbmcgcmFkaW8gd29ya3MgcnVubmluZyBvbgorICogdGhlIHByb3ZpZGVkIGludGVyZmFjZSdzIHJhZGlvLgorICogUHJpb3IgdG8gdGhlIHJlbW92YWwgb2YgdGhlIHJhZGlvIHdvcmssIGl0cyBjYWxsYmFjayAoY2IpIGlzIGNhbGxlZCB3aXRoCisgKiBkZWluaXQgc2V0IHRvIGJlIDEuIEVhY2ggd29yaydzIGNhbGxiYWNrIGlzIHJlc3BvbnNpYmxlIGZvciBjbGVhcmluZyBpdHMKKyAqIGludGVybmFsIGRhdGEgYW5kIHJlc3RvcmluZyB0byBhIGNvcnJlY3Qgc3RhdGUuCisgKiBAd3BhX3M6IHdwYV9zdXBwbGljYW50IGRhdGEKKyAqIEB0eXBlOiB0eXBlIG9mIHdvcmtzIHRvIGJlIHJlbW92ZWQKKyAqIEByZW1vdmVfYWxsOiAxIHRvIHJlbW92ZSBhbGwgdGhlIHdvcmtzIG9uIHRoaXMgcmFkaW8sIDAgdG8gcmVtb3ZlIG9ubHkKKyAqIHRoaXMgaW50ZXJmYWNlJ3Mgd29ya3MuCisgKi8KK3ZvaWQgcmFkaW9fcmVtb3ZlX3dvcmtzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQljb25zdCBjaGFyICp0eXBlLCBpbnQgcmVtb3ZlX2FsbCkKK3sKKwlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcmssICp0bXA7CisJc3RydWN0IHdwYV9yYWRpbyAqcmFkaW8gPSB3cGFfcy0+cmFkaW87CisKKwlkbF9saXN0X2Zvcl9lYWNoX3NhZmUod29yaywgdG1wLCAmcmFkaW8tPndvcmssIHN0cnVjdCB3cGFfcmFkaW9fd29yaywKKwkJCSAgICAgIGxpc3QpIHsKKwkJaWYgKHR5cGUgJiYgb3Nfc3RyY21wKHR5cGUsIHdvcmstPnR5cGUpICE9IDApCisJCQljb250aW51ZTsKKworCQkvKiBza2lwIG90aGVyIGlmYWNlcycgd29ya3MgKi8KKwkJaWYgKCFyZW1vdmVfYWxsICYmIHdvcmstPndwYV9zICE9IHdwYV9zKQorCQkJY29udGludWU7CisKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUmVtb3ZlIHJhZGlvIHdvcmsgJyVzJ0AlcCVzIiwKKwkJCXdvcmstPnR5cGUsIHdvcmssIHdvcmstPnN0YXJ0ZWQgPyAiIChzdGFydGVkKSIgOiAiIik7CisJCXdvcmstPmNiKHdvcmssIDEpOworCQlyYWRpb193b3JrX2ZyZWUod29yayk7CisJfQorCisJLyogaW4gY2FzZSB3ZSByZW1vdmVkIHRoZSBzdGFydGVkIHdvcmsgKi8KKwlyYWRpb193b3JrX2NoZWNrX25leHQod3BhX3MpOworfQorCisKK3N0YXRpYyB2b2lkIHJhZGlvX3JlbW92ZV9pbnRlcmZhY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlzdHJ1Y3Qgd3BhX3JhZGlvICpyYWRpbyA9IHdwYV9zLT5yYWRpbzsKKworCWlmICghcmFkaW8pCisJCXJldHVybjsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUmVtb3ZlIGludGVyZmFjZSAlcyBmcm9tIHJhZGlvICVzIiwKKwkJICAgd3BhX3MtPmlmbmFtZSwgcmFkaW8tPm5hbWUpOworCWRsX2xpc3RfZGVsKCZ3cGFfcy0+cmFkaW9fbGlzdCk7CisJcmFkaW9fcmVtb3ZlX3dvcmtzKHdwYV9zLCBOVUxMLCAwKTsKKwl3cGFfcy0+cmFkaW8gPSBOVUxMOworCWlmICghZGxfbGlzdF9lbXB0eSgmcmFkaW8tPmlmYWNlcykpCisJCXJldHVybjsgLyogSW50ZXJmYWNlcyByZW1haW4gZm9yIHRoaXMgcmFkaW8gKi8KKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUmVtb3ZlIHJhZGlvICVzIiwgcmFkaW8tPm5hbWUpOworCWVsb29wX2NhbmNlbF90aW1lb3V0KHJhZGlvX3N0YXJ0X25leHRfd29yaywgcmFkaW8sIE5VTEwpOworCW9zX2ZyZWUocmFkaW8pOworfQorCisKK3ZvaWQgcmFkaW9fd29ya19jaGVja19uZXh0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJc3RydWN0IHdwYV9yYWRpbyAqcmFkaW8gPSB3cGFfcy0+cmFkaW87CisKKwlpZiAoZGxfbGlzdF9lbXB0eSgmcmFkaW8tPndvcmspKQorCQlyZXR1cm47CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQocmFkaW9fc3RhcnRfbmV4dF93b3JrLCByYWRpbywgTlVMTCk7CisJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLCByYWRpb19zdGFydF9uZXh0X3dvcmssIHJhZGlvLCBOVUxMKTsKK30KKworCisvKioKKyAqIHJhZGlvX2FkZF93b3JrIC0gQWRkIGEgcmFkaW8gd29yayBpdGVtCisgKiBAd3BhX3M6IFBvaW50ZXIgdG8gd3BhX3N1cHBsaWNhbnQgZGF0YQorICogQGZyZXE6IEZyZXF1ZW5jeSBvZiB0aGUgb2ZmY2hhbm5lbCBvcGVyYXRpb24gaW4gTUh6IG9yIDAKKyAqIEB0eXBlOiBVbmlxdWUgaWRlbnRpZmllciBmb3IgZWFjaCB0eXBlIG9mIHdvcmsKKyAqIEBuZXh0OiBGb3JjZSBhcyB0aGUgbmV4dCB3b3JrIHRvIGJlIGV4ZWN1dGVkCisgKiBAY2I6IENhbGxiYWNrIGZ1bmN0aW9uIGZvciBpbmRpY2F0aW5nIHdoZW4gcmFkaW8gaXMgYXZhaWxhYmxlCisgKiBAY3R4OiBDb250ZXh0IHBvaW50ZXIgZm9yIHRoZSB3b3JrICh3b3JrLT5jdHggaW4gY2IoKSkKKyAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQorICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byByZXF1ZXN0IHRpbWUgZm9yIGFuIG9wZXJhdGlvbiB0aGF0IHJlcXVpcmVzCisgKiBleGNsdXNpdmUgcmFkaW8gY29udHJvbC4gT25jZSB0aGUgcmFkaW8gaXMgYXZhaWxhYmxlLCB0aGUgcmVnaXN0ZXJlZCBjYWxsYmFjaworICogZnVuY3Rpb24gd2lsbCBiZSBjYWxsZWQuIHJhZGlvX3dvcmtfZG9uZSgpIG11c3QgYmUgY2FsbGVkIG9uY2UgdGhlIGV4Y2x1c2l2ZQorICogcmFkaW8gb3BlcmF0aW9uIGhhcyBiZWVuIGNvbXBsZXRlZCwgc28gdGhhdCB0aGUgcmFkaW8gaXMgZnJlZWQgZm9yIG90aGVyCisgKiBvcGVyYXRpb25zLiBUaGUgc3BlY2lhbCBjYXNlIG9mIGRlaW5pdD0xIGlzIHVzZWQgdG8gZnJlZSB0aGUgY29udGV4dCBkYXRhCisgKiBkdXJpbmcgaW50ZXJmYWNlIHJlbW92YWwuIFRoYXQgZG9lcyBub3QgYWxsb3cgdGhlIGNhbGxiYWNrIGZ1bmN0aW9uIHRvIHN0YXJ0CisgKiB0aGUgcmFkaW8gb3BlcmF0aW9uLCBpLmUuLCBpdCBtdXN0IGZyZWUgYW55IHJlc291cmNlcyBhbGxvY2F0ZWQgZm9yIHRoZSByYWRpbworICogd29yayBhbmQgcmV0dXJuLgorICoKKyAqIFRoZSBAZnJlcSBwYXJhbWV0ZXIgY2FuIGJlIHVzZWQgdG8gaW5kaWNhdGUgYSBzaW5nbGUgY2hhbm5lbCBvbiB3aGljaCB0aGUKKyAqIG9mZmNoYW5uZWwgb3BlcmF0aW9uIHdpbGwgb2NjdXIuIFRoaXMgbWF5IGFsbG93IG11bHRpcGxlIHJhZGlvIHdvcmsKKyAqIG9wZXJhdGlvbnMgdG8gYmUgcGVyZm9ybWVkIGluIHBhcmFsbGVsIGlmIHRoZXkgYXBwbHkgZm9yIHRoZSBzYW1lIGNoYW5uZWwuCisgKiBTZXR0aW5nIHRoaXMgdG8gMCBpbmRpY2F0ZXMgdGhhdCB0aGUgd29yayBpdGVtIG1heSB1c2UgbXVsdGlwbGUgY2hhbm5lbHMgb3IKKyAqIHJlcXVpcmVzIGV4Y2x1c2l2ZSBjb250cm9sIG9mIHRoZSByYWRpby4KKyAqLworaW50IHJhZGlvX2FkZF93b3JrKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHVuc2lnbmVkIGludCBmcmVxLAorCQkgICBjb25zdCBjaGFyICp0eXBlLCBpbnQgbmV4dCwKKwkJICAgdm9pZCAoKmNiKShzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcmssIGludCBkZWluaXQpLAorCQkgICB2b2lkICpjdHgpCit7CisJc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrOworCWludCB3YXNfZW1wdHk7CisKKwl3b3JrID0gb3NfemFsbG9jKHNpemVvZigqd29yaykpOworCWlmICh3b3JrID09IE5VTEwpCisJCXJldHVybiAtMTsKKwl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJBZGQgcmFkaW8gd29yayAnJXMnQCVwIiwgdHlwZSwgd29yayk7CisJb3NfZ2V0X3JlbHRpbWUoJndvcmstPnRpbWUpOworCXdvcmstPmZyZXEgPSBmcmVxOworCXdvcmstPnR5cGUgPSB0eXBlOworCXdvcmstPndwYV9zID0gd3BhX3M7CisJd29yay0+Y2IgPSBjYjsKKwl3b3JrLT5jdHggPSBjdHg7CisKKwl3YXNfZW1wdHkgPSBkbF9saXN0X2VtcHR5KCZ3cGFfcy0+cmFkaW8tPndvcmspOworCWlmIChuZXh0KQorCQlkbF9saXN0X2FkZCgmd3BhX3MtPnJhZGlvLT53b3JrLCAmd29yay0+bGlzdCk7CisJZWxzZQorCQlkbF9saXN0X2FkZF90YWlsKCZ3cGFfcy0+cmFkaW8tPndvcmssICZ3b3JrLT5saXN0KTsKKwlpZiAod2FzX2VtcHR5KSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkZpcnN0IHJhZGlvIHdvcmsgaXRlbSBpbiB0aGUgcXVldWUgLSBzY2hlZHVsZSBzdGFydCBpbW1lZGlhdGVseSIpOworCQlyYWRpb193b3JrX2NoZWNrX25leHQod3BhX3MpOworCX0KKworCXJldHVybiAwOworfQorCisKKy8qKgorICogcmFkaW9fd29ya19kb25lIC0gSW5kaWNhdGUgdGhhdCBhIHJhZGlvIHdvcmsgaXRlbSBoYXMgYmVlbiBjb21wbGV0ZWQKKyAqIEB3b3JrOiBDb21wbGV0ZWQgd29yaworICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIG9uY2UgdGhlIGNhbGxiYWNrIGZ1bmN0aW9uIHJlZ2lzdGVyZWQgd2l0aAorICogcmFkaW9fYWRkX3dvcmsoKSBoYXMgY29tcGxldGVkIGl0cyB3b3JrLgorICovCit2b2lkIHJhZGlvX3dvcmtfZG9uZShzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKndvcmspCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHdvcmstPndwYV9zOworCXN0cnVjdCBvc19yZWx0aW1lIG5vdywgZGlmZjsKKwl1bnNpZ25lZCBpbnQgc3RhcnRlZCA9IHdvcmstPnN0YXJ0ZWQ7CisKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKKwlvc19yZWx0aW1lX3N1Yigmbm93LCAmd29yay0+dGltZSwgJmRpZmYpOworCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlJhZGlvIHdvcmsgJyVzJ0AlcCAlcyBpbiAlbGQuJTA2bGQgc2Vjb25kcyIsCisJCXdvcmstPnR5cGUsIHdvcmssIHN0YXJ0ZWQgPyAiZG9uZSIgOiAiY2FuY2VsZWQiLAorCQlkaWZmLnNlYywgZGlmZi51c2VjKTsKKwlyYWRpb193b3JrX2ZyZWUod29yayk7CisJaWYgKHN0YXJ0ZWQpCisJCXJhZGlvX3dvcmtfY2hlY2tfbmV4dCh3cGFfcyk7Cit9CisKKworaW50IHJhZGlvX3dvcmtfcGVuZGluZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCBjaGFyICp0eXBlKQoreworCXN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yazsKKwlzdHJ1Y3Qgd3BhX3JhZGlvICpyYWRpbyA9IHdwYV9zLT5yYWRpbzsKKworCWRsX2xpc3RfZm9yX2VhY2god29yaywgJnJhZGlvLT53b3JrLCBzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmssIGxpc3QpIHsKKwkJaWYgKHdvcmstPndwYV9zID09IHdwYV9zICYmIG9zX3N0cmNtcCh3b3JrLT50eXBlLCB0eXBlKSA9PSAwKQorCQkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cGFzX2luaXRfZHJpdmVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICAgc3RydWN0IHdwYV9pbnRlcmZhY2UgKmlmYWNlKQoreworCWNvbnN0IGNoYXIgKmlmbmFtZSwgKmRyaXZlciwgKnJuOworCisJZHJpdmVyID0gaWZhY2UtPmRyaXZlcjsKK25leHRfZHJpdmVyOgorCWlmICh3cGFfc3VwcGxpY2FudF9zZXRfZHJpdmVyKHdwYV9zLCBkcml2ZXIpIDwgMCkKKwkJcmV0dXJuIC0xOworCisJd3BhX3MtPmRydl9wcml2ID0gd3BhX2Rydl9pbml0KHdwYV9zLCB3cGFfcy0+aWZuYW1lKTsKKwlpZiAod3BhX3MtPmRydl9wcml2ID09IE5VTEwpIHsKKwkJY29uc3QgY2hhciAqcG9zOworCQlwb3MgPSBkcml2ZXIgPyBvc19zdHJjaHIoZHJpdmVyLCAnLCcpIDogTlVMTDsKKwkJaWYgKHBvcykgeworCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiRmFpbGVkIHRvIGluaXRpYWxpemUgIgorCQkJCSJkcml2ZXIgaW50ZXJmYWNlIC0gdHJ5IG5leHQgZHJpdmVyIHdyYXBwZXIiKTsKKwkJCWRyaXZlciA9IHBvcyArIDE7CisJCQlnb3RvIG5leHRfZHJpdmVyOworCQl9CisJCXdwYV9tc2cod3BhX3MsIE1TR19FUlJPUiwgIkZhaWxlZCB0byBpbml0aWFsaXplIGRyaXZlciAiCisJCQkiaW50ZXJmYWNlIik7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKHdwYV9kcnZfc2V0X3BhcmFtKHdwYV9zLCB3cGFfcy0+Y29uZi0+ZHJpdmVyX3BhcmFtKSA8IDApIHsKKwkJd3BhX21zZyh3cGFfcywgTVNHX0VSUk9SLCAiRHJpdmVyIGludGVyZmFjZSByZWplY3RlZCAiCisJCQkiZHJpdmVyX3BhcmFtICclcyciLCB3cGFfcy0+Y29uZi0+ZHJpdmVyX3BhcmFtKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmbmFtZSA9IHdwYV9kcnZfZ2V0X2lmbmFtZSh3cGFfcyk7CisJaWYgKGlmbmFtZSAmJiBvc19zdHJjbXAoaWZuYW1lLCB3cGFfcy0+aWZuYW1lKSAhPSAwKSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkRyaXZlciBpbnRlcmZhY2UgcmVwbGFjZWQgIgorCQkJImludGVyZmFjZSBuYW1lIHdpdGggJyVzJyIsIGlmbmFtZSk7CisJCW9zX3N0cmxjcHkod3BhX3MtPmlmbmFtZSwgaWZuYW1lLCBzaXplb2Yod3BhX3MtPmlmbmFtZSkpOworCX0KKworCXJuID0gd3BhX2RyaXZlcl9nZXRfcmFkaW9fbmFtZSh3cGFfcyk7CisJaWYgKHJuICYmIHJuWzBdID09ICdcMCcpCisJCXJuID0gTlVMTDsKKworCXdwYV9zLT5yYWRpbyA9IHJhZGlvX2FkZF9pbnRlcmZhY2Uod3BhX3MsIHJuKTsKKwlpZiAod3BhX3MtPnJhZGlvID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXJldHVybiAwOworfQorCisKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfaW5pdF9pZmFjZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgICAgc3RydWN0IHdwYV9pbnRlcmZhY2UgKmlmYWNlKQogewotCWNvbnN0IGNoYXIgKmlmbmFtZSwgKmRyaXZlcjsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhIGNhcGE7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkluaXRpYWxpemluZyBpbnRlcmZhY2UgJyVzJyBjb25mICclcycgZHJpdmVyICIKQEAgLTI4NDksNiArMzUwNywxMyBAQAogCQl3cGFfcy0+Y29uZmFub3RoZXIgPSBvc19yZWwyYWJzX3BhdGgoaWZhY2UtPmNvbmZhbm90aGVyKTsKIAkJd3BhX2NvbmZpZ19yZWFkKHdwYV9zLT5jb25mYW5vdGhlciwgd3BhX3MtPmNvbmYpOwogCisjaWZkZWYgQ09ORklHX1AyUAorCQl3cGFfcy0+Y29uZl9wMnBfZGV2ID0gb3NfcmVsMmFic19wYXRoKGlmYWNlLT5jb25mX3AycF9kZXYpOworI2lmbmRlZiBBTkRST0lEX1AyUAorCQl3cGFfY29uZmlnX3JlYWQod3BhX3MtPmNvbmZfcDJwX2Rldiwgd3BhX3MtPmNvbmYpOworI2VuZGlmCisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCiAJCS8qCiAJCSAqIE92ZXJyaWRlIGN0cmxfaW50ZXJmYWNlIGFuZCBkcml2ZXJfcGFyYW0gaWYgc2V0IG9uIGNvbW1hbmQKIAkJICogbGluZS4KQEAgLTI5MDgsMzggKzM1NzMsOSBAQAogCSAqIEwyIHJlY2VpdmUgaGFuZGxlciBzbyB0aGF0IGFzc29jaWF0aW9uIGV2ZW50cyBhcmUgcHJvY2Vzc2VkIGJlZm9yZQogCSAqIEVBUE9MLUtleSBwYWNrZXRzIGlmIGJvdGggYmVjb21lIGF2YWlsYWJsZSBmb3IgdGhlIHNhbWUgc2VsZWN0KCkKIAkgKiBjYWxsLiAqLwotCWRyaXZlciA9IGlmYWNlLT5kcml2ZXI7Ci1uZXh0X2RyaXZlcjoKLQlpZiAod3BhX3N1cHBsaWNhbnRfc2V0X2RyaXZlcih3cGFfcywgZHJpdmVyKSA8IDApCisJaWYgKHdwYXNfaW5pdF9kcml2ZXIod3BhX3MsIGlmYWNlKSA8IDApCiAJCXJldHVybiAtMTsKIAotCXdwYV9zLT5kcnZfcHJpdiA9IHdwYV9kcnZfaW5pdCh3cGFfcywgd3BhX3MtPmlmbmFtZSk7Ci0JaWYgKHdwYV9zLT5kcnZfcHJpdiA9PSBOVUxMKSB7Ci0JCWNvbnN0IGNoYXIgKnBvczsKLQkJcG9zID0gZHJpdmVyID8gb3Nfc3RyY2hyKGRyaXZlciwgJywnKSA6IE5VTEw7Ci0JCWlmIChwb3MpIHsKLQkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkZhaWxlZCB0byBpbml0aWFsaXplICIKLQkJCQkiZHJpdmVyIGludGVyZmFjZSAtIHRyeSBuZXh0IGRyaXZlciB3cmFwcGVyIik7Ci0JCQlkcml2ZXIgPSBwb3MgKyAxOwotCQkJZ290byBuZXh0X2RyaXZlcjsKLQkJfQotCQl3cGFfbXNnKHdwYV9zLCBNU0dfRVJST1IsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSBkcml2ZXIgIgotCQkJImludGVyZmFjZSIpOwotCQlyZXR1cm4gLTE7Ci0JfQotCWlmICh3cGFfZHJ2X3NldF9wYXJhbSh3cGFfcywgd3BhX3MtPmNvbmYtPmRyaXZlcl9wYXJhbSkgPCAwKSB7Ci0JCXdwYV9tc2cod3BhX3MsIE1TR19FUlJPUiwgIkRyaXZlciBpbnRlcmZhY2UgcmVqZWN0ZWQgIgotCQkJImRyaXZlcl9wYXJhbSAnJXMnIiwgd3BhX3MtPmNvbmYtPmRyaXZlcl9wYXJhbSk7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlpZm5hbWUgPSB3cGFfZHJ2X2dldF9pZm5hbWUod3BhX3MpOwotCWlmIChpZm5hbWUgJiYgb3Nfc3RyY21wKGlmbmFtZSwgd3BhX3MtPmlmbmFtZSkgIT0gMCkgewotCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJEcml2ZXIgaW50ZXJmYWNlIHJlcGxhY2VkICIKLQkJCSJpbnRlcmZhY2UgbmFtZSB3aXRoICclcyciLCBpZm5hbWUpOwotCQlvc19zdHJsY3B5KHdwYV9zLT5pZm5hbWUsIGlmbmFtZSwgc2l6ZW9mKHdwYV9zLT5pZm5hbWUpKTsKLQl9Ci0KIAlpZiAod3BhX3N1cHBsaWNhbnRfaW5pdF93cGEod3BhX3MpIDwgMCkKIAkJcmV0dXJuIC0xOwogCkBAIC0zMDUzLDIwICszNjg5LDI3IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLSNpZmRlZiBDT05GSUdfUDJQCiAJaWYgKGlmYWNlLT5wMnBfbWdtdCAmJiB3cGFzX3AycF9pbml0KHdwYV9zLT5nbG9iYWwsIHdwYV9zKSA8IDApIHsKIAkJd3BhX21zZyh3cGFfcywgTVNHX0VSUk9SLCAiRmFpbGVkIHRvIGluaXQgUDJQIik7CiAJCXJldHVybiAtMTsKIAl9Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCiAJaWYgKHdwYV9ic3NfaW5pdCh3cGFfcykgPCAwKQogCQlyZXR1cm4gLTE7CiAKKwkvKgorCSAqIFNldCBXYWtlLW9uLVdMQU4gdHJpZ2dlcnMsIGlmIGNvbmZpZ3VyZWQuCisJICogTm90ZTogV2UgZG9uJ3QgcmVzdG9yZS9yZW1vdmUgdGhlIHRyaWdnZXJzIG9uIHNodXRkb3duIChpdCBkb2Vzbid0CisJICogaGF2ZSBlZmZlY3QgYW55d2F5IHdoZW4gdGhlIGludGVyZmFjZSBpcyBkb3duKS4KKwkgKi8KKwlpZiAod3Bhc19zZXRfd293bGFuX3RyaWdnZXJzKHdwYV9zLCAmY2FwYSkgPCAwKQorCQlyZXR1cm4gLTE7CisKICNpZmRlZiBDT05GSUdfRUFQX1BST1hZCiB7CiAJc2l6ZV90IGxlbjsKLQl3cGFfcy0+bW5jX2xlbiA9IGVhcF9wcm94eV9nZXRfaW1zaSh3cGFfcy0+aW1zaSwgJmxlbik7CisJd3BhX3MtPm1uY19sZW4gPSBlYXBvbF9zbV9nZXRfZWFwX3Byb3h5X2ltc2kod3BhX3MtPmVhcG9sLCB3cGFfcy0+aW1zaSwKKwkJCQkJCSAgICAgJmxlbik7CiAJaWYgKHdwYV9zLT5tbmNfbGVuID4gMCkgewogCQl3cGFfcy0+aW1zaVtsZW5dID0gJ1wwJzsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJlYXBfcHJveHk6IElNU0kgJXMgKE1OQyBsZW5ndGggJWQpIiwKQEAgLTMxMDAsMTQgKzM3NDMsMTAgQEAKIAl9CiAKIAl3cGFfc3VwcGxpY2FudF9jbGVhbnVwKHdwYV9zKTsKKwl3cGFzX3AycF9kZWluaXRfaWZhY2Uod3BhX3MpOwogCi0jaWZkZWYgQ09ORklHX1AyUAotCWlmICh3cGFfcyA9PSB3cGFfcy0+Z2xvYmFsLT5wMnBfaW5pdF93cGFfcyAmJiB3cGFfcy0+Z2xvYmFsLT5wMnApIHsKLQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBEaXNhYmxlIFAyUCBzaW5jZSByZW1vdmluZyAiCi0JCQkidGhlIG1hbmFnZW1lbnQgaW50ZXJmYWNlIGlzIGJlaW5nIHJlbW92ZWQiKTsKLQkJd3Bhc19wMnBfZGVpbml0X2dsb2JhbCh3cGFfcy0+Z2xvYmFsKTsKLQl9Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLworCXdwYXNfY3RybF9yYWRpb193b3JrX2ZsdXNoKHdwYV9zKTsKKwlyYWRpb19yZW1vdmVfaW50ZXJmYWNlKHdwYV9zKTsKIAogCWlmICh3cGFfcy0+ZHJ2X3ByaXYpCiAJCXdwYV9kcnZfZGVpbml0KHdwYV9zKTsKQEAgLTM1MDIsNyArNDE0MSw4IEBACiAJb3NfZnJlZShnbG9iYWwtPnBhcmFtcy5vdmVycmlkZV9kcml2ZXIpOwogCW9zX2ZyZWUoZ2xvYmFsLT5wYXJhbXMub3ZlcnJpZGVfY3RybF9pbnRlcmZhY2UpOwogCi0Jb3NfZnJlZShnbG9iYWwtPnAycF9kaXNhbGxvd19mcmVxKTsKKwlvc19mcmVlKGdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXEucmFuZ2UpOworCW9zX2ZyZWUoZ2xvYmFsLT5wMnBfZ29fYXZvaWRfZnJlcS5yYW5nZSk7CiAJb3NfZnJlZShnbG9iYWwtPmFkZF9wc2spOwogCiAJb3NfZnJlZShnbG9iYWwpOwpAQCAtMzUzMiwxMSArNDE3Miw3IEBACiAjaWZkZWYgQ09ORklHX1dQUwogCXdwYXNfd3BzX3VwZGF0ZV9jb25maWcod3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KLQotI2lmZGVmIENPTkZJR19QMlAKIAl3cGFzX3AycF91cGRhdGVfY29uZmlnKHdwYV9zKTsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCi0KIAl3cGFfcy0+Y29uZi0+Y2hhbmdlZF9wYXJhbWV0ZXJzID0gMDsKIH0KIApAQCAtMzU5NSw2ICs0MjMxLDggQEAKIAlpbnQgY291bnQ7CiAJaW50ICpmcmVxcyA9IE5VTEw7CiAKKwl3cGFzX2Nvbm5lY3Rfd29ya19kb25lKHdwYV9zKTsKKwogCS8qCiAJICogUmVtb3ZlIHBvc3NpYmxlIGF1dGhlbnRpY2F0aW9uIHRpbWVvdXQgc2luY2UgdGhlIGNvbm5lY3Rpb24gZmFpbGVkLgogCSAqLwpAQCAtMzY1MSw3ICs0Mjg5LDcgQEAKIAlpZiAoY291bnQgPiAzICYmIHdwYV9zLT5jdXJyZW50X3NzaWQpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDb250aW51b3VzIGFzc29jaWF0aW9uIGZhaWx1cmVzIC0gIgogCQkJICAgImNvbnNpZGVyIHRlbXBvcmFyeSBuZXR3b3JrIGRpc2FibGluZyIpOwotCQl3cGFzX2F1dGhfZmFpbGVkKHdwYV9zKTsKKwkJd3Bhc19hdXRoX2ZhaWxlZCh3cGFfcywgIkNPTk5fRkFJTEVEIik7CiAJfQogCiAJc3dpdGNoIChjb3VudCkgewpAQCAtMzY4MSw4ICs0MzE5LDYgQEAKIAkgKi8KIAl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgdGltZW91dCAvIDEwMDAsCiAJCQkJMTAwMCAqICh0aW1lb3V0ICUgMTAwMCkpOwotCi0Jd3Bhc19wMnBfY29udGludWVfYWZ0ZXJfc2Nhbih3cGFfcyk7CiB9CiAKIApAQCAtMzcxNiw3ICs0MzUyLDcgQEAKIAkJCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7CiAJCWJyZWFrOwogCWNhc2UgV1BBX0NUUkxfUkVRX0VBUF9QQVNTV09SRDoKLQkJb3NfZnJlZShlYXAtPnBhc3N3b3JkKTsKKwkJYmluX2NsZWFyX2ZyZWUoZWFwLT5wYXNzd29yZCwgZWFwLT5wYXNzd29yZF9sZW4pOwogCQllYXAtPnBhc3N3b3JkID0gKHU4ICopIG9zX3N0cmR1cCh2YWx1ZSk7CiAJCWVhcC0+cGFzc3dvcmRfbGVuID0gb3Nfc3RybGVuKHZhbHVlKTsKIAkJZWFwLT5wZW5kaW5nX3JlcV9wYXNzd29yZCA9IDA7CkBAIC0zNzI0LDcgKzQzNjAsNyBAQAogCQkJd3BhX3MtPnJlYXNzb2NpYXRlID0gMTsKIAkJYnJlYWs7CiAJY2FzZSBXUEFfQ1RSTF9SRVFfRUFQX05FV19QQVNTV09SRDoKLQkJb3NfZnJlZShlYXAtPm5ld19wYXNzd29yZCk7CisJCWJpbl9jbGVhcl9mcmVlKGVhcC0+bmV3X3Bhc3N3b3JkLCBlYXAtPm5ld19wYXNzd29yZF9sZW4pOwogCQllYXAtPm5ld19wYXNzd29yZCA9ICh1OCAqKSBvc19zdHJkdXAodmFsdWUpOwogCQllYXAtPm5ld19wYXNzd29yZF9sZW4gPSBvc19zdHJsZW4odmFsdWUpOwogCQllYXAtPnBlbmRpbmdfcmVxX25ld19wYXNzd29yZCA9IDA7CkBAIC0zNzMyLDE0ICs0MzY4LDE0IEBACiAJCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwogCQlicmVhazsKIAljYXNlIFdQQV9DVFJMX1JFUV9FQVBfUElOOgotCQlvc19mcmVlKGVhcC0+cGluKTsKKwkJc3RyX2NsZWFyX2ZyZWUoZWFwLT5waW4pOwogCQllYXAtPnBpbiA9IG9zX3N0cmR1cCh2YWx1ZSk7CiAJCWVhcC0+cGVuZGluZ19yZXFfcGluID0gMDsKIAkJaWYgKHNzaWQgPT0gd3BhX3MtPmN1cnJlbnRfc3NpZCkKIAkJCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7CiAJCWJyZWFrOwogCWNhc2UgV1BBX0NUUkxfUkVRX0VBUF9PVFA6Ci0JCW9zX2ZyZWUoZWFwLT5vdHApOworCQliaW5fY2xlYXJfZnJlZShlYXAtPm90cCwgZWFwLT5vdHBfbGVuKTsKIAkJZWFwLT5vdHAgPSAodTggKikgb3Nfc3RyZHVwKHZhbHVlKTsKIAkJZWFwLT5vdHBfbGVuID0gb3Nfc3RybGVuKHZhbHVlKTsKIAkJb3NfZnJlZShlYXAtPnBlbmRpbmdfcmVxX290cCk7CkBAIC0zNzQ3LDEyICs0MzgzLDE2IEBACiAJCWVhcC0+cGVuZGluZ19yZXFfb3RwX2xlbiA9IDA7CiAJCWJyZWFrOwogCWNhc2UgV1BBX0NUUkxfUkVRX0VBUF9QQVNTUEhSQVNFOgotCQlvc19mcmVlKGVhcC0+cHJpdmF0ZV9rZXlfcGFzc3dkKTsKLQkJZWFwLT5wcml2YXRlX2tleV9wYXNzd2QgPSAodTggKikgb3Nfc3RyZHVwKHZhbHVlKTsKKwkJc3RyX2NsZWFyX2ZyZWUoZWFwLT5wcml2YXRlX2tleV9wYXNzd2QpOworCQllYXAtPnByaXZhdGVfa2V5X3Bhc3N3ZCA9IG9zX3N0cmR1cCh2YWx1ZSk7CiAJCWVhcC0+cGVuZGluZ19yZXFfcGFzc3BocmFzZSA9IDA7CiAJCWlmIChzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQpCiAJCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwogCQlicmVhazsKKwljYXNlIFdQQV9DVFJMX1JFUV9TSU06CisJCXN0cl9jbGVhcl9mcmVlKGVhcC0+ZXh0ZXJuYWxfc2ltX3Jlc3ApOworCQllYXAtPmV4dGVybmFsX3NpbV9yZXNwID0gb3Nfc3RyZHVwKHZhbHVlKTsKKwkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBVbmtub3duIGZpZWxkICclcyciLCBmaWVsZCk7CiAJCXJldHVybiAtMTsKQEAgLTM3OTcsNyArNDQzNyw3IEBACiAJfQogCiAJaWYgKHdwYV9rZXlfbWdtdF93cGFfcHNrKHNzaWQtPmtleV9tZ210KSAmJiAhc3NpZC0+cHNrX3NldCAmJgotCSAgICAhc3NpZC0+ZXh0X3BzaykKKwkgICAgKCFzc2lkLT5wYXNzcGhyYXNlIHx8IHNzaWQtPnNzaWRfbGVuICE9IDApICYmICFzc2lkLT5leHRfcHNrKQogCQlyZXR1cm4gMTsKIAogCXJldHVybiAwOwpAQCAtMzgxNCwxMSArNDQ1NCwxMSBAQAogfQogCiAKLXZvaWQgd3Bhc19hdXRoX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQordm9pZCB3cGFzX2F1dGhfZmFpbGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKnJlYXNvbikKIHsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOwogCWludCBkdXI7Ci0Jc3RydWN0IG9zX3RpbWUgbm93OworCXN0cnVjdCBvc19yZWx0aW1lIG5vdzsKIAogCWlmIChzc2lkID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBdXRoZW50aWNhdGlvbiBmYWlsdXJlIGJ1dCBubyBrbm93biAiCkBAIC0zODQ0LDI3ICs0NDg0LDMzIEBACiAKIAlpZiAoc3NpZC0+YXV0aF9mYWlsdXJlcyA+IDUwKQogCQlkdXIgPSAzMDA7Ci0JZWxzZSBpZiAoc3NpZC0+YXV0aF9mYWlsdXJlcyA+IDIwKQotCQlkdXIgPSAxMjA7CiAJZWxzZSBpZiAoc3NpZC0+YXV0aF9mYWlsdXJlcyA+IDEwKQotCQlkdXIgPSA2MDsKKwkJZHVyID0gMTIwOwogCWVsc2UgaWYgKHNzaWQtPmF1dGhfZmFpbHVyZXMgPiA1KQorCQlkdXIgPSA5MDsKKwllbHNlIGlmIChzc2lkLT5hdXRoX2ZhaWx1cmVzID4gMykKKwkJZHVyID0gNjA7CisJZWxzZSBpZiAoc3NpZC0+YXV0aF9mYWlsdXJlcyA+IDIpCiAJCWR1ciA9IDMwOwogCWVsc2UgaWYgKHNzaWQtPmF1dGhfZmFpbHVyZXMgPiAxKQogCQlkdXIgPSAyMDsKIAllbHNlCiAJCWR1ciA9IDEwOwogCi0Jb3NfZ2V0X3RpbWUoJm5vdyk7CisJaWYgKHNzaWQtPmF1dGhfZmFpbHVyZXMgPiAxICYmCisJICAgIHdwYV9rZXlfbWdtdF93cGFfaWVlZTgwMjF4KHNzaWQtPmtleV9tZ210KSkKKwkJZHVyICs9IG9zX3JhbmRvbSgpICUgKHNzaWQtPmF1dGhfZmFpbHVyZXMgKiAxMCk7CisKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAlpZiAobm93LnNlYyArIGR1ciA8PSBzc2lkLT5kaXNhYmxlZF91bnRpbC5zZWMpCiAJCXJldHVybjsKIAogCXNzaWQtPmRpc2FibGVkX3VudGlsLnNlYyA9IG5vdy5zZWMgKyBkdXI7CiAKIAl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX1RFTVBfRElTQUJMRUQKLQkJImlkPSVkIHNzaWQ9XCIlc1wiIGF1dGhfZmFpbHVyZXM9JXUgZHVyYXRpb249JWQiLAorCQkiaWQ9JWQgc3NpZD1cIiVzXCIgYXV0aF9mYWlsdXJlcz0ldSBkdXJhdGlvbj0lZCByZWFzb249JXMiLAogCQlzc2lkLT5pZCwgd3BhX3NzaWRfdHh0KHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKSwKLQkJc3NpZC0+YXV0aF9mYWlsdXJlcywgZHVyKTsKKwkJc3NpZC0+YXV0aF9mYWlsdXJlcywgZHVyLCByZWFzb24pOwogfQogCiAKQEAgLTM5NDMsOTAgKzQ1ODksNDQgQEAKIH0KIAogCi0vKioKLSAqIHdwYXNfd3BhX2lzX2luX3Byb2dyZXNzIC0gQ2hlY2sgd2hldGhlciBhIGNvbm5lY3Rpb24gaXMgaW4gcHJvZ3Jlc3MKLSAqIEB3cGFfczogUG9pbnRlciB0byB3cGFfc3VwcGxpY2FudCBkYXRhCi0gKgotICogVGhpcyBmdW5jdGlvbiBpcyB0byBjaGVjayBpZiB0aGUgd3BhIHN0YXRlIGlzIGluIGJlZ2lubmluZyBvZiB0aGUgY29ubmVjdGlvbgotICogZHVyaW5nIDQtd2F5IGhhbmRzaGFrZSBvciBncm91cCBrZXkgaGFuZHNoYWtlIHdpdGggV1BBIG9uIGFueSBzaGFyZWQKLSAqIGludGVyZmFjZS4KLSAqLwotaW50IHdwYXNfd3BhX2lzX2luX3Byb2dyZXNzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit2b2lkIGR1bXBfZnJlcV9kYXRhKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKnRpdGxlLAorCQkgICAgc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqZnJlcXNfZGF0YSwKKwkJICAgIHVuc2lnbmVkIGludCBsZW4pCiB7Ci0JY29uc3QgY2hhciAqcm4sICpybjI7Ci0Jc3RydWN0IHdwYV9zdXBwbGljYW50ICppZnM7CisJdW5zaWduZWQgaW50IGk7CiAKLQlpZiAoIXdwYV9zLT5kcml2ZXItPmdldF9yYWRpb19uYW1lKQotICAgICAgICAgICAgICAgIHJldHVybiAwOwotCi0Jcm4gPSB3cGFfcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSh3cGFfcy0+ZHJ2X3ByaXYpOwotCWlmIChybiA9PSBOVUxMIHx8IHJuWzBdID09ICdcMCcpCi0JCXJldHVybiAwOwotCi0JZm9yIChpZnMgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7IGlmczsgaWZzID0gaWZzLT5uZXh0KSB7Ci0JCWlmIChpZnMgPT0gd3BhX3MgfHwgIWlmcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSkKLQkJCWNvbnRpbnVlOwotCi0JCXJuMiA9IGlmcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZShpZnMtPmRydl9wcml2KTsKLQkJaWYgKCFybjIgfHwgb3Nfc3RyY21wKHJuLCBybjIpICE9IDApCi0JCQljb250aW51ZTsKLQkJaWYgKGlmcy0+d3BhX3N0YXRlID49IFdQQV9BVVRIRU5USUNBVElORyAmJgotCQkgICAgaWZzLT53cGFfc3RhdGUgIT0gV1BBX0NPTVBMRVRFRCkgewotCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQ29ubmVjdGlvbiBpcyBpbiBwcm9ncmVzcyAiCi0JCQkJIm9uIGludGVyZmFjZSAlcyAtIGRlZmVyIHNjYW4iLCBpZnMtPmlmbmFtZSk7Ci0JCQlyZXR1cm4gMTsKLQkJfQorCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlNoYXJlZCBmcmVxdWVuY2llcyAobGVuPSV1KTogJXMiLAorCQlsZW4sIHRpdGxlKTsKKwlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKKwkJc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqY3VyID0gJmZyZXFzX2RhdGFbaV07CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgImZyZXFbJXVdOiAlZCwgZmxhZ3M9MHglWCIsCisJCQlpLCBjdXItPmZyZXEsIGN1ci0+ZmxhZ3MpOwogCX0KLQotCXJldHVybiAwOwogfQogCiAKIC8qCiAgKiBGaW5kIHRoZSBvcGVyYXRpbmcgZnJlcXVlbmNpZXMgb2YgYW55IG9mIHRoZSB2aXJ0dWFsIGludGVyZmFjZXMgdGhhdAotICogYXJlIHVzaW5nIHRoZSBzYW1lIHJhZGlvIGFzIHRoZSBjdXJyZW50IGludGVyZmFjZS4KKyAqIGFyZSB1c2luZyB0aGUgc2FtZSByYWRpbyBhcyB0aGUgY3VycmVudCBpbnRlcmZhY2UsIGFuZCBpbiBhZGRpdGlvbiwgZ2V0CisgKiBpbmZvcm1hdGlvbiBhYm91dCB0aGUgaW50ZXJmYWNlIHR5cGVzIHRoYXQgYXJlIHVzaW5nIHRoZSBmcmVxdWVuY3kuCiAgKi8KLWludCBnZXRfc2hhcmVkX3JhZGlvX2ZyZXFzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkgICBpbnQgKmZyZXFfYXJyYXksIHVuc2lnbmVkIGludCBsZW4pCitpbnQgZ2V0X3NoYXJlZF9yYWRpb19mcmVxc19kYXRhKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqZnJlcXNfZGF0YSwKKwkJCQl1bnNpZ25lZCBpbnQgbGVuKQogewotCWNvbnN0IGNoYXIgKnJuLCAqcm4yOwogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqaWZzOwogCXU4IGJzc2lkW0VUSF9BTEVOXTsKIAlpbnQgZnJlcTsKIAl1bnNpZ25lZCBpbnQgaWR4ID0gMCwgaTsKIAotCW9zX21lbXNldChmcmVxX2FycmF5LCAwLCBzaXplb2YoaW50KSAqIGxlbik7CisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAorCQkiRGV0ZXJtaW5pbmcgc2hhcmVkIHJhZGlvIGZyZXF1ZW5jaWVzIChtYXggbGVuICV1KSIsIGxlbik7CisJb3NfbWVtc2V0KGZyZXFzX2RhdGEsIDAsIHNpemVvZihzdHJ1Y3Qgd3BhX3VzZWRfZnJlcV9kYXRhKSAqIGxlbik7CiAKLQkvKiBGaXJzdCBhZGQgdGhlIGZyZXF1ZW5jeSBvZiB0aGUgbG9jYWwgaW50ZXJmYWNlICovCi0JaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgIT0gTlVMTCAmJiB3cGFfcy0+YXNzb2NfZnJlcSAhPSAwKSB7Ci0JCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkLT5tb2RlID09IFdQQVNfTU9ERV9BUCB8fAotCQkgICAgd3BhX3MtPmN1cnJlbnRfc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dPKQotCQkJZnJlcV9hcnJheVtpZHgrK10gPSB3cGFfcy0+Y3VycmVudF9zc2lkLT5mcmVxdWVuY3k7Ci0JCWVsc2UgaWYgKHdwYV9kcnZfZ2V0X2Jzc2lkKHdwYV9zLCBic3NpZCkgPT0gMCkKLQkJCWZyZXFfYXJyYXlbaWR4KytdID0gd3BhX3MtPmFzc29jX2ZyZXE7Ci0JfQotCi0JLyogSWYgZ2V0X3JhZGlvX25hbWUgaXMgbm90IHN1cHBvcnRlZCwgdXNlIG9ubHkgdGhlIGxvY2FsIGZyZXEgKi8KLQlpZiAoIXdwYV9zLT5kcml2ZXItPmdldF9yYWRpb19uYW1lKSB7Ci0JCWZyZXEgPSB3cGFfZHJ2X3NoYXJlZF9mcmVxKHdwYV9zKTsKLQkJaWYgKGZyZXEgPiAwICYmIGlkeCA8IGxlbiAmJgotCQkgICAgKGlkeCA9PSAwIHx8IGZyZXFfYXJyYXlbMF0gIT0gZnJlcSkpCi0JCQlmcmVxX2FycmF5W2lkeCsrXSA9IGZyZXE7Ci0JCXJldHVybiBpZHg7Ci0JfQotCi0Jcm4gPSB3cGFfcy0+ZHJpdmVyLT5nZXRfcmFkaW9fbmFtZSh3cGFfcy0+ZHJ2X3ByaXYpOwotCWlmIChybiA9PSBOVUxMIHx8IHJuWzBdID09ICdcMCcpCi0JCXJldHVybiBpZHg7Ci0KLQlmb3IgKGlmcyA9IHdwYV9zLT5nbG9iYWwtPmlmYWNlcywgaWR4ID0gMDsgaWZzICYmIGlkeCA8IGxlbjsKLQkgICAgIGlmcyA9IGlmcy0+bmV4dCkgewotCQlpZiAod3BhX3MgPT0gaWZzIHx8ICFpZnMtPmRyaXZlci0+Z2V0X3JhZGlvX25hbWUpCi0JCQljb250aW51ZTsKLQotCQlybjIgPSBpZnMtPmRyaXZlci0+Z2V0X3JhZGlvX25hbWUoaWZzLT5kcnZfcHJpdik7Ci0JCWlmICghcm4yIHx8IG9zX3N0cmNtcChybiwgcm4yKSAhPSAwKQotCQkJY29udGludWU7CisJZGxfbGlzdF9mb3JfZWFjaChpZnMsICZ3cGFfcy0+cmFkaW8tPmlmYWNlcywgc3RydWN0IHdwYV9zdXBwbGljYW50LAorCQkJIHJhZGlvX2xpc3QpIHsKKwkJaWYgKGlkeCA9PSBsZW4pCisJCQlicmVhazsKIAogCQlpZiAoaWZzLT5jdXJyZW50X3NzaWQgPT0gTlVMTCB8fCBpZnMtPmFzc29jX2ZyZXEgPT0gMCkKIAkJCWNvbnRpbnVlOwpAQCAtNDA0MSwxMSArNDY0MSw0NSBAQAogCiAJCS8qIEhvbGQgb25seSBkaXN0aW5jdCBmcmVxcyAqLwogCQlmb3IgKGkgPSAwOyBpIDwgaWR4OyBpKyspCi0JCQlpZiAoZnJlcV9hcnJheVtpXSA9PSBmcmVxKQorCQkJaWYgKGZyZXFzX2RhdGFbaV0uZnJlcSA9PSBmcmVxKQogCQkJCWJyZWFrOwogCiAJCWlmIChpID09IGlkeCkKLQkJCWZyZXFfYXJyYXlbaWR4KytdID0gZnJlcTsKKwkJCWZyZXFzX2RhdGFbaWR4KytdLmZyZXEgPSBmcmVxOworCisJCWlmIChpZnMtPmN1cnJlbnRfc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfSU5GUkEpIHsKKwkJCWZyZXFzX2RhdGFbaV0uZmxhZ3MgPSBpZnMtPmN1cnJlbnRfc3NpZC0+cDJwX2dyb3VwID8KKwkJCQlXUEFfRlJFUV9VU0VEX0JZX1AyUF9DTElFTlQgOgorCQkJCVdQQV9GUkVRX1VTRURfQllfSU5GUkFfU1RBVElPTjsKKwkJfQogCX0KKworCWR1bXBfZnJlcV9kYXRhKHdwYV9zLCAiY29tcGxldGVkIGl0ZXJhdGlvbiIsIGZyZXFzX2RhdGEsIGlkeCk7CiAJcmV0dXJuIGlkeDsKIH0KKworCisvKgorICogRmluZCB0aGUgb3BlcmF0aW5nIGZyZXF1ZW5jaWVzIG9mIGFueSBvZiB0aGUgdmlydHVhbCBpbnRlcmZhY2VzIHRoYXQKKyAqIGFyZSB1c2luZyB0aGUgc2FtZSByYWRpbyBhcyB0aGUgY3VycmVudCBpbnRlcmZhY2UuCisgKi8KK2ludCBnZXRfc2hhcmVkX3JhZGlvX2ZyZXFzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICBpbnQgKmZyZXFfYXJyYXksIHVuc2lnbmVkIGludCBsZW4pCit7CisJc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSAqZnJlcXNfZGF0YTsKKwlpbnQgbnVtLCBpOworCisJb3NfbWVtc2V0KGZyZXFfYXJyYXksIDAsIHNpemVvZihpbnQpICogbGVuKTsKKworCWZyZXFzX2RhdGEgPSBvc19jYWxsb2MobGVuLCBzaXplb2Yoc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSkpOworCWlmICghZnJlcXNfZGF0YSkKKwkJcmV0dXJuIC0xOworCisJbnVtID0gZ2V0X3NoYXJlZF9yYWRpb19mcmVxc19kYXRhKHdwYV9zLCBmcmVxc19kYXRhLCBsZW4pOworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykKKwkJZnJlcV9hcnJheVtpXSA9IGZyZXFzX2RhdGFbaV0uZnJlcTsKKworCW9zX2ZyZWUoZnJlcXNfZGF0YSk7CisKKwlyZXR1cm4gbnVtOworfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnQuY29uZiBiL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50LmNvbmYKaW5kZXggZDczZDM3MS4uMmEwZGMyMCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnQuY29uZgorKysgYi93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudC5jb25mCkBAIC04MSw2ICs4MSw4IEBACiAjIHRvIG1ha2Ugd3BhX3N1cHBsaWNhbnQgaW50ZXJvcGVyYXRlIHdpdGggdGhlc2UgQVBzLCB0aGUgdmVyc2lvbiBudW1iZXIgaXMgc2V0CiAjIHRvIDEgYnkgZGVmYXVsdC4gVGhpcyBjb25maWd1cmF0aW9uIHZhbHVlIGNhbiBiZSB1c2VkIHRvIHNldCBpdCB0byB0aGUgbmV3CiAjIHZlcnNpb24gKDIpLgorIyBOb3RlOiBXaGVuIHVzaW5nIE1BQ3NlYywgZWFwb2xfdmVyc2lvbiBzaGFsbCBiZSBzZXQgdG8gMywgd2hpY2ggaXMKKyMgZGVmaW5lZCBpbiBJRUVFIFN0ZCA4MDIuMVgtMjAxMC4KIGVhcG9sX3ZlcnNpb249MQogCiAjIEFQIHNjYW5uaW5nL3NlbGVjdGlvbgpAQCAtOTcsNiArOTksOCBAQAogIyAgICBub24tV1BBIGRyaXZlcnMgd2hlbiB1c2luZyBJRUVFIDgwMi4xWCBtb2RlOyBkbyBub3QgdHJ5IHRvIGFzc29jaWF0ZSB3aXRoCiAjICAgIEFQcyAoaS5lLiwgZXh0ZXJuYWwgcHJvZ3JhbSBuZWVkcyB0byBjb250cm9sIGFzc29jaWF0aW9uKS4gVGhpcyBtb2RlIG11c3QKICMgICAgYWxzbyBiZSB1c2VkIHdoZW4gdXNpbmcgd2lyZWQgRXRoZXJuZXQgZHJpdmVycy4KKyMgICAgTm90ZTogbWFjc2VjX3FjYSBkcml2ZXIgaXMgb25lIHR5cGUgb2YgRXRoZXJuZXQgZHJpdmVyIHdoaWNoIGltcGxlbWVudHMKKyMgICAgbWFjc2VjIGZlYXR1cmUuCiAjIDI6IGxpa2UgMCwgYnV0IGFzc29jaWF0ZSB3aXRoIEFQcyB1c2luZyBzZWN1cml0eSBwb2xpY3kgYW5kIFNTSUQgKGJ1dCBub3QKICMgICAgQlNTSUQpOyB0aGlzIGNhbiBiZSB1c2VkLCBlLmcuLCB3aXRoIG5kaXN3cmFwcGVyIGFuZCBORElTIGRyaXZlcnMgdG8KICMgICAgZW5hYmxlIG9wZXJhdGlvbiB3aXRoIGhpZGRlbiBTU0lEcyBhbmQgb3B0aW1pemVkIHJvYW1pbmc7IGluIHRoaXMgbW9kZSwKQEAgLTI0MSwxNCArMjQ1LDE0IEBACiAjIFRoaXMgaXMgYW4gb3B0aW9uYWwgc2V0IG9mIHBhcmFtZXRlcnMgZm9yIGF1dG9tYXRpYyBzY2FubmluZwogIyB3aXRoaW4gYW4gaW50ZXJmYWNlIGluIGZvbGxvd2luZyBmb3JtYXQ6CiAjYXV0b3NjYW49PGF1dG9zY2FuIG1vZHVsZSBuYW1lPjo8bW9kdWxlIHBhcmFtZXRlcnM+Ci0jwqBhdXRvc2NhbiBpcyBsaWtlIGJnc2NhbiBidXQgb24gZGlzY29ubmVjdGVkIG9yIGluYWN0aXZlIHN0YXRlLgotI8KgRm9yIGluc3RhbmNlLCBvbiBleHBvbmVudGlhbCBtb2R1bGUgcGFyYW1ldGVycyB3b3VsZCBiZSA8YmFzZT46PGxpbWl0PgorIyBhdXRvc2NhbiBpcyBsaWtlIGJnc2NhbiBidXQgb24gZGlzY29ubmVjdGVkIG9yIGluYWN0aXZlIHN0YXRlLgorIyBGb3IgaW5zdGFuY2UsIG9uIGV4cG9uZW50aWFsIG1vZHVsZSBwYXJhbWV0ZXJzIHdvdWxkIGJlIDxiYXNlPjo8bGltaXQ+CiAjYXV0b3NjYW49ZXhwb25lbnRpYWw6MzozMDAKICMgV2hpY2ggbWVhbnMgYSBkZWxheSBiZXR3ZWVuIHNjYW5zIG9uIGEgYmFzZSBleHBvbmVudGlhbCBvZiAzLAotI8KgdXAgdG8gdGhlIGxpbWl0IG9mIDMwMCBzZWNvbmRzICgzLCA5LCAyNyAuLi4gMzAwKQotI8KgRm9yIHBlcmlvZGljIG1vZHVsZSwgcGFyYW1ldGVycyB3b3VsZCBiZSA8Zml4ZWQgaW50ZXJ2YWw+CisjIHVwIHRvIHRoZSBsaW1pdCBvZiAzMDAgc2Vjb25kcyAoMywgOSwgMjcgLi4uIDMwMCkKKyMgRm9yIHBlcmlvZGljIG1vZHVsZSwgcGFyYW1ldGVycyB3b3VsZCBiZSA8Zml4ZWQgaW50ZXJ2YWw+CiAjYXV0b3NjYW49cGVyaW9kaWM6MzAKLSPCoFNvIGEgZGVsYXkgb2YgMzAgc2Vjb25kcyB3aWxsIGJlIGFwcGxpZWQgYmV0d2VlbiBlYWNoIHNjYW4KKyMgU28gYSBkZWxheSBvZiAzMCBzZWNvbmRzIHdpbGwgYmUgYXBwbGllZCBiZXR3ZWVuIGVhY2ggc2NhbgogCiAjIGZpbHRlcl9zc2lkcyAtIFNTSUQtYmFzZWQgc2NhbiByZXN1bHQgZmlsdGVyaW5nCiAjIDAgPSBkbyBub3QgZmlsdGVyIHNjYW4gcmVzdWx0cyAoZGVmYXVsdCkKQEAgLTI2NSw2ICsyNjksMTkgQEAKICMgaW5hY3RpdmUgc3RhdGlvbnMuCiAjcDJwX2dvX21heF9pbmFjdGl2aXR5PTMwMAogCisjIFBhc3NwaHJhc2UgbGVuZ3RoICg4Li42MykgZm9yIFAyUCBHTworIworIyBUaGlzIHBhcmFtZXRlciBjb250cm9scyB0aGUgbGVuZ3RoIG9mIHRoZSByYW5kb20gcGFzc3BocmFzZSB0aGF0IGlzCisjIGdlbmVyYXRlZCBhdCB0aGUgR08uIERlZmF1bHQ6IDguCisjcDJwX3Bhc3NwaHJhc2VfbGVuPTgKKworIyBFeHRyYSBkZWxheSBiZXR3ZWVuIGNvbmN1cnJlbnQgUDJQIHNlYXJjaCBpdGVyYXRpb25zCisjCisjIFRoaXMgdmFsdWUgYWRkcyBleHRyYSBkZWxheSBpbiBtaWxsaXNlY29uZHMgYmV0d2VlbiBjb25jdXJyZW50IHNlYXJjaAorIyBpdGVyYXRpb25zIHRvIG1ha2UgcDJwX2ZpbmQgZnJpZW5kbGllciB0byBjb25jdXJyZW50IG9wZXJhdGlvbnMgYnkgYXZvaWRpbmcKKyMgaXQgZnJvbSB0YWtpbmcgMTAwJSBvZiByYWRpbyByZXNvdXJjZXMuIFRoZSBkZWZhdWx0IHZhbHVlIGlzIDUwMCBtcy4KKyNwMnBfc2VhcmNoX2RlbGF5PTUwMAorCiAjIE9wcG9ydHVuaXN0aWMgS2V5IENhY2hpbmcgKGFsc28ga25vd24gYXMgUHJvYWN0aXZlIEtleSBDYWNoaW5nKSBkZWZhdWx0CiAjIFRoaXMgcGFyYW1ldGVyIGNhbiBiZSB1c2VkIHRvIHNldCB0aGUgZGVmYXVsdCBiZWhhdmlvciBmb3IgdGhlCiAjIHByb2FjdGl2ZV9rZXlfY2FjaGluZyBwYXJhbWV0ZXIuIEJ5IGRlZmF1bHQsIE9LQyBpcyBkaXNhYmxlZCB1bmxlc3MgZW5hYmxlZApAQCAtMzQyLDYgKzM1OSw4IEBACiAjCiAjIGNyZWRlbnRpYWwgZmllbGRzOgogIworIyB0ZW1wb3Jhcnk6IFdoZXRoZXIgdGhpcyBjcmVkZW50aWFsIGlzIHRlbXBvcmFyeSBhbmQgbm90IHRvIGJlIHNhdmVkCisjCiAjIHByaW9yaXR5OiBQcmlvcml0eSBncm91cAogIwlCeSBkZWZhdWx0LCBhbGwgbmV0d29ya3MgYW5kIGNyZWRlbnRpYWxzIGdldCB0aGUgc2FtZSBwcmlvcml0eSBncm91cAogIwkoMCkuIFRoaXMgZmllbGQgY2FuIGJlIHVzZWQgdG8gZ2l2ZSBoaWdoZXIgcHJpb3JpdHkgZm9yIGNyZWRlbnRpYWxzCkBAIC0zOTksOSArNDE4LDExIEBACiAjIG1pbGVuYWdlOiBNaWxlbmFnZSBwYXJhbWV0ZXJzIGZvciBTSU0vVVNJTSBzaW11bGF0b3IgaW4gPEtpPjo8T1BjPjo8U1FOPgogIwlmb3JtYXQKICMKLSMgZG9tYWluOiBIb21lIHNlcnZpY2UgcHJvdmlkZXIgRlFETgorIyBkb21haW46IEhvbWUgc2VydmljZSBwcm92aWRlciBGUUROKHMpCiAjCVRoaXMgaXMgdXNlZCB0byBjb21wYXJlIGFnYWluc3QgdGhlIERvbWFpbiBOYW1lIExpc3QgdG8gZmlndXJlIG91dAotIwl3aGV0aGVyIHRoZSBBUCBpcyBvcGVyYXRlZCBieSB0aGUgSG9tZSBTUC4KKyMJd2hldGhlciB0aGUgQVAgaXMgb3BlcmF0ZWQgYnkgdGhlIEhvbWUgU1AuIE11bHRpcGxlIGRvbWFpbiBlbnRyaWVzIGNhbgorIwliZSB1c2VkIHRvIGNvbmZpZ3VyZSBhbHRlcm5hdGl2ZSBGUUROcyB0aGF0IHdpbGwgYmUgY29uc2lkZXJlZCBob21lCisjCW5ldHdvcmtzLgogIwogIyByb2FtaW5nX2NvbnNvcnRpdW06IFJvYW1pbmcgQ29uc29ydGl1bSBPSQogIwlJZiByb2FtaW5nX2NvbnNvcnRpdW1fbGVuIGlzIG5vbi16ZXJvLCB0aGlzIGZpZWxkIGNvbnRhaW5zIHRoZQpAQCAtNDI4LDYgKzQ0OSw1OSBAQAogIwltYXRjaGluZyB3aXRoIHRoZSBuZXR3b3JrLiBNdWx0aXBsZSBlbnRyaWVzIGNhbiBiZSB1c2VkIHRvIHNwZWNpZnkgbW9yZQogIwl0aGFuIG9uZSBTU0lELgogIworIyByb2FtaW5nX3BhcnRuZXI6IFJvYW1pbmcgcGFydG5lciBpbmZvcm1hdGlvbgorIwlUaGlzIG9wdGlvbmFsIGZpZWxkIGNhbiBiZSB1c2VkIHRvIGNvbmZpZ3VyZSBwcmVmZXJlbmNlcyBiZXR3ZWVuIHJvYW1pbmcKKyMJcGFydG5lcnMuIFRoZSBmaWVsZCBpcyBhIHN0cmluZyBpbiBmb2xsb3dpbmcgZm9ybWF0OgorIwk8RlFETj4sPDAvMSBleGFjdCBtYXRjaD4sPHByaW9yaXR5Piw8KiBvciBjb3VudHJ5IGNvZGU+CisjCShub24tZXhhY3QgbWF0Y2ggbWVhbnMgYW55IHN1YmRvbWFpbiBtYXRjaGVzIHRoZSBlbnRyeTsgcHJpb3JpdHkgaXMgaW4KKyMJMC4uMjU1IHJhbmdlIHdpdGggMCBiZWluZyB0aGUgaGlnaGVzdCBwcmlvcml0eSkKKyMKKyMgdXBkYXRlX2lkZW50aWZpZXI6IFBQUyBNTyBJRAorIwkoSG90c3BvdCAyLjAgUGVyUHJvdmlkZXJTdWJzY3JpcHRpb24vVXBkYXRlSWRlbnRpZmllcikKKyMKKyMgcHJvdmlzaW9uaW5nX3NwOiBGUUROIG9mIHRoZSBTUCB0aGF0IHByb3Zpc2lvbmVkIHRoZSBjcmVkZW50aWFsCisjCVRoaXMgb3B0aW9uYWwgZmllbGQgY2FuIGJlIHVzZWQgdG8ga2VlcCB0cmFjayBvZiB0aGUgU1AgdGhhdCBwcm92aXNpb25lZAorIwl0aGUgY3JlZGVudGlhbCB0byBmaW5kIHRoZSBQUFMgTU8gKC4vV2ktRmkvPHByb3Zpc2lvbmluZ19zcD4pLgorIworIyBNaW5pbXVtIGJhY2toYXVsIHRocmVzaG9sZCAoUFBTLzxYKz4vUG9saWN5L01pbkJhY2toYXVsZFRocmVzaG9sZC8qKQorIwlUaGVzZSBmaWVsZHMgY2FuIGJlIHVzZWQgdG8gc3BlY2lmeSBtaW5pbXVtIGRvd25sb2FkL3VwbG9hZCBiYWNraGF1bAorIwliYW5kd2lkdGggdGhhdCBpcyBwcmVmZXJyZWQgZm9yIHRoZSBjcmVkZW50aWFsLiBUaGlzIGNvbnN0cmFpbnQgaXMKKyMJaWdub3JlZCBpZiB0aGUgQVAgZG9lcyBub3QgYWR2ZXJ0aXNlIFdBTiBNZXRyaWNzIGluZm9ybWF0aW9uIG9yIGlmIHRoZQorIwlsaW1pdCB3b3VsZCBwcmV2ZW50IGFueSBjb25uZWN0aW9uLiBWYWx1ZXMgYXJlIGluIGtpbG9iaXRzIHBlciBzZWNvbmQuCisjIG1pbl9kbF9iYW5kd2lkdGhfaG9tZQorIyBtaW5fdWxfYmFuZHdpZHRoX2hvbWUKKyMgbWluX2RsX2JhbmR3aWR0aF9yb2FtaW5nCisjIG1pbl91bF9iYW5kd2lkdGhfcm9hbWluZworIworIyBtYXhfYnNzX2xvYWQ6IE1heGltdW0gQlNTIExvYWQgQ2hhbm5lbCBVdGlsaXphdGlvbiAoMS4uMjU1KQorIwkoUFBTLzxYKz4vUG9saWN5L01heGltdW1CU1NMb2FkVmFsdWUpCisjCVRoaXMgdmFsdWUgaXMgdXNlZCBhcyB0aGUgbWF4aW11bSBjaGFubmVsIHV0aWxpemF0aW9uIGZvciBuZXR3b3JrCisjCXNlbGVjdGlvbiBwdXJwb3NlcyBmb3IgaG9tZSBuZXR3b3Jrcy4gSWYgdGhlIEFQIGRvZXMgbm90IGFkdmVydGlzZQorIwlCU1MgTG9hZCBvciBpZiB0aGUgbGltaXQgd291bGQgcHJldmVudCBhbnkgY29ubmVjdGlvbiwgdGhpcyBjb25zdHJhaW50CisjCXdpbGwgYmUgaWdub3JlZC4KKyMKKyMgcmVxX2Nvbm5fY2FwYWI6IFJlcXVpcmVkIGNvbm5lY3Rpb24gY2FwYWJpbGl0eQorIwkoUFBTLzxYKz4vUG9saWN5L1JlcXVpcmVkUHJvdG9Qb3J0VHVwbGUpCisjCVRoaXMgdmFsdWUgaXMgdXNlZCB0byBjb25maWd1cmUgc2V0IG9mIHJlcXVpcmVkIHByb3RvY29sL3BvcnQgcGFpcnMgdGhhdAorIwlhIHJvYW1pbmcgbmV0d29yayBzaGFsbCBzdXBwb3J0IChpbmNsdWRlIGV4cGxpY2l0bHkgaW4gQ29ubmVjdGlvbgorIwlDYXBhYmlsaXR5IEFOUVAgZWxlbWVudCkuIFRoaXMgY29uc3RyYWludCBpcyBpZ25vcmVkIGlmIHRoZSBBUCBkb2VzIG5vdAorIwlhZHZlcnRpc2UgQ29ubmVjdGlvbiBDYXBhYmlsaXR5IG9yIGlmIHRoaXMgY29uc3RyYWludCB3b3VsZCBwcmV2ZW50IGFueQorIwluZXR3b3JrIGNvbm5lY3Rpb24uIFRoaXMgcG9saWN5IGlzIG5vdCB1c2VkIGluIGhvbWUgbmV0d29ya3MuCisjCUZvcm1hdDogPHByb3RvY29sPls6PGNvbW1hLXNlcGFyYXRlZCBsaXN0IG9mIHBvcnRzXQorIwlNdWx0aXBsZSBlbnRyaWVzIGNhbiBiZSB1c2VkIHRvIGxpc3QgbXVsdGlwbGUgcmVxdWlyZW1lbnRzLgorIwlGb3IgZXhhbXBsZSwgbnVtYmVyIG9mIGNvbW1vbiBUQ1AgcHJvdG9jb2xzOgorIwlyZXFfY29ubl9jYXBhYj02LDIyLDgwLDQ0MworIwlGb3IgZXhhbXBsZSwgSVBTZWMvSUtFOgorIwlyZXFfY29ubl9jYXBhYj0xNzo1MDAKKyMJcmVxX2Nvbm5fY2FwYWI9NTAKKyMKKyMgb2NzcDogV2hldGhlciB0byB1c2UvcmVxdWlyZSBPQ1NQIHRvIGNoZWNrIHNlcnZlciBjZXJ0aWZpY2F0ZQorIwkwID0gZG8gbm90IHVzZSBPQ1NQIHN0YXBsaW5nIChUTFMgY2VydGlmaWNhdGUgc3RhdHVzIGV4dGVuc2lvbikKKyMJMSA9IHRyeSB0byB1c2UgT0NTUCBzdGFwbGluZywgYnV0IG5vdCByZXF1aXJlIHJlc3BvbnNlCisjCTIgPSByZXF1aXJlIHZhbGlkIE9DU1Agc3RhcGxpbmcgcmVzcG9uc2UKKyMKKyMgc2ltX251bTogSWRlbnRpZmllciBmb3Igd2hpY2ggU0lNIHRvIHVzZSBpbiBtdWx0aS1TSU0gZGV2aWNlcworIwogIyBmb3IgZXhhbXBsZToKICMKICNjcmVkPXsKQEAgLTUwNCw5ICs1NzgsMTAgQEAKICMgMCA9IGluZnJhc3RydWN0dXJlIChNYW5hZ2VkKSBtb2RlLCBpLmUuLCBhc3NvY2lhdGUgd2l0aCBhbiBBUCAoZGVmYXVsdCkKICMgMSA9IElCU1MgKGFkLWhvYywgcGVlci10by1wZWVyKQogIyAyID0gQVAgKGFjY2VzcyBwb2ludCkKLSMgTm90ZTogSUJTUyBjYW4gb25seSBiZSB1c2VkIHdpdGgga2V5X21nbXQgTk9ORSAocGxhaW50ZXh0IGFuZCBzdGF0aWMgV0VQKQotIyBhbmQga2V5X21nbXQ9V1BBLU5PTkUgKGZpeGVkIGdyb3VwIGtleSBUS0lQL0NDTVApLiBXUEEtTm9uZSByZXF1aXJlcwotIyBmb2xsb3dpbmcgbmV0d29yayBibG9jayBvcHRpb25zOgorIyBOb3RlOiBJQlNTIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCBrZXlfbWdtdCBOT05FIChwbGFpbnRleHQgYW5kIHN0YXRpYyBXRVApIGFuZAorIyBXUEEtUFNLICh3aXRoIHByb3RvPVJTTikuIEluIGFkZGl0aW9uLCBrZXlfbWdtdD1XUEEtTk9ORSAoZml4ZWQgZ3JvdXAga2V5CisjIFRLSVAvQ0NNUCkgaXMgYXZhaWxhYmxlIGZvciBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSwgYnV0IGl0cyB1c2UgaXMKKyMgZGVwcmVjYXRlZC4gV1BBLU5vbmUgcmVxdWlyZXMgZm9sbG93aW5nIG5ldHdvcmsgYmxvY2sgb3B0aW9uczoKICMgcHJvdG89V1BBLCBrZXlfbWdtdD1XUEEtTk9ORSwgcGFpcndpc2U9Tk9ORSwgZ3JvdXA9VEtJUCAob3IgQ0NNUCwgYnV0IG5vdAogIyBib3RoKSwgYW5kIHBzayBtdXN0IGFsc28gYmUgc2V0LgogIwpAQCAtNTQ3LDYgKzYyMiwxMiBAQAogIyBiZ3NjYW49ImxlYXJuOjxzaG9ydCBiZ3NjYW4gaW50ZXJ2YWwgaW4gc2Vjb25kcz46PHNpZ25hbCBzdHJlbmd0aCB0aHJlc2hvbGQ+OgogIyA8bG9uZyBpbnRlcnZhbD5bOjxkYXRhYmFzZSBmaWxlIG5hbWU+XSIKICMgYmdzY2FuPSJsZWFybjozMDotNDU6MzAwOi9ldGMvd3BhX3N1cHBsaWNhbnQvbmV0d29yazEuYmdzY2FuIgorIyBFeHBsaWNpdGx5IGRpc2FibGUgYmdzY2FuIGJ5IHNldHRpbmcKKyMgYmdzY2FuPSIiCisjCisjIFRoaXMgb3B0aW9uIGNhbiBhbHNvIGJlIHNldCBvdXRzaWRlIG9mIGFsbCBuZXR3b3JrIGJsb2NrcyBmb3IgdGhlIGJnc2NhbgorIyBwYXJhbWV0ZXIgdG8gYXBwbHkgZm9yIGFsbCB0aGUgbmV0d29ya3MgdGhhdCBoYXZlIG5vIHNwZWNpZmljIGJnc2NhbgorIyBwYXJhbWV0ZXIuCiAjCiAjIHByb3RvOiBsaXN0IG9mIGFjY2VwdGVkIHByb3RvY29scwogIyBXUEEgPSBXUEEvSUVFRSA4MDIuMTFpL0QzLjAKQEAgLTYxMSw4ICs2OTIsMTYgQEAKICMgYml0MCAoMSk6IHJlcXVpcmUgZHluYW1pY2FsbHkgZ2VuZXJhdGVkIHVuaWNhc3QgV0VQIGtleQogIyBiaXQxICgyKTogcmVxdWlyZSBkeW5hbWljYWxseSBnZW5lcmF0ZWQgYnJvYWRjYXN0IFdFUCBrZXkKICMgCSgzID0gcmVxdWlyZSBib3RoIGtleXM7IGRlZmF1bHQpCi0jIE5vdGU6IFdoZW4gdXNpbmcgd2lyZWQgYXV0aGVudGljYXRpb24sIGVhcG9sX2ZsYWdzIG11c3QgYmUgc2V0IHRvIDAgZm9yIHRoZQotIyBhdXRoZW50aWNhdGlvbiB0byBiZSBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5LgorIyBOb3RlOiBXaGVuIHVzaW5nIHdpcmVkIGF1dGhlbnRpY2F0aW9uIChpbmNsdWRpbmcgbWFjc2VjX3FjYSBkcml2ZXIpLAorIyBlYXBvbF9mbGFncyBtdXN0IGJlIHNldCB0byAwIGZvciB0aGUgYXV0aGVudGljYXRpb24gdG8gYmUgY29tcGxldGVkCisjIHN1Y2Nlc3NmdWxseS4KKyMKKyMgbWFjc2VjX3BvbGljeTogSUVFRSA4MDIuMVgvTUFDc2VjIG9wdGlvbnMKKyMgVGhpcyBkZXRlcm1pbmVzIGhvdyBzZXNzaW9ucyBhcmUgc2VjdXJlZCB3aXRoIE1BQ3NlYy4gSXQgaXMgY3VycmVudGx5CisjIGFwcGxpY2FibGUgb25seSB3aGVuIHVzaW5nIHRoZSBtYWNzZWNfcWNhIGRyaXZlciBpbnRlcmZhY2UuCisjIDA6IE1BQ3NlYyBub3QgaW4gdXNlIChkZWZhdWx0KQorIyAxOiBNQUNzZWMgZW5hYmxlZCAtIFNob3VsZCBzZWN1cmUsIGFjY2VwdCBrZXkgc2VydmVyJ3MgYWR2aWNlIHRvCisjICAgIGRldGVybWluZSB3aGV0aGVyIHRvIHVzZSBhIHNlY3VyZSBzZXNzaW9uIG9yIG5vdC4KICMKICMgbWl4ZWRfY2VsbDogVGhpcyBvcHRpb24gY2FuIGJlIHVzZWQgdG8gY29uZmlndXJlIHdoZXRoZXIgc28gY2FsbGVkIG1peGVkCiAjIGNlbGxzLCBpLmUuLCBuZXR3b3JrcyB0aGF0IHVzZSBib3RoIHBsYWludGV4dCBhbmQgZW5jcnlwdGlvbiBpbiB0aGUgc2FtZQpAQCAtNzkxLDYgKzg4MCwxMCBAQAogIwlFQVAgd29ya2Fyb3VuZHMgYXJlIGRpc2FibGVkIHdpdGggZWFwX3dvcmthcm91bmRzPTAuCiAjCUZvciBFQVAtRkFTVCwgdGhpcyBtdXN0IGJlIHNldCB0byAwIChvciBsZWZ0IHVuY29uZmlndXJlZCBmb3IgdGhlCiAjCWRlZmF1bHQgdmFsdWUgdG8gYmUgdXNlZCBhdXRvbWF0aWNhbGx5KS4KKyMgdGxzX2Rpc2FibGVfdGxzdjFfMT0xIC0gZGlzYWJsZSB1c2Ugb2YgVExTdjEuMSAoYSB3b3JrYXJvdW5kIGZvciBBQUEgc2VydmVycworIwl0aGF0IGhhdmUgaXNzdWVzIGludGVyb3BlcmF0aW5nIHdpdGggdXBkYXRlZCBUTFMgdmVyc2lvbikKKyMgdGxzX2Rpc2FibGVfdGxzdjFfMj0xIC0gZGlzYWJsZSB1c2Ugb2YgVExTdjEuMiAoYSB3b3JrYXJvdW5kIGZvciBBQUEgc2VydmVycworIwl0aGF0IGhhdmUgaXNzdWVzIGludGVyb3BlcmF0aW5nIHdpdGggdXBkYXRlZCBUTFMgdmVyc2lvbikKICMKICMgRm9sbG93aW5nIGNlcnRpZmljYXRlL3ByaXZhdGUga2V5IGZpZWxkcyBhcmUgdXNlZCBpbiBpbm5lciBQaGFzZTIKICMgYXV0aGVudGljYXRpb24gd2hlbiB1c2luZyBFQVAtVFRMUyBvciBFQVAtUEVBUC4KQEAgLTg4MSw2ICs5NzQsMTQgQEAKICMgMCA9IFNHSSBlbmFibGVkIChpZiBBUCBzdXBwb3J0cyBpdCkKICMgMSA9IFNHSSBkaXNhYmxlZAogIworIyBkaXNhYmxlX2xkcGM6IFdoZXRoZXIgTERQQyBzaG91bGQgYmUgZGlzYWJsZWQuCisjIDAgPSBMRFBDIGVuYWJsZWQgKGlmIEFQIHN1cHBvcnRzIGl0KQorIyAxID0gTERQQyBkaXNhYmxlZAorIworIyBodDQwX2ludG9sZXJhbnQ6IFdoZXRoZXIgNDAgTUh6IGludG9sZXJhbnQgc2hvdWxkIGJlIGluZGljYXRlZC4KKyMgMCA9IDQwIE1IeiB0b2xlcmFudCAoZGVmYXVsdCkKKyMgMSA9IDQwIE1IeiBpbnRvbGVyYW50CisjCiAjIGh0X21jczogIENvbmZpZ3VyZSBhbGxvd2VkIE1DUyByYXRlcy4KICMgIFBhcnNlZCBhcyBhbiBhcnJheSBvZiBieXRlcywgaW4gYmFzZS0xNiAoYXNjaWktaGV4KQogIyBodF9tY3M9IiIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIFVzZSBhbGwgYXZhaWxhYmxlIChkZWZhdWx0KQpAQCAtODkyLDYgKzk5Myw5IEBACiAjIDAgID0gRW5hYmxlIE1BWC1BTVNEVSBpZiBoYXJkd2FyZSBzdXBwb3J0cyBpdC4KICMgMSAgPSBEaXNhYmxlIEFNU0RVCiAjCisjIGFtcGR1X2ZhY3RvcjogTWF4aW11bSBBLU1QRFUgTGVuZ3RoIEV4cG9uZW50CisjIFZhbHVlOiAwLTMsIHNlZSA3LjMuMi41Ni4zIGluIElFRUUgU3RkIDgwMi4xMW4tMjAwOS4KKyMKICMgYW1wZHVfZGVuc2l0eTogIEFsbG93IG92ZXJyaWRpbmcgQU1QRFUgZGVuc2l0eSBjb25maWd1cmF0aW9uLgogIyAgVHJlYXRlZCBhcyBoaW50IGJ5IHRoZSBrZXJuZWwuCiAjIC0xID0gRG8gbm90IG1ha2UgYW55IGNoYW5nZXMuCkBAIC0xMTU3LDcgKzEyNjEsMTkgQEAKIH0KIAogCi0jIElCU1MvYWQtaG9jIG5ldHdvcmsgd2l0aCBXUEEtTm9uZS9US0lQLgorIyBJQlNTL2FkLWhvYyBuZXR3b3JrIHdpdGggUlNOCituZXR3b3JrPXsKKwlzc2lkPSJpYnNzLXJzbiIKKwlrZXlfbWdtdD1XUEEtUFNLCisJcHJvdG89UlNOCisJcHNrPSIxMjM0NTY3OCIKKwltb2RlPTEKKwlmcmVxdWVuY3k9MjQxMgorCXBhaXJ3aXNlPUNDTVAKKwlncm91cD1DQ01QCit9CisKKyMgSUJTUy9hZC1ob2MgbmV0d29yayB3aXRoIFdQQS1Ob25lL1RLSVAgKGRlcHJlY2F0ZWQpCiBuZXR3b3JrPXsKIAlzc2lkPSJ0ZXN0IGFkaG9jIgogCW1vZGU9MQpAQCAtMTI1MCwzICsxMzY2LDE3IEBACiBuZXR3b3JrPXsKIAlrZXlfbWdtdD1OT05FCiB9CisKKworIyBFeGFtcGxlIE1BQ3NlYyBjb25maWd1cmF0aW9uCisjbmV0d29yaz17CisjCWtleV9tZ210PUlFRUU4MDIxWAorIwllYXA9VFRMUworIwlwaGFzZTI9ImF1dGg9UEFQIgorIwlhbm9ueW1vdXNfaWRlbnRpdHk9ImFub255bW91c0BleGFtcGxlLmNvbSIKKyMJaWRlbnRpdHk9InVzZXJAZXhhbXBsZS5jb20iCisjCXBhc3N3b3JkPSJzZWNyZXRyIgorIwljYV9jZXJ0PSIvZXRjL2NlcnQvY2EucGVtIgorIwllYXBvbF9mbGFncz0wCisjCW1hY3NlY19wb2xpY3k9MQorI30KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50X2kuaCBiL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50X2kuaAppbmRleCBkNjljZDYxLi5iZjNkMTlkIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudF9pLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnRfaS5oCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIHdwYV9zdXBwbGljYW50IC0gSW50ZXJuYWwgZGVmaW5pdGlvbnMKLSAqIENvcHlyaWdodCAoYykgMjAwMy0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTEyLDYgKzEyLDggQEAKICNpbmNsdWRlICJ1dGlscy9saXN0LmgiCiAjaW5jbHVkZSAiY29tbW9uL2RlZnMuaCIKICNpbmNsdWRlICJjb21tb24vc2FlLmgiCisjaW5jbHVkZSAiY29tbW9uL3dwYV9jdHJsLmgiCisjaW5jbHVkZSAid3BzL3dwc19kZWZzLmgiCiAjaW5jbHVkZSAiY29uZmlnX3NzaWQuaCIKIAogZXh0ZXJuIGNvbnN0IGNoYXIgKndwYV9zdXBwbGljYW50X3ZlcnNpb247CkBAIC02Myw2ICs2NSwxNyBAQAogCSAqLwogCWNvbnN0IGNoYXIgKmNvbmZhbm90aGVyOwogCisjaWZkZWYgQ09ORklHX1AyUAorCS8qKgorCSAqIGNvbmZfcDJwX2RldiAtIEFkZGl0aW9uYWwgY29uZmlndXJhdGlvbiBmaWxlIHVzZWQgdG8gaG9sZCB0aGUKKwkgKiBQMlAgRGV2aWNlIGNvbmZpZ3VyYXRpb24gcGFyYW1ldGVycy4KKwkgKgorCSAqIFRoaXMgY2FuIGFsc28gYmUgJU5VTEwuIEluIHN1Y2ggYSBjYXNlLCBpZiBhIFAyUCBEZXZpY2UgZGVkaWNhdGVkCisJICogaW50ZXJmYWNlcyBpcyBjcmVhdGVkLCB0aGUgbWFpbiBjb25maWd1cmF0aW9uIGZpbGUgd2lsbCBiZSB1c2VkLgorCSAqLworCWNvbnN0IGNoYXIgKmNvbmZfcDJwX2RldjsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKIAkvKioKIAkgKiBjdHJsX2ludGVyZmFjZSAtIENvbnRyb2wgaW50ZXJmYWNlIHBhcmFtZXRlcgogCSAqCkBAIC0yMjcsMTIgKzI0MCw2IEBACiAJY2hhciAqc2VydmljZTsKIH07CiAKLXN0cnVjdCB3cGFfZnJlcV9yYW5nZSB7Ci0JdW5zaWduZWQgaW50IG1pbjsKLQl1bnNpZ25lZCBpbnQgbWF4OwotfTsKLQotCiAvKioKICAqIHN0cnVjdCB3cGFfZ2xvYmFsIC0gSW50ZXJuYWwsIGdsb2JhbCBkYXRhIGZvciBhbGwgJXdwYV9zdXBwbGljYW50IGludGVyZmFjZXMKICAqCkBAIC0yNTIsMjAgKzI1OSwyMCBAQAogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqcDJwX2dyb3VwX2Zvcm1hdGlvbjsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKnAycF9pbnZpdGVfZ3JvdXA7CiAJdTggcDJwX2Rldl9hZGRyW0VUSF9BTEVOXTsKLQlzdHJ1Y3Qgb3NfdGltZSBwMnBfZ29fd2FpdF9jbGllbnQ7CisJc3RydWN0IG9zX3JlbHRpbWUgcDJwX2dvX3dhaXRfY2xpZW50OwogCXN0cnVjdCBkbF9saXN0IHAycF9zcnZfYm9uam91cjsgLyogc3RydWN0IHAycF9zcnZfYm9uam91ciAqLwogCXN0cnVjdCBkbF9saXN0IHAycF9zcnZfdXBucDsgLyogc3RydWN0IHAycF9zcnZfdXBucCAqLwogCWludCBwMnBfZGlzYWJsZWQ7CiAJaW50IGNyb3NzX2Nvbm5lY3Rpb247Ci0Jc3RydWN0IHdwYV9mcmVxX3JhbmdlICpwMnBfZGlzYWxsb3dfZnJlcTsKLQl1bnNpZ25lZCBpbnQgbnVtX3AycF9kaXNhbGxvd19mcmVxOworCXN0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0IHAycF9kaXNhbGxvd19mcmVxOworCXN0cnVjdCB3cGFfZnJlcV9yYW5nZV9saXN0IHAycF9nb19hdm9pZF9mcmVxOwogCWVudW0gd3BhX2NvbmNfcHJlZiB7CiAJCVdQQV9DT05DX1BSRUZfTk9UX1NFVCwKIAkJV1BBX0NPTkNfUFJFRl9TVEEsCiAJCVdQQV9DT05DX1BSRUZfUDJQCiAJfSBjb25jX3ByZWY7Ci0JdW5zaWduZWQgaW50IHAycF9jYl9vbl9zY2FuX2NvbXBsZXRlOjE7CiAJdW5zaWduZWQgaW50IHAycF9wZXJfc3RhX3BzazoxOworCXVuc2lnbmVkIGludCBwMnBfZmFpbF9vbl93cHNfY29tcGxldGU6MTsKIAogI2lmZGVmIENPTkZJR19XSUZJX0RJU1BMQVkKIAlpbnQgd2lmaV9kaXNwbGF5OwpAQCAtMjc4LDYgKzI4NSw2MSBAQAogCiAKIC8qKgorICogc3RydWN0IHdwYV9yYWRpbyAtIEludGVybmFsIGRhdGEgZm9yIHBlci1yYWRpbyBpbmZvcm1hdGlvbgorICoKKyAqIFRoaXMgc3RydWN0dXJlIGlzIHVzZWQgdG8gc2hhcmUgZGF0YSBhYm91dCBjb25maWd1cmVkIGludGVyZmFjZXMKKyAqIChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQpIHRoYXQgc2hhcmUgdGhlIHNhbWUgcGh5c2ljYWwgcmFkaW8sIGUuZy4sIHRvIGFsbG93CisgKiBiZXR0ZXIgY29vcmRpbmF0aW9uIG9mIG9mZmNoYW5uZWwgb3BlcmF0aW9ucy4KKyAqLworc3RydWN0IHdwYV9yYWRpbyB7CisJY2hhciBuYW1lWzE2XTsgLyogZnJvbSBkcml2ZXJfb3BzIGdldF9yYWRpb19uYW1lKCkgb3IgZW1wdHkgaWYgbm90CisJCQkqIGF2YWlsYWJsZSAqLworCXN0cnVjdCBkbF9saXN0IGlmYWNlczsgLyogc3RydWN0IHdwYV9zdXBwbGljYW50OjpyYWRpb19saXN0IGVudHJpZXMgKi8KKwlzdHJ1Y3QgZGxfbGlzdCB3b3JrOyAvKiBzdHJ1Y3Qgd3BhX3JhZGlvX3dvcms6Omxpc3QgZW50cmllcyAqLworfTsKKworLyoqCisgKiBzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgLSBSYWRpbyB3b3JrIGl0ZW0KKyAqLworc3RydWN0IHdwYV9yYWRpb193b3JrIHsKKwlzdHJ1Y3QgZGxfbGlzdCBsaXN0OworCXVuc2lnbmVkIGludCBmcmVxOyAvKiBrbm93biBmcmVxdWVuY3kgKE1Ieikgb3IgMCBmb3IgbXVsdGlwbGUvdW5rbm93biAqLworCWNvbnN0IGNoYXIgKnR5cGU7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfczsKKwl2b2lkICgqY2IpKHN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yaywgaW50IGRlaW5pdCk7CisJdm9pZCAqY3R4OworCXVuc2lnbmVkIGludCBzdGFydGVkOjE7CisJc3RydWN0IG9zX3JlbHRpbWUgdGltZTsKK307CisKK2ludCByYWRpb19hZGRfd29yayhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCB1bnNpZ25lZCBpbnQgZnJlcSwKKwkJICAgY29uc3QgY2hhciAqdHlwZSwgaW50IG5leHQsCisJCSAgIHZvaWQgKCpjYikoc3RydWN0IHdwYV9yYWRpb193b3JrICp3b3JrLCBpbnQgZGVpbml0KSwKKwkJICAgdm9pZCAqY3R4KTsKK3ZvaWQgcmFkaW9fd29ya19kb25lKHN0cnVjdCB3cGFfcmFkaW9fd29yayAqd29yayk7Cit2b2lkIHJhZGlvX3JlbW92ZV93b3JrcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJY29uc3QgY2hhciAqdHlwZSwgaW50IHJlbW92ZV9hbGwpOwordm9pZCByYWRpb193b3JrX2NoZWNrX25leHQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CitpbnQgcmFkaW9fd29ya19wZW5kaW5nKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKnR5cGUpOworCitzdHJ1Y3Qgd3BhX2Nvbm5lY3Rfd29yayB7CisJdW5zaWduZWQgaW50IHNtZToxOworCXN0cnVjdCB3cGFfYnNzICpic3M7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkOworfTsKKworaW50IHdwYXNfdmFsaWRfYnNzX3NzaWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9ic3MgKnRlc3RfYnNzLAorCQkJc3RydWN0IHdwYV9zc2lkICp0ZXN0X3NzaWQpOwordm9pZCB3cGFzX2Nvbm5lY3Rfd29ya19mcmVlKHN0cnVjdCB3cGFfY29ubmVjdF93b3JrICpjd29yayk7Cit2b2lkIHdwYXNfY29ubmVjdF93b3JrX2RvbmUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CisKK3N0cnVjdCB3cGFfZXh0ZXJuYWxfd29yayB7CisJdW5zaWduZWQgaW50IGlkOworCWNoYXIgdHlwZVsxMDBdOworCXVuc2lnbmVkIGludCB0aW1lb3V0OworfTsKKworLyoqCiAgKiBvZmZjaGFubmVsX3NlbmRfYWN0aW9uX3Jlc3VsdCAtIFJlc3VsdCBvZiBvZmZjaGFubmVsIHNlbmQgQWN0aW9uIGZyYW1lCiAgKi8KIGVudW0gb2ZmY2hhbm5lbF9zZW5kX2FjdGlvbl9yZXN1bHQgewpAQCAtMjk2LDcgKzM1OCw3IEBACiAJCVdQU19BUF9TRUxfUkVHX09VUgogCX0gdHlwZTsKIAl1bnNpZ25lZCBpbnQgdHJpZXM7Ci0Jc3RydWN0IG9zX3RpbWUgbGFzdF9hdHRlbXB0OworCXN0cnVjdCBvc19yZWx0aW1lIGxhc3RfYXR0ZW1wdDsKIH07CiAKIHN0cnVjdCB3cGFfc3NpZF92YWx1ZSB7CkBAIC0zMDQsNiArMzY2LDE0IEBACiAJc2l6ZV90IHNzaWRfbGVuOwogfTsKIAorI2RlZmluZSBXUEFfRlJFUV9VU0VEX0JZX0lORlJBX1NUQVRJT04gQklUKDApCisjZGVmaW5lIFdQQV9GUkVRX1VTRURfQllfUDJQX0NMSUVOVCBCSVQoMSkKKworc3RydWN0IHdwYV91c2VkX2ZyZXFfZGF0YSB7CisJaW50IGZyZXE7CisJdW5zaWduZWQgaW50IGZsYWdzOworfTsKKwogLyoqCiAgKiBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgLSBJbnRlcm5hbCBkYXRhIGZvciB3cGFfc3VwcGxpY2FudCBpbnRlcmZhY2UKICAqCkBAIC0zMTQsNiArMzg0LDggQEAKICAqLwogc3RydWN0IHdwYV9zdXBwbGljYW50IHsKIAlzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsOworCXN0cnVjdCB3cGFfcmFkaW8gKnJhZGlvOyAvKiBzaGFyZWQgcmFkaW8gY29udGV4dCAqLworCXN0cnVjdCBkbF9saXN0IHJhZGlvX2xpc3Q7IC8qIGxpc3QgaGVhZDogc3RydWN0IHdwYV9yYWRpbzo6aWZhY2VzICovCiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICpwYXJlbnQ7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICpuZXh0OwogCXN0cnVjdCBsMl9wYWNrZXRfZGF0YSAqbDI7CkBAIC0zMzQsOSArNDA2LDE0IEBACiAKIAljaGFyICpjb25mbmFtZTsKIAljaGFyICpjb25mYW5vdGhlcjsKKworI2lmZGVmIENPTkZJR19QMlAKKwljaGFyICpjb25mX3AycF9kZXY7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCiAJc3RydWN0IHdwYV9jb25maWcgKmNvbmY7CiAJaW50IGNvdW50ZXJtZWFzdXJlczsKLQlvc190aW1lX3QgbGFzdF9taWNoYWVsX21pY19lcnJvcjsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBsYXN0X21pY2hhZWxfbWljX2Vycm9yOwogCXU4IGJzc2lkW0VUSF9BTEVOXTsKIAl1OCBwZW5kaW5nX2Jzc2lkW0VUSF9BTEVOXTsgLyogSWYgd3BhX3N0YXRlID09IFdQQV9BU1NPQ0lBVElORywgdGhpcwogCQkJCSAgICAgKiBmaWVsZCBjb250YWlucyB0aGUgdGFyZ2V0IEJTU0lELiAqLwpAQCAtMzY4LDYgKzQ0NSw5IEBACiAKIAllbnVtIHsgV1BBX1NFVEJBTkRfQVVUTywgV1BBX1NFVEJBTkRfNUcsIFdQQV9TRVRCQU5EXzJHIH0gc2V0YmFuZDsKIAorCS8qIFByZWZlcnJlZCBuZXR3b3JrIGZvciB0aGUgbmV4dCBjb25uZWN0aW9uIGF0dGVtcHQgKi8KKwlzdHJ1Y3Qgd3BhX3NzaWQgKm5leHRfc3NpZDsKKwogCS8qIHByZXZpb3VzIHNjYW4gd2FzIHdpbGRjYXJkIHdoZW4gaW50ZXJsZWF2aW5nIGJldHdlZW4KIAkgKiB3aWxkY2FyZCBzY2FucyBhbmQgc3BlY2lmaWMgU1NJRCBzY2FuIHdoZW4gbWF4X3NzaWRzPTEgKi8KIAlpbnQgcHJldl9zY2FuX3dpbGRjYXJkOwpAQCAtNDAwLDggKzQ4MCw3IEBACiAJc3RydWN0IHdwYV9ic3MgKipsYXN0X3NjYW5fcmVzOwogCXVuc2lnbmVkIGludCBsYXN0X3NjYW5fcmVzX3VzZWQ7CiAJdW5zaWduZWQgaW50IGxhc3Rfc2Nhbl9yZXNfc2l6ZTsKLQlpbnQgbGFzdF9zY2FuX2Z1bGw7Ci0Jc3RydWN0IG9zX3RpbWUgbGFzdF9zY2FuOworCXN0cnVjdCBvc19yZWx0aW1lIGxhc3Rfc2NhbjsKIAogCXN0cnVjdCB3cGFfZHJpdmVyX29wcyAqZHJpdmVyOwogCWludCBpbnRlcmZhY2VfcmVtb3ZlZDsgLyogd2hldGhlciB0aGUgbmV0d29yayBpbnRlcmZhY2UgaGFzIGJlZW4KQEAgLTQxMiw2ICs0OTEsNyBAQAogCXN0cnVjdCBjdHJsX2lmYWNlX3ByaXYgKmN0cmxfaWZhY2U7CiAKIAllbnVtIHdwYV9zdGF0ZXMgd3BhX3N0YXRlOworCXN0cnVjdCB3cGFfcmFkaW9fd29yayAqc2Nhbl93b3JrOwogCWludCBzY2FubmluZzsKIAlpbnQgc2NoZWRfc2Nhbm5pbmc7CiAJaW50IG5ld19jb25uZWN0aW9uOwpAQCAtNDI1LDcgKzUwNSw4IEBACiAKIAl1bnNpZ25lZCBjaGFyIGxhc3RfZWFwb2xfc3JjW0VUSF9BTEVOXTsKIAotCWludCBrZXlzX2NsZWFyZWQ7CisJdW5zaWduZWQgaW50IGtleXNfY2xlYXJlZDsgLyogYml0ZmllbGQgb2Yga2V5IGluZGV4ZXMgdGhhdCB0aGUgZHJpdmVyIGlzCisJCQkJICAgICoga25vd24gbm90IHRvIGJlIGNvbmZpZ3VyZWQgd2l0aCBhIGtleSAqLwogCiAJc3RydWN0IHdwYV9ibGFja2xpc3QgKmJsYWNrbGlzdDsKIApAQCAtNDcwLDE0ICs1NTEsMjcgQEAKIAkJICogdG8gYmUgcnVuLgogCQkgKi8KIAkJTUFOVUFMX1NDQU5fUkVRCi0JfSBzY2FuX3JlcTsKLQlzdHJ1Y3Qgb3NfdGltZSBzY2FuX3RyaWdnZXJfdGltZTsKKwl9IHNjYW5fcmVxLCBsYXN0X3NjYW5fcmVxOworCXN0cnVjdCBvc19yZWx0aW1lIHNjYW5fdHJpZ2dlcl90aW1lLCBzY2FuX3N0YXJ0X3RpbWU7CiAJaW50IHNjYW5fcnVuczsgLyogbnVtYmVyIG9mIHNjYW4gcnVucyBzaW5jZSBXUFMgd2FzIHN0YXJ0ZWQgKi8KIAlpbnQgKm5leHRfc2Nhbl9mcmVxczsKKwlpbnQgKm1hbnVhbF9zY2FuX2ZyZXFzOworCWludCAqbWFudWFsX3NjaGVkX3NjYW5fZnJlcXM7CisJdW5zaWduZWQgaW50IG1hbnVhbF9zY2FuX3Bhc3NpdmU6MTsKKwl1bnNpZ25lZCBpbnQgbWFudWFsX3NjYW5fdXNlX2lkOjE7CisJdW5zaWduZWQgaW50IG1hbnVhbF9zY2FuX29ubHlfbmV3OjE7CisJdW5zaWduZWQgaW50IG93bl9zY2FuX3JlcXVlc3RlZDoxOworCXVuc2lnbmVkIGludCBvd25fc2Nhbl9ydW5uaW5nOjE7CisJdW5zaWduZWQgaW50IGV4dGVybmFsX3NjYW5fcnVubmluZzoxOworCXVuc2lnbmVkIGludCBjbGVhcl9kcml2ZXJfc2Nhbl9jYWNoZToxOworCXVuc2lnbmVkIGludCBtYW51YWxfc2Nhbl9pZDsKIAlpbnQgc2Nhbl9pbnRlcnZhbDsgLyogdGltZSBpbiBzZWMgYmV0d2VlbiBzY2FucyB0byBmaW5kIHN1aXRhYmxlIEFQICovCiAJaW50IG5vcm1hbF9zY2FuczsgLyogbm9ybWFsIHNjYW5zIHJ1biBiZWZvcmUgc2NoZWRfc2NhbiAqLwogCWludCBzY2FuX2Zvcl9jb25uZWN0aW9uOyAvKiB3aGV0aGVyIHRoZSBzY2FuIHJlcXVlc3Qgd2FzIHRyaWdnZXJlZCBmb3IKIAkJCQkgICogZmluZGluZyBhIGNvbm5lY3Rpb24gKi8KKyNkZWZpbmUgTUFYX1NDQU5fSUQgMTYKKwlpbnQgc2Nhbl9pZFtNQVhfU0NBTl9JRF07CisJdW5zaWduZWQgaW50IHNjYW5faWRfY291bnQ7CiAKIAl1bnNpZ25lZCBpbnQgZHJ2X2ZsYWdzOwogCXVuc2lnbmVkIGludCBkcnZfZW5jOwpAQCAtNTA5LDkgKzYwMywxMSBAQAogCWludCBibGFja2xpc3RfY2xlYXJlZDsKIAogCXN0cnVjdCB3cGFidWYgKnBlbmRpbmdfZWFwb2xfcng7Ci0Jc3RydWN0IG9zX3RpbWUgcGVuZGluZ19lYXBvbF9yeF90aW1lOworCXN0cnVjdCBvc19yZWx0aW1lIHBlbmRpbmdfZWFwb2xfcnhfdGltZTsKIAl1OCBwZW5kaW5nX2VhcG9sX3J4X3NyY1tFVEhfQUxFTl07CiAJdW5zaWduZWQgaW50IGxhc3RfZWFwb2xfbWF0Y2hlc19ic3NpZDoxOworCXVuc2lnbmVkIGludCBlYXBfZXhwZWN0ZWRfZmFpbHVyZToxOworCXVuc2lnbmVkIGludCByZWF0dGFjaDoxOyAvKiByZWFzc29jaWF0aW9uIHRvIHRoZSBzYW1lIEJTUyByZXF1ZXN0ZWQgKi8KIAogCXN0cnVjdCBpYnNzX3JzbiAqaWJzc19yc247CiAKQEAgLTU0Myw3ICs2MzksOCBAQAogCQl1OCAqc2FfcXVlcnlfdHJhbnNfaWQ7IC8qIGJ1ZmZlciBvZiBXTEFOX1NBX1FVRVJZX1RSX0lEX0xFTiAqCiAJCQkJCSogc2FfcXVlcnlfY291bnQgb2N0ZXRzIG9mIHBlbmRpbmcKIAkJCQkJKiBTQSBRdWVyeSB0cmFuc2FjdGlvbiBpZGVudGlmaWVycyAqLwotCQlzdHJ1Y3Qgb3NfdGltZSBzYV9xdWVyeV9zdGFydDsKKwkJc3RydWN0IG9zX3JlbHRpbWUgc2FfcXVlcnlfc3RhcnQ7CisJCXN0cnVjdCBvc19yZWx0aW1lIGxhc3RfdW5wcm90X2Rpc2Nvbm5lY3Q7CiAJCXU4IHNjaGVkX29ic3Nfc2NhbjsKIAkJdTE2IG9ic3Nfc2Nhbl9pbnQ7CiAJCXUxNiBic3NfbWF4X2lkbGVfcGVyaW9kOwpAQCAtNTcwLDYgKzY2Nyw3IEBACiAJdW5zaWduZWQgaW50IHBlbmRpbmdfYWN0aW9uX2ZyZXE7CiAJaW50IHBlbmRpbmdfYWN0aW9uX25vX2NjazsKIAlpbnQgcGVuZGluZ19hY3Rpb25fd2l0aG91dF9yb2M7CisJdW5zaWduZWQgaW50IHBlbmRpbmdfYWN0aW9uX3R4X2RvbmU6MTsKIAl2b2lkICgqcGVuZGluZ19hY3Rpb25fdHhfc3RhdHVzX2NiKShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgICAgdW5zaWduZWQgaW50IGZyZXEsIGNvbnN0IHU4ICpkc3QsCiAJCQkJCSAgICBjb25zdCB1OCAqc3JjLCBjb25zdCB1OCAqYnNzaWQsCkBAIC02MDMsNiArNzAxLDggQEAKIAl1OCBwMnBfYXV0aF9pbnZpdGVbRVRIX0FMRU5dOwogCWludCBwMnBfc2Rfb3Zlcl9jdHJsX2lmYWNlOwogCWludCBwMnBfaW5fcHJvdmlzaW9uaW5nOworCWludCBwMnBfaW5faW52aXRhdGlvbjsKKwlpbnQgcDJwX2ludml0ZV9nb19mcmVxOwogCWludCBwZW5kaW5nX2ludml0ZV9zc2lkX2lkOwogCWludCBzaG93X2dyb3VwX3N0YXJ0ZWQ7CiAJdTggZ29fZGV2X2FkZHJbRVRIX0FMRU5dOwpAQCAtNjEwLDYgKzcxMCw4IEBACiAJdTggcGVuZGluZ19qb2luX2lmYWNlX2FkZHJbRVRIX0FMRU5dOwogCXU4IHBlbmRpbmdfam9pbl9kZXZfYWRkcltFVEhfQUxFTl07CiAJaW50IHBlbmRpbmdfam9pbl93cHNfbWV0aG9kOworCXU4IHAycF9qb2luX3NzaWRbMzJdOworCXNpemVfdCBwMnBfam9pbl9zc2lkX2xlbjsKIAlpbnQgcDJwX2pvaW5fc2Nhbl9jb3VudDsKIAlpbnQgYXV0b19wZF9zY2FuX3JldHJ5OwogCWludCBmb3JjZV9sb25nX3NkOwpAQCAtNjM5LDIwICs3NDEsMzUgQEAKIAkgKi8KIAljaGFyIGNyb3NzX2Nvbm5lY3RfdXBsaW5rWzEwMF07CiAKLQl1bnNpZ25lZCBpbnQgc3RhX3NjYW5fcGVuZGluZzoxOwogCXVuc2lnbmVkIGludCBwMnBfYXV0b19qb2luOjE7CiAJdW5zaWduZWQgaW50IHAycF9hdXRvX3BkOjE7CiAJdW5zaWduZWQgaW50IHAycF9wZXJzaXN0ZW50X2dyb3VwOjE7CiAJdW5zaWduZWQgaW50IHAycF9mYWxsYmFja190b19nb19uZWc6MTsKIAl1bnNpZ25lZCBpbnQgcDJwX3BkX2JlZm9yZV9nb19uZWc6MTsKIAl1bnNpZ25lZCBpbnQgcDJwX2dvX2h0NDA6MTsKKwl1bnNpZ25lZCBpbnQgcDJwX2dvX3ZodDoxOwogCXVuc2lnbmVkIGludCB1c2VyX2luaXRpYXRlZF9wZDoxOworCXVuc2lnbmVkIGludCBwMnBfZ29fZ3JvdXBfZm9ybWF0aW9uX2NvbXBsZXRlZDoxOworCXVuc2lnbmVkIGludCB3YWl0aW5nX3ByZXNlbmNlX3Jlc3A7CisJaW50IHAycF9maXJzdF9jb25uZWN0aW9uX3RpbWVvdXQ7CisJdW5zaWduZWQgaW50IHAycF9uZmNfdGFnX2VuYWJsZWQ6MTsKKwl1bnNpZ25lZCBpbnQgcDJwX3BlZXJfb29iX3BrX2hhc2hfa25vd246MTsKKwl1bnNpZ25lZCBpbnQgcDJwX2Rpc2FibGVfaXBfYWRkcl9yZXE6MTsKIAlpbnQgcDJwX3BlcnNpc3RlbnRfZ29fZnJlcTsKIAlpbnQgcDJwX3BlcnNpc3RlbnRfaWQ7CiAJaW50IHAycF9nb19pbnRlbnQ7CiAJaW50IHAycF9jb25uZWN0X2ZyZXE7Ci0Jc3RydWN0IG9zX3RpbWUgcDJwX2F1dG9fc3RhcnRlZDsKKwlzdHJ1Y3Qgb3NfcmVsdGltZSBwMnBfYXV0b19zdGFydGVkOwogCXN0cnVjdCB3cGFfc3NpZCAqcDJwX2xhc3RfNHdheV9oc19mYWlsOworCXN0cnVjdCB3cGFfcmFkaW9fd29yayAqcDJwX3NjYW5fd29yazsKKwlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKnAycF9saXN0ZW5fd29yazsKKwlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKnAycF9zZW5kX2FjdGlvbl93b3JrOworCisJdTE2IHAycF9vb2JfZGV2X3B3X2lkOyAvKiBPT0IgRGV2aWNlIFBhc3N3b3JkIElkIGZvciBncm91cCBmb3JtYXRpb24gKi8KKwlzdHJ1Y3Qgd3BhYnVmICpwMnBfb29iX2Rldl9wdzsgLyogT09CIERldmljZSBQYXNzd29yZCBmb3IgZ3JvdXAKKwkJCQkJKiBmb3JtYXRpb24gKi8KKwl1OCBwMnBfcGVlcl9vb2JfcHVia2V5X2hhc2hbV1BTX09PQl9QVUJLRVlfSEFTSF9MRU5dOworCXU4IHAycF9pcF9hZGRyX2luZm9bMyAqIDRdOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCXN0cnVjdCB3cGFfc3NpZCAqYmdzY2FuX3NzaWQ7CkBAIC02NzIsNyArNzg5LDYgQEAKIAlpbnQgYWZ0ZXJfd3BzOwogCWludCBrbm93bl93cHNfZnJlcTsKIAl1bnNpZ25lZCBpbnQgd3BzX2ZyZXE7Ci0JdTE2IHdwc19hcF9jaGFubmVsOwogCWludCB3cHNfZnJhZ21lbnRfc2l6ZTsKIAlpbnQgYXV0b19yZWNvbm5lY3RfZGlzYWJsZWQ7CiAKQEAgLTY4OSw3ICs4MDUsMTUgQEAKIAl1bnNpZ25lZCBpbnQgYXV0b19zZWxlY3Q6MTsKIAl1bnNpZ25lZCBpbnQgYXV0b19uZXR3b3JrX3NlbGVjdDoxOwogCXVuc2lnbmVkIGludCBmZXRjaF9hbGxfYW5xcDoxOworCXVuc2lnbmVkIGludCBmZXRjaF9vc3VfaW5mbzoxOworCXVuc2lnbmVkIGludCBmZXRjaF9vc3VfaWNvbl9pbl9wcm9ncmVzczoxOwogCXN0cnVjdCB3cGFfYnNzICppbnRlcndvcmtpbmdfZ2FzX2JzczsKKwl1bnNpZ25lZCBpbnQgb3N1X2ljb25faWQ7CisJc3RydWN0IG9zdV9wcm92aWRlciAqb3N1X3Byb3Y7CisJc2l6ZV90IG9zdV9wcm92X2NvdW50OworCXN0cnVjdCBvc19yZWx0aW1lIG9zdV9pY29uX2ZldGNoX3N0YXJ0OworCXVuc2lnbmVkIGludCBudW1fb3N1X3NjYW5zOworCXVuc2lnbmVkIGludCBudW1fcHJvdl9mb3VuZDsKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAJdW5zaWduZWQgaW50IGRydl9jYXBhX2tub3duOwogCkBAIC02OTgsMTkgKzgyMiwyNCBAQAogCQl1MTYgbnVtX21vZGVzOwogCQl1MTYgZmxhZ3M7CiAJfSBodzsKKyNpZmRlZiBDT05GSUdfTUFDU0VDCisJc3RydWN0IGllZWU4MDJfMXhfa2F5ICprYXk7CisjZW5kaWYgLyogQ09ORklHX01BQ1NFQyAqLwogCiAJaW50IHBubzsKKwlpbnQgcG5vX3NjaGVkX3BlbmRpbmc7CiAKIAkvKiBXTEFOX1JFQVNPTl8qIHJlYXNvbiBjb2Rlcy4gTmVnYXRpdmUgaWYgbG9jYWxseSBnZW5lcmF0ZWQuICovCiAJaW50IGRpc2Nvbm5lY3RfcmVhc29uOwogCiAJc3RydWN0IGV4dF9wYXNzd29yZF9kYXRhICpleHRfcHc7CiAKLQlzdHJ1Y3Qgd3BhYnVmICpsYXN0X2dhc19yZXNwOwotCXU4IGxhc3RfZ2FzX2FkZHJbRVRIX0FMRU5dOwotCXU4IGxhc3RfZ2FzX2RpYWxvZ190b2tlbjsKKwlzdHJ1Y3Qgd3BhYnVmICpsYXN0X2dhc19yZXNwLCAqcHJldl9nYXNfcmVzcDsKKwl1OCBsYXN0X2dhc19hZGRyW0VUSF9BTEVOXSwgcHJldl9nYXNfYWRkcltFVEhfQUxFTl07CisJdTggbGFzdF9nYXNfZGlhbG9nX3Rva2VuLCBwcmV2X2dhc19kaWFsb2dfdG9rZW47CiAKIAl1bnNpZ25lZCBpbnQgbm9fa2VlcF9hbGl2ZToxOworCXVuc2lnbmVkIGludCBleHRfbWdtdF9mcmFtZV9oYW5kbGluZzoxOwogCiAjaWZkZWYgQ09ORklHX1dOTQogCXU4IHdubV9kaWFsb2dfdG9rZW47CkBAIC03MjksNiArODU4LDExIEBACiAjZW5kaWYgLyogQ09ORklHX1RFU1RJTkdfR0VUX0dUSyAqLwogCiAJdW5zaWduZWQgaW50IG51bV9tdWx0aWNoYW5fY29uY3VycmVudDsKKwlzdHJ1Y3Qgd3BhX3JhZGlvX3dvcmsgKmNvbm5lY3Rfd29yazsKKworCXVuc2lnbmVkIGludCBleHRfd29ya19pZDsKKworCXN0cnVjdCB3cGFidWYgKnZlbmRvcl9lbGVtW05VTV9WRU5ET1JfRUxFTV9GUkFNRVNdOwogfTsKIAogCkBAIC03NzYsNiArOTEwLDkgQEAKIAkJCQkgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkKTsKIHZvaWQgd3BhX3N1cHBsaWNhbnRfc2VsZWN0X25ldHdvcmsoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpOworaW50IHdwYXNfc2V0X3BrY3MxMV9lbmdpbmVfYW5kX21vZHVsZV9wYXRoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgIGNvbnN0IGNoYXIgKnBrY3MxMV9lbmdpbmVfcGF0aCwKKwkJCQkJICAgY29uc3QgY2hhciAqcGtjczExX21vZHVsZV9wYXRoKTsKIGludCB3cGFfc3VwcGxpY2FudF9zZXRfYXBfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJICAgICAgIGludCBhcF9zY2FuKTsKIGludCB3cGFfc3VwcGxpY2FudF9zZXRfYnNzX2V4cGlyYXRpb25fYWdlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCkBAIC04MDcsMjEgKzk0NCwxOSBAQAogdm9pZCB3cGFfc3VwcGxpY2FudF90ZXJtaW5hdGVfcHJvYyhzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsKTsKIHZvaWQgd3BhX3N1cHBsaWNhbnRfcnhfZWFwb2wodm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjX2FkZHIsCiAJCQkgICAgIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pOwotZW51bSB3cGFfa2V5X21nbXQga2V5X21nbXQyZHJpdmVyKGludCBrZXlfbWdtdCk7CiB2b2lkIHdwYV9zdXBwbGljYW50X3VwZGF0ZV9jb25maWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIHdwYV9zdXBwbGljYW50X2NsZWFyX3N0YXR1cyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIHZvaWQgd3Bhc19jb25uZWN0aW9uX2ZhaWxlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQpOwogaW50IHdwYXNfZHJpdmVyX2Jzc19zZWxlY3Rpb24oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiBpbnQgd3Bhc19pc19wMnBfcHJpb3JpdGl6ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci12b2lkIHdwYXNfYXV0aF9mYWlsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIHdwYXNfYXV0aF9mYWlsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqcmVhc29uKTsKIHZvaWQgd3Bhc19jbGVhcl90ZW1wX2Rpc2FibGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkgICAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsIGludCBjbGVhcl9mYWlsdXJlcyk7CiBpbnQgZGlzYWxsb3dlZF9ic3NpZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQpOwogaW50IGRpc2FsbG93ZWRfc3NpZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqc3NpZCwKIAkJICAgIHNpemVfdCBzc2lkX2xlbik7CiB2b2lkIHdwYXNfcmVxdWVzdF9jb25uZWN0aW9uKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwotaW50IHdwYXNfYnVpbGRfZXh0X2NhcGFiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHU4ICpidWYpOwotaW50IHdwYXNfd3BhX2lzX2luX3Byb2dyZXNzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworaW50IHdwYXNfYnVpbGRfZXh0X2NhcGFiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHU4ICpidWYsIHNpemVfdCBidWZsZW4pOwogCiAvKioKICAqIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfY3RybF9yc3BfaGFuZGxlIC0gSGFuZGxlIGEgY29udHJvbCByZXNwb25zZQpAQCAtODY3LDYgKzEwMDIsMTMgQEAKIAogaW50IHdwYXNfaW5pdF9leHRfcHcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiAKK3ZvaWQgZHVtcF9mcmVxX2RhdGEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgY2hhciAqdGl0bGUsCisJCSAgICBzdHJ1Y3Qgd3BhX3VzZWRfZnJlcV9kYXRhICpmcmVxc19kYXRhLAorCQkgICAgdW5zaWduZWQgaW50IGxlbik7CisKK2ludCBnZXRfc2hhcmVkX3JhZGlvX2ZyZXFzX2RhdGEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQlzdHJ1Y3Qgd3BhX3VzZWRfZnJlcV9kYXRhICpmcmVxc19kYXRhLAorCQkJCXVuc2lnbmVkIGludCBsZW4pOwogaW50IGdldF9zaGFyZWRfcmFkaW9fZnJlcXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgIGludCAqZnJlcV9hcnJheSwgdW5zaWduZWQgaW50IGxlbik7CiAKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50X3RlbXBsYXRlLmNvbmYgYi93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudF90ZW1wbGF0ZS5jb25mCmluZGV4IGEwOGViMzMuLmYzZjJhNjQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50X3RlbXBsYXRlLmNvbmYKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnRfdGVtcGxhdGUuY29uZgpAQCAtMSw2ICsxLDYgQEAKICMjIyMjIHdwYV9zdXBwbGljYW50IGNvbmZpZ3VyYXRpb24gZmlsZSB0ZW1wbGF0ZSAjIyMjIwogdXBkYXRlX2NvbmZpZz0xCi1jdHJsX2ludGVyZmFjZT13bGFuMAogZWFwb2xfdmVyc2lvbj0xCiBhcF9zY2FuPTEKIGZhc3RfcmVhdXRoPTEKK3BtZj0xCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93cGFzX2dsdWUuYyBiL3dwYV9zdXBwbGljYW50L3dwYXNfZ2x1ZS5jCmluZGV4IDYxYTQyYmQuLjM1MGIxMjIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwYXNfZ2x1ZS5jCisrKyBiL3dwYV9zdXBwbGljYW50L3dwYXNfZ2x1ZS5jCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiYnNzLmgiCiAjaW5jbHVkZSAic2Nhbi5oIgogI2luY2x1ZGUgIm5vdGlmeS5oIgorI2luY2x1ZGUgIndwYXNfa2F5LmgiCiAKIAogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX0JMT0JTCkBAIC0yMTYsMjkgKzIxNyw1MCBAQAogfQogCiAKLXN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X2VhcG9sX2NiKHN0cnVjdCBlYXBvbF9zbSAqZWFwb2wsIGludCBzdWNjZXNzLAorc3RhdGljIGNvbnN0IGNoYXIgKiByZXN1bHRfc3RyKGVudW0gZWFwb2xfc3VwcF9yZXN1bHQgcmVzdWx0KQoreworCXN3aXRjaCAocmVzdWx0KSB7CisJY2FzZSBFQVBPTF9TVVBQX1JFU1VMVF9GQUlMVVJFOgorCQlyZXR1cm4gIkZBSUxVUkUiOworCWNhc2UgRUFQT0xfU1VQUF9SRVNVTFRfU1VDQ0VTUzoKKwkJcmV0dXJuICJTVUNDRVNTIjsKKwljYXNlIEVBUE9MX1NVUFBfUkVTVUxUX0VYUEVDVEVEX0ZBSUxVUkU6CisJCXJldHVybiAiRVhQRUNURURfRkFJTFVSRSI7CisJfQorCXJldHVybiAiPyI7Cit9CisKKworc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfZWFwb2xfY2Ioc3RydWN0IGVhcG9sX3NtICplYXBvbCwKKwkJCQkgICAgZW51bSBlYXBvbF9zdXBwX3Jlc3VsdCByZXN1bHQsCiAJCQkJICAgIHZvaWQgKmN0eCkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCWludCByZXMsIHBta19sZW47CiAJdTggcG1rW1BNS19MRU5dOwogCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVBPTCBhdXRoZW50aWNhdGlvbiBjb21wbGV0ZWQgJXNzdWNjZXNzZnVsbHkiLAotCQkgICBzdWNjZXNzID8gIiIgOiAidW4iKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUE9MIGF1dGhlbnRpY2F0aW9uIGNvbXBsZXRlZCAtIHJlc3VsdD0lcyIsCisJCSAgIHJlc3VsdF9zdHIocmVzdWx0KSk7CiAKIAlpZiAod3Bhc193cHNfZWFwb2xfY2Iod3BhX3MpID4gMCkKIAkJcmV0dXJuOwogCi0JaWYgKCFzdWNjZXNzKSB7CisJd3BhX3MtPmVhcF9leHBlY3RlZF9mYWlsdXJlID0gcmVzdWx0ID09CisJCUVBUE9MX1NVUFBfUkVTVUxUX0VYUEVDVEVEX0ZBSUxVUkU7CisKKwlpZiAocmVzdWx0ICE9IEVBUE9MX1NVUFBfUkVTVUxUX1NVQ0NFU1MpIHsKIAkJLyoKIAkJICogTWFrZSBzdXJlIHdlIGRvIG5vdCBnZXQgc3R1Y2sgaGVyZSB3YWl0aW5nIGZvciBsb25nIEVBUE9MCiAJCSAqIHRpbWVvdXQgaWYgdGhlIEFQIGRvZXMgbm90IGRpc2Nvbm5lY3QgaW4gY2FzZSBvZgogCQkgKiBhdXRoZW50aWNhdGlvbiBmYWlsdXJlLgogCQkgKi8KIAkJd3BhX3N1cHBsaWNhbnRfcmVxX2F1dGhfdGltZW91dCh3cGFfcywgMiwgMCk7CisJfSBlbHNlIHsKKwkJaWVlZTgwMl8xeF9ub3RpZnlfY3JlYXRlX2FjdG9yKHdwYV9zLCB3cGFfcy0+bGFzdF9lYXBvbF9zcmMpOwogCX0KIAotCWlmICghc3VjY2VzcyB8fCAhKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTXzRXQVlfSEFORFNIQUtFKSkKKwlpZiAocmVzdWx0ICE9IEVBUE9MX1NVUFBfUkVTVUxUX1NVQ0NFU1MgfHwKKwkgICAgISh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU180V0FZX0hBTkRTSEFLRSkpCiAJCXJldHVybjsKIAogCWlmICghd3BhX2tleV9tZ210X3dwYV9pZWVlODAyMXgod3BhX3MtPmtleV9tZ210KSkKQEAgLTUzOSwxMiArNTYxLDEyIEBACiAKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfc2VuZF90ZGxzX21nbXQodm9pZCAqY3R4LCBjb25zdCB1OCAqZHN0LAogCQkJCQkgdTggYWN0aW9uX2NvZGUsIHU4IGRpYWxvZ190b2tlbiwKLQkJCQkJIHUxNiBzdGF0dXNfY29kZSwgY29uc3QgdTggKmJ1ZiwKLQkJCQkJIHNpemVfdCBsZW4pCisJCQkJCSB1MTYgc3RhdHVzX2NvZGUsIHUzMiBwZWVyX2NhcGFiLAorCQkJCQkgY29uc3QgdTggKmJ1Ziwgc2l6ZV90IGxlbikKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gY3R4OwogCXJldHVybiB3cGFfZHJ2X3NlbmRfdGRsc19tZ210KHdwYV9zLCBkc3QsIGFjdGlvbl9jb2RlLCBkaWFsb2dfdG9rZW4sCi0JCQkJICAgICAgc3RhdHVzX2NvZGUsIGJ1ZiwgbGVuKTsKKwkJCQkgICAgICBzdGF0dXNfY29kZSwgcGVlcl9jYXBhYiwgYnVmLCBsZW4pOwogfQogCiAKQEAgLTU2MCw3ICs1ODIsOSBAQAogCWNvbnN0IHU4ICpzdXBwX3JhdGVzLCBzaXplX3Qgc3VwcF9yYXRlc19sZW4sCiAJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9odF9jYXBhYmlsaXRpZXMgKmh0X2NhcGFiLAogCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfdmh0X2NhcGFiaWxpdGllcyAqdmh0X2NhcGFiLAotCXU4IHFvc2luZm8sIGNvbnN0IHU4ICpleHRfY2FwYWIsIHNpemVfdCBleHRfY2FwYWJfbGVuKQorCXU4IHFvc2luZm8sIGNvbnN0IHU4ICpleHRfY2FwYWIsIHNpemVfdCBleHRfY2FwYWJfbGVuLAorCWNvbnN0IHU4ICpzdXBwX2NoYW5uZWxzLCBzaXplX3Qgc3VwcF9jaGFubmVsc19sZW4sCisJY29uc3QgdTggKnN1cHBfb3Blcl9jbGFzc2VzLCBzaXplX3Qgc3VwcF9vcGVyX2NsYXNzZXNfbGVuKQogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CiAJc3RydWN0IGhvc3RhcGRfc3RhX2FkZF9wYXJhbXMgcGFyYW1zOwpAQCAtNTg4LDYgKzYxMiwxMCBAQAogCXBhcmFtcy5zZXQgPSAhYWRkOwogCXBhcmFtcy5leHRfY2FwYWIgPSBleHRfY2FwYWI7CiAJcGFyYW1zLmV4dF9jYXBhYl9sZW4gPSBleHRfY2FwYWJfbGVuOworCXBhcmFtcy5zdXBwX2NoYW5uZWxzID0gc3VwcF9jaGFubmVsczsKKwlwYXJhbXMuc3VwcF9jaGFubmVsc19sZW4gPSBzdXBwX2NoYW5uZWxzX2xlbjsKKwlwYXJhbXMuc3VwcF9vcGVyX2NsYXNzZXMgPSBzdXBwX29wZXJfY2xhc3NlczsKKwlwYXJhbXMuc3VwcF9vcGVyX2NsYXNzZXNfbGVuID0gc3VwcF9vcGVyX2NsYXNzZXNfbGVuOwogCiAJcmV0dXJuIHdwYV9kcnZfc3RhX2FkZCh3cGFfcywgJnBhcmFtcyk7CiB9CkBAIC02MTEsNiArNjM5LDggQEAKIAkJcmV0dXJuIFdQQV9DVFJMX1JFUV9FQVBfT1RQOwogCWVsc2UgaWYgKG9zX3N0cmNtcChmaWVsZCwgIlBBU1NQSFJBU0UiKSA9PSAwKQogCQlyZXR1cm4gV1BBX0NUUkxfUkVRX0VBUF9QQVNTUEhSQVNFOworCWVsc2UgaWYgKG9zX3N0cmNtcChmaWVsZCwgIlNJTSIpID09IDApCisJCXJldHVybiBXUEFfQ1RSTF9SRVFfU0lNOwogCXJldHVybiBXUEFfQ1RSTF9SRVFfVU5LTk9XTjsKIH0KIApAQCAtNjQ3LDYgKzY3Nyw5IEBACiAJCSp0eHQgPSAiUHJpdmF0ZSBrZXkgcGFzc3BocmFzZSI7CiAJCXJldCA9ICJQQVNTUEhSQVNFIjsKIAkJYnJlYWs7CisJY2FzZSBXUEFfQ1RSTF9SRVFfU0lNOgorCQlyZXQgPSAiU0lNIjsKKwkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJYnJlYWs7CiAJfQpAQCAtOTE4LDYgKzk1MSwyMiBAQAogCQljb25mLnNzaWQgPSBzc2lkLT5zc2lkOwogCQljb25mLnNzaWRfbGVuID0gc3NpZC0+c3NpZF9sZW47CiAJCWNvbmYud3BhX3B0a19yZWtleSA9IHNzaWQtPndwYV9wdGtfcmVrZXk7CisjaWZkZWYgQ09ORklHX1AyUAorCQlpZiAoc3NpZC0+cDJwX2dyb3VwICYmIHdwYV9zLT5jdXJyZW50X2JzcyAmJgorCQkgICAgIXdwYV9zLT5wMnBfZGlzYWJsZV9pcF9hZGRyX3JlcSkgeworCQkJc3RydWN0IHdwYWJ1ZiAqcDJwOworCQkJcDJwID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llX211bHRpKHdwYV9zLT5jdXJyZW50X2JzcywKKwkJCQkJCQkgIFAyUF9JRV9WRU5ET1JfVFlQRSk7CisJCQlpZiAocDJwKSB7CisJCQkJdTggZ3JvdXBfY2FwYWI7CisJCQkJZ3JvdXBfY2FwYWIgPSBwMnBfZ2V0X2dyb3VwX2NhcGFiKHAycCk7CisJCQkJaWYgKGdyb3VwX2NhcGFiICYKKwkJCQkgICAgUDJQX0dST1VQX0NBUEFCX0lQX0FERFJfQUxMT0NBVElPTikKKwkJCQkJY29uZi5wMnAgPSAxOworCQkJCXdwYWJ1Zl9mcmVlKHAycCk7CisJCQl9CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJfQogCXdwYV9zbV9zZXRfY29uZmlnKHdwYV9zLT53cGEsIHNzaWQgPyAmY29uZiA6IE5VTEwpOwogfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd3Bhc19rYXkuYyBiL3dwYV9zdXBwbGljYW50L3dwYXNfa2F5LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzU0ZGVjZgotLS0gL2Rldi9udWxsCisrKyBiL3dwYV9zdXBwbGljYW50L3dwYXNfa2F5LmMKQEAgLTAsMCArMSwzNzggQEAKKy8qCisgKiBJRUVFIDgwMi4xWC0yMDEwIEthWSBJbnRlcmZhY2UKKyAqIENvcHlyaWdodCAoYykgMjAxMy0yMDE0LCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworI2luY2x1ZGUgPG9wZW5zc2wvc3NsLmg+CisjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgImVhcF9wZWVyL2VhcC5oIgorI2luY2x1ZGUgImVhcF9wZWVyL2VhcF9pLmgiCisjaW5jbHVkZSAiZWFwb2xfc3VwcC9lYXBvbF9zdXBwX3NtLmgiCisjaW5jbHVkZSAicGFlL2llZWU4MDJfMXhfa2V5LmgiCisjaW5jbHVkZSAicGFlL2llZWU4MDJfMXhfa2F5LmgiCisjaW5jbHVkZSAid3BhX3N1cHBsaWNhbnRfaS5oIgorI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgImNvbmZpZ19zc2lkLmgiCisjaW5jbHVkZSAiZHJpdmVyX2kuaCIKKyNpbmNsdWRlICJ3cGFzX2theS5oIgorCisKKyNkZWZpbmUgREVGQVVMVF9LRVlfTEVOCQkxNgorLyogc2VjdXJlIENvbm5lY3Rpdml0eSBBc3NvY2lhdGlvbiBLZXkgTmFtZSAoQ0tOKSAqLworI2RlZmluZSBERUZBVUxUX0NLTl9MRU4JCTE2CisKKworc3RhdGljIGludCB3cGFzX21hY3NlY19pbml0KHZvaWQgKnByaXYsIHN0cnVjdCBtYWNzZWNfaW5pdF9wYXJhbXMgKnBhcmFtcykKK3sKKwlyZXR1cm4gd3BhX2Rydl9tYWNzZWNfaW5pdChwcml2LCBwYXJhbXMpOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19tYWNzZWNfZGVpbml0KHZvaWQgKnByaXYpCit7CisJcmV0dXJuIHdwYV9kcnZfbWFjc2VjX2RlaW5pdChwcml2KTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfZW5hYmxlX3Byb3RlY3RfZnJhbWVzKHZvaWQgKndwYV9zLCBCb29sZWFuIGVuYWJsZWQpCit7CisJcmV0dXJuIHdwYV9kcnZfZW5hYmxlX3Byb3RlY3RfZnJhbWVzKHdwYV9zLCBlbmFibGVkKTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfc2V0X3JlcGxheV9wcm90ZWN0KHZvaWQgKndwYV9zLCBCb29sZWFuIGVuYWJsZWQsIHUzMiB3aW5kb3cpCit7CisJcmV0dXJuIHdwYV9kcnZfc2V0X3JlcGxheV9wcm90ZWN0KHdwYV9zLCBlbmFibGVkLCB3aW5kb3cpOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19zZXRfY3VycmVudF9jaXBoZXJfc3VpdGUodm9pZCAqd3BhX3MsIGNvbnN0IHU4ICpjcywKKwkJCQkJIHNpemVfdCBjc19sZW4pCit7CisJcmV0dXJuIHdwYV9kcnZfc2V0X2N1cnJlbnRfY2lwaGVyX3N1aXRlKHdwYV9zLCBjcywgY3NfbGVuKTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfZW5hYmxlX2NvbnRyb2xsZWRfcG9ydCh2b2lkICp3cGFfcywgQm9vbGVhbiBlbmFibGVkKQoreworCXJldHVybiB3cGFfZHJ2X2VuYWJsZV9jb250cm9sbGVkX3BvcnQod3BhX3MsIGVuYWJsZWQpOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19nZXRfcmVjZWl2ZV9sb3dlc3RfcG4odm9pZCAqd3BhX3MsIHUzMiBjaGFubmVsLAorCQkJCSAgICAgIHU4IGFuLCB1MzIgKmxvd2VzdF9wbikKK3sKKwlyZXR1cm4gd3BhX2Rydl9nZXRfcmVjZWl2ZV9sb3dlc3RfcG4od3BhX3MsIGNoYW5uZWwsIGFuLCBsb3dlc3RfcG4pOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19nZXRfdHJhbnNtaXRfbmV4dF9wbih2b2lkICp3cGFfcywgdTMyIGNoYW5uZWwsCisJCQkJICAgICAgdTggYW4sIHUzMiAqbmV4dF9wbikKK3sKKwlyZXR1cm4gd3BhX2Rydl9nZXRfdHJhbnNtaXRfbmV4dF9wbih3cGFfcywgY2hhbm5lbCwgYW4sIG5leHRfcG4pOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19zZXRfdHJhbnNtaXRfbmV4dF9wbih2b2lkICp3cGFfcywgdTMyIGNoYW5uZWwsCisJCQkJICAgICAgdTggYW4sIHUzMiBuZXh0X3BuKQoreworCXJldHVybiB3cGFfZHJ2X3NldF90cmFuc21pdF9uZXh0X3BuKHdwYV9zLCBjaGFubmVsLCBhbiwgbmV4dF9wbik7Cit9CisKKworc3RhdGljIGludCB3cGFzX2dldF9hdmFpbGFibGVfcmVjZWl2ZV9zYyh2b2lkICp3cGFfcywgdTMyICpjaGFubmVsKQoreworCXJldHVybiB3cGFfZHJ2X2dldF9hdmFpbGFibGVfcmVjZWl2ZV9zYyh3cGFfcywgY2hhbm5lbCk7Cit9CisKKworc3RhdGljIHVuc2lnbmVkIGludCBjb25mX29mZnNldF92YWwoZW51bSBjb25maWRlbnRpYWxpdHlfb2Zmc2V0IGNvKQoreworCXN3aXRjaCAoY28pIHsKKwljYXNlIENPTkZJREVOVElBTElUWV9PRkZTRVRfMzA6CisJCXJldHVybiAzMDsKKwkJYnJlYWs7CisJY2FzZSBDT05GSURFTlRJQUxJVFlfT0ZGU0VUXzUwOgorCQlyZXR1cm4gNTA7CisJZGVmYXVsdDoKKwkJcmV0dXJuIDA7CisJfQorfQorCisKK3N0YXRpYyBpbnQgd3Bhc19jcmVhdGVfcmVjZWl2ZV9zYyh2b2lkICp3cGFfcywgdTMyIGNoYW5uZWwsCisJCQkJICBzdHJ1Y3QgaWVlZTgwMl8xeF9ta2Ffc2NpICpzY2ksCisJCQkJICBlbnVtIHZhbGlkYXRlX2ZyYW1lcyB2ZiwKKwkJCQkgIGVudW0gY29uZmlkZW50aWFsaXR5X29mZnNldCBjbykKK3sKKwlyZXR1cm4gd3BhX2Rydl9jcmVhdGVfcmVjZWl2ZV9zYyh3cGFfcywgY2hhbm5lbCwgc2NpLT5hZGRyLCBzY2ktPnBvcnQsCisJCQkJCSBjb25mX29mZnNldF92YWwoY28pLCB2Zik7Cit9CisKKworc3RhdGljIGludCB3cGFzX2RlbGV0ZV9yZWNlaXZlX3NjKHZvaWQgKndwYV9zLCB1MzIgY2hhbm5lbCkKK3sKKwlyZXR1cm4gd3BhX2Rydl9kZWxldGVfcmVjZWl2ZV9zYyh3cGFfcywgY2hhbm5lbCk7Cit9CisKKworc3RhdGljIGludCB3cGFzX2NyZWF0ZV9yZWNlaXZlX3NhKHZvaWQgKndwYV9zLCB1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJICB1MzIgbG93ZXN0X3BuLCBjb25zdCB1OCAqc2FrKQoreworCXJldHVybiB3cGFfZHJ2X2NyZWF0ZV9yZWNlaXZlX3NhKHdwYV9zLCBjaGFubmVsLCBhbiwgbG93ZXN0X3BuLCBzYWspOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19lbmFibGVfcmVjZWl2ZV9zYSh2b2lkICp3cGFfcywgdTMyIGNoYW5uZWwsIHU4IGFuKQoreworCXJldHVybiB3cGFfZHJ2X2VuYWJsZV9yZWNlaXZlX3NhKHdwYV9zLCBjaGFubmVsLCBhbik7Cit9CisKKworc3RhdGljIGludCB3cGFzX2Rpc2FibGVfcmVjZWl2ZV9zYSh2b2lkICp3cGFfcywgdTMyIGNoYW5uZWwsIHU4IGFuKQoreworCXJldHVybiB3cGFfZHJ2X2Rpc2FibGVfcmVjZWl2ZV9zYSh3cGFfcywgY2hhbm5lbCwgYW4pOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19nZXRfYXZhaWxhYmxlX3RyYW5zbWl0X3NjKHZvaWQgKndwYV9zLCB1MzIgKmNoYW5uZWwpCit7CisJcmV0dXJuIHdwYV9kcnZfZ2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYyh3cGFfcywgY2hhbm5lbCk7Cit9CisKKworc3RhdGljIGludAord3Bhc19jcmVhdGVfdHJhbnNtaXRfc2Modm9pZCAqd3BhX3MsIHUzMiBjaGFubmVsLAorCQkJY29uc3Qgc3RydWN0IGllZWU4MDJfMXhfbWthX3NjaSAqc2NpLAorCQkJZW51bSBjb25maWRlbnRpYWxpdHlfb2Zmc2V0IGNvKQoreworCXJldHVybiB3cGFfZHJ2X2NyZWF0ZV90cmFuc21pdF9zYyh3cGFfcywgY2hhbm5lbCwgc2NpLT5hZGRyLCBzY2ktPnBvcnQsCisJCQkJCSAgY29uZl9vZmZzZXRfdmFsKGNvKSk7Cit9CisKKworc3RhdGljIGludCB3cGFzX2RlbGV0ZV90cmFuc21pdF9zYyh2b2lkICp3cGFfcywgdTMyIGNoYW5uZWwpCit7CisJcmV0dXJuIHdwYV9kcnZfZGVsZXRlX3RyYW5zbWl0X3NjKHdwYV9zLCBjaGFubmVsKTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfY3JlYXRlX3RyYW5zbWl0X3NhKHZvaWQgKndwYV9zLCB1MzIgY2hhbm5lbCwgdTggYW4sCisJCQkJICAgdTMyIG5leHRfcG4sIEJvb2xlYW4gY29uZmlkZW50aWFsaXR5LAorCQkJCSAgIGNvbnN0IHU4ICpzYWspCit7CisJcmV0dXJuIHdwYV9kcnZfY3JlYXRlX3RyYW5zbWl0X3NhKHdwYV9zLCBjaGFubmVsLCBhbiwgbmV4dF9wbiwKKwkJCQkJICBjb25maWRlbnRpYWxpdHksIHNhayk7Cit9CisKKworc3RhdGljIGludCB3cGFzX2VuYWJsZV90cmFuc21pdF9zYSh2b2lkICp3cGFfcywgdTMyIGNoYW5uZWwsIHU4IGFuKQoreworCXJldHVybiB3cGFfZHJ2X2VuYWJsZV90cmFuc21pdF9zYSh3cGFfcywgY2hhbm5lbCwgYW4pOworfQorCisKK3N0YXRpYyBpbnQgd3Bhc19kaXNhYmxlX3RyYW5zbWl0X3NhKHZvaWQgKndwYV9zLCB1MzIgY2hhbm5lbCwgdTggYW4pCit7CisJcmV0dXJuIHdwYV9kcnZfZGlzYWJsZV90cmFuc21pdF9zYSh3cGFfcywgY2hhbm5lbCwgYW4pOworfQorCisKK2ludCBpZWVlODAyXzF4X2FsbG9jX2theV9zbShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpCit7CisJc3RydWN0IGllZWU4MDJfMXhfa2F5X2N0eCAqa2F5X2N0eDsKKwlzdHJ1Y3QgaWVlZTgwMl8xeF9rYXkgKnJlcyA9IE5VTEw7CisJZW51bSBtYWNzZWNfcG9saWN5IHBvbGljeTsKKworCWllZWU4MDJfMXhfZGVhbGxvY19rYXlfc20od3BhX3MpOworCisJaWYgKCFzc2lkIHx8IHNzaWQtPm1hY3NlY19wb2xpY3kgPT0gMCkKKwkJcmV0dXJuIDA7CisKKwlwb2xpY3kgPSBzc2lkLT5tYWNzZWNfcG9saWN5ID09IDEgPyBTSE9VTERfU0VDVVJFIDogRE9fTk9UX1NFQ1VSRTsKKworCWtheV9jdHggPSBvc196YWxsb2Moc2l6ZW9mKCprYXlfY3R4KSk7CisJaWYgKCFrYXlfY3R4KQorCQlyZXR1cm4gLTE7CisKKwlrYXlfY3R4LT5jdHggPSB3cGFfczsKKworCWtheV9jdHgtPm1hY3NlY19pbml0ID0gd3Bhc19tYWNzZWNfaW5pdDsKKwlrYXlfY3R4LT5tYWNzZWNfZGVpbml0ID0gd3Bhc19tYWNzZWNfZGVpbml0OworCWtheV9jdHgtPmVuYWJsZV9wcm90ZWN0X2ZyYW1lcyA9IHdwYXNfZW5hYmxlX3Byb3RlY3RfZnJhbWVzOworCWtheV9jdHgtPnNldF9yZXBsYXlfcHJvdGVjdCA9IHdwYXNfc2V0X3JlcGxheV9wcm90ZWN0OworCWtheV9jdHgtPnNldF9jdXJyZW50X2NpcGhlcl9zdWl0ZSA9IHdwYXNfc2V0X2N1cnJlbnRfY2lwaGVyX3N1aXRlOworCWtheV9jdHgtPmVuYWJsZV9jb250cm9sbGVkX3BvcnQgPSB3cGFzX2VuYWJsZV9jb250cm9sbGVkX3BvcnQ7CisJa2F5X2N0eC0+Z2V0X3JlY2VpdmVfbG93ZXN0X3BuID0gd3Bhc19nZXRfcmVjZWl2ZV9sb3dlc3RfcG47CisJa2F5X2N0eC0+Z2V0X3RyYW5zbWl0X25leHRfcG4gPSB3cGFzX2dldF90cmFuc21pdF9uZXh0X3BuOworCWtheV9jdHgtPnNldF90cmFuc21pdF9uZXh0X3BuID0gd3Bhc19zZXRfdHJhbnNtaXRfbmV4dF9wbjsKKwlrYXlfY3R4LT5nZXRfYXZhaWxhYmxlX3JlY2VpdmVfc2MgPSB3cGFzX2dldF9hdmFpbGFibGVfcmVjZWl2ZV9zYzsKKwlrYXlfY3R4LT5jcmVhdGVfcmVjZWl2ZV9zYyA9IHdwYXNfY3JlYXRlX3JlY2VpdmVfc2M7CisJa2F5X2N0eC0+ZGVsZXRlX3JlY2VpdmVfc2MgPSB3cGFzX2RlbGV0ZV9yZWNlaXZlX3NjOworCWtheV9jdHgtPmNyZWF0ZV9yZWNlaXZlX3NhID0gd3Bhc19jcmVhdGVfcmVjZWl2ZV9zYTsKKwlrYXlfY3R4LT5lbmFibGVfcmVjZWl2ZV9zYSA9IHdwYXNfZW5hYmxlX3JlY2VpdmVfc2E7CisJa2F5X2N0eC0+ZGlzYWJsZV9yZWNlaXZlX3NhID0gd3Bhc19kaXNhYmxlX3JlY2VpdmVfc2E7CisJa2F5X2N0eC0+Z2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYyA9IHdwYXNfZ2V0X2F2YWlsYWJsZV90cmFuc21pdF9zYzsKKwlrYXlfY3R4LT5jcmVhdGVfdHJhbnNtaXRfc2MgPSB3cGFzX2NyZWF0ZV90cmFuc21pdF9zYzsKKwlrYXlfY3R4LT5kZWxldGVfdHJhbnNtaXRfc2MgPSB3cGFzX2RlbGV0ZV90cmFuc21pdF9zYzsKKwlrYXlfY3R4LT5jcmVhdGVfdHJhbnNtaXRfc2EgPSB3cGFzX2NyZWF0ZV90cmFuc21pdF9zYTsKKwlrYXlfY3R4LT5lbmFibGVfdHJhbnNtaXRfc2EgPSB3cGFzX2VuYWJsZV90cmFuc21pdF9zYTsKKwlrYXlfY3R4LT5kaXNhYmxlX3RyYW5zbWl0X3NhID0gd3Bhc19kaXNhYmxlX3RyYW5zbWl0X3NhOworCisJcmVzID0gaWVlZTgwMl8xeF9rYXlfaW5pdChrYXlfY3R4LCBwb2xpY3ksIHdwYV9zLT5pZm5hbWUsCisJCQkJICB3cGFfcy0+b3duX2FkZHIpOworCWlmIChyZXMgPT0gTlVMTCkgeworCQlvc19mcmVlKGtheV9jdHgpOworCQlyZXR1cm4gLTE7CisJfQorCisJd3BhX3MtPmtheSA9IHJlczsKKworCXJldHVybiAwOworfQorCisKK3ZvaWQgaWVlZTgwMl8xeF9kZWFsbG9jX2theV9zbShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWlmICghd3BhX3MtPmtheSkKKwkJcmV0dXJuOworCisJaWVlZTgwMl8xeF9rYXlfZGVpbml0KHdwYV9zLT5rYXkpOworCXdwYV9zLT5rYXkgPSBOVUxMOworfQorCisKK3N0YXRpYyBpbnQgaWVlZTgwMl8xeF9hdXRoX2dldF9zZXNzaW9uX2lkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgY29uc3QgdTggKmFkZHIsIHU4ICpzaWQsIHNpemVfdCAqbGVuKQoreworCWNvbnN0IHU4ICpzZXNzaW9uX2lkOworCXNpemVfdCBpZF9sZW4sIG5lZWRfbGVuOworCisJc2Vzc2lvbl9pZCA9IGVhcG9sX3NtX2dldF9zZXNzaW9uX2lkKHdwYV9zLT5lYXBvbCwgJmlkX2xlbik7CisJaWYgKHNlc3Npb25faWQgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJCSAgICJGYWlsZWQgdG8gZ2V0IFNlc3Npb25JRCBmcm9tIEVBUE9MIHN0YXRlIG1hY2hpbmVzIik7CisJCXJldHVybiAtMTsKKwl9CisKKwluZWVkX2xlbiA9IDEgKyAyICogU1NMM19SQU5ET01fU0laRTsKKwlpZiAobmVlZF9sZW4gPiBpZF9sZW4pIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAgU2Vzc2lvbi1JZCBub3QgbG9uZyBlbm91Z2giKTsKKwkJcmV0dXJuIC0xOworCX0KKworCW9zX21lbWNweShzaWQsIHNlc3Npb25faWQsIG5lZWRfbGVuKTsKKwkqbGVuID0gbmVlZF9sZW47CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgaW50IGllZWU4MDJfMXhfYXV0aF9nZXRfbXNrKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICphZGRyLAorCQkJCSAgIHU4ICptc2ssIHNpemVfdCAqbGVuKQoreworCXU4IGtleVtFQVBfTVNLX0xFTl07CisJc2l6ZV90IGtleWxlbjsKKwlzdHJ1Y3QgZWFwb2xfc20gKnNtOworCWludCByZXM7CisKKwlzbSA9IHdwYV9zLT5lYXBvbDsKKwlpZiAoc20gPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJa2V5bGVuID0gRUFQX01TS19MRU47CisJcmVzID0gZWFwb2xfc21fZ2V0X2tleShzbSwga2V5LCBrZXlsZW4pOworCWlmIChyZXMpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkgICAiRmFpbGVkIHRvIGdldCBNU0sgZnJvbSBFQVBPTCBzdGF0ZSBtYWNoaW5lcyIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGtleWxlbiA+ICpsZW4pCisJCWtleWxlbiA9ICpsZW47CisJb3NfbWVtY3B5KG1zaywga2V5LCBrZXlsZW4pOworCSpsZW4gPSBrZXlsZW47CisKKwlyZXR1cm4gMDsKK30KKworCit2b2lkICogaWVlZTgwMl8xeF9ub3RpZnlfY3JlYXRlX2FjdG9yKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICAgY29uc3QgdTggKnBlZXJfYWRkcikKK3sKKwl1OCAqc2lkOworCXNpemVfdCBzaWRfbGVuID0gMTI4OworCXN0cnVjdCBta2Ffa2V5X25hbWUgKmNrbjsKKwlzdHJ1Y3QgbWthX2tleSAqY2FrOworCXN0cnVjdCBta2Ffa2V5ICptc2s7CisJdm9pZCAqcmVzID0gTlVMTDsKKworCWlmICghd3BhX3MtPmtheSB8fCB3cGFfcy0+a2F5LT5wb2xpY3kgPT0gRE9fTk9UX1NFQ1VSRSkKKwkJcmV0dXJuIE5VTEw7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywKKwkJICAgIklFRUUgODAyLjFYOiBFeHRlcm5hbCBub3RpZmljYXRpb24gLSBDcmVhdGUgTUtBIGZvciAiCisJCSAgIE1BQ1NUUiwgTUFDMlNUUihwZWVyX2FkZHIpKTsKKworCW1zayA9IG9zX3phbGxvYyhzaXplb2YoKm1zaykpOworCXNpZCA9IG9zX3phbGxvYyhzaWRfbGVuKTsKKwlja24gPSBvc196YWxsb2Moc2l6ZW9mKCpja24pKTsKKwljYWsgPSBvc196YWxsb2Moc2l6ZW9mKCpjYWspKTsKKwlpZiAoIW1zayB8fCAhc2lkIHx8ICFja24gfHwgIWNhaykKKwkJZ290byBmYWlsOworCisJbXNrLT5sZW4gPSBERUZBVUxUX0tFWV9MRU47CisJaWYgKGllZWU4MDJfMXhfYXV0aF9nZXRfbXNrKHdwYV9zLCB3cGFfcy0+YnNzaWQsIG1zay0+a2V5LCAmbXNrLT5sZW4pKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiSUVFRSA4MDIuMVg6IENvdWxkIG5vdCBnZXQgTVNLIik7CisJCWdvdG8gZmFpbDsKKwl9CisKKwlpZiAoaWVlZTgwMl8xeF9hdXRoX2dldF9zZXNzaW9uX2lkKHdwYV9zLCB3cGFfcy0+YnNzaWQsIHNpZCwgJnNpZF9sZW4pKQorCXsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiSUVFRSA4MDIuMVg6IENvdWxkIG5vdCBnZXQgRUFQIFNlc3Npb24gSWQiKTsKKwkJZ290byBmYWlsOworCX0KKworCS8qIERlcml2ZSBDQUsgZnJvbSBNU0sgKi8KKwljYWstPmxlbiA9IERFRkFVTFRfS0VZX0xFTjsKKwlpZiAoaWVlZTgwMl8xeF9jYWtfMTI4Yml0c19hZXNfY21hYyhtc2stPmtleSwgd3BhX3MtPm93bl9hZGRyLAorCQkJCQkgICAgcGVlcl9hZGRyLCBjYWstPmtleSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiSUVFRSA4MDIuMVg6IERlcml2aW5nIENBSyBmYWlsZWQiKTsKKwkJZ290byBmYWlsOworCX0KKwl3cGFfaGV4ZHVtcF9rZXkoTVNHX0RFQlVHLCAiRGVyaXZlZCBDQUsiLCBjYWstPmtleSwgY2FrLT5sZW4pOworCisJLyogRGVyaXZlIENLTiBmcm9tIE1TSyAqLworCWNrbi0+bGVuID0gREVGQVVMVF9DS05fTEVOOworCWlmIChpZWVlODAyXzF4X2Nrbl8xMjhiaXRzX2Flc19jbWFjKG1zay0+a2V5LCB3cGFfcy0+b3duX2FkZHIsCisJCQkJCSAgICBwZWVyX2FkZHIsIHNpZCwgc2lkX2xlbiwKKwkJCQkJICAgIGNrbi0+bmFtZSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkgICAiSUVFRSA4MDIuMVg6IERlcml2aW5nIENLTiBmYWlsZWQiKTsKKwkJZ290byBmYWlsOworCX0KKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJEZXJpdmVkIENLTiIsIGNrbi0+bmFtZSwgY2tuLT5sZW4pOworCisJcmVzID0gaWVlZTgwMl8xeF9rYXlfY3JlYXRlX21rYSh3cGFfcy0+a2F5LCBja24sIGNhaywgMCwKKwkJCQkJRUFQX0VYQ0hBTkdFLCBGQUxTRSk7CisKK2ZhaWw6CisJaWYgKG1zaykgeworCQlvc19tZW1zZXQobXNrLCAwLCBzaXplb2YoKm1zaykpOworCQlvc19mcmVlKG1zayk7CisJfQorCW9zX2ZyZWUoc2lkKTsKKwlvc19mcmVlKGNrbik7CisJaWYgKGNhaykgeworCQlvc19tZW1zZXQoY2FrLCAwLCBzaXplb2YoKmNhaykpOworCQlvc19mcmVlKGNhayk7CisJfQorCisJcmV0dXJuIHJlczsKK30KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYXNfa2F5LmggYi93cGFfc3VwcGxpY2FudC93cGFzX2theS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI3MjM2ZDAKLS0tIC9kZXYvbnVsbAorKysgYi93cGFfc3VwcGxpY2FudC93cGFzX2theS5oCkBAIC0wLDAgKzEsNDEgQEAKKy8qCisgKiBJRUVFIDgwMi4xWC0yMDEwIEthWSBJbnRlcmZhY2UKKyAqIENvcHlyaWdodCAoYykgMjAxMy0yMDE0LCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIFdQQVNfS0FZX0gKKyNkZWZpbmUgV1BBU19LQVlfSAorCisjaWZkZWYgQ09ORklHX01BQ1NFQworCitpbnQgaWVlZTgwMl8xeF9hbGxvY19rYXlfc20oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQpOwordm9pZCAqIGllZWU4MDJfMXhfbm90aWZ5X2NyZWF0ZV9hY3RvcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgIGNvbnN0IHU4ICpwZWVyX2FkZHIpOwordm9pZCBpZWVlODAyXzF4X2RlYWxsb2Nfa2F5X3NtKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworCisjZWxzZSAvKiBDT05GSUdfTUFDU0VDICovCisKK3N0YXRpYyBpbmxpbmUgaW50IGllZWU4MDJfMXhfYWxsb2Nfa2F5X3NtKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgc3RydWN0IHdwYV9zc2lkICpzc2lkKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgKgoraWVlZTgwMl8xeF9ub3RpZnlfY3JlYXRlX2FjdG9yKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICAgICAgY29uc3QgdTggKnBlZXJfYWRkcikKK3sKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGllZWU4MDJfMXhfZGVhbGxvY19rYXlfc20oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKK30KKworI2VuZGlmIC8qIENPTkZJR19NQUNTRUMgKi8KKworI2VuZGlmIC8qIFdQQVNfS0FZX0ggKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYXNfbW9kdWxlX3Rlc3RzLmMgYi93cGFfc3VwcGxpY2FudC93cGFzX21vZHVsZV90ZXN0cy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmU0YzgzYjUKLS0tIC9kZXYvbnVsbAorKysgYi93cGFfc3VwcGxpY2FudC93cGFzX21vZHVsZV90ZXN0cy5jCkBAIC0wLDAgKzEsMTAyIEBACisvKgorICogd3BhX3N1cHBsaWNhbnQgbW9kdWxlIHRlc3RzCisgKiBDb3B5cmlnaHQgKGMpIDIwMTQsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKKyNpbmNsdWRlICJibGFja2xpc3QuaCIKKworCitzdGF0aWMgaW50IHdwYXNfYmxhY2tsaXN0X21vZHVsZV90ZXN0cyh2b2lkKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCB3cGFfczsKKwlpbnQgcmV0ID0gLTE7CisKKwlvc19tZW1zZXQoJndwYV9zLCAwLCBzaXplb2Yod3BhX3MpKTsKKworCXdwYV9ibGFja2xpc3RfY2xlYXIoJndwYV9zKTsKKworCWlmICh3cGFfYmxhY2tsaXN0X2dldChOVUxMLCBOVUxMKSAhPSBOVUxMIHx8CisJICAgIHdwYV9ibGFja2xpc3RfZ2V0KE5VTEwsICh1OCAqKSAiMTIzNDU2IikgIT0gTlVMTCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2dldCgmd3BhX3MsIE5VTEwpICE9IE5VTEwgfHwKKwkgICAgd3BhX2JsYWNrbGlzdF9nZXQoJndwYV9zLCAodTggKikgIjEyMzQ1NiIpICE9IE5VTEwpCisJCWdvdG8gZmFpbDsKKworCWlmICh3cGFfYmxhY2tsaXN0X2FkZChOVUxMLCBOVUxMKSA9PSAwIHx8CisJICAgIHdwYV9ibGFja2xpc3RfYWRkKE5VTEwsICh1OCAqKSAiMTIzNDU2IikgPT0gMCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2FkZCgmd3BhX3MsIE5VTEwpID09IDApCisJCWdvdG8gZmFpbDsKKworCWlmICh3cGFfYmxhY2tsaXN0X2RlbChOVUxMLCBOVUxMKSA9PSAwIHx8CisJICAgIHdwYV9ibGFja2xpc3RfZGVsKE5VTEwsICh1OCAqKSAiMTIzNDU2IikgPT0gMCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2RlbCgmd3BhX3MsIE5VTEwpID09IDAgfHwKKwkgICAgd3BhX2JsYWNrbGlzdF9kZWwoJndwYV9zLCAodTggKikgIjEyMzQ1NiIpID09IDApCisJCWdvdG8gZmFpbDsKKworCWlmICh3cGFfYmxhY2tsaXN0X2FkZCgmd3BhX3MsICh1OCAqKSAiMTExMTExIikgPCAwIHx8CisJICAgIHdwYV9ibGFja2xpc3RfYWRkKCZ3cGFfcywgKHU4ICopICIxMTExMTEiKSA8IDAgfHwKKwkgICAgd3BhX2JsYWNrbGlzdF9hZGQoJndwYV9zLCAodTggKikgIjIyMjIyMiIpIDwgMCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2FkZCgmd3BhX3MsICh1OCAqKSAiMzMzMzMzIikgPCAwIHx8CisJICAgIHdwYV9ibGFja2xpc3RfYWRkKCZ3cGFfcywgKHU4ICopICI0NDQ0NDQiKSA8IDAgfHwKKwkgICAgd3BhX2JsYWNrbGlzdF9kZWwoJndwYV9zLCAodTggKikgIjMzMzMzMyIpIDwgMCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2RlbCgmd3BhX3MsICh1OCAqKSAieHh4eHh4IikgPT0gMCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2dldCgmd3BhX3MsICh1OCAqKSAieHh4eHh4IikgIT0gTlVMTCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2dldCgmd3BhX3MsICh1OCAqKSAiMTExMTExIikgPT0gTlVMTCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2dldCgmd3BhX3MsICh1OCAqKSAiMjIyMjIyIikgPT0gTlVMTCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2dldCgmd3BhX3MsICh1OCAqKSAiNDQ0NDQ0IikgPT0gTlVMTCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2RlbCgmd3BhX3MsICh1OCAqKSAiMTExMTExIikgPCAwIHx8CisJICAgIHdwYV9ibGFja2xpc3RfZGVsKCZ3cGFfcywgKHU4ICopICIyMjIyMjIiKSA8IDAgfHwKKwkgICAgd3BhX2JsYWNrbGlzdF9kZWwoJndwYV9zLCAodTggKikgIjQ0NDQ0NCIpIDwgMCB8fAorCSAgICB3cGFfYmxhY2tsaXN0X2FkZCgmd3BhX3MsICh1OCAqKSAiMTExMTExIikgPCAwIHx8CisJICAgIHdwYV9ibGFja2xpc3RfYWRkKCZ3cGFfcywgKHU4ICopICIyMjIyMjIiKSA8IDAgfHwKKwkgICAgd3BhX2JsYWNrbGlzdF9hZGQoJndwYV9zLCAodTggKikgIjMzMzMzMyIpIDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0gMDsKK2ZhaWw6CisJd3BhX2JsYWNrbGlzdF9jbGVhcigmd3BhX3MpOworCisJaWYgKHJldCkKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJibGFja2xpc3QgbW9kdWxlIHRlc3QgZmFpbHVyZSIpOworCisJcmV0dXJuIHJldDsKK30KKworCitpbnQgd3Bhc19tb2R1bGVfdGVzdHModm9pZCkKK3sKKwlpbnQgcmV0ID0gMDsKKworCXdwYV9wcmludGYoTVNHX0lORk8sICJ3cGFfc3VwcGxpY2FudCBtb2R1bGUgdGVzdHMiKTsKKworCWlmICh3cGFzX2JsYWNrbGlzdF9tb2R1bGVfdGVzdHMoKSA8IDApCisJCXJldCA9IC0xOworCisjaWZkZWYgQ09ORklHX1dQUworCXsKKwkJaW50IHdwc19tb2R1bGVfdGVzdHModm9pZCk7CisJCWlmICh3cHNfbW9kdWxlX3Rlc3RzKCkgPCAwKQorCQkJcmV0ID0gLTE7CisJfQorI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KKworCXsKKwkJaW50IHV0aWxzX21vZHVsZV90ZXN0cyh2b2lkKTsKKwkJaWYgKHV0aWxzX21vZHVsZV90ZXN0cygpIDwgMCkKKwkJCXJldCA9IC0xOworCX0KKworCXsKKwkJaW50IGNvbW1vbl9tb2R1bGVfdGVzdHModm9pZCk7CisJCWlmIChjb21tb25fbW9kdWxlX3Rlc3RzKCkgPCAwKQorCQkJcmV0ID0gLTE7CisJfQorCisJcmV0dXJuIHJldDsKK30KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwc19zdXBwbGljYW50LmMgYi93cGFfc3VwcGxpY2FudC93cHNfc3VwcGxpY2FudC5jCmluZGV4IGY2YzJmY2IuLmZkMGQxNGEgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwc19zdXBwbGljYW50LmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BzX3N1cHBsaWNhbnQuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiB3cGFfc3VwcGxpY2FudCAvIFdQUyBpbnRlZ3JhdGlvbgotICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxNCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNTIsOCArNTIsMzAgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFzX3dwc19hc3NvY193aXRoX2NyZWQodm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKK3sKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gZWxvb3BfY3R4OworCWludCB1c2VfZmFzdF9hc3NvYyA9IHRpbWVvdXRfY3R4ICE9IE5VTEw7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogQ29udGludWluZyBhc3NvY2lhdGlvbiBhZnRlciBlYXBvbF9jYiIpOworCWlmICghdXNlX2Zhc3RfYXNzb2MgfHwKKwkgICAgd3BhX3N1cHBsaWNhbnRfZmFzdF9hc3NvY2lhdGUod3BhX3MpICE9IDEpCisJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKK30KKworCitzdGF0aWMgdm9pZCB3cGFzX3dwc19hc3NvY193aXRoX2NyZWRfY2FuY2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc193cHNfYXNzb2Nfd2l0aF9jcmVkLCB3cGFfcywgKHZvaWQgKikgMCk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc193cHNfYXNzb2Nfd2l0aF9jcmVkLCB3cGFfcywgKHZvaWQgKikgMSk7Cit9CisKKwogaW50IHdwYXNfd3BzX2VhcG9sX2NiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CisJaWYgKHdwYXNfcDJwX3dwc19lYXBvbF9jYih3cGFfcykgPiAwKQorCQlyZXR1cm4gMTsKKwogCWlmICghd3BhX3MtPndwc19zdWNjZXNzICYmCiAJICAgIHdwYV9zLT5jdXJyZW50X3NzaWQgJiYKIAkgICAgZWFwX2lzX3dwc19waW5fZW5yb2xsZWUoJndwYV9zLT5jdXJyZW50X3NzaWQtPmVhcCkpIHsKQEAgLTExOSw5ICsxNDEsMTggQEAKIAkJCXdwYWJ1Zl9mcmVlKHdwcyk7CiAJCX0KIAotCQlpZiAoIXVzZV9mYXN0X2Fzc29jIHx8Ci0JCSAgICB3cGFfc3VwcGxpY2FudF9mYXN0X2Fzc29jaWF0ZSh3cGFfcykgIT0gMSkKLQkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKKwkJLyoKKwkJICogQ29tcGxldGUgdGhlIG5leHQgc3RlcCBmcm9tIGFuIGVsb29wIHRpbWVvdXQgdG8gYWxsb3cgcGVuZGluZworCQkgKiBkcml2ZXIgZXZlbnRzIHJlbGF0ZWQgdG8gdGhlIGRpc2Nvbm5lY3Rpb24gdG8gYmUgcHJvY2Vzc2VkCisJCSAqIGZpcnN0LiBUaGlzIG1ha2VzIGl0IGxlc3MgbGlrZWx5IGZvciBkaXNjb25uZWN0aW9uIGV2ZW50IHRvCisJCSAqIGNhdXNlIHByb2JsZW1zIHdpdGggdGhlIGZvbGxvd2luZyBjb25uZWN0aW9uLgorCQkgKi8KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IENvbnRpbnVlIGFzc29jaWF0aW9uIGZyb20gdGltZW91dCIpOworCQl3cGFzX3dwc19hc3NvY193aXRoX2NyZWRfY2FuY2VsKHdwYV9zKTsKKwkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAxMDAwMCwKKwkJCQkgICAgICAgd3Bhc193cHNfYXNzb2Nfd2l0aF9jcmVkLCB3cGFfcywKKwkJCQkgICAgICAgdXNlX2Zhc3RfYXNzb2MgPyAodm9pZCAqKSAxIDoKKwkJCQkgICAgICAgKHZvaWQgKikgMCk7CiAJCXJldHVybiAxOwogCX0KIApAQCAtMjYwLDMxICsyOTEsNiBAQAogCQkgICAgc3NpZC0+Z3JvdXBfY2lwaGVyICE9IG5ld19zc2lkLT5ncm91cF9jaXBoZXIpCiAJCQljb250aW51ZTsKIAotCQlpZiAoc3NpZC0+cGFzc3BocmFzZSAmJiBuZXdfc3NpZC0+cGFzc3BocmFzZSkgewotCQkJaWYgKG9zX3N0cmxlbihzc2lkLT5wYXNzcGhyYXNlKSAhPQotCQkJICAgIG9zX3N0cmxlbihuZXdfc3NpZC0+cGFzc3BocmFzZSkpCi0JCQkJY29udGludWU7Ci0JCQlpZiAob3Nfc3RyY21wKHNzaWQtPnBhc3NwaHJhc2UsIG5ld19zc2lkLT5wYXNzcGhyYXNlKSAhPQotCQkJICAgIDApCi0JCQkJY29udGludWU7Ci0JCX0gZWxzZSBpZiAoc3NpZC0+cGFzc3BocmFzZSB8fCBuZXdfc3NpZC0+cGFzc3BocmFzZSkKLQkJCWNvbnRpbnVlOwotCi0JCWlmICgoc3NpZC0+cHNrX3NldCB8fCBuZXdfc3NpZC0+cHNrX3NldCkgJiYKLQkJICAgIG9zX21lbWNtcChzc2lkLT5wc2ssIG5ld19zc2lkLT5wc2ssIHNpemVvZihzc2lkLT5wc2spKSAhPSAwKQotCQkJY29udGludWU7Ci0KLQkJaWYgKHNzaWQtPmF1dGhfYWxnID09IFdQQV9BTEdfV0VQKSB7Ci0JCQlpZiAoc3NpZC0+d2VwX3R4X2tleWlkeCAhPSBuZXdfc3NpZC0+d2VwX3R4X2tleWlkeCkKLQkJCQljb250aW51ZTsKLQkJCWlmIChvc19tZW1jbXAoc3NpZC0+d2VwX2tleSwgbmV3X3NzaWQtPndlcF9rZXksCi0JCQkJICAgICAgc2l6ZW9mKHNzaWQtPndlcF9rZXkpKSkKLQkJCQljb250aW51ZTsKLQkJCWlmIChvc19tZW1jbXAoc3NpZC0+d2VwX2tleV9sZW4sIG5ld19zc2lkLT53ZXBfa2V5X2xlbiwKLQkJCQkgICAgICBzaXplb2Yoc3NpZC0+d2VwX2tleV9sZW4pKSkKLQkJCQljb250aW51ZTsKLQkJfQotCiAJCS8qIFJlbW92ZSB0aGUgZHVwbGljYXRlZCBvbGRlciBuZXR3b3JrIGVudHJ5LiAqLwogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlJlbW92ZSBkdXBsaWNhdGUgbmV0d29yayAlZCIsIHNzaWQtPmlkKTsKIAkJd3Bhc19ub3RpZnlfbmV0d29ya19yZW1vdmVkKHdwYV9zLCBzc2lkKTsKQEAgLTI5OCw3ICszMDQsNiBAQAogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkID0gd3BhX3MtPmN1cnJlbnRfc3NpZDsKLQl1OCBrZXlfaWR4ID0gMDsKIAl1MTYgYXV0aF90eXBlOwogI2lmZGVmIENPTkZJR19XUFNfUkVHX0RJU0FCTEVfT1BFTgogCWludCByZWdpc3RyYXIgPSAwOwpAQCAtMzQ0LDcgKzM0OSw2IEBACiAJfQogCiAJaWYgKGF1dGhfdHlwZSAhPSBXUFNfQVVUSF9PUEVOICYmCi0JICAgIGF1dGhfdHlwZSAhPSBXUFNfQVVUSF9TSEFSRUQgJiYKIAkgICAgYXV0aF90eXBlICE9IFdQU19BVVRIX1dQQVBTSyAmJgogCSAgICBhdXRoX3R5cGUgIT0gV1BTX0FVVEhfV1BBMlBTSykgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSWdub3JlZCBjcmVkZW50aWFscyBmb3IgIgpAQCAtMzkyLDYgKzM5NiwxNyBAQAogCQlzc2lkID0gd3BhX2NvbmZpZ19hZGRfbmV0d29yayh3cGFfcy0+Y29uZik7CiAJCWlmIChzc2lkID09IE5VTEwpCiAJCQlyZXR1cm4gLTE7CisJCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkKSB7CisJCQkvKgorCQkJICogU2hvdWxkIHRoZSBHTyBpc3N1ZSBtdWx0aXBsZSBjcmVkZW50aWFscyBmb3Igc29tZQorCQkJICogcmVhc29uLCBlYWNoIGNyZWRlbnRpYWwgc2hvdWxkIGJlIG1hcmtlZCBhcyBhCisJCQkgKiB0ZW1wb3JhcnkgUDJQIGdyb3VwIHNpbWlsYXJseSB0byB0aGUgb25lIHRoYXQgZ2V0cworCQkJICogbWFya2VkIGFzIHN1Y2ggYmFzZWQgb24gdGhlIHByZS1jb25maWd1cmVkIHZhbHVlcworCQkJICogdXNlZCBmb3IgdGhlIFdQUyBuZXR3b3JrIGJsb2NrLgorCQkJICovCisJCQlzc2lkLT5wMnBfZ3JvdXAgPSB3cGFfcy0+Y3VycmVudF9zc2lkLT5wMnBfZ3JvdXA7CisJCQlzc2lkLT50ZW1wb3JhcnkgPSB3cGFfcy0+Y3VycmVudF9zc2lkLT50ZW1wb3Jhcnk7CisJCX0KIAkJd3Bhc19ub3RpZnlfbmV0d29ya19hZGRlZCh3cGFfcywgc3NpZCk7CiAJfQogCkBAIC00MDcsMzggKzQyMiw2IEBACiAJc3dpdGNoIChjcmVkLT5lbmNyX3R5cGUpIHsKIAljYXNlIFdQU19FTkNSX05PTkU6CiAJCWJyZWFrOwotCWNhc2UgV1BTX0VOQ1JfV0VQOgotCQlpZiAoY3JlZC0+a2V5X2xlbiA8PSAwKQotCQkJYnJlYWs7Ci0JCWlmIChjcmVkLT5rZXlfbGVuICE9IDUgJiYgY3JlZC0+a2V5X2xlbiAhPSAxMyAmJgotCQkgICAgY3JlZC0+a2V5X2xlbiAhPSAxMCAmJiBjcmVkLT5rZXlfbGVuICE9IDI2KSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIldQUzogSW52YWxpZCBXRVAgS2V5IGxlbmd0aCAiCi0JCQkJICAgIiVsdSIsICh1bnNpZ25lZCBsb25nKSBjcmVkLT5rZXlfbGVuKTsKLQkJCXJldHVybiAtMTsKLQkJfQotCQlpZiAoY3JlZC0+a2V5X2lkeCA+IE5VTV9XRVBfS0VZUykgewotCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IEludmFsaWQgV0VQIEtleSBpbmRleCAlZCIsCi0JCQkJICAgY3JlZC0+a2V5X2lkeCk7Ci0JCQlyZXR1cm4gLTE7Ci0JCX0KLQkJaWYgKGNyZWQtPmtleV9pZHgpCi0JCQlrZXlfaWR4ID0gY3JlZC0+a2V5X2lkeCAtIDE7Ci0JCWlmIChjcmVkLT5rZXlfbGVuID09IDEwIHx8IGNyZWQtPmtleV9sZW4gPT0gMjYpIHsKLQkJCWlmIChoZXhzdHIyYmluKChjaGFyICopIGNyZWQtPmtleSwKLQkJCQkgICAgICAgc3NpZC0+d2VwX2tleVtrZXlfaWR4XSwKLQkJCQkgICAgICAgY3JlZC0+a2V5X2xlbiAvIDIpIDwgMCkgewotCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV1BTOiBJbnZhbGlkIFdFUCBLZXkgIgotCQkJCQkgICAiJWQiLCBrZXlfaWR4KTsKLQkJCQlyZXR1cm4gLTE7Ci0JCQl9Ci0JCQlzc2lkLT53ZXBfa2V5X2xlbltrZXlfaWR4XSA9IGNyZWQtPmtleV9sZW4gLyAyOwotCQl9IGVsc2UgewotCQkJb3NfbWVtY3B5KHNzaWQtPndlcF9rZXlba2V5X2lkeF0sIGNyZWQtPmtleSwKLQkJCQkgIGNyZWQtPmtleV9sZW4pOwotCQkJc3NpZC0+d2VwX2tleV9sZW5ba2V5X2lkeF0gPSBjcmVkLT5rZXlfbGVuOwotCQl9Ci0JCXNzaWQtPndlcF90eF9rZXlpZHggPSBrZXlfaWR4OwotCQlicmVhazsKIAljYXNlIFdQU19FTkNSX1RLSVA6CiAJCXNzaWQtPnBhaXJ3aXNlX2NpcGhlciA9IFdQQV9DSVBIRVJfVEtJUDsKIAkJYnJlYWs7CkBAIC00NjMsMTEgKzQ0Niw2IEBACiAJCX0KICNlbmRpZiAvKiBDT05GSUdfV1BTX1JFR19ESVNBQkxFX09QRU4gKi8KIAkJYnJlYWs7Ci0JY2FzZSBXUFNfQVVUSF9TSEFSRUQ6Ci0JCXNzaWQtPmF1dGhfYWxnID0gV1BBX0FVVEhfQUxHX1NIQVJFRDsKLQkJc3NpZC0+a2V5X21nbXQgPSBXUEFfS0VZX01HTVRfTk9ORTsKLQkJc3NpZC0+cHJvdG8gPSAwOwotCQlicmVhazsKIAljYXNlIFdQU19BVVRIX1dQQVBTSzoKIAkJc3NpZC0+YXV0aF9hbGcgPSBXUEFfQVVUSF9BTEdfT1BFTjsKIAkJc3NpZC0+a2V5X21nbXQgPSBXUEFfS0VZX01HTVRfUFNLOwpAQCAtNTA5LDkgKzQ4Nyw2IEBACiAKIAl3cGFzX3dwc19zZWN1cml0eV93b3JrYXJvdW5kKHdwYV9zLCBzc2lkLCBjcmVkKTsKIAotCWlmIChjcmVkLT5hcF9jaGFubmVsKQotCQl3cGFfcy0+d3BzX2FwX2NoYW5uZWwgPSBjcmVkLT5hcF9jaGFubmVsOwotCiAJd3Bhc193cHNfcmVtb3ZlX2R1cF9uZXR3b3JrKHdwYV9zLCBzc2lkKTsKIAogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX1dSSVRFCkBAIC01MzMsMTUgKzUwOCw2IEBACiB9CiAKIAotI2lmZGVmIENPTkZJR19QMlAKLXN0YXRpYyB2b2lkIHdwYXNfd3BzX3BiY19vdmVybGFwX2NiKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCi17Ci0Jc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKLQl3cGFzX3AycF9ub3RpZl9wYmNfb3ZlcmxhcCh3cGFfcyk7Ci19Ci0jZW5kaWYgLyogQ09ORklHX1AyUCAqLwotCi0KIHN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X3dwc19ldmVudF9tMmQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJIHN0cnVjdCB3cHNfZXZlbnRfbTJkICptMmQpCiB7CkBAIC01NjAsNyArNTI2LDcgQEAKIAkJICogTm90aWZ5IFAyUCBmcm9tIGVsb29wIHRpbWVvdXQgdG8gYXZvaWQgaXNzdWVzIHdpdGggdGhlCiAJCSAqIGludGVyZmFjZSBnZXR0aW5nIHJlbW92ZWQgd2hpbGUgcHJvY2Vzc2luZyBhIG1lc3NhZ2UuCiAJCSAqLwotCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDAsIHdwYXNfd3BzX3BiY19vdmVybGFwX2NiLCB3cGFfcywKKwkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgwLCAwLCB3cGFzX3AycF9wYmNfb3ZlcmxhcF9jYiwgd3BhX3MsCiAJCQkJICAgICAgIE5VTEwpOwogCX0KICNlbmRpZiAvKiBDT05GSUdfUDJQICovCkBAIC02MDgsOSArNTc0LDcgQEAKIAllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDEwMDAwMCwgd3Bhc193cHNfY2xlYXJfdGltZW91dCwgd3BhX3MsIE5VTEwpOwogCiAJd3Bhc19ub3RpZnlfd3BzX2V2ZW50X2ZhaWwod3BhX3MsIGZhaWwpOwotI2lmZGVmIENPTkZJR19QMlAKIAl3cGFzX3AycF93cHNfZmFpbGVkKHdwYV9zLCBmYWlsKTsKLSNlbmRpZiAvKiBDT05GSUdfUDJQICovCiB9CiAKIApAQCAtNjY5LDkgKzYzMyw3IEBACiAJZWxvb3BfcmVnaXN0ZXJfdGltZW91dCgxMCwgMCwgd3Bhc193cHNfcmVlbmFibGVfbmV0d29ya3NfY2IsIHdwYV9zLAogCQkJICAgICAgIE5VTEwpOwogCi0jaWZkZWYgQ09ORklHX1AyUAogCXdwYXNfcDJwX3dwc19zdWNjZXNzKHdwYV9zLCB3cGFfcy0+YnNzaWQsIDApOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIH0KIAogCkBAIC04ODIsMTIgKzg0NCwxNiBAQAogCWludCBpZDsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsICpyZW1vdmVfc3NpZCA9IE5VTEwsICpwcmV2X2N1cnJlbnQ7CiAKKwl3cGFfcy0+YWZ0ZXJfd3BzID0gMDsKKwl3cGFfcy0+a25vd25fd3BzX2ZyZXEgPSAwOworCiAJcHJldl9jdXJyZW50ID0gd3BhX3MtPmN1cnJlbnRfc3NpZDsKIAogCS8qIEVuYWJsZSB0aGUgbmV0d29ya3MgZGlzYWJsZWQgZHVyaW5nIHdwYXNfd3BzX3JlYXNzb2MgKi8KIAl3cGFzX3dwc19yZWVuYWJsZV9uZXR3b3Jrcyh3cGFfcyk7CiAKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3dwc190aW1lb3V0LCB3cGFfcywgTlVMTCk7CisJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc193cHNfY2xlYXJfdGltZW91dCwgd3BhX3MsIE5VTEwpOwogCiAJLyogUmVtb3ZlIGFueSBleGlzdGluZyBXUFMgbmV0d29yayBmcm9tIGNvbmZpZ3VyYXRpb24gKi8KIAlzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7CkBAIC05MjcsNyArODkzLDggQEAKIAogCiBzdGF0aWMgc3RydWN0IHdwYV9zc2lkICogd3Bhc193cHNfYWRkX25ldHdvcmsoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkJICAgICAgaW50IHJlZ2lzdHJhciwgY29uc3QgdTggKmJzc2lkKQorCQkJCQkgICAgICBpbnQgcmVnaXN0cmFyLCBjb25zdCB1OCAqZGV2X2FkZHIsCisJCQkJCSAgICAgIGNvbnN0IHU4ICpic3NpZCkKIHsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CiAKQEAgLTk0Nyw2ICs5MTQsMTEgQEAKIAkJcmV0dXJuIE5VTEw7CiAJfQogCisjaWZkZWYgQ09ORklHX1AyUAorCWlmIChkZXZfYWRkcikKKwkJb3NfbWVtY3B5KHNzaWQtPmdvX3AycF9kZXZfYWRkciwgZGV2X2FkZHIsIEVUSF9BTEVOKTsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKIAlpZiAoYnNzaWQpIHsKICNpZm5kZWYgQ09ORklHX1AyUAogCQlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOwpAQCAtMTAyNywxMyArOTk5LDE3IEBACiAKIAogc3RhdGljIHZvaWQgd3Bhc193cHNfcmVhc3NvYyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJICAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNlbGVjdGVkLCBjb25zdCB1OCAqYnNzaWQpCisJCQkgICAgIHN0cnVjdCB3cGFfc3NpZCAqc2VsZWN0ZWQsIGNvbnN0IHU4ICpic3NpZCwKKwkJCSAgICAgaW50IGZyZXEpCiB7CiAJc3RydWN0IHdwYV9ic3MgKmJzczsKIAogCXdwYV9zLT5hZnRlcl93cHMgPSAwOwogCXdwYV9zLT5rbm93bl93cHNfZnJlcSA9IDA7Ci0JaWYgKGJzc2lkKSB7CisJaWYgKGZyZXEpIHsKKwkJd3BhX3MtPmFmdGVyX3dwcyA9IDU7CisJCXdwYV9zLT53cHNfZnJlcSA9IGZyZXE7CisJfSBlbHNlIGlmIChic3NpZCkgewogCQlic3MgPSB3cGFfYnNzX2dldF9ic3NpZF9sYXRlc3Qod3BhX3MsIGJzc2lkKTsKIAkJaWYgKGJzcyAmJiBic3MtPmZyZXEgPiAwKSB7CiAJCQl3cGFfcy0+a25vd25fd3BzX2ZyZXEgPSAxOwpAQCAtMTA0OSw2ICsxMDI1LDggQEAKIAl3cGFfcy0+bm9ybWFsX3NjYW5zID0gMDsKIAl3cGFfcy0+d3BzX3N1Y2Nlc3MgPSAwOwogCXdwYV9zLT5ibGFja2xpc3RfY2xlYXJlZCA9IDA7CisKKwl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2NoZWRfc2Nhbih3cGFfcyk7CiAJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDAsIDApOwogfQogCkBAIC0xMDU4LDcgKzEwMzYsNyBAQAogewogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKIAl3cGFzX2NsZWFyX3dwcyh3cGFfcyk7Ci0Jc3NpZCA9IHdwYXNfd3BzX2FkZF9uZXR3b3JrKHdwYV9zLCAwLCBic3NpZCk7CisJc3NpZCA9IHdwYXNfd3BzX2FkZF9uZXR3b3JrKHdwYV9zLCAwLCBOVUxMLCBic3NpZCk7CiAJaWYgKHNzaWQgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCXNzaWQtPnRlbXBvcmFyeSA9IDE7CkBAIC0xMDgxLDI0ICsxMDU5LDQ3IEBACiAJCXNzaWQtPmVhcC5mcmFnbWVudF9zaXplID0gd3BhX3MtPndwc19mcmFnbWVudF9zaXplOwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoV1BTX1BCQ19XQUxLX1RJTUUsIDAsIHdwYXNfd3BzX3RpbWVvdXQsCiAJCQkgICAgICAgd3BhX3MsIE5VTEwpOwotCXdwYXNfd3BzX3JlYXNzb2Mod3BhX3MsIHNzaWQsIGJzc2lkKTsKKwl3cGFzX3dwc19yZWFzc29jKHdwYV9zLCBzc2lkLCBic3NpZCwgMCk7CiAJcmV0dXJuIDA7CiB9CiAKIAotaW50IHdwYXNfd3BzX3N0YXJ0X3BpbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQsCi0JCSAgICAgICBjb25zdCBjaGFyICpwaW4sIGludCBwMnBfZ3JvdXAsIHUxNiBkZXZfcHdfaWQpCitzdGF0aWMgaW50IHdwYXNfd3BzX3N0YXJ0X2Rldl9wdyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSBjb25zdCB1OCAqZGV2X2FkZHIsIGNvbnN0IHU4ICpic3NpZCwKKwkJCQkgY29uc3QgY2hhciAqcGluLCBpbnQgcDJwX2dyb3VwLCB1MTYgZGV2X3B3X2lkLAorCQkJCSBjb25zdCB1OCAqcGVlcl9wdWJrZXlfaGFzaCwKKwkJCQkgY29uc3QgdTggKnNzaWRfdmFsLCBzaXplX3Qgc3NpZF9sZW4sIGludCBmcmVxKQogewogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKLQljaGFyIHZhbFsxMjhdOworCWNoYXIgdmFsWzEyOCArIDIgKiBXUFNfT09CX1BVQktFWV9IQVNIX0xFTl07CiAJdW5zaWduZWQgaW50IHJwaW4gPSAwOworCWNoYXIgaGFzaFsyICogV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gKyAxMF07CiAKIAl3cGFzX2NsZWFyX3dwcyh3cGFfcyk7Ci0Jc3NpZCA9IHdwYXNfd3BzX2FkZF9uZXR3b3JrKHdwYV9zLCAwLCBic3NpZCk7Ci0JaWYgKHNzaWQgPT0gTlVMTCkKKwlpZiAoYnNzaWQgJiYgaXNfemVyb19ldGhlcl9hZGRyKGJzc2lkKSkKKwkJYnNzaWQgPSBOVUxMOworCXNzaWQgPSB3cGFzX3dwc19hZGRfbmV0d29yayh3cGFfcywgMCwgZGV2X2FkZHIsIGJzc2lkKTsKKwlpZiAoc3NpZCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBDb3VsZCBub3QgYWRkIG5ldHdvcmsiKTsKIAkJcmV0dXJuIC0xOworCX0KIAlzc2lkLT50ZW1wb3JhcnkgPSAxOwogCXNzaWQtPnAycF9ncm91cCA9IHAycF9ncm91cDsKKwlpZiAoc3NpZF92YWwpIHsKKwkJc3NpZC0+c3NpZCA9IG9zX21hbGxvYyhzc2lkX2xlbik7CisJCWlmIChzc2lkLT5zc2lkKSB7CisJCQlvc19tZW1jcHkoc3NpZC0+c3NpZCwgc3NpZF92YWwsIHNzaWRfbGVuKTsKKwkJCXNzaWQtPnNzaWRfbGVuID0gc3NpZF9sZW47CisJCX0KKwl9CisJaWYgKHBlZXJfcHVia2V5X2hhc2gpIHsKKwkJb3NfbWVtY3B5KGhhc2gsICIgcGtoYXNoPSIsIDgpOworCQl3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShoYXNoICsgOCwgc2l6ZW9mKGhhc2gpIC0gOCwKKwkJCQkJICAgcGVlcl9wdWJrZXlfaGFzaCwKKwkJCQkJICAgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCX0gZWxzZSB7CisJCWhhc2hbMF0gPSAnXDAnOworCX0KICNpZmRlZiBDT05GSUdfUDJQCiAJaWYgKHAycF9ncm91cCAmJiB3cGFfcy0+Z29fcGFyYW1zICYmIHdwYV9zLT5nb19wYXJhbXMtPnNzaWRfbGVuKSB7CiAJCXNzaWQtPnNzaWQgPSBvc196YWxsb2Mod3BhX3MtPmdvX3BhcmFtcy0+c3NpZF9sZW4gKyAxKTsKQEAgLTExMTIsMjUgKzExMTMsMzggQEAKIAl9CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCWlmIChwaW4pCi0JCW9zX3NucHJpbnRmKHZhbCwgc2l6ZW9mKHZhbCksICJcInBpbj0lcyBkZXZfcHdfaWQ9JXVcIiIsCi0JCQkgICAgcGluLCBkZXZfcHdfaWQpOwotCWVsc2UgeworCQlvc19zbnByaW50Zih2YWwsIHNpemVvZih2YWwpLCAiXCJwaW49JXMgZGV2X3B3X2lkPSV1JXNcIiIsCisJCQkgICAgcGluLCBkZXZfcHdfaWQsIGhhc2gpOworCWVsc2UgaWYgKHBpbiA9PSBOVUxMICYmIGRldl9wd19pZCA9PSBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIpIHsKKwkJb3Nfc25wcmludGYodmFsLCBzaXplb2YodmFsKSwgIlwiZGV2X3B3X2lkPSV1JXNcIiIsCisJCQkgICAgZGV2X3B3X2lkLCBoYXNoKTsKKwl9IGVsc2UgewogCQlycGluID0gd3BzX2dlbmVyYXRlX3BpbigpOwotCQlvc19zbnByaW50Zih2YWwsIHNpemVvZih2YWwpLCAiXCJwaW49JTA4ZCBkZXZfcHdfaWQ9JXVcIiIsCi0JCQkgICAgcnBpbiwgZGV2X3B3X2lkKTsKKwkJb3Nfc25wcmludGYodmFsLCBzaXplb2YodmFsKSwgIlwicGluPSUwOGQgZGV2X3B3X2lkPSV1JXNcIiIsCisJCQkgICAgcnBpbiwgZGV2X3B3X2lkLCBoYXNoKTsKIAl9Ci0JaWYgKHdwYV9jb25maWdfc2V0KHNzaWQsICJwaGFzZTEiLCB2YWwsIDApIDwgMCkKKwlpZiAod3BhX2NvbmZpZ19zZXQoc3NpZCwgInBoYXNlMSIsIHZhbCwgMCkgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBGYWlsZWQgdG8gc2V0IHBoYXNlMSAnJXMnIiwgdmFsKTsKIAkJcmV0dXJuIC0xOworCX0KIAlpZiAod3BhX3MtPndwc19mcmFnbWVudF9zaXplKQogCQlzc2lkLT5lYXAuZnJhZ21lbnRfc2l6ZSA9IHdwYV9zLT53cHNfZnJhZ21lbnRfc2l6ZTsKIAllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KFdQU19QQkNfV0FMS19USU1FLCAwLCB3cGFzX3dwc190aW1lb3V0LAogCQkJICAgICAgIHdwYV9zLCBOVUxMKTsKIAl3cGFfcy0+d3BzX2FwX2l0ZXIgPSAxOwotCXdwYXNfd3BzX3JlYXNzb2Mod3BhX3MsIHNzaWQsIGJzc2lkKTsKKwl3cGFzX3dwc19yZWFzc29jKHdwYV9zLCBzc2lkLCBic3NpZCwgZnJlcSk7CiAJcmV0dXJuIHJwaW47CiB9CiAKIAoraW50IHdwYXNfd3BzX3N0YXJ0X3BpbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQsCisJCSAgICAgICBjb25zdCBjaGFyICpwaW4sIGludCBwMnBfZ3JvdXAsIHUxNiBkZXZfcHdfaWQpCit7CisJcmV0dXJuIHdwYXNfd3BzX3N0YXJ0X2Rldl9wdyh3cGFfcywgTlVMTCwgYnNzaWQsIHBpbiwgcDJwX2dyb3VwLAorCQkJCSAgICAgZGV2X3B3X2lkLCBOVUxMLCBOVUxMLCAwLCAwKTsKK30KKworCiAvKiBDYW5jZWwgdGhlIHdwcyBwYmMvcGluIHJlcXVlc3RzICovCiBpbnQgd3Bhc193cHNfY2FuY2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CkBAIC0xMTU1LDggKzExNjksMTMgQEAKIAl9IGVsc2UgewogCQl3cGFzX3dwc19yZWVuYWJsZV9uZXR3b3Jrcyh3cGFfcyk7CiAJCXdwYXNfd3BzX2NsZWFyX2FwX2luZm8od3BhX3MpOworCQlpZiAoZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc193cHNfY2xlYXJfdGltZW91dCwgd3BhX3MsIE5VTEwpID4KKwkJICAgIDApCisJCQl3cGFzX2NsZWFyX3dwcyh3cGFfcyk7CiAJfQogCisJd3BhX3MtPmFmdGVyX3dwcyA9IDA7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTE3Miw3ICsxMTkxLDcgQEAKIAlpZiAoIXBpbikKIAkJcmV0dXJuIC0xOwogCXdwYXNfY2xlYXJfd3BzKHdwYV9zKTsKLQlzc2lkID0gd3Bhc193cHNfYWRkX25ldHdvcmsod3BhX3MsIDEsIGJzc2lkKTsKKwlzc2lkID0gd3Bhc193cHNfYWRkX25ldHdvcmsod3BhX3MsIDEsIE5VTEwsIGJzc2lkKTsKIAlpZiAoc3NpZCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CiAJc3NpZC0+dGVtcG9yYXJ5ID0gMTsKQEAgLTEyMDAsNyArMTIxOSw3IEBACiAJCXNzaWQtPmVhcC5mcmFnbWVudF9zaXplID0gd3BhX3MtPndwc19mcmFnbWVudF9zaXplOwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoV1BTX1BCQ19XQUxLX1RJTUUsIDAsIHdwYXNfd3BzX3RpbWVvdXQsCiAJCQkgICAgICAgd3BhX3MsIE5VTEwpOwotCXdwYXNfd3BzX3JlYXNzb2Mod3BhX3MsIHNzaWQsIGJzc2lkKTsKKwl3cGFzX3dwc19yZWFzc29jKHdwYV9zLCBzc2lkLCBic3NpZCwgMCk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTEyNjcsNyArMTI4Niw2IEBACiAKIHN0YXRpYyB1MTYgd3BzX2ZpeF9jb25maWdfbWV0aG9kcyh1MTYgY29uZmlnX21ldGhvZHMpCiB7Ci0jaWZkZWYgQ09ORklHX1dQUzIKIAlpZiAoKGNvbmZpZ19tZXRob2RzICYKIAkgICAgIChXUFNfQ09ORklHX0RJU1BMQVkgfCBXUFNfQ09ORklHX1ZJUlRfRElTUExBWSB8CiAJICAgICAgV1BTX0NPTkZJR19QSFlfRElTUExBWSkpID09IFdQU19DT05GSUdfRElTUExBWSkgewpAQCAtMTI4Miw3ICsxMzAwLDYgQEAKIAkJCSAgICJ2aXJ0dWFsX3B1c2hfYnV0dG9uIGZvciBXUFMgMi4wIGNvbXBsaWFuY2UiKTsKIAkJY29uZmlnX21ldGhvZHMgfD0gV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT047CiAJfQotI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAKIAlyZXR1cm4gY29uZmlnX21ldGhvZHM7CiB9CkBAIC0xMjkxLDcgKzEzMDgsOSBAQAogc3RhdGljIHZvaWQgd3Bhc193cHNfc2V0X3V1aWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgICAgIHN0cnVjdCB3cHNfY29udGV4dCAqd3BzKQogewotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBTZXQgVVVJRCBmb3IgaW50ZXJmYWNlICVzIiwgd3BhX3MtPmlmbmFtZSk7CisJY2hhciBidWZbNTBdOworCWNvbnN0IGNoYXIgKnNyYzsKKwogCWlmIChpc19uaWxfdXVpZCh3cGFfcy0+Y29uZi0+dXVpZCkpIHsKIAkJc3RydWN0IHdwYV9zdXBwbGljYW50ICpmaXJzdDsKIAkJZmlyc3QgPSB3cGFfcy0+Z2xvYmFsLT5pZmFjZXM7CkBAIC0xMzAyLDE4ICsxMzIxLDE4IEBACiAJCQkJb3NfbWVtY3B5KHdwcy0+dXVpZCwKIAkJCQkJICB3cGFfcy0+Z2xvYmFsLT5pZmFjZXMtPndwcy0+dXVpZCwKIAkJCQkJICBXUFNfVVVJRF9MRU4pOwotCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBVVUlEIGZyb20gdGhlIGZpcnN0ICIKLQkJCQkgICAgImludGVyZmFjZSIsIHdwcy0+dXVpZCwgV1BTX1VVSURfTEVOKTsKKwkJCXNyYyA9ICJmcm9tIHRoZSBmaXJzdCBpbnRlcmZhY2UiOwogCQl9IGVsc2UgewogCQkJdXVpZF9nZW5fbWFjX2FkZHIod3BhX3MtPm93bl9hZGRyLCB3cHMtPnV1aWQpOwotCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBVVUlEIGJhc2VkIG9uIE1BQyAiCi0JCQkJICAgICJhZGRyZXNzIiwgd3BzLT51dWlkLCBXUFNfVVVJRF9MRU4pOworCQkJc3JjID0gImJhc2VkIG9uIE1BQyBhZGRyZXNzIjsKIAkJfQogCX0gZWxzZSB7CiAJCW9zX21lbWNweSh3cHMtPnV1aWQsIHdwYV9zLT5jb25mLT51dWlkLCBXUFNfVVVJRF9MRU4pOwotCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUFM6IFVVSUQgYmFzZWQgb24gY29uZmlndXJhdGlvbiIsCi0JCQkgICAgd3BzLT51dWlkLCBXUFNfVVVJRF9MRU4pOworCQlzcmMgPSAiYmFzZWQgb24gY29uZmlndXJhdGlvbiI7CiAJfQorCisJdXVpZF9iaW4yc3RyKHdwcy0+dXVpZCwgYnVmLCBzaXplb2YoYnVmKSk7CisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiV1BTOiBVVUlEICVzOiAlcyIsIHNyYywgYnVmKTsKIH0KIAogCkBAIC0xNDE4LDE5ICsxNDM3LDM5IEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19XUFNfRVIKK3N0YXRpYyB2b2lkIHdwYXNfd3BzX25mY19jbGVhcihzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcykKK3sKKwl3cHMtPmFwX25mY19kZXZfcHdfaWQgPSAwOworCXdwYWJ1Zl9mcmVlKHdwcy0+YXBfbmZjX2RoX3B1YmtleSk7CisJd3BzLT5hcF9uZmNfZGhfcHVia2V5ID0gTlVMTDsKKwl3cGFidWZfZnJlZSh3cHMtPmFwX25mY19kaF9wcml2a2V5KTsKKwl3cHMtPmFwX25mY19kaF9wcml2a2V5ID0gTlVMTDsKKwl3cGFidWZfZnJlZSh3cHMtPmFwX25mY19kZXZfcHcpOworCXdwcy0+YXBfbmZjX2Rldl9wdyA9IE5VTEw7Cit9CisjZW5kaWYgLyogQ09ORklHX1dQU19FUiAqLworCisKIHZvaWQgd3Bhc193cHNfZGVpbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CisJd3Bhc193cHNfYXNzb2Nfd2l0aF9jcmVkX2NhbmNlbCh3cGFfcyk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc193cHNfdGltZW91dCwgd3BhX3MsIE5VTEwpOwogCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfd3BzX2NsZWFyX3RpbWVvdXQsIHdwYV9zLCBOVUxMKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3dwc19yZWVuYWJsZV9uZXR3b3Jrc19jYiwgd3BhX3MsIE5VTEwpOwogCXdwYXNfd3BzX2NsZWFyX2FwX2luZm8od3BhX3MpOwogCisjaWZkZWYgQ09ORklHX1AyUAorCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX3BiY19vdmVybGFwX2NiLCB3cGFfcywgTlVMTCk7CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCiAJaWYgKHdwYV9zLT53cHMgPT0gTlVMTCkKIAkJcmV0dXJuOwogCiAjaWZkZWYgQ09ORklHX1dQU19FUgogCXdwc19lcl9kZWluaXQod3BhX3MtPndwc19lciwgTlVMTCwgTlVMTCk7CiAJd3BhX3MtPndwc19lciA9IE5VTEw7CisJd3Bhc193cHNfbmZjX2NsZWFyKHdwYV9zLT53cHMpOwogI2VuZGlmIC8qIENPTkZJR19XUFNfRVIgKi8KIAogCXdwc19yZWdpc3RyYXJfZGVpbml0KHdwYV9zLT53cHMtPnJlZ2lzdHJhcik7CkBAIC0xODgwLDggKzE5MTksMTAgQEAKIAogCWlmIChvc19zdHJjbXAoc2V0dGluZ3MtPmVuY3IsICJOT05FIikgPT0gMCkKIAkJY3JlZC5lbmNyX3R5cGUgPSBXUFNfRU5DUl9OT05FOworI2lmZGVmIENPTkZJR19URVNUSU5HX09QVElPTlMKIAllbHNlIGlmIChvc19zdHJjbXAoc2V0dGluZ3MtPmVuY3IsICJXRVAiKSA9PSAwKQogCQljcmVkLmVuY3JfdHlwZSA9IFdQU19FTkNSX1dFUDsKKyNlbmRpZiAvKiBDT05GSUdfVEVTVElOR19PUFRJT05TICovCiAJZWxzZSBpZiAob3Nfc3RyY21wKHNldHRpbmdzLT5lbmNyLCAiVEtJUCIpID09IDApCiAJCWNyZWQuZW5jcl90eXBlID0gV1BTX0VOQ1JfVEtJUDsKIAllbHNlIGlmIChvc19zdHJjbXAoc2V0dGluZ3MtPmVuY3IsICJDQ01QIikgPT0gMCkKQEAgLTE5NTIsMTkgKzE5OTMsNiBAQAogfQogCiAKLWludCB3cGFzX3dwc19pbl9wcm9ncmVzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQotewotCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKLQotCWZvciAoc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOyBzc2lkOyBzc2lkID0gc3NpZC0+bmV4dCkgewotCQlpZiAoIXNzaWQtPmRpc2FibGVkICYmIHNzaWQtPmtleV9tZ210ID09IFdQQV9LRVlfTUdNVF9XUFMpCi0JCQlyZXR1cm4gMTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotCiB2b2lkIHdwYXNfd3BzX3VwZGF0ZV9jb25maWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKIAlzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcyA9IHdwYV9zLT53cHM7CkBAIC0yMDkwLDE1ICsyMTE4LDMyIEBACiB9CiAKIAotaW50IHdwYXNfd3BzX3N0YXJ0X25mYyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQpCitpbnQgd3Bhc193cHNfc3RhcnRfbmZjKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpnb19kZXZfYWRkciwKKwkJICAgICAgIGNvbnN0IHU4ICpic3NpZCwKKwkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRldl9wdywgdTE2IGRldl9wd19pZCwKKwkJICAgICAgIGludCBwMnBfZ3JvdXAsIGNvbnN0IHU4ICpwZWVyX3B1YmtleV9oYXNoLAorCQkgICAgICAgY29uc3QgdTggKnNzaWQsIHNpemVfdCBzc2lkX2xlbiwgaW50IGZyZXEpCiB7CiAJc3RydWN0IHdwc19jb250ZXh0ICp3cHMgPSB3cGFfcy0+d3BzOwogCWNoYXIgcHdbMzIgKiAyICsgMV07CiAKKwlpZiAoZGV2X3B3X2lkICE9IERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUiAmJiBkZXZfcHcgPT0gTlVMTCkgeworCQlkZXZfcHcgPSB3cGFfcy0+Y29uZi0+d3BzX25mY19kZXZfcHc7CisJCWRldl9wd19pZCA9IHdwYV9zLT5jb25mLT53cHNfbmZjX2Rldl9wd19pZDsKKwl9CisKIAlpZiAod3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5ID09IE5VTEwgfHwKLQkgICAgd3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHJpdmtleSA9PSBOVUxMIHx8Ci0JICAgIHdwYV9zLT5jb25mLT53cHNfbmZjX2Rldl9wdyA9PSBOVUxMKQorCSAgICB3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5ID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IE1pc3NpbmcgREggcGFyYW1zIC0gIgorCQkJICAgImNhbm5vdCBzdGFydCBORkMtdHJpZ2dlcmVkIGNvbm5lY3Rpb24iKTsKIAkJcmV0dXJuIC0xOworCX0KKworCWlmIChkZXZfcHdfaWQgIT0gREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSICYmIGRldl9wdyA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBNaXNzaW5nIERldmljZSBQYXNzd29yZCAoaWQ9JXUpIC0gIgorCQkJICAgImNhbm5vdCBzdGFydCBORkMtdHJpZ2dlcmVkIGNvbm5lY3Rpb24iLCBkZXZfcHdfaWQpOworCQlyZXR1cm4gLTE7CisJfQogCiAJZGg1X2ZyZWUod3BzLT5kaF9jdHgpOwogCXdwYWJ1Zl9mcmVlKHdwcy0+ZGhfcHVia2V5KTsKQEAgLTIxMTEsNiArMjE1Niw3IEBACiAJCXdwcy0+ZGhfcHVia2V5ID0gTlVMTDsKIAkJd3BhYnVmX2ZyZWUod3BzLT5kaF9wcml2a2V5KTsKIAkJd3BzLT5kaF9wcml2a2V5ID0gTlVMTDsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEZhaWxlZCB0byBnZXQgREggcHJpdi9wdWIga2V5Iik7CiAJCXJldHVybiAtMTsKIAl9CiAJd3BzLT5kaF9jdHggPSBkaDVfaW5pdF9maXhlZCh3cHMtPmRoX3ByaXZrZXksIHdwcy0+ZGhfcHVia2V5KTsKQEAgLTIxMTksMjIgKzIxNjUsMjUgQEAKIAkJd3BzLT5kaF9wdWJrZXkgPSBOVUxMOwogCQl3cGFidWZfZnJlZSh3cHMtPmRoX3ByaXZrZXkpOwogCQl3cHMtPmRoX3ByaXZrZXkgPSBOVUxMOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogRmFpbGVkIHRvIGluaXRpYWxpemUgREggY29udGV4dCIpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0Jd3BhX3NucHJpbnRmX2hleF91cHBlcmNhc2UocHcsIHNpemVvZihwdyksCi0JCQkJICAgd3BhYnVmX2hlYWQod3BhX3MtPmNvbmYtPndwc19uZmNfZGV2X3B3KSwKLQkJCQkgICB3cGFidWZfbGVuKHdwYV9zLT5jb25mLT53cHNfbmZjX2Rldl9wdykpOwotCXJldHVybiB3cGFzX3dwc19zdGFydF9waW4od3BhX3MsIGJzc2lkLCBwdywgMCwKLQkJCQkgIHdwYV9zLT5jb25mLT53cHNfbmZjX2Rldl9wd19pZCk7CisJaWYgKGRldl9wdykgeworCQl3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShwdywgc2l6ZW9mKHB3KSwKKwkJCQkJICAgd3BhYnVmX2hlYWQoZGV2X3B3KSwKKwkJCQkJICAgd3BhYnVmX2xlbihkZXZfcHcpKTsKKwl9CisJcmV0dXJuIHdwYXNfd3BzX3N0YXJ0X2Rldl9wdyh3cGFfcywgZ29fZGV2X2FkZHIsIGJzc2lkLAorCQkJCSAgICAgZGV2X3B3ID8gcHcgOiBOVUxMLAorCQkJCSAgICAgcDJwX2dyb3VwLCBkZXZfcHdfaWQsIHBlZXJfcHVia2V5X2hhc2gsCisJCQkJICAgICBzc2lkLCBzc2lkX2xlbiwgZnJlcSk7CiB9CiAKIAogc3RhdGljIGludCB3cGFzX3dwc191c2VfY3JlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJICAgICBzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgKmF0dHIpCiB7Ci0Jd3BhX3MtPndwc19hcF9jaGFubmVsID0gMDsKLQogCS8qCiAJICogRGlzYWJsZSBleGlzdGluZyBuZXR3b3JrcyB0ZW1wb3JhcmlseSB0byBhbGxvdyB0aGUgbmV3bHkgbGVhcm5lZAogCSAqIGNyZWRlbnRpYWwgdG8gYmUgcHJlZmVycmVkLiBFbmFibGUgdGhlIHRlbXBvcmFyaWx5IGRpc2FibGVkIG5ldHdvcmtzCkBAIC0yMTUwLDEyICsyMTk5LDggQEAKIAlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfSU5URVJGQUNFX0RJU0FCTEVEKQogCQlyZXR1cm4gMDsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBSZXF1ZXN0IHJlY29ubmVjdGlvbiB3aXRoIG5ldyBuZXR3b3JrICIKLQkJICAgImJhc2VkIG9uIHRoZSByZWNlaXZlZCBjcmVkZW50aWFsIGFkZGVkIik7Ci0Jd3BhX3MtPm5vcm1hbF9zY2FucyA9IDA7Ci0Jd3BhX3N1cHBsaWNhbnRfcmVpbml0X2F1dG9zY2FuKHdwYV9zKTsKLQlpZiAod3BhX3MtPndwc19hcF9jaGFubmVsKSB7Ci0JCXUxNiBjaGFuID0gd3BhX3MtPndwc19hcF9jaGFubmVsOworCWlmIChhdHRyLT5hcF9jaGFubmVsKSB7CisJCXUxNiBjaGFuID0gV1BBX0dFVF9CRTE2KGF0dHItPmFwX2NoYW5uZWwpOwogCQlpbnQgZnJlcSA9IDA7CiAKIAkJaWYgKGNoYW4gPj0gMSAmJiBjaGFuIDw9IDEzKQpAQCAtMjE2NiwxNCArMjIxMSwyMSBAQAogCQkJZnJlcSA9IDUwMDAgKyA1ICogY2hhbjsKIAogCQlpZiAoZnJlcSkgewotCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IENyZWRlbnRpYWwgaW5kaWNhdGVkICIKLQkJCQkgICAiQVAgY2hhbm5lbCAldSAtPiAldSBNSHoiLCBjaGFuLCBmcmVxKTsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBDcmVkZW50aWFsIGNvbnRhaW5lciBpbmRpY2F0ZWQgQVAgY2hhbm5lbCAldSAtPiAldSBNSHoiLAorCQkJCSAgIGNoYW4sIGZyZXEpOwogCQkJd3BhX3MtPmFmdGVyX3dwcyA9IDU7CiAJCQl3cGFfcy0+d3BzX2ZyZXEgPSBmcmVxOwogCQl9CiAJfQorCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFJlcXVlc3QgcmVjb25uZWN0aW9uIHdpdGggbmV3IG5ldHdvcmsgIgorCQkgICAiYmFzZWQgb24gdGhlIHJlY2VpdmVkIGNyZWRlbnRpYWwgYWRkZWQiKTsKKwl3cGFfcy0+bm9ybWFsX3NjYW5zID0gMDsKKwl3cGFfc3VwcGxpY2FudF9yZWluaXRfYXV0b3NjYW4od3BhX3MpOwogCXdwYV9zLT5kaXNjb25uZWN0ZWQgPSAwOwogCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7CisKKwl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2NoZWRfc2Nhbih3cGFfcyk7CiAJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDAsIDApOwogCiAJcmV0dXJuIDA7CkBAIC0yMjE3LDcgKzIyNjksNyBAQAogCiAKIGludCB3cGFzX3dwc19uZmNfdGFnX3JlYWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCSAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqZGF0YSkKKwkJCSAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqZGF0YSwgaW50IGZvcmNlZF9mcmVxKQogewogCWNvbnN0IHN0cnVjdCB3cGFidWYgKndwcyA9IGRhdGE7CiAJc3RydWN0IHdwYWJ1ZiAqdG1wID0gTlVMTDsKQEAgLTIyMzAsNiArMjI4MiwxNSBAQAogCQkvKiBBc3N1bWUgdGhpcyBjb250YWlucyBmdWxsIE5ERUYgcmVjb3JkICovCiAJCXRtcCA9IG5kZWZfcGFyc2Vfd2lmaShkYXRhKTsKIAkJaWYgKHRtcCA9PSBOVUxMKSB7CisjaWZkZWYgQ09ORklHX1AyUAorCQkJdG1wID0gbmRlZl9wYXJzZV9wMnAoZGF0YSk7CisJCQlpZiAodG1wKSB7CisJCQkJcmV0ID0gd3Bhc19wMnBfbmZjX3RhZ19wcm9jZXNzKHdwYV9zLCB0bXAsCisJCQkJCQkJICAgICAgIGZvcmNlZF9mcmVxKTsKKwkJCQl3cGFidWZfZnJlZSh0bXApOworCQkJCXJldHVybiByZXQ7CisJCQl9CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IENvdWxkIG5vdCBwYXJzZSBOREVGIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KQEAgLTIyNDIsMjQgKzIzMDMsNDUgQEAKIH0KIAogCi1zdHJ1Y3Qgd3BhYnVmICogd3Bhc193cHNfbmZjX2hhbmRvdmVyX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgY3IpCitzdHJ1Y3Qgd3BhYnVmICogd3Bhc193cHNfbmZjX2hhbmRvdmVyX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgIGludCBuZGVmKQogewotCWlmIChjcikKLQkJcmV0dXJuIG5kZWZfYnVpbGRfd2lmaV9oYygxKTsKLQlyZXR1cm4gbmRlZl9idWlsZF93aWZpX2hyKCk7CisJc3RydWN0IHdwYWJ1ZiAqcmV0OworCisJaWYgKHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSA9PSBOVUxMICYmCisJICAgIHdwc19uZmNfZ2VuX2RoKCZ3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXksCisJCQkgICAmd3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHJpdmtleSkgPCAwKQorCQlyZXR1cm4gTlVMTDsKKworCXJldCA9IHdwc19idWlsZF9uZmNfaGFuZG92ZXJfcmVxKHdwYV9zLT53cHMsCisJCQkJCSB3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkpOworCisJaWYgKG5kZWYgJiYgcmV0KSB7CisJCXN0cnVjdCB3cGFidWYgKnRtcDsKKwkJdG1wID0gbmRlZl9idWlsZF93aWZpKHJldCk7CisJCXdwYWJ1Zl9mcmVlKHJldCk7CisJCWlmICh0bXAgPT0gTlVMTCkKKwkJCXJldHVybiBOVUxMOworCQlyZXQgPSB0bXA7CisJfQorCisJcmV0dXJuIHJldDsKIH0KIAogCiAjaWZkZWYgQ09ORklHX1dQU19ORkMKLXN0cnVjdCB3cGFidWYgKiB3cGFzX3dwc19lcl9uZmNfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgICAgaW50IG5kZWYsIGNvbnN0IGNoYXIgKnV1aWQpCisKK3N0YXRpYyBzdHJ1Y3Qgd3BhYnVmICoKK3dwYXNfd3BzX2VyX25mY19oYW5kb3Zlcl9zZWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IG5kZWYsCisJCQkgICAgIGNvbnN0IGNoYXIgKnV1aWQpCiB7CiAjaWZkZWYgQ09ORklHX1dQU19FUgogCXN0cnVjdCB3cGFidWYgKnJldDsKIAl1OCB1W1VVSURfTEVOXSwgKnVzZV91dWlkID0gTlVMTDsKIAl1OCBhZGRyW0VUSF9BTEVOXSwgKnVzZV9hZGRyID0gTlVMTDsKKwlzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcyA9IHdwYV9zLT53cHM7CiAKLQlpZiAoIXdwYV9zLT53cHNfZXIpCisJaWYgKHdwcyA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAogCWlmICh1dWlkID09IE5VTEwpCkBAIC0yMjcxLDExICsyMzUzLDIzIEBACiAJZWxzZQogCQlyZXR1cm4gTlVMTDsKIAotCS8qCi0JICogSGFuZG92ZXIgU2VsZWN0IGNhcnJpZXIgcmVjb3JkIGZvciBXUFMgdXNlcyB0aGUgc2FtZSBmb3JtYXQgYXMKLQkgKiBjb25maWd1cmF0aW9uIHRva2VuLgotCSAqLwotCXJldCA9IHdwc19lcl9uZmNfY29uZmlnX3Rva2VuKHdwYV9zLT53cHNfZXIsIHVzZV91dWlkLCB1c2VfYWRkcik7CisJaWYgKHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSA9PSBOVUxMKSB7CisJCWlmICh3cHNfbmZjX2dlbl9kaCgmd3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5LAorCQkJCSAgICZ3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5KSA8IDApCisJCQlyZXR1cm4gTlVMTDsKKwl9CisKKwl3cGFzX3dwc19uZmNfY2xlYXIod3BzKTsKKwl3cHMtPmFwX25mY19kZXZfcHdfaWQgPSBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVI7CisJd3BzLT5hcF9uZmNfZGhfcHVia2V5ID0gd3BhYnVmX2R1cCh3cGFfcy0+Y29uZi0+d3BzX25mY19kaF9wdWJrZXkpOworCXdwcy0+YXBfbmZjX2RoX3ByaXZrZXkgPSB3cGFidWZfZHVwKHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkpOworCWlmICghd3BzLT5hcF9uZmNfZGhfcHVia2V5IHx8ICF3cHMtPmFwX25mY19kaF9wcml2a2V5KSB7CisJCXdwYXNfd3BzX25mY19jbGVhcih3cHMpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXQgPSB3cHNfZXJfbmZjX2hhbmRvdmVyX3NlbCh3cGFfcy0+d3BzX2VyLCB3cGFfcy0+d3BzLCB1c2VfdXVpZCwKKwkJCQkgICAgICB1c2VfYWRkciwgd3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5KTsKIAlpZiAobmRlZiAmJiByZXQpIHsKIAkJc3RydWN0IHdwYWJ1ZiAqdG1wOwogCQl0bXAgPSBuZGVmX2J1aWxkX3dpZmkocmV0KTsKQEAgLTIzMDYsMjkgKzI0MDAsMTI1IEBACiB9CiAKIAotaW50IHdwYXNfd3BzX25mY19yeF9oYW5kb3Zlcl9yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqZGF0YSkKLXsKLQkvKiBUT0RPICovCi0JcmV0dXJuIC0xOwotfQotCi0KLWludCB3cGFzX3dwc19uZmNfcnhfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRhdGEpCitzdGF0aWMgaW50IHdwYXNfd3BzX25mY19yeF9oYW5kb3Zlcl9zZWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJY29uc3Qgc3RydWN0IHdwYWJ1ZiAqZGF0YSkKIHsKIAlzdHJ1Y3Qgd3BhYnVmICp3cHM7Ci0JaW50IHJldDsKKwlpbnQgcmV0ID0gLTE7CisJdTE2IHdzY19sZW47CisJY29uc3QgdTggKnBvczsKKwlzdHJ1Y3Qgd3BhYnVmIG1zZzsKKwlzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgYXR0cjsKKwl1MTYgZGV2X3B3X2lkOworCWNvbnN0IHU4ICpic3NpZCA9IE5VTEw7CisJaW50IGZyZXEgPSAwOwogCiAJd3BzID0gbmRlZl9wYXJzZV93aWZpKGRhdGEpOwogCWlmICh3cHMgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBSZWNlaXZlZCBhcHBsaWNhdGlvbi92bmQud2ZhLndzYyAiCiAJCSAgICJwYXlsb2FkIGZyb20gTkZDIGNvbm5lY3Rpb24gaGFuZG92ZXIiKTsKLQl3cGFfaGV4ZHVtcF9idWZfa2V5KE1TR19ERUJVRywgIldQUzogTkZDIHBheWxvYWQiLCB3cHMpOwotCXJldCA9IHdwYXNfd3BzX25mY190YWdfcHJvY2Vzcyh3cGFfcywgd3BzKTsKLQl3cGFidWZfZnJlZSh3cHMpOworCXdwYV9oZXhkdW1wX2J1ZihNU0dfREVCVUcsICJXUFM6IE5GQyBwYXlsb2FkIiwgd3BzKTsKKwlpZiAod3BhYnVmX2xlbih3cHMpIDwgMikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVG9vIHNob3J0IFdpLUZpIEhhbmRvdmVyIFNlbGVjdCAiCisJCQkgICAiTWVzc2FnZSIpOworCQlnb3RvIG91dDsKKwl9CisJcG9zID0gd3BhYnVmX2hlYWQod3BzKTsKKwl3c2NfbGVuID0gV1BBX0dFVF9CRTE2KHBvcyk7CisJaWYgKHdzY19sZW4gPiB3cGFidWZfbGVuKHdwcykgLSAyKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBJbnZhbGlkIFdTQyBhdHRyaWJ1dGUgbGVuZ3RoICgldSkgIgorCQkJICAgImluIFdpLUZpIEhhbmRvdmVyIFNlbGVjdCBNZXNzYWdlIiwgd3NjX2xlbik7CisJCWdvdG8gb3V0OworCX0KKwlwb3MgKz0gMjsKIAorCXdwYV9oZXhkdW1wKE1TR19ERUJVRywKKwkJICAgICJXUFM6IFdTQyBhdHRyaWJ1dGVzIGluIFdpLUZpIEhhbmRvdmVyIFNlbGVjdCBNZXNzYWdlIiwKKwkJICAgIHBvcywgd3NjX2xlbik7CisJaWYgKHdzY19sZW4gPCB3cGFidWZfbGVuKHdwcykgLSAyKSB7CisJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywKKwkJCSAgICAiV1BTOiBJZ25vcmUgZXh0cmEgZGF0YSBhZnRlciBXU0MgYXR0cmlidXRlcyIsCisJCQkgICAgcG9zICsgd3NjX2xlbiwgd3BhYnVmX2xlbih3cHMpIC0gMiAtIHdzY19sZW4pOworCX0KKworCXdwYWJ1Zl9zZXQoJm1zZywgcG9zLCB3c2NfbGVuKTsKKwlyZXQgPSB3cHNfcGFyc2VfbXNnKCZtc2csICZhdHRyKTsKKwlpZiAocmV0IDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogQ291bGQgbm90IHBhcnNlIFdTQyBhdHRyaWJ1dGVzIGluICIKKwkJCSAgICJXaS1GaSBIYW5kb3ZlciBTZWxlY3QgTWVzc2FnZSIpOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAoYXR0ci5vb2JfZGV2X3Bhc3N3b3JkID09IE5VTEwgfHwKKwkgICAgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkX2xlbiA8IFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOICsgMikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogTm8gT3V0LW9mLUJhbmQgRGV2aWNlIFBhc3N3b3JkICIKKwkJCSAgICJpbmNsdWRlZCBpbiBXaS1GaSBIYW5kb3ZlciBTZWxlY3QgTWVzc2FnZSIpOworCQlyZXQgPSAtMTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKGF0dHIuc3NpZCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBTU0lEIGluY2x1ZGVkIGluIFdpLUZpIEhhbmRvdmVyICIKKwkJCSAgICJTZWxlY3QgTWVzc2FnZSIpOworCQlyZXQgPSAtMTsKKwkJZ290byBvdXQ7CisJfQorCisJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiV1BTOiBTU0lEIiwgYXR0ci5zc2lkLCBhdHRyLnNzaWRfbGVuKTsKKworCWlmIChhdHRyLm1hY19hZGRyKSB7CisJCWJzc2lkID0gYXR0ci5tYWNfYWRkcjsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IE1BQyBBZGRyZXNzIChCU1NJRCk6ICIgTUFDU1RSLAorCQkJICAgTUFDMlNUUihic3NpZCkpOworCX0KKworCWlmIChhdHRyLnJmX2JhbmRzKQorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogUkYgQmFuZHM6ICVkIiwgKmF0dHIucmZfYmFuZHMpOworCisJaWYgKGF0dHIuYXBfY2hhbm5lbCkgeworCQl1MTYgY2hhbiA9IFdQQV9HRVRfQkUxNihhdHRyLmFwX2NoYW5uZWwpOworCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBBUCBDaGFubmVsOiAlZCIsIGNoYW4pOworCisJCWlmIChjaGFuID49IDEgJiYgY2hhbiA8PSAxMyAmJgorCQkgICAgKGF0dHIucmZfYmFuZHMgPT0gTlVMTCB8fCAqYXR0ci5yZl9iYW5kcyAmIFdQU19SRl8yNEdIWikpCisJCQlmcmVxID0gMjQwNyArIDUgKiBjaGFuOworCQllbHNlIGlmIChjaGFuID09IDE0ICYmCisJCQkgKGF0dHIucmZfYmFuZHMgPT0gTlVMTCB8fAorCQkJICAqYXR0ci5yZl9iYW5kcyAmIFdQU19SRl8yNEdIWikpCisJCQlmcmVxID0gMjQ4NDsKKwkJZWxzZSBpZiAoY2hhbiA+PSAzMCAmJgorCQkJIChhdHRyLnJmX2JhbmRzID09IE5VTEwgfHwKKwkJCSAgKmF0dHIucmZfYmFuZHMgJiBXUFNfUkZfNTBHSFopKQorCQkJZnJlcSA9IDUwMDAgKyA1ICogY2hhbjsKKworCQlpZiAoZnJlcSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsCisJCQkJICAgIldQUzogQVAgaW5kaWNhdGVkIGNoYW5uZWwgJXUgLT4gJXUgTUh6IiwKKwkJCQkgICBjaGFuLCBmcmVxKTsKKwkJfQorCX0KKworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldQUzogT3V0LW9mLUJhbmQgRGV2aWNlIFBhc3N3b3JkIiwKKwkJICAgIGF0dHIub29iX2Rldl9wYXNzd29yZCwgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkX2xlbik7CisJZGV2X3B3X2lkID0gV1BBX0dFVF9CRTE2KGF0dHIub29iX2Rldl9wYXNzd29yZCArCisJCQkJIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOKTsKKwlpZiAoZGV2X3B3X2lkICE9IERFVl9QV19ORkNfQ09OTkVDVElPTl9IQU5ET1ZFUikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVW5leHBlY3RlZCBPT0IgRGV2aWNlIFBhc3N3b3JkIElEICIKKwkJCSAgICIldSBpbiBXaS1GaSBIYW5kb3ZlciBTZWxlY3QgTWVzc2FnZSIsIGRldl9wd19pZCk7CisJCXJldCA9IC0xOworCQlnb3RvIG91dDsKKwl9CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBBUCBQdWJsaWMgS2V5IGhhc2giLAorCQkgICAgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkLCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTik7CisKKwlyZXQgPSB3cGFzX3dwc19zdGFydF9uZmMod3BhX3MsIE5VTEwsIGJzc2lkLCBOVUxMLCBkZXZfcHdfaWQsIDAsCisJCQkJIGF0dHIub29iX2Rldl9wYXNzd29yZCwKKwkJCQkgYXR0ci5zc2lkLCBhdHRyLnNzaWRfbGVuLCBmcmVxKTsKKworb3V0OgorCXdwYWJ1Zl9mcmVlKHdwcyk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMjM0MywxNSArMjUzMywxMDcgQEAKIAlyZXR1cm4gd3Bhc193cHNfbmZjX3J4X2hhbmRvdmVyX3NlbCh3cGFfcywgc2VsKTsKIH0KIAorCitpbnQgd3Bhc19lcl93cHNfbmZjX3JlcG9ydF9oYW5kb3ZlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpyZXEsCisJCQkJICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnNlbCkKK3sKKwlzdHJ1Y3Qgd3BhYnVmICp3cHM7CisJaW50IHJldCA9IC0xOworCXUxNiB3c2NfbGVuOworCWNvbnN0IHU4ICpwb3M7CisJc3RydWN0IHdwYWJ1ZiBtc2c7CisJc3RydWN0IHdwc19wYXJzZV9hdHRyIGF0dHI7CisJdTE2IGRldl9wd19pZDsKKworCS8qCisJICogRW5yb2xsZWUvc3RhdGlvbiBpcyBhbHdheXMgaW5pdGlhdG9yIG9mIHRoZSBORkMgY29ubmVjdGlvbiBoYW5kb3ZlciwKKwkgKiBzbyB1c2UgdGhlIHJlcXVlc3QgbWVzc2FnZSBoZXJlIHRvIGZpbmQgRW5yb2xsZWUgcHVibGljIGtleSBoYXNoLgorCSAqLworCXdwcyA9IG5kZWZfcGFyc2Vfd2lmaShyZXEpOworCWlmICh3cHMgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBSZWNlaXZlZCBhcHBsaWNhdGlvbi92bmQud2ZhLndzYyAiCisJCSAgICJwYXlsb2FkIGZyb20gTkZDIGNvbm5lY3Rpb24gaGFuZG92ZXIiKTsKKwl3cGFfaGV4ZHVtcF9idWYoTVNHX0RFQlVHLCAiV1BTOiBORkMgcGF5bG9hZCIsIHdwcyk7CisJaWYgKHdwYWJ1Zl9sZW4od3BzKSA8IDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFRvbyBzaG9ydCBXaS1GaSBIYW5kb3ZlciBSZXF1ZXN0ICIKKwkJCSAgICJNZXNzYWdlIik7CisJCWdvdG8gb3V0OworCX0KKwlwb3MgPSB3cGFidWZfaGVhZCh3cHMpOworCXdzY19sZW4gPSBXUEFfR0VUX0JFMTYocG9zKTsKKwlpZiAod3NjX2xlbiA+IHdwYWJ1Zl9sZW4od3BzKSAtIDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEludmFsaWQgV1NDIGF0dHJpYnV0ZSBsZW5ndGggKCV1KSAiCisJCQkgICAiaW4gcnQgV2ktRmkgSGFuZG92ZXIgUmVxdWVzdCBNZXNzYWdlIiwgd3NjX2xlbik7CisJCWdvdG8gb3V0OworCX0KKwlwb3MgKz0gMjsKKworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywKKwkJICAgICJXUFM6IFdTQyBhdHRyaWJ1dGVzIGluIFdpLUZpIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSIsCisJCSAgICBwb3MsIHdzY19sZW4pOworCWlmICh3c2NfbGVuIDwgd3BhYnVmX2xlbih3cHMpIC0gMikgeworCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsCisJCQkgICAgIldQUzogSWdub3JlIGV4dHJhIGRhdGEgYWZ0ZXIgV1NDIGF0dHJpYnV0ZXMiLAorCQkJICAgIHBvcyArIHdzY19sZW4sIHdwYWJ1Zl9sZW4od3BzKSAtIDIgLSB3c2NfbGVuKTsKKwl9CisKKwl3cGFidWZfc2V0KCZtc2csIHBvcywgd3NjX2xlbik7CisJcmV0ID0gd3BzX3BhcnNlX21zZygmbXNnLCAmYXR0cik7CisJaWYgKHJldCA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IENvdWxkIG5vdCBwYXJzZSBXU0MgYXR0cmlidXRlcyBpbiAiCisJCQkgICAiV2ktRmkgSGFuZG92ZXIgUmVxdWVzdCBNZXNzYWdlIik7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChhdHRyLm9vYl9kZXZfcGFzc3dvcmQgPT0gTlVMTCB8fAorCSAgICBhdHRyLm9vYl9kZXZfcGFzc3dvcmRfbGVuIDwgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gKyAyKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBObyBPdXQtb2YtQmFuZCBEZXZpY2UgUGFzc3dvcmQgIgorCQkJICAgImluY2x1ZGVkIGluIFdpLUZpIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSIpOworCQlyZXQgPSAtMTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKGF0dHIudXVpZF9lID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IE5vIFVVSUQtRSBpbmNsdWRlZCBpbiBXaS1GaSAiCisJCQkgICAiSGFuZG92ZXIgUmVxdWVzdCBNZXNzYWdlIik7CisJCXJldCA9IC0xOworCQlnb3RvIG91dDsKKwl9CisKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUFM6IFVVSUQtRSIsIGF0dHIudXVpZF9lLCBXUFNfVVVJRF9MRU4pOworCisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBPdXQtb2YtQmFuZCBEZXZpY2UgUGFzc3dvcmQiLAorCQkgICAgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkLCBhdHRyLm9vYl9kZXZfcGFzc3dvcmRfbGVuKTsKKwlkZXZfcHdfaWQgPSBXUEFfR0VUX0JFMTYoYXR0ci5vb2JfZGV2X3Bhc3N3b3JkICsKKwkJCQkgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCWlmIChkZXZfcHdfaWQgIT0gREVWX1BXX05GQ19DT05ORUNUSU9OX0hBTkRPVkVSKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVbmV4cGVjdGVkIE9PQiBEZXZpY2UgUGFzc3dvcmQgSUQgIgorCQkJICAgIiV1IGluIFdpLUZpIEhhbmRvdmVyIFJlcXVlc3QgTWVzc2FnZSIsIGRldl9wd19pZCk7CisJCXJldCA9IC0xOworCQlnb3RvIG91dDsKKwl9CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBFbnJvbGxlZSBQdWJsaWMgS2V5IGhhc2giLAorCQkgICAgYXR0ci5vb2JfZGV2X3Bhc3N3b3JkLCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTik7CisKKwlyZXQgPSB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcHdfdG9rZW4od3BhX3MtPndwcy0+cmVnaXN0cmFyLAorCQkJCQkgICAgIGF0dHIub29iX2Rldl9wYXNzd29yZCwKKwkJCQkJICAgICBERVZfUFdfTkZDX0NPTk5FQ1RJT05fSEFORE9WRVIsCisJCQkJCSAgICAgTlVMTCwgMCwgMSk7CisKK291dDoKKwl3cGFidWZfZnJlZSh3cHMpOworCXJldHVybiByZXQ7Cit9CisKICNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogCiAKLWV4dGVybiBpbnQgd3BhX2RlYnVnX2xldmVsOwotCiBzdGF0aWMgdm9pZCB3cGFzX3dwc19kdW1wX2FwX2luZm8oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKIAlzaXplX3QgaTsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisJc3RydWN0IG9zX3JlbHRpbWUgbm93OwogCiAJaWYgKHdwYV9kZWJ1Z19sZXZlbCA+IE1TR19ERUJVRykKIAkJcmV0dXJuOwpAQCAtMjM1OSw3ICsyNjQxLDcgQEAKIAlpZiAod3BhX3MtPndwc19hcCA9PSBOVUxMKQogCQlyZXR1cm47CiAKLQlvc19nZXRfdGltZSgmbm93KTsKKwlvc19nZXRfcmVsdGltZSgmbm93KTsKIAogCWZvciAoaSA9IDA7IGkgPCB3cGFfcy0+bnVtX3dwc19hcDsgaSsrKSB7CiAJCXN0cnVjdCB3cHNfYXBfaW5mbyAqYXAgPSAmd3BhX3MtPndwc19hcFtpXTsKQEAgLTI0NjMsMTEgKzI3NDUsMTQgQEAKIHZvaWQgd3Bhc193cHNfbm90aWZ5X2Fzc29jKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpic3NpZCkKIHsKIAlzdHJ1Y3Qgd3BzX2FwX2luZm8gKmFwOworCisJd3BhX3MtPmFmdGVyX3dwcyA9IDA7CisKIAlpZiAoIXdwYV9zLT53cHNfYXBfaXRlcikKIAkJcmV0dXJuOwogCWFwID0gd3Bhc193cHNfZ2V0X2FwX2luZm8od3BhX3MsIGJzc2lkKTsKIAlpZiAoYXAgPT0gTlVMTCkKIAkJcmV0dXJuOwogCWFwLT50cmllcysrOwotCW9zX2dldF90aW1lKCZhcC0+bGFzdF9hdHRlbXB0KTsKKwlvc19nZXRfcmVsdGltZSgmYXAtPmxhc3RfYXR0ZW1wdCk7CiB9CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93cHNfc3VwcGxpY2FudC5oIGIvd3BhX3N1cHBsaWNhbnQvd3BzX3N1cHBsaWNhbnQuaAppbmRleCAyYTIxMmNhLi4yMjYzNTEyIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC93cHNfc3VwcGxpY2FudC5oCisrKyBiL3dwYV9zdXBwbGljYW50L3dwc19zdXBwbGljYW50LmgKQEAgLTYwLDI0ICs2MCwyNyBAQAogc3RydWN0IHdwYWJ1ZiAqIHdwYXNfd3BzX2VyX25mY19jb25maWdfdG9rZW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICAgICBpbnQgbmRlZiwgY29uc3QgY2hhciAqdXVpZCk7CiBpbnQgd3Bhc193cHNfdGVybWluYXRlX3BlbmRpbmcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Ci1pbnQgd3Bhc193cHNfaW5fcHJvZ3Jlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIHdwYXNfd3BzX3VwZGF0ZV9jb25maWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiBzdHJ1Y3Qgd3BhYnVmICogd3Bhc193cHNfbmZjX2NvbmZpZ190b2tlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgIGludCBuZGVmLCBjb25zdCBjaGFyICppZF9zdHIpOwogc3RydWN0IHdwYWJ1ZiAqIHdwYXNfd3BzX25mY190b2tlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgbmRlZik7Ci1pbnQgd3Bhc193cHNfc3RhcnRfbmZjKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpic3NpZCk7CitpbnQgd3Bhc193cHNfc3RhcnRfbmZjKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpkZXZfYWRkciwKKwkJICAgICAgIGNvbnN0IHU4ICpic3NpZCwKKwkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRldl9wdywgdTE2IGRldl9wd19pZCwKKwkJICAgICAgIGludCBwMnBfZ3JvdXAsIGNvbnN0IHU4ICpwZWVyX3B1YmtleV9oYXNoLAorCQkgICAgICAgY29uc3QgdTggKnNzaWQsIHNpemVfdCBzc2lkX2xlbiwgaW50IGZyZXEpOwogaW50IHdwYXNfd3BzX25mY190YWdfcmVhZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpkYXRhKTsKLXN0cnVjdCB3cGFidWYgKiB3cGFzX3dwc19uZmNfaGFuZG92ZXJfcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBjcik7CisJCQkgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRhdGEsIGludCBmb3JjZWRfZnJlcSk7CitzdHJ1Y3Qgd3BhYnVmICogd3Bhc193cHNfbmZjX2hhbmRvdmVyX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgIGludCBuZGVmKTsKIHN0cnVjdCB3cGFidWYgKiB3cGFzX3dwc19uZmNfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSAgaW50IG5kZWYsIGludCBjciwgY29uc3QgY2hhciAqdXVpZCk7Ci1pbnQgd3Bhc193cHNfbmZjX3J4X2hhbmRvdmVyX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpkYXRhKTsKLWludCB3cGFzX3dwc19uZmNfcnhfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRhdGEpOwogaW50IHdwYXNfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcmVxLAogCQkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpzZWwpOworaW50IHdwYXNfZXJfd3BzX25mY19yZXBvcnRfaGFuZG92ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcmVxLAorCQkJCSAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpzZWwpOwogdm9pZCB3cGFzX3dwc191cGRhdGVfYXBfaW5mbyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJICAgICBzdHJ1Y3Qgd3BhX3NjYW5fcmVzdWx0cyAqc2Nhbl9yZXMpOwogdm9pZCB3cGFzX3dwc19ub3RpZnlfYXNzb2Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmJzc2lkKTsK