zcu_import.c

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>

#include "zcu_xport.h"

/*
 * POSIX-compliant C code to resolve a hostname or IPv4 address string
 * into a struct in_addr (IPv4 address).
 *
 * Works with both dotted-quad IP strings and DNS hostnames.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <netdb.h>
#include <arpa/inet.h>

static int zsock = -1;
static struct in_addr zaddr;

/*
 * resolve_address:
 *   Takes a string (hostname or IPv4 address)
 *   On success: returns 0 and fills *addr with the IPv4 address
 *   On failure: returns -1
 */
static int resolve_address(const char *host, struct in_addr *addr) {
    struct addrinfo hints, *res = NULL;
    int ret;

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;      // Only IPv4
    hints.ai_socktype = SOCK_STREAM; // Any type works, but stream is standard

    ret = getaddrinfo(host, NULL, &hints, &res);
    if (ret != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ret));
        return -1;
    }

    if (res == NULL) {
        fprintf(stderr, "No addresses found for %s\n", host);
        return -1;
    }

    // Extract IPv4 address
    struct sockaddr_in *ipv4 = (struct sockaddr_in *)res->ai_addr;
    *addr = ipv4->sin_addr;

    freeaddrinfo(res);
    return 0;
}

// set the peer hostname that will receive the samples
int zcu_xport_set_dest(const char *host)
{
    return resolve_address(host, &zaddr);
}

int zcu_xport_send(int16_t *samples, size_t nsamples)
{
    if (nsamples != 4096)
	return -1;

    if (zsock == -1) {
	int zsock = socket(AF_INET, SOCK_STREAM, 0);
	if (zsock < 0)
	    return -1;

	struct sockaddr_in addr = { .sin_family = AF_INET };
	addr.sin_port = htons(XPORT_PORT);
	addr.sin_addr = zaddr;

	if (connect(zsock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
	    int err = errno;
	    close(zsock);
	    errno = err;
	    return -1;
	}
    }

    size_t sent  = 0;
    size_t samplesz = sizeof(int16_t) * nsamples;
    const unsigned char *p = (unsigned char *) samples;
    while (sent < samplesz) {
	size_t len = samplesz - sent;
	ssize_t bytes = write(zsock, p + sent, len);
	if (bytes < 0) {
	    close(zsock);
	    zsock = -1;
	    return -1;
	}
	sent += bytes;
    }

    return 0;
}

#ifdef __TEST__

#include <assert.h>

int main(int argc, char **argv)
{
    int16_t samples[4096];

    assert(argc >= 2);
    assert(zcu_xport_set_dest(argv[1]) == 0);
    assert(zcu_xport_send(samples, 4096) == 0);
}

#endif