Fixes #18. Seems ready for v1.4.0

README.md

@@ -3,8 +3,7 @@ Fan-Control-Daemon
 
 Introduction
 ---------------------
-This is an enhanced version of [rvega's Fan-Control-Daemon](https://github.com/rvega/Fan-Control-Daemon),
-which itself is an enhanced version of [Allan McRae mbpfan](http://allanmcrae.com/2010/05/simple-macbook-pro-fan-daemon/)
+This is an enhanced version of [Allan McRae mbpfan](http://allanmcrae.com/2010/05/simple-macbook-pro-fan-daemon/)
 
 Fan-Control-Daemon is a daemon that uses input from coretemp module and sets the fan speed using the applesmc module. 
 This enhanced version assumes any number of processors and fans (max. 10).
@@ -50,10 +49,6 @@ Compile with
 
     make
 
-Manually compile with
-
-    gcc -o bin/mbpfan src/mbpfan.c -lm
-
 
 Install Instructions
 --------------------

mbpfan.rc-not-maintained → mbpfan.rc.archlinux-notmaintained

 #!/bin/bash
-
-# not maintained in this proejct
+# Archlinux rc script
+# not maintained in this project
+# please, fix it and contribute back to the project
 
 daemon_name=mbpfan
 

src/daemon.c

@@ -34,10 +34,12 @@ int write_pid(int pid)
 {
     FILE *file = NULL;
     file = fopen(program_pid, "w");
+
     if(file != NULL) {
         fprintf(file, "%d", pid);
         fclose(file);
         return 1;
+
     } else {
         return 0;
     }
@@ -48,11 +50,13 @@ int read_pid()
     FILE *file = NULL;
     int pid = -1;
     file = fopen(program_pid, "r");
+
     if(file != NULL) {
         fscanf(file, "%d", &pid);
         fclose(file);
         return pid;
     }
+
     return -1;
 }
 
@@ -103,6 +107,7 @@ void go_daemon(void (*fan_control)())
     if(verbose) {
         setlogmask(LOG_UPTO(LOG_DEBUG));
         openlog(program_name, LOG_CONS | LOG_NDELAY | LOG_PERROR | LOG_PID, LOG_USER);
+
     } else {
         setlogmask(LOG_UPTO(LOG_INFO));
         openlog(program_name, LOG_CONS, LOG_USER);
@@ -115,9 +120,11 @@ void go_daemon(void (*fan_control)())
     if (daemonize) {
 
         pid_slave = fork();
+
         if (pid_slave < 0) {
             exit(EXIT_FAILURE);
         }
+
         if (pid_slave > 0) {
             // kill the father
             exit(EXIT_SUCCESS);
@@ -127,6 +134,7 @@ void go_daemon(void (*fan_control)())
 
         // new sid_slave for the child process
         sid_slave = setsid();
+
         if (sid_slave < 0) {
             exit(EXIT_FAILURE);
         }
@@ -151,23 +159,30 @@ void go_daemon(void (*fan_control)())
             printf("Writing a new .pid file with value %d at: %s\n", current_pid, program_pid);
             syslog(LOG_INFO, "Writing a new .pid file with value %d at: %s", current_pid, program_pid);
         }
+
         if (write_pid(current_pid) == 0) {
             syslog(LOG_ERR, "Can not create a .pid file at: %s. Aborting", program_pid);
+
             if (verbose) {
                 printf("ERROR: Can not create a .pid file at: %s. Aborting\n", program_pid);
             }
+
             exit(EXIT_FAILURE);
+
         } else {
             if (verbose) {
                 printf("Successfully written a new .pid file with value %d at: %s\n", current_pid, program_pid);
                 syslog(LOG_INFO, "Successfully written a new .pid file with value %d at: %s", current_pid, program_pid);
             }
         }
+
     } else {
         syslog(LOG_ERR, "A previously created .pid file exists at: %s. Aborting", program_pid);
+
         if (verbose) {
             printf("ERROR: a previously created .pid file exists at: %s.\n Aborting\n", program_pid);
         }
+
         exit(EXIT_FAILURE);
     }
 

src/daemon.h

@@ -13,6 +13,8 @@
  *
  */
 
+#ifndef _DAEMON_H_
+#define _DAEMON_H_
 
 /**
  * Write the PID of the forked daemon to the
@@ -48,3 +50,5 @@ void signal_handler(int signal);
  * Daemonizes
  */
 int go_daemon(void (*function)());
+
+#endif
\ No newline at end of file

src/global.h

+#ifndef _GLOBAL_H_
+#define _GLOBAL_H_
+
 extern int daemonize;
 extern int verbose;
 
 extern const char* program_name;
 extern const char* program_pid;
+
+struct s_sensors {
+    char* path;
+    char* fan_output_path;
+    char* fan_manual_path;
+    unsigned int temperature;
+    struct s_sensors *next;
+};
+
+typedef s_sensors t_sensors;
+#endif
\ No newline at end of file

src/main.c

@@ -13,6 +13,10 @@
  *
  */
 
+/**
+ * Code formatted with astyle -A3 -s --break-blocks=all --add-brackets *.c *.h
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -46,6 +50,7 @@ int main(int argc, char *argv[])
 {
 
     int c;
+
     while( (c = getopt(argc, argv, "hftv|help")) != -1) {
         switch(c) {
         case 'h':

src/mbpfan.c

@@ -57,7 +57,7 @@ int max_temp = 86;   // do not set it > 90
 
 int polling_interval = 7;
 
-
+/*
 struct s_sensors {
     char* path;
     char* fan_output_path;
@@ -65,6 +65,9 @@ struct s_sensors {
     unsigned int temperature;
     struct s_sensors *next;
 };
+ */
+
+typedef struct s_sensors t_sensors;
 
 
 t_sensors *retrieve_sensors()
@@ -82,6 +85,7 @@ t_sensors *retrieve_sensors()
     sprintf(number,"%d",0);
 
     int i = 0;
+
     for(i = 0; i<10; i++) {
         path = (char*) malloc(sizeof( char ) * path_size);
 
@@ -98,24 +102,33 @@ t_sensors *retrieve_sensors()
             s->path = (char *) malloc(sizeof( char ) * path_size);
             strcpy(s->path, path);
             fscanf(file, "%d", &s->temperature);
+
             if (sensors_head == NULL) {
                 sensors_head = s;
                 sensors_head->next = NULL;
+
             } else {
                 t_sensors *tmp = sensors_head;
+
                 while (tmp->next != NULL) {
                     tmp = tmp->next;
                 }
+
                 tmp->next = s;
                 tmp->next->next = NULL;
             }
+
             fclose(file);
         }
+
         free(path);
         path = NULL;
     }
-    if(sensors_head != NULL)
+
+    if(sensors_head != NULL) {
         find_fans(sensors_head);
+    }
+
     return sensors_head;
 }
 
@@ -162,6 +175,7 @@ void find_fans(t_sensors* sensors)
                 tmp->fan_output_path = (char *) malloc(sizeof( char ) * path_min_size);
                 tmp->fan_manual_path = (char *) malloc(sizeof( char ) * path_man_size);
             }
+
             strcpy(tmp->fan_output_path, path_output);
             strcpy(tmp->fan_manual_path, path_manual);
             tmp = tmp->next;
@@ -173,6 +187,7 @@ void find_fans(t_sensors* sensors)
 
     if(verbose) {
         printf("Found %d sensors and %d fans\n", n_sensors, n_fans);
+
         if(daemonize) {
             syslog(LOG_INFO, "Found %d sensors and %d fans", n_sensors, n_fans);
         }
@@ -189,12 +204,15 @@ void set_fans_man(t_sensors *sensors)
 
     t_sensors *tmp = sensors;
     FILE *file;
+
     while(tmp != NULL) {
         file = fopen(tmp->fan_manual_path, "rw+");
+
         if(file != NULL) {
             fprintf(file, "%d", 1);
             fclose(file);
         }
+
         tmp = tmp->next;
     }
 }
@@ -214,6 +232,7 @@ t_sensors *refresh_sensors(t_sensors *sensors)
 
         tmp = tmp->next;
     }
