Merge pull request #48 from troglobit/coding-style

Coding style

src/Makefile.am

@@ -1,7 +1,7 @@
 bin_PROGRAMS   = light
 light_SOURCES  = main.c light.c light.h helpers.c helpers.h
 light_CPPFLAGS = -I../include -D_XOPEN_SOURCE=500
-light_CFLAGS   = -W -Wall -Wextra -pedantic -std=c99
+light_CFLAGS   = -W -Wall -Wextra -std=gnu99 -Wno-type-limits
 
 install-exec-hook:
 	chmod 4755 $(DESTDIR)$(bindir)/light

src/helpers.c

@@ -6,229 +6,105 @@
 #include <sys/types.h>
 #include <dirent.h>
 
-LIGHT_BOOL light_readUInt(char const * filename, unsigned int *i)
+bool light_file_read_val(char const *filename, unsigned long *val)
 {
-  FILE* fileHandle;
-  unsigned int iCopy;
-
-  fileHandle = fopen(filename, "r");
-
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("reading");
-    return FALSE;
-  }
-
-  if(fscanf(fileHandle, "%u", &iCopy) != 1)
-  {
-    LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
-    fclose(fileHandle);
-    return FALSE;
-  }
-  
-  *i = iCopy;
-
-  fclose(fileHandle);
-  return TRUE;
-}
-
-LIGHT_BOOL light_writeUInt(char const * filename, unsigned int i)
-{
-  FILE* fileHandle;
+	FILE *fp;
+	unsigned long data;
 
-  fileHandle = fopen(filename, "w");
+	fp = fopen(filename, "r");
+	if (!fp) {
+		LIGHT_PERMERR("reading");
+		return false;
+	}
 
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("writing");
-    return FALSE;
-  }
+	if (fscanf(fp, "%lu", &data) != 1) {
+		LIGHT_ERR("Couldn't parse a positive integer number from '%s'", filename);
+		fclose(fp);
+		return false;
+	}
 
-  if(fprintf(fileHandle, "%u", i) < 0)
-  {
-    LIGHT_ERR("fprintf failed");
-    fclose(fileHandle);
-    return FALSE;
-  }
+	*val = data;
 
-  fclose(fileHandle);
-  return TRUE;
+	fclose(fp);
+	return true;
 }
 
-
-LIGHT_BOOL light_readULong(char const * filename, unsigned long *i)
+bool light_file_write_val(char const *filename, unsigned long val)
 {
-  FILE* fileHandle;
-  unsigned long iCopy;;
-
-  fileHandle = fopen(filename, "r");
-
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("reading");
-    return FALSE;
-  }
-
-  if(fscanf(fileHandle, "%lu", &iCopy) != 1)
-  {
-    LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
-    fclose(fileHandle);
-    return FALSE;
-  }
-  
-  *i = iCopy;
-
-  fclose(fileHandle);
-  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;
 }
 
-LIGHT_BOOL light_writeULong(char const * filename, unsigned long i)
+/* Returns true if file is writable, false otherwise */
+bool light_file_is_writable(char const *filename)
 {
-  FILE* fileHandle;
-
-  fileHandle = fopen(filename, "w");
+	FILE *fp;
 
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("writing");
-    return FALSE;
-  }
+	fp = fopen(filename, "r+");
+	if (!fp) {
+		LIGHT_PERMWARN("writing");
+		return false;
+	}
 
-  if(fprintf(fileHandle, "%lu", i) < 0)
-  {
-    LIGHT_ERR("fprintf failed");
-    fclose(fileHandle);
-    return FALSE;
-  }
-
-  fclose(fileHandle);
-  return TRUE;
+	fclose(fp);
+	return true;
 }
 
-
-
-LIGHT_BOOL light_readString(char const * filename, char *buffer, long* size)
+/* Returns true if file is readable, false otherwise */
+bool light_file_is_readable(char const *filename)
 {
-  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_PERMERR("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 = 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;
-}
+	FILE *fp;
 
-LIGHT_BOOL light_isDir(char const * path)
-{
-  DIR *dirHandle = opendir(path);
+	fp = fopen(filename, "r");
+	if (!fp) {
+		LIGHT_PERMWARN("reading");
+		return false;
+	}
 
-  if(!dirHandle)
-  {
-    return FALSE;
-  }
-
-  closedir(dirHandle);
-  return TRUE;
+	fclose(fp);
+	return true;
 }
 
-LIGHT_BOOL light_isWritable(char const * filename)
+/* Prints a notice about a value which was below `x` and was adjusted to it */
+unsigned long light_log_clamp_min(unsigned long min)
 {
-  FILE* fileHandle = fopen(filename, "r+");
-
-  if(!fileHandle)
-  {
-    LIGHT_PERMWARN("writing");
-    return FALSE;
-  }
-
-  fclose(fileHandle);
-  return TRUE;
+	LIGHT_NOTE("too small value, adjusting to mininum %lu (raw)", min);
+	return min;
 }
 
-LIGHT_BOOL light_isReadable(char const * filename)
+/* Prints a notice about a value which was above `x` and was adjusted to it */
+unsigned long light_log_clamp_max(unsigned long max)
 {
-  FILE* fileHandle = fopen(filename, "r");
-
-  if(!fileHandle)
-  {
-    LIGHT_PERMWARN("reading");
-    return FALSE;
-  }
-
-  fclose(fileHandle);
-  return TRUE;
+	LIGHT_NOTE("too large value, adjusting to mavalimum %lu (raw)", max);
+	return max;
 }
 
-unsigned long light_logInfClamp(unsigned long x)
+/* Clamps the `percent` value between 0% and 100% */
+double light_percent_clamp(double val)
 {
-  LIGHT_NOTE_FMT("specified value is inferior to %lu (raw), so adjusting it to this mininum value", x);
-  return x;
-}
+	if (val < 0.0) {
+		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 0%%", val);
+		return 0.0;
+	}
 
-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;
-}
+	if (val > 100.0) {
+		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 100%%", val);
+		return 100.0;
+	}
 
