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 <pthread.h>
  25 #include <iostream>
  26 #include <vector>
  27
  28 #include "callback.h"
  29 #include "configuration.h"
  30 #include "misc.h"
  31 #include "scrobby.h"
  32 #include "song.h"
  33 #include "mpdpp.h"
  34
  35 using std::string;
  36
  37 ScrobbyConfig config;
  38
  39 Handshake handshake;
  40 MPD::Song s;
  41
  42 pthread_t mpdconnection_th;
  43 pthread_t handshake_th;
  44
  45 pthread_mutex_t curl_lock = PTHREAD_MUTEX_INITIALIZER;
  46 pthread_mutex_t handshake_lock = PTHREAD_MUTEX_INITIALIZER;
  47
  48 std::vector<string> SongsQueue;
  49
  50 bool scrobby_exit = 0;
  51 bool notify_about_now_playing = 0;
  52
  53 namespace {
  54         void signal_handler(int);
  55         bool send_handshake();
  56
  57         void *mpdconnection_handler(void *data);
  58         void *handshake_handler(void *);
  59 }
  60
  61 int main(int argc, char **argv)
  62 {
  63         DefaultConfiguration(config);
  64
  65         if (argc > 1)
  66         {
  67                 ParseArgv(config, argc, argv);
  68         }
  69         if (!config.file_config.empty())
  70         {
  71                 if (!ReadConfiguration(config, config.file_config))
  72                 {
  73                         std::cerr << "cannot read configuration file: " << config.file_config << std::endl;
  74                         return 1;
  75                 }
  76         }
  77         else if (!ReadConfiguration(config, config.user_home_folder + "/.scrobbyconf"))
  78         {
  79                 if (!ReadConfiguration(config, "/etc/scrobby.conf"))
  80                 {
  81                         std::cerr << "default configuration files not found!\n";
  82                         return 1;
  83                 }
  84         }
  85         if (config.log_level == llUndefined)
  86         {
  87                 config.log_level = llInfo;
  88         }
  89         if (config.lastfm_user.empty() || (config.lastfm_md5_password.empty() && config.lastfm_password.empty()))
  90         {
  91                 std::cerr << "last.fm user/password is not set.\n";
  92                 return 1;
  93         }
  94         ChangeToUser();
  95         if (!CheckFiles(config))
  96         {
  97                 return 1;
  98         }
  99         if (config.daemonize)
 100         {
 101                 if (!Daemonize())
 102                         std::cerr << "couldn't daemonize!\n";
 103         }
 104
 105         GetCachedSongs(SongsQueue);
 106
 107         MPD::Connection *Mpd = new MPD::Connection;
 108
 109         if (config.mpd_host != "localhost")
 110                 Mpd->SetHostname(config.mpd_host);
 111         if (config.mpd_port != 6600)
 112                 Mpd->SetPort(config.mpd_port);
 113
 114         Mpd->SetTimeout(config.mpd_timeout);
 115         Mpd->SetStatusUpdater(ScrobbyStatusChanged, NULL);
 116         Mpd->SetErrorHandler(ScrobbyErrorCallback, NULL);
 117
 118         signal(SIGHUP, signal_handler);
 119         signal(SIGINT, signal_handler);
 120         signal(SIGTERM, signal_handler);
 121         signal(SIGPIPE, SIG_IGN);
 122
 123         pthread_create(&mpdconnection_th, NULL, mpdconnection_handler, Mpd);
 124         pthread_create(&handshake_th, NULL, handshake_handler, NULL);
 125         pthread_detach(mpdconnection_th);
 126         pthread_detach(handshake_th);
 127
 128         while (!scrobby_exit && !usleep(500000))
 129         {
 130                 if (Mpd->Connected())
 131                         Mpd->UpdateStatus();
 132         }
 133
 134         s.Submit();
 135         Log(llInfo, "Shutting down...");
 136         if (remove(config.file_pid.c_str()) != 0)
 137                 Log(llInfo, "Couldn't remove pid file!");
 138         delete Mpd;
 139
 140         return 0;
 141 }
 142
 143 namespace {
 144         void signal_handler(int)
 145         {
 146                 scrobby_exit = 1;
 147         }
 148
 149         bool send_handshake()
 150         {
 151                 CURLcode code;
 152                 string handshake_url;
 153                 string result;
 154                 string timestamp = IntoStr(time(NULL));
 155
 156                 handshake_url = "http://post.audioscrobbler.com/?hs=true&p=1.2.1&c=mpc&v="VERSION"&u=";
 157                 handshake_url += config.lastfm_user;
 158                 handshake_url += "&t=";
 159                 handshake_url += timestamp;
 160                 handshake_url += "&a=";
 161                 handshake_url += md5sum((config.lastfm_md5_password.empty() ? md5sum(config.lastfm_password) : config.lastfm_md5_password) + timestamp);
 162
 163                 pthread_mutex_lock(&curl_lock);
 164                 CURL *hs = curl_easy_init();
 165                 curl_easy_setopt(hs, CURLOPT_DNS_CACHE_TIMEOUT, 0);
 166                 curl_easy_setopt(hs, CURLOPT_NOSIGNAL, 1);
 167                 curl_easy_setopt(hs, CURLOPT_URL, handshake_url.c_str());
 168                 curl_easy_setopt(hs, CURLOPT_WRITEFUNCTION, write_data);
 169                 curl_easy_setopt(hs, CURLOPT_WRITEDATA, &result);
 170                 curl_easy_setopt(hs, CURLOPT_CONNECTTIMEOUT, curl_timeout);
 171                 code = curl_easy_perform(hs);
 172                 curl_easy_cleanup(hs);
 173                 pthread_mutex_unlock(&curl_lock);
 174
 175                 if (code != CURLE_OK)
 176                 {
 177                         Log(llInfo, "Error while sending handshake: %s", curl_easy_strerror(code));
 178                         return false;
 179                 }
 180
 181                 size_t i = result.find("\n");
 182                 handshake.status = result.substr(0, i);
 183                 if (handshake.status != "OK")
 184                         return false;
 185                 result = result.substr(i+1);
 186                 i = result.find("\n");
 187                 handshake.session_id = result.substr(0, i);
 188                 result = result.substr(i+1);
 189                 i = result.find("\n");
 190                 handshake.nowplaying_url = result.substr(0, i);
 191                 result = result.substr(i+1);
 192                 ignore_newlines(result);
 193                 handshake.submission_url = result;
 194                 return true;
 195         }
 196
 197         void *mpdconnection_handler(void *data)
 198         {
 199                 MPD::Connection *Mpd = static_cast<MPD::Connection *>(data);
 200                 int x = 0;
 201                 while (!scrobby_exit)
 202                 {
 203                         while (!Mpd->Connected())
 204                         {
 205                                 s.Submit();
 206                                 Log(llVerbose, "Connecting to MPD...");
 207                                 Mpd->Disconnect();
 208                                 if (Mpd->Connect())
 209                                 {
 210                                         Log(llInfo, "Connected to MPD at %s !", config.mpd_host.c_str());
 211                                         x = 0;
 212                                 }
 213                                 else
 214                                 {
 215                                         x++;
 216                                         Log(llInfo, "Cannot connect to MPD, retrieving in %d seconds...", 10*x);
 217                                         sleep(10*x);
 218                                 }
 219                         }
 220                         sleep(1);
 221                 }
 222                 pthread_exit(NULL);
 223         }
 224
 225         void *handshake_handler(void *)
 226         {
 227                 int x = 0;
 228                 while (!scrobby_exit)
 229                 {
 230                         if (handshake.status != "OK")
 231                         {
 232                                 pthread_mutex_lock(&handshake_lock);
 233                                 handshake.Clear();
 234                                 if (send_handshake() && !handshake.status.empty())
 235                                 {
 236                                         Log(llInfo, "Handshake returned %s", handshake.status.c_str());
 237                                 }
 238                                 if (handshake.status == "OK")
 239                                 {
 240                                         Log(llInfo, "Connected to Audioscrobbler!");
 241                                         if (!SongsQueue.empty())
 242                                         {
 243                                                 Log(llInfo, "Queue's not empty, submitting songs...");
 244
 245                                                 string result, postdata;
 246                                                 CURLcode code;
 247
 248                                                 pthread_mutex_lock(&curl_lock);
 249                                                 CURL *submission = curl_easy_init();
 250
 251                                                 postdata = "s=";
 252                                                 postdata += handshake.session_id;
 253
 254                                                 for (std::vector<string>::const_iterator it = SongsQueue.begin(); it != SongsQueue.end(); it++)
 255                                                         postdata += *it;
 256
 257                                                 Log(llVerbose, "URL: %s", handshake.submission_url.c_str());
 258                                                 Log(llVerbose, "Post data: %s", postdata.c_str());
 259
 260                                                 curl_easy_setopt(submission, CURLOPT_DNS_CACHE_TIMEOUT, 0);
 261                                                 curl_easy_setopt(submission, CURLOPT_NOSIGNAL, 1);
 262                                                 curl_easy_setopt(submission, CURLOPT_URL, handshake.submission_url.c_str());
 263                                                 curl_easy_setopt(submission, CURLOPT_POST, 1);
 264                                                 curl_easy_setopt(submission, CURLOPT_POSTFIELDS, postdata.c_str());
 265                                                 curl_easy_setopt(submission, CURLOPT_WRITEFUNCTION, write_data);
 266                                                 curl_easy_setopt(submission, CURLOPT_WRITEDATA, &result);
 267                                                 curl_easy_setopt(submission, CURLOPT_CONNECTTIMEOUT, curl_timeout);
 268                                                 code = curl_easy_perform(submission);
 269                                                 curl_easy_cleanup(submission);
 270                                                 pthread_mutex_unlock(&curl_lock);
 271
 272                                                 ignore_newlines(result);
 273
 274                                                 if (result == "OK")
 275                                                 {
 276                                                         Log(llInfo, "Number of submitted songs: %d", SongsQueue.size());
 277                                                         SongsQueue.clear();
 278                                                         ClearCache();
 279                                                         x = 0;
 280                                                 }
 281                                                 else
 282                                                 {
 283                                                         if (result.empty())
 284                                                         {
 285                                                                 Log(llInfo, "Error while submitting songs: %s", curl_easy_strerror(code));
 286                                                         }
 287                                                         else
 288                                                         {
 289                                                                 Log(llInfo, "Audioscrobbler returned status %s", result.c_str());
 290                                                         }
 291                                                 }
 292                                         }
 293                                         notify_about_now_playing = !s.isStream();
 294                                 }
 295                                 else
 296                                 {
 297                                         x++;
 298                                         Log(llInfo, "Connection to Audioscrobbler refused, retrieving in %d seconds...", 10*x);
 299                                 }
 300                                 pthread_mutex_unlock(&handshake_lock);
 301                         }
 302                         sleep(!x ? 1 : 10*x);
 303                 }
 304                 pthread_exit(NULL);
 305         }
 306 }
 307