raop.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960
  1. /*
  2. *
  3. * (c) Philippe 2019, philippe_44@outlook.com
  4. *
  5. * This program is free software: you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation, either version 3 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17. *
  18. */
  19. #include <stdio.h>
  20. #include "platform.h"
  21. #ifdef WIN32
  22. #include <openssl/err.h>
  23. #include <openssl/rand.h>
  24. #include <openssl/rsa.h>
  25. #include <openssl/pem.h>
  26. #include <openssl/engine.h>
  27. #include "mdns.h"
  28. #include "mdnsd.h"
  29. #include "mdnssd-itf.h"
  30. #else
  31. #include "esp_pthread.h"
  32. #include "mdns.h"
  33. #include "mbedtls/version.h"
  34. #include <mbedtls/x509.h>
  35. #endif
  36. #include "util.h"
  37. #include "raop.h"
  38. #include "rtp.h"
  39. #include "dmap_parser.h"
  40. #include "log_util.h"
  41. #define RTSP_STACK_SIZE (8*1024)
  42. #define SEARCH_STACK_SIZE (3*1048)
  43. typedef struct raop_ctx_s {
  44. #ifdef WIN32
  45. struct mdns_service *svc;
  46. struct mdnsd *svr;
  47. #endif
  48. struct in_addr host; // IP of bridge
  49. short unsigned port; // RTSP port for AirPlay
  50. int sock; // socket of the above
  51. struct in_addr peer; // IP of the iDevice (airplay sender)
  52. bool running;
  53. #ifdef WIN32
  54. pthread_t thread;
  55. #else
  56. TaskHandle_t thread, joiner;
  57. StaticTask_t *xTaskBuffer;
  58. StackType_t xStack[RTSP_STACK_SIZE] __attribute__ ((aligned (4)));
  59. #endif
  60. /*
  61. Compiler/Execution bug: if this bool is next to 'running', the rtsp_thread
  62. loop sees 'running' being set to false from at first execution ...
  63. */
  64. bool abort;
  65. unsigned char mac[6];
  66. int latency;
  67. struct {
  68. char *aesiv, *aeskey;
  69. char *fmtp;
  70. } rtsp;
  71. struct rtp_s *rtp;
  72. raop_cmd_cb_t cmd_cb;
  73. raop_data_cb_t data_cb;
  74. struct {
  75. char DACPid[32], id[32];
  76. struct in_addr host;
  77. u16_t port;
  78. bool running;
  79. #ifdef WIN32
  80. struct mDNShandle_s *handle;
  81. pthread_t thread;
  82. #else
  83. TaskHandle_t thread;
  84. StaticTask_t *xTaskBuffer;
  85. StackType_t xStack[SEARCH_STACK_SIZE] __attribute__ ((aligned (4)));;
  86. SemaphoreHandle_t destroy_mutex;
  87. #endif
  88. } active_remote;
  89. void *owner;
  90. } raop_ctx_t;
  91. extern struct mdnsd* glmDNSServer;
  92. extern log_level raop_loglevel;
  93. static log_level *loglevel = &raop_loglevel;
  94. static void* rtsp_thread(void *arg);
  95. static void cleanup_rtsp(raop_ctx_t *ctx, bool abort);
  96. static bool handle_rtsp(raop_ctx_t *ctx, int sock);
  97. static char* rsa_apply(unsigned char *input, int inlen, int *outlen, int mode);
  98. static int base64_pad(char *src, char **padded);
  99. static int base64_encode(const void *data, int size, char **str);
  100. static int base64_decode(const char *str, void *data);
  101. static void* search_remote(void *args);
  102. extern char private_key[];
  103. enum { RSA_MODE_KEY, RSA_MODE_AUTH };
  104. static void on_dmap_string(void *ctx, const char *code, const char *name, const char *buf, size_t len);
  105. /*----------------------------------------------------------------------------*/
  106. struct raop_ctx_s *raop_create(struct in_addr host, char *name,
  107. unsigned char mac[6], int latency,
  108. raop_cmd_cb_t cmd_cb, raop_data_cb_t data_cb) {
  109. struct raop_ctx_s *ctx = malloc(sizeof(struct raop_ctx_s));
  110. struct sockaddr_in addr;
  111. char id[64];
  112. #ifdef WIN32
  113. socklen_t nlen = sizeof(struct sockaddr);
  114. char *txt[] = { "am=airesp32", "tp=UDP", "sm=false", "sv=false", "ek=1",
  115. "et=0,1", "md=0,1,2", "cn=0,1", "ch=2",
  116. "ss=16", "sr=44100", "vn=3", "txtvers=1",
  117. NULL };
  118. #else
  119. mdns_txt_item_t txt[] = {
  120. {"am", "airesp32"},
  121. {"tp", "UDP"},
  122. {"sm","false"},
  123. {"sv","false"},
  124. {"ek","1"},
  125. {"et","0,1"},
  126. {"md","0,1,2"},
  127. {"cn","0,1"},
  128. {"ch","2"},
  129. {"ss","16"},
  130. {"sr","44100"},
  131. {"vn","3"},
  132. {"txtvers","1"},
  133. };
  134. #endif
  135. if (!ctx) return NULL;
  136. // make sure we have a clean context
  137. memset(ctx, 0, sizeof(raop_ctx_t));
  138. #ifdef WIN32
  139. ctx->svr = glmDNSServer;
  140. #endif
  141. ctx->host = host;
  142. ctx->sock = socket(AF_INET, SOCK_STREAM, 0);
  143. ctx->cmd_cb = cmd_cb;
  144. ctx->data_cb = data_cb;
  145. ctx->latency = min(latency, 88200);
  146. if (ctx->sock == -1) {
  147. LOG_ERROR("Cannot create listening socket", NULL);
  148. free(ctx);
  149. return NULL;
  150. }
  151. memset(&addr, 0, sizeof(addr));
  152. addr.sin_addr.s_addr = host.s_addr;
  153. addr.sin_family = AF_INET;
  154. #ifdef WIN32
  155. ctx->port = 0;
  156. addr.sin_port = htons(ctx->port);
  157. #else
  158. ctx->port = 5000;
  159. addr.sin_port = htons(ctx->port);
  160. #endif
  161. if (bind(ctx->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0 || listen(ctx->sock, 1)) {
  162. LOG_ERROR("Cannot bind or listen RTSP listener: %s", strerror(errno));
  163. free(ctx);
  164. closesocket(ctx->sock);
  165. return NULL;
  166. }
  167. #ifdef WIN32
  168. getsockname(ctx->sock, (struct sockaddr *) &addr, &nlen);
  169. ctx->port = ntohs(addr.sin_port);
  170. #endif
  171. ctx->running = true;
  172. memcpy(ctx->mac, mac, 6);
  173. snprintf(id, 64, "%02X%02X%02X%02X%02X%02X@%s", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], name);
  174. #ifdef WIN32
  175. // seems that Windows snprintf does not add NULL char if actual size > max
  176. id[63] = '\0';
  177. ctx->svc = mdnsd_register_svc(ctx->svr, id, "_raop._tcp.local", ctx->port, NULL, (const char**) txt);
  178. pthread_create(&ctx->thread, NULL, &rtsp_thread, ctx);
  179. #else
  180. LOG_INFO("starting mDNS with %s", id);
  181. ESP_ERROR_CHECK( mdns_service_add(id, "_raop", "_tcp", ctx->port, txt, sizeof(txt) / sizeof(mdns_txt_item_t)) );
  182. ctx->xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  183. ctx->thread = xTaskCreateStatic( (TaskFunction_t) rtsp_thread, "RTSP_thread", RTSP_STACK_SIZE, ctx, ESP_TASK_PRIO_MIN + 1, ctx->xStack, ctx->xTaskBuffer);
  184. #endif
  185. return ctx;
  186. }
  187. /*----------------------------------------------------------------------------*/
  188. void raop_abort(struct raop_ctx_s *ctx) {
  189. LOG_INFO("[%p]: aborting RTSP session at next select() wakeup", ctx);
  190. ctx->abort = true;
  191. }
  192. /*----------------------------------------------------------------------------*/
  193. void raop_delete(struct raop_ctx_s *ctx) {
  194. #ifdef WIN32
  195. int sock;
  196. struct sockaddr addr;
  197. socklen_t nlen = sizeof(struct sockaddr);
  198. #endif
  199. if (!ctx) return;
  200. #ifdef WIN32
  201. ctx->running = false;
  202. // wake-up thread by connecting socket, needed for freeBSD
  203. sock = socket(AF_INET, SOCK_STREAM, 0);
  204. getsockname(ctx->sock, (struct sockaddr *) &addr, &nlen);
  205. connect(sock, (struct sockaddr*) &addr, sizeof(addr));
  206. closesocket(sock);
  207. pthread_join(ctx->thread, NULL);
  208. rtp_end(ctx->rtp);
  209. shutdown(ctx->sock, SD_BOTH);
  210. closesocket(ctx->sock);
  211. // terminate search, but do not reclaim memory of pthread if never launched
  212. if (ctx->active_remote.handle) {
  213. close_mDNS(ctx->active_remote.handle);
  214. pthread_join(ctx->active_remote.thread, NULL);
  215. }
  216. // stop broadcasting devices
  217. mdns_service_remove(ctx->svr, ctx->svc);
  218. mdnsd_stop(ctx->svr);
  219. #else
  220. // then the RTSP task
  221. ctx->joiner = xTaskGetCurrentTaskHandle();
  222. ctx->running = false;
  223. ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
  224. vTaskDelete(ctx->thread);
  225. heap_caps_free(ctx->xTaskBuffer);
  226. shutdown(ctx->sock, SHUT_RDWR);
  227. closesocket(ctx->sock);
  228. // cleanup all session-created items
  229. cleanup_rtsp(ctx, true);
  230. mdns_service_remove("_raop", "_tcp");
  231. #endif
  232. NFREE(ctx->rtsp.aeskey);
  233. NFREE(ctx->rtsp.aesiv);
  234. NFREE(ctx->rtsp.fmtp);
  235. free(ctx);
  236. }
  237. /*----------------------------------------------------------------------------*/
  238. bool raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param) {
  239. struct sockaddr_in addr;
  240. int sock;
  241. char *command = NULL;
  242. // first notify the remote controller (if any)
  243. switch(event) {
  244. case RAOP_REW:
  245. command = strdup("beginrew");
  246. break;
  247. case RAOP_FWD:
  248. command = strdup("beginff");
  249. break;
  250. case RAOP_PREV:
  251. command = strdup("previtem");
  252. break;
  253. case RAOP_NEXT:
  254. command = strdup("nextitem");
  255. break;
  256. case RAOP_TOGGLE:
  257. command = strdup("playpause");
  258. break;
  259. case RAOP_PAUSE:
  260. command = strdup("pause");
  261. break;
  262. case RAOP_PLAY:
  263. command = strdup("play");
  264. break;
  265. case RAOP_RESUME:
  266. command = strdup("playresume");
  267. break;
  268. case RAOP_STOP:
  269. command = strdup("stop");
  270. break;
  271. case RAOP_VOLUME_UP:
  272. command = strdup("volumeup");
  273. break;
  274. case RAOP_VOLUME_DOWN:
  275. command = strdup("volumedown");
  276. break;
  277. case RAOP_VOLUME: {
  278. float Volume = *((float*) param);
  279. Volume = Volume ? (Volume - 1) * 30 : -144;
  280. asprintf(&command,"setproperty?dmcp.device-volume=%0.4lf", Volume);
  281. break;
  282. }
  283. default:
  284. break;
  285. }
  286. // no command to send to remote or no remote found yet
  287. if (!command || !ctx->active_remote.port) {
  288. NFREE(command);
  289. return false;
  290. }
  291. sock = socket(AF_INET, SOCK_STREAM, 0);
  292. memset(&addr, 0, sizeof(addr));
  293. addr.sin_family = AF_INET;
  294. addr.sin_addr.s_addr = S_ADDR(ctx->active_remote.host);
  295. addr.sin_port = htons(ctx->active_remote.port);
  296. if (!connect(sock, (struct sockaddr*) &addr, sizeof(addr))) {
  297. char *method, *buf, resp[512] = "";
  298. int len;
  299. key_data_t headers[4] = { {NULL, NULL} };
  300. asprintf(&method, "GET /ctrl-int/1/%s HTTP/1.0", command);
  301. kd_add(headers, "Active-Remote", ctx->active_remote.id);
  302. kd_add(headers, "Connection", "close");
  303. buf = http_send(sock, method, headers);
  304. len = recv(sock, resp, 512, 0);
  305. if (len > 0) resp[len-1] = '\0';
  306. LOG_INFO("[%p]: sending airplay remote\n%s<== received ==>\n%s", ctx, buf, resp);
  307. NFREE(method);
  308. NFREE(buf);
  309. kd_free(headers);
  310. }
  311. free(command);
  312. closesocket(sock);
  313. return true;
  314. }
  315. /*----------------------------------------------------------------------------*/
  316. static void *rtsp_thread(void *arg) {
  317. raop_ctx_t *ctx = (raop_ctx_t*) arg;
  318. int sock = -1;
  319. while (ctx->running) {
  320. fd_set rfds;
  321. struct timeval timeout = {0, 100*1000};
  322. int n;
  323. bool res = false;
  324. if (sock == -1) {
  325. struct sockaddr_in peer;
  326. socklen_t addrlen = sizeof(struct sockaddr_in);
  327. sock = accept(ctx->sock, (struct sockaddr*) &peer, &addrlen);
  328. ctx->peer.s_addr = peer.sin_addr.s_addr;
  329. ctx->abort = false;
  330. if (sock != -1 && ctx->running) {
  331. LOG_INFO("got RTSP connection %u", sock);
  332. } else continue;
  333. }
  334. FD_ZERO(&rfds);
  335. FD_SET(sock, &rfds);
  336. n = select(sock + 1, &rfds, NULL, NULL, &timeout);
  337. if (!n && !ctx->abort) continue;
  338. if (n > 0) res = handle_rtsp(ctx, sock);
  339. if (n < 0 || !res || ctx->abort) {
  340. cleanup_rtsp(ctx, true);
  341. closesocket(sock);
  342. LOG_INFO("RTSP close %u", sock);
  343. sock = -1;
  344. }
  345. }
  346. if (sock != -1) closesocket(sock);
  347. #ifndef WIN32
  348. xTaskNotifyGive(ctx->joiner);
  349. vTaskSuspend(NULL);
  350. #endif
  351. return NULL;
  352. }
  353. /*----------------------------------------------------------------------------*/
  354. static bool handle_rtsp(raop_ctx_t *ctx, int sock)
  355. {
  356. char *buf = NULL, *body = NULL, method[16] = "";
  357. key_data_t headers[16], resp[8] = { {NULL, NULL} };
  358. int len;
  359. bool success = true;
  360. if (!http_parse(sock, method, headers, &body, &len)) {
  361. NFREE(body);
  362. kd_free(headers);
  363. return false;
  364. }
  365. if (strcmp(method, "OPTIONS")) {
  366. LOG_INFO("[%p]: received %s", ctx, method);
  367. }
  368. if ((buf = kd_lookup(headers, "Apple-Challenge")) != NULL) {
  369. int n;
  370. char *buf_pad, *p, *data_b64 = NULL, data[32];
  371. LOG_INFO("[%p]: challenge %s", ctx, buf);
  372. // try to re-acquire IP address if we were missing it
  373. if (S_ADDR(ctx->host) == INADDR_ANY) {
  374. S_ADDR(ctx->host) = get_localhost(NULL);
  375. LOG_INFO("[%p]: IP was missing, trying to get it %s", ctx, inet_ntoa(ctx->host));
  376. }
  377. // need to pad the base64 string as apple device don't
  378. base64_pad(buf, &buf_pad);
  379. p = data + min(base64_decode(buf_pad, data), 32-10);
  380. p = (char*) memcpy(p, &S_ADDR(ctx->host), 4) + 4;
  381. p = (char*) memcpy(p, ctx->mac, 6) + 6;
  382. memset(p, 0, 32 - (p - data));
  383. p = rsa_apply((unsigned char*) data, 32, &n, RSA_MODE_AUTH);
  384. n = base64_encode(p, n, &data_b64);
  385. // remove padding as well (seems to be optional now)
  386. for (n = strlen(data_b64) - 1; n > 0 && data_b64[n] == '='; data_b64[n--] = '\0');
  387. kd_add(resp, "Apple-Response", data_b64);
  388. NFREE(p);
  389. NFREE(buf_pad);
  390. NFREE(data_b64);
  391. }
  392. if (!strcmp(method, "OPTIONS")) {
  393. kd_add(resp, "Public", "ANNOUNCE, SETUP, RECORD, PAUSE, FLUSH, TEARDOWN, OPTIONS, GET_PARAMETER, SET_PARAMETER");
  394. } else if (!strcmp(method, "ANNOUNCE")) {
  395. char *padded, *p;
  396. NFREE(ctx->rtsp.aeskey);
  397. NFREE(ctx->rtsp.aesiv);
  398. NFREE(ctx->rtsp.fmtp);
  399. if ((p = strcasestr(body, "rsaaeskey")) != NULL) {
  400. unsigned char *aeskey;
  401. int len, outlen;
  402. p = strextract(p, ":", "\r\n");
  403. base64_pad(p, &padded);
  404. aeskey = malloc(strlen(padded));
  405. len = base64_decode(padded, aeskey);
  406. ctx->rtsp.aeskey = rsa_apply(aeskey, len, &outlen, RSA_MODE_KEY);
  407. NFREE(p);
  408. NFREE(aeskey);
  409. NFREE(padded);
  410. }
  411. if ((p = strcasestr(body, "aesiv")) != NULL) {
  412. p = strextract(p, ":", "\r\n");
  413. base64_pad(p, &padded);
  414. ctx->rtsp.aesiv = malloc(strlen(padded));
  415. base64_decode(padded, ctx->rtsp.aesiv);
  416. NFREE(p);
  417. NFREE(padded);
  418. }
  419. if ((p = strcasestr(body, "fmtp")) != NULL) {
  420. p = strextract(p, ":", "\r\n");
  421. ctx->rtsp.fmtp = strdup(p);
  422. NFREE(p);
  423. }
  424. // on announce, search remote
  425. if ((buf = kd_lookup(headers, "DACP-ID")) != NULL) strcpy(ctx->active_remote.DACPid, buf);
  426. if ((buf = kd_lookup(headers, "Active-Remote")) != NULL) strcpy(ctx->active_remote.id, buf);
  427. #ifdef WIN32
  428. ctx->active_remote.handle = init_mDNS(false, ctx->host);
  429. pthread_create(&ctx->active_remote.thread, NULL, &search_remote, ctx);
  430. #else
  431. ctx->active_remote.running = true;
  432. ctx->active_remote.destroy_mutex = xSemaphoreCreateBinary();
  433. ctx->active_remote.xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  434. 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);
  435. #endif
  436. } else if (!strcmp(method, "SETUP") && ((buf = kd_lookup(headers, "Transport")) != NULL)) {
  437. char *p;
  438. rtp_resp_t rtp = { 0 };
  439. short unsigned tport = 0, cport = 0;
  440. // we are about to stream, do something if needed
  441. success = ctx->cmd_cb(RAOP_SETUP);
  442. if ((p = strcasestr(buf, "timing_port")) != NULL) sscanf(p, "%*[^=]=%hu", &tport);
  443. if ((p = strcasestr(buf, "control_port")) != NULL) sscanf(p, "%*[^=]=%hu", &cport);
  444. rtp = rtp_init(ctx->peer, ctx->latency, ctx->rtsp.aeskey, ctx->rtsp.aesiv,
  445. ctx->rtsp.fmtp, cport, tport, ctx->cmd_cb, ctx->data_cb);
  446. ctx->rtp = rtp.ctx;
  447. if ( (cport * tport * rtp.cport * rtp.tport * rtp.aport) != 0 && rtp.ctx) {
  448. char *transport;
  449. asprintf(&transport, "RTP/AVP/UDP;unicast;mode=record;control_port=%u;timing_port=%u;server_port=%u", rtp.cport, rtp.tport, rtp.aport);
  450. LOG_DEBUG("[%p]: audio=(%hu:%hu), timing=(%hu:%hu), control=(%hu:%hu)", ctx, 0, rtp.aport, tport, rtp.tport, cport, rtp.cport);
  451. kd_add(resp, "Transport", transport);
  452. kd_add(resp, "Session", "DEADBEEF");
  453. free(transport);
  454. } else {
  455. success = false;
  456. LOG_INFO("[%p]: cannot start session, missing ports", ctx);
  457. }
  458. } else if (!strcmp(method, "RECORD")) {
  459. unsigned short seqno = 0;
  460. unsigned rtptime = 0;
  461. char *p;
  462. if (ctx->latency) {
  463. char latency[6];
  464. snprintf(latency, 6, "%u", ctx->latency);
  465. kd_add(resp, "Audio-Latency", latency);
  466. }
  467. buf = kd_lookup(headers, "RTP-Info");
  468. if (buf && (p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
  469. if (buf && (p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
  470. if (ctx->rtp) rtp_record(ctx->rtp, seqno, rtptime);
  471. success = ctx->cmd_cb(RAOP_STREAM);
  472. } else if (!strcmp(method, "FLUSH")) {
  473. unsigned short seqno = 0;
  474. unsigned rtptime = 0;
  475. char *p;
  476. buf = kd_lookup(headers, "RTP-Info");
  477. if ((p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
  478. if ((p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
  479. // only send FLUSH if useful (discards frames above buffer head and top)
  480. if (ctx->rtp && rtp_flush(ctx->rtp, seqno, rtptime, true)) {
  481. success = ctx->cmd_cb(RAOP_FLUSH);
  482. rtp_flush_release(ctx->rtp);
  483. }
  484. } else if (!strcmp(method, "TEARDOWN")) {
  485. cleanup_rtsp(ctx, false);
  486. success = ctx->cmd_cb(RAOP_STOP);
  487. } else if (!strcmp(method, "SET_PARAMETER")) {
  488. char *p;
  489. if (body && (p = strcasestr(body, "volume")) != NULL) {
  490. float volume;
  491. sscanf(p, "%*[^:]:%f", &volume);
  492. LOG_INFO("[%p]: SET PARAMETER volume %f", ctx, volume);
  493. volume = (volume == -144.0) ? 0 : (1 + volume / 30);
  494. success = ctx->cmd_cb(RAOP_VOLUME, volume);
  495. } else if (body && (p = strcasestr(body, "progress")) != NULL) {
  496. int start, current, stop = 0;
  497. // we want ms, not s
  498. sscanf(p, "%*[^:]:%u/%u/%u", &start, &current, &stop);
  499. current = ((current - start) / 44100) * 1000;
  500. if (stop) stop = ((stop - start) / 44100) * 1000;
  501. else stop = -1;
  502. LOG_INFO("[%p]: SET PARAMETER progress %d/%u %s", ctx, current, stop, p);
  503. success = ctx->cmd_cb(RAOP_PROGRESS, max(current, 0), stop);
  504. } else if (body && ((p = kd_lookup(headers, "Content-Type")) != NULL) && !strcasecmp(p, "application/x-dmap-tagged")) {
  505. struct metadata_s metadata;
  506. dmap_settings settings = {
  507. NULL, NULL, NULL, NULL, NULL, NULL, NULL, on_dmap_string, NULL,
  508. NULL
  509. };
  510. LOG_INFO("[%p]: received metadata", ctx);
  511. settings.ctx = &metadata;
  512. memset(&metadata, 0, sizeof(struct metadata_s));
  513. if (!dmap_parse(&settings, body, len)) {
  514. LOG_INFO("[%p]: received metadata\n\tartist: %s\n\talbum: %s\n\ttitle: %s",
  515. ctx, metadata.artist, metadata.album, metadata.title);
  516. success = ctx->cmd_cb(RAOP_METADATA, metadata.artist, metadata.album, metadata.title);
  517. free_metadata(&metadata);
  518. }
  519. } else {
  520. char *dump = kd_dump(headers);
  521. LOG_INFO("Unhandled SET PARAMETER\n%s", dump);
  522. free(dump);
  523. }
  524. }
  525. // don't need to free "buf" because kd_lookup return a pointer, not a strdup
  526. kd_add(resp, "Audio-Jack-Status", "connected; type=analog");
  527. kd_add(resp, "CSeq", kd_lookup(headers, "CSeq"));
  528. if (success) {
  529. buf = http_send(sock, "RTSP/1.0 200 OK", resp);
  530. } else {
  531. buf = http_send(sock, "RTSP/1.0 503 ERROR", NULL);
  532. closesocket(sock);
  533. }
  534. if (strcmp(method, "OPTIONS")) {
  535. LOG_INFO("[%p]: responding:\n%s", ctx, buf ? buf : "<void>");
  536. }
  537. NFREE(body);
  538. NFREE(buf);
  539. kd_free(resp);
  540. kd_free(headers);
  541. return true;
  542. }
  543. /*----------------------------------------------------------------------------*/
  544. void cleanup_rtsp(raop_ctx_t *ctx, bool abort) {
  545. // first stop RTP process
  546. if (ctx->rtp) {
  547. rtp_end(ctx->rtp);
  548. ctx->rtp = NULL;
  549. if (abort) LOG_INFO("[%p]: RTP thread aborted", ctx);
  550. }
  551. if (ctx->active_remote.running) {
  552. #ifdef WIN32
  553. pthread_join(ctx->active_remote.thread, NULL);
  554. close_mDNS(ctx->active_remote.handle);
  555. #else
  556. // need to make sure no search is on-going and reclaim task memory
  557. ctx->active_remote.running = false;
  558. xSemaphoreTake(ctx->active_remote.destroy_mutex, portMAX_DELAY);
  559. vTaskDelete(ctx->active_remote.thread);
  560. vSemaphoreDelete(ctx->active_remote.thread);
  561. heap_caps_free(ctx->active_remote.xTaskBuffer);
  562. #endif
  563. memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
  564. LOG_INFO("[%p]: Remote search thread aborted", ctx);
  565. }
  566. NFREE(ctx->rtsp.aeskey);
  567. NFREE(ctx->rtsp.aesiv);
  568. NFREE(ctx->rtsp.fmtp);
  569. }
  570. /*----------------------------------------------------------------------------*/
  571. #ifdef WIN32
  572. bool search_remote_cb(mDNSservice_t *slist, void *cookie, bool *stop) {
  573. mDNSservice_t *s;
  574. raop_ctx_t *ctx = (raop_ctx_t*) cookie;
  575. // see if we have found an active remote for our ID
  576. for (s = slist; s; s = s->next) {
  577. if (strcasestr(s->name, ctx->active_remote.DACPid)) {
  578. ctx->active_remote.host = s->addr;
  579. ctx->active_remote.port = s->port;
  580. LOG_INFO("[%p]: found ActiveRemote for %s at %s:%u", ctx, ctx->active_remote.DACPid,
  581. inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
  582. *stop = true;
  583. break;
  584. }
  585. }
  586. // let caller clear list
  587. return false;
  588. }
  589. /*----------------------------------------------------------------------------*/
  590. static void* search_remote(void *args) {
  591. raop_ctx_t *ctx = (raop_ctx_t*) args;
  592. query_mDNS(ctx->active_remote.handle, "_dacp._tcp.local", 0, 0, &search_remote_cb, (void*) ctx);
  593. return NULL;
  594. }
  595. #else
  596. /*----------------------------------------------------------------------------*/
  597. static void* search_remote(void *args) {
  598. raop_ctx_t *ctx = (raop_ctx_t*) args;
  599. bool found = false;
  600. LOG_INFO("starting remote search");
  601. while (ctx->active_remote.running && !found) {
  602. mdns_result_t *results = NULL;
  603. mdns_result_t *r;
  604. mdns_ip_addr_t *a;
  605. if (mdns_query_ptr("_dacp", "_tcp", 3000, 32, &results)) {
  606. LOG_ERROR("mDNS active remote query Failed");
  607. continue;
  608. }
  609. for (r = results; r && !strcasestr(r->instance_name, ctx->active_remote.DACPid); r = r->next);
  610. if (r) {
  611. for (a = r->addr; a && a->addr.type != IPADDR_TYPE_V4; a = a->next);
  612. if (a) {
  613. found = true;
  614. ctx->active_remote.host.s_addr = a->addr.u_addr.ip4.addr;
  615. ctx->active_remote.port = r->port;
  616. LOG_INFO("found remote %s %s:%hu", r->instance_name, inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
  617. }
  618. }
  619. mdns_query_results_free(results);
  620. }
  621. // can't use xNotifyGive as it seems LWIP is using it as well
  622. xSemaphoreGive(ctx->active_remote.destroy_mutex);
  623. vTaskSuspend(NULL);
  624. return NULL;
  625. }
  626. #endif
  627. /*----------------------------------------------------------------------------*/
  628. static char *rsa_apply(unsigned char *input, int inlen, int *outlen, int mode)
  629. {
  630. static char super_secret_key[] =
  631. "-----BEGIN RSA PRIVATE KEY-----\n"
  632. "MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt\n"
  633. "wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U\n"
  634. "wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf\n"
  635. "/+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/\n"
  636. "UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW\n"
  637. "BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa\n"
  638. "LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5\n"
  639. "NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm\n"
  640. "lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz\n"
  641. "aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu\n"
  642. "a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM\n"
  643. "oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z\n"
  644. "oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+\n"
  645. "k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL\n"
  646. "AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA\n"
  647. "cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf\n"
  648. "54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov\n"
  649. "17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc\n"
  650. "1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI\n"
  651. "LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ\n"
  652. "2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKY=\n"
  653. "-----END RSA PRIVATE KEY-----";
  654. #ifdef WIN32
  655. unsigned char *out;
  656. RSA *rsa;
  657. BIO *bmem = BIO_new_mem_buf(super_secret_key, -1);
  658. rsa = PEM_read_bio_RSAPrivateKey(bmem, NULL, NULL, NULL);
  659. BIO_free(bmem);
  660. out = malloc(RSA_size(rsa));
  661. switch (mode) {
  662. case RSA_MODE_AUTH:
  663. *outlen = RSA_private_encrypt(inlen, input, out, rsa,
  664. RSA_PKCS1_PADDING);
  665. break;
  666. case RSA_MODE_KEY:
  667. *outlen = RSA_private_decrypt(inlen, input, out, rsa,
  668. RSA_PKCS1_OAEP_PADDING);
  669. break;
  670. }
  671. RSA_free(rsa);
  672. return (char*) out;
  673. #else
  674. mbedtls_pk_context pkctx;
  675. mbedtls_rsa_context *trsa;
  676. size_t olen;
  677. /*
  678. we should do entropy initialization & pass a rng function but this
  679. consumes a ton of stack and there is no security concern here. Anyway,
  680. mbedtls takes a lot of stack, unfortunately ...
  681. */
  682. mbedtls_pk_init(&pkctx);
  683. mbedtls_pk_parse_key(&pkctx, (unsigned char *)super_secret_key,
  684. sizeof(super_secret_key), NULL, 0);
  685. uint8_t *outbuf = NULL;
  686. trsa = mbedtls_pk_rsa(pkctx);
  687. switch (mode) {
  688. case RSA_MODE_AUTH:
  689. mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE);
  690. outbuf = malloc(trsa->len);
  691. mbedtls_rsa_pkcs1_encrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, inlen, input, outbuf);
  692. *outlen = trsa->len;
  693. break;
  694. case RSA_MODE_KEY:
  695. mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
  696. outbuf = malloc(trsa->len);
  697. mbedtls_rsa_pkcs1_decrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, &olen, input, outbuf, trsa->len);
  698. *outlen = olen;
  699. break;
  700. }
  701. mbedtls_pk_free(&pkctx);
  702. return (char*) outbuf;
  703. #endif
  704. }
  705. #define DECODE_ERROR 0xffffffff
  706. static char base64_chars[] =
  707. "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  708. /*----------------------------------------------------------------------------*/
  709. static int base64_pad(char *src, char **padded)
  710. {
  711. int n;
  712. n = strlen(src) + strlen(src) % 4;
  713. *padded = malloc(n + 1);
  714. memset(*padded, '=', n);
  715. memcpy(*padded, src, strlen(src));
  716. (*padded)[n] = '\0';
  717. return strlen(*padded);
  718. }
  719. /*----------------------------------------------------------------------------*/
  720. static int pos(char c)
  721. {
  722. char *p;
  723. for (p = base64_chars; *p; p++)
  724. if (*p == c)
  725. return p - base64_chars;
  726. return -1;
  727. }
  728. /*----------------------------------------------------------------------------*/
  729. static int base64_encode(const void *data, int size, char **str)
  730. {
  731. char *s, *p;
  732. int i;
  733. int c;
  734. const unsigned char *q;
  735. p = s = (char *) malloc(size * 4 / 3 + 4);
  736. if (p == NULL) return -1;
  737. q = (const unsigned char *) data;
  738. i = 0;
  739. for (i = 0; i < size;) {
  740. c = q[i++];
  741. c *= 256;
  742. if (i < size) c += q[i];
  743. i++;
  744. c *= 256;
  745. if (i < size) c += q[i];
  746. i++;
  747. p[0] = base64_chars[(c & 0x00fc0000) >> 18];
  748. p[1] = base64_chars[(c & 0x0003f000) >> 12];
  749. p[2] = base64_chars[(c & 0x00000fc0) >> 6];
  750. p[3] = base64_chars[(c & 0x0000003f) >> 0];
  751. if (i > size) p[3] = '=';
  752. if (i > size + 1) p[2] = '=';
  753. p += 4;
  754. }
  755. *p = 0;
  756. *str = s;
  757. return strlen(s);
  758. }
  759. /*----------------------------------------------------------------------------*/
  760. static unsigned int token_decode(const char *token)
  761. {
  762. int i;
  763. unsigned int val = 0;
  764. int marker = 0;
  765. if (strlen(token) < 4)
  766. return DECODE_ERROR;
  767. for (i = 0; i < 4; i++) {
  768. val *= 64;
  769. if (token[i] == '=')
  770. marker++;
  771. else if (marker > 0)
  772. return DECODE_ERROR;
  773. else
  774. val += pos(token[i]);
  775. }
  776. if (marker > 2)
  777. return DECODE_ERROR;
  778. return (marker << 24) | val;
  779. }
  780. /*----------------------------------------------------------------------------*/
  781. static int base64_decode(const char *str, void *data)
  782. {
  783. const char *p;
  784. unsigned char *q;
  785. q = data;
  786. for (p = str; *p && (*p == '=' || strchr(base64_chars, *p)); p += 4) {
  787. unsigned int val = token_decode(p);
  788. unsigned int marker = (val >> 24) & 0xff;
  789. if (val == DECODE_ERROR)
  790. return -1;
  791. *q++ = (val >> 16) & 0xff;
  792. if (marker < 2)
  793. *q++ = (val >> 8) & 0xff;
  794. if (marker < 1)
  795. *q++ = val & 0xff;
  796. }
  797. return q - (unsigned char *) data;
  798. }
  799. /*----------------------------------------------------------------------------*/
  800. static void on_dmap_string(void *ctx, const char *code, const char *name, const char *buf, size_t len) {
  801. struct metadata_s *metadata = (struct metadata_s *) ctx;
  802. if (!strcasecmp(code, "asar")) metadata->artist = strndup(buf, len);
  803. else if (!strcasecmp(code, "asal")) metadata->album = strndup(buf, len);
  804. else if (!strcasecmp(code, "minm")) metadata->title = strndup(buf, len);
  805. }