From b565d7d9c47ca1ec5af0effd828431ee96027d60 Mon Sep 17 00:00:00 2001
From: srdusr <99972264+srdusr@users.noreply.github.com>
Date: Mon, 27 May 2024 22:00:00 +0200
Subject: Rename project from wireframe to packeteer

Decided on the name after weighing alternatives in NAMES.md: packeteer
(packet + -eer, "one who wields packets") fit the project's actual
scope better than the wire/frame pun once it had grown into full
L2-L7 dissection, reassembly, checksums, privilege dropping, and dual
TUI/GUI frontends. No existing packet-capture project uses the name;
the one real-world collision (Packeteer, Inc., a networking company
acquired and folded into Blue Coat/Symantec by 2008) is long defunct.

Mechanical rename throughout: CMake project/target names, the
wireframe:: namespace and include/wireframe/ directory (git mv,
history preserved), every #include path, CLI/GUI help text, and the
project's own working directory. NAMES.md rewritten to record the
decision instead of leaving stale self-referential etymology behind
from the blind rename pass.

Verified after every step: full rebuild (all four targets, no
warnings) and the full test suite (128/128 cases, 366/366 assertions)
both from a fresh reconfigure and again after the directory move.
---
 include/wireframe/capture_queue.hpp | 98 -------------------------------------
 1 file changed, 98 deletions(-)
 delete mode 100644 include/wireframe/capture_queue.hpp

(limited to 'include/wireframe/capture_queue.hpp')

diff --git a/include/wireframe/capture_queue.hpp b/include/wireframe/capture_queue.hpp
deleted file mode 100644
index 14794ba..0000000
--- a/include/wireframe/capture_queue.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#pragma once
-
-#include <condition_variable>
-#include <cstdint>
-#include <mutex>
-#include <optional>
-#include <queue>
-#include <vector>
-
-// Bounded queue between the capture thread and the render/analysis
-// thread (PLAN.md's architecture sketch). Owns a copy of each packet's
-// bytes since the buffer libpcap hands the callback is only valid for
-// the duration of that call.
-namespace wireframe {
-
-struct CapturedPacket {
-    std::uint32_t ts_sec;
-    std::uint32_t ts_usec;
-    std::uint32_t original_len;
-    std::vector<unsigned char> data;  // caplen bytes
-};
-
-// Single-producer / single-consumer. Two producer-side push variants
-// for two different producers with different constraints: a live
-// capture thread can't be allowed to stall (PLAN.md is explicit that a
-// traffic spike should drop packets, not block), but a replay-from-file
-// producer has no such real-time pressure, and dropping from a fixed
-// historical record would defeat the point of "faithfully replaying
-// what was captured" - so it blocks for room instead.
-class CaptureQueue {
-public:
-    explicit CaptureQueue(std::size_t capacity) : capacity_(capacity) {}
-
-    // Never blocks: drops the packet and counts it if the queue is full.
-    bool try_push(CapturedPacket&& packet) {
-        {
-            std::lock_guard<std::mutex> lock(mutex_);
-            if (queue_.size() >= capacity_) {
-                ++dropped_;
-                return false;
-            }
-            queue_.push(std::move(packet));
-        }
-        cv_.notify_all();
-        return true;
-    }
-
-    // Blocks until there's room, then pushes. Returns false without
-    // pushing if stop() is called while waiting - the consumer side is
-    // going away, so nothing will ever pop it.
-    bool push(CapturedPacket&& packet) {
-        {
-            std::unique_lock<std::mutex> lock(mutex_);
-            cv_.wait(lock, [this] { return queue_.size() < capacity_ || stopped_; });
-            if (stopped_) return false;
-            queue_.push(std::move(packet));
-        }
-        cv_.notify_all();
-        return true;
-    }
-
-    // Blocks until a packet is available. Returns nullopt only once
-    // stop() has been called and the queue has fully drained - so a
-    // consumer loop on pop() processes everything queued before the
-    // capture side stopped, rather than discarding it.
-    std::optional<CapturedPacket> pop() {
-        std::unique_lock<std::mutex> lock(mutex_);
-        cv_.wait(lock, [this] { return !queue_.empty() || stopped_; });
-        if (queue_.empty()) return std::nullopt;
-        CapturedPacket packet = std::move(queue_.front());
-        queue_.pop();
-        cv_.notify_all();  // wake a push() blocked on room, if any
-        return packet;
-    }
-
-    void stop() {
-        {
-            std::lock_guard<std::mutex> lock(mutex_);
-            stopped_ = true;
-        }
-        cv_.notify_all();
-    }
-
-    std::uint64_t dropped() const {
-        std::lock_guard<std::mutex> lock(mutex_);
-        return dropped_;
-    }
-
-private:
-    mutable std::mutex mutex_;
-    std::condition_variable cv_;
-    std::queue<CapturedPacket> queue_;
-    std::size_t capacity_;
-    bool stopped_ = false;
-    std::uint64_t dropped_ = 0;
-};
-
-}  // namespace wireframe
-- 
cgit v1.2.3