Merge 4a9b5f7357cc720acb86af7d5f03ba0d5bbd6111 into c5fb45423ec1ee1080e442e061ccfcdb98b32e4a

src/helpers.c

     char *tempdir = strdup(dir);
     light_mkpath(dirname(tempdir), mode);
     free(tempdir);
-    
+
     return mkdir(dir, mode);
 }
-

src/helpers.h

 double light_percent_clamp(double percent);
 
 int light_mkpath(char *dir, mode_t mode);
-

src/impl/razer.c

     impl_razer_data_t *target_data = malloc(sizeof(impl_razer_data_t));
     snprintf(target_data->brightness, sizeof(target_data->brightness), "/sys/bus/hid/drivers/razerkbd/%s/%s", device->name, filename);
     target_data->max_brightness = max_brightness;
-    
+
     // Only add targets that actually exist, as we aren't fully sure exactly what targets exist for a given device
     if(light_file_exists(target_data->brightness))
     {
 
     // Setup a target to backlight
     _impl_razer_add_target(new_device, "backlight", "matrix_brightness", 255);
-    
+
     // Setup targets to different possible leds
     _impl_razer_add_target(new_device, "game_led", "game_led_state", 1);
     _impl_razer_add_target(new_device, "macro_led", "macro_led_state", 1);
     // Iterate through the led controllers and create a device_target for each controller 
     DIR *razer_dir;
     struct dirent *curr_entry;
-    
+
     if((razer_dir = opendir("/sys/bus/hid/drivers/razerkbd/")) == NULL)
     {
         // Razer driver isnt properly installed, so we cant add devices in this enumerator 
         return true;
     }
-    
+
     while((curr_entry = readdir(razer_dir)) != NULL)
     {
         // Skip dot entries
         {
             continue;
         }
- 
+
         _impl_razer_add_device(enumerator, curr_entry->d_name);
     }
-    
+
     closedir(razer_dir);
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to write to razer device");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to read from razer device");
         return false;
     }
-    
+
     return true;
 }
 
     impl_razer_data_t *data = (impl_razer_data_t*)target->device_target_data;
 
     *out_value = data->max_brightness;
-    
+
     return true;
 }
 
     // To implement support, simply parse the command string to your liking, and return false on invalid input or results!
     return true;
 }
-
-

src/impl/sysfs.c

     // 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
         {
             continue;
         }
-        
+
         // Setup the target data 
         impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
         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);
-        
+
         // Create a new device target for the controller 
         light_create_device_target(leds_device, curr_entry->d_name, impl_sysfs_set, impl_sysfs_get, impl_sysfs_getmax, impl_sysfs_command, dev_data);
     }
-    
+
     closedir(leds_dir);
-    
+
     return true;
 }
 
     // 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
         {
             continue;
         }
-        
+
         // Setup the target data 
         impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
         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);
-        
+
         // Create a new device target for the controller 
         light_create_device_target(backlight_device, curr_entry->d_name, impl_sysfs_set, impl_sysfs_get, impl_sysfs_getmax, impl_sysfs_command, dev_data);
-        
+
         // 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))
             }
         }
     }
-    
+
     closedir(backlight_dir);
-    
+
     // If we found at least one usable controller, create an auto target mapped to that controller
     if(best_value > 0)
     {
         impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
         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);
-        
+
         // Create a new device target for the controller 
         light_create_device_target(backlight_device, "auto", impl_sysfs_set, impl_sysfs_get, impl_sysfs_getmax, impl_sysfs_command, dev_data);
     }
-    
+
     return true;
 }
 
 {
     // Create a device for the backlight 
     _impl_sysfs_init_backlight(enumerator);
-    
+
     // Create devices for the leds
     _impl_sysfs_init_leds(enumerator);
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to write to sysfs device");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to read from sysfs device");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to read from sysfs device");
         return false;
     }
-    
+
     return true;
 }
 
     // To implement support, simply parse the command string to your liking, and return false on invalid input or results!
     return true;
 }
-
-

src/impl/util.c

     LIGHT_NOTE("impl_util_dryrun_command: running custom command on utility target %s: \"%s\"", target->name, command_string);
     return true;
 }
-
-

src/light.c

 
 /* Static helper functions for this file only, prefix with _ */
 
