Envelope.h

Go to the documentation of this file.

/****
 * Envelope.h
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the Sming UPnP Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 ****/

#pragma once

#include <RapidXML.h>
#include "Error.h"
#include "ErrorCode.h"
#include "Base64.h"

namespace UPnP
{
using Error = UPnP::Error;
class Service;

class Envelope
{
public:
    enum class ContentType {
        none,
        fault,
        request,
        response,
    };

    class Fault
    {
    public:
        Fault(Envelope& envelope) : envelope(envelope)
        {
        }

        explicit operator bool() const
        {
            return envelope.isFault();
        }

        String faultCode() const;
        String faultString() const;
        ErrorCode errorCode() const;
        String errorDescription() const;

        size_t printTo(Print& p) const;

    private:
        Envelope& envelope;
        XML::Node* detail() const;
        XML::Node* error() const;
    };

    Envelope(const Service& service) : service(service)
    {
    }

    void clear();

    bool isEmpty() const
    {
        return type == ContentType::none;
    }

    bool isFault() const
    {
        return type == ContentType::fault;
    }

    Error load(String&& content);

    Error load(const FlashString& content);
    String serialize(bool pretty)
    {
        prepareResponse();
        return XML::serialize(doc, pretty);
    }

    size_t serialize(Print& p, bool pretty)
    {
        prepareResponse();
        return XML::serialize(doc, p, pretty);
    }

    ContentType contentType() const
    {
        return type;
    }

    String actionName() const
    {
        return name;
    }

    Envelope& createRequest(const String& actionName);

    Envelope& createResponse(const String& actionName);

    void convertToResponse()
    {
        if(type == ContentType::request) {
            type = ContentType::response;
            responsePrepared = false;
        }
    }

    void prepareResponse()
    {
        if(type == Envelope::ContentType::response && !responsePrepared) {
            createResponse(actionName());
        }
    }

    Fault createFault(ErrorCode error);

    Fault fault()
    {
        return Fault(*this);
    }

    const Fault fault() const
    {
        return Fault(*const_cast<Envelope*>(this));
    }

    const char* getArgValue(const String& name) const
    {
        auto node = XML::getNode(content, name, "");
        return node ? node->value() : nullptr;
    }

    String getArg(const String& name) const
    {
        return XML::getValue(content, name, "");
    }

    bool getArg(const String& name, char& value, char defaultValue = '?')
    {
        auto s = getArgValue(name);
        if(s == nullptr) {
            value = defaultValue;
            return false;
        }

        value = *s;
        return true;
    }

    bool getArg(const String& name, String& value)
    {
        value = getArg(name);
        return bool(value);
    }

    template <typename T>
    typename std::enable_if<std::is_unsigned<T>::value && !std::is_floating_point<T>::value, bool>::type
    getArg(const String& name, T& value, T defaultValue = T{})
    {
        uint32_t n;
        if(!getArg(name, n, defaultValue)) {
            value = defaultValue;
            return false;
        }

        value = n;
        return true;
    }

    template <typename T>
    typename std::enable_if<std::is_signed<T>::value && !std::is_floating_point<T>::value, bool>::type
    getArg(const String& name, T& value, T defaultValue = T{})
    {
        int32_t n;
        if(!getArg(name, n, defaultValue)) {
            value = defaultValue;
            return false;
        }

        value = n;
        return true;
    }

    bool getArg(const String& name, bool& value, bool defaultValue = false);
    bool getArg(const String& name, uint32_t& value, uint32_t defaultValue = 0);
    bool getArg(const String& name, int32_t& value, int32_t defaultValue = 0);
    bool getArg(const String& name, float& value, float defaultValue = 0.0);
    bool getArg(const String& name, double& value, double defaultValue = 0.0);

    bool getArg(const String& name, Base64& value)
    {
        value = getArgValue(name);
        return bool(value);
    }

    bool addArg(const String& name, const String& value)
    {
        prepareResponse();
        assert(type == ContentType::request || type == ContentType::response);
        XML::appendNode(content, name, value);
        return true;
    }

    bool addArg(const String& name, const char* value)
    {
        return addArg(name, String(value));
    }

    bool addArg(const String& name, bool value)
    {
        return addArg(name, value ? "1" : "0");
    }

    bool addArg(const String& name, const Base64& value)
    {
        return addArg(name, value.encode());
    }

    template <typename T> bool addArg(const String& name, T value)
    {
        return addArg(name, String(value));
    }

    String soapAction() const;

    const Service& service;

private:
    Error parseBody();
    Error verifyObjectType(const String& objectType) const;
    XML::Node* initialise(ContentType contentType);

    XML::Document doc;
    String buffer;
    String name;
    XML::Node* content{nullptr};
    ContentType type{};
    Error lastError{};
    bool responsePrepared{false};
};

} // namespace UPnP