Application:  [HTTP header | data]
Transport:    [TCP header | HTTP header | data]
Network:      [IP header  | TCP header | HTTP header | data]
Link:         [Eth header | IP header  | TCP header | HTTP header | data | Eth trailer]

Total delay = Transmission + Propagation + Processing + Queueing

Traffic intensity = La/R
  L = packet size (bits)
  a = arrival rate (packets/sec)
  R = link transmission rate (bps)

Throughput = data size / transfer time   [bits/sec]

0000 → 11110
0001 → 01001
...
1111 → 11101

4 symbols (A, B, C, D) = 2 bits/symbol
600 baud × 4 symbols → 1200 bps

Source bits
    → Source encoding  (compress: MP3, MPEG4, Huffman)
    → Channel encoding (add redundancy for error correction)
    → Physical transmission (turn symbols into voltage/light/radio)

Transmission delay = packet_size_bits / bandwidth_bps

Propagation delay = distance_m / signal_speed_mps
                  (signal speed ≈ 2×10⁸ m/s in fiber)

1 kbps  = 10³ bps
1 Mbps  = 10⁶ bps
1 Gbps  = 10⁹ bps
1 Tbps  = 10¹² bps
1 Byte  = 8 bits

  1111        11001
+ 1010      ×   101
------       ------
  0101       11001
           +11001
           -------
           1111101

T_frame ≥ 2·d   →   min_frame_size = rate × 2d

(64 bytes × 8 bits) × 2.5×10⁸ m/s / (2 × 10⁷ bps) = 6400 m max cable

| Preamble (7B) | SF (1B) | Dst MAC (6B) | Src MAC (6B) | Length (2B) | Data (0–1500B) | Pad (0–46B) | CRC (4B) |

import struct

# --- PACK (Python → bytes) ---
packed = struct.pack('i 2s f', 42, b'ab', 3.14)

# --- UNPACK (bytes → Python) ---
unpacked = struct.unpack('i 2s f', packed)   # returns tuple

# --- Reusable packer (preferred) ---
packer = struct.Struct('i 2s f')
packed  = packer.pack(42, b'ab', 3.14)
result  = packer.unpack(packed)

# Size
print(packer.size)             # total bytes
print(struct.calcsize('i2sf')) # same, ad-hoc

import struct

packer = struct.Struct('i 3s i')   # e.g. year, month, day

with open('dates.bin', 'wb') as f:
    for i in range(5):
        values = (2020 + i, b'Sep', 15 + i)
        f.write(packer.pack(*values))

with open('dates.bin', 'rb') as f:
    # Read all records sequentially
    for i in range(5):
        data = f.read(packer.size)
        print(packer.unpack(data))

    # Jump to a specific record with seek
    f.seek(packer.size * 4)          # 5th record (0-indexed)
    data = f.read(packer.size)
    print(packer.unpack(data))       # last entry

s = "hello"
b = s.encode()              # b'hello'
s2 = b.decode()             # 'hello'

# Fixed-width string (padded with \x00)
packed = struct.pack('8s', s.encode())    # b'hello\x00\x00\x00'
unpacked = packed.decode().strip('\x00') # 'hello'

import socket

# Convert host byte order → network (big-endian)
socket.htons(x)   # host→network short (16-bit)
socket.htonl(x)   # host→network long  (32-bit)

# Convert network → host byte order
socket.ntohs(x)
socket.ntohl(x)

import struct, sys

params = [
    struct.Struct('c9si'),   # file 1 format
    struct.Struct('if?'),    # file 2 format
    struct.Struct('?9sc'),   # file 3 format
    struct.Struct('icf')     # file 4 format
]

for idx, param in enumerate(params):
    with open(sys.argv[idx + 1], 'rb') as f:
        data = f.read(param.size)
        print(param.unpack(data))

# Pack new values
s1 = struct.Struct('11si?')
print(s1.pack(b'elso', 89, True))

import socket

server_addr = ('', 10000)    # '' = bind to all interfaces

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind(server_addr)
    server.listen(1)           # backlog: max queued connections

    conn, client_addr = server.accept()   # blocks until client connects
    with conn:
        data = conn.recv(1024)             # receive bytes
        print("Got:", data.decode())
        conn.sendall("Hello client!".encode())

import socket

server_addr = ('localhost', 10000)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:
    client.connect(server_addr)
    client.sendall("Hello server!".encode())
    data = client.recv(1024)
    print("Got:", data.decode())

# Server side
import struct

unpacker = struct.Struct('I I 1s')   # uint, uint, char

data = conn.recv(unpacker.size)
num1, num2, op = unpacker.unpack(data)
op_str = op.decode()
result = eval(f"{num1} {op_str} {num2}")   # use eval() for operator dispatch
conn.sendall(str(result).encode())

# Client side
packer = struct.Struct('I I 1s')