-
 static void _light_add_enumerator_device(light_device_enumerator_t *enumerator, light_device_t *new_device)
 {
     // Create a new device array 
     uint64_t new_num_devices = enumerator->num_devices + 1;
     light_device_t **new_devices = malloc(new_num_devices * sizeof(light_device_t*));
-    
+
     // Copy old device array to new one
     for(uint64_t i = 0; i < enumerator->num_devices; i++)
     {
         new_devices[i] = enumerator->devices[i];
     }
-    
+
     // Set the new device
     new_devices[enumerator->num_devices] = new_device;
-    
+
     // Free the old devices array, if needed
     if(enumerator->devices != NULL)
     {
         free(enumerator->devices);
     }
-    
+
     // Replace the devices array with the new one
     enumerator->devices = new_devices;
     enumerator->num_devices = new_num_devices;
     // Create a new targets array 
     uint64_t new_num_targets = device->num_targets + 1;
     light_device_target_t **new_targets = malloc(new_num_targets * sizeof(light_device_target_t*));
-    
+
     // Copy old targets array to new one
     for(uint64_t i = 0; i < device->num_targets; i++)
     {
         new_targets[i] = device->targets[i];
     }
-    
+
     // Set the new target
     new_targets[device->num_targets] = new_target;
-    
+
     // Free the old targets array, if needed
     if(device->targets != NULL)
     {
         free(device->targets);
     }
-    
+
     // Replace the targets array with the new one
     device->targets= new_targets;
     device->num_targets = new_num_targets;
     {
         return 0;
     }
-    
+
     return minimum_value;
 }
 
             return ctx->enumerators[e];
         }
     }
-    
+
     return NULL;
 }
 
             return en->devices[d];
         }
     }
-    
+
     return NULL;
 }
 
             return dev->targets[t];
         }
     }
-    
+
     return NULL;
 }
 
 static bool _light_raw_to_percent(light_device_target_t *target, uint64_t inraw, double *outpercent)
 {
-        double inraw_d = (double)inraw;
-        uint64_t max_value = 0;
-        if(!target->get_max_value(target, &max_value))
-        {
-            LIGHT_ERR("couldn't read from target");
-            return false;
-        }
-        double max_value_d = (double)max_value;
-        double percent = light_percent_clamp((inraw_d / max_value_d) * 100.0);
-        *outpercent = percent;
-        
-        return true;
+    double inraw_d = (double)inraw;
+    uint64_t max_value = 0;
+    if(!target->get_max_value(target, &max_value))
+    {
+        LIGHT_ERR("couldn't read from target");
+        return false;
+    }
+    double max_value_d = (double)max_value;
+    double percent = light_percent_clamp((inraw_d / max_value_d) * 100.0);
+    *outpercent = percent;
+
+    return true;
 }
 
 static bool _light_percent_to_raw(light_device_target_t *target, double inpercent, uint64_t *outraw)
     double target_value_d = max_value_d * (light_percent_clamp(inpercent) / 100.0);
     uint64_t target_value = LIGHT_CLAMP((uint64_t)target_value_d, 0, max_value);
     *outraw = target_value;
-    
+
     return true;
 }
 
         LIGHT_WARN("a command was already set. ignoring.");
         return false;
     }
-    
+
     ctx->run_params.command = new_cmd;
     return true;
 }
 {
     int32_t curr_arg = -1;
     int32_t log_level = 0;
-    
+
     char ctrl_name[NAME_MAX];
     bool need_value = false;
     bool need_float_value = false;
     bool need_target = true; // default cmd is get brightness
     bool specified_target = false;
     snprintf(ctrl_name, sizeof(ctrl_name), "%s", "sysfs/backlight/auto");
-    
+
     while((curr_arg = getopt(argc, argv, "HhVGSLMNPAUTOIv:s:r")) != -1)
     {
         switch(curr_arg)
         {
             // Options
-            
+
             case 'v':
                 if(sscanf(optarg, "%i", &log_level) != 1)
                 {
                     _light_print_usage();
                     return false;
                 }
-                
+
                 if(log_level < 0 || log_level > 3)
                 {
                     fprintf(stderr, "-v argument must be between 0 and 3.\n\n");
                     _light_print_usage();
                     return false;
                 }
-                
+
                 light_loglevel = (light_loglevel_t)log_level;
                 break;
             case 's':
             case 'r':
                 ctx->run_params.raw_mode = true;
                 break;
-            
+
             // Commands
             case 'H':
             case 'h':
     {
         _light_set_context_command(ctx, light_cmd_get_brightness);
     }
-    
+
     if(need_target)
     {
         light_device_target_t *curr_target = light_find_device_target(ctx, ctrl_name);
                 curr_target = light_find_device_target(ctx, "util/test/dryrun");
             }
         }
-        
+
         ctx->run_params.device_target = curr_target;
     }
 
                 _light_print_usage();
                 return false;
             }
