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 #define _LGPL_SOURCE
  20 #include <limits.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/stat.h>
  25 #include <sys/types.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28
  29 #include <common/common.h>
  30 #include <common/utils.h>
  31
  32 #include "conf.h"
  33
  34 /*
  35  * Returns the path with '/CONFIG_FILENAME' added to it;
  36  * path will be NULL if an error occurs.
  37  */
  38 char *config_get_file_path(char *path)
  39 {
  40         int ret;
  41         char *file_path;
  42
  43         ret = asprintf(&file_path, "%s/%s", path, CONFIG_FILENAME);
  44         if (ret < 0) {
  45                 ERR("Fail allocating config file path");
  46                 file_path = NULL;
  47         }
  48
  49         return file_path;
  50 }
  51
  52 /*
  53  * Returns an open FILE pointer to the config file;
  54  * on error, NULL is returned.
  55  */
  56 static FILE *open_config(char *path, const char *mode)
  57 {
  58         FILE *fp = NULL;
  59         char *file_path;
  60
  61         file_path = config_get_file_path(path);
  62         if (file_path == NULL) {
  63                 goto error;
  64         }
  65
  66         fp = fopen(file_path, mode);
  67         if (fp == NULL) {
  68                 goto error;
  69         }
  70
  71 error:
  72         free(file_path);
  73         return fp;
  74 }
  75
  76 /*
  77  * Creates the empty config file at the path.
  78  * On success, returns 0;
  79  * on error, returns -1.
  80  */
  81 static int create_config_file(char *path)
  82 {
  83         int ret;
  84         FILE *fp;
  85
  86         fp = open_config(path, "w+");
  87         if (fp == NULL) {
  88                 ERR("Unable to create config file");
  89                 ret = -1;
  90                 goto error;
  91         }
  92
  93         ret = fclose(fp);
  94
  95 error:
  96         return ret;
  97 }
  98
  99 /*
 100  * Append data to the config file in file_path
 101  * On success, returns 0;
 102  * on error, returns -1.
 103  */
 104 static int write_config(char *file_path, size_t size, char *data)
 105 {
 106         FILE *fp;
 107         size_t len;
 108         int ret = 0;
 109
 110         fp = open_config(file_path, "a");
 111         if (fp == NULL) {
 112                 ret = -1;
 113                 goto end;
 114         }
 115
 116         /* Write session name into config file */
 117         len = fwrite(data, size, 1, fp);
 118         if (len != 1) {
 119                 ret = -1;
 120         }
 121         if (fclose(fp)) {
 122                 PERROR("close write_config");
 123         }
 124 end:
 125         return ret;
 126 }
 127
 128 /*
 129  * Destroys directory config and file config.
 130  */
 131 void config_destroy(char *path)
 132 {
 133         int ret;
 134         char *config_path;
 135
 136         config_path = config_get_file_path(path);
 137         if (config_path == NULL) {
 138                 return;
 139         }
 140
 141         if (!config_exists(config_path)) {
 142                 goto end;
 143         }
 144
 145         DBG("Removing %s\n", config_path);
 146         ret = remove(config_path);
 147         if (ret < 0) {
 148                 PERROR("remove config file");
 149         }
 150 end:
 151         free(config_path);
 152 }
 153
 154 /*
 155  * Destroys the default config
 156  */
 157 void config_destroy_default(void)
 158 {
 159         char *path = utils_get_home_dir();
 160         if (path == NULL) {
 161                 return;
 162         }
 163         config_destroy(path);
 164 }
 165
 166 /*
 167  * Returns 1 if config exists, 0 otherwise
 168  */
 169 int config_exists(const char *path)
 170 {
 171         int ret;
 172         struct stat info;
 173
 174         ret = stat(path, &info);
 175         if (ret < 0) {
 176                 return 0;
 177         }
 178         return S_ISREG(info.st_mode) || S_ISDIR(info.st_mode);
 179 }
 180
 181 static
 182 int _config_read_session_name(char *path, char **name)
 183 {
 184         int ret = 0;
 185         FILE *fp;
 186         char var[NAME_MAX], *session_name;
 187 #if (NAME_MAX == 255)
 188 #define NAME_MAX_SCANF_IS_A_BROKEN_API  "254"
 189 #endif
 190
 191         session_name = zmalloc(NAME_MAX);
 192         if (session_name == NULL) {
 193                 ret = -ENOMEM;
 194                 ERR("Out of memory");
 195                 goto error;
 196         }
 197
 198         fp = open_config(path, "r");
 199         if (fp == NULL) {
 200                 ret = -ENOENT;
 201                 goto error;
 202         }
 203
 204         while (!feof(fp)) {
 205                 if ((ret = fscanf(fp, "%" NAME_MAX_SCANF_IS_A_BROKEN_API
 206                                 "[^'=']=%" NAME_MAX_SCANF_IS_A_BROKEN_API "s\n",
 207                                 var, session_name)) != 2) {
 208                         if (ret == -1) {
 209                                 ERR("Missing session=NAME in config file.");
 210                                 goto error_close;
 211                         }
 212                         continue;
 213                 }
 214
 215                 if (strcmp(var, "session") == 0) {
 216                         goto found;
 217                 }
 218         }
 219
 220 error_close:
 221         if (fclose(fp) < 0) {
 222                 PERROR("close config read session name");
 223         }
 224 error:
 225         free(session_name);
 226         return ret;
 227 found:
 228         *name = session_name;
 229         if (fclose(fp) < 0) {
 230                 PERROR("close config read session name found");
 231         }
 232         return ret;
 233 }
 234
 235 /*
 236  * Returns the session name from the config file.
 237  *
 238  * The caller is responsible for freeing the returned string.
 239  * On error, NULL is returned.
 240  */
 241 char *config_read_session_name(char *path)
 242 {
 243         int ret;
 244         char *name = NULL;
 245
 246         ret = _config_read_session_name(path, &name);
 247         if (ret == -ENOENT) {
 248                 const char *home_dir = utils_get_home_dir();
 249
 250                 ERR("Can't find valid lttng config %s/.lttngrc", home_dir);
 251                 MSG("Did you create a session? (lttng create <my_session>)");
 252         }
 253
 254         return name;
 255 }
 256
 257 /*
 258  * Returns the session name from the config file. (no warnings/errors emitted)
 259  *
 260  * The caller is responsible for freeing the returned string.
 261  * On error, NULL is returned.
 262  */
 263 char *config_read_session_name_quiet(char *path)
 264 {
 265         char *name = NULL;
 266
 267         (void) _config_read_session_name(path, &name);
 268         return name;
 269 }
 270
 271 /*
 272  * Write session name option to the config file.
 273  * On success, returns 0;
 274  * on error, returns -1.
 275  */
 276 int config_add_session_name(char *path, char *name)
 277 {
 278         int ret;
 279         char *attr = "session=";
 280         /* Max name len accepted plus attribute's len and the NULL byte. */
 281         char session_name[NAME_MAX + strlen(attr) + 1];
 282
 283         /*
 284          * With GNU C <  2.1, snprintf returns -1 if the target buffer is too small;
 285          * With GNU C >= 2.1, snprintf returns the required size (excluding closing null)
 286          */
 287         ret = snprintf(session_name, sizeof(session_name), "%s%s\n", attr, name);
 288         if (ret < 0) {
 289                 ret = -1;
 290                 goto error;
 291         }
 292         ret = write_config(path, ret, session_name);
 293 error:
 294         return ret;
 295 }
 296
 297 /*
 298  * Init configuration directory and file.
 299  * On success, returns 0;
 300  * on error, returns -1.
 301  */
 302 int config_init(char *session_name)
 303 {
 304         int ret;
 305         char *path;
 306
 307         path = utils_get_home_dir();
 308         if (path == NULL) {
 309                 ret = -1;
 310                 goto error;
 311         }
 312
 313         /* Create default config file */
 314         ret = create_config_file(path);
 315         if (ret < 0) {
 316                 goto error;
 317         }
 318
 319         ret = config_add_session_name(path, session_name);
 320         if (ret < 0) {
 321                 goto error;
 322         }
 323
 324         DBG("Init config session in %s", path);
 325
 326 error:
 327         return ret;
 328 }