MpdWebScreenshots.cxx

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                    MpdWebScreenshots source file             -----
// -------------------------------------------------------------------------
#include "MpdWebScreenshots.h"
 
#include "TEveManager.h"
#include "TGLViewer.h"
 
#include <TThread.h>
#include <iostream>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/wait.h>
using namespace std;
 
// -----   Default constructor (private)  ----------------------------------
MpdWebScreenshots::MpdWebScreenshots()
    : FairTask("MpdWebScreenshots", 0)
{}
 
// -----   Destructor   ----------------------------------------------------
MpdWebScreenshots::~MpdWebScreenshots() {}
 
// -----   Standard constructor   ------------------------------------------
MpdWebScreenshots::MpdWebScreenshots(const char* name, char* output_dir, bool isWebServer, Int_t iVerbose)
    : FairTask(name, iVerbose)
{
    outputDir = output_dir;
    outputDir += "/";
 
    isWebStarted = false;
    isWeb = isWebServer;
    if (isWebServer)
        return;
 
    if (strlen(outputDir) > 0) {
        struct stat st = {0};
        if (stat(outputDir, &st) == -1)
            mkdir(outputDir, 0700);
 
        cout << "Images of the event display will be saved in directory: " << outputDir << endl;
    }
}
 
// -------------------------------------------------------------------------
InitStatus MpdWebScreenshots::Init()
{
    if (fVerbose > 1)
        cout << "MpdWebScreenshots::Init()" << endl;
 
    if (!IsActive())
        return kERROR;
 
    fMan = MpdEventManager::Instance();
 
    // start web server if required
    if (isWeb && (!isWebStarted)) {
        // Set daemon to FALSE
        daemon = 0;
 
        www_thread_par* pPar = new www_thread_par();
        pPar->web_port = web_port;
        pPar->outputDir = outputDir;
        pPar->daemon = daemon;
 
        TThread* threadWebServ = new TThread((TThread::VoidFunc_t)&start_server, (void*)pPar, TThread::kNormalPriority);
        threadWebServ->Run();
        isWebStarted = true;
    }
 
    return kSUCCESS;
}
 
// -------------------------------------------------------------------------
void MpdWebScreenshots::Exec(Option_t* option)
{
    // redraw event display to capture current event
    gEve->Redraw3D();
    gSystem->ProcessEvents();
 
    TString fileName = outputDir;
    if (isMultiFiles == 1)
        fileName += "event_" + TString::Format("%d", fMan->GetCurrentEvent());
    else
        fileName += "event";
 
    if ((iFormatFiles == 0) || (iFormatFiles == 2)) {
        fileName += ".png";
        gEve->GetDefaultGLViewer()->SavePicture(fileName.Data());
    }
 
    if (iFormatFiles > 0) {
        fileName += ".jpg";
        gEve->GetDefaultGLViewer()->SavePicture(fileName.Data());
    }
 
    return;
}
 
// -------------------------------------------------------------------------
void MpdWebScreenshots::SetParContainers() {}
 
// -------------------------------------------------------------------------
void MpdWebScreenshots::Finish() {}
 
// -------------------------------------------------------------------------
int MpdWebScreenshots::daemonize()
{
    pid_t pid;
    // already a daemon
    if (getppid() == 1)
        return -1;
 
    // Fork off the parent process
    pid = fork();
    if (pid < 0)
        return -2;
 
    // If we got a good PID, then we can exit the parent process.
    if (pid > 0)
        return 0;
 
    // At this point we are executing as the child process
 
    // Change the file mode mask
    umask(0);
 
    // Create a new SID for the child process
    if (setsid() < 0)
        return -3;
 
    // Change the current working directory. This prevents the current directory from being locked; hence not being able
    // to remove it.
    if ((chdir("/")) < 0)
        return -4;
 
    return 0;
}
 
int MpdWebScreenshots::sendString(const char* message, int socket)
{
    return send(socket, message, strlen(message), 0);
}
 
