Let a receiver whose app is full keep what came, and say so

A link's delivery the app had no room for was handed over again at the
next turn: a receiver over its memory budget would refuse the same
records as fast as the owner could apply them. And its sender, seeing
records received but not stored for a second, sent the whole window
again every second.

Now a host says a delivery found it full (PureLinkDone.full). The
receiver keeps the records and hands them over again after a pause, 100
ms doubling to 500 ms, and meanwhile its STORED frames carry flag 2: the
app is full and what came is kept. A sender hearing it starts its
one-second wait for the save again, and sends none of it again. The
spec (012) says both sides; the pause is a local choice that must stay
under the sender's wait.

pure_link_done takes the PureLinkDone itself. test-link's new case keeps
the app full for 5 s: 12 hand-overs meanwhile, taken within 0.5 s of
having room, and no record sent again (21,640 without the flag).

1 files changed, 2 insertions, 2 deletions

diff --git a/link/link.c b/link/link.c
index a834991..37a5a2a 100644
--- a/link/link.c
+++ b/link/link.c
@@ -554,7 +554,7 @@ bool pure_link_serve(PureLinkListener *s, char *error, size_t size) {
     return true;
 }
 
-void pure_link_done(PureLinkListener *s, void *token, uint64_t heard, bool stored, bool gap) {
+void pure_link_done(PureLinkListener *s, PureLinkDone done) {
     pthread_mutex_lock(&s->lock);
     if (s->done_count == s->done_capacity) {
         size_t capacity = s->done_capacity ? 2 * s->done_capacity : 16;
@@ -563,7 +563,7 @@ void pure_link_done(PureLinkListener *s, void *token, uint64_t heard, bool store
         s->done = grown;
         s->done_capacity = capacity;
     }
-    s->done[s->done_count++] = (PureLinkDone){token, heard, stored, gap};
+    s->done[s->done_count++] = done;
     pthread_mutex_unlock(&s->lock);
     wake(s->wake);
 }