Full rewrite (0.9)

CHANGELOG

@@ -1 +1,13 @@
-0.7 -- Ported bash script to C.
+0.9
+  * Complete rewrite of program (Every single byte)
+  * Cleaner, safer code
+  * Completely new intuitive usage (Sorry, it was needed)
+  * Added functionality:
+    * Ability to set/get minimum brightness directly from commandline
+    * Ability to specify the backlight controller to use directly from commandline
+    * Better verbosity
+
+  * Probably missed some stuff
+
+0.7
+  * Ported bash script to C.

Makefile

@@ -1,10 +1,11 @@
 CC=gcc
-CFLAGS=-std=c89 -pedantic -Wall
+CFLAGS=-std=c89 -pedantic -Wall -I"./include"
+
+all:
+	$(CC) $(CFLAGS) -g -o light src/helpers.c src/light.c src/main.c
+exp:
+	$(CC) $(CFLAGS) -E  src/helpers.c src/light.c
 
-debug:clean
-	$(CC) $(CFLAGS) -g -o light main.c
-stable:clean
-	$(CC) $(CFLAGS) -o light main.c
 clean:
 	rm -vfr *~ light
-	
+	

README

@@ -1,63 +1,95 @@
-Light 0.7
----------
+Light 0.9
 
-Copyright (C) 2012 - Fredrik Haikarainen
-Program is licensed under the GPLv3 (Read LICENSE before contiuing)
+Copyright (C) 2012 - 2014, Fredrik Haikarainen
+This is free software, see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE
 
- - Description ---
+--------------------------------------------------------------------------
 
-"Light" is a program to control backlight-controllers in GNU/Linux-systems. It is the successor of "LightScript",
-which is a bash-script with the same purpose, and tries to maintain the same functionality.
+Description:
 
-It features:
+"Light"  is  a program  to control backlight controllers  under GNU/Linux,
+it is the successor of lightscript, which was a bash script with the  same
+purpose, and tries to maintain the same functionality.
 
-	* Works excellent where other software has proven unusable/problematic(xbacklight etc) thanks to how
-	  it operates internally, and the fact that it doesn't need X. 
 
-	* Automatically figures out the best controller to use depending on its resolution, making full use
-	  of the underlying hardware, if you have a "bad system" the controller to use is overridable by the
-	  /etc/light/override-file
+Features:
 
-	* Written in ANSI-C89 -- which practically makes it as portable as a program can be, with the exception
-	  of the glibc-dependency.
+  * Works excellent where other software has been proven to be unusable or
+    problematic, thanks to how it operates internally and to the fact that
+    it does not rely on xorg.
 
-	* Has a default minimumcap of 5% brightness, easily changeable in /etc/light/minlight. This to prevent
-	  screens from turning pitchblack, since some controllers do that on 0 brightness.
+  * Can automatically figure out the best controller to use,   making full
+    use of underlying hardware.
 
- - Usage ---
+  * Possibility to set a minimum brightness value, as some controllers set
+    the screen to be pitch black at a vaĺue of 0 (or higher).
 
-Executed without arguments, light prints usage-information that is pretty self-explanatory.
 
-Examples:
+Installation:
+  
+  If you run ArchLinux, there is a package in the AUR called light.
 
-	Set brightness to 40 percent:
-	light 40
+  1) Install neccessary build tools (gcc, make etc.)
 
-	Increase brightness with 10% and supress output:
-	light -aq 10	
+  2) Type `make`
 
-	Print the maximum-brightness of the best controller and exit:
-	light -m
+  3) Run makeexec.sh as root to give regular users the ability to run the
+     program with root permissions.
 
+  4) Copy/create a symbolic link to the executable to /usr/bin
 
- - Installation ---
+  5) Enjoy!
 
-	1. Install the neccesary buildtools (make, gcc etc)
 
-	2. Type "make stable"
+Usage:
 
-	3. Optionally make the light-binary executable by regular users by running makeexec.sh as root
-	
-	4. Create a symbolic link to /usr/bin
-	
-	5. Enjoy!
+  This application has 4 different operation modes, which are:
 
-	Optional:
-	
-	6. Create /etc/light/minlight to set a minimumcap (5 is good for highresolution controllers)
+    -G:   Get, which reads/gets brightness/data from controllers/files
+    -S:   Set, whichs writes/sets brightness/data to controllers/files
+    -A:   Add, does like -S but instead adds the value
+    -U:   Subtract, does like -S but instead subtracts the value
 
+  When used by themselves   operate on the brightness of a controller that
+  is selected automatically. S, A and U needs another argument,   which is
+  the value to set/add/subtract.   This can be specified either in percent
+  or in raw values,  but remember to specify the value mode if you want to
+  write raw values.
 
+  The value modes are set with -p for percent (default), and -r for raw.
 
- - Contact ---
+  As you can not only read/write the brightness of controllers,    you may
+  also specify a target to read/write from/to:
 
-In case of any feedback(problems/bugs, feature-requests etc) contact me directly on fredrik.haikarainen@gmail.com
+    -b:   Current brightness of selected controller
+    -m:   Maximum brightness of selected controller
+    -c:   Minimum brightness (cap) of selected controller
+
+  Finally, you can either use the built-in controller selection to get the
+  controller with the maximum precision,   or you can specify one manually
+  with the -s flag. The -a flag will force automatic mode and is default.
+
+  NOTE:
+  This application will only print errors if you are using it incorrectly.
+  If something goes wrong, and you can't figure out why,   try setting the
+  verbosity flag:
+
+    -v 0: No debug output
+    -v 1: Errors
+    -v 2: Errors, warnings
+    -v 3: Errors, warnings, notices
+
+  Examples:
+
+    * Get the current brightness in percent
+    
+      light -G
+
+    * Increase brightness by 5 percent
+
+      light -A 5
+
+    * Set the minimum cap to 2 in raw value on the acpi_video0 controller:
+
+      light -Scrs "acpi_video0" 2

include/helpers.h

@@ -0,0 +1,63 @@
+#ifndef LIGHT_HELPERS_H
+#define LIGHT_HELPERS_H
+
+/* Clamps x(value) between y(min) and z(max) in a nested ternary operation. 
+ * if(x < y)
+ * {
+ *  y;
+ * }else{
+ *  if(x>z)
+ *  {
+ *    z;
+ *  }else{
+ *    x;
+ *  }
+ * }*/
+#define LIGHT_CLAMP(x, y, z) ((x<y) ? y : ((x>z) ? z : x ));
+
+#define LIGHT_NOTE(x) if(light_verbosity > 2){printf("%s.\n", x);}
+
+#define LIGHT_WARN(x) if(light_verbosity > 1){printf("warning: \"%s\", in \"%s\" on line %u.\n", x, __FILE__, __LINE__);}
+
+#define LIGHT_ERR(x) if(light_verbosity > 0){printf("error: \"%s\", in \"%s\" on line %u.\n", x, __FILE__, __LINE__);}
+
+#define LIGHT_MEMERR() LIGHT_ERR("memory error");
+
+/* Verbosity levels: 
+ * 0 - No output
+ * 1 - Errors
+ * 2 - Errors, warnings 
+ * 3 - Errors, warnings, notices */
+int    light_verbosity;
+
+/* Typedef for boolean values */
+typedef enum LIGHT_BOOL {
+  FALSE = 0,
+  TRUE
+} LIGHT_BOOL;
+
+/* Reads an unsigned integer from a file into `i` if able, otherwise returns FALSE and leaves `i` untouched */
+LIGHT_BOOL light_readUInt(char const *filename, unsigned int *v);
+
+/* Writes an unsigned integer `i` into file `filename` if able, otherwise returns FALSE */
+LIGHT_BOOL light_writeUInt(char const *filename, unsigned int v);
+
+LIGHT_BOOL light_writeULong(char const *filename, unsigned long v);
+LIGHT_BOOL light_readULong(char const *filename, unsigned long *v);
+
+/* Reads a file into null-terminated `buffer` if able, otherwise returns FALSE
+ * If `size` isn't NULL, it will be set to the read size.
+ *
+ * WARNING: `buffer` HAS to be freed by the user, also make sure it is NULL before passed */
+LIGHT_BOOL light_readString(char const * filename, char * buffer, long * size);
+
+/* Returns TRUE if `path` is a valid directory, FALSE otherwise */
+LIGHT_BOOL light_isDir(char const * path);
+
+/* Returns TRUE if file is writable, FALSE otherwise */
+LIGHT_BOOL light_isWritable(char const * filename);
+
+/* Returns TRUE if file is readable, FALSE otherwise */
+LIGHT_BOOL light_isReadable(char const * filename);
+
+#endif /* LIGHT_HELPERS_H */

