Rewrite codebase, add device-system

configure.ac

@@ -1,5 +1,5 @@
 AC_INIT([light], [1.2-dev], [https://github.com/haikarainen/light/issues])
-AM_INIT_AUTOMAKE([1.11 foreign])
+AM_INIT_AUTOMAKE([1.11 foreign subdir-objects])
 AM_SILENT_RULES([yes])
 
 AC_CONFIG_SRCDIR([src/light.c])

src/Makefile.am

@@ -1,5 +1,5 @@
 bin_PROGRAMS   = light
-light_SOURCES  = main.c light.c light.h helpers.c helpers.h
+light_SOURCES  = main.c light.c light.h helpers.c helpers.h impl/sysfs.c impl/sysfs.h
 light_CPPFLAGS = -I../include -D_GNU_SOURCE
 light_CFLAGS   = -W -Wall -Wextra -std=gnu99 -Wno-type-limits
 

src/helpers.c

@@ -5,20 +5,25 @@
 #include <string.h>
 #include <sys/types.h>
 #include <dirent.h>
+#include <errno.h> // errno
+#include <libgen.h> // dirname 
 
-bool light_file_read_val(char const *filename, unsigned long *val)
+
+bool light_file_read_uint64(char const *filename, uint64_t *val)
 {
 	FILE *fp;
-	unsigned long data;
+	uint64_t data;
 
 	fp = fopen(filename, "r");
-	if (!fp) {
+	if (!fp)
+	{
 		LIGHT_PERMERR("reading");
 		return false;
 	}
 
-	if (fscanf(fp, "%lu", &data) != 1) {
-		LIGHT_ERR("Couldn't parse a positive integer number from '%s'", filename);
+	if (fscanf(fp, "%lu", &data) != 1)
+	{
+		LIGHT_ERR("Couldn't parse an unsigned integer from '%s'", filename);
 		fclose(fp);
 		return false;
 	}
@@ -29,17 +34,19 @@ bool light_file_read_val(char const *filename, unsigned long *val)
 	return true;
 }
 
-bool light_file_write_val(char const *filename, unsigned long val)
+bool light_file_write_uint64(char const *filename, uint64_t val)
 {
 	FILE *fp;
 
 	fp = fopen(filename, "w");
-	if (!fp) {
+	if (!fp)
+	{
 		LIGHT_PERMERR("writing");
 		return false;
 	}
 
-	if (fprintf(fp, "%lu", val) < 0) {
+	if (fprintf(fp, "%lu", val) < 0)
+	{
 		LIGHT_ERR("fprintf failed");
 		fclose(fp);
 		return false;
@@ -55,7 +62,8 @@ bool light_file_is_writable(char const *filename)
 	FILE *fp;
 
 	fp = fopen(filename, "r+");
-	if (!fp) {
+	if (!fp)
+	{
 		LIGHT_PERMWARN("writing");
 		return false;
 	}
@@ -70,7 +78,8 @@ bool light_file_is_readable(char const *filename)
 	FILE *fp;
 
 	fp = fopen(filename, "r");
-	if (!fp) {
+	if (!fp)
+	{
 		LIGHT_PERMWARN("reading");
 		return false;
 	}
@@ -80,14 +89,14 @@ bool light_file_is_readable(char const *filename)
 }
 
 /* Prints a notice about a value which was below `x` and was adjusted to it */
-unsigned long light_log_clamp_min(unsigned long min)
+uint64_t light_log_clamp_min(uint64_t min)
 {
 	LIGHT_NOTE("too small value, adjusting to mininum %lu (raw)", min);
 	return min;
 }
 
 /* Prints a notice about a value which was above `x` and was adjusted to it */
-unsigned long light_log_clamp_max(unsigned long max)
+uint64_t light_log_clamp_max(uint64_t max)
 {
 	LIGHT_NOTE("too large value, adjusting to mavalimum %lu (raw)", max);
 	return max;
@@ -96,15 +105,36 @@ unsigned long light_log_clamp_max(unsigned long max)
 /* Clamps the `percent` value between 0% and 100% */
 double light_percent_clamp(double val)
 {
-	if (val < 0.0) {
+	if (val < 0.0)
+	{
 		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 0%%", val);
 		return 0.0;
 	}
 
-	if (val > 100.0) {
+	if (val > 100.0)
+	{
 		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 100%%", val);
 		return 100.0;
 	}
 
 	return val;
 }
+
+int light_mkpath(char *dir, mode_t mode)
+{
+	struct stat sb;
+
+	if (!dir)
+	{
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (!stat(dir, &sb))
+		return 0;
+
+	light_mkpath(dirname(strdupa(dir)), mode);
+
+	return mkdir(dir, mode);
+}
+

src/helpers.h

@@ -1,7 +1,10 @@
-#ifndef LIGHT_HELPERS_H
-#define LIGHT_HELPERS_H
+
+#pragma once
 
 #include <stdbool.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <stdio.h>
 
 /* Clamps x(value) between y(min) and z(max) in a nested ternary operation */
 #define LIGHT_CLAMP(val, min, max)					\
@@ -29,9 +32,9 @@ light_loglevel_t light_loglevel;
 	if (light_loglevel >= lvl)					\
 		fprintf(fp, "%s:%d:" fmt "\n", __FILE__, __LINE__, ##args)
 
-#define LIGHT_NOTE(fmt, args...) LIGHT_LOG(LIGHT_NOTE_LEVEL,  stdout, "NOTE:" fmt, ##args)
-#define LIGHT_WARN(fmt, args...) LIGHT_LOG(LIGHT_WARN_LEVEL,  stderr, "WARN:" fmt, ##args)
-#define LIGHT_ERR(fmt, args...)  LIGHT_LOG(LIGHT_ERROR_LEVEL, stderr, "!ERR:" fmt, ##args)
+#define LIGHT_NOTE(fmt, args...) LIGHT_LOG(LIGHT_NOTE_LEVEL,  stdout, " Notice: " fmt, ##args)
+#define LIGHT_WARN(fmt, args...) LIGHT_LOG(LIGHT_WARN_LEVEL,  stderr, " Warning: " fmt, ##args)
+#define LIGHT_ERR(fmt, args...)  LIGHT_LOG(LIGHT_ERROR_LEVEL, stderr, " Error: " fmt, ##args)
 #define LIGHT_MEMERR()           LIGHT_ERR("memory error");
 #define LIGHT_PERMLOG(act, log)						\
 	do {								\
@@ -41,15 +44,16 @@ light_loglevel_t light_loglevel;
 #define LIGHT_PERMERR(x)         LIGHT_PERMLOG(x, LIGHT_ERR)
 #define LIGHT_PERMWARN(x)        LIGHT_PERMLOG(x, LIGHT_WARN)
 
-bool light_file_write_val   (char const *filename, unsigned long val);
-bool light_file_read_val    (char const *filename, unsigned long *val);
+bool light_file_write_uint64   (char const *filename, uint64_t val);
+bool light_file_read_uint64    (char const *filename, uint64_t *val);
 
 bool light_file_is_writable (char const *filename);
 bool light_file_is_readable (char const *filename);
 
-unsigned long light_log_clamp_min(unsigned long min);
-unsigned long light_log_clamp_max(unsigned long max);
+uint64_t light_log_clamp_min(uint64_t min);
+uint64_t light_log_clamp_max(uint64_t max);
 
 double light_percent_clamp(double percent);
 
-#endif /* LIGHT_HELPERS_H */
+int light_mkpath(char *dir, mode_t mode);
+

src/impl/razer.c

@@ -0,0 +1 @@
+ 

src/impl/razer.h

@@ -0,0 +1 @@
+ 

src/impl/sysfs.c

@@ -0,0 +1,255 @@
+
+#include "impl/sysfs.h"
+#include "light.h"
+#include "helpers.h"
+
+#include <stdio.h> //snprintf
+#include <stdlib.h> // malloc, free
+#include <dirent.h> // opendir, readdir
+
+static bool _impl_sysfs_init_leds(light_device_enumerator_t *enumerator)
+{
+	// Create a new backlight device
+	light_device_t *leds_device = malloc(sizeof(light_device_t));
+	snprintf(leds_device->name, sizeof(leds_device->name), "%s", "leds");
+	
+	// Add it to the enumerator 
+	light_add_enumerator_device(enumerator, leds_device);
+	
+	// Iterate through the led controllers and create a device_target for each controller 
+	DIR *leds_dir;
+	struct dirent *curr_entry;
+	
+	if((leds_dir = opendir("/sys/class/leds")) == NULL)
+	{
+		LIGHT_ERR("failed to open leds controller directory for reading");
+		return false;
+	}
+	
+	while((curr_entry = readdir(leds_dir)) != NULL)
+	{
+		// Skip dot entries
+		if(curr_entry->d_name[0] == '.')
+		{
+			continue;
+		}
+		
+		// Create a new device target for the controller 
+		light_device_target_t *led_controller = malloc(sizeof(light_device_target_t));
+		snprintf(led_controller->name, sizeof(led_controller->name), "%s", curr_entry->d_name);
+		
+		// Setup the function bindings
+		led_controller->set_value = impl_sysfs_set;
+		led_controller->get_value = impl_sysfs_get;
+		led_controller->get_max_value = impl_sysfs_getmax;
+		led_controller->custom_command = impl_sysfs_command;
+		
+		// Setup the target data 
+		impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
+		led_controller->device_target_data = dev_data;
+		snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/leds/%s/brightness", curr_entry->d_name);
+		snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/leds/%s/max_brightness", curr_entry->d_name);
+		
+		// Add it to the device
+		light_add_device_target(leds_device, led_controller);
+	}
+	
+	return true;
+}
+
+static bool _impl_sysfs_init_backlight(light_device_enumerator_t *enumerator)
+{
+	// Create a new backlight device
+	light_device_t *backlight_device = malloc(sizeof(light_device_t));
+	snprintf(backlight_device->name, sizeof(backlight_device->name), "%s", "backlight");
+	
+	// Add it to the enumerator 
+	light_add_enumerator_device(enumerator, backlight_device);
+	
+	// Iterate through the backlight controllers and create a device_target for each controller 
+	DIR *backlight_dir;
+	struct dirent *curr_entry;
+	
+	// Keep track of the best controller, and create an autodevice from that
+	char best_controller[NAME_MAX];
+	uint64_t best_value = 0;
+	
+	if((backlight_dir = opendir("/sys/class/backlight")) == NULL)
+	{
+		LIGHT_ERR("failed to open backlight controller directory for reading");
+		return false;
+	}
+	
+	while((curr_entry = readdir(backlight_dir)) != NULL)
+	{
+		// Skip dot entries
+		if(curr_entry->d_name[0] == '.')
+		{
+			continue;
+		}
+		
+		// Create a new device target for the controller 
+		light_device_target_t *backlight_controller = malloc(sizeof(light_device_target_t));
+		snprintf(backlight_controller->name, sizeof(backlight_controller->name), "%s", curr_entry->d_name);
+		
+		// Setup the function bindings
+		backlight_controller->set_value = impl_sysfs_set;
+		backlight_controller->get_value = impl_sysfs_get;
+		backlight_controller->get_max_value = impl_sysfs_getmax;
+		backlight_controller->custom_command = impl_sysfs_command;
+		
+		// Setup the target data 
+		impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
+		backlight_controller->device_target_data = dev_data;
+		snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/backlight/%s/brightness", curr_entry->d_name);
+		snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/backlight/%s/max_brightness", curr_entry->d_name);
+		
+		// Read the max brightness to get the best one
+		uint64_t curr_value = 0;
+		if(light_file_read_uint64(dev_data->max_brightness, &curr_value))
+		{
+			if(curr_value > best_value)
+			{
+				best_value = curr_value;
+				snprintf(best_controller, sizeof(best_controller), "%s", backlight_controller->name);
+			}
+		}
+		
+		// Add it to the device
+		light_add_device_target(backlight_device, backlight_controller);
+	}
+	
+	// Create an auto controller 
+	light_device_target_t *auto_controller = malloc(sizeof(light_device_target_t));
+	snprintf(auto_controller->name, sizeof(auto_controller->name), "%s", "auto");
+	
+	// Setup the function bindings
+	auto_controller->set_value = impl_sysfs_set;
+	auto_controller->get_value = impl_sysfs_get;
+	auto_controller->get_max_value = impl_sysfs_getmax;
+	auto_controller->custom_command = impl_sysfs_command;
+	
+	// Setup the target data 
+	impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
+	auto_controller->device_target_data = dev_data;
+	snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/backlight/%s/brightness", best_controller);
+	snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/backlight/%s/max_brightness", best_controller);
+	
+	// Add it to the device
+	light_add_device_target(backlight_device, auto_controller);
+	
+	return true;
+}
+
+bool impl_sysfs_init(light_device_enumerator_t *enumerator)
+{
+	// Create a device for the backlight 
+	_impl_sysfs_init_backlight(enumerator);
+	
+	// Create devices for the leds
+	 _impl_sysfs_init_leds(enumerator);
+	
+	return true;
+}
+
+bool impl_sysfs_free(light_device_enumerator_t *enumerator)
+{
+	// Iterate through the devices in the enumerator
+	for(uint64_t d = 0; d < enumerator->num_devices; d++)
+	{
+		light_device_t *curr_device = enumerator->devices[d];
+		
+		// If the given device points to NULL, we can safely skip it
+		if(curr_device == NULL)
+		{
+			continue;
+		}
+		
+		// If the given device has a targets array that isnt NULL, iterate through it to free the targets, then free the array
+		if(curr_device->targets != NULL)
+		{
+			for(uint64_t t = 0; t < curr_device->num_targets; t++)
+			{
+				light_device_target_t *curr_target = curr_device->targets[t];
+				
+				if(curr_target == NULL)
+				{
+					continue;
+				}
+				
+				if(curr_target->device_target_data != NULL)
+				{
+					free(curr_target->device_target_data);
+				}
+				
+				free(curr_target);
+			}
+			
+			free(curr_device->targets);
+		}
+		
+		// If the given device has any device_data, free it
+		if(curr_device->device_data != NULL)
+		{
+			free(curr_device->device_data);
+		}
+		
+		// Free the device
+		free(curr_device);
+	}
+	
+	// Free the devices array
+	free(enumerator->devices);
+	enumerator->devices = NULL;
+	enumerator->num_devices = 0;
+	
+	return true;
+}
+
+bool impl_sysfs_set(light_device_target_t *target, uint64_t in_value)
+{
+	impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
+
+	if(!light_file_write_uint64(data->brightness, in_value))
+	{
+		LIGHT_ERR("failed to write to sysfs device");
+		return false;
+	}
+	
+	return true;
+}
+
+bool impl_sysfs_get(light_device_target_t *target, uint64_t *out_value)
+{
+	impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
+
+	if(!light_file_read_uint64(data->brightness, out_value))
+	{
+		LIGHT_ERR("failed to read from sysfs device");
+		return false;
+	}
+	
+	return true;
+}
+
+bool impl_sysfs_getmax(light_device_target_t *target, uint64_t *out_value)
+{
+	impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
+
+	if(!light_file_read_uint64(data->max_brightness, out_value))
+	{
+		LIGHT_ERR("failed to read from sysfs device");
+		return false;
+	}
+	
+	return true;
+}
+
+bool impl_sysfs_command(light_device_target_t *target, char const *command_string)
+{
+	// No current need for custom commands in sysfs enumerator
+	// To implement support, simply parse the command string to your liking, and return false on invalid input or results!
+	return true;
+}
+
+

src/impl/sysfs.h

@@ -0,0 +1,21 @@
+
+#pragma once 
+
+#include "light.h"
+
+// Implementation of the sysfs enumerator
+// Enumerates devices for backlights and leds
+
+// Device target data 
+typedef struct {
+	char brightness[NAME_MAX];
+	char max_brightness[NAME_MAX];
+} impl_sysfs_data_t;
+
+bool impl_sysfs_init(light_device_enumerator_t *enumerator);
+bool impl_sysfs_free(light_device_enumerator_t *enumerator);
+
+bool impl_sysfs_set(light_device_target_t *target, uint64_t in_value);
+bool impl_sysfs_get(light_device_target_t *target, uint64_t *out_value);
+bool impl_sysfs_getmax(light_device_target_t *target, uint64_t *out_value);
+bool impl_sysfs_command(light_device_target_t *target, char const *command_string);

src/light.h

@@ -1,105 +1,166 @@
-#ifndef LIGHT_H_
-#define LIGHT_H_
 
-#include "config.h"
-#include "helpers.h"
+#pragma once
 
+#include <stdint.h>
 #include <stdbool.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <linux/limits.h>
+#include <limits.h> // NAME_MAX
+#include <stddef.h> // NULL
+
+#include "config.h"
 
-#define LIGHT_YEAR   "2012-2018"
+#define LIGHT_YEAR   "2012 - 2018"
 #define LIGHT_AUTHOR "Fredrik Haikarainen"
 
-#define ASSERT_SET(t, v)						\
-	if (v) {							\
-		fprintf(stderr, t " cannot be used more than once.\n"); \
-		return false;						\
-	}								\
-	v = true;
-
-#define ASSERT_CMDSET()    ASSERT_SET("Commands", cmd_set)
-#define ASSERT_TARGETSET() ASSERT_SET("Targets", target_set)
-#define ASSERT_FIELDSET()  ASSERT_SET("Fields", field_set)
-#define ASSERT_CTRLSET()   ASSERT_SET("Controllers", ctrl_set)
-#define ASSERT_VALSET()    ASSERT_SET("Values", val_set)
-
-typedef enum {
-	LIGHT_BRIGHTNESS = 0,
-	LIGHT_MAX_BRIGHTNESS,
-	LIGHT_MIN_CAP,
-	LIGHT_SAVERESTORE
-} light_field_t;
-
-typedef enum {
-	LIGHT_BACKLIGHT = 0,
-	LIGHT_KEYBOARD
-} light_target_t;
-
-typedef enum {
-	LIGHT_AUTO = 0,
-	LIGHT_SPECIFY
-} light_ctrl_mode_t;
-
-typedef enum {
-	LIGHT_GET = 0,
-	LIGHT_SET,
-	LIGHT_ADD,
-	LIGHT_SUB,
-	LIGHT_PRINT_HELP,	/* Prints help and exits  */
-	LIGHT_PRINT_VERSION,	/* Prints version info and exits */
-	LIGHT_LIST_CTRL,
-	LIGHT_RESTORE,
-	LIGHT_SAVE
-} light_cmd_t;
-
-typedef enum {
-	LIGHT_RAW = 0,
-	LIGHT_PERCENT
-} light_val_mode_t;
-
-typedef struct {
-	/* Cache file prefix */
-	char               prefix[NAME_MAX];
-
-	/* Which controller to use */
-	light_ctrl_mode_t  ctrl;
-	char               ctrl_name[NAME_MAX + 1];
-
-	/* What to do with the controller */
-	light_cmd_t        cmd;
-	light_val_mode_t   val_mode;
-	unsigned long      val_raw;	/* The specified value in raw mode */
-	double             val_percent;	/* The specified value in percent */
-
-	light_target_t     target;
-	light_field_t      field;
-
-	/* Cache data */
-	bool               has_cached_brightness_max;
-	unsigned long      cached_brightness_max;
-} light_ctx_t;
-
-/* -- Global variable holding the settings for the current run -- */
-light_ctx_t ctx;
-
-bool light_initialize              (int argc, char **argv);
-bool light_execute                 (void);
-void light_free                    (void);
-
-bool light_ctrl_list               (void);
-bool light_ctrl_probe              (char *controller, size_t len);
-bool light_ctrl_exist              (char const *controller);
-
-bool light_ctrl_get_brightness     (char const *controller, unsigned long *v);
-bool light_ctrl_set_brightness     (char const *controller, unsigned long v);
-bool light_ctrl_get_brightness_max (char const *controller, unsigned long *v);
-
-bool light_ctrl_get_cap_min        (char const *controller, bool *hasMinCap, unsigned long *minCap);
-bool light_ctrl_set_cap_min        (char const *controller, unsigned long val);
-
-bool light_ctrl_save_brightness    (char const *controller, unsigned long val);
-bool light_ctrl_restore_brightness (char const *controller);
-
-#endif /* LIGHT_H_ */
+struct _light_device_target_t;
+typedef struct _light_device_target_t light_device_target_t;
+
+struct _light_device_t;
+typedef struct _light_device_t light_device_t;
+
+struct _light_device_enumerator_t;
+typedef struct _light_device_enumerator_t light_device_enumerator_t;
+
+/* Function pointers that implementations have to set for device targets */
+typedef bool (*LFUNCVALSET)(light_device_target_t*, uint64_t);
+typedef bool (*LFUNCVALGET)(light_device_target_t*, uint64_t*);
+typedef bool (*LFUNCMAXVALGET)(light_device_target_t*, uint64_t*);
+typedef bool (*LFUNCCUSTOMCMD)(light_device_target_t*, char const *);
+
+/* Describes a target within a device (for example a led on a keyboard, or a controller for a backlight) */
+struct _light_device_target_t
+{
+	char           name[256];
+	LFUNCVALSET    set_value;
+	LFUNCVALGET    get_value;
+	LFUNCMAXVALGET get_max_value;
+	LFUNCCUSTOMCMD custom_command;
+	void           *device_target_data;
+	light_device_t *device;
+};
+
+
+/* Describes a device (a backlight, a keyboard, a led-strip) */
+struct _light_device_t
+{
+	char                  name[256];
+	light_device_target_t **targets;
+	uint64_t              num_targets;
+	void                  *device_data;
+	light_device_enumerator_t *enumerator;
+};
+
+
+typedef bool (*LFUNCENUMINIT)(light_device_enumerator_t*);
+typedef bool (*LFUNCENUMFREE)(light_device_enumerator_t*);
+
+/* An enumerator that is responsible for creating and freeing devices as well as their targets */
+struct _light_device_enumerator_t
+{
+	char          name[256];
+	LFUNCENUMINIT init;
+	LFUNCENUMFREE free;
+
+	light_device_t **devices;
+	uint64_t num_devices;
+};
+
+typedef struct _light_context_t light_context_t;
+
+// A command that can be run (set, get, add, subtract, print help, print version, list devices etc.)
+typedef bool (*LFUNCCOMMAND)(light_context_t *);
+
+
+/*
+	Options
+	v		Specify verbosity, defaults to o
+	s		Specify target, defaults to sysfs/backlight/auto
+	r		Use raw values instead of percentage
+	
+	Operations
+	H,h 	Print help and exit
+	V		Print version and exit
+	L		List devices
+	
+	G		Get brigthness 
+	M		Get max brightness
+	N		Set minimum cap
+	P		Get minimum cap
+	S		Set brigthness
+	
+	A		Increase brightness
+	U		Decrease brightness
+	O		Save brightness
+	I		Restore brightness
+ */
+
+// The different available commands
+bool light_cmd_print_help(light_context_t *ctx); // H,h 
+bool light_cmd_print_version(light_context_t *ctx); // V
+bool light_cmd_list_devices(light_context_t *ctx); // L
+bool light_cmd_set_brightness(light_context_t *ctx); // S
+bool light_cmd_get_brightness(light_context_t *ctx); // G
+bool light_cmd_get_max_brightness(light_context_t *ctx); // M
+bool light_cmd_set_min_brightness(light_context_t *ctx); // N
+bool light_cmd_get_min_brightness(light_context_t *ctx); // P
+bool light_cmd_add_brightness(light_context_t *ctx); // A
+bool light_cmd_sub_brightness(light_context_t *ctx); // U
+bool light_cmd_save_brightness(light_context_t *ctx); // O
+bool light_cmd_restore_brightness(light_context_t *ctx); // I
+
+
+// CONFDIR/targets/<enumerator>/<device>/<target>/ minimum|saved
+
+struct _light_context_t
+{
+	struct 
+	{
+		LFUNCCOMMAND			command; // What command was issued 
+		uint64_t				value; // The input value, in raw mode
+		bool					raw_mode; // Whether or not we use raw or percentage mode
+		light_device_target_t	*device_target; // The device target to act on
+	} run_params;
+
+	struct
+	{
+		char					conf_dir[NAME_MAX]; // The path to the application cache directory 
+	} sys_params;
+	
+	light_device_enumerator_t **enumerators;
+	uint64_t num_enumerators;
+
+};
+
+/* Initializes the application, given the command-line. Returns a context. */
+light_context_t* light_initialize(int argc, char **argv);
+
+/* Executes the given context. Returns true on success, false on failure. */
+bool light_execute(light_context_t*);
+
+/* Frees the given context */
+void light_free(light_context_t*);
+
+/* Create a device enumerator in the given context */
+light_device_enumerator_t * light_create_enumerator(light_context_t *ctx, char const * name, LFUNCENUMINIT, LFUNCENUMFREE);
+
+/* Initializes all the device enumerators (and its devices, targets) */
+bool light_init_enumerators(light_context_t *ctx);
+
+/* Frees all the device enumerators (and its devices, targets) */
+bool light_free_enumerators(light_context_t *ctx);
+
+void light_add_enumerator_device(light_device_enumerator_t *enumerator, light_device_t *new_device);
+
+void light_add_device_target(light_device_t *device, light_device_target_t *new_target);
+
+typedef struct _light_target_path_t light_target_path_t;
+struct _light_target_path_t 
+{
+	char enumerator[NAME_MAX];
+	char device[NAME_MAX];
+	char target[NAME_MAX];
+};
+
+bool light_split_target_path(char const * in_path, light_target_path_t *out_path);
+
+/* Returns the found device target, or null. Name should be enumerator/device/target */
+light_device_target_t* light_find_device_target(light_context_t *ctx, char const * name);

src/main.c

@@ -1,6 +1,8 @@
+
 #include "light.h"
+#include "helpers.h"
 
-#include <stdio.h>
+//#include <stdio.h>
 
 #define LIGHT_RETURNVAL_INITFAIL  2
 #define LIGHT_RETURNVAL_EXECFAIL  1
@@ -8,17 +10,18 @@
 
 int main(int argc, char **argv)
 {
-	if (!light_initialize(argc, argv)) {
+	light_context_t *light_ctx = light_initialize(argc, argv);
+	if (light_ctx == NULL) {
 		LIGHT_ERR("Initialization failed");
 		return LIGHT_RETURNVAL_INITFAIL;
 	}
 
-	if (!light_execute()) {
+	if (!light_execute(light_ctx)) {
 		LIGHT_ERR("Execution failed");
-		light_free();
+		light_free(light_ctx);
 		return LIGHT_RETURNVAL_EXECFAIL;
 	}
 
-	light_free();
+	light_free(light_ctx);
 	return LIGHT_RETURNVAL_SUCCESS;
 }