第9天：子网划分实战

# day09_subnet_calculator.py
# 功能：子网计算器

import math

class SubnetCalculator:
    """子网计算器"""

    def __init__(self):
        pass

    def cidr_to_mask(self, cidr):
        """
        将CIDR转换为子网掩码

        参数：
            cidr: CIDR值（如24）

        返回：
            子网掩码字符串（如 "255.255.255.0"）
        """
        # 生成32位二进制，前cidr位是1，其余是0
        binary = '1' * cidr + '0' * (32 - cidr)

        # 分成4组，每组8位
        octets = [binary[i:i+8] for i in range(0, 32, 8)]

        # 转换为十进制
        mask = '.'.join([str(int(octet, 2)) for octet in octets])

        return mask

    def mask_to_cidr(self, mask):
        """
        将子网掩码转换为CIDR

        参数：
            mask: 子网掩码字符串（如 "255.255.255.0"）

        返回：
            CIDR值
        """
        # 转换为二进制
        binary = ''.join([format(int(x), '08b') for x in mask.split('.')])

        # 计算1的个数
        return binary.count('1')

    def ip_to_int(self, ip):
        """将IP地址转换为整数"""
        parts = ip.split('.')
        return (int(parts[0]) << 24) + (int(parts[1]) << 16) + \
               (int(parts[2]) << 8) + int(parts[3])

    def int_to_ip(self, num):
        """将整数转换为IP地址"""
        return f"{(num >> 24) & 255}.{(num >> 16) & 255}." \
               f"{(num >> 8) & 255}.{num & 255}"

    def calculate_subnet(self, ip, cidr):
        """
        计算子网信息

        参数：
            ip: IP地址字符串
            cidr: CIDR值

        返回：
            包含所有子网信息的字典
        """
        # 转换为整数
        ip_int = self.ip_to_int(ip)

        # 计算子网掩码
        mask = self.cidr_to_mask(cidr)
        mask_int = self.ip_to_int(mask)

        # 计算网络地址（IP AND 掩码）
        network_int = ip_int & mask_int
        network = self.int_to_ip(network_int)

        # 计算广播地址（网络地址 OR 反码掩码）
        wildcard_int = ~mask_int & 0xFFFFFFFF  # 通配符掩码（反码）
        broadcast_int = network_int | wildcard_int
        broadcast = self.int_to_ip(broadcast_int)

        # 计算第一个和最后一个可用IP
        first_usable_int = network_int + 1
        last_usable_int = broadcast_int - 1

        first_usable = self.int_to_ip(first_usable_int)
        last_usable = self.int_to_ip(last_usable_int)

        # 计算主机数
        host_bits = 32 - cidr
        total_hosts = 2 ** host_bits
        usable_hosts = total_hosts - 2 if total_hosts > 2 else 0

        # 计算通配符掩码
        wildcard = self.int_to_ip(wildcard_int)

        result = {
            'ip': ip,
            'cidr': cidr,
            'mask': mask,
            'wildcard': wildcard,
            'network': network,
            'broadcast': broadcast,
            'first_usable': first_usable,
            'last_usable': last_usable,
            'total_hosts': total_hosts,
            'usable_hosts': usable_hosts
        }

        return result

    def split_subnet(self, ip, old_cidr, new_cidr):
        """
        将一个子网划分为多个更小的子网

        参数：
            ip: 原始网络地址
            old_cidr: 原始CIDR
            new_cidr: 新的CIDR（必须大于old_cidr）

        返回：
            子网列表
        """
        if new_cidr <= old_cidr:
            return None

        # 计算可以划分多少个子网
        num_subnets = 2 ** (new_cidr - old_cidr)

        # 计算每个子网的大小
        subnet_size = 2 ** (32 - new_cidr)

        # 获取起始网络地址
        start_int = self.ip_to_int(ip) & self.ip_to_int(self.cidr_to_mask(old_cidr))

        subnets = []
        for i in range(num_subnets):
            subnet_ip_int = start_int + (i * subnet_size)
            subnet_ip = self.int_to_ip(subnet_ip_int)
            subnets.append(f"{subnet_ip}/{new_cidr}")

        return subnets

    def print_subnet_info(self, info):
        """
        打印子网信息

        参数：
            info: calculate_subnet()返回的字典
        """
        print("=" * 70)
        print("子网信息".center(70))
        print("=" * 70)
        print(f"\n📍 IP地址:          {info['ip']}")
        print(f"🔢 CIDR:            /{info['cidr']}")
        print(f"🎭 子网掩码:        {info['mask']}")
        print(f"🃏 通配符掩码:      {info['wildcard']}")
        print(f"\n🌐 网络地址:        {info['network']}/{info['cidr']}")
        print(f"📡 广播地址:        {info['broadcast']}")
        print(f"\n🏁 第一个可用IP:    {info['first_usable']}")
        print(f"🏁 最后一个可用IP:  {info['last_usable']}")
        print(f"\n📊 总主机数:        {info['total_hosts']}")
        print(f"✅ 可用主机数:      {info['usable_hosts']}")
        print("=" * 70)