+
     return sensors;
 }
 
@@ -223,8 +242,10 @@ void set_fan_speed(t_sensors* sensors, int speed)
 {
     t_sensors *tmp = sensors;
     FILE *file;
+
     while(tmp != NULL) {
         file = fopen(tmp->fan_output_path, "rw+");
+
         if(file != NULL) {
             fprintf(file, "%d", speed);
             fclose(file);
@@ -243,10 +264,12 @@ unsigned short get_temp(t_sensors* sensors)
     unsigned short temp = 0;
 
     t_sensors* tmp = sensors;
+
     while(tmp != NULL) {
         sum_temp += tmp->temperature;
         tmp = tmp->next;
     }
+
     temp = (unsigned short)( ceil( (float)( sum_temp ) / 2000. ) );
     return temp;
 }
@@ -262,35 +285,63 @@ void retrieve_settings()
         /* Could not open configfile */
         if(verbose) {
             printf("Couldn't open configfile, using defaults\n");
+
             if(daemonize) {
                 syslog(LOG_INFO, "Couldn't open configfile, using defaults");
             }
         }
+
     } else {
         settings = settings_open(f);
         fclose(f);
+
         if (settings == NULL) {
             /* Could not read configfile */
             if(verbose) {
                 printf("Couldn't read configfile\n");
+
                 if(daemonize) {
                     syslog(LOG_INFO, "Couldn't read configfile");
                 }
             }
+
         } else {
             /* Read configfile values */
             result = settings_get_int(settings, "general", "min_fan_speed");
-            if (result != 0) min_fan_speed = result;
+
+            if (result != 0) {
+                min_fan_speed = result;
+            }
+
             result = settings_get_int(settings, "general", "max_fan_speed");
-            if (result != 0) max_fan_speed = result;
+
+            if (result != 0) {
+                max_fan_speed = result;
+            }
+
             result = settings_get_int(settings, "general", "low_temp");
-            if (result != 0) low_temp = result;
+
+            if (result != 0) {
+                low_temp = result;
+            }
+
             result = settings_get_int(settings, "general", "high_temp");
-            if (result != 0) high_temp = result;
+
+            if (result != 0) {
+                high_temp = result;
+            }
+
             result = settings_get_int(settings, "general", "max_temp");
-            if (result != 0) max_temp = result;
+
+            if (result != 0) {
+                max_temp = result;
+            }
+
             result = settings_get_int(settings, "general", "polling_interval");
-            if (result != 0) polling_interval = result;
+
+            if (result != 0) {
+                polling_interval = result;
+            }
 
             /* Destroy the settings object */
             settings_delete(settings);
@@ -316,10 +367,12 @@ void mbpfan()
 
     if(verbose) {
         printf("Sleeping for %d seconds\n", polling_interval);
+
         if(daemonize) {
             syslog(LOG_INFO, "Sleeping for %d seconds", polling_interval);
         }
     }
+
     sleep(polling_interval);
 
     step_up = (float)( max_fan_speed - min_fan_speed ) /
@@ -354,6 +407,7 @@ void mbpfan()
 
         if(verbose) {
             printf("Old Temp %d: New Temp: %d, Fan Speed: %d\n", old_temp, new_temp, fan_speed);
+
             if(daemonize) {
                 syslog(LOG_INFO, "Old Temp %d: New Temp: %d, Fan Speed: %d", old_temp, new_temp, fan_speed);
             }
@@ -363,10 +417,12 @@ void mbpfan()
 
         if(verbose) {
             printf("Sleeping for %d seconds\n", polling_interval);
+
             if(daemonize) {
                 syslog(LOG_INFO, "Sleeping for %d seconds", polling_interval);
             }
         }
+
         sleep(polling_interval);
     }
 }

src/mbpfan.h

@@ -14,6 +14,9 @@
  *
  */
 
+#ifndef _MBPFAN_H_
+#define _MBPFAN_H_
+
 /** Basic fan speed parameters
  */
 extern int min_fan_speed;
@@ -83,3 +86,5 @@ unsigned short get_temp(t_sensors* sensors);
  * Main Program
  */
 void mbpfan();
+
+#endif
\ No newline at end of file

src/minunit.c

@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <time.h>
 #include <limits.h>
+#include "global.h"
 #include "mbpfan.h"
 #include "settings.h"
 #include "minunit.h"
@@ -10,32 +11,41 @@
 int tests_run = 0;
 
 
-static char *test_sensor_paths()
+static const char *test_sensor_paths()
 {
     t_sensors* sensors = retrieve_sensors();
     mu_assert("No sensors found", sensors != NULL);
     t_sensors* tmp = sensors;
+
     while(tmp != NULL) {
         mu_assert("Sensor does not have a valid path", tmp->path != NULL);
-        if(tmp->path != NULL)
+
+        if(tmp->path != NULL) {
             mu_assert("Sensor does not have valid temperature", tmp->temperature > 0);
+        }
+
         tmp = tmp->next;
     }
+
     return 0;
 }
 
 
-static char *test_fan_paths()
+static const char *test_fan_paths()
 {
     t_sensors* sensors = retrieve_sensors();
     mu_assert("No sensors found", sensors != NULL);
     t_sensors* tmp = sensors;
     int found_fan_path = 0;
+
     while(tmp != NULL) {
-        if(tmp->fan_output_path != NULL)
+        if(tmp->fan_output_path != NULL) {
             found_fan_path++;
+        }
+
         tmp = tmp->next;
     }
+
     mu_assert("No fans found", found_fan_path != 0);
     return 0;
 }
@@ -46,8 +56,11 @@ unsigned time_seed()
     unsigned char *p = (unsigned char *)&now;
     unsigned seed = 0;
     size_t i;
-    for ( i = 0; i < sizeof now; i++ )
+
+    for ( i = 0; i < sizeof now; i++ ) {
         seed = seed * ( UCHAR_MAX + 2U ) + p[i];
+    }
+
     return seed;
 }
 
@@ -56,17 +69,19 @@ unsigned time_seed()
 int stress(int n)
 {
     int f = n;
+
     while (f > 0) {
         while(n > 0) {
             srand ( time_seed() );
             n--;
         }
+
         f--;
         n = f;
     }
 }
 
-static char *test_get_temp()
+static const char *test_get_temp()
 {
     t_sensors* sensors = retrieve_sensors();
     mu_assert("No sensors found", sensors != NULL);
@@ -78,21 +93,24 @@ static char *test_get_temp()
     return 0;
 }
 
-static char *test_config_file()
+static const char *test_config_file()
 {
     FILE *f = NULL;
     Settings *settings = NULL;
     f = fopen("/etc/mbpfan.conf", "r");
     mu_assert("No config file found", f != NULL);
 
-    if (f == NULL)
+    if (f == NULL) {
         return 0;
+    }
 
     settings = settings_open(f);
     fclose(f);
     mu_assert("Could not read settings from config file", settings != NULL);
-    if (settings == NULL)
+
+    if (settings == NULL) {
         return 0;
+    }
 
     mu_assert("Could not read min_fan_speed from config file",settings_get_int(settings, "general", "min_fan_speed") != 0);
     mu_assert("Could not read max_fan_speed from config file",settings_get_int(settings, "general", "max_fan_speed") != 0);
@@ -107,7 +125,7 @@ static char *test_config_file()
 }
 
 
-static char *all_tests()
+static const char *all_tests()
 {
     mu_run_test(test_sensor_paths);
     mu_run_test(test_fan_paths);
@@ -120,12 +138,15 @@ int tests()
 {
     printf("Starting the tests..\n");
     printf("It is normal for them to take a bit to finish.\n");
-    char *result = all_tests();
+    const char *result = all_tests();
+
     if (result != 0) {
         printf("%s \n", result);
+
     } else {
         printf("ALL TESTS PASSED\n");
     }
+
     printf("Tests run: %d\n", tests_run);
 
     return result != 0;

src/minunit.h

 /**
  * This is the MinUnit testing framework - http://www.jera.com/techinfo/jtns/jtn002.html
  */
-#define mu_assert(message, test) do { if (!(test)) return message; } while (0)
-#define mu_run_test(test) do { char *message = test(); tests_run++; \
-                                if (message) return message; } while (0)
 
-struct s_sensors {
-    char* path;
-    char* fan_output_path;
-    char* fan_manual_path;
-    unsigned int temperature;
-    struct s_sensors *next;
-};
-typedef s_sensors t_sensors;
+#ifndef _MINUNIT_H_
+#define _MINUNIT_H_
 
+#define mu_assert(message, test) do { if (!(test)) return message; } while (0)
+#define mu_run_test(test) do { const char *message = test(); tests_run++; \
+                                if (message) return message; } while (0)
 
 extern int tests_run;
 
-static char *test_sensor_paths();
-static char *test_fan_paths();
-static char *test_get_temp();
-static char *test_config_file();
+static const char *test_sensor_paths();
+static const char *test_fan_paths();
+static const char *test_get_temp();
+static const char *test_config_file();
 
-static char *all_tests();
+static const char *all_tests();
 
 int tests();
+
+#endif
\ No newline at end of file

src/settings.c

@@ -97,9 +97,11 @@ Settings * settings_new()
     Settings *settings;
 
     settings = (Settings*)malloc(sizeof(Settings));
+
     if (settings == NULL) {
         return NULL;
     }
+
     settings->section_count = 0;
     settings->sections = NULL;
     return settings;
@@ -113,17 +115,22 @@ void settings_delete(Settings *settings)
     if (settings == NULL) {
         return;
     }
+
     section = settings->sections;
     n = settings->section_count;
     i = 0;
+
     while (i < n) {
         sm_delete(section->map);
+
         if (section->name != NULL) {
             free(section->name);
         }
+
         section++;
         i++;
     }
+
     free(settings->sections);
     free(settings);
 }
