IP Addresses and Ports

package main

import (
	"fmt"
	"strconv"
	"strings"
)

// parseIPv4 checks "a.b.c.d" (each part 0-255) and returns the four bytes.
func parseIPv4(s string) ([4]int, bool) {
	var ip [4]int
	parts := strings.Split(s, ".")
	if len(parts) != 4 {
		return ip, false
	}
	for i, p := range parts {
		n, err := strconv.Atoi(p)
		if err != nil || n < 0 || n > 255 {
			return ip, false
		}
		ip[i] = n
	}
	return ip, true
}

// This machine's addresses, and which program listens on which address and port.
var myIPs = []string{"192.168.1.10", "127.0.0.1"}
var listeners = map[string]string{
	"0.0.0.0:80":     "nginx (web server)", // 0.0.0.0 means: on every address this machine has
	"0.0.0.0:5432":   "postgres (database)",
	"127.0.0.1:6379": "redis (cache, local only)",
}

// deliver is what the operating system does with an incoming connection.
func deliver(dest string) string {
	host, portStr, _ := strings.Cut(dest, ":")
	if _, ok := parseIPv4(host); !ok {
		return "invalid address"
	}
	port, err := strconv.Atoi(portStr)
	if err != nil || port < 1 || port > 65535 {
		return "invalid port"
	}
	mine := false
	for _, ip := range myIPs {
		mine = mine || ip == host
	}
	if !mine {
		return "not this machine (wrong IP)"
	}
	if prog, ok := listeners[dest]; ok {
		return prog
	}
	if prog, ok := listeners["0.0.0.0:"+portStr]; ok {
		return prog
	}
	return "connection refused (nothing listening there)"
}

func main() {
	ip, _ := parseIPv4("192.168.1.10")
	bits := make([]string, 4)
	for i, b := range ip {
		bits[i] = fmt.Sprintf("%08b", b)
	}
	fmt.Printf("192.168.1.10 = %s (32 bits)\n", strings.Join(bits, "."))
	for _, dest := range []string{
		"192.168.1.10:80",
		"192.168.1.10:5432",
		"192.168.1.10:6379",
		"127.0.0.1:6379",
		"192.168.1.10:8080",
		"192.168.1.99:80",
		"192.168.1.300:80",
	} {
		fmt.Printf("%-20s -> %s\n", dest, deliver(dest))
	}
}

// parseIPv4 checks "a.b.c.d" (each part 0-255) and returns the four bytes, or null.
function parseIPv4(s) {
  const parts = s.split(".");
  if (parts.length !== 4) return null;
  const ip = parts.map((p) => (/^\d+$/.test(p) ? Number(p) : -1));
  return ip.every((n) => n >= 0 && n <= 255) ? ip : null;
}

// This machine's addresses, and which program listens on which address and port.
const myIPs = ["192.168.1.10", "127.0.0.1"];
const listeners = {
  "0.0.0.0:80": "nginx (web server)", // 0.0.0.0 means: on every address this machine has
  "0.0.0.0:5432": "postgres (database)",
  "127.0.0.1:6379": "redis (cache, local only)",
};

// deliver is what the operating system does with an incoming connection.
function deliver(dest) {
  const [host, portStr] = dest.split(":");
  if (!parseIPv4(host)) return "invalid address";
  const port = /^\d+$/.test(portStr) ? Number(portStr) : 0;
  if (port < 1 || port > 65535) return "invalid port";
  if (!myIPs.includes(host)) return "not this machine (wrong IP)";
  return listeners[dest] ?? listeners[`0.0.0.0:${portStr}`] ?? "connection refused (nothing listening there)";
}

const bits = parseIPv4("192.168.1.10").map((b) => b.toString(2).padStart(8, "0"));
console.log(`192.168.1.10 = ${bits.join(".")} (32 bits)`);
for (const dest of [
  "192.168.1.10:80",
  "192.168.1.10:5432",
  "192.168.1.10:6379",
  "127.0.0.1:6379",
  "192.168.1.10:8080",
  "192.168.1.99:80",
  "192.168.1.300:80",
]) {
  console.log(`${dest.padEnd(20)} -> ${deliver(dest)}`);
}

use std::collections::HashMap;

// parse_ipv4 checks "a.b.c.d" (each part 0-255) and returns the four bytes.
fn parse_ipv4(s: &str) -> Option<[u8; 4]> {
    let parts: Vec<&str> = s.split('.').collect();
    if parts.len() != 4 {
        return None;
    }
    let mut ip = [0u8; 4];
    for (i, p) in parts.iter().enumerate() {
        ip[i] = p.parse::<u8>().ok()?; // u8 only holds 0-255, so 300 fails here
    }
    Some(ip)
}

// deliver is what the operating system does with an incoming connection.
fn deliver(dest: &str, my_ips: &[&str], listeners: &HashMap<&str, &str>) -> String {
    let (host, port_str) = dest.split_once(':').unwrap();
    if parse_ipv4(host).is_none() {
        return "invalid address".into();
    }
    match port_str.parse::<u32>() {
        Ok(p) if (1..=65535).contains(&p) => {}
        _ => return "invalid port".into(),
    }
    if !my_ips.contains(&host) {
        return "not this machine (wrong IP)".into();
    }
    let any = format!("0.0.0.0:{port_str}");
    listeners
        .get(dest)
        .or_else(|| listeners.get(any.as_str()))
        .map(|p| p.to_string())
        .unwrap_or_else(|| "connection refused (nothing listening there)".into())
}

