apps/sctl/sctl.cgi.cpp

Go to the documentation of this file.

#include <iostream>
#include <string>
#include <map>
#include <list>
#include <fstream>

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <syslog.h>

#include <sys/socket.h>
#include <sys/param.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <net/if.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <linux/if_ether.h>
#include <sched.h>

using namespace std;

#define _KILLALL "/usr/bin/killall"
#define _FPCF "/usr/local/bin/fpcf"
#define _STR    "/usr/local/bin/str"
#define _CONF_RUN       "/var/state/streamer.conf"
#define _CONF   "/etc/streamer.conf"
#define _STATUS_XML     "/var/state/streamer.xml"

#define HEADER_TEXT     0x00
#define HEADER_XML      0x01

#define STREAMER_ELF    "str"
#define STREAMER_LOCK   "/dev/stream"

#define DEFAULT_PORT    "20000"
#define DEFAULT_ADDR    "232.0.0.1"

void header(int type) {
        cout << "HTTP/1.0 200 OK" << endl;
        cout << "Pragma: no-cache" << endl;
        if(type == HEADER_TEXT)
                cout << "Content-Type: text/plain" << endl;
        if(type == HEADER_XML)
                cout << "Content-Type: text/xml" << endl;
        cout << endl;
}

bool parse_string(const string &str, char delimiter, string &left, string &right) {
    left = "";
    right = "";
    int i = str.find(delimiter);
    if(i > 0 && i < (int)str.length()) {
        const char *c = str.c_str();
        left.insert(0, c, i);
        right.insert(0, &c[i + 1], str.length() - i - 1);
    } else
        left = str;
        if(left == "")
                return false;
        else
                return true;
}

bool streamer_start(map<string, string>);
bool streamer_stop(void);
void stream_status(void);
bool conf_save(map<string, string>);
void conf_load(ostream &stream);
string get_self_ip(string);
void stream_status_to_file(map<string, string> opts);

int main(int argc, char *argv[]) {
//      const char *b;
        string cmd;
        map<string, string> opts;

        string method = getenv("REQUEST_METHOD");
        string query = getenv("QUERY_STRING");
        string uri = getenv("REQUEST_URI");

        string left, right;
        while(parse_string(query, '&', left, right)) {
                string n, v;
                parse_string(left, '=', n, v);
                opts.insert(pair<string, string>(n, v));
                query = right;
        }

        bool res = false;
        if(opts["cmd"] == "start") {
                header(HEADER_TEXT);
                res = streamer_start(opts);
                stream_status_to_file(opts);
        }
        if(opts["cmd"] == "stop") {
                header(HEADER_TEXT);
                res = streamer_stop();
        }
        if(opts["cmd"] == "status") {
                header(HEADER_XML);
                stream_status();
        }
/*
        if(opts["cmd"] == "save") {
                header(HEADER_TEXT);
                res = conf_save(opts);
        }
        if(opts["cmd"] == "load") {
                header(HEADER_XML);
                conf_load(cout);
        }
*/
//      cout << "result: " << res << endl;
/*
        if(opts["cmd"] == "status") {
                cout << "cmd == status" << endl;
        }
*/
        return 0;
}

/************************************************
 *
 * start/stop streamer
 *
 * run specified program with arguments as daemon
 */
bool streamer_is_run(void) {
        int fd = open(STREAMER_LOCK, O_RDONLY);
        if(fd < 0)
                return true;
        close(fd);
        return false;
}

