1017 lines
40 KiB
C++
1017 lines
40 KiB
C++
#include <sys/stat.h>
|
|
#include "output_http_internal.h"
|
|
#include <mist/stream.h>
|
|
#include <mist/encode.h>
|
|
#include <mist/langcodes.h>
|
|
#include <mist/url.h>
|
|
#include "flashPlayer.h"
|
|
#include "oldFlashPlayer.h"
|
|
#include <mist/websocket.h>
|
|
#include <mist/triggers.h>
|
|
|
|
namespace Mist {
|
|
/// Helper function to find the protocol entry for a given port number
|
|
std::string getProtocolForPort(uint16_t portNo){
|
|
std::string ret;
|
|
Util::DTSCShmReader rCapa(SHM_CAPA);
|
|
DTSC::Scan conns = rCapa.getMember("connectors");
|
|
Util::DTSCShmReader rProto(SHM_PROTO);
|
|
DTSC::Scan prtcls = rProto.getScan();
|
|
unsigned int pro_cnt = prtcls.getSize();
|
|
for (unsigned int i = 0; i < pro_cnt; ++i){
|
|
DTSC::Scan capa = conns.getMember(prtcls.getIndice(i).getMember("connector").asString());
|
|
uint16_t port = prtcls.getIndice(i).getMember("port").asInt();
|
|
//get the default port if none is set
|
|
if (!port){
|
|
port = capa.getMember("optional").getMember("port").getMember("default").asInt();
|
|
}
|
|
if (port == portNo){
|
|
ret = capa.getMember("protocol").asString();
|
|
break;
|
|
}
|
|
}
|
|
if (ret.find(':') != std::string::npos){
|
|
ret.erase(ret.find(':'));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OutHTTP::OutHTTP(Socket::Connection & conn) : HTTPOutput(conn){
|
|
stayConnected = false;
|
|
//If this connection is a socket and not already connected to stdio, connect it to stdio.
|
|
if (myConn.getPureSocket() != -1 && myConn.getSocket() != STDIN_FILENO && myConn.getSocket() != STDOUT_FILENO){
|
|
std::string host = getConnectedHost();
|
|
dup2(myConn.getSocket(), STDIN_FILENO);
|
|
dup2(myConn.getSocket(), STDOUT_FILENO);
|
|
myConn.open(STDOUT_FILENO, STDIN_FILENO);
|
|
myConn.setHost(host);
|
|
}
|
|
if (config->getString("nostreamtext").size()){
|
|
setenv("MIST_HTTP_nostreamtext", config->getString("nostreamtext").c_str(), 1);
|
|
}
|
|
if (config->getString("pubaddr").size()){
|
|
std::string pubAddrs = config->getOption("pubaddr", true).toString();
|
|
setenv("MIST_HTTP_pubaddr", pubAddrs.c_str(), 1);
|
|
}
|
|
if (config->getOption("wrappers",true).size() == 0 || config->getString("wrappers") == ""){
|
|
JSON::Value & wrappers = config->getOption("wrappers",true);
|
|
wrappers.shrink(0);
|
|
jsonForEach(capa["optional"]["wrappers"]["allowed"],it){
|
|
wrappers.append(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
OutHTTP::~OutHTTP() {}
|
|
|
|
bool OutHTTP::listenMode(){
|
|
return !(config->getString("ip").size());
|
|
}
|
|
|
|
void OutHTTP::onFail(const std::string & msg, bool critical){
|
|
std::string method = H.method;
|
|
// send logo icon
|
|
if (H.url.length() > 4 && H.url.substr(H.url.length() - 4, 4) == ".ico"){
|
|
sendIcon();
|
|
return;
|
|
}
|
|
if (H.url.length() > 6 && H.url.substr(H.url.length() - 5, 5) == ".html"){
|
|
HTMLResponse();
|
|
return;
|
|
}
|
|
if (H.url.size() >= 3 && H.url.substr(H.url.size() - 3) == ".js"){
|
|
if (websocketHandler()){return;}
|
|
JSON::Value json_resp;
|
|
json_resp["error"] = "Could not retrieve stream. Sorry.";
|
|
json_resp["error_guru"] = msg;
|
|
if (config->getString("nostreamtext") != ""){
|
|
json_resp["on_error"] = config->getString("nostreamtext");
|
|
}
|
|
if (H.url.size() >= 5 && H.url.substr(0, 5) == "/json"){
|
|
H.Clean();
|
|
H.SetBody(json_resp.toString());
|
|
}else{
|
|
H.Clean();
|
|
H.SetBody("if (!mistvideo){var mistvideo = {};}\nmistvideo['" + streamName + "'] = "+json_resp.toString()+";\n");
|
|
}
|
|
H.setCORSHeaders();
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
H.SendResponse("200", "Stream not found", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
HTTPOutput::onFail(msg, critical);
|
|
}
|
|
|
|
void OutHTTP::init(Util::Config * cfg){
|
|
HTTPOutput::init(cfg);
|
|
capa.removeMember("deps");
|
|
capa["name"] = "HTTP";
|
|
capa["friendly"] = "HTTP";
|
|
capa["desc"] = "HTTP connection handler, provides all enabled HTTP-based outputs";
|
|
capa["provides"] = "HTTP";
|
|
capa["protocol"] = "http://";
|
|
capa["codecs"][0u][0u].append("*");
|
|
capa["url_rel"] = "/$.html";
|
|
capa["url_match"].append("/crossdomain.xml");
|
|
capa["url_match"].append("/clientaccesspolicy.xml");
|
|
capa["url_match"].append("/$.html");
|
|
capa["url_match"].append("/favicon.ico");
|
|
capa["url_match"].append("/$.smil");
|
|
capa["url_match"].append("/info_$.js");
|
|
capa["url_match"].append("/json_$.js");
|
|
capa["url_match"].append("/player.js");
|
|
capa["url_match"].append("/videojs.js");
|
|
capa["url_match"].append("/dashjs.js");
|
|
capa["url_match"].append("/webrtc.js");
|
|
capa["url_match"].append("/skins/default.css");
|
|
capa["url_match"].append("/skins/dev.css");
|
|
capa["url_match"].append("/skins/videojs.css");
|
|
capa["url_match"].append("/embed_$.js");
|
|
capa["url_match"].append("/flashplayer.swf");
|
|
capa["url_match"].append("/oldflashplayer.swf");
|
|
capa["url_prefix"] = "/.well-known/";
|
|
capa["optional"]["wrappers"]["name"] = "Active players";
|
|
capa["optional"]["wrappers"]["help"] = "Which players are attempted and in what order.";
|
|
capa["optional"]["wrappers"]["default"] = "";
|
|
capa["optional"]["wrappers"]["type"] = "ord_multi_sel";
|
|
capa["optional"]["wrappers"]["allowed"].append("html5");
|
|
capa["optional"]["wrappers"]["allowed"].append("videojs");
|
|
capa["optional"]["wrappers"]["allowed"].append("dashjs");
|
|
capa["optional"]["wrappers"]["allowed"].append("webrtc");
|
|
capa["optional"]["wrappers"]["allowed"].append("flash_strobe");
|
|
capa["optional"]["wrappers"]["option"] = "--wrappers";
|
|
capa["optional"]["wrappers"]["short"] = "w";
|
|
capa["optional"]["certbot"]["name"] = "Certbot validation token";
|
|
capa["optional"]["certbot"]["help"] = "Automatically set by the MistUtilCertbot authentication hook for certbot. Not intended to be set manually.";
|
|
capa["optional"]["certbot"]["default"] = "";
|
|
capa["optional"]["certbot"]["type"] = "str";
|
|
capa["optional"]["certbot"]["option"] = "--certbot";
|
|
capa["optional"]["certbot"]["short"] = "C";
|
|
cfg->addConnectorOptions(8080, capa);
|
|
/*LTS-START*/
|
|
cfg->addOption("nostreamtext", JSON::fromString("{\"arg\":\"string\", \"default\":\"\", \"short\":\"t\",\"long\":\"nostreamtext\",\"help\":\"Text or HTML to display when streams are unavailable.\"}"));
|
|
capa["optional"]["nostreamtext"]["name"] = "Stream unavailable text";
|
|
capa["optional"]["nostreamtext"]["help"] = "Text or HTML to display when streams are unavailable.";
|
|
capa["optional"]["nostreamtext"]["default"] = "";
|
|
capa["optional"]["nostreamtext"]["type"] = "str";
|
|
capa["optional"]["nostreamtext"]["option"] = "--nostreamtext";
|
|
/*LTS-END*/
|
|
cfg->addOption("pubaddr", JSON::fromString("{\"arg\":\"string\", \"default\":\"\", \"short\":\"A\",\"long\":\"public-address\",\"help\":\"Full public address this output is available as.\"}"));
|
|
capa["optional"]["pubaddr"]["name"] = "Public address";
|
|
capa["optional"]["pubaddr"]["help"] = "Full public address this output is available as, if being proxied";
|
|
capa["optional"]["pubaddr"]["default"] = "";
|
|
capa["optional"]["pubaddr"]["type"] = "inputlist";
|
|
capa["optional"]["pubaddr"]["option"] = "--public-address";
|
|
}
|
|
|
|
/// Sorts the JSON::Value objects that hold source information by preference.
|
|
struct sourceCompare {
|
|
bool operator() (const JSON::Value& lhs, const JSON::Value& rhs) const {
|
|
//first compare simultaneous tracks
|
|
if (lhs["simul_tracks"].asInt() > rhs["simul_tracks"].asInt()){
|
|
//more tracks = higher priority = true.
|
|
return true;
|
|
}
|
|
if (lhs["simul_tracks"].asInt() < rhs["simul_tracks"].asInt()){
|
|
//less tracks = lower priority = false
|
|
return false;
|
|
}
|
|
//same amount of tracks - compare "hardcoded" priorities
|
|
if (lhs["priority"].asInt() > rhs["priority"].asInt()){
|
|
//higher priority = true.
|
|
return true;
|
|
}
|
|
if (lhs["priority"].asInt() < rhs["priority"].asInt()){
|
|
//lower priority = false
|
|
return false;
|
|
}
|
|
//same priority - compare total matches
|
|
if (lhs["total_matches"].asInt() > rhs["total_matches"].asInt()){
|
|
//more matches = higher priority = true.
|
|
return true;
|
|
}
|
|
if (lhs["total_matches"].asInt() < rhs["total_matches"].asInt()){
|
|
//less matches = lower priority = false
|
|
return false;
|
|
}
|
|
//also same amount of matches? just compare the URL then.
|
|
return lhs["url"].asStringRef() < rhs["url"].asStringRef();
|
|
}
|
|
};
|
|
|
|
void addSource(const std::string & rel, std::set<JSON::Value, sourceCompare> & sources, const HTTP::URL & url, JSON::Value & conncapa, unsigned int most_simul, unsigned int total_matches){
|
|
JSON::Value tmp;
|
|
tmp["type"] = conncapa["type"];
|
|
tmp["relurl"] = rel;
|
|
tmp["priority"] = conncapa["priority"];
|
|
if (conncapa.isMember("player_url")){tmp["player_url"] = conncapa["player_url"].asStringRef();}
|
|
tmp["simul_tracks"] = most_simul;
|
|
tmp["total_matches"] = total_matches;
|
|
tmp["url"] = url.link(rel).getUrl();
|
|
sources.insert(tmp);
|
|
}
|
|
|
|
void addSources(std::string & streamname, std::set<JSON::Value, sourceCompare> & sources, HTTP::URL url, JSON::Value & conncapa, JSON::Value & strmMeta, const std::string & useragent){
|
|
url.path += "/";
|
|
if (strmMeta.isMember("live") && conncapa.isMember("exceptions") && conncapa["exceptions"].isObject() && conncapa["exceptions"].size()){
|
|
jsonForEach(conncapa["exceptions"], ex){
|
|
if (ex.key() == "live"){
|
|
if (!Util::checkException(*ex, useragent)){
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const std::string & rel = conncapa["url_rel"].asStringRef();
|
|
unsigned int most_simul = 0;
|
|
unsigned int total_matches = 0;
|
|
if (conncapa.isMember("codecs") && conncapa["codecs"].size() > 0){
|
|
jsonForEach(conncapa["codecs"], it) {
|
|
unsigned int simul = 0;
|
|
if ((*it).size() > 0){
|
|
jsonForEach((*it), itb) {
|
|
unsigned int matches = 0;
|
|
if ((*itb).size() > 0){
|
|
jsonForEach((*itb), itc) {
|
|
const std::string & strRef = (*itc).asStringRef();
|
|
bool byType = false;
|
|
bool multiSel = false;
|
|
uint8_t shift = 0;
|
|
if (strRef[shift] == '@'){byType = true; ++shift;}
|
|
if (strRef[shift] == '+'){multiSel = true; ++shift;}
|
|
jsonForEach(strmMeta["tracks"], trit) {
|
|
if ((!byType && (*trit)["codec"].asStringRef() == strRef.substr(shift)) || (byType && (*trit)["type"].asStringRef() == strRef.substr(shift)) || strRef.substr(shift) == "*"){
|
|
matches++;
|
|
total_matches++;
|
|
if (conncapa.isMember("exceptions") && conncapa["exceptions"].isObject() && conncapa["exceptions"].size()){
|
|
jsonForEach(conncapa["exceptions"], ex){
|
|
if (ex.key() == "codec:"+strRef.substr(shift)){
|
|
if (!Util::checkException(*ex, useragent)){
|
|
matches--;
|
|
total_matches--;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (matches){
|
|
simul++;
|
|
}
|
|
}
|
|
}
|
|
if (simul > most_simul){
|
|
most_simul = simul;
|
|
}
|
|
}
|
|
}
|
|
if (conncapa.isMember("methods") && conncapa["methods"].size() > 0){
|
|
std::string relurl;
|
|
size_t found = rel.find('$');
|
|
if (found != std::string::npos){
|
|
relurl = rel.substr(1, found-1) + Encodings::URL::encode(streamname) + rel.substr(found+1);
|
|
}else{
|
|
relurl = "";
|
|
}
|
|
jsonForEach(conncapa["methods"], it) {
|
|
if (it->isMember("url_rel")){
|
|
size_t foundb = (*it)["url_rel"].asStringRef().find('$');
|
|
if (foundb != std::string::npos){
|
|
relurl = (*it)["url_rel"].asStringRef().substr(1, foundb-1) + Encodings::URL::encode(streamname) + (*it)["url_rel"].asStringRef().substr(foundb+1);
|
|
}
|
|
}
|
|
if (!strmMeta.isMember("live") || !it->isMember("nolive")){
|
|
if (!url.protocol.size() && it->isMember("handler")){
|
|
url.protocol = (*it)["handler"].asStringRef();
|
|
}
|
|
addSource(relurl, sources, url, *it, most_simul, total_matches);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OutHTTP::HTMLResponse(){
|
|
std::string method = H.method;
|
|
HTTP::URL fullURL(H.GetHeader("Host"));
|
|
if (!fullURL.protocol.size()){
|
|
fullURL.protocol = getProtocolForPort(fullURL.getPort());
|
|
}
|
|
if (config->getString("pubaddr") != ""){
|
|
HTTP::URL altURL(config->getString("pubaddr"));
|
|
fullURL.protocol = altURL.protocol;
|
|
if (altURL.host.size()){fullURL.host = altURL.host;}
|
|
fullURL.port = altURL.port;
|
|
fullURL.path = altURL.path;
|
|
}
|
|
if (mistPath.size()){fullURL = mistPath;}
|
|
std::string uAgent = H.GetHeader("User-Agent");
|
|
|
|
std::string forceType = "";
|
|
if (H.GetVar("forcetype").size()) { forceType = ",forceType:\""+H.GetVar("forcetype")+"\""; }
|
|
|
|
std::string devSkin = "";
|
|
if (H.GetVar("dev").size()) { devSkin = ",skin:\"dev\""; }
|
|
H.SetVar("stream", "");
|
|
H.SetVar("dev", "");
|
|
devSkin += ",urlappend:\"" + H.allVars() + "\"";
|
|
H.SetVar("stream", streamName);
|
|
|
|
std::string seekTo = "";
|
|
if (H.GetVar("t").size()){
|
|
uint64_t autoSeekTime = 0;
|
|
std::string sTime = H.GetVar("t");
|
|
unsigned long long h = 0, m = 0, s = 0;
|
|
autoSeekTime = JSON::Value(sTime).asInt();
|
|
if (sscanf(sTime.c_str(), "%llum%llus", &m, &s) == 2){autoSeekTime = m*60+s;}
|
|
if (sscanf(sTime.c_str(), "%llu:%llu", &m, &s) == 2){autoSeekTime = m*60+s;}
|
|
if (sscanf(sTime.c_str(), "%lluh%llum%llus", &h, &m, &s) == 3){autoSeekTime = h*3600+m*60+s;}
|
|
if (sscanf(sTime.c_str(), "%llu:%llu:%llu", &h, &m, &s) == 3){autoSeekTime = h*3600+m*60+s;}
|
|
if (autoSeekTime){
|
|
seekTo = "var f = function(){ if (mv.reference && mv.reference.player && mv.reference.player.api) { mv.reference.player.api.currentTime = "+JSON::Value(autoSeekTime).toString()+"; } this.removeEventListener(\"initialized\",f); }; document.getElementById(\""+streamName+"\").addEventListener(\"initialized\",f);";
|
|
}
|
|
}
|
|
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "text/html");
|
|
H.SetHeader("X-UA-Compatible", "IE=edge");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
std::string hlsUrl = "/hls/"+streamName+"/index.m3u8";
|
|
std::string mp4Url = "/"+streamName+".mp4";
|
|
|
|
H.SetBody("<!DOCTYPE html><html><head><title>"+streamName+"</title><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><style>html{margin:0;padding:0;display:table;width:100%;height:100%;}body{color:white;background:#0f0f0f;margin:0;padding:0;display:table-cell;vertical-align:middle;text-align:center}body>div>div{text-align:left;}</style></head><body><div class=mistvideo id=\""+streamName+"\"><noscript><video controls autoplay><source src=\""+hlsUrl+"\" type=\"application/vnd.apple.mpegurl\"><source src=\""+mp4Url+"\" type=\"video/mp4\"><a href=\""+hlsUrl+"\">Click here to play the video [Apple]</a><br><a href=\""+mp4Url+"\">Click here to play the video [MP4]</a></video></noscript><script src=\"player.js\"></script><script>var mv = {reference:false}; mistPlay('"+streamName+"',{host:'"+fullURL.getUrl()+"',target:document.getElementById('"+streamName+"'),MistVideoObject:mv"+forceType+devSkin+"});"+seekTo+"</script></div></body></html>");
|
|
if ((uAgent.find("iPad") != std::string::npos) || (uAgent.find("iPod") != std::string::npos) || (uAgent.find("iPhone") != std::string::npos)) {
|
|
H.SetHeader("Location",hlsUrl);
|
|
H.SendResponse("307", "HLS redirect", myConn);
|
|
return;
|
|
}
|
|
H.SendResponse("200", "OK", myConn);
|
|
}
|
|
|
|
JSON::Value OutHTTP::getStatusJSON(std::string & reqHost, const std::string & useragent){
|
|
JSON::Value json_resp;
|
|
if (config->getString("nostreamtext") != ""){
|
|
json_resp["on_error"] = config->getString("nostreamtext");
|
|
}
|
|
//Make note of any defaultStream-based redirection
|
|
if (origStreamName.size() && origStreamName != streamName){
|
|
json_resp["redirected"].append(origStreamName);
|
|
json_resp["redirected"].append(streamName);
|
|
}
|
|
uint8_t streamStatus = Util::getStreamStatus(streamName);
|
|
if (streamStatus != STRMSTAT_READY){
|
|
//If we haven't rewritten the stream name yet to a fallback, attempt to do so
|
|
if (origStreamName == streamName){
|
|
JSON::Value defStrmJson = Util::getGlobalConfig("defaultStream");
|
|
std::string defStrm = defStrmJson.asString();
|
|
if(Triggers::shouldTrigger("DEFAULT_STREAM", streamName)){
|
|
std::string payload = defStrm+"\n"+streamName+"\n" + getConnectedHost() +"\n"+capa["name"].asStringRef()+"\n"+reqUrl;
|
|
//The return value is ignored, because the response (defStrm in this case) tells us what to do next, if anything.
|
|
Triggers::doTrigger("DEFAULT_STREAM", payload, streamName, false, defStrm);
|
|
}
|
|
if (defStrm.size()){
|
|
std::string newStrm = defStrm;
|
|
Util::streamVariables(newStrm, streamName, "");
|
|
if (streamName != newStrm){
|
|
INFO_MSG("Falling back to default stream '%s' -> '%s'", defStrm.c_str(), newStrm.c_str());
|
|
origStreamName = streamName;
|
|
streamName = newStrm;
|
|
Util::Config::streamName = streamName;
|
|
reconnect();
|
|
return getStatusJSON(reqHost, useragent);
|
|
}
|
|
}
|
|
origStreamName.clear();//no fallback, don't check again
|
|
}
|
|
switch (streamStatus){
|
|
case STRMSTAT_OFF:
|
|
json_resp["error"] = "Stream is offline";
|
|
break;
|
|
case STRMSTAT_INIT:
|
|
json_resp["error"] = "Stream is initializing";
|
|
break;
|
|
case STRMSTAT_BOOT:
|
|
json_resp["error"] = "Stream is booting";
|
|
break;
|
|
case STRMSTAT_WAIT:
|
|
json_resp["error"] = "Stream is waiting for data";
|
|
break;
|
|
case STRMSTAT_SHUTDOWN:
|
|
json_resp["error"] = "Stream is shutting down";
|
|
break;
|
|
case STRMSTAT_INVALID:
|
|
json_resp["error"] = "Stream status is invalid?!";
|
|
break;
|
|
default:
|
|
json_resp["error"] = "Stream status is unknown?!";
|
|
break;
|
|
}
|
|
return json_resp;
|
|
}
|
|
initialize();
|
|
if (!myConn){
|
|
return json_resp;
|
|
}
|
|
|
|
bool hasVideo = false;
|
|
for (std::map<unsigned int, DTSC::Track>::iterator trit = myMeta.tracks.begin(); trit != myMeta.tracks.end(); trit++){
|
|
if (trit->second.type == "video"){
|
|
hasVideo = true;
|
|
if (trit->second.width > json_resp["width"].asInt()){
|
|
json_resp["width"] = trit->second.width;
|
|
}
|
|
if (trit->second.height > json_resp["height"].asInt()){
|
|
json_resp["height"] = trit->second.height;
|
|
}
|
|
}
|
|
}
|
|
if (json_resp["width"].asInt() < 1 || json_resp["height"].asInt() < 1){
|
|
json_resp["width"] = 640;
|
|
json_resp["height"] = 480;
|
|
if (!hasVideo){json_resp["height"] = 20;}
|
|
}
|
|
if (myMeta.vod){
|
|
json_resp["type"] = "vod";
|
|
}
|
|
if (myMeta.live){
|
|
json_resp["type"] = "live";
|
|
}
|
|
|
|
// show ALL the meta datas!
|
|
json_resp["meta"] = myMeta.toJSON();
|
|
jsonForEach(json_resp["meta"]["tracks"], it) {
|
|
if (it->isMember("lang")){
|
|
(*it)["language"] = Encodings::ISO639::decode((*it)["lang"].asStringRef());
|
|
}
|
|
it->removeMember("fragments");
|
|
it->removeMember("keys");
|
|
it->removeMember("keysizes");
|
|
it->removeMember("parts");
|
|
it->removeMember("ivecs");/*LTS*/
|
|
}
|
|
json_resp["meta"].removeMember("source");
|
|
|
|
//Get sources/protocols information
|
|
Util::DTSCShmReader rCapa(SHM_CAPA);
|
|
DTSC::Scan connectors = rCapa.getMember("connectors");
|
|
Util::DTSCShmReader rProto(SHM_PROTO);
|
|
DTSC::Scan prots = rProto.getScan();
|
|
if (!prots || !connectors){
|
|
json_resp["error"] = "Server configuration unavailable at this time.";
|
|
return json_resp;
|
|
}
|
|
|
|
//create a set for storing source information
|
|
std::set<JSON::Value, sourceCompare> sources;
|
|
|
|
//find out which connectors are enabled
|
|
std::set<std::string> conns;
|
|
unsigned int prots_ctr = prots.getSize();
|
|
for (unsigned int i = 0; i < prots_ctr; ++i){
|
|
conns.insert(prots.getIndice(i).getMember("connector").asString());
|
|
}
|
|
//loop over the connectors.
|
|
for (unsigned int i = 0; i < prots_ctr; ++i){
|
|
std::string cName = prots.getIndice(i).getMember("connector").asString();
|
|
DTSC::Scan capa = connectors.getMember(cName);
|
|
//if the connector has a port,
|
|
if (capa.getMember("optional").getMember("port")){
|
|
HTTP::URL outURL(reqHost);
|
|
//get the default port if none is set
|
|
outURL.port = prots.getIndice(i).getMember("port").asString();
|
|
if (!outURL.port.size()){
|
|
outURL.port = capa.getMember("optional").getMember("port").getMember("default").asString();
|
|
}
|
|
outURL.protocol = capa.getMember("protocol").asString();
|
|
if (outURL.protocol.find(':') != std::string::npos){
|
|
outURL.protocol.erase(outURL.protocol.find(':'));
|
|
}
|
|
JSON::Value pubAddrs;
|
|
pubAddrs.append("");
|
|
if (prots.getIndice(i).hasMember("pubaddr") && prots.getIndice(i).getMember("pubaddr").getType() == DTSC_STR){
|
|
if (prots.getIndice(i).getMember("pubaddr").asString().size()){
|
|
pubAddrs[0u] = prots.getIndice(i).getMember("pubaddr").asString();
|
|
}
|
|
}
|
|
if (prots.getIndice(i).hasMember("pubaddr") && prots.getIndice(i).getMember("pubaddr").getType() == DTSC_ARR){
|
|
pubAddrs = prots.getIndice(i).getMember("pubaddr").asJSON();
|
|
if (!pubAddrs.size()){pubAddrs.append("");}
|
|
}
|
|
if (mistPath.size()){
|
|
pubAddrs.null();
|
|
pubAddrs.append(mistPath);
|
|
}
|
|
//and a URL - then list the URL
|
|
JSON::Value capa_json = capa.asJSON();
|
|
if (capa.getMember("url_rel") || capa.getMember("methods")){
|
|
jsonForEach(pubAddrs, jit){
|
|
HTTP::URL altURL = outURL;
|
|
if (jit->asString().size()){altURL = jit->asString();}
|
|
if (!altURL.host.size()){altURL.host = outURL.host;}
|
|
if (!altURL.protocol.size()){altURL.protocol = outURL.protocol;}
|
|
addSources(streamName, sources, altURL, capa_json, json_resp["meta"], useragent);
|
|
}
|
|
}
|
|
//Make note if this connector can be depended upon by other connectors
|
|
if (capa.getMember("provides")){
|
|
std::string cProv = capa.getMember("provides").asString();
|
|
//if this connector can be depended upon by other connectors, loop over the rest
|
|
//check each enabled protocol separately to see if it depends on this connector
|
|
unsigned int capa_lst_ctr = connectors.getSize();
|
|
for (unsigned int j = 0; j < capa_lst_ctr; ++j){
|
|
//if it depends on this connector and has a URL, list it
|
|
if (conns.count(connectors.getIndiceName(j)) && connectors.getIndice(j).getMember("deps").asString() == cProv && connectors.getIndice(j).getMember("methods")){
|
|
JSON::Value subcapa_json = connectors.getIndice(j).asJSON();
|
|
|
|
jsonForEach(pubAddrs, jit){
|
|
HTTP::URL altURL = outURL;
|
|
if (jit->asString().size()){altURL = jit->asString();}
|
|
if (!altURL.host.size()){altURL.host = outURL.host;}
|
|
if (!altURL.protocol.size()){altURL.protocol = outURL.protocol;}
|
|
addSources(streamName, sources, altURL, subcapa_json, json_resp["meta"], useragent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//loop over the added sources, add them to json_resp["sources"]
|
|
for (std::set<JSON::Value, sourceCompare>::iterator it = sources.begin(); it != sources.end(); it++){
|
|
if ((*it)["simul_tracks"].asInt() > 0){
|
|
json_resp["source"].append(*it);
|
|
}
|
|
}
|
|
return json_resp;
|
|
}
|
|
|
|
void OutHTTP::onHTTP(){
|
|
origStreamName = streamName;
|
|
std::string method = H.method;
|
|
|
|
if (H.GetHeader("X-Mst-Path").size()){mistPath = H.GetHeader("X-Mst-Path");}
|
|
|
|
//Handle certbot validations
|
|
if (H.url.substr(0, 28) == "/.well-known/acme-challenge/"){
|
|
std::string cbToken = H.url.substr(28);
|
|
jsonForEach(config->getOption("certbot",true),it){
|
|
if (it->asStringRef().substr(0, cbToken.size()+1) == cbToken+":"){
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "text/plain");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
H.SetBody(it->asStringRef().substr(cbToken.size()+1));
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
}
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "text/plain");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
H.SetBody("No matching validation found for token '" + cbToken + "'");
|
|
H.SendResponse("404", "Not found", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
if (H.url == "/crossdomain.xml"){
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "text/xml");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
H.SetBody("<?xml version=\"1.0\"?><!DOCTYPE cross-domain-policy SYSTEM \"http://www.adobe.com/xml/dtds/cross-domain-policy.dtd\"><cross-domain-policy><allow-access-from domain=\"*\" /><site-control permitted-cross-domain-policies=\"all\"/></cross-domain-policy>");
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
} //crossdomain.xml
|
|
|
|
if (H.url == "/clientaccesspolicy.xml"){
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "text/xml");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
H.SetBody("<?xml version=\"1.0\" encoding=\"utf-8\"?><access-policy><cross-domain-access><policy><allow-from http-methods=\"*\" http-request-headers=\"*\"><domain uri=\"*\"/></allow-from><grant-to><resource path=\"/\" include-subpaths=\"true\"/></grant-to></policy></cross-domain-access></access-policy>");
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
} //clientaccesspolicy.xml
|
|
|
|
if (H.url == "/flashplayer.swf"){
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "application/x-shockwave-flash");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.SetBody((const char*)FlashMediaPlayback_101_swf, FlashMediaPlayback_101_swf_len);
|
|
H.SendResponse("200", "OK", myConn);
|
|
return;
|
|
}
|
|
if (H.url == "/oldflashplayer.swf"){
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "application/x-shockwave-flash");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.SetBody((const char *)FlashMediaPlayback_swf, FlashMediaPlayback_swf_len);
|
|
H.SendResponse("200", "OK", myConn);
|
|
return;
|
|
|
|
}
|
|
// send logo icon
|
|
if (H.url.length() > 4 && H.url.substr(H.url.length() - 4, 4) == ".ico"){
|
|
sendIcon();
|
|
return;
|
|
}
|
|
|
|
// send generic HTML page
|
|
if (H.url.length() > 6 && H.url.substr(H.url.length() - 5, 5) == ".html"){
|
|
HTMLResponse();
|
|
return;
|
|
}
|
|
|
|
// send smil MBR index
|
|
if (H.url.length() > 6 && H.url.substr(H.url.length() - 5, 5) == ".smil"){
|
|
std::string reqHost = HTTP::URL(H.GetHeader("Host")).host;
|
|
std::string port, url_rel;
|
|
std::string trackSources;//this string contains all track sources for MBR smil
|
|
{
|
|
Util::DTSCShmReader rProto(SHM_PROTO);
|
|
DTSC::Scan prtcls = rProto.getScan();
|
|
Util::DTSCShmReader rCapa(SHM_CAPA);
|
|
DTSC::Scan capa = rCapa.getMember("connectors").getMember("RTMP");
|
|
unsigned int pro_cnt = prtcls.getSize();
|
|
for (unsigned int i = 0; i < pro_cnt; ++i){
|
|
if (prtcls.getIndice(i).getMember("connector").asString() != "RTMP"){
|
|
continue;
|
|
}
|
|
port = prtcls.getIndice(i).getMember("port").asString();
|
|
//get the default port if none is set
|
|
if (!port.size()){
|
|
port = capa.getMember("optional").getMember("port").getMember("default").asString();
|
|
}
|
|
//extract url
|
|
url_rel = capa.getMember("url_rel").asString();
|
|
if (url_rel.find('$')){
|
|
url_rel.resize(url_rel.find('$'));
|
|
}
|
|
}
|
|
|
|
initialize();
|
|
if (!myConn){return;}
|
|
for (std::map<unsigned int, DTSC::Track>::iterator trit = myMeta.tracks.begin(); trit != myMeta.tracks.end(); trit++){
|
|
if (trit->second.type == "video"){
|
|
trackSources += " <video src='"+ streamName + "?track=" + JSON::Value(trit->first).asString() + "' height='" + JSON::Value(trit->second.height).asString() + "' system-bitrate='" + JSON::Value(trit->second.bps).asString() + "' width='" + JSON::Value(trit->second.width).asString() + "' />\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
H.Clean();
|
|
H.SetHeader("Content-Type", "application/smil");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
H.SetBody("<smil>\n <head>\n <meta base='rtmp://" + reqHost + ":" + port + url_rel + "' />\n </head>\n <body>\n <switch>\n"+trackSources+" </switch>\n </body>\n</smil>");
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
if ((H.url.length() > 9 && H.url.substr(0, 6) == "/info_" && H.url.substr(H.url.length() - 3, 3) == ".js") || (H.url.length() > 9 && H.url.substr(0, 6) == "/json_" && H.url.substr(H.url.length() - 3, 3) == ".js")){
|
|
if (websocketHandler()){return;}
|
|
std::string reqHost = HTTP::URL(H.GetHeader("Host")).host;
|
|
std::string useragent = H.GetVar("ua");
|
|
if (!useragent.size()){
|
|
useragent = H.GetHeader("User-Agent");
|
|
}
|
|
std::string response;
|
|
std::string rURL = H.url;
|
|
if(method != "OPTIONS" && method != "HEAD"){
|
|
initialize();
|
|
}
|
|
H.Clean();
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
if (rURL.substr(0, 6) != "/json_"){
|
|
H.SetHeader("Content-Type", "application/javascript");
|
|
}else{
|
|
H.SetHeader("Content-Type", "application/json");
|
|
}
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
response = "// Generating info code for stream " + streamName + "\n\nif (!mistvideo){var mistvideo = {};}\n";
|
|
JSON::Value json_resp = getStatusJSON(reqHost, useragent);
|
|
if (rURL.substr(0, 6) != "/json_"){
|
|
response += "mistvideo['" + streamName + "'] = " + json_resp.toString() + ";\n";
|
|
}else{
|
|
response = json_resp.toString();
|
|
}
|
|
H.SetBody(response);
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
} //embed code generator
|
|
|
|
if ((H.url == "/player.js") || ((H.url.substr(0, 7) == "/embed_") && (H.url.length() > 10) && (H.url.substr(H.url.length() - 3, 3) == ".js"))){
|
|
HTTP::URL fullURL(H.GetHeader("Host"));
|
|
if (!fullURL.protocol.size()){
|
|
fullURL.protocol = getProtocolForPort(fullURL.getPort());
|
|
}
|
|
if (config->getString("pubaddr") != ""){
|
|
HTTP::URL altURL(config->getString("pubaddr"));
|
|
fullURL.protocol = altURL.protocol;
|
|
if (altURL.host.size()){fullURL.host = altURL.host;}
|
|
fullURL.port = altURL.port;
|
|
fullURL.path = altURL.path;
|
|
}
|
|
if (mistPath.size()){fullURL = mistPath;}
|
|
std::string response;
|
|
std::string rURL = H.url;
|
|
H.Clean();
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
H.SetHeader("Content-Type", "application/javascript; charset=utf-8");
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
response.append("if (typeof mistoptions == 'undefined') { mistoptions = {}; }\nif (!('host' in mistoptions)) { mistoptions.host = '"+fullURL.getUrl()+"'; }\n");
|
|
|
|
#include "player.js.h"
|
|
response.append((char*)player_js, (size_t)player_js_len);
|
|
|
|
jsonForEach(config->getOption("wrappers",true),it){
|
|
bool used = false;
|
|
if (it->asStringRef() == "html5"){
|
|
#include "html5.js.h"
|
|
response.append((char*)html5_js, (size_t)html5_js_len);
|
|
used = true;
|
|
}
|
|
if (it->asStringRef() == "flash_strobe"){
|
|
#include "flash_strobe.js.h"
|
|
response.append((char*)flash_strobe_js, (size_t)flash_strobe_js_len);
|
|
used = true;
|
|
}
|
|
if (it->asStringRef() == "dashjs"){
|
|
#include "dashjs.js.h"
|
|
response.append((char*)dash_js, (size_t)dash_js_len);
|
|
used = true;
|
|
}
|
|
if (it->asStringRef() == "videojs"){
|
|
#include "videojs.js.h"
|
|
response.append((char*)video_js, (size_t)video_js_len);
|
|
used = true;
|
|
}
|
|
if (it->asStringRef() == "webrtc"){
|
|
#include "webrtc.js.h"
|
|
response.append((char*)webrtc_js, (size_t)webrtc_js_len);
|
|
used = true;
|
|
}
|
|
if (!used) {
|
|
WARN_MSG("Unknown player type: %s",it->asStringRef().c_str());
|
|
}
|
|
}
|
|
|
|
if ((rURL.substr(0, 7) == "/embed_") && (rURL.length() > 10) && (rURL.substr(rURL.length() - 3, 3) == ".js")){
|
|
response.append("var container = document.createElement(\"div\");\ncontainer.id = \""+streamName+"\";\ndocument.write(container.outerHTML);\nmistPlay(\""+streamName+"\",{target:document.getElementById(\""+streamName+"\")});");
|
|
}
|
|
|
|
H.SetBody(response);
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
|
|
}
|
|
|
|
if (H.url.substr(0, 7) == "/skins/"){
|
|
std::string response;
|
|
std::string url = H.url;
|
|
H.Clean();
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
H.SetHeader("Content-Type", "text/css");
|
|
if (method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
if (url == "/skins/default.css") {
|
|
#include "skin_default.css.h"
|
|
response.append((char*)skin_default_css, (size_t)skin_default_css_len);
|
|
}
|
|
else if (url == "/skins/dev.css") {
|
|
#include "skin_dev.css.h"
|
|
response.append((char*)skin_dev_css, (size_t)skin_dev_css_len);
|
|
}
|
|
else if (url == "/skins/videojs.css") {
|
|
#include "skin_videojs.css.h"
|
|
response.append((char*)skin_videojs_css, (size_t)skin_videojs_css_len);
|
|
}
|
|
else {
|
|
H.SetBody("Unknown stylesheet: "+url);
|
|
H.SendResponse("404", "Unknown stylesheet", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
H.SetBody(response);
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
if (H.url == "/videojs.js"){
|
|
std::string response;
|
|
H.Clean();
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
H.SetHeader("Content-Type", "application/javascript");
|
|
if (method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
#include "player_video.js.h"
|
|
response.append((char*)player_video_js, (size_t)player_video_js_len);
|
|
|
|
H.SetBody(response);
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
if (H.url == "/dashjs.js"){
|
|
std::string response;
|
|
H.Clean();
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
H.SetHeader("Content-Type", "application/javascript");
|
|
if (method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
#include "player_dash_lic.js.h"
|
|
response.append((char*)player_dash_lic_js, (size_t)player_dash_lic_js_len);
|
|
#include "player_dash.js.h"
|
|
response.append((char*)player_dash_js, (size_t)player_dash_js_len);
|
|
|
|
H.SetBody(response);
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
if (H.url == "/webrtc.js"){
|
|
std::string response;
|
|
H.Clean();
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
H.SetHeader("Content-Type", "application/javascript");
|
|
if (method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
|
|
#include "player_webrtc.js.h"
|
|
response.append((char*)player_webrtc_js, (size_t)player_webrtc_js_len);
|
|
|
|
H.SetBody(response);
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void OutHTTP::sendIcon(){
|
|
std::string method = H.method;
|
|
/*LTS-START*/
|
|
if (H.GetVar("s").size() && H.GetVar("s") == SUPER_SECRET){
|
|
H.Clean();
|
|
H.SetHeader("Server", "mistserver/" PACKAGE_VERSION);
|
|
H.setCORSHeaders();
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
H.SetBody("Yup");
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
/*LTS-END*/
|
|
H.Clean();
|
|
#include "../icon.h"
|
|
H.SetHeader("Content-Type", "image/x-icon");
|
|
H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
|
|
H.SetHeader("Content-Length", icon_len);
|
|
H.setCORSHeaders();
|
|
if(method == "OPTIONS" || method == "HEAD"){
|
|
H.SendResponse("200", "OK", myConn);
|
|
H.Clean();
|
|
return;
|
|
}
|
|
H.SendResponse("200", "OK", myConn);
|
|
myConn.SendNow((const char*)icon_data, icon_len);
|
|
H.Clean();
|
|
}
|
|
|
|
bool OutHTTP::websocketHandler(){
|
|
stayConnected = true;
|
|
std::string reqHost = HTTP::URL(H.GetHeader("Host")).host;
|
|
if (H.GetHeader("X-Mst-Path").size()){mistPath = H.GetHeader("X-Mst-Path");}
|
|
std::string useragent = H.GetVar("ua");
|
|
if (!useragent.size()){
|
|
useragent = H.GetHeader("User-Agent");
|
|
}
|
|
std::string upgradeHeader = H.GetHeader("Upgrade");
|
|
Util::stringToLower(upgradeHeader);
|
|
if (upgradeHeader != "websocket"){return false;}
|
|
HTTP::Websocket ws(myConn, H);
|
|
if (!ws){return false;}
|
|
setBlocking(false);
|
|
//start the stream, if needed
|
|
Util::startInput(streamName, "", true, false);
|
|
|
|
char pageName[NAME_BUFFER_SIZE];
|
|
std::string currStreamName;
|
|
currStreamName = streamName;
|
|
snprintf(pageName, NAME_BUFFER_SIZE, SHM_STREAM_STATE, streamName.c_str());
|
|
IPC::sharedPage streamStatus(pageName, 1, false, false);
|
|
uint8_t prevState, newState, metaCounter;
|
|
uint64_t prevTracks;
|
|
prevState = newState = STRMSTAT_INVALID;
|
|
while (keepGoing()){
|
|
if (!streamStatus || !streamStatus.exists()){streamStatus.init(pageName, 1, false, false);}
|
|
if (!streamStatus){newState = STRMSTAT_OFF;}else{newState = streamStatus.mapped[0];}
|
|
|
|
if (newState != prevState || (newState == STRMSTAT_READY && myMeta.tracks.size() != prevTracks)){
|
|
if (newState == STRMSTAT_READY){
|
|
reconnect();
|
|
updateMeta();
|
|
prevTracks = myMeta.tracks.size();
|
|
}else{
|
|
disconnect();
|
|
}
|
|
JSON::Value resp = getStatusJSON(reqHost, useragent);
|
|
if (currStreamName != streamName){
|
|
currStreamName = streamName;
|
|
snprintf(pageName, NAME_BUFFER_SIZE, SHM_STREAM_STATE, streamName.c_str());
|
|
streamStatus.close();
|
|
}
|
|
ws.sendFrame(resp.toString());
|
|
prevState = newState;
|
|
}else{
|
|
if (newState == STRMSTAT_READY){
|
|
stats();
|
|
}
|
|
if (myConn.spool() && ws.readFrame()){
|
|
onWebsocketFrame();
|
|
}else{
|
|
Util::sleep(250);
|
|
}
|
|
if (newState == STRMSTAT_READY && (++metaCounter % 4) == 0){
|
|
updateMeta();
|
|
}
|
|
if ((metaCounter % 40) == 0){
|
|
ws.sendFrame("", 0, 0x9);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|