Coverage Report

Created: 2023-09-25 07:17

/src/uWebSockets/fuzzing/EpollHelloWorld.cpp
Line
Count
Source (jump to first uncovered line)
1
/* We rely on wrapped syscalls */
2
#include "libEpollFuzzer/epoll_fuzzer.h"
3
4
#include "App.h"
5
6
/* We keep this one for teardown later on */
7
struct us_listen_socket_t *listen_socket;
8
struct us_socket_t *client;
9
10
/* This test is run by libEpollFuzzer */
11
6.03k
void test() {
12
  /* ws->getUserData returns one of these */
13
6.03k
    struct PerSocketData {
14
        /* Fill with user data */
15
6.03k
    };
16
17
6.03k
    {
18
        /* Keep in mind that uWS::SSLApp({options}) is the same as uWS::App() when compiled without SSL support.
19
        * You may swap to using uWS:App() if you don't need SSL */
20
6.03k
        auto app = uWS::App({
21
            /* There are example certificates in uWebSockets.js repo */
22
6.03k
            .key_file_name = "../misc/key.pem",
23
6.03k
            .cert_file_name = "../misc/cert.pem",
24
6.03k
            .passphrase = "1234"
25
6.03k
        }).ws<PerSocketData>("/empty", {
26
        /* Having no handlers here should not crash */
27
8.50k
        }).get("/*", [](auto *res, auto *req) {
28
8.50k
            if (req->getHeader("write").length()) {
29
691
                res->writeStatus("200 OK")->writeHeader("write", "true")->write("Hello");
30
691
                res->write(" world!");
31
691
                res->end();
32
7.81k
            } else if (req->getQuery().length()) {
33
910
                res->close();
34
6.90k
            } else {
35
6.90k
                res->end("Hello world!");
36
6.90k
            }
37
8.50k
        }).post("/*", [](auto *res, auto *req) {
38
2.73k
            res->onAborted([]() {
39
                /* We might as well use this opportunity to stress the loop a bit */
40
1.13k
                uWS::Loop::get()->defer([]() {
41
42
1.00k
                });
43
1.13k
            });
44
35.1k
            res->onData([res](std::string_view chunk, bool isEnd) {
45
35.1k
                if (isEnd) {
46
1.59k
                    res->cork([res, chunk]() {
47
1.59k
                        res->write("something ahead");
48
1.59k
                        res->end(chunk);
49
1.59k
                    });
50
1.59k
                }
51
35.1k
            });
52
3.36k
        }).any("/:candy/*", [](auto *res, auto *req) {
53
3.36k
            if (req->getParameter(0).length() == 0) {
54
0
                free((void *) -1);
55
0
            }
56
            /* Some invalid queries */
57
3.36k
            req->getParameter(30000);
58
3.36k
            req->getParameter((unsigned short) -34234);
59
3.36k
            req->getHeader("yhello");
60
3.36k
            req->getQuery();
61
3.36k
            req->getQuery("assd");
62
63
3.36k
            res->end("done");
64
3.36k
        }).ws<PerSocketData>("/*", {
65
            /* Settings */
66
6.03k
            .compression = uWS::SHARED_COMPRESSOR,
67
6.03k
            .maxPayloadLength = 16 * 1024,
68
6.03k
            .idleTimeout = 12,
69
6.03k
            .maxBackpressure = 1024,
70
            /* Handlers */
71
32.3k
            .open = [](auto *ws) {
72
                /* Open event here, you may access ws->getUserData() which points to a PerSocketData struct */
73
32.3k
                ws->getNativeHandle();
74
32.3k
                ws->getRemoteAddressAsText();
75
32.3k
                us_poll_ext((struct us_poll_t *) ws);
76
32.3k
            },
77
13.7k
            .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
78
13.7k
                ws->send(message, opCode, true);
79
13.7k
            },
80
6.03k
            .drain = [](auto *ws) {
81
                /* Check ws->getBufferedAmount() here */
82
5.10k
            },
83
6.03k
            .ping = [](auto *ws, std::string_view) {
84
                /* We use this to trigger the async/wakeup feature */
85
5.81k
                uWS::Loop::get()->defer([]() {
86
                    /* Do nothing */
87
4.20k
                });
88
5.81k
            },
89
6.03k
            .pong = [](auto *ws, std::string_view) {
90
                /* Not implemented yet */
91
1.00k
            },
92
32.3k
            .close = [](auto *ws, int code, std::string_view message) {
93
                /* You may access ws->getUserData() here */
94
32.3k
            }
95
6.03k
        }).listen(9001, [](auto *listenSocket) {
96
6.03k
            listen_socket = listenSocket;
97
6.03k
        });
98
99
        /* Here we want to stress the connect feature, since nothing else stresses it */
100
6.03k
        struct us_loop_t *loop = (struct us_loop_t *) uWS::Loop::get();
101
        /* This function is stupid */
102
6.03k
        us_loop_iteration_number(loop);
103
6.03k
        struct us_socket_context_t *client_context = us_create_socket_context(0, loop, 0, {});
104
6.03k
        us_socket_context_timestamp(0, client_context);
105
6.03k
        client = us_socket_context_connect(0, client_context, "hostname", 5000, "localhost", 0, 0);
106
      
107
6.03k
        if (client) {
108
2.76k
            us_socket_is_established(0, client);
109
2.76k
            us_socket_local_port(0, client);
110
2.76k
        }
111
112
6.03k
        us_socket_context_on_connect_error(0, client_context, [](struct us_socket_t *s, int code) {
113
2.44k
            client = nullptr;
114
2.44k
            return s;
115
2.44k
        });
116
117
6.03k
        us_socket_context_on_open(0, client_context, [](struct us_socket_t *s, int is_client, char *ip, int ip_length) {
118
281
            us_socket_flush(0, s);
119
281
            return s;
120
281
        });
121
122
6.03k
        us_socket_context_on_end(0, client_context, [](struct us_socket_t *s) {
123
            /* Someone sent is a FIN, but we can still send data */
124
836
            us_socket_write(0, s, "asdadasdasdasdaddfgdfhdfgdfg", 28, false);
125
836
            return s;
126
836
        });
127
128
6.03k
        us_socket_context_on_data(0, client_context, [](struct us_socket_t *s, char *data, int length) {
129
427
            return s;
130
427
        });
131
132
6.03k
        us_socket_context_on_writable(0, client_context, [](struct us_socket_t *s) {
133
            /* Let's defer a close here */
134
613
            us_socket_shutdown_read(0, s);
135
613
            return s;
136
613
        });
137
138
6.03k
        us_socket_context_on_close(0, client_context, [](struct us_socket_t *s, int code, void *reason) {
139
314
            client = NULL;
140
314
            return s;
141
314
        });
142
143
        /* Trigger some context functions */
144
6.03k
        app.addServerName("servername", {});
145
6.03k
        app.removeServerName("servername");
146
6.03k
        app.missingServerName(nullptr);
147
6.03k
        app.getNativeHandle();
148
149
6.03k
        app.run();
150
151
        /* After done we also free the client context */
152
6.03k
        us_socket_context_free(0, client_context);
153
6.03k
    }
154
6.03k
    uWS::Loop::get()->setSilent(true);
155
6.03k
    uWS::Loop::get()->free();
156
6.03k
}
157
158
/* Thus function should shutdown the event-loop and let the test fall through */
159
5.98k
void teardown() {
160
  /* If we are called twice there's a bug (it potentially could if
161
   * all open sockets cannot be error-closed in one epoll_wait call).
162
   * But we only allow 1k FDs and we have a buffer of 1024 from epoll_wait */
163
5.98k
  if (!listen_socket && !client) {
164
0
    exit(-1);
165
0
  }
166
167
5.98k
    if (client) {
168
129
        us_socket_close(0, client, 0, 0);
169
129
        client = NULL;
170
129
    }
171
172
  /* We might have open sockets still, and these will be error-closed by epoll_wait */
173
  // us_socket_context_close - close all open sockets created with this socket context
174
5.98k
    if (listen_socket) {
175
5.88k
        us_listen_socket_close(0, listen_socket);
176
5.88k
        listen_socket = NULL;
177
5.88k
    }
178
5.98k
}