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(const 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(const 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(const 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(const 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(const 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         const 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(const char *path, char **name)
 182 {
 183         int ret = 0;
 184         FILE *fp;
 185         char var[NAME_MAX], *session_name;
 186
 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(const 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(const 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(const char *path, const 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(const char *session_name)
 303 {
 304         int ret;
 305         const 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 }