CN Lab

Usage: ping [-t] [-a] [-n count] [-l size] [-f] [-i TTL] [-v TOS]

            [-r count] [-s count] [[-j host-list] | [-k host-list]]

            [-w timeout] [-R] [-S srcaddr] [-c compartment] [-p]

            [-4] [-6] target_name

Options:

    -t             Ping the specified host until stopped.

                   To see statistics and continue - type Control-Break;

                   To stop - type Control-C.

    -a             Resolve addresses to hostnames.

    -n count       Number of echo requests to send.

    -l size        Send buffer size.

    -f             Set Don't Fragment flag in packet (IPv4-only).

    -i TTL         Time To Live.

    -v TOS         Type Of Service (IPv4-only. This setting has been deprecated

                   and has no effect on the type of service field in the IP

                   Header).

    -r count       Record route for count hops (IPv4-only).

    -s count       Timestamp for count hops (IPv4-only).

    -j host-list   Loose source route along host-list (IPv4-only).

    -k host-list   Strict source route along host-list (IPv4-only).

    -w timeout     Timeout in milliseconds to wait for each reply.

    -R             Use routing header to test reverse route also (IPv6-only).

                   Per RFC 5095 the use of this routing header has been

                   deprecated. Some systems may drop echo requests if

                   this header is used.

    -S srcaddr     Source address to use.

    -c compartment Routing compartment identifier.

    -p             Ping a Hyper-V Network Virtualization provider address.

    -4             Force using IPv4.

    -6             Force using IPv6.

# Experiment2a Character Stuffing with correct escape logic (esc after flag/esc)

def character_stuffing(data, flag='F', esc='E'):

    stuffed_data = flag  # Start with the flag

    for char in data:

        if char == flag or char == esc:

            stuffed_data += esc  # Insert escape BEFORE special char

        stuffed_data += char

    stuffed_data += flag  # End with the flag

    return stuffed_data

def character_unstuffing(stuffed_data, flag='F', esc='E'):

    unstuffed_data = ''

    i = 1  # Skip starting flag

    while i < len(stuffed_data) - 1:

        if stuffed_data[i] == esc:

            i += 1  # Skip the escape character

        unstuffed_data += stuffed_data[i]

        i += 1

    return unstuffed_data

# --- Runtime input ---

data = input("Enter the data to be stuffed: ")

flag = input("Enter the flag character (delimiter): ")

esc = input("Enter the escape character: ")

stuffed = character_stuffing(data, flag, esc)

unstuffed = character_unstuffing(stuffed, flag, esc)

print("\nOriginal Data:   ", data)

print("Stuffed Data:    ", stuffed)

print("Unstuffed Data:  ", unstuffed)

#Experiment2b BitStuffing

def bit_stuffing(data):

    stuffed = ''

    count = 0

    for bit in data:

        if bit == '1':

            count += 1

            stuffed += bit

            if count == 5:

                stuffed += '0'  # Stuff 0 after five consecutive 1s

                count = 0

        else:

            stuffed += bit

            count = 0

    return stuffed

def bit_unstuffing(stuffed):

    unstuffed = ''

    count = 0

    i = 0

    while i < len(stuffed):

        if stuffed[i] == '1':

            count += 1

            unstuffed += '1'

            if count == 5:

                i += 1  # Skip stuffed 0

                count = 0

        else:

            unstuffed += '0'

            count = 0

        i += 1

    return unstuffed

# Example usage:

#data = "1111110011111001111"

data=input("Enter binary number to be stuffed: ")

stuffed_bits = bit_stuffing(data)

unstuffed_bits = bit_unstuffing(stuffed_bits)

print("\nOriginal Bits:   ",data)

print("Stuffed Bits:    ", stuffed_bits)

print("Unstuffed Bits:  ", unstuffed_bits)

#Experiment3 Checksum

def calculate_checksum(data_list):

    """

    Calculates 16-bit checksum by summing all 16-bit blocks and returning 1's complement

    """

    checksum = 0

    for data in data_list:

        checksum += int(data, 2)  # binary to int

        # Handle overflow

        if checksum > 0xFFFF:

            checksum = (checksum & 0xFFFF) + 1

    # 1's complement

    checksum = ~checksum & 0xFFFF

    return format(checksum, '016b')  # return 16-bit binary string

def verify_checksum(data_list, received_checksum):

    total_data = data_list + [received_checksum]

    computed = calculate_checksum(total_data)

    return computed == '0000000000000000'

# Example usage