-            
+
             percent_value = light_percent_clamp(percent_value);
             
             uint64_t raw_value = 0;
                 LIGHT_ERR("failed to convert from percent to raw for device target");
                 return false;
             }
-            
+
             ctx->run_params.value = raw_value;
         }
     }
     }
 
     return true;
-    
 }
 
 
-
-
 /* API function definitions */
 
 light_context_t* light_initialize(int argc, char **argv)
     else
     {
         char *xdg_conf = getenv("XDG_CONFIG_HOME");
-        
         if(xdg_conf != NULL)
         {
             snprintf(new_ctx->sys_params.conf_dir, sizeof(new_ctx->sys_params.conf_dir), "%s/light", xdg_conf);
             snprintf(new_ctx->sys_params.conf_dir, sizeof(new_ctx->sys_params.conf_dir), "%s/.config/light", getenv("HOME"));
         }
     }
-    
+
     // Make sure the configuration folder exists, otherwise attempt to create it
     int32_t rc = light_mkpath(new_ctx->sys_params.conf_dir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
     if(rc && errno != EEXIST)
         LIGHT_WARN("couldn't create configuration directory");
         return false;
     }
-    
+
     // Create the built-in enumerators
     light_create_enumerator(new_ctx, "sysfs", &impl_sysfs_init, &impl_sysfs_free);
     light_create_enumerator(new_ctx, "util", &impl_util_init, &impl_util_free);
         LIGHT_ERR("failed to parse arguments");
         return NULL;
     }
-    
+
     return new_ctx;
 }
 
         LIGHT_ERR("run parameters command was null, can't execute");
         return false;
     }
-    
+
     return ctx->run_params.command(ctx);
 }
 
     {
         LIGHT_WARN("failed to free all enumerators");
     }
-    
+
     free(ctx);
 }
 
     // Create a new enumerator array 
     uint64_t new_num_enumerators = ctx->num_enumerators + 1;
     light_device_enumerator_t **new_enumerators = malloc(new_num_enumerators * sizeof(light_device_enumerator_t*));
-    
+
     // Copy old enumerator array to new one
     for(uint64_t i = 0; i < ctx->num_enumerators; i++)
     {
         new_enumerators[i] = ctx->enumerators[i];
     }
-    
+
     // Allocate the new enumerator
     new_enumerators[ctx->num_enumerators] = malloc(sizeof(light_device_enumerator_t));
     light_device_enumerator_t *returner = new_enumerators[ctx->num_enumerators];
-    
+
     returner->devices = NULL;
     returner->num_devices = 0;
     returner->init = init_func;
     returner->free = free_func;
     snprintf(returner->name, sizeof(returner->name), "%s", name);
-    
+
     // Free the old enumerator array, if needed
     if(ctx->enumerators != NULL)
     {
         free(ctx->enumerators);
     }
-    
+
     // Replace the enumerator array with the new one
     ctx->enumerators = new_enumerators;
     ctx->num_enumerators = new_num_enumerators;
             success = false;
         }
     }
-    
+
     return success;
 }
 
     for(uint64_t i = 0; i < ctx->num_enumerators; i++)
     {
         light_device_enumerator_t * curr_enumerator = ctx->enumerators[i];
-        
         if(!curr_enumerator->free(curr_enumerator))
         {
             success = false;
         }
-        
+
         if(curr_enumerator->devices != NULL)
         {
             for(uint64_t d = 0; d < curr_enumerator->num_devices; d++)
             {
                 light_delete_device(curr_enumerator->devices[d]);
             }
-            
+
             free(curr_enumerator->devices);
             curr_enumerator->devices = NULL;
         }
-        
+
         free(curr_enumerator);
     }
-    
+
     free(ctx->enumerators);
     ctx->enumerators = NULL;
     ctx->num_enumerators = 0;
