path: root/src/pvsDaemon.cpp

#include <QCoreApplication>
#include <getopt.h>
#include <stdlib.h>
#include "pvs.h"
#include "src/net/pvsLocalhostCommunicator.h"
#include "src/util/pvsSettingsManager.h"
#include "setup.h"
#include "src/net/pvsMsg.h"
#include "src/core/pvsChatClient.h"

PVS *mainClient = NULL;

// This define works as a switch whether to run as deamon or regular app
#define as_daemon

/// VERSION_STRING is defined in src/version.h
void printVersion(bool doExit)
{

    printf("Version:\t"VERSION_STRING"\n");
    if (doExit)
        exit(0);
}

/// outputs the full help text
void printHelp()
{
    printf("**************************************************************\n");
    printf("\nPool Video Switch Client\n");
    printf("**************************************************************\n");
    printVersion(false);
    printf("**************************************************************\n");
    printf("Usage:\tpoolVSClient <<option> <value>, ... >\n\n");
    printf("Options:\n\n");
    printf("-vncScriptFile <fullpath\\filename>\n\tSpecifies a custom location for the vnc-start/stop-script.\n\tIf not specified, ~/.pvs/pvs-vncsrv is expected.\n\n");
    printf("-freq <seconds>\n\tSpecifies how long to wait until a reconnection attempt is made.\n\tDefault is 5.\n\n");
    printf("-port <port>\n\tSpecifies on which port to run.\n\tDefault is %d.\n\n", SERVER_PORT_INT);
    printf("-h or --help\n\t Shows this help text and exits.\n\n");
    printf("-v or --version\n\t Shows the current version and exits.\n");
    printf(
        "-c <string command>:<string value> \n\t Sends the command and the optional value to a running PVS-Client.\n\t Command and value may not contain spaces or colons.\n\t The dividing colon is mandatory.\n");
    printf("-commands: \n\tPrints out available commands to use with -c . \n ");
    printf("**************************************************************\n");
    exit(0);
}

/// outputs a brief help text
void printNotice()
{
    printf(
        "Use -h or --help to get a listing of all options.\n-v or --version gives you the current version.\n\n");
}

void printCommands()
{
    printf("**************************************************************\n");
    printf("chat:<on/ off/ 1/ 2/ 3>\n ");
    printf("on = turns that chat option on\n off = turns the chat option off\n 1 = bossmode\n 2 = community\n 3 = private\n");
    printf("stop \n\t Stops the running PVS-Client.\n");
    printf("**************************************************************\n");
    exit(0);
}

