Modules: improved handling of results of async handlers.

Previously, r.setReturnValue() had to be used when returning a value from async js_set handler.

async function hash(r) {
    let hash = await crypto.subtle.digest('SHA-512', r.headersIn.host);
    r.setReturnValue(Buffer.from(hash).toString('hex'));
}

Now r.setReturnValue() is not needed:

async function hash(r) {
    let hash = await crypto.subtle.digest('SHA-512', r.headersIn.host);
    return Buffer.from(hash).toString('hex');
}

In addition, infinite microtask loops detection is added.

Author: VadimZhestikov

nginx/ngx_js.c

@@ -12,6 +12,9 @@
 #include "ngx_js.h"
 
 
+#define NGX_MAX_JOB_ITERATIONS 0x1000
+
+
 typedef struct {
     ngx_queue_t          labels;
 } ngx_js_console_t;
@@ -691,6 +694,7 @@ ngx_engine_njs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
     njs_int_t        ret;
     njs_str_t        name;
     ngx_str_t        exception;
+    ngx_uint_t       job_count = 0;
     njs_function_t  *func;
 
     name.start = fname->data;
@@ -729,6 +733,33 @@ ngx_engine_njs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
 
             break;
         }
+
+        job_count++;
+        if (job_count >= NGX_MAX_JOB_ITERATIONS) {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
+                          "js job queue processing limit exceeded (%ui iterations), "
+                          "possible infinite loop in microtasks", NGX_MAX_JOB_ITERATIONS);
+            return NGX_ERROR;
+        }
+    }
+
+    njs_value_t *val = njs_value_arg(&ctx->retval);
+    if (njs_value_is_promise(val)) {
+        njs_promise_type_t  state = njs_promise_state(val);
+
+        if (state == NJS_PROMISE_FULFILL) {
+            njs_value_assign(val, njs_promise_result(val));
+
+        } else if (state == NJS_PROMISE_REJECTED) {
+            njs_vm_throw(vm, njs_promise_result(val));
+
+        } else if (state == NJS_PROMISE_PENDING &&
+                   njs_rbtree_is_empty(&ctx->waiting_events))
+        {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0, 
+                          "js promise pending, no jobs, no waiting_events");
+            return NGX_ERROR;
+        }
     }
 
     return njs_rbtree_is_empty(&ctx->waiting_events) ? NGX_OK : NGX_AGAIN;
@@ -754,8 +785,9 @@ ngx_engine_njs_string(ngx_engine_t *e, njs_opaque_value_t *value,
 {
     ngx_int_t  rc;
     njs_str_t  s;
+    njs_value_t *val = njs_value_arg(value);
 
-    rc = ngx_js_string(e->u.njs.vm, njs_value_arg(value), &s);
+    rc = ngx_js_string(e->u.njs.vm, val, &s);
 
     str->data = s.start;
     str->len = s.length;
@@ -1032,6 +1064,7 @@ ngx_engine_qjs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
     ngx_str_t   exception;
     JSRuntime  *rt;
     JSContext  *cx, *cx1;
+    ngx_uint_t  job_count = 0;
 
     cx = ctx->engine->u.qjs.ctx;
 
@@ -1074,6 +1107,37 @@ ngx_engine_qjs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
 
             break;
         }
+
+        job_count++;
+        if (job_count >= NGX_MAX_JOB_ITERATIONS) {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
+                          "js job queue processing limit exceeded (%ui iterations), "
+                          "possible infinite loop in microtasks", NGX_MAX_JOB_ITERATIONS);
+            return NGX_ERROR;
+        }
+    }
+
+    JSValue retval = ngx_qjs_arg(ctx->retval);
+    if (JS_IsObject(retval)) {
+        JSPromiseStateEnum state = JS_PromiseState(cx, retval);
+
+        if (state == JS_PROMISE_FULFILLED) {
+            JSValue result = JS_PromiseResult(cx, retval);
+            JS_FreeValue(cx, ngx_qjs_arg(ctx->retval));
+            ngx_qjs_arg(ctx->retval) = result;
+
+        } else if (state == JS_PROMISE_REJECTED) {
+            JSValue rejection = JS_PromiseResult(cx, retval);
+            JS_FreeValue(cx, ngx_qjs_arg(ctx->retval));
+            ngx_qjs_arg(ctx->retval) = JS_Throw(cx, rejection);
+
+        } else if (state == JS_PROMISE_PENDING &&
+                   njs_rbtree_is_empty(&ctx->waiting_events))
+        {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0, 
+                          "js promise pending, no jobs, no waiting_events");
+            return NGX_ERROR;
+        }
     }
 
     return njs_rbtree_is_empty(&ctx->waiting_events) ? NGX_OK : NGX_AGAIN;
@@ -1098,7 +1162,9 @@ static ngx_int_t
 ngx_engine_qjs_string(ngx_engine_t *e, njs_opaque_value_t *value,
     ngx_str_t *str)
 {
-    return ngx_qjs_dump_obj(e, ngx_qjs_arg(*value), str);
+    JSValue val = ngx_qjs_arg(*value);
+
+    return ngx_qjs_dump_obj(e, val, str);
 }
 
 

nginx/t/js_async.t

