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