_notebook/ipv4_calculator.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculator (IPv4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network Address\n",
    "\n",
    "Calculate the network address from the IP address and netmask."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Step 1: Write the given IP address in binary format.\n",
    "\n",
    "- Step 2: Write the subnet mask in binary form.\n",
    "\n",
    "- Step 3: Perform the logical  ANDing operation between the corresponding octets of the IP address and the subnet mask.\n",
    "\n",
    "- Step 4: Convert the result back to the decimal format and this will be the network address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IP Address         10100111 11110001 00101010 00010101 -> 167.241.42.21\n",
      "                                   AND\n",
      "Netmask            11111111 11111111 11111111 11111000 -> /29\n",
      "                   -----------------------------------\n",
      "Network Address    10100111 11110001 00101010 00010000 -> 167.241.42.16/29\n"
     ]
    }
   ],
   "source": [
    "# IP Address ----------------------------------------------------------------->\n",
    "\n",
    "ip_addr = input(\"IP Address [xxx.xxx.xxx.xxx]: \")\n",
    "ip_addr_b = \" \".join(\"{:08b}\".format(int(byte)) for byte in ip_addr.split(\".\"))\n",
    "\n",
    "# Netmask -------------------------------------------------------------------->\n",
    "\n",
    "netmask = int(input(\"Netmask [CIDR notation]: \"))\n",
    "netmask_b = \"\".join('1' if i < netmask else '0' for i in range(32))\n",
    "netmask_b = \" \".join(netmask_b[i:(i + 8)] for i in range(0, 32, 8))\n",
    "\n",
    "# Network Address ------------------------------------------------------------>\n",
    "\n",
    "network_addr_bin = \"\".join(str(int(ip_addr_b[i]) & int(netmask_b[i])) if \n",
    "    ip_addr_b[i] != \" \" else \" \" for i in range(35))\n",
    "network_addr = \"\".join(str(int(byte, 2)) + \".\" for byte in \n",
    "    network_addr_bin.split(\" \")).strip(\".\")\n",
    "\n",
    "# Visualization -------------------------------------------------------------->\n",
    "\n",
    "print(\n",
    "    f\"IP Address         {ip_addr_b} -> {ip_addr}\\n\"\n",
    "\tf\"                                   AND\\n\"\n",
    "\tf\"Netmask            {netmask_b} -> /{netmask}\\n\"\n",
    "\tf\"                   -----------------------------------\\n\"\n",
    "\tf\"Network Address    {network_addr_bin} -> {network_addr}/{netmask}\"\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcast Address\n",
    "\n",
    "Calculate broadcast address from the network address.\n",
    "\n",
    "- Step 1: replace all bits dedicated to hosts with 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Network Address    10100111 11110001 00101010 00010000 -> 167.241.42.16/29\n",
      "                   -----------------------------------\n",
      "Broadcast Address  10100111 11110001 00101010 00010111 -> 167.241.42.23\n"
     ]
    }
   ],
   "source": [
    "# Network Address ------------------------------------------------------------>\n",
    "\n",
    "network = input(\"Network Address [xxx.xxx.xxx.xxx/xx]: \")\n",
    "netmask = int(network[-2:])\n",
    "network_addr = network[:-3]\n",
    "network_addr_b = \"\".join(\"{:08b}\".format(int(byte)) for byte in \n",
    "    network_addr.split(\".\"))\n",
    "\n",
    "# Broadcast Address ---------------------------------------------------------->\n",
    "\n",
    "broadcast_addr_b = network_addr_b[:netmask] + '1' * (32 - netmask)\n",
    "broadcast_addr = \".\".join(str(int(broadcast_addr_b[i:i+8], 2)) for i in \n",
    "    range(0, 32, 8))\n",
    "\n",
    "# Visualization -------------------------------------------------------------->\n",
    "\n",
    "def add_spaces(string):\n",
    "    return ' '.join(string[i:i + 8] for i in range(0, 32, 8))\n",
    "\n",
    "print(\n",
    "    f\"Network Address    {add_spaces(network_addr_b)} -> {network}\\n\"\n",
    "\tf\"                   -----------------------------------\\n\"\n",
    "\tf\"Broadcast Address  {add_spaces(broadcast_addr_b)} -> {broadcast_addr}\"\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Host Addresses\n",
    "\n",
    "Valid host addresses are those all between the network address and the broadcast address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Host min -> 167.241.42.16 + 1\n",
      "Host max -> 167.241.42.23 - 1\n"
     ]
    }
   ],
   "source": [
    "# Network Address ------------------------------------------------------------>\n",
    "\n",
    "network = input(\"Network Address [xxx.xxx.xxx.xxx]: \")\n",
    "\n",
    "# Broadcast Address ---------------------------------------------------------->\n",
    "\n",
    "broadcast = input(\"Broadcast Address [xxx.xxx.xxx.xxx]: \")\n",
    "\n",
    "# Hosts Addresses ------------------------------------------------------------>\n",
    "\n",
    "print(f\"Host min -> {network} + 1\\nHost max -> {broadcast} - 1\")"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}