if __name__ == "__main__":

    print("\n--- Checksum Calculation ---")

    n = int(input("Enter number of 16-bit data words: "))

    data_words = []

    for i in range(n):

        word = input(f"Enter data word {i+1} (16-bit binary): ")

        if len(word) != 16 or not set(word).issubset({'0', '1'}):

            print("Invalid input. Must be 16-bit binary.")

            exit(1)

        data_words.append(word)

    checksum = calculate_checksum(data_words)

    print(f"\nCalculated Checksum: {checksum}")

    # Simulate receiver side verification

    print("\n--- Receiver Side Verification ---")

    valid = verify_checksum(data_words, checksum)

    if valid:

        print("No Error Detected (Checksum Verified)")

    else:

        print("Error Detected")

#Experiment4 Hamming Code

def calc_parity_bits(data_bits):

    n = len(data_bits)

    r = 0

    while (2 ** r) < (n + r + 1):

        r += 1

    return r

def insert_parity_bits(data_bits):

    r = calc_parity_bits(data_bits)

    total_length = len(data_bits) + r

    hamming_code = ['0'] * total_length

    j = 0  # index for data bits

    for i in range(1, total_length + 1):

        if (i & (i - 1)) == 0:  # power of 2 positions

            continue

        hamming_code[i - 1] = data_bits[j]

        j += 1

    # Set parity bits

    for i in range(r):

        pos = 2 ** i

        parity = 0

        for j in range(1, total_length + 1):

            if j & pos and j != pos:

                parity ^= int(hamming_code[j - 1])

        hamming_code[pos - 1] = str(parity)

    return ''.join(hamming_code)

def detect_and_correct(hamming_code):

    n = len(hamming_code)

    error_pos = 0

    r = calc_parity_bits(hamming_code)

    for i in range(r):

        pos = 2 ** i

        parity = 0

        for j in range(1, n + 1):

            if j & pos:

                parity ^= int(hamming_code[j - 1])

        if parity != 0:

            error_pos += pos

    if error_pos != 0:

        print(f"Error found at position: {error_pos}")

        hamming_code = list(hamming_code)

        hamming_code[error_pos - 1] = '1' if hamming_code[error_pos - 1] == '0' else '0'

        print("Corrected Hamming Code: ", ''.join(hamming_code))

    else:

        print("No Error Detected in Hamming Code")

    return ''.join(hamming_code)

# Example usage

if __name__ == "__main__":

    print("\n--- Hamming Code Generation and Error Detection ---")

    data = input("Enter binary data bits (e.g., 1011): ")

    if not set(data).issubset({'0', '1'}):

        print("Invalid input. Only binary digits allowed.")

        exit(1)

    encoded = insert_parity_bits(data)

    print("Generated Hamming Code: ", encoded)

    # Simulate error detection and correction

    print("\n--- Error Detection ---")

    received = input(f"Enter received Hamming Code (same length {len(encoded)}): ")

    if len(received) != len(encoded):

        print("Length mismatch!")

    else:

        detect_and_correct(received)

#part2 visualization

def visualize_hamming_code(data_bits, hamming_code):

    r = calc_parity_bits(data_bits)

    total_length = len(hamming_code)

    print("\n--- Hamming Code Visualization ---")

    print(f"Total Bits (Data + Parity): {total_length}")

    print("Position : Bit Type : Value : Covered By Parity")

    for i in range(1, total_length + 1):

        bit = hamming_code[i - 1]

        bit_type = "Parity" if (i & (i - 1)) == 0 else "Data"

        covered_by = []

        # Check which parity bits cover this position

        for j in range(r):

            if i & (2 ** j):

                covered_by.append(f"P{2 ** j}")

        print(f"{i:^8} : {bit_type:^8} : {bit:^5} : {', '.join(covered_by)}")

"""

Experiment5 CRC

#Both Sender and Receiver must agree G(x) i.e., Generator Polynomial;  no of binary bits in = N

# Message/ Frame = M(x)

# append (N-1) 0's to right of M(x) (its binary form)

# perform modulo-2 division; remainder has (N-1) bits;

# to M(x) right of it, append remainder bits

# THIS IS CRC

#-------------------------------------------------------------

#Cyclic Redundancy Check (CRC) is an error-detecting code used in digital networks. CRC appends redundant bits derived from binary division by a generator polynomial.

#CRC-12 polynomial: x¹² + x¹¹ + x³ + x² + x + 1 → binary: 1100000001111

#CRC-16 polynomial: x¹⁶ + x¹⁵ + x² + 1 → binary: 11000000000000101

#CRC-CCITT polynomial: x¹⁶ + x¹² + x⁵ + 1 → binary: 10001000000100001

#---------------------------------------------------------------

For standard use, you would input:

CRC-12: G(x) = 1100000001111

CRC-16-IBM: G(x) = 10000000000000101 ; Applications: Bisynch, XMODEM, disk storage

CRC-CCITT: G(x) = 10001000000100001  ; Applications: X.25, V.42, Bluetooth, HDLC

The code doesn't enforce a specific polynomial, so it can work with any agreed-upon G(x), standard or custom, as long as both sender and receiver use the same G(x). 

"""