-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;
+	return val;
 }

src/helpers.h

@@ -1,96 +1,55 @@
 #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) ? (light_logInfClamp(y)) : ((x>z) ? (light_logSupClamp(z)) : x ))
+#include <stdbool.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_LOG_FMT_BUF_SIZE 1024
 /* Verbosity levels: 
  * 0 - No output
  * 1 - Errors
  * 2 - Errors, warnings 
- * 3 - Errors, warnings, notices */
-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 {
-  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);
-
-/* 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);
+ * 3 - Errors, warnings, notices
+ */
+typedef enum {
+	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, __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_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_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_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);
+
+double light_percent_clamp(double percent);
 
 #endif /* LIGHT_HELPERS_H */

src/light.h

@@ -4,6 +4,7 @@
 #include "config.h"
 #include "helpers.h"
 
+#include <stdbool.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <linux/limits.h>
@@ -11,128 +12,91 @@
 #define LIGHT_YEAR   "2012-2018"
 #define LIGHT_AUTHOR "Fredrik Haikarainen"
 
-#define ASSERT_SET(t,v)							\
+#define ASSERT_SET(t, v)						\
 	if (v) {							\
-		fprintf(stderr, t" arguments cannot be used in conjunction.\n"); \
-		return FALSE;						\
+		fprintf(stderr, t " cannot be used more than once.\n"); \
+		return false;						\
 	}								\
-	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_FIELD {
-  LIGHT_BRIGHTNESS = 0,
-  LIGHT_MAX_BRIGHTNESS,
-  LIGHT_MIN_CAP,
-  LIGHT_SAVERESTORE
-} LIGHT_FIELD;
-
-typedef enum LIGHT_TARGET {
-  LIGHT_BACKLIGHT = 0,
-  LIGHT_KEYBOARD
-} 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_LIST_CTRL,
-  LIGHT_RESTORE,
-  LIGHT_SAVE
-
-} 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[NAME_MAX + 1];
-
-  /* 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_FIELD    field;
-
-  /* Cache data */
-  LIGHT_BOOL      hasCachedMaxBrightness;
-  unsigned long   cachedMaxBrightness;
-
-} light_runtimeArguments, *light_runtimeArguments_p;
+	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 {
+	/* 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_runtimeArguments light_Configuration;
+light_ctx_t ctx;
 
-/* Sets default values for the configuration */
-void light_defaultConfig();
+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);
+bool light_ctrl_exist              (char const *controller);
 
-/* Parses the program arguments and sets the configuration accordingly (unsanitized) */
-LIGHT_BOOL light_parseArguments(int argc, char** argv);
+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);
 
-/* Prints a header if verbosity level > 0 */
-void light_printVersion(void);
+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);
 
-/* 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 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_getMaxBrightness(char const *controller, unsigned long *v);
-
-LIGHT_BOOL light_setBrightness(char const *controller, unsigned long v);
-
-LIGHT_BOOL light_controllerAccessible(char const *controller);
-
-/* 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);
-
-LIGHT_BOOL light_setMinCap(char const *controller, unsigned long v);
-
-LIGHT_BOOL light_listControllers();
-
-LIGHT_BOOL light_saveBrightness(char const *controller, unsigned long v);
-
-LIGHT_BOOL light_restoreBrightness(char const *controller);
+bool light_ctrl_save_brightness    (char const *controller, unsigned long val);
+bool light_ctrl_restore_brightness (char const *controller);
 
 #endif /* LIGHT_H_ */

src/main.c

@@ -6,21 +6,19 @@
 #define LIGHT_RETURNVAL_EXECFAIL  1
 #define LIGHT_RETURNVAL_SUCCESS   0
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
-  if(!light_initialize(argc, argv))
-  {
-    LIGHT_ERR("Initialization failed");
-    return LIGHT_RETURNVAL_INITFAIL;
-  }
+	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;
-  }
+	if (!light_execute()) {
+		LIGHT_ERR("Execution failed");
+		light_free();
+		return LIGHT_RETURNVAL_EXECFAIL;
+	}
 
-  light_free();
-  return LIGHT_RETURNVAL_SUCCESS;
+	light_free();
+	return LIGHT_RETURNVAL_SUCCESS;
 }