void MpdWebScreenshots::sendHeader(const char* Status_code, char* Content_Type, int TotalSize, int socket)
{
    char* head = (char*)"\r\nHTTP/1.1 ";
    char* content_head = (char*)"\r\nContent-Type: ";
    char* server_head = (char*)"\r\nServer: PT06";
    char* length_head = (char*)"\r\nContent-Length: ";
    char* date_head = (char*)"\r\nDate: ";
    char* newline = (char*)"\r\n";
 
    time_t rawtime;
    time(&rawtime);
 
    char contentLength[100];
    sprintf(contentLength, "%i", TotalSize);
 
    char* message = (char*)malloc((strlen(head) + strlen(content_head) + strlen(server_head) + strlen(length_head)
                                   + strlen(date_head) + strlen(newline) + strlen(Status_code) + strlen(Content_Type)
                                   + strlen(contentLength) + 28 + sizeof(char))
                                  * 2);
 
    if (message != NULL) {
        strcpy(message, head);
        strcat(message, Status_code);
        strcat(message, content_head);
        strcat(message, Content_Type);
        strcat(message, server_head);
        strcat(message, length_head);
        strcat(message, contentLength);
        strcat(message, date_head);
        strcat(message, (char*)ctime(&rawtime));
        strcat(message, newline);
 
        sendString(message, socket);
 
        free(message);
    }
}
 
// send file
void MpdWebScreenshots::sendFile(FILE* fp, int connecting_socket)
{
    int current_char = 0;
    do {
        current_char = fgetc(fp);
        // send binary data
        /*int bytes_sent = */ send(connecting_socket, &current_char, sizeof(char), 0);
    } while (current_char != EOF);
}
 
int MpdWebScreenshots::scan(char* input, char* output, size_t start, size_t max)
{
    if (start >= strlen(input))
        return -1;
 
    int appending_char_count = 0;
    size_t count = 0;
 
    size_t i = start;
    for (; i < strlen(input); i++) {
        if (*(input + i) != '\t' && *(input + i) != ' ' && *(input + i) != '\n' && *(input + i) != '\r') {
            if (count < (max - 1)) {
                *(output + appending_char_count) = *(input + i);
                appending_char_count += 1;
                count++;
            }
        } else
            break;
    }
    *(output + appending_char_count) = '\0';
 
    // Find next word start
    i += 1;
 
    for (; i < strlen(input); i++) {
        if (*(input + i) != '\t' && *(input + i) != ' ' && *(input + i) != '\n' && *(input + i) != '\r')
            break;
    }
 
    return i;
}
 
int MpdWebScreenshots::checkMime(char* extension, char* mime_type)
{
    char* current_word = (char*)malloc(600);
    char* word_holder = (char*)malloc(600);
    char* line = (char*)malloc(200);
    int startline = 0;
 
    TString mime_file = "mime.types";
    FILE* mimeFile = fopen(mime_file.Data(), "r");
 
    free(mime_type);
    mime_type = (char*)malloc(200);
 
    memset(mime_type, '\0', 200);
 
    while (fgets(line, 200, mimeFile) != NULL) {
        if (line[0] != '#') {
            startline = scan(line, current_word, 0, 600);
            while (1) {
                startline = scan(line, word_holder, startline, 600);
                if (startline != -1) {
                    if (strcmp(word_holder, extension) == 0) {
                        memcpy(mime_type, current_word, strlen(current_word));
                        free(current_word);
                        free(word_holder);
                        free(line);
                        return 1;
                    }
                } else
                    break;
            }
        }
 
        memset(line, '\0', 200);
    }
 
    free(current_word);
    free(word_holder);
    free(line);
 
    return 0;
}
 
int MpdWebScreenshots::getHttpVersion(char* input, char* output)
{
    char* filename = (char*)malloc(100);
    int start = scan(input, filename, 4, 100);
    if (start > 0) {
        if (scan(input, output, start, 20)) {
            output[strlen(output) + 1] = '\0';
 
            if (strcmp("HTTP/1.1", output) == 0)
                return 1;
            else {
                if (strcmp("HTTP/1.0", output) == 0)
                    return 0;
                else
                    return -1;
            }
        } else
            return -1;
    }
 
    return -1;
}
 