# Block 1: Read input binary G(x), predefined M(x); count number of bits in G(x) and store in 'n'

def read_inputs():

    G = input("Enter the CRC-12 generator polynomial G(x) in binary (expected: 1100000001111): ")

    M = "101100"  # Predefined M(x)

    # Validate G(x) is binary and matches CRC-12 standard

    if not all(bit in '01' for bit in G):

        raise ValueError("G(x) must be a binary string (0s and 1s only).")

    if G != "1100000001111":

        raise ValueError("G(x) must be the CRC-12 standard polynomial: 1100000001111")

    # Validate M(x) is binary

    if not all(bit in '01' for bit in M):

        raise ValueError("Predefined M(x) must be a binary string (0s and 1s only).")

    n = len(G)  # Number of bits in G(x)

    return G, M, n

# Block 2: Append n-1 zeroes to the right of M(x)

def append_zeroes(M, n):

    return M + '0' * (n - 1)

# Block 3: Modulo-2 (XOR) division process to obtain remainder

def modulo2_division(dividend, divisor):

    # Convert strings to lists for easier manipulation

    dividend = list(dividend)

    divisor_length = len(divisor)

    # Perform XOR division

    for i in range(len(dividend) - divisor_length + 1):

        if dividend[i] == '1':  # Only divide if the current bit is 1

            for j in range(divisor_length):

                # XOR operation: 0^0=0, 1^1=0, 0^1=1, 1^0=1

                dividend[i + j] = '0' if dividend[i + j] == divisor[j] else '1'

    # Extract remainder (last n-1 bits)

    remainder = ''.join(dividend[-(divisor_length - 1):])

    return remainder

# Block 4: Append remainder to M(x) to form S(x) = CRC

def generate_crc(M, remainder):

    return M + remainder

# Block 5: Ask the user to enter CRC R(x)

def get_received_crc():

    R = input("Enter the received CRC R(x) in binary: ")

    if not all(bit in '01' for bit in R):

        raise ValueError("Received CRC must be a binary string (0s and 1s only).")

    return R

# Block 6: Check for errors in CRC using G(x) and R(x) to obtain remainder

def check_crc(R, G):

    remainder = modulo2_division(R, G)

    if all(bit == '0' for bit in remainder):

        return "No error in CRC."

    else:

        return "Error detected in CRC (non-zero remainder: {}).".format(remainder)

# Main program

try:

    # Block 1

    G, M, n = read_inputs()

    print(f"G(x): {G}, M(x): {M}, n (bits in G(x)): {n}")

    # Block 2

    M_padded = append_zeroes(M, n)

    print(f"M(x) with {n-1} zeroes appended: {M_padded}")

    # Block 3

    remainder = modulo2_division(M_padded, G)

    print(f"Remainder after modulo-2 division: {remainder}")

    # Block 4

    S = generate_crc(M, remainder)

    print(f"S(x) (CRC with remainder appended): {S}")

    # Block 5

    R = get_received_crc()

    print(f"Received CRC R(x): {R}")

    # Block 6

    result = check_crc(R, G)

    print(result)

except ValueError as e:

    print(f"Error: {e}")

# Block 1: Read input binary G(x), predefined M(x); count number of bits in G(x) and store in 'n'

def read_inputs():

    G = input("Enter the CRC-16 generator polynomial G(x) in binary (expected: 10000000000000101): ")

    M = "101100"  # Predefined M(x)

    # Validate G(x) is binary and matches CRC-16-IBM standard

    if not all(bit in '01' for bit in G):

        raise ValueError("G(x) must be a binary string (0s and 1s only).")

    if G != "10000000000000101":

        raise ValueError("G(x) must be the CRC-16-IBM standard polynomial: 10000000000000101")

    # Validate M(x) is binary

    if not all(bit in '01' for bit in M):

        raise ValueError("Predefined M(x) must be a binary string (0s and 1s only).")

    n = len(G)  # Number of bits in G(x)

    return G, M, n

