From fa82a9ed76b9c3250beb26eae05889924a9fc805 Mon Sep 17 00:00:00 2001 From: Bryan Roe Date: Wed, 29 Sep 2021 22:08:04 -0700 Subject: [PATCH] 1. Updated http-diget to not chunk requests, working around AMT TLS bug 2. Fixed bug in http persistent connections, where 2nd request would close the socket when client request is 'end'ed. 3. Added debug logging/instrumentation to readable and writable stream --- microscript/ILibDuktape_HttpStream.c | 13 +++++++--- microscript/ILibDuktape_Polyfills.c | 2 +- microscript/ILibDuktape_ReadableStream.c | 33 ++++++++++++++++++++++++ microscript/ILibDuktape_WritableStream.c | 2 +- modules/http-digest.js | 30 +++++++++++++++++---- 5 files changed, 69 insertions(+), 11 deletions(-) diff --git a/microscript/ILibDuktape_HttpStream.c b/microscript/ILibDuktape_HttpStream.c index 33327e6..faba63a 100644 --- a/microscript/ILibDuktape_HttpStream.c +++ b/microscript/ILibDuktape_HttpStream.c @@ -67,6 +67,7 @@ void ILibDuktape_RemoveObjFromTable(duk_context *ctx, duk_idx_t tableIdx, char * #define ILibDuktape_IMSG2SR "\xFF_IMSG2ServerResponse" #define ILibDuktape_NS2HttpServer "\xFF_Http_NetServer2HttpServer" #define ILibDuktape_Options2ClientRequest "\xFF_Options2ClientRequest" +#define ILibDuktape_RawOptionsBuffer "\xFF_RawOptionsBuffer" #define ILibDuktape_Socket2AgentStash "\xFF_Socket2AgentStash" #define ILibDuktape_Socket2Agent "\xFF_Socket2Agent" #define ILibDuktape_Socket2AgentKey "\xFF_Socket2AgentKey" @@ -648,9 +649,6 @@ duk_ret_t ILibDuktape_HttpStream_http_endResponseSink(duk_context *ctx) duk_insert(ctx, -4); // [socket][imsg][httpstream][CR] ILibDuktape_DeleteReadOnlyProperty(ctx, -1, "socket"); - ILibDuktape_DeleteReadOnlyProperty(ctx, -2, ILibDuktape_HTTPStream2Socket); - ILibDuktape_DeleteReadOnlyProperty(ctx, -4, ILibDuktape_Socket2HttpStream); - duk_del_prop_string(ctx, -2, ILibDuktape_HTTP2PipedReadable); duk_prepare_method_call(ctx, -1, "removeAllListeners"); // [socket][imsg][httpstream][CR][remove][this] duk_pcall_method(ctx, 0); duk_pop(ctx); // [socket][imsg][httpstream][CR] @@ -658,6 +656,10 @@ duk_ret_t ILibDuktape_HttpStream_http_endResponseSink(duk_context *ctx) if (Duktape_GetBooleanProperty(ctx, -2, "connectionCloseSpecified", 0) != 0) { // We cant persist this connection, so close the socket. + ILibDuktape_DeleteReadOnlyProperty(ctx, -2, ILibDuktape_HTTPStream2Socket); + ILibDuktape_DeleteReadOnlyProperty(ctx, -4, ILibDuktape_Socket2HttpStream); + duk_del_prop_string(ctx, -2, ILibDuktape_HTTP2PipedReadable); + // Agent is already listening for the 'close' event, so it'll cleanup automatically duk_prepare_method_call(ctx, -2, "unpipe"); // [socket][imsg][httpstream][CR][unpipe][this] duk_pcall_method(ctx, 0); duk_pop(ctx); // [socket][imsg][httpstream][CR] @@ -877,7 +879,10 @@ duk_ret_t ILibDuktape_HttpStream_http_OnSocketReady(duk_context *ctx) duk_get_prop_string(ctx, -1, "pipe"); // [socket][clientRequest][HTTPStream][destination][Options][clientRequest][pipe] duk_swap_top(ctx, -2); // [socket][clientRequest][HTTPStream][destination][Options][pipe][this] duk_dup(ctx, -4); // [socket][clientRequest][HTTPStream][destination][Options][pipe][this][destination] - duk_call_method(ctx, 1); + duk_push_object(ctx); // [socket][clientRequest][HTTPStream][destination][Options][pipe][this][destination][options] + duk_push_false(ctx); duk_put_prop_string(ctx, -2, "end"); // [socket][clientRequest][HTTPStream][destination][Options][pipe][this][destination][options] + + duk_call_method(ctx, 2); return(0); } diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index cf3b4fa..d9d8dc6 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2322,7 +2322,7 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) duk_peval_string_noresult(ctx, "addCompressedModule('crc32-stream', Buffer.from('eJyNVNFu2jAUfY+Uf7jiBaiygNgbVTWxtNOiVVARuqpPk3FugrdgZ7bTFCH+fdchtKTdpPnF2Pfk3HOOrxhd+F6kyp0W+cbCZDwZQywtFhApXSrNrFDS93zvVnCUBlOoZIoa7AZhVjJOW1sJ4DtqQ2iYhGMYOECvLfWGl763UxVs2Q6kslAZJAZhIBMFAj5zLC0ICVxty0IwyRFqYTdNl5Yj9L3HlkGtLSMwI3hJp+wcBsw6tUBrY205HY3qug5ZozRUOh8VR5wZ3cbRzTy5+UBq3Rf3skBjQOPvSmiyud4BK0kMZ2uSWLAalAaWa6SaVU5srYUVMg/AqMzWTKPvpcJYLdaV7eR0kkZ+zwGUFJPQmyUQJz34PEviJPC9h3j1dXG/gofZcjmbr+KbBBZLiBbz63gVL+Z0+gKz+SN8i+fXASClRF3wudROPUkULkFMKa4EsdM+U0c5pkQuMsHJlMwrliPk6gm1JC9Qot4K417RkLjU9wqxFbYZAvPeETW5GLnwnpiGB4qjyerqFOKgT2aRbfvD8FS8dGjfyyrJHSdwqlsc0DxEy+jjhA99b398PUep0RKbxPqFfHAsurV//emWew2cwgvzgG8q+SuArKjMZtjFvvnULTeN4Q9eaY3SNT2eG1ERfCKdnNSdODvgIUyP5b9XL9/3aiQN3lYOQfecCcmKc0P/6eQf7K/Hw6lG8Z5bHp9ft86v4OVpKAWrKyS3GSsMtuDF+idyG6ZIcvFOKxoguxsQRQD9J1ZU2A9gDznacydDuiJIpaX7n+ikBYeOvgZCu7s6uMnZqrQqMKSBV9oa0rdvZ2ja7nAg6B/4IHJ3', 'base64'));"); // http-digest. Refer to /modules/http-digest.js for a human readable version - duk_peval_string_noresult(ctx, "addCompressedModule('http-digest', Buffer.from('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', 'base64'), '2021-08-09T11:56:31.000-07:00');"); + duk_peval_string_noresult(ctx, "addCompressedModule('http-digest', Buffer.from('eJzFGl1v2zjy3YD/A+uHlbxVlTi9PdzVmwJZN4vmrucc6vaCRRAEikTb3MiiVqLi+or89xt+SaRM2XFa7OkhlsiZ4cxwZjjDydGP/d6E5puCLJYMnRyP/o4uMoZTNKFFTouIEZr1e/3eBxLjrMQJqrIEF4gtMTrLoxh+1EyA/oOLEqDRSXiMfA4wUFOD4bjf29AKraINyihDVYmBAinRnKQY4S8xzhkiGYrpKk9JlMUYrQlbilUUjbDf+01RoHcsAuAIwHP4mptgKGKcWwTPkrH8zdHRer0OI8FpSIvFUSrhyqMPF5Pz6ez8FXDLMT5nKS5LVOA/KlKAmHcbFOXATBzdAYtptEa0QNGiwDDHKGd2XRBGskWASjpn66jA/V5CSlaQu4pZetKsgbwmAGgqytDgbIYuZgP0y9nsYhb0e1cXn95ffv6Ers4+fjybfro4n6HLj2hyOX138enicgpfv6Kz6W/onxfTdwHCoCVYBX/JC849sEi4BnEC6pphbC0/p5KdMscxmZMYhMoWVbTAaEEfcJGBLCjHxYqUfBdLYC7p91KyIkwYQbktESzy4xFXXr/3EBVCIUJbp1qNvgfi4mjlDcMrNTmWsKvkJxPsX+9+mmnIGH4Z9rnN9HvzKov56gj2L74/f8AZ+5UWoO0E2PUTssAl+whU4Ae0waen0QoP+72v0gjIHNlQYQpbgDNcTGiVMb9BQW/R8VAiKVz+cF6xWhEYrtm51YP+sAE28DRuDkjXGja8rZe7GduwfHN8jkAA4XgMPz+jqFhUK4AvwxRnC7Yco5cvyRB9RXmYV+XSr+evyc1wjB5tirfNqrYCMOxoyG1743fBBCgfGgw+Gu8OWYDj+t0JadEGaOvbwLD5vC3UC82abQpqsppBEPvRspQF312woLOKLd/jCGy29MmqBEeluTDkQC3UWAlXfATgYx07uNlwHPTiFGVVmm4bBgcHUb6CDUfp6o2ACiC4QezSHzSPQAD99QfN5aulTuE36zVQ4suFS8nvtXd1dfWKCwBiQwhi2LtpITF6Dy4IeDy+leDzzPcCb1hLUBtgRIrSwDUMDWKYpNJtwgIbFpFwYGd6qVNv2LJgrjIBrqwVnZ6ik6EN06LOnxICfbxUqNfHNyGjH+ga3DMqIQaEEC1X/nC4jecgxZ8Y0JAn91dujffGDak3MRRQIKPkYNT2zLaMDQ5wy4X0Bh53SotW8xGW1R2P+RCtRoE5rrT0Co22fdd87gD8voMnKa0wur1iCqgDxRQ4DjE1rebDIaYc/35iSnfaK6cEO1BQieSQtKZmfDlkVRPfT1iIFnslBZgDxQQMh4ySjn51SMdHv1W0ForxabxKvw1vVXBVIdkAwmmJt0IxF++Fr3BMEsOhiM+sKrKa50cdIHkMhEwgHxlI6oAIIT8tMn6yvUTeGw/+Gs6th9o4eVSWa1okimGBoelDthOWmyx+H8GxLQYhstGZ1LK3xF+8oR33xm0uT4CKXmmF2ZImNSMNA7W26sVPXIufPGXx5hxsbKTrLNRMvtZmJOW2lCdDhjUkeDFMpR587eL69X6u9xmK3rLpBL08RaPxt0jQ0GrYGv21xRPsSTJjUcH8vwXIOwaXa6NPppfTybm9ENf1n6KoxsTASYCU906em9r8TwcuQzedYxAIp5CAtpMMAqEwY6pW4CCoCiInTOMVU964ZXkqAutETHo03z/Id+ScsYQCFoSaONUgQJWUw3ImitSjwnDafWcO2NAFMIOk2kDQQGyr8HBjGQSxocZtqxl41n423L/QmlUpJVdca4inr4+1klqT1x5PP2lB/iuqP+9GlGs6W5dBFfnwy9e3E3BeeKuc329ybF7vh7eXd7/jmF28A2oDDvdKwg3GBpAsAI1qy99WPZn77fKIx6cR+uEHxDY5psa8PvKoWNsbdqe7WqwMr00pbklWMn4rYdEcWiXSXtZOOlgbCt7kies5YUY2zDew/1X77htksgDlnjq8zPHRzWOXiGxZ0DXY/UX2EKUkQf+OCiDKwGy8zrLMyZAyuh1W4hlWEmo8zzQXHZiaE9Kc5ehIOrCFBGcAL7TNIeVVxrUER4bwqSvKKfdE7rh1nBCICxE8a2OF2OYMFWJrBIIqbAVk69wy5837BqiPipH75I2jFKxM3E5EcOq1TjUZ2blF6OsZf29NxiHBRJrF42WV3Qdonlbl8um1GA9DUrPAHk54BNKGIy97UJTCT7JBYt7rTizBpV5ISnfVfI4LTswN2cFKrdqaACjlF/EagvpoLEVU7toubc1HwvGbR7/FUQdSh0hNgvIdRIjBMCPmX9vzgWQW3Nse10HpJXqK0J1bojdXWavDLvZIU5MQ9jbhZpz8sjnPEmfB/wSCjYr01REYltzZXVu6o5rp3qWDWRFCPpuZR/Nex3y4EoVfmhmSGPC7/amORkWFXcw8Bttjc5JFqRkU/m/RwKDCr6ZAhg59ysJQgOszgp+vxneY4DTa8Ltp3GVzTzFgvcmc/IsukxYCt42zW8rvHzfsdQ/29oOsrF3um+uB9VlBzDib62m9u+0jTV8XyiRJHYvdGVGC51GVMsdNSmcKs3WxyR/XrYa8qFFJmWMFLkeTmtTJCKT5RYk/F0Ty7lisOdA7bLubG5Xi7uWGL/0Ewo/mrqicSFzFQ54XimbM+Yowxk8g4JlXA4HgueVKKqMXCL6nazBvJxQuClrsBqnyRQG1ym4gOBoZyao9UIysMK2Yt2Wm6iZZ7p91uS5KxHae/9asQJAjh9fhc3cWH4pEs9FUYKXlraS8+Tg6Mt/RhLfMOJ9rDOaRoShJkNEUQRldu3FdHRTZxDCsSGYVdsMBFr1a4gyVdIXvKITyJaX3Japy2SAqeedUpfJxSmCk7jcBi5lqrXIc0WXkVwkSEan6wcZqbVWTNTe+pjNtg++tLdZhERhrWlRNqdtsie9BGv1BtQ9hT5qjED/I3hT3grsovu/eXG41EppH0tqEudEYw9L4W4O1JbfGte22hpMiIpnnuAE1WbEPhnZrVPZFwWyP9/dxRKP0YUaye7tNKob8p6cJsmdVrHiUulboYWfbVD9zWsim1unxmPy81TiVfVNB1tU63ZVnNFZhNk5bU4Fk2ZlKOcbaUokGaqt7ajFht0JVH1QQaS9p3qvbvmnZ+lZ8aWyZ9yG77ReMsKQphkp8TkcNBQR1OatKmE5AmreIX1aJhqYcn8Cwq1/YAuGm9pfj0dOMzTglW/tUS3mrYBxq1R1fQO/uF7cJW5HPWlE1lF2HuaWwf8wup6FMGch8I64YA9UfHg0PRu/kbxfFLm25FKlitRVKOxY9ZCk71LagDqHzdDPeYUzbavZIBiaBDjRuN2WZsLYt/fBaQ+R34Bw7moIuVfGYpZOpoL7gn0ckFYctRaso2yB+hJTOxNd8dnUt+dOdbO/n0NhDsXPfwIqrGnG6lus/irYCe5NlPp+EymWfT6BJYp9Pw5XiHkhCpRRGf9B8eEBXAffpjtfp2l1FqmN33SXxvmsIc9G6GNXXA+akvK54Xs3dJVknB3/GLeJOFdTXFC7W5R3WDuZ33aU5lzXugnYawgG3JN3/aeDWmENTz4pR7dTLlHvbLxxF31beom8A7Nm2Zxjr2sI5Sg/r6kXVBu3ttWGcZUNzRbNFY3u7rEsEq20oZnX7sN9b0aSCMxh/yWnBStW1sJqJIvL8D/BP8J8=', 'base64'), '2021-09-29T19:36:45.000-07:00');"); // Clipboard. Refer to /modules/clipboard.js for a human readable version duk_peval_string_noresult(ctx, "addCompressedModule('clipboard', Buffer.from('eJztPWtz2ziS31OV/4BR7S2phJZtOZPNRuvZUmzFqxu/zpKTTCVTOpqEJMYUySMpSx6P77dfN8AHSIIPOfbt1G5YlbFENPqF7ga6AWG2Xzx/duB6t741m4eku7P7VzJ0QmqTA9f3XF8PLdd5/uz5s2PLoE5ATbJ0TOqTcE5J39MN+BO1aOQD9QOAJt3ODlERoBU1tdq9589u3SVZ6LfEcUOyDChgsAIytWxK6NqgXkgshxjuwrMt3TEoWVnhnFGJcHSeP/slwuBehToA6wDuwbepCEb0ELkl8MzD0Hu7vb1arTo647Tj+rNtm8MF28fDg8HpaLAF3GKPS8emQUB8+j9Lywcxr26J7gEzhn4FLNr6irg+0Wc+hbbQRWZXvhVazkwjgTsNV7pPnz8zrSD0ratlmNFTzBrIKwKApnSHtPojMhy1yLv+aDjSnj/7OBz/4+xyTD72Ly76p+PhYETOLsjB2enhcDw8O4Vv70n/9Bfy8/D0UCMUtARU6NrzkXtg0UINUhPUNaI0Q37qcnYCjxrW1DJAKGe21GeUzNwb6jsgC/Gov7ACHMUAmDOfP7OthRUyIwiKEgGRF9uovBvdJ57vQldK9mMdqkr0SsHh50B95/bcd4FKeDu+9RB4p8dbDpa+T51wbC3Et6euI37FvieuSS+oZ+uG2DKiNjWQzQObwtd90v1rvuXUDa3pLTTt7eabLoBjGoTYFiP81J+cXwxP+he/wNu4w8H7yXjwaZx9c3k6PDg7HMQNe4mwa8O2vDGzn31yd8/eT5cOo0gcUOoN7ZvmAdg8Dh41QbKlTVVHX9D282d33IoR0Y1uLxHHjIb/ORKhejmYNQApSvQ29G/5hwgTh4ygBFSHephFh481VTnsTzvt9K2AKYNNdeiKMDz81YvdnZ2ddrsTuiMwd2emtjsBmGWoKkRpd766lqMqY0Wkl0HX0ojSIi/jFy9JS2n1YrfG5z79SO2A1jOYKEXoHf0x9NCYq7Rdrquk833MAyr8N8sTbd1IhnELXJzqCxDUgL8hjQfY9dVYYujbuVpOpxQt1VnatvDeBd2YeqgrGkmMRTWK7MEIYQhN8HBE5YOVASbv2IeO4Togv/rZ+LVdVFCteitRCo0akeK/F9VBHZMbT8aoA2Y+gDzVWGpUypUe0NevFLGHT9GLW+byeuJRwDfhGCaOC0OwtEPVCNca+dLSJY7HbA4dgVmcFgs0hSjG22J2eHNCPmuq7d4X+NeKeLKmRAWeOjZ1ZjCh/UR2X+/t7BRHc3ubnIzIBytY6jYZhUvTcslchyAMM946sH6DKSiJxKKJQjxeoB1GrAlK5ppQjDnAvJgokWixH24lfqi0oUkB0OGxdXVCF65/O+nbtmugO2M3FSjE/L8kuwxcIzsaOb08Pub/BZkd0cOQLyuKzvG71RznetUifyMpwqrY4hNjvnSuAQ3CB8srLqJqaYAbGHmNMSYXQlDolxCPlAVdGN7tJFDrJef/LC5WXuAtYkUCt7CJcwTfWxyUfU+VozBF5JmykCURUu5qSbzhHyJ+IfTF/LYymBNRcdwOl9eh7tGJZD4ZrLnNt5TUupH9OsUkFl0UKiE9heVQvYYz/SOBF4y3DixcXD8M0EUQ4F42QQoTnhaAAdgPmB03CAtNg4H4ggcuSWTKhwphRmwSJ8if/0xULvP+PoZ38vvvJP4+1SE2tx8/lDQS7OkDDSOdfu3+IeLOy3+5qJMJI+/Y6B5SA9bYEDfUpRNYMwdyFRzcF+1aqTh7mWGEdxujif5l8ZRHIebVy2A+mdnuFfi2e/UVlvXo0u0etkFgmEAq4kVOz319axeUm7h7i0MGK92bhK4XgXT5W4Zb7JsNpSVATyKlodv2ZEHDuWtyKsAiYS2c6X9OqIas1sNV9AXVTQhXZjY+W2bkkXGkQxAezmSrWqLCWBkwgXUgxwshaV3g2lZZWc5eV6n2W93AKUNclS8D6m9Bts8yWpA1yjIhH+kz2LzPAHWOJA3EYv4jocu6oYSe7gd0CLg5gs87v3ZGnPDQzPvmvdQVK9fajEapXLDoDlybXlqmKlto8z8pflHhiBcGJJ/ioCqwDYYOJx3pmJi6D8OilLajzV0FJgOQj6ptOcu1gtNcmkhB0nzl6r4JYrEMWjLFgQ0ufUiLsqbZ8dH+2jnzlUrNo7xlm1E1wqIB5ugkiEfsLSrmvtfAMLkI5Ya5tpypK47dwnWs0PW38D3ICNHp0xA+grbzZpLjEHKkG8blp/7l+B9nF8PxL285+s5aX0JM8K3wViOHw9H5cT9pQue09duMMPdiMp2ujzCLj2o2app7wgpJA4CvbaDMkrqJz7QF/+0lL76yF197aVIXjRNMoAYqDdrZgiXXutCDkGWPiXpGhm954YHrYJGP+ui0LI1Wc9rI0+GYOmIZKpSDSDNssyZzjvAK4oT+Mh8/MpCoJrUwpgyEriH4Zhy1RBpkFYGzxQCYncu5RUP9QcZyfRzLs/9VVQa+76J56CYmvoJvlkc0fExq05BmEXKRGgg9WFNjGdJoydlixUUdw3almfTkIYTHhE44p05i0+pN+45j7ASs7tDu3acKVmn7LoqnHYriw4te7PrRyAHrrRz3LCBFk2OkkftMxS+eJT+Cm1IVDVAjzSbLXHEnWwT6Z86W2cnyp+9T5R91qszNlMz6vk+UG06UNWtTHDoeeHkcq5lQHmfmy6HrJIESX1bAlU8soDYUlIduHiQjeaAlE9fFRpj4s/FcRlAy6QLOONba7gyny2o0D50bImYlXADNu9C/vZN5FfJzH28Q3FUMFJtGYJq4rwnId/l5JD+RCDFOFJvhZ07by1pkXaxoZI/xVkJELLQW1F2G9cHcwL22MYeWYugV+0jAsnsgEk2U9wtoGNNPrSqg9rSeeYSKERbWYxKgEi41ghWhHY0x2JaFjsJCAEZnwsL1BBcnIV2HbN2QWwdU7OJtPMGJW11EtteFqy+24KP1q5qUyQdEbCTEwllm7wxfTCJLhn4UnPy9ZVO1fKbTyGdlbeMnLDqB+NFOLn4z2CtX+VWD6LK02BSlEZgT4kjPZ8GBc6O202iTcCZNIdLWIDRhVQh/fL41WGwq2cGL0yfsiaU5oRbck7EB2MCuywhh0yMRks4F8tJMhDfRwA/IWcPMidlXDkEH+FqkKbtgq/jUbz5mcq0Yd6S1sh3HRHzRtrMeCiuxvIdm3fMJ8uWSqNBrwC52/f9jVBaRSiJAMfqodC3Zy07DD7RuEIA+7e5WhJ8JNAvbKz/A1wrSCiJLjv/gYZmDOOiQE92xvKXNtkzy5VF5qsC2c0qX6aVGXW0EFWrJqCZWz9FJlXZmi1z6jYVyDNfnxZM8xcDO4no+gc9h6Ez41HleUZPJd8kk6ljhc6pLHQCwUa0W9bKaQwYO3MCIdz59xC/n1praiAtz0SgR0Ej0PTAgOcPUtPNBtzPrr/jhzpIRtnNwPDwfHsZU8Eyd7/RDd1GgcnQSrfM/6L6Fp4VUBfu+O+tfHCptjRS2m8oovj8ZP5Tg5fj9m8lofDE8PdqI5PnF2YOF/DQaHE8O++P+RhSHpwcXD6WIfTcidnF2Nv44PI2pXbhu+NFyTHdVaypNh6z/80AgwBke4Rk+WkKogk22ObqT8MJOdGrkR/aOmXz0py21YcbA6NYxCiSl6uL8us4N5KTJObpG3HLHkLcxE5Y3cVMr6cbVqImnCEuZLpexqWsf0oBlgK4/uMmlnrkmXM3qppm+VWO9OdGhxOXiivo5dligwcUrTgKQ4rxlteZiYtyQv2IYlnR6KOq4arJPsjI8EB+uRSOpM8vRqdkuIpSEd3zYymAAHBVDwO5O95VMi/hEBwXYAJ1Dvo0LZs6yOCwSNipYwYchPIWpnEnIrC+DVgNmy3jCB7LzTwNQlE+nKnjyKzyOwc9oqLy8fQlRcK97PIBsBpL/3HnXEn5reI7VyDLNRI3nroXxVpop53teWWHw0L7Bbw/tGeqW/dC+/CRQWe/q/myMj2g0O8RHnPPjXBm6qmIeDPvrH3/c46E8d4ZaY9ktqlsDxWlMBVokTD3jMqosmeIIIrNrd3gCWadGpob3eNIg271RPwgFoe/eRvNec9U1FNKnC/eGCpF4Kp2lxecKrOC6AuZe3iR5XQjd4raGRjLbTbn8ojbz4/kC/hZCDdfhk6d/T1ud+tcpTuEHdqyNsT/Xg/mBa1KVH7ORFa2etFxVXioSy+9G5nxiRVHqsdBNsITsLPHYYYInfqd6RVPg21GNhkfZvrKc7WCu4GjAn8wJdGNeLK+l776prpai/3a9M3cq23WKtwzL82POhuV0VmzLWfECsqWvXeKBi265+Gurhe6YRMTQtPomQ00RaYx7UYo33/V3MvOpR1qpx3gFf2mR39lhuRZEHKJ8+eIoRPlvBV7qq2uy9R4/K63iCKRE7pSqVngFalWt/d2e9bfT972XL612XYdajPjwY3Z/srTQvaZOoLXw9wFNOuIhvX1+9hS7E17iUDmaz7u/tl92myHCEwQcDTtAvavttvf3kQ0wwXoie2iNTcgY82sRW0TrNfLYhMW4+35kBa1a9ZOmQwCPB54VTknrP4IWrCRi6Rqpr1b4SoDWvfLFwdL6FydvnSvdCgf5bSf09Wxoqimwx4Hh2rJtNTlWkUHRhsllNDz6eXh8nGFV8MhoVzf9vdrnjAf+Gk+vD905EBBnq/YCjbLNvIpiqZebRABWlE8j3XRnLqYpQhR3EJKFhHTiS4YVllnVAvNDXo5ZhRB1978NtlyaKK9mByZRUJkmNtwewVUnrjdZfbqw5nyEonw49yEF+ENU5GNFSFbaJd60YeX9iY9fToBTrPisawrv36v9JdX+PMp/21r/v18xnKaV7bOVUyjTasKPxB+jLl1LbuNq+mOVxZuM3vei+PeieDNW8PnWoniwsthZpqaV8YeXwQ0drCN7vcTb6h6sV5Td4xS6qyojd0GvXPOWrU2Iu3KCirP0sqeuFFnkNLrT4ht4Xengq2QZ4H0neAARr/5YEFbNqK+54oM2R2+kNgdvour6CH+Rur9P3pC/k790yVuy97qJQtg+gT/xuZSuz6lIcCYW8gpM5E0bCCRvusxomhNLCnYNiL0pEHu1GTEvqvHX03r9Kk9rr7sZrVD3ZzSsp/Tj64JUbzakxO93qaHzl25Boteb0UkjcA2pbkF5u7Hy6onRm7LowxLFJPzk9+QaykFvGth3wsNerLTkze4mSgNi9fadoE6cKXmzkTMBsRqbSym9KVDaxJOQUpXNJVgTL8oodBM6tR6bYE78KJVpEz/CqQNzb2lkle7oYbrayKLFkJps/nlclMS4WQYsGqdg+e1efj65GPzX5WA0Prt4y0q4jSikFw7M6Vqp3T+MOE/st5bzFLKK89HgeHCAt24lnNdTeBjn3Blq2Y7Aqnge9y+OBuOE4RrED+QWHKqeVwSq5HR4Mkj5rEIp4bKeTywXFBUAi1X0xtKUumI1Kz41a8b4yUmMmTeJ7xqbuj6XPvbmhnvsctzplMfTJKmXxS1xoCo0FJXVlBuewc11Z0aT0w8CTxFGOV9SniT8QMzU8lfAaYn60k+dCbvlZIvsbsQ9S0JkPEsrJLJHptoy90gAMy5ST6fkzIH4ZDfuyp4HmrBz7UD6Qt67/kIPY2NulMIw1gTB85rJLpnw5r8mWO+bxIKovuKYLNvcwDB3Wb2I3jxGivbop0VsNwkWhd8Yrcp/EhBfBJMWnpML7oql68kRdahvGSe6H8x1O3PXGh7t2OuKi5BTdmcTuOj6lp/82Ot2TDvb65r6DrUr+sUAmZ7JS97hhF+BohyxG1/YLULNQI9d47oZ5KVjx7AcOpInC3tguwE9KKTyUthhkABy9+nf6JaNi7bqfkc0TDoextl3KfSZR50sQxngTLMq1PdwvoxgyhlVs/dd8vn0h30iudEOT2lE+PIC5LHkdkDneaw5zIkhJ1cPJgOZDrI6zztRBB7NDvtkazcHwJ0hBvtombSLM3YOKkeLm0mWWoPfkrMfrj7Fno8X/ZolDtTpllnGdCJ52daWJ0SRvLFnzFs4CPkk/Hvx0cPCz5684ibkqnIT8uhkcDI5Ofsw6L87xqrnznpnZ6crhKHsVa7fw19F+HuU4DdYeOHtEwfKYugrBR3JYmo6SouwLLvGheYdGJ9J0w0IIkyuxWjEhkfNGKTGCPBIFLM57+jL0GWHZ/nNfoLRNIx0cegqIuLtjKhQpGJr0bhTUshSu+QF7hfHV+Wxy/cyy9Sc+RQDYd2MI7Rm7ULNteaHKTdzaGSeH+ViwBJvKlvohhukYYMdraBi7EjPPcR74TQI9BndunLX7Hf+KT9pbzkVyfKrBvtMxN5OQh7f6ygcAkzRssJ/dMWAUO/P3vkBxiOGzF4ZHNs4iYBjEQRgcZXL6fLLBqro2pvQteV0z9ilfh2TTi0nTTGzKLToEGFLy07ZklRnhhuIhaM3NZ3wSX4FzU+DtNmGJB9V8XWvbLmfXKjy7YdYxafkJ+OP93PxUoLpYbfVHEKIFfDjXtHZTOWOn74jf+riSULpabgiWunhuPwo5EWOfkuOC8dWa/MdSbmBoWbArCaRXYGu2L2kbwsKj6mXKqw0UY3Np1Ie8vdSim/53VASsjkTzLBW9OP4PLHgyZlDU1NumVYQBqxUomwvA38b72+1mZUyFSnt8jW7NC6kZ6p6VdBxdCj+Mj/XbbM4kY6nXJqszppfTeC7K4Lro3jtPVp6SBn/nw/vRoex40euUnYsszhE0S1SVbE2O8PVRtvsVCWxD+An1zN3MTMmAdk3vfIu+cupxc75tiKazA1q0DXzvRz8gosqfu39H6qwIO0=', 'base64'), '2021-08-31T11:05:47.000-07:00');"); diff --git a/microscript/ILibDuktape_ReadableStream.c b/microscript/ILibDuktape_ReadableStream.c index 0a6342b..7b48d28 100644 --- a/microscript/ILibDuktape_ReadableStream.c +++ b/microscript/ILibDuktape_ReadableStream.c @@ -972,6 +972,38 @@ duk_ret_t ILibDuktape_ReadableStream__pipedStreams(duk_context *ctx) duk_get_prop_string(ctx, -1, ILibDuktape_readableStream_PipeArray); // [readable][array] return(1); } +duk_ret_t ILibDuktape_ReadableStream_getBufferedWrites(duk_context *ctx) +{ + ILibDuktape_readableStream *rs; + duk_push_this(ctx); // [stream] + rs = (ILibDuktape_readableStream*)Duktape_GetBufferProperty(ctx, -1, ILibDuktape_readableStream_RSPTRS); + if (rs == NULL) { return(ILibDuktape_Error(ctx, "Internal Error, RS NULL")); } + ILibDuktape_readableStream_bufferedData *buffered = rs->paused_data; + if (rs->paused_data == NULL) { return(ILibDuktape_Error(ctx, "No Buffered Data")); } + + duk_eval_string(ctx, "Buffer.concat"); // [concat] + duk_push_array(ctx); // [concat][list] + + while (buffered!=NULL) + { + duk_push_external_buffer(ctx); // [concat][list][extbuff] + duk_config_buffer(ctx, -1, buffered->buffer, buffered->bufferLen); + duk_push_buffer_object(ctx, -1, 0, buffered->bufferLen, DUK_BUFOBJ_NODEJS_BUFFER); + duk_remove(ctx, -2); // [concat][list][buffer] + duk_array_push(ctx, -2); // [concat][list] + buffered = buffered->Next; + } + + duk_call(ctx, 1); // [buffer] + + while ((buffered = rs->paused_data)) + { + rs->paused_data = buffered->Next; + free(buffered); + } + + return(1); +} ILibDuktape_readableStream* ILibDuktape_ReadableStream_InitEx(duk_context *ctx, ILibDuktape_readableStream_PauseResumeHandler OnPause, ILibDuktape_readableStream_PauseResumeHandler OnResume, ILibDuktape_readableStream_UnShiftHandler OnUnshift, void *user) { ILibDuktape_readableStream *retVal; @@ -1007,5 +1039,6 @@ ILibDuktape_readableStream* ILibDuktape_ReadableStream_InitEx(duk_context *ctx, ILibDuktape_CreateInstanceMethod(ctx, "isPaused", ILibDuktape_readableStream_isPaused, 0); ILibDuktape_CreateInstanceMethod(ctx, "unshift", ILibDuktape_ReadableStream_unshift, 1); ILibDuktape_CreateEventWithGetter(ctx, "_pipedStreams", ILibDuktape_ReadableStream__pipedStreams); + ILibDuktape_CreateInstanceMethod(ctx, "_getBufferedWrites", ILibDuktape_ReadableStream_getBufferedWrites, 0); return retVal; } diff --git a/microscript/ILibDuktape_WritableStream.c b/microscript/ILibDuktape_WritableStream.c index 1cc381d..a44ea0d 100644 --- a/microscript/ILibDuktape_WritableStream.c +++ b/microscript/ILibDuktape_WritableStream.c @@ -312,7 +312,7 @@ duk_ret_t ILibDuktape_WritableStream_PipeSink(duk_context *ctx) duk_dup(ctx, 0); duk_push_this(ctx); - if (g_displayStreamPipeMessages) { printf("PIPE: [%s] => [%s:%d]\n", Duktape_GetStringPropertyValue(ctx, -2, ILibDuktape_OBJID, "unknown"), Duktape_GetStringPropertyValue(ctx, -1, ILibDuktape_OBJID, "unknown"), ILibDuktape_GetReferenceCount(ctx, -1)); } + if (g_displayStreamPipeMessages) { printf("PIPE: [%s/%p] => [%s:%d]\n", Duktape_GetStringPropertyValue(ctx, -2, ILibDuktape_OBJID, "unknown"), (void*)ws, Duktape_GetStringPropertyValue(ctx, -1, ILibDuktape_OBJID, "unknown"), ILibDuktape_GetReferenceCount(ctx, -1)); } return(0); } duk_ret_t ILibDuktape_WritableStream_Ended(duk_context *ctx) diff --git a/modules/http-digest.js b/modules/http-digest.js index e09e7f0..ff2afc3 100644 --- a/modules/http-digest.js +++ b/modules/http-digest.js @@ -158,7 +158,6 @@ function http_digest_instance(options) { this._buffered = Buffer.concat([this._buffered, chunk], this._buffered.length + chunk.length); } - if (this._request) { if (this.writeCalledByEnd()) @@ -170,6 +169,7 @@ function http_digest_instance(options) this._request.write(chunk); } } + if (flush != null) { flush(); } return (true); }, @@ -177,7 +177,14 @@ function http_digest_instance(options) { if (this._ended) { throw ('Stream already ended'); } this._ended = true; - if (this._request && !this.writeCalledByEnd()) { this._request.end(); } + if (!(this.options && this.options.delayWrite)) + { + if (this._request && !this.writeCalledByEnd()) { this._request.end(); } + } + else + { + this._request.end(); + } if (flush != null) { flush(); } } }); @@ -235,15 +242,19 @@ function http_digest_instance(options) ret._request.once('response', function (imsg) { + console.info1('response status code => ' + imsg.statusCode); if (imsg.statusCode == 401) { var callend = this.digRequest._request._callend; var auth = generateAuthHeaders(imsg, this.digRequest.options, this.digRequest._digest); - + console.info1(JSON.stringify(auth, null, 1)); + console.info1(JSON.stringify(this.digRequest.options, null, 1)); this.digRequest._request = this.digRequest._digest.http.request(this.digRequest.options); this.digRequest._request.digRequest = this.digRequest; this.digRequest._request.once('response', function (imsg) { + console.info1('inner response status code => ' + imsg.statusCode); + switch(imsg.statusCode) { case 401: @@ -259,14 +270,23 @@ function http_digest_instance(options) checkEventForwarding(this.digRequest, 'continue'); checkEventForwarding(this.digRequest, 'timeout'); checkEventForwarding(this.digRequest, 'drain'); + + if (callend) { this.digRequest._request.end(); } else { - if (this.digRequest._buffered) { this.digRequest._request.write(this.digRequest._buffered); } - if (this.digRequest._ended) { this.digRequest._request.end(); } + if (this.digRequest._buffered && this.digRequest._ended) + { + this.digRequest._request.end(this.digRequest._buffered); + } + else + { + if (this.digRequest._buffered) { this.digRequest._request.write(this.digRequest._buffered); } + if (this.digRequest._ended) { this.digRequest._request.end(); } + } } } else