int MpdWebScreenshots::GetExtension(char* input, char* output, size_t max)
{
    int in_position = 0;
    int appended_position = 0;
 
    size_t i = 0, count = 0;
    for (; i < strlen(input); i++) {
        if (in_position == 1) {
            if (count < max) {
                output[appended_position] = input[i];
                appended_position += 1;
                count++;
            }
        }
 
        if (input[i] == '.')
            in_position = 1;
    }
    output[appended_position + 1] = '\0';
 
    if (strlen(output) > 0)
        return 1;
 
    return -1;
}
 
// IF NOT EXISTS - RETURN -1. IF EXISTS - RETURN 1
int MpdWebScreenshots::handleHttpGET(char* input, TString output_dir, int connecting_socket)
{
    char* filename = (char*)malloc(200 * sizeof(char));
    char* path = (char*)malloc(1000 * sizeof(char));
    char* extension = (char*)malloc(10 * sizeof(char));
    char* mime = (char*)malloc(200 * sizeof(char));
    char* httpVersion = (char*)malloc(20 * sizeof(char));
 
    int contentLength = 0, mimeSupported = 0;
 
    memset(path, '\0', 1000);
    memset(filename, '\0', 200);
    memset(extension, '\0', 10);
    memset(mime, '\0', 200);
    memset(httpVersion, '\0', 20);
 
    int fileNameLength = scan(input, filename, 5, 200);
 
    int i = 0;
    while (filename[i] != '\0' && filename[i] != '?')
        i++;
 
    if (filename[i] == '?')
        filename[i] = '\0';
 
    if (fileNameLength <= 0)
        return -1;
 
    if (getHttpVersion(input, httpVersion) == -1) {
        sendString("501 Not Implemented\n", connecting_socket);
        return -1;
    }
 
    if (GetExtension(filename, extension, 10) == -1) {
        printf("File extension not existing");
        sendString("400 Bad Request\n", connecting_socket);
 
        free(filename);
        free(mime);
        free(path);
        free(extension);
        return -1;
    }
 
    mimeSupported = checkMime(extension, mime);
    if (mimeSupported != 1) {
        printf("Mime not supported");
        sendString("400 Bad Request\n", connecting_socket);
 
        free(filename);
        free(mime);
        free(path);
        free(extension);
        return -1;
    }
 
    // Open the requesting file as binary
    strcpy(path, output_dir.Data());
    strcat(path, filename);
 
    FILE* fp = fopen(path, "rb");
    if (fp == NULL) {
        printf("\nUnable to open file %s\n", path);
 
        sendString("404 Not Found\n", connecting_socket);
 
        free(filename);
        free(mime);
        free(extension);
        free(path);
        return -1;
    }
 
    // Calculate Content Length
    fseek(fp, 0, SEEK_END);
    contentLength = ftell(fp);
    rewind(fp);
    if (contentLength < 0) {
        printf("File size is zero");
 
        free(filename);
        free(mime);
        free(extension);
        free(path);
        fclose(fp);
        return -1;
    }
 
    // Send File Content
    sendHeader("200 OK", mime, contentLength, connecting_socket);
 
    sendFile(fp, connecting_socket);
 
    free(filename);
    free(mime);
    free(extension);
    free(path);
    fclose(fp);
 
    return 1;
}
 
// IF NOT VALID REQUEST - RETURN -1. IF VALID REQUEST - RETURN 1. IF GET - RETURN 2. IF HEAD - RETURN 0.
int MpdWebScreenshots::getRequestType(char* input)
{
    int type = -1;
    if (strlen(input) > 0)
        type = 1;
 
    char* requestType = (char*)malloc(5);
    scan(input, requestType, 0, 5);
 
    if (type == 1 && strcmp("GET", requestType) == 0)
        type = 1;
    else if (type == 1 && strcmp("HEAD", requestType) == 0)
        type = 2;
    else if (strlen(input) > 4 && strcmp("POST", requestType) == 0)
        type = 0;
    else
        type = -1;
 
    return type;
}
 