# Block 2: Append n-1 zeroes to the right of M(x)

def append_zeroes(M, n):

    return M + '0' * (n - 1)

# Block 3: Modulo-2 (XOR) division process to obtain remainder

def modulo2_division(dividend, divisor):

    # Convert strings to lists for easier manipulation

    dividend = list(dividend)

    divisor_length = len(divisor)

    # Perform XOR division

    for i in range(len(dividend) - divisor_length + 1):

        if dividend[i] == '1':  # Only divide if the current bit is 1

            for j in range(divisor_length):

                # XOR operation: 0^0=0, 1^1=0, 0^1=1, 1^0=1

                dividend[i + j] = '0' if dividend[i + j] == divisor[j] else '1'

    # Extract remainder (last n-1 bits)

    remainder = ''.join(dividend[-(divisor_length - 1):])

    return remainder

# Block 4: Append remainder to M(x) to form S(x) = CRC

def generate_crc(M, remainder):

    return M + remainder

# Block 5: Ask the user to enter CRC R(x)

def get_received_crc():

    R = input("Enter the received CRC R(x) in binary: ")

    if not all(bit in '01' for bit in R):

        raise ValueError("Received CRC must be a binary string (0s and 1s only).")

    return R

# Block 6: Check for errors in CRC using G(x) and R(x) to obtain remainder

def check_crc(R, G):

    remainder = modulo2_division(R, G)

    if all(bit == '0' for bit in remainder):

        return "No error in CRC."

    else:

        return "Error detected in CRC (non-zero remainder: {}).".format(remainder)

# Main program

try:

    # Block 1

    G, M, n = read_inputs()

    print(f"G(x): {G}, M(x): {M}, n (bits in G(x)): {n}")

    # Block 2

    M_padded = append_zeroes(M, n)

    print(f"M(x) with {n-1} zeroes appended: {M_padded}")

    # Block 3

    remainder = modulo2_division(M_padded, G)

    print(f"Remainder after modulo-2 division: {remainder}")

    # Block 4

    S = generate_crc(M, remainder)

    print(f"S(x) (CRC with remainder appended): {S}")

    # Block 5

    R = get_received_crc()

    print(f"Received CRC R(x): {R}")

    # Block 6

    result = check_crc(R, G)

    print(result)

except ValueError as e:

    print(f"Error: {e}")

# Block 1: Read input binary G(x), predefined M(x); count number of bits in G(x) and store in 'n'

def read_inputs():

    G = input("Enter the CRC-CCITT generator polynomial G(x) in binary (expected: 10001000000100001): ")

    M = "101100"  # Predefined M(x)

    # Validate G(x) is binary and matches CRC-CCITT standard

    if not all(bit in '01' for bit in G):

        raise ValueError("G(x) must be a binary string (0s and 1s only).")

    if G != "10001000000100001":

        raise ValueError("G(x) must be the CRC-CCITT standard polynomial: 10001000000100001")

    # Validate M(x) is binary

    if not all(bit in '01' for bit in M):

        raise ValueError("Predefined M(x) must be a binary string (0s and 1s only).")

    n = len(G)  # Number of bits in G(x)

    return G, M, n

# Block 2: Append n-1 zeroes to the right of M(x)

def append_zeroes(M, n):

    return M + '0' * (n - 1)

# Block 3: Modulo-2 (XOR) division process to obtain remainder

def modulo2_division(dividend, divisor):

    # Convert strings to lists for easier manipulation

    dividend = list(dividend)

    divisor_length = len(divisor)

    # Perform XOR division

    for i in range(len(dividend) - divisor_length + 1):

        if dividend[i] == '1':  # Only divide if the current bit is 1

            for j in range(divisor_length):

                # XOR operation: 0^0=0, 1^1=0, 0^1=1, 1^0=1

                dividend[i + j] = '0' if dividend[i + j] == divisor[j] else '1'

    # Extract remainder (last n-1 bits)

    remainder = ''.join(dividend[-(divisor_length - 1):])

    return remainder

# Block 4: Append remainder to M(x) to form S(x) = CRC

def generate_crc(M, remainder):

    return M + remainder

# Block 5: Ask the user to enter CRC R(x)

def get_received_crc():

    R = input("Enter the received CRC R(x) in binary: ")

    if not all(bit in '01' for bit in R):

        raise ValueError("Received CRC must be a binary string (0s and 1s only).")

    return R

