@samitouri / QOSAMI-X402Tunnel-1 / commits / 01117849

rename relaydns to portal

Kim committed Oct 29, 2025 at 16:50 UTC 01117849a0b36f7701cfca6ced89e4bd4d02d362

71 files changed +453 -2364

.github/workflows/ci.yml

+6 -6

@@ -43,9 +43,9 @@ jobs:

43 - name: Run goimports

44 run: |

45 go install golang.org/x/tools/cmd/goimports@latest

46 - if [ -n "$(goimports -local github.com/gosuda/relaydns -l .)" ]; then

46 + if [ -n "$(goimports -local github.com/gosuda/portal -l .)" ]; then

47 echo "Go imports are not formatted:"

48 - goimports -local github.com/gosuda/relaydns -d .

48 + goimports -local github.com/gosuda/portal -d .

49 exit 1

50 fi

@@ -87,13 +87,13 @@ jobs:

87 # run: go mod download

88 #

89 # - name: Build server binary

90 -# run: go build -v -trimpath -o bin/relaydns-server ./cmd/server

90 +# run: go build -v -trimpath -o bin/portal-server ./cmd/server

91 #

92 # - name: Build example HTTP client

93 -# run: go build -v -trimpath -o bin/relaydns-client ./sdk/go/examples/http-client

93 +# run: go build -v -trimpath -o bin/portal-client ./sdk/go/examples/http-client

94 #

95 # - name: Build example chat client

96 -# run: go build -v -trimpath -o bin/relaydns-chat ./sdk/go/examples/chat

96 +# run: go build -v -trimpath -o bin/portal-chat ./sdk/go/examples/chat

97 #

98 # - name: Upload binaries

99 # uses: actions/upload-artifact@v4

@@ -209,7 +209,7 @@ jobs:

209 context: .

210 file: ./Dockerfile

211 push: false

212 - tags: relaydns-server:ci

212 + tags: portal-server:ci

213 cache-from: type=gha

214 cache-to: type=gha,mode=max

215

Cargo.lock

+33 -33

@@ -597,6 +597,39 @@ dependencies = [

597 "universal-hash",

598 ]

599

600 +[[package]]

601 +name = "portal-wasm"

602 +version = "0.1.0"

603 +dependencies = [

604 + "anyhow",

605 + "bytes",

606 + "chacha20poly1305",

607 + "console_error_panic_hook",

608 + "ed25519-dalek",

609 + "futures",

610 + "getrandom 0.2.16",

611 + "hex",

612 + "hkdf",

613 + "js-sys",

614 + "log",

615 + "parking_lot",

616 + "prost",

617 + "prost-build",

618 + "rand_core",

619 + "serde",

620 + "serde-wasm-bindgen",

621 + "serde_json",

622 + "sha2",

623 + "thiserror",

624 + "tokio",

625 + "wasm-bindgen",

626 + "wasm-bindgen-futures",

627 + "wasm-bindgen-test",

628 + "web-sys",

629 + "wee_alloc",

630 + "x25519-dalek",

631 +]

632 +

633 [[package]]

634 name = "prettyplease"

635 version = "0.2.37"

@@ -730,39 +763,6 @@ version = "0.8.8"

763 source = "registry+https://github.com/rust-lang/crates.io-index"

764 checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"

765

733 -[[package]]

734 -name = "relaydns-wasm"

735 -version = "0.1.0"

736 -dependencies = [

737 - "anyhow",

738 - "bytes",

739 - "chacha20poly1305",

740 - "console_error_panic_hook",

741 - "ed25519-dalek",

742 - "futures",

743 - "getrandom 0.2.16",

744 - "hex",

745 - "hkdf",

746 - "js-sys",

747 - "log",

748 - "parking_lot",

749 - "prost",

750 - "prost-build",

751 - "rand_core",

752 - "serde",

753 - "serde-wasm-bindgen",

754 - "serde_json",

755 - "sha2",

756 - "thiserror",

757 - "tokio",

758 - "wasm-bindgen",

759 - "wasm-bindgen-futures",

760 - "wasm-bindgen-test",

761 - "web-sys",

762 - "wee_alloc",

763 - "x25519-dalek",

764 -]

765 -

766 [[package]]

767 name = "rustc_version"

768 version = "0.4.1"

Cargo.toml

+1 -1

@@ -1,5 +1,5 @@

1 [workspace]

2 -members = ["relaydns/wasm"]

2 +members = ["portal/wasm"]

3 resolver = "2"

5 [profile.release]

Dockerfile

+3 -3

@@ -11,13 +11,13 @@ COPY . .

11 RUN apt-get update && apt-get install -y --no-install-recommends make && rm -rf /var/lib/apt/lists/*

13 RUN --mount=type=cache,target=/go/pkg/mod \

14 - make build-server && install -D bin/relayserver /out/relayserver

14 + make build-server && install -D bin/relay-server /out/relay-server

16 # Stage 3: Minimal runtime image

17 FROM gcr.io/distroless/static-debian12:nonroot

19 -COPY --from=builder /out/relayserver /usr/bin/relayserver

19 +COPY --from=builder /out/relay-server /usr/bin/relay-server

21 EXPOSE 4017

23 -ENTRYPOINT ["/usr/bin/relayserver"]

23 +ENTRYPOINT ["/usr/bin/relay-server"]

Makefile

+19 -10

@@ -3,30 +3,39 @@ SHELL := /bin/sh

3 .PHONY: build build-wasm build-server clean

5 # Convenience target: build wasm then server

6 -build: build-wasm build-server

6 +build: build-protoc build-wasm build-server

7 +

8 +build-protoc:

9 + protoc -I . \

10 + --go_out=. \

11 + --go_opt=paths=source_relative \

12 + --go-vtproto_out=. \

13 + --go-vtproto_opt=paths=source_relative \

14 + portal/core/proto/rdsec/rdsec.proto \

15 + portal/core/proto/rdverb/rdverb.proto

17 # Build WASM artifacts and copy to both embed dir and SDK dir (no external scripts)

18 build-wasm:

19 @echo "[wasm] building with wasm-pack..."

11 - cd relaydns/wasm && wasm-pack build --target web --out-dir pkg

20 + cd portal/wasm && wasm-pack build --target web --out-dir pkg

21 @echo "[wasm] copying WASM artifacts to embed dirs..."

22 mkdir -p cmd/relay-server/wasm

23 rm -rf cmd/relay-server/wasm/* sdk/wasm/*

15 - cp -R relaydns/wasm/pkg/. cmd/relay-server/wasm/

24 + cp -R portal/wasm/pkg/. cmd/relay-server/wasm/

25 @echo "[wasm] copying service workers and E2EE proxy files..."

17 - cp relaydns/wasm/sw-proxy.js cmd/relay-server/wasm/

18 - cp relaydns/wasm/sw.js cmd/relay-server/wasm/

26 + cp portal/wasm/sw-proxy.js cmd/relay-server/wasm/

27 + cp portal/wasm/sw.js cmd/relay-server/wasm/

28 @echo "[wasm] copying SecureWebSocket E2EE files..."

20 - cp relaydns/wasm/secure-websocket.js cmd/relay-server/wasm/

21 - cp relaydns/wasm/secure-websocket-sw.js cmd/relay-server/wasm/

29 + cp portal/wasm/secure-websocket.js cmd/relay-server/wasm/

30 + cp portal/wasm/secure-websocket-sw.js cmd/relay-server/wasm/

32 # Build Go relay server (embeds WASM from cmd/relay-server/wasm)

33 build-server:

25 - @echo "[server] building Go relayserver..."

26 - CGO_ENABLED=0 go build -trimpath -ldflags "-s -w" -o bin/relayserver ./cmd/relay-server

34 + @echo "[server] building Go portal..."

35 + CGO_ENABLED=0 go build -trimpath -ldflags "-s -w" -o bin/relay-server ./cmd/relay-server

37 clean:

38 rm -rf bin

39 rm -rf cmd/relay-server/wasm

40 rm -rf sdk/wasm

32 - rm -rf relaydns/wasm/pkg

41 + rm -rf portal/wasm/pkg

README.md

+12 -98

@@ -1,8 +1,8 @@

1 -# RelayDNS

1 +# Portal

3 > Run Locally, Publish Everywhere!

5 -RelayDNS is a secure, encrypted relay service that enables end-to-end encrypted communication between clients through a central relay server. It provides mutual authentication, forward secrecy, and secure connection management with cryptographic identity verification.

5 +Portal(Publicly Open Relay To Access Localhost) is a secure, encrypted relay service that enables end-to-end encrypted communication between clients through a central relay server. It provides mutual authentication, forward secrecy, and secure connection management with cryptographic identity verification.

7 ## Table of Contents

@@ -20,7 +20,7 @@ RelayDNS is a secure, encrypted relay service that enables end-to-end encrypted

21 ## Overview

23 -RelayDNS implements a secure relay protocol that allows clients to register leases and establish encrypted connections through a central server. The system uses modern cryptographic primitives to ensure:

23 +Portal implements a secure relay protocol that allows clients to register leases and establish encrypted connections through a central server. The system uses modern cryptographic primitives to ensure:

25 - **End-to-end encryption**: All communication is encrypted using ChaCha20-Poly1305 AEAD

26 - **Mutual authentication**: Ed25519 signatures verify client identities

@@ -205,8 +205,8 @@ sequenceDiagram

205

206 ```bash

207 # Clone the repository

208 -git clone https://github.com/gosuda/relaydns.git

209 -cd relaydns

208 +git clone https://github.com/gosuda/portal.git

209 +cd portal

210

211 # Build WASM SDK (includes E2EE Proxy Service Worker)

212 make build-wasm

@@ -222,10 +222,10 @@ make build-server

222

223 ```bash

224 # Build with Docker (multi-stage build)

225 -docker build -t relaydns-server .

225 +docker build -t portal-server .

226

227 # Run server

228 -docker run -p 4017:4017 relaydns-server

228 +docker run -p 4017:4017 portal-server

229

230 # Access:

231 # - Admin UI: http://localhost:4017/

@@ -237,7 +237,7 @@ See [DOCKER_BUILD_VERIFICATION.md](DOCKER_BUILD_VERIFICATION.md) for detailed bu

237

238 ### Browser E2EE Proxy (Automatic)

239

240 -The simplest way to use RelayDNS is through the browser E2EE Proxy:

240 +The simplest way to use Portal is through the browser E2EE Proxy:

241

242 ```javascript

243 // 1. Open the E2EE Proxy test page

@@ -257,14 +257,14 @@ The Service Worker intercepts requests and automatically determines message type

257 - `application/octet-stream` → Binary type

258 - `text/*` → Text type

259

260 -See [E2EE_PROXY_DEPLOYMENT.md](E2EE_PROXY_DEPLOYMENT.md) for deployment guide and [relaydns/wasm/](relaydns/wasm/) for WASM SDK documentation.

260 +See [E2EE_PROXY_DEPLOYMENT.md](E2EE_PROXY_DEPLOYMENT.md) for deployment guide and [portal/wasm/](portal/wasm/) for WASM SDK documentation.

261

262 ### WASM SDK (JavaScript/Browser)

263

264 For direct WASM usage without Service Worker:

265

266 ```javascript

267 -import init, { RelayClient } from '/pkg/relaydns_wasm.js';

267 +import init, { RelayClient } from '/pkg/portal_wasm.js';

268

269 // Initialize WASM

270 await init();

@@ -280,7 +280,7 @@ const info = await client.getRelayInfo();

280 console.log('Active leases:', info.leases);

281 ```

282

283 -See [relaydns/wasm/USAGE.md](relaydns/wasm/USAGE.md) for complete WASM SDK documentation.

283 +See [portal/wasm/USAGE.md](portal/wasm/USAGE.md) for complete WASM SDK documentation.

284

285 ### Server Setup

286

@@ -302,7 +302,7 @@ cd cmd/relay-server

302 package main

303

304 import (

305 - "github.com/gosuda/relaydns/sdk"

305 + "github.com/gosuda/portal/sdk"

306 )

307

308 func main() {

@@ -402,92 +402,6 @@ End-to-end encrypted messages use the following format:

402 +-------------------+-------------------+-------------------+-------------------+

403 ```

404

405 -## Development

406 -

407 -### Project Structure

408 -

409 -```

410 -relaydns/

411 -├── relaydns/ # Main package

412 -│ ├── client.go # Client implementation

413 -│ ├── relay.go # Server implementation

414 -│ ├── handlers.go # Request handlers

415 -│ ├── lease.go # Lease management

416 -│ ├── helper.go # Utility functions

417 -│ └── wasm/ # WASM SDK (Rust)

418 -│ ├── src/

419 -│ │ ├── proxy_engine.rs # E2EE Proxy engine

420 -│ │ ├── relay_client.rs # WebSocket client

421 -│ │ ├── crypto.rs # Ed25519 encryption

422 -│ │ └── adapters.rs # HTTP/WS adapters

423 -│ ├── sw-proxy.js # Service Worker (E2EE Proxy)

424 -│ └── sw.js # Service Worker (caching)

425 -│

426 -page

427 -├── relaydns/core/ # Core components

428 -│ ├── cryptoops/ # Cryptographic operations

429 -│ │ ├── handshaker.go # E2EE handshake

430 -│ │ ├── identity.go # Identity management

431 -│ │ └── sig.go # Signature operations

432 -│ └── proto/ # Protocol definitions

433 -│ ├── rdsec/ # Security protocol

434 -│ └── rdverb/ # Relay protocol

435 -├── relaydns/internal/ # Internal utilities

436 -│ ├── randpool/ # CSPRNG implementation

437 -│ └── wsstream/ # WebSocket stream adapter

438 -├── cmd/ # Executables

439 -│ ├── relay-server/ # Relay server

440 -│ │ ├── main.go

441 -│ │ ├── view.go # HTTP routes & embed

442 -│ │ └── wasm/ # Embedded WASM files

443 -│ └── demo-app/ # Demo application

444 -├── sdk/ # Client SDKs

445 -│ └── go/ # Go SDK

446 -└── Makefile # Build automation

447 -```

448 -

449 -### Building

450 -

451 -```bash

452 -# Build WASM SDK

453 -make build-wasm

454 -

455 -# Build relay server (with embedded WASM)

456 -make build-server

457 -

458 -# Build all

459 -make build

460 -

461 -# Run tests

462 -go test ./...

463 -

464 -# Generate protobuf files

465 -buf generate

466 -

467 -# Build Docker image (multi-stage: Rust → Go → Runtime)

468 -docker build -t relaydns-server .

469 -```

470 -

471 -See [relaydns/wasm/BUILDING.md](relaydns/wasm/BUILDING.md) for detailed WASM build instructions.

472 -

473 -### Testing

474 -

475 -```bash

476 -# Go unit tests

477 -go test ./relaydns/...

478 -

479 -# Go integration tests

480 -go test -tags=integration ./...

481 -

482 -# Go with coverage

483 -go test -cover ./...

484 -

485 -# WASM/Rust tests

486 -cd relaydns/wasm

487 -cargo test

488 -

489 -See [relaydns/wasm/INTEGRATION_TEST_GUIDE.md](relaydns/wasm/INTEGRATION_TEST_GUIDE.md) for detailed testing procedures.

490 -

405 ## Contributing

406

407 1. Fork the repository

cmd/demo-app/main.go

+4 -5

@@ -14,15 +14,15 @@ import (

14 "github.com/rs/zerolog/log"

15 "github.com/spf13/cobra"

17 - "github.com/gosuda/relaydns/sdk"

17 + "github.com/gosuda/portal/sdk"

18 )

20 //go:embed static

21 var staticFiles embed.FS

23 var rootCmd = &cobra.Command{

24 - Use: "relaydns-paint",

25 - Short: "RelayDNS collaborative paint (local HTTP backend + libp2p advertiser)",

24 + Use: "demo app",

25 + Short: "demo app using portal relay",

26 RunE: runPaint,

27 }

@@ -182,8 +182,7 @@ func runPaint(cmd *cobra.Command, args []string) error {

182 defer client.Close()

183

184 // 3) Register lease and obtain a net.Listener that accepts relayed connections

185 - alpns := []string{"paint"}

186 - listener, err := client.Listen(cred, flagName, alpns)

185 + listener, err := client.Listen(cred, flagName, []string{"http/1.1"})

186 if err != nil {

187 return fmt.Errorf("listen: %w", err)

188 }

cmd/demo-app/static/index.html

+2 -2

@@ -6,13 +6,13 @@

6 <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">

7 <meta name="apple-mobile-web-app-capable" content="yes">

8 <meta name="mobile-web-app-capable" content="yes">

9 - <title>RelayDNS Paint</title>

9 + <title>Demo App</title>

10 <link rel="stylesheet" href="style.css">

11 </head>

13 <body>

14 <div class="container">

15 - <h1>🎨 RelayDNS Collaborative Paint</h1>

15 + <h1>🎨 Demo App</h1>

17 <div class="toolbar">

18 <div class="mode-buttons">

cmd/relay-server/main.go

+4 -4

@@ -12,12 +12,12 @@ import (

12 "github.com/rs/zerolog/log"

13 "github.com/spf13/cobra"

15 - "github.com/gosuda/relaydns/relaydns"

16 - "github.com/gosuda/relaydns/sdk"

15 + "github.com/gosuda/portal/portal"

16 + "github.com/gosuda/portal/sdk"

17 )

19 var rootCmd = &cobra.Command{

20 - Use: "relayserver",

20 + Use: "portal",

21 Short: "A lightweight, DNS-driven peer-to-peer proxy",

22 RunE: runServer,

23 }

@@ -48,7 +48,7 @@ func runServer(cmd *cobra.Command, args []string) error {

49 cred := sdk.NewCredential()

51 - serv := relaydns.NewRelayServer(cred, flagBootstraps)

51 + serv := portal.NewRelayServer(cred, flagBootstraps)

52 serv.Start()

53 defer serv.Stop()

cmd/relay-server/view.go

+8 -8

@@ -17,20 +17,20 @@ import (

17 "github.com/gorilla/websocket"

18 "github.com/rs/zerolog/log"

20 - "github.com/gosuda/relaydns/relaydns"

21 - "github.com/gosuda/relaydns/relaydns/utils/wsstream"

22 - "github.com/gosuda/relaydns/sdk"

20 + "github.com/gosuda/portal/portal"

21 + "github.com/gosuda/portal/portal/utils/wsstream"

22 + "github.com/gosuda/portal/sdk"

23 )

25 // serveHTTP builds the HTTP mux and returns the server.

26 -func serveHTTP(_ context.Context, addr string, serv *relaydns.RelayServer, nodeID string, bootstraps []string, cancel context.CancelFunc) *http.Server {

26 +func serveHTTP(_ context.Context, addr string, serv *portal.RelayServer, nodeID string, bootstraps []string, cancel context.CancelFunc) *http.Server {

27 if addr == "" {

28 addr = ":0"

29 }

31 mux := http.NewServeMux()

33 - // Per-peer HTTP reverse proxy over RelayDNS

33 + // Per-peer HTTP reverse proxy over Portal

34 // Route: /peer/{leaseID}/*

35 var (

36 proxyClient *sdk.RDClient

@@ -232,7 +232,7 @@ type adminPageData struct {

232 }

233

234 // convertLeaseEntriesToRows converts LeaseEntry data from LeaseManager to leaseRow format for the admin page

235 -func convertLeaseEntriesToRows(serv *relaydns.RelayServer) []leaseRow {

235 +func convertLeaseEntriesToRows(serv *portal.RelayServer) []leaseRow {

236 // Get all lease entries directly from the lease manager

237 leaseEntries := serv.GetAllLeaseEntries()

238

@@ -323,7 +323,7 @@ var serverTmpl = template.Must(template.New("admin-index").Parse(`<!doctype html

323 <head>

324 <meta charset="utf-8"/>

325 <meta name="viewport" content="width=device-width, initial-scale=1" />

326 - <title>RelayDNS Admin</title>

326 + <title>Portal Admin</title>

327 <style>

328 * { box-sizing: border-box }

329 :root {

@@ -352,7 +352,7 @@ var serverTmpl = template.Must(template.New("admin-index").Parse(`<!doctype html

352 <body>

353 <div class="wrap">

354 <header>

355 - <div class="brand">RelayDNS</div>

355 + <div class="brand">Portal</div>

356 <div class="status">Admin</div>

357 </header>

358 <main>

cmd/relay-server/wasm/README.md

+14 -14

@@ -1,6 +1,6 @@

1 -# RelayDNS WASM SDK

1 +# Portal WASM SDK

3 -WebAssembly SDK for RelayDNS with **mandatory End-to-End Encryption (E2EE) Proxy** functionality.

3 +WebAssembly SDK for Portal with **mandatory End-to-End Encryption (E2EE) Proxy** functionality.

5 ## Overview

@@ -57,7 +57,7 @@ make build-wasm

58 **Manual Build:**

59 ```bash

60 -cd relaydns/wasm

60 +cd portal/wasm

62 # Build WASM module

63 wasm-pack build --target web --release

@@ -84,10 +84,10 @@ go build -o relay-server

85 ```bash

86 # From repository root

87 -docker build -t relaydns-server .

87 +docker build -t portal-server .

89 # Run

90 -docker run -p 4017:4017 relaydns-server

90 +docker run -p 4017:4017 portal-server

91 ```

93 The Dockerfile uses multi-stage builds:

@@ -101,10 +101,10 @@ After building, the following files are generated in `cmd/relay-server/wasm/`:

101

102 ```

103 cmd/relay-server/wasm/

104 -├── relaydns_wasm.js # WASM JavaScript bindings

105 -├── relaydns_wasm_bg.wasm # WASM binary (465KB)

106 -├── relaydns_wasm_sw.js # Service Worker bindings

107 -├── relaydns_wasm.d.ts # TypeScript definitions

104 +├── portal_wasm.js # WASM JavaScript bindings

105 +├── portal_wasm_bg.wasm # WASM binary (465KB)

106 +├── portal_wasm_sw.js # Service Worker bindings

107 +├── portal_wasm.d.ts # TypeScript definitions

108 ├── sw-proxy.js # E2EE Proxy Service Worker (ESSENTIAL)

109 └── sw.js # Basic caching Service Worker

110 ```

@@ -138,7 +138,7 @@ fetch('https://api.github.com/zen')

138 ### For Developers (JavaScript)

139

140 ```javascript

141 -import init, { RelayClient } from '/pkg/relaydns_wasm.js';

141 +import init, { RelayClient } from '/pkg/portal_wasm.js';

142

143 // Initialize WASM

144 await init();

@@ -171,7 +171,7 @@ See [Go SDK Documentation](../../sdk/)

171

172 ```bash

173 # Unit tests

174 -cd relaydns/wasm

174 +cd portal/wasm

175 cargo test

176

177 # Integration tests

@@ -208,7 +208,7 @@ Service Worker automatically determines message type:

208

209 ```bash

210 # Rebuild and deploy

211 -cd relaydns/wasm

211 +cd portal/wasm

212 ./deploy-server.sh

213 cd ../../cmd/relay-server

214 go build -o relay-server

@@ -218,8 +218,8 @@ go build -o relay-server

218

219 ```bash

220 # Check files are served correctly

221 -curl http://localhost:4017/pkg/relaydns_wasm.js

222 -curl http://localhost:4017/pkg/relaydns_wasm_bg.wasm

221 +curl http://localhost:4017/pkg/portal_wasm.js

222 +curl http://localhost:4017/pkg/portal_wasm_bg.wasm

223 curl http://localhost:4017/sw-proxy.js

224 ```

225

cmd/relay-server/wasm/package.json

+8 -8

@@ -1,19 +1,19 @@

1 {

2 - "name": "relaydns-wasm",

2 + "name": "portal-wasm",

3 "type": "module",

4 "collaborators": [

5 - "RelayDNS Contributors"

5 + "Portal Contributors"

6 ],

7 - "description": "WebAssembly client for RelayDNS",

7 + "description": "WebAssembly client for Portal",

8 "version": "0.1.0",

9 "license": "MIT OR Apache-2.0",

10 "files": [

11 - "relaydns_wasm_bg.wasm",

12 - "relaydns_wasm.js",

13 - "relaydns_wasm.d.ts"

11 + "portal_wasm_bg.wasm",

12 + "portal_wasm.js",

13 + "portal_wasm.d.ts"

14 ],

15 - "main": "relaydns_wasm.js",

16 - "types": "relaydns_wasm.d.ts",

15 + "main": "portal_wasm.js",

16 + "types": "portal_wasm.d.ts",

17 "sideEffects": [

18 "./snippets/*"

19 ]

cmd/relay-server/wasm/relaydns_wasm.d.ts deleted

-220

@@ -1,220 +0,0 @@

1 -/* tslint:disable */

