initial commit

prezzyipc.c

@@ -0,0 +1,132 @@
+/*
+ * prezzyipc.c
+ * Copyright (c) 2024 Jeremy Baxter.
+ */
+
+#define _PREZZYIPC_C_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "prezzyipc.h"
+
+void
+dumpPacket(PrezzyIpcPacket p)
+{
+	fprintf(stderr,
+			"[packet]\n"
+			"property = %d\n"
+			"type = %d\n"
+			"payload = ",
+			p.property, p.type);
+	if (p.type == PLT_STRING)
+		fprintf(stderr, "%s\n", p.pString);
+	else
+		fprintf(stderr, "%ld\n", p.pInteger);
+}
+
+char *
+fromIpcPacket(PrezzyIpcPacket p)
+{
+	char *buffer;
+
+	buffer = malloc(PREZZY_PACKET_MAX * sizeof(char));
+
+	if (p.type == PLT_STRING) {
+		snprintf(buffer, PREZZY_PACKET_MAX, "%c%s\n",
+				 p.property, p.pString);
+	} else {
+		snprintf(buffer, PREZZY_PACKET_MAX, "%c%ld\n",
+				 p.property, p.pInteger);
+	}
+
+	return buffer;
+}
+
+PrezzyIpcPacket *
+makeIpcPacket(const char *buffer)
+{
+	PrezzyIpcPacket *m;
+	int i;
+
+	m = malloc(sizeof(PrezzyIpcPacket));
+
+	/* extract property */
+	m->property = buffer[0];
+	if (m->property < 0 || m->property >= PREZZY_PROPERTY_MAX)
+		return NULL;
+
+	/* determine payload type */
+	m->type = payloadTypeMapping[m->property];
+
+	switch (m->type) {
+	case PLT_STRING:
+		m->pString = NULL;
+		for (i = 1; buffer[i] != '\n' && buffer[i] != '\0'
+					&& i < PREZZY_PACKET_MAX; i++) {
+			m->pString = realloc(m->pString, (i + 1) * sizeof(char));
+			m->pString[i - 1] = buffer[i];
+			m->pString[i] = '\0';
+		}
+		break;
+	case PLT_INT64:
+		m->pInteger = strtol(buffer + 1, NULL, 10);
+		break;
+	case PLT_INT:
+		m->pInteger = squashLong(strtol(buffer + 1, NULL, 10));
+		break;
+	default: break;
+	}
+
+	return m;
+}
+
+int
+squashLong(long l)
+{
+	return (l >= INT_MIN && l <= INT_MAX) ? l : INT_MAX ;
+}
+
+/*
+ * Copy string src to buffer dst of size dsize.  At most dsize-1
+ * chars will be copied.  Always NUL terminates (unless dsize == 0).
+ * Returns strlen(src); if retval >= dsize, truncation occurred.
+ */
+size_t
+strbcpy(char *dst, const char *src, size_t dsize)
+{
+	const char *osrc = src;
+	size_t nleft = dsize;
+
+	/* Copy as many bytes as will fit. */
+	if (nleft != 0) {
+		while (--nleft != 0) {
+			if ((*dst++ = *src++) == '\0')
+				break;
+		}
+	}
+
+	/* Not enough room in dst, add NUL and traverse rest of src. */
+	if (nleft == 0) {
+		if (dsize != 0)
+			*dst = '\0'; /* NUL-terminate dst */
+		while (*src++)
+			;
+	}
+
+	return (src - osrc - 1); /* count does not include NUL */
+}
+
+char *
+stringFrom(const char *reference)
+{
+	char *buffer;
+	size_t len;
+
+	len = strlen(reference) + 1;
+	buffer = malloc(len * sizeof(char));
+	strbcpy(buffer, reference, len);
+
+	return buffer;
+}