@@ -139,20 +146,26 @@ Settings * settings_open(FILE *stream)
     if (stream == NULL) {
         return NULL;
     }
+
     settings = settings_new();
+
     if (settings == NULL) {
         return NULL;
     }
+
     parse_state.current_section = section_buf;
     parse_state.current_section_n = sizeof(section_buf);
     parse_state.has_section = 0;
     trim_str("", trimmed_buf);
+
     while (fgets(buf, MAX_LINECHARS, stream) != NULL) {
         trim_str(buf, trimmed_buf);
+
         if (!parse_str(settings, trimmed_buf, &parse_state)) {
             return NULL;
         }
     }
+
     return settings;
 }
 
@@ -165,12 +178,15 @@ int settings_save(const Settings *settings, FILE *stream)
     if (settings == NULL) {
         return 0;
     }
+
     if (stream == NULL) {
         return 0;
     }
+
     section = settings->sections;
     n = settings->section_count;
     i = 0;
+
     while (i < n) {
         sprintf(buf, "[%s]\n", section->name);
         fputs(buf, stream);
@@ -179,6 +195,7 @@ int settings_save(const Settings *settings, FILE *stream)
         i++;
         fputs("\n", stream);
     }
+
     return 0;
 }
 
@@ -189,10 +206,13 @@ int settings_get(const Settings *settings, const char *section, const char *key,
     if (settings == NULL) {
         return 0;
     }
+
     s = get_section(settings->sections, settings->section_count, section);
+
     if (s == NULL) {
         return 0;
     }
+
     return sm_get(s->map, key, out_buf, n_out_buf);
 }
 
