1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

"""
IFS and Virtual Sensing Integration
Complete channel access timing model
"""
 
from enum import Enum, auto
from dataclasses import dataclass
from typing import Optional
 
# 802.11g timing constants (microseconds)
SLOT_TIME = 9
SIFS = 10
PIFS = SIFS + SLOT_TIME  # 19 μs
DIFS = SIFS + 2 * SLOT_TIME  # 28 μs
ACK_TIME = 44  # At 6 Mbps
EIFS = SIFS + ACK_TIME + DIFS  # 82 μs
 
class ChannelAccessState(Enum):
    """Station's channel access state machine."""
    IDLE = auto()
    BACKOFF = auto()
    WAIT_DIFS = auto()
    WAIT_EIFS = auto()
    WAIT_NAV = auto()
    TRANSMITTING = auto()
    RECEIVING = auto()
 
@dataclass
class ChannelAccessController:
    """Complete channel access controller with IFS and virtual sensing."""
    
    # Carrier sense states
    cca_busy: bool = False
    nav_remaining_us: int = 0
    
    # IFS states
    difs_timer_us: int = 0
    eifs_active: bool = False
    eifs_timer_us: int = 0
    
    # Backoff state
    backoff_remaining_slots: int = 0
    contention_window: int = 15  # CWmin for 802.11g
    
    # State machine
    state: ChannelAccessState = ChannelAccessState.IDLE
    
    def receive_frame_start(self):
        """Called when frame preamble detected."""
        self.cca_busy = True
        self.state = ChannelAccessState.RECEIVING
    
    def receive_frame_end(self, fcs_valid: bool, duration_us: int = 0,
                          is_for_me: bool = False):
        """
        Called when frame reception completes.
        
        Args:
            fcs_valid: True if FCS check passed
            duration_us: Duration field value (if FCS valid)
            is_for_me: True if this station is the intended recipient
        """
        self.cca_busy = False
        
        if not fcs_valid:
            # FCS error - enter EIFS recovery
            self.eifs_active = True
            self.eifs_timer_us = EIFS
            self.state = ChannelAccessState.WAIT_EIFS
            print(f"  FCS error → Enter EIFS ({EIFS} μs)")
            return
        
        # Valid frame
        self.eifs_active = False
        
        if not is_for_me and duration_us > 0:
            # Update NAV from other stations' frames
            if duration_us > self.nav_remaining_us:
                self.nav_remaining_us = duration_us
                print(f"  NAV updated to {duration_us} μs")
        
        self.update_state()
    
    def update_state(self):
        """Update state machine based on current conditions."""
        if self.cca_busy:
            self.state = ChannelAccessState.RECEIVING
            return
        
        if self.eifs_active and self.eifs_timer_us > 0:
            self.state = ChannelAccessState.WAIT_EIFS
            return
        
        if self.nav_remaining_us > 0:
            self.state = ChannelAccessState.WAIT_NAV
            return
        
        if self.difs_timer_us > 0:
            self.state = ChannelAccessState.WAIT_DIFS
            return
        
        if self.backoff_remaining_slots > 0:
            self.state = ChannelAccessState.BACKOFF
            return
        
        self.state = ChannelAccessState.IDLE
    
    def advance_time(self, delta_us: int):
        """Advance all timers by delta_us microseconds."""
        if self.nav_remaining_us > 0:
            self.nav_remaining_us = max(0, self.nav_remaining_us - delta_us)
        
        if self.eifs_timer_us > 0:
            self.eifs_timer_us = max(0, self.eifs_timer_us - delta_us)
            if self.eifs_timer_us == 0:
                self.eifs_active = False
        
        if self.difs_timer_us > 0:
            self.difs_timer_us = max(0, self.difs_timer_us - delta_us)
        
        # Backoff decrements only when channel idle
        if (not self.cca_busy and 
            self.nav_remaining_us == 0 and 
            not self.eifs_active and
            self.backoff_remaining_slots > 0):
            # Decrement by number of slot times in delta
            slots_elapsed = delta_us // SLOT_TIME
            self.backoff_remaining_slots = max(0, 
                self.backoff_remaining_slots - slots_elapsed)
        
        self.update_state()
    
    def can_transmit(self) -> bool:
        """Check if station can transmit now."""
        return (self.state == ChannelAccessState.IDLE and
                self.backoff_remaining_slots == 0 and
                not self.cca_busy and
                self.nav_remaining_us == 0 and
                not self.eifs_active)
    
    def initiate_transmission(self):
        """Begin transmission process."""
        if self.can_transmit():
            # Need to wait DIFS first
            self.difs_timer_us = DIFS
            self.state = ChannelAccessState.WAIT_DIFS
            print(f"  Starting DIFS wait ({DIFS} μs)")
    
    def get_status(self) -> str:
        """Get current status string."""
        return (f"State: {self.state.name}, CCA: {'BUSY' if self.cca_busy else 'idle'}, "
                f"NAV: {self.nav_remaining_us} μs, EIFS: {self.eifs_timer_us} μs, "
                f"Backoff: {self.backoff_remaining_slots} slots")
 
 
