1 diff -r fb5042644071 debian/patches/00list

     2 --- a/debian/patches/00list	Mon May 19 00:17:05 2008 -0400

     3 +++ b/debian/patches/00list	Mon May 19 01:12:49 2008 -0400

     4 @@ -1,2 +1,4 @@

     5  01verbose-compilation

     6  02compile-with-gcc-4.3

     7 +03mpd-client

     8 +04mpd-client-config-init

     9 diff -r fb5042644071 debian/patches/03mpd-client.dpatch

    10 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000

    11 +++ b/debian/patches/03mpd-client.dpatch	Mon May 19 01:12:49 2008 -0400

    12 @@ -0,0 +1,3597 @@

    13 +#! /bin/sh /usr/share/dpatch/dpatch-run

    14 +## mpd-client.dpatch by Fabien Niñoles <fabien@tzone.org>

    15 +##

    16 +## All lines beginning with `## DP:' are a description of the patch.

    17 +## DP: Add mpd to imms clients.

    18 +

    19 +@DPATCH@

    20 +

    21 +diff -r 171db9560cb5 clients/mpd/immsmpd.cc

    22 +--- /dev/null	Thu Jan 01 00:00:00 1970 +0000

    23 ++++ b/clients/mpd/immsmpd.cc	Mon May 19 00:21:51 2008 -0400

    24 +@@ -0,0 +1,282 @@

    25 ++#include "immsutil.h"

    26 ++#include "clientstub.h"

    27 ++

    28 ++#include <glib.h>

    29 ++#include <signal.h>

    30 ++

    31 ++#include "mpdinterface.h"

    32 ++#include <list>

    33 ++

    34 ++

    35 ++using std::endl;

    36 ++using std::list;

    37 ++using namespace mpd_interface;

    38 ++

    39 ++// interface for communication with IMMS server

    40 ++// comes from clientstub.h

    41 ++struct MPDOps;

    42 ++typedef IMMSClient<MPDOps> MPDClient;

    43 ++

    44 ++int poll_time = 250; // miliseconds

    45 ++const double reconnect_interval = 1.0; // seconds

    46 ++GMainLoop *loop = nullptr;

    47 ++GSource* ts;

    48 ++

    49 ++MPDClient imms;

    50 ++Player mpd;

    51 ++list<int> playqueue;

    52 ++const list<int>::size_type pq_capacity = 1;

    53 ++

    54 ++

    55 ++// that's the main function - it's called regularly and handles all the

    56 ++// IMMS and MPD communication and decides what to do when anything happens

    57 ++gboolean do_events(void *unused);

    58 ++

    59 ++// determines whether the currently playing song has been selected

    60 ++// specifically by the user

    61 ++bool next_jumped(); 

    62 ++

    63 ++void notify_song_ended(const Song& song, double elapsed_time, bool jumped);

    64 ++

    65 ++// resets the elapsed_timer and sets the jumped flag, too

    66 ++void notify_song_started(const Song& song, double& elapsed_time,

    67 ++    bool& jumped);

    68 ++

    69 ++void update_playqueue();

    70 ++bool playqueue_contains(int song);

    71 ++

    72 ++void quit(int signum);

    73 ++

    74 ++

    75 ++struct MPDOps

    76 ++{

    77 ++    // IMMS server's suggestion of the next song

    78 ++    static void set_next(int next)

    79 ++    {

    80 ++      if(playqueue.size() < pq_capacity) {

    81 ++	if(mpd.song(current).path() == mpd.song(next).path() ||

    82 ++	    mpd.song(previous).path() == mpd.song(next).path() ||

    83 ++	    playqueue_contains(next) || next >= mpd.playlist_length()) {

    84 ++          update_playqueue();

    85 ++	}

    86 ++	else {

    87 ++	  playqueue.push_back(next);

    88 ++	}

    89 ++      }

    90 ++    }

    91 ++    // no idea, works just peach as it is

    92 ++    // asked mag about it, waiting for an answer

    93 ++    // TODO if he doesn't answer, dig it out

    94 ++    static void reset_selection() { }

    95 ++    // path of the song at the given pos for IMMS server

    96 ++    static string get_item(int index) {return mpd.song(index).path(); }

    97 ++    // size of the playlist for the IMMS server

    98 ++    static int get_length() { return mpd.playlist_length(); }

    99 ++}; 

   100 ++

   101 ++int main(int argc, char **argv)

   102 ++{

   103 ++  // glib initialization

   104 ++  loop = g_main_loop_new(nullptr, FALSE);

   105 ++

   106 ++  signal(SIGINT,  quit);

   107 ++  signal(SIGTERM, quit);

   108 ++  signal(SIGPIPE, SIG_IGN);

   109 ++

   110 ++  ts = g_timeout_source_new(poll_time);

   111 ++  g_source_attach(ts, nullptr);

   112 ++  g_source_set_callback(ts, (GSourceFunc)do_events, nullptr, nullptr);

   113 ++  // end of glib init

   114 ++

   115 ++  g_main_loop_run(loop);

   116 ++

   117 ++  LOG(INFO) << "Exitting." << endl;

   118 ++  return 0;

   119 ++}

   120 ++

   121 ++gboolean do_events(void *unused)

   122 ++{

   123 ++  static const double time_inc = double(poll_time)/1000.0;

   124 ++    // the time that ACTUALLY elapsed when playing the song (in seconds)

   125 ++  static double elapsed_time = 0; 

   126 ++  static bool jumped = false;

   127 ++  static double reconnect_timeout = 0;

   128 ++

   129 ++  try {

   130 ++    if(!mpd.connected()) {

   131 ++      if(reconnect_timeout < time_inc) {

   132 ++	LOG(INFO) << "Not connected to MPD. Attempting to connect..."

   133 ++	  << endl;

   134 ++	reconnect_timeout = reconnect_interval;

   135 ++	mpd.connect();

   136 ++	LOG(INFO) << "Connected to MPD." << endl;

   137 ++	reconnect_timeout = 0;

   138 ++      }

   139 ++      else {

   140 ++	reconnect_timeout -= time_inc;

   141 ++	return TRUE;

   142 ++      }

   143 ++    }

   144 ++    if(imms.check_connection()) imms.setup(0);

   145 ++    if(!imms.isok()) return TRUE;

   146 ++

   147 ++    mpd.refresh();

   148 ++

   149 ++    if(mpd.playlist_changed()) {

   150 ++      imms.playlist_changed(mpd.playlist_length());

   151 ++      playqueue.clear();

   152 ++    }

   153 ++    if(mpd.radnom()) update_playqueue();

   154 ++

   155 ++    if(mpd.status_changed()) {

   156 ++      if(mpd.status(current) == stopped) {

   157 ++	notify_song_ended(mpd.song(current), elapsed_time, jumped);

   158 ++      }

   159 ++      else if(mpd.status(previous) == stopped &&

   160 ++	  mpd.status(current)==playing) {

   161 ++	notify_song_started(mpd.song(current), elapsed_time, jumped);

   162 ++	

   163 ++	// clear the song_changed() flag

   164 ++	if(mpd.song_changed()) mpd.refresh(); 

   165 ++      }

   166 ++    }

   167 ++    if(mpd.status(current) == playing) {

   168 ++      elapsed_time += time_inc;

   169 ++      if(mpd.song_changed()) {

   170 ++	notify_song_ended(mpd.song(previous), elapsed_time, jumped);

   171 ++

   172 ++	if(!mpd.radnom() || playqueue.empty()) {

   173 ++	  notify_song_started(mpd.song(current), elapsed_time, jumped);

   174 ++	}

   175 ++	else {

   176 ++	  mpd.play_song(playqueue.front());

   177 ++	  notify_song_started(mpd.song(playqueue.front()), elapsed_time,

   178 ++	      jumped);

   179 ++	  playqueue.erase(playqueue.begin());

   180 ++	  update_playqueue();

   181 ++	  // this could otherwise incorrectly set song_changed() flag

   182 ++	  mpd.refresh(); 

   183 ++	}

   184 ++      }

   185 ++      else {

   186 ++	// fix the real timer if it's inconsistent with what player

   187 ++	// says is the elapsed time of the current song

   188 ++	if(elapsed_time - double(mpd.song(current).elapsed()) >= 3.0) {

   189 ++	  if(mpd.song(current).elapsed() == 0) {

   190 ++	    Song tmp_ended = mpd.song(current);

   191 ++	    tmp_ended.set_length(int(elapsed_time) * 2);

   192 ++	    notify_song_ended(tmp_ended, elapsed_time, jumped);

   193 ++	    notify_song_started(mpd.song(current), elapsed_time, jumped);

   194 ++	    jumped = false;

   195 ++	  }

   196 ++	  elapsed_time = mpd.song(current).elapsed();

   197 ++	}

   198 ++      }

   199 ++    }

   200 ++  }

   201 ++  catch (connection_err) {

   202 ++    if(reconnect_timeout >= reconnect_interval) {

   203 ++	  LOG(INFO) << "Connecting to MPD was unsuccessful. "

   204 ++	    "Next attempt in " << reconnect_interval << " second"

   205 ++	    << (reconnect_interval == 1.0 ? "":"s") << "." << endl;

   206 ++    }

   207 ++    else {

   208 ++      LOG(INFO) << "Disconnected from MPD." << endl;

   209 ++    }

   210 ++  }

   211 ++  catch (mpd_err ex) {

   212 ++    LOG(ERROR) << "Error: " << ex.message() << endl;

   213 ++    g_main_quit(loop);

   214 ++    loop = nullptr;

   215 ++    exit(1);

   216 ++  }

   217 ++  return TRUE;

   218 ++}

   219 ++

   220 ++// determines whether the song has been played whole

   221 ++bool played_whole(double elapsed_time, int length)

   222 ++{

   223 ++  static const double abs_limit = 20.0;

   224 ++  static const double coeficient = 0.08;

   225 ++

   226 ++  double rel_limit = double(length) * coeficient;

   227 ++

   228 ++  double limit = (abs_limit < rel_limit) ? abs_limit : rel_limit;

   229 ++  return double(length)-elapsed_time < limit; 

   230 ++}

   231 ++// determines whether the song has been skipped early

   232 ++// (thus being set as not a prefed one)

   233 ++bool bad(double elapsed_time, int length)

   234 ++{

   235 ++  static const double abs_limit = 30.0;

   236 ++  static const double coeficient = 0.13;

   237 ++

   238 ++  double rel_limit = double(length) * coeficient;

   239 ++

   240 ++  double limit = (rel_limit < abs_limit) ? rel_limit : abs_limit;

   241 ++  return elapsed_time < limit;

   242 ++}

   243 ++bool next_jumped()

   244 ++{

   245 ++  if(mpd.radnom()) return false;

   246 ++

   247 ++  if(mpd.song(current).pos() == mpd.song(previous).pos()+1)

   248 ++    return false;

   249 ++  if(mpd.song(current).pos() == 0 &&

   250 ++      mpd.song(previous).pos() == mpd.playlist_length()-1)

   251 ++    return false;

   252 ++

   253 ++  return true;

   254 ++}

   255 ++void notify_song_ended(const Song& song, double elapsed_time, bool jumped)

   256 ++{

   257 ++  if(song.length() == Song::invalid_time) return;

   258 ++

   259 ++  imms.end_song(played_whole(elapsed_time, song.length()), jumped,

   260 ++      bad(elapsed_time, song.length()) );

   261 ++}

   262 ++

   263 ++void notify_song_started(const Song& song, double& elapsed_timer,

   264 ++    bool& jumped)

   265 ++{

   266 ++  imms.start_song(song.pos(), song.path());

   267 ++  elapsed_timer = 0;

   268 ++  jumped = next_jumped();

   269 ++  mpd.song_changed(); // clear the change notification

   270 ++}

   271 ++

   272 ++void update_playqueue()

   273 ++{

   274 ++  static const int timeout_value = 3;

   275 ++  static int timeout = 0;

   276 ++

   277 ++  if(timeout == 0)

   278 ++  {

   279 ++    if(playqueue.size() < pq_capacity) {

   280 ++      list<int>::size_type i;

   281 ++      for(i = pq_capacity - playqueue.size(); i!=0; i--) {

   282 ++	imms.select_next();

   283 ++      }

   284 ++      timeout = timeout_value;

   285 ++    }

   286 ++  }

   287 ++  else --timeout;

   288 ++}

   289 ++

   290 ++bool playqueue_contains(int song)

   291 ++{

   292 ++  list<int>::const_iterator i;

   293 ++  for(i = playqueue.begin(); i!= playqueue.end(); i++) {

   294 ++    if (*i == song) return true;

   295 ++  }

   296 ++  return false;

   297 ++}

   298 ++

   299 ++void quit(int signum)

   300 ++{

   301 ++  if (loop) g_main_quit(loop);

   302 ++  loop = nullptr;

   303 ++  signal(signum, SIG_DFL);

   304 ++}

   305 ++

   306 ++

   307 +diff -r 171db9560cb5 clients/mpd/libmpdclient.c

   308 +--- /dev/null	Thu Jan 01 00:00:00 1970 +0000

   309 ++++ b/clients/mpd/libmpdclient.c	Mon May 19 00:21:51 2008 -0400

   310 +@@ -0,0 +1,1955 @@

   311 ++/* libmpdclient

   312 ++   (c)2003-2006 by Warren Dukes (warren.dukes@gmail.com)

   313 ++   This project's homepage is: http://www.musicpd.org

   314 ++

   315 ++   Redistribution and use in source and binary forms, with or without

   316 ++   modification, are permitted provided that the following conditions

   317 ++   are met:

   318 ++

   319 ++   - Redistributions of source code must retain the above copyright

   320 ++   notice, this list of conditions and the following disclaimer.

   321 ++

   322 ++   - Redistributions in binary form must reproduce the above copyright

   323 ++   notice, this list of conditions and the following disclaimer in the

   324 ++   documentation and/or other materials provided with the distribution.

   325 ++

   326 ++   - Neither the name of the Music Player Daemon nor the names of its

   327 ++   contributors may be used to endorse or promote products derived from

   328 ++   this software without specific prior written permission.

   329 ++

   330 ++   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

   331 ++   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

   332 ++   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

   333 ++   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR

   334 ++   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

   335 ++   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

   336 ++   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

   337 ++   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

   338 ++   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

   339 ++   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

   340 ++   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

   341 ++*/

   342 ++

   343 ++#include "libmpdclient.h"

   344 ++

   345 ++#include <errno.h>

   346 ++#include <ctype.h>

   347 ++#include <sys/types.h>

   348 ++#include <stdio.h>

   349 ++#include <sys/param.h>

   350 ++#include <string.h>

   351 ++#include <unistd.h>

   352 ++#include <stdlib.h>

   353 ++#include <fcntl.h>

   354 ++#include <limits.h>

   355 ++

   356 ++#ifdef WIN32

   357 ++#  include <ws2tcpip.h>

   358 ++#  include <winsock.h>

   359 ++#else

   360 ++#  include <netinet/in.h>

   361 ++#  include <arpa/inet.h>

   362 ++#  include <sys/socket.h>

   363 ++#  include <netdb.h>

   364 ++#endif

   365 ++

   366 ++/* (bits+1)/3 (plus the sign character) */

   367 ++#define INTLEN      ((sizeof(int)       * CHAR_BIT + 1) / 3 + 1)

   368 ++#define LONGLONGLEN ((sizeof(long long) * CHAR_BIT + 1) / 3 + 1)

   369 ++

   370 ++#define COMMAND_LIST    1

   371 ++#define COMMAND_LIST_OK 2

   372 ++

   373 ++#ifndef MPD_NO_GAI

   374 ++#  ifdef AI_ADDRCONFIG

   375 ++#    define MPD_HAVE_GAI

   376 ++#  endif

   377 ++#endif

   378 ++

   379 ++#ifndef MSG_DONTWAIT

   380 ++#  define MSG_DONTWAIT 0

   381 ++#endif

   382 ++

   383 ++#ifdef WIN32

   384 ++#  define SELECT_ERRNO_IGNORE   (errno == WSAEINTR || errno == WSAEINPROGRESS)

   385 ++#  define SENDRECV_ERRNO_IGNORE SELECT_ERRNO_IGNORE

   386 ++#else

   387 ++#  define SELECT_ERRNO_IGNORE   (errno == EINTR)

   388 ++#  define SENDRECV_ERRNO_IGNORE (errno == EINTR || errno == EAGAIN)

   389 ++#  define winsock_dll_error(c)  0

   390 ++#  define closesocket(s)        close(s)

   391 ++#  define WSACleanup()          do { /* nothing */ } while (0)

   392 ++#endif

   393 ++

   394 ++#ifdef WIN32

   395 ++static int winsock_dll_error(mpd_Connection *connection)

   396 ++{

   397 ++	WSADATA wsaData;

   398 ++	if ((WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0 ||

   399 ++			LOBYTE(wsaData.wVersion) != 2 ||

   400 ++			HIBYTE(wsaData.wVersion) != 2 ) {

   401 ++		strcpy(connection->errorStr,

   402 ++		       "Could not find usable WinSock DLL.");

   403 ++		connection->error = MPD_ERROR_SYSTEM;

   404 ++		return 1;

   405 ++	}

   406 ++	return 0;

   407 ++}

   408 ++

   409 ++static int do_connect_fail(mpd_Connection *connection,

   410 ++                           const struct sockaddr *serv_addr, int addrlen)

   411 ++{

   412 ++	int iMode = 1; /* 0 = blocking, else non-blocking */

   413 ++	ioctlsocket(connection->sock, FIONBIO, (u_long FAR*) &iMode);

   414 ++	return (connect(connection->sock,serv_addr,addrlen) == SOCKET_ERROR

   415 ++			&& WSAGetLastError() != WSAEWOULDBLOCK);

   416 ++}

   417 ++#else /* !WIN32 (sane operating systems) */

   418 ++static int do_connect_fail(mpd_Connection *connection,

   419 ++                           const struct sockaddr *serv_addr, int addrlen)

   420 ++{

   421 ++	int flags = fcntl(connection->sock, F_GETFL, 0);

   422 ++	fcntl(connection->sock, F_SETFL, flags | O_NONBLOCK);

   423 ++	return (connect(connection->sock,serv_addr,addrlen)<0 &&

   424 ++				errno!=EINPROGRESS);

   425 ++}

   426 ++#endif /* !WIN32 */

   427 ++

   428 ++#ifdef MPD_HAVE_GAI

   429 ++static int mpd_connect(mpd_Connection * connection, const char * host, int port,

   430 ++                       float timeout)

   431 ++{

   432 ++	int error;

   433 ++	char service[INTLEN+1];

   434 ++	struct addrinfo hints;

   435 ++	struct addrinfo *res = NULL;

   436 ++	struct addrinfo *addrinfo = NULL;

   437 ++

   438 ++	/**

   439 ++	 * Setup hints

   440 ++	 */

   441 ++	hints.ai_flags     = AI_ADDRCONFIG;

   442 ++	hints.ai_family    = PF_UNSPEC;

   443 ++	hints.ai_socktype  = SOCK_STREAM;

   444 ++	hints.ai_protocol  = IPPROTO_TCP;

   445 ++	hints.ai_addrlen   = 0;

   446 ++	hints.ai_addr      = NULL;

   447 ++	hints.ai_canonname = NULL;

   448 ++	hints.ai_next      = NULL;

   449 ++

   450 ++	snprintf(service, sizeof(service), "%i", port);

   451 ++

   452 ++	error = getaddrinfo(host, service, &hints, &addrinfo);

   453 ++

   454 ++	if (error) {

   455 ++		snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH,

   456 ++		         "host \"%s\" not found: %s",

   457 ++		         host, gai_strerror(error));

   458 ++		connection->error = MPD_ERROR_UNKHOST;

   459 ++		return -1;

   460 ++	}

   461 ++

   462 ++	for (res = addrinfo; res; res = res->ai_next) {

   463 ++		/* create socket */

   464 ++		connection->sock = socket(res->ai_family, SOCK_STREAM,

   465 ++		                          res->ai_protocol);

   466 ++		if (connection->sock < 0) {

   467 ++			snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH,

   468 ++			         "problems creating socket: %s",

   469 ++			         strerror(errno));

   470 ++			connection->error = MPD_ERROR_SYSTEM;

   471 ++			freeaddrinfo(addrinfo);

   472 ++			return -1;

   473 ++		}

   474 ++

   475 ++		mpd_setConnectionTimeout(connection, timeout);

   476 ++

   477 ++		/* connect stuff */

   478 ++ 		if (do_connect_fail(connection,

   479 ++		                    res->ai_addr, res->ai_addrlen)) {

   480 ++ 			/* try the next address family */

   481 ++ 			closesocket(connection->sock);

   482 ++ 			connection->sock = -1;

   483 ++ 			continue;

   484 ++		}

   485 ++	}

   486 ++

   487 ++	freeaddrinfo(addrinfo);

   488 ++

   489 ++	if (connection->sock < 0) {

   490 ++		snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH,

   491 ++		         "problems connecting to \"%s\" on port %i: %s",

   492 ++		         host, port, strerror(errno));

   493 ++		connection->error = MPD_ERROR_CONNPORT;

   494 ++

   495 ++		return -1;

   496 ++	}

   497 ++

   498 ++	return 0;

   499 ++}

   500 ++#else /* !MPD_HAVE_GAI */

   501 ++static int mpd_connect(mpd_Connection * connection, const char * host, int port,

   502 ++                       float timeout)

   503 ++{

   504 ++	struct hostent * he;

   505 ++	struct sockaddr * dest;

   506 ++	int destlen;

   507 ++	struct sockaddr_in sin;

   508 ++

   509 ++	if(!(he=gethostbyname(host))) {

   510 ++		snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   511 ++				"host \"%s\" not found",host);

   512 ++		connection->error = MPD_ERROR_UNKHOST;

   513 ++		return -1;

   514 ++	}

   515 ++

   516 ++	memset(&sin,0,sizeof(struct sockaddr_in));

   517 ++	/*dest.sin_family = he->h_addrtype;*/

   518 ++	sin.sin_family = AF_INET;

   519 ++	sin.sin_port = htons(port);

   520 ++

   521 ++	switch(he->h_addrtype) {

   522 ++	case AF_INET:

   523 ++		memcpy((char *)&sin.sin_addr.s_addr,(char *)he->h_addr,

   524 ++				he->h_length);

   525 ++		dest = (struct sockaddr *)&sin;

   526 ++		destlen = sizeof(struct sockaddr_in);

   527 ++		break;

   528 ++	default:

   529 ++		strcpy(connection->errorStr,"address type is not IPv4");

   530 ++		connection->error = MPD_ERROR_SYSTEM;

   531 ++		return -1;

   532 ++		break;

   533 ++	}

   534 ++

   535 ++	if((connection->sock = socket(dest->sa_family,SOCK_STREAM,0))<0) {

   536 ++		strcpy(connection->errorStr,"problems creating socket");

   537 ++		connection->error = MPD_ERROR_SYSTEM;

   538 ++		return -1;

   539 ++	}

   540 ++

   541 ++	mpd_setConnectionTimeout(connection,timeout);

   542 ++

   543 ++	/* connect stuff */

   544 ++	if (do_connect_fail(connection, dest, destlen)) {

   545 ++		snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   546 ++				"problems connecting to \"%s\" on port"

   547 ++				" %i",host,port);

   548 ++		connection->error = MPD_ERROR_CONNPORT;

   549 ++		return -1;

   550 ++	}

   551 ++

   552 ++	return 0;

   553 ++}

   554 ++#endif /* !MPD_HAVE_GAI */

   555 ++

   556 ++char * mpdTagItemKeys[MPD_TAG_NUM_OF_ITEM_TYPES] =

   557 ++{

   558 ++	"Artist",

   559 ++	"Album",

   560 ++	"Title",

   561 ++	"Track",

   562 ++	"Name",

   563 ++	"Genre",

   564 ++	"Date",

   565 ++	"Composer",

   566 ++	"Performer",

   567 ++	"Comment",

   568 ++	"Disc",

   569 ++	"Filename",

   570 ++	"Any"

   571 ++};

   572 ++

   573 ++static char * mpd_sanitizeArg(const char * arg) {

   574 ++	size_t i;

   575 ++	char * ret;

   576 ++	register const char *c;

   577 ++	register char *rc;

   578 ++

   579 ++	/* instead of counting in that loop above, just

   580 ++	 * use a bit more memory and half running time

   581 ++	 */

   582 ++	ret = (char *)malloc(strlen(arg) * 2 + 1);

   583 ++

   584 ++	c = arg;

   585 ++	rc = ret;

   586 ++	for(i = strlen(arg)+1; i != 0; --i) {

   587 ++		if(*c=='"' || *c=='\\')

   588 ++			*rc++ = '\\';

   589 ++		*(rc++) = *(c++);

   590 ++	}

   591 ++

   592 ++	return ret;

   593 ++}

   594 ++

   595 ++static mpd_ReturnElement * mpd_newReturnElement(const char * name, const char * value)

   596 ++{

   597 ++	mpd_ReturnElement * ret = (mpd_ReturnElement *)malloc(sizeof(mpd_ReturnElement));

   598 ++

   599 ++	ret->name = strdup(name);

   600 ++	ret->value = strdup(value);

   601 ++

   602 ++	return ret;

   603 ++}

   604 ++

   605 ++static void mpd_freeReturnElement(mpd_ReturnElement * re) {

   606 ++	free(re->name);

   607 ++	free(re->value);

   608 ++	free(re);

   609 ++}

   610 ++

   611 ++void mpd_setConnectionTimeout(mpd_Connection * connection, float timeout) {

   612 ++	connection->timeout.tv_sec = (int)timeout;

   613 ++	connection->timeout.tv_usec = (int)(timeout*1e6 -

   614 ++	                                    connection->timeout.tv_sec*1000000 +

   615 ++					    0.5);

   616 ++}

   617 ++

   618 ++static int mpd_parseWelcome(mpd_Connection * connection, const char * host, int port,

   619 ++                            char * rt, char * output) {

   620 ++	char * tmp;

   621 ++	char * test;

   622 ++	int i;

   623 ++

   624 ++	if(strncmp(output,MPD_WELCOME_MESSAGE,strlen(MPD_WELCOME_MESSAGE))) {

   625 ++		snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   626 ++				"mpd not running on port %i on host \"%s\"",

   627 ++				port,host);

   628 ++		connection->error = MPD_ERROR_NOTMPD;

   629 ++		return 1;

   630 ++	}

   631 ++

   632 ++	tmp = &output[strlen(MPD_WELCOME_MESSAGE)];

   633 ++

   634 ++	for(i=0;i<3;i++) {

   635 ++		if(tmp) connection->version[i] = strtol(tmp,&test,10);

   636 ++

   637 ++		if (!tmp || (test[0] != '.' && test[0] != '\0')) {

   638 ++			snprintf(connection->errorStr,

   639 ++			         MPD_ERRORSTR_MAX_LENGTH,

   640 ++			         "error parsing version number at "

   641 ++			         "\"%s\"",

   642 ++			         &output[strlen(MPD_WELCOME_MESSAGE)]);

   643 ++			connection->error = MPD_ERROR_NOTMPD;

   644 ++			return 1;

   645 ++		}

   646 ++		tmp = ++test;

   647 ++	}

   648 ++

   649 ++	return 0;

   650 ++}

   651 ++

   652 ++mpd_Connection * mpd_newConnection(const char * host, int port, float timeout) {

   653 ++	int err;

   654 ++	char * rt;

   655 ++	char * output =  NULL;

   656 ++	mpd_Connection * connection = (mpd_Connection *)malloc(sizeof(mpd_Connection));

   657 ++	struct timeval tv;

   658 ++	fd_set fds;

   659 ++	strcpy(connection->buffer,"");

   660 ++	connection->buflen = 0;

   661 ++	connection->bufstart = 0;

   662 ++	strcpy(connection->errorStr,"");

   663 ++	connection->error = 0;

   664 ++	connection->doneProcessing = 0;

   665 ++	connection->commandList = 0;

   666 ++	connection->listOks = 0;

   667 ++	connection->doneListOk = 0;

   668 ++	connection->returnElement = NULL;

   669 ++	connection->request = NULL;

   670 ++

   671 ++	if (winsock_dll_error(connection))

   672 ++		return connection;

   673 ++

   674 ++	if (mpd_connect(connection, host, port, timeout) < 0)

   675 ++		return connection;

   676 ++

   677 ++	while(!(rt = strstr(connection->buffer,"\n"))) {

   678 ++		tv.tv_sec = connection->timeout.tv_sec;

   679 ++		tv.tv_usec = connection->timeout.tv_usec;

   680 ++		FD_ZERO(&fds);

   681 ++		FD_SET(connection->sock,&fds);

   682 ++		if((err = select(connection->sock+1,&fds,NULL,NULL,&tv)) == 1) {

   683 ++			int readed;

   684 ++			readed = recv(connection->sock,

   685 ++					&(connection->buffer[connection->buflen]),

   686 ++					MPD_BUFFER_MAX_LENGTH-connection->buflen,0);

   687 ++			if(readed<=0) {

   688 ++				snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   689 ++						"problems getting a response from"

   690 ++						" \"%s\" on port %i : %s",host,

   691 ++						port, strerror(errno));

   692 ++				connection->error = MPD_ERROR_NORESPONSE;

   693 ++				return connection;

   694 ++			}

   695 ++			connection->buflen+=readed;

   696 ++			connection->buffer[connection->buflen] = '\0';

   697 ++		}

   698 ++		else if(err<0) {

   699 ++ 			if (SELECT_ERRNO_IGNORE)

   700 ++				continue;

   701 ++			snprintf(connection->errorStr,

   702 ++					MPD_ERRORSTR_MAX_LENGTH,

   703 ++					"problems connecting to \"%s\" on port"

   704 ++					" %i",host,port);

   705 ++			connection->error = MPD_ERROR_CONNPORT;

   706 ++			return connection;

   707 ++		}

   708 ++		else {

   709 ++			snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   710 ++					"timeout in attempting to get a response from"

   711 ++					" \"%s\" on port %i",host,port);

   712 ++			connection->error = MPD_ERROR_NORESPONSE;

   713 ++			return connection;

   714 ++		}

   715 ++	}

   716 ++

   717 ++	*rt = '\0';

   718 ++	output = strdup(connection->buffer);

   719 ++	strcpy(connection->buffer,rt+1);

   720 ++	connection->buflen = strlen(connection->buffer);

   721 ++

   722 ++	if(mpd_parseWelcome(connection,host,port,rt,output) == 0) connection->doneProcessing = 1;

   723 ++

   724 ++	free(output);

   725 ++

   726 ++	return connection;

   727 ++}

   728 ++

   729 ++void mpd_clearError(mpd_Connection * connection) {

   730 ++	connection->error = 0;

   731 ++	connection->errorStr[0] = '\0';

   732 ++}

   733 ++

   734 ++void mpd_closeConnection(mpd_Connection * connection) {

   735 ++	closesocket(connection->sock);

   736 ++	if(connection->returnElement) free(connection->returnElement);

   737 ++	if(connection->request) free(connection->request);

   738 ++	free(connection);

   739 ++	WSACleanup();

   740 ++}

   741 ++

   742 ++static void mpd_executeCommand(mpd_Connection * connection, char * command) {

   743 ++	int ret;

   744 ++	struct timeval tv;

   745 ++	fd_set fds;

   746 ++	char * commandPtr = command;

   747 ++	int commandLen = strlen(command);

   748 ++

   749 ++	if(!connection->doneProcessing && !connection->commandList) {

   750 ++		strcpy(connection->errorStr,"not done processing current command");

   751 ++		connection->error = 1;

   752 ++		return;

   753 ++	}

   754 ++

   755 ++	mpd_clearError(connection);

   756 ++

   757 ++	FD_ZERO(&fds);

   758 ++	FD_SET(connection->sock,&fds);

   759 ++	tv.tv_sec = connection->timeout.tv_sec;

   760 ++	tv.tv_usec = connection->timeout.tv_usec;

   761 ++

   762 ++	while((ret = select(connection->sock+1,NULL,&fds,NULL,&tv)==1) ||

   763 ++			(ret==-1 && SELECT_ERRNO_IGNORE)) {

   764 ++		ret = send(connection->sock,commandPtr,commandLen,MSG_DONTWAIT);

   765 ++		if(ret<=0)

   766 ++		{

   767 ++			if (SENDRECV_ERRNO_IGNORE) continue;

   768 ++			snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   769 ++			         "problems giving command \"%s\"",command);

   770 ++			connection->error = MPD_ERROR_SENDING;

   771 ++			return;

   772 ++		}

   773 ++		else {

   774 ++			commandPtr+=ret;

   775 ++			commandLen-=ret;

   776 ++		}

   777 ++

   778 ++		if(commandLen<=0) break;

   779 ++	}

   780 ++

   781 ++	if(commandLen>0) {

   782 ++		perror("");

   783 ++		snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   784 ++		         "timeout sending command \"%s\"",command);

   785 ++		connection->error = MPD_ERROR_TIMEOUT;

   786 ++		return;

   787 ++	}

   788 ++

   789 ++	if(!connection->commandList) connection->doneProcessing = 0;

   790 ++	else if(connection->commandList == COMMAND_LIST_OK) {

   791 ++		connection->listOks++;

   792 ++	}

   793 ++}

   794 ++

   795 ++static void mpd_getNextReturnElement(mpd_Connection * connection) {

   796 ++	char * output = NULL;

   797 ++	char * rt = NULL;

   798 ++	char * name = NULL;

   799 ++	char * value = NULL;

   800 ++	fd_set fds;

   801 ++	struct timeval tv;

   802 ++	char * tok = NULL;

   803 ++	int readed;

   804 ++	char * bufferCheck = NULL;

   805 ++	int err;

   806 ++	int pos;

   807 ++

   808 ++	if(connection->returnElement) mpd_freeReturnElement(connection->returnElement);

   809 ++	connection->returnElement = NULL;

   810 ++

   811 ++	if(connection->doneProcessing || (connection->listOks &&

   812 ++	   connection->doneListOk))

   813 ++	{

   814 ++		strcpy(connection->errorStr,"already done processing current command");

   815 ++		connection->error = 1;

   816 ++		return;

   817 ++	}

   818 ++

   819 ++	bufferCheck = connection->buffer+connection->bufstart;

   820 ++	while(connection->bufstart>=connection->buflen ||

   821 ++			!(rt = strchr(bufferCheck,'\n'))) {

   822 ++		if(connection->buflen>=MPD_BUFFER_MAX_LENGTH) {

   823 ++			memmove(connection->buffer,

   824 ++					connection->buffer+

   825 ++					connection->bufstart,

   826 ++					connection->buflen-

   827 ++					connection->bufstart+1);

   828 ++			connection->buflen-=connection->bufstart;

   829 ++			connection->bufstart = 0;

   830 ++		}

   831 ++		if(connection->buflen>=MPD_BUFFER_MAX_LENGTH) {

   832 ++			strcpy(connection->errorStr,"buffer overrun");

   833 ++			connection->error = MPD_ERROR_BUFFEROVERRUN;

   834 ++			connection->doneProcessing = 1;

   835 ++			connection->doneListOk = 0;

   836 ++			return;

   837 ++		}

   838 ++		bufferCheck = connection->buffer+connection->buflen;

   839 ++		tv.tv_sec = connection->timeout.tv_sec;

   840 ++		tv.tv_usec = connection->timeout.tv_usec;

   841 ++		FD_ZERO(&fds);

   842 ++		FD_SET(connection->sock,&fds);

   843 ++		if((err = select(connection->sock+1,&fds,NULL,NULL,&tv) == 1)) {

   844 ++			readed = recv(connection->sock,

   845 ++					connection->buffer+connection->buflen,

   846 ++					MPD_BUFFER_MAX_LENGTH-connection->buflen,

   847 ++					MSG_DONTWAIT);

   848 ++			if(readed<0 && SENDRECV_ERRNO_IGNORE) {

   849 ++				continue;

   850 ++			}

   851 ++			if(readed<=0) {

   852 ++				strcpy(connection->errorStr,"connection"

   853 ++				       " closed");

   854 ++				connection->error = MPD_ERROR_CONNCLOSED;

   855 ++				connection->doneProcessing = 1;

   856 ++				connection->doneListOk = 0;

   857 ++				return;

   858 ++			}

   859 ++			connection->buflen+=readed;

   860 ++			connection->buffer[connection->buflen] = '\0';

   861 ++		}

   862 ++		else if(err<0 && SELECT_ERRNO_IGNORE) continue;

   863 ++		else {

   864 ++			strcpy(connection->errorStr,"connection timeout");

   865 ++			connection->error = MPD_ERROR_TIMEOUT;

   866 ++			connection->doneProcessing = 1;

   867 ++			connection->doneListOk = 0;

   868 ++			return;

   869 ++		}

   870 ++	}

   871 ++

   872 ++	*rt = '\0';

   873 ++	output = connection->buffer+connection->bufstart;

   874 ++	connection->bufstart = rt - connection->buffer + 1;

   875 ++

   876 ++	if(strcmp(output,"OK")==0) {

   877 ++		if(connection->listOks > 0) {

   878 ++			strcpy(connection->errorStr, "expected more list_OK's");

   879 ++			connection->error = 1;

   880 ++		}

   881 ++		connection->listOks = 0;

   882 ++		connection->doneProcessing = 1;

   883 ++		connection->doneListOk = 0;

   884 ++		return;

   885 ++	}

   886 ++

   887 ++	if(strcmp(output, "list_OK") == 0) {

   888 ++		if(!connection->listOks) {

   889 ++			strcpy(connection->errorStr,

   890 ++					"got an unexpected list_OK");

   891 ++			connection->error = 1;

   892 ++		}

   893 ++		else {

   894 ++			connection->doneListOk = 1;

   895 ++			connection->listOks--;

   896 ++		}

   897 ++		return;

   898 ++	}

   899 ++

   900 ++	if(strncmp(output,"ACK",strlen("ACK"))==0) {

   901 ++		char * test;

   902 ++		char * needle;

   903 ++		int val;

   904 ++

   905 ++		strcpy(connection->errorStr, output);

   906 ++		connection->error = MPD_ERROR_ACK;

   907 ++		connection->errorCode = MPD_ACK_ERROR_UNK;

   908 ++		connection->errorAt = MPD_ERROR_AT_UNK;

   909 ++		connection->doneProcessing = 1;

   910 ++		connection->doneListOk = 0;

   911 ++

   912 ++		needle = strchr(output, '[');

   913 ++		if(!needle) return;

   914 ++		val = strtol(needle+1, &test, 10);

   915 ++		if(*test != '@') return;

   916 ++		connection->errorCode = val;

   917 ++		val = strtol(test+1, &test, 10);

   918 ++		if(*test != ']') return;

   919 ++		connection->errorAt = val;

   920 ++		return;

   921 ++	}

   922 ++

   923 ++	tok = strchr(output, ':');

   924 ++	if (!tok) return;

   925 ++	pos = tok - output;

   926 ++	value = ++tok;

   927 ++	name = output;

   928 ++	name[pos] = '\0';

   929 ++

   930 ++	if(value[0]==' ') {

   931 ++		connection->returnElement = mpd_newReturnElement(name,&(value[1]));

   932 ++	}

   933 ++	else {

   934 ++		snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

   935 ++					"error parsing: %s:%s",name,value);

   936 ++		connection->error = 1;

   937 ++	}

   938 ++}

   939 ++

   940 ++void mpd_finishCommand(mpd_Connection * connection) {

   941 ++	while(!connection->doneProcessing) {

   942 ++		if(connection->doneListOk) connection->doneListOk = 0;

   943 ++		mpd_getNextReturnElement(connection);

   944 ++	}

   945 ++}

   946 ++

   947 ++static void mpd_finishListOkCommand(mpd_Connection * connection) {

   948 ++	while(!connection->doneProcessing && connection->listOks &&

   949 ++			!connection->doneListOk)

   950 ++	{

   951 ++		mpd_getNextReturnElement(connection);

   952 ++	}

   953 ++}

   954 ++

   955 ++int mpd_nextListOkCommand(mpd_Connection * connection) {

   956 ++	mpd_finishListOkCommand(connection);

   957 ++	if(!connection->doneProcessing) connection->doneListOk = 0;

   958 ++	if(connection->listOks == 0 || connection->doneProcessing) return -1;

   959 ++	return 0;

   960 ++}

   961 ++

   962 ++void mpd_sendStatusCommand(mpd_Connection * connection) {

   963 ++	mpd_executeCommand(connection,"status\n");

   964 ++}

   965 ++

   966 ++mpd_Status * mpd_getStatus(mpd_Connection * connection) {

   967 ++	mpd_Status * status;

   968 ++

   969 ++	/*mpd_executeCommand(connection,"status\n");

   970 ++

   971 ++	if(connection->error) return NULL;*/

   972 ++

   973 ++	if(connection->doneProcessing || (connection->listOks &&

   974 ++	   connection->doneListOk))

   975 ++	{

   976 ++		return NULL;

   977 ++	}

   978 ++

   979 ++	if(!connection->returnElement) mpd_getNextReturnElement(connection);

   980 ++

   981 ++	status = (mpd_Status *)malloc(sizeof(mpd_Status));

   982 ++	status->volume = -1;

   983 ++	status->repeat = 0;

   984 ++	status->random = 0;

   985 ++	status->playlist = -1;

   986 ++	status->playlistLength = -1;

   987 ++	status->state = -1;

   988 ++	status->song = 0;

   989 ++	status->songid = 0;

   990 ++	status->elapsedTime = 0;

   991 ++	status->totalTime = 0;

   992 ++	status->bitRate = 0;

   993 ++	status->sampleRate = 0;

   994 ++	status->bits = 0;

   995 ++	status->channels = 0;

   996 ++	status->crossfade = -1;

   997 ++	status->error = NULL;

   998 ++	status->updatingDb = 0;

   999 ++

  1000 ++	if(connection->error) {

  1001 ++		free(status);

  1002 ++		return NULL;

  1003 ++	}

  1004 ++	while(connection->returnElement) {

  1005 ++		mpd_ReturnElement * re = connection->returnElement;

  1006 ++		if(strcmp(re->name,"volume")==0) {

  1007 ++			status->volume = atoi(re->value);

  1008 ++		}

  1009 ++		else if(strcmp(re->name,"repeat")==0) {

  1010 ++			status->repeat = atoi(re->value);

  1011 ++		}

  1012 ++		else if(strcmp(re->name,"random")==0) {

  1013 ++			status->random = atoi(re->value);

  1014 ++		}

  1015 ++		else if(strcmp(re->name,"playlist")==0) {

  1016 ++			status->playlist = strtol(re->value,NULL,10);

  1017 ++		}

  1018 ++		else if(strcmp(re->name,"playlistlength")==0) {

  1019 ++			status->playlistLength = atoi(re->value);

  1020 ++		}

  1021 ++		else if(strcmp(re->name,"bitrate")==0) {

  1022 ++			status->bitRate = atoi(re->value);

  1023 ++		}

  1024 ++		else if(strcmp(re->name,"state")==0) {

  1025 ++			if(strcmp(re->value,"play")==0) {

  1026 ++				status->state = MPD_STATUS_STATE_PLAY;

  1027 ++			}

  1028 ++			else if(strcmp(re->value,"stop")==0) {

  1029 ++				status->state = MPD_STATUS_STATE_STOP;

  1030 ++			}

  1031 ++			else if(strcmp(re->value,"pause")==0) {

  1032 ++				status->state = MPD_STATUS_STATE_PAUSE;

  1033 ++			}

  1034 ++			else {

  1035 ++				status->state = MPD_STATUS_STATE_UNKNOWN;

  1036 ++			}

  1037 ++		}

  1038 ++		else if(strcmp(re->name,"song")==0) {

  1039 ++			status->song = atoi(re->value);

  1040 ++		}

  1041 ++		else if(strcmp(re->name,"songid")==0) {

  1042 ++			status->songid = atoi(re->value);

  1043 ++		}

  1044 ++		else if(strcmp(re->name,"time")==0) {

  1045 ++			char * tok = strchr(re->value,':');

  1046 ++			/* the second strchr below is a safety check */

  1047 ++			if (tok && (strchr(tok,0) > (tok+1))) {

  1048 ++				/* atoi stops at the first non-[0-9] char: */

  1049 ++				status->elapsedTime = atoi(re->value);

  1050 ++				status->totalTime = atoi(tok+1);

  1051 ++			}

  1052 ++		}

  1053 ++		else if(strcmp(re->name,"error")==0) {

  1054 ++			status->error = strdup(re->value);

  1055 ++		}

  1056 ++		else if(strcmp(re->name,"xfade")==0) {

  1057 ++			status->crossfade = atoi(re->value);

  1058 ++		}

  1059 ++		else if(strcmp(re->name,"updating_db")==0) {

  1060 ++			status->updatingDb = atoi(re->value);

  1061 ++		}

  1062 ++		else if(strcmp(re->name,"audio")==0) {

  1063 ++			char * tok = strchr(re->value,':');

  1064 ++			if (tok && (strchr(tok,0) > (tok+1))) {

  1065 ++				status->sampleRate = atoi(re->value);

  1066 ++				status->bits = atoi(++tok);

  1067 ++				tok = strchr(tok,':');

  1068 ++				if (tok && (strchr(tok,0) > (tok+1)))

  1069 ++					status->channels = atoi(tok+1);

  1070 ++			}

  1071 ++		}

  1072 ++

  1073 ++		mpd_getNextReturnElement(connection);

  1074 ++		if(connection->error) {

  1075 ++			free(status);

  1076 ++			return NULL;

  1077 ++		}

  1078 ++	}

  1079 ++

  1080 ++	if(connection->error) {

  1081 ++		free(status);

  1082 ++		return NULL;

  1083 ++	}

  1084 ++	else if(status->state<0) {

  1085 ++		strcpy(connection->errorStr,"state not found");

  1086 ++		connection->error = 1;

  1087 ++		free(status);

  1088 ++		return NULL;

  1089 ++	}

  1090 ++

  1091 ++	return status;

  1092 ++}

  1093 ++

  1094 ++void mpd_freeStatus(mpd_Status * status) {

  1095 ++	if(status->error) free(status->error);

  1096 ++	free(status);

  1097 ++}

  1098 ++

  1099 ++void mpd_sendStatsCommand(mpd_Connection * connection) {

  1100 ++	mpd_executeCommand(connection,"stats\n");

  1101 ++}

  1102 ++

  1103 ++mpd_Stats * mpd_getStats(mpd_Connection * connection) {

  1104 ++	mpd_Stats * stats;

  1105 ++

  1106 ++	/*mpd_executeCommand(connection,"stats\n");

  1107 ++

  1108 ++	if(connection->error) return NULL;*/

  1109 ++

  1110 ++	if(connection->doneProcessing || (connection->listOks &&

  1111 ++	   connection->doneListOk))

  1112 ++	{

  1113 ++		return NULL;

  1114 ++	}

  1115 ++

  1116 ++	if(!connection->returnElement) mpd_getNextReturnElement(connection);

  1117 ++

  1118 ++	stats = (mpd_Stats *)malloc(sizeof(mpd_Stats));

  1119 ++	stats->numberOfArtists = 0;

  1120 ++	stats->numberOfAlbums = 0;

  1121 ++	stats->numberOfSongs = 0;

  1122 ++	stats->uptime = 0;

  1123 ++	stats->dbUpdateTime = 0;

  1124 ++	stats->playTime = 0;

  1125 ++	stats->dbPlayTime = 0;

  1126 ++

  1127 ++	if(connection->error) {

  1128 ++		free(stats);

  1129 ++		return NULL;

  1130 ++	}

  1131 ++	while(connection->returnElement) {

  1132 ++		mpd_ReturnElement * re = connection->returnElement;

  1133 ++		if(strcmp(re->name,"artists")==0) {

  1134 ++			stats->numberOfArtists = atoi(re->value);

  1135 ++		}