file_pcap.h

Go to the documentation of this file.

// Copyright 2024-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <hal_posix/file_io.h>
#include <satcat5/datetime.h>
 
// Buffer size must be large enough for one full-size Ethernet frame.
#ifndef SATCAT5_PCAP_BUFFSIZE
#define SATCAT5_PCAP_BUFFSIZE   1600
#endif
 
namespace satcat5 {
    namespace io {
        constexpr u16 LINKTYPE_ETHERNET     = 1;    // Ethernet (Default)
        constexpr u16 LINKTYPE_USER0        = 147;  // User-defined type #0
        constexpr u16 LINKTYPE_AOS          = 222;  // CCSDS-AOS Space Data Link
        constexpr u16 LINKTYPE_USER(u16 x)          // User-defined type #0-15
            { return LINKTYPE_USER0 + x; }          // Reserved for private use
 
        class ReadPcap : public satcat5::io::ArrayRead {
        public:
            explicit ReadPcap(const char* filename = 0);
 
            void open(const char* filename);
            inline void open(const std::string& filename)
                { open(filename.c_str()); }
 
            inline void close() {m_file.close();}
 
            void read_finalize() override;
 
        protected:
            // Read specific block formats.
            void pcap_hdr();    // Start-of-file header
            bool pcap_dat();    // Packet record
            bool pcapng_blk();  // Read next block (any type)
            void pcapng_shb();  // Section header block
            void pcapng_idb();  // Interface description block
            void pcapng_spb();  // Simple packet block
            void pcapng_epb();  // Enhanced packet block
            void pcapng_skip(); // Any unsupported block
 
            // Shortcuts for reading from the file.
            inline u16 file_rd16()
                { return m_mode_be ? m_file.read_u16() : m_file.read_u16l(); }
            inline u32 file_rd32()
                { return m_mode_be ? m_file.read_u32() : m_file.read_u32l(); }
 
            // Internal state and working buffer.
            satcat5::io::FileReader m_file;
            bool m_mode_be;         // Big-endian file?
            bool m_mode_ng;         // PCAPNG format?
            bool m_mode_pc;         // PCAPNG format?
            u32 m_trim;             // Ignore FCS bytes?
            u8 m_buff[SATCAT5_PCAP_BUFFSIZE];
        };
 
        class WritePcap : public satcat5::io::ArrayWrite {
        public:
            explicit WritePcap(bool pcapng = true);
 
            void open(const char* filename, u16 type = LINKTYPE_ETHERNET);
            inline void open(const std::string& filename, u16 type = LINKTYPE_ETHERNET)
                { open(filename.c_str(), type); }
 
            inline void close()
                { m_file.close(); }
 
            u32 add_interface(const char* name, u16 type = LINKTYPE_ETHERNET);
 
            inline void set_interface(u32 id)
                { m_interface_next = id; }
 
            inline void set_passthrough(satcat5::io::Writeable* wr)
                { m_pass = wr; }
 
            bool write_finalize() override;
 
        protected:
            // Internal state and working buffer.
            satcat5::datetime::Clock m_clock;
            satcat5::io::FileWriter m_file;
            satcat5::io::Writeable* m_pass;
            const bool m_mode_ng;   // PCAPNG format?
            u32 m_interface_count, m_interface_next;
            u8 m_buff[SATCAT5_PCAP_BUFFSIZE];
        };
 
        class WritePcapInterface : public satcat5::io::WriteableRedirect {
        public:
            WritePcapInterface(
                satcat5::io::WritePcap* pcap,
                const char* label, u16 type = LINKTYPE_ETHERNET);
 
            bool write_finalize() override;
 
        protected:
            satcat5::io::WritePcap* const m_pcap;
            const u32 m_id;
        };
    }
}