fn main() {
    // This machine's addresses, and which program listens on which address and port.
    let my_ips = ["192.168.1.10", "127.0.0.1"];
    let listeners = HashMap::from([
        ("0.0.0.0:80", "nginx (web server)"), // 0.0.0.0 means: on every address this machine has
        ("0.0.0.0:5432", "postgres (database)"),
        ("127.0.0.1:6379", "redis (cache, local only)"),
    ]);

    let bits: Vec<String> = parse_ipv4("192.168.1.10").unwrap().iter().map(|b| format!("{b:08b}")).collect();
    println!("192.168.1.10 = {} (32 bits)", bits.join("."));
    for dest in [
        "192.168.1.10:80",
        "192.168.1.10:5432",
        "192.168.1.10:6379",
        "127.0.0.1:6379",
        "192.168.1.10:8080",
        "192.168.1.99:80",
        "192.168.1.300:80",
    ] {
        println!("{:<20} -> {}", dest, deliver(dest, &my_ips, &listeners));
    }
}

def parse_ipv4(s):
    """Checks "a.b.c.d" (each part 0-255) and returns the four bytes, or None."""
    parts = s.split(".")
    if len(parts) != 4 or not all(p.isdigit() and 0 <= int(p) <= 255 for p in parts):
        return None
    return [int(p) for p in parts]


# This machine's addresses, and which program listens on which address and port.
MY_IPS = ["192.168.1.10", "127.0.0.1"]
LISTENERS = {
    "0.0.0.0:80": "nginx (web server)",  # 0.0.0.0 means: on every address this machine has
    "0.0.0.0:5432": "postgres (database)",
    "127.0.0.1:6379": "redis (cache, local only)",
}


def deliver(dest):
    """What the operating system does with an incoming connection."""
    host, port_str = dest.split(":")
    if parse_ipv4(host) is None:
        return "invalid address"
    port = int(port_str) if port_str.isdigit() else 0
    if not 1 <= port <= 65535:
        return "invalid port"
    if host not in MY_IPS:
        return "not this machine (wrong IP)"
    return LISTENERS.get(dest) or LISTENERS.get(f"0.0.0.0:{port_str}") or "connection refused (nothing listening there)"


bits = [f"{b:08b}" for b in parse_ipv4("192.168.1.10")]
print(f"192.168.1.10 = {'.'.join(bits)} (32 bits)")
for dest in [
    "192.168.1.10:80",
    "192.168.1.10:5432",
    "192.168.1.10:6379",
    "127.0.0.1:6379",
    "192.168.1.10:8080",
    "192.168.1.99:80",
    "192.168.1.300:80",
]:
    print(f"{dest:<20} -> {deliver(dest)}")

import java.util.List;
import java.util.Map;

public class Main {
    // parseIPv4 checks "a.b.c.d" (each part 0-255) and returns the four bytes, or null.
    static int[] parseIPv4(String s) {
        String[] parts = s.split("\\.");
        if (parts.length != 4) return null;
        int[] ip = new int[4];
        for (int i = 0; i < 4; i++) {
            if (!parts[i].matches("\\d+")) return null;
            ip[i] = Integer.parseInt(parts[i]);
            if (ip[i] > 255) return null;
        }
        return ip;
    }

    // This machine's addresses, and which program listens on which address and port.
    static final List<String> MY_IPS = List.of("192.168.1.10", "127.0.0.1");
    static final Map<String, String> LISTENERS = Map.of(
        "0.0.0.0:80", "nginx (web server)", // 0.0.0.0 means: on every address this machine has
        "0.0.0.0:5432", "postgres (database)",
        "127.0.0.1:6379", "redis (cache, local only)");

    // deliver is what the operating system does with an incoming connection.
    static String deliver(String dest) {
        String[] hp = dest.split(":");
        if (parseIPv4(hp[0]) == null) return "invalid address";
        int port = hp[1].matches("\\d+") ? Integer.parseInt(hp[1]) : 0;
        if (port < 1 || port > 65535) return "invalid port";
        if (!MY_IPS.contains(hp[0])) return "not this machine (wrong IP)";
        String prog = LISTENERS.getOrDefault(dest, LISTENERS.get("0.0.0.0:" + hp[1]));
        return prog != null ? prog : "connection refused (nothing listening there)";
    }

    public static void main(String[] args) {
        StringBuilder bits = new StringBuilder();
        for (int b : parseIPv4("192.168.1.10")) {
            if (bits.length() > 0) bits.append('.');
            bits.append(String.format("%8s", Integer.toBinaryString(b)).replace(' ', '0'));
        }
        System.out.println("192.168.1.10 = " + bits + " (32 bits)");
        for (String dest : new String[] {
            "192.168.1.10:80",
            "192.168.1.10:5432",
            "192.168.1.10:6379",
            "127.0.0.1:6379",
            "192.168.1.10:8080",
            "192.168.1.99:80",
            "192.168.1.300:80"}) {
            System.out.printf("%-20s -> %s%n", dest, deliver(dest));
        }
    }
}