MessageSpec.h

Go to the documentation of this file.

/****
 * MessageSpec.h - Template specification for constructing SSDP message packets
 *
 * Rather than manually constructing a message from scratch, the framework uses a template
 * to define the type of standard message to be sent with various parameters. Callbacks
 * may be used to customise the message before sending.
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the Sming SSDP 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 "Message.h"
#include <IpAddress.h>
 
#define SSDP_NOTIFY_SUBTYPE_MAP(XX)                                                                                    \
    XX(alive, "ssdp:alive")                                                                                            \
    XX(byebye, "ssdp:byebye")                                                                                          \
    XX(update, "ssdp:update")                                                                                          \
    XX(event, "upnp:propchange")
 
namespace SSDP
{
enum class NotifySubtype {
#define XX(type, str) type,
    SSDP_NOTIFY_SUBTYPE_MAP(XX)
#undef XX
        OTHER
};
 
enum class SearchTarget {
    root, 
    type, 
    uuid, 
    all,  
};
 
enum class SearchMatch {
    root, 
    uuid, 
    type, 
};
 
NotifySubtype getNotifySubtype(const char* subtype);
 
class MessageSpec
{
public:
    MessageSpec(MessageType type)
    {
        data.messageType = uint8_t(type);
        next = nullptr;
    }
 
    MessageSpec(MessageType type, SearchTarget target, void* object = nullptr)
    {
        data.messageType = uint8_t(type);
        data.target = uint8_t(target);
        m_object = object;
        next = nullptr;
    }
 
    MessageSpec(NotifySubtype nts, SearchTarget target, void* object = nullptr)
        : MessageSpec(MessageType::notify, target, object)
    {
        data.notifySubtype = uint8_t(nts);
    }
 
    MessageSpec(const MessageSpec& ms, SearchMatch match, void* object)
    {
        *this = ms;
        next = nullptr;
        data.match = uint8_t(match);
        m_object = object;
    }
 
    bool operator==(const MessageSpec& rhs) const
    {
        return m_object == rhs.m_object && remoteIp() == rhs.remoteIp() &&
               (data.packed & packed_mask) == (rhs.data.packed & packed_mask);
    }
 
    IpAddress remoteIp() const
    {
        return m_remoteIp;
    }
 
    uint16_t remotePort() const
    {
        return data.remotePort;
    }
 
    template <class Object> Object* object() const
    {
        return static_cast<Object*>(m_object);
    }
 
    MessageType type() const
    {
        return MessageType(data.messageType);
    }
 
    NotifySubtype notifySubtype() const
    {
        return NotifySubtype(data.notifySubtype);
    }
 
    SearchMatch match() const
    {
        return SearchMatch(data.match);
    }
 
    SearchTarget target() const
    {
        return SearchTarget(data.target);
    }
 
    void setTarget(SearchTarget target)
    {
        data.target = uint8_t(target);
    }
 
    void setRemote(IpAddress address, uint16_t port)
    {
        m_remoteIp = address;
        data.remotePort = port;
    }
 
    void setRepeat(uint8_t count)
    {
        data.repeat = count;
    }
 
    uint8_t repeat() const
    {
        return data.repeat;
    }
 
    bool shouldRepeat()
    {
        if(data.repeat == 0) {
            return false;
        }
        --data.repeat;
        return true;
    }
 
private:
    void* m_object{nullptr}; 
    IpAddress m_remoteIp{};  
    union Data {
        struct {
            uint32_t remotePort : 16;   
            uint32_t messageType : 4;   
            uint32_t notifySubtype : 4; 
            uint32_t match : 2;         
            uint32_t target : 2;        
            uint32_t repeat : 4;        
        };
        uint32_t packed{0};
    };
    Data data;
    // Compare all but the repeat value
    static constexpr uint32_t packed_mask{0x03FFFFFF};
 
    // These fields are used by the message queue
    friend class MessageQueue;
    uint32_t due;     
    MessageSpec* next; 
};
 
} // namespace SSDP
 
String toString(SSDP::NotifySubtype subtype);
String toString(SSDP::SearchTarget target);
String toString(SSDP::SearchMatch match);