src/configuration.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2009 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <cstdlib>
  22 #include <cstring>
  23 #include <iostream>
  24 #include <fstream>
  25
  26 #ifdef __linux__
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31 #elif defined(__FreeBSD__)
  32 #include <fcntl.h>
  33 #include <kvm.h>
  34 #include <paths.h>
  35 #include <sys/param.h>
  36 #include <sys/sysctl.h>
  37 #include <sys/user.h>
  38 #endif
  39
  40 #ifdef HAVE_CONFIG_H
  41 # include <config.h>
  42 #endif
  43
  44 #include "configuration.h"
  45 #include "misc.h"
  46
  47 using std::string;
  48
  49 ScrobbyConfig Config;
  50
  51 namespace
  52 {
  53         std::string GetLineValue(const string &line, char a = '"', char b = '"')
  54         {
  55                 int i = 0;
  56                 int begin = -1, end = -1;
  57                 for (string::const_iterator it = line.begin(); it != line.end(); i++, it++)
  58                 {
  59                         if (*it == a || *it == b)
  60                         {
  61                                 if (begin < 0)
  62                                         begin = i+1;
  63                                 else
  64                                         end = i;
  65                         }
  66                 }
  67                 if (begin >= 0 && end >= 0)
  68                         return line.substr(begin, end-begin);
  69                 else
  70                         return "";
  71         }
  72
  73         void HomeFolder(const ScrobbyConfig &conf, string &s)
  74         {
  75                 if (s[0] == '~')
  76                         s.replace(0, 1, conf.user_home_folder);
  77         }
  78
  79         LogLevel IntoLogLevel(const string &value)
  80         {
  81                 LogLevel result = llInfo;
  82                 if (value == "none")
  83                 {
  84                         result = llNone;
  85                 }
  86                 else if (value == "info")
  87                 {
  88                         result = llInfo;
  89                 }
  90                 else if (value == "verbose")
  91                 {
  92                         result = llVerbose;
  93                 }
  94                 return result;
  95         }
  96 }
  97
  98 void ParseArgv(ScrobbyConfig &conf, int argc, char **argv)
  99 {
 100         for (int i = 1; i < argc; i++)
 101         {
 102                 if (strcmp(argv[i], "--help") == 0)
 103                 {
 104                         std::cout
 105                         << "usage:\n"
 106                         << "scrobby [options] <conf file>\n"
 107                         << "scrobby [options] (search for ~/.scrobbyconf, then /etc/scrobby.conf)\n\n"
 108                         << "options:\n"
 109                         << "   --help                show this help message\n"
 110                         << "   --no-daemon           do not detach from console\n"
 111                         << "   --quiet               do not log anything\n"
 112                         << "   --verbose             verbose logging\n"
 113                         << "   --version             print version information\n"
 114                         ;
 115                         exit(0);
 116                 }
 117                 else if (strcmp(argv[i], "--no-daemon") == 0)
 118                 {
 119                         conf.daemonize = false;
 120                 }
 121                 else if (strcmp(argv[i], "--quiet") == 0)
 122                 {
 123                         conf.log_level = llNone;
 124                 }
 125                 else if (strcmp(argv[i], "--verbose") == 0)
 126                 {
 127                         conf.log_level = llVerbose;
 128                 }
 129                 else if (strcmp(argv[i], "--version") == 0)
 130                 {
 131                         std::cout << "scrobby - an audioscrobbler mpd client, version "VERSION"\n";
 132                         exit(0);
 133                 }
 134                 else
 135                 {
 136                         conf.file_config = argv[i];
 137                 }
 138         }
 139 }
 140
 141 bool CheckFiles(ScrobbyConfig &conf)
 142 {
 143         std::ofstream f;
 144         std::ifstream g;
 145
 146         g.open(conf.file_pid.c_str());
 147         if (g.is_open())
 148         {
 149                 string strpid;
 150                 getline(g, strpid);
 151                 g.close();
 152                 pid_t pid = StrToInt(strpid);
 153                 if (pid < 1)
 154                 {
 155                         std::cerr << "pid file: " << conf.file_pid << " is invalid, trying to remove...\n";
 156                         if (unlink(conf.file_pid.c_str()) == 0)
 157                         {
 158                                 std::cout << "pid file succesfully removed.\n";
 159                         }
 160                         else
 161                         {
 162                                 std::cerr << "couldn't remove pid file.\n";
 163                                 return false;
 164                         }
 165                 }
 166                 else
 167                 {
 168 #                       ifdef __linux__
 169                         struct stat stat_pid;
 170                         std::ostringstream proc_file;
 171                         proc_file << "/proc/" << pid << std::ends;
 172                         if (!(stat(proc_file.str().c_str(), &stat_pid) == -1 && errno == ENOENT))
 173 #                       elif defined(__FreeBSD__)
 174                         char kvm_errbuf[_POSIX2_LINE_MAX];
 175                         kvm_t *hkvm;
 176                         int cnt = 0;
 177                         struct kinfo_proc *proc;
 178
 179                         hkvm = kvm_openfiles(NULL, _PATH_DEVNULL, NULL, O_RDONLY, kvm_errbuf);
 180                         if (hkvm)
 181                         {
 182                                 proc = kvm_getprocs(hkvm, KERN_PROC_PID, pid, &cnt);
 183                                 kvm_close(hkvm);
 184                         }
 185                         else
 186                         {
 187                                 std::cerr << "kvm_openfiles failed with message:" << std::endl << kvm_errbuf << std::endl;
 188                         }
 189                         if (cnt >= 1)
 190 #                       endif
 191                         {
 192                                 std::cerr << "scrobby is already running with PID " << pid << "!\n";
 193                                 return false;
 194                         }
 195                 }
 196         }
 197
 198         f.open(conf.file_pid.c_str(), std::ios_base::app);
 199         if (!f.is_open())
 200         {
 201                 std::cerr << "Cannot create/open pid file: " << conf.file_pid << std::endl;
 202                 return false;
 203         }
 204         f.close();
 205
 206         f.open(conf.file_log.c_str(), std::ios_base::app);
 207         if (!f.is_open())
 208         {
 209                 std::cerr << "Cannot create/open log file: " << conf.file_log << std::endl;
 210                 return false;
 211         }
 212         f.close();
 213
 214         f.open(conf.file_cache.c_str(), std::ios_base::app);
 215         if (!f.is_open())
 216         {
 217                 std::cerr << "Cannot create/open cache file: " << conf.file_cache << std::endl;
 218                 return false;
 219         }
 220         f.close();
 221
 222         return true;
 223 }
 224
 225 void DefaultConfiguration(ScrobbyConfig &conf)
 226 {
 227         conf.user_home_folder = getenv("HOME") ? getenv("HOME") : "";
 228
 229         conf.mpd_host = "localhost";
 230         conf.mpd_port = 6600;
 231         conf.mpd_timeout = 15;
 232
 233         conf.file_log = "/var/log/scrobby/scrobby.log";
 234         conf.file_pid = "/var/run/scrobby/scrobby.pid";
 235         conf.file_cache = "/var/cache/scrobby/scrobby.cache";
 236
 237         conf.log_level = llUndefined;
 238         conf.daemonize = true;
 239 }
 240
 241 bool ReadConfiguration(ScrobbyConfig &conf, const string &file)
 242 {
 243         string line, v;
 244         std::ifstream f(file.c_str());
 245
 246         if (!f.is_open())
 247                 return false;
 248
 249         while (!f.eof())
 250         {
 251                 getline(f, line);
 252                 if (!line.empty() && line[0] != '#')
 253                 {
 254                         v = GetLineValue(line);
 255
 256                         if (line.find("dedicated_user") != string::npos)
 257                         {
 258                                 if (!line.empty())
 259                                         conf.dedicated_user = v;
 260                         }
 261                         else if (line.find("mpd_host") != string::npos)
 262                         {
 263                                 if (!line.empty())
 264                                         conf.mpd_host = v;
 265                         }
 266                         else if (line.find("mpd_port") != string::npos)
 267                         {
 268                                 if (!v.empty())
 269                                         conf.mpd_port = StrToInt(v);
 270                         }
 271                         else if (line.find("mpd_timeout") != string::npos)
 272                         {
 273                                 if (!v.empty())
 274                                         conf.mpd_timeout = StrToInt(v);
 275                         }
 276                         else if (line.find("log_file") != string::npos)
 277                         {
 278                                 if (!v.empty())
 279                                 {
 280                                         HomeFolder(conf, v);
 281                                         conf.file_log = v;
 282                                 }
 283                         }
 284                         else if (line.find("pid_file") != string::npos)
 285                         {
 286                                 if (!v.empty())
 287                                 {
 288                                         HomeFolder(conf, v);
 289                                         conf.file_pid = v;
 290                                 }
 291                         }
 292                         else if (line.find("cache_file") != string::npos)
 293                         {
 294                                 if (!v.empty())
 295                                 {
 296                                         HomeFolder(conf, v);
 297                                         conf.file_cache = v;
 298                                 }
 299                         }
 300                         else if (line.find("lastfm_user") != string::npos)
 301                         {
 302                                 if (!v.empty())
 303                                         conf.lastfm_user = v;
 304                         }
 305                         else if (line.find("lastfm_password") != string::npos)
 306                         {
 307                                 if (!v.empty())
 308                                         conf.lastfm_password = v;
 309                         }
 310                         else if (line.find("lastfm_md5_password") != string::npos)
 311                         {
 312                                 if (!v.empty())
 313                                         conf.lastfm_md5_password = v;
 314                         }
 315                         else if (line.find("log_level") != string::npos)
 316                         {
 317                                 if (!v.empty() && conf.log_level == llUndefined)
 318                                         conf.log_level = IntoLogLevel(v);
 319                         }
 320                 }
 321         }
 322         f.close();
 323         return true;
 324 }
 325