2 -/* eslint-disable */

3 -/**

4 - * Initialize WASM module

5 - */

6 -export function init(): void;

7 -/**

8 - * Data interpreter for converting relay protocol to browser-friendly format

9 - */

10 -export class DataInterpreter {

11 - private constructor();

12 - free(): void;

13 - [Symbol.dispose](): void;

14 - /**

15 - * Parse relay protocol packet to browser message

16 - */

17 - static parsePacket(data: Uint8Array): any;

18 - /**

19 - * Create relay protocol packet from browser message

20 - */

21 - static createPacket(msg: any): Uint8Array;

22 -}

23 -/**

24 - * HTTP Adapter for file and API transfers

25 - */

26 -export class HttpAdapter {

27 - free(): void;

28 - [Symbol.dispose](): void;

29 - constructor(base_url: string);

30 - /**

31 - * Send GET request

32 - */

33 - get(path: string): Promise<any>;

34 - /**

35 - * Send POST request with JSON body

36 - */

37 - postJson(path: string, body: any): Promise<any>;

38 - /**

39 - * Upload file

40 - */

41 - uploadFile(path: string, file_name: string, file_data: Uint8Array): Promise<any>;

42 - /**

43 - * Download file

44 - */

45 - downloadFile(path: string): Promise<Uint8Array>;

46 -}

47 -/**

48 - * Main proxy engine that handles all intercepted requests

49 - */

50 -export class ProxyEngine {

51 - free(): void;

52 - [Symbol.dispose](): void;

53 - /**

54 - * Create a new proxy engine

55 - */

56 - constructor(server_url: string);

57 - /**

58 - * Check if a URL should be intercepted

59 - */

60 - shouldIntercept(url: string): boolean;

61 - /**

62 - * Handle HTTP request

63 - */

64 - handleHttpRequest(method: string, url: string, headers: any, body?: Uint8Array | null): Promise<any>;

65 - /**

66 - * Open WebSocket connection through tunnel

67 - */

68 - openWebSocket(url: string, protocols: string[]): Promise<any>;

69 - /**

70 - * Send WebSocket message

71 - */

72 - sendWebSocketMessage(tunnel_id: string, data: any, is_binary: boolean): Promise<void>;

73 - /**

74 - * Receive WebSocket message

75 - */

76 - receiveWebSocketMessage(tunnel_id: string): Promise<any>;

77 - /**

78 - * Close WebSocket

79 - */

80 - closeWebSocket(tunnel_id: string, code: number, reason: string): Promise<void>;

81 - /**

82 - * Connect to TCP server

83 - */

84 - connectTcp(host: string, port: number): Promise<any>;

85 - /**

86 - * Get status information

87 - */

88 - getStatus(): any;

89 -}

90 -export class RelayClient {

91 - private constructor();

92 - free(): void;

93 - [Symbol.dispose](): void;

94 - /**

95 - * Connect to RelayDNS server

96 - */

97 - static connect(server_url: string): Promise<RelayClient>;

98 - /**

99 - * Get relay server information

100 - */

101 - getRelayInfo(): Promise<any>;

102 - /**

103 - * Register a lease

104 - */

105 - registerLease(name: string, alpns: string[]): Promise<void>;

106 - /**

107 - * Get client credential ID

108 - */

109 - getCredentialId(): string;

110 - /**

111 - * Request connection to another peer

112 - */

113 - requestConnection(lease_id: string, _alpn: string): Promise<any>;

114 -}

115 -/**

116 - * WebSocket Data Adapter for browser

117 - */

118 -export class WebSocketAdapter {

119 - free(): void;

120 - [Symbol.dispose](): void;

121 - constructor(url: string);

122 - /**

123 - * Connect to WebSocket

124 - */

125 - connect(): Promise<void>;

126 - /**

127 - * Set message callback

128 - */

129 - onMessage(callback: Function): void;

130 - /**

131 - * Set error callback

132 - */

133 - onError(callback: Function): void;

134 - /**

135 - * Send text message

136 - */

137 - sendText(message: string): void;

138 - /**

139 - * Send binary message

140 - */

141 - sendBinary(data: Uint8Array): void;

142 - /**

143 - * Close connection

144 - */

145 - close(): void;

146 -}

147 -

148 -export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;

149 -

150 -export interface InitOutput {

151 - readonly memory: WebAssembly.Memory;

152 - readonly __wbg_httpadapter_free: (a: number, b: number) => void;

153 - readonly httpadapter_new: (a: number, b: number) => number;

154 - readonly httpadapter_get: (a: number, b: number, c: number) => any;

155 - readonly httpadapter_postJson: (a: number, b: number, c: number, d: any) => any;

156 - readonly httpadapter_uploadFile: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;

157 - readonly httpadapter_downloadFile: (a: number, b: number, c: number) => any;

158 - readonly __wbg_websocketadapter_free: (a: number, b: number) => void;

159 - readonly websocketadapter_new: (a: number, b: number) => number;

160 - readonly websocketadapter_connect: (a: number) => any;

161 - readonly websocketadapter_onMessage: (a: number, b: any) => void;

162 - readonly websocketadapter_onError: (a: number, b: any) => void;

163 - readonly websocketadapter_sendText: (a: number, b: number, c: number) => [number, number];

164 - readonly websocketadapter_sendBinary: (a: number, b: number, c: number) => [number, number];

165 - readonly websocketadapter_close: (a: number) => [number, number];

166 - readonly __wbg_datainterpreter_free: (a: number, b: number) => void;

167 - readonly datainterpreter_parsePacket: (a: number, b: number) => [number, number, number];

168 - readonly datainterpreter_createPacket: (a: any) => [number, number, number, number];

169 - readonly __wbg_proxyengine_free: (a: number, b: number) => void;

170 - readonly proxyengine_new: (a: number, b: number) => number;

171 - readonly proxyengine_shouldIntercept: (a: number, b: number, c: number) => number;

172 - readonly proxyengine_handleHttpRequest: (a: number, b: number, c: number, d: number, e: number, f: any, g: number, h: number) => any;

173 - readonly proxyengine_openWebSocket: (a: number, b: number, c: number, d: number, e: number) => any;

174 - readonly proxyengine_sendWebSocketMessage: (a: number, b: number, c: number, d: any, e: number) => any;

175 - readonly proxyengine_receiveWebSocketMessage: (a: number, b: number, c: number) => any;

176 - readonly proxyengine_closeWebSocket: (a: number, b: number, c: number, d: number, e: number, f: number) => any;

177 - readonly proxyengine_connectTcp: (a: number, b: number, c: number, d: number) => any;

178 - readonly proxyengine_getStatus: (a: number) => any;

179 - readonly __wbg_relayclient_free: (a: number, b: number) => void;

180 - readonly relayclient_connect: (a: number, b: number) => any;

181 - readonly relayclient_getRelayInfo: (a: number) => any;

182 - readonly relayclient_registerLease: (a: number, b: number, c: number, d: number, e: number) => any;

183 - readonly relayclient_getCredentialId: (a: number) => [number, number];

184 - readonly relayclient_requestConnection: (a: number, b: number, c: number, d: number, e: number) => any;

185 - readonly init: () => void;

186 - readonly wasm_bindgen__convert__closures_____invoke__h75a085a52d492ff4: (a: number, b: number, c: any) => void;

187 - readonly wasm_bindgen__closure__destroy__h2dcad6e62f01cec1: (a: number, b: number) => void;

188 - readonly wasm_bindgen__convert__closures_____invoke__hed2088bf6dd2c621: (a: number, b: number, c: any) => void;

189 - readonly wasm_bindgen__closure__destroy__h8eb17c158a55b496: (a: number, b: number) => void;

190 - readonly wasm_bindgen__convert__closures_____invoke__h404cda7fa36c69a6: (a: number, b: number, c: any, d: any) => void;

191 - readonly __wbindgen_malloc: (a: number, b: number) => number;

192 - readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

193 - readonly __wbindgen_exn_store: (a: number) => void;

194 - readonly __externref_table_alloc: () => number;

195 - readonly __wbindgen_externrefs: WebAssembly.Table;

196 - readonly __wbindgen_free: (a: number, b: number, c: number) => void;

197 - readonly __externref_table_dealloc: (a: number) => void;

198 - readonly __wbindgen_start: () => void;

199 -}

200 -

201 -export type SyncInitInput = BufferSource | WebAssembly.Module;

202 -/**

203 -* Instantiates the given `module`, which can either be bytes or

204 -* a precompiled `WebAssembly.Module`.

205 -*

206 -* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.

207 -*

208 -* @returns {InitOutput}

209 -*/

210 -export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;

211 -

212 -/**

213 -* If `module_or_path` is {RequestInfo} or {URL}, makes a request and

214 -* for everything else, calls `WebAssembly.instantiate` directly.

215 -*

216 -* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.

217 -*

218 -* @returns {Promise<InitOutput>}

219 -*/

220 -export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

cmd/relay-server/wasm/relaydns_wasm.js deleted

-1334

@@ -1,1334 +0,0 @@

1 -let wasm;

2 -

3 -let cachedUint8ArrayMemory0 = null;

4 -

5 -function getUint8ArrayMemory0() {

6 - if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {

7 - cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);

8 - }

9 - return cachedUint8ArrayMemory0;

10 -}

11 -

12 -let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

13 -

14 -cachedTextDecoder.decode();

15 -

16 -const MAX_SAFARI_DECODE_BYTES = 2146435072;

17 -let numBytesDecoded = 0;

18 -function decodeText(ptr, len) {

19 - numBytesDecoded += len;

20 - if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {

21 - cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

22 - cachedTextDecoder.decode();

23 - numBytesDecoded = len;

24 - }

25 - return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));

26 -}

27 -

28 -function getStringFromWasm0(ptr, len) {

29 - ptr = ptr >>> 0;

30 - return decodeText(ptr, len);

31 -}

32 -

33 -let WASM_VECTOR_LEN = 0;

34 -

35 -const cachedTextEncoder = new TextEncoder();

36 -

37 -if (!('encodeInto' in cachedTextEncoder)) {

38 - cachedTextEncoder.encodeInto = function (arg, view) {

39 - const buf = cachedTextEncoder.encode(arg);

40 - view.set(buf);

41 - return {

42 - read: arg.length,

43 - written: buf.length

44 - };

45 - }

46 -}

47 -

48 -function passStringToWasm0(arg, malloc, realloc) {

49 -

50 - if (realloc === undefined) {

51 - const buf = cachedTextEncoder.encode(arg);

52 - const ptr = malloc(buf.length, 1) >>> 0;

53 - getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);

54 - WASM_VECTOR_LEN = buf.length;

55 - return ptr;

56 - }

57 -

58 - let len = arg.length;

59 - let ptr = malloc(len, 1) >>> 0;

60 -

61 - const mem = getUint8ArrayMemory0();

62 -

63 - let offset = 0;

64 -

65 - for (; offset < len; offset++) {

66 - const code = arg.charCodeAt(offset);

67 - if (code > 0x7F) break;

68 - mem[ptr + offset] = code;

69 - }

70 -

71 - if (offset !== len) {

72 - if (offset !== 0) {

73 - arg = arg.slice(offset);

74 - }

75 - ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;

76 - const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);

77 - const ret = cachedTextEncoder.encodeInto(arg, view);

78 -

79 - offset += ret.written;

80 - ptr = realloc(ptr, len, offset, 1) >>> 0;

81 - }

82 -

83 - WASM_VECTOR_LEN = offset;

84 - return ptr;

85 -}

86 -

87 -let cachedDataViewMemory0 = null;

88 -

89 -function getDataViewMemory0() {

90 - if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {

91 - cachedDataViewMemory0 = new DataView(wasm.memory.buffer);

92 - }

93 - return cachedDataViewMemory0;

94 -}

95 -

96 -function isLikeNone(x) {

97 - return x === undefined || x === null;

98 -}

99 -

100 -function debugString(val) {

101 - // primitive types

102 - const type = typeof val;

103 - if (type == 'number' || type == 'boolean' || val == null) {

104 - return `${val}`;

105 - }

106 - if (type == 'string') {

107 - return `"${val}"`;

108 - }

109 - if (type == 'symbol') {

110 - const description = val.description;

111 - if (description == null) {

112 - return 'Symbol';

113 - } else {

114 - return `Symbol(${description})`;

115 - }

116 - }

117 - if (type == 'function') {

118 - const name = val.name;

119 - if (typeof name == 'string' && name.length > 0) {

120 - return `Function(${name})`;

121 - } else {

122 - return 'Function';

123 - }

124 - }

125 - // objects

126 - if (Array.isArray(val)) {

127 - const length = val.length;

128 - let debug = '[';

129 - if (length > 0) {

130 - debug += debugString(val[0]);

131 - }

132 - for(let i = 1; i < length; i++) {

133 - debug += ', ' + debugString(val[i]);

134 - }

135 - debug += ']';

136 - return debug;

137 - }

138 - // Test for built-in

139 - const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));

140 - let className;

141 - if (builtInMatches && builtInMatches.length > 1) {

142 - className = builtInMatches[1];

143 - } else {

144 - // Failed to match the standard '[object ClassName]'

145 - return toString.call(val);

146 - }

147 - if (className == 'Object') {

148 - // we're a user defined class or Object

149 - // JSON.stringify avoids problems with cycles, and is generally much

150 - // easier than looping through ownProperties of `val`.

151 - try {

152 - return 'Object(' + JSON.stringify(val) + ')';

153 - } catch (_) {

154 - return 'Object';

155 - }

156 - }

157 - // errors

158 - if (val instanceof Error) {

159 - return `${val.name}: ${val.message}\n${val.stack}`;

160 - }

161 - // TODO we could test for more things here, like `Set`s and `Map`s.

162 - return className;

163 -}

164 -

165 -function addToExternrefTable0(obj) {

166 - const idx = wasm.__externref_table_alloc();

167 - wasm.__wbindgen_externrefs.set(idx, obj);

168 - return idx;

169 -}

170 -

171 -function handleError(f, args) {

172 - try {

173 - return f.apply(this, args);

174 - } catch (e) {

175 - const idx = addToExternrefTable0(e);

176 - wasm.__wbindgen_exn_store(idx);

177 - }

178 -}

179 -

180 -function getArrayU8FromWasm0(ptr, len) {

181 - ptr = ptr >>> 0;

182 - return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);

183 -}

184 -

185 -const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')

186 - ? { register: () => {}, unregister: () => {} }

187 - : new FinalizationRegistry(state => state.dtor(state.a, state.b));

188 -

189 -function makeMutClosure(arg0, arg1, dtor, f) {

190 - const state = { a: arg0, b: arg1, cnt: 1, dtor };

191 - const real = (...args) => {

192 -

193 - // First up with a closure we increment the internal reference

194 - // count. This ensures that the Rust closure environment won't

195 - // be deallocated while we're invoking it.

196 - state.cnt++;

197 - const a = state.a;

198 - state.a = 0;

199 - try {

200 - return f(a, state.b, ...args);

201 - } finally {

202 - state.a = a;

203 - real._wbg_cb_unref();

204 - }

205 - };

206 - real._wbg_cb_unref = () => {

207 - if (--state.cnt === 0) {

208 - state.dtor(state.a, state.b);

209 - state.a = 0;

210 - CLOSURE_DTORS.unregister(state);

211 - }

212 - };

213 - CLOSURE_DTORS.register(real, state, state);

214 - return real;

215 -}

216 -

217 -function passArray8ToWasm0(arg, malloc) {

218 - const ptr = malloc(arg.length * 1, 1) >>> 0;

219 - getUint8ArrayMemory0().set(arg, ptr / 1);

220 - WASM_VECTOR_LEN = arg.length;

221 - return ptr;

222 -}

223 -

224 -function takeFromExternrefTable0(idx) {

225 - const value = wasm.__wbindgen_externrefs.get(idx);

226 - wasm.__externref_table_dealloc(idx);

227 - return value;

228 -}

229 -

230 -function passArrayJsValueToWasm0(array, malloc) {

231 - const ptr = malloc(array.length * 4, 4) >>> 0;

232 - for (let i = 0; i < array.length; i++) {

233 - const add = addToExternrefTable0(array[i]);

234 - getDataViewMemory0().setUint32(ptr + 4 * i, add, true);

235 - }

236 - WASM_VECTOR_LEN = array.length;

237 - return ptr;

238 -}

239 -/**

240 - * Initialize WASM module

241 - */

242 -export function init() {

243 - wasm.init();

244 -}

245 -

246 -function wasm_bindgen__convert__closures_____invoke__h75a085a52d492ff4(arg0, arg1, arg2) {

247 - wasm.wasm_bindgen__convert__closures_____invoke__h75a085a52d492ff4(arg0, arg1, arg2);

248 -}

249 -

250 -function wasm_bindgen__convert__closures_____invoke__hed2088bf6dd2c621(arg0, arg1, arg2) {

251 - wasm.wasm_bindgen__convert__closures_____invoke__hed2088bf6dd2c621(arg0, arg1, arg2);

252 -}

253 -

254 -function wasm_bindgen__convert__closures_____invoke__h404cda7fa36c69a6(arg0, arg1, arg2, arg3) {

255 - wasm.wasm_bindgen__convert__closures_____invoke__h404cda7fa36c69a6(arg0, arg1, arg2, arg3);

256 -}

257 -

258 -const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];

259 -

260 -const DataInterpreterFinalization = (typeof FinalizationRegistry === 'undefined')

261 - ? { register: () => {}, unregister: () => {} }

262 - : new FinalizationRegistry(ptr => wasm.__wbg_datainterpreter_free(ptr >>> 0, 1));

263 -/**

264 - * Data interpreter for converting relay protocol to browser-friendly format

265 - */

266 -export class DataInterpreter {

267 -

268 - __destroy_into_raw() {

269 - const ptr = this.__wbg_ptr;

270 - this.__wbg_ptr = 0;

271 - DataInterpreterFinalization.unregister(this);

272 - return ptr;

273 - }

274 -

275 - free() {

276 - const ptr = this.__destroy_into_raw();

277 - wasm.__wbg_datainterpreter_free(ptr, 0);

278 - }

279 - /**

280 - * Parse relay protocol packet to browser message

281 - * @param {Uint8Array} data

282 - * @returns {any}

283 - */

284 - static parsePacket(data) {

285 - const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);

286 - const len0 = WASM_VECTOR_LEN;

287 - const ret = wasm.datainterpreter_parsePacket(ptr0, len0);

288 - if (ret[2]) {

289 - throw takeFromExternrefTable0(ret[1]);

290 - }

291 - return takeFromExternrefTable0(ret[0]);

292 - }

293 - /**

294 - * Create relay protocol packet from browser message

295 - * @param {any} msg

296 - * @returns {Uint8Array}

297 - */

298 - static createPacket(msg) {

299 - const ret = wasm.datainterpreter_createPacket(msg);

300 - if (ret[3]) {

301 - throw takeFromExternrefTable0(ret[2]);

302 - }

303 - var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();

304 - wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);

305 - return v1;

306 - }

307 -}

308 -if (Symbol.dispose) DataInterpreter.prototype[Symbol.dispose] = DataInterpreter.prototype.free;

309 -

310 -const HttpAdapterFinalization = (typeof FinalizationRegistry === 'undefined')

311 - ? { register: () => {}, unregister: () => {} }

312 - : new FinalizationRegistry(ptr => wasm.__wbg_httpadapter_free(ptr >>> 0, 1));

313 -/**

314 - * HTTP Adapter for file and API transfers

315 - */