include/light.h

@@ -0,0 +1,142 @@
+#ifndef LIGHT_H
+#define LIGHT_H
+
+#include "helpers.h"
+
+#include <sys/types.h>
+#include <dirent.h>
+
+#define LIGHT_VER_MAJOR 0
+#define LIGHT_VER_MINOR 9
+#define LIGHT_VER_TYPE "beta"
+#define LIGHT_YEAR 2014
+#define LIGHT_AUTHOR "Fredrik Haikarainen"
+
+#define ASSERT_OPSET() \
+  if(opSet)\
+  {\
+    printf("Operation arguments can not be used in conjunction.\n");\
+    return FALSE;\
+  }\
+  opSet = TRUE;
+
+#define ASSERT_TARGETSET() \
+  if(targetSet)\
+  {\
+    printf("Target arguments can not be used in conjunction.\n");\
+    return FALSE;\
+  }\
+  targetSet = TRUE;
+
+#define ASSERT_CTRLSET()\
+  if(ctrlSet)\
+  {\
+    printf("Controller arguments can not be used in conjunction.\n");\
+    return FALSE;\
+  }\
+  ctrlSet = TRUE;
+
+#define ASSERT_VALSET()\
+  if(valSet)\
+  {\
+    printf("Value arguments can not be used in conjunction.\n");\
+    return FALSE;\
+  }\
+  valSet = TRUE;
+
+
+typedef enum LIGHT_TARGET {
+  LIGHT_BRIGHTNESS = 0,
+  LIGHT_MAX_BRIGHTNESS,
+  LIGHT_MIN_CAP
+} LIGHT_TARGET;
+
+typedef enum LIGHT_CTRL_MODE {
+  LIGHT_AUTO = 0,
+  LIGHT_SPECIFY
+} LIGHT_CTRL_MODE;
+
+typedef enum LIGHT_OP_MODE {
+  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_OP_MODE;
+
+typedef enum LIGHT_VAL_MODE {
+  LIGHT_RAW = 0,
+  LIGHT_PERCENT
+} LIGHT_VAL_MODE;
+
+typedef struct light_runtimeArguments_s {
+  /* Which controller to use */
+  LIGHT_CTRL_MODE controllerMode;
+  char            specifiedController[256];
+
+  /* What to do with the controller */
+  LIGHT_OP_MODE   operationMode;
+  LIGHT_VAL_MODE  valueMode;
+  unsigned long   specifiedValueRaw; /* The specified value in raw mode */
+  double          specifiedValuePercent; /* The specified value in percent */
+  
+  LIGHT_TARGET    target;
+} light_runtimeArguments, *light_runtimeArguments_p;
+
+/* -- Global variables that handles iterating controllers -- */
+struct dirent *light_iterator;
+DIR           *light_iteratorDir;
+char          light_currentController[256];
+
+/* -- Global variable holding the settings for the current run -- */
+light_runtimeArguments light_Configuration;
+
+/* Sets default values for the configuration */
+void light_defaultConfig();
+
+
+/* Parses the program arguments and sets the configuration accordingly (unsanitized) */
+LIGHT_BOOL light_parseArguments(int argc, char** argv);
+
+/* Prints a header if verbosity level > 0 */
+void light_printVersion(void);
+
+/* Prints help regardless of verbosity level */
+void light_printHelp(void);
+
+/* -- SECTION: Main code -- */
+
+/* Initializes the application */
+LIGHT_BOOL light_initialize(int argc, char** argv);
+
+/* Does the work */
+LIGHT_BOOL light_execute(void);
+
+/* Frees up resources */
+void light_free();
+
+/* SECTION: Controller functionality */
+
+/* WARNING: `buffer` HAS to be freed by the user if not null once returned!
+ * Size is always 256 */
+LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET type, char **buffer);
+
+LIGHT_BOOL light_getBrightness(char const *controller, unsigned long *v);
+
+LIGHT_BOOL light_getMaxBrightness(char const *controller, unsigned long *v);
+
+LIGHT_BOOL light_setBrightness(char const *controller, unsigned long v);
+
+LIGHT_BOOL light_controllerAccessible(char const *controller);
+
+LIGHT_BOOL light_iterateControllers(void);
+
+/* WARNING: `controller` HAS to be at least 256 bytes */
+LIGHT_BOOL light_getBestController(char *controller);
+
+LIGHT_BOOL light_getMinCap(char const *controller, LIGHT_BOOL *hasMinCap, unsigned long *minCap);
+
+LIGHT_BOOL light_setMinCap(char const *controller, unsigned long v);
+
+#endif /* LIGHT_H */

main.c