# Block 6: Check for errors in CRC using G(x) and R(x) to obtain remainder

def check_crc(R, G):

    remainder = modulo2_division(R, G)

    if all(bit == '0' for bit in remainder):

        return "No error in CRC."

    else:

        return "Error detected in CRC (non-zero remainder: {}).".format(remainder)

# Main program

try:

    # Block 1

    G, M, n = read_inputs()

    print(f"G(x): {G}, M(x): {M}, n (bits in G(x)): {n}")

    # Block 2

    M_padded = append_zeroes(M, n)

    print(f"M(x) with {n-1} zeroes appended: {M_padded}")

    # Block 3

    remainder = modulo2_division(M_padded, G)

    print(f"Remainder after modulo-2 division: {remainder}")

    # Block 4

    S = generate_crc(M, remainder)

    print(f"S(x) (CRC with remainder appended): {S}")

    # Block 5

    R = get_received_crc()

    print(f"Received CRC R(x): {R}")

    # Block 6

    result = check_crc(R, G)

    print(result)

except ValueError as e:

    print(f"Error: {e}")

import random

import time

# Block 1: Read input for number of frames and window size

def read_inputs():

    try:

        total_frames = int(input("Enter the total number of frames to send: "))

        window_size = int(input("Enter the window size for Go-Back-N: "))

        if total_frames <= 0 or window_size <= 0:

            raise ValueError("Total frames and window size must be positive integers.")

        if window_size > total_frames:

            raise ValueError("Window size cannot be larger than total frames.")

        return total_frames, window_size

    except ValueError as e:

        raise ValueError(f"Invalid input: {e}")

# Block 2: Initialize sender state (window, frame sequence, etc.)

def initialize_sender(total_frames, window_size):

    sender_window = []  # Current window of frames

    next_frame_to_send = 0  # Next frame to send

    base = 0  # Base of the window (oldest unacknowledged frame)

    return sender_window, next_frame_to_send, base

# Block 3: Simulate sender sending frames within the window

def send_frames(sender_window, next_frame_to_send, base, window_size, total_frames, sent_frames):

    frames_sent = []

    while next_frame_to_send < total_frames and len(sender_window) < window_size:

        print(f"Sender: Sending frame {next_frame_to_send}")

        sender_window.append(next_frame_to_send)

        frames_sent.append(next_frame_to_send)

        sent_frames.add(next_frame_to_send)

        next_frame_to_send += 1

    return sender_window, next_frame_to_send, frames_sent

# Block 4: Simulate receiver processing frames and sending ACKs

def receive_frames(frames_sent, error_rate=0.2):

    received_frames = []

    for frame in frames_sent:

        # Simulate random frame loss

        if random.random() > error_rate:  # Frame received successfully

            print(f"Receiver: Received frame {frame}")

            received_frames.append(frame)

        else:

            print(f"Receiver: Frame {frame} lost in transmission")

    # Send ACK for the last successfully received frame + 1 (cumulative ACK)

    if received_frames:

        ack = max(received_frames) + 1

        print(f"Receiver: Sending ACK for frame {ack}")

        return ack

    return None  # No frames received successfully

# Block 5: Simulate timeout and retransmission for unacknowledged frames

def handle_timeout(sender_window, base, next_frame_to_send, sent_frames):

    if sender_window:

        print(f"Sender: Timeout! Retransmitting from frame {base}")

        # Clear window and retransmit from base

        sender_window.clear()

        next_frame_to_send = base

    return sender_window, next_frame_to_send

# Block 6: Main Go-Back-N protocol simulation

def gobackn_protocol(total_frames, window_size):

    sender_window, next_frame_to_send, base = initialize_sender(total_frames, window_size)

    sent_frames = set()  # Track sent frames to avoid duplicates in output

    timeout_duration = 2  # Simulated timeout duration in seconds

    error_rate = 0.2  # Probability of frame loss

    while base < total_frames:

        # Send frames in the window

        sender_window, next_frame_to_send, frames_sent = send_frames(

            sender_window, next_frame_to_send, base, window_size, total_frames, sent_frames

        )

        # Simulate channel delay

        print("Sender: Waiting for ACK...")

        time.sleep(1)

        # Receive frames and get ACK

        ack = receive_frames(frames_sent, error_rate)

        # Process ACK or handle timeout

        if ack is not None and ack > base:

            print(f"Sender: Received ACK for frame {ack}")

            # Move window forward

            sender_window = [f for f in sender_window if f >= ack]

            base = ack

        else:

            print("Sender: No valid ACK received or frame lost.")

            sender_window, next_frame_to_send = handle_timeout(sender_window, base, next_frame_to_send, sent_frames)

        # Simulate timeout check

        time.sleep(timeout_duration)

    print("Sender: All frames sent and acknowledged successfully!")