bool run_daemon(string prog, list<string> args) {
        int null_fd;
        int pid;
        if((pid = fork()) < 0) {
//              cout << "fork() fail!" << endl;
                return false;
        } else
                if(pid != 0) {
                        // wait 2 sec here while a streamer is not run
                        int c = 0;
                        while(!streamer_is_run() && c < 20) {
                                usleep(100000);
                                c++;
                        }
//                      cout << "fork() ok!" << endl;
                        return true;
                }
        // prepare to daemon
        setsid();
        chdir("/");
        umask(0);
        fflush(stdout);
        fflush(stderr);
        null_fd=open("/dev/null",O_RDWR);
        dup2(null_fd, 0);
        dup2(null_fd, 1);
        close(null_fd);
//      fprintf (stdout, "\ntest output to stdout\n");
//      fprintf (stderr, "\ntest output to stderr (after test output to stdout)\n");
//      close(0);
//      close(1);
//      close(2);
        int l = args.size() + 1;
        char **a = (char **)malloc(sizeof(char *) * l);
        int i = 0;
        for(list<string>::iterator it = args.begin(); it != args.end(); it++, i++)
                a[i] = const_cast<char *>((*it).c_str());
        a[i] = NULL;
        execvp(prog.c_str(), a);
        return false;
}

bool streamer_start(map<string, string> opts) {
        if(streamer_is_run()) {
//              cout << "streamer is already running" << endl;
                return true;
        }
        // prepare arguments
        string t;
        list<string> args;
        args.push_back("str");
        string mcast_transport;
        if(opts["addr"] != "")
                mcast_transport = opts["addr"];
        if(opts["port"] != "") {
                mcast_transport += ":";
                mcast_transport += opts["port"];
        }
/*
        if(opts["addr"] != "") {
                args.push_back("-a");
                args.push_back(opts["addr"]);
        }
        if(opts["port"] != "") {
                args.push_back("-p");
                args.push_back(opts["port"]);
        }
*/
        if(opts["fps"] != "") {
                args.push_back("-f");
                args.push_back(opts["fps"]);
        }
        t = opts["transport"];
        if(t != "") {
                if(t == "mcast") {
                        args.push_back("-m");
                        if(mcast_transport != "")
                                args.push_back(mcast_transport);
                }
                if(t == "ucast")
                        args.push_back("-u");
        }
        if(opts["ttl"] != "") {
                args.push_back("-t");
                args.push_back(opts["ttl"]);
        }
        // and run
        conf_save(opts);
        return run_daemon(_STR, args);
}
// Temporary fix - calling "fpcf -jpeg d" as a daemon resulted in errno 9 (EBADF)
// (directly calling that or from php script was OK)
// so I just copied portion of fpcf here
// #include <asm/elphel/c313a.h> - needed to be actually included, not these two lines below
// AF
#define CMOSCAM_IOCTYPE 124
#define IO_CCAM_JPEG    0x08 // JPEG-compressor related commands
void stop_compressor(void) {
 int devfd = open("/dev/sensorpars", O_RDONLY);
 ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG ), 13);
 close (devfd);
}

bool streamer_stop(void) {
        if(streamer_is_run() == false)
                return true;
        list<string> args_kill;
        args_kill.push_back("killall");
        args_kill.push_back("-9");
        args_kill.push_back("str");
        bool res = run_daemon(_KILLALL, args_kill);
        /* wait, when streamer stopped */
        if(res) {
                while(streamer_is_run())
                        sched_yield();
        } else
                return false;
        /* reset horrible drivers */
// thank you. AF
   stop_compressor();
   return true;
/*
        list<string> args_fpcf;
        args_fpcf.push_back("fpcf");
        args_fpcf.push_back("-jpeg");
        args_fpcf.push_back("d");
        return run_daemon(_FPCF, args_fpcf);
*/
}

/************************************************
 *
 * load/save config
 *
 */

