static void serf_iovec_destroy(serf_bucket_t *bucket) { iovec_context_t *ctx = bucket->data; serf_bucket_mem_free(bucket->allocator, ctx->vecs); serf_default_destroy_and_data(bucket); }
static void serf_dechunk_destroy_and_data(serf_bucket_t *bucket) { dechunk_context_t *ctx = bucket->data; serf_bucket_destroy(ctx->stream); serf_default_destroy_and_data(bucket); }
static void serf_simple_destroy(serf_bucket_t *bucket) { simple_context_t *ctx = bucket->data; if (ctx->freefunc) (*ctx->freefunc)(ctx->baton, ctx->original); serf_default_destroy_and_data(bucket); }
static void serf_barrier_destroy(serf_bucket_t *bucket) { /* The intent of this bucket is not to let our wrapped buckets be * destroyed. */ /* The option is for us to go ahead and 'eat' this bucket now, * or just ignore the deletion entirely. */ serf_default_destroy_and_data(bucket); }
static void serf_ssl_destroy_and_data(serf_bucket_t *bucket) { ssl_context_t *ctx = bucket->data; if (!--ctx->ssl_ctx->refcount) { ssl_free_context(ctx->ssl_ctx); } serf_default_destroy_and_data(bucket); }
static void serf_deflate_destroy_and_data(serf_bucket_t *bucket) { deflate_context_t *ctx = bucket->data; /* We may have appended inflate_stream into the stream bucket. * If so, avoid free'ing it twice. */ if (ctx->inflate_stream) { serf_bucket_destroy(ctx->inflate_stream); } serf_bucket_destroy(ctx->stream); serf_default_destroy_and_data(bucket); }
static void serf_response_destroy_and_data(serf_bucket_t *bucket) { response_context_t *ctx = bucket->data; if (ctx->state != STATE_STATUS_LINE) { serf_bucket_mem_free(bucket->allocator, (void*)ctx->sl.reason); } serf_bucket_destroy(ctx->stream); if (ctx->body != NULL) serf_bucket_destroy(ctx->body); serf_bucket_destroy(ctx->headers); serf_default_destroy_and_data(bucket); }
static void serf_aggregate_destroy_and_data(serf_bucket_t *bucket) { aggregate_context_t *ctx = bucket->data; bucket_list_t *next_ctx; while (ctx->list) { if (ctx->bucket_owner) { serf_bucket_destroy(ctx->list->bucket); } next_ctx = ctx->list->next; serf_bucket_mem_free(bucket->allocator, ctx->list); ctx->list = next_ctx; } cleanup_aggregate(ctx, bucket->allocator); serf_default_destroy_and_data(bucket); }
static void serf_headers_destroy_and_data(serf_bucket_t *bucket) { headers_context_t *ctx = bucket->data; header_list_t *scan = ctx->list; while (scan) { header_list_t *next_hdr = scan->next; if (scan->alloc_flags & ALLOC_HEADER) serf_bucket_mem_free(bucket->allocator, (void *)scan->header); if (scan->alloc_flags & ALLOC_VALUE) serf_bucket_mem_free(bucket->allocator, (void *)scan->value); serf_bucket_mem_free(bucket->allocator, scan); scan = next_hdr; } serf_default_destroy_and_data(bucket); }