packetdemux.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/buffer.h>
#include <promeki/bufferview.h>
#include <promeki/enums_pcap.h>
#include <promeki/ipv4address.h>
#include <promeki/ipv6address.h>
#include <promeki/list.h>
#include <promeki/socketaddress.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct UdpDatagram {
                SocketAddress src;
                SocketAddress dst;
                BufferView payload;
                uint8_t ipProtocol = 17;
                bool reassembled = false;
};
 
enum class DemuxStatus {
        Ok,          
        NotUdp,      
        Fragment,    
        Truncated,   
        Malformed,   
        Unsupported, 
};
 
struct DemuxResult {
                DemuxStatus status = DemuxStatus::Malformed;
                UdpDatagram datagram;
};
 
class PacketDemux {
        public:
                static constexpr size_t MaxInFlight = 64;
 
                static constexpr size_t MaxDatagramSize = 65535;
 
                static constexpr uint8_t ProtocolUdp = 17;
 
                static constexpr uint16_t EtherTypeIpv4 = 0x0800;
                static constexpr uint16_t EtherTypeIpv6 = 0x86dd;
                static constexpr uint16_t EtherTypeVlan = 0x8100;  
                static constexpr uint16_t EtherTypeVlanS = 0x88a8; 
 
                PacketDemux() = default;
 
                DemuxResult demux(PcapLinkType linkType, const BufferView &frame);
 
                void reset();
 
                size_t pendingReassemblies() const { return _reasm.size(); }
 
        private:
                enum class L3 {
                        Ipv4,        
                        Ipv6,        
                        NotIp,       
                        TooShort,    
                        Unsupported, 
                };
 
                struct Reasm {
                                bool ipv6 = false;
                                SocketAddress src;      
                                SocketAddress dst;      
                                uint32_t id = 0;        
                                uint8_t protocol = 0;   
                                Buffer data;            
                                List<uint8_t> filled;   
                                size_t totalLength = 0; 
                                bool haveTotal = false;
                                uint64_t tick = 0;      
                };
 
                // Resolve the link layer: returns the IP family (or a
                // non-IP / error status) and, for IP, the byte offset at
                // which the IP header begins.
                L3 resolveL3(PcapLinkType linkType, const uint8_t *p, size_t n, size_t &l3off) const;
 
                DemuxResult demuxIpv4(const BufferView &frame, const uint8_t *p, size_t n, size_t l3off);
                DemuxResult demuxIpv6(const BufferView &frame, const uint8_t *p, size_t n, size_t l3off);
 
                // Build a UDP datagram from a contiguous L4 region.  When
                // @p ownerBuf is valid the region lives in it (reassembled
                // path) and the payload view aliases it; otherwise the
                // region lives in @p frame and the payload view aliases the
                // capture buffer at absolute offset @p l4abs.
                DemuxResult finishUdp(const BufferView &frame, const uint8_t *l4, size_t l4len,
                                      const SocketAddress &srcNoPort, const SocketAddress &dstNoPort,
                                      const Buffer &ownerBuf, size_t l4abs, bool reassembled);
 
                // Find-or-create the reassembly entry for this fragment,
                // copy its bytes in, and return Ok with the rebuilt datagram
                // once coverage is complete (else DemuxStatus::Fragment).
                DemuxResult reassemble(const BufferView &frame, bool ipv6, const SocketAddress &srcNoPort,
                                       const SocketAddress &dstNoPort, uint32_t id, uint8_t upperProtocol,
                                       const uint8_t *fragData, size_t fragLen, size_t fragOffset, bool moreFragments);
 
                List<Reasm> _reasm;     
                uint64_t _tick = 0;     
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK