contrib: sync csnippets

Signed-off-by: He Xian <hexian000@outlook.com>

Author: hexian000

contrib/csnippets/net/url.c

@@ -2,8 +2,8 @@
  * This code is licensed under MIT license (see LICENSE for details) */
 
 #include "url.h"
+#include "utils/ascii.h"
 
-#include <ctype.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -102,33 +102,39 @@ escape(char *buf, size_t buf_size, const char *str, const size_t len,
 	return cap - buf_size;
 }
 
-static size_t escape_host(
+#define S_UNRESERVED "-_.~"
+#define S_SUB_DELIMS "!$&'()*+,;="
+#define S_PCHAR S_UNRESERVED S_SUB_DELIMS ":@"
+
+static size_t escape_hostport(
 	char *buf, const size_t buf_size, const char *host, const size_t len)
 {
 	/* RFC 1738, RFC 2732 */
 	return escape(
-		buf, buf_size, host, len, "-_.~!$&'()*+,;=:[]<>\"", false);
+		buf, buf_size, host, len, S_UNRESERVED S_SUB_DELIMS ":[]",
+		false);
 }
 
 static size_t escape_userinfo(
 	char *buf, const size_t buf_size, const char *userinfo,
 	const size_t len)
 {
-	return escape(buf, buf_size, userinfo, len, "-_.~$&+,;=", false);
+	return escape(
+		buf, buf_size, userinfo, len, S_UNRESERVED S_SUB_DELIMS ":",
+		false);
 }
 
 static size_t escape_query(
 	char *buf, const size_t buf_size, const char *query, const size_t len)
 {
-	return escape(buf, buf_size, query, len, "-_.~", true);
+	return escape(buf, buf_size, query, len, S_PCHAR "/?", true);
 }
 
 static size_t escape_fragment(
 	char *buf, const size_t buf_size, const char *fragment,
 	const size_t len)
 {
-	return escape(
-		buf, buf_size, fragment, len, "-_.~$&+,/:;=?@!()*", false);
+	return escape(buf, buf_size, fragment, len, S_PCHAR "/?", false);
 }
 
 size_t
@@ -208,7 +214,7 @@ size_t url_build(char *buf, size_t buf_size, const struct url *url)
 				APPEND(url->userinfo);
 				APPENDCH('@');
 			}
