void h2o_dispose_request(h2o_req_t *req)
{
/* close the generator if it is still open */
if (req->_generator != NULL) {
/* close generator */
if (req->_generator->stop != NULL)
req->_generator->stop(req->_generator, req);
req->_generator = NULL;
}
/* close the ostreams still open */
while (req->_ostr_top->next != NULL) {
if (req->_ostr_top->stop != NULL)
req->_ostr_top->stop(req->_ostr_top, req);
req->_ostr_top = req->_ostr_top->next;
}
h2o_timeout_unlink(&req->_timeout_entry);
if (req->version != 0 && req->host_config != NULL) {
h2o_logger_t **logger = req->host_config->loggers.entries, **end = logger + req->host_config->loggers.size;
for (; logger != end; ++logger) {
(*logger)->log_access((*logger), req);
}
}
h2o_mempool_clear(&req->pool);
}
static void dispose_socket(h2o_socket_t *sock, int status)
{
if (sock->ssl != NULL) {
SSL_free(sock->ssl->ssl);
free(sock->ssl->input.encrypted);
h2o_mempool_clear(&sock->ssl->output.pool);
free(sock->ssl);
}
free(sock->input);
do_dispose_socket(sock);
}
void on_write_complete(h2o_socket_t *sock, int status)
{
h2o_socket_cb cb;
if (sock->ssl != NULL) {
memset(&sock->ssl->output.bufs, 0, sizeof(sock->ssl->output.bufs));
h2o_mempool_clear(&sock->ssl->output.pool);
}
cb = sock->_cb.write;
sock->_cb.write = NULL;
cb(sock, status);
}
static void dispose_socket(h2o_socket_t *sock, int status)
{
sock->loop->_on_close(sock);
if (sock->ssl != NULL) {
SSL_free(sock->ssl->ssl);
free(sock->ssl->input.encrypted);
h2o_mempool_clear(&sock->ssl->output.pool);
free(sock->ssl);
}
free(sock->input);
wreq_free_buffer_if_allocated(sock);
close(sock->fd);
sock->_flags = H2O_SOCKET_FLAG_IS_DISPOSED;
h2o_socket__link_to_statechanged(sock);
}
static int on_body(h2o_http1client_t *client, const char *errstr)
{
if (errstr != NULL && errstr != h2o_http1client_error_is_eos) {
fprintf(stderr, "%s\n", errstr);
exit(1);
return -1;
}
fwrite(client->sock->input->bytes, 1, client->sock->input->size, stdout);
h2o_buffer_consume(&client->sock->input, client->sock->input->size);
if (errstr == h2o_http1client_error_is_eos) {
if (--cnt_left != 0) {
/* next attempt */
h2o_mempool_clear(&pool);
start_request(client->ctx);
}
}
return 0;
}
static void start_request(h2o_http1client_ctx_t *ctx)
{
char *scheme, *host, *path;
uint16_t port;
h2o_iovec_t *req;
h2o_http1client_t *client;
/* clear memory pool */
h2o_mempool_clear(&pool);
/* parse URL */
if (h2o_parse_url(&pool, url, &scheme, &host, &port, &path) != 0) {
fprintf(stderr, "unrecognized type of URL: %s\n", url);
exit(1);
}
if (strcmp(scheme, "https") == 0) {
fprintf(stderr, "https is not (yet) supported\n");
exit(1);
}
/* build request */
req = h2o_mempool_alloc(&pool, sizeof(*req));
req->base = h2o_mempool_alloc(&pool, 1024);
req->len = snprintf(req->base, 1024, "GET %s HTTP/1.1\r\nhost: %s:%u\r\n\r\n", path, host, (unsigned)port);
assert(req->len < 1024);
/* initiate the request */
if (1) {
if (sockpool == NULL) {
sockpool = h2o_malloc(sizeof(*sockpool));
h2o_socketpool_init(sockpool, host, port, 10);
h2o_socketpool_set_timeout(sockpool, ctx->loop, 5000 /* in msec */);
}
client = h2o_http1client_connect_with_pool(ctx, &pool, sockpool, on_connect);
} else {
client = h2o_http1client_connect(ctx, &pool, host, port, on_connect);
}
assert(client != NULL);
client->data = req;
}
