Merge pull request #25 from abdullahibnnadjo/master

Various fixes and improvements

Makefile

 MANDIR=$(PREFIX)/share/man/man1
 
 CC=gcc
-CFLAGS=-std=c89 -O2 -pedantic -Wall -I"./include"
+CFLAGS=-std=c89 -O2 -pedantic -Wall -I"./include" -D_XOPEN_SOURCE=500
 MANFLAGS=-h -h -v -V -N
 
 HELP2MAN_VERSION := $(shell help2man --version 2>/dev/null)

README.md

 
 ## Usage
 
-This application usually has 4 different criteria on flags to use, which are operation modes, value mode, target and controller mode. Flags from these different modes can never be used in conjunction, but all of them do not always have to be specified (although it is recommended to do so for verbosity).
+This application usually has 5 different criteria on flags to use, which are operation modes, value mode, target, field and controller mode. Flags from these different modes can never be used in conjunction, but all of them do not always have to be specified (although it is recommended to do so for verbosity).
 
 **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 with -v:
 
 
 ### Target
 
-As you can not only handle the **brightness** of controllers, you may also specify a target to read/write from/to:
+You can choose which target to act on:
+
+* -l: Act on screen backlight
+* -k: Act on keyboard backlight and LEDs
+
+### Field
+
+As you can not only handle the **brightness** of controllers, you may also specify a field to read/write from/to:
 
 * -b: Current brightness of selected controller
 * -m: Maximum brightness of selected controller
 * -c: Minimum brightness (cap) of selected controller
-* -k: Set keyboard brightness instead of display brightness
 
 The minimum brightness is a feature implemented as some controllers make the screen go pitch black at 0%, if you have a controller like that, it is recommended to set this value (in either percent or in raw mode). These values will be saved in raw mode though, so if you specify it in percent it might not be too accurate depending on your controller.
 
 
 Get the current brightness in percent
 
-`light -G`
+`light -G`, or simply `light`
 
 Increase brightness by 5 percent
 
 
 `light -Scrs "acpi_video0" 2`
 
+Try to set the brightness to 0 after that, it will be changed to the minimum 2
+
+`light -Srs "acpi_video0" 0`
+
+Find keyboard controllers
+
+`light -Lk`
+
+Activate `ScrollLock` LED
+
+`light -Sks "input15::scrolllock" 100`
+
+Usually, LEDs only take 0 or 1 in raw value (i.e. for off/on), so you can write
+
+`light -Skrs "input15::scrolllock" 1`
+
+Verify this with `light -v3 -mkrs input15::scrolllock`, you should get a max. brightness of 1

include/helpers.h

  *    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");
+#define LIGHT_CLAMP(x, y, z) ((x<y) ? (light_logInfClamp(y)) : ((x>z) ? (light_logSupClamp(z)) : x ))
 
+#define LIGHT_LOG_FMT_BUF_SIZE 1024
 /* Verbosity levels: 
  * 0 - No output
  * 1 - Errors
  * 2 - Errors, warnings 
  * 3 - Errors, warnings, notices */
