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