ldconfig -p | grep serf

        libserf-1.so.1 (libc6,x86-64) => /usr/local/serf/lib/libserf-1.so.1
        libserf-1.so (libc6,x86-64) => /usr/local/serf/lib/libserf-1.so

mkdir -p /var/www/demo
echo "<h1>Hello from Apache Serf demo</h1><p>Serf 1.3.10 async HTTP client test page.</p>" > /var/www/demo/index.html
cd /var/www/demo && nohup python3 -m http.server 8000 >/tmp/httpd.log 2>&1 &

serf_context_t（事件循环）
 └── serf_connection_t（到同一主机的 TCP 连接，可复用/排队多请求）
      └── serf_request_t（一次 HTTP 请求，挂 setup/acceptor/handler 三回调）
           ├── setup      → serf_bucket_request_create 组装请求桶
           ├── acceptor   → 把响应字节流包装成响应桶
           └── handler    → serf_bucket_response_status 读状态行 + serf_bucket_read 读响应体

typedef apr_status_t (*serf_connection_setup_t)(apr_socket_t *skt,
    serf_bucket_t **read_bkt, serf_bucket_t **write_bkt,
    void *setup_baton, apr_pool_t *pool);

apr_status_t serf_bucket_read(serf_bucket_t *bucket, apr_size_t len,
                              const char **data, apr_size_t *len);
/* 返回 APR_SUCCESS（还有数据）、APR_EAGAIN（暂时没有）、APR_EOF（读尽） */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <apr.h>
#include <apr_pools.h>
#include <apr_uri.h>
#include "serf.h"

typedef struct {
    int done;
    int status_code;
    char body[65536];
    size_t blen;
    serf_bucket_alloc_t *bkt_alloc;
} app_ctx_t;

/* 连接级回调（必填）：socket 包装成输入桶 */
static apr_status_t conn_setup(apr_socket_t *skt, serf_bucket_t **input_bkt,
                               serf_bucket_t **output_bkt, void *setup_baton,
                               apr_pool_t *pool)
{
    app_ctx_t *ctx = setup_baton;
    *input_bkt = serf_bucket_socket_create(skt, ctx->bkt_alloc);
    return APR_SUCCESS;
}

/* acceptor：barrier + response 包装响应流 */
static serf_bucket_t *accept_response(serf_request_t *request,
                                      serf_bucket_t *stream,
                                      void *acceptor_baton, apr_pool_t *pool)
{
    serf_bucket_alloc_t *alloc = serf_request_get_alloc(request);
    serf_bucket_t *barrier = serf_bucket_barrier_create(stream, alloc);
    return serf_bucket_response_create(barrier, alloc);
}

/* handler：读状态行 + 循环读响应体；EOF 返回 APR_EOF */
static apr_status_t handle_response(serf_request_t *request,
                                    serf_bucket_t *response,
                                    void *handler_baton, apr_pool_t *pool)
{
    app_ctx_t *ctx = handler_baton;
    serf_status_line sl;
    apr_status_t status;

    if (response == NULL) {
        fprintf(stderr, "[demo] connection closed without response\n");
        ctx->done = 1;
        return APR_SUCCESS;
    }

    status = serf_bucket_response_status(response, &sl);
    if (status) {
        return status;
    }
    ctx->status_code = sl.code;

    while (1) {
        const char *data;
        apr_size_t len;

        status = serf_bucket_read(response, 4096, &data, &len);
        if (SERF_BUCKET_READ_ERROR(status)) {
            return status;
        }
        if (len > 0 && ctx->blen + len < sizeof(ctx->body)) {
            memcpy(ctx->body + ctx->blen, data, len);
            ctx->blen += len;
            ctx->body[ctx->blen] = '\0';
        }
        if (APR_STATUS_IS_EOF(status)) {
            ctx->done = 1;
            return APR_EOF;
        }
        if (APR_STATUS_IS_EAGAIN(status)) {
            return status;
        }
    }
    ctx->done = 1;
    return APR_SUCCESS;
}

/* request setup：组装 GET 请求桶并挂回调 */
static apr_status_t setup_request(serf_request_t *request, void *setup_baton,
                                  serf_bucket_t **req_bkt,
                                  serf_response_acceptor_t *acceptor,
                                  void **acceptor_baton,
                                  serf_response_handler_t *handler,
                                  void **handler_baton, apr_pool_t *pool)
{
    app_ctx_t *ctx = setup_baton;
    serf_bucket_alloc_t *alloc = serf_request_get_alloc(request);

    *req_bkt = serf_request_bucket_request_create(request, "GET", "/", NULL, alloc);
    *acceptor = accept_response;
    *acceptor_baton = ctx;
    *handler = handle_response;
    *handler_baton = ctx;
    return APR_SUCCESS;
}

int main(int argc, char **argv)
{
    apr_status_t status;
    apr_pool_t *pool;
    serf_context_t *ctx;
    serf_connection_t *conn;
    apr_uri_t host_info;
    app_ctx_t app;
    const char *url = (argc > 1) ? argv[1] : "http://127.0.0.1:8000";
    int loops = 0;

    memset(&app, 0, sizeof(app));

    apr_initialize();
    atexit(apr_terminate);
    apr_pool_create(&pool, NULL);

    ctx = serf_context_create(pool);
    app.bkt_alloc = serf_bucket_allocator_create(pool, NULL, NULL);

    apr_uri_parse(pool, url, &host_info);
    status = serf_connection_create2(&conn, ctx, host_info,
                                     conn_setup, &app, NULL, NULL, pool);
    if (status != APR_SUCCESS) {
        return 1;
    }

    serf_connection_request_create(conn, setup_request, &app);

    while (!app.done && loops < 200) {
        status = serf_context_run(ctx, 100000, pool);
        if (status && !APR_STATUS_IS_TIMEUP(status)) {
            return 1;
        }
        loops++;
    }

    printf("HTTP status: %d\n", app.status_code);
    printf("Body bytes : %zu\n", app.blen);
    printf("---- body ----\n%s\n--------------\n", app.body);

    serf_connection_close(conn);
    apr_pool_destroy(pool);
    return app.done ? 0 : 2;
}

cd /opt
gcc serf-demo.c -o serf-demo \
  -I/usr/local/serf/include/serf-1 \
  $(apr-1-config --cflags --includes) \
  $(apu-1-config --includes) \
  -L/usr/local/serf/lib -lserf-1 -lapr-1 -laprutil-1

/opt/serf-demo http://127.0.0.1:8000

HTTP status: 200
Body bytes : 84
---- body ----
<h1>Hello from Apache Serf demo</h1><p>Serf 1.3.10 async HTTP client test page.</p>

--------------