beginning the implementation of new output / probe module interface

src/fieldset.c

@@ -0,0 +1,129 @@
+#include "fieldset.h"
+
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "../lib/logger.h"
+
+// maximum number of records that can be stored in a fieldset
+#define MAX_FIELDS 128
+
+// types of data that can be stored in a field
+#define FS_STRING 0
+#define FS_UINT64 1
+#define FS_BINARY 2
+
+// definition of a field that's provided by a probe module
+// these are used so that users can ask at the command-line
+// what fields are available for consumption
+typedef struct field_def {
+	const char *name;
+	const char *type;
+	const char *desc;
+} field_def_t;
+
+// the internal field type used by fieldset
+typedef struct field {
+	const char *name;
+	int type;
+	int free_;
+	size_t len;
+	void *value;
+} field_t;
+
+// data structure that is populated by the probe module
+// and translated into the data structure that's passed
+// to the output module
+typedef struct fieldset {
+	int len;
+	field_t fields[MAX_FIELDS];
+} fieldset_t;
+
+// we pass a different fieldset to an output module than 
+// the probe module generates for us because a user may
+// only want certain fields and will expect them in a certain
+// order. We generate a translated fieldset that contains
+// only the fields we want to export to the output module.
+// a translation specifies how to efficiently convert the fs
+// povided by the probe module to the fs for the output module.
+typedef struct translation {
+	int len;
+	int translation[MAX_FIELDS];
+} translation_t;
+
+int fs_split_string(int *len, char**results)
+{
+	
+}
+
+fieldset_t *fs_new_fieldset(void)
+{
+	fieldset_t *f = malloc(sizeof(fieldset_t));
+	if (!f) {
+		log_fatal("fieldset", "unable to allocate new fieldset");
+	}
+	memset(f, 0, sizeof(fieldset_t));
+	return f;	
+}
+
+static inline void fs_add_word(fieldset_t *fs, const char *name, int type,
+		int free_, size_t len, void *value)
+{
+	if (fs->len + 1 >= MAX_FIELDS) {
+		log_fatal("fieldset", "out of room in fieldset");
+	}
+	field_t *f = &(fs->fields[fs->len]);
+	fs->len++;
+	f->type = type;
+	f->name = name;
+	f->len = len;
+	f->value = value;
+	f->free_ = free_;
+}
+
+void fs_add_string(fieldset_t *fs, const char *name, char *value, int free_)
+{
+	fs_add_word(fs, name, FS_STRING, free_, strlen(value), (void*) value);
+}
+
+void fs_add_uint64(fieldset_t *fs, const char *name, uint64_t value)
+{
+	fs_add_word(fs, name, FS_STRING, 0, sizeof(uint64_t), (void*) value);
+}
+
+void fs_add_binary(fieldset_t *fs, const char *name, size_t len,
+		void *value, int free_)
+{
+	fs_add_word(fs, name, FS_BINARY, free_, len, value);
+}
+
+void fs_free(fieldset_t *fs)
+{
+	for (int i=0; i < fs->len; i++) {
+		field_t *f = &(fs->fields[i]);
+		if (f->free_) {
+			free(f->value);
+		}
+	}
+	free(fs);
+}
+
+translation_t *fs_generate_fieldset_translation()
+{
+
+}
+
+fieldset_t *translate_fieldset(fieldset_t *fs, translation_t *t)
+{
+	fieldset_t *retv = fs_new_fieldset();
+	if (!retv) {
+		log_fatal("fieldset", "unable to allocate space for translated field set");
+	}
+	for (int i=0; i < t->len; i++) {
+		int o = t->translation[i];
+		memcpy(&(retv->fields[i]), &(fs->fields[o]), sizeof(field_t));
+	}
+	retv->len = t->len;
+}