316 -export class HttpAdapter {

317 -

318 - __destroy_into_raw() {

319 - const ptr = this.__wbg_ptr;

320 - this.__wbg_ptr = 0;

321 - HttpAdapterFinalization.unregister(this);

322 - return ptr;

323 - }

324 -

325 - free() {

326 - const ptr = this.__destroy_into_raw();

327 - wasm.__wbg_httpadapter_free(ptr, 0);

328 - }

329 - /**

330 - * @param {string} base_url

331 - */

332 - constructor(base_url) {

333 - const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

334 - const len0 = WASM_VECTOR_LEN;

335 - const ret = wasm.httpadapter_new(ptr0, len0);

336 - this.__wbg_ptr = ret >>> 0;

337 - HttpAdapterFinalization.register(this, this.__wbg_ptr, this);

338 - return this;

339 - }

340 - /**

341 - * Send GET request

342 - * @param {string} path

343 - * @returns {Promise<any>}

344 - */

345 - get(path) {

346 - const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

347 - const len0 = WASM_VECTOR_LEN;

348 - const ret = wasm.httpadapter_get(this.__wbg_ptr, ptr0, len0);

349 - return ret;

350 - }

351 - /**

352 - * Send POST request with JSON body

353 - * @param {string} path

354 - * @param {any} body

355 - * @returns {Promise<any>}

356 - */

357 - postJson(path, body) {

358 - const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

359 - const len0 = WASM_VECTOR_LEN;

360 - const ret = wasm.httpadapter_postJson(this.__wbg_ptr, ptr0, len0, body);

361 - return ret;

362 - }

363 - /**

364 - * Upload file

365 - * @param {string} path

366 - * @param {string} file_name

367 - * @param {Uint8Array} file_data

368 - * @returns {Promise<any>}

369 - */

370 - uploadFile(path, file_name, file_data) {

371 - const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

372 - const len0 = WASM_VECTOR_LEN;

373 - const ptr1 = passStringToWasm0(file_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

374 - const len1 = WASM_VECTOR_LEN;

375 - const ptr2 = passArray8ToWasm0(file_data, wasm.__wbindgen_malloc);

376 - const len2 = WASM_VECTOR_LEN;

377 - const ret = wasm.httpadapter_uploadFile(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);

378 - return ret;

379 - }

380 - /**

381 - * Download file

382 - * @param {string} path

383 - * @returns {Promise<Uint8Array>}

384 - */

385 - downloadFile(path) {

386 - const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

387 - const len0 = WASM_VECTOR_LEN;

388 - const ret = wasm.httpadapter_downloadFile(this.__wbg_ptr, ptr0, len0);

389 - return ret;

390 - }

391 -}

392 -if (Symbol.dispose) HttpAdapter.prototype[Symbol.dispose] = HttpAdapter.prototype.free;

393 -

394 -const ProxyEngineFinalization = (typeof FinalizationRegistry === 'undefined')

395 - ? { register: () => {}, unregister: () => {} }

396 - : new FinalizationRegistry(ptr => wasm.__wbg_proxyengine_free(ptr >>> 0, 1));

397 -/**

398 - * Main proxy engine that handles all intercepted requests

399 - */

400 -export class ProxyEngine {

401 -

402 - __destroy_into_raw() {

403 - const ptr = this.__wbg_ptr;

404 - this.__wbg_ptr = 0;

405 - ProxyEngineFinalization.unregister(this);

406 - return ptr;

407 - }

408 -

409 - free() {

410 - const ptr = this.__destroy_into_raw();

411 - wasm.__wbg_proxyengine_free(ptr, 0);

412 - }

413 - /**

414 - * Create a new proxy engine

415 - * @param {string} server_url

416 - */

417 - constructor(server_url) {

418 - const ptr0 = passStringToWasm0(server_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

419 - const len0 = WASM_VECTOR_LEN;

420 - const ret = wasm.proxyengine_new(ptr0, len0);

421 - this.__wbg_ptr = ret >>> 0;

422 - ProxyEngineFinalization.register(this, this.__wbg_ptr, this);

423 - return this;

424 - }

425 - /**

426 - * Check if a URL should be intercepted

427 - * @param {string} url

428 - * @returns {boolean}

429 - */

430 - shouldIntercept(url) {

431 - const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

432 - const len0 = WASM_VECTOR_LEN;

433 - const ret = wasm.proxyengine_shouldIntercept(this.__wbg_ptr, ptr0, len0);

434 - return ret !== 0;

435 - }

436 - /**

437 - * Handle HTTP request

438 - * @param {string} method

439 - * @param {string} url

440 - * @param {any} headers

441 - * @param {Uint8Array | null} [body]

442 - * @returns {Promise<any>}

443 - */

444 - handleHttpRequest(method, url, headers, body) {

445 - const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

446 - const len0 = WASM_VECTOR_LEN;

447 - const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

448 - const len1 = WASM_VECTOR_LEN;

449 - var ptr2 = isLikeNone(body) ? 0 : passArray8ToWasm0(body, wasm.__wbindgen_malloc);

450 - var len2 = WASM_VECTOR_LEN;

451 - const ret = wasm.proxyengine_handleHttpRequest(this.__wbg_ptr, ptr0, len0, ptr1, len1, headers, ptr2, len2);

452 - return ret;

453 - }

454 - /**

455 - * Open WebSocket connection through tunnel

456 - * @param {string} url

457 - * @param {string[]} protocols

458 - * @returns {Promise<any>}

459 - */

460 - openWebSocket(url, protocols) {

461 - const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

462 - const len0 = WASM_VECTOR_LEN;

463 - const ptr1 = passArrayJsValueToWasm0(protocols, wasm.__wbindgen_malloc);

464 - const len1 = WASM_VECTOR_LEN;

465 - const ret = wasm.proxyengine_openWebSocket(this.__wbg_ptr, ptr0, len0, ptr1, len1);

466 - return ret;

467 - }

468 - /**

469 - * Send WebSocket message

470 - * @param {string} tunnel_id

471 - * @param {any} data

472 - * @param {boolean} is_binary

473 - * @returns {Promise<void>}

474 - */

475 - sendWebSocketMessage(tunnel_id, data, is_binary) {

476 - const ptr0 = passStringToWasm0(tunnel_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

477 - const len0 = WASM_VECTOR_LEN;

478 - const ret = wasm.proxyengine_sendWebSocketMessage(this.__wbg_ptr, ptr0, len0, data, is_binary);

479 - return ret;

480 - }

481 - /**

482 - * Receive WebSocket message

483 - * @param {string} tunnel_id

484 - * @returns {Promise<any>}

485 - */

486 - receiveWebSocketMessage(tunnel_id) {

487 - const ptr0 = passStringToWasm0(tunnel_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

488 - const len0 = WASM_VECTOR_LEN;

489 - const ret = wasm.proxyengine_receiveWebSocketMessage(this.__wbg_ptr, ptr0, len0);

490 - return ret;

491 - }

492 - /**

493 - * Close WebSocket

494 - * @param {string} tunnel_id

495 - * @param {number} code

496 - * @param {string} reason

497 - * @returns {Promise<void>}

498 - */

499 - closeWebSocket(tunnel_id, code, reason) {

500 - const ptr0 = passStringToWasm0(tunnel_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

501 - const len0 = WASM_VECTOR_LEN;

502 - const ptr1 = passStringToWasm0(reason, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

503 - const len1 = WASM_VECTOR_LEN;

504 - const ret = wasm.proxyengine_closeWebSocket(this.__wbg_ptr, ptr0, len0, code, ptr1, len1);

505 - return ret;

506 - }

507 - /**

508 - * Connect to TCP server

509 - * @param {string} host

510 - * @param {number} port

511 - * @returns {Promise<any>}

512 - */

513 - connectTcp(host, port) {

514 - const ptr0 = passStringToWasm0(host, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

515 - const len0 = WASM_VECTOR_LEN;

516 - const ret = wasm.proxyengine_connectTcp(this.__wbg_ptr, ptr0, len0, port);

517 - return ret;

518 - }

519 - /**

520 - * Get status information

521 - * @returns {any}

522 - */

523 - getStatus() {

524 - const ret = wasm.proxyengine_getStatus(this.__wbg_ptr);

525 - return ret;

526 - }

527 -}

528 -if (Symbol.dispose) ProxyEngine.prototype[Symbol.dispose] = ProxyEngine.prototype.free;

529 -

530 -const RelayClientFinalization = (typeof FinalizationRegistry === 'undefined')

531 - ? { register: () => {}, unregister: () => {} }

532 - : new FinalizationRegistry(ptr => wasm.__wbg_relayclient_free(ptr >>> 0, 1));

533 -

534 -export class RelayClient {

535 -

536 - static __wrap(ptr) {

537 - ptr = ptr >>> 0;

538 - const obj = Object.create(RelayClient.prototype);

539 - obj.__wbg_ptr = ptr;

540 - RelayClientFinalization.register(obj, obj.__wbg_ptr, obj);

541 - return obj;

542 - }

543 -

544 - __destroy_into_raw() {

545 - const ptr = this.__wbg_ptr;

546 - this.__wbg_ptr = 0;

547 - RelayClientFinalization.unregister(this);

548 - return ptr;

549 - }

550 -

551 - free() {

552 - const ptr = this.__destroy_into_raw();

553 - wasm.__wbg_relayclient_free(ptr, 0);

554 - }

555 - /**

556 - * Connect to RelayDNS server

557 - * @param {string} server_url

558 - * @returns {Promise<RelayClient>}

559 - */

560 - static connect(server_url) {

561 - const ptr0 = passStringToWasm0(server_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

562 - const len0 = WASM_VECTOR_LEN;

563 - const ret = wasm.relayclient_connect(ptr0, len0);

564 - return ret;

565 - }

566 - /**

567 - * Get relay server information

568 - * @returns {Promise<any>}

569 - */

570 - getRelayInfo() {

571 - const ret = wasm.relayclient_getRelayInfo(this.__wbg_ptr);

572 - return ret;

573 - }

574 - /**

575 - * Register a lease

576 - * @param {string} name

577 - * @param {string[]} alpns

578 - * @returns {Promise<void>}

579 - */

580 - registerLease(name, alpns) {

581 - const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

582 - const len0 = WASM_VECTOR_LEN;

583 - const ptr1 = passArrayJsValueToWasm0(alpns, wasm.__wbindgen_malloc);

584 - const len1 = WASM_VECTOR_LEN;

585 - const ret = wasm.relayclient_registerLease(this.__wbg_ptr, ptr0, len0, ptr1, len1);

586 - return ret;

587 - }

588 - /**

589 - * Get client credential ID

590 - * @returns {string}

591 - */

592 - getCredentialId() {

593 - let deferred1_0;

594 - let deferred1_1;

595 - try {

596 - const ret = wasm.relayclient_getCredentialId(this.__wbg_ptr);

597 - deferred1_0 = ret[0];

598 - deferred1_1 = ret[1];

599 - return getStringFromWasm0(ret[0], ret[1]);

600 - } finally {

601 - wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);

602 - }

603 - }

604 - /**

605 - * Request connection to another peer

606 - * @param {string} lease_id

607 - * @param {string} _alpn

608 - * @returns {Promise<any>}

609 - */

610 - requestConnection(lease_id, _alpn) {

611 - const ptr0 = passStringToWasm0(lease_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

612 - const len0 = WASM_VECTOR_LEN;

613 - const ptr1 = passStringToWasm0(_alpn, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

614 - const len1 = WASM_VECTOR_LEN;

615 - const ret = wasm.relayclient_requestConnection(this.__wbg_ptr, ptr0, len0, ptr1, len1);

616 - return ret;

617 - }

618 -}

619 -if (Symbol.dispose) RelayClient.prototype[Symbol.dispose] = RelayClient.prototype.free;

620 -

621 -const WebSocketAdapterFinalization = (typeof FinalizationRegistry === 'undefined')

622 - ? { register: () => {}, unregister: () => {} }

623 - : new FinalizationRegistry(ptr => wasm.__wbg_websocketadapter_free(ptr >>> 0, 1));

624 -/**

625 - * WebSocket Data Adapter for browser

626 - */

627 -export class WebSocketAdapter {

628 -

629 - __destroy_into_raw() {

630 - const ptr = this.__wbg_ptr;

631 - this.__wbg_ptr = 0;

632 - WebSocketAdapterFinalization.unregister(this);

633 - return ptr;

634 - }

635 -

636 - free() {

637 - const ptr = this.__destroy_into_raw();

638 - wasm.__wbg_websocketadapter_free(ptr, 0);

639 - }

640 - /**

641 - * @param {string} url

642 - */

643 - constructor(url) {

644 - const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

645 - const len0 = WASM_VECTOR_LEN;

646 - const ret = wasm.websocketadapter_new(ptr0, len0);

647 - this.__wbg_ptr = ret >>> 0;

648 - WebSocketAdapterFinalization.register(this, this.__wbg_ptr, this);

649 - return this;

650 - }

651 - /**

652 - * Connect to WebSocket

653 - * @returns {Promise<void>}

654 - */

655 - connect() {

656 - const ret = wasm.websocketadapter_connect(this.__wbg_ptr);

657 - return ret;

658 - }

659 - /**

660 - * Set message callback

661 - * @param {Function} callback

662 - */

663 - onMessage(callback) {

664 - wasm.websocketadapter_onMessage(this.__wbg_ptr, callback);

665 - }

666 - /**

667 - * Set error callback

668 - * @param {Function} callback

669 - */

670 - onError(callback) {

671 - wasm.websocketadapter_onError(this.__wbg_ptr, callback);

672 - }

673 - /**

674 - * Send text message

675 - * @param {string} message

676 - */

677 - sendText(message) {

678 - const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

679 - const len0 = WASM_VECTOR_LEN;

680 - const ret = wasm.websocketadapter_sendText(this.__wbg_ptr, ptr0, len0);

681 - if (ret[1]) {

682 - throw takeFromExternrefTable0(ret[0]);

683 - }

684 - }

685 - /**

686 - * Send binary message

687 - * @param {Uint8Array} data

688 - */

689 - sendBinary(data) {

690 - const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);

691 - const len0 = WASM_VECTOR_LEN;

692 - const ret = wasm.websocketadapter_sendBinary(this.__wbg_ptr, ptr0, len0);

693 - if (ret[1]) {

694 - throw takeFromExternrefTable0(ret[0]);

695 - }

696 - }

697 - /**

698 - * Close connection

699 - */

700 - close() {

701 - const ret = wasm.websocketadapter_close(this.__wbg_ptr);

702 - if (ret[1]) {

703 - throw takeFromExternrefTable0(ret[0]);

704 - }

705 - }

706 -}

707 -if (Symbol.dispose) WebSocketAdapter.prototype[Symbol.dispose] = WebSocketAdapter.prototype.free;

708 -

709 -const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);

710 -

711 -async function __wbg_load(module, imports) {

712 - if (typeof Response === 'function' && module instanceof Response) {

713 - if (typeof WebAssembly.instantiateStreaming === 'function') {

714 - try {

715 - return await WebAssembly.instantiateStreaming(module, imports);

716 -

717 - } catch (e) {

718 - const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);

719 -

720 - if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {

721 - console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);

722 -

723 - } else {

724 - throw e;

725 - }

726 - }

727 - }

728 -

729 - const bytes = await module.arrayBuffer();

730 - return await WebAssembly.instantiate(bytes, imports);

731 -

732 - } else {

733 - const instance = await WebAssembly.instantiate(module, imports);

734 -

735 - if (instance instanceof WebAssembly.Instance) {

736 - return { instance, module };

737 -

738 - } else {

739 - return instance;

740 - }

741 - }

742 -}

743 -

744 -function __wbg_get_imports() {

745 - const imports = {};

746 - imports.wbg = {};

747 - imports.wbg.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {

748 - const ret = Error(getStringFromWasm0(arg0, arg1));

749 - return ret;

750 - };

751 - imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {

752 - const ret = String(arg1);

753 - const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

754 - const len1 = WASM_VECTOR_LEN;

755 - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

756 - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

757 - };

758 - imports.wbg.__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd = function(arg0, arg1) {

759 - const v = arg1;

760 - const ret = typeof(v) === 'bigint' ? v : undefined;

761 - getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);

762 - getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);

763 - };

764 - imports.wbg.__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68 = function(arg0) {

765 - const v = arg0;

766 - const ret = typeof(v) === 'boolean' ? v : undefined;

767 - return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;

768 - };

769 - imports.wbg.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {

770 - const ret = debugString(arg1);

771 - const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

772 - const len1 = WASM_VECTOR_LEN;

773 - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

774 - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

775 - };

776 - imports.wbg.__wbg___wbindgen_in_bb933bd9e1b3bc0f = function(arg0, arg1) {

777 - const ret = arg0 in arg1;

778 - return ret;

779 - };

780 - imports.wbg.__wbg___wbindgen_is_bigint_cb320707dcd35f0b = function(arg0) {

781 - const ret = typeof(arg0) === 'bigint';

782 - return ret;

783 - };

784 - imports.wbg.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {

785 - const ret = typeof(arg0) === 'function';

786 - return ret;

787 - };

788 - imports.wbg.__wbg___wbindgen_is_object_c818261d21f283a4 = function(arg0) {

789 - const val = arg0;

790 - const ret = typeof(val) === 'object' && val !== null;

791 - return ret;

792 - };

793 - imports.wbg.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {

794 - const ret = typeof(arg0) === 'string';

795 - return ret;

796 - };

797 - imports.wbg.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {

798 - const ret = arg0 === undefined;

799 - return ret;

800 - };

801 - imports.wbg.__wbg___wbindgen_jsval_eq_6b13ab83478b1c50 = function(arg0, arg1) {

802 - const ret = arg0 === arg1;

803 - return ret;

804 - };

805 - imports.wbg.__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147 = function(arg0, arg1) {

806 - const ret = arg0 == arg1;

807 - return ret;

808 - };

809 - imports.wbg.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {

810 - const obj = arg1;

811 - const ret = typeof(obj) === 'number' ? obj : undefined;

812 - getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);

813 - getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);

814 - };

815 - imports.wbg.__wbg___wbindgen_string_get_e4f06c90489ad01b = function(arg0, arg1) {

816 - const obj = arg1;

817 - const ret = typeof(obj) === 'string' ? obj : undefined;

818 - var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

819 - var len1 = WASM_VECTOR_LEN;

820 - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

821 - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

822 - };

823 - imports.wbg.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {

824 - throw new Error(getStringFromWasm0(arg0, arg1));

825 - };

826 - imports.wbg.__wbg__wbg_cb_unref_2454a539ea5790d9 = function(arg0) {

827 - arg0._wbg_cb_unref();

828 - };

829 - imports.wbg.__wbg_append_cb0bba4cf263a60b = function() { return handleError(function (arg0, arg1, arg2, arg3) {

830 - arg0.append(getStringFromWasm0(arg1, arg2), arg3);

831 - }, arguments) };

832 - imports.wbg.__wbg_arrayBuffer_b375eccb84b4ddf3 = function() { return handleError(function (arg0) {

833 - const ret = arg0.arrayBuffer();

834 - return ret;

835 - }, arguments) };

836 - imports.wbg.__wbg_bufferedAmount_3a2b17a4f88feac1 = function(arg0) {

837 - const ret = arg0.bufferedAmount;

838 - return ret;

839 - };

840 - imports.wbg.__wbg_call_525440f72fbfc0ea = function() { return handleError(function (arg0, arg1, arg2) {

841 - const ret = arg0.call(arg1, arg2);

842 - return ret;

843 - }, arguments) };

844 - imports.wbg.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {

845 - const ret = arg0.call(arg1);

846 - return ret;

847 - }, arguments) };

848 - imports.wbg.__wbg_close_885e277edf06b3fa = function() { return handleError(function (arg0) {

849 - arg0.close();

850 - }, arguments) };

851 - imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {

852 - const ret = arg0.crypto;

853 - return ret;

854 - };

855 - imports.wbg.__wbg_data_ee4306d069f24f2d = function(arg0) {

856 - const ret = arg0.data;

857 - return ret;

858 - };

859 - imports.wbg.__wbg_done_2042aa2670fb1db1 = function(arg0) {

860 - const ret = arg0.done;

861 - return ret;

862 - };

863 - imports.wbg.__wbg_entries_e171b586f8f6bdbf = function(arg0) {

864 - const ret = Object.entries(arg0);

865 - return ret;

866 - };

867 - imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {

868 - let deferred0_0;

869 - let deferred0_1;

870 - try {

871 - deferred0_0 = arg0;

872 - deferred0_1 = arg1;

873 - console.error(getStringFromWasm0(arg0, arg1));

874 - } finally {

875 - wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);

876 - }

877 - };

878 - imports.wbg.__wbg_fetch_0c645bcbfc592368 = function(arg0, arg1) {

879 - const ret = arg0.fetch(arg1);

880 - return ret;

881 - };

882 - imports.wbg.__wbg_fetch_cf02cfa16eaaaae8 = function(arg0, arg1, arg2) {

883 - const ret = arg0.fetch(getStringFromWasm0(arg1, arg2));

884 - return ret;

885 - };

886 - imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {

887 - arg0.getRandomValues(arg1);

888 - }, arguments) };

889 - imports.wbg.__wbg_get_7bed016f185add81 = function(arg0, arg1) {

890 - const ret = arg0[arg1 >>> 0];

891 - return ret;

892 - };

893 - imports.wbg.__wbg_get_efcb449f58ec27c2 = function() { return handleError(function (arg0, arg1) {

894 - const ret = Reflect.get(arg0, arg1);

895 - return ret;

896 - }, arguments) };

897 - imports.wbg.__wbg_headers_7ae6dbb1272f8fc6 = function(arg0) {

898 - const ret = arg0.headers;

899 - return ret;

900 - };

901 - imports.wbg.__wbg_instanceof_ArrayBuffer_70beb1189ca63b38 = function(arg0) {

902 - let result;

903 - try {

904 - result = arg0 instanceof ArrayBuffer;

905 - } catch (_) {

906 - result = false;

907 - }

908 - const ret = result;

909 - return ret;

910 - };

911 - imports.wbg.__wbg_instanceof_Map_8579b5e2ab5437c7 = function(arg0) {

912 - let result;

913 - try {

914 - result = arg0 instanceof Map;

915 - } catch (_) {

916 - result = false;

917 - }

918 - const ret = result;

919 - return ret;

920 - };

921 - imports.wbg.__wbg_instanceof_Response_f4f3e87e07f3135c = function(arg0) {

922 - let result;

923 - try {

924 - result = arg0 instanceof Response;

925 - } catch (_) {

926 - result = false;

927 - }

928 - const ret = result;

929 - return ret;

930 - };

931 - imports.wbg.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {

932 - let result;

933 - try {

934 - result = arg0 instanceof Uint8Array;

935 - } catch (_) {

936 - result = false;

937 - }

938 - const ret = result;

939 - return ret;

940 - };

941 - imports.wbg.__wbg_instanceof_Window_4846dbb3de56c84c = function(arg0) {

942 - let result;

943 - try {

944 - result = arg0 instanceof Window;

945 - } catch (_) {

946 - result = false;

947 - }

948 - const ret = result;

949 - return ret;

950 - };

951 - imports.wbg.__wbg_isArray_96e0af9891d0945d = function(arg0) {

952 - const ret = Array.isArray(arg0);

953 - return ret;

954 - };

955 - imports.wbg.__wbg_isSafeInteger_d216eda7911dde36 = function(arg0) {

956 - const ret = Number.isSafeInteger(arg0);

957 - return ret;

958 - };

959 - imports.wbg.__wbg_iterator_e5822695327a3c39 = function() {

960 - const ret = Symbol.iterator;

961 - return ret;

962 - };

963 - imports.wbg.__wbg_json_5d2ba74e315ef6e6 = function() { return handleError(function (arg0) {

964 - const ret = arg0.json();

965 - return ret;

966 - }, arguments) };

967 - imports.wbg.__wbg_length_69bca3cb64fc8748 = function(arg0) {

968 - const ret = arg0.length;

969 - return ret;

970 - };

971 - imports.wbg.__wbg_length_cdd215e10d9dd507 = function(arg0) {

972 - const ret = arg0.length;

973 - return ret;

974 - };

975 - imports.wbg.__wbg_log_4bad60e5c87e5201 = function(arg0, arg1) {

976 - console.log(getStringFromWasm0(arg0, arg1));

977 - };

978 - imports.wbg.__wbg_message_3abccea43568e0bd = function(arg0, arg1) {

979 - const ret = arg1.message;

980 - const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

981 - const len1 = WASM_VECTOR_LEN;

982 - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

983 - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

984 - };

985 - imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {

986 - const ret = arg0.msCrypto;

987 - return ret;

988 - };

989 - imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {

990 - const ret = new Object();

991 - return ret;

992 - };

993 - imports.wbg.__wbg_new_3c3d849046688a66 = function(arg0, arg1) {

994 - try {

995 - var state0 = {a: arg0, b: arg1};

996 - var cb0 = (arg0, arg1) => {

997 - const a = state0.a;

998 - state0.a = 0;

999 - try {

1000 - return wasm_bindgen__convert__closures_____invoke__h404cda7fa36c69a6(a, state0.b, arg0, arg1);

1001 - } finally {

1002 - state0.a = a;

1003 - }

1004 - };

1005 - const ret = new Promise(cb0);

1006 - return ret;

1007 - } finally {

1008 - state0.a = state0.b = 0;

1009 - }

1010 - };

1011 - imports.wbg.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {

1012 - const ret = new Uint8Array(arg0);

1013 - return ret;

1014 - };

1015 - imports.wbg.__wbg_new_68651c719dcda04e = function() {

1016 - const ret = new Map();

1017 - return ret;

1018 - };

1019 - imports.wbg.__wbg_new_6f694bb0585846e0 = function() { return handleError(function () {

1020 - const ret = new FormData();

1021 - return ret;

1022 - }, arguments) };

1023 - imports.wbg.__wbg_new_881c4fe631eee9ad = function() { return handleError(function (arg0, arg1) {

1024 - const ret = new WebSocket(getStringFromWasm0(arg0, arg1));

1025 - return ret;

1026 - }, arguments) };

1027 - imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {

1028 - const ret = new Error();

1029 - return ret;

1030 - };

1031 - imports.wbg.__wbg_new_9edf9838a2def39c = function() { return handleError(function () {

1032 - const ret = new Headers();

1033 - return ret;

1034 - }, arguments) };

1035 - imports.wbg.__wbg_new_e17d9f43105b08be = function() {

1036 - const ret = new Array();

1037 - return ret;

1038 - };

