210659 2020-04-17 09:46:44 -0700 [EME][CDMProxy] Sort key status array lexicographically by key IDs 2020-04-23 07:50:54 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 cturner cturner bugs-noreply calvaris darin eric.carlson ews-watchlist glenn jer.noble philipj sergio oldest_to_newest 1642714 0 cturner 2020-04-17 09:46:44 -0700 [EME][CDMProxy] Sort key status array lexicographically by key IDs 1642738 1 396773 cturner 2020-04-17 10:57:34 -0700 Created attachment 396773 Patch 1642748 2 396773 darin 2020-04-17 11:18:56 -0700 Comment on attachment 396773 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=396773&action=review > Source/WebCore/ChangeLog:4 > + [EME][CDMProxy] Sort key status array lexicographically by key IDs > + https://bugs.webkit.org/show_bug.cgi?id=210659 Re-sorting each time we insert something gives us an almost pathologically inefficient data structure. We might get away with it if it is always very small. I think a reasonable data structure here would be a vector that we keep sorted, using binary search for both searching for elements and to find where to insert a new element in the vector. The standard library offers std::binary_search, which I believe can be used for both of these purposes, and Vector offers Vector::insert which can be used to place new elements in the correct place in the vector after using binary_search to find where to insert. > Source/WebCore/ChangeLog:15 > + (WebCore::KeyStore::add): We could use a HashSet here and keep it > + sorted by design, but we also have to keep references to keys from HashSet is not an ordered collection. You may be thinking of non-hashed collections that are ordered, like std::set. > Source/WebCore/ChangeLog:19 > + not clear how HashSet<RefPtr<T>> could be made to compare with > + operator<(T) rather than operator<(RefPtr<T>) (pointer > + comparison). In addition to that, it's often required to search HashSet doesn't use operator< at all. It uses hashing and equality. > Source/WebCore/ChangeLog:23 > + for a key with a Vector<uint8_t> directly. The HashSet API doesn't > + provide a way to search via predicate (like Vector), which means I > + can not feasibly lookup a Vector<uint8_t> if I'm essentially > + storing RefPtr<Vector<uint8_t>> in the set. Instead, a compromise It’s straightforward to search a HashSet via predicate like you would with a Vector. It would be a loop like this: for (auto it = set.begin(), end = set.end(); it != end; ++it) { if (predicate(*it)) return it; } The reason this isn’t offered is that it’s an O(n) operation, and if doing operations like that, then we’d typically use a Vector instead. The set offers O(log n) membership checking, which is usually the reason we use it. 1643258 3 396773 cturner 2020-04-19 15:54:23 -0700 Comment on attachment 396773 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=396773&action=review Thanks for the review, I feel I can keep the naive insert and resort in this context, but I should clarify why in the ChangeLog. >> Source/WebCore/ChangeLog:4 >> + https://bugs.webkit.org/show_bug.cgi?id=210659 > > Re-sorting each time we insert something gives us an almost pathologically inefficient data structure. We might get away with it if it is always very small. > > I think a reasonable data structure here would be a vector that we keep sorted, using binary search for both searching for elements and to find where to insert a new element in the vector. > > The standard library offers std::binary_search, which I believe can be used for both of these purposes, and Vector offers Vector::insert which can be used to place new elements in the correct place in the vector after using binary_search to find where to insert. > We might get away with it if it is always very small. I should have made it clearer that the collection in this context is typically very small. The common case in practice is for this collection to be of size 1 (one encryption key for all tracks). It's also less common for the collection to be size 2 (one key for audio and one for video) but cases where N > 2 are pathological in themselves, and so in practice the pathology wouldn't be seen. For N=1, the sort call is trivial, and for N=2 it's just a swap. I did consider keeping it sorted, but because of this context the extra complexity didn't seem worth it. >> Source/WebCore/ChangeLog:15 >> + sorted by design, but we also have to keep references to keys from > > HashSet is not an ordered collection. You may be thinking of non-hashed collections that are ordered, like std::set. I'll correct that mistake in the ChangeLog, I am thinking of the ordered variety. >> Source/WebCore/ChangeLog:23 >> + storing RefPtr<Vector<uint8_t>> in the set. Instead, a compromise > > It’s straightforward to search a HashSet via predicate like you would with a Vector. It would be a loop like this: > > for (auto it = set.begin(), end = set.end(); it != end; ++it) { > if (predicate(*it)) > return it; > } > > The reason this isn’t offered is that it’s an O(n) operation, and if doing operations like that, then we’d typically use a Vector instead. The set offers O(log n) membership checking, which is usually the reason we use it. Understood, I shouldn't have been so strong here in my explanation, but loops like that are definitely a warning sign I've picked the wrong data structure :) 1643259 4 cturner 2020-04-19 15:54:28 -0700 View in context: https://bugs.webkit.org/attachment.cgi?id=396773&action=review Thanks for the review, I feel I can keep the naive insert and resort in this context, but I should clarify why in the ChangeLog. >> Source/WebCore/ChangeLog:4 >> + https://bugs.webkit.org/show_bug.cgi?id=210659 > > Re-sorting each time we insert something gives us an almost pathologically inefficient data structure. We might get away with it if it is always very small. > > I think a reasonable data structure here would be a vector that we keep sorted, using binary search for both searching for elements and to find where to insert a new element in the vector. > > The standard library offers std::binary_search, which I believe can be used for both of these purposes, and Vector offers Vector::insert which can be used to place new elements in the correct place in the vector after using binary_search to find where to insert. > We might get away with it if it is always very small. I should have made it clearer that the collection in this context is typically very small. The common case in practice is for this collection to be of size 1 (one encryption key for all tracks). It's also less common for the collection to be size 2 (one key for audio and one for video) but cases where N > 2 are pathological in themselves, and so in practice the pathology wouldn't be seen. For N=1, the sort call is trivial, and for N=2 it's just a swap. I did consider keeping it sorted, but because of this context the extra complexity didn't seem worth it. >> Source/WebCore/ChangeLog:15 >> + sorted by design, but we also have to keep references to keys from > > HashSet is not an ordered collection. You may be thinking of non-hashed collections that are ordered, like std::set. I'll correct that mistake in the ChangeLog, I am thinking of the ordered variety. >> Source/WebCore/ChangeLog:23 >> + storing RefPtr<Vector<uint8_t>> in the set. Instead, a compromise > > It’s straightforward to search a HashSet via predicate like you would with a Vector. It would be a loop like this: > > for (auto it = set.begin(), end = set.end(); it != end; ++it) { > if (predicate(*it)) > return it; > } > > The reason this isn’t offered is that it’s an O(n) operation, and if doing operations like that, then we’d typically use a Vector instead. The set offers O(log n) membership checking, which is usually the reason we use it. Understood, I shouldn't have been so strong here in my explanation, but loops like that are definitely a warning sign I've picked the wrong data structure :) 1643878 5 397084 cturner 2020-04-21 08:23:58 -0700 Created attachment 397084 Patch 1644766 6 ews-feeder 2020-04-23 07:50:52 -0700 Committed r260568: <https://trac.webkit.org/changeset/260568> All reviewed patches have been landed. Closing bug and clearing flags on attachment 397084. 396773 2020-04-17 10:57:34 -0700 2020-04-21 08:23:55 -0700 Patch bug-210659-20200417185733.patch text/plain 4319 cturner U3VidmVyc2lvbiBSZXZpc2lvbjogMjYwMTIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTJlMWY5YjMzZWE1MWQ2 NDEyMDkwNmUyNjkzZGVhNDNjNDAzZWNlYi4uZGQ4NGRiMjdiNDBhNzc5NTUxNmY5YjI2NWE2MDM3 Yzc5OGY2Y2Q1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDIwLTA0LTE3ICBDaGFy bGllIFR1cm5lciAgPGN0dXJuZXJAaWdhbGlhLmNvbT4KKworICAgICAgICBbRU1FXVtDRE1Qcm94 eV0gU29ydCBrZXkgc3RhdHVzIGFycmF5IGxleGljb2dyYXBoaWNhbGx5IGJ5IGtleSBJRHMKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMDY1OQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgaXMgcmVx dWlyZWQgYnkgc2VjdGlvbiA2LjEgb2YKKyAgICAgICAgaHR0cHM6Ly93d3cudzMub3JnL1RSL2Vu Y3J5cHRlZC1tZWRpYS8uCisKKyAgICAgICAgVGVzdDogZW5jcnlwdGVkLW1lZGlhL2NsZWFya2V5 LWtleXN0YXR1c2VzLmh0dHBzLmh0bWwKKworICAgICAgICAqIHBsYXRmb3JtL2VuY3J5cHRlZG1l ZGlhL0NETVByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OktleVN0b3JlOjphZGQpOiBXZSBj b3VsZCB1c2UgYSBIYXNoU2V0IGhlcmUgYW5kIGtlZXAgaXQKKyAgICAgICAgc29ydGVkIGJ5IGRl c2lnbiwgYnV0IHdlIGFsc28gaGF2ZSB0byBrZWVwIHJlZmVyZW5jZXMgdG8ga2V5cyBmcm9tCisg ICAgICAgIHRoZSBrZXkgc3RvcmUgbGVzcyB0aGVpciBkYXRhIGJlY29tZSBpbmFkdmVydGVudGx5 IGNvcnJ1cHRlZC4gSXQgd2FzCisgICAgICAgIG5vdCBjbGVhciBob3cgSGFzaFNldDxSZWZQdHI8 VD4+IGNvdWxkIGJlIG1hZGUgdG8gY29tcGFyZSB3aXRoCisgICAgICAgIG9wZXJhdG9yPChUKSBy YXRoZXIgdGhhbiBvcGVyYXRvcjwoUmVmUHRyPFQ+KSAocG9pbnRlcgorICAgICAgICBjb21wYXJp c29uKS4gSW4gYWRkaXRpb24gdG8gdGhhdCwgaXQncyBvZnRlbiByZXF1aXJlZCB0byBzZWFyY2gK KyAgICAgICAgZm9yIGEga2V5IHdpdGggYSBWZWN0b3I8dWludDhfdD4gZGlyZWN0bHkuIFRoZSBI YXNoU2V0IEFQSSBkb2Vzbid0CisgICAgICAgIHByb3ZpZGUgYSB3YXkgdG8gc2VhcmNoIHZpYSBw cmVkaWNhdGUgKGxpa2UgVmVjdG9yKSwgd2hpY2ggbWVhbnMgSQorICAgICAgICBjYW4gbm90IGZl YXNpYmx5IGxvb2t1cCBhIFZlY3Rvcjx1aW50OF90PiBpZiBJJ20gZXNzZW50aWFsbHkKKyAgICAg ICAgc3RvcmluZyBSZWZQdHI8VmVjdG9yPHVpbnQ4X3Q+PiBpbiB0aGUgc2V0LiBJbnN0ZWFkLCBh IGNvbXByb21pc2UKKyAgICAgICAgaXMgdGFrZW4gdG8gc29ydCB0aGUgVmVjdG9yIGVhY2ggdGlt ZSBpdCdzIHVwZGF0ZWQuIEkgYWxzbworICAgICAgICBjb25zaWRlcmVkIG9ubHkgc29ydGluZyBv bi1kZW1hbmQsIHNpbmNlIGl0IG9ubHkgaGFzIHRvIGJlIGFwcGVhcgorICAgICAgICBzb3J0ZWQg ZnJvbSB0aGUgcGVyc3BlY3RpdmUgb2YgSlMsIHdlIGNvdWxkIHNvcnQgdGhlIGFycmF5IGluCisg ICAgICAgIGNvbnZlcnRUb0pTS2V5U3RhdHVzVmVjdG9yLiBIb3dldmVyLCB0aGF0IGlzIHNlbWFu dGljYWxseSBhIGNvbnN0CisgICAgICAgIG1ldGhvZCwgc28gc29ydGluZyBoZXJlIGZlbHQgdG9v IHN1cnByaXNpbmcuCisgICAgICAgICogcGxhdGZvcm0vZW5jcnlwdGVkbWVkaWEvQ0RNUHJveHku aDoKKyAgICAgICAgKFdlYkNvcmU6OktleTo6b3BlcmF0b3I8KTogQWRkIGEgbGV4aWNvZ3JhcGhp YyBjb21wYXJhdG9yIHRvCisgICAgICAgIEtleS4KKwogMjAyMC0wNC0xNCAgU2ltb24gRnJhc2Vy ICA8c2ltb24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAgICAgICBbQXN5bmMgb3ZlcmZsb3cgc2Ny b2xsXSBCYWNrZ3JvdW5kcyBtaXNzaW5nIG9uIGdtYWlsIHNvbWV0aW1lcwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZW5jcnlwdGVkbWVkaWEvQ0RNUHJveHkuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZW5jcnlwdGVkbWVkaWEvQ0RNUHJveHkuY3BwCmluZGV4IDFm NmNiMDVjMThjNzM0NzUzYmRlY2VlOWIxNzA4MTYyYWE1NGVmMDYuLmViN2NjMGQ3YTQxNDNmNDc0 OTU3ZDFiYjg2NWE1MmM4M2IxNmNkYTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2VuY3J5cHRlZG1lZGlhL0NETVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9lbmNyeXB0ZWRtZWRpYS9DRE1Qcm94eS5jcHAKQEAgLTEyMiw2ICsxMjIsMTQgQEAgYm9v bCBLZXlTdG9yZTo6YWRkKFJlZlB0cjxLZXk+JiYga2V5KQogICAgICAgICBkaWRTdG9yZUNoYW5n ZSA9IHRydWU7CiAgICAgfQogCisgICAgaWYgKGRpZFN0b3JlQ2hhbmdlKSB7CisgICAgICAgIC8v IFNvcnQgdGhlIGtleXMgbGV4aWNvZ3JhcGhpY2FsbHkuCisgICAgICAgIHN0ZDo6c29ydChtX2tl eXMuYmVnaW4oKSwgbV9rZXlzLmVuZCgpLAorICAgICAgICAgICAgW10oY29uc3QgUmVmUHRyPEtl eT4mIGEsIGNvbnN0IFJlZlB0cjxLZXk+JiBiKSB7CisgICAgICAgICAgICAgICAgcmV0dXJuICph IDwgKmI7CisgICAgICAgICAgICB9KTsKKyAgICB9CisKICAgICBrZXktPmFkZFNlc3Npb25SZWZl cmVuY2UoKTsKICAgICByZXR1cm4gZGlkU3RvcmVDaGFuZ2U7CiB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9lbmNyeXB0ZWRtZWRpYS9DRE1Qcm94eS5oIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZW5jcnlwdGVkbWVkaWEvQ0RNUHJveHkuaAppbmRleCA3NzVhNTM5MzBj OWQ3M2I2Y2FlNjRlODRkY2ZkNWU5YzNlYTZjMjQxLi5iNDgyMDcyYzM0ZDJhMzNiNTZhN2YwOTUx MDZlMzI5OTFmY2UyYTUyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9lbmNy eXB0ZWRtZWRpYS9DRE1Qcm94eS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2VuY3J5 cHRlZG1lZGlhL0NETVByb3h5LmgKQEAgLTYxLDYgKzYxLDIxIEBAIHB1YmxpYzoKICAgICBmcmll bmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IEtleSAmazEsIGNvbnN0IEtleSAmazIpIHsgcmV0dXJu IGsxLm1faWQgPT0gazIubV9pZDsgfQogICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3Qg S2V5ICZrLCBjb25zdCBWZWN0b3I8dWludDhfdD4mIGtleUlEKSB7IHJldHVybiBrLm1faWQgPT0g a2V5SUQ7IH0KICAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFZlY3Rvcjx1aW50OF90 PiYga2V5SUQsIGNvbnN0IEtleSAmaykgeyByZXR1cm4gayA9PSBrZXlJRDsgfQorICAgIGZyaWVu ZCBib29sIG9wZXJhdG9yPChjb25zdCBLZXkmIGsxLCBjb25zdCBLZXkmIGsyKQorICAgIHsKKyAg ICAgICAgLy8gS2V5IElEcyBhcmUgY29tcGFyZWQgYXMgZm9sbG93czogRm9yIGtleSBJRHMgQSBv ZiBsZW5ndGggbSBhbmQKKyAgICAgICAgLy8gQiBvZiBsZW5ndGggbiwgYXNzaWduZWQgc3VjaCB0 aGF0IG0gPD0gbiwgbGV0IEEgPCBCIGlmIGFuZCBvbmx5CisgICAgICAgIC8vIGlmIHRoZSBtIG9j dGV0cyBvZiBBIGFyZSBsZXNzIGluIGxleGljb2dyYXBoaWNhbCBvcmRlciB0aGFuIHRoZQorICAg ICAgICAvLyBmaXJzdCBtIG9jdGV0cyBvZiBCIG9yIHRob3NlIG9jdGV0cyBhcmUgZXF1YWwgYW5k IG0gPCBuLgorICAgICAgICAvLyA2LjEgaHR0cHM6Ly93d3cudzMub3JnL1RSL2VuY3J5cHRlZC1t ZWRpYS8KKyAgICAgICAgaW50IGlzRGlmZmVyZW5jZSA9IG1lbWNtcChrMS5tX2lkLmRhdGEoKSwg azIubV9pZC5kYXRhKCksIHN0ZDo6bWluKGsxLm1faWQuc2l6ZSgpLCBrMi5tX2lkLnNpemUoKSkp OworICAgICAgICBpZiAoaXNEaWZmZXJlbmNlKQorICAgICAgICAgICAgcmV0dXJuIGlzRGlmZmVy ZW5jZSA8IDA7CisgICAgICAgIC8vIFRoZSBrZXlzIGFyZSBlcXVhbCB0byB0aGUgc2hhcmVkIGxl bmd0aCwgdGhlIHNob3J0ZXIgc3RyaW5nCisgICAgICAgIC8vIGlzIHRoZXJlZm9yZSBsZXNzIHRo YW4gdGhlIGxvbmdlciBvbmUgaW4gYSBsZXhpY29ncmFwaGljYWwKKyAgICAgICAgLy8gb3JkZXJp bmcuCisgICAgICAgIHJldHVybiBrMS5tX2lkLnNpemUoKSA8IGsyLm1faWQuc2l6ZSgpOworICAg IH0KIAogcHJpdmF0ZToKICAgICB2b2lkIGFkZFNlc3Npb25SZWZlcmVuY2UoKSB7IEFTU0VSVChp c01haW5UaHJlYWQoKSk7IG1fbnVtU2Vzc2lvblJlZmVyZW5jZXMrKzsgfQo= 397084 2020-04-21 08:23:58 -0700 2020-04-23 07:50:53 -0700 Patch bug-210659-20200421162357.patch text/plain 4028 cturner U3VidmVyc2lvbiBSZXZpc2lvbjogMjYwMTIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTJlMWY5YjMzZWE1MWQ2 NDEyMDkwNmUyNjkzZGVhNDNjNDAzZWNlYi4uZDQ3ZDlmNmUxNTQzMDExZTFlYjkwNTFiYWY0NjUw YWRhY2Q0YTVlYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDIwLTA0LTE3ICBDaGFy bGllIFR1cm5lciAgPGN0dXJuZXJAaWdhbGlhLmNvbT4KKworICAgICAgICBbRU1FXVtDRE1Qcm94 eV0gU29ydCBrZXkgc3RhdHVzIGFycmF5IGxleGljb2dyYXBoaWNhbGx5IGJ5IGtleSBJRHMKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMDY1OQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgaXMgcmVx dWlyZWQgYnkgc2VjdGlvbiA2LjEgb2YKKyAgICAgICAgaHR0cHM6Ly93d3cudzMub3JnL1RSL2Vu Y3J5cHRlZC1tZWRpYS8uCisKKyAgICAgICAgVGVzdDogZW5jcnlwdGVkLW1lZGlhL2NsZWFya2V5 LWtleXN0YXR1c2VzLmh0dHBzLmh0bWwKKworICAgICAgICAqIHBsYXRmb3JtL2VuY3J5cHRlZG1l ZGlhL0NETVByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OktleVN0b3JlOjphZGQpOiBXZSBj b3VsZCB1c2UgYSBzZXQgaGVyZSBhbmQga2VlcCBpdAorICAgICAgICBzb3J0ZWQgYnkgZGVzaWdu LCBidXQgdGhpcyBpcyBtb3JlIGNvbXBsZXhpdHkgdGhhbiBuZWVkZWQuIFRoZQorICAgICAgICBz dG9yZSBoYXMgZm9yIHByYWN0aWNhbCBwdXJwb3NlcyBhbiB1cHBlciBsaW1pdCBvZiAyCisgICAg ICAgIGl0ZW1zLiBTb3J0aW5nIHN1Y2ggYSB2ZWN0b3IgbG93ZXJzIHRvIGVpdGhlciBhIG5vb3Ag b3IgYSBzd2FwLiBTbworICAgICAgICB0aGUgc2ltcGxlIGFwcHJvYWNoIGhlcmUgd2lucyBvdmVy IHVzaW5nIHNvbWUga2luZCBvZiBzZWxmLXNvcnRpbmcKKyAgICAgICAgc2V0IHN0cnVjdHVyZS4g SSBhbHNvIGNvbnNpZGVyZWQgb25seSBzb3J0aW5nIG9uLWRlbWFuZCwgc2luY2UgaXQKKyAgICAg ICAgb25seSBoYXMgdG8gYXBwZWFyIHNvcnRlZCBmcm9tIHRoZSBwZXJzcGVjdGl2ZSBvZiBKUywg d2UgY291bGQKKyAgICAgICAgc29ydCB0aGUgYXJyYXkgaW4gY29udmVydFRvSlNLZXlTdGF0dXNW ZWN0b3IuIEhvd2V2ZXIsIHRoYXQgaXMKKyAgICAgICAgc2VtYW50aWNhbGx5IGEgY29uc3QgbWV0 aG9kLCBzbyBzb3J0aW5nIGhlcmUgZmVsdCB0b28gc3VycHJpc2luZy4KKyAgICAgICAgKiBwbGF0 Zm9ybS9lbmNyeXB0ZWRtZWRpYS9DRE1Qcm94eS5oOgorICAgICAgICAoV2ViQ29yZTo6S2V5Ojpv cGVyYXRvcjwpOiBBZGQgYSBsZXhpY29ncmFwaGljIGNvbXBhcmF0b3IgdG8KKyAgICAgICAgS2V5 LgorCiAyMDIwLTA0LTE0ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgog CiAgICAgICAgIFtBc3luYyBvdmVyZmxvdyBzY3JvbGxdIEJhY2tncm91bmRzIG1pc3Npbmcgb24g Z21haWwgc29tZXRpbWVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9lbmNy eXB0ZWRtZWRpYS9DRE1Qcm94eS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9lbmNyeXB0 ZWRtZWRpYS9DRE1Qcm94eS5jcHAKaW5kZXggMWY2Y2IwNWMxOGM3MzQ3NTNiZGVjZWU5YjE3MDgx NjJhYTU0ZWYwNi4uMzZjN2NlZjRhYzZhZDJkY2VhZTZiYTk4MDQ2NGIzYjdjZDQ4ZTM4MSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZW5jcnlwdGVkbWVkaWEvQ0RNUHJveHku Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2VuY3J5cHRlZG1lZGlhL0NETVByb3h5 LmNwcApAQCAtMTIyLDYgKzEyMiwxNiBAQCBib29sIEtleVN0b3JlOjphZGQoUmVmUHRyPEtleT4m JiBrZXkpCiAgICAgICAgIGRpZFN0b3JlQ2hhbmdlID0gdHJ1ZTsKICAgICB9CiAKKyAgICBpZiAo ZGlkU3RvcmVDaGFuZ2UpIHsKKyAgICAgICAgLy8gU29ydCB0aGUga2V5cyBsZXhpY29ncmFwaGlj YWxseS4KKyAgICAgICAgLy8gTk9URTogVGhpcyBpcyBub3QgYXMgcGF0aG9sb2dpY2FsIGFzIGl0 IG1heSBzZWVtLCBmb3IgYWxsCisgICAgICAgIC8vIHByYWN0aWNhbCBwdXJwb3NlcyB0aGUgc3Rv cmUgaGFzIGEgbWF4aW11bSBvZiAyIGtleXMuCisgICAgICAgIHN0ZDo6c29ydChtX2tleXMuYmVn aW4oKSwgbV9rZXlzLmVuZCgpLAorICAgICAgICAgICAgW10oY29uc3QgUmVmUHRyPEtleT4mIGEs IGNvbnN0IFJlZlB0cjxLZXk+JiBiKSB7CisgICAgICAgICAgICAgICAgcmV0dXJuICphIDwgKmI7 CisgICAgICAgICAgICB9KTsKKyAgICB9CisKICAgICBrZXktPmFkZFNlc3Npb25SZWZlcmVuY2Uo KTsKICAgICByZXR1cm4gZGlkU3RvcmVDaGFuZ2U7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9lbmNyeXB0ZWRtZWRpYS9DRE1Qcm94eS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZW5jcnlwdGVkbWVkaWEvQ0RNUHJveHkuaAppbmRleCA3NzVhNTM5MzBjOWQ3M2I2 Y2FlNjRlODRkY2ZkNWU5YzNlYTZjMjQxLi5iNDgyMDcyYzM0ZDJhMzNiNTZhN2YwOTUxMDZlMzI5 OTFmY2UyYTUyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9lbmNyeXB0ZWRt ZWRpYS9DRE1Qcm94eS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2VuY3J5cHRlZG1l ZGlhL0NETVByb3h5LmgKQEAgLTYxLDYgKzYxLDIxIEBAIHB1YmxpYzoKICAgICBmcmllbmQgYm9v bCBvcGVyYXRvcj09KGNvbnN0IEtleSAmazEsIGNvbnN0IEtleSAmazIpIHsgcmV0dXJuIGsxLm1f aWQgPT0gazIubV9pZDsgfQogICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgS2V5ICZr LCBjb25zdCBWZWN0b3I8dWludDhfdD4mIGtleUlEKSB7IHJldHVybiBrLm1faWQgPT0ga2V5SUQ7 IH0KICAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFZlY3Rvcjx1aW50OF90PiYga2V5 SUQsIGNvbnN0IEtleSAmaykgeyByZXR1cm4gayA9PSBrZXlJRDsgfQorICAgIGZyaWVuZCBib29s IG9wZXJhdG9yPChjb25zdCBLZXkmIGsxLCBjb25zdCBLZXkmIGsyKQorICAgIHsKKyAgICAgICAg Ly8gS2V5IElEcyBhcmUgY29tcGFyZWQgYXMgZm9sbG93czogRm9yIGtleSBJRHMgQSBvZiBsZW5n dGggbSBhbmQKKyAgICAgICAgLy8gQiBvZiBsZW5ndGggbiwgYXNzaWduZWQgc3VjaCB0aGF0IG0g PD0gbiwgbGV0IEEgPCBCIGlmIGFuZCBvbmx5CisgICAgICAgIC8vIGlmIHRoZSBtIG9jdGV0cyBv ZiBBIGFyZSBsZXNzIGluIGxleGljb2dyYXBoaWNhbCBvcmRlciB0aGFuIHRoZQorICAgICAgICAv LyBmaXJzdCBtIG9jdGV0cyBvZiBCIG9yIHRob3NlIG9jdGV0cyBhcmUgZXF1YWwgYW5kIG0gPCBu LgorICAgICAgICAvLyA2LjEgaHR0cHM6Ly93d3cudzMub3JnL1RSL2VuY3J5cHRlZC1tZWRpYS8K KyAgICAgICAgaW50IGlzRGlmZmVyZW5jZSA9IG1lbWNtcChrMS5tX2lkLmRhdGEoKSwgazIubV9p ZC5kYXRhKCksIHN0ZDo6bWluKGsxLm1faWQuc2l6ZSgpLCBrMi5tX2lkLnNpemUoKSkpOworICAg ICAgICBpZiAoaXNEaWZmZXJlbmNlKQorICAgICAgICAgICAgcmV0dXJuIGlzRGlmZmVyZW5jZSA8 IDA7CisgICAgICAgIC8vIFRoZSBrZXlzIGFyZSBlcXVhbCB0byB0aGUgc2hhcmVkIGxlbmd0aCwg dGhlIHNob3J0ZXIgc3RyaW5nCisgICAgICAgIC8vIGlzIHRoZXJlZm9yZSBsZXNzIHRoYW4gdGhl IGxvbmdlciBvbmUgaW4gYSBsZXhpY29ncmFwaGljYWwKKyAgICAgICAgLy8gb3JkZXJpbmcuCisg ICAgICAgIHJldHVybiBrMS5tX2lkLnNpemUoKSA8IGsyLm1faWQuc2l6ZSgpOworICAgIH0KIAog cHJpdmF0ZToKICAgICB2b2lkIGFkZFNlc3Npb25SZWZlcmVuY2UoKSB7IEFTU0VSVChpc01haW5U aHJlYWQoKSk7IG1fbnVtU2Vzc2lvblJlZmVyZW5jZXMrKzsgfQo=