MIRROR: javascript for ๐Ÿœ's, a tiny runtime with big ambitions
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

safe cstr buf

+62 -22
+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
··· 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
··· 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 }