src/scrobby.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 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  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <csignal>
  22 #include <cstdlib>
  23 #include <curl/curl.h>
  24 #include <iostream>
  25 #include <vector>
  26
  27 #include "callback.h"
  28 #include "configuration.h"
  29 #include "misc.h"
  30 #include "scrobby.h"
  31 #include "song.h"
  32 #include "mpdpp.h"
  33
  34 using std::string;
  35
  36 Handshake myHandshake;
  37 MPD::Song s;
  38
  39 namespace
  40 {
  41         void do_at_exit();
  42         void signal_handler(int);
  43
  44         bool handshake_sent_properly();
  45 }
  46
  47 int main(int argc, char **argv)
  48 {
  49         DefaultConfiguration(Config);
  50
  51         if (argc > 1)
  52         {
  53                 ParseArgv(Config, argc, argv);
  54         }
  55         if (!Config.file_config.empty())
  56         {
  57                 if (!ReadConfiguration(Config, Config.file_config))
  58                 {
  59                         std::cerr << "cannot read configuration file: " << Config.file_config << std::endl;
  60                         return 1;
  61                 }
  62         }
  63         else if (!ReadConfiguration(Config, Config.user_home_folder + "/.scrobbyconf"))
  64         {
  65                 if (!ReadConfiguration(Config, "/etc/scrobby.conf"))
  66                 {
  67                         std::cerr << "default configuration files not found!\n";
  68                         return 1;
  69                 }
  70         }
  71         if (Config.log_level == llUndefined)
  72         {
  73                 Config.log_level = llInfo;
  74         }
  75         if (Config.lastfm_user.empty() || (Config.lastfm_md5_password.empty() && Config.lastfm_password.empty()))
  76         {
  77                 std::cerr << "last.fm user/password is not set.\n";
  78                 return 1;
  79         }
  80         ChangeToUser();
  81         if (!CheckFiles(Config))
  82         {
  83                 return 1;
  84         }
  85         if (Config.daemonize)
  86         {
  87                 if (!Daemonize())
  88                         std::cerr << "couldn't daemonize!\n";
  89         }
  90
  91         MPD::Song::GetCached();
  92
  93         MPD::Connection *Mpd = new MPD::Connection;
  94
  95         if (Config.mpd_host != "localhost")
  96                 Mpd->SetHostname(Config.mpd_host);
  97         if (Config.mpd_port != 6600)
  98                 Mpd->SetPort(Config.mpd_port);
  99
 100         Mpd->SetTimeout(Config.mpd_timeout);
 101         Mpd->SetStatusUpdater(ScrobbyStatusChanged, NULL);
 102         Mpd->SetErrorHandler(ScrobbyErrorCallback, NULL);
 103
 104         signal(SIGHUP, signal_handler);
 105         signal(SIGINT, signal_handler);
 106         signal(SIGTERM, signal_handler);
 107         signal(SIGPIPE, SIG_IGN);
 108
 109         atexit(do_at_exit);
 110
 111         int handshake_delay = 0;
 112         int mpd_delay = 0;
 113
 114         time_t now = 0;
 115         time_t handshake_ts = 0;
 116         time_t mpd_ts = 0;
 117
 118         while (!usleep(500000))
 119         {
 120                 time(&now);
 121                 if (now > handshake_ts && myHandshake.Status != "OK")
 122                 {
 123                         myHandshake.Clear();
 124                         if (handshake_sent_properly() && !myHandshake.Status.empty())
 125                         {
 126                                 Log(llInfo, "Handshake returned %s", myHandshake.Status.c_str());
 127                         }
 128                         if (myHandshake.Status == "OK")
 129                         {
 130                                 Log(llInfo, "Connected to Audioscrobbler!");
 131                                 handshake_delay = 0;
 132                         }
 133                         else
 134                         {
 135                                 handshake_delay += 10;
 136                                 Log(llInfo, "Connection to Audioscrobbler refused, retrieving in %d seconds...", handshake_delay);
 137                                 handshake_ts = time(0)+handshake_delay;
 138                         }
 139                 }
 140                 if (Mpd->Connected())
 141                 {
 142                         Mpd->UpdateStatus();
 143                 }
 144                 else if (now > mpd_ts)
 145                 {
 146                         s.Submit();
 147                         Log(llVerbose, "Connecting to MPD...");
 148                         if (Mpd->Connect())
 149                         {
 150                                 Log(llInfo, "Connected to MPD at %s !", Config.mpd_host.c_str());
 151                                 mpd_delay = 0;
 152                         }
 153                         else
 154                         {
 155                                 mpd_delay += 10;
 156                                 Log(llInfo, "Cannot connect to MPD, retrieving in %d seconds...", mpd_delay);
 157                                 mpd_ts = time(0)+mpd_delay;
 158                         }
 159                 }
 160         }
 161         return 0;
 162 }
 163
 164 namespace
 165 {
 166         void do_at_exit()
 167         {
 168                 s.Submit();
 169                 Log(llInfo, "Shutting down...");
 170                 if (remove(Config.file_pid.c_str()) != 0)
 171                         Log(llInfo, "Couldn't remove pid file!");
 172         }
 173
 174         void signal_handler(int)
 175         {
 176                 exit(0);
 177         }
 178
 179         bool handshake_sent_properly()
 180         {
 181                 CURLcode code;
 182                 string handshake_url;
 183                 string result;
 184                 string timestamp = IntoStr(time(NULL));
 185
 186                 handshake_url = "http://post.audioscrobbler.com/?hs=true&p=1.2.1&c=mpc&v="VERSION"&u=";
 187                 handshake_url += Config.lastfm_user;
 188                 handshake_url += "&t=";
 189                 handshake_url += timestamp;
 190                 handshake_url += "&a=";
 191                 handshake_url += md5sum((Config.lastfm_md5_password.empty() ? md5sum(Config.lastfm_password) : Config.lastfm_md5_password) + timestamp);
 192
 193                 CURL *hs = curl_easy_init();
 194                 curl_easy_setopt(hs, CURLOPT_URL, handshake_url.c_str());
 195                 curl_easy_setopt(hs, CURLOPT_WRITEFUNCTION, write_data);
 196                 curl_easy_setopt(hs, CURLOPT_WRITEDATA, &result);
 197                 curl_easy_setopt(hs, CURLOPT_CONNECTTIMEOUT, curl_timeout);
 198                 code = curl_easy_perform(hs);
 199                 curl_easy_cleanup(hs);
 200
 201                 if (code != CURLE_OK)
 202                 {
 203                         Log(llInfo, "Error while sending handshake: %s", curl_easy_strerror(code));
 204                         return false;
 205                 }
 206
 207                 size_t i = result.find("\n");
 208                 myHandshake.Status = result.substr(0, i);
 209                 if (myHandshake.Status != "OK")
 210                         return false;
 211                 result = result.substr(i+1);
 212                 i = result.find("\n");
 213                 myHandshake.SessionID = result.substr(0, i);
 214                 result = result.substr(i+1);
 215                 i = result.find("\n");
 216                 myHandshake.NowPlayingURL = result.substr(0, i);
 217                 result = result.substr(i+1);
 218                 IgnoreNewlines(result);
 219                 myHandshake.SubmissionURL = result;
 220                 return true;
 221         }
 222 }
 223