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 Linked list of connections */
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");
}
/* 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");
}
} 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;
}
} 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;
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);
}
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) {
/* 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 {
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
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;
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) {
+ /* TODO */
+}
+
+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", 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");
+ 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");
+ 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 **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;
{ "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_PLAY },
+ { "playlist-get-share", 1, 1, c_playlist_get_share, RIGHT_PLAY },
+ { "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_PLAY },
{ "prefs", 1, 1, c_prefs, RIGHT_READ },
{ "queue", 0, 0, c_queue, RIGHT_READ },
{ "random-disable", 0, 0, c_random_disable, RIGHT_GLOBAL_PREFS },
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,
c->reader = reader_callback;
c->l = l;
c->rights = 0;
+ 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,