// This file is autogenerated by hrpc-c
// !!DO NOT EDIT!!
#include "swarmd_hrpc.h"
#include <compact.h>
#include <stdlib.h>
static int
swarmd_hrpc__frame (const rpc_message_t *msg, uint8_t **out, size_t *out_len) {
compact_state_t state = {0, 0, NULL};
int err = rpc_preencode_message(&state, msg);
if (err < 0) return hrpc_err_decode;
state.buffer = malloc(state.end);
if (state.buffer == NULL) return hrpc_err_alloc;
err = rpc_encode_message(&state, msg);
if (err < 0) {
free(state.buffer);
return hrpc_err_decode;
}
*out = state.buffer;
*out_len = state.end;
return 0;
}
int
swarmd_encode_hello (uint64_t id, const swarmd_hello_request_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_hello_request_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_hello_request_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_hello;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_hello_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_hello_response (const rpc_message_t *msg, swarmd_hello_response_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_hello_response_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_status_get (uint64_t id, const swarmd_none_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_none_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_none_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_status_get;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_status_get_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_status_get_response (const rpc_message_t *msg, swarmd_status_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_status_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_swarm_join (uint64_t id, const swarmd_swarm_join_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_swarm_join_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_swarm_join_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_swarm_join;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_swarm_join_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_swarm_join_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_swarm_leave (uint64_t id, const swarmd_topic_ref_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_topic_ref_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_topic_ref_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_swarm_leave;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_swarm_leave_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_swarm_leave_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_peer_add (uint64_t id, const swarmd_peer_key_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_peer_key_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_peer_key_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_peer_add;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_peer_add_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_peer_add_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_peer_remove (uint64_t id, const swarmd_peer_key_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_peer_key_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_peer_key_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_peer_remove;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_peer_remove_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_peer_remove_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_channel_open (uint64_t id, const swarmd_channel_open_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_channel_open_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_channel_open_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_channel_open;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_channel_open_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_channel_open_response (const rpc_message_t *msg, swarmd_channel_ref_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_channel_ref_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_channel_close (uint64_t id, const swarmd_channel_ref_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_channel_ref_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_channel_ref_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_channel_close;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_channel_close_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_channel_close_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_send (uint64_t id, const swarmd_send_request_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_send_request_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_send_request_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_send;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_send_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_send_response (const rpc_message_t *msg, swarmd_send_result_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_send_result_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_content_hash (uint64_t id, const swarmd_path_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_path_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_path_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_content_hash;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_content_hash_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_content_hash_response (const rpc_message_t *msg, swarmd_hash_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_hash_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_content_serve (uint64_t id, const swarmd_content_serve_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_content_serve_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_content_serve_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_content_serve;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_content_serve_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_content_serve_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_content_fetch (uint64_t id, const swarmd_content_fetch_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_content_fetch_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_content_fetch_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_content_fetch;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_content_fetch_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_content_fetch_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_content_cancel (uint64_t id, const swarmd_content_cancel_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_content_cancel_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_content_cancel_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = id;
msg.command = swarmd_command_content_cancel;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_content_cancel_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) {
rpc_message_t msg = {0};
msg.type = rpc_response;
msg.id = id;
msg.error = true;
msg.stream = 0;
msg.message = error.message;
msg.code = error.code;
msg.status = error.status;
return swarmd_hrpc__frame(&msg, out, out_len);
}
int
swarmd_decode_content_cancel_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) {
if (msg->error) {
error->message = msg->message;
error->code = msg->code;
error->status = msg->status;
return hrpc_error_response;
}
compact_state_t payload = {0, msg->len, msg->data};
int err = swarmd_ok_decode(&payload, result);
if (err < 0) return hrpc_err_decode;
return hrpc_ok;
}
int
swarmd_encode_on_peer_up (const swarmd_peer_up_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_peer_up_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_peer_up_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_peer_up;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_on_peer_down (const swarmd_peer_down_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_peer_down_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_peer_down_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_peer_down;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_on_message (const swarmd_message_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_message_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_message_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_message;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_on_drain (const swarmd_channel_ref_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_channel_ref_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_channel_ref_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_drain;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_on_status (const swarmd_status_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_status_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_status_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_status;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_on_content_progress (const swarmd_content_progress_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_content_progress_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_content_progress_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_content_progress;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_on_content_done (const swarmd_content_done_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_content_done_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_content_done_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_content_done;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_encode_on_content_failed (const swarmd_content_failed_t *args, uint8_t **out, size_t *out_len) {
compact_state_t payload = {0, 0, NULL};
int err = swarmd_content_failed_preencode(&payload, args);
if (err < 0) return hrpc_err_decode;
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) return hrpc_err_alloc;
err = swarmd_content_failed_encode(&payload, args);
if (err < 0) {
free(payload.buffer);
return hrpc_err_decode;
}
}
rpc_message_t msg = {0};
msg.type = rpc_request;
msg.id = 0;
msg.command = swarmd_command_on_content_failed;
msg.stream = 0;
msg.data = payload.buffer;
msg.len = payload.end;
err = swarmd_hrpc__frame(&msg, out, out_len);
free(payload.buffer);
return err;
}
int
swarmd_hrpc_dispatch (const swarmd_hrpc_handlers_t *handlers, const rpc_message_t *msg, uint8_t **reply_out, size_t *reply_len) {
switch (msg->command) {
case swarmd_command_hello: {
if (handlers->on_hello == NULL) return hrpc_err_unknown;
swarmd_hello_request_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_hello_request_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_hello_response_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_hello(handlers->ctx, &req, &res, &error);
swarmd_hello_request_destroy(&req);
if (r < 0) {
swarmd_hello_response_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_hello_response_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_hello_response_preencode(&payload, &res) < 0) {
swarmd_hello_response_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_hello_response_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_hello_response_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_hello_response_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_hello_response_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_status_get: {
if (handlers->on_status_get == NULL) return hrpc_err_unknown;
swarmd_none_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_none_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_status_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_status_get(handlers->ctx, &req, &res, &error);
swarmd_none_destroy(&req);
if (r < 0) {
swarmd_status_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_status_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_status_preencode(&payload, &res) < 0) {
swarmd_status_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_status_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_status_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_status_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_status_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_swarm_join: {
if (handlers->on_swarm_join == NULL) return hrpc_err_unknown;
swarmd_swarm_join_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_swarm_join_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_swarm_join(handlers->ctx, &req, &res, &error);
swarmd_swarm_join_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_swarm_leave: {
if (handlers->on_swarm_leave == NULL) return hrpc_err_unknown;
swarmd_topic_ref_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_topic_ref_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_swarm_leave(handlers->ctx, &req, &res, &error);
swarmd_topic_ref_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_peer_add: {
if (handlers->on_peer_add == NULL) return hrpc_err_unknown;
swarmd_peer_key_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_peer_key_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_peer_add(handlers->ctx, &req, &res, &error);
swarmd_peer_key_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_peer_remove: {
if (handlers->on_peer_remove == NULL) return hrpc_err_unknown;
swarmd_peer_key_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_peer_key_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_peer_remove(handlers->ctx, &req, &res, &error);
swarmd_peer_key_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_channel_open: {
if (handlers->on_channel_open == NULL) return hrpc_err_unknown;
swarmd_channel_open_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_channel_open_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_channel_ref_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_channel_open(handlers->ctx, &req, &res, &error);
swarmd_channel_open_destroy(&req);
if (r < 0) {
swarmd_channel_ref_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_channel_ref_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_channel_ref_preencode(&payload, &res) < 0) {
swarmd_channel_ref_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_channel_ref_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_channel_ref_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_channel_ref_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_channel_ref_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_channel_close: {
if (handlers->on_channel_close == NULL) return hrpc_err_unknown;
swarmd_channel_ref_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_channel_ref_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_channel_close(handlers->ctx, &req, &res, &error);
swarmd_channel_ref_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_send: {
if (handlers->on_send == NULL) return hrpc_err_unknown;
swarmd_send_request_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_send_request_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_send_result_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_send(handlers->ctx, &req, &res, &error);
swarmd_send_request_destroy(&req);
if (r < 0) {
swarmd_send_result_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_send_result_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_send_result_preencode(&payload, &res) < 0) {
swarmd_send_result_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_send_result_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_send_result_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_send_result_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_send_result_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_content_hash: {
if (handlers->on_content_hash == NULL) return hrpc_err_unknown;
swarmd_path_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_path_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_hash_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_content_hash(handlers->ctx, &req, &res, &error);
swarmd_path_destroy(&req);
if (r < 0) {
swarmd_hash_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_hash_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_hash_preencode(&payload, &res) < 0) {
swarmd_hash_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_hash_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_hash_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_hash_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_hash_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_content_serve: {
if (handlers->on_content_serve == NULL) return hrpc_err_unknown;
swarmd_content_serve_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_content_serve_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_content_serve(handlers->ctx, &req, &res, &error);
swarmd_content_serve_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_content_fetch: {
if (handlers->on_content_fetch == NULL) return hrpc_err_unknown;
swarmd_content_fetch_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_content_fetch_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_content_fetch(handlers->ctx, &req, &res, &error);
swarmd_content_fetch_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_content_cancel: {
if (handlers->on_content_cancel == NULL) return hrpc_err_unknown;
swarmd_content_cancel_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_content_cancel_decode(&in, &req) < 0) return hrpc_err_decode;
swarmd_ok_t res = {0};
hrpc_error_t error = {0};
int r = handlers->on_content_cancel(handlers->ctx, &req, &res, &error);
swarmd_content_cancel_destroy(&req);
if (r < 0) {
swarmd_ok_destroy(&res);
return r;
}
if (r == hrpc_error_response) {
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = true;
reply.stream = 0;
reply.message = error.message;
reply.code = error.code;
reply.status = error.status;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
return r < 0 ? r : hrpc_dispatch_reply;
}
compact_state_t payload = {0, 0, NULL};
if (swarmd_ok_preencode(&payload, &res) < 0) {
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
if (payload.end > 0) {
payload.buffer = malloc(payload.end);
if (payload.buffer == NULL) {
swarmd_ok_destroy(&res);
return hrpc_err_alloc;
}
if (swarmd_ok_encode(&payload, &res) < 0) {
free(payload.buffer);
swarmd_ok_destroy(&res);
return hrpc_err_decode;
}
}
swarmd_ok_destroy(&res);
rpc_message_t reply = {0};
reply.type = rpc_response;
reply.id = msg->id;
reply.error = false;
reply.stream = 0;
reply.data = payload.buffer;
reply.len = payload.end;
r = swarmd_hrpc__frame(&reply, reply_out, reply_len);
free(payload.buffer);
return r < 0 ? r : hrpc_dispatch_reply;
}
case swarmd_command_on_peer_up: {
if (handlers->on_on_peer_up == NULL) return hrpc_err_unknown;
swarmd_peer_up_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_peer_up_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_peer_up(handlers->ctx, &req);
swarmd_peer_up_destroy(&req);
return hrpc_dispatch_no_reply;
}
case swarmd_command_on_peer_down: {
if (handlers->on_on_peer_down == NULL) return hrpc_err_unknown;
swarmd_peer_down_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_peer_down_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_peer_down(handlers->ctx, &req);
swarmd_peer_down_destroy(&req);
return hrpc_dispatch_no_reply;
}
case swarmd_command_on_message: {
if (handlers->on_on_message == NULL) return hrpc_err_unknown;
swarmd_message_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_message_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_message(handlers->ctx, &req);
swarmd_message_destroy(&req);
return hrpc_dispatch_no_reply;
}
case swarmd_command_on_drain: {
if (handlers->on_on_drain == NULL) return hrpc_err_unknown;
swarmd_channel_ref_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_channel_ref_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_drain(handlers->ctx, &req);
swarmd_channel_ref_destroy(&req);
return hrpc_dispatch_no_reply;
}
case swarmd_command_on_status: {
if (handlers->on_on_status == NULL) return hrpc_err_unknown;
swarmd_status_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_status_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_status(handlers->ctx, &req);
swarmd_status_destroy(&req);
return hrpc_dispatch_no_reply;
}
case swarmd_command_on_content_progress: {
if (handlers->on_on_content_progress == NULL) return hrpc_err_unknown;
swarmd_content_progress_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_content_progress_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_content_progress(handlers->ctx, &req);
swarmd_content_progress_destroy(&req);
return hrpc_dispatch_no_reply;
}
case swarmd_command_on_content_done: {
if (handlers->on_on_content_done == NULL) return hrpc_err_unknown;
swarmd_content_done_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_content_done_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_content_done(handlers->ctx, &req);
swarmd_content_done_destroy(&req);
return hrpc_dispatch_no_reply;
}
case swarmd_command_on_content_failed: {
if (handlers->on_on_content_failed == NULL) return hrpc_err_unknown;
swarmd_content_failed_t req = {0};
compact_state_t in = {0, msg->len, msg->data};
if (swarmd_content_failed_decode(&in, &req) < 0) return hrpc_err_decode;
handlers->on_on_content_failed(handlers->ctx, &req);
swarmd_content_failed_destroy(&req);
return hrpc_dispatch_no_reply;
}
default:
return hrpc_err_unknown;
}
}