1039 - imports.wbg.__wbg_new_from_slice_92f4d78ca282a2d2 = function(arg0, arg1) {

1040 - const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));

1041 - return ret;

1042 - };

1043 - imports.wbg.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {

1044 - const ret = new Function(getStringFromWasm0(arg0, arg1));

1045 - return ret;

1046 - };

1047 - imports.wbg.__wbg_new_with_length_01aa0dc35aa13543 = function(arg0) {

1048 - const ret = new Uint8Array(arg0 >>> 0);

1049 - return ret;

1050 - };

1051 - imports.wbg.__wbg_new_with_str_and_init_0ae7728b6ec367b1 = function() { return handleError(function (arg0, arg1, arg2) {

1052 - const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);

1053 - return ret;

1054 - }, arguments) };

1055 - imports.wbg.__wbg_new_with_u8_array_sequence_3d2f552b86f4023e = function() { return handleError(function (arg0) {

1056 - const ret = new Blob(arg0);

1057 - return ret;

1058 - }, arguments) };

1059 - imports.wbg.__wbg_next_020810e0ae8ebcb0 = function() { return handleError(function (arg0) {

1060 - const ret = arg0.next();

1061 - return ret;

1062 - }, arguments) };

1063 - imports.wbg.__wbg_next_2c826fe5dfec6b6a = function(arg0) {

1064 - const ret = arg0.next;

1065 - return ret;

1066 - };

1067 - imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {

1068 - const ret = arg0.node;

1069 - return ret;

1070 - };

1071 - imports.wbg.__wbg_now_793306c526e2e3b6 = function() {

1072 - const ret = Date.now();

1073 - return ret;

1074 - };

1075 - imports.wbg.__wbg_of_035271b9e67a3bd9 = function(arg0) {

1076 - const ret = Array.of(arg0);

1077 - return ret;

1078 - };

1079 - imports.wbg.__wbg_ok_5749966cb2b8535e = function(arg0) {

1080 - const ret = arg0.ok;

1081 - return ret;

1082 - };

1083 - imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {

1084 - const ret = arg0.process;

1085 - return ret;

1086 - };

1087 - imports.wbg.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {

1088 - Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);

1089 - };

1090 - imports.wbg.__wbg_queueMicrotask_34d692c25c47d05b = function(arg0) {

1091 - const ret = arg0.queueMicrotask;

1092 - return ret;

1093 - };

1094 - imports.wbg.__wbg_queueMicrotask_9d76cacb20c84d58 = function(arg0) {

1095 - queueMicrotask(arg0);

1096 - };

1097 - imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {

1098 - arg0.randomFillSync(arg1);

1099 - }, arguments) };

1100 - imports.wbg.__wbg_relayclient_new = function(arg0) {

1101 - const ret = RelayClient.__wrap(arg0);

1102 - return ret;

1103 - };

1104 - imports.wbg.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {

1105 - const ret = module.require;

1106 - return ret;

1107 - }, arguments) };

1108 - imports.wbg.__wbg_resolve_caf97c30b83f7053 = function(arg0) {

1109 - const ret = Promise.resolve(arg0);

1110 - return ret;

1111 - };

1112 - imports.wbg.__wbg_send_171576d2f7487517 = function() { return handleError(function (arg0, arg1, arg2) {

1113 - arg0.send(getStringFromWasm0(arg1, arg2));

1114 - }, arguments) };

1115 - imports.wbg.__wbg_send_3d2cf376613294f0 = function() { return handleError(function (arg0, arg1, arg2) {

1116 - arg0.send(getArrayU8FromWasm0(arg1, arg2));

1117 - }, arguments) };

1118 - imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {

1119 - arg0[arg1] = arg2;

1120 - };

1121 - imports.wbg.__wbg_set_8b342d8cd9d2a02c = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {

1122 - arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));

1123 - }, arguments) };

1124 - imports.wbg.__wbg_set_907fb406c34a251d = function(arg0, arg1, arg2) {

1125 - const ret = arg0.set(arg1, arg2);

1126 - return ret;

1127 - };

1128 - imports.wbg.__wbg_set_binaryType_9d839cea8fcdc5c3 = function(arg0, arg1) {

1129 - arg0.binaryType = __wbindgen_enum_BinaryType[arg1];

1130 - };

1131 - imports.wbg.__wbg_set_body_3c365989753d61f4 = function(arg0, arg1) {

1132 - arg0.body = arg1;

1133 - };

1134 - imports.wbg.__wbg_set_c213c871859d6500 = function(arg0, arg1, arg2) {

1135 - arg0[arg1 >>> 0] = arg2;

1136 - };

1137 - imports.wbg.__wbg_set_c2abbebe8b9ebee1 = function() { return handleError(function (arg0, arg1, arg2) {

1138 - const ret = Reflect.set(arg0, arg1, arg2);

1139 - return ret;

1140 - }, arguments) };

1141 - imports.wbg.__wbg_set_method_c02d8cbbe204ac2d = function(arg0, arg1, arg2) {

1142 - arg0.method = getStringFromWasm0(arg1, arg2);

1143 - };

1144 - imports.wbg.__wbg_set_onclose_c09e4f7422de8dae = function(arg0, arg1) {

1145 - arg0.onclose = arg1;

1146 - };

1147 - imports.wbg.__wbg_set_onerror_337a3a2db9517378 = function(arg0, arg1) {

1148 - arg0.onerror = arg1;

1149 - };

1150 - imports.wbg.__wbg_set_onmessage_8661558551a89792 = function(arg0, arg1) {

1151 - arg0.onmessage = arg1;

1152 - };

1153 - imports.wbg.__wbg_set_onopen_efccb9305427b907 = function(arg0, arg1) {

1154 - arg0.onopen = arg1;

1155 - };

1156 - imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {

1157 - const ret = arg1.stack;

1158 - const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

1159 - const len1 = WASM_VECTOR_LEN;

1160 - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

1161 - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

1162 - };

1163 - imports.wbg.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {

1164 - const ret = typeof global === 'undefined' ? null : global;

1165 - return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

1166 - };

1167 - imports.wbg.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {

1168 - const ret = typeof globalThis === 'undefined' ? null : globalThis;

1169 - return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

1170 - };

1171 - imports.wbg.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {

1172 - const ret = typeof self === 'undefined' ? null : self;

1173 - return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

1174 - };

1175 - imports.wbg.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {

1176 - const ret = typeof window === 'undefined' ? null : window;

1177 - return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

1178 - };

1179 - imports.wbg.__wbg_status_de7eed5a7a5bfd5d = function(arg0) {

1180 - const ret = arg0.status;

1181 - return ret;

1182 - };

1183 - imports.wbg.__wbg_stringify_b5fb28f6465d9c3e = function() { return handleError(function (arg0) {

1184 - const ret = JSON.stringify(arg0);

1185 - return ret;

1186 - }, arguments) };

1187 - imports.wbg.__wbg_subarray_480600f3d6a9f26c = function(arg0, arg1, arg2) {

1188 - const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);

1189 - return ret;

1190 - };

1191 - imports.wbg.__wbg_then_4f46f6544e6b4a28 = function(arg0, arg1) {

1192 - const ret = arg0.then(arg1);

1193 - return ret;

1194 - };

1195 - imports.wbg.__wbg_then_70d05cf780a18d77 = function(arg0, arg1, arg2) {

1196 - const ret = arg0.then(arg1, arg2);

1197 - return ret;

1198 - };

1199 - imports.wbg.__wbg_value_692627309814bb8c = function(arg0) {

1200 - const ret = arg0.value;

1201 - return ret;

1202 - };

1203 - imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {

1204 - const ret = arg0.versions;

1205 - return ret;

1206 - };

1207 - imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {

1208 - // Cast intrinsic for `Ref(String) -> Externref`.

1209 - const ret = getStringFromWasm0(arg0, arg1);

1210 - return ret;

1211 - };

1212 - imports.wbg.__wbindgen_cast_3a4c91c0888a208b = function(arg0, arg1) {

1213 - // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.

1214 - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h2dcad6e62f01cec1, wasm_bindgen__convert__closures_____invoke__h75a085a52d492ff4);

1215 - return ret;

1216 - };

1217 - imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {

1218 - // Cast intrinsic for `U64 -> Externref`.

1219 - const ret = BigInt.asUintN(64, arg0);

1220 - return ret;

1221 - };

1222 - imports.wbg.__wbindgen_cast_46d6ccd6e2a13afa = function(arg0, arg1) {

1223 - // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.

1224 - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h2dcad6e62f01cec1, wasm_bindgen__convert__closures_____invoke__h75a085a52d492ff4);

1225 - return ret;

1226 - };

1227 - imports.wbg.__wbindgen_cast_77bc3e92745e9a35 = function(arg0, arg1) {

1228 - var v0 = getArrayU8FromWasm0(arg0, arg1).slice();

1229 - wasm.__wbindgen_free(arg0, arg1 * 1, 1);

1230 - // Cast intrinsic for `Vector(U8) -> Externref`.

1231 - const ret = v0;

1232 - return ret;

1233 - };

1234 - imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {

1235 - // Cast intrinsic for `I64 -> Externref`.

1236 - const ret = arg0;

1237 - return ret;

1238 - };

1239 - imports.wbg.__wbindgen_cast_a4bd8eb24f626613 = function(arg0, arg1) {

1240 - // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.

1241 - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h2dcad6e62f01cec1, wasm_bindgen__convert__closures_____invoke__h75a085a52d492ff4);

1242 - return ret;

1243 - };

1244 - imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {

1245 - // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.

1246 - const ret = getArrayU8FromWasm0(arg0, arg1);

1247 - return ret;

1248 - };

1249 - imports.wbg.__wbindgen_cast_d17062ab4b8c9928 = function(arg0, arg1) {

1250 - // Cast intrinsic for `Closure(Closure { dtor_idx: 253, function: Function { arguments: [Externref], shim_idx: 254, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.

1251 - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h8eb17c158a55b496, wasm_bindgen__convert__closures_____invoke__hed2088bf6dd2c621);

1252 - return ret;

1253 - };

1254 - imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {

1255 - // Cast intrinsic for `F64 -> Externref`.

1256 - const ret = arg0;

1257 - return ret;

1258 - };

1259 - imports.wbg.__wbindgen_init_externref_table = function() {

1260 - const table = wasm.__wbindgen_externrefs;

1261 - const offset = table.grow(4);

1262 - table.set(0, undefined);

1263 - table.set(offset + 0, undefined);

1264 - table.set(offset + 1, null);

1265 - table.set(offset + 2, true);

1266 - table.set(offset + 3, false);

1267 - ;

1268 - };

1269 -

1270 - return imports;

1271 -}

1272 -

1273 -function __wbg_finalize_init(instance, module) {

1274 - wasm = instance.exports;

1275 - __wbg_init.__wbindgen_wasm_module = module;

1276 - cachedDataViewMemory0 = null;

1277 - cachedUint8ArrayMemory0 = null;

1278 -

1279 -

1280 - wasm.__wbindgen_start();

1281 - return wasm;

1282 -}

1283 -

1284 -function initSync(module) {

1285 - if (wasm !== undefined) return wasm;

1286 -

1287 -

1288 - if (typeof module !== 'undefined') {

1289 - if (Object.getPrototypeOf(module) === Object.prototype) {

1290 - ({module} = module)

1291 - } else {

1292 - console.warn('using deprecated parameters for `initSync()`; pass a single object instead')

1293 - }

1294 - }

1295 -

1296 - const imports = __wbg_get_imports();

1297 -

1298 - if (!(module instanceof WebAssembly.Module)) {

1299 - module = new WebAssembly.Module(module);

1300 - }

1301 -

1302 - const instance = new WebAssembly.Instance(module, imports);

1303 -

1304 - return __wbg_finalize_init(instance, module);

1305 -}

1306 -

1307 -async function __wbg_init(module_or_path) {

1308 - if (wasm !== undefined) return wasm;

1309 -

1310 -

1311 - if (typeof module_or_path !== 'undefined') {

1312 - if (Object.getPrototypeOf(module_or_path) === Object.prototype) {

1313 - ({module_or_path} = module_or_path)

1314 - } else {

1315 - console.warn('using deprecated parameters for the initialization function; pass a single object instead')

1316 - }

1317 - }

1318 -

1319 - if (typeof module_or_path === 'undefined') {

1320 - module_or_path = new URL('relaydns_wasm_bg.wasm', import.meta.url);

1321 - }

1322 - const imports = __wbg_get_imports();

1323 -

1324 - if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {

1325 - module_or_path = fetch(module_or_path);

1326 - }

1327 -

1328 - const { instance, module } = await __wbg_load(await module_or_path, imports);

1329 -

1330 - return __wbg_finalize_init(instance, module);

1331 -}

1332 -

1333 -export { initSync };

1334 -export default __wbg_init;

cmd/relay-server/wasm/relaydns_wasm_bg.wasm

Binary files a/cmd/relay-server/wasm/relaydns_wasm_bg.wasm and /dev/null differ

cmd/relay-server/wasm/relaydns_wasm_bg.wasm.d.ts deleted

-50

@@ -1,50 +0,0 @@

1 -/* tslint:disable */

2 -/* eslint-disable */

3 -export const memory: WebAssembly.Memory;

4 -export const __wbg_httpadapter_free: (a: number, b: number) => void;

5 -export const httpadapter_new: (a: number, b: number) => number;

6 -export const httpadapter_get: (a: number, b: number, c: number) => any;

7 -export const httpadapter_postJson: (a: number, b: number, c: number, d: any) => any;

8 -export const httpadapter_uploadFile: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;

9 -export const httpadapter_downloadFile: (a: number, b: number, c: number) => any;

10 -export const __wbg_websocketadapter_free: (a: number, b: number) => void;

11 -export const websocketadapter_new: (a: number, b: number) => number;

12 -export const websocketadapter_connect: (a: number) => any;

13 -export const websocketadapter_onMessage: (a: number, b: any) => void;

14 -export const websocketadapter_onError: (a: number, b: any) => void;

15 -export const websocketadapter_sendText: (a: number, b: number, c: number) => [number, number];

16 -export const websocketadapter_sendBinary: (a: number, b: number, c: number) => [number, number];

17 -export const websocketadapter_close: (a: number) => [number, number];

18 -export const __wbg_datainterpreter_free: (a: number, b: number) => void;

19 -export const datainterpreter_parsePacket: (a: number, b: number) => [number, number, number];

20 -export const datainterpreter_createPacket: (a: any) => [number, number, number, number];

21 -export const __wbg_proxyengine_free: (a: number, b: number) => void;

22 -export const proxyengine_new: (a: number, b: number) => number;

23 -export const proxyengine_shouldIntercept: (a: number, b: number, c: number) => number;

24 -export const proxyengine_handleHttpRequest: (a: number, b: number, c: number, d: number, e: number, f: any, g: number, h: number) => any;

25 -export const proxyengine_openWebSocket: (a: number, b: number, c: number, d: number, e: number) => any;

26 -export const proxyengine_sendWebSocketMessage: (a: number, b: number, c: number, d: any, e: number) => any;

27 -export const proxyengine_receiveWebSocketMessage: (a: number, b: number, c: number) => any;

28 -export const proxyengine_closeWebSocket: (a: number, b: number, c: number, d: number, e: number, f: number) => any;

29 -export const proxyengine_connectTcp: (a: number, b: number, c: number, d: number) => any;

30 -export const proxyengine_getStatus: (a: number) => any;

31 -export const __wbg_relayclient_free: (a: number, b: number) => void;

32 -export const relayclient_connect: (a: number, b: number) => any;

33 -export const relayclient_getRelayInfo: (a: number) => any;

34 -export const relayclient_registerLease: (a: number, b: number, c: number, d: number, e: number) => any;

35 -export const relayclient_getCredentialId: (a: number) => [number, number];

36 -export const relayclient_requestConnection: (a: number, b: number, c: number, d: number, e: number) => any;

37 -export const init: () => void;

38 -export const wasm_bindgen__convert__closures_____invoke__h75a085a52d492ff4: (a: number, b: number, c: any) => void;

39 -export const wasm_bindgen__closure__destroy__h2dcad6e62f01cec1: (a: number, b: number) => void;

40 -export const wasm_bindgen__convert__closures_____invoke__hed2088bf6dd2c621: (a: number, b: number, c: any) => void;

41 -export const wasm_bindgen__closure__destroy__h8eb17c158a55b496: (a: number, b: number) => void;

42 -export const wasm_bindgen__convert__closures_____invoke__h404cda7fa36c69a6: (a: number, b: number, c: any, d: any) => void;

43 -export const __wbindgen_malloc: (a: number, b: number) => number;

44 -export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

45 -export const __wbindgen_exn_store: (a: number) => void;

46 -export const __externref_table_alloc: () => number;

47 -export const __wbindgen_externrefs: WebAssembly.Table;

48 -export const __wbindgen_free: (a: number, b: number, c: number) => void;

49 -export const __externref_table_dealloc: (a: number) => void;

50 -export const __wbindgen_start: () => void;

cmd/relay-server/wasm/secure-websocket.js

+10 -10

@@ -2,7 +2,7 @@

2 * SecureWebSocket - E2EE WebSocket Polyfill using WASM ProxyEngine

3 *

4 * Provides transparent end-to-end encryption for WebSocket connections

5 - * through the RelayDNS WASM ProxyEngine.

5 + * through the Portal WASM ProxyEngine.

6 */

8 // Global WASM instance cache

@@ -15,9 +15,9 @@ let wasmInitPromise = null;

15 */

