rtmphandshake.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cstdint>
#include <promeki/buffer.h>
#include <promeki/bufferview.h>
#include <promeki/enums.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/namespace.h>
#include <promeki/objectbase.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class RtmpHandshake : public ObjectBase {
                PROMEKI_OBJECT(RtmpHandshake, ObjectBase)
        public:
                enum State {
                        NotStarted,      
                        ExchangingC0C1,  
                        ExchangingC2S2,  
                        Done,            
                        Failed           
                };
 
                static constexpr uint8_t Version = 0x03;
 
                static constexpr int ChunkSize = 1536;
 
                explicit RtmpHandshake(RtmpRole role, ObjectBase *parent = nullptr);
 
                ~RtmpHandshake() override;
 
                Error setMode(RtmpHandshakeMode mode);
 
                RtmpHandshakeMode mode() const { return _mode; }
 
                RtmpHandshakeMode negotiatedMode() const { return _negotiatedMode; }
 
                Buffer pendingOutput();
 
                Error feed(const BufferView &data);
 
                void markPeerClosed();
 
                State state() const { return _state; }
 
                Error lastError() const { return _lastError; }
 
                RtmpRole role() const { return _role; }
 
                uint32_t peerEpoch() const { return _peerEpoch; }
 
                uint32_t localEpoch() const { return _localEpoch; }
 
                void setLocalEpoch(uint32_t epoch);
 
                Error setLocalNonce(const BufferView &nonce);
 
                PROMEKI_SIGNAL(complete);
 
                PROMEKI_SIGNAL(failed, Error);
 
        private:
                enum InternalStep {
                        StepSendC0C1,    
                        StepRecvS0S1,    
                        StepSendC2,      
                        StepRecvS2,      
                        StepRecvC0C1,    
                        StepSendS0S1S2,  
                        StepRecvC2,      
                        StepDone
                };
 
                void   advance();
                void   fail(Error err);
                Error  produceClientC1();
                Error  produceClientC2();
                Error  produceServerS0S1S2();
                Error  consumePeerC0C1();          
                Error  consumePeerS0S1();          
                Error  consumePeerC2();            
                Error  consumePeerS2();            
 
                RtmpRole          _role;
                RtmpHandshakeMode _mode = RtmpHandshakeMode::Auto;
                RtmpHandshakeMode _negotiatedMode = RtmpHandshakeMode::Auto;
                State             _state = NotStarted;
                InternalStep      _step = StepSendC0C1;
                Error             _lastError = Error::Ok;
 
                uint32_t _localEpoch = 0;
                uint32_t _peerEpoch = 0;
 
                bool _outEmittedFirst = false;     
                bool _hasOverrideNonce = false;
                List<uint8_t> _overrideNonce;      
 
                List<uint8_t> _outBuffer;          
                List<uint8_t> _inBuffer;           
 
                // ---- Complex-handshake bookkeeping ----
                int    _localScheme = 1;           
                int    _peerScheme = -1;           
                List<uint8_t> _localC1S1;          
                List<uint8_t> _peerC1S1;           
                uint8_t _localDigest[32] = {};     
                uint8_t _peerDigest[32] = {};      
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK