libisoalloc-sys 0.3.0

Security oriented allocator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

/* iso_alloc_printf.c - A secure memory allocator
 * Copyright 2023 - chris.rohlf@gmail.com */

#include "iso_alloc_internal.h"
#include <stdarg.h>

#if __GNUC__ && !__clang__
#pragma GCC diagnostic ignored "-Wstringop-truncation"
#pragma GCC diagnostic ignored "-Wstringop-overflow"
#endif

#define INTERNAL_HIDDEN __attribute__((visibility("hidden")))

/* This primitive printf implementation is only ever called
 * called from the LOG and LOG_AND_ABORT macros. We need to
 * be able to print basic log messages without invoking
 * malloc() or we run the risk of using a corrupted heap */
static int8_t fmt_buf[64];
static const int8_t asc_hex[] = "0123456789abcdef";

INTERNAL_HIDDEN int8_t *_fmt(uint64_t n, uint32_t base) {
    int8_t *ptr;
    uint32_t count = 0;

    __builtin_memset(fmt_buf, 0x0, sizeof(fmt_buf));
    ptr = &fmt_buf[63];

    while(n != 0) {
        *--ptr = asc_hex[n % base];
        n /= base;
        count++;
    };

    if(count == 0) {
        ptr = (int8_t *) "0";
    }

    return ptr;
}

INTERNAL_HIDDEN void _iso_alloc_printf(int32_t fd, const char *f, ...) {
    if(UNLIKELY(f == NULL)) {
        return;
    }

    uint64_t i;
    uint32_t j;
    char *s;
    va_list arg;
    va_start(arg, f);
    char out[65535];
    char *p = out;
    __builtin_memset(p, 0x0, sizeof(out));

    for(const char *idx = f; *idx != '\0'; idx++) {
        if(p >= (char *) (out + sizeof(out))) {
            break;
        }

        while(*idx != '%' && *idx != '\0') {
            *p = *idx;
            p++;

            if(*idx == '\n') {
                break;
            }

            idx++;
        }

        idx++;

        if(*idx == '\0') {
            break;
        }

        if(*idx == 'x' || *idx == 'p') {
            i = va_arg(arg, int64_t);
            s = (char *) _fmt(i, 16);
            __builtin_strncpy(p, s, strlen(s));
            p += strlen(s);
        } else if(*idx == 'd' || *idx == 'u') {
            j = va_arg(arg, int32_t);

            if(0 > j) {
                j = -j;
                *p = '-';
                p++;
            }

            s = (char *) _fmt(j, 10);

            __builtin_strncpy(p, s, strlen(s));
            p += strlen(s);
        } else if(*idx == 'l') {
            if(*(idx + 1) == 'd' || *(idx + 1) == 'u') {
                idx++;
            }

            i = va_arg(arg, int64_t);

            if(0 > i) {
                i = -i;
                *p = '-';
                p++;
            }

            s = (char *) _fmt(i, 10);

            __builtin_strncpy(p, s, strlen(s));
            p += strlen(s);
        } else if(*idx == 's') {
            s = va_arg(arg, char *);

            if(s == NULL) {
                break;
            }

            __builtin_strncpy(p, s, strlen(s));
            p += strlen(s);
        }
    }

    (void) !write(fd, out, strlen(out));
    va_end(arg);
}