Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 Dockerfile FROM martenseemann/quic-network-simulator-endpoint:latest AS builder ARG TARGETPLATFORM RUN echo "TARGETPLATFORM: ${TARGETPLATFORM}" RUN apt-get update && apt-get install -y wget tar git ENV GOVERSION=1.21.1 RUN platform=$(echo ${TARGETPLATFORM} \| tr '/' '-') && \ filename="go${GOVERSION}.${platform}.tar.gz" && \ wget --no-verbose https://dl.google.com/go/${filename} && \ tar xfz ${filename} && \ rm ${filename} ENV PATH="/go/bin:${PATH}" RUN git clone https://go.googlesource.com/net WORKDIR /net RUN go build -o /interop ./internal/quic/cmd/interop FROM martenseemann/quic-network-simulator-endpoint:latest WORKDIR /go-x-net COPY --from=builder /interop ./ # copy run script and run it COPY run_endpoint.sh . RUN chmod +x run_endpoint.sh ENTRYPOINT [ "./run_endpoint.sh" ]	797 B	2025-05-25 12:27
📄 README.md This directory contains configuration and programs used to integrate with the QUIC Interop Test Runner. The QUIC Interop Test Runner executes a variety of test cases against a matrix of clients and servers. https://github.com/marten-seemann/quic-interop-runner	263 B	2025-05-25 12:27
📄 main.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 // The interop command is the client and server used by QUIC interoperability tests. // // https://github.com/marten-seemann/quic-interop-runner package main import ( "bytes" "context" "crypto/tls" "errors" "flag" "fmt" "io" "log" "log/slog" "net" "net/url" "os" "path/filepath" "sync" "golang.org/x/net/quic" "golang.org/x/net/quic/qlog" ) var ( listen = flag.String("listen", "", "listen address") cert = flag.String("cert", "", "certificate") pkey = flag.String("key", "", "private key") root = flag.String("root", "", "serve files from this root") output = flag.String("output", "", "directory to write files to") qlogdir = flag.String("qlog", "", "directory to write qlog output to") ) func main() { ctx := context.Background() flag.Parse() urls := flag.Args() config := &quic.Config{ TLSConfig: &tls.Config{ InsecureSkipVerify: true, MinVersion: tls.VersionTLS13, NextProtos: []string{"hq-interop"}, }, MaxBidiRemoteStreams: -1, MaxUniRemoteStreams: -1, QLogLogger: slog.New(qlog.NewJSONHandler(qlog.HandlerOptions{ Level: quic.QLogLevelFrame, Dir: qlogdir, })), } if cert != "" { c, err := tls.LoadX509KeyPair(cert, pkey) if err != nil { log.Fatal(err) } config.TLSConfig.Certificates = []tls.Certificate{c} } if root != "" { config.MaxBidiRemoteStreams = 100 } if keylog := os.Getenv("SSLKEYLOGFILE"); keylog != "" { f, err := os.Create(keylog) if err != nil { log.Fatal(err) } defer f.Close() config.TLSConfig.KeyLogWriter = f } testcase := os.Getenv("TESTCASE") switch testcase { case "handshake", "keyupdate": basicTest(ctx, config, urls) return case "chacha20": // "[...] offer only ChaCha20 as a ciphersuite." // // crypto/tls does not support configuring TLS 1.3 ciphersuites, // so we can't support this test. case "transfer": // "The client should use small initial flow control windows // for both stream- and connection-level flow control // such that the during the transfer of files on the order of 1 MB // the flow control window needs to be increased." config.MaxStreamReadBufferSize = 64 << 10 config.MaxConnReadBufferSize = 64 << 10 basicTest(ctx, config, urls) return case "http3": // TODO case "multiconnect": // TODO case "resumption": // TODO case "retry": // TODO case "versionnegotiation": // "The client should start a connection using // an unsupported version number [...]" // // We don't support setting the client's version, // so only run this test as a server. if listen != "" && len(urls) == 0 { basicTest(ctx, config, urls) return } case "v2": // We do not support QUIC v2. case "zerortt": // TODO } fmt.Printf("unsupported test case %q\n", testcase) os.Exit(127) } // basicTest runs the standard test setup. // // As a server, it serves the contents of the -root directory. // As a client, it downloads all the provided URLs in parallel, // making one connection to each destination server. func basicTest(ctx context.Context, config quic.Config, urls []string) { l, err := quic.Listen("udp", listen, config) if err != nil { log.Fatal(err) } log.Printf("listening on %v", l.LocalAddr()) byAuthority := map[string][]url.URL{} for _, s := range urls { u, addr, err := parseURL(s) if err != nil { log.Fatal(err) } byAuthority[addr] = append(byAuthority[addr], u) } var g sync.WaitGroup defer g.Wait() for addr, u := range byAuthority { addr, u := addr, u g.Add(1) go func() { defer g.Done() fetchFrom(ctx, config, l, addr, u) }() } if config.MaxBidiRemoteStreams >= 0 { serve(ctx, l) } } func serve(ctx context.Context, l quic.Endpoint) error { for { c, err := l.Accept(ctx) if err != nil { return err } go serveConn(ctx, c) } } func serveConn(ctx context.Context, c quic.Conn) { for { s, err := c.AcceptStream(ctx) if err != nil { return } go func() { if err := serveReq(ctx, s); err != nil { log.Print("serveReq:", err) } }() } } func serveReq(ctx context.Context, s quic.Stream) error { defer s.Close() req, err := io.ReadAll(s) if err != nil { return err } if !bytes.HasSuffix(req, []byte("\r\n")) { return errors.New("invalid request") } req = bytes.TrimSuffix(req, []byte("\r\n")) if !bytes.HasPrefix(req, []byte("GET /")) { return errors.New("invalid request") } req = bytes.TrimPrefix(req, []byte("GET /")) if !filepath.IsLocal(string(req)) { return errors.New("invalid request") } f, err := os.Open(filepath.Join(root, string(req))) if err != nil { return err } defer f.Close() _, err = io.Copy(s, f) return err } func parseURL(s string) (u url.URL, authority string, err error) { u, err = url.Parse(s) if err != nil { return nil, "", err } host := u.Hostname() port := u.Port() if port == "" { port = "443" } authority = net.JoinHostPort(host, port) return u, authority, nil } func fetchFrom(ctx context.Context, config quic.Config, l quic.Endpoint, addr string, urls []url.URL) { conn, err := l.Dial(ctx, "udp", addr, config) if err != nil { log.Printf("%v: %v", addr, err) return } log.Printf("connected to %v", addr) defer conn.Close() var g sync.WaitGroup for _, u := range urls { u := u g.Add(1) go func() { defer g.Done() if err := fetchOne(ctx, conn, u); err != nil { log.Printf("fetch %v: %v", u, err) } else { log.Printf("fetched %v", u) } }() } g.Wait() } func fetchOne(ctx context.Context, conn quic.Conn, u url.URL) error { if len(u.Path) == 0 \|\| u.Path[0] != '/' \|\| !filepath.IsLocal(u.Path[1:]) { return errors.New("invalid path") } file, err := os.Create(filepath.Join(output, u.Path[1:])) if err != nil { return err } s, err := conn.NewStream(ctx) if err != nil { return err } defer s.Close() if _, err := s.Write([]byte("GET " + u.Path + "\r\n")); err != nil { return err } s.CloseWrite() if _, err := io.Copy(file, s); err != nil { return err } return nil }	6.07 KB	2025-05-25 12:27
📄 main_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package main import ( "bufio" "bytes" "context" "net" "os" "os/exec" "path/filepath" "strings" "sync" "testing" ) func init() { // We reexec the test binary with CMD_INTEROP_MAIN=1 to run main. if os.Getenv("CMD_INTEROP_MAIN") == "1" { main() os.Exit(0) } } var ( tryExecOnce sync.Once tryExecErr error ) // needsExec skips the test if we can't use exec.Command. func needsExec(t testing.T) { tryExecOnce.Do(func() { cmd := exec.Command(os.Args[0], "-test.list=^$") cmd.Env = []string{} tryExecErr = cmd.Run() }) if tryExecErr != nil { t.Skipf("skipping test: cannot exec subprocess: %v", tryExecErr) } } type interopTest struct { donec chan struct{} addr string cmd exec.Cmd } func run(ctx context.Context, t testing.T, name, testcase string, args []string) interopTest { needsExec(t) ctx, cancel := context.WithCancel(ctx) cmd := exec.CommandContext(ctx, os.Args[0], args...) out, err := cmd.StderrPipe() if err != nil { t.Fatal(err) } cmd.Stdout = cmd.Stderr cmd.Env = []string{ "CMD_INTEROP_MAIN=1", "TESTCASE=" + testcase, } t.Logf("run %v: %v", name, args) err = cmd.Start() if err != nil { t.Fatal(err) } addrc := make(chan string, 1) donec := make(chan struct{}) go func() { defer close(addrc) defer close(donec) defer t.Logf("%v done", name) s := bufio.NewScanner(out) for s.Scan() { line := s.Text() t.Logf("%v: %v", name, line) _, addr, ok := strings.Cut(line, "listening on ") if ok { select { case addrc <- addr: default: } } } }() t.Cleanup(func() { cancel() <-donec }) addr, ok := <-addrc if !ok { t.Fatal(cmd.Wait()) } _, port, _ := net.SplitHostPort(addr) addr = net.JoinHostPort("localhost", port) iop := &interopTest{ cmd: cmd, donec: donec, addr: addr, } return iop } func (iop interopTest) wait() { <-iop.donec } func TestTransfer(t testing.T) { ctx := context.Background() src := t.TempDir() dst := t.TempDir() certs := t.TempDir() certFile := filepath.Join(certs, "cert.pem") keyFile := filepath.Join(certs, "key.pem") sourceName := "source" content := []byte("hello, world\n") os.WriteFile(certFile, localhostCert, 0600) os.WriteFile(keyFile, localhostKey, 0600) os.WriteFile(filepath.Join(src, sourceName), content, 0600) srv := run(ctx, t, "server", "transfer", []string{ "-listen", "localhost:0", "-cert", filepath.Join(certs, "cert.pem"), "-key", filepath.Join(certs, "key.pem"), "-root", src, }) cli := run(ctx, t, "client", "transfer", []string{ "-output", dst, "https://" + srv.addr + "/" + sourceName, }) cli.wait() got, err := os.ReadFile(filepath.Join(dst, "source")) if err != nil { t.Fatalf("reading downloaded file: %v", err) } if !bytes.Equal(got, content) { t.Fatalf("got downloaded file: %q, want %q", string(got), string(content)) } } // localhostCert is a PEM-encoded TLS cert with SAN IPs // "127.0.0.1" and "[::1]", expiring at Jan 29 16:00:00 2084 GMT. // generated from src/crypto/tls: // go run generate_cert.go --ecdsa-curve P256 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h var localhostCert = []byte(`-----BEGIN CERTIFICATE----- MIIBrDCCAVKgAwIBAgIPCvPhO+Hfv+NW76kWxULUMAoGCCqGSM49BAMCMBIxEDAO BgNVBAoTB0FjbWUgQ28wIBcNNzAwMTAxMDAwMDAwWhgPMjA4NDAxMjkxNjAwMDBa MBIxEDAOBgNVBAoTB0FjbWUgQ28wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARh WRF8p8X9scgW7JjqAwI9nYV8jtkdhqAXG9gyEgnaFNN5Ze9l3Tp1R9yCDBMNsGms PyfMPe5Jrha/LmjgR1G9o4GIMIGFMA4GA1UdDwEB/wQEAwIChDATBgNVHSUEDDAK BggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSOJri/wLQxq6oC Y6ZImms/STbTljAuBgNVHREEJzAlggtleGFtcGxlLmNvbYcEfwAAAYcQAAAAAAAA AAAAAAAAAAAAATAKBggqhkjOPQQDAgNIADBFAiBUguxsW6TGhixBAdORmVNnkx40 HjkKwncMSDbUaeL9jQIhAJwQ8zV9JpQvYpsiDuMmqCuW35XXil3cQ6Drz82c+fvE -----END CERTIFICATE-----`) // localhostKey is the private key for localhostCert. var localhostKey = []byte(testingKey(`-----BEGIN TESTING KEY----- MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgY1B1eL/Bbwf/MDcs rnvvWhFNr1aGmJJR59PdCN9lVVqhRANCAARhWRF8p8X9scgW7JjqAwI9nYV8jtkd hqAXG9gyEgnaFNN5Ze9l3Tp1R9yCDBMNsGmsPyfMPe5Jrha/LmjgR1G9 -----END TESTING KEY-----`)) // testingKey helps keep security scanners from getting excited about a private key in this file. func testingKey(s string) string { return strings.ReplaceAll(s, "TESTING KEY", "PRIVATE KEY") }	4.43 KB	2025-05-25 12:27
📄 run_endpoint.sh #!/bin/bash # Set up the routing needed for the simulation /setup.sh # The following variables are available for use: # - ROLE contains the role of this execution context, client or server # - SERVER_PARAMS contains user-supplied command line parameters # - CLIENT_PARAMS contains user-supplied command line parameters if [ "$ROLE" == "client" ]; then # Wait for the simulator to start up. /wait-for-it.sh sim:57832 -s -t 30 ./interop -output=/downloads -qlog=$QLOGDIR $CLIENT_PARAMS $REQUESTS elif [ "$ROLE" == "server" ]; then ./interop -cert=/certs/cert.pem -key=/certs/priv.key -qlog=$QLOGDIR -listen=:443 -root=/www "$@" $SERVER_PARAMS fi	679 B	2025-05-25 12:27

Terminal