2
0

raop.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993
  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 (2*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, joiner;
  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 abort_rtsp(raop_ctx_t *ctx);
  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. // first stop the search task if any
  221. if (ctx->active_remote.running) {
  222. ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
  223. ctx->active_remote.running = false;
  224. vTaskResume(ctx->active_remote.thread);
  225. ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
  226. vTaskDelete(ctx->active_remote.thread);
  227. heap_caps_free(ctx->active_remote.xTaskBuffer);
  228. }
  229. // then the RTSP task
  230. ctx->joiner = xTaskGetCurrentTaskHandle();
  231. ctx->running = false;
  232. ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
  233. vTaskDelete(ctx->thread);
  234. heap_caps_free(ctx->xTaskBuffer);
  235. rtp_end(ctx->rtp);
  236. shutdown(ctx->sock, SHUT_RDWR);
  237. closesocket(ctx->sock);
  238. mdns_service_remove("_raop", "_tcp");
  239. #endif
  240. NFREE(ctx->rtsp.aeskey);
  241. NFREE(ctx->rtsp.aesiv);
  242. NFREE(ctx->rtsp.fmtp);
  243. free(ctx);
  244. }
  245. /*----------------------------------------------------------------------------*/
  246. bool raop_cmd(struct raop_ctx_s *ctx, raop_event_t event, void *param) {
  247. struct sockaddr_in addr;
  248. int sock;
  249. char *command = NULL;
  250. // first notify the remote controller (if any)
  251. switch(event) {
  252. case RAOP_REW:
  253. command = strdup("beginrew");
  254. break;
  255. case RAOP_FWD:
  256. command = strdup("beginff");
  257. break;
  258. case RAOP_PREV:
  259. command = strdup("previtem");
  260. break;
  261. case RAOP_NEXT:
  262. command = strdup("nextitem");
  263. break;
  264. case RAOP_TOGGLE:
  265. command = strdup("playpause");
  266. break;
  267. case RAOP_PAUSE:
  268. command = strdup("pause");
  269. break;
  270. case RAOP_PLAY:
  271. command = strdup("play");
  272. break;
  273. case RAOP_RESUME:
  274. command = strdup("playresume");
  275. break;
  276. case RAOP_STOP:
  277. command = strdup("stop");
  278. break;
  279. case RAOP_VOLUME_UP:
  280. command = strdup("volumeup");
  281. break;
  282. case RAOP_VOLUME_DOWN:
  283. command = strdup("volumedown");
  284. break;
  285. case RAOP_VOLUME: {
  286. float Volume = *((float*) param);
  287. Volume = Volume ? (Volume - 1) * 30 : -144;
  288. asprintf(&command,"setproperty?dmcp.device-volume=%0.4lf", Volume);
  289. break;
  290. }
  291. default:
  292. break;
  293. }
  294. // no command to send to remote or no remote found yet
  295. if (!command || !ctx->active_remote.port) {
  296. NFREE(command);
  297. return false;
  298. }
  299. sock = socket(AF_INET, SOCK_STREAM, 0);
  300. memset(&addr, 0, sizeof(addr));
  301. addr.sin_family = AF_INET;
  302. addr.sin_addr.s_addr = S_ADDR(ctx->active_remote.host);
  303. addr.sin_port = htons(ctx->active_remote.port);
  304. if (!connect(sock, (struct sockaddr*) &addr, sizeof(addr))) {
  305. char *method, *buf, resp[512] = "";
  306. int len;
  307. key_data_t headers[4] = { {NULL, NULL} };
  308. asprintf(&method, "GET /ctrl-int/1/%s HTTP/1.0", command);
  309. kd_add(headers, "Active-Remote", ctx->active_remote.id);
  310. kd_add(headers, "Connection", "close");
  311. buf = http_send(sock, method, headers);
  312. len = recv(sock, resp, 512, 0);
  313. if (len > 0) resp[len-1] = '\0';
  314. LOG_INFO("[%p]: sending airplay remote\n%s<== received ==>\n%s", ctx, buf, resp);
  315. NFREE(method);
  316. NFREE(buf);
  317. kd_free(headers);
  318. }
  319. free(command);
  320. closesocket(sock);
  321. return true;
  322. }
  323. /*----------------------------------------------------------------------------*/
  324. static void *rtsp_thread(void *arg) {
  325. raop_ctx_t *ctx = (raop_ctx_t*) arg;
  326. int sock = -1;
  327. while (ctx->running) {
  328. fd_set rfds;
  329. struct timeval timeout = {0, 100*1000};
  330. int n;
  331. bool res = false;
  332. if (sock == -1) {
  333. struct sockaddr_in peer;
  334. socklen_t addrlen = sizeof(struct sockaddr_in);
  335. sock = accept(ctx->sock, (struct sockaddr*) &peer, &addrlen);
  336. ctx->peer.s_addr = peer.sin_addr.s_addr;
  337. ctx->abort = false;
  338. if (sock != -1 && ctx->running) {
  339. LOG_INFO("got RTSP connection %u", sock);
  340. } else continue;
  341. }
  342. FD_ZERO(&rfds);
  343. FD_SET(sock, &rfds);
  344. n = select(sock + 1, &rfds, NULL, NULL, &timeout);
  345. if (!n && !ctx->abort) continue;
  346. if (n > 0) res = handle_rtsp(ctx, sock);
  347. if (n < 0 || !res || ctx->abort) {
  348. abort_rtsp(ctx);
  349. closesocket(sock);
  350. LOG_INFO("RTSP close %u", sock);
  351. sock = -1;
  352. }
  353. }
  354. if (sock != -1) closesocket(sock);
  355. #ifndef WIN32
  356. xTaskNotifyGive(ctx->joiner);
  357. vTaskSuspend(NULL);
  358. #endif
  359. return NULL;
  360. }
  361. /*----------------------------------------------------------------------------*/
  362. static bool handle_rtsp(raop_ctx_t *ctx, int sock)
  363. {
  364. char *buf = NULL, *body = NULL, method[16] = "";
  365. key_data_t headers[16], resp[8] = { {NULL, NULL} };
  366. int len;
  367. bool success = true;
  368. if (!http_parse(sock, method, headers, &body, &len)) {
  369. NFREE(body);
  370. kd_free(headers);
  371. return false;
  372. }
  373. if (strcmp(method, "OPTIONS")) {
  374. LOG_INFO("[%p]: received %s", ctx, method);
  375. }
  376. if ((buf = kd_lookup(headers, "Apple-Challenge")) != NULL) {
  377. int n;
  378. char *buf_pad, *p, *data_b64 = NULL, data[32];
  379. LOG_INFO("[%p]: challenge %s", ctx, buf);
  380. // need to pad the base64 string as apple device don't
  381. base64_pad(buf, &buf_pad);
  382. p = data + min(base64_decode(buf_pad, data), 32-10);
  383. p = (char*) memcpy(p, &S_ADDR(ctx->host), 4) + 4;
  384. p = (char*) memcpy(p, ctx->mac, 6) + 6;
  385. memset(p, 0, 32 - (p - data));
  386. p = rsa_apply((unsigned char*) data, 32, &n, RSA_MODE_AUTH);
  387. n = base64_encode(p, n, &data_b64);
  388. // remove padding as well (seems to be optional now)
  389. for (n = strlen(data_b64) - 1; n > 0 && data_b64[n] == '='; data_b64[n--] = '\0');
  390. kd_add(resp, "Apple-Response", data_b64);
  391. NFREE(p);
  392. NFREE(buf_pad);
  393. NFREE(data_b64);
  394. }
  395. if (!strcmp(method, "OPTIONS")) {
  396. kd_add(resp, "Public", "ANNOUNCE, SETUP, RECORD, PAUSE, FLUSH, TEARDOWN, OPTIONS, GET_PARAMETER, SET_PARAMETER");
  397. } else if (!strcmp(method, "ANNOUNCE")) {
  398. char *padded, *p;
  399. NFREE(ctx->rtsp.aeskey);
  400. NFREE(ctx->rtsp.aesiv);
  401. NFREE(ctx->rtsp.fmtp);
  402. if ((p = strcasestr(body, "rsaaeskey")) != NULL) {
  403. unsigned char *aeskey;
  404. int len, outlen;
  405. p = strextract(p, ":", "\r\n");
  406. base64_pad(p, &padded);
  407. aeskey = malloc(strlen(padded));
  408. len = base64_decode(padded, aeskey);
  409. ctx->rtsp.aeskey = rsa_apply(aeskey, len, &outlen, RSA_MODE_KEY);
  410. NFREE(p);
  411. NFREE(aeskey);
  412. NFREE(padded);
  413. }
  414. if ((p = strcasestr(body, "aesiv")) != NULL) {
  415. p = strextract(p, ":", "\r\n");
  416. base64_pad(p, &padded);
  417. ctx->rtsp.aesiv = malloc(strlen(padded));
  418. base64_decode(padded, ctx->rtsp.aesiv);
  419. NFREE(p);
  420. NFREE(padded);
  421. }
  422. if ((p = strcasestr(body, "fmtp")) != NULL) {
  423. p = strextract(p, ":", "\r\n");
  424. ctx->rtsp.fmtp = strdup(p);
  425. NFREE(p);
  426. }
  427. // on announce, search remote
  428. if ((buf = kd_lookup(headers, "DACP-ID")) != NULL) strcpy(ctx->active_remote.DACPid, buf);
  429. if ((buf = kd_lookup(headers, "Active-Remote")) != NULL) strcpy(ctx->active_remote.id, buf);
  430. #ifdef WIN32
  431. ctx->active_remote.handle = init_mDNS(false, ctx->host);
  432. pthread_create(&ctx->active_remote.thread, NULL, &search_remote, ctx);
  433. #else
  434. ctx->active_remote.running = true;
  435. ctx->active_remote.destroy_mutex = xSemaphoreCreateMutex();
  436. ctx->active_remote.xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  437. 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);
  438. #endif
  439. } else if (!strcmp(method, "SETUP") && ((buf = kd_lookup(headers, "Transport")) != NULL)) {
  440. char *p;
  441. rtp_resp_t rtp = { 0 };
  442. short unsigned tport = 0, cport = 0;
  443. // we are about to stream, do something if needed
  444. success = ctx->cmd_cb(RAOP_SETUP);
  445. if ((p = strcasestr(buf, "timing_port")) != NULL) sscanf(p, "%*[^=]=%hu", &tport);
  446. if ((p = strcasestr(buf, "control_port")) != NULL) sscanf(p, "%*[^=]=%hu", &cport);
  447. rtp = rtp_init(ctx->peer, ctx->latency, ctx->rtsp.aeskey, ctx->rtsp.aesiv,
  448. ctx->rtsp.fmtp, cport, tport, ctx->cmd_cb, ctx->data_cb);
  449. ctx->rtp = rtp.ctx;
  450. if ( (cport * tport * rtp.cport * rtp.tport * rtp.aport) != 0 && rtp.ctx) {
  451. char *transport;
  452. asprintf(&transport, "RTP/AVP/UDP;unicast;mode=record;control_port=%u;timing_port=%u;server_port=%u", rtp.cport, rtp.tport, rtp.aport);
  453. LOG_DEBUG("[%p]: audio=(%hu:%hu), timing=(%hu:%hu), control=(%hu:%hu)", ctx, 0, rtp.aport, tport, rtp.tport, cport, rtp.cport);
  454. kd_add(resp, "Transport", transport);
  455. kd_add(resp, "Session", "DEADBEEF");
  456. free(transport);
  457. } else {
  458. success = false;
  459. LOG_INFO("[%p]: cannot start session, missing ports", ctx);
  460. }
  461. } else if (!strcmp(method, "RECORD")) {
  462. unsigned short seqno = 0;
  463. unsigned rtptime = 0;
  464. char *p;
  465. if (ctx->latency) {
  466. char latency[6];
  467. snprintf(latency, 6, "%u", ctx->latency);
  468. kd_add(resp, "Audio-Latency", latency);
  469. }
  470. buf = kd_lookup(headers, "RTP-Info");
  471. if (buf && (p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
  472. if (buf && (p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
  473. if (ctx->rtp) rtp_record(ctx->rtp, seqno, rtptime);
  474. success = ctx->cmd_cb(RAOP_STREAM);
  475. } else if (!strcmp(method, "FLUSH")) {
  476. unsigned short seqno = 0;
  477. unsigned rtptime = 0;
  478. char *p;
  479. buf = kd_lookup(headers, "RTP-Info");
  480. if ((p = strcasestr(buf, "seq")) != NULL) sscanf(p, "%*[^=]=%hu", &seqno);
  481. if ((p = strcasestr(buf, "rtptime")) != NULL) sscanf(p, "%*[^=]=%u", &rtptime);
  482. // only send FLUSH if useful (discards frames above buffer head and top)
  483. if (ctx->rtp && rtp_flush(ctx->rtp, seqno, rtptime))
  484. success = ctx->cmd_cb(RAOP_FLUSH);
  485. } else if (!strcmp(method, "TEARDOWN")) {
  486. rtp_end(ctx->rtp);
  487. ctx->rtp = NULL;
  488. // need to make sure no search is on-going and reclaim pthread memory
  489. #ifdef WIN32
  490. if (ctx->active_remote.handle) close_mDNS(ctx->active_remote.handle);
  491. pthread_join(ctx->active_remote.thread, NULL);
  492. #else
  493. ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
  494. ctx->active_remote.running = false;
  495. xSemaphoreTake(ctx->active_remote.destroy_mutex, portMAX_DELAY);
  496. vTaskDelete(ctx->active_remote.thread);
  497. vSemaphoreDelete(ctx->active_remote.thread);
  498. heap_caps_free(ctx->active_remote.xTaskBuffer);
  499. LOG_INFO("[%p]: mDNS search task terminated", ctx);
  500. #endif
  501. memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
  502. NFREE(ctx->rtsp.aeskey);
  503. NFREE(ctx->rtsp.aesiv);
  504. NFREE(ctx->rtsp.fmtp);
  505. success = ctx->cmd_cb(RAOP_STOP);
  506. } else if (!strcmp(method, "SET_PARAMETER")) {
  507. char *p;
  508. if (body && (p = strcasestr(body, "volume")) != NULL) {
  509. float volume;
  510. sscanf(p, "%*[^:]:%f", &volume);
  511. LOG_INFO("[%p]: SET PARAMETER volume %f", ctx, volume);
  512. volume = (volume == -144.0) ? 0 : (1 + volume / 30);
  513. success = ctx->cmd_cb(RAOP_VOLUME, volume);
  514. } else if (body && (p = strcasestr(body, "progress")) != NULL) {
  515. int start, current, stop = 0;
  516. // we want ms, not s
  517. sscanf(p, "%*[^:]:%u/%u/%u", &start, &current, &stop);
  518. current = ((current - start) / 44100) * 1000;
  519. if (stop) stop = ((stop - start) / 44100) * 1000;
  520. else stop = -1;
  521. LOG_INFO("[%p]: SET PARAMETER progress %d/%u %s", ctx, current, stop, p);
  522. success = ctx->cmd_cb(RAOP_PROGRESS, max(current, 0), stop);
  523. } else if (body && ((p = kd_lookup(headers, "Content-Type")) != NULL) && !strcasecmp(p, "application/x-dmap-tagged")) {
  524. struct metadata_s metadata;
  525. dmap_settings settings = {
  526. NULL, NULL, NULL, NULL, NULL, NULL, NULL, on_dmap_string, NULL,
  527. NULL
  528. };
  529. LOG_INFO("[%p]: received metadata", ctx);
  530. settings.ctx = &metadata;
  531. memset(&metadata, 0, sizeof(struct metadata_s));
  532. if (!dmap_parse(&settings, body, len)) {
  533. LOG_INFO("[%p]: received metadata\n\tartist: %s\n\talbum: %s\n\ttitle: %s",
  534. ctx, metadata.artist, metadata.album, metadata.title);
  535. success = ctx->cmd_cb(RAOP_METADATA, metadata.artist, metadata.album, metadata.title);
  536. free_metadata(&metadata);
  537. }
  538. } else {
  539. char *dump = kd_dump(headers);
  540. LOG_INFO("Unhandled SET PARAMETER\n%s", dump);
  541. free(dump);
  542. }
  543. }
  544. // don't need to free "buf" because kd_lookup return a pointer, not a strdup
  545. kd_add(resp, "Audio-Jack-Status", "connected; type=analog");
  546. kd_add(resp, "CSeq", kd_lookup(headers, "CSeq"));
  547. if (success) {
  548. buf = http_send(sock, "RTSP/1.0 200 OK", resp);
  549. } else {
  550. buf = http_send(sock, "RTSP/1.0 503 ERROR", NULL);
  551. closesocket(sock);
  552. }
  553. if (strcmp(method, "OPTIONS")) {
  554. LOG_INFO("[%p]: responding:\n%s", ctx, buf ? buf : "<void>");
  555. }
  556. NFREE(body);
  557. NFREE(buf);
  558. kd_free(resp);
  559. kd_free(headers);
  560. return true;
  561. }
  562. /*----------------------------------------------------------------------------*/
  563. void abort_rtsp(raop_ctx_t *ctx) {
  564. // first stop RTP process
  565. if (ctx->rtp) {
  566. rtp_end(ctx->rtp);
  567. ctx->rtp = NULL;
  568. LOG_INFO("[%p]: RTP thread aborted", ctx);
  569. }
  570. if (ctx->active_remote.running) {
  571. #ifdef WIN32
  572. pthread_join(ctx->active_remote.thread, NULL);
  573. close_mDNS(ctx->active_remote.handle);
  574. #else
  575. // need to make sure no search is on-going and reclaim task memory
  576. ctx->active_remote.joiner = xTaskGetCurrentTaskHandle();
  577. ctx->active_remote.running = false;
  578. xSemaphoreTake(ctx->active_remote.destroy_mutex, portMAX_DELAY);
  579. vTaskDelete(ctx->active_remote.thread);
  580. vSemaphoreDelete(ctx->active_remote.thread);
  581. heap_caps_free(ctx->active_remote.xTaskBuffer);
  582. #endif
  583. memset(&ctx->active_remote, 0, sizeof(ctx->active_remote));
  584. LOG_INFO("[%p]: Remote search thread aborted", ctx);
  585. }
  586. NFREE(ctx->rtsp.aeskey);
  587. NFREE(ctx->rtsp.aesiv);
  588. NFREE(ctx->rtsp.fmtp);
  589. }
  590. /*----------------------------------------------------------------------------*/
  591. #ifdef WIN32
  592. bool search_remote_cb(mDNSservice_t *slist, void *cookie, bool *stop) {
  593. mDNSservice_t *s;
  594. raop_ctx_t *ctx = (raop_ctx_t*) cookie;
  595. // see if we have found an active remote for our ID
  596. for (s = slist; s; s = s->next) {
  597. if (strcasestr(s->name, ctx->active_remote.DACPid)) {
  598. ctx->active_remote.host = s->addr;
  599. ctx->active_remote.port = s->port;
  600. LOG_INFO("[%p]: found ActiveRemote for %s at %s:%u", ctx, ctx->active_remote.DACPid,
  601. inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
  602. *stop = true;
  603. break;
  604. }
  605. }
  606. // let caller clear list
  607. return false;
  608. }
  609. /*----------------------------------------------------------------------------*/
  610. static void* search_remote(void *args) {
  611. raop_ctx_t *ctx = (raop_ctx_t*) args;
  612. query_mDNS(ctx->active_remote.handle, "_dacp._tcp.local", 0, 0, &search_remote_cb, (void*) ctx);
  613. return NULL;
  614. }
  615. #else
  616. /*----------------------------------------------------------------------------*/
  617. static void* search_remote(void *args) {
  618. raop_ctx_t *ctx = (raop_ctx_t*) args;
  619. bool found = false;
  620. LOG_INFO("starting remote search");
  621. while (ctx->active_remote.running && !found) {
  622. mdns_result_t *results = NULL;
  623. mdns_result_t *r;
  624. mdns_ip_addr_t *a;
  625. if (mdns_query_ptr("_dacp", "_tcp", 3000, 32, &results)) {
  626. LOG_ERROR("mDNS active remote query Failed");
  627. continue;
  628. }
  629. for (r = results; r && !strcasestr(r->instance_name, ctx->active_remote.DACPid); r = r->next);
  630. if (r) {
  631. for (a = r->addr; a && a->addr.type != IPADDR_TYPE_V4; a = a->next);
  632. if (a) {
  633. found = true;
  634. ctx->active_remote.host.s_addr = a->addr.u_addr.ip4.addr;
  635. ctx->active_remote.port = r->port;
  636. LOG_INFO("found remote %s %s:%hu", r->instance_name, inet_ntoa(ctx->active_remote.host), ctx->active_remote.port);
  637. }
  638. }
  639. mdns_query_results_free(results);
  640. }
  641. // can't use xNotifyGive as it seems LWIP is using it as well
  642. xSemaphoreGive(ctx->active_remote.destroy_mutex);
  643. vTaskSuspend(NULL);
  644. return NULL;
  645. }
  646. #endif
  647. /*----------------------------------------------------------------------------*/
  648. static char *rsa_apply(unsigned char *input, int inlen, int *outlen, int mode)
  649. {
  650. static char super_secret_key[] =
  651. "-----BEGIN RSA PRIVATE KEY-----\n"
  652. "MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt\n"
  653. "wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U\n"
  654. "wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf\n"
  655. "/+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/\n"
  656. "UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW\n"
  657. "BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa\n"
  658. "LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5\n"
  659. "NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm\n"
  660. "lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz\n"
  661. "aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu\n"
  662. "a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM\n"
  663. "oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z\n"
  664. "oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+\n"
  665. "k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL\n"
  666. "AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA\n"
  667. "cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf\n"
  668. "54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov\n"
  669. "17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc\n"
  670. "1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI\n"
  671. "LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ\n"
  672. "2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKY=\n"
  673. "-----END RSA PRIVATE KEY-----";
  674. #ifdef WIN32
  675. unsigned char *out;
  676. RSA *rsa;
  677. BIO *bmem = BIO_new_mem_buf(super_secret_key, -1);
  678. rsa = PEM_read_bio_RSAPrivateKey(bmem, NULL, NULL, NULL);
  679. BIO_free(bmem);
  680. out = malloc(RSA_size(rsa));
  681. switch (mode) {
  682. case RSA_MODE_AUTH:
  683. *outlen = RSA_private_encrypt(inlen, input, out, rsa,
  684. RSA_PKCS1_PADDING);
  685. break;
  686. case RSA_MODE_KEY:
  687. *outlen = RSA_private_decrypt(inlen, input, out, rsa,
  688. RSA_PKCS1_OAEP_PADDING);
  689. break;
  690. }
  691. RSA_free(rsa);
  692. return (char*) out;
  693. #else
  694. mbedtls_pk_context pkctx;
  695. mbedtls_rsa_context *trsa;
  696. size_t olen;
  697. /*
  698. we should do entropy initialization & pass a rng function but this
  699. consumes a ton of stack and there is no security concern here. Anyway,
  700. mbedtls takes a lot of stack, unfortunately ...
  701. */
  702. mbedtls_pk_init(&pkctx);
  703. mbedtls_pk_parse_key(&pkctx, (unsigned char *)super_secret_key,
  704. sizeof(super_secret_key), NULL, 0);
  705. uint8_t *outbuf = NULL;
  706. trsa = mbedtls_pk_rsa(pkctx);
  707. switch (mode) {
  708. case RSA_MODE_AUTH:
  709. mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE);
  710. outbuf = malloc(trsa->len);
  711. mbedtls_rsa_pkcs1_encrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, inlen, input, outbuf);
  712. *outlen = trsa->len;
  713. break;
  714. case RSA_MODE_KEY:
  715. mbedtls_rsa_set_padding(trsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
  716. outbuf = malloc(trsa->len);
  717. mbedtls_rsa_pkcs1_decrypt(trsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, &olen, input, outbuf, trsa->len);
  718. *outlen = olen;
  719. break;
  720. }
  721. mbedtls_pk_free(&pkctx);
  722. return (char*) outbuf;
  723. #endif
  724. }
  725. #define DECODE_ERROR 0xffffffff
  726. static char base64_chars[] =
  727. "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  728. /*----------------------------------------------------------------------------*/
  729. static int base64_pad(char *src, char **padded)
  730. {
  731. int n;
  732. n = strlen(src) + strlen(src) % 4;
  733. *padded = malloc(n + 1);
  734. memset(*padded, '=', n);
  735. memcpy(*padded, src, strlen(src));
  736. (*padded)[n] = '\0';
  737. return strlen(*padded);
  738. }
  739. /*----------------------------------------------------------------------------*/
  740. static int pos(char c)
  741. {
  742. char *p;
  743. for (p = base64_chars; *p; p++)
  744. if (*p == c)
  745. return p - base64_chars;
  746. return -1;
  747. }
  748. /*----------------------------------------------------------------------------*/
  749. static int base64_encode(const void *data, int size, char **str)
  750. {
  751. char *s, *p;
  752. int i;
  753. int c;
  754. const unsigned char *q;
  755. p = s = (char *) malloc(size * 4 / 3 + 4);
  756. if (p == NULL) return -1;
  757. q = (const unsigned char *) data;
  758. i = 0;
  759. for (i = 0; i < size;) {
  760. c = q[i++];
  761. c *= 256;
  762. if (i < size) c += q[i];
  763. i++;
  764. c *= 256;
  765. if (i < size) c += q[i];
  766. i++;
  767. p[0] = base64_chars[(c & 0x00fc0000) >> 18];
  768. p[1] = base64_chars[(c & 0x0003f000) >> 12];
  769. p[2] = base64_chars[(c & 0x00000fc0) >> 6];
  770. p[3] = base64_chars[(c & 0x0000003f) >> 0];
  771. if (i > size) p[3] = '=';
  772. if (i > size + 1) p[2] = '=';
  773. p += 4;
  774. }
  775. *p = 0;
  776. *str = s;
  777. return strlen(s);
  778. }
  779. /*----------------------------------------------------------------------------*/
  780. static unsigned int token_decode(const char *token)
  781. {
  782. int i;
  783. unsigned int val = 0;
  784. int marker = 0;
  785. if (strlen(token) < 4)
  786. return DECODE_ERROR;
  787. for (i = 0; i < 4; i++) {
  788. val *= 64;
  789. if (token[i] == '=')
  790. marker++;
  791. else if (marker > 0)
  792. return DECODE_ERROR;
  793. else
  794. val += pos(token[i]);
  795. }
  796. if (marker > 2)
  797. return DECODE_ERROR;
  798. return (marker << 24) | val;
  799. }
  800. /*----------------------------------------------------------------------------*/
  801. static int base64_decode(const char *str, void *data)
  802. {
  803. const char *p;
  804. unsigned char *q;
  805. q = data;
  806. for (p = str; *p && (*p == '=' || strchr(base64_chars, *p)); p += 4) {
  807. unsigned int val = token_decode(p);
  808. unsigned int marker = (val >> 24) & 0xff;
  809. if (val == DECODE_ERROR)
  810. return -1;
  811. *q++ = (val >> 16) & 0xff;
  812. if (marker < 2)
  813. *q++ = (val >> 8) & 0xff;
  814. if (marker < 1)
  815. *q++ = val & 0xff;
  816. }
  817. return q - (unsigned char *) data;
  818. }
  819. /*----------------------------------------------------------------------------*/
  820. static void on_dmap_string(void *ctx, const char *code, const char *name, const char *buf, size_t len) {
  821. struct metadata_s *metadata = (struct metadata_s *) ctx;
  822. if (!strcasecmp(code, "asar")) metadata->artist = strndup(buf, len);
  823. else if (!strcasecmp(code, "asal")) metadata->album = strndup(buf, len);
  824. else if (!strcasecmp(code, "minm")) metadata->title = strndup(buf, len);
  825. }