Packman Build Service PMBS

gogglesmm.changes Changed

gogglesmm.spec Changed

gogglesmm-0.12.4.tar.bz2/ChangeLog -> gogglesmm-0.12.5.tar.bz2/ChangeLog Changed

gogglesmm-0.12.4.tar.bz2/INSTALL -> gogglesmm-0.12.5.tar.bz2/INSTALL Changed

gogglesmm-0.12.4.tar.bz2/Makefile -> gogglesmm-0.12.5.tar.bz2/Makefile Changed

gogglesmm-0.12.4.tar.bz2/README -> gogglesmm-0.12.5.tar.bz2/README Changed

gogglesmm-0.12.4.tar.bz2/build/functions -> gogglesmm-0.12.5.tar.bz2/build/functions Changed

@@ -129,20 +129,24 @@
 {
   # Configure Reswrap
   #------------------
-  RESCMD=$(${PKG_PREFIX}/bin/reswrap -v 2>&1)
+  echo "    Checking Reswrap ... "
+  COMMAND=${RESWRAP:-${PKG_PREFIX}/bin/reswrap}
+  if  ! -x $COMMAND  ; then
+    echo "Missing reswrap"
+    exit 1
+  fi
+  RESCMD=$(${COMMAND} -v 2>&1)
   RESVERSION=$(echo ${RESCMD} | cut -d" " -f2)
   RESWRAP_MAJOR=$(echo ${RESVERSION} | cut -d. -f1)
 
-  if  -d icons  ; then
-    if  $RESWRAP_MAJOR = "5"  ; then
-      RESWRAP_H="${PKG_PREFIX}/bin/reswrap --keep-ext --header"
-      RESWRAP_CPP="${PKG_PREFIX}/bin/reswrap --keep-ext --source --extern"
-      RESWRAP_TEXT="${PKG_PREFIX}/bin/reswrap -t --keep-ext"
-    else
-      RESWRAP_H="${PKG_PREFIX}/bin/reswrap -i -k"
-      RESWRAP_CPP="${PKG_PREFIX}/bin/reswrap -e -k"
-      RESWRAP_TEXT="${PKG_PREFIX}/bin/reswrap -t -k"
-    fi
+  if  $RESWRAP_MAJOR = "5"  ; then
+    RESWRAP_H="${COMMAND} --keep-ext --header"
+    RESWRAP_CPP="${COMMAND} --keep-ext --source --extern"
+    RESWRAP_TEXT="${COMMAND} -t --keep-ext"
+  else
+    RESWRAP_H="${COMMAND} -i -k"
+    RESWRAP_CPP="${COMMAND} -e -k"
+    RESWRAP_TEXT="${COMMAND} -t -k"
   fi
 }

gogglesmm-0.12.4.tar.bz2/build/version -> gogglesmm-0.12.5.tar.bz2/build/version Changed

gogglesmm-0.12.4.tar.bz2/configure -> gogglesmm-0.12.5.tar.bz2/configure Changed

gogglesmm-0.12.4.tar.bz2/po/pt.mo -> gogglesmm-0.12.5.tar.bz2/po/pt.mo Changed

gogglesmm-0.12.4.tar.bz2/po/pt.po -> gogglesmm-0.12.5.tar.bz2/po/pt.po Changed

gogglesmm-0.12.4.tar.bz2/src/GMAudioScrobbler.cpp -> gogglesmm-0.12.5.tar.bz2/src/GMAudioScrobbler.cpp Changed

@@ -1,7 +1,7 @@
 /*******************************************************************************
 *                         Goggles Music Manager                                *
 ********************************************************************************
-*           Copyright (C) 2007-2011 by Sander Jansen. All Rights Reserved      *
+*           Copyright (C) 2007-2010 by Sander Jansen. All Rights Reserved      *
 *                               ---                                            *
 * This program is free software: you can redistribute it and/or modify         *
 * it under the terms of the GNU General Public License as published by         *
@@ -17,8 +17,19 @@
 * along with this program.  If not, see http://www.gnu.org/licenses.           *
 ********************************************************************************/
 #include "gmdefs.h"
+#include "gmutils.h"
+
+
+
+#include "ap_buffer.h"
+#include "ap_http.h"
+#include "ap_xml_parser.h"
+
+
 #include "GMAudioScrobbler.h"
 
+
+
 #ifdef HAVE_GCRYPT
 #include "gcrypt.h"
 #else
@@ -26,18 +37,8 @@
 #endif
 
 
-/* Needed for sockets */
-#include <arpa/inet.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <errno.h>
 
-#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
-#endif
+using namespace ap;
 
 
 /******************************************************************************
@@ -50,14 +51,63 @@
 #define MIN_HANDSHAKE_TIMEOUT 60
 #define DISABLE_HANDSHAKE_TIMEOUT 0
 
+
+/// Old Style
 #define CLIENT_ID "gmm"
 #define CLIENT_VERSION "0.1"
 
+/// New Style
+#define CLIENT_KEY "76525254135cc544d13d381514222c56"
+#define CLIENT_SECRET "09397d5d6a55858a6883735b7cb694f7"
+
 #define SCROBBLER_CACHE_FILE PATHSEPSTRING ".goggles" PATHSEPSTRING "scrobbler.cache"
 
-#define LASTFM_URL "http://post.audioscrobbler.com:80"
+#define LASTFM_URL "http://ws.audioscrobbler.com:80/2.0/"
+#define LASTFM_OLD_URL "http://post.audioscrobbler.com:80"
 #define LIBREFM_URL "http://turtle.libre.fm:80"
 
+/// Error codes returned by last.fm
+enum  {
+  LASTFM_ERROR_UNKNOWN            = 0,
+  LASTFM_ERROR_TOKEN_UNAUTHORIZED = 14,
+  LASTFM_ERROR_TOKEN_EXPIRED      = 15,
+  LASTFM_ERROR_BADSESSION         = 9,
+  LASTFM_ERROR_OFFLINE            = 11,
+  LASTFM_ERROR_UNAVAILABLE        = 16,
+  LASTFM_ERROR_KEY_INVALID        = 10,
+  LASTFM_ERROR_KEY_SUSPENDED      = 26
+  };
+
+/*
+1 : This error does not exist
+2 : Invalid service -This service does not exist
+3 : Invalid Method - No method with that name in this package
+4 : Authentication Failed - You do not have permissions to access the service
+5 : Invalid format - This service doesn't exist in that format
+6 : Invalid parameters - Your request is missing a required parameter
+7 : Invalid resource specified
+8 : Operation failed - Most likely the backend service failed. Please try again.
+9 : Invalid session key - Please re-authenticate
+10 : Invalid API key - You must be granted a valid key by last.fm
+11 : Service Offline - This service is temporarily offline. Try again later.
+12 : Subscribers Only - This station is only available to paid last.fm subscribers
+13 : Invalid method signature supplied
+14 : Unauthorized Token - This token has not been authorized
+15 : This item is not available for streaming.
+16 : The service is temporarily unavailable, please try again.
+17 : Login: User requires to be logged in
+18 : Trial Expired - This user has no free radio plays left. Subscription required.
+19 : This error does not exist
+20 : Not Enough Content - There is not enough content to play this station
+21 : Not Enough Members - This group does not have enough members for radio
+22 : Not Enough Fans - This artist does not have enough fans for for radio
+23 : Not Enough Neighbours - There are not enough neighbours for radio
+24 : No Peak Radio - This user is not allowed to listen to radio during peak usage
+25 : Radio Not Found - Radio station not found
+26 : API Key Suspended - This application is not allowed to make requests to the web services
+27 : Deprecated - This type of request is no longer supported
+*/
+
 
 /******************************************************************************
  *
@@ -77,6 +127,7 @@
   return true;
   }
 
+
 static void checksum(FXString & io){
   if (io.empty()) return;
 #ifdef HAVE_GCRYPT
@@ -104,43 +155,23 @@
 #endif
   }
 
-static FXbool parseurl(const FXString & url,GMHost & host){
-  FXTRACE((70,"parseurl: %s\n",url.text()));
-  host.name=GMURL::host(url);
-  host.port=GMURL::port(url);
-  host.path=GMURL::path(url);
-  FXTRACE((70,"hostname=%s\nport=%d\npath=%s\n",host.name.text(),host.port,host.path.text()));
-  if (host.name.empty()) return false;
-  if (host.port==0) host.port=80;
-  return true;
-  }
-
-
 #define URL_UNSAFE   "#$-_.+!*'><()\\,%\""          // Always Encode
 #define URL_RESERVED ";/?:@=&"              // Only encode if not used as reserved by scheme
 
 
-static FXint tryconnect(struct addrinfo * entry) {
-  FXTRACE((60,"GMAudioScrobbler::tryconnect\n"));
+/**********************************************************************************************************/
 
-  FXint server = socket(entry->ai_family,entry->ai_socktype,entry->ai_protocol);
-  if (server==-1) return -1;
 
-  FXint result = connect(server,entry->ai_addr,entry->ai_addrlen);
-  if (result!=-1) {
-#if defined(SO_NOSIGPIPE)
-    int onoff=1;
-    setsockopt(server,SOL_SOCKET,SO_NOSIGPIPE,1,(void*)&onoff,sizeof(onoff));
-#endif
-    return server;
-    }
-  ::close(server);
-  return -1;
+void GMAudioScrobblerTrack::clear() {
+  artist.clear();
+  album.clear();
+  title.clear();
+  duration=0;
+  no=0;
+  timestamp=0;
+  loveban=0;
   }
 
-/**********************************************************************************************************/
-
-
 void GMAudioScrobblerTrack::save(FXStream & store) const {
   store << artist;
   store << album;
@@ -148,6 +179,7 @@
   store << duration;
   store << no;
   store << timestamp;
+  store << loveban;
   }
 
 void GMAudioScrobblerTrack::load(FXStream & store) {
@@ -157,6 +189,166 @@
   store >> duration;
   store >> no;
   store >> timestamp;
+  store >> loveban;
+  }
+
+
+class ServiceResponse : public XMLStream {
+protected:
+  FXbool       status;
+  FXint        code;
+  FXString     message;
+  FXString     key;
+  FXString     token;
+protected:
+  FXint        elem;
+protected:
+  FXint begin(const FXchar *,const FXchar**);
+  void data(const FXchar *,FXint len);
+  void end(const FXchar *);
+  void parse_lfm_atts(const FXchar **);
+  void parse_lfm_error_atts(const FXchar **);
+public:
+  enum {
+    Elem_None,
+    Elem_LastFM,
+    Elem_LastFM_Error,
+    Elem_LastFM_Token,
+    Elem_LastFM_Session,
+    Elem_LastFM_Session_Key,
+    };
+public:
+  ServiceResponse();
+  ~ServiceResponse();
+
+  FXbool getStatus() const { return status; }
+  FXint  getErrorCode() const { return code; }
+  const FXString & getErrorMessage() const { return message; }
+  const FXString & getSessionKey() const { return key; }
+  const FXString & getToken() const { return token; }
+  };
+
+
+ServiceResponse::ServiceResponse() : elem(Elem_None) {
+   }
+
+ServiceResponse::~ServiceResponse() {
+  }
+
+
+void ServiceResponse::parse_lfm_atts(const FXchar ** attributes) {
+  status=false;
+  for (FXint i=0;attributesi;i+=2){
+    if (compare(attributesi,"status")==0) {
+      if (comparecase(attributesi+1,"ok")==0){
+        status=true;
+        }
+      }
+    }
+  }
+
+
+void ServiceResponse::parse_lfm_error_atts(const FXchar ** attributes) {
+  FXString cd;
+  for (FXint i=0;attributesi;i+=2){
+    if (compare(attributesi,"code")==0) {
+      cd=attributesi+1;
+      code=GMIntVal(cd);
+      }
+    }
+  }
+
+
+FXint ServiceResponse::begin(const FXchar * element,const FXchar ** attributes){
+  switch(elem) {
+    case Elem_None:
+      {
+        if (compare(element,"lfm")==0) {
+          parse_lfm_atts(attributes);
+          elem=Elem_LastFM;
+          return 1;
+          }
+      } break;
+    case Elem_LastFM:
+      {
+        if (compare(element,"error")==0) {
+          parse_lfm_error_atts(attributes);
+          elem=Elem_LastFM_Error;
+          return 1;
+          }
+        else if (compare(element,"session")==0) {
+          elem=Elem_LastFM_Session;
+          return 1;
+          }
+        else if (compare(element,"token")==0) {
+          elem=Elem_LastFM_Token;
+          return 1;
+          }
+      } break;
+    case Elem_LastFM_Session:
+      {
+        if (compare(element,"key")==0) {
+          elem=Elem_LastFM_Session_Key;
+          return 1;
+          }
+      } break;
+    default: return 0; // skip
+    }
+  return 0;
+  }
+
+
+void ServiceResponse::data(const FXchar* data,FXint len){
+  if (elem==Elem_LastFM_Error) {
+    message.assign(data,len);
+    }
+  else if (elem==Elem_LastFM_Session_Key) {
+    key.assign(data,len);
+    }
+  else if (elem==Elem_LastFM_Token) {
+    token.assign(data,len);
+    }
+  }
+
+void ServiceResponse::end(const FXchar*) {
+  switch(elem){
+    case Elem_LastFM_Session_Key : elem=Elem_LastFM_Session; break;
+    case Elem_LastFM_Token       :
+    case Elem_LastFM_Error       :
+    case Elem_LastFM_Session     : elem=Elem_LastFM; break;
+    case Elem_LastFM             : elem=Elem_None; break;
+    }
+  }
+
+
+
+FXbool GMAudioScrobbler::post_request(const FXString & url,const FXString & message,FXString & output) {
+  FXTRACE((60,"post_request %s - %s\n",url.text(),message.text()));
+  if (client->basic("POST",url,
+                      "Content-Type: application/x-www-form-urlencoded\r\n"
+                      "Connection: close\r\n",
+                       message)) {
+    output = client->body();
+    return true;
+    }
+  else {
+    FXTRACE((60,"post_request failed\n"));
+    set_timeout();
+    return false;
+    }
+  }
+
+FXbool GMAudioScrobbler::get_request(const FXString & url,FXString & output) {
+  FXTRACE((60,"get_request\n"));
+  if (client->basic("GET",url,"Connection: close\r\n")) {
+    output = client->body();
+    return true;
+    }
+  else {
+    FXTRACE((60,"get_request failed\n"));
+    set_timeout();
+    return false;
+    }
   }
 
 
@@ -175,14 +367,36 @@
   target(tgt),
   message(msg),
   started(false),
+  mode(SERVICE_LASTFM),
   timeout(DISABLE_HANDSHAKE_TIMEOUT),
-  server(-1),
   nsubmitted(0),
   nfailed(0) {
 
+  client = new HttpClient();
+
   username=FXApp::instance()->reg().readStringEntry("LastFM","username",NULL);
   password=FXApp::instance()->reg().readStringEntry("LastFM","password",NULL);
-  parseurl(FXApp::instance()->reg().readStringEntry("LastFM","handshake-url",LASTFM_URL),host_handshake);
+
+  FXString uri = FXApp::instance()->reg().readStringEntry("LastFM","handshake-url",LASTFM_URL);
+  if (uri==LASTFM_OLD_URL) {
+    uri=LASTFM_URL;
+    username.clear();
+    password.clear();
+    FXApp::instance()->reg().writeBoolEntry("LastFM","client-banned",false);
+    }
+
+  handshake_url = uri;
+  mode=getService();
+
+  /// Get last session
+  if (mode==SERVICE_LASTFM) {
+    session=FXApp::instance()->reg().readStringEntry("LastFM","session",NULL);
+    if (!session.empty()) {
+      FXTRACE((60,"GMAudioScrobbler::GMAudioScrobbler - Session: %s\n",session.text()));
+      nowplaying_url=handshake_url;
+      submit_url=handshake_url;
+      }
+    }
 
   /// Check if we're banned
   if (compare(FXApp::instance()->reg().readStringEntry("LastFM","client-id",CLIENT_ID),CLIENT_ID)==0 &&
@@ -195,19 +409,19 @@
     }
 
   /// Check if we should scrobble tracks or not.
-  if (!FXApp::instance()->reg().readBoolEntry("LastFM","scrobble-tracks",true))
+  if (!FXApp::instance()->reg().readBoolEntry("LastFM","scrobble-tracks",false))
     flags|=FLAG_DISABLED;
 
   FXApp::instance()->reg().writeStringEntry("LastFM","client-id",CLIENT_ID);
   FXApp::instance()->reg().writeStringEntry("LastFM","client-version",CLIENT_VERSION);
   load_queue();
+
+
   }
 
 GMAudioScrobbler::~GMAudioScrobbler(){
-  for (FXint e=dnscache.first();e<dnscache.size();e=dnscache.next(e)){
-    freeaddrinfo((struct addrinfo*)dnscache.data(e));
-    }
   save_queue();
+  delete client;
   }
 
 
