Max size on JSON response

[setroc]

Hello, I recently made a Rest API, where in a specific route I send a JSON as a response. I would like to know if there is any limit to the size of the JSON that can be sent as a response by the server? is it possible to configure this?

[scaprile]

Well... I fail to see the "JSON" specifics in your question, you are just calling https://mongoose.ws/documentation/#mg_http_reply
Mongoose uses dynamic memory allocation. Your readJSON(), whatever it does, will return a const char *. mg_http_reply() will grab that string and try to put it on Mongoose buffer to be sent to TCP, The buffer will try to resize to fit the contents, and if it can't, you'll see an out of memory message in the log

mongoose/src/http.c

Lines 336 to 352 in d013e0f

	void mg_http_reply(struct mg_connection *c, int code, const char *headers,
	const char *fmt, ...) {
	va_list ap;
	size_t len;
	mg_printf(c, "HTTP/1.1 %d %s\r\n%sContent-Length: \r\n\r\n", code,
	mg_http_status_code_str(code), headers == NULL ? "" : headers);
	len = c->send.len;
	va_start(ap, fmt);
	mg_vxprintf(mg_pfn_iobuf, &c->send, fmt, &ap);
	va_end(ap);
	if (c->send.len > 16) {
	size_t n = mg_snprintf((char *) &c->send.buf[len - 15], 11, "%-10lu",
	(unsigned long) (c->send.len - len));
	c->send.buf[len - 15 + n] = ' '; // Change ending 0 to space
	}
	c->is_resp = 0;
	}

mongoose/src/printf.c

Lines 26 to 43 in d013e0f

	static void mg_pfn_iobuf_private(char ch, void *param, bool expand) {
	struct mg_iobuf *io = (struct mg_iobuf *) param;
	if (expand && io->len + 2 > io->size) mg_iobuf_resize(io, io->len + 2);
	if (io->len + 2 <= io->size) {
	io->buf[io->len++] = (uint8_t) ch;
	io->buf[io->len] = 0;
	} else if (io->len < io->size) {
	io->buf[io->len++] = 0; // Guarantee to 0-terminate
	}
	}
	static void mg_putchar_iobuf_static(char ch, void *param) {
	mg_pfn_iobuf_private(ch, param, false);
	}
	void mg_pfn_iobuf(char ch, void *param) {
	mg_pfn_iobuf_private(ch, param, true);
	}

mongoose/src/iobuf.c

Lines 17 to 42 in d013e0f

	int mg_iobuf_resize(struct mg_iobuf *io, size_t new_size) {
	int ok = 1;
	new_size = roundup(new_size, io->align);
	if (new_size == 0) {
	zeromem(io->buf, io->size);
	free(io->buf);
	io->buf = NULL;
	io->len = io->size = 0;
	} else if (new_size != io->size) {
	// NOTE(lsm): do not use realloc here. Use calloc/free only, to ease the
	// porting to some obscure platforms like FreeRTOS
	void *p = calloc(1, new_size);
	if (p != NULL) {
	size_t len = new_size < io->len ? new_size : io->len;
	if (len > 0 && io->buf != NULL) memmove(p, io->buf, len);
	zeromem(io->buf, io->size);
	free(io->buf);
	io->buf = (unsigned char *) p;
	io->size = new_size;
	} else {
	ok = 0;
	MG_ERROR(("%lld->%lld", (uint64_t) io->size, (uint64_t) new_size));
	}
	}
	return ok;
	}