fuzzing.hh 2.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "olm/olm.hh"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


ssize_t read_file(
    int fd,
    uint8_t **buffer
) {
    size_t buffer_size = 4096;
    size_t buffer_pos = 0;
19
20
21
    uint8_t * current_buffer = (uint8_t *) malloc(buffer_size);
    if (!current_buffer) return -1;

22
23
24
25
    while (1) {
        ssize_t count = read(
            fd, current_buffer + buffer_pos, buffer_size - buffer_pos
        );
26
27
28

        if (count < 0) break;  // A read error happened, so just fail immediately.

29
        if (count == 0) {
30
31
32
33
            // Nothing more left to read. We downsize the buffer to fit the
            // data exactly, unless no data was read at all, in which case we
            // skip the downsizing.

34
35
            if (buffer_pos != 0) {
                current_buffer = (uint8_t *) realloc(current_buffer, buffer_pos);
36
                if (!current_buffer) break;
37
            }
38
39

            // The read was successful so we return the allocated buffer.
40
            *buffer = current_buffer;
41
42
            return buffer_pos;
        }
43

44
        buffer_pos += count;
45
46

        // We've reached capacity, so enlarge the buffer.
47
48
49
        if (buffer_pos == buffer_size) {
            buffer_size *= 2;
            uint8_t * new_buffer = (uint8_t *) realloc(current_buffer, buffer_size);
50
            if (!new_buffer) break;
51
52
53
            current_buffer = new_buffer;
        }
    }
54

55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
    free(current_buffer);
    return -1;
}

template<typename T>
T check_errno(
    const char * message,
    T value
) {
    if (value == T(-1)) {
        perror(message);
        exit(1);
    }
    return value;
}

71
72
73
74
template<typename T, typename F>
size_t check_error(
    F f,
    T * object,
75
76
77
78
    const char * message,
    size_t value
) {
    if (value == olm_error()) {
79
        const char * olm_message = f(object);
80
81
82
83
84
        (void)write(STDERR_FILENO, message, strlen(message));
        (void)write(STDERR_FILENO, ": ", 2);
        (void)write(STDERR_FILENO, olm_message, strlen(olm_message));
        (void)write(STDERR_FILENO, "\n", 1);

85
86
87
88
        exit(2);
    }
    return value;
}
89
90
91
92
93
94
95
96

size_t check_session(
    OlmSession * session,
    const char * message,
    size_t value
) {
    return check_error(olm_session_last_error, session, message, value);
}