132 lines
3.3 KiB
Python
Executable file
132 lines
3.3 KiB
Python
Executable file
#! /usr/bin/env python
|
|
# -*- coding: iso-8859-15 -*-
|
|
"""
|
|
Manipulation d'IPv4
|
|
|
|
Copyright (C) Frédéric Pauget
|
|
Licence : GPLv2
|
|
"""
|
|
|
|
import re
|
|
from config import NETs_regexp
|
|
|
|
# Pour accélérer QuadToDec...
|
|
__QuadToDecDone = {}
|
|
|
|
def QuadToDec(ip) :
|
|
"""
|
|
Retourne la représentation décimale d'une ip
|
|
ip est de la forme xxx.xxx.xxx.xxx
|
|
"""
|
|
if ip in __QuadToDecDone:
|
|
return __QuadToDecDone[ip]
|
|
test = ip.split('.')
|
|
if len(test)!=4 : raise ValueError('IP Invalide')
|
|
ip_dec = 0
|
|
for z in range(0,4) :
|
|
n = int(test[z])
|
|
if n<0 or n>255 : raise ValueError('IP Invalide')
|
|
ip_dec += n * ( 256**(3-z) )
|
|
|
|
__QuadToDecDone[ip] = ip_dec
|
|
return ip_dec
|
|
|
|
# Pour accélérer DecToQuad
|
|
__DecToQuadDone = {}
|
|
|
|
def DecToQuad(ip_dec) :
|
|
"""
|
|
Retourne la représentation habituelle d'une ip (xxx.xxx.xxx.xxx)
|
|
ip_dec est l'IP en base 10
|
|
"""
|
|
if ip_dec in __DecToQuadDone:
|
|
return __DecToQuadDone[ip_dec]
|
|
try :
|
|
result = "%d.%d.%d.%d" % ( \
|
|
ip_dec/(256**3) ,
|
|
(ip_dec%(256**3)) / (256**2) ,
|
|
( (ip_dec%(256**3)) % (256**2) ) / 256 ,
|
|
( (ip_dec%(256**3)) % (256**2) ) % 256 )
|
|
__DecToQuadDone[ip_dec] = result
|
|
return result
|
|
except :
|
|
raise ValueError('IP Invalide')
|
|
|
|
__paramDone = {}
|
|
|
|
def param(net, raw=False) :
|
|
"""
|
|
net est un résau fourni sous la forme xxx.xxx.xxx.xxx/yy
|
|
si donnée valide retourne un dictionnaire :
|
|
{ 'network' : xxx.xxx.xxx.xxx ,
|
|
'netmask' : yyy.yyy.yyy.yyy ,
|
|
'broadcast' : zzz.zzz.zzz.zzz }
|
|
sinon retourne {}
|
|
|
|
Si raw = False, alors, on ne convertit pas les résultats sous forme pointée.
|
|
Ils restent sous forme d'un entier.
|
|
"""
|
|
if raw and net in __paramDone:
|
|
return __paramDone[net]
|
|
reseau = {}
|
|
ip, mask = net.split('/')
|
|
|
|
try :
|
|
mask = int(mask)
|
|
dec_ip = QuadToDec(ip)
|
|
if dec_ip == -1 : raise
|
|
except :
|
|
return {}
|
|
|
|
# Calcul du netmask
|
|
non_dec_netmask = (1L<<(32-mask)) - 1
|
|
dec_netmask = (1L<<32) - 1 - non_dec_netmask
|
|
|
|
reseau = { 'netmask' : dec_netmask,
|
|
'network' : dec_ip & dec_netmask,
|
|
'broadcast' : dec_ip | non_dec_netmask }
|
|
if not raw:
|
|
for i in reseau.keys():
|
|
reseau[i] = DecToQuad(reseau[i])
|
|
else:
|
|
__paramDone[net] = reseau
|
|
return reseau
|
|
|
|
def AddrInNet(ip,net) :
|
|
"""
|
|
ip est de la forme xxx.xxx.xxx.xxx
|
|
net est de la forme xxx.xxx.xxx.xxx/yy
|
|
net peut être une liste de chaînes ci-dessus
|
|
Retourne True si l'ip est dans un des réseaux.
|
|
Note : retourne False si l'IP est une adresse de réseau ou broadcast
|
|
"""
|
|
if type(net)==str : net = [ net ]
|
|
|
|
r = False
|
|
ip = QuadToDec(ip)
|
|
for ne in net :
|
|
n = param(ne, raw=True)
|
|
if ip == n['broadcast'] or ip == n['network'] :
|
|
return False
|
|
r = r or n['netmask'] & ip == n['network']
|
|
|
|
return r
|
|
|
|
def AddrInNets(ip,nets) :
|
|
""" Vérifie si l'ip est au moins dans un des réseaux
|
|
de la liste nets (voir AddrInNet) """
|
|
for net in nets :
|
|
if AddrInNet(ip,net) :
|
|
return True
|
|
return False
|
|
|
|
def is_crans(ip):
|
|
if re.match(NETs_regexp['all'], ip):
|
|
return True
|
|
return False
|
|
|
|
if __name__ == '__main__' :
|
|
import sys
|
|
print param(sys.argv[1])
|
|
|
|
|