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 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
20 /** @file lib/eclient.c
21 * @brief Client code for event-driven programs
26 #include <sys/types.h>
27 #include <sys/socket.h>
28 #include <netinet/in.h>
39 #include "configuration.h"
46 #include "inputline.h"
53 #include "client-common.h"
55 /* TODO: more commands */
57 /** @brief How often to send data to the server when receiving logs */
58 #define LOG_PROD_INTERVAL 10
60 /* Types *********************************************************************/
62 /** @brief Client state */
64 state_disconnected
, /**< @brief not connected */
65 state_connecting
, /**< @brief waiting for connect() */
66 state_connected
, /**< @brief connected but not authenticated */
67 state_idle
, /**< @brief not doing anything */
68 state_cmdresponse
, /**< @brief waiting for command resonse */
69 state_body
, /**< @brief accumulating body */
70 state_log
, /**< @brief monitoring log */
73 /** @brief Names for @ref client_state */
74 static const char *const states
[] = {
84 struct operation
; /* forward decl */
86 /** @brief Type of an operation callback */
87 typedef void operation_callback(disorder_eclient
*c
, struct operation
*op
);
89 /** @brief A pending operation.
91 * This can be either a command or part of the authentication protocol. In the
92 * former case new commands are appended to the list, in the latter case they
93 * are inserted at the front. */
95 struct operation
*next
; /**< @brief next operation */
96 char *cmd
; /**< @brief command to send or 0 */
97 operation_callback
*opcallback
; /**< @brief internal completion callback */
98 void (*completed
)(); /**< @brief user completion callback or 0 */
99 void *v
; /**< @brief data for COMPLETED */
100 disorder_eclient
*client
; /**< @brief owning client */
102 /** @brief true if sent to server
104 * This is cleared by disorder_eclient_close(), forcing all queued
105 * commands to be transparently resent.
110 /** @brief Client structure */
111 struct disorder_eclient
{
113 int fd
; /**< @brief connection to server */
114 enum client_state state
; /**< @brief current state */
115 int authenticated
; /**< @brief true when authenicated */
116 struct dynstr output
; /**< @brief output buffer */
117 struct dynstr input
; /**< @brief input buffer */
118 int eof
; /**< @brief input buffer is at EOF */
119 const disorder_eclient_callbacks
*callbacks
; /**< @brief error callbacks */
120 void *u
; /**< @brief user data */
121 struct operation
*ops
; /**< @brief queue of operations */
122 struct operation
**opstail
; /**< @brief queue tail */
123 /* accumulated response */
124 int rc
; /**< @brief response code */
125 char *line
; /**< @brief complete line */
126 struct vector vec
; /**< @brief body */
128 const disorder_eclient_log_callbacks
*log_callbacks
;
129 /**< @brief log callbacks
131 * Once disorder_eclient_log() has been issued this is always set. When we
132 * re-connect it is checked to re-issue the log command.
134 void *log_v
; /**< @brief user data */
135 unsigned long statebits
; /**< @brief latest state */
138 /**< @brief last time we sent a prod
140 * When we are receiving log data we send a "prod" byte to the server from
141 * time to time so that we detect broken connections reasonably quickly. The
142 * server just ignores these bytes.
145 /** @brief Protocol version */
149 /* Forward declarations ******************************************************/
151 static int start_connect(disorder_eclient
*c
);
152 static void process_line(disorder_eclient
*c
, char *line
);
153 static void maybe_connected(disorder_eclient
*c
);
154 static void authbanner_opcallback(disorder_eclient
*c
,
155 struct operation
*op
);
156 static void authuser_opcallback(disorder_eclient
*c
,
157 struct operation
*op
);
158 static void complete(disorder_eclient
*c
);
159 static void send_output(disorder_eclient
*c
);
160 static void put(disorder_eclient
*c
, const char *s
, size_t n
);
161 static void read_input(disorder_eclient
*c
);
162 static void stash_command(disorder_eclient
*c
,
164 operation_callback
*opcallback
,
169 static void log_opcallback(disorder_eclient
*c
, struct operation
*op
);
170 static void logline(disorder_eclient
*c
, const char *line
);
171 static void logentry_completed(disorder_eclient
*c
, int nvec
, char **vec
);
172 static void logentry_failed(disorder_eclient
*c
, int nvec
, char **vec
);
173 static void logentry_moved(disorder_eclient
*c
, int nvec
, char **vec
);
174 static void logentry_playing(disorder_eclient
*c
, int nvec
, char **vec
);
175 static void logentry_queue(disorder_eclient
*c
, int nvec
, char **vec
);
176 static void logentry_recent_added(disorder_eclient
*c
, int nvec
, char **vec
);
177 static void logentry_recent_removed(disorder_eclient
*c
, int nvec
, char **vec
);
178 static void logentry_removed(disorder_eclient
*c
, int nvec
, char **vec
);
179 static void logentry_scratched(disorder_eclient
*c
, int nvec
, char **vec
);
180 static void logentry_state(disorder_eclient
*c
, int nvec
, char **vec
);
181 static void logentry_volume(disorder_eclient
*c
, int nvec
, char **vec
);
182 static void logentry_rescanned(disorder_eclient
*c
, int nvec
, char **vec
);
184 /* Tables ********************************************************************/
186 /** @brief One possible log entry */
187 struct logentry_handler
{
188 const char *name
; /**< @brief Entry name */
189 int min
; /**< @brief Minimum arguments */
190 int max
; /**< @brief Maximum arguments */
191 void (*handler
)(disorder_eclient
*c
,
193 char **vec
); /**< @brief Handler function */
196 /** @brief Table for parsing log entries */
197 static const struct logentry_handler logentry_handlers
[] = {
198 #define LE(X, MIN, MAX) { #X, MIN, MAX, logentry_##X }
203 LE(queue
, 2, INT_MAX
),
204 LE(recent_added
, 2, INT_MAX
),
205 LE(recent_removed
, 1, 1),
213 /* Setup and teardown ********************************************************/
215 /** @brief Create a new client
217 * Does NOT connect the client - connections are made (and re-made) on demand.
219 disorder_eclient
*disorder_eclient_new(const disorder_eclient_callbacks
*cb
,
221 disorder_eclient
*c
= xmalloc(sizeof *c
);
222 D(("disorder_eclient_new"));
226 c
->opstail
= &c
->ops
;
227 vector_init(&c
->vec
);
228 dynstr_init(&c
->input
);
229 dynstr_init(&c
->output
);
233 /** @brief Disconnect a client
234 * @param c Client to disconnect
236 * NB that this routine just disconnnects the TCP connection. It does not
237 * destroy the client! If you continue to use it then it will attempt to
240 void disorder_eclient_close(disorder_eclient
*c
) {
241 struct operation
*op
;
243 D(("disorder_eclient_close"));
245 D(("disorder_eclient_close closing fd %d", c
->fd
));
246 c
->callbacks
->poll(c
->u
, c
, c
->fd
, 0);
249 c
->state
= state_disconnected
;
255 c
->authenticated
= 0;
256 /* We'll need to resend all operations */
257 for(op
= c
->ops
; op
; op
= op
->next
)
259 /* Drop our use a hint that we're disconnected */
260 if(c
->log_callbacks
&& c
->log_callbacks
->state
)
261 c
->log_callbacks
->state(c
->log_v
, c
->statebits
);
264 /** @brief Return current state */
265 unsigned long disorder_eclient_state(const disorder_eclient
*c
) {
266 return c
->statebits
| (c
->state
> state_connected ? DISORDER_CONNECTED
: 0);
269 /* Error reporting ***********************************************************/
271 /** @brief called when a connection error occurs
273 * After this called we will be disconnected (by disorder_eclient_close()),
274 * so there will be a reconnection before any commands can be sent.
276 static int comms_error(disorder_eclient
*c
, const char *fmt
, ...) {
282 byte_xvasprintf(&s
, fmt
, ap
);
284 disorder_eclient_close(c
);
285 c
->callbacks
->comms_error(c
->u
, s
);
289 /** @brief called when the server reports an error */
290 static int protocol_error(disorder_eclient
*c
, struct operation
*op
,
291 int code
, const char *fmt
, ...) {
295 D(("protocol_error"));
297 byte_xvasprintf(&s
, fmt
, ap
);
299 c
->callbacks
->protocol_error(c
->u
, op
->v
, code
, s
);
303 /* State machine *************************************************************/
305 /** @brief Called when there's something to do
307 * @param mode bitmap of @ref DISORDER_POLL_READ and/or @ref DISORDER_POLL_WRITE.
309 * This should be called from by your code when the file descriptor is readable
310 * or writable (as requested by the @c poll callback, see @ref
311 * disorder_eclient_callbacks) and in any case from time to time (with @p mode
312 * = 0) to allow for retries to work.
314 void disorder_eclient_polled(disorder_eclient
*c
, unsigned mode
) {
315 struct operation
*op
;
318 D(("disorder_eclient_polled fd=%d state=%s mode=[%s %s]",
319 c
->fd
, states
[c
->state
],
320 mode
& DISORDER_POLL_READ ?
"READ" : "",
321 mode
& DISORDER_POLL_WRITE ?
"WRITE" : ""));
322 /* The pattern here is to check each possible state in turn and try to
323 * advance (though on error we might go back). If we advance we leave open
324 * the possibility of falling through to the next state, but we set the mode
325 * bits to 0, to avoid false positives (which matter more in some cases than
328 if(c
->state
== state_disconnected
) {
329 D(("state_disconnected"));
330 /* If there is no password yet then we cannot connect */
331 if(!config
->password
) {
332 comms_error(c
, "no password is configured");
336 /* might now be state_disconnected (on error), state_connecting (slow
337 * connect) or state_connected (fast connect). If state_disconnected then
338 * we just rely on a periodic callback from the event loop sometime. */
342 if(c
->state
== state_connecting
&& mode
) {
343 D(("state_connecting"));
345 /* Might be state_disconnected (on error) or state_connected (on success).
346 * In the former case we rely on the event loop for a periodic callback to
351 if(c
->state
== state_connected
) {
352 D(("state_connected"));
353 /* We just connected. Initiate the authentication protocol. */
354 stash_command(c
, 1/*queuejump*/, authbanner_opcallback
,
355 0/*completed*/, 0/*v*/, 0/*cmd*/);
356 /* We never stay is state_connected very long. We could in principle jump
357 * straight to state_cmdresponse since there's actually no command to
358 * send, but that would arguably be cheating. */
359 c
->state
= state_idle
;
362 if(c
->state
== state_idle
) {
364 /* We are connected, and have finished any command we set off, look for
368 if(c
->authenticated
) {
369 /* Transmit all unsent operations */
370 for(op
= c
->ops
; op
; op
= op
->next
) {
372 put(c
, op
->cmd
, strlen(op
->cmd
));
377 /* Just send the head operation */
378 if(c
->ops
->cmd
&& !c
->ops
->sent
) {
379 put(c
, c
->ops
->cmd
, strlen(c
->ops
->cmd
));
383 /* Awaiting response for the operation at the head of the list */
384 c
->state
= state_cmdresponse
;
387 c
->callbacks
->report(c
->u
, 0);
390 /* Queue up a byte to send */
391 if(c
->state
== state_log
392 && c
->output
.nvec
== 0
393 && time(&now
) - c
->last_prod
> LOG_PROD_INTERVAL
) {
398 if(c
->state
== state_cmdresponse
399 || c
->state
== state_body
400 || c
->state
== state_log
) {
401 D(("state_%s", states
[c
->state
]));
402 /* We are awaiting a response */
403 if(mode
& DISORDER_POLL_WRITE
) send_output(c
);
404 if(mode
& DISORDER_POLL_READ
) read_input(c
);
405 /* There are a couple of reasons we might want to re-enter the state
406 * machine from the top. state_idle is obvious: there may be further
407 * commands to process. Re-entering on state_disconnected means that we
408 * immediately retry connection if a comms error occurs during a command.
409 * This is different to the case where a connection fails, where we await a
410 * spontaneous call to initiate the retry. */
412 case state_disconnected
: /* lost connection */
413 case state_idle
: /* completed a command */
415 disorder_eclient_polled(c
, 0);
422 /* Figure out what to set the mode to */
424 case state_disconnected
:
425 D(("state_disconnected (2)"));
426 /* Probably an error occurred. Await a retry. */
429 case state_connecting
:
430 D(("state_connecting (2)"));
431 /* Waiting for connect to complete */
432 mode
= DISORDER_POLL_READ
|DISORDER_POLL_WRITE
;
434 case state_connected
:
435 D(("state_connected (2)"));
436 assert(!"should never be in state_connected here");
439 D(("state_idle (2)"));
440 /* Connected but nothing to do. */
443 case state_cmdresponse
:
446 D(("state_%s (2)", states
[c
->state
]));
447 /* Gathering a response. Wait for input. */
448 mode
= DISORDER_POLL_READ
;
449 /* Flush any pending output. */
450 if(c
->output
.nvec
) mode
|= DISORDER_POLL_WRITE
;
453 D(("fd=%d new mode [%s %s]",
455 mode
& DISORDER_POLL_READ ?
"READ" : "",
456 mode
& DISORDER_POLL_WRITE ?
"WRITE" : ""));
457 if(c
->fd
!= -1) c
->callbacks
->poll(c
->u
, c
, c
->fd
, mode
);
460 /** @brief Called to start connecting */
461 static int start_connect(disorder_eclient
*c
) {
465 D(("start_connect"));
466 if((len
= find_server(&sa
, &c
->ident
)) == (socklen_t
)-1)
467 return comms_error(c
, "cannot look up server"); /* TODO better error */
472 if((c
->fd
= socket(sa
->sa_family
, SOCK_STREAM
, 0)) < 0)
473 return comms_error(c
, "socket: %s", strerror(errno
));
477 if(connect(c
->fd
, sa
, len
) < 0) {
481 c
->state
= state_connecting
;
482 /* We are called from _polled so the state machine will get to do its
486 /* Signal the error to the caller. */
487 return comms_error(c
, "connecting to %s: %s", c
->ident
, strerror(errno
));
490 c
->state
= state_connected
;
494 /** @brief Called when poll triggers while waiting for a connection */
495 static void maybe_connected(disorder_eclient
*c
) {
496 /* We either connected, or got an error. */
498 socklen_t len
= sizeof err
;
500 D(("maybe_connected"));
501 /* Work around over-enthusiastic error slippage */
502 if(getsockopt(c
->fd
, SOL_SOCKET
, SO_ERROR
, &err
, &len
) < 0)
505 /* The connection failed */
506 comms_error(c
, "connecting to %s: %s", c
->ident
, strerror(err
));
507 /* sets state_disconnected */
511 /* The connection succeeded */
512 c
->state
= state_connected
;
513 byte_xasprintf(&r
, "connected to %s", c
->ident
);
514 c
->callbacks
->report(c
->u
, r
);
515 /* If this is a log client we expect to get a bunch of updates from the
516 * server straight away */
520 /* Authentication ************************************************************/
522 static void authbanner_opcallback(disorder_eclient
*c
,
523 struct operation
*op
) {
525 const unsigned char *nonce
;
529 const char *protocol
, *algorithm
, *challenge
;
531 D(("authbanner_opcallback"));
533 || !(rvec
= split(c
->line
+ 4, &nrvec
, SPLIT_QUOTES
, 0, 0))
535 /* Banner told us to go away, or was malformed. We cannot proceed. */
536 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
537 disorder_eclient_close(c
);
557 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
558 disorder_eclient_close(c
);
561 c
->protocol
= atoi(protocol
);
562 if(c
->protocol
< 1 || c
->protocol
> 2) {
563 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
564 disorder_eclient_close(c
);
567 nonce
= unhex(challenge
, &nonce_len
);
568 res
= authhash(nonce
, nonce_len
, config
->password
, algorithm
);
570 protocol_error(c
, op
, c
->rc
, "%s: unknown authentication algorithm '%s'",
571 c
->ident
, algorithm
);
572 disorder_eclient_close(c
);
575 stash_command(c
, 1/*queuejump*/, authuser_opcallback
, 0/*completed*/, 0/*v*/,
576 "user", quoteutf8(config
->username
), quoteutf8(res
),
580 static void authuser_opcallback(disorder_eclient
*c
,
581 struct operation
*op
) {
584 D(("authuser_opcallback"));
585 if(c
->rc
/ 100 != 2) {
586 /* Wrong password or something. We cannot proceed. */
587 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
588 disorder_eclient_close(c
);
591 /* OK, we're authenticated now. */
592 c
->authenticated
= 1;
593 byte_xasprintf(&r
, "authenticated with %s", c
->ident
);
594 c
->callbacks
->report(c
->u
, r
);
595 if(c
->log_callbacks
&& !(c
->ops
&& c
->ops
->opcallback
== log_opcallback
))
596 /* We are a log client, switch to logging mode */
597 stash_command(c
, 0/*queuejump*/, log_opcallback
, 0/*completed*/, c
->log_v
,
601 /* Output ********************************************************************/
603 /* Chop N bytes off the front of a dynstr */
604 static void consume(struct dynstr
*d
, int n
) {
605 D(("consume %d", n
));
606 assert(d
->nvec
>= n
);
607 memmove(d
->vec
, d
->vec
+ n
, d
->nvec
- n
);
611 /* Write some bytes */
612 static void put(disorder_eclient
*c
, const char *s
, size_t n
) {
613 D(("put %d %.*s", c
->fd
, (int)n
, s
));
614 dynstr_append_bytes(&c
->output
, s
, n
);
617 /* Called when we can write to our FD, or at any other time */
618 static void send_output(disorder_eclient
*c
) {
621 D(("send_output %d bytes pending", c
->output
.nvec
));
622 if(c
->state
> state_connecting
&& c
->output
.nvec
) {
623 n
= write(c
->fd
, c
->output
.vec
, c
->output
.nvec
);
630 comms_error(c
, "writing to %s: %s", c
->ident
, strerror(errno
));
634 consume(&c
->output
, n
);
638 /* Input *********************************************************************/
640 /* Called when c->fd might be readable, or at any other time */
641 static void read_input(disorder_eclient
*c
) {
646 D(("read_input in state %s", states
[c
->state
]));
647 if(c
->state
<= state_connected
) return; /* ignore bogus calls */
648 /* read some more input */
649 n
= read(c
->fd
, buffer
, sizeof buffer
);
656 comms_error(c
, "reading from %s: %s", c
->ident
, strerror(errno
));
659 return; /* no new input to process */
661 D(("read %d bytes: [%.*s]", n
, n
, buffer
));
662 dynstr_append_bytes(&c
->input
, buffer
, n
);
665 /* might have more than one line to process */
666 while(c
->state
> state_connecting
667 && (nl
= memchr(c
->input
.vec
, '\n', c
->input
.nvec
))) {
668 process_line(c
, xstrndup(c
->input
.vec
, nl
- c
->input
.vec
));
669 /* we might have disconnected along the way, which zogs the input buffer */
670 if(c
->state
> state_connecting
)
671 consume(&c
->input
, (nl
- c
->input
.vec
) + 1);
674 comms_error(c
, "reading from %s: server disconnected", c
->ident
);
675 c
->authenticated
= 0;
679 /* called with a line that has just been read */
680 static void process_line(disorder_eclient
*c
, char *line
) {
681 D(("process_line %d [%s]", c
->fd
, line
));
683 case state_cmdresponse
:
684 /* This is the first line of a response */
685 if(!(line
[0] >= '0' && line
[0] <= '9'
686 && line
[1] >= '0' && line
[1] <= '9'
687 && line
[2] >= '0' && line
[2] <= '9'
689 fatal(0, "invalid response from server: %s", line
);
690 c
->rc
= (line
[0] * 10 + line
[1]) * 10 + line
[2] - 111 * '0';
694 /* We need to collect the body. */
695 c
->state
= state_body
;
696 vector_init(&c
->vec
);
699 assert(c
->log_callbacks
!= 0);
700 if(c
->log_callbacks
->connected
)
701 c
->log_callbacks
->connected(c
->log_v
);
702 c
->state
= state_log
;
705 /* We've got the whole response. Go into the idle state so the state
706 * machine knows we're done and then call the operation callback. */
712 if(strcmp(line
, ".")) {
713 /* A line from the body */
714 vector_append(&c
->vec
, line
+ (line
[0] == '.'));
716 /* End of the body. */
717 vector_terminate(&c
->vec
);
722 if(strcmp(line
, ".")) {
723 logline(c
, line
+ (line
[0] == '.'));
728 assert(!"wrong state for location");
733 /* Called when an operation completes */
734 static void complete(disorder_eclient
*c
) {
735 struct operation
*op
;
738 /* Pop the operation off the queue */
741 if(c
->opstail
== &op
->next
)
742 c
->opstail
= &c
->ops
;
743 /* If we've pipelined a command ahead then we go straight to cmdresponser.
744 * Otherwise we go to idle, which will arrange further sends. */
745 c
->state
= c
->ops
&& c
->ops
->sent ? state_cmdresponse
: state_idle
;
746 op
->opcallback(c
, op
);
747 /* Note that we always call the opcallback even on error, though command
748 * opcallbacks generally always do the same error handling, i.e. just call
749 * protocol_error(). It's the auth* opcallbacks that have different
753 /* Operation setup ***********************************************************/
755 static void stash_command_vector(disorder_eclient
*c
,
757 operation_callback
*opcallback
,
762 struct operation
*op
= xmalloc(sizeof *op
);
768 for(n
= 0; n
< ncmd
; ++n
) {
770 dynstr_append(&d
, ' ');
771 dynstr_append_string(&d
, quoteutf8(cmd
[n
]));
773 dynstr_append(&d
, '\n');
774 dynstr_terminate(&d
);
777 op
->cmd
= 0; /* usually, awaiting challenge */
778 op
->opcallback
= opcallback
;
779 op
->completed
= completed
;
783 assert(op
->sent
== 0);
785 /* Authentication operations jump the queue of useful commands */
788 if(c
->opstail
== &c
->ops
)
789 c
->opstail
= &op
->next
;
790 for(op
= c
->ops
; op
; op
= op
->next
)
794 c
->opstail
= &op
->next
;
798 static void vstash_command(disorder_eclient
*c
,
800 operation_callback
*opcallback
,
803 const char *cmd
, va_list ap
) {
807 D(("vstash_command %s", cmd ? cmd
: "NULL"));
810 vector_append(&vec
, (char *)cmd
);
811 while((arg
= va_arg(ap
, char *)))
812 vector_append(&vec
, arg
);
813 stash_command_vector(c
, queuejump
, opcallback
, completed
, v
,
816 stash_command_vector(c
, queuejump
, opcallback
, completed
, v
, 0, 0);
819 static void stash_command(disorder_eclient
*c
,
821 operation_callback
*opcallback
,
829 vstash_command(c
, queuejump
, opcallback
, completed
, v
, cmd
, ap
);
833 /* Command support ***********************************************************/
835 /* for commands with a quoted string response */
836 static void string_response_opcallback(disorder_eclient
*c
,
837 struct operation
*op
) {
838 D(("string_response_callback"));
839 if(c
->rc
/ 100 == 2 || c
->rc
== 555) {
842 ((disorder_eclient_string_response
*)op
->completed
)(op
->v
, NULL
);
843 else if(c
->protocol
>= 2) {
844 char **rr
= split(c
->line
+ 4, 0, SPLIT_QUOTES
, 0, 0);
847 ((disorder_eclient_string_response
*)op
->completed
)(op
->v
, *rr
);
849 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
851 ((disorder_eclient_string_response
*)op
->completed
)(op
->v
,
855 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
858 /* for commands with a simple integer response */
859 static void integer_response_opcallback(disorder_eclient
*c
,
860 struct operation
*op
) {
861 D(("string_response_callback"));
862 if(c
->rc
/ 100 == 2) {
864 ((disorder_eclient_integer_response
*)op
->completed
)
865 (op
->v
, strtol(c
->line
+ 4, 0, 10));
867 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
870 /* for commands with no response */
871 static void no_response_opcallback(disorder_eclient
*c
,
872 struct operation
*op
) {
873 D(("no_response_callback"));
874 if(c
->rc
/ 100 == 2) {
876 ((disorder_eclient_no_response
*)op
->completed
)(op
->v
);
878 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
881 /* error callback for queue_unmarshall */
882 static void eclient_queue_error(const char *msg
,
884 struct operation
*op
= u
;
886 protocol_error(op
->client
, op
, -1, "error parsing queue entry: %s", msg
);
889 /* for commands that expect a queue dump */
890 static void queue_response_opcallback(disorder_eclient
*c
,
891 struct operation
*op
) {
893 struct queue_entry
*q
, *qh
= 0, **qtail
= &qh
, *qlast
= 0;
895 D(("queue_response_callback"));
896 if(c
->rc
/ 100 == 2) {
897 /* parse the queue */
898 for(n
= 0; n
< c
->vec
.nvec
; ++n
) {
899 q
= xmalloc(sizeof *q
);
900 D(("queue_unmarshall %s", c
->vec
.vec
[n
]));
901 if(!queue_unmarshall(q
, c
->vec
.vec
[n
], eclient_queue_error
, op
)) {
909 ((disorder_eclient_queue_response
*)op
->completed
)(op
->v
, qh
);
911 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
915 static void playing_response_opcallback(disorder_eclient
*c
,
916 struct operation
*op
) {
917 struct queue_entry
*q
;
919 D(("playing_response_callback"));
920 if(c
->rc
/ 100 == 2) {
923 if(queue_unmarshall(q
= xmalloc(sizeof *q
), c
->line
+ 4,
924 eclient_queue_error
, c
))
931 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
935 ((disorder_eclient_queue_response
*)op
->completed
)(op
->v
, q
);
937 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
940 /* for commands that expect a list of some sort */
941 static void list_response_opcallback(disorder_eclient
*c
,
942 struct operation
*op
) {
943 D(("list_response_callback"));
944 if(c
->rc
/ 100 == 2) {
946 ((disorder_eclient_list_response
*)op
->completed
)(op
->v
,
950 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
954 static void volume_response_opcallback(disorder_eclient
*c
,
955 struct operation
*op
) {
958 D(("volume_response_callback"));
959 if(c
->rc
/ 100 == 2) {
961 if(sscanf(c
->line
+ 4, "%d %d", &l
, &r
) != 2 || l
< 0 || r
< 0)
962 protocol_error(c
, op
, -1, "%s: invalid volume response: %s",
965 ((disorder_eclient_volume_response
*)op
->completed
)(op
->v
, l
, r
);
968 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
971 static int simple(disorder_eclient
*c
,
972 operation_callback
*opcallback
,
975 const char *cmd
, ...) {
979 vstash_command(c
, 0/*queuejump*/, opcallback
, completed
, v
, cmd
, ap
);
981 /* Give the state machine a kick, since we might be in state_idle */
982 disorder_eclient_polled(c
, 0);
986 /* Commands ******************************************************************/
988 int disorder_eclient_version(disorder_eclient
*c
,
989 disorder_eclient_string_response
*completed
,
991 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
992 "version", (char *)0);
995 int disorder_eclient_namepart(disorder_eclient
*c
,
996 disorder_eclient_string_response
*completed
,
1001 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
1002 "part", track
, context
, part
, (char *)0);
1005 int disorder_eclient_play(disorder_eclient
*c
,
1007 disorder_eclient_no_response
*completed
,
1009 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1010 "play", track
, (char *)0);
1013 int disorder_eclient_pause(disorder_eclient
*c
,
1014 disorder_eclient_no_response
*completed
,
1016 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1017 "pause", (char *)0);
1020 int disorder_eclient_resume(disorder_eclient
*c
,
1021 disorder_eclient_no_response
*completed
,
1023 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1024 "resume", (char *)0);
1027 int disorder_eclient_scratch(disorder_eclient
*c
,
1029 disorder_eclient_no_response
*completed
,
1031 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1032 "scratch", id
, (char *)0);
1035 int disorder_eclient_scratch_playing(disorder_eclient
*c
,
1036 disorder_eclient_no_response
*completed
,
1038 return disorder_eclient_scratch(c
, 0, completed
, v
);
1041 int disorder_eclient_remove(disorder_eclient
*c
,
1043 disorder_eclient_no_response
*completed
,
1045 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1046 "remove", id
, (char *)0);
1049 int disorder_eclient_moveafter(disorder_eclient
*c
,
1053 disorder_eclient_no_response
*completed
,
1059 vector_append(&vec
, (char *)"moveafter");
1060 vector_append(&vec
, (char *)target
);
1061 for(n
= 0; n
< nids
; ++n
)
1062 vector_append(&vec
, (char *)ids
[n
]);
1063 stash_command_vector(c
, 0/*queuejump*/, no_response_opcallback
, completed
, v
,
1065 disorder_eclient_polled(c
, 0);
1069 int disorder_eclient_recent(disorder_eclient
*c
,
1070 disorder_eclient_queue_response
*completed
,
1072 return simple(c
, queue_response_opcallback
, (void (*)())completed
, v
,
1073 "recent", (char *)0);
1076 int disorder_eclient_queue(disorder_eclient
*c
,
1077 disorder_eclient_queue_response
*completed
,
1079 return simple(c
, queue_response_opcallback
, (void (*)())completed
, v
,
1080 "queue", (char *)0);
1083 int disorder_eclient_files(disorder_eclient
*c
,
1084 disorder_eclient_list_response
*completed
,
1088 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
1089 "files", dir
, re
, (char *)0);
1092 int disorder_eclient_dirs(disorder_eclient
*c
,
1093 disorder_eclient_list_response
*completed
,
1097 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
1098 "dirs", dir
, re
, (char *)0);
1101 int disorder_eclient_playing(disorder_eclient
*c
,
1102 disorder_eclient_queue_response
*completed
,
1104 return simple(c
, playing_response_opcallback
, (void (*)())completed
, v
,
1105 "playing", (char *)0);
1108 int disorder_eclient_length(disorder_eclient
*c
,
1109 disorder_eclient_integer_response
*completed
,
1112 return simple(c
, integer_response_opcallback
, (void (*)())completed
, v
,
1113 "length", track
, (char *)0);
1116 int disorder_eclient_volume(disorder_eclient
*c
,
1117 disorder_eclient_volume_response
*completed
,
1120 char sl
[64], sr
[64];
1122 if(l
< 0 && r
< 0) {
1123 return simple(c
, volume_response_opcallback
, (void (*)())completed
, v
,
1124 "volume", (char *)0);
1125 } else if(l
>= 0 && r
>= 0) {
1128 byte_snprintf(sl
, sizeof sl
, "%d", l
);
1129 byte_snprintf(sr
, sizeof sr
, "%d", r
);
1130 return simple(c
, volume_response_opcallback
, (void (*)())completed
, v
,
1131 "volume", sl
, sr
, (char *)0);
1133 assert(!"invalid arguments to disorder_eclient_volume");
1134 return -1; /* gcc is being dim */
1138 int disorder_eclient_enable(disorder_eclient
*c
,
1139 disorder_eclient_no_response
*completed
,
1141 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1142 "enable", (char *)0);
1145 int disorder_eclient_disable(disorder_eclient
*c
,
1146 disorder_eclient_no_response
*completed
,
1148 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1149 "disable", (char *)0);
1152 int disorder_eclient_random_enable(disorder_eclient
*c
,
1153 disorder_eclient_no_response
*completed
,
1155 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1156 "random-enable", (char *)0);
1159 int disorder_eclient_random_disable(disorder_eclient
*c
,
1160 disorder_eclient_no_response
*completed
,
1162 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1163 "random-disable", (char *)0);
1166 int disorder_eclient_get(disorder_eclient
*c
,
1167 disorder_eclient_string_response
*completed
,
1168 const char *track
, const char *pref
,
1170 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
1171 "get", track
, pref
, (char *)0);
1174 int disorder_eclient_set(disorder_eclient
*c
,
1175 disorder_eclient_no_response
*completed
,
1176 const char *track
, const char *pref
,
1179 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1180 "set", track
, pref
, value
, (char *)0);
1183 int disorder_eclient_unset(disorder_eclient
*c
,
1184 disorder_eclient_no_response
*completed
,
1185 const char *track
, const char *pref
,
1187 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1188 "unset", track
, pref
, (char *)0);
1191 int disorder_eclient_resolve(disorder_eclient
*c
,
1192 disorder_eclient_string_response
*completed
,
1195 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
1196 "resolve", track
, (char *)0);
1199 int disorder_eclient_search(disorder_eclient
*c
,
1200 disorder_eclient_list_response
*completed
,
1203 if(!split(terms
, 0, SPLIT_QUOTES
, 0, 0)) return -1;
1204 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
1205 "search", terms
, (char *)0);
1208 int disorder_eclient_nop(disorder_eclient
*c
,
1209 disorder_eclient_no_response
*completed
,
1211 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1215 /** @brief Get the last @p max added tracks
1217 * @param completed Called with list
1218 * @param max Number of tracks to get, 0 for all
1219 * @param v Passed to @p completed
1221 * The first track in the list is the most recently added.
1223 int disorder_eclient_new_tracks(disorder_eclient
*c
,
1224 disorder_eclient_list_response
*completed
,
1229 sprintf(limit
, "%d", max
);
1230 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
1231 "new", limit
, (char *)0);
1234 static void rtp_response_opcallback(disorder_eclient
*c
,
1235 struct operation
*op
) {
1236 D(("rtp_response_opcallback"));
1237 if(c
->rc
/ 100 == 2) {
1240 char **vec
= split(c
->line
+ 4, &nvec
, SPLIT_QUOTES
, 0, 0);
1242 ((disorder_eclient_list_response
*)op
->completed
)(op
->v
, nvec
, vec
);
1245 protocol_error(c
, op
, c
->rc
, "%s: %s", c
->ident
, c
->line
);
1248 /** @brief Determine the RTP target address
1250 * @param completed Called with address details
1251 * @param v Passed to @p completed
1253 * The address details will be two elements, the first being the hostname and
1254 * the second the service (port).
1256 int disorder_eclient_rtp_address(disorder_eclient
*c
,
1257 disorder_eclient_list_response
*completed
,
1259 return simple(c
, rtp_response_opcallback
, (void (*)())completed
, v
,
1260 "rtp-address", (char *)0);
1263 /** @brief Get the list of users
1265 * @param completed Called with list of users
1266 * @param v Passed to @p completed
1268 * The user list is not sorted in any particular order.
1270 int disorder_eclient_users(disorder_eclient
*c
,
1271 disorder_eclient_list_response
*completed
,
1273 return simple(c
, list_response_opcallback
, (void (*)())completed
, v
,
1274 "users", (char *)0);
1277 /** @brief Delete a user
1279 * @param completed Called on completion
1280 * @param user User to delete
1281 * @param v Passed to @p completed
1283 int disorder_eclient_deluser(disorder_eclient
*c
,
1284 disorder_eclient_no_response
*completed
,
1287 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1288 "deluser", user
, (char *)0);
1291 /** @brief Get a user property
1293 * @param completed Called on completion
1294 * @param user User to look up
1295 * @param property Property to look up
1296 * @param v Passed to @p completed
1298 int disorder_eclient_userinfo(disorder_eclient
*c
,
1299 disorder_eclient_string_response
*completed
,
1301 const char *property
,
1303 return simple(c
, string_response_opcallback
, (void (*)())completed
, v
,
1304 "userinfo", user
, property
, (char *)0);
1307 /** @brief Modify a user property
1309 * @param completed Called on completion
1310 * @param user User to modify
1311 * @param property Property to modify
1312 * @param value New property value
1313 * @param v Passed to @p completed
1315 int disorder_eclient_edituser(disorder_eclient
*c
,
1316 disorder_eclient_no_response
*completed
,
1318 const char *property
,
1321 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1322 "edituser", user
, property
, value
, (char *)0);
1325 /** @brief Create a new user
1327 * @param completed Called on completion
1328 * @param user User to create
1329 * @param password Initial password
1330 * @param rights Initial rights or NULL
1331 * @param v Passed to @p completed
1333 int disorder_eclient_adduser(disorder_eclient
*c
,
1334 disorder_eclient_no_response
*completed
,
1336 const char *password
,
1339 return simple(c
, no_response_opcallback
, (void (*)())completed
, v
,
1340 "adduser", user
, password
, rights
, (char *)0);
1343 /* Log clients ***************************************************************/
1345 /** @brief Monitor the server log
1347 * @param callbacks Functions to call when anything happens
1348 * @param v Passed to @p callbacks functions
1350 * Once a client is being used for logging it cannot be used for anything else.
1351 * There is magic in authuser_opcallback() to re-submit the @c log command
1352 * after reconnection.
1354 * NB that the @c state callback may be called from within this function,
1355 * i.e. not solely later on from the event loop callback.
1357 int disorder_eclient_log(disorder_eclient
*c
,
1358 const disorder_eclient_log_callbacks
*callbacks
,
1360 if(c
->log_callbacks
) return -1;
1361 c
->log_callbacks
= callbacks
;
1363 /* Repoort initial state */
1364 if(c
->log_callbacks
->state
)
1365 c
->log_callbacks
->state(c
->log_v
, c
->statebits
);
1366 stash_command(c
, 0/*queuejump*/, log_opcallback
, 0/*completed*/, v
,
1368 disorder_eclient_polled(c
, 0);
1372 /* If we get here we've stopped being a log client */
1373 static void log_opcallback(disorder_eclient
*c
,
1374 struct operation
attribute((unused
)) *op
) {
1375 D(("log_opcallback"));
1376 c
->log_callbacks
= 0;
1380 /* error callback for log line parsing */
1381 static void logline_error(const char *msg
, void *u
) {
1382 disorder_eclient
*c
= u
;
1383 protocol_error(c
, c
->ops
, -1, "error parsing log line: %s", msg
);
1386 /* process a single log line */
1387 static void logline(disorder_eclient
*c
, const char *line
) {
1392 D(("logline [%s]", line
));
1393 vec
= split(line
, &nvec
, SPLIT_QUOTES
, logline_error
, c
);
1394 if(nvec
< 2) return; /* probably an error, already
1396 if(sscanf(vec
[0], "%"SCNxMAX
, &when
) != 1) {
1397 /* probably the wrong side of a format change */
1398 protocol_error(c
, c
->ops
, -1, "invalid log timestamp '%s'", vec
[0]);
1401 /* TODO: do something with the time */
1402 n
= TABLE_FIND(logentry_handlers
, name
, vec
[1]);
1403 if(n
< 0) return; /* probably a future command */
1406 if(nvec
< logentry_handlers
[n
].min
|| nvec
> logentry_handlers
[n
].max
)
1408 logentry_handlers
[n
].handler(c
, nvec
, vec
);
1411 static void logentry_completed(disorder_eclient
*c
,
1412 int attribute((unused
)) nvec
, char **vec
) {
1413 c
->statebits
&= ~DISORDER_PLAYING
;
1414 if(c
->log_callbacks
->completed
)
1415 c
->log_callbacks
->completed(c
->log_v
, vec
[0]);
1416 if(c
->log_callbacks
->state
)
1417 c
->log_callbacks
->state(c
->log_v
, c
->statebits
| DISORDER_CONNECTED
);
1420 static void logentry_failed(disorder_eclient
*c
,
1421 int attribute((unused
)) nvec
, char **vec
) {
1422 c
->statebits
&= ~DISORDER_PLAYING
;
1423 if(c
->log_callbacks
->failed
)
1424 c
->log_callbacks
->failed(c
->log_v
, vec
[0], vec
[1]);
1425 if(c
->log_callbacks
->state
)
1426 c
->log_callbacks
->state(c
->log_v
, c
->statebits
| DISORDER_CONNECTED
);
1429 static void logentry_moved(disorder_eclient
*c
,
1430 int attribute((unused
)) nvec
, char **vec
) {
1431 if(c
->log_callbacks
->moved
)
1432 c
->log_callbacks
->moved(c
->log_v
, vec
[0]);
1435 static void logentry_playing(disorder_eclient
*c
,
1436 int attribute((unused
)) nvec
, char **vec
) {
1437 c
->statebits
|= DISORDER_PLAYING
;
1438 if(c
->log_callbacks
->playing
)
1439 c
->log_callbacks
->playing(c
->log_v
, vec
[0], vec
[1]);
1440 if(c
->log_callbacks
->state
)
1441 c
->log_callbacks
->state(c
->log_v
, c
->statebits
| DISORDER_CONNECTED
);
1444 static void logentry_queue(disorder_eclient
*c
,
1445 int attribute((unused
)) nvec
, char **vec
) {
1446 struct queue_entry
*q
;
1448 if(!c
->log_callbacks
->queue
) return;
1449 q
= xmalloc(sizeof *q
);
1450 if(queue_unmarshall_vec(q
, nvec
, vec
, eclient_queue_error
, c
))
1452 c
->log_callbacks
->queue(c
->log_v
, q
);
1455 static void logentry_recent_added(disorder_eclient
*c
,
1456 int attribute((unused
)) nvec
, char **vec
) {
1457 struct queue_entry
*q
;
1459 if(!c
->log_callbacks
->recent_added
) return;
1460 q
= xmalloc(sizeof *q
);
1461 if(queue_unmarshall_vec(q
, nvec
, vec
, eclient_queue_error
, c
))
1463 c
->log_callbacks
->recent_added(c
->log_v
, q
);
1466 static void logentry_recent_removed(disorder_eclient
*c
,
1467 int attribute((unused
)) nvec
, char **vec
) {
1468 if(c
->log_callbacks
->recent_removed
)
1469 c
->log_callbacks
->recent_removed(c
->log_v
, vec
[0]);
1472 static void logentry_removed(disorder_eclient
*c
,
1473 int attribute((unused
)) nvec
, char **vec
) {
1474 if(c
->log_callbacks
->removed
)
1475 c
->log_callbacks
->removed(c
->log_v
, vec
[0], vec
[1]);
1478 static void logentry_rescanned(disorder_eclient
*c
,
1479 int attribute((unused
)) nvec
,
1480 char attribute((unused
)) **vec
) {
1481 if(c
->log_callbacks
->rescanned
)
1482 c
->log_callbacks
->rescanned(c
->log_v
);
1485 static void logentry_scratched(disorder_eclient
*c
,
1486 int attribute((unused
)) nvec
, char **vec
) {
1487 c
->statebits
&= ~DISORDER_PLAYING
;
1488 if(c
->log_callbacks
->scratched
)
1489 c
->log_callbacks
->scratched(c
->log_v
, vec
[0], vec
[1]);
1490 if(c
->log_callbacks
->state
)
1491 c
->log_callbacks
->state(c
->log_v
, c
->statebits
| DISORDER_CONNECTED
);
1494 static const struct {
1497 const char *disable
;
1498 } statestrings
[] = {
1499 { DISORDER_PLAYING_ENABLED
, "enable_play", "disable_play" },
1500 { DISORDER_RANDOM_ENABLED
, "enable_random", "disable_random" },
1501 { DISORDER_TRACK_PAUSED
, "pause", "resume" },
1502 { DISORDER_PLAYING
, "playing", "completed" },
1503 { DISORDER_PLAYING
, 0, "scratched" },
1504 { DISORDER_PLAYING
, 0, "failed" },
1506 #define NSTATES (int)(sizeof statestrings / sizeof *statestrings)
1508 static void logentry_state(disorder_eclient
*c
,
1509 int attribute((unused
)) nvec
, char **vec
) {
1512 for(n
= 0; n
< NSTATES
; ++n
)
1513 if(statestrings
[n
].enable
&& !strcmp(vec
[0], statestrings
[n
].enable
)) {
1514 c
->statebits
|= statestrings
[n
].bit
;
1516 } else if(statestrings
[n
].disable
&& !strcmp(vec
[0], statestrings
[n
].disable
)) {
1517 c
->statebits
&= ~statestrings
[n
].bit
;
1520 if(c
->log_callbacks
->state
)
1521 c
->log_callbacks
->state(c
->log_v
, c
->statebits
| DISORDER_CONNECTED
);
1524 static void logentry_volume(disorder_eclient
*c
,
1525 int attribute((unused
)) nvec
, char **vec
) {
1528 if(!c
->log_callbacks
->volume
) return;
1529 if(xstrtol(&l
, vec
[0], 0, 10)
1530 || xstrtol(&r
, vec
[1], 0, 10)
1531 || l
< 0 || l
> INT_MAX
1532 || r
< 0 || r
> INT_MAX
)
1534 c
->log_callbacks
->volume(c
->log_v
, (int)l
, (int)r
);
1537 /** @brief Convert @p statebits to a string */
1538 char *disorder_eclient_interpret_state(unsigned long statebits
) {
1542 static const struct {
1546 { DISORDER_PLAYING_ENABLED
, "playing_enabled" },
1547 { DISORDER_RANDOM_ENABLED
, "random_enabled" },
1548 { DISORDER_TRACK_PAUSED
, "track_paused" },
1549 { DISORDER_PLAYING
, "playing" },
1550 { DISORDER_CONNECTED
, "connected" },
1552 #define NBITS (sizeof bits / sizeof *bits)
1556 dynstr_append(d
, '0');
1557 for(n
= 0; n
< NBITS
; ++n
)
1558 if(statebits
& bits
[n
].bit
) {
1560 dynstr_append(d
, '|');
1561 dynstr_append_string(d
, bits
[n
].name
);
1562 statebits
^= bits
[n
].bit
;
1568 dynstr_append(d
, '|');
1569 sprintf(s
, "%#lx", statebits
);
1570 dynstr_append_string(d
, s
);
1572 dynstr_terminate(d
);
1581 indent-tabs-mode:nil