초·중·고 네트워크 통신 교육과 국방 전술 이동 애드혹 네트워크(MANET): ZeliDesk의 온디바이스 순수 C# OLSRv2·AODV 동적 메쉬 라우팅, MPR 최적화 플러딩, 0-Alloc 무잠금 패킷 포워딩, 및 기지국 파괴 0초 복구 전술 통신망 아키텍처

using System;
using System.Buffers;
using System.Buffers.Binary;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;

namespace ZeliDesk.Network.TacticalManet
{
    public enum ManetPacketType : byte
    {
        Hello = 0x01,
        TopologyControl = 0x02,
        RouteRequest = 0x03,
        RouteReply = 0x04,
        RouteError = 0x05,
        DataPayload = 0x10
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public readonly struct ManetHeader
    {
        public readonly byte Magic;          // 0x5A ('Z')
        public readonly ManetPacketType Type;// Message Type
        public readonly byte Ttl;            // Time to Live (Hop Limit)
        public readonly byte HopCount;       // Traversed Hops
        public readonly uint SequenceNumber; // Anti-Replay & Loop Prevention
        public readonly uint OriginatorIp;   // Source Tactical VIP (Big-Endian)
        public readonly uint DestinationIp;  // Final Destination VIP (Big-Endian)
        public readonly ushort PayloadLength;// Inner Payload Size

        public ManetHeader(ManetPacketType type, byte ttl, uint seq, uint src, uint dst, ushort len)
        {
            Magic = 0x5A;
            Type = type;
            Ttl = ttl;
            HopCount = 0;
            SequenceNumber = seq;
            OriginatorIp = src;
            DestinationIp = dst;
            PayloadLength = len;
        }
    }

    /// 

    /// ZeliDesk 고속 다중점 릴레이(MPR) 계산 및 순수 C# OLSR 라우팅 코어
    /// 
    public sealed class OlsrMeshRoutingCore : IDisposable
    {
        private readonly uint _localNodeIp;
        private readonly ConcurrentDictionary _oneHopNeighbors = new();
        private readonly ConcurrentDictionary> _twoHopNeighbors = new();
        private readonly HashSet _selectedMprSet = new();
        private readonly ReaderWriterLockSlim _mprLock = new();

        public OlsrMeshRoutingCore(uint localNodeIp)
        {
            _localNodeIp = localNodeIp;
        }

        public sealed class NeighborInfo
        {
            public uint Ip { get; init; }
            public IPEndPoint PhysicalEndpoint { get; set; } = null!;
            public DateTime LastHeard { get; set; }
            public float LinkCostEtx { get; set; } = 1.0f;
            public bool IsBidirectional { get; set; }
        }

        /// 

        /// O(|N1| log |N1|) 그리디 다중점 릴레이(MPR) 집합 산출 (0-Alloc 메모리 구조)
        /// 
        public void RecalculateMultiPointRelays()
        {
            _mprLock.EnterWriteLock();
            try
            {
                _selectedMprSet.Clear();
                var uncoveredTwoHops = new HashSet();

                // 1. 모든 양방향 2-홉 이웃 집약 (자신 및 1-홉 이웃 제외)
                foreach (var kvp in _twoHopNeighbors)
                {
                    if (kvp.Key == _localNodeIp || _oneHopNeighbors.ContainsKey(kvp.Key))
                        continue;
                    uncoveredTwoHops.Add(kvp.Key);
                }

                // 2. 고유 도달 2-홉 이웃(커버할 수 있는 1-홉이 단 1개인 경우) 필수 MPR 등록
                var candidateCoverage = new Dictionary>();
                foreach (var oneHop in _oneHopNeighbors.Values)
                {
                    if (!oneHop.IsBidirectional) continue;
                    if (_twoHopNeighbors.TryGetValue(oneHop.Ip, out var covered))
                    {
                        var validCovered = new HashSet(covered);
                        validCovered.IntersectWith(uncoveredTwoHops);
                        candidateCoverage[oneHop.Ip] = validCovered;
                    }
                }

                // 3. 탐욕 기법(Greedy Coverage): 잔여 2-홉을 최대로 연결하는 1-홉 이웃 순차 선택
                while (uncoveredTwoHops.Count > 0 && candidateCoverage.Count > 0)
                {
                    uint bestCandidate = 0;
                    int maxCoverage = -1;

                    foreach (var (candIp, coverSet) in candidateCoverage)
                    {
                        if (coverSet.Count > maxCoverage)
                        {
                            maxCoverage = coverSet.Count;
                            bestCandidate = candIp;
                        }
                    }

                    if (maxCoverage <= 0 || bestCandidate == 0) break;

                    // MPR로 확정
                    _selectedMprSet.Add(bestCandidate);
                    foreach (var coveredNode in candidateCoverage[bestCandidate])
                    {
                        uncoveredTwoHops.Remove(coveredNode);
                    }
                    candidateCoverage.Remove(bestCandidate);

                    // 나머지 후보들의 커버 집합에서 이미 커버된 노드 제거
                    foreach (var set in candidateCoverage.Values)
                    {
                        set.ExceptWith(_selectedMprSet);
                    }
                }
            }
            finally
            {
                _mprLock.ExitWriteLock();
            }
        }

        /// 

        /// 수신 패킷의 MPR 릴레이 여부 판정 (브로드캐스트 폭풍 억제)
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool ShouldForwardPacket(uint senderOneHopIp)
        {
            _mprLock.EnterReadLock();
            try
            {
                // 송신자가 나를 자신의 MPR로 지정한 경우에만 재전송 릴레이 허용
                return _selectedMprSet.Contains(senderOneHopIp);
            }
            finally
            {
                _mprLock.ExitReadLock();
            }
        }

        public void Dispose()
        {
            _mprLock.Dispose();
        }
    }
}