2 * This file is part of DisOrder.
3 * Copyright (C) 2006-2008 Richard Kettlewell
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 3 of the License, or
8 * (at your option) any later version.
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.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 /** @file lib/eclient.c
19 * @brief Client code for event-driven programs
24 #include <sys/types.h>
25 #include <sys/socket.h>
26 #include <netinet/in.h>
37 #include "configuration.h"
44 #include "inputline.h"
51 #include "client-common.h"
53 /* TODO: more commands */
55 /** @brief How often to send data to the server when receiving logs */
56 #define LOG_PROD_INTERVAL 10
58 /* Types *********************************************************************/
60 /** @brief Client state */
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 */
71 /** @brief Names for @ref client_state */
72 static const char *const states[] = {
82 struct operation; /* forward decl */
84 /** @brief Type of an operation callback */
85 typedef void operation_callback(disorder_eclient *c, struct operation *op);
87 /** @brief A pending operation.
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. */
93 struct operation *next; /**< @brief next operation */
94 char *cmd; /**< @brief command to send or 0 */
95 char **body; /**< @brief command body */
96 operation_callback *opcallback; /**< @brief internal completion callback */
97 void (*completed)(); /**< @brief user completion callback or 0 */
98 void *v; /**< @brief data for COMPLETED */
99 disorder_eclient *client; /**< @brief owning client */
101 /** @brief true if sent to server
103 * This is cleared by disorder_eclient_close(), forcing all queued
104 * commands to be transparently resent.
109 /** @brief Client structure */
110 struct disorder_eclient {
112 int fd; /**< @brief connection to server */
113 enum client_state state; /**< @brief current state */
114 int authenticated; /**< @brief true when authenicated */
115 struct dynstr output; /**< @brief output buffer */
116 struct dynstr input; /**< @brief input buffer */
117 int eof; /**< @brief input buffer is at EOF */
118 const disorder_eclient_callbacks *callbacks; /**< @brief error callbacks */
119 void *u; /**< @brief user data */
120 struct operation *ops; /**< @brief queue of operations */
121 struct operation **opstail; /**< @brief queue tail */
122 /* accumulated response */
123 int rc; /**< @brief response code */
124 char *line; /**< @brief complete line */
125 struct vector vec; /**< @brief body */
127 const disorder_eclient_log_callbacks *log_callbacks;
128 /**< @brief log callbacks
130 * Once disorder_eclient_log() has been issued this is always set. When we
131 * re-connect it is checked to re-issue the log command.
133 void *log_v; /**< @brief user data */
134 unsigned long statebits; /**< @brief latest state */
137 /**< @brief last time we sent a prod
139 * When we are receiving log data we send a "prod" byte to the server from
140 * time to time so that we detect broken connections reasonably quickly. The
141 * server just ignores these bytes.
144 /** @brief Protocol version */
147 /** @brief True if enabled */
151 /* Forward declarations ******************************************************/
153 static int start_connect(disorder_eclient *c);
154 static void process_line(disorder_eclient *c, char *line);
155 static void maybe_connected(disorder_eclient *c);
156 static void authbanner_opcallback(disorder_eclient *c,
157 struct operation *op);
158 static void authuser_opcallback(disorder_eclient *c,
159 struct operation *op);
160 static void complete(disorder_eclient *c);
161 static void send_output(disorder_eclient *c);
162 static void put(disorder_eclient *c, const char *s, size_t n);
163 static void read_input(disorder_eclient *c);
164 static void stash_command(disorder_eclient *c,
166 operation_callback *opcallback,
173 static void log_opcallback(disorder_eclient *c, struct operation *op);
174 static void logline(disorder_eclient *c, const char *line);
175 static void logentry_completed(disorder_eclient *c, int nvec, char **vec);
176 static void logentry_failed(disorder_eclient *c, int nvec, char **vec);
177 static void logentry_moved(disorder_eclient *c, int nvec, char **vec);
178 static void logentry_playing(disorder_eclient *c, int nvec, char **vec);
179 static void logentry_queue(disorder_eclient *c, int nvec, char **vec);
180 static void logentry_recent_added(disorder_eclient *c, int nvec, char **vec);
181 static void logentry_recent_removed(disorder_eclient *c, int nvec, char **vec);
182 static void logentry_removed(disorder_eclient *c, int nvec, char **vec);
183 static void logentry_scratched(disorder_eclient *c, int nvec, char **vec);
184 static void logentry_state(disorder_eclient *c, int nvec, char **vec);
185 static void logentry_volume(disorder_eclient *c, int nvec, char **vec);
186 static void logentry_rescanned(disorder_eclient *c, int nvec, char **vec);
187 static void logentry_user_add(disorder_eclient *c, int nvec, char **vec);
188 static void logentry_user_confirm(disorder_eclient *c, int nvec, char **vec);
189 static void logentry_user_delete(disorder_eclient *c, int nvec, char **vec);
190 static void logentry_user_edit(disorder_eclient *c, int nvec, char **vec);
191 static void logentry_rights_changed(disorder_eclient *c, int nvec, char **vec);
192 static void logentry_adopted(disorder_eclient *c, int nvec, char **vec);
193 static void logentry_playlist_created(disorder_eclient *c, int nvec, char **vec);
194 static void logentry_playlist_deleted(disorder_eclient *c, int nvec, char **vec);
195 static void logentry_playlist_modified(disorder_eclient *c, int nvec, char **vec);
196 static void logentry_global_pref(disorder_eclient *c, int nvec, char **vec);
198 /* Tables ********************************************************************/
200 /** @brief One possible log entry */
201 struct logentry_handler {
202 const char *name; /**< @brief Entry name */
203 int min; /**< @brief Minimum arguments */
204 int max; /**< @brief Maximum arguments */
205 void (*handler)(disorder_eclient *c,
207 char **vec); /**< @brief Handler function */
210 /** @brief Table for parsing log entries */
211 static const struct logentry_handler logentry_handlers[] = {
212 #define LE(X, MIN, MAX) { #X, MIN, MAX, logentry_##X }
216 LE(global_pref, 1, 2),
219 LE(playlist_created, 2, 2),
220 LE(playlist_deleted, 1, 1),
221 LE(playlist_modified, 2, 2),
222 LE(queue, 2, INT_MAX),
223 LE(recent_added, 2, INT_MAX),
224 LE(recent_removed, 1, 1),
227 LE(rights_changed, 1, 1),
231 LE(user_confirm, 1, 1),
232 LE(user_delete, 1, 1),
237 /* Setup and teardown ********************************************************/
239 /** @brief Create a new client
241 * Does NOT connect the client - connections are made (and re-made) on demand.
243 disorder_eclient *disorder_eclient_new(const disorder_eclient_callbacks *cb,
245 disorder_eclient *c = xmalloc(sizeof *c);
246 D(("disorder_eclient_new"));
250 c->opstail = &c->ops;
252 vector_init(&c->vec);
253 dynstr_init(&c->input);
254 dynstr_init(&c->output);
258 /** @brief Disconnect a client
259 * @param c Client to disconnect
261 * NB that this routine just disconnnects the TCP connection. It does not
262 * destroy the client! If you continue to use it then it will attempt to
265 void disorder_eclient_close(disorder_eclient *c) {
266 struct operation *op;
268 D(("disorder_eclient_close"));
270 D(("disorder_eclient_close closing fd %d", c->fd));
271 c->callbacks->poll(c->u, c, c->fd, 0);
274 c->state = state_disconnected;
280 c->authenticated = 0;
281 /* We'll need to resend all operations */
282 for(op = c->ops; op; op = op->next)
284 /* Drop our use a hint that we're disconnected */
285 if(c->log_callbacks && c->log_callbacks->state)
286 c->log_callbacks->state(c->log_v, c->statebits);
289 /** @brief Permit new connection activity */
290 void disorder_eclient_enable_connect(disorder_eclient *c) {
294 /** @brief Suppress new connection activity */
295 void disorder_eclient_disable_connect(disorder_eclient *c) {
299 /** @brief Return current state */
300 unsigned long disorder_eclient_state(const disorder_eclient *c) {
301 return c->statebits | (c->state > state_connected ? DISORDER_CONNECTED : 0);
304 /* Error reporting ***********************************************************/
306 /** @brief called when a connection error occurs
308 * After this called we will be disconnected (by disorder_eclient_close()),
309 * so there will be a reconnection before any commands can be sent.
311 static int comms_error(disorder_eclient *c, const char *fmt, ...) {
317 byte_xvasprintf(&s, fmt, ap);
319 disorder_eclient_close(c);
320 c->callbacks->comms_error(c->u, s);
324 /** @brief called when the server reports an error */
325 static int protocol_error(disorder_eclient *c, struct operation *op,
326 int code, const char *fmt, ...) {
330 D(("protocol_error"));
332 byte_xvasprintf(&s, fmt, ap);
334 c->callbacks->protocol_error(c->u, op->v, code, s);
338 /* State machine *************************************************************/
340 /** @brief Send an operation (into the output buffer)
341 * @param op Operation to send
343 static void op_send(struct operation *op) {
344 disorder_eclient *const c = op->client;
345 put(c, op->cmd, strlen(op->cmd));
347 for(int n = 0; op->body[n]; ++n) {
348 if(op->body[n][0] == '.')
350 put(c, op->body[n], strlen(op->body[n]));
358 /** @brief Called when there's something to do
360 * @param mode bitmap of @ref DISORDER_POLL_READ and/or @ref DISORDER_POLL_WRITE.
362 * This should be called from by your code when the file descriptor is readable
363 * or writable (as requested by the @c poll callback, see @ref
364 * disorder_eclient_callbacks) and in any case from time to time (with @p mode
365 * = 0) to allow for retries to work.
367 void disorder_eclient_polled(disorder_eclient *c, unsigned mode) {
368 struct operation *op;
371 D(("disorder_eclient_polled fd=%d state=%s mode=[%s %s]",
372 c->fd, states[c->state],
373 mode & DISORDER_POLL_READ ? "READ" : "",
374 mode & DISORDER_POLL_WRITE ? "WRITE" : ""));
375 /* The pattern here is to check each possible state in turn and try to
376 * advance (though on error we might go back). If we advance we leave open
377 * the possibility of falling through to the next state, but we set the mode
378 * bits to 0, to avoid false positives (which matter more in some cases than
381 if(c->state == state_disconnected) {
382 D(("state_disconnected"));
383 /* If there is no password yet then we cannot connect */
384 if(!config->password) {
385 comms_error(c, "no password is configured");
389 /* Only try to connect if enabled */
392 /* might now be state_disconnected (on error), state_connecting (slow
393 * connect) or state_connected (fast connect). If state_disconnected then
394 * we just rely on a periodic callback from the event loop sometime. */
398 if(c->state == state_connecting && mode) {
399 D(("state_connecting"));
401 /* Might be state_disconnected (on error) or state_connected (on success).
402 * In the former case we rely on the event loop for a periodic callback to
407 if(c->state == state_connected) {
408 D(("state_connected"));
409 /* We just connected. Initiate the authentication protocol. */
410 stash_command(c, 1/*queuejump*/, authbanner_opcallback,
411 0/*completed*/, 0/*v*/, -1/*nbody*/, 0/*body*/, 0/*cmd*/);
412 /* We never stay is state_connected very long. We could in principle jump
413 * straight to state_cmdresponse since there's actually no command to
414 * send, but that would arguably be cheating. */
415 c->state = state_idle;
418 if(c->state == state_idle) {
420 /* We are connected, and have finished any command we set off, look for
424 if(c->authenticated) {
425 /* Transmit all unsent operations */
426 for(op = c->ops; op; op = op->next) {
431 /* Just send the head operation */
432 if(c->ops->cmd && !c->ops->sent)
435 /* Awaiting response for the operation at the head of the list */
436 c->state = state_cmdresponse;
439 c->callbacks->report(c->u, 0);
442 /* Queue up a byte to send */
443 if(c->state == state_log
444 && c->output.nvec == 0
445 && xtime(&now) - c->last_prod > LOG_PROD_INTERVAL) {
450 if(c->state == state_cmdresponse
451 || c->state == state_body
452 || c->state == state_log) {
453 D(("state_%s", states[c->state]));
454 /* We are awaiting a response */
455 if(mode & DISORDER_POLL_WRITE) send_output(c);
456 if(mode & DISORDER_POLL_READ) read_input(c);
457 /* There are a couple of reasons we might want to re-enter the state
458 * machine from the top. state_idle is obvious: there may be further
459 * commands to process. Re-entering on state_disconnected means that we
460 * immediately retry connection if a comms error occurs during a command.
461 * This is different to the case where a connection fails, where we await a
462 * spontaneous call to initiate the retry. */
464 case state_disconnected: /* lost connection */
465 case state_idle: /* completed a command */
467 disorder_eclient_polled(c, 0);
474 /* Figure out what to set the mode to */
476 case state_disconnected:
477 D(("state_disconnected (2)"));
478 /* Probably an error occurred. Await a retry. */
481 case state_connecting:
482 D(("state_connecting (2)"));
483 /* Waiting for connect to complete */
484 mode = DISORDER_POLL_READ|DISORDER_POLL_WRITE;
486 case state_connected:
487 D(("state_connected (2)"));
488 assert(!"should never be in state_connected here");
491 D(("state_idle (2)"));
492 /* Connected but nothing to do. */
495 case state_cmdresponse:
498 D(("state_%s (2)", states[c->state]));
499 /* Gathering a response. Wait for input. */
500 mode = DISORDER_POLL_READ;
501 /* Flush any pending output. */
502 if(c->output.nvec) mode |= DISORDER_POLL_WRITE;
505 D(("fd=%d new mode [%s %s]",
507 mode & DISORDER_POLL_READ ? "READ" : "",
508 mode & DISORDER_POLL_WRITE ? "WRITE" : ""));
509 if(c->fd != -1) c->callbacks->poll(c->u, c, c->fd, mode);
512 /** @brief Called to start connecting */
513 static int start_connect(disorder_eclient *c) {
517 D(("start_connect"));
518 if((len = find_server(config, &sa, &c->ident)) == (socklen_t)-1)
519 return comms_error(c, "cannot look up server"); /* TODO better error */
524 if((c->fd = socket(sa->sa_family, SOCK_STREAM, 0)) < 0)
525 return comms_error(c, "socket: %s", strerror(errno));
529 if(connect(c->fd, sa, len) < 0) {
533 c->state = state_connecting;
534 /* We are called from _polled so the state machine will get to do its
538 /* Signal the error to the caller. */
539 return comms_error(c, "connecting to %s: %s", c->ident, strerror(errno));
542 c->state = state_connected;
546 /** @brief Called when poll triggers while waiting for a connection */
547 static void maybe_connected(disorder_eclient *c) {
548 /* We either connected, or got an error. */
550 socklen_t len = sizeof err;
552 D(("maybe_connected"));
553 /* Work around over-enthusiastic error slippage */
554 if(getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
557 /* The connection failed */
558 comms_error(c, "connecting to %s: %s", c->ident, strerror(err));
559 /* sets state_disconnected */
563 /* The connection succeeded */
564 c->state = state_connected;
565 byte_xasprintf(&r, "connected to %s", c->ident);
566 c->callbacks->report(c->u, r);
567 /* If this is a log client we expect to get a bunch of updates from the
568 * server straight away */
572 /* Authentication ************************************************************/
574 /** @brief Called with the greeting from the server */
575 static void authbanner_opcallback(disorder_eclient *c,
576 struct operation *op) {
578 const unsigned char *nonce;
582 const char *protocol, *algorithm, *challenge;
584 D(("authbanner_opcallback"));
586 || !(rvec = split(c->line + 4, &nrvec, SPLIT_QUOTES, 0, 0))
588 /* Banner told us to go away, or was malformed. We cannot proceed. */
589 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
590 disorder_eclient_close(c);
610 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
611 disorder_eclient_close(c);
614 c->protocol = atoi(protocol);
615 if(c->protocol < 1 || c->protocol > 2) {
616 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
617 disorder_eclient_close(c);
620 nonce = unhex(challenge, &nonce_len);
621 res = authhash(nonce, nonce_len, config->password, algorithm);
623 protocol_error(c, op, c->rc, "%s: unknown authentication algorithm '%s'",
624 c->ident, algorithm);
625 disorder_eclient_close(c);
628 stash_command(c, 1/*queuejump*/, authuser_opcallback, 0/*completed*/, 0/*v*/,
629 -1/*nbody*/, 0/*body*/,
630 "user", quoteutf8(config->username), quoteutf8(res),
634 /** @brief Called with the response to the @c user command */
635 static void authuser_opcallback(disorder_eclient *c,
636 struct operation *op) {
639 D(("authuser_opcallback"));
640 if(c->rc / 100 != 2) {
641 /* Wrong password or something. We cannot proceed. */
642 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
644 disorder_eclient_close(c);
647 /* OK, we're authenticated now. */
648 c->authenticated = 1;
649 byte_xasprintf(&r, "authenticated with %s", c->ident);
650 c->callbacks->report(c->u, r);
651 if(c->log_callbacks && !(c->ops && c->ops->opcallback == log_opcallback))
652 /* We are a log client, switch to logging mode */
653 stash_command(c, 0/*queuejump*/, log_opcallback, 0/*completed*/, c->log_v,
654 -1/*nbody*/, 0/*body*/,
658 /* Output ********************************************************************/
660 /* Chop N bytes off the front of a dynstr */
661 static void consume(struct dynstr *d, int n) {
662 D(("consume %d", n));
663 assert(d->nvec >= n);
664 memmove(d->vec, d->vec + n, d->nvec - n);
668 /* Write some bytes */
669 static void put(disorder_eclient *c, const char *s, size_t n) {
670 D(("put %d %.*s", c->fd, (int)n, s));
671 dynstr_append_bytes(&c->output, s, n);
674 /* Called when we can write to our FD, or at any other time */
675 static void send_output(disorder_eclient *c) {
678 D(("send_output %d bytes pending", c->output.nvec));
679 if(c->state > state_connecting && c->output.nvec) {
680 n = write(c->fd, c->output.vec, c->output.nvec);
687 comms_error(c, "writing to %s: %s", c->ident, strerror(errno));
691 consume(&c->output, n);
695 /* Input *********************************************************************/
697 /* Called when c->fd might be readable, or at any other time */
698 static void read_input(disorder_eclient *c) {
703 D(("read_input in state %s", states[c->state]));
704 if(c->state <= state_connected) return; /* ignore bogus calls */
705 /* read some more input */
706 n = read(c->fd, buffer, sizeof buffer);
713 comms_error(c, "reading from %s: %s", c->ident, strerror(errno));
716 return; /* no new input to process */
718 D(("read %d bytes: [%.*s]", n, n, buffer));
719 dynstr_append_bytes(&c->input, buffer, n);
722 /* might have more than one line to process */
723 while(c->state > state_connecting
724 && (nl = memchr(c->input.vec, '\n', c->input.nvec))) {
725 process_line(c, xstrndup(c->input.vec, nl - c->input.vec));
726 /* we might have disconnected along the way, which zogs the input buffer */
727 if(c->state > state_connecting)
728 consume(&c->input, (nl - c->input.vec) + 1);
731 comms_error(c, "reading from %s: server disconnected", c->ident);
732 c->authenticated = 0;
736 /* called with a line that has just been read */
737 static void process_line(disorder_eclient *c, char *line) {
738 D(("process_line %d [%s]", c->fd, line));
740 case state_cmdresponse:
741 /* This is the first line of a response */
742 if(!(line[0] >= '0' && line[0] <= '9'
743 && line[1] >= '0' && line[1] <= '9'
744 && line[2] >= '0' && line[2] <= '9'
746 disorder_fatal(0, "invalid response from server: %s", line);
747 c->rc = (line[0] * 10 + line[1]) * 10 + line[2] - 111 * '0';
751 /* We need to collect the body. */
752 c->state = state_body;
753 vector_init(&c->vec);
756 assert(c->log_callbacks != 0);
757 if(c->log_callbacks->connected)
758 c->log_callbacks->connected(c->log_v);
759 c->state = state_log;
762 /* We've got the whole response. Go into the idle state so the state
763 * machine knows we're done and then call the operation callback. */
769 if(strcmp(line, ".")) {
770 /* A line from the body */
771 vector_append(&c->vec, line + (line[0] == '.'));
773 /* End of the body. */
774 vector_terminate(&c->vec);
779 if(strcmp(line, ".")) {
780 logline(c, line + (line[0] == '.'));
785 assert(!"wrong state for location");
790 /* Called when an operation completes */
791 static void complete(disorder_eclient *c) {
792 struct operation *op;
795 /* Pop the operation off the queue */
798 if(c->opstail == &op->next)
799 c->opstail = &c->ops;
800 /* If we've pipelined a command ahead then we go straight to cmdresponser.
801 * Otherwise we go to idle, which will arrange further sends. */
802 c->state = c->ops && c->ops->sent ? state_cmdresponse : state_idle;
803 op->opcallback(c, op);
804 /* Note that we always call the opcallback even on error, though command
805 * opcallbacks generally always do the same error handling, i.e. just call
806 * protocol_error(). It's the auth* opcallbacks that have different
810 /* Operation setup ***********************************************************/
812 static void stash_command_vector(disorder_eclient *c,
814 operation_callback *opcallback,
821 struct operation *op = xmalloc(sizeof *op);
827 for(n = 0; n < ncmd; ++n) {
829 dynstr_append(&d, ' ');
830 dynstr_append_string(&d, quoteutf8(cmd[n]));
832 dynstr_append(&d, '\n');
833 dynstr_terminate(&d);
836 op->cmd = 0; /* usually, awaiting challenge */
838 op->body = xcalloc(nbody + 1, sizeof (char *));
839 for(n = 0; n < nbody; ++n)
840 op->body[n] = xstrdup(body[n]);
844 op->opcallback = opcallback;
845 op->completed = completed;
849 assert(op->sent == 0);
851 /* Authentication operations jump the queue of useful commands */
854 if(c->opstail == &c->ops)
855 c->opstail = &op->next;
856 for(op = c->ops; op; op = op->next)
860 c->opstail = &op->next;
864 static void vstash_command(disorder_eclient *c,
866 operation_callback *opcallback,
871 const char *cmd, va_list ap) {
875 D(("vstash_command %s", cmd ? cmd : "NULL"));
878 vector_append(&vec, (char *)cmd);
879 while((arg = va_arg(ap, char *)))
880 vector_append(&vec, arg);
881 stash_command_vector(c, queuejump, opcallback, completed, v,
882 nbody, body, vec.nvec, vec.vec);
884 stash_command_vector(c, queuejump, opcallback, completed, v,
889 static void stash_command(disorder_eclient *c,
891 operation_callback *opcallback,
901 vstash_command(c, queuejump, opcallback, completed, v, nbody, body, cmd, ap);
905 /* Command support ***********************************************************/
907 static const char *errorstring(disorder_eclient *c) {
910 byte_xasprintf(&s, "%s: %s: %d", c->ident, c->line, c->rc);
914 /* for commands with a quoted string response */
915 static void string_response_opcallback(disorder_eclient *c,
916 struct operation *op) {
917 disorder_eclient_string_response *completed
918 = (disorder_eclient_string_response *)op->completed;
920 D(("string_response_callback"));
922 if(c->rc / 100 == 2 || c->rc == 555) {
924 completed(op->v, NULL, NULL);
925 else if(c->protocol >= 2) {
926 char **rr = split(c->line + 4, 0, SPLIT_QUOTES, 0, 0);
929 completed(op->v, NULL, *rr);
931 /* TODO error message a is bit lame but generally indicates a server
932 * bug rather than anything the user can address */
933 completed(op->v, "error parsing response", NULL);
935 completed(op->v, NULL, c->line + 4);
937 completed(op->v, errorstring(c), NULL);
941 /* for commands with a simple integer response */
942 static void integer_response_opcallback(disorder_eclient *c,
943 struct operation *op) {
944 disorder_eclient_integer_response *completed
945 = (disorder_eclient_integer_response *)op->completed;
947 D(("string_response_callback"));
948 if(c->rc / 100 == 2) {
952 e = xstrtol(&n, c->line + 4, 0, 10);
954 completed(op->v, strerror(e), 0);
956 completed(op->v, 0, n);
958 completed(op->v, errorstring(c), 0);
961 /* for commands with no response */
962 static void no_response_opcallback(disorder_eclient *c,
963 struct operation *op) {
964 disorder_eclient_no_response *completed
965 = (disorder_eclient_no_response *)op->completed;
967 D(("no_response_callback"));
970 completed(op->v, NULL);
972 completed(op->v, errorstring(c));
976 /* error callback for queue_unmarshall */
977 static void eclient_queue_error(const char *msg,
979 struct operation *op = u;
981 /* TODO don't use protocol_error here */
982 protocol_error(op->client, op, -1, "error parsing queue entry: %s", msg);
985 /* for commands that expect a queue dump */
986 static void queue_response_opcallback(disorder_eclient *c,
987 struct operation *op) {
988 disorder_eclient_queue_response *const completed
989 = (disorder_eclient_queue_response *)op->completed;
991 int parse_failed = 0;
992 struct queue_entry *q, *qh = 0, **qtail = &qh, *qlast = 0;
994 D(("queue_response_callback"));
995 if(c->rc / 100 == 2) {
996 /* parse the queue */
997 for(n = 0; n < c->vec.nvec; ++n) {
998 q = xmalloc(sizeof *q);
999 D(("queue_unmarshall %s", c->vec.vec[n]));
1000 if(!queue_unmarshall(q, c->vec.vec[n], NULL, op)) {
1008 /* Currently we pass the partial queue to the callback along with the
1009 * error. This might not be very useful in practice... */
1011 completed(op->v, "cannot parse result", qh);
1013 completed(op->v, 0, qh);
1015 completed(op->v, errorstring(c), 0);
1019 static void playing_response_opcallback(disorder_eclient *c,
1020 struct operation *op) {
1021 disorder_eclient_queue_response *const completed
1022 = (disorder_eclient_queue_response *)op->completed;
1023 struct queue_entry *q;
1025 D(("playing_response_callback"));
1026 if(c->rc / 100 == 2) {
1027 switch(c->rc % 10) {
1029 if(queue_unmarshall(q = xmalloc(sizeof *q), c->line + 4,
1031 completed(op->v, "cannot parse result", 0);
1033 completed(op->v, 0, q);
1036 completed(op->v, 0, 0);
1039 completed(op->v, errorstring(c), 0);
1043 completed(op->v, errorstring(c), 0);
1046 /* for commands that expect a list of some sort */
1047 static void list_response_opcallback(disorder_eclient *c,
1048 struct operation *op) {
1049 disorder_eclient_list_response *const completed =
1050 (disorder_eclient_list_response *)op->completed;
1052 D(("list_response_callback"));
1053 if(c->rc / 100 == 2)
1054 completed(op->v, NULL, c->vec.nvec, c->vec.vec);
1055 else if(c->rc == 555)
1056 completed(op->v, NULL, -1, NULL);
1058 completed(op->v, errorstring(c), 0, 0);
1062 static void volume_response_opcallback(disorder_eclient *c,
1063 struct operation *op) {
1064 disorder_eclient_volume_response *completed
1065 = (disorder_eclient_volume_response *)op->completed;
1068 D(("volume_response_callback"));
1069 if(c->rc / 100 == 2) {
1071 if(sscanf(c->line + 4, "%d %d", &l, &r) != 2 || l < 0 || r < 0)
1072 completed(op->v, "cannot parse volume response", 0, 0);
1074 completed(op->v, 0, l, r);
1077 completed(op->v, errorstring(c), 0, 0);
1080 static int simple(disorder_eclient *c,
1081 operation_callback *opcallback,
1082 void (*completed)(),
1084 const char *cmd, ...) {
1088 vstash_command(c, 0/*queuejump*/, opcallback, completed, v, -1, 0, cmd, ap);
1090 /* Give the state machine a kick, since we might be in state_idle */
1091 disorder_eclient_polled(c, 0);
1095 static int simple_body(disorder_eclient *c,
1096 operation_callback *opcallback,
1097 void (*completed)(),
1101 const char *cmd, ...) {
1105 vstash_command(c, 0/*queuejump*/, opcallback, completed, v, nbody, body, cmd, ap);
1107 /* Give the state machine a kick, since we might be in state_idle */
1108 disorder_eclient_polled(c, 0);
1112 /* Commands ******************************************************************/
1114 int disorder_eclient_version(disorder_eclient *c,
1115 disorder_eclient_string_response *completed,
1117 return simple(c, string_response_opcallback, (void (*)())completed, v,
1118 "version", (char *)0);
1121 int disorder_eclient_namepart(disorder_eclient *c,
1122 disorder_eclient_string_response *completed,
1124 const char *context,
1127 return simple(c, string_response_opcallback, (void (*)())completed, v,
1128 "part", track, context, part, (char *)0);
1131 int disorder_eclient_play(disorder_eclient *c,
1133 disorder_eclient_no_response *completed,
1135 return simple(c, no_response_opcallback, (void (*)())completed, v,
1136 "play", track, (char *)0);
1139 int disorder_eclient_playafter(disorder_eclient *c,
1142 const char **tracks,
1143 disorder_eclient_no_response *completed,
1151 vector_append(&vec, (char *)"playafter");
1152 vector_append(&vec, (char *)target);
1153 for(n = 0; n < ntracks; ++n)
1154 vector_append(&vec, (char *)tracks[n]);
1155 stash_command_vector(c, 0/*queuejump*/, no_response_opcallback, completed, v,
1156 -1, 0, vec.nvec, vec.vec);
1157 disorder_eclient_polled(c, 0);
1161 int disorder_eclient_pause(disorder_eclient *c,
1162 disorder_eclient_no_response *completed,
1164 return simple(c, no_response_opcallback, (void (*)())completed, v,
1165 "pause", (char *)0);
1168 int disorder_eclient_resume(disorder_eclient *c,
1169 disorder_eclient_no_response *completed,
1171 return simple(c, no_response_opcallback, (void (*)())completed, v,
1172 "resume", (char *)0);
1175 int disorder_eclient_scratch(disorder_eclient *c,
1177 disorder_eclient_no_response *completed,
1179 return simple(c, no_response_opcallback, (void (*)())completed, v,
1180 "scratch", id, (char *)0);
1183 int disorder_eclient_scratch_playing(disorder_eclient *c,
1184 disorder_eclient_no_response *completed,
1186 return disorder_eclient_scratch(c, 0, completed, v);
1189 int disorder_eclient_remove(disorder_eclient *c,
1191 disorder_eclient_no_response *completed,
1193 return simple(c, no_response_opcallback, (void (*)())completed, v,
1194 "remove", id, (char *)0);
1197 int disorder_eclient_moveafter(disorder_eclient *c,
1201 disorder_eclient_no_response *completed,
1207 vector_append(&vec, (char *)"moveafter");
1208 vector_append(&vec, (char *)target);
1209 for(n = 0; n < nids; ++n)
1210 vector_append(&vec, (char *)ids[n]);
1211 stash_command_vector(c, 0/*queuejump*/, no_response_opcallback, completed, v,
1212 -1, 0, vec.nvec, vec.vec);
1213 disorder_eclient_polled(c, 0);
1217 int disorder_eclient_recent(disorder_eclient *c,
1218 disorder_eclient_queue_response *completed,
1220 return simple(c, queue_response_opcallback, (void (*)())completed, v,
1221 "recent", (char *)0);
1224 int disorder_eclient_queue(disorder_eclient *c,
1225 disorder_eclient_queue_response *completed,
1227 return simple(c, queue_response_opcallback, (void (*)())completed, v,
1228 "queue", (char *)0);
1231 int disorder_eclient_files(disorder_eclient *c,
1232 disorder_eclient_list_response *completed,
1236 return simple(c, list_response_opcallback, (void (*)())completed, v,
1237 "files", dir, re, (char *)0);
1240 int disorder_eclient_dirs(disorder_eclient *c,
1241 disorder_eclient_list_response *completed,
1245 return simple(c, list_response_opcallback, (void (*)())completed, v,
1246 "dirs", dir, re, (char *)0);
1249 int disorder_eclient_playing(disorder_eclient *c,
1250 disorder_eclient_queue_response *completed,
1252 return simple(c, playing_response_opcallback, (void (*)())completed, v,
1253 "playing", (char *)0);
1256 int disorder_eclient_length(disorder_eclient *c,
1257 disorder_eclient_integer_response *completed,
1260 return simple(c, integer_response_opcallback, (void (*)())completed, v,
1261 "length", track, (char *)0);
1264 int disorder_eclient_volume(disorder_eclient *c,
1265 disorder_eclient_volume_response *completed,
1268 char sl[64], sr[64];
1270 if(l < 0 && r < 0) {
1271 return simple(c, volume_response_opcallback, (void (*)())completed, v,
1272 "volume", (char *)0);
1273 } else if(l >= 0 && r >= 0) {
1276 byte_snprintf(sl, sizeof sl, "%d", l);
1277 byte_snprintf(sr, sizeof sr, "%d", r);
1278 return simple(c, volume_response_opcallback, (void (*)())completed, v,
1279 "volume", sl, sr, (char *)0);
1281 assert(!"invalid arguments to disorder_eclient_volume");
1282 return -1; /* gcc is being dim */
1286 int disorder_eclient_enable(disorder_eclient *c,
1287 disorder_eclient_no_response *completed,
1289 return simple(c, no_response_opcallback, (void (*)())completed, v,
1290 "enable", (char *)0);
1293 int disorder_eclient_disable(disorder_eclient *c,
1294 disorder_eclient_no_response *completed,
1296 return simple(c, no_response_opcallback, (void (*)())completed, v,
1297 "disable", (char *)0);
1300 int disorder_eclient_random_enable(disorder_eclient *c,
1301 disorder_eclient_no_response *completed,
1303 return simple(c, no_response_opcallback, (void (*)())completed, v,
1304 "random-enable", (char *)0);
1307 int disorder_eclient_random_disable(disorder_eclient *c,
1308 disorder_eclient_no_response *completed,
1310 return simple(c, no_response_opcallback, (void (*)())completed, v,
1311 "random-disable", (char *)0);
1314 int disorder_eclient_get(disorder_eclient *c,
1315 disorder_eclient_string_response *completed,
1316 const char *track, const char *pref,
1318 return simple(c, string_response_opcallback, (void (*)())completed, v,
1319 "get", track, pref, (char *)0);
1322 int disorder_eclient_set(disorder_eclient *c,
1323 disorder_eclient_no_response *completed,
1324 const char *track, const char *pref,
1327 return simple(c, no_response_opcallback, (void (*)())completed, v,
1328 "set", track, pref, value, (char *)0);
1331 int disorder_eclient_unset(disorder_eclient *c,
1332 disorder_eclient_no_response *completed,
1333 const char *track, const char *pref,
1335 return simple(c, no_response_opcallback, (void (*)())completed, v,
1336 "unset", track, pref, (char *)0);
1339 int disorder_eclient_resolve(disorder_eclient *c,
1340 disorder_eclient_string_response *completed,
1343 return simple(c, string_response_opcallback, (void (*)())completed, v,
1344 "resolve", track, (char *)0);
1347 int disorder_eclient_search(disorder_eclient *c,
1348 disorder_eclient_list_response *completed,
1351 if(!split(terms, 0, SPLIT_QUOTES, 0, 0)) return -1;
1352 return simple(c, list_response_opcallback, (void (*)())completed, v,
1353 "search", terms, (char *)0);
1356 int disorder_eclient_nop(disorder_eclient *c,
1357 disorder_eclient_no_response *completed,
1359 return simple(c, no_response_opcallback, (void (*)())completed, v,
1363 int disorder_eclient_get_global(disorder_eclient *c,
1364 disorder_eclient_string_response *completed,
1367 return simple(c, string_response_opcallback, (void (*)())completed, v,
1368 "get-global", pref, (char *)0);
1371 int disorder_eclient_set_global(disorder_eclient *c,
1372 disorder_eclient_no_response *completed,
1376 return simple(c, no_response_opcallback, (void (*)())completed, v,
1377 "set-global", pref, value, (char *)0);
1380 int disorder_eclient_unset_global(disorder_eclient *c,
1381 disorder_eclient_no_response *completed,
1384 return simple(c, no_response_opcallback, (void (*)())completed, v,
1385 "unset-global", pref, (char *)0);
1388 /** @brief Get the last @p max added tracks
1390 * @param completed Called with list
1391 * @param max Number of tracks to get, 0 for all
1392 * @param v Passed to @p completed
1394 * The first track in the list is the most recently added.
1396 int disorder_eclient_new_tracks(disorder_eclient *c,
1397 disorder_eclient_list_response *completed,
1402 sprintf(limit, "%d", max);
1403 return simple(c, list_response_opcallback, (void (*)())completed, v,
1404 "new", limit, (char *)0);
1407 static void rtp_response_opcallback(disorder_eclient *c,
1408 struct operation *op) {
1409 disorder_eclient_list_response *const completed =
1410 (disorder_eclient_list_response *)op->completed;
1411 D(("rtp_response_opcallback"));
1412 if(c->rc / 100 == 2) {
1414 char **vec = split(c->line + 4, &nvec, SPLIT_QUOTES, 0, 0);
1417 completed(op->v, NULL, nvec, vec);
1419 completed(op->v, "error parsing response", 0, 0);
1421 completed(op->v, errorstring(c), 0, 0);
1424 /** @brief Determine the RTP target address
1426 * @param completed Called with address details
1427 * @param v Passed to @p completed
1429 * The address details will be two elements, the first being the hostname and
1430 * the second the service (port).
1432 int disorder_eclient_rtp_address(disorder_eclient *c,
1433 disorder_eclient_list_response *completed,
1435 return simple(c, rtp_response_opcallback, (void (*)())completed, v,
1436 "rtp-address", (char *)0);
1439 /** @brief Get the list of users
1441 * @param completed Called with list of users
1442 * @param v Passed to @p completed
1444 * The user list is not sorted in any particular order.
1446 int disorder_eclient_users(disorder_eclient *c,
1447 disorder_eclient_list_response *completed,
1449 return simple(c, list_response_opcallback, (void (*)())completed, v,
1450 "users", (char *)0);
1453 /** @brief Delete a user
1455 * @param completed Called on completion
1456 * @param user User to delete
1457 * @param v Passed to @p completed
1459 int disorder_eclient_deluser(disorder_eclient *c,
1460 disorder_eclient_no_response *completed,
1463 return simple(c, no_response_opcallback, (void (*)())completed, v,
1464 "deluser", user, (char *)0);
1467 /** @brief Get a user property
1469 * @param completed Called on completion
1470 * @param user User to look up
1471 * @param property Property to look up
1472 * @param v Passed to @p completed
1474 int disorder_eclient_userinfo(disorder_eclient *c,
1475 disorder_eclient_string_response *completed,
1477 const char *property,
1479 return simple(c, string_response_opcallback, (void (*)())completed, v,
1480 "userinfo", user, property, (char *)0);
1483 /** @brief Modify a user property
1485 * @param completed Called on completion
1486 * @param user User to modify
1487 * @param property Property to modify
1488 * @param value New property value
1489 * @param v Passed to @p completed
1491 int disorder_eclient_edituser(disorder_eclient *c,
1492 disorder_eclient_no_response *completed,
1494 const char *property,
1497 return simple(c, no_response_opcallback, (void (*)())completed, v,
1498 "edituser", user, property, value, (char *)0);
1501 /** @brief Create a new user
1503 * @param completed Called on completion
1504 * @param user User to create
1505 * @param password Initial password
1506 * @param rights Initial rights or NULL
1507 * @param v Passed to @p completed
1509 int disorder_eclient_adduser(disorder_eclient *c,
1510 disorder_eclient_no_response *completed,
1512 const char *password,
1515 return simple(c, no_response_opcallback, (void (*)())completed, v,
1516 "adduser", user, password, rights, (char *)0);
1519 /** @brief Adopt a track
1521 * @param completed Called on completion
1522 * @param id Track ID
1523 * @param v Passed to @p completed
1525 int disorder_eclient_adopt(disorder_eclient *c,
1526 disorder_eclient_no_response *completed,
1529 return simple(c, no_response_opcallback, (void (*)())completed, v,
1530 "adopt", id, (char *)0);
1533 /** @brief Get the list of playlists
1535 * @param completed Called with list of playlists
1536 * @param v Passed to @p completed
1538 * The playlist list is not sorted in any particular order.
1540 int disorder_eclient_playlists(disorder_eclient *c,
1541 disorder_eclient_list_response *completed,
1543 return simple(c, list_response_opcallback, (void (*)())completed, v,
1544 "playlists", (char *)0);
1547 /** @brief Delete a playlist
1549 * @param completed Called on completion
1550 * @param playlist Playlist to delete
1551 * @param v Passed to @p completed
1553 int disorder_eclient_playlist_delete(disorder_eclient *c,
1554 disorder_eclient_no_response *completed,
1555 const char *playlist,
1557 return simple(c, no_response_opcallback, (void (*)())completed, v,
1558 "playlist-delete", playlist, (char *)0);
1561 /** @brief Lock a playlist
1563 * @param completed Called on completion
1564 * @param playlist Playlist to lock
1565 * @param v Passed to @p completed
1567 int disorder_eclient_playlist_lock(disorder_eclient *c,
1568 disorder_eclient_no_response *completed,
1569 const char *playlist,
1571 return simple(c, no_response_opcallback, (void (*)())completed, v,
1572 "playlist-lock", playlist, (char *)0);
1575 /** @brief Unlock the locked a playlist
1577 * @param completed Called on completion
1578 * @param v Passed to @p completed
1580 int disorder_eclient_playlist_unlock(disorder_eclient *c,
1581 disorder_eclient_no_response *completed,
1583 return simple(c, no_response_opcallback, (void (*)())completed, v,
1584 "playlist-unlock", (char *)0);
1587 /** @brief Set a playlist's sharing
1589 * @param completed Called on completion
1590 * @param playlist Playlist to modify
1591 * @param sharing @c "public" or @c "private"
1592 * @param v Passed to @p completed
1594 int disorder_eclient_playlist_set_share(disorder_eclient *c,
1595 disorder_eclient_no_response *completed,
1596 const char *playlist,
1597 const char *sharing,
1599 return simple(c, no_response_opcallback, (void (*)())completed, v,
1600 "playlist-set-share", playlist, sharing, (char *)0);
1603 /** @brief Get a playlist's sharing
1605 * @param completed Called with sharing status
1606 * @param playlist Playlist to inspect
1607 * @param v Passed to @p completed
1609 int disorder_eclient_playlist_get_share(disorder_eclient *c,
1610 disorder_eclient_string_response *completed,
1611 const char *playlist,
1613 return simple(c, string_response_opcallback, (void (*)())completed, v,
1614 "playlist-get-share", playlist, (char *)0);
1617 /** @brief Set a playlist
1619 * @param completed Called on completion
1620 * @param playlist Playlist to modify
1621 * @param tracks List of tracks
1622 * @param ntracks Number of tracks
1623 * @param v Passed to @p completed
1625 int disorder_eclient_playlist_set(disorder_eclient *c,
1626 disorder_eclient_no_response *completed,
1627 const char *playlist,
1631 return simple_body(c, no_response_opcallback, (void (*)())completed, v,
1633 "playlist-set", playlist, (char *)0);
1636 /** @brief Get a playlist's contents
1638 * @param completed Called with playlist contents
1639 * @param playlist Playlist to inspect
1640 * @param v Passed to @p completed
1642 int disorder_eclient_playlist_get(disorder_eclient *c,
1643 disorder_eclient_list_response *completed,
1644 const char *playlist,
1646 return simple(c, list_response_opcallback, (void (*)())completed, v,
1647 "playlist-get", playlist, (char *)0);
1650 /* Log clients ***************************************************************/
1652 /** @brief Monitor the server log
1654 * @param callbacks Functions to call when anything happens
1655 * @param v Passed to @p callbacks functions
1657 * Once a client is being used for logging it cannot be used for anything else.
1658 * There is magic in authuser_opcallback() to re-submit the @c log command
1659 * after reconnection.
1661 * NB that the @c state callback may be called from within this function,
1662 * i.e. not solely later on from the event loop callback.
1664 int disorder_eclient_log(disorder_eclient *c,
1665 const disorder_eclient_log_callbacks *callbacks,
1667 if(c->log_callbacks) return -1;
1668 c->log_callbacks = callbacks;
1670 /* Repoort initial state */
1671 if(c->log_callbacks->state)
1672 c->log_callbacks->state(c->log_v, c->statebits);
1673 stash_command(c, 0/*queuejump*/, log_opcallback, 0/*completed*/, v,
1674 -1, 0, "log", (char *)0);
1675 disorder_eclient_polled(c, 0);
1679 /* If we get here we've stopped being a log client */
1680 static void log_opcallback(disorder_eclient *c,
1681 struct operation attribute((unused)) *op) {
1682 D(("log_opcallback"));
1683 c->log_callbacks = 0;
1687 /* error callback for log line parsing */
1688 static void logline_error(const char *msg, void *u) {
1689 disorder_eclient *c = u;
1690 /* TODO don't use protocol_error here */
1691 protocol_error(c, c->ops, -1, "error parsing log line: %s", msg);
1694 /* process a single log line */
1695 static void logline(disorder_eclient *c, const char *line) {
1700 D(("logline [%s]", line));
1701 vec = split(line, &nvec, SPLIT_QUOTES, logline_error, c);
1702 if(nvec < 2) return; /* probably an error, already
1704 if(sscanf(vec[0], "%"SCNxMAX, &when) != 1) {
1705 /* probably the wrong side of a format change */
1706 /* TODO don't use protocol_error here */
1707 protocol_error(c, c->ops, -1, "invalid log timestamp '%s'", vec[0]);
1710 /* TODO: do something with the time */
1711 //fprintf(stderr, "log key: %s\n", vec[1]);
1712 n = TABLE_FIND(logentry_handlers, name, vec[1]);
1714 //fprintf(stderr, "...not found\n");
1715 return; /* probably a future command */
1719 if(nvec < logentry_handlers[n].min || nvec > logentry_handlers[n].max) {
1720 //fprintf(stderr, "...wrong # args\n");
1723 logentry_handlers[n].handler(c, nvec, vec);
1726 static void logentry_completed(disorder_eclient *c,
1727 int attribute((unused)) nvec, char **vec) {
1728 c->statebits &= ~DISORDER_PLAYING;
1729 if(c->log_callbacks->completed)
1730 c->log_callbacks->completed(c->log_v, vec[0]);
1731 if(c->log_callbacks->state)
1732 c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1735 static void logentry_failed(disorder_eclient *c,
1736 int attribute((unused)) nvec, char **vec) {
1737 c->statebits &= ~DISORDER_PLAYING;
1738 if(c->log_callbacks->failed)
1739 c->log_callbacks->failed(c->log_v, vec[0], vec[1]);
1740 if(c->log_callbacks->state)
1741 c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1744 static void logentry_moved(disorder_eclient *c,
1745 int attribute((unused)) nvec, char **vec) {
1746 if(c->log_callbacks->moved)
1747 c->log_callbacks->moved(c->log_v, vec[0]);
1750 static void logentry_playing(disorder_eclient *c,
1751 int attribute((unused)) nvec, char **vec) {
1752 c->statebits |= DISORDER_PLAYING;
1753 if(c->log_callbacks->playing)
1754 c->log_callbacks->playing(c->log_v, vec[0], vec[1]);
1755 if(c->log_callbacks->state)
1756 c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1759 static void logentry_queue(disorder_eclient *c,
1760 int attribute((unused)) nvec, char **vec) {
1761 struct queue_entry *q;
1763 if(!c->log_callbacks->queue) return;
1764 q = xmalloc(sizeof *q);
1765 if(queue_unmarshall_vec(q, nvec, vec, eclient_queue_error, c))
1767 c->log_callbacks->queue(c->log_v, q);
1770 static void logentry_recent_added(disorder_eclient *c,
1771 int attribute((unused)) nvec, char **vec) {
1772 struct queue_entry *q;
1774 if(!c->log_callbacks->recent_added) return;
1775 q = xmalloc(sizeof *q);
1776 if(queue_unmarshall_vec(q, nvec, vec, eclient_queue_error, c))
1778 c->log_callbacks->recent_added(c->log_v, q);
1781 static void logentry_recent_removed(disorder_eclient *c,
1782 int attribute((unused)) nvec, char **vec) {
1783 if(c->log_callbacks->recent_removed)
1784 c->log_callbacks->recent_removed(c->log_v, vec[0]);
1787 static void logentry_removed(disorder_eclient *c,
1788 int attribute((unused)) nvec, char **vec) {
1789 if(c->log_callbacks->removed)
1790 c->log_callbacks->removed(c->log_v, vec[0], vec[1]);
1793 static void logentry_rescanned(disorder_eclient *c,
1794 int attribute((unused)) nvec,
1795 char attribute((unused)) **vec) {
1796 if(c->log_callbacks->rescanned)
1797 c->log_callbacks->rescanned(c->log_v);
1800 static void logentry_scratched(disorder_eclient *c,
1801 int attribute((unused)) nvec, char **vec) {
1802 c->statebits &= ~DISORDER_PLAYING;
1803 if(c->log_callbacks->scratched)
1804 c->log_callbacks->scratched(c->log_v, vec[0], vec[1]);
1805 if(c->log_callbacks->state)
1806 c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1809 static void logentry_user_add(disorder_eclient *c,
1810 int attribute((unused)) nvec, char **vec) {
1811 if(c->log_callbacks->user_add)
1812 c->log_callbacks->user_add(c->log_v, vec[0]);
1815 static void logentry_user_confirm(disorder_eclient *c,
1816 int attribute((unused)) nvec, char **vec) {
1817 if(c->log_callbacks->user_confirm)
1818 c->log_callbacks->user_confirm(c->log_v, vec[0]);
1821 static void logentry_user_delete(disorder_eclient *c,
1822 int attribute((unused)) nvec, char **vec) {
1823 if(c->log_callbacks->user_delete)
1824 c->log_callbacks->user_delete(c->log_v, vec[0]);
1827 static void logentry_user_edit(disorder_eclient *c,
1828 int attribute((unused)) nvec, char **vec) {
1829 if(c->log_callbacks->user_edit)
1830 c->log_callbacks->user_edit(c->log_v, vec[0], vec[1]);
1833 static void logentry_rights_changed(disorder_eclient *c,
1834 int attribute((unused)) nvec, char **vec) {
1835 if(c->log_callbacks->rights_changed) {
1837 if(!parse_rights(vec[0], &r, 0/*report*/))
1838 c->log_callbacks->rights_changed(c->log_v, r);
1842 static void logentry_playlist_created(disorder_eclient *c,
1843 int attribute((unused)) nvec,
1845 if(c->log_callbacks->playlist_created)
1846 c->log_callbacks->playlist_created(c->log_v, vec[0], vec[1]);
1849 static void logentry_playlist_deleted(disorder_eclient *c,
1850 int attribute((unused)) nvec,
1852 if(c->log_callbacks->playlist_deleted)
1853 c->log_callbacks->playlist_deleted(c->log_v, vec[0]);
1856 static void logentry_playlist_modified(disorder_eclient *c,
1857 int attribute((unused)) nvec,
1859 if(c->log_callbacks->playlist_modified)
1860 c->log_callbacks->playlist_modified(c->log_v, vec[0], vec[1]);
1863 static const struct {
1866 const char *disable;
1867 } statestrings[] = {
1868 { DISORDER_PLAYING_ENABLED, "enable_play", "disable_play" },
1869 { DISORDER_RANDOM_ENABLED, "enable_random", "disable_random" },
1870 { DISORDER_TRACK_PAUSED, "pause", "resume" },
1871 { DISORDER_PLAYING, "playing", "completed" },
1872 { DISORDER_PLAYING, 0, "scratched" },
1873 { DISORDER_PLAYING, 0, "failed" },
1875 #define NSTATES (int)(sizeof statestrings / sizeof *statestrings)
1877 static void logentry_state(disorder_eclient *c,
1878 int attribute((unused)) nvec, char **vec) {
1881 for(n = 0; n < NSTATES; ++n)
1882 if(statestrings[n].enable && !strcmp(vec[0], statestrings[n].enable)) {
1883 c->statebits |= statestrings[n].bit;
1885 } else if(statestrings[n].disable && !strcmp(vec[0], statestrings[n].disable)) {
1886 c->statebits &= ~statestrings[n].bit;
1889 if(c->log_callbacks->state)
1890 c->log_callbacks->state(c->log_v, c->statebits | DISORDER_CONNECTED);
1893 static void logentry_volume(disorder_eclient *c,
1894 int attribute((unused)) nvec, char **vec) {
1897 if(!c->log_callbacks->volume) return;
1898 if(xstrtol(&l, vec[0], 0, 10)
1899 || xstrtol(&r, vec[1], 0, 10)
1900 || l < 0 || l > INT_MAX
1901 || r < 0 || r > INT_MAX)
1903 c->log_callbacks->volume(c->log_v, (int)l, (int)r);
1906 /** @brief Convert @p statebits to a string */
1907 char *disorder_eclient_interpret_state(unsigned long statebits) {
1911 static const struct {
1915 { DISORDER_PLAYING_ENABLED, "playing_enabled" },
1916 { DISORDER_RANDOM_ENABLED, "random_enabled" },
1917 { DISORDER_TRACK_PAUSED, "track_paused" },
1918 { DISORDER_PLAYING, "playing" },
1919 { DISORDER_CONNECTED, "connected" },
1921 #define NBITS (sizeof bits / sizeof *bits)
1925 dynstr_append(d, '0');
1926 for(n = 0; n < NBITS; ++n)
1927 if(statebits & bits[n].bit) {
1929 dynstr_append(d, '|');
1930 dynstr_append_string(d, bits[n].name);
1931 statebits ^= bits[n].bit;
1937 dynstr_append(d, '|');
1938 sprintf(s, "%#lx", statebits);
1939 dynstr_append_string(d, s);
1941 dynstr_terminate(d);
1945 static void logentry_adopted(disorder_eclient *c,
1946 int attribute((unused)) nvec, char **vec) {
1947 if(c->log_callbacks->adopted)
1948 c->log_callbacks->adopted(c->log_v, vec[0], vec[1]);
1951 static void logentry_global_pref(disorder_eclient *c,
1952 int nvec, char **vec) {
1953 if(c->log_callbacks->global_pref)
1954 c->log_callbacks->global_pref(c->log_v, vec[0], nvec > 1 ? vec[1] : 0);
1962 indent-tabs-mode:nil