Short Answer Problems

• (6.20) The Nyquist Theorem tells us it is 40kHz.
• (7.2) Electrical (for wire), radio (for wireless), light (for fiber).
• (7.8) The cladding ensures light is reflected.
• (7.23) Use Shannon’s Theorem to get the effective limit: $C = B\log_2{(1 + S/N)} = 10^8\log_2{(1+3)} = 2 \times 10^8 = 200 \,\textrm{Mbps}$.
• (13.8) Bus, star, ring, mesh.
• (13.11) AND with 0x100000 and if the result is 0, it is unicast.
• (18.12) In distance-vector routing (DVR) each node shares its routing table with its neighbors; in link-state routing (LSR), the only information passed between nodes is connectivity information.
• (21.4) See dotted_decimal_quad_to_binary in module below
• (21.5) See is_dotted_quad_multicast in module below
• (21.6) This was a weird problem; I wasn’t totally sure what they were asking. So I guessed. See cidr_to_dotted_quad and dotted_quad_to_cidr in module below
• (21.7) 14
• (21.8) /16
• (21.9) No, prefix for /29 must end in three zero bits, but 1.2.3.4 ends in 100.
• (21.10) No, you only get 254 computers in a /24.
• (21.11) Easiest is to partition your x.y.z/22 into x.y.z.0/26, x.y.z.64/26, x.y.z.128/26, and x.y.z.192/26. You have to partition on block boundaries.
• (21.12) Well we can hand out 1024 addresses and only 473 computers total are requested, but the question is will the allocations work given block boundaries? Let‘s say we have 1.0.0.0/22, which goes from 1.0.0.0 to 1.0.3.255, and see if we can satisfy everyone by partitioning:

  # Hosts requested	Block Need	Range
  260	/23	1.0.0.0 ... 1.0.1.255
  128	/24	1.0.2.0 ... 1.0.2.255
  41	/26	1.0.3.0 ... 1.0.3.63
  20	/27	1.0.3.64 ... 1.0.3.95
  15	/27	1.0.3.96 ... 1.0.3.127
  9	/28	1.0.3.128 ... 1.0.3.143

  We did it! And we have 112 addresses left to give out.

  Here is another way to see how the networks are handed out from a /22:

  x x.x x x x x x x x    ← Our /22
  0 x.x x x x x x x x    ← Allocate the /23
  1 0.x x x x x x x x    ← Allocate a /24
  1 1.0 0 x x x x x x    ← Allocate a /26
  1 1.0 1 0 x x x x x    ← Allocate a /27
  1 1.0 1 1 x x x x x    ← and another /27
  1 1.1 0 0 0 x x x x    ← Allocate the /28
  

• (21.13) See cidr_to_address_and_mask_in_binary in module below
• (23.2) Address resolution
• (23.5) 8 + 6 + 4 + 6 + 4 = 28 bytes
• (23.22) It the largest of the private blocks, with 16777216 addresses. The other blocks are much smaller.
• (24.3) 128-bit addresses; simplified header, no checksum, fragmentation at the sender rather than the router, high level features in extension headers; real-time traffic support.
• (24.9) See binary_to_colon_hex in module below

It’s easiest to combine all the functions in a single module since they share some code:

import sys
import re

# Yes, these are global, but it’s a nice way to ensure they are only computed once
OCTET = r'(?:\d|[1-9]\d|1\d\d|2(?:[0-4]\d|5[0-5]))'
DOTTED_QUAD = f'{OCTET}\\.{OCTET}\\.{OCTET}\\.{OCTET}'
IPv4_PATTERN = re.compile(DOTTED_QUAD)
IPv4_CIDR_PATTERN = re.compile(f'{DOTTED_QUAD}/(?:\\d|[1-2]\\d|3[0-2])')
IPv6_BINARY_PATTERN = re.compile(r'[01]{128}')

def validate_ipv4(address):
    if re.fullmatch(IPv4_PATTERN, address) is None:
        raise ValueError('Illegal IPv4 Address')

def validate_ipv4_cidr(address):
    if re.fullmatch(IPv4_CIDR_PATTERN, address) is None:
        raise ValueError('Illegal IPv4 CIDR')

def validate_ipv6_binary(bit_string):
    if re.fullmatch(IPv6_BINARY_PATTERN, bit_string) is None:
        raise ValueError('Illegal IPv6 Binary')

def dotted_decimal_quad_to_binary(quad):
    validate_ipv4(quad)
    return ''.join(f'{int(octet):08b}' for octet in quad.split('.'))

def is_dotted_quad_multicast(quad):
    validate_ipv4(quad)
    return dotted_decimal_quad_to_binary(quad).startswith('1110')

def cidr_to_dotted_quad(cidr):
    '''I guess just drop the slash part after validation'''
    validate_ipv4_cidr(cidr)
    return cidr[0:cidr.index('/')]

