fix(node:dns): fix the crash. (oven-sh#5200)

Author: Hanaasagi

src/bun.js/api/bun/dns_resolver.zig

@@ -1977,11 +1977,6 @@ pub const DNSResolver = struct {
             return .zero;
         };
 
-        if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveSoa", "hostname", "non-empty string");
-            return .zero;
-        }
-
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
 
         var vm = globalThis.bunVM();
@@ -2039,11 +2034,6 @@ pub const DNSResolver = struct {
             return .zero;
         };
 
-        if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveNs", "hostname", "non-empty string");
-            return .zero;
-        }
-
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
 
         var vm = globalThis.bunVM();

src/deps/c_ares.zig

@@ -524,11 +524,12 @@ pub const Channel = opaque {
     }
 
     pub fn resolve(this: *Channel, name: []const u8, comptime lookup_name: []const u8, comptime Type: type, ctx: *Type, comptime cares_type: type, comptime callback: cares_type.Callback(Type)) void {
+        if (name.len >= 1023 or (name.len == 0 and !(bun.strings.eqlComptime(lookup_name, "ns") or bun.strings.eqlComptime(lookup_name, "soa")))) {
+            return cares_type.callbackWrapper(lookup_name, Type, callback).?(ctx, ARES_EBADNAME, 0, null, 0);
+        }
+
         var name_buf: [1024]u8 = undefined;
-        const name_ptr: ?[*:0]const u8 = brk: {
-            if (name.len == 0 or name.len >= 1023) {
-                break :brk null;
-            }
+        const name_ptr: [*:0]const u8 = brk: {
             const len = @min(name.len, name_buf.len - 1);
             @memcpy(name_buf[0..len], name[0..len]);
 

test/js/node/dns/node-dns.test.js

@@ -1,4 +1,4 @@
-import { expect, test } from "bun:test";
+import { describe, expect, test, it } from "bun:test";
 import * as dns from "node:dns";
 import * as dns_promises from "node:dns/promises";
 import * as fs from "node:fs";
@@ -102,6 +102,15 @@ test("dns.resolveSoa (bun.sh)", done => {
   });
 });
 
+test("dns.resolveSoa (empty string)", done => {
+  dns.resolveSoa("", (err, result) => {
+    expect(err).toBeNull();
+    // one of root server
+    expect(result).not.toBeUndefined();
+    done(err);
+  });
+});
+
 test("dns.resolveNaptr (naptr.socketify.dev)", done => {
   dns.resolveNaptr("naptr.socketify.dev", (err, results) => {
     expect(err).toBeNull();
@@ -146,6 +155,32 @@ test("dns.resolveNs (bun.sh) ", done => {
   });
 });
 
+test("dns.resolveNs (empty string) ", done => {
+  dns.resolveNs("", (err, results) => {
+    expect(err).toBeNull();
+    expect(results instanceof Array).toBe(true);
+    // root servers
+    expect(results.sort()).toStrictEqual(
+      [
+        "e.root-servers.net",
+        "h.root-servers.net",
+        "l.root-servers.net",
+        "i.root-servers.net",
+        "a.root-servers.net",
+        "d.root-servers.net",
+        "c.root-servers.net",
+        "b.root-servers.net",
+        "j.root-servers.net",
+        "k.root-servers.net",
+        "g.root-servers.net",
+        "m.root-servers.net",
+        "f.root-servers.net",
+      ].sort(),
+    );
+    done(err);
+  });
+});
+
 test("dns.resolvePtr (ptr.socketify.dev)", done => {
   dns.resolvePtr("ptr.socketify.dev", (err, results) => {
     expect(err).toBeNull();
@@ -268,3 +303,28 @@ test("dns.promises.reverse", async () => {
     expect(hostnames).toContain("one.one.one.one");
   }
 });
+
+describe("test invalid arguments", () => {
+  it.each([
+    // TODO: dns.resolveAny is not implemented yet
+    ["dns.resolveCname", dns.resolveCname],
+    ["dns.resolveCaa", dns.resolveCaa],
+    ["dns.resolveMx", dns.resolveMx],
+    ["dns.resolveNaptr", dns.resolveNaptr],
+    ["dns.resolveNs", dns.resolveNs],
+    ["dns.resolvePtr", dns.resolvePtr],
+    ["dns.resolveSoa", dns.resolveSoa],
+    ["dns.resolveSrv", dns.resolveSrv],
+    ["dns.resolveTxt", dns.resolveTxt],
+  ])("%s", (_, fn, done) => {
+    fn("a".repeat(2000), (err, results) => {
+      try {
+        expect(err).not.toBeNull();
+        expect(results).toBeUndefined();
+        done();
+      } catch (e) {
+        done(e);
+      }
+    });
+  });
+});