X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/f03c5a86c8c9b1f03d8ced522597c9a9844002b4..440af55d72c65f5c149718dc52abd00f512ffb71:/server/server.c diff --git a/server/server.c b/server/server.c index e8e6a68..64d29e0 100644 --- a/server/server.c +++ b/server/server.c @@ -18,60 +18,7 @@ * USA */ -#include -#include "types.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "event.h" -#include "server.h" -#include "syscalls.h" -#include "queue.h" -#include "server-queue.h" -#include "play.h" -#include "log.h" -#include "mem.h" -#include "state.h" -#include "charset.h" -#include "split.h" -#include "configuration.h" -#include "hex.h" -#include "rights.h" -#include "trackdb.h" -#include "table.h" -#include "kvp.h" -#include "mixer.h" -#include "sink.h" -#include "authhash.h" -#include "plugin.h" -#include "printf.h" -#include "trackname.h" -#include "eventlog.h" -#include "defs.h" -#include "cache.h" -#include "unicode.h" -#include "cookies.h" -#include "base64.h" -#include "hash.h" -#include "mime.h" -#include "sendmail.h" -#include "wstat.h" -#include "schedule.h" +#include "disorder-server.h" #ifndef NONCE_SIZE # define NONCE_SIZE 16 @@ -94,6 +41,34 @@ struct listener { int pf; }; +struct conn; + +/** @brief Signature for line reader callback + * @param c Connection + * @param line Line + * @return 0 if incomplete, 1 if complete + * + * @p line is 0-terminated and excludes the newline. It points into the + * input buffer so will become invalid shortly. + */ +typedef int line_reader_type(struct conn *c, + char *line); + +/** @brief Signature for with-body command callbacks + * @param c Connection + * @param body List of body lines + * @param nbody Number of body lines + * @param u As passed to fetch_body() + * @return 0 to suspend input, 1 if complete + * + * The body strings are allocated (so survive indefinitely) and don't include + * newlines. + */ +typedef int body_callback_type(struct conn *c, + char **body, + int nbody, + void *u); + /** @brief One client connection */ struct conn { /** @brief Read commands from here */ @@ -127,6 +102,18 @@ struct conn { struct conn *next; /** @brief True if pending rescan had 'wait' set */ int rescan_wait; + /** @brief Playlist that this connection locks */ + const char *locked_playlist; + /** @brief When that playlist was locked */ + time_t locked_when; + /** @brief Line reader function */ + line_reader_type *line_reader; + /** @brief Called when command body has been read */ + body_callback_type *body_callback; + /** @brief Passed to @c body_callback */ + void *body_u; + /** @brief Accumulating body */ + struct vector body[1]; }; /** @brief Linked list of connections */ @@ -138,6 +125,15 @@ static int reader_callback(ev_source *ev, size_t bytes, int eof, void *u); +static int c_playlist_set_body(struct conn *c, + char **body, + int nbody, + void *u); +static int fetch_body(struct conn *c, + body_callback_type body_callback, + void *u); +static int body_line(struct conn *c, char *line); +static int command(struct conn *c, char *line); static const char *noyes[] = { "no", "yes" }; @@ -401,16 +397,16 @@ static void start_fresh_rescan(void *ru) { static int c_rescan(struct conn *c, char **vec, int nvec) { - int wait = 0, fresh = 0, n; + int flag_wait = 0, flag_fresh = 0, n; /* Parse flags */ for(n = 0; n < nvec; ++n) { if(!strcmp(vec[n], "wait")) - wait = 1; /* wait for rescan to complete */ + flag_wait = 1; /* wait for rescan to complete */ #if 0 /* Currently disabled because untested (and hard to test). */ else if(!strcmp(vec[n], "fresh")) - fresh = 1; /* don't piggyback underway rescan */ + flag_fresh = 1; /* don't piggyback underway rescan */ #endif else { sink_writes(ev_writer_sink(c->w), "550 unknown flag\n"); @@ -419,15 +415,15 @@ static int c_rescan(struct conn *c, } /* Report what was requested */ info("S%x rescan by %s (%s %s)", c->tag, c->who, - wait ? "wait" : "", - fresh ? "fresh" : ""); + flag_wait ? "wait" : "", + flag_fresh ? "fresh" : ""); if(trackdb_rescan_underway()) { - if(fresh) { + if(flag_fresh) { /* We want a fresh rescan but there is already one underway. Arrange a * callback when it completes and then set off a new one. */ - c->rescan_wait = wait; + c->rescan_wait = flag_wait; trackdb_add_rescanned(start_fresh_rescan, c); - if(wait) + if(flag_wait) return 0; else { sink_writes(ev_writer_sink(c->w), "250 rescan queued\n"); @@ -435,7 +431,7 @@ static int c_rescan(struct conn *c, } } else { /* There's a rescan underway, and it's acceptable to piggyback on it */ - if(wait) { + if(flag_wait) { /* We want to block until completion. */ trackdb_add_rescanned(finished_rescan, c); return 0; @@ -448,7 +444,7 @@ static int c_rescan(struct conn *c, } } else { /* No rescan is underway. fresh is therefore irrelevant. */ - if(wait) { + if(flag_wait) { /* We want to block until completion */ trackdb_rescan(c->ev, 1/*check*/, finished_rescan, c); return 0; @@ -929,8 +925,19 @@ static void logclient(const char *msg, void *user) { if(!c->w || !c->r) { /* This connection has gone up in smoke for some reason */ eventlog_remove(c->lo); + c->lo = 0; return; } + /* user_* messages are restricted */ + if(!strncmp(msg, "user_", 5)) { + /* They are only sent to admin users */ + if(!(c->rights & RIGHT_ADMIN)) + return; + /* They are not sent over TCP connections unless remote user-management is + * enabled */ + if(!config->remote_userman && !(c->rights & RIGHT__LOCAL)) + return; + } sink_printf(ev_writer_sink(c->w), "%"PRIxMAX" %s\n", (uintmax_t)time(0), msg); } @@ -1068,21 +1075,25 @@ static int c_resolve(struct conn *c, return 1; } -static int c_tags(struct conn *c, - char attribute((unused)) **vec, - int attribute((unused)) nvec) { - char **tags = trackdb_alltags(); - - sink_printf(ev_writer_sink(c->w), "253 Tag list follows\n"); - while(*tags) { +static int list_response(struct conn *c, + const char *reply, + char **list) { + sink_printf(ev_writer_sink(c->w), "253 %s\n", reply); + while(*list) { sink_printf(ev_writer_sink(c->w), "%s%s\n", - **tags == '.' ? "." : "", *tags); - ++tags; + **list == '.' ? "." : "", *list); + ++list; } sink_writes(ev_writer_sink(c->w), ".\n"); return 1; /* completed */ } +static int c_tags(struct conn *c, + char attribute((unused)) **vec, + int attribute((unused)) nvec) { + return list_response(c, "Tag list follows", trackdb_alltags()); +} + static int c_set_global(struct conn *c, char **vec, int attribute((unused)) nvec) { @@ -1287,10 +1298,21 @@ static int c_edituser(struct conn *c, /* Update rights for this user */ rights_type r; - if(parse_rights(vec[2], &r, 1)) - for(d = connections; d; d = d->next) - if(!strcmp(d->who, vec[0])) + if(!parse_rights(vec[2], &r, 1)) { + const char *new_rights = rights_string(r); + for(d = connections; d; d = d->next) { + if(!strcmp(d->who, vec[0])) { + /* Update rights */ d->rights = r; + /* Notify any log connections */ + if(d->lo) + sink_printf(ev_writer_sink(d->w), + "%"PRIxMAX" rights_changed %s\n", + (uintmax_t)time(0), + quoteutf8(new_rights)); + } + } + } } sink_writes(ev_writer_sink(c->w), "250 OK\n"); } else { @@ -1338,17 +1360,7 @@ static int c_userinfo(struct conn *c, static int c_users(struct conn *c, char attribute((unused)) **vec, int attribute((unused)) nvec) { - /* TODO de-dupe with c_tags */ - char **users = trackdb_listusers(); - - sink_writes(ev_writer_sink(c->w), "253 User list follows\n"); - while(*users) { - sink_printf(ev_writer_sink(c->w), "%s%s\n", - **users == '.' ? "." : "", *users); - ++users; - } - sink_writes(ev_writer_sink(c->w), ".\n"); - return 1; /* completed */ + return list_response(c, "User list follows", trackdb_listusers()); } /** @brief Base64 mapping table for confirmation strings @@ -1458,7 +1470,7 @@ static int c_reminder(struct conn *c, return 1; } if(!(email = kvp_get(k, "email")) - || !strchr(email, '@')) { + || !email_valid(email)) { error(0, "user '%s' has no valid email address", vec[0]); sink_writes(ev_writer_sink(c->w), "550 Cannot send a reminder email\n"); return 1; @@ -1567,7 +1579,7 @@ static int c_schedule_add(struct conn *c, char **vec, int nvec) { struct kvp *actiondata = 0; - char *id; + const char *id; /* Standard fields */ kvp_set(&actiondata, "who", c->who); @@ -1606,6 +1618,152 @@ static int c_schedule_add(struct conn *c, return 1; } +static int playlist_response(struct conn *c, + int err) { + switch(err) { + case 0: + assert(!"cannot cope with success"); + case EACCES: + sink_writes(ev_writer_sink(c->w), "550 Access denied\n"); + break; + case EINVAL: + sink_writes(ev_writer_sink(c->w), "550 Invalid playlist name\n"); + break; + case ENOENT: + sink_writes(ev_writer_sink(c->w), "555 No such playlist\n"); + break; + default: + sink_writes(ev_writer_sink(c->w), "550 Error accessing playlist\n"); + break; + } + return 1; +} + +static int c_playlist_get(struct conn *c, + char **vec, + int attribute((unused)) nvec) { + char **tracks; + int err; + + if(!(err = trackdb_playlist_get(vec[0], c->who, &tracks, 0, 0))) + return list_response(c, "Playlist contents follows", tracks); + else + return playlist_response(c, err); +} + +static int c_playlist_set(struct conn *c, + char **vec, + int attribute((unused)) nvec) { + return fetch_body(c, c_playlist_set_body, vec[0]); +} + +static int c_playlist_set_body(struct conn *c, + char **body, + int nbody, + void *u) { + const char *playlist = u; + int err; + + if(!c->locked_playlist + || strcmp(playlist, c->locked_playlist)) { + sink_writes(ev_writer_sink(c->w), "550 Playlist is not locked\n"); + return 1; + } + if(!(err = trackdb_playlist_set(playlist, c->who, + body, nbody, 0))) { + sink_printf(ev_writer_sink(c->w), "250 OK\n"); + return 1; + } else + return playlist_response(c, err); +} + +static int c_playlist_get_share(struct conn *c, + char **vec, + int attribute((unused)) nvec) { + char *share; + int err; + + if(!(err = trackdb_playlist_get(vec[0], c->who, 0, 0, &share))) { + sink_printf(ev_writer_sink(c->w), "252 %s\n", quoteutf8(share)); + return 1; + } else + return playlist_response(c, err); +} + +static int c_playlist_set_share(struct conn *c, + char **vec, + int attribute((unused)) nvec) { + int err; + + if(!(err = trackdb_playlist_set(vec[0], c->who, 0, 0, vec[1]))) { + sink_printf(ev_writer_sink(c->w), "250 OK\n"); + return 1; + } else + return playlist_response(c, err); +} + +static int c_playlists(struct conn *c, + char attribute((unused)) **vec, + int attribute((unused)) nvec) { + char **p; + + trackdb_playlist_list(c->who, &p, 0); + return list_response(c, "List of playlists follows", p); +} + +static int c_playlist_delete(struct conn *c, + char **vec, + int attribute((unused)) nvec) { + int err; + + if(!(err = trackdb_playlist_delete(vec[0], c->who))) { + sink_writes(ev_writer_sink(c->w), "250 OK\n"); + return 1; + } else + return playlist_response(c, err); +} + +static int c_playlist_lock(struct conn *c, + char **vec, + int attribute((unused)) nvec) { + int err; + struct conn *cc; + + /* Check we're allowed to modify this playlist */ + if((err = trackdb_playlist_set(vec[0], c->who, 0, 0, 0))) + return playlist_response(c, err); + /* If we hold a lock don't allow a new one */ + if(c->locked_playlist) { + sink_writes(ev_writer_sink(c->w), "550 Already holding a lock\n"); + return 1; + } + /* See if some other connection locks the same playlist */ + for(cc = connections; cc; cc = cc->next) + if(cc->locked_playlist && !strcmp(cc->locked_playlist, vec[0])) + break; + if(cc) { + /* TODO: implement config->playlist_lock_timeout */ + sink_writes(ev_writer_sink(c->w), "550 Already locked\n"); + return 1; + } + c->locked_playlist = xstrdup(vec[0]); + time(&c->locked_when); + sink_writes(ev_writer_sink(c->w), "250 Acquired lock\n"); + return 1; +} + +static int c_playlist_unlock(struct conn *c, + char attribute((unused)) **vec, + int attribute((unused)) nvec) { + if(!c->locked_playlist) { + sink_writes(ev_writer_sink(c->w), "550 Not holding a lock\n"); + return 1; + } + c->locked_playlist = 0; + sink_writes(ev_writer_sink(c->w), "250 Released lock\n"); + return 1; +} + static const struct command { /** @brief Command name */ const char *name; @@ -1651,6 +1809,14 @@ static const struct command { { "pause", 0, 0, c_pause, RIGHT_PAUSE }, { "play", 1, 1, c_play, RIGHT_PLAY }, { "playing", 0, 0, c_playing, RIGHT_READ }, + { "playlist-delete", 1, 1, c_playlist_delete, RIGHT_PLAY }, + { "playlist-get", 1, 1, c_playlist_get, RIGHT_READ }, + { "playlist-get-share", 1, 1, c_playlist_get_share, RIGHT_READ }, + { "playlist-lock", 1, 1, c_playlist_lock, RIGHT_PLAY }, + { "playlist-set", 1, 1, c_playlist_set, RIGHT_PLAY }, + { "playlist-set-share", 2, 2, c_playlist_set_share, RIGHT_PLAY }, + { "playlist-unlock", 0, 0, c_playlist_unlock, RIGHT_PLAY }, + { "playlists", 0, 0, c_playlists, RIGHT_READ }, { "prefs", 1, 1, c_prefs, RIGHT_READ }, { "queue", 0, 0, c_queue, RIGHT_READ }, { "random-disable", 0, 0, c_random_disable, RIGHT_GLOBAL_PREFS }, @@ -1686,13 +1852,58 @@ static const struct command { { "volume", 0, 2, c_volume, RIGHT_READ|RIGHT_VOLUME } }; +/** @brief Fetch a command body + * @param c Connection + * @param body_callback Called with body + * @param u Passed to body_callback + * @return 1 + */ +static int fetch_body(struct conn *c, + body_callback_type body_callback, + void *u) { + assert(c->line_reader == command); + c->line_reader = body_line; + c->body_callback = body_callback; + c->body_u = u; + vector_init(c->body); + return 1; +} + +/** @brief @ref line_reader_type callback for command body lines + * @param c Connection + * @param line Line + * @return 1 if complete, 0 if incomplete + * + * Called from reader_callback(). + */ +static int body_line(struct conn *c, + char *line) { + if(*line == '.') { + ++line; + if(!*line) { + /* That's the lot */ + c->line_reader = command; + vector_terminate(c->body); + return c->body_callback(c, c->body->vec, c->body->nvec, c->body_u); + } + } + vector_append(c->body, xstrdup(line)); + return 1; /* completed */ +} + static void command_error(const char *msg, void *u) { struct conn *c = u; sink_printf(ev_writer_sink(c->w), "500 parse error: %s\n", msg); } -/* process a command. Return 1 if complete, 0 if incomplete. */ +/** @brief @ref line_reader_type callback for commands + * @param c Connection + * @param line Line + * @return 1 if complete, 0 if incomplete + * + * Called from reader_callback(). + */ static int command(struct conn *c, char *line) { char **vec; int nvec, n; @@ -1711,7 +1922,7 @@ static int command(struct conn *c, char *line) { sink_writes(ev_writer_sink(c->w), "500 do what?\n"); return 1; } - if((n = TABLE_FIND(commands, struct command, name, vec[0])) < 0) + if((n = TABLE_FIND(commands, name, vec[0])) < 0) sink_writes(ev_writer_sink(c->w), "500 unknown command\n"); else { if(commands[n].rights @@ -1763,7 +1974,7 @@ static int reader_callback(ev_source attribute((unused)) *ev, while((eol = memchr(ptr, '\n', bytes))) { *eol++ = 0; ev_reader_consume(reader, eol - (char *)ptr); - complete = command(c, ptr); + complete = c->line_reader(c, ptr); /* usually command() */ bytes -= (eol - (char *)ptr); ptr = eol; if(!complete) { @@ -1804,6 +2015,7 @@ static int listen_callback(ev_source *ev, D(("server listen_callback fd %d (%s)", fd, l->name)); nonblock(fd); cloexec(fd); + c->next = connections; c->tag = tags++; c->ev = ev; c->w = ev_writer_new(ev, fd, writer_error, c, @@ -1815,6 +2027,8 @@ static int listen_callback(ev_source *ev, c->reader = reader_callback; c->l = l; c->rights = 0; + c->line_reader = command; + connections = c; gcry_randomize(c->nonce, sizeof c->nonce, GCRY_STRONG_RANDOM); sink_printf(ev_writer_sink(c->w), "231 %d %s %s\n", 2,