-			APPENDN(escape_host(
+			APPENDN(escape_hostport(
 				buf, buf_size, url->host, strlen(url->host)));
 		}
 		if (url->path != NULL) {
@@ -274,14 +280,6 @@ static bool unescape(char *str, const bool space)
 	return true;
 }
 
-static inline char *strlower(char *restrict s)
-{
-	for (unsigned char *p = (unsigned char *)s; *p != '\0'; ++p) {
-		*p = tolower(*p);
-	}
-	return s;
-}
-
 bool url_parse(char *raw, struct url *restrict url)
 {
 	/* safety check */

contrib/csnippets/utils/CMakeLists.txt

@@ -6,6 +6,7 @@ target_sources(csnippets
     "${CMAKE_CURRENT_SOURCE_DIR}/slog.c"
     PUBLIC
     "${CMAKE_CURRENT_SOURCE_DIR}/arraysize.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/ascii.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/buffer.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/debug.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/formats.h"

contrib/csnippets/utils/ascii.h

@@ -0,0 +1,70 @@
+/* csnippets (c) 2019-2025 He Xian <hexian000@outlook.com>
+ * This code is licensed under MIT license (see LICENSE for details) */
+
+#ifndef UTILS_ASCII_H
+#define UTILS_ASCII_H
+
+#define isascii(c) (((c) & ~0x7f) == 0)
+
+#define isdigit(c) ('0' <= (c) && (c) <= '9')
+#define isalpha(c) (('A' <= (c) && (c) <= 'Z') || ('a' <= (c) && (c) <= 'z'))
+#define isalnum(c) (isdigit(c) || isalpha(c))
+#define isspace(c)                                                             \
+	((c) == '\t' || (c) == '\n' || (c) == '\v' || (c) == '\f' ||           \
+	 (c) == '\r' || (c) == ' ')
+#define iscntrl(c) (isascii(c) && ((c) <= '\x1f' || (c) == '\x7f'))
+#define islower(c) ('a' <= (c) && (c) <= 'z')
+#define isupper(c) ('A' <= (c) && (c) <= 'Z')
+#define isprint(c) ('\x20' <= (c) && (c) <= '\x7e')
+#define isgraph(c) ('\x21' <= (c) && (c) <= '\x7e')
+#define ispunct(c) (isgraph(c) && !isalnum(c))
+#define isxdigit(c)                                                            \
+	(isdigit(c) || ('A' <= (c) && (c) <= 'F') || ('a' <= (c) && (c) <= 'f'))
+#define isblank(c) ((c) == ' ' || (c) == '\t')
+
+#define tolower(c) ('A' <= (c) && (c) <= 'Z' ? (c) - 'A' + 'a' : (c))
+#define toupper(c) ('a' <= (c) && (c) <= 'z' ? (c) - 'a' + 'A' : (c))
+
+static inline char *strlower(char *restrict s)
+{
+	for (unsigned char *p = (unsigned char *)s; *p; p++) {
+		*p = tolower(*p);
+	}
+	return s;
+}
+
+static inline char *strupper(char *restrict s)
+{
+	for (unsigned char *p = (unsigned char *)s; *p; p++) {
+		*p = toupper(*p);
+	}
+	return s;
+}
+
+static inline char *strtrimleftspace(char *restrict s)
+{
+	const unsigned char *p = (unsigned char *)s;
+	while (*p && isspace(*p)) {
+		p++;
+	}
+	return (char *)p;
+}
+
+static inline char *strtrimrightspace(char *restrict s)
+{
+	unsigned char *e;
+	for (e = (unsigned char *)s; *e; e++) {
+	}
+	e--;
+	while ((unsigned char *)s < e && isspace(*e)) {
+		*e-- = '\0';
+	}
+	return s;
+}
+
+static inline char *strtrimspace(char *restrict s)
+{
+	return strtrimrightspace(strtrimleftspace(s));
+}
+
+#endif /* UTILS_ASCII_H */

contrib/csnippets/utils/buffer.c

@@ -10,6 +10,18 @@
 #include <stdlib.h>
 #include <string.h>
 
+/**
+ * Append formatted text into a fixed buffer using a va_list.
+ *
+ * Behavior:
+ * - Writes at most the remaining capacity.
+ * - Ensures there is a trailing NUL in the buffer storage.
+ * - Advances len by up to (cap - len - 1).
+ *
+ * Returns the number of characters that would have been written (excluding
+ * the terminating NUL), as per vsnprintf semantics. Non-positive values
+ * indicate an encoding/formatting error or zero available space.
+ */
 int buf_vappendf(
 	struct buffer *restrict buf, const char *restrict format, va_list args)
 {
@@ -34,6 +46,17 @@ int buf_appendf(struct buffer *restrict buf, const char *restrict format, ...)
 	return ret;
 }
 
+/**
+ * Ensure a growable buffer has capacity of at least `want` bytes.
+ *
+ * Growth strategy:
+ * - Below 256 bytes: jump to 256.
+ * - Below 4096 bytes: double the current capacity.
+ * - 4096 and above: grow by cap/4 + 3*4096/4 to moderate fragmentation.
+ *
+ * Always reserves one extra byte for NUL-termination. On allocation failure,
+ * returns the original pointer unchanged.
+ */
 struct vbuffer *vbuf_grow(struct vbuffer *vbuf, const size_t want)
 {
 	const size_t maxcap = SIZE_MAX - sizeof(struct vbuffer) - 1;
@@ -80,6 +103,12 @@ struct vbuffer *vbuf_grow(struct vbuffer *vbuf, const size_t want)
 	return newbuf;
 }
 
+/**
+ * Append up to n bytes to a growable buffer.
+ * - Attempts to grow to fit; if growth fails, appends what fits.
+ * - Maintains a trailing NUL in the reserved byte (does not change len).
+ * - If len == cap (previous alloc failure), the append is skipped.
+ */
 struct vbuffer *
 vbuf_append(struct vbuffer *restrict vbuf, const void *restrict data, size_t n)
 {
@@ -105,6 +134,11 @@ vbuf_append(struct vbuffer *restrict vbuf, const void *restrict data, size_t n)
 	return vbuf;
 }
 
+/**
+ * Append formatted text to a growable buffer using a va_list.
+ * Performs a two-pass attempt: try in-place then grow and retry.
+ * Keeps a trailing NUL in the reserved byte. On failure, truncates to fit.
+ */
 struct vbuffer *vbuf_vappendf(
 	struct vbuffer *restrict vbuf, const char *restrict format,
 	va_list args)