@@ -203,6 +223,7 @@ int settings_get_int(const Settings *settings, const char *section, const char *
     if (get_converted_value(settings, section, key, CONVERT_MODE_INT, &i)) {
         return i;
     }
+
     return 0;
 }
 
@@ -213,6 +234,7 @@ long settings_get_long(const Settings *settings, const char *section, const char
     if (get_converted_value(settings, section, key, CONVERT_MODE_LONG, &l)) {
         return l;
     }
+
     return 0;
 }
 
@@ -223,6 +245,7 @@ double settings_get_double(const Settings *settings, const char *section, const
     if (get_converted_value(settings, section, key, CONVERT_MODE_DOUBLE, &d)) {
         return d;
     }
+
     return 0;
 }
 
@@ -248,36 +271,47 @@ int settings_set(Settings *settings, const char *section, const char *key, const
     if (settings == NULL) {
         return 0;
     }
+
     if (section == NULL || key == NULL || value == NULL) {
         return 0;
     }
+
     if (strlen(section) == 0) {
         return 0;
     }
+
     /* Get a pointer to the section */
     s = get_section(settings->sections, settings->section_count, section);
+
     if (s == NULL) {
         /* The section is not created---create it */
         s = (Section*)realloc(settings->sections, (settings->section_count + 1) * sizeof(Section));
+
         if (s == NULL) {
             return 0;
         }
+
         settings->sections = s;
         settings->section_count++;
         s = &(settings->sections[settings->section_count - 1]);
         s->map = sm_new(DEFAULT_STRMAP_CAPACITY);
+
         if (s->map == NULL) {
             free(s);
             return 0;
         }
+
         s->name = (char*)malloc((strlen(section) + 1) * sizeof(char));
+
         if (s->name == NULL) {
             sm_delete(s->map);
             free(s);
             return 0;
         }
+
         strcpy(s->name, section);
     }
+
     return sm_put(s->map, key, value);
 }
 
