C++ (Cpp) h2o_timeout_unlinkの例

コード例 #1

ファイル: request.c プロジェクト: Debug-Orz/h2o

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);
}

コード例 #2

ファイル: util.c プロジェクト: letv-cdn/h2o

static h2o_accept_ctx_t *free_accept_data(struct st_h2o_accept_data_t *data)
{
    h2o_accept_ctx_t *ctx = data->ctx;
    h2o_timeout_unlink(&data->timeout);
    free(data);
    return ctx;
}

コード例 #3

ファイル: util.c プロジェクト: nwcs/h2o

static h2o_accept_ctx_t *free_accept_data(struct st_h2o_accept_data_t *data)
{
    h2o_accept_ctx_t *ctx = data->ctx;
    assert(data->async_resumption_get_req == NULL);
    h2o_timeout_unlink(&data->timeout);
    free(data);
    return ctx;
}

コード例 #4

ファイル: http1.c プロジェクト: ifzz/h2o

static void close_connection(struct st_h2o_http1_conn_t *conn, int close_socket)
{
    h2o_timeout_unlink(&conn->_timeout_entry);
    h2o_dispose_request(&conn->req);
    if (conn->sock != NULL && close_socket)
        h2o_socket_close(conn->sock);
    free(conn);
}

コード例 #5

ファイル: socketpool.c プロジェクト: fetus-hina/h2o

void h2o_socketpool_unregister_loop(h2o_socketpool_t *pool, h2o_loop_t *loop)
{
    if (pool->_interval_cb.loop != loop)
        return;
    h2o_timeout_unlink(&pool->_interval_cb.entry);
    h2o_timeout_dispose(loop, &pool->_interval_cb.timeout);
    pool->_interval_cb.loop = NULL;
}

コード例 #6

ファイル: connection.c プロジェクト: cautonwong/h2o

static void update_idle_timeout(h2o_http2_conn_t *conn)
{
    h2o_timeout_unlink(&conn->_timeout_entry);

    if (conn->num_streams.responding == 0) {
        assert(h2o_linklist_is_empty(&conn->_pending_reqs));
        conn->_timeout_entry.cb = on_idle_timeout;
        h2o_timeout_link(conn->super.ctx->loop, &conn->super.ctx->http2.idle_timeout, &conn->_timeout_entry);
    }
}

コード例 #7

ファイル: http1.c プロジェクト: ifzz/h2o

static void set_timeout(struct st_h2o_http1_conn_t *conn, h2o_timeout_t *timeout, h2o_timeout_cb cb)
{
    if (conn->_timeout != NULL) {
        h2o_timeout_unlink(&conn->_timeout_entry);
        conn->_timeout_entry.cb = NULL;
    }
    conn->_timeout = timeout;
    if (timeout != NULL) {
        h2o_timeout_link(conn->super.ctx->loop, timeout, &conn->_timeout_entry);
        conn->_timeout_entry.cb = cb;
    }
}

コード例 #8

ファイル: socketpool.c プロジェクト: Daiki0525/h2o

void h2o_socketpool_dispose(h2o_socketpool_t *pool)
{
    pthread_mutex_lock(&pool->_shared.mutex);
    while (!h2o_linklist_is_empty(&pool->_shared.sockets)) {
        struct pool_entry_t *entry = H2O_STRUCT_FROM_MEMBER(struct pool_entry_t, link, pool->_shared.sockets.next);
        destroy_attached(entry);
        __sync_sub_and_fetch(&pool->_shared.count, 1);
    }
    pthread_mutex_unlock(&pool->_shared.mutex);
    pthread_mutex_destroy(&pool->_shared.mutex);

    if (pool->_interval_cb.loop != NULL) {
        h2o_timeout_unlink(&pool->_interval_cb.entry);
        h2o_timeout_dispose(pool->_interval_cb.loop, &pool->_interval_cb.timeout);
    }
    if (pool->peer.is_named)
        free(pool->peer.named.host.base);
}

コード例 #9

ファイル: socketpool.c プロジェクト: IvwsIgeMq/h2o

void h2o_socketpool_dispose(h2o_socketpool_t *pool)
{
    pthread_mutex_lock(&pool->_shared.mutex);
    while (!h2o_linklist_is_empty(&pool->_shared.sockets)) {
        struct pool_entry_t *entry = H2O_STRUCT_FROM_MEMBER(struct pool_entry_t, link, pool->_shared.sockets.next);
        destroy_attached(entry);
        __sync_sub_and_fetch(&pool->_shared.count, 1);
    }
    pthread_mutex_unlock(&pool->_shared.mutex);
    pthread_mutex_destroy(&pool->_shared.mutex);

    if (pool->_interval_cb.loop != NULL) {
        h2o_timeout_unlink(&pool->_interval_cb.entry);
        h2o_timeout_dispose(pool->_interval_cb.loop, &pool->_interval_cb.timeout);
    }
    free(pool->peer.host.base);
    switch (pool->type) {
    case H2O_SOCKETPOOL_TYPE_NAMED:
        free(pool->peer.named_serv.base);
        break;
    case H2O_SOCKETPOOL_TYPE_SOCKADDR:
        break;
    }
}

コード例 #10

ファイル: util.c プロジェクト: nmdguerreiro/h2o

static void free_accept_data(struct st_h2o_accept_data_t *data)
{
    assert(data->async_resumption_get_req == NULL);
    h2o_timeout_unlink(&data->timeout);
    free(data);
}