Пример #1
0
    def check_ip(self):
        network_segment = IP(self.start_ip + '/' + self.netmask, make_net=True)

        ret = dict()
        # 起止IP必须在同一个网段中
        if IP(self.end_ip) not in network_segment:
            ret['state'] = ji.Common.exchange_state(41251)
            raise ji.PreviewingError(json.dumps(ret, ensure_ascii=False))

        # 网关必须与将分配给Guest的IP,处于同一个网段中
        if IP(self.gateway) not in network_segment:
            ret['state'] = ji.Common.exchange_state(41252)
            raise ji.PreviewingError(json.dumps(ret, ensure_ascii=False))

        # 网关不能是网络地址或广播地址
        if IP(self.gateway) in [network_segment[i] for i in (0, -1)]:
            ret['state'] = ji.Common.exchange_state(41253)
            raise ji.PreviewingError(json.dumps(ret, ensure_ascii=False))

        # 当用户输入的起始IP为网络地址时,自动重置其为该网段中第一个可用IP
        if self.start_ip == network_segment[0].__str__():
            self.start_ip = intToIp(
                (int(IP(self.start_ip).strDec()) + 1).__str__(), 4)

        # 当用户输入的结束IP为广播地址时,自动重置其为该网段中最后一个可用IP
        if self.end_ip == network_segment[-1].__str__():
            self.end_ip = intToIp(
                (int(IP(self.end_ip).strDec()) - 1).__str__(), 4)

        # 起始的可用IP地址必须小于结束的可用IP地址
        if IP(self.start_ip) >= IP(self.end_ip):
            ret['state'] = ji.Common.exchange_state(41254)
            raise ji.PreviewingError(json.dumps(ret, ensure_ascii=False))

        return True
Пример #2
0
def generate_available_ip2set(start_ip, end_ip, netmask):
    conn = get_redis_connection()
    # 删除现有的server publickey字段
    conn.delete("spublickey")
    # 删除现有的可用IP集合
    conn.delete('ip_available_set')
    # 起止IP必须在同一网段中
    network_segment = IP(start_ip + '/' + netmask, make_net=True)

    # 初始化服务器公钥
    server_publickey_file = "/etc/wireguard/spublickey"
    cmd = "cat %s" % server_publickey_file
    server_publickey = os.popen(cmd).read().strip()
    conn.set("spublickey", server_publickey)

    # 初始化可用ip
    if IP(end_ip) in network_segment:
        for ip_dec in range(IP(start_ip).int(), IP(end_ip).int() + 1):
            ip = intToIp(ip_dec, 4)
            if check_ip(ip):
                conn.sadd("ip_available_set", ip)

        return "success"
    else:
        return "error"
Пример #3
0
    def generate_available_ip2set(self):
        # 删除现有的可用IP集合
        db.r.delete(app_config['ip_available_set'])

        for ip_dec in range(int(IP(self.start_ip).strDec()),
                            int(IP(self.end_ip).strDec()) + 1):
            db.r.sadd(app_config['ip_available_set'], intToIp(ip_dec, 4))
Пример #4
0
    def unpack(packed):
        """
        The rowkey packed format is: >I (big endian single int)
        The unpacked format is: dot quad string, no leading zeros
        """

        if len(packed) != 4:
            raise Exception("not a 4 byte buffer")

        return intToIp(unpack(">I", packed), 4)
Пример #5
0
def make_ip(room, machine):
	"""
	Génère une IP à partir du numéro de chambre et de l'index de la
	machine. Il s'agit d'appliquer le plan d'adressage de Maiz pour
	les résidents enregistrés. Au cas où la documentation se perde,
	voici comment c'est foutu :

	    172.17.R S C C C C C C . C C C M M M M M

	172.17 est le préfixe, y'a pas de souci avec ça.

	R et S définissent le type de machine. Dans le cas d'un résident
	enregistré, c'est 10. (00 pour un serveur, 01 pour un switch, et
	11 pour un invité).

	Les bits C définissent le numéro de chambre.

	Les bits M définissent le numéro de machine.

	La fonction prends en argument les numéros de chambre et de
	machine, et retourne une chaîne contenant l'IP valide.
	"""

	# On utilise la classe BinString qui permet de créer une "chaîne
	# binaire" bits par bits assez simplement.
	s = utils.BinString()

	# Si on ne peut pas encoder la chambre, on gueule
	if len(bin(room)) > 11:
		raise Exception(_('Could not generate IP: room number to high (%(number)d)') % {'number': room})

	# Si on ne peut pas encoder la machine, on laisse l'utilisateur
	# se démerder avec ses IP multiples
	machine = machine % 31

	# 172.17, le préfixe Maiznet
	s += utils.tobinrep(172, 8)
	s += utils.tobinrep(17, 8)

	# On a une IP de résident, donc les deux bits suivants sont 10
	s += '10'

	# On ajoute ensuite la chambre et la machine
	s += utils.tobinrep(room, 9)
	s += utils.tobinrep(machine, 5)

	# Et finalement, on génère l'IP
	ip = intToIp(s.to_int(), 4)

	return ip
Пример #6
0
def generate_available_ip2set():
    conn = get_redis_connection()
    # 删除现有的可用IP集合
    conn.delete('ip_available_set')
    # 起止IP必须在同一网段中
    network_segment = IP(start_ip + '/' + netmask, make_net=True)

    if IP(end_ip) in network_segment:
        for ip_dec in range(IP(start_ip).int(),IP(end_ip).int()+1):
            ip = intToIp(ip_dec,4)
            if check_ip(ip):
                conn.sadd("ip_available_set",ip)

        return "success"
    else:
        return "error"
Пример #7
0
def general_ip(start_ip,end_ip,netmask):
    """
    生成IP地址段
    """
    # 起止IP必须在同一网段中
    network_segment = IP(start_ip + '/' + netmask, make_net=True)
    if IP(end_ip) in network_segment:
        ip_list = []
        for ip_dec in range(IP(start_ip).int(),IP(end_ip).int()+1):
            ip = intToIp(ip_dec,4)
            if check_ip(ip):
                ip_list.append(ip)

        return ip_list
    else:
        return "error"
Пример #8
0
    def ip_generator(self, occupied_ips=None):
        """
        # 可用 IP 生成器
        :param occupied_ips: 已分配的虚拟机 IP 列表
        :return: 返回一个可分配的 IP 地址,格式如 '192.168.1.1'
        """

        assert isinstance(occupied_ips, list)

        occupied_ips_dec = list()

        for occupied_ip in occupied_ips:
            occupied_ips_dec.append(int(IP(occupied_ip).strDec()))

        for ip_dec in range(int(IP(self.start_ip).strDec()), int(IP(self.end_ip).strDec()) + 1):
            if ip_dec in occupied_ips_dec:
                continue

            yield intToIp(ip_dec, 4)