Skip to content

V
vlc-gpu
Commit 28f90a27 authored by Rafaël Carré's avatar Rafaël Carré
Browse files
Options

audioscrobbler: clean up 

- cosmetics ( xx ) -> (xx) (look at patch with -w)
- remove useless header inclusion
- move some variables from p_sys to Run() function scope
- fix invalid asprintf() return value checks
...
parent 58267d2b
Hide whitespace changes
Inline Side-by-side
Showing with 339 additions and 382 deletions
modules/misc/audioscrobbler.c
View file @ 28f90a27
/***************************************************************************** /*****************************************************************************
* audioscrobbler.c : audioscrobbler submission plugin * audioscrobbler.c : audioscrobbler submission plugin
***************************************************************************** *****************************************************************************
* Copyright © 2006-2009 the VideoLAN team * Copyright © 2006-2011 the VideoLAN team
* $Id$ * $Id$
* *
* Author: Rafaël Carré <funman at videolanorg> * Author: Rafaël Carré <funman at videolanorg>
...@@ -32,10 +32,6 @@ ...@@ -32,10 +32,6 @@
* Preamble * Preamble
*****************************************************************************/ *****************************************************************************/
#if defined( WIN32 )
#include <time.h>
#endif
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
# include "config.h" # include "config.h"
#endif #endif
...@@ -78,10 +74,6 @@ struct intf_sys_t ...@@ -78,10 +74,6 @@ struct intf_sys_t
vlc_mutex_t lock; /**< p_sys mutex */ vlc_mutex_t lock; /**< p_sys mutex */
vlc_cond_t wait; /**< song to submit event */ vlc_cond_t wait; /**< song to submit event */
/* data about audioscrobbler session */
mtime_t next_exchange; /**< when can we send data */
unsigned int i_interval; /**< waiting interval (secs)*/
/* submission of played songs */ /* submission of played songs */
char *psz_submit_host; /**< where to submit data */ char *psz_submit_host; /**< where to submit data */
int i_submit_port; /**< port to which submit */ int i_submit_port; /**< port to which submit */
...@@ -93,7 +85,6 @@ struct intf_sys_t ...@@ -93,7 +85,6 @@ struct intf_sys_t
int i_nowp_port; /**< port to which submit */ int i_nowp_port; /**< port to which submit */
char *psz_nowp_file; /**< file to which submit */ char *psz_nowp_file; /**< file to which submit */
#endif #endif
bool b_handshaked; /**< are we authenticated ? */
char psz_auth_token[33]; /**< Authentication token */ char psz_auth_token[33]; /**< Authentication token */
/* data about song currently playing */ /* data about song currently playing */
...@@ -111,9 +102,9 @@ struct intf_sys_t ...@@ -111,9 +102,9 @@ struct intf_sys_t
* metadata already */ * metadata already */
}; };
static int Open ( vlc_object_t * ); static int Open (vlc_object_t *);
static void Close ( vlc_object_t * ); static void Close (vlc_object_t *);
static void Run ( intf_thread_t * ); static void Run (intf_thread_t *);
/***************************************************************************** /*****************************************************************************
* Module descriptor * Module descriptor
...@@ -133,128 +124,116 @@ static void Run ( intf_thread_t * ); ...@@ -133,128 +124,116 @@ static void Run ( intf_thread_t * );
#define CLIENT_NAME PACKAGE #define CLIENT_NAME PACKAGE
#define CLIENT_VERSION VERSION #define CLIENT_VERSION VERSION
/* HTTP POST request : to submit data */
#define POST_REQUEST "POST /%s HTTP/1.1\n" \
"Accept-Encoding: identity\n" \
"Content-length: %u\n" \
"Connection: close\n" \
"Content-type: application/x-www-form-urlencoded\n" \
"Host: %s\n" \
"User-agent: VLC media player/%s\r\n" \
"\r\n" \
"%s\r\n" \
"\r\n"
vlc_module_begin () vlc_module_begin ()
set_category( CAT_INTERFACE ) set_category(CAT_INTERFACE)
set_subcategory( SUBCAT_INTERFACE_CONTROL ) set_subcategory(SUBCAT_INTERFACE_CONTROL)
set_shortname( N_( "Audioscrobbler" ) ) set_shortname(N_("Audioscrobbler"))
set_description( N_("Submission of played songs to last.fm") ) set_description(N_("Submission of played songs to last.fm"))
add_string( "lastfm-username", "", add_string("lastfm-username", "",
USERNAME_TEXT, USERNAME_LONGTEXT, false ) USERNAME_TEXT, USERNAME_LONGTEXT, false)
add_password( "lastfm-password", "", add_password("lastfm-password", "",
PASSWORD_TEXT, PASSWORD_LONGTEXT, false ) PASSWORD_TEXT, PASSWORD_LONGTEXT, false)
add_string( "scrobbler-url", "post.audioscrobbler.com", add_string("scrobbler-url", "post.audioscrobbler.com",
URL_TEXT, URL_LONGTEXT, false ) URL_TEXT, URL_LONGTEXT, false)
set_capability( "interface", 0 ) set_capability("interface", 0)
set_callbacks( Open, Close ) set_callbacks(Open, Close)
vlc_module_end () vlc_module_end ()
/***************************************************************************** /*****************************************************************************
* DeleteSong : Delete the char pointers in a song * DeleteSong : Delete the char pointers in a song
*****************************************************************************/ *****************************************************************************/
static void DeleteSong( audioscrobbler_song_t* p_song ) static void DeleteSong(audioscrobbler_song_t* p_song)
{ {
FREENULL( p_song->psz_a ); FREENULL(p_song->psz_a);
FREENULL( p_song->psz_b ); FREENULL(p_song->psz_b);
FREENULL( p_song->psz_t ); FREENULL(p_song->psz_t);
FREENULL( p_song->psz_m ); FREENULL(p_song->psz_m);
FREENULL( p_song->psz_n ); FREENULL(p_song->psz_n);
} }
/***************************************************************************** /*****************************************************************************
* ReadMetaData : Read meta data when parsed by vlc * ReadMetaData : Read meta data when parsed by vlc
*****************************************************************************/ *****************************************************************************/
static void ReadMetaData( intf_thread_t *p_this ) static void ReadMetaData(intf_thread_t *p_this)
{ {
input_thread_t *p_input; input_thread_t *p_input;
input_item_t *p_item; input_item_t *p_item;
intf_sys_t *p_sys = p_this->p_sys; intf_sys_t *p_sys = p_this->p_sys;
p_input = playlist_CurrentInput( pl_Get( p_this ) ); p_input = playlist_CurrentInput(pl_Get(p_this));
if( !p_input ) if (!p_input)
return; return;
p_item = input_GetItem( p_input ); p_item = input_GetItem(p_input);
if( !p_item ) if (!p_item)
{ {
vlc_object_release( p_input ); vlc_object_release(p_input);
return; return;
} }
#define ALLOC_ITEM_META( a, b ) do { \ #define ALLOC_ITEM_META(a, b) do { \
char *psz_meta = input_item_Get##b( p_item ); \ char *psz_meta = input_item_Get##b(p_item); \
if( psz_meta && *psz_meta ) \ if (psz_meta && *psz_meta) \
a = encode_URI_component( psz_meta ); \ a = encode_URI_component(psz_meta); \
free( psz_meta ); \ free(psz_meta); \
} while(0) } while (0)
vlc_mutex_lock( &p_sys->lock ); vlc_mutex_lock(&p_sys->lock);
p_sys->b_meta_read = true; p_sys->b_meta_read = true;
ALLOC_ITEM_META( p_sys->p_current_song.psz_a, Artist ); ALLOC_ITEM_META(p_sys->p_current_song.psz_a, Artist);
if( !p_sys->p_current_song.psz_a ) if (!p_sys->p_current_song.psz_a)
{ {
msg_Dbg( p_this, "No artist.." ); msg_Dbg(p_this, "No artist..");
DeleteSong( &p_sys->p_current_song ); DeleteSong(&p_sys->p_current_song);
goto end; goto end;
} }
ALLOC_ITEM_META( p_sys->p_current_song.psz_t, Title ); ALLOC_ITEM_META(p_sys->p_current_song.psz_t, Title);
if( !p_sys->p_current_song.psz_t ) if (!p_sys->p_current_song.psz_t)
{ {
msg_Dbg( p_this, "No track name.." ); msg_Dbg(p_this, "No track name..");
DeleteSong( &p_sys->p_current_song ); DeleteSong(&p_sys->p_current_song);
goto end; goto end;
} }
/* Now we have read the mandatory meta data, so we can submit that info */ /* Now we have read the mandatory meta data, so we can submit that info */
p_sys->b_submit = true; p_sys->b_submit = true;
ALLOC_ITEM_META( p_sys->p_current_song.psz_b, Album ); ALLOC_ITEM_META(p_sys->p_current_song.psz_b, Album);
if( !p_sys->p_current_song.psz_b ) if (!p_sys->p_current_song.psz_b)
p_sys->p_current_song.psz_b = calloc( 1, 1 ); p_sys->p_current_song.psz_b = calloc(1, 1);
ALLOC_ITEM_META( p_sys->p_current_song.psz_m, TrackID ); ALLOC_ITEM_META(p_sys->p_current_song.psz_m, TrackID);
if( !p_sys->p_current_song.psz_m ) if (!p_sys->p_current_song.psz_m)
p_sys->p_current_song.psz_m = calloc( 1, 1 ); p_sys->p_current_song.psz_m = calloc(1, 1);
p_sys->p_current_song.i_l = input_item_GetDuration( p_item ) / 1000000; p_sys->p_current_song.i_l = input_item_GetDuration(p_item) / 1000000;
ALLOC_ITEM_META( p_sys->p_current_song.psz_n, TrackNum ); ALLOC_ITEM_META(p_sys->p_current_song.psz_n, TrackNum);
if( !p_sys->p_current_song.psz_n ) if (!p_sys->p_current_song.psz_n)
p_sys->p_current_song.psz_n = calloc( 1, 1 ); p_sys->p_current_song.psz_n = calloc(1, 1);
#undef ALLOC_ITEM_META #undef ALLOC_ITEM_META
msg_Dbg( p_this, "Meta data registered" ); msg_Dbg(p_this, "Meta data registered");
end: end:
vlc_mutex_unlock( &p_sys->lock ); vlc_mutex_unlock(&p_sys->lock);
vlc_object_release( p_input ); vlc_object_release(p_input);
} }
/***************************************************************************** /*****************************************************************************
* AddToQueue: Add the played song to the queue to be submitted * AddToQueue: Add the played song to the queue to be submitted
*****************************************************************************/ *****************************************************************************/
static void AddToQueue ( intf_thread_t *p_this ) static void AddToQueue (intf_thread_t *p_this)
{ {
mtime_t played_time; mtime_t played_time;
intf_sys_t *p_sys = p_this->p_sys; intf_sys_t *p_sys = p_this->p_sys;
vlc_mutex_lock( &p_sys->lock ); vlc_mutex_lock(&p_sys->lock);
if( !p_sys->b_submit ) if (!p_sys->b_submit)
goto end; goto end;
/* wait for the user to listen enough before submitting */ /* wait for the user to listen enough before submitting */
...@@ -264,110 +243,107 @@ static void AddToQueue ( intf_thread_t *p_this ) ...@@ -264,110 +243,107 @@ static void AddToQueue ( intf_thread_t *p_this )
/*HACK: it seam that the preparsing sometime fail, /*HACK: it seam that the preparsing sometime fail,
so use the playing time as the song length */ so use the playing time as the song length */
if( p_sys->p_current_song.i_l == 0 ) if (p_sys->p_current_song.i_l == 0)
p_sys->p_current_song.i_l = played_time; p_sys->p_current_song.i_l = played_time;
/* Don't send song shorter than 30s */ /* Don't send song shorter than 30s */
if( p_sys->p_current_song.i_l < 30 ) if (p_sys->p_current_song.i_l < 30)
{ {
msg_Dbg( p_this, "Song too short (< 30s), not submitting" ); msg_Dbg(p_this, "Song too short (< 30s), not submitting");
goto end; goto end;
} }
/* Send if the user had listen more than 240s OR half the track length */ /* Send if the user had listen more than 240s OR half the track length */
if( ( played_time < 240 ) && if ((played_time < 240) &&
( played_time < ( p_sys->p_current_song.i_l / 2 ) ) ) (played_time < (p_sys->p_current_song.i_l / 2)))
{ {
msg_Dbg( p_this, "Song not listened long enough, not submitting" ); msg_Dbg(p_this, "Song not listened long enough, not submitting");
goto end; goto end;
} }
/* Check that all meta are present */ /* Check that all meta are present */
if( !p_sys->p_current_song.psz_a || !*p_sys->p_current_song.psz_a || if (!p_sys->p_current_song.psz_a || !*p_sys->p_current_song.psz_a ||
!p_sys->p_current_song.psz_t || !*p_sys->p_current_song.psz_t ) !p_sys->p_current_song.psz_t || !*p_sys->p_current_song.psz_t)
{ {
msg_Dbg( p_this, "Missing artist or title, not submitting" ); msg_Dbg(p_this, "Missing artist or title, not submitting");
goto end; goto end;
} }
if( p_sys->i_songs >= QUEUE_MAX ) if (p_sys->i_songs >= QUEUE_MAX)
{ {
msg_Warn( p_this, "Submission queue is full, not submitting" ); msg_Warn(p_this, "Submission queue is full, not submitting");
goto end; goto end;
} }
msg_Dbg( p_this, "Song will be submitted." ); msg_Dbg(p_this, "Song will be submitted.");
#define QUEUE_COPY( a ) \ #define QUEUE_COPY(a) \
p_sys->p_queue[p_sys->i_songs].a = p_sys->p_current_song.a p_sys->p_queue[p_sys->i_songs].a = p_sys->p_current_song.a
#define QUEUE_COPY_NULL( a ) \ #define QUEUE_COPY_NULL(a) \
QUEUE_COPY( a ); \ QUEUE_COPY(a); \
p_sys->p_current_song.a = NULL p_sys->p_current_song.a = NULL
QUEUE_COPY( i_l ); QUEUE_COPY(i_l);
QUEUE_COPY_NULL( psz_n ); QUEUE_COPY_NULL(psz_n);
QUEUE_COPY_NULL( psz_a ); QUEUE_COPY_NULL(psz_a);
QUEUE_COPY_NULL( psz_t ); QUEUE_COPY_NULL(psz_t);
QUEUE_COPY_NULL( psz_b ); QUEUE_COPY_NULL(psz_b);
QUEUE_COPY_NULL( psz_m ); QUEUE_COPY_NULL(psz_m);
QUEUE_COPY( date ); QUEUE_COPY(date);
#undef QUEUE_COPY_NULL #undef QUEUE_COPY_NULL
#undef QUEUE_COPY #undef QUEUE_COPY
p_sys->i_songs++; p_sys->i_songs++;
/* signal the main loop we have something to submit */ /* signal the main loop we have something to submit */
vlc_cond_signal( &p_sys->wait ); vlc_cond_signal(&p_sys->wait);
end: end:
DeleteSong( &p_sys->p_current_song ); DeleteSong(&p_sys->p_current_song);
p_sys->b_submit = false; p_sys->b_submit = false;
vlc_mutex_unlock( &p_sys->lock ); vlc_mutex_unlock(&p_sys->lock);
} }
/***************************************************************************** /*****************************************************************************
* PlayingChange: Playing status change callback * PlayingChange: Playing status change callback
*****************************************************************************/ *****************************************************************************/
static int PlayingChange( vlc_object_t *p_this, const char *psz_var, static int PlayingChange(vlc_object_t *p_this, const char *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data ) vlc_value_t oldval, vlc_value_t newval, void *p_data)
{ {
VLC_UNUSED( oldval ); VLC_UNUSED(oldval);
intf_thread_t *p_intf = ( intf_thread_t* ) p_data; intf_thread_t *p_intf = (intf_thread_t*) p_data;
intf_sys_t *p_sys = p_intf->p_sys; intf_sys_t *p_sys = p_intf->p_sys;
input_thread_t *p_input = ( input_thread_t* )p_this; input_thread_t *p_input = (input_thread_t*)p_this;
vlc_value_t state_value; int state;
VLC_UNUSED( p_this ); VLC_UNUSED( psz_var ); VLC_UNUSED(psz_var);
if( newval.i_int != INPUT_EVENT_STATE ) return VLC_SUCCESS; if (newval.i_int != INPUT_EVENT_STATE) return VLC_SUCCESS;
if( var_CountChoices( p_input, "video-es" ) ) if (var_CountChoices(p_input, "video-es"))
{ {
msg_Dbg( p_this, "Not an audio-only input, not submitting"); msg_Dbg(p_this, "Not an audio-only input, not submitting");
return VLC_SUCCESS; return VLC_SUCCESS;
} }
state_value.i_int = 0; state = var_GetInteger(p_input, "state");
var_Get( p_input, "state", &state_value );
if (!p_sys->b_meta_read && state >= PLAYING_S)
if( !p_sys->b_meta_read && state_value.i_int >= PLAYING_S )
{ {
ReadMetaData( p_intf ); ReadMetaData(p_intf);
return VLC_SUCCESS; return VLC_SUCCESS;
} }
if( state_value.i_int >= END_S ) if (state >= END_S)
AddToQueue( p_intf ); AddToQueue(p_intf);
else if( state_value.i_int == PAUSE_S ) else if (state == PAUSE_S)
p_sys->time_pause = mdate(); p_sys->time_pause = mdate();
else if( p_sys->time_pause > 0 && state_value.i_int == PLAYING_S ) else if (p_sys->time_pause > 0 && state == PLAYING_S)
{ {
p_sys->time_total_pauses += ( mdate() - p_sys->time_pause ); p_sys->time_total_pauses += (mdate() - p_sys->time_pause);
p_sys->time_pause = 0; p_sys->time_pause = 0;
} }
...@@ -377,73 +353,73 @@ static int PlayingChange( vlc_object_t *p_this, const char *psz_var, ...@@ -377,73 +353,73 @@ static int PlayingChange( vlc_object_t *p_this, const char *psz_var,
/***************************************************************************** /*****************************************************************************
* ItemChange: Playlist item change callback * ItemChange: Playlist item change callback
*****************************************************************************/ *****************************************************************************/
static int ItemChange( vlc_object_t *p_this, const char *psz_var, static int ItemChange(vlc_object_t *p_this, const char *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data ) vlc_value_t oldval, vlc_value_t newval, void *p_data)
{ {
input_thread_t *p_input; input_thread_t *p_input;
intf_thread_t *p_intf = ( intf_thread_t* ) p_data; intf_thread_t *p_intf = (intf_thread_t*) p_data;
intf_sys_t *p_sys = p_intf->p_sys; intf_sys_t *p_sys = p_intf->p_sys;
input_item_t *p_item; input_item_t *p_item;
VLC_UNUSED( p_this ); VLC_UNUSED( psz_var ); VLC_UNUSED(p_this); VLC_UNUSED(psz_var);
VLC_UNUSED( oldval ); VLC_UNUSED( newval ); VLC_UNUSED(oldval); VLC_UNUSED(newval);
p_sys->b_state_cb = false; p_sys->b_state_cb = false;
p_sys->b_meta_read = false; p_sys->b_meta_read = false;
p_sys->b_submit = false; p_sys->b_submit = false;
p_input = playlist_CurrentInput( pl_Get( p_intf ) ); p_input = playlist_CurrentInput(pl_Get(p_intf));
if( !p_input || p_input->b_dead ) if (!p_input || p_input->b_dead)
return VLC_SUCCESS; return VLC_SUCCESS;
p_item = input_GetItem( p_input ); p_item = input_GetItem(p_input);
if( !p_item ) if (!p_item)
{ {
vlc_object_release( p_input ); vlc_object_release(p_input);
return VLC_SUCCESS; return VLC_SUCCESS;
} }
if( var_CountChoices( p_input, "video-es" ) ) if (var_CountChoices(p_input, "video-es"))
{ {
msg_Dbg( p_this, "Not an audio-only input, not submitting"); msg_Dbg(p_this, "Not an audio-only input, not submitting");
vlc_object_release( p_input ); vlc_object_release(p_input);
return VLC_SUCCESS; return VLC_SUCCESS;
} }
p_sys->time_total_pauses = 0; p_sys->time_total_pauses = 0;
time( &p_sys->p_current_song.date ); /* to be sent to last.fm */ time(&p_sys->p_current_song.date); /* to be sent to last.fm */
p_sys->p_current_song.i_start = mdate(); /* only used locally */ p_sys->p_current_song.i_start = mdate(); /* only used locally */
var_AddCallback( p_input, "intf-event", PlayingChange, p_intf ); var_AddCallback(p_input, "intf-event", PlayingChange, p_intf);
p_sys->b_state_cb = true; p_sys->b_state_cb = true;
if( input_item_IsPreparsed( p_item ) ) if (input_item_IsPreparsed(p_item))
ReadMetaData( p_intf ); ReadMetaData(p_intf);
/* if the input item was not preparsed, we'll do it in PlayingChange() /* if the input item was not preparsed, we'll do it in PlayingChange()
* callback, when "state" == PLAYING_S */ * callback, when "state" == PLAYING_S */
vlc_object_release( p_input ); vlc_object_release(p_input);
return VLC_SUCCESS; return VLC_SUCCESS;
} }
/***************************************************************************** /*****************************************************************************
* Open: initialize and create stuff * Open: initialize and create stuff
*****************************************************************************/ *****************************************************************************/
static int Open( vlc_object_t *p_this ) static int Open(vlc_object_t *p_this)
{ {
intf_thread_t *p_intf = ( intf_thread_t* ) p_this; intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = calloc( 1, sizeof( intf_sys_t ) ); intf_sys_t *p_sys = calloc(1, sizeof(intf_sys_t));
if( !p_sys ) if (!p_sys)
return VLC_ENOMEM; return VLC_ENOMEM;
p_intf->p_sys = p_sys; p_intf->p_sys = p_sys;
vlc_mutex_init( &p_sys->lock ); vlc_mutex_init(&p_sys->lock);
vlc_cond_init( &p_sys->wait ); vlc_cond_init(&p_sys->wait);
var_AddCallback( pl_Get( p_intf ), "item-current", ItemChange, p_intf ); var_AddCallback(pl_Get(p_intf), "item-current", ItemChange, p_intf);
p_intf->pf_run = Run; p_intf->pf_run = Run;
...@@ -453,35 +429,35 @@ static int Open( vlc_object_t *p_this ) ...@@ -453,35 +429,35 @@ static int Open( vlc_object_t *p_this )
/***************************************************************************** /*****************************************************************************
* Close: destroy interface stuff * Close: destroy interface stuff
*****************************************************************************/ *****************************************************************************/
static void Close( vlc_object_t *p_this ) static void Close(vlc_object_t *p_this)
{ {
playlist_t *p_playlist = pl_Get( p_this ); playlist_t *p_playlist = pl_Get(p_this);
input_thread_t *p_input; input_thread_t *p_input;
intf_thread_t *p_intf = ( intf_thread_t* ) p_this; intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_intf->p_sys; intf_sys_t *p_sys = p_intf->p_sys;
var_DelCallback( p_playlist, "item-current", ItemChange, p_intf ); var_DelCallback(p_playlist, "item-current", ItemChange, p_intf);
p_input = playlist_CurrentInput( p_playlist ); p_input = playlist_CurrentInput(p_playlist);
if ( p_input ) if (p_input)
{ {
if( p_sys->b_state_cb ) if (p_sys->b_state_cb)
var_DelCallback( p_input, "intf-event", PlayingChange, p_intf ); var_DelCallback(p_input, "intf-event", PlayingChange, p_intf);
vlc_object_release( p_input ); vlc_object_release(p_input);
} }
int i; int i;
for( i = 0; i < p_sys->i_songs; i++ ) for (i = 0; i < p_sys->i_songs; i++)
DeleteSong( &p_sys->p_queue[i] ); DeleteSong(&p_sys->p_queue[i]);
free( p_sys->psz_submit_host ); free(p_sys->psz_submit_host);
free( p_sys->psz_submit_file ); free(p_sys->psz_submit_file);
#if 0 //NOT USED #if 0 //NOT USED
free( p_sys->psz_nowp_host ); free(p_sys->psz_nowp_host);
free( p_sys->psz_nowp_file ); free(p_sys->psz_nowp_file);
#endif #endif
vlc_cond_destroy( &p_sys->wait ); vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy( &p_sys->lock ); vlc_mutex_destroy(&p_sys->lock);
free( p_sys ); free(p_sys);
} }
...@@ -499,59 +475,58 @@ static void Close( vlc_object_t *p_this ) ...@@ -499,59 +475,58 @@ static void Close( vlc_object_t *p_this )
* VLC_EGENERIC Invalid url provided * VLC_EGENERIC Invalid url provided
* VLC_SUCCESS Success * VLC_SUCCESS Success
*****************************************************************************/ *****************************************************************************/
static int ParseURL( char *psz_url, char **psz_host, char **psz_file, static int ParseURL(char *psz_url, char **psz_host, char **psz_file,
int *i_port ) int *i_port)
{ {
int i_pos; size_t i_pos;
int i_len = strlen( psz_url ); size_t i_len = strlen(psz_url);
bool b_no_port = false; bool b_no_port = false;
FREENULL( *psz_host ); FREENULL(*psz_host);
FREENULL( *psz_file ); FREENULL(*psz_file);
i_pos = strcspn( psz_url, ":" ); i_pos = strcspn(psz_url, ":");
if( i_pos == i_len ) if (i_pos == i_len)
{ {
*i_port = 80; *i_port = 80;
i_pos = strcspn( psz_url, "/" ); i_pos = strcspn(psz_url, "/");
b_no_port = true; b_no_port = true;
} }
*psz_host = strndup( psz_url, i_pos ); *psz_host = strndup(psz_url, i_pos);
if( !*psz_host ) if (!*psz_host)
return VLC_ENOMEM; return VLC_ENOMEM;
if( !b_no_port ) if (!b_no_port)
{ {
i_pos++; /* skip the ':' */ i_pos++; /* skip the ':' */
*i_port = atoi( psz_url + i_pos ); *i_port = atoi(psz_url + i_pos);
if( *i_port <= 0 ) if (*i_port <= 0)
{ {
FREENULL( *psz_host ); FREENULL(*psz_host);
return VLC_EGENERIC; return VLC_EGENERIC;
} }
i_pos = strcspn( psz_url, "/" ); i_pos = strcspn(psz_url, "/");
} }
if( i_pos == i_len ) if (i_pos == i_len)
return VLC_EGENERIC; return VLC_EGENERIC;
i_pos++; /* skip the '/' */ i_pos++; /* skip the '/' */
*psz_file = strdup( psz_url + i_pos ); *psz_file = strdup(psz_url + i_pos);
if( !*psz_file ) if (!*psz_file)
{ {
FREENULL( *psz_host ); FREENULL(*psz_host);
return VLC_ENOMEM; return VLC_ENOMEM;
} }
free( psz_url );
return VLC_SUCCESS; return VLC_SUCCESS;
} }
/***************************************************************************** /*****************************************************************************
* Handshake : Init audioscrobbler connection * Handshake : Init audioscrobbler connection
*****************************************************************************/ *****************************************************************************/
static int Handshake( intf_thread_t *p_this ) static int Handshake(intf_thread_t *p_this)
{ {
char *psz_username, *psz_password; char *psz_username, *psz_password;
char *psz_scrobbler_url; char *psz_scrobbler_url;
...@@ -568,164 +543,157 @@ static int Handshake( intf_thread_t *p_this ) ...@@ -568,164 +543,157 @@ static int Handshake( intf_thread_t *p_this )
int i_ret; int i_ret;
char *psz_url; char *psz_url;
intf_thread_t *p_intf = ( intf_thread_t* ) p_this; intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_this->p_sys; intf_sys_t *p_sys = p_this->p_sys;
psz_username = var_InheritString( p_this, "lastfm-username" ); psz_username = var_InheritString(p_this, "lastfm-username");
if( !psz_username ) if (!psz_username)
return VLC_ENOMEM; return VLC_ENOMEM;
psz_password = var_InheritString( p_this, "lastfm-password" ); psz_password = var_InheritString(p_this, "lastfm-password");
if( !psz_password ) if (!psz_password)
{ {
free( psz_username ); free(psz_username);
return VLC_ENOMEM; return VLC_ENOMEM;
} }
/* username or password have not been setup */ /* username or password have not been setup */
if ( !*psz_username || !*psz_password ) if (!*psz_username || !*psz_password)
{ {
free( psz_username ); free(psz_username);
free( psz_password ); free(psz_password);
return VLC_ENOVAR; return VLC_ENOVAR;
} }
time( &timestamp ); time(&timestamp);
/* generates a md5 hash of the password */ /* generates a md5 hash of the password */
InitMD5( &p_struct_md5 ); InitMD5(&p_struct_md5);
AddMD5( &p_struct_md5, ( uint8_t* ) psz_password, strlen( psz_password ) ); AddMD5(&p_struct_md5, (uint8_t*) psz_password, strlen(psz_password));
EndMD5( &p_struct_md5 ); EndMD5(&p_struct_md5);
free( psz_password ); free(psz_password);
char *psz_password_md5 = psz_md5_hash( &p_struct_md5 ); char *psz_password_md5 = psz_md5_hash(&p_struct_md5);
if( !psz_password_md5 ) if (!psz_password_md5)
{ {
free( psz_username ); free(psz_username);
return VLC_ENOMEM; return VLC_ENOMEM;
} }
snprintf( psz_timestamp, sizeof( psz_timestamp ), "%"PRIu64, snprintf(psz_timestamp, sizeof(psz_timestamp), "%"PRIu64,
(uint64_t)timestamp ); (uint64_t)timestamp);
/* generates a md5 hash of : /* generates a md5 hash of :
* - md5 hash of the password, plus * - md5 hash of the password, plus
* - timestamp in clear text * - timestamp in clear text
*/ */
InitMD5( &p_struct_md5 ); InitMD5(&p_struct_md5);
AddMD5( &p_struct_md5, ( uint8_t* ) psz_password_md5, 32 ); AddMD5(&p_struct_md5, (uint8_t*) psz_password_md5, 32);
AddMD5( &p_struct_md5, ( uint8_t* ) psz_timestamp, strlen( psz_timestamp )); AddMD5(&p_struct_md5, (uint8_t*) psz_timestamp, strlen(psz_timestamp));
EndMD5( &p_struct_md5 ); EndMD5(&p_struct_md5);
free( psz_password_md5 ); free(psz_password_md5);
char *psz_auth_token = psz_md5_hash( &p_struct_md5 ); char *psz_auth_token = psz_md5_hash(&p_struct_md5);
if( !psz_auth_token ) if (!psz_auth_token)
{ {
free( psz_username ); free(psz_username);
return VLC_ENOMEM; return VLC_ENOMEM;
} }
strncpy( p_sys->psz_auth_token, psz_auth_token, 33 );
free( psz_auth_token );
psz_scrobbler_url = var_InheritString( p_this, "scrobbler-url" ); psz_scrobbler_url = var_InheritString(p_this, "scrobbler-url");
if( !psz_scrobbler_url ) if (!psz_scrobbler_url)
{ {
free( psz_username ); free(psz_username);
return VLC_ENOMEM; return VLC_ENOMEM;
} }
if( !asprintf( &psz_handshake_url, i_ret = asprintf(&psz_handshake_url,
"http://%s/?hs=true&p=1.2&c=%s&v=%s&u=%s&t=%s&a=%s", psz_scrobbler_url, "http://%s/?hs=true&p=1.2&c="CLIENT_NAME"&v="CLIENT_VERSION"&u=%s&t=%s&a=%s"
CLIENT_NAME, CLIENT_VERSION, psz_username, psz_timestamp, , psz_scrobbler_url, psz_username, psz_timestamp, psz_auth_token);
p_sys->psz_auth_token ) )
{ free(psz_scrobbler_url);
free( psz_scrobbler_url ); free(psz_username);
free( psz_username ); if (i_ret == -1)
return VLC_ENOMEM; return VLC_ENOMEM;
}
free( psz_scrobbler_url );
free( psz_username );
/* send the http handshake request */ /* send the http handshake request */
p_stream = stream_UrlNew( p_intf, psz_handshake_url ); p_stream = stream_UrlNew(p_intf, psz_handshake_url);
free( psz_handshake_url ); free(psz_handshake_url);
if( !p_stream ) if (!p_stream)
return VLC_EGENERIC; return VLC_EGENERIC;
/* read answer */ /* read answer */
i_ret = stream_Read( p_stream, p_buffer, 1023 ); i_ret = stream_Read(p_stream, p_buffer, sizeof(p_buffer) - 1);
if( i_ret == 0 ) if (i_ret == 0)
{ {
stream_Delete( p_stream ); stream_Delete(p_stream);
return VLC_EGENERIC; return VLC_EGENERIC;
} }
p_buffer[i_ret] = '\0'; p_buffer[i_ret] = '\0';
stream_Delete( p_stream ); stream_Delete(p_stream);
p_buffer_pos = strstr( ( char* ) p_buffer, "FAILED " ); p_buffer_pos = strstr((char*) p_buffer, "FAILED ");
if ( p_buffer_pos ) if (p_buffer_pos)
{ {
/* handshake request failed, sorry */ /* handshake request failed, sorry */
msg_Err( p_this, "last.fm handshake failed: %s", p_buffer_pos + 7 ); msg_Err(p_this, "last.fm handshake failed: %s", p_buffer_pos + 7);
return VLC_EGENERIC; return VLC_EGENERIC;
} }
p_buffer_pos = strstr( ( char* ) p_buffer, "BADAUTH" ); if (strstr((char*) p_buffer, "BADAUTH"))
if ( p_buffer_pos )
{ {
/* authentication failed, bad username/password combination */ /* authentication failed, bad username/password combination */
dialog_Fatal( p_this, dialog_Fatal(p_this,
_("last.fm: Authentication failed"), _("last.fm: Authentication failed"),
"%s", _("last.fm username or password is incorrect. " "%s", _("last.fm username or password is incorrect. "
"Please verify your settings and relaunch VLC." ) ); "Please verify your settings and relaunch VLC."));
return VLC_AUDIOSCROBBLER_EFATAL; return VLC_AUDIOSCROBBLER_EFATAL;
} }
p_buffer_pos = strstr( ( char* ) p_buffer, "BANNED" ); if (strstr((char*) p_buffer, "BANNED"))
if ( p_buffer_pos )
{ {
/* oops, our version of vlc has been banned by last.fm servers */ /* oops, our version of vlc has been banned by last.fm servers */
msg_Err( p_intf, "This version of VLC has been banned by last.fm. " msg_Err(p_intf, "This version of VLC has been banned by last.fm. "
"You should upgrade VLC, or disable the last.fm plugin." ); "You should upgrade VLC, or disable the last.fm plugin.");
return VLC_AUDIOSCROBBLER_EFATAL; return VLC_AUDIOSCROBBLER_EFATAL;
} }
p_buffer_pos = strstr( ( char* ) p_buffer, "BADTIME" ); if (strstr((char*) p_buffer, "BADTIME"))
if ( p_buffer_pos )
{ {
/* The system clock isn't good */ /* The system clock isn't good */
msg_Err( p_intf, "last.fm handshake failed because your clock is too " msg_Err(p_intf, "last.fm handshake failed because your clock is too "
"much shifted. Please correct it, and relaunch VLC." ); "much shifted. Please correct it, and relaunch VLC.");
return VLC_AUDIOSCROBBLER_EFATAL; return VLC_AUDIOSCROBBLER_EFATAL;
} }
p_buffer_pos = strstr( ( char* ) p_buffer, "OK" ); p_buffer_pos = strstr((char*) p_buffer, "OK");
if ( !p_buffer_pos ) if (!p_buffer_pos)
goto proto; goto proto;
p_buffer_pos = strstr( p_buffer_pos, "\n" ); p_buffer_pos = strstr(p_buffer_pos, "\n");
if( !p_buffer_pos || strlen( p_buffer_pos ) < 34 ) if (!p_buffer_pos || strlen(p_buffer_pos) < 33)
goto proto; goto proto;
p_buffer_pos++; /* we skip the '\n' */ p_buffer_pos++; /* we skip the '\n' */
/* save the session ID */ /* save the session ID */
snprintf( p_sys->psz_auth_token, 33, "%s", p_buffer_pos ); memcpy(p_sys->psz_auth_token, p_buffer_pos, 32);
p_sys->psz_auth_token[32] = '\0';
p_buffer_pos = strstr( p_buffer_pos, "http://" ); p_buffer_pos = strstr(p_buffer_pos, "http://");
if( !p_buffer_pos || strlen( p_buffer_pos ) == 7 ) if (!p_buffer_pos || strlen(p_buffer_pos) == 7)
goto proto; goto proto;
/* We need to read the nowplaying url */ /* We need to read the nowplaying url */
p_buffer_pos += 7; /* we skip "http://" */ p_buffer_pos += 7; /* we skip "http://" */
#if 0 //NOT USED #if 0 //NOT USED
psz_url = strndup( p_buffer_pos, strcspn( p_buffer_pos, "\n" ) ); psz_url = strndup(p_buffer_pos, strcspn(p_buffer_pos, "\n"));
if( !psz_url ) if (!psz_url)
goto oom; goto oom;
switch( ParseURL( psz_url, &p_sys->psz_nowp_host, switch(ParseURL(psz_url, &p_sys->psz_nowp_host,
&p_sys->psz_nowp_file, &p_sys->i_nowp_port ) ) &p_sys->psz_nowp_file, &p_sys->i_nowp_port))
{ {
case VLC_ENOMEM: case VLC_ENOMEM:
goto oom; goto oom;
...@@ -736,18 +704,21 @@ static int Handshake( intf_thread_t *p_this ) ...@@ -736,18 +704,21 @@ static int Handshake( intf_thread_t *p_this )
break; break;
} }
#endif #endif
p_buffer_pos = strstr( p_buffer_pos, "http://" ); p_buffer_pos = strstr(p_buffer_pos, "http://");
if( !p_buffer_pos || strlen( p_buffer_pos ) == 7 ) if (!p_buffer_pos || strlen(p_buffer_pos) == 7)
goto proto; goto proto;
/* We need to read the submission url */ /* We need to read the submission url */
p_buffer_pos += 7; /* we skip "http://" */ p_buffer_pos += 7; /* we skip "http://" */
psz_url = strndup( p_buffer_pos, strcspn( p_buffer_pos, "\n" ) ); psz_url = strndup(p_buffer_pos, strcspn(p_buffer_pos, "\n"));
if( !psz_url ) if (!psz_url)
goto oom; goto oom;
switch( ParseURL( psz_url, &p_sys->psz_submit_host, int ret = ParseURL(psz_url, &p_sys->psz_submit_host,
&p_sys->psz_submit_file, &p_sys->i_submit_port ) ) &p_sys->psz_submit_file, &p_sys->i_submit_port);
free(psz_url);
switch(ret)
{ {
case VLC_ENOMEM: case VLC_ENOMEM:
goto oom; goto oom;
...@@ -764,14 +735,13 @@ oom: ...@@ -764,14 +735,13 @@ oom:
return VLC_ENOMEM; return VLC_ENOMEM;
proto: proto:
msg_Err( p_intf, "Handshake: can't recognize server protocol" ); msg_Err(p_intf, "Handshake: can't recognize server protocol");
return VLC_EGENERIC; return VLC_EGENERIC;
} }
static void HandleInterval(mtime_t *next, unsigned int *i_interval)
static void HandleInterval( mtime_t *next, unsigned int *i_interval )
{ {
if( *i_interval == 0 ) if (*i_interval == 0)
{ {
/* first interval is 1 minute */ /* first interval is 1 minute */
*i_interval = 1; *i_interval = 1;
...@@ -780,112 +750,96 @@ static void HandleInterval( mtime_t *next, unsigned int *i_interval ) ...@@ -780,112 +750,96 @@ static void HandleInterval( mtime_t *next, unsigned int *i_interval )
{ {
/* else we double the previous interval, up to 120 minutes */ /* else we double the previous interval, up to 120 minutes */
*i_interval <<= 1; *i_interval <<= 1;
if( *i_interval > 120 ) if (*i_interval > 120)
*i_interval = 120; *i_interval = 120;
} }
*next = mdate() + ( *i_interval * 1000000 * 60 ); *next = mdate() + (*i_interval * 1000000 * 60);
} }
/***************************************************************************** /*****************************************************************************
* Run : call Handshake() then submit songs * Run : call Handshake() then submit songs
*****************************************************************************/ *****************************************************************************/
static void Run( intf_thread_t *p_intf ) static void Run(intf_thread_t *p_intf)
{ {
char *psz_submit, *psz_submit_song, *psz_submit_tmp;
int i_net_ret;
int i_song;
uint8_t p_buffer[1024]; uint8_t p_buffer[1024];
char *p_buffer_pos;
int i_post_socket;
int canc = vlc_savecancel(); int canc = vlc_savecancel();
bool b_handshaked = false;
/* data about audioscrobbler session */
mtime_t next_exchange; /**< when can we send data */
unsigned int i_interval; /**< waiting interval (secs)*/
intf_sys_t *p_sys = p_intf->p_sys; intf_sys_t *p_sys = p_intf->p_sys;
/* main loop */ /* main loop */
for( ;; ) for (;;)
{ {
bool b_wait = false; vlc_restorecancel(canc);
vlc_mutex_lock(&p_sys->lock);
mutex_cleanup_push(&p_sys->lock);
vlc_restorecancel( canc ); do
vlc_mutex_lock( &p_sys->lock ); vlc_cond_wait(&p_sys->wait, &p_sys->lock);
mutex_cleanup_push( &p_sys->lock ); while (mdate() < next_exchange);
if( mdate() < p_sys->next_exchange )
/* wait until we can resubmit, i.e. */
b_wait = vlc_cond_timedwait( &p_sys->wait, &p_sys->lock,
p_sys->next_exchange ) == 0;
else
/* wait for data to submit */
/* we are signaled each time there is a song to submit */
vlc_cond_wait( &p_sys->wait, &p_sys->lock );
vlc_cleanup_run(); vlc_cleanup_run();
canc = vlc_savecancel(); canc = vlc_savecancel();
if( b_wait )
continue; /* holding on until next_exchange */
/* handshake if needed */ /* handshake if needed */
if( !p_sys->b_handshaked ) if (!b_handshaked)
{ {
msg_Dbg( p_intf, "Handshaking with last.fm ..." ); msg_Dbg(p_intf, "Handshaking with last.fm ...");
switch( Handshake( p_intf ) ) switch(Handshake(p_intf))
{ {
case VLC_ENOMEM: case VLC_ENOMEM:
return; return;
case VLC_ENOVAR: case VLC_ENOVAR:
/* username not set */ /* username not set */
dialog_Fatal( p_intf, dialog_Fatal(p_intf,
_("Last.fm username not set"), _("Last.fm username not set"),
"%s", _("Please set a username or disable the " "%s", _("Please set a username or disable the "
"audioscrobbler plugin, and restart VLC.\n" "audioscrobbler plugin, and restart VLC.\n"
"Visit http://www.last.fm/join/ to get an account.") "Visit http://www.last.fm/join/ to get an account.")
); );
return; return;
case VLC_SUCCESS: case VLC_SUCCESS:
msg_Dbg( p_intf, "Handshake successfull :)" ); msg_Dbg(p_intf, "Handshake successfull :)");
p_sys->b_handshaked = true; b_handshaked = true;
p_sys->i_interval = 0; i_interval = 0;
p_sys->next_exchange = mdate(); next_exchange = mdate();
break; break;
case VLC_AUDIOSCROBBLER_EFATAL: case VLC_AUDIOSCROBBLER_EFATAL:
msg_Warn( p_intf, "Exiting..." ); msg_Warn(p_intf, "Exiting...");
return; return;
case VLC_EGENERIC: case VLC_EGENERIC:
default: default:
/* protocol error : we'll try later */ /* protocol error : we'll try later */
HandleInterval( &p_sys->next_exchange, &p_sys->i_interval ); HandleInterval(&next_exchange, &i_interval);
break; break;
} }
/* if handshake failed let's restart the loop */ /* if handshake failed let's restart the loop */
if( !p_sys->b_handshaked ) if (!b_handshaked)
continue; continue;
} }
msg_Dbg( p_intf, "Going to submit some data..." ); msg_Dbg(p_intf, "Going to submit some data...");
char *psz_submit;
/* The session may be invalid if there is a trailing \n */ if (asprintf(&psz_submit, "s=%s", p_sys->psz_auth_token) == -1)
char *psz_ln = strrchr( p_sys->psz_auth_token, '\n' );
if( psz_ln )
*psz_ln = '\0';
if( !asprintf( &psz_submit, "s=%s", p_sys->psz_auth_token ) )
{ /* Out of memory */
return; return;
}
/* forge the HTTP POST request */ /* forge the HTTP POST request */
vlc_mutex_lock( &p_sys->lock ); vlc_mutex_lock(&p_sys->lock);
audioscrobbler_song_t *p_song; audioscrobbler_song_t *p_song;
for( i_song = 0 ; i_song < p_sys->i_songs ; i_song++ ) for (int i_song = 0 ; i_song < p_sys->i_songs ; i_song++)
{ {
char *psz_submit_song, *psz_submit_tmp;
p_song = &p_sys->p_queue[i_song]; p_song = &p_sys->p_queue[i_song];
if( !asprintf( &psz_submit_song, if (asprintf(&psz_submit_song,
"&a%%5B%d%%5D=%s" "&a%%5B%d%%5D=%s"
"&t%%5B%d%%5D=%s" "&t%%5B%d%%5D=%s"
"&i%%5B%d%%5D=%u" "&i%%5B%d%%5D=%u"
...@@ -904,102 +858,105 @@ static void Run( intf_thread_t *p_intf ) ...@@ -904,102 +858,105 @@ static void Run( intf_thread_t *p_intf )
i_song, p_song->psz_b, i_song, p_song->psz_b,
i_song, p_song->psz_n, i_song, p_song->psz_n,
i_song, p_song->psz_m i_song, p_song->psz_m
) ) ) == -1)
{ /* Out of memory */ { /* Out of memory */
vlc_mutex_unlock( &p_sys->lock ); vlc_mutex_unlock(&p_sys->lock);
return; return;
} }
psz_submit_tmp = psz_submit; psz_submit_tmp = psz_submit;
if( !asprintf( &psz_submit, "%s%s", if (asprintf(&psz_submit, "%s%s",
psz_submit_tmp, psz_submit_song ) ) psz_submit_tmp, psz_submit_song) == -1)
{ /* Out of memory */ { /* Out of memory */
free( psz_submit_tmp ); free(psz_submit_tmp);
free( psz_submit_song ); free(psz_submit_song);
vlc_mutex_unlock( &p_sys->lock ); vlc_mutex_unlock(&p_sys->lock);
return; return;
} }
free( psz_submit_song ); free(psz_submit_song);
free( psz_submit_tmp ); free(psz_submit_tmp);
} }
vlc_mutex_unlock( &p_sys->lock ); vlc_mutex_unlock(&p_sys->lock);
i_post_socket = net_ConnectTCP( p_intf, int i_post_socket = net_ConnectTCP(p_intf, p_sys->psz_submit_host,
p_sys->psz_submit_host, p_sys->i_submit_port ); p_sys->i_submit_port);
if ( i_post_socket == -1 ) if (i_post_socket == -1)
{ {
/* If connection fails, we assume we must handshake again */ /* If connection fails, we assume we must handshake again */
HandleInterval( &p_sys->next_exchange, &p_sys->i_interval ); HandleInterval(&next_exchange, &i_interval);
p_sys->b_handshaked = false; b_handshaked = false;
free( psz_submit ); free(psz_submit);
continue; continue;
} }
/* we transmit the data */ /* we transmit the data */
i_net_ret = net_Printf( int i_net_ret = net_Printf(p_intf, i_post_socket, NULL,
p_intf, i_post_socket, NULL, "POST /%s HTTP/1.1\n"
POST_REQUEST, p_sys->psz_submit_file, "Accept-Encoding: identity\n"
(unsigned)strlen( psz_submit ), p_sys->psz_submit_host, "Content-length: %zu\n"
VERSION, psz_submit "Connection: close\n"
); "Content-type: application/x-www-form-urlencoded\n"
"Host: %s\n"
free( psz_submit ); "User-agent: VLC media player/"VERSION"\r\n"
if ( i_net_ret == -1 ) "\r\n"
"%s\r\n"
"\r\n",
p_sys->psz_submit_file, strlen(psz_submit),
p_sys->psz_submit_host, psz_submit
);
free(psz_submit);
if (i_net_ret == -1)
{ {
/* If connection fails, we assume we must handshake again */ /* If connection fails, we assume we must handshake again */
HandleInterval( &p_sys->next_exchange, &p_sys->i_interval ); HandleInterval(&next_exchange, &i_interval);
p_sys->b_handshaked = false; b_handshaked = false;
continue; continue;
} }
i_net_ret = net_Read( p_intf, i_post_socket, NULL, i_net_ret = net_Read(p_intf, i_post_socket, NULL,
p_buffer, 1023, false ); p_buffer, sizeof(p_buffer) - 1, false);
if ( i_net_ret <= 0 ) if (i_net_ret <= 0)
{ {
/* if we get no answer, something went wrong : try again */ /* if we get no answer, something went wrong : try again */
continue; continue;
} }
net_Close( i_post_socket ); net_Close(i_post_socket);
p_buffer[i_net_ret] = '\0'; p_buffer[i_net_ret] = '\0';
p_buffer_pos = strstr( ( char * ) p_buffer, "FAILED" ); char *failed = strstr((char *) p_buffer, "FAILED");
if ( p_buffer_pos ) if (failed)
{ {
msg_Warn( p_intf, "%s", p_buffer_pos ); msg_Warn(p_intf, "%s", failed);
HandleInterval( &p_sys->next_exchange, &p_sys->i_interval ); HandleInterval(&next_exchange, &i_interval);
continue; continue;
} }
p_buffer_pos = strstr( ( char * ) p_buffer, "BADSESSION" ); if (strstr((char *) p_buffer, "BADSESSION"))
if ( p_buffer_pos )
{ {
msg_Err( p_intf, "Authentication failed (BADSESSION), are you connected to last.fm with another program ?" ); msg_Err(p_intf, "Authentication failed (BADSESSION), are you connected to last.fm with another program ?");
p_sys->b_handshaked = false; b_handshaked = false;
HandleInterval( &p_sys->next_exchange, &p_sys->i_interval ); HandleInterval(&next_exchange, &i_interval);
continue; continue;
} }
p_buffer_pos = strstr( ( char * ) p_buffer, "OK" ); if (strstr((char *) p_buffer, "OK"))
if ( p_buffer_pos )
{ {
int i; for (int i = 0; i < p_sys->i_songs; i++)
for( i = 0; i < p_sys->i_songs; i++ ) DeleteSong(&p_sys->p_queue[i]);
DeleteSong( &p_sys->p_queue[i] );
p_sys->i_songs = 0; p_sys->i_songs = 0;
p_sys->i_interval = 0; i_interval = 0;
p_sys->next_exchange = mdate(); next_exchange = mdate();
msg_Dbg( p_intf, "Submission successful!" ); msg_Dbg(p_intf, "Submission successful!");
} }
else else
{ {
msg_Err( p_intf, "Authentication failed, handshaking again (%s)", msg_Err(p_intf, "Authentication failed, handshaking again (%s)",
p_buffer ); p_buffer);
p_sys->b_handshaked = false; b_handshaked = false;
HandleInterval( &p_sys->next_exchange, &p_sys->i_interval ); HandleInterval(&next_exchange, &i_interval);
continue;
} }
} }
vlc_restorecancel( canc ); vlc_restorecancel(canc);
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment