git.sesse.net Git - vlc/blob - modules/misc/audioscrobbler.c

   1 /*****************************************************************************
   2  * audioscrobbler.c : audioscrobbler submission plugin
   3  *****************************************************************************
   4  * Copyright (C) 2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Rafaël Carré <rafael -dot- carre -at- wanadoo -dot- fr>
   8  *          Kenneth Ostby <kenneo -at- idi -dot- ntnu -dot- no>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  29 #define _GNU_SOURCE
  30 #include <string.h>
  31
  32 #if !defined( strlwr ) && !defined( WIN32 )
  33 #include <ctype.h>
  34 #endif
  35
  36 #if defined( WIN32 )
  37 #include <time.h>
  38 #endif
  39 /*
  40  * TODO :
  41  * review/replace :
  42  *   hexa()
  43  *   md5 to char[]
  44  */
  45 #include <vlc/vlc.h>
  46 #include <vlc/intf.h>
  47 #include <vlc_meta.h>
  48 #include <vlc_md5.h>
  49 #include <vlc_block.h>
  50 #include <vlc_stream.h>
  51 #include <vlc_url.h>
  52 #include <network.h>
  53
  54 /*****************************************************************************
  55  * Local prototypes
  56  *****************************************************************************/
  57
  58 /* Keeps track of metadata to be submitted, and if song has been submitted */
  59 typedef struct audioscrobbler_song_t
  60 {
  61     char        *psz_a;                /* track artist     */
  62     char        *psz_t;                /* track title      */
  63     char        *psz_b;                /* track album      */
  64     int         i_l;                   /* track length     */
  65 /* vlc can't retrieve musicbrainz id, so let's ignore it   */
  66 /*  int         i_m;  */               /* musicbrainz id   */
  67     char        *psz_i;                /* date             */
  68     time_t      time_playing;          /* date (epoch)     */
  69 } audioscrobbler_song_t;
  70
  71
  72 /* Queue to be submitted to server, 10 songs max */
  73 typedef struct audioscrobbler_queue_t
  74 {
  75     audioscrobbler_song_t   **p_queue;      /* contains up to 10 songs        */
  76     int                     i_songs_nb;     /* number of songs                */
  77     void                    *p_next_queue;  /* if queue full, pointer to next */
  78 } audioscrobbler_queue_t;
  79
  80 struct intf_sys_t
  81 {
  82     audioscrobbler_queue_t  *p_first_queue;     /* 1st queue              */
  83     vlc_mutex_t             lock;               /* p_sys mutex            */
  84
  85 /* data about audioscrobbler session */
  86     int                     i_interval;         /* last interval recorded */
  87     time_t                  time_last_interval; /* when was it recorded ? */
  88     char                    *psz_submit_host;   /* where to submit data ? */
  89     int                     i_submit_port;      /* at which port ?        */
  90     char                    *psz_submit_file;   /* in which file ?        */
  91     char                    *psz_username;      /* last.fm username       */
  92     vlc_bool_t              b_handshaked;       /* did we handshake ?     */
  93     int                     i_post_socket;      /* socket for submission  */
  94     char                    *psz_response_md5;  /* md5 response to use    */
  95
  96 /* data about input elements */
  97     input_thread_t          *p_input;           /* previous p_input       */
  98     audioscrobbler_song_t   *p_current_song;    /* song being played      */
  99     time_t                  time_pause;         /* time when vlc paused   */
 100     time_t                  time_total_pauses;  /* sum of time in pause   */
 101     vlc_bool_t              b_queued;           /* has it been queud ?    */
 102     vlc_bool_t              b_metadata_read;    /* did we read metadata ? */
 103     vlc_bool_t              b_paused;           /* are we playing ?       */
 104 };
 105
 106 intf_sys_t *p_sys_global;     /* for use same p_sys in all threads */
 107
 108 static int  Open    ( vlc_object_t * );
 109 static void Close   ( vlc_object_t * );
 110 static void Run     ( intf_thread_t * );
 111 static int ItemChange   ( vlc_object_t *, const char *,
 112                         vlc_value_t, vlc_value_t, void * );
 113 static int PlayingChange( vlc_object_t *, const char *,
 114                         vlc_value_t, vlc_value_t, void * );
 115 static int AddToQueue   ( intf_thread_t *p_this );
 116 static int Handshake    ( intf_thread_t *p_sd );
 117 static int ReadMetaData ( intf_thread_t *p_this );
 118 void DeleteQueue( audioscrobbler_queue_t *p_queue );
 119 char *hexa( short int i );
 120
 121 #if !defined(strlwr) && !defined( WIN32 )
 122 char* strlwr(char *psz_string);
 123 #endif
 124
 125 /*****************************************************************************
 126  * Module descriptor
 127  ****************************************************************************/
 128
 129
 130 #define APPLICATION_NAME "VLC media player"
 131 #define USERNAME_TEXT N_("Username")
 132 #define USERNAME_LONGTEXT N_("Audioscrobbler username")
 133 #define PASSWORD_TEXT N_("Password")
 134 #define PASSWORD_LONGTEXT N_("Audioscrobbler password")
 135 #define DEFAULT_INTERVAL 60
 136 #define CLIENT_NAME     PACKAGE
 137 #define CLIENT_VERSION  VERSION
 138
 139 /* HTTP POST request : to submit data */
 140 #define    POST_REQUEST "POST /%s HTTP/1.1\n"                               \
 141                         "Accept-Encoding: identity\n"                       \
 142                         "Content-length: %d\n"                              \
 143                         "Connection: close\n"                               \
 144                         "Content-type: application/x-www-form-urlencoded\n" \
 145                         "Host: %s\n"                                        \
 146                         "User-agent: VLC Media Player/%s\r\n"               \
 147                         "\r\n"                                              \
 148                         "%s\r\n"                                            \
 149                         "\r\n"
 150
 151 /* data to submit */
 152 #define POST_DATA "u=%s&s=%s&a%%5B%d%%5D=%s&t%%5B%d%%5D=%s" \
 153                   "&b%%5B%d%%5D=%s&m%%5B%d%%5D=&l%%5B%d%%5D=%d&i%%5B%d%%5D=%s"
 154
 155 vlc_module_begin();
 156     set_category( CAT_INTERFACE );
 157     set_subcategory( SUBCAT_INTERFACE_CONTROL );
 158     set_shortname( N_( "Audioscrobbler" ) );
 159     set_description( _("Audioscrobbler submission Plugin") );
 160     add_string( "lastfm-username", "", NULL,
 161                 USERNAME_TEXT, USERNAME_LONGTEXT, VLC_TRUE );
 162     add_string( "lastfm-password", "", NULL,
 163                 PASSWORD_TEXT, PASSWORD_LONGTEXT, VLC_TRUE );
 164     set_capability( "interface", 0 );
 165     set_callbacks( Open, Close );
 166 vlc_module_end();
 167
 168 /*****************************************************************************
 169  * Open: initialize and create stuff
 170  *****************************************************************************/
 171
 172 static int Open( vlc_object_t *p_this )
 173 {
 174     intf_thread_t       *p_intf;
 175     intf_sys_t          *p_sys;
 176     playlist_t          *p_playlist;
 177
 178     p_intf = ( intf_thread_t* ) p_this;
 179     p_sys = malloc( sizeof( intf_sys_t ) );
 180     if( !p_sys )
 181     {
 182       goto error;
 183     }
 184
 185     vlc_mutex_init( p_this, &p_sys->lock );
 186
 187     p_sys_global = p_sys;
 188     p_sys->psz_submit_host = NULL;
 189     p_sys->psz_submit_file = NULL;
 190     p_sys->b_handshaked = VLC_FALSE;
 191     p_sys->i_interval = 0;
 192     p_sys->time_last_interval = time( NULL );
 193     p_sys->psz_username = NULL;
 194     p_sys->p_input = NULL;
 195     p_sys->b_paused = VLC_FALSE;
 196
 197     /* md5 response is 32 chars, + final \0 */
 198     p_sys->psz_response_md5 = malloc( sizeof( char ) * 33 );
 199     if( !p_sys->psz_response_md5 )
 200     {
 201         vlc_mutex_destroy ( &p_sys->lock );
 202         goto error;
 203    }
 204
 205     p_sys->p_first_queue = malloc( sizeof( audioscrobbler_queue_t ) );
 206     if( !p_sys->p_first_queue )
 207     {
 208         vlc_mutex_destroy( &p_sys->lock );
 209         goto error;
 210     }
 211
 212     p_sys->p_current_song = malloc( sizeof( audioscrobbler_song_t ) );
 213     if( !p_sys->p_current_song )
 214     {
 215         vlc_mutex_destroy( &p_sys->lock );
 216         goto error;
 217     }
 218
 219     /* queues can't contain more than 10 songs */
 220     p_sys->p_first_queue->p_queue =
 221         malloc( 10 * sizeof( audioscrobbler_song_t ) );
 222     if( !p_sys->p_current_song )
 223     {
 224         vlc_mutex_destroy( &p_sys->lock );
 225         goto error;
 226     }
 227
 228     p_sys->p_first_queue->i_songs_nb = 0;
 229     p_sys->p_first_queue->p_next_queue = NULL;
 230
 231     p_playlist = pl_Yield( p_intf );
 232     var_AddCallback( p_playlist, "playlist-current", ItemChange, p_intf );
 233     pl_Release( p_playlist );
 234
 235     p_intf->pf_run = Run;
 236
 237     return VLC_SUCCESS;
 238
 239 error:
 240     free( p_sys->p_current_song );
 241     free( p_sys->p_first_queue );
 242     free( p_sys->psz_response_md5 );
 243     free( p_sys );
 244
 245     return VLC_ENOMEM;
 246 }
 247
 248 /*****************************************************************************
 249  * Close: destroy interface stuff
 250  *****************************************************************************/
 251 static void Close( vlc_object_t *p_this )
 252 {
 253     intf_thread_t               *p_intf;
 254     intf_sys_t                  *p_sys;
 255     audioscrobbler_queue_t      *p_current_queue, *p_next_queue;
 256     playlist_t                  *p_playlist;
 257
 258     p_intf = ( intf_thread_t* ) p_this;
 259     p_sys = p_intf->p_sys;
 260
 261     p_playlist = pl_Yield( p_intf );
 262     var_DelCallback( p_playlist, "playlist-current", ItemChange, p_intf );
 263     pl_Release( p_playlist );
 264
 265     vlc_mutex_lock ( &p_sys->lock );
 266     p_current_queue = p_sys->p_first_queue;
 267     vlc_mutex_unlock ( &p_sys->lock );
 268
 269     while( ( p_current_queue->i_songs_nb == 10 ) &&
 270         ( p_current_queue->p_next_queue != NULL ) )
 271     {
 272         p_next_queue = p_current_queue->p_next_queue;
 273         DeleteQueue( p_current_queue );
 274         free( p_current_queue );
 275         p_current_queue = p_next_queue;
 276     }
 277
 278     DeleteQueue( p_current_queue );
 279     free( p_current_queue );
 280
 281     vlc_mutex_lock ( &p_sys->lock );
 282     if ( p_sys->psz_username )
 283     {
 284         free( p_sys->psz_username );
 285     }
 286
 287     free( p_sys->p_current_song );
 288     vlc_mutex_unlock ( &p_sys->lock );
 289     vlc_mutex_destroy( &p_sys->lock );
 290     free( p_sys );
 291 }
 292
 293 /*****************************************************************************
 294  * Run : Handshake with audioscrobbler, then submit songs
 295  *****************************************************************************/
 296 static void Run( intf_thread_t *p_this )
 297 {
 298     char                    *psz_submit_string = NULL;
 299     int                     i_handshake;
 300     int                     i_netprintf;
 301     int                     i_song;
 302     playlist_t              *p_playlist;
 303     uint8_t                 *p_buffer = NULL;
 304     char                    *p_buffer_pos = NULL;
 305     time_t                  played_time;
 306     audioscrobbler_queue_t  *p_first_queue;
 307     intf_sys_t              *p_sys;
 308
 309     p_this->p_sys = p_sys_global;
 310     p_sys = p_this->p_sys;
 311     while( !p_this->b_die )
 312     {
 313         if( p_sys->b_handshaked == VLC_FALSE )
 314         {
 315             if ( time( NULL ) >=
 316                 ( p_sys->time_last_interval + p_sys->i_interval ) )
 317             {
 318                 msg_Dbg( p_this, "Handshaking with last.fm ..." );
 319                 i_handshake = Handshake( p_this );
 320
 321                 if( i_handshake == VLC_ENOMEM )
 322                 {
 323                     msg_Err( p_this, "Out of memory" );
 324                     return;
 325                 }
 326
 327                 else if( i_handshake == VLC_ENOVAR )
 328                 /* username not set */
 329                 {
 330                     msg_Dbg( p_this, "Set an username then restart vlc" );
 331                     vlc_mutex_unlock ( &p_sys->lock );
 332                     return;
 333                 }
 334
 335                 else if( i_handshake == VLC_SUCCESS )
 336                 {
 337                     msg_Dbg( p_this, "Handshake successfull :)" );
 338                     vlc_mutex_lock ( &p_sys->lock );
 339                     p_sys->b_handshaked = VLC_TRUE;
 340                     vlc_mutex_unlock ( &p_sys->lock );
 341                 }
 342
 343                 else
 344                 {
 345                     vlc_mutex_lock ( &p_sys->lock );
 346                     p_sys->i_interval = DEFAULT_INTERVAL;
 347                     time( &p_sys->time_last_interval );
 348                     vlc_mutex_unlock ( &p_sys->lock );
 349                 }
 350             }
 351         }
 352
 353         else
 354         {
 355             if ( ( p_sys->p_first_queue->i_songs_nb > 0 ) &&
 356                 ( time( NULL ) >=
 357                 ( p_sys->time_last_interval + p_sys->i_interval )  ) )
 358             {
 359                 msg_Dbg( p_this, "Going to submit some data..." );
 360                 vlc_mutex_lock ( &p_sys->lock );
 361                 psz_submit_string = malloc( 2048 * sizeof( char ) );
 362
 363                 if (!psz_submit_string)
 364                 {
 365                     msg_Err( p_this, "Out of memory" );
 366                     vlc_mutex_unlock ( &p_sys->lock );
 367                     return;
 368                 }
 369
 370                 for (i_song = 0; i_song < p_sys->p_first_queue->i_songs_nb ;
 371                     i_song++ )
 372                 {
 373                     snprintf( psz_submit_string, 2048, POST_DATA,
 374                         p_sys->psz_username, p_sys->psz_response_md5,
 375                         i_song, p_sys->p_first_queue->p_queue[i_song]->psz_a,
 376                         i_song, p_sys->p_first_queue->p_queue[i_song]->psz_t,
 377                         i_song, p_sys->p_first_queue->p_queue[i_song]->psz_b,
 378                         i_song,
 379                         i_song, p_sys->p_first_queue->p_queue[i_song]->i_l,
 380                         i_song, p_sys->p_first_queue->p_queue[i_song]->psz_i
 381                     );
 382                 }
 383
 384                 p_sys->i_post_socket = net_ConnectTCP( p_this,
 385                     p_sys->psz_submit_host, p_sys->i_submit_port);
 386
 387                 i_netprintf = net_Printf(
 388                     VLC_OBJECT(p_this), p_sys->i_post_socket, NULL,
 389                     POST_REQUEST, p_sys->psz_submit_file,
 390                     strlen( psz_submit_string), p_sys->psz_submit_file,
 391                     VERSION, psz_submit_string
 392                 );
 393
 394                 if ( i_netprintf == -1 )
 395                 {
 396                 /* If connection fails, we assume we must handshake again */
 397                     p_sys->i_interval = DEFAULT_INTERVAL;
 398                     time( &p_sys->time_last_interval );
 399                     p_sys->b_handshaked = VLC_FALSE;
 400                     vlc_mutex_unlock ( &p_sys->lock );
 401                     return;
 402                 }
 403
 404                 p_buffer = ( uint8_t* ) calloc( 1, 1024 );
 405                 if ( !p_buffer )
 406                 {
 407                     msg_Err( p_this, "Out of memory" );
 408                     vlc_mutex_unlock ( &p_sys->lock );
 409                     return;
 410                 }
 411
 412                 net_Read( p_this, p_sys->i_post_socket, NULL,
 413                           p_buffer, 1024, VLC_FALSE );
 414                 net_Close( p_sys->i_post_socket );
 415
 416                 p_buffer_pos = strstr( ( char * ) p_buffer, "INTERVAL" );
 417
 418                 if ( p_buffer_pos )
 419                 {
 420                     p_sys->i_interval = atoi( p_buffer_pos +
 421                                               strlen( "INTERVAL " ) );
 422                     time( &p_sys->time_last_interval );
 423                 }
 424
 425                 p_buffer_pos = strstr( ( char * ) p_buffer, "FAILED" );
 426
 427                 if ( p_buffer_pos )
 428                 {
 429                     msg_Err( p_this, p_buffer_pos );
 430                     vlc_mutex_unlock ( &p_sys->lock );
 431                     return;
 432                 }
 433
 434                 p_buffer_pos = strstr( ( char * ) p_buffer, "BADAUTH" );
 435
 436                 if ( p_buffer_pos )
 437                 {
 438                     msg_Err( p_this,
 439                              "Authentification failed, handshaking again" );
 440                     p_sys->b_handshaked = VLC_FALSE;
 441                     vlc_mutex_unlock ( &p_sys->lock );
 442                     return;
 443                 }
 444
 445                 p_buffer_pos = strstr( ( char * ) p_buffer, "OK" );
 446
 447                 if ( p_buffer_pos )
 448                 {
 449                     if ( p_sys->p_first_queue->i_songs_nb == 10 )
 450                     {
 451                         p_first_queue = p_sys->p_first_queue->p_next_queue;
 452                         DeleteQueue( p_sys->p_first_queue );
 453                         free( p_sys->p_first_queue );
 454                         p_sys->p_first_queue = p_first_queue;
 455                     }
 456                     else
 457                     {
 458                         DeleteQueue( p_sys->p_first_queue );
 459                         p_sys->p_first_queue->i_songs_nb = 0;
 460                     }
 461                     msg_Dbg( p_this, "Submission successfull!" );
 462                 }
 463                 vlc_mutex_unlock ( &p_sys->lock );
 464             }
 465         }
 466         msleep( INTF_IDLE_SLEEP );
 467
 468         p_playlist = pl_Yield( p_this );
 469         PL_LOCK;
 470         if( p_playlist->request.i_status == PLAYLIST_STOPPED )
 471         {
 472             PL_UNLOCK;
 473             /* if we stopped, we won't submit playing song */
 474             vlc_mutex_lock( &p_sys->lock );
 475             p_sys->b_queued = VLC_TRUE;
 476             p_sys->b_metadata_read = VLC_TRUE;
 477             vlc_mutex_unlock( &p_sys->lock );
 478         }
 479
 480         pl_Release( p_playlist );
 481         vlc_mutex_lock( &p_sys->lock );
 482
 483         if( p_sys->b_metadata_read == VLC_FALSE )
 484         {
 485             time( &played_time );
 486             played_time -= p_sys->p_current_song->time_playing;
 487             played_time -= p_sys->time_total_pauses;
 488
 489
 490             vlc_mutex_unlock( &p_sys->lock );
 491
 492             /* ok now we can read meta data */
 493             if( played_time > 10 )
 494             {
 495                 ReadMetaData( p_this );
 496             }
 497         }
 498         else
 499         {
 500             if( ( p_sys->b_queued == VLC_FALSE )
 501                 && ( p_sys->b_paused == VLC_FALSE ) )
 502             {
 503                 vlc_mutex_unlock( &p_sys->lock );
 504                 if( AddToQueue( p_this ) == VLC_ENOMEM )
 505                 {
 506                     msg_Err( p_this, "Out of memory" );
 507                     return;
 508                 }
 509             }
 510             else
 511             {
 512                 vlc_mutex_unlock( &p_sys->lock );
 513             }
 514         }
 515     }
 516 }
 517
 518 /*****************************************************************************
 519  * PlayingChange: Playing status change callback
 520  *****************************************************************************/
 521 static int PlayingChange( vlc_object_t *p_this, const char *psz_var,
 522                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 523 {
 524     intf_thread_t       *p_intf;
 525     intf_sys_t          *p_sys;
 526
 527     p_intf = ( intf_thread_t* ) p_data;
 528     p_sys = p_intf->p_sys;
 529
 530     (void)p_this; (void)psz_var; (void)oldval;
 531
 532     vlc_mutex_lock( &p_sys->lock );
 533
 534     if( newval.i_int == PAUSE_S )
 535     {
 536         time( &p_sys->time_pause );
 537         p_sys->b_paused = VLC_TRUE;
 538     }
 539
 540     if( newval.i_int == PLAYING_S )
 541     {
 542         p_sys->time_total_pauses += time( NULL ) - p_sys->time_pause;
 543         p_sys->b_paused = VLC_TRUE;
 544     }
 545
 546     vlc_mutex_unlock( &p_sys->lock );
 547
 548     return VLC_SUCCESS;
 549 }
 550
 551 /*****************************************************************************
 552  * ItemChange: Playlist item change callback
 553  *****************************************************************************/
 554 static int ItemChange( vlc_object_t *p_this, const char *psz_var,
 555                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 556 {
 557     playlist_t          *p_playlist;
 558     input_thread_t      *p_input = NULL;
 559     intf_thread_t       *p_intf;
 560     intf_sys_t          *p_sys;
 561
 562     time_t              epoch;
 563     struct tm           *epoch_tm;
 564
 565     char                psz_date[20];
 566
 567     (void)p_this; (void)psz_var; (void)oldval; (void)newval;
 568
 569     p_intf = ( intf_thread_t* ) p_data;
 570     p_sys = p_intf->p_sys;
 571
 572     vlc_mutex_lock ( &p_sys->lock );
 573
 574     if ( p_sys->p_input )
 575     {
 576         /* we delete the callback for the old p_input */
 577         var_DelCallback( p_sys->p_input, "state", PlayingChange, p_intf );
 578     }
 579
 580     vlc_mutex_unlock ( &p_sys->lock );
 581
 582     p_playlist = pl_Yield( p_intf );
 583     PL_LOCK;
 584     p_input = p_playlist->p_input;
 585
 586     if( !p_input )
 587     {
 588         PL_UNLOCK;
 589         pl_Release( p_playlist );
 590         vlc_mutex_lock( &p_sys->lock );
 591
 592         /* we won't read p_input */
 593         p_sys->b_queued = VLC_TRUE;
 594         p_sys->b_metadata_read = VLC_TRUE;
 595
 596         vlc_mutex_unlock( &p_sys->lock );
 597         return VLC_SUCCESS;
 598     }
 599
 600     vlc_object_yield( p_input );
 601     PL_UNLOCK;
 602     pl_Release( p_playlist );
 603
 604     var_AddCallback( p_input, "state", PlayingChange, p_intf );
 605
 606     vlc_mutex_lock ( &p_sys->lock );
 607
 608     /* reset pause counter */
 609     p_sys->time_total_pauses = 0;
 610
 611     /* we save the p_input value to delete the callback later */
 612     p_sys->p_input = p_input;
 613
 614     /* we'll read after to be sure it's present */
 615     p_sys->b_metadata_read = VLC_FALSE;
 616
 617     p_sys->b_queued = VLC_TRUE;
 618
 619     time( &epoch );
 620     epoch_tm = gmtime( &epoch );
 621     snprintf( psz_date, 20, "%.4d-%.2d-%.2d %.2d:%.2d:%.2d",
 622         epoch_tm->tm_year+1900, epoch_tm->tm_mon+1, epoch_tm->tm_mday,
 623         epoch_tm->tm_hour, epoch_tm->tm_min, epoch_tm->tm_sec );
 624
 625     p_sys->p_current_song->psz_i = encode_URI_component( psz_date );
 626     p_sys->p_current_song->time_playing = epoch;
 627
 628     p_sys->b_paused = ( p_input->b_dead || !p_input->input.p_item->psz_name )
 629                       ? VLC_TRUE : VLC_FALSE;
 630
 631     vlc_mutex_unlock( &p_sys->lock );
 632
 633     vlc_object_release( p_input );
 634     return VLC_SUCCESS;
 635 }
 636
 637 /*****************************************************************************
 638  * AddToQueue: Add the played song to the queue to be submitted
 639  *****************************************************************************/
 640 static int AddToQueue ( intf_thread_t *p_this )
 641 {
 642     int                         i_songs_nb;
 643     time_t                      played_time;
 644     audioscrobbler_queue_t      *p_queue = NULL, *p_next_queue = NULL;
 645     intf_sys_t                  *p_sys;
 646
 647     p_sys = p_this->p_sys;
 648
 649     /* has it been queued already ? is it long enough ? */
 650     vlc_mutex_lock( &p_sys->lock );
 651     if( p_sys->p_current_song->i_l < 30 )
 652     {
 653         msg_Dbg( p_this, "Song too short (< 30s) -> not submitting" );
 654         p_sys->b_queued = VLC_TRUE;
 655         vlc_mutex_unlock ( &p_sys->lock );
 656         return VLC_SUCCESS;
 657     }
 658
 659     /* wait for the user to listen enough before submitting */
 660     time ( &played_time );
 661     played_time -= p_sys->p_current_song->time_playing;
 662     played_time -= p_sys->time_total_pauses;
 663
 664     if( ( played_time < 240 )
 665         && ( played_time < ( p_sys->p_current_song->i_l / 2 ) ) )
 666     {
 667         vlc_mutex_unlock ( &p_sys->lock );
 668         return VLC_SUCCESS;
 669     }
 670
 671     msg_Dbg( p_this, "Ok. We'll put it in the queue for submission" );
 672
 673     p_queue = p_sys->p_first_queue;
 674
 675     while( ( p_queue->i_songs_nb == 10 ) && ( p_queue->p_next_queue != NULL ) )
 676     {
 677         p_queue = p_queue->p_next_queue;
 678     }
 679
 680     i_songs_nb = p_queue->i_songs_nb;
 681
 682     if( i_songs_nb == 10 )
 683     {
 684         p_next_queue = malloc( sizeof( audioscrobbler_queue_t ) );
 685         if( !p_next_queue )
 686         {
 687             vlc_mutex_unlock ( &p_sys->lock );
 688             return VLC_ENOMEM;
 689         }
 690         p_queue->p_next_queue = p_next_queue;
 691         i_songs_nb = 0;
 692         p_queue = p_next_queue;
 693         p_queue->i_songs_nb = i_songs_nb;
 694     }
 695
 696     p_queue->p_queue[i_songs_nb] = malloc( sizeof( audioscrobbler_song_t ) );
 697
 698     p_queue->p_queue[i_songs_nb]->i_l = p_sys->p_current_song->i_l;
 699
 700     p_queue->p_queue[i_songs_nb]->psz_a =
 701         strdup( p_sys->p_current_song->psz_a );
 702
 703     p_queue->p_queue[i_songs_nb]->psz_t =
 704         strdup( p_sys->p_current_song->psz_t );
 705
 706     p_queue->p_queue[i_songs_nb]->psz_b =
 707         strdup( p_sys->p_current_song->psz_b );
 708
 709     p_queue->p_queue[i_songs_nb]->psz_i =
 710         strdup( p_sys->p_current_song->psz_i );
 711
 712     p_queue->i_songs_nb++;
 713     p_sys->b_queued = VLC_TRUE;
 714
 715     vlc_mutex_unlock( &p_sys->lock );
 716
 717     return VLC_SUCCESS;
 718 }
 719
 720 /*****************************************************************************
 721  * Handshake : Init audioscrobbler connection
 722  *****************************************************************************/
 723 static int Handshake( intf_thread_t *p_this )
 724 {
 725     char                *psz_password = NULL;
 726     struct md5_s        *p_struct_md5 = NULL;
 727     char                *psz_password_md5 = NULL;
 728     char                *ps_challenge_md5 = NULL;
 729
 730     stream_t            *p_stream;
 731     char                *psz_handshake_url = NULL;
 732
 733     uint8_t             *p_buffer = NULL;
 734     char                *p_buffer_pos = NULL;
 735     char                *psz_buffer_substring = NULL;
 736     char                *psz_url_parser = NULL;
 737     int                 i_url_pos, i;
 738
 739     char                *b1, *b2, *b3, *b4;
 740
 741     intf_thread_t       *p_intf;
 742     intf_sys_t          *p_sys;
 743
 744     p_intf = ( intf_thread_t* ) p_this;
 745     p_sys = p_this->p_sys;
 746
 747     vlc_mutex_lock ( &p_sys->lock );
 748
 749     p_sys->psz_username = config_GetPsz(p_this, "lastfm-username");
 750     if ( !p_sys->psz_username )
 751     {
 752         goto memerror;
 753     }
 754
 755
 756     if ( !*p_sys->psz_username )
 757     {
 758         msg_Info( p_this, "You have to set an username! "
 759          "Visit https://www.last.fm/join/" );
 760         return VLC_ENOVAR;
 761     }
 762
 763     psz_handshake_url = malloc( 1024 );
 764     if ( !psz_handshake_url )
 765     {
 766         goto memerror;
 767     }
 768
 769     snprintf( psz_handshake_url, 1024,
 770         "http://post.audioscrobbler.com/?hs=true&p=1.1&c=%s&v=%s&u=%s",
 771         CLIENT_NAME, CLIENT_VERSION, p_sys->psz_username );
 772
 773     p_stream = stream_UrlNew( p_intf, psz_handshake_url);
 774
 775     free( psz_handshake_url );
 776
 777     if( !p_stream )
 778     {
 779         p_sys->i_interval = DEFAULT_INTERVAL;
 780         time( &p_sys->time_last_interval );
 781         vlc_mutex_unlock ( &p_sys->lock );
 782         return VLC_EGENERIC;
 783     }
 784
 785     p_buffer = ( uint8_t* ) calloc( 1, 1024 );
 786     if ( !p_buffer )
 787     {
 788         stream_Delete( p_stream );
 789         goto memerror;
 790     }
 791
 792     if ( stream_Read( p_stream, p_buffer, 1024 ) == 0 )
 793     {
 794         stream_Delete( p_stream );
 795         free( p_buffer );
 796         vlc_mutex_unlock ( &p_sys->lock );
 797         return VLC_EGENERIC;
 798     }
 799
 800     stream_Delete( p_stream );
 801
 802     p_buffer_pos = strstr( ( char * ) p_buffer, "INTERVAL" );
 803
 804     if ( p_buffer_pos )
 805     {
 806         p_sys->i_interval = atoi( p_buffer_pos + strlen( "INTERVAL " ) );
 807         time( &p_sys->time_last_interval );
 808     }
 809
 810     p_buffer_pos = strstr( ( char * ) p_buffer, "FAILED" );
 811
 812     if ( p_buffer_pos )
 813     {
 814         msg_Info( p_this, p_buffer_pos );
 815         free( p_buffer );
 816         vlc_mutex_unlock ( &p_sys->lock );
 817         return VLC_EGENERIC;
 818     }
 819
 820     p_buffer_pos = strstr( ( char * ) p_buffer, "BADUSER" );
 821
 822     if ( p_buffer_pos )
 823     {
 824         msg_Info( p_intf, "Username is incorrect" );
 825         free( p_buffer );
 826         vlc_mutex_unlock ( &p_sys->lock );
 827         return VLC_EGENERIC;
 828     }
 829
 830     p_buffer_pos = strstr( ( char * ) p_buffer, "UPDATE" );
 831
 832     if ( p_buffer_pos )
 833     {
 834         msg_Dbg( p_intf, "Protocol updated" );
 835         msg_Dbg( p_intf, p_buffer_pos );
 836     }
 837
 838     else
 839     {
 840         p_buffer_pos = strstr( ( char * ) p_buffer, "UPTODATE" );
 841         if ( !p_buffer_pos )
 842         {
 843             msg_Dbg( p_intf, "Protocol error" );
 844             free( p_buffer );
 845             vlc_mutex_unlock ( &p_sys->lock );
 846             return VLC_EGENERIC;
 847         }
 848     }
 849
 850     psz_buffer_substring = strndup( strstr( p_buffer_pos, "\n" ) + 1, 32 );
 851     if ( !psz_buffer_substring )
 852     {
 853         goto memerror;
 854     }
 855     else
 856     {
 857         ps_challenge_md5 = malloc( sizeof( char ) * 32 );
 858         if ( !ps_challenge_md5 )
 859         {
 860             goto memerror;
 861         }
 862         memcpy( ps_challenge_md5, psz_buffer_substring, 32 );
 863         free( psz_buffer_substring );
 864     }
 865
 866     p_buffer_pos = ( void* ) strstr( ( char* ) p_buffer, "http://" );
 867
 868     if ( p_sys->psz_submit_host != NULL )
 869     {
 870         free( p_sys->psz_submit_host );
 871     }
 872
 873     if ( p_sys->psz_submit_file != NULL )
 874     {
 875         free( p_sys->psz_submit_file );
 876     }
 877
 878     psz_url_parser = p_buffer_pos + strlen( "http://" );
 879
 880     i_url_pos = strcspn( psz_url_parser, ":" );
 881     p_sys->psz_submit_host = strndup( psz_url_parser, i_url_pos );
 882
 883     p_sys->i_submit_port = atoi( psz_url_parser + i_url_pos + 1 );
 884
 885     psz_url_parser += strcspn( psz_url_parser , "/" ) + 1;
 886     i_url_pos = strcspn( psz_url_parser, "\n" );
 887     p_sys->psz_submit_file = strndup( psz_url_parser, i_url_pos );
 888
 889     free(p_buffer);
 890
 891     p_struct_md5 = malloc( sizeof( struct md5_s ) );
 892     if( !p_struct_md5 )
 893     {
 894         goto memerror;
 895     }
 896
 897     psz_password = config_GetPsz(p_this, "lastfm-password");
 898     if ( !psz_password )
 899     {
 900          goto memerror;
 901     }
 902
 903     InitMD5( p_struct_md5 );
 904     AddMD5( p_struct_md5, ( uint8_t* ) psz_password, strlen( psz_password ) );
 905     EndMD5( p_struct_md5 );
 906
 907     free( psz_password );
 908
 909     psz_password_md5 = malloc ( 33 * sizeof( char ) );
 910     if ( !psz_password_md5 )
 911     {
 912         goto memerror;
 913     }
 914
 915     for ( i = 0; i < 4; i++ )
 916     {
 917     /* TODO check that this works on every arch/platform (uint32_t to char) */
 918         b1 = hexa( p_struct_md5->p_digest[i] % 256 );
 919         b2 = hexa( ( p_struct_md5->p_digest[i] / 256 ) % 256 );
 920         b3 = hexa( ( p_struct_md5->p_digest[i] / 65536 ) % 256 );
 921         b4 = hexa( p_struct_md5->p_digest[i] / 16777216 );
 922         sprintf( &psz_password_md5[8*i], "%s%s%s%s", b1, b2, b3, b4 );
 923         free( b1 );
 924         free( b2 );
 925         free( b3 );
 926         free( b4 );
 927     }
 928
 929     strlwr( psz_password_md5 );
 930
 931     InitMD5( p_struct_md5 );
 932     AddMD5( p_struct_md5, ( uint8_t* ) psz_password_md5, 32 );
 933     AddMD5( p_struct_md5, ( uint8_t* ) ps_challenge_md5, 32 );
 934     EndMD5( p_struct_md5 );
 935
 936     free( ps_challenge_md5 );
 937     free( psz_password_md5 );
 938
 939     for ( i = 0; i < 4; i++ )
 940     {
 941         b1 = hexa( p_struct_md5->p_digest[i] % 256 );
 942         b2 = hexa( ( p_struct_md5->p_digest[i] / 256 ) % 256 );
 943         b3 = hexa( ( p_struct_md5->p_digest[i] / 65536 ) % 256 );
 944         b4 = hexa( p_struct_md5->p_digest[i] / 16777216 );
 945         sprintf( &p_sys->psz_response_md5[8*i],"%s%s%s%s", b1, b2, b3, b4 );
 946         free( b1 );
 947         free( b2 );
 948         free( b3 );
 949         free( b4 );
 950     }
 951
 952     p_sys->psz_response_md5[32] = 0;
 953
 954     strlwr( p_sys->psz_response_md5 );
 955
 956     vlc_mutex_unlock ( &p_sys->lock );
 957
 958     return VLC_SUCCESS;
 959
 960 memerror:
 961     free( p_buffer );
 962     free( p_struct_md5 );
 963     free( psz_buffer_substring );
 964
 965     vlc_mutex_unlock ( &p_sys->lock );
 966     return VLC_ENOMEM;
 967 }
 968
 969 /*****************************************************************************
 970  * hexa : Converts a byte to a string in its hexadecimal value
 971  *****************************************************************************/
 972 char *hexa( short int i )
 973 {
 974     char        *res = calloc( 3 , sizeof( char ) );
 975
 976     ((i/16) < 10) ? res[0] = (i / 16) + '0' : ( res[0] = (i/16) + 'a' - 10 );
 977     ((i%16) < 10) ? res[1] = (i % 16) + '0' : ( res[1] = (i%16) + 'a' - 10 );
 978
 979     return res;
 980 }
 981 /*****************************************************************************
 982  * strlwr : Converts a string to lower case
 983  *****************************************************************************/
 984 #if !defined(strlwr) && !defined( WIN32 )
 985 char* strlwr(char *psz_string)
 986 {
 987     while ( *psz_string )
 988     {
 989         *psz_string++ = tolower( *psz_string );
 990     }
 991     return psz_string;
 992 }
 993 #endif
 994
 995 /*****************************************************************************
 996  * DeleteQueue : Free all songs from an audioscrobbler_queue_t
 997  *****************************************************************************/
 998 void DeleteQueue( audioscrobbler_queue_t *p_queue )
 999 {
1000     int     i;
1001
1002     for( i = 0; i < p_queue->i_songs_nb; i++ )
1003     {
1004         free( p_queue->p_queue[i]->psz_a );
1005         free( p_queue->p_queue[i]->psz_b );
1006         free( p_queue->p_queue[i]->psz_t );
1007         free( p_queue->p_queue[i]->psz_i );
1008         free( p_queue->p_queue[i] );
1009     }
1010 }
1011
1012 /*****************************************************************************
1013  * ReadMetaData : Puts current song's meta data in p_sys->p_current_song
1014  *****************************************************************************/
1015 static int ReadMetaData( intf_thread_t *p_this )
1016 {
1017     playlist_t          *p_playlist;
1018     char                *psz_title = NULL;
1019     char                *psz_artist = NULL;
1020     char                *psz_album = NULL;
1021     int                 i_length = -1;
1022     input_thread_t      *p_input = NULL;
1023     vlc_value_t         video_val;
1024     intf_sys_t          *p_sys;
1025
1026     p_sys = p_this->p_sys;
1027     p_playlist = pl_Yield( p_this );
1028     PL_LOCK;
1029     p_input = p_playlist->p_input;
1030
1031     if( !p_input )
1032     {
1033         return VLC_SUCCESS;
1034     }
1035
1036     vlc_object_yield( p_input );
1037     PL_UNLOCK;
1038     pl_Release( p_playlist );
1039
1040     if ( p_input->input.p_item->i_type == ITEM_TYPE_NET )
1041     {
1042         msg_Dbg( p_this, "We play a stream -> no submission");
1043         goto no_submission;
1044     }
1045
1046     var_Change( p_input, "video-es", VLC_VAR_CHOICESCOUNT, &video_val, NULL );
1047     if( video_val.i_int > 0 )
1048     {
1049         msg_Dbg( p_this, "We play a video -> no submission");
1050         goto no_submission;
1051     }
1052
1053     if ( p_input->input.p_item->p_meta->psz_artist )
1054     {
1055         psz_artist = encode_URI_component(
1056             p_input->input.p_item->p_meta->psz_artist );
1057         if ( !psz_artist )
1058         {
1059             goto error;
1060         }
1061     }
1062     else
1063     {
1064         msg_Dbg( p_this, "No artist.." );
1065         goto no_submission;
1066     }
1067
1068     if ( p_input->input.p_item->p_meta->psz_album )
1069     {
1070         psz_album = encode_URI_component(
1071             p_input->input.p_item->p_meta->psz_album );
1072         if ( !psz_album )
1073         {
1074             goto error;
1075         }
1076     }
1077     else
1078     {
1079         msg_Dbg( p_this, "No album.." );
1080         goto no_submission;
1081     }
1082
1083     if ( p_input->input.p_item->psz_name )
1084     {
1085         psz_title = encode_URI_component( p_input->input.p_item->psz_name );
1086         if ( !psz_title )
1087         {
1088             goto error;
1089         }
1090     }
1091     else
1092     {
1093         msg_Dbg( p_this, "No track name.." );
1094         goto no_submission;
1095     }
1096
1097     i_length = p_input->input.p_item->i_duration / 1000000;
1098
1099     vlc_object_release( p_input );
1100
1101     vlc_mutex_lock ( &p_sys->lock );
1102
1103     p_sys->p_current_song->psz_a = strdup( psz_artist );
1104     p_sys->p_current_song->psz_t = strdup( psz_title );
1105     p_sys->p_current_song->psz_b = strdup( psz_album );
1106     p_sys->p_current_song->i_l = i_length;
1107     p_sys->b_queued = VLC_FALSE;
1108     p_sys->b_metadata_read = VLC_TRUE;
1109
1110     vlc_mutex_unlock ( &p_sys->lock );
1111
1112     msg_Dbg( p_this, "Meta data registered, waiting to be queued" );
1113
1114     free( psz_title );
1115     free( psz_artist );
1116     free( psz_album );
1117
1118     return VLC_SUCCESS;
1119
1120 error:
1121     free( psz_artist );
1122     free( psz_album );
1123     free( psz_title );
1124     return VLC_ENOMEM;
1125
1126 no_submission:
1127     vlc_object_release( p_input );
1128
1129     free( psz_title );
1130     free( psz_artist );
1131     free( psz_album );
1132
1133     vlc_mutex_lock( &p_sys->lock );
1134     p_sys->b_queued = VLC_TRUE;
1135     p_sys->b_metadata_read = VLC_TRUE;
1136     vlc_mutex_unlock( &p_sys->lock );
1137
1138     return VLC_SUCCESS;
1139 }