///
int main(int argc, char** argv)
{
    int frequency = 5;
    int port = -1;

    QFileInfo script;
    #ifdef __WIN32__
        //TODO Win32
        if (!script.exists())
            script.setFile(getHomeDir() + "/.pvs/pvs-vncsrv_win32.bat");
    #else
        script.setFile("/usr/bin/pvs-vncsrv");
        if (!script.exists())
            script.setFile("/usr/local/bin/pvs-vncsrv");
        if (!script.exists())
            script.setFile(getHomeDir() + "/.pvs/pvs-vncsrv");
    #endif //__WIN32__

    QCoreApplication app(argc, argv);
    app.setOrganizationName("openslx");
    app.setOrganizationDomain("openslx.org");
    app.setApplicationName("pvs");
    // use system locale as language to translate gui
    QTranslator translator;
    translator.load(":pvs");
    app.installTranslator(&translator);


    PVSLocalhostCommunicator com(getPolicyFilePath(QString(
                                     ".comfile")));
    com.run();
    if (!(com.running()))
    {
        printf("Error. UDS Communicator is not running. Exiting.\n");
        exit(0);
    }

    printf("UDS Communicator is running.\n");
    int option_index = 0;

    while (1)
    {
        static struct option long_options[] =
        {
            { "help", no_argument, 0, 'h' },
            { "commands", no_argument, 0, 'o' },
            { "version", no_argument, 0, 'v' },
            { "port", required_argument, 0, 'p' },
            { "freq", required_argument, 0, 'f' },
            { "client", required_argument, 0, 'e' },
            { "script", required_argument, 0, 's' },
            { 0, 0, 0, 0 },
        };
        /* getopt_long stores the option index here. */

        int c = getopt_long(argc, argv, "hvoc:f:e:s:p:", long_options,
                            &option_index);
        option_index++;
        if (c == -1)
            break;

        switch (c)
        {
        case 'h':
            printHelp();
            break;
        case 'o':
            printCommands();
            break;
        case 'v':
            printVersion(true);
            break;
        case 'c':
        {
            if (option_index + 1 < argc)
            {
                if (com.server())
                {
                    // wont work, no daemon running
                    printf("Error. No running PVS-Client found. Exiting.\n");
                    com.stop();
                }
                else
                {
                    QStringList line = QString::fromLocal8Bit(argv[option_index
                                       + 1]).split(":");
                    QString &ident = line[0];
                    QString message;
                    if (line.size() > 1)
                        message = line[1];
                    if (ident.size() > 0) // no use sending empty idents... not even sure if this COULD happen
                    {
                        bool flag = false;
                        if (ident == "make")
                            PVSSettingsManager::getManager()->setConfigs();
                        else if (ident == "chat" && message == "boss")
                        {
                            PVSSettingsManager::getManager()->reWriteConfigs("chatmode", "bossmode");
                            flag = true;

                        }
                        else if (ident == "chat" && message == "all")
                        {
                            PVSSettingsManager::getManager()->reWriteConfigs("chatmode", "community");
                            flag = true;
                        }
                        else if (ident == "chat" && message == "private")
                        {
                            PVSSettingsManager::getManager()->reWriteConfigs("chatmode", "private");
                            flag = true;
                        }
                        else if (ident == "chat" && message == "on")
                        {
                            PVSSettingsManager::getManager()->reWriteConfigs("chatstate", "on");
                            flag = true;
                        }
                        else if (ident == "chat" && message == "off")
                        {
                            PVSSettingsManager::getManager()->reWriteConfigs("chatstate", "off");
                            flag = true;
                        }
                        else if (ident == "room")
                        {
                            //PVSSettingsManager::getManager()->reWriteConfigs(ident, message);
                            flag = true;
                        }
                        else if (ident == "stop" && message == NULL)
                            flag = true;
                        else
                            printf("option %s doesn't exist\n", ident.toUtf8().data());

                        if (flag)
                        {
                            qDebug("Will send i: %s, m: %s\n", ident.toUtf8().data(), message.toUtf8().data());
                            com.sendCommand(ident, message);
                            QCoreApplication::processEvents(QEventLoop::AllEvents);
                            printf("Sent command. Exiting.\n");
                        }
                    }

                    else
                        printf("Something went horribly wrong, since the ident is empty.\n");

                }
            }
            else
            {
                printf("Error. No command issued. Exiting.\n");
            }
            exit(0); // and gone
            break;
        }
        case 'f':
        {
            if (option_index + 1 < argc)
            {
                frequency = atoi(argv[option_index + 1]);
                if (frequency <= 0)
                {
                    frequency = 5; // return to standard
                    ConsoleLog writeError(QString(
                                              "malformed frequency, setting standard = 5"));
                    printNotice();
                }
                else
                    ConsoleLog writeLine(QString("Using frequency ").append(
                                             int2String(frequency)));
                option_index++;
                continue;
            }
            break;
        }
        case 'p':
        {
            if (option_index + 1 < argc)
            {
                port = atoi(argv[option_index + 1]);
                if (port <= 0)
                {
                    ConsoleLog writeTerminal(QString("port maybe malformed"));
                    printNotice();
                    port = -1; // return to standard
                }
                else
                    ConsoleLog writeTerminal(QString("Using port ").append(
                                                 int2String(port)));
                option_index++;
                continue;
            }
            break;
        }
        case 'e':
        {
            if (option_index + 1 < argc)
            {
                printf("WARNING: -e is deprecated\n");
                option_index++;
                continue;
            }
            break;
        }
        case 's':
        {
            if (option_index + 1 < argc)
            {
                script.setFile(QString(argv[option_index + 1]));
                option_index++;
                continue;
            }
            break;
        }
        case '?':
        {
            ConsoleLog writeError(
                QString("Unrecognized option/paramter: ").append(
                    argv[option_index]));
            printNotice();
        }
        default:
            abort();
        }
        //else
        //    printNotice();
    }

    if (!com.server())
    {
        printf("Error. PoolVSClient already running. Exiting\n");
        com.stop();
        exit(0);
    }

    ConsoleLog setLogName(QString("log.client"));
    ConsoleLog writeLine(QString("PVS-Client started."));

#ifdef as_daemon

    /*Alex: neu schreiben als pvsdaemon_win32.cpp und minimieren in Task-Leiste*/
    #ifndef __WIN32__
    /* Our process ID and Session ID */
    pid_t pid, sid;

    /* Fork off the parent process */
    pid = fork();
    if (pid < 0)
    {
        exit(-1);
    }
    /* If we got a good PID, then
     we can exit the parent process. */
    if (pid > 0)
    {
        exit(0);
    }

    /* Change the file mode mask */
    umask(0);

    /* Open any logs here */

    /* Create a new SID for the child process */
    sid = setsid();
    if (sid < 0)
    {
        /* Log the failure */
        exit(-1);
    }

    /* Change the current working directory */
    if ((chdir("/")) < 0)
    {
        /* Log the failure */
        exit(-1);
    }

    /* Close out the standard file descriptors */
    close(STDIN_FILENO);
    freopen ((QString(getHomeDir()).append(QString("/.pvs/dump"))).toUtf8().data(),"w",stdout);
    //close(STDOUT_FILENO);
    close(STDERR_FILENO);
    #endif /*__WIN32__*/
    /* Daemon-specific initialization goes here */

    /* The Big Loop */

#endif

    mainClient = new PVS();
    PVSSettingsManager::getManager()->setConfigFile(getPolicyFilePath("clientconf"));
    com.getDispatcher()->addListener("*", mainClient, &PVS::onDaemonCommand);

    if (port <= 0)
        port = SERVER_PORT_INT;
    ConsoleLog writeLine(QString("TCP-Port: ").append(int2String(port)));
    mainClient->setScriptPath(script.filePath());
    ConsoleLog writeLine(QString("VNCScriptPath: ").append(script.filePath()));
    createPolicyDir();
    createPolicyFiles();

    //  long int gr = 0;
    mainClient->setScriptPath(script.filePath());
    app.exec();
    delete mainClient;

    return 0;
}