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.
Files changed (44) hide show
  1. package/.github/workflows/ci.yml +2 -0
  2. package/CHANGELOG.md +201 -0
  3. package/CONTRIBUTION.md +1 -1
  4. package/bin/cli.js +1 -0
  5. package/bin/go/bridge.js +74 -14
  6. package/bin/go/convert.js +48 -0
  7. package/bin/go/metadata.js +13 -4
  8. package/bin/go/overrides.js +4 -6
  9. package/bin/go/stdlib.generated.js +2 -0
  10. package/bin/index.js +117 -0
  11. package/bin/main.js +1 -0
  12. package/bin/node/child_process.js +51 -3
  13. package/bin/node/cluster.js +41 -3
  14. package/bin/node/core.js +1 -1
  15. package/bin/node/crypto.js +205 -4
  16. package/bin/node/dgram.js +230 -6
  17. package/bin/node/dns.js +470 -7
  18. package/bin/node/errno_tables.js +445 -0
  19. package/bin/node/fs.js +21 -14
  20. package/bin/node/http.js +128 -30
  21. package/bin/node/http2.js +4 -1
  22. package/bin/node/module_v8.js +142 -0
  23. package/bin/node/net.js +9 -6
  24. package/bin/node/process.js +242 -0
  25. package/bin/node/readline.js +271 -0
  26. package/bin/node/registry.js +2 -1
  27. package/bin/node/sqlite.js +60 -12
  28. package/bin/node/stream.js +139 -7
  29. package/bin/node/test.js +311 -19
  30. package/bin/node/url.js +23 -5
  31. package/bin/node/util.js +18 -1
  32. package/bin/node/util_extra.js +6 -30
  33. package/bin/node/worker_threads.js +79 -19
  34. package/bin/transpiler.js +4019 -497
  35. package/bin/typecheck-node.js +1 -0
  36. package/bin/version.js +1 -1
  37. package/conformance.md +1025 -884
  38. package/examples/README.md +5 -5
  39. package/examples/json-server/README.md +31 -29
  40. package/examples/json-server/bench.mjs +130 -38
  41. package/package.json +1 -1
  42. package/types/typenative-go.d.ts +23 -0
  43. package/types/typenative-npm.d.ts +169 -5
  44. package/types/typenative.d.ts +185 -11
@@ -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
- func (s *TnDgramSocket) setBroadcast(flag bool) {}
349
- func (s *TnDgramSocket) setTTL(ttl float64) float64 { return ttl }
350
- func (s *TnDgramSocket) setMulticastTTL(ttl float64) float64 { return ttl }
351
- func (s *TnDgramSocket) setMulticastLoopback(flag bool) bool { return flag }
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
- defineHelper(r, 'nodeDgram', ['net', 'strconv', 'strings'], ['nodeNet', 'netErrors', 'nodeEvents', 'eventLoop', 'nodeInvoke', 'dynamic'], dgramHelper);
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];