quicsilver 0.5.0-arm64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e371ace66e01439da41b65099c636cd44a4ea9d91ecc2d03480b2cbb245ea80a
+  data.tar.gz: e506c1721b3ff3736f47d79b70248fa50d81c67ac001b3dfb3f153f37a8d1205
+SHA512:
+  metadata.gz: 1c2ac3a20e79a0535ef7701d825745bc5624800482120ee796ba47e77fb2647342765b7b9ef961cb43a915ace6466378a19e189954cea85957f9e89993e5581a
+  data.tar.gz: b4f72a0645749bb05f981d6363451688bf9cabcc8f51a9e7a0e1a2fe7ee3ef7942238dfb4c828747d9fdaa472c9edd6888248a3dd8e59e661bef3d6ae160cebd

data/.github/workflows/ci.yml

@@ -0,0 +1,49 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+
+    runs-on: ubuntu-24.04
+    continue-on-error: ${{ matrix.allow-failure }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - ruby-version: "3.4"
+            allow-failure: false
+          - ruby-version: "4.0"
+            allow-failure: false
+          - ruby-version: "head"
+            allow-failure: true
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Build MSQUIC
+      run: bundle exec rake build_msquic
+    - name: Compile
+      run: bundle exec rake compile
+    - name: Run tests
+      run: bundle exec rake

data/.github/workflows/cibuildgem.yaml

@@ -0,0 +1,117 @@
+name: "Package and release gems with precompiled binaries"
+on:
+  workflow_dispatch:
+    inputs:
+      release:
+        description: "If the whole build passes on all platforms, release the gems on RubyGems.org"
+        required: false
+        type: boolean
+        default: false
+env:
+  CIBUILDGEM: 1
+  RELEASE: "true"
+jobs:
+  compile:
+    timeout-minutes: 20
+    name: "Cross compile the gem on different ruby versions"
+    strategy:
+      matrix:
+        os: ["macos-latest", "ubuntu-22.04"]
+    runs-on: "${{ matrix.os }}"
+    steps:
+      - name: "Checkout code"
+        uses: "actions/checkout@v5"
+        with:
+          submodules: recursive
+      - name: "Setup Ruby"
+        uses: "ruby/setup-ruby@v1"
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - name: "Build MsQuic"
+        run: bundle exec rake build_msquic bundle_msquic
+      - name: "Verify bundled MsQuic"
+        run: |
+          ls -la lib/quicsilver
+          test -f lib/quicsilver/libmsquic.2.dylib || test -f lib/quicsilver/libmsquic.so.2
+      - name: "Verify package file list"
+        run: |
+          ruby -e 'puts "RELEASE=#{ENV["RELEASE"].inspect}"; spec = Gem::Specification.load("quicsilver.gemspec"); puts spec.files.grep(/libmsquic/)'
+      - name: "Run cibuildgem"
+        uses: "shopify/cibuildgem/.github/actions/cibuildgem@main"
+        with:
+          step: "compile"
+      - name: "Upload staged artifacts with MsQuic"
+        uses: "actions/upload-artifact@v4"
+        with:
+          name: "stage-${{ runner.os }}-${{ runner.arch }}"
+          path: |
+            ./tmp/**/*.so
+            ./tmp/**/*.so.*
+            ./tmp/**/*.bundle
+            ./tmp/**/*.dylib
+            ./tmp/**/*.dylib.*
+            ./pkg/*.gem
+          if-no-files-found: error
+          retention-days: 1
+          overwrite: true
+  test:
+    timeout-minutes: 20
+    name: "Run the test suite"
+    needs: compile
+    strategy:
+      matrix:
+        os: ["macos-latest", "ubuntu-22.04"]
+        rubies: ["3.4", "4.0"]
+        type: ["cross"]
+    runs-on: "${{ matrix.os }}"
+    steps:
+      - name: "Checkout code"
+        uses: "actions/checkout@v5"
+      - name: "Setup Ruby"
+        uses: "ruby/setup-ruby@v1"
+        with:
+          ruby-version: "${{ matrix.rubies }}"
+          bundler-cache: true
+      - name: "Run cibuildgem"
+        uses: "shopify/cibuildgem/.github/actions/cibuildgem@main"
+        with:
+          step: "test_${{ matrix.type }}"
+  install:
+    timeout-minutes: 5
+    name: "Verify the gem can be installed"
+    needs: test
+    strategy:
+      matrix:
+        os: ["macos-latest", "ubuntu-22.04"]
+    runs-on: "${{ matrix.os }}"
+    steps:
+      - name: "Setup Ruby"
+        uses: "ruby/setup-ruby@v1"
+        with:
+          ruby-version: "4.0.0"
+      - name: "Download platform gems"
+        uses: "actions/download-artifact@v5"
+        with:
+          name: "stage-${{ runner.os }}-${{ runner.arch }}"
+      - name: "Install platform gem"
+        run: ruby -e 'puts Dir["pkg/*-#{Gem::Platform.local}.gem"].fetch(0)' | xargs gem install
+  release:
+    environment: release
+    permissions:
+      id-token: write
+      contents: read
+    timeout-minutes: 5
+    if: ${{ inputs.release }}
+    name: "Release all gems with RubyGems"
+    needs: install
+    runs-on: "ubuntu-latest"
+    steps:
+      - name: "Setup Ruby"
+        uses: "ruby/setup-ruby@v1"
+        with:
+          ruby-version: "4.0.0"
+      - name: "Run cibuildgem"
+        uses: "shopify/cibuildgem/.github/actions/cibuildgem@main"
+        with:
+          step: "release"

data/.gitignore

@@ -0,0 +1,21 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/*
+/certs/*
+/certificates/*
+*.bundle
+*.bundle.*
+*.so
+*.so.*
+*.dylib
+*.dylib.*
+lib/quicsilver/quicsilver.bundle
+*.gem
+autoresearch.*
+ext/quicsilver/Makefile

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/msquic"]
+	path = vendor/msquic
+	url = https://github.com/microsoft/msquic.git

data/.ruby-version

@@ -0,0 +1 @@
+3.4.2

data/CHANGELOG.md

@@ -0,0 +1,175 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.5.0] - 2026-11-02
+
+### Added
+
+- WebTransport session flow control (draft-ietf-webtrans-http3-16 §5): the `WT_MAX_DATA`, `WT_MAX_STREAMS`, `WT_DATA_BLOCKED` and `WT_STREAMS_BLOCKED` capsules, negotiation via `SETTINGS_WT_INITIAL_MAX_*`, enforcement of limits we advertise, spending of limits a peer grants, and proactive grants as the application consumes. `WebTransportStream#writable?` and `WebTransportSession#on_writable` report send credit. Prohibited per-stream capsules fail the session. §5.1 requires both endpoints to advertise a non-zero initial limit; browsers tested do not, so sessions with them run without it and remain limited to one per connection.
+
+- `Transport::StreamEvent#final_size` reports how many bytes the peer sent on a stream the peer reset, from the RESET_STREAM frame (RFC 9000 §4.5); `nil` when the final size is not settled. WebTransport session flow control needs it to charge the bytes a reset discarded (draft-ietf-webtrans-http3-16 §5.4). MsQuic keeps the value but does not expose it, so it is read through a new vendored patch, `ext/quicsilver/patches/stream-final-size.patch`.
+- Shared connection multiplexing — single QUIC connection serves all threads concurrently (5x faster: 16,000 req/s vs 3,175 req/s exclusive). Default pool mode.
+- `TransportError` base class with MsQuic status code parsing — typed errors instead of string-matching RuntimeError from C extension
+- `StreamFailedToOpenError` wraps `StreamOpen`/`StreamStart` failures with parsed hex status
+- Stream flow control visibility — `QUIC_STREAM_START_FLAG_INDICATE_PEER_ACCEPT` dispatches `STREAM_START_COMPLETE` and `STREAM_PEER_ACCEPTED` events to Ruby
+- H3 Datagram support (RFC 9221/9297) — `client.datagram_send`, `server.datagram_send`, `on_datagram` callbacks, `SETTINGS_H3_DATAGRAM` advertised
+- Client priority support — send `priority` header with extensible priorities (RFC 9218)
+- Client request body streaming — `build_request('POST', path, body: :stream)` with `Request#stream_body`
+- Client response body streaming — `request.streaming_response` returns headers immediately, body arrives incrementally
+- Per-request timeout support
+- Connection pool blocks with timeout (ConditionVariable) instead of raising immediately when full
+- Response unification — single response representation across buffered and streaming paths
+- Multi-threaded benchmarks
+
+### Fixed
+
+- Repeated response headers are sent as separate fields. They were flattened into a Hash keyed by name, which kept only the last value; a Rails response setting a session cookie alongside any other lost the session, so sign-in succeeded and the next request arrived unauthenticated. `set-cookie` MUST NOT be combined (RFC 9110 §5.3).
+- WebTransport rejects the `WT_MAX_STREAM_DATA` and `WT_STREAM_DATA_BLOCKED` capsules. Per-stream data limits belong to the HTTP/2 binding; over HTTP/3 each WebTransport stream is a QUIC stream with its own limits, so receipt is a session error carrying `WT_FLOW_CONTROL_ERROR` (draft-ietf-webtrans-http3-16 §5.4). They were previously ignored as unknown capsule types. Unknown types are still ignored.
+- WebTransport CLOSE and DRAIN capsules use HTTP/3 DATA frames. Session close sends FIN, validates peer close payloads, and terminates both directions on protocol errors.
+- WT_STREAM (`0x41`) is rejected with the connection error `H3_FRAME_ERROR` when it appears anywhere other than the first bytes of a request stream, including on the control stream (draft-ietf-webtrans-http3-16 §4.3). It is only a signal value at the front of a WebTransport stream, never a frame elsewhere.
+- WebTransport capsules sent optimistically on the CONNECT stream are no longer processed before the server responds. They are held unparsed, then processed once `accept!` sends the 2xx or discarded if the session is rejected (§3.2). The hold is bounded at 64 KiB; exceeding it fails the session with `H3_MESSAGE_ERROR`. Previously a CLOSE capsule arriving before the application responded would terminate the session and make it unacceptable.
+- Release GVL during `wait_for_connection` — no longer blocks all Ruby threads during handshake
+- Stream cleanup after response sent — `Connection#@streams` entries removed on completion, not just on connection close
+- Error hierarchy — `FrameError`, `MessageError`, `StreamFailedToOpenError` all inherit from `Quicsilver::Error`
+- Large response crash and concurrent connection race condition
+- Rack adapter owns early hints and trailer wiring (removed from server)
+
+### Changed
+
+- MsQuic callbacks no longer call into Ruby. The poll thread runs the whole MsQuic iteration with the GVL released and queues events; a dispatcher thread delivers them to `Server.handle_stream` in order. `Quicsilver.defer_stream_receive` and `Transport::Stream#defer_receive` are removed: delivery is asynchronous, so a receive cannot be handed back to MsQuic, and a method that always declined would be indistinguishable from one that declined this time. With `receive_backpressure: true`, the one WebTransport receive that can arrive before the first credit grant is delivered whole and may exceed `receive_buffer_bytes`; it is bounded by the initial QUIC stream window instead (RFC 9000 §4.1), and no credit is granted until the reader drains below the limit. Previously the excess was deferred. Credit bounds every receive after that as before. Each connection may have at most 128 datagrams queued ahead of the dispatcher (quic-go's figure); past that the oldest is dropped, as RFC 9221 §5.3 permits and as quiche and neqo do. `Server#stats["datagrams"]["dropped"]` counts drops across connections. `receive_buffer_bytes` was never a bound on what a single `read` returns.
+- `Quicsilver.send_stream` no longer copies the body. The Ruby String is frozen and MsQuic sends from its bytes directly, with the String retained until the send completes. Callers that went on mutating a buffer after sending it must `dup` first; nothing in the library did. Large responses gain about 4% on server-side time; small ones are unchanged. The poll thread's idle spin before sleeping is now configurable via `QUICSILVER_POLL_IDLE_US` (default 0, the previous behaviour); it measured as having no effect under load and is exposed for low-concurrency latency-sensitive deployments to evaluate.
+- WebTransport child streams have bounded receive queues, and a child that fills its buffer now pauses instead of losing its stream. `accept!` takes `receive_buffer_bytes` (default 1 MiB), `receive_buffer_chunks` (default 1024), `receive_overflow_code` and `receive_backpressure` (default `true`); delivery stops until the application reads. A reader that never drains leaves its stream paused indefinitely, and a paused stream holds connection credit, so it can stall its siblings. `receive_backpressure: false` restores the previous policy: an overflowing child is sent `STOP_SENDING` with `receive_overflow_code`, its queued input is discarded and its pending reads fail, while its write side stays open. Limits apply to each child's queued Ruby input, not to native buffers or the whole connection. `WebTransportStream#initialize` now requires these four options rather than defaulting them, so the defaults have a single home in `WebTransportSession::DEFAULT_RECEIVE_OPTIONS`.
+- WebTransport stream resets are directional. `RESET_STREAM` closes only the read side and invokes the new `on_peer_reset`; `STOP_SENDING` closes only the write side and invokes the new `on_peer_stop_sending`. `on_close` fires once both directions are closed. Previously either signal tore down the whole stream and both reported through `on_reset`, which is removed — the `peer_` prefix distinguishes these inbound events from the outbound `reset` and `abort` methods.
+- WebTransport CONNECT waits for peer SETTINGS before reaching Rack, including when headers arrive with FIN. The `webtransport-h3` token requires `WT_ENABLED=1` and `H3_DATAGRAM=1`; the legacy `webtransport` token requires `H3_DATAGRAM=1`. Waiting is limited to one CONNECT and 64 KiB of body data per connection, with cleanup on cancellation or connection closure.
+- WebTransport permits one active session per QUIC connection until session flow control is implemented. Additional CONNECT requests are rejected with `H3_REQUEST_REJECTED`; closing a session allows another. SETTINGS no longer advertise session flow-control credit, and the legacy session limit is one.
+- WebTransport `close(code:, reason:)` rejects invalid UTF-8 and codes outside the unsigned 32-bit range before changing session state. Valid UTF-8 binary strings remain supported; long valid reasons are truncated at a UTF-8 character boundary.
+- Connection pool default mode is `:shared` (multiplexed) — `:exclusive` available as opt-in
+- `open_stream` wraps C extension errors into typed `StreamFailedToOpenError` / `TransportError`
+- MsQuic submodule updated from v2.5.0 to v2.5.7
+- Uni stream default documented: 10 (3 required by HTTP/3, headroom for GREASE and extensions)
+- Scheduler base class extracted for extensibility
+
+## [0.4.0] - 2026-04-25
+
+### Added
+- Client connection pool with automatic reuse (`Quicsilver::Client.get/post` class-level API)
+- GREASE support (RFC 9297) — settings, frames, and unidirectional streams
+- GOAWAY validation (RFC 9114 §7.2.6) — monotonically decreasing IDs, stream ID validation
+- Trailer support (RFC 9114 §4.1) — parse and send trailing HEADERS frames
+- Extensible Priorities (RFC 9218) — parse `priority` header, PRIORITY_UPDATE frames on control stream, MsQuic stream priority mapping
+- FrameParser base class — unified frame walking, ordering, body accumulation, size limits
+- FrameReader module — shared byte-level frame extraction for request/response/control streams
+- Trailer wiring in Adapter and StreamOutput for protocol-http integration
+- Informational 1xx responses (§4.1) — 103 Early Hints with `rack.early_hints` support for Rails
+- Two-phase GOAWAY shutdown (§5.2) — server sends decreasing GOAWAY IDs during graceful shutdown
+- Client processes server SETTINGS (§7.2.4) — parses peer's SETTINGS including MAX_FIELD_SECTION_SIZE
+- Client processes server GOAWAY (§5.2) — tracks peer_goaway_id, blocks new requests, connection pool evicts draining connections
+- MIT license in gemspec
+
+### Fixed
+- QPACK prefix decoding — decode Required Insert Count and Delta Base as varints instead of hardcoded `offset = 2`
+- Default decoder rejects payloads referencing the dynamic table
+- Response parser now enforces `max_frame_payload_size` (was missing)
+- Duplicate `frames` method in FrameParser
+- Consistent `@headers` and `@trailers` initialization (`{}` not `nil`)
+- extconf.rb — force Apple clang on macOS (Homebrew clang produces broken MsQuic binaries)
+
+### Changed
+- RequestParser and ResponseParser inherit from FrameParser (reduced ~230 lines of duplication)
+- `store_header`, `body`, `DEFAULT_DECODER`, `EMPTY_BODY`, `parse!` moved to FrameParser base class
+- `@body_io` renamed to `@body` in ResponseParser for consistency
+- ResponseEncoder accepts optional `trailers:` hash
+- StreamOutput accepts `send_fin:` parameter for trailer support
+
+## [0.3.0] - 2026-03-23
+
+### Added
+- QPACK Huffman coding with 8-bit decode table and encode/decode caching
+- 0-RTT replay protection for unsafe HTTP methods
+- Bounded backpressure support
+- Buffer size limits to prevent memory exhaustion (configurable `max_body_size`, `max_header_size`, `max_header_count`, `max_frame_payload_size`)
+- Content-length validation
+- Multi-value header support for duplicate header fields
+- Headers validation: reject connection-specific headers, require `:authority` or `host` for http/https schemes
+- Incremental unidirectional stream processing with critical stream protection
+- QPACK encoder and decoder stream instruction validation
+- Spec-correct error signaling with error codes on `FrameError` and `MessageError`
+- Suppress response body for HEAD requests per RFC 9114 §4.1
+- Allow `te: trailers` header in requests per RFC 9114 §4.2
+- Custom ALPN support (no longer hardcoded to `h3`)
+- `Stream` and `StreamEvent` abstractions to encapsulate C extension details
+- Dual-stack (IPv4/IPv6) listener support — fixes TLS handshake failures on macOS
+- Client `PUT` method
+- Integration test suite for curl HTTP/3
+
+### Fixed
+- Memory leaks: free `StreamContext` on `SHUTDOWN_COMPLETE`, free `ConnectionContext` on `CONNECTION_SHUTDOWN_COMPLETE`, close `EventQ`/`ExecContext`/`WakeFd` on shutdown
+- Double-free and handle leaks in C extension
+- `dispatch_to_ruby` safety with `rb_protect`; client use-after-free fix
+- Infinite loop on truncated varint in request/response parsers
+- Frame ordering: `DATA` before `HEADERS` now raises `FrameError`
+- `STOP_SENDING` / `STREAM_RESET` compliance — server properly cancels streams and resets send side
+- Control stream validation: reject duplicate settings, forbidden frame types, and reserved HTTP/2 types
+- QPACK static table index 57/58 casing (`includeSubDomains`)
+- Stale stream handle guard in cancel and C extension
+- Replaced `Thread.kill` with `Thread.raise(DrainTimeoutError)` for clean drain
+- Binary encoding for `buffer_data` and empty FIN handling
+- Linux/GitHub CI: use epoll instead of kqueue on non-Darwin platforms
+- Circular require warning
+
+### Changed
+- Reorganized gem structure: `protocol/`, `server/`, `transport/` directories
+- Server owns the 0-RTT policy
+- QPACK encoder uses O(1) static table lookup with multi-level caching
+- QPACK decoder uses string-based decoding with result caching
+- HTTP/3 parsers optimized with parse-level caching and lazy allocation
+- Varint encoding/decoding optimized with precomputed tables
+- HTTP/3 encoders handle framing only; QPACK handles field encoding (cleaner separation)
+- MsQuic custom execution mode with configurable worker pool and throughput settings
+
+### Limitations
+- Client does not reuse connections
+
+## [0.2.0] - 2025-12-17
+
+### Added
+- Graceful shutdown with GOAWAY frames (RFC 9114 compliant)
+- Streaming response support for lazy/chunked bodies
+- Flow control settings for backpressure management
+- Client HTTP verb helpers: `get`, `post`, `patch`, `delete`, `head`
+- Integration test suite
+- Benchmarking examples for Rails
+
+### Fixed
+- Memory leak: send buffers now freed on SEND_COMPLETE callback
+- Segfault in event loop when client_obj was invalid
+- Content-Type header handling for Rack compatibility
+- String concatenation performance using StringIO
+
+### Changed
+- `server.start` now blocks until shutdown (no separate `wait_for_connections` needed)
+- Refactored to global event loop architecture
+- Simplified server internals with Connection and QuicStream classes
+- Replaced debug puts with proper logging
+
+### Limitations
+- No server push or trailer support
+- No dynamic QPACK table (static table only)
+- Client does not reuse connections
+
+## [0.1.0] - 2025-10-28
+
+### Added
+- Initial HTTP/3 server implementation using Microsoft MSQUIC
+- HTTP/3 client for testing and development
+- Rack support
+- HTTP/3 frame encoding/decoding (DATA, HEADERS, SETTINGS)
+- QPACK header compression (static table support)
+- Bidirectional request/response streams
+- Request body buffering for large payloads

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in quicsilver.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    quicsilver (0.5.0)
+      console
+      localhost (~> 1.6)
+      logger
+      protocol-http (~> 0.49)
+      protocol-rack (~> 0.22)
+      rack (~> 3.0)
+      rackup (~> 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    benchmark-ips (2.14.0)
+    cibuildgem (0.3.0)
+      prism
+      rake-compiler
+      thor
+    console (1.34.3)
+      fiber-annotation
+      fiber-local (~> 1.1)
+      json
+    fiber-annotation (0.2.0)
+    fiber-local (1.1.0)
+      fiber-storage
+    fiber-storage (1.0.1)
+    io-stream (0.11.1)
+    json (2.15.2)
+    localhost (1.6.0)
+    logger (1.7.0)
+    minitest (5.27.0)
+    minitest-focus (1.4.0)
+      minitest (>= 4, < 6)
+    prism (1.9.0)
+    protocol-http (0.60.0)
+    protocol-rack (0.22.1)
+      io-stream (>= 0.10)
+      protocol-http (~> 0.58)
+      rack (>= 1.0)
+    rack (3.2.4)
+    rackup (2.2.1)
+      rack (>= 3)
+    rake (13.4.2)
+    rake-compiler (1.3.0)
+      rake
+    rake-compiler-dock (1.9.1)
+    thor (1.5.0)
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+  benchmark-ips (~> 2.12)
+  bundler (~> 2.0)
+  cibuildgem
+  minitest (~> 5.0)
+  minitest-focus (~> 1.3)
+  quicsilver!
+  rake (~> 13.0)
+  rake-compiler (~> 1.2)
+  rake-compiler-dock (~> 1.3)
+
+BUNDLED WITH
+   2.6.5

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Haroon Ahmed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.