@@ -288,10 +322,13 @@ int settings_section_get_count(const Settings *settings, const char *section)
     if (settings == NULL) {
         return 0;
     }
+
     sect = get_section(settings->sections, settings->section_count, section);
+
     if (sect == NULL) {
         return 0;
     }
+
     return sm_get_count(sect->map);
 }
 
@@ -300,9 +337,11 @@ int settings_section_enum(const Settings *settings, const char *section, setting
     Section *sect;
 
     sect = get_section(settings->sections, settings->section_count, section);
+
     if (sect == NULL) {
         return 0;
     }
+
     return sm_enum(sect->map, enum_func, obj);
 }
 
@@ -318,19 +357,24 @@ static void trim_str(const char *str, char *out_buf)
     while (*str != '\0' && is_blank_char(*str)) {
         str++;
     }
+
     s0 = str;
     len = 0;
+
     while (*str != '\0') {
         len++;
         str++;
     }
+
     if (len > 0) {
         str--;
     }
+
     while (is_blank_char(*str)) {
         str--;
         len--;
     }
+
     memcpy(out_buf, s0, len);
     out_buf[len] = '\0';
 }
@@ -355,39 +399,54 @@ static int parse_str(Settings *settings, char *str, ParseState *parse_state)
 
     if (*str == '\0') {
         return 1;
+
     } else if (is_blank_str(str)) {
         return 1;
+
     } else if (is_comment_str(str)) {
         return 1;
+
     } else if (is_section_str(str)) {
         result = get_section_from_str(str, buf, sizeof(buf));
+
         if (!result) {
             return 0;
         }
+
         if (strlen(buf) + 1 > parse_state->current_section_n) {
             return 0;
         }
+
         strcpy(parse_state->current_section, buf);
         parse_state->has_section = 1;
         return 1;
+
     } else if (is_key_value_str(str)) {
         result = get_key_value_from_str(str, buf1, sizeof(buf1), buf2, sizeof(buf2));
+
         if (!result) {
             return 0;
         }
+
         if (!parse_state->has_section) {
             return 0;
         }
+
         return settings_set(settings, parse_state->current_section, buf1, buf2);
+
     } else if (is_key_without_value_str(str)) {
         result = get_key_without_value_from_str(str, buf, sizeof(buf));
+
         if (!result) {
             return 0;
         }
+
         if (!parse_state->has_section) {
             return 0;
         }
+
         return settings_set(settings, parse_state->current_section, buf, "");
+
     } else {
         return 0;
     }