def demonstrate_ifs_interaction():
    """Demonstrate IFS and virtual sensing interaction."""
    
    print("=== IFS and Virtual Sensing Demonstration ===")
    print()
    
    controller = ChannelAccessController()
    
    print("Initial state:", controller.get_status())
    print()
    
    # Scenario 1: Normal NAV from CTS
    print("--- Scenario 1: Receive valid CTS (not for us) ---")
    controller.receive_frame_start()
    print("  Receiving CTS...")
    controller.receive_frame_end(fcs_valid=True, duration_us=1000, is_for_me=False)
    print("  Status:", controller.get_status())
    print()
    
    # Time passes, NAV decrements
    print("--- 500 μs later ---")
    controller.advance_time(500)
    print("  Status:", controller.get_status())
    print()
    
    # Scenario 2: FCS error triggers EIFS
    print("--- Scenario 2: Receive corrupted frame ---")
    controller.receive_frame_start()
    print("  Receiving frame...")
    controller.receive_frame_end(fcs_valid=False)
    print("  Status:", controller.get_status())
    print()
    
    # EIFS runs in parallel with remaining NAV
    print("--- 100 μs later ---")
    controller.advance_time(100)
    print("  Status:", controller.get_status())
    print()
    
    # Everything clears
    print("--- 1500 μs later (all timers expire) ---")
    controller.advance_time(1500)
    print("  Status:", controller.get_status())
    print(f"  Can transmit: {controller.can_transmit()}")
 
demonstrate_ifs_interaction()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

"""
Virtual Sensing Failure Mode Analysis
Demonstrates scenarios where virtual sensing provides incomplete protection
"""
 
from dataclasses import dataclass
from typing import List, Tuple
 
@dataclass
class TransmissionEvent:
    """Represents a transmission attempt and its outcome."""
    station: str
    start_time_us: int
    duration_us: int
    target: str
    success: bool
    failure_reason: str = ""
 
def analyze_sifs_race_condition():
    """
    Analyze the SIFS boundary race condition.
    
    Scenario: Hidden terminal starts transmitting during SIFS
    between RTS and CTS.
    """
    
    print("=== SIFS Race Condition Analysis ===")
    print()
    
    # Timeline
    RTS_END = 52  # RTS transmission ends
    SIFS = 10      # SIFS duration
    CTS_START = RTS_END + SIFS  # = 62 μs
    
    # Hidden terminal C's transmission attempt
    # C checks channel during SIFS (RTS already ended, CTS not started)
    C_CCA_CHECK = 55  # During SIFS
    C_TX_START = 55   # If C decides to transmit
    
    print(f"RTS ends at:      T = {RTS_END} μs")
    print(f"SIFS period:      T = {RTS_END} to {CTS_START} μs")
    print(f"CTS starts at:    T = {CTS_START} μs")
    print()
    print(f"Hidden terminal C checks channel at: T = {C_CCA_CHECK} μs")
    print(f"  → CCA result: IDLE (RTS ended, CTS not started)")
    print(f"  → NAV at C: 0 (C never heard RTS)")
    print(f"  → C's decision: TRANSMIT")
    print()
    
    if C_TX_START < CTS_START:
        print(f"🔴 COLLISION: C starts at {C_TX_START} μs, CTS at {CTS_START} μs")
        print(f"   Both C's frame and CTS collide at stations that hear both")
        print(f"   Hidden terminal protection FAILED for this case")
    else:
        print(f"🟢 No collision: C would start after CTS")
    
    print()
    return C_TX_START < CTS_START
 
