X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/6cd155a8b6895c9284fe2007e475e0d7ecd751ff..ad2f8275a5fc0dba29ca97bc02342d1f1627e590:/lib/eclient.c diff --git a/lib/eclient.c b/lib/eclient.c index e33cb7c..d93412a 100644 --- a/lib/eclient.c +++ b/lib/eclient.c @@ -1,6 +1,6 @@ /* * This file is part of DisOrder. - * Copyright (C) 2006 Richard Kettlewell + * Copyright (C) 2006, 2007 Richard Kettlewell * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -37,6 +37,7 @@ #include #include #include +#include #include "log.h" #include "mem.h" @@ -58,6 +59,9 @@ /* TODO: more commands */ +/** @brief How often to send data to the server when receiving logs */ +#define LOG_PROD_INTERVAL 10 + /* Types *********************************************************************/ /** @brief Client state */ @@ -125,9 +129,23 @@ struct disorder_eclient { int rc; /**< @brief response code */ char *line; /**< @brief complete line */ struct vector vec; /**< @brief body */ - const disorder_eclient_log_callbacks *log_callbacks; /**< @brief log callbacks */ + + const disorder_eclient_log_callbacks *log_callbacks; + /**< @brief log callbacks + * + * Once disorder_eclient_log() has been issued this is always set. When we + * re-connect it is checked to re-issue the log command. + */ void *log_v; /**< @brief user data */ unsigned long statebits; /**< @brief latest state */ + + time_t last_prod; + /**< @brief last time we sent a prod + * + * When we are receiving log data we send a "prod" byte to the server from + * time to time so that we detect broken connections reasonably quickly. The + * server just ignores these bytes. + */ }; /* Forward declarations ******************************************************/ @@ -170,6 +188,7 @@ static void logentry_removed(disorder_eclient *c, int nvec, char **vec); static void logentry_scratched(disorder_eclient *c, int nvec, char **vec); static void logentry_state(disorder_eclient *c, int nvec, char **vec); static void logentry_volume(disorder_eclient *c, int nvec, char **vec); +static void logentry_rescanned(disorder_eclient *c, int nvec, char **vec); /* Tables ********************************************************************/ @@ -194,6 +213,7 @@ static const struct logentry_handler logentry_handlers[] = { LE(recent_added, 2, INT_MAX), LE(recent_removed, 1, 1), LE(removed, 1, 2), + LE(rescanned, 0, 0), LE(scratched, 2, 2), LE(state, 1, 1), LE(volume, 2, 2) @@ -306,6 +326,7 @@ static int protocol_error(disorder_eclient *c, struct operation *op, */ void disorder_eclient_polled(disorder_eclient *c, unsigned mode) { struct operation *op; + time_t now; D(("disorder_eclient_polled fd=%d state=%s mode=[%s %s]", c->fd, states[c->state], @@ -374,6 +395,14 @@ void disorder_eclient_polled(disorder_eclient *c, unsigned mode) { c->callbacks->report(c->u, 0); } + /* Queue up a byte to send */ + if(c->state == state_log + && c->output.nvec == 0 + && time(&now) - c->last_prod > LOG_PROD_INTERVAL) { + put(c, "x", 1); + c->last_prod = now; + } + if(c->state == state_cmdresponse || c->state == state_body || c->state == state_log) { @@ -453,6 +482,7 @@ static int start_connect(void *cc, return comms_error(c, "socket: %s", strerror(errno)); c->eof = 0; nonblock(c->fd); + cloexec(c->fd); if(connect(c->fd, sa, len) < 0) { switch(errno) { case EINTR: @@ -503,16 +533,31 @@ static void authbanner_opcallback(disorder_eclient *c, size_t nonce_len; const unsigned char *nonce; const char *res; + char **rvec; + int nrvec; + const char *algo = "SHA1"; D(("authbanner_opcallback")); - if(c->rc / 100 != 2) { - /* Banner told us to go away. We cannot proceed. */ + if(c->rc / 100 != 2 + || !(rvec = split(c->line + 4, &nrvec, SPLIT_QUOTES, 0, 0)) + || nrvec < 1) { + /* Banner told us to go away, or was malformed. We cannot proceed. */ protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line); disorder_eclient_close(c); return; } - nonce = unhex(c->line + 4, &nonce_len); - res = authhash(nonce, nonce_len, config->password); + if(nrvec > 1) { + algo = *rvec++; + --nrvec; + } + nonce = unhex(rvec[0], &nonce_len); + res = authhash(nonce, nonce_len, config->password, algo); + if(!res) { + protocol_error(c, op, c->rc, "%s: unknown authentication algorithm '%s'", + c->ident, algo); + disorder_eclient_close(c); + return; + } stash_command(c, 1/*queuejump*/, authuser_opcallback, 0/*completed*/, 0/*v*/, "user", quoteutf8(config->username), quoteutf8(res), (char *)0); @@ -634,7 +679,7 @@ static void process_line(disorder_eclient *c, char *line) { case 3: /* We need to collect the body. */ c->state = state_body; - c->vec.nvec = 0; + vector_init(&c->vec); break; case 4: assert(c->log_callbacks != 0); @@ -1141,6 +1186,54 @@ int disorder_eclient_nop(disorder_eclient *c, "nop", (char *)0); } +/** @brief Get the last @p max added tracks + * @param c Client + * @param completed Called with list + * @param max Number of tracks to get, 0 for all + * @param v Passed to @p completed + * + * The first track in the list is the most recently added. + */ +int disorder_eclient_new_tracks(disorder_eclient *c, + disorder_eclient_list_response *completed, + int max, + void *v) { + char limit[32]; + + sprintf(limit, "%d", max); + return simple(c, list_response_opcallback, (void (*)())completed, v, + "new", limit, (char *)0); +} + +static void rtp_response_opcallback(disorder_eclient *c, + struct operation *op) { + D(("rtp_response_opcallback")); + if(c->rc / 100 == 2) { + if(op->completed) { + int nvec; + char **vec = split(c->line + 4, &nvec, SPLIT_QUOTES, 0, 0); + + ((disorder_eclient_list_response *)op->completed)(op->v, nvec, vec); + } + } else + protocol_error(c, op, c->rc, "%s: %s", c->ident, c->line); +} + +/** @brief Determine the RTP target address + * @param c Client + * @param completed Called with address details + * @param v Passed to @p completed + * + * The address details will be two elements, the first being the hostname and + * the second the service (port). + */ +int disorder_eclient_rtp_address(disorder_eclient *c, + disorder_eclient_list_response *completed, + void *v) { + return simple(c, rtp_response_opcallback, (void (*)())completed, v, + "rtp-address", (char *)0); +} + /* Log clients ***************************************************************/ /** @brief Monitor the server log @@ -1275,6 +1368,13 @@ static void logentry_removed(disorder_eclient *c, c->log_callbacks->removed(c->log_v, vec[0], vec[1]); } +static void logentry_rescanned(disorder_eclient *c, + int attribute((unused)) nvec, + char attribute((unused)) **vec) { + if(!c->log_callbacks->rescanned) return; + c->log_callbacks->rescanned(c->log_v); +} + static void logentry_scratched(disorder_eclient *c, int attribute((unused)) nvec, char **vec) { if(!c->log_callbacks->scratched) return; @@ -1292,6 +1392,9 @@ static const struct { { DISORDER_PLAYING_ENABLED, "enable_play", "disable_play" }, { DISORDER_RANDOM_ENABLED, "enable_random", "disable_random" }, { DISORDER_TRACK_PAUSED, "pause", "resume" }, + { DISORDER_PLAYING, "playing", "completed" }, + { DISORDER_PLAYING, 0, "scratched" }, + { DISORDER_PLAYING, 0, "failed" }, }; #define NSTATES (int)(sizeof statestrings / sizeof *statestrings) @@ -1300,10 +1403,10 @@ static void logentry_state(disorder_eclient *c, int n; for(n = 0; n < NSTATES; ++n) - if(!strcmp(vec[0], statestrings[n].enable)) { + if(statestrings[n].enable && !strcmp(vec[0], statestrings[n].enable)) { c->statebits |= statestrings[n].bit; break; - } else if(!strcmp(vec[0], statestrings[n].disable)) { + } else if(statestrings[n].disable && !strcmp(vec[0], statestrings[n].disable)) { c->statebits &= ~statestrings[n].bit; break; }