@@ -1,478 +0,0 @@
-/*	
- * 	Licensed under the GNU Public License version 3.
- *	Read attached LICENSE
- * 	Copyright (C) 2012 - Fredrik Haikarainen
- * 	Fredrik.haikarainen@gmail.com
- */
-
-#define _GNU_SOURCE
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <dirent.h>
-#include <string.h>
-#include <unistd.h>
-#include <limits.h>
-
-typedef enum LBOOL{
-	TRUE = 0,
-	FALSE = 1
-} LBOOL;
-
-typedef enum LOPTYPE{
-	SET = 0,
-	ADD = 1,
-	SUB = 2
-} LOPTYPE;
-
-/* Flags */
-LBOOL q; /* Quiet, supresses output */
-LBOOL c; /* print unprecise current value in percentage */
-LBOOL m; /* read max value*/
-LBOOL p; /* precision read current value */
-int wbright;
-LOPTYPE ot;
-
-LBOOL readint(const char* f, unsigned int *i){
-	FILE* ff = fopen(f, "r");
-	if(ff){
-		fscanf(ff, "%u", i);
-		fclose(ff);
-		return TRUE;
-	}else{
-		return FALSE;
-	}
-}
-
-LBOOL readchar(const char* f, char *c){
-	
-	FILE* ff = fopen(f, "r");
-
-	/*c = malloc(sz+1);*/
-	if(ff){
-		unsigned int sz;
-		fseek(ff, 0L, SEEK_END);
-		sz = ftell(ff);
-		fseek(ff, 0L, SEEK_SET);
-		fgets(c,sz,ff);
-		fclose(ff);
-		return TRUE;
-	}else{
-		return FALSE;
-	}
-}
-
-LBOOL writeint(const char* f, unsigned int i){
-	FILE* ff = fopen(f, "w");
-	if(ff){
-		fprintf(ff, "%u", i);
-		fclose(ff);
-		return TRUE;
-	}else{
-		return FALSE;
-	}
-}
-
-
-LBOOL is_dir(const char* d){
-	DIR* dd = opendir(d);
-	if(dd){
-		closedir(dd);
-		return TRUE;
-	}else{
-		return FALSE;
-	}
-}
-
-LBOOL is_writable(const char* f){
-	FILE* dd = fopen(f, "w");
-	if(dd){
-		fclose(dd);
-		return TRUE;
-	}else{
-		return FALSE;
-	}	
-}
-
-typedef struct {
-	char		name[256];
-	unsigned int	current_brightness;
-	unsigned int	max_brightness;
-	char		c_path[256]; /* Controller-path */
-	char		cb_path[256]; /* Current brightness-path */
-	char		mb_path[256]; /* Max brightness-path */
-	char		b_path[256]; /* Brightness-path */
-	enum LBOOL	is_ok;
-	unsigned int	guide_id;
-} controller;
-
-typedef struct {
-	controller	controllers[256];
-	unsigned int	num_controllers;
-} fetch_result;
-
-
-fetch_result fetch_controllers(const char* ctrldir){
-	fetch_result returner;
-	struct dirent* ep;
-
-	DIR* lcdir = opendir(ctrldir);
-	
-	returner.num_controllers = 0;
-
-	if(!lcdir){
-		if(q == FALSE)
-			printf("Error: Could not open directory '%s'!\n", ctrldir);
-	}else{
-		while( ( ep = readdir(lcdir) ) ){
-			char* currctrldir = "";
-			char* currctrldir_curr = "";
-			char* currctrldir_max = "";
-			char* currctrldir_f = "";
-			if( ep->d_name[0] != '.'){
-				strncpy(returner.controllers[returner.num_controllers].name, ep->d_name, sizeof(returner.controllers[returner.num_controllers].name));
-				
-				/* Set some default values, in case something fails we dont just get null */
-				returner.controllers[returner.num_controllers].current_brightness = 0;
-				returner.controllers[returner.num_controllers].max_brightness = 0;
-				returner.controllers[returner.num_controllers].is_ok = TRUE;
-				/*
-				returner.controllers[returner.num_controllers].c_path = NULL;
-				returner.controllers[returner.num_controllers].cb_path = NULL;
-				returner.controllers[returner.num_controllers].b_path = NULL;
-				returner.controllers[returner.num_controllers].mb_path = NULL;
-				*/
-				/* Get path to the current controller dir */
-				asprintf(&currctrldir, "%s/%s", ctrldir, ep->d_name);
-				
-				strncpy(returner.controllers[returner.num_controllers].c_path, currctrldir, sizeof(returner.controllers[returner.num_controllers].c_path));
-				
-				if(is_dir(currctrldir) == FALSE){
-					if(q == FALSE)
-						printf("Warning: '%s' is not a directory, check your system.\n", currctrldir);
-					returner.controllers[returner.num_controllers].is_ok = FALSE;
-				}
-				
-				/* Get path to current actual_brightness-file */
-				asprintf(&currctrldir_curr, "%s/%s", currctrldir, "actual_brightness");
-				strncpy(returner.controllers[returner.num_controllers].cb_path, currctrldir_curr, sizeof(returner.controllers[returner.num_controllers].cb_path));
-				if( readint(currctrldir_curr, &returner.controllers[returner.num_controllers].current_brightness) == FALSE ){
-					if(q == FALSE)
-						printf("Warning: Can't read actual_brightness-file of '%s'. Will ignore this controller.\n", ep->d_name);
-					returner.controllers[returner.num_controllers].is_ok = FALSE;
-				}				
-				
-				/* Get path to current max_brightness-file*/
-				asprintf(&currctrldir_max, "%s/%s", currctrldir, "max_brightness");
-				strncpy(returner.controllers[returner.num_controllers].mb_path, currctrldir_max, sizeof(returner.controllers[returner.num_controllers].mb_path));
-				
-				if( readint(currctrldir_max, &returner.controllers[returner.num_controllers].max_brightness) == FALSE ){
-					if(q == FALSE)
-						printf("Warning: Can't read max_brightness-file of '%s'. Will ignore this controller.\n", ep->d_name);
-					returner.controllers[returner.num_controllers].is_ok = FALSE;
-				}
-				
-				/* Get path to current brightness-file */
-				asprintf(&currctrldir_f, "%s/%s", currctrldir, "brightness");
-				strncpy(returner.controllers[returner.num_controllers].b_path, currctrldir_f, sizeof(returner.controllers[returner.num_controllers].b_path));
-				if( is_writable(currctrldir_f) == FALSE){
-					if(q == FALSE)
-						printf("Warning: Controllerfile of '%s' is not writable. Will ignore this controller.\n", ep->d_name);
-					returner.controllers[returner.num_controllers].is_ok = FALSE;
-				}
-				
-				
-				returner.num_controllers++;
-			}
-		}
-		closedir(lcdir);	
-	}
-	return returner;
-}
-
-controller* get_best_controller(fetch_result* res){
-	unsigned int it;
-	unsigned int cmax;
-	LBOOL foundokctrl;
-	controller* returner;
-	
-	
-	it = 0;
-	cmax = 0;
-	foundokctrl = FALSE;
-	
-	returner = NULL;
-	
-	while(it < res->num_controllers){
-		if(res->controllers[it].is_ok == TRUE){
-			if(foundokctrl != TRUE){
-				foundokctrl = TRUE;
-				returner = &res->controllers[it];
-			}
-			if(res->controllers[it].max_brightness > cmax){
-				cmax = res->controllers[it].max_brightness;
-				returner = &res->controllers[it];
-			}
-		}
-		it++;
-	}
-	
-	return returner;
-}
-
-controller* get_controller_by_name(fetch_result* res, const char* name){
-	unsigned int it;
-	controller* returner;
-	
-	it = 0;
-	returner = NULL;
-	
-	while(it < res->num_controllers){
-		if(strcmp(res->controllers[it].name, name) == 0){
-			returner = &res->controllers[it];
-		}
-		it++;
-	}
-	
-	return returner;
-		
-}
-
-void usage(){
-	printf("Usage: light [-qcaspmfh] [--options] <value>\n\n\tFlags:\n\t-q:\t Run quiet, supresses output.\n\t-c:\t Prints the current brightness in percent and exits.(Not precise)\n\t-p:\t Prints the current brightness directly from controller and exits. (Precise)\n\t-m:\t Prints the max brightness directly from controller and exits. \n\t-a:\t Add the value instead of setting it.\n\t-s:\t Subtract the value instead of setting it.\n\t-h:\t Shows this help and exits.\n");
-	printf("\n\tOptions:\n\t--help:\t Shows this help and exits.\n\n\t<value>\t Brightness wanted in percent.\n\n");
-}
-
-int main(int argc, char **argv) {
-	unsigned int argsit;
-	
-	fetch_result	res;
-	controller*	best_ctrl;
-	unsigned int	citr;
-	uid_t		uid;
-	unsigned int	minlight;
-	LBOOL		given;
-	unsigned int	real_wbright;
-	unsigned int	minlight_nonp;
-	unsigned int	curr_bright;
-	unsigned int	curr_brightp;
-	LBOOL		useforce;
-	char*		useforce_name;
-	
-	/* Get UID */
-	uid = getuid();
-	
-	useforce = FALSE;
-	useforce_name = malloc(256*sizeof(char));
-	
-	/* Parse arguments */
-	q=FALSE;
-	c=FALSE;
-	m=FALSE;
-	p=FALSE;
-	ot=SET;
-	wbright=0;
-	argsit = 1;
-	given=FALSE;
-	while(argsit < argc){
-		char* carg = argv[argsit];
-		if(carg[0] == '-'){
-			LBOOL argdone;
-			argdone = FALSE;
-			if(strlen(carg) > 2){
-				if(carg[1] == '-'){
-					int longargs = strlen(carg) -2;
-					char *longarg = (char*) malloc(longargs);
-					strncpy(longarg, carg+2, longargs);
-					
-					if(strcmp(longarg, "help") == 0){
-						usage();
-						return 0;
-					}else{
-						printf("Unknown option: \"%s\".\n", longarg);
-						return 0;
-					}
-					argdone = TRUE;
-				}
-			}
-			
-			if(argdone == FALSE){
-				unsigned int cargit = 1;
-				while(cargit < strlen(carg)){
-					switch(carg[cargit]){
-						case 'q':
-							q = TRUE;
-						break;
-						case 'a':
-							ot = ADD;
-						break;
-						case 's':
-							ot = SUB;
-						break;
-						case 'c':
-							c = TRUE;
-						break;
-						case 'p':
-							p = TRUE;
-						break;
-						case 'm':
-							m = TRUE;
-						break;
-						case 'h':
-							usage();
-							return 0;
-						break;
-						default:
-							printf("Unknown flag: %c\n", carg[cargit]);
-							return 1;
-						break;
-					}
-					cargit++;
-				}
-			}
-		}else{
-			wbright = atoi(carg);
-			given=TRUE;
-		}
-		
-		argsit++;
-	}
-	
-	
-	if(c == TRUE || m == TRUE || p == TRUE){
-		q = TRUE;
-	}
-	
-	if(given == FALSE && c == FALSE && m == FALSE && p == FALSE){
-		usage();
-		return 0;
-	}
-	if(q == FALSE)
-		printf("Light 0.7 - Fredrik Haikarainen\n");
-	
-	/* Get and check minlight */
-	
-	if(readint("/etc/light/minlight", &minlight) == FALSE){
-		minlight = 5;
-		if(q == FALSE)
-			printf("Warning: Couldn't read /etc/light/minlight, using 5 as default.\n");
-	}
-	
-	/* Fetch controllers */
-	if(q == FALSE)
-		printf("Fetching controllers..\n");
-	
-	res = fetch_controllers("/sys/class/backlight");
-	citr = 0;
-	while(citr < res.num_controllers){
-		controller* currc = &res.controllers[citr];
-		if(currc->is_ok == TRUE){
-			if(q == FALSE)
-				printf("\tFound '%s' (%u/%u)\n", currc->name, currc->current_brightness, currc->max_brightness);
-		}else{
-			if(q == FALSE)
-				printf("\tFound '%s', but ignoring\n", currc->name);
-		}
-		citr++;
-	}
-
-	if(q == FALSE)
-		printf("\n");
-	/* Read override-file if exists*/
-	if(readchar("/etc/light/override",useforce_name) == TRUE){
-		printf("Overriding controller '%s' !\n", useforce_name);
-		useforce=TRUE;
-	}
-	if(useforce == TRUE){
-		best_ctrl = get_controller_by_name(&res, useforce_name);
-		if(best_ctrl == NULL){
-			if(q == FALSE)
-				printf("Can't override, no such controller. Check/remove your override-file!\n");
-			return 1;	
-		}
-	}else{
-		/* Get the best controller */
-		best_ctrl = get_best_controller(&res);
-		
-		if(best_ctrl == NULL){
-			if(uid == 0){
-				if(q == FALSE)
-					printf("No okay controller found, even though you are root! Check your system.\n");
-			}else{
-				if(q == FALSE)
-					printf("No okay controller found, check your permissions or try to run as root.\n");
-			}
-			return 1;
-		}
-	}
-	
-	if(p == TRUE){
-		printf("%u\n", best_ctrl->current_brightness);
-		return 0;
-	}
-	
-	if(m == TRUE){
-		printf("%u\n", best_ctrl->max_brightness);
-		return 0;
-	}
-	
-	if(q == FALSE)
-		printf("Using controller '%s' ..\n", best_ctrl->name);
-	
-	if(wbright < 0){ wbright = 0;}
-	if(wbright > 100){wbright=100;}
-	
-	curr_bright = best_ctrl->current_brightness;
-	curr_brightp = (float)((float)curr_bright / (float)best_ctrl->max_brightness) * 100;
-	
-	
-	if(c == TRUE){
-		printf("%u\n", curr_brightp);
-		return 0;
-	}
-	
-	minlight_nonp = best_ctrl->max_brightness * ( (float)minlight / 100) + 1;
-	
-	switch(ot){
-		case SET:
-			real_wbright = best_ctrl->max_brightness * ( (float)wbright / 100 );
-		break;
-		case ADD:
-			real_wbright = ( best_ctrl->max_brightness * ( (float)( curr_brightp + wbright +1) / 100 ));
-		break;
-		case SUB:
-			if(curr_brightp <= wbright){
-				real_wbright = minlight_nonp;
-			}else{
-				real_wbright = ( best_ctrl->max_brightness * ( (float)( curr_brightp - wbright + 1) / 100 ));
-			}
-		break;
-		default:
-		break;
-	}
-	
-
-
-	/* FIXME<- SHOULD BE FIXED NOW, LETS STAY HERE ANYWAY JUST IN CASE 
-		Line below makes sure the value never wraps around and gets higher. Puts a (high) limit on max brightness.
-		Not sure if safe for portabilities sake.
-	 
-	if(real_wbright > ((UINT_MAX/2) - best_ctrl->max_brightness)){ real_wbright = minlight_nonp; } 
-	*/
-	
-	
-	if(real_wbright > best_ctrl->max_brightness){real_wbright = best_ctrl->max_brightness;}
-	if(real_wbright < minlight_nonp){real_wbright = minlight_nonp;}
-	
-	if(q == FALSE)
-		printf("Writing %u to file '%s'..\n", real_wbright, best_ctrl->b_path);
-	
-	if(writeint(best_ctrl->b_path, real_wbright) == FALSE){
-		if(q == FALSE){
-			printf("Error: Could not write to file %s, check your permissions!\n", best_ctrl->b_path);
-		}
-		return 1;
-	}
-	
-	return 0;
-}

