json_writer.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
// json_writer.h — accumulate a JSON (or any text) response and flush it to a socket in ONE
// write, so it leaves as full-size TCP segments instead of many tiny per-field/per-byte ones.
//
// Why: handlers that build JSON with repeated fdprintf(sock, ...) produce hundreds/thousands of
// 1-2 byte TCP segments. Under concurrent NTP load a single lost tiny segment triggers a ~1 s TCP
// retransmit timeout that freezes the shared ethernet TX path (NTP included). Fewer, larger
// segments make that far less likely. (The pjs-based handlers use SendJsonBody() in
// webfunctions.cpp for the same reason; this is the equivalent for fdprintf-style handlers.)
//
// Usage:
//     JsonWriter jw(sock);                 // grabs a heap buffer (grows as needed)
//     jw.Printf("{\"a\":%d,", x);
//     ...
//     jw.Printf("}");
//     // flushed automatically when jw goes out of scope (or call jw.Flush()).
//
// On allocation failure it degrades gracefully to per-call socket writes (never drops output).
 
#ifndef NTP1061_JSON_WRITER_H
#define NTP1061_JSON_WRITER_H
 
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <iosys.h>   // writeall
 
class JsonWriter
{
    int   m_sock;
    char *m_buf;
    int   m_cap;
    int   m_len;
 
public:
    explicit JsonWriter(int sock, int initCap = 2048)
        : m_sock(sock), m_buf((char *)malloc(initCap)), m_cap(m_buf ? initCap : 0), m_len(0) {}
 
    ~JsonWriter() { Flush(); if (m_buf) free(m_buf); }
 
    void Printf(const char *fmt, ...)
    {
        va_list ap;
 
        // No buffer (allocation failed): write this piece straight to the socket.
        if (!m_buf)
        {
            char tmp[256];
            va_start(ap, fmt);
            int n = vsnprintf(tmp, sizeof(tmp), fmt, ap);
            va_end(ap);
            if (n > 0) writeall(m_sock, tmp, (n < (int)sizeof(tmp)) ? n : (int)sizeof(tmp) - 1);
            return;
        }
 
        for (;;)
        {
            va_start(ap, fmt);
            int need = vsnprintf(m_buf + m_len, m_cap - m_len, fmt, ap);
            va_end(ap);
 
            if (need < 0) return;                       // encoding error
            if (m_len + need < m_cap) { m_len += need; return; }   // fit
 
            // Did not fit: grow and retry.
            int nc = m_cap * 2;
            while (m_len + need + 1 > nc) nc *= 2;
            char *nb = (char *)realloc(m_buf, nc);
            if (!nb)
            {
                // Out of memory: flush what we have, then write this piece directly.
                Flush();
                char tmp[256];
                va_start(ap, fmt);
                int n = vsnprintf(tmp, sizeof(tmp), fmt, ap);
                va_end(ap);
                if (n > 0) writeall(m_sock, tmp, (n < (int)sizeof(tmp)) ? n : (int)sizeof(tmp) - 1);
                return;
            }
            m_buf = nb;
            m_cap = nc;
        }
    }
 
    void Flush() { if (m_buf && m_len > 0) { writeall(m_sock, m_buf, m_len); m_len = 0; } }
};
 
#endif // NTP1061_JSON_WRITER_H