-int    light_verbosity;
+typedef enum LIGHT_LOG_LEVEL {
+  LIGHT_ERROR_LEVEL = 1,
+  LIGHT_WARN_LEVEL,
+  LIGHT_NOTE_LEVEL
+} LIGHT_LOG_LEVEL;
+
+LIGHT_LOG_LEVEL light_verbosity;
+char light_log_buffer[LIGHT_LOG_FMT_BUF_SIZE];
+
+#define LIGHT_LOG(lvl,f,t,x)if(light_verbosity >= lvl){fprintf(f,t": \"%s\", in \"%s\" on line %u.\n", x, __FILE__, __LINE__);}
+
+#define LIGHT_NOTE(x)LIGHT_LOG(LIGHT_NOTE_LEVEL,stdout,"notice",x)
+
+#define LIGHT_WARN(x)LIGHT_LOG(LIGHT_WARN_LEVEL,stderr,"warning",x)
+
+#define LIGHT_ERR(x)LIGHT_LOG(LIGHT_ERROR_LEVEL,stderr,"error",x)
+
+#define LIGHT_LOG_FMT(x,s,f)if(snprintf(light_log_buffer, LIGHT_LOG_FMT_BUF_SIZE,x,s) > 0){f(light_log_buffer);}
+
+#define LIGHT_NOTE_FMT(x,s)LIGHT_LOG_FMT(x,s,LIGHT_NOTE);
+
+#define LIGHT_WARN_FMT(x,s)LIGHT_LOG_FMT(x,s,LIGHT_WARN);
+
+#define LIGHT_ERR_FMT(x,s)LIGHT_LOG_FMT(x,s,LIGHT_ERR);
+
+#define LIGHT_MEMERR() LIGHT_ERR("memory error");
+
+#define LIGHT_PERMLOG(x,f)f##_FMT("could not open '%s' for "x,filename); f("check if this file exists or if you have the right permissions");
+
+#define LIGHT_PERMERR(x) LIGHT_PERMLOG(x,LIGHT_ERR)
+
+#define LIGHT_PERMWARN(x) LIGHT_PERMLOG(x,LIGHT_WARN)
 
 /* Typedef for boolean values */
 typedef enum LIGHT_BOOL {
 /* Returns TRUE if file is readable, FALSE otherwise */
 LIGHT_BOOL light_isReadable(char const * filename);
 
+/* Clamps the `percent` value between 0% and 100% */
+double light_clampPercent(double percent);
+
+/* Prints a notice about a value which was below `x` and was adjusted to it */
+unsigned long light_logInfClamp(unsigned long x);
+
+/* Prints a notice about a value which was above `x` and was adjusted to it */
+unsigned long light_logSupClamp(unsigned long x);
+
 #endif /* LIGHT_HELPERS_H */

include/light.h

 
 #include <sys/types.h>
 #include <dirent.h>
+#include <linux/limits.h>
 
 #define LIGHT_VER_MAJOR 0
-#define LIGHT_VER_MINOR 9
+#define LIGHT_VER_MINOR 10
 #define LIGHT_VER_TYPE "beta"
 #define LIGHT_YEAR 2014
 #define LIGHT_AUTHOR "Fredrik Haikarainen"
 
-#define ASSERT_OPSET() \
-  if(opSet)\
+#define ASSERT_SET(t,v) \
+  if(v)\
   {\
-    printf("Operation arguments can not be used in conjunction.\n");\
+    fprintf(stderr, t" 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;
+  v = TRUE;
 
+#define ASSERT_OPSET() ASSERT_SET("Operation", opSet)
+#define ASSERT_TARGETSET() ASSERT_SET("Target", targetSet)
+#define ASSERT_FIELDSET() ASSERT_SET("Field", fieldSet)
+#define ASSERT_CTRLSET() ASSERT_SET("Controller", ctrlSet)
+#define ASSERT_VALSET() ASSERT_SET("Value", valSet)
 
-typedef enum LIGHT_TARGET {
+typedef enum LIGHT_FIELD {
   LIGHT_BRIGHTNESS = 0,
   LIGHT_MAX_BRIGHTNESS,
   LIGHT_MIN_CAP,
-  LIGHT_SAVERESTORE,
-  LIGHT_KEYBOARD,
-  LIGHT_KEYBOARD_MAX_BRIGHTNESS
+  LIGHT_SAVERESTORE
+} LIGHT_FIELD;
+
+typedef enum LIGHT_TARGET {
+  LIGHT_BACKLIGHT = 0,
+  LIGHT_KEYBOARD
 } LIGHT_TARGET;
 
 typedef enum LIGHT_CTRL_MODE {
 typedef struct light_runtimeArguments_s {
   /* Which controller to use */
   LIGHT_CTRL_MODE controllerMode;
-  char            specifiedController[256];
+  char            specifiedController[NAME_MAX + 1];
 
   /* What to do with the controller */
   LIGHT_OP_MODE   operationMode;
   unsigned long   specifiedValueRaw; /* The specified value in raw mode */
   double          specifiedValuePercent; /* The specified value in percent */
 
-  LIGHT_TARGET    target;
-} light_runtimeArguments, *light_runtimeArguments_p;
+  LIGHT_TARGET   target;
+  LIGHT_FIELD    field;
+
+  /* Cache data */
+  LIGHT_BOOL      hasCachedMaxBrightness;
+  unsigned long   cachedMaxBrightness;
 
-/* -- Global variables that handles iterating controllers -- */
-struct dirent *light_iterator;
-DIR           *light_iteratorDir;
-char          light_currentController[256];
+} light_runtimeArguments, *light_runtimeArguments_p;
 
 /* -- Global variable holding the settings for the current run -- */
 light_runtimeArguments light_Configuration;
 /* 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);
+ * Size is always NAME_MAX + 1 */
+LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET target, LIGHT_FIELD type, char **buffer);
+
+LIGHT_BOOL light_validControllerName(char const *controller);
 
 LIGHT_BOOL light_getBrightness(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 */
+/* WARNING: `controller` HAS to be at most NAME_MAX, otherwise fails */
 LIGHT_BOOL light_getBestController(char *controller);
 
 LIGHT_BOOL light_getMinCap(char const *controller, LIGHT_BOOL *hasMinCap, unsigned long *minCap);

src/helpers.c

 
   if(!fileHandle)
   {
-    LIGHT_ERR("could not open file for reading");
+    LIGHT_PERMERR("reading");
     return FALSE;
   }
 
   if(fscanf(fileHandle, "%u", &iCopy) != 1)
   {
-    LIGHT_ERR("file contents are corrupt");
+    LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
     fclose(fileHandle);
     return FALSE;
   }
 
   if(!fileHandle)
   {
-    LIGHT_ERR("could not open file for writing");
+    LIGHT_PERMERR("writing");
     return FALSE;
   }
 
 
   if(!fileHandle)
   {
-    LIGHT_ERR("could not open file for reading");
+    LIGHT_PERMERR("reading");
     return FALSE;
   }
 
   if(fscanf(fileHandle, "%lu", &iCopy) != 1)
   {
-    LIGHT_ERR("file contents are corrupt");
+    LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
     fclose(fileHandle);
     return FALSE;
   }
 
   if(!fileHandle)
   {
-    LIGHT_ERR("could not open file for writing");
+    LIGHT_PERMERR("writing");
     return FALSE;
   }
 
 
   if(!fileHandle)
   {
-    LIGHT_ERR("could not open file for reading");
+    LIGHT_PERMERR("reading");
     return FALSE;
   }
 
 
 LIGHT_BOOL light_isWritable(char const * filename)
 {
-  FILE* fileHandle = fopen(filename, "w");
+  FILE* fileHandle = fopen(filename, "r+");
 
   if(!fileHandle)
   {
+    LIGHT_PERMWARN("writing");
     return FALSE;
   }
 
 
   if(!fileHandle)
   {
+    LIGHT_PERMWARN("reading");
     return FALSE;
   }
 
   fclose(fileHandle);
   return TRUE;
 }
+
+unsigned long light_logInfClamp(unsigned long x)
+{
+  LIGHT_NOTE_FMT("specified value is inferior to %lu (raw), so adjusting it to this mininum value", x);
+  return x;
+}
+
+unsigned long light_logSupClamp(unsigned long x)
+{
+  LIGHT_NOTE_FMT("specified value is superior to %lu (raw), so adjusting it to this maximum value", x);
+  return x;
+}
+
+double light_clampPercent(double p)
+{
+  if(p < 0.0)
+  {
+    LIGHT_WARN_FMT("specified value %g%% is not valid, adjusting it to 0%%", p);
+    return 0.0;
+  }else if(p > 100.0){
+    LIGHT_WARN_FMT("specified value %g%% is not valid, adjusting it to 100%%", p);
+    return 100.0;
+  }
+  return p;
+}