def main():
    """
    主函数
    """
    calc = SubnetCalculator()

    print("=" * 70)
    print("子网计算器".center(70))
    print("=" * 70)

    while True:
        print("\n请选择功能:")
        print("1. 计算子网信息")
        print("2. CIDR ↔ 子网掩码转换")
        print("3. 子网划分")
        print("4. 快速查询常用CIDR")
        print("0. 退出")

        choice = input("\n请输入选项: ").strip()

        if choice == '0':
            print("\n再见！")
            break

        elif choice == '1':
            ip = input("\n请输入IP地址: ").strip()
            cidr = input("请输入CIDR（如24）: ").strip()

            try:
                cidr = int(cidr)
                if 0 <= cidr <= 32:
                    info = calc.calculate_subnet(ip, cidr)
                    calc.print_subnet_info(info)
                else:
                    print("❌ CIDR必须在0-32之间")
            except ValueError:
                print("❌ 请输入有效的数字")

        elif choice == '2':
            print("\n请选择转换方向:")
            print("1. CIDR → 子网掩码")
            print("2. 子网掩码 → CIDR")

            sub_choice = input("请输入选项: ").strip()

            if sub_choice == '1':
                cidr = input("\n请输入CIDR: ").strip()
                try:
                    cidr = int(cidr)
                    mask = calc.cidr_to_mask(cidr)
                    print(f"\n/{cidr} = {mask}")
                except ValueError:
                    print("❌ 请输入有效的数字")

            elif sub_choice == '2':
                mask = input("\n请输入子网掩码: ").strip()
                try:
                    cidr = calc.mask_to_cidr(mask)
                    print(f"\n{mask} = /{cidr}")
                except:
                    print("❌ 请输入有效的子网掩码")

        elif choice == '3':
            ip = input("\n请输入网络地址: ").strip()
            old_cidr = input("请输入原始CIDR: ").strip()
            new_cidr = input("请输入新的CIDR: ").strip()

            try:
                old_cidr = int(old_cidr)
                new_cidr = int(new_cidr)

                subnets = calc.split_subnet(ip, old_cidr, new_cidr)

                if subnets:
                    print(f"\n📊 将 {ip}/{old_cidr} 划分为 /{new_cidr} 子网:")
                    print(f"   共 {len(subnets)} 个子网\n")
                    for i, subnet in enumerate(subnets, 1):
                        print(f"   {i}. {subnet}")
                else:
                    print("❌ 新CIDR必须大于原CIDR")
            except ValueError:
                print("❌ 请输入有效的数字")

        elif choice == '4':
            print("\n常用CIDR速查表：")
            print(f"\n{'CIDR':<8} {'子网掩码':<18} {'可用主机数':<12} {'说明'}")
            print("-" * 60)

            common_cidrs = [
                (8, "A类默认"),
                (16, "B类默认"),
                (24, "C类默认"),
                (25, "C类分2个子网"),
                (26, "C类分4个子网"),
                (27, "C类分8个子网"),
                (28, "C类分16个子网"),
                (29, "小型子网"),
                (30, "点对点链路"),
            ]

            for cidr, desc in common_cidrs:
                mask = calc.cidr_to_mask(cidr)
                hosts = 2 ** (32 - cidr) - 2
                print(f"/{cidr:<7} {mask:<18} {hosts:<12} {desc}")

if __name__ == "__main__":
    main()

python code/day09/day09_subnet_calculator.py