raop.c 28 KB

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