/**
* Process a POST request containing a JSON object. This function
* realizes an MHD POST processor that will (incrementally) process
* JSON data uploaded to the HTTP server. It will store the required
* state in the @a con_cls, which must be cleaned up using
* #GNUNET_JSON_post_parser_callback().
*
* @param buffer_max maximum allowed size for the buffer
* @param con_cls the closure (will point to a `struct Buffer *`)
* @param upload_data the POST data
* @param upload_data_size number of bytes in @a upload_data
* @param json the JSON object for a completed request
* @return result code indicating the status of the operation
*/
enum GNUNET_JSON_PostResult
GNUNET_JSON_post_parser (size_t buffer_max,
void **con_cls,
const char *upload_data,
size_t *upload_data_size,
json_t **json)
{
struct Buffer *r = *con_cls;
*json = NULL;
if (NULL == *con_cls)
{
/* We are seeing a fresh POST request. */
r = GNUNET_new (struct Buffer);
if (GNUNET_OK !=
buffer_init (r,
upload_data,
*upload_data_size,
REQUEST_BUFFER_INITIAL,
buffer_max))
{
*con_cls = NULL;
buffer_deinit (r);
GNUNET_free (r);
return GNUNET_JSON_PR_OUT_OF_MEMORY;
}
/* everything OK, wait for more POST data */
*upload_data_size = 0;
*con_cls = r;
return GNUNET_JSON_PR_CONTINUE;
}
void svndump_deinit(void)
{
log_reset();
repo_reset();
reset_dump_ctx(~0);
reset_rev_ctx(0);
reset_node_ctx(NULL);
if (buffer_deinit())
fprintf(stderr, "Input error\n");
if (ferror(stdout))
fprintf(stderr, "Output error\n");
}
int cmd_main(int argc, const char **argv)
{
struct line_buffer stdin_buf = LINE_BUFFER_INIT;
struct line_buffer file_buf = LINE_BUFFER_INIT;
struct line_buffer *input = &stdin_buf;
const char *filename;
char *s;
if (argc == 1)
filename = NULL;
else if (argc == 2)
filename = argv[1];
else
usage("test-line-buffer [file | &fd] < script");
if (buffer_init(&stdin_buf, NULL))
die_errno("open error");
if (filename) {
if (*filename == '&') {
if (buffer_fdinit(&file_buf, strtouint32(filename + 1)))
die_errno("error opening fd %s", filename + 1);
} else {
if (buffer_init(&file_buf, filename))
die_errno("error opening %s", filename);
}
input = &file_buf;
}
while ((s = buffer_read_line(&stdin_buf)))
handle_line(s, input);
if (filename && buffer_deinit(&file_buf))
die("error reading from %s", filename);
if (buffer_deinit(&stdin_buf))
die("input error");
if (ferror(stdout))
die("output error");
return 0;
}
static int apply_delta(int argc, const char **argv)
{
struct line_buffer preimage = LINE_BUFFER_INIT;
struct line_buffer delta = LINE_BUFFER_INIT;
struct sliding_view preimage_view = SLIDING_VIEW_INIT(&preimage, -1);
if (argc != 5)
usage(test_svnfe_usage);
if (buffer_init(&preimage, argv[2]))
die_errno("cannot open preimage");
if (buffer_init(&delta, argv[3]))
die_errno("cannot open delta");
if (svndiff0_apply(&delta, (off_t) strtoumax(argv[4], NULL, 0),
&preimage_view, stdout))
return 1;
if (buffer_deinit(&preimage))
die_errno("cannot close preimage");
if (buffer_deinit(&delta))
die_errno("cannot close delta");
strbuf_release(&preimage_view.buf);
return 0;
}
void svndump_deinit(void)
{
fast_export_deinit();
reset_dump_ctx(NULL);
reset_rev_ctx(0);
reset_node_ctx(NULL);
strbuf_release(&rev_ctx.log);
strbuf_release(&node_ctx.src);
strbuf_release(&node_ctx.dst);
if (buffer_deinit(&input))
fprintf(stderr, "Input error\n");
if (ferror(stdout))
fprintf(stderr, "Output error\n");
}
int main(int argc, char *argv[]) {
client_udp_t *client;
io_service_t *iosvc;
buffer_t *buffer;
context_t context;
endpoint_t ep;
if (argc < 3) {
fprintf(stdout, "usage: %s <src-port> <dst-port>\n", argv[0]);
exit(0);
}
buffer = buffer_init(10, buffer_policy_no_shrink);
assert(buffer != NULL);
iosvc = io_service_init();
assert(iosvc != NULL);
ep.ep_type = EPT_TCP;
ep.ep_class = EPC_IP4;
ep.ep.ip4.addr[0] = ep.ep.ip4.addr[1] =
ep.ep.ip4.addr[2] = ep.ep.ip4.addr[3] = 0;
ep.ep.ip4.port = 12345;
client = client_udp_init(iosvc, NULL /*"127.0.0.1"*/, argv[1] /*"54321"*/, 1);
assert(client != NULL);
context.buffer = buffer;
context.client = client;
context.service = iosvc;
buffer_resize(&buffer, 10);
memcpy(buffer_data(buffer), "1234567890", 10);
//client_udp_connect_sync(client, "127.0.0.1", "12345", connected, &context);
//oto_server_tcp_listen_async(server, connection_accepted, &context);
client_udp_send_async(context.client, context.buffer, "127.0.0.1", argv[2], data_sent, &context);
io_service_run(iosvc);
/*io_service_stop(iosvc, true);*/
client_udp_deinit(client);
io_service_deinit(iosvc);
buffer_deinit(buffer);
return 0;
}
int main(int argc, char *argv[])
{
char *s;
if (argc != 1)
usage("test-line-buffer < input.txt");
if (buffer_init(NULL))
die_errno("open error");
while ((s = buffer_read_line())) {
s = buffer_read_string(strtouint32(s));
fputs(s, stdout);
fputc('\n', stdout);
buffer_skip_bytes(1);
if (!(s = buffer_read_line()))
break;
buffer_copy_bytes(strtouint32(s) + 1);
}
if (buffer_deinit())
die("input error");
if (ferror(stdout))
die("output error");
buffer_reset();
return 0;
}
void fast_export_deinit(void)
{
if (buffer_deinit(&report_buffer))
die_errno("error closing fast-import feedback stream");
}
/************ definitions ************/
void reader(uss_t *srv, uss_connection_t *conn,
int error, driver_core_t *core) {
const pr_signature_t *s;
pr_driver_response_t *response_header;
const pr_driver_command_t *dc;
const pr_driver_command_argument_t *dca;
const uint8_t *dca_value;
uint8_t argc, arg_idx;
uint8_t cmd_idx;
size_t required_length;
driver_command_t *comm;
buffer_t response;
driver_core_connection_state_t *state;
if (error) {
LOG(LOG_LEVEL_WARN, "Couldn't recv from client: %s\n",
strerror(errno));
avl_tree_remove(&core->connection_state, conn->fd);
unix_socket_server_close_connection(srv, conn);
return;
}
if (conn->eof) {
LOG_MSG(LOG_LEVEL_DEBUG, "Another one EOF\n");
avl_tree_remove(&core->connection_state, conn->fd);
unix_socket_server_close_connection(srv, conn);
return;
}
s = (const pr_signature_t *)(conn->read_task.b.data);
if (PR_DRV_COMMAND != s->s) {
LOG(LOG_LEVEL_WARN, "Invalid signature received: %#02x\n",
s->s);
avl_tree_remove(&core->connection_state, conn->fd);
unix_socket_server_close_connection(srv, conn);
return;
}
if (conn->read_task.b.user_size < sizeof(pr_driver_command_t)) {
conn->read_task.b.offset = conn->read_task.b.user_size;
unix_socket_server_recv(
srv, conn,
sizeof(pr_driver_command_t) - conn->read_task.b.user_size,
(uss_reader_t)reader,
core);
return;
}
state = (driver_core_connection_state_t *)conn->priv;
dc = (const pr_driver_command_t *)s;
argc = dc->argc;
cmd_idx = dc->cmd_idx;
dca = (const pr_driver_command_argument_t *)(dc + 1);
state->argc = argc;
comm = (driver_command_t *)vector_get(&core->payload->commands, cmd_idx);
if (argc > comm->max_arity) {
LOG(LOG_LEVEL_WARN, "Maximum command arity exceeded: %#02x vs %#02x\n",
(unsigned int)argc, (unsigned int)comm->max_arity);
avl_tree_remove(&core->connection_state, conn->fd);
unix_socket_server_close_connection(srv, conn);
return;
}
if (!argc) {
LOG(LOG_LEVEL_DEBUG, "Calling %*s with no arguments\n",
comm->name_len, comm->name);
buffer_init(&response, sizeof(*response_header), bp_non_shrinkable);
comm->handler(cmd_idx,
comm->name, comm->name_len,
argc, NULL, &response);
if (response.user_size < sizeof(*response_header)) {
LOG_MSG(LOG_LEVEL_FATAL,
"Comand handler malforms response buffer\n");
abort();
}
response_header = (pr_driver_response_t *)response.data;
response_header->s.s = PR_DRV_RESPONSE;
response_header->len = response.user_size - sizeof(*response_header);
unix_socket_server_send(srv, conn, response.data, response.user_size,
(uss_writer_t)writer, core);
buffer_deinit(&response);
return;
} /* if (!argc) */
if (state->argc == state->args_received) {
LOG(LOG_LEVEL_DEBUG, "Calling %*s with %d arguments\n",
comm->name_len, comm->name, state->argc);
driver_command_argument_t argv[state->argc];
for (arg_idx = 0; arg_idx < state->argc; ++arg_idx) {
argv[arg_idx].arg = (const char *)(dca + 1);
argv[arg_idx].arg_len = dca->len;
dca = (const pr_driver_command_argument_t *)(
(const uint8_t *)(dca + 1) + dca->len);
}
buffer_init(&response, 0, bp_non_shrinkable);
comm->handler(cmd_idx,
comm->name, comm->name_len,
state->argc, argv, &response);
unix_socket_server_send(srv, conn, response.data, response.user_size,
(uss_writer_t)writer, core);
buffer_deinit(&response);
return;
} /* if (state->argc == state->args_received) */
/* TODO receive full arguments vector */
if (0 == state->last_argument_offset)
state->last_argument_offset = sizeof(*dc);
dca = (const pr_driver_command_argument_t *)(
(const uint8_t *)s + state->last_argument_offset
);
if (conn->read_task.b.user_size < state->last_argument_offset
+ sizeof(*dca)) {
required_length = state->last_argument_offset + sizeof(*dca);
conn->read_task.b.offset = conn->read_task.b.user_size;
unix_socket_server_recv(
srv, conn,
required_length - conn->read_task.b.user_size,
(uss_reader_t)reader,
core);
return;
}
if (conn->read_task.b.user_size < state->last_argument_offset
+ sizeof(*dca) + dca->len) {
required_length = state->last_argument_offset + sizeof(*dca)
+ dca->len;
conn->read_task.b.offset = conn->read_task.b.user_size;
unix_socket_server_recv(
srv, conn,
required_length - conn->read_task.b.user_size,
(uss_reader_t)reader,
core);
return;
}
++state->args_received;
state->last_argument_offset += sizeof(*dca) + dca->len;
required_length = state->last_argument_offset + sizeof(*dca);
if (state->args_received < state->argc) {
conn->read_task.b.offset = conn->read_task.b.user_size;
unix_socket_server_recv(
srv, conn,
required_length - conn->read_task.b.user_size,
(uss_reader_t)reader,
core);
return;
}
LOG(LOG_LEVEL_DEBUG, "Calling %*s with %d arguments\n",
comm->name_len, comm->name, state->argc);
driver_command_argument_t argv[state->argc];
for (arg_idx = 0; arg_idx < state->argc; ++arg_idx) {
argv[arg_idx].arg = (const char *)(dca + 1);
argv[arg_idx].arg_len = dca->len;
dca = (const pr_driver_command_argument_t *)(
(const uint8_t *)(dca + 1) + dca->len);
}
buffer_init(&response, sizeof(*response_header), bp_non_shrinkable);
comm->handler(cmd_idx,
comm->name, comm->name_len,
state->argc, argv, &response);
if (response.user_size < sizeof(*response_header)) {
LOG_MSG(LOG_LEVEL_FATAL,
"Comand handler malforms response buffer\n");
abort();
}
response_header = (pr_driver_response_t *)response.data;
response_header->s.s = PR_DRV_RESPONSE;
response_header->len = response.user_size - sizeof(*response_header);
unix_socket_server_send(srv, conn, response.data, response.user_size,
(uss_writer_t)writer, core);
buffer_deinit(&response);
}