# Main program

try:

    # Block 1

    total_frames, window_size = read_inputs()

    print(f"Total frames: {total_frames}, Window size: {window_size}")

    # Block 6

    gobackn_protocol(total_frames, window_size)

except ValueError as e:

    print(f"Error: {e}")

import random

import time

# Block 1: Read input for number of frames and window size

def read_inputs():

    try:

        total_frames = int(input("Enter the total number of frames to send: "))

        window_size = int(input("Enter the window size for Selective Repeat: "))

        if total_frames <= 0 or window_size <= 0:

            raise ValueError("Total frames and window size must be positive integers.")

        if window_size > total_frames:

            raise ValueError("Window size cannot be larger than total frames.")

        return total_frames, window_size

    except ValueError as e:

        raise ValueError(f"Invalid input: {e}")

# Block 2: Initialize sender and receiver state (window, frame sequence, buffers)

def initialize_protocol(total_frames, window_size):

    sender_window = {}  # Dictionary to track frames in window: {frame_number: (sent_time, acknowledged)}

    receiver_buffer = {}  # Dictionary to buffer out-of-order frames: {frame_number: received}

    next_frame_to_send = 0  # Next frame to send

    base = 0  # Base of the sender window (oldest unacknowledged frame)

    expected_frame = 0  # Receiver's next expected frame for in-order delivery

    return sender_window, receiver_buffer, next_frame_to_send, base, expected_frame

# Block 3: Simulate sender sending frames within the window

def send_frames(sender_window, next_frame_to_send, base, window_size, total_frames, sent_frames):

    frames_sent = []

    current_time = time.time()

    while next_frame_to_send < total_frames and len(sender_window) < window_size:

        if next_frame_to_send not in sender_window:

            print(f"Sender: Sending frame {next_frame_to_send}")

            sender_window[next_frame_to_send] = (current_time, False)  # (sent_time, acknowledged)

            frames_sent.append(next_frame_to_send)

            sent_frames.add(next_frame_to_send)

            next_frame_to_send += 1

    return sender_window, next_frame_to_send, frames_sent

# Block 4: Simulate receiver processing frames, buffering, and sending selective ACKs

def receive_frames(frames_sent, receiver_buffer, expected_frame, error_rate=0.2):

    acks = []

    for frame in frames_sent:

        # Simulate random frame loss

        if random.random() > error_rate:  # Frame received successfully

            print(f"Receiver: Received frame {frame}")

            receiver_buffer[frame] = True

            acks.append(frame)  # Send ACK for this frame

            print(f"Receiver: Sending ACK for frame {frame}")

        else:

            print(f"Receiver: Frame {frame} lost in transmission")

    # Deliver in-order frames from buffer

    delivered = []

    while expected_frame in receiver_buffer:

        print(f"Receiver: Delivering frame {expected_frame} in order")

        delivered.append(expected_frame)

        del receiver_buffer[expected_frame]

        expected_frame += 1

    return acks, receiver_buffer, expected_frame

# Block 5: Process ACKs and handle timeouts for selective retransmission

def process_acks_and_timeouts(sender_window, acks, base, timeout_duration=2):

    current_time = time.time()

    frames_to_retransmit = []

    # Mark received ACKs

    for ack in acks:

        if ack in sender_window:

            sender_window[ack] = (sender_window[ack][0], True)  # Mark as acknowledged

            print(f"Sender: Received ACK for frame {ack}")

    # Advance base to the next unacknowledged frame

    while base in sender_window and sender_window[base][1]:

        del sender_window[base]

        base += 1

    # Check for timeouts and queue retransmissions

    for frame in list(sender_window.keys()):

        sent_time, acknowledged = sender_window[frame]

        if not acknowledged and (current_time - sent_time) > timeout_duration:

            print(f"Sender: Timeout for frame {frame}. Queuing for retransmission")

            frames_to_retransmit.append(frame)

            sender_window[frame] = (current_time, False)  # Update sent time

    return sender_window, base, frames_to_retransmit

# Block 6: Main Selective Repeat protocol simulation

