MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
safe cstr buf
+62
-22
+22
include/utils.h
+22
include/utils.h
···
4
4
5
5
#include <stdlib.h>
6
6
#include <stdint.h>
7
+
#include <string.h>
8
+
9
+
typedef struct {
10
+
char *ptr;
11
+
char *heap;
12
+
} cstr_buf_t;
7
13
8
14
const char *ant_semver(void);
9
15
uint64_t hash_key(const char *key, size_t len);
···
12
18
int ant_version(void *argtable[]);
13
19
14
20
void *try_oom(size_t size);
21
+
void cstr_free(cstr_buf_t *buf);
22
+
23
+
char *cstr_init(
24
+
cstr_buf_t *buf,
25
+
char *stack,
26
+
size_t stack_size,
27
+
const char *src,
28
+
size_t len
29
+
);
30
+
31
+
#define CSTR_BUF(name, size) \
32
+
char name##_stack[size]; \
33
+
cstr_buf_t name = {0}
34
+
35
+
#define CSTR_INIT(buf, src, len) \
36
+
cstr_init(&(buf), buf##_stack, sizeof(buf##_stack), (src), (len))
15
37
16
38
#endif
+22
-22
src/modules/process.c
+22
-22
src/modules/process.c
···
31
31
#include "config.h"
32
32
#include "internal.h"
33
33
#include "runtime.h"
34
+
#include "utils.h"
34
35
35
36
#include "modules/process.h"
36
37
#include "modules/symbol.h"
···
1264
1265
}
1265
1266
#endif
1266
1267
1267
-
static jsval_t env_getter(ant_t *js, jsval_t obj, const char *key, size_t key_len) {
1268
-
char *key_str = (char *)malloc(key_len + 1);
1268
+
static jsval_t env_getter(ant_t *js, jsval_t obj, const char *key, size_t key_len) {
1269
+
CSTR_BUF(buf, 256);
1270
+
char *key_str = CSTR_INIT(buf, key, key_len);
1269
1271
if (!key_str) return js_mkundef();
1270
1272
1271
-
memcpy(key_str, key, key_len);
1272
-
key_str[key_len] = '\0';
1273
-
1274
1273
char *value = getenv(key_str);
1275
-
free(key_str);
1274
+
cstr_free(&buf);
1276
1275
1277
1276
if (value == NULL) return js_mkundef();
1278
1277
return js_mkstr(js, value, strlen(value));
···
1282
1281
jsval_t str_val = coerce_to_str(js, value);
1283
1282
setprop_cstr(js, obj, key, key_len, str_val);
1284
1283
1285
-
char key_buf[256];
1286
-
if (key_len < sizeof(key_buf)) {
1287
-
memcpy(key_buf, key, key_len);
1288
-
key_buf[key_len] = '\0';
1289
-
1284
+
CSTR_BUF(buf, 256);
1285
+
char *key_str = CSTR_INIT(buf, key, key_len);
1286
+
if (key_str) {
1290
1287
size_t val_len;
1291
1288
char *val_str = js_getstr(js, str_val, &val_len);
1292
-
if (val_str) setenv(key_buf, val_str, 1);
1289
+
if (val_str) setenv(key_str, val_str, 1);
1290
+
cstr_free(&buf);
1293
1291
}
1294
1292
1295
1293
return true;
···
1390
1388
if (key_len >= 2 && key[0] == '_' && key[1] == '_') continue;
1391
1389
if (vtype(value) != T_STR) continue;
1392
1390
1393
-
char key_buf[256];
1394
-
if (key_len >= sizeof(key_buf)) continue;
1395
-
memcpy(key_buf, key, key_len);
1396
-
key_buf[key_len] = '\0';
1391
+
CSTR_BUF(buf, 256);
1392
+
char *key_str = CSTR_INIT(buf, key, key_len);
1393
+
if (!key_str) continue;
1397
1394
1398
-
if (getenv(key_buf)) continue;
1395
+
if (getenv(key_str)) {
1396
+
cstr_free(&buf);
1397
+
continue;
1398
+
} cstr_free(&buf);
1399
1399
1400
1400
size_t val_len;
1401
1401
char *val_str = js_getstr(js, value, &val_len);
···
1407
1407
1408
1408
static void env_to_object_cb(ant_t *js, const char *key, size_t key_len, const char *value, size_t val_len, void *ctx) {
1409
1409
jsval_t obj = *(jsval_t *)ctx;
1410
-
char key_buf[256];
1411
-
if (key_len >= sizeof(key_buf)) return;
1412
-
memcpy(key_buf, key, key_len);
1413
-
key_buf[key_len] = '\0';
1414
-
js_set(js, obj, key_buf, js_mkstr(js, value, val_len));
1410
+
CSTR_BUF(buf, 256);
1411
+
char *key_str = CSTR_INIT(buf, key, key_len);
1412
+
if (!key_str) return;
1413
+
js_set(js, obj, key_str, js_mkstr(js, value, val_len));
1414
+
cstr_free(&buf);
1415
1415
}
1416
1416
1417
1417
static jsval_t env_to_object(ant_t *js, jsval_t *args, int nargs) {
+18
src/utils.c
+18
src/utils.c
···
112
112
fputs("Error: out of memory\n", stderr);
113
113
exit(EXIT_FAILURE);
114
114
} return p;
115
+
}
116
+
117
+
void cstr_free(cstr_buf_t *buf) {
118
+
if (buf->heap) free(buf->heap);
119
+
}
120
+
121
+
char *cstr_init(cstr_buf_t *buf, char *stack, size_t stack_size, const char *src, size_t len) {
122
+
if (len < stack_size) {
123
+
buf->ptr = stack;
124
+
buf->heap = NULL;
125
+
} else {
126
+
buf->heap = malloc(len + 1);
127
+
if (!buf->heap) return NULL;
128
+
buf->ptr = buf->heap;
129
+
}
130
+
memcpy(buf->ptr, src, len);
131
+
buf->ptr[len] = '\0';
132
+
return buf->ptr;
115
133
}