int MpdWebScreenshots::receive(int connecting_socket, TString output_dir)
{
    char buffer[BUFFER_SIZE];
    memset(buffer, '\0', BUFFER_SIZE);
 
    if ((recv(connecting_socket, buffer, BUFFER_SIZE, 0)) == -1) {
        printf("Error handling incoming request");
        return -1;
    }
 
    int request = getRequestType(buffer);
    if (request == 1)   // GET
        handleHttpGET(buffer, output_dir, connecting_socket);
    else if (request != 2)   // NOT HEAD
    {
        if (request == 0)   // POST
            sendString("501 Not Implemented\n", connecting_socket);
        else   // GARBAGE
            sendString("400 Bad Request\n", connecting_socket);
    }
    // else                      // HEAD
    //     1; //SendHeader();
 
    return 1;
}
 
int MpdWebScreenshots::acceptConnection(int currentSocket, TString output_dir)
{
    sockaddr_storage connectorSocket;
    socklen_t addressSize = sizeof(connectorSocket);
 
    int connecting_socket = accept(currentSocket, (struct sockaddr*)&(connectorSocket), &addressSize);
    if (connecting_socket < 0) {
        perror("Accepting sockets");
        return -1;
    }
 
    // --- Workflow --- //
    // 1. Receive ( recv() ) the GET / HEAD
    // 2. Process the request and see if the file exists
    // 3. Read the file content
    // 4. Send out with correct mine and http 1.1
    if (receive(connecting_socket, output_dir) < 0) {
        perror("Receive");
        return -1;
    }
 
    close(connecting_socket);
 
    while (-1 != waitpid(-1, NULL, WNOHANG))
        ;
 
    return 0;
}
 
int MpdWebScreenshots::start(int webPort, TString output_dir)
{
    // Create a socket and assign currentSocket to the descriptor
    int currentSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (currentSocket == -1) {
        perror("Create socket");
        return -1;
    }
 
    // Bind to the currentSocket descriptor and listen to the port in PORT
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(webPort);
 
    if (bind(currentSocket, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("Bind to port");
        return -2;
    }
 
    // Start listening for connections and accept no more than MAX_CONNECTIONS in the Quee
    if (listen(currentSocket, MAX_CONNECTIONS) < 0) {
        perror("Listen on port");
        return -3;
    }
 
    while (1)
        acceptConnection(currentSocket, output_dir);
}
 
int MpdWebScreenshots::start_server(void* ptr)
{
    www_thread_par* pPar = (www_thread_par*)ptr;
    int webPort = pPar->web_port;
    TString output_dir = pPar->outputDir;
    int daemon = pPar->daemon;
 
    int argc = 0;
    char** argv = NULL;
 
    TString log_file;
    for (int parameterCount = 1; parameterCount < argc; parameterCount++) {
        // If flag -p is used, set port
        if (strcmp(argv[parameterCount], "-p") == 0) {
            // Indicate that we want to jump over the next parameter
            parameterCount++;
            printf("Setting port to %i\n", atoi(argv[parameterCount]));
            webPort = atoi(argv[parameterCount]);
        }
        // If flag -d is used, set daemon to TRUE;
        else
        {
            if (strcmp(argv[parameterCount], "-d") == 0) {
                printf("Setting daemon = TRUE");
                daemon = 1;
            } else {
                if (strcmp(argv[parameterCount], "-l") == 0) {
                    // Indicate that we want to jump over the next parameter
                    parameterCount++;
                    printf("Setting logfile = %s\n", argv[parameterCount]);
                    log_file = (TString)(char*)argv[parameterCount];
                } else {
                    printf("Usage: %s [-p port] [-d] [-l logfile]\n", argv[0]);
                    printf("\t\t-p port\t\tWhich port to listen to.\n");
                    printf("\t\t-d\t\tEnables  daemon mode.\n");
                    printf("\t\t-l logfile\tWhich file to store the log to.\n");
                    return -1;
                }
            }
        }
    }
 
    printf("Settings:\n");
    printf("Port:\t\t\t%i\n", webPort);
    printf("Server root:\t\t%s\n", output_dir.Data());
    printf("Logfile:\t\t%s\n", log_file.Data());
    printf("daemon:\t\t\t%i\n", daemon);
 
    if (daemon == 1)
        daemonize();
 
    start(webPort, output_dir);
 
    return 0;
}