chiark - git - mdw - disorder/blob - lib/eclient.c

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2006-2008 Richard Kettlewell
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20 /** @file lib/eclient.c
  21  * @brief Client code for event-driven programs
  22  */
  23
  24 #include "common.h"
  25
  26 #include <sys/types.h>
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <sys/un.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <netdb.h>
  33 #include <inttypes.h>
  34 #include <stddef.h>
  35 #include <time.h>
  36
  37 #include "log.h"
  38 #include "mem.h"
  39 #include "configuration.h"
  40 #include "queue.h"
  41 #include "eclient.h"
  42 #include "charset.h"
  43 #include "hex.h"
  44 #include "split.h"
  45 #include "vector.h"
  46 #include "inputline.h"
  47 #include "kvp.h"
  48 #include "syscalls.h"
  49 #include "printf.h"
  50 #include "addr.h"
  51 #include "authhash.h"
  52 #include "table.h"
  53 #include "client-common.h"
  54
  55 /* TODO: more commands */
  56
  57 /** @brief How often to send data to the server when receiving logs */
  58 #define LOG_PROD_INTERVAL 10
  59
  60 /* Types *********************************************************************/
  61
  62 /** @brief Client state */
  63 enum client_state {
  64   state_disconnected,          /**< @brief not connected */
  65   state_connecting,            /**< @brief waiting for connect() */
  66   state_connected,             /**< @brief connected but not authenticated */
  67   state_idle,                  /**< @brief not doing anything */
  68   state_cmdresponse,           /**< @brief waiting for command resonse */
  69   state_body,                  /**< @brief accumulating body */
  70   state_log,                   /**< @brief monitoring log */
  71 };
  72
  73 /** @brief Names for @ref client_state */
  74 static const char *const states[] = {
  75   "disconnected",
  76   "connecting",
  77   "connected",
  78   "idle",
  79   "cmdresponse",
  80   "body",
  81   "log"
  82 };
  83
  84 struct operation;                       /* forward decl */
  85
  86 /** @brief Type of an operation callback */
  87 typedef void operation_callback(disorder_eclient *c, struct operation *op);
  88
  89 /** @brief A pending operation.
  90  *
  91  * This can be either a command or part of the authentication protocol.  In the
  92  * former case new commands are appended to the list, in the latter case they
  93  * are inserted at the front. */
  94 struct operation {
  95   struct operation *next;          /**< @brief next operation */
  96   char *cmd;                       /**< @brief command to send or 0 */
  97   operation_callback *opcallback;  /**< @brief internal completion callback */
  98   void (*completed)();             /**< @brief user completion callback or 0 */
  99   void *v;                         /**< @brief data for COMPLETED */
 100   disorder_eclient *client;        /**< @brief owning client */
 101
 102   /** @brief true if sent to server
 103    *
 104    * This is cleared by disorder_eclient_close(), forcing all queued
 105    * commands to be transparently resent.
 106    */
 107   int sent;
 108 };
 109
 110 /** @brief Client structure */
 111 struct disorder_eclient {
 112   char *ident;
 113   int fd;                               /**< @brief connection to server */
 114   enum client_state state;              /**< @brief current state */
 115   int authenticated;                    /**< @brief true when authenicated */
 116   struct dynstr output;                 /**< @brief output buffer */
 117   struct dynstr input;                  /**< @brief input buffer */
 118   int eof;                              /**< @brief input buffer is at EOF */
 119   const disorder_eclient_callbacks *callbacks; /**< @brief error callbacks */
 120   void *u;                              /**< @brief user data */
 121   struct operation *ops;                /**< @brief queue of operations */
 122   struct operation **opstail;           /**< @brief queue tail */
 123   /* accumulated response */
 124   int rc;                               /**< @brief response code */
 125   char *line;                           /**< @brief complete line */
 126   struct vector vec;                    /**< @brief body */
 127
 128   const disorder_eclient_log_callbacks *log_callbacks;
 129   /**< @brief log callbacks
 130    *
 131    * Once disorder_eclient_log() has been issued this is always set.  When we
 132    * re-connect it is checked to re-issue the log command.
 133    */
 134   void *log_v;                          /**< @brief user data */
 135   unsigned long statebits;              /**< @brief latest state */
 136
 137   time_t last_prod;
 138   /**< @brief last time we sent a prod
 139    *
 140    * When we are receiving log data we send a "prod" byte to the server from
 141    * time to time so that we detect broken connections reasonably quickly.  The
 142    * server just ignores these bytes.
 143    */
 144
 145   /** @brief Protocol version */
 146   int protocol;
 147 };
 148
 149 /* Forward declarations ******************************************************/
 150
 151 static int start_connect(disorder_eclient *c);
 152 static void process_line(disorder_eclient *c, char *line);
 153 static void maybe_connected(disorder_eclient *c);
 154 static void authbanner_opcallback(disorder_eclient *c,
 155                                   struct operation *op);
 156 static void authuser_opcallback(disorder_eclient *c,
 157                                 struct operation *op);
 158 static void complete(disorder_eclient *c);
 159 static void send_output(disorder_eclient *c);
 160 static void put(disorder_eclient *c, const char *s, size_t n);
 161 static void read_input(disorder_eclient *c);
 162 static void stash_command(disorder_eclient *c,
 163                           int queuejump,
 164                           operation_callback *opcallback,
 165                           void (*completed)(),
 166                           void *v,
 167                           const char *cmd,
 168                           ...);
 169 static void log_opcallback(disorder_eclient *c, struct operation *op);
 170 static void logline(disorder_eclient *c, const char *line);
 171 static void logentry_completed(disorder_eclient *c, int nvec, char **vec);
 172 static void logentry_failed(disorder_eclient *c, int nvec, char **vec);
 173 static void logentry_moved(disorder_eclient *c, int nvec, char **vec);
 174 static void logentry_playing(disorder_eclient *c, int nvec, char **vec);
 175 static void logentry_queue(disorder_eclient *c, int nvec, char **vec);
 176 static void logentry_recent_added(disorder_eclient *c, int nvec, char **vec);
 177 static void logentry_recent_removed(disorder_eclient *c, int nvec, char **vec);
 178 static void logentry_removed(disorder_eclient *c, int nvec, char **vec);
 179 static void logentry_scratched(disorder_eclient *c, int nvec, char **vec);
 180 static void logentry_state(disorder_eclient *c, int nvec, char **vec);
 181 static void logentry_volume(disorder_eclient *c, int nvec, char **vec);
 182 static void logentry_rescanned(disorder_eclient *c, int nvec, char **vec);
 183
 184 /* Tables ********************************************************************/
 185
 186 /** @brief One possible log entry */
 187 struct logentry_handler {
 188   const char *name;                     /**< @brief Entry name */
 189   int min;                              /**< @brief Minimum arguments */
 190   int max;                              /**< @brief Maximum arguments */
 191   void (*handler)(disorder_eclient *c,
 192                   int nvec,
 193                   char **vec);          /**< @brief Handler function */
 194 };
 195
 196 /** @brief Table for parsing log entries */
 197 static const struct logentry_handler logentry_handlers[] = {
 198 #define LE(X, MIN, MAX) { #X, MIN, MAX, logentry_##X }
 199   LE(completed, 1, 1),
 200   LE(failed, 2, 2),
 201   LE(moved, 1, 1),
 202   LE(playing, 1, 2),
 203   LE(queue, 2, INT_MAX),
 204   LE(recent_added, 2, INT_MAX),
 205   LE(recent_removed, 1, 1),
 206   LE(removed, 1, 2),
 207   LE(rescanned, 0, 0),
 208   LE(scratched, 2, 2),
 209   LE(state, 1, 1),
 210   LE(volume, 2, 2)
 211 };
 212
 213 /* Setup and teardown ********************************************************/
 214
 215 /** @brief Create a new client
 216  *
 217  * Does NOT connect the client - connections are made (and re-made) on demand.
 218  */
 219 disorder_eclient *disorder_eclient_new(const disorder_eclient_callbacks *cb,
 220                                        void *u) {
 221   disorder_eclient *c = xmalloc(sizeof *c);
 222   D(("disorder_eclient_new"));
 223   c->fd = -1;
 224   c->callbacks = cb;
 225   c->u = u;
 226   c->opstail = &c->ops;
 227   vector_init(&c->vec);
 228   dynstr_init(&c->input);
 229   dynstr_init(&c->output);
 230   return c;
 231 }
 232
 233 /** @brief Disconnect a client
 234  * @param c Client to disconnect
 235  *
 236  * NB that this routine just disconnnects the TCP connection.  It does not
 237  * destroy the client!  If you continue to use it then it will attempt to
 238  * reconnect.
 239  */
 240 void disorder_eclient_close(disorder_eclient *c) {
 241   struct operation *op;
 242
 243   D(("disorder_eclient_close"));
 244   if(c->fd != -1) {
 245     D(("disorder_eclient_close closing fd %d", c->fd));
 246     c->callbacks->poll(c->u, c, c->fd, 0);
 247     xclose(c->fd);
 248     c->fd = -1;
 249     c->state = state_disconnected;
 250     c->statebits = 0;
 251   }
 252   c->output.nvec = 0;
 253   c->input.nvec = 0;
 254   c->eof = 0;
 255   c->authenticated = 0;
 256   /* We'll need to resend all operations */
 257   for(op = c->ops; op; op = op->next)
 258     op->sent = 0;
 259   /* Drop our use a hint that we're disconnected */
 260   if(c->log_callbacks && c->log_callbacks->state)
 261     c->log_callbacks->state(c->log_v, c->statebits);
 262 }
 263
 264 /** @brief Return current state */
 265 unsigned long disorder_eclient_state(const disorder_eclient *c) {
 266   return c->statebits | (c->state > state_connected ? DISORDER_CONNECTED : 0);
 267 }
 268
 269 /* Error reporting ***********************************************************/
 270
 271 /** @brief called when a connection error occurs
 272  *
 273  * After this called we will be disconnected (by disorder_eclient_close()),
 274  * so there will be a reconnection before any commands can be sent.
 275  */
 276 static int comms_error(disorder_eclient *c, const char *fmt, ...) {
 277   va_list ap;
 278   char *s;
 279
 280   D(("comms_error"));
 281   va_start(ap, fmt);
 282   byte_xvasprintf(&s, fmt, ap);
 283   va_end(ap);
 284   disorder_eclient_close(c);
 285   c->callbacks->comms_error(c->u, s);
 286   return -1;
 287 }
 288
 289 /** @brief called when the server reports an error */
 290 static int protocol_error(disorder_eclient *c, struct operation *op,
 291                           int code, const char *fmt, ...) {
 292   va_list ap;
 293   char *s;
 294
 295   D(("protocol_error"));
 296   va_start(ap, fmt);
 297   byte_xvasprintf(&s, fmt, ap);
 298   va_end(ap);
 299   c->callbacks->protocol_error(c->u, op->v, code, s);
 300   return -1;
 301 }
 302
 303 /* State machine *************************************************************/
 304
 305 /** @brief Called when there's something to do
 306  * @param c Client
 307  * @param mode bitmap of @ref DISORDER_POLL_READ and/or @ref DISORDER_POLL_WRITE.
 308  *
 309  * This should be called from by your code when the file descriptor is readable
 310  * or writable (as requested by the @c poll callback, see @ref
 311  * disorder_eclient_callbacks) and in any case from time to time (with @p mode
 312  * = 0) to allow for retries to work.
 313  */
 314 void disorder_eclient_polled(disorder_eclient *c, unsigned mode) {
 315   struct operation *op;
 316   time_t now;
 317
 318   D(("disorder_eclient_polled fd=%d state=%s mode=[%s %s]",
 319      c->fd, states[c->state],
 320      mode & DISORDER_POLL_READ ? "READ" : "",
 321      mode & DISORDER_POLL_WRITE ? "WRITE" : ""));
 322   /* The pattern here is to check each possible state in turn and try to
 323    * advance (though on error we might go back).  If we advance we leave open
 324    * the possibility of falling through to the next state, but we set the mode
 325    * bits to 0, to avoid false positives (which matter more in some cases than
 326    * others). */
 327
 328   if(c->state == state_disconnected) {
 329     D(("state_disconnected"));
 330     /* If there is no password yet then we cannot connect */
 331     if(!config->password) {
 332       comms_error(c, "no password is configured");
 333       return;
 334     }
 335     start_connect(c);
 336     /* might now be state_disconnected (on error), state_connecting (slow
 337      * connect) or state_connected (fast connect).  If state_disconnected then
 338      * we just rely on a periodic callback from the event loop sometime. */
 339     mode = 0;
 340   }
 341
 342   if(c->state == state_connecting && mode) {
 343     D(("state_connecting"));
 344     maybe_connected(c);
 345     /* Might be state_disconnected (on error) or state_connected (on success).
 346      * In the former case we rely on the event loop for a periodic callback to
 347      * retry. */
 348     mode = 0;
 349   }
 350
 351   if(c->state == state_connected) {
 352     D(("state_connected"));
 353     /* We just connected.  Initiate the authentication protocol. */
 354     stash_command(c, 1/*queuejump*/, authbanner_opcallback,
 355                   0/*completed*/, 0/*v*/, 0/*cmd*/);
 356     /* We never stay is state_connected very long.  We could in principle jump
 357      * straight to state_cmdresponse since there's actually no command to
 358      * send, but that would arguably be cheating. */
 359     c->state = state_idle;
 360   }
 361
 362   if(c->state == state_idle) {
 363     D(("state_idle"));
 364     /* We are connected, and have finished any command we set off, look for
 365      * some work to do */
 366     if(c->ops) {
 367       D(("have ops"));
 368       if(c->authenticated) {
 369         /* Transmit all unsent operations */
 370         for(op = c->ops; op; op = op->next) {
 371           if(!op->sent) {
 372             put(c, op->cmd, strlen(op->cmd));
 373             op->sent = 1;
 374           }
 375         }
 376       } else {
 377         /* Just send the head operation */
 378         if(c->ops->cmd && !c->ops->sent) {
 379           put(c, c->ops->cmd, strlen(c->ops->cmd));
 380           c->ops->sent = 1;
 381         }
 382       }
 383       /* Awaiting response for the operation at the head of the list */
 384       c->state = state_cmdresponse;
 385     } else
 386       /* genuinely idle */
 387       c->callbacks->report(c->u, 0);
 388   }
 389
 390   /* Queue up a byte to send */
 391   if(c->state == state_log
 392      && c->output.nvec == 0
 393      && time(&now) - c->last_prod > LOG_PROD_INTERVAL) {
 394     put(c, "x", 1);
 395     c->last_prod = now;
 396   }
 397
 398   if(c->state == state_cmdresponse
 399      || c->state == state_body
 400      || c->state == state_log) {
 401     D(("state_%s", states[c->state]));
 402     /* We are awaiting a response */
 403     if(mode & DISORDER_POLL_WRITE) send_output(c);
 404     if(mode & DISORDER_POLL_READ) read_input(c);
 405     /* There are a couple of reasons we might want to re-enter the state
 406      * machine from the top.  state_idle is obvious: there may be further
 407      * commands to process.  Re-entering on state_disconnected means that we
 408      * immediately retry connection if a comms error occurs during a command.
 409      * This is different to the case where a connection fails, where we await a
 410      * spontaneous call to initiate the retry. */
 411     switch(c->state) {
 412     case state_disconnected:            /* lost connection */
 413     case state_idle:                    /* completed a command */
 414       D(("retrying"));
 415       disorder_eclient_polled(c, 0);
 416       return;
 417     default:
 418       break;
 419     }
 420   }
 421
 422   /* Figure out what to set the mode to */
 423   switch(c->state) {
 424   case state_disconnected:
 425     D(("state_disconnected (2)"));
 426     /* Probably an error occurred.  Await a retry. */
 427     mode = 0;
 428     break;
 429   case state_connecting:
 430     D(("state_connecting (2)"));
 431     /* Waiting for connect to complete */
 432     mode = DISORDER_POLL_READ|DISORDER_POLL_WRITE;
 433     break;
 434   case state_connected:
 435     D(("state_connected (2)"));
 436     assert(!"should never be in state_connected here");
 437     break;
 438   case state_idle:
 439     D(("state_idle (2)"));
 440     /* Connected but nothing to do. */
 441     mode = 0;
 442     break;
 443   case state_cmdresponse:
 444   case state_body:
 445   case state_log:
 446     D(("state_%s (2)", states[c->state]));
 447     /* Gathering a response.  Wait for input. */
 448     mode = DISORDER_POLL_READ;
 449     /* Flush any pending output. */
 450     if(c->output.nvec) mode |= DISORDER_POLL_WRITE;
 451     break;
 452   }
 453   D(("fd=%d new mode [%s %s]",
 454      c->fd,
 455      mode & DISORDER_POLL_READ ? "READ" : "",
 456      mode & DISORDER_POLL_WRITE ? "WRITE" : ""));
 457   if(c->fd != -1) c->callbacks->poll(c->u, c, c->fd, mode);
 458 }
 459
 460 /** @brief Called to start connecting */
 461 static int start_connect(disorder_eclient *c) {
 462   struct sockaddr *sa;
 463   socklen_t len;
 464
 465   D(("start_connect"));
 466   if((len = find_server(&sa, &c->ident)) == (socklen_t)-1)
 467     return comms_error(c, "cannot look up server"); /* TODO better error */
 468   if(c->fd != -1) {
 469     xclose(c->fd);
 470     c->fd = -1;
 471   }
 472   if((c->fd = socket(sa->sa_family, SOCK_STREAM, 0)) < 0)
 473     return comms_error(c, "socket: %s", strerror(errno));
 474   c->eof = 0;
 475   nonblock(c->fd);
 476   cloexec(c->fd);
 477   if(connect(c->fd, sa, len) < 0) {
 478     switch(errno) {
 479     case EINTR:
 480     case EINPROGRESS:
 481       c->state = state_connecting;
 482       /* We are called from _polled so the state machine will get to do its
 483        * thing */
 484       return 0;
 485     default:
 486       /* Signal the error to the caller. */
 487       return comms_error(c, "connecting to %s: %s", c->ident, strerror(errno));
 488     }
 489   } else
 490     c->state = state_connected;
 491   return 0;
 492 }
 493
 494 /** @brief Called when poll triggers while waiting for a connection */
 495 static void maybe_connected(disorder_eclient *c) {
 496   /* We either connected, or got an error. */
 497   int err;
 498   socklen_t len = sizeof err;
 499
 500   D(("maybe_connected"));
 501   /* Work around over-enthusiastic error slippage */
 502   if(getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
 503     err = errno;
 504   if(err) {
 505     /* The connection failed */
 506     comms_error(c, "connecting to %s: %s", c->ident, strerror(err));
 507     /* sets state_disconnected */
 508   } else {
 509     char *r;
 510
 511     /* The connection succeeded */
 512     c->state = state_connected;
 513     byte_xasprintf(&r, "connected to %s", c->ident);
 514     c->callbacks->report(c->u, r);
 515     /* If this is a log client we expect to get a bunch of updates from the
 516      * server straight away */
 517   }
 518 }
 519
 520 /* Authentication ************************************************************/
 521
 522 /** @brief Called with the greeting from the server */
 523 static void authbanner_opcallback(disorder_eclient *c,
 524                                   struct operation *op) {
 525   size_t nonce_len;
 526   const unsigned char *nonce;
 527   const char *res;
 528   char **rvec;
 529   int nrvec;
 530   const char *protocol, *algorithm, *challenge;
 531
 532   D(("authbanner_opcallback"));
 533   if(c->rc / 100 != 2
 534      || !(rvec = split(c->line + 4, &nrvec, SPLIT_QUOTES, 0, 0))
 535      || nrvec < 1) {
 536     /* Banner told us to go away, or was malformed.  We cannot proceed. */
 537     protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
 538     disorder_eclient_close(c);
 539     return;
 540   }
 541   switch(nrvec) {
 542   case 1:
 543     protocol = "1";
 544     algorithm = "sha1";
 545     challenge = *rvec++;
 546     break;
 547   case 2:
 548     protocol = "1";
 549     algorithm = *rvec++;
 550     challenge = *rvec++;
 551     break;
 552   case 3:
 553     protocol = *rvec++;
 554     algorithm = *rvec++;
 555     challenge = *rvec++;
 556     break;
 557   default:
 558     protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
 559     disorder_eclient_close(c);
 560     return;
 561   }
 562   c->protocol = atoi(protocol);
 563   if(c->protocol < 1 || c->protocol > 2) {
 564     protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
 565     disorder_eclient_close(c);
 566     return;
 567   }
 568   nonce = unhex(challenge, &nonce_len);
 569   res = authhash(nonce, nonce_len, config->password, algorithm);
 570   if(!res) {
 571     protocol_error(c, op, c->rc, "%s: unknown authentication algorithm '%s'",
 572                    c->ident, algorithm);
 573     disorder_eclient_close(c);
 574     return;
 575   }
 576   stash_command(c, 1/*queuejump*/, authuser_opcallback, 0/*completed*/, 0/*v*/,
 577                 "user", quoteutf8(config->username), quoteutf8(res),
 578                 (char *)0);
 579 }
 580
 581 /** @brief Called with the response to the @c user command */
 582 static void authuser_opcallback(disorder_eclient *c,
 583                                 struct operation *op) {
 584   char *r;
 585
 586   D(("authuser_opcallback"));
 587   if(c->rc / 100 != 2) {
 588     /* Wrong password or something.  We cannot proceed. */
 589     protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
 590     disorder_eclient_close(c);
 591     return;
 592   }
 593   /* OK, we're authenticated now. */
 594   c->authenticated = 1;
 595   byte_xasprintf(&r, "authenticated with %s", c->ident);
 596   c->callbacks->report(c->u, r);
 597   if(c->log_callbacks && !(c->ops && c->ops->opcallback == log_opcallback))
 598     /* We are a log client, switch to logging mode */
 599     stash_command(c, 0/*queuejump*/, log_opcallback, 0/*completed*/, c->log_v,
 600                   "log", (char *)0);
 601 }
 602
 603 /* Output ********************************************************************/
 604
 605 /* Chop N bytes off the front of a dynstr */
 606 static void consume(struct dynstr *d, int n) {
 607   D(("consume %d", n));
 608   assert(d->nvec >= n);
 609   memmove(d->vec, d->vec + n, d->nvec - n);
 610   d->nvec -= n;
 611 }
 612
 613 /* Write some bytes */
 614 static void put(disorder_eclient *c, const char *s, size_t n) {
 615   D(("put %d %.*s", c->fd, (int)n, s));
 616   dynstr_append_bytes(&c->output, s, n);
 617 }
 618
 619 /* Called when we can write to our FD, or at any other time */
 620 static void send_output(disorder_eclient *c) {
 621   int n;
 622
 623   D(("send_output %d bytes pending", c->output.nvec));
 624   if(c->state > state_connecting && c->output.nvec) {
 625     n = write(c->fd, c->output.vec, c->output.nvec);
 626     if(n < 0) {
 627       switch(errno) {
 628       case EINTR:
 629       case EAGAIN:
 630         break;
 631       default:
 632         comms_error(c, "writing to %s: %s", c->ident, strerror(errno));
 633         break;
 634       }
 635     } else
 636       consume(&c->output, n);
 637   }
 638 }
 639
 640 /* Input *********************************************************************/
 641
 642 /* Called when c->fd might be readable, or at any other time */
 643 static void read_input(disorder_eclient *c) {
 644   char *nl;
 645   int n;
 646   char buffer[512];
 647
 648   D(("read_input in state %s", states[c->state]));
 649   if(c->state <= state_connected) return; /* ignore bogus calls */
 650   /* read some more input */
 651   n = read(c->fd, buffer, sizeof buffer);
 652   if(n < 0) {
 653     switch(errno) {
 654     case EINTR:
 655     case EAGAIN:
 656       break;
 657     default:
 658       comms_error(c, "reading from %s: %s", c->ident, strerror(errno));
 659       break;
 660     }
 661     return;                             /* no new input to process */
 662   } else if(n) {
 663     D(("read %d bytes: [%.*s]", n, n, buffer));
 664     dynstr_append_bytes(&c->input, buffer, n);
 665   } else
 666     c->eof = 1;
 667   /* might have more than one line to process */
 668   while(c->state > state_connecting
 669         && (nl = memchr(c->input.vec, '\n', c->input.nvec))) {
 670     process_line(c, xstrndup(c->input.vec, nl - c->input.vec));
 671     /* we might have disconnected along the way, which zogs the input buffer */
 672     if(c->state > state_connecting)
 673       consume(&c->input, (nl - c->input.vec) + 1);
 674   }
 675   if(c->eof) {
 676     comms_error(c, "reading from %s: server disconnected", c->ident);
 677     c->authenticated = 0;
 678   }
 679 }
 680
 681 /* called with a line that has just been read */
 682 static void process_line(disorder_eclient *c, char *line) {
 683   D(("process_line %d [%s]", c->fd, line));
 684   switch(c->state) {
 685   case state_cmdresponse:
 686     /* This is the first line of a response */
 687     if(!(line[0] >= '0' && line[0] <= '9'
 688          && line[1] >= '0' && line[1] <= '9'
 689          && line[2] >= '0' && line[2] <= '9'
 690          && line[3] == ' '))
 691       fatal(0, "invalid response from server: %s", line);
 692     c->rc = (line[0] * 10 + line[1]) * 10 + line[2] - 111 * '0';
 693     c->line = line;
 694     switch(c->rc % 10) {
 695     case 3:
 696       /* We need to collect the body. */
 697       c->state = state_body;
 698       vector_init(&c->vec);
 699       break;
 700     case 4:
 701       assert(c->log_callbacks != 0);
 702       if(c->log_callbacks->connected)
 703         c->log_callbacks->connected(c->log_v);
 704       c->state = state_log;
 705       break;
 706     default:
 707       /* We've got the whole response.  Go into the idle state so the state
 708        * machine knows we're done and then call the operation callback. */
 709       complete(c);
 710       break;
 711     }
 712     break;
 713   case state_body:
 714     if(strcmp(line, ".")) {
 715       /* A line from the body */
 716       vector_append(&c->vec, line + (line[0] == '.'));
 717     } else {
 718       /* End of the body. */
 719       vector_terminate(&c->vec);
 720       complete(c);
 721     }
 722     break;
 723   case state_log:
 724     if(strcmp(line, ".")) {
 725       logline(c, line + (line[0] == '.'));
 726     } else
 727       complete(c);
 728     break;
 729   default:
 730     assert(!"wrong state for location");
 731     break;
 732   }
 733 }
 734
 735 /* Called when an operation completes */
 736 static void complete(disorder_eclient *c) {
 737   struct operation *op;
 738
 739   D(("complete"));
 740   /* Pop the operation off the queue */
 741   op = c->ops;
 742   c->ops = op->next;
 743   if(c->opstail == &op->next)
 744     c->opstail = &c->ops;
 745   /* If we've pipelined a command ahead then we go straight to cmdresponser.
 746    * Otherwise we go to idle, which will arrange further sends. */
 747   c->state = c->ops && c->ops->sent ? state_cmdresponse : state_idle;
 748   op->opcallback(c, op);
 749   /* Note that we always call the opcallback even on error, though command
 750    * opcallbacks generally always do the same error handling, i.e. just call
 751    * protocol_error().  It's the auth* opcallbacks that have different
 752    * behaviour. */
 753 }
 754
 755 /* Operation setup ***********************************************************/
 756
 757 static void stash_command_vector(disorder_eclient *c,
 758                                  int queuejump,
 759                                  operation_callback *opcallback,
 760                                  void (*completed)(),
 761                                  void *v,
 762                                  int ncmd,
 763                                  char **cmd) {
 764   struct operation *op = xmalloc(sizeof *op);
 765   struct dynstr d;
 766   int n;
 767
 768   if(cmd) {
 769     dynstr_init(&d);
 770     for(n = 0; n < ncmd; ++n) {
 771       if(n)
 772         dynstr_append(&d, ' ');
 773       dynstr_append_string(&d, quoteutf8(cmd[n]));
 774     }
 775     dynstr_append(&d, '\n');
 776     dynstr_terminate(&d);
 777     op->cmd = d.vec;
 778   } else
 779     op->cmd = 0;                        /* usually, awaiting challenge */
 780   op->opcallback = opcallback;
 781   op->completed = completed;
 782   op->v = v;
 783   op->next = 0;
 784   op->client = c;
 785   assert(op->sent == 0);
 786   if(queuejump) {
 787     /* Authentication operations jump the queue of useful commands */
 788     op->next = c->ops;
 789     c->ops = op;
 790     if(c->opstail == &c->ops)
 791       c->opstail = &op->next;
 792     for(op = c->ops; op; op = op->next)
 793       assert(!op->sent);
 794   } else {
 795     *c->opstail = op;
 796     c->opstail = &op->next;
 797   }
 798 }
 799
 800 static void vstash_command(disorder_eclient *c,
 801                            int queuejump,
 802                            operation_callback *opcallback,
 803                            void (*completed)(),
 804                            void *v,
 805                            const char *cmd, va_list ap) {
 806   char *arg;
 807   struct vector vec;
 808
 809   D(("vstash_command %s", cmd ? cmd : "NULL"));
 810   if(cmd) {
 811     vector_init(&vec);
 812     vector_append(&vec, (char *)cmd);
 813     while((arg = va_arg(ap, char *)))
 814       vector_append(&vec, arg);
 815     stash_command_vector(c, queuejump, opcallback, completed, v,
 816                          vec.nvec, vec.vec);
 817   } else
 818     stash_command_vector(c, queuejump, opcallback, completed, v, 0, 0);
 819 }
 820
 821 static void stash_command(disorder_eclient *c,
 822                           int queuejump,
 823                           operation_callback *opcallback,
 824                           void (*completed)(),
 825                           void *v,
 826                           const char *cmd,
 827                           ...) {
 828   va_list ap;
 829
 830   va_start(ap, cmd);
 831   vstash_command(c, queuejump, opcallback, completed, v, cmd, ap);
 832   va_end(ap);
 833 }
 834
 835 /* Command support ***********************************************************/
 836
 837 static const char *errorstring(disorder_eclient *c) {
 838   char *s;
 839
 840   byte_xasprintf(&s, "%s: %s: %d", c->ident, c->line, c->rc);
 841   return s;
 842 }
 843
 844 /* for commands with a quoted string response */
 845 static void string_response_opcallback(disorder_eclient *c,
 846                                        struct operation *op) {
 847   disorder_eclient_string_response *completed
 848     = (disorder_eclient_string_response *)op->completed;
 849
 850   D(("string_response_callback"));
 851   if(c->rc / 100 == 2 || c->rc == 555) {
 852     if(op->completed) {
 853       if(c->rc == 555)
 854         completed(op->v, NULL, NULL);
 855       else if(c->protocol >= 2) {
 856         char **rr = split(c->line + 4, 0, SPLIT_QUOTES, 0, 0);
 857
 858         if(rr && *rr)
 859           completed(op->v, NULL, *rr);
 860         else
 861           /* TODO error message a is bit lame but generally indicates a server
 862            * bug rather than anything the user can address */
 863           completed(op->v, "error parsing response", NULL);
 864       } else
 865         completed(op->v, NULL, c->line + 4);
 866     }
 867   } else
 868     completed(op->v, errorstring(c), NULL);
 869 }
 870
 871 /* for commands with a simple integer response */
 872 static void integer_response_opcallback(disorder_eclient *c,
 873                                         struct operation *op) {
 874   disorder_eclient_integer_response *completed
 875     = (disorder_eclient_integer_response *)op->completed;
 876
 877   D(("string_response_callback"));
 878   if(c->rc / 100 == 2) {
 879     long n;
 880     int e;
 881
 882     e = xstrtol(&n, c->line + 4, 0, 10);
 883     if(e)
 884       completed(op->v, strerror(e), 0);
 885     else
 886       completed(op->v, 0, n);
 887   } else
 888     completed(op->v, errorstring(c), 0);
 889 }
 890
 891 /* for commands with no response */
 892 static void no_response_opcallback(disorder_eclient *c,
 893                                    struct operation *op) {
 894   disorder_eclient_no_response *completed
 895     = (disorder_eclient_no_response *)op->completed;
 896
 897   D(("no_response_callback"));
 898   if(c->rc / 100 == 2)
 899     completed(op->v, NULL);
 900   else
 901     completed(op->v, errorstring(c));
 902 }
 903
 904 /* error callback for queue_unmarshall */
 905 static void eclient_queue_error(const char *msg,
 906                                 void *u) {
 907   struct operation *op = u;
 908
 909   /* TODO don't use protocol_error here */
 910   protocol_error(op->client, op, -1, "error parsing queue entry: %s", msg);
 911 }
 912
 913 /* for commands that expect a queue dump */
 914 static void queue_response_opcallback(disorder_eclient *c,
 915                                       struct operation *op) {
 916   disorder_eclient_queue_response *const completed
 917     = (disorder_eclient_queue_response *)op->completed;
 918   int n;
 919   int parse_failed = 0;
 920   struct queue_entry *q, *qh = 0, **qtail = &qh, *qlast = 0;
 921
 922   D(("queue_response_callback"));
 923   if(c->rc / 100 == 2) {
 924     /* parse the queue */
 925     for(n = 0; n < c->vec.nvec; ++n) {
 926       q = xmalloc(sizeof *q);
 927       D(("queue_unmarshall %s", c->vec.vec[n]));
 928       if(!queue_unmarshall(q, c->vec.vec[n], NULL, op)) {
 929         q->prev = qlast;
 930         *qtail = q;
 931         qtail = &q->next;
 932         qlast = q;
 933       } else
 934         parse_failed = 1;
 935     }
 936     /* Currently we pass the partial queue to the callback along with the
 937      * error.  This might not be very useful in practice... */
 938     if(parse_failed)
 939       completed(op->v, "cannot parse result", qh);
 940     else
 941       completed(op->v, 0, qh);
 942   } else
 943     completed(op->v, errorstring(c), 0);
 944 }
 945
 946 /* for 'playing' */
 947 static void playing_response_opcallback(disorder_eclient *c,
 948                                         struct operation *op) {
 949   disorder_eclient_queue_response *const completed
 950     = (disorder_eclient_queue_response *)op->completed;
 951   struct queue_entry *q;
 952
 953   D(("playing_response_callback"));
 954   if(c->rc / 100 == 2) {
 955     switch(c->rc % 10) {
 956     case 2:
 957       if(queue_unmarshall(q = xmalloc(sizeof *q), c->line + 4,
 958                           NULL, c))
 959         completed(op->v, "cannot parse result", 0);
 960       else
 961         completed(op->v, 0, q);
 962       break;
 963     case 9:
 964       completed(op->v, 0, 0);
 965       break;
 966     default:
 967       completed(op->v, errorstring(c), 0);
 968       break;
 969     }
 970   } else
 971     completed(op->v, errorstring(c), 0);
 972 }
 973
 974 /* for commands that expect a list of some sort */
 975 static void list_response_opcallback(disorder_eclient *c,
 976                                      struct operation *op) {
 977   disorder_eclient_list_response *const completed =
 978     (disorder_eclient_list_response *)op->completed;
 979
 980   D(("list_response_callback"));
 981   if(c->rc / 100 == 2)
 982     completed(op->v, NULL, c->vec.nvec, c->vec.vec);
 983   else
 984     completed(op->v, errorstring(c), 0, 0);
 985 }
 986
 987 /* for volume */
 988 static void volume_response_opcallback(disorder_eclient *c,
 989                                        struct operation *op) {
 990   disorder_eclient_volume_response *completed
 991     = (disorder_eclient_volume_response *)op->completed;
 992   int l, r;
 993
 994   D(("volume_response_callback"));
 995   if(c->rc / 100 == 2) {
 996     if(op->completed) {
 997       if(sscanf(c->line + 4, "%d %d", &l, &r) != 2 || l < 0 || r < 0)
 998         completed(op->v, "cannot parse volume response", 0, 0);
 999       else
1000         completed(op->v, 0, l, r);
1001     }
1002   } else
1003     completed(op->v, errorstring(c), 0, 0);
1004 }
1005
1006 static int simple(disorder_eclient *c,
1007                   operation_callback *opcallback,
1008                   void (*completed)(),
1009                   void *v,
1010                   const char *cmd, ...) {
1011   va_list ap;
1012
1013   va_start(ap, cmd);
1014   vstash_command(c, 0/*queuejump*/, opcallback, completed, v, cmd, ap);
1015   va_end(ap);
1016   /* Give the state machine a kick, since we might be in state_idle */
1017   disorder_eclient_polled(c, 0);
1018   return 0;
1019 }
1020
1021 /* Commands ******************************************************************/
1022
1023 int disorder_eclient_version(disorder_eclient *c,
1024                              disorder_eclient_string_response *completed,
1025                              void *v) {
1026   return simple(c, string_response_opcallback, (void (*)())completed, v,
1027                 "version", (char *)0);
1028 }
1029
1030 int disorder_eclient_namepart(disorder_eclient *c,
1031                               disorder_eclient_string_response *completed,
1032                               const char *track,
1033                               const char *context,
1034                               const char *part,
1035                               void *v) {
1036   return simple(c, string_response_opcallback, (void (*)())completed, v,
1037                 "part", track, context, part, (char *)0);
1038 }
1039
1040 int disorder_eclient_play(disorder_eclient *c,
1041                           const char *track,
1042                           disorder_eclient_no_response *completed,
1043                           void *v) {
1044   return simple(c, no_response_opcallback, (void (*)())completed, v,
1045                 "play", track, (char *)0);
1046 }
1047
1048 int disorder_eclient_pause(disorder_eclient *c,
1049                            disorder_eclient_no_response *completed,
1050                            void *v) {
1051   return simple(c, no_response_opcallback, (void (*)())completed, v,
1052                 "pause", (char *)0);
1053 }
1054
1055 int disorder_eclient_resume(disorder_eclient *c,
1056                             disorder_eclient_no_response *completed,
1057                             void *v) {
1058   return simple(c, no_response_opcallback, (void (*)())completed, v,
1059                 "resume", (char *)0);
1060 }
1061
1062 int disorder_eclient_scratch(disorder_eclient *c,
1063                              const char *id,
1064                              disorder_eclient_no_response *completed,
1065                              void *v) {
1066   return simple(c, no_response_opcallback, (void (*)())completed, v,
1067                 "scratch", id, (char *)0);
1068 }
1069
1070 int disorder_eclient_scratch_playing(disorder_eclient *c,
1071                                      disorder_eclient_no_response *completed,
1072                                      void *v) {
1073   return disorder_eclient_scratch(c, 0, completed, v);
1074 }
1075
1076 int disorder_eclient_remove(disorder_eclient *c,
1077                             const char *id,
1078                             disorder_eclient_no_response *completed,
1079                             void *v) {
1080   return simple(c, no_response_opcallback, (void (*)())completed, v,
1081                 "remove", id, (char *)0);
1082 }
1083
1084 int disorder_eclient_moveafter(disorder_eclient *c,
1085                                const char *target,
1086                                int nids,
1087                                const char **ids,
1088                                disorder_eclient_no_response *completed,
1089                                void *v) {
1090   struct vector vec;
1091   int n;
1092
1093   vector_init(&vec);
1094   vector_append(&vec, (char *)"moveafter");
1095   vector_append(&vec, (char *)target);
1096   for(n = 0; n < nids; ++n)
1097     vector_append(&vec, (char *)ids[n]);
1098   stash_command_vector(c, 0/*queuejump*/, no_response_opcallback, completed, v,
1099                        vec.nvec, vec.vec);
1100   disorder_eclient_polled(c, 0);
1101   return 0;
1102 }
1103
1104 int disorder_eclient_recent(disorder_eclient *c,
1105                             disorder_eclient_queue_response *completed,
1106                             void *v) {
1107   return simple(c, queue_response_opcallback, (void (*)())completed, v,
1108                 "recent", (char *)0);
1109 }
1110
1111 int disorder_eclient_queue(disorder_eclient *c,
1112                             disorder_eclient_queue_response *completed,
1113                             void *v) {
1114   return simple(c, queue_response_opcallback, (void (*)())completed, v,
1115                 "queue", (char *)0);
1116 }
1117
1118 int disorder_eclient_files(disorder_eclient *c,
1119                            disorder_eclient_list_response *completed,
1120                            const char *dir,
1121                            const char *re,
1122                            void *v) {
1123   return simple(c, list_response_opcallback, (void (*)())completed, v,
1124                 "files", dir, re, (char *)0);
1125 }
1126
1127 int disorder_eclient_dirs(disorder_eclient *c,
1128                           disorder_eclient_list_response *completed,
1129                           const char *dir,
1130                           const char *re,
1131                           void *v) {
1132   return simple(c, list_response_opcallback, (void (*)())completed, v,
1133                 "dirs", dir, re, (char *)0);
1134 }
1135
1136 int disorder_eclient_playing(disorder_eclient *c,
1137                              disorder_eclient_queue_response *completed,
1138                              void *v) {
1139   return simple(c, playing_response_opcallback, (void (*)())completed, v,
1140                 "playing", (char *)0);
1141 }
1142
1143 int disorder_eclient_length(disorder_eclient *c,
1144                             disorder_eclient_integer_response *completed,
1145                             const char *track,
1146                             void *v) {
1147   return simple(c, integer_response_opcallback, (void (*)())completed, v,
1148                 "length", track, (char *)0);
1149 }
1150
1151 int disorder_eclient_volume(disorder_eclient *c,
1152                             disorder_eclient_volume_response *completed,
1153                             int l, int r,
1154                             void *v) {
1155   char sl[64], sr[64];
1156
1157   if(l < 0 && r < 0) {
1158     return simple(c, volume_response_opcallback, (void (*)())completed, v,
1159                   "volume", (char *)0);
1160   } else if(l >= 0 && r >= 0) {
1161     assert(l <= 100);
1162     assert(r <= 100);
1163     byte_snprintf(sl, sizeof sl, "%d", l);
1164     byte_snprintf(sr, sizeof sr, "%d", r);
1165     return simple(c, volume_response_opcallback, (void (*)())completed, v,
1166                   "volume", sl, sr, (char *)0);
1167   } else {
1168     assert(!"invalid arguments to disorder_eclient_volume");
1169     return -1;                          /* gcc is being dim */
1170   }
1171 }
1172
1173 int disorder_eclient_enable(disorder_eclient *c,
1174                             disorder_eclient_no_response *completed,
1175                             void *v) {
1176   return simple(c, no_response_opcallback, (void (*)())completed, v,
1177                 "enable", (char *)0);
1178 }
1179
1180 int disorder_eclient_disable(disorder_eclient *c,
1181                              disorder_eclient_no_response *completed,
1182                              void *v){
1183   return simple(c, no_response_opcallback, (void (*)())completed, v,
1184                 "disable", (char *)0);
1185 }
1186
1187 int disorder_eclient_random_enable(disorder_eclient *c,
1188                                    disorder_eclient_no_response *completed,
1189                                    void *v){
1190   return simple(c, no_response_opcallback, (void (*)())completed, v,
1191                 "random-enable", (char *)0);
1192 }
1193
1194 int disorder_eclient_random_disable(disorder_eclient *c,
1195                                     disorder_eclient_no_response *completed,
1196                                     void *v){
1197   return simple(c, no_response_opcallback, (void (*)())completed, v,
1198                 "random-disable", (char *)0);
1199 }
1200
1201 int disorder_eclient_get(disorder_eclient *c,
1202                          disorder_eclient_string_response *completed,
1203                          const char *track, const char *pref,
1204                          void *v) {
1205   return simple(c, string_response_opcallback, (void (*)())completed, v,
1206                 "get", track, pref, (char *)0);
1207 }
1208
1209 int disorder_eclient_set(disorder_eclient *c,
1210                          disorder_eclient_no_response *completed,
1211                          const char *track, const char *pref,
1212                          const char *value,
1213                          void *v) {
1214   return simple(c, no_response_opcallback, (void (*)())completed, v,
1215                 "set", track, pref, value, (char *)0);
1216 }
1217
1218 int disorder_eclient_unset(disorder_eclient *c,
1219                            disorder_eclient_no_response *completed,
1220                            const char *track, const char *pref,
1221                            void *v) {
1222   return simple(c, no_response_opcallback, (void (*)())completed, v,
1223                 "unset", track, pref, (char *)0);
1224 }
1225
1226 int disorder_eclient_resolve(disorder_eclient *c,
1227                              disorder_eclient_string_response *completed,
1228                              const char *track,
1229                              void *v) {
1230   return simple(c, string_response_opcallback,  (void (*)())completed, v,
1231                 "resolve", track, (char *)0);
1232 }
1233
1234 int disorder_eclient_search(disorder_eclient *c,
1235                             disorder_eclient_list_response *completed,
1236                             const char *terms,
1237                             void *v) {
1238   if(!split(terms, 0, SPLIT_QUOTES, 0, 0)) return -1;
1239   return simple(c, list_response_opcallback, (void (*)())completed, v,
1240                 "search", terms, (char *)0);
1241 }
1242
1243 int disorder_eclient_nop(disorder_eclient *c,
1244                          disorder_eclient_no_response *completed,
1245                          void *v) {
1246   return simple(c, no_response_opcallback, (void (*)())completed, v,
1247                 "nop", (char *)0);
1248 }
1249
1250 /** @brief Get the last @p max added tracks
1251  * @param c Client
1252  * @param completed Called with list
1253  * @param max Number of tracks to get, 0 for all
1254  * @param v Passed to @p completed
1255  *
1256  * The first track in the list is the most recently added.
1257  */
1258 int disorder_eclient_new_tracks(disorder_eclient *c,
1259                                 disorder_eclient_list_response *completed,
1260                                 int max,
1261                                 void *v) {
1262   char limit[32];
1263
1264   sprintf(limit, "%d", max);
1265   return simple(c, list_response_opcallback, (void (*)())completed, v,
1266                 "new", limit, (char *)0);
1267 }
1268
1269 static void rtp_response_opcallback(disorder_eclient *c,
1270                                     struct operation *op) {
1271   disorder_eclient_list_response *const completed =
1272     (disorder_eclient_list_response *)op->completed;
1273   D(("rtp_response_opcallback"));
1274   if(c->rc / 100 == 2) {
1275     int nvec;
1276     char **vec = split(c->line + 4, &nvec, SPLIT_QUOTES, 0, 0);
1277
1278     if(vec)
1279       completed(op->v, NULL, nvec, vec);
1280     else
1281       completed(op->v, "error parsing response", 0, 0);
1282   } else
1283     completed(op->v, errorstring(c), 0, 0);
1284 }
1285
1286 /** @brief Determine the RTP target address
1287  * @param c Client
1288  * @param completed Called with address details
1289  * @param v Passed to @p completed
1290  *
1291  * The address details will be two elements, the first being the hostname and
1292  * the second the service (port).
1293  */
1294 int disorder_eclient_rtp_address(disorder_eclient *c,
1295                                  disorder_eclient_list_response *completed,
1296                                  void *v) {
1297   return simple(c, rtp_response_opcallback, (void (*)())completed, v,
1298                 "rtp-address", (char *)0);
1299 }
1300
1301 /** @brief Get the list of users
1302  * @param c Client
1303  * @param completed Called with list of users
1304  * @param v Passed to @p completed
1305  *
1306  * The user list is not sorted in any particular order.
1307  */
1308 int disorder_eclient_users(disorder_eclient *c,
1309                            disorder_eclient_list_response *completed,
1310                            void *v) {
1311   return simple(c, list_response_opcallback, (void (*)())completed, v,
1312                 "users", (char *)0);
1313 }
1314
1315 /** @brief Delete a user
1316  * @param c Client
1317  * @param completed Called on completion
1318  * @param user User to delete
1319  * @param v Passed to @p completed
1320  */
1321 int disorder_eclient_deluser(disorder_eclient *c,
1322                              disorder_eclient_no_response *completed,
1323                              const char *user,
1324                              void *v) {
1325   return simple(c, no_response_opcallback, (void (*)())completed, v,
1326                 "deluser", user, (char *)0);
1327 }
1328
1329 /** @brief Get a user property
1330  * @param c Client
1331  * @param completed Called on completion
1332  * @param user User to look up
1333  * @param property Property to look up
1334  * @param v Passed to @p completed
1335  */
1336 int disorder_eclient_userinfo(disorder_eclient *c,
1337                               disorder_eclient_string_response *completed,
1338                               const char *user,
1339                               const char *property,
1340                               void *v) {
1341   return simple(c, string_response_opcallback,  (void (*)())completed, v,
1342                 "userinfo", user, property, (char *)0);
1343 }
1344
1345 /** @brief Modify a user property
1346  * @param c Client
1347  * @param completed Called on completion
1348  * @param user User to modify
1349  * @param property Property to modify
1350  * @param value New property value
1351  * @param v Passed to @p completed
1352  */
1353 int disorder_eclient_edituser(disorder_eclient *c,
1354                               disorder_eclient_no_response *completed,
1355                               const char *user,
1356                               const char *property,
1357                               const char *value,
1358                               void *v) {
1359   return simple(c, no_response_opcallback, (void (*)())completed, v,
1360                 "edituser", user, property, value, (char *)0);
1361 }
1362
1363 /** @brief Create a new user
1364  * @param c Client
1365  * @param completed Called on completion
1366  * @param user User to create
1367  * @param password Initial password
1368  * @param rights Initial rights or NULL
1369  * @param v Passed to @p completed
1370  */
1371 int disorder_eclient_adduser(disorder_eclient *c,
1372                              disorder_eclient_no_response *completed,
1373                              const char *user,
1374                              const char *password,
1375                              const char *rights,
1376                              void *v) {
1377   return simple(c, no_response_opcallback, (void (*)())completed, v,
1378                 "adduser", user, password, rights, (char *)0);
1379 }
1380
1381 /* Log clients ***************************************************************/
1382
1383 /** @brief Monitor the server log
1384  * @param c Client
1385  * @param callbacks Functions to call when anything happens
1386  * @param v Passed to @p callbacks functions
1387  *
1388  * Once a client is being used for logging it cannot be used for anything else.
1389  * There is magic in authuser_opcallback() to re-submit the @c log command
1390  * after reconnection.
1391  *
1392  * NB that the @c state callback may be called from within this function,
1393  * i.e. not solely later on from the event loop callback.
1394  */
1395 int disorder_eclient_log(disorder_eclient *c,
1396                          const disorder_eclient_log_callbacks *callbacks,
1397                          void *v) {
1398   if(c->log_callbacks) return -1;
1399   c->log_callbacks = callbacks;
1400   c->log_v = v;
1401   /* Repoort initial state */
1402   if(c->log_callbacks->state)
1403     c->log_callbacks->state(c->log_v, c->statebits);
1404   stash_command(c, 0/*queuejump*/, log_opcallback, 0/*completed*/, v,
1405                 "log", (char *)0);
1406   disorder_eclient_polled(c, 0);
1407   return 0;
1408 }
1409
1410 /* If we get here we've stopped being a log client */
1411 static void log_opcallback(disorder_eclient *c,
1412                            struct operation attribute((unused)) *op) {
1413   D(("log_opcallback"));
1414   c->log_callbacks = 0;
1415   c->log_v = 0;
1416 }
1417
1418 /* error callback for log line parsing */
1419 static void logline_error(const char *msg, void *u) {
1420   disorder_eclient *c = u;
1421   /* TODO don't use protocol_error here */
1422   protocol_error(c, c->ops, -1, "error parsing log line: %s", msg);
1423 }
1424
1425 /* process a single log line */
1426 static void logline(disorder_eclient *c, const char *line) {
1427   int nvec, n;
1428   char **vec;
1429   uintmax_t when;
1430
1431   D(("logline [%s]", line));
1432   vec = split(line, &nvec, SPLIT_QUOTES, logline_error, c);
1433   if(nvec < 2) return;                  /* probably an error, already
1434                                          * reported */
1435   if(sscanf(vec[0], "%"SCNxMAX, &when) != 1) {
1436     /* probably the wrong side of a format change */
1437     /* TODO don't use protocol_error here */
1438     protocol_error(c, c->ops, -1, "invalid log timestamp '%s'", vec[0]);
1439     return;
1440   }
1441   /* TODO: do something with the time */
1442   n = TABLE_FIND(logentry_handlers, name, vec[1]);
1443   if(n < 0) return;                     /* probably a future command */
1444   vec += 2;
1445   nvec -= 2;
1446   if(nvec < logentry_handlers[n].min || nvec > logentry_handlers[n].max)
1447     return;
1448   logentry_handlers[n].handler(c, nvec, vec);
1449 }
1450
1451 static void logentry_completed(disorder_eclient *c,
1452                                int attribute((unused)) nvec, char **vec) {
1453   c->statebits &= ~DISORDER_PLAYING;
1454   if(c->log_callbacks->completed)
1455     c->log_callbacks->completed(c->log_v, vec[0]);
1456   if(c->log_callbacks->state)
1457     c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1458 }
1459
1460 static void logentry_failed(disorder_eclient *c,
1461                             int attribute((unused)) nvec, char **vec) {
1462   c->statebits &= ~DISORDER_PLAYING;
1463   if(c->log_callbacks->failed)
1464     c->log_callbacks->failed(c->log_v, vec[0], vec[1]);
1465   if(c->log_callbacks->state)
1466     c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1467 }
1468
1469 static void logentry_moved(disorder_eclient *c,
1470                            int attribute((unused)) nvec, char **vec) {
1471   if(c->log_callbacks->moved)
1472     c->log_callbacks->moved(c->log_v, vec[0]);
1473 }
1474
1475 static void logentry_playing(disorder_eclient *c,
1476                              int attribute((unused)) nvec, char **vec) {
1477   c->statebits |= DISORDER_PLAYING;
1478   if(c->log_callbacks->playing)
1479     c->log_callbacks->playing(c->log_v, vec[0], vec[1]);
1480   if(c->log_callbacks->state)
1481     c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1482 }
1483
1484 static void logentry_queue(disorder_eclient *c,
1485                            int attribute((unused)) nvec, char **vec) {
1486   struct queue_entry *q;
1487
1488   if(!c->log_callbacks->queue) return;
1489   q = xmalloc(sizeof *q);
1490   if(queue_unmarshall_vec(q, nvec, vec, eclient_queue_error, c))
1491     return;                             /* bogus */
1492   c->log_callbacks->queue(c->log_v, q);
1493 }
1494
1495 static void logentry_recent_added(disorder_eclient *c,
1496                                   int attribute((unused)) nvec, char **vec) {
1497   struct queue_entry *q;
1498
1499   if(!c->log_callbacks->recent_added) return;
1500   q = xmalloc(sizeof *q);
1501   if(queue_unmarshall_vec(q, nvec, vec, eclient_queue_error, c))
1502     return;                           /* bogus */
1503   c->log_callbacks->recent_added(c->log_v, q);
1504 }
1505
1506 static void logentry_recent_removed(disorder_eclient *c,
1507                                     int attribute((unused)) nvec, char **vec) {
1508   if(c->log_callbacks->recent_removed)
1509     c->log_callbacks->recent_removed(c->log_v, vec[0]);
1510 }
1511
1512 static void logentry_removed(disorder_eclient *c,
1513                              int attribute((unused)) nvec, char **vec) {
1514   if(c->log_callbacks->removed)
1515     c->log_callbacks->removed(c->log_v, vec[0], vec[1]);
1516 }
1517
1518 static void logentry_rescanned(disorder_eclient *c,
1519                                int attribute((unused)) nvec,
1520                                char attribute((unused)) **vec) {
1521   if(c->log_callbacks->rescanned)
1522     c->log_callbacks->rescanned(c->log_v);
1523 }
1524
1525 static void logentry_scratched(disorder_eclient *c,
1526                                int attribute((unused)) nvec, char **vec) {
1527   c->statebits &= ~DISORDER_PLAYING;
1528   if(c->log_callbacks->scratched)
1529     c->log_callbacks->scratched(c->log_v, vec[0], vec[1]);
1530   if(c->log_callbacks->state)
1531     c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1532 }
1533
1534 static const struct {
1535   unsigned long bit;
1536   const char *enable;
1537   const char *disable;
1538 } statestrings[] = {
1539   { DISORDER_PLAYING_ENABLED, "enable_play", "disable_play" },
1540   { DISORDER_RANDOM_ENABLED, "enable_random", "disable_random" },
1541   { DISORDER_TRACK_PAUSED, "pause", "resume" },
1542   { DISORDER_PLAYING, "playing", "completed" },
1543   { DISORDER_PLAYING, 0, "scratched" },
1544   { DISORDER_PLAYING, 0, "failed" },
1545 };
1546 #define NSTATES (int)(sizeof statestrings / sizeof *statestrings)
1547
1548 static void logentry_state(disorder_eclient *c,
1549                            int attribute((unused)) nvec, char **vec) {
1550   int n;
1551
1552   for(n = 0; n < NSTATES; ++n)
1553     if(statestrings[n].enable && !strcmp(vec[0], statestrings[n].enable)) {
1554       c->statebits |= statestrings[n].bit;
1555       break;
1556     } else if(statestrings[n].disable && !strcmp(vec[0], statestrings[n].disable)) {
1557       c->statebits &= ~statestrings[n].bit;
1558       break;
1559     }
1560   if(c->log_callbacks->state)
1561     c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1562 }
1563
1564 static void logentry_volume(disorder_eclient *c,
1565                             int attribute((unused)) nvec, char **vec) {
1566   long l, r;
1567
1568   if(!c->log_callbacks->volume) return;
1569   if(xstrtol(&l, vec[0], 0, 10)
1570      || xstrtol(&r, vec[1], 0, 10)
1571      || l < 0 || l > INT_MAX
1572      || r < 0 || r > INT_MAX)
1573     return;                             /* bogus */
1574   c->log_callbacks->volume(c->log_v, (int)l, (int)r);
1575 }
1576
1577 /** @brief Convert @p statebits to a string */
1578 char *disorder_eclient_interpret_state(unsigned long statebits) {
1579   struct dynstr d[1];
1580   size_t n;
1581
1582   static const struct {
1583     unsigned long bit;
1584     const char *name;
1585   } bits[] = {
1586     { DISORDER_PLAYING_ENABLED, "playing_enabled" },
1587     { DISORDER_RANDOM_ENABLED, "random_enabled" },
1588     { DISORDER_TRACK_PAUSED, "track_paused" },
1589     { DISORDER_PLAYING, "playing" },
1590     { DISORDER_CONNECTED, "connected" },
1591   };
1592 #define NBITS (sizeof bits / sizeof *bits)
1593
1594   dynstr_init(d);
1595   if(!statebits)
1596     dynstr_append(d, '0');
1597   for(n = 0; n < NBITS; ++n)
1598     if(statebits & bits[n].bit) {
1599       if(d->nvec)
1600         dynstr_append(d, '|');
1601       dynstr_append_string(d, bits[n].name);
1602       statebits ^= bits[n].bit;
1603     }
1604   if(statebits) {
1605     char s[20];
1606
1607     if(d->nvec)
1608       dynstr_append(d, '|');
1609     sprintf(s, "%#lx", statebits);
1610     dynstr_append_string(d, s);
1611   }
1612   dynstr_terminate(d);
1613   return d->vec;
1614 }
1615
1616 /*
1617 Local Variables:
1618 c-basic-offset:2
1619 comment-column:40
1620 fill-column:79
1621 indent-tabs-mode:nil
1622 End:
1623 */