def selective_repeat_protocol(total_frames, window_size):

    sender_window, receiver_buffer, next_frame_to_send, base, expected_frame = initialize_protocol(total_frames, window_size)

    sent_frames = set()  # Track sent frames to avoid duplicates in output

    timeout_duration = 2  # Simulated timeout duration in seconds

    error_rate = 0.2  # Probability of frame loss

    while base < total_frames:

        # Send frames in the window

        sender_window, next_frame_to_send, frames_sent = send_frames(

            sender_window, next_frame_to_send, base, window_size, total_frames, sent_frames

        )

        # Simulate channel delay

        print("Sender: Waiting for ACKs...")

        time.sleep(1)

        # Receive frames and get selective ACKs

        acks, receiver_buffer, expected_frame = receive_frames(

            frames_sent, receiver_buffer, expected_frame, error_rate

        )

        # Process ACKs and check for timeouts

        sender_window, base, frames_to_retransmit = process_acks_and_timeouts(

            sender_window, acks, base, timeout_duration

        )

        # Retransmit specific frames that timed out

        for frame in frames_to_retransmit:

            print(f"Sender: Retransmitting frame {frame}")

            sender_window[frame] = (time.time(), False)  # Update sent time

            sent_frames.add(frame)

            frames_sent = [frame]  # Send retransmitted frame

            acks, receiver_buffer, expected_frame = receive_frames(

                frames_sent, receiver_buffer, expected_frame, error_rate

            )

            sender_window, base, _ = process_acks_and_timeouts(

                sender_window, acks, base, timeout_duration

            )

        # Simulate timeout check

        time.sleep(timeout_duration)

    print("Sender: All frames sent and acknowledged successfully!")

# Main program

try:

    # Block 1

    total_frames, window_size = read_inputs()

    print(f"Total frames: {total_frames}, Window size: {window_size}")

    # Block 6

    selective_repeat_protocol(total_frames, window_size)

except ValueError as e:

    print(f"Error: {e}")

import random

import time

# Block 1: Read input for number of frames

def read_inputs():

    try:

        total_frames = int(input("Enter the total number of frames to send: "))

        if total_frames <= 0:

            raise ValueError("Total frames must be a positive integer.")

        return total_frames

    except ValueError as e:

        raise ValueError(f"Invalid input: {e}")

# Block 2: Initialize sender and receiver state

def initialize_protocol():

    current_frame = 0  # Current frame to send

    seq_num = 0  # Sequence number (0 or 1 for alternating bit)

    expected_seq_num = 0  # Receiver's expected sequence number

    return current_frame, seq_num, expected_seq_num

# Block 3: Simulate sender sending a frame

def send_frame(current_frame, seq_num, sent_frames):

    print(f"Sender: Sending frame {current_frame} with sequence number {seq_num}")

    sent_frames.add(current_frame)

    return (current_frame, seq_num)

# Block 4: Simulate receiver processing frame and sending ACK

def receive_frame(frame_data, expected_seq_num, error_rate=0.2):

    frame_num, seq_num = frame_data

    # Simulate random frame loss

    if random.random() > error_rate:  # Frame received successfully

        print(f"Receiver: Received frame {frame_num} with sequence number {seq_num}")

        if seq_num == expected_seq_num:

            print(f"Receiver: Frame {frame_num} is in order, delivering")

            # Send ACK with next expected sequence number

            ack_seq_num = 1 - seq_num  # Toggle sequence number (0 -> 1, 1 -> 0)

            print(f"Receiver: Sending ACK for sequence number {ack_seq_num}")

            return ack_seq_num

        else:

            print(f"Receiver: Frame {frame_num} has incorrect sequence number, discarding")

            return None  # Discard out-of-order frame

    else:

        print(f"Receiver: Frame {frame_num} lost in transmission")

        return None

# Block 5: Simulate ACK processing and timeout handling

def process_ack_and_timeout(sent_frame, received_ack, expected_ack, timeout_duration=2):

    current_time = time.time()

    sent_frame_num, sent_seq_num = sent_frame

    # Simulate ACK loss

    if received_ack is not None and random.random() > 0.2:  # ACK received successfully

        print(f"Sender: Received ACK for sequence number {received_ack}")

        if received_ack == expected_ack:

            print(f"Sender: Frame {sent_frame_num} acknowledged successfully")

            return True, current_time  # ACK matches, move to next frame

        else:

            print(f"Sender: Incorrect ACK sequence number, waiting...")

            return False, current_time

    else:

        print(f"Sender: ACK for frame {sent_frame_num} lost or not received")

        return False, current_time

# Block 6: Main Stop-and-Wait protocol simulation

