Update the python bindings to work with current version
[deb_shairplay.git] / src / lib / raop.c
1 /**
2 * Copyright (C) 2011-2012 Juho Vähä-Herttua
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 */
14
15 #include <stdlib.h>
16 #include <stdio.h>
17 #include <string.h>
18 #include <assert.h>
19
20 #include "raop.h"
21 #include "raop_rtp.h"
22 #include "rsakey.h"
23 #include "httpd.h"
24 #include "sdp.h"
25
26 #include "global.h"
27 #include "utils.h"
28 #include "netutils.h"
29 #include "logger.h"
30
31 /* Actually 345 bytes for 2048-bit key */
32 #define MAX_SIGNATURE_LEN 512
33
34 struct raop_s {
35 /* Callbacks for audio */
36 raop_callbacks_t callbacks;
37
38 /* Logger instance */
39 logger_t logger;
40
41 /* HTTP daemon and RSA key */
42 httpd_t *httpd;
43 rsakey_t *rsakey;
44
45 /* Hardware address information */
46 unsigned char hwaddr[MAX_HWADDR_LEN];
47 int hwaddrlen;
48 };
49
50 struct raop_conn_s {
51 raop_t *raop;
52 raop_rtp_t *raop_rtp;
53
54 unsigned char *local;
55 int locallen;
56
57 unsigned char *remote;
58 int remotelen;
59 };
60 typedef struct raop_conn_s raop_conn_t;
61
62 static void *
63 conn_init(void *opaque, unsigned char *local, int locallen, unsigned char *remote, int remotelen)
64 {
65 raop_conn_t *conn;
66
67 conn = calloc(1, sizeof(raop_conn_t));
68 if (!conn) {
69 return NULL;
70 }
71 conn->raop = opaque;
72 conn->raop_rtp = NULL;
73
74 if (locallen == 4) {
75 logger_log(&conn->raop->logger, LOGGER_INFO,
76 "Local: %d.%d.%d.%d\n",
77 local[0], local[1], local[2], local[3]);
78 } else if (locallen == 16) {
79 logger_log(&conn->raop->logger, LOGGER_INFO,
80 "Local: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
81 local[0], local[1], local[2], local[3], local[4], local[5], local[6], local[7],
82 local[8], local[9], local[10], local[11], local[12], local[13], local[14], local[15]);
83 }
84 if (remotelen == 4) {
85 logger_log(&conn->raop->logger, LOGGER_INFO,
86 "Remote: %d.%d.%d.%d\n",
87 remote[0], remote[1], remote[2], remote[3]);
88 } else if (remotelen == 16) {
89 logger_log(&conn->raop->logger, LOGGER_INFO,
90 "Remote: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
91 remote[0], remote[1], remote[2], remote[3], remote[4], remote[5], remote[6], remote[7],
92 remote[8], remote[9], remote[10], remote[11], remote[12], remote[13], remote[14], remote[15]);
93 }
94
95 conn->local = malloc(locallen);
96 assert(conn->local);
97 memcpy(conn->local, local, locallen);
98
99 conn->remote = malloc(remotelen);
100 assert(conn->remote);
101 memcpy(conn->remote, remote, remotelen);
102
103 conn->locallen = locallen;
104 conn->remotelen = remotelen;
105 return conn;
106 }
107
108 static void
109 conn_request(void *ptr, http_request_t *request, http_response_t **response)
110 {
111 raop_conn_t *conn = ptr;
112 raop_t *raop = conn->raop;
113
114 http_response_t *res;
115 const char *method;
116 const char *cseq;
117 const char *challenge;
118
119 method = http_request_get_method(request);
120 cseq = http_request_get_header(request, "CSeq");
121 if (!method || !cseq) {
122 return;
123 }
124
125 res = http_response_init("RTSP/1.0", 200, "OK");
126 http_response_add_header(res, "CSeq", cseq);
127 http_response_add_header(res, "Apple-Jack-Status", "connected; type=analog");
128
129 challenge = http_request_get_header(request, "Apple-Challenge");
130 if (challenge) {
131 char signature[MAX_SIGNATURE_LEN];
132
133 memset(signature, 0, sizeof(signature));
134 rsakey_sign(raop->rsakey, signature, sizeof(signature), challenge,
135 conn->local, conn->locallen, raop->hwaddr, raop->hwaddrlen);
136 http_response_add_header(res, "Apple-Response", signature);
137
138 logger_log(&conn->raop->logger, LOGGER_DEBUG, "Got challenge: %s\n", challenge);
139 logger_log(&conn->raop->logger, LOGGER_DEBUG, "Got response: %s\n", signature);
140 }
141 if (!strcmp(method, "OPTIONS")) {
142 http_response_add_header(res, "Public", "ANNOUNCE, SETUP, RECORD, PAUSE, FLUSH, TEARDOWN, OPTIONS, GET_PARAMETER, SET_PARAMETER");
143 } else if (!strcmp(method, "ANNOUNCE")) {
144 const char *data;
145 int datalen;
146
147 unsigned char aeskey[16];
148 unsigned char aesiv[16];
149 int aeskeylen, aesivlen;
150
151 data = http_request_get_data(request, &datalen);
152 if (data) {
153 sdp_t *sdp;
154 const char *remotestr, *fmtpstr, *aeskeystr, *aesivstr;
155
156 sdp = sdp_init(data, datalen);
157 remotestr = sdp_get_connection(sdp);
158 fmtpstr = sdp_get_fmtp(sdp);
159 aeskeystr = sdp_get_rsaaeskey(sdp);
160 aesivstr = sdp_get_aesiv(sdp);
161
162 logger_log(&conn->raop->logger, LOGGER_DEBUG, "connection: %s\n", remotestr);
163 logger_log(&conn->raop->logger, LOGGER_DEBUG, "fmtp: %s\n", fmtpstr);
164 logger_log(&conn->raop->logger, LOGGER_DEBUG, "rsaaeskey: %s\n", aeskeystr);
165 logger_log(&conn->raop->logger, LOGGER_DEBUG, "aesiv: %s\n", aesivstr);
166
167 aeskeylen = rsakey_decrypt(raop->rsakey, aeskey, sizeof(aeskey), aeskeystr);
168 aesivlen = rsakey_parseiv(raop->rsakey, aesiv, sizeof(aesiv), aesivstr);
169 logger_log(&conn->raop->logger, LOGGER_DEBUG, "aeskeylen: %d\n", aeskeylen);
170 logger_log(&conn->raop->logger, LOGGER_DEBUG, "aesivlen: %d\n", aesivlen);
171
172 if (conn->raop_rtp) {
173 /* This should never happen */
174 raop_rtp_destroy(conn->raop_rtp);
175 conn->raop_rtp = NULL;
176 }
177 conn->raop_rtp = raop_rtp_init(&raop->logger, &raop->callbacks, remotestr, fmtpstr, aeskey, aesiv);
178 sdp_destroy(sdp);
179 }
180 } else if (!strcmp(method, "SETUP")) {
181 unsigned short remote_cport=0, remote_tport=0;
182 unsigned short cport=0, tport=0, dport=0;
183 const char *transport;
184 char buffer[1024];
185 int use_udp;
186
187 transport = http_request_get_header(request, "Transport");
188 assert(transport);
189
190 logger_log(&conn->raop->logger, LOGGER_INFO, "Transport: %s\n", transport);
191 use_udp = strncmp(transport, "RTP/AVP/TCP", 11);
192 if (use_udp) {
193 char *original, *current, *tmpstr;
194
195 current = original = strdup(transport);
196 if (original) {
197 while ((tmpstr = utils_strsep(&current, ";")) != NULL) {
198 unsigned short value;
199 int ret;
200
201 ret = sscanf(tmpstr, "control_port=%hu", &value);
202 if (ret == 1) {
203 logger_log(&conn->raop->logger, LOGGER_DEBUG, "Found remote control port: %hu\n", value);
204 remote_cport = value;
205 }
206 ret = sscanf(tmpstr, "timing_port=%hu", &value);
207 if (ret == 1) {
208 logger_log(&conn->raop->logger, LOGGER_DEBUG, "Found remote timing port: %hu\n", value);
209 remote_tport = value;
210 }
211 }
212 }
213 free(original);
214 }
215 raop_rtp_start(conn->raop_rtp, use_udp, remote_cport, remote_tport, &cport, &tport, &dport);
216
217 memset(buffer, 0, sizeof(buffer));
218 if (use_udp) {
219 snprintf(buffer, sizeof(buffer)-1,
220 "RTP/AVP/UDP;unicast;mode=record;timing_port=%hu;events;control_port=%hu;server_port=%hu",
221 tport, cport, dport);
222 } else {
223 snprintf(buffer, sizeof(buffer)-1,
224 "RTP/AVP/TCP;unicast;interleaved=0-1;mode=record;server_port=%u",
225 dport);
226 }
227 logger_log(&conn->raop->logger, LOGGER_INFO, "Responding with %s\n", buffer);
228 http_response_add_header(res, "Transport", buffer);
229 http_response_add_header(res, "Session", "DEADBEEF");
230 } else if (!strcmp(method, "SET_PARAMETER")) {
231 const char *data;
232 int datalen;
233 char *datastr;
234
235 data = http_request_get_data(request, &datalen);
236 datastr = calloc(1, datalen+1);
237 if (data && datastr && conn->raop_rtp) {
238 memcpy(datastr, data, datalen);
239 if (!strncmp(datastr, "volume: ", 8)) {
240 float vol = 0.0;
241 sscanf(data+8, "%f", &vol);
242 raop_rtp_set_volume(conn->raop_rtp, vol);
243 }
244 }
245 } else if (!strcmp(method, "FLUSH")) {
246 const char *rtpinfo;
247 int next_seq = -1;
248
249 rtpinfo = http_request_get_header(request, "RTP-Info");
250 if (rtpinfo) {
251 logger_log(&conn->raop->logger, LOGGER_INFO, "Flush with RTP-Info: %s\n", rtpinfo);
252 if (!strncmp(rtpinfo, "seq=", 4)) {
253 next_seq = strtol(rtpinfo+4, NULL, 10);
254 }
255 }
256 if (conn->raop_rtp) {
257 raop_rtp_flush(conn->raop_rtp, next_seq);
258 }
259 } else if (!strcmp(method, "TEARDOWN")) {
260 http_response_add_header(res, "Connection", "close");
261 if (conn->raop_rtp) {
262 /* Destroy our RTP session */
263 raop_rtp_stop(conn->raop_rtp);
264 raop_rtp_destroy(conn->raop_rtp);
265 conn->raop_rtp = NULL;
266 }
267 }
268 http_response_finish(res, NULL, 0);
269
270 logger_log(&conn->raop->logger, LOGGER_DEBUG, "Got request %s with URL %s\n", method, http_request_get_url(request));
271 *response = res;
272 }
273
274 static void
275 conn_destroy(void *ptr)
276 {
277 raop_conn_t *conn = ptr;
278
279 if (conn->raop_rtp) {
280 /* This is done in case TEARDOWN was not called */
281 raop_rtp_destroy(conn->raop_rtp);
282 }
283 free(conn->local);
284 free(conn->remote);
285 free(conn);
286 }
287
288 raop_t *
289 raop_init(raop_callbacks_t *callbacks, const char *pemkey)
290 {
291 raop_t *raop;
292 httpd_t *httpd;
293 rsakey_t *rsakey;
294 httpd_callbacks_t httpd_cbs;
295
296 assert(callbacks);
297 assert(pemkey);
298
299 /* Initialize the network */
300 if (netutils_init() < 0) {
301 return NULL;
302 }
303
304 /* Validate the callbacks structure */
305 if (!callbacks->audio_init || !callbacks->audio_set_volume ||
306 !callbacks->audio_process || !callbacks->audio_flush ||
307 !callbacks->audio_destroy) {
308 return NULL;
309 }
310
311 /* Allocate the raop_t structure */
312 raop = calloc(1, sizeof(raop_t));
313 if (!raop) {
314 return NULL;
315 }
316
317 /* Initialize the logger */
318 logger_init(&raop->logger);
319
320 /* Set HTTP callbacks to our handlers */
321 memset(&httpd_cbs, 0, sizeof(httpd_cbs));
322 httpd_cbs.opaque = raop;
323 httpd_cbs.conn_init = &conn_init;
324 httpd_cbs.conn_request = &conn_request;
325 httpd_cbs.conn_destroy = &conn_destroy;
326
327 /* Initialize the http daemon */
328 httpd = httpd_init(&raop->logger, &httpd_cbs, 10, 1);
329 if (!httpd) {
330 free(raop);
331 return NULL;
332 }
333
334 /* Copy callbacks structure */
335 memcpy(&raop->callbacks, callbacks, sizeof(raop_callbacks_t));
336
337 /* Initialize RSA key handler */
338 rsakey = rsakey_init_pem(pemkey);
339 if (!rsakey) {
340 free(httpd);
341 free(raop);
342 return NULL;
343 }
344
345 raop->httpd = httpd;
346 raop->rsakey = rsakey;
347
348 return raop;
349 }
350
351 raop_t *
352 raop_init_from_keyfile(raop_callbacks_t *callbacks, const char *keyfile)
353 {
354 raop_t *raop;
355 char *pemstr;
356
357 if (utils_read_file(&pemstr, keyfile) < 0) {
358 return NULL;
359 }
360 raop = raop_init(callbacks, pemstr);
361 free(pemstr);
362 return raop;
363 }
364
365 void
366 raop_destroy(raop_t *raop)
367 {
368 if (raop) {
369 raop_stop(raop);
370
371 httpd_destroy(raop->httpd);
372 rsakey_destroy(raop->rsakey);
373 free(raop);
374
375 /* Cleanup the network */
376 netutils_cleanup();
377 }
378 }
379
380 int
381 raop_start(raop_t *raop, unsigned short *port, const char *hwaddr, int hwaddrlen)
382 {
383 assert(raop);
384 assert(port);
385 assert(hwaddr);
386
387 /* Validate hardware address */
388 if (hwaddrlen > MAX_HWADDR_LEN) {
389 return -1;
390 }
391
392 /* Copy hwaddr to the raop structure */
393 memcpy(raop->hwaddr, hwaddr, hwaddrlen);
394 raop->hwaddrlen = hwaddrlen;
395
396 return httpd_start(raop->httpd, port);
397 }
398
399 void
400 raop_stop(raop_t *raop)
401 {
402 assert(raop);
403
404 httpd_stop(raop->httpd);
405 }
406