/* * Copyright (C) 2010-2011 Julien BLACHE * * 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 * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifdef HAVE_CONFIG_H # include #endif #include #include #include #include #include #include #include #include #include #include #include #if defined(HAVE_SYS_EVENTFD_H) && defined(HAVE_EVENTFD) # define USE_EVENTFD # include #endif #include #include #include #include "logger.h" #include "misc.h" #include "conffile.h" #include "artwork.h" #include "httpd.h" #include "httpd_dacp.h" #include "dmap_common.h" #include "db.h" #include "daap_query.h" #include "player.h" #include "queue.h" #include "listener.h" /* httpd event base, from httpd.c */ extern struct event_base *evbase_httpd; /* From httpd_daap.c */ struct daap_session; struct daap_session * daap_session_find(struct evhttp_request *req, struct evkeyvalq *query, struct evbuffer *evbuf); struct uri_map { regex_t preg; char *regexp; void (*handler)(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query); }; struct dacp_update_request { struct evhttp_request *req; struct dacp_update_request *next; }; typedef void (*dacp_propget)(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); typedef void (*dacp_propset)(const char *value, struct evkeyvalq *query); struct dacp_prop_map { char *desc; dacp_propget propget; dacp_propset propset; }; /* Forward - properties getters */ static void dacp_propget_volume(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_volumecontrollable(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_playerstate(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_shufflestate(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_availableshufflestates(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_repeatstate(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_availablerepeatstates(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_nowplaying(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_playingtime(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_fullscreenenabled(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_fullscreen(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_visualizerenabled(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_visualizer(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_itms_songid(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_haschapterdata(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_mediakind(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); static void dacp_propget_extendedmediakind(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi); /* Forward - properties setters */ static void dacp_propset_volume(const char *value, struct evkeyvalq *query); static void dacp_propset_playingtime(const char *value, struct evkeyvalq *query); static void dacp_propset_shufflestate(const char *value, struct evkeyvalq *query); static void dacp_propset_repeatstate(const char *value, struct evkeyvalq *query); static void dacp_propset_userrating(const char *value, struct evkeyvalq *query); /* gperf static hash, dacp_prop.gperf */ #include "dacp_prop_hash.c" /* Play status update */ #ifdef USE_EVENTFD static int update_efd; #else static int update_pipe[2]; #endif static struct event *updateev; static int current_rev; /* Play status update requests */ static struct dacp_update_request *update_requests; /* Seek timer */ static struct event *seek_timer; static int seek_target; /* If an item is removed from the library while in the queue, we replace it with this */ static struct media_file_info dummy_mfi = { .id = 9999999, .title = "(unknown title)", .artist = "(unknown artist)", .album = "(unknown album)", .genre = "(unknown genre)", }; /* DACP helpers */ static void dacp_nowplaying(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { uint32_t id; int64_t songalbumid; if ((status->status == PLAY_STOPPED) || !mfi) return; /* Send bogus id's if playing internet radio, because clients like * Remote and Retune will only update metadata (like artwork) if the id's * change (which they wouldn't do if we sent the real ones) * FIXME: Giving the client invalid ids on purpose is hardly ideal, but the * clients don't seem to use these ids for anything other than rating. */ if (mfi->data_kind == DATA_KIND_HTTP) { id = djb_hash(mfi->album, strlen(mfi->album)); songalbumid = (int64_t)id; } else { id = status->id; songalbumid = mfi->songalbumid; } dmap_add_container(evbuf, "canp", 16); dmap_add_raw_uint32(evbuf, 1); /* Database */ dmap_add_raw_uint32(evbuf, status->plid); dmap_add_raw_uint32(evbuf, status->pos_pl); dmap_add_raw_uint32(evbuf, id); dmap_add_string(evbuf, "cann", mfi->title); dmap_add_string(evbuf, "cana", mfi->artist); dmap_add_string(evbuf, "canl", mfi->album); dmap_add_string(evbuf, "cang", mfi->genre); dmap_add_long(evbuf, "asai", songalbumid); dmap_add_int(evbuf, "cmmk", 1); } static void dacp_playingtime(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { if ((status->status == PLAY_STOPPED) || !mfi) return; if (mfi->song_length) dmap_add_int(evbuf, "cant", mfi->song_length - status->pos_ms); /* Remaining time in ms */ else dmap_add_int(evbuf, "cant", 0); /* Unknown remaining time */ dmap_add_int(evbuf, "cast", mfi->song_length); /* Song length in ms */ } /* Update requests helpers */ static int make_playstatusupdate(struct evbuffer *evbuf) { struct player_status status; struct media_file_info *mfi; struct evbuffer *psu; int ret; psu = evbuffer_new(); if (!psu) { DPRINTF(E_LOG, L_DACP, "Could not allocate evbuffer for playstatusupdate\n"); return -1; } player_get_status(&status); if (status.status != PLAY_STOPPED) { mfi = db_file_fetch_byid(status.id); if (!mfi) { DPRINTF(E_LOG, L_DACP, "Could not fetch file id %d\n", status.id); mfi = &dummy_mfi; } } else mfi = NULL; dmap_add_int(psu, "mstt", 200); /* 12 */ dmap_add_int(psu, "cmsr", current_rev); /* 12 */ dmap_add_char(psu, "caps", status.status); /* 9 */ /* play status, 2 = stopped, 3 = paused, 4 = playing */ dmap_add_char(psu, "cash", status.shuffle); /* 9 */ /* shuffle, true/false */ dmap_add_char(psu, "carp", status.repeat); /* 9 */ /* repeat, 0 = off, 1 = repeat song, 2 = repeat (playlist) */ dmap_add_char(psu, "cafs", 0); /* 9 */ /* dacp.fullscreen */ dmap_add_char(psu, "cavs", 0); /* 9 */ /* dacp.visualizer */ dmap_add_char(psu, "cavc", 1); /* 9 */ /* volume controllable */ dmap_add_int(psu, "caas", 2); /* 12 */ /* available shuffle states */ dmap_add_int(psu, "caar", 6); /* 12 */ /* available repeat states */ dmap_add_char(psu, "cafe", 0); /* 9 */ /* dacp.fullscreenenabled */ dmap_add_char(psu, "cave", 0); /* 9 */ /* dacp.visualizerenabled */ if (mfi) { dacp_nowplaying(psu, &status, mfi); dmap_add_int(psu, "casa", 1); /* 12 */ /* unknown */ dmap_add_int(psu, "astm", mfi->song_length); dmap_add_char(psu, "casc", 1); /* Maybe an indication of extra data? */ dmap_add_char(psu, "caks", 6); /* Unknown */ dacp_playingtime(psu, &status, mfi); if (mfi != &dummy_mfi) free_mfi(mfi, 0); } dmap_add_char(psu, "casu", 1); /* 9 */ /* unknown */ dmap_add_char(psu, "ceQu", 0); /* 9 */ /* unknown */ dmap_add_container(evbuf, "cmst", evbuffer_get_length(psu)); /* 8 + len */ ret = evbuffer_add_buffer(evbuf, psu); evbuffer_free(psu); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not add status data to playstatusupdate reply\n"); return -1; } return 0; } static void playstatusupdate_cb(int fd, short what, void *arg) { struct dacp_update_request *ur; struct evbuffer *evbuf; struct evbuffer *update; struct evhttp_connection *evcon; uint8_t *buf; size_t len; int ret; #ifdef USE_EVENTFD eventfd_t count; ret = eventfd_read(update_efd, &count); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not read playstatusupdate event counter: %s\n", strerror(errno)); goto readd; } #else int dummy; read(update_pipe[0], &dummy, sizeof(dummy)); #endif if (!update_requests) goto readd; evbuf = evbuffer_new(); if (!evbuf) { DPRINTF(E_LOG, L_DACP, "Could not allocate evbuffer for playstatusupdate reply\n"); goto readd; } update = evbuffer_new(); if (!update) { DPRINTF(E_LOG, L_DACP, "Could not allocate evbuffer for playstatusupdate data\n"); goto out_free_evbuf; } ret = make_playstatusupdate(update); if (ret < 0) goto out_free_update; len = evbuffer_get_length(update); for (ur = update_requests; update_requests; ur = update_requests) { update_requests = ur->next; evcon = evhttp_request_get_connection(ur->req); if (evcon) evhttp_connection_set_closecb(evcon, NULL, NULL); // Only copy buffer if we actually need to reuse it if (ur->next) { buf = evbuffer_pullup(update, -1); evbuffer_add(evbuf, buf, len); httpd_send_reply(ur->req, HTTP_OK, "OK", evbuf); } else httpd_send_reply(ur->req, HTTP_OK, "OK", update); free(ur); } current_rev++; out_free_update: evbuffer_free(update); out_free_evbuf: evbuffer_free(evbuf); readd: ret = event_add(updateev, NULL); if (ret < 0) DPRINTF(E_LOG, L_DACP, "Couldn't re-add event for playstatusupdate\n"); } /* Thread: player */ static void dacp_playstatus_update_handler(enum listener_event_type type) { int ret; // Only send status update on player change events if (type != LISTENER_PLAYER) return; #ifdef USE_EVENTFD ret = eventfd_write(update_efd, 1); if (ret < 0) DPRINTF(E_LOG, L_DACP, "Could not send status update event: %s\n", strerror(errno)); #else int dummy = 42; ret = write(update_pipe[1], &dummy, sizeof(dummy)); if (ret != sizeof(dummy)) DPRINTF(E_LOG, L_DACP, "Could not write to status update fd: %s\n", strerror(errno)); #endif } static void update_fail_cb(struct evhttp_connection *evcon, void *arg) { struct dacp_update_request *ur; struct dacp_update_request *p; struct evhttp_connection *evc; ur = (struct dacp_update_request *)arg; DPRINTF(E_DBG, L_DACP, "Update request: client closed connection\n"); evc = evhttp_request_get_connection(ur->req); if (evc) evhttp_connection_set_closecb(evc, NULL, NULL); if (ur == update_requests) update_requests = ur->next; else { for (p = update_requests; p && (p->next != ur); p = p->next) ; if (!p) { DPRINTF(E_LOG, L_DACP, "WARNING: struct dacp_update_request not found in list; BUG!\n"); return; } p->next = ur->next; } free(ur); } /* Properties getters */ static void dacp_propget_volume(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dmap_add_int(evbuf, "cmvo", status->volume); } static void dacp_propget_volumecontrollable(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dmap_add_char(evbuf, "cavc", 1); } static void dacp_propget_playerstate(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dmap_add_char(evbuf, "caps", status->status); } static void dacp_propget_shufflestate(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dmap_add_char(evbuf, "cash", status->shuffle); } static void dacp_propget_availableshufflestates(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dmap_add_int(evbuf, "caas", 2); } static void dacp_propget_repeatstate(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dmap_add_char(evbuf, "carp", status->repeat); } static void dacp_propget_availablerepeatstates(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dmap_add_int(evbuf, "caar", 6); } static void dacp_propget_nowplaying(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dacp_nowplaying(evbuf, status, mfi); } static void dacp_propget_playingtime(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { dacp_playingtime(evbuf, status, mfi); } static void dacp_propget_fullscreenenabled(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } static void dacp_propget_fullscreen(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } static void dacp_propget_visualizerenabled(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } static void dacp_propget_visualizer(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } static void dacp_propget_itms_songid(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } static void dacp_propget_haschapterdata(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } static void dacp_propget_mediakind(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } static void dacp_propget_extendedmediakind(struct evbuffer *evbuf, struct player_status *status, struct media_file_info *mfi) { // TODO } /* Properties setters */ static void dacp_propset_volume(const char *value, struct evkeyvalq *query) { const char *param; uint64_t id; int volume; int ret; ret = safe_atoi32(value, &volume); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "dmcp.volume argument doesn't convert to integer: %s\n", value); return; } param = evhttp_find_header(query, "speaker-id"); if (param) { ret = safe_atou64(param, &id); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid speaker ID in dmcp.volume request\n"); return; } player_volume_setrel_speaker(id, volume); return; } param = evhttp_find_header(query, "include-speaker-id"); if (param) { ret = safe_atou64(param, &id); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid speaker ID in dmcp.volume request\n"); return; } player_volume_setabs_speaker(id, volume); return; } player_volume_set(volume); } static void seek_timer_cb(int fd, short what, void *arg) { int ret; DPRINTF(E_DBG, L_DACP, "Seek timer expired, target %d ms\n", seek_target); ret = player_playback_seek(seek_target); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Player failed to seek to %d ms\n", seek_target); return; } ret = player_playback_start(NULL); if (ret < 0) DPRINTF(E_LOG, L_DACP, "Player returned an error for start after seek\n"); } static void dacp_propset_playingtime(const char *value, struct evkeyvalq *query) { struct timeval tv; int ret; ret = safe_atoi32(value, &seek_target); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "dacp.playingtime argument doesn't convert to integer: %s\n", value); return; } evutil_timerclear(&tv); tv.tv_usec = 200 * 1000; evtimer_add(seek_timer, &tv); } static void dacp_propset_shufflestate(const char *value, struct evkeyvalq *query) { int enable; int ret; ret = safe_atoi32(value, &enable); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "dacp.shufflestate argument doesn't convert to integer: %s\n", value); return; } player_shuffle_set(enable); } static void dacp_propset_repeatstate(const char *value, struct evkeyvalq *query) { int mode; int ret; ret = safe_atoi32(value, &mode); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "dacp.repeatstate argument doesn't convert to integer: %s\n", value); return; } player_repeat_set(mode); } static void dacp_propset_userrating(const char *value, struct evkeyvalq *query) { struct media_file_info *mfi; const char *param; uint32_t itemid; uint32_t rating; int ret; ret = safe_atou32(value, &rating); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "dacp.userrating argument doesn't convert to integer: %s\n", value); return; } param = evhttp_find_header(query, "item-spec"); // Remote if (!param) param = evhttp_find_header(query, "song-spec"); // Retune if (!param) { DPRINTF(E_LOG, L_DACP, "Missing item-spec/song-spec parameter in dacp.userrating query\n"); return; } param = strchr(param, ':'); if (!param) { DPRINTF(E_LOG, L_DACP, "Malformed item-spec/song-spec parameter in dacp.userrating query\n"); return; } param++; ret = safe_hextou32(param, &itemid); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Couldn't convert item-spec/song-spec to an integer in dacp.userrating (%s)\n", param); return; } mfi = db_file_fetch_byid(itemid); /* If no mfi, it may be because we sent an invalid nowplaying itemid. In this * case request the real one from the player and default to that. */ if (!mfi) { DPRINTF(E_WARN, L_DACP, "Invalid id %d for rating, defaulting to player id\n", itemid); ret = player_now_playing(&itemid); if ((ret < 0) || !(mfi = db_file_fetch_byid(itemid))) { DPRINTF(E_WARN, L_DACP, "Could not find an id for rating\n"); return; } } mfi->rating = rating; /* We're not touching any string field in mfi, so it's safe to * skip unicode_fixup_mfi() before the update */ db_file_update(mfi); free_mfi(mfi, 0); } static void dacp_reply_ctrlint(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { /* /ctrl-int */ /* If tags are added or removed container sizes should be adjusted too */ dmap_add_container(evbuf, "caci", 194); /* 8, unknown dacp container - size of content */ dmap_add_int(evbuf, "mstt", 200); /* 12, dmap.status */ dmap_add_char(evbuf, "muty", 0); /* 9, dmap.updatetype */ dmap_add_int(evbuf, "mtco", 1); /* 12, dmap.specifiedtotalcount */ dmap_add_int(evbuf, "mrco", 1); /* 12, dmap.returnedcount */ dmap_add_container(evbuf, "mlcl", 141); /* 8, dmap.listing - size of content */ dmap_add_container(evbuf, "mlit", 133); /* 8, dmap.listingitem - size of content */ dmap_add_int(evbuf, "miid", 1); /* 12, dmap.itemid - database ID */ dmap_add_char(evbuf, "cmik", 1); /* 9, unknown */ dmap_add_int(evbuf, "cmpr", (2 << 16 | 2)); /* 12, dmcp.protocolversion */ dmap_add_int(evbuf, "capr", (2 << 16 | 5)); /* 12, dacp.protocolversion */ dmap_add_char(evbuf, "cmsp", 1); /* 9, unknown */ dmap_add_char(evbuf, "aeFR", 0x64); /* 9, unknown */ dmap_add_char(evbuf, "cmsv", 1); /* 9, unknown */ dmap_add_char(evbuf, "cass", 1); /* 9, unknown */ dmap_add_char(evbuf, "caov", 1); /* 9, unknown */ dmap_add_char(evbuf, "casu", 1); /* 9, unknown */ dmap_add_char(evbuf, "ceSG", 1); /* 9, unknown */ dmap_add_char(evbuf, "cmrl", 1); /* 9, unknown */ dmap_add_long(evbuf, "ceSX", (1 << 1 | 1)); /* 16, unknown dacp - lowest bit announces support for playqueue-contents/-edit */ httpd_send_reply(req, HTTP_OK, "OK", evbuf); } static int find_first_song_id(const char *query) { struct db_media_file_info dbmfi; struct query_params qp; int id; int ret; memset(&qp, 0, sizeof(struct query_params)); /* We only want the id of the first song */ qp.type = Q_ITEMS; qp.idx_type = I_FIRST; qp.sort = S_NONE; qp.offset = 0; qp.limit = 1; qp.filter = daap_query_parse_sql(query); if (!qp.filter) { DPRINTF(E_LOG, L_PLAYER, "Improper DAAP query!\n"); return -1; } ret = db_query_start(&qp); if (ret < 0) { DPRINTF(E_LOG, L_PLAYER, "Could not start query\n"); goto no_query_start; } if (((ret = db_query_fetch_file(&qp, &dbmfi)) == 0) && (dbmfi.id)) { ret = safe_atoi32(dbmfi.id, &id); if (ret < 0) { DPRINTF(E_LOG, L_PLAYER, "Invalid song id in query result!\n"); goto no_result; } DPRINTF(E_DBG, L_PLAYER, "Found index song (id %d)\n", id); ret = 1; } else { DPRINTF(E_LOG, L_PLAYER, "No song matches query (results %d): %s\n", qp.results, qp.filter); goto no_result; } no_result: db_query_end(&qp); no_query_start: if (qp.filter) free(qp.filter); if (ret == 1) return id; else return -1; } static int dacp_queueitem_make(struct queue_item **head, const char *query, const char *queuefilter, const char *sort, int quirk) { struct media_file_info *mfi; struct query_params qp; struct queue_item *items; int64_t albumid; int64_t artistid; int plid; int id; int idx; int ret; int len; char *s; char buf[1024]; if (query) { id = find_first_song_id(query); if (id < 0) return -1; } else id = 0; memset(&qp, 0, sizeof(struct query_params)); qp.offset = 0; qp.limit = 0; qp.sort = S_NONE; qp.idx_type = I_NONE; if (quirk) { qp.sort = S_ALBUM; qp.type = Q_ITEMS; mfi = db_file_fetch_byid(id); if (!mfi) return -1; snprintf(buf, sizeof(buf), "f.songalbumid = %" PRIi64, mfi->songalbumid); free_mfi(mfi, 0); qp.filter = strdup(buf); } else if (queuefilter) { len = strlen(queuefilter); if ((len > 6) && (strncmp(queuefilter, "album:", 6) == 0)) { qp.type = Q_ITEMS; ret = safe_atoi64(strchr(queuefilter, ':') + 1, &albumid); if (ret < 0) { DPRINTF(E_LOG, L_PLAYER, "Invalid album id in queuefilter: %s\n", queuefilter); return -1; } snprintf(buf, sizeof(buf), "f.songalbumid = %" PRIi64, albumid); qp.filter = strdup(buf); } else if ((len > 7) && (strncmp(queuefilter, "artist:", 7) == 0)) { qp.type = Q_ITEMS; ret = safe_atoi64(strchr(queuefilter, ':') + 1, &artistid); if (ret < 0) { DPRINTF(E_LOG, L_PLAYER, "Invalid artist id in queuefilter: %s\n", queuefilter); return -1; } snprintf(buf, sizeof(buf), "f.songartistid = %" PRIi64, artistid); qp.filter = strdup(buf); } else if ((len > 9) && (strncmp(queuefilter, "playlist:", 9) == 0)) { qp.type = Q_PLITEMS; ret = safe_atoi32(strchr(queuefilter, ':') + 1, &plid); if (ret < 0) { DPRINTF(E_LOG, L_PLAYER, "Invalid playlist id in queuefilter: %s\n", queuefilter); return -1; } qp.id = plid; qp.filter = strdup("1 = 1"); } else if ((len > 6) && (strncmp(queuefilter, "genre:", 6) == 0)) { qp.type = Q_ITEMS; s = db_escape_string(queuefilter + 6); if (!s) return -1; snprintf(buf, sizeof(buf), "f.genre = '%s'", s); qp.filter = strdup(buf); } else { DPRINTF(E_LOG, L_PLAYER, "Unknown queuefilter %s\n", queuefilter); // If the queuefilter is unkown, ignore it and use the query parameter instead to build the sql query id = 0; qp.type = Q_ITEMS; qp.filter = daap_query_parse_sql(query); } } else { id = 0; qp.type = Q_ITEMS; qp.filter = daap_query_parse_sql(query); } if (sort) { if (strcmp(sort, "name") == 0) qp.sort = S_NAME; else if (strcmp(sort, "album") == 0) qp.sort = S_ALBUM; else if (strcmp(sort, "artist") == 0) qp.sort = S_ARTIST; } items = queueitem_make_byquery(&qp); if (qp.filter) free(qp.filter); if (items) *head = items; else return -1; // Get the position (0-based) of the first item idx = queueitem_pos(items, id); return idx; } static void dacp_reply_cue_play(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct player_status status; struct queue_item *items; const char *sort; const char *cuequery; const char *param; uint32_t id; uint32_t item_id; uint32_t pos; int clear; struct player_history *history; int hist; int ret; /* /cue?command=play&query=...&sort=...&index=N */ param = evhttp_find_header(query, "clear-first"); if (param) { ret = safe_atoi32(param, &clear); if (ret < 0) DPRINTF(E_LOG, L_DACP, "Invalid clear-first value in cue request\n"); else if (clear) { player_playback_stop(); player_queue_clear(); } } cuequery = evhttp_find_header(query, "query"); if (cuequery) { sort = evhttp_find_header(query, "sort"); ret = dacp_queueitem_make(&items, cuequery, NULL, sort, 0); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not build song queue\n"); dmap_send_error(req, "cacr", "Could not build song queue"); return; } player_queue_add(items, NULL); } else { player_get_status(&status); if (status.status != PLAY_STOPPED) player_playback_stop(); } param = evhttp_find_header(query, "dacp.shufflestate"); if (param) dacp_propset_shufflestate(param, NULL); id = 0; item_id = 0; pos = 0; param = evhttp_find_header(query, "index"); if (param) { ret = safe_atou32(param, &pos); if (ret < 0) DPRINTF(E_LOG, L_DACP, "Invalid index (%s) in cue request\n", param); } /* If selection was from Up Next queue or history queue (command will be playnow), then index is relative */ hist = 0; if ((param = evhttp_find_header(query, "command")) && (strcmp(param, "playnow") == 0)) { /* If mode parameter is -1 or 1, the index is relative to the history queue, otherwise to the Up Next queue */ param = evhttp_find_header(query, "mode"); if (param && ((strcmp(param, "-1") == 0) || (strcmp(param, "1") == 0))) { /* Play from history queue */ hist = 1; history = player_history_get(); if (history->count > pos) { pos = (history->start_index + history->count - pos - 1) % MAX_HISTORY_COUNT; item_id = history->item_id[pos]; } else { DPRINTF(E_LOG, L_DACP, "Could not start playback from history\n"); dmap_send_error(req, "cacr", "Playback failed to start"); return; } } else { /* Play from Up Next queue */ pos += status.pos_pl; if (status.status == PLAY_STOPPED && pos > 0) pos--; } } /* If playing from history queue, the pos holds the id of the item to play */ if (hist) ret = player_playback_start_byitemid(item_id, &id); else ret = player_playback_start_bypos(pos, &id); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not start playback\n"); dmap_send_error(req, "cacr", "Playback failed to start"); return; } dmap_add_container(evbuf, "cacr", 24); /* 8 + len */ dmap_add_int(evbuf, "mstt", 200); /* 12 */ dmap_add_int(evbuf, "miid", id); /* 12 */ httpd_send_reply(req, HTTP_OK, "OK", evbuf); } static void dacp_reply_cue_clear(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { /* /cue?command=clear */ player_playback_stop(); player_queue_clear(); dmap_add_container(evbuf, "cacr", 24); /* 8 + len */ dmap_add_int(evbuf, "mstt", 200); /* 12 */ dmap_add_int(evbuf, "miid", 0); /* 12 */ httpd_send_reply(req, HTTP_OK, "OK", evbuf); } static void dacp_reply_cue(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; const char *param; s = daap_session_find(req, query, evbuf); if (!s) return; param = evhttp_find_header(query, "command"); if (!param) { DPRINTF(E_DBG, L_DACP, "No command in cue request\n"); dmap_send_error(req, "cacr", "No command in cue request"); return; } if (strcmp(param, "clear") == 0) dacp_reply_cue_clear(req, evbuf, uri, query); else if (strcmp(param, "play") == 0) dacp_reply_cue_play(req, evbuf, uri, query); else { DPRINTF(E_LOG, L_DACP, "Unknown cue command %s\n", param); dmap_send_error(req, "cacr", "Unknown command in cue request"); return; } } static void dacp_reply_playspec(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct player_status status; struct queue_item *items; struct daap_session *s; const char *param; const char *shuffle; uint32_t plid; uint32_t id; int pos; int ret; /* /ctrl-int/1/playspec?database-spec='dmap.persistentid:0x1'&container-spec='dmap.persistentid:0x5'&container-item-spec='dmap.containeritemid:0x9' * or (Apple Remote when playing a Podcast) * /ctrl-int/1/playspec?database-spec='dmap.persistentid:0x1'&container-spec='dmap.persistentid:0x5'&item-spec='dmap.itemid:0x9' * With our DAAP implementation, container-spec is the playlist ID and container-item-spec/item-spec is the song ID */ s = daap_session_find(req, query, evbuf); if (!s) return; /* Check for shuffle */ shuffle = evhttp_find_header(query, "dacp.shufflestate"); /* Playlist ID */ param = evhttp_find_header(query, "container-spec"); if (!param) { DPRINTF(E_LOG, L_DACP, "No container-spec in playspec request\n"); goto out_fail; } param = strchr(param, ':'); if (!param) { DPRINTF(E_LOG, L_DACP, "Malformed container-spec parameter in playspec request\n"); goto out_fail; } param++; ret = safe_hextou32(param, &plid); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Couldn't convert container-spec to an integer in playspec (%s)\n", param); goto out_fail; } if (!shuffle) { /* Start song ID */ if ((param = evhttp_find_header(query, "item-spec"))) plid = 0; // This is a podcast/audiobook - just play a single item, not a playlist else if (!(param = evhttp_find_header(query, "container-item-spec"))) { DPRINTF(E_LOG, L_DACP, "No container-item-spec/item-spec in playspec request\n"); goto out_fail; } param = strchr(param, ':'); if (!param) { DPRINTF(E_LOG, L_DACP, "Malformed container-item-spec/item-spec parameter in playspec request\n"); goto out_fail; } param++; ret = safe_hextou32(param, &id); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Couldn't convert container-item-spec/item-spec to an integer in playspec (%s)\n", param); goto out_fail; } } else id = 0; DPRINTF(E_DBG, L_DACP, "Playspec request for playlist %d, start song id %d%s\n", plid, id, (shuffle) ? ", shuffle" : ""); items = NULL; if (plid > 0) items = queueitem_make_byplid(plid); else if (id > 0) items = queueitem_make_byid(id); if (!items) { DPRINTF(E_LOG, L_DACP, "Could not build song queue from playlist %d\n", plid); goto out_fail; } pos = queueitem_pos(items, id); if (pos < 0) { DPRINTF(E_DBG, L_DACP, "No item with %d found in queue\n", id); pos = 0; } DPRINTF(E_DBG, L_DACP, "Playspec start song index is %d\n", pos); player_get_status(&status); if (status.status != PLAY_STOPPED) player_playback_stop(); player_queue_clear(); player_queue_add(items, NULL); player_queue_plid(plid); if (shuffle) dacp_propset_shufflestate(shuffle, NULL); ret = player_playback_start_bypos(pos, NULL); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not start playback\n"); goto out_fail; } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); return; out_fail: evhttp_send_error(req, 500, "Internal Server Error"); } static void dacp_reply_pause(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; s = daap_session_find(req, query, evbuf); if (!s) return; player_playback_pause(); /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_playpause(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; struct player_status status; int ret; s = daap_session_find(req, query, evbuf); if (!s) return; player_get_status(&status); if (status.status == PLAY_PLAYING) { player_playback_pause(); } else { ret = player_playback_start(NULL); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Player returned an error for start after pause\n"); evhttp_send_error(req, 500, "Internal Server Error"); return; } } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_nextitem(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; int ret; s = daap_session_find(req, query, evbuf); if (!s) return; ret = player_playback_next(); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Player returned an error for nextitem\n"); evhttp_send_error(req, 500, "Internal Server Error"); return; } ret = player_playback_start(NULL); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Player returned an error for start after nextitem\n"); evhttp_send_error(req, 500, "Internal Server Error"); return; } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_previtem(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; int ret; s = daap_session_find(req, query, evbuf); if (!s) return; ret = player_playback_prev(); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Player returned an error for previtem\n"); evhttp_send_error(req, 500, "Internal Server Error"); return; } ret = player_playback_start(NULL); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Player returned an error for start after previtem\n"); evhttp_send_error(req, 500, "Internal Server Error"); return; } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_beginff(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; s = daap_session_find(req, query, evbuf); if (!s) return; /* TODO */ /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_beginrew(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; s = daap_session_find(req, query, evbuf); if (!s) return; /* TODO */ /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_playresume(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; s = daap_session_find(req, query, evbuf); if (!s) return; /* TODO */ /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static int playqueuecontents_add_source(struct evbuffer *songlist, uint32_t source_id, int pos_in_queue, uint32_t plid) { struct evbuffer *song; struct media_file_info *mfi; int ret; song = evbuffer_new(); if (!song) { DPRINTF(E_LOG, L_DACP, "Could not allocate song evbuffer for playqueue-contents\n"); return -1; } mfi = db_file_fetch_byid(source_id); if (!mfi) { DPRINTF(E_LOG, L_DACP, "Could not fetch file id %d\n", source_id); mfi = &dummy_mfi; } dmap_add_container(song, "ceQs", 16); dmap_add_raw_uint32(song, 1); /* Database */ dmap_add_raw_uint32(song, plid); dmap_add_raw_uint32(song, 0); /* Should perhaps be playlist index? */ dmap_add_raw_uint32(song, mfi->id); dmap_add_string(song, "ceQn", mfi->title); dmap_add_string(song, "ceQr", mfi->artist); dmap_add_string(song, "ceQa", mfi->album); dmap_add_string(song, "ceQg", mfi->genre); dmap_add_long(song, "asai", mfi->songalbumid); dmap_add_int(song, "cmmk", mfi->media_kind); dmap_add_int(song, "casa", 1); /* Unknown */ dmap_add_int(song, "astm", mfi->song_length); dmap_add_char(song, "casc", 1); /* Maybe an indication of extra data? */ dmap_add_char(song, "caks", 6); /* Unknown */ dmap_add_int(song, "ceQI", pos_in_queue); dmap_add_container(songlist, "mlit", evbuffer_get_length(song)); ret = evbuffer_add_buffer(songlist, song); evbuffer_free(song); if (mfi != &dummy_mfi) free_mfi(mfi, 0); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not add song to songlist for playqueue-contents\n"); return ret; } return 0; } static void dacp_reply_playqueuecontents(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; struct evbuffer *songlist; struct evbuffer *playlists; struct player_status status; struct player_history *history; struct queue *queue; struct queue_item *item; const char *param; size_t songlist_length; size_t playlist_length; int span; int count; int i; int n; int ret; int start_index; /* /ctrl-int/1/playqueue-contents?span=50&session-id=... */ s = daap_session_find(req, query, evbuf); if (!s) return; DPRINTF(E_DBG, L_DACP, "Fetching playqueue contents\n"); span = 50; /* Default */ param = evhttp_find_header(query, "span"); if (param) { ret = safe_atoi32(param, &span); if (ret < 0) DPRINTF(E_LOG, L_DACP, "Invalid span value in playqueue-contents request\n"); } i = 0; n = 0; // count of songs in songlist songlist = evbuffer_new(); if (!songlist) { DPRINTF(E_LOG, L_DACP, "Could not allocate songlist evbuffer for playqueue-contents\n"); dmap_send_error(req, "ceQR", "Out of memory"); return; } /* * If the span parameter is negativ make song list for Previously Played, * otherwise make song list for Up Next and begin with first song after playlist position. */ if (span < 0) { history = player_history_get(); if (abs(span) > history->count) { start_index = history->start_index; } else { start_index = (history->start_index + history->count - abs(span)) % MAX_HISTORY_COUNT; } for (n = 0; n < history->count && n < abs(span); n++) { ret = playqueuecontents_add_source(songlist, history->id[(start_index + n) % MAX_HISTORY_COUNT], (n + 1), status.plid); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not add song to songlist for playqueue-contents\n"); dmap_send_error(req, "ceQR", "Out of memory"); return; } } } else { player_get_status(&status); queue = player_queue_get_bypos(abs(span)); if (queue) { i = 0; count = queue_count(queue); for (n = 0; (n < count) && (n < abs(span)); n++) { item = queue_get_byindex(queue, n, 0); ret = playqueuecontents_add_source(songlist, queueitem_id(item), (n + i + 1), status.plid); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not add song to songlist for playqueue-contents\n"); dmap_send_error(req, "ceQR", "Out of memory"); return; } } queue_free(queue); } } /* Playlists are hist, curr and main. */ playlists = evbuffer_new(); if (!playlists) { DPRINTF(E_LOG, L_DACP, "Could not allocate playlists evbuffer for playqueue-contents\n"); if (songlist) evbuffer_free(songlist); dmap_send_error(req, "ceQR", "Out of memory"); return; } dmap_add_container(playlists, "mlit", 61); dmap_add_string(playlists, "ceQk", "hist"); /* 12 */ dmap_add_int(playlists, "ceQi", -200); /* 12 */ dmap_add_int(playlists, "ceQm", 200); /* 12 */ dmap_add_string(playlists, "ceQl", "Previously Played"); /* 25 = 8 + 17 */ if (songlist) { dmap_add_container(playlists, "mlit", 36); dmap_add_string(playlists, "ceQk", "curr"); /* 12 */ dmap_add_int(playlists, "ceQi", 0); /* 12 */ dmap_add_int(playlists, "ceQm", 1); /* 12 */ dmap_add_container(playlists, "mlit", 69); dmap_add_string(playlists, "ceQk", "main"); /* 12 */ dmap_add_int(playlists, "ceQi", 1); /* 12 */ dmap_add_int(playlists, "ceQm", n); /* 12 */ dmap_add_string(playlists, "ceQl", "Up Next"); /* 15 = 8 + 7 */ dmap_add_string(playlists, "ceQh", "from Music"); /* 18 = 8 + 10 */ songlist_length = evbuffer_get_length(songlist); } else songlist_length = 0; /* Final construction of reply */ playlist_length = evbuffer_get_length(playlists); dmap_add_container(evbuf, "ceQR", 79 + playlist_length + songlist_length); /* size of entire container */ dmap_add_int(evbuf, "mstt", 200); /* 12, dmap.status */ dmap_add_int(evbuf, "mtco", abs(span)); /* 12 */ dmap_add_int(evbuf, "mrco", n); /* 12 */ dmap_add_char(evbuf, "ceQu", 0); /* 9 */ dmap_add_container(evbuf, "mlcl", 8 + playlist_length + songlist_length); /* 8 */ dmap_add_container(evbuf, "ceQS", playlist_length); /* 8 */ ret = evbuffer_add_buffer(evbuf, playlists); evbuffer_free(playlists); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not add playlists to evbuffer for playqueue-contents\n"); if (songlist) evbuffer_free(songlist); dmap_send_error(req, "ceQR", "Out of memory"); return; } if (songlist) { ret = evbuffer_add_buffer(evbuf, songlist); evbuffer_free(songlist); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not add songlist to evbuffer for playqueue-contents\n"); dmap_send_error(req, "ceQR", "Out of memory"); return; } } dmap_add_char(evbuf, "apsm", status.shuffle); /* 9, daap.playlistshufflemode - not part of mlcl container */ dmap_add_char(evbuf, "aprm", status.repeat); /* 9, daap.playlistrepeatmode - not part of mlcl container */ httpd_send_reply(req, HTTP_OK, "OK", evbuf); } static void dacp_reply_playqueueedit_clear(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { const char *param; param = evhttp_find_header(query, "mode"); /* * The mode parameter contains the playlist to be cleared. * If mode=0x68697374 (hex representation of the ascii string "hist") clear the history, * otherwise the current playlist. */ if (strcmp(param,"0x68697374") == 0) player_queue_clear_history(); else player_queue_clear(); dmap_add_container(evbuf, "cacr", 24); /* 8 + len */ dmap_add_int(evbuf, "mstt", 200); /* 12 */ dmap_add_int(evbuf, "miid", 0); /* 12 */ httpd_send_reply(req, HTTP_OK, "OK", evbuf); } static void dacp_reply_playqueueedit_add(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { //?command=add&query='dmap.itemid:156'&sort=album&mode=3&session-id=100 // -> mode=3: add to playqueue position 0 (play next) //?command=add&query='dmap.itemid:158'&sort=album&mode=0&session-id=100 // -> mode=0: add to end of playqueue //?command=add&query='dmap.itemid:306'&queuefilter=album:6525753023700533274&sort=album&mode=1&session-id=100 // -> mode 1: stop playblack, clear playqueue, add songs to playqueue //?command=add&query='dmap.itemid:2'&query-modifier=containers&sort=name&mode=2&session-id=100 // -> mode 2: stop playblack, clear playqueue, add shuffled songs from playlist=itemid to playqueue struct queue_item *items; const char *editquery; const char *queuefilter; const char *querymodifier; const char *sort; const char *param; char modifiedquery[32]; uint32_t idx; int mode; int plid; int ret; int quirkyquery; mode = 1; param = evhttp_find_header(query, "mode"); if (param) { ret = safe_atoi32(param, &mode); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid mode value in playqueue-edit request\n"); dmap_send_error(req, "cacr", "Invalid request"); return; } } if ((mode == 1) || (mode == 2)) { player_playback_stop(); player_queue_clear(); } editquery = evhttp_find_header(query, "query"); if (editquery) { sort = evhttp_find_header(query, "sort"); // if sort param is missing and an album or artist is added to the queue, set sort to "album" if (!sort && (strstr(editquery, "daap.songalbumid:") || strstr(editquery, "daap.songartistid:"))) { sort = "album"; } // only use queryfilter if mode is not equal 0 (add to up next), 3 (play next) or 5 (add to up next) queuefilter = (mode == 0 || mode == 3 || mode == 5) ? NULL : evhttp_find_header(query, "queuefilter"); querymodifier = evhttp_find_header(query, "query-modifier"); if (!querymodifier || (strcmp(querymodifier, "containers") != 0)) { quirkyquery = (mode == 1) && strstr(editquery, "dmap.itemid:") && ((!queuefilter) || strstr(queuefilter, "(null)")); ret = dacp_queueitem_make(&items, editquery, queuefilter, sort, quirkyquery); } else { // Modify the query: Take the id from the editquery and use it as a queuefilter playlist id ret = safe_atoi32(strchr(editquery, ':') + 1, &plid); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid playlist id in request: %s\n", editquery); dmap_send_error(req, "cacr", "Invalid request"); return; } snprintf(modifiedquery, sizeof(modifiedquery), "playlist:%d", plid); ret = dacp_queueitem_make(&items, NULL, modifiedquery, sort, 0); } if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not build song queue\n"); dmap_send_error(req, "cacr", "Invalid request"); return; } idx = ret; if (mode == 3) { player_queue_add_next(items); } else { player_queue_add(items, NULL); } } else { DPRINTF(E_LOG, L_DACP, "Could not add song queue, DACP query missing\n"); dmap_send_error(req, "cacr", "Invalid request"); return; } if (mode == 2) { player_shuffle_set(1); idx = 0; } DPRINTF(E_DBG, L_DACP, "Song queue built, playback starting at index %" PRIu32 "\n", idx); ret = player_playback_start_bypos(idx, NULL); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not start playback\n"); dmap_send_error(req, "cacr", "Playback failed to start"); return; } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_playqueueedit_move(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { /* * Handles the move command. * Exampe request: * playqueue-edit?command=move&edit-params='edit-param.move-pair:3,0'&session-id=100 * * The 'edit-param.move-pair' param contains the index of the song in the playqueue to be moved (index 3 in the example) * and the index of the song after which it should be inserted (index 0 in the exampe, the now playing song). */ int ret; const char *param; int src; int dst; param = evhttp_find_header(query, "edit-params"); if (param) { ret = safe_atoi32(strchr(param, ':') + 1, &src); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid edit-params move-from value in playqueue-edit request\n"); dmap_send_error(req, "cacr", "Invalid request"); return; } ret = safe_atoi32(strchr(param, ',') + 1, &dst); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid edit-params move-to value in playqueue-edit request\n"); dmap_send_error(req, "cacr", "Invalid request"); return; } player_queue_move_bypos(src, dst); } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_playqueueedit_remove(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { /* * Handles the remove command. * Exampe request (removes song at position 1 in the playqueue): * ?command=remove&items=1&session-id=100 */ int ret; const char *param; int item_index; param = evhttp_find_header(query, "items"); if (param) { ret = safe_atoi32(param, &item_index); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid edit-params remove item value in playqueue-edit request\n"); dmap_send_error(req, "cacr", "Invalid request"); return; } player_queue_remove_bypos(item_index); } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void dacp_reply_playqueueedit(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; const char *param; /* Variations of /ctrl-int/1/playqueue-edit and expected behaviour User selected play (album or artist tab): ?command=add&query='...'&sort=album&mode=1&session-id=... -> clear queue, play query results User selected play (playlist): ?command=add&query='dmap.itemid:...'&query-modifier=containers&mode=1&session-id=... -> clear queue, play playlist with the id specified by itemid User selected track (album tab): ?command=add&query='dmap.itemid:...'&queuefilter=album:...&sort=album&mode=1&session-id=... -> clear queue, play itemid and the rest of album User selected track (artist tab): ?command=add&query='dmap.itemid:...'&queuefilter=artist:...&sort=album&mode=1&session-id=... -> clear queue, play itemid and the rest of artist tracks User selected track (song tab): ?command=add&query='dmap.itemid:...'&queuefilter=playlist:...&sort=name&mode=1&session-id=... -> clear queue, play itemid and the rest of playlist User selected track (playlist tab): ?command=add&query='dmap.containeritemid:...'&queuefilter=playlist:...&sort=physical&mode=1&session-id=... -> clear queue, play containeritemid and the rest of playlist User selected shuffle (artist tab): ?command=add&query='...'&sort=album&mode=2&session-id=... -> clear queue, play shuffled query results User selected add item to queue: ?command=add&query='...'&sort=album&mode=0&session-id=... -> add query results to queue User selected play next song (album tab) ?command=add&query='daap.songalbumid:...'&sort=album&mode=3&session-id=... -> replace queue from after current song with query results User selected track in queue: ?command=playnow&index=...&session-id=... -> play index And the quirky query from Remote - no sort and no queuefilter User selected track (Audiobooks): ?command=add&query='dmap.itemid:...'&mode=1&session-id=... -> clear queue, play itemid and the rest of album tracks ?command=move&edit-params='edit-param.move-pair:3,0'&session-id=100 -> move song from playqueue position 3 to be played after song at position 0 ?command=remove&items=1&session-id=100 -> remove song on position 1 from the playqueue */ s = daap_session_find(req, query, evbuf); if (!s) return; param = evhttp_find_header(query, "command"); if (!param) { DPRINTF(E_LOG, L_DACP, "No command in playqueue-edit request\n"); dmap_send_error(req, "cmst", "Invalid request"); return; } if (strcmp(param, "clear") == 0) dacp_reply_playqueueedit_clear(req, evbuf, uri, query); else if (strcmp(param, "playnow") == 0) dacp_reply_cue_play(req, evbuf, uri, query); else if (strcmp(param, "add") == 0) dacp_reply_playqueueedit_add(req, evbuf, uri, query); else if (strcmp(param, "move") == 0) dacp_reply_playqueueedit_move(req, evbuf, uri, query); else if (strcmp(param, "remove") == 0) dacp_reply_playqueueedit_remove(req, evbuf, uri, query); else { DPRINTF(E_LOG, L_DACP, "Unknown playqueue-edit command %s\n", param); dmap_send_error(req, "cmst", "Invalid request"); return; } } static void dacp_reply_playstatusupdate(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; struct dacp_update_request *ur; struct evhttp_connection *evcon; const char *param; int reqd_rev; int ret; s = daap_session_find(req, query, evbuf); if (!s) return; param = evhttp_find_header(query, "revision-number"); if (!param) { DPRINTF(E_LOG, L_DACP, "Missing revision-number in update request\n"); dmap_send_error(req, "cmst", "Invalid request"); return; } ret = safe_atoi32(param, &reqd_rev); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Parameter revision-number not an integer\n"); dmap_send_error(req, "cmst", "Invalid request"); return; } if ((reqd_rev == 0) || (reqd_rev == 1)) { ret = make_playstatusupdate(evbuf); if (ret < 0) evhttp_send_error(req, 500, "Internal Server Error"); else httpd_send_reply(req, HTTP_OK, "OK", evbuf); return; } /* Else, just let the request hang until we have changes to push back */ ur = (struct dacp_update_request *)malloc(sizeof(struct dacp_update_request)); if (!ur) { DPRINTF(E_LOG, L_DACP, "Out of memory for update request\n"); dmap_send_error(req, "cmst", "Out of memory"); return; } ur->req = req; ur->next = update_requests; update_requests = ur; /* If the connection fails before we have an update to push out * to the client, we need to know. */ evcon = evhttp_request_get_connection(req); if (evcon) evhttp_connection_set_closecb(evcon, update_fail_cb, ur); } static void dacp_reply_nowplayingartwork(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { char clen[32]; struct daap_session *s; struct evkeyvalq *headers; const char *param; char *ctype; size_t len; uint32_t id; int max_w; int max_h; int ret; s = daap_session_find(req, query, evbuf); if (!s) return; param = evhttp_find_header(query, "mw"); if (!param) { DPRINTF(E_LOG, L_DACP, "Request for artwork without mw parameter\n"); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); return; } ret = safe_atoi32(param, &max_w); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not convert mw parameter to integer\n"); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); return; } param = evhttp_find_header(query, "mh"); if (!param) { DPRINTF(E_LOG, L_DACP, "Request for artwork without mh parameter\n"); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); return; } ret = safe_atoi32(param, &max_h); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not convert mh parameter to integer\n"); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); return; } ret = player_now_playing(&id); if (ret < 0) goto no_artwork; ret = artwork_get_item(evbuf, id, max_w, max_h); len = evbuffer_get_length(evbuf); switch (ret) { case ART_FMT_PNG: ctype = "image/png"; break; case ART_FMT_JPEG: ctype = "image/jpeg"; break; default: if (len > 0) evbuffer_drain(evbuf, len); goto no_artwork; } headers = evhttp_request_get_output_headers(req); evhttp_remove_header(headers, "Content-Type"); evhttp_add_header(headers, "Content-Type", ctype); snprintf(clen, sizeof(clen), "%ld", (long)len); evhttp_add_header(headers, "Content-Length", clen); /* No gzip compression for artwork */ evhttp_send_reply(req, HTTP_OK, "OK", evbuf); return; no_artwork: evhttp_send_error(req, HTTP_NOTFOUND, "Not Found"); } static void dacp_reply_getproperty(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct player_status status; struct daap_session *s; const struct dacp_prop_map *dpm; struct media_file_info *mfi; struct evbuffer *proplist; const char *param; char *ptr; char *prop; char *propstr; size_t len; int ret; s = daap_session_find(req, query, evbuf); if (!s) return; param = evhttp_find_header(query, "properties"); if (!param) { DPRINTF(E_WARN, L_DACP, "Invalid DACP getproperty request, no properties\n"); dmap_send_error(req, "cmgt", "Invalid request"); return; } propstr = strdup(param); if (!propstr) { DPRINTF(E_LOG, L_DACP, "Could not duplicate properties parameter; out of memory\n"); dmap_send_error(req, "cmgt", "Out of memory"); return; } proplist = evbuffer_new(); if (!proplist) { DPRINTF(E_LOG, L_DACP, "Could not allocate evbuffer for properties list\n"); dmap_send_error(req, "cmgt", "Out of memory"); goto out_free_propstr; } player_get_status(&status); if (status.status != PLAY_STOPPED) { mfi = db_file_fetch_byid(status.id); if (!mfi) { DPRINTF(E_LOG, L_DACP, "Could not fetch file id %d\n", status.id); dmap_send_error(req, "cmgt", "Server error"); goto out_free_proplist; } } else mfi = NULL; prop = strtok_r(propstr, ",", &ptr); while (prop) { dpm = dacp_find_prop(prop, strlen(prop)); if (dpm) { if (dpm->propget) dpm->propget(proplist, &status, mfi); else DPRINTF(E_WARN, L_DACP, "No getter method for DACP property %s\n", prop); } else DPRINTF(E_LOG, L_DACP, "Could not find requested property '%s'\n", prop); prop = strtok_r(NULL, ",", &ptr); } free(propstr); if (mfi) free_mfi(mfi, 0); len = evbuffer_get_length(proplist); dmap_add_container(evbuf, "cmgt", 12 + len); dmap_add_int(evbuf, "mstt", 200); /* 12 */ ret = evbuffer_add_buffer(evbuf, proplist); evbuffer_free(proplist); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not add properties to getproperty reply\n"); dmap_send_error(req, "cmgt", "Out of memory"); return; } httpd_send_reply(req, HTTP_OK, "OK", evbuf); return; out_free_proplist: evbuffer_free(proplist); out_free_propstr: free(propstr); } static void dacp_reply_setproperty(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; const struct dacp_prop_map *dpm; struct evkeyval *param; s = daap_session_find(req, query, evbuf); if (!s) return; /* Known properties: * dacp.shufflestate 0/1 * dacp.repeatstate 0/1/2 * dacp.playingtime seek to time in ms * dmcp.volume 0-100, float */ /* /ctrl-int/1/setproperty?dacp.shufflestate=1&session-id=100 */ TAILQ_FOREACH(param, query, next) { dpm = dacp_find_prop(param->key, strlen(param->key)); if (!dpm) { DPRINTF(E_SPAM, L_DACP, "Unknown DACP property %s\n", param->key); continue; } if (dpm->propset) dpm->propset(param->value, query); else DPRINTF(E_WARN, L_DACP, "No setter method for DACP property %s\n", dpm->desc); } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static void speaker_enum_cb(uint64_t id, const char *name, int relvol, struct spk_flags flags, void *arg) { struct evbuffer *evbuf; int len; evbuf = (struct evbuffer *)arg; len = 8 + strlen(name) + 28; if (flags.selected) len += 9; if (flags.has_password) len += 9; if (flags.has_video) len += 9; dmap_add_container(evbuf, "mdcl", len); /* 8 + len */ if (flags.selected) dmap_add_char(evbuf, "caia", 1); /* 9 */ if (flags.has_password) dmap_add_char(evbuf, "cahp", 1); /* 9 */ if (flags.has_video) dmap_add_char(evbuf, "caiv", 1); /* 9 */ dmap_add_string(evbuf, "minm", name); /* 8 + len */ dmap_add_long(evbuf, "msma", id); /* 16 */ dmap_add_int(evbuf, "cmvo", relvol); /* 12 */ } static void dacp_reply_getspeakers(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; struct evbuffer *spklist; size_t len; s = daap_session_find(req, query, evbuf); if (!s) return; spklist = evbuffer_new(); if (!spklist) { DPRINTF(E_LOG, L_DACP, "Could not create evbuffer for speaker list\n"); dmap_send_error(req, "casp", "Out of memory"); return; } player_speaker_enumerate(speaker_enum_cb, spklist); len = evbuffer_get_length(spklist); dmap_add_container(evbuf, "casp", 12 + len); dmap_add_int(evbuf, "mstt", 200); /* 12 */ evbuffer_add_buffer(evbuf, spklist); evbuffer_free(spklist); httpd_send_reply(req, HTTP_OK, "OK", evbuf); } static void dacp_reply_setspeakers(struct evhttp_request *req, struct evbuffer *evbuf, char **uri, struct evkeyvalq *query) { struct daap_session *s; const char *param; const char *ptr; uint64_t *ids; int nspk; int i; int ret; s = daap_session_find(req, query, evbuf); if (!s) return; param = evhttp_find_header(query, "speaker-id"); if (!param) { DPRINTF(E_LOG, L_DACP, "Missing speaker-id parameter in DACP setspeakers request\n"); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); return; } if (strlen(param) == 0) { ids = NULL; goto fastpath; } nspk = 1; ptr = param; while ((ptr = strchr(ptr + 1, ','))) nspk++; ids = (uint64_t *)malloc((nspk + 1) * sizeof(uint64_t)); if (!ids) { DPRINTF(E_LOG, L_DACP, "Out of memory for speaker ids\n"); evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error"); return; } param--; i = 1; do { param++; ret = safe_hextou64(param, &ids[i]); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Invalid speaker id in request: %s\n", param); nspk--; continue; } else { DPRINTF(E_DBG, L_DACP, "Speaker id converted with ret %d, param %s, dec val %" PRIu64 ".\n", ret, param, ids[i]); } i++; } while ((param = strchr(param + 1, ','))); ids[0] = nspk; fastpath: ret = player_speaker_set(ids); if (ids) free(ids); if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Speakers de/activation failed!\n"); /* Password problem */ if (ret == -2) evhttp_send_error(req, 902, ""); else evhttp_send_error(req, 500, "Internal Server Error"); return; } /* 204 No Content is the canonical reply */ evhttp_send_reply(req, HTTP_NOCONTENT, "No Content", evbuf); } static struct uri_map dacp_handlers[] = { { .regexp = "^/ctrl-int$", .handler = dacp_reply_ctrlint }, { .regexp = "^/ctrl-int/[[:digit:]]+/cue$", .handler = dacp_reply_cue }, { .regexp = "^/ctrl-int/[[:digit:]]+/playspec$", .handler = dacp_reply_playspec }, { .regexp = "^/ctrl-int/[[:digit:]]+/pause$", .handler = dacp_reply_pause }, { .regexp = "^/ctrl-int/[[:digit:]]+/playpause$", .handler = dacp_reply_playpause }, { .regexp = "^/ctrl-int/[[:digit:]]+/nextitem$", .handler = dacp_reply_nextitem }, { .regexp = "^/ctrl-int/[[:digit:]]+/previtem$", .handler = dacp_reply_previtem }, { .regexp = "^/ctrl-int/[[:digit:]]+/beginff$", .handler = dacp_reply_beginff }, { .regexp = "^/ctrl-int/[[:digit:]]+/beginrew$", .handler = dacp_reply_beginrew }, { .regexp = "^/ctrl-int/[[:digit:]]+/playresume$", .handler = dacp_reply_playresume }, { .regexp = "^/ctrl-int/[[:digit:]]+/playstatusupdate$", .handler = dacp_reply_playstatusupdate }, { .regexp = "^/ctrl-int/[[:digit:]]+/playqueue-contents$", .handler = dacp_reply_playqueuecontents }, { .regexp = "^/ctrl-int/[[:digit:]]+/playqueue-edit$", .handler = dacp_reply_playqueueedit }, { .regexp = "^/ctrl-int/[[:digit:]]+/nowplayingartwork$", .handler = dacp_reply_nowplayingartwork }, { .regexp = "^/ctrl-int/[[:digit:]]+/getproperty$", .handler = dacp_reply_getproperty }, { .regexp = "^/ctrl-int/[[:digit:]]+/setproperty$", .handler = dacp_reply_setproperty }, { .regexp = "^/ctrl-int/[[:digit:]]+/getspeakers$", .handler = dacp_reply_getspeakers }, { .regexp = "^/ctrl-int/[[:digit:]]+/setspeakers$", .handler = dacp_reply_setspeakers }, { .regexp = NULL, .handler = NULL } }; void dacp_request(struct evhttp_request *req) { char *full_uri; char *uri; char *ptr; char *uri_parts[7]; struct evbuffer *evbuf; struct evkeyvalq query; struct evkeyvalq *headers; int handler; int ret; int i; memset(&query, 0, sizeof(struct evkeyvalq)); full_uri = httpd_fixup_uri(req); if (!full_uri) { evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); return; } ptr = strchr(full_uri, '?'); if (ptr) *ptr = '\0'; uri = strdup(full_uri); if (!uri) { free(full_uri); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); return; } if (ptr) *ptr = '?'; ptr = uri; uri = evhttp_decode_uri(uri); free(ptr); DPRINTF(E_DBG, L_DACP, "DACP request: %s\n", full_uri); handler = -1; for (i = 0; dacp_handlers[i].handler; i++) { ret = regexec(&dacp_handlers[i].preg, uri, 0, NULL, 0); if (ret == 0) { handler = i; break; } } if (handler < 0) { DPRINTF(E_LOG, L_DACP, "Unrecognized DACP request\n"); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); free(uri); free(full_uri); return; } /* DACP has no HTTP authentication - Remote is identified by its pairing-guid */ memset(uri_parts, 0, sizeof(uri_parts)); uri_parts[0] = strtok_r(uri, "/", &ptr); for (i = 1; (i < sizeof(uri_parts) / sizeof(uri_parts[0])) && uri_parts[i - 1]; i++) { uri_parts[i] = strtok_r(NULL, "/", &ptr); } if (!uri_parts[0] || uri_parts[i - 1] || (i < 2)) { DPRINTF(E_LOG, L_DACP, "DACP URI has too many/few components (%d)\n", (uri_parts[0]) ? i : 0); evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request"); free(uri); free(full_uri); return; } evbuf = evbuffer_new(); if (!evbuf) { DPRINTF(E_LOG, L_DACP, "Could not allocate evbuffer for DACP reply\n"); evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error"); free(uri); free(full_uri); return; } evhttp_parse_query(full_uri, &query); headers = evhttp_request_get_output_headers(req); evhttp_add_header(headers, "DAAP-Server", "forked-daapd/" VERSION); /* Content-Type for all DACP replies; can be overriden as needed */ evhttp_add_header(headers, "Content-Type", "application/x-dmap-tagged"); dacp_handlers[handler].handler(req, evbuf, uri_parts, &query); evbuffer_free(evbuf); evhttp_clear_headers(&query); free(uri); free(full_uri); } int dacp_is_request(struct evhttp_request *req, char *uri) { if (strncmp(uri, "/ctrl-int/", strlen("/ctrl-int/")) == 0) return 1; if (strcmp(uri, "/ctrl-int") == 0) return 1; return 0; } int dacp_init(void) { char buf[64]; int i; int ret; current_rev = 2; update_requests = NULL; #ifdef USE_EVENTFD update_efd = eventfd(0, EFD_CLOEXEC); if (update_efd < 0) { DPRINTF(E_LOG, L_DACP, "Could not create update eventfd: %s\n", strerror(errno)); return -1; } #else # ifdef HAVE_PIPE2 ret = pipe2(update_pipe, O_CLOEXEC); # else ret = pipe(update_pipe); # endif if (ret < 0) { DPRINTF(E_LOG, L_DACP, "Could not create update pipe: %s\n", strerror(errno)); return -1; } #endif /* USE_EVENTFD */ for (i = 0; dacp_handlers[i].handler; i++) { ret = regcomp(&dacp_handlers[i].preg, dacp_handlers[i].regexp, REG_EXTENDED | REG_NOSUB); if (ret != 0) { regerror(ret, &dacp_handlers[i].preg, buf, sizeof(buf)); DPRINTF(E_FATAL, L_DACP, "DACP init failed; regexp error: %s\n", buf); goto regexp_fail; } } #ifdef USE_EVENTFD updateev = event_new(evbase_httpd, update_efd, EV_READ, playstatusupdate_cb, NULL); #else updateev = event_new(evbase_httpd, update_pipe[0], EV_READ, playstatusupdate_cb, NULL); #endif if (!updateev) { DPRINTF(E_LOG, L_DACP, "Could not create update event\n"); return -1; } event_add(updateev, NULL); seek_timer = evtimer_new(evbase_httpd, seek_timer_cb, NULL); if (!seek_timer) { DPRINTF(E_LOG, L_DACP, "Could not create seek_timer event\n"); return -1; } listener_add(dacp_playstatus_update_handler, LISTENER_PLAYER); return 0; regexp_fail: #ifdef USE_EVENTFD close(update_efd); #else close(update_pipe[0]); close(update_pipe[1]); #endif return -1; } void dacp_deinit(void) { struct dacp_update_request *ur; struct evhttp_connection *evcon; int i; listener_remove(dacp_playstatus_update_handler); event_free(seek_timer); for (i = 0; dacp_handlers[i].handler; i++) regfree(&dacp_handlers[i].preg); for (ur = update_requests; update_requests; ur = update_requests) { update_requests = ur->next; evcon = evhttp_request_get_connection(ur->req); if (evcon) { evhttp_connection_set_closecb(evcon, NULL, NULL); evhttp_connection_free(evcon); } free(ur); } event_free(updateev); #ifdef USE_EVENTFD close(update_efd); #else close(update_pipe[0]); close(update_pipe[1]); #endif }