src/helpers.c

@@ -0,0 +1,207 @@
+#include "helpers.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <dirent.h>
+
+LIGHT_BOOL light_readUInt(char const * filename, unsigned int *i)
+{
+  FILE* fileHandle;
+  unsigned int iCopy;
+
+  fileHandle = fopen(filename, "r");
+
+  if(!fileHandle)
+  {
+    LIGHT_ERR("could not open file for reading");
+    return FALSE;
+  }
+
+  if(fscanf(fileHandle, "%u", &iCopy) != 1)
+  {
+    LIGHT_ERR("file contents are corrupt");
+    fclose(fileHandle);
+    return FALSE;
+  }
+  
+  *i = iCopy;
+
+  fclose(fileHandle);
+  return TRUE;
+}
+
+LIGHT_BOOL light_writeUInt(char const * filename, unsigned int i)
+{
+  FILE* fileHandle;
+
+  fileHandle = fopen(filename, "w");
+
+  if(!fileHandle)
+  {
+    LIGHT_ERR("could not open file for writing");
+    return FALSE;
+  }
+
+  if(fprintf(fileHandle, "%u", i) < 0)
+  {
+    LIGHT_ERR("fprintf failed");
+    fclose(fileHandle);
+    return FALSE;
+  }
+
+  fclose(fileHandle);
+  return TRUE;
+}
+
+
+LIGHT_BOOL light_readULong(char const * filename, unsigned long *i)
+{
+  FILE* fileHandle;
+  unsigned long iCopy;;
+
+  fileHandle = fopen(filename, "r");
+
+  if(!fileHandle)
+  {
+    LIGHT_ERR("could not open file for reading");
+    return FALSE;
+  }
+
+  if(fscanf(fileHandle, "%lu", &iCopy) != 1)
+  {
+    LIGHT_ERR("file contents are corrupt");
+    fclose(fileHandle);
+    return FALSE;
+  }
+  
+  *i = iCopy;
+
+  fclose(fileHandle);
+  return TRUE;
+}
+
+LIGHT_BOOL light_writeULong(char const * filename, unsigned long i)
+{
+  FILE* fileHandle;
+
+  fileHandle = fopen(filename, "w");
+
+  if(!fileHandle)
+  {
+    LIGHT_ERR("could not open file for writing");
+    return FALSE;
+  }
+
+  if(fprintf(fileHandle, "%lu", i) < 0)
+  {
+    LIGHT_ERR("fprintf failed");
+    fclose(fileHandle);
+    return FALSE;
+  }
+
+  fclose(fileHandle);
+  return TRUE;
+}
+
+
+
+LIGHT_BOOL light_readString(char const * filename, char *buffer, long* size)
+{
+  FILE *fileHandle;
+  long fileSize;
+  long readSize;
+
+  /* Make sure buffer pointer is null */
+  if(buffer != NULL)
+  {
+    LIGHT_ERR("buffer passed to function isn't NULL");
+    return FALSE;
+  }
+
+  /* Open file */
+  fileHandle = fopen(filename, "r");
+
+  if(!fileHandle)
+  {
+    LIGHT_ERR("could not open file for reading");
+    return FALSE;
+  }
+
+  /* Get the file size */
+  fseek(fileHandle, 0L, SEEK_END);
+  fileSize = ftell(fileHandle);
+  rewind(fileHandle);
+
+  /* Allocate the string and null-terminate it */
+  buffer = (char*) malloc(sizeof(char)*(fileSize+1));
+  memset(buffer, '\0', fileSize);
+
+  if(buffer == NULL)
+  {
+    LIGHT_MEMERR();
+    fclose(fileHandle);
+    return FALSE;
+  }
+
+  /* Read the file */
+  readSize = fread(buffer, sizeof(char), fileSize, fileHandle);
+
+  if(readSize != fileSize)
+  {
+    LIGHT_ERR("read error");
+    free(buffer);
+    fclose(fileHandle);
+    return FALSE;
+  }
+  
+  /* Set the size */
+  if(size != NULL)
+  {
+    *size = readSize;
+  }
+
+  /* All well, close handle and return TRUE */
+  fclose(fileHandle);
+  return TRUE;
+}
+
+LIGHT_BOOL light_isDir(char const * path)
+{
+  DIR *dirHandle = opendir(path);
+
+  if(!dirHandle)
+  {
+    return FALSE;
+  }
+
+  closedir(dirHandle);
+  return TRUE;
+}
+
+LIGHT_BOOL light_isWritable(char const * filename)
+{
+  FILE* fileHandle = fopen(filename, "w");
+
+  if(!fileHandle)
+  {
+    return FALSE;
+  }
+
+  fclose(fileHandle);
+  return TRUE;
+}
+
+LIGHT_BOOL light_isReadable(char const * filename)
+{
+  FILE* fileHandle = fopen(filename, "r");
+
+  if(!fileHandle)
+  {
+    return FALSE;
+  }
+
+  fclose(fileHandle);
+  return TRUE;
+}

