chiark / gitweb /
Remove arch tags throughout
[disorder] / lib / eclient.c
CommitLineData
460b9539 1/*
2 * This file is part of DisOrder.
3 * Copyright (C) 2006 Richard Kettlewell
4 *
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.
9 *
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.
14 *
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
18 * USA
19 */
20
21#include <config.h>
22#include "types.h"
23
24#include <sys/types.h>
25#include <sys/socket.h>
26#include <netinet/in.h>
27#include <sys/un.h>
28#include <string.h>
29#include <stdio.h>
30#include <unistd.h>
31#include <errno.h>
32#include <netdb.h>
33#include <stdlib.h>
34#include <assert.h>
35#include <inttypes.h>
36#include <stddef.h>
37
38#include "log.h"
39#include "mem.h"
40#include "configuration.h"
41#include "queue.h"
42#include "eclient.h"
43#include "charset.h"
44#include "hex.h"
45#include "split.h"
46#include "vector.h"
47#include "inputline.h"
48#include "kvp.h"
49#include "syscalls.h"
50#include "printf.h"
51#include "addr.h"
52#include "authhash.h"
53#include "table.h"
54#include "client-common.h"
55
56/* TODO: more commands */
57
58/* Types *********************************************************************/
59
60enum client_state {
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 */
68};
69
70static const char *const states[] = {
71 "disconnected",
72 "connecting",
73 "connected",
74 "idle",
75 "cmdresponse",
76 "body",
77 "log"
78};
79
80struct operation; /* forward decl */
81
82typedef void operation_callback(disorder_eclient *c, struct operation *op);
83
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. */
87struct operation {
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 */
95};
96
97struct disorder_eclient {
98 const char *ident;
99 int fd;
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;
107 void *u;
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;
116 void *log_v;
117 unsigned long statebits; /* current state */
118};
119
120/* Forward declarations ******************************************************/
121
122static int start_connect(void *cc,
123 const struct sockaddr *sa,
124 socklen_t len,
125 const char *ident);
126static void process_line(disorder_eclient *c, char *line);
127static int start_connect(void *cc,
128 const struct sockaddr *sa,
129 socklen_t len,
130 const char *ident);
131static void maybe_connected(disorder_eclient *c);
132static void authbanner_opcallback(disorder_eclient *c,
133 struct operation *op);
134static void authuser_opcallback(disorder_eclient *c,
135 struct operation *op);
136static void complete(disorder_eclient *c);
137static void send_output(disorder_eclient *c);
138static void put(disorder_eclient *c, const char *s, size_t n);
139static void read_input(disorder_eclient *c);
140static void stash_command(disorder_eclient *c,
141 int queuejump,
142 operation_callback *opcallback,
143 void (*completed)(),
144 void *v,
145 const char *cmd,
146 ...);
147static void log_opcallback(disorder_eclient *c, struct operation *op);
148static void logline(disorder_eclient *c, const char *line);
149static void logentry_completed(disorder_eclient *c, int nvec, char **vec);
150static void logentry_failed(disorder_eclient *c, int nvec, char **vec);
151static void logentry_moved(disorder_eclient *c, int nvec, char **vec);
152static void logentry_playing(disorder_eclient *c, int nvec, char **vec);
153static void logentry_queue(disorder_eclient *c, int nvec, char **vec);
154static void logentry_recent_added(disorder_eclient *c, int nvec, char **vec);
155static void logentry_recent_removed(disorder_eclient *c, int nvec, char **vec);
156static void logentry_removed(disorder_eclient *c, int nvec, char **vec);
157static void logentry_scratched(disorder_eclient *c, int nvec, char **vec);
158static void logentry_state(disorder_eclient *c, int nvec, char **vec);
159static void logentry_volume(disorder_eclient *c, int nvec, char **vec);
160
161/* Tables ********************************************************************/
162
163static const struct logentry_handler {
164 const char *name;
165 int min, max;
166 void (*handler)(disorder_eclient *c,
167 int nvec,
168 char **vec);
169} logentry_handlers[] = {
170#define LE(X, MIN, MAX) { #X, MIN, MAX, logentry_##X }
171 LE(completed, 1, 1),
172 LE(failed, 2, 2),
173 LE(moved, 1, 1),
174 LE(playing, 1, 2),
175 LE(queue, 2, INT_MAX),
176 LE(recent_added, 2, INT_MAX),
177 LE(recent_removed, 1, 1),
178 LE(removed, 1, 2),
179 LE(scratched, 2, 2),
180 LE(state, 1, 1),
181 LE(volume, 2, 2)
182};
183
184/* Setup and teardown ********************************************************/
185
186disorder_eclient *disorder_eclient_new(const disorder_eclient_callbacks *cb,
187 void *u) {
188 disorder_eclient *c = xmalloc(sizeof *c);
189 D(("disorder_eclient_new"));
190 c->fd = -1;
191 c->callbacks = cb;
192 c->u = u;
193 c->opstail = &c->ops;
194 vector_init(&c->vec);
195 dynstr_init(&c->input);
196 dynstr_init(&c->output);
197 return c;
198}
199
200void disorder_eclient_close(disorder_eclient *c) {
201 struct operation *op;
202
203 D(("disorder_eclient_close"));
204 if(c->fd != -1) {
205 D(("disorder_eclient_close closing fd %d", c->fd));
206 c->callbacks->poll(c->u, c, c->fd, 0);
207 xclose(c->fd);
208 c->fd = -1;
209 c->state = state_disconnected;
210 }
211 c->output.nvec = 0;
212 c->input.nvec = 0;
213 c->eof = 0;
214 c->authenticated = 0;
215 /* We'll need to resend all operations */
216 for(op = c->ops; op; op = op->next)
217 op->sent = 0;
218}
219
220/* Error reporting ***********************************************************/
221
222/* called when a connection error occurs */
223static int comms_error(disorder_eclient *c, const char *fmt, ...) {
224 va_list ap;
225 char *s;
226
227 D(("comms_error"));
228 va_start(ap, fmt);
229 byte_xvasprintf(&s, fmt, ap);
230 va_end(ap);
231 disorder_eclient_close(c);
232 c->callbacks->comms_error(c->u, s);
233 return -1;
234}
235
236/* called when the server reports an error */
237static int protocol_error(disorder_eclient *c, struct operation *op,
238 int code, const char *fmt, ...) {
239 va_list ap;
240 char *s;
241
242 D(("protocol_error"));
243 va_start(ap, fmt);
244 byte_xvasprintf(&s, fmt, ap);
245 va_end(ap);
246 c->callbacks->protocol_error(c->u, op->v, code, s);
247 return -1;
248}
249
250/* State machine *************************************************************/
251
252void disorder_eclient_polled(disorder_eclient *c, unsigned mode) {
253 struct operation *op;
254
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
263 * others). */
264
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. */
271 mode = 0;
272 }
273
274 if(c->state == state_connecting && mode) {
275 D(("state_connecting"));
276 maybe_connected(c);
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
279 * retry. */
280 mode = 0;
281 }
282
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;
292 }
293
294 if(c->state == state_idle) {
295 D(("state_idle"));
296 /* We are connected, and have finished any command we set off, look for
297 * some work to do */
298 if(c->ops) {
299 D(("have ops"));
300 if(c->authenticated) {
301 /* Transmit all unsent operations */
302 for(op = c->ops; op; op = op->next) {
303 if(!op->sent) {
304 put(c, op->cmd, strlen(op->cmd));
305 op->sent = 1;
306 }
307 }
308 } else {
309 /* Just send the head operation */
310 if(c->ops->cmd && !c->ops->sent) {
311 put(c, c->ops->cmd, strlen(c->ops->cmd));
312 c->ops->sent = 1;
313 }
314 }
315 /* Awaiting response for the operation at the head of the list */
316 c->state = state_cmdresponse;
317 } else
318 /* genuinely idle */
319 c->callbacks->report(c->u, 0);
320 }
321
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. */
335 switch(c->state) {
336 case state_disconnected: /* lost connection */
337 case state_idle: /* completed a command */
338 D(("retrying"));
339 disorder_eclient_polled(c, 0);
340 return;
341 default:
342 break;
343 }
344 }
345
346 /* Figure out what to set the mode to */
347 switch(c->state) {
348 case state_disconnected:
349 D(("state_disconnected (2)"));
350 /* Probably an error occurred. Await a retry. */
351 mode = 0;
352 break;
353 case state_connecting:
354 D(("state_connecting (2)"));
355 /* Waiting for connect to complete */
356 mode = DISORDER_POLL_READ|DISORDER_POLL_WRITE;
357 break;
358 case state_connected:
359 D(("state_connected (2)"));
360 assert(!"should never be in state_connected here");
361 break;
362 case state_idle:
363 D(("state_idle (2)"));
364 /* Connected but nothing to do. */
365 mode = 0;
366 break;
367 case state_cmdresponse:
368 case state_body:
369 case state_log:
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;
375 break;
376 }
377 D(("fd=%d new mode [%s %s]",
378 c->fd,
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);
382}
383
384/* Called to start connecting */
385static int start_connect(void *cc,
386 const struct sockaddr *sa,
387 socklen_t len,
388 const char *ident) {
389 disorder_eclient *c = cc;
390
391 D(("start_connect"));
392 c->ident = xstrdup(ident);
393 if(c->fd != -1) {
394 xclose(c->fd);
395 c->fd = -1;
396 }
397 if((c->fd = socket(sa->sa_family, SOCK_STREAM, 0)) < 0)
398 return comms_error(c, "socket: %s", strerror(errno));
399 c->eof = 0;
400 nonblock(c->fd);
401 if(connect(c->fd, sa, len) < 0) {
402 switch(errno) {
403 case EINTR:
404 case EINPROGRESS:
405 c->state = state_connecting;
406 /* We are called from _polled so the state machine will get to do its
407 * thing */
408 return 0;
409 default:
410 /* Signal the error to the caller. */
411 return comms_error(c, "connecting to %s: %s", ident, strerror(errno));
412 }
413 } else
414 c->state = state_connected;
415 return 0;
416}
417
418/* Called when maybe connected */
419static void maybe_connected(disorder_eclient *c) {
420 /* We either connected, or got an error. */
421 int err;
422 socklen_t len = sizeof err;
423
424 D(("maybe_connected"));
425 /* Work around over-enthusiastic error slippage */
426 if(getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
427 err = errno;
428 if(err) {
429 /* The connection failed */
430 comms_error(c, "connecting to %s: %s", c->ident, strerror(err));
431 /* sets state_disconnected */
432 } else {
433 /* The connection succeeded */
434 c->state = state_connected;
435 }
436}
437
438/* Authentication ************************************************************/
439
440static void authbanner_opcallback(disorder_eclient *c,
441 struct operation *op) {
442 size_t nonce_len;
443 const unsigned char *nonce;
444 const char *res;
445
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);
451 return;
452 }
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),
457 (char *)0);
458}
459
460static 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);
467 return;
468 }
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,
474 "log", (char *)0);
475}
476
477/* Output ********************************************************************/
478
479/* Chop N bytes off the front of a dynstr */
480static 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);
484 d->nvec -= n;
485}
486
487/* Write some bytes */
488static 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);
491}
492
493/* Called when we can write to our FD, or at any other time */
494static void send_output(disorder_eclient *c) {
495 int n;
496
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);
500 if(n < 0) {
501 switch(errno) {
502 case EINTR:
503 case EAGAIN:
504 break;
505 default:
506 comms_error(c, "writing to %s: %s", c->ident, strerror(errno));
507 break;
508 }
509 } else
510 consume(&c->output, n);
511 }
512}
513
514/* Input *********************************************************************/
515
516/* Called when c->fd might be readable, or at any other time */
517static void read_input(disorder_eclient *c) {
518 char *nl;
519 int n;
520 char buffer[512];
521
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);
526 if(n < 0) {
527 switch(errno) {
528 case EINTR:
529 case EAGAIN:
530 break;
531 default:
532 comms_error(c, "reading from %s: %s", c->ident, strerror(errno));
533 break;
534 }
535 return; /* no new input to process */
536 } else if(n) {
537 D(("read %d bytes: [%.*s]", n, n, buffer));
538 dynstr_append_bytes(&c->input, buffer, n);
539 } else
540 c->eof = 1;
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);
548 }
549 if(c->eof)
550 comms_error(c, "reading from %s: server disconnected", c->ident);
551}
552
553/* called with a line that has just been read */
554static void process_line(disorder_eclient *c, char *line) {
555 D(("process_line %d [%s]", c->fd, line));
556 switch(c->state) {
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'
562 && line[3] == ' '))
563 fatal(0, "invalid response from server: %s", line);
564 c->rc = (line[0] * 10 + line[1]) * 10 + line[2] - 111 * '0';
565 c->line = line;
566 switch(c->rc % 10) {
567 case 3:
568 /* We need to collect the body. */
569 c->state = state_body;
570 c->vec.nvec = 0;
571 break;
572 case 4:
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;
577 break;
578 default:
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. */
581 complete(c);
582 break;
583 }
584 break;
585 case state_body:
586 if(strcmp(line, ".")) {
587 /* A line from the body */
588 vector_append(&c->vec, line + (line[0] == '.'));
589 } else {
590 /* End of the body. */
591 vector_terminate(&c->vec);
592 complete(c);
593 }
594 break;
595 case state_log:
596 if(strcmp(line, ".")) {
597 logline(c, line + (line[0] == '.'));
598 } else
599 complete(c);
600 break;
601 default:
602 assert(!"wrong state for location");
603 break;
604 }
605}
606
607/* Called when an operation completes */
608static void complete(disorder_eclient *c) {
609 struct operation *op;
610
611 D(("complete"));
612 /* Pop the operation off the queue */
613 op = c->ops;
614 c->ops = op->next;
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
624 * behaviour. */
625}
626
627/* Operation setup ***********************************************************/
628
629static void stash_command_vector(disorder_eclient *c,
630 int queuejump,
631 operation_callback *opcallback,
632 void (*completed)(),
633 void *v,
634 int ncmd,
635 char **cmd) {
636 struct operation *op = xmalloc(sizeof *op);
637 struct dynstr d;
638 int n;
639
640 if(cmd) {
641 dynstr_init(&d);
642 for(n = 0; n < ncmd; ++n) {
643 if(n)
644 dynstr_append(&d, ' ');
645 dynstr_append_string(&d, quoteutf8(cmd[n]));
646 }
647 dynstr_append(&d, '\n');
648 dynstr_terminate(&d);
649 op->cmd = d.vec;
650 } else
651 op->cmd = 0; /* usually, awaiting challenge */
652 op->opcallback = opcallback;
653 op->completed = completed;
654 op->v = v;
655 op->next = 0;
656 op->client = c;
657 assert(op->sent == 0);
658 if(queuejump) {
659 /* Authentication operations jump the queue of useful commands */
660 op->next = c->ops;
661 c->ops = op;
662 if(c->opstail == &c->ops)
663 c->opstail = &op->next;
664 for(op = c->ops; op; op = op->next)
665 assert(!op->sent);
666 } else {
667 *c->opstail = op;
668 c->opstail = &op->next;
669 }
670}
671
672static void vstash_command(disorder_eclient *c,
673 int queuejump,
674 operation_callback *opcallback,
675 void (*completed)(),
676 void *v,
677 const char *cmd, va_list ap) {
678 char *arg;
679 struct vector vec;
680
681 D(("vstash_command %s", cmd ? cmd : "NULL"));
682 if(cmd) {
683 vector_init(&vec);
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,
688 vec.nvec, vec.vec);
689 } else
690 stash_command_vector(c, queuejump, opcallback, completed, v, 0, 0);
691}
692
693static void stash_command(disorder_eclient *c,
694 int queuejump,
695 operation_callback *opcallback,
696 void (*completed)(),
697 void *v,
698 const char *cmd,
699 ...) {
700 va_list ap;
701
702 va_start(ap, cmd);
703 vstash_command(c, queuejump, opcallback, completed, v, cmd, ap);
704 va_end(ap);
705}
706
707/* Command support ***********************************************************/
708
709/* for commands with a simple string response */
710static void string_response_opcallback(disorder_eclient *c,
711 struct operation *op) {
712 D(("string_response_callback"));
713 if(c->rc / 100 == 2) {
714 if(op->completed)
715 ((disorder_eclient_string_response *)op->completed)(op->v, c->line + 4);
716 } else
717 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
718}
719
720/* for commands with a simple integer response */
721static void integer_response_opcallback(disorder_eclient *c,
722 struct operation *op) {
723 D(("string_response_callback"));
724 if(c->rc / 100 == 2) {
725 if(op->completed)
726 ((disorder_eclient_integer_response *)op->completed)
727 (op->v, strtol(c->line + 4, 0, 10));
728 } else
729 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
730}
731
732/* for commands with no response */
733static void no_response_opcallback(disorder_eclient *c,
734 struct operation *op) {
735 D(("no_response_callback"));
736 if(c->rc / 100 == 2) {
737 if(op->completed)
738 ((disorder_eclient_no_response *)op->completed)(op->v);
739 } else
740 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
741}
742
743/* error callback for queue_unmarshall */
744static void eclient_queue_error(const char *msg,
745 void *u) {
746 struct operation *op = u;
747
748 protocol_error(op->client, op, -1, "error parsing queue entry: %s", msg);
749}
750
751/* for commands that expect a queue dump */
752static void queue_response_opcallback(disorder_eclient *c,
753 struct operation *op) {
754 int n;
755 struct queue_entry *q, *qh = 0, **qtail = &qh, *qlast = 0;
756
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)) {
764 q->prev = qlast;
765 *qtail = q;
766 qtail = &q->next;
767 qlast = q;
768 }
769 }
770 if(op->completed)
771 ((disorder_eclient_queue_response *)op->completed)(op->v, qh);
772 } else
773 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
774}
775
776/* for 'playing' */
777static void playing_response_opcallback(disorder_eclient *c,
778 struct operation *op) {
779 struct queue_entry *q;
780
781 D(("playing_response_callback"));
782 if(c->rc / 100 == 2) {
783 switch(c->rc % 10) {
784 case 2:
785 if(queue_unmarshall(q = xmalloc(sizeof *q), c->line + 4,
786 eclient_queue_error, c))
787 return;
788 break;
789 case 9:
790 q = 0;
791 break;
792 default:
793 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
794 return;
795 }
796 if(op->completed)
797 ((disorder_eclient_queue_response *)op->completed)(op->v, q);
798 } else
799 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
800}
801
802/* for commands that expect a list of some sort */
803static void list_response_opcallback(disorder_eclient *c,
804 struct operation *op) {
805 D(("list_response_callback"));
806 if(c->rc / 100 == 2) {
807 if(op->completed)
808 ((disorder_eclient_list_response *)op->completed)(op->v,
809 c->vec.nvec,
810 c->vec.vec);
811 } else
812 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
813}
814
815/* for volume */
816static void volume_response_opcallback(disorder_eclient *c,
817 struct operation *op) {
818 int l, r;
819
820 D(("volume_response_callback"));
821 if(c->rc / 100 == 2) {
822 if(op->completed) {
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",
825 c->ident, c->line);
826 else
827 ((disorder_eclient_volume_response *)op->completed)(op->v, l, r);
828 }
829 } else
830 protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line);
831}
832
833static int simple(disorder_eclient *c,
834 operation_callback *opcallback,
835 void (*completed)(),
836 void *v,
837 const char *cmd, ...) {
838 va_list ap;
839
840 va_start(ap, cmd);
841 vstash_command(c, 0/*queuejump*/, opcallback, completed, v, cmd, ap);
842 va_end(ap);
843 /* Give the state machine a kick, since we might be in state_idle */
844 disorder_eclient_polled(c, 0);
845 return 0;
846}
847
848/* Commands ******************************************************************/
849
850int disorder_eclient_version(disorder_eclient *c,
851 disorder_eclient_string_response *completed,
852 void *v) {
853 return simple(c, string_response_opcallback, (void (*)())completed, v,
854 "version", (char *)0);
855}
856
857int disorder_eclient_namepart(disorder_eclient *c,
858 disorder_eclient_string_response *completed,
859 const char *track,
860 const char *context,
861 const char *part,
862 void *v) {
863 return simple(c, string_response_opcallback, (void (*)())completed, v,
864 "part", track, context, part, (char *)0);
865}
866
867int disorder_eclient_play(disorder_eclient *c,
868 const char *track,
869 disorder_eclient_no_response *completed,
870 void *v) {
871 return simple(c, no_response_opcallback, (void (*)())completed, v,
872 "play", track, (char *)0);
873}
874
875int disorder_eclient_pause(disorder_eclient *c,
876 disorder_eclient_no_response *completed,
877 void *v) {
878 return simple(c, no_response_opcallback, (void (*)())completed, v,
879 "pause", (char *)0);
880}
881
882int disorder_eclient_resume(disorder_eclient *c,
883 disorder_eclient_no_response *completed,
884 void *v) {
885 return simple(c, no_response_opcallback, (void (*)())completed, v,
886 "resume", (char *)0);
887}
888
889int disorder_eclient_scratch(disorder_eclient *c,
890 const char *id,
891 disorder_eclient_no_response *completed,
892 void *v) {
893 return simple(c, no_response_opcallback, (void (*)())completed, v,
894 "scratch", id, (char *)0);
895}
896
897int disorder_eclient_scratch_playing(disorder_eclient *c,
898 disorder_eclient_no_response *completed,
899 void *v) {
900 return disorder_eclient_scratch(c, 0, completed, v);
901}
902
903int disorder_eclient_remove(disorder_eclient *c,
904 const char *id,
905 disorder_eclient_no_response *completed,
906 void *v) {
907 return simple(c, no_response_opcallback, (void (*)())completed, v,
908 "remove", id, (char *)0);
909}
910
911int disorder_eclient_moveafter(disorder_eclient *c,
912 const char *target,
913 int nids,
914 const char **ids,
915 disorder_eclient_no_response *completed,
916 void *v) {
917 struct vector vec;
918 int n;
919
920 vector_init(&vec);
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,
926 vec.nvec, vec.vec);
927 disorder_eclient_polled(c, 0);
928 return 0;
929}
930
931int disorder_eclient_recent(disorder_eclient *c,
932 disorder_eclient_queue_response *completed,
933 void *v) {
934 return simple(c, queue_response_opcallback, (void (*)())completed, v,
935 "recent", (char *)0);
936}
937
938int disorder_eclient_queue(disorder_eclient *c,
939 disorder_eclient_queue_response *completed,
940 void *v) {
941 return simple(c, queue_response_opcallback, (void (*)())completed, v,
942 "queue", (char *)0);
943}
944
945int disorder_eclient_files(disorder_eclient *c,
946 disorder_eclient_list_response *completed,
947 const char *dir,
948 const char *re,
949 void *v) {
950 return simple(c, list_response_opcallback, (void (*)())completed, v,
951 "files", dir, re, (char *)0);
952}
953
954int disorder_eclient_dirs(disorder_eclient *c,
955 disorder_eclient_list_response *completed,
956 const char *dir,
957 const char *re,
958 void *v) {
959 return simple(c, list_response_opcallback, (void (*)())completed, v,
960 "dirs", dir, re, (char *)0);
961}
962
963int disorder_eclient_playing(disorder_eclient *c,
964 disorder_eclient_queue_response *completed,
965 void *v) {
966 return simple(c, playing_response_opcallback, (void (*)())completed, v,
967 "playing", (char *)0);
968}
969
970int disorder_eclient_length(disorder_eclient *c,
971 disorder_eclient_integer_response *completed,
972 const char *track,
973 void *v) {
974 return simple(c, integer_response_opcallback, (void (*)())completed, v,
975 "length", track, (char *)0);
976}
977
978int disorder_eclient_volume(disorder_eclient *c,
979 disorder_eclient_volume_response *completed,
980 int l, int r,
981 void *v) {
982 char sl[64], sr[64];
983
984 if(l < 0 && r < 0) {
985 return simple(c, volume_response_opcallback, (void (*)())completed, v,
986 "volume", (char *)0);
987 } else if(l >= 0 && r >= 0) {
988 assert(l <= 100);
989 assert(r <= 100);
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);
994 } else {
995 assert(!"invalid arguments to disorder_eclient_volume");
996 return -1; /* gcc is being dim */
997 }
998}
999
1000int disorder_eclient_enable(disorder_eclient *c,
1001 disorder_eclient_no_response *completed,
1002 void *v) {
1003 return simple(c, no_response_opcallback, (void (*)())completed, v,
1004 "enable", (char *)0);
1005}
1006
1007int disorder_eclient_disable(disorder_eclient *c,
1008 disorder_eclient_no_response *completed,
1009 void *v){
1010 return simple(c, no_response_opcallback, (void (*)())completed, v,
1011 "disable", (char *)0);
1012}
1013
1014int disorder_eclient_random_enable(disorder_eclient *c,
1015 disorder_eclient_no_response *completed,
1016 void *v){
1017 return simple(c, no_response_opcallback, (void (*)())completed, v,
1018 "random-enable", (char *)0);
1019}
1020
1021int disorder_eclient_random_disable(disorder_eclient *c,
1022 disorder_eclient_no_response *completed,
1023 void *v){
1024 return simple(c, no_response_opcallback, (void (*)())completed, v,
1025 "random-disable", (char *)0);
1026}
1027
1028int disorder_eclient_get(disorder_eclient *c,
1029 disorder_eclient_string_response *completed,
1030 const char *track, const char *pref,
1031 void *v) {
1032 return simple(c, string_response_opcallback, (void (*)())completed, v,
1033 "get", track, pref, (char *)0);
1034}
1035
1036int disorder_eclient_set(disorder_eclient *c,
1037 disorder_eclient_no_response *completed,
1038 const char *track, const char *pref,
1039 const char *value,
1040 void *v) {
1041 return simple(c, no_response_opcallback, (void (*)())completed, v,
1042 "set", track, pref, value, (char *)0);
1043}
1044
1045int disorder_eclient_unset(disorder_eclient *c,
1046 disorder_eclient_no_response *completed,
1047 const char *track, const char *pref,
1048 void *v) {
1049 return simple(c, no_response_opcallback, (void (*)())completed, v,
1050 "unset", track, pref, (char *)0);
1051}
1052
1053int disorder_eclient_resolve(disorder_eclient *c,
1054 disorder_eclient_string_response *completed,
1055 const char *track,
1056 void *v) {
1057 return simple(c, string_response_opcallback, (void (*)())completed, v,
1058 "resolve", track, (char *)0);
1059}
1060
1061int disorder_eclient_search(disorder_eclient *c,
1062 disorder_eclient_list_response *completed,
1063 const char *terms,
1064 void *v) {
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);
1068}
1069
1070/* Log clients ***************************************************************/
1071
1072int disorder_eclient_log(disorder_eclient *c,
1073 const disorder_eclient_log_callbacks *callbacks,
1074 void *v) {
1075 if(c->log_callbacks) return -1;
1076 c->log_callbacks = callbacks;
1077 c->log_v = v;
1078 stash_command(c, 0/*queuejump*/, log_opcallback, 0/*completed*/, v,
1079 "log", (char *)0);
1080 return 0;
1081}
1082
1083/* If we get here we've stopped being a log client */
1084static void log_opcallback(disorder_eclient *c,
1085 struct operation attribute((unused)) *op) {
1086 D(("log_opcallback"));
1087 c->log_callbacks = 0;
1088 c->log_v = 0;
1089}
1090
1091/* error callback for log line parsing */
1092static 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);
1095}
1096
1097/* process a single log line */
1098static void logline(disorder_eclient *c, const char *line) {
1099 int nvec, n;
1100 char **vec;
1101 uintmax_t when;
1102
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
1106 * reported */
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]);
1110 return;
1111 }
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 */
1115 vec += 2;
1116 nvec -= 2;
1117 if(nvec < logentry_handlers[n].min || nvec > logentry_handlers[n].max)
1118 return;
1119 logentry_handlers[n].handler(c, nvec, vec);
1120}
1121
1122static 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]);
1126}
1127
1128static 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]);
1132}
1133
1134static 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]);
1138}
1139
1140static 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]);
1144}
1145
1146static void logentry_queue(disorder_eclient *c,
1147 int attribute((unused)) nvec, char **vec) {
1148 struct queue_entry *q;
1149
1150 if(!c->log_callbacks->completed) return;
1151 q = xmalloc(sizeof *q);
1152 if(queue_unmarshall_vec(q, nvec, vec, eclient_queue_error, c))
1153 return; /* bogus */
1154 c->log_callbacks->queue(c->log_v, q);
1155}
1156
1157static void logentry_recent_added(disorder_eclient *c,
1158 int attribute((unused)) nvec, char **vec) {
1159 struct queue_entry *q;
1160
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))
1164 return; /* bogus */
1165 c->log_callbacks->recent_added(c->log_v, q);
1166}
1167
1168static 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]);
1172}
1173
1174static 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]);
1178}
1179
1180static 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]);
1184}
1185
1186static const struct {
1187 unsigned long bit;
1188 const char *enable;
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" },
1194};
1195#define NSTATES (int)(sizeof states / sizeof *states)
1196
1197static void logentry_state(disorder_eclient *c,
1198 int attribute((unused)) nvec, char **vec) {
1199 int n;
1200
1201 for(n = 0; n < NSTATES; ++n)
1202 if(!strcmp(vec[0], statestrings[n].enable)) {
1203 c->statebits |= statestrings[n].bit;
1204 break;
1205 } else if(!strcmp(vec[0], statestrings[n].disable)) {
1206 c->statebits &= ~statestrings[n].bit;
1207 break;
1208 }
1209 if(!c->log_callbacks->state) return;
1210 c->log_callbacks->state(c->log_v, c->statebits);
1211}
1212
1213static void logentry_volume(disorder_eclient *c,
1214 int attribute((unused)) nvec, char **vec) {
1215 long l, r;
1216
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)
1222 return; /* bogus */
1223 c->log_callbacks->volume(c->log_v, (int)l, (int)r);
1224}
1225
1226/*
1227Local Variables:
1228c-basic-offset:2
1229comment-column:40
1230fill-column:79
1231indent-tabs-mode:nil
1232End:
1233*/