@@ -218,15 +432,17 @@
  ******************************************************************************/
 
 FXuint GMAudioScrobbler::getService() {
-  if (host_handshake.name=="post.audioscrobbler.com")
+  FXString host = GMURL::host(handshake_url);
+  if (host=="ws.audioscrobbler.com")
     return SERVICE_LASTFM;
-  else if (host_handshake.name=="turtle.libre.fm")
+  else if (host=="turtle.libre.fm")
     return SERVICE_LIBREFM;
   else
     return SERVICE_CUSTOM;
   }
 
 void GMAudioScrobbler::service(FXuint s) {
+  FXTRACE((60,"GMAudioScrobbler::service\n"));
   if (s==SERVICE_LASTFM || s==SERVICE_LIBREFM) {
 
     mutex_data.lock();
@@ -236,7 +452,12 @@
     else
       FXApp::instance()->reg().writeStringEntry("LastFM","handshake-url",LIBREFM_URL);
 
-    parseurl(FXApp::instance()->reg().readStringEntry("LastFM","handshake-url",LASTFM_URL),host_handshake);
+    handshake_url=FXApp::instance()->reg().readStringEntry("LastFM","handshake-url",LASTFM_URL);
+    nowplaying_url.clear();
+    submit_url.clear();
+    session.clear();
+    token.clear();
+
     flags|=FLAG_SERVICE;
     flags&=~FLAG_BADAUTH|FLAG_TIMEOUT|FLAG_BANNED|FLAG_BADTIME;
 
@@ -244,9 +465,12 @@
     password.clear();
     FXApp::instance()->reg().writeStringEntry("LastFM","username",username.text());
     FXApp::instance()->reg().writeStringEntry("LastFM","password",password.text());
+    FXApp::instance()->reg().writeStringEntry("LastFM","session","");
     FXApp::instance()->reg().writeBoolEntry("LastFM","client-banned",false);
 
-    reset_handshake_timeout();
+    mode=s;
+
+    reset_timeout();
     mutex_data.unlock();
 
     wakeup();
@@ -265,23 +489,31 @@
     shutdown();
     }
   else {
-    FXString newpass=pass;
-    checksum(newpass);
-    if (user!=username || newpass!=password) {
-      username=user;
-      password=newpass;
-      FXApp::instance()->reg().writeStringEntry("LastFM","username",username.text());
-      FXApp::instance()->reg().writeStringEntry("LastFM","password",password.text());
-      flags|=FLAG_LOGIN_CHANGED;
-      flags&=~FLAG_BADAUTH;
-      mutex_data.unlock();
-      if (username.empty() || password.empty())
-        shutdown();
-      else
-        runTask();
+    if (mode==SERVICE_LIBREFM) {
+      FXString newpass=pass;
+      checksum(newpass);
+      if (user!=username || newpass!=password) {
+        username=user;
+        password=newpass;
+        FXApp::instance()->reg().writeStringEntry("LastFM","username",username.text());
+        FXApp::instance()->reg().writeStringEntry("LastFM","password",password.text());
+        flags|=FLAG_LOGIN_CHANGED;
+        flags&=~FLAG_BADAUTH;
+        mutex_data.unlock();
+        if (username.empty() || password.empty())
+          shutdown();
+        else
+          runTask();
+        }
+      else {
+        mutex_data.unlock();
+        }
       }
     else {
+      flags|=FLAG_LOGIN_CHANGED;
+      flags&=~FLAG_BADAUTH;
       mutex_data.unlock();
+      runTask();
       }
     }
   }
@@ -300,7 +532,10 @@
 
 
 FXbool GMAudioScrobbler::can_submit() {
-  return !( (flags&FLAG_DISABLED) || (flags&FLAG_BANNED) || (flags&FLAG_BADAUTH) || (flags&FLAG_BADTIME) || username.empty() || password.empty() );
+  if (getService()==SERVICE_LASTFM)
+    return !( (flags&FLAG_DISABLED) || (flags&FLAG_BANNED) || (flags&FLAG_BADAUTH) || (flags&FLAG_BADTIME));
+  else
+    return !( (flags&FLAG_DISABLED) || (flags&FLAG_BANNED) || (flags&FLAG_BADAUTH) || (flags&FLAG_BADTIME) || username.empty() || password.empty() );
   }
 
 void GMAudioScrobbler::nowplaying(GMTrack & info){
@@ -310,7 +545,7 @@
     shutdown();
     }
   else {
-    nowplayingtrack=GMAudioScrobblerTrack(1,info);
+    nowplayingtrack=GMAudioScrobblerTrack(1,info,0);
     mutex_data.unlock();
     runTask();
     }
@@ -326,12 +561,27 @@
     shutdown();
     }
   else {
-    submitqueue.append(GMAudioScrobblerTrack(timestamp,info));
+    submitqueue.append(GMAudioScrobblerTrack(timestamp,info,0));
     mutex_data.unlock();
     runTask();
     }
   }
 
+void GMAudioScrobbler::loveban(GMTrack & /*info*/, FXint /*loveban*/){
+#if 0
+  mutex_data.lock();
+  if (!can_submit()) {
+    mutex_data.unlock();
+    shutdown();
+    }
+  else {
+    submitqueue.append(GMAudioScrobblerTrack(0,info,loveban));
+    mutex_data.unlock();
+    runTask();
+    }
+#endif
+  return;
+}
 
 void GMAudioScrobbler::wakeup(){
   mutex_task.lock();
@@ -359,6 +609,11 @@
     join();
     started=false;
     }