@@ -410,8 +469,10 @@ static int is_blank_str(const char *str)
         if (!is_blank_char(*str)) {
             return 0;
         }
+
         str++;
     }
+
     return 1;
 }
 
@@ -426,6 +487,7 @@ static int is_comment_str(const char *str)
          */
         return 1;
     }
+
     return 0;
 }
 
@@ -438,13 +500,16 @@ static int is_section_str(const char *str)
         /* The first character must be the section start character */
         return 0;
     }
+
     while (*str != '\0' && *str != SECTION_END_CHAR) {
         str++;
     }
+
     if (*str != SECTION_END_CHAR) {
         /* The section end character must be present somewhere thereafter */
         return 0;
     }
+
     return 1;
 }
 
@@ -457,13 +522,16 @@ static int is_key_value_str(const char *str)
         /* It is illegal to start with the key-value separator */
         return 0;
     }
+
     while (*str != '\0' && *str != KEY_VALUE_SEPARATOR_CHAR) {
         str++;
     }
+
     if (*str != KEY_VALUE_SEPARATOR_CHAR) {
         /* The key-value separator must be present after the key part */
         return 0;
     }
+
     return 1;
 }
 
@@ -476,13 +544,16 @@ static int is_key_without_value_str(const char *str)
         /* It is illegal to start with the key-value separator */
         return 0;
     }
+
     while (*str != '\0' && *str != KEY_VALUE_SEPARATOR_CHAR) {
         str++;
     }
+
     if (*str == KEY_VALUE_SEPARATOR_CHAR) {
         /* The key-value separator must not be present after the key part */
         return 0;
     }
+
     return 1;
 }
 
@@ -497,20 +568,24 @@ static int get_section_from_str(const char *str, char *out_buf, unsigned int out
     count = 0;
     /* Jump past the section begin character */
     str++;
+
     while (*str != '\0' && *str != SECTION_END_CHAR) {
         /* Read in the section name into the output buffer */
         if (count == out_buf_n) {
             return 0;
         }
+
         *out_buf = *str;
         out_buf++;
         str++;
         count++;
     }
+
     /* Terminate the output buffer */
     if (count == out_buf_n) {
         return 0;
     }
+
     *out_buf = '\0';
     return 1;
 }
@@ -526,6 +601,7 @@ static int get_key_value_from_str(const char *str, char *out_buf1, unsigned int
 
     count1 = 0;
     count2 = 0;
+
     /* Read the key value from the input string and write it sequentially
      * to the first output buffer by walking the input string until we either hit
      * the null-terminator or the key-value separator.
@@ -535,34 +611,42 @@ static int get_key_value_from_str(const char *str, char *out_buf1, unsigned int
         if (count1 == out_buf1_n) {
             return 0;
         }
+
         /* Copy the character to the first output buffer */
         *out_buf1 = *str;
         out_buf1++;
         str++;
         count1++;
     }
+
     /* Terminate the first output buffer */
     if (count1 == out_buf1_n) {
         return 0;
     }
+
     *out_buf1 = '\0';
+
     /* Now trace the first input buffer backwards until we hit a non-blank character */
     while (is_blank_char(*(out_buf1 - 1))) {
         out_buf1--;
     }
+
     *out_buf1 = '\0';
+
     /* Try to proceed one more character, past the last read key-value
      * delimiter, in the input string.
      */
     if (*str != '\0') {
         str++;
     }
+
     /* Now find start of the value in the input string by walking the input
      * string until we either hit the null-terminator or a blank character.
      */
     while (*str != '\0' && is_blank_char(*str)) {
         str++;
     }
+
     while (*str != '\0') {
         /* Fail if there is a possibility that we are overwriting the second
          * input buffer.
@@ -570,16 +654,19 @@ static int get_key_value_from_str(const char *str, char *out_buf1, unsigned int
         if (count2 == out_buf2_n) {
             return 0;
         }
+
         /* Copy the character to the second output buffer */
         *out_buf2 = *str;
         out_buf2++;
         str++;
         count2++;
     }
+
     /* Terminate the second output buffer */
     if (count2 == out_buf2_n) {
         return 0;
     }
+
     *out_buf2 = '\0';
     return 1;
 }
