static void requests_status_per_thread(void *priv, h2o_context_t *ctx)
{
struct st_requests_status_ctx_t *rsc = priv;
struct st_collect_req_status_cbdata_t cbdata = {rsc->logconf};
/* we encountered an error at init() time, return early */
if (rsc->logconf == NULL)
return;
h2o_buffer_init(&cbdata.buffer, &h2o_socket_buffer_prototype);
ctx->globalconf->http1.callbacks.foreach_request(ctx, collect_req_status, &cbdata);
ctx->globalconf->http2.callbacks.foreach_request(ctx, collect_req_status, &cbdata);
/* concat JSON elements */
if (cbdata.buffer->size != 0) {
#ifndef _MSC_VER
pthread_mutex_lock(&rsc->mutex);
#else
uv_mutex_lock(&rsc->mutex);
#endif
if (rsc->req_data.len == 0)
h2o_buffer_consume(&cbdata.buffer, 1); /* skip preceeding comma */
rsc->req_data.base = h2o_mem_realloc(rsc->req_data.base, rsc->req_data.len + cbdata.buffer->size);
memcpy(rsc->req_data.base + rsc->req_data.len, cbdata.buffer->bytes, cbdata.buffer->size);
rsc->req_data.len += cbdata.buffer->size;
#ifndef _MSC_VER
pthread_mutex_unlock(&rsc->mutex);
#else
uv_mutex_unlock(&rsc->mutex);
#endif
}
h2o_buffer_dispose(&cbdata.buffer);
}
void h2o_append_to_null_terminated_list(void ***list, void *element)
{
size_t cnt;
for (cnt = 0; (*list)[cnt] != NULL; ++cnt)
;
*list = h2o_mem_realloc(*list, (cnt + 2) * sizeof(void *));
(*list)[cnt++] = element;
(*list)[cnt] = NULL;
}
void h2o_vector__expand(h2o_mem_pool_t *pool, h2o_vector_t *vector, size_t element_size, size_t new_capacity)
{
void *new_entries;
assert(vector->capacity < new_capacity);
if (vector->capacity == 0)
vector->capacity = 4;
while (vector->capacity < new_capacity)
vector->capacity *= 2;
if (pool != NULL) {
new_entries = h2o_mem_alloc_pool(pool, element_size * vector->capacity);
memcpy(new_entries, vector->entries, element_size * vector->size);
} else {
new_entries = h2o_mem_realloc(vector->entries, element_size * vector->capacity);
}
vector->entries = new_entries;
}
static int on_config_mruby_handler_file(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node)
{
struct mruby_configurator_t *self = (void *)cmd->configurator;
FILE *fp = NULL;
h2o_iovec_t buf = {};
int ret = -1;
/* open and read file */
if ((fp = fopen(node->data.scalar, "rt")) == NULL) {
h2o_configurator_errprintf(cmd, node, "failed to open file: %s:%s", node->data.scalar, strerror(errno));
goto Exit;
}
while (!feof(fp)) {
buf.base = h2o_mem_realloc(buf.base, buf.len + 65536);
buf.len += fread(buf.base + buf.len, 1, 65536, fp);
if (ferror(fp)) {
h2o_configurator_errprintf(cmd, node, "I/O error occurred while reading file:%s:%s", node->data.scalar,
strerror(errno));
goto Exit;
}
}
/* set source */
self->vars->source = buf;
buf.base = NULL;
self->vars->path = node->data.scalar; /* the value is retained until the end of the configuration phase */
self->vars->lineno = 0;
/* check if there is any error in source */
char errbuf[1024];
if (!compile_test(self->vars, errbuf)) {
h2o_configurator_errprintf(cmd, node, "failed to compile file:%s:%s", node->data.scalar, errbuf);
goto Exit;
}
/* register */
h2o_mruby_register(ctx->pathconf, self->vars);
ret = 0;
Exit:
if (fp != NULL)
fclose(fp);
if (buf.base != NULL)
free(buf.base);
return ret;
}
static char *expand_line_buf(char *line, size_t cur_size, size_t required)
{
size_t new_size = cur_size;
/* determine the new size */
do {
new_size *= 2;
} while (new_size < required);
/* reallocate */
if (cur_size == LOG_ALLOCA_SIZE) {
char *newpt = h2o_mem_alloc(new_size);
memcpy(newpt, line, cur_size);
line = newpt;
} else {
line = h2o_mem_realloc(line, new_size);
}
return line;
}
static ssize_t send_callback(wslay_event_context_ptr ctx, const uint8_t *data, size_t len, int flags, void *_conn)
{
h2o_websocket_conn_t *conn = _conn;
h2o_iovec_t buf;
/* return WOULDBLOCK if pending (TODO: queue fixed number of chunks, instead of only one) */
if (h2o_socket_is_writing(conn->sock)) {
wslay_event_set_error(conn->ws_ctx, WSLAY_ERR_WOULDBLOCK);
return -1;
}
/* copy data */
conn->_write_buf = h2o_mem_realloc(conn->_write_buf, len);
memcpy(conn->_write_buf, data, len);
/* write */
buf.base = conn->_write_buf;
buf.len = len;
h2o_socket_write(conn->sock, &buf, 1, on_write_complete);
return len;
}
