forked from mikebrady/shairport-sync
-
Notifications
You must be signed in to change notification settings - Fork 0
/
metadata.c
334 lines (267 loc) · 10.5 KB
/
metadata.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
/*
* Metadate structure and utility methods. This file is part of Shairport.
* Copyright (c) Benjamin Maus 2013
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
#include <memory.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "config.h"
#ifdef HAVE_LIBSSL
#include <openssl/md5.h>
#endif
#ifdef HAVE_LIBPOLARSSL
#include <polarssl/md5.h>
#endif
#include "common.h"
#include "metadata.h"
// including a simple base64 encoder to minimise malloc/free activity
// From Stack Overflow, with thanks:
// http:https://stackoverflow.com/questions/342409/how-do-i-base64-encode-decode-in-c
// minor mods to make independent of C99.
// more significant changes make it not malloc memory
// needs to initialise the docoding table first
// add _so to end of name to avoid confusion with polarssl's implementation
static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'};
static int mod_table[] = {0, 2, 1};
// pass in a pointer to the data, its length, a pointer to the output buffer and a pointer to an int containing its maximum length
// the actual length will be returned.
char *base64_encode_so(const unsigned char *data,
size_t input_length,
char *encoded_data,
size_t *output_length) {
size_t calculated_output_length = 4 * ((input_length + 2) / 3);
if (calculated_output_length> *output_length)
return(NULL);
*output_length = calculated_output_length;
int i,j;
for (i = 0, j = 0; i < input_length;) {
uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0;
uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0;
uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0;
uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];
}
for (i = 0; i < mod_table[input_length % 3]; i++)
encoded_data[*output_length - 1 - i] = '=';
return encoded_data;
}
// with thanks!
//
metadata player_meta;
static int fd = -1;
static int dirty = 0;
void metadata_set(char** field, const char* value) {
if (*field) {
if (!strcmp(*field, value))
return;
free(*field);
}
*field = strdup(value);
dirty = 1;
}
void metadata_create(void) {
if (!config.meta_dir)
return;
const char fn[] = "shairport_sync_metadata_pipe";
size_t pl = strlen(config.meta_dir) + 1 + strlen(fn);
char* path = malloc(pl+1);
snprintf(path, pl+1, "%s/%s", config.meta_dir, fn);
if (mkfifo(path, 0644) && errno != EEXIST)
die("Could not create metadata FIFO %s", path);
free(path);
}
void metadata_open(void) {
if (!config.meta_dir)
return;
const char fn[] = "shairport_sync_metadata_pipe";
size_t pl = strlen(config.meta_dir) + 1 + strlen(fn);
char* path = malloc(pl+1);
snprintf(path, pl+1, "%s/%s", config.meta_dir, fn);
fd = open(path, O_WRONLY | O_NONBLOCK);
if (fd < 0)
debug(1, "Could not open metadata FIFO %s. Will try again later.", path);
free(path);
}
static void metadata_close(void) {
close(fd);
fd = -1;
}
void metadata_init(void) {
if (!config.meta_dir)
return;
metadata_create();
}
static void print_one(const char *name, const char *value) {
int ignore;
ignore = write(fd, name, strlen(name));
ignore = write(fd, "=", 1);
if (value)
ignore = write(fd, value, strlen(value));
ignore = write(fd, "\n", 1);
}
#define write_one(name) \
print_one(#name, player_meta.name)
void metadata_write(void) {
int ret;
// readers may go away and come back
if (fd < 0)
metadata_open();
if (fd < 0)
return;
if (!dirty)
return;
dirty = 0;
write_one(artist);
write_one(title);
write_one(album);
write_one(artwork);
write_one(genre);
write_one(comment);
ret = write(fd, "\n", 1);
if (ret < 1) // no reader
metadata_close();
}
void metadata_cover_image(const char *buf, int len, const char *ext) {
if (!config.meta_dir)
return;
if (buf) {
debug(2, "Cover Art set\n");
} else {
debug(2, "Cover Art cleared\n");
return;
}
uint8_t img_md5[16];
#ifdef HAVE_LIBSSL
MD5_CTX ctx;
MD5_Init(&ctx);
MD5_Update(&ctx, buf, len);
MD5_Final(img_md5, &ctx);
#endif
#ifdef HAVE_LIBPOLARSSL
md5_context tctx;
md5_starts(&tctx);
md5_update(&tctx, buf, len);
md5_finish(&tctx, img_md5);
#endif
char img_md5_str[33];
int i;
for (i = 0; i < 16; i++)
sprintf(&img_md5_str[i*2], "%02x", (uint8_t)img_md5[i]);
char *dir = config.meta_dir;
char *prefix = "cover-";
size_t pl = strlen(dir) + 1 + strlen(prefix) + strlen(img_md5_str) + 1 + strlen(ext);
char *path = malloc(pl+1);
snprintf(path, pl+1, "%s/%s%s.%s", dir, prefix, img_md5_str, ext);
int cover_fd = open(path, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP| S_IROTH | S_IWOTH);
if (cover_fd < 0) {
warn("Could not open file %s for writing cover art", path);
return;
}
if (write(cover_fd, buf, len) < len) {
warn("writing %s failed\n", path);
free(path);
return;
}
close(cover_fd);
debug(2, "Cover Art file is \"%s\".\n", path);
metadata_set(&player_meta.artwork, path+strlen(dir)+1);
free(path);
}
// Metadata is not used by shairport-sync.
// Instead we send all metadata to a fifo pipe, so that other apps can listen to the pipe and use the metadata.
// We use two 4-character codes to identify each piece of data and we send the data itself in base64 form.
// The first 4-character code, called the "type", is either:
// 'core' for all the regular metadadata coming from iTunes, etc., or
// 'ssnc' (for 'shairport-sync') for all metadata coming from Shairport Sync itself, such as start/end delimiters, etc.
// For 'core' metadata, the second 4-character code is the 4-character metadata code coming from iTunes etc.
// For 'ssnc' metadata, the second 4-character code is used to distinguish the messages.
// Cover art is not tagged in the same way as other metadata, it seems, so is sent as an 'ssnc' type metadata message with the code 'PICT'
// The three kinds of 'ssnc' metadata at present are 'strt', 'stop' and 'PICT' for metadata package start, metadata package stop and cover art, respectively.
// Metadata is sent in two disctinct parts:
// (1) a line with type, code and length information surrounded by XML-type tags and
// (2) the data itself, if any, in base64 form, surrounded by XML-style data tags.
void metadata_process(uint32_t type,uint32_t code,char *data,uint32_t length) {
debug(2,"Process metadata with type %x, code %x and length %u.",type,code,length);
int ret;
// readers may go away and come back
if (fd < 0)
metadata_open();
if (fd < 0)
return;
char thestring[1024];
snprintf(thestring,1024,"<type>%x</type><code>%x</code><length>%u</length>\n",type,code,length);
ret = write(fd, thestring, strlen(thestring));
if (ret < 1) // possibly the pipe is running out of memory becasue the reader is too slow
debug(1,"Error writing to pipe");
if (length>0) {
snprintf(thestring,1024,"<data encoding=\"base64\">\n");
ret = write(fd, thestring, strlen(thestring));
if (ret < 1) // no reader
debug(1,"Error writing to pipe");
// here, we write the data in base64 form using the crappy base64 encoder provided
// but, we break it into lines of 76 output characters, except for the last one.
// thus, we send groups of (76/4)*3 = 57 bytes to the encoder at a time
size_t remaining_count = length;
char *remaining_data = data;
size_t towrite_count;
char outbuf[76];
while ((remaining_count) && (ret>=0)) {
size_t towrite_count = remaining_count;
if (towrite_count>57)
towrite_count = 57;
size_t outbuf_size = 76; // size of output buffer on entry, length of result on exit
if (base64_encode_so(remaining_data, towrite_count, outbuf, &outbuf_size)==NULL)
debug(1,"Error encoding base64 data.");
//debug(1,"Remaining count: %d ret: %d, outbuf_size: %d.",remaining_count,ret,outbuf_size);
ret = write(fd,outbuf,outbuf_size);
if (ret<0)
debug(1,"Error writing base64 data to pipe: \"%s\".",strerror(errno));
remaining_data+=towrite_count;
remaining_count-=towrite_count;
//ret = write(fd,"\r\n",2);
//if (ret<0)
// debug(1,"Error writing base64 cr/lf to pipe.");
}
snprintf(thestring,1024,"</data>\n");
ret = write(fd, thestring, strlen(thestring));
if (ret < 1) // no reader
debug(1,"Error writing to pipe");
}
}