Repository navigation
Releases
Releases · zystem/nimgrpc
0.7.0
Added
- A coverage-guided fuzzer,
tools/libfuzz.nim(libFuzzer, built with clang, AddressSanitizer and UBSan;tools/libfuzz.sh TARGET [SECONDS]), over the seven targets oftools/fuzz.nim: gRPC framing, gzip, three Protobuf message types, the HTTP/2 server session and, new, the HTTP/2 client session (what a server may send to a client with a call open andmaxHeaderListBytesset). The targets and the seeds moved totools/fuzztargets.nim, shared by both. The weeklyfuzz.ymlruns it once per target and keeps the corpus in the cache. Run on 2026-11-18, 30 s per target on a development machine (the client session on 2026-11-19, 40 s): no finding. It instruments our code only; nghttp2 and zlib are linked as built. ClientLimitsfordialanddialAsync(blocking and chronos):handshakeTimeoutMs(20 s by default) closes a connection whose server accepted the TCP connection and does not finish TLS and send its first SETTINGS (before, a call with no deadline waited for ever);maxHeaderListBytes(64 KiB by default) resets a call whose response headers or trailers weigh more.tests/tclientlimits.nim.
Fixed
- A stream that nghttp2 reset while the session framed the RST_STREAM (a callback that fails, on a connection with nothing more to read) was reported closed only when the next bytes arrived, so a call could wait for ever. The reader looks at the session's events again after it has queued the output, on both adapters.
Changed
- The weekly soak test fails over 34 KiB per held connection (plain) and 96 KiB (TLS), from 60 and 100: the measured figures are 28 and 86 KiB since the stream tables were made small, and a regression of 10 KiB is now seen.
docs/async.mdgave about 75 KiB for TLS; the soak runs had always measured 96, and it is 86 now. - Less memory per connection on the chronos server: the tables of open streams start with 4 slots instead of 64. A server with 1,000 connections, each with a call open, holds 30 MiB instead of 40 (38 KiB to 28 KiB per connection; 5,000: 142 MiB instead of 191). Measured on 2026-11-18, plain HTTP/2; TLS not measured.
Upgrade notes: docs/upgrading.md (section 0.7.0).
0.6.0
Added
- Interceptors: code that runs around every call, for authentication by metadata, logging and metrics in one place.
addInterceptoron a server (GrpcServer,AsyncGrpcServer) and on a channel (GrpcChannel,AsyncChannel). A server interceptor sees the path, the metadata and the deadline of a call to a registered method before its request is decoded, may set response metadata, and either lets the call proceed or refuses it with a status; after the handler it sees what the handler raised. A client interceptor may change the metadata and the deadline of everyunaryCallandnewCallon the channel, those of generated clients included, and sees the outcome of a unary call. Interceptors see no messages. An interceptor that swallows the error of a call does not turn it into OK. With no interceptor added nothing changes. How to: docs/interceptors.md; example:examples/interceptors.nim. Tests:tests/tinterceptors.nim.
Changed
- nghttp2 1.71.0 (from 1.68.1) in the CI,
tools/build-nghttp2.shand the build instructions. The library's code did not change for it. Run against it on 2026-11-16: the 25 test files,tools/hostile.sh(both servers, 0 failed), the interop cases with grpc-go v1.76.0 in both directions in plaintext, TLS and mutual TLS (blocking and chronos peers), and h2spec 2.6.0 (the same results as with 1.68.0). The lowest version that builds is still 1.61.0. - The CI checks the SHA-256 of the nghttp2 archive it downloads, as
tools/build-nghttp2.shalready did. - h2spec:
tools/h2specasyncandtools/h2specservertake a delay before their answer,tools/conformance.shuses 100 ms for both, and with it the timing artefacts of the test servers no longer occur, sotools/h2spec_check.pyaccepts nothing but the nine differences between RFC 7540 and RFC 9113; docs/h2spec.md has the runs. - chronos server:
stopstarts closing every connection before it waits for any of them (it closed them one after another).
Fixed
- A connection no longer holds a Nim reference to the
TlsConfigit was made with (ConnObj.tlsConf, blocking and chronos): the C side counts the owners of the configuration atomically since 0.3.1, so the reference only added reference-count traffic on an object that the caller's thread also uses, and aConnis freed on the thread that closes it. A blockingGrpcChannelholds ashareof the configuration instead of the caller's object, soclosemay run on a thread other than the one that dialled without touching the count of the object that thread passed todial. Test:tests/ttls.nim("channels dialled on several threads"); it passes on the old code too (the race is not reproduced), it guards the new ownership. - chronos adapter (client and server): a connection was closed with the socket still holding bytes that had not been read, when the peer sent something right behind the frame that ended the connection (a PING behind its GOAWAY, say). The kernel then sends a TCP reset instead of an orderly end, and a reset can cost the peer what it has not read yet. A connection that is being closed now ends its own side first, throws away what the peer still sends until the peer ends its side, for one second and one mebibyte at most, and closes the socket after that; a connection whose socket failed is closed at once as before. Found by h2spec (test 7, about one run in ten); the blocking adapter did not have it. Tests:
tests/tasynch2.nim(suite "how a connection is closed"). - chronos adapter: a connection whose peer had sent GOAWAY, with no call left, stayed open until the peer closed it if the GOAWAY arrived while the connection still had bytes to write: whether the session had finished was looked at only when input arrived. It is looked at after each write too. Found by the test above (about one run in ten of the file hung).
Upgrade notes: docs/upgrading.md (section 0.6.0).
0.5.1
Added
- Examples:
examples/hello.nim(a server and a client in one process, no generated code),examples/greeter/(a service fromhello.protothrough generated code: a server with health and reflection, a client, and both on chronos), and examples/README.md, a tutorial with what every command prints. tools/build-nghttp2.sh: downloads nghttp2 1.68.1, checks its SHA-256 and builds it intodeps/nghttp2of the clone, without root. Builds inside the repository find it there, or whereNGHTTP2_PREFIXpoints;-d:nghttp2Prefixon the command line still wins. A program that uses the installed library is not affected.tests/texamples.nim: builds and runs everynim c -r examples/...shown inREADME.mdandexamples/README.mdand compares the output with the document; whereprotocis installed it also checks thathello_pb.nimis what the plugin generates.- docs/README.md: an index of the documents with the kind of each page.
- docs/troubleshooting.md: every message of the library with its meaning and what to do; docs/faq.md; docs/production.md, a checklist before a server faces real clients; docs/supported-versions.md.
tests/tdocs.nim: fails when a message the library can raise has no line in the troubleshooting page, makes 17 common failures happen (a closed port, TLS against plaintext, a wrong CA or name, a missing client certificate, a full server, a message over the limit and others) and compares their text with the page, compares the supported-versions page withnimgrpc.nimble, the CI workflow and the source, and checks that the index lists every page.
Changed
- README: starts with what the library is, when to use it and when not, a picture of the parts, a first run with its output, a table of ways to install, a glossary and the documents by purpose; the description of the API follows unchanged, the status went below it.
- Encoder (
nimgrpc/protobuf, used by generated code): abytesorstringfield of 64 KiB or more is copied once into a buffer of the size of the message. Before, the buffer was reallocated when the field went in and again when the length in front of it needed more than one byte, so a message with one 4 MiB field cost about 10 MiB while it was encoded. The wire form is the same and generated code does not have to be regenerated. This was the library's part of the pentest's finding 4 (responses a client asks for and never reads): 200 such calls asking for 4 MB responses held 2.53 GB before and 1.76 GB after (measured locally on 2026-11-15, blocking server, release build). What is left is the handler's own message and one encoded copy per waiting handler; docs/threat-model.md says how to bound it. Tests:tests/tcodec.nim(suite "large values").
Fixed
- Blocking server: a unary request much larger than
maxMessage(6 MB and more against the default 4 MiB) left the client waiting until its deadline, and without a deadline for ever. The server answered RESOURCE_EXHAUSTED when the limit was passed and read no more, so the window of the stream stayed shut and the client could not finish sending to see the answer. The server now resets such a stream with NO_ERROR once its response is complete, as the chronos server already did and as other gRPC servers do; the client gets RESOURCE_EXHAUSTED at once. Found bytests/tdocs.nimin CI. Tests:tests/thostile.nim. - Documents that said what the code does not do: docs/threat-model.md said a handler gets the peer's certificate (it gets the metadata only; mutual TLS admits a client, it does not name it); docs/security-requirements.md said there are no connection quotas (
maxConnectionsandmaxConnectionsPerIpexist since 0.2.0 and 0.4.0); it andSECURITY.mdcalled the version 0.0.x. - README: the health snippet
let health = newHealth()does not compile besideimport nimgrpc/health(the name is the module's); it islet h = newHealth().
Upgrade notes: docs/upgrading.md (section 0.5.1).
0.5.0
Security
- TLS: a peer that negotiates no ALPN protocol is refused on both sides. A client that sent no ALPN extension at all (
openssl s_client -tls1_2without-alpn) used to finish the handshake, because BearSSL's own check only fails when a client offers other protocols; the server now ends the handshake with an alert, and a client refuses a server that selects no protocol ("peer did not negotiate ALPN h2"). Resumed sessions are unchanged (found by a local pentest). Tests:tests/ttls.nim. - Both servers: a handler exception that is not a
GrpcErrorwas sent to the client as UNKNOWN with its text, which can hold file paths, queries and other internals. The client now getsinternal error. AGrpcErrorkeeps its own code and message. NewsetErrorHook(both servers, beforestart) calls a hook with the method path and the exception, so the operator can still log it; without a hook nothing is written anywhere. - nghttp2: CI, the README and the build pages now use 1.68.1 (was 1.68.0). It fixes CVE-2026-27135 (GHSA-6933-cjhr-5qg6, High): an assertion failure after the session was terminated while handling an ALTSVC, PRIORITY_UPDATE or user-defined extension frame. This library enables none of those frames and never terminates a session from a callback, so a program linked with 1.68.0 is not known to be reachable; rebuild nghttp2 at 1.68.1 all the same. The minimum that compiles stays 1.61.0.
- zlib 1.4 (2026-11-04) fixes several memory errors (CVE-2026-85091 and others) in
gzwrite,inflateGetDictionary,inflateSync,inflatePrime,deflatePrime,inflateBack,gzseekanddeflateResetKeep. The library calls none of them (onlydeflateInit2,deflateBound,deflate,inflateInit2,inflateand theirEnd), so nothing changes here; zlib is the system's and is updated with it.
Added
tools/hostile.sh(tools/hostile.py,tools/hostiletarget.nim): a hostile client in raw HTTP/2 frames against the blocking and the chronos server: nested Protobuf groups, a wire type that does not exist, Rapid Reset, CONTINUATION, PING and SETTINGS floods, oversized headers, a 4 GB length prefix, a gzip bomb, random frames, 400 calls opened and left (unary,Health/Watch, streaming), 300 MB on a stream nobody reads, 500 idle connections. After each attack an ordinary call must be answered and the server must not have grown past its bound. These are the attacks of the pentest of 2026-11-14, kept so that what they found does not come back.tools/conformance.sh: h2spec against both HTTP/2 adapters (a failure that is not one of the known ones of docs/h2spec.md fails it) and grpcurl against server reflection.- The workflow
Hostile clientruns both once a week and when their files change; a failure of the weekly run opens an issue.
Changed
- Both servers and both clients: the content-type must be
application/grpc, or that followed by+or;(application/grpc+proto).application/grpcxand other look-alikes get HTTP 415 from a server and fail a client call. - Both servers: a
grpc-timeoutheader that is present but malformed (-1S,5x) ends the call with INTERNAL ("malformed grpc-timeout") before the handler runs; it used to mean no deadline. A call without the header still has no deadline.
Upgrade notes: docs/upgrading.md (section 0.5.0).
0.4.0
Security
- Blocking adapter (server and client): received body bytes were acknowledged to the peer as soon as they arrived, so a stream whose reader did not read grew without limit: 300 MB sent on one
Health/Watchcall, whose handler reads one message and no more, took a server to 587 MB (found by a local pentest, 2026-11-14). Flow control is now manual, as on the chronos adapter: the window of a stream reopens only as its reader takes the bytes (one stream holds at most 1 MiB unread), and the window of the connection reopens at once until 8 MiB wait unread in all its streams. - Blocking server: a client could use up every worker thread without sending a message. Each call took a worker when its HEADERS arrived, so 400 calls opened and left alone on 4 connections stopped a server with the default 256 workers for everybody (same pentest). A unary call now takes its worker only when its request message has arrived; a call that waits costs no thread. Streaming calls still take a worker from their start; what bounds them is below.
Health/Watchand server reflection on the blocking server keep a worker per call for as long as the client stays:newHealth(maxWatches = 64)andnewReflection(maxStreams = 16)now limit how many run at once (one more gets RESOURCE_EXHAUSTED; 0 for no limit).CheckandListare not limited.
Added
- CI runs the tests, plain and under AddressSanitizer, on Nim 2.4.0 too (besides 2.2.12 and 2.2.14).
Limits.maxCallMs(both servers; 0, off, by default): the longest a call may last whatever deadline the client asked for. Past it the server resets the call (the handler sees DEADLINE_EXCEEDED, the client CANCELLED). It bounds a streaming call that a client opens and leaves quiet.Limits.maxConnectionsPerIp(both servers; 0, off, by default): connections served at once from one address; one more is closed at once.tests/thostile.nim: calls left without a message, large unary messages side by side,maxCallMs, the limits ofWatchand reflection,maxConnectionsPerIp;tests/tblocking.nim: a stream nobody reads holds one window and the other streams go on.
Changed
Limits.handshakeTimeoutMsis 20 seconds by default (was 120): on the blocking server a connection costs two threads from the moment it is accepted, and one that sends nothing kept them for two minutes.- The blocking server no longer ends the program when the system refuses a new thread: the call or the connection waits for a thread that exists.
Upgrade notes: docs/upgrading.md (section 0.4.0).
0.3.1
Security
nimgrpc/health: a request (or, for the client, a response) with a protobuf wire type that does not exist (6 or 7) ended the program with a RangeDefect: the 7-byte body00 00 00 00 02 0e 00sent to/grpc.health.v1.Health/Checkstopped any server that registered the health service, with no authentication. In 0.3.0 only (the service is new there). The decoders now raiseProtobufError, which the server answers with INVALID_ARGUMENT.- A small request could crash a server, or a client reading a reply: the Protobuf decoder had no limit on how deep messages nest.
skipFieldskipped a group (an unknown proto2 start-group, two bytes0xC3 0x3Efor field 1000) by recursing, so a body of such pairs made it recurse once per pair; 200 KB overflowed the stack of a blocking-server worker thread, anddecodeHealthRequeston 600 KB overflowed the 8 MB main stack, which is where the chronos server runs handlers. Messages nested inside messages (a recursive type such asmessage Node { Node child = 2; }) recursed the same way:Node.decodeof a 700 000-level chain of 3.5 MB crashed with a segmentation fault (run on the code of 0.3.0, a release build). Every program that decodes Protobuf it did not write is affected, all versions up to 0.3.0: the generateddecode, the health service, reflection and the well-known types. The message limit (4 MiB by default) did not help, as 2 000 000 groups fit in it. Fixed: decoding stops withProtobufError("message nested too deeply") pastmaxNestingDepth(100, the limit of protobuf-go and C++ protobuf); a server answers INTERNAL, as for any message it cannot decode. Groups are now skipped without recursion. Generated code needs no regeneration: it reads a nested message throughsubReader, which now carries and checks the depth. Tests:tests/tcodec.nim(suite "nesting limit"),tests/tgrpc.nimandtests/tasyncgrpc.nim(a 200 KB group bomb to a server, then a normal call), and a seed intools/fuzz.nim.
Added
- TLS: a server dialled by an IP address ("10.0.0.5", "::1", "[::1]"), or with
serverNamean IP address, is checked against the iPAddress entries of its certificate (subjectAltName), as RFC 6125 says; before, only DNS names could be verified, so a service on an address without a name could not use TLS with verification. No SNI is sent for an IP address (RFC 6066). Tests:tests/ttls.nim.
Fixed
TlsConfigshared by several threads: a configuration handed to more than one thread was a Nimrefcopied between them, and ORC counts references without atomics, so it could be freed while a handshake still read its trust anchors (SIGSEGV in a program that connects afresh from several threads; found by a soak run). The configuration now has an atomic count of owners and each connection holds one.share(c)gives a thread or a connection its own object over the same configuration and the same resumable sessions; use it when aTlsConfigcrosses threads.
Upgrade notes: docs/upgrading.md (section 0.3.1).
0.3.0
Security
- nghttp2 1.61.0 or later is required (was 1.57.0), which limits the CONTINUATION flood (CVE-2024-28182); the build fails with an
#erroragainst an older header. The limits that nghttp2 applies by default to CONTINUATION frames (8 after a HEADERS frame) and to RST_STREAM (a burst of 1000, then 33 a second: Rapid Reset, CVE-2023-44487) are now set by the library itself, andtests/th2session.nimfeeds a server the frames of a flood.
Added
- Happy Eyeballs (RFC 8305) in
dial, blocking and chronos: the addresses of a name are tried in the order of the resolver's first family, then the families alternating, and when an attempt has not answered within 250 ms (or has failed) the next address is tried alongside it; the first to connect wins. A dead IPv6 route no longer costs a wholeconnectTimeoutMsbefore IPv4 is tried. Tests:tests/teyeballs.nim. unaryCall(blocking and chronos) sends a call again, up to twice within its deadline (20 ms, then 40 ms apart), when the server refused it without starting on it: REFUSED_STREAM, which is also what nghttp2 reports for a stream a GOAWAY left unprocessed (a draining server, a connection rotated bymaxConnectionAgeMs, the first burst before SETTINGS). The error of the last attempt has the newGrpcError.unprocessedset. Calls that may have run are never repeated, and streaming calls are not retried (newCallalready tries a fresh connection once). Tests:tests/tretry.nim.nimgrpc/reflection: server reflection (grpc.reflection.v1andv1alpha) for both servers, so thatgrpcurlandgrpc_clican list the services of a server (always) and describe them (with their descriptors):newReflection(),addFileDescriptor,srv.register(refl).protoc-gen-nimwrites the serializedFileDescriptorProto(without the source info protoc adds) into a module when it runs with--nim_opt=descriptor, as the constantfileDescriptorProto; the well-known types are built in (tools/gen_wkt_descriptors.py).file_by_filename,file_containing_symbol(messages, nested types, enums and their values, fields, services, methods) answer with the file and the imports the reflection holds; extensions are not supported. Servers gainserviceNames. Checked against grpc-go's own reflection client (tests/interop/reflection_interop.sh: it builds the descriptors it gets). Tests:tests/treflection.nim.nimgrpc/healthclient: the asking side of the health service, on blocking and chronos channels:checkHealth(NOT_FOUND ishsServiceUnknown),isServing,waitServingandwatchHealth/next/close. Test:tests/thealthclient.nim. The health service is checked against grpc-go's own client (tests/interop/health_interop.sh: Check, NOT_FOUND, List, Watch; all pass with grpc-go 1.84.0).nimgrpc/health: the gRPC health checking service (grpc.health.v1.Health:Check,Watch,List) for both servers, which is what the native gRPC probe of Kubernetes, Envoy andgrpc_health_probecall.newHealth(),srv.register(health),health.setStatus(service, hsNotServing),health.shutdown()beforestop.Healthis a handle to memory shared by all threads (copy it, hand it to threads,closefrees it). Message bytes checked againstprotocand the officialhealth.proto. Test:tests/thealth.nim.- Rotation of server connections:
Limits.maxConnectionAgeMs(age, give or take 10%) andLimits.maxConnectionIdleMs(no call for that long), both off by default, drain a connection: an advisory GOAWAY, the final one a moment later, the calls in progress finish, then the connection closes;Limits.maxConnectionAgeGraceMs(30 s) is how long they get. Behind a load balancer this spreads long-lived clients over new instances and makes them resolve names again (connections are balanced, not calls, in Kubernetes); clients of this library dial a new connection for the next call on their own. Blocking and chronos servers. Tests:tests/tconnage.nim,tests/tconnageasync.nim. - TCP keepalive and a limit for the handshake. Every connection, client and server, blocking and chronos, gets the system's TCP keepalive (
Keepalive.tcpSecs, 15 seconds by default, 0 turns it off): a peer that has vanished is found and a NAT or load balancer does not forget a quiet connection. A server closes a connection whose peer has not completed the TLS handshake and sent its preface and first SETTINGS withinLimits.handshakeTimeoutMs(120 seconds by default, 0 for no limit); until now such a connection, which holds two threads on the blocking server, stayed until the peer left. Test:tests/thandshake.nim(it reads the keepalive timers of the sockets from/proc/net/tcp). See docs/threat-model.md. - IPv6. A server listens on an IPv6 address (
address = "::1"), or on both families (address = "::", dual-stack); the blockingdialtakes IPv6 literals ("::1", "[::1]") and tries every address a name resolves to, IPv6 ones included, in the resolver's order, each withconnectTimeoutMs. The:authorityof an IPv6 host is bracketed. Until now the sockets were IPv4 only: a server could not bind::1and a host with only an AAAA record could not be reached. The chronos adapter already resolved both families and now has tests. Test:tests/tipv6.nim(skipped without an IPv6 loopback). shutdown(GrpcChannel): closes every connection of the channel and frees nothing. Calls in progress, on any thread, fail at once, and new calls are refused. A program whose threads wait in calls can stop them with it, join them, and only thenclosethe channel. Safe from any thread and more than once.nimble coverage/tools/coverage.sh: statement coverage ofsrc/nimgrpcfrom gcov (the Nim compiler's#linedirectives make it report.nimlines); 88.8% now, CI fails under 80% (jobtests (coverage, Nim 2.2.12)). See docs/building.md.- The builds of this repository honour
CC,CFLAGSandLDFLAGSfrom the environment (added to the flags in use); see docs/building.md, which also says how debug information, repeatable builds and installation are handled.
Fixed
- Deadlines and timed waits of the blocking adapter counted on
CLOCK_REALTIME, so a step of the system clock (NTP, a resumed virtual machine) shortened or stretched a timeout. They count onCLOCK_MONOTONICnow (Linux; other systems keep the wall clock). Test:tests/tblocking.nim, which fails with the old pairing of clocks. close(GrpcChannel)from one thread while a call of another thread was waiting inrecvfreed the connection under that call: the call that then failed touched freed memory (found with AddressSanitizer in a program that closed its channel to end its reader thread; the corrupted heap ended in a thread spinning for ever in the allocator).closenow waits (up to ten seconds) for the calls that are inside a procedure of the library on another thread to leave it, and does not free the channel if one does not. A call that has not entered the library yet cannot be waited for: do not start calls on a channel that is being closed. Test:tests/tchannelclose.nim.
Upgrade notes: docs/upgrading.md (section 0.3.0).
0.2.1
Added
- docs/releasing.md: how a maintainer makes a release (the release pull request, the signed tag, the GitHub release), and
tools/release_notes.sh X.Y.Z, which prints the notes of a version from the changelog. nimble lint(run in CI): the compiler's style check as an error and warnings as failures over the library, the plugin, the tests and the tools. The generated code is exempt from the style check (proto names keep their spelling;protoc-gen-nimnow writes{.push styleChecks: off.}). A release build of the repository compiles its C with-fstack-protector-strong -D_FORTIFY_SOURCE=2.- Release tags are signed (SSH key), from this release on (the tags up to 0.2.0 are not); how to verify one is in SECURITY.md, the public key in
docs/allowed_signers.
Fixed
- The fuzz workflow took its
secondsinput into the text of a shell command; it is now passed as an environment variable and checked to be a number. tests/tlimits.nimsometimes failed under AddressSanitizer (a 16 KiB leak of a worker thread's cycle roots, seen in CI on Nim 2.2.14): the test opened its burst of calls on a new connection, the server refused the excess with REFUSED_STREAM (which the test did not check), and the exceptions of the refused calls left cycle roots in the threads of the test. The test now makes one call first and checks every reply. The behaviour itself is documented in docs/upgrading.md.examples/static_client.nimimportednimgrpc/testing/test_pb, which the 0.1.0 rename had changed by mistake; it isgrpc/testing/test_pb(the generated code of the test protos,-p:tests/gen).
Upgrade notes: docs/upgrading.md (section 0.2.1).
0.2.0
Added
Limitsfor both servers (limitsofnewGrpcServer,newAsyncGrpcServer,newStreamServer,newAsyncStreamServer):maxConcurrentStreams(announced to clients as SETTINGS_MAX_CONCURRENT_STREAMS, 100 by default; a client that ignores it gets REFUSED_STREAM),maxConnections(a connection past the limit is closed at once; no limit by default) andmaxConnectionBuffer(body bytes queued on all streams of a connection that the socket has not taken, 16 MiB by default; a sender waits above it). Tests intests/tlimits.nimandtests/tasynclimits.nim.
Security
- nghttp2 1.57.0 or later is required, which limits the Rapid Reset attack (CVE-2023-44487): the build fails with an
#erroragainst an older header, and a test checks the linked library's version.
Changed
- A server now announces 100 concurrent streams per connection; before, nghttp2's default (no limit) applied. Set
Limits(maxConcurrentStreams: 0)for the old behaviour. See docs/upgrading.md.
Upgrade notes: docs/upgrading.md (section 0.2.0).
0.1.0
Changed
- The nimble package is now
nimgrpc(nimgrpc.nimble) and so are the modules:import grpcbecomesimport nimgrpc,import grpc/protobufbecomesimport nimgrpc/protobuf, and so on. The namegrpcin the nimble directory belongs to another project, and two packages with agrpcmodule cannot be used in one build. Regenerate the code of your.protofiles with the newprotoc-gen-nim. See docs/upgrading.md.
Upgrade notes: docs/upgrading.md (section 0.1.0).