src/light.c

@@ -0,0 +1,703 @@
+#include "light.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+
+void light_defaultConfig()
+{
+  light_Configuration.controllerMode         = LIGHT_AUTO;
+  memset(&light_Configuration.specifiedController, '\0', 256);
+  light_Configuration.operationMode          = LIGHT_GET;
+  light_Configuration.valueMode              = LIGHT_PERCENT;
+  light_Configuration.specifiedValueRaw      = 0;
+  light_Configuration.specifiedValuePercent  = 0.0;
+  light_Configuration.target                 = LIGHT_BRIGHTNESS;
+  light_verbosity                            = 0;
+}
+
+LIGHT_BOOL light_parseArguments(int argc, char** argv)
+{
+  int currFlag;
+
+  LIGHT_BOOL opSet = FALSE;
+  LIGHT_BOOL targetSet = FALSE;
+  LIGHT_BOOL ctrlSet = FALSE;
+  LIGHT_BOOL valSet = FALSE;
+
+  unsigned long specLen = 0;
+
+  while((currFlag = getopt(argc, argv, "HhVGSAUbmcas:prv:")) != -1)
+  {
+    switch(currFlag)
+    {
+      /* -- Operations -- */
+      case 'H':
+      case 'h':
+        ASSERT_OPSET();
+        light_Configuration.operationMode = LIGHT_PRINT_HELP;
+        break;
+      case 'V':
+        ASSERT_OPSET();
+        light_Configuration.operationMode = LIGHT_PRINT_VERSION;
+        break;
+      case 'G':
+        ASSERT_OPSET();
+        light_Configuration.operationMode = LIGHT_GET;
+        break;
+      case 'S':
+        ASSERT_OPSET();
+        light_Configuration.operationMode = LIGHT_SET;
+        break;
+      case 'A':
+        ASSERT_OPSET();
+        light_Configuration.operationMode = LIGHT_ADD;
+        break;
+      case 'U':
+        ASSERT_OPSET();
+        light_Configuration.operationMode = LIGHT_SUB;
+        break;
+
+      /* -- Targets -- */
+      case 'b':
+        ASSERT_TARGETSET();
+        light_Configuration.target = LIGHT_BRIGHTNESS;
+        break;
+      case 'm':
+        ASSERT_TARGETSET();
+        light_Configuration.target = LIGHT_MAX_BRIGHTNESS;
+        break;
+      case 'c':
+        ASSERT_TARGETSET();
+        light_Configuration.target = LIGHT_MIN_CAP;
+        break;
+
+      /* -- Controller selection -- */
+      case 'a':
+        ASSERT_CTRLSET();
+        light_Configuration.controllerMode = LIGHT_AUTO;
+        break;;
+      case 's':
+        ASSERT_CTRLSET();
+        light_Configuration.controllerMode = LIGHT_SPECIFY;
+        if(optarg == NULL)
+        {
+          printf("-s NEEDS an argument.\n\n");
+          light_printHelp();
+        }
+
+        specLen = strlen(optarg);
+        if(specLen > 255)
+        {
+          specLen = 255;
+        }
+
+        strncpy(light_Configuration.specifiedController, optarg, specLen);
+
+        light_Configuration.specifiedController[255] = '\0';
+        break;
+      /* -- Value modes -- */
+      case 'p':
+        ASSERT_VALSET();
+        light_Configuration.valueMode = LIGHT_PERCENT;
+        break;
+      case 'r':
+        ASSERT_VALSET();
+        light_Configuration.valueMode = LIGHT_RAW;
+        break;
+
+      /* -- Other -- */
+      case 'v':
+        if(optarg == NULL)
+        {
+          printf("-v NEEDS an argument.\n\n");
+          light_printHelp();
+          return FALSE;
+        }
+        if(sscanf(optarg, "%i", &light_verbosity) != 1)
+        {
+          printf("-v Verbosity is not specified in a recognizable format.\n\n");
+          light_printHelp();
+          return FALSE;
+        }
+        if(light_verbosity < 0 || light_verbosity > 3)
+        {
+          printf("-v Verbosity has to be between 0 and 3.\n\n");
+          light_printHelp();
+          return FALSE;
+        }
+        break;
+    }
+  }
+
+  /* If we need a <value> (for writing), make sure we have it! */
+  if(light_Configuration.operationMode == LIGHT_SET ||
+     light_Configuration.operationMode == LIGHT_ADD ||
+     light_Configuration.operationMode == LIGHT_SUB)
+  {
+    if(argc - optind != 1)
+    {
+      printf("Light needs an argument for <value>.\n\n");
+      light_printHelp();
+      return FALSE;
+    }
+
+    if(light_Configuration.valueMode == LIGHT_PERCENT)
+    {
+      if(sscanf(argv[optind], "%lf", &light_Configuration.specifiedValuePercent) != 1){
+        printf("<value> is not specified in a recognizable format.\n\n");
+        light_printHelp();
+        return FALSE;
+      }
+      light_Configuration.specifiedValuePercent = LIGHT_CLAMP(light_Configuration.specifiedValuePercent, 0.00, 100.00);
+    }else{
+      if(sscanf(argv[optind], "%lu", &light_Configuration.specifiedValueRaw) != 1){
+        printf("<value> is not specified in a recognizable format.\n\n");
+        light_printHelp();
+        return FALSE;
+      }
+    }
+
+  }
+
+  return TRUE;
+}
+
+void light_printVersion(){
+  printf("Light %u.%u (%s)\n", LIGHT_VER_MAJOR, LIGHT_VER_MINOR, LIGHT_VER_TYPE);
+  printf("Copyright (C) %u %s\n", LIGHT_YEAR, LIGHT_AUTHOR);
+  printf("This is free software, see the source for copying conditions.  There is NO\n");
+  printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE\n\n");
+}
+
+void light_printHelp(){
+  printf("Usage: light <options> <value>\n");
+  printf("<value> has to be either integral(raw mode) or decimal(percent mode) depending on the specified value mode.\n");
+  printf("<options> can be any of the following:\n\n");
+
+  printf("Operations (can not be used in conjunction):\n");
+  printf("  -H -h:\tPrints this help and exits\n");
+  printf("  -V:\t\tPrints version info and exits\n");
+  printf("  -G:\t\tGet value (default)\n");
+  printf("  -S:\t\tSet value\n");
+  printf("  -A:\t\tAdd value\n");
+  printf("  -U:\t\tSubtract value\n\n");
+  
+  printf("Targets (can not be used in conjunction):\n");
+  printf("  -b:\t\tBrightness (default)\n  \t\tUsed with [GSAU]\n\n");
+  printf("  -m:\t\tMaximum brightness\n  \t\tUsed with [G]\n\n");
+  printf("  -c:\t\tMinimum cap\n  \t\tUsed with [GS]\n");
+  printf("  \t\tG returns null if no minimum cap is set.\n\n");
+
+  printf("Controller selection (can not be used in conjunction):\n");
+  printf("  -a:\t\tSelects controller automatically (default).\n");
+  printf("  -s:\t\tSpecify controller to use. (needs argument)\n\n");
+
+  printf("Value modes (can not be used in conjunction):\n");
+  printf("  -p:\t\tInterpret <value> as, and output values in, percent. (default)\n");
+  printf("  -r:\t\tInterpret <value> as, and output values in, raw mode.\n\n");
+  
+  printf("Other:\n");
+  printf("  -v:\t\tSets the verbosity level, (needs argument).\n  \t\t0: Only outputs read values.\n  \t\t1: Read values, Errors.\n  \t\t2: Read values, Errors, Warnings.\n  \t\t3: Read values, Errors, Warnings, Notices.\n\n");
+}
+
+LIGHT_BOOL light_initialize(int argc, char** argv)
+{
+  light_defaultConfig();
+  if(!light_parseArguments(argc, argv))
+  {
+    LIGHT_ERR("could not parse arguments");
+    return FALSE;
+  }
+
+  if(light_Configuration.operationMode == LIGHT_PRINT_HELP || light_Configuration.operationMode == LIGHT_PRINT_VERSION)
+  {
+      return TRUE;
+  }
+  
+  /* Make sure we have a valid controller before we proceed */
+  if(light_Configuration.controllerMode == LIGHT_AUTO)
+  {
+    LIGHT_NOTE("Automatic mode -- finding best controller");
+    if(!light_getBestController(light_Configuration.specifiedController))
+    {
+      LIGHT_ERR("could not find suitable controller");
+      return FALSE;
+    }
+  }
+
+  if(!light_controllerAccessible(light_Configuration.specifiedController))
+  {
+    LIGHT_ERR("selected controller is not valid, make sure this application is run as root.");
+    return FALSE;
+  }
+  
+
+  return TRUE;
+}
+
+LIGHT_BOOL light_execute()
+{
+  unsigned long rawCurr; /* The current brightness, in raw mode */
+  double    percentCurr; /* The current brightness, in percent  */
+  unsigned long  rawMax; /* The max brightness, in percent      */
+  
+  unsigned long  rawSetP; /* The final value to be set, in raw mode, when setting with percent */
+  unsigned long  rawAddP; /* The final value to be set, in raw mode, when adding with percent */
+  unsigned long  rawSubP; /* The final value to be set, in raw mode, when subtracting with percent */
+
+  unsigned long  rawSetR; /* The final value to be set, in raw mode, when setting with raw values */
+  unsigned long  rawAddR; /* The final value to be set, in raw mode, when adding with raw values */
+  unsigned long  rawSubR; /* The final value to be set, in raw mode, when subtracting with raw values */
+
+  unsigned long   minCap; /* The minimum cap, in raw mode */
+  double   percentMinCap; /* The minimum cap, in percent */
+  LIGHT_BOOL   hasMinCap; /* If we have a minimum cap     */
+  unsigned long  minCapP; /* The final value to be set, in raw mode, when setting with percent (This is uncapped and used for minimum cap setting) */
+  unsigned long  minCapR; /* The final value to be set, in raw mode, when setting with raw values (This is uncapped and used for minimum cap setting) */
+
+  unsigned long  *writeVal; /* The actual value used for writing */
+
+  /* Print help and version info */
+  if(light_Configuration.operationMode == LIGHT_PRINT_HELP)
+  {
+    light_printHelp();
+    return TRUE;
+  }
+
+  if(light_Configuration.operationMode == LIGHT_PRINT_VERSION)
+  {
+    light_printVersion();
+    return TRUE;
+  }
+
+  /* Prepare variables */
+
+  /* -- First, get the current, min and max values directly from controller/configuration (raw values) */
+  if(!light_getBrightness(light_Configuration.specifiedController, &rawCurr))
+  {
+    LIGHT_ERR("could not get brightness");
+    return FALSE;
+  }
+
+  if(!light_getMaxBrightness(light_Configuration.specifiedController, &rawMax))
+  {
+    LIGHT_ERR("could not get max brightness");
+    return FALSE;
+  }
+
+  if(!light_getMinCap(light_Configuration.specifiedController, &hasMinCap, &minCap))
+  {
+    LIGHT_ERR("could not get min brightness");
+    return FALSE;
+  }
+
+  if( hasMinCap && ( minCap < 0 || minCap > rawMax ) )
+  {
+    LIGHT_WARN("invalid minimum cap for controller, ignoring and using 0");
+    minCap = 0;
+  }
+
+  /* -- Secondly, calculate the rest of the values (Clamp them here as well!) */
+  percentCurr = LIGHT_CLAMP( ((double)rawCurr) /  ((double)rawMax) * 100 , 0.00, 100.00 );
+  percentMinCap = LIGHT_CLAMP( ((double)minCap) / ((double)rawMax) * 100 , 0.00, 100.00 );  
+
+  rawSetP     = LIGHT_CLAMP( ((unsigned long) (light_Configuration.specifiedValuePercent * ((double)rawMax) ) / 100) , minCap, rawMax );
+  rawAddP     = LIGHT_CLAMP( ((unsigned long) ( (percentCurr + light_Configuration.specifiedValuePercent) * ((double)rawMax)) / 100) , minCap, rawMax );
+  rawSubP     = LIGHT_CLAMP( ((unsigned long) ( (percentCurr - light_Configuration.specifiedValuePercent) * ((double)rawMax)) / 100) , minCap, rawMax );
+
+  rawSetR     = LIGHT_CLAMP( light_Configuration.specifiedValueRaw , minCap, rawMax );
+  rawAddR     = LIGHT_CLAMP( rawCurr + light_Configuration.specifiedValueRaw , minCap, rawMax );
+  rawSubR     = LIGHT_CLAMP( rawCurr - light_Configuration.specifiedValueRaw , minCap, rawMax );
+
+  minCapP     = LIGHT_CLAMP(((unsigned long) (light_Configuration.specifiedValuePercent * ((double)rawMax) ) / 100), 0, rawMax);
+  minCapR     = LIGHT_CLAMP( light_Configuration.specifiedValueRaw, 0, rawMax );
+  
+  /* Handle get operations */
+  if(light_Configuration.operationMode == LIGHT_GET)
+  {
+    switch(light_Configuration.target){
+      case LIGHT_BRIGHTNESS:
+        (light_Configuration.valueMode == LIGHT_RAW) ? printf("%lu\n", rawCurr) : printf("%.2f\n", percentCurr);
+        break;
+      case LIGHT_MAX_BRIGHTNESS:
+        (light_Configuration.valueMode == LIGHT_RAW) ? printf("%lu\n", rawMax) : printf("100.00\n"); /* <- I know how stupid it is but it might just make someones life easier */
+        break;
+      case LIGHT_MIN_CAP:
+        (light_Configuration.valueMode == LIGHT_RAW) ? printf("%lu\n", minCap) : printf("%.2f\n", percentMinCap);
+        break;
+    }
+
+    return TRUE;
+  }
+
+  /* Handle set/add/sub operations */
+  if(light_Configuration.operationMode == LIGHT_SET ||
+     light_Configuration.operationMode == LIGHT_ADD || 
+     light_Configuration.operationMode == LIGHT_SUB)
+  {
+
+    /* Set the pointer we will use for write to a fallback (that shouldn't change anything) */
+    writeVal = &rawCurr;
+
+    if(light_Configuration.target == LIGHT_MIN_CAP)
+    {
+      /* Handle minimum cap files */
+
+      /* If we are not attempting to set, fail! */
+      if(light_Configuration.operationMode != LIGHT_SET)
+      {
+        printf("Minimum cap can only be used with get/set operations.\n");
+        return FALSE;
+      }
+
+      /* Point our writevalue and attempt to write*/
+      writeVal = (light_Configuration.valueMode == LIGHT_RAW) ? &minCapR : &minCapP;
+      if(!light_setMinCap(light_Configuration.specifiedController, *writeVal))
+      {
+        LIGHT_ERR("could not set minimum cap");
+        return FALSE;
+      }
+
+      /* All good? Return true. */
+      return TRUE;
+
+    }else if(light_Configuration.target == LIGHT_BRIGHTNESS){
+      /* Handle brightness writing */
+
+      /* Point our writevalue according to configuration */
+      switch(light_Configuration.operationMode)
+      {
+        case LIGHT_SET:
+          writeVal = (light_Configuration.valueMode == LIGHT_RAW) ? &rawSetR : &rawSetP;
+          break;
+        case LIGHT_ADD:
+          writeVal = (light_Configuration.valueMode == LIGHT_RAW) ? &rawAddR : &rawAddP;
+          break;
+        case LIGHT_SUB:
+          writeVal = (light_Configuration.valueMode == LIGHT_RAW) ? &rawSubR : &rawSubP;
+          break;
+        case LIGHT_GET:
+        case LIGHT_PRINT_HELP:
+        case LIGHT_PRINT_VERSION:
+          break;
+      }
+
+      /* Attempt to write */
+      if(!light_setBrightness(light_Configuration.specifiedController, *writeVal))
+      {
+        LIGHT_ERR("could not set brightness");
+        return FALSE;
+      }
+
+      /* All good? return true. */
+      return TRUE;
+
+    }else{
+      /* If we didn't provide a valid target for write operations, fail. */
+      printf("set/add/subtract operations are only available for brightness and minimum cap files.\n");
+      return FALSE;
+    }
+  }
+
+  printf("Controller: %s\nValueRaw: %lu\nValuePercent: %.2f\nOpMode: %u\nValMode: %u\nTarget: %u\n\n", light_Configuration.specifiedController, light_Configuration.specifiedValueRaw, light_Configuration.specifiedValuePercent, light_Configuration.operationMode, light_Configuration.valueMode, light_Configuration.target);
+
+  printf("You did not specify a valid combination of commandline arguments. Have some help: \n");
+  light_printHelp();
+  return FALSE;
+}
+
+void light_free()
+{
+
+}
+
+LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET type, char **buffer)
+{
+  char* returner = (char*)malloc(256);
+  int spfVal = -1;
+
+  if(returner == NULL)
+  {
+    LIGHT_MEMERR();
+    buffer = NULL;
+    return FALSE;
+  }
+
+  memset(returner, '\0', 256);
+  
+  switch(type)
+  {
+    case LIGHT_BRIGHTNESS:
+      spfVal = sprintf(returner, "/sys/class/backlight/%s/brightness", controller);
+      break;
+    case LIGHT_MAX_BRIGHTNESS:
+      spfVal = sprintf(returner, "/sys/class/backlight/%s/max_brightness", controller);
+      break;
+    case LIGHT_MIN_CAP:
+      spfVal = sprintf(returner, "/etc/light/mincap/%s", controller);
+      break;
+  }
+
+  if(spfVal < 0)
+  {
+    LIGHT_ERR("sprintf failed");
+    free(returner);
+    buffer = NULL;
+    return FALSE;
+  }
+
+  *buffer = returner;
+
+  return TRUE;
+}
+
+LIGHT_BOOL light_getBrightness(char const *controller, unsigned long *v)
+{
+  char *brightnessPath = NULL;
+  LIGHT_BOOL readVal = FALSE;
+
+  if(!light_genPath(controller, LIGHT_BRIGHTNESS, &brightnessPath))
+  {
+    LIGHT_ERR("could not generate path to brightness file");
+    return FALSE;
+  }
+
+  readVal = light_readULong( brightnessPath , v);
+  free(brightnessPath);
+
+  if(!readVal)
+  {
+    LIGHT_ERR("could not read value from brightness file");
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+LIGHT_BOOL light_getMaxBrightness(char const *controller, unsigned long *v)
+{
+  char *maxPath;
+  LIGHT_BOOL readVal = FALSE;
+
+  if(!light_genPath(controller, LIGHT_MAX_BRIGHTNESS, &maxPath))
+  {
+    LIGHT_ERR("could not generate path to maximum brightness file");
+    return FALSE;
+  }
+
+  readVal = light_readULong(maxPath , v);
+  free(maxPath);
+
+  if(!readVal)
+  {
+    LIGHT_ERR("could not read value from max brightness file");
+    return FALSE;
+  }
+
+  if(*v == 0)
+  {
+    LIGHT_ERR("max brightness is 0, so controller is not valid");
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+LIGHT_BOOL light_setBrightness(char const *controller, unsigned long v)
+{
+  char *brightnessPath = NULL;
+  LIGHT_BOOL writeVal = FALSE;
+
+  if(!light_genPath(controller, LIGHT_BRIGHTNESS, &brightnessPath))
+  {
+    LIGHT_ERR("could not generate path to brightness file");
+    return FALSE;
+  }
+
+  writeVal = light_writeULong(brightnessPath, v);
+
+  if(!writeVal)
+  {
+    LIGHT_ERR("could not write value to brightness file");
+  }
+
+  free(brightnessPath);
+  return writeVal;
+}
+
+LIGHT_BOOL light_controllerAccessible(char const *controller)
+{
+  char *brightnessPath = NULL;
+  unsigned long dummy;
+
+  if(!light_getBrightness(controller, &dummy))
+  {
+    LIGHT_WARN("could not read controllers brightness file, so controller is not accessible")
+    return FALSE;
+  }
+
+  if(!light_getMaxBrightness(controller, &dummy))
+  {
+    LIGHT_WARN("could not read controller max brightness file, so controller is not accessible")
+    return FALSE;
+  }
+
+  if(!light_genPath(controller, LIGHT_BRIGHTNESS, &brightnessPath))
+  {
+    LIGHT_ERR("could not generate path to brightness file");
+    return FALSE;
+  }
+
+  if(!light_isWritable(brightnessPath))
+  {
+    LIGHT_WARN("could not open controller brightness file for writing, so controller is not accessible");
+    free(brightnessPath);
+    return FALSE;
+  }
+
+  free(brightnessPath);
+  return TRUE;
+}
+
+LIGHT_BOOL light_iterateControllers()
+{
+  LIGHT_BOOL dotsKilled = FALSE;
+
+  if(light_iteratorDir == NULL)
+  {
+    light_iteratorDir = opendir("/sys/class/backlight");
+    if(light_iteratorDir == NULL)
+    {
+      LIGHT_ERR("could not open /sys/class/backlight directory");
+      return FALSE;
+    }
+  }
+
+  while(!dotsKilled)
+  {
+    light_iterator = readdir(light_iteratorDir);
+    if(light_iterator == NULL)
+    {
+      if(light_iteratorDir != NULL)
+      {
+        closedir(light_iteratorDir);
+        light_iteratorDir = NULL;
+      }
+      return FALSE;
+    }
+
+    if(light_iterator->d_name[0] != '.')
+    {
+      dotsKilled = TRUE;
+    }
+  }
+
+  strcpy(light_currentController, light_iterator->d_name);
+
+  return TRUE;
+}
+
+LIGHT_BOOL light_getBestController(char *controller)
+{
+  char bestYet[256];
+  unsigned long bestValYet = 0;
+  LIGHT_BOOL foundOkController = FALSE;
+
+  memset(bestYet, '\0', 256);
+
+  while(light_iterateControllers())
+  {
+    unsigned long currVal = 0;
+
+    if(light_getMaxBrightness(light_currentController, &currVal))
+    {
+      
+      if(light_controllerAccessible(light_currentController))
+      {
+        if(currVal > bestValYet)
+        {
+        foundOkController = TRUE;
+        bestValYet = currVal;
+        memset(bestYet, '\0', 256);
+        strcpy(bestYet, light_currentController);
+        }else{
+          LIGHT_NOTE("ignoring controller as better one already found");
+        }
+      }else{
+        LIGHT_WARN("controller not accessible");
+      }
+    }else{
+      LIGHT_WARN("could not read max brightness from file");
+    }
+  }
+
+  if(!foundOkController)
+  {
+    LIGHT_ERR("could not find an accessible controller");
+    return FALSE;
+  }
+
+  if(bestValYet == 0)
+  {
+    LIGHT_ERR("found accessible controller but it's useless/corrupt");
+    return FALSE;
+  }
+
+  memset(controller, '\0', 256);
+  strcpy(controller, bestYet);
+
+  return TRUE;
+}
+
+LIGHT_BOOL light_getMinCap(char const * controller, LIGHT_BOOL * hasMinCap, unsigned long * minCap)
+{
+ char * mincapPath = NULL;
+ 
+ if(!light_genPath(controller, LIGHT_MIN_CAP, &mincapPath))
+ {
+    LIGHT_ERR("could not generate path to minimum cap file");
+    return FALSE;
+ }
+
+  if(!light_isReadable(mincapPath)){
+    *hasMinCap = FALSE;
+    *minCap = 0;
+    free(mincapPath);
+    return TRUE;
+  }
+
+  if(!light_readULong(mincapPath, minCap))
+  {
+    LIGHT_ERR("could not read minimum cap from file");
+    free(mincapPath);
+    return FALSE;
+  }
+
+  *hasMinCap = TRUE;
+
+  free(mincapPath);
+  return TRUE;
+}
+
+LIGHT_BOOL light_setMinCap(char const * controller, unsigned long v)
+{
+  char * mincapPath = NULL;
+  if(!light_genPath(controller, LIGHT_MIN_CAP, &mincapPath))
+  {
+    LIGHT_ERR("could not generate path to minimum cap file");
+    return FALSE;
+  }
+
+  if(!light_writeULong(mincapPath, v))
+  {
+    LIGHT_ERR("could not write to minimum cap file");
+    free(mincapPath);
+    return FALSE;
+  }
+
+  free(mincapPath);
+  return TRUE;
+}

src/main.c

@@ -0,0 +1,26 @@
+#include "light.h"
+
+#include <stdio.h>
+
+#define LIGHT_RETURNVAL_INITFAIL  -2
+#define LIGHT_RETURNVAL_EXECFAIL  -1
+#define LIGHT_RETURNVAL_SUCCESS   0
+
+int main(int argc, char** argv)
+{
+  if(!light_initialize(argc, argv))
+  {
+    LIGHT_ERR("Initialization failed");
+    return LIGHT_RETURNVAL_INITFAIL;
+  }
+
+  if(!light_execute())
+  {
+    LIGHT_ERR("Execution failed");
+    light_free();
+    return LIGHT_RETURNVAL_EXECFAIL;
+  }
+
+  light_free();
+  return LIGHT_RETURNVAL_SUCCESS;
+}