Merge pull request #61 from haikarainen/device-rewrite

Rewrite codebase, add device-system pewpew

DOCUMENTATION.md

@@ -0,0 +1,230 @@
+# Developer Instructions
+
+This file is aimed at developers of light, or developers who want to implement "drivers" (enumerators) for their own hardware.
+
+## Coding Standards
+
+Light is a small project, which helps keep it clean. However we still would like to see a consistent styling throughout the project, as well as in third-party enumerator implementations. The actual source code may not be fully "up to code" yet, but it's getting there.
+
+We use 4 spaces for indentation. We have an empty line at the top and bottom of each file.
+
+The following two sources should be clear enough examples of our coding style:
+
+### Header files 
+
+```c
+    
+    #pragma once
+    
+    #include <stdbool.h>
+    #include <stdint.h>
+    #include <stdfoo.h> /* foo_type_t */
+    
+    
+    typedef struct _some_struct_t some_struct_t;
+    struct _some_struct_t 
+    {
+        uint64_t    id;
+        foo_type_t  my_foo_thing;
+        foo_type_t  *my_foo_ptr;
+    }
+    
+    /* Describe what the purpose of this function is, what it does with/to foo_struct, and what it returns. */
+    bool do_some_stuff(some_struct_t *foo_struct);
+    
+```
+
+### Source files
+
+The second line of each source file should be the include to the corresponding header file, followed by an empty line.
+
+Internal/static functions are always prefixed with an underscore (_).
+
+```c
+
+#include "some_struct.h"
+
+static void _increment_one(uint64_t *out_value)
+{
+    *out_value += 1;
+}
+
+bool do_some_stuff(some_struct_t *foo_struct)
+{
+    _increment_one(foo_struct->id);
+    
+    if(foo_struct->id > 33)
+    {
+        return false;
+    }
+    
+    if(foo_struct->my_foo_ptr != NULL)
+    {
+        free(foo_struct->my_foo_ptr);
+    }
+    
+    foo_struct->my_foo_ptr = malloc(sizeof(foo_type_t));
+    
+    return true;
+}
+
+```
+
+## Implementing an enumerator 
+
+Implementing your own devices through an enumerator is pretty easy. The required steps are as follows:
+
+### Step 1
+
+Create a headerfile and a corresponding sourcefile under the `impl` folder, Call them `foo.h` and `foo.c`. Open up the `sysfs.c` and `sysfs.h` files for reference implementations.
+
+### Step 2
+
+In the header, you need to first do a `#pragma once` (obviously), then `#include "light.h"` to get access to some struct declarations, then at the bare minimum declare 6 functions. If you need to store your own data for each device or device-target, you will need to declare structs for these as well.
+
+```c
+
+#pragma once 
+
+#include "light.h"
+
+// Implementation of the foo enumerator
+// Enumerates devices for quacking ducks
+
+// Device target data 
+struct _impl_foo_data_t
+{
+    int32_t internal_quack_id;
+};
+
+typedef struct _impl_foo_data_t impl_foo_data_t;
+
+bool impl_foo_init(light_device_enumerator_t *enumerator);
+bool impl_foo_free(light_device_enumerator_t *enumerator);
+
+bool impl_foo_set(light_device_target_t *target, uint64_t in_value);
+bool impl_foo_get(light_device_target_t *target, uint64_t *out_value);
+bool impl_foo_getmax(light_device_target_t *target, uint64_t *out_value);
+bool impl_foo_command(light_device_target_t *target, char const *command_string);
+
+```
+
+### Step 3
+
+In the sourcefile, you need to implement the 6 methods. Make sure to return `true` on success and `false` on failure. If you do not actually implement a function (for example `impl_foo_command`), just return `true`.
+
+The job of the enumerator is to identify/enumerate a bunch of different devices (or just one, or even zero if it doesnt find any). You are also responsible to create the device targets for them (i.e, the things that you actually write to on the device). You do this by setting the devices and targets up in `impl_foo_init` and to free these in `impl_foo_free`. The enumerator (this code) owns the memory of the devices and targets, and thus is in charge of allocating and freeing it. 
+
+```c
+
+#include "impl/foo.h"
+
+#include "light.h"
+#include "helpers.h"
+
+bool impl_foo_init(light_device_enumerator_t *enumerator)
+{
+    /* Lets create a single device, with a single target, for simplicity */
+    
+    /* Allocate a new device */
+    light_device_t *new_device = malloc(sizeof(light_device_t));
+    
+    /* Set the name of the new device to "new_device_name" */
+    snprintf(leds_device->name, sizeof(leds_device->name), "%s", "new_device_name");
+    
+    /* Add the newly created device to the enumerator */
+    light_add_enumerator_device(enumerator, new_device);
+
+    
+    
+    /* Allocate a new device target for the newly created device */
+    light_device_target_t *new_target = malloc(sizeof(light_device_target_t));
+    
+    /* Set the name of the new target */
+    snprintf(new_target->name, sizeof(new_target->name), "%s", "new_target_name");
+    
+    /* Setup the function bindings for this target, i.e. what functions will run internally when you run different commands on this device target */
+    new_target->set_value = impl_foo_set;
+    new_target->get_value = impl_foo_get;
+    new_target->get_max_value = impl_foo_getmax;
+    new_target->custom_command = impl_foo_command;
+    
+    /* Finally add the target to the device */
+    light_add_device_target(new_device, new_target);
+    
+    
+    
+    /* Optional: Setup data specific to either a device or a target, or both. */ 
+    /* Useful to for example reference an ID in a third-party API or likewise */
+    impl_foo_data_t *custom_data = malloc(sizeof(impl_foo_data_t));
+    custom_data->internal_quack_id = 333;
+    
+    /* You can set it to the device itself, or to a target */
+    new_device->device_data = custom_data;
+    new_target->device_target_data = custom_data;
+
+    /* Return true because we didnt get any errors! */
+    return true;
+}
+
+bool impl_foo_free(light_device_enumerator_t *enumerator)
+{
+    /* We are responsible to free the memory we allocated in init, so lets do that */
+    
+    /* 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];
+
+        /* Iterate throug hthe targets in the device */
+        for(uint64_t t = 0; t < curr_device->num_targets; t++)
+        {
+            light_device_target_t *curr_target = curr_device->targets[t];
+            
+            /* If we allocated any target data, free it here */
+            if(curr_target->device_target_data != NULL)
+            {
+                free(curr_target->device_target_data);
+            }
+            
+            free(curr_target);
+        }
+
+        /* If we allocated any device data, free it here */
+        if(curr_device->device_data != NULL)
+        {
+            free(curr_device->device_data);
+        }
+        
+        /* We need to 'dispose' of the device when we are done with it, to free some internal memory. Always do this when you are about to free a device that you allocated. */
+        light_dispose_device(curr_device);
+        
+        /* Free the device */
+        free(curr_device);
+    }
+    
+    return true;
+}
+
+/* Implement the other functions to do their thing. Get, Set and GetMax should be self-explanatory. Command is reserved for future use, but basically will allow the user to run custom commands on a target. */
+
+```
+
+### Step 4
+
+Now that you have implemented your enumerator, it is time to inject it to the application itself. You will be able to compile your enumerator into a plugin in the future, but for now, locate the `light_initialize` function inside `light.c`. You will see some calls (perhaps just one call) to `light_create_enumerator` inside of this function. Add one more call to this function to register your enumerator in the application:
+
+The first argument is the application context, the second is the name that your enumerator will get, and the last two are the init and free functions that we implemented.
+
+```c
+light_create_enumerator(new_ctx, "foo", &impl_foo_init, &impl_foo_free);
+```
+
+Once you do this, you should be able to find your device target when running `light -L`, and it should be called something like `foo/new_device_name/new_target_name` if you followed this guide.
+
+The only thing left now is to create a pull request so that the rest of the world can share the functionality that you just implemented!
+
+
+## Troubleshooting
+
+If you run into any issues, feel free to create a new Github issue, even if you are just asking for "support" or likewise.

