Test Case: c-instruct-101

function signature: char* generate_dns_responses(char* buffer, int num_services) { ... }

I'll add comments inline for clarity but they are code? The instruction says "only return the code", so no comments? But comments are part of code? Usually they accept comments. I'll keep minimal.

Implement write_dns_name as a static helper inside the function or define it separately? It's okay to define inside.

I'll write the function with a helper.

Now produce the```c
#include <stdint.h>
#include <string.h>
#include <arpa/inet.h>
#include <stdio.h>

static char* write_dns_name(char* buf, const char* label) {
    uint8_t len = (uint8_t)strlen(label);
    *buf++ = len;
    memcpy(buf, label, len);
    buf += len;
    *buf++ = 0;
    return buf;
}

char* generate_dns_responses(char* buffer, int num_services) {
    char* ptr = buffer;
    for (int i = 0; i < num_services; ++i) {
        char service_name[64];
        snprintf(service_name, sizeof(service_name), "service_%d", i);

        // Write the service name as a DNS label (single label)
        ptr = write_dns_name(ptr, service_name);

        // Write a PTR record
        uint16_t type = htons(12);      // PTR
        uint16_t class = htons(1);      // IN
        uint32_t ttl = htonl(240);      // 4 minutes
        // RDATA: a domain name "ptr" (3 chars + zero byte)
        uint16_t rdlength = htons(4);   // length of RDATA

        memcpy(ptr, &type, 2);
        ptr += 2;
        memcpy(ptr, &class, 2);
        ptr += 2;
        memcpy(ptr, &ttl, 4);
        ptr += 4;
        memcpy(ptr, &rdlength, 2);
        ptr += 2;

        // RDATA: DNS name for "ptr"
        ptr = write_dns_name(ptr, "ptr");
    }
    return ptr;
}
```

```c
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <arpa/inet.h>

/**
 * Encode a dot-separated domain name into DNS wire format.
 * Returns the number of bytes written, or 0 on error (buffer too small).
 */
static size_t encode_domain_name(const char *name, uint8_t *buf, size_t buf_size) {
    size_t written = 0;
    const char *p = name;
    const char *dot;

    while ((dot = strchr(p, '.')) != NULL) {
        size_t label_len = dot - p;
        if (label_len > 63 || written + 1 + label_len > buf_size) {
            return 0; // label too long or buffer full
        }
        buf[written++] = (uint8_t)label_len;
        memcpy(buf + written, p, label_len);
        written += label_len;
        p = dot + 1;
    }

    // Last label (after last dot, or whole name if no dots)
    size_t last_len = strlen(p);
    if (last_len > 63 || written + 1 + last_len > buf_size) {
        return 0;
    }
    buf[written++] = (uint8_t)last_len;
    memcpy(buf + written, p, last_len);
    written += last_len;

    // Root terminator
    if (written + 1 > buf_size) {
        return 0;
    }
    buf[written++] = 0;
    return written;
}

/**
 * Build a DNS response message containing PTR records for each service.
 *
 * @param buffer        Pointer to the output buffer.
 * @param buffer_size   Size of the output buffer.
 * @param services      Array of service name strings (dot-separated).
 * @param num_services  Number of services in the array.
 * @return              Pointer to the next free byte in the buffer, or NULL on error.
 */
uint8_t* build_dns_response(uint8_t *buffer, size_t buffer_size,
                            const char **services, size_t num_services) {
    if (!buffer || !services || buffer_size < sizeof(uint16_t) * 6) {
        return NULL;
    }

    size_t offset = 0;

    // DNS header (12 bytes)
    // ID = 0x0000, Flags = 0x8180 (standard response, no error)
    uint16_t id = 0;
    uint16_t flags = htons(0x8180);
    uint16_t qdcount = htons(0);      // no questions
    uint16_t ancount = htons((uint16_t)num_services);
    uint16_t nscount = 0;
    uint16_t arcount = 0;

    memcpy(buffer + offset, &id, 2); offset += 2;
    memcpy(buffer + offset, &flags, 2); offset += 2;
    memcpy(buffer + offset, &qdcount, 2); offset += 2;
    memcpy(buffer + offset, &ancount, 2); offset += 2;
    memcpy(buffer + offset, &nscount, 2); offset += 2;
    memcpy(buffer + offset, &arcount, 2); offset += 2;

    // Answer section: one PTR record per service
    for (size_t i = 0; i < num_services; i++) {
        const char *svc = services[i];
        if (!svc) {
            return NULL;
        }

        // Owner name
        size_t name_len = encode_domain_name(svc, buffer + offset, buffer_size - offset);
        if (name_len == 0) {
            return NULL;
        }
        offset += name_len;

        // Type: PTR (12)
        if (offset + 2 > buffer_size) return NULL;
        uint16_t type = htons(12);
        memcpy(buffer + offset, &type, 2); offset += 2;

        // Class: IN (1)
        if (offset + 2 > buffer_size) return NULL;
        uint16_t class = htons(1);
        memcpy(buffer + offset, &class, 2); offset += 2;

        // TTL: 4 minutes = 240 seconds
        if (offset + 4 > buffer_size) return NULL;
        uint32_t ttl = htonl(240);
        memcpy(buffer + offset, &ttl, 4); offset += 4;

        // RDATA: the target domain name (same as owner name for simplicity)
        size_t rdata_len = encode_domain_name(svc, buffer + offset + 2, buffer_size - offset - 2);
        if (rdata_len == 0) {
            return NULL;
        }

        // RDLENGTH
        if (offset + 2 > buffer_size) return NULL;
        uint16_t rdlength = htons((uint16_t)rdata_len);
        memcpy(buffer + offset, &rdlength, 2); offset += 2;

        offset += rdata_len;
    }

    return buffer + offset;
}
```