wa_send.h

/*
 * One file off the card, a piece at a time.
 *
 * The size is taken before the first byte goes, so the response can say how
 * long it is (Content-Length); the file then has to deliver exactly that.
 * A read error, or a file that ends early or runs long -- a card pulled part
 * way -- ends the transfer as failed, and the response is cut off there: a
 * browser reports a download shorter than announced as failed.
 *
 * No piece is larger than the caller's buffer; nothing holds the whole file.
 *
 * Pure C, no ESP-IDF (Espressif Internet-of-Things Development Framework).
 *
 * SPDX-License-Identifier: MIT
 */
 
#ifndef RCBENCH_WA_SEND_H
#define RCBENCH_WA_SEND_H
 
#include <stdbool.h>
#include <stdint.h>
 
#include "wa_walk.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define WA_SEND_CHUNK 4096u
 
typedef struct {
    const wa_fs_t *fs;
    void          *file;
    uint64_t       size;   
    uint64_t       sent;
    bool           failed;
} wa_send_t;

bool wa_send_begin(wa_send_t *s, const wa_fs_t *fs, const char *path,
                   uint64_t size);

int32_t wa_send_next(wa_send_t *s, uint8_t *buf, uint32_t cap);

void wa_send_end(wa_send_t *s);
 
/*
 * The connection a response goes out on.
 *
 * A piece is offered to put(), which queues what fits and never waits.  When
 * nothing fits, wait() waits for room for at most a slice.  A transfer ends
 * when the receiver closes or the connection fails, when stop() says so,
 * and when the receiver takes nothing for WA_SEND_QUIET_MS: a receiver that
 * stops reading without closing would otherwise hold the server, which
 * answers one request at a time, for as long as it stays.
 */

#define WA_SEND_QUIET_MS 30000u
#define WA_SEND_SLICE_MS 250u

typedef enum {
    WA_WAIT_READY = 0, 
    WA_WAIT_IDLE,      
    WA_WAIT_GONE,      
} wa_wait_t;
 
typedef struct {
    int32_t   (*put)(void *ctx, const uint8_t *p, uint32_t n);
    wa_wait_t (*wait)(void *ctx, uint32_t ms);
    bool      (*stop)(void *ctx);
    uint32_t  (*now_ms)(void *ctx);
    void      *ctx;
} wa_sink_t;

typedef enum {
    WA_SEND_DONE = 0,     
    WA_SEND_GONE,         
    WA_SEND_QUIET,        
    WA_SEND_STOPPED,      
    WA_SEND_READ_FAILED,  
} wa_send_res_t;

wa_send_res_t wa_sink_all(const wa_sink_t *k, const void *data, uint32_t n);

wa_send_res_t wa_send_run(wa_send_t *s, uint8_t *buf, uint32_t cap,
                          const wa_sink_t *k);

const char *wa_send_res_name(wa_send_res_t r);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RCBENCH_WA_SEND_H */