0573f5420be84b5cd78c914f63745cb3959062c6
[cubemap] / config.cpp
1 #include <arpa/inet.h>
2 #include <assert.h>
3 #include <ctype.h>
4 #include <stdint.h>
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <net/if.h>
9 #include <sys/socket.h>
10 #include <map>
11 #include <string>
12 #include <utility>
13 #include <vector>
14
15 #include "tlse.h"
16
17 #include "acceptor.h"
18 #include "config.h"
19 #include "log.h"
20 #include "parse.h"
21
22 using namespace std;
23
24 #define DEFAULT_BACKLOG_SIZE 10485760
25
26 struct ConfigLine {
27         string keyword;
28         vector<string> arguments;
29         map<string, string> parameters;
30 };
31
32 namespace {
33
34 bool parse_hostport(const string &hostport, sockaddr_in6 *addr)
35 {
36         memset(addr, 0, sizeof(*addr));
37         addr->sin6_family = AF_INET6;
38
39         string port_string;
40
41         // See if the argument if on the type [ipv6addr]:port.
42         if (!hostport.empty() && hostport[0] == '[') {
43                 size_t split = hostport.find("]:");
44                 if (split == string::npos) {
45                         log(ERROR, "address '%s' is malformed; must be either [ipv6addr]:port or ipv4addr:port");
46                         return false;
47                 }
48
49                 string host(hostport.begin() + 1, hostport.begin() + split);
50                 port_string = hostport.substr(split + 2);
51
52                 if (inet_pton(AF_INET6, host.c_str(), &addr->sin6_addr) != 1) {
53                         log(ERROR, "'%s' is not a valid IPv6 address");
54                         return false;
55                 }
56         } else {
57                 // OK, then it must be ipv4addr:port.
58                 size_t split = hostport.find(":");
59                 if (split == string::npos) {
60                         log(ERROR, "address '%s' is malformed; must be either [ipv6addr]:port or ipv4addr:port");
61                         return false;
62                 }
63
64                 string host(hostport.begin(), hostport.begin() + split);
65                 port_string = hostport.substr(split + 1);
66
67                 // Parse to an IPv4 address, then construct a mapped-v4 address from that.
68                 in_addr addr4;
69
70                 if (inet_pton(AF_INET, host.c_str(), &addr4) != 1) {
71                         log(ERROR, "'%s' is not a valid IPv4 address");
72                         return false;
73                 }
74
75                 addr->sin6_addr.s6_addr32[2] = htonl(0xffff);
76                 addr->sin6_addr.s6_addr32[3] = addr4.s_addr;
77         }
78
79         int port = atoi(port_string.c_str());
80         if (port < 1 || port >= 65536) {
81                 log(ERROR, "port %d is out of range (must be [1,65536>).", port);
82                 return false;
83         }
84         addr->sin6_port = ntohs(port);
85
86         return true;
87 }
88
89 bool read_config(const string &filename, vector<ConfigLine> *lines)
90 {
91         FILE *fp = fopen(filename.c_str(), "r");
92         if (fp == NULL) {
93                 log_perror(filename.c_str());
94                 return false;
95         }
96
97         char buf[4096];
98         while (!feof(fp)) {
99                 if (fgets(buf, sizeof(buf), fp) == NULL) {
100                         break;
101                 }
102
103                 // Chop off the string at the first #, \r or \n.
104                 buf[strcspn(buf, "#\r\n")] = 0;
105
106                 // Remove all whitespace from the end of the string.
107                 size_t len = strlen(buf);
108                 while (len > 0 && isspace(buf[len - 1])) {
109                         buf[--len] = 0;
110                 }
111
112                 // If the line is now all blank, ignore it.
113                 if (len == 0) {
114                         continue;
115                 }
116
117                 vector<string> tokens = split_tokens(buf);
118                 assert(!tokens.empty());
119                 
120                 ConfigLine line;
121                 line.keyword = tokens[0];
122
123                 for (size_t i = 1; i < tokens.size(); ++i) {
124                         // foo=bar is a parameter; anything else is an argument.
125                         size_t equals_pos = tokens[i].find_first_of('=');
126                         if (equals_pos == string::npos) {
127                                 line.arguments.push_back(tokens[i]);
128                         } else {
129                                 string key = tokens[i].substr(0, equals_pos);
130                                 string value = tokens[i].substr(equals_pos + 1, string::npos);
131                                 line.parameters.insert(make_pair(key, value));
132                         }
133                 }
134
135                 lines->push_back(line);
136         }
137
138         if (fclose(fp) == EOF) {
139                 log_perror(filename.c_str());
140                 return false;
141         }
142         return true;
143 }
144
145 bool fetch_config_string(const vector<ConfigLine> &config, const string &keyword, string *value)
146 {
147         for (const ConfigLine &line : config) {
148                 if (line.keyword != keyword) {
149                         continue;
150                 }
151                 if (line.parameters.size() > 0 ||
152                     line.arguments.size() != 1) {
153                         log(ERROR, "'%s' takes one argument and no parameters", keyword.c_str());
154                         return false;
155                 }
156                 *value = line.arguments[0];
157                 return true;
158         }
159         return false;
160 }
161
162 bool fetch_config_int(const vector<ConfigLine> &config, const string &keyword, int *value)
163 {
164         for (const ConfigLine &line : config) {
165                 if (line.keyword != keyword) {
166                         continue;
167                 }
168                 if (line.parameters.size() > 0 ||
169                     line.arguments.size() != 1) {
170                         log(ERROR, "'%s' takes one argument and no parameters", keyword.c_str());
171                         return false;
172                 }
173                 *value = atoi(line.arguments[0].c_str());  // TODO: verify int validity.
174                 return true;
175         }
176         return false;
177 }
178
179 bool load_file_to_string(const string &filename, size_t max_size, string *contents)
180 {
181         contents->clear();
182
183         FILE *fp = fopen(filename.c_str(), "r");
184         if (fp == NULL) {
185                 log_perror(filename.c_str());
186                 return false;
187         }
188
189         char buf[4096];
190         while (!feof(fp)) {
191                 size_t ret = fread(buf, 1, sizeof(buf), fp);
192                 if (ret > 0) {
193                         contents->append(buf, buf + ret);
194                 } else {
195                         if (ferror(fp)) {
196                                 log_perror(filename.c_str());
197                                 fclose(fp);
198                                 return false;
199                         }
200                         assert(feof(fp));
201                         break;
202                 }
203
204                 if (contents->size() > max_size) {
205                         log(ERROR, "%s was longer than the maximum allowed %zu bytes", filename.c_str(), max_size);
206                         fclose(fp);
207                         return false;
208                 }
209         }
210         fclose(fp);
211         return true;
212 }
213
214 bool parse_tls_parameters(const map<string, string> &parameters, AcceptorConfig *acceptor)
215 {
216         bool has_cert = false, has_key = false;
217
218         auto tls_cert_it = parameters.find("tls_cert");
219         if (tls_cert_it != parameters.end()) {
220                 if (!load_file_to_string(tls_cert_it->second, 1048576, &acceptor->certificate_chain)) {
221                         return false;
222                 }
223
224                 // Verify that the certificate is valid.
225                 bool is_server = true;
226                 TLSContext *server_context = tls_create_context(is_server, TLS_V12);
227                 int num_cert = tls_load_certificates(
228                         server_context,
229                         reinterpret_cast<const unsigned char *>(acceptor->certificate_chain.data()),
230                         acceptor->certificate_chain.size());
231                 if (num_cert < 0) {
232                         log_tls_error(tls_cert_it->second.c_str(), num_cert);
233                         tls_destroy_context(server_context);
234                         return false;
235                 } else if (num_cert == 0) {
236                         log(ERROR, "%s did not contain any certificates", tls_cert_it->second.c_str());
237                         return false;
238                 }
239                 tls_destroy_context(server_context);
240                 has_cert = true;
241         }
242
243         auto tls_key_it = parameters.find("tls_key");
244         if (tls_key_it != parameters.end()) {
245                 if (!load_file_to_string(tls_key_it->second, 1048576, &acceptor->private_key)) {
246                         return false;
247                 }
248
249                 // Verify that the key is valid.
250                 bool is_server = true;
251                 TLSContext *server_context = tls_create_context(is_server, TLS_V12);
252                 int num_keys = tls_load_private_key(
253                         server_context,
254                         reinterpret_cast<const unsigned char *>(acceptor->private_key.data()),
255                         acceptor->private_key.size());
256                 if (num_keys < 0) {
257                         log_tls_error(tls_key_it->second.c_str(), num_keys);
258                         tls_destroy_context(server_context);
259                         return false;
260                 } else if (num_keys == 0) {
261                         log(ERROR, "%s did not contain any private keys", tls_key_it->second.c_str());
262                         return false;
263                 }
264                 tls_destroy_context(server_context);
265                 has_key = true;
266         }
267
268         if (has_cert != has_key) {
269                 log(ERROR, "Only one of tls_cert= and tls_key= was given, needs zero or both");
270                 return false;
271         }
272
273         return true;
274 }
275
276
277 bool parse_port(const ConfigLine &line, Config *config)
278 {
279         if (line.arguments.size() != 1) {
280                 log(ERROR, "'port' takes exactly one argument");
281                 return false;
282         }
283
284         int port = atoi(line.arguments[0].c_str());
285         if (port < 1 || port >= 65536) {
286                 log(ERROR, "port %d is out of range (must be [1,65536>).", port);
287                 return false;
288         }
289
290         AcceptorConfig acceptor;
291         acceptor.addr = create_any_address(port);
292
293         if (!parse_tls_parameters(line.parameters, &acceptor)) {
294                 return false;
295         }
296         config->acceptors.push_back(acceptor);
297         return true;
298 }
299
300 bool parse_listen(const ConfigLine &line, Config *config)
301 {
302         if (line.arguments.size() != 1) {
303                 log(ERROR, "'listen' takes exactly one argument");
304                 return false;
305         }
306
307         AcceptorConfig acceptor;
308         if (!parse_hostport(line.arguments[0], &acceptor.addr)) {
309                 return false;
310         }
311         if (!parse_tls_parameters(line.parameters, &acceptor)) {
312                 return false;
313         }
314         config->acceptors.push_back(acceptor);
315         return true;
316 }
317
318 bool parse_stream(const ConfigLine &line, Config *config)
319 {
320         if (line.arguments.size() != 1) {
321                 log(ERROR, "'stream' takes exactly one argument");
322                 return false;
323         }
324
325         StreamConfig stream;
326         stream.url = line.arguments[0];
327
328         const auto src_it = line.parameters.find("src");
329         if (src_it == line.parameters.end()) {
330                 log(WARNING, "stream '%s' has no src= attribute, clients will not get any data.",
331                         stream.url.c_str());
332         } else {
333                 stream.src = src_it->second;
334                 // TODO: Verify that the URL is parseable?
335         }
336
337         const auto backlog_it = line.parameters.find("backlog_size");
338         if (backlog_it == line.parameters.end()) {
339                 stream.backlog_size = DEFAULT_BACKLOG_SIZE;
340         } else {
341                 stream.backlog_size = atoi(backlog_it->second.c_str());
342         }
343
344         const auto prebuffer_it = line.parameters.find("force_prebuffer");
345         if (prebuffer_it == line.parameters.end()) {
346                 stream.prebuffering_bytes = 0;
347         } else {
348                 stream.prebuffering_bytes = atoi(prebuffer_it->second.c_str());
349         }
350
351         // Parse output encoding.
352         const auto encoding_parm_it = line.parameters.find("encoding");
353         if (encoding_parm_it == line.parameters.end() ||
354             encoding_parm_it->second == "raw") {
355                 stream.encoding = StreamConfig::STREAM_ENCODING_RAW;
356         } else if (encoding_parm_it->second == "metacube") {
357                 stream.encoding = StreamConfig::STREAM_ENCODING_METACUBE;
358         } else {
359                 log(ERROR, "Parameter 'encoding' must be either 'raw' (default) or 'metacube'");
360                 return false;
361         }
362
363         // Parse input encoding.
364         const auto src_encoding_parm_it = line.parameters.find("src_encoding");
365         if (src_encoding_parm_it == line.parameters.end() ||
366             src_encoding_parm_it->second == "metacube") {
367                 stream.src_encoding = StreamConfig::STREAM_ENCODING_METACUBE;
368         } else if (src_encoding_parm_it->second == "raw") {
369                 stream.src_encoding = StreamConfig::STREAM_ENCODING_RAW;
370         } else {
371                 log(ERROR, "Parameter 'src_encoding' must be either 'raw' or 'metacube' (default)");
372                 return false;
373         }
374
375         // Parse the pacing rate, converting from kilobits to bytes as needed.
376         const auto pacing_rate_it = line.parameters.find("pacing_rate_kbit");
377         if (pacing_rate_it == line.parameters.end()) {
378                 stream.pacing_rate = ~0U;
379         } else {
380                 stream.pacing_rate = atoi(pacing_rate_it->second.c_str()) * 1024 / 8;
381         }
382
383         config->streams.push_back(stream);
384         return true;
385 }
386
387 bool parse_udpstream(const ConfigLine &line, Config *config)
388 {
389         if (line.arguments.size() != 1) {
390                 log(ERROR, "'udpstream' takes exactly one argument");
391                 return false;
392         }
393
394         UDPStreamConfig udpstream;
395
396         string hostport = line.arguments[0];
397         if (!parse_hostport(hostport, &udpstream.dst)) {
398                 return false;
399         }
400
401         const auto src_it = line.parameters.find("src");
402         if (src_it == line.parameters.end()) {
403                 // This is pretty meaningless, but OK, consistency is good.
404                 log(WARNING, "udpstream to %s has no src= attribute, clients will not get any data.",
405                         hostport.c_str());
406         } else {
407                 udpstream.src = src_it->second;
408                 // TODO: Verify that the URL is parseable?
409         }
410
411         // Parse the pacing rate, converting from kilobits to bytes as needed.
412         const auto pacing_rate_it = line.parameters.find("pacing_rate_kbit");
413         if (pacing_rate_it == line.parameters.end()) {
414                 udpstream.pacing_rate = ~0U;
415         } else {
416                 udpstream.pacing_rate = atoi(pacing_rate_it->second.c_str()) * 1024 / 8;
417         }
418
419         // Parse the TTL. The same value is used for unicast and multicast.
420         const auto ttl_it = line.parameters.find("ttl");
421         if (ttl_it == line.parameters.end()) {
422                 udpstream.ttl = -1;
423         } else {
424                 udpstream.ttl = atoi(ttl_it->second.c_str());
425         }
426
427         // Parse the multicast interface index.
428         const auto multicast_iface_it = line.parameters.find("multicast_output_interface");
429         if (multicast_iface_it == line.parameters.end()) {
430                 udpstream.multicast_iface_index = -1;
431         } else {
432                 udpstream.multicast_iface_index = if_nametoindex(multicast_iface_it->second.c_str());
433                 if (udpstream.multicast_iface_index == 0) {
434                         log(ERROR, "Interface '%s' does not exist", multicast_iface_it->second.c_str());
435                         return false;
436                 }
437         }
438
439         config->udpstreams.push_back(udpstream);
440         return true;
441 }
442
443 bool parse_gen204(const ConfigLine &line, Config *config)
444 {
445         if (line.arguments.size() != 1) {
446                 log(ERROR, "'gen204' takes exactly one argument");
447                 return false;
448         }
449
450         Gen204Config gen204;
451         gen204.url = line.arguments[0];
452
453         // Parse the CORS origin, if it exists.
454         const auto allow_origin_it = line.parameters.find("allow_origin");
455         if (allow_origin_it != line.parameters.end()) {
456                 gen204.allow_origin = allow_origin_it->second;
457         }
458
459         config->pings.push_back(gen204);
460         return true;
461 }
462
463 bool parse_error_log(const ConfigLine &line, Config *config)
464 {
465         if (line.arguments.size() != 0) {
466                 log(ERROR, "'error_log' takes no arguments (only parameters type= and filename=)");
467                 return false;
468         }
469
470         LogConfig log_config;
471         const auto type_it = line.parameters.find("type");
472         if (type_it == line.parameters.end()) {
473                 log(ERROR, "'error_log' has no type= parameter");
474                 return false; 
475         }
476
477         string type = type_it->second;
478         if (type == "file") {
479                 log_config.type = LogConfig::LOG_TYPE_FILE;
480         } else if (type == "syslog") {
481                 log_config.type = LogConfig::LOG_TYPE_SYSLOG;
482         } else if (type == "console") {
483                 log_config.type = LogConfig::LOG_TYPE_CONSOLE;
484         } else {
485                 log(ERROR, "Unknown log type '%s'", type.c_str());
486                 return false; 
487         }
488
489         if (log_config.type == LogConfig::LOG_TYPE_FILE) {
490                 const auto filename_it = line.parameters.find("filename");
491                 if (filename_it == line.parameters.end()) {
492                         log(ERROR, "error_log type 'file' with no filename= parameter");
493                         return false; 
494                 }
495                 log_config.filename = filename_it->second;
496         }
497
498         config->log_destinations.push_back(log_config);
499         return true;
500 }
501
502 }  // namespace
503
504 bool parse_config(const string &filename, Config *config)
505 {
506         vector<ConfigLine> lines;
507         if (!read_config(filename, &lines)) {
508                 return false;
509         }
510
511         config->daemonize = false;
512
513         if (!fetch_config_int(lines, "num_servers", &config->num_servers)) {
514                 log(ERROR, "Missing 'num_servers' statement in config file.");
515                 return false;
516         }
517         if (config->num_servers < 1 || config->num_servers >= 20000) {  // Insanely high max limit.
518                 log(ERROR, "'num_servers' is %d, needs to be in [1, 20000>.", config->num_servers);
519                 return false;
520         }
521
522         // See if the user wants stats.
523         config->stats_interval = 60;
524         bool has_stats_file = fetch_config_string(lines, "stats_file", &config->stats_file);
525         bool has_stats_interval = fetch_config_int(lines, "stats_interval", &config->stats_interval);
526         if (has_stats_interval && !has_stats_file) {
527                 log(WARNING, "'stats_interval' given, but no 'stats_file'. No client statistics will be written.");
528         }
529
530         config->input_stats_interval = 60;
531         bool has_input_stats_file = fetch_config_string(lines, "input_stats_file", &config->input_stats_file);
532         bool has_input_stats_interval = fetch_config_int(lines, "input_stats_interval", &config->input_stats_interval);
533         if (has_input_stats_interval && !has_input_stats_file) {
534                 log(WARNING, "'input_stats_interval' given, but no 'input_stats_file'. No input statistics will be written.");
535         }
536         
537         fetch_config_string(lines, "access_log", &config->access_log_file);
538
539         for (const ConfigLine &line : lines) {
540                 if (line.keyword == "num_servers" ||
541                     line.keyword == "stats_file" ||
542                     line.keyword == "stats_interval" ||
543                     line.keyword == "input_stats_file" ||
544                     line.keyword == "input_stats_interval" ||
545                     line.keyword == "access_log") {
546                         // Already taken care of, above.
547                 } else if (line.keyword == "port") {
548                         if (!parse_port(line, config)) {
549                                 return false;
550                         }
551                 } else if (line.keyword == "listen") {
552                         if (!parse_listen(line, config)) {
553                                 return false;
554                         }
555                 } else if (line.keyword == "stream") {
556                         if (!parse_stream(line, config)) {
557                                 return false;
558                         }
559                 } else if (line.keyword == "udpstream") {
560                         if (!parse_udpstream(line, config)) {
561                                 return false;
562                         }
563                 } else if (line.keyword == "gen204") {
564                         if (!parse_gen204(line, config)) {
565                                 return false;
566                         }
567                 } else if (line.keyword == "error_log") {
568                         if (!parse_error_log(line, config)) {
569                                 return false;
570                         }
571                 } else if (line.keyword == "daemonize") {
572                         config->daemonize = true;
573                 } else {
574                         log(ERROR, "Unknown configuration keyword '%s'.",
575                                 line.keyword.c_str());
576                         return false;
577                 }
578         }
579
580         return true;
581 }