Variable in struct corrupted when storing value using library function

I'm trying the write a service that pings the watchdog device using the linux watchdog driver. In the function named 'LoadConfigurationFile' I pass a pointer to a struct that is defined above. That function then gets a string and stores it at the address of the variable in the struct with a library call(libconfig). However when I access the variable 'printf("%s\n", options.devicepath);return 1;' instead of printing the contents of configuration file as expected: "/dev/watchdog", the program displays "�/watchdog".

#include <errno.h>
#include <getopt.h>
#include <limits.h>
#include <linux/types.h>
#include <linux/watchdog.h>
#include <signal.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <syslog.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <libconfig.h>

struct cfgoptions {
    const char* devicepath;
};

struct cfgoptions options;
char *confile = "/etc/watchdogd.cfg";

    int LoadConfigurationFile(struct cfgoptions *s);

int main(int argc, char *argv[])
{

 struct cfgoptions *st_ptr;
     st_ptr = &options;

    if (LoadConfigurationFile(st_ptr) < 0)
        /*exit(EXIT_FAILURE);*/
/**/

printf("%s\n", options.devicepath);return 1;

/**/ 

int LoadConfigurationFile(struct cfgoptions *s)
{
    config_t cfg;
    config_init(&cfg);

    if (!config_read_file(&cfg, confile) && config_error_file(&cfg) == NULL)
    {
        fprintf(stderr, "daemon: cannot open configuration file: %s\n", config_error_file(&cfg));
        config_destroy(&cfg);
        return -1;
    } else if (!config_read_file(&cfg, confile)) {
        fprintf(stderr, "daemon:%s:%d: %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
        config_destroy(&cfg);
        config_destroy(&cfg);
        return -1;
    }

    if (!config_lookup_string(&cfg, "watchdog-device", &s->devicepath))
        s->devicepath = "/dev/watchdog";

    config_destroy(&cfg);

    return 0;
}

/etc/watchdogd.cfg:

watchdog-device = "/dev/watchdog"

int config_setting_lookup_string(const config_setting_t *setting,
                                 const char *name, const char **value)
{
  config_setting_t *member = config_setting_get_member(setting, name);
  if(! member)
    return(CONFIG_FALSE);

  if(config_setting_type(member) != CONFIG_TYPE_STRING)
    return(CONFIG_FALSE);

  *value = config_setting_get_string(member);
  return(CONFIG_TRUE);
}

config_setting_t *config_setting_get_member(const config_setting_t *setting,
                                            const char *name)
{
  if(setting->type != CONFIG_TYPE_GROUP)
    return(NULL);

  return(__config_list_search(setting->value.list, name, NULL));
}

const char *config_setting_get_string(const config_setting_t *setting)
{
  return((setting->type == CONFIG_TYPE_STRING) ? setting->value.sval : NULL);
}

Solution

the problem is you're calling config_destroy. That loses all your data allocated during lookups..

— Function: void config_destroy (config_t * config) These functions initialize and destroy the configuration object config.

config_init() initializes the config_t structure pointed to by config as a new, empty configuration.

config_destroy() destroys the configuration config, deallocating all memory associated with the configuration, but does not attempt to deallocate the config_t structure itself.

Pretty sure on this.

Try getting rid of that line and see what happens.

More: When libconfig allocates memory for the pointers you pass in, it has to keep the memory references around somewhere so it can clean them up later. That's what the cfg object is. It's just a big record keeping object for everything the library has allocated. When you destroy it, the library must free all allocated memory or else it will be leaked forever.