#include <string.h>
#include <net/if.h>
#include <sys/socket.h>
-#include <map>
#include <string>
#include <utility>
+#include <unordered_map>
#include <vector>
#include "tlse.h"
#include "acceptor.h"
#include "config.h"
+#include "input.h"
#include "log.h"
#include "parse.h"
struct ConfigLine {
string keyword;
vector<string> arguments;
- map<string, string> parameters;
+ unordered_map<string, string> parameters;
};
namespace {
addr->sin6_addr.s6_addr32[3] = addr4.s_addr;
}
- int port = atoi(port_string.c_str());
+ int port = stoi(port_string);
if (port < 1 || port >= 65536) {
log(ERROR, "port %d is out of range (must be [1,65536>).", port);
return false;
log(ERROR, "'%s' takes one argument and no parameters", keyword.c_str());
return false;
}
- *value = atoi(line.arguments[0].c_str()); // TODO: verify int validity.
+ *value = stoi(line.arguments[0]); // TODO: verify int validity.
return true;
}
return false;
return true;
}
-bool parse_tls_parameters(const map<string, string> ¶meters, AcceptorConfig *acceptor)
+bool parse_tls_parameters(const unordered_map<string, string> ¶meters, AcceptorConfig *acceptor)
{
bool has_cert = false, has_key = false;
return false;
}
- int port = atoi(line.arguments[0].c_str());
+ int port = stoi(line.arguments[0]);
if (port < 1 || port >= 65536) {
log(ERROR, "port %d is out of range (must be [1,65536>).", port);
return false;
stream.url = line.arguments[0];
const auto src_it = line.parameters.find("src");
+ bool input_is_udp = false;
if (src_it == line.parameters.end()) {
log(WARNING, "stream '%s' has no src= attribute, clients will not get any data.",
stream.url.c_str());
} else {
stream.src = src_it->second;
- // TODO: Verify that the URL is parseable?
+
+ string protocol, user, host, port, path;
+ if (!parse_url(stream.src, &protocol, &user, &host, &port, &path)) {
+ log(ERROR, "could not parse URL '%s'", stream.src.c_str());
+ return false;
+ }
+ if (protocol == "udp") {
+ input_is_udp = true;
+ }
}
const auto backlog_it = line.parameters.find("backlog_size");
if (backlog_it == line.parameters.end()) {
stream.backlog_size = DEFAULT_BACKLOG_SIZE;
} else {
- stream.backlog_size = atoi(backlog_it->second.c_str());
+ stream.backlog_size = stoll(backlog_it->second);
}
const auto prebuffer_it = line.parameters.find("force_prebuffer");
if (prebuffer_it == line.parameters.end()) {
stream.prebuffering_bytes = 0;
} else {
- stream.prebuffering_bytes = atoi(prebuffer_it->second.c_str());
+ stream.prebuffering_bytes = stoll(prebuffer_it->second);
}
// Parse output encoding.
// Parse input encoding.
const auto src_encoding_parm_it = line.parameters.find("src_encoding");
- if (src_encoding_parm_it == line.parameters.end() ||
- src_encoding_parm_it->second == "metacube") {
+ if (src_encoding_parm_it == line.parameters.end()) {
+ stream.src_encoding = input_is_udp ? StreamConfig::STREAM_ENCODING_RAW : StreamConfig::STREAM_ENCODING_METACUBE;
+ } else if (src_encoding_parm_it->second == "metacube") {
+ if (input_is_udp) {
+ log(ERROR, "UDP streams cannot have Metacube input");
+ return false;
+ }
stream.src_encoding = StreamConfig::STREAM_ENCODING_METACUBE;
} else if (src_encoding_parm_it->second == "raw") {
stream.src_encoding = StreamConfig::STREAM_ENCODING_RAW;
} else {
- log(ERROR, "Parameter 'src_encoding' must be either 'raw' or 'metacube' (default)");
+ log(ERROR, "Parameter 'src_encoding' must be either 'raw' (default for UDP) or 'metacube' (default for HTTP)");
return false;
}
if (pacing_rate_it == line.parameters.end()) {
stream.pacing_rate = ~0U;
} else {
- stream.pacing_rate = atoi(pacing_rate_it->second.c_str()) * 1024 / 8;
+ stream.pacing_rate = stoll(pacing_rate_it->second.c_str()) * 1024 / 8;
+ }
+
+ // Parse the HLS URL, if any.
+ const auto hls_url_it = line.parameters.find("hls_playlist");
+ if (hls_url_it != line.parameters.end()) {
+ stream.hls_url = hls_url_it->second;
+ if (stream.hls_url.empty()) {
+ log(ERROR, "Parameter 'hls_playlist' was given but empty");
+ return false;
+ }
+ if (stream.encoding == StreamConfig::STREAM_ENCODING_METACUBE) {
+ log(ERROR, "HLS cannot be used with Metacube output");
+ return false;
+ }
+ }
+
+ // Parse the HLS fragment duration, if any.
+ const auto hls_frag_duration_it = line.parameters.find("hls_frag_duration");
+ if (hls_frag_duration_it != line.parameters.end()) {
+ if (stream.hls_url.empty()) {
+ log(ERROR, "Parameter 'hls_frag_duration' given, but no 'hls_playlist' given");
+ return false;
+ }
+ stream.hls_frag_duration = stoi(hls_frag_duration_it->second);
+ if (stream.hls_frag_duration <= 0) {
+ log(ERROR, "'hls_frag_duration' must be a strictly positive integer");
+ return false;
+ }
+ }
+
+ // Parse the HLS backlog margin, if any.
+ const auto hls_backlog_margin_it = line.parameters.find("hls_backlog_margin");
+ if (hls_backlog_margin_it != line.parameters.end()) {
+ if (stream.hls_url.empty()) {
+ log(ERROR, "Parameter 'hls_backlog_margin' given, but no 'hls_playlist' given");
+ return false;
+ }
+ stream.hls_backlog_margin = stoi(hls_backlog_margin_it->second);
+ if (stream.hls_backlog_margin < 0 || stream.hls_backlog_margin >= stream.backlog_size) {
+ log(ERROR, "'hls_backlog_margin' must be nonnegative, but less than the backlog size");
+ return false;
+ }
+ }
+
+ // Parse the CORS origin, if it exists.
+ const auto allow_origin_it = line.parameters.find("allow_origin");
+ if (allow_origin_it != line.parameters.end()) {
+ stream.allow_origin = allow_origin_it->second;
}
config->streams.push_back(stream);
if (pacing_rate_it == line.parameters.end()) {
udpstream.pacing_rate = ~0U;
} else {
- udpstream.pacing_rate = atoi(pacing_rate_it->second.c_str()) * 1024 / 8;
+ udpstream.pacing_rate = stoi(pacing_rate_it->second) * 1024 / 8;
}
// Parse the TTL. The same value is used for unicast and multicast.
if (ttl_it == line.parameters.end()) {
udpstream.ttl = -1;
} else {
- udpstream.ttl = atoi(ttl_it->second.c_str());
+ udpstream.ttl = stoi(ttl_it->second);
}
// Parse the multicast interface index.
projects / cubemap / blobdiff