2 * This file is part of DisOrder.
3 * Copyright (C) 2006 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 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
24 #include <sys/types.h>
25 #include <sys/socket.h>
26 #include <netinet/in.h>
40 #include "configuration.h"
47 #include "inputline.h"
54 #include "client-common.h"
56 /* TODO: more commands */
58 /* Types *********************************************************************/
61 state_disconnected, /* not connected */
62 state_connecting, /* waiting for connect() */
63 state_connected, /* connected but not authenticated */
64 state_idle, /* not doing anything */
65 state_cmdresponse, /* waiting for command resonse */
66 state_body, /* accumulating body */
67 state_log, /* monitoring log */
70 static const char *const states[] = {
80 struct operation; /* forward decl */
82 typedef void operation_callback(disorder_eclient *c, struct operation *op);
84 /* A pending operation. This can be either a command or part of the
85 * authentication protocol. In the former case new commands are appended to
86 * the list, in the latter case they are inserted at the front. */
88 struct operation *next; /* next operation */
89 char *cmd; /* command to send or 0 */
90 operation_callback *opcallback; /* internal completion callback */
91 void (*completed)(); /* user completion callback or 0 */
92 void *v; /* data for COMPLETED */
93 disorder_eclient *client; /* owning client */
94 int sent; /* true if sent to server */
97 struct disorder_eclient {
100 enum client_state state; /* current state */
101 int authenticated; /* true when authenicated */
102 struct dynstr output; /* output buffer */
103 struct dynstr input; /* input buffer */
104 int eof; /* input buffer is at EOF */
105 /* error reporting callbacks */
106 const disorder_eclient_callbacks *callbacks;
108 /* operation queuue */
109 struct operation *ops, **opstail;
110 /* accumulated response */
111 int rc; /* response code */
112 char *line; /* complete line */
113 struct vector vec; /* body */
114 /* log client callback */
115 const disorder_eclient_log_callbacks *log_callbacks;
117 unsigned long statebits; /* current state */
120 /* Forward declarations ******************************************************/
122 static int start_connect(void *cc,
123 const struct sockaddr *sa,
126 static void process_line(disorder_eclient *c, char *line);
127 static int start_connect(void *cc,
128 const struct sockaddr *sa,
131 static void maybe_connected(disorder_eclient *c);
132 static void authbanner_opcallback(disorder_eclient *c,
133 struct operation *op);
134 static void authuser_opcallback(disorder_eclient *c,
135 struct operation *op);
136 static void complete(disorder_eclient *c);
137 static void send_output(disorder_eclient *c);
138 static void put(disorder_eclient *c, const char *s, size_t n);
139 static void read_input(disorder_eclient *c);
140 static void stash_command(disorder_eclient *c,
142 operation_callback *opcallback,
147 static void log_opcallback(disorder_eclient *c, struct operation *op);
148 static void logline(disorder_eclient *c, const char *line);
149 static void logentry_completed(disorder_eclient *c, int nvec, char **vec);
150 static void logentry_failed(disorder_eclient *c, int nvec, char **vec);
151 static void logentry_moved(disorder_eclient *c, int nvec, char **vec);
152 static void logentry_playing(disorder_eclient *c, int nvec, char **vec);
153 static void logentry_queue(disorder_eclient *c, int nvec, char **vec);
154 static void logentry_recent_added(disorder_eclient *c, int nvec, char **vec);
155 static void logentry_recent_removed(disorder_eclient *c, int nvec, char **vec);
156 static void logentry_removed(disorder_eclient *c, int nvec, char **vec);
157 static void logentry_scratched(disorder_eclient *c, int nvec, char **vec);
158 static void logentry_state(disorder_eclient *c, int nvec, char **vec);
159 static void logentry_volume(disorder_eclient *c, int nvec, char **vec);
161 /* Tables ********************************************************************/
163 static const struct logentry_handler {
166 void (*handler)(disorder_eclient *c,
169 } logentry_handlers[] = {
170 #define LE(X, MIN, MAX) { #X, MIN, MAX, logentry_##X }
175 LE(queue, 2, INT_MAX),
176 LE(recent_added, 2, INT_MAX),
177 LE(recent_removed, 1, 1),
184 /* Setup and teardown ********************************************************/
186 disorder_eclient *disorder_eclient_new(const disorder_eclient_callbacks *cb,
188 disorder_eclient *c = xmalloc(sizeof *c);
189 D(("disorder_eclient_new"));
193 c->opstail = &c->ops;
194 vector_init(&c->vec);
195 dynstr_init(&c->input);
196 dynstr_init(&c->output);
197 if(!config->password) {
198 error(0, "no password set");
204 void disorder_eclient_close(disorder_eclient *c) {
205 struct operation *op;
207 D(("disorder_eclient_close"));
209 D(("disorder_eclient_close closing fd %d", c->fd));
210 c->callbacks->poll(c->u, c, c->fd, 0);
213 c->state = state_disconnected;
218 c->authenticated = 0;
219 /* We'll need to resend all operations */
220 for(op = c->ops; op; op = op->next)
224 /* Error reporting ***********************************************************/
226 /* called when a connection error occurs */
227 static int comms_error(disorder_eclient *c, const char *fmt, ...) {
233 byte_xvasprintf(&s, fmt, ap);
235 disorder_eclient_close(c);
236 c->callbacks->comms_error(c->u, s);
240 /* called when the server reports an error */
241 static int protocol_error(disorder_eclient *c, struct operation *op,
242 int code, const char *fmt, ...) {
246 D(("protocol_error"));
248 byte_xvasprintf(&s, fmt, ap);
250 c->callbacks->protocol_error(c->u, op->v, code, s);
254 /* State machine *************************************************************/
256 void disorder_eclient_polled(disorder_eclient *c, unsigned mode) {
257 struct operation *op;
259 D(("disorder_eclient_polled fd=%d state=%s mode=[%s %s]",
260 c->fd, states[c->state],
261 mode & DISORDER_POLL_READ ? "READ" : "",
262 mode & DISORDER_POLL_WRITE ? "WRITE" : ""));
263 /* The pattern here is to check each possible state in turn and try to
264 * advance (though on error we might go back). If we advance we leave open
265 * the possibility of falling through to the next state, but we set the mode
266 * bits to 0, to avoid false positives (which matter more in some cases than
269 if(c->state == state_disconnected) {
270 D(("state_disconnected"));
271 with_sockaddr(c, start_connect);
272 /* might now be state_disconnected (on error), state_connecting (slow
273 * connect) or state_connected (fast connect). If state_disconnected then
274 * we just rely on a periodic callback from the event loop sometime. */
278 if(c->state == state_connecting && mode) {
279 D(("state_connecting"));
281 /* Might be state_disconnected (on error) or state_connected (on success).
282 * In the former case we rely on the event loop for a periodic callback to
287 if(c->state == state_connected) {
288 D(("state_connected"));
289 /* We just connected. Initiate the authentication protocol. */
290 stash_command(c, 1/*queuejump*/, authbanner_opcallback,
291 0/*completed*/, 0/*v*/, 0/*cmd*/);
292 /* We never stay is state_connected very long. We could in principle jump
293 * straight to state_cmdresponse since there's actually no command to
294 * send, but that would arguably be cheating. */
295 c->state = state_idle;
298 if(c->state == state_idle) {
300 /* We are connected, and have finished any command we set off, look for
304 if(c->authenticated) {
305 /* Transmit all unsent operations */
306 for(op = c->ops; op; op = op->next) {
308 put(c, op->cmd, strlen(op->cmd));
313 /* Just send the head operation */
314 if(c->ops->cmd && !c->ops->sent) {
315 put(c, c->ops->cmd, strlen(c->ops->cmd));
319 /* Awaiting response for the operation at the head of the list */
320 c->state = state_cmdresponse;
323 c->callbacks->report(c->u, 0);
326 if(c->state == state_cmdresponse
327 || c->state == state_body
328 || c->state == state_log) {
329 D(("state_%s", states[c->state]));
330 /* We are awaiting a response */
331 if(mode & DISORDER_POLL_WRITE) send_output(c);
332 if(mode & DISORDER_POLL_READ) read_input(c);
333 /* There are a couple of reasons we might want to re-enter the state
334 * machine from the top. state_idle is obvious: there may be further
335 * commands to process. Re-entering on state_disconnected means that we
336 * immediately retry connection if a comms error occurs during a command.
337 * This is different to the case where a connection fails, where we await a
338 * spontaneous call to initiate the retry. */
340 case state_disconnected: /* lost connection */
341 case state_idle: /* completed a command */
343 disorder_eclient_polled(c, 0);
350 /* Figure out what to set the mode to */
352 case state_disconnected:
353 D(("state_disconnected (2)"));
354 /* Probably an error occurred. Await a retry. */
357 case state_connecting:
358 D(("state_connecting (2)"));
359 /* Waiting for connect to complete */
360 mode = DISORDER_POLL_READ|DISORDER_POLL_WRITE;
362 case state_connected:
363 D(("state_connected (2)"));
364 assert(!"should never be in state_connected here");
367 D(("state_idle (2)"));
368 /* Connected but nothing to do. */
371 case state_cmdresponse:
374 D(("state_%s (2)", states[c->state]));
375 /* Gathering a response. Wait for input. */
376 mode = DISORDER_POLL_READ;
377 /* Flush any pending output. */
378 if(c->output.nvec) mode |= DISORDER_POLL_WRITE;
381 D(("fd=%d new mode [%s %s]",
383 mode & DISORDER_POLL_READ ? "READ" : "",
384 mode & DISORDER_POLL_WRITE ? "WRITE" : ""));
385 if(c->fd != -1) c->callbacks->poll(c->u, c, c->fd, mode);
388 /* Called to start connecting */
389 static int start_connect(void *cc,
390 const struct sockaddr *sa,
393 disorder_eclient *c = cc;
395 D(("start_connect"));
396 c->ident = xstrdup(ident);
401 if((c->fd = socket(sa->sa_family, SOCK_STREAM, 0)) < 0)
402 return comms_error(c, "socket: %s", strerror(errno));
405 if(connect(c->fd, sa, len) < 0) {
409 c->state = state_connecting;
410 /* We are called from _polled so the state machine will get to do its
414 /* Signal the error to the caller. */
415 return comms_error(c, "connecting to %s: %s", ident, strerror(errno));
418 c->state = state_connected;
422 /* Called when maybe connected */
423 static void maybe_connected(disorder_eclient *c) {
424 /* We either connected, or got an error. */
426 socklen_t len = sizeof err;
428 D(("maybe_connected"));
429 /* Work around over-enthusiastic error slippage */
430 if(getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
433 /* The connection failed */
434 comms_error(c, "connecting to %s: %s", c->ident, strerror(err));
435 /* sets state_disconnected */
437 /* The connection succeeded */
438 c->state = state_connected;
442 /* Authentication ************************************************************/
444 static void authbanner_opcallback(disorder_eclient *c,
445 struct operation *op) {
447 const unsigned char *nonce;
450 D(("authbanner_opcallback"));
451 if(c->rc / 100 != 2) {
452 /* Banner told us to go away. We cannot proceed. */
453 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
454 disorder_eclient_close(c);
457 nonce = unhex(c->line + 4, &nonce_len);
458 res = authhash(nonce, nonce_len, config->password);
459 stash_command(c, 1/*queuejump*/, authuser_opcallback, 0/*completed*/, 0/*v*/,
460 "user", quoteutf8(config->username), quoteutf8(res),
464 static void authuser_opcallback(disorder_eclient *c,
465 struct operation *op) {
466 D(("authuser_opcallback"));
467 if(c->rc / 100 != 2) {
468 /* Wrong password or something. We cannot proceed. */
469 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
470 disorder_eclient_close(c);
473 /* OK, we're authenticated now. */
474 c->authenticated = 1;
475 if(c->log_callbacks && !(c->ops && c->ops->opcallback == log_opcallback))
476 /* We are a log client, switch to logging mode */
477 stash_command(c, 0/*queuejump*/, log_opcallback, 0/*completed*/, c->log_v,
481 /* Output ********************************************************************/
483 /* Chop N bytes off the front of a dynstr */
484 static void consume(struct dynstr *d, int n) {
485 D(("consume %d", n));
486 assert(d->nvec >= n);
487 memmove(d->vec, d->vec + n, d->nvec - n);
491 /* Write some bytes */
492 static void put(disorder_eclient *c, const char *s, size_t n) {
493 D(("put %d %.*s", c->fd, (int)n, s));
494 dynstr_append_bytes(&c->output, s, n);
497 /* Called when we can write to our FD, or at any other time */
498 static void send_output(disorder_eclient *c) {
501 D(("send_output %d bytes pending", c->output.nvec));
502 if(c->state > state_connecting && c->output.nvec) {
503 n = write(c->fd, c->output.vec, c->output.nvec);
510 comms_error(c, "writing to %s: %s", c->ident, strerror(errno));
514 consume(&c->output, n);
518 /* Input *********************************************************************/
520 /* Called when c->fd might be readable, or at any other time */
521 static void read_input(disorder_eclient *c) {
526 D(("read_input in state %s", states[c->state]));
527 if(c->state <= state_connected) return; /* ignore bogus calls */
528 /* read some more input */
529 n = read(c->fd, buffer, sizeof buffer);
536 comms_error(c, "reading from %s: %s", c->ident, strerror(errno));
539 return; /* no new input to process */
541 D(("read %d bytes: [%.*s]", n, n, buffer));
542 dynstr_append_bytes(&c->input, buffer, n);
545 /* might have more than one line to process */
546 while(c->state > state_connecting
547 && (nl = memchr(c->input.vec, '\n', c->input.nvec))) {
548 process_line(c, xstrndup(c->input.vec, nl - c->input.vec));
549 /* we might have disconnected along the way, which zogs the input buffer */
550 if(c->state > state_connecting)
551 consume(&c->input, (nl - c->input.vec) + 1);
554 comms_error(c, "reading from %s: server disconnected", c->ident);
555 c->authenticated = 0;
559 /* called with a line that has just been read */
560 static void process_line(disorder_eclient *c, char *line) {
561 D(("process_line %d [%s]", c->fd, line));
563 case state_cmdresponse:
564 /* This is the first line of a response */
565 if(!(line[0] >= '0' && line[0] <= '9'
566 && line[1] >= '0' && line[1] <= '9'
567 && line[2] >= '0' && line[2] <= '9'
569 fatal(0, "invalid response from server: %s", line);
570 c->rc = (line[0] * 10 + line[1]) * 10 + line[2] - 111 * '0';
574 /* We need to collect the body. */
575 c->state = state_body;
579 assert(c->log_callbacks != 0);
580 if(c->log_callbacks->connected)
581 c->log_callbacks->connected(c->log_v);
582 c->state = state_log;
585 /* We've got the whole response. Go into the idle state so the state
586 * machine knows we're done and then call the operation callback. */
592 if(strcmp(line, ".")) {
593 /* A line from the body */
594 vector_append(&c->vec, line + (line[0] == '.'));
596 /* End of the body. */
597 vector_terminate(&c->vec);
602 if(strcmp(line, ".")) {
603 logline(c, line + (line[0] == '.'));
608 assert(!"wrong state for location");
613 /* Called when an operation completes */
614 static void complete(disorder_eclient *c) {
615 struct operation *op;
618 /* Pop the operation off the queue */
621 if(c->opstail == &op->next)
622 c->opstail = &c->ops;
623 /* If we've pipelined a command ahead then we go straight to cmdresponser.
624 * Otherwise we go to idle, which will arrange further sends. */
625 c->state = c->ops && c->ops->sent ? state_cmdresponse : state_idle;
626 op->opcallback(c, op);
627 /* Note that we always call the opcallback even on error, though command
628 * opcallbacks generally always do the same error handling, i.e. just call
629 * protocol_error(). It's the auth* opcallbacks that have different
633 /* Operation setup ***********************************************************/
635 static void stash_command_vector(disorder_eclient *c,
637 operation_callback *opcallback,
642 struct operation *op = xmalloc(sizeof *op);
648 for(n = 0; n < ncmd; ++n) {
650 dynstr_append(&d, ' ');
651 dynstr_append_string(&d, quoteutf8(cmd[n]));
653 dynstr_append(&d, '\n');
654 dynstr_terminate(&d);
657 op->cmd = 0; /* usually, awaiting challenge */
658 op->opcallback = opcallback;
659 op->completed = completed;
663 assert(op->sent == 0);
665 /* Authentication operations jump the queue of useful commands */
668 if(c->opstail == &c->ops)
669 c->opstail = &op->next;
670 for(op = c->ops; op; op = op->next)
674 c->opstail = &op->next;
678 static void vstash_command(disorder_eclient *c,
680 operation_callback *opcallback,
683 const char *cmd, va_list ap) {
687 D(("vstash_command %s", cmd ? cmd : "NULL"));
690 vector_append(&vec, (char *)cmd);
691 while((arg = va_arg(ap, char *)))
692 vector_append(&vec, arg);
693 stash_command_vector(c, queuejump, opcallback, completed, v,
696 stash_command_vector(c, queuejump, opcallback, completed, v, 0, 0);
699 static void stash_command(disorder_eclient *c,
701 operation_callback *opcallback,
709 vstash_command(c, queuejump, opcallback, completed, v, cmd, ap);
713 /* Command support ***********************************************************/
715 /* for commands with a simple string response */
716 static void string_response_opcallback(disorder_eclient *c,
717 struct operation *op) {
718 D(("string_response_callback"));
719 if(c->rc / 100 == 2) {
721 ((disorder_eclient_string_response *)op->completed)(op->v, c->line + 4);
723 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
726 /* for commands with a simple integer response */
727 static void integer_response_opcallback(disorder_eclient *c,
728 struct operation *op) {
729 D(("string_response_callback"));
730 if(c->rc / 100 == 2) {
732 ((disorder_eclient_integer_response *)op->completed)
733 (op->v, strtol(c->line + 4, 0, 10));
735 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
738 /* for commands with no response */
739 static void no_response_opcallback(disorder_eclient *c,
740 struct operation *op) {
741 D(("no_response_callback"));
742 if(c->rc / 100 == 2) {
744 ((disorder_eclient_no_response *)op->completed)(op->v);
746 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
749 /* error callback for queue_unmarshall */
750 static void eclient_queue_error(const char *msg,
752 struct operation *op = u;
754 protocol_error(op->client, op, -1, "error parsing queue entry: %s", msg);
757 /* for commands that expect a queue dump */
758 static void queue_response_opcallback(disorder_eclient *c,
759 struct operation *op) {
761 struct queue_entry *q, *qh = 0, **qtail = &qh, *qlast = 0;
763 D(("queue_response_callback"));
764 if(c->rc / 100 == 2) {
765 /* parse the queue */
766 for(n = 0; n < c->vec.nvec; ++n) {
767 q = xmalloc(sizeof *q);
768 D(("queue_unmarshall %s", c->vec.vec[n]));
769 if(!queue_unmarshall(q, c->vec.vec[n], eclient_queue_error, op)) {
777 ((disorder_eclient_queue_response *)op->completed)(op->v, qh);
779 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
783 static void playing_response_opcallback(disorder_eclient *c,
784 struct operation *op) {
785 struct queue_entry *q;
787 D(("playing_response_callback"));
788 if(c->rc / 100 == 2) {
791 if(queue_unmarshall(q = xmalloc(sizeof *q), c->line + 4,
792 eclient_queue_error, c))
799 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
803 ((disorder_eclient_queue_response *)op->completed)(op->v, q);
805 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
808 /* for commands that expect a list of some sort */
809 static void list_response_opcallback(disorder_eclient *c,
810 struct operation *op) {
811 D(("list_response_callback"));
812 if(c->rc / 100 == 2) {
814 ((disorder_eclient_list_response *)op->completed)(op->v,
818 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
822 static void volume_response_opcallback(disorder_eclient *c,
823 struct operation *op) {
826 D(("volume_response_callback"));
827 if(c->rc / 100 == 2) {
829 if(sscanf(c->line + 4, "%d %d", &l, &r) != 2 || l < 0 || r < 0)
830 protocol_error(c, op, -1, "%s: invalid volume response: %s",
833 ((disorder_eclient_volume_response *)op->completed)(op->v, l, r);
836 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
839 static int simple(disorder_eclient *c,
840 operation_callback *opcallback,
843 const char *cmd, ...) {
847 vstash_command(c, 0/*queuejump*/, opcallback, completed, v, cmd, ap);
849 /* Give the state machine a kick, since we might be in state_idle */
850 disorder_eclient_polled(c, 0);
854 /* Commands ******************************************************************/
856 int disorder_eclient_version(disorder_eclient *c,
857 disorder_eclient_string_response *completed,
859 return simple(c, string_response_opcallback, (void (*)())completed, v,
860 "version", (char *)0);
863 int disorder_eclient_namepart(disorder_eclient *c,
864 disorder_eclient_string_response *completed,
869 return simple(c, string_response_opcallback, (void (*)())completed, v,
870 "part", track, context, part, (char *)0);
873 int disorder_eclient_play(disorder_eclient *c,
875 disorder_eclient_no_response *completed,
877 return simple(c, no_response_opcallback, (void (*)())completed, v,
878 "play", track, (char *)0);
881 int disorder_eclient_pause(disorder_eclient *c,
882 disorder_eclient_no_response *completed,
884 return simple(c, no_response_opcallback, (void (*)())completed, v,
888 int disorder_eclient_resume(disorder_eclient *c,
889 disorder_eclient_no_response *completed,
891 return simple(c, no_response_opcallback, (void (*)())completed, v,
892 "resume", (char *)0);
895 int disorder_eclient_scratch(disorder_eclient *c,
897 disorder_eclient_no_response *completed,
899 return simple(c, no_response_opcallback, (void (*)())completed, v,
900 "scratch", id, (char *)0);
903 int disorder_eclient_scratch_playing(disorder_eclient *c,
904 disorder_eclient_no_response *completed,
906 return disorder_eclient_scratch(c, 0, completed, v);
909 int disorder_eclient_remove(disorder_eclient *c,
911 disorder_eclient_no_response *completed,
913 return simple(c, no_response_opcallback, (void (*)())completed, v,
914 "remove", id, (char *)0);
917 int disorder_eclient_moveafter(disorder_eclient *c,
921 disorder_eclient_no_response *completed,
927 vector_append(&vec, (char *)"moveafter");
928 vector_append(&vec, (char *)target);
929 for(n = 0; n < nids; ++n)
930 vector_append(&vec, (char *)ids[n]);
931 stash_command_vector(c, 0/*queuejump*/, no_response_opcallback, completed, v,
933 disorder_eclient_polled(c, 0);
937 int disorder_eclient_recent(disorder_eclient *c,
938 disorder_eclient_queue_response *completed,
940 return simple(c, queue_response_opcallback, (void (*)())completed, v,
941 "recent", (char *)0);
944 int disorder_eclient_queue(disorder_eclient *c,
945 disorder_eclient_queue_response *completed,
947 return simple(c, queue_response_opcallback, (void (*)())completed, v,
951 int disorder_eclient_files(disorder_eclient *c,
952 disorder_eclient_list_response *completed,
956 return simple(c, list_response_opcallback, (void (*)())completed, v,
957 "files", dir, re, (char *)0);
960 int disorder_eclient_dirs(disorder_eclient *c,
961 disorder_eclient_list_response *completed,
965 return simple(c, list_response_opcallback, (void (*)())completed, v,
966 "dirs", dir, re, (char *)0);
969 int disorder_eclient_playing(disorder_eclient *c,
970 disorder_eclient_queue_response *completed,
972 return simple(c, playing_response_opcallback, (void (*)())completed, v,
973 "playing", (char *)0);
976 int disorder_eclient_length(disorder_eclient *c,
977 disorder_eclient_integer_response *completed,
980 return simple(c, integer_response_opcallback, (void (*)())completed, v,
981 "length", track, (char *)0);
984 int disorder_eclient_volume(disorder_eclient *c,
985 disorder_eclient_volume_response *completed,
991 return simple(c, volume_response_opcallback, (void (*)())completed, v,
992 "volume", (char *)0);
993 } else if(l >= 0 && r >= 0) {
996 byte_snprintf(sl, sizeof sl, "%d", l);
997 byte_snprintf(sr, sizeof sr, "%d", r);
998 return simple(c, volume_response_opcallback, (void (*)())completed, v,
999 "volume", sl, sr, (char *)0);
1001 assert(!"invalid arguments to disorder_eclient_volume");
1002 return -1; /* gcc is being dim */
1006 int disorder_eclient_enable(disorder_eclient *c,
1007 disorder_eclient_no_response *completed,
1009 return simple(c, no_response_opcallback, (void (*)())completed, v,
1010 "enable", (char *)0);
1013 int disorder_eclient_disable(disorder_eclient *c,
1014 disorder_eclient_no_response *completed,
1016 return simple(c, no_response_opcallback, (void (*)())completed, v,
1017 "disable", (char *)0);
1020 int disorder_eclient_random_enable(disorder_eclient *c,
1021 disorder_eclient_no_response *completed,
1023 return simple(c, no_response_opcallback, (void (*)())completed, v,
1024 "random-enable", (char *)0);
1027 int disorder_eclient_random_disable(disorder_eclient *c,
1028 disorder_eclient_no_response *completed,
1030 return simple(c, no_response_opcallback, (void (*)())completed, v,
1031 "random-disable", (char *)0);
1034 int disorder_eclient_get(disorder_eclient *c,
1035 disorder_eclient_string_response *completed,
1036 const char *track, const char *pref,
1038 return simple(c, string_response_opcallback, (void (*)())completed, v,
1039 "get", track, pref, (char *)0);
1042 int disorder_eclient_set(disorder_eclient *c,
1043 disorder_eclient_no_response *completed,
1044 const char *track, const char *pref,
1047 return simple(c, no_response_opcallback, (void (*)())completed, v,
1048 "set", track, pref, value, (char *)0);
1051 int disorder_eclient_unset(disorder_eclient *c,
1052 disorder_eclient_no_response *completed,
1053 const char *track, const char *pref,
1055 return simple(c, no_response_opcallback, (void (*)())completed, v,
1056 "unset", track, pref, (char *)0);
1059 int disorder_eclient_resolve(disorder_eclient *c,
1060 disorder_eclient_string_response *completed,
1063 return simple(c, string_response_opcallback, (void (*)())completed, v,
1064 "resolve", track, (char *)0);
1067 int disorder_eclient_search(disorder_eclient *c,
1068 disorder_eclient_list_response *completed,
1071 if(!split(terms, 0, SPLIT_QUOTES, 0, 0)) return -1;
1072 return simple(c, list_response_opcallback, (void (*)())completed, v,
1073 "search", terms, (char *)0);
1076 /* Log clients ***************************************************************/
1078 int disorder_eclient_log(disorder_eclient *c,
1079 const disorder_eclient_log_callbacks *callbacks,
1081 if(c->log_callbacks) return -1;
1082 c->log_callbacks = callbacks;
1084 stash_command(c, 0/*queuejump*/, log_opcallback, 0/*completed*/, v,
1089 /* If we get here we've stopped being a log client */
1090 static void log_opcallback(disorder_eclient *c,
1091 struct operation attribute((unused)) *op) {
1092 D(("log_opcallback"));
1093 c->log_callbacks = 0;
1097 /* error callback for log line parsing */
1098 static void logline_error(const char *msg, void *u) {
1099 disorder_eclient *c = u;
1100 protocol_error(c, c->ops, -1, "error parsing log line: %s", msg);
1103 /* process a single log line */
1104 static void logline(disorder_eclient *c, const char *line) {
1109 D(("log_opcallback [%s]", line));
1110 vec = split(line, &nvec, SPLIT_QUOTES, logline_error, c);
1111 if(nvec < 2) return; /* probably an error, already
1113 if(sscanf(vec[0], "%"SCNxMAX, &when) != 1) {
1114 /* probably the wrong side of a format change */
1115 protocol_error(c, c->ops, -1, "invalid log timestamp '%s'", vec[0]);
1118 /* TODO: do something with the time */
1119 n = TABLE_FIND(logentry_handlers, struct logentry_handler, name, vec[1]);
1120 if(n < 0) return; /* probably a future command */
1123 if(nvec < logentry_handlers[n].min || nvec > logentry_handlers[n].max)
1125 logentry_handlers[n].handler(c, nvec, vec);
1128 static void logentry_completed(disorder_eclient *c,
1129 int attribute((unused)) nvec, char **vec) {
1130 if(!c->log_callbacks->completed) return;
1131 c->log_callbacks->completed(c->log_v, vec[0]);
1134 static void logentry_failed(disorder_eclient *c,
1135 int attribute((unused)) nvec, char **vec) {
1136 if(!c->log_callbacks->failed)return;
1137 c->log_callbacks->failed(c->log_v, vec[0], vec[1]);
1140 static void logentry_moved(disorder_eclient *c,
1141 int attribute((unused)) nvec, char **vec) {
1142 if(!c->log_callbacks->moved) return;
1143 c->log_callbacks->moved(c->log_v, vec[0]);
1146 static void logentry_playing(disorder_eclient *c,
1147 int attribute((unused)) nvec, char **vec) {
1148 if(!c->log_callbacks->playing) return;
1149 c->log_callbacks->playing(c->log_v, vec[0], vec[1]);
1152 static void logentry_queue(disorder_eclient *c,
1153 int attribute((unused)) nvec, char **vec) {
1154 struct queue_entry *q;
1156 if(!c->log_callbacks->completed) return;
1157 q = xmalloc(sizeof *q);
1158 if(queue_unmarshall_vec(q, nvec, vec, eclient_queue_error, c))
1160 c->log_callbacks->queue(c->log_v, q);
1163 static void logentry_recent_added(disorder_eclient *c,
1164 int attribute((unused)) nvec, char **vec) {
1165 struct queue_entry *q;
1167 if(!c->log_callbacks->recent_added) return;
1168 q = xmalloc(sizeof *q);
1169 if(queue_unmarshall_vec(q, nvec, vec, eclient_queue_error, c))
1171 c->log_callbacks->recent_added(c->log_v, q);
1174 static void logentry_recent_removed(disorder_eclient *c,
1175 int attribute((unused)) nvec, char **vec) {
1176 if(!c->log_callbacks->recent_removed) return;
1177 c->log_callbacks->recent_removed(c->log_v, vec[0]);
1180 static void logentry_removed(disorder_eclient *c,
1181 int attribute((unused)) nvec, char **vec) {
1182 if(!c->log_callbacks->removed) return;
1183 c->log_callbacks->removed(c->log_v, vec[0], vec[1]);
1186 static void logentry_scratched(disorder_eclient *c,
1187 int attribute((unused)) nvec, char **vec) {
1188 if(!c->log_callbacks->scratched) return;
1189 c->log_callbacks->scratched(c->log_v, vec[0], vec[1]);
1192 static const struct {
1195 const char *disable;
1196 } statestrings[] = {
1197 { DISORDER_PLAYING_ENABLED, "enable_play", "disable_play" },
1198 { DISORDER_RANDOM_ENABLED, "enable_random", "disable_random" },
1199 { DISORDER_TRACK_PAUSED, "pause", "resume" },
1201 #define NSTATES (int)(sizeof states / sizeof *states)
1203 static void logentry_state(disorder_eclient *c,
1204 int attribute((unused)) nvec, char **vec) {
1207 for(n = 0; n < NSTATES; ++n)
1208 if(!strcmp(vec[0], statestrings[n].enable)) {
1209 c->statebits |= statestrings[n].bit;
1211 } else if(!strcmp(vec[0], statestrings[n].disable)) {
1212 c->statebits &= ~statestrings[n].bit;
1215 if(!c->log_callbacks->state) return;
1216 c->log_callbacks->state(c->log_v, c->statebits);
1219 static void logentry_volume(disorder_eclient *c,
1220 int attribute((unused)) nvec, char **vec) {
1223 if(!c->log_callbacks->volume) return;
1224 if(xstrtol(&l, vec[0], 0, 10)
1225 || xstrtol(&r, vec[1], 0, 10)
1226 || l < 0 || l > INT_MAX
1227 || r < 0 || r > INT_MAX)
1229 c->log_callbacks->volume(c->log_v, (int)l, (int)r);
1237 indent-tabs-mode:nil