def analyze_distant_hidden_terminal():
    """
    Analyze distant hidden terminal that barely hears CTS.
    """
    
    print("=== Distant Hidden Terminal Analysis ===")
    print()
    
    # Signal strength calculations (simplified)
    CTS_TX_POWER_DBM = 20
    PATH_LOSS_NEAR = 70  # dB at normal distance
    PATH_LOSS_FAR = 90   # dB at far distance
    
    RX_SENSITIVITY = -82  # dBm, minimum for valid decode
    
    near_rx_power = CTS_TX_POWER_DBM - PATH_LOSS_NEAR  # -50 dBm
    far_rx_power = CTS_TX_POWER_DBM - PATH_LOSS_FAR    # -70 dBm
    
    print(f"CTS transmit power: {CTS_TX_POWER_DBM} dBm")
    print(f"Receiver sensitivity: {RX_SENSITIVITY} dBm")
    print()
    print(f"Near hidden terminal (70 dB loss):")
    print(f"  Received power: {near_rx_power} dBm")
    print(f"  Can decode CTS: {'YES ✓' if near_rx_power > RX_SENSITIVITY else 'NO ✗'}")
    print(f"  NAV protection: {'YES' if near_rx_power > RX_SENSITIVITY else 'NO (EIFS only)'}")
    print()
    print(f"Far hidden terminal (90 dB loss):")
    print(f"  Received power: {far_rx_power} dBm")
    print(f"  Can decode CTS: {'YES ✓' if far_rx_power > RX_SENSITIVITY else 'NO ✗'}")
    
    if far_rx_power > RX_SENSITIVITY:
        print(f"  NAV protection: YES")
    else:
        # Check if energy detection triggers
        ED_THRESHOLD = -62  # dBm for energy detection
        if far_rx_power > ED_THRESHOLD:
            print(f"  Energy detected: YES → defers based on CCA")
        else:
            print(f"  Energy detected: NO")
            print(f"  NAV protection: NO (frame not received)")
            print(f"  → Distant hidden terminal may transmit!")
    
    print()
    return far_rx_power < RX_SENSITIVITY
 
def analyze_nav_attack():
    """
    Analyze NAV-based denial of service attack.
    """
    
    print("=== NAV Attack Analysis ===")
    print()
    
    MAX_DURATION = 32767  # Maximum Duration field value (μs)
    ATTACK_FRAME_RATE = 30  # Frames per second
    
    # Attacker sends one frame with max Duration every 33ms
    attack_cycle_ms = 1000 / ATTACK_FRAME_RATE  # 33.3 ms
    denial_per_cycle_ms = MAX_DURATION / 1000   # 32.7 ms
    
    print(f"Attack parameters:")
    print(f"  Max Duration value: {MAX_DURATION} μs ({MAX_DURATION/1000:.1f} ms)")
    print(f"  Attack frame rate: {ATTACK_FRAME_RATE} frames/second")
    print(f"  Attack cycle: {attack_cycle_ms:.1f} ms")
    print()
    print(f"Impact per cycle:")
    print(f"  Channel denied: {denial_per_cycle_ms:.1f} ms")
    print(f"  Channel available: {attack_cycle_ms - denial_per_cycle_ms:.1f} ms")
    print()
    
    effective_throughput_ratio = (attack_cycle_ms - denial_per_cycle_ms) / attack_cycle_ms
    print(f"Effective channel capacity: {effective_throughput_ratio * 100:.1f}%")
    print(f"Denial of service severity: {(1 - effective_throughput_ratio) * 100:.1f}%")
    print()
    
    if effective_throughput_ratio < 0.1:
        print("🔴 SEVERE: Network essentially unusable")
    elif effective_throughput_ratio < 0.5:
        print("🟡 MODERATE: Significant performance degradation")
    else:
        print("🟢 MILD: Some throughput loss")
 
# Run analyses
print("="*60)
analyze_sifs_race_condition()
print("="*60)
analyze_distant_hidden_terminal()
print("="*60)
analyze_nav_attack()