@@ -593,6 +680,7 @@ static int get_key_without_value_from_str(const char *str, char *out_buf, unsign
     unsigned int count;
 
     count = 0;
+
     /* Now read the key value from the input string and write it sequentially
      * to the output buffer by walking the input string until we either hit
      * the null-terminator or the key-value separator.
@@ -602,16 +690,19 @@ static int get_key_without_value_from_str(const char *str, char *out_buf, unsign
         if (count == out_buf_n) {
             return 0;
         }
+
         /* Copy the character to the input buffer */
         *out_buf = *str;
         out_buf++;
         str++;
         count++;
     }
+
     /* Terminate the output buffer */
     if (count == out_buf_n) {
         return 0;
     }
+
     *out_buf = '\0';
     return 1;
 }
@@ -638,6 +729,7 @@ static const char * get_token(char *str, char delim, char **last)
     char *s0;
 
     s0 = str;
+
     /* If we hit the null-terminator the string
      * is exhausted and another token does not
      * exist.
@@ -645,17 +737,20 @@ static const char * get_token(char *str, char delim, char **last)
     if (*str == '\0') {
         return NULL;
     }
+
     /* Walk the string until we encounter a
      * null-terminator or the delimiter.
      */
     while (*str != '\0' && *str != delim) {
         str++;
     }
+
     /* Terminate the return token, if necessary */
     if (*str != '\0') {
         *str = '\0';
         str++;
     }
+
     *last = str;
     return s0;
 }
@@ -673,6 +768,7 @@ static int get_converted_value(const Settings *settings, const char *section, co
     if (!settings_get(settings, section, key, value, MAX_VALUECHARS)) {
         return 0;
     }
+
     switch (mode) {
     case CONVERT_MODE_INT:
         *((int *)out) = atoi(value);
@@ -684,6 +780,7 @@ static int get_converted_value(const Settings *settings, const char *section, co
         *((double *)out) = atof(value);
         return 1;
     }
+
     return 0;
 }
 
@@ -704,14 +801,18 @@ static int get_converted_tuple(const Settings *settings, const char *section, co
     if (out == NULL) {
         return 0;
     }
+
     if (n_out == 0) {
         return 0;
     }
+
     if (!settings_get(settings, section, key, value, MAX_VALUECHARS)) {
         return 0;
     }
+
     v = value;
     count = 0;
+
     /* Walk over all tokens in the value, and convert them and assign them
      * to the output array as specified by the mode.
      */
@@ -729,8 +830,10 @@ static int get_converted_tuple(const Settings *settings, const char *section, co
         default:
             return 0;
         }
+
         count++;
     }
+
     return 1;
 }
 
@@ -745,15 +848,19 @@ static Section * get_section(Section *sections, unsigned int n, const char *name
     if (name == NULL) {
         return NULL;
     }
+
     section = sections;
     i = 0;
+
     while (i < n) {
         if (strcmp(section->name, name) == 0) {
             return section;
         }
+
         section++;
         i++;
     }
+
     return NULL;
 }
 
@@ -769,10 +876,13 @@ static void enum_map(const char *key, const char *value, const void *obj)
     if (key == NULL || value == NULL) {
         return;
     }
+
     if (obj == NULL) {
         return;
     }
+
     stream = (FILE *)obj;
+
     if (strlen(key) < MAX_KEYCHARS && strlen(value) < MAX_VALUECHARS) {
         sprintf(buf, "%s%c%s\n", key, KEY_VALUE_SEPARATOR_CHAR, value);
         fputs(buf, stream);

src/strmap.c

@@ -62,15 +62,19 @@ StrMap * sm_new(unsigned int capacity)
     StrMap *map;
 
     map = (StrMap*)malloc(sizeof(StrMap));
+
     if (map == NULL) {
         return NULL;
     }
+
     map->count = capacity;
     map->buckets = (Bucket*)malloc(map->count * sizeof(Bucket));
+
     if (map->buckets == NULL) {
         free(map);
         return NULL;
     }
+
     memset(map->buckets, 0, map->count * sizeof(Bucket));
     return map;
 }
@@ -84,23 +88,28 @@ void sm_delete(StrMap *map)
     if (map == NULL) {
         return;
     }
+
     n = map->count;
     bucket = map->buckets;
     i = 0;
+
     while (i < n) {
         m = bucket->count;
         pair = bucket->pairs;
         j = 0;
+
         while(j < m) {
             free(pair->key);
             free(pair->value);
             pair++;
             j++;
         }
+
         free(bucket->pairs);
         bucket++;
         i++;
     }
+
     free(map->buckets);
     free(map);
 }
@@ -114,24 +123,31 @@ int sm_get(const StrMap *map, const char *key, char *out_buf, unsigned int n_out
     if (map == NULL) {
         return 0;
     }
+
     if (key == NULL) {
         return 0;
     }
+
     index = hash(key) % map->count;
     bucket = &(map->buckets[index]);
     pair = get_pair(bucket, key);
+
     if (pair == NULL) {
         return 0;
     }
+
     if (out_buf == NULL && n_out_buf == 0) {
         return strlen(pair->value) + 1;
     }
+
     if (out_buf == NULL) {
         return 0;
     }
+
     if (strlen(pair->value) >= n_out_buf) {
         return 0;
     }
+
     strcpy(out_buf, pair->value);
     return 1;
 }
