121123 2013-09-10 14:17:37 -0700 Web Inspector: Do not try to parse incomplete HTTP requests 2013-09-16 08:48:57 -0700 1 1 1 Unclassified WebKit Web Inspector 528+ (Nightly build) All All RESOLVED FIXED InRadar P2 Normal --- 121121 0 andrunko webkit-unassigned cgarcia commit-queue danilo.eu graouts gustavo joepeck mrobinson timothy webkit-bug-importer oldest_to_newest 927491 0 andrunko 2013-09-10 14:17:37 -0700 When working on a patch for bug #121121 I found an issue with the InspectorServer where it would try to parse an HTTP message before receiving the full message and thus fail connecting with the chromedevtools plugin. What happens is that the WebSocketServerConnection receives buffers on WebSocketServerConnection::didReceiveSocketStreamData and calls WebSocketServerConnection::readHTTPMessage which then checks if we have a valid request by calling HTTPRequest::parseHTTPRequestFromBuffer. If the request is valid it tries to parse the message and clears the buffer, otherwise it continues adding data to the internal buffer until we have a valid request. The problem is that currently HTTPRequest::parseHTTPRequestFromBuffer considers the request as valid before receiving the full message. To solve this we should make the method check if the request headers end with a blank line otherwise we consider the request as invalid (see also http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html). Patch to follow. 927492 1 webkit-bug-importer 2013-09-10 14:17:55 -0700 <rdar://problem/14958134> 927499 2 211243 andrunko 2013-09-10 14:25:18 -0700 Created attachment 211243 Patch 928411 3 211453 andrunko 2013-09-12 11:50:57 -0700 Created attachment 211453 Patch with GTK tests This patch is the same as attachment #211243 but it also includes a patch for the GTK TestInspectorServer. I did not write a generic test as I am not sure how (or if even possible) to do a similar test using JS+HTML. If there is another option please let me know and I can update the test to not be gtk specific. Feel free to apply the other patch without the test if you prefer. 928413 4 commit-queue 2013-09-12 11:53:20 -0700 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 928448 5 211453 commit-queue 2013-09-12 12:59:20 -0700 Comment on attachment 211453 Patch with GTK tests Clearing flags on attachment: 211453 Committed r155642: <http://trac.webkit.org/changeset/155642> 928688 6 211453 cgarcia 2013-09-13 00:59:23 -0700 Comment on attachment 211453 Patch with GTK tests View in context: https://bugs.webkit.org/attachment.cgi?id=211453&action=review I'm late again, sorry, I have some comments, though, please consider fixing them in a follow up commit. > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:248 > + GSocketClient* client = g_socket_client_new(); You are leaking this, please use GRefPtr > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:249 > + GSocketConnection* connection = g_socket_client_connect_to_host(client, "127.0.0.1", 2999, NULL, &error.outPtr()); Use 0 instead of NULL for the cancellable. You are leaking the connection too, please use GRefPtr. > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:250 > + g_assert(!error.get()); Use g_assert_no_error instead, that way if there's an error you will see a message with the error description. > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:258 > + g_output_stream_write(ostream, incompleteRequest, strlen(incompleteRequest), NULL, &error.outPtr()); Use 0 instead of NULL. > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:259 > + g_assert(!error.get()); Use g_assert_no_error instead, that way if there's an error you will see a message with the error description. > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:264 > + g_input_stream_read_async(istream, response, sizeof(response) - 1, G_PRIORITY_DEFAULT, NULL, NULL, NULL); Use 0 instead of NULL. > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:268 > + // Give a chance for the server to reply. > + test->wait(2); > + // If we got any answer it means the server replied to an incomplete request, lets fail. > + g_assert(String(response).isEmpty()); I don't think this is the proper way to test this. You should use a GAsyncReadyCallback and spin a run loop to get the bytes read with g_input_stream_read_finish(). You can also start a timeout idle to assert when reached. With this code we are always waiting for 2 seconds, making running the tests slower even with it runs correctly. Also you don't need to initialize the buffer, and then convert it to a String to check if it's empty, just check the bytes actually read. 928856 7 211555 andrunko 2013-09-13 08:23:55 -0700 Created attachment 211555 Patch addressing Carlos review (In reply to comment #6) > (From update of attachment 211453 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=211453&action=review > > I'm late again, sorry, I have some comments, though, please consider fixing them in a follow up commit. > np, attach patch should address the issues, see comments below. > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:248 > > + GSocketClient* client = g_socket_client_new(); > > You are leaking this, please use GRefPtr > Done > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:249 > > + GSocketConnection* connection = g_socket_client_connect_to_host(client, "127.0.0.1", 2999, NULL, &error.outPtr()); > > Use 0 instead of NULL for the cancellable. You are leaking the connection too, please use GRefPtr. > Done > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:250 > > + g_assert(!error.get()); > > Use g_assert_no_error instead, that way if there's an error you will see a message with the error description. > Done > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:258 > > + g_output_stream_write(ostream, incompleteRequest, strlen(incompleteRequest), NULL, &error.outPtr()); > > Use 0 instead of NULL. > Done > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:259 > > + g_assert(!error.get()); > > Use g_assert_no_error instead, that way if there's an error you will see a message with the error description. > Done > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:264 > > + g_input_stream_read_async(istream, response, sizeof(response) - 1, G_PRIORITY_DEFAULT, NULL, NULL, NULL); > > Use 0 instead of NULL. > Done > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:268 > > + // Give a chance for the server to reply. > > + test->wait(2); > > + // If we got any answer it means the server replied to an incomplete request, lets fail. > > + g_assert(String(response).isEmpty()); > > I don't think this is the proper way to test this. You should use a GAsyncReadyCallback and spin a run loop to get the bytes read with g_input_stream_read_finish(). You can also start a timeout idle to assert when reached. With this code we are always waiting for 2 seconds, making running the tests slower even with it runs correctly. Also you don't need to initialize the buffer, and then convert it to a String to check if it's empty, just check the bytes actually read. Quoting from IRC: <andrunko> KaL, hi there, so for bug 121123, I will do the changes you suggested but I am not sure about the last suggestion (do not wait 2 seconds) <andrunko> the thing is that with the patch (where the test pass) we should wait for a timeout as expected result <andrunko> that is why we wait 2 seconds to give a chance to the inspector server to reply, if it does /not/ reply we have a successful test <andrunko> if it does reply the test should fail <KaL> ah, I see, it's the opposite to what I thought I changed the timeout to 1 second though. The test still fails without the fix and works with the fix accordingly. Thanks both for the reviews. 929175 8 211555 cgarcia 2013-09-14 00:33:22 -0700 Comment on attachment 211555 Patch addressing Carlos review View in context: https://bugs.webkit.org/attachment.cgi?id=211555&action=review > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:249 > + GRefPtr<GSocketClient> client = g_socket_client_new(); > + GRefPtr<GSocketConnection> connection = g_socket_client_connect_to_host(client.get(), "127.0.0.1", 2999, 0, &error.outPtr()); This is still wrong, you have to adopt the reference with adoptGRef(). > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:264 > + g_input_stream_read_async(istream, response, sizeof(response) - 1, G_PRIORITY_DEFAULT, 0, 0, 0); Since the operation might never finish, I think it would be better to pass a cancellable, and cancel the operation before the test finish so that the thread used to implement the async operation exits. > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:268 > g_assert(String(response).isEmpty()); You don't need to convert the buffer to a String just to check if it's empty, you can simply check response[0] == '\0' 929689 9 211778 andrunko 2013-09-16 07:06:52 -0700 Created attachment 211778 Patch addressing Carlos review (new round) (In reply to comment #8) > (From update of attachment 211555 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=211555&action=review > > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:249 > > + GRefPtr<GSocketClient> client = g_socket_client_new(); > > + GRefPtr<GSocketConnection> connection = g_socket_client_connect_to_host(client.get(), "127.0.0.1", 2999, 0, &error.outPtr()); > > This is still wrong, you have to adopt the reference with adoptGRef(). > Done. > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:264 > > + g_input_stream_read_async(istream, response, sizeof(response) - 1, G_PRIORITY_DEFAULT, 0, 0, 0); > > Since the operation might never finish, I think it would be better to pass a cancellable, and cancel the operation before the test finish so that the thread used to implement the async operation exits. > Done > > Source/WebKit2/UIProcess/API/gtk/tests/TestInspectorServer.cpp:268 > > g_assert(String(response).isEmpty()); > > You don't need to convert the buffer to a String just to check if it's empty, you can simply check response[0] == '\0' Of course, don't ask me why I did that :D. Done 929693 10 andrunko 2013-09-16 07:09:13 -0700 Btw, TestInspectorServer is hanging on master after 86b826a. The test gets stuck on "/webkit2/WebKitWebInspectorServer/test-open-debugging-session:". I had to comment this failing testcase to test the updated patch on attachment #211778. 929700 11 gustavo 2013-09-16 07:44:58 -0700 The timeout is my bad, see https://bugs.webkit.org/show_bug.cgi?id=121383 929709 12 211778 cgarcia 2013-09-16 08:25:24 -0700 Comment on attachment 211778 Patch addressing Carlos review (new round) Thanks! 929727 13 211778 commit-queue 2013-09-16 08:48:54 -0700 Comment on attachment 211778 Patch addressing Carlos review (new round) Clearing flags on attachment: 211778 Committed r155861: <http://trac.webkit.org/changeset/155861> 929728 14 commit-queue 2013-09-16 08:48:57 -0700 All reviewed patches have been landed. Closing bug. 211243 2013-09-10 14:25:18 -0700 2013-09-13 12:30:53 -0700 Patch 0001-Web-Inspector-Do-not-try-to-parse-incomplete-HTTP-re.patch text/plain 4378 andrunko RnJvbSA5NzgwNDdmN2IwYjNmMmMwOTZlOTg0NTNjODI3Njg3YzQ3ZTRmODlkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiQW5kcmUgTW9yZWlyYSBNYWdhbGhhZXMgKGFuZHJ1bmtvKSIg PGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+CkRhdGU6IFR1ZSwgMTAgU2VwIDIwMTMg MTg6MTg6NTUgLTAzMDAKU3ViamVjdDogW1BBVENIXSBXZWIgSW5zcGVjdG9yOiBEbyBub3QgdHJ5 IHRvIHBhcnNlIGluY29tcGxldGUgSFRUUCByZXF1ZXN0cwogaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTEyMTEyMwoKUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpX aGVuIHdvcmtpbmcgb24gYSBwYXRjaCBmb3IgYnVnICMxMjExMjEgSSBmb3VuZCBhbiBpc3N1ZSB3 aXRoIHRoZSBJbnNwZWN0b3JTZXJ2ZXIgd2hlcmUgaXQgd291bGQgdHJ5CnRvIHBhcnNlIGFuIEhU VFAgbWVzc2FnZSBiZWZvcmUgcmVjZWl2aW5nIHRoZSBmdWxsIG1lc3NhZ2UgYW5kIHRodXMgZmFp bCBjb25uZWN0aW5nIHdpdGggdGhlCmNocm9tZWRldnRvb2xzIHBsdWdpbi4KCldoYXQgaGFwcGVu cyBpcyB0aGF0IHRoZSBXZWJTb2NrZXRTZXJ2ZXJDb25uZWN0aW9uIHJlY2VpdmVzIGJ1ZmZlcnMg b24KV2ViU29ja2V0U2VydmVyQ29ubmVjdGlvbjo6ZGlkUmVjZWl2ZVNvY2tldFN0cmVhbURhdGEg YW5kIGNhbGxzCldlYlNvY2tldFNlcnZlckNvbm5lY3Rpb246OnJlYWRIVFRQTWVzc2FnZSB3aGlj aCB0aGVuIGNoZWNrcyBpZiB3ZSBoYXZlIGEgdmFsaWQgcmVxdWVzdCBieSBjYWxsaW5nCkhUVFBS ZXF1ZXN0OjpwYXJzZUhUVFBSZXF1ZXN0RnJvbUJ1ZmZlci4gSWYgdGhlIHJlcXVlc3QgaXMgdmFs aWQgaXQgdHJpZXMgdG8gcGFyc2UgdGhlIG1lc3NhZ2UgYW5kCmNsZWFycyB0aGUgYnVmZmVyLCBv dGhlcndpc2UgaXQgY29udGludWVzIGFkZGluZyBkYXRhIHRvIHRoZSBpbnRlcm5hbCBidWZmZXIg dW50aWwgd2UgaGF2ZSBhIHZhbGlkCnJlcXVlc3QuCgpUaGUgcHJvYmxlbSBpcyB0aGF0IGN1cnJl bnRseSBIVFRQUmVxdWVzdDo6cGFyc2VIVFRQUmVxdWVzdEZyb21CdWZmZXIgY29uc2lkZXJzIHRo ZSByZXF1ZXN0IGFzIHZhbGlkCmJlZm9yZSByZWNlaXZpbmcgdGhlIGZ1bGwgbWVzc2FnZS4gVG8g c29sdmUgdGhpcyB3ZSBzaG91bGQgbWFrZSB0aGUgbWV0aG9kIGNoZWNrIGlmIHRoZSByZXF1ZXN0 CmhlYWRlcnMgZW5kIHdpdGggYSBibGFuayBsaW5lIG90aGVyd2lzZSB3ZSBjb25zaWRlciB0aGUg cmVxdWVzdCBhcyBpbnZhbGlkIChzZWUgYWxzbwpodHRwOi8vd3d3LnczLm9yZy9Qcm90b2NvbHMv cmZjMjYxNi9yZmMyNjE2LXNlYzQuaHRtbCkuCgoqIFVJUHJvY2Vzcy9JbnNwZWN0b3JTZXJ2ZXIv SFRUUFJlcXVlc3QuY3BwOgooV2ViS2l0OjpIVFRQUmVxdWVzdDo6cGFyc2VIZWFkZXJzKToKRG8g bm90IGNvbnNpZGVyIHJlcXVlc3QgdmFsaWQgaWYgaGVhZGVycyBkaWRuJ3QgZW5kIHdpdGggYSBi bGFuayBsaW5lLgotLS0KIFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgMjcgKysrKysrKysrKysrKysrKysrKysrKwogLi4uL1VJUHJvY2Vzcy9JbnNw ZWN0b3JTZXJ2ZXIvSFRUUFJlcXVlc3QuY3BwICAgICAgfCAgNyArKysrKysKIDIgZmlsZXMgY2hh bmdlZCwgMzQgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5n ZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCAxY2YyNjgyLi41MmRjYTRmIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTMtMDktMTAgIEFuZHJlIE1vcmVpcmEgTWFn YWxoYWVzICAgPGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAgV2Vi IEluc3BlY3RvcjogRG8gbm90IHRyeSB0byBwYXJzZSBpbmNvbXBsZXRlIEhUVFAgcmVxdWVzdHMK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyMTEyMwor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdoZW4gd29y a2luZyBvbiBhIHBhdGNoIGZvciBidWcgIzEyMTEyMSBJIGZvdW5kIGFuIGlzc3VlIHdpdGggdGhl IEluc3BlY3RvclNlcnZlciB3aGVyZSBpdAorICAgICAgICB3b3VsZCB0cnkgdG8gcGFyc2UgYW4g SFRUUCBtZXNzYWdlIGJlZm9yZSByZWNlaXZpbmcgdGhlIGZ1bGwgbWVzc2FnZSBhbmQgdGh1cyBm YWlsCisgICAgICAgIGNvbm5lY3Rpbmcgd2l0aCB0aGUgY2hyb21lZGV2dG9vbHMgcGx1Z2luLgor CisgICAgICAgIFdoYXQgaGFwcGVucyBpcyB0aGF0IHRoZSBXZWJTb2NrZXRTZXJ2ZXJDb25uZWN0 aW9uIHJlY2VpdmVzIGJ1ZmZlcnMgb24KKyAgICAgICAgV2ViU29ja2V0U2VydmVyQ29ubmVjdGlv bjo6ZGlkUmVjZWl2ZVNvY2tldFN0cmVhbURhdGEgYW5kIGNhbGxzCisgICAgICAgIFdlYlNvY2tl dFNlcnZlckNvbm5lY3Rpb246OnJlYWRIVFRQTWVzc2FnZSB3aGljaCB0aGVuIGNoZWNrcyBpZiB3 ZSBoYXZlIGEgdmFsaWQgcmVxdWVzdCBieQorICAgICAgICBjYWxsaW5nIEhUVFBSZXF1ZXN0Ojpw YXJzZUhUVFBSZXF1ZXN0RnJvbUJ1ZmZlci4gSWYgdGhlIHJlcXVlc3QgaXMgdmFsaWQgaXQgdHJp ZXMgdG8gcGFyc2UKKyAgICAgICAgdGhlIG1lc3NhZ2UgYW5kIGNsZWFycyB0aGUgYnVmZmVyLCBv dGhlcndpc2UgaXQgY29udGludWVzIGFkZGluZyBkYXRhIHRvIHRoZSBpbnRlcm5hbCBidWZmZXIK KyAgICAgICAgdW50aWwgd2UgaGF2ZSBhIHZhbGlkIHJlcXVlc3QuCisKKyAgICAgICAgVGhlIHBy b2JsZW0gaXMgdGhhdCBjdXJyZW50bHkgSFRUUFJlcXVlc3Q6OnBhcnNlSFRUUFJlcXVlc3RGcm9t QnVmZmVyIGNvbnNpZGVycyB0aGUgcmVxdWVzdAorICAgICAgICBhcyB2YWxpZCBiZWZvcmUgcmVj ZWl2aW5nIHRoZSBmdWxsIG1lc3NhZ2UuIFRvIHNvbHZlIHRoaXMgd2Ugc2hvdWxkIG1ha2UgdGhl IG1ldGhvZCBjaGVjayBpZgorICAgICAgICB0aGUgcmVxdWVzdCBoZWFkZXJzIGVuZCB3aXRoIGEg YmxhbmsgbGluZSBvdGhlcndpc2Ugd2UgY29uc2lkZXIgdGhlIHJlcXVlc3QgYXMgaW52YWxpZCAo c2VlCisgICAgICAgIGFsc28gaHR0cDovL3d3dy53My5vcmcvUHJvdG9jb2xzL3JmYzI2MTYvcmZj MjYxNi1zZWM0Lmh0bWwpLgorCisgICAgICAgICogVUlQcm9jZXNzL0luc3BlY3RvclNlcnZlci9I VFRQUmVxdWVzdC5jcHA6CisgICAgICAgIChXZWJLaXQ6OkhUVFBSZXF1ZXN0OjpwYXJzZUhlYWRl cnMpOgorICAgICAgICBEbyBub3QgY29uc2lkZXIgcmVxdWVzdCB2YWxpZCBpZiBoZWFkZXJzIGRp ZG4ndCBlbmQgd2l0aCBhIGJsYW5rIGxpbmUuCisKIDIwMTMtMDktMDUgIEFuZGVycyBDYXJsc3Nv biAgPGFuZGVyc2NhQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXBsYWNlIHVzZXMgb2YgQ0xBTkdf UFJBR01BIHdpdGggI3ByYWdtYQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0luc3BlY3RvclNlcnZlci9IVFRQUmVxdWVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvSW5zcGVjdG9yU2VydmVyL0hUVFBSZXF1ZXN0LmNwcAppbmRleCA3MzQ5MjZjLi41ZDljNGIy IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvSW5zcGVjdG9yU2VydmVyL0hU VFBSZXF1ZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvSW5zcGVjdG9yU2Vy dmVyL0hUVFBSZXF1ZXN0LmNwcApAQCAtOTMsNiArOTMsMTMgQEAgc2l6ZV90IEhUVFBSZXF1ZXN0 OjpwYXJzZUhlYWRlcnMoY29uc3QgY2hhciogZGF0YSwgc2l6ZV90IGxlbmd0aCwgU3RyaW5nJiBm YWlsdXIKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBtX2hlYWRlckZpZWxkcy5hZGQobmFt ZSwgdmFsdWUpOwogICAgIH0KKworICAgIC8vIElmIHdlIGdvdCBoZXJlIGFuZCAibmFtZSIgaXMg ZW1wdHksIGl0IG1lYW5zIHRoZSBoZWFkZXJzIGFyZSB2YWxpZCBhbmQgZW5kZWQgd2l0aCBhCisg ICAgLy8gYmxhbmsgbGluZSAocGFyc2VIVFRQSGVhZGVyIHJldHVybnMgIm5hbWUiIGFzIGVtcHR5 IGlmIHBhcnNpbmcgYSBibGFuayBsaW5lKSwgb3RoZXJ3aXNlCisgICAgLy8gdGhlIGhlYWRlcnMg ZGlkbid0IGVuZCB3aXRoIGEgYmxhbmsgbGluZSBhbmQgd2UgaGF2ZSBhbiBpbnZhbGlkIHJlcXVl c3QuCisgICAgLy8gU2VlIGFsc28gaHR0cDovL3d3dy53My5vcmcvUHJvdG9jb2xzL3JmYzI2MTYv cmZjMjYxNi1zZWM0Lmh0bWwKKyAgICBpZiAoIW5hbWUuaXNFbXB0eSgpKQorICAgICAgICByZXR1 cm4gMDsKICAgICByZXR1cm4gcCAtIGRhdGE7CiB9CiAKLS0gCjEuOC4xLjIKCg== 211453 2013-09-12 11:50:57 -0700 2013-09-13 00:59:23 -0700 Patch with GTK tests 0001-Web-Inspector-Do-not-try-to-parse-incomplete-HTTP-re.patch text/plain 7293 andrunko RnJvbSA2NTBlYTRmZGZmMWYzODhkMzM3OTkzZjFmMzBkMWNlMDQ3MDczMjMyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiQW5kcmUgTW9yZWlyYSBNYWdhbGhhZXMgKGFuZHJ1bmtvKSIg PGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+CkRhdGU6IFR1ZSwgMTAgU2VwIDIwMTMg MTg6MTg6NTUgLTAzMDAKU3ViamVjdDogW1BBVENIXSBXZWIgSW5zcGVjdG9yOiBEbyBub3QgdHJ5 IHRvIHBhcnNlIGluY29tcGxldGUgSFRUUCByZXF1ZXN0cwogaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTEyMTEyMwoKUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpX aGVuIHdvcmtpbmcgb24gYSBwYXRjaCBmb3IgYnVnICMxMjExMjEgSSBmb3VuZCBhbiBpc3N1ZSB3 aXRoIHRoZSBJbnNwZWN0b3JTZXJ2ZXIgd2hlcmUgaXQgd291bGQgdHJ5CnRvIHBhcnNlIGFuIEhU VFAgbWVzc2FnZSBiZWZvcmUgcmVjZWl2aW5nIHRoZSBmdWxsIG1lc3NhZ2UgYW5kIHRodXMgZmFp bCBjb25uZWN0aW5nIHdpdGggdGhlCmNocm9tZWRldnRvb2xzIHBsdWdpbi4KCldoYXQgaGFwcGVu cyBpcyB0aGF0IHRoZSBXZWJTb2NrZXRTZXJ2ZXJDb25uZWN0aW9uIHJlY2VpdmVzIGJ1ZmZlcnMg b24KV2ViU29ja2V0U2VydmVyQ29ubmVjdGlvbjo6ZGlkUmVjZWl2ZVNvY2tldFN0cmVhbURhdGEg YW5kIGNhbGxzCldlYlNvY2tldFNlcnZlckNvbm5lY3Rpb246OnJlYWRIVFRQTWVzc2FnZSB3aGlj aCB0aGVuIGNoZWNrcyBpZiB3ZSBoYXZlIGEgdmFsaWQgcmVxdWVzdCBieSBjYWxsaW5nCkhUVFBS ZXF1ZXN0OjpwYXJzZUhUVFBSZXF1ZXN0RnJvbUJ1ZmZlci4gSWYgdGhlIHJlcXVlc3QgaXMgdmFs aWQgaXQgdHJpZXMgdG8gcGFyc2UgdGhlIG1lc3NhZ2UgYW5kCmNsZWFycyB0aGUgYnVmZmVyLCBv dGhlcndpc2UgaXQgY29udGludWVzIGFkZGluZyBkYXRhIHRvIHRoZSBpbnRlcm5hbCBidWZmZXIg dW50aWwgd2UgaGF2ZSBhIHZhbGlkCnJlcXVlc3QuCgpUaGUgcHJvYmxlbSBpcyB0aGF0IGN1cnJl bnRseSBIVFRQUmVxdWVzdDo6cGFyc2VIVFRQUmVxdWVzdEZyb21CdWZmZXIgY29uc2lkZXJzIHRo ZSByZXF1ZXN0IGFzIHZhbGlkCmJlZm9yZSByZWNlaXZpbmcgdGhlIGZ1bGwgbWVzc2FnZS4gVG8g c29sdmUgdGhpcyB3ZSBzaG91bGQgbWFrZSB0aGUgbWV0aG9kIGNoZWNrIGlmIHRoZSByZXF1ZXN0 CmhlYWRlcnMgZW5kIHdpdGggYSBibGFuayBsaW5lIG90aGVyd2lzZSB3ZSBjb25zaWRlciB0aGUg cmVxdWVzdCBhcyBpbnZhbGlkIChzZWUgYWxzbwpodHRwOi8vd3d3LnczLm9yZy9Qcm90b2NvbHMv cmZjMjYxNi9yZmMyNjE2LXNlYzQuaHRtbCkuCgoqIFVJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rl c3RJbnNwZWN0b3JTZXJ2ZXIuY3BwOgooc2VuZEluY29tcGxldGVSZXF1ZXN0KToKKGJlZm9yZUFs bCk6CkFkZCBHVEsgc3BlY2lmaWMgdGVzdCB0byBjaGVjayBpZiB0aGUgaW5zcGVjdG9yIHNlcnZl ciByZXBsaWVzIHRvIGluY29tcGxldGUgcmVxdWVzdHMuCiogVUlQcm9jZXNzL0luc3BlY3RvclNl cnZlci9IVFRQUmVxdWVzdC5jcHA6CihXZWJLaXQ6OkhUVFBSZXF1ZXN0OjpwYXJzZUhlYWRlcnMp OgpEbyBub3QgY29uc2lkZXIgcmVxdWVzdCB2YWxpZCBpZiBoZWFkZXJzIGRpZG4ndCBlbmQgd2l0 aCBhIGJsYW5rIGxpbmUuCi0tLQogU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAzMSArKysrKysrKysrKysrKysrKysrKysrCiAuLi4vQVBJL2d0ay90 ZXN0cy9UZXN0SW5zcGVjdG9yU2VydmVyLmNwcCAgICAgICAgICB8IDI4ICsrKysrKysrKysrKysr KysrKysKIC4uLi9VSVByb2Nlc3MvSW5zcGVjdG9yU2VydmVyL0hUVFBSZXF1ZXN0LmNwcCAgICAg IHwgIDcgKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNjYgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpp bmRleCAxY2YyNjgyLi43MzMxNTIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTMt MDktMTIgIEFuZHJlIE1vcmVpcmEgTWFnYWxoYWVzICAgPGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJv cmEuY28udWs+CisKKyAgICAgICAgV2ViIEluc3BlY3RvcjogRG8gbm90IHRyeSB0byBwYXJzZSBp bmNvbXBsZXRlIEhUVFAgcmVxdWVzdHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTEyMTEyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFdoZW4gd29ya2luZyBvbiBhIHBhdGNoIGZvciBidWcgIzEyMTEyMSBJ IGZvdW5kIGFuIGlzc3VlIHdpdGggdGhlIEluc3BlY3RvclNlcnZlciB3aGVyZSBpdCB3b3VsZCB0 cnkKKyAgICAgICAgdG8gcGFyc2UgYW4gSFRUUCBtZXNzYWdlIGJlZm9yZSByZWNlaXZpbmcgdGhl IGZ1bGwgbWVzc2FnZSBhbmQgdGh1cyBmYWlsIGNvbm5lY3Rpbmcgd2l0aCB0aGUKKyAgICAgICAg Y2hyb21lZGV2dG9vbHMgcGx1Z2luLgorCisgICAgICAgIFdoYXQgaGFwcGVucyBpcyB0aGF0IHRo ZSBXZWJTb2NrZXRTZXJ2ZXJDb25uZWN0aW9uIHJlY2VpdmVzIGJ1ZmZlcnMgb24KKyAgICAgICAg V2ViU29ja2V0U2VydmVyQ29ubmVjdGlvbjo6ZGlkUmVjZWl2ZVNvY2tldFN0cmVhbURhdGEgYW5k IGNhbGxzCisgICAgICAgIFdlYlNvY2tldFNlcnZlckNvbm5lY3Rpb246OnJlYWRIVFRQTWVzc2Fn ZSB3aGljaCB0aGVuIGNoZWNrcyBpZiB3ZSBoYXZlIGEgdmFsaWQgcmVxdWVzdCBieSBjYWxsaW5n CisgICAgICAgIEhUVFBSZXF1ZXN0OjpwYXJzZUhUVFBSZXF1ZXN0RnJvbUJ1ZmZlci4gSWYgdGhl IHJlcXVlc3QgaXMgdmFsaWQgaXQgdHJpZXMgdG8gcGFyc2UgdGhlIG1lc3NhZ2UgYW5kCisgICAg ICAgIGNsZWFycyB0aGUgYnVmZmVyLCBvdGhlcndpc2UgaXQgY29udGludWVzIGFkZGluZyBkYXRh IHRvIHRoZSBpbnRlcm5hbCBidWZmZXIgdW50aWwgd2UgaGF2ZSBhIHZhbGlkCisgICAgICAgIHJl cXVlc3QuCisKKyAgICAgICAgVGhlIHByb2JsZW0gaXMgdGhhdCBjdXJyZW50bHkgSFRUUFJlcXVl c3Q6OnBhcnNlSFRUUFJlcXVlc3RGcm9tQnVmZmVyIGNvbnNpZGVycyB0aGUgcmVxdWVzdCBhcyB2 YWxpZAorICAgICAgICBiZWZvcmUgcmVjZWl2aW5nIHRoZSBmdWxsIG1lc3NhZ2UuIFRvIHNvbHZl IHRoaXMgd2Ugc2hvdWxkIG1ha2UgdGhlIG1ldGhvZCBjaGVjayBpZiB0aGUgcmVxdWVzdAorICAg ICAgICBoZWFkZXJzIGVuZCB3aXRoIGEgYmxhbmsgbGluZSBvdGhlcndpc2Ugd2UgY29uc2lkZXIg dGhlIHJlcXVlc3QgYXMgaW52YWxpZCAoc2VlIGFsc28KKyAgICAgICAgaHR0cDovL3d3dy53My5v cmcvUHJvdG9jb2xzL3JmYzI2MTYvcmZjMjYxNi1zZWM0Lmh0bWwpLgorCisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdEluc3BlY3RvclNlcnZlci5jcHA6CisgICAgICAgIChz ZW5kSW5jb21wbGV0ZVJlcXVlc3QpOgorICAgICAgICAoYmVmb3JlQWxsKToKKyAgICAgICAgQWRk IEdUSyBzcGVjaWZpYyB0ZXN0IHRvIGNoZWNrIGlmIHRoZSBpbnNwZWN0b3Igc2VydmVyIHJlcGxp ZXMgdG8gaW5jb21wbGV0ZSByZXF1ZXN0cy4KKyAgICAgICAgKiBVSVByb2Nlc3MvSW5zcGVjdG9y U2VydmVyL0hUVFBSZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYktpdDo6SFRUUFJlcXVlc3Q6OnBh cnNlSGVhZGVycyk6CisgICAgICAgIERvIG5vdCBjb25zaWRlciByZXF1ZXN0IHZhbGlkIGlmIGhl YWRlcnMgZGlkbid0IGVuZCB3aXRoIGEgYmxhbmsgbGluZS4KKwogMjAxMy0wOS0wNSAgQW5kZXJz IENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFJlcGxhY2UgdXNlcyBv ZiBDTEFOR19QUkFHTUEgd2l0aCAjcHJhZ21hCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0SW5zcGVjdG9yU2VydmVyLmNwcCBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwCmlu ZGV4IDM1ZmIzZmMuLjBiMjM1NGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwCkBAIC0y NDAsNiArMjQwLDMzIEBAIHN0YXRpYyB2b2lkIG9wZW5SZW1vdGVEZWJ1Z2dpbmdTZXNzaW9uKElu c3BlY3RvclNlcnZlclRlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCiAgICAgZ19hc3NlcnRfY21w c3RyKHdlYmtpdF93ZWJfdmlld19nZXRfdGl0bGUodGVzdC0+bV93ZWJWaWV3KSwgPT0sICJXZWIg SW5zcGVjdG9yIC0gaHR0cDovLzEyNy4wLjAuMToyOTk5LyIpOwogfQogCitzdGF0aWMgdm9pZCBz ZW5kSW5jb21wbGV0ZVJlcXVlc3QoSW5zcGVjdG9yU2VydmVyVGVzdCogdGVzdCwgZ2NvbnN0cG9p bnRlcikKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisKKyAgICAvLyBDb25uZWN0IHRv IHRoZSBpbnNwZWN0b3Igc2VydmVyLgorICAgIEdTb2NrZXRDbGllbnQqIGNsaWVudCA9IGdfc29j a2V0X2NsaWVudF9uZXcoKTsKKyAgICBHU29ja2V0Q29ubmVjdGlvbiogY29ubmVjdGlvbiA9IGdf c29ja2V0X2NsaWVudF9jb25uZWN0X3RvX2hvc3QoY2xpZW50LCAiMTI3LjAuMC4xIiwgMjk5OSwg TlVMTCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBnX2Fzc2VydCghZXJyb3IuZ2V0KCkpOworCisg ICAgLy8gU2VuZCBpbmNvbXBsZXRlIHJlcXVlc3QgKG1pc3NpbmcgYmxhbmsgbGluZSBhZnRlciBo ZWFkZXJzKSBhbmQgY2hlY2sgaWYgaW5zcGVjdG9yIHNlcnZlcgorICAgIC8vIHJlcGxpZXMuIFRo ZSBzZXJ2ZXIgc2hvdWxkIG5vdCByZXBseSB0byBhbiBpbmNvbXBsZXRlIHJlcXVlc3QgYW5kIHRo ZSB0ZXN0IHNob3VsZCB0aW1lb3V0CisgICAgLy8gb24gcmVhZC4KKyAgICBHT3V0cHV0U3RyZWFt KiBvc3RyZWFtID0gZ19pb19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0oR19JT19TVFJFQU0oY29u bmVjdGlvbikpOworICAgIC8vIFJlcXVlc3QgbWlzc2luZyBibGFuayBsaW5lIGFmdGVyIGhlYWRl cnMuCisgICAgY29uc3QgZ2NoYXIqIGluY29tcGxldGVSZXF1ZXN0ID0gIkdFVCAvZGV2dG9vbHMv cGFnZS8xIEhUVFAvMS4xXHJcbkhvc3Q6IExvY2FsaG9zdFxyXG4iOworICAgIGdfb3V0cHV0X3N0 cmVhbV93cml0ZShvc3RyZWFtLCBpbmNvbXBsZXRlUmVxdWVzdCwgc3RybGVuKGluY29tcGxldGVS ZXF1ZXN0KSwgTlVMTCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBnX2Fzc2VydCghZXJyb3IuZ2V0 KCkpOworCisgICAgR0lucHV0U3RyZWFtKiBpc3RyZWFtID0gZ19pb19zdHJlYW1fZ2V0X2lucHV0 X3N0cmVhbShHX0lPX1NUUkVBTShjb25uZWN0aW9uKSk7CisgICAgY2hhciByZXNwb25zZVsxNl07 CisgICAgbWVtc2V0KHJlc3BvbnNlLCAwLCBzaXplb2YocmVzcG9uc2UpKTsKKyAgICBnX2lucHV0 X3N0cmVhbV9yZWFkX2FzeW5jKGlzdHJlYW0sIHJlc3BvbnNlLCBzaXplb2YocmVzcG9uc2UpIC0g MSwgR19QUklPUklUWV9ERUZBVUxULCBOVUxMLCBOVUxMLCBOVUxMKTsKKyAgICAvLyBHaXZlIGEg Y2hhbmNlIGZvciB0aGUgc2VydmVyIHRvIHJlcGx5LgorICAgIHRlc3QtPndhaXQoMik7CisgICAg Ly8gSWYgd2UgZ290IGFueSBhbnN3ZXIgaXQgbWVhbnMgdGhlIHNlcnZlciByZXBsaWVkIHRvIGFu IGluY29tcGxldGUgcmVxdWVzdCwgbGV0cyBmYWlsLgorICAgIGdfYXNzZXJ0KFN0cmluZyhyZXNw b25zZSkuaXNFbXB0eSgpKTsKK30KIAogdm9pZCBiZWZvcmVBbGwoKQogewpAQCAtMjUwLDYgKzI3 Nyw3IEBAIHZvaWQgYmVmb3JlQWxsKCkKICAgICBJbnNwZWN0b3JTZXJ2ZXJUZXN0OjphZGQoIldl YktpdFdlYkluc3BlY3RvclNlcnZlciIsICJ0ZXN0LXBhZ2UtbGlzdCIsIHRlc3RJbnNwZWN0b3JT ZXJ2ZXJQYWdlTGlzdCk7CiAgICAgSW5zcGVjdG9yU2VydmVyVGVzdDo6YWRkKCJXZWJLaXRXZWJJ bnNwZWN0b3JTZXJ2ZXIiLCAidGVzdC1yZW1vdGUtZGVidWdnaW5nLW1lc3NhZ2UiLCB0ZXN0UmVt b3RlRGVidWdnaW5nTWVzc2FnZSk7CiAgICAgSW5zcGVjdG9yU2VydmVyVGVzdDo6YWRkKCJXZWJL aXRXZWJJbnNwZWN0b3JTZXJ2ZXIiLCAidGVzdC1vcGVuLWRlYnVnZ2luZy1zZXNzaW9uIiwgb3Bl blJlbW90ZURlYnVnZ2luZ1Nlc3Npb24pOworICAgIEluc3BlY3RvclNlcnZlclRlc3Q6OmFkZCgi V2ViS2l0V2ViSW5zcGVjdG9yU2VydmVyIiwgInRlc3QtaW5jb21wbGV0ZS1yZXF1ZXN0Iiwgc2Vu ZEluY29tcGxldGVSZXF1ZXN0KTsKIAogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvSW5zcGVjdG9yU2VydmVyL0hUVFBSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9JbnNwZWN0b3JTZXJ2ZXIvSFRUUFJlcXVlc3QuY3BwCmluZGV4IDczNDkyNmMu LjVkOWM0YjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9JbnNwZWN0b3JT ZXJ2ZXIvSFRUUFJlcXVlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9JbnNw ZWN0b3JTZXJ2ZXIvSFRUUFJlcXVlc3QuY3BwCkBAIC05Myw2ICs5MywxMyBAQCBzaXplX3QgSFRU UFJlcXVlc3Q6OnBhcnNlSGVhZGVycyhjb25zdCBjaGFyKiBkYXRhLCBzaXplX3QgbGVuZ3RoLCBT dHJpbmcmIGZhaWx1cgogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIG1faGVhZGVyRmllbGRz LmFkZChuYW1lLCB2YWx1ZSk7CiAgICAgfQorCisgICAgLy8gSWYgd2UgZ290IGhlcmUgYW5kICJu YW1lIiBpcyBlbXB0eSwgaXQgbWVhbnMgdGhlIGhlYWRlcnMgYXJlIHZhbGlkIGFuZCBlbmRlZCB3 aXRoIGEKKyAgICAvLyBibGFuayBsaW5lIChwYXJzZUhUVFBIZWFkZXIgcmV0dXJucyAibmFtZSIg YXMgZW1wdHkgaWYgcGFyc2luZyBhIGJsYW5rIGxpbmUpLCBvdGhlcndpc2UKKyAgICAvLyB0aGUg aGVhZGVycyBkaWRuJ3QgZW5kIHdpdGggYSBibGFuayBsaW5lIGFuZCB3ZSBoYXZlIGFuIGludmFs aWQgcmVxdWVzdC4KKyAgICAvLyBTZWUgYWxzbyBodHRwOi8vd3d3LnczLm9yZy9Qcm90b2NvbHMv cmZjMjYxNi9yZmMyNjE2LXNlYzQuaHRtbAorICAgIGlmICghbmFtZS5pc0VtcHR5KCkpCisgICAg ICAgIHJldHVybiAwOwogICAgIHJldHVybiBwIC0gZGF0YTsKIH0KIAotLSAKMS44LjEuMgoK 211555 2013-09-13 08:23:55 -0700 2013-09-16 07:06:52 -0700 Patch addressing Carlos review 0001-Web-Inspector-Do-not-try-to-parse-incomplete-HTTP-re.patch text/plain 4113 andrunko RnJvbSBlNGNkZWVjOWFmMWNkODU3OTlhNDkyMWE2NDhiMDFhMTVmYTg0ZWQ4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiQW5kcmUgTW9yZWlyYSBNYWdhbGhhZXMgKGFuZHJ1bmtvKSIg PGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+CkRhdGU6IEZyaSwgMTMgU2VwIDIwMTMg MTI6MTY6MjMgLTAzMDAKU3ViamVjdDogW1BBVENIXSBXZWIgSW5zcGVjdG9yOiBEbyBub3QgdHJ5 IHRvIHBhcnNlIGluY29tcGxldGUgSFRUUCByZXF1ZXN0cwogaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTEyMTEyMwoKUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpV cGRhdGUgdG8gaW5jb3Jwb3JhdGUgYWRkaXRpb25hbCByZXZpZXcgc3VnZ2VzdGlvbnMuCgoqIFVJ UHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwOgooc2VuZEluY29t cGxldGVSZXF1ZXN0KToKRml4IG1lbW9yeSBsZWFrcywgY2hhbmdlIHRlc3QgdGltZW91dCBmcm9t IDIgc2Vjb25kcyB0byAxIHNlY29uZCwKdXNlICIwIiBpbnN0ZWFkIG9mICJOVUxMIiBhbmQgdXNl IGdfYXNzZXJ0X25vX2Vycm9yIHdoZW4gY2hlY2tpbmcKZm9yIEdFcnJvci4KLS0tCiBTb3VyY2Uv V2ViS2l0Mi9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNSArKysr KysrKysrKysrKysKIC4uLi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0SW5zcGVjdG9yU2Vy dmVyLmNwcCAgICB8IDE4ICsrKysrKysrKy0tLS0tLS0tLQogMiBmaWxlcyBjaGFuZ2VkLCAyNCBp bnNlcnRpb25zKCspLCA5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA0MjVlNWZlLi4xMzIy ZWIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTMtMDktMTMgIEFuZHJlIE1vcmVp cmEgTWFnYWxoYWVzICAgPGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+CisKKyAgICAg ICAgV2ViIEluc3BlY3RvcjogRG8gbm90IHRyeSB0byBwYXJzZSBpbmNvbXBsZXRlIEhUVFAgcmVx dWVzdHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEy MTEyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVw ZGF0ZSB0byBpbmNvcnBvcmF0ZSBhZGRpdGlvbmFsIHJldmlldyBzdWdnZXN0aW9ucy4KKworICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwOgor ICAgICAgICAoc2VuZEluY29tcGxldGVSZXF1ZXN0KToKKyAgICAgICAgRml4IG1lbW9yeSBsZWFr cywgY2hhbmdlIHRlc3QgdGltZW91dCBmcm9tIDIgc2Vjb25kcyB0byAxIHNlY29uZCwKKyAgICAg ICAgdXNlICIwIiBpbnN0ZWFkIG9mICJOVUxMIiBhbmQgdXNlIGdfYXNzZXJ0X25vX2Vycm9yIHdo ZW4gY2hlY2tpbmcKKyAgICAgICAgZm9yIEdFcnJvci4KKwogMjAxMy0wOS0xMiAgU2ltb24gRnJh c2VyICA8c2ltb24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAgICAgICBBdm9pZCBleHRyYSBzY3Jv bGxiYXItcmVsYXRlZCBsYXlvdXRzIGZvciBvdmVybGF5IHNjcm9sbGJhcnMKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2 ZXIuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdEluc3Bl Y3RvclNlcnZlci5jcHAKaW5kZXggMGIyMzU0Zi4uMjBmZWQyYiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdEluc3BlY3RvclNlcnZlci5jcHAK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdEluc3BlY3Rv clNlcnZlci5jcHAKQEAgLTI0NSwyNSArMjQ1LDI1IEBAIHN0YXRpYyB2b2lkIHNlbmRJbmNvbXBs ZXRlUmVxdWVzdChJbnNwZWN0b3JTZXJ2ZXJUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogICAg IEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKIAogICAgIC8vIENvbm5lY3QgdG8gdGhlIGluc3BlY3Rv ciBzZXJ2ZXIuCi0gICAgR1NvY2tldENsaWVudCogY2xpZW50ID0gZ19zb2NrZXRfY2xpZW50X25l dygpOwotICAgIEdTb2NrZXRDb25uZWN0aW9uKiBjb25uZWN0aW9uID0gZ19zb2NrZXRfY2xpZW50 X2Nvbm5lY3RfdG9faG9zdChjbGllbnQsICIxMjcuMC4wLjEiLCAyOTk5LCBOVUxMLCAmZXJyb3Iu b3V0UHRyKCkpOwotICAgIGdfYXNzZXJ0KCFlcnJvci5nZXQoKSk7CisgICAgR1JlZlB0cjxHU29j a2V0Q2xpZW50PiBjbGllbnQgPSBnX3NvY2tldF9jbGllbnRfbmV3KCk7CisgICAgR1JlZlB0cjxH U29ja2V0Q29ubmVjdGlvbj4gY29ubmVjdGlvbiA9IGdfc29ja2V0X2NsaWVudF9jb25uZWN0X3Rv X2hvc3QoY2xpZW50LmdldCgpLCAiMTI3LjAuMC4xIiwgMjk5OSwgMCwgJmVycm9yLm91dFB0cigp KTsKKyAgICBnX2Fzc2VydF9ub19lcnJvcihlcnJvci5nZXQoKSk7CiAKICAgICAvLyBTZW5kIGlu Y29tcGxldGUgcmVxdWVzdCAobWlzc2luZyBibGFuayBsaW5lIGFmdGVyIGhlYWRlcnMpIGFuZCBj aGVjayBpZiBpbnNwZWN0b3Igc2VydmVyCiAgICAgLy8gcmVwbGllcy4gVGhlIHNlcnZlciBzaG91 bGQgbm90IHJlcGx5IHRvIGFuIGluY29tcGxldGUgcmVxdWVzdCBhbmQgdGhlIHRlc3Qgc2hvdWxk IHRpbWVvdXQKICAgICAvLyBvbiByZWFkLgotICAgIEdPdXRwdXRTdHJlYW0qIG9zdHJlYW0gPSBn X2lvX3N0cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShHX0lPX1NUUkVBTShjb25uZWN0aW9uKSk7Cisg ICAgR091dHB1dFN0cmVhbSogb3N0cmVhbSA9IGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFt KEdfSU9fU1RSRUFNKGNvbm5lY3Rpb24uZ2V0KCkpKTsKICAgICAvLyBSZXF1ZXN0IG1pc3Npbmcg YmxhbmsgbGluZSBhZnRlciBoZWFkZXJzLgogICAgIGNvbnN0IGdjaGFyKiBpbmNvbXBsZXRlUmVx dWVzdCA9ICJHRVQgL2RldnRvb2xzL3BhZ2UvMSBIVFRQLzEuMVxyXG5Ib3N0OiBMb2NhbGhvc3Rc clxuIjsKLSAgICBnX291dHB1dF9zdHJlYW1fd3JpdGUob3N0cmVhbSwgaW5jb21wbGV0ZVJlcXVl c3QsIHN0cmxlbihpbmNvbXBsZXRlUmVxdWVzdCksIE5VTEwsICZlcnJvci5vdXRQdHIoKSk7Ci0g ICAgZ19hc3NlcnQoIWVycm9yLmdldCgpKTsKKyAgICBnX291dHB1dF9zdHJlYW1fd3JpdGUob3N0 cmVhbSwgaW5jb21wbGV0ZVJlcXVlc3QsIHN0cmxlbihpbmNvbXBsZXRlUmVxdWVzdCksIDAsICZl cnJvci5vdXRQdHIoKSk7CisgICAgZ19hc3NlcnRfbm9fZXJyb3IoZXJyb3IuZ2V0KCkpOwogCi0g ICAgR0lucHV0U3RyZWFtKiBpc3RyZWFtID0gZ19pb19zdHJlYW1fZ2V0X2lucHV0X3N0cmVhbShH X0lPX1NUUkVBTShjb25uZWN0aW9uKSk7CisgICAgR0lucHV0U3RyZWFtKiBpc3RyZWFtID0gZ19p b19zdHJlYW1fZ2V0X2lucHV0X3N0cmVhbShHX0lPX1NUUkVBTShjb25uZWN0aW9uLmdldCgpKSk7 CiAgICAgY2hhciByZXNwb25zZVsxNl07CiAgICAgbWVtc2V0KHJlc3BvbnNlLCAwLCBzaXplb2Yo cmVzcG9uc2UpKTsKLSAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2FzeW5jKGlzdHJlYW0sIHJlc3Bv bnNlLCBzaXplb2YocmVzcG9uc2UpIC0gMSwgR19QUklPUklUWV9ERUZBVUxULCBOVUxMLCBOVUxM LCBOVUxMKTsKKyAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2FzeW5jKGlzdHJlYW0sIHJlc3BvbnNl LCBzaXplb2YocmVzcG9uc2UpIC0gMSwgR19QUklPUklUWV9ERUZBVUxULCAwLCAwLCAwKTsKICAg ICAvLyBHaXZlIGEgY2hhbmNlIGZvciB0aGUgc2VydmVyIHRvIHJlcGx5LgotICAgIHRlc3QtPndh aXQoMik7CisgICAgdGVzdC0+d2FpdCgxKTsKICAgICAvLyBJZiB3ZSBnb3QgYW55IGFuc3dlciBp dCBtZWFucyB0aGUgc2VydmVyIHJlcGxpZWQgdG8gYW4gaW5jb21wbGV0ZSByZXF1ZXN0LCBsZXRz IGZhaWwuCiAgICAgZ19hc3NlcnQoU3RyaW5nKHJlc3BvbnNlKS5pc0VtcHR5KCkpOwogfQotLSAK MS44LjEuMgoK 211778 2013-09-16 07:06:52 -0700 2013-09-16 08:48:54 -0700 Patch addressing Carlos review (new round) 0001-Web-Inspector-Do-not-try-to-parse-incomplete-HTTP-re.patch text/plain 4299 andrunko RnJvbSBkNjYxZjc5YzViNjM1M2NlMTdlMTkxMWU2ZDBkY2U4OThiNjIyNTM2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiQW5kcmUgTW9yZWlyYSBNYWdhbGhhZXMgKGFuZHJ1bmtvKSIg PGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+CkRhdGU6IEZyaSwgMTMgU2VwIDIwMTMg MTI6MTY6MjMgLTAzMDAKU3ViamVjdDogW1BBVENIXSBXZWIgSW5zcGVjdG9yOiBEbyBub3QgdHJ5 IHRvIHBhcnNlIGluY29tcGxldGUgSFRUUCByZXF1ZXN0cwogaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTEyMTEyMwoKUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpV cGRhdGUgdG8gaW5jb3Jwb3JhdGUgYWRkaXRpb25hbCByZXZpZXcgc3VnZ2VzdGlvbnMuCgoqIFVJ UHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwOgooc2VuZEluY29t cGxldGVSZXF1ZXN0KToKRml4IG1lbW9yeSBsZWFrcywgY2hhbmdlIHRlc3QgdGltZW91dCBmcm9t IDIgc2Vjb25kcyB0byAxIHNlY29uZCwKdXNlICIwIiBpbnN0ZWFkIG9mICJOVUxMIiBhbmQgdXNl IGdfYXNzZXJ0X25vX2Vycm9yIHdoZW4gY2hlY2tpbmcKZm9yIEdFcnJvci4KLS0tCiBTb3VyY2Uv V2ViS2l0Mi9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICB8IDE1ICsrKysrKysr KysrKysrKwogLi4uL0FQSS9ndGsvdGVzdHMvVGVzdEluc3BlY3RvclNlcnZlci5jcHAgICAgICAg ICAgfCAyMiArKysrKysrKysrKystLS0tLS0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDI3IGluc2Vy dGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCAzYTMxOTA3Li5lYjczZGVj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTMtMDktMTMgIEFuZHJlIE1vcmVpcmEg TWFnYWxoYWVzICAgPGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAg V2ViIEluc3BlY3RvcjogRG8gbm90IHRyeSB0byBwYXJzZSBpbmNvbXBsZXRlIEhUVFAgcmVxdWVz dHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyMTEy MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVwZGF0 ZSB0byBpbmNvcnBvcmF0ZSBhZGRpdGlvbmFsIHJldmlldyBzdWdnZXN0aW9ucy4KKworICAgICAg ICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwOgorICAg ICAgICAoc2VuZEluY29tcGxldGVSZXF1ZXN0KToKKyAgICAgICAgRml4IG1lbW9yeSBsZWFrcywg Y2hhbmdlIHRlc3QgdGltZW91dCBmcm9tIDIgc2Vjb25kcyB0byAxIHNlY29uZCwKKyAgICAgICAg dXNlICIwIiBpbnN0ZWFkIG9mICJOVUxMIiBhbmQgdXNlIGdfYXNzZXJ0X25vX2Vycm9yIHdoZW4g Y2hlY2tpbmcKKyAgICAgICAgZm9yIEdFcnJvci4KKwogMjAxMy0wOS0xMyAgR3VzdGF2byBOb3Jv bmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jb20+CiAKICAgICAgICAgW0dU S10gTW92ZSB0byB0aGUgbmV3IHdlYiBpbnNwZWN0b3IKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RJbnNwZWN0b3JTZXJ2ZXIuY3BwIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdEluc3BlY3RvclNlcnZlci5j cHAKaW5kZXggYjA0NjhiZi4uZmE0Y2I0ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdEluc3BlY3RvclNlcnZlci5jcHAKKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdEluc3BlY3RvclNlcnZlci5jcHAK QEAgLTI0NSwyNyArMjQ1LDI5IEBAIHN0YXRpYyB2b2lkIHNlbmRJbmNvbXBsZXRlUmVxdWVzdChJ bnNwZWN0b3JTZXJ2ZXJUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogICAgIEdPd25QdHI8R0Vy cm9yPiBlcnJvcjsKIAogICAgIC8vIENvbm5lY3QgdG8gdGhlIGluc3BlY3RvciBzZXJ2ZXIuCi0g ICAgR1NvY2tldENsaWVudCogY2xpZW50ID0gZ19zb2NrZXRfY2xpZW50X25ldygpOwotICAgIEdT b2NrZXRDb25uZWN0aW9uKiBjb25uZWN0aW9uID0gZ19zb2NrZXRfY2xpZW50X2Nvbm5lY3RfdG9f aG9zdChjbGllbnQsICIxMjcuMC4wLjEiLCAyOTk5LCBOVUxMLCAmZXJyb3Iub3V0UHRyKCkpOwot ICAgIGdfYXNzZXJ0KCFlcnJvci5nZXQoKSk7CisgICAgR1JlZlB0cjxHU29ja2V0Q2xpZW50PiBj bGllbnQgPSBhZG9wdEdSZWYoZ19zb2NrZXRfY2xpZW50X25ldygpKTsKKyAgICBHUmVmUHRyPEdT b2NrZXRDb25uZWN0aW9uPiBjb25uZWN0aW9uID0gYWRvcHRHUmVmKGdfc29ja2V0X2NsaWVudF9j b25uZWN0X3RvX2hvc3QoY2xpZW50LmdldCgpLCAiMTI3LjAuMC4xIiwgMjk5OSwgMCwgJmVycm9y Lm91dFB0cigpKSk7CisgICAgZ19hc3NlcnRfbm9fZXJyb3IoZXJyb3IuZ2V0KCkpOwogCiAgICAg Ly8gU2VuZCBpbmNvbXBsZXRlIHJlcXVlc3QgKG1pc3NpbmcgYmxhbmsgbGluZSBhZnRlciBoZWFk ZXJzKSBhbmQgY2hlY2sgaWYgaW5zcGVjdG9yIHNlcnZlcgogICAgIC8vIHJlcGxpZXMuIFRoZSBz ZXJ2ZXIgc2hvdWxkIG5vdCByZXBseSB0byBhbiBpbmNvbXBsZXRlIHJlcXVlc3QgYW5kIHRoZSB0 ZXN0IHNob3VsZCB0aW1lb3V0CiAgICAgLy8gb24gcmVhZC4KLSAgICBHT3V0cHV0U3RyZWFtKiBv c3RyZWFtID0gZ19pb19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0oR19JT19TVFJFQU0oY29ubmVj dGlvbikpOworICAgIEdPdXRwdXRTdHJlYW0qIG9zdHJlYW0gPSBnX2lvX3N0cmVhbV9nZXRfb3V0 cHV0X3N0cmVhbShHX0lPX1NUUkVBTShjb25uZWN0aW9uLmdldCgpKSk7CiAgICAgLy8gUmVxdWVz dCBtaXNzaW5nIGJsYW5rIGxpbmUgYWZ0ZXIgaGVhZGVycy4KICAgICBjb25zdCBnY2hhciogaW5j b21wbGV0ZVJlcXVlc3QgPSAiR0VUIC9kZXZ0b29scy9wYWdlLzEgSFRUUC8xLjFcclxuSG9zdDog TG9jYWxob3N0XHJcbiI7Ci0gICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlKG9zdHJlYW0sIGluY29t cGxldGVSZXF1ZXN0LCBzdHJsZW4oaW5jb21wbGV0ZVJlcXVlc3QpLCBOVUxMLCAmZXJyb3Iub3V0 UHRyKCkpOwotICAgIGdfYXNzZXJ0KCFlcnJvci5nZXQoKSk7CisgICAgZ19vdXRwdXRfc3RyZWFt X3dyaXRlKG9zdHJlYW0sIGluY29tcGxldGVSZXF1ZXN0LCBzdHJsZW4oaW5jb21wbGV0ZVJlcXVl c3QpLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGdfYXNzZXJ0X25vX2Vycm9yKGVycm9yLmdl dCgpKTsKIAotICAgIEdJbnB1dFN0cmVhbSogaXN0cmVhbSA9IGdfaW9fc3RyZWFtX2dldF9pbnB1 dF9zdHJlYW0oR19JT19TVFJFQU0oY29ubmVjdGlvbikpOworICAgIEdJbnB1dFN0cmVhbSogaXN0 cmVhbSA9IGdfaW9fc3RyZWFtX2dldF9pbnB1dF9zdHJlYW0oR19JT19TVFJFQU0oY29ubmVjdGlv bi5nZXQoKSkpOwogICAgIGNoYXIgcmVzcG9uc2VbMTZdOwogICAgIG1lbXNldChyZXNwb25zZSwg MCwgc2l6ZW9mKHJlc3BvbnNlKSk7Ci0gICAgZ19pbnB1dF9zdHJlYW1fcmVhZF9hc3luYyhpc3Ry ZWFtLCByZXNwb25zZSwgc2l6ZW9mKHJlc3BvbnNlKSAtIDEsIEdfUFJJT1JJVFlfREVGQVVMVCwg TlVMTCwgTlVMTCwgTlVMTCk7CisgICAgR1JlZlB0cjxHQ2FuY2VsbGFibGU+IGNhbmNlbCA9IGFk b3B0R1JlZihnX2NhbmNlbGxhYmxlX25ldygpKTsKKyAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2Fz eW5jKGlzdHJlYW0sIHJlc3BvbnNlLCBzaXplb2YocmVzcG9uc2UpIC0gMSwgR19QUklPUklUWV9E RUZBVUxULCBjYW5jZWwuZ2V0KCksIDAsIDApOwogICAgIC8vIEdpdmUgYSBjaGFuY2UgZm9yIHRo ZSBzZXJ2ZXIgdG8gcmVwbHkuCi0gICAgdGVzdC0+d2FpdCgyKTsKKyAgICB0ZXN0LT53YWl0KDEp OworICAgIGdfY2FuY2VsbGFibGVfY2FuY2VsKGNhbmNlbC5nZXQoKSk7CiAgICAgLy8gSWYgd2Ug Z290IGFueSBhbnN3ZXIgaXQgbWVhbnMgdGhlIHNlcnZlciByZXBsaWVkIHRvIGFuIGluY29tcGxl dGUgcmVxdWVzdCwgbGV0cyBmYWlsLgotICAgIGdfYXNzZXJ0KFN0cmluZyhyZXNwb25zZSkuaXNF bXB0eSgpKTsKKyAgICBnX2Fzc2VydChyZXNwb25zZVswXSA9PSAnXDAnKTsKIH0KIAogdm9pZCBi ZWZvcmVBbGwoKQotLSAKMS44LjEuMgoK