values = (10, 3, b'+')
client.sendall(packer.pack(*values))
answer = client.recv(64).decode()

sock.settimeout(1.0)    # raises socket.timeout after 1 s
sock.setblocking(False) # non-blocking (settimeout(0))
sock.setblocking(True)  # blocking (settimeout(None))

try:
    conn, addr = server.accept()
except socket.timeout:
    pass   # no client connected within timeout

import sys
port = int(sys.argv[1])
server_addr = ('localhost', port)

from socket import socket, AF_INET, SOCK_DGRAM

server_address = ('', 10000)

with socket(AF_INET, SOCK_DGRAM) as server:
    server.bind(server_address)

    data, client_addr = server.recvfrom(4096)   # receive + get sender address
    print("Got:", data.decode(), "from:", client_addr)

    server.sendto("Hello client!".encode(), client_addr)  # send reply to sender

from socket import socket, AF_INET, SOCK_DGRAM

server_addr = ('localhost', 10000)

with socket(AF_INET, SOCK_DGRAM) as client:
    client.sendto("Hello Server!".encode(), server_addr)

    data, _ = client.recvfrom(4096)
    print("Got:", data.decode())

with socket(AF_INET, SOCK_DGRAM) as server:
    server.bind(('', 10000))
    while True:
        data, addr = server.recvfrom(4096)
        # handle data...
        server.sendto(response, addr)

# Client: send file in 200-byte chunks
CHUNK = 200
with open('photo.jpg', 'rb') as f:
    while True:
        chunk = f.read(CHUNK)
        client.sendto(chunk if chunk else b'', server_addr)
        ack, _ = client.recvfrom(16)   # wait for 'ok'
        if not chunk:
            break

# Server: receive chunks
with socket(AF_INET, SOCK_DGRAM) as server:
    server.bind(('', 10000))
    with open('received.jpg', 'wb') as out:
        while True:
            data, addr = server.recvfrom(256)
            server.sendto(b'ok', addr)
            if not data:
                break
            out.write(data)

# Server
import struct
packer = struct.Struct('I I 1s')

with socket(AF_INET, SOCK_DGRAM) as server:
    server.bind(('', 10000))
    while True:
        data, addr = server.recvfrom(packer.size)
        n1, n2, op = packer.unpack(data)
        result = eval(f"{n1} {op.decode()} {n2}")
        server.sendto(str(result).encode(), addr)

import socket, struct

MULTICAST_GROUP = '224.3.29.71'
PORT = 10000

# --- Sender ---
ttl = struct.pack('b', 1)
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sender:
    sender.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl)
    sender.sendto(b'Hello multicast!', (MULTICAST_GROUP, PORT))

# --- Receiver ---
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as recv:
    recv.bind(('', PORT))
    group = socket.inet_aton(MULTICAST_GROUP)
    mreq = struct.pack('4sL', group, socket.INADDR_ANY)
    recv.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
    data, addr = recv.recvfrom(1024)

from select import select

readable, writable, exceptional = select(inputs, outputs, inputs, timeout)

from socket import socket, AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
from select import select

server_addr = ('', 10000)

with socket(AF_INET, SOCK_STREAM) as server:
    server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    server.bind(server_addr)
    server.listen(5)

    inputs = [server]   # start with just the server socket

    while True:
        r, w, e = select(inputs, [], inputs, timeout=1)

        if not (r or w or e):
            continue   # timeout, nothing happened

        for s in r:
            if s is server:
                # New connection
                client, addr = s.accept()
                inputs.append(client)
                print("Connected:", addr)
            else:
                # Existing client sent data
                data = s.recv(1024)
                if not data:
                    # Client disconnected
                    print("Disconnected:", s.getpeername())
                    inputs.remove(s)
                    s.close()
                else:
                    print("Received:", data.decode())
                    s.sendall("OK".encode())

        for s in e:
            inputs.remove(s)
            s.close()

from socket import socket, AF_INET, SOCK_STREAM
from time import sleep

server_addr = ('localhost', 10000)

with socket(AF_INET, SOCK_STREAM) as client:
    client.connect(server_addr)

    for _ in range(5):
        client.sendall("Hello Server!".encode())
        data = client.recv(200)
        print("Received:", data.decode())
        sleep(2)

for s in r:
    if s is server:
        client, addr = s.accept()
        inputs.append(client)
        name = client.recv(64).decode()
        client_names[client] = name
    else:
        data = s.recv(1024)
        if not data:
            inputs.remove(s)
            s.close()
        else:
            name = client_names.get(s, '?')
            msg = f"[{name}] {data.decode()}".encode()
            for other in inputs:
                if other is not server and other is not s:
                    other.sendall(msg)

import struct, random
from select import select
from socket import *

MSG = struct.Struct('c i')   # 1 char + 4 byte int

