h2_bucket_beam.h

Go to the documentation of this file.

/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef h2_bucket_beam_h
#define h2_bucket_beam_h
 
#include "h2_conn_ctx.h"
 
struct apr_thread_mutex_t;
struct apr_thread_cond_t;
 
typedef struct h2_bucket_beam h2_bucket_beam;
 
typedef void h2_beam_io_callback(void *ctx, h2_bucket_beam *beam,
                                 apr_off_t bytes);
typedef void h2_beam_ev_callback(void *ctx, h2_bucket_beam *beam);
 
typedef struct {
    APR_RING_HEAD(h2_bucket_list, apr_bucket) list;
} h2_blist;
 
struct h2_bucket_beam {
    int id;
    const char *name;
    conn_rec *from;
    apr_pool_t *pool;
    h2_blist buckets_to_send;
    h2_blist buckets_consumed;
    h2_blist buckets_eor;
 
    apr_size_t max_buf_size;
    apr_interval_time_t timeout;
 
    int aborted;
    int closed;
    int tx_mem_limits; /* only memory size counts on transfers */
    int copy_files;
 
    struct apr_thread_mutex_t *lock;
    struct apr_thread_cond_t *change;
    
    h2_beam_ev_callback *was_empty_cb; /* event: beam changed to non-empty in h2_beam_send() */
    void *was_empty_ctx;
    h2_beam_ev_callback *recv_cb;      /* event: buckets were transfered in h2_beam_receive() */
    void *recv_ctx;
    h2_beam_ev_callback *send_cb;      /* event: buckets were added in h2_beam_send() */
    void *send_ctx;
    h2_beam_ev_callback *eagain_cb;    /* event: a receive results in ARP_EAGAIN */
    void *eagain_ctx;
 
    apr_off_t recv_bytes;             /* amount of bytes transferred in h2_beam_receive() */
    apr_off_t recv_bytes_reported;    /* amount of bytes reported as received via callback */
    h2_beam_io_callback *cons_io_cb;  /* report: recv_bytes deltas for sender */
    void *cons_ctx;
};
 
apr_status_t h2_beam_create(h2_bucket_beam **pbeam,
                            conn_rec *from,
                            apr_pool_t *pool, 
                            int id, const char *tag,
                            apr_size_t buffer_size,
                            apr_interval_time_t timeout);
 
apr_status_t h2_beam_destroy(h2_bucket_beam *beam, conn_rec *c);
 
void h2_beam_set_copy_files(h2_bucket_beam * beam, int enabled);
 
apr_status_t h2_beam_send(h2_bucket_beam *beam, conn_rec *from,
                          apr_bucket_brigade *bb, 
                          apr_read_type_e block,
                          apr_off_t *pwritten);
 
apr_status_t h2_beam_receive(h2_bucket_beam *beam, conn_rec *to,
                             apr_bucket_brigade *bb,
                             apr_read_type_e block,
                             apr_off_t readbytes);
 
int h2_beam_empty(h2_bucket_beam *beam);
 
void h2_beam_abort(h2_bucket_beam *beam, conn_rec *c);
 
void h2_beam_close(h2_bucket_beam *beam, conn_rec *c);
 
void h2_beam_timeout_set(h2_bucket_beam *beam, 
                         apr_interval_time_t timeout);
 
apr_interval_time_t h2_beam_timeout_get(h2_bucket_beam *beam);
 
void h2_beam_buffer_size_set(h2_bucket_beam *beam, 
                             apr_size_t buffer_size);
apr_size_t h2_beam_buffer_size_get(h2_bucket_beam *beam);
 
void h2_beam_on_consumed(h2_bucket_beam *beam, 
                         h2_beam_io_callback *io_cb, void *ctx);
 
void h2_beam_on_received(h2_bucket_beam *beam,
                         h2_beam_ev_callback *recv_cb, void *ctx);
 
void h2_beam_on_eagain(h2_bucket_beam *beam,
                       h2_beam_ev_callback *eagain_cb, void *ctx);
 
void h2_beam_on_send(h2_bucket_beam *beam,
                     h2_beam_ev_callback *on_send_cb, void *ctx);
 
void h2_beam_on_was_empty(h2_bucket_beam *beam,
                          h2_beam_ev_callback *was_empty_cb, void *ctx);
 
int h2_beam_report_consumption(h2_bucket_beam *beam);
 
apr_off_t h2_beam_get_buffered(h2_bucket_beam *beam);
 
apr_off_t h2_beam_get_mem_used(h2_bucket_beam *beam);
 
int h2_beam_is_complete(h2_bucket_beam *beam);
 
#endif /* h2_bucket_beam_h */