libuwebsockets-sys 0.0.1

Native bindings to the uWebSockets CAPI
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

extern "C" {
#include "quic.h"
}

#include "Http3ResponseData.h"

namespace uWS {

    /* Is a quic stream */
    struct Http3Response {

        // this one is AsyncSocket, so it has to translate to the stream - abrupt stream termination
        void close() {
            //us_quic_stream_close((us_quic_stream_t *) this);
        }

        void endWithoutBody(std::optional<size_t> reportedContentLength = std::nullopt, bool closeConnection = false) {

        }

        Http3Response *writeStatus(std::string_view status) {
            Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext((us_quic_stream_t *) this);

            /* Nothing is done if status already written */
            if (responseData->headerOffset == 0) {
                us_quic_socket_context_set_header(nullptr, 0, (char *) ":status", 7, status.data(), status.length());
                responseData->headerOffset = 1;
            }

            return this;
        }

        Http3Response *writeHeader(std::string_view key, std::string_view value) {
            Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext((us_quic_stream_t *) this);

            writeStatus("200 OK");

            us_quic_socket_context_set_header(nullptr, responseData->headerOffset++, key.data(), key.length(), value.data(), value.length());

            return this;
        }

        std::pair<bool, bool> tryEnd(std::string_view data, uintmax_t totalSize = 0) {
            Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext((us_quic_stream_t *) this);

            writeStatus("200 OK");

            us_quic_socket_context_send_headers(nullptr, (us_quic_stream_t *) this, responseData->headerOffset, data.length() > 0);


            unsigned int written = us_quic_stream_write((us_quic_stream_t *) this, (char *) data.data(), (int) data.length());

            if (written == data.length()) {
                return {true, true};
            } else {

                responseData->offset = written;

                return {true, false};
            }


            return {true, true};
        }

        /* Idnetical */
        Http3Response *write(std::string_view data) {


            return this;
        }

        /* Identical */
        void end(std::string_view data = {}, bool closeConnection = false) {

            Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext((us_quic_stream_t *) this);

            /* If not already written */
            writeStatus("200 OK");
            
            // has body is determined by the ending so this is perfect here
            us_quic_socket_context_send_headers(nullptr, (us_quic_stream_t *) this, responseData->headerOffset, data.length() > 0);

            /* Write body and shutdown (unknown if content-length must be present?) */
            unsigned int written = us_quic_stream_write((us_quic_stream_t *) this, (char *) data.data(), (int) data.length());

            /* Buffer up remains */
            if (written != data.length()) {
                responseData->backpressure.append(data.data() + written, data.length() - written);
            } else {
                /* Every request has its own stream, so we conceptually serve requests like in HTTP 1.0 */
                us_quic_stream_shutdown((us_quic_stream_t *) this);
            }
        }

        /* Attach handler for aborted HTTP request */
        Http3Response *onAborted(MoveOnlyFunction<void()> &&handler) {
            Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext((us_quic_stream_t *) this);

            responseData->onAborted = std::move(handler);
            return this;
        }

        /* Attach a read handler for data sent. Will be called with FIN set true if last segment. */
        Http3Response *onData(MoveOnlyFunction<void(std::string_view, bool)> &&handler) {
            Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext((us_quic_stream_t *) this);

            responseData->onData = std::move(handler);
            return this;
        }

        Http3Response *onWritable(MoveOnlyFunction<bool(uintmax_t)> &&handler) {
            Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext((us_quic_stream_t *) this);

            responseData->onWritable = std::move(handler);
            return this;
        }
    };

}