fuzzing.h 2.45 KB
Newer Older
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
#include "olm/olm.h"

#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>

#define OLM_FUZZING 1

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

    while (1) {
        ssize_t count = read(
            fd, current_buffer + buffer_pos, buffer_size - buffer_pos
        );

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

        if (count == 0) {
            // 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.

            if (buffer_pos != 0) {
                current_buffer = (uint8_t *) realloc(current_buffer, buffer_pos);
                if (!current_buffer) break;
            }

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

        buffer_pos += count;

        // We've reached capacity, so enlarge the buffer.
        if (buffer_pos == buffer_size) {
            buffer_size *= 2;
            uint8_t * new_buffer = (uint8_t *) realloc(current_buffer, buffer_size);
            if (!new_buffer) break;
            current_buffer = new_buffer;
        }
    }

    free(current_buffer);
    return -1;
}

ssize_t check_errno(
    const char * message,
    ssize_t value
) {
    if (value == (ssize_t)-1) {
        perror(message);
        exit(1);
    }
    return value;
}

size_t check_error(
    const char * message,
    const char * olm_message,
    size_t value
) {
    if (value == olm_error()) {
        (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);

        exit(2);
    }
    return value;
}

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

size_t check_outbound_group_session(
    OlmOutboundGroupSession * session,
    const char * message,
    size_t value
) {
    return check_error(message, olm_outbound_group_session_last_error(session), value);
}