protocolhttp.cpp

/*
 * protocolhttp.c: IPTV plugin for the Video Disk Recorder
 *
 * See the README file for copyright information and how to reach the author.
 *
 */

#include <cstring>

#include <vdr/device.h>

#include "common.h"
#include "config.h"
#include "log.h"
#include "protocolhttp.h"

cIptvProtocolHttp::cIptvProtocolHttp()
    : streamAddrM(strdup("")),
      streamPathM(strdup("/")),
      streamPortM(0) {
    debug1("%s", __PRETTY_FUNCTION__);
}

cIptvProtocolHttp::~cIptvProtocolHttp() {
    debug1("%s", __PRETTY_FUNCTION__);

    // Close the socket
    cIptvProtocolHttp::Close();

    // Free allocated memory
    free(streamPathM);
    free(streamAddrM);
}

bool cIptvProtocolHttp::Connect() {
    debug1("%s", __PRETTY_FUNCTION__);

    // Check that stream address is valid
    if (!isActiveM && !isempty(streamAddrM) && !isempty(streamPathM)) {
        // Ensure that socket is valid and connect
        OpenSocket(streamPortM, streamAddrM);
        if (!ConnectSocket()) {
            CloseSocket();
            return false;
        }

        // Formulate and send HTTP request
        cString buffer = cString::sprintf("GET %s HTTP/1.1\r\n"
                                          "Host: %s\r\n"
                                          "User-Agent: vdr-%s/%s\r\n"
                                          "Range: bytes=0-\r\n"
                                          "Connection: Close\r\n"
                                          "\r\n", streamPathM, streamAddrM,
                                          PLUGIN_NAME_I18N, VERSION);

        unsigned int len = strlen(*buffer);
        debug1("%s Requesting %d: %s", __PRETTY_FUNCTION__, len, *buffer);

        if (!Write(*buffer, len)) {
            CloseSocket();

            return false;
        }

        // Now process headers
        if (!ProcessHeaders()) {
            CloseSocket();

            return false;
        }

        // Update active flag
        isActiveM = true;
    }

    return true;
}

bool cIptvProtocolHttp::Disconnect() {
    debug1("%s", __PRETTY_FUNCTION__);

    if (isActiveM) {
        // Close the socket
        CloseSocket();

        // Update active flag
        isActiveM = false;
    }

    return true;
}

bool cIptvProtocolHttp::GetHeaderLine(char *destP, unsigned int destLenP, unsigned int &recvLenP) {
    debug1("%s (, %u, )", __PRETTY_FUNCTION__, destLenP);

    bool linefeed = false;
    bool newline = false;
    char *bufptr = destP;
    recvLenP = 0;

    if (!destP) {
        return false;
    }

    while (!newline || !linefeed) {
        // Wait 500ms for data
        if (ReadChar(bufptr, 500)) {
            // Parsing end conditions, if line ends with \r\n
            if (linefeed && *bufptr=='\n') {
                newline = true;
                // First occurrence of \r seen
            } else if (*bufptr=='\r') {
                linefeed = true;
                // Saw just data or \r without \n
            } else {
                linefeed = false;
                ++recvLenP;
            }

            ++bufptr;

            // Check that buffer won't be exceeded
            if (recvLenP >= destLenP) {
                error("Header wouldn't fit into buffer");
                recvLenP = 0;

                return false;
            }
        } else {
            error("No HTTP response received in 500ms");

            return false;
        }
    }

    return true;
}

bool cIptvProtocolHttp::ProcessHeaders() {
    debug1("%s", __PRETTY_FUNCTION__);

    unsigned int lineLength = 0;
    int version = 0, response = 0;
    bool responseFound = false;
    char fmt[32];
    char buf[4096];

    // Generate HTTP response format string with 2 arguments
    snprintf(fmt, sizeof(fmt), "HTTP/1.%%%zui %%%zui ", sizeof(version) - 1, sizeof(response) - 1);

    while (!responseFound || lineLength!=0) {
        memset(buf, 0, sizeof(buf));

        if (!GetHeaderLine(buf, sizeof(buf), lineLength)) {
            return false;
        }

        if (!responseFound && sscanf(buf, fmt, &version, &response)!=2) {
            error("Expected HTTP header not found");

            continue;
        } else {
            responseFound = true;
        }

        // Allow only 'OK' and 'Partial Content'
        if ((response!=200) && (response!=206)) {
            error("Invalid HTTP response (%d): %s", response, buf);

            return false;
        }
    }

    return true;
}

bool cIptvProtocolHttp::Open() {
    debug1("%s", __PRETTY_FUNCTION__);

    // Connect the socket
    return Connect();
}

bool cIptvProtocolHttp::Close() {
    debug1("%s", __PRETTY_FUNCTION__);

    // Disconnect the current stream
    Disconnect();

    return true;
}

int cIptvProtocolHttp::Read(unsigned char *bufferAddrP, unsigned int bufferLenP) {
    return cIptvTcpSocket::Read(bufferAddrP, bufferLenP);
}

bool cIptvProtocolHttp::SetSource(SourceParameter parameter) {
    debug1("%s (%s, %d, %d)", __PRETTY_FUNCTION__, parameter.locationP, parameter.parameterP, parameter.indexP);

    if (!isempty(parameter.locationP)) {
        // Disconnect the current socket
        Disconnect();

        // Update stream address, path and port
        streamAddrM = strcpyrealloc(streamAddrM, parameter.locationP);
        char *path = strstr(streamAddrM, "/");

        if (path) {
            streamPathM = strcpyrealloc(streamPathM, path);
            *path = 0;
        } else {
            streamPathM = strcpyrealloc(streamPathM, "/");
        }

        streamPortM = parameter.parameterP;

        // Re-connect the socket
        Connect();
    }

    return true;
}

bool cIptvProtocolHttp::SetPid(int pidP, int typeP, bool onP) {
    debug16("%s (%d, %d, %d)", __PRETTY_FUNCTION__, pidP, typeP, onP);

    return true;
}

cString cIptvProtocolHttp::GetInformation() {
    debug16("%s", __PRETTY_FUNCTION__);

    return cString::sprintf("http://%s:%d%s", streamAddrM, streamPortM, streamPathM);
}