ZGlmZiAtLWdpdCBhL2NvbmYvbWltZS50eXBlcyBiL2NvbmYvbWltZS50eXBlcwppbmRleCBlMTdjM2QxLi44MTgxMzNhIDEwMDY0NAotLS0gYS9jb25mL21pbWUudHlwZXMKKysrIGIvY29uZi9taW1lLnR5cGVzCkBAIC00OSw1ICs0OSw2IEBACiAgICAgdmlkZW8veC1mbHYgICAgICAgICAgICAgICAgICAgICAgICAgICBmbHY7CiAgICAgdmlkZW8veC1tc3ZpZGVvICAgICAgICAgICAgICAgICAgICAgICBhdmk7CiAgICAgdmlkZW8veC1tcy13bXYgICAgICAgICAgICAgICAgICAgICAgICB3bXY7CisgICAgdmlkZW8veC1tcy1hc2YgICAgICAgICAgICAgICAgICAgICAgICBhc3ggYXNmOwogICAgIHZpZGVvL3gtbW5nICAgICAgICAgICAgICAgICAgICAgICAgICAgbW5nOwogfQpkaWZmIC0tZ2l0IGEvZG9jcy94bWwvbmdpbngvY2hhbmdlcy54bWwgYi9kb2NzL3htbC9uZ2lueC9jaGFuZ2VzLnhtbAppbmRleCA3NjU3YTVjLi44Zjc3ZmFhIDEwMDY0NAotLS0gYS9kb2NzL3htbC9uZ2lueC9jaGFuZ2VzLnhtbAorKysgYi9kb2NzL3htbC9uZ2lueC9jaGFuZ2VzLnhtbApAQCAtOSw2ICs5LDUyIEBACiA8dGl0bGUgbGFuZz0iZW4iPm5naW54IGNoYW5nZWxvZzwvdGl0bGU+CiAKIAorPGNoYW5nZXMgdmVyPSIwLjMuNDYiIGRhdGU9IjExLjA1LjIwMDYiPgorCis8Y2hhbmdlIHR5cGU9ImZlYXR1cmUiPgorPHBhcmEgbGFuZz0icnUiPgorxMnSxcvUydfZIHByb3h5X2hpZGVfaGVhZGVyLCBwcm94eV9wYXNzX2hlYWRlciwgZmFzdGNnaV9oaWRlX2hlYWRlcgorySBmYXN0Y2dpX3Bhc3NfaGVhZGVyLgorPC9wYXJhPgorPHBhcmEgbGFuZz0iZW4iPgordGhlICJwcm94eV9oaWRlX2hlYWRlciIsICJwcm94eV9wYXNzX2hlYWRlciIsICJmYXN0Y2dpX2hpZGVfaGVhZGVyIiwKK2FuZCAiZmFzdGNnaV9wYXNzX2hlYWRlciIgZGlyZWN0aXZlcy4KKzwvcGFyYT4KKzwvY2hhbmdlPgorCis8Y2hhbmdlIHR5cGU9ImNoYW5nZSI+Cis8cGFyYSBsYW5nPSJydSI+CivEydLFy9TJ19kgcHJveHlfeF9wb3dlcmVkX2J5LCBmYXN0Y2dpX3hfcG93ZXJlZF9ieSDJIHByb3h5X3Bhc3Nfc2VydmVyCivV0NLB2sTOxc7ZLgorPC9wYXJhPgorPHBhcmEgbGFuZz0iZW4iPgordGhlICJwcm94eV9wYXNzX3hfcG93ZXJlZF9ieSIsICJmYXN0Y2dpX3hfcG93ZXJlZF9ieSIsIGFuZCAicHJveHlfcGFzc19zZXJ2ZXIiCitkaXJlY3RpdmVzIHdlcmUgY2FuY2VsZWQuCis8L3BhcmE+Cis8L2NoYW5nZT4KKworPGNoYW5nZSB0eXBlPSJmZWF0dXJlIj4KKzxwYXJhIGxhbmc9InJ1Ij4KK9cg0sXWyc3FINDSz8vTySDQz8TExdLWydfBxdTT0SDT1NLPy8Eg2sHHz8zP18vBICJYLUFjY2VsLUJ1ZmZlcmluZyIKK9cgz9TXxdTFIMLcy8XOxMEuCis8L3BhcmE+Cis8cGFyYSBsYW5nPSJlbiI+Cit0aGUgIlgtQWNjZWwtQnVmZmVyaW5nIiByZXNwb25zZSBoZWFkZXIgbGluZSBpcyBzdXBwb3J0ZWQgaW4gcHJveHkgbW9kZS4KKzwvcGFyYT4KKzwvY2hhbmdlPgorCis8Y2hhbmdlIHR5cGU9ImJ1Z2ZpeCI+Cis8cGFyYSBsYW5nPSJydSI+CivP28nCz8sgySDV1MXexcsg0MHN0dTJINDSySDQxdLFy8/OxsnH1dLBw8nJINcgzc/E1czFIG5neF9odHRwX3BlcmxfbW9kdWxlLgorPC9wYXJhPgorPHBhcmEgbGFuZz0iZW4iPgordGhlIHJlY29uZmlndXJhdGlvbiBidWcgYW5kIG1lbW9yeSBsZWFrcyBpbiB0aGUgbmd4X2h0dHBfcGVybF9tb2R1bGUuCis8L3BhcmE+Cis8L2NoYW5nZT4KKworPC9jaGFuZ2VzPgorCisKIDxjaGFuZ2VzIHZlcj0iMC4zLjQ1IiBkYXRlPSIwNi4wNS4yMDA2Ij4KIAogPGNoYW5nZSB0eXBlPSJmZWF0dXJlIj4KQEAgLTc3Nyw3ICs4MjMsNyBAQAogxMnSxcvUydfBIHJlc3RyaWN0X2hvc3RfbmFtZXMg1dDSwdrEzsXOwS4KIDwvcGFyYT4KIDxwYXJhIGxhbmc9ImVuIj4KLXRoZSAicmVzdHJpY3RfaG9zdF9uYW1lcyIgZGlyZWN0aXZlIGlzIGNhbmNlbGVkLgordGhlICJyZXN0cmljdF9ob3N0X25hbWVzIiBkaXJlY3RpdmUgd2FzIGNhbmNlbGVkLgogPC9wYXJhPgogPC9jaGFuZ2U+CiAKQEAgLTEwNTcsNyArMTEwMyw3IEBACiDNxdTPxCAkci0+cXVlcnlfc3RyaW5nINcgzc/E1czFIG5neF9odHRwX3BlcmxfbW9kdWxlINXQ0sHaxM6jzi4KIDwvcGFyYT4KIDxwYXJhIGxhbmc9ImVuIj4KLXRoZSBtZXRob2QgJHItPnF1ZXJ5X3N0cmluZyBvZiBuZ3hfaHR0cF9wZXJsX21vZHVsZSBpcyBjYW5jZWxlZC4KK3RoZSBtZXRob2QgJHItPnF1ZXJ5X3N0cmluZyBvZiBuZ3hfaHR0cF9wZXJsX21vZHVsZSB3YXMgY2FuY2VsZWQuCiA8L3BhcmE+CiA8L2NoYW5nZT4KIApAQCAtMjY4NCw3ICsyNzMwLDcgQEAKINDF0sXOxdPFzsEgzsEgx8zPwsHM2M7ZyiDV0s/Xxc7YLgogPC9wYXJhPgogPHBhcmEgbGFuZz0iZW4iPgotdGhlICJzc2xfZW5naW5lIiBkaXJlY3RpdmUgaXMgY2FuY2VsZWQgaW4gdGhlIG5neF9odHRwX3NzbF9tb2R1bGUKK3RoZSAic3NsX2VuZ2luZSIgZGlyZWN0aXZlIHdhcyBjYW5jZWxlZCBpbiB0aGUgbmd4X2h0dHBfc3NsX21vZHVsZQogYW5kIG5vdyBpcyBpbnRyb2R1Y2VkIGF0IGdsb2JhbCBsZXZlbC4KIDwvcGFyYT4KIDwvY2hhbmdlPgpAQCAtMjkzNCw3ICsyOTgwLDcgQEAKIDwvcGFyYT4KIDxwYXJhIGxhbmc9ImVuIj4KIFRoZSBjaGFuZ2VzIGluIHRoZSBuZ3hfaHR0cF9jaGFyc2V0X21vZHVsZToKLXRoZSAiZGVmYXVsdF9jaGFyc2V0IiBkaXJlY3RpdmUgaXMgY2FuY2VsZWQ7Cit0aGUgImRlZmF1bHRfY2hhcnNldCIgZGlyZWN0aXZlIHdhcyBjYW5jZWxlZDsKIHRoZSAiY2hhcnNldCIgZGlyZWN0aXZlIHNldHMgdGhlIHJlc3BvbnNlIGNoYXJzZXQ7CiB0aGUgInNvdXJjZV9jaGFyc2V0IiBkaXJlY3RpdmUgc2V0cyB0aGUgc291cmNlIGNoYXJzZXQgb25seS4KIDwvcGFyYT4KQEAgLTM2NzMsNyArMzcxOSw3IEBACiA8L3BhcmE+CiA8cGFyYSBsYW5nPSJlbiI+CiB0aGUgInByb3h5X3NldF9oZWFkZXIiIGRpcmVjdGl2ZS4KLVRoZSAicHJveHlfeF92YXIiIGlzIGNhbmNlbGVkIGFuZCBtdXN0IGJlIHJlcGxhY2VkIHdpdGggdGhlIHByb3h5X3NldF9oZWFkZXIKK1RoZSAicHJveHlfeF92YXIiIHdhcyBjYW5jZWxlZCBhbmQgbXVzdCBiZSByZXBsYWNlZCB3aXRoIHRoZSBwcm94eV9zZXRfaGVhZGVyCiBkaXJlY3RpdmUuCiA8L3BhcmE+CiA8L2NoYW5nZT4KZGlmZiAtLWdpdCBhL3NyYy9jb3JlL25naW54LmggYi9zcmMvY29yZS9uZ2lueC5oCmluZGV4IGU0OWI5MWMuLmVjZTU3ZjUgMTAwNjQ0Ci0tLSBhL3NyYy9jb3JlL25naW54LmgKKysrIGIvc3JjL2NvcmUvbmdpbnguaApAQCAtOCw3ICs4LDcgQEAKICNkZWZpbmUgX05HSU5YX0hfSU5DTFVERURfCiAKIAotI2RlZmluZSBOR0lOWF9WRVIgICAgICAgICAgIm5naW54LzAuMy40NSIKKyNkZWZpbmUgTkdJTlhfVkVSICAgICAgICAgICJuZ2lueC8wLjMuNDYiCiAKICNkZWZpbmUgTkdJTlhfVkFSICAgICAgICAgICJOR0lOWCIKICNkZWZpbmUgTkdYX09MRFBJRF9FWFQgICAgICIub2xkYmluIgpkaWZmIC0tZ2l0IGEvc3JjL2NvcmUvbmd4X2NvbmZfZmlsZS5jIGIvc3JjL2NvcmUvbmd4X2NvbmZfZmlsZS5jCmluZGV4IGI4OTU5MTAuLjk0ZGZlNjIgMTAwNjQ0Ci0tLSBhL3NyYy9jb3JlL25neF9jb25mX2ZpbGUuYworKysgYi9zcmMvY29yZS9uZ3hfY29uZl9maWxlLmMKQEAgLTkwMCwzOCArOTAwLDczIEBACiAKIAogY2hhciAqCi1uZ3hfY29uZl9zZXRfdGFibGVfZWx0X3Nsb3Qobmd4X2NvbmZfdCAqY2YsIG5neF9jb21tYW5kX3QgKmNtZCwgdm9pZCAqY29uZikKK25neF9jb25mX3NldF9zdHJfYXJyYXlfc2xvdChuZ3hfY29uZl90ICpjZiwgbmd4X2NvbW1hbmRfdCAqY21kLCB2b2lkICpjb25mKQogewogICAgIGNoYXIgICpwID0gY29uZjsKIAotICAgIG5neF9zdHJfdCAgICAgICAgICp2YWx1ZTsKKyAgICBuZ3hfc3RyX3QgICAgICAgICAqdmFsdWUsICpzOwogICAgIG5neF9hcnJheV90ICAgICAgKiphOwotICAgIG5neF90YWJsZV9lbHRfdCAgICplbHQ7CiAgICAgbmd4X2NvbmZfcG9zdF90ICAgKnBvc3Q7CiAKICAgICBhID0gKG5neF9hcnJheV90ICoqKSAocCArIGNtZC0+b2Zmc2V0KTsKIAogICAgIGlmICgqYSA9PSBOVUxMKSB7Ci0gICAgICAgICphID0gbmd4X2FycmF5X2NyZWF0ZShjZi0+cG9vbCwgNCwgc2l6ZW9mKG5neF90YWJsZV9lbHRfdCkpOworICAgICAgICAqYSA9IG5neF9hcnJheV9jcmVhdGUoY2YtPnBvb2wsIDQsIHNpemVvZihuZ3hfc3RyX3QpKTsKICAgICAgICAgaWYgKCphID09IE5VTEwpIHsKICAgICAgICAgICAgIHJldHVybiBOR1hfQ09ORl9FUlJPUjsKICAgICAgICAgfQogICAgIH0KIAotICAgIGVsdCA9IG5neF9hcnJheV9wdXNoKCphKTsKLSAgICBpZiAoZWx0ID09IE5VTEwpIHsKKyAgICBzID0gbmd4X2FycmF5X3B1c2goKmEpOworICAgIGlmIChzID09IE5VTEwpIHsKICAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOwogICAgIH0KIAogICAgIHZhbHVlID0gY2YtPmFyZ3MtPmVsdHM7CiAKLSAgICBlbHQtPmhhc2ggPSAwOwotICAgIGVsdC0+a2V5ID0gdmFsdWVbMV07Ci0gICAgZWx0LT52YWx1ZSA9IHZhbHVlWzJdOworICAgICpzID0gdmFsdWVbMV07CiAKICAgICBpZiAoY21kLT5wb3N0KSB7CiAgICAgICAgIHBvc3QgPSBjbWQtPnBvc3Q7Ci0gICAgICAgIHJldHVybiBwb3N0LT5wb3N0X2hhbmRsZXIoY2YsIHBvc3QsIGVsdCk7CisgICAgICAgIHJldHVybiBwb3N0LT5wb3N0X2hhbmRsZXIoY2YsIHBvc3QsIHMpOworICAgIH0KKworICAgIHJldHVybiBOR1hfQ09ORl9PSzsKK30KKworCitjaGFyICoKK25neF9jb25mX3NldF9rZXl2YWxfc2xvdChuZ3hfY29uZl90ICpjZiwgbmd4X2NvbW1hbmRfdCAqY21kLCB2b2lkICpjb25mKQoreworICAgIGNoYXIgICpwID0gY29uZjsKKworICAgIG5neF9zdHJfdCAgICAgICAgICp2YWx1ZTsKKyAgICBuZ3hfYXJyYXlfdCAgICAgICoqYTsKKyAgICBuZ3hfa2V5dmFsX3QgICAgICAqa3Y7CisgICAgbmd4X2NvbmZfcG9zdF90ICAgKnBvc3Q7CisKKyAgICBhID0gKG5neF9hcnJheV90ICoqKSAocCArIGNtZC0+b2Zmc2V0KTsKKworICAgIGlmICgqYSA9PSBOVUxMKSB7CisgICAgICAgICphID0gbmd4X2FycmF5X2NyZWF0ZShjZi0+cG9vbCwgNCwgc2l6ZW9mKG5neF9rZXl2YWxfdCkpOworICAgICAgICBpZiAoKmEgPT0gTlVMTCkgeworICAgICAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgICAgICB9CisgICAgfQorCisgICAga3YgPSBuZ3hfYXJyYXlfcHVzaCgqYSk7CisgICAgaWYgKGt2ID09IE5VTEwpIHsKKyAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgIH0KKworICAgIHZhbHVlID0gY2YtPmFyZ3MtPmVsdHM7CisKKyAgICBrdi0+a2V5ID0gdmFsdWVbMV07CisgICAga3YtPnZhbHVlID0gdmFsdWVbMl07CisKKyAgICBpZiAoY21kLT5wb3N0KSB7CisgICAgICAgIHBvc3QgPSBjbWQtPnBvc3Q7CisgICAgICAgIHJldHVybiBwb3N0LT5wb3N0X2hhbmRsZXIoY2YsIHBvc3QsIGt2KTsKICAgICB9CiAKICAgICByZXR1cm4gTkdYX0NPTkZfT0s7CmRpZmYgLS1naXQgYS9zcmMvY29yZS9uZ3hfY29uZl9maWxlLmggYi9zcmMvY29yZS9uZ3hfY29uZl9maWxlLmgKaW5kZXggMzdkMzZkNi4uOGY4NGUzNiAxMDA2NDQKLS0tIGEvc3JjL2NvcmUvbmd4X2NvbmZfZmlsZS5oCisrKyBiL3NyYy9jb3JlL25neF9jb25mX2ZpbGUuaApAQCAtMzIzLDggKzMyMyw5IEBACiAKIGNoYXIgKm5neF9jb25mX3NldF9mbGFnX3Nsb3Qobmd4X2NvbmZfdCAqY2YsIG5neF9jb21tYW5kX3QgKmNtZCwgdm9pZCAqY29uZik7CiBjaGFyICpuZ3hfY29uZl9zZXRfc3RyX3Nsb3Qobmd4X2NvbmZfdCAqY2YsIG5neF9jb21tYW5kX3QgKmNtZCwgdm9pZCAqY29uZik7Ci1jaGFyICpuZ3hfY29uZl9zZXRfdGFibGVfZWx0X3Nsb3Qobmd4X2NvbmZfdCAqY2YsIG5neF9jb21tYW5kX3QgKmNtZCwKK2NoYXIgKm5neF9jb25mX3NldF9zdHJfYXJyYXlfc2xvdChuZ3hfY29uZl90ICpjZiwgbmd4X2NvbW1hbmRfdCAqY21kLAogICAgIHZvaWQgKmNvbmYpOworY2hhciAqbmd4X2NvbmZfc2V0X2tleXZhbF9zbG90KG5neF9jb25mX3QgKmNmLCBuZ3hfY29tbWFuZF90ICpjbWQsIHZvaWQgKmNvbmYpOwogY2hhciAqbmd4X2NvbmZfc2V0X251bV9zbG90KG5neF9jb25mX3QgKmNmLCBuZ3hfY29tbWFuZF90ICpjbWQsIHZvaWQgKmNvbmYpOwogY2hhciAqbmd4X2NvbmZfc2V0X3NpemVfc2xvdChuZ3hfY29uZl90ICpjZiwgbmd4X2NvbW1hbmRfdCAqY21kLCB2b2lkICpjb25mKTsKIGNoYXIgKm5neF9jb25mX3NldF9tc2VjX3Nsb3Qobmd4X2NvbmZfdCAqY2YsIG5neF9jb21tYW5kX3QgKmNtZCwgdm9pZCAqY29uZik7CmRpZmYgLS1naXQgYS9zcmMvY29yZS9uZ3hfaGFzaC5jIGIvc3JjL2NvcmUvbmd4X2hhc2guYwppbmRleCAwZWU1ZTc3Li4wZTliYzJjIDEwMDY0NAotLS0gYS9zcmMvY29yZS9uZ3hfaGFzaC5jCisrKyBiL3NyYy9jb3JlL25neF9oYXNoLmMKQEAgLTUyNSwxODAgKzUyNSw2IEBACiAKIAogbmd4X2ludF90Ci1uZ3hfaGFzaDBfaW5pdChuZ3hfaGFzaDBfdCAqaGFzaCwgbmd4X3Bvb2xfdCAqcG9vbCwgdm9pZCAqbmFtZXMsCi0gICAgbmd4X3VpbnRfdCBuZWx0cykKLXsKLSAgICB1X2NoYXIgICAgICAqcDsKLSAgICBuZ3hfc3RyX3QgICAqbmFtZSwgKmJ1Y2tldDsKLSAgICBuZ3hfdWludF90ICAgaSwgbiwga2V5LCBzaXplLCBiZXN0LCAqdGVzdCwgYnVja2V0cywgbWluX2J1Y2tldHM7Ci0KLSAgICBpZiAobmVsdHMgPT0gMCkgewotICAgICAgICBmb3IgKG5hbWUgPSAobmd4X3N0cl90ICopIG5hbWVzOwotICAgICAgICAgICAgIG5hbWUtPmxlbjsKLSAgICAgICAgICAgICBuYW1lID0gKG5neF9zdHJfdCAqKSAoKGNoYXIgKikgbmFtZSArIGhhc2gtPmJ1Y2tldF9zaXplKSkKLSAgICAgICAgewotICAgICAgICAgICAgbmVsdHMrKzsKLSAgICAgICAgfQotICAgIH0KLQotICAgIHRlc3QgPSBuZ3hfYWxsb2MoaGFzaC0+bWF4X3NpemUgKiBzaXplb2Yobmd4X3VpbnRfdCksIHBvb2wtPmxvZyk7Ci0gICAgaWYgKHRlc3QgPT0gTlVMTCkgewotICAgICAgICByZXR1cm4gTkdYX0VSUk9SOwotICAgIH0KLQotICAgIG1pbl9idWNrZXRzID0gaGFzaC0+YnVja2V0X2xpbWl0ICsgMTsKLQotI2lmIChOR1hfU1VQUFJFU1NfV0FSTikKLSAgICBiZXN0ID0gMDsKLSNlbmRpZgotCi0gICAgZm9yIChzaXplID0gMTsgc2l6ZSA8IGhhc2gtPm1heF9zaXplOyBzaXplKyspIHsKLQotICAgICAgICBidWNrZXRzID0gMDsKLQotICAgICAgICBmb3IgKGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7Ci0gICAgICAgICAgICB0ZXN0W2ldID0gMDsKLSAgICAgICAgfQotCi0gICAgICAgIGZvciAobiA9IDAsIG5hbWUgPSAobmd4X3N0cl90ICopIG5hbWVzOwotICAgICAgICAgICAgIG4gPCBuZWx0czsKLSAgICAgICAgICAgICBuKyssIG5hbWUgPSAobmd4X3N0cl90ICopICgoY2hhciAqKSBuYW1lICsgaGFzaC0+YnVja2V0X3NpemUpKQotICAgICAgICB7Ci0gICAgICAgICAgICBpZiAobmFtZS0+ZGF0YSA9PSBOVUxMKSB7Ci0gICAgICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAgICAgICB9Ci0KLSAgICAgICAgICAgIGtleSA9IDA7Ci0KLSAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBuYW1lLT5sZW47IGkrKykgewotICAgICAgICAgICAgICAgIGtleSArPSBuZ3hfdG9sb3dlcihuYW1lLT5kYXRhW2ldKTsKLSAgICAgICAgICAgIH0KLQotICAgICAgICAgICAga2V5ICU9IHNpemU7Ci0KLSAgICAgICAgICAgIGlmICh0ZXN0W2tleV0gPT0gaGFzaC0+YnVja2V0X2xpbWl0KSB7Ci0gICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICB9Ci0KLSAgICAgICAgICAgIHRlc3Rba2V5XSsrOwotCi0gICAgICAgICAgICBpZiAoYnVja2V0cyA8IHRlc3Rba2V5XSkgewotICAgICAgICAgICAgICAgIGJ1Y2tldHMgPSB0ZXN0W2tleV07Ci0gICAgICAgICAgICB9Ci0gICAgICAgIH0KLQotICAgICAgICBpZiAobiA9PSBuZWx0cykgewotICAgICAgICAgICAgaWYgKG1pbl9idWNrZXRzID4gYnVja2V0cykgewotICAgICAgICAgICAgICAgIG1pbl9idWNrZXRzID0gYnVja2V0czsKLSAgICAgICAgICAgICAgICBiZXN0ID0gc2l6ZTsKLSAgICAgICAgICAgIH0KLQotICAgICAgICAgICAgaWYgKGhhc2gtPmJ1Y2tldF9saW1pdCA9PSAxKSB7Ci0gICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICB9Ci0gICAgICAgIH0KLSAgICB9Ci0KLSAgICBpZiAobWluX2J1Y2tldHMgPT0gaGFzaC0+YnVja2V0X2xpbWl0ICsgMSkgewotICAgICAgICBuZ3hfbG9nX2Vycm9yKE5HWF9MT0dfRU1FUkcsIHBvb2wtPmxvZywgMCwKLSAgICAgICAgICAgICAgICAgICAgICAiY291bGQgbm90IGJ1aWxkIHRoZSAlcyBoYXNoLCB5b3Ugc2hvdWxkIGluY3JlYXNlICIKLSAgICAgICAgICAgICAgICAgICAgICAiZWl0aGVyICVzX3NpemU6ICVpIG9yICVzX2J1Y2tldF9saW1pdDogJWkiLAotICAgICAgICAgICAgICAgICAgICAgIGhhc2gtPm5hbWUsIGhhc2gtPm5hbWUsIGhhc2gtPm1heF9zaXplLAotICAgICAgICAgICAgICAgICAgICAgIGhhc2gtPm5hbWUsIGhhc2gtPmJ1Y2tldF9saW1pdCk7Ci0gICAgICAgIG5neF9mcmVlKHRlc3QpOwotICAgICAgICByZXR1cm4gTkdYX0VSUk9SOwotICAgIH0KLQotICAgIGhhc2gtPmJ1Y2tldHMgPSBuZ3hfcGNhbGxvYyhwb29sLCBiZXN0ICogaGFzaC0+YnVja2V0X3NpemUpOwotICAgIGlmIChoYXNoLT5idWNrZXRzID09IE5VTEwpIHsKLSAgICAgICAgbmd4X2ZyZWUodGVzdCk7Ci0gICAgICAgIHJldHVybiBOR1hfRVJST1I7Ci0gICAgfQotCi0gICAgaWYgKGhhc2gtPmJ1Y2tldF9saW1pdCAhPSAxKSB7Ci0KLSAgICAgICAgZm9yIChpID0gMDsgaSA8IGJlc3Q7IGkrKykgewotICAgICAgICAgICAgdGVzdFtpXSA9IDA7Ci0gICAgICAgIH0KLQotICAgICAgICBmb3IgKG4gPSAwLCBuYW1lID0gKG5neF9zdHJfdCAqKSBuYW1lczsKLSAgICAgICAgICAgICBuIDwgbmVsdHM7Ci0gICAgICAgICAgICAgbisrLCBuYW1lID0gKG5neF9zdHJfdCAqKSAoKGNoYXIgKikgbmFtZSArIGhhc2gtPmJ1Y2tldF9zaXplKSkKLSAgICAgICAgewotICAgICAgICAgICAgaWYgKG5hbWUtPmRhdGEgPT0gTlVMTCkgewotICAgICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICAgICAgfQotCi0gICAgICAgICAgICBrZXkgPSAwOwotCi0gICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgbmFtZS0+bGVuOyBpKyspIHsKLSAgICAgICAgICAgICAgICBrZXkgKz0gbmd4X3RvbG93ZXIobmFtZS0+ZGF0YVtpXSk7Ci0gICAgICAgICAgICB9Ci0KLSAgICAgICAgICAgIGtleSAlPSBiZXN0OwotCi0gICAgICAgICAgICB0ZXN0W2tleV0rKzsKLSAgICAgICAgfQotCi0gICAgICAgIGZvciAoaSA9IDA7IGkgPCBiZXN0OyBpKyspIHsKLSAgICAgICAgICAgIGlmICh0ZXN0W2ldID09IDApIHsKLSAgICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIH0KLQotICAgICAgICAgICAgYnVja2V0ID0gbmd4X3BhbGxvYyhwb29sLCB0ZXN0W2ldICogaGFzaC0+YnVja2V0X3NpemUpOwotICAgICAgICAgICAgaWYgKGJ1Y2tldCA9PSBOVUxMKSB7Ci0gICAgICAgICAgICAgICAgbmd4X2ZyZWUodGVzdCk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuIE5HWF9FUlJPUjsKLSAgICAgICAgICAgIH0KLQotICAgICAgICAgICAgaGFzaC0+YnVja2V0c1tpXSA9IGJ1Y2tldDsKLSAgICAgICAgICAgIGJ1Y2tldC0+bGVuID0gMDsKLSAgICAgICAgfQotICAgIH0KLQotICAgIGZvciAobiA9IDAsIG5hbWUgPSAobmd4X3N0cl90ICopIG5hbWVzOwotICAgICAgICAgbiA8IG5lbHRzOwotICAgICAgICAgbisrLCBuYW1lID0gKG5neF9zdHJfdCAqKSAoKGNoYXIgKikgbmFtZSArIGhhc2gtPmJ1Y2tldF9zaXplKSkKLSAgICB7Ci0gICAgICAgIGlmIChuYW1lLT5kYXRhID09IE5VTEwpIHsKLSAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICB9Ci0KLSAgICAgICAga2V5ID0gMDsKLQotICAgICAgICBmb3IgKGkgPSAwOyBpIDwgbmFtZS0+bGVuOyBpKyspIHsKLSAgICAgICAgICAgIGtleSArPSBuZ3hfdG9sb3dlcihuYW1lLT5kYXRhW2ldKTsKLSAgICAgICAgfQotCi0gICAgICAgIGtleSAlPSBiZXN0OwotCi0gICAgICAgIGlmIChoYXNoLT5idWNrZXRfbGltaXQgPT0gMSkgewotICAgICAgICAgICAgcCA9ICh1X2NoYXIgKikgaGFzaC0+YnVja2V0cyArIGtleSAqIGhhc2gtPmJ1Y2tldF9zaXplOwotICAgICAgICAgICAgbmd4X21lbWNweShwLCBuYW1lLCBoYXNoLT5idWNrZXRfc2l6ZSk7Ci0gICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgfQotCi0gICAgICAgIGZvciAoYnVja2V0ID0gaGFzaC0+YnVja2V0c1trZXldOwotICAgICAgICAgICAgIGJ1Y2tldC0+bGVuOwotICAgICAgICAgICAgIGJ1Y2tldCA9IChuZ3hfc3RyX3QgKikgKChjaGFyICopIGJ1Y2tldCArIGhhc2gtPmJ1Y2tldF9zaXplKSkKLSAgICAgICAgewotICAgICAgICAgICAgYnVja2V0LT5sZW4gJj0gMHg3ZmZmZmZmZjsKLSAgICAgICAgfQotCi0gICAgICAgIG5neF9tZW1jcHkoYnVja2V0LCBuYW1lLCBoYXNoLT5idWNrZXRfc2l6ZSk7Ci0gICAgICAgIGJ1Y2tldC0+bGVuIHw9IDB4ODAwMDAwMDA7Ci0gICAgfQotCi0gICAgbmd4X2ZyZWUodGVzdCk7Ci0KLSAgICBoYXNoLT5oYXNoX3NpemUgPSBiZXN0OwotICAgIGhhc2gtPm1pbl9idWNrZXRzID0gbWluX2J1Y2tldHM7Ci0KLSAgICByZXR1cm4gTkdYX09LOwotfQotCi0KLW5neF9pbnRfdAogbmd4X2hhc2hfa2V5c19hcnJheV9pbml0KG5neF9oYXNoX2tleXNfYXJyYXlzX3QgKmhhLCBuZ3hfdWludF90IHR5cGUpCiB7CiAgICAgbmd4X3VpbnRfdCAgYXNpemU7CmRpZmYgLS1naXQgYS9zcmMvY29yZS9uZ3hfaGFzaC5oIGIvc3JjL2NvcmUvbmd4X2hhc2guaAppbmRleCBhZDczNDM4Li5kYThiN2UwIDEwMDY0NAotLS0gYS9zcmMvY29yZS9uZ3hfaGFzaC5oCisrKyBiL3NyYy9jb3JlL25neF9oYXNoLmgKQEAgLTk0LDYgKzk0LDcgQEAKICAgICBuZ3hfdWludF90ICAgICAgICBoYXNoOwogICAgIG5neF9zdHJfdCAgICAgICAgIGtleTsKICAgICBuZ3hfc3RyX3QgICAgICAgICB2YWx1ZTsKKyAgICB1X2NoYXIgICAgICAgICAgICpsb3djYXNlX2tleTsKIH0gbmd4X3RhYmxlX2VsdF90OwogCiAKQEAgLTEwNiw3ICsxMDcsNyBAQAogbmd4X2ludF90IG5neF9oYXNoX3dpbGRjYXJkX2luaXQobmd4X2hhc2hfaW5pdF90ICpoaW5pdCwgbmd4X2hhc2hfa2V5X3QgKm5hbWVzLAogICAgIG5neF91aW50X3QgbmVsdHMpOwogCi0jZGVmaW5lIG5neF9oYXNoKGtleSwgYykgICBrZXkgKiAzMSArIGMKKyNkZWZpbmUgbmd4X2hhc2goa2V5LCBjKSAgICgobmd4X3VpbnRfdCkga2V5ICogMzEgKyBjKQogbmd4X3VpbnRfdCBuZ3hfaGFzaF9rZXkodV9jaGFyICpkYXRhLCBzaXplX3QgbGVuKTsKIG5neF91aW50X3Qgbmd4X2hhc2hfa2V5X2xjKHVfY2hhciAqZGF0YSwgc2l6ZV90IGxlbik7CiAKQEAgLTExNSw5ICsxMTYsNCBAQAogICAgIHZvaWQgKnZhbHVlLCBuZ3hfdWludF90IGZsYWdzKTsKIAogCi0jZGVmaW5lIG5neF9oYXNoMChrZXksIGMpICAga2V5ICsgYwotbmd4X2ludF90IG5neF9oYXNoMF9pbml0KG5neF9oYXNoMF90ICpoYXNoLCBuZ3hfcG9vbF90ICpwb29sLCB2b2lkICpuYW1lcywKLSAgICBuZ3hfdWludF90IG5lbHRzKTsKLQotCiAjZW5kaWYgLyogX05HWF9IQVNIX0hfSU5DTFVERURfICovCmRpZmYgLS1naXQgYS9zcmMvY29yZS9uZ3hfc3RyaW5nLmggYi9zcmMvY29yZS9uZ3hfc3RyaW5nLmgKaW5kZXggZDc2YTBmNS4uODE4YTI5MCAxMDA2NDQKLS0tIGEvc3JjL2NvcmUvbmd4X3N0cmluZy5oCisrKyBiL3NyYy9jb3JlL25neF9zdHJpbmcuaApAQCAtMTMsMTEgKzEzLDE3IEBACiAKIAogdHlwZWRlZiBzdHJ1Y3QgewotICAgIHNpemVfdCAgICBsZW47Ci0gICAgdV9jaGFyICAgKmRhdGE7CisgICAgc2l6ZV90ICAgICBsZW47CisgICAgdV9jaGFyICAgICpkYXRhOwogfSBuZ3hfc3RyX3Q7CiAKIAordHlwZWRlZiBzdHJ1Y3QgeworICAgIG5neF9zdHJfdCAga2V5OworICAgIG5neF9zdHJfdCAgdmFsdWU7Cit9IG5neF9rZXl2YWxfdDsKKworCiAjZGVmaW5lIG5neF9zdHJpbmcoc3RyKSAgeyBzaXplb2Yoc3RyKSAtIDEsICh1X2NoYXIgKikgc3RyIH0KICNkZWZpbmUgbmd4X251bGxfc3RyaW5nICB7IDAsIE5VTEwgfQogCmRpZmYgLS1naXQgYS9zcmMvaHR0cC9tb2R1bGVzL25neF9odHRwX2Zhc3RjZ2lfbW9kdWxlLmMgYi9zcmMvaHR0cC9tb2R1bGVzL25neF9odHRwX2Zhc3RjZ2lfbW9kdWxlLmMKaW5kZXggZmY1NTExOC4uNzc3YTdkZCAxMDA2NDQKLS0tIGEvc3JjL2h0dHAvbW9kdWxlcy9uZ3hfaHR0cF9mYXN0Y2dpX21vZHVsZS5jCisrKyBiL3NyYy9odHRwL21vZHVsZXMvbmd4X2h0dHBfZmFzdGNnaV9tb2R1bGUuYwpAQCAtMjQ2LDEzICsyNDYsNiBAQAogICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfZmFzdGNnaV9sb2NfY29uZl90LCB1cHN0cmVhbS5yZWRpcmVjdF9lcnJvcnMpLAogICAgICAgTlVMTCB9LAogCi0gICAgeyBuZ3hfc3RyaW5nKCJmYXN0Y2dpX3hfcG93ZXJlZF9ieSIpLAotICAgICAgTkdYX0hUVFBfTUFJTl9DT05GfE5HWF9IVFRQX1NSVl9DT05GfE5HWF9IVFRQX0xPQ19DT05GfE5HWF9DT05GX0ZMQUcsCi0gICAgICBuZ3hfY29uZl9zZXRfZmxhZ19zbG90LAotICAgICAgTkdYX0hUVFBfTE9DX0NPTkZfT0ZGU0VULAotICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfZmFzdGNnaV9sb2NfY29uZl90LCB1cHN0cmVhbS5wYXNzX3hfcG93ZXJlZF9ieSksCi0gICAgICBOVUxMIH0sCi0KICAgICB7IG5neF9zdHJpbmcoImZhc3RjZ2lfcmVhZF90aW1lb3V0IiksCiAgICAgICBOR1hfSFRUUF9NQUlOX0NPTkZ8TkdYX0hUVFBfU1JWX0NPTkZ8TkdYX0hUVFBfTE9DX0NPTkZ8TkdYX0NPTkZfVEFLRTEsCiAgICAgICBuZ3hfY29uZl9zZXRfbXNlY19zbG90LApAQCAtMzE4LDExICszMTEsMjUgQEAKIAogICAgIHsgbmd4X3N0cmluZygiZmFzdGNnaV9wYXJhbSIpLAogICAgICAgTkdYX0hUVFBfTUFJTl9DT05GfE5HWF9IVFRQX1NSVl9DT05GfE5HWF9IVFRQX0xPQ19DT05GfE5HWF9DT05GX1RBS0UyLAotICAgICAgbmd4X2NvbmZfc2V0X3RhYmxlX2VsdF9zbG90LAorICAgICAgbmd4X2NvbmZfc2V0X2tleXZhbF9zbG90LAogICAgICAgTkdYX0hUVFBfTE9DX0NPTkZfT0ZGU0VULAogICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfZmFzdGNnaV9sb2NfY29uZl90LCBwYXJhbXNfc291cmNlKSwKICAgICAgIE5VTEwgfSwKIAorICAgIHsgbmd4X3N0cmluZygiZmFzdGNnaV9wYXNzX2hlYWRlciIpLAorICAgICAgTkdYX0hUVFBfTUFJTl9DT05GfE5HWF9IVFRQX1NSVl9DT05GfE5HWF9IVFRQX0xPQ19DT05GfE5HWF9DT05GX0ZMQUcsCisgICAgICBuZ3hfY29uZl9zZXRfc3RyX2FycmF5X3Nsb3QsCisgICAgICBOR1hfSFRUUF9MT0NfQ09ORl9PRkZTRVQsCisgICAgICBvZmZzZXRvZihuZ3hfaHR0cF9mYXN0Y2dpX2xvY19jb25mX3QsIHVwc3RyZWFtLnBhc3NfaGVhZGVycyksCisgICAgICBOVUxMIH0sCisKKyAgICB7IG5neF9zdHJpbmcoImZhc3RjZ2lfaGlkZV9oZWFkZXIiKSwKKyAgICAgIE5HWF9IVFRQX01BSU5fQ09ORnxOR1hfSFRUUF9TUlZfQ09ORnxOR1hfSFRUUF9MT0NfQ09ORnxOR1hfQ09ORl9GTEFHLAorICAgICAgbmd4X2NvbmZfc2V0X3N0cl9hcnJheV9zbG90LAorICAgICAgTkdYX0hUVFBfTE9DX0NPTkZfT0ZGU0VULAorICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfZmFzdGNnaV9sb2NfY29uZl90LCB1cHN0cmVhbS5oaWRlX2hlYWRlcnMpLAorICAgICAgTlVMTCB9LAorCiAgICAgICBuZ3hfbnVsbF9jb21tYW5kCiB9OwogCkBAIC0zNTgsNiArMzY1LDE2IEBACiB9OwogCiAKK3N0YXRpYyBuZ3hfc3RyX3QgIG5neF9odHRwX2Zhc3RjZ2lfaGlkZV9oZWFkZXJzW10gPSB7CisgICAgbmd4X3N0cmluZygiU3RhdHVzIiksCisgICAgbmd4X3N0cmluZygiWC1BY2NlbC1FeHBpcmVzIiksCisgICAgbmd4X3N0cmluZygiWC1BY2NlbC1SZWRpcmVjdCIpLAorICAgIG5neF9zdHJpbmcoIlgtQWNjZWwtTGltaXQtUmF0ZSIpLAorICAgIG5neF9zdHJpbmcoIlgtQWNjZWwtQnVmZmVyIiksCisgICAgbmd4X251bGxfc3RyaW5nCit9OworCisKIHN0YXRpYyBuZ3hfaW50X3QKIG5neF9odHRwX2Zhc3RjZ2lfaGFuZGxlcihuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIpCiB7CkBAIC0zOTAsNiArNDA3LDggQEAKICAgICB1LT5hYm9ydF9yZXF1ZXN0ID0gbmd4X2h0dHBfZmFzdGNnaV9hYm9ydF9yZXF1ZXN0OwogICAgIHUtPmZpbmFsaXplX3JlcXVlc3QgPSBuZ3hfaHR0cF9mYXN0Y2dpX2ZpbmFsaXplX3JlcXVlc3Q7CiAKKyAgICB1LT5idWZmZXJpbmcgPSAxOworCiAgICAgdS0+cGlwZSA9IG5neF9wY2FsbG9jKHItPnBvb2wsIHNpemVvZihuZ3hfZXZlbnRfcGlwZV90KSk7CiAgICAgaWYgKHUtPnBpcGUgPT0gTlVMTCkgewogICAgICAgICByZXR1cm4gTkdYX0hUVFBfSU5URVJOQUxfU0VSVkVSX0VSUk9SOwpAQCAtNzk2LDcgKzgxNSw3IEBACiAgICAgdV9jaGFyICAgICAgICAgICAgICAgICAgICAgICAgICpzdGFydCwgKmxhc3Q7CiAgICAgbmd4X3N0cl90ICAgICAgICAgICAgICAgICAgICAgICpzdGF0dXNfbGluZSwgbGluZTsKICAgICBuZ3hfaW50X3QgICAgICAgICAgICAgICAgICAgICAgIHJjLCBzdGF0dXM7Ci0gICAgbmd4X3VpbnRfdCAgICAgICAgICAgICAgICAgICAgICBrZXk7CisgICAgbmd4X3VpbnRfdCAgICAgICAgICAgICAgICAgICAgICBpOwogICAgIG5neF90YWJsZV9lbHRfdCAgICAgICAgICAgICAgICAqaDsKICAgICBuZ3hfaHR0cF91cHN0cmVhbV90ICAgICAgICAgICAgKnU7CiAgICAgbmd4X2h0dHBfZmFzdGNnaV9jdHhfdCAgICAgICAgICpmOwpAQCAtODA2LDcgKzgyNSw2IEBACiAgICAgZiA9IG5neF9odHRwX2dldF9tb2R1bGVfY3R4KHIsIG5neF9odHRwX2Zhc3RjZ2lfbW9kdWxlKTsKIAogICAgIHVtY2YgPSBuZ3hfaHR0cF9nZXRfbW9kdWxlX21haW5fY29uZihyLCBuZ3hfaHR0cF91cHN0cmVhbV9tb2R1bGUpOwotICAgIGhoID0gKG5neF9odHRwX3Vwc3RyZWFtX2hlYWRlcl90ICopIHVtY2YtPmhlYWRlcnNfaW5faGFzaC5idWNrZXRzOwogCiAgICAgaWYgKGYgPT0gTlVMTCkgewogICAgICAgICBmID0gbmd4X3BjYWxsb2Moci0+cG9vbCwgc2l6ZW9mKG5neF9odHRwX2Zhc3RjZ2lfY3R4X3QpKTsKQEAgLTk4MCwyNiArOTk4LDM0IEBACiAgICAgICAgICAgICAgICAgaC0+dmFsdWUubGVuID0gci0+aGVhZGVyX2VuZCAtIHItPmhlYWRlcl9zdGFydDsKIAogICAgICAgICAgICAgICAgIGgtPmtleS5kYXRhID0gbmd4X3BhbGxvYyhyLT5wb29sLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoLT5rZXkubGVuICsgMSArIGgtPnZhbHVlLmxlbiArIDEpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGgtPmtleS5sZW4gKyAxICsgaC0+dmFsdWUubGVuICsgMSArIGgtPmtleS5sZW4pOwogICAgICAgICAgICAgICAgIGlmIChoLT5rZXkuZGF0YSA9PSBOVUxMKSB7CiAgICAgICAgICAgICAgICAgICAgIHJldHVybiBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CiAgICAgICAgICAgICAgICAgfQogCiAgICAgICAgICAgICAgICAgaC0+dmFsdWUuZGF0YSA9IGgtPmtleS5kYXRhICsgaC0+a2V5LmxlbiArIDE7CisgICAgICAgICAgICAgICAgaC0+bG93Y2FzZV9rZXkgPSBoLT5rZXkuZGF0YSArIGgtPmtleS5sZW4gKyAxCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICArIGgtPnZhbHVlLmxlbiArIDE7CiAKICAgICAgICAgICAgICAgICBuZ3hfY3B5c3RybihoLT5rZXkuZGF0YSwgci0+aGVhZGVyX25hbWVfc3RhcnQsIGgtPmtleS5sZW4gKyAxKTsKICAgICAgICAgICAgICAgICBuZ3hfY3B5c3RybihoLT52YWx1ZS5kYXRhLCByLT5oZWFkZXJfc3RhcnQsIGgtPnZhbHVlLmxlbiArIDEpOwogCi0gICAgICAgICAgICAgICAga2V5ID0gaC0+aGFzaCAlIHVtY2YtPmhlYWRlcnNfaW5faGFzaC5oYXNoX3NpemU7CisgICAgICAgICAgICAgICAgaWYgKGgtPmtleS5sZW4gPT0gci0+bG93Y2FzZV9pbmRleCkgeworICAgICAgICAgICAgICAgICAgICBuZ3hfbWVtY3B5KGgtPmxvd2Nhc2Vfa2V5LCByLT5sb3djYXNlX2hlYWRlciwgaC0+a2V5Lmxlbik7CiAKLSAgICAgICAgICAgICAgICBpZiAoaGhba2V5XS5uYW1lLmxlbiA9PSBoLT5rZXkubGVuCi0gICAgICAgICAgICAgICAgICAgICYmIG5neF9zdHJjYXNlY21wKGhoW2tleV0ubmFtZS5kYXRhLCBoLT5rZXkuZGF0YSkgPT0gMCkKLSAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgIGlmIChoaFtrZXldLmhhbmRsZXIociwgaCwgaGhba2V5XS5vZmZzZXQpICE9IE5HWF9PSykgewotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIE5HWF9IVFRQX0lOVEVSTkFMX1NFUlZFUl9FUlJPUjsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgaC0+a2V5LmxlbjsgaSsrKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBoLT5sb3djYXNlX2tleVtpXSA9IG5neF90b2xvd2VyKGgtPmxvd2Nhc2Vfa2V5W2ldKTsKICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgIH0KIAorICAgICAgICAgICAgICAgIGhoID0gbmd4X2hhc2hfZmluZCgmdW1jZi0+aGVhZGVyc19pbl9oYXNoLCBoLT5oYXNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoLT5sb3djYXNlX2tleSwgaC0+a2V5Lmxlbik7CisKKyAgICAgICAgICAgICAgICBpZiAoaGggJiYgaGgtPmhhbmRsZXIociwgaCwgaGgtPm9mZnNldCkgIT0gTkdYX09LKSB7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CisgICAgICAgICAgICAgICAgfQorCiAgICAgICAgICAgICAgICAgbmd4X2xvZ19kZWJ1ZzIoTkdYX0xPR19ERUJVR19IVFRQLCByLT5jb25uZWN0aW9uLT5sb2csIDAsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImh0dHAgZmFzdGNnaSBoZWFkZXI6IFwiJVY6ICVWXCIiLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZoLT5rZXksICZoLT52YWx1ZSk7CkBAIC0xNDc0LDkgKzE1MDAsMTEgQEAKICAgICAgKiBzZXQgYnkgbmd4X3BjYWxsb2MoKToKICAgICAgKgogICAgICAqICAgICBjb25mLT51cHN0cmVhbS5idWZzLm51bSA9IDA7Ci0gICAgICogICAgIGNvbmYtPnVwc3RyZWFtLnBhdGggPSBOVUxMOwogICAgICAqICAgICBjb25mLT51cHN0cmVhbS5uZXh0X3Vwc3RyZWFtID0gMDsKICAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0udGVtcF9wYXRoID0gTlVMTDsKKyAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzX2hhc2ggPSB7IE5VTEwsIDAgfTsKKyAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzID0gTlVMTDsKKyAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0ucGFzc19oZWFkZXJzID0gTlVMTDsKICAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0uc2NoZW1hID0geyAwLCBOVUxMIH07CiAgICAgICogICAgIGNvbmYtPnVwc3RyZWFtLnVyaSA9IHsgMCwgTlVMTCB9OwogICAgICAqICAgICBjb25mLT51cHN0cmVhbS5sb2NhdGlvbiA9IE5VTEw7CkBAIC0xNTEwLDEyICsxNTM4LDYgQEAKICAgICAvKiAiZmFzdGNnaV9jeWNsaWNfdGVtcF9maWxlIiBpcyBkaXNhYmxlZCAqLwogICAgIGNvbmYtPnVwc3RyZWFtLmN5Y2xpY190ZW1wX2ZpbGUgPSAwOwogCi0gICAgY29uZi0+dXBzdHJlYW0ucGFzc194X3Bvd2VyZWRfYnkgPSBOR1hfQ09ORl9VTlNFVDsKLQotICAgIC8qIHRoZSBoYXJkY29kZWQgdmFsdWVzICovCi0gICAgY29uZi0+dXBzdHJlYW0ucGFzc19zZXJ2ZXIgPSAxOwotICAgIGNvbmYtPnVwc3RyZWFtLnBhc3NfZGF0ZSA9IDE7Ci0KICAgICByZXR1cm4gY29uZjsKIH0KIApAQCAtMTUyOSw4ICsxNTUxLDEyIEBACiAgICAgdV9jaGFyICAgICAgICAgICAgICAgICAgICAgICAqcDsKICAgICBzaXplX3QgICAgICAgICAgICAgICAgICAgICAgICBzaXplOwogICAgIHVpbnRwdHJfdCAgICAgICAgICAgICAgICAgICAgKmNvZGU7Ci0gICAgbmd4X3VpbnRfdCAgICAgICAgICAgICAgICAgICAgaTsKLSAgICBuZ3hfdGFibGVfZWx0X3QgICAgICAgICAgICAgICpzcmM7CisgICAgbmd4X3N0cl90ICAgICAgICAgICAgICAgICAgICAqaGVhZGVyOworICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgIGksIGo7CisgICAgbmd4X2FycmF5X3QgICAgICAgICAgICAgICAgICAgaGlkZV9oZWFkZXJzOworICAgIG5neF9rZXl2YWxfdCAgICAgICAgICAgICAgICAgKnNyYzsKKyAgICBuZ3hfaGFzaF9rZXlfdCAgICAgICAgICAgICAgICpoazsKKyAgICBuZ3hfaGFzaF9pbml0X3QgICAgICAgICAgICAgICBoYXNoOwogICAgIG5neF9odHRwX3NjcmlwdF9jb21waWxlX3QgICAgIHNjOwogICAgIG5neF9odHRwX3NjcmlwdF9jb3B5X2NvZGVfdCAgKmNvcHk7CiAKQEAgLTE2ODIsMTIgKzE3MDgsMTExIEBACiAgICAgbmd4X2NvbmZfbWVyZ2VfdmFsdWUoY29uZi0+dXBzdHJlYW0ucmVkaXJlY3RfZXJyb3JzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJldi0+dXBzdHJlYW0ucmVkaXJlY3RfZXJyb3JzLCAwKTsKIAotICAgIG5neF9jb25mX21lcmdlX3ZhbHVlKGNvbmYtPnVwc3RyZWFtLnBhc3NfeF9wb3dlcmVkX2J5LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJldi0+dXBzdHJlYW0ucGFzc194X3Bvd2VyZWRfYnksIDEpOwotCiAKICAgICBuZ3hfY29uZl9tZXJnZV9zdHJfdmFsdWUoY29uZi0+aW5kZXgsIHByZXYtPmluZGV4LCAiIik7CiAKKyAgICBpZiAoY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzID09IE5VTEwKKyAgICAgICAgJiYgY29uZi0+dXBzdHJlYW0ucGFzc19oZWFkZXJzID09IE5VTEwpCisgICAgeworICAgICAgICBjb25mLT51cHN0cmVhbS5oaWRlX2hlYWRlcnMgPSBwcmV2LT51cHN0cmVhbS5oaWRlX2hlYWRlcnM7CisgICAgICAgIGNvbmYtPnVwc3RyZWFtLnBhc3NfaGVhZGVycyA9IHByZXYtPnVwc3RyZWFtLnBhc3NfaGVhZGVyczsKKyAgICAgICAgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzX2hhc2ggPSBwcmV2LT51cHN0cmVhbS5oaWRlX2hlYWRlcnNfaGFzaDsKKworICAgICAgICBpZiAoY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzX2hhc2guYnVja2V0cykgeworICAgICAgICAgICAgZ290byBwZWVyczsKKyAgICAgICAgfQorCisgICAgfSBlbHNlIHsKKyAgICAgICAgaWYgKGNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVycyA9PSBOVUxMKSB7CisgICAgICAgICAgICBjb25mLT51cHN0cmVhbS5oaWRlX2hlYWRlcnMgPSBwcmV2LT51cHN0cmVhbS5oaWRlX2hlYWRlcnM7CisgICAgICAgIH0KKworICAgICAgICBpZiAoY29uZi0+dXBzdHJlYW0ucGFzc19oZWFkZXJzID09IE5VTEwpIHsKKyAgICAgICAgICAgIGNvbmYtPnVwc3RyZWFtLnBhc3NfaGVhZGVycyA9IHByZXYtPnVwc3RyZWFtLnBhc3NfaGVhZGVyczsKKyAgICAgICAgfQorICAgIH0KKworICAgIGlmIChuZ3hfYXJyYXlfaW5pdCgmaGlkZV9oZWFkZXJzLCBjZi0+dGVtcF9wb29sLCA0LCBzaXplb2Yobmd4X2hhc2hfa2V5X3QpKQorICAgICAgICAhPSBOR1hfT0spCisgICAgeworICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CisgICAgfQorCisgICAgZm9yIChoZWFkZXIgPSBuZ3hfaHR0cF9mYXN0Y2dpX2hpZGVfaGVhZGVyczsgaGVhZGVyLT5sZW47IGhlYWRlcisrKSB7CisgICAgICAgIGhrID0gbmd4X2FycmF5X3B1c2goJmhpZGVfaGVhZGVycyk7CisgICAgICAgIGlmIChoayA9PSBOVUxMKSB7CisgICAgICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CisgICAgICAgIH0KKworICAgICAgICBoay0+a2V5ID0gKmhlYWRlcjsKKyAgICAgICAgaGstPmtleV9oYXNoID0gbmd4X2hhc2hfa2V5X2xjKGhlYWRlci0+ZGF0YSwgaGVhZGVyLT5sZW4pOworICAgICAgICBoay0+dmFsdWUgPSAodm9pZCAqKSAxOworICAgIH0KKworICAgIGlmIChjb25mLT51cHN0cmVhbS5oaWRlX2hlYWRlcnMpIHsKKworICAgICAgICBoZWFkZXIgPSBjb25mLT51cHN0cmVhbS5oaWRlX2hlYWRlcnMtPmVsdHM7CisKKyAgICAgICAgZm9yIChpID0gMDsgaSA8IGNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVycy0+bmVsdHM7IGkrKykgeworCisgICAgICAgICAgICBoayA9IGhpZGVfaGVhZGVycy5lbHRzOworCisgICAgICAgICAgICBmb3IgKGogPSAwOyBqIDwgaGlkZV9oZWFkZXJzLm5lbHRzOyBqKyspIHsKKyAgICAgICAgICAgICAgICBpZiAobmd4X3N0cmNhc2VjbXAoaGVhZGVyW2ldLmRhdGEsIGhrW2pdLmtleS5kYXRhKSA9PSAwKSB7CisgICAgICAgICAgICAgICAgICAgIGdvdG8gZXhpc3Q7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorCisgICAgICAgICAgICBoayA9IG5neF9hcnJheV9wdXNoKCZoaWRlX2hlYWRlcnMpOworICAgICAgICAgICAgaWYgKGhrID09IE5VTEwpIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGhrLT5rZXkgPSBoZWFkZXJbaV07CisgICAgICAgICAgICBoay0+a2V5X2hhc2ggPSBuZ3hfaGFzaF9rZXlfbGMoaGVhZGVyW2ldLmRhdGEsIGhlYWRlcltpXS5sZW4pOworICAgICAgICAgICAgaGstPnZhbHVlID0gKHZvaWQgKikgMTsKKworICAgICAgICBleGlzdDoKKworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAoY29uZi0+dXBzdHJlYW0ucGFzc19oZWFkZXJzKSB7CisKKyAgICAgICAgaGsgPSBoaWRlX2hlYWRlcnMuZWx0czsKKyAgICAgICAgaGVhZGVyID0gY29uZi0+dXBzdHJlYW0ucGFzc19oZWFkZXJzLT5lbHRzOworCisgICAgICAgIGZvciAoaSA9IDA7IGkgPCBjb25mLT51cHN0cmVhbS5wYXNzX2hlYWRlcnMtPm5lbHRzOyBpKyspIHsKKworICAgICAgICAgICAgZm9yIChqID0gMDsgaiA8IGhpZGVfaGVhZGVycy5uZWx0czsgaisrKSB7CisKKyAgICAgICAgICAgICAgICBpZiAoaGtbal0ua2V5LmRhdGEgPT0gTlVMTCkgeworICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICBpZiAobmd4X3N0cmNhc2VjbXAoaGVhZGVyW2ldLmRhdGEsIGhrW2pdLmtleS5kYXRhKSA9PSAwKSB7CisgICAgICAgICAgICAgICAgICAgIGhrW2pdLmtleS5kYXRhID0gTlVMTDsKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorCisgICAgaGFzaC5oYXNoID0gJmNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVyc19oYXNoOworICAgIGhhc2gua2V5ID0gbmd4X2hhc2hfa2V5X2xjOworICAgIGhhc2gubWF4X3NpemUgPSA1MTI7CisgICAgaGFzaC5idWNrZXRfc2l6ZSA9IG5neF9jYWNoZWxpbmVfc2l6ZTsKKyAgICBoYXNoLm5hbWUgPSAiZmFzdGNnaV9oaWRlX2hlYWRlcnNfaGFzaCI7CisgICAgaGFzaC5wb29sID0gY2YtPnBvb2w7CisgICAgaGFzaC50ZW1wX3Bvb2wgPSBOVUxMOworCisgICAgaWYgKG5neF9oYXNoX2luaXQoJmhhc2gsIGhpZGVfaGVhZGVycy5lbHRzLCBoaWRlX2hlYWRlcnMubmVsdHMpICE9IE5HWF9PSykgeworICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CisgICAgfQorCitwZWVyczoKKwogICAgIGlmIChjb25mLT5wZWVycyA9PSBOVUxMKSB7CiAgICAgICAgIGNvbmYtPnBlZXJzID0gcHJldi0+cGVlcnM7CiAgICAgICAgIGNvbmYtPnVwc3RyZWFtLnNjaGVtYSA9IHByZXYtPnVwc3RyZWFtLnNjaGVtYTsKZGlmZiAtLWdpdCBhL3NyYy9odHRwL21vZHVsZXMvbmd4X2h0dHBfbWVtY2FjaGVkX21vZHVsZS5jIGIvc3JjL2h0dHAvbW9kdWxlcy9uZ3hfaHR0cF9tZW1jYWNoZWRfbW9kdWxlLmMKaW5kZXggYWNlODcyMy4uNjM4NGFmMCAxMDA2NDQKLS0tIGEvc3JjL2h0dHAvbW9kdWxlcy9uZ3hfaHR0cF9tZW1jYWNoZWRfbW9kdWxlLmMKKysrIGIvc3JjL2h0dHAvbW9kdWxlcy9uZ3hfaHR0cF9tZW1jYWNoZWRfbW9kdWxlLmMKQEAgLTUyNCwxMSArNTI0LDggQEAKICAgICBjb25mLT51cHN0cmVhbS5idXN5X2J1ZmZlcnNfc2l6ZSA9IDA7CiAgICAgY29uZi0+dXBzdHJlYW0ubWF4X3RlbXBfZmlsZV9zaXplID0gMDsKICAgICBjb25mLT51cHN0cmVhbS50ZW1wX2ZpbGVfd3JpdGVfc2l6ZSA9IDA7Ci0gICAgY29uZi0+dXBzdHJlYW0ucGFzc194X3Bvd2VyZWRfYnkgPSAwOwogICAgIGNvbmYtPnVwc3RyZWFtLnJlZGlyZWN0X2Vycm9ycyA9IDE7CiAgICAgY29uZi0+dXBzdHJlYW0ucmVkaXJlY3RfNDA0ID0gMTsKLSAgICBjb25mLT51cHN0cmVhbS5wYXNzX3NlcnZlciA9IDE7Ci0gICAgY29uZi0+dXBzdHJlYW0ucGFzc19kYXRlID0gMTsKICAgICBjb25mLT51cHN0cmVhbS5wYXNzX3JlcXVlc3RfaGVhZGVycyA9IDA7CiAgICAgY29uZi0+dXBzdHJlYW0ucGFzc19yZXF1ZXN0X2JvZHkgPSAwOwogCmRpZmYgLS1naXQgYS9zcmMvaHR0cC9tb2R1bGVzL25neF9odHRwX3Byb3h5X21vZHVsZS5jIGIvc3JjL2h0dHAvbW9kdWxlcy9uZ3hfaHR0cF9wcm94eV9tb2R1bGUuYwppbmRleCAwZTNjOTQ5Li5kZDY2YmZhIDEwMDY0NAotLS0gYS9zcmMvaHR0cC9tb2R1bGVzL25neF9odHRwX3Byb3h5X21vZHVsZS5jCisrKyBiL3NyYy9odHRwL21vZHVsZXMvbmd4X2h0dHBfcHJveHlfbW9kdWxlLmMKQEAgLTQyLDcgKzQyLDcgQEAKICAgICBuZ3hfYXJyYXlfdCAgICAgICAgICAgICAgICAgKmJvZHlfc2V0OwogICAgIG5neF9hcnJheV90ICAgICAgICAgICAgICAgICAqaGVhZGVyc19zZXRfbGVuOwogICAgIG5neF9hcnJheV90ICAgICAgICAgICAgICAgICAqaGVhZGVyc19zZXQ7Ci0gICAgbmd4X2hhc2gwX3QgICAgICAgICAgICAgICAgICpoZWFkZXJzX3NldF9oYXNoOworICAgIG5neF9oYXNoX3QgICAgICAgICAgICAgICAgICAgaGVhZGVyc19zZXRfaGFzaDsKIAogICAgIG5neF9hcnJheV90ICAgICAgICAgICAgICAgICAqaGVhZGVyc19zb3VyY2U7CiAgICAgbmd4X2FycmF5X3QgICAgICAgICAgICAgICAgICpoZWFkZXJzX25hbWVzOwpAQCAtMTg3LDcgKzE4Nyw3IEBACiAKICAgICB7IG5neF9zdHJpbmcoInByb3h5X3NldF9oZWFkZXIiKSwKICAgICAgIE5HWF9IVFRQX01BSU5fQ09ORnxOR1hfSFRUUF9TUlZfQ09ORnxOR1hfSFRUUF9MT0NfQ09ORnxOR1hfQ09ORl9UQUtFMiwKLSAgICAgIG5neF9jb25mX3NldF90YWJsZV9lbHRfc2xvdCwKKyAgICAgIG5neF9jb25mX3NldF9rZXl2YWxfc2xvdCwKICAgICAgIE5HWF9IVFRQX0xPQ19DT05GX09GRlNFVCwKICAgICAgIG9mZnNldG9mKG5neF9odHRwX3Byb3h5X2xvY19jb25mX3QsIGhlYWRlcnNfc291cmNlKSwKICAgICAgIE5VTEwgfSwKQEAgLTI5NywyNSArMjk3LDE4IEBACiAgICAgICBvZmZzZXRvZihuZ3hfaHR0cF9wcm94eV9sb2NfY29uZl90LCB1cHN0cmVhbS5mYWlsX3RpbWVvdXQpLAogICAgICAgTlVMTCB9LAogCi0gICAgeyBuZ3hfc3RyaW5nKCJwcm94eV9wYXNzX3hfcG93ZXJlZF9ieSIpLAorICAgIHsgbmd4X3N0cmluZygicHJveHlfcGFzc19oZWFkZXIiKSwKICAgICAgIE5HWF9IVFRQX01BSU5fQ09ORnxOR1hfSFRUUF9TUlZfQ09ORnxOR1hfSFRUUF9MT0NfQ09ORnxOR1hfQ09ORl9GTEFHLAotICAgICAgbmd4X2NvbmZfc2V0X2ZsYWdfc2xvdCwKKyAgICAgIG5neF9jb25mX3NldF9zdHJfYXJyYXlfc2xvdCwKICAgICAgIE5HWF9IVFRQX0xPQ19DT05GX09GRlNFVCwKLSAgICAgIG9mZnNldG9mKG5neF9odHRwX3Byb3h5X2xvY19jb25mX3QsIHVwc3RyZWFtLnBhc3NfeF9wb3dlcmVkX2J5KSwKKyAgICAgIG9mZnNldG9mKG5neF9odHRwX3Byb3h5X2xvY19jb25mX3QsIHVwc3RyZWFtLnBhc3NfaGVhZGVycyksCiAgICAgICBOVUxMIH0sCiAKLSAgICB7IG5neF9zdHJpbmcoInByb3h5X3Bhc3Nfc2VydmVyIiksCisgICAgeyBuZ3hfc3RyaW5nKCJwcm94eV9oaWRlX2hlYWRlciIpLAogICAgICAgTkdYX0hUVFBfTUFJTl9DT05GfE5HWF9IVFRQX1NSVl9DT05GfE5HWF9IVFRQX0xPQ19DT05GfE5HWF9DT05GX0ZMQUcsCi0gICAgICBuZ3hfY29uZl9zZXRfZmxhZ19zbG90LAorICAgICAgbmd4X2NvbmZfc2V0X3N0cl9hcnJheV9zbG90LAogICAgICAgTkdYX0hUVFBfTE9DX0NPTkZfT0ZGU0VULAotICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfcHJveHlfbG9jX2NvbmZfdCwgdXBzdHJlYW0ucGFzc19zZXJ2ZXIpLAotICAgICAgTlVMTCB9LAotCi0gICAgeyBuZ3hfc3RyaW5nKCJwcm94eV9wYXNzX3hfYWNjZWxfZXhwaXJlcyIpLAotICAgICAgTkdYX0hUVFBfTUFJTl9DT05GfE5HWF9IVFRQX1NSVl9DT05GfE5HWF9IVFRQX0xPQ19DT05GfE5HWF9DT05GX0ZMQUcsCi0gICAgICBuZ3hfY29uZl9zZXRfZmxhZ19zbG90LAotICAgICAgTkdYX0hUVFBfTE9DX0NPTkZfT0ZGU0VULAotICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfcHJveHlfbG9jX2NvbmZfdCwgdXBzdHJlYW0ucGFzc194X2FjY2VsX2V4cGlyZXMpLAorICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfcHJveHlfbG9jX2NvbmZfdCwgdXBzdHJlYW0uaGlkZV9oZWFkZXJzKSwKICAgICAgIE5VTEwgfSwKIAogICAgICAgbmd4X251bGxfY29tbWFuZApAQCAtMzU2LDExICszNDksMjMgQEAKIHN0YXRpYyBjaGFyICBuZ3hfaHR0cF9wcm94eV92ZXJzaW9uW10gPSAiIEhUVFAvMS4wIiBDUkxGOwogCiAKLXN0YXRpYyBuZ3hfdGFibGVfZWx0X3QgIG5neF9odHRwX3Byb3h5X2hlYWRlcnNbXSA9IHsKLSAgICB7IDAsIG5neF9zdHJpbmcoIkhvc3QiKSwgbmd4X3N0cmluZygiJHByb3h5X2hvc3QiKSB9LAotICAgIHsgMCwgbmd4X3N0cmluZygiQ29ubmVjdGlvbiIpLCBuZ3hfc3RyaW5nKCJjbG9zZSIpIH0sCi0gICAgeyAwLCBuZ3hfc3RyaW5nKCJLZWVwLUFsaXZlIiksIG5neF9zdHJpbmcoIiIpIH0sCi0gICAgeyAwLCBuZ3hfbnVsbF9zdHJpbmcsIG5neF9udWxsX3N0cmluZyB9CitzdGF0aWMgbmd4X2tleXZhbF90ICBuZ3hfaHR0cF9wcm94eV9oZWFkZXJzW10gPSB7CisgICAgeyBuZ3hfc3RyaW5nKCJIb3N0IiksIG5neF9zdHJpbmcoIiRwcm94eV9ob3N0IikgfSwKKyAgICB7IG5neF9zdHJpbmcoIkNvbm5lY3Rpb24iKSwgbmd4X3N0cmluZygiY2xvc2UiKSB9LAorICAgIHsgbmd4X3N0cmluZygiS2VlcC1BbGl2ZSIpLCBuZ3hfc3RyaW5nKCIiKSB9LAorICAgIHsgbmd4X251bGxfc3RyaW5nLCBuZ3hfbnVsbF9zdHJpbmcgfQorfTsKKworCitzdGF0aWMgbmd4X3N0cl90ICBuZ3hfaHR0cF9wcm94eV9oaWRlX2hlYWRlcnNbXSA9IHsKKyAgICBuZ3hfc3RyaW5nKCJEYXRlIiksCisgICAgbmd4X3N0cmluZygiU2VydmVyIiksCisgICAgbmd4X3N0cmluZygiWC1QYWQiKSwKKyAgICBuZ3hfc3RyaW5nKCJYLUFjY2VsLUV4cGlyZXMiKSwKKyAgICBuZ3hfc3RyaW5nKCJYLUFjY2VsLVJlZGlyZWN0IiksCisgICAgbmd4X3N0cmluZygiWC1BY2NlbC1MaW1pdC1SYXRlIiksCisgICAgbmd4X3N0cmluZygiWC1BY2NlbC1CdWZmZXIiKSwKKyAgICBuZ3hfbnVsbF9zdHJpbmcKIH07CiAKIApAQCAtNDIyLDE2ICs0MjcsMTUgQEAKICAgICAgICAgdS0+cmV3cml0ZV9yZWRpcmVjdCA9IG5neF9odHRwX3Byb3h5X3Jld3JpdGVfcmVkaXJlY3Q7CiAgICAgfQogCi0gICAgaWYgKHBsY2YtPnVwc3RyZWFtLmJ1ZmZlcmluZykgeworICAgIHUtPmJ1ZmZlcmluZyA9IHBsY2YtPnVwc3RyZWFtLmJ1ZmZlcmluZzsKIAotICAgICAgICB1LT5waXBlID0gbmd4X3BjYWxsb2Moci0+cG9vbCwgc2l6ZW9mKG5neF9ldmVudF9waXBlX3QpKTsKLSAgICAgICAgaWYgKHUtPnBpcGUgPT0gTlVMTCkgewotICAgICAgICAgICAgcmV0dXJuIE5HWF9IVFRQX0lOVEVSTkFMX1NFUlZFUl9FUlJPUjsKLSAgICAgICAgfQotCi0gICAgICAgIHUtPnBpcGUtPmlucHV0X2ZpbHRlciA9IG5neF9ldmVudF9waXBlX2NvcHlfaW5wdXRfZmlsdGVyOworICAgIHUtPnBpcGUgPSBuZ3hfcGNhbGxvYyhyLT5wb29sLCBzaXplb2Yobmd4X2V2ZW50X3BpcGVfdCkpOworICAgIGlmICh1LT5waXBlID09IE5VTEwpIHsKKyAgICAgICAgcmV0dXJuIE5HWF9IVFRQX0lOVEVSTkFMX1NFUlZFUl9FUlJPUjsKICAgICB9CiAKKyAgICB1LT5waXBlLT5pbnB1dF9maWx0ZXIgPSBuZ3hfZXZlbnRfcGlwZV9jb3B5X2lucHV0X2ZpbHRlcjsKKwogICAgIHUtPmFjY2VsID0gMTsKIAogICAgIHItPnVwc3RyZWFtID0gdTsKQEAgLTQ1MCwxMCArNDU0LDEwIEBACiBuZ3hfaHR0cF9wcm94eV9jcmVhdGVfcmVxdWVzdChuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIpCiB7CiAgICAgc2l6ZV90ICAgICAgICAgICAgICAgICAgICAgICAgbGVuLCBsb2NfbGVuLCBib2R5X2xlbjsKLSAgICBuZ3hfdWludF90ICAgICAgICAgICAgICAgICAgICBpLCBrZXksIHVucGFyc2VkX3VyaTsKICAgICB1aW50cHRyX3QgICAgICAgICAgICAgICAgICAgICBlc2NhcGU7CiAgICAgbmd4X2J1Zl90ICAgICAgICAgICAgICAgICAgICAqYjsKLSAgICBuZ3hfc3RyX3QgICAgICAgICAgICAgICAgICAgICpoaCwgbWV0aG9kOworICAgIG5neF9zdHJfdCAgICAgICAgICAgICAgICAgICAgIG1ldGhvZDsKKyAgICBuZ3hfdWludF90ICAgICAgICAgICAgICAgICAgICBpLCB1bnBhcnNlZF91cmk7CiAgICAgbmd4X2NoYWluX3QgICAgICAgICAgICAgICAgICAqY2wsICpib2R5OwogICAgIG5neF9saXN0X3BhcnRfdCAgICAgICAgICAgICAgKnBhcnQ7CiAgICAgbmd4X3RhYmxlX2VsdF90ICAgICAgICAgICAgICAqaGVhZGVyOwpAQCAtNTQxLDggKzU0NSw2IEBACiAgICAgfQogCiAKLSAgICBoaCA9IChuZ3hfc3RyX3QgKikgcGxjZi0+aGVhZGVyc19zZXRfaGFzaC0+YnVja2V0czsKLQogICAgIGlmIChwbGNmLT51cHN0cmVhbS5wYXNzX3JlcXVlc3RfaGVhZGVycykgewogICAgICAgICBwYXJ0ID0gJnItPmhlYWRlcnNfaW4uaGVhZGVycy5wYXJ0OwogICAgICAgICBoZWFkZXIgPSBwYXJ0LT5lbHRzOwpAQCAtNTU5LDEwICs1NjEsOCBAQAogICAgICAgICAgICAgICAgIGkgPSAwOwogICAgICAgICAgICAgfQogCi0gICAgICAgICAgICBrZXkgPSBoZWFkZXJbaV0uaGFzaCAlIHBsY2YtPmhlYWRlcnNfc2V0X2hhc2gtPmhhc2hfc2l6ZTsKLQotICAgICAgICAgICAgaWYgKGhoW2tleV0ubGVuID09IGhlYWRlcltpXS5rZXkubGVuCi0gICAgICAgICAgICAgICAgJiYgbmd4X3N0cmNhc2VjbXAoaGhba2V5XS5kYXRhLCBoZWFkZXJbaV0ua2V5LmRhdGEpID09IDApCisgICAgICAgICAgICBpZiAobmd4X2hhc2hfZmluZCgmcGxjZi0+aGVhZGVyc19zZXRfaGFzaCwgaGVhZGVyW2ldLmhhc2gsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoZWFkZXJbaV0ubG93Y2FzZV9rZXksIGhlYWRlcltpXS5rZXkubGVuKSkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgICAgIH0KQEAgLTY3NiwxMCArNjc2LDggQEAKICAgICAgICAgICAgICAgICBpID0gMDsKICAgICAgICAgICAgIH0KIAotICAgICAgICAgICAga2V5ID0gaGVhZGVyW2ldLmhhc2ggJSBwbGNmLT5oZWFkZXJzX3NldF9oYXNoLT5oYXNoX3NpemU7Ci0KLSAgICAgICAgICAgIGlmIChoaFtrZXldLmxlbiA9PSBoZWFkZXJbaV0ua2V5LmxlbgotICAgICAgICAgICAgICAgICYmIG5neF9zdHJjYXNlY21wKGhoW2tleV0uZGF0YSwgaGVhZGVyW2ldLmtleS5kYXRhKSA9PSAwKQorICAgICAgICAgICAgaWYgKG5neF9oYXNoX2ZpbmQoJnBsY2YtPmhlYWRlcnNfc2V0X2hhc2gsIGhlYWRlcltpXS5oYXNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaGVhZGVyW2ldLmxvd2Nhc2Vfa2V5LCBoZWFkZXJbaV0ua2V5LmxlbikpCiAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgICAgICB9CkBAIC0xMDU1LDEzICsxMDUzLDEyIEBACiBuZ3hfaHR0cF9wcm94eV9wcm9jZXNzX2hlYWRlcihuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIpCiB7CiAgICAgbmd4X2ludF90ICAgICAgICAgICAgICAgICAgICAgICByYzsKLSAgICBuZ3hfdWludF90ICAgICAgICAgICAgICAgICAgICAgIGtleTsKKyAgICBuZ3hfdWludF90ICAgICAgICAgICAgICAgICAgICAgIGk7CiAgICAgbmd4X3RhYmxlX2VsdF90ICAgICAgICAgICAgICAgICpoOwogICAgIG5neF9odHRwX3Vwc3RyZWFtX2hlYWRlcl90ICAgICAqaGg7CiAgICAgbmd4X2h0dHBfdXBzdHJlYW1fbWFpbl9jb25mX3QgICp1bWNmOwogCiAgICAgdW1jZiA9IG5neF9odHRwX2dldF9tb2R1bGVfbWFpbl9jb25mKHIsIG5neF9odHRwX3Vwc3RyZWFtX21vZHVsZSk7Ci0gICAgaGggPSAobmd4X2h0dHBfdXBzdHJlYW1faGVhZGVyX3QgKikgdW1jZi0+aGVhZGVyc19pbl9oYXNoLmJ1Y2tldHM7CiAKICAgICBmb3IgKCA7OyAgKSB7CiAKQEAgLTEwODIsMjYgKzEwNzksMzMgQEAKICAgICAgICAgICAgIGgtPnZhbHVlLmxlbiA9IHItPmhlYWRlcl9lbmQgLSByLT5oZWFkZXJfc3RhcnQ7CiAKICAgICAgICAgICAgIGgtPmtleS5kYXRhID0gbmd4X3BhbGxvYyhyLT5wb29sLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGgtPmtleS5sZW4gKyAxICsgaC0+dmFsdWUubGVuICsgMSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaC0+a2V5LmxlbiArIDEgKyBoLT52YWx1ZS5sZW4gKyAxICsgaC0+a2V5Lmxlbik7CiAgICAgICAgICAgICBpZiAoaC0+a2V5LmRhdGEgPT0gTlVMTCkgewogICAgICAgICAgICAgICAgIHJldHVybiBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGgtPnZhbHVlLmRhdGEgPSBoLT5rZXkuZGF0YSArIGgtPmtleS5sZW4gKyAxOworICAgICAgICAgICAgaC0+bG93Y2FzZV9rZXkgPSBoLT5rZXkuZGF0YSArIGgtPmtleS5sZW4gKyAxICsgaC0+dmFsdWUubGVuICsgMTsKIAogICAgICAgICAgICAgbmd4X2NweXN0cm4oaC0+a2V5LmRhdGEsIHItPmhlYWRlcl9uYW1lX3N0YXJ0LCBoLT5rZXkubGVuICsgMSk7CiAgICAgICAgICAgICBuZ3hfY3B5c3RybihoLT52YWx1ZS5kYXRhLCByLT5oZWFkZXJfc3RhcnQsIGgtPnZhbHVlLmxlbiArIDEpOwogCi0gICAgICAgICAgICBrZXkgPSBoLT5oYXNoICUgdW1jZi0+aGVhZGVyc19pbl9oYXNoLmhhc2hfc2l6ZTsKKyAgICAgICAgICAgIGlmIChoLT5rZXkubGVuID09IHItPmxvd2Nhc2VfaW5kZXgpIHsKKyAgICAgICAgICAgICAgICBuZ3hfbWVtY3B5KGgtPmxvd2Nhc2Vfa2V5LCByLT5sb3djYXNlX2hlYWRlciwgaC0+a2V5Lmxlbik7CiAKLSAgICAgICAgICAgIGlmIChoaFtrZXldLm5hbWUubGVuID09IGgtPmtleS5sZW4KLSAgICAgICAgICAgICAgICAmJiBuZ3hfc3RyY2FzZWNtcChoaFtrZXldLm5hbWUuZGF0YSwgaC0+a2V5LmRhdGEpID09IDApCi0gICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgaWYgKGhoW2tleV0uaGFuZGxlcihyLCBoLCBoaFtrZXldLm9mZnNldCkgIT0gTkdYX09LKSB7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBoLT5rZXkubGVuOyBpKyspIHsKKyAgICAgICAgICAgICAgICAgICAgaC0+bG93Y2FzZV9rZXlbaV0gPSBuZ3hfdG9sb3dlcihoLT5sb3djYXNlX2tleVtpXSk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogCisgICAgICAgICAgICBoaCA9IG5neF9oYXNoX2ZpbmQoJnVtY2YtPmhlYWRlcnNfaW5faGFzaCwgaC0+aGFzaCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoLT5sb3djYXNlX2tleSwgaC0+a2V5Lmxlbik7CisKKyAgICAgICAgICAgIGlmIChoaCAmJiBoaC0+aGFuZGxlcihyLCBoLCBoaC0+b2Zmc2V0KSAhPSBOR1hfT0spIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gTkdYX0hUVFBfSU5URVJOQUxfU0VSVkVSX0VSUk9SOworICAgICAgICAgICAgfQorCiAgICAgICAgICAgICBuZ3hfbG9nX2RlYnVnMihOR1hfTE9HX0RFQlVHX0hUVFAsIHItPmNvbm5lY3Rpb24tPmxvZywgMCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICJodHRwIHByb3h5IGhlYWRlcjogXCIlVjogJVZcIiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAmaC0+a2V5LCAmaC0+dmFsdWUpOwpAQCAtMTExNiw2ICsxMTIwLDQyIEBACiAgICAgICAgICAgICBuZ3hfbG9nX2RlYnVnMChOR1hfTE9HX0RFQlVHX0hUVFAsIHItPmNvbm5lY3Rpb24tPmxvZywgMCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICJodHRwIHByb3h5IGhlYWRlciBkb25lIik7CiAKKyAgICAgICAgICAgIC8qCisgICAgICAgICAgICAgKiBpZiBubyAiU2VydmVyIiBhbmQgIkRhdGUiIGluIGhlYWRlciBsaW5lLAorICAgICAgICAgICAgICogdGhlbiBhZGQgdGhlIHNwZWNpYWwgZW1wdHkgaGVhZGVycworICAgICAgICAgICAgICovCisKKyAgICAgICAgICAgIGlmIChyLT51cHN0cmVhbS0+aGVhZGVyc19pbi5zZXJ2ZXIgPT0gTlVMTCkgeworICAgICAgICAgICAgICAgIGggPSBuZ3hfbGlzdF9wdXNoKCZyLT51cHN0cmVhbS0+aGVhZGVyc19pbi5oZWFkZXJzKTsKKyAgICAgICAgICAgICAgICBpZiAoaCA9PSBOVUxMKSB7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CisgICAgICAgICAgICAgICAgfQorCisgICAgICAgICAgICAgICAgaC0+aGFzaCA9IG5neF9oYXNoKG5neF9oYXNoKG5neF9oYXNoKG5neF9oYXNoKAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmd4X2hhc2goJ3MnLCAnZScpLCAncicpLCAndicpLCAnZScpLCAncicpOworCisgICAgICAgICAgICAgICAgaC0+a2V5LmxlbiA9IHNpemVvZigiU2VydmVyIikgLSAxOworICAgICAgICAgICAgICAgIGgtPmtleS5kYXRhID0gKHVfY2hhciAqKSAiU2VydmVyIjsKKyAgICAgICAgICAgICAgICBoLT52YWx1ZS5sZW4gPSAwOworICAgICAgICAgICAgICAgIGgtPnZhbHVlLmRhdGEgPSBOVUxMOworICAgICAgICAgICAgICAgIGgtPmxvd2Nhc2Vfa2V5ID0gKHVfY2hhciAqKSAic2VydmVyIjsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgaWYgKHItPnVwc3RyZWFtLT5oZWFkZXJzX2luLmRhdGUgPT0gTlVMTCkgeworICAgICAgICAgICAgICAgIGggPSBuZ3hfbGlzdF9wdXNoKCZyLT51cHN0cmVhbS0+aGVhZGVyc19pbi5oZWFkZXJzKTsKKyAgICAgICAgICAgICAgICBpZiAoaCA9PSBOVUxMKSB7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CisgICAgICAgICAgICAgICAgfQorCisgICAgICAgICAgICAgICAgaC0+aGFzaCA9IG5neF9oYXNoKG5neF9oYXNoKG5neF9oYXNoKCdkJywgJ2EnKSwgJ3QnKSwgJ2UnKTsKKworICAgICAgICAgICAgICAgIGgtPmtleS5sZW4gPSBzaXplb2YoIkRhdGUiKSAtIDE7CisgICAgICAgICAgICAgICAgaC0+a2V5LmRhdGEgPSAodV9jaGFyICopICJEYXRlIjsKKyAgICAgICAgICAgICAgICBoLT52YWx1ZS5sZW4gPSAwOworICAgICAgICAgICAgICAgIGgtPnZhbHVlLmRhdGEgPSBOVUxMOworICAgICAgICAgICAgICAgIGgtPmxvd2Nhc2Vfa2V5ID0gKHVfY2hhciAqKSAiZGF0ZSI7CisgICAgICAgICAgICB9CisKICAgICAgICAgICAgIHJldHVybiBOR1hfT0s7CiAgICAgICAgIH0KIApAQCAtMTQwNiw2ICsxNDQ2LDkgQEAKICAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0uYnVmcy5udW0gPSAwOwogICAgICAqICAgICBjb25mLT51cHN0cmVhbS5uZXh0X3Vwc3RyZWFtID0gMDsKICAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0udGVtcF9wYXRoID0gTlVMTDsKKyAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzX2hhc2ggPSB7IE5VTEwsIDAgfTsKKyAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzID0gTlVMTDsKKyAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0ucGFzc19oZWFkZXJzID0gTlVMTDsKICAgICAgKiAgICAgY29uZi0+dXBzdHJlYW0uc2NoZW1hID0geyAwLCBOVUxMIH07CiAgICAgICogICAgIGNvbmYtPnVwc3RyZWFtLnVyaSA9IHsgMCwgTlVMTCB9OwogICAgICAqICAgICBjb25mLT51cHN0cmVhbS5sb2NhdGlvbiA9IE5VTEw7CkBAIC0xNDQ2LDEyICsxNDg5LDggQEAKICAgICAvKiAicHJveHlfY3ljbGljX3RlbXBfZmlsZSIgaXMgZGlzYWJsZWQgKi8KICAgICBjb25mLT51cHN0cmVhbS5jeWNsaWNfdGVtcF9maWxlID0gMDsKIAotICAgIGNvbmYtPnVwc3RyZWFtLnBhc3NfeF9wb3dlcmVkX2J5ID0gTkdYX0NPTkZfVU5TRVQ7Ci0gICAgY29uZi0+dXBzdHJlYW0ucGFzc19zZXJ2ZXIgPSBOR1hfQ09ORl9VTlNFVDsKLSAgICBjb25mLT51cHN0cmVhbS5wYXNzX2RhdGUgPSAwOwotICAgIGNvbmYtPnVwc3RyZWFtLnBhc3NfeF9hY2NlbF9leHBpcmVzID0gTkdYX0NPTkZfVU5TRVQ7Ci0KICAgICBjb25mLT5yZWRpcmVjdCA9IE5HWF9DT05GX1VOU0VUOworICAgIGNvbmYtPnVwc3RyZWFtLmNoYW5nZV9idWZmZXJpbmcgPSAxOwogCiAgICAgcmV0dXJuIGNvbmY7CiB9CkBAIC0xNDY2LDkgKzE1MDUsMTIgQEAKICAgICB1X2NoYXIgICAgICAgICAgICAgICAgICAgICAgICpwOwogICAgIHNpemVfdCAgICAgICAgICAgICAgICAgICAgICAgIHNpemU7CiAgICAgdWludHB0cl90ICAgICAgICAgICAgICAgICAgICAqY29kZTsKLSAgICBuZ3hfc3RyX3QgICAgICAgICAgICAgICAgICAgICpuYW1lOwotICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgIGk7Ci0gICAgbmd4X3RhYmxlX2VsdF90ICAgICAgICAgICAgICAqc3JjLCAqcywgKmg7CisgICAgbmd4X3N0cl90ICAgICAgICAgICAgICAgICAgICAqaGVhZGVyOworICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgIGksIGo7CisgICAgbmd4X2FycmF5X3QgICAgICAgICAgICAgICAgICAgaGlkZV9oZWFkZXJzOworICAgIG5neF9rZXl2YWxfdCAgICAgICAgICAgICAgICAgKnNyYywgKnMsICpoOworICAgIG5neF9oYXNoX2tleV90ICAgICAgICAgICAgICAgKmhrOworICAgIG5neF9oYXNoX2luaXRfdCAgICAgICAgICAgICAgIGhhc2g7CiAgICAgbmd4X2h0dHBfcHJveHlfcmVkaXJlY3RfdCAgICAqcHI7CiAgICAgbmd4X2h0dHBfc2NyaXB0X2NvbXBpbGVfdCAgICAgc2M7CiAgICAgbmd4X2h0dHBfc2NyaXB0X2NvcHlfY29kZV90ICAqY29weTsKQEAgLTE2MjcsMTQgKzE2NjksNiBAQAogICAgIG5neF9jb25mX21lcmdlX3ZhbHVlKGNvbmYtPnVwc3RyZWFtLnJlZGlyZWN0X2Vycm9ycywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHByZXYtPnVwc3RyZWFtLnJlZGlyZWN0X2Vycm9ycywgMCk7CiAKLSAgICBuZ3hfY29uZl9tZXJnZV92YWx1ZShjb25mLT51cHN0cmVhbS5wYXNzX3hfcG93ZXJlZF9ieSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHByZXYtPnVwc3RyZWFtLnBhc3NfeF9wb3dlcmVkX2J5LCAxKTsKLSAgICBuZ3hfY29uZl9tZXJnZV92YWx1ZShjb25mLT51cHN0cmVhbS5wYXNzX3NlcnZlciwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHByZXYtPnVwc3RyZWFtLnBhc3Nfc2VydmVyLCAwKTsKLSAgICBuZ3hfY29uZl9tZXJnZV92YWx1ZShjb25mLT51cHN0cmVhbS5wYXNzX3hfYWNjZWxfZXhwaXJlcywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHByZXYtPnVwc3RyZWFtLnBhc3NfeF9hY2NlbF9leHBpcmVzLCAwKTsKLQotCiAgICAgbmd4X2NvbmZfbWVyZ2VfdmFsdWUoY29uZi0+cmVkaXJlY3QsIHByZXYtPnJlZGlyZWN0LCAxKTsKIAogICAgIGlmIChjb25mLT5yZWRpcmVjdCkgewpAQCAtMTY2Miw2ICsxNjk2LDEwNiBAQAogICAgICAgICB9CiAgICAgfQogCisgICAgaWYgKGNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVycyA9PSBOVUxMCisgICAgICAgICYmIGNvbmYtPnVwc3RyZWFtLnBhc3NfaGVhZGVycyA9PSBOVUxMKQorICAgIHsKKyAgICAgICAgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzID0gcHJldi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzOworICAgICAgICBjb25mLT51cHN0cmVhbS5wYXNzX2hlYWRlcnMgPSBwcmV2LT51cHN0cmVhbS5wYXNzX2hlYWRlcnM7CisgICAgICAgIGNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVyc19oYXNoID0gcHJldi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzX2hhc2g7CisKKyAgICAgICAgaWYgKGNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVyc19oYXNoLmJ1Y2tldHMpIHsKKyAgICAgICAgICAgIGdvdG8gcGVlcnM7CisgICAgICAgIH0KKworICAgIH0gZWxzZSB7CisgICAgICAgIGlmIChjb25mLT51cHN0cmVhbS5oaWRlX2hlYWRlcnMgPT0gTlVMTCkgeworICAgICAgICAgICAgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzID0gcHJldi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzOworICAgICAgICB9CisKKyAgICAgICAgaWYgKGNvbmYtPnVwc3RyZWFtLnBhc3NfaGVhZGVycyA9PSBOVUxMKSB7CisgICAgICAgICAgICBjb25mLT51cHN0cmVhbS5wYXNzX2hlYWRlcnMgPSBwcmV2LT51cHN0cmVhbS5wYXNzX2hlYWRlcnM7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAobmd4X2FycmF5X2luaXQoJmhpZGVfaGVhZGVycywgY2YtPnRlbXBfcG9vbCwgNCwgc2l6ZW9mKG5neF9oYXNoX2tleV90KSkKKyAgICAgICAgIT0gTkdYX09LKQorICAgIHsKKyAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgIH0KKworICAgIGZvciAoaGVhZGVyID0gbmd4X2h0dHBfcHJveHlfaGlkZV9oZWFkZXJzOyBoZWFkZXItPmxlbjsgaGVhZGVyKyspIHsKKyAgICAgICAgaGsgPSBuZ3hfYXJyYXlfcHVzaCgmaGlkZV9oZWFkZXJzKTsKKyAgICAgICAgaWYgKGhrID09IE5VTEwpIHsKKyAgICAgICAgICAgIHJldHVybiBOR1hfQ09ORl9FUlJPUjsKKyAgICAgICAgfQorCisgICAgICAgIGhrLT5rZXkgPSAqaGVhZGVyOworICAgICAgICBoay0+a2V5X2hhc2ggPSBuZ3hfaGFzaF9rZXlfbGMoaGVhZGVyLT5kYXRhLCBoZWFkZXItPmxlbik7CisgICAgICAgIGhrLT52YWx1ZSA9ICh2b2lkICopIDE7CisgICAgfQorCisgICAgaWYgKGNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVycykgeworCisgICAgICAgIGhlYWRlciA9IGNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVycy0+ZWx0czsKKworICAgICAgICBmb3IgKGkgPSAwOyBpIDwgY29uZi0+dXBzdHJlYW0uaGlkZV9oZWFkZXJzLT5uZWx0czsgaSsrKSB7CisKKyAgICAgICAgICAgIGhrID0gaGlkZV9oZWFkZXJzLmVsdHM7CisKKyAgICAgICAgICAgIGZvciAoaiA9IDA7IGogPCBoaWRlX2hlYWRlcnMubmVsdHM7IGorKykgeworICAgICAgICAgICAgICAgIGlmIChuZ3hfc3RyY2FzZWNtcChoZWFkZXJbaV0uZGF0YSwgaGtbal0ua2V5LmRhdGEpID09IDApIHsKKyAgICAgICAgICAgICAgICAgICAgZ290byBleGlzdDsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGhrID0gbmd4X2FycmF5X3B1c2goJmhpZGVfaGVhZGVycyk7CisgICAgICAgICAgICBpZiAoaGsgPT0gTlVMTCkgeworICAgICAgICAgICAgICAgIHJldHVybiBOR1hfQ09ORl9FUlJPUjsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgaGstPmtleSA9IGhlYWRlcltpXTsKKyAgICAgICAgICAgIGhrLT5rZXlfaGFzaCA9IG5neF9oYXNoX2tleV9sYyhoZWFkZXJbaV0uZGF0YSwgaGVhZGVyW2ldLmxlbik7CisgICAgICAgICAgICBoay0+dmFsdWUgPSAodm9pZCAqKSAxOworCisgICAgICAgIGV4aXN0OgorCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorICAgIH0KKworICAgIGlmIChjb25mLT51cHN0cmVhbS5wYXNzX2hlYWRlcnMpIHsKKworICAgICAgICBoayA9IGhpZGVfaGVhZGVycy5lbHRzOworICAgICAgICBoZWFkZXIgPSBjb25mLT51cHN0cmVhbS5wYXNzX2hlYWRlcnMtPmVsdHM7CisKKyAgICAgICAgZm9yIChpID0gMDsgaSA8IGNvbmYtPnVwc3RyZWFtLnBhc3NfaGVhZGVycy0+bmVsdHM7IGkrKykgeworICAgICAgICAgICAgZm9yIChqID0gMDsgaiA8IGhpZGVfaGVhZGVycy5uZWx0czsgaisrKSB7CisKKyAgICAgICAgICAgICAgICBpZiAoaGtbal0ua2V5LmRhdGEgPT0gTlVMTCkgeworICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICBpZiAobmd4X3N0cmNhc2VjbXAoaGVhZGVyW2ldLmRhdGEsIGhrW2pdLmtleS5kYXRhKSA9PSAwKSB7CisgICAgICAgICAgICAgICAgICAgIGhrW2pdLmtleS5kYXRhID0gTlVMTDsKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorCisgICAgaGFzaC5oYXNoID0gJmNvbmYtPnVwc3RyZWFtLmhpZGVfaGVhZGVyc19oYXNoOworICAgIGhhc2gua2V5ID0gbmd4X2hhc2hfa2V5X2xjOworICAgIGhhc2gubWF4X3NpemUgPSA1MTI7CisgICAgaGFzaC5idWNrZXRfc2l6ZSA9IG5neF9jYWNoZWxpbmVfc2l6ZTsKKyAgICBoYXNoLm5hbWUgPSAicHJveHlfaGlkZV9oZWFkZXJzX2hhc2giOworICAgIGhhc2gucG9vbCA9IGNmLT5wb29sOworICAgIGhhc2gudGVtcF9wb29sID0gTlVMTDsKKworICAgIGlmIChuZ3hfaGFzaF9pbml0KCZoYXNoLCBoaWRlX2hlYWRlcnMuZWx0cywgaGlkZV9oZWFkZXJzLm5lbHRzKSAhPSBOR1hfT0spIHsKKyAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgIH0KKworcGVlcnM6CiAKICAgICBpZiAoY29uZi0+cGVlcnMgPT0gTlVMTCkgewogICAgICAgICBjb25mLT5wZWVycyA9IHByZXYtPnBlZXJzOwpAQCAtMTY5Niw3ICsxODMwLDcgQEAKIAogICAgICAgICBpZiAoY29uZi0+aGVhZGVyc19zb3VyY2UgPT0gTlVMTCkgewogICAgICAgICAgICAgY29uZi0+aGVhZGVyc19zb3VyY2UgPSBuZ3hfYXJyYXlfY3JlYXRlKGNmLT5wb29sLCA0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNpemVvZihuZ3hfdGFibGVfZWx0X3QpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzaXplb2Yobmd4X2tleXZhbF90KSk7CiAgICAgICAgICAgICBpZiAoY29uZi0+aGVhZGVyc19zb3VyY2UgPT0gTlVMTCkgewogICAgICAgICAgICAgICAgIHJldHVybiBOR1hfQ09ORl9FUlJPUjsKICAgICAgICAgICAgIH0KQEAgLTE3MDcsNyArMTg0MSw2IEBACiAgICAgICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CiAgICAgICAgIH0KIAotICAgICAgICBzLT5oYXNoID0gMDsKICAgICAgICAgcy0+a2V5LmxlbiA9IHNpemVvZigiQ29udGVudC1MZW5ndGgiKSAtIDE7CiAgICAgICAgIHMtPmtleS5kYXRhID0gKHVfY2hhciAqKSAiQ29udGVudC1MZW5ndGgiOwogICAgICAgICBzLT52YWx1ZS5sZW4gPSBzaXplb2YoIiRwcm94eV9pbnRlcm5hbF9ib2R5X2xlbmd0aCIpIC0gMTsKQEAgLTE3MjMsMTkgKzE4NTYsMTkgQEAKICAgICAgICAgY29uZi0+aGVhZGVyc19zb3VyY2UgPSBwcmV2LT5oZWFkZXJzX3NvdXJjZTsKICAgICB9CiAKLSAgICBpZiAoY29uZi0+aGVhZGVyc19zZXRfaGFzaCkgeworICAgIGlmIChjb25mLT5oZWFkZXJzX3NldF9oYXNoLmJ1Y2tldHMpIHsKICAgICAgICAgcmV0dXJuIE5HWF9DT05GX09LOwogICAgIH0KIAogCi0gICAgY29uZi0+aGVhZGVyc19uYW1lcyA9IG5neF9hcnJheV9jcmVhdGUoY2YtPnBvb2wsIDQsIHNpemVvZihuZ3hfc3RyX3QpKTsKKyAgICBjb25mLT5oZWFkZXJzX25hbWVzID0gbmd4X2FycmF5X2NyZWF0ZShjZi0+cG9vbCwgNCwgc2l6ZW9mKG5neF9oYXNoX2tleV90KSk7CiAgICAgaWYgKGNvbmYtPmhlYWRlcnNfbmFtZXMgPT0gTlVMTCkgewogICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CiAgICAgfQogCiAgICAgaWYgKGNvbmYtPmhlYWRlcnNfc291cmNlID09IE5VTEwpIHsKICAgICAgICAgY29uZi0+aGVhZGVyc19zb3VyY2UgPSBuZ3hfYXJyYXlfY3JlYXRlKGNmLT5wb29sLCA0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mKG5neF90YWJsZV9lbHRfdCkpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mKG5neF9rZXl2YWxfdCkpOwogICAgICAgICBpZiAoY29uZi0+aGVhZGVyc19zb3VyY2UgPT0gTlVMTCkgewogICAgICAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOwogICAgICAgICB9CkBAIC0xNzgwLDEyICsxOTEzLDE0IEBACiAgICAgc3JjID0gY29uZi0+aGVhZGVyc19zb3VyY2UtPmVsdHM7CiAgICAgZm9yIChpID0gMDsgaSA8IGNvbmYtPmhlYWRlcnNfc291cmNlLT5uZWx0czsgaSsrKSB7CiAKLSAgICAgICAgbmFtZSA9IG5neF9hcnJheV9wdXNoKGNvbmYtPmhlYWRlcnNfbmFtZXMpOwotICAgICAgICBpZiAobmFtZSA9PSBOVUxMKSB7CisgICAgICAgIGhrID0gbmd4X2FycmF5X3B1c2goY29uZi0+aGVhZGVyc19uYW1lcyk7CisgICAgICAgIGlmIChoayA9PSBOVUxMKSB7CiAgICAgICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CiAgICAgICAgIH0KIAotICAgICAgICAqbmFtZSA9IHNyY1tpXS5rZXk7CisgICAgICAgIGhrLT5rZXkgPSBzcmNbaV0ua2V5OworICAgICAgICBoay0+a2V5X2hhc2ggPSBuZ3hfaGFzaF9rZXlfbGMoc3JjW2ldLmtleS5kYXRhLCBzcmNbaV0ua2V5Lmxlbik7CisgICAgICAgIGhrLT52YWx1ZSA9ICh2b2lkICopIDE7CiAKICAgICAgICAgaWYgKHNyY1tpXS52YWx1ZS5sZW4gPT0gMCkgewogICAgICAgICAgICAgY29udGludWU7CkBAIC0xOTE4LDYgKzIwNTMsMjMgQEAKICAgICAqY29kZSA9ICh1aW50cHRyX3QpIE5VTEw7CiAKIAorICAgIGhhc2guaGFzaCA9ICZjb25mLT5oZWFkZXJzX3NldF9oYXNoOworICAgIGhhc2gua2V5ID0gbmd4X2hhc2hfa2V5X2xjOworICAgIGhhc2gubWF4X3NpemUgPSA1MTI7CisgICAgaGFzaC5idWNrZXRfc2l6ZSA9IG5neF9jYWNoZWxpbmVfc2l6ZTsKKyAgICBoYXNoLm5hbWUgPSAicHJveHlfc2V0X2hlYWRlcl9oYXNoIjsKKyAgICBoYXNoLnBvb2wgPSBjZi0+cG9vbDsKKyAgICBoYXNoLnRlbXBfcG9vbCA9IE5VTEw7CisKKyAgICBpZiAobmd4X2hhc2hfaW5pdCgmaGFzaCwgY29uZi0+aGVhZGVyc19uYW1lcy0+ZWx0cywKKyAgICAgICAgICAgICAgICAgICAgICBjb25mLT5oZWFkZXJzX25hbWVzLT5uZWx0cykKKyAgICAgICAgIT0gTkdYX09LKQorICAgIHsKKyAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgIH0KKworCisjaWYgMAogICAgIGNvbmYtPmhlYWRlcnNfc2V0X2hhc2ggPSBuZ3hfcGNhbGxvYyhjZi0+cG9vbCwgc2l6ZW9mKG5neF9oYXNoMF90KSk7CiAgICAgaWYgKGNvbmYtPmhlYWRlcnNfc2V0X2hhc2ggPT0gTlVMTCkgewogICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CkBAIC0xOTQwLDYgKzIwOTIsNyBAQAogICAgICAgICAgICAgICAgICAgICJtYXggYnVja2V0cyBwZXIgZW50cnk6ICV1aSIsCiAgICAgICAgICAgICAgICAgICAgY29uZi0+aGVhZGVyc19zZXRfaGFzaC0+aGFzaF9zaXplLAogICAgICAgICAgICAgICAgICAgIGNvbmYtPmhlYWRlcnNfc2V0X2hhc2gtPm1pbl9idWNrZXRzKTsKKyNlbmRpZgogCiAgICAgcmV0dXJuIE5HWF9DT05GX09LOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2h0dHAvbW9kdWxlcy9wZXJsL25neF9odHRwX3BlcmxfbW9kdWxlLmMgYi9zcmMvaHR0cC9tb2R1bGVzL3Blcmwvbmd4X2h0dHBfcGVybF9tb2R1bGUuYwppbmRleCBhYTBlNDFkLi42YjcyOThjIDEwMDY0NAotLS0gYS9zcmMvaHR0cC9tb2R1bGVzL3Blcmwvbmd4X2h0dHBfcGVybF9tb2R1bGUuYworKysgYi9zcmMvaHR0cC9tb2R1bGVzL3Blcmwvbmd4X2h0dHBfcGVybF9tb2R1bGUuYwpAQCAtNTEsNiArNTEsOCBAQAogc3RhdGljIFBlcmxJbnRlcnByZXRlciAqCiAgICAgbmd4X2h0dHBfcGVybF9jcmVhdGVfaW50ZXJwcmV0ZXIobmd4X2h0dHBfcGVybF9tYWluX2NvbmZfdCAqcG1jZiwKICAgICBuZ3hfbG9nX3QgKmxvZyk7CitzdGF0aWMgbmd4X2ludF90IG5neF9odHRwX3BlcmxfcnVuX3JlcXVpcmVzKG5neF9hcnJheV90ICpyZXF1aXJlcywKKyAgICBuZ3hfbG9nX3QgKmxvZyk7CiBzdGF0aWMgbmd4X2ludF90IG5neF9odHRwX3BlcmxfY2FsbF9oYW5kbGVyKHBUSFhfIG5neF9odHRwX3JlcXVlc3RfdCAqciwKICAgICBTViAqc3ViLCBuZ3hfc3RyX3QgKiphcmdzLCBuZ3hfc3RyX3QgKmhhbmRsZXIsIG5neF9zdHJfdCAqcnYpOwogc3RhdGljIHZvaWQgbmd4X2h0dHBfcGVybF9ldmFsX2Fub25fc3ViKHBUSFhfIG5neF9zdHJfdCAqaGFuZGxlciwgU1YgKipzdik7CkBAIC02Nyw3ICs2OSwxMCBAQAogc3RhdGljIGNoYXIgKm5neF9odHRwX3Blcmxfc2V0KG5neF9jb25mX3QgKmNmLCBuZ3hfY29tbWFuZF90ICpjbWQsIHZvaWQgKmNvbmYpOwogc3RhdGljIGNoYXIgKm5neF9odHRwX3BlcmxfaW50ZXJwX21heF91bnN1cHBvcnRlZChuZ3hfY29uZl90ICpjZiwgdm9pZCAqcG9zdCwKICAgICB2b2lkICpkYXRhKTsKKyNpZiAoTkdYX0hBVkVfUEVSTF9DTE9ORSB8fCBOR1hfSEFWRV9QRVJMX01VTFRJUExJQ0lUWSkKIHN0YXRpYyB2b2lkIG5neF9odHRwX3BlcmxfY2xlYW51cF9wZXJsKHZvaWQgKmRhdGEpOworI2VuZGlmCitzdGF0aWMgdm9pZCBuZ3hfaHR0cF9wZXJsX2NsZWFudXBfc3Yodm9pZCAqZGF0YSk7CiAKIAogc3RhdGljIG5neF9jb25mX3Bvc3RfaGFuZGxlcl9wdCAgbmd4X2h0dHBfcGVybF9pbnRlcnBfbWF4X3AgPQpAQCAtMzk0LDIyICszOTksNiBAQAogCiAgICAgZFRIWGEoY3R4LT5wZXJsKTsKIAotI2lmIDAKLQotICAgIG5neF9odHRwX3BlcmxfZXZhbF9hbm9uX3N1YihhVEhYXyBoYW5kbGVyLCAmc3YpOwotCi0gICAgaWYgKHN2ID09ICZQTF9zdl91bmRlZikgewotICAgICAgICBuZ3hfbG9nX2Vycm9yKE5HWF9MT0dfRVJSLCByLT5jb25uZWN0aW9uLT5sb2csIDAsCi0gICAgICAgICAgICAgICAgICAgICAgImV2YWxfcHYoXCIlVlwiKSBmYWlsZWQiLCBoYW5kbGVyKTsKLSAgICAgICAgcmV0dXJuIE5HWF9FUlJPUjsKLSAgICB9Ci0KLSAgICBpZiAoc3YgPT0gTlVMTCkgewotICAgICAgICBzdiA9IG5ld1NWcHZuKChjaGFyICopIGhhbmRsZXItPmRhdGEsIGhhbmRsZXItPmxlbik7Ci0gICAgfQotCi0jZW5kaWYKLQogICAgIHN2ID0gbmV3U1Zwdm4oKGNoYXIgKikgaGFuZGxlci0+ZGF0YSwgaGFuZGxlci0+bGVuKTsKIAogICAgIHJjID0gbmd4X2h0dHBfcGVybF9jYWxsX2hhbmRsZXIoYVRIWF8gciwgc3YsICZwYXJhbXNbTkdYX0hUVFBfUEVSTF9TU0lfQVJHXSwKQEAgLTQ3MCwxMyArNDU5LDE4IEBACiBzdGF0aWMgY2hhciAqCiBuZ3hfaHR0cF9wZXJsX2luaXRfaW50ZXJwcmV0ZXIobmd4X2NvbmZfdCAqY2YsIG5neF9odHRwX3BlcmxfbWFpbl9jb25mX3QgKnBtY2YpCiB7Ci0gICAgbmd4X3Bvb2xfY2xlYW51cF90ICAgICAgICAgKmNsbjsKKyNpZiAoTkdYX0hBVkVfUEVSTF9DTE9ORSB8fCBOR1hfSEFWRV9QRVJMX01VTFRJUExJQ0lUWSkKKyAgICBuZ3hfcG9vbF9jbGVhbnVwX3QgICpjbG47CiAKICAgICBjbG4gPSBuZ3hfcG9vbF9jbGVhbnVwX2FkZChjZi0+cG9vbCwgMCk7CiAgICAgaWYgKGNsbiA9PSBOVUxMKSB7CiAgICAgICAgIHJldHVybiBOR1hfQ09ORl9FUlJPUjsKICAgICB9CiAKKyNlbHNlCisgICAgc3RhdGljIFBlcmxJbnRlcnByZXRlciAgKnBlcmw7CisjZW5kaWYKKwogI2lmZGVmIE5HWF9QRVJMX01PRFVMRVMKICAgICBpZiAocG1jZi0+bW9kdWxlcy5kYXRhID09IE5VTEwpIHsKICAgICAgICAgcG1jZi0+bW9kdWxlcy5kYXRhID0gTkdYX1BFUkxfTU9EVUxFUzsKQEAgLTQ4OSw2ICs0ODMsMjAgQEAKICAgICAgICAgfQogICAgIH0KIAorI2lmICEoTkdYX0hBVkVfUEVSTF9DTE9ORSB8fCBOR1hfSEFWRV9QRVJMX01VTFRJUExJQ0lUWSkKKworICAgIGlmIChwZXJsKSB7CisgICAgICAgIGlmIChuZ3hfaHR0cF9wZXJsX3J1bl9yZXF1aXJlcygmcG1jZi0+cmVxdWlyZXMsIGNmLT5sb2cpICE9IE5HWF9PSykgeworICAgICAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgICAgICB9CisKKyAgICAgICAgcG1jZi0+cGVybCA9IHBlcmw7CisKKyAgICAgICAgcmV0dXJuIE5HWF9DT05GX09LOworICAgIH0KKworI2VuZGlmCisKICAgICBQRVJMX1NZU19JTklUKCZuZ3hfYXJnYywgJm5neF9hcmd2KTsKIAogICAgIHBtY2YtPnBlcmwgPSBuZ3hfaHR0cF9wZXJsX2NyZWF0ZV9pbnRlcnByZXRlcihwbWNmLCBjZi0+bG9nKTsKQEAgLTQ5OCw5ICs1MDYsMTcgQEAKICAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOwogICAgIH0KIAorI2lmIChOR1hfSEFWRV9QRVJMX0NMT05FIHx8IE5HWF9IQVZFX1BFUkxfTVVMVElQTElDSVRZKQorCiAgICAgY2xuLT5oYW5kbGVyID0gbmd4X2h0dHBfcGVybF9jbGVhbnVwX3Blcmw7CiAgICAgY2xuLT5kYXRhID0gcG1jZi0+cGVybDsKIAorI2Vsc2UKKworICAgIHBlcmwgPSBwbWNmLT5wZXJsOworCisjZW5kaWYKKwogICAgIHJldHVybiBOR1hfQ09ORl9PSzsKIH0KIApAQCAtNTExLDEwICs1MjcsNiBAQAogewogICAgIGludCAgICAgICAgICAgICAgICBuOwogICAgIGNoYXIgICAgICAgICAgICAgICplbWJlZGRpbmdbNl07Ci0gICAgY2hhciAgICAgICAgICAgICAqKnNjcmlwdDsKLSAgICBTVFJMRU4gICAgICAgICAgICAgbGVuOwotICAgIG5neF9zdHJfdCAgICAgICAgICBlcnI7Ci0gICAgbmd4X3VpbnRfdCAgICAgICAgIGk7CiAgICAgUGVybEludGVycHJldGVyICAgKnBlcmw7CiAKICAgICBuZ3hfbG9nX2RlYnVnMChOR1hfTE9HX0RFQlVHX0hUVFAsIGxvZywgMCwgImNyZWF0ZSBwZXJsIGludGVycHJldGVyIik7CkBAIC01ODMsMjIgKzU5NSw4IEBACiAgICAgICAgIGdvdG8gZmFpbDsKICAgICB9CiAKLSAgICBzY3JpcHQgPSBwbWNmLT5yZXF1aXJlcy5lbHRzOwotICAgIGZvciAoaSA9IDA7IGkgPCBwbWNmLT5yZXF1aXJlcy5uZWx0czsgaSsrKSB7Ci0gICAgICAgIHJlcXVpcmVfcHYoc2NyaXB0W2ldKTsKLQotICAgICAgICBpZiAoU3ZUUlVFKEVSUlNWKSkgewotCi0gICAgICAgICAgICBlcnIuZGF0YSA9ICh1X2NoYXIgKikgU3ZQVihFUlJTViwgbGVuKTsKLSAgICAgICAgICAgIGZvciAobGVuLS07IGVyci5kYXRhW2xlbl0gPT0gTEYgfHwgZXJyLmRhdGFbbGVuXSA9PSBDUjsgbGVuLS0pIHsKLSAgICAgICAgICAgICAgICAvKiB2b2lkICovCi0gICAgICAgICAgICB9Ci0gICAgICAgICAgICBlcnIubGVuID0gbGVuICsgMTsKLQotICAgICAgICAgICAgbmd4X2xvZ19lcnJvcihOR1hfTE9HX0VNRVJHLCBsb2csIDAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICJyZXF1aXJlX3B2KFwiJXNcIikgZmFpbGVkOiBcIiVWXCIiLCBzY3JpcHRbaV0sICZlcnIpOwotICAgICAgICAgICAgZ290byBmYWlsOwotICAgICAgICB9CisgICAgaWYgKG5neF9odHRwX3BlcmxfcnVuX3JlcXVpcmVzKCZwbWNmLT5yZXF1aXJlcywgbG9nKSAhPSBOR1hfT0spIHsKKyAgICAgICAgZ290byBmYWlsOwogICAgIH0KIAogICAgIH0KQEAgLTYxNyw2ICs2MTUsMzggQEAKIH0KIAogCitzdGF0aWMgbmd4X2ludF90CituZ3hfaHR0cF9wZXJsX3J1bl9yZXF1aXJlcyhuZ3hfYXJyYXlfdCAqcmVxdWlyZXMsIG5neF9sb2dfdCAqbG9nKQoreworICAgIGNoYXIgICAgICAgKipzY3JpcHQ7CisgICAgU1RSTEVOICAgICAgIGxlbjsKKyAgICBuZ3hfc3RyX3QgICAgZXJyOworICAgIG5neF91aW50X3QgICBpOworCisgICAgc2NyaXB0ID0gcmVxdWlyZXMtPmVsdHM7CisgICAgZm9yIChpID0gMDsgaSA8IHJlcXVpcmVzLT5uZWx0czsgaSsrKSB7CisKKyAgICAgICAgcmVxdWlyZV9wdihzY3JpcHRbaV0pOworCisgICAgICAgIGlmIChTdlRSVUUoRVJSU1YpKSB7CisKKyAgICAgICAgICAgIGVyci5kYXRhID0gKHVfY2hhciAqKSBTdlBWKEVSUlNWLCBsZW4pOworICAgICAgICAgICAgZm9yIChsZW4tLTsgZXJyLmRhdGFbbGVuXSA9PSBMRiB8fCBlcnIuZGF0YVtsZW5dID09IENSOyBsZW4tLSkgeworICAgICAgICAgICAgICAgIC8qIHZvaWQgKi8KKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIGVyci5sZW4gPSBsZW4gKyAxOworCisgICAgICAgICAgICBuZ3hfbG9nX2Vycm9yKE5HWF9MT0dfRU1FUkcsIGxvZywgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgInJlcXVpcmVfcHYoXCIlc1wiKSBmYWlsZWQ6IFwiJVZcIiIsIHNjcmlwdFtpXSwgJmVycik7CisKKyAgICAgICAgICAgIHJldHVybiBOR1hfRVJST1I7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gTkdYX09LOworfQorCisKICNpZiAoX19JTlRFTF9DT01QSUxFUikKIC8qCiAgKiBkaXNhYmxlICdkZWNsYXJhdGlvbiBoaWRlcyBwYXJhbWV0ZXIgIm15X3BlcmwiJyB3YXJuaW5nIGZvciBFTlRFUiBhbmQgTEVBVkUKQEAgLTc0MCwxMSArNzcwLDggQEAKICAgICAgICAgfQogICAgIH0KIAotICAgIGlmIChuZ3hfc3RybmNtcChwLCAic3ViICIsIDQpID09IDAKLSAgICAgICAgfHwgbmd4X3N0cm5jbXAocCwgInVzZSAiLCA0KSA9PSAwKQotICAgIHsKKyAgICBpZiAobmd4X3N0cm5jbXAocCwgInN1YiAiLCA0KSA9PSAwIHx8IG5neF9zdHJuY21wKHAsICJ1c2UgIiwgNCkgPT0gMCkgewogICAgICAgICAqc3YgPSBldmFsX3B2KChjaGFyICopIHAsIEZBTFNFKTsKLQogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC04MDUsMTAgKzgzMiwxMiBAQAogfQogCiAKKyNpZiAoTkdYX0hBVkVfUEVSTF9DTE9ORSB8fCBOR1hfSEFWRV9QRVJMX01VTFRJUExJQ0lUWSkKKwogc3RhdGljIHZvaWQKIG5neF9odHRwX3BlcmxfY2xlYW51cF9wZXJsKHZvaWQgKmRhdGEpCiB7Ci0gICAgUGVybEludGVycHJldGVyICpwZXJsID0gZGF0YTsKKyAgICBQZXJsSW50ZXJwcmV0ZXIgICpwZXJsID0gZGF0YTsKIAogICAgICh2b2lkKSBwZXJsX2Rlc3RydWN0KHBlcmwpOwogCkBAIC04MTcsNiArODQ2LDE3IEBACiAgICAgUEVSTF9TWVNfVEVSTSgpOwogfQogCisjZW5kaWYKKworCitzdGF0aWMgdm9pZAorbmd4X2h0dHBfcGVybF9jbGVhbnVwX3N2KHZvaWQgKmRhdGEpCit7CisgICAgU1YgICpzdiA9IGRhdGE7CisKKyAgICBTdlJFRkNOVF9kZWMoc3YpOworfQorCiAKIHN0YXRpYyBuZ3hfaW50X3QKIG5neF9odHRwX3BlcmxfcHJlY29uZmlndXJhdGlvbihuZ3hfY29uZl90ICpjZikKQEAgLTkwOCw2ICs5NDgsNyBAQAogICAgIG5neF9odHRwX3BlcmxfbG9jX2NvbmZfdCAqcGxjZiA9IGNvbmY7CiAKICAgICBuZ3hfc3RyX3QgICAgICAgICAgICAgICAgICAqdmFsdWU7CisgICAgbmd4X3Bvb2xfY2xlYW51cF90ICAgICAgICAgKmNsbjsKICAgICBuZ3hfaHR0cF9jb3JlX2xvY19jb25mX3QgICAqY2xjZjsKICAgICBuZ3hfaHR0cF9wZXJsX21haW5fY29uZl90ICAqcG1jZjsKIApAQCAtOTI3LDYgKzk2OCwxMSBAQAogICAgICAgICB9CiAgICAgfQogCisgICAgY2xuID0gbmd4X3Bvb2xfY2xlYW51cF9hZGQoY2YtPnBvb2wsIDApOworICAgIGlmIChjbG4gPT0gTlVMTCkgeworICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CisgICAgfQorCiAgICAgcGxjZi0+aGFuZGxlciA9IHZhbHVlWzFdOwogCiAgICAgewpAQCAtOTQ3LDYgKzk5Myw5IEBACiAKICAgICB9CiAKKyAgICBjbG4tPmhhbmRsZXIgPSBuZ3hfaHR0cF9wZXJsX2NsZWFudXBfc3Y7CisgICAgY2xuLT5kYXRhID0gcGxjZi0+c3ViOworCiAgICAgY2xjZiA9IG5neF9odHRwX2NvbmZfZ2V0X21vZHVsZV9sb2NfY29uZihjZiwgbmd4X2h0dHBfY29yZV9tb2R1bGUpOwogICAgIGNsY2YtPmhhbmRsZXIgPSBuZ3hfaHR0cF9wZXJsX2hhbmRsZXI7CiAKQEAgLTk1OSw2ICsxMDA4LDcgQEAKIHsKICAgICBuZ3hfaW50X3QgICAgICAgICAgICAgICAgICAgaW5kZXg7CiAgICAgbmd4X3N0cl90ICAgICAgICAgICAgICAgICAgKnZhbHVlOworICAgIG5neF9wb29sX2NsZWFudXBfdCAgICAgICAgICpjbG47CiAgICAgbmd4X2h0dHBfdmFyaWFibGVfdCAgICAgICAgKnY7CiAgICAgbmd4X2h0dHBfcGVybF92YXJpYWJsZV90ICAgKnB2OwogICAgIG5neF9odHRwX3BlcmxfbWFpbl9jb25mX3QgICpwbWNmOwpAQCAtOTk3LDYgKzEwNDcsMTEgQEAKICAgICAgICAgfQogICAgIH0KIAorICAgIGNsbiA9IG5neF9wb29sX2NsZWFudXBfYWRkKGNmLT5wb29sLCAwKTsKKyAgICBpZiAoY2xuID09IE5VTEwpIHsKKyAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgIH0KKwogICAgIHB2LT5oYW5kbGVyID0gdmFsdWVbMl07CiAKICAgICB7CkBAIC0xMDE3LDYgKzEwNzIsOSBAQAogCiAgICAgfQogCisgICAgY2xuLT5oYW5kbGVyID0gbmd4X2h0dHBfcGVybF9jbGVhbnVwX3N2OworICAgIGNsbi0+ZGF0YSA9IHB2LT5zdWI7CisKICAgICB2LT5nZXRfaGFuZGxlciA9IG5neF9odHRwX3BlcmxfdmFyaWFibGU7CiAgICAgdi0+ZGF0YSA9ICh1aW50cHRyX3QpIHB2OwogCmRpZmYgLS1naXQgYS9zcmMvaHR0cC9uZ3hfaHR0cC5jIGIvc3JjL2h0dHAvbmd4X2h0dHAuYwppbmRleCBhMTViM2UzLi44ODY2N2M2IDEwMDY0NAotLS0gYS9zcmMvaHR0cC9uZ3hfaHR0cC5jCisrKyBiL3NyYy9odHRwL25neF9odHRwLmMKQEAgLTc5LDExICs3OSwxMyBAQAogICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgbWksIG0sIHMsIGwsIHAsIGEsIGk7CiAgICAgbmd4X3VpbnRfdCAgICAgICAgICAgICAgICAgICBsYXN0LCBiaW5kX2FsbCwgZG9uZTsKICAgICBuZ3hfY29uZl90ICAgICAgICAgICAgICAgICAgIHBjZjsKLSAgICBuZ3hfYXJyYXlfdCAgICAgICAgICAgICAgICAgIGluX3BvcnRzOworICAgIG5neF9hcnJheV90ICAgICAgICAgICAgICAgICAgaGVhZGVyc19pbiwgaW5fcG9ydHM7CisgICAgbmd4X2hhc2hfa2V5X3QgICAgICAgICAgICAgICpoazsKICAgICBuZ3hfaGFzaF9pbml0X3QgICAgICAgICAgICAgIGhhc2g7CiAgICAgbmd4X2xpc3RlbmluZ190ICAgICAgICAgICAgICpsczsKICAgICBuZ3hfaHR0cF9saXN0ZW5fdCAgICAgICAgICAgKmxzY2Y7CiAgICAgbmd4X2h0dHBfbW9kdWxlX3QgICAgICAgICAgICptb2R1bGU7CisgICAgbmd4X2h0dHBfaGVhZGVyX3QgICAgICAgICAgICpoZWFkZXI7CiAgICAgbmd4X2h0dHBfaW5fcG9ydF90ICAgICAgICAgICpoaXA7CiAgICAgbmd4X2h0dHBfaGFuZGxlcl9wdCAgICAgICAgICpoOwogICAgIG5neF9odHRwX2NvbmZfY3R4X3QgICAgICAgICAqY3R4OwpAQCAtMzczLDIxICszNzUsMzUgQEAKICAgICBjbWNmLT5waGFzZXNbTkdYX0hUVFBfTE9HX1BIQVNFXS50eXBlID0gTkdYX09LOwogCiAKLSAgICBjbWNmLT5oZWFkZXJzX2luX2hhc2gubWF4X3NpemUgPSAyMDA7Ci0gICAgY21jZi0+aGVhZGVyc19pbl9oYXNoLmJ1Y2tldF9saW1pdCA9IDE7Ci0gICAgY21jZi0+aGVhZGVyc19pbl9oYXNoLmJ1Y2tldF9zaXplID0gc2l6ZW9mKG5neF9odHRwX2hlYWRlcl90KTsKLSAgICBjbWNmLT5oZWFkZXJzX2luX2hhc2gubmFtZSA9ICJodHRwIGhlYWRlcnNfaW4iOwotCi0gICAgaWYgKG5neF9oYXNoMF9pbml0KCZjbWNmLT5oZWFkZXJzX2luX2hhc2gsIGNmLT5wb29sLCBuZ3hfaHR0cF9oZWFkZXJzX2luLCAwKQorICAgIGlmIChuZ3hfYXJyYXlfaW5pdCgmaGVhZGVyc19pbiwgY2YtPnRlbXBfcG9vbCwgMzIsIHNpemVvZihuZ3hfaGFzaF9rZXlfdCkpCiAgICAgICAgICE9IE5HWF9PSykKICAgICB7CiAgICAgICAgIHJldHVybiBOR1hfQ09ORl9FUlJPUjsKICAgICB9CiAKLSAgICBuZ3hfbG9nX2RlYnVnMihOR1hfTE9HX0RFQlVHX0hUVFAsIGNmLT5sb2csIDAsCi0gICAgICAgICAgICAgICAgICAgImh0dHAgaGVhZGVyc19pbiBoYXNoIHNpemU6ICV1aSwgbWF4IGJ1Y2tldHMgcGVyIGVudHJ5OiAldWkiLAotICAgICAgICAgICAgICAgICAgIGNtY2YtPmhlYWRlcnNfaW5faGFzaC5oYXNoX3NpemUsCi0gICAgICAgICAgICAgICAgICAgY21jZi0+aGVhZGVyc19pbl9oYXNoLm1pbl9idWNrZXRzKTsKKyAgICBmb3IgKGhlYWRlciA9IG5neF9odHRwX2hlYWRlcnNfaW47IGhlYWRlci0+bmFtZS5sZW47IGhlYWRlcisrKSB7CisgICAgICAgIGhrID0gbmd4X2FycmF5X3B1c2goJmhlYWRlcnNfaW4pOworICAgICAgICBpZiAoaGsgPT0gTlVMTCkgeworICAgICAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgICAgICB9CisKKyAgICAgICAgaGstPmtleSA9IGhlYWRlci0+bmFtZTsKKyAgICAgICAgaGstPmtleV9oYXNoID0gbmd4X2hhc2hfa2V5X2xjKGhlYWRlci0+bmFtZS5kYXRhLCBoZWFkZXItPm5hbWUubGVuKTsKKyAgICAgICAgaGstPnZhbHVlID0gaGVhZGVyOworICAgIH0KKworICAgIGhhc2guaGFzaCA9ICZjbWNmLT5oZWFkZXJzX2luX2hhc2g7CisgICAgaGFzaC5rZXkgPSBuZ3hfaGFzaF9rZXlfbGM7CisgICAgaGFzaC5tYXhfc2l6ZSA9IDUxMjsKKyAgICBoYXNoLmJ1Y2tldF9zaXplID0gbmd4X2NhY2hlbGluZV9zaXplOworICAgIGhhc2gubmFtZSA9ICJoZWFkZXJzX2luX2hhc2giOworICAgIGhhc2gucG9vbCA9IGNmLT5wb29sOworICAgIGhhc2gudGVtcF9wb29sID0gTlVMTDsKKworICAgIGlmIChuZ3hfaGFzaF9pbml0KCZoYXNoLCBoZWFkZXJzX2luLmVsdHMsIGhlYWRlcnNfaW4ubmVsdHMpICE9IE5HWF9PSykgeworICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CisgICAgfQorCiAKICAgICBmb3IgKG0gPSAwOyBuZ3hfbW9kdWxlc1ttXTsgbSsrKSB7CiAgICAgICAgIGlmIChuZ3hfbW9kdWxlc1ttXS0+dHlwZSAhPSBOR1hfSFRUUF9NT0RVTEUpIHsKZGlmZiAtLWdpdCBhL3NyYy9odHRwL25neF9odHRwX2NvcmVfbW9kdWxlLmMgYi9zcmMvaHR0cC9uZ3hfaHR0cF9jb3JlX21vZHVsZS5jCmluZGV4IDkzMWJlODguLjU0MDNmZGIgMTAwNjQ0Ci0tLSBhL3NyYy9odHRwL25neF9odHRwX2NvcmVfbW9kdWxlLmMKKysrIGIvc3JjL2h0dHAvbmd4X2h0dHBfY29yZV9tb2R1bGUuYwpAQCAtOTIxLDQyICs5MjEsNDMgQEAKIHsKICAgICB1X2NoYXIgICAgICAgICAgICAgICAgICAgICBjLCAqcCwgKmV4dGVuOwogICAgIG5neF9zdHJfdCAgICAgICAgICAgICAgICAgKnR5cGU7Ci0gICAgbmd4X3VpbnRfdCAgICAgICAgICAgICAgICAgaTsKKyAgICBuZ3hfdWludF90ICAgICAgICAgICAgICAgICBpLCBoYXNoOwogICAgIG5neF9odHRwX2NvcmVfbG9jX2NvbmZfdCAgKmNsY2Y7CiAKICAgICBjbGNmID0gbmd4X2h0dHBfZ2V0X21vZHVsZV9sb2NfY29uZihyLCBuZ3hfaHR0cF9jb3JlX21vZHVsZSk7CiAKICAgICBpZiAoci0+ZXh0ZW4ubGVuKSB7CiAKLSAgICAgICAgaWYgKCFyLT5sb3dfY2FzZV9leHRlbikgewotICAgICAgICAgICAgZm9yIChpID0gMDsgaSA8IHItPmV4dGVuLmxlbjsgaSsrKSB7Ci0gICAgICAgICAgICAgICAgYyA9IHItPmV4dGVuLmRhdGFbaV07Ci0gICAgICAgICAgICAgICAgaWYgKGMgPj0gJ0EnICYmIGMgPD0gJ1onKSB7Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIH0KKyAgICAgICAgaGFzaCA9IDA7CiAKLSAgICAgICAgICAgIGlmIChpIDwgci0+ZXh0ZW4ubGVuKSB7CisgICAgICAgIGZvciAoaSA9IDA7IGkgPCByLT5leHRlbi5sZW47IGkrKykgeworICAgICAgICAgICAgYyA9IHItPmV4dGVuLmRhdGFbaV07CisKKyAgICAgICAgICAgIGlmIChjID49ICdBJyAmJiBjIDw9ICdaJykgeworCiAgICAgICAgICAgICAgICAgcCA9IG5neF9wYWxsb2Moci0+cG9vbCwgci0+ZXh0ZW4ubGVuKTsKICAgICAgICAgICAgICAgICBpZiAocCA9PSBOVUxMKSB7CiAgICAgICAgICAgICAgICAgICAgIHJldHVybiBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1I7CiAgICAgICAgICAgICAgICAgfQogCisgICAgICAgICAgICAgICAgaGFzaCA9IDA7CiAgICAgICAgICAgICAgICAgZXh0ZW4gPSBwOwogCiAgICAgICAgICAgICAgICAgZm9yIChpID0gMDsgaSA8IHItPmV4dGVuLmxlbjsgaSsrKSB7Ci0gICAgICAgICAgICAgICAgICAgIGMgPSByLT5leHRlbi5kYXRhW2ldOwotICAgICAgICAgICAgICAgICAgICAqcCsrID0gbmd4X3RvbG93ZXIoYyk7CisgICAgICAgICAgICAgICAgICAgIGMgPSBuZ3hfdG9sb3dlcihyLT5leHRlbi5kYXRhW2ldKTsKKyAgICAgICAgICAgICAgICAgICAgaGFzaCA9IG5neF9oYXNoKGhhc2gsIGMpOworICAgICAgICAgICAgICAgICAgICAqcCsrID0gYzsKICAgICAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgICAgICByLT5leHRlbi5kYXRhID0gZXh0ZW47CisKKyAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgIH0KIAotICAgICAgICAgICAgci0+bG93X2Nhc2VfZXh0ZW4gPSAxOworICAgICAgICAgICAgaGFzaCA9IG5neF9oYXNoKGhhc2gsIGMpOwogICAgICAgICB9CiAKLSAgICAgICAgdHlwZSA9IG5neF9oYXNoX2ZpbmQoJmNsY2YtPnR5cGVzX2hhc2gsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5neF9oYXNoX2tleShyLT5leHRlbi5kYXRhLCByLT5leHRlbi5sZW4pLAorICAgICAgICB0eXBlID0gbmd4X2hhc2hfZmluZCgmY2xjZi0+dHlwZXNfaGFzaCwgaGFzaCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgci0+ZXh0ZW4uZGF0YSwgci0+ZXh0ZW4ubGVuKTsKIAogICAgICAgICBpZiAodHlwZSkgewpAQCAtOTgxLDE3ICs5ODIsOSBAQAogCiAgICAgZm9yIChpID0gci0+dXJpLmxlbiAtIDE7IGkgPiAxOyBpLS0pIHsKICAgICAgICAgaWYgKHItPnVyaS5kYXRhW2ldID09ICcuJyAmJiByLT51cmkuZGF0YVtpIC0gMV0gIT0gJy8nKSB7CisKICAgICAgICAgICAgIHItPmV4dGVuLmxlbiA9IHItPnVyaS5sZW4gLSBpIC0gMTsKLQotICAgICAgICAgICAgaWYgKHItPmV4dGVuLmxlbiA+IDApIHsKLSAgICAgICAgICAgICAgICByLT5leHRlbi5kYXRhID0gbmd4X3BhbGxvYyhyLT5wb29sLCByLT5leHRlbi5sZW4gKyAxKTsKLSAgICAgICAgICAgICAgICBpZiAoci0+ZXh0ZW4uZGF0YSA9PSBOVUxMKSB7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiBOR1hfRVJST1I7Ci0gICAgICAgICAgICAgICAgfQotCi0gICAgICAgICAgICAgICAgbmd4X2NweXN0cm4oci0+ZXh0ZW4uZGF0YSwgJnItPnVyaS5kYXRhW2kgKyAxXSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByLT5leHRlbi5sZW4gKyAxKTsKLSAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHItPmV4dGVuLmRhdGEgPSAmci0+dXJpLmRhdGFbaSArIDFdOwogCiAgICAgICAgICAgICBicmVhazsKIApAQCAtMTAwMCw4ICs5OTMsNiBAQAogICAgICAgICB9CiAgICAgfQogCi0gICAgci0+bG93X2Nhc2VfZXh0ZW4gPSAwOwotCiAgICAgcmV0dXJuIE5HWF9PSzsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2h0dHAvbmd4X2h0dHBfY29yZV9tb2R1bGUuaCBiL3NyYy9odHRwL25neF9odHRwX2NvcmVfbW9kdWxlLmgKaW5kZXggNjgxYmIyNy4uNGY3ODIzZCAxMDA2NDQKLS0tIGEvc3JjL2h0dHAvbmd4X2h0dHBfY29yZV9tb2R1bGUuaAorKysgYi9zcmMvaHR0cC9uZ3hfaHR0cF9jb3JlX21vZHVsZS5oCkBAIC03Miw3ICs3Miw3IEBACiAKICAgICBuZ3hfaHR0cF9waGFzZV90ICAgICAgICAgICBwaGFzZXNbTkdYX0hUVFBfTE9HX1BIQVNFICsgMV07CiAKLSAgICBuZ3hfaGFzaDBfdCAgICAgICAgICAgICAgICBoZWFkZXJzX2luX2hhc2g7CisgICAgbmd4X2hhc2hfdCAgICAgICAgICAgICAgICAgaGVhZGVyc19pbl9oYXNoOwogCiAgICAgbmd4X2hhc2hfdCAgICAgICAgICAgICAgICAgdmFyaWFibGVzX2hhc2g7CiAKZGlmZiAtLWdpdCBhL3NyYy9odHRwL25neF9odHRwX3BhcnNlLmMgYi9zcmMvaHR0cC9uZ3hfaHR0cF9wYXJzZS5jCmluZGV4IDFiMWU5NjMuLjQyNmFhOGEgMTAwNjQ0Ci0tLSBhL3NyYy9odHRwL25neF9odHRwX3BhcnNlLmMKKysrIGIvc3JjL2h0dHAvbmd4X2h0dHBfcGFyc2UuYwpAQCAtOSw2ICs5LDggQEAKICNpbmNsdWRlIDxuZ3hfaHR0cC5oPgogCiAKKy8qIGdjYywgaWNjLCBtc3ZjIGFuZCBvdGhlcnMgY29tcGlsZSB0aGVzZSBzd2l0Y2hlcyBhcyBhbiBqdW1wIHRhYmxlICovCisKIG5neF9pbnRfdAogbmd4X2h0dHBfcGFyc2VfcmVxdWVzdF9saW5lKG5neF9odHRwX3JlcXVlc3RfdCAqciwgbmd4X2J1Zl90ICpiKQogewpAQCAtNDMsOCArNDUsNiBAQAogICAgIGZvciAocCA9IGItPnBvczsgcCA8IGItPmxhc3Q7IHArKykgewogICAgICAgICBjaCA9ICpwOwogCi0gICAgICAgIC8qIGdjYyAyLjk1LjIgYW5kIG1zdmMgNi4wIGNvbXBpbGUgdGhpcyBzd2l0Y2ggYXMgYW4ganVtcCB0YWJsZSAqLwotCiAgICAgICAgIHN3aXRjaCAoc3RhdGUpIHsKIAogICAgICAgICAvKiBIVFRQIG1ldGhvZHM6IEdFVCwgSEVBRCwgUE9TVCAqLwpAQCAtNTI4LDcgKzUyOCw3IEBACiBuZ3hfaHR0cF9wYXJzZV9oZWFkZXJfbGluZShuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIsIG5neF9idWZfdCAqYikKIHsKICAgICB1X2NoYXIgICAgICBjLCBjaCwgKnA7Ci0gICAgbmd4X3VpbnRfdCAgaGFzaDsKKyAgICBuZ3hfdWludF90ICBoYXNoLCBpOwogICAgIGVudW0gewogICAgICAgICBzd19zdGFydCA9IDAsCiAgICAgICAgIHN3X25hbWUsCkBAIC01NDAsOCArNTQwLDE5IEBACiAgICAgICAgIHN3X2hlYWRlcl9hbG1vc3RfZG9uZQogICAgIH0gc3RhdGU7CiAKKyAgICBzdGF0aWMgdV9jaGFyICBsb3djYXNlW10gPQorICAgICAgICAiXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMCIKKyAgICAgICAgIlwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwLVwwXDAiICIwMTIzNDU2Nzg5XDBcMFwwXDBcMFwwIgorICAgICAgICAiXDBhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5elwwXDBcMFwwXDAiCisgICAgICAgICJcMGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6XDBcMFwwXDBcMCIKKyAgICAgICAgIlwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDAiCisgICAgICAgICJcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwIgorICAgICAgICAiXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMCIKKyAgICAgICAgIlwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwXDBcMFwwIjsKKwogICAgIHN0YXRlID0gci0+c3RhdGU7CiAgICAgaGFzaCA9IHItPmhlYWRlcl9oYXNoOworICAgIGkgPSByLT5sb3djYXNlX2luZGV4OwogCiAgICAgZm9yIChwID0gYi0+cG9zOyBwIDwgYi0+bGFzdDsgcCsrKSB7CiAgICAgICAgIGNoID0gKnA7CkBAIC01NjQsMTQgKzU3NSwxMiBAQAogICAgICAgICAgICAgICAgIHN0YXRlID0gc3dfbmFtZTsKICAgICAgICAgICAgICAgICByLT5oZWFkZXJfbmFtZV9zdGFydCA9IHA7CiAKLSAgICAgICAgICAgICAgICBjID0gKHVfY2hhcikgKGNoIHwgMHgyMCk7Ci0gICAgICAgICAgICAgICAgaWYgKGMgPj0gJ2EnICYmIGMgPD0gJ3onKSB7Ci0gICAgICAgICAgICAgICAgICAgIGhhc2ggPSBjOwotICAgICAgICAgICAgICAgICAgICBicmVhazsKLSAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgYyA9IGxvd2Nhc2VbY2hdOwogCi0gICAgICAgICAgICAgICAgaWYgKGNoID49ICcwJyAmJiBjaCA8PSAnOScpIHsKLSAgICAgICAgICAgICAgICAgICAgaGFzaCA9IGNoOworICAgICAgICAgICAgICAgIGlmIChjKSB7CisgICAgICAgICAgICAgICAgICAgIGhhc2ggPSBuZ3hfaGFzaCgwLCBjKTsKKyAgICAgICAgICAgICAgICAgICAgci0+bG93Y2FzZV9oZWFkZXJbMF0gPSBjOworICAgICAgICAgICAgICAgICAgICBpID0gMTsKICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgICAgICAgfQogCkBAIC01ODQsOSArNTkzLDEyIEBACiAKICAgICAgICAgLyogaGVhZGVyIG5hbWUgKi8KICAgICAgICAgY2FzZSBzd19uYW1lOgotICAgICAgICAgICAgYyA9ICh1X2NoYXIpIChjaCB8IDB4MjApOwotICAgICAgICAgICAgaWYgKGMgPj0gJ2EnICYmIGMgPD0gJ3onKSB7Ci0gICAgICAgICAgICAgICAgaGFzaCArPSBjOworICAgICAgICAgICAgYyA9IGxvd2Nhc2VbY2hdOworCisgICAgICAgICAgICBpZiAoYykgeworICAgICAgICAgICAgICAgIGhhc2ggPSBuZ3hfaGFzaChoYXNoLCBjKTsKKyAgICAgICAgICAgICAgICByLT5sb3djYXNlX2hlYWRlcltpKytdID0gYzsKKyAgICAgICAgICAgICAgICBpICY9IH5OR1hfSFRUUF9MQ19IRUFERVJfTEVOOwogICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgfQogCkBAIC01OTYsMTYgKzYwOCw2IEBACiAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIGlmIChjaCA9PSAnLScpIHsKLSAgICAgICAgICAgICAgICBoYXNoICs9IGNoOwotICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICAgICAgfQotCi0gICAgICAgICAgICBpZiAoY2ggPj0gJzAnICYmIGNoIDw9ICc5JykgewotICAgICAgICAgICAgICAgIGhhc2ggKz0gY2g7Ci0gICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICB9Ci0KICAgICAgICAgICAgIGlmIChjaCA9PSBDUikgewogICAgICAgICAgICAgICAgIHItPmhlYWRlcl9uYW1lX2VuZCA9IHA7CiAgICAgICAgICAgICAgICAgci0+aGVhZGVyX3N0YXJ0ID0gcDsKQEAgLTcyNiw2ICs3MjgsNyBAQAogICAgIGItPnBvcyA9IHA7CiAgICAgci0+c3RhdGUgPSBzdGF0ZTsKICAgICByLT5oZWFkZXJfaGFzaCA9IGhhc2g7CisgICAgci0+bG93Y2FzZV9pbmRleCA9IGk7CiAKICAgICByZXR1cm4gTkdYX0FHQUlOOwogCkBAIC03MzQsNiArNzM3LDcgQEAKICAgICBiLT5wb3MgPSBwICsgMTsKICAgICByLT5zdGF0ZSA9IHN3X3N0YXJ0OwogICAgIHItPmhlYWRlcl9oYXNoID0gaGFzaDsKKyAgICByLT5sb3djYXNlX2luZGV4ID0gaTsKIAogICAgIHJldHVybiBOR1hfT0s7CiAKZGlmZiAtLWdpdCBhL3NyYy9odHRwL25neF9odHRwX3JlcXVlc3QuYyBiL3NyYy9odHRwL25neF9odHRwX3JlcXVlc3QuYwppbmRleCA1MjA3ZmExLi5kOGQ4OTM2IDEwMDY0NAotLS0gYS9zcmMvaHR0cC9uZ3hfaHR0cF9yZXF1ZXN0LmMKKysrIGIvc3JjL2h0dHAvbmd4X2h0dHBfcmVxdWVzdC5jCkBAIC0yNSw3ICsyNSw4IEBACiAgICAgbmd4X3RhYmxlX2VsdF90ICpoLCBuZ3hfdWludF90IG9mZnNldCk7CiAKIHN0YXRpYyBuZ3hfaW50X3Qgbmd4X2h0dHBfcHJvY2Vzc19yZXF1ZXN0X2hlYWRlcihuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIpOwotc3RhdGljIHZvaWQgbmd4X2h0dHBfZmluZF92aXJ0dWFsX3NlcnZlcihuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIpOworc3RhdGljIHZvaWQgbmd4X2h0dHBfZmluZF92aXJ0dWFsX3NlcnZlcihuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIsCisgICAgbmd4X2h0dHBfdmlydHVhbF9uYW1lc190ICp2biwgbmd4X3VpbnRfdCBoYXNoKTsKIAogc3RhdGljIHZvaWQgbmd4X2h0dHBfcmVxdWVzdF9oYW5kbGVyKG5neF9ldmVudF90ICpldik7CiBzdGF0aWMgbmd4X2ludF90IG5neF9odHRwX3NldF93cml0ZV9oYW5kbGVyKG5neF9odHRwX3JlcXVlc3RfdCAqcik7CkBAIC03MzksOCArNzQwLDggQEAKIHsKICAgICBzc2l6ZV90ICAgICAgICAgICAgICAgICAgICAgbjsKICAgICBuZ3hfaW50X3QgICAgICAgICAgICAgICAgICAgcmMsIHJ2OwotICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICBrZXk7CiAgICAgbmd4X3N0cl90ICAgICAgICAgICAgICAgICAgIGhlYWRlcjsKKyAgICBuZ3hfdWludF90ICAgICAgICAgICAgICAgICAgaTsKICAgICBuZ3hfdGFibGVfZWx0X3QgICAgICAgICAgICAqaDsKICAgICBuZ3hfY29ubmVjdGlvbl90ICAgICAgICAgICAqYzsKICAgICBuZ3hfaHR0cF9oZWFkZXJfdCAgICAgICAgICAqaGg7CkBAIC03NjMsNyArNzY0LDYgQEAKIAogICAgIGNtY2YgPSBuZ3hfaHR0cF9nZXRfbW9kdWxlX21haW5fY29uZihyLCBuZ3hfaHR0cF9jb3JlX21vZHVsZSk7CiAgICAgY3NjZiA9IG5neF9odHRwX2dldF9tb2R1bGVfc3J2X2NvbmYociwgbmd4X2h0dHBfY29yZV9tb2R1bGUpOwotICAgIGhoID0gKG5neF9odHRwX2hlYWRlcl90ICopIGNtY2YtPmhlYWRlcnNfaW5faGFzaC5idWNrZXRzOwogCiAgICAgcmMgPSBOR1hfQUdBSU47CiAKQEAgLTg0MSwxNiArODQxLDI4IEBACiAgICAgICAgICAgICBoLT52YWx1ZS5kYXRhID0gci0+aGVhZGVyX3N0YXJ0OwogICAgICAgICAgICAgaC0+dmFsdWUuZGF0YVtoLT52YWx1ZS5sZW5dID0gJ1wwJzsKIAotICAgICAgICAgICAga2V5ID0gaC0+aGFzaCAlIGNtY2YtPmhlYWRlcnNfaW5faGFzaC5oYXNoX3NpemU7CisgICAgICAgICAgICBoLT5sb3djYXNlX2tleSA9IG5neF9wYWxsb2Moci0+cG9vbCwgaC0+a2V5Lmxlbik7CisgICAgICAgICAgICBpZiAoaC0+bG93Y2FzZV9rZXkgPT0gTlVMTCkgeworICAgICAgICAgICAgICAgIG5neF9odHRwX2Nsb3NlX3JlcXVlc3QociwgTkdYX0hUVFBfSU5URVJOQUxfU0VSVkVSX0VSUk9SKTsKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIGlmIChoaFtrZXldLm5hbWUubGVuID09IGgtPmtleS5sZW4KLSAgICAgICAgICAgICAgICAmJiBuZ3hfc3RyY2FzZWNtcChoaFtrZXldLm5hbWUuZGF0YSwgaC0+a2V5LmRhdGEpID09IDApCi0gICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgaWYgKGhoW2tleV0uaGFuZGxlcihyLCBoLCBoaFtrZXldLm9mZnNldCkgIT0gTkdYX09LKSB7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIGlmIChoLT5rZXkubGVuID09IHItPmxvd2Nhc2VfaW5kZXgpIHsKKyAgICAgICAgICAgICAgICBuZ3hfbWVtY3B5KGgtPmxvd2Nhc2Vfa2V5LCByLT5sb3djYXNlX2hlYWRlciwgaC0+a2V5Lmxlbik7CisKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgZm9yIChpID0gMDsgaSA8IGgtPmtleS5sZW47IGkrKykgeworICAgICAgICAgICAgICAgICAgICBoLT5sb3djYXNlX2tleVtpXSA9IG5neF90b2xvd2VyKGgtPmxvd2Nhc2Vfa2V5W2ldKTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAKKyAgICAgICAgICAgIGhoID0gbmd4X2hhc2hfZmluZCgmY21jZi0+aGVhZGVyc19pbl9oYXNoLCBoLT5oYXNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGgtPmxvd2Nhc2Vfa2V5LCBoLT5rZXkubGVuKTsKKworICAgICAgICAgICAgaWYgKGhoICYmIGhoLT5oYW5kbGVyKHIsIGgsIGhoLT5vZmZzZXQpICE9IE5HWF9PSykgeworICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIH0KKwogICAgICAgICAgICAgbmd4X2xvZ19kZWJ1ZzIoTkdYX0xPR19ERUJVR19IVFRQLCByLT5jb25uZWN0aW9uLT5sb2csIDAsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAiaHR0cCBoZWFkZXI6IFwiJVY6ICVWXCIiLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgJmgtPmtleSwgJmgtPnZhbHVlKTsKQEAgLTExNzQsMTIgKzExODYsMTYgQEAKIHsKICAgICBzaXplX3QgICAgICAgICAgICAgICAgICAgIGxlbjsKICAgICB1X2NoYXIgICAgICAgICAgICAgICAgICAgKnVhLCAqdXNlcl9hZ2VudCwgY2g7CisgICAgbmd4X3VpbnRfdCAgICAgICAgICAgICAgICBoYXNoOwogI2lmIChOR1hfSFRUUF9TU0wpCiAgICAgbG9uZyAgICAgICAgICAgICAgICAgICAgICByYzsKICAgICBuZ3hfaHR0cF9zc2xfc3J2X2NvbmZfdCAgKnNzY2Y7CiAjZW5kaWYKIAogICAgIGlmIChyLT5oZWFkZXJzX2luLmhvc3QpIHsKKworICAgICAgICBoYXNoID0gMDsKKwogICAgICAgICBmb3IgKGxlbiA9IDA7IGxlbiA8IHItPmhlYWRlcnNfaW4uaG9zdC0+dmFsdWUubGVuOyBsZW4rKykgewogICAgICAgICAgICAgY2ggPSByLT5oZWFkZXJzX2luLmhvc3QtPnZhbHVlLmRhdGFbbGVuXTsKIApAQCAtMTE4NywxNiArMTIwMywyMSBAQAogICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgfQogCi0gICAgICAgICAgICByLT5oZWFkZXJzX2luLmhvc3QtPnZhbHVlLmRhdGFbbGVuXSA9IG5neF90b2xvd2VyKGNoKTsKKyAgICAgICAgICAgIGNoID0gbmd4X3RvbG93ZXIoY2gpOworICAgICAgICAgICAgci0+aGVhZGVyc19pbi5ob3N0LT52YWx1ZS5kYXRhW2xlbl0gPSBjaDsKKyAgICAgICAgICAgIGhhc2ggPSBuZ3hfaGFzaChoYXNoLCBjaCk7CiAgICAgICAgIH0KIAotICAgICAgICBpZiAoci0+aGVhZGVyc19pbi5ob3N0LT52YWx1ZS5kYXRhW2xlbiAtIDFdID09ICcuJykgeworICAgICAgICBpZiAobGVuICYmIHItPmhlYWRlcnNfaW4uaG9zdC0+dmFsdWUuZGF0YVtsZW4gLSAxXSA9PSAnLicpIHsKICAgICAgICAgICAgIGxlbi0tOworICAgICAgICAgICAgaGFzaCA9IG5neF9oYXNoX2tleShyLT5oZWFkZXJzX2luLmhvc3QtPnZhbHVlLmRhdGEsIGxlbik7CiAgICAgICAgIH0KIAogICAgICAgICByLT5oZWFkZXJzX2luLmhvc3RfbmFtZV9sZW4gPSBsZW47CiAKLSAgICAgICAgbmd4X2h0dHBfZmluZF92aXJ0dWFsX3NlcnZlcihyKTsKKyAgICAgICAgaWYgKHItPnZpcnR1YWxfbmFtZXMpIHsKKyAgICAgICAgICAgIG5neF9odHRwX2ZpbmRfdmlydHVhbF9zZXJ2ZXIociwgci0+dmlydHVhbF9uYW1lcywgaGFzaCk7CisgICAgICAgIH0KIAogICAgIH0gZWxzZSB7CiAgICAgICAgIGlmIChyLT5odHRwX3ZlcnNpb24gPiBOR1hfSFRUUF9WRVJTSU9OXzEwKSB7CkBAIC0xMzQ1LDI3ICsxMzY2LDE5IEBACiAKIAogc3RhdGljIHZvaWQKLW5neF9odHRwX2ZpbmRfdmlydHVhbF9zZXJ2ZXIobmd4X2h0dHBfcmVxdWVzdF90ICpyKQorbmd4X2h0dHBfZmluZF92aXJ0dWFsX3NlcnZlcihuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIsCisgICAgbmd4X2h0dHBfdmlydHVhbF9uYW1lc190ICp2biwgbmd4X3VpbnRfdCBoYXNoKQogewogICAgIHNpemVfdCAgICAgICAgICAgICAgICAgICAgIGxlbjsKICAgICB1X2NoYXIgICAgICAgICAgICAgICAgICAgICpob3N0OwotICAgIG5neF9odHRwX3ZpcnR1YWxfbmFtZXNfdCAgKnZuOwogICAgIG5neF9odHRwX2NvcmVfbG9jX2NvbmZfdCAgKmNsY2Y7CiAgICAgbmd4X2h0dHBfY29yZV9zcnZfY29uZl90ICAqY3NjZjsKIAotICAgIHZuID0gci0+dmlydHVhbF9uYW1lczsKLQotICAgIGlmICh2biA9PSBOVUxMKSB7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KICAgICBob3N0ID0gci0+aGVhZGVyc19pbi5ob3N0LT52YWx1ZS5kYXRhOwogICAgIGxlbiA9IHItPmhlYWRlcnNfaW4uaG9zdF9uYW1lX2xlbjsKIAotICAgIC8qIFNUVUI6IG5neF9oYXNoX2tleSgpIGhlcmUgaXMgU1RVQiAqLwotCiAgICAgaWYgKHZuLT5oYXNoLmJ1Y2tldHMpIHsKLSAgICAgICAgY3NjZiA9IG5neF9oYXNoX2ZpbmQoJnZuLT5oYXNoLCBuZ3hfaGFzaF9rZXkoaG9zdCwgbGVuKSwgaG9zdCwgbGVuKTsKKyAgICAgICAgY3NjZiA9IG5neF9oYXNoX2ZpbmQoJnZuLT5oYXNoLCBoYXNoLCBob3N0LCBsZW4pOwogICAgICAgICBpZiAoY3NjZikgewogICAgICAgICAgICAgZ290byBmb3VuZDsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvc3JjL2h0dHAvbmd4X2h0dHBfcmVxdWVzdC5oIGIvc3JjL2h0dHAvbmd4X2h0dHBfcmVxdWVzdC5oCmluZGV4IGU0NjdkZGUuLmE4YWE5ODMgMTAwNjQ0Ci0tLSBhL3NyYy9odHRwL25neF9odHRwX3JlcXVlc3QuaAorKysgYi9zcmMvaHR0cC9uZ3hfaHR0cF9yZXF1ZXN0LmgKQEAgLTEwLDYgKzEwLDkgQEAKIAogI2RlZmluZSBOR1hfSFRUUF9NQVhfUkVXUklURV9DWUNMRVMgICAgICAgIDEwCiAKKy8qIG11c3QgYmUgMl5uICovCisjZGVmaW5lIE5HWF9IVFRQX0xDX0hFQURFUl9MRU4gICAgICAgICAgICAgMzIKKwogCiAjZGVmaW5lIE5HWF9IVFRQX0RJU0NBUkRfQlVGRkVSX1NJWkUgICAgICAgNDA5NgogI2RlZmluZSBOR1hfSFRUUF9MSU5HRVJJTkdfQlVGRkVSX1NJWkUgICAgIDQwOTYKQEAgLTQwMCw3ICs0MDMsNiBAQAogCiAgICAgdW5zaWduZWQgICAgICAgICAgICAgICAgICAgICAgICAgIGZhc3Rfc3VicmVxdWVzdDoxOwogCi0gICAgdW5zaWduZWQgICAgICAgICAgICAgICAgICAgICAgICAgIGxvd19jYXNlX2V4dGVuOjE7CiAgICAgdW5zaWduZWQgICAgICAgICAgICAgICAgICAgICAgICAgIGhlYWRlcl90aW1lb3V0X3NldDoxOwogCiAgICAgdW5zaWduZWQgICAgICAgICAgICAgICAgICAgICAgICAgIHByb3h5OjE7CkBAIC00NjMsNyArNDY1LDEwIEBACiAgICAgdV9jaGFyICAgICAgICAgICAgICAgICAgICAgICAgICAgKmhlYWRlcl9uYW1lX2VuZDsKICAgICB1X2NoYXIgICAgICAgICAgICAgICAgICAgICAgICAgICAqaGVhZGVyX3N0YXJ0OwogICAgIHVfY2hhciAgICAgICAgICAgICAgICAgICAgICAgICAgICpoZWFkZXJfZW5kOworCiAgICAgbmd4X3VpbnRfdCAgICAgICAgICAgICAgICAgICAgICAgIGhlYWRlcl9oYXNoOworICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgICAgICBsb3djYXNlX2luZGV4OworICAgIHVfY2hhciAgICAgICAgICAgICAgICAgICAgICAgICAgICBsb3djYXNlX2hlYWRlcltOR1hfSFRUUF9MQ19IRUFERVJfTEVOXTsKIH07CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2h0dHAvbmd4X2h0dHBfdXBzdHJlYW0uYyBiL3NyYy9odHRwL25neF9odHRwX3Vwc3RyZWFtLmMKaW5kZXggNDVlNTg2Zi4uNWVhYWQ3OSAxMDA2NDQKLS0tIGEvc3JjL2h0dHAvbmd4X2h0dHBfdXBzdHJlYW0uYworKysgYi9zcmMvaHR0cC9uZ3hfaHR0cF91cHN0cmVhbS5jCkBAIC00NywxMCArNDcsOSBAQAogICAgIG5neF90YWJsZV9lbHRfdCAqaCwgbmd4X3VpbnRfdCBvZmZzZXQpOwogc3RhdGljIG5neF9pbnRfdCBuZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2xpbWl0X3JhdGUobmd4X2h0dHBfcmVxdWVzdF90ICpyLAogICAgIG5neF90YWJsZV9lbHRfdCAqaCwgbmd4X3VpbnRfdCBvZmZzZXQpOwotc3RhdGljIG5neF9pbnRfdCBuZ3hfaHR0cF91cHN0cmVhbV9jb3B5X2hlYWRlcl9saW5lKG5neF9odHRwX3JlcXVlc3RfdCAqciwKK3N0YXRpYyBuZ3hfaW50X3Qgbmd4X2h0dHBfdXBzdHJlYW1fcHJvY2Vzc19idWZmZXJpbmcobmd4X2h0dHBfcmVxdWVzdF90ICpyLAogICAgIG5neF90YWJsZV9lbHRfdCAqaCwgbmd4X3VpbnRfdCBvZmZzZXQpOwotc3RhdGljIG5neF9pbnRfdAotICAgIG5neF9odHRwX3Vwc3RyZWFtX2NvbmRpdGlvbmFsX2NvcHlfaGVhZGVyX2xpbmUobmd4X2h0dHBfcmVxdWVzdF90ICpyLAorc3RhdGljIG5neF9pbnRfdCBuZ3hfaHR0cF91cHN0cmVhbV9jb3B5X2hlYWRlcl9saW5lKG5neF9odHRwX3JlcXVlc3RfdCAqciwKICAgICBuZ3hfdGFibGVfZWx0X3QgKmgsIG5neF91aW50X3Qgb2Zmc2V0KTsKIHN0YXRpYyBuZ3hfaW50X3QKICAgICBuZ3hfaHR0cF91cHN0cmVhbV9jb3B5X211bHRpX2hlYWRlcl9saW5lcyhuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIsCkBAIC0xMDMsNyArMTAyLDcgQEAKICAgICB7IG5neF9zdHJpbmcoIlN0YXR1cyIpLAogICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2hlYWRlcl9saW5lLAogICAgICAgICAgICAgICAgICBvZmZzZXRvZihuZ3hfaHR0cF91cHN0cmVhbV9oZWFkZXJzX2luX3QsIHN0YXR1cyksCi0gICAgICAgICAgICAgICAgIC8qIFNUVUIgKi8gbmd4X2h0dHBfdXBzdHJlYW1faWdub3JlX2hlYWRlcl9saW5lLCAwLCAwIH0sCisgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX2NvcHlfaGVhZGVyX2xpbmUsIDAsIDAgfSwKIAogICAgIHsgbmd4X3N0cmluZygiQ29udGVudC1UeXBlIiksCiAgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX3Byb2Nlc3NfaGVhZGVyX2xpbmUsCkBAIC0xMTgsMTQgKzExNywxNCBAQAogICAgIHsgbmd4X3N0cmluZygiRGF0ZSIpLAogICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2hlYWRlcl9saW5lLAogICAgICAgICAgICAgICAgICBvZmZzZXRvZihuZ3hfaHR0cF91cHN0cmVhbV9oZWFkZXJzX2luX3QsIGRhdGUpLAotICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9jb25kaXRpb25hbF9jb3B5X2hlYWRlcl9saW5lLAotICAgICAgICAgICAgICAgICBvZmZzZXRvZihuZ3hfaHR0cF91cHN0cmVhbV9jb25mX3QsIHBhc3NfZGF0ZSksIDAgfSwKKyAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1fY29weV9oZWFkZXJfbGluZSwKKyAgICAgICAgICAgICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfaGVhZGVyc19vdXRfdCwgZGF0ZSksIDAgfSwKIAogICAgIHsgbmd4X3N0cmluZygiU2VydmVyIiksCiAgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX3Byb2Nlc3NfaGVhZGVyX2xpbmUsCiAgICAgICAgICAgICAgICAgIG9mZnNldG9mKG5neF9odHRwX3Vwc3RyZWFtX2hlYWRlcnNfaW5fdCwgc2VydmVyKSwKLSAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1fY29uZGl0aW9uYWxfY29weV9oZWFkZXJfbGluZSwKLSAgICAgICAgICAgICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfdXBzdHJlYW1fY29uZl90LCBwYXNzX3NlcnZlciksIDAgfSwKKyAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1fY29weV9oZWFkZXJfbGluZSwKKyAgICAgICAgICAgICAgICAgb2Zmc2V0b2Yobmd4X2h0dHBfaGVhZGVyc19vdXRfdCwgc2VydmVyKSwgMCB9LAogCiAgICAgeyBuZ3hfc3RyaW5nKCJXV1ctQXV0aGVudGljYXRlIiksCiAgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX3Byb2Nlc3NfaGVhZGVyX2xpbmUsCkBAIC0xNzQsMjAgKzE3MywxNCBAQAogICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9pZ25vcmVfaGVhZGVyX2xpbmUsIDAsCiAgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX2lnbm9yZV9oZWFkZXJfbGluZSwgMCwgMCB9LAogCi0gICAgeyBuZ3hfc3RyaW5nKCJYLVBhZCIpLAotICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9pZ25vcmVfaGVhZGVyX2xpbmUsIDAsCi0gICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX2lnbm9yZV9oZWFkZXJfbGluZSwgMCwgMCB9LAotCiAgICAgeyBuZ3hfc3RyaW5nKCJYLVBvd2VyZWQtQnkiKSwKICAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1faWdub3JlX2hlYWRlcl9saW5lLCAwLAotICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9jb25kaXRpb25hbF9jb3B5X2hlYWRlcl9saW5lLAotICAgICAgICAgICAgICAgICBvZmZzZXRvZihuZ3hfaHR0cF91cHN0cmVhbV9jb25mX3QsIHBhc3NfeF9wb3dlcmVkX2J5KSwgMCB9LAorICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9jb3B5X2hlYWRlcl9saW5lLCAwLCAwIH0sCiAKICAgICB7IG5neF9zdHJpbmcoIlgtQWNjZWwtRXhwaXJlcyIpLAogICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2hlYWRlcl9saW5lLAogICAgICAgICAgICAgICAgICBvZmZzZXRvZihuZ3hfaHR0cF91cHN0cmVhbV9oZWFkZXJzX2luX3QsIHhfYWNjZWxfZXhwaXJlcyksCi0gICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX2NvbmRpdGlvbmFsX2NvcHlfaGVhZGVyX2xpbmUsCi0gICAgICAgICAgICAgICAgIG9mZnNldG9mKG5neF9odHRwX3Vwc3RyZWFtX2NvbmZfdCwgcGFzc194X2FjY2VsX2V4cGlyZXMpLCAwIH0sCisgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX2NvcHlfaGVhZGVyX2xpbmUsIDAsIDAgfSwKIAogICAgIHsgbmd4X3N0cmluZygiWC1BY2NlbC1SZWRpcmVjdCIpLAogICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2hlYWRlcl9saW5lLApAQCAtMTk4LDYgKzE5MSwxMCBAQAogICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2xpbWl0X3JhdGUsIDAsCiAgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX2lnbm9yZV9oZWFkZXJfbGluZSwgMCwgMCB9LAogCisgICAgeyBuZ3hfc3RyaW5nKCJYLUFjY2VsLUJ1ZmZlcmluZyIpLAorICAgICAgICAgICAgICAgICBuZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2J1ZmZlcmluZywgMCwKKyAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1faWdub3JlX2hlYWRlcl9saW5lLCAwLCAwIH0sCisKICNpZiAoTkdYX0hUVFBfR1pJUCkKICAgICB7IG5neF9zdHJpbmcoIkNvbnRlbnQtRW5jb2RpbmciKSwKICAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1fcHJvY2Vzc19oZWFkZXJfbGluZSwKQEAgLTg4MSw3ICs4NzgsNyBAQAogICAgIHNzaXplX3QgICAgICAgICAgICAgICAgICAgICAgICAgbjsKICAgICBuZ3hfaW50X3QgICAgICAgICAgICAgICAgICAgICAgIHJjOwogICAgIG5neF9zdHJfdCAgICAgICAgICAgICAgICAgICAgICAqdXJpLCBhcmdzOwotICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgICAgaSwga2V5LCBmbGFnczsKKyAgICBuZ3hfdWludF90ICAgICAgICAgICAgICAgICAgICAgIGksIGZsYWdzOwogICAgIG5neF9saXN0X3BhcnRfdCAgICAgICAgICAgICAgICAqcGFydDsKICAgICBuZ3hfdGFibGVfZWx0X3QgICAgICAgICAgICAgICAgKmg7CiAgICAgbmd4X2Nvbm5lY3Rpb25fdCAgICAgICAgICAgICAgICpjOwpAQCAtMTA4OSw3ICsxMDg2LDYgQEAKICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1fZmluYWxpemVfcmVxdWVzdChyLCB1LCBOR1hfREVDTElORUQpOwogCiAgICAgICAgIHVtY2YgPSBuZ3hfaHR0cF9nZXRfbW9kdWxlX21haW5fY29uZihyLCBuZ3hfaHR0cF91cHN0cmVhbV9tb2R1bGUpOwotICAgICAgICBoaCA9IChuZ3hfaHR0cF91cHN0cmVhbV9oZWFkZXJfdCAqKSB1bWNmLT5oZWFkZXJzX2luX2hhc2guYnVja2V0czsKIAogICAgICAgICBwYXJ0ID0gJnItPnVwc3RyZWFtLT5oZWFkZXJzX2luLmhlYWRlcnMucGFydDsKICAgICAgICAgaCA9IHBhcnQtPmVsdHM7CkBAIC0xMTA2LDE4ICsxMTAyLDE1IEBACiAgICAgICAgICAgICAgICAgaSA9IDA7CiAgICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIGtleSA9IGhbaV0uaGFzaCAlIHVtY2YtPmhlYWRlcnNfaW5faGFzaC5oYXNoX3NpemU7CisgICAgICAgICAgICBoaCA9IG5neF9oYXNoX2ZpbmQoJnVtY2YtPmhlYWRlcnNfaW5faGFzaCwgaFtpXS5oYXNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGhbaV0ubG93Y2FzZV9rZXksIGhbaV0ua2V5Lmxlbik7CiAKLSAgICAgICAgICAgIGlmIChoaFtrZXldLnJlZGlyZWN0Ci0gICAgICAgICAgICAgICAgJiYgaGhba2V5XS5uYW1lLmxlbiA9PSBoW2ldLmtleS5sZW4KLSAgICAgICAgICAgICAgICAmJiBuZ3hfc3RyY2FzZWNtcChoaFtrZXldLm5hbWUuZGF0YSwgaFtpXS5rZXkuZGF0YSkgPT0gMCkKLSAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICBpZiAoaGhba2V5XS5jb3B5X2hhbmRsZXIociwgJmhbaV0sIGhoW2tleV0uY29uZikgIT0gTkdYX09LKSB7CisgICAgICAgICAgICBpZiAoaGggJiYgaGgtPnJlZGlyZWN0KSB7CisgICAgICAgICAgICAgICAgaWYgKGhoLT5jb3B5X2hhbmRsZXIociwgJmhbaV0sIGhoLT5jb25mKSAhPSBOR1hfT0spIHsKICAgICAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1fZmluYWxpemVfcmVxdWVzdChyLCB1LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1IpOwogICAgICAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgICAgICAgfQotCiAgICAgICAgICAgICB9CiAgICAgICAgIH0KIApAQCAtMTE0OSw3ICsxMTQyLDcgQEAKICAgICBpbnQgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRjcF9ub2RlbGF5OwogICAgIHNzaXplX3QgICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZTsKICAgICBuZ3hfaW50X3QgICAgICAgICAgICAgICAgICAgICAgIHJjOwotICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgICAgaSwga2V5OworICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgICAgaTsKICAgICBuZ3hfbGlzdF9wYXJ0X3QgICAgICAgICAgICAgICAgKnBhcnQ7CiAgICAgbmd4X3RhYmxlX2VsdF90ICAgICAgICAgICAgICAgICpoOwogICAgIG5neF9ldmVudF9waXBlX3QgICAgICAgICAgICAgICAqcDsKQEAgLTExNjEsNyArMTE1NCw2IEBACiAgICAgbmd4X2h0dHBfdXBzdHJlYW1fbWFpbl9jb25mX3QgICp1bWNmOwogCiAgICAgdW1jZiA9IG5neF9odHRwX2dldF9tb2R1bGVfbWFpbl9jb25mKHIsIG5neF9odHRwX3Vwc3RyZWFtX21vZHVsZSk7Ci0gICAgaGggPSAobmd4X2h0dHBfdXBzdHJlYW1faGVhZGVyX3QgKikgdW1jZi0+aGVhZGVyc19pbl9oYXNoLmJ1Y2tldHM7CiAKICAgICBwYXJ0ID0gJnItPnVwc3RyZWFtLT5oZWFkZXJzX2luLmhlYWRlcnMucGFydDsKICAgICBoID0gcGFydC0+ZWx0czsKQEAgLTExNzgsMTIgKzExNzAsMTcgQEAKICAgICAgICAgICAgIGkgPSAwOwogICAgICAgICB9CiAKLSAgICAgICAga2V5ID0gaFtpXS5oYXNoICUgdW1jZi0+aGVhZGVyc19pbl9oYXNoLmhhc2hfc2l6ZTsKLQotICAgICAgICBpZiAoaGhba2V5XS5uYW1lLmxlbiA9PSBoW2ldLmtleS5sZW4KLSAgICAgICAgICAgICYmIG5neF9zdHJjYXNlY21wKGhoW2tleV0ubmFtZS5kYXRhLCBoW2ldLmtleS5kYXRhKSA9PSAwKQorICAgICAgICBpZiAobmd4X2hhc2hfZmluZCgmdS0+Y29uZi0+aGlkZV9oZWFkZXJzX2hhc2gsIGhbaV0uaGFzaCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaFtpXS5sb3djYXNlX2tleSwgaFtpXS5rZXkubGVuKSkKICAgICAgICAgewotICAgICAgICAgICAgaWYgKGhoW2tleV0uY29weV9oYW5kbGVyKHIsICZoW2ldLCBoaFtrZXldLmNvbmYpICE9IE5HWF9PSykgeworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKworICAgICAgICBoaCA9IG5neF9oYXNoX2ZpbmQoJnVtY2YtPmhlYWRlcnNfaW5faGFzaCwgaFtpXS5oYXNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgaFtpXS5sb3djYXNlX2tleSwgaFtpXS5rZXkubGVuKTsKKworICAgICAgICBpZiAoaGgpIHsKKyAgICAgICAgICAgIGlmIChoaC0+Y29weV9oYW5kbGVyKHIsICZoW2ldLCBoaC0+Y29uZikgIT0gTkdYX09LKSB7CiAgICAgICAgICAgICAgICAgbmd4X2h0dHBfdXBzdHJlYW1fZmluYWxpemVfcmVxdWVzdChyLCB1LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOR1hfSFRUUF9JTlRFUk5BTF9TRVJWRVJfRVJST1IpOwogICAgICAgICAgICAgICAgIHJldHVybjsKQEAgLTExOTksNiArMTE5NiwxNCBAQAogICAgICAgICB9CiAgICAgfQogCisgICAgaWYgKHItPmhlYWRlcnNfb3V0LnNlcnZlciAmJiByLT5oZWFkZXJzX291dC5zZXJ2ZXItPnZhbHVlLmRhdGEgPT0gTlVMTCkgeworICAgICAgICByLT5oZWFkZXJzX291dC5zZXJ2ZXItPmhhc2ggPSAwOworICAgIH0KKworICAgIGlmIChyLT5oZWFkZXJzX291dC5kYXRlICYmIHItPmhlYWRlcnNfb3V0LmRhdGUtPnZhbHVlLmRhdGEgPT0gTlVMTCkgeworICAgICAgICByLT5oZWFkZXJzX291dC5kYXRlLT5oYXNoID0gMDsKKyAgICB9CisKICAgICByLT5oZWFkZXJzX291dC5zdGF0dXMgPSB1LT5oZWFkZXJzX2luLnN0YXR1c19uOwogICAgIHItPmhlYWRlcnNfb3V0LnN0YXR1c19saW5lID0gdS0+aGVhZGVyc19pbi5zdGF0dXNfbGluZTsKIApAQCAtMTIzNiw3ICsxMjQxLDcgQEAKIAogICAgIGNsY2YgPSBuZ3hfaHR0cF9nZXRfbW9kdWxlX2xvY19jb25mKHIsIG5neF9odHRwX2NvcmVfbW9kdWxlKTsKIAotICAgIGlmICh1LT5waXBlID09IE5VTEwpIHsKKyAgICBpZiAoIXUtPmJ1ZmZlcmluZykgewogCiAgICAgICAgIGlmICh1LT5pbnB1dF9maWx0ZXIgPT0gTlVMTCkgewogICAgICAgICAgICAgdS0+aW5wdXRfZmlsdGVyX2luaXQgPSBuZ3hfaHR0cF91cHN0cmVhbV9ub25fYnVmZmVyZWRfZmlsdGVyX2luaXQ7CkBAIC0yMDU0LDYgKzIwNTksMzcgQEAKIAogCiBzdGF0aWMgbmd4X2ludF90CituZ3hfaHR0cF91cHN0cmVhbV9wcm9jZXNzX2J1ZmZlcmluZyhuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIsIG5neF90YWJsZV9lbHRfdCAqaCwKKyAgICBuZ3hfdWludF90IG9mZnNldCkKK3sKKyAgICB1X2NoYXIgIGMwLCBjMSwgYzI7CisKKyAgICBpZiAoci0+dXBzdHJlYW0tPmNvbmYtPmNoYW5nZV9idWZmZXJpbmcpIHsKKworICAgICAgICBpZiAoaC0+dmFsdWUubGVuID09IDIpIHsKKyAgICAgICAgICAgIGMwID0gbmd4X3RvbG93ZXIoaC0+dmFsdWUuZGF0YVswXSk7CisgICAgICAgICAgICBjMSA9IG5neF90b2xvd2VyKGgtPnZhbHVlLmRhdGFbMV0pOworCisgICAgICAgICAgICBpZiAoYzAgPT0gJ24nICYmIGMxID09ICdvJykgeworICAgICAgICAgICAgICAgIHItPnVwc3RyZWFtLT5idWZmZXJpbmcgPSAwOworICAgICAgICAgICAgfQorCisgICAgICAgIH0gZWxzZSBpZiAoaC0+dmFsdWUubGVuID09IDMpIHsKKyAgICAgICAgICAgIGMwID0gbmd4X3RvbG93ZXIoaC0+dmFsdWUuZGF0YVswXSk7CisgICAgICAgICAgICBjMSA9IG5neF90b2xvd2VyKGgtPnZhbHVlLmRhdGFbMV0pOworICAgICAgICAgICAgYzIgPSBuZ3hfdG9sb3dlcihoLT52YWx1ZS5kYXRhWzJdKTsKKworICAgICAgICAgICAgaWYgKGMwID09ICd5JyAmJiBjMSA9PSAnZScgJiYgYzIgPT0gJ3MnKSB7CisgICAgICAgICAgICAgICAgci0+dXBzdHJlYW0tPmJ1ZmZlcmluZyA9IDE7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gTkdYX09LOworfQorCisKK3N0YXRpYyBuZ3hfaW50X3QKIG5neF9odHRwX3Vwc3RyZWFtX2NvcHlfaGVhZGVyX2xpbmUobmd4X2h0dHBfcmVxdWVzdF90ICpyLCBuZ3hfdGFibGVfZWx0X3QgKmgsCiAgICAgbmd4X3VpbnRfdCBvZmZzZXQpCiB7CkBAIC0yMDc2LDMwICsyMTEyLDYgQEAKIAogCiBzdGF0aWMgbmd4X2ludF90Ci1uZ3hfaHR0cF91cHN0cmVhbV9jb25kaXRpb25hbF9jb3B5X2hlYWRlcl9saW5lKG5neF9odHRwX3JlcXVlc3RfdCAqciwKLSAgICBuZ3hfdGFibGVfZWx0X3QgKmgsIG5neF91aW50X3Qgb2Zmc2V0KQotewotICAgIG5neF9mbGFnX3QgICAgICAgKmY7Ci0gICAgbmd4X3RhYmxlX2VsdF90ICAqaG87Ci0KLSAgICBmID0gKG5neF9mbGFnX3QgKikgKChjaGFyICopIHItPnVwc3RyZWFtLT5jb25mICsgb2Zmc2V0KTsKLQotICAgIGlmICgqZiA9PSAwKSB7Ci0gICAgICAgIHJldHVybiBOR1hfT0s7Ci0gICAgfQotCi0gICAgaG8gPSBuZ3hfbGlzdF9wdXNoKCZyLT5oZWFkZXJzX291dC5oZWFkZXJzKTsKLSAgICBpZiAoaG8gPT0gTlVMTCkgewotICAgICAgICByZXR1cm4gTkdYX0VSUk9SOwotICAgIH0KLQotICAgICpobyA9ICpoOwotCi0gICAgcmV0dXJuIE5HWF9PSzsKLX0KLQotCi1zdGF0aWMgbmd4X2ludF90CiBuZ3hfaHR0cF91cHN0cmVhbV9jb3B5X211bHRpX2hlYWRlcl9saW5lcyhuZ3hfaHR0cF9yZXF1ZXN0X3QgKnIsCiAgICAgbmd4X3RhYmxlX2VsdF90ICpoLCBuZ3hfdWludF90IG9mZnNldCkKIHsKQEAgLTI1NTQsMjIgKzI1NjYsMzkgQEAKIHsKICAgICBuZ3hfaHR0cF91cHN0cmVhbV9tYWluX2NvbmZfdCAgKnVtY2YgPSBjb25mOwogCi0gICAgdW1jZi0+aGVhZGVyc19pbl9oYXNoLm1heF9zaXplID0gMTAwOwotICAgIHVtY2YtPmhlYWRlcnNfaW5faGFzaC5idWNrZXRfbGltaXQgPSAxOwotICAgIHVtY2YtPmhlYWRlcnNfaW5faGFzaC5idWNrZXRfc2l6ZSA9IHNpemVvZihuZ3hfaHR0cF91cHN0cmVhbV9oZWFkZXJfdCk7Ci0gICAgdW1jZi0+aGVhZGVyc19pbl9oYXNoLm5hbWUgPSAidXBzdHJlYW1faGVhZGVyc19pbiI7CisgICAgbmd4X2FycmF5X3QgICAgICAgICAgICAgICAgICBoZWFkZXJzX2luOworICAgIG5neF9oYXNoX2tleV90ICAgICAgICAgICAgICAqaGs7CisgICAgbmd4X2hhc2hfaW5pdF90ICAgICAgICAgICAgICBoYXNoOworICAgIG5neF9odHRwX3Vwc3RyZWFtX2hlYWRlcl90ICAqaGVhZGVyOwogCi0gICAgaWYgKG5neF9oYXNoMF9pbml0KCZ1bWNmLT5oZWFkZXJzX2luX2hhc2gsIGNmLT5wb29sLAotICAgICAgICAgICAgICAgICAgICAgIG5neF9odHRwX3Vwc3RyZWFtX2hlYWRlcnNfaW4sIDApICE9IE5HWF9PSykKKyAgICBpZiAobmd4X2FycmF5X2luaXQoJmhlYWRlcnNfaW4sIGNmLT50ZW1wX3Bvb2wsIDMyLCBzaXplb2Yobmd4X2hhc2hfa2V5X3QpKQorICAgICAgICAhPSBOR1hfT0spCiAgICAgewogICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CiAgICAgfQogCi0gICAgbmd4X2xvZ19kZWJ1ZzIoTkdYX0xPR19ERUJVR19IVFRQLCBjZi0+bG9nLCAwLAotICAgICAgICAgICAgICAgICAgICJodHRwIHVwc3RyZWFtIGhlYWRlcnNfaW4gaGFzaCBzaXplOiAldWksICIKLSAgICAgICAgICAgICAgICAgICAibWF4IGJ1Y2tldHMgcGVyIGVudHJ5OiAldWkiLAotICAgICAgICAgICAgICAgICAgIHVtY2YtPmhlYWRlcnNfaW5faGFzaC5oYXNoX3NpemUsCi0gICAgICAgICAgICAgICAgICAgdW1jZi0+aGVhZGVyc19pbl9oYXNoLm1pbl9idWNrZXRzKTsKKyAgICBmb3IgKGhlYWRlciA9IG5neF9odHRwX3Vwc3RyZWFtX2hlYWRlcnNfaW47IGhlYWRlci0+bmFtZS5sZW47IGhlYWRlcisrKSB7CisgICAgICAgIGhrID0gbmd4X2FycmF5X3B1c2goJmhlYWRlcnNfaW4pOworICAgICAgICBpZiAoaGsgPT0gTlVMTCkgeworICAgICAgICAgICAgcmV0dXJuIE5HWF9DT05GX0VSUk9SOworICAgICAgICB9CisKKyAgICAgICAgaGstPmtleSA9IGhlYWRlci0+bmFtZTsKKyAgICAgICAgaGstPmtleV9oYXNoID0gbmd4X2hhc2hfa2V5X2xjKGhlYWRlci0+bmFtZS5kYXRhLCBoZWFkZXItPm5hbWUubGVuKTsKKyAgICAgICAgaGstPnZhbHVlID0gaGVhZGVyOworICAgIH0KKworICAgIGhhc2guaGFzaCA9ICZ1bWNmLT5oZWFkZXJzX2luX2hhc2g7CisgICAgaGFzaC5rZXkgPSBuZ3hfaGFzaF9rZXlfbGM7CisgICAgaGFzaC5tYXhfc2l6ZSA9IDUxMjsKKyAgICBoYXNoLmJ1Y2tldF9zaXplID0gbmd4X2NhY2hlbGluZV9zaXplOworICAgIGhhc2gubmFtZSA9ICJ1cHN0cmVhbV9oZWFkZXJzX2luX2hhc2giOworICAgIGhhc2gucG9vbCA9IGNmLT5wb29sOworICAgIGhhc2gudGVtcF9wb29sID0gTlVMTDsKKworICAgIGlmIChuZ3hfaGFzaF9pbml0KCZoYXNoLCBoZWFkZXJzX2luLmVsdHMsIGhlYWRlcnNfaW4ubmVsdHMpICE9IE5HWF9PSykgeworICAgICAgICByZXR1cm4gTkdYX0NPTkZfRVJST1I7CisgICAgfQogCiAgICAgcmV0dXJuIE5HWF9DT05GX09LOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2h0dHAvbmd4X2h0dHBfdXBzdHJlYW0uaCBiL3NyYy9odHRwL25neF9odHRwX3Vwc3RyZWFtLmgKaW5kZXggNGQwN2MzZS4uZTYxYzBiYyAxMDA2NDQKLS0tIGEvc3JjL2h0dHAvbmd4X2h0dHBfdXBzdHJlYW0uaAorKysgYi9zcmMvaHR0cC9uZ3hfaHR0cF91cHN0cmVhbS5oCkBAIC00MSw3ICs0MSw3IEBACiAKIAogdHlwZWRlZiBzdHJ1Y3QgewotICAgIG5neF9oYXNoMF90ICAgICAgICAgICAgICAgICAgICAgaGVhZGVyc19pbl9oYXNoOworICAgIG5neF9oYXNoX3QgICAgICAgICAgICAgICAgICAgICAgaGVhZGVyc19pbl9oYXNoOwogfSBuZ3hfaHR0cF91cHN0cmVhbV9tYWluX2NvbmZfdDsKIAogCkBAIC03NywxOSArNzcsMTkgQEAKICAgICBuZ3hfZmxhZ190ICAgICAgICAgICAgICAgICAgICAgIHJlZGlyZWN0X2Vycm9yczsKICAgICBuZ3hfZmxhZ190ICAgICAgICAgICAgICAgICAgICAgIGN5Y2xpY190ZW1wX2ZpbGU7CiAKLSAgICBuZ3hfZmxhZ190ICAgICAgICAgICAgICAgICAgICAgIHBhc3NfeF9wb3dlcmVkX2J5OwotICAgIG5neF9mbGFnX3QgICAgICAgICAgICAgICAgICAgICAgcGFzc19zZXJ2ZXI7Ci0gICAgbmd4X2ZsYWdfdCAgICAgICAgICAgICAgICAgICAgICBwYXNzX2RhdGU7Ci0gICAgbmd4X2ZsYWdfdCAgICAgICAgICAgICAgICAgICAgICBwYXNzX3hfYWNjZWxfZXhwaXJlczsKLQogICAgIG5neF9wYXRoX3QgICAgICAgICAgICAgICAgICAgICAqdGVtcF9wYXRoOwogCisgICAgbmd4X2hhc2hfdCAgICAgICAgICAgICAgICAgICAgICBoaWRlX2hlYWRlcnNfaGFzaDsKKyAgICBuZ3hfYXJyYXlfdCAgICAgICAgICAgICAgICAgICAgKmhpZGVfaGVhZGVyczsKKyAgICBuZ3hfYXJyYXlfdCAgICAgICAgICAgICAgICAgICAgKnBhc3NfaGVhZGVyczsKKwogICAgIG5neF9zdHJfdCAgICAgICAgICAgICAgICAgICAgICAgc2NoZW1hOwogICAgIG5neF9zdHJfdCAgICAgICAgICAgICAgICAgICAgICAgdXJpOwogICAgIG5neF9zdHJfdCAgICAgICAgICAgICAgICAgICAgICAgbG9jYXRpb247CiAgICAgbmd4X3N0cl90ICAgICAgICAgICAgICAgICAgICAgICB1cmw7ICAvKiB1c2VkIGluIHByb3h5X3Jld3JpdGVfbG9jYXRpb24gKi8KIAotICAgIG5neF91aW50X3QgICAgICAgICAgICAgICAgICAgICAgcmVkaXJlY3RfNDA0OyAvKiB1bnNpZ25lZCByZWRpcmVjdF80MDQ6MTsgKi8KKyAgICB1bnNpZ25lZCAgICAgICAgICAgICAgICAgICAgICAgIHJlZGlyZWN0XzQwNDoxOworICAgIHVuc2lnbmVkICAgICAgICAgICAgICAgICAgICAgICAgY2hhbmdlX2J1ZmZlcmluZzoxOwogCiAjaWYgKE5HWF9IVFRQX1NTTCkKICAgICBuZ3hfc3NsX3QgICAgICAgICAgICAgICAgICAgICAgKnNzbDsKQEAgLTE5MSw2ICsxOTEsOCBAQAogICAgIHVuc2lnbmVkICAgICAgICAgICAgICAgICAgICAgICAgY2FjaGFibGU6MTsKICAgICB1bnNpZ25lZCAgICAgICAgICAgICAgICAgICAgICAgIGFjY2VsOjE7CiAKKyAgICB1bnNpZ25lZCAgICAgICAgICAgICAgICAgICAgICAgIGJ1ZmZlcmluZzoxOworCiAgICAgdW5zaWduZWQgICAgICAgICAgICAgICAgICAgICAgICByZXF1ZXN0X3NlbnQ6MTsKICAgICB1bnNpZ25lZCAgICAgICAgICAgICAgICAgICAgICAgIGhlYWRlcl9zZW50OjE7CiB9Owo=