src/bin/lttng/conf.c

   1 /*
   2  * Copyright (c)  2011 David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <limits.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/stat.h>
  24 #include <sys/types.h>
  25 #include <unistd.h>
  26
  27 #include <common/error.h>
  28
  29 #include "conf.h"
  30
  31 /*
  32  * Returns the path with '/CONFIG_FILENAME' added to it;
  33  * path will be NULL if an error occurs.
  34  */
  35 char *config_get_file_path(char *path)
  36 {
  37         int ret;
  38         char *file_path;
  39
  40         ret = asprintf(&file_path, "%s/%s", path, CONFIG_FILENAME);
  41         if (ret < 0) {
  42                 ERR("Fail allocating config file path");
  43         }
  44
  45         return file_path;
  46 }
  47
  48 /*
  49  * Returns an open FILE pointer to the config file;
  50  * on error, NULL is returned.
  51  */
  52 static FILE *open_config(char *path, const char *mode)
  53 {
  54         FILE *fp = NULL;
  55         char *file_path;
  56
  57         file_path = config_get_file_path(path);
  58         if (file_path == NULL) {
  59                 goto error;
  60         }
  61
  62         fp = fopen(file_path, mode);
  63         if (fp == NULL) {
  64                 goto error;
  65         }
  66
  67 error:
  68         free(file_path);
  69         return fp;
  70 }
  71
  72 /*
  73  * Creates the empty config file at the path.
  74  * On success, returns 0;
  75  * on error, returns -1.
  76  */
  77 static int create_config_file(char *path)
  78 {
  79         int ret;
  80         FILE *fp;
  81
  82         fp = open_config(path, "w+");
  83         if (fp == NULL) {
  84                 ERR("Unable to create config file");
  85                 ret = -1;
  86                 goto error;
  87         }
  88
  89         ret = fclose(fp);
  90
  91 error:
  92         return ret;
  93 }
  94
  95 /*
  96  * Append data to the config file in file_path
  97  * On success, returns 0;
  98  * on error, returns -1.
  99  */
 100 static int write_config(char *file_path, size_t size, char *data)
 101 {
 102         FILE *fp;
 103         size_t len;
 104         int ret = 0;
 105
 106         fp = open_config(file_path, "a");
 107         if (fp == NULL) {
 108                 ret = -1;
 109                 goto end;
 110         }
 111
 112         /* Write session name into config file */
 113         len = fwrite(data, size, 1, fp);
 114         if (len != 1) {
 115                 ret = -1;
 116         }
 117         if (fclose(fp)) {
 118                 PERROR("close write_config");
 119         }
 120 end:
 121         return ret;
 122 }
 123
 124 /*
 125  * Returns the HOME directory path. Caller MUST NOT free(3) the return pointer.
 126  */
 127 char *config_get_default_path(void)
 128 {
 129         return getenv("HOME");
 130 }
 131
 132 /*
 133  * Destroys directory config and file config.
 134  */
 135 void config_destroy(char *path)
 136 {
 137         int ret;
 138         char *config_path;
 139
 140         config_path = config_get_file_path(path);
 141         if (config_path == NULL) {
 142                 return;
 143         }
 144
 145         if (!config_exists(config_path)) {
 146                 goto end;
 147         }
 148
 149         DBG("Removing %s\n", config_path);
 150         ret = remove(config_path);
 151         if (ret < 0) {
 152                 perror("remove config file");
 153         }
 154 end:
 155         free(config_path);
 156 }
 157
 158 /*
 159  * Destroys the default config
 160  */
 161 void config_destroy_default(void)
 162 {
 163         char *path = config_get_default_path();
 164         if (path == NULL) {
 165                 return;
 166         }
 167         config_destroy(path);
 168 }
 169
 170 /*
 171  * Returns 1 if config exists, 0 otherwise
 172  */
 173 int config_exists(const char *path)
 174 {
 175         int ret;
 176         struct stat info;
 177
 178         ret = stat(path, &info);
 179         if (ret < 0) {
 180                 return 0;
 181         }
 182         return S_ISREG(info.st_mode) || S_ISDIR(info.st_mode);
 183 }
 184
 185 /*
 186  * Returns the session name from the config file.
 187  * The caller is responsible for freeing the returned string.
 188  * On error, NULL is returned.
 189  */
 190 char *config_read_session_name(char *path)
 191 {
 192         int ret;
 193         FILE *fp;
 194         char var[NAME_MAX], *session_name;
 195
 196         session_name = malloc(NAME_MAX);
 197         if (session_name == NULL) {
 198                 ERR("Out of memory");
 199                 goto error;
 200         }
 201
 202         fp = open_config(path, "r");
 203         if (fp == NULL) {
 204                 ERR("Can't find valid lttng config %s/.lttngrc", path);
 205                 MSG("Did you create a session? (lttng create <my_session>)");
 206                 goto error;
 207         }
 208
 209         while (!feof(fp)) {
 210                 if ((ret = fscanf(fp, "%[^'=']=%s\n", var, session_name)) != 2) {
 211                         if (ret == -1) {
 212                                 ERR("Missing session=NAME in config file.");
 213                                 goto error_close;
 214                         }
 215                         continue;
 216                 }
 217
 218                 if (strcmp(var, "session") == 0) {
 219                         goto found;
 220                 }
 221         }
 222
 223 error_close:
 224         ret = fclose(fp);
 225         if (ret < 0) {
 226                 PERROR("close config read session name");
 227         }
 228
 229 error:
 230         return NULL;
 231
 232 found:
 233         ret = fclose(fp);
 234         if (ret < 0) {
 235                 PERROR("close config read session name found");
 236         }
 237         return session_name;
 238
 239 }
 240
 241 /*
 242  * Write session name option to the config file.
 243  * On success, returns 0;
 244  * on error, returns -1.
 245  */
 246 int config_add_session_name(char *path, char *name)
 247 {
 248         int ret;
 249         char session_name[NAME_MAX];
 250
 251         /*
 252          * With GNU C <  2.1, snprintf returns -1 if the target buffer is too small;
 253          * With GNU C >= 2.1, snprintf returns the required size (excluding closing null)
 254          */
 255         ret = snprintf(session_name, NAME_MAX, "session=%s\n", name);
 256         if ((ret < 0) || (ret >= NAME_MAX)) {
 257                 ret = -1;
 258                 goto error;
 259         }
 260         ret = write_config(path, ret, session_name);
 261 error:
 262         return ret;
 263 }
 264
 265 /*
 266  * Init configuration directory and file.
 267  * On success, returns 0;
 268  * on error, returns -1.
 269  */
 270 int config_init(char *session_name)
 271 {
 272         int ret;
 273         char *path;
 274
 275         path = config_get_default_path();
 276         if (path == NULL) {
 277                 ret = -1;
 278                 goto error;
 279         }
 280
 281         /* Create default config file */
 282         ret = create_config_file(path);
 283         if (ret < 0) {
 284                 goto error;
 285         }
 286
 287         ret = config_add_session_name(path, session_name);
 288         if (ret < 0) {
 289                 goto error;
 290         }
 291
 292         DBG("Init config session in %s", path);
 293
 294 error:
 295         return ret;
 296 }