xonecas.io
7814
Ta

tiny-c-agent / files

tiny-c-agent / src / util.c

5.6 KB
1#include "util.h"
2#include <errno.h>
3#include <unistd.h>
4#include <sys/stat.h>
5#include <stdbool.h>
6
7#include <stdarg.h>
8#include <stdio.h>
9#include <stdlib.h>
10#include <string.h>
11
12void *xmalloc(size_t n) {
13    void *p = malloc(n);
14    if (!p) abort();
15    return p;
16}
17
18void *xcalloc(size_t n, size_t size) {
19    void *p = calloc(n, size);
20    if (!p) abort();
21    return p;
22}
23
24void *xrealloc(void *p, size_t n) {
25    p = realloc(p, n);
26    if (!p) abort();
27    return p;
28}
29
30char *xstrdup(const char *s) {
31    size_t n = strlen(s) + 1;
32    char *p = xmalloc(n);
33    memcpy(p, s, n);
34    return p;
35}
36
37void buf_init(tiny_buf *b) {
38    b->data = NULL;
39    b->len = 0;
40    b->cap = 0;
41}
42
43void buf_free(tiny_buf *b) {
44    free(b->data);
45    buf_init(b);
46}
47
48void buf_clear(tiny_buf *b) {
49    b->len = 0;
50    if (b->data) b->data[0] = '\0';
51}
52
53void buf_reserve(tiny_buf *b, size_t extra) {
54    if (b->len + extra + 1 <= b->cap) return;
55    size_t cap = b->cap ? b->cap : 64;
56    while (cap < b->len + extra + 1) cap *= 2;
57    b->data = xrealloc(b->data, cap);
58    b->cap = cap;
59}
60
61void buf_add(tiny_buf *b, const void *p, size_t n) {
62    if (n == 0) return;
63    buf_reserve(b, n);
64    memcpy(b->data + b->len, p, n);
65    b->len += n;
66    b->data[b->len] = '\0';
67}
68
69void buf_adds(tiny_buf *b, const char *s) {
70    buf_add(b, s, strlen(s));
71}
72
73void buf_addc(tiny_buf *b, char c) {
74    buf_add(b, &c, 1);
75}
76
77void buf_addf(tiny_buf *b, const char *fmt, ...) {
78    va_list ap;
79    va_start(ap, fmt);
80    va_list ap2;
81    va_copy(ap2, ap);
82    int n = vsnprintf(NULL, 0, fmt, ap);
83    va_end(ap);
84    if (n < 0) {
85        va_end(ap2);
86        return;
87    }
88    buf_reserve(b, (size_t)n);
89    vsnprintf(b->data + b->len, (size_t)n + 1, fmt, ap2);
90    b->len += (size_t)n;
91    va_end(ap2);
92}
93
94char *buf_steal(tiny_buf *b) {
95    if (!b->data) return xstrdup("");
96    char *d = b->data;
97    b->data = NULL;
98    b->len = 0;
99    b->cap = 0;
100    return d;
101}
102
103void tiny_set_error(char **err, const char *fmt, ...) {
104    if (!err) return;
105    char detail[512];
106    va_list ap;
107    va_start(ap, fmt);
108    vsnprintf(detail, sizeof detail, fmt, ap);
109    va_end(ap);
110    free(*err);
111    *err = xstrdup(detail);
112}
113
114int tiny_fail(char **err, const char *fmt, ...) {
115    if (err) {
116        char detail[512];
117        va_list ap;
118        va_start(ap, fmt);
119        vsnprintf(detail, sizeof detail, fmt, ap);
120        va_end(ap);
121        free(*err);
122        *err = xstrdup(detail);
123    }
124    return -1;
125}
126
127int tiny_mkdirs(const char *path) {
128    char buf[4096];
129    size_t len = strlen(path);
130    if (len == 0 || len >= sizeof buf) {
131        errno = ENAMETOOLONG;
132        return -1;
133    }
134    memcpy(buf, path, len + 1);
135    for (char *p = buf + 1; *p; p++) {
136        if (*p != '/') continue;
137        *p = '\0';
138        if (mkdir(buf, 0755) != 0 && errno != EEXIST) return -1;
139        *p = '/';
140    }
141    if (mkdir(buf, 0755) != 0 && errno != EEXIST) return -1;
142    return 0;
143}
144
145char *tiny_path_join(const char *a, const char *b) {
146    size_t al = strlen(a);
147    bool slash = al > 0 && a[al - 1] == '/';
148    size_t n = al + strlen(b) + (slash ? 1 : 2);
149    char *p = xmalloc(n);
150    snprintf(p, n, slash ? "%s%s" : "%s/%s", a, b);
151    return p;
152}
153
154void strv_push(tiny_strv *l, char *s) {
155    if (l->n == l->cap) {
156        l->cap = l->cap ? l->cap * 2 : 8;
157        l->v = xrealloc(l->v, l->cap * sizeof *l->v);
158    }
159    l->v[l->n++] = s;
160}
161
162void strv_free(tiny_strv *l) {
163    for (size_t i = 0; i < l->n; i++) free(l->v[i]);
164    free(l->v);
165    l->v = NULL;
166    l->n = 0;
167    l->cap = 0;
168}
169
170tiny_strv tiny_split_lines(const char *s) {
171    tiny_strv l = {0};
172    const char *p = s;
173    for (;;) {
174        const char *nl = strchr(p, '\n');
175        size_t len = nl ? (size_t)(nl - p) : strlen(p);
176        char *line = xmalloc(len + 1);
177        memcpy(line, p, len);
178        line[len] = '\0';
179        strv_push(&l, line);
180        if (!nl) break;
181        p = nl + 1;
182    }
183    return l;
184}
185
186char *tiny_trim_end(const char *s) {
187    size_t len = strlen(s);
188    while (len > 0 && (s[len - 1] == '\n' || s[len - 1] == '\r')) len--;
189    char *out = xmalloc(len + 1);
190    memcpy(out, s, len);
191    out[len] = '\0';
192    return out;
193}
194
195static bool is_space(char c) {
196    return c == ' ' || c == '\t' || c == '\n' || c == '\r';
197}
198
199char *tiny_trim(const char *s) {
200    while (is_space(*s)) s++;
201    size_t n = strlen(s);
202    while (n > 0 && is_space(s[n - 1])) n--;
203    char *out = xmalloc(n + 1);
204    memcpy(out, s, n);
205    out[n] = '\0';
206    return out;
207}
208
209bool tiny_is_blank(const char *s) {
210    while (is_space(*s)) s++;
211    return *s == '\0';
212}
213
214void tiny_set_str(char **dst, const char *src) {
215    free(*dst);
216    *dst = xstrdup(src ? src : "");
217}
218
219int tiny_write_all(int fd, const char *buf, size_t len) {
220    while (len > 0) {
221        ssize_t n = write(fd, buf, len);
222        if (n < 0) {
223            if (errno == EINTR) continue;
224            return -1;
225        }
226        buf += n;
227        len -= (size_t)n;
228    }
229    return 0;
230}
231
232char *tiny_read_file(const char *path) {
233    FILE *f = fopen(path, "rb");
234    if (!f) return NULL;
235    char *s = tiny_read_stream(f);
236    fclose(f);
237    return s;
238}
239
240char *tiny_read_stream(FILE *f) {
241    tiny_buf b;
242    buf_init(&b);
243    char chunk[8192];
244    size_t n;
245    while ((n = fread(chunk, 1, sizeof chunk, f)) > 0) buf_add(&b, chunk, n);
246    return buf_steal(&b);
247}
248
249char *tiny_url_endpoint(const char *base, const char *path) {
250    if (!base || !base[0]) return NULL;
251    size_t n = strlen(base);
252    bool slash = base[n - 1] == '/';
253    size_t size = n + strlen(path) + 2;
254    char *url = xmalloc(size);
255    snprintf(url, size, slash ? "%s%s" : "%s/%s", base, path);
256    return url;
257}