How to Detect If Two IP Addresses Are from the Same Network Modem

<?php
/**
 * A class to validate IP addresses, check if two IPs belong to the same network,
 * and handle CIDR notation.
 */
class IPAddressValidator {

    public function __construct() {}

    public static function isValidIPv4(string $ip): bool {
        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== false;
    }

    public static function isValidIPv6(string $ip): bool {
        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== false;
    }

    /**
     * Checks if two IPs belong to the same network based on an optional subnet mask length.
     *
     * @param string $ip1 The first IP address.
     * @param string $ip2 The second IP address.
     * @param int|null $subnetLength Optional subnet mask length for comparison.
     *                               Defaults to classful network rules if not specified.
     * @return array An associative array with success status and message.
     */

    public static function isSameModem(string $ip1, string $ip2, ?int $subnetLength = null): array {
        if (!self::isValidIPv4($ip1) && !self::isValidIPv6($ip1)) {
            return [
                'success' => false,
                'message' => 'The first IP address is invalid.'
            ];
        }

        if (!self::isValidIPv4($ip2) && !self::isValidIPv6($ip2)) {
            return [
                'success' => false,
                'message' => 'The second IP address is invalid.'
            ];
        }

        if (self::isValidIPv4($ip1) && self::isValidIPv4($ip2)) {
            return self::compareIPv4Networks($ip1, $ip2, $subnetLength);
        }

        if (self::isValidIPv6($ip1) && self::isValidIPv6($ip2)) {
            return self::compareIPv6Networks($ip1, $ip2, $subnetLength);
        }

        return [
            'success' => false,
            'message' => 'Cannot compare IPv4 and IPv6 addresses.'
        ];
    }

    /**
     * Validates and parses a CIDR notation.
     *
     * @param string $cidr The CIDR notation (e.g., 192.168.1.0/24).
     * @return array|null
     * Returns an associative array with 'ip' and 'prefix' keys if valid, null otherwise.
     */
    public static function parseCIDR(string $cidr): ?array {
        $parts = explode('/', $cidr);
        if (count($parts) !== 2) {
            return null; // Invalid format
        }

        [$ip, $prefix] = $parts;
        $prefix = (int)$prefix;

        if (self::isValidIPv4($ip) && $prefix >= 0 && $prefix <= 32) {
            return ['ip' => $ip, 'prefix' => $prefix];
        }

        if (self::isValidIPv6($ip) && $prefix >= 0 && $prefix <= 128) {
            return ['ip' => $ip, 'prefix' => $prefix];
        }

        return null; // Invalid IP or prefix
    }

    private static function compareIPv4Networks(string $ip1, string $ip2, ?int $subnetLength): array {
        if ($subnetLength === null) {
            $subnetLength = 24; // Default to /24
        }

        $mask = ~((1 << (32 - $subnetLength)) - 1);
        $longIp1 = ip2long($ip1) & $mask;
        $longIp2 = ip2long($ip2) & $mask;

        $isSameNetwork = $longIp1 === $longIp2;
        return [
            'success' => true,
            'message' => $isSameNetwork ? 'Same network' : 'Different networks'
        ];
    }

    private static function compareIPv6Networks(string $ip1, string $ip2, ?int $subnetLength): array {
        if ($subnetLength === null) {
            $subnetLength = 64; // Default to /64
        }

        $binIp1 = @inet_pton($ip1);
        $binIp2 = @inet_pton($ip2);

        if ($binIp1 === false || $binIp2 === false) {
            return [
                'success' => false,
                'message' => 'Invalid IPv6 address provided.'
            ];
        }

        $mask = str_repeat("\xff", intdiv($subnetLength, 8)) .
                chr((0xff << (8 - $subnetLength % 8)) & 0xff) .
                str_repeat("\x00", 16 - ceil($subnetLength / 8));

        $isSameNetwork = ($binIp1 & $mask) === ($binIp2 & $mask);
        return [
            'success' => true,
            'message' => $isSameNetwork ? 'Same network' : 'Different networks'
        ];
    }
}
?>

$isIPv4 = IPAddressValidator::isValidIPv4('192.168.1.1');
// Returns true for valid IPv4

$isIPv6 = IPAddressValidator::isValidIPv6('2001:db8::1');
// Returns true for valid IPv6

$result = IPAddressValidator::isSameModem('192.168.1.1', '192.168.1.20', 24);
// Returns: ['success' => true, 'message' => 'Same network']

$cidrData = IPAddressValidator::parseCIDR('192.168.1.0/24');
// Returns: ['ip' => '192.168.1.0', 'prefix' => 24]

<?php

require_once './ip-address-validator.php';

// Check if two IPs are in the same subnet
$result = IPAddressValidator::isSameModem('192.168.1.1', '192.168.1.2');
if ($result['success']) {
    echo $result['message'];  // "Same network"
}

$result = IPAddressValidator::isSameModem('2001:db8:1234::', '2001:db8:1234:1::');
if ($result['success']) {
    echo $result['message'];  // "Same network"
}

// Validate and parse CIDR
$cidr = "192.168.1.0/24";
$parsedCIDR = IPAddressValidator::parseCIDR($cidr);
if ($parsedCIDR !== null) {
    echo "Valid CIDR\n";
    echo "IP: " . $parsedCIDR['ip'] . "\n";
    echo "Prefix: " . $parsedCIDR['prefix'] . "\n";
} else {
    echo "Invalid CIDR";
}

// Compare IPs using parsed CIDR
$ip1 = "192.168.1.10";
$ip2 = "192.168.1.20";
$subnetLength = $parsedCIDR['prefix'];

$result = IPAddressValidator::isSameModem($ip1, $ip2, $subnetLength);
print_r($result); // Should print: Same network

// Invalid CIDR example
$invalidCIDR = "192.168.1.0/33";
$parsedInvalidCIDR = IPAddressValidator::parseCIDR($invalidCIDR);
if ($parsedInvalidCIDR === null) {
    echo "Invalid CIDR notation: $invalidCIDR\n";
}