D(("S%x writer completed", c->tag));
} else {
if(errno_value != EPIPE)
- error(errno_value, "S%x write error on socket", c->tag);
+ disorder_error(errno_value, "S%x write error on socket", c->tag);
if(c->r) {
D(("cancel reader"));
ev_reader_cancel(c->r);
struct conn *c = u;
D(("server reader_error S%x %d", c->tag, errno_value));
- error(errno_value, "S%x read error on socket", c->tag);
+ disorder_error(errno_value, "S%x read error on socket", c->tag);
if(c->w)
ev_writer_close(c->w);
c->w = 0;
sink_writes(ev_writer_sink(c->w), "550 cannot resolve track\n");
return 1;
}
- q = queue_add(track, c->who, WHERE_BEFORE_RANDOM, origin_picked);
+ q = queue_add(track, c->who, WHERE_BEFORE_RANDOM, NULL, origin_picked);
queue_write();
- /* If we added the first track, and something is playing, then prepare the
- * new track. If nothing is playing then we don't bother as it wouldn't gain
- * anything. */
- if(q == qhead.next && playing)
- prepare(c->ev, q);
sink_printf(ev_writer_sink(c->w), "252 %s\n", q->id);
+ /* We make sure the track at the head of the queue is prepared, just in case
+ * we added it. We could be more subtle but prepare() will ensure we don't
+ * prepare the same track twice so there's no point. */
+ if(qhead.next != &qhead)
+ prepare(c->ev, qhead.next);
/* If the queue was empty but we are for some reason paused then
* unpause. */
if(!playing) resume_playing(0);
return 1; /* completed */
}
+static int c_playafter(struct conn *c, char **vec,
+ int attribute((unused)) nvec) {
+ const char *track;
+ struct queue_entry *q;
+ const char *afterme = vec[0];
+
+ for(int n = 1; n < nvec; ++n) {
+ if(!trackdb_exists(vec[n])) {
+ sink_writes(ev_writer_sink(c->w), "550 track is not in database\n");
+ return 1;
+ }
+ if(!(track = trackdb_resolve(vec[n]))) {
+ sink_writes(ev_writer_sink(c->w), "550 cannot resolve track\n");
+ return 1;
+ }
+ q = queue_add(track, c->who, WHERE_AFTER, afterme, origin_picked);
+ if(!q) {
+ sink_printf(ev_writer_sink(c->w), "550 No such ID\n");
+ return 1;
+ }
+ disorder_info("added %s as %s after %s", track, q->id, afterme);
+ afterme = q->id;
+ }
+ queue_write();
+ sink_printf(ev_writer_sink(c->w), "252 OK\n");
+ /* We make sure the track at the head of the queue is prepared, just in case
+ * we added it. We could be more subtle but prepare() will ensure we don't
+ * prepare the same track twice so there's no point. */
+ if(qhead.next != &qhead) {
+ prepare(c->ev, qhead.next);
+ disorder_info("prepared %s", qhead.next->id);
+ }
+ /* If the queue was empty but we are for some reason paused then
+ * unpause. */
+ if(!playing)
+ resume_playing(0);
+ play(c->ev);
+ return 1; /* completed */
+}
+
static int c_remove(struct conn *c, char **vec,
int attribute((unused)) nvec) {
struct queue_entry *q;
return 1;
}
if(!right_removable(c->rights, c->who, q)) {
- error(0, "%s attempted remove but lacks required rights", c->who);
+ disorder_error(0, "%s attempted remove but lacks required rights", c->who);
sink_writes(ev_writer_sink(c->w),
"510 Not authorized to remove that track\n");
return 1;
* playing track then you will get 550 if you weren't authorized to scratch
* the currently playing track. */
if(!right_scratchable(c->rights, c->who, playing)) {
- error(0, "%s attempted scratch but lacks required rights", c->who);
+ disorder_error(0, "%s attempted scratch but lacks required rights", c->who);
sink_writes(ev_writer_sink(c->w),
"510 Not authorized to scratch that track\n");
return 1;
static int c_shutdown(struct conn *c,
char attribute((unused)) **vec,
int attribute((unused)) nvec) {
- info("S%x shut down by %s", c->tag, c->who);
+ disorder_info("S%x shut down by %s", c->tag, c->who);
sink_writes(ev_writer_sink(c->w), "250 shutting down\n");
ev_writer_flush(c->w);
quit(c->ev);
static int c_reconfigure(struct conn *c,
char attribute((unused)) **vec,
int attribute((unused)) nvec) {
- info("S%x reconfigure by %s", c->tag, c->who);
+ disorder_info("S%x reconfigure by %s", c->tag, c->who);
if(reconfigure(c->ev, 1))
sink_writes(ev_writer_sink(c->w), "550 error reading new config\n");
else
}
}
/* Report what was requested */
- info("S%x rescan by %s (%s %s)", c->tag, c->who,
- flag_wait ? "wait" : "",
- flag_fresh ? "fresh" : "");
+ disorder_info("S%x rescan by %s (%s %s)", c->tag, c->who,
+ flag_wait ? "wait" : "",
+ flag_fresh ? "fresh" : "");
if(trackdb_rescan_underway()) {
if(flag_fresh) {
/* We want a fresh rescan but there is already one underway. Arrange a
/* get connection data */
l = sizeof u;
if(getpeername(c->fd, &u.sa, &l) < 0) {
- error(errno, "S%x error calling getpeername", c->tag);
+ disorder_error(errno, "S%x error calling getpeername", c->tag);
return 0;
}
if(c->l->pf != PF_UNIX) {
if((n = getnameinfo(&u.sa, l,
host, sizeof host, 0, 0, NI_NUMERICHOST))) {
- error(0, "S%x error calling getnameinfo: %s", c->tag, gai_strerror(n));
+ disorder_error(0, "S%x error calling getnameinfo: %s",
+ c->tag, gai_strerror(n));
return 0;
}
return xstrdup(host);
k = trackdb_getuserinfo(vec[0]);
/* reject nonexistent users */
if(!k) {
- error(0, "S%x unknown user '%s' from %s", c->tag, vec[0], host);
+ disorder_error(0, "S%x unknown user '%s' from %s", c->tag, vec[0], host);
sink_writes(ev_writer_sink(c->w), "530 authentication failed\n");
return 1;
}
/* reject unconfirmed users */
if(kvp_get(k, "confirmation")) {
- error(0, "S%x unconfirmed user '%s' from %s", c->tag, vec[0], host);
+ disorder_error(0, "S%x unconfirmed user '%s' from %s",
+ c->tag, vec[0], host);
sink_writes(ev_writer_sink(c->w), "530 authentication failed\n");
return 1;
}
password = kvp_get(k, "password");
if(!password) password = "";
if(parse_rights(kvp_get(k, "rights"), &rights, 1)) {
- error(0, "error parsing rights for %s", vec[0]);
+ disorder_error(0, "error parsing rights for %s", vec[0]);
sink_writes(ev_writer_sink(c->w), "530 authentication failed\n");
return 1;
}
c->rights = rights;
/* currently we only bother logging remote connections */
if(strcmp(host, "local"))
- info("S%x %s connected from %s", c->tag, vec[0], host);
+ disorder_info("S%x %s connected from %s", c->tag, vec[0], host);
else
c->rights |= RIGHT__LOCAL;
sink_writes(ev_writer_sink(c->w), "230 OK\n");
return 1;
}
/* oops, response was wrong */
- info("S%x authentication failure for %s from %s", c->tag, vec[0], host);
+ disorder_info("S%x authentication failure for %s from %s",
+ c->tag, vec[0], host);
sink_writes(ev_writer_sink(c->w), "530 authentication failed\n");
return 1;
}
queue_fix_sofar(playing);
if((l = trackdb_get(playing->track, "_length"))
&& (length = atol(l))) {
- time(&when);
+ xtime(&when);
when += length - playing->sofar + config->gap;
}
} else
/* Nothing is playing but playing is enabled, so whatever is
* first in the queue can be expected to start immediately. */
- time(&when);
+ xtime(&when);
}
for(q = qhead.next; q != &qhead; q = q->next) {
/* fill in estimated start time */
}
rights = set ? RIGHT_VOLUME : RIGHT_READ;
if(!(c->rights & rights)) {
- error(0, "%s attempted to set volume but lacks required rights", c->who);
+ disorder_error(0, "%s attempted to set volume but lacks required rights",
+ c->who);
sink_writes(ev_writer_sink(c->w), "510 Prohibited\n");
return 1;
}
return;
}
sink_printf(ev_writer_sink(c->w), "%"PRIxMAX" %s\n",
- (uintmax_t)time(0), msg);
+ (uintmax_t)xtime(0), msg);
}
static int c_log(struct conn *c,
sink_writes(ev_writer_sink(c->w), "254 OK\n");
/* pump out initial state */
- time(&now);
+ xtime(&now);
sink_printf(ev_writer_sink(c->w), "%"PRIxMAX" state %s\n",
(uintmax_t)now,
playing_is_enabled() ? "enable_play" : "disable_play");
return 1;
}
if(!has_move_rights(c, &q, 1)) {
- error(0, "%s attempted move but lacks required rights", c->who);
+ disorder_error(0, "%s attempted move but lacks required rights", c->who);
sink_writes(ev_writer_sink(c->w),
"510 Not authorized to move that track\n");
return 1;
return 1;
}
if(!has_move_rights(c, qs, nvec)) {
- error(0, "%s attempted moveafter but lacks required rights", c->who);
+ disorder_error(0, "%s attempted moveafter but lacks required rights",
+ c->who);
sink_writes(ev_writer_sink(c->w),
"510 Not authorized to move those tracks\n");
return 1;
static int c_new(struct conn *c,
char **vec,
int nvec) {
- int max, n;
+ int max;
char **tracks;
if(nvec > 0)
max = config->new_max;
tracks = trackdb_new(0, max);
sink_printf(ev_writer_sink(c->w), "253 New track list follows\n");
- n = 0;
while(*tracks) {
sink_printf(ev_writer_sink(c->w), "%s%s\n",
**tracks == '.' ? "." : "", *tracks);
c->cookie = vec[0];
c->rights = rights;
if(strcmp(host, "local"))
- info("S%x %s connected with cookie from %s", c->tag, user, host);
+ disorder_info("S%x %s connected with cookie from %s", c->tag, user, host);
else
c->rights |= RIGHT__LOCAL;
/* Response contains username so client knows who they are acting as */
const char *rights;
if(!config->remote_userman && !(c->rights & RIGHT__LOCAL)) {
- error(0, "S%x: remote adduser", c->tag);
+ disorder_error(0, "S%x: remote adduser", c->tag);
sink_writes(ev_writer_sink(c->w), "550 Remote user management is disabled\n");
return 1;
}
struct conn *d;
if(!config->remote_userman && !(c->rights & RIGHT__LOCAL)) {
- error(0, "S%x: remote deluser", c->tag);
+ disorder_error(0, "S%x: remote deluser", c->tag);
sink_writes(ev_writer_sink(c->w), "550 Remote user management is disabled\n");
return 1;
}
struct conn *d;
if(!config->remote_userman && !(c->rights & RIGHT__LOCAL)) {
- error(0, "S%x: remote edituser", c->tag);
+ disorder_error(0, "S%x: remote edituser", c->tag);
sink_writes(ev_writer_sink(c->w), "550 Remote user management is disabled\n");
return 1;
}
if(d->lo)
sink_printf(ev_writer_sink(d->w),
"%"PRIxMAX" rights_changed %s\n",
- (uintmax_t)time(0),
+ (uintmax_t)xtime(0),
quoteutf8(new_rights));
}
}
}
sink_writes(ev_writer_sink(c->w), "250 OK\n");
} else {
- error(0, "%s attempted edituser but lacks required rights", c->who);
+ disorder_error(0, "%s attempted edituser but lacks required rights",
+ c->who);
sink_writes(ev_writer_sink(c->w), "510 Restricted to administrators\n");
}
return 1;
if(!config->remote_userman
&& !(c->rights & RIGHT__LOCAL)
&& strcmp(vec[1], "rights")) {
- error(0, "S%x: remote userinfo %s %s", c->tag, vec[0], vec[1]);
+ disorder_error(0, "S%x: remote userinfo %s %s", c->tag, vec[0], vec[1]);
sink_writes(ev_writer_sink(c->w), "550 Remote user management is disabled\n");
return 1;
}
else
sink_writes(ev_writer_sink(c->w), "550 No such user\n");
} else {
- error(0, "%s attempted userinfo but lacks required rights", c->who);
+ disorder_error(0, "%s attempted userinfo but lacks required rights",
+ c->who);
sink_writes(ev_writer_sink(c->w), "510 Restricted to administrators\n");
}
return 1;
* letters and digits, minimizing the chance of the URL being mispasted. */
gcry_randomize(nonce, sizeof nonce, GCRY_STRONG_RANDOM);
if(basen(nonce, CONFIRM_SIZE, nonce_str, sizeof nonce_str, 62)) {
- error(0, "buffer too small encoding confirmation string");
+ disorder_error(0, "buffer too small encoding confirmation string");
sink_writes(ev_writer_sink(c->w), "550 Cannot create user\n");
}
byte_xasprintf(&cs, "%s/%s", vec[0], nonce_str);
c->cookie = 0;
c->rights = rights;
if(strcmp(host, "local"))
- info("S%x %s confirmed from %s", c->tag, user, host);
+ disorder_info("S%x %s confirmed from %s", c->tag, user, host);
else
c->rights |= RIGHT__LOCAL;
/* Response contains username so client knows who they are acting as */
if(!status) {
sink_writes(ev_writer_sink(c->w), "250 OK\n");
} else {
- error(0, "reminder subprocess %s", wstat(status));
+ disorder_error(0, "reminder subprocess %s", wstat(status));
sink_writes(ev_writer_sink(c->w), "550 Cannot send a reminder email\n");
}
/* Re-enable this connection */
static hash *last_reminder;
if(!config->mail_sender) {
- error(0, "cannot send password reminders because mail_sender not set");
+ disorder_error(0, "cannot send password reminders because mail_sender not set");
sink_writes(ev_writer_sink(c->w), "550 Cannot send a reminder email\n");
return 1;
}
if(!(k = trackdb_getuserinfo(vec[0]))) {
- error(0, "reminder for user '%s' who does not exist", vec[0]);
+ disorder_error(0, "reminder for user '%s' who does not exist", vec[0]);
sink_writes(ev_writer_sink(c->w), "550 Cannot send a reminder email\n");
return 1;
}
if(!(email = kvp_get(k, "email"))
|| !email_valid(email)) {
- error(0, "user '%s' has no valid email address", vec[0]);
+ disorder_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;
}
if(!(password = kvp_get(k, "password"))
|| !*password) {
- error(0, "user '%s' has no password", vec[0]);
+ disorder_error(0, "user '%s' has no password", vec[0]);
sink_writes(ev_writer_sink(c->w), "550 Cannot send a reminder email\n");
return 1;
}
if(!last_reminder)
last_reminder = hash_new(sizeof (time_t));
last = hash_find(last_reminder, vec[0]);
- time(&now);
+ xtime(&now);
if(last && now < *last + config->reminder_interval) {
- error(0, "sent a password reminder to '%s' too recently", vec[0]);
+ disorder_error(0, "sent a password reminder to '%s' too recently", vec[0]);
sink_writes(ev_writer_sink(c->w), "550 Cannot send a reminder email\n");
return 1;
}
"\n"
" %s\n", password);
if(!(text = mime_encode_text(text, &charset, &encoding)))
- fatal(0, "cannot encode email");
+ disorder_fatal(0, "cannot encode email");
byte_xasprintf((char **)&content_type, "text/plain;charset=%s",
quote822(charset, 0));
pid = sendmail_subprocess("", config->mail_sender, email,
return 1;
}
hash_add(last_reminder, vec[0], &now, HASH_INSERT_OR_REPLACE);
- info("sending a passsword reminder to user '%s'", vec[0]);
+ disorder_info("sending a passsword reminder to user '%s'", vec[0]);
/* We can only continue when the subprocess finishes */
ev_child(c->ev, pid, 0, sent_reminder, c);
return 0;
{ "part", 3, 3, c_part, RIGHT_READ },
{ "pause", 0, 0, c_pause, RIGHT_PAUSE },
{ "play", 1, 1, c_play, RIGHT_PLAY },
+ { "playafter", 2, INT_MAX, c_playafter, 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 },
else {
if(commands[n].rights
&& !(c->rights & commands[n].rights)) {
- error(0, "%s attempted %s but lacks required rights", c->who ? c->who : "NULL",
+ disorder_error(0, "%s attempted %s but lacks required rights",
+ c->who ? c->who : "NULL",
commands[n].name);
sink_writes(ev_writer_sink(c->w), "510 Prohibited\n");
return 1;
}
if(eof) {
if(bytes)
- error(0, "S%x unterminated line", c->tag);
+ disorder_error(0, "S%x unterminated line", c->tag);
D(("normal reader close"));
c->r = 0;
if(c->w) {
c->w = ev_writer_new(ev, fd, writer_error, c,
"client writer");
if(!c->w) {
- error(0, "ev_writer_new for file inbound connection (fd=%d) failed",
+ disorder_error(0, "ev_writer_new for file inbound connection (fd=%d) failed",
fd);
close(fd);
return 0;
if(!c->r)
/* Main reason for failure is the FD is too big and that will already have
* been handled */
- fatal(0, "ev_reader_new for file inbound connection (fd=%d) failed", fd);
+ disorder_fatal(0,
+ "ev_reader_new for file inbound connection (fd=%d) failed",
+ fd);
ev_tie(c->r, c->w);
c->fd = fd;
c->reader = reader_callback;
fd = xsocket(pf, SOCK_STREAM, 0);
xsetsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
if(bind(fd, sa, socklen) < 0) {
- error(errno, "error binding to %s", name);
+ disorder_error(errno, "error binding to %s", name);
return -1;
}
xlisten(fd, 128);
l->pf = pf;
if(ev_listen(ev, fd, listen_callback, l, "server listener"))
exit(EXIT_FAILURE);
- info("listening on %s", name);
+ disorder_info("listening on %s", name);
return fd;
}
~mdw / disorder / blobdiff