@@ -145,15 +161,19 @@ int sm_exists(const StrMap *map, const char *key)
     if (map == NULL) {
         return 0;
     }
+
     if (key == NULL) {
         return 0;
     }
+
     index = hash(key) % map->count;
     bucket = &(map->buckets[index]);
     pair = get_pair(bucket, key);
+
     if (pair == NULL) {
         return 0;
     }
+
     return 1;
 }
 
@@ -168,14 +188,17 @@ int sm_put(StrMap *map, const char *key, const char *value)
     if (map == NULL) {
         return 0;
     }
+
     if (key == NULL || value == NULL) {
         return 0;
     }
+
     key_len = strlen(key);
     value_len = strlen(value);
     /* Get a pointer to the bucket the key string hashes to */
     index = hash(key) % map->count;
     bucket = &(map->buckets[index]);
+
     /* Check if we can handle insertion by simply replacing
      * an existing value in a key-value pair in the bucket.
      */
@@ -188,50 +211,64 @@ int sm_put(StrMap *map, const char *key, const char *value)
              * space for the new larger value.
              */
             tmp_value = (char*)realloc(pair->value, (value_len + 1) * sizeof(char));
+
             if (tmp_value == NULL) {
                 return 0;
             }
+
             pair->value = tmp_value;
         }
+
         /* Copy the new value into the pair that matches the key */
         strcpy(pair->value, value);
         return 1;
     }
+
     /* Allocate space for a new key and value */
     new_key = (char*)malloc((key_len + 1) * sizeof(char));
+
     if (new_key == NULL) {
         return 0;
     }
+
     new_value = (char*)malloc((value_len + 1) * sizeof(char));
+
     if (new_value == NULL) {
         free(new_key);
         return 0;
     }
+
     /* Create a key-value pair */
     if (bucket->count == 0) {
         /* The bucket is empty, lazily allocate space for a single
          * key-value pair.
          */
         bucket->pairs = (Pair*)malloc(sizeof(Pair));
+
         if (bucket->pairs == NULL) {
             free(new_key);
             free(new_value);
             return 0;
         }
+
         bucket->count = 1;
+
     } else {
         /* The bucket wasn't empty but no pair existed that matches the provided
          * key, so create a new key-value pair.
          */
         tmp_pairs = (Pair*)realloc(bucket->pairs, (bucket->count + 1) * sizeof(Pair));
+
         if (tmp_pairs == NULL) {
             free(new_key);
             free(new_value);
             return 0;
         }
+
         bucket->pairs = tmp_pairs;
         bucket->count++;
     }
+
     /* Get the last pair in the chain for the bucket */
     pair = &(bucket->pairs[bucket->count - 1]);
     pair->key = new_key;
@@ -252,22 +289,27 @@ int sm_get_count(const StrMap *map)
     if (map == NULL) {
         return 0;
     }
+
     bucket = map->buckets;
     n = map->count;
     i = 0;
     count = 0;
+
     while (i < n) {
         pair = bucket->pairs;
         m = bucket->count;
         j = 0;
+
         while (j < m) {
             count++;
             pair++;
             j++;
         }
+
         bucket++;
         i++;
     }
+
     return count;
 }
 
@@ -280,24 +322,30 @@ int sm_enum(const StrMap *map, sm_enum_func enum_func, const void *obj)
     if (map == NULL) {
         return 0;
     }
+
     if (enum_func == NULL) {
         return 0;
     }
+
     bucket = map->buckets;
     n = map->count;
     i = 0;
+
     while (i < n) {
         pair = bucket->pairs;
         m = bucket->count;
         j = 0;
+
         while (j < m) {
             enum_func(pair->key, pair->value, obj);
             pair++;
             j++;
         }
+
         bucket++;
         i++;
     }
+
     return 1;
 }
 
@@ -311,20 +359,25 @@ static Pair * get_pair(Bucket *bucket, const char *key)
     Pair *pair;
 
     n = bucket->count;
+
     if (n == 0) {
         return NULL;
     }
+
     pair = bucket->pairs;
     i = 0;
+
     while (i < n) {
         if (pair->key != NULL && pair->value != NULL) {
             if (strcmp(pair->key, key) == 0) {
                 return pair;
             }
         }
+
         pair++;
         i++;
     }
+
     return NULL;
 }
 
@@ -339,6 +392,7 @@ static unsigned long hash(const char *str)
     while (c = *str++) {
         hash = ((hash << 5) + hash) + c;
     }
+
     return hash;
 }