NetDev 脚本 - 路由的聚合

一个 IPv4 网段聚合的实现:

  • 效果: 将多个相同掩码长度的网段,聚合为尽量少的网段,这里,尽量避免了歧义,所以是 100% 正反向匹配;
  • 注意: 如果是不同掩码长度的网段聚合,可以先分类或将网段展开为同掩码长度的多个子网。
from socket import inet_ntoa, inet_aton
from struct import pack, unpack


class IPv4RouteAgg(object):

    def __init__(self, mask: int, nets=None):
        if nets is None:
            nets = []
        self.mask_len = mask
        self.mask_bits = IPv4Tools.mask_int_fmt(mask)
        self.nets = [IPv4Tools.ip_int_fmt(net) & self.mask_bits for net in nets]

    def add_net(self, net):
        self.nets.append(IPv4Tools.ip_int_fmt(net))

    def get_agg(self):
        same_part = self._get_same_part()
        diff_len = self.mask_len - same_part[0]
        if diff_len > 18:
            raise ValueError("nets diff part is too long (more than 18), please classify before agg.")
        net_group = NetGroup(diff_len=self.mask_len - same_part[0], start=same_part[1] >> 32 - self.mask_len)
        for net in self.nets:
            net_group.match(net >> 32 - self.mask_len)
        nets = []
        filled_ngs = net_group.return_filled()
        for ng in filled_ngs:
            nets.append(f"{IPv4Tools.ipv4_fmt(ng.start << 32 - self.mask_len)}/{self.mask_len - ng.diff_len}")
        return nets

    def _get_same_part(self):
        for shorter_len in range(self.mask_len, 0, -1):
            is_same_and_prefix = self._same_on_this_mask(shorter_len)
            if is_same_and_prefix[0]:
                return shorter_len, is_same_and_prefix[1]

    def _same_on_this_mask(self, mask_len):
        mask_bit = IPv4Tools.mask_int_fmt(mask_len)
        same_prefix = self.nets[0] & mask_bit
        for net in self.nets[1:]:
            if same_prefix ^ (net & mask_bit):
                return False, same_prefix
        return True, same_prefix


class NetGroup(object):

    def __init__(self, diff_len, start):
        self.diff_len = diff_len
        self.start = start
        self.end = start + 2 ** diff_len - 1 if diff_len > 0 else self.start
        self._fill = False
        if diff_len == 0:
            self.data = start
            return
        self.data = [NetGroup(diff_len - 1, start), NetGroup(diff_len - 1, start + 2 ** (diff_len - 1))]

    @property
    def fill(self):
        if isinstance(self.data, int):
            return self._fill
        return all([self.data[0].fill, self.data[1].fill])

    def match(self, value):
        if self.start <= value <= self.end:
            if isinstance(self.data, int):
                self._fill = True
            elif not self.data[0].match(value):
                self.data[1].match(value)
            return True
        else:
            return False

    def return_filled(self):
        if self.fill:
            return [self]
        if isinstance(self.data, int):
            return []

        nps = []
        nps.extend(self.data[0].return_filled())
        nps.extend(self.data[1].return_filled())
        return nps

    def __repr__(self):
        return f"{self.start}" if self.start == self.end else f"{self.start}-{self.end}"


class IPv4Tools:
    @staticmethod
    def mask_int_fmt(mask_len):
        return 0xffffffff ^ (1 << 32 - mask_len) - 1

    @staticmethod
    def mask_len_fmt(mask_int):
        return 32 - len(bin(0xffffffff ^ mask_int)[2:])

    @staticmethod
    def ip_int_fmt(ip_in_str: str):
        return unpack("!I", inet_aton(ip_in_str))[0]

    @staticmethod
    def ipv4_fmt(ip_in_int: int):
        return inet_ntoa(pack(">I", ip_in_int))


if __name__ == '__main__':
    ra = IPv4RouteAgg(nets=["192.168.0.0", "192.168.1.0", "192.168.2.0", "192.168.3.0", "192.168.4.0", "192.0.100.0"], mask=24)
    for i in range(23, 200):
        ra.add_net(f"192.168.{i}.0")
    print(ra.get_agg())

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值