def dotted_quad_to_cidr(quad, length):
    '''I guess just add the slash after validation'''
    validate_ipv4(quad)
    if not isinstance(length, int) or length < 0 or length > 32:
        raise ValueError('Invalid CIDR length')
    return f'{quad}/{length}'

def cidr_to_address_and_mask_in_binary(cidr):
    validate_ipv4_cidr(cidr)
    address, length = cidr.split('/')
    mask = '1' * int(length) + '0' * (32 - int(length))
    return address, mask

def binary_to_colon_hex(b):
    validate_ipv6_binary(b)
    return ':'.join(f'{int(b[i:i+16], 2):x}' for i in range(0, 128, 16))

Tests for the Python IPUtils

While you were not required to turn in unit tests, the little functions that were required in this assigment were tricky that you would be insane not to have provided unit tests. Here are the tests I used, just for fun:

import pytest
import iputils

def test_dotted_decimal_quad_to_binary():
    good = [
        ('12.3.8.9', '00001100000000110000100000001001'),
        ('255.255.255.255', '11111111111111111111111111111111'),
        ('100.32.240.96', '01100100001000001111000001100000')]
    bad = ['', 'dog', '100.256.0.0', '10.0', '1..100', '3.-5.2.2']
    for ip, binary in good:
        assert iputils.dotted_decimal_quad_to_binary(ip) == binary
    for ip in bad:
        with pytest.raises(ValueError):
            iputils.dotted_decimal_quad_to_binary(ip)

def test_is_dotted_quad_multicast():
    multicast = ['224.0.0.0', '239.255.255.255', '230.1.8.129']
    not_multicast = ['223.0.0.0', '240.0.1.2', '255.255.255.255']
    bad = ['', 'dog', '100.256.0.0', '10.0', '1..100', '3.-5.2.2']
    for ip in multicast:
        assert iputils.is_dotted_quad_multicast(ip)
    for ip in not_multicast:
        assert not iputils.is_dotted_quad_multicast(ip)
    for ip in bad:
        with pytest.raises(ValueError):
            iputils.is_dotted_quad_multicast(ip)

def test_cidr_to_dotted_quad():
    good = [
        ('12.3.8.9/20', '12.3.8.9'),
        ('5.222.11.3/25', '5.222.11.3'),
        ('100.32.240.96/8', '100.32.240.96')]
    bad = [
        '', 'dog', '100.256.0.0', '10.0', '1..100', '3.-5.2.2',
        '1.1.1.1/dog', '1.1.1.1/33']
    for cidr, ip in good:
        assert iputils.cidr_to_dotted_quad(cidr) == ip
    for cidr in bad:
        with pytest.raises(ValueError):
            iputils.dotted_decimal_quad_to_binary(cidr)

def test_dotted_quad_to_cidr():
    good = [
        ('12.3.8.9/20', 20, '12.3.8.9'),
        ('5.222.11.3/25', 25, '5.222.11.3'),
        ('100.32.240.96/32', 32, '100.32.240.96')]
    bad = [
        ('100.256.0.0', 8),
        ('1.1.1.1', 33),
        ('2.3.4.5', 'dog')]
    for cidr, length, quad in good:
        assert iputils.dotted_quad_to_cidr(quad, length) == cidr
    for quad, length in bad:
        with pytest.raises(ValueError):
            iputils.dotted_quad_to_cidr(quad, length)

def test_cidr_to_address_and_mask_in_binary():
    good = [
        ('12.3.8.9/20', '12.3.8.9', '11111111111111111111000000000000'),
        ('5.222.11.3/25', '5.222.11.3', '11111111111111111111111110000000'),
        ('5.222.11.3/1', '5.222.11.3', '10000000000000000000000000000000'),
        ('5.222.11.3/32', '5.222.11.3', '11111111111111111111111111111111'),
        ('100.32.240.96/0', '100.32.240.96', '00000000000000000000000000000000')]
    bad = [
        '', 'dog', '100.256.0.0', '10.0', '1..100', '3.-5.2.2',
        '1.1.1.1/dog', '1.1.1.1/33']
    for cidr, ip, mask in good:
        assert iputils.cidr_to_address_and_mask_in_binary(cidr) == (ip, mask)
    for cidr in bad:
        with pytest.raises(ValueError):
            iputils.cidr_to_address_and_mask_in_binary(cidr)

def test_binary_to_colon_hex():
    good = [
        ('0000000000000011' * 8, '3:3:3:3:3:3:3:3'),
        ('1010' * 32, 'aaaa:aaaa:aaaa:aaaa:aaaa:aaaa:aaaa:aaaa'),
        ('11010010' * 15 + '11000011', 'd2d2:d2d2:d2d2:d2d2:d2d2:d2d2:d2d2:d2c3'),
        ('0' * 128, '0:0:0:0:0:0:0:0')]
    bad = ['', '10101', '1'*127+'2']
    for binary, address in good:
        assert iputils.binary_to_colon_hex(binary) == address
    for binary in bad:
        with pytest.raises(ValueError):
            iputils.binary_to_colon_hex(binary)

Little K'tah

Will be on GitHub.