ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
browser_session.cpp
Go to the documentation of this file.
1#include <emscripten/bind.h>
2extern "C" {
6}
7#include "client_bytes.h"
8#include <sodium.h>
9#include "byte_arrays.h"
10
11#include <memory>
12#include <cstddef>
13#include <cstdint>
14#include <string>
15#include <vector>
16
17EMSCRIPTEN_DECLARE_VAL_TYPE(NullablePeerBytes);
19
21public:
22 BrowserSessionBinding(bool server, int encryption, PeerBytes password, PeerBytes identity, PeerBytes expected) {
23 auto pass = binding_copy_input(password);
24 auto secret = binding_copy_input(identity);
25 auto key = binding_copy_input(expected);
26 if ((!secret.empty() && secret.size() != 64) || (!key.empty() && key.size() != 32)) {
27 SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer identity or verification key length");
28 construction_error_ = "Invalid peer identity or verification key length";
29 } else {
30 pass.push_back(0);
31 session_.reset(
32 browser_session_create(server, encryption, pass.size() > 1 ? reinterpret_cast<char *>(pass.data()) : nullptr, secret.empty() ? nullptr : secret.data(), key.empty() ? nullptr : key.data()));
33 }
34 if (!pass.empty())
35 sodium_memzero(pass.data(), pass.size());
36 if (!secret.empty())
37 sodium_memzero(secret.data(), secret.size());
38 if (!key.empty())
39 sodium_memzero(key.data(), key.size());
40 }
43
44 bool valid() const {
45 return static_cast<bool>(session_);
46 }
47 bool ready() const {
48 return session_ && browser_session_ready(session_.get());
49 }
50 std::string error() const {
51 if (!session_ && !construction_error_.empty())
52 return construction_error_;
53 return browser_session_error(session_.get());
54 }
55 void close() {
56 session_.reset();
57 }
58 emscripten::val process(emscripten::val event) {
59 emscripten::val result = emscripten::val::object();
60 if (!session_) {
61 const int code = SET_ERRNO(ERROR_INVALID_STATE, "Browser session is not initialized");
62 result.set("code", code);
63 result.set("ok", false);
64 result.set("message", "Browser session is not initialized");
65 result.set("retryable", false);
66 result.set("outputs", emscripten::val::array());
67 result.set("received", emscripten::val::null());
68 result.set("queuedBytes", 0);
69 result.set("writable", false);
70 return result;
71 }
72 result.set("code", 0);
73 const std::string type = event["type"].as<std::string>();
74 if (type == "start") {
75 result.set("code", static_cast<int>(browser_session_start(session_.get())));
76 } else if (type == "connected" || type == "disconnected") {
77 browser_session_set_connected(session_.get(), type == "connected");
78 } else if (type == "send" || type == "receive") {
79 auto bytes = binding_copy_input(event["packet"]);
80 const int code = input_bytes(bytes, type == "receive");
81 result.set("code", code);
82 if (!bytes.empty())
83 sodium_memzero(bytes.data(), bytes.size());
84 } else if (type == "tick") {
85 result.set("code", static_cast<int>(browser_session_tick(session_.get())));
86 } else if (type == "quic-begin") {
87 result.set("code", static_cast<int>(browser_session_quic_begin(session_.get())));
88 } else if (type == "quic-event" && event["operation"].as<std::string>() == "init") {
89 result.set("code", static_cast<int>(browser_session_security_init(session_.get())));
90 } else if (type == "quic-event" && event["operation"].as<std::string>() == "tick") {
91 int code = static_cast<int>(browser_session_security_tick(session_.get()));
92 result.set("epoch", browser_session_security_epoch(session_.get()));
93 emscripten::val quic_outputs = emscripten::val::array();
94 for (unsigned i = 0; i < 16; ++i) {
95 uint8_t data[256];
96 size_t length = 0;
97 uint32_t flow = 0;
98 code = browser_session_security_output(session_.get(), data, sizeof(data), &length, &flow);
99 if (code || !length)
100 break;
101 emscripten::val output = emscripten::val::object();
102 output.set("code", code);
103 output.set("flow", flow);
104 output.set("packet", binding_copy_output(data, length));
105 quic_outputs.call<void>("push", output);
106 }
107 result.set("code", code);
108 result.set("quicOutputs", quic_outputs);
109 } else if (type == "quic-event" && event["operation"].as<std::string>() == "state") {
110 result.set("epoch", browser_session_security_epoch(session_.get()));
111 } else if (type == "quic-event" && (event["operation"].as<std::string>() == "seal" || event["operation"].as<std::string>() == "open")) {
112 auto packet = binding_copy_input(event["packet"]);
113 const bool seal = event["operation"].as<std::string>() == "seal";
114 std::vector<uint8_t> output(packet.size() + (seal ? 94 : 0));
115 size_t length = 0;
116 uint64_t sequence = 0;
117 const int code = browser_session_security_packet(session_.get(), seal, event["flow"].as<unsigned>(), event["delivery"].as<unsigned>(), packet.data(), packet.size(), output.data(), output.size(),
118 &length, &sequence);
119 result.set("code", code);
120 result.set("packet", binding_copy_output(output.data(), code ? 0 : length));
121 result.set("sequence", emscripten::val::global("BigInt")(std::to_string(sequence)));
122 if (!packet.empty())
123 sodium_memzero(packet.data(), packet.size());
124 if (!output.empty())
125 sodium_memzero(output.data(), output.size());
126 } else {
127 result.set("code", SET_ERRNO(ERROR_INVALID_PARAM, "Unknown browser session event"));
128 }
129 const int code = result["code"].as<int>();
130 if (code) {
132 const bool has_context = errno_has(&context);
133 result.set("message", has_context && context.context_message[0] ? std::string(context.context_message) : std::string(asciichat_error_string(static_cast<asciichat_error_t>(code))));
134 result.set("retryable", network_error_action(static_cast<asciichat_error_t>(code)) == NETWORK_ERROR_RETRY);
135 }
136 emscripten::val outputs = emscripten::val::array();
137 for (unsigned i = 0; i < 16; ++i) {
138 const void *data = browser_session_output_data(session_.get());
139 if (!data)
140 break;
141 outputs.call<void>("push", binding_copy_output(data, browser_session_output_size(session_.get())));
142 browser_session_output_pop(session_.get());
143 }
144 result.set("outputs", outputs);
145 const void *received = browser_session_received_data(session_.get());
146 const size_t received_size = browser_session_received_size(session_.get());
147 result.set("received", received && received_size ? binding_copy_output(received, received_size) : emscripten::val::null());
148 result.set("queuedBytes", browser_session_queued_bytes(session_.get()));
149 result.set("writable", browser_session_writable(session_.get(), 0));
150 result.set("ok", result["code"].as<int>() == 0);
151 return result;
152 }
153
154 emscripten::val processBatch(emscripten::val events) {
155 emscripten::val batch = emscripten::val::array();
156 const unsigned count = events["length"].as<unsigned>();
157 if (count > 128) {
158 emscripten::val error = emscripten::val::object();
159 error.set("code", static_cast<int>(SET_ERRNO(ERROR_INVALID_PARAM, "Browser session event batch exceeds 128 events")));
160 error.set("ok", false);
161 error.set("message", "Browser session event batch exceeds 128 events");
162 error.set("retryable", false);
163 batch.call<void>("push", error);
164 return batch;
165 }
166 for (unsigned index = 0; index < count; ++index)
167 batch.call<void>("push", process(events[index]));
168 return batch;
169 }
170
171private:
172 int input_bytes(const std::vector<uint8_t> &bytes, bool receive) {
173 return receive ? browser_session_receive(session_.get(), bytes.data(), bytes.size()) : browser_session_send(session_.get(), bytes.data(), bytes.size());
174 }
175 std::unique_ptr<browser_session_t, decltype(&browser_session_destroy)> session_{nullptr, &browser_session_destroy};
176 std::string construction_error_;
177};
178
179EMSCRIPTEN_BINDINGS(ascii_chat_browser_session) {
180 emscripten::register_type<PeerBytes>("PeerBytes", "Uint8Array");
181 emscripten::register_type<NullablePeerBytes>("NullablePeerBytes", "Uint8Array | null");
182 emscripten::class_<BrowserSessionBinding>("BrowserSessionBinding")
183 .constructor<bool, int, PeerBytes, PeerBytes, PeerBytes>()
184 .function("valid", &BrowserSessionBinding::valid)
185 .function("ready", &BrowserSessionBinding::ready)
186 .function("error", &BrowserSessionBinding::error)
187 .function("close", &BrowserSessionBinding::close)
188 .function("process", &BrowserSessionBinding::process)
189 .function("processBatch", &BrowserSessionBinding::processBatch);
190}
bool errno_has(asciichat_error_context_t *context)
#define SET_ERRNO(code,...)
EMSCRIPTEN_BINDINGS(ascii_chat_browser_session)
EMSCRIPTEN_DECLARE_VAL_TYPE(NullablePeerBytes)
emscripten::val binding_copy_output(const void *data, size_t length)
Definition byte_arrays.h:18
std::vector< uint8_t > binding_copy_input(emscripten::val bytes)
Definition byte_arrays.h:6
BrowserSessionBinding(bool server, int encryption, PeerBytes password, PeerBytes identity, PeerBytes expected)
emscripten::val process(emscripten::val event)
BrowserSessionBinding & operator=(const BrowserSessionBinding &)=delete
std::string error() const
emscripten::val processBatch(emscripten::val events)
BrowserSessionBinding(const BrowserSessionBinding &)=delete
unsigned int uint32_t
unsigned long long uint64_t
unsigned char uint8_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_INVALID_STATE
@ ERROR_INVALID_PARAM
struct browser_session browser_session_t
Network error handling utilities.
asciichat_error_t browser_session_security_tick(browser_session_t *peer)
double browser_session_security_epoch(browser_session_t *peer)
const void * browser_session_output_data(browser_session_t *peer)
void browser_session_output_pop(browser_session_t *peer)
void browser_session_destroy(browser_session_t *peer)
size_t browser_session_queued_bytes(const browser_session_t *peer)
asciichat_error_t browser_session_security_packet(browser_session_t *peer, bool seal, uint32_t channel, uint32_t delivery, const uint8_t *packet, size_t length, uint8_t *output, size_t capacity, size_t *out_length, uint64_t *sequence)
const char * browser_session_error(browser_session_t *peer)
bool browser_session_ready(browser_session_t *peer)
asciichat_error_t browser_session_security_output(browser_session_t *peer, uint8_t *output, size_t capacity, size_t *length, uint32_t *channel)
asciichat_error_t browser_session_send(browser_session_t *peer, const void *data, size_t length)
size_t browser_session_received_size(browser_session_t *peer)
browser_session_t * browser_session_create(bool server, int encryption, const char *password, const uint8_t *identity, const uint8_t *expected_key)
asciichat_error_t browser_session_tick(browser_session_t *peer)
asciichat_error_t browser_session_receive(browser_session_t *peer, const void *data, size_t length)
asciichat_error_t browser_session_start(browser_session_t *peer)
bool browser_session_writable(const browser_session_t *peer, size_t additional_bytes)
size_t browser_session_output_size(browser_session_t *peer)
void browser_session_set_connected(browser_session_t *peer, bool connected)
asciichat_error_t browser_session_security_init(browser_session_t *peer)
const void * browser_session_received_data(browser_session_t *peer)
asciichat_error_t browser_session_quic_begin(browser_session_t *peer)
network_error_action_t network_error_action(asciichat_error_t code)
static bool size_t index
Definition queries.h:8