README.md

@@ -1,11 +1,11 @@
-Light - A Program to Control Backlight Controllers
+Light - A program to control backlights (and other hardware lights) in GNU/Linux
 ==================================================
 
 - [Introduction](#introduction)
 - [Examples](#examples)
 - [Usage](#usage)
-  - [Commands](#commands)
-  - [Options](#options)
+  - [Command options](#command-options)
+  - [Extra options](#extra-options)
 - [Installation](#installation)
   - [Arch Linux](#arch-linux)
   - [Fedora](#fedora)
@@ -17,25 +17,22 @@ Light - A Program to Control Backlight Controllers
 Introduction
 ------------
 
-[Light][] is a program to control backlight controllers under GNU/Linux:
+[Light][] is a program to control backlights and other lights under GNU/Linux:
 
-* Works, in particular when other software, e.g. xbacklight, does not
-* Does not rely on X
-* Automatically detects the best controller
-* Possibility to set a minimum brightness value
+* Works where other software has proven unreliable (xbacklight etc.)
+* Works even in a fully CLI-environment, i.e. it does not rely on X
+* Provides functionality to automatically control backlights with the highest precision available
+* Extra features, like setting a minimum brightness value for controllers, or saving/restoring the value for poweroffs/boots.
 
-Let's get started with a few examples!  See the following sections for
-the detailed descriptions of all available commands, options and how to
-access different controllers.
+See the following sections for the detailed descriptions of all available commands, options and how to access different controllers.
 
-Light is available in many GNU/Linux distributions already, and it also
-has a fork called [brillo][] by [Cameron Nemo](@CameronNemo).
+Light is available in many GNU/Linux distributions already.
 
 
 Examples
 --------
 
-Get the current brightness in percent
+Get the current backlight brightness in percent
 
     light -G
 
@@ -43,99 +40,58 @@ or
 
      light
 
-Increase brightness by 5 percent
+Increase backlight brightness by 5 percent
 
     light -A 5
 
-Set the minimum cap to 2 in raw value on the acpi_video0 controller:
+Set the minimum cap to 2 in raw value on the sysfs/backlight/acpi_video0 device:
 
-    light -cr -s acpi_video0 -S 2
+    light -Nrs "sysfs/backlight/acpi_video0" 2
 
-Try to set the brightness to 0 after that, it will be changed to the
-minimum 2:
+List available devices
 
-    light -r -s acpi_video0 -S 0
+    light -L
 
-Find keyboard controllers:
-
-    light -k -L
-
-Activate `ScrollLock` LED, here `input15` is used, but this varies
+Activate the Num. Lock keyboard LED, here `sysfs/leds/input3::numlock` is used, but this varies
 between different systems:
 
-    light -k -s "input15::scrolllock" -S 100
-
-Usually, LEDs only take 0 or 1 in raw value (i.e. for off/on), so you
-can instead write:
-
-    light -kr -s "input15::scrolllock" -S 1
-
-Verify by reading back the max brightness, you should get a value of 1:
-
-    light -kr -m -s "input15::scrolllock
+    light -Srs "sysfs/leds/input3::numlock" 1
 
 
 Usage
 -----
 
-### Commands
-
-* `-G`: Get (read) brightness/data from controllers/files
-* `-S VAL`: Set (write)brightness/data to controllers/files
-* `-A VAL`: Like `-S`, but adds the given value
-* `-U VAL`: Like `-S`, but subtracts the given value
-* `-O`: Save the current brightness for later use (usually used on shutdown)
-* `-I`: Restore the previously saved brightness (usually used on boot)
-* `-L`: List available controllers, see below `-k` option as well
+Usage follows the following pattern, where options are optional and the neccesity of value depends on the options used
+    
+    light [options] <value>
 
-Without any options (below) the commands operate on the brightness of an
-automatically selected controller.  Values are given in percent, unless
-the below `r` option is also given.
+### Command options
 
-**Note:** like most UNIX applications, light only gives output on
-  errors.  If something goes wrong try the verbosity option `-v VAL`:
+You may only specify one command flag at a time. These flags decide what the program will ultimately end up doing.
 
-* 0: No debug output
-* 1: Errors
-* 2: Errors, warnings
-* 3: Errors, warnings, notices
+*  `-H` Show help and exit
+*  `-V` Show program version and exit
+*  `-L` List available devices
+*  `-A` Increase brightness by value (value needed!)
+*  `-U` Decrease brightness by value (value needed!)
+*  `-S` Set brightness to value (value needed!)
+*  `-G` Get brightness
+*  `-N` Set minimum brightness to value (value needed!)
+*  `-P` Get minimum brightness
+*  `-I` Save the current brightness
+*  `-O` Restore the previously saved brightness
 
-### Options
+Without any extra options, the command will operate on the device called `sysfs/backlight/auto`, which works as it's own device however it proxies the backlight device that has the highest controller resolution (read: highest precision). Values are interpreted and printed as percentage between 0.0 - 100.0.
 
-Values may be given, or presented, in percent or raw mode.  Raw mode is
-the format specific to the controller.  The default is in percent, but
-raw mode may be required for precise control, or when the steps are very
-few, e.g. for most keyboard backlight controllers.
+**Note:** If something goes wrong, you can find out by maxing out the verbosity flag by passing `-v 3` to the options. This will activate the logging of warnings, errors and notices. Light will never print these by default, as it is designed to primarily interface with other applications and not humanbeings directly.
 
-* `-p`: Percent, default
-* `-r`: Raw mode
+### Extra options
 
-By default the screen is the active target for all commands, use `-k` to
-select the keyboard instead.  In either case you may need to select a
-different controller, see below.
+These can be mixed, combined and matched after convenience. 
 
-* `-l`: Act on screen backlight, default
-* `-k`: Act on keyboard backlight and LEDs
-
-By default commands act on the brightness property, which is read+write.
-The maximum brightness is a read-only property.  The minimum brightness
-cap is a feature implemented to protect against setting brightness too
-low, since some controllers make the screen go pitch black at 0%.  For
-controllers like that it is recommended to set this value.
-
-* `-b`: Current brightness of selected controller, default
-* `-m`: Max. brightness of selected controller
-* `-c`: Min. brightness (cap) of selected controller (recommend raw mode)
-
-Controller is automatically done to select the controller with maximum
-precision.  It can however also be done manually and we recommend the
-`-L` and `-Lk` commands to list available controllers:
-
-* `-a`: Automatic controller selection
-* `-s ARG`: Manual controller selection
-
-**Note:** Without the `-s` flag on _every_ command light will default
-  to automatic controller selection.
+* `-r` Raw mode, values (printed and interpreted from commandline) will be treated as integers in the controllers native range, instead of in percent.
+* `-v <verbosity>` Specifies the verbosity level. 0 is default and prints nothing. 1 prints only errors, 2 prints only errors and warnings, and 3 prints both errors, warnings and notices.
+* `-s <devicepath>` Specifies which device to work on. List available devices with the -L command. Full path is needed.
 
 
 Installation
@@ -145,11 +101,8 @@ Installation
 
 If you run Arch Linux, there exists 2 packages;
 
-* [light-git][] - For the absolutely latest version
-* [light-tag][] - For the latest tagged release
-
-We recommend you go with light-git as you might miss important features
-and bugfixes if you do not.
+* [light-git][] - For the latest development branch (master)
+* [light][] - For the latest stable release
 
 
 ### Fedora
@@ -163,17 +116,15 @@ and you're good to go.
 
 ### Manual
 
-We recommended downloading a versioned tarball from the relases page on
-GitHub.  Download and untar the archive:
+If you download a stable release, these are the commands that will get you up and running:
 
     tar xf light-x.yy.tar.gz
     cd light-x.yy/
     ./configure && make
     sudo make install
 
-However, should you want to try the latest GitHub source you first need
-to clone the repository and run the `autogen.sh` script.  This requires
-`automake` and `autoconf` to be installed on your system.
+However the latest development branch requires some extras. Clone the repository and run the `autogen.sh` script.  This requires that
+`automake` and `autoconf` is installed on your system.
 
     ./autogen.sh
     ./configure && make
@@ -209,6 +160,5 @@ This is free software, see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE
 
 [Light]:     https://github.com/haikarainen/light/
-[brillo]:    https://gitlab.com/cameronnemo/brillo/
 [light-git]: https://aur.archlinux.org/packages/light-git
-[light-tag]: https://aur.archlinux.org/packages/light
+[light]: https://aur.archlinux.org/packages/light

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,7 +1,7 @@
 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
+light_CFLAGS   = -W -Wall -Wextra -std=gnu18 -Wno-type-limits -Wno-format-truncation -Wno-unused-parameter
 
 if CLASSIC
 install-exec-hook:

src/helpers.c

@@ -5,106 +5,138 @@
 #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)
-{
-	FILE *fp;
-	unsigned long data;
-
-	fp = fopen(filename, "r");
-	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);
-		fclose(fp);
-		return false;
-	}
 
-	*val = data;
-
-	fclose(fp);
-	return true;
+bool light_file_read_uint64(char const *filename, uint64_t *val)
+{
+    FILE *fp;
+    uint64_t data;
+
+    fp = fopen(filename, "r");
+    if (!fp)
+    {
+        LIGHT_PERMERR("reading");
+        return false;
+    }
+
+    if (fscanf(fp, "%lu", &data) != 1)
+    {
+        LIGHT_ERR("Couldn't parse an unsigned integer from '%s'", filename);
+        fclose(fp);
+        return false;
+    }
+
+    *val = data;
+
+    fclose(fp);
+    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) {
-		LIGHT_PERMERR("writing");
-		return false;
-	}
-
-	if (fprintf(fp, "%lu", val) < 0) {
-		LIGHT_ERR("fprintf failed");
-		fclose(fp);
-		return false;
-	}
-
-	fclose(fp);
-	return true;
+    FILE *fp;
+
+    fp = fopen(filename, "w");
+    if (!fp)
+    {
+        LIGHT_PERMERR("writing");
+        return false;
+    }
+
+    if (fprintf(fp, "%lu", val) < 0)
+    {
+        LIGHT_ERR("fprintf failed");
+        fclose(fp);
+        return false;
+    }
+
+    fclose(fp);
+    return true;
 }
 
 /* Returns true if file is writable, false otherwise */
 bool light_file_is_writable(char const *filename)
 {
-	FILE *fp;
+    FILE *fp;
 
-	fp = fopen(filename, "r+");
-	if (!fp) {
-		LIGHT_PERMWARN("writing");
-		return false;
-	}
+    fp = fopen(filename, "r+");
+    if (!fp)
+    {
+        LIGHT_PERMWARN("writing");
+        return false;
+    }
 
-	fclose(fp);
-	return true;
+    fclose(fp);
+    return true;
 }
 
 /* Returns true if file is readable, false otherwise */
 bool light_file_is_readable(char const *filename)
 {
-	FILE *fp;
+    FILE *fp;
 
-	fp = fopen(filename, "r");
-	if (!fp) {
-		LIGHT_PERMWARN("reading");
-		return false;
-	}
+    fp = fopen(filename, "r");
+    if (!fp)
+    {
+        LIGHT_PERMWARN("reading");
+        return false;
+    }
 
-	fclose(fp);
-	return true;
+    fclose(fp);
+    return true;
 }
 
 /* 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;
+    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;
+    LIGHT_NOTE("too large value, adjusting to mavalimum %lu (raw)", max);
+    return max;
 }
 
 /* Clamps the `percent` value between 0% and 100% */
 double light_percent_clamp(double val)
 {
-	if (val < 0.0) {
-		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 0%%", val);
-		return 0.0;
-	}
-
-	if (val > 100.0) {
-		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 100%%", val);
-		return 100.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)
+    {
+        LIGHT_WARN("specified value %g%% is not valid, adjusting it to 100%%", val);
+        return 100.0;
+    }
+
+    return val;
+}
 
-	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;
+
+    char *tempdir = strdup(dir);
+    light_mkpath(dirname(tempdir), mode);
+    free(tempdir);
+    
+    return mkdir(dir, mode);
 }
+

src/helpers.h

@@ -1,55 +1,55 @@
-#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)					\
-	(val < min							\
-	 ? light_log_clamp_min(min)					\
-	 : (val > max							\
-	    ? light_log_clamp_max(max)					\
-	    : val ))
+#define LIGHT_CLAMP(val, min, max) (val < min ? light_log_clamp_min(min) : (val > max ? light_log_clamp_max(max) : val))
 
 /* Verbosity levels: 
- * 0 - No output
- * 1 - Errors
- * 2 - Errors, warnings 
- * 3 - Errors, warnings, notices
- */
+* 0 - No output
+* 1 - Errors
+* 2 - Errors, warnings 
+* 3 - Errors, warnings, notices
+*/
 typedef enum {
-	LIGHT_ERROR_LEVEL = 1,
-	LIGHT_WARN_LEVEL,
-	LIGHT_NOTE_LEVEL
+    LIGHT_ERROR_LEVEL = 1,
+    LIGHT_WARN_LEVEL,
+    LIGHT_NOTE_LEVEL
 } light_loglevel_t;
 
 light_loglevel_t light_loglevel;
 
-#define LIGHT_LOG(lvl, fp, fmt, args...)				\
-	if (light_loglevel >= lvl)					\
-		fprintf(fp, "%s:%d:" fmt "\n", __FILE__, __LINE__, ##args)
+#define LIGHT_LOG(lvl, fp, fmt, args...)\
+    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 {								\
-		log("could not open '%s' for " act, filename);		\
-		log("Verify it exists with the right permissions");	\
-	} while (0)
+#define LIGHT_PERMLOG(act, log)\
+    do {\
+        log("could not open '%s' for " act, filename);\
+        log("Verify it exists with the right permissions");\
+    } while (0)
+
 #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,250 @@
+
+#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);
+    }
+    
+    closedir(leds_dir);
+    
+    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);
+    }
+    
+    closedir(backlight_dir);
+    
+    // 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;
+        }
+        
+        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);
+        }
+        
+        // If the given device has any device_data, free it
+        if(curr_device->device_data != NULL)
+        {
+            free(curr_device->device_data);
+        }
+                
+        light_dispose_device(curr_device);    
+
+        // Free the device
+        free(curr_device);
+    }
+    
+    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,24 @@
+
+#pragma once 
+
+#include "light.h"
+
+// Implementation of the sysfs enumerator
+// Enumerates devices for backlights and leds
+
+// Device target data 
+struct _impl_sysfs_data_t
+{
+    char brightness[NAME_MAX];
+    char max_brightness[NAME_MAX];
+};
+
+typedef struct _impl_sysfs_data_t 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,140 @@
-#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 *);
+
+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;
+};
+
+// 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
+
+/* 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);
+
+/* Frees any runtime-allocated data inside a device. Call this before you free a device. */
+void light_dispose_device(light_device_t *device);

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_ERR("Initialization failed");
-		return LIGHT_RETURNVAL_INITFAIL;
-	}
+    light_context_t *light_ctx = light_initialize(argc, argv);
+    if (light_ctx == NULL) {
+        LIGHT_ERR("Initialization failed");
+        return LIGHT_RETURNVAL_INITFAIL;
+    }
 
-	if (!light_execute()) {
-		LIGHT_ERR("Execution failed");
-		light_free();
-		return LIGHT_RETURNVAL_EXECFAIL;
-	}
+    if (!light_execute(light_ctx)) {
+        LIGHT_ERR("Execution failed");
+        light_free(light_ctx);
+        return LIGHT_RETURNVAL_EXECFAIL;
+    }
 
-	light_free();
-	return LIGHT_RETURNVAL_SUCCESS;
+    light_free(light_ctx);
+    return LIGHT_RETURNVAL_SUCCESS;
 }