16 async function getRelayUrl() {

17 // 1. Check if manually configured

18 - if (window.RELAYDNS_RELAY_URL) {

19 - console.log('[SecureWebSocket] Using configured relay URL:', window.RELAYDNS_RELAY_URL);

20 - return window.RELAYDNS_RELAY_URL;

18 + if (window.PORTAL_RELAY_URL) {

19 + console.log('[SecureWebSocket] Using configured relay URL:', window.PORTAL_RELAY_URL);

20 + return window.PORTAL_RELAY_URL;

21 }

23 // 2. Try to get from server API

@@ -102,11 +102,11 @@ async function getProxyEngine() {

102

103 // Load WASM module

104 if (typeof wasm_bindgen === 'undefined') {

105 - throw new Error('WASM module not loaded. Include relaydns_wasm.js first.');

105 + throw new Error('WASM module not loaded. Include portal_wasm.js first.');

106 }

107

108 // Initialize WASM

109 - await wasm_bindgen('/pkg/relaydns_wasm_bg.wasm');

109 + await wasm_bindgen('/pkg/portal_wasm_bg.wasm');

110

111 // Get relay server URL

112 const relayUrl = await getRelayUrl();

@@ -619,22 +619,22 @@ SecureWebSocket.CLOSED = 3;

619 // Configuration

620 const config = {

621 // Enable E2EE for all WebSockets by default

622 - enabled: window.RELAYDNS_E2EE_ENABLED !== false,

622 + enabled: window.PORTAL_E2EE_ENABLED !== false,

623

624 // Patterns to intercept (regex strings)

625 - interceptPatterns: window.RELAYDNS_INTERCEPT_PATTERNS || [

625 + interceptPatterns: window.PORTAL_INTERCEPT_PATTERNS || [

626 '.*' // Intercept all by default

627 ],

628

629 // Patterns to bypass (regex strings) - takes precedence

630 - bypassPatterns: window.RELAYDNS_BYPASS_PATTERNS || [

630 + bypassPatterns: window.PORTAL_BYPASS_PATTERNS || [

631 '^wss?://localhost:4017/', // Don't intercept relay server itself

632 '^wss?://localhost:8000/', // Don't intercept local dev server

633 '^wss?://127\\.0\\.0\\.1', // Don't intercept loopback

634 ],

635

636 // Debug mode

637 - debug: window.RELAYDNS_DEBUG || false

637 + debug: window.PORTAL_DEBUG || false

638 };

639

640 /**

cmd/relay-server/wasm/sw-proxy.js

+4 -4

@@ -1,7 +1,7 @@

1 -// Service Worker for RelayDNS Network Proxy

1 +// Service Worker for Portal Network Proxy

2 // WASM must be loaded during install phase

4 -const CACHE_NAME = 'relaydns-proxy-v1';

4 +const CACHE_NAME = 'portal-proxy-v1';

5 let proxyEngine = null;

6 let wasmReady = false;

7 let initializationPromise = null;

@@ -27,7 +27,7 @@ async function initializeProxyEngine() {

27 console.log('[SW-Proxy] wasm_bindgen not available, loading via dynamic import...');

29 // Use dynamic import for ES6 modules

30 - const wasmModule = await import('/pkg/relaydns_wasm.js');

30 + const wasmModule = await import('/pkg/portal_wasm.js');

32 // Make wasm_bindgen available globally

33 self.wasm_bindgen = wasmModule;

@@ -53,7 +53,7 @@ async function initializeProxyEngine() {

54 // wasm_bindgen is now the module object from dynamic import

55 const initWasm = self.wasm_bindgen.default || self.wasm_bindgen;

56 - await initWasm('/pkg/relaydns_wasm_bg.wasm');

56 + await initWasm('/pkg/portal_wasm_bg.wasm');

58 console.log('[SW-Proxy] ✓ WASM module initialized');

59 }

cmd/relay-server/wasm/sw.js

+5 -5

@@ -1,10 +1,10 @@

1 -// Service Worker for RelayDNS WASM Client

2 -const CACHE_NAME = 'relaydns-wasm-v1';

1 +// Service Worker for Portal WASM Client

2 +const CACHE_NAME = 'portal-wasm-v1';

4 // Files to cache

5 const urlsToCache = [

6 - '/pkg/relaydns_wasm.js',

7 - '/pkg/relaydns_wasm_bg.wasm',

6 + '/pkg/portal_wasm.js',

7 + '/pkg/portal_wasm_bg.wasm',

8 '/example.html',

9 '/adapter-test.html'

10 ];

@@ -77,7 +77,7 @@ self.addEventListener('fetch', (event) => {

77 );

78 }

79 // Handle JS files

80 - else if (url.pathname.endsWith('relaydns_wasm.js')) {

80 + else if (url.pathname.endsWith('portal_wasm.js')) {

81 event.respondWith(

82 caches.match(event.request)

83 .then((response) => {

cmd/webclient/index.html

+2 -2

@@ -2,10 +2,10 @@

2 <head>

3 <meta charset="UTF-8">

4 <meta name="viewport" content="width=device-width, initial-scale=1.0">

5 - <title>RelayDNS WebClient</title>

5 + <title>Portal WebClient</title>

6 </head>

7 <body>

8 - <h1>RelayDNS WebClient</h1>

8 + <h1>Portal WebClient</h1>

9 <hr/>

10 </body>

11 </html>

\ No newline at end of file

cmd/webclient/service-worker.js

+6 -6

@@ -37,9 +37,9 @@ async function runWASM() {

37 const { instance } = await WebAssembly.instantiate(wasm_file, go.importObject);

39 // go.run()은 Go의 main()을 실행하고,

40 - // _relaydns_http 콜백이 등록되면 리턴합니다.

40 + // _portal_http 콜백이 등록되면 리턴합니다.

41 go.run(instance);

42 - console.log("Service Worker: Go WASM 실행 완료. _relaydns_http가 준비되었습니다.");

42 + console.log("Service Worker: Go WASM 실행 완료. _portal_http가 준비되었습니다.");

43 }

45 /**

@@ -103,18 +103,18 @@ self.addEventListener('fetch', (event) => {

103 // WASM이 준비될 때까지 기다림

104 await getWasmReady();

105

106 - if (typeof _relaydns_http !== 'undefined') {

106 + if (typeof _portal_http !== 'undefined') {

107 // WASM이 준비되었고 핸들러 함수가 존재함

108 - const resp = await _relaydns_http(event.request);

108 + const resp = await _portal_http(event.request);

109 return resp;

110 } else {

111 // getWasmReady()가 성공했는데도 함수가 없는 비정상 상황

112 - console.error("Service Worker: WASM 로드는 성공했으나 _relaydns_http가 정의되지 않았습니다.");

112 + console.error("Service Worker: WASM 로드는 성공했으나 _portal_http가 정의되지 않았습니다.");

113 return new Response("WASM 핸들러를 사용할 수 없습니다.", { status: 500 });

114 }

115 } catch (err) {

116 // 1. getWasmReady() 실패 (WASM 로드/실행 실패)

117 - // 2. _relaydns_http(event.request) 실패 (Go 핸들러 내부 에러)

117 + // 2. _portal_http(event.request) 실패 (Go 핸들러 내부 에러)

118 console.error(`Service Worker: Go 핸들러 처리 실패 (네트워크로 폴백): ${err}`, event.request.url);

119

120 // WASM 핸들러 실패 시 네트워크로 폴백

docker-compose.yml

+1 -1

@@ -1,5 +1,5 @@

1 services:

2 - relayserver:

2 + portal:

3 build:

4 context: .

5 dockerfile: Dockerfile

go.mod

+1 -1

@@ -1,4 +1,4 @@

1 -module github.com/gosuda/relaydns

1 +module github.com/gosuda/portal

3 go 1.25.3

portal/client.go renamed

+4 -5

@@ -1,4 +1,4 @@

1 -package relaydns

1 +package portal

3 import (

4 "crypto/rand"

@@ -7,9 +7,9 @@ import (

7 "sync"

8 "time"

10 - "github.com/gosuda/relaydns/relaydns/core/cryptoops"

11 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

12 - "github.com/gosuda/relaydns/relaydns/core/proto/rdverb"

10 + "github.com/gosuda/portal/portal/core/cryptoops"

11 + "github.com/gosuda/portal/portal/core/proto/rdsec"

12 + "github.com/gosuda/portal/portal/core/proto/rdverb"

13 "github.com/hashicorp/yamux"

14 "github.com/rs/zerolog/log"

15 )

@@ -36,7 +36,6 @@ func (i *IncommingConn) RemoteID() string {

36 return i.SecureConnection.RemoteID()

37 }

39 -// RelayClient는 RelayServer에 연결하여 서비스를 요청하는 클라이언트입니다.

39 type RelayClient struct {

40 conn io.ReadWriteCloser

portal/core/cryptoops/README.md renamed

+2 -2

@@ -1,6 +1,6 @@

1 # Cryptographic Operations & End-to-End Encryption (E2EE)

3 -This package implements a secure, authenticated end-to-end encryption protocol for RelayDNS using modern cryptographic primitives and best practices.

3 +This package implements a secure, authenticated end-to-end encryption protocol for Portal using modern cryptographic primitives and best practices.

5 ## Table of Contents

@@ -383,7 +383,7 @@ func releaseBuffer(buffer *bytebufferpool.ByteBuffer) {

383 Cryptographically secure random numbers are critical:

384

385 ```go

386 -import "github.com/gosuda/relaydns/relaydns/internal/randpool"

386 +import "github.com/gosuda/portal/portal/internal/randpool"

387

388 // Generate random nonce

389 nonce := make([]byte, nonceSize)

portal/core/cryptoops/handshaker.go renamed

+2 -2

@@ -18,8 +18,8 @@ import (

18 "golang.org/x/crypto/hkdf"

19 "google.golang.org/protobuf/proto"

21 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

22 - "github.com/gosuda/relaydns/relaydns/utils/randpool"

21 + "github.com/gosuda/portal/portal/core/proto/rdsec"

22 + "github.com/gosuda/portal/portal/utils/randpool"

23 "github.com/valyala/bytebufferpool"

24 )

portal/core/cryptoops/handshaker_test.go renamed

+1 -1

@@ -9,7 +9,7 @@ import (

9 "testing"

10 "time"

12 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

12 + "github.com/gosuda/portal/portal/core/proto/rdsec"

13 "golang.org/x/crypto/curve25519"

14 )

portal/core/cryptoops/identity.go renamed

+1 -1

@@ -4,7 +4,7 @@ import (

4 "crypto/ed25519"

5 "errors"

7 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

7 + "github.com/gosuda/portal/portal/core/proto/rdsec"

8 )

10 func ValidateIdentity(identity *rdsec.Identity) bool {

portal/core/cryptoops/sig.go renamed

portal/core/proto/rdsec/rdsec.pb.go renamed

+42 -44

@@ -1,8 +1,8 @@

1 // Code generated by protoc-gen-go. DO NOT EDIT.

2 // versions:

3 // protoc-gen-go v1.36.10

4 -// protoc (unknown)

5 -// source: relaydns/core/proto/rdsec/rdsec.proto

4 +// protoc v3.21.12

5 +// source: portal/core/proto/rdsec/rdsec.proto

7 package rdsec

@@ -48,11 +48,11 @@ func (x ProtocolVersion) String() string {

48 }

50 func (ProtocolVersion) Descriptor() protoreflect.EnumDescriptor {

51 - return file_relaydns_core_proto_rdsec_rdsec_proto_enumTypes[0].Descriptor()

51 + return file_portal_core_proto_rdsec_rdsec_proto_enumTypes[0].Descriptor()

52 }

54 func (ProtocolVersion) Type() protoreflect.EnumType {

55 - return &file_relaydns_core_proto_rdsec_rdsec_proto_enumTypes[0]

55 + return &file_portal_core_proto_rdsec_rdsec_proto_enumTypes[0]

56 }

58 func (x ProtocolVersion) Number() protoreflect.EnumNumber {

@@ -61,7 +61,7 @@ func (x ProtocolVersion) Number() protoreflect.EnumNumber {

62 // Deprecated: Use ProtocolVersion.Descriptor instead.

63 func (ProtocolVersion) EnumDescriptor() ([]byte, []int) {

64 - return file_relaydns_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{0}

64 + return file_portal_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{0}

65 }

67 type Identity struct {

@@ -74,7 +74,7 @@ type Identity struct {

75 func (x *Identity) Reset() {

76 *x = Identity{}

77 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[0]

77 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[0]

78 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

79 ms.StoreMessageInfo(mi)

80 }

@@ -86,7 +86,7 @@ func (x *Identity) String() string {

86 func (*Identity) ProtoMessage() {}

88 func (x *Identity) ProtoReflect() protoreflect.Message {

89 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[0]

89 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[0]

90 if x != nil {

91 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

92 if ms.LoadMessageInfo() == nil {

@@ -99,7 +99,7 @@ func (x *Identity) ProtoReflect() protoreflect.Message {

100 // Deprecated: Use Identity.ProtoReflect.Descriptor instead.

101 func (*Identity) Descriptor() ([]byte, []int) {

102 - return file_relaydns_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{0}

102 + return file_portal_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{0}

103 }

104

105 func (x *Identity) GetId() string {

@@ -130,7 +130,7 @@ type ClientInitPayload struct {

130

131 func (x *ClientInitPayload) Reset() {

132 *x = ClientInitPayload{}

133 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[1]

133 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[1]

134 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

135 ms.StoreMessageInfo(mi)

136 }

@@ -142,7 +142,7 @@ func (x *ClientInitPayload) String() string {

142 func (*ClientInitPayload) ProtoMessage() {}

143

144 func (x *ClientInitPayload) ProtoReflect() protoreflect.Message {

145 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[1]

145 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[1]

146 if x != nil {

147 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

148 if ms.LoadMessageInfo() == nil {

@@ -155,7 +155,7 @@ func (x *ClientInitPayload) ProtoReflect() protoreflect.Message {

155

156 // Deprecated: Use ClientInitPayload.ProtoReflect.Descriptor instead.

157 func (*ClientInitPayload) Descriptor() ([]byte, []int) {

158 - return file_relaydns_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{1}

158 + return file_portal_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{1}

159 }

160

161 func (x *ClientInitPayload) GetVersion() ProtocolVersion {

@@ -210,7 +210,7 @@ type SignedPayload struct {

210

211 func (x *SignedPayload) Reset() {

212 *x = SignedPayload{}

213 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[2]

213 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[2]

214 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

215 ms.StoreMessageInfo(mi)

216 }

@@ -222,7 +222,7 @@ func (x *SignedPayload) String() string {

222 func (*SignedPayload) ProtoMessage() {}

223

224 func (x *SignedPayload) ProtoReflect() protoreflect.Message {

225 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[2]

225 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[2]

226 if x != nil {

227 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

228 if ms.LoadMessageInfo() == nil {

@@ -235,7 +235,7 @@ func (x *SignedPayload) ProtoReflect() protoreflect.Message {

235

236 // Deprecated: Use SignedPayload.ProtoReflect.Descriptor instead.

237 func (*SignedPayload) Descriptor() ([]byte, []int) {

238 - return file_relaydns_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{2}

238 + return file_portal_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{2}

239 }

240

241 func (x *SignedPayload) GetData() []byte {

@@ -266,7 +266,7 @@ type ServerInitPayload struct {

266

267 func (x *ServerInitPayload) Reset() {

268 *x = ServerInitPayload{}

269 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[3]

269 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[3]

270 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

271 ms.StoreMessageInfo(mi)

272 }

@@ -278,7 +278,7 @@ func (x *ServerInitPayload) String() string {

278 func (*ServerInitPayload) ProtoMessage() {}

279

280 func (x *ServerInitPayload) ProtoReflect() protoreflect.Message {

281 - mi := &file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes[3]

281 + mi := &file_portal_core_proto_rdsec_rdsec_proto_msgTypes[3]

282 if x != nil {

283 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

284 if ms.LoadMessageInfo() == nil {

@@ -291,7 +291,7 @@ func (x *ServerInitPayload) ProtoReflect() protoreflect.Message {

291

292 // Deprecated: Use ServerInitPayload.ProtoReflect.Descriptor instead.

293 func (*ServerInitPayload) Descriptor() ([]byte, []int) {

294 - return file_relaydns_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{3}

294 + return file_portal_core_proto_rdsec_rdsec_proto_rawDescGZIP(), []int{3}

295 }

296

297 func (x *ServerInitPayload) GetVersion() ProtocolVersion {

@@ -336,11 +336,11 @@ func (x *ServerInitPayload) GetSessionPublicKey() []byte {

336 return nil

337 }

338

339 -var File_relaydns_core_proto_rdsec_rdsec_proto protoreflect.FileDescriptor

339 +var File_portal_core_proto_rdsec_rdsec_proto protoreflect.FileDescriptor

340

341 -const file_relaydns_core_proto_rdsec_rdsec_proto_rawDesc = "" +

341 +const file_portal_core_proto_rdsec_rdsec_proto_rawDesc = "" +

342 "\n" +

343 - "%relaydns/core/proto/rdsec/rdsec.proto\x12\x05rdsec\"9\n" +

343 + "#portal/core/proto/rdsec/rdsec.proto\x12\x05rdsec\"9\n" +

344 "\bIdentity\x12\x0e\n" +

345 "\x02id\x18\x01 \x01(\tR\x02id\x12\x1d\n" +

346 "\n" +

@@ -363,32 +363,30 @@ const file_relaydns_core_proto_rdsec_rdsec_proto_rawDesc = "" +

363 "\x04alpn\x18\x05 \x01(\tR\x04alpn\x12,\n" +

364 "\x12session_public_key\x18\x06 \x01(\fR\x10sessionPublicKey*)\n" +

365 "\x0fProtocolVersion\x12\x16\n" +

366 - "\x12PROTOCOL_VERSION_1\x10\x00B\x87\x01\n" +

367 - "\tcom.rdsecB\n" +

368 - "RdsecProtoP\x01Z:github.com/gosuda/relaydns/relaydns/core/proto/rdsec;rdsec\xa2\x02\x03RXX\xaa\x02\x05Rdsec\xca\x02\x05Rdsec\xe2\x02\x11Rdsec\\GPBMetadata\xea\x02\x05Rdsecb\x06proto3"

366 + "\x12PROTOCOL_VERSION_1\x10\x00B8Z6github.com/gosuda/portal/portal/core/proto/rdsec;rdsecb\x06proto3"

367

368 var (

371 - file_relaydns_core_proto_rdsec_rdsec_proto_rawDescOnce sync.Once

372 - file_relaydns_core_proto_rdsec_rdsec_proto_rawDescData []byte

369 + file_portal_core_proto_rdsec_rdsec_proto_rawDescOnce sync.Once

370 + file_portal_core_proto_rdsec_rdsec_proto_rawDescData []byte

371 )

372

375 -func file_relaydns_core_proto_rdsec_rdsec_proto_rawDescGZIP() []byte {

376 - file_relaydns_core_proto_rdsec_rdsec_proto_rawDescOnce.Do(func() {

377 - file_relaydns_core_proto_rdsec_rdsec_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_relaydns_core_proto_rdsec_rdsec_proto_rawDesc), len(file_relaydns_core_proto_rdsec_rdsec_proto_rawDesc)))

373 +func file_portal_core_proto_rdsec_rdsec_proto_rawDescGZIP() []byte {

374 + file_portal_core_proto_rdsec_rdsec_proto_rawDescOnce.Do(func() {

375 + file_portal_core_proto_rdsec_rdsec_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_portal_core_proto_rdsec_rdsec_proto_rawDesc), len(file_portal_core_proto_rdsec_rdsec_proto_rawDesc)))

376 })

379 - return file_relaydns_core_proto_rdsec_rdsec_proto_rawDescData

377 + return file_portal_core_proto_rdsec_rdsec_proto_rawDescData

378 }

379

382 -var file_relaydns_core_proto_rdsec_rdsec_proto_enumTypes = make([]protoimpl.EnumInfo, 1)

383 -var file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes = make([]protoimpl.MessageInfo, 4)

384 -var file_relaydns_core_proto_rdsec_rdsec_proto_goTypes = []any{

380 +var file_portal_core_proto_rdsec_rdsec_proto_enumTypes = make([]protoimpl.EnumInfo, 1)

381 +var file_portal_core_proto_rdsec_rdsec_proto_msgTypes = make([]protoimpl.MessageInfo, 4)

382 +var file_portal_core_proto_rdsec_rdsec_proto_goTypes = []any{

383 (ProtocolVersion)(0), // 0: rdsec.ProtocolVersion

384 (*Identity)(nil), // 1: rdsec.Identity

385 (*ClientInitPayload)(nil), // 2: rdsec.ClientInitPayload

386 (*SignedPayload)(nil), // 3: rdsec.SignedPayload

387 (*ServerInitPayload)(nil), // 4: rdsec.ServerInitPayload

388 }

391 -var file_relaydns_core_proto_rdsec_rdsec_proto_depIdxs = []int32{

389 +var file_portal_core_proto_rdsec_rdsec_proto_depIdxs = []int32{

390 0, // 0: rdsec.ClientInitPayload.version:type_name -> rdsec.ProtocolVersion

391 1, // 1: rdsec.ClientInitPayload.identity:type_name -> rdsec.Identity

392 0, // 2: rdsec.ServerInitPayload.version:type_name -> rdsec.ProtocolVersion

@@ -400,27 +398,27 @@ var file_relaydns_core_proto_rdsec_rdsec_proto_depIdxs = []int32{

398 0, // [0:4] is the sub-list for field type_name

399 }

400

403 -func init() { file_relaydns_core_proto_rdsec_rdsec_proto_init() }

404 -func file_relaydns_core_proto_rdsec_rdsec_proto_init() {

405 - if File_relaydns_core_proto_rdsec_rdsec_proto != nil {

401 +func init() { file_portal_core_proto_rdsec_rdsec_proto_init() }

402 +func file_portal_core_proto_rdsec_rdsec_proto_init() {

403 + if File_portal_core_proto_rdsec_rdsec_proto != nil {

404 return

405 }

406 type x struct{}

407 out := protoimpl.TypeBuilder{

408 File: protoimpl.DescBuilder{

409 GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

412 - RawDescriptor: unsafe.Slice(unsafe.StringData(file_relaydns_core_proto_rdsec_rdsec_proto_rawDesc), len(file_relaydns_core_proto_rdsec_rdsec_proto_rawDesc)),

410 + RawDescriptor: unsafe.Slice(unsafe.StringData(file_portal_core_proto_rdsec_rdsec_proto_rawDesc), len(file_portal_core_proto_rdsec_rdsec_proto_rawDesc)),

411 NumEnums: 1,

412 NumMessages: 4,

413 NumExtensions: 0,

414 NumServices: 0,

415 },

418 - GoTypes: file_relaydns_core_proto_rdsec_rdsec_proto_goTypes,

419 - DependencyIndexes: file_relaydns_core_proto_rdsec_rdsec_proto_depIdxs,

420 - EnumInfos: file_relaydns_core_proto_rdsec_rdsec_proto_enumTypes,

421 - MessageInfos: file_relaydns_core_proto_rdsec_rdsec_proto_msgTypes,

416 + GoTypes: file_portal_core_proto_rdsec_rdsec_proto_goTypes,

417 + DependencyIndexes: file_portal_core_proto_rdsec_rdsec_proto_depIdxs,

418 + EnumInfos: file_portal_core_proto_rdsec_rdsec_proto_enumTypes,

419 + MessageInfos: file_portal_core_proto_rdsec_rdsec_proto_msgTypes,

420 }.Build()

423 - File_relaydns_core_proto_rdsec_rdsec_proto = out.File

424 - file_relaydns_core_proto_rdsec_rdsec_proto_goTypes = nil

425 - file_relaydns_core_proto_rdsec_rdsec_proto_depIdxs = nil

421 + File_portal_core_proto_rdsec_rdsec_proto = out.File

422 + file_portal_core_proto_rdsec_rdsec_proto_goTypes = nil

423 + file_portal_core_proto_rdsec_rdsec_proto_depIdxs = nil

424 }

portal/core/proto/rdsec/rdsec.proto renamed

+1 -1

@@ -2,7 +2,7 @@ syntax = "proto3";

3 package rdsec;

5 -option go_package = "github.com/gosuda/relaydns/relaydns/core/proto/rdsec;rdsec";

5 +option go_package = "github.com/gosuda/portal/portal/core/proto/rdsec;rdsec";

7 message Identity {

8 string id = 1;

portal/core/proto/rdsec/rdsec_vtproto.pb.go renamed

+1 -1

@@ -1,6 +1,6 @@

1 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.

2 // protoc-gen-go-vtproto version: v0.6.0

3 -// source: relaydns/core/proto/rdsec/rdsec.proto

3 +// source: portal/core/proto/rdsec/rdsec.proto

5 package rdsec

portal/core/proto/rdverb/rdverb.pb.go renamed

+67 -69

@@ -1,13 +1,13 @@

1 // Code generated by protoc-gen-go. DO NOT EDIT.

2 // versions:

3 // protoc-gen-go v1.36.10

4 -// protoc (unknown)

5 -// source: relaydns/core/proto/rdverb/rdverb.proto

4 +// protoc v3.21.12

5 +// source: portal/core/proto/rdverb/rdverb.proto

7 package rdverb

9 import (

10 - rdsec "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

10 + rdsec "github.com/gosuda/portal/portal/core/proto/rdsec"

11 protoreflect "google.golang.org/protobuf/reflect/protoreflect"

12 protoimpl "google.golang.org/protobuf/runtime/protoimpl"

13 reflect "reflect"

@@ -70,11 +70,11 @@ func (x PacketType) String() string {

70 }

72 func (PacketType) Descriptor() protoreflect.EnumDescriptor {

73 - return file_relaydns_core_proto_rdverb_rdverb_proto_enumTypes[0].Descriptor()

73 + return file_portal_core_proto_rdverb_rdverb_proto_enumTypes[0].Descriptor()

74 }

76 func (PacketType) Type() protoreflect.EnumType {

77 - return &file_relaydns_core_proto_rdverb_rdverb_proto_enumTypes[0]

77 + return &file_portal_core_proto_rdverb_rdverb_proto_enumTypes[0]

78 }

80 func (x PacketType) Number() protoreflect.EnumNumber {

@@ -83,7 +83,7 @@ func (x PacketType) Number() protoreflect.EnumNumber {

84 // Deprecated: Use PacketType.Descriptor instead.

85 func (PacketType) EnumDescriptor() ([]byte, []int) {

86 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{0}

86 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{0}

87 }

89 type ResponseCode int32

@@ -131,11 +131,11 @@ func (x ResponseCode) String() string {

131 }

132

133 func (ResponseCode) Descriptor() protoreflect.EnumDescriptor {

134 - return file_relaydns_core_proto_rdverb_rdverb_proto_enumTypes[1].Descriptor()

134 + return file_portal_core_proto_rdverb_rdverb_proto_enumTypes[1].Descriptor()

135 }

136

137 func (ResponseCode) Type() protoreflect.EnumType {

138 - return &file_relaydns_core_proto_rdverb_rdverb_proto_enumTypes[1]

138 + return &file_portal_core_proto_rdverb_rdverb_proto_enumTypes[1]

139 }

140

141 func (x ResponseCode) Number() protoreflect.EnumNumber {

@@ -144,7 +144,7 @@ func (x ResponseCode) Number() protoreflect.EnumNumber {

144

145 // Deprecated: Use ResponseCode.Descriptor instead.

146 func (ResponseCode) EnumDescriptor() ([]byte, []int) {

147 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{1}

147 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{1}

148 }

149

150 type Packet struct {

@@ -157,7 +157,7 @@ type Packet struct {

157

158 func (x *Packet) Reset() {

159 *x = Packet{}

160 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[0]

160 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[0]

161 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

162 ms.StoreMessageInfo(mi)

163 }

@@ -169,7 +169,7 @@ func (x *Packet) String() string {

169 func (*Packet) ProtoMessage() {}

170

171 func (x *Packet) ProtoReflect() protoreflect.Message {

172 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[0]

172 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[0]

173 if x != nil {

174 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

175 if ms.LoadMessageInfo() == nil {

@@ -182,7 +182,7 @@ func (x *Packet) ProtoReflect() protoreflect.Message {

182

183 // Deprecated: Use Packet.ProtoReflect.Descriptor instead.

184 func (*Packet) Descriptor() ([]byte, []int) {

185 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{0}

185 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{0}

186 }

187

188 func (x *Packet) GetType() PacketType {

@@ -210,7 +210,7 @@ type RelayInfo struct {

210

211 func (x *RelayInfo) Reset() {

212 *x = RelayInfo{}

213 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[1]

213 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[1]

214 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

215 ms.StoreMessageInfo(mi)

216 }

@@ -222,7 +222,7 @@ func (x *RelayInfo) String() string {

222 func (*RelayInfo) ProtoMessage() {}

223

224 func (x *RelayInfo) ProtoReflect() protoreflect.Message {

225 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[1]

225 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[1]

226 if x != nil {

227 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

228 if ms.LoadMessageInfo() == nil {

@@ -235,7 +235,7 @@ func (x *RelayInfo) ProtoReflect() protoreflect.Message {

235

236 // Deprecated: Use RelayInfo.ProtoReflect.Descriptor instead.

237 func (*RelayInfo) Descriptor() ([]byte, []int) {

238 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{1}

238 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{1}

239 }

240

241 func (x *RelayInfo) GetIdentity() *rdsec.Identity {

@@ -267,7 +267,7 @@ type RelayInfoRequest struct {

267

268 func (x *RelayInfoRequest) Reset() {

269 *x = RelayInfoRequest{}

270 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[2]

270 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[2]

271 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

272 ms.StoreMessageInfo(mi)

273 }

@@ -279,7 +279,7 @@ func (x *RelayInfoRequest) String() string {

279 func (*RelayInfoRequest) ProtoMessage() {}

280

281 func (x *RelayInfoRequest) ProtoReflect() protoreflect.Message {

282 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[2]

282 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[2]

283 if x != nil {

284 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

285 if ms.LoadMessageInfo() == nil {

@@ -292,7 +292,7 @@ func (x *RelayInfoRequest) ProtoReflect() protoreflect.Message {

292

293 // Deprecated: Use RelayInfoRequest.ProtoReflect.Descriptor instead.

294 func (*RelayInfoRequest) Descriptor() ([]byte, []int) {

295 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{2}

295 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{2}

296 }

297

298 type RelayInfoResponse struct {

@@ -304,7 +304,7 @@ type RelayInfoResponse struct {

304

305 func (x *RelayInfoResponse) Reset() {

306 *x = RelayInfoResponse{}

307 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[3]

307 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[3]

308 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

309 ms.StoreMessageInfo(mi)

310 }

@@ -316,7 +316,7 @@ func (x *RelayInfoResponse) String() string {

316 func (*RelayInfoResponse) ProtoMessage() {}

317

318 func (x *RelayInfoResponse) ProtoReflect() protoreflect.Message {

319 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[3]

319 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[3]

320 if x != nil {

321 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

322 if ms.LoadMessageInfo() == nil {

@@ -329,7 +329,7 @@ func (x *RelayInfoResponse) ProtoReflect() protoreflect.Message {

329

330 // Deprecated: Use RelayInfoResponse.ProtoReflect.Descriptor instead.

331 func (*RelayInfoResponse) Descriptor() ([]byte, []int) {

332 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{3}

332 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{3}

333 }

334

335 func (x *RelayInfoResponse) GetRelayInfo() *RelayInfo {

@@ -351,7 +351,7 @@ type Lease struct {

351

352 func (x *Lease) Reset() {

353 *x = Lease{}

354 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[4]

354 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[4]

355 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

356 ms.StoreMessageInfo(mi)

357 }

@@ -363,7 +363,7 @@ func (x *Lease) String() string {

363 func (*Lease) ProtoMessage() {}

364

365 func (x *Lease) ProtoReflect() protoreflect.Message {

366 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[4]

366 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[4]

367 if x != nil {

368 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

369 if ms.LoadMessageInfo() == nil {

@@ -376,7 +376,7 @@ func (x *Lease) ProtoReflect() protoreflect.Message {

376

377 // Deprecated: Use Lease.ProtoReflect.Descriptor instead.

378 func (*Lease) Descriptor() ([]byte, []int) {

379 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{4}

379 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{4}

380 }

381

382 func (x *Lease) GetIdentity() *rdsec.Identity {

@@ -418,7 +418,7 @@ type LeaseUpdateRequest struct {

418

419 func (x *LeaseUpdateRequest) Reset() {

420 *x = LeaseUpdateRequest{}

421 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[5]

421 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[5]

422 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

423 ms.StoreMessageInfo(mi)

424 }

@@ -430,7 +430,7 @@ func (x *LeaseUpdateRequest) String() string {

430 func (*LeaseUpdateRequest) ProtoMessage() {}

431

432 func (x *LeaseUpdateRequest) ProtoReflect() protoreflect.Message {

433 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[5]

433 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[5]

434 if x != nil {

435 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

436 if ms.LoadMessageInfo() == nil {

@@ -443,7 +443,7 @@ func (x *LeaseUpdateRequest) ProtoReflect() protoreflect.Message {

443

444 // Deprecated: Use LeaseUpdateRequest.ProtoReflect.Descriptor instead.

445 func (*LeaseUpdateRequest) Descriptor() ([]byte, []int) {

446 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{5}

446 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{5}

447 }

448

449 func (x *LeaseUpdateRequest) GetLease() *Lease {

@@ -476,7 +476,7 @@ type LeaseUpdateResponse struct {

476

477 func (x *LeaseUpdateResponse) Reset() {

478 *x = LeaseUpdateResponse{}

479 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[6]

479 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[6]

480 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

481 ms.StoreMessageInfo(mi)

482 }

@@ -488,7 +488,7 @@ func (x *LeaseUpdateResponse) String() string {

488 func (*LeaseUpdateResponse) ProtoMessage() {}

489

490 func (x *LeaseUpdateResponse) ProtoReflect() protoreflect.Message {

491 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[6]

491 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[6]

492 if x != nil {

493 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

494 if ms.LoadMessageInfo() == nil {

@@ -501,7 +501,7 @@ func (x *LeaseUpdateResponse) ProtoReflect() protoreflect.Message {

501

502 // Deprecated: Use LeaseUpdateResponse.ProtoReflect.Descriptor instead.

503 func (*LeaseUpdateResponse) Descriptor() ([]byte, []int) {

504 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{6}

504 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{6}

505 }

506

507 func (x *LeaseUpdateResponse) GetCode() ResponseCode {

@@ -522,7 +522,7 @@ type LeaseDeleteRequest struct {

522

523 func (x *LeaseDeleteRequest) Reset() {

524 *x = LeaseDeleteRequest{}

525 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[7]

525 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[7]

526 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

527 ms.StoreMessageInfo(mi)

528 }

@@ -534,7 +534,7 @@ func (x *LeaseDeleteRequest) String() string {

534 func (*LeaseDeleteRequest) ProtoMessage() {}

535

536 func (x *LeaseDeleteRequest) ProtoReflect() protoreflect.Message {

537 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[7]

537 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[7]

538 if x != nil {

539 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

540 if ms.LoadMessageInfo() == nil {

@@ -547,7 +547,7 @@ func (x *LeaseDeleteRequest) ProtoReflect() protoreflect.Message {

547

548 // Deprecated: Use LeaseDeleteRequest.ProtoReflect.Descriptor instead.

549 func (*LeaseDeleteRequest) Descriptor() ([]byte, []int) {

550 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{7}

550 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{7}

551 }

552

553 func (x *LeaseDeleteRequest) GetIdentity() *rdsec.Identity {

@@ -580,7 +580,7 @@ type LeaseDeleteResponse struct {

580

581 func (x *LeaseDeleteResponse) Reset() {

582 *x = LeaseDeleteResponse{}

583 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[8]

583 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[8]

584 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

585 ms.StoreMessageInfo(mi)

586 }

@@ -592,7 +592,7 @@ func (x *LeaseDeleteResponse) String() string {

592 func (*LeaseDeleteResponse) ProtoMessage() {}

593

594 func (x *LeaseDeleteResponse) ProtoReflect() protoreflect.Message {

595 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[8]

595 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[8]

596 if x != nil {

597 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

598 if ms.LoadMessageInfo() == nil {

@@ -605,7 +605,7 @@ func (x *LeaseDeleteResponse) ProtoReflect() protoreflect.Message {

605

606 // Deprecated: Use LeaseDeleteResponse.ProtoReflect.Descriptor instead.

607 func (*LeaseDeleteResponse) Descriptor() ([]byte, []int) {

608 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{8}

608 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{8}

609 }

610

611 func (x *LeaseDeleteResponse) GetCode() ResponseCode {

@@ -625,7 +625,7 @@ type ConnectionRequest struct {

625

626 func (x *ConnectionRequest) Reset() {

627 *x = ConnectionRequest{}

628 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[9]

628 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[9]

629 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

630 ms.StoreMessageInfo(mi)

631 }

@@ -637,7 +637,7 @@ func (x *ConnectionRequest) String() string {

637 func (*ConnectionRequest) ProtoMessage() {}

638

639 func (x *ConnectionRequest) ProtoReflect() protoreflect.Message {

640 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[9]

640 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[9]

641 if x != nil {

642 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

643 if ms.LoadMessageInfo() == nil {

@@ -650,7 +650,7 @@ func (x *ConnectionRequest) ProtoReflect() protoreflect.Message {

650

651 // Deprecated: Use ConnectionRequest.ProtoReflect.Descriptor instead.

652 func (*ConnectionRequest) Descriptor() ([]byte, []int) {

653 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{9}

653 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{9}

654 }

655

656 func (x *ConnectionRequest) GetLeaseId() string {

@@ -676,7 +676,7 @@ type ConnectionResponse struct {

676

677 func (x *ConnectionResponse) Reset() {

678 *x = ConnectionResponse{}

679 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[10]

679 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[10]

680 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

681 ms.StoreMessageInfo(mi)

682 }

@@ -688,7 +688,7 @@ func (x *ConnectionResponse) String() string {

688 func (*ConnectionResponse) ProtoMessage() {}

689

690 func (x *ConnectionResponse) ProtoReflect() protoreflect.Message {

691 - mi := &file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes[10]

691 + mi := &file_portal_core_proto_rdverb_rdverb_proto_msgTypes[10]

692 if x != nil {

693 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

694 if ms.LoadMessageInfo() == nil {

@@ -701,7 +701,7 @@ func (x *ConnectionResponse) ProtoReflect() protoreflect.Message {

701

702 // Deprecated: Use ConnectionResponse.ProtoReflect.Descriptor instead.

703 func (*ConnectionResponse) Descriptor() ([]byte, []int) {

704 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{10}

704 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP(), []int{10}

705 }

706

707 func (x *ConnectionResponse) GetCode() ResponseCode {

@@ -711,11 +711,11 @@ func (x *ConnectionResponse) GetCode() ResponseCode {

711 return ResponseCode_RESPONSE_CODE_UNKNOWN

712 }

713

714 -var File_relaydns_core_proto_rdverb_rdverb_proto protoreflect.FileDescriptor

714 +var File_portal_core_proto_rdverb_rdverb_proto protoreflect.FileDescriptor

715

716 -const file_relaydns_core_proto_rdverb_rdverb_proto_rawDesc = "" +

716 +const file_portal_core_proto_rdverb_rdverb_proto_rawDesc = "" +

717 "\n" +

718 - "'relaydns/core/proto/rdverb/rdverb.proto\x12\x06rdverb\x1a%relaydns/core/proto/rdsec/rdsec.proto\"J\n" +

718 + "%portal/core/proto/rdverb/rdverb.proto\x12\x06rdverb\x1a#portal/core/proto/rdsec/rdsec.proto\"J\n" +

719 "\x06Packet\x12&\n" +

720 "\x04type\x18\x01 \x01(\x0e2\x12.rdverb.PacketTypeR\x04type\x12\x18\n" +

721 "\apayload\x18\x02 \x01(\fR\apayload\"j\n" +

@@ -766,25 +766,23 @@ const file_relaydns_core_proto_rdverb_rdverb_proto_rawDesc = "" +

766 "\x1eRESPONSE_CODE_INVALID_IDENTITY\x10\x03\x12\x1e\n" +

767 "\x1aRESPONSE_CODE_INVALID_NAME\x10\x04\x12\x1e\n" +

768 "\x1aRESPONSE_CODE_INVALID_ALPN\x10\x05\x12\x1a\n" +

769 - "\x16RESPONSE_CODE_REJECTED\x10\x06B\x8f\x01\n" +

770 - "\n" +

771 - "com.rdverbB\vRdverbProtoP\x01Z<github.com/gosuda/relaydns/relaydns/core/proto/rdverb;rdverb\xa2\x02\x03RXX\xaa\x02\x06Rdverb\xca\x02\x06Rdverb\xe2\x02\x12Rdverb\\GPBMetadata\xea\x02\x06Rdverbb\x06proto3"

769 + "\x16RESPONSE_CODE_REJECTED\x10\x06B:Z8github.com/gosuda/portal/portal/core/proto/rdverb;rdverbb\x06proto3"

770

771 var (

774 - file_relaydns_core_proto_rdverb_rdverb_proto_rawDescOnce sync.Once

775 - file_relaydns_core_proto_rdverb_rdverb_proto_rawDescData []byte

772 + file_portal_core_proto_rdverb_rdverb_proto_rawDescOnce sync.Once

773 + file_portal_core_proto_rdverb_rdverb_proto_rawDescData []byte

774 )

775

778 -func file_relaydns_core_proto_rdverb_rdverb_proto_rawDescGZIP() []byte {

779 - file_relaydns_core_proto_rdverb_rdverb_proto_rawDescOnce.Do(func() {

780 - file_relaydns_core_proto_rdverb_rdverb_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_relaydns_core_proto_rdverb_rdverb_proto_rawDesc), len(file_relaydns_core_proto_rdverb_rdverb_proto_rawDesc)))

776 +func file_portal_core_proto_rdverb_rdverb_proto_rawDescGZIP() []byte {

777 + file_portal_core_proto_rdverb_rdverb_proto_rawDescOnce.Do(func() {

778 + file_portal_core_proto_rdverb_rdverb_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_portal_core_proto_rdverb_rdverb_proto_rawDesc), len(file_portal_core_proto_rdverb_rdverb_proto_rawDesc)))

779 })

782 - return file_relaydns_core_proto_rdverb_rdverb_proto_rawDescData

780 + return file_portal_core_proto_rdverb_rdverb_proto_rawDescData

781 }

782

785 -var file_relaydns_core_proto_rdverb_rdverb_proto_enumTypes = make([]protoimpl.EnumInfo, 2)

786 -var file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes = make([]protoimpl.MessageInfo, 11)

787 -var file_relaydns_core_proto_rdverb_rdverb_proto_goTypes = []any{

783 +var file_portal_core_proto_rdverb_rdverb_proto_enumTypes = make([]protoimpl.EnumInfo, 2)

784 +var file_portal_core_proto_rdverb_rdverb_proto_msgTypes = make([]protoimpl.MessageInfo, 11)

785 +var file_portal_core_proto_rdverb_rdverb_proto_goTypes = []any{

786 (PacketType)(0), // 0: rdverb.PacketType

787 (ResponseCode)(0), // 1: rdverb.ResponseCode

788 (*Packet)(nil), // 2: rdverb.Packet

@@ -800,7 +798,7 @@ var file_relaydns_core_proto_rdverb_rdverb_proto_goTypes = []any{

798 (*ConnectionResponse)(nil), // 12: rdverb.ConnectionResponse

799 (*rdsec.Identity)(nil), // 13: rdsec.Identity

800 }

803 -var file_relaydns_core_proto_rdverb_rdverb_proto_depIdxs = []int32{

801 +var file_portal_core_proto_rdverb_rdverb_proto_depIdxs = []int32{

802 0, // 0: rdverb.Packet.type:type_name -> rdverb.PacketType

803 13, // 1: rdverb.RelayInfo.identity:type_name -> rdsec.Identity

804 3, // 2: rdverb.RelayInfoResponse.relay_info:type_name -> rdverb.RelayInfo

@@ -818,27 +816,27 @@ var file_relaydns_core_proto_rdverb_rdverb_proto_depIdxs = []int32{

816 0, // [0:10] is the sub-list for field type_name

817 }

818

821 -func init() { file_relaydns_core_proto_rdverb_rdverb_proto_init() }

822 -func file_relaydns_core_proto_rdverb_rdverb_proto_init() {

823 - if File_relaydns_core_proto_rdverb_rdverb_proto != nil {

819 +func init() { file_portal_core_proto_rdverb_rdverb_proto_init() }

820 +func file_portal_core_proto_rdverb_rdverb_proto_init() {

821 + if File_portal_core_proto_rdverb_rdverb_proto != nil {

822 return

823 }

824 type x struct{}

825 out := protoimpl.TypeBuilder{

826 File: protoimpl.DescBuilder{

827 GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

830 - RawDescriptor: unsafe.Slice(unsafe.StringData(file_relaydns_core_proto_rdverb_rdverb_proto_rawDesc), len(file_relaydns_core_proto_rdverb_rdverb_proto_rawDesc)),

828 + RawDescriptor: unsafe.Slice(unsafe.StringData(file_portal_core_proto_rdverb_rdverb_proto_rawDesc), len(file_portal_core_proto_rdverb_rdverb_proto_rawDesc)),

829 NumEnums: 2,

830 NumMessages: 11,

831 NumExtensions: 0,

832 NumServices: 0,

833 },

836 - GoTypes: file_relaydns_core_proto_rdverb_rdverb_proto_goTypes,

837 - DependencyIndexes: file_relaydns_core_proto_rdverb_rdverb_proto_depIdxs,

838 - EnumInfos: file_relaydns_core_proto_rdverb_rdverb_proto_enumTypes,

839 - MessageInfos: file_relaydns_core_proto_rdverb_rdverb_proto_msgTypes,

834 + GoTypes: file_portal_core_proto_rdverb_rdverb_proto_goTypes,

835 + DependencyIndexes: file_portal_core_proto_rdverb_rdverb_proto_depIdxs,

836 + EnumInfos: file_portal_core_proto_rdverb_rdverb_proto_enumTypes,

837 + MessageInfos: file_portal_core_proto_rdverb_rdverb_proto_msgTypes,

838 }.Build()

841 - File_relaydns_core_proto_rdverb_rdverb_proto = out.File

842 - file_relaydns_core_proto_rdverb_rdverb_proto_goTypes = nil

843 - file_relaydns_core_proto_rdverb_rdverb_proto_depIdxs = nil

839 + File_portal_core_proto_rdverb_rdverb_proto = out.File

840 + file_portal_core_proto_rdverb_rdverb_proto_goTypes = nil

841 + file_portal_core_proto_rdverb_rdverb_proto_depIdxs = nil

842 }

portal/core/proto/rdverb/rdverb.proto renamed

+2 -2

@@ -2,9 +2,9 @@ syntax = "proto3";

3 package rdverb;

5 -import "relaydns/core/proto/rdsec/rdsec.proto";

5 +import "portal/core/proto/rdsec/rdsec.proto";

7 -option go_package = "github.com/gosuda/relaydns/relaydns/core/proto/rdverb;rdverb";

7 +option go_package = "github.com/gosuda/portal/portal/core/proto/rdverb;rdverb";

9 enum PacketType {

10 PACKET_TYPE_RELAY_INFO_REQUEST = 0;

portal/core/proto/rdverb/rdverb_vtproto.pb.go renamed

+70 -294

@@ -1,12 +1,12 @@

1 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.

2 // protoc-gen-go-vtproto version: v0.6.0

3 -// source: relaydns/core/proto/rdverb/rdverb.proto

3 +// source: portal/core/proto/rdverb/rdverb.proto

5 package rdverb

7 import (

8 fmt "fmt"

9 - rdsec "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

9 + rdsec "github.com/gosuda/portal/portal/core/proto/rdsec"

10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"

11 proto "google.golang.org/protobuf/proto"

12 protoimpl "google.golang.org/protobuf/runtime/protoimpl"

@@ -48,13 +48,7 @@ func (m *RelayInfo) CloneVT() *RelayInfo {

48 return (*RelayInfo)(nil)

49 }

50 r := new(RelayInfo)

51 - if rhs := m.Identity; rhs != nil {

52 - if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *rdsec.Identity }); ok {

53 - r.Identity = vtpb.CloneVT()

54 - } else {

55 - r.Identity = proto.Clone(rhs).(*rdsec.Identity)

56 - }

57 - }

51 + r.Identity = m.Identity.CloneVT()

52 if rhs := m.Address; rhs != nil {

53 tmpContainer := make([]string, len(rhs))

54 copy(tmpContainer, rhs)

@@ -114,15 +108,9 @@ func (m *Lease) CloneVT() *Lease {

108 return (*Lease)(nil)

109 }

110 r := new(Lease)

111 + r.Identity = m.Identity.CloneVT()

112 r.Expires = m.Expires

113 r.Name = m.Name

119 - if rhs := m.Identity; rhs != nil {

120 - if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *rdsec.Identity }); ok {

121 - r.Identity = vtpb.CloneVT()

122 - } else {

123 - r.Identity = proto.Clone(rhs).(*rdsec.Identity)

124 - }

125 - }

114 if rhs := m.Alpn; rhs != nil {

115 tmpContainer := make([]string, len(rhs))

116 copy(tmpContainer, rhs)

@@ -184,14 +172,8 @@ func (m *LeaseDeleteRequest) CloneVT() *LeaseDeleteRequest {

172 return (*LeaseDeleteRequest)(nil)

173 }

174 r := new(LeaseDeleteRequest)

175 + r.Identity = m.Identity.CloneVT()

176 r.Timestamp = m.Timestamp

188 - if rhs := m.Identity; rhs != nil {

189 - if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *rdsec.Identity }); ok {

190 - r.Identity = vtpb.CloneVT()

191 - } else {

192 - r.Identity = proto.Clone(rhs).(*rdsec.Identity)

193 - }

194 - }

177 if rhs := m.Nonce; rhs != nil {

178 tmpBytes := make([]byte, len(rhs))

179 copy(tmpBytes, rhs)

@@ -231,13 +213,7 @@ func (m *ConnectionRequest) CloneVT() *ConnectionRequest {

213 }

214 r := new(ConnectionRequest)

215 r.LeaseId = m.LeaseId

234 - if rhs := m.ClientIdentity; rhs != nil {

235 - if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *rdsec.Identity }); ok {

236 - r.ClientIdentity = vtpb.CloneVT()

237 - } else {

238 - r.ClientIdentity = proto.Clone(rhs).(*rdsec.Identity)

239 - }

240 - }

216 + r.ClientIdentity = m.ClientIdentity.CloneVT()

217 if len(m.unknownFields) > 0 {

218 r.unknownFields = make([]byte, len(m.unknownFields))

219 copy(r.unknownFields, m.unknownFields)

@@ -294,11 +270,7 @@ func (this *RelayInfo) EqualVT(that *RelayInfo) bool {

270 } else if this == nil || that == nil {

271 return false

272 }

297 - if equal, ok := interface{}(this.Identity).(interface{ EqualVT(*rdsec.Identity) bool }); ok {

298 - if !equal.EqualVT(that.Identity) {

299 - return false

300 - }

301 - } else if !proto.Equal(this.Identity, that.Identity) {

273 + if !this.Identity.EqualVT(that.Identity) {

274 return false

275 }

276 if len(this.Address) != len(that.Address) {

@@ -370,11 +342,7 @@ func (this *Lease) EqualVT(that *Lease) bool {

342 } else if this == nil || that == nil {

343 return false

344 }

373 - if equal, ok := interface{}(this.Identity).(interface{ EqualVT(*rdsec.Identity) bool }); ok {

374 - if !equal.EqualVT(that.Identity) {

375 - return false

376 - }

377 - } else if !proto.Equal(this.Identity, that.Identity) {

345 + if !this.Identity.EqualVT(that.Identity) {

346 return false

347 }

348 if this.Expires != that.Expires {

@@ -452,11 +420,7 @@ func (this *LeaseDeleteRequest) EqualVT(that *LeaseDeleteRequest) bool {

420 } else if this == nil || that == nil {

421 return false

422 }

455 - if equal, ok := interface{}(this.Identity).(interface{ EqualVT(*rdsec.Identity) bool }); ok {

456 - if !equal.EqualVT(that.Identity) {

457 - return false

458 - }

459 - } else if !proto.Equal(this.Identity, that.Identity) {

423 + if !this.Identity.EqualVT(that.Identity) {

424 return false

425 }

426 if string(this.Nonce) != string(that.Nonce) {

@@ -503,11 +467,7 @@ func (this *ConnectionRequest) EqualVT(that *ConnectionRequest) bool {

467 if this.LeaseId != that.LeaseId {

468 return false

469 }

506 - if equal, ok := interface{}(this.ClientIdentity).(interface{ EqualVT(*rdsec.Identity) bool }); ok {

507 - if !equal.EqualVT(that.ClientIdentity) {

508 - return false

509 - }

510 - } else if !proto.Equal(this.ClientIdentity, that.ClientIdentity) {

470 + if !this.ClientIdentity.EqualVT(that.ClientIdentity) {

471 return false

472 }

473 return string(this.unknownFields) == string(that.unknownFields)

@@ -633,24 +593,12 @@ func (m *RelayInfo) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

593 }

594 }

595 if m.Identity != nil {

636 - if vtmsg, ok := interface{}(m.Identity).(interface {

637 - MarshalToSizedBufferVT([]byte) (int, error)

638 - }); ok {

639 - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])

640 - if err != nil {

641 - return 0, err

642 - }

643 - i -= size

644 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

645 - } else {

646 - encoded, err := proto.Marshal(m.Identity)

647 - if err != nil {

648 - return 0, err

649 - }

650 - i -= len(encoded)

651 - copy(dAtA[i:], encoded)

652 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

596 + size, err := m.Identity.MarshalToSizedBufferVT(dAtA[:i])

597 + if err != nil {

598 + return 0, err

599 }

600 + i -= size

601 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

602 i--

603 dAtA[i] = 0xa

604 }

@@ -785,24 +733,12 @@ func (m *Lease) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

733 dAtA[i] = 0x10

734 }

735 if m.Identity != nil {

788 - if vtmsg, ok := interface{}(m.Identity).(interface {

789 - MarshalToSizedBufferVT([]byte) (int, error)

790 - }); ok {

791 - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])

792 - if err != nil {

793 - return 0, err

794 - }

795 - i -= size

796 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

797 - } else {

798 - encoded, err := proto.Marshal(m.Identity)

799 - if err != nil {

800 - return 0, err

801 - }

802 - i -= len(encoded)

803 - copy(dAtA[i:], encoded)

804 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

736 + size, err := m.Identity.MarshalToSizedBufferVT(dAtA[:i])

737 + if err != nil {

738 + return 0, err

739 }

740 + i -= size

741 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

742 i--

743 dAtA[i] = 0xa

744 }

@@ -945,24 +881,12 @@ func (m *LeaseDeleteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

881 dAtA[i] = 0x12

882 }

883 if m.Identity != nil {

948 - if vtmsg, ok := interface{}(m.Identity).(interface {

949 - MarshalToSizedBufferVT([]byte) (int, error)

950 - }); ok {

951 - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])

952 - if err != nil {

953 - return 0, err

954 - }

955 - i -= size

956 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

957 - } else {

958 - encoded, err := proto.Marshal(m.Identity)

959 - if err != nil {

960 - return 0, err

961 - }

962 - i -= len(encoded)

963 - copy(dAtA[i:], encoded)

964 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

884 + size, err := m.Identity.MarshalToSizedBufferVT(dAtA[:i])

885 + if err != nil {

886 + return 0, err

887 }

888 + i -= size

889 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

890 i--

891 dAtA[i] = 0xa

892 }

@@ -1038,24 +962,12 @@ func (m *ConnectionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

962 copy(dAtA[i:], m.unknownFields)

963 }

964 if m.ClientIdentity != nil {

1041 - if vtmsg, ok := interface{}(m.ClientIdentity).(interface {

1042 - MarshalToSizedBufferVT([]byte) (int, error)

1043 - }); ok {

1044 - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])

1045 - if err != nil {

1046 - return 0, err

1047 - }

1048 - i -= size

1049 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1050 - } else {

1051 - encoded, err := proto.Marshal(m.ClientIdentity)

1052 - if err != nil {

1053 - return 0, err

1054 - }

1055 - i -= len(encoded)

1056 - copy(dAtA[i:], encoded)

1057 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

965 + size, err := m.ClientIdentity.MarshalToSizedBufferVT(dAtA[:i])

966 + if err != nil {

967 + return 0, err

968 }

969 + i -= size

970 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

971 i--

972 dAtA[i] = 0x12

973 }

@@ -1201,24 +1113,12 @@ func (m *RelayInfo) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {

1113 }

1114 }

1115 if m.Identity != nil {

1204 - if vtmsg, ok := interface{}(m.Identity).(interface {

1205 - MarshalToSizedBufferVTStrict([]byte) (int, error)

1206 - }); ok {

1207 - size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])

1208 - if err != nil {

1209 - return 0, err

1210 - }

1211 - i -= size

1212 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1213 - } else {

1214 - encoded, err := proto.Marshal(m.Identity)

1215 - if err != nil {

1216 - return 0, err

1217 - }

1218 - i -= len(encoded)

1219 - copy(dAtA[i:], encoded)

1220 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

1116 + size, err := m.Identity.MarshalToSizedBufferVTStrict(dAtA[:i])

1117 + if err != nil {

1118 + return 0, err

1119 }

1120 + i -= size

1121 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1122 i--

1123 dAtA[i] = 0xa

1124 }

@@ -1353,24 +1253,12 @@ func (m *Lease) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {

1253 dAtA[i] = 0x10

1254 }

1255 if m.Identity != nil {

1356 - if vtmsg, ok := interface{}(m.Identity).(interface {

1357 - MarshalToSizedBufferVTStrict([]byte) (int, error)

1358 - }); ok {

1359 - size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])

1360 - if err != nil {

1361 - return 0, err

1362 - }

1363 - i -= size

1364 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1365 - } else {

1366 - encoded, err := proto.Marshal(m.Identity)

1367 - if err != nil {

1368 - return 0, err

1369 - }

1370 - i -= len(encoded)

1371 - copy(dAtA[i:], encoded)

1372 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

1256 + size, err := m.Identity.MarshalToSizedBufferVTStrict(dAtA[:i])

1257 + if err != nil {

1258 + return 0, err

1259 }

1260 + i -= size

1261 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1262 i--

1263 dAtA[i] = 0xa

1264 }

@@ -1513,24 +1401,12 @@ func (m *LeaseDeleteRequest) MarshalToSizedBufferVTStrict(dAtA []byte) (int, err

1401 dAtA[i] = 0x12

1402 }

1403 if m.Identity != nil {

1516 - if vtmsg, ok := interface{}(m.Identity).(interface {

1517 - MarshalToSizedBufferVTStrict([]byte) (int, error)

1518 - }); ok {

1519 - size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])

1520 - if err != nil {

1521 - return 0, err

1522 - }

1523 - i -= size

1524 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1525 - } else {

1526 - encoded, err := proto.Marshal(m.Identity)

1527 - if err != nil {

1528 - return 0, err

1529 - }

1530 - i -= len(encoded)

1531 - copy(dAtA[i:], encoded)

1532 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

1404 + size, err := m.Identity.MarshalToSizedBufferVTStrict(dAtA[:i])

1405 + if err != nil {

1406 + return 0, err

1407 }

1408 + i -= size

1409 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1410 i--

1411 dAtA[i] = 0xa

1412 }

@@ -1606,24 +1482,12 @@ func (m *ConnectionRequest) MarshalToSizedBufferVTStrict(dAtA []byte) (int, erro

1482 copy(dAtA[i:], m.unknownFields)

1483 }

1484 if m.ClientIdentity != nil {

1609 - if vtmsg, ok := interface{}(m.ClientIdentity).(interface {

1610 - MarshalToSizedBufferVTStrict([]byte) (int, error)

1611 - }); ok {

1612 - size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])

1613 - if err != nil {

1614 - return 0, err

1615 - }

1616 - i -= size

1617 - i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1618 - } else {

1619 - encoded, err := proto.Marshal(m.ClientIdentity)

1620 - if err != nil {

1621 - return 0, err

1622 - }

1623 - i -= len(encoded)

1624 - copy(dAtA[i:], encoded)

1625 - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))

1485 + size, err := m.ClientIdentity.MarshalToSizedBufferVTStrict(dAtA[:i])

1486 + if err != nil {

1487 + return 0, err

1488 }

1489 + i -= size

1490 + i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

1491 i--

1492 dAtA[i] = 0x12

1493 }

@@ -1699,13 +1563,7 @@ func (m *RelayInfo) SizeVT() (n int) {

1563 var l int

1564 _ = l

1565 if m.Identity != nil {

1702 - if size, ok := interface{}(m.Identity).(interface {

1703 - SizeVT() int

1704 - }); ok {

1705 - l = size.SizeVT()

1706 - } else {

1707 - l = proto.Size(m.Identity)

1708 - }

1566 + l = m.Identity.SizeVT()

1567 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

1568 }

1569 if len(m.Address) > 0 {

@@ -1755,13 +1613,7 @@ func (m *Lease) SizeVT() (n int) {

1613 var l int

1614 _ = l

1615 if m.Identity != nil {

1758 - if size, ok := interface{}(m.Identity).(interface {

1759 - SizeVT() int

1760 - }); ok {

1761 - l = size.SizeVT()

1762 - } else {

1763 - l = proto.Size(m.Identity)

1764 - }

1616 + l = m.Identity.SizeVT()

1617 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

1618 }

1619 if m.Expires != 0 {

@@ -1822,13 +1674,7 @@ func (m *LeaseDeleteRequest) SizeVT() (n int) {

1674 var l int

1675 _ = l

1676 if m.Identity != nil {

1825 - if size, ok := interface{}(m.Identity).(interface {

1826 - SizeVT() int

1827 - }); ok {

1828 - l = size.SizeVT()

1829 - } else {

1830 - l = proto.Size(m.Identity)

1831 - }

1677 + l = m.Identity.SizeVT()

1678 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

1679 }

1680 l = len(m.Nonce)

@@ -1866,13 +1712,7 @@ func (m *ConnectionRequest) SizeVT() (n int) {

1712 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

1713 }

1714 if m.ClientIdentity != nil {

1869 - if size, ok := interface{}(m.ClientIdentity).(interface {

1870 - SizeVT() int

1871 - }); ok {

1872 - l = size.SizeVT()

1873 - } else {

1874 - l = proto.Size(m.ClientIdentity)

1875 - }

1715 + l = m.ClientIdentity.SizeVT()

1716 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

1717 }

1718 n += len(m.unknownFields)

@@ -2057,16 +1897,8 @@ func (m *RelayInfo) UnmarshalVT(dAtA []byte) error {

1897 if m.Identity == nil {

1898 m.Identity = &rdsec.Identity{}

1899 }

2060 - if unmarshal, ok := interface{}(m.Identity).(interface {

2061 - UnmarshalVT([]byte) error

2062 - }); ok {

2063 - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

2064 - return err

2065 - }

2066 - } else {

2067 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Identity); err != nil {

2068 - return err

2069 - }

1900 + if err := m.Identity.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

1901 + return err

1902 }

1903 iNdEx = postIndex

1904 case 2:

@@ -2354,16 +2186,8 @@ func (m *Lease) UnmarshalVT(dAtA []byte) error {

2186 if m.Identity == nil {

2187 m.Identity = &rdsec.Identity{}

2188 }

2357 - if unmarshal, ok := interface{}(m.Identity).(interface {

2358 - UnmarshalVT([]byte) error

2359 - }); ok {

2360 - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

2361 - return err

2362 - }

2363 - } else {

2364 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Identity); err != nil {

2365 - return err

2366 - }

2189 + if err := m.Identity.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

2190 + return err

2191 }

2192 iNdEx = postIndex

2193 case 2:

@@ -2742,16 +2566,8 @@ func (m *LeaseDeleteRequest) UnmarshalVT(dAtA []byte) error {

2566 if m.Identity == nil {

2567 m.Identity = &rdsec.Identity{}

2568 }

2745 - if unmarshal, ok := interface{}(m.Identity).(interface {

2746 - UnmarshalVT([]byte) error

2747 - }); ok {

2748 - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

2749 - return err

2750 - }

2751 - } else {

2752 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Identity); err != nil {

2753 - return err

2754 - }

2569 + if err := m.Identity.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

2570 + return err

2571 }

2572 iNdEx = postIndex

2573 case 2:

@@ -2992,16 +2808,8 @@ func (m *ConnectionRequest) UnmarshalVT(dAtA []byte) error {

2808 if m.ClientIdentity == nil {

2809 m.ClientIdentity = &rdsec.Identity{}

2810 }

2995 - if unmarshal, ok := interface{}(m.ClientIdentity).(interface {

2996 - UnmarshalVT([]byte) error

2997 - }); ok {

2998 - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

2999 - return err

3000 - }

3001 - } else {

3002 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.ClientIdentity); err != nil {

3003 - return err

3004 - }

2811 + if err := m.ClientIdentity.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

2812 + return err

2813 }

2814 iNdEx = postIndex

2815 default:

@@ -3258,16 +3066,8 @@ func (m *RelayInfo) UnmarshalVTUnsafe(dAtA []byte) error {

3066 if m.Identity == nil {

3067 m.Identity = &rdsec.Identity{}

3068 }

3261 - if unmarshal, ok := interface{}(m.Identity).(interface {

3262 - UnmarshalVTUnsafe([]byte) error

3263 - }); ok {

3264 - if err := unmarshal.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

3265 - return err

3266 - }

3267 - } else {

3268 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Identity); err != nil {

3269 - return err

3270 - }

3069 + if err := m.Identity.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

3070 + return err

3071 }

3072 iNdEx = postIndex

3073 case 2:

@@ -3563,16 +3363,8 @@ func (m *Lease) UnmarshalVTUnsafe(dAtA []byte) error {

3363 if m.Identity == nil {

3364 m.Identity = &rdsec.Identity{}

3365 }

3566 - if unmarshal, ok := interface{}(m.Identity).(interface {

3567 - UnmarshalVTUnsafe([]byte) error

3568 - }); ok {

3569 - if err := unmarshal.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

3570 - return err

3571 - }

3572 - } else {

3573 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Identity); err != nil {

3574 - return err

3575 - }

3366 + if err := m.Identity.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

3367 + return err

3368 }

3369 iNdEx = postIndex

3370 case 2:

@@ -3956,16 +3748,8 @@ func (m *LeaseDeleteRequest) UnmarshalVTUnsafe(dAtA []byte) error {

3748 if m.Identity == nil {

3749 m.Identity = &rdsec.Identity{}

3750 }

3959 - if unmarshal, ok := interface{}(m.Identity).(interface {

3960 - UnmarshalVTUnsafe([]byte) error

3961 - }); ok {

3962 - if err := unmarshal.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

3963 - return err

3964 - }

3965 - } else {

3966 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Identity); err != nil {

3967 - return err

3968 - }

3751 + if err := m.Identity.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

3752 + return err

3753 }

3754 iNdEx = postIndex

3755 case 2:

@@ -4207,16 +3991,8 @@ func (m *ConnectionRequest) UnmarshalVTUnsafe(dAtA []byte) error {

3991 if m.ClientIdentity == nil {

3992 m.ClientIdentity = &rdsec.Identity{}

3993 }

4210 - if unmarshal, ok := interface{}(m.ClientIdentity).(interface {

4211 - UnmarshalVTUnsafe([]byte) error

4212 - }); ok {

4213 - if err := unmarshal.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

4214 - return err

4215 - }

4216 - } else {

4217 - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.ClientIdentity); err != nil {

4218 - return err

4219 - }

3994 + if err := m.ClientIdentity.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {

3995 + return err

3996 }

3997 iNdEx = postIndex

3998 default:

portal/handlers.go renamed

+4 -4

@@ -1,13 +1,13 @@

1 -package relaydns

1 +package portal

3 import (

4 "encoding/binary"

5 "io"

6 "sync"

8 - "github.com/gosuda/relaydns/relaydns/core/cryptoops"

9 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

10 - "github.com/gosuda/relaydns/relaydns/core/proto/rdverb"

8 + "github.com/gosuda/portal/portal/core/cryptoops"

9 + "github.com/gosuda/portal/portal/core/proto/rdsec"

10 + "github.com/gosuda/portal/portal/core/proto/rdverb"

11 "github.com/hashicorp/yamux"

12 "github.com/rs/zerolog/log"

13 "github.com/valyala/bytebufferpool"

portal/helper.go renamed

+2 -2

@@ -1,10 +1,10 @@

1 -package relaydns

1 +package portal

3 import (

4 "encoding/binary"

5 "io"

7 - "github.com/gosuda/relaydns/relaydns/core/proto/rdverb"

7 + "github.com/gosuda/portal/portal/core/proto/rdverb"

8 "github.com/valyala/bytebufferpool"

9 )

portal/lease.go renamed

+3 -3

@@ -1,11 +1,11 @@

1 -package relaydns

1 +package portal

3 import (

4 "sync"

5 "time"

7 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

8 - "github.com/gosuda/relaydns/relaydns/core/proto/rdverb"

7 + "github.com/gosuda/portal/portal/core/proto/rdsec"

8 + "github.com/gosuda/portal/portal/core/proto/rdverb"

9 )

11 type LeaseEntry struct {

portal/lease_test.go renamed

+3 -3

@@ -1,11 +1,11 @@

1 -package relaydns

1 +package portal

3 import (

4 "testing"

5 "time"

7 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

8 - "github.com/gosuda/relaydns/relaydns/core/proto/rdverb"

7 + "github.com/gosuda/portal/portal/core/proto/rdsec"

8 + "github.com/gosuda/portal/portal/core/proto/rdverb"

9 )

11 func TestLeaseManager_NameConflict(t *testing.T) {

portal/relay.go renamed

+4 -4

@@ -1,13 +1,13 @@

1 -package relaydns

1 +package portal

3 import (

4 "io"

5 "sync"

6 "time"

8 - "github.com/gosuda/relaydns/relaydns/core/cryptoops"

9 - "github.com/gosuda/relaydns/relaydns/core/proto/rdsec"

10 - "github.com/gosuda/relaydns/relaydns/core/proto/rdverb"

8 + "github.com/gosuda/portal/portal/core/cryptoops"

9 + "github.com/gosuda/portal/portal/core/proto/rdsec"

10 + "github.com/gosuda/portal/portal/core/proto/rdverb"

11 "github.com/hashicorp/yamux"

12 "github.com/rs/zerolog/log"

13 )

portal/utils/randpool/randpool.go renamed

portal/utils/wsstream/wsstream.go renamed

portal/wasm/.cargo/config.toml renamed

portal/wasm/.gitignore renamed

portal/wasm/Cargo.toml renamed

+3 -3

@@ -1,9 +1,9 @@

1 [package]

2 -name = "relaydns-wasm"

2 +name = "portal-wasm"

3 version = "0.1.0"

4 edition = "2021"

5 -authors = ["RelayDNS Contributors"]

6 -description = "WebAssembly client for RelayDNS"

5 +authors = ["Portal Contributors"]

6 +description = "WebAssembly client for Portal"

7 license = "MIT OR Apache-2.0"

9 [lib]

portal/wasm/E2EE_PROXY_INTEGRATION.md renamed

+15 -15

@@ -2,7 +2,7 @@

3 ## Overview

5 -RelayDNS provides **mandatory E2EE (End-to-End Encryption) proxy** functionality that automatically encrypts all network traffic through relay servers.

5 +Portal provides **mandatory E2EE (End-to-End Encryption) proxy** functionality that automatically encrypts all network traffic through relay servers.

7 ## Architecture

@@ -56,7 +56,7 @@ mux.HandleFunc("/peer/{id}/*", ...) // Server-side reverse proxy

57 ### 2. WASM SDK (Rust)

59 -**Location:** `relaydns/wasm/`

59 +**Location:** `portal/wasm/`

61 **Key Files:**

62 - `src/proxy_engine.rs` - E2EE proxy engine

@@ -96,14 +96,14 @@ mux.HandleFunc("/peer/{id}/*", ...) // Server-side reverse proxy

96 set -e

98 echo "Building WASM SDK..."

99 -cd relaydns/wasm

99 +cd portal/wasm

100 wasm-pack build --target web --release

101

102 echo "Copying to server embed directory..."

103 mkdir -p ../../cmd/relay-server/wasm

104 -cp pkg/relaydns_wasm.js ../../cmd/relay-server/wasm/

105 -cp pkg/relaydns_wasm_bg.wasm ../../cmd/relay-server/wasm/

106 -cp pkg/relaydns_wasm_sw.js ../../cmd/relay-server/wasm/

104 +cp pkg/portal_wasm.js ../../cmd/relay-server/wasm/

105 +cp pkg/portal_wasm_bg.wasm ../../cmd/relay-server/wasm/

106 +cp pkg/portal_wasm_sw.js ../../cmd/relay-server/wasm/

107 cp sw-proxy.js ../../cmd/relay-server/wasm/

108

109 echo "Building server..."

@@ -138,7 +138,7 @@ cd cmd/relay-server

138 go run .

139

140 # Terminal 2: WASM Dev Server

141 -cd relaydns/wasm

141 +cd portal/wasm

142 wasm-pack build --target web --dev

143 python -m http.server 8000

144 ```

@@ -177,7 +177,7 @@ fetch('https://api.example.com/data'); // ← Automatically encrypted!

177 **2. Direct RelayClient Usage**

178

179 ```javascript

180 -import init, { RelayClient } from '/pkg/relaydns_wasm.js';

180 +import init, { RelayClient } from '/pkg/portal_wasm.js';

181

182 // Initialize WASM

183 await init();

@@ -198,7 +198,7 @@ console.log('Active leases:', info.leases);

198 **3. Go SDK Integration**

199

200 ```go

201 -import "github.com/gosuda/relaydns/sdk"

201 +import "github.com/gosuda/portal/sdk"

202

203 // Create client

204 client, err := sdk.NewClient(func(c *sdk.RDClientConfig) {

@@ -290,7 +290,7 @@ fetch('https://api.github.com/zen')

290

291 ```bash

292 # Rust tests

293 -cd relaydns/wasm

293 +cd portal/wasm

294 cargo test

295

296 # Go tests

@@ -302,7 +302,7 @@ go test ./...

302

303 ```bash

304 # Run full integration test

305 -cd relaydns/wasm

305 +cd portal/wasm

306 ./integration-test.sh

307 ```

308

@@ -320,7 +320,7 @@ cd relaydns/wasm

320 ls cmd/relay-server/wasm/sw-proxy.js

321

322 # Rebuild if missing

323 -cd relaydns/wasm

323 +cd portal/wasm

324 wasm-pack build --target web

325 cp sw-proxy.js ../../cmd/relay-server/wasm/

326 ```

@@ -332,7 +332,7 @@ cp sw-proxy.js ../../cmd/relay-server/wasm/

332 **Solution:**

333 ```bash

334 # Rebuild WASM with correct target

335 -cd relaydns/wasm

335 +cd portal/wasm

336 wasm-pack build --target web --release

337

338 # Check output

@@ -365,13 +365,13 @@ ls pkg/

365

366 1. **Preload WASM:**

367 ```html

368 - <link rel="preload" href="/pkg/relaydns_wasm_bg.wasm" as="fetch" crossorigin>

368 + <link rel="preload" href="/pkg/portal_wasm_bg.wasm" as="fetch" crossorigin>

369 ```

370

371 2. **Service Worker Cache:**

372 ```javascript

373 // sw-proxy.js caches WASM files

374 - const CACHE_NAME = 'relaydns-v1';

374 + const CACHE_NAME = 'portal-v1';

375 ```

376

377 3. **Use HTTP/2:**

portal/wasm/README.md renamed

+14 -14

@@ -1,6 +1,6 @@

1 -# RelayDNS WASM SDK

1 +# Portal WASM SDK

3 -WebAssembly SDK for RelayDNS with **mandatory End-to-End Encryption (E2EE) Proxy** functionality.

3 +WebAssembly SDK for Portal with **mandatory End-to-End Encryption (E2EE) Proxy** functionality.

5 ## Overview

@@ -57,7 +57,7 @@ make build-wasm

58 **Manual Build:**

59 ```bash

60 -cd relaydns/wasm

60 +cd portal/wasm

62 # Build WASM module

63 wasm-pack build --target web --release

@@ -84,10 +84,10 @@ go build -o relay-server

85 ```bash

86 # From repository root

87 -docker build -t relaydns-server .

87 +docker build -t portal-server .

89 # Run

90 -docker run -p 4017:4017 relaydns-server

90 +docker run -p 4017:4017 portal-server

91 ```

93 The Dockerfile uses multi-stage builds:

@@ -101,10 +101,10 @@ After building, the following files are generated in `cmd/relay-server/wasm/`:

101

102 ```

103 cmd/relay-server/wasm/

104 -├── relaydns_wasm.js # WASM JavaScript bindings

105 -├── relaydns_wasm_bg.wasm # WASM binary (465KB)

106 -├── relaydns_wasm_sw.js # Service Worker bindings

107 -├── relaydns_wasm.d.ts # TypeScript definitions

104 +├── portal_wasm.js # WASM JavaScript bindings

105 +├── portal_wasm_bg.wasm # WASM binary (465KB)

106 +├── portal_wasm_sw.js # Service Worker bindings

107 +├── portal_wasm.d.ts # TypeScript definitions

108 ├── sw-proxy.js # E2EE Proxy Service Worker (ESSENTIAL)

109 └── sw.js # Basic caching Service Worker

110 ```

@@ -138,7 +138,7 @@ fetch('https://api.github.com/zen')

138 ### For Developers (JavaScript)

139

140 ```javascript

141 -import init, { RelayClient } from '/pkg/relaydns_wasm.js';

141 +import init, { RelayClient } from '/pkg/portal_wasm.js';

142

143 // Initialize WASM

144 await init();

@@ -171,7 +171,7 @@ See [Go SDK Documentation](../../sdk/)

171

172 ```bash

173 # Unit tests

174 -cd relaydns/wasm

174 +cd portal/wasm

175 cargo test

176

177 # Integration tests

@@ -208,7 +208,7 @@ Service Worker automatically determines message type:

208

209 ```bash

210 # Rebuild and deploy

211 -cd relaydns/wasm

211 +cd portal/wasm

212 ./deploy-server.sh

213 cd ../../cmd/relay-server

214 go build -o relay-server

@@ -218,8 +218,8 @@ go build -o relay-server

218

219 ```bash

220 # Check files are served correctly

221 -curl http://localhost:4017/pkg/relaydns_wasm.js

222 -curl http://localhost:4017/pkg/relaydns_wasm_bg.wasm

221 +curl http://localhost:4017/pkg/portal_wasm.js

222 +curl http://localhost:4017/pkg/portal_wasm_bg.wasm

223 curl http://localhost:4017/sw-proxy.js

224 ```

225

portal/wasm/SERVICE_WORKER.md renamed

+11 -11

@@ -1,8 +1,8 @@

1 -# Service Worker Implementation for RelayDNS WASM

1 +# Service Worker Implementation for Portal WASM

3 ## Overview

5 -RelayDNS WASM client uses Service Worker to efficiently load and cache WASM modules and JavaScript files.

5 +Portal WASM client uses Service Worker to efficiently load and cache WASM modules and JavaScript files.

7 ## Architecture

@@ -39,8 +39,8 @@ Service Worker provides the following features:

39 - **Fetch**: Serve files using cache-first strategy

41 #### Cached Files

42 -- `/pkg/relaydns_wasm.js` - JavaScript glue code

43 -- `/pkg/relaydns_wasm_bg.wasm` - WASM binary

42 +- `/pkg/portal_wasm.js` - JavaScript glue code

43 +- `/pkg/portal_wasm_bg.wasm` - WASM binary

44 - `/example.html` - Main HTML page

46 ### 2. HTML Integration

@@ -59,7 +59,7 @@ if ('serviceWorker' in navigator) {

59 }

61 // WASM Module Loading

62 -import init, { RelayClient } from './pkg/relaydns_wasm.js';

62 +import init, { RelayClient } from './pkg/portal_wasm.js';

63 ```

65 ## Benefits

@@ -110,7 +110,7 @@ Network First → Cache Fallback

110

111 Run development server:

112 ```bash

113 -cd relaydns/wasm

113 +cd portal/wasm

114 go run serve.go

115 # or

116 python3 -m http.server 8000

@@ -153,7 +153,7 @@ wasm-pack build --target web

153 ```

154 [SW] Installing Service Worker...

155 [SW] Caching WASM files

156 - [SW] Serving WASM from cache: /pkg/relaydns_wasm_bg.wasm

156 + [SW] Serving WASM from cache: /pkg/portal_wasm_bg.wasm

157 ```

158

159 ### Force Update

@@ -177,12 +177,12 @@ navigator.serviceWorker.getRegistrations().then(registrations => {

177

178 Manage cache versions in `sw.js`:

179 ```javascript

180 -const CACHE_NAME = 'relaydns-wasm-v1';

180 +const CACHE_NAME = 'portal-wasm-v1';

181 ```

182

183 When deploying new version:

184 ```javascript

185 -const CACHE_NAME = 'relaydns-wasm-v2';

185 +const CACHE_NAME = 'portal-wasm-v2';

186 ```

187

188 ### Cached URLs

@@ -190,8 +190,8 @@ const CACHE_NAME = 'relaydns-wasm-v2';

190 Add required files:

191 ```javascript

192 const urlsToCache = [

193 - '/pkg/relaydns_wasm.js',

194 - '/pkg/relaydns_wasm_bg.wasm',

193 + '/pkg/portal_wasm.js',

194 + '/pkg/portal_wasm_bg.wasm',

195 '/example.html',

196 // Add more files...

197 ];

portal/wasm/USAGE.md renamed

+15 -15

@@ -1,4 +1,4 @@

1 -# RelayDNS WASM Usage Guide

1 +# Portal WASM Usage Guide

3 ## 📦 Installation and Build

@@ -18,7 +18,7 @@ rustup target add wasm32-unknown-unknown

18 ### 2. Build

20 ```bash

21 -cd e:/git/relaydns/relaydns/wasm

21 +cd e:/git/portal/portal/wasm

23 # Development build (fast, includes debug info)

24 wasm-pack build --target web --dev

@@ -40,16 +40,16 @@ wasm-pack build --target web --release

40 <html>

41 <head>

42 <meta charset="utf-8">

43 - <title>RelayDNS WASM Client</title>

43 + <title>Portal WASM Client</title>

44 </head>

45 <body>

46 - <h1>RelayDNS WASM Client</h1>

46 + <h1>Portal WASM Client</h1>

47 <div id="status">Initializing...</div>

48 <pre id="output"></pre>

50 <script type="module">

51 // Import WASM module

52 - import init, { RelayClient } from './pkg/relaydns_wasm.js';

52 + import init, { RelayClient } from './pkg/portal_wasm.js';

54 async function main() {

55 try {

@@ -57,7 +57,7 @@ wasm-pack build --target web --release

57 await init();

58 console.log('✓ WASM initialized');

60 - // 2. Connect to RelayDNS server

60 + // 2. Connect to Portal server

61 const client = await new RelayClient('wss://your-relay-server.com/ws');

62 document.getElementById('status').textContent = 'Connected!';

@@ -91,7 +91,7 @@ wasm-pack build --target web --release

92 ```bash

93 # Python HTTP server

94 -cd e:/git/relaydns/relaydns/wasm

94 +cd e:/git/portal/portal/wasm

95 python -m http.server 8000

97 # Or Node.js

@@ -111,7 +111,7 @@ npx serve .

111 new RelayClient(serverUrl: string): Promise<RelayClient>

112 ```

113

114 -Connect to RelayDNS server.

114 +Connect to Portal server.

115

116 **Parameters:**

117 - `serverUrl`: WebSocket server URL (e.g., `wss://relay.example.com/ws`)

@@ -202,7 +202,7 @@ console.log('Connection result:', result);

202 ### Using with TypeScript

203

204 ```typescript

205 -import init, { RelayClient } from './pkg/relaydns_wasm';

205 +import init, { RelayClient } from './pkg/portal_wasm';

206

207 interface RelayInfo {

208 identity: {

@@ -229,7 +229,7 @@ async function main() {

229

230 ```tsx

231 import { useEffect, useState } from 'react';

232 -import init, { RelayClient } from './pkg/relaydns_wasm';

232 +import init, { RelayClient } from './pkg/portal_wasm';

233

234 function App() {

235 const [client, setClient] = useState<RelayClient | null>(null);

@@ -263,7 +263,7 @@ function App() {

263 ```vue

264 <template>

265 <div>

266 - <h1>RelayDNS Client</h1>

266 + <h1>Portal Client</h1>

267 <div v-if="loading">Connecting...</div>

268 <div v-else-if="error">Error: {{ error }}</div>

269 <div v-else>

@@ -275,7 +275,7 @@ function App() {

275

276 <script setup lang="ts">

277 import { ref, onMounted } from 'vue';

278 -import init, { RelayClient } from './pkg/relaydns_wasm';

278 +import init, { RelayClient } from './pkg/portal_wasm';

279

280 const client = ref<RelayClient | null>(null);

281 const info = ref<any>(null);

@@ -344,7 +344,7 @@ Browser DevTools → Network tab:

344 ### Simple Chat Application

345

346 ```javascript

347 -import init, { RelayClient } from './pkg/relaydns_wasm.js';

347 +import init, { RelayClient } from './pkg/portal_wasm.js';

348

349 class ChatApp {

350 constructor() {

@@ -399,13 +399,13 @@ console.log('Online users:', users);

399

400 - **Reduce Build Size**: Use `wasm-opt` for additional optimization

401 ```bash

402 - wasm-opt -Oz -o optimized.wasm pkg/relaydns_wasm_bg.wasm

402 + wasm-opt -Oz -o optimized.wasm pkg/portal_wasm_bg.wasm

403 ```

404

405 - **Improve Loading Speed**:

406 ```javascript

407 // Use streaming initialization

408 - const response = await fetch('./pkg/relaydns_wasm_bg.wasm');

408 + const response = await fetch('./pkg/portal_wasm_bg.wasm');

409 await init(response);

410 ```

411

portal/wasm/build.rs renamed

portal/wasm/package.json renamed

+5 -5

@@ -1,9 +1,9 @@

1 {

2 - "name": "relaydns-wasm",

2 + "name": "portal-wasm",

3 "version": "0.1.0",

4 - "description": "WebAssembly client for RelayDNS",

5 - "main": "pkg/relaydns_wasm.js",

6 - "types": "pkg/relaydns_wasm.d.ts",

4 + "description": "WebAssembly client for Portal",

5 + "main": "pkg/portal_wasm.js",

6 + "types": "pkg/portal_wasm.d.ts",

7 "scripts": {

8 "build": "wasm-pack build --target web --out-dir pkg",

9 "build:node": "wasm-pack build --target nodejs --out-dir pkg-node",

@@ -19,7 +19,7 @@

19 "p2p",

20 "networking"

21 ],

22 - "author": "RelayDNS Contributors",

22 + "author": "Portal Contributors",

23 "license": "MIT OR Apache-2.0",

24 "files": [

25 "pkg/"

portal/wasm/proto/rdsec/rdsec.proto renamed

+1 -1

@@ -2,7 +2,7 @@ syntax = "proto3";

3 package rdsec;

5 -option go_package = "github.com/gosuda/relaydns/relaydns/core/proto/rdsec;rdsec";

5 +option go_package = "github.com/gosuda/portal/portal/core/proto/rdsec;rdsec";

7 message Identity {

8 string id = 1;

portal/wasm/proto/rdverb/rdverb.proto renamed

+1 -1

@@ -4,7 +4,7 @@ package rdverb;

5 import "rdsec/rdsec.proto";

7 -option go_package = "github.com/gosuda/relaydns/relaydns/core/proto/rdverb;rdverb";

7 +option go_package = "github.com/gosuda/portal/portal/core/proto/rdverb;rdverb";

9 enum PacketType {

10 PACKET_TYPE_RELAY_INFO_REQUEST = 0;

portal/wasm/secure-websocket-sw.js renamed

portal/wasm/secure-websocket.js renamed

+10 -10

@@ -2,7 +2,7 @@

2 * SecureWebSocket - E2EE WebSocket Polyfill using WASM ProxyEngine

3 *

4 * Provides transparent end-to-end encryption for WebSocket connections

5 - * through the RelayDNS WASM ProxyEngine.

5 + * through the Portal WASM ProxyEngine.

6 */

8 // Global WASM instance cache

@@ -15,9 +15,9 @@ let wasmInitPromise = null;

15 */

16 async function getRelayUrl() {

17 // 1. Check if manually configured

18 - if (window.RELAYDNS_RELAY_URL) {

19 - console.log('[SecureWebSocket] Using configured relay URL:', window.RELAYDNS_RELAY_URL);

20 - return window.RELAYDNS_RELAY_URL;

18 + if (window.PORTAL_RELAY_URL) {

19 + console.log('[SecureWebSocket] Using configured relay URL:', window.PORTAL_RELAY_URL);

20 + return window.PORTAL_RELAY_URL;

21 }

23 // 2. Try to get from server API

@@ -102,11 +102,11 @@ async function getProxyEngine() {

102

103 // Load WASM module

104 if (typeof wasm_bindgen === 'undefined') {

105 - throw new Error('WASM module not loaded. Include relaydns_wasm.js first.');

105 + throw new Error('WASM module not loaded. Include portal_wasm.js first.');

106 }

107

108 // Initialize WASM

109 - await wasm_bindgen('/pkg/relaydns_wasm_bg.wasm');

109 + await wasm_bindgen('/pkg/portal_wasm_bg.wasm');

110

111 // Get relay server URL

112 const relayUrl = await getRelayUrl();

@@ -619,22 +619,22 @@ SecureWebSocket.CLOSED = 3;

619 // Configuration

620 const config = {

621 // Enable E2EE for all WebSockets by default

622 - enabled: window.RELAYDNS_E2EE_ENABLED !== false,

622 + enabled: window.PORTAL_E2EE_ENABLED !== false,

623

624 // Patterns to intercept (regex strings)

625 - interceptPatterns: window.RELAYDNS_INTERCEPT_PATTERNS || [

625 + interceptPatterns: window.PORTAL_INTERCEPT_PATTERNS || [

626 '.*' // Intercept all by default

627 ],

628

629 // Patterns to bypass (regex strings) - takes precedence

630 - bypassPatterns: window.RELAYDNS_BYPASS_PATTERNS || [

630 + bypassPatterns: window.PORTAL_BYPASS_PATTERNS || [

631 '^wss?://localhost:4017/', // Don't intercept relay server itself

632 '^wss?://localhost:8000/', // Don't intercept local dev server

633 '^wss?://127\\.0\\.0\\.1', // Don't intercept loopback

634 ],

635

636 // Debug mode

637 - debug: window.RELAYDNS_DEBUG || false

637 + debug: window.PORTAL_DEBUG || false

638 };

639

640 /**

portal/wasm/src/adapters.rs renamed

portal/wasm/src/crypto.rs renamed

portal/wasm/src/lib.rs renamed

portal/wasm/src/proto/mod.rs renamed

portal/wasm/src/proto/rdsec.rs renamed

portal/wasm/src/proto/rdverb.rs renamed

portal/wasm/src/protocol_codec.rs renamed

portal/wasm/src/proxy_engine.rs renamed

+1 -1

@@ -79,7 +79,7 @@ impl ProxyEngine {

79 #[wasm_bindgen(js_name = shouldIntercept)]

80 pub fn should_intercept(&self, url: String) -> bool {

81 // Don't intercept same-origin requests to WASM server

82 - if url.contains("localhost:8000") || url.contains("relaydns_wasm") {

82 + if url.contains("localhost:8000") || url.contains("portal_wasm") {

83 return false;

84 }

portal/wasm/src/relay_client.rs renamed

+1 -1

@@ -42,7 +42,7 @@ pub struct IdentityInfo {

43 #[wasm_bindgen]

44 impl RelayClient {

45 - /// Connect to RelayDNS server

45 + /// Connect to Portal server

46 pub async fn connect(server_url: String) -> Result<RelayClient, JsValue> {

47 // Test connection

48 let _test_ws = WebSocketStream::connect(&server_url)

portal/wasm/src/tunnel_manager.rs renamed

portal/wasm/src/utils.rs renamed

portal/wasm/src/ws_stream.rs renamed

portal/wasm/sw-proxy.js renamed

+4 -4

@@ -1,7 +1,7 @@

1 -// Service Worker for RelayDNS Network Proxy

1 +// Service Worker for Portal Network Proxy

2 // WASM must be loaded during install phase

4 -const CACHE_NAME = 'relaydns-proxy-v1';

4 +const CACHE_NAME = 'portal-proxy-v1';

5 let proxyEngine = null;

6 let wasmReady = false;

7 let initializationPromise = null;

@@ -27,7 +27,7 @@ async function initializeProxyEngine() {

27 console.log('[SW-Proxy] wasm_bindgen not available, loading via dynamic import...');

29 // Use dynamic import for ES6 modules

30 - const wasmModule = await import('/pkg/relaydns_wasm.js');

30 + const wasmModule = await import('/pkg/portal_wasm.js');

32 // Make wasm_bindgen available globally

33 self.wasm_bindgen = wasmModule;

@@ -53,7 +53,7 @@ async function initializeProxyEngine() {

54 // wasm_bindgen is now the module object from dynamic import

55 const initWasm = self.wasm_bindgen.default || self.wasm_bindgen;

56 - await initWasm('/pkg/relaydns_wasm_bg.wasm');

56 + await initWasm('/pkg/portal_wasm_bg.wasm');

58 console.log('[SW-Proxy] ✓ WASM module initialized');

59 }

portal/wasm/sw.js renamed

+5 -5

@@ -1,10 +1,10 @@

1 -// Service Worker for RelayDNS WASM Client

2 -const CACHE_NAME = 'relaydns-wasm-v1';

1 +// Service Worker for Portal WASM Client

2 +const CACHE_NAME = 'portal-wasm-v1';

4 // Files to cache

5 const urlsToCache = [

6 - '/pkg/relaydns_wasm.js',

7 - '/pkg/relaydns_wasm_bg.wasm',

6 + '/pkg/portal_wasm.js',

7 + '/pkg/portal_wasm_bg.wasm',

8 '/example.html',

9 '/adapter-test.html'

10 ];

@@ -77,7 +77,7 @@ self.addEventListener('fetch', (event) => {

77 );

78 }

79 // Handle JS files

80 - else if (url.pathname.endsWith('relaydns_wasm.js')) {

80 + else if (url.pathname.endsWith('portal_wasm.js')) {

81 event.respondWith(

82 caches.match(event.request)

83 .then((response) => {

sdk/sdk.go

+9 -9

@@ -12,10 +12,10 @@ import (

12 "time"

14 "github.com/gorilla/websocket"

15 - "github.com/gosuda/relaydns/relaydns"

16 - "github.com/gosuda/relaydns/relaydns/core/cryptoops"

17 - "github.com/gosuda/relaydns/relaydns/core/proto/rdverb"

18 - "github.com/gosuda/relaydns/relaydns/utils/wsstream"

15 + "github.com/gosuda/portal/portal"

16 + "github.com/gosuda/portal/portal/core/cryptoops"

17 + "github.com/gosuda/portal/portal/core/proto/rdverb"

18 + "github.com/gosuda/portal/portal/utils/wsstream"

19 "github.com/rs/zerolog/log"

20 )

@@ -95,7 +95,7 @@ func WithReconnectInterval(interval time.Duration) Option {

96 type rdRelay struct {

97 addr string

98 - client *relaydns.RelayClient

98 + client *portal.RelayClient

99 dialer func(context.Context, string) (io.ReadWriteCloser, error)

100 stop chan struct{}

101 mu sync.Mutex

@@ -147,7 +147,7 @@ func (r *RDConnection) SetWriteDeadline(t time.Time) error {

147 type rdAddr string

148

149 func (a rdAddr) Network() string {

150 - return "relaydns"

150 + return "portal"

151 }

152

153 func (a rdAddr) String() string {

@@ -219,7 +219,7 @@ func NewClient(opt ...Option) (*RDClient, error) {

219 continue // Skip failed connections

220 }

221

222 - relayClient := relaydns.NewRelayClient(conn)

222 + relayClient := portal.NewRelayClient(conn)

223 if relayClient == nil {

224 log.Error().Str("server", server).Msg("[SDK] Failed to create relay client")

225 conn.Close()

@@ -602,7 +602,7 @@ func (g *RDClient) reconnectRelay(relay *rdRelay, config *RDClientConfig) {

602 }

603

604 // Create new relay client

605 - relayClient := relaydns.NewRelayClient(conn)

605 + relayClient := portal.NewRelayClient(conn)

606 if relayClient == nil {

607 log.Error().Str("relay", relay.addr).Msg("[SDK] Failed to create relay client after reconnection")

608 conn.Close()

@@ -717,7 +717,7 @@ func (g *RDClient) AddRelay(addr string, dialer func(context.Context, string) (i

717 }

718

719 // Create relay client

720 - relayClient := relaydns.NewRelayClient(conn)

720 + relayClient := portal.NewRelayClient(conn)

721 if relayClient == nil {

722 conn.Close()

723 return errors.New("failed to create relay client")

sdk/sdk_e2e_test.go

+6 -6

@@ -12,9 +12,9 @@ import (

12 "time"

14 "github.com/gorilla/websocket"

15 - "github.com/gosuda/relaydns/relaydns"

16 - "github.com/gosuda/relaydns/relaydns/core/cryptoops"

17 - "github.com/gosuda/relaydns/relaydns/utils/wsstream"

15 + "github.com/gosuda/portal/portal"

16 + "github.com/gosuda/portal/portal/core/cryptoops"

17 + "github.com/gosuda/portal/portal/utils/wsstream"

18 "github.com/rs/zerolog"

19 "github.com/rs/zerolog/log"

20 )

@@ -40,7 +40,7 @@ func TestE2E_ClientToAppThroughRelay(t *testing.T) {

41 // 2. Start relay server

42 log.Info().Msg("[TEST] Step 2: Starting relay server")

43 - relayServer := relaydns.NewRelayServer(relayServerCred, []string{"ws://127.0.0.1:14017/relay"})

43 + relayServer := portal.NewRelayServer(relayServerCred, []string{"ws://127.0.0.1:14017/relay"})

44 relayServer.Start()

45 defer relayServer.Stop()

@@ -233,7 +233,7 @@ func TestE2E_MultipleConnections(t *testing.T) {

233 t.Fatalf("Failed to create relay server credential: %v", err)

234 }

235

236 - relayServer := relaydns.NewRelayServer(relayServerCred, []string{"ws://127.0.0.1:14018/relay"})

236 + relayServer := portal.NewRelayServer(relayServerCred, []string{"ws://127.0.0.1:14018/relay"})

237 relayServer.Start()

238 defer relayServer.Stop()

239

@@ -388,7 +388,7 @@ func TestE2E_ConnectionTimeout(t *testing.T) {

388 // Try to dial to non-existent lease

389 relayServerCred := NewCredential()

390

391 - relayServer := relaydns.NewRelayServer(relayServerCred, []string{"ws://127.0.0.1:14019/relay"})

391 + relayServer := portal.NewRelayServer(relayServerCred, []string{"ws://127.0.0.1:14019/relay"})

392 relayServer.Start()

393 defer relayServer.Stop()

394