+
+  /// Save Session
+  FXApp::instance()->reg().writeStringEntry("LastFM","session",session.text());
+  FXApp::instance()->reg().writeBoolEntry("LastFM","client-banned",(flags&FLAG_BANNED));
+
   }
 
 void GMAudioScrobbler::disable(){
@@ -431,7 +686,7 @@
 
 
 void GMAudioScrobbler::save_queue(){
-  FXTRACE((60,"GMAudioScrobbler::save_queue\n"));
+  FXTRACE((60,"GMAudioScrobbler::save_queue => %d entries\n",submitqueue.no()));
   FXuint version=20080501;
   FXString filename = FXSystem::getHomeDirectory() + SCROBBLER_CACHE_FILE;
   if (submitqueue.no()) {
@@ -448,7 +703,6 @@
     }
   }
 
-
 FXbool GMAudioScrobbler::waitForTask() {
   FXTRACE((60,"GMAudioScrobbler::waitForTask\n"));
   if (timeout>0) {
@@ -517,7 +771,7 @@
     return TASK_NONE;
     }
 
-  if (flags&FLAG_BADAUTH || flags&FLAG_BADTIME)
+  if (flags&FLAG_BADAUTH)
     return TASK_NONE;
 
   if (flags&FLAG_TIMEOUT) {
@@ -527,11 +781,29 @@
 
   if (flags&FLAG_LOGIN_CHANGED) {
     session.clear();
-    return TASK_LOGIN;
+    if (getService()==SERVICE_LASTFM) {
+      if (!token.empty())
+        return TASK_LOGIN;
+      else
+        return TASK_AUTHENTICATE;
+      }
+    else {
+      return TASK_LOGIN;
+      }
     }
 
   if (submitqueue.no() || nowplayingtrack.timestamp) {
-    if (session.empty()) return TASK_LOGIN;
+    if (session.empty()) {
+      if (getService()==SERVICE_LASTFM) {
+        if (!token.empty())
+          return TASK_LOGIN;
+        else
+          return TASK_AUTHENTICATE;
+        }
+      else {
+        return TASK_LOGIN;
+        }
+      }
     else if (submitqueue.no()) return TASK_SUBMIT;
     else return TASK_NOWPLAYING;
     }
@@ -543,14 +815,16 @@
 
 FXint GMAudioScrobbler::run() {
   FXTRACE((60,"GMAudioScrobbler::run\n"));
+
   FXuchar next=TASK_NONE;
   do {
     while((next=getNextTask())!=TASK_NONE) {
       switch(next){
-        case TASK_LOGIN     : handshake();  break;
-        case TASK_SUBMIT    : submit();     break;
-        case TASK_NOWPLAYING: nowplaying(); break;
-        case TASK_SHUTDOWN  : goto done;    break;
+        case TASK_AUTHENTICATE : authenticate(); break;
+        case TASK_LOGIN        : handshake();    break;
+        case TASK_SUBMIT       : submit();       break;
+        case TASK_NOWPLAYING   : nowplaying();   break;
+        case TASK_SHUTDOWN     : goto done;      break;
         }
       }
     }	while(waitForTask());
@@ -567,66 +841,8 @@
   }
 
 
-FXbool GMAudioScrobbler::open_connection(GMHost & host) {
-  FXTRACE((60,"GMAudioScrobbler::open_connection %s %d %s\n",host.name.text(),host.port,host.path.text()));
-
-  if (host.name.empty() || host.port==0)
-    return false;
-
-  FXString lookupname = host.name+GMStringVal(host.port);
-  struct addrinfo   hints;
-  struct addrinfo * available=NULL,*entry=NULL;
-  int result=0;
-
-  memset(&hints,0,sizeof(struct addrinfo));
-  hints.ai_family=AF_UNSPEC;
-  hints.ai_socktype=SOCK_STREAM;
-
-  FXASSERT(server==-1);
-
-  available = (struct addrinfo *) dnscache.find(lookupname.text());
-  if (available) {
-    for (entry=available;entry;entry=entry->ai_next){
-      server = tryconnect(entry);
-      if (server!=-1) break;
-      }
-    if (server==-1) {
-      dnscache.remove(lookupname.text());
-      freeaddrinfo(available);
-      }
-    }
-
-  if (server==-1) {
-    if ((result=getaddrinfo(host.name.text(),GMStringVal(host.port).text(),&hints,&available))!=0){
-      FXTRACE((60,"getaddrinfo: %s\n", gai_strerror(result)));
-      return false;
-      }
-    for (entry=available;entry;entry=entry->ai_next){
-      server = tryconnect(entry);
-      if (server!=-1) break;
-      }
-    if (server!=-1) {
-      dnscache.insert(lookupname.text(),available);
-      }
-    else {
-      freeaddrinfo(available);
-      }
-    }
-
-  if (server==-1)
-    return false;
-
-  return true;
-  }
 
-void GMAudioScrobbler::close_connection(){
-  if (server!=-1) {
-    ::close(server);
-    server=-1;
-    }
-  }
-
-void GMAudioScrobbler::set_handshake_timeout(){
+void GMAudioScrobbler::set_timeout(){
   flags|=FLAG_TIMEOUT;
   if (timeout==0)
     timeout=MIN_HANDSHAKE_TIMEOUT;
@@ -634,7 +850,7 @@
     timeout=FXMIN(MAX_HANDSHAKE_TIMEOUT,timeout<<1);
   }
 
-void GMAudioScrobbler::reset_handshake_timeout(){
+void GMAudioScrobbler::reset_timeout(){
   timeout=DISABLE_HANDSHAKE_TIMEOUT;
   }
 
@@ -649,56 +865,104 @@
   }
 
 
-void GMAudioScrobbler::create_handshake_request(FXString & msg) {
+
+
+
+void GMAudioScrobbler::create_token_request(FXString & request) {
   FXMutexLock lock(mutex_data);
-  FXTRACE((60,"GMAudioScrobbler::create_handshake_request\n"));
-  FXString token;
-  FXlong timestamp = FXThread::time()/1000000000;
-  FXString timestamp_text = GMStringVal(timestamp);
+  FXTRACE((60,"GMAudioScrobbler::create_token_request\n"));
+  FXString signature="api_key"CLIENT_KEY"methodauth.getToken"CLIENT_SECRET;
+  checksum(signature);
+  request=GMStringFormat("method=auth.getToken&api_key="CLIENT_KEY"&api_sig=%s",signature.text());
+  flags&=~(FLAG_LOGIN_CHANGED);
+  }
+
+
+void GMAudioScrobbler::process_token_response(const FXString & response){
+  FXMutexLock lock(mutex_data);
+  if (flags&FLAG_LOGIN_CHANGED) return;
+  ServiceResponse service;
+  FXTRACE((60,"GMAudioScrobbler::process_token_response\n%s\n",response.text()));
+  if (service.parse(response) && service.getStatus()) {
+    token=service.getToken();
+    FXTRACE((60,"GMAudioScrobbler::process_token_response => token=%s\n",token.text()));
+    FXString url="http://www.last.fm/api/auth/?api_key="CLIENT_KEY"&token="+token;
+    feedback.message(target,FXSEL(SEL_OPENED,message),url.text(),url.length());
+    reset_timeout(); /// Reset timer
+    set_timeout();   /// Let's wait at least 60s
+    }
+  else {
+    FXTRACE((60,"last.fm service failed with code %d: %s\n",service.getErrorCode(),service.getErrorMessage().text()));
+    flags|=FLAG_BADAUTH;
+    }
+  }
 
-  token = password + timestamp_text;
-  checksum(token);
 
-  msg=GMStringFormat("GET /?hs=true&p=1.2&c="CLIENT_ID"&v="CLIENT_VERSION"&u=%s&t=%s&a=%s HTTP/1.1\r\nHOST:%s\r\n\r\n",username.text(),timestamp_text.text(),token.text(),host_handshake.name.text());
 
+FXuint GMAudioScrobbler::create_handshake_request(FXString & request) {
+  FXMutexLock lock(mutex_data);
+  FXTRACE((60,"GMAudioScrobbler::create_handshake_request\n"));
+  if (mode==SERVICE_LASTFM) {
+    FXString signature=GMStringFormat("api_key%smethodauth.getSessiontoken%s%s",CLIENT_KEY,token.text(),CLIENT_SECRET);
+    checksum(signature);
+    request=GMStringFormat("method=auth.getSession&api_key=%s&api_sig=%s&token=%s",CLIENT_KEY,signature.text(),token.text());
+    }
+  else {
+    FXlong timestamp = FXThread::time()/1000000000;
+    FXString timestamp_text = GMStringVal(timestamp);
+    FXString tk = password + timestamp_text;
+    checksum(tk);
+    request=GMStringFormat("/?hs=true&p=1.2&c="CLIENT_ID"&v="CLIENT_VERSION"&u=%s&t=%s&a=%s",username.text(),timestamp_text.text(),tk.text());
+    }
   flags&=~(FLAG_LOGIN_CHANGED);
+  return mode;
   }
 
 
 
-void GMAudioScrobbler::process_handshake_response(const FXchar * buffer,FXint len){
+
+void GMAudioScrobbler::process_handshake_response(const FXString & response){
   FXMutexLock lock(mutex_data);
   if (flags&FLAG_LOGIN_CHANGED) return;
-  FXTRACE((60,"GMAudioScrobbler::process_handshake_response\n"));
-  if (len>0 && ( (compare("HTTP/1.1 200",buffer,12)==0) || (compare("HTTP/1.0 200",buffer,12)==0) )) {
-    FXStringList headers;
-    FXint i,s;
-    for (i=0,s=0;i<len;i++){
-      if (bufferi=='\r' &&  (bufferi+1=='\n' || bufferi+1=='\0')){
-        if (i-s==0) break;
-        headers.append(FXString(&buffers,i-s));
-        s=i+2;
-        i++;
+  FXTRACE((60,"GMAudioScrobbler::process_handshake_response\n%s",response.text()));
+
+  if (mode==SERVICE_LASTFM) {
+    ServiceResponse service;
+    if (!service.parse(response) || !service.getStatus()){
+      FXTRACE((60,"last.fm service failed with code %d: %s\n",service.getErrorCode(),service.getErrorMessage().text()));
+      switch(service.getErrorCode()) {
+        case LASTFM_ERROR_TOKEN_EXPIRED     : token.clear();        break;
+        case LASTFM_ERROR_TOKEN_UNAUTHORIZED:
+        case LASTFM_ERROR_OFFLINE           :
+        case LASTFM_ERROR_UNAVAILABLE       : set_timeout();        break;
+        default                             : flags|=FLAG_BADAUTH;  break;
         }
       }
-    s=i=i+2;
-    FXString response(&buffers,len-i);
-    FXString code=response.section('\n',0);
+    else {
+      session=service.getSessionKey();
+      nowplaying_url=handshake_url;
+      submit_url=handshake_url;
+      flags&=~FLAG_BADAUTH;
+      reset_timeout();
+      }
+    }
+  else {
+    FXString code;
+    code=response.section('\n',0);
     if (compare(code,"OK",2)==0) {
       session = response.section('\n',1);
-      parseurl(response.section('\n',2),host_nowplaying);
-      parseurl(response.section('\n',3),host_submit);
+      nowplaying_url=response.section('\n',2);
+      submit_url=response.section('\n',3);
       flags&=~FLAG_BADAUTH;
-      reset_handshake_timeout();
+      reset_timeout();
       }
     else if (compare(code,"BANNED",6)==0){
       FXTRACE((60,"\t=> BANNED\n"));
       const FXchar msg = "This version of Goggles Music Manager is not supported\nby scrobbler service. Please upgrade to a newer version of GMM.";
       feedback.message(target,FXSEL(SEL_COMMAND,message),msg,ARRAYNUMBER(msg));
       flags|=FLAG_BANNED;
-      FXApp::instance()->reg().writeBoolEntry("LastFM","client-banned",true);
+      //FXApp::instance()->reg().writeBoolEntry("LastFM","client-banned",true);
       }
-      
     else if (compare(code,"BADTIME",7)==0){
       FXTRACE((60,"\t=> BADTIME\n"));
       const FXchar msg = "Unable submit tracks scrobbler service. The system time doesn't match\n"
@@ -715,211 +979,359 @@
       }
     else if (compare(code,"FAILED",6)==0){
       FXTRACE((60,"\t=> FAILED\n"));
-      set_handshake_timeout();
+      set_timeout();
       }
     else {
       FXTRACE((60,"\t=> Unknown\n"));
-      FXTRACE((60,"%s\n",buffer));
-      set_handshake_timeout();
+      FXTRACE((60,"%s\n",response.text()));
+      set_timeout();
       }
     }
-  else {
-    FXTRACE((60,"\t=> HTTP error\n"));
-    set_handshake_timeout();
-    }
   }
 
 
-void GMAudioScrobbler::handshake() {
-  FXTRACE((60,"GMAudioScrobbler::handshake\n"));
 
-  FXString msg;
-  FXint ncount,nread,nwritten;
-  FXchar buffer1024={0};
+void GMAudioScrobbler::authenticate() {
+  FXString request;
+  FXString response;
+  create_token_request(request);
+  if (post_request(handshake_url,request,response))
+    process_token_response(response);
+  }
 
-  if (!open_connection(host_handshake)){
-    FXTRACE((60,"GMAudioScrobbler::open_connection failed\n"));
-    set_handshake_timeout();
-    return;
-    }
+void GMAudioScrobbler::handshake() {
+  FXString request;
+  FXString response;
+  FXbool result;
 
-  create_handshake_request(msg);
+  if (create_handshake_request(request)==SERVICE_LASTFM)
+    result = post_request(handshake_url,request,response);
+  else
+    result = get_request(handshake_url+request,response);
 
-  ncount=0;
-  do {
-    nwritten=::send(server,&msgncount,msg.length()-ncount,MSG_NOSIGNAL);
-    if (nwritten==-1) {
-      close_connection();
-      set_handshake_timeout();
-      return;
-      }
-    ncount+=nwritten;
-    } while(ncount<msg.length());
+  if (result)
+    process_handshake_response(response);
+  }
 
-  ncount=0;
-  do {
-    nread=::recv(server,&bufferncount,1023-ncount,0);
-    if (nread<0) {
-      close_connection();
-      set_handshake_timeout();
-      return;
-      }
-    ncount+=nread;
-    } while(nread>0);
+void GMAudioScrobbler::nowplaying() {
+  FXString request;
+  FXString response;
+  create_nowplaying_request(request);
+  if (post_request(nowplaying_url,request,response))
+    process_nowplaying_response(response);
+  }
 
-  process_handshake_response(buffer,ncount);
+void GMAudioScrobbler::submit() {
+  FXString request;
+  FXString response;
+  create_submit_request(request);
+  if (post_request(submit_url,request,response))
+    process_submit_response(response);
+  }
 
-  close_connection();
-  return;
+void GMAudioScrobbler::loveban() {
+  FXString request;
+  FXString response;
+  create_loveban_request(request);
+  if (post_request(submit_url,request,response))
+    process_loveban_response(response);
   }
 
 
 
 
-void GMAudioScrobbler::create_nowplaying_request(GMHost & host,FXString & msg) {
+
+
+
+void GMAudioScrobbler::create_nowplaying_request(FXString & request) {
   FXMutexLock lock(mutex_data);
   FXTRACE((60,"GMAudioScrobbler::create_nowplaying_request\n"));
-  FXString nowplaying_payload;
-  nowplaying_payload+="s=";
-  nowplaying_payload+=gm_url_encode(session);
-  nowplaying_payload+=GMStringFormat("&a=%s",gm_url_encode(nowplayingtrack.artist).text());
-  nowplaying_payload+=GMStringFormat("&t=%s",gm_url_encode(nowplayingtrack.title).text());
-  nowplaying_payload+=GMStringFormat("&b=%s",gm_url_encode(nowplayingtrack.album).text());
-  nowplaying_payload+=GMStringFormat("&l=%d",nowplayingtrack.duration);
-  nowplaying_payload+=GMStringFormat("&n=%d",nowplayingtrack.no);
-  nowplaying_payload+="&m";
-  nowplayingtrack.artist.clear();
-  nowplayingtrack.title.clear();
-  nowplayingtrack.album.clear();
-  nowplayingtrack.timestamp=0;
-  FXTRACE((71,"Payload: %s\n\n",nowplaying_payload.text()));
-  msg="POST " + host.path + " HTTP/1.1\r\nHOST:" + host.name + "\r\nContent-Type: application/x-www-form-urlencoded\r\n";
-  msg+=GMStringFormat("Content-Length: %d\r\n",nowplaying_payload.length());
-  msg+="\r\n";
-  msg+=nowplaying_payload;
-  }
-
-
-void GMAudioScrobbler::process_nowplaying_response(const FXchar * buffer,FXint len){
+  if (mode==SERVICE_LASTFM) {
+    FXString signature=GMStringFormat("album%s"
+                                      "api_key"CLIENT_KEY
+                                      "artist%s"
+                                      "duration%d"
+                                      "methodtrack.updateNowPlaying"
+                                      "sk%s"
+                                      "track%s"
+                                      "trackNumber%d"
+                                      CLIENT_SECRET,
+                                      nowplayingtrack.album.text(),
+                                      nowplayingtrack.artist.text(),
+                                      nowplayingtrack.duration,
+                                      session.text(),
+                                      nowplayingtrack.title.text(),
+                                      nowplayingtrack.no);
+
+    checksum(signature);
+
+    request=GMStringFormat("method=track.updateNowPlaying"
+                           "&track=%s"
+                           "&artist=%s"
+                           "&album=%s"
+                           "&trackNumber=%d"
+                           "&duration=%d"
+                           "&api_key="CLIENT_KEY
+                           "&api_sig=%s"
+                           "&sk=%s",
+                           gm_url_encode(nowplayingtrack.title).text(),
+                           gm_url_encode(nowplayingtrack.artist).text(),
+                           gm_url_encode(nowplayingtrack.album).text(),
+                           nowplayingtrack.no,
+                           nowplayingtrack.duration,
+                           signature.text(),
+                           session.text());
+    }
+  else {
+    request=GMStringFormat("s=%s&a=%s&t=%s&b=%s&l=%d&n=%d&m",gm_url_encode(session).text(),
+                                                             gm_url_encode(nowplayingtrack.artist).text(),
+                                                             gm_url_encode(nowplayingtrack.title).text(),
+                                                             gm_url_encode(nowplayingtrack.album).text(),
+                                                             nowplayingtrack.duration,
+                                                             nowplayingtrack.no);
+    }
+  nowplayingtrack.clear();
+  }
+
+
+void GMAudioScrobbler::process_nowplaying_response(const FXString & response){
   FXMutexLock lock(mutex_data);
   if (flags&FLAG_LOGIN_CHANGED) return;
-  FXTRACE((60,"GMAudioScrobbler::process_nowplaying_response\n"));
-  if (len>0 && ( (compare("HTTP/1.1 200",buffer,12)==0) || (compare("HTTP/1.0 200",buffer,12)==0) )) {
-    FXStringList headers;
-    FXint i,s;
-    for (i=0,s=0;i<len;i++){
-      if (bufferi=='\r' &&  (bufferi+1=='\n' || bufferi+1=='\0')){
-        if (i-s==0) break;
-        headers.append(FXString(&buffers,i-s));
-        s=i+2;
-        i++;
+  FXTRACE((60,"GMAudioScrobbler::process_nowplaying_response:\n %s\n",response.text()));
+  if (mode==SERVICE_LASTFM) {
+    ServiceResponse service;
+    if (!service.parse(response) || !service.getStatus()) {
+      FXTRACE((60,"last.fm service failed with code %d: %s\n",service.getErrorCode(),service.getErrorMessage().text()));
+      switch(service.getErrorCode()) {
+        case LASTFM_ERROR_OFFLINE      :
+        case LASTFM_ERROR_UNAVAILABLE  : set_timeout();           break;
+        case LASTFM_ERROR_BADSESSION   : session.clear();         break;
+        case LASTFM_ERROR_KEY_INVALID  :
+        case LASTFM_ERROR_KEY_SUSPENDED: flags|=FLAG_BANNED;      break;
+        default                        : flags|=FLAG_BADAUTH;     break;
         }
       }
-    s=i=i+2;
-    FXString response(&buffers,len-i);
+    }
+  else {
+    FXString response;
     FXString code=response.section('\n',0);
     FXTRACE((70,"Now Playing Response: %s\n\n",response.text()));
     if (compare(code,"BADSESSION",10)==0) {
       session.clear();
       }
     }
-  else {
-    FXTRACE((70,"Now Playing Response:\n%s\n\n",buffer));
-    }
   }
 
 
-void GMAudioScrobbler::nowplaying() {
-  FXTRACE((60,"GMAudioScrobbler::nowplaying\n"));
-  FXchar buffer1024={0};
-  FXString msg;
-  FXint ncount,nread,nwritten;
+void GMAudioScrobbler::create_submit_request(FXString & request) {
+  FXMutexLock lock(mutex_data);
+  FXTRACE((60,"GMAudioScrobbler::create_submit_request\n"));
+  FXint i,s;
+  FXint ntracks = FXMIN(50,submitqueue.no());
+  FXString signature;
+
+  if (mode==SERVICE_LASTFM) {
+    if (ntracks==1) {
+      signature=GMStringFormat("album0%s"
+                               "api_key"CLIENT_KEY
+                               "artist0%s"
+                               "duration0%d"
+                               "methodtrack.scrobble"
+                               "sk%s"
+                               "timestamp0%u"
+                               "trackNumber0%d"
+                               "track0%s"
+                               CLIENT_SECRET,
+                               submitqueue0.album.text(),
+                               submitqueue0.artist.text(),
+                               submitqueue0.duration,
+                               session.text(),
+                               submitqueue0.getTimeStamp(),
+                               submitqueue0.no,
+                               submitqueue0.title.text());
+      }
+    else if (ntracks<10) {
 
+      for (i=0;i<ntracks;i++)
+        signature+=GMStringFormat("album%d%s",i,submitqueuei.album.text());
 
-  if (!open_connection(host_nowplaying)){
-    set_submit_failed();
-    return;
-    }
+      signature+="api_key"CLIENT_KEY;
 
-  create_nowplaying_request(host_nowplaying,msg);
+      for (i=0;i<ntracks;i++)
+        signature+=GMStringFormat("artist%d%s",i,submitqueuei.artist.text());
 
-  ncount=0;
-  do {
-    nwritten=::send(server,&msgncount,msg.length()-ncount,MSG_NOSIGNAL);
-    if (nwritten==-1) {
-      close_connection();
-      set_handshake_timeout();
-      return;
-      }
-    ncount+=nwritten;
-    } while(ncount<msg.length());
+      for (i=0;i<ntracks;i++)
+        signature+=GMStringFormat("duration%d%d",i,submitqueuei.duration);
 
-  ncount=0;
-  do {
-    nread=::recv(server,&bufferncount,1023-ncount,0);
-    if (nread<0) {
-      close_connection();
-      set_handshake_timeout();
-      return;
+      signature+="methodtrack.scrobble";
+      signature+="sk"+session;
+
+      for (i=0;i<ntracks;i++)
+        signature+=GMStringFormat("timestamp%d%u",i,submitqueuei.getTimeStamp());
+
+      for (i=0;i<ntracks;i++)
+        signature+=GMStringFormat("trackNumber%d%d",i,submitqueuei.no);
+
+      for (i=0;i<ntracks;i++)
+        signature+=GMStringFormat("track%d%s",i,submitqueuei.title.text());
+
+      signature+=CLIENT_SECRET;
       }
-    ncount+=nread;
-    } while(nread>0);
+    else {
+      /// albums
+      for (s=0,i=10;i<ntracks;i++){
+        if ((i%10)==0) {
+          signature+=GMStringFormat("album%d%s",s,submitqueues.album.text());
+          s++;
+          }
+        signature+=GMStringFormat("album%d%s",i,submitqueuei.album.text());
+        }
+      for (;s<10;s++)
+        signature+=GMStringFormat("album%d%s",s,submitqueues.album.text());
 
-  process_nowplaying_response(buffer,ncount);
+      signature+="api_key"CLIENT_KEY;
 
-  close_connection();
-  return;
-  }
+      /// artists
+      for (s=0,i=10;i<ntracks;i++){
+        if ((i%10)==0) {
+          signature+=GMStringFormat("artist%d%s",s,submitqueues.artist.text());
+          s++;
+          }
+        signature+=GMStringFormat("artist%d%s",i,submitqueuei.artist.text());
+        }
+      for (;s<10;s++)
+        signature+=GMStringFormat("artist%d%s",s,submitqueues.artist.text());
+
+      /// duration
+      for (s=0,i=10;i<ntracks;i++){
+        if ((i%10)==0) {
+          signature+=GMStringFormat("duration%d%d",s,submitqueues.duration);
+          s++;
+          }
+        signature+=GMStringFormat("duration%d%d",i,submitqueuei.duration);
+        }
+      for (;s<10;s++)
+        signature+=GMStringFormat("duration%d%d",s,submitqueues.duration);
 
+      signature+="methodtrack.scrobble";
+      signature+="sk"+session;
 
+      /// Timestamp
+      for (s=0,i=10;i<ntracks;i++){
+        if ((i%10)==0) {
+          signature+=GMStringFormat("timestamp%d%u",s,submitqueues.getTimeStamp());
+          s++;
+          }
+        signature+=GMStringFormat("timestamp%d%u",i,submitqueuei.getTimeStamp());
+        }
+      for (;s<10;s++)
+        signature+=GMStringFormat("timestamp%d%u",s,submitqueues.getTimeStamp());
+
+      /// track number
+      for (s=0,i=10;i<ntracks;i++){
+        if ((i%10)==0) {
+          signature+=GMStringFormat("trackNumber%d%d",s,submitqueues.no);
+          s++;
+          }
+        signature+=GMStringFormat("trackNumber%d%d",i,submitqueuei.no);
+        }
+      for (;s<10;s++)
+        signature+=GMStringFormat("trackNumber%d%d",s,submitqueues.no);
 
-void GMAudioScrobbler::create_submit_request(GMHost & host,FXString & msg) {
-  FXMutexLock lock(mutex_data);
-  FXTRACE((60,"GMAudioScrobbler::create_submit_request\n"));
-  FXString payload;
-  nsubmitted=0;
-  payload+="s=";
-  payload+=gm_url_encode(session);
-  for (FXint i=0;i<submitqueue.no() && i<50;i++) {
-    payload+=GMStringFormat("&a%d=%s",i,gm_url_encode(submitqueuei.artist).text());
-    payload+=GMStringFormat("&t%d=%s",i,gm_url_encode(submitqueuei.title).text());
-    payload+=GMStringFormat("&i%d=%u",i,(FXuint)(submitqueuei.timestamp/1000000000));
-    payload+=GMStringFormat("&o%d=P",i);
-    payload+=GMStringFormat("&r%d",i);
-    payload+=GMStringFormat("&l%d=%d",i,submitqueuei.duration);
-    payload+=GMStringFormat("&b%d=%s",i,gm_url_encode(submitqueuei.album).text());
-    payload+=GMStringFormat("&n%d=%d",i,submitqueuei.no);
-    payload+=GMStringFormat("&m%d",i);
-    nsubmitted++;
-    }
-  FXTRACE((71,"Payload: %s\n\n",payload.text()));
-  msg="POST " + host.path + " HTTP/1.1\r\nHOST:" + host.name + "\r\nContent-Type: application/x-www-form-urlencoded\r\n";
-  msg+=GMStringFormat("Content-Length: %d\r\n",payload.length());
-  msg+="\r\n";
-  msg+=payload;
-  }
-
-
-void GMAudioScrobbler::process_submit_response(const FXchar * buffer,FXint len){
+
+      /// track
+      for (s=0,i=10;i<ntracks;i++){
+        if ((i%10)==0) {
+          signature+=GMStringFormat("track%d%s",s,submitqueues.title.text());
+          s++;
+          }
+        signature+=GMStringFormat("track%d%s",i,submitqueuei.title.text());
+        }
+      for (;s<10;s++)
+        signature+=GMStringFormat("track%d%s",s,submitqueues.title.text());
+
+
+      signature+=CLIENT_SECRET;
+      }
+
+    checksum(signature);
+
+    request="method=track.scrobble";
+    for (i=0;i<ntracks;i++) {
+      request+=GMStringFormat("&track%d=%s"
+                              "&timestamp%d=%u"
+                              "&artist%d=%s"
+                              "&album%d=%s"
+                              "&trackNumber%d=%d"
+                              "&duration%d=%d",
+                              i,gm_url_encode(submitqueuei.title).text(),
+                              i,submitqueuei.getTimeStamp(),
+                              i,gm_url_encode(submitqueuei.artist).text(),
+                              i,gm_url_encode(submitqueuei.album).text(),
+                              i,submitqueuei.no,
+                              i,submitqueuei.duration);
+      }
+    request+=GMStringFormat("&api_key="CLIENT_KEY"&api_sig=%s&sk=%s",signature.text(),session.text());
+    }
+  else {
+    request+="s=";
+    request+=gm_url_encode(session);
+    for (i=0;i<ntracks;i++) {
+      request+=GMStringFormat("&a%d=%s"
+                              "&t%d=%s"
+                              "&i%d=%u"
+                              "&o%d=P"
+                              "&r%d"
+                              "&l%d=%d"
+                              "&b%d=%s"
+                              "&n%d=%d"
+                              "&m%d",
+                              i,gm_url_encode(submitqueuei.artist).text(),
+                              i,gm_url_encode(submitqueuei.title).text(),
+                              i,submitqueuei.getTimeStamp(),
+                              i,i,
+                              i,submitqueuei.duration,
+                              i,gm_url_encode(submitqueuei.album).text(),
+                              i,submitqueuei.no,
+                              i);
+        }
+    }
+  nsubmitted=ntracks;
+  }
+
+void GMAudioScrobbler::process_submit_response(const FXString & response){
   FXMutexLock lock(mutex_data);
   FXTRACE((60,"GMAudioScrobbler::process_submit_response\n"));
-  if (len>0 && ( (compare("HTTP/1.1 200",buffer,12)==0) || (compare("HTTP/1.0 200",buffer,12)==0) )) {
-    FXStringList headers;
-    FXint i,s;
-    for (i=0,s=0;i<len;i++){
-      if (bufferi=='\r' &&  (bufferi+1=='\n' || bufferi+1=='\0')){
-        if (i-s==0) break;
-        headers.append(FXString(&buffers,i-s));
-        s=i+2;
-        i++;
+  if (mode==SERVICE_LASTFM) {
+    ServiceResponse service;
+    if (!service.parse(response) || !service.getStatus()) {
+      FXTRACE((60,"last.fm service failed with code %d: %s\n",service.getErrorCode(),service.getErrorMessage().text()));
+      switch(service.getErrorCode()) {
+        case LASTFM_ERROR_OFFLINE      :
+        case LASTFM_ERROR_UNAVAILABLE  : set_timeout(); break;
+        case LASTFM_ERROR_BADSESSION   : session.clear();         break;
+        case LASTFM_ERROR_KEY_INVALID  :
+        case LASTFM_ERROR_KEY_SUSPENDED: flags|=FLAG_BANNED;      break;
+        default                        : flags|=FLAG_BADAUTH;     break;
         }
       }
-    s=i=i+2;
-    FXString response(&buffers,len-i);
+    else {
+      FXTRACE((60,"last.fm service submit success\n"));
+      submitqueue.erase(0,nsubmitted);
+      nsubmitted=0;
+      }
+    }
+  else {
     FXString code=response.section('\n',0);
     FXTRACE((70,"Submit Response: %s\n\n",response.text()));
     if (compare(code,"OK",2)==0) {
-      submitqueue.erase(0,nsubmitted);
+      if (submitqueue0.loveban!=0) {
+        submitqueue0.timestamp=0;
+        loveban();
+        }
+      else {
+        submitqueue.erase(0,nsubmitted);
+        }
       nsubmitted=0;
       }
     else if (compare(code,"BADSESSION",10)==0) {
@@ -935,51 +1347,45 @@
       nsubmitted=0;
       }
     }
-  else {
-    FXTRACE((70,"Submit Response: %s\n\n",buffer));
-    set_submit_failed();
-    nsubmitted=0;
-    }
   }
 
 
-void GMAudioScrobbler::submit() {
-  FXTRACE((60,"GMAudioScrobbler::submit\n"));
-  FXchar buffer1024={0};
-  FXString msg;
-  FXint ncount,nread,nwritten;
+/* LastFM */
+void GMAudioScrobbler::create_loveban_request(FXString & request){
+  FXMutexLock lock(mutex_data);
+  FXTRACE((60,"GMAudioScrobbler::create_loveban_request\n"));
+  FXASSERT(mode==SERVICE_LASTFM);
+
+  FXString signature=GMStringFormat("api_key"CLIENT_KEY
+                           "artist%s"
+                           "methodtrack.love" //methodtrack.ban
+                           "sk%s"
+                           "track%s"
+                           CLIENT_SECRET,
+                           submitqueue0.artist.text(),
+                           session.text(),
+                           submitqueue0.title.text());
+
+  checksum(signature);
+
+  request=GMStringFormat("method=track.love" ////method=track.ban
+                         "&track=%s"
+                         "&artist=%s"
+                         "&api_key="CLIENT_KEY
+                         "&api_sig=%s"
+                         "&sk=%s",
+                         gm_url_encode(submitqueue0.title).text(),
+                         gm_url_encode(submitqueue0.artist).text(),
+                         signature.text(),
+                         session.text());
+  }
 
-  if (!open_connection(host_submit)){
-    set_submit_failed();
-    return;
+void GMAudioScrobbler::process_loveban_response(const FXString & response){
+  FXMutexLock lock(mutex_data);
+  FXTRACE((60,"GMAudioScrobbler::process_loveban_response\n"));
+  ServiceResponse service;
+  if (!service.parse(response) || !service.getStatus()) {
+    session.clear();
+    FXTRACE((60,"last.fm service failed with code %d: %s\n",service.getErrorCode(),service.getErrorMessage().text()));
     }
-
-  create_submit_request(host_submit,msg);
-
-  ncount=0;
-  do {
-    nwritten=::send(server,&msgncount,msg.length()-ncount,MSG_NOSIGNAL);
-    if (nwritten==-1) {
-      close_connection();
-      set_handshake_timeout();
-      return;
-      }
-    ncount+=nwritten;
-    } while(ncount<msg.length());
-
-  ncount=0;
-  do {
-    nread=::recv(server,&bufferncount,1023-ncount,0);
-    if (nread<0) {
-      close_connection();
-      set_handshake_timeout();
-      return;
-      }
-    ncount+=nread;
-    } while(nread>0);
-
-  process_submit_response(buffer,ncount);
-
-  close_connection();
-  return;
   }

gogglesmm-0.12.4.tar.bz2/src/GMAudioScrobbler.h -> gogglesmm-0.12.5.tar.bz2/src/GMAudioScrobbler.h Changed

@@ -1,7 +1,7 @@
 /*******************************************************************************
 *                         Goggles Music Manager                                *
 ********************************************************************************
-*         Copyright (C) 2008-2011 by Sander Jansen. All Rights Reserved        *
+*         Copyright (C) 2008-2010 by Sander Jansen. All Rights Reserved        *
 *                               ---                                            *
 * This program is free software: you can redistribute it and/or modify         *
 * it under the terms of the GNU General Public License as published by         *
@@ -19,14 +19,6 @@
 #ifndef GMAUDIOSCROBBLER_H
 #define GMAUDIOSCROBBLER_H
 
-struct GMHost {
-  FXString name;
-  FXString path;
-  FXuint port;
-  GMHost() : port(0) {}
-  GMHost(const FXString & n,FXuint p) : name(n), port(p) {}
-  };
-
 struct GMAudioScrobblerTrack {
   FXString artist;
   FXString album;
@@ -34,22 +26,30 @@
   FXuint   duration;
   FXint    no;
   FXlong   timestamp;
+  FXint    loveban;
   GMAudioScrobblerTrack(){}
-  GMAudioScrobblerTrack(FXlong time,GMTrack & t) : artist(t.artist),album(t.album),title(t.title),duration(t.time),no(t.no),timestamp(time){}
+  GMAudioScrobblerTrack(FXlong time,GMTrack & t,FXint lb) : artist(t.artist),album(t.album),title(t.title),duration(t.time),no(t.no),timestamp(time)/* LastFM */,loveban(lb)/* LastFM End */{}
 
   void load(FXStream & store);
   void save(FXStream & store) const;
+
+  FXuint getTimeStamp() const { return (FXuint)(timestamp/1000000000); }
+
+  void clear();
   };
 
 typedef FXArray<GMAudioScrobblerTrack> GMAudioScrobblerTrackList;
 
-
 enum {
   SERVICE_LASTFM,
   SERVICE_LIBREFM,
   SERVICE_CUSTOM
   };
 
+namespace ap {
+  class HttpClient;
+  };
+
 class GMAudioScrobbler : public FXThread {
 private:
   FXMutex           mutex_task;
@@ -61,24 +61,28 @@
   FXSelector        message;
   FXbool            started;
 private:
-  GMHost            host_handshake;
-  GMHost            host_nowplaying;
-  GMHost            host_submit;
+  ap::HttpClient*       client;
+private:
+  FXuint            mode;
+  FXString          handshake_url;
+  FXString          nowplaying_url;
+  FXString          submit_url;
+
+
   FXString          username;
   FXString          password;
   FXString          session;
+  FXString          token;
 protected:
   FXlong            timeout;
-protected:
-  FXint             server;
-  FXDict            dnscache;
 private:
   enum {
-    TASK_NONE       = 0x0,
-    TASK_LOGIN 			= 0x1,
-    TASK_NOWPLAYING = 0x2,
-    TASK_SUBMIT 		= 0x4,
-    TASK_SHUTDOWN   = 0x8
+    TASK_NONE         = 0x0,
+    TASK_LOGIN 	      = 0x1,
+    TASK_NOWPLAYING   = 0x2,
+    TASK_SUBMIT 	  = 0x4,
+    TASK_SHUTDOWN     = 0x8,
+    TASK_AUTHENTICATE = 0x10,
     };
 private:
   enum {
@@ -86,7 +90,7 @@
     FLAG_LOGIN_CHANGED = 0x1,
     FLAG_BANNED        = 0x2,
     FLAG_BADAUTH       = 0x4,
-    FLAG_BADTIME			 = 0x8,
+    FLAG_BADTIME	   = 0x8,
     FLAG_SHUTDOWN      = 0x10,
     FLAG_TIMEOUT       = 0x20,
     FLAG_NETWORK       = 0x40,
@@ -96,8 +100,8 @@
 protected:
   FXint run();
 protected:
-  FXbool open_connection(GMHost &);
-  void close_connection();
+  FXbool post_request(const FXString & url,const FXString & request,FXString & response);
+  FXbool get_request(const FXString & url,FXString & response);
 protected:
   FXuchar getNextTask();
   FXbool  waitForTask();
@@ -109,17 +113,23 @@
   FXint nsubmitted;
   FXint nfailed;
 protected:
+  void authenticate();
   void handshake();
   void submit();
   void nowplaying();
-  void create_handshake_request(FXString &);
-  void process_handshake_response(const FXchar *,FXint);
-  void create_nowplaying_request(GMHost &,FXString &);
-  void process_nowplaying_response(const FXchar *,FXint);
-  void create_submit_request(GMHost &,FXString &);
-  void process_submit_response(const FXchar *,FXint);
-  void set_handshake_timeout();
-  void reset_handshake_timeout();
+  void loveban();
+  void create_loveban_request(FXString &);
+  void process_loveban_response(const FXString&);
+  void create_token_request(FXString &);
+  void process_token_response(const FXString&);
+  FXuint create_handshake_request(FXString &);
+  void process_handshake_response(const FXString&);
+  void create_nowplaying_request(FXString &);
+  void process_nowplaying_response(const FXString&);
+  void create_submit_request(FXString &);
+  void process_submit_response(const FXString&);
+  void set_timeout();
+  void reset_timeout();
   void set_submit_failed();
   void load_queue();
   void save_queue();
@@ -133,6 +143,7 @@
   FXuint getService();
 
   void nowplaying(GMTrack & info);
+  void loveban(GMTrack & info, FXint loveban);
 
   void service(FXuint s);
   void submit(FXlong timestamp,GMTrack & info);
@@ -147,6 +158,7 @@
 
 extern FXbool init_gcrypt();
 
+
 #endif

gogglesmm-0.12.4.tar.bz2/src/GMFetch.cpp -> gogglesmm-0.12.5.tar.bz2/src/GMFetch.cpp Changed

@@ -20,62 +20,44 @@
 #include "gmdefs.h"
 #include "GMFetch.h"
 #include "GMPlayerManager.h"
-#ifdef HAVE_CURL
-#include <curl/curl.h>
-#endif
+
+#include "ap_buffer.h"
+#include "ap_http.h"
+using namespace ap;
 
 GMFetch * GMFetch::fetch = NULL;
 
 GMFetch::GMFetch() : gui(FXApp::instance()) {
   }
 
-#ifdef HAVE_CURL
-static size_t download_write(void *buffer, size_t size, size_t nmemb,void *ptr_response){
-  FXString * response = reinterpret_cast<FXString*>(ptr_response);
-  response->append((const FXchar *)buffer,size*nmemb);
-  return size*nmemb;
-  }
-#endif
 
 FXint GMFetch::run() {
-#ifdef HAVE_CURL
-  FXchar errorbufCURL_ERROR_SIZE;
   GMFetchResponse * response = new GMFetchResponse;
   response->url = url;
-  CURL * handle = curl_easy_init();
-  curl_easy_setopt(handle,CURLOPT_NOSIGNAL,1);
-  curl_easy_setopt(handle,CURLOPT_URL,url.text());
-  curl_easy_setopt(handle,CURLOPT_WRITEFUNCTION,download_write);
-  curl_easy_setopt(handle,CURLOPT_WRITEDATA,&response->data);
-  curl_easy_setopt(handle,CURLOPT_FOLLOWLOCATION,1); /// Perhaps update the database with the new url
-#ifdef DEBUG
-  curl_easy_setopt(handle,CURLOPT_VERBOSE,1); /// Perhaps update the database with the new url
-#endif
-  curl_easy_setopt(handle,CURLOPT_ERRORBUFFER,errorbuf);
-  if (curl_easy_perform(handle)) {
-    errormsg=errorbuf;
-    gui.message(GMPlayerManager::instance(),FXSEL(SEL_COMMAND,GMPlayerManager::ID_DOWNLOAD_COMPLETE));
-    }
-  else {
-    FXchar * ct;
-    if (curl_easy_getinfo(handle,CURLINFO_CONTENT_TYPE,&ct)==CURLE_OK){
-      response->content_type = ct;
+  HttpClient client;
+
+  // HEAD request don't always work...
+  if (client.basic("GET",url) && client.status.code==200) {
+    response->content_type = client.getHeader("content-type");
+    if (response->content_type.find("audio/mpegurl")!=-1 ||
+        response->content_type.find("audio/x-mpegurl")!=-1 ||
+        response->content_type.find("application/pls+xml")!=-1 ||
+        response->content_type.find("audio/x-scpls")!=-1) {
+      response->data=client.body();
       }
     gui.message(GMPlayerManager::instance(),FXSEL(SEL_COMMAND,GMPlayerManager::ID_DOWNLOAD_COMPLETE),&response,sizeof(GMFetchResponse*));
     }
-  curl_easy_cleanup(handle);
-#endif
+  else {
+    errormsg="Failed to retrieve";
+    gui.message(GMPlayerManager::instance(),FXSEL(SEL_COMMAND,GMPlayerManager::ID_DOWNLOAD_COMPLETE));
+    }
   return 0;
   }
 
 void GMFetch::init() {
-#ifdef HAVE_CURL
-  curl_global_init(CURL_GLOBAL_NOTHING);
-#endif
   }
 
 void GMFetch::exit() {
-#ifdef HAVE_CURL
   if (fetch) {
 
     if (fetch->running())
@@ -84,13 +66,10 @@
     delete fetch;
     fetch=NULL;
     }
-  curl_global_cleanup();
-#endif
   }
 
 
 void GMFetch::download(const FXString & url) {
-#ifdef HAVE_CURL
   if (fetch==NULL) {
     fetch = new GMFetch();
     }
@@ -100,26 +79,17 @@
     }
   fetch->url = url;
   fetch->start();
-#else
-  GMPlayerManager::instance()->handle(GMPlayerManager::instance(),FXSEL(SEL_COMMAND,GMPlayerManager::ID_DOWNLOAD_COMPLETE),NULL);
-#endif
   }
 
 void GMFetch::cancel_and_wait(){
-#ifdef HAVE_CURL
   if (fetch && fetch->running() ) {
     fetch->join();
     }
-#endif
   }
 
 FXbool GMFetch::busy(){
-#ifdef HAVE_CURL
   if (fetch && fetch->running() )
     return true;
   else
     return false;
-#else
-  return false;
-#endif
   }

gogglesmm-0.12.4.tar.bz2/src/GMIconTheme.cpp -> gogglesmm-0.12.5.tar.bz2/src/GMIconTheme.cpp Changed

gogglesmm-0.12.4.tar.bz2/src/GMPlayer.cpp -> gogglesmm-0.12.5.tar.bz2/src/GMPlayer.cpp Changed

gogglesmm-0.12.4.tar.bz2/src/GMPlayerManager.cpp -> gogglesmm-0.12.5.tar.bz2/src/GMPlayerManager.cpp Changed

@@ -88,7 +88,10 @@
   FXMAPFUNC(SEL_CLOSE,GMPlayerManager::ID_WINDOW,GMPlayerManager::onCmdCloseWindow),
   FXMAPFUNC(SEL_SIGNAL,GMPlayerManager::ID_CHILD,GMPlayerManager::onCmdChild),
 
-  FXMAPFUNC(SEL_COMMAND,GMPlayerManager::ID_SCROBBLER_ERROR,GMPlayerManager::onScrobblerError),
+  FXMAPFUNC(SEL_COMMAND,GMPlayerManager::ID_SCROBBLER,GMPlayerManager::onScrobblerError),
+  FXMAPFUNC(SEL_OPENED,GMPlayerManager::ID_SCROBBLER,GMPlayerManager::onScrobblerOpen),
+
+
   FXMAPFUNC(SEL_COMMAND,GMPlayerManager::ID_EQUALIZER,GMPlayerManager::onCmdEqualizer),
   FXMAPFUNC(SEL_COMMAND,GMPlayerManager::ID_SHOW_MANAGER,GMPlayerManager::onCmdShowManager),
 
@@ -741,7 +744,7 @@
     }
 #endif
 
-  lastfm = new GMAudioScrobbler(this,ID_SCROBBLER_ERROR);
+  lastfm = new GMAudioScrobbler(this,ID_SCROBBLER);
 
 #ifdef HAVE_DBUS
   if (sessionbus) {
@@ -920,14 +923,9 @@
   }
 
 void GMPlayerManager::download(const FXString & filename){
-#ifdef HAVE_CURL
   FXString status = "Downloading " + filename + " ...";
   GMPlayerManager::instance()->setStatus(status);
   GMFetch::download(filename);
-#else
-  show_message("Error","No buildin support for m3u/pls streams. GMM was build without libcurl.");
-  reset_track_display();
-#endif
   }
 
 FXbool GMPlayerManager::play(const FXString & filename) {
@@ -1054,12 +1052,9 @@
   /// Check for pls or m3u, since xine cannot handle that
   FXbool local = gm_is_local_file(filename);
   if (!local) {
-    FXString extension = FXPath::extension(GMURL::path(filename));
-    if ((comparecase(extension,"pls")==0) || (comparecase(extension,"m3u")==0)){
-      trackinfo.mrl = filename;
-      download(filename);
-      return;
-      }
+    trackinfo.mrl = filename;
+    download(filename);
+    return;
     }
 
   if (local) {
@@ -1125,13 +1120,8 @@
   /// Check for pls or m3u, since xine cannot handle that
   FXbool local = gm_is_local_file(trackinfo.mrl);
   if (!local) {
-
-    FXString extension = FXPath::extension(GMURL::path(trackinfo.mrl));
-    if ((comparecase(extension,"pls")==0) || (comparecase(extension,"m3u")==0)){
-      download(trackinfo.mrl);
-      reset_track_display();
-      return;
-      }
+    download(trackinfo.mrl);
+    return;
     }
 
   if (play(trackinfo.mrl)){
@@ -1205,11 +1195,8 @@
   /// Check for pls or m3u, since xine cannot handle that
   FXbool local = gm_is_local_file(trackinfo.mrl);
   if (!local) {
-    FXString extension = FXPath::extension(GMURL::path(trackinfo.mrl));
-    if ((comparecase(extension,"pls")==0) || (comparecase(extension,"m3u")==0)){
-      download(trackinfo.mrl);
-      return;
-      }
+    download(trackinfo.mrl);
+    return;
     }
 
   if (play(trackinfo.mrl) && gm_is_local_file(trackinfo.mrl))
@@ -1249,11 +1236,8 @@
   /// Check for pls or m3u, since xine cannot handle that
   FXbool local = gm_is_local_file(trackinfo.mrl);
   if (!local) {
-    FXString extension = FXPath::extension(GMURL::path(trackinfo.mrl));
-    if ((comparecase(extension,"pls")==0) || (comparecase(extension,"m3u")==0)){
-      download(trackinfo.mrl);
-      return;
-      }
+    download(trackinfo.mrl);
+    return;
     }
 
   if (play(trackinfo.mrl) && gm_is_local_file(trackinfo.mrl))
@@ -1556,11 +1540,17 @@
   return 1;
   }
 
+
 long GMPlayerManager::onScrobblerError(FXObject*,FXSelector,void*ptr){
   show_message(fxtr("Last.FM Error"),(const FXchar*)ptr);
   return 1;
   }
 
+long GMPlayerManager::onScrobblerOpen(FXObject*,FXSelector,void*ptr){
+  gm_open_browser((const FXchar*)ptr);
+  return 1;
+  }
+
 long GMPlayerManager::onPlayerError(FXObject*,FXSelector,void*){
   FXString errormsg;
   player->getErrorMessage(errormsg);
@@ -1576,18 +1566,21 @@
     response = *((GMFetchResponse**)ptr);
 
   if (response) {
-     if (response->url == trackinfo.mrl ) {
+    if (response->url == trackinfo.mrl ) {
       FXStringList list;
-      FXString extension = FXPath::extension(GMURL::path(response->url));
-      if (comparecase(extension,"pls")==0 || response->content_type.find("audio/x-scpls")!=-1)
-        gm_parse_pls(response->data,list);
-      else if (comparecase(extension,"m3u")==0 || response->content_type.find("audio/mpegurl")!=-1)
+      if ((response->content_type.find("audio/mpegurl")!=-1 ||
+          response->content_type.find("audio/x-mpegurl")!=-1) && response->data.length()){
         gm_parse_m3u(response->data,list);
+        }
+      else if ((response->content_type.find("application/pls+xml")!=-1 ||
+                response->content_type.find("audio/x-scpls")!=-1) && response->data.length()) {
 
-      if (list.no())
-        play(list);
-      else
-        reset_track_display();
+        gm_parse_pls(response->data,list);
+        }
+      else {
+        list.append(response->url);
+        }
+      play(list);
       }
     else {
       reset_track_display();

gogglesmm-0.12.4.tar.bz2/src/GMPlayerManager.h -> gogglesmm-0.12.5.tar.bz2/src/GMPlayerManager.h Changed

gogglesmm-0.12.4.tar.bz2/src/GMPreferencesDialog.cpp -> gogglesmm-0.12.5.tar.bz2/src/GMPreferencesDialog.cpp Changed

@@ -221,7 +221,6 @@
 FXDEFMAP(GMPreferencesDialog) GMPreferencesDialogMap={
   FXMAPFUNC(SEL_COMMAND,GMPreferencesDialog::ID_LASTFM_SCROBBLE,GMPreferencesDialog::onCmdLastFMScrobble),
   FXMAPFUNC(SEL_COMMAND,GMPreferencesDialog::ID_LASTFM_SERVICE,GMPreferencesDialog::onCmdLastFMService),
-
   FXMAPFUNC(SEL_COMMAND,GMPreferencesDialog::ID_LASTFM_USERNAME,GMPreferencesDialog::onCmdLastFMUserName),
   FXMAPFUNC(SEL_CHANGED,GMPreferencesDialog::ID_LASTFM_USERNAME,GMPreferencesDialog::onCmdLastFMUserName),
   FXMAPFUNC(SEL_FOCUSIN,GMPreferencesDialog::ID_LASTFM_PASSWORD,GMPreferencesDialog::onFocusLastFMPassWord),
@@ -306,9 +305,11 @@
     }
 #endif
 
+
   grpbox =  new FXGroupBox(vframe,tr("Last.fm"),FRAME_NONE|LAYOUT_FILL_X,0,0,0,0,23,3,0,0,0,0);
   grpbox->setFont(GMApp::instance()->getThickFont());
 
+
   if (GMPlayerManager::instance()->getAudioScrobbler()->isBanned()) {
     new FXLabel(grpbox,tr("This version of Goggles Music Manager is\n"
                        "not supported by Last-FM. Please upgrade\n"
@@ -339,10 +340,11 @@
     if (current_service==SERVICE_CUSTOM) lastfm_join->hide();
 
 
-    new FXLabel(matrix,tr("Username:"),NULL,labelstyle);
+    lastfm_username_label = new FXLabel(matrix,tr("Username:"),NULL,labelstyle);
     lastfm_username = new GMTextField(matrix,20,this,ID_LASTFM_USERNAME,FRAME_SUNKEN|FRAME_THICK);
-    new FXLabel(matrix,tr("Password:"),NULL,labelstyle);
+    lastfm_password_label = new FXLabel(matrix,tr("Password:"),NULL,labelstyle);
     lastfm_password = new GMTextField(matrix,20,this,ID_LASTFM_PASSWORD,FRAME_SUNKEN|FRAME_THICK|TEXTFIELD_PASSWD);
+
     new FXFrame(matrix,FRAME_NONE);
     lastfm_scrobble = new GMCheckButton(grpbox,tr("Scrobble"),this,ID_LASTFM_SCROBBLE,LAYOUT_FIX_X|LAYOUT_FIX_Y|CHECKBUTTON_NORMAL,6,0);
     lastfm_scrobble->setFont(GMApp::instance()->getThickFont());
@@ -352,8 +354,22 @@
       lastfm_password->setText("1234567890");
 
     lastfm_scrobble->setCheck(GMPlayerManager::instance()->getAudioScrobbler()->isEnabled());
+
+    if (current_service==SERVICE_LASTFM){
+      lastfm_username->hide();
+      lastfm_username_label->hide();
+      lastfm_password->hide();
+      lastfm_password_label->hide();
+      }
+    else {
+      lastfm_username->show();
+      lastfm_username_label->show();
+      lastfm_password->show();
+      lastfm_password_label->show();
+      }
     }
 
+
   new GMTabItem(tabbook,tr("&Window"),NULL,TAB_TOP_NORMAL,0,0,0,0,5,5);
   vframe = new GMTabFrame(tabbook);
 
@@ -701,6 +717,13 @@
   }
 
 
+
+
+
+
+
+
+
 long GMPreferencesDialog::onCmdLastFMScrobble(FXObject*,FXSelector,void*){
   if (lastfm_scrobble->getCheck())
     GMPlayerManager::instance()->getAudioScrobbler()->enable();
@@ -712,6 +735,8 @@
 
 long GMPreferencesDialog::onCmdLastFMService(FXObject*,FXSelector,void*){
   if (lastfm_service->getCurrentItem()!=SERVICE_CUSTOM) {
+
+
     GMPlayerManager::instance()->getAudioScrobbler()->service(lastfm_service->getCurrentItem());
     lastfm_username->setText(FXString::null,false);
     lastfm_password->setText(FXString::null,false);
@@ -722,6 +747,19 @@
       }
     lastfm_join->show();
     }
+
+  if (lastfm_service->getCurrentItem()==SERVICE_LASTFM){
+    lastfm_username->hide();
+    lastfm_username_label->hide();
+    lastfm_password->hide();
+    lastfm_password_label->hide();
+    }
+  else {
+    lastfm_username->show();
+    lastfm_username_label->show();
+    lastfm_password->show();
+    lastfm_password_label->show();
+    }
   return 1;
   }
 
@@ -769,7 +807,6 @@
   }
 
 
-
 long GMPreferencesDialog::onCmdElementColor(FXObject*,FXSelector sel,void* rgba) {
   FXColor color = (FXColor)(FXuval)rgba;

gogglesmm-0.12.4.tar.bz2/src/GMPreferencesDialog.h -> gogglesmm-0.12.5.tar.bz2/src/GMPreferencesDialog.h Changed

gogglesmm-0.12.4.tar.bz2/src/GMTrackList.h -> gogglesmm-0.12.5.tar.bz2/src/GMTrackList.h Changed

gogglesmm-0.12.5.tar.bz2/src/ap_buffer.cpp Added

@@ -0,0 +1,168 @@
+#include "gmdefs.h"
+#include "ap_buffer.h"
+
+#define ROUNDVAL    16
+#define ROUNDUP(n)  (((n)+ROUNDVAL-1)&-ROUNDVAL)
+
+namespace ap {
+
+MemoryBuffer::MemoryBuffer(FXival cap) :
+  buffer(NULL),
+  buffersize(0),
+  rdptr(NULL),
+  wrptr(NULL) {
+  reserve(cap);
+  }
+
+MemoryBuffer::MemoryBuffer(const MemoryBuffer & other) :
+  buffer(NULL),
+  buffersize(0),
+  rdptr(NULL),
+  wrptr(NULL) {
+  reserve(other.capacity());
+  append(other.data(),other.size());
+  }
+
+MemoryBuffer::~MemoryBuffer() {
+  freeElms(buffer);
+  buffersize=0;
+  wrptr=rdptr=NULL;
+  }
+
+// Assignment operator
+MemoryBuffer& MemoryBuffer::operator=(const MemoryBuffer& other) {
+  clear();
+  reserve(other.capacity());
+  append(other.data(),other.size());
+  return *this;
+  }
+
+// Append operator
+MemoryBuffer& MemoryBuffer::operator+=(const MemoryBuffer& other) {
+  reserve(other.capacity());
+  append(other.data(),other.size());
+  return *this;
+  }
+
+
+void MemoryBuffer::adopt(MemoryBuffer & other) {
+
+  // Take over
+  buffer=other.buffer;
+  buffersize=other.buffersize;
+  rdptr=other.rdptr;
+  wrptr=other.wrptr;
+
+  // Reset Other
+  other.buffer=other.rdptr=other.wrptr=NULL;
+  other.buffersize=0;
+  }
+
+
+// Clear
+void MemoryBuffer::clear() {
+  wrptr=rdptr=buffer;
+  }
+
+// Clear and reset
+void MemoryBuffer::reset(FXival nbytes) {
+  clear();
+  if (buffersize!=nbytes) {
+    buffersize=nbytes;
+    resizeElms(buffer,buffersize);
+    wrptr=rdptr=buffer;
+    }
+  }
+
+
+// Make room for needed bytes
+void MemoryBuffer::reserve(FXival needed) {
+  if (needed>0) {
+    if (buffer) {
+      FXival avail = space();
+
+      /// Check if we can move back rdptr/wrptr
+      if (avail<needed) {
+        if (rdptr>buffer) {
+          if (wrptr>rdptr) {
+            memmove(buffer,rdptr,wrptr-rdptr);
+            wrptr-=(rdptr-buffer);
+            rdptr = buffer;
+            avail = space();
+            }
+          else {
+            wrptr=rdptr=buffer;
+            avail=buffersize;
+            }
+          }
+        }
+
+      /// Still not enough space, resize buffer
+      if (avail<needed) {
+        buffersize=ROUNDUP(buffersize+(needed-avail));
+        avail=wrptr-buffer;
+        resizeElms(buffer,buffersize);
+        wrptr=rdptr=buffer;
+        wrptr+=avail;
+        }
+      }
+    else {
+      buffersize=needed;
+      allocElms(buffer,buffersize);
+      wrptr=rdptr=buffer;
+      }
+    }
+  }
+
+
+void MemoryBuffer::readBytes(FXival nbytes) {
+  FXASSERT(nbytes<=size());
+  rdptr+=nbytes;
+  }
+
+void MemoryBuffer::wroteBytes(FXival nbytes) {
+  FXASSERT(nbytes<=space());
+  wrptr+=nbytes;
+  }
+
+void MemoryBuffer::append(const void * b,FXival nbytes) {
+  if (nbytes) {
+    reserve(nbytes);
+    memcpy(wrptr,b,nbytes);
+    wrptr+=nbytes;
+    }
+  }
+
+void MemoryBuffer::append(const FXchar c,FXival nbytes/*=1*/) {
+  FXASSERT(nbytes>=1);
+  reserve(nbytes);
+  while(nbytes--) *wrptr++=c;
+  }
+
+
+FXival MemoryBuffer::read(void * b, FXival nbytes) {
+  //FXASSERT(nbytes<size());
+  nbytes=FXMIN(size(),nbytes);
+  memcpy(b,rdptr,nbytes);
+  readBytes(nbytes);
+  return nbytes;
+  }
+
+FXival MemoryBuffer::peek(void * b, FXival nbytes) {
+//  FXASSERT(nbytes<size());
+  nbytes=FXMIN(size(),nbytes);
+  memcpy(b,rdptr,nbytes);
+  return nbytes;
+  }
+
+
+void MemoryBuffer::trimBegin(FXival nbytes) {
+  readBytes(nbytes);
+  }
+
+void MemoryBuffer::trimEnd(FXival nbytes) {
+  FXASSERT(nbytes<=size());
+  wrptr-=nbytes;
+  }
+
+}

gogglesmm-0.12.5.tar.bz2/src/ap_buffer.h Added

@@ -0,0 +1,96 @@
+#ifndef AP_MEMORY_BUFFER_H
+#define AP_MEMORY_BUFFER_H
+
+namespace ap {
+
+
+class MemoryBuffer {
+protected:
+  FXchar * buffer;
+  FXival   buffersize;
+  FXchar * rdptr;
+  FXchar * wrptr;
+public:
+  // Constructor
+  MemoryBuffer(FXival cap=4096);
+
+  // Construct initialized from other buffer
+  MemoryBuffer(const MemoryBuffer &);
+
+  // Assignment operator
+  MemoryBuffer& operator=(const MemoryBuffer&);
+
+  // Append operator
+  MemoryBuffer& operator+=(const MemoryBuffer&);
+
+  // Adopt from buffer
+  void adopt(MemoryBuffer &);
+
+  // Make room for nbytes
+  void reserve(FXival nbytes);
+
+  // Clear buffer and reset to nbytes
+  void reset(FXival nbytes=4096);
+
+  // Clear buffer
+  void clear();
+
+  // Number of unread bytes
+  FXival size() const { return (wrptr-rdptr); }
+
+  // Number of bytes that can be written
+  FXival space() const { return buffersize - (wrptr-buffer); }
+
+  // Size of the buffer
+  FXival capacity() const { return buffersize; }
+
+  // Read nbytes
+  FXival read(void * bytes,FXival nbytes);
+
+  // Read nbytes without advancing the read ptr.
+  FXival peek(void * bytes,FXival nbytes);
+
+  // Append bytes of nbytes.
+  void append(const void * bytes,FXival nbytes);
+
+  // Append constant nbytes.
+  void append(const FXchar c, FXival nbytes=1);
+
+  // Wrote nbytes. Updates the wrptr
+  void wroteBytes(FXival nbytes);
+
+  // Read nbytes. Update the rdptr
+  void readBytes(FXival nbytes);
+
+  /// Trim nbytes at beginning
+  void trimBegin(FXival nbytes);
+
+  /// Trim nbytes at end
+  void trimEnd(FXival nbytes);
+
+
+  /// Index into array
+  const FXchar& operator(FXint i) const { return rdptri; }
+
+  /// Return write pointer
+  FXuchar* ptr() { return (FXuchar*)wrptr; }
+  const FXuchar* ptr() const { return (FXuchar*)wrptr; }
+
+  FXfloat * flt() { return reinterpret_cast<FXfloat*>(wrptr); }
+  FXchar  * s8()  { return reinterpret_cast<FXchar*>(wrptr); }
+  FXshort * s16() { return reinterpret_cast<FXshort*>(wrptr); }
+  FXint   * s32() { return reinterpret_cast<FXint*>(wrptr); }
+
+  /// Return pointer to buffer
+  FXuchar* data() { return (FXuchar*)rdptr; }
+  const FXuchar* data() const { return (const FXuchar*)rdptr; }
+
+  void setReadPosition(const FXuchar *p) { rdptr=(FXchar*)p; }
+
+  // Destructor
+  ~MemoryBuffer();
+  };
+}
+
+#endif
+

gogglesmm-0.12.5.tar.bz2/src/ap_http.cpp Added

@@ -0,0 +1,997 @@
+#include "gmdefs.h"
+#include "ap_buffer.h"
+#include "ap_http.h"
+
+
+#ifndef WIN32
+#include <unistd.h> // for close()
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h> // for getaddrinfo()
+#endif
+
+#ifndef MSG_NOSIGNAL
+#define MSG_NOSIGNAL 0
+#endif
+
+#if FOXVERSION < FXVERSION(1,7,0)
+#define APIntVal(x)  FXIntVal((x))
+#define APStringVal FXStringVal
+#else
+#define APIntVal(x) ((x).toInt())
+#define APStringVal FXString::value
+#endif
+
+#ifndef BadHandle
+#ifdef WIN32
+#define BadHandle INVALID_HANDLE_VALUE
+#else
+#define BadHandle -1
+#endif
+#endif
+
+
+using namespace ap;
+
+namespace ap {
+
+
+FXint HttpStatus::type() const {
+  if (code>=100 && code<200)
+    return HTTP_RESPONSE_INFORMATIONAL;
+  else if (code>=200 && code<300)
+    return HTTP_RESPONSE_SUCCESS;
+  else if (code>=300 && code<400)
+    return HTTP_RESPONSE_REDIRECT;
+  else if (code>=400 && code<500)
+    return HTTP_RESPONSE_CLIENT_ERROR;
+  else if (code>=500 && code<600)
+    return HTTP_RESPONSE_SERVER_ERROR;
+  else
+    return HTTP_RESPONSE_FAILED;
+  }
+
+
+HttpResponse::HttpResponse() :
+  flags(0),
+  content_length(-1),
+  chunk_remaining(-1) {
+  }
+
+HttpResponse::~HttpResponse() {
+  clear();
+  }
+
+void HttpResponse::clear() {
+  flags=0;
+  content_length=-1;
+  chunk_remaining=-1;
+  clear_headers();
+  }
+
+
+// Read (at most) nbytes from buffer or source
+FXival HttpResponse::read(FXchar*ptr,FXival nbytes) {
+  FXival nread=0;
+  while(nbytes) {
+    if (buffer.size()) {
+      FXival n = buffer.read(ptr,nbytes);
+      nread+=n;
+      nbytes-=n;
+      ptr+=n;
+      }
+    else {
+      FXival n = readBlock(ptr,nbytes);
+      if (n<=0) return (nread>0) ? nread : n;
+      nread+=n;
+      nbytes-=n;
+      ptr+=n;
+      }
+    }
+  return nread;
+  }
+
+// Fill buffer with (at most) nbytes
+FXival HttpResponse::fill(FXival nbytes) {
+  buffer.reserve(nbytes);
+  FXival nread = readBlock((FXchar*)buffer.ptr(),nbytes);
+  if (nread>0) {
+    //fxmessage("buf: \"%s\"\n",buffer.data());
+    buffer.wroteBytes(nread);
+    }
+  return nread;
+  }
+
+
+// Try parsing one HTTP header from buffer. If succesfull, returns
+// headers. Mode can either be HEADER_SINGLE_LINE or HEADER_MULTIPLE_LINES,
+// depending on whether headers may span multiple lines or not.
+FXbool HttpResponse::parse_header(FXString & line,FXuint mode) {
+  FXint len=0,i,j,l;
+  for (i=0;i<buffer.size()-1;i++){
+    if (bufferi=='\r' && bufferi+1=='\n') {
+
+      // If header cannot span multiple lines, we're done here.
+      if (mode==HEADER_SINGLE_LINE) {
+        if (i>0) line.assign((FXchar*)buffer.data(),i);
+        buffer.readBytes(i+2);
+        return true;
+        }
+
+      // check if header continues on the next line
+      if (len>0) {
+
+        // need more bytes
+        if ((i+2)>=buffer.size())
+            return false;
+
+        /// header continues on next line
+        if (bufferi+2==' ' || bufferi+2=='\t')
+            continue;
+        }
+
+      /// copy string
+      line.length(len);
+      for (j=0,l=0;l<len;j++){
+        if (bufferj=='\r' || bufferj=='\n')
+          continue;
+        linel++=bufferj;
+        }
+      buffer.readBytes(i+2);
+      return true;
+      }
+    len++;
+    }
+  return false;
+  }
+
+// Store parsed header into headers.
+void HttpResponse::insert_header(const FXString & header) {
+  FXString key   = header.before(':').lower();
+  FXString value = header.after(':').trim();
+  FXString * existing = (FXString*)headers.find(key.text());
+  if (existing) {
+    (*existing) += ", " + value;
+    }
+  else {
+    FXString * v = new FXString;
+    v->adopt(value);
+    headers.replace(key.text(),v);
+    }
+  }
+
+void HttpResponse::clear_headers() {
+  for (FXint pos=headers.first();pos<=headers.last();pos=headers.next(pos)) {
+    FXString * field = (FXString*) headers.data(pos);
+    delete field;
+    }
+  headers.clear();
+  }
+
+void HttpResponse::check_headers() {
+  FXString * field = NULL;
+
+  field = (FXString*) headers.find("content-length");
+  if (field)
+    content_length = APIntVal(*field);
+
+  field = (FXString*) headers.find("transfer-encoding");
+  if (field && field->contains("chunked") )
+    flags|=ChunkedResponse;
+
+  field = (FXString*) headers.find("connection");
+  if (field && comparecase(*field,"close")==0)
+    flags|=ConnectionClose;
+
+#ifdef DEBUG
+  for (FXint pos=headers.first();pos<=headers.last();pos=headers.next(pos)) {
+    fxmessage("%s: %s\n",headers.key(pos),((FXString*)headers.data(pos))->text());
+    }
+#endif
+  }
+
+
+
+
+// Read a chunk header and set the chunksize
+FXbool HttpResponse::read_chunk_header(FXint & chunksize) {
+  FXString header;
+  FXchar   clrf2;
+
+  // We've read a previous chunk
+  if (chunksize==0) {
+    if (read(clrf,2)!=2 || clrf0!='\r' || clrf1!='\n') {
+      fxwarning("http: missing line feed: %c%c\n",clrf0,clrf1);
+      return false;
+      }
+    }
+
+  if (read_header(header,HEADER_SINGLE_LINE)) {
+    if (header.scan("%x",&chunksize)==1) {
+      return true;
+      }
+    }
+  return false;
+  }
+
+
+// Read status line and set status.
+FXbool HttpResponse::read_status() {
+  FXString header;
+  if (read_header(header,HEADER_SINGLE_LINE)) {
+    if (header.scan("HTTP/%d.%d %d",&status.major,&status.minor,&status.code)==3 ||
+        header.scan("ICY %d",&status.code)==1){
+      //fxmessage("Code: %d \nVersion: %d.%d\n",status.code,status.major,status.minor);
+      return true;
+      }
+    }
+  return false;
+  }
+
+// Read header
+FXbool HttpResponse::read_header(FXString & header,FXuint mode) {
+  while(!parse_header(header,mode)) {
+    if (fill()==-1)
+      return false;
+    }
+  return true;
+  }
+
+
+
+
+// Read the full message body non-chunked
+FXString HttpResponse::read_body() {
+  FXString body;
+  if (content_length==0) {
+    return FXString::null;
+    }
+  else if (content_length>0) {
+    body.length(content_length);
+    FXival n = read(&body0,content_length);
+    if (n<content_length)  // Partial Transfer...
+      return FXString::null;
+    }
+  else {
+    const FXint BLOCK=4096;
+    FXint pos=0;
+    FXival n=0;
+    do {
+      body.length(body.length()+BLOCK);
+      n = read(&bodypos,BLOCK);
+      if (n>0) pos+=n;
+      }
+    while(n==BLOCK);
+
+    if (pos>0)
+      body.length(pos);
+    }
+  return body;
+  }
+
+// Read the full message body chunked
+FXString HttpResponse::read_body_chunked() {
+  FXString header;
+  FXString body;
+  FXint    chunksize=-1;
+
+  if (read_chunk_header(chunksize)) {
+
+    while(chunksize) {
+
+      // Resize buffer
+      body.length(body.length()+chunksize);
+
+      // Anything less than chunksize is an error
+      if (read(&bodybody.length()-chunksize,chunksize)<chunksize)
+        goto fail;
+
+      // Set to zero so read_chunk_header will check for crlf
+      chunksize=0;
+
+      // Next chunk header
+      if (!read_chunk_header(chunksize))
+        goto fail;
+      }
+
+    // Trailing Headers
+    while(read_header(header,HEADER_MULTIPLE_LINES)) {
+
+      // empty header indicates end of headers
+      if (header.empty())
+        break;
+
+      insert_header(header);
+      }
+
+    return body;
+    }
+fail:
+  return FXString::null;
+  }
+
+
+
+
+
+FXival HttpResponse::read_body(FXchar *& body) {
+  body=NULL;
+
+  if (content_length>0) {
+    allocElms(body,content_length);
+    FXival n = read(body,content_length);
+    if (n!=content_length) {
+      freeElms(body);
+      body=NULL;
+      return -1;
+      }
+    return content_length;
+    }
+  else if (content_length<0) {
+    const FXint BLOCK=4096;
+    FXint  size = 0;
+    FXival len  = 0;
+    FXival n;
+    do {
+      resizeElms(body,size+BLOCK);
+      size+=BLOCK;
+      n = read(body+len,BLOCK);
+      if (n>0) len+=n;
+      }
+    while(n==BLOCK);
+    return len;
+    }
+  else {
+    return 0;
+    }
+  }
+
+
+FXival HttpResponse::read_body_chunked(FXchar *& body) {
+  FXString header;
+  FXint    size=0;
+  FXint    chunksize=-1;
+
+  body = NULL;
+
+  if (read_chunk_header(chunksize)) {
+
+    while(chunksize) {
+
+      // Resize buffer
+      size+=chunksize;
+      resizeElms(body,size);
+
+      // Anything less than chunksize is an error
+      if (read(body+size-chunksize,chunksize)<chunksize)
+        goto fail;
+
+      // Set to zero so read_chunk_header will check for crlf
+      chunksize=0;
+
+      // Next chunk header
+      if (!read_chunk_header(chunksize))
+        goto fail;
+      }
+
+    // Trailing Headers
+    while(read_header(header,HEADER_MULTIPLE_LINES)) {
+
+      // empty header indicates end of headers
+      if (header.empty())
+        break;
+
+      insert_header(header);
+      }
+
+    return size;
+    }
+fail:
+  freeElms(body);
+  return -1;
+  }
+
+
+FXival HttpResponse::read_body(void*ptr,FXival len) {
+  if (content_length >= 0) {
+    FXchar * data = (FXchar*)ptr;
+    FXival n = read(data,FXMIN(content_length,len));
+    if (n>0) content_length-=n;
+    return n;
+    }
+  else {
+    return read((FXchar*)ptr,len);
+    }
+  }
+
+
+FXival HttpResponse::read_body_chunked(void * ptr,FXival len) {
+  FXchar * data = (FXchar*)ptr;
+  FXString header;
+  FXival   nbytes=0;
+  while(len) {
+
+    if (chunk_remaining<=0) {
+
+      if (!read_chunk_header(chunk_remaining))
+        return -1;
+
+      if (chunk_remaining==0) {
+
+        // Trailing Headers
+        while(read_header(header,HEADER_MULTIPLE_LINES)) {
+
+          // empty header indicates end of headers
+          if (header.empty())
+            break;
+
+          insert_header(header);
+          }
+
+        return nbytes;
+        }
+      }
+
+    FXival n = read(data+nbytes,FXMIN(len,chunk_remaining));
+    if (n<=0) return nbytes;
+    chunk_remaining-=n;
+    nbytes+=n;
+    len-=n;
+    }
+  return nbytes;
+  }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Parse the response status and headers. Returns true if succesful
+FXint HttpResponse::parse() {
+  FXString header;
+  if (read_status()) {
+    while(read_header(header,HEADER_MULTIPLE_LINES)) {
+      // empty header indicates end of headers
+      if (header.empty()) {
+        check_headers();
+        return status.type();
+        }
+      insert_header(header);
+      }
+    }
+  return HTTP_RESPONSE_FAILED;
+  }
+
+// Read the full message body into string
+FXString HttpResponse::body() {
+  if (flags&HeadRequest)
+    return FXString::null;
+  else if (flags&ChunkedResponse)
+    return read_body_chunked();
+  else
+    return read_body();
+  }
+
+// Read the full message body into buffer
+FXival HttpResponse::body(FXchar *& out) {
+  if (flags&HeadRequest)
+    return 0;
+  else if (flags&ChunkedResponse)
+    return read_body_chunked(out);
+  else
+    return read_body(out);
+  }
+
+
+FXival HttpResponse::readBody(void * ptr,FXival len) {
+  if (flags&HeadRequest)
+    return 0;
+  else if (flags&ChunkedResponse)
+    return read_body_chunked(ptr,len);
+  else
+    return read_body(ptr,len);
+  }
+
+
+void HttpResponse::discard() {
+  if (!(flags&ConnectionClose) && !(flags&HeadRequest)) {
+    FXchar buffer1024;
+    while(readBody(buffer,1024)==1024) ;
+    }
+  }
+
+FXString HttpResponse::getHeader(const FXString & key) const {
+  FXString * value = (FXString*)headers.find(key.text());
+  if (value)
+    return (*value);
+  else
+    return FXString::null;
+  }
+
+
+FXint HttpResponse::getContentLength() const {
+  return content_length;
+  }
+
+
+
+
+
+
+
+
+
+
+HttpHost::HttpHost() : port(0) {
+  }
+
+HttpHost::HttpHost(const FXString & url) {
+  set(url);
+  }
+
+FXbool HttpHost::set(const FXString & url) {
+  FXString nn = GMURL::host(url);
+  FXint    np = GMURL::port(url);
+  if (np==0) np=80;
+
+  if (name!=nn || port!=np) {
+    name.adopt(nn);
+    port=np;
+    return true;
+    }
+  return false;
+  }
+
+
+
+
+HttpClient::HttpClient() : device(BadHandle) {
+    }
+
+
+HttpClient::~HttpClient() {
+  close();
+  }
+
+void HttpClient::close() {
+  if (device!=BadHandle) {
+    shutdown(device,SHUT_RDWR);
+    ::close(device);
+    device=BadHandle;
+    }
+  }
+
+void HttpClient::discard() {
+  if (flags&ConnectionClose) {
+    close();
+    }
+  else {
+    HttpResponse::discard();
+    }
+  }
+
+#ifndef SOCK_NONBLOCK
+static FXbool ap_set_nonblocking(FXint fd) {
+  FXint flags;
+
+  flags = fcntl(fd, F_GETFL);
+  if (flags==-1) return false;
+
+  flags |= O_NONBLOCK;
+
+  if (fcntl(fd,F_SETFL,flags)==-1)
+    return false;
+
+  return true;
+  }
+#endif
+
+#ifndef SOCK_CLOEXEC
+static FXbool ap_set_closeonexec(FXint fd) {
+  FXint flags;
+
+  flags = fcntl(fd, F_GETFD);
+  if (flags==-1) return false;
+
+  flags |= FD_CLOEXEC;
+
+  if (fcntl(fd,F_SETFD,flags)==-1)
+    return false;
+
+  return true;
+  }
+#endif
+
+
+#if defined(SO_NOSIGPIPE)
+static FXbool ap_set_nosignal(FXint fd) {
+  int nosignal=1;
+  socklen_t len=sizeof(nosignal);
+  if (setsockopt(fd,SOL_SOCKET,SO_NOSIGPIPE,&nosignal,len)==0)
+    return true;
+  else
+    return false;
+  }
+#else
+static FXbool ap_set_nosignal(FXint)  {
+  // will try to use MSG_NOSIGNAL instead...
+  return true;
+  }
+#endif
+
+static FXbool ap_set_timeout(FXInputHandle handle,FXint timeout) {
+  struct timeval tv;
+
+  memset(&tv,0,sizeof(struct timeval));
+
+  tv.tv_sec  = timeout;
+
+  // Receiving
+  if (setsockopt(handle,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(struct timeval)))
+    return false;
+
+  // Sending
+  if (setsockopt(handle,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(struct timeval)))
+    return false;
+
+  return true;
+  }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static FXInputHandle ap_create_socket(FXint domain, FXint type, FXint protocol,FXbool nonblocking,FXuint timeout=10) {
+  FXInputHandle device = BadHandle;
+
+  // On linux 2.6.27 we can pass additional socket options
+  int opts=0;
+
+#ifdef SOCK_CLOEXEC
+  opts|=SOCK_CLOEXEC;
+#endif
+
+#ifdef SOCK_NONBLOCK
+  if (nonblocking)
+    opts|=SOCK_NONBLOCK;
+#endif
+
+  device = socket(domain,type|opts,protocol);
+  if (device==BadHandle)
+    return BadHandle;
+
+#ifndef SOCK_CLOEXEC
+  if (!ap_set_closeonexec(device)){
+    ::close(device);
+    return BadHandle;
+    }
+#endif
+
+#ifndef SOCK_NONBLOCK
+  if (nonblocking && !ap_set_nonblocking(device)){
+    ::close(device);
+    return BadHandle;
+    }
+#endif
+
+  // Don't want signals
+  if (!ap_set_nosignal(device)) {
+    ::close(device);
+    return BadHandle;
+    }
+
+  // In case of blocking sockets, set a timeout
+  if (!nonblocking && !ap_set_timeout(device,timeout)) {
+    ::close(device);
+    return BadHandle;
+    }
+
+  return device;
+  }
+
+
+FXbool HttpClient::open_connection() {
+  struct addrinfo   hints;
+  struct addrinfo * list=NULL;
+  struct addrinfo * item=NULL;
+  FXint result;
+
+
+  memset(&hints,0,sizeof(struct addrinfo));
+  hints.ai_family=AF_UNSPEC;
+  hints.ai_socktype=SOCK_STREAM;
+  hints.ai_flags|=(AI_NUMERICSERV|AI_ADDRCONFIG);
+
+
+  if (flags&UseProxy)
+    result=getaddrinfo(proxy.name.text(),APStringVal(proxy.port).text(),&hints,&list);
+  else
+    result=getaddrinfo(server.name.text(),APStringVal(server.port).text(),&hints,&list);
+
+  if (result)
+    return false;
+
+  for (item=list;item;item=item->ai_next){
+
+    device = ap_create_socket(item->ai_family,item->ai_socktype,item->ai_protocol,(flags&UseNonBlock));
+    if (device == BadHandle)
+      continue;
+
+    if (connect(device,item->ai_addr,item->ai_addrlen)==0){
+      freeaddrinfo(list);
+      return true;
+      }
+
+    // In case of non-blocking we need to wait for the socket to become ready to write.
+    if (errno==EINPROGRESS || errno==EINTR || errno==EWOULDBLOCK) {
+      if (wait_write(device)) {
+        int socket_error=0;
+        socklen_t socket_length=sizeof(socket_error);
+        if (getsockopt(device,SOL_SOCKET,SO_ERROR,&socket_error,&socket_length)==0 && socket_error==0){
+          freeaddrinfo(list);
+          return true;
+          }
+        }
+      else {
+        ::close(device);
+        device=BadHandle;
+        freeaddrinfo(list);
+        return false;
+        }
+      }
+
+    // Failed, try some other one.
+    ::close(device);
+    device=BadHandle;
+    }
+
+  if (list)
+    freeaddrinfo(list);
+  return false;
+  }
+
+
+FXival HttpClient::writeBlock(const void * data,FXival count) {
+  FXival nwritten=-1;
+  do{
+    nwritten=::write(device,data,count);
+    }
+  while(nwritten<0 && errno==EINTR);
+  return nwritten;
+  }
+
+FXival HttpClient::readBlock(void * data,FXival count) {
+  FXival nread=-1;
+  do{
+    nread=::read(device,data,count);
+    }
+  while(nread<0 && errno==EINTR);
+  return nread;
+  }
+
+
+FXbool HttpClient::send(const FXchar * data,FXint len) {
+  do {
+     FXival n = writeBlock(data,len);
+     if (n<=0) return false;
+     data += n;
+     len -= n;
+     }
+  while(len);
+  return true;
+  }
+
+
+
+void HttpClient::reset(FXbool forceclose){
+  if (forceclose)
+    close();
+  else
+    discard();
+
+  clear();
+  }
+
+
+FXbool HttpClient::request(const FXchar * method,const FXString & url,const FXString & headers,const FXString & body) {
+  FXString command,path,query;
+
+  // Set Server Host
+  FXbool host_changed = server.set(url);
+  if (flags&UseProxy)
+    host_changed = false;
+
+  // Reset Client
+  reset(host_changed);
+
+  if (compare(method,"HEAD")==0) {
+    flags|=HeadRequest;
+    }
+
+  // Open connection if necessary
+  if (device==BadHandle && !open_connection())
+    return false;
+
+  // Extract path and query
+  path  = GMURL::path(url);
+  if (path.empty())
+    path = "/";
+
+  query = GMURL::query(url);
+  if (!query.empty())
+    path += "?" + query;
+
+
+//  fxmessage("path: %s\n",path.text());
+
+  // Method + Path
+//  if (flags&HttpProxy)
+//    command = method + url  + "\r\n"
+  //else
+  command = method;
+  command += " " + path + " HTTP/1.1\r\n";
+
+  // Add Host
+  command += "Host: " + server.name + "\r\n";
+
+  // Add Content Length
+  if (body.length())
+    command +=  "Content-Length: " + APStringVal(body.length()) + "\r\n";
+
+  // Additional headers
+  command+=headers;
+
+  // End of headers
+  command += "\r\n";
+
+  // Add body
+  if (body.length())
+    command += body;
+
+  // Send Command
+  return send(command.text(),command.length());
+  }
+
+
+
+static FXString ap_encode_base64(const FXString & source) {
+  const FXchar base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const FXuchar * in = (const FXuchar*)source.text();
+  FXint remaining = source.length() % 3;
+  FXint length    = source.length() - remaining;
+  FXint n=0;
+  FXString out;
+
+  out.length(4*(source.length()/3));
+
+  for (int i=0;i<length;i+=3) {
+    outn++=base64(ini>>2);
+    outn++=base64((ini&0x3)<<4)|(ini+1>>4);
+    outn++=base64((ini+1&0xf)<<2)|(ini+2>>6);
+    outn++=base64(ini+2&0x3f);
+    }
+
+  if (remaining) {
+    outn++=base64(inlength>>2);
+    if (remaining>1) {
+      outn++=base64((inlength&0x3)<<4)|(inlength+1>>4);
+      outn++=base64((inlength+1&0xf)<<2)|inlength+2>>6;
+      outn++='=';
+      }
+    else {
+      outn++=base64((inlength&0x3)<<4);
+      outn++='=';
+      outn++='=';
+      }
+    }
+  return out;
+  }
+
+
+
+
+FXbool HttpClient::basic(const FXchar*    method,
+                         FXString         url,
+                         const FXString & headers,
+                         const FXString & body) {
+
+  if (request(method,url,headers,body)) {
+    do {
+      switch(parse()) {
+        case HTTP_RESPONSE_INFORMATIONAL:
+          {
+            if (status.code==HTTP_CONTINUE) {
+              continue;
+              }
+            break;
+          }
+        case HTTP_RESPONSE_REDIRECT     :
+          {
+            // 304 - Document not changed. We're done
+            // 305 - Need to use a proxy. Currently not handled
+            // 306 - Unused
+            if (status.code==HTTP_NOT_MODIFIED || status.code==HTTP_USE_PROXY || status.code==306)
+              return true;
+
+            url = getHeader("location");
+
+            // No url given, done here
+            if (url.empty())
+              return false;
+
+            // Don't do automatic redirections for non GET/HEAD requests
+            if (comparecase(method,"GET") && comparecase(method,"HEAD"))
+              return true;
+
+            if (!request(method,url,headers,body)) {
+              return false;
+              }
+            continue;
+            break;
+          }
+        case HTTP_RESPONSE_CLIENT_ERROR  :
+          {
+            if (status.code==HTTP_UNAUTHORIZED) {
+
+              FXString user     = GMURL::username(url);
+              FXString password = GMURL::password(url);
+
+              if (user.empty() || password.empty())
+                return true;
+
+              FXString challenge = getHeader("www-authenticate");
+
+              if (comparecase(challenge,"basic",5)==0) {
+                FXString auth = "Authorization: Basic " + ap_encode_base64(user+":"+password) + "\r\n";
+
+                if (!request(method,url,headers+auth,body)) {
+                  return false;
+                  }
+                continue;
+                }
+//              else if (comparecase(challenge,"digest",6)==0){
+//                FXASSERT(0);
+//                }
+              }
+          } break;
+
+        default: break;
+        }
+      return true;
+      }
+    while(1);
+    }
+  return false;
+  }
+
+
+
+
+}
+
+
+
+
+

gogglesmm-0.12.5.tar.bz2/src/ap_http.h Added

@@ -0,0 +1,282 @@
+#ifndef AP_HTTP_H
+#define AP_HTTP_H
+
+#ifndef GMAPI
+#define GMAPI
+#endif
+
+namespace ap {
+
+enum {
+    // HTTP status types
+    HTTP_RESPONSE_FAILED        = 0,
+    HTTP_RESPONSE_INFORMATIONAL = 1,
+    HTTP_RESPONSE_SUCCESS       = 2,
+    HTTP_RESPONSE_REDIRECT      = 3,
+    HTTP_RESPONSE_CLIENT_ERROR  = 4,
+    HTTP_RESPONSE_SERVER_ERROR  = 5,
+
+
+    // Informational 1xx
+    HTTP_CONTINUE                           = 100,
+    HTTP_SWITCHING_PROTOCOLS                = 101,
+    HTTP_PROCESSING                         = 102, // RFC2518 - WebDAV
+
+    // Succesful 2xx
+    HTTP_OK                                 = 200,
+    HTTP_CREATED                            = 201,
+    HTTP_ACCEPTED                           = 202,
+    HTTP_NONAUTHORITATIVE_INFORMATION       = 203,
+    HTTP_NO_CONTENT                         = 204,
+    HTTP_RESET_CONTENT                      = 205,
+    HTTP_PARTIAL_CONTENT                    = 206,
+    HTTP_MULTI_STATUS                       = 207, //WEBDAV
+    HTTP_IM_USED                            = 226, //RFC3229
+
+    // Redirect 3xx
+    HTTP_MULTIPLE_CHOICES                   = 300,
+    HTTP_MOVED_PERMANENTLY                  = 301,
+    HTTP_FOUND                              = 302,
+    HTTP_SEE_OTHER                          = 303,
+    HTTP_NOT_MODIFIED                       = 304,
+    HTTP_USE_PROXY                          = 305,
+    HTTP_TEMPORARY_REDIRECT                 = 307,
+
+    // Client Error 4xx
+    HTTP_BADREQUEST                         = 400,
+    HTTP_UNAUTHORIZED                       = 401,
+    HTTP_PAYMENTREQUIRED                    = 402,
+    HTTP_FORBIDDEN                          = 403,
+    HTTP_NOT_FOUND                          = 404,
+    HTTP_METHOD_NOT_ALLOWED                 = 405,
+    HTTP_NOT_ACCEPTABLE                     = 406,
+    HTTP_PROXY_AUTHENTICATION_REQUIRED      = 407,
+    HTTP_REQUEST_TIMEOUT                    = 408,
+    HTTP_CONFLICT                           = 409,
+    HTTP_GONE                               = 410,
+    HTTP_LENGTH_REQUIRED                    = 411,
+    HTTP_PRECONDITION_FAILED                = 412,
+    HTTP_REQUESTENTITY_TOO_LARGE            = 413,
+    HTTP_REQUESTURI_TOO_LONG                = 414,
+    HTTP_UNSUPPORTED_MEDIATYPE              = 415,
+    HTTP_REQUESTED_RANGE_NOT_SATISFIABLE    = 416,
+    HTTP_EXPECTATION_FAILED                 = 417,
+    HTTP_UNPROCESSABLE_ENTITY               = 422,
+    HTTP_LOCKED                             = 423,
+    HTTP_FAILED_DEPENDENCY                  = 424, //RFC4918 - WEBDAV
+    HTTP_NO_CODE                            = 425,
+    HTTP_UPGRADE_REQUIRED                   = 426,
+
+    // Server Error 5xx
+    HTTP_INTERNAL_SERVER_ERROR              = 500,
+    HTTP_NOT_IMPLEMENTED                    = 501,
+    HTTP_BAD_GATEWAY                        = 502,
+    HTTP_SERVICE_UNAVAILABLE                = 503,
+    HTTP_GATEWAY_TIMEOUT                    = 504,
+    HTTP_VERSION_NOTSUPPORTED               = 505,
+    HTTP_INSUFFICIENT_STORAGE               = 507, //RFC4918 - WEBDAV
+    HTTP_BANDWITH_LIMIT_EXCEEDED            = 509,
+    HTTP_NOT_EXTENDED                       = 510 //RFC 2774
+    };
+
+
+enum {
+    HEADER_MULTIPLE_LINES = 0,
+    HEADER_SINGLE_LINE    = 1
+    };
+
+
+/* Http Status */
+struct GMAPI HttpStatus {
+    FXint major;
+    FXint minor;
+    FXint code;
+    FXint type() const;
+    };
+
+/* Http Response Parser */
+class GMAPI HttpResponse {
+private:
+    MemoryBuffer buffer;            // Internal Buffer
+protected:
+    FXuint       flags;             // Options flags used by parser
+    FXint        content_length;    // Content Length from header
+    FXint        content_remaining; // Content left to read
+    FXint        chunk_remaining;   // Remaining bytes left to read in chunk
+public:
+    HttpStatus   status;            // Response Status. Valid after response() returns true
+    FXDict       headers;           // Dictionary of all http headers
+protected:
+
+    // Internal Parser Flags
+    enum {
+        ChunkedResponse  = 0x1,      // Chunked Response
+        ConnectionClose  = 0x2,      // Connection Closes
+        ResponseComplete = 0x4,
+        HeadRequest      = 0x8,
+        Last             = 0x10
+        };
+
+protected:
+
+    /// read nbytes from source.
+    virtual FXival readBlock(void * ptr,FXival nbytes)=0;
+
+private:
+
+    /// read nbytes
+    FXival read(FXchar*ptr,FXival nbytes);
+
+    /// read (at most) nbytes into buffer
+    FXival fill(FXival nbytes=128);
+
+private:
+
+    // Try reading complete header from buffer
+    FXbool parse_header(FXString & header,FXuint span);
+
+    // Add header to dictionary
+    void insert_header(const FXString &);
+
+    // Check all headers we're interested in
+    void check_headers();
+
+    // Clear Headers
+    void clear_headers();
+
+private:
+
+    // Reads chunk header and gives back size.
+    FXbool read_chunk_header(FXint & chunksize);
+
+    // Read regular
+    FXbool read_header(FXString & header,FXuint span);
+
+    // Read status line
+    FXbool read_status();
+
+private:
+
+    // Read body using normal transfer. Returns a string
+    FXString read_body();
+
+    // Read body using chunked transfer. Returns a string
+    FXString read_body_chunked();
+
+
+    // Read body using normal transfer. Returns size of message body or -1.
+    FXival   read_body(FXchar*&);
+
+    // Read body using chunked transfer. Returns size of message body or -1.
+    FXival   read_body_chunked(FXchar*&);
+
+
+    // Read body using chunked transfer
+    FXival   read_body_chunked(void * ptr,FXival len);
+
+    // Read body using normal transfer
+    FXival   read_body(void * ptr,FXival len);
+
+protected:
+
+    // Constructor
+    HttpResponse();
+
+    // Clear Response
+    void clear();
+
+public:
+
+    // Completes reading response
+    virtual void discard();
+
+    // Read response status and headers.
+    FXint parse();
+
+    // Return the complete message body as string
+    FXString body();
+
+    // Return the complete message body as buffer. Returns body size or -1 on error.
+    // Buffer needs to be freed with freeElms()
+    FXival body(FXchar *& out);
+
+
+    /// Read partial body
+    FXival readBody(void*ptr,FXival len);
+
+
+    // Return header for given key
+    FXString getHeader(const FXString & key) const;
+
+    // Return Content Length if known or -1
+    FXint getContentLength() const;
+
+    // Destructor
+    virtual ~HttpResponse();
+    };
+
+
+
+struct HttpHost {
+  FXString name;
+  FXint    port;
+
+  HttpHost();
+  HttpHost(const FXString & url);
+
+  // Set from url. returns true if changed
+  FXbool set(const FXString & url);
+  };
+
+
+
+
+
+
+
+class GMAPI HttpClient : public HttpResponse {
+protected:
+    FXInputHandle device;
+protected:
+    HttpHost      server;
+    HttpHost      proxy;
+protected:
+    enum {
+        UseProxy    = 0x10,   // Keep in Sync with HttpResponse
+        UseNonBlock = 0x20,  // Non Blocking Sockets
+        };
+protected:
+    virtual FXival readBlock(void*,FXival);
+    virtual FXival writeBlock(const void*,FXival);
+
+    // Subclass for non-blocking IO
+    virtual FXbool wait_write(FXInputHandle) { return false; }
+protected:
+    FXbool send(const FXchar *,FXint len);
+    FXbool open_connection();
+
+    // Reset Response
+    void reset(FXbool forceclose);
+public:
+    HttpClient();
+
+    void close();
+
+    // Discard response
+    virtual void discard();
+
+    FXbool request(const FXchar * method,const FXString & url,const FXString & headers=FXString::null,const FXString & message=FXString::null);
+
+
+    // Perform basic request and handles some basic HTTP features
+    FXbool basic(const FXchar *   method,
+                 FXString         url,
+                 const FXString & headers=FXString::null,
+                 const FXString & body=FXString::null);
+
+    ~HttpClient();
+    };
+
+}
+
+#endif

gogglesmm-0.12.5.tar.bz2/src/ap_xml_parser.cpp Added

@@ -0,0 +1,67 @@
+#include "gmdefs.h"
+#include "ap_xml_parser.h"
+
+#include <expat.h>
+
+namespace ap {
+
+XMLStream::XMLStream() : parser(NULL), depth(1),skip(0) {
+  parser = XML_ParserCreate(NULL);
+  XML_SetUserData((XML_Parser)parser,this);
+  XML_SetElementHandler((XML_Parser)parser,xml_element_start,xml_element_end);
+  XML_SetCharacterDataHandler((XML_Parser)parser,xml_element_data);
+  }
+
+XMLStream::~XMLStream() {
+  XML_ParserFree((XML_Parser)parser);
+  }
+
+
+void XMLStream::xml_print_error() {
+  fxmessage("Parse Error (line %ld, column %ld): %s\n",XML_GetCurrentLineNumber((XML_Parser)parser),XML_GetCurrentColumnNumber((XML_Parser)parser),XML_ErrorString(XML_GetErrorCode((XML_Parser)parser)));
+  }
+
+FXbool XMLStream::parse(const FXchar * buffer,FXint length) {
+  XML_Status code = XML_Parse((XML_Parser)parser,buffer,length,1);
+  if (code==XML_STATUS_ERROR) {
+    xml_print_error();
+    return false;
+    }
+  return true;
+  }
+
+FXbool XMLStream::parse(const FXString & buffer) {
+  return parse(buffer.text(),buffer.length());
+  }
+
+void XMLStream::xml_element_start(void*ptr,const FXchar * element,const FXchar ** attributes) {
+  XMLStream * stream = reinterpret_cast<XMLStream*>(ptr);
+  if (!stream->skip) {
+    if (!stream->begin(element,attributes)) {
+      stream->skip=stream->depth;
+      }
+    }
+  stream->depth++;
+  }
+
+void XMLStream::xml_element_end(void*ptr,const FXchar * element) {
+  XMLStream * stream = reinterpret_cast<XMLStream*>(ptr);
+
+  if (!stream->skip)
+    stream->end(element);
+
+  stream->depth--;
+
+  // turn off skip
+  if (stream->skip==stream->depth)
+    stream->skip=0;
+  }
+
+void XMLStream::xml_element_data(void*ptr,const FXchar * data,FXint len) {
+  XMLStream * stream = reinterpret_cast<XMLStream*>(ptr);
+  stream->data(data,len);
+  }
+
+
+
+}

gogglesmm-0.12.5.tar.bz2/src/ap_xml_parser.h Added

gogglesmm-0.12.4.tar.bz2/src/gmdefs.h -> gogglesmm-0.12.5.tar.bz2/src/gmdefs.h Changed

gogglesmm-0.12.4.tar.bz2/src/gmutils.cpp -> gogglesmm-0.12.5.tar.bz2/src/gmutils.cpp Changed

@@ -35,21 +35,22 @@
 
 /******************************************************************************/
 
-#include <expat.h>
-
+#include "ap_xml_parser.h"
 
+#include <expat.h>
 
+using namespace ap;
 
-class XSPFParser {
-protected:
-  XML_Parser   parser;
-  FXint        element;
+class XSPFParser : public XMLStream{
+public:
   FXStringList files;
   FXString     title;
-public:
-  static void xspf_element_start(void*,const XML_Char *,const XML_Char **);
-  static void xspf_element_end(void*,const XML_Char *);
-  static void xspf_element_data(void*,const XML_Char*,int);
+protected:
+  FXint        elem;
+protected:
+  FXint begin(const FXchar *,const FXchar**);
+  void data(const FXchar *,FXint len);
+  void end(const FXchar *);
 public:
   enum {
     Elem_None,
@@ -62,110 +63,83 @@
 public:
   XSPFParser();
   ~XSPFParser();
-  void parse(const FXString & buffer,FXStringList & mrl,FXString & title);
   };
 
-
-XSPFParser::XSPFParser() : element(Elem_None) {
-  parser = XML_ParserCreate(NULL);
-  XML_SetUserData(parser,this);
-  XML_SetElementHandler(parser,xspf_element_start,xspf_element_end);
-  XML_SetCharacterDataHandler(parser,xspf_element_data);
+XSPFParser::XSPFParser() : elem(Elem_None) {
   }
 
-XSPFParser::~XSPFParser() {
-  XML_ParserFree(parser);
+XSPFParser::~XSPFParser(){
   }
 
-void XSPFParser::parse(const FXString & buffer,FXStringList & mrl,FXString & t) {
-  if (XML_Parse(parser,buffer.text(),buffer.length(),1)==0) {
-    // some error occured;
-    }
-  else {
-    t=title;
-    mrl.adopt(files);
-    }
-  }
-
-void XSPFParser::xspf_element_start(void * ptr,const XML_Char * name,const XML_Char**/*atts*/) {
-  XSPFParser * parser = static_cast<XSPFParser*>(ptr);
-  FXASSERT(parser);
-  switch(parser->element) {
+FXint XSPFParser::begin(const FXchar * element,const FXchar **/* attributes*/){
+  switch(elem) {
     case Elem_None:
       {
-        if (compare(name,"playlist")==0)
-          parser->element = Elem_Playlist;
+        if (compare(element,"playlist")==0) {
+          elem=Elem_Playlist;
+          return 1;
+          }
       } break;
     case Elem_Playlist:
       {
-        if (compare(name,"title")==0)
-          parser->element = Elem_Playlist_Title;
-        else if (compare(name,"trackList")==0)
-          parser->element = Elem_Playlist_TrackList;
-        } break;
-
-    case Elem_Playlist_TrackList:
-      {
-        if (compare(name,"track")==0)
-          parser->element = Elem_Playlist_TrackList_Track;
-       } break;
-
-    case Elem_Playlist_TrackList_Track:
-      {
-        if (compare(name,"location")==0)
-          parser->element = Elem_Playlist_TrackList_Track_Location;
-       } break;
-    default: break;
-    }
-  }
-
-void XSPFParser::xspf_element_end(void * ptr,const XML_Char * name) {
-  XSPFParser * parser = static_cast<XSPFParser*>(ptr);
-  FXASSERT(parser);
-  switch(parser->element) {
-    case Elem_Playlist:
-      {
-        if (compare(name,"playlist")==0)
-          parser->element=Elem_None;
+        if (compare(element,"title")==0) {
+          elem=Elem_Playlist_Title;
+          return 1;
+          }
+        else if (compare(element,"trackList")==0) {
+          elem=Elem_Playlist_TrackList;
+          return 1;
+          }
       } break;
     case Elem_Playlist_TrackList:
       {
-        if (compare(name,"trackList")==0)
-          parser->element=Elem_Playlist;
-      } break;
-    case Elem_Playlist_Title:
-      {
-        if (compare(name,"title")==0)
-          parser->element=Elem_Playlist;
+        if (compare(element,"track")==0) {
+          elem=Elem_Playlist_TrackList_Track;
+          return 1;
+          }
       } break;
     case Elem_Playlist_TrackList_Track:
       {
-        if (compare(name,"track")==0)
-          parser->element = Elem_Playlist_TrackList;
-       } break;
-    case Elem_Playlist_TrackList_Track_Location:
-      {
-        if (compare(name,"location")==0)
-          parser->element = Elem_Playlist_TrackList_Track;
-       } break;
-    default: break;
+        if (compare(element,"location")==0) {
+          elem=Elem_Playlist_TrackList_Track_Location;
+          return 1;
+          }
+      } break;
+    default: return 0; // skip
     }
+  return 0;
   }
 
 
-void XSPFParser::xspf_element_data(void * ptr,const XML_Char * data,int len) {
-  XSPFParser * parser = static_cast<XSPFParser*>(ptr);
-  FXASSERT(parser);
-  if (parser->element==Elem_Playlist_TrackList_Track_Location) {
-    FXString url(data,len);
-    parser->files.append(url);
+void XSPFParser::data(const FXchar* str,FXint len){
+  if (elem==Elem_Playlist_Title) {
+    title.assign(str,len);
     }
-  else if (parser->element==Elem_Playlist_Title) {
-    parser->title.assign(data,len);
+  else if (elem==Elem_Playlist_TrackList_Track_Location) {
+    FXString url(str,len);
+    files.append(url);
+    }
+  }
+
+void XSPFParser::end(const FXchar*) {
+  switch(elem){
+    case Elem_Playlist_TrackList_Track_Location: elem=Elem_Playlist_TrackList_Track; break;
+    case Elem_Playlist_TrackList_Track         : elem=Elem_Playlist_TrackList; break;
+    case Elem_Playlist_TrackList               :
+    case Elem_Playlist_Title                   : elem=Elem_Playlist; break;
+    case Elem_Playlist                         : elem=Elem_None; break;
     }
   }
 
 
+void gm_parse_xspf(const FXString & data,FXStringList & mrl,FXString & title) {
+  XSPFParser xspf;
+  if (xspf.parse(data)) {
+    mrl=xspf.files;
+    title=xspf.title;
+    }
+  }
+
 /******************************************************************************/
 
 
@@ -296,16 +270,6 @@
 
 
 
-
-
-
-
-void gm_parse_xspf(FXString & data,FXStringList & mrl,FXString & title) {
-  XSPFParser xspf;
-  xspf.parse(data,mrl,title);
-  }
-
-
 FXbool gm_has_opengl() {
 #if FOXVERSION < FXVERSION(1,7,15)
   int glminor,glmajor;

gogglesmm-0.12.4.tar.bz2/src/gmutils.h -> gogglesmm-0.12.5.tar.bz2/src/gmutils.h Changed

Changes of Revision 8