|
|
@@ -1,954 +1,954 @@
|
|
|
-/*
|
|
|
- *
|
|
|
- * (c) Philippe 2019, philippe_44@outlook.com
|
|
|
- *
|
|
|
- * 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
|
- *
|
|
|
- */
|
|
|
-
|
|
|
-#include <stdio.h>
|
|
|
-
|
|
|
-#include "platform.h"
|
|
|
-
|
|
|
-#ifdef WIN32
|
|
|
-#include <openssl/err.h>
|
|
|
-#include <openssl/rand.h>
|
|
|
-#include <openssl/rsa.h>
|
|
|
-#include <openssl/pem.h>
|
|
|
-#include <openssl/engine.h>
|
|
|
-#include "mdns.h"
|
|
|
-#include "mdnsd.h"
|
|
|
-#include "mdnssd-itf.h"
|
|
|
-#else
|
|
|
-#include "esp_pthread.h"
|
|
|
-#include "mdns.h"
|
|
|
-#include "mbedtls/version.h"
|
|
|
-#include <mbedtls/x509.h>
|
|
|
-#endif
|
|
|
-
|
|
|
-#include "util.h"
|
|
|
-#include "raop.h"
|
|
|
-#include "rtp.h"
|
|
|
-#include "dmap_parser.h"
|
|
|
-#include "log_util.h"
|
|
|
-
|
|
|
-#define RTSP_STACK_SIZE (8*1024)
|
|
|
-#define SEARCH_STACK_SIZE (2*1048)
|
|
|
-
|
|
|
-typedef struct raop_ctx_s {
|
|
|
-#ifdef WIN32
|
|
|
- struct mdns_service *svc;
|
|
|
- struct mdnsd *svr;
|
|
|
-#endif
|
|
|
- struct in_addr host; // IP of bridge
|
|
|
- short unsigned port; // RTSP port for AirPlay
|
|
|
- int sock; // socket of the above
|
|
|
- struct in_addr peer; // IP of the iDevice (airplay sender)
|
|
|
- bool running;
|
|
|
-#ifdef WIN32
|
|
|
- pthread_t thread, search_thread;
|
|
|
-#else
|
|
|
- TaskHandle_t thread, search_thread, joiner;
|
|
|
- StaticTask_t *xTaskBuffer;
|
|
|
- StackType_t xStack[RTSP_STACK_SIZE] __attribute__ ((aligned (4)));
|
|
|
-#endif
|
|
|
- unsigned char mac[6];
|
|
|
- int latency;
|
|
|
- struct {
|
|
|
- char *aesiv, *aeskey;
|
|
|
- char *fmtp;
|
|
|
- } rtsp;
|
|
|
- struct rtp_s *rtp;
|
|
|
- raop_cmd_cb_t cmd_cb;
|
|
|
- raop_data_cb_t data_cb;
|
|
|
- struct {
|
|
|
- char DACPid[32], id[32];
|
|
|
- struct in_addr host;
|
|
|
- u16_t port;
|
|
|
-#ifdef WIN32
|
|
|
- struct mDNShandle_s *handle;
|
|
|
-#else
|
|
|
- bool running;
|
|
|
- TaskHandle_t thread, joiner;
|
|
|
- StaticTask_t *xTaskBuffer;
|
|
|
- StackType_t xStack[SEARCH_STACK_SIZE] __attribute__ ((aligned (4)));;
|
|
|
-#endif
|
|
|
- } active_remote;
|
|
|
- void *owner;
|
|
|
-} raop_ctx_t;
|
|
|
-
|
|
|
-extern struct mdnsd* glmDNSServer;
|
|
|
-extern log_level raop_loglevel;
|
|
|
-static log_level *loglevel = &raop_loglevel;
|
|
|
-
|
|
|
-static void* rtsp_thread(void *arg);
|
|
|
-static bool handle_rtsp(raop_ctx_t *ctx, int sock);
|
|
|
-
|
|
|
-static char* rsa_apply(unsigned char *input, int inlen, int *outlen, int mode);
|
|
|
-static int base64_pad(char *src, char **padded);
|
|
|
-static int base64_encode(const void *data, int size, char **str);
|
|
|
-static int base64_decode(const char *str, void *data);
|
|
|
-static void* search_remote(void *args);
|
|
|
-
|
|
|
-extern char private_key[];
|
|
|
-
enum { RSA_MODE_KEY, RSA_MODE_AUTH };
|
|
|
-
|
|
|
-static void on_dmap_string(void *ctx, const char *code, const char *name, const char *buf, size_t len);
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-struct raop_ctx_s *raop_create(struct in_addr host, char *name,
|
|
|
- unsigned char mac[6], int latency,
|
|
|
- raop_cmd_cb_t cmd_cb, raop_data_cb_t data_cb) {
|
|
|
- struct raop_ctx_s *ctx = malloc(sizeof(struct raop_ctx_s));
|
|
|
- struct sockaddr_in addr;
|
|
|
- char id[64];
|
|
|
-
#ifdef WIN32
|
|
|
- socklen_t nlen = sizeof(struct sockaddr);
|
|
|
- char *txt[] = { "am=airesp32", "tp=UDP", "sm=false", "sv=false", "ek=1",
|
|
|
- "et=0,1", "md=0,1,2", "cn=0,1", "ch=2",
|
|
|
- "ss=16", "sr=44100", "vn=3", "txtvers=1",
|
|
|
- NULL };
|
|
|
-#else
|
|
|
- mdns_txt_item_t txt[] = {
|
|
|
- {"am", "airesp32"},
|
|
|
- {"tp", "UDP"},
|
|
|
- {"sm","false"},
|
|
|
- {"sv","false"},
|
|
|
- {"ek","1"},
|
|
|
- {"et","0,1"},
|
|
|
- {"md","0,1,2"},
|
|
|
- {"cn","0,1"},
|
|
|
- {"ch","2"},
|
|
|
- {"ss","16"},
|
|
|
- {"sr","44100"},
|
|
|
- {"vn","3"},
|
|
|
- {"txtvers","1"},
|
|
|
- };
|
|
|
-
|
|
|
-#endif
|
|
|
-
|
|
|
- if (!ctx) return NULL;
|
|
|
-
|
|
|
- // make sure we have a clean context
|
|
|
- memset(ctx, 0, sizeof(raop_ctx_t));
|
|
|
-
|
|
|
-#ifdef WIN32
|
|
|
- ctx->svr = glmDNSServer;
|
|
|
-#endif
|
|
|
- ctx->host = host;
|
|
|
- ctx->sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
- ctx->cmd_cb = cmd_cb;
|
|
|
- ctx->data_cb = data_cb;
|
|
|
- ctx->latency = min(latency, 88200);
|
|
|
- if (ctx->sock == -1) {
|
|
|
- LOG_ERROR("Cannot create listening socket", NULL);
|
|
|
- free(ctx);
|
|
|
- return NULL;
|
|
|
- }
|
|
|
-
|
|
|
- memset(&addr, 0, sizeof(addr));
|
|
|
- addr.sin_addr.s_addr = host.s_addr;
|
|
|
- addr.sin_family = AF_INET;
|
|
|
-#ifdef WIN32
|
|
|
- ctx->port = 0;
|
|
|
- addr.sin_port = htons(ctx->port);
|
|
|
-#else
|
|
|
- ctx->port = 5000;
|
|
|
- addr.sin_port = htons(ctx->port);
|
|
|
-#endif
|
|
|
-
|
|
|
- if (bind(ctx->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0 || listen(ctx->sock, 1)) {
|
|
|
- LOG_ERROR("Cannot bind or listen RTSP listener: %s", strerror(errno));
|
|
|
- free(ctx);
|
|
|
- closesocket(ctx->sock);
|
|
|
- return NULL;
|
|
|
- }
|
|
|
-
|
|
|
-#ifdef WIN32
|
|
|
- getsockname(ctx->sock, (struct sockaddr *) &addr, &nlen);
|
|
|
- ctx->port = ntohs(addr.sin_port);
|
|
|
-#endif
|
|
|
-
ctx->running = true;
|
|
|
-
memcpy(ctx->mac, mac, 6);
|
|
|
- snprintf(id, 64, "%02X%02X%02X%02X%02X%02X@%s", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], name);
|
|
|
-
#ifdef WIN32
|
|
|
- // seems that Windows snprintf does not add NULL char if actual size > max
|
|
|
- id[63] = '\0';
|
|
|
- ctx->svc = mdnsd_register_svc(ctx->svr, id, "_raop._tcp.local", ctx->port, NULL, (const char**) txt);
|
|
|
- pthread_create(&ctx->thread, NULL, &rtsp_thread, ctx);
|
|
|
-
#else
|
|
|
- LOG_INFO("starting mDNS with %s", id);
|
|
|
- ESP_ERROR_CHECK( mdns_service_add(id, "_raop", "_tcp", ctx->port, txt, sizeof(txt) / sizeof(mdns_txt_item_t)) );
|
|
|
-
|
|
|
- ctx->xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
|
|
|
- ctx->thread = xTaskCreateStatic( (TaskFunction_t) rtsp_thread, "RTSP_thread", RTSP_STACK_SIZE, ctx, ESP_TASK_PRIO_MIN + 1, ctx->xStack, ctx->xTaskBuffer);
|
|
|
-#endif
|
|
|
-
|
|
|
- return ctx;
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-void raop_delete(struct raop_ctx_s *ctx) {
|
|
|
-#ifdef WIN32
|
|
|
- int sock;
|
|
|
- struct sockaddr addr;
|
|
|
- socklen_t nlen = sizeof(struct sockaddr);
|
|
|
-#endif
|
|
|
-
|
|
|
-if (!ctx) return;
|
|
|
-
|
|
|
-#ifdef WIN32
|
|
|
- ctx->running = false;
|
|
|
-
|
|
|
- // wake-up thread by connecting socket, needed for freeBSD
|
|
|
- sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
- getsockname(ctx->sock, (struct sockaddr *) &addr, &nlen);
|
|
|
- connect(sock, (struct sockaddr*) &addr, sizeof(addr));
|
|
|
- closesocket(sock);
|
|
|
-
|
|
|
- pthread_join(ctx->thread, NULL);
|
|
|
-
|
|
|
- rtp_end(ctx->rtp);
|
|
|
-
|
|
|
- shutdown(ctx->sock, SD_BOTH);
|
|
|
- closesocket(ctx->sock);
|
|
|
-
|
|
|
- // terminate search, but do not reclaim memory of pthread if never launched
|
|
|
- if (ctx->active_remote.handle) {
|
|
|
- close_mDNS(ctx->active_remote.handle);
|
|
|
- pthread_join(ctx->search_thread, NULL);
|
|
|
- }
|
|
|
-
|
|
|
- // stop broadcasting devices
|
|
|
- mdns_service_remove(ctx->svr, ctx->svc);
|
|
|
- mdnsd_stop(ctx->svr);
|
|
|
-#else
|
|
|
- // first stop the search task if any
|
|
|
- if (ctx->active_remote.running) {
|
|
|
- ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
|
|
|
- ctx->active_remote.running = false;
|
|
|
-
|
|
|
- vTaskResume(ctx->active_remote.thread);
|
|
|
- ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
- vTaskDelete(ctx->active_remote.thread);
|
|
|
-
|
|
|
- heap_caps_free(ctx->active_remote.xTaskBuffer);
|
|
|
- }
|
|
|
-
|
|
|
- // then the RTSP task
|
|
|
- ctx->joiner = xTaskGetCurrentTaskHandle();
|
|
|
- ctx->running = false;
|
|
|
-
|
|
|
- ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
- vTaskDelete(ctx->thread);
|
|
|
- heap_caps_free(ctx->xTaskBuffer);
|
|
|
-
|
|
|
- rtp_end(ctx->rtp);
|
|
|
-
|
|
|
- shutdown(ctx->sock, SHUT_RDWR);
|
|
|
- closesocket(ctx->sock);
|
|
|
-
|
|
|
- mdns_service_remove("_raop", "_tcp");
|
|
|
-#endif
|
|
|
-
|
|
|
- NFREE(ctx->rtsp.aeskey);
|
|
|
- NFREE(ctx->rtsp.aesiv);
|
|
|
- NFREE(ctx->rtsp.fmtp);
|
|
|
-
|
|
|
- free(ctx);
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-void raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param) {
|
|
|
- struct sockaddr_in addr;
|
|
|
- int sock;
|
|
|
- char *command = NULL;
|
|
|
-
|
|
|
- // first notify the remote controller (if any)
|
|
|
- switch(event) {
|
|
|
- case RAOP_REW:
|
|
|
- command = strdup("beginrew");
|
|
|
- break;
|
|
|
- case RAOP_FWD:
|
|
|
- command = strdup("beginff");
|
|
|
- break;
|
|
|
- case RAOP_PREV:
|
|
|
- command = strdup("previtem");
|
|
|
- break;
|
|
|
- case RAOP_NEXT:
|
|
|
- command = strdup("nextitem");
|
|
|
- break;
|
|
|
- case RAOP_TOGGLE:
|
|
|
- command = strdup("playpause");
|
|
|
- break;
|
|
|
- case RAOP_PAUSE:
|
|
|
- command = strdup("pause");
|
|
|
- break;
|
|
|
- case RAOP_PLAY:
|
|
|
- command = strdup("play");
|
|
|
- break;
|
|
|
- case RAOP_RESUME:
|
|
|
- command = strdup("playresume");
|
|
|
- break;
|
|
|
- case RAOP_STOP:
|
|
|
- command = strdup("stop");
|
|
|
- break;
|
|
|
- case RAOP_VOLUME_UP:
|
|
|
- command = strdup("volumeup");
|
|
|
- break;
|
|
|
- case RAOP_VOLUME_DOWN:
|
|
|
- command = strdup("volumedown");
|
|
|
- break;
|
|
|
- case RAOP_VOLUME: {
|
|
|
- float Volume = *((float*) param);
|
|
|
- Volume = Volume ? (Volume - 1) * 30 : -144;
|
|
|
- asprintf(&command,"setproperty?dmcp.device-volume=%0.4lf", Volume);
|
|
|
- break;
|
|
|
- }
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- // no command to send to remote or no remote found yet
|
|
|
- if (!command || !ctx->active_remote.port) {
|
|
|
- NFREE(command);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
-
|
|
|
- memset(&addr, 0, sizeof(addr));
|
|
|
- addr.sin_family = AF_INET;
|
|
|
- addr.sin_addr.s_addr = S_ADDR(ctx->active_remote.host);
|
|
|
- addr.sin_port = htons(ctx->active_remote.port);
|
|
|
-
|
|
|
- if (!connect(sock, (struct sockaddr*) &addr, sizeof(addr))) {
|
|
|
- char *method, *buf, resp[512] = "";
|
|
|
- int len;
|
|
|
- key_data_t headers[4] = { {NULL, NULL} };
|
|
|
-
|
|
|
- asprintf(&method, "GET /ctrl-int/1/%s HTTP/1.0", command);
|
|
|
- kd_add(headers, "Active-Remote", ctx->active_remote.id);
|
|
|
- kd_add(headers, "Connection", "close");
|
|
|
-
|
|
|
- buf = http_send(sock, method, headers);
|
|
|
- len = recv(sock, resp, 512, 0);
|
|
|
- if (len > 0) resp[len-1] = '\0';
|
|
|
- LOG_INFO("[%p]: sending airplay remote\n%s<== received ==>\n%s", ctx, buf, resp);
|
|
|
-
|
|
|
- NFREE(method);
|
|
|
- NFREE(buf);
|
|
|
- kd_free(headers);
|
|
|
- }
|
|
|
-
|
|
|
- free(command);
|
|
|
- closesocket(sock);
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static void *rtsp_thread(void *arg) {
|
|
|
- raop_ctx_t *ctx = (raop_ctx_t*) arg;
|
|
|
- int sock = -1;
|
|
|
-
|
|
|
- while (ctx->running) {
|
|
|
- fd_set rfds;
|
|
|
- struct timeval timeout = {0, 100*1000};
|
|
|
- int n;
|
|
|
- bool res = false;
|
|
|
-
|
|
|
- if (sock == -1) {
|
|
|
- struct sockaddr_in peer;
|
|
|
- socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
|
-
|
|
|
- sock = accept(ctx->sock, (struct sockaddr*) &peer, &addrlen);
|
|
|
- ctx->peer.s_addr = peer.sin_addr.s_addr;
|
|
|
-
|
|
|
- if (sock != -1 && ctx->running) {
|
|
|
- LOG_INFO("got RTSP connection %u", sock);
|
|
|
- } else continue;
|
|
|
- }
|
|
|
-
|
|
|
- FD_ZERO(&rfds);
|
|
|
- FD_SET(sock, &rfds);
|
|
|
-
|
|
|
- n = select(sock + 1, &rfds, NULL, NULL, &timeout);
|
|
|
-
|
|
|
- if (!n) continue;
|
|
|
-
|
|
|
- if (n > 0) res = handle_rtsp(ctx, sock);
|
|
|
-
|
|
|
- if (n < 0 || !res) {
|
|
|
- closesocket(sock);
|
|
|
- LOG_INFO("RTSP close %u", sock);
|
|
|
- sock = -1;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (sock != -1) closesocket(sock);
|
|
|
-
|
|
|
-#ifndef WIN32
|
|
|
- xTaskNotifyGive(ctx->joiner);
|
|
|
- vTaskSuspend(NULL);
|
|
|
-#endif
|
|
|
-
|
|
|
- return NULL;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static bool handle_rtsp(raop_ctx_t *ctx, int sock)
|
|
|
-{
|
|
|
- char *buf = NULL, *body = NULL, method[16] = "";
|
|
|
- key_data_t headers[16], resp[8] = { {NULL, NULL} };
|
|
|
- int len;
|
|
|
- bool success = true;
|
|
|
-
|
|
|
- if (!http_parse(sock, method, headers, &body, &len)) {
|
|
|
- NFREE(body);
|
|
|
- kd_free(headers);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if (strcmp(method, "OPTIONS")) {
|
|
|
- LOG_INFO("[%p]: received %s", ctx, method);
|
|
|
- }
|
|
|
-
|
|
|
- if ((buf = kd_lookup(headers, "Apple-Challenge")) != NULL) {
|
|
|
- int n;
|
|
|
- char *buf_pad, *p, *data_b64 = NULL, data[32];
|
|
|
-
|
|
|
- LOG_INFO("[%p]: challenge %s", ctx, buf);
|
|
|
-
|
|
|
- // need to pad the base64 string as apple device don't
|
|
|
- base64_pad(buf, &buf_pad);
|
|
|
-
|
|
|
- p = data + min(base64_decode(buf_pad, data), 32-10);
|
|
|
- p = (char*) memcpy(p, &S_ADDR(ctx->host), 4) + 4;
|
|
|
- p = (char*) memcpy(p, ctx->mac, 6) + 6;
|
|
|
- memset(p, 0, 32 - (p - data));
|
|
|
- p = rsa_apply((unsigned char*) data, 32, &n, RSA_MODE_AUTH);
|
|
|
- n = base64_encode(p, n, &data_b64);
|
|
|
-
|
|
|
- // remove padding as well (seems to be optional now)
|
|
|
- for (n = strlen(data_b64) - 1; n > 0 && data_b64[n] == '='; data_b64[n--] = '\0');
|
|
|
-
|
|
|
- kd_add(resp, "Apple-Response", data_b64);
|
|
|
-
|
|
|
- NFREE(p);
|
|
|
- NFREE(buf_pad);
|
|
|
- NFREE(data_b64);
|
|
|
- }
|
|
|
-
|
|
|
- if (!strcmp(method, "OPTIONS")) {
|
|
|
-
|
|
|
- kd_add(resp, "Public", "ANNOUNCE, SETUP, RECORD, PAUSE, FLUSH, TEARDOWN, OPTIONS, GET_PARAMETER, SET_PARAMETER");
|
|
|
-
|
|
|
- } else if (!strcmp(method, "ANNOUNCE")) {
|
|
|
- char *padded, *p;
|
|
|
-
|
|
|
- NFREE(ctx->rtsp.aeskey);
|
|
|
- NFREE(ctx->rtsp.aesiv);
|
|
|
- NFREE(ctx->rtsp.fmtp);
|
|
|
-
|
|
|
- // LMS might has taken over the player, leaving us with a running RTP session (should not happen)
|
|
|
- if (ctx->rtp) {
|
|
|
- LOG_WARN("[%p]: closing unfinished RTP session", ctx);
|
|
|
- rtp_end(ctx->rtp);
|
|
|
- }
|
|
|
-
|
|
|
- // same, should not happen unless we have missed a teardown ...
|
|
|
- if (ctx->active_remote.running) {
|
|
|
- ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
|
|
|
- ctx->active_remote.running = false;
|
|
|
-
|
|
|
- vTaskResume(ctx->active_remote.thread);
|
|
|
- ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
- vTaskDelete(ctx->active_remote.thread);
|
|
|
-
|
|
|
- heap_caps_free(ctx->active_remote.xTaskBuffer);
|
|
|
- memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
|
|
|
-
|
|
|
- LOG_WARN("[%p]: closing unfinished mDNS search", ctx);
|
|
|
- }
|
|
|
-
|
|
|
- if ((p = strcasestr(body, "rsaaeskey")) != NULL) {
|
|
|
- unsigned char *aeskey;
|
|
|
- int len, outlen;
|
|
|
-
|
|
|
- p = strextract(p, ":", "\r\n");
|
|
|
- base64_pad(p, &padded);
|
|
|
- aeskey = malloc(strlen(padded));
|
|
|
- len = base64_decode(padded, aeskey);
|
|
|
- ctx->rtsp.aeskey = rsa_apply(aeskey, len, &outlen, RSA_MODE_KEY);
|
|
|
-
|
|
|
- NFREE(p);
|
|
|
- NFREE(aeskey);
|
|
|
- NFREE(padded);
|
|
|
- }
|
|
|
-
|
|
|
- if ((p = strcasestr(body, "aesiv")) != NULL) {
|
|
|
- p = strextract(p, ":", "\r\n");
|
|
|
- base64_pad(p, &padded);
|
|
|
- ctx->rtsp.aesiv = malloc(strlen(padded));
|
|
|
- base64_decode(padded, ctx->rtsp.aesiv);
|
|
|
-
|
|
|
- NFREE(p);
|
|
|
- NFREE(padded);
|
|
|
- }
|
|
|
-
|
|
|
- if ((p = strcasestr(body, "fmtp")) != NULL) {
|
|
|
- p = strextract(p, ":", "\r\n");
|
|
|
- ctx->rtsp.fmtp = strdup(p);
|
|
|
- NFREE(p);
|
|
|
- }
|
|
|
-
|
|
|
- // on announce, search remote
|
|
|
- if ((buf = kd_lookup(headers, "DACP-ID")) != NULL) strcpy(ctx->active_remote.DACPid, buf);
|
|
|
- if ((buf = kd_lookup(headers, "Active-Remote")) != NULL) strcpy(ctx->active_remote.id, buf);
|
|
|
-
|
|
|
-#ifdef WIN32
|
|
|
- ctx->active_remote.handle = init_mDNS(false, ctx->host);
|
|
|
- pthread_create(&ctx->search_thread, NULL, &search_remote, ctx);
|
|
|
-#else
|
|
|
- ctx->active_remote.running = true;
|
|
|
- ctx->active_remote.xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
|
|
|
- ctx->active_remote.thread = xTaskCreateStatic( (TaskFunction_t) search_remote, "search_remote", SEARCH_STACK_SIZE, ctx, ESP_TASK_PRIO_MIN + 1, ctx->active_remote.xStack, ctx->active_remote.xTaskBuffer);
|
|
|
-#endif
|
|
|
-
|
|
|
- } else if (!strcmp(method, "SETUP") && ((buf = kd_lookup(headers, "Transport")) != NULL)) {
|
|
|
- char *p;
|
|
|
- rtp_resp_t rtp = { 0 };
|
|
|
- short unsigned tport = 0, cport = 0;
|
|
|
-
|
|
|
- // we are about to stream, do something if needed
|
|
|
- success = ctx->cmd_cb(RAOP_SETUP, NULL);
|
|
|
-
|
|
|
- if ((p = strcasestr(buf, "timing_port")) != NULL) sscanf(p, "%*[^=]=%hu", &tport);
|
|
|
- if ((p = strcasestr(buf, "control_port")) != NULL) sscanf(p, "%*[^=]=%hu", &cport);
|
|
|
-
|
|
|
- rtp = rtp_init(ctx->peer, ctx->latency, ctx->rtsp.aeskey, ctx->rtsp.aesiv,
|
|
|
- ctx->rtsp.fmtp, cport, tport, ctx->cmd_cb, ctx->data_cb);
|
|
|
-
|
|
|
- ctx->rtp = rtp.ctx;
|
|
|
-
|
|
|
- if (cport * tport * rtp.cport * rtp.tport * rtp.aport && rtp.ctx) {
|
|
|
- char *transport;
|
|
|
- asprintf(&transport, "RTP/AVP/UDP;unicast;mode=record;control_port=%u;timing_port=%u;server_port=%u", rtp.cport, rtp.tport, rtp.aport);
|
|
|
- LOG_DEBUG("[%p]: audio=(%hu:%hu), timing=(%hu:%hu), control=(%hu:%hu)", ctx, 0, rtp.aport, tport, rtp.tport, cport, rtp.cport);
|
|
|
- kd_add(resp, "Transport", transport);
|
|
|
- kd_add(resp, "Session", "DEADBEEF");
|
|
|
- free(transport);
|
|
|
- } else {
|
|
|
- success = false;
|
|
|
- LOG_INFO("[%p]: cannot start session, missing ports", ctx);
|
|
|
- }
|
|
|
-
|
|
|
- } else if (!strcmp(method, "RECORD")) {
|
|
|
- unsigned short seqno = 0;
|
|
|
- unsigned rtptime = 0;
|
|
|
- char *p;
|
|
|
-
|
|
|
- if (ctx->latency) {
|
|
|
- char latency[6];
|
|
|
- snprintf(latency, 6, "%u", ctx->latency);
|
|
|
- kd_add(resp, "Audio-Latency", latency);
|
|
|
- }
|
|
|
-
|
|
|
- buf = kd_lookup(headers, "RTP-Info");
|
|
|
- if (buf && (p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
|
|
|
- if (buf && (p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
|
|
|
-
|
|
|
- if (ctx->rtp) rtp_record(ctx->rtp, seqno, rtptime);
|
|
|
-
|
|
|
- success = ctx->cmd_cb(RAOP_STREAM, NULL);
|
|
|
-
|
|
|
- } else if (!strcmp(method, "FLUSH")) {
|
|
|
- unsigned short seqno = 0;
|
|
|
- unsigned rtptime = 0;
|
|
|
- char *p;
|
|
|
-
|
|
|
- buf = kd_lookup(headers, "RTP-Info");
|
|
|
- if ((p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
|
|
|
- if ((p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
|
|
|
-
|
|
|
- // only send FLUSH if useful (discards frames above buffer head and top)
|
|
|
- if (ctx->rtp && rtp_flush(ctx->rtp, seqno, rtptime))
|
|
|
- success = ctx->cmd_cb(RAOP_FLUSH, NULL);
|
|
|
-
|
|
|
- } else if (!strcmp(method, "TEARDOWN")) {
|
|
|
-
|
|
|
- rtp_end(ctx->rtp);
|
|
|
-
|
|
|
- ctx->rtp = NULL;
|
|
|
-
|
|
|
- // need to make sure no search is on-going and reclaim pthread memory
|
|
|
-#ifdef WIN32
|
|
|
- if (ctx->active_remote.handle) close_mDNS(ctx->active_remote.handle);
|
|
|
- pthread_join(ctx->search_thread, NULL);
|
|
|
-#else
|
|
|
- ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
|
|
|
- ctx->active_remote.running = false;
|
|
|
-
|
|
|
- // task might not need to be resumed anyway
|
|
|
- vTaskResume(ctx->active_remote.thread);
|
|
|
- ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
- vTaskDelete(ctx->active_remote.thread);
|
|
|
-
|
|
|
- heap_caps_free(ctx->active_remote.xTaskBuffer);
|
|
|
-
|
|
|
- LOG_INFO("[%p]: mDNS search task terminated", ctx);
|
|
|
-#endif
|
|
|
-
|
|
|
- memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
|
|
|
- NFREE(ctx->rtsp.aeskey);
|
|
|
- NFREE(ctx->rtsp.aesiv);
|
|
|
- NFREE(ctx->rtsp.fmtp);
|
|
|
-
|
|
|
- success = ctx->cmd_cb(RAOP_STOP, NULL);
|
|
|
-
|
|
|
- } else if (!strcmp(method, "SET_PARAMETER")) {
|
|
|
- char *p;
|
|
|
-
|
|
|
- if (body && (p = strcasestr(body, "volume")) != NULL) {
|
|
|
- float volume;
|
|
|
-
|
|
|
- sscanf(p, "%*[^:]:%f", &volume);
|
|
|
- LOG_INFO("[%p]: SET PARAMETER volume %f", ctx, volume);
|
|
|
- volume = (volume == -144.0) ? 0 : (1 + volume / 30);
|
|
|
- success = ctx->cmd_cb(RAOP_VOLUME, &volume);
|
|
|
- }
|
|
|
-/*
|
|
|
- if (body && ((p = kd_lookup(headers, "Content-Type")) != NULL) && !strcasecmp(p, "application/x-dmap-tagged")) {
|
|
|
- struct metadata_s metadata;
|
|
|
- dmap_settings settings = {
|
|
|
- NULL, NULL, NULL, NULL, NULL, NULL, NULL, on_dmap_string, NULL,
|
|
|
- NULL
|
|
|
- };
|
|
|
-
|
|
|
- settings.ctx = &metadata;
|
|
|
- memset(&metadata, 0, sizeof(struct metadata_s));
|
|
|
- if (!dmap_parse(&settings, body, len)) {
|
|
|
- LOG_INFO("[%p]: received metadata\n\tartist: %s\n\talbum: %s\n\ttitle: %s",
|
|
|
- ctx, metadata.artist, metadata.album, metadata.title);
|
|
|
- free_metadata(&metadata);
|
|
|
- }
|
|
|
- }
|
|
|
-*/
|
|
|
- }
|
|
|
-
|
|
|
- // don't need to free "buf" because kd_lookup return a pointer, not a strdup
|
|
|
- kd_add(resp, "Audio-Jack-Status", "connected; type=analog");
|
|
|
- kd_add(resp, "CSeq", kd_lookup(headers, "CSeq"));
|
|
|
-
|
|
|
- if (success) buf = http_send(sock, "RTSP/1.0 200 OK", resp);
|
|
|
- else buf = http_send(sock, "RTSP/1.0 500 ERROR", NULL);
|
|
|
-
|
|
|
- if (strcmp(method, "OPTIONS")) {
|
|
|
- LOG_INFO("[%p]: responding:\n%s", ctx, buf ? buf : "<void>");
|
|
|
- }
|
|
|
-
|
|
|
- NFREE(body);
|
|
|
- NFREE(buf);
|
|
|
- kd_free(resp);
|
|
|
- kd_free(headers);
|
|
|
-
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-#ifdef WIN32
|
|
|
-bool search_remote_cb(mDNSservice_t *slist, void *cookie, bool *stop) {
|
|
|
- mDNSservice_t *s;
|
|
|
- raop_ctx_t *ctx = (raop_ctx_t*) cookie;
|
|
|
-
|
|
|
- // see if we have found an active remote for our ID
|
|
|
- for (s = slist; s; s = s->next) {
|
|
|
- if (strcasestr(s->name, ctx->active_remote.DACPid)) {
|
|
|
- ctx->active_remote.host = s->addr;
|
|
|
- ctx->active_remote.port = s->port;
|
|
|
- LOG_INFO("[%p]: found ActiveRemote for %s at %s:%u", ctx, ctx->active_remote.DACPid,
|
|
|
- inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
|
|
|
- *stop = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // let caller clear list
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static void* search_remote(void *args) {
|
|
|
- raop_ctx_t *ctx = (raop_ctx_t*) args;
|
|
|
-
|
|
|
- query_mDNS(ctx->active_remote.handle, "_dacp._tcp.local", 0, 0, &search_remote_cb, (void*) ctx);
|
|
|
-
|
|
|
- return NULL;
|
|
|
-}
|
|
|
-
|
|
|
-#else
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static void* search_remote(void *args) {
|
|
|
- raop_ctx_t *ctx = (raop_ctx_t*) args;
|
|
|
- bool found = false;
|
|
|
-
|
|
|
- LOG_INFO("starting remote search");
|
|
|
-
|
|
|
- while (ctx->active_remote.running && !found) {
|
|
|
- mdns_result_t *results = NULL;
|
|
|
- mdns_result_t *r;
|
|
|
- mdns_ip_addr_t *a;
|
|
|
-
|
|
|
- if (mdns_query_ptr("_dacp", "_tcp", 3000, 32, &results)) {
|
|
|
- LOG_ERROR("mDNS active remote query Failed");
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- for (r = results; r && !strcasestr(r->instance_name, ctx->active_remote.DACPid); r = r->next);
|
|
|
- if (r) {
|
|
|
- for (a = r->addr; a && a->addr.type != IPADDR_TYPE_V4; a = a->next);
|
|
|
- if (a) {
|
|
|
- found = true;
|
|
|
- ctx->active_remote.host.s_addr = a->addr.u_addr.ip4.addr;
|
|
|
- ctx->active_remote.port = r->port;
|
|
|
- LOG_INFO("found remote %s %s:%hu", r->instance_name, inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- mdns_query_results_free(results);
|
|
|
- }
|
|
|
-
|
|
|
- /*
|
|
|
- for some reason which is beyond me, if that tasks gives the semaphore
|
|
|
- before the RTSP tasks waits for it, then freeRTOS crashes in queue
|
|
|
- management caused by LWIP stack once the RTSP socket is closed. I have
|
|
|
- no clue why, but so we'll suspend the tasks as soon as we're done with
|
|
|
- search and wait for the resume then give the semaphore
|
|
|
- */
|
|
|
- // PS: I know this is not fully race-condition free
|
|
|
- if (ctx->active_remote.running) vTaskSuspend(NULL);
|
|
|
- xTaskNotifyGive(ctx->active_remote.joiner);
|
|
|
-
|
|
|
- // now our context will be deleted
|
|
|
- vTaskSuspend(NULL);
|
|
|
-
|
|
|
- return NULL;
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
-
/*----------------------------------------------------------------------------*/
|
|
|
-static char *rsa_apply(unsigned char *input, int inlen, int *outlen, int mode)
|
|
|
-{
|
|
|
- static char super_secret_key[] =
|
|
|
- "-----BEGIN RSA PRIVATE KEY-----\n"
|
|
|
- "MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt\n"
|
|
|
- "wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U\n"
|
|
|
- "wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf\n"
|
|
|
- "/+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/\n"
|
|
|
- "UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW\n"
|
|
|
- "BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa\n"
|
|
|
- "LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5\n"
|
|
|
- "NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm\n"
|
|
|
- "lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz\n"
|
|
|
- "aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu\n"
|
|
|
- "a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM\n"
|
|
|
- "oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z\n"
|
|
|
- "oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+\n"
|
|
|
- "k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL\n"
|
|
|
- "AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA\n"
|
|
|
- "cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf\n"
|
|
|
- "54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov\n"
|
|
|
- "17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc\n"
|
|
|
- "1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI\n"
|
|
|
- "LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ\n"
|
|
|
- "2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKY=\n"
|
|
|
- "-----END RSA PRIVATE KEY-----";
|
|
|
-#ifdef WIN32
|
|
|
- unsigned char *out;
|
|
|
- RSA *rsa;
|
|
|
-
|
|
|
- BIO *bmem = BIO_new_mem_buf(super_secret_key, -1);
|
|
|
- rsa = PEM_read_bio_RSAPrivateKey(bmem, NULL, NULL, NULL);
|
|
|
- BIO_free(bmem);
|
|
|
-
|
|
|
- out = malloc(RSA_size(rsa));
|
|
|
- switch (mode) {
|
|
|
- case RSA_MODE_AUTH:
|
|
|
- *outlen = RSA_private_encrypt(inlen, input, out, rsa,
|
|
|
- RSA_PKCS1_PADDING);
|
|
|
- break;
|
|
|
- case RSA_MODE_KEY:
|
|
|
- *outlen = RSA_private_decrypt(inlen, input, out, rsa,
|
|
|
- RSA_PKCS1_OAEP_PADDING);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- RSA_free(rsa);
|
|
|
-
|
|
|
- return (char*) out;
|
|
|
-#else
|
|
|
- mbedtls_pk_context pkctx;
|
|
|
- mbedtls_rsa_context *trsa;
|
|
|
- size_t olen;
|
|
|
-
|
|
|
- /*
|
|
|
- we should do entropy initialization & pass a rng function but this
|
|
|
- consumes a ton of stack and there is no security concern here. Anyway,
|
|
|
- mbedtls takes a lot of stack, unfortunately ...
|
|
|
- */
|
|
|
-
|
|
|
- mbedtls_pk_init(&pkctx);
|
|
|
- mbedtls_pk_parse_key(&pkctx, (unsigned char *)super_secret_key,
|
|
|
- sizeof(super_secret_key), NULL, 0);
|
|
|
-
|
|
|
- uint8_t *outbuf = NULL;
|
|
|
- trsa = mbedtls_pk_rsa(pkctx);
|
|
|
-
|
|
|
- switch (mode) {
|
|
|
- case RSA_MODE_AUTH:
|
|
|
- mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE);
|
|
|
- outbuf = malloc(trsa->len);
|
|
|
- mbedtls_rsa_pkcs1_encrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, inlen, input, outbuf);
|
|
|
- *outlen = trsa->len;
|
|
|
- break;
|
|
|
- case RSA_MODE_KEY:
|
|
|
- mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
|
|
|
- outbuf = malloc(trsa->len);
|
|
|
- mbedtls_rsa_pkcs1_decrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, &olen, input, outbuf, trsa->len);
|
|
|
- *outlen = olen;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- mbedtls_pk_free(&pkctx);
|
|
|
-
|
|
|
- return (char*) outbuf;
|
|
|
-#endif
|
|
|
-}
|
|
|
-
|
|
|
-#define DECODE_ERROR 0xffffffff
|
|
|
-
|
|
|
-static char base64_chars[] =
|
|
|
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static int base64_pad(char *src, char **padded)
|
|
|
-{
|
|
|
- int n;
|
|
|
-
|
|
|
- n = strlen(src) + strlen(src) % 4;
|
|
|
- *padded = malloc(n + 1);
|
|
|
- memset(*padded, '=', n);
|
|
|
- memcpy(*padded, src, strlen(src));
|
|
|
- (*padded)[n] = '\0';
|
|
|
-
|
|
|
- return strlen(*padded);
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static int pos(char c)
|
|
|
-{
|
|
|
- char *p;
|
|
|
- for (p = base64_chars; *p; p++)
|
|
|
- if (*p == c)
|
|
|
- return p - base64_chars;
|
|
|
- return -1;
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static int base64_encode(const void *data, int size, char **str)
|
|
|
-{
|
|
|
- char *s, *p;
|
|
|
- int i;
|
|
|
- int c;
|
|
|
- const unsigned char *q;
|
|
|
-
|
|
|
- p = s = (char *) malloc(size * 4 / 3 + 4);
|
|
|
- if (p == NULL) return -1;
|
|
|
- q = (const unsigned char *) data;
|
|
|
- i = 0;
|
|
|
- for (i = 0; i < size;) {
|
|
|
- c = q[i++];
|
|
|
- c *= 256;
|
|
|
- if (i < size) c += q[i];
|
|
|
- i++;
|
|
|
- c *= 256;
|
|
|
- if (i < size) c += q[i];
|
|
|
- i++;
|
|
|
- p[0] = base64_chars[(c & 0x00fc0000) >> 18];
|
|
|
- p[1] = base64_chars[(c & 0x0003f000) >> 12];
|
|
|
- p[2] = base64_chars[(c & 0x00000fc0) >> 6];
|
|
|
- p[3] = base64_chars[(c & 0x0000003f) >> 0];
|
|
|
- if (i > size) p[3] = '=';
|
|
|
- if (i > size + 1) p[2] = '=';
|
|
|
- p += 4;
|
|
|
- }
|
|
|
- *p = 0;
|
|
|
- *str = s;
|
|
|
- return strlen(s);
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static unsigned int token_decode(const char *token)
|
|
|
-{
|
|
|
- int i;
|
|
|
- unsigned int val = 0;
|
|
|
- int marker = 0;
|
|
|
- if (strlen(token) < 4)
|
|
|
- return DECODE_ERROR;
|
|
|
- for (i = 0; i < 4; i++) {
|
|
|
- val *= 64;
|
|
|
- if (token[i] == '=')
|
|
|
- marker++;
|
|
|
- else if (marker > 0)
|
|
|
- return DECODE_ERROR;
|
|
|
- else
|
|
|
- val += pos(token[i]);
|
|
|
- }
|
|
|
- if (marker > 2)
|
|
|
- return DECODE_ERROR;
|
|
|
- return (marker << 24) | val;
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static int base64_decode(const char *str, void *data)
|
|
|
-{
|
|
|
- const char *p;
|
|
|
- unsigned char *q;
|
|
|
-
|
|
|
- q = data;
|
|
|
- for (p = str; *p && (*p == '=' || strchr(base64_chars, *p)); p += 4) {
|
|
|
- unsigned int val = token_decode(p);
|
|
|
- unsigned int marker = (val >> 24) & 0xff;
|
|
|
- if (val == DECODE_ERROR)
|
|
|
- return -1;
|
|
|
- *q++ = (val >> 16) & 0xff;
|
|
|
- if (marker < 2)
|
|
|
- *q++ = (val >> 8) & 0xff;
|
|
|
- if (marker < 1)
|
|
|
- *q++ = val & 0xff;
|
|
|
- }
|
|
|
- return q - (unsigned char *) data;
|
|
|
-}
|
|
|
-
|
|
|
-/*----------------------------------------------------------------------------*/
|
|
|
-static void on_dmap_string(void *ctx, const char *code, const char *name, const char *buf, size_t len) {
|
|
|
- struct metadata_s *metadata = (struct metadata_s *) ctx;
|
|
|
-
|
|
|
- if (!strcasecmp(code, "asar")) metadata->artist = strndup(buf, len);
|
|
|
- else if (!strcasecmp(code, "asal")) metadata->album = strndup(buf, len);
|
|
|
- else if (!strcasecmp(code, "minm")) metadata->title = strndup(buf, len);
|
|
|
-}
|
|
|
-
|
|
|
+/*
|
|
|
+ *
|
|
|
+ * (c) Philippe 2019, philippe_44@outlook.com
|
|
|
+ *
|
|
|
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+
|
|
|
+#include "platform.h"
|
|
|
+
|
|
|
+#ifdef WIN32
|
|
|
+#include <openssl/err.h>
|
|
|
+#include <openssl/rand.h>
|
|
|
+#include <openssl/rsa.h>
|
|
|
+#include <openssl/pem.h>
|
|
|
+#include <openssl/engine.h>
|
|
|
+#include "mdns.h"
|
|
|
+#include "mdnsd.h"
|
|
|
+#include "mdnssd-itf.h"
|
|
|
+#else
|
|
|
+#include "esp_pthread.h"
|
|
|
+#include "mdns.h"
|
|
|
+#include "mbedtls/version.h"
|
|
|
+#include <mbedtls/x509.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#include "util.h"
|
|
|
+#include "raop.h"
|
|
|
+#include "rtp.h"
|
|
|
+#include "dmap_parser.h"
|
|
|
+#include "log_util.h"
|
|
|
+
|
|
|
+#define RTSP_STACK_SIZE (8*1024)
|
|
|
+#define SEARCH_STACK_SIZE (2*1048)
|
|
|
+
|
|
|
+typedef struct raop_ctx_s {
|
|
|
+#ifdef WIN32
|
|
|
+ struct mdns_service *svc;
|
|
|
+ struct mdnsd *svr;
|
|
|
+#endif
|
|
|
+ struct in_addr host; // IP of bridge
|
|
|
+ short unsigned port; // RTSP port for AirPlay
|
|
|
+ int sock; // socket of the above
|
|
|
+ struct in_addr peer; // IP of the iDevice (airplay sender)
|
|
|
+ bool running;
|
|
|
+#ifdef WIN32
|
|
|
+ pthread_t thread, search_thread;
|
|
|
+#else
|
|
|
+ TaskHandle_t thread, search_thread, joiner;
|
|
|
+ StaticTask_t *xTaskBuffer;
|
|
|
+ StackType_t xStack[RTSP_STACK_SIZE] __attribute__ ((aligned (4)));
|
|
|
+#endif
|
|
|
+ unsigned char mac[6];
|
|
|
+ int latency;
|
|
|
+ struct {
|
|
|
+ char *aesiv, *aeskey;
|
|
|
+ char *fmtp;
|
|
|
+ } rtsp;
|
|
|
+ struct rtp_s *rtp;
|
|
|
+ raop_cmd_cb_t cmd_cb;
|
|
|
+ raop_data_cb_t data_cb;
|
|
|
+ struct {
|
|
|
+ char DACPid[32], id[32];
|
|
|
+ struct in_addr host;
|
|
|
+ u16_t port;
|
|
|
+#ifdef WIN32
|
|
|
+ struct mDNShandle_s *handle;
|
|
|
+#else
|
|
|
+ bool running;
|
|
|
+ TaskHandle_t thread, joiner;
|
|
|
+ StaticTask_t *xTaskBuffer;
|
|
|
+ StackType_t xStack[SEARCH_STACK_SIZE] __attribute__ ((aligned (4)));;
|
|
|
+#endif
|
|
|
+ } active_remote;
|
|
|
+ void *owner;
|
|
|
+} raop_ctx_t;
|
|
|
+
|
|
|
+extern struct mdnsd* glmDNSServer;
|
|
|
+extern log_level raop_loglevel;
|
|
|
+static log_level *loglevel = &raop_loglevel;
|
|
|
+
|
|
|
+static void* rtsp_thread(void *arg);
|
|
|
+static bool handle_rtsp(raop_ctx_t *ctx, int sock);
|
|
|
+
|
|
|
+static char* rsa_apply(unsigned char *input, int inlen, int *outlen, int mode);
|
|
|
+static int base64_pad(char *src, char **padded);
|
|
|
+static int base64_encode(const void *data, int size, char **str);
|
|
|
+static int base64_decode(const char *str, void *data);
|
|
|
+static void* search_remote(void *args);
|
|
|
+
|
|
|
+extern char private_key[];
|
|
|
+
enum { RSA_MODE_KEY, RSA_MODE_AUTH };
|
|
|
+
|
|
|
+static void on_dmap_string(void *ctx, const char *code, const char *name, const char *buf, size_t len);
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+struct raop_ctx_s *raop_create(struct in_addr host, char *name,
|
|
|
+ unsigned char mac[6], int latency,
|
|
|
+ raop_cmd_cb_t cmd_cb, raop_data_cb_t data_cb) {
|
|
|
+ struct raop_ctx_s *ctx = malloc(sizeof(struct raop_ctx_s));
|
|
|
+ struct sockaddr_in addr;
|
|
|
+ char id[64];
|
|
|
+
#ifdef WIN32
|
|
|
+ socklen_t nlen = sizeof(struct sockaddr);
|
|
|
+ char *txt[] = { "am=airesp32", "tp=UDP", "sm=false", "sv=false", "ek=1",
|
|
|
+ "et=0,1", "md=0,1,2", "cn=0,1", "ch=2",
|
|
|
+ "ss=16", "sr=44100", "vn=3", "txtvers=1",
|
|
|
+ NULL };
|
|
|
+#else
|
|
|
+ mdns_txt_item_t txt[] = {
|
|
|
+ {"am", "airesp32"},
|
|
|
+ {"tp", "UDP"},
|
|
|
+ {"sm","false"},
|
|
|
+ {"sv","false"},
|
|
|
+ {"ek","1"},
|
|
|
+ {"et","0,1"},
|
|
|
+ {"md","0,1,2"},
|
|
|
+ {"cn","0,1"},
|
|
|
+ {"ch","2"},
|
|
|
+ {"ss","16"},
|
|
|
+ {"sr","44100"},
|
|
|
+ {"vn","3"},
|
|
|
+ {"txtvers","1"},
|
|
|
+ };
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+ if (!ctx) return NULL;
|
|
|
+
|
|
|
+ // make sure we have a clean context
|
|
|
+ memset(ctx, 0, sizeof(raop_ctx_t));
|
|
|
+
|
|
|
+#ifdef WIN32
|
|
|
+ ctx->svr = glmDNSServer;
|
|
|
+#endif
|
|
|
+ ctx->host = host;
|
|
|
+ ctx->sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
+ ctx->cmd_cb = cmd_cb;
|
|
|
+ ctx->data_cb = data_cb;
|
|
|
+ ctx->latency = min(latency, 88200);
|
|
|
+ if (ctx->sock == -1) {
|
|
|
+ LOG_ERROR("Cannot create listening socket", NULL);
|
|
|
+ free(ctx);
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ memset(&addr, 0, sizeof(addr));
|
|
|
+ addr.sin_addr.s_addr = host.s_addr;
|
|
|
+ addr.sin_family = AF_INET;
|
|
|
+#ifdef WIN32
|
|
|
+ ctx->port = 0;
|
|
|
+ addr.sin_port = htons(ctx->port);
|
|
|
+#else
|
|
|
+ ctx->port = 5000;
|
|
|
+ addr.sin_port = htons(ctx->port);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if (bind(ctx->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0 || listen(ctx->sock, 1)) {
|
|
|
+ LOG_ERROR("Cannot bind or listen RTSP listener: %s", strerror(errno));
|
|
|
+ free(ctx);
|
|
|
+ closesocket(ctx->sock);
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+#ifdef WIN32
|
|
|
+ getsockname(ctx->sock, (struct sockaddr *) &addr, &nlen);
|
|
|
+ ctx->port = ntohs(addr.sin_port);
|
|
|
+#endif
|
|
|
+
ctx->running = true;
|
|
|
+
memcpy(ctx->mac, mac, 6);
|
|
|
+ snprintf(id, 64, "%02X%02X%02X%02X%02X%02X@%s", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], name);
|
|
|
+
#ifdef WIN32
|
|
|
+ // seems that Windows snprintf does not add NULL char if actual size > max
|
|
|
+ id[63] = '\0';
|
|
|
+ ctx->svc = mdnsd_register_svc(ctx->svr, id, "_raop._tcp.local", ctx->port, NULL, (const char**) txt);
|
|
|
+ pthread_create(&ctx->thread, NULL, &rtsp_thread, ctx);
|
|
|
+
#else
|
|
|
+ LOG_INFO("starting mDNS with %s", id);
|
|
|
+ ESP_ERROR_CHECK( mdns_service_add(id, "_raop", "_tcp", ctx->port, txt, sizeof(txt) / sizeof(mdns_txt_item_t)) );
|
|
|
+
|
|
|
+ ctx->xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
|
|
|
+ ctx->thread = xTaskCreateStatic( (TaskFunction_t) rtsp_thread, "RTSP_thread", RTSP_STACK_SIZE, ctx, ESP_TASK_PRIO_MIN + 1, ctx->xStack, ctx->xTaskBuffer);
|
|
|
+#endif
|
|
|
+
|
|
|
+ return ctx;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+void raop_delete(struct raop_ctx_s *ctx) {
|
|
|
+#ifdef WIN32
|
|
|
+ int sock;
|
|
|
+ struct sockaddr addr;
|
|
|
+ socklen_t nlen = sizeof(struct sockaddr);
|
|
|
+#endif
|
|
|
+
|
|
|
+if (!ctx) return;
|
|
|
+
|
|
|
+#ifdef WIN32
|
|
|
+ ctx->running = false;
|
|
|
+
|
|
|
+ // wake-up thread by connecting socket, needed for freeBSD
|
|
|
+ sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
+ getsockname(ctx->sock, (struct sockaddr *) &addr, &nlen);
|
|
|
+ connect(sock, (struct sockaddr*) &addr, sizeof(addr));
|
|
|
+ closesocket(sock);
|
|
|
+
|
|
|
+ pthread_join(ctx->thread, NULL);
|
|
|
+
|
|
|
+ rtp_end(ctx->rtp);
|
|
|
+
|
|
|
+ shutdown(ctx->sock, SD_BOTH);
|
|
|
+ closesocket(ctx->sock);
|
|
|
+
|
|
|
+ // terminate search, but do not reclaim memory of pthread if never launched
|
|
|
+ if (ctx->active_remote.handle) {
|
|
|
+ close_mDNS(ctx->active_remote.handle);
|
|
|
+ pthread_join(ctx->search_thread, NULL);
|
|
|
+ }
|
|
|
+
|
|
|
+ // stop broadcasting devices
|
|
|
+ mdns_service_remove(ctx->svr, ctx->svc);
|
|
|
+ mdnsd_stop(ctx->svr);
|
|
|
+#else
|
|
|
+ // first stop the search task if any
|
|
|
+ if (ctx->active_remote.running) {
|
|
|
+ ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
|
|
|
+ ctx->active_remote.running = false;
|
|
|
+
|
|
|
+ vTaskResume(ctx->active_remote.thread);
|
|
|
+ ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
+ vTaskDelete(ctx->active_remote.thread);
|
|
|
+
|
|
|
+ heap_caps_free(ctx->active_remote.xTaskBuffer);
|
|
|
+ }
|
|
|
+
|
|
|
+ // then the RTSP task
|
|
|
+ ctx->joiner = xTaskGetCurrentTaskHandle();
|
|
|
+ ctx->running = false;
|
|
|
+
|
|
|
+ ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
+ vTaskDelete(ctx->thread);
|
|
|
+ heap_caps_free(ctx->xTaskBuffer);
|
|
|
+
|
|
|
+ rtp_end(ctx->rtp);
|
|
|
+
|
|
|
+ shutdown(ctx->sock, SHUT_RDWR);
|
|
|
+ closesocket(ctx->sock);
|
|
|
+
|
|
|
+ mdns_service_remove("_raop", "_tcp");
|
|
|
+#endif
|
|
|
+
|
|
|
+ NFREE(ctx->rtsp.aeskey);
|
|
|
+ NFREE(ctx->rtsp.aesiv);
|
|
|
+ NFREE(ctx->rtsp.fmtp);
|
|
|
+
|
|
|
+ free(ctx);
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+void raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param) {
|
|
|
+ struct sockaddr_in addr;
|
|
|
+ int sock;
|
|
|
+ char *command = NULL;
|
|
|
+
|
|
|
+ // first notify the remote controller (if any)
|
|
|
+ switch(event) {
|
|
|
+ case RAOP_REW:
|
|
|
+ command = strdup("beginrew");
|
|
|
+ break;
|
|
|
+ case RAOP_FWD:
|
|
|
+ command = strdup("beginff");
|
|
|
+ break;
|
|
|
+ case RAOP_PREV:
|
|
|
+ command = strdup("previtem");
|
|
|
+ break;
|
|
|
+ case RAOP_NEXT:
|
|
|
+ command = strdup("nextitem");
|
|
|
+ break;
|
|
|
+ case RAOP_TOGGLE:
|
|
|
+ command = strdup("playpause");
|
|
|
+ break;
|
|
|
+ case RAOP_PAUSE:
|
|
|
+ command = strdup("pause");
|
|
|
+ break;
|
|
|
+ case RAOP_PLAY:
|
|
|
+ command = strdup("play");
|
|
|
+ break;
|
|
|
+ case RAOP_RESUME:
|
|
|
+ command = strdup("playresume");
|
|
|
+ break;
|
|
|
+ case RAOP_STOP:
|
|
|
+ command = strdup("stop");
|
|
|
+ break;
|
|
|
+ case RAOP_VOLUME_UP:
|
|
|
+ command = strdup("volumeup");
|
|
|
+ break;
|
|
|
+ case RAOP_VOLUME_DOWN:
|
|
|
+ command = strdup("volumedown");
|
|
|
+ break;
|
|
|
+ case RAOP_VOLUME: {
|
|
|
+ float Volume = *((float*) param);
|
|
|
+ Volume = Volume ? (Volume - 1) * 30 : -144;
|
|
|
+ asprintf(&command,"setproperty?dmcp.device-volume=%0.4lf", Volume);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // no command to send to remote or no remote found yet
|
|
|
+ if (!command || !ctx->active_remote.port) {
|
|
|
+ NFREE(command);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
+
|
|
|
+ memset(&addr, 0, sizeof(addr));
|
|
|
+ addr.sin_family = AF_INET;
|
|
|
+ addr.sin_addr.s_addr = S_ADDR(ctx->active_remote.host);
|
|
|
+ addr.sin_port = htons(ctx->active_remote.port);
|
|
|
+
|
|
|
+ if (!connect(sock, (struct sockaddr*) &addr, sizeof(addr))) {
|
|
|
+ char *method, *buf, resp[512] = "";
|
|
|
+ int len;
|
|
|
+ key_data_t headers[4] = { {NULL, NULL} };
|
|
|
+
|
|
|
+ asprintf(&method, "GET /ctrl-int/1/%s HTTP/1.0", command);
|
|
|
+ kd_add(headers, "Active-Remote", ctx->active_remote.id);
|
|
|
+ kd_add(headers, "Connection", "close");
|
|
|
+
|
|
|
+ buf = http_send(sock, method, headers);
|
|
|
+ len = recv(sock, resp, 512, 0);
|
|
|
+ if (len > 0) resp[len-1] = '\0';
|
|
|
+ LOG_INFO("[%p]: sending airplay remote\n%s<== received ==>\n%s", ctx, buf, resp);
|
|
|
+
|
|
|
+ NFREE(method);
|
|
|
+ NFREE(buf);
|
|
|
+ kd_free(headers);
|
|
|
+ }
|
|
|
+
|
|
|
+ free(command);
|
|
|
+ closesocket(sock);
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static void *rtsp_thread(void *arg) {
|
|
|
+ raop_ctx_t *ctx = (raop_ctx_t*) arg;
|
|
|
+ int sock = -1;
|
|
|
+
|
|
|
+ while (ctx->running) {
|
|
|
+ fd_set rfds;
|
|
|
+ struct timeval timeout = {0, 100*1000};
|
|
|
+ int n;
|
|
|
+ bool res = false;
|
|
|
+
|
|
|
+ if (sock == -1) {
|
|
|
+ struct sockaddr_in peer;
|
|
|
+ socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
|
+
|
|
|
+ sock = accept(ctx->sock, (struct sockaddr*) &peer, &addrlen);
|
|
|
+ ctx->peer.s_addr = peer.sin_addr.s_addr;
|
|
|
+
|
|
|
+ if (sock != -1 && ctx->running) {
|
|
|
+ LOG_INFO("got RTSP connection %u", sock);
|
|
|
+ } else continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ FD_ZERO(&rfds);
|
|
|
+ FD_SET(sock, &rfds);
|
|
|
+
|
|
|
+ n = select(sock + 1, &rfds, NULL, NULL, &timeout);
|
|
|
+
|
|
|
+ if (!n) continue;
|
|
|
+
|
|
|
+ if (n > 0) res = handle_rtsp(ctx, sock);
|
|
|
+
|
|
|
+ if (n < 0 || !res) {
|
|
|
+ closesocket(sock);
|
|
|
+ LOG_INFO("RTSP close %u", sock);
|
|
|
+ sock = -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (sock != -1) closesocket(sock);
|
|
|
+
|
|
|
+#ifndef WIN32
|
|
|
+ xTaskNotifyGive(ctx->joiner);
|
|
|
+ vTaskSuspend(NULL);
|
|
|
+#endif
|
|
|
+
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static bool handle_rtsp(raop_ctx_t *ctx, int sock)
|
|
|
+{
|
|
|
+ char *buf = NULL, *body = NULL, method[16] = "";
|
|
|
+ key_data_t headers[16], resp[8] = { {NULL, NULL} };
|
|
|
+ int len;
|
|
|
+ bool success = true;
|
|
|
+
|
|
|
+ if (!http_parse(sock, method, headers, &body, &len)) {
|
|
|
+ NFREE(body);
|
|
|
+ kd_free(headers);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (strcmp(method, "OPTIONS")) {
|
|
|
+ LOG_INFO("[%p]: received %s", ctx, method);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((buf = kd_lookup(headers, "Apple-Challenge")) != NULL) {
|
|
|
+ int n;
|
|
|
+ char *buf_pad, *p, *data_b64 = NULL, data[32];
|
|
|
+
|
|
|
+ LOG_INFO("[%p]: challenge %s", ctx, buf);
|
|
|
+
|
|
|
+ // need to pad the base64 string as apple device don't
|
|
|
+ base64_pad(buf, &buf_pad);
|
|
|
+
|
|
|
+ p = data + min(base64_decode(buf_pad, data), 32-10);
|
|
|
+ p = (char*) memcpy(p, &S_ADDR(ctx->host), 4) + 4;
|
|
|
+ p = (char*) memcpy(p, ctx->mac, 6) + 6;
|
|
|
+ memset(p, 0, 32 - (p - data));
|
|
|
+ p = rsa_apply((unsigned char*) data, 32, &n, RSA_MODE_AUTH);
|
|
|
+ n = base64_encode(p, n, &data_b64);
|
|
|
+
|
|
|
+ // remove padding as well (seems to be optional now)
|
|
|
+ for (n = strlen(data_b64) - 1; n > 0 && data_b64[n] == '='; data_b64[n--] = '\0');
|
|
|
+
|
|
|
+ kd_add(resp, "Apple-Response", data_b64);
|
|
|
+
|
|
|
+ NFREE(p);
|
|
|
+ NFREE(buf_pad);
|
|
|
+ NFREE(data_b64);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!strcmp(method, "OPTIONS")) {
|
|
|
+
|
|
|
+ kd_add(resp, "Public", "ANNOUNCE, SETUP, RECORD, PAUSE, FLUSH, TEARDOWN, OPTIONS, GET_PARAMETER, SET_PARAMETER");
|
|
|
+
|
|
|
+ } else if (!strcmp(method, "ANNOUNCE")) {
|
|
|
+ char *padded, *p;
|
|
|
+
|
|
|
+ NFREE(ctx->rtsp.aeskey);
|
|
|
+ NFREE(ctx->rtsp.aesiv);
|
|
|
+ NFREE(ctx->rtsp.fmtp);
|
|
|
+
|
|
|
+ // LMS might has taken over the player, leaving us with a running RTP session (should not happen)
|
|
|
+ if (ctx->rtp) {
|
|
|
+ LOG_WARN("[%p]: closing unfinished RTP session", ctx);
|
|
|
+ rtp_end(ctx->rtp);
|
|
|
+ }
|
|
|
+
|
|
|
+ // same, should not happen unless we have missed a teardown ...
|
|
|
+ if (ctx->active_remote.running) {
|
|
|
+ ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
|
|
|
+ ctx->active_remote.running = false;
|
|
|
+
|
|
|
+ vTaskResume(ctx->active_remote.thread);
|
|
|
+ ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
+ vTaskDelete(ctx->active_remote.thread);
|
|
|
+
|
|
|
+ heap_caps_free(ctx->active_remote.xTaskBuffer);
|
|
|
+ memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
|
|
|
+
|
|
|
+ LOG_WARN("[%p]: closing unfinished mDNS search", ctx);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((p = strcasestr(body, "rsaaeskey")) != NULL) {
|
|
|
+ unsigned char *aeskey;
|
|
|
+ int len, outlen;
|
|
|
+
|
|
|
+ p = strextract(p, ":", "\r\n");
|
|
|
+ base64_pad(p, &padded);
|
|
|
+ aeskey = malloc(strlen(padded));
|
|
|
+ len = base64_decode(padded, aeskey);
|
|
|
+ ctx->rtsp.aeskey = rsa_apply(aeskey, len, &outlen, RSA_MODE_KEY);
|
|
|
+
|
|
|
+ NFREE(p);
|
|
|
+ NFREE(aeskey);
|
|
|
+ NFREE(padded);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((p = strcasestr(body, "aesiv")) != NULL) {
|
|
|
+ p = strextract(p, ":", "\r\n");
|
|
|
+ base64_pad(p, &padded);
|
|
|
+ ctx->rtsp.aesiv = malloc(strlen(padded));
|
|
|
+ base64_decode(padded, ctx->rtsp.aesiv);
|
|
|
+
|
|
|
+ NFREE(p);
|
|
|
+ NFREE(padded);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((p = strcasestr(body, "fmtp")) != NULL) {
|
|
|
+ p = strextract(p, ":", "\r\n");
|
|
|
+ ctx->rtsp.fmtp = strdup(p);
|
|
|
+ NFREE(p);
|
|
|
+ }
|
|
|
+
|
|
|
+ // on announce, search remote
|
|
|
+ if ((buf = kd_lookup(headers, "DACP-ID")) != NULL) strcpy(ctx->active_remote.DACPid, buf);
|
|
|
+ if ((buf = kd_lookup(headers, "Active-Remote")) != NULL) strcpy(ctx->active_remote.id, buf);
|
|
|
+
|
|
|
+#ifdef WIN32
|
|
|
+ ctx->active_remote.handle = init_mDNS(false, ctx->host);
|
|
|
+ pthread_create(&ctx->search_thread, NULL, &search_remote, ctx);
|
|
|
+#else
|
|
|
+ ctx->active_remote.running = true;
|
|
|
+ ctx->active_remote.xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
|
|
|
+ ctx->active_remote.thread = xTaskCreateStatic( (TaskFunction_t) search_remote, "search_remote", SEARCH_STACK_SIZE, ctx, ESP_TASK_PRIO_MIN + 1, ctx->active_remote.xStack, ctx->active_remote.xTaskBuffer);
|
|
|
+#endif
|
|
|
+
|
|
|
+ } else if (!strcmp(method, "SETUP") && ((buf = kd_lookup(headers, "Transport")) != NULL)) {
|
|
|
+ char *p;
|
|
|
+ rtp_resp_t rtp = { 0 };
|
|
|
+ short unsigned tport = 0, cport = 0;
|
|
|
+
|
|
|
+ // we are about to stream, do something if needed
|
|
|
+ success = ctx->cmd_cb(RAOP_SETUP, NULL);
|
|
|
+
|
|
|
+ if ((p = strcasestr(buf, "timing_port")) != NULL) sscanf(p, "%*[^=]=%hu", &tport);
|
|
|
+ if ((p = strcasestr(buf, "control_port")) != NULL) sscanf(p, "%*[^=]=%hu", &cport);
|
|
|
+
|
|
|
+ rtp = rtp_init(ctx->peer, ctx->latency, ctx->rtsp.aeskey, ctx->rtsp.aesiv,
|
|
|
+ ctx->rtsp.fmtp, cport, tport, ctx->cmd_cb, ctx->data_cb);
|
|
|
+
|
|
|
+ ctx->rtp = rtp.ctx;
|
|
|
+
|
|
|
+ if (cport * tport * rtp.cport * rtp.tport * rtp.aport && rtp.ctx) {
|
|
|
+ char *transport;
|
|
|
+ asprintf(&transport, "RTP/AVP/UDP;unicast;mode=record;control_port=%u;timing_port=%u;server_port=%u", rtp.cport, rtp.tport, rtp.aport);
|
|
|
+ LOG_DEBUG("[%p]: audio=(%hu:%hu), timing=(%hu:%hu), control=(%hu:%hu)", ctx, 0, rtp.aport, tport, rtp.tport, cport, rtp.cport);
|
|
|
+ kd_add(resp, "Transport", transport);
|
|
|
+ kd_add(resp, "Session", "DEADBEEF");
|
|
|
+ free(transport);
|
|
|
+ } else {
|
|
|
+ success = false;
|
|
|
+ LOG_INFO("[%p]: cannot start session, missing ports", ctx);
|
|
|
+ }
|
|
|
+
|
|
|
+ } else if (!strcmp(method, "RECORD")) {
|
|
|
+ unsigned short seqno = 0;
|
|
|
+ unsigned rtptime = 0;
|
|
|
+ char *p;
|
|
|
+
|
|
|
+ if (ctx->latency) {
|
|
|
+ char latency[6];
|
|
|
+ snprintf(latency, 6, "%u", ctx->latency);
|
|
|
+ kd_add(resp, "Audio-Latency", latency);
|
|
|
+ }
|
|
|
+
|
|
|
+ buf = kd_lookup(headers, "RTP-Info");
|
|
|
+ if (buf && (p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
|
|
|
+ if (buf && (p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
|
|
|
+
|
|
|
+ if (ctx->rtp) rtp_record(ctx->rtp, seqno, rtptime);
|
|
|
+
|
|
|
+ success = ctx->cmd_cb(RAOP_STREAM, NULL);
|
|
|
+
|
|
|
+ } else if (!strcmp(method, "FLUSH")) {
|
|
|
+ unsigned short seqno = 0;
|
|
|
+ unsigned rtptime = 0;
|
|
|
+ char *p;
|
|
|
+
|
|
|
+ buf = kd_lookup(headers, "RTP-Info");
|
|
|
+ if ((p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
|
|
|
+ if ((p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
|
|
|
+
|
|
|
+ // only send FLUSH if useful (discards frames above buffer head and top)
|
|
|
+ if (ctx->rtp && rtp_flush(ctx->rtp, seqno, rtptime))
|
|
|
+ success = ctx->cmd_cb(RAOP_FLUSH, NULL);
|
|
|
+
|
|
|
+ } else if (!strcmp(method, "TEARDOWN")) {
|
|
|
+
|
|
|
+ rtp_end(ctx->rtp);
|
|
|
+
|
|
|
+ ctx->rtp = NULL;
|
|
|
+
|
|
|
+ // need to make sure no search is on-going and reclaim pthread memory
|
|
|
+#ifdef WIN32
|
|
|
+ if (ctx->active_remote.handle) close_mDNS(ctx->active_remote.handle);
|
|
|
+ pthread_join(ctx->search_thread, NULL);
|
|
|
+#else
|
|
|
+ ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
|
|
|
+ ctx->active_remote.running = false;
|
|
|
+
|
|
|
+ // task might not need to be resumed anyway
|
|
|
+ vTaskResume(ctx->active_remote.thread);
|
|
|
+ ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
|
|
|
+ vTaskDelete(ctx->active_remote.thread);
|
|
|
+
|
|
|
+ heap_caps_free(ctx->active_remote.xTaskBuffer);
|
|
|
+
|
|
|
+ LOG_INFO("[%p]: mDNS search task terminated", ctx);
|
|
|
+#endif
|
|
|
+
|
|
|
+ memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
|
|
|
+ NFREE(ctx->rtsp.aeskey);
|
|
|
+ NFREE(ctx->rtsp.aesiv);
|
|
|
+ NFREE(ctx->rtsp.fmtp);
|
|
|
+
|
|
|
+ success = ctx->cmd_cb(RAOP_STOP, NULL);
|
|
|
+
|
|
|
+ } else if (!strcmp(method, "SET_PARAMETER")) {
|
|
|
+ char *p;
|
|
|
+
|
|
|
+ if (body && (p = strcasestr(body, "volume")) != NULL) {
|
|
|
+ float volume;
|
|
|
+
|
|
|
+ sscanf(p, "%*[^:]:%f", &volume);
|
|
|
+ LOG_INFO("[%p]: SET PARAMETER volume %f", ctx, volume);
|
|
|
+ volume = (volume == -144.0) ? 0 : (1 + volume / 30);
|
|
|
+ success = ctx->cmd_cb(RAOP_VOLUME, &volume);
|
|
|
+ }
|
|
|
+/*
|
|
|
+ if (body && ((p = kd_lookup(headers, "Content-Type")) != NULL) && !strcasecmp(p, "application/x-dmap-tagged")) {
|
|
|
+ struct metadata_s metadata;
|
|
|
+ dmap_settings settings = {
|
|
|
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, on_dmap_string, NULL,
|
|
|
+ NULL
|
|
|
+ };
|
|
|
+
|
|
|
+ settings.ctx = &metadata;
|
|
|
+ memset(&metadata, 0, sizeof(struct metadata_s));
|
|
|
+ if (!dmap_parse(&settings, body, len)) {
|
|
|
+ LOG_INFO("[%p]: received metadata\n\tartist: %s\n\talbum: %s\n\ttitle: %s",
|
|
|
+ ctx, metadata.artist, metadata.album, metadata.title);
|
|
|
+ free_metadata(&metadata);
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+ }
|
|
|
+
|
|
|
+ // don't need to free "buf" because kd_lookup return a pointer, not a strdup
|
|
|
+ kd_add(resp, "Audio-Jack-Status", "connected; type=analog");
|
|
|
+ kd_add(resp, "CSeq", kd_lookup(headers, "CSeq"));
|
|
|
+
|
|
|
+ if (success) buf = http_send(sock, "RTSP/1.0 200 OK", resp);
|
|
|
+ else buf = http_send(sock, "RTSP/1.0 500 ERROR", NULL);
|
|
|
+
|
|
|
+ if (strcmp(method, "OPTIONS")) {
|
|
|
+ LOG_INFO("[%p]: responding:\n%s", ctx, buf ? buf : "<void>");
|
|
|
+ }
|
|
|
+
|
|
|
+ NFREE(body);
|
|
|
+ NFREE(buf);
|
|
|
+ kd_free(resp);
|
|
|
+ kd_free(headers);
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+#ifdef WIN32
|
|
|
+bool search_remote_cb(mDNSservice_t *slist, void *cookie, bool *stop) {
|
|
|
+ mDNSservice_t *s;
|
|
|
+ raop_ctx_t *ctx = (raop_ctx_t*) cookie;
|
|
|
+
|
|
|
+ // see if we have found an active remote for our ID
|
|
|
+ for (s = slist; s; s = s->next) {
|
|
|
+ if (strcasestr(s->name, ctx->active_remote.DACPid)) {
|
|
|
+ ctx->active_remote.host = s->addr;
|
|
|
+ ctx->active_remote.port = s->port;
|
|
|
+ LOG_INFO("[%p]: found ActiveRemote for %s at %s:%u", ctx, ctx->active_remote.DACPid,
|
|
|
+ inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
|
|
|
+ *stop = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // let caller clear list
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static void* search_remote(void *args) {
|
|
|
+ raop_ctx_t *ctx = (raop_ctx_t*) args;
|
|
|
+
|
|
|
+ query_mDNS(ctx->active_remote.handle, "_dacp._tcp.local", 0, 0, &search_remote_cb, (void*) ctx);
|
|
|
+
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+#else
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static void* search_remote(void *args) {
|
|
|
+ raop_ctx_t *ctx = (raop_ctx_t*) args;
|
|
|
+ bool found = false;
|
|
|
+
|
|
|
+ LOG_INFO("starting remote search");
|
|
|
+
|
|
|
+ while (ctx->active_remote.running && !found) {
|
|
|
+ mdns_result_t *results = NULL;
|
|
|
+ mdns_result_t *r;
|
|
|
+ mdns_ip_addr_t *a;
|
|
|
+
|
|
|
+ if (mdns_query_ptr("_dacp", "_tcp", 3000, 32, &results)) {
|
|
|
+ LOG_ERROR("mDNS active remote query Failed");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (r = results; r && !strcasestr(r->instance_name, ctx->active_remote.DACPid); r = r->next);
|
|
|
+ if (r) {
|
|
|
+ for (a = r->addr; a && a->addr.type != IPADDR_TYPE_V4; a = a->next);
|
|
|
+ if (a) {
|
|
|
+ found = true;
|
|
|
+ ctx->active_remote.host.s_addr = a->addr.u_addr.ip4.addr;
|
|
|
+ ctx->active_remote.port = r->port;
|
|
|
+ LOG_INFO("found remote %s %s:%hu", r->instance_name, inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ mdns_query_results_free(results);
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ for some reason which is beyond me, if that tasks gives the semaphore
|
|
|
+ before the RTSP tasks waits for it, then freeRTOS crashes in queue
|
|
|
+ management caused by LWIP stack once the RTSP socket is closed. I have
|
|
|
+ no clue why, but so we'll suspend the tasks as soon as we're done with
|
|
|
+ search and wait for the resume then give the semaphore
|
|
|
+ */
|
|
|
+ // PS: I know this is not fully race-condition free
|
|
|
+ if (ctx->active_remote.running) vTaskSuspend(NULL);
|
|
|
+ xTaskNotifyGive(ctx->active_remote.joiner);
|
|
|
+
|
|
|
+ // now our context will be deleted
|
|
|
+ vTaskSuspend(NULL);
|
|
|
+
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+
/*----------------------------------------------------------------------------*/
|
|
|
+static char *rsa_apply(unsigned char *input, int inlen, int *outlen, int mode)
|
|
|
+{
|
|
|
+ static char super_secret_key[] =
|
|
|
+ "-----BEGIN RSA PRIVATE KEY-----\n"
|
|
|
+ "MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt\n"
|
|
|
+ "wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U\n"
|
|
|
+ "wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf\n"
|
|
|
+ "/+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/\n"
|
|
|
+ "UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW\n"
|
|
|
+ "BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa\n"
|
|
|
+ "LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5\n"
|
|
|
+ "NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm\n"
|
|
|
+ "lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz\n"
|
|
|
+ "aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu\n"
|
|
|
+ "a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM\n"
|
|
|
+ "oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z\n"
|
|
|
+ "oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+\n"
|
|
|
+ "k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL\n"
|
|
|
+ "AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA\n"
|
|
|
+ "cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf\n"
|
|
|
+ "54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov\n"
|
|
|
+ "17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc\n"
|
|
|
+ "1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI\n"
|
|
|
+ "LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ\n"
|
|
|
+ "2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKY=\n"
|
|
|
+ "-----END RSA PRIVATE KEY-----";
|
|
|
+#ifdef WIN32
|
|
|
+ unsigned char *out;
|
|
|
+ RSA *rsa;
|
|
|
+
|
|
|
+ BIO *bmem = BIO_new_mem_buf(super_secret_key, -1);
|
|
|
+ rsa = PEM_read_bio_RSAPrivateKey(bmem, NULL, NULL, NULL);
|
|
|
+ BIO_free(bmem);
|
|
|
+
|
|
|
+ out = malloc(RSA_size(rsa));
|
|
|
+ switch (mode) {
|
|
|
+ case RSA_MODE_AUTH:
|
|
|
+ *outlen = RSA_private_encrypt(inlen, input, out, rsa,
|
|
|
+ RSA_PKCS1_PADDING);
|
|
|
+ break;
|
|
|
+ case RSA_MODE_KEY:
|
|
|
+ *outlen = RSA_private_decrypt(inlen, input, out, rsa,
|
|
|
+ RSA_PKCS1_OAEP_PADDING);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ RSA_free(rsa);
|
|
|
+
|
|
|
+ return (char*) out;
|
|
|
+#else
|
|
|
+ mbedtls_pk_context pkctx;
|
|
|
+ mbedtls_rsa_context *trsa;
|
|
|
+ size_t olen;
|
|
|
+
|
|
|
+ /*
|
|
|
+ we should do entropy initialization & pass a rng function but this
|
|
|
+ consumes a ton of stack and there is no security concern here. Anyway,
|
|
|
+ mbedtls takes a lot of stack, unfortunately ...
|
|
|
+ */
|
|
|
+
|
|
|
+ mbedtls_pk_init(&pkctx);
|
|
|
+ mbedtls_pk_parse_key(&pkctx, (unsigned char *)super_secret_key,
|
|
|
+ sizeof(super_secret_key), NULL, 0);
|
|
|
+
|
|
|
+ uint8_t *outbuf = NULL;
|
|
|
+ trsa = mbedtls_pk_rsa(pkctx);
|
|
|
+
|
|
|
+ switch (mode) {
|
|
|
+ case RSA_MODE_AUTH:
|
|
|
+ mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE);
|
|
|
+ outbuf = malloc(trsa->len);
|
|
|
+ mbedtls_rsa_pkcs1_encrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, inlen, input, outbuf);
|
|
|
+ *outlen = trsa->len;
|
|
|
+ break;
|
|
|
+ case RSA_MODE_KEY:
|
|
|
+ mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
|
|
|
+ outbuf = malloc(trsa->len);
|
|
|
+ mbedtls_rsa_pkcs1_decrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, &olen, input, outbuf, trsa->len);
|
|
|
+ *outlen = olen;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ mbedtls_pk_free(&pkctx);
|
|
|
+
|
|
|
+ return (char*) outbuf;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+#define DECODE_ERROR 0xffffffff
|
|
|
+
|
|
|
+static char base64_chars[] =
|
|
|
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static int base64_pad(char *src, char **padded)
|
|
|
+{
|
|
|
+ int n;
|
|
|
+
|
|
|
+ n = strlen(src) + strlen(src) % 4;
|
|
|
+ *padded = malloc(n + 1);
|
|
|
+ memset(*padded, '=', n);
|
|
|
+ memcpy(*padded, src, strlen(src));
|
|
|
+ (*padded)[n] = '\0';
|
|
|
+
|
|
|
+ return strlen(*padded);
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static int pos(char c)
|
|
|
+{
|
|
|
+ char *p;
|
|
|
+ for (p = base64_chars; *p; p++)
|
|
|
+ if (*p == c)
|
|
|
+ return p - base64_chars;
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static int base64_encode(const void *data, int size, char **str)
|
|
|
+{
|
|
|
+ char *s, *p;
|
|
|
+ int i;
|
|
|
+ int c;
|
|
|
+ const unsigned char *q;
|
|
|
+
|
|
|
+ p = s = (char *) malloc(size * 4 / 3 + 4);
|
|
|
+ if (p == NULL) return -1;
|
|
|
+ q = (const unsigned char *) data;
|
|
|
+ i = 0;
|
|
|
+ for (i = 0; i < size;) {
|
|
|
+ c = q[i++];
|
|
|
+ c *= 256;
|
|
|
+ if (i < size) c += q[i];
|
|
|
+ i++;
|
|
|
+ c *= 256;
|
|
|
+ if (i < size) c += q[i];
|
|
|
+ i++;
|
|
|
+ p[0] = base64_chars[(c & 0x00fc0000) >> 18];
|
|
|
+ p[1] = base64_chars[(c & 0x0003f000) >> 12];
|
|
|
+ p[2] = base64_chars[(c & 0x00000fc0) >> 6];
|
|
|
+ p[3] = base64_chars[(c & 0x0000003f) >> 0];
|
|
|
+ if (i > size) p[3] = '=';
|
|
|
+ if (i > size + 1) p[2] = '=';
|
|
|
+ p += 4;
|
|
|
+ }
|
|
|
+ *p = 0;
|
|
|
+ *str = s;
|
|
|
+ return strlen(s);
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static unsigned int token_decode(const char *token)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ unsigned int val = 0;
|
|
|
+ int marker = 0;
|
|
|
+ if (strlen(token) < 4)
|
|
|
+ return DECODE_ERROR;
|
|
|
+ for (i = 0; i < 4; i++) {
|
|
|
+ val *= 64;
|
|
|
+ if (token[i] == '=')
|
|
|
+ marker++;
|
|
|
+ else if (marker > 0)
|
|
|
+ return DECODE_ERROR;
|
|
|
+ else
|
|
|
+ val += pos(token[i]);
|
|
|
+ }
|
|
|
+ if (marker > 2)
|
|
|
+ return DECODE_ERROR;
|
|
|
+ return (marker << 24) | val;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static int base64_decode(const char *str, void *data)
|
|
|
+{
|
|
|
+ const char *p;
|
|
|
+ unsigned char *q;
|
|
|
+
|
|
|
+ q = data;
|
|
|
+ for (p = str; *p && (*p == '=' || strchr(base64_chars, *p)); p += 4) {
|
|
|
+ unsigned int val = token_decode(p);
|
|
|
+ unsigned int marker = (val >> 24) & 0xff;
|
|
|
+ if (val == DECODE_ERROR)
|
|
|
+ return -1;
|
|
|
+ *q++ = (val >> 16) & 0xff;
|
|
|
+ if (marker < 2)
|
|
|
+ *q++ = (val >> 8) & 0xff;
|
|
|
+ if (marker < 1)
|
|
|
+ *q++ = val & 0xff;
|
|
|
+ }
|
|
|
+ return q - (unsigned char *) data;
|
|
|
+}
|
|
|
+
|
|
|
+/*----------------------------------------------------------------------------*/
|
|
|
+static void on_dmap_string(void *ctx, const char *code, const char *name, const char *buf, size_t len) {
|
|
|
+ struct metadata_s *metadata = (struct metadata_s *) ctx;
|
|
|
+
|
|
|
+ if (!strcasecmp(code, "asar")) metadata->artist = strndup(buf, len);
|
|
|
+ else if (!strcasecmp(code, "asal")) metadata->album = strndup(buf, len);
|
|
|
+ else if (!strcasecmp(code, "minm")) metadata->title = strndup(buf, len);
|
|
|
+}
|
|
|
+
|
Sebastien