bool conf_save(map<string, string> opts) {
        ofstream ofile;
        ofile.open(_CONF_RUN);
        string t;
        t = opts["transport"];
        if(t == "mcast") {
                ofile << "name=multicast" << endl;
                ofile << "n=1" << endl;
        } else {
                ofile << "name=unicast" << endl;
                ofile << "n=2" << endl;
        }
        ofile << "dest_port=";
        if(opts["port"] != "")
                ofile << opts["port"] << endl;
        else
                ofile << DEFAULT_PORT << endl;
        ofile << "dest_ip=";
        if(opts["addr"] != "")
                ofile << opts["addr"] << endl;
        else
                ofile << DEFAULT_ADDR << endl;
        ofile << "autostart=";
        if(opts["autostart"] == "true" || opts["autostart"] == "1")
                ofile << "true" << endl;
        else
                ofile << "false" << endl;
        ofile << "fps=";
        if(opts["fps"] != "") {
                ofile << opts["fps"] << endl;
                ofile << "maxfps=1" << endl;
        } else {
                ofile << "0" << endl;
                ofile << "maxfps=0" << endl;
        }
        ofile.close();
        return true;
}

void conf_load(ostream &out) {
        out << "<streamer>" << endl;
        map<string, string> conf;
        ifstream ifile(_CONF);
        string part;
        while(!ifile.eof()) {
                char in = ifile.get();
                if(in == '\r' || in == '\n') {
                        if(part == "")
                                continue;
                        string n, v;
                        parse_string(part, '=', n, v);
                        out << "<" << n << ">";
                        out << v;
                        out << "</" << n << ">" << endl;
                        part = "";
                        continue;
                }
                part += in;
        }
        ifile.close();
        out << "</streamer>" << endl;
}

void stream_status_to_file(map<string, string> opts) {
        ofstream ofile(_STATUS_XML);
        string t;
        t = opts["transport"];
        string _n = "1";
        string _name = "multicast";
        string _m = "1";
        if(t != "mcast") {
                _n = "2";
                _name = "unicast";
                _m = "0";
        }
        ofile << "<streamer>" << endl;
        ofile << "<n>" << _n << "</n>" << endl;
        ofile << "<name>" << _name << "</name>" << endl;
        ofile << "<rtsp>";
        ofile << "<ip>"  << get_self_ip("eth0") << "</ip>";
        ofile << "<port>554</port>";
        ofile << "</rtsp>" << endl;
        ofile << "<rtp>";
        ofile << "<ip>" << opts["addr"] << "</ip>";
        ofile << "<port>" << opts["port"] << "</port>";
        ofile << "<multicast>" << _m << "</multicast>";
        ofile << "</rtp>" << endl;
        ofile << "</streamer>" << endl;
}

void stream_status(void) {
        bool is_run = streamer_is_run();
        if(is_run) {
                ifstream ifile(_STATUS_XML);
//              char buf[256];
                while(!ifile.eof()) {
                        string z;
                        ifile >> z;
                        cout << z;
//                      int l = ifile.read(buf, 255);
//                      cout.write(buf, l);
                }
                return;
        }
        cout << "<streamer>" << endl;
        cout << "<n>0</n>" << endl;
        cout << "<name>multicast</name>" << endl;
        cout << "<rtsp>";
        cout << "<ip>"  << get_self_ip("eth0") << "</ip>";
        cout << "<port>554</port>";
        cout << "</rtsp>" << endl;
        cout << "<rtp>";
        cout << "<ip>232.0.0.1</ip>";
        cout << "<port>20000</port>";
        cout << "<multicast>1</multicast>";
        cout << "</rtp>" << endl;
        cout << "</streamer>" << endl;
}

string get_self_ip(string iface) {
        struct ifreq ifr;
        struct sockaddr_in *sin;
        int fd;

        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if(fd < 0)
                return "0.0.0.0";

        memset(&ifr, 0, sizeof(ifr));
        strcpy(ifr.ifr_name, "eth0");

        if(ioctl(fd, SIOCGIFADDR, &ifr) != 0)
                return "0.0.0.0";

        sin = (struct sockaddr_in*)(ifr.ifr_addr.sa_data + 2);
        struct in_addr src_addr4 = *(struct in_addr*)sin;
        close(fd);
        return inet_ntoa(src_addr4);
}

---