From 83b5efeb54f584ca4997895f3bc0ffdb1f096ca6 Mon Sep 17 00:00:00 2001 From: Calvin Date: Sun, 18 Aug 2024 18:43:30 -0600 Subject: [PATCH 01/90] doc: reserve ABI 130 for Electron 33 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backport-PR-URL: https://github.com/nodejs/node/pull/54455 PR-URL: https://github.com/nodejs/node/pull/54383 Reviewed-By: Richard Lau Reviewed-By: Yagiz Nizipli Reviewed-By: Michaël Zasso Reviewed-By: Luigi Pinca Reviewed-By: Moshe Atlow Reviewed-By: Jake Yuesong Li --- doc/abi_version_registry.json | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/abi_version_registry.json b/doc/abi_version_registry.json index 07df2ebdf6de93..204d1edce2128c 100644 --- a/doc/abi_version_registry.json +++ b/doc/abi_version_registry.json @@ -1,5 +1,6 @@ { "NODE_MODULE_VERSION": [ + { "modules": 130,"runtime": "electron", "variant": "electron", "versions": "33" }, { "modules": 128, "runtime":"electron", "variant": "electron", "versions": "32" }, { "modules": 127, "runtime":"node", "variant": "v8_12.4", "versions": "22.0.0" }, { "modules": 126,"runtime": "node", "variant": "v8_12.3", "versions": "22.0.0-pre" }, From 25419915c79d498c7636b65e9216748a62fdebd5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alfredo=20Gonz=C3=A1lez?= <12631491+mfdebian@users.noreply.github.com> Date: Mon, 19 Aug 2024 09:52:40 -0400 Subject: [PATCH 02/90] doc: add esm examples to node:https PR-URL: https://github.com/nodejs/node/pull/54399 Reviewed-By: Luigi Pinca Reviewed-By: Trivikram Kamat --- doc/api/https.md | 213 +++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 187 insertions(+), 26 deletions(-) diff --git a/doc/api/https.md b/doc/api/https.md index 1ba6574fde5ea0..fcefc06e6a5b87 100644 --- a/doc/api/https.md +++ b/doc/api/https.md @@ -243,14 +243,30 @@ added: v0.3.4 * `requestListener` {Function} A listener to be added to the `'request'` event. * Returns: {https.Server} -```js +```mjs +// curl -k https://localhost:8000/ +import { createServer } from 'node:https'; +import { readFileSync } from 'node:fs'; + +const options = { + key: readFileSync('private-key.pem'), + cert: readFileSync('certificate.pem'), +}; + +createServer(options, (req, res) => { + res.writeHead(200); + res.end('hello world\n'); +}).listen(8000); +``` + +```cjs // curl -k https://localhost:8000/ const https = require('node:https'); const fs = require('node:fs'); const options = { - key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'), - cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'), + key: fs.readFileSync('private-key.pem'), + cert: fs.readFileSync('certificate.pem'), }; https.createServer(options, (req, res) => { @@ -261,12 +277,27 @@ https.createServer(options, (req, res) => { Or -```js +```mjs +import { createServer } from 'node:https'; +import { readFileSync } from 'node:fs'; + +const options = { + pfx: readFileSync('test_cert.pfx'), + passphrase: 'sample', +}; + +createServer(options, (req, res) => { + res.writeHead(200); + res.end('hello world\n'); +}).listen(8000); +``` + +```cjs const https = require('node:https'); const fs = require('node:fs'); const options = { - pfx: fs.readFileSync('test/fixtures/test_cert.pfx'), + pfx: fs.readFileSync('test_cert.pfx'), passphrase: 'sample', }; @@ -276,6 +307,20 @@ https.createServer(options, (req, res) => { }).listen(8000); ``` +To generate the certificate and key for this example, run: + +```bash +openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \ + -keyout private-key.pem -out certificate.pem +``` + +Then, to generate the `pfx` certificate for this example, run: + +```bash +openssl pkcs12 -certpbe AES-256-CBC -export -out test_cert.pfx \ + -inkey private-key.pem -in certificate.pem -passout pass:sample +``` + ## `https.get(options[, callback])` ## `https.get(url[, options][, callback])` @@ -303,7 +348,24 @@ Like [`http.get()`][] but for HTTPS. string, it is automatically parsed with [`new URL()`][]. If it is a [`URL`][] object, it will be automatically converted to an ordinary `options` object. -```js +```mjs +import { get } from 'node:https'; +import process from 'node:process'; + +get('https://encrypted.google.com/', (res) => { + console.log('statusCode:', res.statusCode); + console.log('headers:', res.headers); + + res.on('data', (d) => { + process.stdout.write(d); + }); + +}).on('error', (e) => { + console.error(e); +}); +``` + +```cjs const https = require('node:https'); https.get('https://encrypted.google.com/', (res) => { @@ -394,7 +456,33 @@ object, it will be automatically converted to an ordinary `options` object. class. The `ClientRequest` instance is a writable stream. If one needs to upload a file with a POST request, then write to the `ClientRequest` object. -```js +```mjs +import { request } from 'node:https'; +import process from 'node:process'; + +const options = { + hostname: 'encrypted.google.com', + port: 443, + path: '/', + method: 'GET', +}; + +const req = request(options, (res) => { + console.log('statusCode:', res.statusCode); + console.log('headers:', res.headers); + + res.on('data', (d) => { + process.stdout.write(d); + }); +}); + +req.on('error', (e) => { + console.error(e); +}); +req.end(); +``` + +```cjs const https = require('node:https'); const options = { @@ -427,8 +515,8 @@ const options = { port: 443, path: '/', method: 'GET', - key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'), - cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'), + key: fs.readFileSync('private-key.pem'), + cert: fs.readFileSync('certificate.pem'), }; options.agent = new https.Agent(options); @@ -445,8 +533,8 @@ const options = { port: 443, path: '/', method: 'GET', - key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'), - cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'), + key: fs.readFileSync('private-key.pem'), + cert: fs.readFileSync('certificate.pem'), agent: false, }; @@ -468,7 +556,80 @@ const req = https.request(options, (res) => { Example pinning on certificate fingerprint, or the public key (similar to `pin-sha256`): -```js +```mjs +import { checkServerIdentity } from 'node:tls'; +import { Agent, request } from 'node:https'; +import { createHash } from 'node:crypto'; + +function sha256(s) { + return createHash('sha256').update(s).digest('base64'); +} +const options = { + hostname: 'github.com', + port: 443, + path: '/', + method: 'GET', + checkServerIdentity: function(host, cert) { + // Make sure the certificate is issued to the host we are connected to + const err = checkServerIdentity(host, cert); + if (err) { + return err; + } + + // Pin the public key, similar to HPKP pin-sha256 pinning + const pubkey256 = 'SIXvRyDmBJSgatgTQRGbInBaAK+hZOQ18UmrSwnDlK8='; + if (sha256(cert.pubkey) !== pubkey256) { + const msg = 'Certificate verification error: ' + + `The public key of '${cert.subject.CN}' ` + + 'does not match our pinned fingerprint'; + return new Error(msg); + } + + // Pin the exact certificate, rather than the pub key + const cert256 = 'FD:6E:9B:0E:F3:98:BC:D9:04:C3:B2:EC:16:7A:7B:' + + '0F:DA:72:01:C9:03:C5:3A:6A:6A:E5:D0:41:43:63:EF:65'; + if (cert.fingerprint256 !== cert256) { + const msg = 'Certificate verification error: ' + + `The certificate of '${cert.subject.CN}' ` + + 'does not match our pinned fingerprint'; + return new Error(msg); + } + + // This loop is informational only. + // Print the certificate and public key fingerprints of all certs in the + // chain. Its common to pin the public key of the issuer on the public + // internet, while pinning the public key of the service in sensitive + // environments. + let lastprint256; + do { + console.log('Subject Common Name:', cert.subject.CN); + console.log(' Certificate SHA256 fingerprint:', cert.fingerprint256); + + const hash = createHash('sha256'); + console.log(' Public key ping-sha256:', sha256(cert.pubkey)); + + lastprint256 = cert.fingerprint256; + cert = cert.issuerCertificate; + } while (cert.fingerprint256 !== lastprint256); + + }, +}; + +options.agent = new Agent(options); +const req = request(options, (res) => { + console.log('All OK. Server matched our pinned cert or public key'); + console.log('statusCode:', res.statusCode); + + res.on('data', (d) => {}); +}); + +req.on('error', (e) => { + console.error(e.message); +}); +req.end(); +``` + +```cjs const tls = require('node:tls'); const https = require('node:https'); const crypto = require('node:crypto'); @@ -489,7 +650,7 @@ const options = { } // Pin the public key, similar to HPKP pin-sha256 pinning - const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU='; + const pubkey256 = 'SIXvRyDmBJSgatgTQRGbInBaAK+hZOQ18UmrSwnDlK8='; if (sha256(cert.pubkey) !== pubkey256) { const msg = 'Certificate verification error: ' + `The public key of '${cert.subject.CN}' ` + @@ -498,8 +659,8 @@ const options = { } // Pin the exact certificate, rather than the pub key - const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' + - 'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16'; + const cert256 = 'FD:6E:9B:0E:F3:98:BC:D9:04:C3:B2:EC:16:7A:7B:' + + '0F:DA:72:01:C9:03:C5:3A:6A:6A:E5:D0:41:43:63:EF:65'; if (cert.fingerprint256 !== cert256) { const msg = 'Certificate verification error: ' + `The certificate of '${cert.subject.CN}' ` + @@ -530,8 +691,6 @@ options.agent = new https.Agent(options); const req = https.request(options, (res) => { console.log('All OK. Server matched our pinned cert or public key'); console.log('statusCode:', res.statusCode); - // Print the HPKP values - console.log('headers:', res.headers['public-key-pins']); res.on('data', (d) => {}); }); @@ -546,17 +705,19 @@ Outputs for example: ```text Subject Common Name: github.com - Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16 - Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU= -Subject Common Name: DigiCert SHA2 Extended Validation Server CA - Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A - Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho= -Subject Common Name: DigiCert High Assurance EV Root CA - Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF - Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18= + Certificate SHA256 fingerprint: FD:6E:9B:0E:F3:98:BC:D9:04:C3:B2:EC:16:7A:7B:0F:DA:72:01:C9:03:C5:3A:6A:6A:E5:D0:41:43:63:EF:65 + Public key ping-sha256: SIXvRyDmBJSgatgTQRGbInBaAK+hZOQ18UmrSwnDlK8= +Subject Common Name: Sectigo ECC Domain Validation Secure Server CA + Certificate SHA256 fingerprint: 61:E9:73:75:E9:F6:DA:98:2F:F5:C1:9E:2F:94:E6:6C:4E:35:B6:83:7C:E3:B9:14:D2:24:5C:7F:5F:65:82:5F + Public key ping-sha256: Eep0p/AsSa9lFUH6KT2UY+9s1Z8v7voAPkQ4fGknZ2g= +Subject Common Name: USERTrust ECC Certification Authority + Certificate SHA256 fingerprint: A6:CF:64:DB:B4:C8:D5:FD:19:CE:48:89:60:68:DB:03:B5:33:A8:D1:33:6C:62:56:A8:7D:00:CB:B3:DE:F3:EA + Public key ping-sha256: UJM2FOhG9aTNY0Pg4hgqjNzZ/lQBiMGRxPD5Y2/e0bw= +Subject Common Name: AAA Certificate Services + Certificate SHA256 fingerprint: D7:A7:A0:FB:5D:7E:27:31:D7:71:E9:48:4E:BC:DE:F7:1D:5F:0C:3E:0A:29:48:78:2B:C8:3E:E0:EA:69:9E:F4 + Public key ping-sha256: vRU+17BDT2iGsXvOi76E7TQMcTLXAqj0+jGPdW7L1vM= All OK. Server matched our pinned cert or public key statusCode: 200 -headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho="; pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4="; pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains ``` [`Agent`]: #class-httpsagent From 6ccbd32ae8364f477bbaa8b68e5644b67ec71df8 Mon Sep 17 00:00:00 2001 From: Aviv Keller <38299977+RedYetiDev@users.noreply.github.com> Date: Mon, 19 Aug 2024 10:01:06 -0400 Subject: [PATCH 03/90] doc, meta: add missing `,` to `BUILDING.md` PR-URL: https://github.com/nodejs/node/pull/54409 Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca --- BUILDING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILDING.md b/BUILDING.md index d02c51f4c276ae..ad95b3b21c2790 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -123,7 +123,7 @@ platforms. This is true regardless of entries in the table below. -[^1]: Older kernel versions may work. However official Node.js release +[^1]: Older kernel versions may work. However, official Node.js release binaries are [built on RHEL 8 systems](#official-binary-platforms-and-toolchains) with kernel 4.18. From c4996c189fd26608c8e487f4fed15e523b874d7a Mon Sep 17 00:00:00 2001 From: Aviv Keller <38299977+RedYetiDev@users.noreply.github.com> Date: Mon, 19 Aug 2024 10:01:20 -0400 Subject: [PATCH 04/90] meta: run coverage-windows when `vcbuild.bat` updated PR-URL: https://github.com/nodejs/node/pull/54412 Reviewed-By: Luigi Pinca Reviewed-By: Marco Ippolito --- .github/workflows/coverage-windows.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/coverage-windows.yml b/.github/workflows/coverage-windows.yml index 34fe96d5ec609a..67e503895b25c3 100644 --- a/.github/workflows/coverage-windows.yml +++ b/.github/workflows/coverage-windows.yml @@ -5,7 +5,7 @@ on: types: [opened, synchronize, reopened, ready_for_review] paths: - lib/**/*.js - - Makefile + - vcbuild.bat - src/**/*.cc - src/**/*.h - test/** @@ -18,7 +18,7 @@ on: - main paths: - lib/**/*.js - - Makefile + - vcbuild.bat - src/**/*.cc - src/**/*.h - test/** From 909c5320fd12028eb782a358b6cdf4d515987724 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 11 Aug 2024 12:11:26 -0700 Subject: [PATCH 05/90] src: move more crypto code to ncrypto PR-URL: https://github.com/nodejs/node/pull/54320 Reviewed-By: Yagiz Nizipli --- deps/ncrypto/ncrypto.cc | 53 ++++++++++++++++++++++++++++++++++++ deps/ncrypto/ncrypto.h | 51 ++++++++++++++++++++++++++++++++-- src/crypto/crypto_bio.cc | 8 +++--- src/crypto/crypto_context.cc | 22 +++++++-------- src/crypto/crypto_ec.cc | 2 +- src/crypto/crypto_keys.cc | 32 ++++++++++------------ src/crypto/crypto_tls.cc | 11 ++++---- src/crypto/crypto_util.cc | 3 +- src/crypto/crypto_x509.cc | 15 +++++----- 9 files changed, 147 insertions(+), 50 deletions(-) diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index df5bd6f33c43c1..c3f4b3fd9893f7 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -963,4 +963,57 @@ X509Pointer X509Pointer::IssuerFrom(const SSL_CTX* ctx, const X509View& cert) { X509Pointer X509Pointer::PeerFrom(const SSLPointer& ssl) { return X509Pointer(SSL_get_peer_certificate(ssl.get())); } +// ============================================================================ +// BIOPointer + +BIOPointer::BIOPointer(BIO* bio) : bio_(bio) {} + +BIOPointer::BIOPointer(BIOPointer&& other) noexcept : bio_(other.release()) {} + +BIOPointer& BIOPointer::operator=(BIOPointer&& other) noexcept { + if (this == &other) return *this; + this->~BIOPointer(); + return *new (this) BIOPointer(std::move(other)); +} + +BIOPointer::~BIOPointer() { reset(); } + +void BIOPointer::reset(BIO* bio) { bio_.reset(bio); } + +BIO* BIOPointer::release() { return bio_.release(); } + +bool BIOPointer::resetBio() const { + if (!bio_) return 0; + return BIO_reset(bio_.get()) == 1; +} + +BIOPointer BIOPointer::NewMem() { + return BIOPointer(BIO_new(BIO_s_mem())); +} + +BIOPointer BIOPointer::NewSecMem() { + return BIOPointer(BIO_new(BIO_s_secmem())); +} + +BIOPointer BIOPointer::New(const BIO_METHOD* method) { + return BIOPointer(BIO_new(method)); +} + +BIOPointer BIOPointer::New(const void* data, size_t len) { + return BIOPointer(BIO_new_mem_buf(data, len)); +} + +BIOPointer BIOPointer::NewFile(std::string_view filename, std::string_view mode) { + return BIOPointer(BIO_new_file(filename.data(), mode.data())); +} + +BIOPointer BIOPointer::NewFp(FILE* fd, int close_flag) { + return BIOPointer(BIO_new_fp(fd, close_flag)); +} + +int BIOPointer::Write(BIOPointer* bio, std::string_view message) { + if (bio == nullptr || !*bio) return 0; + return BIO_write(bio->get(), message.data(), message.size()); +} + } // namespace ncrypto diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index 50e86538edda7c..e62a99595ae2c6 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -6,8 +6,8 @@ #include #include #include +#include #include -#include #include #include #include @@ -17,6 +17,7 @@ #include #include #include +#include #ifndef OPENSSL_NO_ENGINE # include #endif // !OPENSSL_NO_ENGINE @@ -192,7 +193,6 @@ template using DeleteFnPtr = typename FunctionDeleter::Pointer; using BignumCtxPointer = DeleteFnPtr; -using BIOPointer = DeleteFnPtr; using CipherCtxPointer = DeleteFnPtr; using DHPointer = DeleteFnPtr; using DSAPointer = DeleteFnPtr; @@ -265,6 +265,53 @@ class DataPointer final { size_t len_ = 0; }; +class BIOPointer final { +public: + static BIOPointer NewMem(); + static BIOPointer NewSecMem(); + static BIOPointer New(const BIO_METHOD* method); + static BIOPointer New(const void* data, size_t len); + static BIOPointer NewFile(std::string_view filename, std::string_view mode); + static BIOPointer NewFp(FILE* fd, int flags); + + BIOPointer() = default; + BIOPointer(std::nullptr_t) : bio_(nullptr) {} + explicit BIOPointer(BIO* bio); + BIOPointer(BIOPointer&& other) noexcept; + BIOPointer& operator=(BIOPointer&& other) noexcept; + NCRYPTO_DISALLOW_COPY(BIOPointer) + ~BIOPointer(); + + inline bool operator==(std::nullptr_t) noexcept { return bio_ == nullptr; } + inline operator bool() const { return bio_ != nullptr; } + inline BIO* get() const noexcept { return bio_.get(); } + + inline operator BUF_MEM*() const { + BUF_MEM* mem = nullptr; + if (!bio_) return mem; + BIO_get_mem_ptr(bio_.get(), &mem); + return mem; + } + + inline operator BIO*() const { return bio_.get(); } + + void reset(BIO* bio = nullptr); + BIO* release(); + + bool resetBio() const; + + static int Write(BIOPointer* bio, std::string_view message); + + template + static void Printf(BIOPointer* bio, const char* format, Args...args) { + if (bio == nullptr || !*bio) return; + BIO_printf(bio->get(), format, std::forward(args...)); + } + +private: + mutable DeleteFnPtr bio_; +}; + class BignumPointer final { public: BignumPointer() = default; diff --git a/src/crypto/crypto_bio.cc b/src/crypto/crypto_bio.cc index 47045365ceaf81..e9c920ccffa70a 100644 --- a/src/crypto/crypto_bio.cc +++ b/src/crypto/crypto_bio.cc @@ -33,7 +33,7 @@ namespace node { namespace crypto { BIOPointer NodeBIO::New(Environment* env) { - BIOPointer bio(BIO_new(GetMethod())); + auto bio = BIOPointer::New(GetMethod()); if (bio && env != nullptr) NodeBIO::FromBIO(bio.get())->env_ = env; return bio; @@ -43,9 +43,9 @@ BIOPointer NodeBIO::New(Environment* env) { BIOPointer NodeBIO::NewFixed(const char* data, size_t len, Environment* env) { BIOPointer bio = New(env); - if (!bio || - len > INT_MAX || - BIO_write(bio.get(), data, len) != static_cast(len) || + if (!bio || len > INT_MAX || + BIOPointer::Write(&bio, std::string_view(data, len)) != + static_cast(len) || BIO_set_mem_eof_return(bio.get(), 0) != 1) { return BIOPointer(); } diff --git a/src/crypto/crypto_context.cc b/src/crypto/crypto_context.cc index 1efe7bfcdfe603..48fecc82c159d8 100644 --- a/src/crypto/crypto_context.cc +++ b/src/crypto/crypto_context.cc @@ -64,16 +64,17 @@ X509_STORE* GetOrCreateRootCertStore() { // Caller responsible for BIO_free_all-ing the returned object. BIOPointer LoadBIO(Environment* env, Local v) { if (v->IsString() || v->IsArrayBufferView()) { - BIOPointer bio(BIO_new(BIO_s_secmem())); - if (!bio) return nullptr; + auto bio = BIOPointer::NewSecMem(); + if (!bio) return {}; ByteSource bsrc = ByteSource::FromStringOrBuffer(env, v); - if (bsrc.size() > INT_MAX) return nullptr; - int written = BIO_write(bio.get(), bsrc.data(), bsrc.size()); - if (written < 0) return nullptr; - if (static_cast(written) != bsrc.size()) return nullptr; + if (bsrc.size() > INT_MAX) return {}; + int written = BIOPointer::Write( + &bio, std::string_view(bsrc.data(), bsrc.size())); + if (written < 0) return {}; + if (static_cast(written) != bsrc.size()) return {}; return bio; } - return nullptr; + return {}; } namespace { @@ -202,7 +203,7 @@ unsigned long LoadCertsFromFile( // NOLINT(runtime/int) const char* file) { MarkPopErrorOnReturn mark_pop_error_on_return; - BIOPointer bio(BIO_new_file(file, "r")); + auto bio = BIOPointer::NewFile(file, "r"); if (!bio) return ERR_get_error(); while (X509* x509 = PEM_read_bio_X509( @@ -1012,16 +1013,15 @@ void SecureContext::SetSessionIdContext( if (SSL_CTX_set_session_id_context(sc->ctx_.get(), sid_ctx, sid_ctx_len) == 1) return; - BUF_MEM* mem; Local message; - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); if (!bio) { message = FIXED_ONE_BYTE_STRING(env->isolate(), "SSL_CTX_set_session_id_context error"); } else { ERR_print_errors(bio.get()); - BIO_get_mem_ptr(bio.get(), &mem); + BUF_MEM* mem = bio; message = OneByteString(env->isolate(), mem->data, mem->length); } diff --git a/src/crypto/crypto_ec.cc b/src/crypto/crypto_ec.cc index cd6bee36dae102..d9e29a01d297e4 100644 --- a/src/crypto/crypto_ec.cc +++ b/src/crypto/crypto_ec.cc @@ -736,7 +736,7 @@ WebCryptoKeyExportStatus ECKeyExportTraits::DoExport( CHECK_EQ(1, EC_KEY_set_public_key(ec.get(), uncompressed.get())); EVPKeyPointer pkey(EVP_PKEY_new()); CHECK_EQ(1, EVP_PKEY_set1_EC_KEY(pkey.get(), ec.get())); - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); CHECK(bio); if (!i2d_PUBKEY_bio(bio.get(), pkey.get())) return WebCryptoKeyExportStatus::FAILED; diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc index 35474c31bfc2e3..f49bb1254cb219 100644 --- a/src/crypto/crypto_keys.cc +++ b/src/crypto/crypto_keys.cc @@ -104,7 +104,7 @@ ParseKeyResult TryParsePublicKey(EVPKeyPointer* pkey, ParseKeyResult ParsePublicKeyPEM(EVPKeyPointer* pkey, const char* key_pem, int key_pem_len) { - BIOPointer bp(BIO_new_mem_buf(const_cast(key_pem), key_pem_len)); + auto bp = BIOPointer::New(key_pem, key_pem_len); if (!bp) return ParseKeyResult::kParseKeyFailed; @@ -119,7 +119,7 @@ ParseKeyResult ParsePublicKeyPEM(EVPKeyPointer* pkey, return ret; // Maybe it is PKCS#1. - CHECK(BIO_reset(bp.get())); + CHECK(bp.resetBio()); ret = TryParsePublicKey(pkey, bp, "RSA PUBLIC KEY", [](const unsigned char** p, long l) { // NOLINT(runtime/int) return d2i_PublicKey(EVP_PKEY_RSA, nullptr, p, l); @@ -128,7 +128,7 @@ ParseKeyResult ParsePublicKeyPEM(EVPKeyPointer* pkey, return ret; // X.509 fallback. - CHECK(BIO_reset(bp.get())); + CHECK(bp.resetBio()); return TryParsePublicKey(pkey, bp, "CERTIFICATE", [](const unsigned char** p, long l) { // NOLINT(runtime/int) X509Pointer x509(d2i_X509(nullptr, p, l)); @@ -218,7 +218,7 @@ ParseKeyResult ParsePrivateKey(EVPKeyPointer* pkey, const ByteSource* passphrase = config.passphrase_.get(); if (config.format_ == kKeyFormatPEM) { - BIOPointer bio(BIO_new_mem_buf(key, key_len)); + auto bio = BIOPointer::New(key, key_len); if (!bio) return ParseKeyResult::kParseKeyFailed; @@ -233,7 +233,7 @@ ParseKeyResult ParsePrivateKey(EVPKeyPointer* pkey, const unsigned char* p = reinterpret_cast(key); pkey->reset(d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &p, key_len)); } else if (config.type_.ToChecked() == kKeyEncodingPKCS8) { - BIOPointer bio(BIO_new_mem_buf(key, key_len)); + auto bio = BIOPointer::New(key, key_len); if (!bio) return ParseKeyResult::kParseKeyFailed; @@ -270,12 +270,10 @@ ParseKeyResult ParsePrivateKey(EVPKeyPointer* pkey, return ParseKeyResult::kParseKeyFailed; } -MaybeLocal BIOToStringOrBuffer( - Environment* env, - BIO* bio, - PKFormatType format) { - BUF_MEM* bptr; - BIO_get_mem_ptr(bio, &bptr); +MaybeLocal BIOToStringOrBuffer(Environment* env, + const BIOPointer& bio, + PKFormatType format) { + BUF_MEM* bptr = bio; if (format == kKeyFormatPEM) { // PEM is an ASCII format, so we will return it as a string. return String::NewFromUtf8(env->isolate(), bptr->data, @@ -292,7 +290,7 @@ MaybeLocal BIOToStringOrBuffer( MaybeLocal WritePrivateKey(Environment* env, OSSL3_CONST EVP_PKEY* pkey, const PrivateKeyEncodingConfig& config) { - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); CHECK(bio); // If an empty string was passed as the passphrase, the ByteSource might @@ -388,7 +386,7 @@ MaybeLocal WritePrivateKey(Environment* env, ThrowCryptoError(env, ERR_get_error(), "Failed to encode private key"); return MaybeLocal(); } - return BIOToStringOrBuffer(env, bio.get(), config.format_); + return BIOToStringOrBuffer(env, bio, config.format_); } bool WritePublicKeyInner(OSSL3_CONST EVP_PKEY* pkey, @@ -422,14 +420,14 @@ bool WritePublicKeyInner(OSSL3_CONST EVP_PKEY* pkey, MaybeLocal WritePublicKey(Environment* env, OSSL3_CONST EVP_PKEY* pkey, const PublicKeyEncodingConfig& config) { - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); CHECK(bio); if (!WritePublicKeyInner(pkey, bio, config)) { ThrowCryptoError(env, ERR_get_error(), "Failed to encode public key"); return MaybeLocal(); } - return BIOToStringOrBuffer(env, bio.get(), config.format_); + return BIOToStringOrBuffer(env, bio, config.format_); } Maybe ExportJWKSecretKey(Environment* env, @@ -1448,7 +1446,7 @@ WebCryptoKeyExportStatus PKEY_SPKI_Export( CHECK_EQ(key_data->GetKeyType(), kKeyTypePublic); ManagedEVPPKey m_pkey = key_data->GetAsymmetricKey(); Mutex::ScopedLock lock(*m_pkey.mutex()); - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); CHECK(bio); if (!i2d_PUBKEY_bio(bio.get(), m_pkey.get())) return WebCryptoKeyExportStatus::FAILED; @@ -1464,7 +1462,7 @@ WebCryptoKeyExportStatus PKEY_PKCS8_Export( ManagedEVPPKey m_pkey = key_data->GetAsymmetricKey(); Mutex::ScopedLock lock(*m_pkey.mutex()); - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); CHECK(bio); PKCS8Pointer p8inf(EVP_PKEY2PKCS8(m_pkey.get())); if (!i2d_PKCS8_PRIV_KEY_INFO_bio(bio.get(), p8inf.get())) diff --git a/src/crypto/crypto_tls.cc b/src/crypto/crypto_tls.cc index 0ad6fa28542978..4013c1d8e2ff68 100644 --- a/src/crypto/crypto_tls.cc +++ b/src/crypto/crypto_tls.cc @@ -20,12 +20,13 @@ // USE OR OTHER DEALINGS IN THE SOFTWARE. #include "crypto/crypto_tls.h" -#include "crypto/crypto_context.h" -#include "crypto/crypto_common.h" -#include "crypto/crypto_util.h" +#include +#include "async_wrap-inl.h" #include "crypto/crypto_bio.h" #include "crypto/crypto_clienthello-inl.h" -#include "async_wrap-inl.h" +#include "crypto/crypto_common.h" +#include "crypto/crypto_context.h" +#include "crypto/crypto_util.h" #include "debug_utils-inl.h" #include "memory_tracker-inl.h" #include "node_buffer.h" @@ -1244,7 +1245,7 @@ void TLSWrap::EnableTrace(const FunctionCallbackInfo& args) { #if HAVE_SSL_TRACE if (wrap->ssl_) { - wrap->bio_trace_.reset(BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT)); + wrap->bio_trace_ = BIOPointer::NewFp(stderr, BIO_NOCLOSE | BIO_FP_TEXT); SSL_set_msg_callback(wrap->ssl_.get(), [](int write_p, int version, int content_type, const void* buf, size_t len, SSL* ssl, void* arg) -> void { diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc index 78656b5ee6f46d..501177f15cbdb0 100644 --- a/src/crypto/crypto_util.cc +++ b/src/crypto/crypto_util.cc @@ -355,8 +355,7 @@ MaybeLocal ByteSource::ToBuffer(Environment* env) { ByteSource ByteSource::FromBIO(const BIOPointer& bio) { CHECK(bio); - BUF_MEM* bptr; - BIO_get_mem_ptr(bio.get(), &bptr); + BUF_MEM* bptr = bio; ByteSource::Builder out(bptr->length); memcpy(out.data(), bptr->data, bptr->length); return std::move(out).release(); diff --git a/src/crypto/crypto_x509.cc b/src/crypto/crypto_x509.cc index 367ae2bea384b7..386528e65945f2 100644 --- a/src/crypto/crypto_x509.cc +++ b/src/crypto/crypto_x509.cc @@ -102,8 +102,7 @@ void Fingerprint(const FunctionCallbackInfo& args) { MaybeLocal ToV8Value(Local context, BIOPointer&& bio) { if (!bio) return {}; - BUF_MEM* mem; - BIO_get_mem_ptr(bio.get(), &mem); + BUF_MEM* mem = bio; Local ret; if (!String::NewFromUtf8(context->GetIsolate(), mem->data, @@ -161,8 +160,7 @@ MaybeLocal ToV8Value(Local context, const ASN1_STRING* str) { MaybeLocal ToV8Value(Local context, const BIOPointer& bio) { if (!bio) return {}; - BUF_MEM* mem; - BIO_get_mem_ptr(bio.get(), &mem); + BUF_MEM* mem = bio; Local ret; if (!String::NewFromUtf8(context->GetIsolate(), mem->data, @@ -175,8 +173,7 @@ MaybeLocal ToV8Value(Local context, const BIOPointer& bio) { MaybeLocal ToBuffer(Environment* env, BIOPointer* bio) { if (bio == nullptr || !*bio) return {}; - BUF_MEM* mem; - BIO_get_mem_ptr(bio->get(), &mem); + BUF_MEM* mem = *bio; auto backing = ArrayBuffer::NewBackingStore( mem->data, mem->length, @@ -664,14 +661,16 @@ MaybeLocal GetPubKey(Environment* env, OSSL3_CONST RSA* rsa) { } MaybeLocal GetModulusString(Environment* env, const BIGNUM* n) { - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); + if (!bio) return {}; BN_print(bio.get(), n); return ToV8Value(env->context(), bio); } MaybeLocal GetExponentString(Environment* env, const BIGNUM* e) { uint64_t exponent_word = static_cast(BignumPointer::GetWord(e)); - BIOPointer bio(BIO_new(BIO_s_mem())); + auto bio = BIOPointer::NewMem(); + if (!bio) return {}; BIO_printf(bio.get(), "0x%" PRIx64, exponent_word); return ToV8Value(env->context(), bio); } From cbe30a02a35edfe03192d740ee6d70b8731b8ce4 Mon Sep 17 00:00:00 2001 From: Colin Ihrig Date: Tue, 20 Aug 2024 03:14:01 -0400 Subject: [PATCH 06/90] test_runner: finish build phase before running tests This commit updates the test runner to wait for suites to finish building before starting any tests. This is necessary when test filtering is enabled, as suites may transition from filtered to not filtered depending on what is inside of them. Fixes: https://github.com/nodejs/node/issues/54084 Fixes: https://github.com/nodejs/node/issues/54154 PR-URL: https://github.com/nodejs/node/pull/54423 Reviewed-By: Benjamin Gruenbaum Reviewed-By: Matteo Collina Reviewed-By: Moshe Atlow Reviewed-By: Jake Yuesong Li --- lib/internal/test_runner/harness.js | 42 ++++- lib/internal/test_runner/runner.js | 2 +- lib/internal/test_runner/test.js | 2 +- .../output/filtered-suite-delayed-build.js | 16 ++ .../filtered-suite-delayed-build.snapshot | 34 ++++ .../output/filtered-suite-order.mjs | 49 ++++++ .../output/filtered-suite-order.snapshot | 166 ++++++++++++++++++ .../output/source_mapped_locations.snapshot | 3 - test/parallel/test-runner-output.mjs | 2 + 9 files changed, 302 insertions(+), 14 deletions(-) create mode 100644 test/fixtures/test-runner/output/filtered-suite-delayed-build.js create mode 100644 test/fixtures/test-runner/output/filtered-suite-delayed-build.snapshot create mode 100644 test/fixtures/test-runner/output/filtered-suite-order.mjs create mode 100644 test/fixtures/test-runner/output/filtered-suite-order.snapshot diff --git a/lib/internal/test_runner/harness.js b/lib/internal/test_runner/harness.js index 9c372c115e90f2..3c56820cf4e247 100644 --- a/lib/internal/test_runner/harness.js +++ b/lib/internal/test_runner/harness.js @@ -1,9 +1,11 @@ 'use strict'; const { ArrayPrototypeForEach, + ArrayPrototypePush, FunctionPrototypeBind, PromiseResolve, SafeMap, + SafePromiseAllReturnVoid, } = primordials; const { getCallerLocation } = internalBinding('util'); const { @@ -24,6 +26,7 @@ const { shouldColorizeTestFiles, } = require('internal/test_runner/utils'); const { queueMicrotask } = require('internal/process/task_queues'); +const { createDeferredPromise } = require('internal/util'); const { bigint: hrtime } = process.hrtime; const resolvedPromise = PromiseResolve(); const testResources = new SafeMap(); @@ -32,9 +35,12 @@ let globalRoot; testResources.set(reporterScope.asyncId(), reporterScope); function createTestTree(rootTestOptions, globalOptions) { + const buildPhaseDeferred = createDeferredPromise(); const harness = { __proto__: null, - allowTestsToRun: false, + buildPromise: buildPhaseDeferred.promise, + buildSuites: [], + isWaitingForBuildPhase: false, bootstrapPromise: resolvedPromise, watching: false, config: globalOptions, @@ -56,6 +62,13 @@ function createTestTree(rootTestOptions, globalOptions) { shouldColorizeTestFiles: shouldColorizeTestFiles(globalOptions.destinations), teardown: null, snapshotManager: null, + async waitForBuildPhase() { + if (harness.buildSuites.length > 0) { + await SafePromiseAllReturnVoid(harness.buildSuites); + } + + buildPhaseDeferred.resolve(); + }, }; harness.resetCounters(); @@ -243,14 +256,25 @@ function lazyBootstrapRoot() { } async function startSubtestAfterBootstrap(subtest) { - if (subtest.root.harness.bootstrapPromise) { - // Only incur the overhead of awaiting the Promise once. - await subtest.root.harness.bootstrapPromise; - subtest.root.harness.bootstrapPromise = null; - queueMicrotask(() => { - subtest.root.harness.allowTestsToRun = true; - subtest.root.processPendingSubtests(); - }); + if (subtest.root.harness.buildPromise) { + if (subtest.root.harness.bootstrapPromise) { + await subtest.root.harness.bootstrapPromise; + subtest.root.harness.bootstrapPromise = null; + } + + if (subtest.buildSuite) { + ArrayPrototypePush(subtest.root.harness.buildSuites, subtest.buildSuite); + } + + if (!subtest.root.harness.isWaitingForBuildPhase) { + subtest.root.harness.isWaitingForBuildPhase = true; + queueMicrotask(() => { + subtest.root.harness.waitForBuildPhase(); + }); + } + + await subtest.root.harness.buildPromise; + subtest.root.harness.buildPromise = null; } await subtest.start(); diff --git a/lib/internal/test_runner/runner.js b/lib/internal/test_runner/runner.js index e994b1aa40ecab..a4874d5caead91 100644 --- a/lib/internal/test_runner/runner.js +++ b/lib/internal/test_runner/runner.js @@ -610,7 +610,7 @@ function run(options = kEmptyObject) { } const runFiles = () => { root.harness.bootstrapPromise = null; - root.harness.allowTestsToRun = true; + root.harness.buildPromise = null; return SafePromiseAllSettledReturnVoid(testFiles, (path) => { const subtest = runTestFile(path, filesWatcher, opts); filesWatcher?.runningSubtests.set(path, subtest); diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js index e4ebbb2ee9238b..b79ff7a049ea6c 100644 --- a/lib/internal/test_runner/test.js +++ b/lib/internal/test_runner/test.js @@ -766,7 +766,7 @@ class Test extends AsyncResource { // it. Otherwise, return a Promise to the caller and mark the test as // pending for later execution. this.reporter.enqueue(this.nesting, this.loc, this.name); - if (!this.root.harness.allowTestsToRun || !this.parent.hasConcurrency()) { + if (this.root.harness.buildPromise || !this.parent.hasConcurrency()) { const deferred = createDeferredPromise(); deferred.test = this; diff --git a/test/fixtures/test-runner/output/filtered-suite-delayed-build.js b/test/fixtures/test-runner/output/filtered-suite-delayed-build.js new file mode 100644 index 00000000000000..c6b7060c2b88b2 --- /dev/null +++ b/test/fixtures/test-runner/output/filtered-suite-delayed-build.js @@ -0,0 +1,16 @@ +// Flags: --test-name-pattern=enabled +'use strict'; +const common = require('../../../common'); +const { suite, test } = require('node:test'); + +suite('async suite', async () => { + await 1; + test('enabled 1', common.mustCall()); + await 1; + test('not run', common.mustNotCall()); + await 1; +}); + +suite('sync suite', () => { + test('enabled 2', common.mustCall()); +}); diff --git a/test/fixtures/test-runner/output/filtered-suite-delayed-build.snapshot b/test/fixtures/test-runner/output/filtered-suite-delayed-build.snapshot new file mode 100644 index 00000000000000..dbe3048dffdf12 --- /dev/null +++ b/test/fixtures/test-runner/output/filtered-suite-delayed-build.snapshot @@ -0,0 +1,34 @@ +TAP version 13 +# Subtest: async suite + # Subtest: enabled 1 + ok 1 - enabled 1 + --- + duration_ms: * + ... + 1..1 +ok 1 - async suite + --- + duration_ms: * + type: 'suite' + ... +# Subtest: sync suite + # Subtest: enabled 2 + ok 1 - enabled 2 + --- + duration_ms: * + ... + 1..1 +ok 2 - sync suite + --- + duration_ms: * + type: 'suite' + ... +1..2 +# tests 2 +# suites 2 +# pass 2 +# fail 0 +# cancelled 0 +# skipped 0 +# todo 0 +# duration_ms * diff --git a/test/fixtures/test-runner/output/filtered-suite-order.mjs b/test/fixtures/test-runner/output/filtered-suite-order.mjs new file mode 100644 index 00000000000000..f7df0cb8e355a7 --- /dev/null +++ b/test/fixtures/test-runner/output/filtered-suite-order.mjs @@ -0,0 +1,49 @@ +// Flags: --test-only +import { describe, test, after } from 'node:test'; + +after(() => { console.log('with global after()'); }); +await Promise.resolve(); + +console.log('Execution order was:'); +const ll = (t) => { console.log(` * ${t.fullName}`) }; + +describe('A', () => { + test.only('A', ll); + test('B', ll); + describe.only('C', () => { + test.only('A', ll); + test('B', ll); + }); + describe('D', () => { + test.only('A', ll); + test('B', ll); + }); +}); +describe.only('B', () => { + test('A', ll); + test('B', ll); + describe('C', () => { + test('A', ll); + }); +}); +describe('C', () => { + test.only('A', ll); + test('B', ll); + describe.only('C', () => { + test('A', ll); + test('B', ll); + }); + describe('D', () => { + test('A', ll); + test.only('B', ll); + }); +}); +describe('D', () => { + test('A', ll); + test.only('B', ll); +}); +describe.only('E', () => { + test('A', ll); + test('B', ll); +}); +test.only('F', ll); diff --git a/test/fixtures/test-runner/output/filtered-suite-order.snapshot b/test/fixtures/test-runner/output/filtered-suite-order.snapshot new file mode 100644 index 00000000000000..7a18df8c7d0aea --- /dev/null +++ b/test/fixtures/test-runner/output/filtered-suite-order.snapshot @@ -0,0 +1,166 @@ +Execution order was: + * A > A + * A > C > A + * A > D > A + * B > A + * B > B + * B > C > A + * C > A + * C > C > A + * C > C > B + * C > D > B + * D > B + * E > A + * E > B + * F +with global after() +TAP version 13 +# Subtest: A + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + # Subtest: C + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + 1..1 + ok 2 - C + --- + duration_ms: * + type: 'suite' + ... + # Subtest: D + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + 1..1 + ok 3 - D + --- + duration_ms: * + type: 'suite' + ... + 1..3 +ok 1 - A + --- + duration_ms: * + type: 'suite' + ... +# Subtest: B + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + # Subtest: B + ok 2 - B + --- + duration_ms: * + ... + # Subtest: C + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + 1..1 + ok 3 - C + --- + duration_ms: * + type: 'suite' + ... + 1..3 +ok 2 - B + --- + duration_ms: * + type: 'suite' + ... +# Subtest: C + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + # Subtest: C + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + # Subtest: B + ok 2 - B + --- + duration_ms: * + ... + 1..2 + ok 2 - C + --- + duration_ms: * + type: 'suite' + ... + # Subtest: D + # Subtest: B + ok 1 - B + --- + duration_ms: * + ... + 1..1 + ok 3 - D + --- + duration_ms: * + type: 'suite' + ... + 1..3 +ok 3 - C + --- + duration_ms: * + type: 'suite' + ... +# Subtest: D + # Subtest: B + ok 1 - B + --- + duration_ms: * + ... + 1..1 +ok 4 - D + --- + duration_ms: * + type: 'suite' + ... +# Subtest: E + # Subtest: A + ok 1 - A + --- + duration_ms: * + ... + # Subtest: B + ok 2 - B + --- + duration_ms: * + ... + 1..2 +ok 5 - E + --- + duration_ms: * + type: 'suite' + ... +# Subtest: F +ok 6 - F + --- + duration_ms: * + ... +1..6 +# tests 14 +# suites 10 +# pass 14 +# fail 0 +# cancelled 0 +# skipped 0 +# todo 0 +# duration_ms * diff --git a/test/fixtures/test-runner/output/source_mapped_locations.snapshot b/test/fixtures/test-runner/output/source_mapped_locations.snapshot index 29b70fd0d08378..24c3ee8d113446 100644 --- a/test/fixtures/test-runner/output/source_mapped_locations.snapshot +++ b/test/fixtures/test-runner/output/source_mapped_locations.snapshot @@ -21,9 +21,6 @@ not ok 1 - fails * * * - * - * - * ... 1..1 # tests 1 diff --git a/test/parallel/test-runner-output.mjs b/test/parallel/test-runner-output.mjs index bd2db22ee6cc36..0125a8168e4464 100644 --- a/test/parallel/test-runner-output.mjs +++ b/test/parallel/test-runner-output.mjs @@ -101,6 +101,8 @@ const tests = [ { name: 'test-runner/output/eval_dot.js', transform: specTransform }, { name: 'test-runner/output/eval_spec.js', transform: specTransform }, { name: 'test-runner/output/eval_tap.js' }, + { name: 'test-runner/output/filtered-suite-delayed-build.js' }, + { name: 'test-runner/output/filtered-suite-order.mjs' }, { name: 'test-runner/output/filtered-suite-throws.js' }, { name: 'test-runner/output/hooks.js' }, { name: 'test-runner/output/hooks_spec_reporter.js', transform: specTransform }, From 3a74c400d5458e92a04f96d44a11ea8067921278 Mon Sep 17 00:00:00 2001 From: Yagiz Nizipli Date: Tue, 20 Aug 2024 09:04:30 -0400 Subject: [PATCH 07/90] src: improve `buffer.transcode` performance PR-URL: https://github.com/nodejs/node/pull/54153 Reviewed-By: Daniel Lemire Reviewed-By: Benjamin Gruenbaum Reviewed-By: Matteo Collina Reviewed-By: Minwoo Jung Reviewed-By: James M Snell --- benchmark/buffers/buffer-transcode.js | 35 +++++++++ src/node_i18n.cc | 107 +++++++++++--------------- 2 files changed, 79 insertions(+), 63 deletions(-) create mode 100644 benchmark/buffers/buffer-transcode.js diff --git a/benchmark/buffers/buffer-transcode.js b/benchmark/buffers/buffer-transcode.js new file mode 100644 index 00000000000000..cbb3b2e9b16374 --- /dev/null +++ b/benchmark/buffers/buffer-transcode.js @@ -0,0 +1,35 @@ +'use strict'; +const common = require('../common.js'); +const assert = require('node:assert'); +const buffer = require('node:buffer'); + +const hasIntl = !!process.config.variables.v8_enable_i18n_support; +const encodings = ['latin1', 'ascii', 'ucs2', 'utf8']; + +if (!hasIntl) { + console.log('Skipping: `transcode` is only available on platforms that support i18n`'); + process.exit(0); +} + +const bench = common.createBenchmark(main, { + fromEncoding: encodings, + toEncoding: encodings, + length: [1, 10, 1000], + n: [1e5], +}, { + combinationFilter(p) { + return !(p.fromEncoding === 'ucs2' && p.toEncoding === 'utf8'); + }, +}); + +function main({ n, fromEncoding, toEncoding, length }) { + const input = Buffer.from('a'.repeat(length)); + let out = 0; + bench.start(); + for (let i = 0; i < n; i++) { + const dest = buffer.transcode(input, fromEncoding, toEncoding); + out += dest.buffer.byteLength; + } + bench.end(n); + assert.ok(out >= 0); +} diff --git a/src/node_i18n.cc b/src/node_i18n.cc index 7a13f35d2f2bcb..43bb68351bf0a6 100644 --- a/src/node_i18n.cc +++ b/src/node_i18n.cc @@ -42,6 +42,7 @@ #include "node_i18n.h" #include "node_external_reference.h" +#include "simdutf.h" #if defined(NODE_HAVE_I18N_SUPPORT) @@ -147,7 +148,6 @@ MaybeLocal Transcode(Environment* env, const char* source, const size_t source_length, UErrorCode* status) { - *status = U_ZERO_ERROR; MaybeLocal ret; MaybeStackBuffer result; Converter to(toEncoding); @@ -170,22 +170,21 @@ MaybeLocal Transcode(Environment* env, return ret; } -MaybeLocal TranscodeToUcs2(Environment* env, - const char* fromEncoding, - const char* toEncoding, - const char* source, - const size_t source_length, - UErrorCode* status) { - *status = U_ZERO_ERROR; - MaybeLocal ret; +MaybeLocal TranscodeLatin1ToUcs2(Environment* env, + const char* fromEncoding, + const char* toEncoding, + const char* source, + const size_t source_length, + UErrorCode* status) { MaybeStackBuffer destbuf(source_length); - Converter from(fromEncoding); - const size_t length_in_chars = source_length * sizeof(UChar); - ucnv_toUChars(from.conv(), *destbuf, length_in_chars, - source, source_length, status); - if (U_SUCCESS(*status)) - ret = ToBufferEndian(env, &destbuf); - return ret; + auto actual_length = + simdutf::convert_latin1_to_utf16le(source, source_length, destbuf.out()); + if (actual_length == 0) { + *status = U_INVALID_CHAR_FOUND; + return {}; + } + + return Buffer::New(env, &destbuf); } MaybeLocal TranscodeFromUcs2(Environment* env, @@ -194,13 +193,11 @@ MaybeLocal TranscodeFromUcs2(Environment* env, const char* source, const size_t source_length, UErrorCode* status) { - *status = U_ZERO_ERROR; MaybeStackBuffer sourcebuf; MaybeLocal ret; Converter to(toEncoding); - size_t sublen = ucnv_getMinCharSize(to.conv()); - std::string sub(sublen, '?'); + std::string sub(to.min_char_size(), '?'); to.set_subst_chars(sub.c_str()); const size_t length_in_chars = source_length / sizeof(UChar); @@ -221,26 +218,18 @@ MaybeLocal TranscodeUcs2FromUtf8(Environment* env, const char* source, const size_t source_length, UErrorCode* status) { - *status = U_ZERO_ERROR; - MaybeStackBuffer destbuf; - int32_t result_length; - u_strFromUTF8(*destbuf, destbuf.capacity(), &result_length, - source, source_length, status); - MaybeLocal ret; - if (U_SUCCESS(*status)) { - destbuf.SetLength(result_length); - ret = ToBufferEndian(env, &destbuf); - } else if (*status == U_BUFFER_OVERFLOW_ERROR) { - *status = U_ZERO_ERROR; - destbuf.AllocateSufficientStorage(result_length); - u_strFromUTF8(*destbuf, result_length, &result_length, - source, source_length, status); - if (U_SUCCESS(*status)) { - destbuf.SetLength(result_length); - ret = ToBufferEndian(env, &destbuf); - } + size_t expected_utf16_length = + simdutf::utf16_length_from_utf8(source, source_length); + MaybeStackBuffer destbuf(expected_utf16_length); + auto actual_length = + simdutf::convert_utf8_to_utf16le(source, source_length, destbuf.out()); + + if (actual_length == 0) { + *status = U_INVALID_CHAR_FOUND; + return {}; } - return ret; + + return Buffer::New(env, &destbuf); } MaybeLocal TranscodeUtf8FromUcs2(Environment* env, @@ -249,32 +238,25 @@ MaybeLocal TranscodeUtf8FromUcs2(Environment* env, const char* source, const size_t source_length, UErrorCode* status) { - *status = U_ZERO_ERROR; - MaybeLocal ret; const size_t length_in_chars = source_length / sizeof(UChar); - int32_t result_length; - MaybeStackBuffer sourcebuf; - MaybeStackBuffer destbuf; - CopySourceBuffer(&sourcebuf, source, source_length, length_in_chars); - u_strToUTF8(*destbuf, destbuf.capacity(), &result_length, - *sourcebuf, length_in_chars, status); - if (U_SUCCESS(*status)) { - destbuf.SetLength(result_length); - ret = ToBufferEndian(env, &destbuf); - } else if (*status == U_BUFFER_OVERFLOW_ERROR) { - *status = U_ZERO_ERROR; - destbuf.AllocateSufficientStorage(result_length); - u_strToUTF8(*destbuf, result_length, &result_length, *sourcebuf, - length_in_chars, status); - if (U_SUCCESS(*status)) { - destbuf.SetLength(result_length); - ret = ToBufferEndian(env, &destbuf); - } + size_t expected_utf8_length = simdutf::utf8_length_from_utf16le( + reinterpret_cast(source), length_in_chars); + + MaybeStackBuffer destbuf(expected_utf8_length); + auto actual_length = simdutf::convert_utf16le_to_utf8( + reinterpret_cast(source), + length_in_chars, + destbuf.out()); + + if (actual_length == 0) { + *status = U_INVALID_CHAR_FOUND; + return {}; } - return ret; + + return Buffer::New(env, &destbuf); } -const char* EncodingName(const enum encoding encoding) { +constexpr const char* EncodingName(const enum encoding encoding) { switch (encoding) { case ASCII: return "us-ascii"; case LATIN1: return "iso8859-1"; @@ -284,7 +266,7 @@ const char* EncodingName(const enum encoding encoding) { } } -bool SupportedEncoding(const enum encoding encoding) { +constexpr bool SupportedEncoding(const enum encoding encoding) { switch (encoding) { case ASCII: case LATIN1: @@ -309,8 +291,7 @@ void Transcode(const FunctionCallbackInfo&args) { switch (fromEncoding) { case ASCII: case LATIN1: - if (toEncoding == UCS2) - tfn = &TranscodeToUcs2; + if (toEncoding == UCS2) tfn = &TranscodeLatin1ToUcs2; break; case UTF8: if (toEncoding == UCS2) From 1c29e74d304af0827514e8815f04080fc53bd254 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Tue, 20 Aug 2024 19:39:40 +0200 Subject: [PATCH 08/90] test_runner: make `mock.module`'s `specifier` consistent with `import()` The previous implementation was trying to follow both `require` and `import` conventions. It is not practical to try to follow both, and aligning with `import()` seems to be what makes the most sense. PR-URL: https://github.com/nodejs/node/pull/54416 Reviewed-By: Benjamin Gruenbaum Reviewed-By: Moshe Atlow --- doc/api/test.md | 2 +- lib/internal/test_runner/mock/mock.js | 9 ++-- test/parallel/test-runner-module-mocking.js | 59 +++++++++++---------- 3 files changed, 39 insertions(+), 31 deletions(-) diff --git a/doc/api/test.md b/doc/api/test.md index 9fb227b1b4e534..cafcd5f9389405 100644 --- a/doc/api/test.md +++ b/doc/api/test.md @@ -2040,7 +2040,7 @@ added: v22.3.0 > Stability: 1.0 - Early development -* `specifier` {string} A string identifying the module to mock. +* `specifier` {string|URL} A string identifying the module to mock. * `options` {Object} Optional configuration options for the mock module. The following properties are supported: * `cache` {boolean} If `false`, each call to `require()` or `import()` diff --git a/lib/internal/test_runner/mock/mock.js b/lib/internal/test_runner/mock/mock.js index 828f3e513f8e5f..a0de3d2dd41909 100644 --- a/lib/internal/test_runner/mock/mock.js +++ b/lib/internal/test_runner/mock/mock.js @@ -34,7 +34,7 @@ const { } = require('internal/errors'); const esmLoader = require('internal/modules/esm/loader'); const { getOptionValue } = require('internal/options'); -const { fileURLToPath, toPathIfFileURL, URL } = require('internal/url'); +const { fileURLToPath, toPathIfFileURL, URL, isURL } = require('internal/url'); const { emitExperimentalWarning, getStructuredStack, @@ -49,7 +49,6 @@ const { validateInteger, validateObject, validateOneOf, - validateString, } = require('internal/validators'); const { MockTimers } = require('internal/test_runner/mock/mock_timers'); const { strictEqual, notStrictEqual } = require('assert'); @@ -488,7 +487,11 @@ class MockTracker { module(specifier, options = kEmptyObject) { emitExperimentalWarning('Module mocking'); - validateString(specifier, 'specifier'); + if (typeof specifier !== 'string') { + if (!isURL(specifier)) + throw new ERR_INVALID_ARG_TYPE('specifier', ['string', 'URL'], specifier); + specifier = `${specifier}`; + } validateObject(options, 'options'); debug('module mock entry, specifier = "%s", options = %o', specifier, options); diff --git a/test/parallel/test-runner-module-mocking.js b/test/parallel/test-runner-module-mocking.js index 7e59c0d4dcde8b..a9a5c33a7c26b4 100644 --- a/test/parallel/test-runner-module-mocking.js +++ b/test/parallel/test-runner-module-mocking.js @@ -10,7 +10,7 @@ const fixtures = require('../common/fixtures'); const assert = require('node:assert'); const { relative } = require('node:path'); const { test } = require('node:test'); -const { fileURLToPath, pathToFileURL } = require('node:url'); +const { pathToFileURL } = require('node:url'); test('input validation', async (t) => { await t.test('throws if specifier is not a string', (t) => { @@ -154,7 +154,7 @@ test('CJS mocking with namedExports option', async (t) => { assert.strictEqual(original.string, 'original cjs string'); assert.strictEqual(original.fn, undefined); - t.mock.module(fixture, { + t.mock.module(pathToFileURL(fixture), { namedExports: { fn() { return 42; } }, }); const mocked = require(fixture); @@ -174,7 +174,7 @@ test('CJS mocking with namedExports option', async (t) => { assert.strictEqual(original.string, 'original cjs string'); assert.strictEqual(original.fn, undefined); - t.mock.module(fixture, { + t.mock.module(pathToFileURL(fixture), { namedExports: { fn() { return 42; } }, cache: true, }); @@ -195,7 +195,7 @@ test('CJS mocking with namedExports option', async (t) => { assert.strictEqual(original.string, 'original cjs string'); assert.strictEqual(original.fn, undefined); - t.mock.module(fixture, { + t.mock.module(pathToFileURL(fixture), { namedExports: { fn() { return 42; } }, cache: false, }); @@ -219,7 +219,7 @@ test('CJS mocking with namedExports option', async (t) => { const defaultExport = { val1: 5, val2: 3 }; - t.mock.module(fixture, { + t.mock.module(pathToFileURL(fixture), { defaultExport, namedExports: { val1: 'mock value' }, }); @@ -242,7 +242,7 @@ test('CJS mocking with namedExports option', async (t) => { const defaultExport = null; - t.mock.module(fixture, { + t.mock.module(pathToFileURL(fixture), { defaultExport, namedExports: { val1: 'mock value' }, }); @@ -256,7 +256,7 @@ test('CJS mocking with namedExports option', async (t) => { test('ESM mocking with namedExports option', async (t) => { await t.test('does not cache by default', async (t) => { - const fixture = fixtures.path('module-mocking', 'basic-esm.mjs'); + const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs'); const original = await import(fixture); assert.strictEqual(original.string, 'original esm string'); @@ -276,7 +276,7 @@ test('ESM mocking with namedExports option', async (t) => { }); await t.test('explicitly enables caching', async (t) => { - const fixture = fixtures.path('module-mocking', 'basic-esm.mjs'); + const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs'); const original = await import(fixture); assert.strictEqual(original.string, 'original esm string'); @@ -297,7 +297,7 @@ test('ESM mocking with namedExports option', async (t) => { }); await t.test('explicitly disables caching', async (t) => { - const fixture = fixtures.path('module-mocking', 'basic-esm.mjs'); + const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs'); const original = await import(fixture); assert.strictEqual(original.string, 'original esm string'); @@ -318,7 +318,8 @@ test('ESM mocking with namedExports option', async (t) => { }); await t.test('named exports are not applied to defaultExport', async (t) => { - const fixture = fixtures.path('module-mocking', 'basic-esm.mjs'); + const fixturePath = fixtures.path('module-mocking', 'basic-esm.mjs'); + const fixture = pathToFileURL(fixturePath); const original = await import(fixture); assert.strictEqual(original.string, 'original esm string'); @@ -338,11 +339,11 @@ test('ESM mocking with namedExports option', async (t) => { assert.strictEqual(mocked.default, 'mock default'); assert.strictEqual(mocked.val1, 'mock value'); t.mock.reset(); - common.expectRequiredModule(require(fixture), original); + common.expectRequiredModule(require(fixturePath), original); }); await t.test('throws if named exports cannot be applied to defaultExport as CJS', async (t) => { - const fixture = fixtures.path('module-mocking', 'basic-cjs.js'); + const fixture = fixtures.fileURL('module-mocking', 'basic-cjs.js'); const original = await import(fixture); assert.strictEqual(original.default.string, 'original cjs string'); @@ -366,13 +367,14 @@ test('ESM mocking with namedExports option', async (t) => { test('modules cannot be mocked multiple times at once', async (t) => { await t.test('CJS', async (t) => { const fixture = fixtures.path('module-mocking', 'basic-cjs.js'); + const fixtureURL = pathToFileURL(fixture).href; - t.mock.module(fixture, { + t.mock.module(fixtureURL, { namedExports: { fn() { return 42; } }, }); assert.throws(() => { - t.mock.module(fixture, { + t.mock.module(fixtureURL, { namedExports: { fn() { return 55; } }, }); }, { @@ -386,7 +388,7 @@ test('modules cannot be mocked multiple times at once', async (t) => { }); await t.test('ESM', async (t) => { - const fixture = fixtures.path('module-mocking', 'basic-esm.mjs'); + const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs').href; t.mock.module(fixture, { namedExports: { fn() { return 42; } }, @@ -409,10 +411,10 @@ test('modules cannot be mocked multiple times at once', async (t) => { test('mocks are automatically restored', async (t) => { const cjsFixture = fixtures.path('module-mocking', 'basic-cjs.js'); - const esmFixture = fixtures.path('module-mocking', 'basic-esm.mjs'); + const esmFixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs'); await t.test('CJS', async (t) => { - t.mock.module(cjsFixture, { + t.mock.module(pathToFileURL(cjsFixture), { namedExports: { fn() { return 42; } }, }); @@ -442,9 +444,9 @@ test('mocks are automatically restored', async (t) => { test('mocks can be restored independently', async (t) => { const cjsFixture = fixtures.path('module-mocking', 'basic-cjs.js'); - const esmFixture = fixtures.path('module-mocking', 'basic-esm.mjs'); + const esmFixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs'); - const cjsMock = t.mock.module(cjsFixture, { + const cjsMock = t.mock.module(pathToFileURL(cjsFixture), { namedExports: { fn() { return 42; } }, }); @@ -511,10 +513,11 @@ test('node:- core module mocks can be used by both module systems', async (t) => test('CJS mocks can be used by both module systems', async (t) => { const cjsFixture = fixtures.path('module-mocking', 'basic-cjs.js'); - const cjsMock = t.mock.module(cjsFixture, { + const cjsFixtureURL = pathToFileURL(cjsFixture); + const cjsMock = t.mock.module(cjsFixtureURL, { namedExports: { fn() { return 42; } }, }); - let esmImpl = await import(pathToFileURL(cjsFixture)); + let esmImpl = await import(cjsFixtureURL); let cjsImpl = require(cjsFixture); assert.strictEqual(esmImpl.fn(), 42); @@ -522,7 +525,7 @@ test('CJS mocks can be used by both module systems', async (t) => { cjsMock.restore(); - esmImpl = await import(pathToFileURL(cjsFixture)); + esmImpl = await import(cjsFixtureURL); cjsImpl = require(cjsFixture); assert.strictEqual(esmImpl.default.string, 'original cjs string'); @@ -532,7 +535,7 @@ test('CJS mocks can be used by both module systems', async (t) => { test('relative paths can be used by both module systems', async (t) => { const fixture = relative( __dirname, fixtures.path('module-mocking', 'basic-esm.mjs') - ); + ).replaceAll('\\', '/'); const mock = t.mock.module(fixture, { namedExports: { fn() { return 42; } }, }); @@ -597,24 +600,26 @@ test('mocked modules do not impact unmocked modules', async (t) => { test('defaultExports work with CJS mocks in both module systems', async (t) => { const fixture = fixtures.path('module-mocking', 'basic-cjs.js'); + const fixtureURL = pathToFileURL(fixture); const original = require(fixture); const defaultExport = Symbol('default'); assert.strictEqual(original.string, 'original cjs string'); - t.mock.module(fixture, { defaultExport }); + t.mock.module(fixtureURL, { defaultExport }); assert.strictEqual(require(fixture), defaultExport); - assert.strictEqual((await import(pathToFileURL(fixture))).default, defaultExport); + assert.strictEqual((await import(fixtureURL)).default, defaultExport); }); test('defaultExports work with ESM mocks in both module systems', async (t) => { - const fixture = fixtures.fileURL('module-mocking', 'basic-esm.mjs'); + const fixturePath = fixtures.path('module-mocking', 'basic-esm.mjs'); + const fixture = pathToFileURL(fixturePath); const original = await import(fixture); const defaultExport = Symbol('default'); assert.strictEqual(original.string, 'original esm string'); t.mock.module(`${fixture}`, { defaultExport }); assert.strictEqual((await import(fixture)).default, defaultExport); - assert.strictEqual(require(fileURLToPath(fixture)), defaultExport); + assert.strictEqual(require(fixturePath), defaultExport); }); test('wrong import syntax should throw error after module mocking.', async () => { From 336496b90e567ea35840473f2f90facb2027d4a2 Mon Sep 17 00:00:00 2001 From: Chengzhong Wu Date: Tue, 20 Aug 2024 20:45:17 +0100 Subject: [PATCH 09/90] module: add sourceURL magic comment hinting generated source Source map is not necessary in strip-only mode. However, to map the source file in debuggers to the original TypeScript source, add a sourceURL magic comment to hint that it is a generated source. PR-URL: https://github.com/nodejs/node/pull/54402 Reviewed-By: Antoine du Hamel Reviewed-By: Kohei Ueno Reviewed-By: Marco Ippolito Reviewed-By: Matteo Collina --- lib/internal/modules/helpers.js | 5 ++- test/common/inspector-helper.js | 8 ++++ test/parallel/test-inspector-strip-types.js | 43 +++++++++++++++++++++ 3 files changed, 55 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-inspector-strip-types.js diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js index 890d851f5bd88f..729a33e04f34cd 100644 --- a/lib/internal/modules/helpers.js +++ b/lib/internal/modules/helpers.js @@ -371,7 +371,10 @@ function stripTypeScriptTypes(source, filename) { const base64SourceMap = Buffer.from(map).toString('base64'); return `${code}\n\n//# sourceMappingURL=data:application/json;base64,${base64SourceMap}`; } - return code; + // Source map is not necessary in strip-only mode. However, to map the source + // file in debuggers to the original TypeScript source, add a sourceURL magic + // comment to hint that it is a generated source. + return `${code}\n\n//# sourceURL=${filename}`; } function isUnderNodeModules(filename) { diff --git a/test/common/inspector-helper.js b/test/common/inspector-helper.js index 4890fa68c46110..9d5e3b15aece4b 100644 --- a/test/common/inspector-helper.js +++ b/test/common/inspector-helper.js @@ -271,6 +271,14 @@ class InspectorSession { `break on ${url}:${line}`); } + waitForPauseOnStart() { + return this + .waitForNotification( + (notification) => + notification.method === 'Debugger.paused' && notification.params.reason === 'Break on start', + 'break on start'); + } + pausedDetails() { return this._pausedDetails; } diff --git a/test/parallel/test-inspector-strip-types.js b/test/parallel/test-inspector-strip-types.js new file mode 100644 index 00000000000000..68e2463d530e8f --- /dev/null +++ b/test/parallel/test-inspector-strip-types.js @@ -0,0 +1,43 @@ +'use strict'; + +const common = require('../common'); +common.skipIfInspectorDisabled(); +if (!process.config.variables.node_use_amaro) common.skip('Requires Amaro'); + +const { NodeInstance } = require('../common/inspector-helper.js'); +const fixtures = require('../common/fixtures'); +const assert = require('assert'); + +const scriptPath = fixtures.path('typescript/ts/test-typescript.ts'); + +async function runTest() { + const child = new NodeInstance( + ['--inspect-brk=0', '--experimental-strip-types'], + undefined, + scriptPath); + + const session = await child.connectInspectorSession(); + + const commands = [ + { 'method': 'Debugger.enable' }, + { 'method': 'Runtime.enable' }, + { 'method': 'Runtime.runIfWaitingForDebugger' }, + ]; + + await session.send(commands); + + const scriptParsed = await session.waitForNotification((notification) => { + if (notification.method !== 'Debugger.scriptParsed') return false; + + return notification.params.url === scriptPath; + }); + // Verify that the script has a sourceURL, hinting that it is a generated source. + assert(scriptParsed.params.hasSourceURL); + + await session.waitForPauseOnStart(); + await session.runToCompletion(); + + assert.strictEqual((await child.expectShutdown()).exitCode, 0); +} + +runTest().then(common.mustCall()); From 45b02506924686ac8cb9ce63aa1a260ab5fb6562 Mon Sep 17 00:00:00 2001 From: Colin Ihrig Date: Tue, 20 Aug 2024 22:38:55 -0400 Subject: [PATCH 10/90] test_runner: account for newline in source maps This commit updates the source mapping logic in the test runner to account for newline characters that are not included in line length calculations. Co-authored-by: Simon Chan <1330321+yume-chan@users.noreply.github.com> Fixes: https://github.com/nodejs/node/issues/54240 PR-URL: https://github.com/nodejs/node/pull/54444 Reviewed-By: Jake Yuesong Li Reviewed-By: Matteo Collina Reviewed-By: Benjamin Gruenbaum Reviewed-By: Moshe Atlow --- lib/internal/test_runner/coverage.js | 4 +- .../source-map-line-lengths/index.js | 77 +++++++++++++++++++ .../source-map-line-lengths/index.js.map | 7 ++ .../source-map-line-lengths/index.ts | 76 ++++++++++++++++++ test/parallel/test-runner-coverage.js | 13 ++++ 5 files changed, 175 insertions(+), 2 deletions(-) create mode 100644 test/fixtures/test-runner/source-map-line-lengths/index.js create mode 100644 test/fixtures/test-runner/source-map-line-lengths/index.js.map create mode 100644 test/fixtures/test-runner/source-map-line-lengths/index.ts diff --git a/lib/internal/test_runner/coverage.js b/lib/internal/test_runner/coverage.js index b97965235e7d47..7d78bd69886566 100644 --- a/lib/internal/test_runner/coverage.js +++ b/lib/internal/test_runner/coverage.js @@ -340,8 +340,8 @@ class TestCoverage { const { data, lineLengths } = sourceMapCache[url]; let offset = 0; const executedLines = ArrayPrototypeMap(lineLengths, (length, i) => { - const coverageLine = new CoverageLine(i + 1, offset, null, length); - offset += length; + const coverageLine = new CoverageLine(i + 1, offset, null, length + 1); + offset += length + 1; return coverageLine; }); if (data.sourcesContent != null) { diff --git a/test/fixtures/test-runner/source-map-line-lengths/index.js b/test/fixtures/test-runner/source-map-line-lengths/index.js new file mode 100644 index 00000000000000..ff63423bfb3c8b --- /dev/null +++ b/test/fixtures/test-runner/source-map-line-lengths/index.js @@ -0,0 +1,77 @@ +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +function a() { + console.log(1); +} +a(); +//# sourceMappingURL=index.js.map diff --git a/test/fixtures/test-runner/source-map-line-lengths/index.js.map b/test/fixtures/test-runner/source-map-line-lengths/index.js.map new file mode 100644 index 00000000000000..ace65dc3ccdd14 --- /dev/null +++ b/test/fixtures/test-runner/source-map-line-lengths/index.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["index.ts"], + "sourcesContent": ["1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\n1;\nfunction a() {\n console.log(1);\n}\na();\n"], + "mappings": "AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI;AACX,UAAQ,IAAI,CAAC;AACf;AACA,EAAE;", + "names": [] +} diff --git a/test/fixtures/test-runner/source-map-line-lengths/index.ts b/test/fixtures/test-runner/source-map-line-lengths/index.ts new file mode 100644 index 00000000000000..0eee24b0c75e45 --- /dev/null +++ b/test/fixtures/test-runner/source-map-line-lengths/index.ts @@ -0,0 +1,76 @@ +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +1; +function a() { + console.log(1); +} +a(); diff --git a/test/parallel/test-runner-coverage.js b/test/parallel/test-runner-coverage.js index 1283232a867246..8a6cb392de2585 100644 --- a/test/parallel/test-runner-coverage.js +++ b/test/parallel/test-runner-coverage.js @@ -428,3 +428,16 @@ test('coverage with included and excluded files', skipIfNoInspector, () => { assert.strictEqual(result.status, 0); assert(!findCoverageFileForPid(result.pid)); }); + +test('properly accounts for line endings in source maps', skipIfNoInspector, () => { + const fixture = fixtures.path('test-runner', 'source-map-line-lengths', 'index.js'); + const args = [ + '--test', '--experimental-test-coverage', '--test-reporter', 'tap', + fixture, + ]; + const result = spawnSync(process.execPath, args); + const report = 'index.ts | 100.00 | 100.00 | 100.00 |'; + assert.strictEqual(result.stderr.toString(), ''); + assert(result.stdout.toString().includes(report)); + assert.strictEqual(result.status, 0); +}); From 858b583c881ef1f2efc5742580a497368c0f11ee Mon Sep 17 00:00:00 2001 From: cjihrig Date: Fri, 19 Jul 2024 14:56:35 -0400 Subject: [PATCH 11/90] test_runner: defer inheriting hooks until run() This commit updates the way the test runner computes inherited hooks. Instead of computing them when the Test/Suite is constructed, they are now computed just prior to running the Test/Suite. The reason is because when multiple test files are run in the same process, it is possible for the inherited hooks to change as more files are loaded. PR-URL: https://github.com/nodejs/node/pull/53927 Fixes: https://github.com/nodejs/node/issues/51548 Reviewed-By: Benjamin Gruenbaum Reviewed-By: Matteo Collina --- lib/internal/test_runner/test.js | 42 +++++++++++++++++++------------- 1 file changed, 25 insertions(+), 17 deletions(-) diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js index b79ff7a049ea6c..8d07d273653721 100644 --- a/lib/internal/test_runner/test.js +++ b/lib/internal/test_runner/test.js @@ -408,14 +408,6 @@ class Test extends AsyncResource { this.childNumber = 0; this.timeout = kDefaultTimeout; this.entryFile = entryFile; - this.hooks = { - __proto__: null, - before: [], - after: [], - beforeEach: [], - afterEach: [], - ownAfterEachCount: 0, - }; } else { const nesting = parent.parent === null ? parent.nesting : parent.nesting + 1; @@ -431,14 +423,6 @@ class Test extends AsyncResource { this.childNumber = parent.subtests.length + 1; this.timeout = parent.timeout; this.entryFile = parent.entryFile; - this.hooks = { - __proto__: null, - before: [], - after: [], - beforeEach: ArrayPrototypeSlice(parent.hooks.beforeEach), - afterEach: ArrayPrototypeSlice(parent.hooks.afterEach), - ownAfterEachCount: 0, - }; if (this.willBeFiltered()) { this.filtered = true; @@ -514,6 +498,14 @@ class Test extends AsyncResource { this.subtests = []; this.waitingOn = 0; this.finished = false; + this.hooks = { + __proto__: null, + before: [], + after: [], + beforeEach: [], + afterEach: [], + ownAfterEachCount: 0, + }; if (!this.config.only && (only || this.parent?.runOnlySubtests)) { const warning = @@ -691,6 +683,21 @@ class Test extends AsyncResource { this.abortController.abort(); } + computeInheritedHooks() { + if (this.parent.hooks.beforeEach.length > 0) { + ArrayPrototypeUnshift( + this.hooks.beforeEach, + ...ArrayPrototypeSlice(this.parent.hooks.beforeEach), + ); + } + + if (this.parent.hooks.afterEach.length > 0) { + ArrayPrototypePushApply( + this.hooks.afterEach, ArrayPrototypeSlice(this.parent.hooks.afterEach), + ); + } + } + createHook(name, fn, options) { validateOneOf(name, 'hook name', kHookNames); // eslint-disable-next-line no-use-before-define @@ -715,7 +722,6 @@ class Test extends AsyncResource { } else { ArrayPrototypePush(this.hooks[name], hook); } - return hook; } fail(err) { @@ -817,6 +823,7 @@ class Test extends AsyncResource { async run() { if (this.parent !== null) { this.parent.activeSubtests++; + this.computeInheritedHooks(); } this.startTime ??= hrtime(); @@ -1211,6 +1218,7 @@ class Suite extends Test { } async run() { + this.computeInheritedHooks(); const hookArgs = this.getRunArgs(); let stopPromise; From 97fa075c2eb08a4229e1264d8842eac0490e4e40 Mon Sep 17 00:00:00 2001 From: cjihrig Date: Sat, 13 Jul 2024 11:10:59 -0400 Subject: [PATCH 12/90] test_runner: support running tests in process This commit introduces a new --experimental-test-isolation flag that, when set to 'none', causes the test runner to execute all tests in the same process. By default, this is the main test runner process, but if watch mode is enabled, it spawns a separate process that runs all of the tests. The default value of the new flag is 'process', which uses the existing behavior of running each test file in its own child process. It is worth noting that when the isolation mode is 'none', globals and all other top level logic (such as top level before() and after() hooks) is shared among all files. Co-authored-by: Moshe Atlow PR-URL: https://github.com/nodejs/node/pull/53927 Fixes: https://github.com/nodejs/node/issues/51548 Reviewed-By: Benjamin Gruenbaum Reviewed-By: Matteo Collina --- doc/api/cli.md | 21 +- doc/api/test.md | 40 ++- doc/node.1 | 3 + lib/internal/main/test_runner.js | 2 +- lib/internal/test_runner/harness.js | 1 + lib/internal/test_runner/runner.js | 196 ++++++++++--- lib/internal/test_runner/utils.js | 31 +- src/env-inl.h | 3 +- src/node_options.cc | 21 +- src/node_options.h | 1 + .../test-runner/no-isolation/one.test.js | 32 +++ .../test-runner/no-isolation/two.test.js | 30 ++ test/fixtures/test-runner/snapshots/unit-2.js | 11 + test/parallel/test-runner-cli-concurrency.js | 14 + test/parallel/test-runner-cli-timeout.js | 8 + test/parallel/test-runner-cli.js | 271 ++++++++++-------- test/parallel/test-runner-coverage.js | 38 +++ .../test-runner-extraneous-async-activity.js | 18 ++ .../test-runner-force-exit-failure.js | 23 +- .../test-runner-no-isolation-filtering.js | 69 +++++ test/parallel/test-runner-no-isolation.mjs | 47 +++ test/parallel/test-runner-snapshot-tests.js | 72 +++++ 22 files changed, 746 insertions(+), 206 deletions(-) create mode 100644 test/fixtures/test-runner/no-isolation/one.test.js create mode 100644 test/fixtures/test-runner/no-isolation/two.test.js create mode 100644 test/fixtures/test-runner/snapshots/unit-2.js create mode 100644 test/parallel/test-runner-no-isolation-filtering.js create mode 100644 test/parallel/test-runner-no-isolation.mjs diff --git a/doc/api/cli.md b/doc/api/cli.md index 3aa5eff9ce1aec..33b9e1ce00b9b6 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -1081,6 +1081,20 @@ generated as part of the test runner output. If no tests are run, a coverage report is not generated. See the documentation on [collecting code coverage from tests][] for more details. +### `--experimental-test-isolation=mode` + + + +> Stability: 1.0 - Early development + +Configures the type of test isolation used in the test runner. When `mode` is +`'process'`, each test file is run in a separate child process. When `mode` is +`'none'`, all test files run in the same process as the test runner. The default +isolation mode is `'process'`. This flag is ignored if the `--test` flag is not +present. See the [test runner execution model][] section for more information. + ### `--experimental-test-module-mocks` The maximum number of test files that the test runner CLI will execute -concurrently. The default value is `os.availableParallelism() - 1`. +concurrently. If `--experimental-test-isolation` is set to `'none'`, this flag +is ignored and concurrency is one. Otherwise, concurrency defaults to +`os.availableParallelism() - 1`. ### `--test-coverage-exclude` @@ -2363,7 +2379,7 @@ added: v22.3.0 > Stability: 1.0 - Early development -Regenerates the snapshot file used by the test runner for [snapshot testing][]. +Regenerates the snapshot files used by the test runner for [snapshot testing][]. Node.js must be started with the `--experimental-test-snapshots` flag in order to use this functionality. @@ -3573,6 +3589,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12 [snapshot testing]: test.md#snapshot-testing [syntax detection]: packages.md#syntax-detection [test reporters]: test.md#test-reporters +[test runner execution model]: test.md#test-runner-execution-model [timezone IDs]: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones [tracking issue for user-land snapshots]: https://github.com/nodejs/node/issues/44014 [ways that `TZ` is handled in other environments]: https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html diff --git a/doc/api/test.md b/doc/api/test.md index cafcd5f9389405..8cb53b1363923f 100644 --- a/doc/api/test.md +++ b/doc/api/test.md @@ -445,18 +445,26 @@ in the [test runner execution model][] section. ### Test runner execution model -Each matching test file is executed in a separate child process. The maximum -number of child processes running at any time is controlled by the -[`--test-concurrency`][] flag. If the child process finishes with an exit code -of 0, the test is considered passing. Otherwise, the test is considered to be a -failure. Test files must be executable by Node.js, but are not required to use -the `node:test` module internally. +When process-level test isolation is enabled, each matching test file is +executed in a separate child process. The maximum number of child processes +running at any time is controlled by the [`--test-concurrency`][] flag. If the +child process finishes with an exit code of 0, the test is considered passing. +Otherwise, the test is considered to be a failure. Test files must be executable +by Node.js, but are not required to use the `node:test` module internally. Each test file is executed as if it was a regular script. That is, if the test file itself uses `node:test` to define tests, all of those tests will be executed within a single application thread, regardless of the value of the `concurrency` option of [`test()`][]. +When process-level test isolation is disabled, each matching test file is +imported into the test runner process. Once all test files have been loaded, the +top level tests are executed with a concurrency of one. Because the test files +are all run within the same context, it is possible for tests to interact with +each other in ways that are not possible when isolation is enabled. For example, +if a test relies on global state, it is possible for that state to be modified +by a test originating from another file. + ## Collecting code coverage > Stability: 1 - Experimental @@ -933,7 +941,7 @@ the [`--experimental-test-snapshots`][] command-line flag. Snapshot files are generated by starting Node.js with the [`--test-update-snapshots`][] command-line flag. A separate snapshot file is generated for each test file. By default, the snapshot file has the same name -as `process.argv[1]` with a `.snapshot` file extension. This behavior can be +as the test file with a `.snapshot` file extension. This behavior can be configured using the `snapshot.setResolveSnapshotPath()` function. Each snapshot assertion corresponds to an export in the snapshot file. @@ -1239,6 +1247,9 @@ added: - v18.9.0 - v16.19.0 changes: + - version: REPLACEME + pr-url: https://github.com/nodejs/node/pull/53927 + description: Added the `isolation` option. - version: v22.6.0 pr-url: https://github.com/nodejs/node/pull/53866 description: Added the `globPatterns` option. @@ -1272,8 +1283,13 @@ changes: * `inspectPort` {number|Function} Sets inspector port of test child process. This can be a number, or a function that takes no arguments and returns a number. If a nullish value is provided, each process gets its own port, - incremented from the primary's `process.debugPort`. - **Default:** `undefined`. + incremented from the primary's `process.debugPort`. This option is ignored + if the `isolation` option is set to `'none'` as no child processes are + spawned. **Default:** `undefined`. + * `isolation` {string} Configures the type of test isolation. If set to + `'process'`, each test file is run in a separate child process. If set to + `'none'`, all test files run in the current process. **Default:** + `'process'`. * `only`: {boolean} If truthy, the test context will only run tests that have the `only` option set * `setup` {Function} A function that accepts the `TestsStream` instance @@ -1717,9 +1733,9 @@ added: v22.3.0 * `fn` {Function} A function used to compute the location of the snapshot file. The function receives the path of the test file as its only argument. If the - `process.argv[1]` is not associated with a file (for example in the REPL), - the input is undefined. `fn()` must return a string specifying the location of - the snapshot file. + test is not associated with a file (for example in the REPL), the input is + undefined. `fn()` must return a string specifying the location of the snapshot + snapshot file. This function is used to customize the location of the snapshot file used for snapshot testing. By default, the snapshot filename is the same as the entry diff --git a/doc/node.1 b/doc/node.1 index a9a98870308024..fa5d7f79c46d55 100644 --- a/doc/node.1 +++ b/doc/node.1 @@ -185,6 +185,9 @@ Enable the experimental node:sqlite module. .It Fl -experimental-test-coverage Enable code coverage in the test runner. . +.It Fl -experimental-test-isolation Ns = Ns Ar mode +Configures the type of test isolation used in the test runner. +. .It Fl -experimental-test-module-mocks Enable module mocking in the test runner. . diff --git a/lib/internal/main/test_runner.js b/lib/internal/main/test_runner.js index cc853da7388821..b1f69b07771ac6 100644 --- a/lib/internal/main/test_runner.js +++ b/lib/internal/main/test_runner.js @@ -21,7 +21,7 @@ markBootstrapComplete(); const options = parseCommandLine(); -if (isUsingInspector()) { +if (isUsingInspector() && options.isolation === 'process') { process.emitWarning('Using the inspector with --test forces running at a concurrency of 1. ' + 'Use the inspectPort option to run with concurrency'); options.concurrency = 1; diff --git a/lib/internal/test_runner/harness.js b/lib/internal/test_runner/harness.js index 3c56820cf4e247..1bc6cddabd41a0 100644 --- a/lib/internal/test_runner/harness.js +++ b/lib/internal/test_runner/harness.js @@ -334,4 +334,5 @@ module.exports = { after: hook('after'), beforeEach: hook('beforeEach'), afterEach: hook('afterEach'), + startSubtestAfterBootstrap, }; diff --git a/lib/internal/test_runner/runner.js b/lib/internal/test_runner/runner.js index a4874d5caead91..b5431221b4ebd9 100644 --- a/lib/internal/test_runner/runner.js +++ b/lib/internal/test_runner/runner.js @@ -11,6 +11,7 @@ const { ArrayPrototypeMap, ArrayPrototypePush, ArrayPrototypeShift, + ArrayPrototypeSlice, ArrayPrototypeSome, ArrayPrototypeSort, ObjectAssign, @@ -24,6 +25,7 @@ const { StringPrototypeIndexOf, StringPrototypeSlice, StringPrototypeStartsWith, + Symbol, TypedArrayPrototypeGetLength, TypedArrayPrototypeSubarray, } = primordials; @@ -44,18 +46,28 @@ const { ERR_TEST_FAILURE, }, } = require('internal/errors'); +const esmLoader = require('internal/modules/esm/loader'); const { validateArray, validateBoolean, validateFunction, validateObject, + validateOneOf, validateInteger, } = require('internal/validators'); const { getInspectPort, isUsingInspector, isInspectorMessage } = require('internal/util/inspector'); const { isRegExp } = require('internal/util/types'); -const { kEmptyObject } = require('internal/util'); +const { pathToFileURL } = require('internal/url'); +const { + createDeferredPromise, + getCWDURL, + kEmptyObject, +} = require('internal/util'); const { kEmitMessage } = require('internal/test_runner/tests_stream'); -const { createTestTree } = require('internal/test_runner/harness'); +const { + createTestTree, + startSubtestAfterBootstrap, +} = require('internal/test_runner/harness'); const { kAborted, kCancelledByParent, @@ -77,7 +89,11 @@ const { triggerUncaughtException, exitCodes: { kGenericUserError }, } = internalBinding('errors'); +let debug = require('internal/util/debuglog').debuglog('test_runner', (fn) => { + debug = fn; +}); +const kIsolatedProcessName = Symbol('kIsolatedProcessName'); const kFilterArgs = ['--test', '--experimental-test-coverage', '--watch']; const kFilterArgValues = ['--test-reporter', '--test-reporter-destination']; const kDiagnosticsFilterArgs = ['tests', 'suites', 'pass', 'fail', 'cancelled', 'skipped', 'todo', 'duration_ms']; @@ -130,7 +146,12 @@ function getRunArgs(path, { forceExit, inspectPort, testNamePatterns, testSkipPa if (only === true) { ArrayPrototypePush(argv, '--test-only'); } - ArrayPrototypePush(argv, path); + + if (path === kIsolatedProcessName) { + ArrayPrototypePush(argv, '--test', ...ArrayPrototypeSlice(process.argv, 1)); + } else { + ArrayPrototypePush(argv, path); + } return argv; } @@ -326,7 +347,9 @@ class FileTest extends Test { function runTestFile(path, filesWatcher, opts) { const watchMode = filesWatcher != null; - const subtest = opts.root.createSubtest(FileTest, path, { __proto__: null, signal: opts.signal }, async (t) => { + const testPath = path === kIsolatedProcessName ? '' : path; + const testOpts = { __proto__: null, signal: opts.signal }; + const subtest = opts.root.createSubtest(FileTest, testPath, testOpts, async (t) => { const args = getRunArgs(path, opts); const stdio = ['pipe', 'pipe', 'pipe']; const env = { __proto__: null, ...process.env, NODE_TEST_CONTEXT: 'child-v8' }; @@ -418,10 +441,23 @@ function watchFiles(testFiles, opts) { const filesWatcher = { __proto__: null, watcher, runningProcesses, runningSubtests }; opts.root.harness.watching = true; + async function restartTestFile(file) { + const runningProcess = runningProcesses.get(file); + if (runningProcess) { + runningProcess.kill(); + await once(runningProcess, 'exit'); + } + if (!runningSubtests.size) { + // Reset the topLevel counter + opts.root.harness.counters.topLevel = 0; + } + await runningSubtests.get(file); + runningSubtests.set(file, runTestFile(file, filesWatcher, opts)); + } + watcher.on('changed', ({ owners, eventType }) => { if (!opts.hasFiles && eventType === 'rename') { const updatedTestFiles = createTestFileList(opts.globPatterns); - const newFileName = ArrayPrototypeFind(updatedTestFiles, (x) => !ArrayPrototypeIncludes(testFiles, x)); const previousFileName = ArrayPrototypeFind(testFiles, (x) => !ArrayPrototypeIncludes(updatedTestFiles, x)); @@ -439,25 +475,22 @@ function watchFiles(testFiles, opts) { } - watcher.unfilterFilesOwnedBy(owners); - PromisePrototypeThen(SafePromiseAllReturnVoid(testFiles, async (file) => { - if (!owners.has(file)) { - return; - } - const runningProcess = runningProcesses.get(file); - if (runningProcess) { - runningProcess.kill(); - await once(runningProcess, 'exit'); - } - if (!runningSubtests.size) { - // Reset the topLevel counter - opts.root.harness.counters.topLevel = 0; - } - await runningSubtests.get(file); - runningSubtests.set(file, runTestFile(file, filesWatcher, opts)); - }, undefined, (error) => { - triggerUncaughtException(error, true /* fromPromise */); - })); + if (opts.isolation === 'none') { + PromisePrototypeThen(restartTestFile(kIsolatedProcessName), undefined, (error) => { + triggerUncaughtException(error, true /* fromPromise */); + }); + } else { + watcher.unfilterFilesOwnedBy(owners); + PromisePrototypeThen(SafePromiseAllReturnVoid(testFiles, async (file) => { + if (!owners.has(file)) { + return; + } + + await restartTestFile(file); + }, undefined, (error) => { + triggerUncaughtException(error, true /* fromPromise */); + })); + } }); if (opts.signal) { kResistStopPropagation ??= require('internal/event_target').kResistStopPropagation; @@ -485,6 +518,7 @@ function run(options = kEmptyObject) { files, forceExit, inspectPort, + isolation = 'process', watch, setup, only, @@ -566,6 +600,7 @@ function run(options = kEmptyObject) { throw new ERR_INVALID_ARG_TYPE(name, ['string', 'RegExp'], value); }); } + validateOneOf(isolation, 'options.isolation', ['process', 'none']); const rootTestOptions = { __proto__: null, concurrency, timeout, signal }; const globalOptions = { @@ -576,21 +611,16 @@ function run(options = kEmptyObject) { setup, // This line can be removed when parseCommandLine() is removed here. }; const root = createTestTree(rootTestOptions, globalOptions); - - if (process.env.NODE_TEST_CONTEXT !== undefined) { - process.emitWarning('node:test run() is being called recursively within a test file. skipping running files.'); - root.postRun(); - return root.reporter; - } let testFiles = files ?? createTestFileList(globPatterns); if (shard) { testFiles = ArrayPrototypeFilter(testFiles, (_, index) => index % shard.total === shard.index - 1); } - let postRun = () => root.postRun(); - let teardown = () => root.harness.teardown(); + let teardown; + let postRun; let filesWatcher; + let runFiles; const opts = { __proto__: null, root, @@ -602,21 +632,95 @@ function run(options = kEmptyObject) { globPatterns, only, forceExit, + isolation, }; - if (watch) { - filesWatcher = watchFiles(testFiles, opts); - postRun = undefined; - teardown = undefined; - } - const runFiles = () => { - root.harness.bootstrapPromise = null; - root.harness.buildPromise = null; - return SafePromiseAllSettledReturnVoid(testFiles, (path) => { - const subtest = runTestFile(path, filesWatcher, opts); - filesWatcher?.runningSubtests.set(path, subtest); - return subtest; - }); - }; + + if (isolation === 'process') { + if (process.env.NODE_TEST_CONTEXT !== undefined) { + process.emitWarning('node:test run() is being called recursively within a test file. skipping running files.'); + root.postRun(); + return root.reporter; + } + + if (watch) { + filesWatcher = watchFiles(testFiles, opts); + } else { + postRun = () => root.postRun(); + teardown = () => root.harness.teardown(); + } + + runFiles = () => { + root.harness.bootstrapPromise = null; + root.harness.buildPromise = null; + return SafePromiseAllSettledReturnVoid(testFiles, (path) => { + const subtest = runTestFile(path, filesWatcher, opts); + filesWatcher?.runningSubtests.set(path, subtest); + return subtest; + }); + }; + } else if (isolation === 'none') { + if (watch) { + filesWatcher = watchFiles(testFiles, opts); + runFiles = async () => { + root.harness.bootstrapPromise = null; + root.harness.buildPromise = null; + const subtest = runTestFile(kIsolatedProcessName, filesWatcher, opts); + filesWatcher?.runningSubtests.set(kIsolatedProcessName, subtest); + return subtest; + }; + } else { + runFiles = async () => { + const { promise, resolve: finishBootstrap } = createDeferredPromise(); + + await root.runInAsyncScope(async () => { + const parentURL = getCWDURL().href; + const cascadedLoader = esmLoader.getOrInitializeCascadedLoader(); + let topLevelTestCount = 0; + + root.harness.bootstrapPromise = promise; + + for (let i = 0; i < testFiles.length; ++i) { + const testFile = testFiles[i]; + const fileURL = pathToFileURL(testFile); + const parent = i === 0 ? undefined : parentURL; + let threw = false; + let importError; + + root.entryFile = resolve(testFile); + debug('loading test file:', fileURL.href); + try { + await cascadedLoader.import(fileURL, parent, { __proto__: null }); + } catch (err) { + threw = true; + importError = err; + } + + debug( + 'loaded "%s": top level test count before = %d and after = %d', + testFile, + topLevelTestCount, + root.subtests.length, + ); + if (topLevelTestCount === root.subtests.length) { + // This file had no tests in it. Add the placeholder test. + const subtest = root.createSubtest(Test, testFile); + if (threw) { + subtest.fail(importError); + } + startSubtestAfterBootstrap(subtest); + } + + topLevelTestCount = root.subtests.length; + } + }); + + debug('beginning test execution'); + root.entryFile = null; + finishBootstrap(); + root.processPendingSubtests(); + }; + } + } const setupPromise = PromiseResolve(setup?.(root.reporter)); PromisePrototypeThen(PromisePrototypeThen(PromisePrototypeThen(setupPromise, runFiles), postRun), teardown); diff --git a/lib/internal/test_runner/utils.js b/lib/internal/test_runner/utils.js index e6c421ff870bbd..882eb50aa5db47 100644 --- a/lib/internal/test_runner/utils.js +++ b/lib/internal/test_runner/utils.js @@ -195,11 +195,12 @@ function parseCommandLine() { let coverageExcludeGlobs; let coverageIncludeGlobs; let destinations; - let only; + let isolation; + let only = getOptionValue('--test-only'); let reporters; let shard; - let testNamePatterns; - let testSkipPatterns; + let testNamePatterns = mapPatternFlagToRegExArray('--test-name-pattern'); + let testSkipPatterns = mapPatternFlagToRegExArray('--test-skip-pattern'); let timeout; if (isChildProcessV8) { @@ -230,10 +231,17 @@ function parseCommandLine() { } if (isTestRunner) { + isolation = getOptionValue('--experimental-test-isolation'); timeout = getOptionValue('--test-timeout') || Infinity; - concurrency = getOptionValue('--test-concurrency') || true; - only = false; - testNamePatterns = null; + + if (isolation === 'none') { + concurrency = 1; + } else { + concurrency = getOptionValue('--test-concurrency') || true; + only = false; + testNamePatterns = null; + testSkipPatterns = null; + } const shardOption = getOptionValue('--test-shard'); if (shardOption) { @@ -290,6 +298,7 @@ function parseCommandLine() { coverageIncludeGlobs, destinations, forceExit, + isolation, only, reporters, setup, @@ -305,6 +314,16 @@ function parseCommandLine() { return globalTestOptions; } +function mapPatternFlagToRegExArray(flagName) { + const patterns = getOptionValue(flagName); + + if (patterns?.length > 0) { + return ArrayPrototypeMap(patterns, (re) => convertStringToRegExp(re, flagName)); + } + + return null; +} + function countCompletedTest(test, harness = test.root.harness) { if (test.nesting === 0) { harness.counters.topLevel++; diff --git a/src/env-inl.h b/src/env-inl.h index fcc8cfdd92429f..28a15aa741ddd4 100644 --- a/src/env-inl.h +++ b/src/env-inl.h @@ -670,7 +670,8 @@ inline bool Environment::owns_inspector() const { inline bool Environment::should_create_inspector() const { return (flags_ & EnvironmentFlags::kNoCreateInspector) == 0 && - !options_->test_runner && !options_->watch_mode; + !(options_->test_runner && options_->test_isolation == "process") && + !options_->watch_mode; } inline bool Environment::should_wait_for_inspector_frontend() const { diff --git a/src/node_options.cc b/src/node_options.cc index 0312922013d427..996acf3959b7e7 100644 --- a/src/node_options.cc +++ b/src/node_options.cc @@ -143,6 +143,18 @@ void EnvironmentOptions::CheckOptions(std::vector* errors, } if (test_runner) { + if (test_isolation == "none") { + debug_options_.allow_attaching_debugger = true; + } else { + if (test_isolation != "process") { + errors->push_back("invalid value for --experimental-test-isolation"); + } + +#ifndef ALLOW_ATTACHING_DEBUGGER_IN_TEST_RUNNER + debug_options_.allow_attaching_debugger = false; +#endif + } + if (syntax_check_only) { errors->push_back("either --test or --check can be used, not both"); } @@ -159,10 +171,6 @@ void EnvironmentOptions::CheckOptions(std::vector* errors, errors->push_back( "--watch-path cannot be used in combination with --test"); } - -#ifndef ALLOW_ATTACHING_DEBUGGER_IN_TEST_RUNNER - debug_options_.allow_attaching_debugger = false; -#endif } if (watch_mode) { @@ -662,6 +670,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() { AddOption("--experimental-test-coverage", "enable code coverage in the test runner", &EnvironmentOptions::test_runner_coverage); + AddOption("--experimental-test-isolation", + "configures the type of test isolation used in the test runner", + &EnvironmentOptions::test_isolation); AddOption("--experimental-test-module-mocks", "enable module mocking in the test runner", &EnvironmentOptions::test_runner_module_mocks); @@ -863,7 +874,7 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() { " (default: false)", &EnvironmentOptions::report_exclude_network, kAllowedInEnvvar); -} +} // NOLINT(readability/fn_size) PerIsolateOptionsParser::PerIsolateOptionsParser( const EnvironmentOptionsParser& eop) { diff --git a/src/node_options.h b/src/node_options.h index 6eda1e721ff989..61277b427c8db8 100644 --- a/src/node_options.h +++ b/src/node_options.h @@ -192,6 +192,7 @@ class EnvironmentOptions : public Options { std::vector test_reporter_destination; bool test_only = false; bool test_udp_no_try_send = false; + std::string test_isolation = "process"; std::string test_shard; std::vector test_skip_pattern; std::vector coverage_include_pattern; diff --git a/test/fixtures/test-runner/no-isolation/one.test.js b/test/fixtures/test-runner/no-isolation/one.test.js new file mode 100644 index 00000000000000..69e0485a37127b --- /dev/null +++ b/test/fixtures/test-runner/no-isolation/one.test.js @@ -0,0 +1,32 @@ +'use strict'; +const { before, beforeEach, after, afterEach, test, suite } = require('node:test'); + +globalThis.GLOBAL_ORDER = []; + +before(function() { + GLOBAL_ORDER.push(`before one: ${this.name}`); +}); + +beforeEach(function() { + GLOBAL_ORDER.push(`beforeEach one: ${this.name}`); +}); + +after(function() { + GLOBAL_ORDER.push(`after one: ${this.name}`); +}); + +afterEach(function() { + GLOBAL_ORDER.push(`afterEach one: ${this.name}`); +}); + +suite('suite one', function() { + GLOBAL_ORDER.push(this.name); + + test('suite one - test', { only: true }, function() { + GLOBAL_ORDER.push(this.name); + }); +}); + +test('test one', function() { + GLOBAL_ORDER.push(this.name); +}); diff --git a/test/fixtures/test-runner/no-isolation/two.test.js b/test/fixtures/test-runner/no-isolation/two.test.js new file mode 100644 index 00000000000000..50ae6541ce156d --- /dev/null +++ b/test/fixtures/test-runner/no-isolation/two.test.js @@ -0,0 +1,30 @@ +'use strict'; +const { before, beforeEach, after, afterEach, test, suite } = require('node:test'); + +before(function() { + GLOBAL_ORDER.push(`before two: ${this.name}`); +}); + +beforeEach(function() { + GLOBAL_ORDER.push(`beforeEach two: ${this.name}`); +}); + +after(function() { + GLOBAL_ORDER.push(`after two: ${this.name}`); +}); + +afterEach(function() { + GLOBAL_ORDER.push(`afterEach two: ${this.name}`); +}); + +suite('suite two', function() { + GLOBAL_ORDER.push(this.name); + + before(function() { + GLOBAL_ORDER.push(`before suite two: ${this.name}`); + }); + + test('suite two - test', { only: true }, function() { + GLOBAL_ORDER.push(this.name); + }); +}); diff --git a/test/fixtures/test-runner/snapshots/unit-2.js b/test/fixtures/test-runner/snapshots/unit-2.js new file mode 100644 index 00000000000000..311378b2810136 --- /dev/null +++ b/test/fixtures/test-runner/snapshots/unit-2.js @@ -0,0 +1,11 @@ +'use strict'; +const { snapshot, test } = require('node:test'); +const { basename, join } = require('node:path'); + +snapshot.setResolveSnapshotPath((testFile) => { + return join(process.cwd(), `${basename(testFile)}.snapshot`); +}); + +test('has a snapshot', (t) => { + t.assert.snapshot('a snapshot from ' + __filename); +}); diff --git a/test/parallel/test-runner-cli-concurrency.js b/test/parallel/test-runner-cli-concurrency.js index fbabaf08e27279..b2aa0ac6c3c6c5 100644 --- a/test/parallel/test-runner-cli-concurrency.js +++ b/test/parallel/test-runner-cli-concurrency.js @@ -24,3 +24,17 @@ test('concurrency of two', async () => { const cp = spawnSync(process.execPath, args, { cwd, env }); assert.match(cp.stderr.toString(), /concurrency: 2,/); }); + +test('isolation=none uses a concurrency of one', async () => { + const args = ['--test', '--experimental-test-isolation=none']; + const cp = spawnSync(process.execPath, args, { cwd, env }); + assert.match(cp.stderr.toString(), /concurrency: 1,/); +}); + +test('isolation=none overrides --test-concurrency', async () => { + const args = [ + '--test', '--experimental-test-isolation=none', '--test-concurrency=2', + ]; + const cp = spawnSync(process.execPath, args, { cwd, env }); + assert.match(cp.stderr.toString(), /concurrency: 1,/); +}); diff --git a/test/parallel/test-runner-cli-timeout.js b/test/parallel/test-runner-cli-timeout.js index b8998d397fa12c..53a3e4ce7ea48e 100644 --- a/test/parallel/test-runner-cli-timeout.js +++ b/test/parallel/test-runner-cli-timeout.js @@ -18,3 +18,11 @@ test('timeout of 10ms', async () => { const cp = spawnSync(process.execPath, args, { cwd, env }); assert.match(cp.stderr.toString(), /timeout: 10,/); }); + +test('isolation=none uses the --test-timeout flag', async () => { + const args = [ + '--test', '--experimental-test-isolation=none', '--test-timeout=10', + ]; + const cp = spawnSync(process.execPath, args, { cwd, env }); + assert.match(cp.stderr.toString(), /timeout: 10,/); +}); diff --git a/test/parallel/test-runner-cli.js b/test/parallel/test-runner-cli.js index f165a509c995cc..d2d2eea8809404 100644 --- a/test/parallel/test-runner-cli.js +++ b/test/parallel/test-runner-cli.js @@ -7,92 +7,162 @@ const { join } = require('path'); const fixtures = require('../common/fixtures'); const testFixtures = fixtures.path('test-runner'); -{ - // File not found. - const args = ['--test', 'a-random-file-that-does-not-exist.js']; - const child = spawnSync(process.execPath, args); +for (const isolation of ['none', 'process']) { + { + // File not found. + const args = [ + '--test', + `--experimental-test-isolation=${isolation}`, + 'a-random-file-that-does-not-exist.js', + ]; + const child = spawnSync(process.execPath, args); - assert.strictEqual(child.status, 1); - assert.strictEqual(child.signal, null); - assert.strictEqual(child.stdout.toString(), ''); - assert.match(child.stderr.toString(), /^Could not find/); -} + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); + assert.strictEqual(child.stdout.toString(), ''); + assert.match(child.stderr.toString(), /^Could not find/); + } -{ - // Default behavior. node_modules is ignored. Files that don't match the - // pattern are ignored except in test/ directories. - const args = ['--test']; - const child = spawnSync(process.execPath, args, { cwd: join(testFixtures, 'default-behavior') }); + { + // Default behavior. node_modules is ignored. Files that don't match the + // pattern are ignored except in test/ directories. + const args = ['--test', `--experimental-test-isolation=${isolation}`]; + const child = spawnSync(process.execPath, args, { cwd: join(testFixtures, 'default-behavior') }); - assert.strictEqual(child.status, 1); - assert.strictEqual(child.signal, null); - assert.strictEqual(child.stderr.toString(), ''); - const stdout = child.stdout.toString(); - assert.match(stdout, /ok 1 - this should pass/); - assert.match(stdout, /not ok 2 - this should fail/); - assert.match(stdout, /ok 3 - subdir.+subdir_test\.js/); - assert.match(stdout, /ok 4 - this should pass/); - assert.match(stdout, /ok 5 - this should be skipped/); - assert.match(stdout, /ok 6 - this should be executed/); -} + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); + assert.strictEqual(child.stderr.toString(), ''); + const stdout = child.stdout.toString(); + + assert.match(stdout, /ok 1 - this should pass/); + assert.match(stdout, /not ok 2 - this should fail/); + assert.match(stdout, /ok 3 - subdir.+subdir_test\.js/); + assert.match(stdout, /ok 4 - this should pass/); + assert.match(stdout, /ok 5 - this should be skipped/); + assert.match(stdout, /ok 6 - this should be executed/); + } -{ - // Same but with a prototype mutation in require scripts. - const args = ['--require', join(testFixtures, 'protoMutation.js'), '--test']; - const child = spawnSync(process.execPath, args, { cwd: join(testFixtures, 'default-behavior') }); + { + // Same but with a prototype mutation in require scripts. + const args = [ + '--require', join(testFixtures, 'protoMutation.js'), + '--test', + `--experimental-test-isolation=${isolation}`, + ]; + const child = spawnSync(process.execPath, args, { cwd: join(testFixtures, 'default-behavior') }); + + const stdout = child.stdout.toString(); + assert.match(stdout, /ok 1 - this should pass/); + assert.match(stdout, /not ok 2 - this should fail/); + assert.match(stdout, /ok 3 - subdir.+subdir_test\.js/); + assert.match(stdout, /ok 4 - this should pass/); + assert.match(stdout, /ok 5 - this should be skipped/); + assert.match(stdout, /ok 6 - this should be executed/); + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); + assert.strictEqual(child.stderr.toString(), ''); + } - const stdout = child.stdout.toString(); - assert.match(stdout, /ok 1 - this should pass/); - assert.match(stdout, /not ok 2 - this should fail/); - assert.match(stdout, /ok 3 - subdir.+subdir_test\.js/); - assert.match(stdout, /ok 4 - this should pass/); - assert.match(stdout, /ok 5 - this should be skipped/); - assert.match(stdout, /ok 6 - this should be executed/); - assert.strictEqual(child.status, 1); - assert.strictEqual(child.signal, null); - assert.strictEqual(child.stderr.toString(), ''); -} + { + // User specified files that don't match the pattern are still run. + const args = [ + '--test', + `--experimental-test-isolation=${isolation}`, + join(testFixtures, 'index.js'), + ]; + const child = spawnSync(process.execPath, args, { cwd: testFixtures }); -{ - // User specified files that don't match the pattern are still run. - const args = ['--test', join(testFixtures, 'index.js')]; - const child = spawnSync(process.execPath, args, { cwd: testFixtures }); + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); + assert.strictEqual(child.stderr.toString(), ''); + const stdout = child.stdout.toString(); + assert.match(stdout, /not ok 1 - .+index\.js/); + } - assert.strictEqual(child.status, 1); - assert.strictEqual(child.signal, null); - assert.strictEqual(child.stderr.toString(), ''); - const stdout = child.stdout.toString(); - assert.match(stdout, /not ok 1 - .+index\.js/); -} + { + // Searches node_modules if specified. + const args = [ + '--test', + `--experimental-test-isolation=${isolation}`, + join(testFixtures, 'default-behavior/node_modules/*.js'), + ]; + const child = spawnSync(process.execPath, args); -{ - // Searches node_modules if specified. - const args = ['--test', join(testFixtures, 'default-behavior/node_modules/*.js')]; - const child = spawnSync(process.execPath, args); + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); + assert.strictEqual(child.stderr.toString(), ''); + const stdout = child.stdout.toString(); + assert.match(stdout, /not ok 1 - .+test-nm\.js/); + } - assert.strictEqual(child.status, 1); - assert.strictEqual(child.signal, null); - assert.strictEqual(child.stderr.toString(), ''); - const stdout = child.stdout.toString(); - assert.match(stdout, /not ok 1 - .+test-nm\.js/); -} + { + // The current directory is used by default. + const args = ['--test', `--experimental-test-isolation=${isolation}`]; + const options = { cwd: join(testFixtures, 'default-behavior') }; + const child = spawnSync(process.execPath, args, options); -{ - // The current directory is used by default. - const args = ['--test']; - const options = { cwd: join(testFixtures, 'default-behavior') }; - const child = spawnSync(process.execPath, args, options); + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); + assert.strictEqual(child.stderr.toString(), ''); + const stdout = child.stdout.toString(); + assert.match(stdout, /ok 1 - this should pass/); + assert.match(stdout, /not ok 2 - this should fail/); + assert.match(stdout, /ok 3 - subdir.+subdir_test\.js/); + assert.match(stdout, /ok 4 - this should pass/); + assert.match(stdout, /ok 5 - this should be skipped/); + assert.match(stdout, /ok 6 - this should be executed/); + } - assert.strictEqual(child.status, 1); - assert.strictEqual(child.signal, null); - assert.strictEqual(child.stderr.toString(), ''); - const stdout = child.stdout.toString(); - assert.match(stdout, /ok 1 - this should pass/); - assert.match(stdout, /not ok 2 - this should fail/); - assert.match(stdout, /ok 3 - subdir.+subdir_test\.js/); - assert.match(stdout, /ok 4 - this should pass/); - assert.match(stdout, /ok 5 - this should be skipped/); - assert.match(stdout, /ok 6 - this should be executed/); + { + // Test combined stream outputs + const args = [ + '--test', + `--experimental-test-isolation=${isolation}`, + 'test/fixtures/test-runner/default-behavior/index.test.js', + 'test/fixtures/test-runner/nested.js', + 'test/fixtures/test-runner/invalid-tap.js', + ]; + const child = spawnSync(process.execPath, args); + + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); + assert.strictEqual(child.stderr.toString(), ''); + const stdout = child.stdout.toString(); + assert.match(stdout, /# Subtest: this should pass/); + assert.match(stdout, /ok 1 - this should pass/); + assert.match(stdout, / {2}---/); + assert.match(stdout, / {2}duration_ms: .*/); + assert.match(stdout, / {2}\.\.\./); + + assert.match(stdout, /# Subtest: .+invalid-tap\.js/); + assert.match(stdout, /invalid tap output/); + assert.match(stdout, /ok 2 - .+invalid-tap\.js/); + + assert.match(stdout, /# Subtest: level 0a/); + assert.match(stdout, / {4}# Subtest: level 1a/); + assert.match(stdout, / {4}ok 1 - level 1a/); + assert.match(stdout, / {4}# Subtest: level 1b/); + assert.match(stdout, / {4}not ok 2 - level 1b/); + assert.match(stdout, / {6}code: 'ERR_TEST_FAILURE'/); + assert.match(stdout, / {6}stack: |-'/); + assert.match(stdout, / {8}TestContext\. .*/); + assert.match(stdout, / {4}# Subtest: level 1c/); + assert.match(stdout, / {4}ok 3 - level 1c # SKIP aaa/); + assert.match(stdout, / {4}# Subtest: level 1d/); + assert.match(stdout, / {4}ok 4 - level 1d/); + assert.match(stdout, /not ok 3 - level 0a/); + assert.match(stdout, / {2}error: '1 subtest failed'/); + assert.match(stdout, /# Subtest: level 0b/); + assert.match(stdout, /not ok 4 - level 0b/); + assert.match(stdout, / {2}error: 'level 0b error'/); + assert.match(stdout, /# tests 8/); + assert.match(stdout, /# suites 0/); + assert.match(stdout, /# pass 4/); + assert.match(stdout, /# fail 3/); + assert.match(stdout, /# cancelled 0/); + assert.match(stdout, /# skipped 1/); + assert.match(stdout, /# todo 0/); + } } { @@ -115,57 +185,6 @@ const testFixtures = fixtures.path('test-runner'); } } -{ - // Test combined stream outputs - const args = [ - '--test', - 'test/fixtures/test-runner/default-behavior/index.test.js', - 'test/fixtures/test-runner/nested.js', - 'test/fixtures/test-runner/invalid-tap.js', - ]; - const child = spawnSync(process.execPath, args); - - - assert.strictEqual(child.status, 1); - assert.strictEqual(child.signal, null); - assert.strictEqual(child.stderr.toString(), ''); - const stdout = child.stdout.toString(); - assert.match(stdout, /# Subtest: this should pass/); - assert.match(stdout, /ok 1 - this should pass/); - assert.match(stdout, / {2}---/); - assert.match(stdout, / {2}duration_ms: .*/); - assert.match(stdout, / {2}\.\.\./); - - assert.match(stdout, /# Subtest: .+invalid-tap\.js/); - assert.match(stdout, /# invalid tap output/); - assert.match(stdout, /ok 2 - .+invalid-tap\.js/); - - assert.match(stdout, /# Subtest: level 0a/); - assert.match(stdout, / {4}# Subtest: level 1a/); - assert.match(stdout, / {4}ok 1 - level 1a/); - assert.match(stdout, / {4}# Subtest: level 1b/); - assert.match(stdout, / {4}not ok 2 - level 1b/); - assert.match(stdout, / {6}code: 'ERR_TEST_FAILURE'/); - assert.match(stdout, / {6}stack: |-'/); - assert.match(stdout, / {8}TestContext\. .*/); - assert.match(stdout, / {4}# Subtest: level 1c/); - assert.match(stdout, / {4}ok 3 - level 1c # SKIP aaa/); - assert.match(stdout, / {4}# Subtest: level 1d/); - assert.match(stdout, / {4}ok 4 - level 1d/); - assert.match(stdout, /not ok 3 - level 0a/); - assert.match(stdout, / {2}error: '1 subtest failed'/); - assert.match(stdout, /# Subtest: level 0b/); - assert.match(stdout, /not ok 4 - level 0b/); - assert.match(stdout, / {2}error: 'level 0b error'/); - assert.match(stdout, /# tests 8/); - assert.match(stdout, /# suites 0/); - assert.match(stdout, /# pass 4/); - assert.match(stdout, /# fail 3/); - assert.match(stdout, /# cancelled 0/); - assert.match(stdout, /# skipped 1/); - assert.match(stdout, /# todo 0/); -} - { // Test user logging in tests. const args = [ diff --git a/test/parallel/test-runner-coverage.js b/test/parallel/test-runner-coverage.js index 8a6cb392de2585..6cda6d2d1e090f 100644 --- a/test/parallel/test-runner-coverage.js +++ b/test/parallel/test-runner-coverage.js @@ -187,6 +187,44 @@ test('coverage is combined for multiple processes', skipIfNoInspector, () => { assert.strictEqual(result.status, 0); }); +test('coverage works with isolation=none', skipIfNoInspector, () => { + // There is a bug in coverage calculation. The branch % in the common.js + // fixture is different depending on the test isolation mode. The 'none' mode + // is closer to what c8 reports here, so the bug is likely in the code that + // merges reports from different processes. + let report = [ + '# start of coverage report', + '# -------------------------------------------------------------------', + '# file | line % | branch % | funcs % | uncovered lines', + '# -------------------------------------------------------------------', + '# common.js | 89.86 | 68.42 | 100.00 | 8 13-14 18 34-35 53', + '# first.test.js | 83.33 | 100.00 | 50.00 | 5-6', + '# second.test.js | 100.00 | 100.00 | 100.00 | ', + '# third.test.js | 100.00 | 100.00 | 100.00 | ', + '# -------------------------------------------------------------------', + '# all files | 92.11 | 76.00 | 88.89 |', + '# -------------------------------------------------------------------', + '# end of coverage report', + ].join('\n'); + + if (common.isWindows) { + report = report.replaceAll('/', '\\'); + } + + const fixture = fixtures.path('v8-coverage', 'combined_coverage'); + const args = [ + '--test', '--experimental-test-coverage', '--test-reporter', 'tap', '--experimental-test-isolation=none', + ]; + const result = spawnSync(process.execPath, args, { + env: { ...process.env, NODE_TEST_TMPDIR: tmpdir.path }, + cwd: fixture, + }); + + assert.strictEqual(result.stderr.toString(), ''); + assert(result.stdout.toString().includes(report)); + assert.strictEqual(result.status, 0); +}); + test('coverage reports on lines, functions, and branches', skipIfNoInspector, async (t) => { const fixture = fixtures.path('test-runner', 'coverage.js'); const child = spawnSync(process.execPath, diff --git a/test/parallel/test-runner-extraneous-async-activity.js b/test/parallel/test-runner-extraneous-async-activity.js index 68db109b292f15..23f3194e02f106 100644 --- a/test/parallel/test-runner-extraneous-async-activity.js +++ b/test/parallel/test-runner-extraneous-async-activity.js @@ -48,3 +48,21 @@ const { spawnSync } = require('child_process'); assert.strictEqual(child.status, 1); assert.strictEqual(child.signal, null); } + +{ + const child = spawnSync(process.execPath, [ + '--test', + '--experimental-test-isolation=none', + fixtures.path('test-runner', 'async-error-in-test-hook.mjs'), + ]); + const stdout = child.stdout.toString(); + assert.match(stdout, /^# Error: Test hook "before" at .+async-error-in-test-hook\.mjs:3:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /^# Error: Test hook "beforeEach" at .+async-error-in-test-hook\.mjs:9:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /^# Error: Test hook "after" at .+async-error-in-test-hook\.mjs:15:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /^# Error: Test hook "afterEach" at .+async-error-in-test-hook\.mjs:21:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /^# pass 1$/m); + assert.match(stdout, /^# fail 0$/m); + assert.match(stdout, /^# cancelled 0$/m); + assert.strictEqual(child.status, 1); + assert.strictEqual(child.signal, null); +} diff --git a/test/parallel/test-runner-force-exit-failure.js b/test/parallel/test-runner-force-exit-failure.js index 1fff8f30d7e038..ce1f3208c5b4e6 100644 --- a/test/parallel/test-runner-force-exit-failure.js +++ b/test/parallel/test-runner-force-exit-failure.js @@ -4,12 +4,21 @@ const { match, doesNotMatch, strictEqual } = require('node:assert'); const { spawnSync } = require('node:child_process'); const fixtures = require('../common/fixtures'); const fixture = fixtures.path('test-runner/throws_sync_and_async.js'); -const r = spawnSync(process.execPath, ['--test', '--test-force-exit', fixture]); -strictEqual(r.status, 1); -strictEqual(r.signal, null); -strictEqual(r.stderr.toString(), ''); +for (const isolation of ['none', 'process']) { + const args = [ + '--test', + '--test-force-exit', + `--experimental-test-isolation=${isolation}`, + fixture, + ]; + const r = spawnSync(process.execPath, args); -const stdout = r.stdout.toString(); -match(stdout, /error: 'fails'/); -doesNotMatch(stdout, /this should not have a chance to be thrown/); + strictEqual(r.status, 1); + strictEqual(r.signal, null); + strictEqual(r.stderr.toString(), ''); + + const stdout = r.stdout.toString(); + match(stdout, /error: 'fails'/); + doesNotMatch(stdout, /this should not have a chance to be thrown/); +} diff --git a/test/parallel/test-runner-no-isolation-filtering.js b/test/parallel/test-runner-no-isolation-filtering.js new file mode 100644 index 00000000000000..f8fba1cbfffbef --- /dev/null +++ b/test/parallel/test-runner-no-isolation-filtering.js @@ -0,0 +1,69 @@ +'use strict'; +require('../common'); +const fixtures = require('../common/fixtures'); +const assert = require('node:assert'); +const { spawnSync } = require('node:child_process'); +const { test } = require('node:test'); + +const fixture1 = fixtures.path('test-runner', 'no-isolation', 'one.test.js'); +const fixture2 = fixtures.path('test-runner', 'no-isolation', 'two.test.js'); + +test('works with --test-only', () => { + const args = [ + '--test', + '--experimental-test-isolation=none', + '--test-only', + fixture1, + fixture2, + ]; + const child = spawnSync(process.execPath, args); + const stdout = child.stdout.toString(); + + assert.strictEqual(child.status, 0); + assert.strictEqual(child.signal, null); + assert.match(stdout, /# tests 2/); + assert.match(stdout, /# suites 2/); + assert.match(stdout, /# pass 2/); + assert.match(stdout, /ok 1 - suite one/); + assert.match(stdout, /ok 1 - suite one - test/); + assert.match(stdout, /ok 2 - suite two/); + assert.match(stdout, /ok 1 - suite two - test/); +}); + +test('works with --test-name-pattern', () => { + const args = [ + '--test', + '--experimental-test-isolation=none', + '--test-name-pattern=/test one/', + fixture1, + fixture2, + ]; + const child = spawnSync(process.execPath, args); + const stdout = child.stdout.toString(); + + assert.strictEqual(child.status, 0); + assert.strictEqual(child.signal, null); + assert.match(stdout, /# tests 1/); + assert.match(stdout, /# suites 0/); + assert.match(stdout, /# pass 1/); + assert.match(stdout, /ok 1 - test one/); +}); + +test('works with --test-skip-pattern', () => { + const args = [ + '--test', + '--experimental-test-isolation=none', + '--test-skip-pattern=/one/', + fixture1, + fixture2, + ]; + const child = spawnSync(process.execPath, args); + const stdout = child.stdout.toString(); + + assert.strictEqual(child.status, 0); + assert.strictEqual(child.signal, null); + assert.match(stdout, /# tests 1/); + assert.match(stdout, /# suites 1/); + assert.match(stdout, /# pass 1/); + assert.match(stdout, /ok 1 - suite two - test/); +}); diff --git a/test/parallel/test-runner-no-isolation.mjs b/test/parallel/test-runner-no-isolation.mjs new file mode 100644 index 00000000000000..60b0c962e6779b --- /dev/null +++ b/test/parallel/test-runner-no-isolation.mjs @@ -0,0 +1,47 @@ +import { allowGlobals, mustCall, mustNotCall } from '../common/index.mjs'; +import * as fixtures from '../common/fixtures.mjs'; +import { deepStrictEqual } from 'node:assert'; +import { run } from 'node:test'; + +const stream = run({ + files: [ + fixtures.path('test-runner', 'no-isolation', 'one.test.js'), + fixtures.path('test-runner', 'no-isolation', 'two.test.js'), + ], + isolation: 'none', +}); + +stream.on('test:fail', mustNotCall()); +stream.on('test:pass', mustCall(5)); +// eslint-disable-next-line no-unused-vars +for await (const _ of stream); +allowGlobals(globalThis.GLOBAL_ORDER); +deepStrictEqual(globalThis.GLOBAL_ORDER, [ + 'before one: ', + 'suite one', + 'before two: ', + 'suite two', + + 'beforeEach one: suite one - test', + 'beforeEach two: suite one - test', + 'suite one - test', + 'afterEach one: suite one - test', + 'afterEach two: suite one - test', + + 'beforeEach one: test one', + 'beforeEach two: test one', + 'test one', + 'afterEach one: test one', + 'afterEach two: test one', + + 'before suite two: suite two', + + 'beforeEach one: suite two - test', + 'beforeEach two: suite two - test', + 'suite two - test', + 'afterEach one: suite two - test', + 'afterEach two: suite two - test', + + 'after one: ', + 'after two: ', +]); diff --git a/test/parallel/test-runner-snapshot-tests.js b/test/parallel/test-runner-snapshot-tests.js index e00019ef49d4f6..62ebdd3cade2fb 100644 --- a/test/parallel/test-runner-snapshot-tests.js +++ b/test/parallel/test-runner-snapshot-tests.js @@ -339,3 +339,75 @@ test('t.assert.snapshot()', async (t) => { t.assert.match(child.stdout, /fail 0/); }); }); + +test('snapshots from multiple files (isolation=none)', async (t) => { + tmpdir.refresh(); + + const fixture = fixtures.path('test-runner', 'snapshots', 'unit.js'); + const fixture2 = fixtures.path('test-runner', 'snapshots', 'unit-2.js'); + + await t.test('fails prior to snapshot generation', async (t) => { + const args = [ + '--test', + '--experimental-test-isolation=none', + '--experimental-test-snapshots', + fixture, + fixture2, + ]; + const child = await common.spawnPromisified( + process.execPath, + args, + { cwd: tmpdir.path }, + ); + + t.assert.strictEqual(child.code, 1); + t.assert.strictEqual(child.signal, null); + t.assert.match(child.stdout, /# tests 6/); + t.assert.match(child.stdout, /# pass 0/); + t.assert.match(child.stdout, /# fail 6/); + t.assert.match(child.stdout, /Missing snapshots/); + }); + + await t.test('passes when regenerating snapshots', async (t) => { + const args = [ + '--test', + '--experimental-test-isolation=none', + '--experimental-test-snapshots', + '--test-update-snapshots', + fixture, + fixture2, + ]; + const child = await common.spawnPromisified( + process.execPath, + args, + { cwd: tmpdir.path }, + ); + + t.assert.strictEqual(child.code, 0); + t.assert.strictEqual(child.signal, null); + t.assert.match(child.stdout, /tests 6/); + t.assert.match(child.stdout, /pass 6/); + t.assert.match(child.stdout, /fail 0/); + }); + + await t.test('passes when snapshots exist', async (t) => { + const args = [ + '--test', + '--experimental-test-isolation=none', + '--experimental-test-snapshots', + fixture, + fixture2, + ]; + const child = await common.spawnPromisified( + process.execPath, + args, + { cwd: tmpdir.path }, + ); + + t.assert.strictEqual(child.code, 0); + t.assert.strictEqual(child.signal, null); + t.assert.match(child.stdout, /tests 6/); + t.assert.match(child.stdout, /pass 6/); + t.assert.match(child.stdout, /fail 0/); + }); +}); From 3caf29ea8869d4668193111ebdd390b63d7942dc Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Sun, 18 Aug 2024 00:29:34 +0000 Subject: [PATCH 13/90] deps: update sqlite to 3.46.1 PR-URL: https://github.com/nodejs/node/pull/54433 Reviewed-By: Rafael Gonzaga Reviewed-By: Benjamin Gruenbaum Reviewed-By: Marco Ippolito --- deps/sqlite/sqlite3.c | 158 ++++++++++++++++++++++-------------------- deps/sqlite/sqlite3.h | 6 +- 2 files changed, 85 insertions(+), 79 deletions(-) diff --git a/deps/sqlite/sqlite3.c b/deps/sqlite/sqlite3.c index 6e13cd8a1c632b..946815f13ec882 100644 --- a/deps/sqlite/sqlite3.c +++ b/deps/sqlite/sqlite3.c @@ -1,6 +1,6 @@ /****************************************************************************** ** This file is an amalgamation of many separate C source files from SQLite -** version 3.46.0. By combining all the individual C code files into this +** version 3.46.1. By combining all the individual C code files into this ** single large file, the entire code can be compiled as a single translation ** unit. This allows many compilers to do optimizations that would not be ** possible if the files were compiled separately. Performance improvements @@ -18,7 +18,7 @@ ** separate file. This file contains only code for the core SQLite library. ** ** The content in this amalgamation comes from Fossil check-in -** 96c92aba00c8375bc32fafcdf12429c58bd8. +** c9c2ab54ba1f5f46360f1b4f35d849cd3f08. */ #define SQLITE_CORE 1 #define SQLITE_AMALGAMATION 1 @@ -459,9 +459,9 @@ extern "C" { ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */ -#define SQLITE_VERSION "3.46.0" -#define SQLITE_VERSION_NUMBER 3046000 -#define SQLITE_SOURCE_ID "2024-05-23 13:25:27 96c92aba00c8375bc32fafcdf12429c58bd8aabfcadab6683e35bbb9cdebf19e" +#define SQLITE_VERSION "3.46.1" +#define SQLITE_VERSION_NUMBER 3046001 +#define SQLITE_SOURCE_ID "2024-08-13 09:16:08 c9c2ab54ba1f5f46360f1b4f35d849cd3f080e6fc2b6c60e91b16c63f69a1e33" /* ** CAPI3REF: Run-Time Library Version Numbers @@ -19361,7 +19361,7 @@ struct SrcList { #define WHERE_AGG_DISTINCT 0x0400 /* Query is "SELECT agg(DISTINCT ...)" */ #define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */ #define WHERE_RIGHT_JOIN 0x1000 /* Processing a RIGHT JOIN */ - /* 0x2000 not currently used */ +#define WHERE_KEEP_ALL_JOINS 0x2000 /* Do not do the omit-noop-join opt */ #define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */ /* 0x8000 not currently used */ @@ -24886,8 +24886,8 @@ static const struct { /* 1 */ { 6, "minute", 7.7379e+12, 60.0 }, /* 2 */ { 4, "hour", 1.2897e+11, 3600.0 }, /* 3 */ { 3, "day", 5373485.0, 86400.0 }, - /* 4 */ { 5, "month", 176546.0, 2592000.0 }, - /* 5 */ { 4, "year", 14713.0, 31536000.0 }, + /* 4 */ { 5, "month", 176546.0, 30.0*86400.0 }, + /* 5 */ { 4, "year", 14713.0, 365.0*86400.0 }, }; /* @@ -90173,7 +90173,8 @@ SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff assert( iVar>0 ); if( v ){ Mem *pMem = &v->aVar[iVar-1]; - assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); + assert( (v->db->flags & SQLITE_EnableQPSG)==0 + || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 ); if( 0==(pMem->flags & MEM_Null) ){ sqlite3_value *pRet = sqlite3ValueNew(v->db); if( pRet ){ @@ -90193,7 +90194,8 @@ SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff */ SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){ assert( iVar>0 ); - assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); + assert( (v->db->flags & SQLITE_EnableQPSG)==0 + || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 ); if( iVar>=32 ){ v->expmask |= 0x80000000; }else{ @@ -106950,7 +106952,7 @@ static void extendFJMatch( static SQLITE_NOINLINE int isValidSchemaTableName( const char *zTab, /* Name as it appears in the SQL */ Table *pTab, /* The schema table we are trying to match */ - Schema *pSchema /* non-NULL if a database qualifier is present */ + const char *zDb /* non-NULL if a database qualifier is present */ ){ const char *zLegacy; assert( pTab!=0 ); @@ -106961,7 +106963,7 @@ static SQLITE_NOINLINE int isValidSchemaTableName( if( sqlite3StrICmp(zTab+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){ return 1; } - if( pSchema==0 ) return 0; + if( zDb==0 ) return 0; if( sqlite3StrICmp(zTab+7, &LEGACY_SCHEMA_TABLE[7])==0 ) return 1; if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1; }else{ @@ -107144,7 +107146,7 @@ static int lookupName( } }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){ if( pTab->tnum!=1 ) continue; - if( !isValidSchemaTableName(zTab, pTab, pSchema) ) continue; + if( !isValidSchemaTableName(zTab, pTab, zDb) ) continue; } assert( ExprUseYTab(pExpr) ); if( IN_RENAME_OBJECT && pItem->zAlias ){ @@ -108876,6 +108878,9 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames( ** Resolve all names for all expression in an expression list. This is ** just like sqlite3ResolveExprNames() except that it works for an expression ** list rather than a single expression. +** +** The return value is SQLITE_OK (0) for success or SQLITE_ERROR (1) for a +** failure. */ SQLITE_PRIVATE int sqlite3ResolveExprListNames( NameContext *pNC, /* Namespace to resolve expressions in. */ @@ -108884,7 +108889,7 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames( int i; int savedHasAgg = 0; Walker w; - if( pList==0 ) return WRC_Continue; + if( pList==0 ) return SQLITE_OK; w.pParse = pNC->pParse; w.xExprCallback = resolveExprStep; w.xSelectCallback = resolveSelectStep; @@ -108898,7 +108903,7 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames( #if SQLITE_MAX_EXPR_DEPTH>0 w.pParse->nHeight += pExpr->nHeight; if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){ - return WRC_Abort; + return SQLITE_ERROR; } #endif sqlite3WalkExprNN(&w, pExpr); @@ -108915,10 +108920,10 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames( (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); } - if( w.pParse->nErr>0 ) return WRC_Abort; + if( w.pParse->nErr>0 ) return SQLITE_ERROR; } pNC->ncFlags |= savedHasAgg; - return WRC_Continue; + return SQLITE_OK; } /* @@ -117457,7 +117462,7 @@ static int renameResolveTrigger(Parse *pParse){ /* ALWAYS() because if the table of the trigger does not exist, the ** error would have been hit before this point */ if( ALWAYS(pParse->pTriggerTab) ){ - rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab); + rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab)!=0; } /* Resolve symbols in WHEN clause */ @@ -124426,8 +124431,9 @@ SQLITE_PRIVATE void sqlite3CreateView( #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) /* ** The Table structure pTable is really a VIEW. Fill in the names of -** the columns of the view in the pTable structure. Return the number -** of errors. If an error is seen leave an error message in pParse->zErrMsg. +** the columns of the view in the pTable structure. Return non-zero if +** there are errors. If an error is seen an error message is left +** in pParse->zErrMsg. */ static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){ Table *pSelTab; /* A fake table from which we get the result set */ @@ -124550,7 +124556,7 @@ static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){ sqlite3DeleteColumnNames(db, pTable); } #endif /* SQLITE_OMIT_VIEW */ - return nErr; + return nErr + pParse->nErr; } SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ assert( pTable!=0 ); @@ -130848,6 +130854,8 @@ static void groupConcatValue(sqlite3_context *context){ sqlite3_result_error_toobig(context); }else if( pAccum->accError==SQLITE_NOMEM ){ sqlite3_result_error_nomem(context); + }else if( pGCC->nAccum>0 && pAccum->nChar==0 ){ + sqlite3_result_text(context, "", 1, SQLITE_STATIC); }else{ const char *zText = sqlite3_str_value(pAccum); sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT); @@ -133602,6 +133610,7 @@ SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList pRet->pSrc->nSrc = 1; pRet->pPrior = pLeft->pPrior; pRet->op = pLeft->op; + if( pRet->pPrior ) pRet->selFlags |= SF_Values; pLeft->pPrior = 0; pLeft->op = TK_SELECT; assert( pLeft->pNext==0 ); @@ -166067,7 +166076,9 @@ static int whereLoopAddBtree( " according to whereIsCoveringIndex()\n", pProbe->zName)); } } - }else if( m==0 ){ + }else if( m==0 + && (HasRowid(pTab) || pWInfo->pSelect!=0 || sqlite3FaultSim(700)) + ){ WHERETRACE(0x200, ("-> %s a covering index according to bitmasks\n", pProbe->zName, m==0 ? "is" : "is not")); @@ -167956,6 +167967,10 @@ static void showAllWhereLoops(WhereInfo *pWInfo, WhereClause *pWC){ ** the right-most table of a subquery that was flattened into the ** main query and that subquery was the right-hand operand of an ** inner join that held an ON or USING clause. +** 6) The ORDER BY clause has 63 or fewer terms +** 7) The omit-noop-join optimization is enabled. +** +** Items (1), (6), and (7) are checked by the caller. ** ** For example, given: ** @@ -168369,6 +168384,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( if( pOrderBy && pOrderBy->nExpr>=BMS ){ pOrderBy = 0; wctrlFlags &= ~WHERE_WANT_DISTINCT; + wctrlFlags |= WHERE_KEEP_ALL_JOINS; /* Disable omit-noop-join opt */ } /* The number of tables in the FROM clause is limited by the number of @@ -168669,10 +168685,10 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( ** in-line sqlite3WhereCodeOneLoopStart() for performance reasons. */ notReady = ~(Bitmask)0; - if( pWInfo->nLevel>=2 - && pResultSet!=0 /* these two combine to guarantee */ - && 0==(wctrlFlags & WHERE_AGG_DISTINCT) /* condition (1) above */ - && OptimizationEnabled(db, SQLITE_OmitNoopJoin) + if( pWInfo->nLevel>=2 /* Must be a join, or this opt8n is pointless */ + && pResultSet!=0 /* Condition (1) */ + && 0==(wctrlFlags & (WHERE_AGG_DISTINCT|WHERE_KEEP_ALL_JOINS)) /* (1),(6) */ + && OptimizationEnabled(db, SQLITE_OmitNoopJoin) /* (7) */ ){ notReady = whereOmitNoopJoin(pWInfo, notReady); nTabList = pWInfo->nLevel; @@ -168992,26 +169008,6 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( } #endif -#ifdef SQLITE_DEBUG -/* -** Return true if cursor iCur is opened by instruction k of the -** bytecode. Used inside of assert() only. -*/ -static int cursorIsOpen(Vdbe *v, int iCur, int k){ - while( k>=0 ){ - VdbeOp *pOp = sqlite3VdbeGetOp(v,k--); - if( pOp->p1!=iCur ) continue; - if( pOp->opcode==OP_Close ) return 0; - if( pOp->opcode==OP_OpenRead ) return 1; - if( pOp->opcode==OP_OpenWrite ) return 1; - if( pOp->opcode==OP_OpenDup ) return 1; - if( pOp->opcode==OP_OpenAutoindex ) return 1; - if( pOp->opcode==OP_OpenEphemeral ) return 1; - } - return 0; -} -#endif /* SQLITE_DEBUG */ - /* ** Generate the end of the WHERE loop. See comments on ** sqlite3WhereBegin() for additional information. @@ -169311,16 +169307,10 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ ** reference. Verify that this is harmless - that the ** table being referenced really is open. */ -#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC - assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 - || cursorIsOpen(v,pOp->p1,k) - || pOp->opcode==OP_Offset - ); -#else - assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 - || cursorIsOpen(v,pOp->p1,k) - ); -#endif + if( pLoop->wsFlags & WHERE_IDX_ONLY ){ + sqlite3ErrorMsg(pParse, "internal query planner error"); + pParse->rc = SQLITE_INTERNAL; + } } }else if( pOp->opcode==OP_Rowid ){ pOp->p1 = pLevel->iIdxCur; @@ -172591,9 +172581,9 @@ static void updateDeleteLimitError( break; } } - if( (p->selFlags & SF_MultiValue)==0 && - (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 && - cnt>mxSelect + if( (p->selFlags & (SF_MultiValue|SF_Values))==0 + && (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 + && cnt>mxSelect ){ sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); } @@ -237004,7 +236994,11 @@ static int sqlite3Fts5ExprNew( } sqlite3_free(sParse.apPhrase); - *pzErr = sParse.zErr; + if( 0==*pzErr ){ + *pzErr = sParse.zErr; + }else{ + sqlite3_free(sParse.zErr); + } return sParse.rc; } @@ -239132,6 +239126,7 @@ static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd( assert( pRight->eType==FTS5_STRING || pRight->eType==FTS5_TERM || pRight->eType==FTS5_EOF + || (pRight->eType==FTS5_AND && pParse->bPhraseToAnd) ); if( pLeft->eType==FTS5_AND ){ @@ -251299,6 +251294,7 @@ static int fts5UpdateMethod( rc = SQLITE_ERROR; }else{ rc = fts5SpecialDelete(pTab, apVal); + bUpdateOrDelete = 1; } }else{ rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]); @@ -252473,14 +252469,16 @@ static int sqlite3Fts5GetTokenizer( if( pMod==0 ){ assert( nArg>0 ); rc = SQLITE_ERROR; - *pzErr = sqlite3_mprintf("no such tokenizer: %s", azArg[0]); + if( pzErr ) *pzErr = sqlite3_mprintf("no such tokenizer: %s", azArg[0]); }else{ rc = pMod->x.xCreate( pMod->pUserData, (azArg?&azArg[1]:0), (nArg?nArg-1:0), &pConfig->pTok ); pConfig->pTokApi = &pMod->x; if( rc!=SQLITE_OK ){ - if( pzErr ) *pzErr = sqlite3_mprintf("error in tokenizer constructor"); + if( pzErr && rc!=SQLITE_NOMEM ){ + *pzErr = sqlite3_mprintf("error in tokenizer constructor"); + } }else{ pConfig->ePattern = sqlite3Fts5TokenizerPattern( pMod->x.xCreate, pConfig->pTok @@ -252539,7 +252537,7 @@ static void fts5SourceIdFunc( ){ assert( nArg==0 ); UNUSED_PARAM2(nArg, apUnused); - sqlite3_result_text(pCtx, "fts5: 2024-05-23 13:25:27 96c92aba00c8375bc32fafcdf12429c58bd8aabfcadab6683e35bbb9cdebf19e", -1, SQLITE_TRANSIENT); + sqlite3_result_text(pCtx, "fts5: 2024-08-13 09:16:08 c9c2ab54ba1f5f46360f1b4f35d849cd3f080e6fc2b6c60e91b16c63f69a1e33", -1, SQLITE_TRANSIENT); } /* @@ -252574,17 +252572,23 @@ static int fts5IntegrityMethod( assert( pzErr!=0 && *pzErr==0 ); UNUSED_PARAM(isQuick); + assert( pTab->p.pConfig->pzErrmsg==0 ); + pTab->p.pConfig->pzErrmsg = pzErr; rc = sqlite3Fts5StorageIntegrity(pTab->pStorage, 0); - if( (rc&0xff)==SQLITE_CORRUPT ){ - *pzErr = sqlite3_mprintf("malformed inverted index for FTS5 table %s.%s", - zSchema, zTabname); - rc = (*pzErr) ? SQLITE_OK : SQLITE_NOMEM; - }else if( rc!=SQLITE_OK ){ - *pzErr = sqlite3_mprintf("unable to validate the inverted index for" - " FTS5 table %s.%s: %s", - zSchema, zTabname, sqlite3_errstr(rc)); + if( *pzErr==0 && rc!=SQLITE_OK ){ + if( (rc&0xff)==SQLITE_CORRUPT ){ + *pzErr = sqlite3_mprintf("malformed inverted index for FTS5 table %s.%s", + zSchema, zTabname); + rc = (*pzErr) ? SQLITE_OK : SQLITE_NOMEM; + }else{ + *pzErr = sqlite3_mprintf("unable to validate the inverted index for" + " FTS5 table %s.%s: %s", + zSchema, zTabname, sqlite3_errstr(rc)); + } } + sqlite3Fts5IndexCloseReader(pTab->p.pIndex); + pTab->p.pConfig->pzErrmsg = 0; return rc; } @@ -254018,7 +254022,7 @@ static int fts5AsciiCreate( int i; memset(p, 0, sizeof(AsciiTokenizer)); memcpy(p->aTokenChar, aAsciiTokenChar, sizeof(aAsciiTokenChar)); - for(i=0; rc==SQLITE_OK && ibFold = 1; pNew->iFoldParam = 0; - for(i=0; rc==SQLITE_OK && iiFoldParam!=0 && pNew->bFold==0 ){ rc = SQLITE_ERROR; diff --git a/deps/sqlite/sqlite3.h b/deps/sqlite/sqlite3.h index 57df8dcf2027a7..f64ca01727829c 100644 --- a/deps/sqlite/sqlite3.h +++ b/deps/sqlite/sqlite3.h @@ -146,9 +146,9 @@ extern "C" { ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */ -#define SQLITE_VERSION "3.46.0" -#define SQLITE_VERSION_NUMBER 3046000 -#define SQLITE_SOURCE_ID "2024-05-23 13:25:27 96c92aba00c8375bc32fafcdf12429c58bd8aabfcadab6683e35bbb9cdebf19e" +#define SQLITE_VERSION "3.46.1" +#define SQLITE_VERSION_NUMBER 3046001 +#define SQLITE_SOURCE_ID "2024-08-13 09:16:08 c9c2ab54ba1f5f46360f1b4f35d849cd3f080e6fc2b6c60e91b16c63f69a1e33" /* ** CAPI3REF: Run-Time Library Version Numbers From a5ce24181b2806b1114cb4f2f98839a2b35f1c11 Mon Sep 17 00:00:00 2001 From: cjihrig Date: Tue, 11 Jun 2024 20:40:08 -0400 Subject: [PATCH 14/90] deps: sqlite: fix Windows compilation This is equivalent to the following upstream change: https://sqlite.org/src/info/6c103aee6f146869 Original commit message: Change constant expressions to pre-computed constants, because apparently MSVC on ARM requires that. [forum:/forumpost/4feb1685cced0a8e|Forum thread 4feb1685cced0a8e]. FossilOrigin-Name: 6c103aee6f146869a3e0c48694592f2e4c6b57ecdb4450f46e762c38b4e686f1 PR-URL: https://github.com/nodejs/node/pull/54433 Reviewed-By: Rafael Gonzaga Reviewed-By: Benjamin Gruenbaum Reviewed-By: Marco Ippolito --- deps/sqlite/sqlite3.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/deps/sqlite/sqlite3.c b/deps/sqlite/sqlite3.c index 946815f13ec882..20752a7ca9ee68 100644 --- a/deps/sqlite/sqlite3.c +++ b/deps/sqlite/sqlite3.c @@ -24886,8 +24886,8 @@ static const struct { /* 1 */ { 6, "minute", 7.7379e+12, 60.0 }, /* 2 */ { 4, "hour", 1.2897e+11, 3600.0 }, /* 3 */ { 3, "day", 5373485.0, 86400.0 }, - /* 4 */ { 5, "month", 176546.0, 30.0*86400.0 }, - /* 5 */ { 4, "year", 14713.0, 365.0*86400.0 }, + /* 4 */ { 5, "month", 176546.0, 2592000.0 }, + /* 5 */ { 4, "year", 14713.0, 31536000.0 }, }; /* From 0cf78aa24b6e11cc13e83b5908b60e23389ef3f8 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 21 Aug 2024 17:44:29 +0200 Subject: [PATCH 15/90] test_runner: refactor `mock_loader` PR-URL: https://github.com/nodejs/node/pull/54223 Reviewed-By: Yagiz Nizipli Reviewed-By: Colin Ihrig Reviewed-By: Chemi Atlow Reviewed-By: Moshe Atlow Reviewed-By: James M Snell --- lib/internal/test_runner/mock/loader.js | 48 ++++----------------- lib/internal/test_runner/mock/mock.js | 10 ++++- test/parallel/test-runner-module-mocking.js | 6 +++ 3 files changed, 22 insertions(+), 42 deletions(-) diff --git a/lib/internal/test_runner/mock/loader.js b/lib/internal/test_runner/mock/loader.js index a434248bcced16..25d9b31d0cb74d 100644 --- a/lib/internal/test_runner/mock/loader.js +++ b/lib/internal/test_runner/mock/loader.js @@ -10,21 +10,16 @@ const { }, } = primordials; const { - ensureNodeScheme, kBadExportsMessage, kMockSearchParam, kMockSuccess, kMockExists, kMockUnknownMessage, } = require('internal/test_runner/mock/mock'); -const { pathToFileURL, URL } = require('internal/url'); -const { normalizeReferrerURL } = require('internal/modules/helpers'); +const { URL, URLParse } = require('internal/url'); let debug = require('internal/util/debuglog').debuglog('test_runner', (fn) => { debug = fn; }); -const { createRequire, isBuiltin } = require('module'); -const { defaultGetFormatWithoutErrors } = require('internal/modules/esm/get_format'); -const { defaultResolve } = require('internal/modules/esm/resolve'); // TODO(cjihrig): The mocks need to be thread aware because the exports are // evaluated on the thread that creates the mock. Before marking this API as @@ -79,46 +74,18 @@ async function initialize(data) { async function resolve(specifier, context, nextResolve) { debug('resolve hook entry, specifier = "%s", context = %o', specifier, context); - let mockSpecifier; - if (isBuiltin(specifier)) { - mockSpecifier = ensureNodeScheme(specifier); - } else { - let format; - - if (context.parentURL) { - format = defaultGetFormatWithoutErrors(pathToFileURL(context.parentURL)); - } - - try { - if (format === 'module') { - specifier = defaultResolve(specifier, context).url; - } else { - specifier = pathToFileURL( - createRequire(context.parentURL).resolve(specifier), - ).href; - } - } catch { - const parentURL = normalizeReferrerURL(context.parentURL); - const parsedURL = URL.parse(specifier, parentURL)?.href; - - if (parsedURL) { - specifier = parsedURL; - } - } - - mockSpecifier = specifier; - } + const nextResolveResult = await nextResolve(specifier, context); + const mockSpecifier = nextResolveResult.url; const mock = mocks.get(mockSpecifier); debug('resolve hook, specifier = "%s", mock = %o', specifier, mock); if (mock?.active !== true) { - return nextResolve(specifier, context); + return nextResolveResult; } const url = new URL(mockSpecifier); - url.searchParams.set(kMockSearchParam, mock.localVersion); if (!mock.cache) { @@ -127,13 +94,14 @@ async function resolve(specifier, context, nextResolve) { mock.localVersion++; } - debug('resolve hook finished, url = "%s"', url.href); - return nextResolve(url.href, context); + const { href } = url; + debug('resolve hook finished, url = "%s"', href); + return { __proto__: null, url: href, format: nextResolveResult.format }; } async function load(url, context, nextLoad) { debug('load hook entry, url = "%s", context = %o', url, context); - const parsedURL = URL.parse(url); + const parsedURL = URLParse(url); if (parsedURL) { parsedURL.searchParams.delete(kMockSearchParam); } diff --git a/lib/internal/test_runner/mock/mock.js b/lib/internal/test_runner/mock/mock.js index a0de3d2dd41909..5d3bce816aa69b 100644 --- a/lib/internal/test_runner/mock/mock.js +++ b/lib/internal/test_runner/mock/mock.js @@ -34,7 +34,13 @@ const { } = require('internal/errors'); const esmLoader = require('internal/modules/esm/loader'); const { getOptionValue } = require('internal/options'); -const { fileURLToPath, toPathIfFileURL, URL, isURL } = require('internal/url'); +const { + fileURLToPath, + isURL, + pathToFileURL, + toPathIfFileURL, + URL, +} = require('internal/url'); const { emitExperimentalWarning, getStructuredStack, @@ -511,7 +517,7 @@ class MockTracker { // Get the file that called this function. We need four stack frames: // vm context -> getStructuredStack() -> this function -> actual caller. - const caller = getStructuredStack()[3]?.getFileName(); + const caller = pathToFileURL(getStructuredStack()[3]?.getFileName()).href; const { format, url } = sharedState.moduleLoader.resolveSync( mockSpecifier, caller, null, ); diff --git a/test/parallel/test-runner-module-mocking.js b/test/parallel/test-runner-module-mocking.js index a9a5c33a7c26b4..45345815c69db4 100644 --- a/test/parallel/test-runner-module-mocking.js +++ b/test/parallel/test-runner-module-mocking.js @@ -407,6 +407,12 @@ test('modules cannot be mocked multiple times at once', async (t) => { assert.strictEqual(mocked.fn(), 42); }); + + await t.test('Importing a Windows path should fail', { skip: !common.isWindows }, async (t) => { + const fixture = fixtures.path('module-mocking', 'wrong-path.js'); + t.mock.module(fixture, { namedExports: { fn() { return 42; } } }); + await assert.rejects(import(fixture), { code: 'ERR_UNSUPPORTED_ESM_URL_SCHEME' }); + }); }); test('mocks are automatically restored', async (t) => { From b0ed8dbb2fe0502e2b2ac94508d74c9a65379bc5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Wed, 21 Aug 2024 17:44:39 +0200 Subject: [PATCH 16/90] test: prevent V8 from writing into the system's tmpdir MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refs: https://github.com/nodejs/build/issues/3864 PR-URL: https://github.com/nodejs/node/pull/54395 Reviewed-By: Richard Lau Reviewed-By: Juan José Arboleda Reviewed-By: Jake Yuesong Li Reviewed-By: Luigi Pinca Reviewed-By: Yagiz Nizipli --- test/parallel/test-cli-node-options.js | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/test/parallel/test-cli-node-options.js b/test/parallel/test-cli-node-options.js index 8d614e607177cd..e898a81af09ca6 100644 --- a/test/parallel/test-cli-node-options.js +++ b/test/parallel/test-cli-node-options.js @@ -93,7 +93,12 @@ function expectNoWorker(opt, want, command, wantsError) { function expect( opt, want, command = 'console.log("B")', wantsError = false, testWorker = true ) { - const argv = ['-e', command]; + const argv = [ + // --perf-basic-prof and --perf-basic-prof-only-functions write to /tmp by default. + `--perf-basic-prof-path=${tmpdir.path}`, + '-e', + command, + ]; const opts = { cwd: tmpdir.path, env: Object.assign({}, process.env, { NODE_OPTIONS: opt }), From da6c61def82190fd07cbdd9bb946644273eddf96 Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Thu, 22 Aug 2024 10:48:47 +0200 Subject: [PATCH 17/90] tools: add swc license PR-URL: https://github.com/nodejs/node/pull/54462 Fixes: https://github.com/nodejs/amaro/issues/49 Reviewed-By: Paolo Insogna Reviewed-By: Chengzhong Wu Reviewed-By: Jake Yuesong Li Reviewed-By: Luigi Pinca Reviewed-By: Michael Dawson Reviewed-By: Matteo Collina Reviewed-By: Yagiz Nizipli Reviewed-By: Robert Nagy --- LICENSE | 205 +++++++++++++++++++++++++++++++++++++++ tools/license-builder.sh | 2 + 2 files changed, 207 insertions(+) diff --git a/LICENSE b/LICENSE index 1daa041f0cf188..2eed637682a9a0 100644 --- a/LICENSE +++ b/LICENSE @@ -155,6 +155,211 @@ The externally maintained libraries used by Node.js are: SOFTWARE. """ +- swc, located at deps/amaro, is licensed as follows: + """ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2024 SWC contributors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + """ + - ICU, located at deps/icu-small, is licensed as follows: """ UNICODE LICENSE V3 diff --git a/tools/license-builder.sh b/tools/license-builder.sh index 8a1a4df38aad09..11057d1f4894b8 100755 --- a/tools/license-builder.sh +++ b/tools/license-builder.sh @@ -40,6 +40,8 @@ licenseText="$(cat "${rootdir}/deps/v8/third_party/ittapi/LICENSES/BSD-3-Clause. addlicense "ittapi" "deps/v8/third_party/ittapi" "$licenseText" licenseText="$(cat "${rootdir}/deps/amaro/LICENSE.md")" addlicense "amaro" "deps/amaro" "$licenseText" +licenseText="$(cat "${rootdir}/deps/amaro/dist/LICENSE")" +addlicense "swc" "deps/amaro/dist" "$licenseText" if [ -f "${rootdir}/deps/icu/LICENSE" ]; then # ICU 57 and following. Drop the BOM licenseText="$(sed -e '1s/^[^a-zA-Z ]*ICU/ICU/' -e :a -e 's/<[^>]*>//g;s/ / /g;s/ +$//;/ Date: Thu, 22 Aug 2024 12:08:49 -0400 Subject: [PATCH 18/90] deps: update undici to 6.19.8 PR-URL: https://github.com/nodejs/node/pull/54456 Reviewed-By: Marco Ippolito Reviewed-By: Matteo Collina --- deps/undici/src/CONTRIBUTING.md | 1 + deps/undici/src/build/wasm.js | 7 +- .../src/lib/dispatcher/balanced-pool.js | 25 ++++- deps/undici/src/lib/llhttp/wasm_build_env.txt | 4 +- deps/undici/src/lib/web/fetch/body.js | 32 ++++++- deps/undici/src/lib/web/fetch/request.js | 8 +- deps/undici/src/lib/web/fetch/response.js | 23 +---- deps/undici/src/package-lock.json | 95 ++++++++++++++----- deps/undici/src/package.json | 2 +- deps/undici/undici.js | 60 ++++++------ src/undici_version.h | 2 +- 11 files changed, 172 insertions(+), 87 deletions(-) diff --git a/deps/undici/src/CONTRIBUTING.md b/deps/undici/src/CONTRIBUTING.md index 6b6c01d2264e33..68c9b977f1a862 100644 --- a/deps/undici/src/CONTRIBUTING.md +++ b/deps/undici/src/CONTRIBUTING.md @@ -159,6 +159,7 @@ an unbundled version instead of bundling one in `libnode.so`. To enable this, pass `EXTERNAL_PATH=/path/to/global/node_modules/undici` to `build/wasm.js`. Pass this path with `loader.js` appended to `--shared-builtin-undici/undici-path` in Node.js's `configure.py`. If building on a non-Alpine Linux distribution, you may need to also set the `WASM_CC`, `WASM_CFLAGS`, `WASM_LDFLAGS` and `WASM_LDLIBS` environment variables before running `build/wasm.js`. +Similarly, you can set the `WASM_OPT` environment variable to utilize your own `wasm-opt` optimizer. ### Benchmarks diff --git a/deps/undici/src/build/wasm.js b/deps/undici/src/build/wasm.js index 2f65c0e1d74159..1880ce3dfe4a4c 100644 --- a/deps/undici/src/build/wasm.js +++ b/deps/undici/src/build/wasm.js @@ -14,6 +14,7 @@ const WASM_CC = process.env.WASM_CC || 'clang' let WASM_CFLAGS = process.env.WASM_CFLAGS || '--sysroot=/usr/share/wasi-sysroot -target wasm32-unknown-wasi' let WASM_LDFLAGS = process.env.WASM_LDFLAGS || '' const WASM_LDLIBS = process.env.WASM_LDLIBS || '' +const WASM_OPT = process.env.WASM_OPT || './wasm-opt' // For compatibility with Node.js' `configure --shared-builtin-undici/undici-path ...` const EXTERNAL_PATH = process.env.EXTERNAL_PATH @@ -77,7 +78,7 @@ const hasApk = (function () { try { execSync('command -v apk'); return true } catch (error) { return false } })() const hasOptimizer = (function () { - try { execSync('./wasm-opt --version'); return true } catch (error) { return false } + try { execSync(`${WASM_OPT} --version`); return true } catch (error) { return false } })() if (hasApk) { // Gather information about the tools used for the build @@ -97,7 +98,7 @@ ${join(WASM_SRC, 'src')}/*.c \ ${WASM_LDLIBS}`, { stdio: 'inherit' }) if (hasOptimizer) { - execSync(`./wasm-opt ${WASM_OPT_FLAGS} -o ${join(WASM_OUT, 'llhttp.wasm')} ${join(WASM_OUT, 'llhttp.wasm')}`, { stdio: 'inherit' }) + execSync(`${WASM_OPT} ${WASM_OPT_FLAGS} -o ${join(WASM_OUT, 'llhttp.wasm')} ${join(WASM_OUT, 'llhttp.wasm')}`, { stdio: 'inherit' }) } writeWasmChunk('llhttp.wasm', 'llhttp-wasm.js') @@ -109,7 +110,7 @@ ${join(WASM_SRC, 'src')}/*.c \ ${WASM_LDLIBS}`, { stdio: 'inherit' }) if (hasOptimizer) { - execSync(`./wasm-opt ${WASM_OPT_FLAGS} --enable-simd -o ${join(WASM_OUT, 'llhttp_simd.wasm')} ${join(WASM_OUT, 'llhttp_simd.wasm')}`, { stdio: 'inherit' }) + execSync(`${WASM_OPT} ${WASM_OPT_FLAGS} --enable-simd -o ${join(WASM_OUT, 'llhttp_simd.wasm')} ${join(WASM_OUT, 'llhttp_simd.wasm')}`, { stdio: 'inherit' }) } writeWasmChunk('llhttp_simd.wasm', 'llhttp_simd-wasm.js') diff --git a/deps/undici/src/lib/dispatcher/balanced-pool.js b/deps/undici/src/lib/dispatcher/balanced-pool.js index 15a7e7b5879761..1e2de289cb73fa 100644 --- a/deps/undici/src/lib/dispatcher/balanced-pool.js +++ b/deps/undici/src/lib/dispatcher/balanced-pool.js @@ -25,9 +25,23 @@ const kWeight = Symbol('kWeight') const kMaxWeightPerServer = Symbol('kMaxWeightPerServer') const kErrorPenalty = Symbol('kErrorPenalty') +/** + * Calculate the greatest common divisor of two numbers by + * using the Euclidean algorithm. + * + * @param {number} a + * @param {number} b + * @returns {number} + */ function getGreatestCommonDivisor (a, b) { - if (b === 0) return a - return getGreatestCommonDivisor(b, a % b) + if (a === 0) return b + + while (b !== 0) { + const t = b + b = a % b + a = t + } + return a } function defaultFactory (origin, opts) { @@ -105,7 +119,12 @@ class BalancedPool extends PoolBase { } _updateBalancedPoolStats () { - this[kGreatestCommonDivisor] = this[kClients].map(p => p[kWeight]).reduce(getGreatestCommonDivisor, 0) + let result = 0 + for (let i = 0; i < this[kClients].length; i++) { + result = getGreatestCommonDivisor(this[kClients][i][kWeight], result) + } + + this[kGreatestCommonDivisor] = result } removeUpstream (upstream) { diff --git a/deps/undici/src/lib/llhttp/wasm_build_env.txt b/deps/undici/src/lib/llhttp/wasm_build_env.txt index cef6c799b6a14e..88676cd7cd04d1 100644 --- a/deps/undici/src/lib/llhttp/wasm_build_env.txt +++ b/deps/undici/src/lib/llhttp/wasm_build_env.txt @@ -1,12 +1,12 @@ -> undici@6.19.7 prebuild:wasm +> undici@6.19.8 prebuild:wasm > node build/wasm.js --prebuild > docker build --platform=linux/x86_64 -t llhttp_wasm_builder -f /home/runner/work/node/node/deps/undici/src/build/Dockerfile /home/runner/work/node/node/deps/undici/src -> undici@6.19.7 build:wasm +> undici@6.19.8 build:wasm > node build/wasm.js --docker > docker run --rm -t --platform=linux/x86_64 --user 1001:127 --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/lib/llhttp,target=/home/node/undici/lib/llhttp llhttp_wasm_builder node build/wasm.js diff --git a/deps/undici/src/lib/web/fetch/body.js b/deps/undici/src/lib/web/fetch/body.js index 55718ac7c8165d..464e7b50e5ced7 100644 --- a/deps/undici/src/lib/web/fetch/body.js +++ b/deps/undici/src/lib/web/fetch/body.js @@ -16,12 +16,25 @@ const { kState } = require('./symbols') const { webidl } = require('./webidl') const { Blob } = require('node:buffer') const assert = require('node:assert') -const { isErrored } = require('../../core/util') +const { isErrored, isDisturbed } = require('node:stream') const { isArrayBuffer } = require('node:util/types') const { serializeAMimeType } = require('./data-url') const { multipartFormDataParser } = require('./formdata-parser') const textEncoder = new TextEncoder() +function noop () {} + +const hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf('v18') !== 0 +let streamRegistry + +if (hasFinalizationRegistry) { + streamRegistry = new FinalizationRegistry((weakRef) => { + const stream = weakRef.deref() + if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) { + stream.cancel('Response object has been garbage collected').catch(noop) + } + }) +} // https://fetch.spec.whatwg.org/#concept-bodyinit-extract function extractBody (object, keepalive = false) { @@ -264,7 +277,7 @@ function safelyExtractBody (object, keepalive = false) { return extractBody(object, keepalive) } -function cloneBody (body) { +function cloneBody (instance, body) { // To clone a body body, run these steps: // https://fetch.spec.whatwg.org/#concept-body-clone @@ -272,6 +285,10 @@ function cloneBody (body) { // 1. Let « out1, out2 » be the result of teeing body’s stream. const [out1, out2] = body.stream.tee() + if (hasFinalizationRegistry) { + streamRegistry.register(instance, new WeakRef(out1)) + } + // 2. Set body’s stream to out1. body.stream = out1 @@ -414,7 +431,7 @@ async function consumeBody (object, convertBytesToJSValue, instance) { // 1. If object is unusable, then return a promise rejected // with a TypeError. - if (bodyUnusable(object[kState].body)) { + if (bodyUnusable(object)) { throw new TypeError('Body is unusable: Body has already been read') } @@ -454,7 +471,9 @@ async function consumeBody (object, convertBytesToJSValue, instance) { } // https://fetch.spec.whatwg.org/#body-unusable -function bodyUnusable (body) { +function bodyUnusable (object) { + const body = object[kState].body + // An object including the Body interface mixin is // said to be unusable if its body is non-null and // its body’s stream is disturbed or locked. @@ -496,5 +515,8 @@ module.exports = { extractBody, safelyExtractBody, cloneBody, - mixinBody + mixinBody, + streamRegistry, + hasFinalizationRegistry, + bodyUnusable } diff --git a/deps/undici/src/lib/web/fetch/request.js b/deps/undici/src/lib/web/fetch/request.js index bc436aa9705e34..542ea7fb28a0ed 100644 --- a/deps/undici/src/lib/web/fetch/request.js +++ b/deps/undici/src/lib/web/fetch/request.js @@ -2,7 +2,7 @@ 'use strict' -const { extractBody, mixinBody, cloneBody } = require('./body') +const { extractBody, mixinBody, cloneBody, bodyUnusable } = require('./body') const { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = require('./headers') const { FinalizationRegistry } = require('./dispatcher-weakref')() const util = require('../../core/util') @@ -557,7 +557,7 @@ class Request { // 40. If initBody is null and inputBody is non-null, then: if (initBody == null && inputBody != null) { // 1. If input is unusable, then throw a TypeError. - if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) { + if (bodyUnusable(input)) { throw new TypeError( 'Cannot construct a Request with a Request object that has already been used.' ) @@ -759,7 +759,7 @@ class Request { webidl.brandCheck(this, Request) // 1. If this is unusable, then throw a TypeError. - if (this.bodyUsed || this.body?.locked) { + if (bodyUnusable(this)) { throw new TypeError('unusable') } @@ -877,7 +877,7 @@ function cloneRequest (request) { // 2. If request’s body is non-null, set newRequest’s body to the // result of cloning request’s body. if (request.body != null) { - newRequest.body = cloneBody(request.body) + newRequest.body = cloneBody(newRequest, request.body) } // 3. Return newRequest. diff --git a/deps/undici/src/lib/web/fetch/response.js b/deps/undici/src/lib/web/fetch/response.js index 603410a4a63e4a..155dbadd1adc7f 100644 --- a/deps/undici/src/lib/web/fetch/response.js +++ b/deps/undici/src/lib/web/fetch/response.js @@ -1,7 +1,7 @@ 'use strict' const { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = require('./headers') -const { extractBody, cloneBody, mixinBody } = require('./body') +const { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = require('./body') const util = require('../../core/util') const nodeUtil = require('node:util') const { kEnumerableProperty } = util @@ -26,24 +26,9 @@ const { URLSerializer } = require('./data-url') const { kConstruct } = require('../../core/symbols') const assert = require('node:assert') const { types } = require('node:util') -const { isDisturbed, isErrored } = require('node:stream') const textEncoder = new TextEncoder('utf-8') -const hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf('v18') !== 0 -let registry - -if (hasFinalizationRegistry) { - registry = new FinalizationRegistry((weakRef) => { - const stream = weakRef.deref() - if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) { - stream.cancel('Response object has been garbage collected').catch(noop) - } - }) -} - -function noop () {} - // https://fetch.spec.whatwg.org/#response-class class Response { // Creates network error Response. @@ -244,7 +229,7 @@ class Response { webidl.brandCheck(this, Response) // 1. If this is unusable, then throw a TypeError. - if (this.bodyUsed || this.body?.locked) { + if (bodyUnusable(this)) { throw webidl.errors.exception({ header: 'Response.clone', message: 'Body has already been consumed.' @@ -327,7 +312,7 @@ function cloneResponse (response) { // 3. If response’s body is non-null, then set newResponse’s body to the // result of cloning response’s body. if (response.body != null) { - newResponse.body = cloneBody(response.body) + newResponse.body = cloneBody(newResponse, response.body) } // 4. Return newResponse. @@ -532,7 +517,7 @@ function fromInnerResponse (innerResponse, guard) { // a primitive or an object, even undefined. If the held value is an object, the registry keeps // a strong reference to it (so it can pass it to the cleanup callback later). Reworded from // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry - registry.register(response, new WeakRef(innerResponse.body.stream)) + streamRegistry.register(response, new WeakRef(innerResponse.body.stream)) } return response diff --git a/deps/undici/src/package-lock.json b/deps/undici/src/package-lock.json index 5c3f78dec80f4b..67e74b4e445fee 100644 --- a/deps/undici/src/package-lock.json +++ b/deps/undici/src/package-lock.json @@ -1,12 +1,12 @@ { "name": "undici", - "version": "6.19.7", + "version": "6.19.8", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "undici", - "version": "6.19.7", + "version": "6.19.8", "license": "MIT", "devDependencies": { "@fastify/busboy": "2.1.1", @@ -50,9 +50,9 @@ } }, "node_modules/@actions/http-client": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.2.1.tgz", - "integrity": "sha512-KhC/cZsq7f8I4LfZSJKgCvEwfkE8o1538VoBeoGzokVLLnbFDEAdFD3UhoMklxo2un9NJVBdANOresx7vTHlHw==", + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.2.2.tgz", + "integrity": "sha512-2TvX5LskKQzDDQI+bobIDGAjkn0NJiQlg4MTrKnZ8HfQ7nDEUbtJ1ytxPDb2bfk3Hr2XD99X8oAJISAmIoiSAQ==", "dev": true, "license": "MIT", "dependencies": { @@ -412,6 +412,38 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/plugin-syntax-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz", + "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-attributes": { + "version": "7.24.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.24.7.tgz", + "integrity": "sha512-hbX+lKKeUMGihnK8nvKqmXBInriT3GVjzXKFriV3YC6APGxMbP8RZNFwy91+hocLXq90Mta+HshoB31802bb8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, "node_modules/@babel/plugin-syntax-import-meta": { "version": "7.10.4", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", @@ -532,6 +564,22 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/plugin-syntax-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, "node_modules/@babel/plugin-syntax-top-level-await": { "version": "7.14.5", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", @@ -1616,9 +1664,9 @@ "license": "MIT" }, "node_modules/@types/node": { - "version": "18.19.43", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.43.tgz", - "integrity": "sha512-Mw/YlgXnyJdEwLoFv2dpuJaDFriX+Pc+0qOBJ57jC1H6cDxIj2xc5yUrdtArDVG0m+KV6622a4p2tenEqB3C/g==", + "version": "18.19.45", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.45.tgz", + "integrity": "sha512-VZxPKNNhjKmaC1SUYowuXSRSMGyQGmQjvvA1xE4QZ0xce2kLtEhPDS+kqpCPBZYgqblCLQ2DAjSzmgCM5auvhA==", "dev": true, "license": "MIT", "dependencies": { @@ -2257,24 +2305,27 @@ } }, "node_modules/babel-preset-current-node-syntax": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", - "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.1.0.tgz", + "integrity": "sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw==", "dev": true, "license": "MIT", "dependencies": { "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-syntax-bigint": "^7.8.3", - "@babel/plugin-syntax-class-properties": "^7.8.3", - "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.12.13", + "@babel/plugin-syntax-class-static-block": "^7.14.5", + "@babel/plugin-syntax-import-attributes": "^7.24.7", + "@babel/plugin-syntax-import-meta": "^7.10.4", "@babel/plugin-syntax-json-strings": "^7.8.3", - "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4", "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", - "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.10.4", "@babel/plugin-syntax-object-rest-spread": "^7.8.3", "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", "@babel/plugin-syntax-optional-chaining": "^7.8.3", - "@babel/plugin-syntax-top-level-await": "^7.8.3" + "@babel/plugin-syntax-private-property-in-object": "^7.14.5", + "@babel/plugin-syntax-top-level-await": "^7.14.5" }, "peerDependencies": { "@babel/core": "^7.0.0" @@ -3202,9 +3253,9 @@ "license": "MIT" }, "node_modules/electron-to-chromium": { - "version": "1.5.5", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.5.tgz", - "integrity": "sha512-QR7/A7ZkMS8tZuoftC/jfqNkZLQO779SSW3YuZHP4eXpj3EffGLFcB/Xu9AAZQzLccTiCV+EmUo3ha4mQ9wnlA==", + "version": "1.5.11", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.11.tgz", + "integrity": "sha512-R1CccCDYqndR25CaXFd6hp/u9RaaMcftMkphmvuepXr5b1vfLkRml6aWVeBhXJ7rbevHkKEMJtz8XqPf7ffmew==", "dev": true, "license": "ISC" }, @@ -5036,9 +5087,9 @@ } }, "node_modules/ignore": { - "version": "5.3.1", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz", - "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", "dev": true, "license": "MIT", "engines": { diff --git a/deps/undici/src/package.json b/deps/undici/src/package.json index 86fbc7e26b36f2..bf777b24a2b90a 100644 --- a/deps/undici/src/package.json +++ b/deps/undici/src/package.json @@ -1,6 +1,6 @@ { "name": "undici", - "version": "6.19.7", + "version": "6.19.8", "description": "An HTTP/1.1 client, written from scratch for Node.js", "homepage": "https://undici.nodejs.org", "bugs": { diff --git a/deps/undici/undici.js b/deps/undici/undici.js index b2e064facf2a64..acbece91687872 100644 --- a/deps/undici/undici.js +++ b/deps/undici/undici.js @@ -5210,11 +5210,24 @@ var require_body = __commonJS({ var { webidl } = require_webidl(); var { Blob: Blob2 } = require("node:buffer"); var assert = require("node:assert"); - var { isErrored } = require_util(); + var { isErrored, isDisturbed } = require("node:stream"); var { isArrayBuffer } = require("node:util/types"); var { serializeAMimeType } = require_data_url(); var { multipartFormDataParser } = require_formdata_parser(); var textEncoder = new TextEncoder(); + function noop() { + } + __name(noop, "noop"); + var hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf("v18") !== 0; + var streamRegistry; + if (hasFinalizationRegistry) { + streamRegistry = new FinalizationRegistry((weakRef) => { + const stream = weakRef.deref(); + if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) { + stream.cancel("Response object has been garbage collected").catch(noop); + } + }); + } function extractBody(object, keepalive = false) { let stream = null; if (object instanceof ReadableStream) { @@ -5359,8 +5372,11 @@ Content-Type: ${value.type || "application/octet-stream"}\r return extractBody(object, keepalive); } __name(safelyExtractBody, "safelyExtractBody"); - function cloneBody(body) { + function cloneBody(instance, body) { const [out1, out2] = body.stream.tee(); + if (hasFinalizationRegistry) { + streamRegistry.register(instance, new WeakRef(out1)); + } body.stream = out1; return { stream: out2, @@ -5443,7 +5459,7 @@ Content-Type: ${value.type || "application/octet-stream"}\r __name(mixinBody, "mixinBody"); async function consumeBody(object, convertBytesToJSValue, instance) { webidl.brandCheck(object, instance); - if (bodyUnusable(object[kState].body)) { + if (bodyUnusable(object)) { throw new TypeError("Body is unusable: Body has already been read"); } throwIfAborted(object[kState]); @@ -5464,7 +5480,8 @@ Content-Type: ${value.type || "application/octet-stream"}\r return promise.promise; } __name(consumeBody, "consumeBody"); - function bodyUnusable(body) { + function bodyUnusable(object) { + const body = object[kState].body; return body != null && (body.stream.locked || util.isDisturbed(body.stream)); } __name(bodyUnusable, "bodyUnusable"); @@ -5485,7 +5502,10 @@ Content-Type: ${value.type || "application/octet-stream"}\r extractBody, safelyExtractBody, cloneBody, - mixinBody + mixinBody, + streamRegistry, + hasFinalizationRegistry, + bodyUnusable }; } }); @@ -8719,7 +8739,7 @@ var require_response = __commonJS({ "lib/web/fetch/response.js"(exports2, module2) { "use strict"; var { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = require_headers(); - var { extractBody, cloneBody, mixinBody } = require_body(); + var { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = require_body(); var util = require_util(); var nodeUtil = require("node:util"); var { kEnumerableProperty } = util; @@ -8744,21 +8764,7 @@ var require_response = __commonJS({ var { kConstruct } = require_symbols(); var assert = require("node:assert"); var { types } = require("node:util"); - var { isDisturbed, isErrored } = require("node:stream"); var textEncoder = new TextEncoder("utf-8"); - var hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf("v18") !== 0; - var registry; - if (hasFinalizationRegistry) { - registry = new FinalizationRegistry((weakRef) => { - const stream = weakRef.deref(); - if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) { - stream.cancel("Response object has been garbage collected").catch(noop); - } - }); - } - function noop() { - } - __name(noop, "noop"); var Response = class _Response { static { __name(this, "Response"); @@ -8873,7 +8879,7 @@ var require_response = __commonJS({ // Returns a clone of response. clone() { webidl.brandCheck(this, _Response); - if (this.bodyUsed || this.body?.locked) { + if (bodyUnusable(this)) { throw webidl.errors.exception({ header: "Response.clone", message: "Body has already been consumed." @@ -8932,7 +8938,7 @@ var require_response = __commonJS({ } const newResponse = makeResponse({ ...response, body: null }); if (response.body != null) { - newResponse.body = cloneBody(response.body); + newResponse.body = cloneBody(newResponse, response.body); } return newResponse; } @@ -9065,7 +9071,7 @@ var require_response = __commonJS({ setHeadersList(response[kHeaders], innerResponse.headersList); setHeadersGuard(response[kHeaders], guard); if (hasFinalizationRegistry && innerResponse.body?.stream) { - registry.register(response, new WeakRef(innerResponse.body.stream)); + streamRegistry.register(response, new WeakRef(innerResponse.body.stream)); } return response; } @@ -9187,7 +9193,7 @@ var require_dispatcher_weakref = __commonJS({ var require_request2 = __commonJS({ "lib/web/fetch/request.js"(exports2, module2) { "use strict"; - var { extractBody, mixinBody, cloneBody } = require_body(); + var { extractBody, mixinBody, cloneBody, bodyUnusable } = require_body(); var { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = require_headers(); var { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()(); var util = require_util(); @@ -9513,7 +9519,7 @@ var require_request2 = __commonJS({ } let finalBody = inputOrInitBody; if (initBody == null && inputBody != null) { - if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) { + if (bodyUnusable(input)) { throw new TypeError( "Cannot construct a Request with a Request object that has already been used." ); @@ -9648,7 +9654,7 @@ var require_request2 = __commonJS({ // Returns a clone of request. clone() { webidl.brandCheck(this, _Request); - if (this.bodyUsed || this.body?.locked) { + if (bodyUnusable(this)) { throw new TypeError("unusable"); } const clonedRequest = cloneRequest(this[kState]); @@ -9742,7 +9748,7 @@ var require_request2 = __commonJS({ function cloneRequest(request) { const newRequest = makeRequest({ ...request, body: null }); if (request.body != null) { - newRequest.body = cloneBody(request.body); + newRequest.body = cloneBody(newRequest, request.body); } return newRequest; } diff --git a/src/undici_version.h b/src/undici_version.h index ac384500e05a5d..8a50f720dbfd9b 100644 --- a/src/undici_version.h +++ b/src/undici_version.h @@ -2,5 +2,5 @@ // Refer to tools/dep_updaters/update-undici.sh #ifndef SRC_UNDICI_VERSION_H_ #define SRC_UNDICI_VERSION_H_ -#define UNDICI_VERSION "6.19.7" +#define UNDICI_VERSION "6.19.8" #endif // SRC_UNDICI_VERSION_H_ From 0d7171d8e9c18edf20ee436dd4a6fd4af40c330c Mon Sep 17 00:00:00 2001 From: Aviv Keller <38299977+RedYetiDev@users.noreply.github.com> Date: Thu, 22 Aug 2024 18:16:16 -0400 Subject: [PATCH 19/90] meta: add more labels to dep-updaters PR-URL: https://github.com/nodejs/node/pull/54454 Reviewed-By: Marco Ippolito Reviewed-By: Luigi Pinca --- .github/workflows/tools.yml | 14 +++++++------- .github/workflows/update-openssl.yml | 2 +- .github/workflows/update-v8.yml | 2 +- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml index 8ac8cd6be6b5c0..79fb0c3324f7b8 100644 --- a/.github/workflows/tools.yml +++ b/.github/workflows/tools.yml @@ -85,7 +85,7 @@ jobs: rm temp-output - id: amaro subsystem: deps - label: dependencies + label: dependencies, strip-types run: | ./tools/dep_updaters/update-amaro.sh > temp-output cat temp-output @@ -93,7 +93,7 @@ jobs: rm temp-output - id: brotli subsystem: deps - label: dependencies + label: dependencies, zlib run: | ./tools/dep_updaters/update-brotli.sh > temp-output cat temp-output @@ -101,7 +101,7 @@ jobs: rm temp-output - id: c-ares subsystem: deps - label: dependencies + label: dependencies, cares run: | ./tools/dep_updaters/update-c-ares.sh > temp-output cat temp-output @@ -163,7 +163,7 @@ jobs: rm temp-output - id: gyp-next subsystem: tools - label: tools + label: tools, gyp run: | ./tools/dep_updaters/update-gyp-next.sh > temp-output cat temp-output @@ -179,7 +179,7 @@ jobs: rm temp-output - id: icu subsystem: deps - label: dependencies, test + label: dependencies, test, icu run: | ./tools/dep_updaters/update-icu.sh > temp-output cat temp-output @@ -293,7 +293,7 @@ jobs: rm temp-output - id: sqlite subsystem: deps - label: dependencies + label: dependencies, sqlite run: | ./tools/dep_updaters/update-sqlite.sh > temp-output cat temp-output @@ -317,7 +317,7 @@ jobs: rm temp-output - id: zlib subsystem: deps - label: dependencies + label: dependencies, zlib run: | ./tools/dep_updaters/update-zlib.sh > temp-output cat temp-output diff --git a/.github/workflows/update-openssl.yml b/.github/workflows/update-openssl.yml index baaffb51d44f51..84f71c2fc94fe6 100644 --- a/.github/workflows/update-openssl.yml +++ b/.github/workflows/update-openssl.yml @@ -36,7 +36,7 @@ jobs: body: This is an automated update of OpenSSL to ${{ env.NEW_VERSION }}. branch: actions/tools-update-openssl # Custom branch *just* for this Action. commit-message: 'deps: upgrade openssl sources to quictls/openssl-${{ env.NEW_VERSION }}' - labels: dependencies + labels: dependencies, openssl title: 'deps: update OpenSSL to ${{ env.NEW_VERSION }}' path: deps/openssl update-pull-request-title-and-body: true diff --git a/.github/workflows/update-v8.yml b/.github/workflows/update-v8.yml index c37be908cc9cfb..5fc845c7785f8a 100644 --- a/.github/workflows/update-v8.yml +++ b/.github/workflows/update-v8.yml @@ -54,4 +54,4 @@ jobs: delete-branch: true title: 'deps: patch V8 to ${{ env.NEW_VERSION }}' body: This is an automated patch update of V8 to ${{ env.NEW_VERSION }}. - labels: v8 engine + labels: dependencies, v8 engine From 61affd77a7fff610620fee7e010b4c5c8526608c Mon Sep 17 00:00:00 2001 From: shallow-beach <96891913+shallow-beach@users.noreply.github.com> Date: Thu, 22 Aug 2024 17:52:53 -0700 Subject: [PATCH 20/90] doc: fix capitalization in module.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PR-URL: https://github.com/nodejs/node/pull/54488 Reviewed-By: Antoine du Hamel Reviewed-By: Ulises Gascón Reviewed-By: Luigi Pinca Reviewed-By: Jake Yuesong Li --- doc/api/modules.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/api/modules.md b/doc/api/modules.md index b64cbd0e261b84..56d435115929d8 100644 --- a/doc/api/modules.md +++ b/doc/api/modules.md @@ -417,7 +417,7 @@ described in greater detail elsewhere in this documentation. The built-in modules are defined within the Node.js source and are located in the `lib/` folder. -built-in modules can be identified using the `node:` prefix, in which case +Built-in modules can be identified using the `node:` prefix, in which case it bypasses the `require` cache. For instance, `require('node:http')` will always return the built in HTTP module, even if there is `require.cache` entry by that name. From b5843568b43d25a4d6bd2fa2b143752840961199 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Fri, 23 Aug 2024 03:23:40 -0400 Subject: [PATCH 21/90] deps: update amaro to 0.1.7 PR-URL: https://github.com/nodejs/node/pull/54473 Reviewed-By: Marco Ippolito Reviewed-By: Jake Yuesong Li --- deps/amaro/dist/index.js | 4 ++-- deps/amaro/dist/package.json | 2 +- deps/amaro/package.json | 2 +- src/amaro_version.h | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/deps/amaro/dist/index.js b/deps/amaro/dist/index.js index 5c50f8c8919339..10ad4d1fefcdf9 100644 --- a/deps/amaro/dist/index.js +++ b/deps/amaro/dist/index.js @@ -465,12 +465,12 @@ ${val.stack}`; module2.exports.__wbg_queueMicrotask_12a30234db4045d3 = function(arg0) { queueMicrotask(getObject(arg0)); }; - module2.exports.__wbindgen_closure_wrapper5958 = function(arg0, arg1, arg2) { + module2.exports.__wbindgen_closure_wrapper5961 = function(arg0, arg1, arg2) { const ret = makeMutClosure(arg0, arg1, 520, __wbg_adapter_38); return addHeapObject(ret); }; var { Buffer: Buffer2 } = require("node:buffer"); - var bytes = Buffer2.from("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", "base64"); + var bytes = Buffer2.from("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", "base64"); var wasmModule = new WebAssembly.Module(bytes); var wasmInstance = new WebAssembly.Instance(wasmModule, imports); wasm = wasmInstance.exports; diff --git a/deps/amaro/dist/package.json b/deps/amaro/dist/package.json index eaabedb1ba427d..542d98211b5eb9 100644 --- a/deps/amaro/dist/package.json +++ b/deps/amaro/dist/package.json @@ -4,7 +4,7 @@ "강동윤 " ], "description": "wasm module for swc", - "version": "1.7.11", + "version": "1.7.14", "license": "Apache-2.0", "repository": { "type": "git", diff --git a/deps/amaro/package.json b/deps/amaro/package.json index e5f1c259715bc4..1cdbb4716df5f1 100644 --- a/deps/amaro/package.json +++ b/deps/amaro/package.json @@ -1,6 +1,6 @@ { "name": "amaro", - "version": "0.1.6", + "version": "0.1.7", "description": "Node.js TypeScript wrapper", "license": "MIT", "type": "commonjs", diff --git a/src/amaro_version.h b/src/amaro_version.h index 7bc2800b4e8440..13ca4d534b1f43 100644 --- a/src/amaro_version.h +++ b/src/amaro_version.h @@ -2,5 +2,5 @@ // Refer to tools/dep_updaters/update-amaro.sh #ifndef SRC_AMARO_VERSION_H_ #define SRC_AMARO_VERSION_H_ -#define AMARO_VERSION "0.1.6" +#define AMARO_VERSION "0.1.7" #endif // SRC_AMARO_VERSION_H_ From fffc300c6df17c212ce925e6771d3e7c3a34d205 Mon Sep 17 00:00:00 2001 From: Wiyeong Seo Date: Fri, 23 Aug 2024 16:31:55 +0900 Subject: [PATCH 22/90] stream: change stream to use index instead of `for...of` PR-URL: https://github.com/nodejs/node/pull/54474 Refs: https://github.com/nodejs/node/blob/main/doc/contributing/primordials.md#unsafe-array-iteration Reviewed-By: Daeyeon Jeong Reviewed-By: Antoine du Hamel Reviewed-By: Matteo Collina Reviewed-By: Raz Luvaton Reviewed-By: Benjamin Gruenbaum Reviewed-By: Luigi Pinca --- lib/stream.js | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/lib/stream.js b/lib/stream.js index 420415a2259827..a26cc0b81c557e 100644 --- a/lib/stream.js +++ b/lib/stream.js @@ -61,7 +61,9 @@ Stream.isReadable = utils.isReadable; Stream.isWritable = utils.isWritable; Stream.Readable = require('internal/streams/readable'); -for (const key of ObjectKeys(streamReturningOperators)) { +const streamKeys = ObjectKeys(streamReturningOperators); +for (let i = 0; i < streamKeys.length; i++) { + const key = streamKeys[i]; const op = streamReturningOperators[key]; function fn(...args) { if (new.target) { @@ -79,7 +81,9 @@ for (const key of ObjectKeys(streamReturningOperators)) { writable: true, }); } -for (const key of ObjectKeys(promiseReturningOperators)) { +const promiseKeys = ObjectKeys(promiseReturningOperators); +for (let i = 0; i < promiseKeys.length; i++) { + const key = promiseKeys[i]; const op = promiseReturningOperators[key]; function fn(...args) { if (new.target) { From 1e01bdc0d0f5c0937f8f6df543e2b1a916e6d961 Mon Sep 17 00:00:00 2001 From: Giovanni Bucci Date: Fri, 23 Aug 2024 11:11:43 +0200 Subject: [PATCH 23/90] net: exclude ipv6 loopback addresses from server.listen Fixes: https://github.com/nodejs/node/issues/51732 PR-URL: https://github.com/nodejs/node/pull/54264 Reviewed-By: Tim Perry Reviewed-By: Paolo Insogna Reviewed-By: Matteo Collina --- lib/net.js | 39 +++++- src/cares_wrap.cc | 21 +++ ...er-close-before-calling-lookup-callback.js | 2 +- .../test-net-server-listen-ipv6-link-local.js | 131 ++++++++++++++++++ 4 files changed, 189 insertions(+), 4 deletions(-) create mode 100644 test/sequential/test-net-server-listen-ipv6-link-local.js diff --git a/lib/net.js b/lib/net.js index 4de6f9c5f6f23a..be21c566610286 100644 --- a/lib/net.js +++ b/lib/net.js @@ -62,6 +62,7 @@ const { UV_ECANCELED, UV_ETIMEDOUT, } = internalBinding('uv'); +const { convertIpv6StringToBuffer } = internalBinding('cares_wrap'); const { Buffer } = require('buffer'); const { ShutdownWrap } = internalBinding('stream_wrap'); @@ -2118,19 +2119,51 @@ Server.prototype.listen = function(...args) { throw new ERR_INVALID_ARG_VALUE('options', options); }; +function isIpv6LinkLocal(ip) { + if (!isIPv6(ip)) { return false; } + + const ipv6Buffer = convertIpv6StringToBuffer(ip); + const firstByte = ipv6Buffer[0]; // The first 8 bits + const secondByte = ipv6Buffer[1]; // The next 8 bits + + // The link-local prefix is `1111111010`, which in hexadecimal is `fe80` + // First 8 bits (firstByte) should be `11111110` (0xfe) + // The next 2 bits of the second byte should be `10` (0x80) + + const isFirstByteCorrect = (firstByte === 0xfe); // 0b11111110 == 0xfe + const isSecondByteCorrect = (secondByte & 0xc0) === 0x80; // 0b10xxxxxx == 0x80 + + return isFirstByteCorrect && isSecondByteCorrect; +} + +function filterOnlyValidAddress(addresses) { + // Return the first non IPV6 link-local address if present + for (const address of addresses) { + if (!isIpv6LinkLocal(address.address)) { + return address; + } + } + + // Otherwise return the first address + return addresses[0]; +} + function lookupAndListen(self, port, address, backlog, exclusive, flags) { if (dns === undefined) dns = require('dns'); const listeningId = self._listeningId; - dns.lookup(address, function doListen(err, ip, addressType) { + + dns.lookup(address, { all: true }, (err, addresses) => { if (listeningId !== self._listeningId) { return; } if (err) { self.emit('error', err); } else { - addressType = ip ? addressType : 4; - listenInCluster(self, ip, port, addressType, + const validAddress = filterOnlyValidAddress(addresses); + const family = validAddress?.family || 4; + + listenInCluster(self, validAddress.address, port, family, backlog, undefined, exclusive, flags); } }); diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc index 26877f3ddd8f69..436b2e3e002d81 100644 --- a/src/cares_wrap.cc +++ b/src/cares_wrap.cc @@ -1566,6 +1566,24 @@ void CanonicalizeIP(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(val); } +void ConvertIpv6StringToBuffer(const FunctionCallbackInfo& args) { + Isolate* isolate = args.GetIsolate(); + node::Utf8Value ip(isolate, args[0]); + unsigned char dst[16]; // IPv6 addresses are 128 bits (16 bytes) + + if (uv_inet_pton(AF_INET6, *ip, dst) != 0) { + isolate->ThrowException(v8::Exception::Error( + String::NewFromUtf8(isolate, "Invalid IPv6 address").ToLocalChecked())); + return; + } + + Local buffer = + node::Buffer::Copy( + isolate, reinterpret_cast(dst), sizeof(dst)) + .ToLocalChecked(); + args.GetReturnValue().Set(buffer); +} + void GetAddrInfo(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); @@ -1902,6 +1920,8 @@ void Initialize(Local target, SetMethod(context, target, "getaddrinfo", GetAddrInfo); SetMethod(context, target, "getnameinfo", GetNameInfo); SetMethodNoSideEffect(context, target, "canonicalizeIP", CanonicalizeIP); + SetMethodNoSideEffect( + context, target, "convertIpv6StringToBuffer", ConvertIpv6StringToBuffer); SetMethod(context, target, "strerror", StrError); @@ -1995,6 +2015,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) { registry->Register(GetAddrInfo); registry->Register(GetNameInfo); registry->Register(CanonicalizeIP); + registry->Register(ConvertIpv6StringToBuffer); registry->Register(StrError); registry->Register(ChannelWrap::New); diff --git a/test/parallel/test-net-server-close-before-calling-lookup-callback.js b/test/parallel/test-net-server-close-before-calling-lookup-callback.js index 58cfc5504c04fa..0c42639523288f 100644 --- a/test/parallel/test-net-server-close-before-calling-lookup-callback.js +++ b/test/parallel/test-net-server-close-before-calling-lookup-callback.js @@ -3,5 +3,5 @@ const common = require('../common'); const net = require('net'); // Process should exit because it does not create a real TCP server. -// Paas localhost to ensure create TCP handle asynchronously because It causes DNS resolution. +// Pass localhost to ensure create TCP handle asynchronously because it causes DNS resolution. net.createServer().listen(0, 'localhost', common.mustNotCall()).close(); diff --git a/test/sequential/test-net-server-listen-ipv6-link-local.js b/test/sequential/test-net-server-listen-ipv6-link-local.js new file mode 100644 index 00000000000000..56664c227cb5b7 --- /dev/null +++ b/test/sequential/test-net-server-listen-ipv6-link-local.js @@ -0,0 +1,131 @@ +'use strict'; +const common = require('../common'); +const assert = require('assert'); +const net = require('net'); +const dns = require('dns'); +const { mock } = require('node:test'); + +if (!common.hasIPv6) { + common.printSkipMessage('IPv6 support is required for this test'); + return; +} + +// Test on IPv6 Server, dns.lookup throws an error +{ + mock.method(dns, 'lookup', (hostname, options, callback) => { + callback(new Error('Mocked error')); + }); + const host = 'ipv6_link_local'; + + const server = net.createServer(); + + server.on('error', common.mustCall((e) => { + assert.strictEqual(e.message, 'Mocked error'); + })); + + server.listen(common.PORT + 2, host); +} + + +// Test on IPv6 Server, server.listen throws an error +{ + mock.method(dns, 'lookup', (hostname, options, callback) => { + if (hostname === 'ipv6_link_local') { + callback(null, [{ address: 'fe80::1', family: 6 }]); + } else { + dns.lookup.wrappedMethod(hostname, options, callback); + } + }); + const host = 'ipv6_link_local'; + + const server = net.createServer(); + + server.on('error', common.mustCall((e) => { + assert.strictEqual(e.address, 'fe80::1'); + assert.strictEqual(e.syscall, 'listen'); + })); + + server.listen(common.PORT + 2, host); +} + +// Test on IPv6 Server, picks 127.0.0.1 between that and a bunch of link-local addresses +{ + + mock.method(dns, 'lookup', (hostname, options, callback) => { + if (hostname === 'ipv6_link_local_with_many_entries') { + callback(null, [ + { address: 'fe80::1', family: 6 }, + { address: 'fe80::abcd:1234', family: 6 }, + { address: 'fe80::1ff:fe23:4567:890a', family: 6 }, + { address: 'fe80::200:5aee:feaa:20a2', family: 6 }, + { address: 'fe80::f2de:f1ff:fe2b:3c4b', family: 6 }, + { address: 'fe81::1', family: 6 }, + { address: 'fe82::abcd:1234', family: 6 }, + { address: 'fe83::1ff:fe23:4567:890a', family: 6 }, + { address: 'fe84::200:5aee:feaa:20a2', family: 6 }, + { address: 'fe85::f2de:f1ff:fe2b:3c4b', family: 6 }, + { address: 'fe86::1', family: 6 }, + { address: 'fe87::abcd:1234', family: 6 }, + { address: 'fe88::1ff:fe23:4567:890a', family: 6 }, + { address: 'fe89::200:5aee:feaa:20a2', family: 6 }, + { address: 'fe8a::f2de:f1ff:fe2b:3c4b', family: 6 }, + { address: 'fe8b::1', family: 6 }, + { address: 'fe8c::abcd:1234', family: 6 }, + { address: 'fe8d::1ff:fe23:4567:890a', family: 6 }, + { address: 'fe8e::200:5aee:feaa:20a2', family: 6 }, + { address: 'fe8f::f2de:f1ff:fe2b:3c4b', family: 6 }, + { address: 'fea0::1', family: 6 }, + { address: 'febf::abcd:1234', family: 6 }, + { address: 'febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff', family: 6 }, + { address: '127.0.0.1', family: 4 }, + ]); + } else { + dns.lookup.wrappedMethod(hostname, options, callback); + } + }); + + const host = 'ipv6_link_local_with_many_entries'; + + const server = net.createServer(); + + server.on('error', common.mustNotCall()); + + server.listen(common.PORT + 3, host, common.mustCall(() => { + const address = server.address(); + assert.strictEqual(address.address, '127.0.0.1'); + assert.strictEqual(address.port, common.PORT + 3); + assert.strictEqual(address.family, 'IPv4'); + server.close(); + })); +} + + +// Test on IPv6 Server, picks ::1 because the other address is a link-local address +{ + + const host = 'ipv6_link_local_with_double_entry'; + const validIpv6Address = '::1'; + + mock.method(dns, 'lookup', (hostname, options, callback) => { + if (hostname === 'ipv6_link_local_with_double_entry') { + callback(null, [ + { address: 'fe80::1', family: 6 }, + { address: validIpv6Address, family: 6 }, + ]); + } else { + dns.lookup.wrappedMethod(hostname, options, callback); + } + }); + + const server = net.createServer(); + + server.on('error', common.mustNotCall()); + + server.listen(common.PORT + 4, host, common.mustCall(() => { + const address = server.address(); + assert.strictEqual(address.address, validIpv6Address); + assert.strictEqual(address.port, common.PORT + 4); + assert.strictEqual(address.family, 'IPv6'); + server.close(); + })); +} From eef303028f9f06a6c64c20e5b537fd6db6ac69a7 Mon Sep 17 00:00:00 2001 From: Joyee Cheung Date: Fri, 23 Aug 2024 13:53:18 +0200 Subject: [PATCH 24/90] src: remove cached data tag from snapshot metadata This only served as a preemptive check, but serializing this in the snapshot would make it unreproducible on different hardware. In the current cached data version tag, the V8 version can already be checked as part of the existing Node.js version check. The V8 flags aren't necessarily important for snapshot/code cache mismatches (only a small subset are), and the CPU features currently don't matter, so doing an exact match is stricter than necessary. Removing the check to help making the snapshot more reproducible on different hardware. PR-URL: https://github.com/nodejs/node/pull/54122 Refs: https://github.com/nodejs/build/issues/3043 Reviewed-By: Yagiz Nizipli Reviewed-By: Chengzhong Wu --- src/env.cc | 1 - src/env.h | 2 -- src/node_snapshotable.cc | 23 ----------------------- test/parallel/parallel.status | 7 +++++++ 4 files changed, 7 insertions(+), 26 deletions(-) diff --git a/src/env.cc b/src/env.cc index f2c0105fa28291..852a8651c8a769 100644 --- a/src/env.cc +++ b/src/env.cc @@ -320,7 +320,6 @@ std::ostream& operator<<(std::ostream& output, const SnapshotMetadata& i) { << " \"" << i.node_version << "\", // node_version\n" << " \"" << i.node_arch << "\", // node_arch\n" << " \"" << i.node_platform << "\", // node_platform\n" - << " " << i.v8_cache_version_tag << ", // v8_cache_version_tag\n" << " " << i.flags << ", // flags\n" << "}"; return output; diff --git a/src/env.h b/src/env.h index ee119eb3556b6d..6177e52d25272d 100644 --- a/src/env.h +++ b/src/env.h @@ -549,8 +549,6 @@ struct SnapshotMetadata { std::string node_version; std::string node_arch; std::string node_platform; - // Result of v8::ScriptCompiler::CachedDataVersionTag(). - uint32_t v8_cache_version_tag; SnapshotFlags flags; }; diff --git a/src/node_snapshotable.cc b/src/node_snapshotable.cc index 426066fb9d63d4..fe04a8ee8d708b 100644 --- a/src/node_snapshotable.cc +++ b/src/node_snapshotable.cc @@ -43,7 +43,6 @@ using v8::Isolate; using v8::Local; using v8::Object; using v8::ObjectTemplate; -using v8::ScriptCompiler; using v8::SnapshotCreator; using v8::StartupData; using v8::String; @@ -542,7 +541,6 @@ SnapshotMetadata SnapshotDeserializer::Read() { result.node_version = ReadString(); result.node_arch = ReadString(); result.node_platform = ReadString(); - result.v8_cache_version_tag = ReadArithmetic(); result.flags = static_cast(ReadArithmetic()); if (is_debug) { @@ -570,9 +568,6 @@ size_t SnapshotSerializer::Write(const SnapshotMetadata& data) { written_total += WriteString(data.node_arch); Debug("Write Node.js platform %s\n", data.node_platform); written_total += WriteString(data.node_platform); - Debug("Write V8 cached data version tag %" PRIx32 "\n", - data.v8_cache_version_tag); - written_total += WriteArithmetic(data.v8_cache_version_tag); Debug("Write snapshot flags %" PRIx32 "\n", static_cast(data.flags)); written_total += WriteArithmetic(static_cast(data.flags)); @@ -697,23 +692,6 @@ bool SnapshotData::Check() const { return false; } - if (metadata.type == SnapshotMetadata::Type::kFullyCustomized && - !WithoutCodeCache(metadata.flags)) { - uint32_t current_cache_version = v8::ScriptCompiler::CachedDataVersionTag(); - if (metadata.v8_cache_version_tag != current_cache_version) { - // For now we only do this check for the customized snapshots - we know - // that the flags we use in the default snapshot are limited and safe - // enough so we can relax the constraints for it. - fprintf(stderr, - "Failed to load the startup snapshot because it was built with " - "a different version of V8 or with different V8 configurations.\n" - "Expected tag %" PRIx32 ", read %" PRIx32 "\n", - current_cache_version, - metadata.v8_cache_version_tag); - return false; - } - } - // TODO(joyeecheung): check incompatible Node.js flags. return true; } @@ -1180,7 +1158,6 @@ ExitCode SnapshotBuilder::CreateSnapshot(SnapshotData* out, per_process::metadata.versions.node, per_process::metadata.arch, per_process::metadata.platform, - v8::ScriptCompiler::CachedDataVersionTag(), config->flags}; // We cannot resurrect the handles from the snapshot, so make sure that diff --git a/test/parallel/parallel.status b/test/parallel/parallel.status index da93f6ca89ac83..8328ae196f63bd 100644 --- a/test/parallel/parallel.status +++ b/test/parallel/parallel.status @@ -19,6 +19,13 @@ test-fs-read-stream-concurrent-reads: PASS, FLAKY # https://github.com/nodejs/node/issues/52630 test-error-serdes: PASS, FLAKY +# Until V8 provides a better way to check for flag mismatch without +# making the code cache/snapshot unreproducible, disable the test +# for a preemptive check now. It should idealy fail more gracefully +# with a better checking mechanism. +# https://github.com/nodejs/build/issues/3043 +test-snapshot-incompatible: SKIP + [$system==win32] # Windows on x86 From b5a23c9783637fd3703a0697c4ba8c20843ca309 Mon Sep 17 00:00:00 2001 From: Aviv Keller <38299977+RedYetiDev@users.noreply.github.com> Date: Fri, 23 Aug 2024 08:29:47 -0400 Subject: [PATCH 25/90] meta: remind users to use a supported version in bug reports PR-URL: https://github.com/nodejs/node/pull/54481 Reviewed-By: Matteo Collina Reviewed-By: Antoine du Hamel Reviewed-By: Marco Ippolito --- .github/ISSUE_TEMPLATE/1-bug-report.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/ISSUE_TEMPLATE/1-bug-report.yml b/.github/ISSUE_TEMPLATE/1-bug-report.yml index bc2f78a46ac722..4637a2fa86e17b 100644 --- a/.github/ISSUE_TEMPLATE/1-bug-report.yml +++ b/.github/ISSUE_TEMPLATE/1-bug-report.yml @@ -13,7 +13,9 @@ body: - type: input attributes: label: Version - description: Output of `node -v` + description: | + Output of `node -v`. + Please verify that you are reproducing the issue in a [currently-supported version](https://github.com/nodejs/Release/blob/HEAD/README.md#release-schedule) of Node.js. - type: textarea attributes: label: Platform From d4310fe9c1d8f3f7d9c08fef2726e0e8dd66f124 Mon Sep 17 00:00:00 2001 From: Aviv Keller <38299977+RedYetiDev@users.noreply.github.com> Date: Fri, 23 Aug 2024 13:02:11 -0400 Subject: [PATCH 26/90] test_runner: add support for coverage thresholds Co-Authored-By: Marco Ippolito PR-URL: https://github.com/nodejs/node/pull/54429 Reviewed-By: Matteo Collina Reviewed-By: Paolo Insogna Reviewed-By: Moshe Atlow Reviewed-By: Colin Ihrig Reviewed-By: Marco Ippolito --- doc/api/cli.md | 36 ++++++ doc/node.1 | 9 ++ lib/internal/test_runner/test.js | 21 ++++ lib/internal/test_runner/utils.js | 15 +++ src/node_options.cc | 13 +++ src/node_options.h | 3 + .../test-runner-coverage-thresholds.js | 110 ++++++++++++++++++ 7 files changed, 207 insertions(+) create mode 100644 test/parallel/test-runner-coverage-thresholds.js diff --git a/doc/api/cli.md b/doc/api/cli.md index 33b9e1ce00b9b6..1eaf935ca121f3 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -2218,6 +2218,17 @@ concurrently. If `--experimental-test-isolation` is set to `'none'`, this flag is ignored and concurrency is one. Otherwise, concurrency defaults to `os.availableParallelism() - 1`. +### `--test-coverage-branches=threshold` + + + +> Stability: 1 - Experimental + +Require a minimum percent of covered branches. If code coverage does not reach +the threshold specified, the process will exit with code `1`. + ### `--test-coverage-exclude` + +> Stability: 1 - Experimental + +Require a minimum percent of covered functions. If code coverage does not reach +the threshold specified, the process will exit with code `1`. + ### `--test-coverage-include` + +> Stability: 1 - Experimental + +Require a minimum percent of covered lines. If code coverage does not reach +the threshold specified, the process will exit with code `1`. + ### `--test-force-exit` -Use this flag to disable experimental [`WebSocket`][] support. +Disable exposition of [`WebSocket`][] on the global scope. ### `--no-extra-info-on-fatal-exception` From 02d664b75f178c36507a6a80a2f4a69063d57461 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sat, 24 Aug 2024 22:10:11 +0200 Subject: [PATCH 33/90] test: fix improper path to URL conversion PR-URL: https://github.com/nodejs/node/pull/54509 Reviewed-By: Luigi Pinca Reviewed-By: James M Snell --- test/fixtures/permission/fs-read.js | 3 ++- .../test-diagnostics-channel-module-import-error.js | 6 ++---- test/parallel/test-diagnostics-channel-module-import.js | 6 ++---- 3 files changed, 6 insertions(+), 9 deletions(-) diff --git a/test/fixtures/permission/fs-read.js b/test/fixtures/permission/fs-read.js index 29594ca8b5d5a2..ddde4593204c82 100644 --- a/test/fixtures/permission/fs-read.js +++ b/test/fixtures/permission/fs-read.js @@ -5,10 +5,11 @@ const common = require('../../common'); const assert = require('assert'); const fs = require('fs'); const path = require('path'); +const { pathToFileURL } = require('url'); const blockedFile = process.env.BLOCKEDFILE; const bufferBlockedFile = Buffer.from(process.env.BLOCKEDFILE); -const blockedFileURL = new URL('file://' + process.env.BLOCKEDFILE); +const blockedFileURL = pathToFileURL(process.env.BLOCKEDFILE); const blockedFolder = process.env.BLOCKEDFOLDER; const allowedFolder = process.env.ALLOWEDFOLDER; const regularFile = __filename; diff --git a/test/parallel/test-diagnostics-channel-module-import-error.js b/test/parallel/test-diagnostics-channel-module-import-error.js index f3518e8fc55ae6..08ac8d0d8ffb0c 100644 --- a/test/parallel/test-diagnostics-channel-module-import-error.js +++ b/test/parallel/test-diagnostics-channel-module-import-error.js @@ -2,6 +2,7 @@ const common = require('../common'); const assert = require('assert'); const dc = require('diagnostics_channel'); +const { pathToFileURL } = require('url'); const trace = dc.tracingChannel('module.import'); const events = []; @@ -30,10 +31,7 @@ trace.subscribe({ import('does-not-exist').then( common.mustNotCall(), common.mustCall((error) => { - let expectedParentURL = module.filename.replaceAll('\\', '/'); - expectedParentURL = common.isWindows ? - `file:///${expectedParentURL}` : - `file://${expectedParentURL}`; + const expectedParentURL = pathToFileURL(module.filename).href; // Verify order and contents of each event assert.deepStrictEqual(events, [ { diff --git a/test/parallel/test-diagnostics-channel-module-import.js b/test/parallel/test-diagnostics-channel-module-import.js index 51ca24ed3d4515..dcd821d3ac789c 100644 --- a/test/parallel/test-diagnostics-channel-module-import.js +++ b/test/parallel/test-diagnostics-channel-module-import.js @@ -2,6 +2,7 @@ const common = require('../common'); const assert = require('assert'); const dc = require('diagnostics_channel'); +const { pathToFileURL } = require('url'); const trace = dc.tracingChannel('module.import'); const events = []; @@ -29,10 +30,7 @@ trace.subscribe({ import('http').then( common.mustCall((result) => { - let expectedParentURL = module.filename.replaceAll('\\', '/'); - expectedParentURL = common.isWindows ? - `file:///${expectedParentURL}` : - `file://${expectedParentURL}`; + const expectedParentURL = pathToFileURL(module.filename).href; // Verify order and contents of each event assert.deepStrictEqual(events, [ { From 8a4b26f00c55bbb3217accd1d9e4f75851e5305d Mon Sep 17 00:00:00 2001 From: Paolo Insogna Date: Sun, 25 Aug 2024 09:30:10 +0200 Subject: [PATCH 34/90] timers: fix validation PR-URL: https://github.com/nodejs/node/pull/54404 Reviewed-By: Claudio Wunder --- doc/api/timers.md | 5 +- lib/timers/promises.js | 91 +++++++++++-------- .../test-timers-timeout-promisified.js | 38 +++----- 3 files changed, 68 insertions(+), 66 deletions(-) diff --git a/doc/api/timers.md b/doc/api/timers.md index c9744aaf52cc32..3a4ebe834b934c 100644 --- a/doc/api/timers.md +++ b/doc/api/timers.md @@ -532,9 +532,8 @@ added: An experimental API defined by the [Scheduling APIs][] draft specification being developed as a standard Web Platform API. -Calling `timersPromises.scheduler.wait(delay, options)` is roughly equivalent -to calling `timersPromises.setTimeout(delay, undefined, options)` except that -the `ref` option is not supported. +Calling `timersPromises.scheduler.wait(delay, options)` is equivalent +to calling `timersPromises.setTimeout(delay, undefined, options)`. ```mjs import { scheduler } from 'node:timers/promises'; diff --git a/lib/timers/promises.js b/lib/timers/promises.js index 2bf36d6cc51700..d577ac9240ec17 100644 --- a/lib/timers/promises.js +++ b/lib/timers/promises.js @@ -24,7 +24,6 @@ const { AbortError, codes: { ERR_ILLEGAL_CONSTRUCTOR, - ERR_INVALID_ARG_TYPE, ERR_INVALID_THIS, }, } = require('internal/errors'); @@ -33,6 +32,7 @@ const { validateAbortSignal, validateBoolean, validateObject, + validateNumber, } = require('internal/validators'); const { @@ -50,34 +50,33 @@ function cancelListenerHandler(clear, reject, signal) { } function setTimeout(after, value, options = kEmptyObject) { - const args = value !== undefined ? [value] : value; - if (options == null || typeof options !== 'object') { - return PromiseReject( - new ERR_INVALID_ARG_TYPE( - 'options', - 'Object', - options)); - } - const { signal, ref = true } = options; try { - validateAbortSignal(signal, 'options.signal'); + if (typeof after !== 'undefined') { + validateNumber(after, 'delay'); + } + + validateObject(options, 'options'); + + if (typeof options?.signal !== 'undefined') { + validateAbortSignal(options.signal, 'options.signal'); + } + + if (typeof options?.ref !== 'undefined') { + validateBoolean(options.ref, 'options.ref'); + } } catch (err) { return PromiseReject(err); } - if (typeof ref !== 'boolean') { - return PromiseReject( - new ERR_INVALID_ARG_TYPE( - 'options.ref', - 'boolean', - ref)); - } + + const { signal, ref = true } = options; if (signal?.aborted) { return PromiseReject(new AbortError(undefined, { cause: signal.reason })); } + let oncancel; const ret = new Promise((resolve, reject) => { - const timeout = new Timeout(resolve, after, args, false, ref); + const timeout = new Timeout(resolve, after, [value], false, ref); insert(timeout, timeout._idleTimeout); if (signal) { oncancel = FunctionPrototypeBind(cancelListenerHandler, @@ -93,30 +92,26 @@ function setTimeout(after, value, options = kEmptyObject) { } function setImmediate(value, options = kEmptyObject) { - if (options == null || typeof options !== 'object') { - return PromiseReject( - new ERR_INVALID_ARG_TYPE( - 'options', - 'Object', - options)); - } - const { signal, ref = true } = options; try { - validateAbortSignal(signal, 'options.signal'); + validateObject(options, 'options'); + + if (typeof options?.signal !== 'undefined') { + validateAbortSignal(options.signal, 'options.signal'); + } + + if (typeof options?.ref !== 'undefined') { + validateBoolean(options.ref, 'options.ref'); + } } catch (err) { return PromiseReject(err); } - if (typeof ref !== 'boolean') { - return PromiseReject( - new ERR_INVALID_ARG_TYPE( - 'options.ref', - 'boolean', - ref)); - } + + const { signal, ref = true } = options; if (signal?.aborted) { return PromiseReject(new AbortError(undefined, { cause: signal.reason })); } + let oncancel; const ret = new Promise((resolve, reject) => { const immediate = new Immediate(resolve, [value]); @@ -136,13 +131,29 @@ function setImmediate(value, options = kEmptyObject) { } async function* setInterval(after, value, options = kEmptyObject) { - validateObject(options, 'options'); + try { + if (typeof after !== 'undefined') { + validateNumber(after, 'delay'); + } + + validateObject(options, 'options'); + + if (typeof options?.signal !== 'undefined') { + validateAbortSignal(options.signal, 'options.signal'); + } + + if (typeof options?.ref !== 'undefined') { + validateBoolean(options.ref, 'options.ref'); + } + } catch (err) { + return PromiseReject(err); + } + const { signal, ref = true } = options; - validateAbortSignal(signal, 'options.signal'); - validateBoolean(ref, 'options.ref'); - if (signal?.aborted) + if (signal?.aborted) { throw new AbortError(undefined, { cause: signal?.reason }); + } let onCancel; let interval; @@ -216,7 +227,7 @@ class Scheduler { wait(delay, options) { if (!this[kScheduler]) throw new ERR_INVALID_THIS('Scheduler'); - return setTimeout(delay, undefined, { signal: options?.signal }); + return setTimeout(delay, undefined, options); } } diff --git a/test/parallel/test-timers-timeout-promisified.js b/test/parallel/test-timers-timeout-promisified.js index a63923b7feea86..a89ccad7305f89 100644 --- a/test/parallel/test-timers-timeout-promisified.js +++ b/test/parallel/test-timers-timeout-promisified.js @@ -63,29 +63,21 @@ process.on('multipleResolves', common.mustNotCall()); } { - Promise.all( - [1, '', false, Infinity].map( - (i) => assert.rejects(setPromiseTimeout(10, null, i), { - code: 'ERR_INVALID_ARG_TYPE' - }) - ) - ).then(common.mustCall()); - - Promise.all( - [1, '', false, Infinity, null, {}].map( - (signal) => assert.rejects(setPromiseTimeout(10, null, { signal }), { - code: 'ERR_INVALID_ARG_TYPE' - }) - ) - ).then(common.mustCall()); - - Promise.all( - [1, '', Infinity, null, {}].map( - (ref) => assert.rejects(setPromiseTimeout(10, null, { ref }), { - code: 'ERR_INVALID_ARG_TYPE' - }) - ) - ).then(common.mustCall()); + for (const delay of ['', false]) { + assert.rejects(() => setPromiseTimeout(delay, null, {}), /ERR_INVALID_ARG_TYPE/).then(common.mustCall()); + } + + for (const options of [1, '', false, Infinity]) { + assert.rejects(() => setPromiseTimeout(10, null, options), /ERR_INVALID_ARG_TYPE/).then(common.mustCall()); + } + + for (const signal of [1, '', false, Infinity, null, {}]) { + assert.rejects(() => setPromiseTimeout(10, null, { signal }), /ERR_INVALID_ARG_TYPE/).then(common.mustCall()); + } + + for (const ref of [1, '', Infinity, null, {}]) { + assert.rejects(() => setPromiseTimeout(10, null, { ref }), /ERR_INVALID_ARG_TYPE/).then(common.mustCall()); + } } { From 290f6ce619ea116d478f01f05b763e797586ee67 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Sun, 25 Aug 2024 06:12:37 -0400 Subject: [PATCH 35/90] deps: update amaro to 0.1.8 PR-URL: https://github.com/nodejs/node/pull/54520 Reviewed-By: Marco Ippolito Reviewed-By: Benjamin Gruenbaum Reviewed-By: Claudio Wunder Reviewed-By: Rafael Gonzaga --- deps/amaro/dist/index.js | 9 ++++++++- deps/amaro/package.json | 2 +- src/amaro_version.h | 2 +- 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/deps/amaro/dist/index.js b/deps/amaro/dist/index.js index 10ad4d1fefcdf9..0122d2a3bd7df9 100644 --- a/deps/amaro/dist/index.js +++ b/deps/amaro/dist/index.js @@ -489,7 +489,14 @@ module.exports = __toCommonJS(src_exports); // src/transform.ts var import_wasm = __toESM(require_wasm()); var DEFAULT_OPTIONS = { - mode: "strip-only" + mode: "strip-only", + // default transform will only work when mode is "transform" + transform: { + verbatimModuleSyntax: true, + nativeClassProperties: true, + noEmptyExport: true, + importNotUsedAsValues: "preserve" + } }; function transformSync(source, options) { const input = `${source ?? ""}`; diff --git a/deps/amaro/package.json b/deps/amaro/package.json index 1cdbb4716df5f1..210ffca37854bb 100644 --- a/deps/amaro/package.json +++ b/deps/amaro/package.json @@ -1,6 +1,6 @@ { "name": "amaro", - "version": "0.1.7", + "version": "0.1.8", "description": "Node.js TypeScript wrapper", "license": "MIT", "type": "commonjs", diff --git a/src/amaro_version.h b/src/amaro_version.h index 13ca4d534b1f43..5f95a43bb3a95f 100644 --- a/src/amaro_version.h +++ b/src/amaro_version.h @@ -2,5 +2,5 @@ // Refer to tools/dep_updaters/update-amaro.sh #ifndef SRC_AMARO_VERSION_H_ #define SRC_AMARO_VERSION_H_ -#define AMARO_VERSION "0.1.7" +#define AMARO_VERSION "0.1.8" #endif // SRC_AMARO_VERSION_H_ From 72c554ababf6284d287b982301f5e19cf32ed02e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Sun, 25 Aug 2024 12:43:17 +0200 Subject: [PATCH 36/90] sqlite: return results with null prototype These objects are dictionaries, and a query can return columns with special names like `__proto__` (which would be ignored without this change). Also construct the object by passing vectors of properties for better performance and improve error handling by using `MaybeLocal`. PR-URL: https://github.com/nodejs/node/pull/54350 Reviewed-By: Benjamin Gruenbaum Reviewed-By: Yagiz Nizipli Reviewed-By: Franziska Hinkelmann Reviewed-By: James M Snell --- src/node_sqlite.cc | 88 ++++++++++--------- src/node_sqlite.h | 4 +- test/parallel/test-sqlite-data-types.js | 6 +- test/parallel/test-sqlite-database-sync.js | 4 +- test/parallel/test-sqlite-named-parameters.js | 4 +- test/parallel/test-sqlite-statement-sync.js | 21 +++-- test/parallel/test-sqlite-transactions.js | 2 +- test/parallel/test-sqlite.js | 8 +- 8 files changed, 76 insertions(+), 61 deletions(-) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 4821db5303501a..14b8263310279a 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -25,6 +25,10 @@ using v8::FunctionTemplate; using v8::Integer; using v8::Isolate; using v8::Local; +using v8::LocalVector; +using v8::MaybeLocal; +using v8::Name; +using v8::Null; using v8::Number; using v8::Object; using v8::String; @@ -405,7 +409,7 @@ bool StatementSync::BindValue(const Local& value, const int index) { return true; } -Local StatementSync::ColumnToValue(const int column) { +MaybeLocal StatementSync::ColumnToValue(const int column) { switch (sqlite3_column_type(statement_, column)) { case SQLITE_INTEGER: { sqlite3_int64 value = sqlite3_column_int64(statement_, column); @@ -419,7 +423,7 @@ Local StatementSync::ColumnToValue(const int column) { "represented as a JavaScript number: %" PRId64, column, value); - return Local(); + return MaybeLocal(); } } case SQLITE_FLOAT: @@ -428,14 +432,10 @@ Local StatementSync::ColumnToValue(const int column) { case SQLITE_TEXT: { const char* value = reinterpret_cast( sqlite3_column_text(statement_, column)); - Local val; - if (!String::NewFromUtf8(env()->isolate(), value).ToLocal(&val)) { - return Local(); - } - return val; + return String::NewFromUtf8(env()->isolate(), value).As(); } case SQLITE_NULL: - return v8::Null(env()->isolate()); + return Null(env()->isolate()); case SQLITE_BLOB: { size_t size = static_cast(sqlite3_column_bytes(statement_, column)); @@ -451,19 +451,15 @@ Local StatementSync::ColumnToValue(const int column) { } } -Local StatementSync::ColumnNameToValue(const int column) { +MaybeLocal StatementSync::ColumnNameToName(const int column) { const char* col_name = sqlite3_column_name(statement_, column); if (col_name == nullptr) { node::THROW_ERR_INVALID_STATE( env(), "Cannot get name of column %d", column); - return Local(); + return MaybeLocal(); } - Local key; - if (!String::NewFromUtf8(env()->isolate(), col_name).ToLocal(&key)) { - return Local(); - } - return key; + return String::NewFromUtf8(env()->isolate(), col_name).As(); } void StatementSync::MemoryInfo(MemoryTracker* tracker) const {} @@ -474,9 +470,9 @@ void StatementSync::All(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); THROW_AND_RETURN_ON_BAD_STATE( env, stmt->IsFinalized(), "statement has been finalized"); + Isolate* isolate = env->isolate(); int r = sqlite3_reset(stmt->statement_); - CHECK_ERROR_OR_THROW( - env->isolate(), stmt->db_->Connection(), r, SQLITE_OK, void()); + CHECK_ERROR_OR_THROW(isolate, stmt->db_->Connection(), r, SQLITE_OK, void()); if (!stmt->BindParams(args)) { return; @@ -484,28 +480,30 @@ void StatementSync::All(const FunctionCallbackInfo& args) { auto reset = OnScopeLeave([&]() { sqlite3_reset(stmt->statement_); }); int num_cols = sqlite3_column_count(stmt->statement_); - std::vector> rows; + LocalVector rows(isolate); while ((r = sqlite3_step(stmt->statement_)) == SQLITE_ROW) { - Local row = Object::New(env->isolate()); + LocalVector row_keys(isolate); + row_keys.reserve(num_cols); + LocalVector row_values(isolate); + row_values.reserve(num_cols); for (int i = 0; i < num_cols; ++i) { - Local key = stmt->ColumnNameToValue(i); - if (key.IsEmpty()) return; - Local val = stmt->ColumnToValue(i); - if (val.IsEmpty()) return; - - if (row->Set(env->context(), key, val).IsNothing()) { - return; - } + Local key; + if (!stmt->ColumnNameToName(i).ToLocal(&key)) return; + Local val; + if (!stmt->ColumnToValue(i).ToLocal(&val)) return; + row_keys.emplace_back(key); + row_values.emplace_back(val); } + Local row = Object::New( + isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols); rows.emplace_back(row); } CHECK_ERROR_OR_THROW( - env->isolate(), stmt->db_->Connection(), r, SQLITE_DONE, void()); - args.GetReturnValue().Set( - Array::New(env->isolate(), rows.data(), rows.size())); + isolate, stmt->db_->Connection(), r, SQLITE_DONE, void()); + args.GetReturnValue().Set(Array::New(isolate, rows.data(), rows.size())); } void StatementSync::Get(const FunctionCallbackInfo& args) { @@ -514,9 +512,9 @@ void StatementSync::Get(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); THROW_AND_RETURN_ON_BAD_STATE( env, stmt->IsFinalized(), "statement has been finalized"); + Isolate* isolate = env->isolate(); int r = sqlite3_reset(stmt->statement_); - CHECK_ERROR_OR_THROW( - env->isolate(), stmt->db_->Connection(), r, SQLITE_OK, void()); + CHECK_ERROR_OR_THROW(isolate, stmt->db_->Connection(), r, SQLITE_OK, void()); if (!stmt->BindParams(args)) { return; @@ -526,7 +524,7 @@ void StatementSync::Get(const FunctionCallbackInfo& args) { r = sqlite3_step(stmt->statement_); if (r == SQLITE_DONE) return; if (r != SQLITE_ROW) { - THROW_ERR_SQLITE_ERROR(env->isolate(), stmt->db_->Connection()); + THROW_ERR_SQLITE_ERROR(isolate, stmt->db_->Connection()); return; } @@ -535,19 +533,23 @@ void StatementSync::Get(const FunctionCallbackInfo& args) { return; } - Local result = Object::New(env->isolate()); + LocalVector keys(isolate); + keys.reserve(num_cols); + LocalVector values(isolate); + values.reserve(num_cols); for (int i = 0; i < num_cols; ++i) { - Local key = stmt->ColumnNameToValue(i); - if (key.IsEmpty()) return; - Local val = stmt->ColumnToValue(i); - if (val.IsEmpty()) return; - - if (result->Set(env->context(), key, val).IsNothing()) { - return; - } + Local key; + if (!stmt->ColumnNameToName(i).ToLocal(&key)) return; + Local val; + if (!stmt->ColumnToValue(i).ToLocal(&val)) return; + keys.emplace_back(key); + values.emplace_back(val); } + Local result = + Object::New(isolate, Null(isolate), keys.data(), values.data(), num_cols); + args.GetReturnValue().Set(result); } @@ -676,7 +678,7 @@ Local StatementSync::GetConstructorTemplate( if (tmpl.IsEmpty()) { Isolate* isolate = env->isolate(); tmpl = NewFunctionTemplate(isolate, IllegalConstructor); - tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "StatementSync")); + tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "StatementSync")); tmpl->InstanceTemplate()->SetInternalFieldCount( StatementSync::kInternalFieldCount); SetProtoMethod(isolate, tmpl, "all", StatementSync::All); diff --git a/src/node_sqlite.h b/src/node_sqlite.h index ca6e8c7f23cf40..f62b2e991cb95a 100644 --- a/src/node_sqlite.h +++ b/src/node_sqlite.h @@ -80,8 +80,8 @@ class StatementSync : public BaseObject { std::optional> bare_named_params_; bool BindParams(const v8::FunctionCallbackInfo& args); bool BindValue(const v8::Local& value, const int index); - v8::Local ColumnToValue(const int column); - v8::Local ColumnNameToValue(const int column); + v8::MaybeLocal ColumnToValue(const int column); + v8::MaybeLocal ColumnNameToName(const int column); }; } // namespace sqlite diff --git a/test/parallel/test-sqlite-data-types.js b/test/parallel/test-sqlite-data-types.js index 582d5bd611edf4..df77a90908eed5 100644 --- a/test/parallel/test-sqlite-data-types.js +++ b/test/parallel/test-sqlite-data-types.js @@ -49,6 +49,7 @@ suite('data binding and mapping', () => { const query = db.prepare('SELECT * FROM types WHERE key = ?'); t.assert.deepStrictEqual(query.get(1), { + __proto__: null, key: 1, int: 42, double: 3.14159, @@ -56,6 +57,7 @@ suite('data binding and mapping', () => { buf: u8a, }); t.assert.deepStrictEqual(query.get(2), { + __proto__: null, key: 2, int: null, double: null, @@ -63,6 +65,7 @@ suite('data binding and mapping', () => { buf: null, }); t.assert.deepStrictEqual(query.get(3), { + __proto__: null, key: 3, int: 8, double: 2.718, @@ -70,6 +73,7 @@ suite('data binding and mapping', () => { buf: new TextEncoder().encode('x☃y☃'), }); t.assert.deepStrictEqual(query.get(4), { + __proto__: null, key: 4, int: 99, double: 0xf, @@ -151,7 +155,7 @@ suite('data binding and mapping', () => { ); t.assert.deepStrictEqual( db.prepare('SELECT * FROM data ORDER BY key').all(), - [{ key: 1, val: 5 }, { key: 2, val: null }], + [{ __proto__: null, key: 1, val: 5 }, { __proto__: null, key: 2, val: null }], ); }); }); diff --git a/test/parallel/test-sqlite-database-sync.js b/test/parallel/test-sqlite-database-sync.js index 1bc409926ae446..e528daf227c507 100644 --- a/test/parallel/test-sqlite-database-sync.js +++ b/test/parallel/test-sqlite-database-sync.js @@ -143,8 +143,8 @@ suite('DatabaseSync.prototype.exec()', () => { t.assert.strictEqual(result, undefined); const stmt = db.prepare('SELECT * FROM data ORDER BY key'); t.assert.deepStrictEqual(stmt.all(), [ - { key: 1, val: 2 }, - { key: 8, val: 9 }, + { __proto__: null, key: 1, val: 2 }, + { __proto__: null, key: 8, val: 9 }, ]); }); diff --git a/test/parallel/test-sqlite-named-parameters.js b/test/parallel/test-sqlite-named-parameters.js index 27857111953d27..3060e252235401 100644 --- a/test/parallel/test-sqlite-named-parameters.js +++ b/test/parallel/test-sqlite-named-parameters.js @@ -42,7 +42,7 @@ suite('named parameters', () => { stmt.run({ k: 1, v: 9 }); t.assert.deepStrictEqual( db.prepare('SELECT * FROM data').get(), - { key: 1, val: 9 }, + { __proto__: null, key: 1, val: 9 }, ); }); @@ -57,7 +57,7 @@ suite('named parameters', () => { stmt.run({ k: 1 }); t.assert.deepStrictEqual( db.prepare('SELECT * FROM data').get(), - { key: 1, val: 1 }, + { __proto__: null, key: 1, val: 1 }, ); }); diff --git a/test/parallel/test-sqlite-statement-sync.js b/test/parallel/test-sqlite-statement-sync.js index 7a4069678af966..1052e9fb76390b 100644 --- a/test/parallel/test-sqlite-statement-sync.js +++ b/test/parallel/test-sqlite-statement-sync.js @@ -43,7 +43,15 @@ suite('StatementSync.prototype.get()', () => { t.assert.strictEqual(stmt.get('key1', 'val1'), undefined); t.assert.strictEqual(stmt.get('key2', 'val2'), undefined); stmt = db.prepare('SELECT * FROM storage ORDER BY key'); - t.assert.deepStrictEqual(stmt.get(), { key: 'key1', val: 'val1' }); + t.assert.deepStrictEqual(stmt.get(), { __proto__: null, key: 'key1', val: 'val1' }); + }); + + test('executes a query that returns special columns', (t) => { + const db = new DatabaseSync(nextDb()); + t.after(() => { db.close(); }); + const stmt = db.prepare('SELECT 1 as __proto__, 2 as constructor, 3 as toString'); + // eslint-disable-next-line no-dupe-keys + t.assert.deepStrictEqual(stmt.get(), { __proto__: null, ['__proto__']: 1, constructor: 2, toString: 3 }); }); }); @@ -71,8 +79,8 @@ suite('StatementSync.prototype.all()', () => { ); stmt = db.prepare('SELECT * FROM storage ORDER BY key'); t.assert.deepStrictEqual(stmt.all(), [ - { key: 'key1', val: 'val1' }, - { key: 'key2', val: 'val2' }, + { __proto__: null, key: 'key1', val: 'val1' }, + { __proto__: null, key: 'key2', val: 'val2' }, ]); }); }); @@ -171,11 +179,11 @@ suite('StatementSync.prototype.setReadBigInts()', () => { t.assert.strictEqual(setup, undefined); const query = db.prepare('SELECT val FROM data'); - t.assert.deepStrictEqual(query.get(), { val: 42 }); + t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42 }); t.assert.strictEqual(query.setReadBigInts(true), undefined); - t.assert.deepStrictEqual(query.get(), { val: 42n }); + t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42n }); t.assert.strictEqual(query.setReadBigInts(false), undefined); - t.assert.deepStrictEqual(query.get(), { val: 42 }); + t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42 }); const insert = db.prepare('INSERT INTO data (key) VALUES (?)'); t.assert.deepStrictEqual( @@ -223,6 +231,7 @@ suite('StatementSync.prototype.setReadBigInts()', () => { const good = db.prepare(`SELECT ${Number.MAX_SAFE_INTEGER} + 1`); good.setReadBigInts(true); t.assert.deepStrictEqual(good.get(), { + __proto__: null, [`${Number.MAX_SAFE_INTEGER} + 1`]: 2n ** 53n, }); }); diff --git a/test/parallel/test-sqlite-transactions.js b/test/parallel/test-sqlite-transactions.js index a37e635541bbf2..b5ed187e067e6d 100644 --- a/test/parallel/test-sqlite-transactions.js +++ b/test/parallel/test-sqlite-transactions.js @@ -37,7 +37,7 @@ suite('manual transactions', () => { ); t.assert.deepStrictEqual( db.prepare('SELECT * FROM data').all(), - [{ key: 100 }], + [{ __proto__: null, key: 100 }], ); }); diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js index 8acabb96fceab4..f8b122131fe7a2 100644 --- a/test/parallel/test-sqlite.js +++ b/test/parallel/test-sqlite.js @@ -77,11 +77,11 @@ test('in-memory databases are supported', (t) => { t.assert.strictEqual(setup2, undefined); t.assert.deepStrictEqual( db1.prepare('SELECT * FROM data').all(), - [{ key: 1 }] + [{ __proto__: null, key: 1 }] ); t.assert.deepStrictEqual( db2.prepare('SELECT * FROM data').all(), - [{ key: 1 }] + [{ __proto__: null, key: 1 }] ); }); @@ -90,10 +90,10 @@ test('PRAGMAs are supported', (t) => { t.after(() => { db.close(); }); t.assert.deepStrictEqual( db.prepare('PRAGMA journal_mode = WAL').get(), - { journal_mode: 'wal' }, + { __proto__: null, journal_mode: 'wal' }, ); t.assert.deepStrictEqual( db.prepare('PRAGMA journal_mode').get(), - { journal_mode: 'wal' }, + { __proto__: null, journal_mode: 'wal' }, ); }); From 94985df9d619fa822cfb1bed85ddd5e87a14b6fc Mon Sep 17 00:00:00 2001 From: Early Riser <80089617+EarlyRiser42@users.noreply.github.com> Date: Sun, 25 Aug 2024 09:41:13 -0400 Subject: [PATCH 37/90] benchmark: fix benchmark for file path and URL conversion PR-URL: https://github.com/nodejs/node/pull/54190 Reviewed-By: Daeyeon Jeong Reviewed-By: Antoine du Hamel --- benchmark/url/whatwg-url-to-and-from-path.js | 56 +++++++++++++------- 1 file changed, 37 insertions(+), 19 deletions(-) diff --git a/benchmark/url/whatwg-url-to-and-from-path.js b/benchmark/url/whatwg-url-to-and-from-path.js index 3b87c0670a8fee..366a8c98991f60 100644 --- a/benchmark/url/whatwg-url-to-and-from-path.js +++ b/benchmark/url/whatwg-url-to-and-from-path.js @@ -3,28 +3,46 @@ const common = require('../common.js'); const { fileURLToPath, pathToFileURL } = require('node:url'); const isWindows = process.platform === 'win32'; -const bench = common.createBenchmark(main, { - input: isWindows ? [ - 'file:///c/', - ] : [ - 'file:///dev/null', - 'file:///dev/null?key=param&bool', - 'file:///dev/null?key=param&bool#hash', - ], - method: isWindows ? [ - 'fileURLToPath', - ] : [ - 'fileURLToPath', - 'pathToFileURL', - ], - n: [5e6], -}); +const inputs = isWindows ? [ + 'C:\\foo', + 'C:\\Program Files\\Music\\Web Sys\\main.html?REQUEST=RADIO', + '\\\\nas\\My Docs\\File.doc', + '\\\\?\\UNC\\server\\share\\folder\\file.txt', + 'file:///C:/foo', + 'file:///C:/dir/foo?query=1', + 'file:///C:/dir/foo#fragment', +] : [ + '/dev/null', + '/dev/null?key=param&bool', + '/dev/null?key=param&bool#hash', + 'file:///dev/null', + 'file:///dev/null?key=param&bool', + 'file:///dev/null?key=param&bool#hash', +]; -function main({ n, input, method }) { - method = method === 'fileURLOrPath' ? fileURLToPath : pathToFileURL; +const bench = common.createBenchmark( + main, + { + method: ['pathToFileURL', 'fileURLToPath'], + input: Object.values(inputs), + n: [5e6], + }, + { + combinationFilter: (p) => ( + (isWindows ? + (!p.input.startsWith('file://') && p.method === 'pathToFileURL') : + p.method === 'pathToFileURL' + ) || + (p.input.startsWith('file://') && p.method === 'fileURLToPath') + ), + }, +); + +function main({ method, input, n }) { + const methodFunc = method === 'fileURLToPath' ? fileURLToPath : pathToFileURL; bench.start(); for (let i = 0; i < n; i++) { - method(input); + methodFunc(input); } bench.end(n); } From 66ae9f4c0a5910f9903e4b2f057b1892ac2aec50 Mon Sep 17 00:00:00 2001 From: Luigi Pinca Date: Mon, 26 Aug 2024 00:16:25 +0200 Subject: [PATCH 38/90] test: use valid hostnames Use valid hostnames in `test/sequential/test-net-server-listen-ipv6-link-local.js`. Refs: https://github.com/nodejs/node/pull/54554 PR-URL: https://github.com/nodejs/node/pull/54556 Reviewed-By: Yagiz Nizipli Reviewed-By: Antoine du Hamel --- .../test-net-server-listen-ipv6-link-local.js | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/sequential/test-net-server-listen-ipv6-link-local.js b/test/sequential/test-net-server-listen-ipv6-link-local.js index 56664c227cb5b7..284fb1bdec17f0 100644 --- a/test/sequential/test-net-server-listen-ipv6-link-local.js +++ b/test/sequential/test-net-server-listen-ipv6-link-local.js @@ -15,7 +15,7 @@ if (!common.hasIPv6) { mock.method(dns, 'lookup', (hostname, options, callback) => { callback(new Error('Mocked error')); }); - const host = 'ipv6_link_local'; + const host = 'ipv6-link-local'; const server = net.createServer(); @@ -30,13 +30,13 @@ if (!common.hasIPv6) { // Test on IPv6 Server, server.listen throws an error { mock.method(dns, 'lookup', (hostname, options, callback) => { - if (hostname === 'ipv6_link_local') { + if (hostname === 'ipv6-link-local') { callback(null, [{ address: 'fe80::1', family: 6 }]); } else { dns.lookup.wrappedMethod(hostname, options, callback); } }); - const host = 'ipv6_link_local'; + const host = 'ipv6-link-local'; const server = net.createServer(); @@ -52,7 +52,7 @@ if (!common.hasIPv6) { { mock.method(dns, 'lookup', (hostname, options, callback) => { - if (hostname === 'ipv6_link_local_with_many_entries') { + if (hostname === 'ipv6-link-local-with-many-entries') { callback(null, [ { address: 'fe80::1', family: 6 }, { address: 'fe80::abcd:1234', family: 6 }, @@ -84,7 +84,7 @@ if (!common.hasIPv6) { } }); - const host = 'ipv6_link_local_with_many_entries'; + const host = 'ipv6-link-local-with-many-entries'; const server = net.createServer(); @@ -103,11 +103,11 @@ if (!common.hasIPv6) { // Test on IPv6 Server, picks ::1 because the other address is a link-local address { - const host = 'ipv6_link_local_with_double_entry'; + const host = 'ipv6-link-local-with-double-entry'; const validIpv6Address = '::1'; mock.method(dns, 'lookup', (hostname, options, callback) => { - if (hostname === 'ipv6_link_local_with_double_entry') { + if (hostname === 'ipv6-link-local-with-double-entry') { callback(null, [ { address: 'fe80::1', family: 6 }, { address: validIpv6Address, family: 6 }, From 7d9e99479176ac8e6594ad612cc657c9b7b422e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= Date: Mon, 26 Aug 2024 13:11:27 +0200 Subject: [PATCH 39/90] src: change SetEncodedValue to return Maybe MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit With recent versions of V8, it is not necessary to use Maybe anymore. This changes SetEncodedValue to return Maybe instead. PR-URL: https://github.com/nodejs/node/pull/54443 Reviewed-By: Luigi Pinca Reviewed-By: Anna Henningsen Reviewed-By: Michaël Zasso --- src/crypto/crypto_ec.cc | 7 +------ src/crypto/crypto_util.cc | 16 ++++++++-------- src/crypto/crypto_util.h | 11 +++++------ 3 files changed, 14 insertions(+), 20 deletions(-) diff --git a/src/crypto/crypto_ec.cc b/src/crypto/crypto_ec.cc index d9e29a01d297e4..4a80f843336a3d 100644 --- a/src/crypto/crypto_ec.cc +++ b/src/crypto/crypto_ec.cc @@ -828,12 +828,7 @@ Maybe ExportJWKEcKey( if (key->GetKeyType() == kKeyTypePrivate) { const BIGNUM* pvt = EC_KEY_get0_private_key(ec); - return SetEncodedValue( - env, - target, - env->jwk_d_string(), - pvt, - degree_bytes).IsJust() ? JustVoid() : Nothing(); + return SetEncodedValue(env, target, env->jwk_d_string(), pvt, degree_bytes); } return JustVoid(); diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc index 501177f15cbdb0..4660be3cea1449 100644 --- a/src/crypto/crypto_util.cc +++ b/src/crypto/crypto_util.cc @@ -604,12 +604,11 @@ MaybeLocal EncodeBignum( error); } -Maybe SetEncodedValue( - Environment* env, - Local target, - Local name, - const BIGNUM* bn, - int size) { +Maybe SetEncodedValue(Environment* env, + Local target, + Local name, + const BIGNUM* bn, + int size) { Local value; Local error; CHECK_NOT_NULL(bn); @@ -617,9 +616,10 @@ Maybe SetEncodedValue( if (!EncodeBignum(env, bn, size, &error).ToLocal(&value)) { if (!error.IsEmpty()) env->isolate()->ThrowException(error); - return Nothing(); + return Nothing(); } - return target->Set(env->context(), name, value); + return target->Set(env->context(), name, value).IsJust() ? JustVoid() + : Nothing(); } bool SetRsaOaepLabel(const EVPKeyCtxPointer& ctx, const ByteSource& label) { diff --git a/src/crypto/crypto_util.h b/src/crypto/crypto_util.h index 680c30f42ab727..8756008d4ce3d2 100644 --- a/src/crypto/crypto_util.h +++ b/src/crypto/crypto_util.h @@ -713,12 +713,11 @@ v8::MaybeLocal EncodeBignum( int size, v8::Local* error); -v8::Maybe SetEncodedValue( - Environment* env, - v8::Local target, - v8::Local name, - const BIGNUM* bn, - int size = 0); +v8::Maybe SetEncodedValue(Environment* env, + v8::Local target, + v8::Local name, + const BIGNUM* bn, + int size = 0); bool SetRsaOaepLabel(const EVPKeyCtxPointer& rsa, const ByteSource& label); From b5eb24c86a454548633cf9990cde56e9cf5445cb Mon Sep 17 00:00:00 2001 From: Colin Ihrig Date: Mon, 26 Aug 2024 08:39:36 -0400 Subject: [PATCH 40/90] test: force spec reporter in test-runner-watch-mode.mjs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit In the CI this test generates TAP output that can confuse the Python test runner. Avoid the problem by not outputting TAP at from the spawned child process. Fixes: https://github.com/nodejs/node/issues/54535 PR-URL: https://github.com/nodejs/node/pull/54538 Reviewed-By: Luigi Pinca Reviewed-By: Michaël Zasso Reviewed-By: Matteo Collina Reviewed-By: Benjamin Gruenbaum Reviewed-By: James M Snell --- test/parallel/test-runner-watch-mode.mjs | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/test/parallel/test-runner-watch-mode.mjs b/test/parallel/test-runner-watch-mode.mjs index ee124493575103..fd7b47fb45149a 100644 --- a/test/parallel/test-runner-watch-mode.mjs +++ b/test/parallel/test-runner-watch-mode.mjs @@ -41,7 +41,8 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { const ran1 = util.createDeferredPromise(); const ran2 = util.createDeferredPromise(); const child = spawn(process.execPath, - ['--watch', '--test', file ? fixturePaths[file] : undefined].filter(Boolean), + ['--watch', '--test', '--test-reporter=spec', + file ? fixturePaths[file] : undefined].filter(Boolean), { encoding: 'utf8', stdio: 'pipe', cwd: tmpdir.path }); let stdout = ''; let currentRun = ''; @@ -50,7 +51,7 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { child.stdout.on('data', (data) => { stdout += data.toString(); currentRun += data.toString(); - const testRuns = stdout.match(/# duration_ms\s\d+/g); + const testRuns = stdout.match(/duration_ms\s\d+/g); if (testRuns?.length >= 1) ran1.resolve(); if (testRuns?.length >= 2) ran2.resolve(); }); @@ -71,10 +72,10 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { assert.strictEqual(runs.length, 2); for (const run of runs) { - assert.match(run, /# tests 1/); - assert.match(run, /# pass 1/); - assert.match(run, /# fail 0/); - assert.match(run, /# cancelled 0/); + assert.match(run, /tests 1/); + assert.match(run, /pass 1/); + assert.match(run, /fail 0/); + assert.match(run, /cancelled 0/); } }; @@ -94,10 +95,10 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { assert.strictEqual(runs.length, 2); for (const run of runs) { - assert.match(run, /# tests 1/); - assert.match(run, /# pass 1/); - assert.match(run, /# fail 0/); - assert.match(run, /# cancelled 0/); + assert.match(run, /tests 1/); + assert.match(run, /pass 1/); + assert.match(run, /fail 0/); + assert.match(run, /cancelled 0/); } }; From 4578e9485bf694ab0d4ff677495b57a3db541864 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Sat, 24 Aug 2024 14:51:26 +0200 Subject: [PATCH 41/90] src: use better return types in KVStore MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Use `v8::Maybe` instead of `v8::Maybe` and handle error from `AssignFromObject`. - An empty `v8::Maybe` is supposed to be returned when an exception is pending. Use `std::optional` instead to indicate a missing value in `Get(key)`. PR-URL: https://github.com/nodejs/node/pull/54539 Reviewed-By: Tobias Nießen Reviewed-By: Anna Henningsen Reviewed-By: James M Snell Reviewed-By: Rafael Gonzaga Reviewed-By: Mohammed Keyvanzadeh --- src/inspector_profiler.cc | 2 +- src/node_credentials.cc | 5 ++++- src/node_dotenv.cc | 2 +- src/node_env_var.cc | 39 ++++++++++++++++++++------------------- src/node_worker.cc | 20 ++++++++++++-------- src/util.h | 5 +++-- 6 files changed, 41 insertions(+), 32 deletions(-) diff --git a/src/inspector_profiler.cc b/src/inspector_profiler.cc index 5210d8a581c627..8cd39e091242bf 100644 --- a/src/inspector_profiler.cc +++ b/src/inspector_profiler.cc @@ -472,7 +472,7 @@ void StartProfilers(Environment* env) { }, env); std::string coverage_str = - env->env_vars()->Get("NODE_V8_COVERAGE").FromMaybe(std::string()); + env->env_vars()->Get("NODE_V8_COVERAGE").value_or(std::string()); if (!coverage_str.empty() || env->options()->test_runner_coverage) { CHECK_NULL(env->coverage_connection()); env->set_coverage_connection(std::make_unique(env)); diff --git a/src/node_credentials.cc b/src/node_credentials.cc index 80605c92012c31..6333c64231d30f 100644 --- a/src/node_credentials.cc +++ b/src/node_credentials.cc @@ -91,7 +91,10 @@ bool SafeGetenv(const char* key, env_vars = per_process::system_environment; } - return env_vars->Get(key).To(text); + std::optional value = env_vars->Get(key); + if (!value.has_value()) return false; + *text = value.value(); + return true; } static void SafeGetenv(const FunctionCallbackInfo& args) { diff --git a/src/node_dotenv.cc b/src/node_dotenv.cc index 8bc027b24c718f..1cb57fcaea2628 100644 --- a/src/node_dotenv.cc +++ b/src/node_dotenv.cc @@ -52,7 +52,7 @@ void Dotenv::SetEnvironment(node::Environment* env) { auto existing = env->env_vars()->Get(key.data()); - if (existing.IsNothing()) { + if (!existing.has_value()) { env->env_vars()->Set( isolate, v8::String::NewFromUtf8( diff --git a/src/node_env_var.cc b/src/node_env_var.cc index 85f82180d48d6c..fdf86f17d460f5 100644 --- a/src/node_env_var.cc +++ b/src/node_env_var.cc @@ -6,6 +6,7 @@ #include "node_process-inl.h" #include // tzset(), _tzset() +#include namespace node { using v8::Array; @@ -19,6 +20,7 @@ using v8::Integer; using v8::Intercepted; using v8::Isolate; using v8::Just; +using v8::JustVoid; using v8::Local; using v8::Maybe; using v8::MaybeLocal; @@ -38,7 +40,7 @@ using v8::Value; class RealEnvStore final : public KVStore { public: MaybeLocal Get(Isolate* isolate, Local key) const override; - Maybe Get(const char* key) const override; + std::optional Get(const char* key) const override; void Set(Isolate* isolate, Local key, Local value) override; int32_t Query(Isolate* isolate, Local key) const override; int32_t Query(const char* key) const override; @@ -49,7 +51,7 @@ class RealEnvStore final : public KVStore { class MapKVStore final : public KVStore { public: MaybeLocal Get(Isolate* isolate, Local key) const override; - Maybe Get(const char* key) const override; + std::optional Get(const char* key) const override; void Set(Isolate* isolate, Local key, Local value) override; int32_t Query(Isolate* isolate, Local key) const override; int32_t Query(const char* key) const override; @@ -101,7 +103,7 @@ void DateTimeConfigurationChangeNotification( } } -Maybe RealEnvStore::Get(const char* key) const { +std::optional RealEnvStore::Get(const char* key) const { Mutex::ScopedLock lock(per_process::env_var_mutex); size_t init_sz = 256; @@ -116,19 +118,19 @@ Maybe RealEnvStore::Get(const char* key) const { } if (ret >= 0) { // Env key value fetch success. - return Just(std::string(*val, init_sz)); + return std::string(*val, init_sz); } - return Nothing(); + return std::nullopt; } MaybeLocal RealEnvStore::Get(Isolate* isolate, Local property) const { node::Utf8Value key(isolate, property); - Maybe value = Get(*key); + std::optional value = Get(*key); - if (value.IsJust()) { - std::string val = value.FromJust(); + if (value.has_value()) { + std::string val = value.value(); return String::NewFromUtf8( isolate, val.data(), NewStringType::kNormal, val.size()); } @@ -229,17 +231,17 @@ std::shared_ptr KVStore::Clone(Isolate* isolate) const { return copy; } -Maybe MapKVStore::Get(const char* key) const { +std::optional MapKVStore::Get(const char* key) const { Mutex::ScopedLock lock(mutex_); auto it = map_.find(key); - return it == map_.end() ? Nothing() : Just(it->second); + return it == map_.end() ? std::nullopt : std::make_optional(it->second); } MaybeLocal MapKVStore::Get(Isolate* isolate, Local key) const { Utf8Value str(isolate, key); - Maybe value = Get(*str); - if (value.IsNothing()) return Local(); - std::string val = value.FromJust(); + std::optional value = Get(*str); + if (!value.has_value()) return MaybeLocal(); + std::string val = value.value(); return String::NewFromUtf8( isolate, val.data(), NewStringType::kNormal, val.size()); } @@ -291,30 +293,29 @@ std::shared_ptr KVStore::CreateMapKVStore() { return std::make_shared(); } -Maybe KVStore::AssignFromObject(Local context, +Maybe KVStore::AssignFromObject(Local context, Local entries) { Isolate* isolate = context->GetIsolate(); HandleScope handle_scope(isolate); Local keys; if (!entries->GetOwnPropertyNames(context).ToLocal(&keys)) - return Nothing(); + return Nothing(); uint32_t keys_length = keys->Length(); for (uint32_t i = 0; i < keys_length; i++) { Local key; - if (!keys->Get(context, i).ToLocal(&key)) - return Nothing(); + if (!keys->Get(context, i).ToLocal(&key)) return Nothing(); if (!key->IsString()) continue; Local value; Local value_string; if (!entries->Get(context, key).ToLocal(&value) || !value->ToString(context).ToLocal(&value_string)) { - return Nothing(); + return Nothing(); } Set(isolate, key.As(), value_string); } - return Just(true); + return JustVoid(); } // TODO(bnoordhuis) Not super efficient but called infrequently. Not worth diff --git a/src/node_worker.cc b/src/node_worker.cc index a946939a88fc58..e8026fe24c7021 100644 --- a/src/node_worker.cc +++ b/src/node_worker.cc @@ -531,8 +531,12 @@ void Worker::New(const FunctionCallbackInfo& args) { } else if (args[1]->IsObject()) { // User provided env. env_vars = KVStore::CreateMapKVStore(); - env_vars->AssignFromObject(isolate->GetCurrentContext(), - args[1].As()); + if (env_vars + ->AssignFromObject(isolate->GetCurrentContext(), + args[1].As()) + .IsNothing()) { + return; + } } else { // Env is shared. env_vars = env->env_vars(); @@ -542,21 +546,21 @@ void Worker::New(const FunctionCallbackInfo& args) { per_isolate_opts.reset(new PerIsolateOptions()); HandleEnvOptions(per_isolate_opts->per_env, [&env_vars](const char* name) { - return env_vars->Get(name).FromMaybe(""); + return env_vars->Get(name).value_or(""); }); #ifndef NODE_WITHOUT_NODE_OPTIONS - std::string node_options; - if (env_vars->Get("NODE_OPTIONS").To(&node_options)) { + std::optional node_options = env_vars->Get("NODE_OPTIONS"); + if (node_options.has_value()) { std::vector errors{}; std::vector env_argv = - ParseNodeOptionsEnvVar(node_options, &errors); + ParseNodeOptionsEnvVar(node_options.value(), &errors); // [0] is expected to be the program name, add dummy string. env_argv.insert(env_argv.begin(), ""); std::vector invalid_args{}; - std::string parent_node_options; - USE(env->env_vars()->Get("NODE_OPTIONS").To(&parent_node_options)); + std::optional parent_node_options = + env->env_vars()->Get("NODE_OPTIONS"); // If the worker code passes { env: { ...process.env, ... } } or // the NODE_OPTIONS is otherwise character-for-character equal to the diff --git a/src/util.h b/src/util.h index a3fa79f749d94e..a6da8720c499df 100644 --- a/src/util.h +++ b/src/util.h @@ -40,6 +40,7 @@ #include #include #include +#include #include #include #include @@ -306,7 +307,7 @@ class KVStore { virtual v8::MaybeLocal Get(v8::Isolate* isolate, v8::Local key) const = 0; - virtual v8::Maybe Get(const char* key) const = 0; + virtual std::optional Get(const char* key) const = 0; virtual void Set(v8::Isolate* isolate, v8::Local key, v8::Local value) = 0; @@ -317,7 +318,7 @@ class KVStore { virtual v8::Local Enumerate(v8::Isolate* isolate) const = 0; virtual std::shared_ptr Clone(v8::Isolate* isolate) const; - virtual v8::Maybe AssignFromObject(v8::Local context, + virtual v8::Maybe AssignFromObject(v8::Local context, v8::Local entries); v8::Maybe AssignToObject(v8::Isolate* isolate, v8::Local context, From 49381886827ed2d8ea4f08d92865ea3b66e3723c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Sat, 24 Aug 2024 16:33:04 +0200 Subject: [PATCH 42/90] src: return `v8::Object` from error constructors It's more specific than `v8::Value`. PR-URL: https://github.com/nodejs/node/pull/54541 Reviewed-By: Anna Henningsen Reviewed-By: Rafael Gonzaga Reviewed-By: James M Snell Reviewed-By: Mohammed Keyvanzadeh --- src/node_errors.h | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/src/node_errors.h b/src/node_errors.h index 8d70680171b1a8..171e2a2e09011c 100644 --- a/src/node_errors.h +++ b/src/node_errors.h @@ -113,7 +113,7 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details); #define V(code, type) \ template \ - inline v8::Local code( \ + inline v8::Local code( \ v8::Isolate* isolate, const char* format, Args&&... args) { \ std::string message = SPrintF(format, std::forward(args)...); \ v8::Local js_code = OneByteString(isolate, #code); \ @@ -209,17 +209,15 @@ ERRORS_WITH_CODE(V) "Accessing Object.prototype.__proto__ has been " \ "disallowed with --disable-proto=throw") -#define V(code, message) \ - inline v8::Local code(v8::Isolate* isolate) { \ - return code(isolate, message); \ - } \ - inline void THROW_ ## code(v8::Isolate* isolate) { \ - isolate->ThrowException(code(isolate, message)); \ - } \ - inline void THROW_ ## code(Environment* env) { \ - THROW_ ## code(env->isolate()); \ - } - PREDEFINED_ERROR_MESSAGES(V) +#define V(code, message) \ + inline v8::Local code(v8::Isolate* isolate) { \ + return code(isolate, message); \ + } \ + inline void THROW_##code(v8::Isolate* isolate) { \ + isolate->ThrowException(code(isolate, message)); \ + } \ + inline void THROW_##code(Environment* env) { THROW_##code(env->isolate()); } +PREDEFINED_ERROR_MESSAGES(V) #undef V // Errors with predefined non-static messages @@ -231,7 +229,7 @@ inline void THROW_ERR_SCRIPT_EXECUTION_TIMEOUT(Environment* env, THROW_ERR_SCRIPT_EXECUTION_TIMEOUT(env, message.str().c_str()); } -inline v8::Local ERR_BUFFER_TOO_LARGE(v8::Isolate* isolate) { +inline v8::Local ERR_BUFFER_TOO_LARGE(v8::Isolate* isolate) { char message[128]; snprintf(message, sizeof(message), @@ -240,7 +238,7 @@ inline v8::Local ERR_BUFFER_TOO_LARGE(v8::Isolate* isolate) { return ERR_BUFFER_TOO_LARGE(isolate, message); } -inline v8::Local ERR_STRING_TOO_LONG(v8::Isolate* isolate) { +inline v8::Local ERR_STRING_TOO_LONG(v8::Isolate* isolate) { char message[128]; snprintf(message, sizeof(message), "Cannot create a string longer than 0x%x characters", From 1ff3f63f5ed0390524d1037357edb2d79ca87500 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Sat, 24 Aug 2024 16:45:11 +0200 Subject: [PATCH 43/90] src: handle errors correctly in `permission.cc` Return an empty `MaybeLocal` to indicate that an exception is pending. PR-URL: https://github.com/nodejs/node/pull/54541 Reviewed-By: Anna Henningsen Reviewed-By: Rafael Gonzaga Reviewed-By: James M Snell Reviewed-By: Mohammed Keyvanzadeh --- src/permission/permission.cc | 49 ++++++++++++++++++------------------ 1 file changed, 24 insertions(+), 25 deletions(-) diff --git a/src/permission/permission.cc b/src/permission/permission.cc index ad393df0e38976..7c84aa044dbbf5 100644 --- a/src/permission/permission.cc +++ b/src/permission/permission.cc @@ -18,6 +18,8 @@ namespace node { using v8::Context; using v8::FunctionCallbackInfo; using v8::Local; +using v8::MaybeLocal; +using v8::NewStringType; using v8::Object; using v8::String; using v8::Value; @@ -105,46 +107,43 @@ Permission::Permission() : enabled_(false) { #undef V } -Local CreateAccessDeniedError(Environment* env, - PermissionScope perm, - const std::string_view& res) { - Local err = ERR_ACCESS_DENIED(env->isolate()); - CHECK(err->IsObject()); - if (err.As() - ->Set(env->context(), - env->permission_string(), - v8::String::NewFromUtf8(env->isolate(), - Permission::PermissionToString(perm), - v8::NewStringType::kNormal) - .ToLocalChecked()) +MaybeLocal CreateAccessDeniedError(Environment* env, + PermissionScope perm, + const std::string_view& res) { + Local err = ERR_ACCESS_DENIED(env->isolate()); + Local perm_string; + Local resource_string; + if (!String::NewFromUtf8(env->isolate(), + Permission::PermissionToString(perm), + NewStringType::kNormal) + .ToLocal(&perm_string) || + !String::NewFromUtf8( + env->isolate(), std::string(res).c_str(), NewStringType::kNormal) + .ToLocal(&resource_string) || + err->Set(env->context(), env->permission_string(), perm_string) .IsNothing() || - err.As() - ->Set(env->context(), - env->resource_string(), - v8::String::NewFromUtf8(env->isolate(), - std::string(res).c_str(), - v8::NewStringType::kNormal) - .ToLocalChecked()) - .IsNothing()) - return Local(); + err->Set(env->context(), env->resource_string(), resource_string) + .IsNothing()) { + return MaybeLocal(); + } return err; } void Permission::ThrowAccessDenied(Environment* env, PermissionScope perm, const std::string_view& res) { - Local err = CreateAccessDeniedError(env, perm, res); + MaybeLocal err = CreateAccessDeniedError(env, perm, res); if (err.IsEmpty()) return; - env->isolate()->ThrowException(err); + env->isolate()->ThrowException(err.ToLocalChecked()); } void Permission::AsyncThrowAccessDenied(Environment* env, fs::FSReqBase* req_wrap, PermissionScope perm, const std::string_view& res) { - Local err = CreateAccessDeniedError(env, perm, res); + MaybeLocal err = CreateAccessDeniedError(env, perm, res); if (err.IsEmpty()) return; - return req_wrap->Reject(err); + return req_wrap->Reject(err.ToLocalChecked()); } void Permission::EnablePermissions() { From 38798140c428265740628a22a0f2d234daba307b Mon Sep 17 00:00:00 2001 From: Aviv Keller <38299977+RedYetiDev@users.noreply.github.com> Date: Mon, 26 Aug 2024 16:43:19 -0400 Subject: [PATCH 44/90] tools: remove unused python files MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PR-URL: https://github.com/nodejs/node/pull/53928 Reviewed-By: Moshe Atlow Reviewed-By: Luigi Pinca Reviewed-By: James M Snell Reviewed-By: Ulises Gascón --- tools/getarch.py | 10 ---------- tools/getendian.py | 4 ---- tools/getmachine.py | 3 --- 3 files changed, 17 deletions(-) delete mode 100644 tools/getarch.py delete mode 100644 tools/getendian.py delete mode 100644 tools/getmachine.py diff --git a/tools/getarch.py b/tools/getarch.py deleted file mode 100644 index 3c366525463340..00000000000000 --- a/tools/getarch.py +++ /dev/null @@ -1,10 +0,0 @@ -from __future__ import print_function -from utils import GuessArchitecture -arch = GuessArchitecture() - -# assume 64 bit unless set specifically -print(GuessArchitecture() \ - .replace('ia32', 'x64') \ - .replace('ppc', 'ppc64') \ - .replace('arm', 'arm64') \ - .replace('s390', 's390x')) diff --git a/tools/getendian.py b/tools/getendian.py deleted file mode 100644 index 0f9fcc1c860584..00000000000000 --- a/tools/getendian.py +++ /dev/null @@ -1,4 +0,0 @@ -from __future__ import print_function -import sys -# "little" or "big" -print(sys.byteorder) diff --git a/tools/getmachine.py b/tools/getmachine.py deleted file mode 100644 index 046d8b17a797fd..00000000000000 --- a/tools/getmachine.py +++ /dev/null @@ -1,3 +0,0 @@ -from __future__ import print_function -import platform -print(platform.machine()) From 846e2b289601160b08b92949dc42758fc3b948cd Mon Sep 17 00:00:00 2001 From: Colin Ihrig Date: Mon, 26 Aug 2024 20:54:22 -0400 Subject: [PATCH 45/90] test: refactor test_runner tests to change default reporter This commit updates the test runner tests in order to switch the default reporter from tap to spec. This commit can be backported, while changing the default reporter cannot. Refs: https://github.com/nodejs/node/issues/54540 PR-URL: https://github.com/nodejs/node/pull/54547 Reviewed-By: Matteo Collina Reviewed-By: Benjamin Gruenbaum Reviewed-By: James M Snell Reviewed-By: Moshe Atlow Reviewed-By: Jake Yuesong Li --- test/common/assertSnapshot.js | 6 +- test/parallel/test-runner-cli.js | 24 ++- test/parallel/test-runner-exit-code.js | 10 +- .../test-runner-extraneous-async-activity.js | 44 ++--- .../test-runner-force-exit-failure.js | 3 +- test/parallel/test-runner-inspect.mjs | 7 +- test/parallel/test-runner-misc.js | 6 +- test/parallel/test-runner-module-mocking.js | 2 +- .../test-runner-no-isolation-filtering.js | 3 + test/parallel/test-runner-output.mjs | 184 ++++++++++++++---- test/parallel/test-runner-root-duration.js | 1 + test/parallel/test-runner-snapshot-tests.js | 12 +- .../test-runner-watch-mode-complex.mjs | 18 +- 13 files changed, 220 insertions(+), 100 deletions(-) diff --git a/test/common/assertSnapshot.js b/test/common/assertSnapshot.js index a22455160bd9f7..e0793ce5394cda 100644 --- a/test/common/assertSnapshot.js +++ b/test/common/assertSnapshot.js @@ -77,7 +77,11 @@ async function spawnAndAssert(filename, transform = (x) => x, { tty = false, ... test({ skip: 'Skipping pseudo-tty tests, as pseudo terminals are not available on Windows.' }); return; } - const flags = common.parseTestFlags(filename); + let flags = common.parseTestFlags(filename); + if (options.flags) { + flags = [...options.flags, ...flags]; + } + const executable = tty ? (process.env.PYTHON || 'python3') : process.execPath; const args = tty ? diff --git a/test/parallel/test-runner-cli.js b/test/parallel/test-runner-cli.js index d2d2eea8809404..8610d512561dff 100644 --- a/test/parallel/test-runner-cli.js +++ b/test/parallel/test-runner-cli.js @@ -26,7 +26,8 @@ for (const isolation of ['none', 'process']) { { // Default behavior. node_modules is ignored. Files that don't match the // pattern are ignored except in test/ directories. - const args = ['--test', `--experimental-test-isolation=${isolation}`]; + const args = ['--test', '--test-reporter=tap', + `--experimental-test-isolation=${isolation}`]; const child = spawnSync(process.execPath, args, { cwd: join(testFixtures, 'default-behavior') }); assert.strictEqual(child.status, 1); @@ -47,6 +48,7 @@ for (const isolation of ['none', 'process']) { const args = [ '--require', join(testFixtures, 'protoMutation.js'), '--test', + '--test-reporter=tap', `--experimental-test-isolation=${isolation}`, ]; const child = spawnSync(process.execPath, args, { cwd: join(testFixtures, 'default-behavior') }); @@ -67,6 +69,7 @@ for (const isolation of ['none', 'process']) { // User specified files that don't match the pattern are still run. const args = [ '--test', + '--test-reporter=tap', `--experimental-test-isolation=${isolation}`, join(testFixtures, 'index.js'), ]; @@ -83,6 +86,7 @@ for (const isolation of ['none', 'process']) { // Searches node_modules if specified. const args = [ '--test', + '--test-reporter=tap', `--experimental-test-isolation=${isolation}`, join(testFixtures, 'default-behavior/node_modules/*.js'), ]; @@ -105,18 +109,19 @@ for (const isolation of ['none', 'process']) { assert.strictEqual(child.signal, null); assert.strictEqual(child.stderr.toString(), ''); const stdout = child.stdout.toString(); - assert.match(stdout, /ok 1 - this should pass/); - assert.match(stdout, /not ok 2 - this should fail/); - assert.match(stdout, /ok 3 - subdir.+subdir_test\.js/); - assert.match(stdout, /ok 4 - this should pass/); - assert.match(stdout, /ok 5 - this should be skipped/); - assert.match(stdout, /ok 6 - this should be executed/); + assert.match(stdout, /this should pass/); + assert.match(stdout, /this should fail/); + assert.match(stdout, /subdir.+subdir_test\.js/); + assert.match(stdout, /this should pass/); + assert.match(stdout, /this should be skipped/); + assert.match(stdout, /this should be executed/); } { // Test combined stream outputs const args = [ '--test', + '--test-reporter=tap', `--experimental-test-isolation=${isolation}`, 'test/fixtures/test-runner/default-behavior/index.test.js', 'test/fixtures/test-runner/nested.js', @@ -189,6 +194,7 @@ for (const isolation of ['none', 'process']) { // Test user logging in tests. const args = [ '--test', + '--test-reporter=tap', 'test/fixtures/test-runner/user-logs.js', ]; const child = spawnSync(process.execPath, args); @@ -223,7 +229,7 @@ for (const isolation of ['none', 'process']) { assert.strictEqual(child.status, 0); assert.strictEqual(child.signal, null); const stdout = child.stdout.toString(); - assert.match(stdout, /ok 1 - this should pass/); + assert.match(stdout, /this should pass/); } { @@ -290,6 +296,7 @@ for (const isolation of ['none', 'process']) { // --test-shard option, first shard const args = [ '--test', + '--test-reporter=tap', '--test-shard=1/2', join(testFixtures, 'shards/*.cjs'), ]; @@ -324,6 +331,7 @@ for (const isolation of ['none', 'process']) { // --test-shard option, last shard const args = [ '--test', + '--test-reporter=tap', '--test-shard=2/2', join(testFixtures, 'shards/*.cjs'), ]; diff --git a/test/parallel/test-runner-exit-code.js b/test/parallel/test-runner-exit-code.js index 700480386d5b4a..d2f0251e5fb30c 100644 --- a/test/parallel/test-runner-exit-code.js +++ b/test/parallel/test-runner-exit-code.js @@ -12,7 +12,7 @@ async function runAndKill(file) { return; } let stdout = ''; - const child = spawn(process.execPath, ['--test', file]); + const child = spawn(process.execPath, ['--test', '--test-reporter=tap', file]); child.stdout.setEncoding('utf8'); child.stdout.on('data', (chunk) => { if (!stdout.length) child.kill('SIGINT'); @@ -58,10 +58,10 @@ if (process.argv[2] === 'child') { assert.strictEqual(child.status, 0); assert.strictEqual(child.signal, null); const stdout = child.stdout.toString(); - assert.match(stdout, /# tests 3/); - assert.match(stdout, /# pass 0/); - assert.match(stdout, /# fail 0/); - assert.match(stdout, /# todo 3/); + assert.match(stdout, /tests 3/); + assert.match(stdout, /pass 0/); + assert.match(stdout, /fail 0/); + assert.match(stdout, /todo 3/); child = spawnSync(process.execPath, [__filename, 'child', 'fail']); assert.strictEqual(child.status, 1); diff --git a/test/parallel/test-runner-extraneous-async-activity.js b/test/parallel/test-runner-extraneous-async-activity.js index 23f3194e02f106..58593fe70bbe10 100644 --- a/test/parallel/test-runner-extraneous-async-activity.js +++ b/test/parallel/test-runner-extraneous-async-activity.js @@ -10,10 +10,10 @@ const { spawnSync } = require('child_process'); fixtures.path('test-runner', 'extraneous_set_immediate_async.mjs'), ]); const stdout = child.stdout.toString(); - assert.match(stdout, /^# Error: Test "extraneous async activity test" at .+extraneous_set_immediate_async\.mjs:3:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# pass 1/m); - assert.match(stdout, /^# fail 1$/m); - assert.match(stdout, /^# cancelled 0$/m); + assert.match(stdout, /Error: Test "extraneous async activity test" at .+extraneous_set_immediate_async\.mjs:3:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /pass 1/m); + assert.match(stdout, /fail 1$/m); + assert.match(stdout, /cancelled 0$/m); assert.strictEqual(child.status, 1); assert.strictEqual(child.signal, null); } @@ -24,10 +24,10 @@ const { spawnSync } = require('child_process'); fixtures.path('test-runner', 'extraneous_set_timeout_async.mjs'), ]); const stdout = child.stdout.toString(); - assert.match(stdout, /^# Error: Test "extraneous async activity test" at .+extraneous_set_timeout_async\.mjs:3:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# pass 1$/m); - assert.match(stdout, /^# fail 1$/m); - assert.match(stdout, /^# cancelled 0$/m); + assert.match(stdout, /Error: Test "extraneous async activity test" at .+extraneous_set_timeout_async\.mjs:3:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /pass 1$/m); + assert.match(stdout, /fail 1$/m); + assert.match(stdout, /cancelled 0$/m); assert.strictEqual(child.status, 1); assert.strictEqual(child.signal, null); } @@ -38,13 +38,13 @@ const { spawnSync } = require('child_process'); fixtures.path('test-runner', 'async-error-in-test-hook.mjs'), ]); const stdout = child.stdout.toString(); - assert.match(stdout, /^# Error: Test hook "before" at .+async-error-in-test-hook\.mjs:3:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# Error: Test hook "beforeEach" at .+async-error-in-test-hook\.mjs:9:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# Error: Test hook "after" at .+async-error-in-test-hook\.mjs:15:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# Error: Test hook "afterEach" at .+async-error-in-test-hook\.mjs:21:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# pass 1$/m); - assert.match(stdout, /^# fail 1$/m); - assert.match(stdout, /^# cancelled 0$/m); + assert.match(stdout, /Error: Test hook "before" at .+async-error-in-test-hook\.mjs:3:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /Error: Test hook "beforeEach" at .+async-error-in-test-hook\.mjs:9:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /Error: Test hook "after" at .+async-error-in-test-hook\.mjs:15:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /Error: Test hook "afterEach" at .+async-error-in-test-hook\.mjs:21:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /pass 1$/m); + assert.match(stdout, /fail 1$/m); + assert.match(stdout, /cancelled 0$/m); assert.strictEqual(child.status, 1); assert.strictEqual(child.signal, null); } @@ -56,13 +56,13 @@ const { spawnSync } = require('child_process'); fixtures.path('test-runner', 'async-error-in-test-hook.mjs'), ]); const stdout = child.stdout.toString(); - assert.match(stdout, /^# Error: Test hook "before" at .+async-error-in-test-hook\.mjs:3:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# Error: Test hook "beforeEach" at .+async-error-in-test-hook\.mjs:9:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# Error: Test hook "after" at .+async-error-in-test-hook\.mjs:15:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# Error: Test hook "afterEach" at .+async-error-in-test-hook\.mjs:21:1 generated asynchronous activity after the test ended/m); - assert.match(stdout, /^# pass 1$/m); - assert.match(stdout, /^# fail 0$/m); - assert.match(stdout, /^# cancelled 0$/m); + assert.match(stdout, /Error: Test hook "before" at .+async-error-in-test-hook\.mjs:3:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /Error: Test hook "beforeEach" at .+async-error-in-test-hook\.mjs:9:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /Error: Test hook "after" at .+async-error-in-test-hook\.mjs:15:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /Error: Test hook "afterEach" at .+async-error-in-test-hook\.mjs:21:1 generated asynchronous activity after the test ended/m); + assert.match(stdout, /pass 1$/m); + assert.match(stdout, /fail 0$/m); + assert.match(stdout, /cancelled 0$/m); assert.strictEqual(child.status, 1); assert.strictEqual(child.signal, null); } diff --git a/test/parallel/test-runner-force-exit-failure.js b/test/parallel/test-runner-force-exit-failure.js index ce1f3208c5b4e6..ae2b21d7c61dc0 100644 --- a/test/parallel/test-runner-force-exit-failure.js +++ b/test/parallel/test-runner-force-exit-failure.js @@ -8,6 +8,7 @@ const fixture = fixtures.path('test-runner/throws_sync_and_async.js'); for (const isolation of ['none', 'process']) { const args = [ '--test', + '--test-reporter=spec', '--test-force-exit', `--experimental-test-isolation=${isolation}`, fixture, @@ -19,6 +20,6 @@ for (const isolation of ['none', 'process']) { strictEqual(r.stderr.toString(), ''); const stdout = r.stdout.toString(); - match(stdout, /error: 'fails'/); + match(stdout, /Error: fails/); doesNotMatch(stdout, /this should not have a chance to be thrown/); } diff --git a/test/parallel/test-runner-inspect.mjs b/test/parallel/test-runner-inspect.mjs index e4e6a7d35f4810..2161959498f15c 100644 --- a/test/parallel/test-runner-inspect.mjs +++ b/test/parallel/test-runner-inspect.mjs @@ -12,7 +12,7 @@ tmpdir.refresh(); { const child = new NodeInstance( - ['--test', '--inspect-brk=0'], + ['--test', '--test-reporter=tap', '--inspect-brk=0'], undefined, fixtures.path('test-runner/default-behavior/index.test.js') ); @@ -38,7 +38,10 @@ tmpdir.refresh(); { - const args = ['--test', '--inspect=0', fixtures.path('test-runner/index.js')]; + const args = [ + '--test', '--test-reporter=tap', '--inspect=0', + fixtures.path('test-runner/index.js'), + ]; const { stderr, stdout, code, signal } = await common.spawnPromisified(process.execPath, args); assert.match(stderr, diff --git a/test/parallel/test-runner-misc.js b/test/parallel/test-runner-misc.js index abc2715dcfba48..cea115493249a1 100644 --- a/test/parallel/test-runner-misc.js +++ b/test/parallel/test-runner-misc.js @@ -33,9 +33,9 @@ if (process.argv[2] === 'child') { } else { const child = spawnSync(process.execPath, [__filename, 'child', 'abortSignal']); const stdout = child.stdout.toString(); - assert.match(stdout, /^# pass 2$/m); - assert.match(stdout, /^# fail 0$/m); - assert.match(stdout, /^# cancelled 1$/m); + assert.match(stdout, /pass 2$/m); + assert.match(stdout, /fail 0$/m); + assert.match(stdout, /cancelled 1$/m); assert.strictEqual(child.status, 1); assert.strictEqual(child.signal, null); } diff --git a/test/parallel/test-runner-module-mocking.js b/test/parallel/test-runner-module-mocking.js index 45345815c69db4..f36dc13915b51a 100644 --- a/test/parallel/test-runner-module-mocking.js +++ b/test/parallel/test-runner-module-mocking.js @@ -571,7 +571,7 @@ test('node_modules can be used by both module systems', async (t) => { assert.strictEqual(code, 0); assert.strictEqual(signal, null); - assert.match(stdout, /# pass 1/); + assert.match(stdout, /pass 1/); }); test('file:// imports are supported in ESM only', async (t) => { diff --git a/test/parallel/test-runner-no-isolation-filtering.js b/test/parallel/test-runner-no-isolation-filtering.js index f8fba1cbfffbef..21db267d5323c6 100644 --- a/test/parallel/test-runner-no-isolation-filtering.js +++ b/test/parallel/test-runner-no-isolation-filtering.js @@ -11,6 +11,7 @@ const fixture2 = fixtures.path('test-runner', 'no-isolation', 'two.test.js'); test('works with --test-only', () => { const args = [ '--test', + '--test-reporter=tap', '--experimental-test-isolation=none', '--test-only', fixture1, @@ -33,6 +34,7 @@ test('works with --test-only', () => { test('works with --test-name-pattern', () => { const args = [ '--test', + '--test-reporter=tap', '--experimental-test-isolation=none', '--test-name-pattern=/test one/', fixture1, @@ -52,6 +54,7 @@ test('works with --test-name-pattern', () => { test('works with --test-skip-pattern', () => { const args = [ '--test', + '--test-reporter=tap', '--experimental-test-isolation=none', '--test-skip-pattern=/one/', fixture1, diff --git a/test/parallel/test-runner-output.mjs b/test/parallel/test-runner-output.mjs index 47e0f211f34a0d..6de1c2eeafce98 100644 --- a/test/parallel/test-runner-output.mjs +++ b/test/parallel/test-runner-output.mjs @@ -92,50 +92,116 @@ const lcovTransform = snapshot.transform( const tests = [ - { name: 'test-runner/output/abort.js' }, - { name: 'test-runner/output/abort-runs-after-hook.js' }, - { name: 'test-runner/output/abort_suite.js' }, - { name: 'test-runner/output/abort_hooks.js' }, - { name: 'test-runner/output/describe_it.js' }, - { name: 'test-runner/output/describe_nested.js' }, + { name: 'test-runner/output/abort.js', flags: ['--test-reporter=tap'] }, + { + name: 'test-runner/output/abort-runs-after-hook.js', + flags: ['--test-reporter=tap'], + }, + { name: 'test-runner/output/abort_suite.js', flags: ['--test-reporter=tap'] }, + { name: 'test-runner/output/abort_hooks.js', flags: ['--test-reporter=tap'] }, + { name: 'test-runner/output/describe_it.js', flags: ['--test-reporter=tap'] }, + { + name: 'test-runner/output/describe_nested.js', + flags: ['--test-reporter=tap'], + }, { name: 'test-runner/output/eval_dot.js', transform: specTransform }, { name: 'test-runner/output/eval_spec.js', transform: specTransform }, { name: 'test-runner/output/eval_tap.js' }, - { name: 'test-runner/output/filtered-suite-delayed-build.js' }, - { name: 'test-runner/output/filtered-suite-order.mjs' }, - { name: 'test-runner/output/filtered-suite-throws.js' }, - { name: 'test-runner/output/hooks.js' }, + { + name: 'test-runner/output/filtered-suite-delayed-build.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/filtered-suite-order.mjs', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/filtered-suite-throws.js', + flags: ['--test-reporter=tap'], + }, + { name: 'test-runner/output/hooks.js', flags: ['--test-reporter=tap'] }, { name: 'test-runner/output/hooks_spec_reporter.js', transform: specTransform }, { name: 'test-runner/output/skip-each-hooks.js', transform: specTransform }, { name: 'test-runner/output/suite-skip-hooks.js', transform: specTransform }, - { name: 'test-runner/output/timeout_in_before_each_should_not_affect_further_tests.js' }, - { name: 'test-runner/output/hooks-with-no-global-test.js' }, - { name: 'test-runner/output/global-hooks-with-no-tests.js' }, - { name: 'test-runner/output/before-and-after-each-too-many-listeners.js' }, - { name: 'test-runner/output/before-and-after-each-with-timeout-too-many-listeners.js' }, + { + name: 'test-runner/output/timeout_in_before_each_should_not_affect_further_tests.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/hooks-with-no-global-test.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/global-hooks-with-no-tests.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/before-and-after-each-too-many-listeners.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/before-and-after-each-with-timeout-too-many-listeners.js', + flags: ['--test-reporter=tap'], + }, { name: 'test-runner/output/force_exit.js', transform: specTransform }, - { name: 'test-runner/output/global_after_should_fail_the_test.js' }, - { name: 'test-runner/output/no_refs.js' }, - { name: 'test-runner/output/no_tests.js' }, - { name: 'test-runner/output/only_tests.js' }, + { + name: 'test-runner/output/global_after_should_fail_the_test.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/no_refs.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/no_tests.js', + flags: ['--test-reporter=tap'], + }, + { name: 'test-runner/output/only_tests.js', flags: ['--test-reporter=tap'] }, { name: 'test-runner/output/dot_reporter.js', transform: specTransform }, { name: 'test-runner/output/junit_reporter.js', transform: junitTransform }, { name: 'test-runner/output/spec_reporter_successful.js', transform: specTransform }, { name: 'test-runner/output/spec_reporter.js', transform: specTransform }, { name: 'test-runner/output/spec_reporter_cli.js', transform: specTransform }, - { name: 'test-runner/output/source_mapped_locations.mjs' }, + { + name: 'test-runner/output/source_mapped_locations.mjs', + flags: ['--test-reporter=tap'], + }, process.features.inspector ? { name: 'test-runner/output/lcov_reporter.js', transform: lcovTransform } : false, - { name: 'test-runner/output/output.js' }, + { name: 'test-runner/output/output.js', flags: ['--test-reporter=tap'] }, { name: 'test-runner/output/output_cli.js' }, - { name: 'test-runner/output/name_and_skip_patterns.js' }, - { name: 'test-runner/output/name_pattern.js' }, - { name: 'test-runner/output/name_pattern_with_only.js' }, - { name: 'test-runner/output/skip_pattern.js' }, - { name: 'test-runner/output/unfinished-suite-async-error.js' }, - { name: 'test-runner/output/unresolved_promise.js' }, + { + name: 'test-runner/output/name_and_skip_patterns.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/name_pattern.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/name_pattern_with_only.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/skip_pattern.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/unfinished-suite-async-error.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/unresolved_promise.js', + flags: ['--test-reporter=tap'], + }, { name: 'test-runner/output/default_output.js', transform: specTransform, tty: true }, - { name: 'test-runner/output/arbitrary-output.js' }, - { name: 'test-runner/output/async-test-scheduling.mjs' }, + { + name: 'test-runner/output/arbitrary-output.js', + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/async-test-scheduling.mjs', + flags: ['--test-reporter=tap'], + }, !skipForceColors ? { name: 'test-runner/output/arbitrary-output-colored.js', transform: snapshot.transform(specTransform, replaceTestDuration), tty: true @@ -147,24 +213,58 @@ const tests = [ snapshot.replaceWindowsLineEndings, replaceTestDuration, ), + flags: ['--test-reporter=tap'], + }, + { + name: 'test-runner/output/test-runner-plan.js', + flags: ['--test-reporter=tap'], }, - { name: 'test-runner/output/test-runner-plan.js' }, - process.features.inspector ? { name: 'test-runner/output/coverage_failure.js' } : false, - { name: 'test-runner/output/test-diagnostic-warning-without-test-only-flag.js' }, - process.features.inspector ? { name: 'test-runner/output/coverage-width-80.mjs' } : false, - process.features.inspector ? { name: 'test-runner/output/coverage-width-100.mjs' } : false, - process.features.inspector ? { name: 'test-runner/output/coverage-width-150.mjs' } : false, - process.features.inspector ? { name: 'test-runner/output/coverage-width-infinity.mjs' } : false, - process.features.inspector ? { name: 'test-runner/output/coverage-width-80-uncovered-lines.mjs' } : false, - process.features.inspector ? { name: 'test-runner/output/coverage-width-100-uncovered-lines.mjs' } : false, - process.features.inspector ? { name: 'test-runner/output/coverage-width-150-uncovered-lines.mjs' } : false, - process.features.inspector ? { name: 'test-runner/output/coverage-width-infinity-uncovered-lines.mjs' } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage_failure.js', + flags: ['--test-reporter=tap'], + } : false, + { + name: 'test-runner/output/test-diagnostic-warning-without-test-only-flag.js', + flags: ['--test-reporter=tap'], + }, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-80.mjs', + flags: ['--test-reporter=tap'], + } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-100.mjs', + flags: ['--test-reporter=tap'], + } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-150.mjs', + flags: ['--test-reporter=tap'], + } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-infinity.mjs', + flags: ['--test-reporter=tap'], + } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-80-uncovered-lines.mjs', + flags: ['--test-reporter=tap'], + } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-100-uncovered-lines.mjs', + flags: ['--test-reporter=tap'], + } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-150-uncovered-lines.mjs', + flags: ['--test-reporter=tap'], + } : false, + process.features.inspector ? { + name: 'test-runner/output/coverage-width-infinity-uncovered-lines.mjs', + flags: ['--test-reporter=tap'], + } : false, ] .filter(Boolean) -.map(({ name, tty, transform }) => ({ +.map(({ flags, name, tty, transform }) => ({ name, fn: common.mustCall(async () => { - await snapshot.spawnAndAssert(fixtures.path(name), transform ?? defaultTransform, { tty }); + await snapshot.spawnAndAssert(fixtures.path(name), transform ?? defaultTransform, { tty, flags }); }), })); diff --git a/test/parallel/test-runner-root-duration.js b/test/parallel/test-runner-root-duration.js index 0c1b69359cc497..73718a8bf00be0 100644 --- a/test/parallel/test-runner-root-duration.js +++ b/test/parallel/test-runner-root-duration.js @@ -10,6 +10,7 @@ test('root duration is longer than test duration', async () => { stderr, stdout, } = await spawnPromisified(process.execPath, [ + '--test-reporter=tap', fixtures.path('test-runner/root-duration.mjs'), ]); diff --git a/test/parallel/test-runner-snapshot-tests.js b/test/parallel/test-runner-snapshot-tests.js index 62ebdd3cade2fb..bad3645f5fa183 100644 --- a/test/parallel/test-runner-snapshot-tests.js +++ b/test/parallel/test-runner-snapshot-tests.js @@ -305,9 +305,9 @@ test('t.assert.snapshot()', async (t) => { t.assert.strictEqual(child.code, 1); t.assert.strictEqual(child.signal, null); - t.assert.match(child.stdout, /# tests 5/); - t.assert.match(child.stdout, /# pass 0/); - t.assert.match(child.stdout, /# fail 5/); + t.assert.match(child.stdout, /tests 5/); + t.assert.match(child.stdout, /pass 0/); + t.assert.match(child.stdout, /fail 5/); t.assert.match(child.stdout, /Missing snapshots/); }); @@ -362,9 +362,9 @@ test('snapshots from multiple files (isolation=none)', async (t) => { t.assert.strictEqual(child.code, 1); t.assert.strictEqual(child.signal, null); - t.assert.match(child.stdout, /# tests 6/); - t.assert.match(child.stdout, /# pass 0/); - t.assert.match(child.stdout, /# fail 6/); + t.assert.match(child.stdout, /tests 6/); + t.assert.match(child.stdout, /pass 0/); + t.assert.match(child.stdout, /fail 6/); t.assert.match(child.stdout, /Missing snapshots/); }); diff --git a/test/parallel/test-runner-watch-mode-complex.mjs b/test/parallel/test-runner-watch-mode-complex.mjs index 62966d57964276..0ec9a225c3501c 100644 --- a/test/parallel/test-runner-watch-mode-complex.mjs +++ b/test/parallel/test-runner-watch-mode-complex.mjs @@ -63,7 +63,7 @@ describe('test runner watch mode with more complex setup', () => { child.stdout.on('data', (data) => { stdout += data.toString(); currentRun += data.toString(); - const testRuns = stdout.match(/# duration_ms\s\d+/g); + const testRuns = stdout.match(/duration_ms\s\d+/g); if (testRuns?.length >= 2) { ran2.resolve(); @@ -91,14 +91,14 @@ describe('test runner watch mode with more complex setup', () => { const [firstRun, secondRun] = runs; - assert.match(firstRun, /# tests 3/); - assert.match(firstRun, /# pass 3/); - assert.match(firstRun, /# fail 0/); - assert.match(firstRun, /# cancelled 0/); + assert.match(firstRun, /tests 3/); + assert.match(firstRun, /pass 3/); + assert.match(firstRun, /fail 0/); + assert.match(firstRun, /cancelled 0/); - assert.match(secondRun, /# tests 2/); - assert.match(secondRun, /# pass 2/); - assert.match(secondRun, /# fail 0/); - assert.match(secondRun, /# cancelled 0/); + assert.match(secondRun, /tests 2/); + assert.match(secondRun, /pass 2/); + assert.match(secondRun, /fail 0/); + assert.match(secondRun, /cancelled 0/); }); }); From fe56949cbbc4ed0bfdf5f84dd965b78e3617b0da Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 26 Aug 2024 20:54:35 -0400 Subject: [PATCH 46/90] deps: update c-ares to v1.33.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PR-URL: https://github.com/nodejs/node/pull/54549 Reviewed-By: Luigi Pinca Reviewed-By: Michaël Zasso Reviewed-By: Mohammed Keyvanzadeh Reviewed-By: James M Snell Reviewed-By: Marco Ippolito Reviewed-By: Rafael Gonzaga --- deps/cares/CMakeLists.txt | 15 +- deps/cares/Makefile.in | 2 + deps/cares/RELEASE-NOTES.md | 32 + deps/cares/aminclude_static.am | 2 +- deps/cares/configure | 562 ++++++++++-------- deps/cares/configure.ac | 12 +- deps/cares/docs/Makefile.in | 2 + deps/cares/include/Makefile.in | 2 + deps/cares/include/ares_version.h | 4 +- deps/cares/libcares.pc.cmake | 7 +- deps/cares/src/Makefile.in | 2 + deps/cares/src/lib/Makefile.in | 4 +- deps/cares/src/lib/ares__close_sockets.c | 2 +- deps/cares/src/lib/ares__socket.c | 2 +- deps/cares/src/lib/ares_android.c | 3 +- deps/cares/src/lib/ares_cookie.c | 3 +- deps/cares/src/lib/ares_getaddrinfo.c | 7 + deps/cares/src/lib/ares_metrics.c | 2 +- deps/cares/src/lib/ares_private.h | 12 +- deps/cares/src/lib/ares_process.c | 21 +- deps/cares/src/lib/ares_qcache.c | 12 +- deps/cares/src/lib/ares_search.c | 72 ++- deps/cares/src/lib/ares_send.c | 6 +- deps/cares/src/lib/ares_sysconfig.c | 3 +- deps/cares/src/lib/dsa/ares__htable.c | 2 +- .../src/lib/event/ares_event_configchg.c | 5 +- deps/cares/src/lib/str/ares__buf.c | 6 +- deps/cares/src/tools/Makefile.in | 2 + 28 files changed, 495 insertions(+), 311 deletions(-) diff --git a/deps/cares/CMakeLists.txt b/deps/cares/CMakeLists.txt index d3f6907564868e..9862406495f4fa 100644 --- a/deps/cares/CMakeLists.txt +++ b/deps/cares/CMakeLists.txt @@ -12,7 +12,7 @@ INCLUDE (CheckCSourceCompiles) INCLUDE (CheckStructHasMember) INCLUDE (CheckLibraryExists) -PROJECT (c-ares LANGUAGES C VERSION "1.33.0" ) +PROJECT (c-ares LANGUAGES C VERSION "1.33.1" ) # Set this version before release SET (CARES_VERSION "${PROJECT_VERSION}") @@ -30,7 +30,7 @@ INCLUDE (GNUInstallDirs) # include this *AFTER* PROJECT(), otherwise paths are w # For example, a version of 4:0:2 would generate output such as: # libname.so -> libname.so.2 # libname.so.2 -> libname.so.2.2.0 -SET (CARES_LIB_VERSIONINFO "20:0:18") +SET (CARES_LIB_VERSIONINFO "20:1:18") OPTION (CARES_STATIC "Build as a static library" OFF) @@ -772,12 +772,11 @@ IF (CARES_INSTALL) INSTALL (EXPORT ${PROJECT_NAME}-targets COMPONENT Devel DESTINATION ${CMAKECONFIG_INSTALL_DIR} NAMESPACE ${PROJECT_NAME}::) INSTALL (FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake" COMPONENT Devel DESTINATION ${CMAKECONFIG_INSTALL_DIR}) - # pkgconfig support - IF (NOT CARES_SHARED) - FOREACH (LIB ${CARES_DEPENDENT_LIBS}) - SET (CARES_PRIVATE_LIBS "${CARES_PRIVATE_LIBS} -l${LIB}") - ENDFOREACH () - ENDIF () + # pkgconfig support for static builds + FOREACH (LIB ${CARES_DEPENDENT_LIBS}) + SET (CARES_PRIVATE_LIBS "${CARES_PRIVATE_LIBS} -l${LIB}") + ENDFOREACH () + CONFIGURE_FILE("libcares.pc.cmake" "libcares.pc" @ONLY) INSTALL (FILES "${CMAKE_CURRENT_BINARY_DIR}/libcares.pc" COMPONENT Devel DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") ENDIF () diff --git a/deps/cares/Makefile.in b/deps/cares/Makefile.in index 4feaae7267c0fc..706dafdbdfc5fa 100644 --- a/deps/cares/Makefile.in +++ b/deps/cares/Makefile.in @@ -328,6 +328,8 @@ FGREP = @FGREP@ FILECMD = @FILECMD@ GCOV = @GCOV@ GENHTML = @GENHTML@ +GMOCK112_CFLAGS = @GMOCK112_CFLAGS@ +GMOCK112_LIBS = @GMOCK112_LIBS@ GMOCK_CFLAGS = @GMOCK_CFLAGS@ GMOCK_LIBS = @GMOCK_LIBS@ GREP = @GREP@ diff --git a/deps/cares/RELEASE-NOTES.md b/deps/cares/RELEASE-NOTES.md index b072feb29fdebe..e9c04953dc6022 100644 --- a/deps/cares/RELEASE-NOTES.md +++ b/deps/cares/RELEASE-NOTES.md @@ -1,3 +1,35 @@ +## c-ares version 1.33.1 - August 23 2024 + +This is a bugfix release. + +Bugfixes: +* Work around systemd-resolved quirk that returns unexpected codes for single + label names. Also adds test cases to validate the work around works and + will continue to work in future releases. + [PR #863](https://github.com/c-ares/c-ares/pull/863), + See Also https://github.com/systemd/systemd/issues/34101 +* Fix sysconfig ndots default value, also adds containerized test case to + prevent future regressions. + [PR #862](https://github.com/c-ares/c-ares/pull/862) +* Fix blank DNS name returning error code rather than valid record for + commands like: `adig -t SOA .`. Also adds test case to prevent future + regressions. + [9e574af](https://github.com/c-ares/c-ares/commit/9e574af) +* Fix calculation of query times > 1s. + [2b2eae7](https://github.com/c-ares/c-ares/commit/2b2eae7) +* Fix building on old Linux releases that don't have `TCP_FASTOPEN_CONNECT`. + [b7a89b9](https://github.com/c-ares/c-ares/commit/b7a89b9) +* Fix minor Android build warnings. + [PR #848](https://github.com/c-ares/c-ares/pull/848) + +Thanks go to these friendly people for their efforts and contributions for this +release: +* Brad House (@bradh352) +* Erik Lax (@eriklax) +* Hans-Christian Egtvedt (@egtvedt) +* Mikael Lindemann (@mikaellindemann) +* Nodar Chkuaselidze (@nodech) + ## c-ares version 1.33.0 - August 2 2024 This is a feature and bugfix release. diff --git a/deps/cares/aminclude_static.am b/deps/cares/aminclude_static.am index 436bfe5a5be5d1..538a810c9eb0ee 100644 --- a/deps/cares/aminclude_static.am +++ b/deps/cares/aminclude_static.am @@ -1,6 +1,6 @@ # aminclude_static.am generated automatically by Autoconf -# from AX_AM_MACROS_STATIC on Fri Aug 2 08:48:39 EDT 2024 +# from AX_AM_MACROS_STATIC on Fri Aug 23 09:37:25 EDT 2024 # Code coverage diff --git a/deps/cares/configure b/deps/cares/configure index d9dad13dd30287..74e9741fe6ee7a 100755 --- a/deps/cares/configure +++ b/deps/cares/configure @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.72 for c-ares 1.33.0. +# Generated by GNU Autoconf 2.72 for c-ares 1.33.1. # # Report bugs to . # @@ -614,8 +614,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='c-ares' PACKAGE_TARNAME='c-ares' -PACKAGE_VERSION='1.33.0' -PACKAGE_STRING='c-ares 1.33.0' +PACKAGE_VERSION='1.33.1' +PACKAGE_STRING='c-ares 1.33.1' PACKAGE_BUGREPORT='c-ares mailing list: http://lists.haxx.se/listinfo/c-ares' PACKAGE_URL='' @@ -663,6 +663,8 @@ AM_CPPFLAGS AM_CFLAGS BUILD_TESTS_FALSE BUILD_TESTS_TRUE +GMOCK112_LIBS +GMOCK112_CFLAGS GMOCK_LIBS GMOCK_CFLAGS PKG_CONFIG_LIBDIR @@ -868,7 +870,9 @@ PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR GMOCK_CFLAGS -GMOCK_LIBS' +GMOCK_LIBS +GMOCK112_CFLAGS +GMOCK112_LIBS' # Initialize some variables set by options. @@ -1417,7 +1421,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -'configure' configures c-ares 1.33.0 to adapt to many kinds of systems. +'configure' configures c-ares 1.33.1 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1488,7 +1492,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of c-ares 1.33.0:";; + short | recursive ) echo "Configuration of c-ares 1.33.1:";; esac cat <<\_ACEOF @@ -1557,6 +1561,10 @@ Some influential environment variables: GMOCK_CFLAGS C compiler flags for GMOCK, overriding pkg-config GMOCK_LIBS linker flags for GMOCK, overriding pkg-config + GMOCK112_CFLAGS + C compiler flags for GMOCK112, overriding pkg-config + GMOCK112_LIBS + linker flags for GMOCK112, overriding pkg-config Use these variables to override the choices made by 'configure' or to help it to find libraries and programs with nonstandard names/locations. @@ -1625,7 +1633,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -c-ares configure 1.33.0 +c-ares configure 1.33.1 generated by GNU Autoconf 2.72 Copyright (C) 2023 Free Software Foundation, Inc. @@ -1953,50 +1961,6 @@ fi } # ac_fn_cxx_try_link -# ac_fn_c_try_run LINENO -# ---------------------- -# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that -# executables *can* be run. -ac_fn_c_try_run () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' - { { case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; } -then : - ac_retval=0 -else case e in #( - e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5 - printf "%s\n" "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=$ac_status ;; -esac -fi - rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - as_fn_set_status $ac_retval - -} # ac_fn_c_try_run - # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. @@ -2245,6 +2209,50 @@ printf "%s\n" "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_member + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that +# executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf "%s\n" "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf "%s\n" "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; } +then : + ac_retval=0 +else case e in #( + e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5 + printf "%s\n" "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status ;; +esac +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run ac_configure_args_raw= for ac_arg do @@ -2269,7 +2277,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by c-ares $as_me 1.33.0, which was +It was created by c-ares $as_me 1.33.1, which was generated by GNU Autoconf 2.72. Invocation command line was $ $0$ac_configure_args_raw @@ -3261,7 +3269,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu -CARES_VERSION_INFO="20:0:18" +CARES_VERSION_INFO="20:1:18" @@ -6182,7 +6190,7 @@ fi # Define the identity of the package. PACKAGE='c-ares' - VERSION='1.33.0' + VERSION='1.33.1' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h @@ -20044,190 +20052,6 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether user namespaces are supported" >&5 -printf %s "checking whether user namespaces are supported... " >&6; } -if test ${ax_cv_user_namespace+y} -then : - printf %s "(cached) " >&6 -else case e in #( - e) - ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - if test "$cross_compiling" = yes -then : - ax_cv_user_namespace=no -else case e in #( - e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -#define _GNU_SOURCE -#include -#include -#include -#include -#include -#include -#include - -int userfn(void *d) { - usleep(100000); /* synchronize by sleep */ - return (getuid() != 0); -} -char userst[1024*1024]; -int main() { - char buffer[1024]; - int rc, status, fd; - pid_t child = clone(userfn, userst + 1024*1024, CLONE_NEWUSER|SIGCHLD, 0); - if (child < 0) return 1; - - snprintf(buffer, sizeof(buffer), "/proc/%d/uid_map", child); - fd = open(buffer, O_CREAT|O_WRONLY|O_TRUNC, 0755); - snprintf(buffer, sizeof(buffer), "0 %d 1\n", getuid()); - write(fd, buffer, strlen(buffer)); - close(fd); - - rc = waitpid(child, &status, 0); - if (rc <= 0) return 1; - if (!WIFEXITED(status)) return 1; - return WEXITSTATUS(status); -} - -_ACEOF -if ac_fn_c_try_run "$LINENO" -then : - ax_cv_user_namespace=yes -else case e in #( - e) ax_cv_user_namespace=no ;; -esac -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext ;; -esac -fi - - ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - ;; -esac -fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_user_namespace" >&5 -printf "%s\n" "$ax_cv_user_namespace" >&6; } - if test "$ax_cv_user_namespace" = yes; then - -printf "%s\n" "#define HAVE_USER_NAMESPACE 1" >>confdefs.h - - fi - - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether UTS namespaces are supported" >&5 -printf %s "checking whether UTS namespaces are supported... " >&6; } -if test ${ax_cv_uts_namespace+y} -then : - printf %s "(cached) " >&6 -else case e in #( - e) - ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - if test "$cross_compiling" = yes -then : - ax_cv_uts_namespace=no -else case e in #( - e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -#define _GNU_SOURCE -#include -#include -#include -#include -#include -#include -#include -#include - -int utsfn(void *d) { - char buffer[1024]; - const char *name = "autoconftest"; - int rc = sethostname(name, strlen(name)); - if (rc != 0) return 1; - gethostname(buffer, 1024); - return (strcmp(buffer, name) != 0); -} - -char st2[1024*1024]; -int fn(void *d) { - pid_t child; - int rc, status; - usleep(100000); /* synchronize by sleep */ - if (getuid() != 0) return 1; - child = clone(utsfn, st2 + 1024*1024, CLONE_NEWUTS|SIGCHLD, 0); - if (child < 0) return 1; - rc = waitpid(child, &status, 0); - if (rc <= 0) return 1; - if (!WIFEXITED(status)) return 1; - return WEXITSTATUS(status); -} -char st[1024*1024]; -int main() { - char buffer[1024]; - int rc, status, fd; - pid_t child = clone(fn, st + 1024*1024, CLONE_NEWUSER|SIGCHLD, 0); - if (child < 0) return 1; - - snprintf(buffer, sizeof(buffer), "/proc/%d/uid_map", child); - fd = open(buffer, O_CREAT|O_WRONLY|O_TRUNC, 0755); - snprintf(buffer, sizeof(buffer), "0 %d 1\n", getuid()); - write(fd, buffer, strlen(buffer)); - close(fd); - - rc = waitpid(child, &status, 0); - if (rc <= 0) return 1; - if (!WIFEXITED(status)) return 1; - return WEXITSTATUS(status); -} - - -_ACEOF -if ac_fn_c_try_run "$LINENO" -then : - ax_cv_uts_namespace=yes -else case e in #( - e) ax_cv_uts_namespace=no ;; -esac -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext ;; -esac -fi - - ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - ;; -esac -fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_uts_namespace" >&5 -printf "%s\n" "$ax_cv_uts_namespace" >&6; } - if test "$ax_cv_uts_namespace" = yes; then - -printf "%s\n" "#define HAVE_UTS_NAMESPACE 1" >>confdefs.h - - fi - # Check whether --enable-largefile was given. if test ${enable_largefile+y} then : @@ -24753,6 +24577,264 @@ printf "%s\n" "$as_me: WARNING: gmock could not be found, not building tests" >& else as_fn_error $? "tests require gmock" "$LINENO" 5 fi + else + +pkg_failed=no +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gmock >= 1.12.0" >&5 +printf %s "checking for gmock >= 1.12.0... " >&6; } + +if test -n "$GMOCK112_CFLAGS"; then + pkg_cv_GMOCK112_CFLAGS="$GMOCK112_CFLAGS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gmock >= 1.12.0\""; } >&5 + ($PKG_CONFIG --exists --print-errors "gmock >= 1.12.0") 2>&5 + ac_status=$? + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_GMOCK112_CFLAGS=`$PKG_CONFIG --cflags "gmock >= 1.12.0" 2>/dev/null` + test "x$?" != "x0" && pkg_failed=yes +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi +if test -n "$GMOCK112_LIBS"; then + pkg_cv_GMOCK112_LIBS="$GMOCK112_LIBS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gmock >= 1.12.0\""; } >&5 + ($PKG_CONFIG --exists --print-errors "gmock >= 1.12.0") 2>&5 + ac_status=$? + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_GMOCK112_LIBS=`$PKG_CONFIG --libs "gmock >= 1.12.0" 2>/dev/null` + test "x$?" != "x0" && pkg_failed=yes +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi + + + +if test $pkg_failed = yes; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } + +if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then + _pkg_short_errors_supported=yes +else + _pkg_short_errors_supported=no +fi + if test $_pkg_short_errors_supported = yes; then + GMOCK112_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "gmock >= 1.12.0" 2>&1` + else + GMOCK112_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "gmock >= 1.12.0" 2>&1` + fi + # Put the nasty error message in config.log where it belongs + echo "$GMOCK112_PKG_ERRORS" >&5 + + have_gmock_v112=no +elif test $pkg_failed = untried; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } + have_gmock_v112=no +else + GMOCK112_CFLAGS=$pkg_cv_GMOCK112_CFLAGS + GMOCK112_LIBS=$pkg_cv_GMOCK112_LIBS + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } + have_gmock_v112=yes +fi + if test "x$have_gmock_v112" = "xyes" ; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether user namespaces are supported" >&5 +printf %s "checking whether user namespaces are supported... " >&6; } +if test ${ax_cv_user_namespace+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + if test "$cross_compiling" = yes +then : + ax_cv_user_namespace=no +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include + +int userfn(void *d) { + usleep(100000); /* synchronize by sleep */ + return (getuid() != 0); +} +char userst[1024*1024]; +int main() { + char buffer[1024]; + int rc, status, fd; + pid_t child = clone(userfn, userst + 1024*1024, CLONE_NEWUSER|SIGCHLD, 0); + if (child < 0) return 1; + + snprintf(buffer, sizeof(buffer), "/proc/%d/uid_map", child); + fd = open(buffer, O_CREAT|O_WRONLY|O_TRUNC, 0755); + snprintf(buffer, sizeof(buffer), "0 %d 1\n", getuid()); + write(fd, buffer, strlen(buffer)); + close(fd); + + rc = waitpid(child, &status, 0); + if (rc <= 0) return 1; + if (!WIFEXITED(status)) return 1; + return WEXITSTATUS(status); +} + +_ACEOF +if ac_fn_c_try_run "$LINENO" +then : + ax_cv_user_namespace=yes +else case e in #( + e) ax_cv_user_namespace=no ;; +esac +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac +fi + + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + ;; +esac +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_user_namespace" >&5 +printf "%s\n" "$ax_cv_user_namespace" >&6; } + if test "$ax_cv_user_namespace" = yes; then + +printf "%s\n" "#define HAVE_USER_NAMESPACE 1" >>confdefs.h + + fi + + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether UTS namespaces are supported" >&5 +printf %s "checking whether UTS namespaces are supported... " >&6; } +if test ${ax_cv_uts_namespace+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + if test "$cross_compiling" = yes +then : + ax_cv_uts_namespace=no +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include + +int utsfn(void *d) { + char buffer[1024]; + const char *name = "autoconftest"; + int rc = sethostname(name, strlen(name)); + if (rc != 0) return 1; + gethostname(buffer, 1024); + return (strcmp(buffer, name) != 0); +} + +char st2[1024*1024]; +int fn(void *d) { + pid_t child; + int rc, status; + usleep(100000); /* synchronize by sleep */ + if (getuid() != 0) return 1; + child = clone(utsfn, st2 + 1024*1024, CLONE_NEWUTS|SIGCHLD, 0); + if (child < 0) return 1; + rc = waitpid(child, &status, 0); + if (rc <= 0) return 1; + if (!WIFEXITED(status)) return 1; + return WEXITSTATUS(status); +} +char st[1024*1024]; +int main() { + char buffer[1024]; + int rc, status, fd; + pid_t child = clone(fn, st + 1024*1024, CLONE_NEWUSER|SIGCHLD, 0); + if (child < 0) return 1; + + snprintf(buffer, sizeof(buffer), "/proc/%d/uid_map", child); + fd = open(buffer, O_CREAT|O_WRONLY|O_TRUNC, 0755); + snprintf(buffer, sizeof(buffer), "0 %d 1\n", getuid()); + write(fd, buffer, strlen(buffer)); + close(fd); + + rc = waitpid(child, &status, 0); + if (rc <= 0) return 1; + if (!WIFEXITED(status)) return 1; + return WEXITSTATUS(status); +} + + +_ACEOF +if ac_fn_c_try_run "$LINENO" +then : + ax_cv_uts_namespace=yes +else case e in #( + e) ax_cv_uts_namespace=no ;; +esac +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac +fi + + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + ;; +esac +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_uts_namespace" >&5 +printf "%s\n" "$ax_cv_uts_namespace" >&6; } + if test "$ax_cv_uts_namespace" = yes; then + +printf "%s\n" "#define HAVE_UTS_NAMESPACE 1" >>confdefs.h + + fi + + fi fi fi if test "x$build_tests" != "xno" ; then @@ -26629,7 +26711,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by c-ares $as_me 1.33.0, which was +This file was extended by c-ares $as_me 1.33.1, which was generated by GNU Autoconf 2.72. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -26697,7 +26779,7 @@ ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ -c-ares config.status 1.33.0 +c-ares config.status 1.33.1 configured by $0, generated by GNU Autoconf 2.72, with options \\"\$ac_cs_config\\" diff --git a/deps/cares/configure.ac b/deps/cares/configure.ac index be891e40621ffd..59fd975b64f873 100644 --- a/deps/cares/configure.ac +++ b/deps/cares/configure.ac @@ -2,10 +2,10 @@ dnl Copyright (C) The c-ares project and its contributors dnl SPDX-License-Identifier: MIT AC_PREREQ([2.69]) -AC_INIT([c-ares], [1.33.0], +AC_INIT([c-ares], [1.33.1], [c-ares mailing list: http://lists.haxx.se/listinfo/c-ares]) -CARES_VERSION_INFO="20:0:18" +CARES_VERSION_INFO="20:1:18" dnl This flag accepts an argument of the form current[:revision[:age]]. So, dnl passing -version-info 3:12:1 sets current to 3, revision to 12, and age to dnl 1. @@ -153,8 +153,6 @@ _EOF ]) AX_CODE_COVERAGE -AX_CHECK_USER_NAMESPACE -AX_CHECK_UTS_NAMESPACE AC_SYS_LARGEFILE case $host_os in @@ -819,6 +817,12 @@ if test "x$build_tests" != "xno" ; then else AC_MSG_ERROR([tests require gmock]) fi + else + PKG_CHECK_MODULES([GMOCK112], [gmock >= 1.12.0], [ have_gmock_v112=yes ], [ have_gmock_v112=no ]) + if test "x$have_gmock_v112" = "xyes" ; then + AX_CHECK_USER_NAMESPACE + AX_CHECK_UTS_NAMESPACE + fi fi fi if test "x$build_tests" != "xno" ; then diff --git a/deps/cares/docs/Makefile.in b/deps/cares/docs/Makefile.in index 155ab9d3017e5b..a57cd0abc18846 100644 --- a/deps/cares/docs/Makefile.in +++ b/deps/cares/docs/Makefile.in @@ -227,6 +227,8 @@ FGREP = @FGREP@ FILECMD = @FILECMD@ GCOV = @GCOV@ GENHTML = @GENHTML@ +GMOCK112_CFLAGS = @GMOCK112_CFLAGS@ +GMOCK112_LIBS = @GMOCK112_LIBS@ GMOCK_CFLAGS = @GMOCK_CFLAGS@ GMOCK_LIBS = @GMOCK_LIBS@ GREP = @GREP@ diff --git a/deps/cares/include/Makefile.in b/deps/cares/include/Makefile.in index 2960e5a55237c4..99936f8649748f 100644 --- a/deps/cares/include/Makefile.in +++ b/deps/cares/include/Makefile.in @@ -238,6 +238,8 @@ FGREP = @FGREP@ FILECMD = @FILECMD@ GCOV = @GCOV@ GENHTML = @GENHTML@ +GMOCK112_CFLAGS = @GMOCK112_CFLAGS@ +GMOCK112_LIBS = @GMOCK112_LIBS@ GMOCK_CFLAGS = @GMOCK_CFLAGS@ GMOCK_LIBS = @GMOCK_LIBS@ GREP = @GREP@ diff --git a/deps/cares/include/ares_version.h b/deps/cares/include/ares_version.h index fef66b739791be..c910d79209a3fb 100644 --- a/deps/cares/include/ares_version.h +++ b/deps/cares/include/ares_version.h @@ -32,11 +32,11 @@ #define ARES_VERSION_MAJOR 1 #define ARES_VERSION_MINOR 33 -#define ARES_VERSION_PATCH 0 +#define ARES_VERSION_PATCH 1 #define ARES_VERSION \ ((ARES_VERSION_MAJOR << 16) | (ARES_VERSION_MINOR << 8) | \ (ARES_VERSION_PATCH)) -#define ARES_VERSION_STR "1.33.0" +#define ARES_VERSION_STR "1.33.1" #define CARES_HAVE_ARES_LIBRARY_INIT 1 #define CARES_HAVE_ARES_LIBRARY_CLEANUP 1 diff --git a/deps/cares/libcares.pc.cmake b/deps/cares/libcares.pc.cmake index 74e4d0cf445978..257255d84d5ce9 100644 --- a/deps/cares/libcares.pc.cmake +++ b/deps/cares/libcares.pc.cmake @@ -7,9 +7,9 @@ # Copyright (C) The c-ares project and its contributors # SPDX-License-Identifier: MIT prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=@CMAKE_INSTALL_FULL_BINDIR@ -libdir=@CMAKE_INSTALL_FULL_LIBDIR@ -includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ +exec_prefix=${prefix}/@CMAKE_INSTALL_BINDIR@ +libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ +includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ Name: c-ares URL: https://c-ares.org/ @@ -18,5 +18,6 @@ Version: @CARES_VERSION@ Requires: Requires.private: Cflags: -I${includedir} +Cflags.private: -DCARES_STATICLIB Libs: -L${libdir} -lcares Libs.private: @CARES_PRIVATE_LIBS@ diff --git a/deps/cares/src/Makefile.in b/deps/cares/src/Makefile.in index 45558374c870ad..3ad8a92a6a4f15 100644 --- a/deps/cares/src/Makefile.in +++ b/deps/cares/src/Makefile.in @@ -250,6 +250,8 @@ FGREP = @FGREP@ FILECMD = @FILECMD@ GCOV = @GCOV@ GENHTML = @GENHTML@ +GMOCK112_CFLAGS = @GMOCK112_CFLAGS@ +GMOCK112_LIBS = @GMOCK112_LIBS@ GMOCK_CFLAGS = @GMOCK_CFLAGS@ GMOCK_LIBS = @GMOCK_LIBS@ GREP = @GREP@ diff --git a/deps/cares/src/lib/Makefile.in b/deps/cares/src/lib/Makefile.in index c0d96ed81bb29b..30d33843d5d2d8 100644 --- a/deps/cares/src/lib/Makefile.in +++ b/deps/cares/src/lib/Makefile.in @@ -15,7 +15,7 @@ @SET_MAKE@ # aminclude_static.am generated automatically by Autoconf -# from AX_AM_MACROS_STATIC on Fri Aug 2 08:48:39 EDT 2024 +# from AX_AM_MACROS_STATIC on Fri Aug 23 09:37:25 EDT 2024 # Copyright (C) The c-ares project and its contributors # SPDX-License-Identifier: MIT @@ -490,6 +490,8 @@ FGREP = @FGREP@ FILECMD = @FILECMD@ GCOV = @GCOV@ GENHTML = @GENHTML@ +GMOCK112_CFLAGS = @GMOCK112_CFLAGS@ +GMOCK112_LIBS = @GMOCK112_LIBS@ GMOCK_CFLAGS = @GMOCK_CFLAGS@ GMOCK_LIBS = @GMOCK_LIBS@ GREP = @GREP@ diff --git a/deps/cares/src/lib/ares__close_sockets.c b/deps/cares/src/lib/ares__close_sockets.c index 27bbaacf0e8931..71c7e64f08ad38 100644 --- a/deps/cares/src/lib/ares__close_sockets.c +++ b/deps/cares/src/lib/ares__close_sockets.c @@ -37,7 +37,7 @@ static void ares__requeue_queries(ares_conn_t *conn, ares__tvnow(&now); while ((query = ares__llist_first_val(conn->queries_to_conn)) != NULL) { - ares__requeue_query(query, &now, requeue_status, ARES_TRUE); + ares__requeue_query(query, &now, requeue_status, ARES_TRUE, NULL); } } diff --git a/deps/cares/src/lib/ares__socket.c b/deps/cares/src/lib/ares__socket.c index 2e360efb4148d9..86e281fcddadd4 100644 --- a/deps/cares/src/lib/ares__socket.c +++ b/deps/cares/src/lib/ares__socket.c @@ -56,7 +56,7 @@ #include #include -#if defined(__linux__) && defined(MSG_FASTOPEN) +#if defined(__linux__) && defined(TCP_FASTOPEN_CONNECT) # define TFO_SUPPORTED 1 # define TFO_SKIP_CONNECT 0 # define TFO_USE_SENDTO 0 diff --git a/deps/cares/src/lib/ares_android.c b/deps/cares/src/lib/ares_android.c index 4c0ffa04f7c36e..06ab8940ad736d 100644 --- a/deps/cares/src/lib/ares_android.c +++ b/deps/cares/src/lib/ares_android.c @@ -27,6 +27,7 @@ # include "ares_private.h" # include # include +# include "ares_android.h" static JavaVM *android_jvm = NULL; static jobject android_connectivity_manager = NULL; @@ -227,7 +228,7 @@ int ares_library_init_android(jobject connectivity_manager) (*android_jvm)->DetachCurrentThread(android_jvm); } - return ret; + return (int)ret; } int ares_library_android_initialized(void) diff --git a/deps/cares/src/lib/ares_cookie.c b/deps/cares/src/lib/ares_cookie.c index 0680fe9ec7b6a3..bf9d1ba25da41d 100644 --- a/deps/cares/src/lib/ares_cookie.c +++ b/deps/cares/src/lib/ares_cookie.c @@ -427,7 +427,8 @@ ares_status_t ares_cookie_validate(ares_query_t *query, /* Resend the request, hopefully it will work the next time as we should * have recorded a server cookie */ ares__requeue_query(query, now, ARES_SUCCESS, - ARES_FALSE /* Don't increment try count */); + ARES_FALSE /* Don't increment try count */, + NULL); /* Parent needs to drop this response */ return ARES_EBADRESP; diff --git a/deps/cares/src/lib/ares_getaddrinfo.c b/deps/cares/src/lib/ares_getaddrinfo.c index f67acdec2fac81..713acf744a0dca 100644 --- a/deps/cares/src/lib/ares_getaddrinfo.c +++ b/deps/cares/src/lib/ares_getaddrinfo.c @@ -528,6 +528,13 @@ static void host_callback(void *arg, ares_status_t status, size_t timeouts, hquery->nodata_cnt++; } next_lookup(hquery, hquery->nodata_cnt ? ARES_ENODATA : status); + } else if ( + (status == ARES_ESERVFAIL || status == ARES_EREFUSED) && + ares__name_label_cnt(hquery->names[hquery->next_name_idx-1]) == 1 + ) { + /* Issue #852, systemd-resolved may return SERVFAIL or REFUSED on a + * single label domain name. */ + next_lookup(hquery, hquery->nodata_cnt ? ARES_ENODATA : status); } else { end_hquery(hquery, status); } diff --git a/deps/cares/src/lib/ares_metrics.c b/deps/cares/src/lib/ares_metrics.c index aa0ea8c01707a4..0e22fc37e7cb46 100644 --- a/deps/cares/src/lib/ares_metrics.c +++ b/deps/cares/src/lib/ares_metrics.c @@ -170,7 +170,7 @@ void ares_metrics_record(const ares_query_t *query, ares_server_t *server, } ares__timeval_diff(&tvdiff, &query->ts, &now); - query_ms = (unsigned int)(tvdiff.sec + (tvdiff.usec / 1000)); + query_ms = (unsigned int)((tvdiff.sec * 1000) + (tvdiff.usec / 1000)); if (query_ms == 0) { query_ms = 1; } diff --git a/deps/cares/src/lib/ares_private.h b/deps/cares/src/lib/ares_private.h index b85ecb5e14d73d..263c2a606d3708 100644 --- a/deps/cares/src/lib/ares_private.h +++ b/deps/cares/src/lib/ares_private.h @@ -462,10 +462,14 @@ ares_bool_t ares__timedout(const ares_timeval_t *now, /* Returns one of the normal ares status codes like ARES_SUCCESS */ ares_status_t ares__send_query(ares_query_t *query, const ares_timeval_t *now); -ares_status_t ares__requeue_query(ares_query_t *query, - const ares_timeval_t *now, - ares_status_t status, - ares_bool_t inc_try_count); +ares_status_t ares__requeue_query(ares_query_t *query, + const ares_timeval_t *now, + ares_status_t status, + ares_bool_t inc_try_count, + const ares_dns_record_t *dnsrec); + +/*! Count the number of labels (dots+1) in a domain */ +size_t ares__name_label_cnt(const char *name); /*! Retrieve a list of names to use for searching. The first successful * query in the list wins. This function also uses the HOSTSALIASES file diff --git a/deps/cares/src/lib/ares_process.c b/deps/cares/src/lib/ares_process.c index 65ee673f6edcd5..f05f67d8f2b176 100644 --- a/deps/cares/src/lib/ares_process.c +++ b/deps/cares/src/lib/ares_process.c @@ -571,7 +571,7 @@ static void process_timeouts(ares_channel_t *channel, const ares_timeval_t *now) conn = query->conn; server_increment_failures(conn->server, query->using_tcp); - ares__requeue_query(query, now, ARES_ETIMEOUT, ARES_TRUE); + ares__requeue_query(query, now, ARES_ETIMEOUT, ARES_TRUE, NULL); } } @@ -711,7 +711,7 @@ static ares_status_t process_answer(ares_channel_t *channel, } server_increment_failures(server, query->using_tcp); - ares__requeue_query(query, now, status, ARES_TRUE); + ares__requeue_query(query, now, status, ARES_TRUE, rdnsrec); /* Should any of these cause a connection termination? * Maybe SERVER_FAILURE? */ @@ -756,10 +756,11 @@ static void handle_conn_error(ares_conn_t *conn, ares_bool_t critical_failure, ares__close_connection(conn, failure_status); } -ares_status_t ares__requeue_query(ares_query_t *query, - const ares_timeval_t *now, - ares_status_t status, - ares_bool_t inc_try_count) +ares_status_t ares__requeue_query(ares_query_t *query, + const ares_timeval_t *now, + ares_status_t status, + ares_bool_t inc_try_count, + const ares_dns_record_t *dnsrec) { ares_channel_t *channel = query->channel; size_t max_tries = ares__slist_len(channel->servers) * channel->tries; @@ -783,7 +784,7 @@ ares_status_t ares__requeue_query(ares_query_t *query, query->error_status = ARES_ETIMEOUT; } - end_query(channel, NULL, query, query->error_status, NULL); + end_query(channel, NULL, query, query->error_status, dnsrec); return ARES_ETIMEOUT; } @@ -1078,7 +1079,7 @@ ares_status_t ares__send_query(ares_query_t *query, const ares_timeval_t *now) case ARES_ECONNREFUSED: case ARES_EBADFAMILY: server_increment_failures(server, query->using_tcp); - return ares__requeue_query(query, now, status, ARES_TRUE); + return ares__requeue_query(query, now, status, ARES_TRUE, NULL); /* Anything else is not retryable, likely ENOMEM */ default: @@ -1104,7 +1105,7 @@ ares_status_t ares__send_query(ares_query_t *query, const ares_timeval_t *now) case ARES_ECONNREFUSED: case ARES_EBADFAMILY: handle_conn_error(conn, ARES_TRUE, status); - status = ares__requeue_query(query, now, status, ARES_TRUE); + status = ares__requeue_query(query, now, status, ARES_TRUE, NULL); if (status == ARES_ETIMEOUT) { status = ARES_ECONNREFUSED; } @@ -1114,7 +1115,7 @@ ares_status_t ares__send_query(ares_query_t *query, const ares_timeval_t *now) * just requeue to a different server/connection. */ default: server_increment_failures(server, query->using_tcp); - status = ares__requeue_query(query, now, status, ARES_TRUE); + status = ares__requeue_query(query, now, status, ARES_TRUE, NULL); return status; } diff --git a/deps/cares/src/lib/ares_qcache.c b/deps/cares/src/lib/ares_qcache.c index aee1328b51c7bc..9725212fded7d1 100644 --- a/deps/cares/src/lib/ares_qcache.c +++ b/deps/cares/src/lib/ares_qcache.c @@ -121,9 +121,11 @@ static char *ares__qcache_calc_key(const ares_dns_record_t *dnsrec) name_len--; } - status = ares__buf_append(buf, (const unsigned char *)name, name_len); - if (status != ARES_SUCCESS) { - goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ + if (name_len > 0) { + status = ares__buf_append(buf, (const unsigned char *)name, name_len); + if (status != ARES_SUCCESS) { + goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ + } } } @@ -346,8 +348,8 @@ static ares_status_t ares__qcache_insert(ares__qcache_t *qcache, } entry->dnsrec = qresp; - entry->expire_ts = now->sec + (time_t)ttl; - entry->insert_ts = now->sec; + entry->expire_ts = (time_t)now->sec + (time_t)ttl; + entry->insert_ts = (time_t)now->sec; /* We can't guarantee the server responded with the same flags as the * request had, so we have to re-parse the request in order to generate the diff --git a/deps/cares/src/lib/ares_search.c b/deps/cares/src/lib/ares_search.c index ae98df39a80a8f..2d3c0fc5145684 100644 --- a/deps/cares/src/lib/ares_search.c +++ b/deps/cares/src/lib/ares_search.c @@ -107,26 +107,37 @@ static void search_callback(void *arg, ares_status_t status, size_t timeouts, { struct search_query *squery = (struct search_query *)arg; ares_channel_t *channel = squery->channel; - ares_dns_rcode_t rcode; - size_t ancount; + ares_status_t mystatus; ares_bool_t skip_cleanup = ARES_FALSE; squery->timeouts += timeouts; - if (status != ARES_SUCCESS) { - end_squery(squery, status, dnsrec); - return; - } - - rcode = ares_dns_record_get_rcode(dnsrec); - ancount = ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER); - mystatus = ares_dns_query_reply_tostatus(rcode, ancount); - - if (mystatus != ARES_ENODATA && mystatus != ARES_ESERVFAIL && - mystatus != ARES_ENOTFOUND) { - end_squery(squery, mystatus, dnsrec); - return; + if (dnsrec) { + ares_dns_rcode_t rcode = ares_dns_record_get_rcode(dnsrec); + size_t ancount = ares_dns_record_rr_cnt(dnsrec, + ARES_SECTION_ANSWER); + mystatus = ares_dns_query_reply_tostatus(rcode, ancount); + } else { + mystatus = status; + } + + switch (mystatus) { + case ARES_ENODATA: + case ARES_ENOTFOUND: + break; + case ARES_ESERVFAIL: + case ARES_EREFUSED: + /* Issue #852, systemd-resolved may return SERVFAIL or REFUSED on a + * single label domain name. */ + if (ares__name_label_cnt(squery->names[squery->next_name_idx-1]) != 1) { + end_squery(squery, mystatus, dnsrec); + return; + } + break; + default: + end_squery(squery, mystatus, dnsrec); + return; } /* If we ever get ARES_ENODATA along the way, record that; if the search @@ -147,7 +158,6 @@ static void search_callback(void *arg, ares_status_t status, size_t timeouts, return; } - /* We have no more domains to search, return an appropriate response. */ if (mystatus == ARES_ENOTFOUND && squery->ever_got_nodata) { end_squery(squery, ARES_ENODATA, NULL); @@ -176,6 +186,25 @@ static ares_bool_t ares__search_eligible(const ares_channel_t *channel, return ARES_TRUE; } +size_t ares__name_label_cnt(const char *name) +{ + const char *p; + size_t ndots = 0; + + if (name == NULL) { + return 0; + } + + for (p = name; p != NULL && *p != 0; p++) { + if (*p == '.') { + ndots++; + } + } + + /* Label count is 1 greater than ndots */ + return ndots+1; +} + ares_status_t ares__search_name_list(const ares_channel_t *channel, const char *name, char ***names, size_t *names_len) @@ -186,7 +215,6 @@ ares_status_t ares__search_name_list(const ares_channel_t *channel, char *alias = NULL; size_t ndots = 0; size_t idx = 0; - const char *p; size_t i; /* Perform HOSTALIASES resolution */ @@ -223,12 +251,10 @@ ares_status_t ares__search_name_list(const ares_channel_t *channel, goto done; } - /* Count the number of dots in name */ - ndots = 0; - for (p = name; *p != 0; p++) { - if (*p == '.') { - ndots++; - } + /* Count the number of dots in name, 1 less than label count */ + ndots = ares__name_label_cnt(name); + if (ndots > 0) { + ndots--; } /* Allocate an entry for each search domain, plus one for as-is */ diff --git a/deps/cares/src/lib/ares_send.c b/deps/cares/src/lib/ares_send.c index 9441534404962f..64ff7edd3ac602 100644 --- a/deps/cares/src/lib/ares_send.c +++ b/deps/cares/src/lib/ares_send.c @@ -62,7 +62,11 @@ static ares_status_t ares_apply_dns0x20(ares_channel_t *channel, } len = ares_strlen(name); - if (len == 0 || len >= sizeof(dns0x20name)) { + if (len == 0) { + return ARES_SUCCESS; + } + + if (len >= sizeof(dns0x20name)) { status = ARES_EBADNAME; goto done; } diff --git a/deps/cares/src/lib/ares_sysconfig.c b/deps/cares/src/lib/ares_sysconfig.c index 2cd3df28235ec3..61e6a423a7578a 100644 --- a/deps/cares/src/lib/ares_sysconfig.c +++ b/deps/cares/src/lib/ares_sysconfig.c @@ -239,7 +239,7 @@ static ares_status_t ares__init_sysconfig_android(ares_sysconfig_t *sysconfig) char propname[PROP_NAME_MAX]; char propvalue[PROP_VALUE_MAX] = ""; for (i = 1; i <= MAX_DNS_PROPERTIES; i++) { - snprintf(propname, sizeof(propname), "%s%u", DNS_PROP_NAME_PREFIX, i); + snprintf(propname, sizeof(propname), "%s%zu", DNS_PROP_NAME_PREFIX, i); if (__system_property_get(propname, propvalue) < 1) { break; } @@ -494,6 +494,7 @@ ares_status_t ares__init_by_sysconfig(ares_channel_t *channel) ares_sysconfig_t sysconfig; memset(&sysconfig, 0, sizeof(sysconfig)); + sysconfig.ndots = 1; /* Default value if not otherwise set */ #if defined(USE_WINSOCK) status = ares__init_sysconfig_windows(&sysconfig); diff --git a/deps/cares/src/lib/dsa/ares__htable.c b/deps/cares/src/lib/dsa/ares__htable.c index d608d60ce3a51a..9049b3246b36f1 100644 --- a/deps/cares/src/lib/dsa/ares__htable.c +++ b/deps/cares/src/lib/dsa/ares__htable.c @@ -59,7 +59,7 @@ static unsigned int ares__htable_generate_seed(ares__htable_t *htable) * collision attack is very low with a small amount of effort */ seed |= (unsigned int)((size_t)htable & 0xFFFFFFFF); seed |= (unsigned int)((size_t)&seed & 0xFFFFFFFF); - seed |= (unsigned int)(t & 0xFFFFFFFF); + seed |= (unsigned int)(((ares_uint64_t)t) & 0xFFFFFFFF); return seed; } diff --git a/deps/cares/src/lib/event/ares_event_configchg.c b/deps/cares/src/lib/event/ares_event_configchg.c index 030c76c69c9148..10f0e21dde77fa 100644 --- a/deps/cares/src/lib/event/ares_event_configchg.c +++ b/deps/cares/src/lib/event/ares_event_configchg.c @@ -31,6 +31,8 @@ ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg, ares_event_thread_t *e) { + (void)configchg; + (void)e; /* No ability */ return ARES_ENOTIMP; } @@ -38,6 +40,7 @@ ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg, void ares_event_configchg_destroy(ares_event_configchg_t *configchg) { /* No-op */ + (void)configchg; } #elif defined(__linux__) @@ -107,7 +110,7 @@ static void ares_event_configchg_cb(ares_event_thread_t *e, ares_socket_t fd, * size provided, so I assume it won't ever return partial events. */ for (ptr = buf; ptr < buf + len; ptr += sizeof(struct inotify_event) + event->len) { - event = (const struct inotify_event *)ptr; + event = (const struct inotify_event *)((const void *)ptr); if (event->len == 0 || ares_strlen(event->name) == 0) { continue; diff --git a/deps/cares/src/lib/str/ares__buf.c b/deps/cares/src/lib/str/ares__buf.c index b855260ab37322..bf6d4a0e1d3712 100644 --- a/deps/cares/src/lib/str/ares__buf.c +++ b/deps/cares/src/lib/str/ares__buf.c @@ -213,10 +213,14 @@ ares_status_t ares__buf_append(ares__buf_t *buf, const unsigned char *data, { ares_status_t status; - if (data == NULL || data_len == 0) { + if (data == NULL && data_len != 0) { return ARES_EFORMERR; } + if (data_len == 0) { + return ARES_SUCCESS; + } + status = ares__buf_ensure_space(buf, data_len); if (status != ARES_SUCCESS) { return status; diff --git a/deps/cares/src/tools/Makefile.in b/deps/cares/src/tools/Makefile.in index 9c896092b1ec19..e1b661ec1d7cbf 100644 --- a/deps/cares/src/tools/Makefile.in +++ b/deps/cares/src/tools/Makefile.in @@ -275,6 +275,8 @@ FGREP = @FGREP@ FILECMD = @FILECMD@ GCOV = @GCOV@ GENHTML = @GENHTML@ +GMOCK112_CFLAGS = @GMOCK112_CFLAGS@ +GMOCK112_LIBS = @GMOCK112_LIBS@ GMOCK_CFLAGS = @GMOCK_CFLAGS@ GMOCK_LIBS = @GMOCK_LIBS@ GREP = @GREP@ From afd8c1eb4f10e9afcd74e1f77a2f68fe47a32dc6 Mon Sep 17 00:00:00 2001 From: Robert Nagy Date: Tue, 27 Aug 2024 06:01:30 +0200 Subject: [PATCH 47/90] buffer: allow invalid encoding in from Looks like a bug to me but the change should probably done in a semver majpr. PR-URL: https://github.com/nodejs/node/pull/54533 Reviewed-By: Matteo Collina Reviewed-By: Benjamin Gruenbaum Reviewed-By: Jake Yuesong Li Reviewed-By: Rafael Gonzaga --- lib/buffer.js | 2 +- test/parallel/test-buffer-from.js | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/lib/buffer.js b/lib/buffer.js index 05b57275f03dca..4467a555c7180e 100644 --- a/lib/buffer.js +++ b/lib/buffer.js @@ -476,7 +476,7 @@ function createFromString(string, ops, length = ops.byteLength(string)) { function fromString(string, encoding) { let ops; - if (!encoding || encoding === 'utf8') { + if (!encoding || encoding === 'utf8' || typeof encoding !== 'string') { ops = encodingOps.utf8; } else { ops = getEncodingOps(encoding); diff --git a/test/parallel/test-buffer-from.js b/test/parallel/test-buffer-from.js index 284c63e7d02e8e..416a3b3a3105b5 100644 --- a/test/parallel/test-buffer-from.js +++ b/test/parallel/test-buffer-from.js @@ -139,3 +139,6 @@ throws(() => { code: 'ERR_OUT_OF_RANGE', }) ); + +// Invalid encoding is allowed +Buffer.from('asd', 1); From e6e1f4e8bd0e5d7f8284e9653a6e5c4f6df4f3f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= Date: Tue, 27 Aug 2024 10:17:21 +0200 Subject: [PATCH 48/90] src: remove redundant AESCipherMode For each supported variant of AES, we already have OpenSSL's associated NID, so we can simply retrieve the block cipher mode of operation from the NID. PR-URL: https://github.com/nodejs/node/pull/54438 Reviewed-By: James M Snell Reviewed-By: Benjamin Gruenbaum --- src/crypto/crypto_aes.cc | 28 +++++++++++++--------------- src/crypto/crypto_aes.h | 33 +++++++++++++-------------------- 2 files changed, 26 insertions(+), 35 deletions(-) diff --git a/src/crypto/crypto_aes.cc b/src/crypto/crypto_aes.cc index fa93f767574299..f9f9a73d46dbb1 100644 --- a/src/crypto/crypto_aes.cc +++ b/src/crypto/crypto_aes.cc @@ -471,12 +471,9 @@ Maybe AESCipherTraits::AdditionalConfig( params->variant = static_cast(args[offset].As()->Value()); - AESCipherMode cipher_op_mode; int cipher_nid; - -#define V(name, _, mode, nid) \ +#define V(name, _, nid) \ case kKeyVariantAES_##name: { \ - cipher_op_mode = mode; \ cipher_nid = nid; \ break; \ } @@ -487,15 +484,22 @@ Maybe AESCipherTraits::AdditionalConfig( } #undef V - if (cipher_op_mode != AESCipherMode::KW) { + params->cipher = EVP_get_cipherbynid(cipher_nid); + if (params->cipher == nullptr) { + THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env); + return Nothing(); + } + + int cipher_op_mode = EVP_CIPHER_mode(params->cipher); + if (cipher_op_mode != EVP_CIPH_WRAP_MODE) { if (!ValidateIV(env, mode, args[offset + 1], params)) { return Nothing(); } - if (cipher_op_mode == AESCipherMode::CTR) { + if (cipher_op_mode == EVP_CIPH_CTR_MODE) { if (!ValidateCounter(env, args[offset + 2], params)) { return Nothing(); } - } else if (cipher_op_mode == AESCipherMode::GCM) { + } else if (cipher_op_mode == EVP_CIPH_GCM_MODE) { if (!ValidateAuthTag(env, mode, cipher_mode, args[offset + 2], params) || !ValidateAdditionalData(env, mode, args[offset + 3], params)) { return Nothing(); @@ -505,12 +509,6 @@ Maybe AESCipherTraits::AdditionalConfig( UseDefaultIV(params); } - params->cipher = EVP_get_cipherbynid(cipher_nid); - if (params->cipher == nullptr) { - THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env); - return Nothing(); - } - if (params->iv.size() < static_cast(EVP_CIPHER_iv_length(params->cipher))) { THROW_ERR_CRYPTO_INVALID_IV(env); @@ -527,7 +525,7 @@ WebCryptoCipherStatus AESCipherTraits::DoCipher( const AESCipherConfig& params, const ByteSource& in, ByteSource* out) { -#define V(name, fn, _, __) \ +#define V(name, fn, _) \ case kKeyVariantAES_##name: \ return fn(env, key_data.get(), cipher_mode, params, in, out); switch (params.variant) { @@ -541,7 +539,7 @@ WebCryptoCipherStatus AESCipherTraits::DoCipher( void AES::Initialize(Environment* env, Local target) { AESCryptoJob::Initialize(env, target); -#define V(name, _, __, ___) NODE_DEFINE_CONSTANT(target, kKeyVariantAES_##name); +#define V(name, _, __) NODE_DEFINE_CONSTANT(target, kKeyVariantAES_##name); VARIANTS(V) #undef V } diff --git a/src/crypto/crypto_aes.h b/src/crypto/crypto_aes.h index 2ddbc14b8e606e..a9ec45c26606de 100644 --- a/src/crypto/crypto_aes.h +++ b/src/crypto/crypto_aes.h @@ -15,29 +15,22 @@ constexpr size_t kAesBlockSize = 16; constexpr unsigned kNoAuthTagLength = static_cast(-1); constexpr const char* kDefaultWrapIV = "\xa6\xa6\xa6\xa6\xa6\xa6\xa6\xa6"; -enum class AESCipherMode { - CTR, - CBC, - GCM, - KW, -}; - #define VARIANTS(V) \ - V(CTR_128, AES_CTR_Cipher, AESCipherMode::CTR, NID_aes_128_ctr) \ - V(CTR_192, AES_CTR_Cipher, AESCipherMode::CTR, NID_aes_192_ctr) \ - V(CTR_256, AES_CTR_Cipher, AESCipherMode::CTR, NID_aes_256_ctr) \ - V(CBC_128, AES_Cipher, AESCipherMode::CBC, NID_aes_128_cbc) \ - V(CBC_192, AES_Cipher, AESCipherMode::CBC, NID_aes_192_cbc) \ - V(CBC_256, AES_Cipher, AESCipherMode::CBC, NID_aes_256_cbc) \ - V(GCM_128, AES_Cipher, AESCipherMode::GCM, NID_aes_128_gcm) \ - V(GCM_192, AES_Cipher, AESCipherMode::GCM, NID_aes_192_gcm) \ - V(GCM_256, AES_Cipher, AESCipherMode::GCM, NID_aes_256_gcm) \ - V(KW_128, AES_Cipher, AESCipherMode::KW, NID_id_aes128_wrap) \ - V(KW_192, AES_Cipher, AESCipherMode::KW, NID_id_aes192_wrap) \ - V(KW_256, AES_Cipher, AESCipherMode::KW, NID_id_aes256_wrap) + V(CTR_128, AES_CTR_Cipher, NID_aes_128_ctr) \ + V(CTR_192, AES_CTR_Cipher, NID_aes_192_ctr) \ + V(CTR_256, AES_CTR_Cipher, NID_aes_256_ctr) \ + V(CBC_128, AES_Cipher, NID_aes_128_cbc) \ + V(CBC_192, AES_Cipher, NID_aes_192_cbc) \ + V(CBC_256, AES_Cipher, NID_aes_256_cbc) \ + V(GCM_128, AES_Cipher, NID_aes_128_gcm) \ + V(GCM_192, AES_Cipher, NID_aes_192_gcm) \ + V(GCM_256, AES_Cipher, NID_aes_256_gcm) \ + V(KW_128, AES_Cipher, NID_id_aes128_wrap) \ + V(KW_192, AES_Cipher, NID_id_aes192_wrap) \ + V(KW_256, AES_Cipher, NID_id_aes256_wrap) enum AESKeyVariant { -#define V(name, _, __, ___) kKeyVariantAES_##name, +#define V(name, _, __) kKeyVariantAES_##name, VARIANTS(V) #undef V }; From ac178b094bf3c3a109ba307d33452904c44cde43 Mon Sep 17 00:00:00 2001 From: Robert Nagy Date: Tue, 27 Aug 2024 10:48:52 +0200 Subject: [PATCH 49/90] buffer: truncate instead of throw when writing beyond buffer Fixes: https://github.com/nodejs/node/issues/54523 Fixes: https://github.com/nodejs/node/issues/54518 PR-URL: https://github.com/nodejs/node/pull/54524 Reviewed-By: Ethan Arrowood Reviewed-By: Benjamin Gruenbaum Reviewed-By: Ruben Bridgewater Reviewed-By: Rafael Gonzaga Reviewed-By: Anna Henningsen Reviewed-By: Matteo Collina --- lib/internal/buffer.js | 6 +++--- test/parallel/test-buffer-write.js | 15 +++++++++++++++ 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/lib/internal/buffer.js b/lib/internal/buffer.js index c547c1f993fb55..20b22ad529385a 100644 --- a/lib/internal/buffer.js +++ b/lib/internal/buffer.js @@ -1040,7 +1040,7 @@ function addBufferPrototypeMethods(proto) { if (offset < 0 || offset > this.byteLength) { throw new ERR_BUFFER_OUT_OF_BOUNDS('offset'); } - if (length < 0 || length > this.byteLength - offset) { + if (length < 0) { throw new ERR_BUFFER_OUT_OF_BOUNDS('length'); } return asciiWriteStatic(this, string, offset, length); @@ -1051,7 +1051,7 @@ function addBufferPrototypeMethods(proto) { if (offset < 0 || offset > this.byteLength) { throw new ERR_BUFFER_OUT_OF_BOUNDS('offset'); } - if (length < 0 || length > this.byteLength - offset) { + if (length < 0) { throw new ERR_BUFFER_OUT_OF_BOUNDS('length'); } return latin1WriteStatic(this, string, offset, length); @@ -1062,7 +1062,7 @@ function addBufferPrototypeMethods(proto) { if (offset < 0 || offset > this.byteLength) { throw new ERR_BUFFER_OUT_OF_BOUNDS('offset'); } - if (length < 0 || length > this.byteLength - offset) { + if (length < 0) { throw new ERR_BUFFER_OUT_OF_BOUNDS('length'); } return utf8WriteStatic(this, string, offset, length); diff --git a/test/parallel/test-buffer-write.js b/test/parallel/test-buffer-write.js index 128327c47e5d6f..309367c9c75ca1 100644 --- a/test/parallel/test-buffer-write.js +++ b/test/parallel/test-buffer-write.js @@ -106,3 +106,18 @@ assert.strictEqual(Buffer.alloc(4) assert.strictEqual(buf.write('ыы', 1, 'utf16le'), 4); assert.deepStrictEqual([...buf], [0, 0x4b, 0x04, 0x4b, 0x04, 0, 0, 0]); } + +{ + const buf = Buffer.alloc(1); + assert.strictEqual(buf.write('ww'), 1); + assert.strictEqual(buf.toString(), 'w'); +} + +assert.throws(() => { + const buf = Buffer.alloc(1); + assert.strictEqual(buf.asciiWrite('ww', 0, -1)); + assert.strictEqual(buf.latin1Write('ww', 0, -1)); + assert.strictEqual(buf.utf8Write('ww', 0, -1)); +}, common.expectsError({ + code: 'ERR_BUFFER_OUT_OF_BOUNDS', +})); From 3cd10a3f40d90ef810dd88cce0830e65abb2d9df Mon Sep 17 00:00:00 2001 From: Vladimir Morozov Date: Tue, 27 Aug 2024 02:30:19 -0700 Subject: [PATCH 50/90] node-api: remove RefBase and CallbackWrapper PR-URL: https://github.com/nodejs/node/pull/53590 Reviewed-By: Yagiz Nizipli Reviewed-By: Gabriel Schulhof Reviewed-By: Chengzhong Wu Reviewed-By: James M Snell Reviewed-By: Michael Dawson --- src/js_native_api_v8.cc | 508 ++++++++++++++++++++-------------------- src/js_native_api_v8.h | 183 ++++++++------- src/node_api.cc | 19 +- 3 files changed, 360 insertions(+), 350 deletions(-) diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc index c03e1570ca6c0c..b6349b832acd10 100644 --- a/src/js_native_api_v8.cc +++ b/src/js_native_api_v8.cc @@ -134,43 +134,38 @@ napi_status NewExternalString(napi_env env, return status; } -class TrackedStringResource : public Finalizer, RefTracker { +class TrackedStringResource : private RefTracker { public: TrackedStringResource(napi_env env, napi_finalize finalize_callback, void* data, void* finalize_hint) - : Finalizer(env, finalize_callback, data, finalize_hint) { + : RefTracker(), finalizer_(env, finalize_callback, data, finalize_hint) { Link(finalize_callback == nullptr ? &env->reflist : &env->finalizing_reflist); } protected: - // The only time Finalize() gets called before Dispose() is if the + // The only time Finalize() gets called before destructor is if the // environment is dying. Finalize() expects that the item will be unlinked, - // so we do it here. V8 will still call Dispose() on us later, so we don't do - // any deleting here. We just null out env_ to avoid passing a stale pointer - // to the user's finalizer when V8 does finally call Dispose(). + // so we do it here. V8 will still call destructor on us later, so we don't do + // any deleting here. We just null out env to avoid passing a stale pointer + // to the user's finalizer when V8 does finally call destructor. void Finalize() override { Unlink(); - env_ = nullptr; + finalizer_.ResetEnv(); } - ~TrackedStringResource() { - if (finalize_callback_ == nullptr) return; - if (env_ == nullptr) { - // The environment is dead. Call the finalizer directly. - finalize_callback_(nullptr, finalize_data_, finalize_hint_); - } else { - // The environment is still alive. Let's remove ourselves from its list - // of references and call the user's finalizer. - Unlink(); - env_->CallFinalizer(finalize_callback_, finalize_data_, finalize_hint_); - } + ~TrackedStringResource() override { + Unlink(); + finalizer_.CallFinalizer(); } + + private: + Finalizer finalizer_; }; -class ExternalOneByteStringResource +class ExternalOneByteStringResource final : public v8::String::ExternalOneByteStringResource, TrackedStringResource { public: @@ -191,8 +186,8 @@ class ExternalOneByteStringResource const size_t length_; }; -class ExternalStringResource : public v8::String::ExternalStringResource, - TrackedStringResource { +class ExternalStringResource final : public v8::String::ExternalStringResource, + TrackedStringResource { public: ExternalStringResource(napi_env env, char16_t* string, @@ -368,7 +363,7 @@ inline napi_status Unwrap(napi_env env, if (action == RemoveWrap) { CHECK(obj->DeletePrivate(context, NAPI_PRIVATE_KEY(context, wrapper)) .FromJust()); - if (reference->ownership() == Ownership::kUserland) { + if (reference->ownership() == ReferenceOwnership::kUserland) { // When the wrap is been removed, the finalizer should be reset. reference->ResetFinalizer(); } else { @@ -400,10 +395,16 @@ class CallbackBundle { bundle->env = env; v8::Local cbdata = v8::External::New(env->isolate, bundle); - Reference::New( - env, cbdata, 0, Ownership::kRuntime, Delete, bundle, nullptr); + ReferenceWithFinalizer::New( + env, cbdata, 0, ReferenceOwnership::kRuntime, Delete, bundle, nullptr); return cbdata; } + + static CallbackBundle* FromCallbackData(v8::Local data) { + return reinterpret_cast(data.As()->Value()); + } + + public: napi_env env; // Necessary to invoke C++ NAPI callback void* cb_data; // The user provided callback data napi_callback cb; @@ -415,71 +416,9 @@ class CallbackBundle { } }; -// Base class extended by classes that wrap V8 function and property callback -// info. -class CallbackWrapper { - public: - inline CallbackWrapper(napi_value this_arg, size_t args_length, void* data) - : _this(this_arg), _args_length(args_length), _data(data) {} - - virtual napi_value GetNewTarget() = 0; - virtual void Args(napi_value* buffer, size_t bufferlength) = 0; - virtual void SetReturnValue(napi_value value) = 0; - - napi_value This() { return _this; } - - size_t ArgsLength() { return _args_length; } - - void* Data() { return _data; } - - protected: - const napi_value _this; - const size_t _args_length; - void* _data; -}; - -class CallbackWrapperBase : public CallbackWrapper { - public: - inline CallbackWrapperBase(const v8::FunctionCallbackInfo& cbinfo, - const size_t args_length) - : CallbackWrapper( - JsValueFromV8LocalValue(cbinfo.This()), args_length, nullptr), - _cbinfo(cbinfo) { - _bundle = reinterpret_cast( - cbinfo.Data().As()->Value()); - _data = _bundle->cb_data; - } - - protected: - inline void InvokeCallback() { - napi_callback_info cbinfo_wrapper = reinterpret_cast( - static_cast(this)); - - // All other pointers we need are stored in `_bundle` - napi_env env = _bundle->env; - napi_callback cb = _bundle->cb; - - napi_value result = nullptr; - bool exceptionOccurred = false; - env->CallIntoModule([&](napi_env env) { result = cb(env, cbinfo_wrapper); }, - [&](napi_env env, v8::Local value) { - exceptionOccurred = true; - if (env->terminatedOrTerminating()) { - return; - } - env->isolate->ThrowException(value); - }); - - if (!exceptionOccurred && (result != nullptr)) { - this->SetReturnValue(result); - } - } - - const v8::FunctionCallbackInfo& _cbinfo; - CallbackBundle* _bundle; -}; - -class FunctionCallbackWrapper : public CallbackWrapperBase { +// Wraps up v8::FunctionCallbackInfo. +// The class must be stack allocated. +class FunctionCallbackWrapper { public: static void Invoke(const v8::FunctionCallbackInfo& info) { FunctionCallbackWrapper cbwrapper(info); @@ -514,41 +453,70 @@ class FunctionCallbackWrapper : public CallbackWrapperBase { return napi_clear_last_error(env); } - explicit FunctionCallbackWrapper( - const v8::FunctionCallbackInfo& cbinfo) - : CallbackWrapperBase(cbinfo, cbinfo.Length()) {} - - napi_value GetNewTarget() override { - if (_cbinfo.IsConstructCall()) { - return v8impl::JsValueFromV8LocalValue(_cbinfo.NewTarget()); + napi_value GetNewTarget() { + if (cbinfo_.IsConstructCall()) { + return v8impl::JsValueFromV8LocalValue(cbinfo_.NewTarget()); } else { return nullptr; } } - /*virtual*/ - void Args(napi_value* buffer, size_t buffer_length) override { + void Args(napi_value* buffer, size_t buffer_length) { size_t i = 0; - size_t min = std::min(buffer_length, _args_length); + size_t min_arg_count = std::min(buffer_length, ArgsLength()); - for (; i < min; i += 1) { - buffer[i] = v8impl::JsValueFromV8LocalValue(_cbinfo[i]); + for (; i < min_arg_count; ++i) { + buffer[i] = JsValueFromV8LocalValue(cbinfo_[i]); } if (i < buffer_length) { napi_value undefined = - v8impl::JsValueFromV8LocalValue(v8::Undefined(_cbinfo.GetIsolate())); - for (; i < buffer_length; i += 1) { + JsValueFromV8LocalValue(v8::Undefined(cbinfo_.GetIsolate())); + for (; i < buffer_length; ++i) { buffer[i] = undefined; } } } - /*virtual*/ - void SetReturnValue(napi_value value) override { - v8::Local val = v8impl::V8LocalValueFromJsValue(value); - _cbinfo.GetReturnValue().Set(val); + napi_value This() { return JsValueFromV8LocalValue(cbinfo_.This()); } + + size_t ArgsLength() { return static_cast(cbinfo_.Length()); } + + void* Data() { return bundle_->cb_data; } + + private: + explicit FunctionCallbackWrapper( + const v8::FunctionCallbackInfo& cbinfo) + : cbinfo_(cbinfo), + bundle_(CallbackBundle::FromCallbackData(cbinfo.Data())) {} + + void InvokeCallback() { + napi_callback_info cbinfo_wrapper = + reinterpret_cast(this); + + // All other pointers we need are stored in `_bundle` + napi_env env = bundle_->env; + napi_callback cb = bundle_->cb; + + napi_value result = nullptr; + bool exceptionOccurred = false; + env->CallIntoModule([&](napi_env env) { result = cb(env, cbinfo_wrapper); }, + [&](napi_env env, v8::Local value) { + exceptionOccurred = true; + if (env->terminatedOrTerminating()) { + return; + } + env->isolate->ThrowException(value); + }); + + if (!exceptionOccurred && (result != nullptr)) { + cbinfo_.GetReturnValue().Set(V8LocalValueFromJsValue(result)); + } } + + private: + const v8::FunctionCallbackInfo& cbinfo_; + CallbackBundle* bundle_; }; inline napi_status Wrap(napi_env env, @@ -579,24 +547,29 @@ inline napi_status Wrap(napi_env env, // before then, then the finalize callback will never be invoked.) // Therefore a finalize callback is required when returning a reference. CHECK_ARG(env, finalize_cb); - reference = v8impl::Reference::New(env, - obj, - 0, - v8impl::Ownership::kUserland, - finalize_cb, - native_object, - finalize_hint); + reference = v8impl::ReferenceWithFinalizer::New( + env, + obj, + 0, + v8impl::ReferenceOwnership::kUserland, + finalize_cb, + native_object, + finalize_hint); *result = reinterpret_cast(reference); - } else { + } else if (finalize_cb != nullptr) { // Create a self-deleting reference. - reference = v8impl::Reference::New( + reference = v8impl::ReferenceWithFinalizer::New( env, obj, 0, - v8impl::Ownership::kRuntime, + v8impl::ReferenceOwnership::kRuntime, finalize_cb, native_object, - finalize_cb == nullptr ? nullptr : finalize_hint); + finalize_hint); + } else { + // Create a self-deleting reference. + reference = v8impl::ReferenceWithData::New( + env, obj, 0, v8impl::ReferenceOwnership::kRuntime, native_object); } CHECK(obj->SetPrivate(context, @@ -621,27 +594,46 @@ inline bool CanBeHeldWeakly(v8::Local value) { } // end of anonymous namespace +void Finalizer::ResetEnv() { + env_ = nullptr; +} + void Finalizer::ResetFinalizer() { finalize_callback_ = nullptr; finalize_data_ = nullptr; finalize_hint_ = nullptr; } +void Finalizer::CallFinalizer() { + napi_finalize finalize_callback = finalize_callback_; + void* finalize_data = finalize_data_; + void* finalize_hint = finalize_hint_; + ResetFinalizer(); + + if (finalize_callback == nullptr) return; + if (env_ == nullptr) { + // The environment is dead. Call the finalizer directly. + finalize_callback(nullptr, finalize_data, finalize_hint); + } else { + env_->CallFinalizer(finalize_callback, finalize_data, finalize_hint); + } +} + TrackedFinalizer::TrackedFinalizer(napi_env env, napi_finalize finalize_callback, void* finalize_data, void* finalize_hint) - : Finalizer(env, finalize_callback, finalize_data, finalize_hint), - RefTracker() { - Link(finalize_callback == nullptr ? &env->reflist : &env->finalizing_reflist); -} + : RefTracker(), + finalizer_(env, finalize_callback, finalize_data, finalize_hint) {} TrackedFinalizer* TrackedFinalizer::New(napi_env env, napi_finalize finalize_callback, void* finalize_data, void* finalize_hint) { - return new TrackedFinalizer( + TrackedFinalizer* finalizer = new TrackedFinalizer( env, finalize_callback, finalize_data, finalize_hint); + finalizer->Link(&env->finalizing_reflist); + return finalizer; } // When a TrackedFinalizer is being deleted, it may have been queued to call its @@ -650,92 +642,25 @@ TrackedFinalizer::~TrackedFinalizer() { // Remove from the env's tracked list. Unlink(); // Try to remove the finalizer from the scheduled second pass callback. - env_->DequeueFinalizer(this); + finalizer_.env()->DequeueFinalizer(this); } void TrackedFinalizer::Finalize() { - FinalizeCore(/*deleteMe:*/ true); -} - -void TrackedFinalizer::FinalizeCore(bool deleteMe) { - // Swap out the field finalize_callback so that it can not be accidentally - // called more than once. - napi_finalize finalize_callback = finalize_callback_; - void* finalize_data = finalize_data_; - void* finalize_hint = finalize_hint_; - ResetFinalizer(); - - // Either the RefBase is going to be deleted in the finalize_callback or not, - // it should be removed from the tracked list. Unlink(); - // If the finalize_callback is present, it should either delete the - // derived RefBase, or the RefBase ownership was set to Ownership::kRuntime - // and the deleteMe parameter is true. - if (finalize_callback != nullptr) { - env_->CallFinalizer(finalize_callback, finalize_data, finalize_hint); - } - - if (deleteMe) { - delete this; - } -} - -// Wrapper around v8impl::Persistent that implements reference counting. -RefBase::RefBase(napi_env env, - uint32_t initial_refcount, - Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) - : TrackedFinalizer(env, finalize_callback, finalize_data, finalize_hint), - refcount_(initial_refcount), - ownership_(ownership) {} - -RefBase* RefBase::New(napi_env env, - uint32_t initial_refcount, - Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) { - return new RefBase(env, - initial_refcount, - ownership, - finalize_callback, - finalize_data, - finalize_hint); -} - -void* RefBase::Data() { - return finalize_data_; -} - -uint32_t RefBase::Ref() { - return ++refcount_; -} - -uint32_t RefBase::Unref() { - if (refcount_ == 0) { - return 0; - } - return --refcount_; + finalizer_.CallFinalizer(); + delete this; } -uint32_t RefBase::RefCount() { - return refcount_; -} - -void RefBase::Finalize() { - // If the RefBase is not Ownership::kRuntime, userland code should delete it. - // Delete it if it is Ownership::kRuntime. - FinalizeCore(/*deleteMe:*/ ownership_ == Ownership::kRuntime); -} - -template -Reference::Reference(napi_env env, v8::Local value, Args&&... args) - : RefBase(env, std::forward(args)...), +Reference::Reference(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership) + : RefTracker(), persistent_(env->isolate, value), + refcount_(initial_refcount), + ownership_(ownership), can_be_weak_(CanBeHeldWeakly(value)) { - if (RefCount() == 0) { + if (refcount_ == 0) { SetWeak(); } } @@ -743,22 +668,18 @@ Reference::Reference(napi_env env, v8::Local value, Args&&... args) Reference::~Reference() { // Reset the handle. And no weak callback will be invoked. persistent_.Reset(); + + // Remove from the env's tracked list. + Unlink(); } Reference* Reference::New(napi_env env, v8::Local value, uint32_t initial_refcount, - Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) { - return new Reference(env, - value, - initial_refcount, - ownership, - finalize_callback, - finalize_data, - finalize_hint); + ReferenceOwnership ownership) { + Reference* reference = new Reference(env, value, initial_refcount, ownership); + reference->Link(&env->reflist); + return reference; } uint32_t Reference::Ref() { @@ -767,32 +688,29 @@ uint32_t Reference::Ref() { if (persistent_.IsEmpty()) { return 0; } - uint32_t refcount = RefBase::Ref(); - if (refcount == 1 && can_be_weak_) { + if (++refcount_ == 1 && can_be_weak_) { persistent_.ClearWeak(); } - return refcount; + return refcount_; } uint32_t Reference::Unref() { // When the persistent_ is cleared in the WeakCallback, and a second pass // callback is pending, return 0 unconditionally. - if (persistent_.IsEmpty()) { + if (persistent_.IsEmpty() || refcount_ == 0) { return 0; } - uint32_t old_refcount = RefCount(); - uint32_t refcount = RefBase::Unref(); - if (old_refcount == 1 && refcount == 0) { + if (--refcount_ == 0) { SetWeak(); } - return refcount; + return refcount_; } -v8::Local Reference::Get() { +v8::Local Reference::Get(napi_env env) { if (persistent_.IsEmpty()) { return v8::Local(); } else { - return v8::Local::New(env_->isolate, persistent_); + return v8::Local::New(env->isolate, persistent_); } } @@ -801,12 +719,30 @@ void Reference::Finalize() { // be invoked again. persistent_.Reset(); - // Chain up to perform the rest of the finalization. - RefBase::Finalize(); + // If the Reference is not ReferenceOwnership::kRuntime, userland code should + // delete it. Delete it if it is ReferenceOwnership::kRuntime. + bool deleteMe = ownership_ == ReferenceOwnership::kRuntime; + + // Whether the Reference is going to be deleted in the finalize_callback + // or not, it should be removed from the tracked list. + Unlink(); + + // If the finalize_callback is present, it should either delete the + // derived Reference, or the Reference ownership was set to + // ReferenceOwnership::kRuntime and the deleteMe parameter is true. + CallUserFinalizer(); + + if (deleteMe) { + delete this; + } } -// Mark the reference as weak and eligible for collection -// by the gc. +// Call the Finalize immediately since there is no user finalizer to call. +void Reference::InvokeFinalizerFromGC() { + Finalize(); +} + +// Mark the reference as weak and eligible for collection by the GC. void Reference::SetWeak() { if (can_be_weak_) { persistent_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter); @@ -815,14 +751,76 @@ void Reference::SetWeak() { } } -// The N-API finalizer callback may make calls into the engine. V8's heap is -// not in a consistent state during the weak callback, and therefore it does -// not support calls back into it. Enqueue the invocation of the finalizer. +// Static function called by GC. Delegate the call to the reference instance. void Reference::WeakCallback(const v8::WeakCallbackInfo& data) { Reference* reference = data.GetParameter(); - // The reference must be reset during the weak callback as the API protocol. + // The reference must be reset during the weak callback per V8 API protocol. reference->persistent_.Reset(); - reference->env_->InvokeFinalizerFromGC(reference); + reference->InvokeFinalizerFromGC(); +} + +ReferenceWithData* ReferenceWithData::New(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + void* data) { + ReferenceWithData* reference = + new ReferenceWithData(env, value, initial_refcount, ownership, data); + reference->Link(&env->reflist); + return reference; +} + +ReferenceWithData::ReferenceWithData(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + void* data) + : Reference(env, value, initial_refcount, ownership), data_(data) {} + +ReferenceWithFinalizer* ReferenceWithFinalizer::New( + napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + napi_finalize finalize_callback, + void* finalize_data, + void* finalize_hint) { + ReferenceWithFinalizer* reference = + new ReferenceWithFinalizer(env, + value, + initial_refcount, + ownership, + finalize_callback, + finalize_data, + finalize_hint); + reference->Link(&env->finalizing_reflist); + return reference; +} + +ReferenceWithFinalizer::ReferenceWithFinalizer(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + napi_finalize finalize_callback, + void* finalize_data, + void* finalize_hint) + : Reference(env, value, initial_refcount, ownership), + finalizer_(env, finalize_callback, finalize_data, finalize_hint) {} + +ReferenceWithFinalizer::~ReferenceWithFinalizer() { + // Try to remove the finalizer from the scheduled second pass callback. + finalizer_.env()->DequeueFinalizer(this); +} + +void ReferenceWithFinalizer::CallUserFinalizer() { + finalizer_.CallFinalizer(); +} + +// The Node-API finalizer callback may make calls into the engine. V8's heap is +// not in a consistent state during the weak callback, and therefore it does +// not support calls back into it. Enqueue the invocation of the finalizer. +void ReferenceWithFinalizer::InvokeFinalizerFromGC() { + finalizer_.env()->InvokeFinalizerFromGC(this); } /** @@ -2048,8 +2046,8 @@ napi_status NAPI_CDECL napi_get_cb_info( CHECK_ENV(env); CHECK_ARG(env, cbinfo); - v8impl::CallbackWrapper* info = - reinterpret_cast(cbinfo); + v8impl::FunctionCallbackWrapper* info = + reinterpret_cast(cbinfo); if (argv != nullptr) { CHECK_ARG(env, argc); @@ -2075,8 +2073,8 @@ napi_status NAPI_CDECL napi_get_new_target(napi_env env, CHECK_ARG(env, cbinfo); CHECK_ARG(env, result); - v8impl::CallbackWrapper* info = - reinterpret_cast(cbinfo); + v8impl::FunctionCallbackWrapper* info = + reinterpret_cast(cbinfo); *result = info->GetNewTarget(); return napi_clear_last_error(env); @@ -2598,13 +2596,13 @@ napi_create_external(napi_env env, if (finalize_cb) { // The Reference object will delete itself after invoking the finalizer // callback. - v8impl::Reference::New(env, - external_value, - 0, - v8impl::Ownership::kRuntime, - finalize_cb, - data, - finalize_hint); + v8impl::ReferenceWithFinalizer::New(env, + external_value, + 0, + v8impl::ReferenceOwnership::kRuntime, + finalize_cb, + data, + finalize_hint); } *result = v8impl::JsValueFromV8LocalValue(external_value); @@ -2739,7 +2737,7 @@ napi_status NAPI_CDECL napi_create_reference(napi_env env, } v8impl::Reference* reference = v8impl::Reference::New( - env, v8_value, initial_refcount, v8impl::Ownership::kUserland); + env, v8_value, initial_refcount, v8impl::ReferenceOwnership::kUserland); *result = reinterpret_cast(reference); return napi_clear_last_error(env); @@ -2795,7 +2793,7 @@ napi_status NAPI_CDECL napi_reference_unref(napi_env env, v8impl::Reference* reference = reinterpret_cast(ref); - if (reference->RefCount() == 0) { + if (reference->refcount() == 0) { return napi_set_last_error(env, napi_generic_failure); } @@ -2821,7 +2819,7 @@ napi_status NAPI_CDECL napi_get_reference_value(napi_env env, CHECK_ARG(env, result); v8impl::Reference* reference = reinterpret_cast(ref); - *result = v8impl::JsValueFromV8LocalValue(reference->Get()); + *result = v8impl::JsValueFromV8LocalValue(reference->Get(env)); return napi_clear_last_error(env); } @@ -3432,10 +3430,10 @@ napi_add_finalizer(napi_env env, // Create a self-deleting reference if the optional out-param result is not // set. - v8impl::Ownership ownership = result == nullptr - ? v8impl::Ownership::kRuntime - : v8impl::Ownership::kUserland; - v8impl::Reference* reference = v8impl::Reference::New( + v8impl::ReferenceOwnership ownership = + result == nullptr ? v8impl::ReferenceOwnership::kRuntime + : v8impl::ReferenceOwnership::kUserland; + v8impl::Reference* reference = v8impl::ReferenceWithFinalizer::New( env, v8_value, 0, ownership, finalize_cb, finalize_data, finalize_hint); if (result != nullptr) { @@ -3478,15 +3476,16 @@ napi_status NAPI_CDECL napi_set_instance_data(node_api_basic_env basic_env, napi_env env = const_cast(basic_env); CHECK_ENV(env); - v8impl::RefBase* old_data = static_cast(env->instance_data); + v8impl::TrackedFinalizer* old_data = + static_cast(env->instance_data); if (old_data != nullptr) { // Our contract so far has been to not finalize any old data there may be. // So we simply delete it. delete old_data; } - env->instance_data = v8impl::RefBase::New( - env, 0, v8impl::Ownership::kRuntime, finalize_cb, data, finalize_hint); + env->instance_data = + v8impl::TrackedFinalizer::New(env, finalize_cb, data, finalize_hint); return napi_clear_last_error(env); } @@ -3496,9 +3495,10 @@ napi_status NAPI_CDECL napi_get_instance_data(node_api_basic_env env, CHECK_ENV(env); CHECK_ARG(env, data); - v8impl::RefBase* idata = static_cast(env->instance_data); + v8impl::TrackedFinalizer* idata = + static_cast(env->instance_data); - *data = (idata == nullptr ? nullptr : idata->Data()); + *data = (idata == nullptr ? nullptr : idata->data()); return napi_clear_last_error(env); } diff --git a/src/js_native_api_v8.h b/src/js_native_api_v8.h index 1817226b2daac4..99bb30cfbe9a9d 100644 --- a/src/js_native_api_v8.h +++ b/src/js_native_api_v8.h @@ -8,14 +8,15 @@ inline napi_status napi_clear_last_error(node_api_basic_env env); namespace v8impl { +// Base class to track references and finalizers in a doubly linked list. class RefTracker { public: + using RefList = RefTracker; + RefTracker() = default; virtual ~RefTracker() = default; virtual void Finalize() {} - typedef RefTracker RefList; - inline void Link(RefList* list) { prev_ = list; next_ = list->next_; @@ -47,7 +48,6 @@ class RefTracker { RefList* prev_ = nullptr; }; -class Finalizer; } // end of namespace v8impl struct napi_env__ { @@ -99,11 +99,7 @@ struct napi_env__ { } } - // Call finalizer immediately. - virtual void CallFinalizer(napi_finalize cb, void* data, void* hint) { - v8::HandleScope handle_scope(isolate); - CallIntoModule([&](napi_env env) { cb(env, data, hint); }); - } + virtual void CallFinalizer(napi_finalize cb, void* data, void* hint) = 0; // Invoke finalizer from V8 garbage collector. void InvokeFinalizerFromGC(v8impl::RefTracker* finalizer); @@ -323,7 +319,7 @@ inline v8::Local V8LocalValueFromJsValue(napi_value v) { // Adapter for napi_finalize callbacks. class Finalizer { - protected: + public: Finalizer(napi_env env, napi_finalize finalize_callback, void* finalize_data, @@ -333,23 +329,14 @@ class Finalizer { finalize_data_(finalize_data), finalize_hint_(finalize_hint) {} - virtual ~Finalizer() = default; - - public: - static Finalizer* New(napi_env env, - napi_finalize finalize_callback = nullptr, - void* finalize_data = nullptr, - void* finalize_hint = nullptr) { - return new Finalizer(env, finalize_callback, finalize_data, finalize_hint); - } - - napi_finalize callback() { return finalize_callback_; } + napi_env env() { return env_; } void* data() { return finalize_data_; } - void* hint() { return finalize_hint_; } + void ResetEnv(); void ResetFinalizer(); + void CallFinalizer(); - protected: + private: napi_env env_; napi_finalize finalize_callback_; void* finalize_data_; @@ -370,24 +357,8 @@ class TryCatch : public v8::TryCatch { napi_env _env; }; -// Ownership of a reference. -enum class Ownership { - // The reference is owned by the runtime. No userland call is needed to - // destruct the reference. - kRuntime, - // The reference is owned by the userland. User code is responsible to delete - // the reference with appropriate node-api calls. - kUserland, -}; - // Wrapper around Finalizer that can be tracked. -class TrackedFinalizer : public Finalizer, public RefTracker { - protected: - TrackedFinalizer(napi_env env, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint); - +class TrackedFinalizer final : public RefTracker { public: static TrackedFinalizer* New(napi_env env, napi_finalize finalize_callback, @@ -395,76 +366,120 @@ class TrackedFinalizer : public Finalizer, public RefTracker { void* finalize_hint); ~TrackedFinalizer() override; - protected: - void Finalize() override; - void FinalizeCore(bool deleteMe); -}; + void* data() { return finalizer_.data(); } -// Wrapper around TrackedFinalizer that implements reference counting. -class RefBase : public TrackedFinalizer { - protected: - RefBase(napi_env env, - uint32_t initial_refcount, - Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint); - - public: - static RefBase* New(napi_env env, - uint32_t initial_refcount, - Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint); - - void* Data(); - uint32_t Ref(); - uint32_t Unref(); - uint32_t RefCount(); - - Ownership ownership() { return ownership_; } - - protected: + private: + TrackedFinalizer(napi_env env, + napi_finalize finalize_callback, + void* finalize_data, + void* finalize_hint); void Finalize() override; private: - uint32_t refcount_; - Ownership ownership_; + Finalizer finalizer_; }; -// Wrapper around v8impl::Persistent. -class Reference : public RefBase { - protected: - template - Reference(napi_env env, v8::Local value, Args&&... args); +// Ownership of a reference. +enum class ReferenceOwnership : uint8_t { + // The reference is owned by the runtime. No userland call is needed to + // destruct the reference. + kRuntime, + // The reference is owned by the userland. User code is responsible to delete + // the reference with appropriate node-api calls. + kUserland, +}; +// Wrapper around v8impl::Persistent. +class Reference : public RefTracker { public: static Reference* New(napi_env env, v8::Local value, uint32_t initial_refcount, - Ownership ownership, - napi_finalize finalize_callback = nullptr, - void* finalize_data = nullptr, - void* finalize_hint = nullptr); + ReferenceOwnership ownership); + ~Reference() override; - virtual ~Reference(); uint32_t Ref(); uint32_t Unref(); - v8::Local Get(); + v8::Local Get(napi_env env); + + virtual void ResetFinalizer() {} + virtual void* Data() { return nullptr; } + + uint32_t refcount() const { return refcount_; } + ReferenceOwnership ownership() { return ownership_; } protected: - void Finalize() override; + Reference(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership); + virtual void CallUserFinalizer() {} + virtual void InvokeFinalizerFromGC(); private: static void WeakCallback(const v8::WeakCallbackInfo& data); - void SetWeak(); + void Finalize() override; + private: v8impl::Persistent persistent_; + uint32_t refcount_; + ReferenceOwnership ownership_; bool can_be_weak_; }; +// Reference that can store additional data. +class ReferenceWithData final : public Reference { + public: + static ReferenceWithData* New(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + void* data); + + void* Data() override { return data_; } + + private: + ReferenceWithData(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + void* data); + + private: + void* data_; +}; + +// Reference that has a user finalizer callback. +class ReferenceWithFinalizer final : public Reference { + public: + static ReferenceWithFinalizer* New(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + napi_finalize finalize_callback, + void* finalize_data, + void* finalize_hint); + ~ReferenceWithFinalizer() override; + + void ResetFinalizer() override { finalizer_.ResetFinalizer(); } + void* Data() override { return finalizer_.data(); } + + private: + ReferenceWithFinalizer(napi_env env, + v8::Local value, + uint32_t initial_refcount, + ReferenceOwnership ownership, + napi_finalize finalize_callback, + void* finalize_data, + void* finalize_hint); + void CallUserFinalizer() override; + void InvokeFinalizerFromGC() override; + + private: + Finalizer finalizer_; +}; + } // end of namespace v8impl #endif // SRC_JS_NATIVE_API_V8_H_ diff --git a/src/node_api.cc b/src/node_api.cc index 542ee21d0f4660..a019a1826c6ce7 100644 --- a/src/node_api.cc +++ b/src/node_api.cc @@ -122,9 +122,9 @@ namespace { class BufferFinalizer : private Finalizer { public: static BufferFinalizer* New(napi_env env, - napi_finalize finalize_callback = nullptr, - void* finalize_data = nullptr, - void* finalize_hint = nullptr) { + napi_finalize finalize_callback, + void* finalize_data, + void* finalize_hint) { return new BufferFinalizer( env, finalize_callback, finalize_data, finalize_hint); } @@ -132,13 +132,8 @@ class BufferFinalizer : private Finalizer { static void FinalizeBufferCallback(char* data, void* hint) { std::unique_ptr finalizer{ static_cast(hint)}; - finalizer->finalize_data_ = data; - // It is safe to call into JavaScript at this point. - if (finalizer->finalize_callback_ == nullptr) return; - finalizer->env_->CallFinalizer(finalizer->finalize_callback_, - finalizer->finalize_data_, - finalizer->finalize_hint_); + finalizer->CallFinalizer(); } struct Deleter { @@ -151,10 +146,10 @@ class BufferFinalizer : private Finalizer { void* finalize_data, void* finalize_hint) : Finalizer(env, finalize_callback, finalize_data, finalize_hint) { - env_->Ref(); + env->Ref(); } - ~BufferFinalizer() { env_->Unref(); } + ~BufferFinalizer() { env()->Unref(); } }; void ThrowNodeApiVersionError(node::Environment* node_env, @@ -1064,7 +1059,7 @@ napi_create_external_buffer(napi_env env, // The finalizer object will delete itself after invoking the callback. v8impl::BufferFinalizer* finalizer = - v8impl::BufferFinalizer::New(env, finalize_cb, nullptr, finalize_hint); + v8impl::BufferFinalizer::New(env, finalize_cb, data, finalize_hint); v8::MaybeLocal maybe = node::Buffer::New(isolate, From 101e2996561c2e311f8e354c3ed08befaf0b8cf8 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Mon, 19 Aug 2024 16:53:33 -0700 Subject: [PATCH 51/90] src: move more crypto_dh.cc code to ncrypto Update deps/ncrypto/ncrypto.cc PR-URL: https://github.com/nodejs/node/pull/54459 Reviewed-By: Yagiz Nizipli --- deps/ncrypto/dh-primes.h | 304 ++++++++++++++ deps/ncrypto/ncrypto.cc | 236 +++++++++++ deps/ncrypto/ncrypto.gyp | 1 + deps/ncrypto/ncrypto.h | 79 +++- src/crypto/crypto_dh.cc | 700 ++++++++++++++------------------ src/crypto/crypto_dh.h | 35 +- test/parallel/test-crypto-dh.js | 2 +- 7 files changed, 920 insertions(+), 437 deletions(-) create mode 100644 deps/ncrypto/dh-primes.h diff --git a/deps/ncrypto/dh-primes.h b/deps/ncrypto/dh-primes.h new file mode 100644 index 00000000000000..e8e8da3dddddd0 --- /dev/null +++ b/deps/ncrypto/dh-primes.h @@ -0,0 +1,304 @@ +/* ==================================================================== + * Copyright (c) 2011 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * licensing@OpenSSL.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * ==================================================================== + * + * This product includes cryptographic software written by Eric Young + * (eay@cryptsoft.com). This product includes software written by Tim + * Hudson (tjh@cryptsoft.com). */ + +#include + +#include +#include +#include + +extern "C" int bn_set_words(BIGNUM *bn, const BN_ULONG *words, size_t num); + +// Backporting primes that may not be supported in earlier boringssl versions. Intentionally +// keeping the existing C-style formatting. + +#define OPENSSL_ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) + +#if defined(OPENSSL_64_BIT) +#define TOBN(hi, lo) ((BN_ULONG)(hi) << 32 | (lo)) +#elif defined(OPENSSL_32_BIT) +#define TOBN(hi, lo) (lo), (hi) +#else +#error "Must define either OPENSSL_32_BIT or OPENSSL_64_BIT" +#endif + +static BIGNUM *get_params(BIGNUM *ret, const BN_ULONG *words, size_t num_words) { + BIGNUM *alloc = NULL; + if (ret == NULL) { + alloc = BN_new(); + if (alloc == NULL) { + return NULL; + } + ret = alloc; + } + + if (!bn_set_words(ret, words, num_words)) { + BN_free(alloc); + return NULL; + } + + return ret; +} + +BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *ret) { + static const BN_ULONG kWords[] = { + TOBN(0xffffffff, 0xffffffff), TOBN(0x15728e5a, 0x8aacaa68), + TOBN(0x15d22618, 0x98fa0510), TOBN(0x3995497c, 0xea956ae5), + TOBN(0xde2bcbf6, 0x95581718), TOBN(0xb5c55df0, 0x6f4c52c9), + TOBN(0x9b2783a2, 0xec07a28f), TOBN(0xe39e772c, 0x180e8603), + TOBN(0x32905e46, 0x2e36ce3b), TOBN(0xf1746c08, 0xca18217c), + TOBN(0x670c354e, 0x4abc9804), TOBN(0x9ed52907, 0x7096966d), + TOBN(0x1c62f356, 0x208552bb), TOBN(0x83655d23, 0xdca3ad96), + TOBN(0x69163fa8, 0xfd24cf5f), TOBN(0x98da4836, 0x1c55d39a), + TOBN(0xc2007cb8, 0xa163bf05), TOBN(0x49286651, 0xece45b3d), + TOBN(0xae9f2411, 0x7c4b1fe6), TOBN(0xee386bfb, 0x5a899fa5), + TOBN(0x0bff5cb6, 0xf406b7ed), TOBN(0xf44c42e9, 0xa637ed6b), + TOBN(0xe485b576, 0x625e7ec6), TOBN(0x4fe1356d, 0x6d51c245), + TOBN(0x302b0a6d, 0xf25f1437), TOBN(0xef9519b3, 0xcd3a431b), + TOBN(0x514a0879, 0x8e3404dd), TOBN(0x020bbea6, 0x3b139b22), + TOBN(0x29024e08, 0x8a67cc74), TOBN(0xc4c6628b, 0x80dc1cd1), + TOBN(0xc90fdaa2, 0x2168c234), TOBN(0xffffffff, 0xffffffff), + }; + return get_params(ret, kWords, OPENSSL_ARRAY_SIZE(kWords)); +} + +BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *ret) { + static const BN_ULONG kWords[] = { + TOBN(0xffffffff, 0xffffffff), TOBN(0x4b82d120, 0xa93ad2ca), + TOBN(0x43db5bfc, 0xe0fd108e), TOBN(0x08e24fa0, 0x74e5ab31), + TOBN(0x770988c0, 0xbad946e2), TOBN(0xbbe11757, 0x7a615d6c), + TOBN(0x521f2b18, 0x177b200c), TOBN(0xd8760273, 0x3ec86a64), + TOBN(0xf12ffa06, 0xd98a0864), TOBN(0xcee3d226, 0x1ad2ee6b), + TOBN(0x1e8c94e0, 0x4a25619d), TOBN(0xabf5ae8c, 0xdb0933d7), + TOBN(0xb3970f85, 0xa6e1e4c7), TOBN(0x8aea7157, 0x5d060c7d), + TOBN(0xecfb8504, 0x58dbef0a), TOBN(0xa85521ab, 0xdf1cba64), + TOBN(0xad33170d, 0x04507a33), TOBN(0x15728e5a, 0x8aaac42d), + TOBN(0x15d22618, 0x98fa0510), TOBN(0x3995497c, 0xea956ae5), + TOBN(0xde2bcbf6, 0x95581718), TOBN(0xb5c55df0, 0x6f4c52c9), + TOBN(0x9b2783a2, 0xec07a28f), TOBN(0xe39e772c, 0x180e8603), + TOBN(0x32905e46, 0x2e36ce3b), TOBN(0xf1746c08, 0xca18217c), + TOBN(0x670c354e, 0x4abc9804), TOBN(0x9ed52907, 0x7096966d), + TOBN(0x1c62f356, 0x208552bb), TOBN(0x83655d23, 0xdca3ad96), + TOBN(0x69163fa8, 0xfd24cf5f), TOBN(0x98da4836, 0x1c55d39a), + TOBN(0xc2007cb8, 0xa163bf05), TOBN(0x49286651, 0xece45b3d), + TOBN(0xae9f2411, 0x7c4b1fe6), TOBN(0xee386bfb, 0x5a899fa5), + TOBN(0x0bff5cb6, 0xf406b7ed), TOBN(0xf44c42e9, 0xa637ed6b), + TOBN(0xe485b576, 0x625e7ec6), TOBN(0x4fe1356d, 0x6d51c245), + TOBN(0x302b0a6d, 0xf25f1437), TOBN(0xef9519b3, 0xcd3a431b), + TOBN(0x514a0879, 0x8e3404dd), TOBN(0x020bbea6, 0x3b139b22), + TOBN(0x29024e08, 0x8a67cc74), TOBN(0xc4c6628b, 0x80dc1cd1), + TOBN(0xc90fdaa2, 0x2168c234), TOBN(0xffffffff, 0xffffffff), + }; + return get_params(ret, kWords, OPENSSL_ARRAY_SIZE(kWords)); +} + +BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *ret) { + static const BN_ULONG kWords[] = { + TOBN(0xffffffff, 0xffffffff), TOBN(0x4df435c9, 0x34063199), + TOBN(0x86ffb7dc, 0x90a6c08f), TOBN(0x93b4ea98, 0x8d8fddc1), + TOBN(0xd0069127, 0xd5b05aa9), TOBN(0xb81bdd76, 0x2170481c), + TOBN(0x1f612970, 0xcee2d7af), TOBN(0x233ba186, 0x515be7ed), + TOBN(0x99b2964f, 0xa090c3a2), TOBN(0x287c5947, 0x4e6bc05d), + TOBN(0x2e8efc14, 0x1fbecaa6), TOBN(0xdbbbc2db, 0x04de8ef9), + TOBN(0x2583e9ca, 0x2ad44ce8), TOBN(0x1a946834, 0xb6150bda), + TOBN(0x99c32718, 0x6af4e23c), TOBN(0x88719a10, 0xbdba5b26), + TOBN(0x1a723c12, 0xa787e6d7), TOBN(0x4b82d120, 0xa9210801), + TOBN(0x43db5bfc, 0xe0fd108e), TOBN(0x08e24fa0, 0x74e5ab31), + TOBN(0x770988c0, 0xbad946e2), TOBN(0xbbe11757, 0x7a615d6c), + TOBN(0x521f2b18, 0x177b200c), TOBN(0xd8760273, 0x3ec86a64), + TOBN(0xf12ffa06, 0xd98a0864), TOBN(0xcee3d226, 0x1ad2ee6b), + TOBN(0x1e8c94e0, 0x4a25619d), TOBN(0xabf5ae8c, 0xdb0933d7), + TOBN(0xb3970f85, 0xa6e1e4c7), TOBN(0x8aea7157, 0x5d060c7d), + TOBN(0xecfb8504, 0x58dbef0a), TOBN(0xa85521ab, 0xdf1cba64), + TOBN(0xad33170d, 0x04507a33), TOBN(0x15728e5a, 0x8aaac42d), + TOBN(0x15d22618, 0x98fa0510), TOBN(0x3995497c, 0xea956ae5), + TOBN(0xde2bcbf6, 0x95581718), TOBN(0xb5c55df0, 0x6f4c52c9), + TOBN(0x9b2783a2, 0xec07a28f), TOBN(0xe39e772c, 0x180e8603), + TOBN(0x32905e46, 0x2e36ce3b), TOBN(0xf1746c08, 0xca18217c), + TOBN(0x670c354e, 0x4abc9804), TOBN(0x9ed52907, 0x7096966d), + TOBN(0x1c62f356, 0x208552bb), TOBN(0x83655d23, 0xdca3ad96), + TOBN(0x69163fa8, 0xfd24cf5f), TOBN(0x98da4836, 0x1c55d39a), + TOBN(0xc2007cb8, 0xa163bf05), TOBN(0x49286651, 0xece45b3d), + TOBN(0xae9f2411, 0x7c4b1fe6), TOBN(0xee386bfb, 0x5a899fa5), + TOBN(0x0bff5cb6, 0xf406b7ed), TOBN(0xf44c42e9, 0xa637ed6b), + TOBN(0xe485b576, 0x625e7ec6), TOBN(0x4fe1356d, 0x6d51c245), + TOBN(0x302b0a6d, 0xf25f1437), TOBN(0xef9519b3, 0xcd3a431b), + TOBN(0x514a0879, 0x8e3404dd), TOBN(0x020bbea6, 0x3b139b22), + TOBN(0x29024e08, 0x8a67cc74), TOBN(0xc4c6628b, 0x80dc1cd1), + TOBN(0xc90fdaa2, 0x2168c234), TOBN(0xffffffff, 0xffffffff), + }; + return get_params(ret, kWords, OPENSSL_ARRAY_SIZE(kWords)); +} + +BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *ret) { + static const BN_ULONG kWords[] = { + TOBN(0xffffffff, 0xffffffff), TOBN(0xe694f91e, 0x6dcc4024), + TOBN(0x12bf2d5b, 0x0b7474d6), TOBN(0x043e8f66, 0x3f4860ee), + TOBN(0x387fe8d7, 0x6e3c0468), TOBN(0xda56c9ec, 0x2ef29632), + TOBN(0xeb19ccb1, 0xa313d55c), TOBN(0xf550aa3d, 0x8a1fbff0), + TOBN(0x06a1d58b, 0xb7c5da76), TOBN(0xa79715ee, 0xf29be328), + TOBN(0x14cc5ed2, 0x0f8037e0), TOBN(0xcc8f6d7e, 0xbf48e1d8), + TOBN(0x4bd407b2, 0x2b4154aa), TOBN(0x0f1d45b7, 0xff585ac5), + TOBN(0x23a97a7e, 0x36cc88be), TOBN(0x59e7c97f, 0xbec7e8f3), + TOBN(0xb5a84031, 0x900b1c9e), TOBN(0xd55e702f, 0x46980c82), + TOBN(0xf482d7ce, 0x6e74fef6), TOBN(0xf032ea15, 0xd1721d03), + TOBN(0x5983ca01, 0xc64b92ec), TOBN(0x6fb8f401, 0x378cd2bf), + TOBN(0x33205151, 0x2bd7af42), TOBN(0xdb7f1447, 0xe6cc254b), + TOBN(0x44ce6cba, 0xced4bb1b), TOBN(0xda3edbeb, 0xcf9b14ed), + TOBN(0x179727b0, 0x865a8918), TOBN(0xb06a53ed, 0x9027d831), + TOBN(0xe5db382f, 0x413001ae), TOBN(0xf8ff9406, 0xad9e530e), + TOBN(0xc9751e76, 0x3dba37bd), TOBN(0xc1d4dcb2, 0x602646de), + TOBN(0x36c3fab4, 0xd27c7026), TOBN(0x4df435c9, 0x34028492), + TOBN(0x86ffb7dc, 0x90a6c08f), TOBN(0x93b4ea98, 0x8d8fddc1), + TOBN(0xd0069127, 0xd5b05aa9), TOBN(0xb81bdd76, 0x2170481c), + TOBN(0x1f612970, 0xcee2d7af), TOBN(0x233ba186, 0x515be7ed), + TOBN(0x99b2964f, 0xa090c3a2), TOBN(0x287c5947, 0x4e6bc05d), + TOBN(0x2e8efc14, 0x1fbecaa6), TOBN(0xdbbbc2db, 0x04de8ef9), + TOBN(0x2583e9ca, 0x2ad44ce8), TOBN(0x1a946834, 0xb6150bda), + TOBN(0x99c32718, 0x6af4e23c), TOBN(0x88719a10, 0xbdba5b26), + TOBN(0x1a723c12, 0xa787e6d7), TOBN(0x4b82d120, 0xa9210801), + TOBN(0x43db5bfc, 0xe0fd108e), TOBN(0x08e24fa0, 0x74e5ab31), + TOBN(0x770988c0, 0xbad946e2), TOBN(0xbbe11757, 0x7a615d6c), + TOBN(0x521f2b18, 0x177b200c), TOBN(0xd8760273, 0x3ec86a64), + TOBN(0xf12ffa06, 0xd98a0864), TOBN(0xcee3d226, 0x1ad2ee6b), + TOBN(0x1e8c94e0, 0x4a25619d), TOBN(0xabf5ae8c, 0xdb0933d7), + TOBN(0xb3970f85, 0xa6e1e4c7), TOBN(0x8aea7157, 0x5d060c7d), + TOBN(0xecfb8504, 0x58dbef0a), TOBN(0xa85521ab, 0xdf1cba64), + TOBN(0xad33170d, 0x04507a33), TOBN(0x15728e5a, 0x8aaac42d), + TOBN(0x15d22618, 0x98fa0510), TOBN(0x3995497c, 0xea956ae5), + TOBN(0xde2bcbf6, 0x95581718), TOBN(0xb5c55df0, 0x6f4c52c9), + TOBN(0x9b2783a2, 0xec07a28f), TOBN(0xe39e772c, 0x180e8603), + TOBN(0x32905e46, 0x2e36ce3b), TOBN(0xf1746c08, 0xca18217c), + TOBN(0x670c354e, 0x4abc9804), TOBN(0x9ed52907, 0x7096966d), + TOBN(0x1c62f356, 0x208552bb), TOBN(0x83655d23, 0xdca3ad96), + TOBN(0x69163fa8, 0xfd24cf5f), TOBN(0x98da4836, 0x1c55d39a), + TOBN(0xc2007cb8, 0xa163bf05), TOBN(0x49286651, 0xece45b3d), + TOBN(0xae9f2411, 0x7c4b1fe6), TOBN(0xee386bfb, 0x5a899fa5), + TOBN(0x0bff5cb6, 0xf406b7ed), TOBN(0xf44c42e9, 0xa637ed6b), + TOBN(0xe485b576, 0x625e7ec6), TOBN(0x4fe1356d, 0x6d51c245), + TOBN(0x302b0a6d, 0xf25f1437), TOBN(0xef9519b3, 0xcd3a431b), + TOBN(0x514a0879, 0x8e3404dd), TOBN(0x020bbea6, 0x3b139b22), + TOBN(0x29024e08, 0x8a67cc74), TOBN(0xc4c6628b, 0x80dc1cd1), + TOBN(0xc90fdaa2, 0x2168c234), TOBN(0xffffffff, 0xffffffff), + }; + return get_params(ret, kWords, OPENSSL_ARRAY_SIZE(kWords)); +} + +BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *ret) { + static const BN_ULONG kWords[] = { + TOBN(0xffffffff, 0xffffffff), TOBN(0x60c980dd, 0x98edd3df), + TOBN(0xc81f56e8, 0x80b96e71), TOBN(0x9e3050e2, 0x765694df), + TOBN(0x9558e447, 0x5677e9aa), TOBN(0xc9190da6, 0xfc026e47), + TOBN(0x889a002e, 0xd5ee382b), TOBN(0x4009438b, 0x481c6cd7), + TOBN(0x359046f4, 0xeb879f92), TOBN(0xfaf36bc3, 0x1ecfa268), + TOBN(0xb1d510bd, 0x7ee74d73), TOBN(0xf9ab4819, 0x5ded7ea1), + TOBN(0x64f31cc5, 0x0846851d), TOBN(0x4597e899, 0xa0255dc1), + TOBN(0xdf310ee0, 0x74ab6a36), TOBN(0x6d2a13f8, 0x3f44f82d), + TOBN(0x062b3cf5, 0xb3a278a6), TOBN(0x79683303, 0xed5bdd3a), + TOBN(0xfa9d4b7f, 0xa2c087e8), TOBN(0x4bcbc886, 0x2f8385dd), + TOBN(0x3473fc64, 0x6cea306b), TOBN(0x13eb57a8, 0x1a23f0c7), + TOBN(0x22222e04, 0xa4037c07), TOBN(0xe3fdb8be, 0xfc848ad9), + TOBN(0x238f16cb, 0xe39d652d), TOBN(0x3423b474, 0x2bf1c978), + TOBN(0x3aab639c, 0x5ae4f568), TOBN(0x2576f693, 0x6ba42466), + TOBN(0x741fa7bf, 0x8afc47ed), TOBN(0x3bc832b6, 0x8d9dd300), + TOBN(0xd8bec4d0, 0x73b931ba), TOBN(0x38777cb6, 0xa932df8c), + TOBN(0x74a3926f, 0x12fee5e4), TOBN(0xe694f91e, 0x6dbe1159), + TOBN(0x12bf2d5b, 0x0b7474d6), TOBN(0x043e8f66, 0x3f4860ee), + TOBN(0x387fe8d7, 0x6e3c0468), TOBN(0xda56c9ec, 0x2ef29632), + TOBN(0xeb19ccb1, 0xa313d55c), TOBN(0xf550aa3d, 0x8a1fbff0), + TOBN(0x06a1d58b, 0xb7c5da76), TOBN(0xa79715ee, 0xf29be328), + TOBN(0x14cc5ed2, 0x0f8037e0), TOBN(0xcc8f6d7e, 0xbf48e1d8), + TOBN(0x4bd407b2, 0x2b4154aa), TOBN(0x0f1d45b7, 0xff585ac5), + TOBN(0x23a97a7e, 0x36cc88be), TOBN(0x59e7c97f, 0xbec7e8f3), + TOBN(0xb5a84031, 0x900b1c9e), TOBN(0xd55e702f, 0x46980c82), + TOBN(0xf482d7ce, 0x6e74fef6), TOBN(0xf032ea15, 0xd1721d03), + TOBN(0x5983ca01, 0xc64b92ec), TOBN(0x6fb8f401, 0x378cd2bf), + TOBN(0x33205151, 0x2bd7af42), TOBN(0xdb7f1447, 0xe6cc254b), + TOBN(0x44ce6cba, 0xced4bb1b), TOBN(0xda3edbeb, 0xcf9b14ed), + TOBN(0x179727b0, 0x865a8918), TOBN(0xb06a53ed, 0x9027d831), + TOBN(0xe5db382f, 0x413001ae), TOBN(0xf8ff9406, 0xad9e530e), + TOBN(0xc9751e76, 0x3dba37bd), TOBN(0xc1d4dcb2, 0x602646de), + TOBN(0x36c3fab4, 0xd27c7026), TOBN(0x4df435c9, 0x34028492), + TOBN(0x86ffb7dc, 0x90a6c08f), TOBN(0x93b4ea98, 0x8d8fddc1), + TOBN(0xd0069127, 0xd5b05aa9), TOBN(0xb81bdd76, 0x2170481c), + TOBN(0x1f612970, 0xcee2d7af), TOBN(0x233ba186, 0x515be7ed), + TOBN(0x99b2964f, 0xa090c3a2), TOBN(0x287c5947, 0x4e6bc05d), + TOBN(0x2e8efc14, 0x1fbecaa6), TOBN(0xdbbbc2db, 0x04de8ef9), + TOBN(0x2583e9ca, 0x2ad44ce8), TOBN(0x1a946834, 0xb6150bda), + TOBN(0x99c32718, 0x6af4e23c), TOBN(0x88719a10, 0xbdba5b26), + TOBN(0x1a723c12, 0xa787e6d7), TOBN(0x4b82d120, 0xa9210801), + TOBN(0x43db5bfc, 0xe0fd108e), TOBN(0x08e24fa0, 0x74e5ab31), + TOBN(0x770988c0, 0xbad946e2), TOBN(0xbbe11757, 0x7a615d6c), + TOBN(0x521f2b18, 0x177b200c), TOBN(0xd8760273, 0x3ec86a64), + TOBN(0xf12ffa06, 0xd98a0864), TOBN(0xcee3d226, 0x1ad2ee6b), + TOBN(0x1e8c94e0, 0x4a25619d), TOBN(0xabf5ae8c, 0xdb0933d7), + TOBN(0xb3970f85, 0xa6e1e4c7), TOBN(0x8aea7157, 0x5d060c7d), + TOBN(0xecfb8504, 0x58dbef0a), TOBN(0xa85521ab, 0xdf1cba64), + TOBN(0xad33170d, 0x04507a33), TOBN(0x15728e5a, 0x8aaac42d), + TOBN(0x15d22618, 0x98fa0510), TOBN(0x3995497c, 0xea956ae5), + TOBN(0xde2bcbf6, 0x95581718), TOBN(0xb5c55df0, 0x6f4c52c9), + TOBN(0x9b2783a2, 0xec07a28f), TOBN(0xe39e772c, 0x180e8603), + TOBN(0x32905e46, 0x2e36ce3b), TOBN(0xf1746c08, 0xca18217c), + TOBN(0x670c354e, 0x4abc9804), TOBN(0x9ed52907, 0x7096966d), + TOBN(0x1c62f356, 0x208552bb), TOBN(0x83655d23, 0xdca3ad96), + TOBN(0x69163fa8, 0xfd24cf5f), TOBN(0x98da4836, 0x1c55d39a), + TOBN(0xc2007cb8, 0xa163bf05), TOBN(0x49286651, 0xece45b3d), + TOBN(0xae9f2411, 0x7c4b1fe6), TOBN(0xee386bfb, 0x5a899fa5), + TOBN(0x0bff5cb6, 0xf406b7ed), TOBN(0xf44c42e9, 0xa637ed6b), + TOBN(0xe485b576, 0x625e7ec6), TOBN(0x4fe1356d, 0x6d51c245), + TOBN(0x302b0a6d, 0xf25f1437), TOBN(0xef9519b3, 0xcd3a431b), + TOBN(0x514a0879, 0x8e3404dd), TOBN(0x020bbea6, 0x3b139b22), + TOBN(0x29024e08, 0x8a67cc74), TOBN(0xc4c6628b, 0x80dc1cd1), + TOBN(0xc90fdaa2, 0x2168c234), TOBN(0xffffffff, 0xffffffff), + }; + return get_params(ret, kWords, OPENSSL_ARRAY_SIZE(kWords)); +} diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index c3f4b3fd9893f7..2a02ae79e4e30c 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -1,6 +1,7 @@ #include "ncrypto.h" #include #include +#include #include #include #include @@ -8,6 +9,9 @@ #if OPENSSL_VERSION_MAJOR >= 3 #include #endif +#ifdef OPENSSL_IS_BORINGSSL +#include "dh-primes.h" +#endif // OPENSSL_IS_BORINGSSL namespace ncrypto { namespace { @@ -289,6 +293,11 @@ const BIGNUM* BignumPointer::One() { return BN_value_one(); } +BignumPointer BignumPointer::clone() { + if (!bn_) return {}; + return BignumPointer(BN_dup(bn_.get())); +} + // ============================================================================ // Utility methods @@ -1016,4 +1025,231 @@ int BIOPointer::Write(BIOPointer* bio, std::string_view message) { return BIO_write(bio->get(), message.data(), message.size()); } +// ============================================================================ +// DHPointer + +namespace { +bool EqualNoCase(const std::string_view a, const std::string_view b) { + if (a.size() != b.size()) return false; + return std::equal(a.begin(), a.end(), b.begin(), b.end(), + [](char a, char b) { return std::tolower(a) == std::tolower(b); }); +} +} // namespace + +DHPointer::DHPointer(DH* dh) : dh_(dh) {} + +DHPointer::DHPointer(DHPointer&& other) noexcept : dh_(other.release()) {} + +DHPointer& DHPointer::operator=(DHPointer&& other) noexcept { + if (this == &other) return *this; + this->~DHPointer(); + return *new (this) DHPointer(std::move(other)); +} + +DHPointer::~DHPointer() { reset(); } + +void DHPointer::reset(DH* dh) { dh_.reset(dh); } + +DH* DHPointer::release() { return dh_.release(); } + +BignumPointer DHPointer::FindGroup(const std::string_view name, + FindGroupOption option) { +#define V(n, p) if (EqualNoCase(name, n)) return BignumPointer(p(nullptr)); + if (option != FindGroupOption::NO_SMALL_PRIMES) { + V("modp1", BN_get_rfc2409_prime_768); + V("modp2", BN_get_rfc2409_prime_1024); + V("modp5", BN_get_rfc3526_prime_1536); + } + V("modp14", BN_get_rfc3526_prime_2048); + V("modp15", BN_get_rfc3526_prime_3072); + V("modp16", BN_get_rfc3526_prime_4096); + V("modp17", BN_get_rfc3526_prime_6144); + V("modp18", BN_get_rfc3526_prime_8192); +#undef V + return {}; +} + +BignumPointer DHPointer::GetStandardGenerator() { + auto bn = BignumPointer::New(); + if (!bn) return {}; + if (!bn.setWord(DH_GENERATOR_2)) return {}; + return bn; +} + +DHPointer DHPointer::FromGroup(const std::string_view name, + FindGroupOption option) { + auto group = FindGroup(name, option); + if (!group) return {}; // Unable to find the named group. + + auto generator = GetStandardGenerator(); + if (!generator) return {}; // Unable to create the generator. + + return New(std::move(group), std::move(generator)); +} + +DHPointer DHPointer::New(BignumPointer&& p, BignumPointer&& g) { + if (!p || !g) return {}; + + DHPointer dh(DH_new()); + if (!dh) return {}; + + if (DH_set0_pqg(dh.get(), p.get(), nullptr, g.get()) != 1) return {}; + + // If the call above is successful, the DH object takes ownership of the + // BIGNUMs, so we must release them here. + p.release(); + g.release(); + + return dh; +} + +DHPointer DHPointer::New(size_t bits, unsigned int generator) { + DHPointer dh(DH_new()); + if (!dh) return {}; + + if (DH_generate_parameters_ex(dh.get(), bits, generator, nullptr) != 1) { + return {}; + } + + return dh; +} + +DHPointer::CheckResult DHPointer::check() { + ClearErrorOnReturn clearErrorOnReturn; + if (!dh_) return DHPointer::CheckResult::NONE; + int codes = 0; + if (DH_check(dh_.get(), &codes) != 1) + return DHPointer::CheckResult::CHECK_FAILED; + return static_cast(codes); +} + +DHPointer::CheckPublicKeyResult DHPointer::checkPublicKey(const BignumPointer& pub_key) { + ClearErrorOnReturn clearErrorOnReturn; + if (!pub_key || !dh_) return DHPointer::CheckPublicKeyResult::CHECK_FAILED; + int codes = 0; + if (DH_check_pub_key(dh_.get(), pub_key.get(), &codes) != 1) + return DHPointer::CheckPublicKeyResult::CHECK_FAILED; + if (codes & DH_CHECK_PUBKEY_TOO_SMALL) { + return DHPointer::CheckPublicKeyResult::TOO_SMALL; + } else if (codes & DH_CHECK_PUBKEY_TOO_SMALL) { + return DHPointer::CheckPublicKeyResult::TOO_LARGE; + } else if (codes != 0) { + return DHPointer::CheckPublicKeyResult::INVALID; + } + return CheckPublicKeyResult::NONE; +} + +DataPointer DHPointer::getPrime() const { + if (!dh_) return {}; + const BIGNUM* p; + DH_get0_pqg(dh_.get(), &p, nullptr, nullptr); + return BignumPointer::Encode(p); +} + +DataPointer DHPointer::getGenerator() const { + if (!dh_) return {}; + const BIGNUM* g; + DH_get0_pqg(dh_.get(), nullptr, nullptr, &g); + return BignumPointer::Encode(g); +} + +DataPointer DHPointer::getPublicKey() const { + if (!dh_) return {}; + const BIGNUM* pub_key; + DH_get0_key(dh_.get(), &pub_key, nullptr); + return BignumPointer::Encode(pub_key); +} + +DataPointer DHPointer::getPrivateKey() const { + if (!dh_) return {}; + const BIGNUM* pvt_key; + DH_get0_key(dh_.get(), nullptr, &pvt_key); + return BignumPointer::Encode(pvt_key); +} + +DataPointer DHPointer::generateKeys() const { + ClearErrorOnReturn clearErrorOnReturn; + if (!dh_) return {}; + + // Key generation failed + if (!DH_generate_key(dh_.get())) return {}; + + return getPublicKey(); +} + +size_t DHPointer::size() const { + if (!dh_) return 0; + return DH_size(dh_.get()); +} + +DataPointer DHPointer::computeSecret(const BignumPointer& peer) const { + ClearErrorOnReturn clearErrorOnReturn; + if (!dh_ || !peer) return {}; + + auto dp = DataPointer::Alloc(size()); + if (!dp) return {}; + + int size = DH_compute_key(static_cast(dp.get()), peer.get(), dh_.get()); + if (size < 0) return {}; + + // The size of the computed key can be smaller than the size of the DH key. + // We want to make sure that the key is correctly padded. + if (size < dp.size()) { + const size_t padding = dp.size() - size; + uint8_t* data = static_cast(dp.get()); + memmove(data + padding, data, size); + memset(data, 0, padding); + } + + return dp; +} + +bool DHPointer::setPublicKey(BignumPointer&& key) { + if (!dh_) return false; + if (DH_set0_key(dh_.get(), key.get(), nullptr) == 1) { + key.release(); + return true; + } + return false; +} + +bool DHPointer::setPrivateKey(BignumPointer&& key) { + if (!dh_) return false; + if (DH_set0_key(dh_.get(), nullptr, key.get()) == 1) { + key.release(); + return true; + } + return false; +} + +DataPointer DHPointer::stateless(const EVPKeyPointer& ourKey, + const EVPKeyPointer& theirKey) { + size_t out_size; + if (!ourKey || !theirKey) return {}; + + EVPKeyCtxPointer ctx(EVP_PKEY_CTX_new(ourKey.get(), nullptr)); + if (!ctx || + EVP_PKEY_derive_init(ctx.get()) <= 0 || + EVP_PKEY_derive_set_peer(ctx.get(), theirKey.get()) <= 0 || + EVP_PKEY_derive(ctx.get(), nullptr, &out_size) <= 0) { + return {}; + } + + if (out_size == 0) return {}; + + auto out = DataPointer::Alloc(out_size); + if (EVP_PKEY_derive(ctx.get(), reinterpret_cast(out.get()), &out_size) <= 0) { + return {}; + } + + if (out_size < out.size()) { + const size_t padding = out.size() - out_size; + uint8_t* data = static_cast(out.get()); + memmove(data + padding, data, out_size); + memset(data, 0, padding); + } + + return out; +} + } // namespace ncrypto diff --git a/deps/ncrypto/ncrypto.gyp b/deps/ncrypto/ncrypto.gyp index cf9b7c6cdb6d2c..90ac158d7e2171 100644 --- a/deps/ncrypto/ncrypto.gyp +++ b/deps/ncrypto/ncrypto.gyp @@ -2,6 +2,7 @@ 'variables': { 'ncrypto_sources': [ 'engine.cc', + 'dh-primes.h', 'ncrypto.cc', 'ncrypto.h', ], diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index e62a99595ae2c6..9b6aecaaecd6f9 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -194,7 +194,6 @@ using DeleteFnPtr = typename FunctionDeleter::Pointer; using BignumCtxPointer = DeleteFnPtr; using CipherCtxPointer = DeleteFnPtr; -using DHPointer = DeleteFnPtr; using DSAPointer = DeleteFnPtr; using DSASigPointer = DeleteFnPtr; using ECDSASigPointer = DeleteFnPtr; @@ -354,10 +353,88 @@ class BignumPointer final { static unsigned long GetWord(const BIGNUM* bn); static const BIGNUM* One(); + BignumPointer clone(); + private: DeleteFnPtr bn_; }; +class DHPointer final { +public: + + enum class FindGroupOption { + NONE, + // There are known and documented security issues with prime groups smaller + // than 2048 bits. When the NO_SMALL_PRIMES option is set, these small prime + // groups will not be supported. + NO_SMALL_PRIMES, + }; + + static BignumPointer GetStandardGenerator(); + + static BignumPointer FindGroup(const std::string_view name, + FindGroupOption option = FindGroupOption::NONE); + static DHPointer FromGroup(const std::string_view name, + FindGroupOption option = FindGroupOption::NONE); + + static DHPointer New(BignumPointer&& p, BignumPointer&& g); + static DHPointer New(size_t bits, unsigned int generator); + + DHPointer() = default; + explicit DHPointer(DH* dh); + DHPointer(DHPointer&& other) noexcept; + DHPointer& operator=(DHPointer&& other) noexcept; + NCRYPTO_DISALLOW_COPY(DHPointer) + ~DHPointer(); + + inline bool operator==(std::nullptr_t) noexcept { return dh_ == nullptr; } + inline operator bool() const { return dh_ != nullptr; } + inline DH* get() const { return dh_.get(); } + void reset(DH* dh = nullptr); + DH* release(); + + enum class CheckResult { + NONE, + P_NOT_PRIME = DH_CHECK_P_NOT_PRIME, + P_NOT_SAFE_PRIME = DH_CHECK_P_NOT_SAFE_PRIME, + UNABLE_TO_CHECK_GENERATOR = DH_UNABLE_TO_CHECK_GENERATOR, + NOT_SUITABLE_GENERATOR = DH_NOT_SUITABLE_GENERATOR, + Q_NOT_PRIME = DH_CHECK_Q_NOT_PRIME, + INVALID_Q = DH_CHECK_INVALID_Q_VALUE, + INVALID_J = DH_CHECK_INVALID_J_VALUE, + CHECK_FAILED = 512, + }; + CheckResult check(); + + enum class CheckPublicKeyResult { + NONE, + TOO_SMALL = DH_R_CHECK_PUBKEY_TOO_SMALL, + TOO_LARGE = DH_R_CHECK_PUBKEY_TOO_LARGE, + INVALID = DH_R_CHECK_PUBKEY_INVALID, + CHECK_FAILED = 512, + }; + // Check to see if the given public key is suitable for this DH instance. + CheckPublicKeyResult checkPublicKey(const BignumPointer& pub_key); + + DataPointer getPrime() const; + DataPointer getGenerator() const; + DataPointer getPublicKey() const; + DataPointer getPrivateKey() const; + DataPointer generateKeys() const; + DataPointer computeSecret(const BignumPointer& peer) const; + + bool setPublicKey(BignumPointer&& key); + bool setPrivateKey(BignumPointer&& key); + + size_t size() const; + + static DataPointer stateless(const EVPKeyPointer& ourKey, + const EVPKeyPointer& theirKey); + +private: + DeleteFnPtr dh_; +}; + class X509Pointer; class X509View final { diff --git a/src/crypto/crypto_dh.cc b/src/crypto/crypto_dh.cc index 57dd1c0b36bb47..1203cc469413cb 100644 --- a/src/crypto/crypto_dh.cc +++ b/src/crypto/crypto_dh.cc @@ -5,27 +5,28 @@ #include "crypto/crypto_util.h" #include "env-inl.h" #include "memory_tracker-inl.h" +#include "ncrypto.h" +#include "node_errors.h" +#include "openssl/bnerr.h" +#include "openssl/dh.h" #include "threadpoolwork-inl.h" #include "v8.h" -#include - namespace node { using v8::ArrayBuffer; -using v8::BackingStore; using v8::ConstructorBehavior; using v8::Context; using v8::DontDelete; using v8::FunctionCallback; using v8::FunctionCallbackInfo; using v8::FunctionTemplate; -using v8::HandleScope; using v8::Int32; using v8::Isolate; using v8::Just; using v8::Local; using v8::Maybe; +using v8::MaybeLocal; using v8::Nothing; using v8::Object; using v8::PropertyAttribute; @@ -36,361 +37,219 @@ using v8::String; using v8::Value; namespace crypto { -namespace { -void ZeroPadDiffieHellmanSecret(size_t remainder_size, - char* data, - size_t length) { - // DH_size returns number of bytes in a prime number. - // DH_compute_key returns number of bytes in a remainder of exponent, which - // may have less bytes than a prime number. Therefore add 0-padding to the - // allocated buffer. - const size_t prime_size = length; - if (remainder_size != prime_size) { - CHECK_LT(remainder_size, prime_size); - const size_t padding = prime_size - remainder_size; - memmove(data + padding, data, remainder_size); - memset(data, 0, padding); - } -} -} // namespace - -DiffieHellman::DiffieHellman(Environment* env, Local wrap) - : BaseObject(env, wrap), verifyError_(0) { +DiffieHellman::DiffieHellman(Environment* env, Local wrap, DHPointer dh) + : BaseObject(env, wrap), dh_(std::move(dh)) { MakeWeak(); } -void DiffieHellman::Initialize(Environment* env, Local target) { - Isolate* isolate = env->isolate(); - Local context = env->context(); - auto make = [&](Local name, FunctionCallback callback) { - Local t = NewFunctionTemplate(isolate, callback); - - const PropertyAttribute attributes = - static_cast(ReadOnly | DontDelete); - - t->InstanceTemplate()->SetInternalFieldCount( - DiffieHellman::kInternalFieldCount); - - SetProtoMethod(isolate, t, "generateKeys", GenerateKeys); - SetProtoMethod(isolate, t, "computeSecret", ComputeSecret); - SetProtoMethodNoSideEffect(isolate, t, "getPrime", GetPrime); - SetProtoMethodNoSideEffect(isolate, t, "getGenerator", GetGenerator); - SetProtoMethodNoSideEffect(isolate, t, "getPublicKey", GetPublicKey); - SetProtoMethodNoSideEffect(isolate, t, "getPrivateKey", GetPrivateKey); - SetProtoMethod(isolate, t, "setPublicKey", SetPublicKey); - SetProtoMethod(isolate, t, "setPrivateKey", SetPrivateKey); - - Local verify_error_getter_templ = - FunctionTemplate::New(isolate, - DiffieHellman::VerifyErrorGetter, - Local(), - Signature::New(env->isolate(), t), - /* length */ 0, - ConstructorBehavior::kThrow, - SideEffectType::kHasNoSideEffect); - - t->InstanceTemplate()->SetAccessorProperty( - env->verify_error_string(), - verify_error_getter_templ, - Local(), - attributes); - - SetConstructorFunction(context, target, name, t); - }; - - make(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellman"), New); - make(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellmanGroup"), - DiffieHellmanGroup); - - SetMethodNoSideEffect( - context, target, "statelessDH", DiffieHellman::Stateless); - DHKeyPairGenJob::Initialize(env, target); - DHKeyExportJob::Initialize(env, target); - DHBitsJob::Initialize(env, target); -} - -void DiffieHellman::RegisterExternalReferences( - ExternalReferenceRegistry* registry) { - registry->Register(New); - registry->Register(DiffieHellmanGroup); - - registry->Register(GenerateKeys); - registry->Register(ComputeSecret); - registry->Register(GetPrime); - registry->Register(GetGenerator); - registry->Register(GetPublicKey); - registry->Register(GetPrivateKey); - registry->Register(SetPublicKey); - registry->Register(SetPrivateKey); - - registry->Register(DiffieHellman::VerifyErrorGetter); - registry->Register(DiffieHellman::Stateless); - - DHKeyPairGenJob::RegisterExternalReferences(registry); - DHKeyExportJob::RegisterExternalReferences(registry); - DHBitsJob::RegisterExternalReferences(registry); -} - -bool DiffieHellman::Init(int primeLength, int g) { - dh_.reset(DH_new()); - if (!DH_generate_parameters_ex(dh_.get(), primeLength, g, nullptr)) - return false; - return VerifyContext(); -} - void DiffieHellman::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackFieldWithSize("dh", dh_ ? kSizeOf_DH : 0); } namespace { -bool SetDhParams(DH* dh, BignumPointer* p, BignumPointer* g) { - // If DH_set0_pqg returns 0, ownership of the input parameters has - // not been transferred to the DH object. If the return value is 1, - // ownership has been transferred and we need to release them. - // The documentation for DH_set0_pqg is not clear on this point. - // It says that ownership is transfered when the method is called - // but there is an internal check that returns 0 if the input is - // not valid, and in that case ownership is not transferred. - if (DH_set0_pqg(dh, p->get(), nullptr, g->get()) == 0) return false; - p->release(); - g->release(); - return true; -} -} // namespace - -bool DiffieHellman::Init(BignumPointer&& bn_p, int g) { - dh_.reset(DH_new()); - CHECK_GE(g, 2); - auto bn_g = BignumPointer::New(); - return bn_p && bn_g.setWord(g) && SetDhParams(dh_.get(), &bn_p, &bn_g) && - VerifyContext(); -} +MaybeLocal DataPointerToBuffer(Environment* env, + ncrypto::DataPointer&& data) { + auto backing = ArrayBuffer::NewBackingStore( + data.get(), + data.size(), + [](void* data, size_t len, void* ptr) { + ncrypto::DataPointer free_ne(data, len); + }, + nullptr); + data.release(); + + auto ab = ArrayBuffer::New(env->isolate(), std::move(backing)); + return Buffer::New(env, ab, 0, ab->ByteLength()).FromMaybe(Local()); +} + +void DiffieHellmanGroup(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + CHECK_EQ(args.Length(), 1); + THROW_AND_RETURN_IF_NOT_STRING(env, args[0], "Group name"); + const node::Utf8Value group_name(env->isolate(), args[0]); -bool DiffieHellman::Init(const char* p, int p_len, int g) { - dh_.reset(DH_new()); - if (p_len <= 0) { - ERR_put_error(ERR_LIB_BN, BN_F_BN_GENERATE_PRIME_EX, - BN_R_BITS_TOO_SMALL, __FILE__, __LINE__); - return false; - } - if (g <= 1) { - ERR_put_error(ERR_LIB_DH, DH_F_DH_BUILTIN_GENPARAMS, - DH_R_BAD_GENERATOR, __FILE__, __LINE__); - return false; + DHPointer dh = DHPointer::FromGroup(group_name.ToStringView()); + if (!dh) { + return THROW_ERR_CRYPTO_UNKNOWN_DH_GROUP(env); } - BignumPointer bn_p(reinterpret_cast(p), p_len); - auto bn_g = BignumPointer::New(); - return bn_p && bn_g.setWord(g) && SetDhParams(dh_.get(), &bn_p, &bn_g) && - VerifyContext(); -} -bool DiffieHellman::Init(const char* p, int p_len, const char* g, int g_len) { - dh_.reset(DH_new()); - if (p_len <= 0) { - ERR_put_error(ERR_LIB_BN, BN_F_BN_GENERATE_PRIME_EX, - BN_R_BITS_TOO_SMALL, __FILE__, __LINE__); - return false; - } - if (g_len <= 0) { - ERR_put_error(ERR_LIB_DH, DH_F_DH_BUILTIN_GENPARAMS, - DH_R_BAD_GENERATOR, __FILE__, __LINE__); - return false; - } - BignumPointer bn_g(reinterpret_cast(g), g_len); - if (!bn_g || bn_g.isZero() || bn_g.isOne()) { - ERR_put_error(ERR_LIB_DH, DH_F_DH_BUILTIN_GENPARAMS, - DH_R_BAD_GENERATOR, __FILE__, __LINE__); - return false; - } - BignumPointer bn_p(reinterpret_cast(p), p_len); - return bn_p && SetDhParams(dh_.get(), &bn_p, &bn_g) && VerifyContext(); + new DiffieHellman(env, args.This(), std::move(dh)); } -constexpr int kStandardizedGenerator = 2; - -template -BignumPointer InstantiateStandardizedGroup() { - return BignumPointer(p(nullptr)); -} +void New(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); -typedef BignumPointer (*StandardizedGroupInstantiator)(); - -// Returns a function that can be used to create an instance of a standardized -// Diffie-Hellman group. The generator is always kStandardizedGenerator. -inline StandardizedGroupInstantiator FindDiffieHellmanGroup(const char* name) { -#define V(n, p) \ - if (StringEqualNoCase(name, n)) return InstantiateStandardizedGroup

- V("modp1", BN_get_rfc2409_prime_768); - V("modp2", BN_get_rfc2409_prime_1024); - V("modp5", BN_get_rfc3526_prime_1536); - V("modp14", BN_get_rfc3526_prime_2048); - V("modp15", BN_get_rfc3526_prime_3072); - V("modp16", BN_get_rfc3526_prime_4096); - V("modp17", BN_get_rfc3526_prime_6144); - V("modp18", BN_get_rfc3526_prime_8192); -#undef V - return nullptr; -} + if (args.Length() != 2) { + return THROW_ERR_MISSING_ARGS(env, "Constructor must have two arguments"); + } -void DiffieHellman::DiffieHellmanGroup( - const FunctionCallbackInfo& args) { - Environment* env = Environment::GetCurrent(args); - DiffieHellman* diffieHellman = new DiffieHellman(env, args.This()); + if (args[0]->IsInt32()) { + int32_t bits = args[0].As()->Value(); + if (bits < 2) { +#if OPENSSL_VERSION_MAJOR >= 3 + ERR_put_error(ERR_LIB_DH, 0, DH_R_MODULUS_TOO_SMALL, __FILE__, __LINE__); +#else + ERR_put_error(ERR_LIB_BN, 0, BN_R_BITS_TOO_SMALL, __FILE__, __LINE__); +#endif + return ThrowCryptoError(env, ERR_get_error(), "Invalid prime length"); + } - CHECK_EQ(args.Length(), 1); - THROW_AND_RETURN_IF_NOT_STRING(env, args[0], "Group name"); + // If the first argument is an Int32 then we are generating a new + // prime and then using that to generate the Diffie-Hellman parameters. + // The second argument must be an Int32 as well. + if (!args[1]->IsInt32()) { + return THROW_ERR_INVALID_ARG_TYPE(env, + "Second argument must be an int32"); + } + int32_t generator = args[1].As()->Value(); + if (generator < 2) { + ERR_put_error(ERR_LIB_DH, 0, DH_R_BAD_GENERATOR, __FILE__, __LINE__); + return ThrowCryptoError(env, ERR_get_error(), "Invalid generator"); + } - bool initialized = false; + auto dh = DHPointer::New(bits, generator); + if (!dh) { + return THROW_ERR_INVALID_ARG_VALUE(env, "Invalid DH parameters"); + } + new DiffieHellman(env, args.This(), std::move(dh)); + return; + } - const node::Utf8Value group_name(env->isolate(), args[0]); - auto group = FindDiffieHellmanGroup(*group_name); - if (group == nullptr) - return THROW_ERR_CRYPTO_UNKNOWN_DH_GROUP(env); + // The first argument must be an ArrayBuffer or ArrayBufferView with the + // prime, and the second argument must be an int32 with the generator + // or an ArrayBuffer or ArrayBufferView with the generator. - initialized = diffieHellman->Init(group(), kStandardizedGenerator); - if (!initialized) - THROW_ERR_CRYPTO_INITIALIZATION_FAILED(env); -} + ArrayBufferOrViewContents arg0(args[0]); + if (UNLIKELY(!arg0.CheckSizeInt32())) + return THROW_ERR_OUT_OF_RANGE(env, "prime is too big"); + BignumPointer bn_p(reinterpret_cast(arg0.data()), arg0.size()); + BignumPointer bn_g; + if (!bn_p) { + return THROW_ERR_INVALID_ARG_VALUE(env, "Invalid prime"); + } -void DiffieHellman::New(const FunctionCallbackInfo& args) { - Environment* env = Environment::GetCurrent(args); - DiffieHellman* diffieHellman = - new DiffieHellman(env, args.This()); - bool initialized = false; - - if (args.Length() == 2) { - if (args[0]->IsInt32()) { - if (args[1]->IsInt32()) { - initialized = diffieHellman->Init(args[0].As()->Value(), - args[1].As()->Value()); - } - } else { - ArrayBufferOrViewContents arg0(args[0]); - if (UNLIKELY(!arg0.CheckSizeInt32())) - return THROW_ERR_OUT_OF_RANGE(env, "prime is too big"); - if (args[1]->IsInt32()) { - initialized = diffieHellman->Init(arg0.data(), - arg0.size(), - args[1].As()->Value()); - } else { - ArrayBufferOrViewContents arg1(args[1]); - if (UNLIKELY(!arg1.CheckSizeInt32())) - return THROW_ERR_OUT_OF_RANGE(env, "generator is too big"); - initialized = diffieHellman->Init(arg0.data(), arg0.size(), - arg1.data(), arg1.size()); - } + if (args[1]->IsInt32()) { + int32_t generator = args[1].As()->Value(); + if (generator < 2) { + ERR_put_error(ERR_LIB_DH, 0, DH_R_BAD_GENERATOR, __FILE__, __LINE__); + return ThrowCryptoError(env, ERR_get_error(), "Invalid generator"); + } + bn_g = BignumPointer::New(); + if (!bn_g.setWord(generator)) { + ERR_put_error(ERR_LIB_DH, 0, DH_R_BAD_GENERATOR, __FILE__, __LINE__); + return ThrowCryptoError(env, ERR_get_error(), "Invalid generator"); + } + } else { + ArrayBufferOrViewContents arg1(args[1]); + if (UNLIKELY(!arg1.CheckSizeInt32())) + return THROW_ERR_OUT_OF_RANGE(env, "generator is too big"); + bn_g = BignumPointer(reinterpret_cast(arg1.data()), arg1.size()); + if (!bn_g) { + ERR_put_error(ERR_LIB_DH, 0, DH_R_BAD_GENERATOR, __FILE__, __LINE__); + return ThrowCryptoError(env, ERR_get_error(), "Invalid generator"); + } + if (bn_g.getWord() < 2) { + ERR_put_error(ERR_LIB_DH, 0, DH_R_BAD_GENERATOR, __FILE__, __LINE__); + return ThrowCryptoError(env, ERR_get_error(), "Invalid generator"); } } - if (!initialized) { - return ThrowCryptoError(env, ERR_get_error(), "Initialization failed"); + auto dh = DHPointer::New(std::move(bn_p), std::move(bn_g)); + if (!dh) { + return THROW_ERR_INVALID_ARG_VALUE(env, "Invalid DH parameters"); } + new DiffieHellman(env, args.This(), std::move(dh)); } - -void DiffieHellman::GenerateKeys(const FunctionCallbackInfo& args) { +void GenerateKeys(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - DiffieHellman* diffieHellman; ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); + DHPointer& dh = *diffieHellman; - if (!DH_generate_key(diffieHellman->dh_.get())) { - return ThrowCryptoError(env, ERR_get_error(), "Key generation failed"); + auto dp = dh.generateKeys(); + if (!dp) { + return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Key generation failed"); } - const BIGNUM* pub_key; - DH_get0_key(diffieHellman->dh_.get(), &pub_key, nullptr); - - std::unique_ptr bs; - { - const int size = BignumPointer::GetByteCount(pub_key); - CHECK_GE(size, 0); - NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data()); - bs = ArrayBuffer::NewBackingStore(env->isolate(), size); + Local buffer; + if (DataPointerToBuffer(env, std::move(dp)).ToLocal(&buffer)) { + args.GetReturnValue().Set(buffer); } +} - CHECK_EQ( - bs->ByteLength(), - BignumPointer::EncodePaddedInto( - pub_key, static_cast(bs->Data()), bs->ByteLength())); +void GetPrime(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + DiffieHellman* diffieHellman; + ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); + DHPointer& dh = *diffieHellman; - Local ab = ArrayBuffer::New(env->isolate(), std::move(bs)); + auto dp = dh.getPrime(); + if (!dp) { + return THROW_ERR_CRYPTO_INVALID_STATE(env, "p is null"); + } Local buffer; - if (!Buffer::New(env, ab, 0, ab->ByteLength()).ToLocal(&buffer)) return; - args.GetReturnValue().Set(buffer); + if (DataPointerToBuffer(env, std::move(dp)).ToLocal(&buffer)) { + args.GetReturnValue().Set(buffer); + } } - -void DiffieHellman::GetField(const FunctionCallbackInfo& args, - const BIGNUM* (*get_field)(const DH*), - const char* err_if_null) { +void GetGenerator(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); + DiffieHellman* diffieHellman; + ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); + DHPointer& dh = *diffieHellman; - DiffieHellman* dh; - ASSIGN_OR_RETURN_UNWRAP(&dh, args.This()); - - const BIGNUM* num = get_field(dh->dh_.get()); - if (num == nullptr) - return THROW_ERR_CRYPTO_INVALID_STATE(env, err_if_null); - - std::unique_ptr bs; - { - const int size = BignumPointer::GetByteCount(num); - CHECK_GE(size, 0); - NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data()); - bs = ArrayBuffer::NewBackingStore(env->isolate(), size); + auto dp = dh.getGenerator(); + if (!dp) { + return THROW_ERR_CRYPTO_INVALID_STATE(env, "g is null"); } - - CHECK_EQ(bs->ByteLength(), - BignumPointer::EncodePaddedInto( - num, static_cast(bs->Data()), bs->ByteLength())); - - Local ab = ArrayBuffer::New(env->isolate(), std::move(bs)); Local buffer; - if (!Buffer::New(env, ab, 0, ab->ByteLength()).ToLocal(&buffer)) return; - args.GetReturnValue().Set(buffer); + if (DataPointerToBuffer(env, std::move(dp)).ToLocal(&buffer)) { + args.GetReturnValue().Set(buffer); + } } -void DiffieHellman::GetPrime(const FunctionCallbackInfo& args) { - GetField(args, [](const DH* dh) -> const BIGNUM* { - const BIGNUM* p; - DH_get0_pqg(dh, &p, nullptr, nullptr); - return p; - }, "p is null"); -} +void GetPublicKey(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + DiffieHellman* diffieHellman; + ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); + DHPointer& dh = *diffieHellman; -void DiffieHellman::GetGenerator(const FunctionCallbackInfo& args) { - GetField(args, [](const DH* dh) -> const BIGNUM* { - const BIGNUM* g; - DH_get0_pqg(dh, nullptr, nullptr, &g); - return g; - }, "g is null"); + auto dp = dh.getPublicKey(); + if (!dp) { + return THROW_ERR_CRYPTO_INVALID_STATE( + env, "No public key - did you forget to generate one?"); + } + Local buffer; + if (DataPointerToBuffer(env, std::move(dp)).ToLocal(&buffer)) { + args.GetReturnValue().Set(buffer); + } } -void DiffieHellman::GetPublicKey(const FunctionCallbackInfo& args) { - GetField(args, [](const DH* dh) -> const BIGNUM* { - const BIGNUM* pub_key; - DH_get0_key(dh, &pub_key, nullptr); - return pub_key; - }, "No public key - did you forget to generate one?"); -} +void GetPrivateKey(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + DiffieHellman* diffieHellman; + ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); + DHPointer& dh = *diffieHellman; -void DiffieHellman::GetPrivateKey(const FunctionCallbackInfo& args) { - GetField(args, [](const DH* dh) -> const BIGNUM* { - const BIGNUM* priv_key; - DH_get0_key(dh, nullptr, &priv_key); - return priv_key; - }, "No private key - did you forget to generate one?"); + auto dp = dh.getPrivateKey(); + if (!dp) { + return THROW_ERR_CRYPTO_INVALID_STATE( + env, "No private key - did you forget to generate one?"); + } + Local buffer; + if (DataPointerToBuffer(env, std::move(dp)).ToLocal(&buffer)) { + args.GetReturnValue().Set(buffer); + } } -void DiffieHellman::ComputeSecret(const FunctionCallbackInfo& args) { +void ComputeSecret(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - DiffieHellman* diffieHellman; ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); - - ClearErrorOnReturn clear_error_on_return; + DHPointer& dh = *diffieHellman; CHECK_EQ(args.Length(), 1); ArrayBufferOrViewContents key_buf(args[0]); @@ -398,94 +257,73 @@ void DiffieHellman::ComputeSecret(const FunctionCallbackInfo& args) { return THROW_ERR_OUT_OF_RANGE(env, "secret is too big"); BignumPointer key(key_buf.data(), key_buf.size()); - std::unique_ptr bs; - { - NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data()); - bs = ArrayBuffer::NewBackingStore(env->isolate(), - DH_size(diffieHellman->dh_.get())); - } - - int size = DH_compute_key(static_cast(bs->Data()), - key.get(), - diffieHellman->dh_.get()); - - if (size == -1) { - int checkResult; - int checked; - - checked = DH_check_pub_key(diffieHellman->dh_.get(), - key.get(), - &checkResult); - - if (!checked) { - return ThrowCryptoError(env, ERR_get_error(), "Invalid Key"); - } else if (checkResult) { - if (checkResult & DH_CHECK_PUBKEY_TOO_SMALL) { - return THROW_ERR_CRYPTO_INVALID_KEYLEN(env, - "Supplied key is too small"); - } else if (checkResult & DH_CHECK_PUBKEY_TOO_LARGE) { - return THROW_ERR_CRYPTO_INVALID_KEYLEN(env, - "Supplied key is too large"); - } - } - - return THROW_ERR_CRYPTO_INVALID_KEYTYPE(env); + switch (dh.checkPublicKey(key)) { + case DHPointer::CheckPublicKeyResult::INVALID: + // Fall-through + case DHPointer::CheckPublicKeyResult::CHECK_FAILED: + return THROW_ERR_CRYPTO_INVALID_KEYTYPE(env, + "Unspecified validation error"); + case DHPointer::CheckPublicKeyResult::TOO_SMALL: + return THROW_ERR_CRYPTO_INVALID_KEYLEN(env, "Supplied key is too small"); + case DHPointer::CheckPublicKeyResult::TOO_LARGE: + return THROW_ERR_CRYPTO_INVALID_KEYLEN(env, "Supplied key is too large"); + case DHPointer::CheckPublicKeyResult::NONE: + break; } - CHECK_GE(size, 0); - ZeroPadDiffieHellmanSecret(size, - static_cast(bs->Data()), - bs->ByteLength()); + auto dp = dh.computeSecret(key); - Local ab = ArrayBuffer::New(env->isolate(), std::move(bs)); Local buffer; - if (!Buffer::New(env, ab, 0, ab->ByteLength()).ToLocal(&buffer)) return; - args.GetReturnValue().Set(buffer); + if (DataPointerToBuffer(env, std::move(dp)).ToLocal(&buffer)) { + args.GetReturnValue().Set(buffer); + } } -void DiffieHellman::SetKey(const FunctionCallbackInfo& args, - int (*set_field)(DH*, BIGNUM*), const char* what) { +void SetPublicKey(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - DiffieHellman* dh; - ASSIGN_OR_RETURN_UNWRAP(&dh, args.This()); + DiffieHellman* diffieHellman; + ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); + DHPointer& dh = *diffieHellman; CHECK_EQ(args.Length(), 1); ArrayBufferOrViewContents buf(args[0]); if (UNLIKELY(!buf.CheckSizeInt32())) return THROW_ERR_OUT_OF_RANGE(env, "buf is too big"); BignumPointer num(buf.data(), buf.size()); CHECK(num); - CHECK_EQ(1, set_field(dh->dh_.get(), num.release())); -} - -void DiffieHellman::SetPublicKey(const FunctionCallbackInfo& args) { - SetKey(args, - [](DH* dh, BIGNUM* num) { return DH_set0_key(dh, num, nullptr); }, - "Public key"); + CHECK(dh.setPublicKey(std::move(num))); } -void DiffieHellman::SetPrivateKey(const FunctionCallbackInfo& args) { - SetKey(args, - [](DH* dh, BIGNUM* num) { return DH_set0_key(dh, nullptr, num); }, - "Private key"); +void SetPrivateKey(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + DiffieHellman* diffieHellman; + ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); + DHPointer& dh = *diffieHellman; + CHECK_EQ(args.Length(), 1); + ArrayBufferOrViewContents buf(args[0]); + if (UNLIKELY(!buf.CheckSizeInt32())) + return THROW_ERR_OUT_OF_RANGE(env, "buf is too big"); + BignumPointer num(buf.data(), buf.size()); + CHECK(num); + CHECK(dh.setPrivateKey(std::move(num))); } -void DiffieHellman::VerifyErrorGetter(const FunctionCallbackInfo& args) { - HandleScope scope(args.GetIsolate()); - +void Check(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); DiffieHellman* diffieHellman; ASSIGN_OR_RETURN_UNWRAP(&diffieHellman, args.This()); - args.GetReturnValue().Set(diffieHellman->verifyError_); -} + DHPointer& dh = *diffieHellman; + auto result = dh.check(); + if (result == DHPointer::CheckResult::CHECK_FAILED) { + return THROW_ERR_CRYPTO_OPERATION_FAILED(env, + "Checking DH parameters failed"); + } -bool DiffieHellman::VerifyContext() { - int codes; - if (!DH_check(dh_.get(), &codes)) - return false; - verifyError_ = codes; - return true; + args.GetReturnValue().Set(static_cast(result)); } +} // namespace + // The input arguments to DhKeyPairGenJob can vary // 1. CryptoJobMode // and either @@ -509,13 +347,15 @@ Maybe DhKeyGenTraits::AdditionalConfig( if (args[*offset]->IsString()) { Utf8Value group_name(env->isolate(), args[*offset]); - auto group = FindDiffieHellmanGroup(*group_name); - if (group == nullptr) { + auto group = DHPointer::FindGroup(group_name.ToStringView()); + if (!group) { THROW_ERR_CRYPTO_UNKNOWN_DH_GROUP(env); return Nothing(); } - params->params.prime = group(); + static constexpr int kStandardizedGenerator = 2; + + params->params.prime = std::move(group); params->params.generator = kStandardizedGenerator; *offset += 1; } else { @@ -547,15 +387,13 @@ EVPKeyCtxPointer DhKeyGenTraits::Setup(DhKeyPairGenConfig* params) { EVPKeyPointer key_params; if (BignumPointer* prime_fixed_value = std::get_if(¶ms->params.prime)) { - DHPointer dh(DH_new()); - if (!dh) - return EVPKeyCtxPointer(); - + auto prime = prime_fixed_value->clone(); auto bn_g = BignumPointer::New(); - if (!bn_g.setWord(params->params.generator) || - !SetDhParams(dh.get(), prime_fixed_value, &bn_g)) { - return EVPKeyCtxPointer(); + if (!prime || !bn_g || !bn_g.setWord(params->params.generator)) { + return {}; } + auto dh = DHPointer::New(std::move(prime), std::move(bn_g)); + if (!dh) return {}; key_params = EVPKeyPointer(EVP_PKEY_new()); CHECK(key_params); @@ -572,7 +410,7 @@ EVPKeyCtxPointer DhKeyGenTraits::Setup(DhKeyPairGenConfig* params) { param_ctx.get(), params->params.generator) <= 0 || EVP_PKEY_paramgen(param_ctx.get(), &raw_params) <= 0) { - return EVPKeyCtxPointer(); + return {}; } key_params = EVPKeyPointer(raw_params); @@ -581,8 +419,7 @@ EVPKeyCtxPointer DhKeyGenTraits::Setup(DhKeyPairGenConfig* params) { } EVPKeyCtxPointer ctx(EVP_PKEY_CTX_new(key_params.get(), nullptr)); - if (!ctx || EVP_PKEY_keygen_init(ctx.get()) <= 0) - return EVPKeyCtxPointer(); + if (!ctx || EVP_PKEY_keygen_init(ctx.get()) <= 0) return {}; return ctx; } @@ -616,29 +453,15 @@ WebCryptoKeyExportStatus DHKeyExportTraits::DoExport( } namespace { -ByteSource StatelessDiffieHellmanThreadsafe( - const ManagedEVPPKey& our_key, - const ManagedEVPPKey& their_key) { - size_t out_size; - - EVPKeyCtxPointer ctx(EVP_PKEY_CTX_new(our_key.get(), nullptr)); - if (!ctx || - EVP_PKEY_derive_init(ctx.get()) <= 0 || - EVP_PKEY_derive_set_peer(ctx.get(), their_key.get()) <= 0 || - EVP_PKEY_derive(ctx.get(), nullptr, &out_size) <= 0) - return ByteSource(); - - ByteSource::Builder out(out_size); - if (EVP_PKEY_derive(ctx.get(), out.data(), &out_size) <= 0) { - return ByteSource(); - } +ByteSource StatelessDiffieHellmanThreadsafe(const ManagedEVPPKey& our_key, + const ManagedEVPPKey& their_key) { + auto dp = DHPointer::stateless(our_key.pkey(), their_key.pkey()); + if (!dp) return {}; - ZeroPadDiffieHellmanSecret(out_size, out.data(), out.size()); - return std::move(out).release(); + return ByteSource::Allocated(dp.release()); } -} // namespace -void DiffieHellman::Stateless(const FunctionCallbackInfo& args) { +void Stateless(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); CHECK(args[0]->IsObject() && args[1]->IsObject()); @@ -662,6 +485,7 @@ void DiffieHellman::Stateless(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(out); } +} // namespace Maybe DHBitsTraits::AdditionalConfig( CryptoJobMode mode, @@ -719,5 +543,75 @@ Maybe GetDhKeyDetail( return Just(true); } +void DiffieHellman::Initialize(Environment* env, Local target) { + Isolate* isolate = env->isolate(); + Local context = env->context(); + auto make = [&](Local name, FunctionCallback callback) { + Local t = NewFunctionTemplate(isolate, callback); + + const PropertyAttribute attributes = + static_cast(ReadOnly | DontDelete); + + t->InstanceTemplate()->SetInternalFieldCount( + DiffieHellman::kInternalFieldCount); + + SetProtoMethod(isolate, t, "generateKeys", GenerateKeys); + SetProtoMethod(isolate, t, "computeSecret", ComputeSecret); + SetProtoMethodNoSideEffect(isolate, t, "getPrime", GetPrime); + SetProtoMethodNoSideEffect(isolate, t, "getGenerator", GetGenerator); + SetProtoMethodNoSideEffect(isolate, t, "getPublicKey", GetPublicKey); + SetProtoMethodNoSideEffect(isolate, t, "getPrivateKey", GetPrivateKey); + SetProtoMethod(isolate, t, "setPublicKey", SetPublicKey); + SetProtoMethod(isolate, t, "setPrivateKey", SetPrivateKey); + + Local verify_error_getter_templ = + FunctionTemplate::New(isolate, + Check, + Local(), + Signature::New(env->isolate(), t), + /* length */ 0, + ConstructorBehavior::kThrow, + SideEffectType::kHasNoSideEffect); + + t->InstanceTemplate()->SetAccessorProperty(env->verify_error_string(), + verify_error_getter_templ, + Local(), + attributes); + + SetConstructorFunction(context, target, name, t); + }; + + make(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellman"), New); + make(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellmanGroup"), + DiffieHellmanGroup); + + SetMethodNoSideEffect(context, target, "statelessDH", Stateless); + DHKeyPairGenJob::Initialize(env, target); + DHKeyExportJob::Initialize(env, target); + DHBitsJob::Initialize(env, target); +} + +void DiffieHellman::RegisterExternalReferences( + ExternalReferenceRegistry* registry) { + registry->Register(New); + registry->Register(DiffieHellmanGroup); + + registry->Register(GenerateKeys); + registry->Register(ComputeSecret); + registry->Register(GetPrime); + registry->Register(GetGenerator); + registry->Register(GetPublicKey); + registry->Register(GetPrivateKey); + registry->Register(SetPublicKey); + registry->Register(SetPrivateKey); + + registry->Register(Check); + registry->Register(Stateless); + + DHKeyPairGenJob::RegisterExternalReferences(registry); + DHKeyExportJob::RegisterExternalReferences(registry); + DHBitsJob::RegisterExternalReferences(registry); +} + } // namespace crypto } // namespace node diff --git a/src/crypto/crypto_dh.h b/src/crypto/crypto_dh.h index ec12548dbe57d5..b2df7ca7bb53c0 100644 --- a/src/crypto/crypto_dh.h +++ b/src/crypto/crypto_dh.h @@ -14,48 +14,19 @@ namespace node { namespace crypto { -class DiffieHellman : public BaseObject { +class DiffieHellman final : public BaseObject { public: static void Initialize(Environment* env, v8::Local target); static void RegisterExternalReferences(ExternalReferenceRegistry* registry); - bool Init(int primeLength, int g); - bool Init(BignumPointer&& bn_p, int g); - bool Init(const char* p, int p_len, int g); - bool Init(const char* p, int p_len, const char* g, int g_len); - - static void Stateless(const v8::FunctionCallbackInfo& args); - - protected: - static void DiffieHellmanGroup( - const v8::FunctionCallbackInfo& args); - static void New(const v8::FunctionCallbackInfo& args); - static void GenerateKeys(const v8::FunctionCallbackInfo& args); - static void GetPrime(const v8::FunctionCallbackInfo& args); - static void GetGenerator(const v8::FunctionCallbackInfo& args); - static void GetPublicKey(const v8::FunctionCallbackInfo& args); - static void GetPrivateKey(const v8::FunctionCallbackInfo& args); - static void ComputeSecret(const v8::FunctionCallbackInfo& args); - static void SetPublicKey(const v8::FunctionCallbackInfo& args); - static void SetPrivateKey(const v8::FunctionCallbackInfo& args); - static void VerifyErrorGetter( - const v8::FunctionCallbackInfo& args); - - DiffieHellman(Environment* env, v8::Local wrap); + DiffieHellman(Environment* env, v8::Local wrap, DHPointer dh); + operator DHPointer&() { return dh_; } void MemoryInfo(MemoryTracker* tracker) const override; SET_MEMORY_INFO_NAME(DiffieHellman) SET_SELF_SIZE(DiffieHellman) private: - static void GetField(const v8::FunctionCallbackInfo& args, - const BIGNUM* (*get_field)(const DH*), - const char* err_if_null); - static void SetKey(const v8::FunctionCallbackInfo& args, - int (*set_field)(DH*, BIGNUM*), const char* what); - bool VerifyContext(); - - int verifyError_; DHPointer dh_; }; diff --git a/test/parallel/test-crypto-dh.js b/test/parallel/test-crypto-dh.js index 8ae0a002fec094..9ebe14011eed22 100644 --- a/test/parallel/test-crypto-dh.js +++ b/test/parallel/test-crypto-dh.js @@ -92,7 +92,7 @@ const crypto = require('crypto'); assert.throws(() => { dh3.computeSecret(''); }, { message: common.hasOpenSSL3 && !hasOpenSSL3WithNewErrorMessage ? - 'error:02800080:Diffie-Hellman routines::invalid secret' : + 'Unspecified validation error' : 'Supplied key is too small' }); } } From 3cf645768e15ca9690f3417add3a82b82234b089 Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Fri, 23 Aug 2024 10:00:39 +0200 Subject: [PATCH 52/90] module: use amaro default transform values PR-URL: https://github.com/nodejs/node/pull/54517 Fixes: https://github.com/nodejs/node/issues/54514 Reviewed-By: Benjamin Gruenbaum Reviewed-By: Paolo Insogna --- lib/internal/modules/helpers.js | 4 ---- test/es-module/test-typescript-transform.mjs | 12 ++++++++++++ test/fixtures/typescript/cts/test-import-require.cts | 5 +++++ 3 files changed, 17 insertions(+), 4 deletions(-) create mode 100644 test/fixtures/typescript/cts/test-import-require.cts diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js index 729a33e04f34cd..c4cf82fe49f349 100644 --- a/lib/internal/modules/helpers.js +++ b/lib/internal/modules/helpers.js @@ -359,10 +359,6 @@ function stripTypeScriptTypes(source, filename) { mode: typeScriptParsingMode, sourceMap: sourceMapEnabled, filename, - // Transform option is only applied in transform mode. - transform: { - verbatimModuleSyntax: true, - }, }; const { code, map } = parse(source, options); if (map) { diff --git a/test/es-module/test-typescript-transform.mjs b/test/es-module/test-typescript-transform.mjs index 85a5cf96f3cc02..06faa3ddfcf932 100644 --- a/test/es-module/test-typescript-transform.mjs +++ b/test/es-module/test-typescript-transform.mjs @@ -114,3 +114,15 @@ test('execute a transpiled JavaScript file', async () => { strictEqual(result.stdout, ''); strictEqual(result.code, 1); }); + +test('execute TypeScript file with import = require', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-transform-types', + '--no-warnings', + fixtures.path('typescript/cts/test-import-require.cts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); diff --git a/test/fixtures/typescript/cts/test-import-require.cts b/test/fixtures/typescript/cts/test-import-require.cts new file mode 100644 index 00000000000000..2d21a9c6ec3d66 --- /dev/null +++ b/test/fixtures/typescript/cts/test-import-require.cts @@ -0,0 +1,5 @@ +import util = require("node:util"); + +const foo: string = "Hello, TypeScript!"; + +console.log(util.styleText(["red"], foo)); From 8ffdd1e2b29d2470a616bfecbf8038d67cf7d423 Mon Sep 17 00:00:00 2001 From: Yagiz Nizipli Date: Tue, 27 Aug 2024 10:58:36 -0400 Subject: [PATCH 53/90] zlib: simplify validators PR-URL: https://github.com/nodejs/node/pull/54442 Reviewed-By: James M Snell --- lib/internal/validators.js | 43 ++++++++++++++++++++++++++++++++++ lib/zlib.js | 48 +++----------------------------------- 2 files changed, 46 insertions(+), 45 deletions(-) diff --git a/lib/internal/validators.js b/lib/internal/validators.js index 298eab9bbdba2f..9798e0b5fe353c 100644 --- a/lib/internal/validators.js +++ b/lib/internal/validators.js @@ -7,6 +7,7 @@ const { ArrayPrototypeIncludes, ArrayPrototypeJoin, ArrayPrototypeMap, + NumberIsFinite, NumberIsInteger, NumberIsNaN, NumberMAX_SAFE_INTEGER, @@ -567,6 +568,46 @@ const validateLinkHeaderValue = hideStackFrames((hints) => { ); }); +// 1. Returns false for undefined and NaN +// 2. Returns true for finite numbers +// 3. Throws ERR_INVALID_ARG_TYPE for non-numbers +// 4. Throws ERR_OUT_OF_RANGE for infinite numbers +const validateFiniteNumber = hideStackFrames((number, name) => { + // Common case + if (number === undefined) { + return false; + } + + if (NumberIsFinite(number)) { + return true; // Is a valid number + } + + if (NumberIsNaN(number)) { + return false; + } + + validateNumber(number, name); + + // Infinite numbers + throw new ERR_OUT_OF_RANGE(name, 'a finite number', number); +}); + +// 1. Returns def for number when it's undefined or NaN +// 2. Returns number for finite numbers >= lower and <= upper +// 3. Throws ERR_INVALID_ARG_TYPE for non-numbers +// 4. Throws ERR_OUT_OF_RANGE for infinite numbers or numbers > upper or < lower +const checkRangesOrGetDefault = hideStackFrames( + (number, name, lower, upper, def) => { + if (!validateFiniteNumber(number, name)) { + return def; + } + if (number < lower || number > upper) { + throw new ERR_OUT_OF_RANGE(name, `>= ${lower} and <= ${upper}`, number); + } + return number; + }, +); + module.exports = { isInt32, isUint32, @@ -601,4 +642,6 @@ module.exports = { validateAbortSignal, validateLinkHeaderValue, validateInternalField, + validateFiniteNumber, + checkRangesOrGetDefault, }; diff --git a/lib/zlib.js b/lib/zlib.js index 1a00ea59b484a6..a2c092f1037261 100644 --- a/lib/zlib.js +++ b/lib/zlib.js @@ -28,7 +28,6 @@ const { ArrayPrototypePush, FunctionPrototypeBind, MathMaxApply, - NumberIsFinite, NumberIsNaN, ObjectDefineProperties, ObjectDefineProperty, @@ -51,7 +50,6 @@ const { ERR_ZLIB_INITIALIZATION_FAILED, }, genericNodeError, - hideStackFrames, } = require('internal/errors'); const { Transform, finished } = require('stream'); const { @@ -71,9 +69,10 @@ const { } = require('buffer'); const { owner_symbol } = require('internal/async_hooks').symbols; const { + checkRangesOrGetDefault, validateFunction, - validateNumber, validateUint32, + validateFiniteNumber, } = require('internal/validators'); const kFlushFlag = Symbol('kFlushFlag'); @@ -195,47 +194,6 @@ function zlibOnError(message, errno, code) { self[kError] = error; } -// 1. Returns false for undefined and NaN -// 2. Returns true for finite numbers -// 3. Throws ERR_INVALID_ARG_TYPE for non-numbers -// 4. Throws ERR_OUT_OF_RANGE for infinite numbers -const checkFiniteNumber = hideStackFrames((number, name) => { - // Common case - if (number === undefined) { - return false; - } - - if (NumberIsFinite(number)) { - return true; // Is a valid number - } - - if (NumberIsNaN(number)) { - return false; - } - - validateNumber.withoutStackTrace(number, name); - - // Infinite numbers - throw new ERR_OUT_OF_RANGE.HideStackFramesError(name, 'a finite number', number); -}); - -// 1. Returns def for number when it's undefined or NaN -// 2. Returns number for finite numbers >= lower and <= upper -// 3. Throws ERR_INVALID_ARG_TYPE for non-numbers -// 4. Throws ERR_OUT_OF_RANGE for infinite numbers or numbers > upper or < lower -const checkRangesOrGetDefault = hideStackFrames( - (number, name, lower, upper, def) => { - if (!checkFiniteNumber.withoutStackTrace(number, name)) { - return def; - } - if (number < lower || number > upper) { - throw new ERR_OUT_OF_RANGE.HideStackFramesError(name, - `>= ${lower} and <= ${upper}`, number); - } - return number; - }, -); - const FLUSH_BOUND = [ [ Z_NO_FLUSH, Z_BLOCK ], [ BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_EMIT_METADATA ], @@ -261,7 +219,7 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) { if (opts) { chunkSize = opts.chunkSize; - if (!checkFiniteNumber(chunkSize, 'options.chunkSize')) { + if (!validateFiniteNumber(chunkSize, 'options.chunkSize')) { chunkSize = Z_DEFAULT_CHUNK; } else if (chunkSize < Z_MIN_CHUNK) { throw new ERR_OUT_OF_RANGE('options.chunkSize', From fc57beaad396859be4faa0074e3a431e297b422d Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Tue, 27 Aug 2024 17:48:43 +0200 Subject: [PATCH 54/90] doc: add note about shasum generation failure MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PR-URL: https://github.com/nodejs/node/pull/54487 Reviewed-By: Ulises Gascón Reviewed-By: Benjamin Gruenbaum Reviewed-By: Luigi Pinca Reviewed-By: James M Snell --- doc/contributing/releases.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/doc/contributing/releases.md b/doc/contributing/releases.md index b1116de86f8599..0160d94fea5a61 100644 --- a/doc/contributing/releases.md +++ b/doc/contributing/releases.md @@ -944,6 +944,13 @@ a `NODEJS_RELEASE_HOST` environment variable: NODEJS_RELEASE_HOST=proxy.xyz ./tools/release.sh ``` +> \[!TIP] +> Sometimes, due to machines being overloaded or other external factors, +> the files at , +> or `SHASUMS256.txt` may not be generated correctly. +> In this case you can repeat the signing step in order +> to fix it. e.g: `./tools/release.sh -s`. + `tools/release.sh` will perform the following actions when run:
From a9ce2b6a28651dad7a4ae276c1add100be3ec03d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vinicius=20Louren=C3=A7o?= <12551007+H4ad@users.noreply.github.com> Date: Tue, 27 Aug 2024 13:20:35 -0300 Subject: [PATCH 55/90] lib: fix emit warning for debuglog.time when disabled PR-URL: https://github.com/nodejs/node/pull/54275 Reviewed-By: James M Snell Reviewed-By: Joyee Cheung Reviewed-By: Rafael Gonzaga --- lib/internal/util/debuglog.js | 15 +++++++-------- test/fixtures/GH-54265/dep1.js | 4 ++++ test/fixtures/GH-54265/dep2.js | 3 +++ test/fixtures/GH-54265/index.js | 10 ++++++++++ test/fixtures/GH-54265/require-hook.js | 9 +++++++++ test/parallel/test-module-print-timing.mjs | 17 +++++++++++++++++ 6 files changed, 50 insertions(+), 8 deletions(-) create mode 100644 test/fixtures/GH-54265/dep1.js create mode 100644 test/fixtures/GH-54265/dep2.js create mode 100644 test/fixtures/GH-54265/index.js create mode 100644 test/fixtures/GH-54265/require-hook.js diff --git a/lib/internal/util/debuglog.js b/lib/internal/util/debuglog.js index 87d19dcc843170..0ffb79041641ac 100644 --- a/lib/internal/util/debuglog.js +++ b/lib/internal/util/debuglog.js @@ -133,6 +133,7 @@ function pad(value) { const kNone = 1 << 0; const kSkipLog = 1 << 1; const kSkipTrace = 1 << 2; +const kShouldSkipAll = kSkipLog | kSkipTrace; const kSecond = 1000; const kMinute = 60 * kSecond; @@ -377,8 +378,6 @@ function debugWithTimer(set, cb) { let debugLogCategoryEnabled = false; let timerFlags = kNone; - const skipAll = kSkipLog | kSkipTrace; - function ensureTimerFlagsAreUpdated() { timerFlags &= ~kSkipTrace; @@ -393,7 +392,7 @@ function debugWithTimer(set, cb) { function internalStartTimer(logLabel, traceLabel) { ensureTimerFlagsAreUpdated(); - if (timerFlags === skipAll) { + if ((timerFlags & kShouldSkipAll) === kShouldSkipAll) { return; } @@ -413,7 +412,7 @@ function debugWithTimer(set, cb) { function internalEndTimer(logLabel, traceLabel) { ensureTimerFlagsAreUpdated(); - if (timerFlags === skipAll) { + if ((timerFlags & kShouldSkipAll) === kShouldSkipAll) { return; } @@ -434,7 +433,7 @@ function debugWithTimer(set, cb) { function internalLogTimer(logLabel, traceLabel, args) { ensureTimerFlagsAreUpdated(); - if (timerFlags === skipAll) { + if ((timerFlags & kShouldSkipAll) === kShouldSkipAll) { return; } @@ -477,7 +476,7 @@ function debugWithTimer(set, cb) { const startTimer = (logLabel, traceLabel) => { init(); - if (timerFlags !== skipAll) + if ((timerFlags & kShouldSkipAll) !== kShouldSkipAll) internalStartTimer(logLabel, traceLabel); }; @@ -487,7 +486,7 @@ function debugWithTimer(set, cb) { const endTimer = (logLabel, traceLabel) => { init(); - if (timerFlags !== skipAll) + if ((timerFlags & kShouldSkipAll) !== kShouldSkipAll) internalEndTimer(logLabel, traceLabel); }; @@ -497,7 +496,7 @@ function debugWithTimer(set, cb) { const logTimer = (logLabel, traceLabel, args) => { init(); - if (timerFlags !== skipAll) + if ((timerFlags & kShouldSkipAll) !== kShouldSkipAll) internalLogTimer(logLabel, traceLabel, args); }; diff --git a/test/fixtures/GH-54265/dep1.js b/test/fixtures/GH-54265/dep1.js new file mode 100644 index 00000000000000..42464d01ec18a1 --- /dev/null +++ b/test/fixtures/GH-54265/dep1.js @@ -0,0 +1,4 @@ +// dep1.js +module.exports = function requireDep2() { + require("./dep2.js"); +}; diff --git a/test/fixtures/GH-54265/dep2.js b/test/fixtures/GH-54265/dep2.js new file mode 100644 index 00000000000000..59c017990f8999 --- /dev/null +++ b/test/fixtures/GH-54265/dep2.js @@ -0,0 +1,3 @@ +// dep2.js + +// (empty) diff --git a/test/fixtures/GH-54265/index.js b/test/fixtures/GH-54265/index.js new file mode 100644 index 00000000000000..9caef6b88cb9dc --- /dev/null +++ b/test/fixtures/GH-54265/index.js @@ -0,0 +1,10 @@ +// index.js +const Module = require("module"); +const requireDep2 = require("./dep1.js"); + +const globalCache = Module._cache; +Module._cache = Object.create(null); +require("./require-hook.js"); +Module._cache = globalCache; + +requireDep2(); diff --git a/test/fixtures/GH-54265/require-hook.js b/test/fixtures/GH-54265/require-hook.js new file mode 100644 index 00000000000000..e94a2b6261dab0 --- /dev/null +++ b/test/fixtures/GH-54265/require-hook.js @@ -0,0 +1,9 @@ +// require-hook.js +const Module = require("module"); +const requireDep2 = require("./dep1.js"); + +const originalJSLoader = Module._extensions[".js"]; +Module._extensions[".js"] = function customJSLoader(module, filename) { + requireDep2(); + return originalJSLoader(module, filename); +}; diff --git a/test/parallel/test-module-print-timing.mjs b/test/parallel/test-module-print-timing.mjs index 124ac5e2763e8c..01f715482e7ccd 100644 --- a/test/parallel/test-module-print-timing.mjs +++ b/test/parallel/test-module-print-timing.mjs @@ -4,6 +4,7 @@ import { readFile } from 'node:fs/promises'; import { it } from 'node:test'; import tmpdir from '../common/tmpdir.js'; import { spawnSyncAndAssert } from '../common/child_process.js'; +import fixtures from '../common/fixtures.js'; tmpdir.refresh(); @@ -153,3 +154,19 @@ it('should support enable tracing dynamically', async () => { const vmTraces = outputFileJson.filter((trace) => trace.name === "require('vm')"); assert.strictEqual(vmTraces.length, 0); }); + +it('should not print when is disabled and found duplicated labels (GH-54265)', () => { + const testFile = fixtures.path('GH-54265/index.js'); + + spawnSyncAndAssert(process.execPath, [ + testFile, + ], { + cwd: tmpdir.path, + env: { + ...process.env, + }, + }, { + stdout: '', + stderr: '', + }); +}); From c3dc83befc6fb34d6eece86d94aedd635def083c Mon Sep 17 00:00:00 2001 From: Michael Dawson Date: Thu, 22 Aug 2024 19:35:18 +0000 Subject: [PATCH 56/90] doc: support collaborators - talk amplification MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - document that we support collaborators by amplifying their talks Signed-off-by: Michael Dawson PR-URL: https://github.com/nodejs/node/pull/54508 Reviewed-By: Yagiz Nizipli Reviewed-By: Tobias Nießen Reviewed-By: Matteo Collina Reviewed-By: Rafael Gonzaga Reviewed-By: Ulises Gascón Reviewed-By: Luigi Pinca Reviewed-By: Moshe Atlow Reviewed-By: James M Snell --- doc/contributing/recognizing-contributors.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/doc/contributing/recognizing-contributors.md b/doc/contributing/recognizing-contributors.md index c825af5d1a3cf7..280072bc0cdf9b 100644 --- a/doc/contributing/recognizing-contributors.md +++ b/doc/contributing/recognizing-contributors.md @@ -40,6 +40,16 @@ includes (in alphabetical order): * [Polar](https://polar.sh/) * [thanks.dev](https://thanks.dev) +## Amplification of posts announcing talks by collaborators + +When a collaborator is speaking at a public event they may request amplification +by the Node.js social media accounts. They can request that a post highlighting +that they are speaking at the event be amplified by the Node.js accounts by +making a request in the #nodejs-social channel in the OpenJS Foundation slack. +We trust that collaborators will only request amplification when they believe +the event is revelant to the Node.js community and the content of the post is +in line with the norms of the project. + ## Bi-monthly contributor spotlight The contributor spotlight program showcases individual(s) or teams who have From 33a6b3c7a9a7b6ba08e99bd2ca948ee3e34dda33 Mon Sep 17 00:00:00 2001 From: Stefan Stojanovic Date: Tue, 27 Aug 2024 20:44:05 +0200 Subject: [PATCH 57/90] deps: backport ICU-22787 to fix ClangCL on Windows - Floating patch for ICU 75.x ICU Bug: https://unicode-org.atlassian.net/browse/ICU-22787 Backport of: https://github.com/unicode-org/icu/pull/3023 PR-URL: https://github.com/nodejs/node/pull/54502 Reviewed-By: Steven R Loomis Reviewed-By: Richard Lau --- .../75/source/common/unicode/platform.h | 849 ++++++ .../75/source/tools/genccode/genccode.c | 226 ++ .../75/source/tools/genccode/pkg_genc.h | 111 + .../75/source/tools/pkgdata/pkgdata.cpp | 2292 +++++++++++++++++ .../75/source/tools/toolutil/pkg_genc.cpp | 1428 ++++++++++ .../75/source/tools/toolutil/pkg_genc.h | 111 + 6 files changed, 5017 insertions(+) create mode 100644 tools/icu/patches/75/source/common/unicode/platform.h create mode 100644 tools/icu/patches/75/source/tools/genccode/genccode.c create mode 100644 tools/icu/patches/75/source/tools/genccode/pkg_genc.h create mode 100644 tools/icu/patches/75/source/tools/pkgdata/pkgdata.cpp create mode 100644 tools/icu/patches/75/source/tools/toolutil/pkg_genc.cpp create mode 100644 tools/icu/patches/75/source/tools/toolutil/pkg_genc.h diff --git a/tools/icu/patches/75/source/common/unicode/platform.h b/tools/icu/patches/75/source/common/unicode/platform.h new file mode 100644 index 00000000000000..59176005f334b1 --- /dev/null +++ b/tools/icu/patches/75/source/common/unicode/platform.h @@ -0,0 +1,849 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* +****************************************************************************** +* +* Copyright (C) 1997-2016, International Business Machines +* Corporation and others. All Rights Reserved. +* +****************************************************************************** +* +* FILE NAME : platform.h +* +* Date Name Description +* 05/13/98 nos Creation (content moved here from ptypes.h). +* 03/02/99 stephen Added AS400 support. +* 03/30/99 stephen Added Linux support. +* 04/13/99 stephen Reworked for autoconf. +****************************************************************************** +*/ + +#ifndef _PLATFORM_H +#define _PLATFORM_H + +#include "unicode/uconfig.h" +#include "unicode/uvernum.h" + +/** + * \file + * \brief Basic types for the platform. + * + * This file used to be generated by autoconf/configure. + * Starting with ICU 49, platform.h is a normal source file, + * to simplify cross-compiling and working with non-autoconf/make build systems. + * + * When a value in this file does not work on a platform, then please + * try to derive it from the U_PLATFORM value + * (for which we might need a new value constant in rare cases) + * and/or from other macros that are predefined by the compiler + * or defined in standard (POSIX or platform or compiler) headers. + * + * As a temporary workaround, you can add an explicit \#define for some macros + * before it is first tested, or add an equivalent -D macro definition + * to the compiler's command line. + * + * Note: Some compilers provide ways to show the predefined macros. + * For example, with gcc you can compile an empty .c file and have the compiler + * print the predefined macros with + * \code + * gcc -E -dM -x c /dev/null | sort + * \endcode + * (You can provide an actual empty .c file rather than /dev/null. + * -x c++ is for C++.) + */ + +/** + * Define some things so that they can be documented. + * @internal + */ +#ifdef U_IN_DOXYGEN +/* + * Problem: "platform.h:335: warning: documentation for unknown define U_HAVE_STD_STRING found." means that U_HAVE_STD_STRING is not documented. + * Solution: #define any defines for non @internal API here, so that they are visible in the docs. If you just set PREDEFINED in Doxyfile.in, they won't be documented. + */ + +/* None for now. */ +#endif + +/** + * \def U_PLATFORM + * The U_PLATFORM macro defines the platform we're on. + * + * We used to define one different, value-less macro per platform. + * That made it hard to know the set of relevant platforms and macros, + * and hard to deal with variants of platforms. + * + * Starting with ICU 49, we define platforms as numeric macros, + * with ranges of values for related platforms and their variants. + * The U_PLATFORM macro is set to one of these values. + * + * Historical note from the Solaris Wikipedia article: + * AT&T and Sun collaborated on a project to merge the most popular Unix variants + * on the market at that time: BSD, System V, and Xenix. + * This became Unix System V Release 4 (SVR4). + * + * @internal + */ + +/** Unknown platform. @internal */ +#define U_PF_UNKNOWN 0 +/** Windows @internal */ +#define U_PF_WINDOWS 1000 +/** MinGW. Windows, calls to Win32 API, but using GNU gcc and binutils. @internal */ +#define U_PF_MINGW 1800 +/** + * Cygwin. Windows, calls to cygwin1.dll for Posix functions, + * using MSVC or GNU gcc and binutils. + * @internal + */ +#define U_PF_CYGWIN 1900 +/* Reserve 2000 for U_PF_UNIX? */ +/** HP-UX is based on UNIX System V. @internal */ +#define U_PF_HPUX 2100 +/** Solaris is a Unix operating system based on SVR4. @internal */ +#define U_PF_SOLARIS 2600 +/** BSD is a UNIX operating system derivative. @internal */ +#define U_PF_BSD 3000 +/** AIX is based on UNIX System V Releases and 4.3 BSD. @internal */ +#define U_PF_AIX 3100 +/** IRIX is based on UNIX System V with BSD extensions. @internal */ +#define U_PF_IRIX 3200 +/** + * Darwin is a POSIX-compliant operating system, composed of code developed by Apple, + * as well as code derived from NeXTSTEP, BSD, and other projects, + * built around the Mach kernel. + * Darwin forms the core set of components upon which Mac OS X, Apple TV, and iOS are based. + * (Original description modified from WikiPedia.) + * @internal + */ +#define U_PF_DARWIN 3500 +/** iPhone OS (iOS) is a derivative of Mac OS X. @internal */ +#define U_PF_IPHONE 3550 +/** QNX is a commercial Unix-like real-time operating system related to BSD. @internal */ +#define U_PF_QNX 3700 +/** Linux is a Unix-like operating system. @internal */ +#define U_PF_LINUX 4000 +/** + * Native Client is pretty close to Linux. + * See https://developer.chrome.com/native-client and + * http://www.chromium.org/nativeclient + * @internal + */ +#define U_PF_BROWSER_NATIVE_CLIENT 4020 +/** Android is based on Linux. @internal */ +#define U_PF_ANDROID 4050 +/** Fuchsia is a POSIX-ish platform. @internal */ +#define U_PF_FUCHSIA 4100 +/* Maximum value for Linux-based platform is 4499 */ +/** + * Emscripten is a C++ transpiler for the Web that can target asm.js or + * WebAssembly. It provides some POSIX-compatible wrappers and stubs and + * some Linux-like functionality, but is not fully compatible with + * either. + * @internal + */ +#define U_PF_EMSCRIPTEN 5010 +/** z/OS is the successor to OS/390 which was the successor to MVS. @internal */ +#define U_PF_OS390 9000 +/** "IBM i" is the current name of what used to be i5/OS and earlier OS/400. @internal */ +#define U_PF_OS400 9400 + +#ifdef U_PLATFORM + /* Use the predefined value. */ +#elif defined(__MINGW32__) +# define U_PLATFORM U_PF_MINGW +#elif defined(__CYGWIN__) +# define U_PLATFORM U_PF_CYGWIN +#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) +# define U_PLATFORM U_PF_WINDOWS +#elif defined(__ANDROID__) +# define U_PLATFORM U_PF_ANDROID + /* Android wchar_t support depends on the API level. */ +# include +#elif defined(__pnacl__) || defined(__native_client__) +# define U_PLATFORM U_PF_BROWSER_NATIVE_CLIENT +#elif defined(__Fuchsia__) +# define U_PLATFORM U_PF_FUCHSIA +#elif defined(linux) || defined(__linux__) || defined(__linux) +# define U_PLATFORM U_PF_LINUX +#elif defined(__APPLE__) && defined(__MACH__) +# include +# if (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) && (defined(TARGET_OS_MACCATALYST) && !TARGET_OS_MACCATALYST) /* variant of TARGET_OS_MAC */ +# define U_PLATFORM U_PF_IPHONE +# else +# define U_PLATFORM U_PF_DARWIN +# endif +#elif defined(BSD) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__MirBSD__) +# if defined(__FreeBSD__) +# include +# endif +# define U_PLATFORM U_PF_BSD +#elif defined(sun) || defined(__sun) + /* Check defined(__SVR4) || defined(__svr4__) to distinguish Solaris from SunOS? */ +# define U_PLATFORM U_PF_SOLARIS +# if defined(__GNUC__) + /* Solaris/GCC needs this header file to get the proper endianness. Normally, this + * header file is included with stddef.h but on Solairs/GCC, the GCC version of stddef.h + * is included which does not include this header file. + */ +# include +# endif +#elif defined(_AIX) || defined(__TOS_AIX__) +# define U_PLATFORM U_PF_AIX +#elif defined(_hpux) || defined(hpux) || defined(__hpux) +# define U_PLATFORM U_PF_HPUX +#elif defined(sgi) || defined(__sgi) +# define U_PLATFORM U_PF_IRIX +#elif defined(__QNX__) || defined(__QNXNTO__) +# define U_PLATFORM U_PF_QNX +#elif defined(__TOS_MVS__) +# define U_PLATFORM U_PF_OS390 +#elif defined(__OS400__) || defined(__TOS_OS400__) +# define U_PLATFORM U_PF_OS400 +#elif defined(__EMSCRIPTEN__) +# define U_PLATFORM U_PF_EMSCRIPTEN +#else +# define U_PLATFORM U_PF_UNKNOWN +#endif + +/** + * \def U_REAL_MSVC + * Defined if the compiler is the real MSVC compiler (and not something like + * Clang setting _MSC_VER in order to compile Windows code that requires it). + * Otherwise undefined. + * @internal + */ +#if (defined(_MSC_VER) && !(defined(__clang__) && __clang__)) || defined(U_IN_DOXYGEN) +# define U_REAL_MSVC +#endif + +/** + * \def CYGWINMSVC + * Defined if this is Windows with Cygwin, but using MSVC rather than gcc. + * Otherwise undefined. + * @internal + */ +/* Commented out because this is already set in mh-cygwin-msvc +#if U_PLATFORM == U_PF_CYGWIN && defined(_MSC_VER) +# define CYGWINMSVC +#endif +*/ +#ifdef U_IN_DOXYGEN +# define CYGWINMSVC +#endif + +/** + * \def U_PLATFORM_USES_ONLY_WIN32_API + * Defines whether the platform uses only the Win32 API. + * Set to 1 for Windows/MSVC, ClangCL and MinGW but not Cygwin. + * @internal + */ +#ifdef U_PLATFORM_USES_ONLY_WIN32_API + /* Use the predefined value. */ +#elif (U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_MINGW) || defined(CYGWINMSVC) +# define U_PLATFORM_USES_ONLY_WIN32_API 1 +#else + /* Cygwin implements POSIX. */ +# define U_PLATFORM_USES_ONLY_WIN32_API 0 +#endif + +/** + * \def U_PLATFORM_HAS_WIN32_API + * Defines whether the Win32 API is available on the platform. + * Set to 1 for Windows/MSVC, ClangCL, MinGW and Cygwin. + * @internal + */ +#ifdef U_PLATFORM_HAS_WIN32_API + /* Use the predefined value. */ +#elif U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN +# define U_PLATFORM_HAS_WIN32_API 1 +#else +# define U_PLATFORM_HAS_WIN32_API 0 +#endif + +/** + * \def U_PLATFORM_HAS_WINUWP_API + * Defines whether target is intended for Universal Windows Platform API + * Set to 1 for Windows10 Release Solution Configuration + * @internal + */ +#ifdef U_PLATFORM_HAS_WINUWP_API + /* Use the predefined value. */ +#else +# define U_PLATFORM_HAS_WINUWP_API 0 +#endif + +/** + * \def U_PLATFORM_IMPLEMENTS_POSIX + * Defines whether the platform implements (most of) the POSIX API. + * Set to 1 for Cygwin and most other platforms. + * @internal + */ +#ifdef U_PLATFORM_IMPLEMENTS_POSIX + /* Use the predefined value. */ +#elif U_PLATFORM_USES_ONLY_WIN32_API +# define U_PLATFORM_IMPLEMENTS_POSIX 0 +#else +# define U_PLATFORM_IMPLEMENTS_POSIX 1 +#endif + +/** + * \def U_PLATFORM_IS_LINUX_BASED + * Defines whether the platform is Linux or one of its derivatives. + * @internal + */ +#ifdef U_PLATFORM_IS_LINUX_BASED + /* Use the predefined value. */ +#elif U_PF_LINUX <= U_PLATFORM && U_PLATFORM <= 4499 +# define U_PLATFORM_IS_LINUX_BASED 1 +#else +# define U_PLATFORM_IS_LINUX_BASED 0 +#endif + +/** + * \def U_PLATFORM_IS_DARWIN_BASED + * Defines whether the platform is Darwin or one of its derivatives. + * @internal + */ +#ifdef U_PLATFORM_IS_DARWIN_BASED + /* Use the predefined value. */ +#elif U_PF_DARWIN <= U_PLATFORM && U_PLATFORM <= U_PF_IPHONE +# define U_PLATFORM_IS_DARWIN_BASED 1 +#else +# define U_PLATFORM_IS_DARWIN_BASED 0 +#endif + +/*===========================================================================*/ +/** @{ Compiler and environment features */ +/*===========================================================================*/ + +/** + * \def U_GCC_MAJOR_MINOR + * Indicates whether the compiler is gcc (test for != 0), + * and if so, contains its major (times 100) and minor version numbers. + * If the compiler is not gcc, then U_GCC_MAJOR_MINOR == 0. + * + * For example, for testing for whether we have gcc, and whether it's 4.6 or higher, + * use "#if U_GCC_MAJOR_MINOR >= 406". + * @internal + */ +#ifdef __GNUC__ +# define U_GCC_MAJOR_MINOR (__GNUC__ * 100 + __GNUC_MINOR__) +#else +# define U_GCC_MAJOR_MINOR 0 +#endif + +/** + * \def U_IS_BIG_ENDIAN + * Determines the endianness of the platform. + * @internal + */ +#ifdef U_IS_BIG_ENDIAN + /* Use the predefined value. */ +#elif defined(BYTE_ORDER) && defined(BIG_ENDIAN) +# define U_IS_BIG_ENDIAN (BYTE_ORDER == BIG_ENDIAN) +#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) + /* gcc */ +# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) +#elif defined(__BIG_ENDIAN__) || defined(_BIG_ENDIAN) +# define U_IS_BIG_ENDIAN 1 +#elif defined(__LITTLE_ENDIAN__) || defined(_LITTLE_ENDIAN) +# define U_IS_BIG_ENDIAN 0 +#elif U_PLATFORM == U_PF_OS390 || U_PLATFORM == U_PF_OS400 || defined(__s390__) || defined(__s390x__) + /* These platforms do not appear to predefine any endianness macros. */ +# define U_IS_BIG_ENDIAN 1 +#elif defined(_PA_RISC1_0) || defined(_PA_RISC1_1) || defined(_PA_RISC2_0) + /* HPPA do not appear to predefine any endianness macros. */ +# define U_IS_BIG_ENDIAN 1 +#elif defined(sparc) || defined(__sparc) || defined(__sparc__) + /* Some sparc based systems (e.g. Linux) do not predefine any endianness macros. */ +# define U_IS_BIG_ENDIAN 1 +#else +# define U_IS_BIG_ENDIAN 0 +#endif + +/** + * \def U_HAVE_PLACEMENT_NEW + * Determines whether to override placement new and delete for STL. + * @stable ICU 2.6 + */ +#ifdef U_HAVE_PLACEMENT_NEW + /* Use the predefined value. */ +#elif defined(__BORLANDC__) +# define U_HAVE_PLACEMENT_NEW 0 +#else +# define U_HAVE_PLACEMENT_NEW 1 +#endif + +/** + * \def U_HAVE_DEBUG_LOCATION_NEW + * Define this to define the MFC debug version of the operator new. + * + * @stable ICU 3.4 + */ +#ifdef U_HAVE_DEBUG_LOCATION_NEW + /* Use the predefined value. */ +#elif defined(_MSC_VER) +# define U_HAVE_DEBUG_LOCATION_NEW 1 +#else +# define U_HAVE_DEBUG_LOCATION_NEW 0 +#endif + +/* Compatibility with compilers other than clang: http://clang.llvm.org/docs/LanguageExtensions.html */ +#ifdef __has_attribute +# define UPRV_HAS_ATTRIBUTE(x) __has_attribute(x) +#else +# define UPRV_HAS_ATTRIBUTE(x) 0 +#endif +#ifdef __has_cpp_attribute +# define UPRV_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define UPRV_HAS_CPP_ATTRIBUTE(x) 0 +#endif +#ifdef __has_declspec_attribute +# define UPRV_HAS_DECLSPEC_ATTRIBUTE(x) __has_declspec_attribute(x) +#else +# define UPRV_HAS_DECLSPEC_ATTRIBUTE(x) 0 +#endif +#ifdef __has_builtin +# define UPRV_HAS_BUILTIN(x) __has_builtin(x) +#else +# define UPRV_HAS_BUILTIN(x) 0 +#endif +#ifdef __has_feature +# define UPRV_HAS_FEATURE(x) __has_feature(x) +#else +# define UPRV_HAS_FEATURE(x) 0 +#endif +#ifdef __has_extension +# define UPRV_HAS_EXTENSION(x) __has_extension(x) +#else +# define UPRV_HAS_EXTENSION(x) 0 +#endif +#ifdef __has_warning +# define UPRV_HAS_WARNING(x) __has_warning(x) +#else +# define UPRV_HAS_WARNING(x) 0 +#endif + + +#if defined(__clang__) +#define UPRV_NO_SANITIZE_UNDEFINED __attribute__((no_sanitize("undefined"))) +#else +#define UPRV_NO_SANITIZE_UNDEFINED +#endif + +/** + * \def U_MALLOC_ATTR + * Attribute to mark functions as malloc-like + * @internal + */ +#if defined(__GNUC__) && __GNUC__>=3 +# define U_MALLOC_ATTR __attribute__ ((__malloc__)) +#else +# define U_MALLOC_ATTR +#endif + +/** + * \def U_ALLOC_SIZE_ATTR + * Attribute to specify the size of the allocated buffer for malloc-like functions + * @internal + */ +#if (defined(__GNUC__) && \ + (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) || \ + UPRV_HAS_ATTRIBUTE(alloc_size) +# define U_ALLOC_SIZE_ATTR(X) __attribute__ ((alloc_size(X))) +# define U_ALLOC_SIZE_ATTR2(X,Y) __attribute__ ((alloc_size(X,Y))) +#else +# define U_ALLOC_SIZE_ATTR(X) +# define U_ALLOC_SIZE_ATTR2(X,Y) +#endif + +/** + * \def U_CPLUSPLUS_VERSION + * 0 if no C++; 1, 11, 14, ... if C++. + * Support for specific features cannot always be determined by the C++ version alone. + * @internal + */ +#ifdef U_CPLUSPLUS_VERSION +# if U_CPLUSPLUS_VERSION != 0 && !defined(__cplusplus) +# undef U_CPLUSPLUS_VERSION +# define U_CPLUSPLUS_VERSION 0 +# endif + /* Otherwise use the predefined value. */ +#elif !defined(__cplusplus) +# define U_CPLUSPLUS_VERSION 0 +#elif __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +# define U_CPLUSPLUS_VERSION 17 +#elif __cplusplus >= 201402L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) +# define U_CPLUSPLUS_VERSION 14 +#elif __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L) +# define U_CPLUSPLUS_VERSION 11 +#else + // C++98 or C++03 +# define U_CPLUSPLUS_VERSION 1 +#endif + +/** + * \def U_FALLTHROUGH + * Annotate intentional fall-through between switch labels. + * http://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough + * @internal + */ +#ifndef __cplusplus + // Not for C. +#elif defined(U_FALLTHROUGH) + // Use the predefined value. +#elif defined(__clang__) + // Test for compiler vs. feature separately. + // Other compilers might choke on the feature test. +# if UPRV_HAS_CPP_ATTRIBUTE(clang::fallthrough) || \ + (UPRV_HAS_FEATURE(cxx_attributes) && \ + UPRV_HAS_WARNING("-Wimplicit-fallthrough")) +# define U_FALLTHROUGH [[clang::fallthrough]] +# endif +#elif defined(__GNUC__) && (__GNUC__ >= 7) +# define U_FALLTHROUGH __attribute__((fallthrough)) +#endif + +#ifndef U_FALLTHROUGH +# define U_FALLTHROUGH +#endif + +/** @} */ + +/*===========================================================================*/ +/** @{ Character data types */ +/*===========================================================================*/ + +/** + * U_CHARSET_FAMILY is equal to this value when the platform is an ASCII based platform. + * @stable ICU 2.0 + */ +#define U_ASCII_FAMILY 0 + +/** + * U_CHARSET_FAMILY is equal to this value when the platform is an EBCDIC based platform. + * @stable ICU 2.0 + */ +#define U_EBCDIC_FAMILY 1 + +/** + * \def U_CHARSET_FAMILY + * + *

These definitions allow to specify the encoding of text + * in the char data type as defined by the platform and the compiler. + * It is enough to determine the code point values of "invariant characters", + * which are the ones shared by all encodings that are in use + * on a given platform.

+ * + *

Those "invariant characters" should be all the uppercase and lowercase + * latin letters, the digits, the space, and "basic punctuation". + * Also, '\\n', '\\r', '\\t' should be available.

+ * + *

The list of "invariant characters" is:
+ * \code + * A-Z a-z 0-9 SPACE " % & ' ( ) * + , - . / : ; < = > ? _ + * \endcode + *
+ * (52 letters + 10 numbers + 20 punc/sym/space = 82 total)

+ * + *

This matches the IBM Syntactic Character Set (CS 640).

+ * + *

In other words, all the graphic characters in 7-bit ASCII should + * be safely accessible except the following:

+ * + * \code + * '\' + * '[' + * ']' + * '{' + * '}' + * '^' + * '~' + * '!' + * '#' + * '|' + * '$' + * '@' + * '`' + * \endcode + * @stable ICU 2.0 + */ +#ifdef U_CHARSET_FAMILY + /* Use the predefined value. */ +#elif U_PLATFORM == U_PF_OS390 && (!defined(__CHARSET_LIB) || !__CHARSET_LIB) +# define U_CHARSET_FAMILY U_EBCDIC_FAMILY +#elif U_PLATFORM == U_PF_OS400 && !defined(__UTF32__) +# define U_CHARSET_FAMILY U_EBCDIC_FAMILY +#else +# define U_CHARSET_FAMILY U_ASCII_FAMILY +#endif + +/** + * \def U_CHARSET_IS_UTF8 + * + * Hardcode the default charset to UTF-8. + * + * If this is set to 1, then + * - ICU will assume that all non-invariant char*, StringPiece, std::string etc. + * contain UTF-8 text, regardless of what the system API uses + * - some ICU code will use fast functions like u_strFromUTF8() + * rather than the more general and more heavy-weight conversion API (ucnv.h) + * - ucnv_getDefaultName() always returns "UTF-8" + * - ucnv_setDefaultName() is disabled and will not change the default charset + * - static builds of ICU are smaller + * - more functionality is available with the UCONFIG_NO_CONVERSION build-time + * configuration option (see unicode/uconfig.h) + * - the UCONFIG_NO_CONVERSION build option in uconfig.h is more usable + * + * @stable ICU 4.2 + * @see UCONFIG_NO_CONVERSION + */ +#ifdef U_CHARSET_IS_UTF8 + /* Use the predefined value. */ +#elif U_PLATFORM_IS_LINUX_BASED || U_PLATFORM_IS_DARWIN_BASED || \ + U_PLATFORM == U_PF_EMSCRIPTEN +# define U_CHARSET_IS_UTF8 1 +#else +# define U_CHARSET_IS_UTF8 0 +#endif + +/** @} */ + +/*===========================================================================*/ +/** @{ Information about wchar support */ +/*===========================================================================*/ + +/** + * \def U_HAVE_WCHAR_H + * Indicates whether is available (1) or not (0). Set to 1 by default. + * + * @stable ICU 2.0 + */ +#ifdef U_HAVE_WCHAR_H + /* Use the predefined value. */ +#elif U_PLATFORM == U_PF_ANDROID && __ANDROID_API__ < 9 + /* + * Android before Gingerbread (Android 2.3, API level 9) did not support wchar_t. + * The type and header existed, but the library functions did not work as expected. + * The size of wchar_t was 1 but L"xyz" string literals had 32-bit units anyway. + */ +# define U_HAVE_WCHAR_H 0 +#else +# define U_HAVE_WCHAR_H 1 +#endif + +/** + * \def U_SIZEOF_WCHAR_T + * U_SIZEOF_WCHAR_T==sizeof(wchar_t) + * + * @stable ICU 2.0 + */ +#ifdef U_SIZEOF_WCHAR_T + /* Use the predefined value. */ +#elif (U_PLATFORM == U_PF_ANDROID && __ANDROID_API__ < 9) + /* + * Classic Mac OS and Mac OS X before 10.3 (Panther) did not support wchar_t or wstring. + * Newer Mac OS X has size 4. + */ +# define U_SIZEOF_WCHAR_T 1 +#elif U_PLATFORM_HAS_WIN32_API || U_PLATFORM == U_PF_CYGWIN +# define U_SIZEOF_WCHAR_T 2 +#elif U_PLATFORM == U_PF_AIX + /* + * AIX 6.1 information, section "Wide character data representation": + * "... the wchar_t datatype is 32-bit in the 64-bit environment and + * 16-bit in the 32-bit environment." + * and + * "All locales use Unicode for their wide character code values (process code), + * except the IBM-eucTW codeset." + */ +# ifdef __64BIT__ +# define U_SIZEOF_WCHAR_T 4 +# else +# define U_SIZEOF_WCHAR_T 2 +# endif +#elif U_PLATFORM == U_PF_OS390 + /* + * z/OS V1R11 information center, section "LP64 | ILP32": + * "In 31-bit mode, the size of long and pointers is 4 bytes and the size of wchar_t is 2 bytes. + * Under LP64, the size of long and pointer is 8 bytes and the size of wchar_t is 4 bytes." + */ +# ifdef _LP64 +# define U_SIZEOF_WCHAR_T 4 +# else +# define U_SIZEOF_WCHAR_T 2 +# endif +#elif U_PLATFORM == U_PF_OS400 +# if defined(__UTF32__) + /* + * LOCALETYPE(*LOCALEUTF) is specified. + * Wide-character strings are in UTF-32, + * narrow-character strings are in UTF-8. + */ +# define U_SIZEOF_WCHAR_T 4 +# elif defined(__UCS2__) + /* + * LOCALETYPE(*LOCALEUCS2) is specified. + * Wide-character strings are in UCS-2, + * narrow-character strings are in EBCDIC. + */ +# define U_SIZEOF_WCHAR_T 2 +# else + /* + * LOCALETYPE(*CLD) or LOCALETYPE(*LOCALE) is specified. + * Wide-character strings are in 16-bit EBCDIC, + * narrow-character strings are in EBCDIC. + */ +# define U_SIZEOF_WCHAR_T 2 +# endif +#else +# define U_SIZEOF_WCHAR_T 4 +#endif + +#ifndef U_HAVE_WCSCPY +#define U_HAVE_WCSCPY U_HAVE_WCHAR_H +#endif + +/** @} */ + +/** + * \def U_HAVE_CHAR16_T + * Defines whether the char16_t type is available for UTF-16 + * and u"abc" UTF-16 string literals are supported. + * This is a new standard type and standard string literal syntax in C++11 + * but has been available in some compilers before. + * @internal + */ +#ifdef U_HAVE_CHAR16_T + /* Use the predefined value. */ +#else + /* + * Notes: + * C++11 and C11 require support for UTF-16 literals + * Doesn't work on Mac C11 (see workaround in ptypes.h). + */ +# if defined(__cplusplus) || !U_PLATFORM_IS_DARWIN_BASED +# define U_HAVE_CHAR16_T 1 +# else +# define U_HAVE_CHAR16_T 0 +# endif +#endif + +/** + * @{ + * \def U_DECLARE_UTF16 + * Do not use this macro because it is not defined on all platforms. + * Use the UNICODE_STRING or U_STRING_DECL macros instead. + * @internal + */ +#ifdef U_DECLARE_UTF16 + /* Use the predefined value. */ +#elif U_HAVE_CHAR16_T \ + || (defined(__xlC__) && defined(__IBM_UTF_LITERAL) && U_SIZEOF_WCHAR_T != 2) \ + || (defined(__HP_aCC) && __HP_aCC >= 035000) \ + || (defined(__HP_cc) && __HP_cc >= 111106) \ + || (defined(U_IN_DOXYGEN)) +# define U_DECLARE_UTF16(string) u ## string +#elif U_SIZEOF_WCHAR_T == 2 \ + && (U_CHARSET_FAMILY == 0 || (U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_OS400 && defined(__UCS2__))) +# define U_DECLARE_UTF16(string) L ## string +#else + /* Leave U_DECLARE_UTF16 undefined. See unistr.h. */ +#endif + +/** @} */ + +/*===========================================================================*/ +/** @{ Symbol import-export control */ +/*===========================================================================*/ + +#ifdef U_EXPORT + /* Use the predefined value. */ +#elif defined(U_STATIC_IMPLEMENTATION) +# define U_EXPORT +#elif defined(_MSC_VER) || (UPRV_HAS_DECLSPEC_ATTRIBUTE(__dllexport__) && \ + UPRV_HAS_DECLSPEC_ATTRIBUTE(__dllimport__)) +# define U_EXPORT __declspec(dllexport) +#elif defined(__GNUC__) +# define U_EXPORT __attribute__((visibility("default"))) +#elif (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x550) \ + || (defined(__SUNPRO_C) && __SUNPRO_C >= 0x550) +# define U_EXPORT __global +/*#elif defined(__HP_aCC) || defined(__HP_cc) +# define U_EXPORT __declspec(dllexport)*/ +#else +# define U_EXPORT +#endif + +/* U_CALLCONV is related to U_EXPORT2 */ +#ifdef U_EXPORT2 + /* Use the predefined value. */ +#elif defined(_MSC_VER) +# define U_EXPORT2 __cdecl +#else +# define U_EXPORT2 +#endif + +#ifdef U_IMPORT + /* Use the predefined value. */ +#elif defined(_MSC_VER) || (UPRV_HAS_DECLSPEC_ATTRIBUTE(__dllexport__) && \ + UPRV_HAS_DECLSPEC_ATTRIBUTE(__dllimport__)) + /* Windows needs to export/import data. */ +# define U_IMPORT __declspec(dllimport) +#else +# define U_IMPORT +#endif + +/** + * \def U_HIDDEN + * This is used to mark internal structs declared within external classes, + * to prevent the internal structs from having the same visibility as the + * class within which they are declared. + * @internal + */ +#ifdef U_HIDDEN + /* Use the predefined value. */ +#elif defined(__GNUC__) +# define U_HIDDEN __attribute__((visibility("hidden"))) +#else +# define U_HIDDEN +#endif + +/** + * \def U_CALLCONV + * Similar to U_CDECL_BEGIN/U_CDECL_END, this qualifier is necessary + * in callback function typedefs to make sure that the calling convention + * is compatible. + * + * This is only used for non-ICU-API functions. + * When a function is a public ICU API, + * you must use the U_CAPI and U_EXPORT2 qualifiers. + * + * Please note, you need to use U_CALLCONV after the *. + * + * NO : "static const char U_CALLCONV *func( . . . )" + * YES: "static const char* U_CALLCONV func( . . . )" + * + * @stable ICU 2.0 + */ +#if U_PLATFORM == U_PF_OS390 && defined(__cplusplus) +# define U_CALLCONV __cdecl +#else +# define U_CALLCONV U_EXPORT2 +#endif + +/** + * \def U_CALLCONV_FPTR + * Similar to U_CALLCONV, but only used on function pointers. + * @internal + */ +#if U_PLATFORM == U_PF_OS390 && defined(__cplusplus) +# define U_CALLCONV_FPTR U_CALLCONV +#else +# define U_CALLCONV_FPTR +#endif +/** @} */ + +#endif // _PLATFORM_H diff --git a/tools/icu/patches/75/source/tools/genccode/genccode.c b/tools/icu/patches/75/source/tools/genccode/genccode.c new file mode 100644 index 00000000000000..0f243952a7d452 --- /dev/null +++ b/tools/icu/patches/75/source/tools/genccode/genccode.c @@ -0,0 +1,226 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* + ******************************************************************************* + * Copyright (C) 1999-2016, International Business Machines + * Corporation and others. All Rights Reserved. + ******************************************************************************* + * file name: gennames.c + * encoding: UTF-8 + * tab size: 8 (not used) + * indentation:4 + * + * created on: 1999nov01 + * created by: Markus W. Scherer + * + * This program reads a binary file and creates a C source code file + * with a byte array that contains the data of the binary file. + * + * 12/09/1999 weiv Added multiple file handling + */ + +#include "unicode/utypes.h" + +#if U_PLATFORM_HAS_WIN32_API +# define VC_EXTRALEAN +# define WIN32_LEAN_AND_MEAN +# define NOUSER +# define NOSERVICE +# define NOIME +# define NOMCX +#include +#include +#endif + +#if U_PLATFORM_IS_LINUX_BASED && U_HAVE_ELF_H +# define U_ELF +#endif + +#ifdef U_ELF +# include +# if defined(ELFCLASS64) +# define U_ELF64 +# endif + /* Old elf.h headers may not have EM_X86_64, or have EM_X8664 instead. */ +# ifndef EM_X86_64 +# define EM_X86_64 62 +# endif +# define ICU_ENTRY_OFFSET 0 +#endif + +#include +#include +#include +#include "unicode/putil.h" +#include "cmemory.h" +#include "cstring.h" +#include "filestrm.h" +#include "toolutil.h" +#include "unicode/uclean.h" +#include "uoptions.h" +#include "pkg_genc.h" + +enum { + kOptHelpH = 0, + kOptHelpQuestionMark, + kOptDestDir, + kOptQuiet, + kOptName, + kOptEntryPoint, +#ifdef CAN_GENERATE_OBJECTS + kOptObject, + kOptMatchArch, + kOptCpuArch, + kOptSkipDllExport, +#endif + kOptFilename, + kOptAssembly +}; + +static UOption options[]={ +/*0*/UOPTION_HELP_H, + UOPTION_HELP_QUESTION_MARK, + UOPTION_DESTDIR, + UOPTION_QUIET, + UOPTION_DEF("name", 'n', UOPT_REQUIRES_ARG), + UOPTION_DEF("entrypoint", 'e', UOPT_REQUIRES_ARG), +#ifdef CAN_GENERATE_OBJECTS +/*6*/UOPTION_DEF("object", 'o', UOPT_NO_ARG), + UOPTION_DEF("match-arch", 'm', UOPT_REQUIRES_ARG), + UOPTION_DEF("cpu-arch", 'c', UOPT_REQUIRES_ARG), + UOPTION_DEF("skip-dll-export", '\0', UOPT_NO_ARG), +#endif + UOPTION_DEF("filename", 'f', UOPT_REQUIRES_ARG), + UOPTION_DEF("assembly", 'a', UOPT_REQUIRES_ARG) +}; + +#define CALL_WRITECCODE 'c' +#define CALL_WRITEASSEMBLY 'a' +#define CALL_WRITEOBJECT 'o' +extern int +main(int argc, char* argv[]) { + UBool verbose = true; + char writeCode; + + U_MAIN_INIT_ARGS(argc, argv); + + options[kOptDestDir].value = "."; + + /* read command line options */ + argc=u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options); + + /* error handling, printing usage message */ + if(argc<0) { + fprintf(stderr, + "error in command line argument \"%s\"\n", + argv[-argc]); + } + if(argc<0 || options[kOptHelpH].doesOccur || options[kOptHelpQuestionMark].doesOccur) { + fprintf(stderr, + "usage: %s [-options] filename1 filename2 ...\n" + "\tread each binary input file and \n" + "\tcreate a .c file with a byte array that contains the input file's data\n" + "options:\n" + "\t-h or -? or --help this usage text\n" + "\t-d or --destdir destination directory, followed by the path\n" + "\t-q or --quiet do not display warnings and progress\n" + "\t-n or --name symbol prefix, followed by the prefix\n" + "\t-e or --entrypoint entry point name, followed by the name (_dat will be appended)\n" + "\t-r or --revision Specify a version\n" + , argv[0]); +#ifdef CAN_GENERATE_OBJECTS + fprintf(stderr, + "\t-o or --object write a .obj file instead of .c\n" + "\t-m or --match-arch file.o match the architecture (CPU, 32/64 bits) of the specified .o\n" + "\t ELF format defaults to i386. Windows defaults to the native platform.\n" + "\t-c or --cpu-arch Specify a CPU architecture for which to write a .obj file for ClangCL on Windows\n" + "\t Valid values for this opton are x64, x86 and arm64.\n" + "\t--skip-dll-export Don't export the ICU data entry point symbol (for use when statically linking)\n"); +#endif + fprintf(stderr, + "\t-f or --filename Specify an alternate base filename. (default: symbolname_typ)\n" + "\t-a or --assembly Create assembly file. (possible values are: "); + + printAssemblyHeadersToStdErr(); + } else { + const char *message, *filename; + /* TODO: remove void (*writeCode)(const char *, const char *); */ + + if(options[kOptAssembly].doesOccur) { + message="generating assembly code for %s\n"; + writeCode = CALL_WRITEASSEMBLY; + /* TODO: remove writeCode=&writeAssemblyCode; */ + + if (!checkAssemblyHeaderName(options[kOptAssembly].value)) { + fprintf(stderr, + "Assembly type \"%s\" is unknown.\n", options[kOptAssembly].value); + return -1; + } + } +#ifdef CAN_GENERATE_OBJECTS + else if(options[kOptObject].doesOccur) { + message="generating object code for %s\n"; + writeCode = CALL_WRITEOBJECT; + /* TODO: remove writeCode=&writeObjectCode; */ + } +#endif + else + { + message="generating C code for %s\n"; + writeCode = CALL_WRITECCODE; + /* TODO: remove writeCode=&writeCCode; */ + } + if (options[kOptQuiet].doesOccur) { + verbose = false; + } + while(--argc) { + filename=getLongPathname(argv[argc]); + if (verbose) { + fprintf(stdout, message, filename); + } + + switch (writeCode) { + case CALL_WRITECCODE: + writeCCode(filename, options[kOptDestDir].value, + options[kOptEntryPoint].doesOccur ? options[kOptEntryPoint].value : NULL, + options[kOptName].doesOccur ? options[kOptName].value : NULL, + options[kOptFilename].doesOccur ? options[kOptFilename].value : NULL, + NULL, + 0); + break; + case CALL_WRITEASSEMBLY: + writeAssemblyCode(filename, options[kOptDestDir].value, + options[kOptEntryPoint].doesOccur ? options[kOptEntryPoint].value : NULL, + options[kOptFilename].doesOccur ? options[kOptFilename].value : NULL, + NULL, + 0); + break; +#ifdef CAN_GENERATE_OBJECTS + case CALL_WRITEOBJECT: + if(options[kOptCpuArch].doesOccur) { + if (!checkCpuArchitecture(options[kOptCpuArch].value)) { + fprintf(stderr, + "CPU architecture \"%s\" is unknown.\n", options[kOptCpuArch].value); + return -1; + } + } + writeObjectCode(filename, options[kOptDestDir].value, + options[kOptEntryPoint].doesOccur ? options[kOptEntryPoint].value : NULL, + options[kOptMatchArch].doesOccur ? options[kOptMatchArch].value : NULL, + options[kOptCpuArch].doesOccur ? options[kOptCpuArch].value : NULL, + options[kOptFilename].doesOccur ? options[kOptFilename].value : NULL, + NULL, + 0, + !options[kOptSkipDllExport].doesOccur); + break; +#endif + default: + /* Should never occur. */ + break; + } + /* TODO: remove writeCode(filename, options[kOptDestDir].value); */ + } + } + + return 0; +} diff --git a/tools/icu/patches/75/source/tools/genccode/pkg_genc.h b/tools/icu/patches/75/source/tools/genccode/pkg_genc.h new file mode 100644 index 00000000000000..76474ec7df6fd8 --- /dev/null +++ b/tools/icu/patches/75/source/tools/genccode/pkg_genc.h @@ -0,0 +1,111 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/****************************************************************************** + * Copyright (C) 2008-2011, International Business Machines + * Corporation and others. All Rights Reserved. + ******************************************************************************* + */ + +#ifndef __PKG_GENC_H__ +#define __PKG_GENC_H__ + +#include "unicode/utypes.h" +#include "toolutil.h" + +#include "unicode/putil.h" +#include "putilimp.h" + +/*** Platform #defines move here ***/ +#if U_PLATFORM_HAS_WIN32_API +#ifdef __GNUC__ +#define WINDOWS_WITH_GNUC +#else +#define WINDOWS_WITH_MSVC +#endif +#endif + + +#if !defined(WINDOWS_WITH_MSVC) +#define BUILD_DATA_WITHOUT_ASSEMBLY +#endif + +#ifndef U_DISABLE_OBJ_CODE /* testing */ +#if defined(WINDOWS_WITH_MSVC) || U_PLATFORM_IS_LINUX_BASED +#define CAN_WRITE_OBJ_CODE +#endif +#if U_PLATFORM_HAS_WIN32_API || defined(U_ELF) +#define CAN_GENERATE_OBJECTS +#endif +#endif + +#if U_PLATFORM == U_PF_CYGWIN || defined(CYGWINMSVC) +#define USING_CYGWIN +#endif + +/* + * When building the data library without assembly, + * some platforms use a single c code file for all of + * the data to generate the final data library. This can + * increase the performance of the pkdata tool. + */ +#if U_PLATFORM == U_PF_OS400 +#define USE_SINGLE_CCODE_FILE +#endif + +/* Need to fix the file seperator character when using MinGW. */ +#if defined(WINDOWS_WITH_GNUC) || defined(USING_CYGWIN) +#define PKGDATA_FILE_SEP_STRING "/" +#else +#define PKGDATA_FILE_SEP_STRING U_FILE_SEP_STRING +#endif + +#define LARGE_BUFFER_MAX_SIZE 2048 +#define SMALL_BUFFER_MAX_SIZE 512 +#define SMALL_BUFFER_FLAG_NAMES 32 +#define BUFFER_PADDING_SIZE 20 + +/** End platform defines **/ + + + +U_CAPI void U_EXPORT2 +printAssemblyHeadersToStdErr(void); + +U_CAPI UBool U_EXPORT2 +checkAssemblyHeaderName(const char* optAssembly); + +U_CAPI UBool U_EXPORT2 +checkCpuArchitecture(const char* optCpuArch); + +U_CAPI void U_EXPORT2 +writeCCode( + const char *filename, + const char *destdir, + const char *optEntryPoint, + const char *optName, + const char *optFilename, + char *outFilePath, + size_t outFilePathCapacity); + +U_CAPI void U_EXPORT2 +writeAssemblyCode( + const char *filename, + const char *destdir, + const char *optEntryPoint, + const char *optFilename, + char *outFilePath, + size_t outFilePathCapacity); + +U_CAPI void U_EXPORT2 +writeObjectCode( + const char *filename, + const char *destdir, + const char *optEntryPoint, + const char *optMatchArch, + const char *optCpuArch, + const char *optFilename, + char *outFilePath, + size_t outFilePathCapacity, + UBool optWinDllExport); + +#endif diff --git a/tools/icu/patches/75/source/tools/pkgdata/pkgdata.cpp b/tools/icu/patches/75/source/tools/pkgdata/pkgdata.cpp new file mode 100644 index 00000000000000..51452a51bb3e48 --- /dev/null +++ b/tools/icu/patches/75/source/tools/pkgdata/pkgdata.cpp @@ -0,0 +1,2292 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/****************************************************************************** + * Copyright (C) 2000-2016, International Business Machines + * Corporation and others. All Rights Reserved. + ******************************************************************************* + * file name: pkgdata.cpp + * encoding: ANSI X3.4 (1968) + * tab size: 8 (not used) + * indentation:4 + * + * created on: 2000may15 + * created by: Steven \u24C7 Loomis + * + * This program packages the ICU data into different forms + * (DLL, common data, etc.) + */ + +// Defines _XOPEN_SOURCE for access to POSIX functions. +// Must be before any other #includes. +#include "uposixdefs.h" + +#include "unicode/utypes.h" + +#include "unicode/putil.h" +#include "putilimp.h" + +#if U_HAVE_POPEN +#if (U_PF_MINGW <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN) && defined(__STRICT_ANSI__) +/* popen/pclose aren't defined in strict ANSI on Cygwin and MinGW */ +#undef __STRICT_ANSI__ +#endif +#endif + +#include "cmemory.h" +#include "cstring.h" +#include "filestrm.h" +#include "toolutil.h" +#include "unicode/uclean.h" +#include "unewdata.h" +#include "uoptions.h" +#include "package.h" +#include "pkg_icu.h" +#include "pkg_genc.h" +#include "pkg_gencmn.h" +#include "flagparser.h" +#include "filetools.h" +#include "charstr.h" +#include "uassert.h" + +#if U_HAVE_POPEN +# include +#endif + +#include +#include + +U_CDECL_BEGIN +#include "pkgtypes.h" +U_CDECL_END + +#if U_HAVE_POPEN +U_NAMESPACE_BEGIN +U_DEFINE_LOCAL_OPEN_POINTER(LocalPipeFilePointer, FILE, pclose); +U_NAMESPACE_END +#endif + +using icu::LocalMemory; + +static void loadLists(UPKGOptions *o, UErrorCode *status); + +static int32_t pkg_executeOptions(UPKGOptions *o); + +#ifdef WINDOWS_WITH_MSVC +static int32_t pkg_createWindowsDLL(const char mode, const char *gencFilePath, UPKGOptions *o); +#endif +static int32_t pkg_createSymLinks(const char *targetDir, UBool specialHandling=false); +static int32_t pkg_installLibrary(const char *installDir, const char *dir, UBool noVersion); +static int32_t pkg_installFileMode(const char *installDir, const char *srcDir, const char *fileListName); +static int32_t pkg_installCommonMode(const char *installDir, const char *fileName); + +#ifdef BUILD_DATA_WITHOUT_ASSEMBLY +static int32_t pkg_createWithoutAssemblyCode(UPKGOptions *o, const char *targetDir, const char mode); +#endif + +#ifdef CAN_WRITE_OBJ_CODE +static void pkg_createOptMatchArch(char *optMatchArch); +static void pkg_destroyOptMatchArch(char *optMatchArch); +#endif + +static int32_t pkg_createWithAssemblyCode(const char *targetDir, const char mode, const char *gencFilePath); +static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command = nullptr, UBool specialHandling=false); +static int32_t pkg_archiveLibrary(const char *targetDir, const char *version, UBool reverseExt); +static void createFileNames(UPKGOptions *o, const char mode, const char *version_major, const char *version, const char *libName, const UBool reverseExt, UBool noVersion); +static int32_t initializePkgDataFlags(UPKGOptions *o); + +static int32_t pkg_getPkgDataPath(UBool verbose, UOption *option); +static int runCommand(const char* command, UBool specialHandling=false); + +#define IN_COMMON_MODE(mode) (mode == 'a' || mode == 'c') +#define IN_DLL_MODE(mode) (mode == 'd' || mode == 'l') +#define IN_STATIC_MODE(mode) (mode == 's') +#define IN_FILES_MODE(mode) (mode == 'f') + +enum { + NAME, + BLDOPT, + MODE, + HELP, + HELP_QUESTION_MARK, + VERBOSE, + COPYRIGHT, + COMMENT, + DESTDIR, + REBUILD, + TEMPDIR, + INSTALL, + SOURCEDIR, + ENTRYPOINT, + REVISION, + FORCE_PREFIX, + LIBNAME, + QUIET, + WITHOUT_ASSEMBLY, + PDS_BUILD, + WIN_UWP_BUILD, + WIN_DLL_ARCH, + WIN_DYNAMICBASE +}; + +/* This sets the modes that are available */ +static struct { + const char *name, *alt_name; + const char *desc; +} modes[] = { + { "files", nullptr, "Uses raw data files (no effect). Installation copies all files to the target location." }, +#if U_PLATFORM_HAS_WIN32_API + { "dll", "library", "Generates one common data file and one shared library, .dll"}, + { "common", "archive", "Generates just the common file, .dat"}, + { "static", "static", "Generates one statically linked library, " LIB_PREFIX "" UDATA_LIB_SUFFIX } +#else +#ifdef UDATA_SO_SUFFIX + { "dll", "library", "Generates one shared library, " UDATA_SO_SUFFIX }, +#endif + { "common", "archive", "Generates one common data file, .dat" }, + { "static", "static", "Generates one statically linked library, " LIB_PREFIX "" UDATA_LIB_SUFFIX } +#endif +}; + +static UOption options[]={ + /*00*/ UOPTION_DEF( "name", 'p', UOPT_REQUIRES_ARG), + /*01*/ UOPTION_DEF( "bldopt", 'O', UOPT_REQUIRES_ARG), /* on Win32 it is release or debug */ + /*02*/ UOPTION_DEF( "mode", 'm', UOPT_REQUIRES_ARG), + /*03*/ UOPTION_HELP_H, /* -h */ + /*04*/ UOPTION_HELP_QUESTION_MARK, /* -? */ + /*05*/ UOPTION_VERBOSE, /* -v */ + /*06*/ UOPTION_COPYRIGHT, /* -c */ + /*07*/ UOPTION_DEF( "comment", 'C', UOPT_REQUIRES_ARG), + /*08*/ UOPTION_DESTDIR, /* -d */ + /*11*/ UOPTION_DEF( "rebuild", 'F', UOPT_NO_ARG), + /*12*/ UOPTION_DEF( "tempdir", 'T', UOPT_REQUIRES_ARG), + /*13*/ UOPTION_DEF( "install", 'I', UOPT_REQUIRES_ARG), + /*14*/ UOPTION_SOURCEDIR , + /*15*/ UOPTION_DEF( "entrypoint", 'e', UOPT_REQUIRES_ARG), + /*16*/ UOPTION_DEF( "revision", 'r', UOPT_REQUIRES_ARG), + /*17*/ UOPTION_DEF( "force-prefix", 'f', UOPT_NO_ARG), + /*18*/ UOPTION_DEF( "libname", 'L', UOPT_REQUIRES_ARG), + /*19*/ UOPTION_DEF( "quiet", 'q', UOPT_NO_ARG), + /*20*/ UOPTION_DEF( "without-assembly", 'w', UOPT_NO_ARG), + /*21*/ UOPTION_DEF("zos-pds-build", 'z', UOPT_NO_ARG), + /*22*/ UOPTION_DEF("windows-uwp-build", 'u', UOPT_NO_ARG), + /*23*/ UOPTION_DEF("windows-DLL-arch", 'a', UOPT_REQUIRES_ARG), + /*24*/ UOPTION_DEF("windows-dynamicbase", 'b', UOPT_NO_ARG), +}; + +/* This enum and the following char array should be kept in sync. */ +enum { + GENCCODE_ASSEMBLY_TYPE, + SO_EXT, + SOBJ_EXT, + A_EXT, + LIBPREFIX, + LIB_EXT_ORDER, + COMPILER, + LIBFLAGS, + GENLIB, + LDICUDTFLAGS, + LD_SONAME, + RPATH_FLAGS, + BIR_FLAGS, + AR, + ARFLAGS, + RANLIB, + INSTALL_CMD, + PKGDATA_FLAGS_SIZE +}; +static const char* FLAG_NAMES[PKGDATA_FLAGS_SIZE] = { + "GENCCODE_ASSEMBLY_TYPE", + "SO", + "SOBJ", + "A", + "LIBPREFIX", + "LIB_EXT_ORDER", + "COMPILE", + "LIBFLAGS", + "GENLIB", + "LDICUDTFLAGS", + "LD_SONAME", + "RPATH_FLAGS", + "BIR_LDFLAGS", + "AR", + "ARFLAGS", + "RANLIB", + "INSTALL_CMD" +}; +static char **pkgDataFlags = nullptr; + +enum { + LIB_FILE, + LIB_FILE_VERSION_MAJOR, + LIB_FILE_VERSION, + LIB_FILE_VERSION_TMP, +#if U_PLATFORM == U_PF_CYGWIN + LIB_FILE_CYGWIN, + LIB_FILE_CYGWIN_VERSION, +#elif U_PLATFORM == U_PF_MINGW + LIB_FILE_MINGW, +#elif U_PLATFORM == U_PF_OS390 + LIB_FILE_OS390BATCH_MAJOR, + LIB_FILE_OS390BATCH_VERSION, +#endif + LIB_FILENAMES_SIZE +}; +static char libFileNames[LIB_FILENAMES_SIZE][256]; + +static UPKGOptions *pkg_checkFlag(UPKGOptions *o); + +const char options_help[][320]={ + "Set the data name", +#ifdef U_MAKE_IS_NMAKE + "The directory where the ICU is located (e.g. which contains the bin directory)", +#else + "Specify options for the builder.", +#endif + "Specify the mode of building (see below; default: common)", + "This usage text", + "This usage text", + "Make the output verbose", + "Use the standard ICU copyright", + "Use a custom comment (instead of the copyright)", + "Specify the destination directory for files", + "Force rebuilding of all data", + "Specify temporary dir (default: output dir)", + "Install the data (specify target)", + "Specify a custom source directory", + "Specify a custom entrypoint name (default: short name)", + "Specify a version when packaging in dll or static mode", + "Add package to all file names if not present", + "Library name to build (if different than package name)", + "Quiet mode. (e.g. Do not output a readme file for static libraries)", + "Build the data without assembly code", + "Build PDS dataset (zOS build only)", + "Build for Universal Windows Platform (Windows build only)", + "Specify the DLL machine architecture for LINK.exe (Windows build only)", + "Ignored. Enable DYNAMICBASE on the DLL. This is now the default. (Windows build only)", +}; + +const char *progname = "PKGDATA"; + +int +main(int argc, char* argv[]) { + int result = 0; + /* FileStream *out; */ + UPKGOptions o; + CharList *tail; + UBool needsHelp = false; + UErrorCode status = U_ZERO_ERROR; + /* char tmp[1024]; */ + uint32_t i; + int32_t n; + + U_MAIN_INIT_ARGS(argc, argv); + + progname = argv[0]; + + options[MODE].value = "common"; + + /* read command line options */ + argc=u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options); + + /* error handling, printing usage message */ + /* I've decided to simply print an error and quit. This tool has too + many options to just display them all of the time. */ + + if(options[HELP].doesOccur || options[HELP_QUESTION_MARK].doesOccur) { + needsHelp = true; + } + else { + if(!needsHelp && argc<0) { + fprintf(stderr, + "%s: error in command line argument \"%s\"\n", + progname, + argv[-argc]); + fprintf(stderr, "Run '%s --help' for help.\n", progname); + return 1; + } + + +#if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) + if(!options[BLDOPT].doesOccur && uprv_strcmp(options[MODE].value, "common") != 0) { + if (pkg_getPkgDataPath(options[VERBOSE].doesOccur, &options[BLDOPT]) != 0) { + fprintf(stderr, " required parameter is missing: -O is required for static and shared builds.\n"); + fprintf(stderr, "Run '%s --help' for help.\n", progname); + return 1; + } + } +#else + if(options[BLDOPT].doesOccur) { + fprintf(stdout, "Warning: You are using the -O option which is not needed for MSVC build on Windows.\n"); + } +#endif + + if(!options[NAME].doesOccur) /* -O we already have - don't report it. */ + { + fprintf(stderr, " required parameter -p is missing \n"); + fprintf(stderr, "Run '%s --help' for help.\n", progname); + return 1; + } + + if(argc == 1) { + fprintf(stderr, + "No input files specified.\n" + "Run '%s --help' for help.\n", progname); + return 1; + } + } /* end !needsHelp */ + + if(argc<0 || needsHelp ) { + fprintf(stderr, + "usage: %s [-options] [-] [packageFile] \n" + "\tProduce packaged ICU data from the given list(s) of files.\n" + "\t'-' by itself means to read from stdin.\n" + "\tpackageFile is a text file containing the list of files to package.\n", + progname); + + fprintf(stderr, "\n options:\n"); + for(i=0;i(strlen(command)); + + if (len == 0) { + return 0; + } + + if (!specialHandling) { +#if defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW || U_PLATFORM == U_PF_OS400 + int32_t buff_len; + if ((len + BUFFER_PADDING_SIZE) >= SMALL_BUFFER_MAX_SIZE) { + cmd = (char *)uprv_malloc(len + BUFFER_PADDING_SIZE); + buff_len = len + BUFFER_PADDING_SIZE; + } else { + cmd = cmdBuffer; + buff_len = SMALL_BUFFER_MAX_SIZE; + } +#if defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW + snprintf(cmd, buff_len, "bash -c \"%s\"", command); + +#elif U_PLATFORM == U_PF_OS400 + snprintf(cmd, buff_len "QSH CMD('%s')", command); +#endif +#else + goto normal_command_mode; +#endif + } else { +#if !(defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW || U_PLATFORM == U_PF_OS400) +normal_command_mode: +#endif + cmd = (char *)command; + } + + printf("pkgdata: %s\n", cmd); + int result = system(cmd); + if (result != 0) { + fprintf(stderr, "-- return status = %d\n", result); + result = 1; // system() result code is platform specific. + } + + if (cmd != cmdBuffer && cmd != command) { + uprv_free(cmd); + } + + return result; +} + +#define LN_CMD "ln -s" +#define RM_CMD "rm -f" + +static int32_t pkg_executeOptions(UPKGOptions *o) { + int32_t result = 0; + + const char mode = o->mode[0]; + char targetDir[SMALL_BUFFER_MAX_SIZE] = ""; + char tmpDir[SMALL_BUFFER_MAX_SIZE] = ""; + char datFileName[SMALL_BUFFER_MAX_SIZE] = ""; + char datFileNamePath[LARGE_BUFFER_MAX_SIZE] = ""; + char checkLibFile[LARGE_BUFFER_MAX_SIZE] = ""; + + initializePkgDataFlags(o); + + if (IN_FILES_MODE(mode)) { + /* Copy the raw data to the installation directory. */ + if (o->install != nullptr) { + uprv_strcpy(targetDir, o->install); + if (o->shortName != nullptr) { + uprv_strcat(targetDir, PKGDATA_FILE_SEP_STRING); + uprv_strcat(targetDir, o->shortName); + } + + if(o->verbose) { + fprintf(stdout, "# Install: Files mode, copying files to %s..\n", targetDir); + } + result = pkg_installFileMode(targetDir, o->srcDir, o->fileListFiles->str); + } + return result; + } else /* if (IN_COMMON_MODE(mode) || IN_DLL_MODE(mode) || IN_STATIC_MODE(mode)) */ { + UBool noVersion = false; + + uprv_strcpy(targetDir, o->targetDir); + uprv_strcat(targetDir, PKGDATA_FILE_SEP_STRING); + + uprv_strcpy(tmpDir, o->tmpDir); + uprv_strcat(tmpDir, PKGDATA_FILE_SEP_STRING); + + uprv_strcpy(datFileNamePath, tmpDir); + + uprv_strcpy(datFileName, o->shortName); + uprv_strcat(datFileName, UDATA_CMN_SUFFIX); + + uprv_strcat(datFileNamePath, datFileName); + + if(o->verbose) { + fprintf(stdout, "# Writing package file %s ..\n", datFileNamePath); + } + result = writePackageDatFile(datFileNamePath, o->comment, o->srcDir, o->fileListFiles->str, nullptr, U_CHARSET_FAMILY ? 'e' : U_IS_BIG_ENDIAN ? 'b' : 'l'); + if (result != 0) { + fprintf(stderr,"Error writing package dat file.\n"); + return result; + } + + if (IN_COMMON_MODE(mode)) { + char targetFileNamePath[LARGE_BUFFER_MAX_SIZE] = ""; + + uprv_strcpy(targetFileNamePath, targetDir); + uprv_strcat(targetFileNamePath, datFileName); + + /* Move the dat file created to the target directory. */ + if (uprv_strcmp(datFileNamePath, targetFileNamePath) != 0) { + if (T_FileStream_file_exists(targetFileNamePath)) { + if ((result = remove(targetFileNamePath)) != 0) { + fprintf(stderr, "Unable to remove old dat file: %s\n", + targetFileNamePath); + return result; + } + } + + result = rename(datFileNamePath, targetFileNamePath); + + if (o->verbose) { + fprintf(stdout, "# Moving package file to %s ..\n", + targetFileNamePath); + } + if (result != 0) { + fprintf( + stderr, + "Unable to move dat file (%s) to target location (%s).\n", + datFileNamePath, targetFileNamePath); + return result; + } + } + + if (o->install != nullptr) { + result = pkg_installCommonMode(o->install, targetFileNamePath); + } + + return result; + } else /* if (IN_STATIC_MODE(mode) || IN_DLL_MODE(mode)) */ { + char gencFilePath[SMALL_BUFFER_MAX_SIZE] = ""; + char version_major[10] = ""; + UBool reverseExt = false; + +#if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) + /* Get the version major number. */ + if (o->version != nullptr) { + for (uint32_t i = 0;i < sizeof(version_major);i++) { + if (o->version[i] == '.') { + version_major[i] = 0; + break; + } + version_major[i] = o->version[i]; + } + } else { + noVersion = true; + if (IN_DLL_MODE(mode)) { + fprintf(stdout, "Warning: Providing a revision number with the -r option is recommended when packaging data in the current mode.\n"); + } + } + +#if U_PLATFORM != U_PF_OS400 + /* Certain platforms have different library extension ordering. (e.g. libicudata.##.so vs libicudata.so.##) + * reverseExt is false if the suffix should be the version number. + */ + if (pkgDataFlags[LIB_EXT_ORDER][uprv_strlen(pkgDataFlags[LIB_EXT_ORDER])-1] == pkgDataFlags[SO_EXT][uprv_strlen(pkgDataFlags[SO_EXT])-1]) { + reverseExt = true; + } +#endif + /* Using the base libName and version number, generate the library file names. */ + createFileNames(o, mode, version_major, o->version == nullptr ? "" : o->version, o->libName, reverseExt, noVersion); + + if ((o->version!=nullptr || IN_STATIC_MODE(mode)) && o->rebuild == false && o->pdsbuild == false) { + /* Check to see if a previous built data library file exists and check if it is the latest. */ + snprintf(checkLibFile, sizeof(checkLibFile), "%s%s", targetDir, libFileNames[LIB_FILE_VERSION]); + if (T_FileStream_file_exists(checkLibFile)) { + if (isFileModTimeLater(checkLibFile, o->srcDir, true) && isFileModTimeLater(checkLibFile, o->options)) { + if (o->install != nullptr) { + if(o->verbose) { + fprintf(stdout, "# Installing already-built library into %s\n", o->install); + } + result = pkg_installLibrary(o->install, targetDir, noVersion); + } else { + if(o->verbose) { + printf("# Not rebuilding %s - up to date.\n", checkLibFile); + } + } + return result; + } else if (o->verbose && (o->install!=nullptr)) { + fprintf(stdout, "# Not installing up-to-date library %s into %s\n", checkLibFile, o->install); + } + } else if(o->verbose && (o->install!=nullptr)) { + fprintf(stdout, "# Not installing missing %s into %s\n", checkLibFile, o->install); + } + } + + if (pkg_checkFlag(o) == nullptr) { + /* Error occurred. */ + return result; + } +#endif + + if (!o->withoutAssembly && pkgDataFlags[GENCCODE_ASSEMBLY_TYPE][0] != 0) { + const char* genccodeAssembly = pkgDataFlags[GENCCODE_ASSEMBLY_TYPE]; + + if(o->verbose) { + fprintf(stdout, "# Generating assembly code %s of type %s ..\n", gencFilePath, genccodeAssembly); + } + + /* Offset genccodeAssembly by 3 because "-a " */ + if (genccodeAssembly && + (uprv_strlen(genccodeAssembly)>3) && + checkAssemblyHeaderName(genccodeAssembly+3)) { + writeAssemblyCode( + datFileNamePath, + o->tmpDir, + o->entryName, + nullptr, + gencFilePath, + sizeof(gencFilePath)); + + result = pkg_createWithAssemblyCode(targetDir, mode, gencFilePath); + if (result != 0) { + fprintf(stderr, "Error generating assembly code for data.\n"); + return result; + } else if (IN_STATIC_MODE(mode)) { + if(o->install != nullptr) { + if(o->verbose) { + fprintf(stdout, "# Installing static library into %s\n", o->install); + } + result = pkg_installLibrary(o->install, targetDir, noVersion); + } + return result; + } + } else { + fprintf(stderr,"Assembly type \"%s\" is unknown.\n", genccodeAssembly); + return -1; + } + } else { + if(o->verbose) { + fprintf(stdout, "# Writing object code to %s ..\n", gencFilePath); + } + if (o->withoutAssembly) { +#ifdef BUILD_DATA_WITHOUT_ASSEMBLY + result = pkg_createWithoutAssemblyCode(o, targetDir, mode); +#else + /* This error should not occur. */ + fprintf(stderr, "Error- BUILD_DATA_WITHOUT_ASSEMBLY is not defined. Internal error.\n"); +#endif + } else { +#ifdef CAN_WRITE_OBJ_CODE + /* Try to detect the arch type, use nullptr if unsuccessful */ + char optMatchArch[10] = { 0 }; + pkg_createOptMatchArch(optMatchArch); + writeObjectCode( + datFileNamePath, + o->tmpDir, + o->entryName, + (optMatchArch[0] == 0 ? nullptr : optMatchArch), + nullptr, + nullptr, + gencFilePath, + sizeof(gencFilePath), + true); + pkg_destroyOptMatchArch(optMatchArch); +#if U_PLATFORM_IS_LINUX_BASED + result = pkg_generateLibraryFile(targetDir, mode, gencFilePath); +#elif defined(WINDOWS_WITH_MSVC) + result = pkg_createWindowsDLL(mode, gencFilePath, o); +#endif +#elif defined(BUILD_DATA_WITHOUT_ASSEMBLY) + result = pkg_createWithoutAssemblyCode(o, targetDir, mode); +#else + fprintf(stderr, "Error- neither CAN_WRITE_OBJ_CODE nor BUILD_DATA_WITHOUT_ASSEMBLY are defined. Internal error.\n"); + return 1; +#endif + } + + if (result != 0) { + fprintf(stderr, "Error generating package data.\n"); + return result; + } + } +#if !U_PLATFORM_USES_ONLY_WIN32_API + if(!IN_STATIC_MODE(mode)) { + /* Certain platforms uses archive library. (e.g. AIX) */ + if(o->verbose) { + fprintf(stdout, "# Creating data archive library file ..\n"); + } + result = pkg_archiveLibrary(targetDir, o->version, reverseExt); + if (result != 0) { + fprintf(stderr, "Error creating data archive library file.\n"); + return result; + } +#if U_PLATFORM != U_PF_OS400 + if (!noVersion) { + /* Create symbolic links for the final library file. */ +#if U_PLATFORM == U_PF_OS390 + result = pkg_createSymLinks(targetDir, o->pdsbuild); +#else + result = pkg_createSymLinks(targetDir, noVersion); +#endif + if (result != 0) { + fprintf(stderr, "Error creating symbolic links of the data library file.\n"); + return result; + } + } +#endif + } /* !IN_STATIC_MODE */ +#endif + +#if !U_PLATFORM_USES_ONLY_WIN32_API + /* Install the libraries if option was set. */ + if (o->install != nullptr) { + if(o->verbose) { + fprintf(stdout, "# Installing library file to %s ..\n", o->install); + } + result = pkg_installLibrary(o->install, targetDir, noVersion); + if (result != 0) { + fprintf(stderr, "Error installing the data library.\n"); + return result; + } + } +#endif + } + } + return result; +} + +/* Initialize the pkgDataFlags with the option file given. */ +static int32_t initializePkgDataFlags(UPKGOptions *o) { + UErrorCode status = U_ZERO_ERROR; + int32_t result = 0; + int32_t currentBufferSize = SMALL_BUFFER_MAX_SIZE; + int32_t tmpResult = 0; + + /* Initialize pkgdataFlags */ + pkgDataFlags = (char**)uprv_malloc(sizeof(char*) * PKGDATA_FLAGS_SIZE); + + /* If we run out of space, allocate more */ +#if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) + do { +#endif + if (pkgDataFlags != nullptr) { + for (int32_t i = 0; i < PKGDATA_FLAGS_SIZE; i++) { + pkgDataFlags[i] = (char*)uprv_malloc(sizeof(char) * currentBufferSize); + if (pkgDataFlags[i] != nullptr) { + pkgDataFlags[i][0] = 0; + } else { + fprintf(stderr,"Error allocating memory for pkgDataFlags.\n"); + /* If an error occurs, ensure that the rest of the array is nullptr */ + for (int32_t n = i + 1; n < PKGDATA_FLAGS_SIZE; n++) { + pkgDataFlags[n] = nullptr; + } + return -1; + } + } + } else { + fprintf(stderr,"Error allocating memory for pkgDataFlags.\n"); + return -1; + } + + if (o->options == nullptr) { + return result; + } + +#if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) + /* Read in options file. */ + if(o->verbose) { + fprintf(stdout, "# Reading options file %s\n", o->options); + } + status = U_ZERO_ERROR; + tmpResult = parseFlagsFile(o->options, pkgDataFlags, currentBufferSize, FLAG_NAMES, (int32_t)PKGDATA_FLAGS_SIZE, &status); + if (status == U_BUFFER_OVERFLOW_ERROR) { + for (int32_t i = 0; i < PKGDATA_FLAGS_SIZE; i++) { + if (pkgDataFlags[i]) { + uprv_free(pkgDataFlags[i]); + pkgDataFlags[i] = nullptr; + } + } + currentBufferSize = tmpResult; + } else if (U_FAILURE(status)) { + fprintf(stderr,"Unable to open or read \"%s\" option file. status = %s\n", o->options, u_errorName(status)); + return -1; + } +#endif + if(o->verbose) { + fprintf(stdout, "# pkgDataFlags=\n"); + for(int32_t i=0;iverbose) { + fprintf(stdout, "# libFileName[LIB_FILE] = %s\n", libFileNames[LIB_FILE]); + } + +#if U_PLATFORM == U_PF_MINGW + // Name the import library lib*.dll.a + snprintf(libFileNames[LIB_FILE_MINGW], sizeof(libFileNames[LIB_FILE_MINGW]), "lib%s.dll.a", libName); +#elif U_PLATFORM == U_PF_CYGWIN + snprintf(libFileNames[LIB_FILE_CYGWIN], sizeof(libFileNames[LIB_FILE_CYGWIN]), "cyg%s%s%s", + libName, + FILE_EXTENSION_SEP, + pkgDataFlags[SO_EXT]); + snprintf(libFileNames[LIB_FILE_CYGWIN_VERSION], sizeof(libFileNames[LIB_FILE_CYGWIN_VERSION]), "cyg%s%s%s%s", + libName, + version_major, + FILE_EXTENSION_SEP, + pkgDataFlags[SO_EXT]); + + uprv_strcat(pkgDataFlags[SO_EXT], "."); + uprv_strcat(pkgDataFlags[SO_EXT], pkgDataFlags[A_EXT]); +#elif U_PLATFORM == U_PF_OS400 || defined(_AIX) + snprintf(libFileNames[LIB_FILE_VERSION_TMP], sizeof(libFileNames[LIB_FILE_VERSION_TMP]), "%s%s%s", + libFileNames[LIB_FILE], + FILE_EXTENSION_SEP, + pkgDataFlags[SOBJ_EXT]); +#elif U_PLATFORM == U_PF_OS390 + snprintf(libFileNames[LIB_FILE_VERSION_TMP], sizeof(libFileNames[LIB_FILE_VERSION_TMP]), "%s%s%s%s%s", + libFileNames[LIB_FILE], + pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "", + reverseExt ? version : pkgDataFlags[SOBJ_EXT], + FILE_EXTENSION_SEP, + reverseExt ? pkgDataFlags[SOBJ_EXT] : version); + + snprintf(libFileNames[LIB_FILE_OS390BATCH_VERSION], sizeof(libFileNames[LIB_FILE_OS390BATCH_VERSION]), "%s%s.x", + libFileNames[LIB_FILE], + version); + snprintf(libFileNames[LIB_FILE_OS390BATCH_MAJOR], sizeof(libFileNames[LIB_FILE_OS390BATCH_MAJOR]), "%s%s.x", + libFileNames[LIB_FILE], + version_major); +#else + if (noVersion && !reverseExt) { + snprintf(libFileNames[LIB_FILE_VERSION_TMP], sizeof(libFileNames[LIB_FILE_VERSION_TMP]), "%s%s%s", + libFileNames[LIB_FILE], + FILE_SUFFIX, + pkgDataFlags[SOBJ_EXT]); + } else { + snprintf(libFileNames[LIB_FILE_VERSION_TMP], sizeof(libFileNames[LIB_FILE_VERSION_TMP]), "%s%s%s%s%s", + libFileNames[LIB_FILE], + FILE_SUFFIX, + reverseExt ? version : pkgDataFlags[SOBJ_EXT], + FILE_EXTENSION_SEP, + reverseExt ? pkgDataFlags[SOBJ_EXT] : version); + } +#endif + if (noVersion && !reverseExt) { + snprintf(libFileNames[LIB_FILE_VERSION_MAJOR], sizeof(libFileNames[LIB_FILE_VERSION_TMP]), "%s%s%s", + libFileNames[LIB_FILE], + FILE_SUFFIX, + pkgDataFlags[SO_EXT]); + + snprintf(libFileNames[LIB_FILE_VERSION], sizeof(libFileNames[LIB_FILE_VERSION]), "%s%s%s", + libFileNames[LIB_FILE], + FILE_SUFFIX, + pkgDataFlags[SO_EXT]); + } else { + snprintf(libFileNames[LIB_FILE_VERSION_MAJOR], sizeof(libFileNames[LIB_FILE_VERSION_MAJOR]), "%s%s%s%s%s", + libFileNames[LIB_FILE], + FILE_SUFFIX, + reverseExt ? version_major : pkgDataFlags[SO_EXT], + FILE_EXTENSION_SEP, + reverseExt ? pkgDataFlags[SO_EXT] : version_major); + + snprintf(libFileNames[LIB_FILE_VERSION], sizeof(libFileNames[LIB_FILE_VERSION]), "%s%s%s%s%s", + libFileNames[LIB_FILE], + FILE_SUFFIX, + reverseExt ? version : pkgDataFlags[SO_EXT], + FILE_EXTENSION_SEP, + reverseExt ? pkgDataFlags[SO_EXT] : version); + } + + if(o->verbose) { + fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s\n", libFileNames[LIB_FILE_VERSION]); + } + +#if U_PF_MINGW <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN + /* Cygwin and MinGW only deals with the version major number. */ + uprv_strcpy(libFileNames[LIB_FILE_VERSION_TMP], libFileNames[LIB_FILE_VERSION_MAJOR]); +#endif + + if(IN_STATIC_MODE(mode)) { + snprintf(libFileNames[LIB_FILE_VERSION], sizeof(libFileNames[LIB_FILE_VERSION]), "%s.%s", libFileNames[LIB_FILE], pkgDataFlags[A_EXT]); + libFileNames[LIB_FILE_VERSION_MAJOR][0]=0; + if(o->verbose) { + fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s (static)\n", libFileNames[LIB_FILE_VERSION]); + } + } +} + +/* Create the symbolic links for the final library file. */ +static int32_t pkg_createSymLinks(const char *targetDir, UBool specialHandling) { + int32_t result = 0; + char cmd[LARGE_BUFFER_MAX_SIZE]; + char name1[SMALL_BUFFER_MAX_SIZE]; /* symlink file name */ + char name2[SMALL_BUFFER_MAX_SIZE]; /* file name to symlink */ + const char* FILE_EXTENSION_SEP = uprv_strlen(pkgDataFlags[SO_EXT]) == 0 ? "" : "."; + +#if U_PLATFORM != U_PF_CYGWIN + /* No symbolic link to make. */ + if (uprv_strlen(libFileNames[LIB_FILE_VERSION]) == 0 || uprv_strlen(libFileNames[LIB_FILE_VERSION_MAJOR]) == 0 || + uprv_strcmp(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_MAJOR]) == 0) { + return result; + } + + snprintf(cmd, sizeof(cmd), "cd %s && %s %s && %s %s %s", + targetDir, + RM_CMD, + libFileNames[LIB_FILE_VERSION_MAJOR], + LN_CMD, + libFileNames[LIB_FILE_VERSION], + libFileNames[LIB_FILE_VERSION_MAJOR]); + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd); + return result; + } +#endif + + if (specialHandling) { +#if U_PLATFORM == U_PF_CYGWIN + snprintf(name1, sizeof(name1), "%s", libFileNames[LIB_FILE_CYGWIN]); + snprintf(name2, sizeof(name2), "%s", libFileNames[LIB_FILE_CYGWIN_VERSION]); +#elif U_PLATFORM == U_PF_OS390 + /* Create the symbolic links for the import data */ + /* Use the cmd buffer to store path to import data file to check its existence */ + snprintf(cmd, sizeof(cmd), "%s/%s", targetDir, libFileNames[LIB_FILE_OS390BATCH_VERSION]); + if (T_FileStream_file_exists(cmd)) { + snprintf(cmd, sizeof(cmd), "cd %s && %s %s && %s %s %s", + targetDir, + RM_CMD, + libFileNames[LIB_FILE_OS390BATCH_MAJOR], + LN_CMD, + libFileNames[LIB_FILE_OS390BATCH_VERSION], + libFileNames[LIB_FILE_OS390BATCH_MAJOR]); + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd); + return result; + } + + snprintf(cmd, sizeof(cmd), "cd %s && %s %s.x && %s %s %s.x", + targetDir, + RM_CMD, + libFileNames[LIB_FILE], + LN_CMD, + libFileNames[LIB_FILE_OS390BATCH_VERSION], + libFileNames[LIB_FILE]); + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd); + return result; + } + } + + /* Needs to be set here because special handling skips it */ + snprintf(name1, sizeof(name1), "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]); + snprintf(name2, sizeof(name2), "%s", libFileNames[LIB_FILE_VERSION]); +#else + goto normal_symlink_mode; +#endif + } else { +#if U_PLATFORM != U_PF_CYGWIN +normal_symlink_mode: +#endif + snprintf(name1, sizeof(name1), "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]); + snprintf(name2, sizeof(name2), "%s", libFileNames[LIB_FILE_VERSION]); + } + + snprintf(cmd, sizeof(cmd), "cd %s && %s %s && %s %s %s", + targetDir, + RM_CMD, + name1, + LN_CMD, + name2, + name1); + + result = runCommand(cmd); + + return result; +} + +static int32_t pkg_installLibrary(const char *installDir, const char *targetDir, UBool noVersion) { + int32_t result = 0; + char cmd[SMALL_BUFFER_MAX_SIZE]; + + auto ret = snprintf(cmd, + sizeof(cmd), + "cd %s && %s %s %s%s%s", + targetDir, + pkgDataFlags[INSTALL_CMD], + libFileNames[LIB_FILE_VERSION], + installDir, PKGDATA_FILE_SEP_STRING, libFileNames[LIB_FILE_VERSION]); + (void)ret; + U_ASSERT(0 <= ret && ret < SMALL_BUFFER_MAX_SIZE); + + result = runCommand(cmd); + + if (result != 0) { + fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); + return result; + } + +#ifdef CYGWINMSVC + snprintf(cmd, sizeof(cmd), "cd %s && %s %s.lib %s", + targetDir, + pkgDataFlags[INSTALL_CMD], + libFileNames[LIB_FILE], + installDir + ); + result = runCommand(cmd); + + if (result != 0) { + fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); + return result; + } +#elif U_PLATFORM == U_PF_CYGWIN + snprintf(cmd, sizeof(cmd), "cd %s && %s %s %s", + targetDir, + pkgDataFlags[INSTALL_CMD], + libFileNames[LIB_FILE_CYGWIN_VERSION], + installDir + ); + result = runCommand(cmd); + + if (result != 0) { + fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); + return result; + } + +#elif U_PLATFORM == U_PF_OS390 + if (T_FileStream_file_exists(libFileNames[LIB_FILE_OS390BATCH_VERSION])) { + snprintf(cmd, sizeof(cmd), "%s %s %s", + pkgDataFlags[INSTALL_CMD], + libFileNames[LIB_FILE_OS390BATCH_VERSION], + installDir + ); + result = runCommand(cmd); + + if (result != 0) { + fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); + return result; + } + } +#endif + + if (noVersion) { + return result; + } else { + return pkg_createSymLinks(installDir, true); + } +} + +static int32_t pkg_installCommonMode(const char *installDir, const char *fileName) { + int32_t result = 0; + char cmd[SMALL_BUFFER_MAX_SIZE] = ""; + + if (!T_FileStream_file_exists(installDir)) { + UErrorCode status = U_ZERO_ERROR; + + uprv_mkdir(installDir, &status); + if (U_FAILURE(status)) { + fprintf(stderr, "Error creating installation directory: %s\n", installDir); + return -1; + } + } +#ifndef U_WINDOWS_WITH_MSVC + snprintf(cmd, sizeof(cmd), "%s %s %s", pkgDataFlags[INSTALL_CMD], fileName, installDir); +#else + snprintf(cmd, sizeof(cmd), "%s %s %s %s", WIN_INSTALL_CMD, fileName, installDir, WIN_INSTALL_CMD_FLAGS); +#endif + + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Failed to install data file with command: %s\n", cmd); + } + + return result; +} + +#ifdef U_WINDOWS_MSVC +/* Copy commands for installing the raw data files on Windows. */ +#define WIN_INSTALL_CMD "xcopy" +#define WIN_INSTALL_CMD_FLAGS "/E /Y /K" +#endif +static int32_t pkg_installFileMode(const char *installDir, const char *srcDir, const char *fileListName) { + int32_t result = 0; + char cmd[SMALL_BUFFER_MAX_SIZE] = ""; + + if (!T_FileStream_file_exists(installDir)) { + UErrorCode status = U_ZERO_ERROR; + + uprv_mkdir(installDir, &status); + if (U_FAILURE(status)) { + fprintf(stderr, "Error creating installation directory: %s\n", installDir); + return -1; + } + } +#ifndef U_WINDOWS_WITH_MSVC + char buffer[SMALL_BUFFER_MAX_SIZE] = ""; + int32_t bufferLength = 0; + + FileStream *f = T_FileStream_open(fileListName, "r"); + if (f != nullptr) { + for(;;) { + if (T_FileStream_readLine(f, buffer, SMALL_BUFFER_MAX_SIZE) != nullptr) { + bufferLength = static_cast(uprv_strlen(buffer)); + /* Remove new line character. */ + if (bufferLength > 0) { + buffer[bufferLength-1] = 0; + } + + auto ret = snprintf(cmd, + sizeof(cmd), + "%s %s%s%s %s%s%s", + pkgDataFlags[INSTALL_CMD], + srcDir, PKGDATA_FILE_SEP_STRING, buffer, + installDir, PKGDATA_FILE_SEP_STRING, buffer); + (void)ret; + U_ASSERT(0 <= ret && ret < SMALL_BUFFER_MAX_SIZE); + + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Failed to install data file with command: %s\n", cmd); + break; + } + } else { + if (!T_FileStream_eof(f)) { + fprintf(stderr, "Failed to read line from file: %s\n", fileListName); + result = -1; + } + break; + } + } + T_FileStream_close(f); + } else { + result = -1; + fprintf(stderr, "Unable to open list file: %s\n", fileListName); + } +#else + snprintf(cmd, sizeof(cmd), "%s %s %s %s", WIN_INSTALL_CMD, srcDir, installDir, WIN_INSTALL_CMD_FLAGS); + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Failed to install data file with command: %s\n", cmd); + } +#endif + + return result; +} + +/* Archiving of the library file may be needed depending on the platform and options given. + * If archiving is not needed, copy over the library file name. + */ +static int32_t pkg_archiveLibrary(const char *targetDir, const char *version, UBool reverseExt) { + int32_t result = 0; + char cmd[LARGE_BUFFER_MAX_SIZE]; + + /* If the shared object suffix and the final object suffix is different and the final object suffix and the + * archive file suffix is the same, then the final library needs to be archived. + */ + if (uprv_strcmp(pkgDataFlags[SOBJ_EXT], pkgDataFlags[SO_EXT]) != 0 && uprv_strcmp(pkgDataFlags[A_EXT], pkgDataFlags[SO_EXT]) == 0) { + snprintf(libFileNames[LIB_FILE_VERSION], sizeof(libFileNames[LIB_FILE_VERSION]), "%s%s%s.%s", + libFileNames[LIB_FILE], + pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "", + reverseExt ? version : pkgDataFlags[SO_EXT], + reverseExt ? pkgDataFlags[SO_EXT] : version); + + snprintf(cmd, sizeof(cmd), "%s %s %s%s %s%s", + pkgDataFlags[AR], + pkgDataFlags[ARFLAGS], + targetDir, + libFileNames[LIB_FILE_VERSION], + targetDir, + libFileNames[LIB_FILE_VERSION_TMP]); + + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd); + return result; + } + + snprintf(cmd, sizeof(cmd), "%s %s%s", + pkgDataFlags[RANLIB], + targetDir, + libFileNames[LIB_FILE_VERSION]); + + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd); + return result; + } + + /* Remove unneeded library file. */ + snprintf(cmd, sizeof(cmd), "%s %s%s", + RM_CMD, + targetDir, + libFileNames[LIB_FILE_VERSION_TMP]); + + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd); + return result; + } + + } else { + uprv_strcpy(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_TMP]); + } + + return result; +} + +/* + * Using the compiler information from the configuration file set by -O option, generate the library file. + * command may be given to allow for a larger buffer for cmd. + */ +static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command, UBool specialHandling) { + int32_t result = 0; + char *cmd = nullptr; + UBool freeCmd = false; + int32_t length = 0; + + (void)specialHandling; // Suppress unused variable compiler warnings on platforms where all usage + // of this parameter is #ifdefed out. + + /* This is necessary because if packaging is done without assembly code, objectFile might be extremely large + * containing many object files and so the calling function should supply a command buffer that is large + * enough to handle this. Otherwise, use the default size. + */ + if (command != nullptr) { + cmd = command; + } + + if (IN_STATIC_MODE(mode)) { + if (cmd == nullptr) { + length = static_cast(uprv_strlen(pkgDataFlags[AR]) + uprv_strlen(pkgDataFlags[ARFLAGS]) + uprv_strlen(targetDir) + + uprv_strlen(libFileNames[LIB_FILE_VERSION]) + uprv_strlen(objectFile) + uprv_strlen(pkgDataFlags[RANLIB]) + BUFFER_PADDING_SIZE); + if ((cmd = (char *)uprv_malloc(sizeof(char) * length)) == nullptr) { + fprintf(stderr, "Unable to allocate memory for command.\n"); + return -1; + } + freeCmd = true; + } + sprintf(cmd, "%s %s %s%s %s", + pkgDataFlags[AR], + pkgDataFlags[ARFLAGS], + targetDir, + libFileNames[LIB_FILE_VERSION], + objectFile); + + result = runCommand(cmd); + if (result == 0) { + sprintf(cmd, "%s %s%s", + pkgDataFlags[RANLIB], + targetDir, + libFileNames[LIB_FILE_VERSION]); + + result = runCommand(cmd); + } + } else /* if (IN_DLL_MODE(mode)) */ { + if (cmd == nullptr) { + length = static_cast(uprv_strlen(pkgDataFlags[GENLIB]) + uprv_strlen(pkgDataFlags[LDICUDTFLAGS]) + + ((uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_VERSION_TMP])) * 2) + + uprv_strlen(objectFile) + uprv_strlen(pkgDataFlags[LD_SONAME]) + + uprv_strlen(pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR]) + + uprv_strlen(pkgDataFlags[RPATH_FLAGS]) + uprv_strlen(pkgDataFlags[BIR_FLAGS]) + BUFFER_PADDING_SIZE); +#if U_PLATFORM == U_PF_CYGWIN + length += static_cast(uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_CYGWIN_VERSION])); +#elif U_PLATFORM == U_PF_MINGW + length += static_cast(uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_MINGW])); +#endif + if ((cmd = (char *)uprv_malloc(sizeof(char) * length)) == nullptr) { + fprintf(stderr, "Unable to allocate memory for command.\n"); + return -1; + } + freeCmd = true; + } +#if U_PLATFORM == U_PF_MINGW + sprintf(cmd, "%s%s%s %s -o %s%s %s %s%s %s %s", + pkgDataFlags[GENLIB], + targetDir, + libFileNames[LIB_FILE_MINGW], + pkgDataFlags[LDICUDTFLAGS], + targetDir, + libFileNames[LIB_FILE_VERSION_TMP], +#elif U_PLATFORM == U_PF_CYGWIN + sprintf(cmd, "%s%s%s %s -o %s%s %s %s%s %s %s", + pkgDataFlags[GENLIB], + targetDir, + libFileNames[LIB_FILE_VERSION_TMP], + pkgDataFlags[LDICUDTFLAGS], + targetDir, + libFileNames[LIB_FILE_CYGWIN_VERSION], +#elif U_PLATFORM == U_PF_AIX + sprintf(cmd, "%s %s%s;%s %s -o %s%s %s %s%s %s %s", + RM_CMD, + targetDir, + libFileNames[LIB_FILE_VERSION_TMP], + pkgDataFlags[GENLIB], + pkgDataFlags[LDICUDTFLAGS], + targetDir, + libFileNames[LIB_FILE_VERSION_TMP], +#else + sprintf(cmd, "%s %s -o %s%s %s %s%s %s %s", + pkgDataFlags[GENLIB], + pkgDataFlags[LDICUDTFLAGS], + targetDir, + libFileNames[LIB_FILE_VERSION_TMP], +#endif + objectFile, + pkgDataFlags[LD_SONAME], + pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR], + pkgDataFlags[RPATH_FLAGS], + pkgDataFlags[BIR_FLAGS]); + + /* Generate the library file. */ + result = runCommand(cmd); + +#if U_PLATFORM == U_PF_OS390 + char *env_tmp; + char PDS_LibName[512]; + char PDS_Name[512]; + + PDS_Name[0] = 0; + PDS_LibName[0] = 0; + if (specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata") == 0) { + if (env_tmp = getenv("ICU_PDS_NAME")) { + sprintf(PDS_Name, "%s%s", + env_tmp, + "DA"); + strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX")); + } else if (env_tmp = getenv("PDS_NAME_PREFIX")) { + sprintf(PDS_Name, "%s%s", + env_tmp, + U_ICU_VERSION_SHORT "DA"); + } else { + sprintf(PDS_Name, "%s%s", + "IXMI", + U_ICU_VERSION_SHORT "DA"); + } + } else if (!specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata_stub") == 0) { + if (env_tmp = getenv("ICU_PDS_NAME")) { + sprintf(PDS_Name, "%s%s", + env_tmp, + "D1"); + strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX")); + } else if (env_tmp = getenv("PDS_NAME_PREFIX")) { + sprintf(PDS_Name, "%s%s", + env_tmp, + U_ICU_VERSION_SHORT "D1"); + } else { + sprintf(PDS_Name, "%s%s", + "IXMI", + U_ICU_VERSION_SHORT "D1"); + } + } + + if (PDS_Name[0]) { + sprintf(PDS_LibName,"%s%s%s%s%s", + "\"//'", + getenv("LOADMOD"), + "(", + PDS_Name, + ")'\""); + sprintf(cmd, "%s %s -o %s %s %s%s %s %s", + pkgDataFlags[GENLIB], + pkgDataFlags[LDICUDTFLAGS], + PDS_LibName, + objectFile, + pkgDataFlags[LD_SONAME], + pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR], + pkgDataFlags[RPATH_FLAGS], + pkgDataFlags[BIR_FLAGS]); + + result = runCommand(cmd); + } +#endif + } + + if (result != 0) { + fprintf(stderr, "Error generating library file. Failed command: %s\n", cmd); + } + + if (freeCmd) { + uprv_free(cmd); + } + + return result; +} + +static int32_t pkg_createWithAssemblyCode(const char *targetDir, const char mode, const char *gencFilePath) { + char tempObjectFile[SMALL_BUFFER_MAX_SIZE] = ""; + int32_t result = 0; + int32_t length = 0; + + /* Remove the ending .s and replace it with .o for the new object file. */ + uprv_strcpy(tempObjectFile, gencFilePath); + tempObjectFile[uprv_strlen(tempObjectFile)-1] = 'o'; + + length = static_cast(uprv_strlen(pkgDataFlags[COMPILER]) + uprv_strlen(pkgDataFlags[LIBFLAGS]) + + uprv_strlen(tempObjectFile) + uprv_strlen(gencFilePath) + BUFFER_PADDING_SIZE); + + LocalMemory cmd((char *)uprv_malloc(sizeof(char) * length)); + if (cmd.isNull()) { + return -1; + } + + /* Generate the object file. */ + snprintf(cmd.getAlias(), length, "%s %s -o %s %s", + pkgDataFlags[COMPILER], + pkgDataFlags[LIBFLAGS], + tempObjectFile, + gencFilePath); + + result = runCommand(cmd.getAlias()); + + if (result != 0) { + fprintf(stderr, "Error creating with assembly code. Failed command: %s\n", cmd.getAlias()); + return result; + } + + return pkg_generateLibraryFile(targetDir, mode, tempObjectFile); +} + +#ifdef BUILD_DATA_WITHOUT_ASSEMBLY +/* + * Generation of the data library without assembly code needs to compile each data file + * individually and then link it all together. + * Note: Any update to the directory structure of the data needs to be reflected here. + */ +enum { + DATA_PREFIX_BRKITR, + DATA_PREFIX_COLL, + DATA_PREFIX_CURR, + DATA_PREFIX_LANG, + DATA_PREFIX_RBNF, + DATA_PREFIX_REGION, + DATA_PREFIX_TRANSLIT, + DATA_PREFIX_ZONE, + DATA_PREFIX_UNIT, + DATA_PREFIX_LENGTH +}; + +const static char DATA_PREFIX[DATA_PREFIX_LENGTH][10] = { + "brkitr", + "coll", + "curr", + "lang", + "rbnf", + "region", + "translit", + "zone", + "unit" +}; + +static int32_t pkg_createWithoutAssemblyCode(UPKGOptions *o, const char *targetDir, const char mode) { + int32_t result = 0; + CharList *list = o->filePaths; + CharList *listNames = o->files; + int32_t listSize = pkg_countCharList(list); + char *buffer; + char *cmd; + char gencmnFile[SMALL_BUFFER_MAX_SIZE] = ""; + char tempObjectFile[SMALL_BUFFER_MAX_SIZE] = ""; +#ifdef USE_SINGLE_CCODE_FILE + char icudtAll[SMALL_BUFFER_MAX_SIZE] = ""; + FileStream *icudtAllFile = nullptr; + + snprintf(icudtAll, sizeof(icudtAll), "%s%s%sall.c", + o->tmpDir, + PKGDATA_FILE_SEP_STRING, + libFileNames[LIB_FILE]); + /* Remove previous icudtall.c file. */ + if (T_FileStream_file_exists(icudtAll) && (result = remove(icudtAll)) != 0) { + fprintf(stderr, "Unable to remove old icudtall file: %s\n", icudtAll); + return result; + } + + if((icudtAllFile = T_FileStream_open(icudtAll, "w"))==nullptr) { + fprintf(stderr, "Unable to write to icudtall file: %s\n", icudtAll); + return result; + } +#endif + + if (list == nullptr || listNames == nullptr) { + /* list and listNames should never be nullptr since we are looping through the CharList with + * the given size. + */ + return -1; + } + + if ((cmd = (char *)uprv_malloc((listSize + 2) * SMALL_BUFFER_MAX_SIZE)) == nullptr) { + fprintf(stderr, "Unable to allocate memory for cmd.\n"); + return -1; + } else if ((buffer = (char *)uprv_malloc((listSize + 1) * SMALL_BUFFER_MAX_SIZE)) == nullptr) { + fprintf(stderr, "Unable to allocate memory for buffer.\n"); + uprv_free(cmd); + return -1; + } + + for (int32_t i = 0; i < (listSize + 1); i++) { + const char *file ; + const char *name; + + if (i == 0) { + /* The first iteration calls the gencmn function and initializes the buffer. */ + createCommonDataFile(o->tmpDir, o->shortName, o->entryName, nullptr, o->srcDir, o->comment, o->fileListFiles->str, 0, true, o->verbose, gencmnFile); + buffer[0] = 0; +#ifdef USE_SINGLE_CCODE_FILE + uprv_strcpy(tempObjectFile, gencmnFile); + tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o'; + + sprintf(cmd, "%s %s -o %s %s", + pkgDataFlags[COMPILER], + pkgDataFlags[LIBFLAGS], + tempObjectFile, + gencmnFile); + + result = runCommand(cmd); + if (result != 0) { + break; + } + + sprintf(buffer, "%s",tempObjectFile); +#endif + } else { + char newName[SMALL_BUFFER_MAX_SIZE]; + char dataName[SMALL_BUFFER_MAX_SIZE]; + char dataDirName[SMALL_BUFFER_MAX_SIZE]; + const char *pSubstring; + file = list->str; + name = listNames->str; + + newName[0] = dataName[0] = 0; + for (int32_t n = 0; n < DATA_PREFIX_LENGTH; n++) { + dataDirName[0] = 0; + sprintf(dataDirName, "%s%s", DATA_PREFIX[n], PKGDATA_FILE_SEP_STRING); + /* If the name contains a prefix (indicating directory), alter the new name accordingly. */ + pSubstring = uprv_strstr(name, dataDirName); + if (pSubstring != nullptr) { + char newNameTmp[SMALL_BUFFER_MAX_SIZE] = ""; + const char *p = name + uprv_strlen(dataDirName); + for (int32_t i = 0;;i++) { + if (p[i] == '.') { + newNameTmp[i] = '_'; + continue; + } + newNameTmp[i] = p[i]; + if (p[i] == 0) { + break; + } + } + auto ret = snprintf(newName, + sizeof(newName), + "%s_%s", + DATA_PREFIX[n], + newNameTmp); + (void)ret; + U_ASSERT(0 <= ret && ret < SMALL_BUFFER_MAX_SIZE); + ret = snprintf(dataName, + sizeof(dataName), + "%s_%s", + o->shortName, + DATA_PREFIX[n]); + (void)ret; + U_ASSERT(0 <= ret && ret < SMALL_BUFFER_MAX_SIZE); + } + if (newName[0] != 0) { + break; + } + } + + if(o->verbose) { + printf("# Generating %s \n", gencmnFile); + } + + writeCCode( + file, + o->tmpDir, + nullptr, + dataName[0] != 0 ? dataName : o->shortName, + newName[0] != 0 ? newName : nullptr, + gencmnFile, + sizeof(gencmnFile)); + +#ifdef USE_SINGLE_CCODE_FILE + sprintf(cmd, "#include \"%s\"\n", gencmnFile); + T_FileStream_writeLine(icudtAllFile, cmd); + /* don't delete the file */ +#endif + } + +#ifndef USE_SINGLE_CCODE_FILE + uprv_strcpy(tempObjectFile, gencmnFile); + tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o'; + + sprintf(cmd, "%s %s -o %s %s", + pkgDataFlags[COMPILER], + pkgDataFlags[LIBFLAGS], + tempObjectFile, + gencmnFile); + result = runCommand(cmd); + if (result != 0) { + fprintf(stderr, "Error creating library without assembly code. Failed command: %s\n", cmd); + break; + } + + uprv_strcat(buffer, " "); + uprv_strcat(buffer, tempObjectFile); + +#endif + + if (i > 0) { + list = list->next; + listNames = listNames->next; + } + } + +#ifdef USE_SINGLE_CCODE_FILE + T_FileStream_close(icudtAllFile); + uprv_strcpy(tempObjectFile, icudtAll); + tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o'; + + sprintf(cmd, "%s %s -I. -o %s %s", + pkgDataFlags[COMPILER], + pkgDataFlags[LIBFLAGS], + tempObjectFile, + icudtAll); + + result = runCommand(cmd); + if (result == 0) { + uprv_strcat(buffer, " "); + uprv_strcat(buffer, tempObjectFile); + } else { + fprintf(stderr, "Error creating library without assembly code. Failed command: %s\n", cmd); + } +#endif + + if (result == 0) { + /* Generate the library file. */ +#if U_PLATFORM == U_PF_OS390 + result = pkg_generateLibraryFile(targetDir, mode, buffer, cmd, (o->pdsbuild && IN_DLL_MODE(mode))); +#else + result = pkg_generateLibraryFile(targetDir,mode, buffer, cmd); +#endif + } + + uprv_free(buffer); + uprv_free(cmd); + + return result; +} +#endif + +#ifdef WINDOWS_WITH_MSVC +#define LINK_CMD "link.exe /nologo /release /out:" +#define LINK_FLAGS "/NXCOMPAT /DYNAMICBASE /DLL /NOENTRY /MANIFEST:NO /implib:" + +#define LINK_EXTRA_UWP_FLAGS "/APPCONTAINER " +#define LINK_EXTRA_UWP_FLAGS_X86_ONLY "/SAFESEH " + +#define LINK_EXTRA_FLAGS_MACHINE "/MACHINE:" +#define LIB_CMD "LIB.exe /nologo /out:" +#define LIB_FILE "icudt.lib" +#define LIB_EXT UDATA_LIB_SUFFIX +#define DLL_EXT UDATA_SO_SUFFIX + +static int32_t pkg_createWindowsDLL(const char mode, const char *gencFilePath, UPKGOptions *o) { + int32_t result = 0; + char cmd[LARGE_BUFFER_MAX_SIZE]; + if (IN_STATIC_MODE(mode)) { + char staticLibFilePath[SMALL_BUFFER_MAX_SIZE] = ""; + +#ifdef CYGWINMSVC + snprintf(staticLibFilePath, sizeof(staticLibFilePath), "%s%s%s%s%s", + o->targetDir, + PKGDATA_FILE_SEP_STRING, + pkgDataFlags[LIBPREFIX], + o->libName, + LIB_EXT); +#else + snprintf(staticLibFilePath, sizeof(staticLibFilePath), "%s%s%s%s%s", + o->targetDir, + PKGDATA_FILE_SEP_STRING, + (strstr(o->libName, "icudt") ? "s" : ""), + o->libName, + LIB_EXT); +#endif + + snprintf(cmd, sizeof(cmd), "%s\"%s\" \"%s\"", + LIB_CMD, + staticLibFilePath, + gencFilePath); + } else if (IN_DLL_MODE(mode)) { + char dllFilePath[SMALL_BUFFER_MAX_SIZE] = ""; + char libFilePath[SMALL_BUFFER_MAX_SIZE] = ""; + char resFilePath[SMALL_BUFFER_MAX_SIZE] = ""; + char tmpResFilePath[SMALL_BUFFER_MAX_SIZE] = ""; + +#ifdef CYGWINMSVC + uprv_strcpy(dllFilePath, o->targetDir); +#else + uprv_strcpy(dllFilePath, o->srcDir); +#endif + uprv_strcat(dllFilePath, PKGDATA_FILE_SEP_STRING); + uprv_strcpy(libFilePath, dllFilePath); + +#ifdef CYGWINMSVC + uprv_strcat(libFilePath, o->libName); + uprv_strcat(libFilePath, ".lib"); + + uprv_strcat(dllFilePath, o->libName); + uprv_strcat(dllFilePath, o->version); +#else + if (strstr(o->libName, "icudt")) { + uprv_strcat(libFilePath, LIB_FILE); + } else { + uprv_strcat(libFilePath, o->libName); + uprv_strcat(libFilePath, ".lib"); + } + uprv_strcat(dllFilePath, o->entryName); +#endif + uprv_strcat(dllFilePath, DLL_EXT); + + uprv_strcpy(tmpResFilePath, o->tmpDir); + uprv_strcat(tmpResFilePath, PKGDATA_FILE_SEP_STRING); + uprv_strcat(tmpResFilePath, ICUDATA_RES_FILE); + + if (T_FileStream_file_exists(tmpResFilePath)) { + snprintf(resFilePath, sizeof(resFilePath), "\"%s\"", tmpResFilePath); + } + + /* Check if dll file and lib file exists and that it is not newer than genc file. */ + if (!o->rebuild && (T_FileStream_file_exists(dllFilePath) && isFileModTimeLater(dllFilePath, gencFilePath)) && + (T_FileStream_file_exists(libFilePath) && isFileModTimeLater(libFilePath, gencFilePath))) { + if(o->verbose) { + printf("# Not rebuilding %s - up to date.\n", gencFilePath); + } + return 0; + } + + char extraFlags[SMALL_BUFFER_MAX_SIZE] = ""; +#ifdef WINDOWS_WITH_MSVC + if (options[WIN_UWP_BUILD].doesOccur) { + uprv_strcat(extraFlags, LINK_EXTRA_UWP_FLAGS); + + if (options[WIN_DLL_ARCH].doesOccur) { + if (uprv_strcmp(options[WIN_DLL_ARCH].value, "X86") == 0) { + uprv_strcat(extraFlags, LINK_EXTRA_UWP_FLAGS_X86_ONLY); + } + } + } + + if (options[WIN_DLL_ARCH].doesOccur) { + uprv_strcat(extraFlags, LINK_EXTRA_FLAGS_MACHINE); + uprv_strcat(extraFlags, options[WIN_DLL_ARCH].value); + } + +#endif + snprintf(cmd, sizeof(cmd), "%s\"%s\" %s %s\"%s\" \"%s\" %s", + LINK_CMD, + dllFilePath, + extraFlags, + LINK_FLAGS, + libFilePath, + gencFilePath, + resFilePath + ); + } + + result = runCommand(cmd, true); + if (result != 0) { + fprintf(stderr, "Error creating Windows DLL library. Failed command: %s\n", cmd); + } + + return result; +} +#endif + +static UPKGOptions *pkg_checkFlag(UPKGOptions *o) { +#if U_PLATFORM == U_PF_AIX + /* AIX needs a map file. */ + char *flag = nullptr; + int32_t length = 0; + char tmpbuffer[SMALL_BUFFER_MAX_SIZE]; + const char MAP_FILE_EXT[] = ".map"; + FileStream *f = nullptr; + char mapFile[SMALL_BUFFER_MAX_SIZE] = ""; + int32_t start = -1; + uint32_t count = 0; + const char rm_cmd[] = "rm -f all ;"; + + flag = pkgDataFlags[GENLIB]; + + /* This portion of the code removes 'rm -f all' in the GENLIB. + * Only occurs in AIX. + */ + if (uprv_strstr(flag, rm_cmd) != nullptr) { + char *tmpGenlibFlagBuffer = nullptr; + int32_t i, offset; + + length = static_cast(uprv_strlen(flag) + 1); + tmpGenlibFlagBuffer = (char *)uprv_malloc(length); + if (tmpGenlibFlagBuffer == nullptr) { + /* Memory allocation error */ + fprintf(stderr,"Unable to allocate buffer of size: %d.\n", length); + return nullptr; + } + + uprv_strcpy(tmpGenlibFlagBuffer, flag); + + offset = static_cast(uprv_strlen(rm_cmd)); + + for (i = 0; i < (length - offset); i++) { + flag[i] = tmpGenlibFlagBuffer[offset + i]; + } + + /* Zero terminate the string */ + flag[i] = 0; + + uprv_free(tmpGenlibFlagBuffer); + } + + flag = pkgDataFlags[BIR_FLAGS]; + length = static_cast(uprv_strlen(pkgDataFlags[BIR_FLAGS])); + + for (int32_t i = 0; i < length; i++) { + if (flag[i] == MAP_FILE_EXT[count]) { + if (count == 0) { + start = i; + } + count++; + } else { + count = 0; + } + + if (count == uprv_strlen(MAP_FILE_EXT)) { + break; + } + } + + if (start >= 0) { + int32_t index = 0; + for (int32_t i = 0;;i++) { + if (i == start) { + for (int32_t n = 0;;n++) { + if (o->shortName[n] == 0) { + break; + } + tmpbuffer[index++] = o->shortName[n]; + } + } + + tmpbuffer[index++] = flag[i]; + + if (flag[i] == 0) { + break; + } + } + + uprv_memset(flag, 0, length); + uprv_strcpy(flag, tmpbuffer); + + uprv_strcpy(mapFile, o->shortName); + uprv_strcat(mapFile, MAP_FILE_EXT); + + f = T_FileStream_open(mapFile, "w"); + if (f == nullptr) { + fprintf(stderr,"Unable to create map file: %s.\n", mapFile); + return nullptr; + } else { + snprintf(tmpbuffer, sizeof(tmpbuffer), "%s%s ", o->entryName, UDATA_CMN_INTERMEDIATE_SUFFIX); + + T_FileStream_writeLine(f, tmpbuffer); + + T_FileStream_close(f); + } + } +#elif U_PLATFORM == U_PF_CYGWIN || U_PLATFORM == U_PF_MINGW + /* Cygwin needs to change flag options. */ + char *flag = nullptr; + int32_t length = 0; + + flag = pkgDataFlags[GENLIB]; + length = static_cast(uprv_strlen(pkgDataFlags[GENLIB])); + + int32_t position = length - 1; + + for(;position >= 0;position--) { + if (flag[position] == '=') { + position++; + break; + } + } + + uprv_memset(flag + position, 0, length - position); +#elif U_PLATFORM == U_PF_OS400 + /* OS/400 needs to fix the ld options (swap single quote with double quote) */ + char *flag = nullptr; + int32_t length = 0; + + flag = pkgDataFlags[GENLIB]; + length = static_cast(uprv_strlen(pkgDataFlags[GENLIB])); + + int32_t position = length - 1; + + for(int32_t i = 0; i < length; i++) { + if (flag[i] == '\'') { + flag[i] = '\"'; + } + } +#endif + // Don't really need a return value, just need to stop compiler warnings about + // the unused parameter 'o' on platforms where it is not otherwise used. + return o; +} + +static void loadLists(UPKGOptions *o, UErrorCode *status) +{ + CharList *l, *tail = nullptr, *tail2 = nullptr; + FileStream *in; + char line[16384]; + char *linePtr, *lineNext; + const uint32_t lineMax = 16300; + char *tmp; + int32_t tmpLength = 0; + char *s; + int32_t ln=0; /* line number */ + + for(l = o->fileListFiles; l; l = l->next) { + if(o->verbose) { + fprintf(stdout, "# pkgdata: Reading %s..\n", l->str); + } + /* TODO: stdin */ + in = T_FileStream_open(l->str, "r"); /* open files list */ + + if(!in) { + fprintf(stderr, "Error opening <%s>.\n", l->str); + *status = U_FILE_ACCESS_ERROR; + return; + } + + while(T_FileStream_readLine(in, line, sizeof(line))!=nullptr) { /* for each line */ + ln++; + if(uprv_strlen(line)>lineMax) { + fprintf(stderr, "%s:%d - line too long (over %d chars)\n", l->str, (int)ln, (int)lineMax); + exit(1); + } + /* remove spaces at the beginning */ + linePtr = line; + /* On z/OS, disable call to isspace (#9996). Investigate using uprv_isspace instead (#9999) */ +#if U_PLATFORM != U_PF_OS390 + while(isspace(*linePtr)) { + linePtr++; + } +#endif + s=linePtr; + /* remove trailing newline characters */ + while(*s!=0) { + if(*s=='\r' || *s=='\n') { + *s=0; + break; + } + ++s; + } + if((*linePtr == 0) || (*linePtr == '#')) { + continue; /* comment or empty line */ + } + + /* Now, process the line */ + lineNext = nullptr; + + while(linePtr && *linePtr) { /* process space-separated items */ + while(*linePtr == ' ') { + linePtr++; + } + /* Find the next quote */ + if(linePtr[0] == '"') + { + lineNext = uprv_strchr(linePtr+1, '"'); + if(lineNext == nullptr) { + fprintf(stderr, "%s:%d - missing trailing double quote (\")\n", + l->str, (int)ln); + exit(1); + } else { + lineNext++; + if(*lineNext) { + if(*lineNext != ' ') { + fprintf(stderr, "%s:%d - malformed quoted line at position %d, expected ' ' got '%c'\n", + l->str, (int)ln, (int)(lineNext-line), (*lineNext)?*lineNext:'0'); + exit(1); + } + *lineNext = 0; + lineNext++; + } + } + } else { + lineNext = uprv_strchr(linePtr, ' '); + if(lineNext) { + *lineNext = 0; /* terminate at space */ + lineNext++; + } + } + + /* add the file */ + s = (char*)getLongPathname(linePtr); + + /* normal mode.. o->files is just the bare list without package names */ + o->files = pkg_appendToList(o->files, &tail, uprv_strdup(linePtr)); + if(uprv_pathIsAbsolute(s) || s[0] == '.') { + fprintf(stderr, "pkgdata: Error: absolute path encountered. Old style paths are not supported. Use relative paths such as 'fur.res' or 'translit%cfur.res'.\n\tBad path: '%s'\n", U_FILE_SEP_CHAR, s); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + /* The +5 is to add a little extra space for, among other things, PKGDATA_FILE_SEP_STRING */ + tmpLength = static_cast(uprv_strlen(o->srcDir) + uprv_strlen(s) + 5); + if((tmp = (char *)uprv_malloc(tmpLength)) == nullptr) { + fprintf(stderr, "pkgdata: Error: Unable to allocate tmp buffer size: %d\n", tmpLength); + exit(U_MEMORY_ALLOCATION_ERROR); + } + uprv_strcpy(tmp, o->srcDir); + uprv_strcat(tmp, o->srcDir[uprv_strlen(o->srcDir)-1] == U_FILE_SEP_CHAR ? "" : PKGDATA_FILE_SEP_STRING); + uprv_strcat(tmp, s); + o->filePaths = pkg_appendToList(o->filePaths, &tail2, tmp); + linePtr = lineNext; + } /* for each entry on line */ + } /* for each line */ + T_FileStream_close(in); + } /* for each file list file */ +} + +/* Helper for pkg_getPkgDataPath() */ +#if U_HAVE_POPEN +static UBool getPkgDataPath(const char *cmd, UBool verbose, char *buf, size_t items) { + icu::CharString cmdBuf; + UErrorCode status = U_ZERO_ERROR; + icu::LocalPipeFilePointer p; + size_t n; + + cmdBuf.append(cmd, status); + if (verbose) { + fprintf(stdout, "# Calling: %s\n", cmdBuf.data()); + } + p.adoptInstead( popen(cmdBuf.data(), "r") ); + + if (p.isNull() || (n = fread(buf, 1, items-1, p.getAlias())) <= 0) { + fprintf(stderr, "%s: Error calling '%s'\n", progname, cmd); + *buf = 0; + return false; + } + + return true; +} +#endif + +/* Get path to pkgdata.inc. Try pkg-config first, falling back to icu-config. */ +static int32_t pkg_getPkgDataPath(UBool verbose, UOption *option) { +#if U_HAVE_POPEN + static char buf[512] = ""; + UBool pkgconfigIsValid = true; + const char *pkgconfigCmd = "pkg-config --variable=pkglibdir icu-uc"; + const char *icuconfigCmd = "icu-config --incpkgdatafile"; + const char *pkgdata = "pkgdata.inc"; + + if (!getPkgDataPath(pkgconfigCmd, verbose, buf, UPRV_LENGTHOF(buf))) { + if (!getPkgDataPath(icuconfigCmd, verbose, buf, UPRV_LENGTHOF(buf))) { + fprintf(stderr, "%s: icu-config not found. Fix PATH or specify -O option\n", progname); + return -1; + } + + pkgconfigIsValid = false; + } + + for (int32_t length = strlen(buf) - 1; length >= 0; length--) { + if (buf[length] == '\n' || buf[length] == ' ') { + buf[length] = 0; + } else { + break; + } + } + + if (!*buf) { + fprintf(stderr, "%s: Unable to locate pkgdata.inc. Unable to parse the results of '%s'. Check paths or use the -O option to specify the path to pkgdata.inc.\n", progname, pkgconfigIsValid ? pkgconfigCmd : icuconfigCmd); + return -1; + } + + if (pkgconfigIsValid) { + uprv_strcat(buf, U_FILE_SEP_STRING); + uprv_strcat(buf, pkgdata); + } + + buf[strlen(buf)] = 0; + + option->value = buf; + option->doesOccur = true; + + return 0; +#else + return -1; +#endif +} + +#ifdef CAN_WRITE_OBJ_CODE + /* Create optMatchArch for genccode architecture detection */ +static void pkg_createOptMatchArch(char *optMatchArch) { +#if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) + const char* code = "void oma(){}"; + const char* source = "oma.c"; + const char* obj = "oma.obj"; + FileStream* stream = nullptr; + + stream = T_FileStream_open(source,"w"); + if (stream != nullptr) { + T_FileStream_writeLine(stream, code); + T_FileStream_close(stream); + + char cmd[LARGE_BUFFER_MAX_SIZE]; + snprintf(cmd, sizeof(cmd), "%s %s -o %s", + pkgDataFlags[COMPILER], + source, + obj); + + if (runCommand(cmd) == 0){ + sprintf(optMatchArch, "%s", obj); + } + else { + fprintf(stderr, "Failed to compile %s\n", source); + } + if(!T_FileStream_remove(source)){ + fprintf(stderr, "T_FileStream_remove failed to delete %s\n", source); + } + } + else { + fprintf(stderr, "T_FileStream_open failed to open %s for writing\n", source); + } +#endif +} +static void pkg_destroyOptMatchArch(char *optMatchArch) { + if(T_FileStream_file_exists(optMatchArch) && !T_FileStream_remove(optMatchArch)){ + fprintf(stderr, "T_FileStream_remove failed to delete %s\n", optMatchArch); + } +} +#endif diff --git a/tools/icu/patches/75/source/tools/toolutil/pkg_genc.cpp b/tools/icu/patches/75/source/tools/toolutil/pkg_genc.cpp new file mode 100644 index 00000000000000..d51a52c8fff13c --- /dev/null +++ b/tools/icu/patches/75/source/tools/toolutil/pkg_genc.cpp @@ -0,0 +1,1428 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/****************************************************************************** + * Copyright (C) 2009-2016, International Business Machines + * Corporation and others. All Rights Reserved. + ******************************************************************************* + */ +#include "unicode/utypes.h" + +#if U_PLATFORM_HAS_WIN32_API +# define VC_EXTRALEAN +# define WIN32_LEAN_AND_MEAN +# define NOUSER +# define NOSERVICE +# define NOIME +# define NOMCX +#include +#include +# if defined(__clang__) +# include +# endif +# ifdef __GNUC__ +# define WINDOWS_WITH_GNUC +# endif +#endif + +#if U_PLATFORM_IS_LINUX_BASED && U_HAVE_ELF_H +# define U_ELF +#endif + +#ifdef U_ELF +# include +# if defined(ELFCLASS64) +# define U_ELF64 +# endif + /* Old elf.h headers may not have EM_X86_64, or have EM_X8664 instead. */ +# ifndef EM_X86_64 +# define EM_X86_64 62 +# endif +# define ICU_ENTRY_OFFSET 0 +#endif + +#include +#include +#include "unicode/putil.h" +#include "cmemory.h" +#include "cstring.h" +#include "filestrm.h" +#include "toolutil.h" +#include "unicode/uclean.h" +#include "uoptions.h" +#include "pkg_genc.h" +#include "filetools.h" +#include "charstr.h" +#include "unicode/errorcode.h" + +#define MAX_COLUMN ((uint32_t)(0xFFFFFFFFU)) + +#define HEX_0X 0 /* 0x1234 */ +#define HEX_0H 1 /* 01234h */ + +/* prototypes --------------------------------------------------------------- */ +static void +getOutFilename( + const char *inFilename, + const char *destdir, + char *outFilename, + int32_t outFilenameCapacity, + char *entryName, + int32_t entryNameCapacity, + const char *newSuffix, + const char *optFilename); + +static uint32_t +write8(FileStream *out, uint8_t byte, uint32_t column); + +static uint32_t +write32(FileStream *out, uint32_t byte, uint32_t column); + +#if U_PLATFORM == U_PF_OS400 +static uint32_t +write8str(FileStream *out, uint8_t byte, uint32_t column); +#endif +/* -------------------------------------------------------------------------- */ + +/* +Creating Template Files for New Platforms + +Let the cc compiler help you get started. +Compile this program + const unsigned int x[5] = {1, 2, 0xdeadbeef, 0xffffffff, 16}; +with the -S option to produce assembly output. + +For example, this will generate array.s: +gcc -S array.c + +This will produce a .s file that may look like this: + + .file "array.c" + .version "01.01" +gcc2_compiled.: + .globl x + .section .rodata + .align 4 + .type x,@object + .size x,20 +x: + .long 1 + .long 2 + .long -559038737 + .long -1 + .long 16 + .ident "GCC: (GNU) 2.96 20000731 (Red Hat Linux 7.1 2.96-85)" + +which gives a starting point that will compile, and can be transformed +to become the template, generally with some consulting of as docs and +some experimentation. + +If you want ICU to automatically use this assembly, you should +specify "GENCCODE_ASSEMBLY=-a name" in the specific config/mh-* file, +where the name is the compiler or platform that you used in this +assemblyHeader data structure. +*/ +static const struct AssemblyType { + const char *name; + const char *header; + const char *beginLine; + const char *footer; + int8_t hexType; /* HEX_0X or HEX_0h */ +} assemblyHeader[] = { + /* For gcc assemblers, the meaning of .align changes depending on the */ + /* hardware, so we use .balign 16 which always means 16 bytes. */ + /* https://sourceware.org/binutils/docs/as/Pseudo-Ops.html */ + {"gcc", + ".globl %s\n" + "\t.section .note.GNU-stack,\"\",%%progbits\n" + "#ifdef __CET__\n" + "# include \n" + "#endif\n" + "\t.section .rodata\n" + "\t.balign 16\n" + "#ifdef U_HIDE_DATA_SYMBOL\n" + "\t.hidden %s\n" + "#endif\n" + "\t.type %s,%%object\n" + "%s:\n\n", + + ".long ",".size %s, .-%s\n",HEX_0X + }, + {"gcc-darwin", + /*"\t.section __TEXT,__text,regular,pure_instructions\n" + "\t.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n"*/ + ".globl _%s\n" + "#ifdef U_HIDE_DATA_SYMBOL\n" + "\t.private_extern _%s\n" + "#endif\n" + "\t.data\n" + "\t.const\n" + "\t.balign 16\n" + "_%s:\n\n", + + ".long ","",HEX_0X + }, + /* macOS PPC should use `.p2align 4` instead `.balign 16` because is + * unknown pseudo ops for such legacy system*/ + {"gcc-darwin-ppc", + /*"\t.section __TEXT,__text,regular,pure_instructions\n" + "\t.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n"*/ + ".globl _%s\n" + "#ifdef U_HIDE_DATA_SYMBOL\n" + "\t.private_extern _%s\n" + "#endif\n" + "\t.data\n" + "\t.const\n" + "\t.p2align 4\n" + "_%s:\n\n", + + ".long ","",HEX_0X + }, + {"gcc-cygwin", + ".globl _%s\n" + "\t.section .rodata\n" + "\t.balign 16\n" + "_%s:\n\n", + + ".long ","",HEX_0X + }, + {"gcc-mingw64", + ".globl %s\n" + "\t.section .rodata\n" + "\t.balign 16\n" + "%s:\n\n", + + ".long ","",HEX_0X + }, +/* 16 bytes alignment. */ +/* http://docs.oracle.com/cd/E19641-01/802-1947/802-1947.pdf */ + {"sun", + "\t.section \".rodata\"\n" + "\t.align 16\n" + ".globl %s\n" + "%s:\n", + + ".word ","",HEX_0X + }, +/* 16 bytes alignment for sun-x86. */ +/* http://docs.oracle.com/cd/E19963-01/html/821-1608/eoiyg.html */ + {"sun-x86", + "Drodata.rodata:\n" + "\t.type Drodata.rodata,@object\n" + "\t.size Drodata.rodata,0\n" + "\t.globl %s\n" + "\t.align 16\n" + "%s:\n", + + ".4byte ","",HEX_0X + }, +/* 1<<4 bit alignment for aix. */ +/* http://pic.dhe.ibm.com/infocenter/aix/v6r1/index.jsp?topic=%2Fcom.ibm.aix.aixassem%2Fdoc%2Falangref%2Fidalangref_csect_pseudoop.htm */ + {"xlc", + ".globl %s{RO}\n" + "\t.toc\n" + "%s:\n" + "\t.csect %s{RO}, 4\n", + + ".long ","",HEX_0X + }, + {"aCC-ia64", + "\t.file \"%s.s\"\n" + "\t.type %s,@object\n" + "\t.global %s\n" + "\t.secalias .abe$0.rodata, \".rodata\"\n" + "\t.section .abe$0.rodata = \"a\", \"progbits\"\n" + "\t.align 16\n" + "%s::\t", + + "data4 ","",HEX_0X + }, + {"aCC-parisc", + "\t.SPACE $TEXT$\n" + "\t.SUBSPA $LIT$\n" + "%s\n" + "\t.EXPORT %s\n" + "\t.ALIGN 16\n", + + ".WORD ","",HEX_0X + }, +/* align 16 bytes */ +/* http://msdn.microsoft.com/en-us/library/dwa9fwef.aspx */ + {"nasm", + "global %s\n" +#if defined(_WIN32) + "section .rdata align=16\n" +#else + "section .rodata align=16\n" +#endif + "%s:\n", + " dd ","",HEX_0X + }, + { "masm", + "\tTITLE %s\n" + "; generated by genccode\n" + ".386\n" + ".model flat\n" + "\tPUBLIC _%s\n" + "ICUDATA_%s\tSEGMENT READONLY PARA PUBLIC FLAT 'DATA'\n" + "\tALIGN 16\n" + "_%s\tLABEL DWORD\n", + "\tDWORD ","\nICUDATA_%s\tENDS\n\tEND\n",HEX_0H + }, + { "masm64", + "\tTITLE %s\n" + "; generated by genccode\n" + "\tPUBLIC _%s\n" + "ICUDATA_%s\tSEGMENT READONLY 'DATA'\n" + "\tALIGN 16\n" + "_%s\tLABEL DWORD\n", + "\tDWORD ","\nICUDATA_%s\tENDS\n\tEND\n",HEX_0H + } +}; + +static int32_t assemblyHeaderIndex = -1; +static int32_t hexType = HEX_0X; + +U_CAPI UBool U_EXPORT2 +checkAssemblyHeaderName(const char* optAssembly) { + int32_t idx; + assemblyHeaderIndex = -1; + for (idx = 0; idx < UPRV_LENGTHOF(assemblyHeader); idx++) { + if (uprv_strcmp(optAssembly, assemblyHeader[idx].name) == 0) { + assemblyHeaderIndex = idx; + hexType = assemblyHeader[idx].hexType; /* set the hex type */ + return true; + } + } + + return false; +} + +U_CAPI UBool U_EXPORT2 +checkCpuArchitecture(const char* optCpuArch) { + return strcmp(optCpuArch, "x64") == 0 || strcmp(optCpuArch, "x86") == 0 || strcmp(optCpuArch, "arm64") == 0; +} + + +U_CAPI void U_EXPORT2 +printAssemblyHeadersToStdErr() { + int32_t idx; + fprintf(stderr, "%s", assemblyHeader[0].name); + for (idx = 1; idx < UPRV_LENGTHOF(assemblyHeader); idx++) { + fprintf(stderr, ", %s", assemblyHeader[idx].name); + } + fprintf(stderr, + ")\n"); +} + +U_CAPI void U_EXPORT2 +writeAssemblyCode( + const char *filename, + const char *destdir, + const char *optEntryPoint, + const char *optFilename, + char *outFilePath, + size_t outFilePathCapacity) { + uint32_t column = MAX_COLUMN; + char entry[96]; + union { + uint32_t uint32s[1024]; + char chars[4096]; + } buffer; + FileStream *in, *out; + size_t i, length, count; + + in=T_FileStream_open(filename, "rb"); + if(in==nullptr) { + fprintf(stderr, "genccode: unable to open input file %s\n", filename); + exit(U_FILE_ACCESS_ERROR); + } + + const char* newSuffix = nullptr; + + if (uprv_strcmp(assemblyHeader[assemblyHeaderIndex].name, "masm") == 0) { + newSuffix = ".masm"; + } + else if (uprv_strcmp(assemblyHeader[assemblyHeaderIndex].name, "nasm") == 0) { + newSuffix = ".asm"; + } else { + newSuffix = ".S"; + } + + getOutFilename( + filename, + destdir, + buffer.chars, + sizeof(buffer.chars), + entry, + sizeof(entry), + newSuffix, + optFilename); + out=T_FileStream_open(buffer.chars, "w"); + if(out==nullptr) { + fprintf(stderr, "genccode: unable to open output file %s\n", buffer.chars); + exit(U_FILE_ACCESS_ERROR); + } + + if (outFilePath != nullptr) { + if (uprv_strlen(buffer.chars) >= outFilePathCapacity) { + fprintf(stderr, "genccode: filename too long\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + uprv_strcpy(outFilePath, buffer.chars); +#if defined (WINDOWS_WITH_GNUC) && U_PLATFORM != U_PF_CYGWIN + /* Need to fix the file separator character when using MinGW. */ + swapFileSepChar(outFilePath, U_FILE_SEP_CHAR, '/'); +#endif + } + + if(optEntryPoint != nullptr) { + uprv_strcpy(entry, optEntryPoint); + uprv_strcat(entry, "_dat"); + } + + /* turn dashes or dots in the entry name into underscores */ + length=uprv_strlen(entry); + for(i=0; i= sizeof(buffer.chars)) { + fprintf(stderr, "genccode: entry name too long (long filename?)\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + T_FileStream_writeLine(out, buffer.chars); + T_FileStream_writeLine(out, assemblyHeader[assemblyHeaderIndex].beginLine); + + for(;;) { + memset(buffer.uint32s, 0, sizeof(buffer.uint32s)); + length=T_FileStream_read(in, buffer.uint32s, sizeof(buffer.uint32s)); + if(length==0) { + break; + } + for(i=0; i<(length/sizeof(buffer.uint32s[0])); i++) { + // TODO: What if the last read sees length not as a multiple of 4? + column = write32(out, buffer.uint32s[i], column); + } + } + + T_FileStream_writeLine(out, "\n"); + + count = snprintf( + buffer.chars, sizeof(buffer.chars), + assemblyHeader[assemblyHeaderIndex].footer, + entry, entry, entry, entry, + entry, entry, entry, entry); + if (count >= sizeof(buffer.chars)) { + fprintf(stderr, "genccode: entry name too long (long filename?)\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + T_FileStream_writeLine(out, buffer.chars); + + if(T_FileStream_error(in)) { + fprintf(stderr, "genccode: file read error while generating from file %s\n", filename); + exit(U_FILE_ACCESS_ERROR); + } + + if(T_FileStream_error(out)) { + fprintf(stderr, "genccode: file write error while generating from file %s\n", filename); + exit(U_FILE_ACCESS_ERROR); + } + + T_FileStream_close(out); + T_FileStream_close(in); +} + +U_CAPI void U_EXPORT2 +writeCCode( + const char *filename, + const char *destdir, + const char *optEntryPoint, + const char *optName, + const char *optFilename, + char *outFilePath, + size_t outFilePathCapacity) { + uint32_t column = MAX_COLUMN; + char buffer[4096], entry[96]; + FileStream *in, *out; + size_t i, length, count; + + in=T_FileStream_open(filename, "rb"); + if(in==nullptr) { + fprintf(stderr, "genccode: unable to open input file %s\n", filename); + exit(U_FILE_ACCESS_ERROR); + } + + if(optName != nullptr) { /* prepend 'icudt28_' */ + // +2 includes the _ and the NUL + if (uprv_strlen(optName) + 2 > sizeof(entry)) { + fprintf(stderr, "genccode: entry name too long (long filename?)\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + strcpy(entry, optName); + strcat(entry, "_"); + } else { + entry[0] = 0; + } + + getOutFilename( + filename, + destdir, + buffer, + static_cast(sizeof(buffer)), + entry + uprv_strlen(entry), + static_cast(sizeof(entry) - uprv_strlen(entry)), + ".c", + optFilename); + + if (outFilePath != nullptr) { + if (uprv_strlen(buffer) >= outFilePathCapacity) { + fprintf(stderr, "genccode: filename too long\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + uprv_strcpy(outFilePath, buffer); +#if defined (WINDOWS_WITH_GNUC) && U_PLATFORM != U_PF_CYGWIN + /* Need to fix the file separator character when using MinGW. */ + swapFileSepChar(outFilePath, U_FILE_SEP_CHAR, '/'); +#endif + } + + out=T_FileStream_open(buffer, "w"); + if(out==nullptr) { + fprintf(stderr, "genccode: unable to open output file %s\n", buffer); + exit(U_FILE_ACCESS_ERROR); + } + + if(optEntryPoint != nullptr) { + uprv_strcpy(entry, optEntryPoint); + uprv_strcat(entry, "_dat"); + } + + /* turn dashes or dots in the entry name into underscores */ + length=uprv_strlen(entry); + for(i=0; i= sizeof(buffer)) { + fprintf(stderr, "genccode: entry name too long (long filename?)\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + T_FileStream_writeLine(out, buffer); + + for(;;) { + length=T_FileStream_read(in, buffer, sizeof(buffer)); + if(length==0) { + break; + } + for(i=0; i= sizeof(buffer)) { + fprintf(stderr, "genccode: entry name too long (long filename?)\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + T_FileStream_writeLine(out, buffer); + + for(;;) { + length=T_FileStream_read(in, buffer, sizeof(buffer)); + if(length==0) { + break; + } + for(i=0; i= 0 ; i--) +#endif + { + uint8_t value = ptrIdx[i]; + if (value || seenNonZero) { + *(s++)=hexToStr[value>>4]; + *(s++)=hexToStr[value&0xF]; + seenNonZero = 1; + } + } + if(hexType==HEX_0H) { + *(s++)='h'; + } + } + + *(s++)=0; + T_FileStream_writeLine(out, bitFieldStr); + return column; +} + +static uint32_t +write8(FileStream *out, uint8_t byte, uint32_t column) { + char s[4]; + int i=0; + + /* convert the byte value to a string */ + if(byte>=100) { + s[i++]=(char)('0'+byte/100); + byte%=100; + } + if(i>0 || byte>=10) { + s[i++]=(char)('0'+byte/10); + byte%=10; + } + s[i++]=(char)('0'+byte); + s[i]=0; + + /* write the value, possibly with comma and newline */ + if(column==MAX_COLUMN) { + /* first byte */ + column=1; + } else if(column<16) { + T_FileStream_writeLine(out, ","); + ++column; + } else { + T_FileStream_writeLine(out, ",\n"); + column=1; + } + T_FileStream_writeLine(out, s); + return column; +} + +#if U_PLATFORM == U_PF_OS400 +static uint32_t +write8str(FileStream *out, uint8_t byte, uint32_t column) { + char s[8]; + + if (byte > 7) + snprintf(s, sizeof(s), "\\x%X", byte); + else + snprintf(s, sizeof(s), "\\%X", byte); + + /* write the value, possibly with comma and newline */ + if(column==MAX_COLUMN) { + /* first byte */ + column=1; + T_FileStream_writeLine(out, "\""); + } else if(column<24) { + ++column; + } else { + T_FileStream_writeLine(out, "\"\n\""); + column=1; + } + T_FileStream_writeLine(out, s); + return column; +} +#endif + +static void +getOutFilename( + const char *inFilename, + const char *destdir, + char *outFilename, + int32_t outFilenameCapacity, + char *entryName, + int32_t entryNameCapacity, + const char *newSuffix, + const char *optFilename) { + const char *basename=findBasename(inFilename), *suffix=uprv_strrchr(basename, '.'); + + icu::CharString outFilenameBuilder; + icu::CharString entryNameBuilder; + icu::ErrorCode status; + + /* copy path */ + if(destdir!=nullptr && *destdir!=0) { + outFilenameBuilder.append(destdir, status); + outFilenameBuilder.ensureEndsWithFileSeparator(status); + } else { + outFilenameBuilder.append(inFilename, static_cast(basename - inFilename), status); + } + inFilename=basename; + + if(suffix==nullptr) { + /* the filename does not have a suffix */ + entryNameBuilder.append(inFilename, status); + if(optFilename != nullptr) { + outFilenameBuilder.append(optFilename, status); + } else { + outFilenameBuilder.append(inFilename, status); + } + outFilenameBuilder.append(newSuffix, status); + } else { + int32_t saveOutFilenameLength = outFilenameBuilder.length(); + /* copy basename */ + while(inFilename= outFilenameCapacity) { + fprintf(stderr, "genccode: output filename too long\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + + if (entryNameBuilder.length() >= entryNameCapacity) { + fprintf(stderr, "genccode: entry name too long (long filename?)\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + + outFilenameBuilder.extract(outFilename, outFilenameCapacity, status); + entryNameBuilder.extract(entryName, entryNameCapacity, status); +} + +#ifdef CAN_GENERATE_OBJECTS +static void +getArchitecture( + uint16_t *pCPU, + uint16_t *pBits, + UBool *pIsBigEndian, + const char *optMatchArch, + [[maybe_unused]] const char *optCpuArch) { + union { + char bytes[2048]; +#ifdef U_ELF + Elf32_Ehdr header32; + /* Elf32_Ehdr and ELF64_Ehdr are identical for the necessary fields. */ +#elif U_PLATFORM_HAS_WIN32_API + IMAGE_FILE_HEADER header; +#endif + } buffer; + + const char *filename; + FileStream *in; + int32_t length; + +#ifdef U_ELF + +#elif U_PLATFORM_HAS_WIN32_API + const IMAGE_FILE_HEADER *pHeader; +#else +# error "Unknown platform for CAN_GENERATE_OBJECTS." +#endif + + if(optMatchArch != nullptr) { + filename=optMatchArch; + } else { + /* set defaults */ +#ifdef U_ELF + /* set EM_386 because elf.h does not provide better defaults */ + *pCPU=EM_386; + *pBits=32; + *pIsBigEndian=(UBool)(U_IS_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB); +#elif U_PLATFORM_HAS_WIN32_API + // Windows always runs in little-endian mode. + *pIsBigEndian = false; + + // Note: The various _M_ macros are predefined by the MSVC compiler based + // on the target compilation architecture. + // https://docs.microsoft.com/cpp/preprocessor/predefined-macros + + // link.exe will link an IMAGE_FILE_MACHINE_UNKNOWN data-only .obj file + // no matter what architecture it is targeting (though other values are + // required to match). Unfortunately, the variable name decoration/mangling + // is slightly different on x86, which means we can't use the UNKNOWN type + // for all architectures though. +# if defined(_M_IX86) + *pCPU = IMAGE_FILE_MACHINE_I386; +# else + // Linker for ClangCL doesn't handle IMAGE_FILE_MACHINE_UNKNOWN the same as + // linker for MSVC. Because of this optCpuArch is used to define the CPU + // architecture in that case. While _M_AMD64 and _M_ARM64 could be used, + // this would potentially be problematic when cross-compiling as this code + // would most likely be ran on host machine to generate the .obj file for + // the target architecture. +# if defined(__clang__) + if (strcmp(optCpuArch, "x64") == 0) { + *pCPU = IMAGE_FILE_MACHINE_AMD64; + } else if (strcmp(optCpuArch, "x86") == 0) { + *pCPU = IMAGE_FILE_MACHINE_I386; + } else if (strcmp(optCpuArch, "arm64") == 0) { + *pCPU = IMAGE_FILE_MACHINE_ARM64; + } else { + std::terminate(); // Unreachable. + } +# else + *pCPU = IMAGE_FILE_MACHINE_UNKNOWN; +# endif +# endif +# if defined(_M_IA64) || defined(_M_AMD64) || defined (_M_ARM64) + *pBits = 64; // Doesn't seem to be used for anything interesting though? +# elif defined(_M_IX86) || defined(_M_ARM) + *pBits = 32; +# else +# error "Unknown platform for CAN_GENERATE_OBJECTS." +# endif +#else +# error "Unknown platform for CAN_GENERATE_OBJECTS." +#endif + return; + } + + in=T_FileStream_open(filename, "rb"); + if(in==nullptr) { + fprintf(stderr, "genccode: unable to open match-arch file %s\n", filename); + exit(U_FILE_ACCESS_ERROR); + } + length=T_FileStream_read(in, buffer.bytes, sizeof(buffer.bytes)); + +#ifdef U_ELF + if(length<(int32_t)sizeof(Elf32_Ehdr)) { + fprintf(stderr, "genccode: match-arch file %s is too short\n", filename); + exit(U_UNSUPPORTED_ERROR); + } + if( + buffer.header32.e_ident[0]!=ELFMAG0 || + buffer.header32.e_ident[1]!=ELFMAG1 || + buffer.header32.e_ident[2]!=ELFMAG2 || + buffer.header32.e_ident[3]!=ELFMAG3 || + buffer.header32.e_ident[EI_CLASS]ELFCLASS64 + ) { + fprintf(stderr, "genccode: match-arch file %s is not an ELF object file, or not supported\n", filename); + exit(U_UNSUPPORTED_ERROR); + } + + *pBits= buffer.header32.e_ident[EI_CLASS]==ELFCLASS32 ? 32 : 64; /* only 32 or 64: see check above */ +#ifdef U_ELF64 + if(*pBits!=32 && *pBits!=64) { + fprintf(stderr, "genccode: currently only supports 32-bit and 64-bit ELF format\n"); + exit(U_UNSUPPORTED_ERROR); + } +#else + if(*pBits!=32) { + fprintf(stderr, "genccode: built with elf.h missing 64-bit definitions\n"); + exit(U_UNSUPPORTED_ERROR); + } +#endif + + *pIsBigEndian=(UBool)(buffer.header32.e_ident[EI_DATA]==ELFDATA2MSB); + if(*pIsBigEndian!=U_IS_BIG_ENDIAN) { + fprintf(stderr, "genccode: currently only same-endianness ELF formats are supported\n"); + exit(U_UNSUPPORTED_ERROR); + } + /* TODO: Support byte swapping */ + + *pCPU=buffer.header32.e_machine; +#elif U_PLATFORM_HAS_WIN32_API + if(lengthMachine; + /* + * The number of bits is implicit with the Machine value. + * *pBits is ignored in the calling code, so this need not be precise. + */ + *pBits= *pCPU==IMAGE_FILE_MACHINE_I386 ? 32 : 64; + /* Windows always runs on little-endian CPUs. */ + *pIsBigEndian=false; +#else +# error "Unknown platform for CAN_GENERATE_OBJECTS." +#endif + + T_FileStream_close(in); +} + +U_CAPI void U_EXPORT2 +writeObjectCode( + const char *filename, + const char *destdir, + const char *optEntryPoint, + const char *optMatchArch, + const char *optCpuArch, + const char *optFilename, + char *outFilePath, + size_t outFilePathCapacity, + UBool optWinDllExport) { + /* common variables */ + char buffer[4096], entry[96]={ 0 }; + FileStream *in, *out; + const char *newSuffix; + int32_t i, entryLength, length, size, entryOffset=0, entryLengthOffset=0; + + uint16_t cpu, bits; + UBool makeBigEndian; + + (void)optWinDllExport; /* unused except Windows */ + + /* platform-specific variables and initialization code */ +#ifdef U_ELF + /* 32-bit Elf file header */ + static Elf32_Ehdr header32={ + { + /* e_ident[] */ + ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, + ELFCLASS32, + U_IS_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB, + EV_CURRENT /* EI_VERSION */ + }, + ET_REL, + EM_386, + EV_CURRENT, /* e_version */ + 0, /* e_entry */ + 0, /* e_phoff */ + (Elf32_Off)sizeof(Elf32_Ehdr), /* e_shoff */ + 0, /* e_flags */ + (Elf32_Half)sizeof(Elf32_Ehdr), /* eh_size */ + 0, /* e_phentsize */ + 0, /* e_phnum */ + (Elf32_Half)sizeof(Elf32_Shdr), /* e_shentsize */ + 5, /* e_shnum */ + 2 /* e_shstrndx */ + }; + + /* 32-bit Elf section header table */ + static Elf32_Shdr sectionHeaders32[5]={ + { /* SHN_UNDEF */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }, + { /* .symtab */ + 1, /* sh_name */ + SHT_SYMTAB, + 0, /* sh_flags */ + 0, /* sh_addr */ + (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)), /* sh_offset */ + (Elf32_Word)(2*sizeof(Elf32_Sym)), /* sh_size */ + 3, /* sh_link=sect hdr index of .strtab */ + 1, /* sh_info=One greater than the symbol table index of the last + * local symbol (with STB_LOCAL). */ + 4, /* sh_addralign */ + (Elf32_Word)(sizeof(Elf32_Sym)) /* sh_entsize */ + }, + { /* .shstrtab */ + 9, /* sh_name */ + SHT_STRTAB, + 0, /* sh_flags */ + 0, /* sh_addr */ + (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)+2*sizeof(Elf32_Sym)), /* sh_offset */ + 40, /* sh_size */ + 0, /* sh_link */ + 0, /* sh_info */ + 1, /* sh_addralign */ + 0 /* sh_entsize */ + }, + { /* .strtab */ + 19, /* sh_name */ + SHT_STRTAB, + 0, /* sh_flags */ + 0, /* sh_addr */ + (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)+2*sizeof(Elf32_Sym)+40), /* sh_offset */ + (Elf32_Word)sizeof(entry), /* sh_size */ + 0, /* sh_link */ + 0, /* sh_info */ + 1, /* sh_addralign */ + 0 /* sh_entsize */ + }, + { /* .rodata */ + 27, /* sh_name */ + SHT_PROGBITS, + SHF_ALLOC, /* sh_flags */ + 0, /* sh_addr */ + (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)+2*sizeof(Elf32_Sym)+40+sizeof(entry)), /* sh_offset */ + 0, /* sh_size */ + 0, /* sh_link */ + 0, /* sh_info */ + 16, /* sh_addralign */ + 0 /* sh_entsize */ + } + }; + + /* symbol table */ + static Elf32_Sym symbols32[2]={ + { /* STN_UNDEF */ + 0, 0, 0, 0, 0, 0 + }, + { /* data entry point */ + 1, /* st_name */ + 0, /* st_value */ + 0, /* st_size */ + ELF64_ST_INFO(STB_GLOBAL, STT_OBJECT), + 0, /* st_other */ + 4 /* st_shndx=index of related section table entry */ + } + }; + + /* section header string table, with decimal string offsets */ + static const char sectionStrings[40]= + /* 0 */ "\0" + /* 1 */ ".symtab\0" + /* 9 */ ".shstrtab\0" + /* 19 */ ".strtab\0" + /* 27 */ ".rodata\0" + /* 35 */ "\0\0\0\0"; /* contains terminating NUL */ + /* 40: padded to multiple of 8 bytes */ + + /* + * Use entry[] for the string table which will contain only the + * entry point name. + * entry[0] must be 0 (NUL) + * The entry point name can be up to 38 characters long (sizeof(entry)-2). + */ + + /* 16-align .rodata in the .o file, just in case */ + static const char padding[16]={ 0 }; + int32_t paddingSize; + +#ifdef U_ELF64 + /* 64-bit Elf file header */ + static Elf64_Ehdr header64={ + { + /* e_ident[] */ + ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, + ELFCLASS64, + U_IS_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB, + EV_CURRENT /* EI_VERSION */ + }, + ET_REL, + EM_X86_64, + EV_CURRENT, /* e_version */ + 0, /* e_entry */ + 0, /* e_phoff */ + (Elf64_Off)sizeof(Elf64_Ehdr), /* e_shoff */ + 0, /* e_flags */ + (Elf64_Half)sizeof(Elf64_Ehdr), /* eh_size */ + 0, /* e_phentsize */ + 0, /* e_phnum */ + (Elf64_Half)sizeof(Elf64_Shdr), /* e_shentsize */ + 5, /* e_shnum */ + 2 /* e_shstrndx */ + }; + + /* 64-bit Elf section header table */ + static Elf64_Shdr sectionHeaders64[5]={ + { /* SHN_UNDEF */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }, + { /* .symtab */ + 1, /* sh_name */ + SHT_SYMTAB, + 0, /* sh_flags */ + 0, /* sh_addr */ + (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)), /* sh_offset */ + (Elf64_Xword)(2*sizeof(Elf64_Sym)), /* sh_size */ + 3, /* sh_link=sect hdr index of .strtab */ + 1, /* sh_info=One greater than the symbol table index of the last + * local symbol (with STB_LOCAL). */ + 4, /* sh_addralign */ + (Elf64_Xword)(sizeof(Elf64_Sym)) /* sh_entsize */ + }, + { /* .shstrtab */ + 9, /* sh_name */ + SHT_STRTAB, + 0, /* sh_flags */ + 0, /* sh_addr */ + (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)+2*sizeof(Elf64_Sym)), /* sh_offset */ + 40, /* sh_size */ + 0, /* sh_link */ + 0, /* sh_info */ + 1, /* sh_addralign */ + 0 /* sh_entsize */ + }, + { /* .strtab */ + 19, /* sh_name */ + SHT_STRTAB, + 0, /* sh_flags */ + 0, /* sh_addr */ + (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)+2*sizeof(Elf64_Sym)+40), /* sh_offset */ + (Elf64_Xword)sizeof(entry), /* sh_size */ + 0, /* sh_link */ + 0, /* sh_info */ + 1, /* sh_addralign */ + 0 /* sh_entsize */ + }, + { /* .rodata */ + 27, /* sh_name */ + SHT_PROGBITS, + SHF_ALLOC, /* sh_flags */ + 0, /* sh_addr */ + (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)+2*sizeof(Elf64_Sym)+40+sizeof(entry)), /* sh_offset */ + 0, /* sh_size */ + 0, /* sh_link */ + 0, /* sh_info */ + 16, /* sh_addralign */ + 0 /* sh_entsize */ + } + }; + + /* + * 64-bit symbol table + * careful: different order of items compared with Elf32_sym! + */ + static Elf64_Sym symbols64[2]={ + { /* STN_UNDEF */ + 0, 0, 0, 0, 0, 0 + }, + { /* data entry point */ + 1, /* st_name */ + ELF64_ST_INFO(STB_GLOBAL, STT_OBJECT), + 0, /* st_other */ + 4, /* st_shndx=index of related section table entry */ + 0, /* st_value */ + 0 /* st_size */ + } + }; + +#endif /* U_ELF64 */ + + /* entry[] have a leading NUL */ + entryOffset=1; + + /* in the common code, count entryLength from after the NUL */ + entryLengthOffset=1; + + newSuffix=".o"; + +#elif U_PLATFORM_HAS_WIN32_API + struct { + IMAGE_FILE_HEADER fileHeader; + IMAGE_SECTION_HEADER sections[2]; + char linkerOptions[100]; + } objHeader; + IMAGE_SYMBOL symbols[1]; + struct { + DWORD sizeofLongNames; + char longNames[100]; + } symbolNames; + + /* + * entry sometimes have a leading '_' + * overwritten if entryOffset==0 depending on the target platform + * see check for cpu below + */ + entry[0]='_'; + + newSuffix=".obj"; +#else +# error "Unknown platform for CAN_GENERATE_OBJECTS." +#endif + + /* deal with options, files and the entry point name */ + getArchitecture(&cpu, &bits, &makeBigEndian, optMatchArch, optCpuArch); + if (optMatchArch) + { + printf("genccode: --match-arch cpu=%hu bits=%hu big-endian=%d\n", cpu, bits, makeBigEndian); + } + else + { + printf("genccode: using architecture cpu=%hu bits=%hu big-endian=%d\n", cpu, bits, makeBigEndian); + } +#if U_PLATFORM_HAS_WIN32_API + if(cpu==IMAGE_FILE_MACHINE_I386) { + entryOffset=1; + } +#endif + + in=T_FileStream_open(filename, "rb"); + if(in==nullptr) { + fprintf(stderr, "genccode: unable to open input file %s\n", filename); + exit(U_FILE_ACCESS_ERROR); + } + size=T_FileStream_size(in); + + getOutFilename( + filename, + destdir, + buffer, + sizeof(buffer), + entry + entryOffset, + sizeof(entry) - entryOffset, + newSuffix, + optFilename); + + if (outFilePath != nullptr) { + if (uprv_strlen(buffer) >= outFilePathCapacity) { + fprintf(stderr, "genccode: filename too long\n"); + exit(U_ILLEGAL_ARGUMENT_ERROR); + } + uprv_strcpy(outFilePath, buffer); + } + + if(optEntryPoint != nullptr) { + uprv_strcpy(entry+entryOffset, optEntryPoint); + uprv_strcat(entry+entryOffset, "_dat"); + } + /* turn dashes in the entry name into underscores */ + entryLength=(int32_t)uprv_strlen(entry+entryLengthOffset); + for(i=0; i Date: Tue, 27 Aug 2024 15:11:04 -0400 Subject: [PATCH 58/90] doc: fix information about including coverage files PR-URL: https://github.com/nodejs/node/pull/54527 Reviewed-By: Moshe Atlow Reviewed-By: Benjamin Gruenbaum Reviewed-By: James M Snell Reviewed-By: Colin Ihrig --- doc/api/test.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/api/test.md b/doc/api/test.md index 8cb53b1363923f..42cf30728b03d2 100644 --- a/doc/api/test.md +++ b/doc/api/test.md @@ -474,7 +474,8 @@ command-line flag, code coverage is collected and statistics are reported once all tests have completed. If the [`NODE_V8_COVERAGE`][] environment variable is used to specify a code coverage directory, the generated V8 coverage files are written to that directory. Node.js core modules and files within -`node_modules/` directories are not included in the coverage report. If +`node_modules/` directories are, by default, not included in the coverage report. +However, they can be explicity included via the [`--test-coverage-include`][] flag. If coverage is enabled, the coverage report is sent to any [test reporters][] via the `'test:coverage'` event. @@ -3497,6 +3498,7 @@ Can be used to abort test subtasks when the test has been aborted. [`--experimental-test-snapshots`]: cli.md#--experimental-test-snapshots [`--import`]: cli.md#--importmodule [`--test-concurrency`]: cli.md#--test-concurrency +[`--test-coverage-include`]: cli.md#--test-coverage-include [`--test-name-pattern`]: cli.md#--test-name-pattern [`--test-only`]: cli.md#--test-only [`--test-reporter-destination`]: cli.md#--test-reporter-destination From 72345dee1cc249a0af62108ff2880bfd815b7d15 Mon Sep 17 00:00:00 2001 From: Vladimir Morozov Date: Tue, 27 Aug 2024 14:30:50 -0700 Subject: [PATCH 59/90] test: fix embedding test for Windows PR-URL: https://github.com/nodejs/node/pull/53659 Reviewed-By: Yagiz Nizipli Reviewed-By: Rafael Gonzaga Reviewed-By: Stefan Stojanovic Reviewed-By: Chengzhong Wu Reviewed-By: Joyee Cheung Reviewed-By: James M Snell Reviewed-By: Luigi Pinca --- test/embedding/test-embedding.js | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/test/embedding/test-embedding.js b/test/embedding/test-embedding.js index 5f706eb5666dd0..71c4f7f324c973 100644 --- a/test/embedding/test-embedding.js +++ b/test/embedding/test-embedding.js @@ -10,6 +10,7 @@ const { } = require('../common/child_process'); const path = require('path'); const fs = require('fs'); +const os = require('os'); tmpdir.refresh(); common.allowGlobals(global.require); @@ -152,12 +153,6 @@ for (const extraSnapshotArgs of [ { cwd: tmpdir.path }); } -// Skipping rest of the test on Windows because it fails in the CI -// TODO(StefanStojanovic): Reenable rest of the test after fixing it -if (common.isWindows) { - return; -} - // Guarantee NODE_REPL_EXTERNAL_MODULE won't bypass kDisableNodeOptionsEnv { spawnSyncAndExit( @@ -172,6 +167,6 @@ if (common.isWindows) { { status: 9, signal: null, - stderr: `${binary}: NODE_REPL_EXTERNAL_MODULE can't be used with kDisableNodeOptionsEnv\n`, + stderr: `${binary}: NODE_REPL_EXTERNAL_MODULE can't be used with kDisableNodeOptionsEnv${os.EOL}`, }); } From 7fd033fe56fd0f3f49bf263db1b486a29684ea95 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Aug 2024 00:29:41 +0000 Subject: [PATCH 60/90] doc: run license-builder PR-URL: https://github.com/nodejs/node/pull/54562 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli Reviewed-By: Marco Ippolito Reviewed-By: Luigi Pinca Reviewed-By: Rafael Gonzaga Reviewed-By: Moshe Atlow --- LICENSE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index 2eed637682a9a0..f0d084732f53c1 100644 --- a/LICENSE +++ b/LICENSE @@ -155,7 +155,7 @@ The externally maintained libraries used by Node.js are: SOFTWARE. """ -- swc, located at deps/amaro, is licensed as follows: +- swc, located at deps/amaro/dist, is licensed as follows: """ Apache License Version 2.0, January 2004 From 04f83b50ad6c470699c587d36d59fed319ea761f Mon Sep 17 00:00:00 2001 From: jakecastelli Date: Mon, 26 Aug 2024 01:12:58 +0930 Subject: [PATCH 61/90] Revert "net: validate host name for server listen" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 52322aa42a43cb820432946e7997d070de078a10. PR-URL: https://github.com/nodejs/node/pull/54554 Reviewed-By: Claudio Wunder Reviewed-By: James M Snell Reviewed-By: Luigi Pinca Reviewed-By: Ulises Gascón Reviewed-By: Benjamin Gruenbaum From 4a664b5fcbd9023f1624a3d49ea9bfe5974446da Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Wed, 28 Aug 2024 15:00:11 -0300 Subject: [PATCH 62/90] lib: respect terminal capabilities on styleText This PR changes styleText API to respect terminal capabilities and environment variables such as NO_COLOR, NODE_DISABLE_COLORS, and FORCE_COLOR. PR-URL: https://github.com/nodejs/node/pull/54389 Fixes: https://github.com/nodejs/node/issues/54365 Reviewed-By: Moshe Atlow Reviewed-By: Claudio Wunder Reviewed-By: Rich Trott --- doc/api/util.md | 43 +++++++++++++-- lib/util.js | 42 +++++++++++++- test/parallel/test-bootstrap-modules.js | 1 + test/parallel/test-util-styletext.js | 73 +++++++++++++++++++++++-- 4 files changed, 146 insertions(+), 13 deletions(-) diff --git a/doc/api/util.md b/doc/api/util.md index 126a36b0d79b34..17580bed72c39f 100644 --- a/doc/api/util.md +++ b/doc/api/util.md @@ -1800,7 +1800,7 @@ console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m')); // Prints "value" ``` -## `util.styleText(format, text)` +## `util.styleText(format, text[, options])` > Stability: 1.1 - Active development @@ -1808,24 +1808,55 @@ console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m')); added: - v21.7.0 - v20.12.0 +changes: + - version: REPLACEME + pr-url: https://github.com/nodejs/node/pull/54389 + description: Respect isTTY and environment variables + such as NO_COLORS, NODE_DISABLE_COLORS, and FORCE_COLOR. --> * `format` {string | Array} A text format or an Array of text formats defined in `util.inspect.colors`. * `text` {string} The text to to be formatted. +* `options` {Object} + * `validateStream` {boolean} When true, `stream` is checked to see if it can handle colors. **Default:** `true`. + * `stream` {Stream} A stream that will be validated if it can be colored. **Default:** `process.stdout`. -This function returns a formatted text considering the `format` passed. +This function returns a formatted text considering the `format` passed +for printing in a terminal, it is aware of the terminal's capabilities +and act according to the configuration set via `NO_COLORS`, +`NODE_DISABLE_COLORS` and `FORCE_COLOR` environment variables. ```mjs import { styleText } from 'node:util'; -const errorMessage = styleText('red', 'Error! Error!'); -console.log(errorMessage); +import { stderr } from 'node:process'; + +const successMessage = styleText('green', 'Success!'); +console.log(successMessage); + +const errorMessage = styleText( + 'red', + 'Error! Error!', + // Validate if process.stderr has TTY + { stream: stderr }, +); +console.error(successMessage); ``` ```cjs const { styleText } = require('node:util'); -const errorMessage = styleText('red', 'Error! Error!'); -console.log(errorMessage); +const { stderr } = require('node:process'); + +const successMessage = styleText('green', 'Success!'); +console.log(successMessage); + +const errorMessage = styleText( + 'red', + 'Error! Error!', + // Validate if process.stderr has TTY + { stream: stderr }, +); +console.error(successMessage); ``` `util.inspect.colors` also provides text formats such as `italic`, and diff --git a/lib/util.js b/lib/util.js index 11d69e6fa0f460..1c17f526d834d8 100644 --- a/lib/util.js +++ b/lib/util.js @@ -65,13 +65,26 @@ const { } = require('internal/util/inspect'); const { debuglog } = require('internal/util/debuglog'); const { + validateBoolean, validateFunction, validateNumber, validateString, validateOneOf, } = require('internal/validators'); const { isBuffer } = require('buffer').Buffer; +const { + isReadableStream, + isWritableStream, + isNodeStream, +} = require('internal/streams/utils'); const types = require('internal/util/types'); + +let utilColors; +function lazyUtilColors() { + utilColors ??= require('internal/util/colors'); + return utilColors; +} + const binding = internalBinding('util'); const { @@ -209,10 +222,25 @@ function escapeStyleCode(code) { /** * @param {string | string[]} format * @param {string} text + * @param {object} [options={}] + * @param {boolean} [options.validateStream=true] - Whether to validate the stream. + * @param {Stream} [options.stream=process.stdout] - The stream used for validation. * @returns {string} */ -function styleText(format, text) { +function styleText(format, text, { validateStream = true, stream = process.stdout } = {}) { validateString(text, 'text'); + validateBoolean(validateStream, 'options.validateStream'); + + if (validateStream) { + if ( + !isReadableStream(stream) && + !isWritableStream(stream) && + !isNodeStream(stream) + ) { + throw new ERR_INVALID_ARG_TYPE('stream', ['ReadableStream', 'WritableStream', 'Stream'], stream); + } + } + if (ArrayIsArray(format)) { let left = ''; let right = ''; @@ -232,6 +260,18 @@ function styleText(format, text) { if (formatCodes == null) { validateOneOf(format, 'format', ObjectKeys(inspect.colors)); } + + // Check colorize only after validating arg type and value + if ( + validateStream && + ( + !stream || + !lazyUtilColors().shouldColorize(stream) + ) + ) { + return text; + } + return `${escapeStyleCode(formatCodes[0])}${text}${escapeStyleCode(formatCodes[1])}`; } diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js index f1303515f6585c..d8a55fae95c290 100644 --- a/test/parallel/test-bootstrap-modules.js +++ b/test/parallel/test-bootstrap-modules.js @@ -46,6 +46,7 @@ expected.beforePreExec = new Set([ 'NativeModule internal/assert', 'NativeModule internal/util/inspect', 'NativeModule internal/util/debuglog', + 'NativeModule internal/streams/utils', 'NativeModule internal/timers', 'NativeModule events', 'Internal Binding buffer', diff --git a/test/parallel/test-util-styletext.js b/test/parallel/test-util-styletext.js index 6baa6a60eac8ac..764ce6f1a31c94 100644 --- a/test/parallel/test-util-styletext.js +++ b/test/parallel/test-util-styletext.js @@ -1,7 +1,12 @@ 'use strict'; -require('../common'); -const assert = require('assert'); -const util = require('util'); + +const common = require('../common'); +const assert = require('node:assert'); +const util = require('node:util'); +const { WriteStream } = require('node:tty'); + +const styled = '\u001b[31mtest\u001b[39m'; +const noChange = 'test'; [ undefined, @@ -31,13 +36,69 @@ assert.throws(() => { code: 'ERR_INVALID_ARG_VALUE', }); -assert.strictEqual(util.styleText('red', 'test'), '\u001b[31mtest\u001b[39m'); +assert.strictEqual( + util.styleText('red', 'test', { validateStream: false }), + '\u001b[31mtest\u001b[39m', +); + +assert.strictEqual( + util.styleText(['bold', 'red'], 'test', { validateStream: false }), + '\u001b[1m\u001b[31mtest\u001b[39m\u001b[22m', +); -assert.strictEqual(util.styleText(['bold', 'red'], 'test'), '\u001b[1m\u001b[31mtest\u001b[39m\u001b[22m'); -assert.strictEqual(util.styleText(['bold', 'red'], 'test'), util.styleText('bold', util.styleText('red', 'test'))); +assert.strictEqual( + util.styleText(['bold', 'red'], 'test', { validateStream: false }), + util.styleText( + 'bold', + util.styleText('red', 'test', { validateStream: false }), + { validateStream: false }, + ), +); assert.throws(() => { util.styleText(['invalid'], 'text'); }, { code: 'ERR_INVALID_ARG_VALUE', }); + +assert.throws(() => { + util.styleText('red', 'text', { stream: {} }); +}, { + code: 'ERR_INVALID_ARG_TYPE', +}); + +// does not throw +util.styleText('red', 'text', { stream: {}, validateStream: false }); + +assert.strictEqual( + util.styleText('red', 'test', { validateStream: false }), + styled, +); + +const fd = common.getTTYfd(); +if (fd !== -1) { + const writeStream = new WriteStream(fd); + + const originalEnv = process.env; + [ + { isTTY: true, env: {}, expected: styled }, + { isTTY: false, env: {}, expected: noChange }, + { isTTY: true, env: { NODE_DISABLE_COLORS: '1' }, expected: noChange }, + { isTTY: true, env: { NO_COLOR: '1' }, expected: noChange }, + { isTTY: true, env: { FORCE_COLOR: '1' }, expected: styled }, + { isTTY: true, env: { FORCE_COLOR: '1', NODE_DISABLE_COLORS: '1' }, expected: styled }, + { isTTY: false, env: { FORCE_COLOR: '1', NO_COLOR: '1', NODE_DISABLE_COLORS: '1' }, expected: styled }, + { isTTY: true, env: { FORCE_COLOR: '1', NO_COLOR: '1', NODE_DISABLE_COLORS: '1' }, expected: styled }, + ].forEach((testCase) => { + writeStream.isTTY = testCase.isTTY; + process.env = { + ...process.env, + ...testCase.env + }; + const output = util.styleText('red', 'test', { stream: writeStream }); + assert.strictEqual(output, testCase.expected); + process.env = originalEnv; + }); +} else { + common.skip('Could not create TTY fd'); +} From 4baf4637eb8e20079d52497d98edfa59fa8cf8bc Mon Sep 17 00:00:00 2001 From: Joyee Cheung Date: Thu, 29 Aug 2024 01:22:57 +0200 Subject: [PATCH 63/90] src: add JS APIs for compile cache and NODE_DISABLE_COMPILE_CACHE This patch adds the following API for tools to enable compile cache dynamically and query its status. - module.enableCompileCache(cacheDir) - module.getCompileCacheDir() In addition this adds a NODE_DISABLE_COMPILE_CACHE environment variable to disable the code cache enabled by the APIs as an escape hatch to avoid unexpected/undesired effects of the compile cache (e.g. less precise test coverage). When the module.enableCompileCache() method is invoked without a specified directory, Node.js will use the value of the NODE_COMPILE_CACHE environment variable if it's set, or defaults to `path.join(os.tmpdir(), 'node-compile-cache')` otherwise. Therefore it's recommended for tools to call this method without specifying the directory to allow overrides. PR-URL: https://github.com/nodejs/node/pull/54501 Fixes: https://github.com/nodejs/node/issues/53639 Reviewed-By: Benjamin Gruenbaum Reviewed-By: James M Snell Reviewed-By: Antoine du Hamel --- doc/api/cli.md | 34 ++-- doc/api/module.md | 157 +++++++++++++++++- lib/internal/modules/helpers.js | 54 +++++- lib/module.js | 8 + src/compile_cache.cc | 8 +- src/compile_cache.h | 7 +- src/env.cc | 15 +- src/node_modules.cc | 45 +++++ test/fixtures/compile-cache-wrapper.js | 21 +++ test/parallel/test-compile-cache-api-env.js | 81 +++++++++ .../test-compile-cache-api-permission.js | 56 +++++++ .../test-compile-cache-api-success.js | 79 +++++++++ .../parallel/test-compile-cache-api-tmpdir.js | 92 ++++++++++ test/parallel/test-compile-cache-disable.js | 39 +++++ 14 files changed, 665 insertions(+), 31 deletions(-) create mode 100644 test/fixtures/compile-cache-wrapper.js create mode 100644 test/parallel/test-compile-cache-api-env.js create mode 100644 test/parallel/test-compile-cache-api-permission.js create mode 100644 test/parallel/test-compile-cache-api-success.js create mode 100644 test/parallel/test-compile-cache-api-tmpdir.js create mode 100644 test/parallel/test-compile-cache-disable.js diff --git a/doc/api/cli.md b/doc/api/cli.md index 0b5e061482a210..e76499d914a664 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -2868,25 +2868,8 @@ added: v22.1.0 > Stability: 1.1 - Active Development -When set, whenever Node.js compiles a CommonJS or a ECMAScript Module, -it will use on-disk [V8 code cache][] persisted in the specified directory -to speed up the compilation. This may slow down the first load of a -module graph, but subsequent loads of the same module graph may get -a significant speedup if the contents of the modules do not change. - -To clean up the generated code cache, simply remove the directory. -It will be recreated the next time the same directory is used for -`NODE_COMPILE_CACHE`. - -Compilation cache generated by one version of Node.js may not be used -by a different version of Node.js. Cache generated by different versions -of Node.js will be stored separately if the same directory is used -to persist the cache, so they can co-exist. - -Caveat: currently when using this with [V8 JavaScript code coverage][], the -coverage being collected by V8 may be less precise in functions that are -deserialized from the code cache. It's recommended to turn this off when -running tests to generate precise coverage. +Enable the [module compile cache][] for the Node.js instance. See the documentation of +[module compile cache][] for details. ### `NODE_DEBUG=module[,…]` @@ -2908,6 +2891,17 @@ added: v0.3.0 When set, colors will not be used in the REPL. +### `NODE_DISABLE_COMPILE_CACHE=1` + + + +> Stability: 1.1 - Active Development + +Disable the [module compile cache][] for the Node.js instance. See the documentation of +[module compile cache][] for details. + ### `NODE_EXTRA_CA_CERTS=file` + +> Stability: 1.1 - Active Development + +The following constants are returned as the `status` field in the object returned by +[`module.enableCompileCache()`][] to indicate the result of the attempt to enable the +[module compile cache][]. + + + + + + + + + + + + + + + + + + + + + + +
ConstantDescription
ENABLED + Node.js has enabled the compile cache successfully. The directory used to store the + compile cache will be returned in the directory field in the + returned object. +
ALREADY_ENABLED + The compile cache has already been enabled before, either by a previous call to + module.enableCompileCache(), or by the NODE_COMPILE_CACHE=dir + environment variable. The directory used to store the + compile cache will be returned in the directory field in the + returned object. +
FAILED + Node.js fails to enable the compile cache. This can be caused by the lack of + permission to use the specified directory, or various kinds of file system errors. + The detail of the failure will be returned in the message field in the + returned object. +
DISABLED + Node.js cannot enable the compile cache because the environment variable + NODE_DISABLE_COMPILE_CACHE=1 has been set. +
+ +### `module.enableCompileCache([cacheDir])` + + + +> Stability: 1.1 - Active Development + +* `cacheDir` {string|undefined} Optional path to specify the directory where the compile cache + will be stored/retrieved. +* Returns: {Object} + * `status` {integer} One of the [`module.constants.compileCacheStatus`][] + * `message` {string|undefined} If Node.js cannot enable the compile cache, this contains + the error message. Only set if `status` is `module.constants.compileCacheStatus.FAILED`. + * `directory` {string|undefined} If the compile cache is enabled, this contains the directory + where the compile cache is stored. Only set if `status` is + `module.constants.compileCacheStatus.ENABLED` or + `module.constants.compileCacheStatus.ALREADY_ENABLED`. + +Enable [module compile cache][] in the current Node.js instance. + +If `cacheDir` is not specified, Node.js will either use the directory specified by the +[`NODE_COMPILE_CACHE=dir`][] environment variable if it's set, or use +`path.join(os.tmpdir(), 'node-compile-cache')` otherwise. For general use cases, it's +recommended to call `module.enableCompileCache()` without specifying the `cacheDir`, +so that the directory can be overriden by the `NODE_COMPILE_CACHE` environment +variable when necessary. + +Since compile cache is supposed to be a quiet optimization that is not required for the +application to be functional, this method is designed to not throw any exception when the +compile cache cannot be enabled. Instead, it will return an object containing an error +message in the `message` field to aid debugging. +If compile cache is enabled successefully, the `directory` field in the returned object +contains the path to the directory where the compile cache is stored. The `status` +field in the returned object would be one of the `module.constants.compileCacheStatus` +values to indicate the result of the attempt to enable the [module compile cache][]. + +This method only affects the current Node.js instance. To enable it in child worker threads, +either call this method in child worker threads too, or set the +`process.env.NODE_COMPILE_CACHE` value to compile cache directory so the behavior can +be inheritend into the child workers. The directory can be obtained either from the +`directory` field returned by this method, or with [`module.getCompileCacheDir()`][]. + +#### Module compile cache + + + +The module compile cache can be enabled either using the [`module.enableCompileCache()`][] +method or the [`NODE_COMPILE_CACHE=dir`][] environemnt variable. After it's enabled, +whenever Node.js compiles a CommonJS or a ECMAScript Module, it will use on-disk +[V8 code cache][] persisted in the specified directory to speed up the compilation. +This may slow down the first load of a module graph, but subsequent loads of the same module +graph may get a significant speedup if the contents of the modules do not change. + +To clean up the generated compile cache on disk, simply remove the cache directory. The cache +directory will be recreated the next time the same directory is used for for compile cache +storage. To avoid filling up the disk with stale cache, it is recommended to use a directory +under the [`os.tmpdir()`][]. If the compile cache is enabled by a call to +[`module.enableCompileCache()`][] without specifying the directory, Node.js will use +the [`NODE_DISABLE_COMPILE_CACHE=1`][] environment variable if it's set, or defaults +to `path.join(os.tmpdir(), 'node-compile-cache')` otherwise. To locate the compile cache +directory used by a running Node.js instance, use [`module.getCompileCacheDir()`][]. + +Currently when using the compile cache with [V8 JavaScript code coverage][], the +coverage being collected by V8 may be less precise in functions that are +deserialized from the code cache. It's recommended to turn this off when +running tests to generate precise coverage. + +The enabled module compile cache can be disabled by the [`NODE_DISABLE_COMPILE_CACHE=1`][] +environment variable. This can be useful when the compile cache leads to unexpected or +undesired behaviors (e.g. less precise test coverage). + +Compilation cache generated by one version of Node.js can not be reused by a different +version of Node.js. Cache generated by different versions of Node.js will be stored +separately if the same base directory is used to persist the cache, so they can co-exist. + +### `module.getCompileCacheDir()` + + + +> Stability: 1.1 - Active Development + +* Returns: {string|undefined} Path to the [module compile cache][] directory if it is enabled, + or `undefined` otherwise. + ### `module.isBuiltin(moduleName)` -* `contextObject` {Object} An object that will be [contextified][]. If - `undefined`, a new object will be created. +* `contextObject` {Object|vm.constants.DONT\_CONTEXTIFY|undefined} + Either [`vm.constants.DONT_CONTEXTIFY`][] or an object that will be [contextified][]. + If `undefined`, an empty contextified object will be created for backwards compatibility. * `options` {Object} * `displayErrors` {boolean} When `true`, if an [`Error`][] occurs while compiling the `code`, the line of code causing the error is attached @@ -275,9 +279,16 @@ changes: `breakOnSigint` scopes in that case. * Returns: {any} the result of the very last statement executed in the script. -First contextifies the given `contextObject`, runs the compiled code contained -by the `vm.Script` object within the created context, and returns the result. -Running code does not have access to local scope. +This method is a shortcut to `script.runInContext(vm.createContext(options), options)`. +It does several things at once: + +1. Creates a new context. +2. If `contextObject` is an object, [contextifies][contextified] it with the new context. + If `contextObject` is undefined, creates a new object and [contextifies][contextified] it. + If `contextObject` is [`vm.constants.DONT_CONTEXTIFY`][], don't [contextify][contextified] anything. +3. Runs the compiled code contained by the `vm.Script` object within the created context. The code + does not have access to the scope in which this method is called. +4. Returns the result. The following example compiles code that sets a global variable, then executes the code multiple times in different contexts. The globals are set on and @@ -295,6 +306,12 @@ contexts.forEach((context) => { console.log(contexts); // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }] + +// This would throw if the context is created from a contextified object. +// vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary +// global objects that can be frozen. +const freezeScript = new vm.Script('Object.freeze(globalThis); globalThis;'); +const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY); ``` ### `script.runInThisContext([options])` @@ -1072,6 +1089,10 @@ For detailed information, see -* `contextObject` {Object} +* `contextObject` {Object|vm.constants.DONT\_CONTEXTIFY|undefined} + Either [`vm.constants.DONT_CONTEXTIFY`][] or an object that will be [contextified][]. + If `undefined`, an empty contextified object will be created for backwards compatibility. * `options` {Object} * `name` {string} Human-readable name of the newly created context. **Default:** `'VM Context i'`, where `i` is an ascending numerical index of @@ -1124,10 +1147,10 @@ changes: [Support of dynamic `import()` in compilation APIs][]. * Returns: {Object} contextified object. -If given a `contextObject`, the `vm.createContext()` method will [prepare that +If the given `contextObject` is an object, the `vm.createContext()` method will [prepare that object][contextified] and return a reference to it so that it can be used in calls to [`vm.runInContext()`][] or [`script.runInContext()`][]. Inside such -scripts, the `contextObject` will be the global object, retaining all of its +scripts, the global object will be wrapped by the `contextObject`, retaining all of its existing properties but also having the built-in objects and functions any standard [global object][] has. Outside of scripts run by the vm module, global variables will remain unchanged. @@ -1152,6 +1175,11 @@ console.log(global.globalVar); If `contextObject` is omitted (or passed explicitly as `undefined`), a new, empty [contextified][] object will be returned. +When the global object in the newly created context is [contextified][], it has some quirks +compared to ordinary global objects. For example, it cannot be frozen. To create a context +without the contextifying quirks, pass [`vm.constants.DONT_CONTEXTIFY`][] as the `contextObject` +argument. See the documentation of [`vm.constants.DONT_CONTEXTIFY`][] for details. + The `vm.createContext()` method is primarily useful for creating a single context that can be used to run multiple scripts. For instance, if emulating a web browser, the method can be used to create a single context representing a @@ -1171,7 +1199,8 @@ added: v0.11.7 * Returns: {boolean} Returns `true` if the given `object` object has been [contextified][] using -[`vm.createContext()`][]. +[`vm.createContext()`][], or if it's the global object of a context created +using [`vm.constants.DONT_CONTEXTIFY`][]. ## `vm.measureMemory([options])` @@ -1332,6 +1361,10 @@ console.log(contextObject); * `code` {string} The JavaScript code to compile and run. -* `contextObject` {Object} An object that will be [contextified][]. If - `undefined`, a new object will be created. +* `contextObject` {Object|vm.constants.DONT\_CONTEXTIFY|undefined} + Either [`vm.constants.DONT_CONTEXTIFY`][] or an object that will be [contextified][]. + If `undefined`, an empty contextified object will be created for backwards compatibility. * `options` {Object|string} * `filename` {string} Specifies the filename used in stack traces produced by this script. **Default:** `'evalmachine.'`. @@ -1407,13 +1441,21 @@ changes: `breakOnSigint` scopes in that case. * Returns: {any} the result of the very last statement executed in the script. -The `vm.runInNewContext()` first contextifies the given `contextObject` (or -creates a new `contextObject` if passed as `undefined`), compiles the `code`, -runs it within the created context, then returns the result. Running code -does not have access to the local scope. - +This method is a shortcut to +`(new vm.Script(code, options)).runInContext(vm.createContext(options), options)`. If `options` is a string, then it specifies the filename. +It does several things at once: + +1. Creates a new context. +2. If `contextObject` is an object, [contextifies][contextified] it with the new context. + If `contextObject` is undefined, creates a new object and [contextifies][contextified] it. + If `contextObject` is [`vm.constants.DONT_CONTEXTIFY`][], don't [contextify][contextified] anything. +3. Compiles the code as a`vm.Script` +4. Runs the compield code within the created context. The code does not have access to the scope in + which this method is called. +5. Returns the result. + The following example compiles and executes code that increments a global variable and sets a new one. These globals are contained in the `contextObject`. @@ -1428,6 +1470,11 @@ const contextObject = { vm.runInNewContext('count += 1; name = "kitty"', contextObject); console.log(contextObject); // Prints: { animal: 'cat', count: 3, name: 'kitty' } + +// This would throw if the context is created from a contextified object. +// vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary global objects that +// can be frozen. +const frozenContext = vm.runInNewContext('Object.freeze(globalThis); globalThis;', vm.constants.DONT_CONTEXTIFY); ``` ## `vm.runInThisContext(code[, options])` @@ -1555,13 +1602,85 @@ According to the [V8 Embedder's Guide][]: > JavaScript applications to run in a single instance of V8. You must explicitly > specify the context in which you want any JavaScript code to be run. -When the method `vm.createContext()` is called, the `contextObject` argument -(or a newly-created object if `contextObject` is `undefined`) is associated -internally with a new instance of a V8 Context. This V8 Context provides the -`code` run using the `node:vm` module's methods with an isolated global -environment within which it can operate. The process of creating the V8 Context -and associating it with the `contextObject` is what this document refers to as -"contextifying" the object. +When the method `vm.createContext()` is called with an object, the `contextObject` argument +will be used to wrap the global object of a new instance of a V8 Context +(if `contextObject` is `undefined`, a new object will be created from the current context +before its contextified). This V8 Context provides the `code` run using the `node:vm` +module's methods with an isolated global environment within which it can operate. +The process of creating the V8 Context and associating it with the `contextObject` +in the outer context is what this document refers to as "contextifying" the object. + +The contextifying would introduce some quirks to the `globalThis` value in the context. +For example, it cannot be frozen, and it is not reference equal to the `contextObject` +in the outer context. + +```js +const vm = require('node:vm'); + +// An undefined `contextObject` option makes the global object contextified. +let context = vm.createContext(); +console.log(vm.runInContext('globalThis', context) === context); // false +// A contextified global object cannot be frozen. +try { + vm.runInContext('Object.freeze(globalThis);', context); +} catch(e) { + console.log(e); // TypeError: Cannot freeze +} +console.log(vm.runInContext('globalThis.foo = 1; foo;', context)); // 1 +``` + +To create a context with an ordinary global object and get access to a global proxy in +the outer context with fewer quirks, specify `vm.constants.DONT_CONTEXTIFY` as the +`contextObject` argument. + +### `vm.constants.DONT_CONTEXTIFY` + +This constant, when used as the `contextObject` argument in vm APIs, instructs Node.js to create +a context without wrapping its global object with another object in a Node.js-specific manner. +As a result, the `globalThis` value inside the new context would behave more closely to an ordinary +one. + +```js +const vm = require('node:vm'); + +// Use vm.constants.DONT_CONTEXTIFY to freeze the global object. +const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); +vm.runInContext('Object.freeze(globalThis);', context); +try { + vm.runInContext('bar = 1; bar;', context); +} catch(e) { + console.log(e); // Uncaught ReferenceError: bar is not defined +} +``` + +When `vm.constants.DONT_CONTEXTIFY` is used as the `contextObject` argument to [`vm.createContext()`][], +the returned object is a proxy-like object to the global object in the newly created context with +fewer Node.js-specific quirks. It is reference equal to the `globalThis` value in the new context, +can be modified from outside the context, and can be used to access built-ins in the new context directly. + +```js +const vm = require('node:vm'); + +const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + +// Returned object is reference equal to globalThis in the new context. +console.log(vm.runInContext('globalThis', context) === context); // true + +// Can be used to access globals in the new context directly. +console.log(context.Array); // [Function: Array] +vm.runInContext('foo = 1;', context); +console.log(context.foo); // 1 +context.bar = 1; +console.log(vm.runInContext('bar;', context)); // 1 + +// Can be frozen and it affects the inner context. +Object.freeze(context); +try { + vm.runInContext('baz = 1; baz;', context); +} catch(e) { + console.log(e); // Uncaught ReferenceError: baz is not defined +} +``` ## Timeout interactions with asynchronous tasks and Promises @@ -1851,6 +1970,7 @@ const { Script, SyntheticModule } = require('node:vm'); [`script.runInThisContext()`]: #scriptruninthiscontextoptions [`url.origin`]: url.md#urlorigin [`vm.compileFunction()`]: #vmcompilefunctioncode-params-options +[`vm.constants.DONT_CONTEXTIFY`]: #vmconstantsdont_contextify [`vm.createContext()`]: #vmcreatecontextcontextobject-options [`vm.runInContext()`]: #vmrunincontextcode-contextifiedobject-options [`vm.runInThisContext()`]: #vmruninthiscontextcode-options diff --git a/lib/vm.js b/lib/vm.js index e1ad4e30c33b66..3eea66b3f07437 100644 --- a/lib/vm.js +++ b/lib/vm.js @@ -65,6 +65,7 @@ const { } = require('internal/vm'); const { vm_dynamic_import_main_context_default, + vm_context_no_contextify, } = internalBinding('symbols'); const kParsingContext = Symbol('script parsing context'); @@ -222,7 +223,7 @@ function getContextOptions(options) { let defaultContextNameIndex = 1; function createContext(contextObject = {}, options = kEmptyObject) { - if (isContext(contextObject)) { + if (contextObject !== vm_context_no_contextify && isContext(contextObject)) { return contextObject; } @@ -258,10 +259,10 @@ function createContext(contextObject = {}, options = kEmptyObject) { const hostDefinedOptionId = getHostDefinedOptionId(importModuleDynamically, name); - makeContext(contextObject, name, origin, strings, wasm, microtaskQueue, hostDefinedOptionId); + const result = makeContext(contextObject, name, origin, strings, wasm, microtaskQueue, hostDefinedOptionId); // Register the context scope callback after the context was initialized. - registerImportModuleDynamically(contextObject, importModuleDynamically); - return contextObject; + registerImportModuleDynamically(result, importModuleDynamically); + return result; } function createScript(code, options) { @@ -394,6 +395,7 @@ function measureMemory(options = kEmptyObject) { const vmConstants = { __proto__: null, USE_MAIN_CONTEXT_DEFAULT_LOADER: vm_dynamic_import_main_context_default, + DONT_CONTEXTIFY: vm_context_no_contextify, }; ObjectFreeze(vmConstants); diff --git a/src/env_properties.h b/src/env_properties.h index 1ed8ab4d116313..9bfe077abfb0cd 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -57,6 +57,7 @@ V(resource_symbol, "resource_symbol") \ V(trigger_async_id_symbol, "trigger_async_id_symbol") \ V(source_text_module_default_hdo, "source_text_module_default_hdo") \ + V(vm_context_no_contextify, "vm_context_no_contextify") \ V(vm_dynamic_import_default_internal, "vm_dynamic_import_default_internal") \ V(vm_dynamic_import_main_context_default, \ "vm_dynamic_import_main_context_default") \ diff --git a/src/node_contextify.cc b/src/node_contextify.cc index 895f7b9d096166..bc90501da0ffde 100644 --- a/src/node_contextify.cc +++ b/src/node_contextify.cc @@ -118,9 +118,15 @@ Local Uint32ToName(Local context, uint32_t index) { BaseObjectPtr ContextifyContext::New( Environment* env, Local sandbox_obj, ContextOptions* options) { + Local object_template; HandleScope scope(env->isolate()); - Local object_template = env->contextify_global_template(); - DCHECK(!object_template.IsEmpty()); + CHECK_IMPLIES(sandbox_obj.IsEmpty(), options->vanilla); + if (!sandbox_obj.IsEmpty()) { + // Do not use the template with interceptors for vanilla contexts. + object_template = env->contextify_global_template(); + DCHECK(!object_template.IsEmpty()); + } + const SnapshotData* snapshot_data = env->isolate_data()->snapshot_data(); MicrotaskQueue* queue = @@ -217,7 +223,7 @@ MaybeLocal ContextifyContext::CreateV8Context( EscapableHandleScope scope(isolate); Local ctx; - if (snapshot_data == nullptr) { + if (object_template.IsEmpty() || snapshot_data == nullptr) { ctx = Context::New( isolate, nullptr, // extensions @@ -249,6 +255,7 @@ BaseObjectPtr ContextifyContext::New( Local sandbox_obj, ContextOptions* options) { HandleScope scope(env->isolate()); + CHECK_IMPLIES(sandbox_obj.IsEmpty(), options->vanilla); // This only initializes part of the context. The primordials are // only initialized when needed because even deserializing them slows // things down significantly and they are only needed in rare occasions @@ -267,8 +274,13 @@ BaseObjectPtr ContextifyContext::New( // embedder data field. The sandbox uses a private symbol to hold a reference // to the ContextifyContext wrapper which in turn internally references // the context from its constructor. - v8_context->SetEmbedderData(ContextEmbedderIndex::kSandboxObject, - sandbox_obj); + if (sandbox_obj.IsEmpty()) { + v8_context->SetEmbedderData(ContextEmbedderIndex::kSandboxObject, + v8::Undefined(env->isolate())); + } else { + v8_context->SetEmbedderData(ContextEmbedderIndex::kSandboxObject, + sandbox_obj); + } // Delegate the code generation validation to // node::ModifyCodeGenerationFromStrings. @@ -290,16 +302,19 @@ BaseObjectPtr ContextifyContext::New( Local wrapper; { Context::Scope context_scope(v8_context); - Local ctor_name = sandbox_obj->GetConstructorName(); - if (!ctor_name->Equals(v8_context, env->object_string()).FromMaybe(false) && - new_context_global - ->DefineOwnProperty( - v8_context, - v8::Symbol::GetToStringTag(env->isolate()), - ctor_name, - static_cast(v8::DontEnum)) - .IsNothing()) { - return BaseObjectPtr(); + if (!sandbox_obj.IsEmpty()) { + Local ctor_name = sandbox_obj->GetConstructorName(); + if (!ctor_name->Equals(v8_context, env->object_string()) + .FromMaybe(false) && + new_context_global + ->DefineOwnProperty( + v8_context, + v8::Symbol::GetToStringTag(env->isolate()), + ctor_name, + static_cast(v8::DontEnum)) + .IsNothing()) { + return BaseObjectPtr(); + } } // Assign host_defined_options_id to the global object so that in the @@ -328,23 +343,27 @@ BaseObjectPtr ContextifyContext::New( result->MakeWeak(); } - if (sandbox_obj + Local wrapper_holder = + sandbox_obj.IsEmpty() ? new_context_global : sandbox_obj; + if (!wrapper_holder.IsEmpty() && + wrapper_holder ->SetPrivate( v8_context, env->contextify_context_private_symbol(), wrapper) .IsNothing()) { return BaseObjectPtr(); } - // Assign host_defined_options_id to the sandbox object so that module - // callbacks like importModuleDynamically can be registered once back to the - // JS land. - if (sandbox_obj + + // Assign host_defined_options_id to the sandbox object or the global object + // (for vanilla contexts) so that module callbacks like + // importModuleDynamically can be registered once back to the JS land. + if (!sandbox_obj.IsEmpty() && + sandbox_obj ->SetPrivate(v8_context, env->host_defined_option_symbol(), options->host_defined_options_id) .IsNothing()) { return BaseObjectPtr(); } - return result; } @@ -378,18 +397,21 @@ void ContextifyContext::RegisterExternalReferences( // makeContext(sandbox, name, origin, strings, wasm); void ContextifyContext::MakeContext(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); + ContextOptions options; CHECK_EQ(args.Length(), 7); - CHECK(args[0]->IsObject()); - Local sandbox = args[0].As(); - - // Don't allow contextifying a sandbox multiple times. - CHECK( - !sandbox->HasPrivate( - env->context(), - env->contextify_context_private_symbol()).FromJust()); - - ContextOptions options; + Local sandbox; + if (args[0]->IsObject()) { + sandbox = args[0].As(); + // Don't allow contextifying a sandbox multiple times. + CHECK(!sandbox + ->HasPrivate(env->context(), + env->contextify_context_private_symbol()) + .FromJust()); + } else { + CHECK(args[0]->IsSymbol()); + options.vanilla = true; + } CHECK(args[1]->IsString()); options.name = args[1].As(); @@ -422,18 +444,23 @@ void ContextifyContext::MakeContext(const FunctionCallbackInfo& args) { try_catch.ReThrow(); return; } + + if (sandbox.IsEmpty()) { + args.GetReturnValue().Set(context_ptr->context()->Global()); + } else { + args.GetReturnValue().Set(sandbox); + } } // static ContextifyContext* ContextifyContext::ContextFromContextifiedSandbox( - Environment* env, - const Local& sandbox) { - Local context_global; - if (sandbox + Environment* env, const Local& wrapper_holder) { + Local contextify; + if (wrapper_holder ->GetPrivate(env->context(), env->contextify_context_private_symbol()) - .ToLocal(&context_global) && - context_global->IsObject()) { - return Unwrap(context_global.As()); + .ToLocal(&contextify) && + contextify->IsObject()) { + return Unwrap(contextify.As()); } return nullptr; } diff --git a/src/node_contextify.h b/src/node_contextify.h index b9e846f70bad4f..2581db0d7df568 100644 --- a/src/node_contextify.h +++ b/src/node_contextify.h @@ -19,6 +19,7 @@ struct ContextOptions { v8::Local allow_code_gen_wasm; std::unique_ptr own_microtask_queue; v8::Local host_defined_options_id; + bool vanilla = false; }; class ContextifyContext : public BaseObject { @@ -43,8 +44,7 @@ class ContextifyContext : public BaseObject { static void RegisterExternalReferences(ExternalReferenceRegistry* registry); static ContextifyContext* ContextFromContextifiedSandbox( - Environment* env, - const v8::Local& sandbox); + Environment* env, const v8::Local& wrapper_holder); inline v8::Local context() const { return PersistentToLocal::Default(env()->isolate(), context_); @@ -55,8 +55,12 @@ class ContextifyContext : public BaseObject { } inline v8::Local sandbox() const { - return context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject) - .As(); + // Only vanilla contexts have undefined sandboxes. sandbox() is only used by + // interceptors who are not supposed to be called on vanilla contexts. + v8::Local result = + context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject); + CHECK(!result->IsUndefined()); + return result.As(); } inline v8::MicrotaskQueue* microtask_queue() const { diff --git a/test/parallel/test-vm-context-dont-contextify.js b/test/parallel/test-vm-context-dont-contextify.js new file mode 100644 index 00000000000000..6cbd62e8947b3d --- /dev/null +++ b/test/parallel/test-vm-context-dont-contextify.js @@ -0,0 +1,185 @@ +'use strict'; + +// Check vm.constants.DONT_CONTEXTIFY works. + +const common = require('../common'); + +const assert = require('assert'); +const vm = require('vm'); +const fixtures = require('../common/fixtures'); + +{ + // Check identity of the returned object. + const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + // The globalThis in the new context should be reference equal to the returned object. + assert.strictEqual(vm.runInContext('globalThis', context), context); + assert(vm.isContext(context)); + assert.strictEqual(typeof context.Array, 'function'); // Can access builtins directly. + assert.deepStrictEqual(Object.keys(context), []); // Properties on the global proxy are not enumerable +} + +{ + // Check that vm.createContext can return the original context if re-passed. + const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + const context2 = new vm.createContext(context); + assert.strictEqual(context, context2); +} + +{ + // Check that the context is vanilla and that Script.runInContext works. + const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + const result = + new vm.Script('globalThis.hey = 1; Object.freeze(globalThis); globalThis.process') + .runInContext(context); + assert.strictEqual(globalThis.hey, undefined); // Should not leak into current context. + assert.strictEqual(result, undefined); // Vanilla context has no Node.js globals +} + +{ + // Check Script.runInNewContext works. + const result = + new vm.Script('globalThis.hey = 1; Object.freeze(globalThis); globalThis.process') + .runInNewContext(vm.constants.DONT_CONTEXTIFY); + assert.strictEqual(globalThis.hey, undefined); // Should not leak into current context. + assert.strictEqual(result, undefined); // Vanilla context has no Node.js globals +} + +{ + // Check that vm.runInNewContext() works + const result = vm.runInNewContext( + 'globalThis.hey = 1; Object.freeze(globalThis); globalThis.process', + vm.constants.DONT_CONTEXTIFY); + assert.strictEqual(globalThis.hey, undefined); // Should not leak into current context. + assert.strictEqual(result, undefined); // Vanilla context has no Node.js globals +} + +{ + // Check that the global object of vanilla contexts work as expected. + const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + + // Check mutation via globalThis. + vm.runInContext('globalThis.foo = 1;', context); + assert.strictEqual(globalThis.foo, undefined); // Should not pollute the current context. + assert.strictEqual(context.foo, 1); + assert.strictEqual(vm.runInContext('globalThis.foo', context), 1); + assert.strictEqual(vm.runInContext('foo', context), 1); + + // Check mutation from outside. + context.foo = 2; + assert.strictEqual(context.foo, 2); + assert.strictEqual(vm.runInContext('globalThis.foo', context), 2); + assert.strictEqual(vm.runInContext('foo', context), 2); + + // Check contextual mutation. + vm.runInContext('bar = 1;', context); + assert.strictEqual(globalThis.bar, undefined); // Should not pollute the current context. + assert.strictEqual(context.bar, 1); + assert.strictEqual(vm.runInContext('globalThis.bar', context), 1); + assert.strictEqual(vm.runInContext('bar', context), 1); + + // Check adding new property from outside. + context.baz = 1; + assert.strictEqual(context.baz, 1); + assert.strictEqual(vm.runInContext('globalThis.baz', context), 1); + assert.strictEqual(vm.runInContext('baz', context), 1); + + // Check mutation via Object.defineProperty(). + vm.runInContext('Object.defineProperty(globalThis, "qux", {' + + 'enumerable: false, configurable: false, get() { return 1; } })', context); + assert.strictEqual(globalThis.qux, undefined); // Should not pollute the current context. + assert.strictEqual(context.qux, 1); + assert.strictEqual(vm.runInContext('qux', context), 1); + const desc = Object.getOwnPropertyDescriptor(context, 'qux'); + assert.strictEqual(desc.enumerable, false); + assert.strictEqual(desc.configurable, false); + assert.strictEqual(typeof desc.get, 'function'); + assert.throws(() => { context.qux = 1; }, { name: 'TypeError' }); + assert.throws(() => { Object.defineProperty(context, 'qux', { value: 1 }); }, { name: 'TypeError' }); + // Setting a value without a setter fails silently. + assert.strictEqual(vm.runInContext('qux = 2; qux', context), 1); + assert.throws(() => { + vm.runInContext('Object.defineProperty(globalThis, "qux", { value: 1 });'); + }, { name: 'TypeError' }); +} + +function checkFrozen(context) { + // Check mutation via globalThis. + vm.runInContext('globalThis.foo = 1', context); // Invoking setters on freezed object fails silently. + assert.strictEqual(context.foo, undefined); + assert.strictEqual(vm.runInContext('globalThis.foo', context), undefined); + assert.throws(() => { + vm.runInContext('foo', context); // It should not be looked up contextually. + }, { + name: 'ReferenceError' + }); + + // Check mutation from outside. + assert.throws(() => { + context.foo = 2; + }, { name: 'TypeError' }); + assert.strictEqual(context.foo, undefined); + assert.strictEqual(vm.runInContext('globalThis.foo', context), undefined); + assert.throws(() => { + vm.runInContext('foo', context); // It should not be looked up contextually. + }, { + name: 'ReferenceError' + }); + + // Check contextual mutation. + vm.runInContext('bar = 1', context); // Invoking setters on freezed object fails silently. + assert.strictEqual(context.bar, undefined); + assert.strictEqual(vm.runInContext('globalThis.bar', context), undefined); + assert.throws(() => { + vm.runInContext('bar', context); // It should not be looked up contextually. + }, { + name: 'ReferenceError' + }); + + // Check mutation via Object.defineProperty(). + assert.throws(() => { + vm.runInContext('Object.defineProperty(globalThis, "qux", {' + + 'enumerable: false, configurable: false, get() { return 1; } })', context); + }, { + name: 'TypeError' + }); + assert.strictEqual(context.qux, undefined); + assert.strictEqual(vm.runInContext('globalThis.qux', context), undefined); + assert.strictEqual(Object.getOwnPropertyDescriptor(context, 'qux'), undefined); + assert.throws(() => { Object.defineProperty(context, 'qux', { value: 1 }); }, { name: 'TypeError' }); + assert.throws(() => { + vm.runInContext('qux', context); + }, { + name: 'ReferenceError' + }); +} + +{ + // Check freezing the vanilla context's global object from within the context. + const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + // Only vanilla contexts' globals can be freezed. Contextified global objects cannot be freezed + // due to the presence of interceptors. + vm.runInContext('Object.freeze(globalThis)', context); + checkFrozen(context); +} + +{ + // Check freezing the vanilla context's global object from outside the context. + const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + Object.freeze(context); + checkFrozen(context); +} + +// Check importModuleDynamically works. +(async function() { + { + const moduleUrl = fixtures.fileURL('es-modules', 'message.mjs'); + const namespace = await import(moduleUrl.href); + // Check dynamic import works + const context = vm.createContext(vm.constants.DONT_CONTEXTIFY); + const script = new vm.Script(`import('${encodeURI(moduleUrl.href)}')`, { + importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER, + }); + const promise = script.runInContext(context); + assert.strictEqual(await promise, namespace); + } +})().catch(common.mustNotCall()); diff --git a/tools/doc/type-parser.mjs b/tools/doc/type-parser.mjs index c548e2ccff8276..6b94a94283ccb2 100644 --- a/tools/doc/type-parser.mjs +++ b/tools/doc/type-parser.mjs @@ -236,6 +236,8 @@ const customTypesMap = { 'vm.SourceTextModule': 'vm.html#class-vmsourcetextmodule', 'vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER': 'vm.html#vmconstantsuse_main_context_default_loader', + 'vm.constants.DONT_CONTEXTIFY': + 'vm.html#vmconstantsdont_contextify', 'MessagePort': 'worker_threads.html#class-messageport', 'Worker': 'worker_threads.html#class-worker', From 73604cf1c538ed7ddbd8b881441b9718ea368fed Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Thu, 29 Aug 2024 12:15:03 +0200 Subject: [PATCH 75/90] deps: update nghttp2 to 1.63.0 PR-URL: https://github.com/nodejs/node/pull/54589 Reviewed-By: Luigi Pinca Reviewed-By: Rafael Gonzaga --- deps/nghttp2/lib/Makefile.in | 4 ++++ deps/nghttp2/lib/includes/Makefile.in | 4 ++++ deps/nghttp2/lib/includes/nghttp2/nghttp2.h | 4 ++++ deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h | 4 ++-- deps/nghttp2/lib/nghttp2_extpri.h | 2 +- deps/nghttp2/lib/nghttp2_hd.c | 9 +++++---- deps/nghttp2/lib/nghttp2_helper.h | 2 +- deps/nghttp2/lib/nghttp2_submit.h | 2 +- 8 files changed, 22 insertions(+), 9 deletions(-) diff --git a/deps/nghttp2/lib/Makefile.in b/deps/nghttp2/lib/Makefile.in index aeae3d76cc49d7..c4ab62421eaab0 100644 --- a/deps/nghttp2/lib/Makefile.in +++ b/deps/nghttp2/lib/Makefile.in @@ -361,6 +361,8 @@ LIBNGTCP2_CRYPTO_BORINGSSL_CFLAGS = @LIBNGTCP2_CRYPTO_BORINGSSL_CFLAGS@ LIBNGTCP2_CRYPTO_BORINGSSL_LIBS = @LIBNGTCP2_CRYPTO_BORINGSSL_LIBS@ LIBNGTCP2_CRYPTO_QUICTLS_CFLAGS = @LIBNGTCP2_CRYPTO_QUICTLS_CFLAGS@ LIBNGTCP2_CRYPTO_QUICTLS_LIBS = @LIBNGTCP2_CRYPTO_QUICTLS_LIBS@ +LIBNGTCP2_CRYPTO_WOLFSSL_CFLAGS = @LIBNGTCP2_CRYPTO_WOLFSSL_CFLAGS@ +LIBNGTCP2_CRYPTO_WOLFSSL_LIBS = @LIBNGTCP2_CRYPTO_WOLFSSL_LIBS@ LIBNGTCP2_LIBS = @LIBNGTCP2_LIBS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ @@ -414,6 +416,8 @@ TESTLDADD = @TESTLDADD@ VERSION = @VERSION@ WARNCFLAGS = @WARNCFLAGS@ WARNCXXFLAGS = @WARNCXXFLAGS@ +WOLFSSL_CFLAGS = @WOLFSSL_CFLAGS@ +WOLFSSL_LIBS = @WOLFSSL_LIBS@ ZLIB_CFLAGS = @ZLIB_CFLAGS@ ZLIB_LIBS = @ZLIB_LIBS@ abs_builddir = @abs_builddir@ diff --git a/deps/nghttp2/lib/includes/Makefile.in b/deps/nghttp2/lib/includes/Makefile.in index 128496617d6441..e2150c10c6dd1d 100644 --- a/deps/nghttp2/lib/includes/Makefile.in +++ b/deps/nghttp2/lib/includes/Makefile.in @@ -266,6 +266,8 @@ LIBNGTCP2_CRYPTO_BORINGSSL_CFLAGS = @LIBNGTCP2_CRYPTO_BORINGSSL_CFLAGS@ LIBNGTCP2_CRYPTO_BORINGSSL_LIBS = @LIBNGTCP2_CRYPTO_BORINGSSL_LIBS@ LIBNGTCP2_CRYPTO_QUICTLS_CFLAGS = @LIBNGTCP2_CRYPTO_QUICTLS_CFLAGS@ LIBNGTCP2_CRYPTO_QUICTLS_LIBS = @LIBNGTCP2_CRYPTO_QUICTLS_LIBS@ +LIBNGTCP2_CRYPTO_WOLFSSL_CFLAGS = @LIBNGTCP2_CRYPTO_WOLFSSL_CFLAGS@ +LIBNGTCP2_CRYPTO_WOLFSSL_LIBS = @LIBNGTCP2_CRYPTO_WOLFSSL_LIBS@ LIBNGTCP2_LIBS = @LIBNGTCP2_LIBS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ @@ -319,6 +321,8 @@ TESTLDADD = @TESTLDADD@ VERSION = @VERSION@ WARNCFLAGS = @WARNCFLAGS@ WARNCXXFLAGS = @WARNCXXFLAGS@ +WOLFSSL_CFLAGS = @WOLFSSL_CFLAGS@ +WOLFSSL_LIBS = @WOLFSSL_LIBS@ ZLIB_CFLAGS = @ZLIB_CFLAGS@ ZLIB_LIBS = @ZLIB_LIBS@ abs_builddir = @abs_builddir@ diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h index 92c3ccc6e4855a..5afd02479c34eb 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h @@ -72,6 +72,10 @@ extern "C" { # endif /* !BUILDING_NGHTTP2 */ #endif /* !defined(WIN32) */ +#ifdef BUILDING_NGHTTP2 +# undef NGHTTP2_NO_SSIZE_T +#endif /* BUILDING_NGHTTP2 */ + /** * @typedef * diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h index c2f3323459480d..40570cfa1d1392 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h @@ -29,7 +29,7 @@ * @macro * Version number of the nghttp2 library release */ -#define NGHTTP2_VERSION "1.62.1" +#define NGHTTP2_VERSION "1.63.0" /** * @macro @@ -37,6 +37,6 @@ * release. This is a 24 bit number with 8 bits for major number, 8 bits * for minor and 8 bits for patch. Version 1.2.3 becomes 0x010203. */ -#define NGHTTP2_VERSION_NUM 0x013e01 +#define NGHTTP2_VERSION_NUM 0x013f00 #endif /* NGHTTP2VER_H */ diff --git a/deps/nghttp2/lib/nghttp2_extpri.h b/deps/nghttp2/lib/nghttp2_extpri.h index 23c6ddc0c0539d..db911972084c72 100644 --- a/deps/nghttp2/lib/nghttp2_extpri.h +++ b/deps/nghttp2/lib/nghttp2_extpri.h @@ -60,6 +60,6 @@ void nghttp2_extpri_from_uint8(nghttp2_extpri *extpri, uint8_t u8extpri); * nghttp2_extpri_uint8_inc extracts inc from |PRI| which is supposed to * be constructed by nghttp2_extpri_to_uint8. */ -#define nghttp2_extpri_uint8_inc(PRI) (((PRI)&NGHTTP2_EXTPRI_INC_MASK) != 0) +#define nghttp2_extpri_uint8_inc(PRI) (((PRI) & NGHTTP2_EXTPRI_INC_MASK) != 0) #endif /* NGHTTP2_EXTPRI_H */ diff --git a/deps/nghttp2/lib/nghttp2_hd.c b/deps/nghttp2/lib/nghttp2_hd.c index cab6ec8fc7d2b4..a4137ef14ab719 100644 --- a/deps/nghttp2/lib/nghttp2_hd.c +++ b/deps/nghttp2/lib/nghttp2_hd.c @@ -35,10 +35,11 @@ /* Make scalar initialization form of nghttp2_hd_entry */ #define MAKE_STATIC_ENT(N, V, T, H) \ { \ - {NULL, NULL, (uint8_t *)(N), sizeof((N)) - 1, -1}, \ - {NULL, NULL, (uint8_t *)(V), sizeof((V)) - 1, -1}, \ - {(uint8_t *)(N), (uint8_t *)(V), sizeof((N)) - 1, sizeof((V)) - 1, 0}, \ - T, H \ + {NULL, NULL, (uint8_t *)(N), sizeof((N)) - 1, -1}, \ + {NULL, NULL, (uint8_t *)(V), sizeof((V)) - 1, -1}, \ + {(uint8_t *)(N), (uint8_t *)(V), sizeof((N)) - 1, sizeof((V)) - 1, 0}, \ + T, \ + H, \ } /* Generated by mkstatictbl.py */ diff --git a/deps/nghttp2/lib/nghttp2_helper.h b/deps/nghttp2/lib/nghttp2_helper.h index 01b85c44ed0f4d..89b0d4f535db79 100644 --- a/deps/nghttp2/lib/nghttp2_helper.h +++ b/deps/nghttp2/lib/nghttp2_helper.h @@ -64,7 +64,7 @@ nghttp2_min_def(size, size_t); #define lstreq(A, B, N) ((sizeof((A)) - 1) == (N) && memcmp((A), (B), (N)) == 0) #define nghttp2_struct_of(ptr, type, member) \ - ((type *)(void *)((char *)(ptr)-offsetof(type, member))) + ((type *)(void *)((char *)(ptr) - offsetof(type, member))) /* * Copies 2 byte unsigned integer |n| in host byte order to |buf| in diff --git a/deps/nghttp2/lib/nghttp2_submit.h b/deps/nghttp2/lib/nghttp2_submit.h index 96781d2a274515..350ee02275902a 100644 --- a/deps/nghttp2/lib/nghttp2_submit.h +++ b/deps/nghttp2/lib/nghttp2_submit.h @@ -31,7 +31,7 @@ #include -typedef struct nghttp2_data_provider_wrap nghttp2_data_provider_wrap; +#include "nghttp2_outbound_item.h" int nghttp2_submit_data_shared(nghttp2_session *session, uint8_t flags, int32_t stream_id, From 5ee234a5a6fe9e6e6a75d6f62ef46ec8ed4d49c0 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 29 Aug 2024 18:46:40 +0200 Subject: [PATCH 76/90] test,crypto: update WebCryptoAPI WPT MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refs: #54572 Refs: #54468 PR-URL: https://github.com/nodejs/node/pull/54593 Refs: https://github.com/nodejs/node/issues/54572 Refs: https://github.com/nodejs/node/pull/54468 Reviewed-By: James M Snell Reviewed-By: Benjamin Gruenbaum Reviewed-By: Michaël Zasso Reviewed-By: Yagiz Nizipli Reviewed-By: Luigi Pinca --- test/common/wpt.js | 12 +- test/fixtures/wpt/README.md | 2 +- .../derive_bits_keys/cfrg_curves_bits.js | 25 +- .../derived_bits_length.https.any.js | 11 + .../derive_bits_keys/derived_bits_length.js | 36 ++ .../derived_bits_length_testcases.js | 30 + .../derived_bits_length_vectors.js | 33 + .../derive_bits_keys/ecdh_bits.js | 19 - .../wpt/WebCryptoAPI/derive_bits_keys/hkdf.js | 19 - .../WebCryptoAPI/derive_bits_keys/pbkdf2.js | 20 - .../wpt/WebCryptoAPI/getRandomValues.any.js | 17 + .../importKey-unsettled-promise.https.any.js | 17 + .../wpt/WebCryptoAPI/sign_verify/eddsa.js | 590 ++++++------------ .../eddsa_small_order_points.https.any.js | 6 + .../sign_verify/eddsa_small_order_points.js | 26 + .../WebCryptoAPI/sign_verify/eddsa_vectors.js | 141 ++++- test/fixtures/wpt/versions.json | 2 +- test/wpt/README.md | 10 +- test/wpt/status/WebCryptoAPI.cjs | 37 ++ test/wpt/status/WebCryptoAPI.json | 8 - 20 files changed, 568 insertions(+), 493 deletions(-) create mode 100644 test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_testcases.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_vectors.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/import_export/crashtests/importKey-unsettled-promise.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_small_order_points.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_small_order_points.js create mode 100644 test/wpt/status/WebCryptoAPI.cjs delete mode 100644 test/wpt/status/WebCryptoAPI.json diff --git a/test/common/wpt.js b/test/common/wpt.js index 7917e17729c7ee..0c8805d541286e 100644 --- a/test/common/wpt.js +++ b/test/common/wpt.js @@ -458,8 +458,16 @@ class StatusLoader { load() { const dir = path.join(__dirname, '..', 'wpt'); - const statusFile = path.join(dir, 'status', `${this.path}.json`); - const result = JSON.parse(fs.readFileSync(statusFile, 'utf8')); + let statusFile = path.join(dir, 'status', `${this.path}.json`); + let result; + + if (fs.existsSync(statusFile)) { + result = JSON.parse(fs.readFileSync(statusFile, 'utf8')); + } else { + statusFile = path.join(dir, 'status', `${this.path}.cjs`); + result = require(statusFile); + } + this.rules.addRules(result); const subDir = fixtures.path('wpt', this.path); diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md index e5565462a12029..118bb456a8eecd 100644 --- a/test/fixtures/wpt/README.md +++ b/test/fixtures/wpt/README.md @@ -32,7 +32,7 @@ Last update: - user-timing: https://github.com/web-platform-tests/wpt/tree/5ae85bf826/user-timing - wasm/jsapi: https://github.com/web-platform-tests/wpt/tree/cde25e7e3c/wasm/jsapi - wasm/webapi: https://github.com/web-platform-tests/wpt/tree/fd1b23eeaa/wasm/webapi -- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/5e042cbc4e/WebCryptoAPI +- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/6748a0a246/WebCryptoAPI - webidl/ecmascript-binding/es-exceptions: https://github.com/web-platform-tests/wpt/tree/a370aad338/webidl/ecmascript-binding/es-exceptions - webmessaging/broadcastchannel: https://github.com/web-platform-tests/wpt/tree/e97fac4791/webmessaging/broadcastchannel - webstorage: https://github.com/web-platform-tests/wpt/tree/9dafa89214/webstorage diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js index ef6905e574c158..da809278a87aa5 100644 --- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js @@ -6,8 +6,6 @@ function define_tests() { // Verify the derive functions perform checks against the all-zero value results, // ensuring small-order points are rejected. // https://www.rfc-editor.org/rfc/rfc7748#section-6.1 - // TODO: The spec states that the check must be done on use, but there is discussion about doing it on import. - // https://github.com/WICG/webcrypto-secure-curves/pull/13 Object.keys(kSmallOrderPoint).forEach(function(algorithmName) { kSmallOrderPoint[algorithmName].forEach(function(test) { promise_test(async() => { @@ -23,8 +21,8 @@ function define_tests() { false, []) derived = await subtle.deriveBits({name: algorithmName, public: publicKey}, privateKey, 8 * sizes[algorithmName]); } catch (err) { - assert_false(privateKey === undefined, "Private key should be valid."); - assert_false(publicKey === undefined, "Public key should be valid."); + assert_true(privateKey !== undefined, "Private key should be valid."); + assert_true(publicKey !== undefined, "Public key should be valid."); assert_equals(err.name, "OperationError", "Should throw correct error, not " + err.name + ": " + err.message + "."); } assert_equals(derived, undefined, "Operation succeeded, but should not have."); @@ -59,25 +57,6 @@ function define_tests() { }); }, algorithmName + " mixed case parameters"); - // Null length - // "Null" is not valid per the current spec - // - https://github.com/w3c/webcrypto/issues/322 - // - https://github.com/w3c/webcrypto/issues/329 - // - // Proposal for a spec change: - // - https://github.com/w3c/webcrypto/pull/345 - // - // This test case may be replaced by these new tests: - // - https://github.com/web-platform-tests/wpt/pull/43400 - promise_test(function(test) { - return subtle.deriveBits({name: algorithmName, public: publicKeys[algorithmName]}, privateKeys[algorithmName], null) - .then(function(derivation) { - assert_true(equalBuffers(derivation, derivations[algorithmName]), "Derived correct bits"); - }, function(err) { - assert_unreached("deriveBits failed with error " + err.name + ": " + err.message); - }); - }, algorithmName + " with null length"); - // Shorter than entire derivation per algorithm promise_test(function(test) { return subtle.deriveBits({name: algorithmName, public: publicKeys[algorithmName]}, privateKeys[algorithmName], 8 * sizes[algorithmName] - 32) diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.https.any.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.https.any.js new file mode 100644 index 00000000000000..0aee2e3c172d30 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.https.any.js @@ -0,0 +1,11 @@ +// META: title=WebCryptoAPI: deriveBits() tests for the 'length' parameter +// META: script=derived_bits_length.js +// META: script=derived_bits_length_vectors.js +// META: script=derived_bits_length_testcases.js + +// Define subtests from a `promise_test` to ensure the harness does not +// complete before the subtests are available. `explicit_done` cannot be used +// for this purpose because the global `done` function is automatically invoked +// by the WPT infrastructure in dedicated worker tests defined using the +// "multi-global" pattern. +promise_test(define_tests, 'setup - define tests'); diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.js new file mode 100644 index 00000000000000..5a7ed7eb50a0a0 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length.js @@ -0,0 +1,36 @@ +function define_tests() { + // May want to test prefixed implementations. + var subtle = self.crypto.subtle; + + Object.keys(testCases).forEach(algorithm => { + let testData = algorithms[algorithm]; + testCases[algorithm].forEach(testParam => { + promise_test(async() => { + let derivedBits, privateKey, publicKey; + try { + privateKey = await subtle.importKey(testData.privateKey.format, testData.privateKey.data, testData.importAlg, false, ["deriveBits"]); + if (testData.deriveAlg.public !== undefined) { + publicKey = await subtle.importKey(testData.publicKey.format, testData.publicKey.data, testData.importAlg, false, []); + testData.deriveAlg.public = publicKey; + } + if (testParam.length === "omitted") + derivedBits = await subtle.deriveBits(testData.deriveAlg, privateKey); + else + derivedBits = await subtle.deriveBits(testData.deriveAlg, privateKey, testParam.length); + if (testParam.expected === undefined) { + assert_unreached("deriveBits should have thrown an OperationError exception."); + } + assert_array_equals(new Uint8Array(derivedBits), testParam.expected, "Derived bits do not match the expected result."); + } catch (err) { + if (err instanceof AssertionError || testParam.expected !== undefined) { + throw err; + } + assert_true(privateKey !== undefined, "Key should be valid."); + assert_equals(err.name, "OperationError", "deriveBits correctly threw OperationError: " + err.message); + } + }, algorithm + " derivation with " + testParam.length + " as 'length' parameter"); + }); + }); + + return Promise.resolve("define_tests"); +} diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_testcases.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_testcases.js new file mode 100644 index 00000000000000..1bd7fbc2c85989 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_testcases.js @@ -0,0 +1,30 @@ +var testCases = { + "HKDF": [ + {length: 256, expected: algorithms["HKDF"].derivation}, + {length: 0, expected: undefined}, // explicitly disallowed, so should throw + {length: null, expected: undefined }, // should throw an exception + {length: undefined, expected: undefined }, // should throw an exception + {length: "omitted", expected: undefined }, // default value is null, so should throw + ], + "PBKDF2": [ + {length: 256, expected: algorithms["PBKDF2"].derivation}, + {length: 0, expected: undefined}, // explicitly disallowed, so should throw + {length: null, expected: undefined }, // should throw an exception + {length: undefined, expected: undefined }, // should throw an exception + {length: "omitted", expected: undefined }, // default value is null, so should throw + ], + "ECDH": [ + {length: 256, expected: algorithms["ECDH"].derivation}, + {length: 0, expected: emptyArray}, + {length: null, expected: algorithms["ECDH"].derivation}, + {length: undefined, expected: algorithms["ECDH"].derivation}, + {length: "omitted", expected: algorithms["ECDH"].derivation }, // default value is null + ], + "X25519": [ + {length: 256, expected: algorithms["X25519"].derivation}, + {length: 0, expected: emptyArray}, + {length: null, expected: algorithms["X25519"].derivation}, + {length: undefined, expected: algorithms["X25519"].derivation}, + {length: "omitted", expected: algorithms["X25519"].derivation }, // default value is null + ], +} diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_vectors.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_vectors.js new file mode 100644 index 00000000000000..fa51f7d3f2b195 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/derived_bits_length_vectors.js @@ -0,0 +1,33 @@ +const emptyArray = new Uint8Array([]); +const rawKey = new Uint8Array([85, 115, 101, 114, 115, 32, 115, 104, 111, 117, 108, 100, 32, 112, 105, 99, 107, 32, 108, 111, 110, 103, 32, 112, 97, 115, 115, 112, 104, 114, 97, 115, 101, 115, 32, 40, 110, 111, 116, 32, 117, 115, 101, 32, 115, 104, 111, 114, 116, 32, 112, 97, 115, 115, 119, 111, 114, 100, 115, 41, 33]); +const salt = new Uint8Array([83, 111, 100, 105, 117, 109, 32, 67, 104, 108, 111, 114, 105, 100, 101, 32, 99, 111, 109, 112, 111, 117, 110, 100]); +const info = new Uint8Array([72, 75, 68, 70, 32, 101, 120, 116, 114, 97, 32, 105, 110, 102, 111]); + +var algorithms = { + "HKDF": { + importAlg: {name: "HKDF"}, + privateKey: {format: "raw", data: rawKey}, + deriveAlg: {name: "HKDF", salt: salt, hash: "SHA-256", info: info}, + derivation: new Uint8Array([49, 183, 214, 133, 48, 168, 99, 231, 23, 192, 129, 202, 105, 23, 182, 134, 80, 179, 221, 154, 41, 243, 6, 6, 226, 202, 209, 153, 190, 193, 77, 19]), + }, + "PBKDF2": { + importAlg: {name: "PBKDF2"}, + privateKey: {format: "raw", data: rawKey}, + deriveAlg: {name: "PBKDF2", salt: salt, hash: "SHA-256", iterations: 100000}, + derivation: new Uint8Array([17, 153, 45, 139, 129, 51, 17, 36, 76, 84, 75, 98, 41, 41, 69, 226, 8, 212, 3, 206, 189, 107, 149, 82, 161, 165, 98, 6, 93, 153, 88, 234]), + }, + "ECDH": { + importAlg: {name: "ECDH", namedCurve: "P-256"}, + privateKey: {format: "pkcs8", data: new Uint8Array([48, 129, 135, 2, 1, 0, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7, 4, 109, 48, 107, 2, 1, 1, 4, 32, 15, 247, 79, 232, 241, 202, 175, 97, 92, 206, 241, 29, 217, 53, 114, 87, 98, 217, 216, 65, 236, 186, 185, 94, 170, 38, 68, 123, 52, 100, 245, 113, 161, 68, 3, 66, 0, 4, 140, 96, 11, 44, 102, 25, 45, 97, 158, 39, 210, 37, 107, 59, 151, 118, 178, 141, 30, 5, 246, 13, 234, 189, 98, 174, 123, 154, 211, 157, 224, 217, 59, 4, 102, 109, 199, 119, 14, 126, 207, 13, 211, 203, 203, 211, 110, 221, 107, 94, 220, 153, 81, 7, 55, 161, 237, 104, 46, 205, 112, 244, 10, 47])}, + publicKey: {format: "spki", data: new Uint8Array([48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7, 3, 66, 0, 4, 154, 116, 32, 120, 126, 95, 77, 105, 211, 232, 34, 114, 115, 1, 109, 56, 224, 71, 129, 133, 223, 127, 238, 156, 142, 103, 60, 202, 211, 79, 126, 128, 254, 49, 141, 182, 221, 107, 119, 218, 99, 32, 165, 246, 151, 89, 9, 68, 23, 177, 52, 239, 138, 139, 116, 193, 101, 4, 57, 198, 115, 0, 90, 61])}, + deriveAlg: {name: "ECDH", public: new Uint8Array ([])}, + derivation: new Uint8Array([14, 143, 60, 77, 177, 178, 162, 131, 115, 90, 0, 220, 87, 31, 26, 232, 151, 28, 227, 35, 250, 17, 131, 137, 203, 95, 65, 196, 59, 61, 181, 161]), + }, + "X25519": { + importAlg: {name: "X25519"}, + privateKey: {format: "pkcs8", data: new Uint8Array([48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 110, 4, 34, 4, 32, 200, 131, 142, 118, 208, 87, 223, 183, 216, 201, 90, 105, 225, 56, 22, 10, 221, 99, 115, 253, 113, 164, 210, 118, 187, 86, 227, 168, 27, 100, 255, 97])}, + publicKey: {format: "spki", data: new Uint8Array([48, 42, 48, 5, 6, 3, 43, 101, 110, 3, 33, 0, 28, 242, 177, 230, 2, 46, 197, 55, 55, 30, 215, 245, 62, 84, 250, 17, 84, 216, 62, 152, 235, 100, 234, 81, 250, 229, 179, 48, 124, 254, 151, 6])}, + deriveAlg: {name: "X25519", public: new Uint8Array ([])}, + derivation: new Uint8Array([39, 104, 64, 157, 250, 185, 158, 194, 59, 140, 137, 185, 63, 245, 136, 2, 149, 247, 97, 118, 8, 143, 137, 228, 61, 254, 190, 126, 161, 149, 0, 8]), + } +}; diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/ecdh_bits.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/ecdh_bits.js index cb9747a529fd53..36b29c20a282ab 100644 --- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/ecdh_bits.js +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/ecdh_bits.js @@ -55,25 +55,6 @@ function define_tests() { }); }, namedCurve + " mixed case parameters"); - // Null length - // "Null" is not valid per the current spec - // - https://github.com/w3c/webcrypto/issues/322 - // - https://github.com/w3c/webcrypto/issues/329 - // - // Proposal for a spec change: - // - https://github.com/w3c/webcrypto/pull/345 - // - // This test case may be replaced by these new tests: - // - https://github.com/web-platform-tests/wpt/pull/43400 - promise_test(function(test) { - return subtle.deriveBits({name: "ECDH", public: publicKeys[namedCurve]}, privateKeys[namedCurve], null) - .then(function(derivation) { - assert_true(equalBuffers(derivation, derivations[namedCurve]), "Derived correct bits"); - }, function(err) { - assert_unreached("deriveBits failed with error " + err.name + ": " + err.message); - }); - }, namedCurve + " with null length"); - // Shorter than entire derivation per algorithm promise_test(function(test) { return subtle.deriveBits({name: "ECDH", public: publicKeys[namedCurve]}, privateKeys[namedCurve], 8 * sizes[namedCurve] - 32) diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/hkdf.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/hkdf.js index 3903da5cddff94..b2dfda0257bc81 100644 --- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/hkdf.js +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/hkdf.js @@ -139,25 +139,6 @@ function define_tests() { }); }, testName + " with missing info"); - // length null (OperationError) - // "Null" is not valid per the current spec - // - https://github.com/w3c/webcrypto/issues/322 - // - https://github.com/w3c/webcrypto/issues/329 - // - // Proposal for a spec change: - // - https://github.com/w3c/webcrypto/pull/345 - // - // This test case may be replaced by these new tests: - // - https://github.com/web-platform-tests/wpt/pull/43400 - subsetTest(promise_test, function(test) { - return subtle.deriveBits(algorithm, baseKeys[derivedKeySize], null) - .then(function(derivation) { - assert_unreached("null length should have thrown an OperationError"); - }, function(err) { - assert_equals(err.name, "OperationError", "deriveBits with null length correctly threw OperationError: " + err.message); - }); - }, testName + " with null length"); - // length not multiple of 8 (OperationError) subsetTest(promise_test, function(test) { return subtle.deriveBits(algorithm, baseKeys[derivedKeySize], 44) diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/pbkdf2.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/pbkdf2.js index 4e4ae79d800a40..090806ceb6b3ea 100644 --- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/pbkdf2.js +++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/pbkdf2.js @@ -103,26 +103,6 @@ function define_tests() { }); - // Test various error conditions for deriveBits below: - // length null (OperationError) - // "Null" is not valid per the current spec - // - https://github.com/w3c/webcrypto/issues/322 - // - https://github.com/w3c/webcrypto/issues/329 - // - // Proposal for a spec change: - // - https://github.com/w3c/webcrypto/pull/345 - // - // This test case may be replaced by these new tests: - // - https://github.com/web-platform-tests/wpt/pull/43400 - subsetTest(promise_test, function(test) { - return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, baseKeys[passwordSize], null) - .then(function(derivation) { - assert_unreached("null length should have thrown an OperationError"); - }, function(err) { - assert_equals(err.name, "OperationError", "deriveBits with null length correctly threw OperationError: " + err.message); - }); - }, testName + " with null length"); - // 0 length (OperationError) subsetTest(promise_test, function(test) { return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, baseKeys[passwordSize], 0) diff --git a/test/fixtures/wpt/WebCryptoAPI/getRandomValues.any.js b/test/fixtures/wpt/WebCryptoAPI/getRandomValues.any.js index 1a3370ea13d2c0..574134eb76dcd8 100644 --- a/test/fixtures/wpt/WebCryptoAPI/getRandomValues.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/getRandomValues.any.js @@ -1,4 +1,15 @@ // Step 1. +test(function() { + assert_throws_dom("TypeMismatchError", function() { + self.crypto.getRandomValues(new Float16Array(6)) + }, "Float16Array") + + assert_throws_dom("TypeMismatchError", function() { + const len = 65536 / Float16Array.BYTES_PER_ELEMENT + 1; + self.crypto.getRandomValues(new Float16Array(len)); + }, "Float16Array (too long)") +}, "Float16 arrays"); + test(function() { assert_throws_dom("TypeMismatchError", function() { self.crypto.getRandomValues(new Float32Array(6)) @@ -57,4 +68,10 @@ for (const array of arrays) { test(function() { assert_true(self.crypto.getRandomValues(new ctor(0)).length == 0) }, "Null arrays: " + array); + + test(function() { + class Buffer extends ctor {} + // Must not throw for the test to pass + self.crypto.getRandomValues(new Buffer(256)); + }, "Subclass of " + array); } diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/crashtests/importKey-unsettled-promise.https.any.js b/test/fixtures/wpt/WebCryptoAPI/import_export/crashtests/importKey-unsettled-promise.https.any.js new file mode 100644 index 00000000000000..0ceeea390ebf97 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/import_export/crashtests/importKey-unsettled-promise.https.any.js @@ -0,0 +1,17 @@ +// META: title=WebCryptoAPI: Assure promise returned by importKey is settled. +// META: timeout=long +// META: script=/common/gc.js + +'use strict'; + +promise_test(async () => { + const jwkKey = {}; + const extractable = true; + crypto.subtle.importKey("jwk", jwkKey, {name: "UNSUPPORTED", hash: "SHA-224"}, extractable, []).then( + () => { assert_unreached("Unsupported algorithm should cause promise rejection")}, + (err) => { + assert_equals(err.name, "NotSupportedError"); + }); + await garbageCollect(); +}) + diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js index d77a8808831176..de9a5268827d75 100644 --- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js +++ b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js @@ -1,363 +1,214 @@ function run_test() { - setup({explicit_done: true}); - var subtle = self.crypto.subtle; // Change to test prefixed implementations - // When are all these tests really done? When all the promises they use have resolved. - var all_promises = []; - // Source file [algorithm_name]_vectors.js provides the getTestVectors method // for the algorithm that drives these tests. var testVectors = getTestVectors(); - // Test verification first, because signing tests rely on that working testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { - var operation = subtle.verify(algorithm, vector.publicKey, vector.signature, vector.data) - .then(function(is_verified) { - assert_true(is_verified, "Signature verified"); - }, function(err) { - assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); - }); - - return operation; - }, vector.name + " verification"); - - }, function(err) { - // We need a failed test if the importVectorKey operation fails, so - // we know we never tested verification. - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " verification"); - }); - - all_promises.push(promise); - }); + var algorithm = {name: vector.algorithmName}; - // Test verification with an altered buffer after call - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { + // Test verification first, because signing tests rely on that working + promise_test(async() => { + let isVerified = false; + let key; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); + isVerified = await subtle.verify(algorithm, key, vector.signature, vector.data) + } catch (err) { + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); + }; + assert_true(isVerified, "Signature verified"); + }, vector.name + " verification"); + + // Test verification with an altered buffer after call + promise_test(async() => { + let isVerified = false; + let key; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); var signature = copyBuffer(vector.signature); - var operation = subtle.verify(algorithm, vector.publicKey, signature, vector.data) - .then(function(is_verified) { - assert_true(is_verified, "Signature verified"); - }, function(err) { - assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); - }); - - signature[0] = 255 - signature[0]; - return operation; - }, vector.name + " verification with altered signature after call"); - }, function(err) { - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " verification with altered signature after call"); - }); - - all_promises.push(promise); - }); - - // Check for successful verification even if data is altered after call. - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { + [isVerified] = await Promise.all([ + subtle.verify(algorithm, key, signature, vector.data), + signature[0] = 255 - signature[0] + ]); + } catch (err) { + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); + }; + assert_true(isVerified, "Signature verified"); + }, vector.name + " verification with altered signature after call"); + + // Check for successful verification even if data is altered after call. + promise_test(async() => { + let isVerified = false; + let key; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); var data = copyBuffer(vector.data); - var operation = subtle.verify(algorithm, vector.publicKey, vector.signature, data) - .then(function(is_verified) { - assert_true(is_verified, "Signature verified"); - }, function(err) { - assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); - }); - - data[0] = 255 - data[0]; - return operation; - }, vector.name + " with altered data after call"); - }, function(err) { - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " with altered data after call"); - }); - - all_promises.push(promise); - }); - - // Check for failures due to using privateKey to verify. - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { - return subtle.verify(algorithm, vector.privateKey, vector.signature, vector.data) - .then(function(data) { - assert_unreached("Should have thrown error for using privateKey to verify in " + vector.name + ": " + err.message + "'"); - }, function(err) { - assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'"); - }); - }, vector.name + " using privateKey to verify"); - - }, function(err) { - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " using privateKey to verify"); - }); - - all_promises.push(promise); - }); - - // Check for failures due to using publicKey to sign. - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { - return subtle.sign(algorithm, vector.publicKey, vector.data) - .then(function(signature) { - assert_unreached("Should have thrown error for using publicKey to sign in " + vector.name + ": " + err.message + "'"); - }, function(err) { - assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'"); - }); - }, vector.name + " using publicKey to sign"); - }, function(err) { - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " using publicKey to sign"); - }); - - all_promises.push(promise); - }); - - // Check for failures due to no "verify" usage. - testVectors.forEach(function(originalVector) { - var vector = Object.assign({}, originalVector); - - var promise = importVectorKeys(vector, [], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { - return subtle.verify(algorithm, vector.publicKey, vector.signature, vector.data) - .then(function(data) { - assert_unreached("Should have thrown error for no verify usage in " + vector.name + ": " + err.message + "'"); - }, function(err) { - assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'"); - }); - }, vector.name + " no verify usage"); - }, function(err) { - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " no verify usage"); - }); - - all_promises.push(promise); - }); - - // Check for successful signing and verification. - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { - return subtle.sign(algorithm, vector.privateKey, vector.data) - .then(function(signature) { - assert_true(equalBuffers(signature, vector.signature), "Signing did not give the expected output"); - // Can we verify the signature? - return subtle.verify(algorithm, vector.publicKey, signature, vector.data) - .then(function(is_verified) { - assert_true(is_verified, "Round trip verification works"); - return signature; - }, function(err) { - assert_unreached("verify error for test " + vector.name + ": " + err.message + "'"); - }); - }, function(err) { - assert_unreached("sign error for test " + vector.name + ": '" + err.message + "'"); - }); - }, vector.name + " round trip"); - - }, function(err) { - // We need a failed test if the importVectorKey operation fails, so - // we know we never tested signing or verifying - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " round trip"); - }); - - all_promises.push(promise); - }); - - // Test signing with the wrong algorithm - testVectors.forEach(function(vector) { - // Want to get the key for the wrong algorithm - var promise = subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"]) - .then(function(wrongKey) { - var algorithm = {name: vector.algorithmName}; - return importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - promise_test(function(test) { - var operation = subtle.sign(algorithm, wrongKey, vector.data) - .then(function(signature) { - assert_unreached("Signing should not have succeeded for " + vector.name); - }, function(err) { - assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'"); - }); - - return operation; - }, vector.name + " signing with wrong algorithm name"); - - }, function(err) { - // We need a failed test if the importVectorKey operation fails, so - // we know we never tested verification. - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " signing with wrong algorithm name"); - }); - }, function(err) { - promise_test(function(test) { - assert_unreached("Generate wrong key for test " + vector.name + " failed: '" + err.message + "'"); - }, "generate wrong key step: " + vector.name + " signing with wrong algorithm name"); - }); - - all_promises.push(promise); - }); - - // Test verification with the wrong algorithm - testVectors.forEach(function(vector) { - // Want to get the key for the wrong algorithm - var promise = subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"]) - .then(function(wrongKey) { - return importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; - promise_test(function(test) { - var operation = subtle.verify(algorithm, wrongKey, vector.signature, vector.data) - .then(function(signature) { - assert_unreached("Verifying should not have succeeded for " + vector.name); - }, function(err) { - assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'"); - }); - - return operation; - }, vector.name + " verifying with wrong algorithm name"); - - }, function(err) { - // We need a failed test if the importVectorKey operation fails, so - // we know we never tested verification. - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " verifying with wrong algorithm name"); - }); - }, function(err) { - promise_test(function(test) { - assert_unreached("Generate wrong key for test " + vector.name + " failed: '" + err.message + "'"); - }, "generate wrong key step: " + vector.name + " verifying with wrong algorithm name"); - }); - - all_promises.push(promise); - }); - - // Test verification fails with wrong signature - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; + [isVerified] = await Promise.all([ + subtle.verify(algorithm, key, vector.signature, data), + data[0] = 255 - data[0] + ]); + } catch (err) { + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); + }; + assert_true(isVerified, "Signature verified"); + }, vector.name + " with altered data after call"); + + // Check for failures due to using privateKey to verify. + promise_test(async() => { + let isVerified = false; + let key; + try { + key = await subtle.importKey("pkcs8", vector.privateKeyBuffer, algorithm, false, ["sign"]); + isVerified = await subtle.verify(algorithm, key, vector.signature, vector.data) + assert_unreached("Should have thrown error for using privateKey to verify in " + vector.name); + } catch (err) { + if (err instanceof AssertionError) + throw err; + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'"); + }; + assert_false(isVerified, "Signature verified"); + }, vector.name + " using privateKey to verify"); + + // Check for failures due to using publicKey to sign. + promise_test(async() => { + let isVerified = false; + let key; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); + let signature = await subtle.sign(algorithm, key, vector.data); + assert_unreached("Should have thrown error for using publicKey to sign in " + vector.name); + } catch (err) { + if (err instanceof AssertionError) + throw err; + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'"); + }; + }, vector.name + " using publicKey to sign"); + + // Check for failures due to no "verify" usage. + promise_test(async() => { + let isVerified = false; + let key; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, []); + isVerified = await subtle.verify(algorithm, key, vector.signature, vector.data) + assert_unreached("Should have thrown error for no verify usage in " + vector.name); + } catch (err) { + if (err instanceof AssertionError) + throw err; + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'"); + }; + assert_false(isVerified, "Signature verified"); + }, vector.name + " no verify usage"); + + // Check for successful signing and verification. + var algorithm = {name: vector.algorithmName}; + promise_test(async() => { + let isVerified = false; + let privateKey, publicKey; + let signature; + try { + privateKey = await subtle.importKey("pkcs8", vector.privateKeyBuffer, algorithm, false, ["sign"]); + publicKey = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); + signature = await subtle.sign(algorithm, privateKey, vector.data); + isVerified = await subtle.verify(algorithm, publicKey, vector.signature, vector.data) + } catch (err) { + assert_false(publicKey === undefined || privateKey === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_false(signature === undefined, "sign error for test " + vector.name + ": '" + err.message + "'"); + assert_unreached("verify error for test " + vector.name + ": " + err.message + "'"); + }; + assert_true(isVerified, "Round trip verification works"); + }, vector.name + " round trip"); + + // Test signing with the wrong algorithm + var algorithm = {name: vector.algorithmName}; + promise_test(async() => { + let wrongKey; + try { + wrongKey = await subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"]) + let signature = await subtle.sign(algorithm, wrongKey, vector.data); + assert_unreached("Signing should not have succeeded for " + vector.name); + } catch (err) { + if (err instanceof AssertionError) + throw err; + assert_false(wrongKey === undefined, "Generate wrong key for test " + vector.name + " failed: '" + err.message + "'"); + assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'"); + }; + }, vector.name + " signing with wrong algorithm name"); + + // Test verification with the wrong algorithm + var algorithm = {name: vector.algorithmName}; + promise_test(async() => { + let wrongKey; + try { + wrongKey = await subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"]) + let isVerified = await subtle.verify(algorithm, wrongKey, vector.signature, vector.data) + assert_unreached("Verifying should not have succeeded for " + vector.name); + } catch (err) { + if (err instanceof AssertionError) + throw err; + assert_false(wrongKey === undefined, "Generate wrong key for test " + vector.name + " failed: '" + err.message + "'"); + assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'"); + }; + }, vector.name + " verifying with wrong algorithm name"); + + // Test verification fails with wrong signature + var algorithm = {name: vector.algorithmName}; + promise_test(async() => { + let key; + let isVerified = true; var signature = copyBuffer(vector.signature); signature[0] = 255 - signature[0]; - promise_test(function(test) { - var operation = subtle.verify(algorithm, vector.publicKey, signature, vector.data) - .then(function(is_verified) { - assert_false(is_verified, "Signature NOT verified"); - }, function(err) { - assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); - }); - - return operation; - }, vector.name + " verification failure due to altered signature"); - - }, function(err) { - // We need a failed test if the importVectorKey operation fails, so - // we know we never tested verification. - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " verification failure due to altered signature"); - }); - - all_promises.push(promise); - }); - - // Test verification fails with short (odd length) signature - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); + isVerified = await subtle.verify(algorithm, key, signature, vector.data) + } catch (err) { + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); + }; + assert_false(isVerified, "Signature verified"); + }, vector.name + " verification failure due to altered signature"); + + // Test verification fails with short (odd length) signature + promise_test(async() => { + let key; + let isVerified = true; var signature = vector.signature.slice(1); // Skip the first byte - promise_test(function(test) { - var operation = subtle.verify(algorithm, vector.publicKey, signature, vector.data) - .then(function(is_verified) { - assert_false(is_verified, "Signature NOT verified"); - }, function(err) { - assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); - }); - - return operation; - }, vector.name + " verification failure due to shortened signature"); - - }, function(err) { - // We need a failed test if the importVectorKey operation fails, so - // we know we never tested verification. - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " verification failure due to shortened signature"); - }); - - all_promises.push(promise); - }); - - // Test verification fails with wrong data - testVectors.forEach(function(vector) { - var promise = importVectorKeys(vector, ["verify"], ["sign"]) - .then(function(vectors) { - var algorithm = {name: vector.algorithmName}; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); + isVerified = await subtle.verify(algorithm, key, signature, vector.data) + } catch (err) { + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); + }; + assert_false(isVerified, "Signature verified"); + }, vector.name + " verification failure due to shortened signature"); + + // Test verification fails with wrong data + promise_test(async() => { + let key; + let isVerified = true; var data = copyBuffer(vector.data); data[0] = 255 - data[0]; - promise_test(function(test) { - var operation = subtle.verify(algorithm, vector.publicKey, vector.signature, data) - .then(function(is_verified) { - assert_false(is_verified, "Signature NOT verified"); - }, function(err) { - assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); - }); - - return operation; - }, vector.name + " verification failure due to altered data"); - - }, function(err) { - // We need a failed test if the importVectorKey operation fails, so - // we know we never tested verification. - promise_test(function(test) { - assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''"); - }, "importVectorKeys step: " + vector.name + " verification failure due to altered data"); - }); - - all_promises.push(promise); - }); - - - promise_test(function() { - return Promise.all(all_promises) - .then(function() {done();}) - .catch(function() {done();}) - }, "setup"); - - // Test that generated keys are valid for signing and verifying. - testVectors.forEach(function(vector) { - var algorithm = {name: vector.algorithmName}; + try { + key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]); + isVerified = await subtle.verify(algorithm, key, vector.signature, data) + } catch (err) { + assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''"); + assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'"); + }; + assert_false(isVerified, "Signature verified"); + }, vector.name + " verification failure due to altered data"); + + // Test that generated keys are valid for signing and verifying. promise_test(async() => { let key = await subtle.generateKey(algorithm, false, ["sign", "verify"]); let signature = await subtle.sign(algorithm, key.privateKey, vector.data); @@ -366,42 +217,6 @@ function run_test() { }, "Sign and verify using generated " + vector.algorithmName + " keys."); }); - - // A test vector has all needed fields for signing and verifying, EXCEPT that the - // key field may be null. This function replaces that null with the Correct - // CryptoKey object. - // - // Returns a Promise that yields an updated vector on success. - function importVectorKeys(vector, publicKeyUsages, privateKeyUsages) { - var publicPromise, privatePromise; - - if (vector.publicKey !== null) { - publicPromise = new Promise(function(resolve, reject) { - resolve(vector); - }); - } else { - publicPromise = subtle.importKey(vector.publicKeyFormat, vector.publicKeyBuffer, {name: vector.algorithmName}, false, publicKeyUsages) - .then(function(key) { - vector.publicKey = key; - return vector; - }); // Returns a copy of the sourceBuffer it is sent. - } - - if (vector.privateKey !== null) { - privatePromise = new Promise(function(resolve, reject) { - resolve(vector); - }); - } else { - privatePromise = subtle.importKey(vector.privateKeyFormat, vector.privateKeyBuffer, {name: vector.algorithmName}, false, privateKeyUsages) - .then(function(key) { - vector.privateKey = key; - return vector; - }); - } - - return Promise.all([publicPromise, privatePromise]); - } - // Returns a copy of the sourceBuffer it is sent. function copyBuffer(sourceBuffer) { var source = new Uint8Array(sourceBuffer); @@ -414,22 +229,5 @@ function run_test() { return copy; } - function equalBuffers(a, b) { - if (a.byteLength !== b.byteLength) { - return false; - } - - var aBytes = new Uint8Array(a); - var bBytes = new Uint8Array(b); - - for (var i=0; i { + let isVerified = true; + let publicKey; + try { + publicKey = await subtle.importKey("raw", test.keyData, algorithm, false, ["verify"]) + isVerified = await subtle.verify(algorithm, publicKey, test.signature, test.message); + } catch (err) { + assert_true(publicKey !== undefined, "Public key should be valid."); + assert_unreached("The operation shouldn't fail, but it thown this error: " + err.name + ": " + err.message + "."); + } + assert_equals(isVerified, test.verified, "Signature verification result."); + }, algorithmName + " Verification checks with small-order key of order - Test " + test.id); + }); + }); + + return; +} diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js index 96ec2b01af96f2..ce80e0ea7e2626 100644 --- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js +++ b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js @@ -53,6 +53,145 @@ function getTestVectors() { vectors.push(vector); }); - return vectors; } + +// https://eprint.iacr.org/2020/1244.pdf#table.caption.3 +var kSmallOrderPoints = [ + // Canonical serializations + [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // #0 - Order 1 + [0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // #1 - Order 2 + [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80], // #2 - Order 4 + [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // #3 - Order 4 + [0xC7, 0x17, 0x6A, 0x70, 0x3D, 0x4D, 0xD8, 0x4F, 0xBA, 0x3C, 0x0B, 0x76, 0x0D, 0x10, 0x67, 0x0F, 0x2A, 0x20, 0x53, 0xFA, 0x2C, 0x39, 0xCC, 0xC6, 0x4E, 0xC7, 0xFD, 0x77, 0x92, 0xAC, 0x03, 0x7A], // #4 - Order 8 + [0xC7, 0x17, 0x6A, 0x70, 0x3D, 0x4D, 0xD8, 0x4F, 0xBA, 0x3C, 0x0B, 0x76, 0x0D, 0x10, 0x67, 0x0F, 0x2A, 0x20, 0x53, 0xFA, 0x2C, 0x39, 0xCC, 0xC6, 0x4E, 0xC7, 0xFD, 0x77, 0x92, 0xAC, 0x03, 0xFA], // #5 - Order 8 + [0x26, 0xE8, 0x95, 0x8F, 0xC2, 0xB2, 0x27, 0xB0, 0x45, 0xC3, 0xF4, 0x89, 0xF2, 0xEF, 0x98, 0xF0, 0xD5, 0xDF, 0xAC, 0x05, 0xD3, 0xC6, 0x33, 0x39, 0xB1, 0x38, 0x02, 0x88, 0x6D, 0x53, 0xFC, 0x05], // #6 - Order 8 + [0x26, 0xE8, 0x95, 0x8F, 0xC2, 0xB2, 0x27, 0xB0, 0x45, 0xC3, 0xF4, 0x89, 0xF2, 0xEF, 0x98, 0xF0, 0xD5, 0xDF, 0xAC, 0x05, 0xD3, 0xC6, 0x33, 0x39, 0xB1, 0x38, 0x02, 0x88, 0x6D, 0x53, 0xFC, 0x85], // #7 - Order 8 + + // Non-canonical serializatons + [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80], // #8 - Order 1 + [0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], // #9 - Order 2 + [0xEE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // #10 - Order 1 + [0xEE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], // #11 - Order 1 + [0xED, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], // #12 - Order 4 + [0xED, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // #13 - Order 4 +]; + + +var pubKeys = [ + [0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f, 0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f, 0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6, 0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0xfa], // kSmallOrderPoints #5 + [0xf7, 0xba, 0xde, 0xc5, 0xb8, 0xab, 0xea, 0xf6, 0x99, 0x58, 0x39, 0x92, 0x21, 0x9b, 0x7b, 0x22, 0x3f, 0x1d, 0xf3, 0xfb, 0xbe, 0xa9, 0x19, 0x84, 0x4e, 0x3f, 0x7c, 0x55, 0x4a, 0x43, 0xdd, 0x43], // highest 32 bytes of case "1" signature + [0xcd, 0xb2, 0x67, 0xce, 0x40, 0xc5, 0xcd, 0x45, 0x30, 0x6f, 0xa5, 0xd2, 0xf2, 0x97, 0x31, 0x45, 0x93, 0x87, 0xdb, 0xf9, 0xeb, 0x93, 0x3b, 0x7b, 0xd5, 0xae, 0xd9, 0xa7, 0x65, 0xb8, 0x8d, 0x4d], + [0x44, 0x2a, 0xad, 0x9f, 0x08, 0x9a, 0xd9, 0xe1, 0x46, 0x47, 0xb1, 0xef, 0x90, 0x99, 0xa1, 0xff, 0x47, 0x98, 0xd7, 0x85, 0x89, 0xe6, 0x6f, 0x28, 0xec, 0xa6, 0x9c, 0x11, 0xf5, 0x82, 0xa6, 0x23], + [0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], // kSmallOrderPoints #9 + [0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // kSmallOrderPoints #1 +] + +// https://eprint.iacr.org/2020/1244.pdf +// signature = (R, S); public key A, h = SHA512(R||A||M ) +// 8(SB) = 8R + 8(hA) => (1) +// SB = R + hA => (2) +var kSmallOrderTestCases = { + "Ed25519": [ + { + id: "0", // S = 0 | A's order = small | R's order = small | (1) = pass | (2) = pass + message : Uint8Array.from([0x8c, 0x93, 0x25, 0x5d, 0x71, 0xdc, 0xab, 0x10, 0xe8, 0xf3, 0x79, 0xc2, 0x62, 0x00, 0xf3, 0xc7, 0xbd, 0x5f, 0x09, 0xd9, 0xbc, 0x30, 0x68, 0xd3, 0xef, 0x4e, 0xde, 0xb4, 0x85, 0x30, 0x22, 0xb6]), + keyData : Uint8Array.from(pubKeys[0]), + signature : Uint8Array.from([0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f, 0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f, 0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6, 0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), + verified: false, // small-order signature's R fail in the verification. + }, + { + id: "1", // 0 < S < L | A's order = small | R's order = mixed | (1) = pass | (2) = pass + message : Uint8Array.from([0x9b, 0xd9, 0xf4, 0x4f, 0x4d, 0xcc, 0x75, 0xbd, 0x53, 0x1b, 0x56, 0xb2, 0xcd, 0x28, 0x0b, 0x0b, 0xb3, 0x8f, 0xc1, 0xcd, 0x6d, 0x12, 0x30, 0xe1, 0x48, 0x61, 0xd8, 0x61, 0xde, 0x09, 0x2e, 0x79]), + keyData : Uint8Array.from(pubKeys[0]), + signature : Uint8Array.from([0xf7, 0xba, 0xde, 0xc5, 0xb8, 0xab, 0xea, 0xf6, 0x99, 0x58, 0x39, 0x92, 0x21, 0x9b, 0x7b, 0x22, 0x3f, 0x1d, 0xf3, 0xfb, 0xbe, 0xa9, 0x19, 0x84, 0x4e, 0x3f, 0x7c, 0x55, 0x4a, 0x43, 0xdd, 0x43, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]), + verified: false, // small-order key's data fail in the verification. + }, + { + id: "2", // 0 < S < L | A's order = mixed | R's order = small | (1) = pass | (2) = pass + message : Uint8Array.from([0xae, 0xbf, 0x3f, 0x26, 0x01, 0xa0, 0xc8, 0xc5, 0xd3, 0x9c, 0xc7, 0xd8, 0x91, 0x16, 0x42, 0xf7, 0x40, 0xb7, 0x81, 0x68, 0x21, 0x8d, 0xa8, 0x47, 0x17, 0x72, 0xb3, 0x5f, 0x9d, 0x35, 0xb9, 0xab]), + keyData : Uint8Array.from(pubKeys[1]), + signature : Uint8Array.from([0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f, 0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f, 0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6, 0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0xfa, 0x8c, 0x4b, 0xd4, 0x5a, 0xec, 0xac, 0xa5, 0xb2, 0x4f, 0xb9, 0x7b, 0xc1, 0x0a, 0xc2, 0x7a, 0xc8, 0x75, 0x1a, 0x7d, 0xfe, 0x1b, 0xaf, 0xf8, 0xb9, 0x53, 0xec, 0x9f, 0x58, 0x33, 0xca, 0x26, 0x0e]), + verified: false, // small-order signature's R fail in the verification. + }, + { + id: "3", // 0 < S < L | A's order = mixed | R's order = mixed | (1) = pass | (2) = pass + message : Uint8Array.from([0x9b, 0xd9, 0xf4, 0x4f, 0x4d, 0xcc, 0x75, 0xbd, 0x53, 0x1b, 0x56, 0xb2, 0xcd, 0x28, 0x0b, 0x0b, 0xb3, 0x8f, 0xc1, 0xcd, 0x6d, 0x12, 0x30, 0xe1, 0x48, 0x61, 0xd8, 0x61, 0xde, 0x09, 0x2e, 0x79]), + keyData : Uint8Array.from(pubKeys[2]), + signature : Uint8Array.from([0x90, 0x46, 0xa6, 0x47, 0x50, 0x44, 0x49, 0x38, 0xde, 0x19, 0xf2, 0x27, 0xbb, 0x80, 0x48, 0x5e, 0x92, 0xb8, 0x3f, 0xdb, 0x4b, 0x65, 0x06, 0xc1, 0x60, 0x48, 0x4c, 0x01, 0x6c, 0xc1, 0x85, 0x2f, 0x87, 0x90, 0x9e, 0x14, 0x42, 0x8a, 0x7a, 0x1d, 0x62, 0xe9, 0xf2, 0x2f, 0x3d, 0x3a, 0xd7, 0x80, 0x2d, 0xb0, 0x2e, 0xb2, 0xe6, 0x88, 0xb6, 0xc5, 0x2f, 0xcd, 0x66, 0x48, 0xa9, 0x8b, 0xd0, 0x09]), + verified: true, // mixed-order points are not checked. + }, + { + id: "4", // 0 < S < L | A's order = mixed | R's order = mixed | (1) = pass | (2) = fail + message : Uint8Array.from([0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40, 0x11, 0xea, 0xcc, 0xd5, 0x5b, 0x53, 0xf5, 0x6c]), + keyData : Uint8Array.from(pubKeys[2]), + signature : Uint8Array.from([0x16, 0x0a, 0x1c, 0xb0, 0xdc, 0x9c, 0x02, 0x58, 0xcd, 0x0a, 0x7d, 0x23, 0xe9, 0x4d, 0x8f, 0xa8, 0x78, 0xbc, 0xb1, 0x92, 0x5f, 0x2c, 0x64, 0x24, 0x6b, 0x2d, 0xee, 0x17, 0x96, 0xbe, 0xd5, 0x12, 0x5e, 0xc6, 0xbc, 0x98, 0x2a, 0x26, 0x9b, 0x72, 0x3e, 0x06, 0x68, 0xe5, 0x40, 0x91, 0x1a, 0x9a, 0x6a, 0x58, 0x92, 0x1d, 0x69, 0x25, 0xe4, 0x34, 0xab, 0x10, 0xaa, 0x79, 0x40, 0x55, 0x1a, 0x09]), + verified: false, // expect a cofactorless verification algorithm. + }, + { + id: "5", // 0 < S < L | A's order = mixed | R's order = L | (1) = pass | (2) = fail + message : Uint8Array.from([0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40, 0x11, 0xea, 0xcc, 0xd5, 0x5b, 0x53, 0xf5, 0x6c]), + keyData : Uint8Array.from(pubKeys[2]), + signature : Uint8Array.from([0x21, 0x12, 0x2a, 0x84, 0xe0, 0xb5, 0xfc, 0xa4, 0x05, 0x2f, 0x5b, 0x12, 0x35, 0xc8, 0x0a, 0x53, 0x78, 0x78, 0xb3, 0x8f, 0x31, 0x42, 0x35, 0x6b, 0x2c, 0x23, 0x84, 0xeb, 0xad, 0x46, 0x68, 0xb7, 0xe4, 0x0b, 0xc8, 0x36, 0xda, 0xc0, 0xf7, 0x10, 0x76, 0xf9, 0xab, 0xe3, 0xa5, 0x3f, 0x9c, 0x03, 0xc1, 0xce, 0xee, 0xdd, 0xb6, 0x58, 0xd0, 0x03, 0x04, 0x94, 0xac, 0xe5, 0x86, 0x68, 0x74, 0x05]), + verified: false, // expect a cofactorless verification algorithm. + }, + { + id: "6", // S > L | A's order = L | R's order = L | (1) = pass | (2) = pass + message : Uint8Array.from([0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41, 0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40]), + keyData : Uint8Array.from(pubKeys[3]), + signature : Uint8Array.from([0xe9, 0x6f, 0x66, 0xbe, 0x97, 0x6d, 0x82, 0xe6, 0x01, 0x50, 0xba, 0xec, 0xff, 0x99, 0x06, 0x68, 0x4a, 0xeb, 0xb1, 0xef, 0x18, 0x1f, 0x67, 0xa7, 0x18, 0x9a, 0xc7, 0x8e, 0xa2, 0x3b, 0x6c, 0x0e, 0x54, 0x7f, 0x76, 0x90, 0xa0, 0xe2, 0xdd, 0xcd, 0x04, 0xd8, 0x7d, 0xbc, 0x34, 0x90, 0xdc, 0x19, 0xb3, 0xb3, 0x05, 0x2f, 0x7f, 0xf0, 0x53, 0x8c, 0xb6, 0x8a, 0xfb, 0x36, 0x9b, 0xa3, 0xa5, 0x14]), + verified: false, // S out of bounds + }, + { + id: "7", // S >> L | A's order = L | R's order = L | (1) = pass | (2) = pass + message : Uint8Array.from([0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41, 0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40]), + keyData : Uint8Array.from(pubKeys[3]), + signature : Uint8Array.from([0x8c, 0xe5, 0xb9, 0x6c, 0x8f, 0x26, 0xd0, 0xab, 0x6c, 0x47, 0x95, 0x8c, 0x9e, 0x68, 0xb9, 0x37, 0x10, 0x4c, 0xd3, 0x6e, 0x13, 0xc3, 0x35, 0x66, 0xac, 0xd2, 0xfe, 0x8d, 0x38, 0xaa, 0x19, 0x42, 0x7e, 0x71, 0xf9, 0x8a, 0x47, 0x34, 0xe7, 0x4f, 0x2f, 0x13, 0xf0, 0x6f, 0x97, 0xc2, 0x0d, 0x58, 0xcc, 0x3f, 0x54, 0xb8, 0xbd, 0x0d, 0x27, 0x2f, 0x42, 0xb6, 0x95, 0xdd, 0x7e, 0x89, 0xa8, 0xc2, 0x02]), + verified: false, // S out of bounds + }, + { + id: "8", // 0 < S < L | A's order = mixed | R's order = small (non-canonical) | (1) = ? | (2) = ? Implementations that reduce A before hashing will accept #8 and accept #9, and viceversa + message : Uint8Array.from([0x9b, 0xed, 0xc2, 0x67, 0x42, 0x37, 0x25, 0xd4, 0x73, 0x88, 0x86, 0x31, 0xeb, 0xf4, 0x59, 0x88, 0xba, 0xd3, 0xdb, 0x83, 0x85, 0x1e, 0xe8, 0x5c, 0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41]), + keyData : Uint8Array.from(pubKeys[1]), + signature : Uint8Array.from([0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xbe, 0x96, 0x78, 0xac, 0x10, 0x2e, 0xdc, 0xd9, 0x2b, 0x02, 0x10, 0xbb, 0x34, 0xd7, 0x42, 0x8d, 0x12, 0xff, 0xc5, 0xdf, 0x5f, 0x37, 0xe3, 0x59, 0x94, 0x12, 0x66, 0xa4, 0xe3, 0x5f, 0x0f]), + verified: false, // non-canonical point should fail in the verificaton (RFC8032) + }, + { + id: "9", // 0 < S < L | A's order = mixed | R's order = small (non-canonical) | (1) = ? | (2) = ? + message : Uint8Array.from([0x9b, 0xed, 0xc2, 0x67, 0x42, 0x37, 0x25, 0xd4, 0x73, 0x88, 0x86, 0x31, 0xeb, 0xf4, 0x59, 0x88, 0xba, 0xd3, 0xdb, 0x83, 0x85, 0x1e, 0xe8, 0x5c, 0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41]), + keyData : Uint8Array.from(pubKeys[1]), + signature : Uint8Array.from([0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x8c, 0x5b, 0x64, 0xcd, 0x20, 0x89, 0x82, 0xaa, 0x38, 0xd4, 0x93, 0x66, 0x21, 0xa4, 0x77, 0x5a, 0xa2, 0x33, 0xaa, 0x05, 0x05, 0x71, 0x1d, 0x8f, 0xdc, 0xfd, 0xaa, 0x94, 0x3d, 0x49, 0x08]), + verified: false, // non-canonical point should fail in the verificaton (RFC8032) + }, + { + id: "10", // 0 < S < L | A's order = small (non-canonical) | R's order = mixed | (1) = ? | (2) = ? Implementations that reduce A before hashing will accept #10 and accept #11, and viceversa + message : Uint8Array.from([0xe9, 0x6b, 0x70, 0x21, 0xeb, 0x39, 0xc1, 0xa1, 0x63, 0xb6, 0xda, 0x4e, 0x30, 0x93, 0xdc, 0xd3, 0xf2, 0x13, 0x87, 0xda, 0x4c, 0xc4, 0x57, 0x2b, 0xe5, 0x88, 0xfa, 0xfa, 0xe2, 0x3c, 0x15, 0x5b]), + keyData : Uint8Array.from(pubKeys[4]), + signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]), + verified: false, // non-canonical point should fail in the verificaton (RFC8032) + }, + { + id: "11", // 0 < S < L | A's order = small (non-canonical) | R's order = mixed | (1) = ? | (2) = ? Implementations that reduce A before hashing will accept #10 and accept #11, and viceversa + message : Uint8Array.from([0x39, 0xa5, 0x91, 0xf5, 0x32, 0x1b, 0xbe, 0x07, 0xfd, 0x5a, 0x23, 0xdc, 0x2f, 0x39, 0xd0, 0x25, 0xd7, 0x45, 0x26, 0x61, 0x57, 0x46, 0x72, 0x7c, 0xee, 0xfd, 0x6e, 0x82, 0xae, 0x65, 0xc0, 0x6f]), + keyData : Uint8Array.from(pubKeys[4]), + signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]), + verified: false, // non-canonical point should fail in the verificaton (RFC8032) + }, + // https://eprint.iacr.org/2020/1244.pdf#section.A.2 + // cases breaking non-repudiation + { + id: "12", // 0 < S < L | A's order = small | R's order = mixed | (1) = ? | (2) = ? + message : Uint8Array.from([0x53, 0x65, 0x6e, 0x64, 0x20, 0x31, 0x30, 0x30, 0x20, 0x55, 0x53, 0x44, 0x20, 0x74, 0x6f, 0x20, 0x41, 0x6c, 0x69, 0x63, 0x65]), + keyData : Uint8Array.from(pubKeys[5]), + signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]), + verified: false, + }, + { + id: "13", // 0 < S < L | A's order = small | R's order = mixed | (1) = ? | (2) = ? + message : Uint8Array.from([0x53, 0x65, 0x6e, 0x64, 0x20, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x55, 0x53, 0x44, 0x20, 0x74, 0x6f, 0x20, 0x41, 0x6c, 0x69, 0x63, 0x65]), + keyData : Uint8Array.from(pubKeys[5]), + signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]), + verified: false, + } + ] +}; diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json index c9320269a28f2a..43b1f480d1f18c 100644 --- a/test/fixtures/wpt/versions.json +++ b/test/fixtures/wpt/versions.json @@ -88,7 +88,7 @@ "path": "wasm/webapi" }, "WebCryptoAPI": { - "commit": "5e042cbc4ecab7b2279a5fd411c6daa24ca886c6", + "commit": "6748a0a24614b01ce6527493a19ef846738bee3a", "path": "WebCryptoAPI" }, "webidl/ecmascript-binding/es-exceptions": { diff --git a/test/wpt/README.md b/test/wpt/README.md index 0f73062e289a47..df890d5d832ee0 100644 --- a/test/wpt/README.md +++ b/test/wpt/README.md @@ -27,7 +27,7 @@ it's not yet clear how compliant the implementation is, the requirements and expected failures can be figured out in a later step when the tests are run for the first time. -See [Format of a status JSON file](#status-format) for details. +See [Format of a status file](#status-format) for details. ### 2. Pull the WPT files @@ -98,7 +98,7 @@ add this to `test/wpt/status/url.json`: } ``` -See [Format of a status JSON file](#status-format) for details. +See [Format of a status file](#status-format) for details. ### 5. Commit the changes and submit a Pull Request @@ -147,7 +147,7 @@ expected failures. -## Format of a status JSON file +## Format of a status file ```json { @@ -177,6 +177,10 @@ A test may have to be skipped because it depends on another irrelevant Web API, or certain harness has not been ported in our test runner yet. In that case it needs to be marked with `skip` instead of `fail`. +The status file may optionally also be a CJS module that exports the object. +This allows for more complex logic to be used to determine the expected status +of a test. + [Web Platform Tests]: https://github.com/web-platform-tests/wpt [`test/fixtures/wpt/README.md`]: ../fixtures/wpt/README.md [git node wpt]: https://github.com/nodejs/node-core-utils/blob/HEAD/docs/git-node.md#git-node-wpt diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs new file mode 100644 index 00000000000000..0057d5f72cc937 --- /dev/null +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -0,0 +1,37 @@ +'use strict'; + +const os = require('node:os'); + +const s390x = os.arch() === 's390x'; + +module.exports = { + 'algorithm-discards-context.https.window.js': { + 'skip': 'Not relevant in Node.js context', + }, + 'historical.any.js': { + 'skip': 'Not relevant in Node.js context', + }, + 'getRandomValues.any.js': { + 'fail': { + 'note': 'Node.js does not support Float16Array', + 'expected': [ + 'Float16 arrays', + ], + }, + }, + 'sign_verify/eddsa_small_order_points.https.any.js': { + 'fail': { + 'note': 'see https://github.com/nodejs/node/issues/54572', + 'expected': [ + 'Ed25519 Verification checks with small-order key of order - Test 1', + 'Ed25519 Verification checks with small-order key of order - Test 2', + 'Ed25519 Verification checks with small-order key of order - Test 12', + 'Ed25519 Verification checks with small-order key of order - Test 13', + ...(s390x ? [] : [ + 'Ed25519 Verification checks with small-order key of order - Test 0', + 'Ed25519 Verification checks with small-order key of order - Test 11', + ]), + ], + }, + }, +}; diff --git a/test/wpt/status/WebCryptoAPI.json b/test/wpt/status/WebCryptoAPI.json deleted file mode 100644 index 9f9ba93240be25..00000000000000 --- a/test/wpt/status/WebCryptoAPI.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "algorithm-discards-context.https.window.js": { - "skip": "Not relevant in Node.js context" - }, - "historical.any.js": { - "skip": "Not relevant in Node.js context" - } -} From c74f2aeb92700c4f0d792d5c7ee50043860dec73 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Mon, 26 Aug 2024 21:05:07 -0700 Subject: [PATCH 77/90] test: update test-assert to use node:test PR-URL: https://github.com/nodejs/node/pull/54585 Reviewed-By: Yagiz Nizipli Reviewed-By: Colin Ihrig --- test/parallel/test-assert-strict-exists.js | 6 - test/parallel/test-assert.js | 1836 ++++++++++---------- 2 files changed, 912 insertions(+), 930 deletions(-) delete mode 100644 test/parallel/test-assert-strict-exists.js diff --git a/test/parallel/test-assert-strict-exists.js b/test/parallel/test-assert-strict-exists.js deleted file mode 100644 index 50cd8a49a70aa5..00000000000000 --- a/test/parallel/test-assert-strict-exists.js +++ /dev/null @@ -1,6 +0,0 @@ -'use strict'; - -require('../common'); -const assert = require('assert'); - -assert.strictEqual(require('assert/strict'), assert.strict); diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js index 1679edb2941808..b5e5bb1c9b0a29 100644 --- a/test/parallel/test-assert.js +++ b/test/parallel/test-assert.js @@ -21,11 +21,11 @@ 'use strict'; -const common = require('../common'); +const { invalidArgTypeHelper } = require('../common'); const assert = require('assert'); const { inspect } = require('util'); +const { test } = require('node:test'); const vm = require('vm'); -const a = assert; // Disable colored output to prevent color codes from breaking assertion // message comparisons. This should only be an issue when process.stdout @@ -37,14 +37,31 @@ const strictEqualMessageStart = 'Expected values to be strictly equal:\n'; const start = 'Expected values to be strictly deep-equal:'; const actExp = '+ actual - expected'; -assert.ok(a.AssertionError.prototype instanceof Error, - 'a.AssertionError instanceof Error'); - -assert.throws(() => a(false), a.AssertionError, 'ok(false)'); -assert.throws(() => a.ok(false), a.AssertionError, 'ok(false)'); +/* eslint-disable no-restricted-syntax */ +/* eslint-disable no-restricted-properties */ + +test('some basics', () => { + assert.ok(assert.AssertionError.prototype instanceof Error, + 'assert.AssertionError instanceof Error'); + + assert.throws(() => assert(false), assert.AssertionError, 'ok(false)'); + assert.throws(() => assert.ok(false), assert.AssertionError, 'ok(false)'); + assert(true); + assert('test', 'ok(\'test\')'); + assert.ok(true); + assert.ok('test'); + assert.throws(() => assert.equal(true, false), + assert.AssertionError, 'equal(true, false)'); + assert.equal(null, null); + assert.equal(undefined, undefined); + assert.equal(null, undefined); + assert.equal(true, true); + assert.equal(2, '2'); + assert.notEqual(true, false); + assert.notStrictEqual(2, '2'); +}); -// Throw message if the message is instanceof Error. -{ +test('Throw message if the message is instanceof Error', () => { let threw = false; try { assert.ok(false, new Error('ok(false)')); @@ -53,10 +70,9 @@ assert.throws(() => a.ok(false), a.AssertionError, 'ok(false)'); assert.ok(e instanceof Error); } assert.ok(threw, 'Error: ok(false)'); -} +}); -// Errors created in different contexts are handled as any other custom error -{ +test('Errors created in different contexts are handled as any other custom error', () => { const context = vm.createContext(); const error = vm.runInContext('new SyntaxError("custom error")', context); @@ -64,219 +80,213 @@ assert.throws(() => a.ok(false), a.AssertionError, 'ok(false)'); message: 'custom error', name: 'SyntaxError' }); -} +}); -a(true); -a('test', 'ok(\'test\')'); -a.ok(true); -a.ok('test'); +test('assert.throws()', () => { + assert.throws(() => assert.notEqual(true, true), + assert.AssertionError, 'notEqual(true, true)'); -assert.throws(() => a.equal(true, false), - a.AssertionError, 'equal(true, false)'); + assert.throws(() => assert.strictEqual(2, '2'), + assert.AssertionError, 'strictEqual(2, \'2\')'); -a.equal(null, null); -a.equal(undefined, undefined); -a.equal(null, undefined); -a.equal(true, true); -a.equal(2, '2'); -a.notEqual(true, false); + assert.throws(() => assert.strictEqual(null, undefined), + assert.AssertionError, 'strictEqual(null, undefined)'); -assert.throws(() => a.notEqual(true, true), - a.AssertionError, 'notEqual(true, true)'); + assert.throws( + () => assert.notStrictEqual(2, 2), + { + message: 'Expected "actual" to be strictly unequal to: 2', + name: 'AssertionError' + } + ); -assert.throws(() => a.strictEqual(2, '2'), - a.AssertionError, 'strictEqual(2, \'2\')'); + assert.throws( + () => assert.notStrictEqual('a '.repeat(30), 'a '.repeat(30)), + { + message: 'Expected "actual" to be strictly unequal to:\n\n' + + `'${'a '.repeat(30)}'`, + name: 'AssertionError' + } + ); -/* eslint-disable no-restricted-syntax */ -assert.throws(() => a.strictEqual(null, undefined), - a.AssertionError, 'strictEqual(null, undefined)'); + assert.throws( + () => assert.notEqual(1, 1), + { + message: '1 != 1', + operator: '!=' + } + ); -assert.throws( - () => a.notStrictEqual(2, 2), - { - message: 'Expected "actual" to be strictly unequal to: 2', - name: 'AssertionError' + // Testing the throwing. + function thrower(errorConstructor) { + throw new errorConstructor({}); } -); -assert.throws( - () => a.notStrictEqual('a '.repeat(30), 'a '.repeat(30)), + // The basic calls work. + assert.throws(() => thrower(assert.AssertionError), assert.AssertionError, 'message'); + assert.throws(() => thrower(assert.AssertionError), assert.AssertionError); + assert.throws(() => thrower(assert.AssertionError)); + + // If not passing an error, catch all. + assert.throws(() => thrower(TypeError)); + + // When passing a type, only catch errors of the appropriate type. + assert.throws( + () => assert.throws(() => thrower(TypeError), assert.AssertionError), + { + generatedMessage: true, + actual: new TypeError({}), + expected: assert.AssertionError, + code: 'ERR_ASSERTION', + name: 'AssertionError', + operator: 'throws', + message: 'The error is expected to be an instance of "AssertionError". ' + + 'Received "TypeError"\n\nError message:\n\n[object Object]' + } + ); + + // doesNotThrow should pass through all errors. { - message: 'Expected "actual" to be strictly unequal to:\n\n' + - `'${'a '.repeat(30)}'`, - name: 'AssertionError' + let threw = false; + try { + assert.doesNotThrow(() => thrower(TypeError), assert.AssertionError); + } catch (e) { + threw = true; + assert.ok(e instanceof TypeError); + } + assert(threw, 'assert.doesNotThrow with an explicit error is eating extra errors'); } -); -assert.throws( - () => a.notEqual(1, 1), + // Key difference is that throwing our correct error makes an assertion error. { - message: '1 != 1', - operator: '!=' + let threw = false; + try { + assert.doesNotThrow(() => thrower(TypeError), TypeError); + } catch (e) { + threw = true; + assert.ok(e instanceof assert.AssertionError); + assert.ok(!e.stack.includes('at Function.doesNotThrow')); + } + assert.ok(threw, 'assert.doesNotThrow is not catching type matching errors'); } -); -a.notStrictEqual(2, '2'); - -// Testing the throwing. -function thrower(errorConstructor) { - throw new errorConstructor({}); -} + assert.throws( + () => assert.doesNotThrow(() => thrower(Error), 'user message'), + { + name: 'AssertionError', + code: 'ERR_ASSERTION', + operator: 'doesNotThrow', + message: 'Got unwanted exception: user message\n' + + 'Actual message: "[object Object]"' + } + ); -// The basic calls work. -assert.throws(() => thrower(a.AssertionError), a.AssertionError, 'message'); -assert.throws(() => thrower(a.AssertionError), a.AssertionError); -assert.throws(() => thrower(a.AssertionError)); + assert.throws( + () => assert.doesNotThrow(() => thrower(Error)), + { + code: 'ERR_ASSERTION', + message: 'Got unwanted exception.\nActual message: "[object Object]"' + } + ); -// If not passing an error, catch all. -assert.throws(() => thrower(TypeError)); + assert.throws( + () => assert.doesNotThrow(() => thrower(Error), /\[[a-z]{6}\s[A-z]{6}\]/g, 'user message'), + { + name: 'AssertionError', + code: 'ERR_ASSERTION', + operator: 'doesNotThrow', + message: 'Got unwanted exception: user message\n' + + 'Actual message: "[object Object]"' + } + ); -// When passing a type, only catch errors of the appropriate type. -assert.throws( - () => a.throws(() => thrower(TypeError), a.AssertionError), + // Make sure that validating using constructor really works. { - generatedMessage: true, - actual: new TypeError({}), - expected: a.AssertionError, - code: 'ERR_ASSERTION', - name: 'AssertionError', - operator: 'throws', - message: 'The error is expected to be an instance of "AssertionError". ' + - 'Received "TypeError"\n\nError message:\n\n[object Object]' + let threw = false; + try { + assert.throws( + () => { + throw ({}); // eslint-disable-line no-throw-literal + }, + Array + ); + } catch { + threw = true; + } + assert.ok(threw, 'wrong constructor validation'); } -); -// doesNotThrow should pass through all errors. -{ - let threw = false; - try { - a.doesNotThrow(() => thrower(TypeError), a.AssertionError); - } catch (e) { - threw = true; - assert.ok(e instanceof TypeError); - } - assert(threw, 'a.doesNotThrow with an explicit error is eating extra errors'); -} + // Use a RegExp to validate the error message. + { + assert.throws(() => thrower(TypeError), /\[object Object\]/); -// Key difference is that throwing our correct error makes an assertion error. -{ - let threw = false; - try { - a.doesNotThrow(() => thrower(TypeError), TypeError); - } catch (e) { - threw = true; - assert.ok(e instanceof a.AssertionError); - assert.ok(!e.stack.includes('at Function.doesNotThrow')); - } - assert.ok(threw, 'a.doesNotThrow is not catching type matching errors'); -} + const symbol = Symbol('foo'); + assert.throws(() => { + throw symbol; + }, /foo/); -assert.throws( - () => a.doesNotThrow(() => thrower(Error), 'user message'), - { - name: 'AssertionError', - code: 'ERR_ASSERTION', - operator: 'doesNotThrow', - message: 'Got unwanted exception: user message\n' + - 'Actual message: "[object Object]"' + assert.throws(() => { + assert.throws(() => { + throw symbol; + }, /abc/); + }, { + message: 'The input did not match the regular expression /abc/. ' + + "Input:\n\n'Symbol(foo)'\n", + code: 'ERR_ASSERTION', + operator: 'throws', + actual: symbol, + expected: /abc/ + }); } -); -assert.throws( - () => a.doesNotThrow(() => thrower(Error)), - { - code: 'ERR_ASSERTION', - message: 'Got unwanted exception.\nActual message: "[object Object]"' - } -); + // Use a fn to validate the error object. + assert.throws(() => thrower(TypeError), (err) => { + if ((err instanceof TypeError) && /\[object Object\]/.test(err)) { + return true; + } + }); -assert.throws( - () => a.doesNotThrow(() => thrower(Error), /\[[a-z]{6}\s[A-z]{6}\]/g, 'user message'), + // https://github.com/nodejs/node/issues/3188 { - name: 'AssertionError', - code: 'ERR_ASSERTION', - operator: 'doesNotThrow', - message: 'Got unwanted exception: user message\n' + - 'Actual message: "[object Object]"' - } -); - -// Make sure that validating using constructor really works. -{ - let threw = false; - try { + let actual; assert.throws( () => { - throw ({}); // eslint-disable-line no-throw-literal + const ES6Error = class extends Error {}; + const AnotherErrorType = class extends Error {}; + + assert.throws(() => { + actual = new AnotherErrorType('foo'); + throw actual; + }, ES6Error); }, - Array + (err) => { + assert.strictEqual( + err.message, + 'The error is expected to be an instance of "ES6Error". ' + + 'Received "AnotherErrorType"\n\nError message:\n\nfoo' + ); + assert.strictEqual(err.actual, actual); + return true; + } ); - } catch { - threw = true; - } - assert.ok(threw, 'wrong constructor validation'); -} - -// Use a RegExp to validate the error message. -{ - a.throws(() => thrower(TypeError), /\[object Object\]/); - - const symbol = Symbol('foo'); - a.throws(() => { - throw symbol; - }, /foo/); - - a.throws(() => { - a.throws(() => { - throw symbol; - }, /abc/); - }, { - message: 'The input did not match the regular expression /abc/. ' + - "Input:\n\n'Symbol(foo)'\n", - code: 'ERR_ASSERTION', - operator: 'throws', - actual: symbol, - expected: /abc/ - }); -} - -// Use a fn to validate the error object. -a.throws(() => thrower(TypeError), (err) => { - if ((err instanceof TypeError) && /\[object Object\]/.test(err)) { - return true; } -}); -// https://github.com/nodejs/node/issues/3188 -{ - let actual; assert.throws( - () => { - const ES6Error = class extends Error {}; - const AnotherErrorType = class extends Error {}; - - assert.throws(() => { - actual = new AnotherErrorType('foo'); - throw actual; - }, ES6Error); - }, - (err) => { - assert.strictEqual( - err.message, - 'The error is expected to be an instance of "ES6Error". ' + - 'Received "AnotherErrorType"\n\nError message:\n\nfoo' - ); - assert.strictEqual(err.actual, actual); - return true; + () => assert.strictEqual(new Error('foo'), new Error('foobar')), + { + code: 'ERR_ASSERTION', + name: 'AssertionError', + message: 'Expected "actual" to be reference-equal to "expected":\n' + + '+ actual - expected\n\n' + + '+ [Error: foo]\n- [Error: foobar]' } ); -} +}); -// Check messages from assert.throws(). -{ +test('Check messages from assert.throws()', () => { const noop = () => {}; assert.throws( - () => { a.throws((noop)); }, + () => { assert.throws((noop)); }, { code: 'ERR_ASSERTION', message: 'Missing expected exception.', @@ -286,7 +296,7 @@ a.throws(() => thrower(TypeError), (err) => { }); assert.throws( - () => { a.throws(noop, TypeError); }, + () => { assert.throws(noop, TypeError); }, { code: 'ERR_ASSERTION', message: 'Missing expected exception (TypeError).', @@ -295,7 +305,7 @@ a.throws(() => thrower(TypeError), (err) => { }); assert.throws( - () => { a.throws(noop, 'fhqwhgads'); }, + () => { assert.throws(noop, 'fhqwhgads'); }, { code: 'ERR_ASSERTION', message: 'Missing expected exception: fhqwhgads', @@ -304,7 +314,7 @@ a.throws(() => thrower(TypeError), (err) => { }); assert.throws( - () => { a.throws(noop, TypeError, 'fhqwhgads'); }, + () => { assert.throws(noop, TypeError, 'fhqwhgads'); }, { code: 'ERR_ASSERTION', message: 'Missing expected exception (TypeError): fhqwhgads', @@ -314,78 +324,80 @@ a.throws(() => thrower(TypeError), (err) => { let threw = false; try { - a.throws(noop); + assert.throws(noop); } catch (e) { threw = true; - assert.ok(e instanceof a.AssertionError); + assert.ok(e instanceof assert.AssertionError); assert.ok(!e.stack.includes('at Function.throws')); } assert.ok(threw); -} +}); + +test('Test assertion messages', () => { + const circular = { y: 1 }; + circular.x = circular; + + function testAssertionMessage(actual, expected, msg) { + assert.throws( + () => assert.strictEqual(actual, ''), + { + generatedMessage: true, + message: msg || strictEqualMessageStart + + `+ actual - expected\n\n+ ${expected}\n- ''` + } + ); + } -const circular = { y: 1 }; -circular.x = circular; + function testShortAssertionMessage(actual, expected) { + testAssertionMessage(actual, expected, strictEqualMessageStart + + `\n${inspect(actual)} !== ''\n`); + } -function testAssertionMessage(actual, expected, msg) { + testShortAssertionMessage(null, 'null'); + testShortAssertionMessage(true, 'true'); + testShortAssertionMessage(false, 'false'); + testShortAssertionMessage(100, '100'); + testShortAssertionMessage(NaN, 'NaN'); + testShortAssertionMessage(Infinity, 'Infinity'); + testShortAssertionMessage('a', '"a"'); + testShortAssertionMessage('foo', '\'foo\''); + testShortAssertionMessage(0, '0'); + testShortAssertionMessage(Symbol(), 'Symbol()'); + testShortAssertionMessage(undefined, 'undefined'); + testShortAssertionMessage(-Infinity, '-Infinity'); + testAssertionMessage([], '[]'); + testAssertionMessage(/a/, '/a/'); + testAssertionMessage(/abc/gim, '/abc/gim'); + testAssertionMessage({}, '{}'); + testAssertionMessage([1, 2, 3], '[\n+ 1,\n+ 2,\n+ 3\n+ ]'); + testAssertionMessage(function f() {}, '[Function: f]'); + testAssertionMessage(function() {}, '[Function (anonymous)]'); + testAssertionMessage(circular, + ' {\n+ x: [Circular *1],\n+ y: 1\n+ }'); + testAssertionMessage({ a: undefined, b: null }, + '{\n+ a: undefined,\n+ b: null\n+ }'); + testAssertionMessage({ a: NaN, b: Infinity, c: -Infinity }, + '{\n+ a: NaN,\n+ b: Infinity,\n+ c: -Infinity\n+ }'); + + // https://github.com/nodejs/node-v0.x-archive/issues/5292 assert.throws( - () => assert.strictEqual(actual, ''), + () => assert.strictEqual(1, 2), { - generatedMessage: true, - message: msg || strictEqualMessageStart + - `+ actual - expected\n\n+ ${expected}\n- ''` + message: `${strictEqualMessageStart}\n1 !== 2\n`, + generatedMessage: true } ); -} - -function testShortAssertionMessage(actual, expected) { - testAssertionMessage(actual, expected, strictEqualMessageStart + - `\n${inspect(actual)} !== ''\n`); -} - -testShortAssertionMessage(null, 'null'); -testShortAssertionMessage(true, 'true'); -testShortAssertionMessage(false, 'false'); -testShortAssertionMessage(100, '100'); -testShortAssertionMessage(NaN, 'NaN'); -testShortAssertionMessage(Infinity, 'Infinity'); -testShortAssertionMessage('a', '"a"'); -testShortAssertionMessage('foo', '\'foo\''); -testShortAssertionMessage(0, '0'); -testShortAssertionMessage(Symbol(), 'Symbol()'); -testShortAssertionMessage(undefined, 'undefined'); -testShortAssertionMessage(-Infinity, '-Infinity'); -testAssertionMessage([], '[]'); -testAssertionMessage(/a/, '/a/'); -testAssertionMessage(/abc/gim, '/abc/gim'); -testAssertionMessage({}, '{}'); -testAssertionMessage([1, 2, 3], '[\n+ 1,\n+ 2,\n+ 3\n+ ]'); -testAssertionMessage(function f() {}, '[Function: f]'); -testAssertionMessage(function() {}, '[Function (anonymous)]'); -testAssertionMessage(circular, - ' {\n+ x: [Circular *1],\n+ y: 1\n+ }'); -testAssertionMessage({ a: undefined, b: null }, - '{\n+ a: undefined,\n+ b: null\n+ }'); -testAssertionMessage({ a: NaN, b: Infinity, c: -Infinity }, - '{\n+ a: NaN,\n+ b: Infinity,\n+ c: -Infinity\n+ }'); - -// https://github.com/nodejs/node-v0.x-archive/issues/5292 -assert.throws( - () => assert.strictEqual(1, 2), - { - message: `${strictEqualMessageStart}\n1 !== 2\n`, - generatedMessage: true - } -); -assert.throws( - () => assert.strictEqual(1, 2, 'oh no'), - { - message: 'oh no', - generatedMessage: false - } -); + assert.throws( + () => assert.strictEqual(1, 2, 'oh no'), + { + message: 'oh no', + generatedMessage: false + } + ); +}); -{ +test('Custom errors', () => { let threw = false; const rangeError = new RangeError('my range'); @@ -402,7 +414,7 @@ assert.throws( // Verify AssertionError is the result from doesNotThrow with custom Error. try { - a.doesNotThrow(() => { + assert.doesNotThrow(() => { throw new TypeError('wrong type'); }, TypeError, rangeError); } catch (e) { @@ -412,10 +424,9 @@ assert.throws( assert.ok(!e.stack.includes('doesNotThrow'), e); } assert.ok(threw); -} +}); -{ - // Verify that throws() and doesNotThrow() throw on non-functions. +test('Verify that throws() and doesNotThrow() throw on non-functions', () => { const testBlockTypeError = (method, fn) => { assert.throws( () => method(fn), @@ -423,7 +434,7 @@ assert.throws( code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError', message: 'The "fn" argument must be of type function.' + - common.invalidArgTypeHelper(fn) + invalidArgTypeHelper(fn) } ); }; @@ -446,28 +457,29 @@ assert.throws( testBlockTypeError(assert.doesNotThrow, null); testBlockTypeError(assert.throws, undefined); testBlockTypeError(assert.doesNotThrow, undefined); -} - -// https://github.com/nodejs/node/issues/3275 -// eslint-disable-next-line no-throw-literal -assert.throws(() => { throw 'error'; }, (err) => err === 'error'); -assert.throws(() => { throw new Error(); }, (err) => err instanceof Error); - -// Long values should be truncated for display. -assert.throws(() => { - assert.strictEqual('A'.repeat(1000), ''); -}, (err) => { - assert.strictEqual(err.code, 'ERR_ASSERTION'); - assert.strictEqual(err.message, - `${strictEqualMessageStart}+ actual - expected\n\n` + - `+ '${'A'.repeat(1000)}'\n- ''`); - assert.strictEqual(err.actual.length, 1000); - assert.ok(inspect(err).includes(`actual: '${'A'.repeat(488)}...'`)); - return true; }); -// Output that extends beyond 10 lines should also be truncated for display. -{ +test('https://github.com/nodejs/node/issues/3275', () => { + // eslint-disable-next-line no-throw-literal + assert.throws(() => { throw 'error'; }, (err) => err === 'error'); + assert.throws(() => { throw new Error(); }, (err) => err instanceof Error); +}); + +test('Long values should be truncated for display', () => { + assert.throws(() => { + assert.strictEqual('A'.repeat(1000), ''); + }, (err) => { + assert.strictEqual(err.code, 'ERR_ASSERTION'); + assert.strictEqual(err.message, + `${strictEqualMessageStart}+ actual - expected\n\n` + + `+ '${'A'.repeat(1000)}'\n- ''`); + assert.strictEqual(err.actual.length, 1000); + assert.ok(inspect(err).includes(`actual: '${'A'.repeat(488)}...'`)); + return true; + }); +}); + +test('Output that extends beyond 10 lines should also be truncated for display', () => { const multilineString = 'fhqwhgads\n'.repeat(15); assert.throws(() => { assert.strictEqual(multilineString, ''); @@ -481,10 +493,9 @@ assert.throws(() => { " '...'")); return true; }); -} +}); -{ - // Bad args to AssertionError constructor should throw TypeError. +test('Bad args to AssertionError constructor should throw TypeError.', () => { const args = [1, true, false, '', null, Infinity, Symbol('test'), undefined]; for (const input of args) { assert.throws( @@ -493,54 +504,43 @@ assert.throws(() => { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError', message: 'The "options" argument must be of type object.' + - common.invalidArgTypeHelper(input) + invalidArgTypeHelper(input) }); } -} +}); -assert.throws( - () => assert.strictEqual(new Error('foo'), new Error('foobar')), - { - code: 'ERR_ASSERTION', - name: 'AssertionError', - message: 'Expected "actual" to be reference-equal to "expected":\n' + - '+ actual - expected\n\n' + - '+ [Error: foo]\n- [Error: foobar]' - } -); - -a.equal(NaN, NaN); -a.throws( - () => a.notEqual(NaN, NaN), - a.AssertionError -); - -// Test strict assert. -{ - const a = require('assert'); - const assert = require('assert').strict; - /* eslint-disable no-restricted-properties */ - assert.throws(() => assert.equal(1, true), assert.AssertionError); - assert.notEqual(0, false); - assert.throws(() => assert.deepEqual(1, true), assert.AssertionError); - assert.notDeepEqual(0, false); - assert.equal(assert.strict, assert.strict.strict); - assert.equal(assert.equal, assert.strictEqual); - assert.equal(assert.deepEqual, assert.deepStrictEqual); - assert.equal(assert.notEqual, assert.notStrictEqual); - assert.equal(assert.notDeepEqual, assert.notDeepStrictEqual); - assert.equal(Object.keys(assert).length, Object.keys(a).length); - assert(7); +test('NaN is handled correctly', () => { + assert.equal(NaN, NaN); assert.throws( - () => assert(...[]), + () => assert.notEqual(NaN, NaN), + assert.AssertionError + ); +}); + +test('Test strict assert', () => { + const { strict } = require('assert'); + + strict.throws(() => strict.equal(1, true), strict.AssertionError); + strict.notEqual(0, false); + strict.throws(() => strict.deepEqual(1, true), strict.AssertionError); + strict.notDeepEqual(0, false); + strict.equal(strict.strict, strict.strict.strict); + strict.equal(strict.equal, strict.strictEqual); + strict.equal(strict.deepEqual, strict.deepStrictEqual); + strict.equal(strict.notEqual, strict.notStrictEqual); + strict.equal(strict.notDeepEqual, strict.notDeepStrictEqual); + strict.equal(Object.keys(strict).length, Object.keys(assert).length); + strict(7); + strict.throws( + () => strict(...[]), { message: 'No value argument passed to `assert.ok()`', name: 'AssertionError', generatedMessage: true } ); - assert.throws( - () => a(), + strict.throws( + () => assert(), { message: 'No value argument passed to `assert.ok()`', name: 'AssertionError' @@ -550,17 +550,17 @@ a.throws( // Test setting the limit to zero and that assert.strict works properly. const tmpLimit = Error.stackTraceLimit; Error.stackTraceLimit = 0; - assert.throws( + strict.throws( () => { - assert.ok( + strict.ok( typeof 123 === 'string' ); }, { code: 'ERR_ASSERTION', - constructor: assert.AssertionError, + constructor: strict.AssertionError, message: 'The expression evaluated to a falsy value:\n\n ' + - "assert.ok(\n typeof 123 === 'string'\n )\n" + "strict.ok(\n typeof 123 === 'string'\n )\n" } ); Error.stackTraceLimit = tmpLimit; @@ -582,8 +582,8 @@ a.throws( ' 4,', ' 5', ' ]'].join('\n'); - assert.throws( - () => assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]), + strict.throws( + () => strict.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]), { message }); message = [ @@ -602,8 +602,8 @@ a.throws( ' 1', ' ]', ].join('\n'); - assert.throws( - () => assert.deepEqual( + strict.throws( + () => strict.deepEqual( [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1]), { message }); @@ -623,8 +623,8 @@ a.throws( ' 1', ' ]', ].join('\n'); - assert.throws( - () => assert.deepEqual( + strict.throws( + () => strict.deepEqual( [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1]), { message }); @@ -644,8 +644,8 @@ a.throws( ' 1', ' ]', ].join('\n'); - assert.throws( - () => assert.deepEqual( + strict.throws( + () => strict.deepEqual( [1, 2, 1, 1, 0, 1, 1], [1, 1, 1, 1, 0, 1]), { message }); @@ -661,8 +661,8 @@ a.throws( '+ ]', '- undefined', ].join('\n'); - assert.throws( - () => assert.deepEqual([1, 2, 1], undefined), + strict.throws( + () => strict.deepEqual([1, 2, 1], undefined), { message }); message = [ @@ -675,8 +675,8 @@ a.throws( ' 1', ' ]', ].join('\n'); - assert.throws( - () => assert.deepEqual([1, 2, 1], [2, 1]), + strict.throws( + () => strict.deepEqual([1, 2, 1], [2, 1]), { message }); message = `${start}\n` + @@ -687,15 +687,15 @@ a.throws( '...\n' + '- 2,\n'.repeat(25) + '...'; - assert.throws( - () => assert.deepEqual(Array(28).fill(1), Array(28).fill(2)), + strict.throws( + () => strict.deepEqual(Array(28).fill(1), Array(28).fill(2)), { message }); const obj1 = {}; const obj2 = { loop: 'forever' }; obj2[inspect.custom] = () => '{}'; // No infinite loop and no custom inspect. - assert.throws(() => assert.deepEqual(obj1, obj2), { + strict.throws(() => strict.deepEqual(obj1, obj2), { message: `${start}\n` + `${actExp}\n` + '\n' + @@ -707,8 +707,8 @@ a.throws( }); // notDeepEqual tests - assert.throws( - () => assert.notDeepEqual([1], [1]), + strict.throws( + () => strict.notDeepEqual([1], [1]), { message: 'Expected "actual" not to be strictly deep-equal to:\n\n' + '[\n 1\n]\n' @@ -718,278 +718,260 @@ a.throws( message = 'Expected "actual" not to be strictly deep-equal to:' + `\n\n[${'\n 1,'.repeat(45)}\n...\n`; const data = Array(51).fill(1); - assert.throws( - () => assert.notDeepEqual(data, data), + strict.throws( + () => strict.notDeepEqual(data, data), { message }); - /* eslint-enable no-restricted-properties */ -} -assert.throws( - () => assert.ok(null), - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - generatedMessage: true, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'assert.ok(null)\n' - } -); -assert.throws( - () => { - // This test case checks if `try` left brace without a line break - // before the assertion causes any wrong assertion message. - // Therefore, don't reformat the following code. - // Refs: https://github.com/nodejs/node/issues/30872 - try { assert.ok(0); // eslint-disable-line no-useless-catch, @stylistic/js/brace-style - } catch (err) { - throw err; +}); + +test('Additional asserts', () => { + assert.throws( + () => assert.ok(null), + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + generatedMessage: true, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'assert.ok(null)\n' } - }, - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - generatedMessage: true, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'assert.ok(0)\n' - } -); -assert.throws( - () => { - try { - throw new Error(); - // This test case checks if `catch` left brace without a line break - // before the assertion causes any wrong assertion message. - // Therefore, don't reformat the following code. - // Refs: https://github.com/nodejs/node/issues/30872 - } catch (err) { assert.ok(0); } // eslint-disable-line no-unused-vars - }, - { + ); + assert.throws( + () => { + // This test case checks if `try` left brace without a line break + // before the assertion causes any wrong assertion message. + // Therefore, don't reformat the following code. + // Refs: https://github.com/nodejs/node/issues/30872 + try { assert.ok(0); // eslint-disable-line no-useless-catch, @stylistic/js/brace-style + } catch (err) { + throw err; + } + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + generatedMessage: true, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'assert.ok(0)\n' + } + ); + assert.throws( + () => { + try { + throw new Error(); + // This test case checks if `catch` left brace without a line break + // before the assertion causes any wrong assertion message. + // Therefore, don't reformat the following code. + // Refs: https://github.com/nodejs/node/issues/30872 + } catch (err) { assert.ok(0); } // eslint-disable-line no-unused-vars + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + generatedMessage: true, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'assert.ok(0)\n' + } + ); + assert.throws( + () => { + // This test case checks if `function` left brace without a line break + // before the assertion causes any wrong assertion message. + // Therefore, don't reformat the following code. + // Refs: https://github.com/nodejs/node/issues/30872 + function test() { assert.ok(0); // eslint-disable-line @stylistic/js/brace-style + } + test(); + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + generatedMessage: true, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'assert.ok(0)\n' + } + ); + assert.throws( + () => assert(typeof 123n === 'string'), + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + generatedMessage: true, + message: 'The expression evaluated to a falsy value:\n\n ' + + "assert(typeof 123n === 'string')\n" + } + ); + + assert.throws( + () => assert(false, Symbol('foo')), + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + generatedMessage: false, + message: 'Symbol(foo)' + } + ); + + assert.throws( + () => { + assert.strictEqual((() => 'string')(), 123 instanceof + Buffer); + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'Expected values to be strictly equal:\n' + + '+ actual - expected\n' + + '\n' + + "+ 'string'\n" + + '- false' + } + ); + + assert.throws( + () => { + assert.strictEqual((() => 'string')(), 123 instanceof + Buffer); + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'Expected values to be strictly equal:\n' + + '+ actual - expected\n' + + '\n' + + "+ 'string'\n" + + '- false' + } + ); + + /* eslint-disable @stylistic/js/indent */ + assert.throws(() => { + assert.strictEqual(( + () => 'string')(), 123 instanceof + Buffer); + }, { code: 'ERR_ASSERTION', constructor: assert.AssertionError, - generatedMessage: true, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'assert.ok(0)\n' - } -); -assert.throws( - () => { - // This test case checks if `function` left brace without a line break - // before the assertion causes any wrong assertion message. - // Therefore, don't reformat the following code. - // Refs: https://github.com/nodejs/node/issues/30872 - function test() { assert.ok(0); // eslint-disable-line @stylistic/js/brace-style + message: 'Expected values to be strictly equal:\n' + + '+ actual - expected\n' + + '\n' + + "+ 'string'\n" + + '- false' } - test(); - }, - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - generatedMessage: true, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'assert.ok(0)\n' - } -); -assert.throws( - () => assert(typeof 123n === 'string'), - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - generatedMessage: true, - message: 'The expression evaluated to a falsy value:\n\n ' + - "assert(typeof 123n === 'string')\n" - } -); - -assert.throws( - () => assert(false, Symbol('foo')), - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - generatedMessage: false, - message: 'Symbol(foo)' - } -); - -assert.throws( - () => { - a( - (() => 'string')() - // eslint-disable-next-line @stylistic/js/operator-linebreak - === - 123 instanceof - Buffer - ); - }, - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n' + - ' a(\n' + - ' (() => \'string\')()\n' + - ' // eslint-disable-next-line @stylistic/js/operator-linebreak\n' + - ' ===\n' + - ' 123 instanceof\n' + - ' Buffer\n' + - ' )\n' - } -); - -assert.throws( - () => { - a( - (() => 'string')() - // eslint-disable-next-line @stylistic/js/operator-linebreak - === - 123 instanceof - Buffer - ); - }, - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n' + - ' a(\n' + - ' (() => \'string\')()\n' + - ' // eslint-disable-next-line @stylistic/js/operator-linebreak\n' + - ' ===\n' + - ' 123 instanceof\n' + - ' Buffer\n' + - ' )\n' - } -); - -/* eslint-disable @stylistic/js/indent */ -assert.throws(() => { -a(( - () => 'string')() === -123 instanceof -Buffer -); -}, { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n' + - ' a((\n' + - ' () => \'string\')() ===\n' + - ' 123 instanceof\n' + - ' Buffer\n' + - ' )\n' - } -); -/* eslint-enable @stylistic/js/indent */ - -assert.throws( - () => { - assert(true); assert(null, undefined); - }, - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'assert(null, undefined)\n' - } -); + ); + /* eslint-enable @stylistic/js/indent */ -assert.throws( - () => { - assert - .ok(null, undefined); - }, - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'ok(null, undefined)\n' - } -); + assert.throws( + () => { + assert(true); assert(null, undefined); + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'assert(null, undefined)\n' + } + ); -assert.throws( - // eslint-disable-next-line dot-notation, @stylistic/js/quotes - () => assert['ok']["apply"](null, [0]), - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'assert[\'ok\']["apply"](null, [0])\n' - } -); + assert.throws( + () => { + assert + .ok(null, undefined); + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'ok(null, undefined)\n' + } + ); -assert.throws( - () => { - const wrapper = (fn, value) => fn(value); - wrapper(assert, false); - }, - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n fn(value)\n' - } -); + assert.throws( + // eslint-disable-next-line dot-notation, @stylistic/js/quotes + () => assert['ok']["apply"](null, [0]), + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'assert[\'ok\']["apply"](null, [0])\n' + } + ); -assert.throws( - () => assert.ok.call(null, 0), - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'The expression evaluated to a falsy value:\n\n ' + - 'assert.ok.call(null, 0)\n', - generatedMessage: true - } -); + assert.throws( + () => { + const wrapper = (fn, value) => fn(value); + wrapper(assert, false); + }, + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'The expression evaluated to a falsy value:\n\n fn(value)\n' + } + ); -assert.throws( - () => assert.ok.call(null, 0, 'test'), - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'test', - generatedMessage: false - } -); + assert.throws( + () => assert.ok.call(null, 0), + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'The expression evaluated to a falsy value:\n\n ' + + 'assert.ok.call(null, 0)\n', + generatedMessage: true + } + ); -// Works in eval. -assert.throws( - () => new Function('assert', 'assert(1 === 2);')(assert), - { - code: 'ERR_ASSERTION', - constructor: assert.AssertionError, - message: 'false == true' - } -); -assert.throws( - () => eval('console.log("FOO");\nassert.ok(1 === 2);'), - { - code: 'ERR_ASSERTION', - message: 'false == true' - } -); + assert.throws( + () => assert.ok.call(null, 0, 'test'), + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'test', + generatedMessage: false + } + ); -assert.throws( - () => assert.throws(() => {}, 'Error message', 'message'), - { - code: 'ERR_INVALID_ARG_TYPE', - name: 'TypeError', - message: 'The "error" argument must be of type function or ' + - 'an instance of Error, RegExp, or Object. Received type string ' + - "('Error message')" - } -); + // Works in eval. + assert.throws( + () => new Function('assert', 'assert(1 === 2);')(assert), + { + code: 'ERR_ASSERTION', + constructor: assert.AssertionError, + message: 'false == true' + } + ); + assert.throws( + () => eval('console.log("FOO");\nassert.ok(1 === 2);'), + { + code: 'ERR_ASSERTION', + message: 'false == true' + } + ); -const inputs = [1, false, Symbol()]; -for (const input of inputs) { assert.throws( - () => assert.throws(() => {}, input), + () => assert.throws(() => {}, 'Error message', 'message'), { code: 'ERR_INVALID_ARG_TYPE', + name: 'TypeError', message: 'The "error" argument must be of type function or ' + - 'an instance of Error, RegExp, or Object.' + - common.invalidArgTypeHelper(input) + 'an instance of Error, RegExp, or Object. Received type string ' + + "('Error message')" } ); -} -{ + const inputs = [1, false, Symbol()]; + for (const input of inputs) { + assert.throws( + () => assert.throws(() => {}, input), + { + code: 'ERR_INVALID_ARG_TYPE', + message: 'The "error" argument must be of type function or ' + + 'an instance of Error, RegExp, or Object.' + + invalidArgTypeHelper(input) + } + ); + } +}); +test('Throws accepts objects', () => { assert.throws(() => { // eslint-disable-next-line no-constant-binary-expression assert.ok((() => Boolean('' === false))()); @@ -1058,7 +1040,7 @@ for (const input of inputs) { ); assert.throws( - () => a.doesNotThrow(() => { throw new Error(); }, { foo: 'bar' }), + () => assert.doesNotThrow(() => { throw new Error(); }, { foo: 'bar' }), { name: 'TypeError', code: 'ERR_INVALID_ARG_TYPE', @@ -1100,414 +1082,420 @@ for (const input of inputs) { assert.throws(() => { throw undefined; }, /undefined/); assert.throws( // eslint-disable-next-line no-throw-literal - () => a.doesNotThrow(() => { throw undefined; }), + () => assert.doesNotThrow(() => { throw undefined; }), { name: 'AssertionError', code: 'ERR_ASSERTION', message: 'Got unwanted exception.\nActual message: "undefined"' } ); -} - -assert.throws( - () => assert.throws(() => { throw new Error(); }, {}), - { - message: "The argument 'error' may not be an empty object. Received {}", - code: 'ERR_INVALID_ARG_VALUE' - } -); - -assert.throws( - () => a.throws( - // eslint-disable-next-line no-throw-literal - () => { throw 'foo'; }, - 'foo' - ), - { - code: 'ERR_AMBIGUOUS_ARGUMENT', - message: 'The "error/message" argument is ambiguous. ' + - 'The error "foo" is identical to the message.' - } -); - -assert.throws( - () => a.throws( - () => { throw new TypeError('foo'); }, - 'foo' - ), - { - code: 'ERR_AMBIGUOUS_ARGUMENT', - message: 'The "error/message" argument is ambiguous. ' + - 'The error message "foo" is identical to the message.' - } -); -/* eslint-enable no-restricted-syntax */ - -// Should not throw. -// eslint-disable-next-line no-restricted-syntax, no-throw-literal -assert.throws(() => { throw null; }, 'foo'); - -assert.throws( - () => assert.strictEqual([], []), - { - message: 'Values have same structure but are not reference-equal:\n\n[]\n' - } -); +}); -{ - const args = (function() { return arguments; })('a'); +test('Additional assert', () => { assert.throws( - () => assert.strictEqual(args, { 0: 'a' }), + () => assert.throws(() => { throw new Error(); }, {}), { - message: 'Expected "actual" to be reference-equal to "expected":\n' + - '+ actual - expected\n\n' + - "+ [Arguments] {\n- {\n '0': 'a'\n }" + message: "The argument 'error' may not be an empty object. Received {}", + code: 'ERR_INVALID_ARG_VALUE' } ); -} - -assert.throws( - () => { throw new TypeError('foobar'); }, - { - message: /foo/, - name: /^TypeError$/ - } -); -assert.throws( - () => assert.throws( - () => { throw new TypeError('foobar'); }, + assert.throws( + () => assert.throws( + // eslint-disable-next-line no-throw-literal + () => { throw 'foo'; }, + 'foo' + ), { - message: /fooa/, - name: /^TypeError$/ + code: 'ERR_AMBIGUOUS_ARGUMENT', + message: 'The "error/message" argument is ambiguous. ' + + 'The error "foo" is identical to the message.' } - ), - { - message: `${start}\n${actExp}\n\n` + - ' Comparison {\n' + - "+ message: 'foobar',\n" + - '- message: /fooa/,\n' + - " name: 'TypeError'\n" + - ' }' - } -); + ); -{ - let actual = null; - const expected = { message: 'foo' }; assert.throws( () => assert.throws( - () => { throw actual; }, - expected + () => { throw new TypeError('foo'); }, + 'foo' ), { - operator: 'throws', - actual, - expected, - generatedMessage: true, - message: `${start}\n${actExp}\n\n` + - '+ null\n' + - '- {\n' + - "- message: 'foo'\n" + - '- }' + code: 'ERR_AMBIGUOUS_ARGUMENT', + message: 'The "error/message" argument is ambiguous. ' + + 'The error message "foo" is identical to the message.' } ); - actual = 'foobar'; - const message = 'message'; + // Should not throw. + assert.throws(() => { throw null; }, 'foo'); // eslint-disable-line no-throw-literal + assert.throws( - () => assert.throws( - () => { throw actual; }, - { message: 'foobar' }, - message - ), + () => assert.strictEqual([], []), { - actual, - message, - operator: 'throws', - generatedMessage: false + message: 'Values have same structure but are not reference-equal:\n\n[]\n' } ); -} -// Indicate where the strings diverge. -assert.throws( - () => assert.strictEqual('test test', 'test foobar'), { - code: 'ERR_ASSERTION', - name: 'AssertionError', - message: strictEqualMessageStart + - '+ actual - expected\n\n' + - "+ 'test test'\n" + - "- 'test foobar'\n" + - ' ^' - } -); - -// Check for reference-equal objects in `notStrictEqual()` -assert.throws( - () => { - const obj = {}; - assert.notStrictEqual(obj, obj); - }, - { - code: 'ERR_ASSERTION', - name: 'AssertionError', - message: 'Expected "actual" not to be reference-equal to "expected": {}' + const args = (function() { return arguments; })('a'); + assert.throws( + () => assert.strictEqual(args, { 0: 'a' }), + { + message: 'Expected "actual" to be reference-equal to "expected":\n' + + '+ actual - expected\n\n' + + "+ [Arguments] {\n- {\n '0': 'a'\n }" + } + ); } -); -assert.throws( - () => { - const obj = { a: true }; - assert.notStrictEqual(obj, obj); - }, - { - code: 'ERR_ASSERTION', - name: 'AssertionError', - message: 'Expected "actual" not to be reference-equal to "expected":\n\n' + - '{\n a: true\n}\n' - } -); + assert.throws( + () => { throw new TypeError('foobar'); }, + { + message: /foo/, + name: /^TypeError$/ + } + ); -{ - let threw = false; - try { - // eslint-disable-next-line no-restricted-syntax - assert.deepStrictEqual(Array(100).fill(1), 'foobar'); - } catch (err) { - threw = true; - assert.match(inspect(err), /actual: \[Array],\n {2}expected: 'foobar',/); - } - assert(threw); -} - -assert.throws( - () => a.equal(1), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.deepEqual(/a/), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.notEqual(null), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.notDeepEqual('test'), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.strictEqual({}), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.deepStrictEqual(Symbol()), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.notStrictEqual(5n), // eslint-disable-line no-restricted-syntax - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.notDeepStrictEqual(undefined), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.strictEqual(), - { code: 'ERR_MISSING_ARGS' } -); - -assert.throws( - () => a.deepStrictEqual(), - { code: 'ERR_MISSING_ARGS' } -); - -// Verify that `stackStartFunction` works as alternative to `stackStartFn`. -{ - (function hidden() { - const err = new assert.AssertionError({ - actual: 'foo', - operator: 'strictEqual', - stackStartFunction: hidden - }); - const err2 = new assert.AssertionError({ - actual: 'foo', - operator: 'strictEqual', - stackStartFn: hidden - }); - assert(!err.stack.includes('hidden')); - assert(!err2.stack.includes('hidden')); - })(); -} + assert.throws( + () => assert.throws( + () => { throw new TypeError('foobar'); }, + { + message: /fooa/, + name: /^TypeError$/ + } + ), + { + message: `${start}\n${actExp}\n\n` + + ' Comparison {\n' + + "+ message: 'foobar',\n" + + '- message: /fooa/,\n' + + " name: 'TypeError'\n" + + ' }' + } + ); -assert.throws( - () => assert.throws(() => { throw Symbol('foo'); }, RangeError), { - message: 'The error is expected to be an instance of "RangeError". ' + - 'Received "Symbol(foo)"' - } -); + let actual = null; + const expected = { message: 'foo' }; + assert.throws( + () => assert.throws( + () => { throw actual; }, + expected + ), + { + operator: 'throws', + actual, + expected, + generatedMessage: true, + message: `${start}\n${actExp}\n\n` + + '+ null\n' + + '- {\n' + + "- message: 'foo'\n" + + '- }' + } + ); -assert.throws( - // eslint-disable-next-line no-throw-literal - () => assert.throws(() => { throw [1, 2]; }, RangeError), - { - message: 'The error is expected to be an instance of "RangeError". ' + - 'Received "[Array]"' + actual = 'foobar'; + const message = 'message'; + assert.throws( + () => assert.throws( + () => { throw actual; }, + { message: 'foobar' }, + message + ), + { + actual, + message, + operator: 'throws', + generatedMessage: false + } + ); } -); -{ - const err = new TypeError('foo'); - const validate = (() => () => ({ a: true, b: [ 1, 2, 3 ] }))(); + // Indicate where the strings diverge. assert.throws( - () => assert.throws(() => { throw err; }, validate), + () => assert.strictEqual('test test', 'test foobar'), { - message: 'The validation function is expected to ' + - `return "true". Received ${inspect(validate())}\n\nCaught ` + - `error:\n\n${err}`, code: 'ERR_ASSERTION', - actual: err, - expected: validate, name: 'AssertionError', - operator: 'throws', + message: strictEqualMessageStart + + '+ actual - expected\n\n' + + "+ 'test test'\n" + + "- 'test foobar'\n" + + ' ^' } ); -} - -assert.throws( - () => { - const script = new vm.Script('new RangeError("foobar");'); - const context = vm.createContext(); - const err = script.runInContext(context); - assert.throws(() => { throw err; }, RangeError); - }, - { - message: 'The error is expected to be an instance of "RangeError". ' + - 'Received an error with identical name but a different ' + - 'prototype.\n\nError message:\n\nfoobar' - } -); -// Multiple assert.match() tests. -{ + // Check for reference-equal objects in `notStrictEqual()` assert.throws( - () => assert.match(/abc/, 'string'), + () => { + const obj = {}; + assert.notStrictEqual(obj, obj); + }, { - code: 'ERR_INVALID_ARG_TYPE', - message: 'The "regexp" argument must be an instance of RegExp. ' + - "Received type string ('string')" + code: 'ERR_ASSERTION', + name: 'AssertionError', + message: 'Expected "actual" not to be reference-equal to "expected": {}' } ); + assert.throws( - () => assert.match('string', /abc/), + () => { + const obj = { a: true }; + assert.notStrictEqual(obj, obj); + }, { - actual: 'string', - expected: /abc/, - operator: 'match', - message: 'The input did not match the regular expression /abc/. ' + - "Input:\n\n'string'\n", - generatedMessage: true + code: 'ERR_ASSERTION', + name: 'AssertionError', + message: 'Expected "actual" not to be reference-equal to "expected":\n\n' + + '{\n a: true\n}\n' } ); - assert.throws( - () => assert.match('string', /abc/, 'foobar'), - { - actual: 'string', - expected: /abc/, - operator: 'match', - message: 'foobar', - generatedMessage: false + + { + let threw = false; + try { + assert.deepStrictEqual(Array(100).fill(1), 'foobar'); + } catch (err) { + threw = true; + assert.match(inspect(err), /actual: \[Array],\n {2}expected: 'foobar',/); } + assert(threw); + } + + assert.throws( + () => assert.equal(1), + { code: 'ERR_MISSING_ARGS' } + ); + + assert.throws( + () => assert.deepEqual(/a/), + { code: 'ERR_MISSING_ARGS' } ); - const errorMessage = new RangeError('foobar'); + assert.throws( - () => assert.match('string', /abc/, errorMessage), - errorMessage + () => assert.notEqual(null), + { code: 'ERR_MISSING_ARGS' } ); + assert.throws( - () => assert.match({ abc: 123 }, /abc/), - { - actual: { abc: 123 }, - expected: /abc/, - operator: 'match', - message: 'The "string" argument must be of type string. ' + - 'Received type object ({ abc: 123 })', - generatedMessage: true - } + () => assert.notDeepEqual('test'), + { code: 'ERR_MISSING_ARGS' } ); - assert.match('I will pass', /pass$/); -} -// Multiple assert.doesNotMatch() tests. -{ assert.throws( - () => assert.doesNotMatch(/abc/, 'string'), - { - code: 'ERR_INVALID_ARG_TYPE', - message: 'The "regexp" argument must be an instance of RegExp. ' + - "Received type string ('string')" - } + () => assert.strictEqual({}), + { code: 'ERR_MISSING_ARGS' } ); + assert.throws( - () => assert.doesNotMatch('string', /string/), - { - actual: 'string', - expected: /string/, - operator: 'doesNotMatch', - message: 'The input was expected to not match the regular expression ' + - "/string/. Input:\n\n'string'\n", - generatedMessage: true - } + () => assert.deepStrictEqual(Symbol()), + { code: 'ERR_MISSING_ARGS' } + ); + + assert.throws( + () => assert.notStrictEqual(5n), + { code: 'ERR_MISSING_ARGS' } ); + + assert.throws( + () => assert.notDeepStrictEqual(undefined), + { code: 'ERR_MISSING_ARGS' } + ); + assert.throws( - () => assert.doesNotMatch('string', /string/, 'foobar'), + () => assert.strictEqual(), + { code: 'ERR_MISSING_ARGS' } + ); + + assert.throws( + () => assert.deepStrictEqual(), + { code: 'ERR_MISSING_ARGS' } + ); + + // Verify that `stackStartFunction` works as alternative to `stackStartFn`. + { + (function hidden() { + const err = new assert.AssertionError({ + actual: 'foo', + operator: 'strictEqual', + stackStartFunction: hidden + }); + const err2 = new assert.AssertionError({ + actual: 'foo', + operator: 'strictEqual', + stackStartFn: hidden + }); + assert(!err.stack.includes('hidden')); + assert(!err2.stack.includes('hidden')); + })(); + } + + assert.throws( + () => assert.throws(() => { throw Symbol('foo'); }, RangeError), { - actual: 'string', - expected: /string/, - operator: 'doesNotMatch', - message: 'foobar', - generatedMessage: false + message: 'The error is expected to be an instance of "RangeError". ' + + 'Received "Symbol(foo)"' } ); - const errorMessage = new RangeError('foobar'); + assert.throws( - () => assert.doesNotMatch('string', /string/, errorMessage), - errorMessage + // eslint-disable-next-line no-throw-literal + () => assert.throws(() => { throw [1, 2]; }, RangeError), + { + message: 'The error is expected to be an instance of "RangeError". ' + + 'Received "[Array]"' + } ); + + { + const err = new TypeError('foo'); + const validate = (() => () => ({ a: true, b: [ 1, 2, 3 ] }))(); + assert.throws( + () => assert.throws(() => { throw err; }, validate), + { + message: 'The validation function is expected to ' + + `return "true". Received ${inspect(validate())}\n\nCaught ` + + `error:\n\n${err}`, + code: 'ERR_ASSERTION', + actual: err, + expected: validate, + name: 'AssertionError', + operator: 'throws', + } + ); + } + assert.throws( - () => assert.doesNotMatch({ abc: 123 }, /abc/), + () => { + const script = new vm.Script('new RangeError("foobar");'); + const context = vm.createContext(); + const err = script.runInContext(context); + assert.throws(() => { throw err; }, RangeError); + }, { - actual: { abc: 123 }, - expected: /abc/, - operator: 'doesNotMatch', - message: 'The "string" argument must be of type string. ' + - 'Received type object ({ abc: 123 })', - generatedMessage: true + message: 'The error is expected to be an instance of "RangeError". ' + + 'Received an error with identical name but a different ' + + 'prototype.\n\nError message:\n\nfoobar' } ); - assert.doesNotMatch('I will pass', /different$/); -} -{ - const tempColor = inspect.defaultOptions.colors; - assert.throws(() => { - inspect.defaultOptions.colors = true; - // Guarantee the position indicator is placed correctly. - assert.strictEqual(111554n, 11111115); - }, (err) => { - assert.strictEqual(inspect(err).split('\n')[5], ' ^'); - inspect.defaultOptions.colors = tempColor; - return true; - }); -} + // Multiple assert.match() tests. + { + assert.throws( + () => assert.match(/abc/, 'string'), + { + code: 'ERR_INVALID_ARG_TYPE', + message: 'The "regexp" argument must be an instance of RegExp. ' + + "Received type string ('string')" + } + ); + assert.throws( + () => assert.match('string', /abc/), + { + actual: 'string', + expected: /abc/, + operator: 'match', + message: 'The input did not match the regular expression /abc/. ' + + "Input:\n\n'string'\n", + generatedMessage: true + } + ); + assert.throws( + () => assert.match('string', /abc/, 'foobar'), + { + actual: 'string', + expected: /abc/, + operator: 'match', + message: 'foobar', + generatedMessage: false + } + ); + const errorMessage = new RangeError('foobar'); + assert.throws( + () => assert.match('string', /abc/, errorMessage), + errorMessage + ); + assert.throws( + () => assert.match({ abc: 123 }, /abc/), + { + actual: { abc: 123 }, + expected: /abc/, + operator: 'match', + message: 'The "string" argument must be of type string. ' + + 'Received type object ({ abc: 123 })', + generatedMessage: true + } + ); + assert.match('I will pass', /pass$/); + } + + // Multiple assert.doesNotMatch() tests. + { + assert.throws( + () => assert.doesNotMatch(/abc/, 'string'), + { + code: 'ERR_INVALID_ARG_TYPE', + message: 'The "regexp" argument must be an instance of RegExp. ' + + "Received type string ('string')" + } + ); + assert.throws( + () => assert.doesNotMatch('string', /string/), + { + actual: 'string', + expected: /string/, + operator: 'doesNotMatch', + message: 'The input was expected to not match the regular expression ' + + "/string/. Input:\n\n'string'\n", + generatedMessage: true + } + ); + assert.throws( + () => assert.doesNotMatch('string', /string/, 'foobar'), + { + actual: 'string', + expected: /string/, + operator: 'doesNotMatch', + message: 'foobar', + generatedMessage: false + } + ); + const errorMessage = new RangeError('foobar'); + assert.throws( + () => assert.doesNotMatch('string', /string/, errorMessage), + errorMessage + ); + assert.throws( + () => assert.doesNotMatch({ abc: 123 }, /abc/), + { + actual: { abc: 123 }, + expected: /abc/, + operator: 'doesNotMatch', + message: 'The "string" argument must be of type string. ' + + 'Received type object ({ abc: 123 })', + generatedMessage: true + } + ); + assert.doesNotMatch('I will pass', /different$/); + } + + { + const tempColor = inspect.defaultOptions.colors; + assert.throws(() => { + inspect.defaultOptions.colors = true; + // Guarantee the position indicator is placed correctly. + assert.strictEqual(111554n, 11111115); + }, (err) => { + assert.strictEqual(inspect(err).split('\n')[5], ' ^'); + inspect.defaultOptions.colors = tempColor; + return true; + }); + } +}); + +test('assert/strict exists', () => { + assert.strictEqual(require('assert/strict'), assert.strict); +}); + +/* eslint-enable no-restricted-syntax */ +/* eslint-enable no-restricted-properties */ From 9f1ce732a8513227d4a716f1cb8b6c4945973eba Mon Sep 17 00:00:00 2001 From: James M Snell Date: Mon, 26 Aug 2024 21:15:20 -0700 Subject: [PATCH 78/90] test: update test-assert-typedarray-deepequal to use node:test PR-URL: https://github.com/nodejs/node/pull/54585 Reviewed-By: Yagiz Nizipli Reviewed-By: Colin Ihrig --- .../test-assert-typedarray-deepequal.js | 161 ++++++++++-------- 1 file changed, 87 insertions(+), 74 deletions(-) diff --git a/test/parallel/test-assert-typedarray-deepequal.js b/test/parallel/test-assert-typedarray-deepequal.js index aee5225ca1fe51..1c1c4c030a267e 100644 --- a/test/parallel/test-assert-typedarray-deepequal.js +++ b/test/parallel/test-assert-typedarray-deepequal.js @@ -2,6 +2,7 @@ require('../common'); const assert = require('assert'); +const { test, suite } = require('node:test'); function makeBlock(f) { const args = Array.prototype.slice.call(arguments, 1); @@ -10,82 +11,94 @@ function makeBlock(f) { }; } -const equalArrayPairs = [ - [new Uint8Array(1e5), new Uint8Array(1e5)], - [new Uint16Array(1e5), new Uint16Array(1e5)], - [new Uint32Array(1e5), new Uint32Array(1e5)], - [new Uint8ClampedArray(1e5), new Uint8ClampedArray(1e5)], - [new Int8Array(1e5), new Int8Array(1e5)], - [new Int16Array(1e5), new Int16Array(1e5)], - [new Int32Array(1e5), new Int32Array(1e5)], - [new Float32Array(1e5), new Float32Array(1e5)], - [new Float64Array(1e5), new Float64Array(1e5)], - [new Float32Array([+0.0]), new Float32Array([+0.0])], - [new Uint8Array([1, 2, 3, 4]).subarray(1), new Uint8Array([2, 3, 4])], - [new Uint16Array([1, 2, 3, 4]).subarray(1), new Uint16Array([2, 3, 4])], - [new Uint32Array([1, 2, 3, 4]).subarray(1, 3), new Uint32Array([2, 3])], - [new ArrayBuffer(3), new ArrayBuffer(3)], - [new SharedArrayBuffer(3), new SharedArrayBuffer(3)], -]; +suite('equalArrayPairs', () => { + const equalArrayPairs = [ + [new Uint8Array(1e5), new Uint8Array(1e5)], + [new Uint16Array(1e5), new Uint16Array(1e5)], + [new Uint32Array(1e5), new Uint32Array(1e5)], + [new Uint8ClampedArray(1e5), new Uint8ClampedArray(1e5)], + [new Int8Array(1e5), new Int8Array(1e5)], + [new Int16Array(1e5), new Int16Array(1e5)], + [new Int32Array(1e5), new Int32Array(1e5)], + [new Float32Array(1e5), new Float32Array(1e5)], + [new Float64Array(1e5), new Float64Array(1e5)], + [new Float32Array([+0.0]), new Float32Array([+0.0])], + [new Uint8Array([1, 2, 3, 4]).subarray(1), new Uint8Array([2, 3, 4])], + [new Uint16Array([1, 2, 3, 4]).subarray(1), new Uint16Array([2, 3, 4])], + [new Uint32Array([1, 2, 3, 4]).subarray(1, 3), new Uint32Array([2, 3])], + [new ArrayBuffer(3), new ArrayBuffer(3)], + [new SharedArrayBuffer(3), new SharedArrayBuffer(3)], + ]; -const looseEqualArrayPairs = [ - [new Float32Array([+0.0]), new Float32Array([-0.0])], - [new Float64Array([+0.0]), new Float64Array([-0.0])], -]; + for (const arrayPair of equalArrayPairs) { + test('', () => { + // eslint-disable-next-line no-restricted-properties + assert.deepEqual(arrayPair[0], arrayPair[1]); + assert.deepStrictEqual(arrayPair[0], arrayPair[1]); + }); + } +}); -const notEqualArrayPairs = [ - [new ArrayBuffer(3), new SharedArrayBuffer(3)], - [new Int16Array(256), new Uint16Array(256)], - [new Int16Array([256]), new Uint16Array([256])], - [new Float64Array([+0.0]), new Float32Array([-0.0])], - [new Uint8Array(2), new Uint8Array(3)], - [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])], - [new Uint8ClampedArray([300, 2, 3]), new Uint8Array([300, 2, 3])], - [new Uint16Array([2]), new Uint16Array([3])], - [new Uint16Array([0]), new Uint16Array([256])], - [new Int16Array([0]), new Uint16Array([256])], - [new Int16Array([-256]), new Uint16Array([0xff00])], // same bits - [new Int32Array([-256]), new Uint32Array([0xffffff00])], // ditto - [new Float32Array([0.1]), new Float32Array([0.0])], - [new Float32Array([0.1]), new Float32Array([0.1, 0.2])], - [new Float64Array([0.1]), new Float64Array([0.0])], - [new Uint8Array([1, 2, 3]).buffer, new Uint8Array([4, 5, 6]).buffer], - [ - new Uint8Array(new SharedArrayBuffer(3)).fill(1).buffer, - new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer, - ], - [new ArrayBuffer(2), new ArrayBuffer(3)], - [new SharedArrayBuffer(2), new SharedArrayBuffer(3)], - [new ArrayBuffer(2), new SharedArrayBuffer(3)], - [ - new Uint8Array(new ArrayBuffer(3)).fill(1).buffer, - new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer, - ], -]; +suite('looseEqualArrayPairs', () => { + const looseEqualArrayPairs = [ + [new Float32Array([+0.0]), new Float32Array([-0.0])], + [new Float64Array([+0.0]), new Float64Array([-0.0])], + ]; -for (const arrayPair of equalArrayPairs) { - // eslint-disable-next-line no-restricted-properties - assert.deepEqual(arrayPair[0], arrayPair[1]); - assert.deepStrictEqual(arrayPair[0], arrayPair[1]); -} + for (const arrayPair of looseEqualArrayPairs) { + test('', () => { + // eslint-disable-next-line no-restricted-properties + assert.deepEqual(arrayPair[0], arrayPair[1]); + assert.throws( + makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]), + assert.AssertionError + ); + }); + } +}); -for (const arrayPair of looseEqualArrayPairs) { - // eslint-disable-next-line no-restricted-properties - assert.deepEqual(arrayPair[0], arrayPair[1]); - assert.throws( - makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]), - assert.AssertionError - ); -} +suite('notEqualArrayPairs', () => { + const notEqualArrayPairs = [ + [new ArrayBuffer(3), new SharedArrayBuffer(3)], + [new Int16Array(256), new Uint16Array(256)], + [new Int16Array([256]), new Uint16Array([256])], + [new Float64Array([+0.0]), new Float32Array([-0.0])], + [new Uint8Array(2), new Uint8Array(3)], + [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])], + [new Uint8ClampedArray([300, 2, 3]), new Uint8Array([300, 2, 3])], + [new Uint16Array([2]), new Uint16Array([3])], + [new Uint16Array([0]), new Uint16Array([256])], + [new Int16Array([0]), new Uint16Array([256])], + [new Int16Array([-256]), new Uint16Array([0xff00])], // same bits + [new Int32Array([-256]), new Uint32Array([0xffffff00])], // ditto + [new Float32Array([0.1]), new Float32Array([0.0])], + [new Float32Array([0.1]), new Float32Array([0.1, 0.2])], + [new Float64Array([0.1]), new Float64Array([0.0])], + [new Uint8Array([1, 2, 3]).buffer, new Uint8Array([4, 5, 6]).buffer], + [ + new Uint8Array(new SharedArrayBuffer(3)).fill(1).buffer, + new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer, + ], + [new ArrayBuffer(2), new ArrayBuffer(3)], + [new SharedArrayBuffer(2), new SharedArrayBuffer(3)], + [new ArrayBuffer(2), new SharedArrayBuffer(3)], + [ + new Uint8Array(new ArrayBuffer(3)).fill(1).buffer, + new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer, + ], + ]; -for (const arrayPair of notEqualArrayPairs) { - assert.throws( - // eslint-disable-next-line no-restricted-properties - makeBlock(assert.deepEqual, arrayPair[0], arrayPair[1]), - assert.AssertionError - ); - assert.throws( - makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]), - assert.AssertionError - ); -} + for (const arrayPair of notEqualArrayPairs) { + test('', () => { + assert.throws( + // eslint-disable-next-line no-restricted-properties + makeBlock(assert.deepEqual, arrayPair[0], arrayPair[1]), + assert.AssertionError + ); + assert.throws( + makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]), + assert.AssertionError + ); + }); + } +}); From bf824483cd731378d9d504d3654ee6b39b30b51e Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Thu, 29 Aug 2024 16:42:53 -0300 Subject: [PATCH 79/90] doc: fix typo in styleText description PR-URL: https://github.com/nodejs/node/pull/54616 Reviewed-By: Luigi Pinca Reviewed-By: Chemi Atlow Reviewed-By: Rich Trott --- doc/api/util.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/api/util.md b/doc/api/util.md index 17580bed72c39f..c7cf5143a4cec6 100644 --- a/doc/api/util.md +++ b/doc/api/util.md @@ -1823,8 +1823,8 @@ changes: * `stream` {Stream} A stream that will be validated if it can be colored. **Default:** `process.stdout`. This function returns a formatted text considering the `format` passed -for printing in a terminal, it is aware of the terminal's capabilities -and act according to the configuration set via `NO_COLORS`, +for printing in a terminal. It is aware of the terminal's capabilities +and acts according to the configuration set via `NO_COLORS`, `NODE_DISABLE_COLORS` and `FORCE_COLOR` environment variables. ```mjs From bc976cfc931288f1ed64d9690b5fa29c244a1599 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Mon, 26 Aug 2024 18:52:27 -0700 Subject: [PATCH 80/90] test: update test-abortsignal-cloneable to use node:test PR-URL: https://github.com/nodejs/node/pull/54581 Reviewed-By: Yagiz Nizipli Reviewed-By: Matteo Collina --- test/parallel/test-abortsignal-cloneable.js | 92 +++++++++++---------- 1 file changed, 50 insertions(+), 42 deletions(-) diff --git a/test/parallel/test-abortsignal-cloneable.js b/test/parallel/test-abortsignal-cloneable.js index a5061a7b81b65b..ffffcc5f43fa0d 100644 --- a/test/parallel/test-abortsignal-cloneable.js +++ b/test/parallel/test-abortsignal-cloneable.js @@ -1,83 +1,91 @@ 'use strict'; -const common = require('../common'); +require('../common'); const { ok, strictEqual } = require('assert'); -const { setImmediate: pause } = require('timers/promises'); +const { setImmediate: sleep } = require('timers/promises'); const { transferableAbortSignal, transferableAbortController, } = require('util'); +const { + test, + mock, +} = require('node:test'); - -function deferred() { - let res; - const promise = new Promise((resolve) => res = resolve); - return { res, promise }; -} - -(async () => { +test('Can create a transferable abort controller', async () => { const ac = transferableAbortController(); const mc = new MessageChannel(); - const deferred1 = deferred(); - const deferred2 = deferred(); - const resolvers = [deferred1, deferred2]; + const setup1 = Promise.withResolvers(); + const setup2 = Promise.withResolvers(); + const setupResolvers = [setup1, setup2]; - mc.port1.onmessage = common.mustCall(({ data }) => { - data.addEventListener('abort', common.mustCall(() => { + const abort1 = Promise.withResolvers(); + const abort2 = Promise.withResolvers(); + const abort3 = Promise.withResolvers(); + const abortResolvers = [abort1, abort2, abort3]; + + mc.port1.onmessage = ({ data }) => { + data.addEventListener('abort', () => { strictEqual(data.reason, 'boom'); - })); - resolvers.shift().res(); - }, 2); + abortResolvers.shift().resolve(); + }); + setupResolvers.shift().resolve(); + }; mc.port2.postMessage(ac.signal, [ac.signal]); // Can be cloned/transferd multiple times and they all still work mc.port2.postMessage(ac.signal, [ac.signal]); - mc.port2.close(); - // Although we're using transfer semantics, the local AbortSignal // is still usable locally. - ac.signal.addEventListener('abort', common.mustCall(() => { + ac.signal.addEventListener('abort', () => { strictEqual(ac.signal.reason, 'boom'); - })); + abortResolvers.shift().resolve(); + }); - await Promise.all([ deferred1.promise, deferred2.promise ]); + await Promise.all([ setup1.promise, setup2.promise ]); ac.abort('boom'); - // Because the postMessage used by the underlying AbortSignal - // takes at least one turn of the event loop to be processed, - // and because it is unref'd, it won't, by itself, keep the - // event loop open long enough for the test to complete, so - // we schedule two back to back turns of the event to ensure - // the loop runs long enough for the test to complete. - await pause(); - await pause(); + await Promise.all([ abort1.promise, abort2.promise, abort3.promise ]); + + mc.port2.close(); -})().then(common.mustCall()); +}); -{ +test('Can create a transferable abort signal', async () => { const signal = transferableAbortSignal(AbortSignal.abort('boom')); ok(signal.aborted); strictEqual(signal.reason, 'boom'); const mc = new MessageChannel(); - mc.port1.onmessage = common.mustCall(({ data }) => { + const { promise, resolve } = Promise.withResolvers(); + mc.port1.onmessage = ({ data }) => { ok(data instanceof AbortSignal); ok(data.aborted); strictEqual(data.reason, 'boom'); - mc.port1.close(); - }); + resolve(); + }; mc.port2.postMessage(signal, [signal]); -} + await promise; + mc.port1.close(); +}); -{ - // The cloned AbortSignal does not keep the event loop open - // waiting for the abort to be triggered. +test('A cloned AbortSignal does not keep the event loop open', async () => { const ac = transferableAbortController(); const mc = new MessageChannel(); - mc.port1.onmessage = common.mustCall(); + const fn = mock.fn(); + mc.port1.onmessage = fn; mc.port2.postMessage(ac.signal, [ac.signal]); + // Because the postMessage used by the underlying AbortSignal + // takes at least one turn of the event loop to be processed, + // and because it is unref'd, it won't, by itself, keep the + // event loop open long enough for the test to complete, so + // we schedule two back to back turns of the event to ensure + // the loop runs long enough for the test to complete. + await sleep(); + await sleep(); + strictEqual(fn.mock.calls.length, 1); mc.port2.close(); -} +}); From edbecf52098251fc2026dac03cadc5c0fafbd088 Mon Sep 17 00:00:00 2001 From: Michael Dawson Date: Thu, 29 Aug 2024 19:59:18 -0400 Subject: [PATCH 81/90] test: increase key size for ca2-cert.pem Refs: https://github.com/nodejs/node/pull/44498 Refs: https://github.com/nodejs/node/issues/53382 Key sizes were increased to 2048 in PR 44498 including the configuration file for the generation of ca2-cert.pem. However, it seems like updating ca2-cert.pem and related files themselves were missed as they were not updated in the PR and the ca2-cert.pem reported as being associated with a 1024 bit key. I believe that was the cause of some of the failures mentioned in https://github.com/nodejs/node/issues/53382 as OpenSSL 3.2 increased the default security level from 1 to 2 and that would mean that certificates associated with keys of 1024 bits would no longer be accepted. This PR updates the key size for ca2-cert.pem. It was not necessary to change the config, only run the generation for the ca2-cert.pem and related files. Signed-off-by: Michael Dawson PR-URL: https://github.com/nodejs/node/pull/54599 Reviewed-By: Luigi Pinca Reviewed-By: Richard Lau Reviewed-By: James M Snell --- test/fixtures/keys/agent10-cert.pem | 80 +++++++++++++----------- test/fixtures/keys/agent10.pfx | Bin 4317 -> 4736 bytes test/fixtures/keys/agent3-cert.pem | 35 ++++++----- test/fixtures/keys/agent4-cert.pem | 41 +++++++----- test/fixtures/keys/agent5-cert.pem | 41 +++++++----- test/fixtures/keys/ca2-cert.pem | 33 +++++----- test/fixtures/keys/ca2-crl.pem | 20 +++--- test/fixtures/keys/ca2-database.txt | 1 + test/fixtures/keys/ca2-database.txt.old | 1 + test/fixtures/keys/ca2-key.pem | 44 ++++++++----- test/fixtures/keys/ca4-cert.pem | 41 +++++++----- 11 files changed, 195 insertions(+), 142 deletions(-) diff --git a/test/fixtures/keys/agent10-cert.pem b/test/fixtures/keys/agent10-cert.pem index ce0e515e823d1b..59bb0705757d5b 100644 --- a/test/fixtures/keys/agent10-cert.pem +++ b/test/fixtures/keys/agent10-cert.pem @@ -1,41 +1,47 @@ -----BEGIN CERTIFICATE----- -MIIDjjCCAnagAwIBAgITMVaZ0eX5Kp8NI4vaKFVI592wTjANBgkqhkiG9w0BAQsF -ADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEfMB0G -A1UECgwWVGhlIE5vZGUuanMgRm91bmRhdGlvbjEQMA4GA1UECwwHTm9kZS5qczEM -MAoGA1UEAwwDY2E0MR4wHAYJKoZIhvcNAQkBFg9jYTRAZXhhbXBsZS5vcmcwIBcN -MjIwOTAzMjE0MDM3WhgPMjI5NjA2MTcyMTQwMzdaMHgxCzAJBgNVBAYTAlVTMQsw -CQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxHzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZv -dW5kYXRpb24xEDAOBgNVBAsMB05vZGUuanMxHDAaBgNVBAMME2FnZW50MTAuZXhh -bXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDP49yjMES5 -1sfYG4ac06jR7DnSizMDgW+0V6CFPguv6p1D08aBA60mhY8+tjsbin3DYRiTB2HN -7C9svZ2cAffKK9W/40G6+jfJuB6I8g+LtdZ9hViw2RC0k4PFLzpG3VsJRpM4Wfos -/ubZqBuNGLN+K68sAFU0jbUra4dtJQXMi7SlFlJIUx2g10OF312uJcREfFVgNAw4 -EIZ2H7bmGtpE0p3UfBir4HTy5nz4ruYCbbzNWDuX7RIGZSXtqaQc7P9QPvuLzspl -feI8S2oRTLRIgDEatXJFlIWzGu1kF7XjftOrnFHwRWICK6joqSzdLhSS02qfqIRF -JFVZ8QNq11bhAgMBAAEwDQYJKoZIhvcNAQELBQADggEBACenzaglCUisBHiI7H/v -tOF/75jxDUO8FmV3mksh33EpTmzoBiQD1DiTFQu/EEJ/iAbdTRJ1PVnJsMTFH0Bm -7SmkYOCpETleXjU1MwHZIvh/gGa/CjLZhop26FkK2oqENl7iaM9vvqxxQ8H4Niit -ay3cn+aB9o8MjTH9Ki9iH0LS6bwtqqRimXXX0sx3HTUnFxD/7tzE7s6t7ayk+rIJ -6mBeQAw3UjNzjtLTvSxHoPFto7z5imF+6/v236UlOTdQpkbRS1KlxA8wm/NisWeq -TLjPh5BkZof+CwTUoAFK+WILsIHuvVY9SZBNcsQvsBao/whRR2Z8bU1HDAh8jHnk -4wo= +MIIDijCCAnICFAa1gku/rBMKem53dr6+kaDTIvSCMA0GCSqGSIb3DQEBCwUAMIGI +MQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMR8wHQYDVQQK +DBZUaGUgTm9kZS5qcyBGb3VuZGF0aW9uMRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYD +VQQDDANjYTQxHjAcBgkqhkiG9w0BCQEWD2NhNEBleGFtcGxlLm9yZzAgFw0yNDA4 +MjcyMjU4NDRaGA8yMjk4MDYxMTIyNTg0NFoweDELMAkGA1UEBhMCVVMxCzAJBgNV +BAgMAkNBMQswCQYDVQQHDAJTRjEfMB0GA1UECgwWVGhlIE5vZGUuanMgRm91bmRh +dGlvbjEQMA4GA1UECwwHTm9kZS5qczEcMBoGA1UEAwwTYWdlbnQxMC5leGFtcGxl +LmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM/j3KMwRLnWx9gb +hpzTqNHsOdKLMwOBb7RXoIU+C6/qnUPTxoEDrSaFjz62OxuKfcNhGJMHYc3sL2y9 +nZwB98or1b/jQbr6N8m4HojyD4u11n2FWLDZELSTg8UvOkbdWwlGkzhZ+iz+5tmo +G40Ys34rrywAVTSNtStrh20lBcyLtKUWUkhTHaDXQ4XfXa4lxER8VWA0DDgQhnYf +tuYa2kTSndR8GKvgdPLmfPiu5gJtvM1YO5ftEgZlJe2ppBzs/1A++4vOymV94jxL +ahFMtEiAMRq1ckWUhbMa7WQXteN+06ucUfBFYgIrqOipLN0uFJLTap+ohEUkVVnx +A2rXVuECAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAy0rm8E+PR+ZuaQsz8Q3s0Y7I +fNICuwEyByMcwiwCjvMM2FwNZbnmagmSQ2eo+jD0GMAcBLS61AWhC8tPqO6DfFOj +7L07NYJWTKQMqAsv3n6Nl0uXd8Aa4iGDhsMeTZXXk4E/GsZZ8T4pDmE8TtY6285Y +ONU7uKKFcnIfQwtcEUnpwqSAYmQxKa+rhQ974rW3hBCxvtrwNRXsMjCoPyfkIuOz +9P6ThZfMWlmuKg852Yi2VglaOrxakQInQGz4Q0JHyROd/e9m3J+t/QFR9VqtRnX8 +UEOlxD8iazk//VFd7WrO2jzqjXFIzBNrdvmsNsP+8uIjrGJtHdKeHL7v5V687A== -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- -MIIDFzCCAoCgAwIBAgIJAJHwBmNgafKfMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV -BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu -dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2EyMSAwHgYJKoZIhvcNAQkB -FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0yMjA5MDMxNDQ2NTFaGA8yMjk2MDYxNzE0 -NDY1MVowgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0Yx -HzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAOBgNVBAsMB05vZGUu -anMxDDAKBgNVBAMMA2NhNDEeMBwGCSqGSIb3DQEJARYPY2E0QGV4YW1wbGUub3Jn -MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0HnUahyfA25t8kaziu0i -vVMkTWntm0pJ8oemeO7yCGaY4QHEwN+QUzrzO7y7ngl2Dt76eEvj0mrgaW8Ao7Ns -ePfp3663g8RrBsb4cR1da2Tc8kpXCqgwbcTlm8HI/7OAdHGA2YDLNv7iyVk9meHM -gYfO9dVgrZ7RxfnGwNMJdNjYJrd02xeU6euoKl9j/ZWCG5xHAM2xAXOKHGm8toIm -+Ss6iZXY8kypy7Fjwyv7jMT8V+pzIWu24xd3Y3s07r59nkFmQ29nHMTaLP7Tf3TY -MBI5mp8fet732aBoywpQ/w05LR9gdM1jpUvIlmhj4qGskv17AMEmRecwic3opq/b -yQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GBADsFOR+N -Bcm2FyHOutoFpQn70qAFg0xlO3NTH87uubbs6rf3LDrsskhjskfs6wpUk56IJOoU -H7+F7aDDtSrnxzxxC5eZeGyaN05T5N01OdK3xvqUnr7mg/Ce0jnxrZhxHI8SHOqs -Kwrg4fRasUHGhH286Y13xOj2pLSrVoSbkXsA +MIIEaDCCA1CgAwIBAgIUDxaIwCfB2vttbQL/LlnVg4mwMUAwDQYJKoZIhvcNAQEL +BQAwejELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEPMA0G +A1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTIxIDAe +BgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMCAXDTI0MDgyNzIyNTg0NFoY +DzIyOTgwNjExMjI1ODQ0WjCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQsw +CQYDVQQHDAJTRjEfMB0GA1UECgwWVGhlIE5vZGUuanMgRm91bmRhdGlvbjEQMA4G +A1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2E0MR4wHAYJKoZIhvcNAQkBFg9jYTRA +ZXhhbXBsZS5vcmcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQedRq +HJ8Dbm3yRrOK7SK9UyRNae2bSknyh6Z47vIIZpjhAcTA35BTOvM7vLueCXYO3vp4 +S+PSauBpbwCjs2x49+nfrreDxGsGxvhxHV1rZNzySlcKqDBtxOWbwcj/s4B0cYDZ +gMs2/uLJWT2Z4cyBh8711WCtntHF+cbA0wl02Ngmt3TbF5Tp66gqX2P9lYIbnEcA +zbEBc4ocaby2gib5KzqJldjyTKnLsWPDK/uMxPxX6nMha7bjF3djezTuvn2eQWZD +b2ccxNos/tN/dNgwEjmanx963vfZoGjLClD/DTktH2B0zWOlS8iWaGPioayS/XsA +wSZF5zCJzeimr9vJAgMBAAGjgdQwgdEwDAYDVR0TBAUwAwEB/zAdBgNVHQ4EFgQU +Tc8o3KouldTCYNQHvW09ZBv9sW0wgaEGA1UdIwSBmTCBlqF+pHwwejELMAkGA1UE +BhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEPMA0GA1UECgwGSm95ZW50 +MRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTIxIDAeBgkqhkiG9w0BCQEW +EXJ5QHRpbnljbG91ZHMub3JnghRsoeMhBMOB34RpWIz6SD/UwaqquzANBgkqhkiG +9w0BAQsFAAOCAQEAKtd7q+5123jVDzpydg4o3FO84u/1gzlkQ9gAc0q48/ePD/0g +GTeTLz3fODq84l0Nx0g2XbcnrnH/07dzykZokAI6TFhv9qioeMmZa5UhwLSFynXJ +tqP26jA2/dpofGrVV2up/dJ9nw/jmvsRTigvIjkPyofFyxyssNmUIOXgEB6szthQ +mg0VKqgcF3yPDFiSMNh7YnxKd6Rsw1uujtRR+dbkLJs3m0sk+MNra7+LIfqVU5Iv +UyieguUmYYtW9rWTjxVCEl84teryIFJK81GlX/wiq1Nx3DZj+DCSwJMdl5DDzvH8 +EnE1L+MapqCnP0eAmNdWwF5SVxfKUwtt6uPpYw== -----END CERTIFICATE----- diff --git a/test/fixtures/keys/agent10.pfx b/test/fixtures/keys/agent10.pfx index f1df772cbbee1bcda61fe8bbf7467023219bb58b..fc6a9a20b1f7c116415971d84049f92bdefb7ee8 100644 GIT binary patch literal 4736 zcmYk9XEYp+w#5ww(IbfHqKt0z=rwxpy^P*_3`QINqD2d$3^97t=)L#eNf5#aq7%K| z-1XkO_kB3)tn=IJ?2mh`4Th7z&;b}=I0+xtGxjK@s4D^hHXsj9!iWhcq5F%ez;OJ; z|4LYSaQv{p=d94u;3r2H+m_#J~Rx*5$<6{Z)f(> z192*)a(cXO{SSLh8M*$Hct_Yz3ucLjg!;b8^;(Ad(*z^|APM&jv7bj-_8*%H4G~Sj z>;*ITB2T3Y3(_s5;>;JF7)53)Wwb3uD16Zm)z1$8)W80&Tqn**l)JIRnBRZ>gZ5?N z#tSj-YCyU}L35p|@a;t&X0J5sFh;TELAK!Pj51wc^1EY*^l*2zZ6u17;2$8KdfK{znI0)v3! zwYN6$n>`!?NI~fye#xkqv+ILG_CSPO7ei>dxrSLd!d1E`-^VOgsL(fWqe)Uu; z&@HgaI?O{+)Ua{H;I7JsHS}`cO6_{PEU{Qgd$O<7BPMS;6~mI#d?xy5sV!p&QDn43mN>e_rCKxJHm9~` z=EeaH%%zHqj0><7@=Weni4gnmHX*AULG&%sJ;zJ1F%qVjb~R4rOahtp?Y-~Ro&p|G z(}L7T;%zYJyOW+CMShU-EA8(;jvS*)Lk*%E9c)v5S!u9lZ>l2pCrHK4sGmW{s+Cbk z-U3c`!wCVQfqZW)Z#%Vln_4V$2yVp_)wg5If=Pdm-aO<@2dd;Y6f45`AFVcUfiNdO zaJ6Y6vJMP-mcF5}gp@ht!O@0w-&Kk|y~5xH4D(npxg7@dXzPfqmf!vJqTPMIf25>M z$d!ittuq{HO?Qs9BaREC5xJIA*Mt+-kk?4SLH=LJr>o=%5r&>e#(>m$+?8#s9gSf zW(c{Ewpb^oI?0JIZbdcgL3Dw(=P8pR|20;>Mu-Javph5PX|``Zr~sty_9XXlP-t0F z$u1d98ttc8&voIjFI6W^uN2!l6iO79qBS~IU0j(10_8MVm0bc7^P~q;3cI$~&r)Y@ ziKn~5_()+F&E)W5^WBqkHj<1}O7HJTfPSNU;aA37f6k9$C7QzoL{vchrjaWyUG_T ztoNn}{U6GnE=g~H8O2>2w+PjP8ZvrnC>x(P&#n~p5ZZ+c-AS&){e%AZsn)ccpW+#k zDCEyYvMO7h3&>NxwbECFc{wr$9iLJB^v;ojjJrr0s2@0gt^T&6SWHGLW7f#SNF!VG^%zx+;AN95%hUI000g1EegdC|GC z9-Kt~Lu|g`1G((8U9VC(CuR%VNTpXQk&gmK*Yh<-Q4;XB0?Bp;Efe#NXt14KMzq>? zKN~L6??ODuIj{N*kFnF>2vBA`URk=x$f0kPLtHsC zh>93u=*uRS(p^coH%FKKQsOn+F=ASbgmTLnk8U0(+*u3!f*vO2w#Oe`7Un3+x=E1H zX}hgNlI(sBo(pbPd03X8(Kl5zLlP;_FqD+Qtu*PlfRiTB8m;z6UR92-0Y;HFzv_=9@bWML(WeX3TE#28BpFu5Lc!874eE!s*j&cpvr0=El%Q zjK!T3e3*bw{1_?)=MA_79pZ_~RIKNK&IvA_#Ton(ry-8E;lH|~TA0b>Y;$buI3yI8 zUv5AZ_~+2D1o4kKu#!n-M;rPG;Tv_h!>HmFqj;f^%wX7>m@M#`70)TYb~bz2&F=Xq z&WlSt_Aaxc1+w=-jwxq31Ld0)uNS5Yrc1I+$^{r$L(1CXIlekZQ?Kf^(4z3;7vjhZ z3gkX&cc`vKTwpYPP`#>BJin@Mo$M}IrwB3M+Z2{=;J>sL9QYKlawREjacaDu80d#A zu2|H>`eoqTUkjbNV|v&Woij=Sg)ar)UY5oP@V^<_KxCWtOK+M0feR++_!ST&^v)(^DK^c+&5XbWj^gxGD4yYtM{4 z_G9tW)Y7P=+*{xrZa$1E#BykO%xh{WxfJ)VJ#h_88iT%^@}yo@IO|+w%q)DE)8gCa zR(dvzuGQo?HiX5UHyq&eQ^GhcMl!n|j#^#ZnCX}egR4PafzNL>2l~rU zu7Xn~f`?b;o|p?+2! z`}o=*jZXnL&ky@%FSW%9QYoq$VG-hlT|uc_4E~15$r7?Vs_UPGLOjs0HgzVtC$Vo= z58H#`b6JWOu>D9`Pxs7RcCcG!x4C$P3%*~*jOJCYySs4~X!_XXly~0+WhNA-8QTI1 zz(g#LX(nIG2)wi53m#bj!-0|iuXyCafqs~9px0mQ_II4H@cyrc-~!P9ioAaz7ufJW zA3y@I3YhJ`Cq9@O6X(_Gy#Jh33*g^f1&oh{^FJ2o&wyxP8mwnlQAz+i3`_t!CUJ{2 zdUP3-fUC)G9k=LF>p3PIb6W9QcVkKfa0l`>=oqH*~SI~VrLNJRa^r}|`&?8PN?M%as( z^j5OY%tkO;k<@wz$~3NuYkbFkI?T}yqga`uf2BvD>8wzB|JK+2?nWZ8TEkl@lLq>92e^h>0BHxuUD)~)y_kK3rwjaD<{*fk3!sM%uArFp1SSxnEM zg}L;E)3(>TF@g1)4Z4x+Ha|uIWyxXAEKn{XGzL78q*hslw~fhN4Fq{KbA&%+-u#~1 zgLy}YR83dNrNa(B4u9)4>b#z*GTgVzyG^a2wia_h(To%HQkNiE`fG>EkhxO2kWS8^ zKOEyM)9a5y8U4Xl@+n8EE9nvG65IVolMxHOAO?OpX>oJKeDqin$$59B_%kSxC#-tX z;4>ednNTvB;qFxIyx74`S8IDyfApl^*Z`q1f)WF zI~>bN)n1+-WrGIxwU5kiTnXFjTmJ#3brm~bf88V|`n2?%(m8G0ufp@T!m5=6UxIZw z@an`zm5&u00k5Pw3C6e)yu;=}CN%sMYaLNxntqVdnH|FW*>}%1mnY4xxmhg}L)M;R zd?w5wRX<~e?(`P1_uEwhls2>~UU&be;mYXsLSY6{nmnr=%alVOMq$JA+ zi~Q9;bwVI6QS%7K_@WD7Ab+T61X&XYV=>_fsd|Oliz&LquRpd3J_BfaT9*NhBxjc#aNsb{0H$YxysQtxtQvkk%Q{_ME5mNb-uY z^0p2y7cCc6m(8mgFOy&a#GV#o4%K7Z?U{SVuDP$A@VEK&A3OQC?-o9iLzEH`;(#J% z8G+MwEYj&eg|u=UG+@3|2gzHNK-xOx^p`?UFzCYA?C%qLIu`B7S6o+Givf|kzAh0g zI|gnM9!!l0B&&CEE&=)c-U_CIZ5uyX`Q{SMVYij}Ui2J^GII?sOf0v?1>)&KDA1uMM z+&6%<7(QyN9z#w{F+OvAA5x*g>^wC)DFFU-a;I0ASC#M<8%C-BJxw&yup7TEdyD0X z<_C%X52x~G%c<+H9^}iapi3RE`jwi*Cs2=_JwZJqjd%C2Rj_s$}btWNYEVf7Z>6212tERyJ*Xp0bpkZ94nL~qe0R*5cp zStR1-&fGS0AO1Nr=ggdk|KZGsK*JXC0R#v%tdNj||K*dHI4FP!P=to10MW37fA(tx z8Y1_<5n&M;g7{}Wzz5*{6Yl>_00<^R@P9Rs{%a%y633WT-ED3he!#~k#*09MuPPhP z=H<_{o%-#DB>C^_eo70gdkTK?L&lKx_4Y^W~H#I=cS*h`K*JNbL(F#S1DVk>QYuN&%sSW6TZKAiNaUkQUsjW^^B85 z)yCT&f4Qvp%j~(oRh*rMeVhEX2EHI7-AxnkiM&5uL9AXsp>mJGavLrjSiv?4bd4K6 z4yKrv53ryhQA9Don**u?M_Y6^7sN?4-X=rc$E8eq~M z1>-o(_~ahjx^_ZNGf)C8%Z^ob!*zze;k!#(7+DQ$+Gv0epL=np^MSj{95frB7x%CY zWZ7eiGPu*TSBBRJbGg?^=9D>}rN=|Nq8e7W*)x?~VC2@P-=5#||6V0wii`=*x%3Q9i;*RVH~ zOh>i(-RuVEg-qcS^9@-Ern)=td_GWXf8x&X zXwzg0^XNqFbS0@G1Xj`-P9pZ>8OCsAfr-{&)|Jg)n(X zoXg;r$1-y(@E+eSH|I`Fc)iL&Q|>*o$t z=C3Lti}H;gJVKqEIzHP9^+H>HO0>l6nkMVt@XHw>8Hp-IpT{ z^YX5$;^F=G?=xe@YZdqQ$SjJhzsmdb{3Pg*vQBKd-O>^`b za_zXAx@T)QSBxJ@3g4#1mBVKWRF$TWmyaG__JKeXx#X0EP#GL5f>@SShoXr1`^!`V zNAww|%f5Zp5Xss10SY74)C1j7?TX(Gx6W1mIPNqp`l}?%R{^hN`#^pR8C8q9sh`v8 zo-Ed(;#+K>66X_`$p%gJP;{b?-gpJum@!Mpg#u@*JFi27%gf^Vd+MD*Dg$O?q`Ril zZIDAU^dZT^?Zv&oJ&#KWbF+xOhRt1`r47(R(ykwytCVX1CzV zAGqTGVX&Ln9+aj~LJ%sI(W`SsDlE<0b9}2o_8n6=ulv^Y{oXbKbPLaIikQt4`#_Pf z0@*dgfCN+~^%1UZ|9}lir|ny=$53A@ z%P$((`Kdla<@FnS(*1TTPvknQr2a(P=VRy_)J67s&RoFydO+$hemZ) zu!mht)_T~@w#}NkJ{J44FPHT9mey3=*#S&9)+ zfEkYMmUrWudl}eI-b?{<&CPl8k?9v^dY<8-#bzr@OHLbJq~dfE*jnH)FH9(2^c@+7 zejC*_*&YEEZG^XWR?!9AmVfZ;(Yr)ZbmJUQR&7sj9H;r(D;w0i_{@I&5up zHP_5R{RRr$if0Eo;S)tKKRS754YYnX780j+s4!>Qcr2|S=f=R6R&RSM6jo)&9BNu& z*}*EfvV55IWX;$5)$(KAciaVQl!I=ezx8(huI9+U;MLqrY5rAuoo8ofs5CRN$VfW^ zNG<*Bl|9=B3;jY7)LOQfe`JyV1(_02AXJoKC?}mj)PaOap@0q9krZaD-4qoCg64j! zbjM`<1X89)zLmFWmsQfGTTTG^f-n|1HHX`CEfH|8I4_xxS3A21HY&wlrdMnr8NhP{ zQgY|K2#YN$!s8hD{oT5&rKC+E_9SeDKbwOKEW(OMd1!eM;3}PGW5xhdL)BzUh|j6u zEj6*<^D`()K#n3!>1kU-b!2)QLV_8?JLTnhzR7u#)osnYBra!*^}Y4DD%Yt6UFo`7 zC&>rDrlni+>%jPx^stvb{(3cqy1B2us8qJ7Z5?b}>{lf!AjnMKXUJ&p0K`JY%pd+vB^k|vP>m_L(p!xZq{L%N!=g(>_Jcuj*!t1RpA|4$^CU&JxOxt7Pmy+_8qjV-` z_o)MY>(eGtCB1Q1*ShJv!`syihpxa|_@8c>@W6H9_123nu@=1G7>Cm-fW%>BY3p8K zm82Y$Jf!#i$6blb_0zPZ2Su6EQQT)r4Ijn!GIpny#FBF?lWs|UKGRXP&(z}hNwMOl zs$5WazI3hhx$KIDu$8IR8|XZ9?0Sh;9Da@@L1<~SZUkqtz&!9BJewF9m0rTQbFe%W zS^hS-EV`P4^z)JgH;xFV*am0$nL5cxS5*FG#_+f{YAZc@Qg9;ywAsEl`9rPy4b+^| zX#O-_#u(@wbS8i=7_bN}+gn=b-6t4INg4PtmExWa<`(3MC}4eqyIctW(A{DFP*&1u z4MB((zlfD|$8a1;`)82J66aQ)4d|FYGYZdHxvZYPlmk&J0ju=?6haVX2FovAfMst1 zvbJ$x1{wYKa63JQQNmUc4y-L%Gl*W67Fvj%cCH)Z&>L4NwIW^}zF z%%xS+rI7W}i}NX`Aq~g(sy+~*4%UrjY_8TIg28RKE2n&^TXMxEnQG&M|4L3y>GKWM zaqMXLOIBCAzibArkJSjdY2VF!$Dd`zpq}22QA9D{CvfXW@JlggjGKz?5#P+n&U4^P z3w$Cl_T7Y1H5xTkUax~TYy$8TgErW*JT%=EPRHEW7R0{_VoK{s)!=@NP0nktn$@3L zT4Y}C2Oby7K=8CenX0yAlPDMV;lC9-_+unHA9qt z_`tVQA#APO6Rr&280vf6&*C(zY*QUpvUf_4I~m;`o;|-vtn=v3o2k5p8E_ zA5f=;utb@TJ<}V1=V9en=n=z`KmXvafjPGtl|r46y?7l%S0|cTUQ>7{>U8r2#N{WK-x{G zE@B@L_Z~U&W6rU}taQvP$Ll`E^ikznx`zF$y6R8n3c8=L@-qbzy^7s*o1XL_jom4d zIAIHOIE;KMTl3v$eNwGGwZWL-+_^2L|0&2dayV}UK>jAx+4-DUz8+Zr_j8S&ycVSe zw(m}9+|yg>Y%|PFua#X(W3QQuh&CnYnf05j4-Yv)@t?HOu+Fz zRlqm;8mzltiAl&n*c{nApJzlMx=gt-Z>J&jJ5nChw~(E z?W`v9j=@SATYj-ZyLQ&f6?jWW{*!KXVq?`lk$YAAz)6d2Jna3rg<9|$A=_|y znLn+-$2BF`Do)l)x4y+?aV2c=T99GHJ%p+j__N#NiY~MdE?1e;YHk3)5;?M<>yIA*Br*AHPjAo5%jCaVZk?iwW0~8Yiq1cA zbY||mMv2BxnwpY2XC3H2(4_t5qN=p@HwxCzKi!XV@rdabu&$?Wb$Qcs_?Mjx0m-~& z^`eTppKRKNc{qZ~<-|5+JEZY_N=WUQd5C$|U5R`}>)j2Z;F^3nVI|_1{^$ywAM-tx zD!DjgZH@WYgxP+6Vph}k>u2bQ2JtS}hSR|50pE7J)Do%Eva%2D?4pc^uB5QHvc-UD z{CbjW`2aTFa9vPdyIzC1FF}Gq>lT+LP1^wiu(s69J|p>YdFByt>nJ+)LR!sK#r_Cg zNvnR6ovt5n^Kno&+_fc@dihnPD8NOK8^QTM>qtT^NCTwW1pn$*@qOm^zRjjZktaho z2-kFh5Ja#eNC-jq$q4WnKzKkZ{}$!JbD}id5FfLs3WO4hx-8QK5>vxZFxHJV`2V?* F{{d`mCA Date: Fri, 30 Aug 2024 12:25:01 +0200 Subject: [PATCH 82/90] test: run V8 Fast API tests in release mode too Only keep the call count assertions under `common.isDebug`. PR-URL: https://github.com/nodejs/node/pull/54570 Reviewed-By: Robert Nagy Reviewed-By: Benjamin Gruenbaum Reviewed-By: Yagiz Nizipli Reviewed-By: Rafael Gonzaga Reviewed-By: Matteo Collina Reviewed-By: James M Snell --- doc/contributing/adding-v8-fast-api.md | 31 +++++++++---------- test/parallel/test-whatwg-url-canparse.js | 12 ++++--- .../test-crypto-timing-safe-equal.js | 15 +++++---- 3 files changed, 31 insertions(+), 27 deletions(-) diff --git a/doc/contributing/adding-v8-fast-api.md b/doc/contributing/adding-v8-fast-api.md index 5326f8e5fd6987..7f7da32656d81b 100644 --- a/doc/contributing/adding-v8-fast-api.md +++ b/doc/contributing/adding-v8-fast-api.md @@ -173,25 +173,24 @@ A typical function that communicates between JavaScript and C++ is as follows. // We could also require a function that uses the internal binding internally. const { divide } = internalBinding('custom_namespace'); - if (common.isDebug) { - const { getV8FastApiCallCount } = internalBinding('debug'); - - // The function that will be optimized. It has to be a function written in - // JavaScript. Since `divide` comes from the C++ side, we need to wrap it. - function testFastPath(a, b) { - return divide(a, b); - } + // The function that will be optimized. It has to be a function written in + // JavaScript. Since `divide` comes from the C++ side, we need to wrap it. + function testFastPath(a, b) { + return divide(a, b); + } - eval('%PrepareFunctionForOptimization(testFastPath)'); - // This call will let V8 know about the argument types that the function expects. - assert.strictEqual(testFastPath(6, 3), 2); + eval('%PrepareFunctionForOptimization(testFastPath)'); + // This call will let V8 know about the argument types that the function expects. + assert.strictEqual(testFastPath(6, 3), 2); - eval('%OptimizeFunctionOnNextCall(testFastPath)'); - assert.strictEqual(testFastPath(8, 2), 4); - assert.throws(() => testFastPath(1, 0), { - code: 'ERR_INVALID_STATE', - }); + eval('%OptimizeFunctionOnNextCall(testFastPath)'); + assert.strictEqual(testFastPath(8, 2), 4); + assert.throws(() => testFastPath(1, 0), { + code: 'ERR_INVALID_STATE', + }); + if (common.isDebug) { + const { getV8FastApiCallCount } = internalBinding('debug'); assert.strictEqual(getV8FastApiCallCount('custom_namespace.divide.ok'), 1); assert.strictEqual(getV8FastApiCallCount('custom_namespace.divide.error'), 1); } diff --git a/test/parallel/test-whatwg-url-canparse.js b/test/parallel/test-whatwg-url-canparse.js index c67f957ec65f49..e49373324d36e3 100644 --- a/test/parallel/test-whatwg-url-canparse.js +++ b/test/parallel/test-whatwg-url-canparse.js @@ -19,9 +19,8 @@ assert.throws(() => { // It should not throw when called without a base string assert.strictEqual(URL.canParse('https://example.org'), true); -if (common.isDebug) { - const { getV8FastApiCallCount } = internalBinding('debug'); - +{ + // V8 Fast API function testFastPaths() { // `canParse` binding has two overloads. assert.strictEqual(URL.canParse('https://www.example.com/path/?query=param#hash'), true); @@ -33,6 +32,9 @@ if (common.isDebug) { eval('%OptimizeFunctionOnNextCall(URL.canParse)'); testFastPaths(); - assert.strictEqual(getV8FastApiCallCount('url.canParse'), 1); - assert.strictEqual(getV8FastApiCallCount('url.canParse.withBase'), 1); + if (common.isDebug) { + const { getV8FastApiCallCount } = internalBinding('debug'); + assert.strictEqual(getV8FastApiCallCount('url.canParse'), 1); + assert.strictEqual(getV8FastApiCallCount('url.canParse.withBase'), 1); + } } diff --git a/test/sequential/test-crypto-timing-safe-equal.js b/test/sequential/test-crypto-timing-safe-equal.js index 97fd35448c98b4..80b3a69e59cb2d 100644 --- a/test/sequential/test-crypto-timing-safe-equal.js +++ b/test/sequential/test-crypto-timing-safe-equal.js @@ -93,10 +93,8 @@ assert.throws( } ); -if (common.isDebug) { - const { internalBinding } = require('internal/test/binding'); - const { getV8FastApiCallCount } = internalBinding('debug'); - +{ + // V8 Fast API const foo = Buffer.from('foo'); const bar = Buffer.from('bar'); const longer = Buffer.from('longer'); @@ -111,6 +109,11 @@ if (common.isDebug) { assert.throws(() => testFastPath(foo, longer), { code: 'ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH', }); - assert.strictEqual(getV8FastApiCallCount('crypto.timingSafeEqual.ok'), 2); - assert.strictEqual(getV8FastApiCallCount('crypto.timingSafeEqual.error'), 1); + + if (common.isDebug) { + const { internalBinding } = require('internal/test/binding'); + const { getV8FastApiCallCount } = internalBinding('debug'); + assert.strictEqual(getV8FastApiCallCount('crypto.timingSafeEqual.ok'), 2); + assert.strictEqual(getV8FastApiCallCount('crypto.timingSafeEqual.error'), 1); + } } From fe5666f0068799cd371d42e2e211c931c8c2ac73 Mon Sep 17 00:00:00 2001 From: Chengzhong Wu Date: Fri, 30 Aug 2024 12:22:58 +0100 Subject: [PATCH 83/90] vm: return all own names and symbols in property enumerator interceptor Property enumerator methods like `Object.getOwnPropertyNames`, `Object.getOwnPropertySymbols`, and `Object.keys` all invokes the named property enumerator interceptor. V8 will filter the result based on the invoked enumerator variant. Fix the enumerator interceptor to return all potential properties. PR-URL: https://github.com/nodejs/node/pull/54522 Refs: https://github.com/jsdom/jsdom/issues/3688 Reviewed-By: Joyee Cheung --- src/node_contextify.cc | 32 ++++++++--- .../test-vm-global-property-enumerator.js | 56 ++++++++++++++++++- .../test-vm-ownkeys.js | 8 +-- .../test-vm-ownpropertynames.js | 8 +-- .../test-vm-ownpropertysymbols.js | 8 +-- 5 files changed, 88 insertions(+), 24 deletions(-) rename test/{known_issues => parallel}/test-vm-ownkeys.js (68%) rename test/{known_issues => parallel}/test-vm-ownpropertynames.js (69%) rename test/{known_issues => parallel}/test-vm-ownpropertysymbols.js (69%) diff --git a/src/node_contextify.cc b/src/node_contextify.cc index bc90501da0ffde..fc137486f5e6ba 100644 --- a/src/node_contextify.cc +++ b/src/node_contextify.cc @@ -769,19 +769,25 @@ Intercepted ContextifyContext::PropertyDeleterCallback( // static void ContextifyContext::PropertyEnumeratorCallback( const PropertyCallbackInfo& args) { + // Named enumerator will be invoked on Object.keys, + // Object.getOwnPropertyNames, Object.getOwnPropertySymbols, + // Object.getOwnPropertyDescriptors, for...in, etc. operations. + // Named enumerator should return all own non-indices property names, + // including string properties and symbol properties. V8 will filter the + // result array to match the expected symbol-only, enumerable-only with + // NamedPropertyQueryCallback. ContextifyContext* ctx = ContextifyContext::Get(args); // Still initializing if (IsStillInitializing(ctx)) return; Local properties; - // Only get named properties, exclude symbols and indices. + // Only get own named properties, exclude indices. if (!ctx->sandbox() ->GetPropertyNames( ctx->context(), - KeyCollectionMode::kIncludePrototypes, - static_cast(PropertyFilter::ONLY_ENUMERABLE | - PropertyFilter::SKIP_SYMBOLS), + KeyCollectionMode::kOwnOnly, + static_cast(PropertyFilter::ALL_PROPERTIES), IndexFilter::kSkipIndices) .ToLocal(&properties)) return; @@ -792,6 +798,12 @@ void ContextifyContext::PropertyEnumeratorCallback( // static void ContextifyContext::IndexedPropertyEnumeratorCallback( const PropertyCallbackInfo& args) { + // Indexed enumerator will be invoked on Object.keys, + // Object.getOwnPropertyNames, Object.getOwnPropertyDescriptors, for...in, + // etc. operations. Indexed enumerator should return all own non-indices index + // properties. V8 will filter the result array to match the expected + // enumerable-only with IndexedPropertyQueryCallback. + Isolate* isolate = args.GetIsolate(); HandleScope scope(isolate); ContextifyContext* ctx = ContextifyContext::Get(args); @@ -802,9 +814,15 @@ void ContextifyContext::IndexedPropertyEnumeratorCallback( Local properties; - // By default, GetPropertyNames returns string and number property names, and - // doesn't convert the numbers to strings. - if (!ctx->sandbox()->GetPropertyNames(context).ToLocal(&properties)) return; + // Only get own index properties. + if (!ctx->sandbox() + ->GetPropertyNames( + context, + KeyCollectionMode::kOwnOnly, + static_cast(PropertyFilter::SKIP_SYMBOLS), + IndexFilter::kIncludeIndices) + .ToLocal(&properties)) + return; std::vector> properties_vec; if (FromV8Array(context, properties, &properties_vec).IsNothing()) { diff --git a/test/parallel/test-vm-global-property-enumerator.js b/test/parallel/test-vm-global-property-enumerator.js index 7b37c2af41094d..7443c2c27d6c89 100644 --- a/test/parallel/test-vm-global-property-enumerator.js +++ b/test/parallel/test-vm-global-property-enumerator.js @@ -1,5 +1,6 @@ 'use strict'; require('../common'); +const globalNames = require('../common/globals'); const vm = require('vm'); const assert = require('assert'); @@ -39,11 +40,62 @@ const cases = [ key: 'value', }, }, + (() => { + const obj = { + __proto__: { + [Symbol.toStringTag]: 'proto', + }, + }; + Object.defineProperty(obj, '1', { + value: 'value', + enumerable: false, + configurable: true, + }); + Object.defineProperty(obj, 'key', { + value: 'value', + enumerable: false, + configurable: true, + }); + Object.defineProperty(obj, Symbol('symbol'), { + value: 'value', + enumerable: false, + configurable: true, + }); + Object.defineProperty(obj, Symbol('symbol-enumerable'), { + value: 'value', + enumerable: true, + configurable: true, + }); + return obj; + })(), ]; for (const [idx, obj] of cases.entries()) { const ctx = vm.createContext(obj); const globalObj = vm.runInContext('this', ctx); - const keys = Object.keys(globalObj); - assert.deepStrictEqual(keys, Object.keys(obj), `Case ${idx} failed`); + assert.deepStrictEqual(Object.keys(globalObj), Object.keys(obj), `Case ${idx} failed: Object.keys`); + + const ownPropertyNamesInner = difference(Object.getOwnPropertyNames(globalObj), globalNames.intrinsics); + const ownPropertyNamesOuter = Object.getOwnPropertyNames(obj); + assert.deepStrictEqual( + ownPropertyNamesInner, + ownPropertyNamesOuter, + `Case ${idx} failed: Object.getOwnPropertyNames` + ); + + // FIXME(legendecas): globalThis[@@toStringTag] is unconditionally + // initialized to the sandbox's constructor name, even if it does not exist + // on the sandbox object. This may incorrectly initialize the prototype + // @@toStringTag on the globalThis as an own property, like + // Window.prototype[@@toStringTag] should be a property on the prototype. + assert.deepStrictEqual( + Object.getOwnPropertySymbols(globalObj).filter((it) => it !== Symbol.toStringTag), + Object.getOwnPropertySymbols(obj), + `Case ${idx} failed: Object.getOwnPropertySymbols` + ); } + +function difference(arrA, arrB) { + const setB = new Set(arrB); + return arrA.filter((x) => !setB.has(x)); +}; diff --git a/test/known_issues/test-vm-ownkeys.js b/test/parallel/test-vm-ownkeys.js similarity index 68% rename from test/known_issues/test-vm-ownkeys.js rename to test/parallel/test-vm-ownkeys.js index 9d1bae72b50c28..47938a176bbf3b 100644 --- a/test/known_issues/test-vm-ownkeys.js +++ b/test/parallel/test-vm-ownkeys.js @@ -15,11 +15,9 @@ Object.defineProperty(sandbox, sym2, { value: true }); const ctx = vm.createContext(sandbox); -// Sanity check -// Please uncomment these when the test is no longer broken -// assert.deepStrictEqual(Reflect.ownKeys(sandbox), ['a', 'b', sym1, sym2]); -// assert.deepStrictEqual(Object.getOwnPropertyNames(sandbox), ['a', 'b']); -// assert.deepStrictEqual(Object.getOwnPropertySymbols(sandbox), [sym1, sym2]); +assert.deepStrictEqual(Reflect.ownKeys(sandbox), ['a', 'b', sym1, sym2]); +assert.deepStrictEqual(Object.getOwnPropertyNames(sandbox), ['a', 'b']); +assert.deepStrictEqual(Object.getOwnPropertySymbols(sandbox), [sym1, sym2]); const nativeKeys = vm.runInNewContext('Reflect.ownKeys(this);'); const ownKeys = vm.runInContext('Reflect.ownKeys(this);', ctx); diff --git a/test/known_issues/test-vm-ownpropertynames.js b/test/parallel/test-vm-ownpropertynames.js similarity index 69% rename from test/known_issues/test-vm-ownpropertynames.js rename to test/parallel/test-vm-ownpropertynames.js index 41f6822ee1a47f..f076195257536f 100644 --- a/test/known_issues/test-vm-ownpropertynames.js +++ b/test/parallel/test-vm-ownpropertynames.js @@ -15,11 +15,9 @@ Object.defineProperty(sandbox, sym2, { value: true }); const ctx = vm.createContext(sandbox); -// Sanity check -// Please uncomment these when the test is no longer broken -// assert.deepStrictEqual(Reflect.ownKeys(sandbox), ['a', 'b', sym1, sym2]); -// assert.deepStrictEqual(Object.getOwnPropertyNames(sandbox), ['a', 'b']); -// assert.deepStrictEqual(Object.getOwnPropertySymbols(sandbox), [sym1, sym2]); +assert.deepStrictEqual(Reflect.ownKeys(sandbox), ['a', 'b', sym1, sym2]); +assert.deepStrictEqual(Object.getOwnPropertyNames(sandbox), ['a', 'b']); +assert.deepStrictEqual(Object.getOwnPropertySymbols(sandbox), [sym1, sym2]); const nativeNames = vm.runInNewContext('Object.getOwnPropertyNames(this);'); const ownNames = vm.runInContext('Object.getOwnPropertyNames(this);', ctx); diff --git a/test/known_issues/test-vm-ownpropertysymbols.js b/test/parallel/test-vm-ownpropertysymbols.js similarity index 69% rename from test/known_issues/test-vm-ownpropertysymbols.js rename to test/parallel/test-vm-ownpropertysymbols.js index 676133cc9ecaea..f943b8604949cd 100644 --- a/test/known_issues/test-vm-ownpropertysymbols.js +++ b/test/parallel/test-vm-ownpropertysymbols.js @@ -15,11 +15,9 @@ Object.defineProperty(sandbox, sym2, { value: true }); const ctx = vm.createContext(sandbox); -// Sanity check -// Please uncomment these when the test is no longer broken -// assert.deepStrictEqual(Reflect.ownKeys(sandbox), ['a', 'b', sym1, sym2]); -// assert.deepStrictEqual(Object.getOwnPropertyNames(sandbox), ['a', 'b']); -// assert.deepStrictEqual(Object.getOwnPropertySymbols(sandbox), [sym1, sym2]); +assert.deepStrictEqual(Reflect.ownKeys(sandbox), ['a', 'b', sym1, sym2]); +assert.deepStrictEqual(Object.getOwnPropertyNames(sandbox), ['a', 'b']); +assert.deepStrictEqual(Object.getOwnPropertySymbols(sandbox), [sym1, sym2]); const nativeSym = vm.runInNewContext('Object.getOwnPropertySymbols(this);'); const ownSym = vm.runInContext('Object.getOwnPropertySymbols(this);', ctx); From 9ba75faf5fe0f2027ba63df51d52d4ecd1066baf Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Fri, 30 Aug 2024 11:22:28 -0300 Subject: [PATCH 84/90] src,lib: add performance.uvMetricsInfo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit exposes a new API to the perf_hooks.performance module. This wraps uv_metrics_info into performance.uvMetricsInfo() function. PR-URL: https://github.com/nodejs/node/pull/54413 Reviewed-By: Matteo Collina Reviewed-By: Benjamin Gruenbaum Reviewed-By: Vinícius Lourenço Claro Cardoso Reviewed-By: James M Snell Reviewed-By: Tobias Nießen Reviewed-By: Richard Lau Reviewed-By: Marco Ippolito Reviewed-By: Yagiz Nizipli --- doc/api/perf_hooks.md | 34 ++++++++++++++ lib/internal/perf/nodetiming.js | 8 ++++ src/env_properties.h | 3 ++ src/node_perf.cc | 26 +++++++++++ .../fixtures/test-nodetiming-uvmetricsinfo.js | 46 +++++++++++++++++++ ...st-performance-nodetiming-uvmetricsinfo.js | 20 ++++++++ 6 files changed, 137 insertions(+) create mode 100644 test/fixtures/test-nodetiming-uvmetricsinfo.js create mode 100644 test/parallel/test-performance-nodetiming-uvmetricsinfo.js diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md index 5663c5db42cdb9..719c6f11ea946b 100644 --- a/doc/api/perf_hooks.md +++ b/doc/api/perf_hooks.md @@ -887,6 +887,40 @@ added: v8.5.0 The high resolution millisecond timestamp at which the Node.js process was initialized. +### `performanceNodeTiming.uvMetricsInfo` + + + +* Returns: {Object} + * `loopCount` {number} Number of event loop iterations. + * `events` {number} Number of events that have been processed by the event handler. + * `eventsWaiting` {number} Number of events that were waiting to be processed when the event provider was called. + +This is a wrapper to the `uv_metrics_info` function. +It returns the current set of event loop metrics. + +It is recommended to use this property inside a function whose execution was +scheduled using `setImmediate` to avoid collecting metrics before finishing all +operations scheduled during the current loop iteration. + +```cjs +const { performance } = require('node:perf_hooks'); + +setImmediate(() => { + console.log(performance.nodeTiming.uvMetricsInfo); +}); +``` + +```mjs +import { performance } from 'node:perf_hooks'; + +setImmediate(() => { + console.log(performance.nodeTiming.uvMetricsInfo); +}); +``` + ### `performanceNodeTiming.v8Start` > Stability: 1.0 - Early development @@ -2221,7 +2221,7 @@ is ignored and concurrency is one. Otherwise, concurrency defaults to ### `--test-coverage-branches=threshold` > Stability: 1 - Experimental @@ -2249,7 +2249,7 @@ files must meet **both** criteria to be included in the coverage report. ### `--test-coverage-functions=threshold` > Stability: 1 - Experimental @@ -2277,7 +2277,7 @@ files must meet **both** criteria to be included in the coverage report. ### `--test-coverage-lines=threshold` > Stability: 1 - Experimental @@ -2894,7 +2894,7 @@ When set, colors will not be used in the REPL. ### `NODE_DISABLE_COMPILE_CACHE=1` > Stability: 1.1 - Active Development diff --git a/doc/api/module.md b/doc/api/module.md index 9b98231f02e52c..ad5ce86c5328a1 100644 --- a/doc/api/module.md +++ b/doc/api/module.md @@ -67,7 +67,7 @@ const siblingModule = require('./sibling-module'); ### `module.constants.compileCacheStatus` > Stability: 1.1 - Active Development @@ -120,7 +120,7 @@ The following constants are returned as the `status` field in the object returne ### `module.enableCompileCache([cacheDir])` > Stability: 1.1 - Active Development @@ -165,7 +165,7 @@ be inheritend into the child workers. The directory can be obtained either from @@ -202,7 +202,7 @@ separately if the same base directory is used to persist the cache, so they can ### `module.getCompileCacheDir()` > Stability: 1.1 - Active Development diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md index 719c6f11ea946b..e8a9022f4f0a39 100644 --- a/doc/api/perf_hooks.md +++ b/doc/api/perf_hooks.md @@ -890,7 +890,7 @@ initialized. ### `performanceNodeTiming.uvMetricsInfo` * Returns: {Object} diff --git a/doc/api/test.md b/doc/api/test.md index 42cf30728b03d2..43f494c0e45bc1 100644 --- a/doc/api/test.md +++ b/doc/api/test.md @@ -1248,7 +1248,7 @@ added: - v18.9.0 - v16.19.0 changes: - - version: REPLACEME + - version: v22.8.0 pr-url: https://github.com/nodejs/node/pull/53927 description: Added the `isolation` option. - version: v22.6.0 diff --git a/doc/api/util.md b/doc/api/util.md index c7cf5143a4cec6..6673408dec09f9 100644 --- a/doc/api/util.md +++ b/doc/api/util.md @@ -1809,7 +1809,7 @@ added: - v21.7.0 - v20.12.0 changes: - - version: REPLACEME + - version: v22.8.0 pr-url: https://github.com/nodejs/node/pull/54389 description: Respect isTTY and environment variables such as NO_COLORS, NODE_DISABLE_COLORS, and FORCE_COLOR. diff --git a/doc/api/vm.md b/doc/api/vm.md index 30dbf724158792..f8575e3815403a 100644 --- a/doc/api/vm.md +++ b/doc/api/vm.md @@ -229,7 +229,7 @@ overhead.