@@ -35,9 +35,10 @@ events {
 http {
     %%TEST_GLOBALS_HTTP%%
 
-    js_set $test_async      test.set_timeout;
-    js_set $context_var     test.context_var;
-    js_set $test_set_rv_var test.set_rv_var;
+    js_set $test_async       test.set_timeout;
+    js_set $context_var      test.context_var;
+    js_set $test_set_rv_var  test.set_rv_var;
+    js_set $test_promise_var test.set_promise_var;
 
     js_import test.js;
 
@@ -85,6 +86,10 @@ http {
             return 200 $test_set_rv_var;
         }
 
+        location /promise_var {
+            return 200 $test_promise_var;
+        }
+
         location /await_reject {
             js_content test.await_reject;
         }
@@ -198,6 +203,13 @@ $t->write_file('test.js', <<EOF);
         r.setReturnValue(`retval: \${a1 + a2}`);
     }
 
+    async function set_promise_var(r) {
+        const a1 = await pr(10);
+        const a2 = await pr(20);
+
+        return `retval: \${a1 + a2}`;
+    }
+
     async function timeout(ms) {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
@@ -213,11 +225,11 @@ $t->write_file('test.js', <<EOF);
 
     export default {njs:test_njs, set_timeout, set_timeout_data,
                     set_timeout_many, context_var, shared_ctx, limit_rate,
-                    async_content, set_rv_var, await_reject};
+                    async_content, set_rv_var, set_promise_var, await_reject};
 
 EOF
 
-$t->try_run('no njs available')->plan(10);
+$t->try_run('no njs available')->plan(11);
 
 ###############################################################################
 
@@ -229,6 +241,7 @@ like(http_get('/limit_rate'), qr/A{50}/, 'limit_rate');
 
 like(http_get('/async_content'), qr/retval: AB/, 'async content');
 like(http_get('/set_rv_var'), qr/retval: 30/, 'set return value variable');
+like(http_get('/promise_var'), qr/retval: 30/, 'fulfilled promise variable');
 
 http_get('/async_var');
 http_get('/await_reject');

nginx/t/js_promise_infinite_loop_protection.t

@@ -0,0 +1,146 @@
+#!/usr/bin/perl
+
+# (C) Test for infinite loop protection in microtask queue processing
+
+# Tests for proper handling of infinite microtask loops similar to Node.js protection.
+
+###############################################################################
+
+use warnings;
+use strict;
+
+use Test::More;
+
+BEGIN { use FindBin; chdir($FindBin::Bin); }
+
+use lib 'lib';
+use Test::Nginx;
+
+###############################################################################
+
+select STDERR; $| = 1;
+select STDOUT; $| = 1;
+
+my $t = Test::Nginx->new()->has(qw/http rewrite/)
+	->write_file_expand('nginx.conf', <<'EOF');
+
+%%TEST_GLOBALS%%
+
+daemon off;
+
+events {
+}
+
+http {
+    %%TEST_GLOBALS_HTTP%%
+
+    js_import test.js;
+
+    server {
+        listen       127.0.0.1:8080;
+        server_name  localhost;
+
+        location /njs {
+            js_content test.njs;
+        }
+
+        location /infinite_microtasks {
+            js_content test.infinite_microtasks;
+        }
+
+        location /recursive_promises {
+            js_content test.recursive_promises;
+        }
+
+        location /normal_promise_chain {
+            js_content test.normal_promise_chain;
+        }
+
+    }
+}
+
+EOF
+
+$t->write_file('test.js', <<'EOF');
+    function test_njs(r) {
+        r.return(200, njs.version);
+    }
+
+    function infinite_microtasks(r) {
+        // Create an infinite microtask loop - should trigger protection limit
+        function infiniteLoop() {
+            return Promise.resolve().then(() => {
+                // Recursively create more microtasks
+                return infiniteLoop();
+            });
+        }
+        
+        return infiniteLoop();
+    }
+
+    function recursive_promises(r) {
+        // Another variation of infinite microtask generation
+        let count = 0;
+        function createPromise() {
+            return new Promise((resolve) => {
+                resolve();
+            }).then(() => {
+                count++;
+                // Keep creating more promises indefinitely
+                return createPromise();
+            });
+        }
+        
+        return createPromise();
+    }
+
+    function normal_promise_chain(r) {
+        // Normal promise chain that should complete without hitting the limit
+        let result = Promise.resolve(1);
+        
+        // Create a reasonable chain of 50 promises (well under the 1000 limit)
+        for (let i = 0; i < 50; i++) {
+            result = result.then((value) => value + 1);
+        }
+        
+        return result.then((finalValue) => {
+            r.return(200, "completed with value: " + finalValue);
+        });
+    }
+
+    export default {njs: test_njs, infinite_microtasks, recursive_promises, normal_promise_chain};
+
+EOF
+
+$t->try_run('no njs available')->plan(6);
+
+###############################################################################
+
+# Test basic functionality
+like(http_get('/njs'), qr/\d+\.\d+\.\d+/, 'njs version');
+
+# Test normal promise chain (should work - under the limit)
+like(http_get('/normal_promise_chain'), qr/completed with value: 51/, 'normal promise chain completes');
+
+# Test infinite microtasks scenario - should trigger protection limit
+my $infinite_response = http_get('/infinite_microtasks');
+like($infinite_response, qr/HTTP\/1\.[01] 500|Internal Server Error/, 'infinite microtasks causes error');
+
+# Test recursive promises scenario - should also trigger protection limit  
+my $recursive_response = http_get('/recursive_promises');
+like($recursive_response, qr/HTTP\/1\.[01] 500|Internal Server Error/, 'recursive promises causes error');
+
+$t->stop();
+
+# Check error log for the specific infinite loop protection messages
+my $error_log = $t->read_file('error.log');
+
+# Should have error messages for job queue limit exceeded
+ok(index($error_log, 'js job queue processing limit exceeded') > 0, 
+   'job queue limit exceeded message logged');
+
+# Should mention possible infinite loop
+ok(index($error_log, 'possible infinite loop in microtasks') > 0, 
+   'infinite loop warning message logged');
+
+###############################################################################