def stop_and_wait_protocol(total_frames):

    current_frame, seq_num, expected_seq_num = initialize_protocol()

    sent_frames = set()  # Track sent frames to avoid duplicates in output

    timeout_duration = 2  # Simulated timeout duration in seconds

    error_rate = 0.2  # Probability of frame/ACK loss

    last_sent_time = time.time()

    while current_frame < total_frames:

        # Send frame

        sent_frame = send_frame(current_frame, seq_num, sent_frames)

        # Simulate channel delay

        print("Sender: Waiting for ACK...")

        time.sleep(1)

        # Receive frame and get ACK

        ack = receive_frame(sent_frame, expected_seq_num, error_rate)

        # Process ACK or timeout

        acknowledged, last_sent_time = process_ack_and_timeout(sent_frame, ack, 1 - seq_num, timeout_duration)

        if acknowledged:

            # Move to next frame

            current_frame += 1

            seq_num = 1 - seq_num  # Toggle sequence number

            expected_seq_num = seq_num

        elif (time.time() - last_sent_time) > timeout_duration:

            print(f"Sender: Timeout for frame {current_frame}, retransmitting")

            last_sent_time = time.time()  # Reset timer for retransmission

            # Frame is resent in the next iteration

    print("Sender: All frames sent and acknowledged successfully!")

# Main program

try:

    # Block 1

    total_frames = read_inputs()

    print(f"Total frames: {total_frames}")

    # Block 6

    stop_and_wait_protocol(total_frames)

except ValueError as e:

    print(f"Error: {e}")

import time

# Block 1: Read input for bucket size, output rate, and packet arrivals

def read_inputs():

    try:

        bucket_size = int(input("Enter the bucket size (number of packets): "))

        output_rate = int(input("Enter the output rate (packets per second): "))

        num_arrivals = int(input("Enter the number of packet arrival events: "))

        if bucket_size <= 0 or output_rate <= 0 or num_arrivals <= 0:

            raise ValueError("Bucket size, output rate, and number of arrivals must be positive integers.")

        # Read packet arrivals as (time, packet_count) pairs

        packet_arrivals = []

        print("Enter each packet arrival as 'time packet_count' (e.g., '1 5' for 5 packets at time 1):")

        for _ in range(num_arrivals):

            time_val, count = map(int, input().split())

            if time_val < 0 or count < 0:

                raise ValueError("Time and packet count must be non-negative.")

            packet_arrivals.append((time_val, count))

        return bucket_size, output_rate, packet_arrivals

    except ValueError as e:

        raise ValueError(f"Invalid input: {e}")

# Block 2: Initialize leaky bucket state

def initialize_bucket(bucket_size):

    current_bucket = 0  # Current number of packets in the bucket

    last_leak_time = 0  # Time of the last leak event

    return current_bucket, last_leak_time

# Block 3: Process incoming packets and update bucket

def process_packets(current_bucket, bucket_size, arrival_time, packet_count):

    print(f"Time {arrival_time}: Received {packet_count} packets")

    # Check if bucket can accommodate incoming packets

    if current_bucket + packet_count <= bucket_size:

        current_bucket += packet_count

        print(f"Time {arrival_time}: Accepted {packet_count} packets. Bucket now has {current_bucket} packets")

    else:

        accepted = max(0, bucket_size - current_bucket)

        dropped = packet_count - accepted

        current_bucket += accepted

        print(f"Time {arrival_time}: Accepted {accepted} packets, dropped {dropped} packets due to bucket overflow. Bucket now has {current_bucket} packets")

    return current_bucket

# Block 4: Simulate leaking packets at the output rate

def leak_packets(current_bucket, output_rate, current_time, last_leak_time):

    # Calculate time elapsed since last leak

    time_elapsed = current_time - last_leak_time

    packets_leaked = int(time_elapsed * output_rate)

    if packets_leaked > 0:

        packets_leaked = min(packets_leaked, current_bucket)  # Can't leak more than what's in the bucket

        current_bucket -= packets_leaked

        print(f"Time {current_time}: Leaked {packets_leaked} packets. Bucket now has {current_bucket} packets")

    return current_bucket, current_time

# Block 5: Main leaky bucket algorithm simulation

def leaky_bucket_algorithm(bucket_size, output_rate, packet_arrivals):

    current_bucket, last_leak_time = initialize_bucket(bucket_size)

    # Sort arrivals by time

    packet_arrivals.sort(key=lambda x: x[0])

    max_time = max(arrival[0] for arrival in packet_arrivals) + 1  # Run until last arrival + 1 second

    for current_time in range(max_time + 1):