alef 0.110.4

Opinionated polyglot binding generator for Rust libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

{#- Once-per-suite mock-request-count helper (alef issue #443).

   Context variables (see src/e2e/codegen/mock_assertions/helper.rs for the full contract):
   - helper_name: function name
   - total_path: mock server's total-count endpoint path
   - one_path: mock server's single-key endpoint path

   Emits ONE `static` function using a raw POSIX socket (no libcurl dependency -- the generated
   C test project links no HTTP client, and this backend is the one the mock server's plain-text
   decimal body was designed for: a bare `strtol` over the response body needs no JSON parser).
   `base_url` is always "http://<host>:<port>" (see rust::mock_server::binary -- MOCK_SERVER_URL
   is always this shape), so the host/port split only needs to find the last ':' before any '/'.
   Callers build `pathAndQuery` from "{{ total_path }}?prefix=<p>" (mock.requests.total) or
   "{{ one_path }}?key=<k>" (mock.requests["<k>"]) -- see mock_assertions::model::MockQuery.

   `static` scopes this to one translation unit, matching every other per-file test helper this
   backend emits (see c/runner.rs's `alef_json_get_string`), so multiple generated .c files never
   collide. The extra `#include`s this needs (sys/socket.h, netdb.h, unistd.h) are injected by
   `c::assertion_mock_capture::append_helper_if_referenced`, only when this helper is actually
   referenced -- see that function's doc for why they cannot simply be unconditional.
#}

static int {{ helper_name }}(const char *base_url, const char *path_and_query) {
    const char *host_start = base_url;
    if (strncmp(host_start, "http://", 7) == 0) {
        host_start += 7;
    }
    const char *slash = strchr(host_start, '/');
    const char *colon = strrchr(host_start, ':');
    if (colon != NULL && slash != NULL && colon > slash) {
        colon = NULL;
    }
    size_t host_len;
    if (colon != NULL) {
        host_len = (size_t)(colon - host_start);
    } else if (slash != NULL) {
        host_len = (size_t)(slash - host_start);
    } else {
        host_len = strlen(host_start);
    }
    char host[256];
    if (host_len == 0 || host_len >= sizeof(host)) {
        fprintf(stderr, "{{ helper_name }}: unparseable host in '%s'\n", base_url);
        exit(1);
    }
    memcpy(host, host_start, host_len);
    host[host_len] = '\0';

    char port[16];
    strcpy(port, "80");
    if (colon != NULL) {
        const char *port_start = colon + 1;
        size_t port_len = slash != NULL ? (size_t)(slash - port_start) : strlen(port_start);
        if (port_len == 0 || port_len >= sizeof(port)) {
            fprintf(stderr, "{{ helper_name }}: unparseable port in '%s'\n", base_url);
            exit(1);
        }
        memcpy(port, port_start, port_len);
        port[port_len] = '\0';
    }

    struct addrinfo hints;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    struct addrinfo *resolved = NULL;
    int gai_error = getaddrinfo(host, port, &hints, &resolved);
    if (gai_error != 0) {
        fprintf(stderr, "{{ helper_name }}: getaddrinfo(%s:%s): %s\n", host, port, gai_strerror(gai_error));
        exit(1);
    }

    int sock_fd = -1;
    for (struct addrinfo *candidate = resolved; candidate != NULL; candidate = candidate->ai_next) {
        sock_fd = socket(candidate->ai_family, candidate->ai_socktype, candidate->ai_protocol);
        if (sock_fd == -1) {
            continue;
        }
        if (connect(sock_fd, candidate->ai_addr, candidate->ai_addrlen) == 0) {
            break;
        }
        close(sock_fd);
        sock_fd = -1;
    }
    freeaddrinfo(resolved);
    if (sock_fd == -1) {
        fprintf(stderr, "{{ helper_name }}: connect to %s:%s failed\n", host, port);
        exit(1);
    }

    char request[1024];
    int request_len = snprintf(
        request, sizeof(request),
        "GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", path_and_query, host
    );
    if (request_len < 0 || (size_t)request_len >= sizeof(request)) {
        fprintf(stderr, "{{ helper_name }}: request line too long for '%s'\n", path_and_query);
        close(sock_fd);
        exit(1);
    }

    size_t sent_total = 0;
    while (sent_total < (size_t)request_len) {
        ssize_t sent_now = send(sock_fd, request + sent_total, (size_t)request_len - sent_total, 0);
        if (sent_now <= 0) {
            fprintf(stderr, "{{ helper_name }}: send() failed\n");
            close(sock_fd);
            exit(1);
        }
        sent_total += (size_t)sent_now;
    }

    char response[4096];
    size_t response_len = 0;
    for (;;) {
        if (response_len >= sizeof(response) - 1) {
            fprintf(stderr, "{{ helper_name }}: response exceeded %zu bytes\n", sizeof(response) - 1);
            close(sock_fd);
            exit(1);
        }
        ssize_t received_now = recv(sock_fd, response + response_len, sizeof(response) - 1 - response_len, 0);
        if (received_now < 0) {
            fprintf(stderr, "{{ helper_name }}: recv() failed\n");
            close(sock_fd);
            exit(1);
        }
        if (received_now == 0) {
            break;
        }
        response_len += (size_t)received_now;
    }
    close(sock_fd);
    response[response_len] = '\0';

    const char *body = strstr(response, "\r\n\r\n");
    if (body == NULL) {
        fprintf(stderr, "{{ helper_name }}: malformed HTTP response (no header terminator): %s\n", response);
        exit(1);
    }
    body += 4;
    return (int)strtol(body, NULL, 10);
}