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