-    
+
     return success;
 }
 
         LIGHT_WARN("invalid path passed to split_target_path");
         return false;
     }
-    
+
     size_t size = end - begin;
     strncpy(out_path->enumerator, begin, size);
     out_path->enumerator[size] = '\0';
-    
+
     begin = end + 1;
     end = strstr(begin, "/");
     if(end == NULL)
         LIGHT_WARN("invalid path passed to split_target_path");
         return false;
     }
-    
+
     size = end - begin;
     strncpy(out_path->device, begin, size);
     out_path->device[size] = '\0';
-    
+
     strcpy(out_path->target, end + 1);
-    
+
     return true;
 }
 
         LIGHT_WARN("light_find_device_target needs a path in the format of \"enumerator/device/target\", the following format is not recognized:  \"%s\"", name);
         return NULL;
     }
-    
+
     /*
     Uncomment to debug the split function
     printf("enumerator: %s %u\ndevice: %s %u\ntarget: %s %u\n",
             new_path.device, strlen(new_path.device),
             new_path.target, strlen(new_path.target));
     */
-    
+
     // find a matching enumerator 
-    
+
     light_device_enumerator_t *enumerator = _light_find_enumerator(ctx, new_path.enumerator);
     if(enumerator == NULL)
     {
         LIGHT_WARN("no such enumerator, \"%s\"", new_path.enumerator);
         return NULL;
     }
-    
+
     light_device_t *device = _light_find_device(enumerator, new_path.device);
     if(device == NULL)
     {
         LIGHT_WARN("no such device, \"%s\"", new_path.device);
         return NULL;
     }
-    
+
     light_device_target_t *target = _light_find_target(device, new_path.target);
     if(target == NULL)
     {
         LIGHT_WARN("no such target, \"%s\"", new_path.target);
         return NULL;
     }
-    
+
     return target;
 }
 
             for(uint64_t target = 0; target < curr_device->num_targets; target++)
             {
                 light_device_target_t *curr_target = curr_device->targets[target];
-                
                 printf("\t%s/%s/%s\n", curr_enumerator->name, curr_device->name, curr_target->name);
             }
         }
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
-    
+
     uint64_t mincap = _light_get_min_cap(ctx);
     uint64_t value = ctx->run_params.value;
     if(mincap > value)
     {
         value = mincap;
     }