server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('', int(sys.argv[2])))
server.listen(5)

inputs  = [server]
target  = random.randint(1, 100)

while True:
    r, _, e = select(inputs, [], inputs, 1)
    for s in r:
        if s is server:
            client, _ = s.accept(); inputs.append(client)
        else:
            raw = s.recv(MSG.size)
            if not raw:
                inputs.remove(s); s.close(); continue
            op, num = MSG.unpack(raw)
            op = op.decode()
            if op == '<':
                reply = b'I' if target < num else b'N'
            elif op == '>':
                reply = b'I' if target > num else b'N'
            elif op == '=':
                if num == target:
                    s.sendall(MSG.pack(b'Y', 0))
                    for other in inputs:
                        if other is not server and other is not s:
                            other.sendall(MSG.pack(b'V', 0))
                    inputs = [server]
                    target = random.randint(1, 100)
                    continue
                else:
                    reply = b'K'
            s.sendall(MSG.pack(reply, 0))

Number of subnets  = 2^(subnet bits)
                   = 2^(CIDR_prefix - class_default_prefix)

Number of hosts    = 2^(host bits) - 2
                   = 2^(32 - CIDR_prefix) - 2

import socket

socket.gethostname()                         # local hostname
socket.gethostbyname('www.example.com')      # → '93.184.216.34'
socket.gethostbyname_ex('www.example.com')   # → (hostname, aliases, [ips])
socket.gethostbyaddr('157.181.161.79')       # reverse lookup

# List services on ports 1-100
for port in range(1, 101):
    for proto in ('tcp', 'udp'):
        try:
            print(f"{port}/{proto} → {socket.getservbyport(port, proto)}")
        except OSError:
            pass

# TCP
socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# UDP
socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# Client packs: "5:10:15:20:25:50"
nums = [5, 10, 15, 20, 25]
bet = 50
msg = ':'.join(map(str, nums)) + ':' + str(bet)
sock.sendall(msg.encode())

# Server unpacks
raw = conn.recv(1024).decode()
parts = raw.split(':')
nums = list(map(int, parts[:5]))
bet  = int(parts[5])

import struct

# Example: 5 shorts + 1 int (numbers + bet)
packer = struct.Struct('5H I')   # 5 unsigned short + 1 unsigned int
packed = packer.pack(5, 10, 15, 20, 25, 50)
conn.sendall(packed)

# Server
data = conn.recv(packer.size)
nums_and_bet = packer.unpack(data)
nums = list(nums_and_bet[:5])
bet  = nums_and_bet[5]

import hashlib, zlib

# MD5 checksum
payload = b"5:10:15:20:25:50"
checksum = hashlib.md5(payload).digest()    # 16 bytes
conn.sendall(payload + checksum)

# Verify on server
raw = conn.recv(1024)
data, chk_recv = raw[:-16], raw[-16:]
assert hashlib.md5(data).digest() == chk_recv, "Checksum mismatch!"

# CRC32 (4 bytes)
crc = struct.pack('I', zlib.crc32(payload) & 0xFFFFFFFF)
conn.sendall(payload + crc)

from select import select

inputs = [server]
while True:
    r, _, e = select(inputs, [], inputs, 1)
    for s in r:
        if s is server:
            client, _ = s.accept()
            inputs.append(client)
        else:
            data = s.recv(1024)
            if not data:
                inputs.remove(s); s.close()
            else:
                # handle client
                s.sendall(response)

import random
nums = random.sample(range(1, 21), 5)   # 5 unique from 1..20
bet  = random.randint(1, 100)

raw = input("Enter 5 numbers (space-separated): ")
nums = list(map(int, raw.split()))
bet  = int(input("Enter bet: "))

import json, sys
with open(sys.argv[1]) as f:
    data = json.load(f)
nums = data['numbers']
bet  = data['bet']

import sys
nums = list(map(int, sys.argv[1:6]))
bet  = int(sys.argv[6])

Client → History Server → Lottery Server
Client ← History Server ← Lottery Server
         (history logs here)

# History server receives from client
data, addr = history_sock.recvfrom(1024)  # UDP example

# Forward to lottery server
lottery_addr = ('localhost', 20000)
history_sock.sendto(data, lottery_addr)

# Wait for lottery reply
result, _ = history_sock.recvfrom(1024)

# Log it
log_to_json(data, result)

# Forward back to client
history_sock.sendto(result, addr)

Client → Lottery Server
Lottery Server → History Server (async notification)
Client ← Lottery Server

Client → Lottery Server → Client
Client → History Server (after getting result)

# Client logs via UDP to history
hist_addr = ('localhost', 30000)
hist_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
log = json.dumps({'picks': nums, 'drawn': drawn, 'win': winnings}).encode()
hist_sock.sendto(log, hist_addr)

import json, os

LOG_FILE = 'history.json'

