typenative 0.4.0 → 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.github/workflows/ci.yml +2 -0
- package/CHANGELOG.md +201 -0
- package/CONTRIBUTION.md +1 -1
- package/bin/cli.js +1 -0
- package/bin/go/bridge.js +74 -14
- package/bin/go/convert.js +48 -0
- package/bin/go/metadata.js +13 -4
- package/bin/go/overrides.js +4 -6
- package/bin/go/stdlib.generated.js +2 -0
- package/bin/index.js +117 -0
- package/bin/main.js +1 -0
- package/bin/node/child_process.js +51 -3
- package/bin/node/cluster.js +41 -3
- package/bin/node/core.js +1 -1
- package/bin/node/crypto.js +205 -4
- package/bin/node/dgram.js +230 -6
- package/bin/node/dns.js +470 -7
- package/bin/node/errno_tables.js +445 -0
- package/bin/node/fs.js +21 -14
- package/bin/node/http.js +128 -30
- package/bin/node/http2.js +4 -1
- package/bin/node/module_v8.js +142 -0
- package/bin/node/net.js +9 -6
- package/bin/node/process.js +242 -0
- package/bin/node/readline.js +271 -0
- package/bin/node/registry.js +2 -1
- package/bin/node/sqlite.js +60 -12
- package/bin/node/stream.js +139 -7
- package/bin/node/test.js +311 -19
- package/bin/node/url.js +23 -5
- package/bin/node/util.js +18 -1
- package/bin/node/util_extra.js +6 -30
- package/bin/node/worker_threads.js +79 -19
- package/bin/transpiler.js +4019 -497
- package/bin/typecheck-node.js +1 -0
- package/bin/version.js +1 -1
- package/conformance.md +1025 -884
- package/examples/README.md +5 -5
- package/examples/json-server/README.md +31 -29
- package/examples/json-server/bench.mjs +130 -38
- package/package.json +1 -1
- package/types/typenative-go.d.ts +23 -0
- package/types/typenative-npm.d.ts +169 -5
- package/types/typenative.d.ts +185 -11
package/bin/node/crypto.js
CHANGED
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
// random bytes / UUIDs / ints, timingSafeEqual, PBKDF2 / HKDF, AES ciphers
|
|
3
3
|
// (cbc / ctr / gcm). Backed by Go's crypto packages.
|
|
4
4
|
import { defineClass, defineHelper, defineModule, setResults } from './registry.js';
|
|
5
|
+
import { streamListenerTypes } from './stream.js';
|
|
5
6
|
const cryptoHelper = `// node:crypto
|
|
6
7
|
func tnHashFactory(alg string) func() hash.Hash {
|
|
7
8
|
switch strings.ToLower(alg) {
|
|
@@ -42,6 +43,9 @@ type TnHash struct {
|
|
|
42
43
|
h hash.Hash
|
|
43
44
|
alg string
|
|
44
45
|
finalized bool
|
|
46
|
+
hmac bool
|
|
47
|
+
// set when the hash is used as a stream (hashStream)
|
|
48
|
+
stream interface{}
|
|
45
49
|
}
|
|
46
50
|
|
|
47
51
|
func TnCreateHash(alg string, options ...interface{}) *TnHash {
|
|
@@ -49,7 +53,7 @@ func TnCreateHash(alg string, options ...interface{}) *TnHash {
|
|
|
49
53
|
}
|
|
50
54
|
|
|
51
55
|
func TnCreateHmac(alg string, key interface{}, options ...interface{}) *TnHash {
|
|
52
|
-
return &TnHash{h: hmac.New(tnHashFactory(alg), tnCryptoBytes(key, "")), alg: alg}
|
|
56
|
+
return &TnHash{h: hmac.New(tnHashFactory(alg), tnCryptoBytes(key, "")), alg: alg, hmac: true}
|
|
53
57
|
}
|
|
54
58
|
|
|
55
59
|
// Bytes of data passed to crypto APIs: strings in an encoding (utf8 by default) or Buffers
|
|
@@ -76,6 +80,10 @@ func (h *TnHash) update(data interface{}, enc ...string) *TnHash {
|
|
|
76
80
|
}
|
|
77
81
|
|
|
78
82
|
func (h *TnHash) digestBytes() []byte {
|
|
83
|
+
// a second hmac.digest() is empty; a second hash.digest() throws
|
|
84
|
+
if h.finalized && h.hmac {
|
|
85
|
+
return []byte{}
|
|
86
|
+
}
|
|
79
87
|
if h.finalized {
|
|
80
88
|
panic(TnNodeError("Error", "ERR_CRYPTO_HASH_FINALIZED", "Digest already called"))
|
|
81
89
|
}
|
|
@@ -189,13 +197,158 @@ type TnCipher struct {
|
|
|
189
197
|
authTag []byte
|
|
190
198
|
autoPadding bool
|
|
191
199
|
finalized bool
|
|
200
|
+
wrapped bool
|
|
192
201
|
}
|
|
193
202
|
|
|
194
203
|
func TnGetCiphers() []string {
|
|
195
|
-
return []string{"aes-128-cbc", "aes-128-ctr", "aes-128-gcm", "aes-192-cbc", "aes-192-ctr", "aes-192-gcm", "aes-256-cbc", "aes-256-ctr", "aes-256-gcm"
|
|
204
|
+
return []string{"aes-128-cbc", "aes-128-ctr", "aes-128-gcm", "aes-192-cbc", "aes-192-ctr", "aes-192-gcm", "aes-256-cbc", "aes-256-ctr", "aes-256-gcm",
|
|
205
|
+
"aes128-wrap", "aes128-wrap-pad", "aes192-wrap", "aes192-wrap-pad", "aes256-wrap", "aes256-wrap-pad",
|
|
206
|
+
"id-aes128-wrap", "id-aes128-wrap-pad", "id-aes192-wrap", "id-aes192-wrap-pad", "id-aes256-wrap", "id-aes256-wrap-pad"}
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
// AES key wrap (RFC 3394) and key wrap with padding (RFC 5649): the whole
|
|
210
|
+
// input goes through one update(), as with OpenSSL
|
|
211
|
+
func tnAESWrapRounds(block cipher.Block, a []byte, r [][]byte) []byte {
|
|
212
|
+
n := len(r)
|
|
213
|
+
buf := make([]byte, 16)
|
|
214
|
+
for j := 0; j <= 5; j++ {
|
|
215
|
+
for i := 1; i <= n; i++ {
|
|
216
|
+
copy(buf, a)
|
|
217
|
+
copy(buf[8:], r[i-1])
|
|
218
|
+
block.Encrypt(buf, buf)
|
|
219
|
+
t := uint64(n*j + i)
|
|
220
|
+
for k := 0; k < 8; k++ {
|
|
221
|
+
a[k] = buf[k] ^ byte(t>>(56-8*k))
|
|
222
|
+
}
|
|
223
|
+
copy(r[i-1], buf[8:])
|
|
224
|
+
}
|
|
225
|
+
}
|
|
226
|
+
out := append([]byte{}, a...)
|
|
227
|
+
for _, b := range r {
|
|
228
|
+
out = append(out, b...)
|
|
229
|
+
}
|
|
230
|
+
return out
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
func tnAESUnwrapRounds(block cipher.Block, data []byte) ([]byte, []byte) {
|
|
234
|
+
n := len(data)/8 - 1
|
|
235
|
+
a := append([]byte{}, data[:8]...)
|
|
236
|
+
r := make([][]byte, n)
|
|
237
|
+
for i := range r {
|
|
238
|
+
r[i] = append([]byte{}, data[8*(i+1):8*(i+2)]...)
|
|
239
|
+
}
|
|
240
|
+
buf := make([]byte, 16)
|
|
241
|
+
for j := 5; j >= 0; j-- {
|
|
242
|
+
for i := n; i >= 1; i-- {
|
|
243
|
+
t := uint64(n*j + i)
|
|
244
|
+
for k := 0; k < 8; k++ {
|
|
245
|
+
buf[k] = a[k] ^ byte(t>>(56-8*k))
|
|
246
|
+
}
|
|
247
|
+
copy(buf[8:], r[i-1])
|
|
248
|
+
block.Decrypt(buf, buf)
|
|
249
|
+
copy(a, buf[:8])
|
|
250
|
+
copy(r[i-1], buf[8:])
|
|
251
|
+
}
|
|
252
|
+
}
|
|
253
|
+
plain := []byte{}
|
|
254
|
+
for _, b := range r {
|
|
255
|
+
plain = append(plain, b...)
|
|
256
|
+
}
|
|
257
|
+
return a, plain
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
func tnWrapState() *TnError {
|
|
261
|
+
return TnNodeError("Error", "", "Trying to add data in unsupported state")
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
func (c *TnCipher) keyWrap(data []byte) []byte {
|
|
265
|
+
if c.wrapped {
|
|
266
|
+
panic(tnWrapState())
|
|
267
|
+
}
|
|
268
|
+
c.wrapped = true
|
|
269
|
+
padded := c.mode == "wrap-pad"
|
|
270
|
+
if !c.decrypt {
|
|
271
|
+
if padded {
|
|
272
|
+
aiv := append(append([]byte{}, c.iv...), byte(len(data)>>24), byte(len(data)>>16), byte(len(data)>>8), byte(len(data)))
|
|
273
|
+
plain := append(append([]byte{}, data...), make([]byte, (8-len(data)%8)%8)...)
|
|
274
|
+
if len(plain) == 8 {
|
|
275
|
+
out := make([]byte, 16)
|
|
276
|
+
c.block.Encrypt(out, append(aiv, plain...))
|
|
277
|
+
return out
|
|
278
|
+
}
|
|
279
|
+
data = plain
|
|
280
|
+
c.iv = aiv
|
|
281
|
+
} else if len(data) < 16 || len(data)%8 != 0 {
|
|
282
|
+
panic(tnWrapState())
|
|
283
|
+
}
|
|
284
|
+
r := make([][]byte, len(data)/8)
|
|
285
|
+
for i := range r {
|
|
286
|
+
r[i] = append([]byte{}, data[8*i:8*i+8]...)
|
|
287
|
+
}
|
|
288
|
+
return tnAESWrapRounds(c.block, append([]byte{}, c.iv...), r)
|
|
289
|
+
}
|
|
290
|
+
if len(data) < 16 || len(data)%8 != 0 {
|
|
291
|
+
panic(tnWrapState())
|
|
292
|
+
}
|
|
293
|
+
var a, plain []byte
|
|
294
|
+
if padded && len(data) == 16 {
|
|
295
|
+
buf := make([]byte, 16)
|
|
296
|
+
c.block.Decrypt(buf, data)
|
|
297
|
+
a, plain = buf[:8], buf[8:]
|
|
298
|
+
} else {
|
|
299
|
+
a, plain = tnAESUnwrapRounds(c.block, data)
|
|
300
|
+
}
|
|
301
|
+
if !padded {
|
|
302
|
+
if subtle.ConstantTimeCompare(a, c.iv) != 1 {
|
|
303
|
+
panic(tnWrapState())
|
|
304
|
+
}
|
|
305
|
+
return plain
|
|
306
|
+
}
|
|
307
|
+
size := int(a[4])<<24 | int(a[5])<<16 | int(a[6])<<8 | int(a[7])
|
|
308
|
+
if subtle.ConstantTimeCompare(a[:4], c.iv) != 1 || size > len(plain) || size <= len(plain)-8 {
|
|
309
|
+
panic(tnWrapState())
|
|
310
|
+
}
|
|
311
|
+
for _, b := range plain[size:] {
|
|
312
|
+
if b != 0 {
|
|
313
|
+
panic(tnWrapState())
|
|
314
|
+
}
|
|
315
|
+
}
|
|
316
|
+
return plain[:size]
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
// aes128-wrap / id-aes256-wrap-pad / …
|
|
320
|
+
func tnCreateWrapCipher(alg string, key interface{}, iv interface{}, decrypt bool) *TnCipher {
|
|
321
|
+
name := strings.TrimPrefix(strings.ToLower(alg), "id-")
|
|
322
|
+
mode := "wrap"
|
|
323
|
+
if strings.HasSuffix(name, "-wrap-pad") {
|
|
324
|
+
mode = "wrap-pad"
|
|
325
|
+
}
|
|
326
|
+
bits := strings.TrimSuffix(strings.TrimSuffix(strings.TrimPrefix(name, "aes"), "-pad"), "-wrap")
|
|
327
|
+
k := tnCryptoBytes(key, "")
|
|
328
|
+
if strconv.Itoa(len(k)*8) != bits {
|
|
329
|
+
panic(TnNodeError("RangeError", "ERR_CRYPTO_INVALID_KEYLEN", "Invalid key length"))
|
|
330
|
+
}
|
|
331
|
+
block, err := aes.NewCipher(k)
|
|
332
|
+
if err != nil {
|
|
333
|
+
panic(TnNodeError("RangeError", "ERR_CRYPTO_INVALID_KEYLEN", "Invalid key length"))
|
|
334
|
+
}
|
|
335
|
+
ivBytes := []byte{0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6}
|
|
336
|
+
if mode == "wrap-pad" {
|
|
337
|
+
ivBytes = []byte{0xA6, 0x59, 0x59, 0xA6}
|
|
338
|
+
}
|
|
339
|
+
if iv != nil && !TnIsNil(iv) {
|
|
340
|
+
ivBytes = tnCryptoBytes(iv, "")
|
|
341
|
+
}
|
|
342
|
+
if len(ivBytes) != 8 && mode == "wrap" || len(ivBytes) != 4 && mode == "wrap-pad" {
|
|
343
|
+
panic(TnNodeError("TypeError", "ERR_CRYPTO_INVALID_IV", "Invalid initialization vector"))
|
|
344
|
+
}
|
|
345
|
+
return &TnCipher{decrypt: decrypt, mode: mode, block: block, iv: ivBytes}
|
|
196
346
|
}
|
|
197
347
|
|
|
198
348
|
func TnCreateCipher(alg string, key interface{}, iv interface{}, decrypt bool, options ...interface{}) *TnCipher {
|
|
349
|
+
if strings.Contains(strings.ToLower(alg), "-wrap") {
|
|
350
|
+
return tnCreateWrapCipher(alg, key, iv, decrypt)
|
|
351
|
+
}
|
|
199
352
|
parts := strings.Split(strings.ToLower(alg), "-")
|
|
200
353
|
if len(parts) != 3 || parts[0] != "aes" {
|
|
201
354
|
panic(TnNodeError("Error", "ERR_CRYPTO_UNKNOWN_CIPHER", "Unknown cipher"))
|
|
@@ -238,6 +391,8 @@ func TnCreateCipher(alg string, key interface{}, iv interface{}, decrypt bool, o
|
|
|
238
391
|
|
|
239
392
|
func (c *TnCipher) process(data []byte) []byte {
|
|
240
393
|
switch c.mode {
|
|
394
|
+
case "wrap", "wrap-pad":
|
|
395
|
+
return c.keyWrap(data)
|
|
241
396
|
case "ctr":
|
|
242
397
|
out := make([]byte, len(data))
|
|
243
398
|
c.stream.XORKeyStream(out, data)
|
|
@@ -264,7 +419,7 @@ func (c *TnCipher) finish() []byte {
|
|
|
264
419
|
}
|
|
265
420
|
c.finalized = true
|
|
266
421
|
switch c.mode {
|
|
267
|
-
case "ctr":
|
|
422
|
+
case "ctr", "wrap", "wrap-pad":
|
|
268
423
|
return []byte{}
|
|
269
424
|
case "gcm":
|
|
270
425
|
if c.decrypt {
|
|
@@ -344,6 +499,38 @@ func (c *TnCipher) setAutoPadding(pad ...bool) *TnCipher {
|
|
|
344
499
|
c.autoPadding = len(pad) == 0 || pad[0]
|
|
345
500
|
return c
|
|
346
501
|
}`;
|
|
502
|
+
// Hash / Hmac as streams (write / end / pipe / pipeline): a transform that
|
|
503
|
+
// hashes what is written and pushes the digest at the end, as in Node; only
|
|
504
|
+
// programs that use a hash as a stream carry it
|
|
505
|
+
const hashStreamHelper = `func (h *TnHash) tnStream() *TnStream {
|
|
506
|
+
if h.stream == nil {
|
|
507
|
+
s := TnNewTransform()
|
|
508
|
+
s.goTransform = func(chunk []byte) {
|
|
509
|
+
if !h.finalized {
|
|
510
|
+
h.h.Write(chunk)
|
|
511
|
+
}
|
|
512
|
+
}
|
|
513
|
+
s.goFlush = func() []byte { return h.digestBytes() }
|
|
514
|
+
h.stream = s
|
|
515
|
+
}
|
|
516
|
+
return h.stream.(*TnStream)
|
|
517
|
+
}
|
|
518
|
+
|
|
519
|
+
func (h *TnHash) write(chunk interface{}, args ...interface{}) bool {
|
|
520
|
+
return h.tnStream().write(chunk, args...)
|
|
521
|
+
}
|
|
522
|
+
|
|
523
|
+
func (h *TnHash) end(args ...interface{}) *TnStream { return h.tnStream().end(args...) }
|
|
524
|
+
|
|
525
|
+
func (h *TnHash) on(event string, fn interface{}) *TnEventEmitter { return h.tnStream().on(event, fn) }
|
|
526
|
+
|
|
527
|
+
func (h *TnHash) once(event string, fn interface{}) *TnEventEmitter {
|
|
528
|
+
return h.tnStream().once(event, fn)
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
func (h *TnHash) read(size ...float64) interface{} { return h.tnStream().read(size...) }
|
|
532
|
+
|
|
533
|
+
func (h *TnHash) setEncoding(enc string) *TnStream { return h.tnStream().setEncoding(enc) }`;
|
|
347
534
|
export function registerCrypto(r) {
|
|
348
535
|
defineModule(r, 'crypto');
|
|
349
536
|
r.globals['crypto'] = 'crypto';
|
|
@@ -368,7 +555,21 @@ export function registerCrypto(r) {
|
|
|
368
555
|
'strconv',
|
|
369
556
|
'strings'
|
|
370
557
|
], ['error', 'buffer', 'dynamic'], cryptoHelper);
|
|
371
|
-
defineClass(r, 'crypto.Hash', '*TnHash', 'class', 'update=*TnHash; copy=*TnHash', '', '', '');
|
|
558
|
+
defineClass(r, 'crypto.Hash', '*TnHash', 'class', 'update=*TnHash; copy=*TnHash; write=bool; end=*TnStream; on=*TnEventEmitter; once=*TnEventEmitter; read=interface{}; setEncoding=*TnStream; pipe=interface{}', '', '', '');
|
|
559
|
+
defineHelper(r, 'hashStream', [], ['nodeCrypto', 'nodeStream'], hashStreamHelper);
|
|
560
|
+
for (const method of ['write', 'end', 'on', 'once', 'read', 'setEncoding']) {
|
|
561
|
+
r.methods[`crypto.Hash#${method}`] = (c) => {
|
|
562
|
+
r.helper('hashStream');
|
|
563
|
+
return `${c.recv}.${method}(${c.args.join(', ')})`;
|
|
564
|
+
};
|
|
565
|
+
}
|
|
566
|
+
r.methods['crypto.Hash#pipe'] = (c) => {
|
|
567
|
+
r.helper('hashStream');
|
|
568
|
+
return `TnPipe(${c.recv}, ${c.args.join(', ')})`;
|
|
569
|
+
};
|
|
570
|
+
r.typers['crypto.Hash#pipe'] = (c) => c.types[0] || '*TnStream';
|
|
571
|
+
r.paramTypers['crypto.Hash#on'] = (nodes) => streamListenerTypes(nodes);
|
|
572
|
+
r.paramTypers['crypto.Hash#once'] = r.paramTypers['crypto.Hash#on'];
|
|
372
573
|
r.classes['crypto.Hmac'] = r.classes['crypto.Hash'];
|
|
373
574
|
defineClass(r, 'crypto.Cipher', '*TnCipher', 'class', 'setAAD=*TnCipher; setAuthTag=*TnCipher; getAuthTag=[]byte; setAutoPadding=*TnCipher', '', '', '');
|
|
374
575
|
r.classes['crypto.Cipheriv'] = r.classes['crypto.Cipher'];
|
package/bin/node/dgram.js
CHANGED
|
@@ -345,10 +345,138 @@ func (s *TnDgramSocket) unref() *TnDgramSocket {
|
|
|
345
345
|
return s
|
|
346
346
|
}
|
|
347
347
|
|
|
348
|
-
|
|
349
|
-
func (
|
|
350
|
-
|
|
351
|
-
|
|
348
|
+
// Socket options: EBADF before bind(), as in Node (libuv opens the socket there)
|
|
349
|
+
func tnDgramOptError(name string, err error) *TnError {
|
|
350
|
+
code := "EBADF"
|
|
351
|
+
switch {
|
|
352
|
+
case err == nil:
|
|
353
|
+
case errors.Is(err, syscall.EINVAL):
|
|
354
|
+
code = "EINVAL"
|
|
355
|
+
case errors.Is(err, syscall.ENODEV):
|
|
356
|
+
code = "ENODEV"
|
|
357
|
+
case errors.Is(err, syscall.EBADF):
|
|
358
|
+
code = "EBADF"
|
|
359
|
+
default:
|
|
360
|
+
code = tnNetCode(err)
|
|
361
|
+
}
|
|
362
|
+
e := TnNodeError("Error", code, name+" "+code)
|
|
363
|
+
e.props["errno"] = tnNetErrnos[code]
|
|
364
|
+
e.props["syscall"] = name
|
|
365
|
+
return e
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
func (s *TnDgramSocket) setOpt(name string, opt string, value int) {
|
|
369
|
+
if s.conn == nil {
|
|
370
|
+
panic(tnDgramOptError(name, nil))
|
|
371
|
+
}
|
|
372
|
+
if err := tnDgramSetOpt(s.conn, s.network == "udp6", opt, value); err != nil {
|
|
373
|
+
panic(tnDgramOptError(name, err))
|
|
374
|
+
}
|
|
375
|
+
}
|
|
376
|
+
|
|
377
|
+
func tnDgramBool(flag bool) int {
|
|
378
|
+
if flag {
|
|
379
|
+
return 1
|
|
380
|
+
}
|
|
381
|
+
return 0
|
|
382
|
+
}
|
|
383
|
+
|
|
384
|
+
func tnDgramTTL(name string, ttl float64) int {
|
|
385
|
+
if math.IsNaN(ttl) || ttl != math.Trunc(ttl) {
|
|
386
|
+
panic(TnNodeError("TypeError", "ERR_INVALID_ARG_TYPE", "The \\"ttl\\" argument must be of type number. Received "+TnJSString(ttl)))
|
|
387
|
+
}
|
|
388
|
+
return int(ttl)
|
|
389
|
+
}
|
|
390
|
+
|
|
391
|
+
func (s *TnDgramSocket) setBroadcast(flag bool) {
|
|
392
|
+
s.setOpt("setBroadcast", "broadcast", tnDgramBool(flag))
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
func (s *TnDgramSocket) setTTL(ttl float64) float64 {
|
|
396
|
+
s.setOpt("setTTL", "ttl", tnDgramTTL("setTTL", ttl))
|
|
397
|
+
return ttl
|
|
398
|
+
}
|
|
399
|
+
|
|
400
|
+
func (s *TnDgramSocket) setMulticastTTL(ttl float64) float64 {
|
|
401
|
+
s.setOpt("setMulticastTTL", "multicastTTL", tnDgramTTL("setMulticastTTL", ttl))
|
|
402
|
+
return ttl
|
|
403
|
+
}
|
|
404
|
+
|
|
405
|
+
func (s *TnDgramSocket) setMulticastLoopback(flag bool) bool {
|
|
406
|
+
s.setOpt("setMulticastLoopback", "multicastLoopback", tnDgramBool(flag))
|
|
407
|
+
return flag
|
|
408
|
+
}
|
|
409
|
+
|
|
410
|
+
// The interface for a multicastInterface argument: an IPv4 address, or an
|
|
411
|
+
// IPv6 scope ("::%eth0") or address
|
|
412
|
+
func (s *TnDgramSocket) multicastIface(iface string) (net.IP, int) {
|
|
413
|
+
if iface == "" {
|
|
414
|
+
return nil, 0
|
|
415
|
+
}
|
|
416
|
+
if i := strings.IndexByte(iface, '%'); i >= 0 {
|
|
417
|
+
if ifi, err := net.InterfaceByName(iface[i+1:]); err == nil {
|
|
418
|
+
return nil, ifi.Index
|
|
419
|
+
}
|
|
420
|
+
if n, err := strconv.Atoi(iface[i+1:]); err == nil {
|
|
421
|
+
return nil, n
|
|
422
|
+
}
|
|
423
|
+
iface = iface[:i]
|
|
424
|
+
}
|
|
425
|
+
ip := net.ParseIP(iface)
|
|
426
|
+
if ip == nil {
|
|
427
|
+
panic(tnDgramOptError("setMulticastInterface", syscall.EINVAL))
|
|
428
|
+
}
|
|
429
|
+
if ip.To4() == nil {
|
|
430
|
+
if ifaces, err := net.Interfaces(); err == nil {
|
|
431
|
+
for _, ifi := range ifaces {
|
|
432
|
+
addrs, _ := ifi.Addrs()
|
|
433
|
+
for _, a := range addrs {
|
|
434
|
+
if n, ok := a.(*net.IPNet); ok && n.IP.Equal(ip) {
|
|
435
|
+
return ip, ifi.Index
|
|
436
|
+
}
|
|
437
|
+
}
|
|
438
|
+
}
|
|
439
|
+
}
|
|
440
|
+
}
|
|
441
|
+
return ip, 0
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
// setMulticastInterface(iface)
|
|
445
|
+
func (s *TnDgramSocket) setMulticastInterface(iface string) {
|
|
446
|
+
if s.conn == nil {
|
|
447
|
+
panic(tnDgramOptError("setMulticastInterface", nil))
|
|
448
|
+
}
|
|
449
|
+
ip, index := s.multicastIface(iface)
|
|
450
|
+
if err := tnDgramMulticastIF(s.conn, s.network == "udp6", ip, index); err != nil {
|
|
451
|
+
panic(tnDgramOptError("setMulticastInterface", err))
|
|
452
|
+
}
|
|
453
|
+
}
|
|
454
|
+
|
|
455
|
+
// addMembership(group, iface?) / dropMembership: an unbound socket binds first
|
|
456
|
+
func (s *TnDgramSocket) membership(name string, join bool, group string, iface []string) {
|
|
457
|
+
ip := net.ParseIP(group)
|
|
458
|
+
if ip == nil || !ip.IsMulticast() {
|
|
459
|
+
panic(tnDgramOptError(name, syscall.EINVAL))
|
|
460
|
+
}
|
|
461
|
+
if s.conn == nil {
|
|
462
|
+
if err := s.listen("", 0); err != nil {
|
|
463
|
+
panic(err)
|
|
464
|
+
}
|
|
465
|
+
TnLoopPost(func() { s.emit("listening") })
|
|
466
|
+
}
|
|
467
|
+
ifaceIP, index := s.multicastIface(strings.Join(iface, ""))
|
|
468
|
+
if err := tnDgramMembership(s.conn, join, ip, ifaceIP, index); err != nil {
|
|
469
|
+
panic(tnDgramOptError(name, err))
|
|
470
|
+
}
|
|
471
|
+
}
|
|
472
|
+
|
|
473
|
+
func (s *TnDgramSocket) addMembership(group string, iface ...string) {
|
|
474
|
+
s.membership("addMembership", true, group, iface)
|
|
475
|
+
}
|
|
476
|
+
|
|
477
|
+
func (s *TnDgramSocket) dropMembership(group string, iface ...string) {
|
|
478
|
+
s.membership("dropMembership", false, group, iface)
|
|
479
|
+
}
|
|
352
480
|
|
|
353
481
|
func (s *TnDgramSocket) setRecvBufferSize(size float64) {
|
|
354
482
|
if s.conn != nil {
|
|
@@ -361,11 +489,107 @@ func (s *TnDgramSocket) setSendBufferSize(size float64) {
|
|
|
361
489
|
s.conn.SetWriteBuffer(int(size))
|
|
362
490
|
}
|
|
363
491
|
}`;
|
|
492
|
+
// Socket options through the raw descriptor, one variant per target OS
|
|
493
|
+
// (nodeDgramOS@os); BSDs take a byte for the IPv4 multicast TTL / loopback
|
|
494
|
+
function dgramOSHelper(fd, mcast4) {
|
|
495
|
+
return `func tnDgramSockopt(conn *net.UDPConn, set func(fd ${fd}) error) error {
|
|
496
|
+
raw, err := conn.SyscallConn()
|
|
497
|
+
if err != nil {
|
|
498
|
+
return err
|
|
499
|
+
}
|
|
500
|
+
var serr error
|
|
501
|
+
if err := raw.Control(func(fd uintptr) { serr = set(${fd}(fd)) }); err != nil {
|
|
502
|
+
return err
|
|
503
|
+
}
|
|
504
|
+
return serr
|
|
505
|
+
}
|
|
506
|
+
|
|
507
|
+
func tnDgramSetOpt(conn *net.UDPConn, v6 bool, opt string, value int) error {
|
|
508
|
+
return tnDgramSockopt(conn, func(fd ${fd}) error {
|
|
509
|
+
switch opt {
|
|
510
|
+
case "broadcast":
|
|
511
|
+
return syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_BROADCAST, value)
|
|
512
|
+
case "ttl":
|
|
513
|
+
if v6 {
|
|
514
|
+
return syscall.SetsockoptInt(fd, syscall.IPPROTO_IPV6, syscall.IPV6_UNICAST_HOPS, value)
|
|
515
|
+
}
|
|
516
|
+
return syscall.SetsockoptInt(fd, syscall.IPPROTO_IP, syscall.IP_TTL, value)
|
|
517
|
+
case "multicastTTL":
|
|
518
|
+
if v6 {
|
|
519
|
+
return syscall.SetsockoptInt(fd, syscall.IPPROTO_IPV6, syscall.IPV6_MULTICAST_HOPS, value)
|
|
520
|
+
}
|
|
521
|
+
return ${mcast4.replace('OPT', 'syscall.IP_MULTICAST_TTL')}
|
|
522
|
+
case "multicastLoopback":
|
|
523
|
+
if v6 {
|
|
524
|
+
return syscall.SetsockoptInt(fd, syscall.IPPROTO_IPV6, syscall.IPV6_MULTICAST_LOOP, value)
|
|
525
|
+
}
|
|
526
|
+
return ${mcast4.replace('OPT', 'syscall.IP_MULTICAST_LOOP')}
|
|
527
|
+
}
|
|
528
|
+
return nil
|
|
529
|
+
})
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
func tnDgramMulticastIF(conn *net.UDPConn, v6 bool, ip net.IP, index int) error {
|
|
533
|
+
return tnDgramSockopt(conn, func(fd ${fd}) error {
|
|
534
|
+
if v6 {
|
|
535
|
+
return syscall.SetsockoptInt(fd, syscall.IPPROTO_IPV6, syscall.IPV6_MULTICAST_IF, index)
|
|
536
|
+
}
|
|
537
|
+
var addr [4]byte
|
|
538
|
+
if ip4 := ip.To4(); ip4 != nil {
|
|
539
|
+
copy(addr[:], ip4)
|
|
540
|
+
}
|
|
541
|
+
return syscall.SetsockoptInet4Addr(fd, syscall.IPPROTO_IP, syscall.IP_MULTICAST_IF, addr)
|
|
542
|
+
})
|
|
543
|
+
}
|
|
544
|
+
|
|
545
|
+
func tnDgramMembership(conn *net.UDPConn, join bool, group net.IP, iface net.IP, index int) error {
|
|
546
|
+
return tnDgramSockopt(conn, func(fd ${fd}) error {
|
|
547
|
+
if g4 := group.To4(); g4 != nil {
|
|
548
|
+
mreq := &syscall.IPMreq{}
|
|
549
|
+
copy(mreq.Multiaddr[:], g4)
|
|
550
|
+
if i4 := iface.To4(); i4 != nil {
|
|
551
|
+
copy(mreq.Interface[:], i4)
|
|
552
|
+
}
|
|
553
|
+
opt := syscall.IP_ADD_MEMBERSHIP
|
|
554
|
+
if !join {
|
|
555
|
+
opt = syscall.IP_DROP_MEMBERSHIP
|
|
556
|
+
}
|
|
557
|
+
return syscall.SetsockoptIPMreq(fd, syscall.IPPROTO_IP, opt, mreq)
|
|
558
|
+
}
|
|
559
|
+
mreq := &syscall.IPv6Mreq{Interface: uint32(index)}
|
|
560
|
+
copy(mreq.Multiaddr[:], group.To16())
|
|
561
|
+
opt := syscall.IPV6_JOIN_GROUP
|
|
562
|
+
if !join {
|
|
563
|
+
opt = syscall.IPV6_LEAVE_GROUP
|
|
564
|
+
}
|
|
565
|
+
return syscall.SetsockoptIPv6Mreq(fd, syscall.IPPROTO_IPV6, opt, mreq)
|
|
566
|
+
})
|
|
567
|
+
}`;
|
|
568
|
+
}
|
|
569
|
+
const otherDgramOSHelper = `func tnDgramSetOpt(conn *net.UDPConn, v6 bool, opt string, value int) error {
|
|
570
|
+
return errors.ErrUnsupported
|
|
571
|
+
}
|
|
572
|
+
|
|
573
|
+
func tnDgramMulticastIF(conn *net.UDPConn, v6 bool, ip net.IP, index int) error {
|
|
574
|
+
return errors.ErrUnsupported
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
func tnDgramMembership(conn *net.UDPConn, join bool, group net.IP, iface net.IP, index int) error {
|
|
578
|
+
return errors.ErrUnsupported
|
|
579
|
+
}`;
|
|
364
580
|
export function registerDgram(r) {
|
|
365
581
|
defineModule(r, 'dgram');
|
|
366
|
-
|
|
582
|
+
const intOpt = 'syscall.SetsockoptInt(fd, syscall.IPPROTO_IP, OPT, value)';
|
|
583
|
+
const byteOpt = 'syscall.SetsockoptByte(fd, syscall.IPPROTO_IP, OPT, byte(value))';
|
|
584
|
+
defineHelper(r, 'nodeDgramOS@linux', ['net', 'syscall'], [], dgramOSHelper('int', intOpt));
|
|
585
|
+
for (const goos of ['darwin', 'freebsd', 'openbsd', 'netbsd', 'dragonfly']) {
|
|
586
|
+
defineHelper(r, `nodeDgramOS@${goos}`, ['net', 'syscall'], [], dgramOSHelper('int', byteOpt));
|
|
587
|
+
}
|
|
588
|
+
defineHelper(r, 'nodeDgramOS@windows', ['net', 'syscall'], [], dgramOSHelper('syscall.Handle', intOpt));
|
|
589
|
+
defineHelper(r, 'nodeDgramOS@other', ['errors', 'net'], [], otherDgramOSHelper);
|
|
590
|
+
defineHelper(r, 'nodeDgram', ['errors', 'math', 'net', 'strconv', 'strings', 'syscall'], ['nodeNet', 'netErrors', 'nodeEvents', 'eventLoop', 'nodeInvoke', 'dynamic', 'nodeDgramOS@os'], dgramHelper);
|
|
367
591
|
const use = () => r.helper('nodeDgram');
|
|
368
|
-
defineClass(r, 'dgram.Socket', '*TnDgramSocket', 'class', 'on=*TnEventEmitter; once=*TnEventEmitter; addListener=*TnEventEmitter; off=*TnEventEmitter; removeListener=*TnEventEmitter; removeAllListeners=*TnEventEmitter; emit=bool; listenerCount=float64; bind=*TnDgramSocket; send=; connect=; disconnect=; remoteAddress=*TnAddressInfo; address=*TnAddressInfo; close=*TnDgramSocket; ref=*TnDgramSocket; unref=*TnDgramSocket; setBroadcast=; setTTL=float64; setMulticastTTL=float64; setMulticastLoopback=bool; setRecvBufferSize=; setSendBufferSize=', '', '', '');
|
|
592
|
+
defineClass(r, 'dgram.Socket', '*TnDgramSocket', 'class', 'on=*TnEventEmitter; once=*TnEventEmitter; addListener=*TnEventEmitter; off=*TnEventEmitter; removeListener=*TnEventEmitter; removeAllListeners=*TnEventEmitter; emit=bool; listenerCount=float64; bind=*TnDgramSocket; send=; connect=; disconnect=; remoteAddress=*TnAddressInfo; address=*TnAddressInfo; close=*TnDgramSocket; ref=*TnDgramSocket; unref=*TnDgramSocket; setBroadcast=; setTTL=float64; setMulticastTTL=float64; setMulticastLoopback=bool; setMulticastInterface=; addMembership=; dropMembership=; setRecvBufferSize=; setSendBufferSize=', '', '', '');
|
|
369
593
|
defineClass(r, 'dgram.RemoteInfo', '*TnRemoteInfo', 'class', '', 'address=string; family=string; port=float64; size=float64', '', '');
|
|
370
594
|
const listeners = (nodes) => {
|
|
371
595
|
const event = nodes[0];
|