-    
+
     if(!target->set_value(target, value))
     {
         LIGHT_ERR("failed to write to target");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     uint64_t value = 0;
     if(!target->get_value(target, &value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     if(ctx->run_params.raw_mode)
     {
         printf("%" PRIu64 "\n", value);
         }
         printf("%.2f\n", percent);
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     if(!ctx->run_params.raw_mode)
     {
         printf("100.0\n");
         return true;
     }
-    
+
     uint64_t max_value = 0;
     if(!target->get_max_value(target, &max_value))
     {
         LIGHT_ERR("failed to read from device target");
         return false;
     }
-    
+
     printf("%" PRIu64 "\n", max_value);
     return true;
 }
 {
     char target_path[NAME_MAX];
     _light_get_target_path(ctx, target_path, sizeof(target_path));
-    
+
     // Make sure the target folder exists, otherwise attempt to create it
     int32_t rc = light_mkpath(target_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
     if(rc && errno != EEXIST)
         LIGHT_ERR("couldn't create target directory for minimum brightness");
         return false;
     }
-    
+
     char target_filepath[NAME_MAX];
     _light_get_target_file(ctx, target_filepath, sizeof(target_filepath), "minimum");
-    
+
     if(!light_file_write_uint64(target_filepath, ctx->run_params.value))
     {
         LIGHT_ERR("couldn't write value to minimum file");
         return false;
     }
-    
+
     return true;
 }
 
 
         return true;
     }
-    
+
     if(ctx->run_params.raw_mode)
     {
         printf("%" PRIu64 "\n", minimum_value);
             LIGHT_ERR("failed to convert value from raw to percent for device target");
             return false;
         }
-        
+
         printf("%.2f\n", minimum_d);
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     uint64_t value = 0;
     if(!target->get_value(target, &value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     uint64_t max_value = 0;
     if(!target->get_max_value(target, &max_value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     value += ctx->run_params.value;
-    
     uint64_t mincap = _light_get_min_cap(ctx);
     if(mincap > value)
     {
         value = mincap;
     }
-    
-    
+
     if(value > max_value)
     {
         value = max_value;
     }
-    
+
     if(!target->set_value(target, value))
     {
         LIGHT_ERR("failed to write to target");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     uint64_t value = 0;
     if(!target->get_value(target, &value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     if(value > ctx->run_params.value)
     {
         value -= ctx->run_params.value;
     {
         value = 0;
     }
-    
+
     uint64_t mincap = _light_get_min_cap(ctx);
     if(mincap > value)
     {
         LIGHT_ERR("failed to write to target");
         return false;
     }
-    
+
     return true;
 }
 
 
     uint64_t old_value = value;
     value *= ctx->run_params.float_value;
- 
+
     // Check that we actually de/increase value
     if(value == old_value)
     {
 {
     char target_path[NAME_MAX];
     _light_get_target_path(ctx, target_path, sizeof(target_path));
-    
+
     // Make sure the target folder exists, otherwise attempt to create it
     int32_t rc = light_mkpath(target_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
     if(rc && errno != EEXIST)
         LIGHT_ERR("couldn't create target directory for save brightness");
         return false;
     }
-    
+
     char target_filepath[NAME_MAX];
     _light_get_target_file(ctx, target_filepath, sizeof(target_filepath), "save");
 
         LIGHT_ERR("couldn't read from device target");
         return false;
     }
-    
+
     if(!light_file_write_uint64(target_filepath, curr_value))
     {
         LIGHT_ERR("couldn't write value to savefile");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("couldn't read value from savefile");
         return false;
     }
-    
+
     uint64_t mincap = _light_get_min_cap(ctx);
     if(mincap > saved_value)
     {
         saved_value = mincap;
     }
-    
+
     if(!ctx->run_params.device_target->set_value(ctx->run_params.device_target, saved_value))
     {
         LIGHT_ERR("couldn't write saved value to device target");
         return false;
     }
-    
+
     return true;
 }
 
     new_device->targets = NULL;
     new_device->num_targets = 0;
     new_device->device_data = device_data;
-    
+
     snprintf(new_device->name, sizeof(new_device->name), "%s", name);
-    
+
     _light_add_enumerator_device(enumerator, new_device);
-    
+
     return new_device;
 }
 
     {
         light_delete_device_target(device->targets[i]);
     }
-    
+
     if(device->targets != NULL)
     {
         free(device->targets);
     }
-    
+
     if(device->device_data != NULL)
     {
         free(device->device_data);
     }
-    
+
     free(device);
 }
 
-light_device_target_t *light_create_device_target(light_device_t *device, char const *name, LFUNCVALSET setfunc, LFUNCVALGET getfunc, LFUNCMAXVALGET getmaxfunc, LFUNCCUSTOMCMD cmdfunc, void *target_data)
+light_device_target_t *light_create_device_target(light_device_t *device,
+                                                    char const *name,
+                                                    LFUNCVALSET setfunc,
+                                                    LFUNCVALGET getfunc,
+                                                    LFUNCMAXVALGET getmaxfunc,
+                                                    LFUNCCUSTOMCMD cmdfunc,
+                                                    void *target_data)
 {
     light_device_target_t *new_target = malloc(sizeof(light_device_target_t));
     new_target->device = device;
     new_target->get_max_value = getmaxfunc;
     new_target->custom_command = cmdfunc;
     new_target->device_target_data = target_data;
-    
+
     snprintf(new_target->name, sizeof(new_target->name), "%s", name);
-    
+
     _light_add_device_target(device, new_target);
-    
+
     return new_target;
 }
 
     {
         free(device_target->device_target_data);
     }
-    
+
     free(device_target);
 }

src/light.h

 
 #include "config.h"
 
-#define LIGHT_YEAR   "2012 - 2018"
+#define LIGHT_YEAR   "2012 - 2022"
 #define LIGHT_AUTHOR "Fredrik Haikarainen"
 
 struct _light_device_target_t;
 /* 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;
+    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*);
 
     {
         char                    conf_dir[NAME_MAX]; // The path to the application cache directory 
     } sys_params;
-    
+
     light_device_enumerator_t   **enumerators;
     uint64_t                    num_enumerators;
 };
 
 /* 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);
-