def log_to_json(entry: dict):
    records = []
    if os.path.exists(LOG_FILE):
        with open(LOG_FILE) as f:
            records = json.load(f)
    records.append(entry)
    with open(LOG_FILE, 'w') as f:
        json.dump(records, f, indent=2)

import socket, random, struct
from select import select

NUMBERS_COUNT = 5
MAX_NUMBER    = 20

packer = struct.Struct('5H I')   # 5 picks + bet

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(('', 10000))
server.listen(5)

inputs = [server]

drawn = random.sample(range(1, MAX_NUMBER + 1), NUMBERS_COUNT)
print("Drawn:", drawn)

while True:
    r, _, _ = select(inputs, [], inputs, 1)
    for s in r:
        if s is server:
            client, _ = s.accept(); inputs.append(client)
        else:
            raw = s.recv(packer.size)
            if not raw:
                inputs.remove(s); s.close(); continue

            *picks, bet = packer.unpack(raw)
            hits = len(set(picks) & set(drawn))
            win  = bet * hits

            # Reply: drawn numbers + winnings
            resp_fmt = struct.Struct('5H I I')   # drawn + hits + win
            s.sendall(resp_fmt.pack(*drawn, hits, win))

python3 client.py cs1.json

1. demand allocation: A<->C st:1 - successful
2. demand allocation: B<->C st:2 - successful
3. demand deallocation: A<->C st:5
4. demand allocation: D<->C st:6 - successful
5. demand allocation: A<->C st:7 - unsuccessful

{
  "links": [
    { "points": ["A", "B"], "capacity": 10.0 }
  ],
  "possible-circuits": [
    ["A", "B", "C"],
    ["A", "C"]
  ],
  "simulation": {
    "duration": 20,
    "demands": [
      { "end-points": ["A", "C"], "demand": 3.0, "start-time": 1, "end-time": 5 }
    ]
  }
}

import json, sys

def get_link_key(a, b):
    return tuple(sorted([a, b]))

def simulate(filename):
    with open(filename) as f:
        data = json.load(f)

    # Build capacity map
    cap = {}
    for link in data['links']:
        key = get_link_key(link['points'][0], link['points'][1])
        cap[key] = link['capacity']

    # Create and sort events
    events = []
    for d in data['simulation']['demands']:
        events.append((d['start-time'], 1, 'alloc',   d))
        events.append((d['end-time'],   0, 'dealloc', d))
    events.sort(key=lambda e: (e[0], e[1]))

    allocated = {}   # demand id → circuit used
    n = 1

    for time, _, etype, demand in events:
        n1, n2 = demand['end-points']

        if etype == 'alloc':
            chosen = None
            for circuit in data['possible-circuits']:
                # Check endpoints match
                if not ((circuit[0] == n1 and circuit[-1] == n2) or
                        (circuit[0] == n2 and circuit[-1] == n1)):
                    continue
                # Check capacity on every link
                if all(cap.get(get_link_key(circuit[i], circuit[i+1]), 0) >= demand['demand']
                       for i in range(len(circuit) - 1)):
                    chosen = circuit
                    break

            if chosen:
                for i in range(len(chosen) - 1):
                    cap[get_link_key(chosen[i], chosen[i+1])] -= demand['demand']
                allocated[id(demand)] = chosen
                status = "successful"
            else:
                status = "unsuccessful"

            print(f"{n}. demand allocation: {n1}<->{n2} st:{time} - {status}")

        else:  # dealloc
            did = id(demand)
            if did in allocated:
                circuit = allocated.pop(did)
                for i in range(len(circuit) - 1):
                    cap[get_link_key(circuit[i], circuit[i+1])] += demand['demand']
                print(f"{n}. demand deallocation: {n1}<->{n2} st:{time}")
            else:
                continue

        n += 1

if __name__ == '__main__':
    simulate(sys.argv[1])

import struct, sys

# Part 1: read binary files
# Replace these formats with your actual ones from TMS
params = [
    struct.Struct('c9si'),    # file 1
    struct.Struct('if?'),     # file 2
    struct.Struct('?9sc'),    # file 3
    struct.Struct('icf')      # file 4
]

for idx, param in enumerate(params):
    with open(sys.argv[idx + 1], 'rb') as f:
        data = f.read(param.size)
        print(param.unpack(data))

# Part 2: pack values
# Replace formats and values with your actual ones from TMS
s1 = struct.Struct('11si?')
print(s1.pack(b'elso', 89, True))

s2 = struct.Struct('f?c')
print(s2.pack(92.5, False, b'X'))

s3 = struct.Struct('i9sf')
print(s3.pack(80, b'masodik', 99.9))

s4 = struct.Struct('ci12s')
print(s4.pack(b'Z', 111, b'harmadik'))

python3 client.py database1.bin database2.bin database3.bin database4.bin