620 lines
28 KiB
C++
620 lines
28 KiB
C++
/// \file controller.cpp
|
|
/// Contains all code for the controller executable.
|
|
|
|
#include <stdio.h>
|
|
//#include <io.h>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <sys/stat.h>
|
|
#include <mist/config.h>
|
|
#include <mist/socket.h>
|
|
#include <mist/http_parser.h>
|
|
#include <mist/procs.h>
|
|
#include <mist/auth.h>
|
|
#include <mist/timing.h>
|
|
#include <mist/converter.h>
|
|
#include <mist/stream.h>
|
|
#include "controller_storage.h"
|
|
#include "controller_connectors.h"
|
|
#include "controller_streams.h"
|
|
#include "controller_capabilities.h"
|
|
#include "server.html.h"
|
|
|
|
#define UPLINK_INTERVAL 30
|
|
|
|
#ifndef COMPILED_USERNAME
|
|
#define COMPILED_USERNAME ""
|
|
#define COMPILED_PASSWORD ""
|
|
#endif
|
|
|
|
///\brief Holds everything unique to the controller.
|
|
namespace Controller {
|
|
|
|
Secure::Auth keychecker; ///< Checks key authorization.
|
|
|
|
///\brief A class storing information about a connected user.
|
|
class ConnectedUser{
|
|
public:
|
|
Socket::Connection C;///<The socket through which the user is connected.
|
|
HTTP::Parser H;///<The HTTP::Parser associated to this user, for the lsp.
|
|
bool Authorized;///<Indicates whether the current user is authorized.
|
|
bool clientMode;///<Indicates how to parse the commands.
|
|
int logins;///<Keeps track of the amount of login-tries.
|
|
std::string Username;///<The username of the user.
|
|
|
|
///\brief Construct a new user from a connection.
|
|
///\param c The socket through which the user is connected.
|
|
ConnectedUser(Socket::Connection c){
|
|
C = c;
|
|
H.Clean();
|
|
logins = 0;
|
|
Authorized = false;
|
|
clientMode = false;
|
|
}
|
|
};
|
|
|
|
///\brief Checks an authorization request for a given user.
|
|
///\param Request The request to be parsed.
|
|
///\param Response The location to store the generated response.
|
|
///\param conn The user to be checked for authorization.
|
|
void Authorize(JSON::Value & Request, JSON::Value & Response, ConnectedUser & conn){
|
|
time_t Time = time(0);
|
|
tm * TimeInfo = localtime( &Time);
|
|
std::stringstream Date;
|
|
std::string retval;
|
|
Date << TimeInfo->tm_mday << "-" << TimeInfo->tm_mon << "-" << TimeInfo->tm_year + 1900;
|
|
std::string Challenge = Secure::md5(Date.str().c_str() + conn.C.getHost());
|
|
if (Request.isMember("authorize")){
|
|
std::string UserID = Request["authorize"]["username"];
|
|
if (Storage["account"].isMember(UserID)){
|
|
if (Secure::md5(Storage["account"][UserID]["password"].asString() + Challenge) == Request["authorize"]["password"].asString()){
|
|
Response["authorize"]["status"] = "OK";
|
|
conn.Username = UserID;
|
|
conn.Authorized = true;
|
|
return;
|
|
}
|
|
}
|
|
if (UserID != ""){
|
|
if (Request["authorize"]["password"].asString() != ""
|
|
&& Secure::md5(Storage["account"][UserID]["password"].asString()) != Request["authorize"]["password"].asString()){
|
|
Log("AUTH", "Failed login attempt " + UserID + " @ " + conn.C.getHost());
|
|
}
|
|
}
|
|
conn.logins++;
|
|
}
|
|
conn.Username = "";
|
|
conn.Authorized = false;
|
|
Response["authorize"]["status"] = "CHALL";
|
|
Response["authorize"]["challenge"] = Challenge;
|
|
return;
|
|
}
|
|
|
|
///\brief Check the submitted configuration and handle things accordingly.
|
|
///\param in The new configuration.
|
|
///\param out The location to store the resulting configuration.
|
|
void CheckConfig(JSON::Value & in, JSON::Value & out){
|
|
for (JSON::ObjIter jit = in.ObjBegin(); jit != in.ObjEnd(); jit++){
|
|
if (jit->first == "version" || jit->first == "time"){
|
|
continue;
|
|
}
|
|
if (out.isMember(jit->first)){
|
|
if (jit->second != out[jit->first]){
|
|
Log("CONF", std::string("Updated configuration value ") + jit->first);
|
|
}
|
|
}else{
|
|
Log("CONF", std::string("New configuration value ") + jit->first);
|
|
}
|
|
}
|
|
if (out["config"]["basepath"].asString()[out["config"]["basepath"].asString().size() - 1] == '/'){
|
|
out["config"]["basepath"] = out["config"]["basepath"].asString().substr(0, out["config"]["basepath"].asString().size() - 1);
|
|
}
|
|
for (JSON::ObjIter jit = out.ObjBegin(); jit != out.ObjEnd(); jit++){
|
|
if (jit->first == "version" || jit->first == "time"){
|
|
continue;
|
|
}
|
|
if ( !in.isMember(jit->first)){
|
|
Log("CONF", std::string("Deleted configuration value ") + jit->first);
|
|
}
|
|
}
|
|
out = in;
|
|
}
|
|
|
|
///\brief Parse received statistics.
|
|
///\param stats The statistics to be parsed.
|
|
void CheckStats(JSON::Value & stats){
|
|
long long int currTime = Util::epoch();
|
|
for (JSON::ObjIter jit = stats.ObjBegin(); jit != stats.ObjEnd(); jit++){
|
|
if (currTime - lastBuffer[jit->first] > 120){
|
|
stats.removeMember(jit->first);
|
|
return;
|
|
}else{
|
|
if (jit->second.isMember("curr") && jit->second["curr"].size() > 0){
|
|
for (JSON::ObjIter u_it = jit->second["curr"].ObjBegin(); u_it != jit->second["curr"].ObjEnd(); ++u_it){
|
|
if (u_it->second.isMember("now") && u_it->second["now"].asInt() < currTime - 3){
|
|
jit->second["log"].append(u_it->second);
|
|
jit->second["curr"].removeMember(u_it->first);
|
|
if ( !jit->second["curr"].size()){
|
|
break;
|
|
}
|
|
u_it = jit->second["curr"].ObjBegin();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} //Controller namespace
|
|
|
|
/// the following function is a simple check if the user wants to proceed to fix (y), ignore (n) or abort on (a) a question
|
|
char yna(std::string user_input){
|
|
if(user_input == "y" || user_input == "Y"){
|
|
return 'y';
|
|
}else if(user_input == "n" || user_input == "N"){
|
|
return 'n';
|
|
}else if(user_input == "a" || user_input == "A"){
|
|
return 'a';
|
|
}else{
|
|
return 'x';//when no valid option is found, yna returns x
|
|
}
|
|
}
|
|
|
|
/// createAccount accepts a string in the form of username:account
|
|
/// and creates an account.
|
|
void createAccount (std::string account){
|
|
if (account.size() > 0){
|
|
size_t colon = account.find(':');
|
|
if (colon != std::string::npos && colon != 0 && colon != account.size()){
|
|
std::string uname = account.substr(0, colon);
|
|
std::string pword = account.substr(colon + 1, std::string::npos);
|
|
Controller::Log("CONF", "Created account " + uname + " through commandline option");
|
|
Controller::Storage["account"][uname]["password"] = Secure::md5(pword);
|
|
}
|
|
}
|
|
if ( !Controller::Storage["config"].isMember("basePath")){
|
|
Controller::Storage["config"]["basePath"] = Util::getMyPath();
|
|
}
|
|
}
|
|
|
|
///\brief The main entry point for the controller.
|
|
int main(int argc, char ** argv){
|
|
Controller::Storage = JSON::fromFile("config.json");
|
|
JSON::Value stored_port = JSON::fromString("{\"long\":\"port\", \"short\":\"p\", \"arg\":\"integer\", \"help\":\"TCP port to listen on.\"}");
|
|
stored_port["default"] = Controller::Storage["config"]["controller"]["port"];
|
|
if ( !stored_port["default"]){
|
|
stored_port["default"] = 4242;
|
|
}
|
|
JSON::Value stored_interface =
|
|
JSON::fromString(
|
|
"{\"long\":\"interface\", \"short\":\"i\", \"arg\":\"string\", \"help\":\"Interface address to listen on, or 0.0.0.0 for all available interfaces.\"}");
|
|
stored_interface["default"] = Controller::Storage["config"]["controller"]["interface"];
|
|
if ( !stored_interface["default"]){
|
|
stored_interface["default"] = "0.0.0.0";
|
|
}
|
|
JSON::Value stored_user = JSON::fromString(
|
|
"{\"long\":\"username\", \"short\":\"u\", \"arg\":\"string\", \"help\":\"Username to transfer privileges to, default is root.\"}");
|
|
stored_user["default"] = Controller::Storage["config"]["controller"]["username"];
|
|
if ( !stored_user["default"]){
|
|
stored_user["default"] = "root";
|
|
}
|
|
Util::Config conf = Util::Config(argv[0], PACKAGE_VERSION " / " RELEASE);
|
|
conf.addOption("listen_port", stored_port);
|
|
conf.addOption("listen_interface", stored_interface);
|
|
conf.addOption("username", stored_user);
|
|
conf.addOption("daemonize",
|
|
JSON::fromString(
|
|
"{\"long\":\"daemon\", \"short\":\"d\", \"default\":1, \"long_off\":\"nodaemon\", \"short_off\":\"n\", \"help\":\"Turns deamon mode on (-d) or off (-n). -d (default) runs quietly in background, -n enables verbose in foreground.\"}"));
|
|
conf.addOption("account",
|
|
JSON::fromString(
|
|
"{\"long\":\"account\", \"short\":\"a\", \"arg\":\"string\" \"default\":\"\", \"help\":\"A username:password string to create a new account with.\"}"));
|
|
conf.addOption("configFile",
|
|
JSON::fromString(
|
|
"{\"long\":\"config\", \"short\":\"c\", \"arg\":\"string\" \"default\":\"config.json\", \"help\":\"Specify a config file other than default.\"}"));
|
|
conf.addOption("uplink",
|
|
JSON::fromString(
|
|
"{\"default\":\"\", \"arg\":\"string\", \"help\":\"MistSteward uplink host and port.\", \"short\":\"U\", \"long\":\"uplink\"}"));
|
|
conf.addOption("uplink-name",
|
|
JSON::fromString(
|
|
"{\"default\":\"" COMPILED_USERNAME "\", \"arg\":\"string\", \"help\":\"MistSteward uplink username.\", \"short\":\"N\", \"long\":\"uplink-name\"}"));
|
|
conf.addOption("uplink-pass",
|
|
JSON::fromString(
|
|
"{\"default\":\"" COMPILED_PASSWORD "\", \"arg\":\"string\", \"help\":\"MistSteward uplink password.\", \"short\":\"P\", \"long\":\"uplink-pass\"}"));
|
|
conf.parseArgs(argc, argv);
|
|
|
|
//Input custom config here
|
|
Controller::Storage = JSON::fromFile(conf.getString("configFile"));
|
|
|
|
//check for port, interface and username in arguments
|
|
//if they are not there, take them from config file, if there
|
|
if (conf.getOption("listen_port", true).size() <= 1){
|
|
if (Controller::Storage["config"]["controller"]["port"]){
|
|
conf.getOption("listen_port") = Controller::Storage["config"]["controller"]["port"];
|
|
}
|
|
}
|
|
if (conf.getOption("listen_interface", true).size() <= 1){
|
|
if (Controller::Storage["config"]["controller"]["interface"]){
|
|
conf.getOption("listen_interface") = Controller::Storage["config"]["controller"]["interface"];
|
|
}
|
|
}
|
|
if (conf.getOption("username", true).size() <= 1){
|
|
if (Controller::Storage["config"]["controller"]["username"]){
|
|
conf.getOption("username") = Controller::Storage["config"]["controller"]["username"];
|
|
}
|
|
}
|
|
|
|
|
|
JSON::Value capabilities;
|
|
//list available protocols and report about them
|
|
std::deque<std::string> execs;
|
|
Util::getMyExec(execs);
|
|
std::string arg_one;
|
|
char const * conn_args[] = {0, "-j", 0};
|
|
for (std::deque<std::string>::iterator it = execs.begin(); it != execs.end(); it++){
|
|
if ((*it).substr(0, 8) == "MistConn"){
|
|
arg_one = Util::getMyPath() + (*it);
|
|
conn_args[0] = arg_one.c_str();
|
|
capabilities["connectors"][(*it).substr(8)] = JSON::fromString(Util::Procs::getOutputOf((char**)conn_args));
|
|
if (capabilities["connectors"][(*it).substr(8)].size() < 1){
|
|
capabilities["connectors"].removeMember((*it).substr(8));
|
|
}
|
|
}
|
|
}
|
|
|
|
createAccount(conf.getString("account"));
|
|
|
|
/// User friendliness input added at this line
|
|
if (isatty(fileno(stdin))){
|
|
//check for username
|
|
if ( !Controller::Storage.isMember("account") || Controller::Storage["account"].size() < 1){
|
|
std::string in_string = "";
|
|
while(yna(in_string) == 'x'){
|
|
std::cerr << "Account not set, do you want to create an account? (y)es, (n)o, (a)bort: ";
|
|
std::getline(std::cin, in_string);
|
|
if (yna(in_string) == 'y'){
|
|
//create account
|
|
std::string usr_string = "";
|
|
while(!(Controller::Storage.isMember("account") && Controller::Storage["account"].size() > 0)){
|
|
std::cerr << "Please type in the username, a colon and a password in the following format; username:password" << std::endl << ": ";
|
|
std::getline(std::cin, usr_string);
|
|
createAccount(usr_string);
|
|
}
|
|
}else if(yna(in_string) == 'a'){
|
|
//abort controller startup
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
//check for protocols
|
|
if ( !Controller::Storage.isMember("config") || !Controller::Storage["config"].isMember("protocols") || Controller::Storage["config"]["protocols"].size() < 1){
|
|
std::string in_string = "";
|
|
while(yna(in_string) == 'x'){
|
|
std::cerr << "Protocols not set, do you want to enable default protocols? (y)es, (n)o, (a)bort: ";
|
|
std::getline(std::cin, in_string);
|
|
if (yna(in_string) == 'y'){
|
|
//create protocols
|
|
for (JSON::ObjIter it = capabilities["connectors"].ObjBegin(); it != capabilities["connectors"].ObjEnd(); it++){
|
|
if ( !it->second.isMember("required")){
|
|
JSON::Value newProtocol;
|
|
newProtocol["connector"] = it->first;
|
|
Controller::Storage["config"]["protocols"].append(newProtocol);
|
|
}
|
|
}
|
|
}else if(yna(in_string) == 'a'){
|
|
//abort controller startup
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
//check for streams
|
|
if ( !Controller::Storage.isMember("streams") || Controller::Storage["streams"].size() < 1){
|
|
std::cerr << "No streams configured, remember to set up streams through local settings page on port " << conf.getInteger("listen_port") << " or using the API." << std::endl;
|
|
}
|
|
}
|
|
|
|
std::string uplink_addr = conf.getString("uplink");
|
|
std::string uplink_host = "";
|
|
int uplink_port = 0;
|
|
if (uplink_addr.size() > 0){
|
|
size_t colon = uplink_addr.find(':');
|
|
if (colon != std::string::npos && colon != 0 && colon != uplink_addr.size()){
|
|
uplink_host = uplink_addr.substr(0, colon);
|
|
uplink_port = atoi(uplink_addr.substr(colon + 1, std::string::npos).c_str());
|
|
Controller::Log("CONF",
|
|
"Connection to uplink enabled on host " + uplink_host + " and port " + uplink_addr.substr(colon + 1, std::string::npos));
|
|
}
|
|
}
|
|
|
|
time_t lastuplink = 0;
|
|
time_t processchecker = 0;
|
|
Socket::Server API_Socket = Socket::Server(conf.getInteger("listen_port"), conf.getString("listen_interface"), true);
|
|
Socket::Server Stats_Socket = Socket::Server(Util::getTmpFolder() + "statistics", true);
|
|
conf.activate();
|
|
Socket::Connection Incoming;
|
|
std::vector<Controller::ConnectedUser> users;
|
|
std::vector<Socket::Connection> buffers;
|
|
JSON::Value Request;
|
|
JSON::Value Response;
|
|
std::string jsonp;
|
|
Controller::ConnectedUser * uplink = 0;
|
|
Controller::Log("CONF", "Controller started");
|
|
conf.activate();
|
|
|
|
//Create a converter class and automatically load in all encoders.
|
|
Converter::Converter myConverter;
|
|
|
|
while (API_Socket.connected() && conf.is_active){
|
|
Util::sleep(10);//sleep for 10 ms - prevents 100% CPU time
|
|
|
|
if (Util::epoch() - processchecker > 10){
|
|
processchecker = Util::epoch();
|
|
Controller::CheckProtocols(Controller::Storage["config"]["protocols"], capabilities);
|
|
Controller::CheckAllStreams(Controller::Storage["streams"]);
|
|
Controller::CheckStats(Controller::Storage["statistics"]);
|
|
myConverter.updateStatus();
|
|
}
|
|
if (uplink_port && Util::epoch() - lastuplink > UPLINK_INTERVAL){
|
|
lastuplink = Util::epoch();
|
|
bool gotUplink = false;
|
|
if (users.size() > 0){
|
|
for (std::vector<Controller::ConnectedUser>::iterator it = users.end() - 1; it >= users.begin(); it--){
|
|
if ( !it->C.connected()){
|
|
it->C.close();
|
|
users.erase(it);
|
|
break;
|
|
}
|
|
if (it->clientMode){
|
|
uplink = & *it;
|
|
gotUplink = true;
|
|
}
|
|
}
|
|
}
|
|
if ( !gotUplink){
|
|
Incoming = Socket::Connection(uplink_host, uplink_port, true);
|
|
if (Incoming.connected()){
|
|
users.push_back((Controller::ConnectedUser)Incoming);
|
|
users.back().clientMode = true;
|
|
uplink = &users.back();
|
|
gotUplink = true;
|
|
}
|
|
}
|
|
if (gotUplink){
|
|
Response.null(); //make sure no data leaks from previous requests
|
|
Response["config"] = Controller::Storage["config"];
|
|
Response["streams"] = Controller::Storage["streams"];
|
|
Response["log"] = Controller::Storage["log"];
|
|
Response["statistics"] = Controller::Storage["statistics"];
|
|
Response["now"] = (unsigned int)lastuplink;
|
|
uplink->H.Clean();
|
|
uplink->H.SetBody("command=" + HTTP::Parser::urlencode(Response.toString()));
|
|
uplink->H.BuildRequest();
|
|
uplink->C.Send(uplink->H.BuildResponse("200", "OK"));
|
|
uplink->H.Clean();
|
|
//Controller::Log("UPLK", "Sending server data to uplink.");
|
|
}else{
|
|
Controller::Log("UPLK", "Could not connect to uplink.");
|
|
}
|
|
}
|
|
|
|
Incoming = API_Socket.accept(true);
|
|
if (Incoming.connected()){
|
|
users.push_back((Controller::ConnectedUser)Incoming);
|
|
}
|
|
Incoming = Stats_Socket.accept(true);
|
|
if (Incoming.connected()){
|
|
buffers.push_back(Incoming);
|
|
}
|
|
if (buffers.size() > 0){
|
|
for (std::vector<Socket::Connection>::iterator it = buffers.begin(); it != buffers.end(); it++){
|
|
if ( !it->connected()){
|
|
it->close();
|
|
buffers.erase(it);
|
|
break;
|
|
}
|
|
if (it->spool()){
|
|
while (it->Received().size()){
|
|
it->Received().get().resize(it->Received().get().size() - 1);
|
|
Request = JSON::fromString(it->Received().get());
|
|
it->Received().get().clear();
|
|
if (Request.isMember("buffer")){
|
|
std::string thisbuffer = Request["buffer"];
|
|
Controller::lastBuffer[thisbuffer] = Util::epoch();
|
|
//if metadata is available, store it
|
|
if (Request.isMember("meta")){
|
|
Controller::Storage["streams"][thisbuffer]["meta"] = Request["meta"];
|
|
}
|
|
if (Request.isMember("totals")){
|
|
Controller::Storage["statistics"][thisbuffer]["curr"] = Request["curr"];
|
|
std::string nowstr = Request["totals"]["now"].asString();
|
|
Controller::Storage["statistics"][thisbuffer]["totals"][nowstr] = Request["totals"];
|
|
Controller::Storage["statistics"][thisbuffer]["totals"][nowstr].removeMember("now");
|
|
Controller::Storage["statistics"][thisbuffer]["totals"].shrink(600); //limit to 10 minutes of data
|
|
for (JSON::ObjIter jit = Request["log"].ObjBegin(); jit != Request["log"].ObjEnd(); jit++){
|
|
Controller::Storage["statistics"][thisbuffer]["log"].append(jit->second);
|
|
Controller::Storage["statistics"][thisbuffer]["log"].shrink(1000); //limit to 1000 users per buffer
|
|
}
|
|
}
|
|
}
|
|
if (Request.isMember("vod")){
|
|
std::string thisfile = Request["vod"]["filename"];
|
|
for (JSON::ObjIter oit = Controller::Storage["streams"].ObjBegin(); oit != Controller::Storage["streams"].ObjEnd(); ++oit){
|
|
if ((oit->second.isMember("source") && oit->second["source"].asString() == thisfile)
|
|
|| (oit->second.isMember("channel") && oit->second["channel"]["URL"].asString() == thisfile)){
|
|
Controller::lastBuffer[oit->first] = Util::epoch();
|
|
if (Request["vod"].isMember("meta")){
|
|
Controller::Storage["streams"][oit->first]["meta"] = Request["vod"]["meta"];
|
|
}
|
|
JSON::Value sockit = (long long int)it->getSocket();
|
|
std::string nowstr = Request["vod"]["now"].asString();
|
|
Controller::Storage["statistics"][oit->first]["curr"][sockit.asString()] = Request["vod"];
|
|
Controller::Storage["statistics"][oit->first]["curr"][sockit.asString()].removeMember("meta");
|
|
JSON::Value nowtotal;
|
|
for (JSON::ObjIter u_it = Controller::Storage["statistics"][oit->first]["curr"].ObjBegin();
|
|
u_it != Controller::Storage["statistics"][oit->first]["curr"].ObjEnd(); ++u_it){
|
|
nowtotal["up"] = nowtotal["up"].asInt() + u_it->second["up"].asInt();
|
|
nowtotal["down"] = nowtotal["down"].asInt() + u_it->second["down"].asInt();
|
|
nowtotal["count"] = nowtotal["count"].asInt() + 1;
|
|
}
|
|
Controller::Storage["statistics"][oit->first]["totals"][nowstr] = nowtotal;
|
|
Controller::Storage["statistics"][oit->first]["totals"].shrink(600);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (users.size() > 0){
|
|
for (std::vector<Controller::ConnectedUser>::iterator it = users.begin(); it != users.end(); it++){
|
|
if ( !it->C.connected() || it->logins > 3){
|
|
it->C.close();
|
|
users.erase(it);
|
|
break;
|
|
}
|
|
if (it->C.spool() || it->C.Received().size()){
|
|
if (it->H.Read(it->C)){
|
|
Response.null(); //make sure no data leaks from previous requests
|
|
if (it->clientMode){
|
|
// In clientMode, requests are reversed. These are connections we initiated to GearBox.
|
|
// They are assumed to be authorized, but authorization to gearbox is still done.
|
|
// This authorization uses the compiled-in or commandline username and password (account).
|
|
Request = JSON::fromString(it->H.body);
|
|
if (Request["authorize"]["status"] != "OK"){
|
|
if (Request["authorize"].isMember("challenge")){
|
|
it->logins++;
|
|
if (it->logins > 2){
|
|
Controller::Log("UPLK", "Max login attempts passed - dropping connection to uplink.");
|
|
it->C.close();
|
|
}else{
|
|
Response["config"] = Controller::Storage["config"];
|
|
Response["streams"] = Controller::Storage["streams"];
|
|
Response["log"] = Controller::Storage["log"];
|
|
Response["statistics"] = Controller::Storage["statistics"];
|
|
Response["authorize"]["username"] = conf.getString("uplink-name");
|
|
Controller::checkCapable(capabilities);
|
|
Response["capabilities"] = capabilities;
|
|
Controller::Log("UPLK", "Responding to login challenge: " + Request["authorize"]["challenge"].asString());
|
|
Response["authorize"]["password"] = Secure::md5(conf.getString("uplink-pass") + Request["authorize"]["challenge"].asString());
|
|
it->H.Clean();
|
|
it->H.SetBody("command=" + HTTP::Parser::urlencode(Response.toString()));
|
|
it->H.BuildRequest();
|
|
it->C.Send(it->H.BuildResponse("200", "OK"));
|
|
it->H.Clean();
|
|
Controller::Log("UPLK", "Attempting login to uplink.");
|
|
}
|
|
}
|
|
}else{
|
|
if (Request.isMember("config")){
|
|
Controller::CheckConfig(Request["config"], Controller::Storage["config"]);
|
|
Controller::CheckProtocols(Controller::Storage["config"]["protocols"], capabilities);
|
|
}
|
|
if (Request.isMember("streams")){
|
|
Controller::CheckStreams(Request["streams"], Controller::Storage["streams"]);
|
|
Controller::CheckAllStreams(Controller::Storage["streams"]);
|
|
}
|
|
if (Request.isMember("clearstatlogs")){
|
|
Controller::Storage["log"].null();
|
|
Controller::Storage["statistics"].null();
|
|
}
|
|
}
|
|
}else{
|
|
Request = JSON::fromString(it->H.GetVar("command"));
|
|
if ( !Request.isObject() && it->H.url != "/api"){
|
|
it->H.Clean();
|
|
it->H.SetHeader("Content-Type", "text/html");
|
|
it->H.SetHeader("X-Info", "To force an API response, request the file /api");
|
|
it->H.SetHeader("Server", "mistserver/" PACKAGE_VERSION "/" + Util::Config::libver + "/" RELEASE);
|
|
it->H.SetBody(std::string((char*)server_html, (size_t)server_html_len));
|
|
it->C.Send(it->H.BuildResponse("200", "OK"));
|
|
it->H.Clean();
|
|
}else{
|
|
Authorize(Request, Response, ( *it));
|
|
if (it->Authorized){
|
|
//Parse config and streams from the request.
|
|
if (Request.isMember("config")){
|
|
Controller::CheckConfig(Request["config"], Controller::Storage["config"]);
|
|
Controller::CheckProtocols(Controller::Storage["config"]["protocols"], capabilities);
|
|
}
|
|
if (Request.isMember("streams")){
|
|
Controller::CheckStreams(Request["streams"], Controller::Storage["streams"]);
|
|
Controller::CheckAllStreams(Controller::Storage["streams"]);
|
|
}
|
|
if (Request.isMember("capabilities")){
|
|
Controller::checkCapable(capabilities);
|
|
Response["capabilities"] = capabilities;
|
|
}
|
|
if (Request.isMember("conversion")){
|
|
if (Request["conversion"].isMember("encoders")){
|
|
Response["conversion"]["encoders"] = myConverter.getEncoders();
|
|
}
|
|
if (Request["conversion"].isMember("query")){
|
|
if (Request["conversion"]["query"].isMember("path")){
|
|
Response["conversion"]["query"] = myConverter.queryPath(Request["conversion"]["query"]["path"].asString());
|
|
}else{
|
|
Response["conversion"]["query"] = myConverter.queryPath("./");
|
|
}
|
|
}
|
|
if (Request["conversion"].isMember("convert")){
|
|
for (JSON::ObjIter it = Request["conversion"]["convert"].ObjBegin(); it != Request["conversion"]["convert"].ObjEnd(); it++){
|
|
myConverter.startConversion(it->first,it->second);
|
|
}
|
|
}
|
|
if (Request["conversion"].isMember("status") || Request["conversion"].isMember("convert")){
|
|
Response["conversion"]["status"] = myConverter.getStatus();
|
|
if (Request["conversion"].isMember("clear")){
|
|
myConverter.clearStatus();
|
|
}
|
|
}
|
|
}
|
|
if (Request.isMember("save")){
|
|
Controller::WriteFile(conf.getString("configFile"), Controller::Storage.toString());
|
|
Controller::Log("CONF", "Config written to file on request through API");
|
|
}
|
|
//sent current configuration, no matter if it was changed or not
|
|
//Response["streams"] = Storage["streams"];
|
|
Response["config"] = Controller::Storage["config"];
|
|
Response["config"]["version"] = PACKAGE_VERSION "/" + Util::Config::libver + "/" RELEASE;
|
|
Response["streams"] = Controller::Storage["streams"];
|
|
//add required data to the current unix time to the config, for syncing reasons
|
|
Response["config"]["time"] = Util::epoch();
|
|
if ( !Response["config"].isMember("serverid")){
|
|
Response["config"]["serverid"] = "";
|
|
}
|
|
//sent any available logs and statistics
|
|
Response["log"] = Controller::Storage["log"];
|
|
Response["statistics"] = Controller::Storage["statistics"];
|
|
//clear log and statistics if requested
|
|
if (Request.isMember("clearstatlogs")){
|
|
Controller::Storage["log"].null();
|
|
Controller::Storage["statistics"].null();
|
|
}
|
|
|
|
}
|
|
jsonp = "";
|
|
if (it->H.GetVar("callback") != ""){
|
|
jsonp = it->H.GetVar("callback");
|
|
}
|
|
if (it->H.GetVar("jsonp") != ""){
|
|
jsonp = it->H.GetVar("jsonp");
|
|
}
|
|
it->H.Clean();
|
|
it->H.SetHeader("Content-Type", "text/javascript");
|
|
if (jsonp == ""){
|
|
it->H.SetBody(Response.toString() + "\n\n");
|
|
}else{
|
|
it->H.SetBody(jsonp + "(" + Response.toString() + ");\n\n");
|
|
}
|
|
it->C.Send(it->H.BuildResponse("200", "OK"));
|
|
it->H.Clean();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
API_Socket.close();
|
|
Controller::Log("CONF", "Controller shutting down");
|
|
Controller::WriteFile(conf.getString("configFile"), Controller::Storage.toString());
|
|
Util::Procs::StopAll();
|
|
std::cout << "Killed all processes, wrote config to disk. Exiting." << std::endl;
|
|
return 0;
|
|
}
|