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
);
200 void disorder_eclient_close(disorder_eclient
*c
) {
201 struct operation
*op
;
203 D(("disorder_eclient_close"));
205 D(("disorder_eclient_close closing fd %d", c
->fd
));
206 c
->callbacks
->poll(c
->u
, c
, c
->fd
, 0);
209 c
->state
= state_disconnected
;
214 c
->authenticated
= 0;
215 /* We'll need to resend all operations */
216 for(op
= c
->ops
; op
; op
= op
->next
)
220 /* Error reporting ***********************************************************/
222 /* called when a connection error occurs */
223 static int comms_error(disorder_eclient
*c
, const char *fmt
, ...) {
229 byte_xvasprintf(&s
, fmt
, ap
);
231 disorder_eclient_close(c
);
232 c
->callbacks
->comms_error(c
->u
, s
);
236 /* called when the server reports an error */
237 static int protocol_error(disorder_eclient
*c
, struct operation
*op
,
238 int code
, const char *fmt
, ...) {
242 D(("protocol_error"));
244 byte_xvasprintf(&s
, fmt
, ap
);
246 c
->callbacks
->protocol_error(c
->u
, op
->v
, code
, s
);
250 /* State machine *************************************************************/
252 void disorder_eclient_polled(disorder_eclient
*c
, unsigned mode
) {
253 struct operation
*op
;
255 D(("disorder_eclient_polled fd=%d state=%s mode=[%s %s]",
256 c
->fd
, states
[c
->state
],
257 mode
& DISORDER_POLL_READ ?
"READ" : "",
258 mode
& DISORDER_POLL_WRITE ?
"WRITE" : ""));
259 /* The pattern here is to check each possible state in turn and try to
260 * advance (though on error we might go back). If we advance we leave open
261 * the possibility of falling through to the next state, but we set the mode
262 * bits to 0, to avoid false positives (which matter more in some cases than
265 if(c
->state
== state_disconnected
) {
266 D(("state_disconnected"));
267 with_sockaddr(c
, start_connect
);
268 /* might now be state_disconnected (on error), state_connecting (slow
269 * connect) or state_connected (fast connect). If state_disconnected then
270 * we just rely on a periodic callback from the event loop sometime. */
274 if(c
->state
== state_connecting
&& mode
) {
275 D(("state_connecting"));
277 /* Might be state_disconnected (on error) or state_connected (on success).
278 * In the former case we rely on the event loop for a periodic callback to
283 if(c
->state
== state_connected
) {
284 D(("state_connected"));
285 /* We just connected. Initiate the authentication protocol. */
286 stash_command(c
, 1/*queuejump*/, authbanner_opcallback
,
287 0/*completed*/, 0/*v*/, 0/*cmd*/);
288 /* We never stay is state_connected very long. We could in principle jump
289 * straight to state_cmdresponse since there's actually no command to
290 * send, but that would arguably be cheating. */
291 c
->state
= state_idle
;
294 if(c
->state
== state_idle
) {
296 /* We are connected, and have finished any command we set off, look for
300 if(c
->authenticated
) {
301 /* Transmit all unsent operations */
302 for(op
= c
->ops
; op
; op
= op
->next
) {
304 put(c
, op
->cmd
, strlen(op
->cmd
));
309 /* Just send the head operation */
310 if(c
->ops
->cmd
&& !c
->ops
->sent
) {
311 put(c
, c
->ops
->cmd
, strlen(c
->ops
->cmd
));
315 /* Awaiting response for the operation at the head of the list */
316 c
->state
= state_cmdresponse
;
319 c
->callbacks
->report(c
->u
, 0);
322 if(c
->state
== state_cmdresponse
323 || c
->state
== state_body
324 || c
->state
== state_log
) {
325 D(("state_%s", states
[c
->state
]));
326 /* We are awaiting a response */
327 if(mode
& DISORDER_POLL_WRITE
) send_output(c
);
328 if(mode
& DISORDER_POLL_READ
) read_input(c
);
329 /* There are a couple of reasons we might want to re-enter the state
330 * machine from the top. state_idle is obvious: there may be further
331 * commands to process. Re-entering on state_disconnected means that we
332 * immediately retry connection if a comms error occurs during a command.
333 * This is different to the case where a connection fails, where we await a
334 * spontaneous call to initiate the retry. */
336 case state_disconnected
: /* lost connection */
337 case state_idle
: /* completed a command */
339 disorder_eclient_polled(c
, 0);
346 /* Figure out what to set the mode to */
348 case state_disconnected
:
349 D(("state_disconnected (2)"));
350 /* Probably an error occurred. Await a retry. */
353 case state_connecting
:
354 D(("state_connecting (2)"));
355 /* Waiting for connect to complete */
356 mode
= DISORDER_POLL_READ
|DISORDER_POLL_WRITE
;
358 case state_connected
:
359 D(("state_connected (2)"));
360 assert(!"should never be in state_connected here");
363 D(("state_idle (2)"));
364 /* Connected but nothing to do. */
367 case state_cmdresponse
:
370 D(("state_%s (2)", states
[c
->state
]));
371 /* Gathering a response. Wait for input. */
372 mode
= DISORDER_POLL_READ
;
373 /* Flush any pending output. */
374 if(c
->output
.nvec
) mode
|= DISORDER_POLL_WRITE
;
377 D(("fd=%d new mode [%s %s]",
379 mode
& DISORDER_POLL_READ ?
"READ" : "",
380 mode
& DISORDER_POLL_WRITE ?
"WRITE" : ""));
381 if(c
->fd
!= -1) c
->callbacks
->poll(c
->u
, c
, c
->fd
, mode
);
384 /* Called to start connecting */
385 static int start_connect(void *cc
,
386 const struct sockaddr
*sa
,
389 disorder_eclient
*c
= cc
;
391 D(("start_connect"));
392 c
->ident
= xstrdup(ident
);
397 if((c
->fd
= socket(sa
->sa_family
, SOCK_STREAM
, 0)) < 0)
398 return comms_error(c
, "socket: %s", strerror(errno
));
401 if(connect(c
->fd
, sa
, len
) < 0) {
405 c
->state
= state_connecting
;
406 /* We are called from _polled so the state machine will get to do its
410 /* Signal the error to the caller. */
411 return comms_error(c
, "connecting to %s: %s", ident
, strerror(errno
));
414 c
->state
= state_connected
;
418 /* Called when maybe connected */
419 static void maybe_connected(disorder_eclient
*c
) {
420 /* We either connected, or got an error. */
422 socklen_t len
= sizeof err
;
424 D(("maybe_connected"));
425 /* Work around over-enthusiastic error slippage */
426 if(getsockopt(c
->fd
, SOL_SOCKET
, SO_ERROR
, &err
, &len
) < 0)
429 /* The connection failed */
430 comms_error(c
, "connecting to %s: %s", c
->ident
, strerror(err
));
431 /* sets state_disconnected */
433 /* The connection succeeded */
434 c
->state
= state_connected
;
438 /* Authentication ************************************************************/
440 static void authbanner_opcallback(disorder_eclient
*c
,
441 struct operation
*op
) {
443 const unsigned char *nonce
;
446 D(("authbanner_opcallback"));
447 if(c
->rc
/ 100 != 2) {
448 /* Banner told us to go away. We cannot proceed. */
449 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
450 disorder_eclient_close(c
);
453 nonce
= unhex(c
->line
+ 4, &nonce_len
);
454 res
= authhash(nonce
, nonce_len
, config
->password
);
455 stash_command(c
, 1/*queuejump*/, authuser_opcallback
, 0/*completed*/, 0/*v*/,
456 "user", quoteutf8(config
->username
), quoteutf8(res
),
460 static void authuser_opcallback(disorder_eclient
*c
,
461 struct operation
*op
) {
462 D(("authuser_opcallback"));
463 if(c
->rc
/ 100 != 2) {
464 /* Wrong password or something. We cannot proceed. */
465 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
466 disorder_eclient_close(c
);
469 /* OK, we're authenticated now. */
470 c
->authenticated
= 1;
471 if(c
->log_callbacks
&& !(c
->ops
&& c
->ops
->opcallback
== log_opcallback
))
472 /* We are a log client, switch to logging mode */
473 stash_command(c
, 0/*queuejump*/, log_opcallback
, 0/*completed*/, c
->log_v
,
477 /* Output ********************************************************************/
479 /* Chop N bytes off the front of a dynstr */
480 static void consume(struct dynstr
*d
, int n
) {
481 D(("consume %d", n
));
482 assert(d
->nvec
>= n
);
483 memmove(d
->vec
, d
->vec
+ n
, d
->nvec
- n
);
487 /* Write some bytes */
488 static void put(disorder_eclient
*c
, const char *s
, size_t n
) {
489 D(("put %d %.*s", c
->fd
, (int)n
, s
));
490 dynstr_append_bytes(&c
->output
, s
, n
);
493 /* Called when we can write to our FD, or at any other time */
494 static void send_output(disorder_eclient
*c
) {
497 D(("send_output %d bytes pending", c
->output
.nvec
));
498 if(c
->state
> state_connecting
&& c
->output
.nvec
) {
499 n
= write(c
->fd
, c
->output
.vec
, c
->output
.nvec
);
506 comms_error(c
, "writing to %s: %s", c
->ident
, strerror(errno
));
510 consume(&c
->output
, n
);
514 /* Input *********************************************************************/
516 /* Called when c->fd might be readable, or at any other time */
517 static void read_input(disorder_eclient
*c
) {
522 D(("read_input in state %s", states
[c
->state
]));
523 if(c
->state
<= state_connected
) return; /* ignore bogus calls */
524 /* read some more input */
525 n
= read(c
->fd
, buffer
, sizeof buffer
);
532 comms_error(c
, "reading from %s: %s", c
->ident
, strerror(errno
));
535 return; /* no new input to process */
537 D(("read %d bytes: [%.*s]", n
, n
, buffer
));
538 dynstr_append_bytes(&c
->input
, buffer
, n
);
541 /* might have more than one line to process */
542 while(c
->state
> state_connecting
543 && (nl
= memchr(c
->input
.vec
, '\n', c
->input
.nvec
))) {
544 process_line(c
, xstrndup(c
->input
.vec
, nl
- c
->input
.vec
));
545 /* we might have disconnected along the way, which zogs the input buffer */
546 if(c
->state
> state_connecting
)
547 consume(&c
->input
, (nl
- c
->input
.vec
) + 1);
550 comms_error(c
, "reading from %s: server disconnected", c
->ident
);
553 /* called with a line that has just been read */
554 static void process_line(disorder_eclient
*c
, char *line
) {
555 D(("process_line %d [%s]", c
->fd
, line
));
557 case state_cmdresponse
:
558 /* This is the first line of a response */
559 if(!(line
[0] >= '0' && line
[0] <= '9'
560 && line
[1] >= '0' && line
[1] <= '9'
561 && line
[2] >= '0' && line
[2] <= '9'
563 fatal(0, "invalid response from server: %s", line
);
564 c
->rc
= (line
[0] * 10 + line
[1]) * 10 + line
[2] - 111 * '0';
568 /* We need to collect the body. */
569 c
->state
= state_body
;
573 assert(c
->log_callbacks
!= 0);
574 if(c
->log_callbacks
->connected
)
575 c
->log_callbacks
->connected(c
->log_v
);
576 c
->state
= state_log
;
579 /* We've got the whole response. Go into the idle state so the state
580 * machine knows we're done and then call the operation callback. */
586 if(strcmp(line
, ".")) {
587 /* A line from the body */
588 vector_append(&c
->vec
, line
+ (line
[0] == '.'));
590 /* End of the body. */
591 vector_terminate(&c
->vec
);
596 if(strcmp(line
, ".")) {
597 logline(c
, line
+ (line
[0] == '.'));
602 assert(!"wrong state for location");
607 /* Called when an operation completes */
608 static void complete(disorder_eclient
*c
) {
609 struct operation
*op
;
612 /* Pop the operation off the queue */
615 if(c
->opstail
== &op
->next
)
616 c
->opstail
= &c
->ops
;
617 /* If we've pipelined a command ahead then we go straight to cmdresponser.
618 * Otherwise we go to idle, which will arrange further sends. */
619 c
->state
= c
->ops
&& c
->ops
->sent ? state_cmdresponse
: state_idle
;
620 op
->opcallback(c
, op
);
621 /* Note that we always call the opcallback even on error, though command
622 * opcallbacks generally always do the same error handling, i.e. just call
623 * protocol_error(). It's the auth* opcallbacks that have different
627 /* Operation setup ***********************************************************/
629 static void stash_command_vector(disorder_eclient
*c
,
631 operation_callback
*opcallback
,
636 struct operation
*op
= xmalloc(sizeof *op
);
642 for(n
= 0; n
< ncmd
; ++n
) {
644 dynstr_append(&d
, ' ');
645 dynstr_append_string(&d
, quoteutf8(cmd
[n
]));
647 dynstr_append(&d
, '\n');
648 dynstr_terminate(&d
);
651 op
->cmd
= 0; /* usually, awaiting challenge */
652 op
->opcallback
= opcallback
;
653 op
->completed
= completed
;
657 assert(op
->sent
== 0);
659 /* Authentication operations jump the queue of useful commands */
662 if(c
->opstail
== &c
->ops
)
663 c
->opstail
= &op
->next
;
664 for(op
= c
->ops
; op
; op
= op
->next
)
668 c
->opstail
= &op
->next
;
672 static void vstash_command(disorder_eclient
*c
,
674 operation_callback
*opcallback
,
677 const char *cmd
, va_list ap
) {
681 D(("vstash_command %s", cmd ? cmd
: "NULL"));
684 vector_append(&vec
, (char *)cmd
);
685 while((arg
= va_arg(ap
, char *)))
686 vector_append(&vec
, arg
);
687 stash_command_vector(c
, queuejump
, opcallback
, completed
, v
,
690 stash_command_vector(c
, queuejump
, opcallback
, completed
, v
, 0, 0);
693 static void stash_command(disorder_eclient
*c
,
695 operation_callback
*opcallback
,
703 vstash_command(c
, queuejump
, opcallback
, completed
, v
, cmd
, ap
);
707 /* Command support ***********************************************************/
709 /* for commands with a simple string response */
710 static void string_response_opcallback(disorder_eclient
*c
,
711 struct operation
*op
) {
712 D(("string_response_callback"));
713 if(c
->rc
/ 100 == 2) {
715 ((disorder_eclient_string_response
*)op
->completed
)(op
->v
, c
->line
+ 4);
717 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
720 /* for commands with a simple integer response */
721 static void integer_response_opcallback(disorder_eclient
*c
,
722 struct operation
*op
) {
723 D(("string_response_callback"));
724 if(c
->rc
/ 100 == 2) {
726 ((disorder_eclient_integer_response
*)op
->completed
)
727 (op
->v
, strtol(c
->line
+ 4, 0, 10));
729 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
732 /* for commands with no response */
733 static void no_response_opcallback(disorder_eclient
*c
,
734 struct operation
*op
) {
735 D(("no_response_callback"));
736 if(c
->rc
/ 100 == 2) {
738 ((disorder_eclient_no_response
*)op
->completed
)(op
->v
);
740 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
743 /* error callback for queue_unmarshall */
744 static void eclient_queue_error(const char *msg
,
746 struct operation
*op
= u
;
748 protocol_error(op
->client
, op
, -1, "error parsing queue entry: %s", msg
);
751 /* for commands that expect a queue dump */
752 static void queue_response_opcallback(disorder_eclient
*c
,
753 struct operation
*op
) {
755 struct queue_entry
*q
, *qh
= 0, **qtail
= &qh
, *qlast
= 0;
757 D(("queue_response_callback"));
758 if(c
->rc
/ 100 == 2) {
759 /* parse the queue */
760 for(n
= 0; n
< c
->vec
.nvec
; ++n
) {
761 q
= xmalloc(sizeof *q
);
762 D(("queue_unmarshall %s", c
->vec
.vec
[n
]));
763 if(!queue_unmarshall(q
, c
->vec
.vec
[n
], eclient_queue_error
, op
)) {
771 ((disorder_eclient_queue_response
*)op
->completed
)(op
->v
, qh
);
773 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
777 static void playing_response_opcallback(disorder_eclient
*c
,
778 struct operation
*op
) {
779 struct queue_entry
*q
;
781 D(("playing_response_callback"));
782 if(c
->rc
/ 100 == 2) {
785 if(queue_unmarshall(q
= xmalloc(sizeof *q
), c
->line
+ 4,
786 eclient_queue_error
, c
))
793 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
797 ((disorder_eclient_queue_response
*)op
->completed
)(op
->v
, q
);
799 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
802 /* for commands that expect a list of some sort */
803 static void list_response_opcallback(disorder_eclient
*c
,
804 struct operation
*op
) {
805 D(("list_response_callback"));
806 if(c
->rc
/ 100 == 2) {
808 ((disorder_eclient_list_response
*)op
->completed
)(op
->v
,
812 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
816 static void volume_response_opcallback(disorder_eclient
*c
,
817 struct operation
*op
) {
820 D(("volume_response_callback"));
821 if(c
->rc
/ 100 == 2) {
823 if(sscanf(c
->line
+ 4, "%d %d", &l
, &r
) != 2 || l
< 0 || r
< 0)
824 protocol_error(c
, op
, -1, "%s: invalid volume response: %s",
827 ((disorder_eclient_volume_response
*)op
->completed
)(op
->v
, l
, r
);
830 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
833 static int simple(disorder_eclient
*c
,
834 operation_callback
*opcallback
,
837 const char *cmd
, ...) {
841 vstash_command(c
, 0/*queuejump*/, opcallback
, completed
, v
, cmd
, ap
);
843 /* Give the state machine a kick, since we might be in state_idle */
844 disorder_eclient_polled(c
, 0);
848 /* Commands ******************************************************************/
850 int disorder_eclient_version(disorder_eclient
*c
,
851 disorder_eclient_string_response
*completed
,
853 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
854 "version", (char *)0);
857 int disorder_eclient_namepart(disorder_eclient
*c
,
858 disorder_eclient_string_response
*completed
,
863 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
864 "part", track
, context
, part
, (char *)0);
867 int disorder_eclient_play(disorder_eclient
*c
,
869 disorder_eclient_no_response
*completed
,
871 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
872 "play", track
, (char *)0);
875 int disorder_eclient_pause(disorder_eclient
*c
,
876 disorder_eclient_no_response
*completed
,
878 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
882 int disorder_eclient_resume(disorder_eclient
*c
,
883 disorder_eclient_no_response
*completed
,
885 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
886 "resume", (char *)0);
889 int disorder_eclient_scratch(disorder_eclient
*c
,
891 disorder_eclient_no_response
*completed
,
893 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
894 "scratch", id
, (char *)0);
897 int disorder_eclient_scratch_playing(disorder_eclient
*c
,
898 disorder_eclient_no_response
*completed
,
900 return disorder_eclient_scratch(c
, 0, completed
, v
);
903 int disorder_eclient_remove(disorder_eclient
*c
,
905 disorder_eclient_no_response
*completed
,
907 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
908 "remove", id
, (char *)0);
911 int disorder_eclient_moveafter(disorder_eclient
*c
,
915 disorder_eclient_no_response
*completed
,
921 vector_append(&vec
, (char *)"moveafter");
922 vector_append(&vec
, (char *)target
);
923 for(n
= 0; n
< nids
; ++n
)
924 vector_append(&vec
, (char *)ids
[n
]);
925 stash_command_vector(c
, 0/*queuejump*/, no_response_opcallback
, completed
, v
,
927 disorder_eclient_polled(c
, 0);
931 int disorder_eclient_recent(disorder_eclient
*c
,
932 disorder_eclient_queue_response
*completed
,
934 return simple(c
, queue_response_opcallback
, (void (*)())completed
, v
,
935 "recent", (char *)0);
938 int disorder_eclient_queue(disorder_eclient
*c
,
939 disorder_eclient_queue_response
*completed
,
941 return simple(c
, queue_response_opcallback
, (void (*)())completed
, v
,
945 int disorder_eclient_files(disorder_eclient
*c
,
946 disorder_eclient_list_response
*completed
,
950 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
951 "files", dir
, re
, (char *)0);
954 int disorder_eclient_dirs(disorder_eclient
*c
,
955 disorder_eclient_list_response
*completed
,
959 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
960 "dirs", dir
, re
, (char *)0);
963 int disorder_eclient_playing(disorder_eclient
*c
,
964 disorder_eclient_queue_response
*completed
,
966 return simple(c
, playing_response_opcallback
, (void (*)())completed
, v
,
967 "playing", (char *)0);
970 int disorder_eclient_length(disorder_eclient
*c
,
971 disorder_eclient_integer_response
*completed
,
974 return simple(c
, integer_response_opcallback
, (void (*)())completed
, v
,
975 "length", track
, (char *)0);
978 int disorder_eclient_volume(disorder_eclient
*c
,
979 disorder_eclient_volume_response
*completed
,
985 return simple(c
, volume_response_opcallback
, (void (*)())completed
, v
,
986 "volume", (char *)0);
987 } else if(l
>= 0 && r
>= 0) {
990 byte_snprintf(sl
, sizeof sl
, "%d", l
);
991 byte_snprintf(sr
, sizeof sr
, "%d", r
);
992 return simple(c
, volume_response_opcallback
, (void (*)())completed
, v
,
993 "volume", sl
, sr
, (char *)0);
995 assert(!"invalid arguments to disorder_eclient_volume");
996 return -1; /* gcc is being dim */
1000 int disorder_eclient_enable(disorder_eclient
*c
,
1001 disorder_eclient_no_response
*completed
,
1003 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1004 "enable", (char *)0);
1007 int disorder_eclient_disable(disorder_eclient
*c
,
1008 disorder_eclient_no_response
*completed
,
1010 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1011 "disable", (char *)0);
1014 int disorder_eclient_random_enable(disorder_eclient
*c
,
1015 disorder_eclient_no_response
*completed
,
1017 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1018 "random-enable", (char *)0);
1021 int disorder_eclient_random_disable(disorder_eclient
*c
,
1022 disorder_eclient_no_response
*completed
,
1024 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1025 "random-disable", (char *)0);
1028 int disorder_eclient_get(disorder_eclient
*c
,
1029 disorder_eclient_string_response
*completed
,
1030 const char *track
, const char *pref
,
1032 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
1033 "get", track
, pref
, (char *)0);
1036 int disorder_eclient_set(disorder_eclient
*c
,
1037 disorder_eclient_no_response
*completed
,
1038 const char *track
, const char *pref
,
1041 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1042 "set", track
, pref
, value
, (char *)0);
1045 int disorder_eclient_unset(disorder_eclient
*c
,
1046 disorder_eclient_no_response
*completed
,
1047 const char *track
, const char *pref
,
1049 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1050 "unset", track
, pref
, (char *)0);
1053 int disorder_eclient_resolve(disorder_eclient
*c
,
1054 disorder_eclient_string_response
*completed
,
1057 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
1058 "resolve", track
, (char *)0);
1061 int disorder_eclient_search(disorder_eclient
*c
,
1062 disorder_eclient_list_response
*completed
,
1065 if(!split(terms
, 0, SPLIT_QUOTES
, 0, 0)) return -1;
1066 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
1067 "search", terms
, (char *)0);
1070 /* Log clients ***************************************************************/
1072 int disorder_eclient_log(disorder_eclient
*c
,
1073 const disorder_eclient_log_callbacks
*callbacks
,
1075 if(c
->log_callbacks
) return -1;
1076 c
->log_callbacks
= callbacks
;
1078 stash_command(c
, 0/*queuejump*/, log_opcallback
, 0/*completed*/, v
,
1083 /* If we get here we've stopped being a log client */
1084 static void log_opcallback(disorder_eclient
*c
,
1085 struct operation
attribute((unused
)) *op
) {
1086 D(("log_opcallback"));
1087 c
->log_callbacks
= 0;
1091 /* error callback for log line parsing */
1092 static void logline_error(const char *msg
, void *u
) {
1093 disorder_eclient
*c
= u
;
1094 protocol_error(c
, c
->ops
, -1, "error parsing log line: %s", msg
);
1097 /* process a single log line */
1098 static void logline(disorder_eclient
*c
, const char *line
) {
1103 D(("log_opcallback [%s]", line
));
1104 vec
= split(line
, &nvec
, SPLIT_QUOTES
, logline_error
, c
);
1105 if(nvec
< 2) return; /* probably an error, already
1107 if(sscanf(vec
[0], "%"SCNxMAX
, &when
) != 1) {
1108 /* probably the wrong side of a format change */
1109 protocol_error(c
, c
->ops
, -1, "invalid log timestamp '%s'", vec
[0]);
1112 /* TODO: do something with the time */
1113 n
= TABLE_FIND(logentry_handlers
, struct logentry_handler
, name
, vec
[1]);
1114 if(n
< 0) return; /* probably a future command */
1117 if(nvec
< logentry_handlers
[n
].min
|| nvec
> logentry_handlers
[n
].max
)
1119 logentry_handlers
[n
].handler(c
, nvec
, vec
);
1122 static void logentry_completed(disorder_eclient
*c
,
1123 int attribute((unused
)) nvec
, char **vec
) {
1124 if(!c
->log_callbacks
->completed
) return;
1125 c
->log_callbacks
->completed(c
->log_v
, vec
[0]);
1128 static void logentry_failed(disorder_eclient
*c
,
1129 int attribute((unused
)) nvec
, char **vec
) {
1130 if(!c
->log_callbacks
->failed
)return;
1131 c
->log_callbacks
->failed(c
->log_v
, vec
[0], vec
[1]);
1134 static void logentry_moved(disorder_eclient
*c
,
1135 int attribute((unused
)) nvec
, char **vec
) {
1136 if(!c
->log_callbacks
->moved
) return;
1137 c
->log_callbacks
->moved(c
->log_v
, vec
[0]);
1140 static void logentry_playing(disorder_eclient
*c
,
1141 int attribute((unused
)) nvec
, char **vec
) {
1142 if(!c
->log_callbacks
->playing
) return;
1143 c
->log_callbacks
->playing(c
->log_v
, vec
[0], vec
[1]);
1146 static void logentry_queue(disorder_eclient
*c
,
1147 int attribute((unused
)) nvec
, char **vec
) {
1148 struct queue_entry
*q
;
1150 if(!c
->log_callbacks
->completed
) return;
1151 q
= xmalloc(sizeof *q
);
1152 if(queue_unmarshall_vec(q
, nvec
, vec
, eclient_queue_error
, c
))
1154 c
->log_callbacks
->queue(c
->log_v
, q
);
1157 static void logentry_recent_added(disorder_eclient
*c
,
1158 int attribute((unused
)) nvec
, char **vec
) {
1159 struct queue_entry
*q
;
1161 if(!c
->log_callbacks
->recent_added
) return;
1162 q
= xmalloc(sizeof *q
);
1163 if(queue_unmarshall_vec(q
, nvec
, vec
, eclient_queue_error
, c
))
1165 c
->log_callbacks
->recent_added(c
->log_v
, q
);
1168 static void logentry_recent_removed(disorder_eclient
*c
,
1169 int attribute((unused
)) nvec
, char **vec
) {
1170 if(!c
->log_callbacks
->recent_removed
) return;
1171 c
->log_callbacks
->recent_removed(c
->log_v
, vec
[0]);
1174 static void logentry_removed(disorder_eclient
*c
,
1175 int attribute((unused
)) nvec
, char **vec
) {
1176 if(!c
->log_callbacks
->removed
) return;
1177 c
->log_callbacks
->removed(c
->log_v
, vec
[0], vec
[1]);
1180 static void logentry_scratched(disorder_eclient
*c
,
1181 int attribute((unused
)) nvec
, char **vec
) {
1182 if(!c
->log_callbacks
->scratched
) return;
1183 c
->log_callbacks
->scratched(c
->log_v
, vec
[0], vec
[1]);
1186 static const struct {
1189 const char *disable
;
1190 } statestrings
[] = {
1191 { DISORDER_PLAYING_ENABLED
, "enable_play", "disable_play" },
1192 { DISORDER_RANDOM_ENABLED
, "enable_random", "disable_random" },
1193 { DISORDER_TRACK_PAUSED
, "pause", "resume" },
1195 #define NSTATES (int)(sizeof states / sizeof *states)
1197 static void logentry_state(disorder_eclient
*c
,
1198 int attribute((unused
)) nvec
, char **vec
) {
1201 for(n
= 0; n
< NSTATES
; ++n
)
1202 if(!strcmp(vec
[0], statestrings
[n
].enable
)) {
1203 c
->statebits
|= statestrings
[n
].bit
;
1205 } else if(!strcmp(vec
[0], statestrings
[n
].disable
)) {
1206 c
->statebits
&= ~statestrings
[n
].bit
;
1209 if(!c
->log_callbacks
->state
) return;
1210 c
->log_callbacks
->state(c
->log_v
, c
->statebits
);
1213 static void logentry_volume(disorder_eclient
*c
,
1214 int attribute((unused
)) nvec
, char **vec
) {
1217 if(!c
->log_callbacks
->volume
) return;
1218 if(xstrtol(&l
, vec
[0], 0, 10)
1219 || xstrtol(&r
, vec
[1], 0, 10)
1220 || l
< 0 || l
> INT_MAX
1221 || r
< 0 || r
> INT_MAX
)
1223 c
->log_callbacks
->volume(c
->log_v
, (int)l
, (int)r
);
1231 indent-tabs-mode:nil
1234 /* arch-tag:61ONz2p/LWaDRnToGI2+fg */