Question Ip range

bilbao écrit:

Donc je vais faire des test \"classiques\".

Pour ce thème, une regex facilitera la gestion des erreurs, en tout cas la validité d'une adresse IP :
[code:1]
#http://www.codekeep.net/snippets/9bd4694c-1d33-415e-b97f-db2f7f07015e.aspx
$reg=\"(?<First>2[0-4]\d|25[0-5]|[01]?\d\d?)\.(?<Second>2[0-4]\d|25\"+
\"[0-5]|[01]?\d\d?)\.(?<Third>2[0-4]\d|25[0-5]|[01]?\d\d?)\.(?\"+
\"<Fourth>2[0-4]\d|25[0-5]|[01]?\d\d?)\"
$regIP = new-object System.Text.RegularExpressions.Regex $reg,\"IgnoreCase,CultureInvariant,IgnorePatternWhitespace,Compiled\"
$Result=$regIP.Match($IpRangeStart)
$Result.Success
#Ou
$IpRangeEnd -match $reg
$matches.Fourth[/code:1]
Le groupes nommés facilitent l'accès aux 4 partiess de l'adresse.

J'ai essayé aussi cette approche pour reconstruire l'adresse, il y a surement mieux :
[code:1]
$IpRangeStart=\"192.168.1.20\"
$IpRangeEnd=\"192.170.4.30\"

$StartAddressByte=([system.net.ipaddress]$IpRangeStart).GetAddressBytes()
$EndAddressByte=([system.net.ipaddress]$IpRangeEnd).GetAddressBytes()

$Section=3
function make($Section) {
Invoke-Expression \"$($StartAddressByte[$section])..$($EndAddressByte[$section])\" |
Foreach {
$ExecutionContext.InvokeCommand.ExpandString(('$($StartAddressByte[0]).$($StartAddressByte[1]).$($StartAddressByte[2]).$($StartAddressByte[3])' -replace \"\`$StartAddressByte\[$Section\]\",$_))
}
}

make 3
[/code:1]
Reste que je ne sais pas quel comportement tu recherches lors de la génération, souhaites-tu couvrir toutes les plages ?
Exemples
de 192.168.1.20 à 192.168.1.255 puis de 192.168.2.0 à 192.168.2.255 etc jusqu'à 192.170.4.30

Si tu n'y pas vois d'inconvénient on va appliquer un des principes de l'objet, la réutilisation :
[code:1]
$source = @\"
// From technosrix.blogspot.com/2009/05/how-to-g...sses-from-given.html
//Renvoi une étendue d'adresse IP
using System;
using System.Collections;
using System.Net;

namespace PowerShell.Tools
{
public class IpRange
{
public static ArrayList GetIpAdressFromRange(string fromIp, string toIp)
{
ArrayList ips = new ArrayList();
IPAddress tmpIP = null;

//generate only for valid set of ips
//Todo: check for toip >fromIp
if (IPAddress.TryParse(fromIp, out tmpIP) == true &&
IPAddress.TryParse(toIp, out tmpIP) == true)
{


string[] fromOct = fromIp.Split('.');

string[] toOct = toIp.Split('.');

string a = null, b = null, c = null, d = null;

int startA = Convert.ToInt32(fromOct[0]);
int startB = Convert.ToInt32(fromOct[1]);
int startC = 1;
int startD = 1;

int endA = Convert.ToInt32(toOct[0]);
int endB = 255;
int endC = 255;
int endD = 255;


for (int intA = startA; intA <= endA; intA++)
{
a = intA.ToString();

startB = intA == Convert.ToInt32(fromOct[0]) ? Convert.ToInt32(fromOct[1]) : 1;
endB = intA == Convert.ToInt32(toOct[0]) ? Convert.ToInt32(toOct[1]) : 255;

for (int intB = startB; intB <= endB; intB++)
{
b = intB.ToString();

startC = (intA == Convert.ToInt32(fromOct[0])) && (intB == Convert.ToInt32(fromOct[1])) ?
Convert.ToInt32(fromOct[2]) : 1;
endC = (intA == Convert.ToInt32(toOct[0])) && (intB == Convert.ToInt32(toOct[1])) ?
Convert.ToInt32(toOct[2]) : 255;


for (int intC = startC; intC <= endC; intC++)
{
c = intC.ToString();

startD = (intA == Convert.ToInt32(fromOct[0])) && (intB == Convert.ToInt32(fromOct[1])) && (intC == Convert.ToInt32(fromOct[2])) ?
Convert.ToInt32(fromOct[3]) : 1;
endD = (intA == Convert.ToInt32(toOct[0])) && (intB == Convert.ToInt32(toOct[1])) && (intC == Convert.ToInt32(toOct[2])) ?
Convert.ToInt32(toOct[3]) : 255;


for (int intD = startD; intD <= endD; intD++)
{
d = intD.ToString();
ips.Add(a + \".\" + b + \".\" + c + \".\" + d);
}
}
}
}

}
return ips;
}
}
}
\"@

Add-Type -TypeDefinition $source

$range=[PowerShell.Tools.IpRange]::GetIpAdressFromRange(\"192.168.1.20\", \"192.170.4.30\"«»)
[/code:1]
On 'triche' un peu, mais on gagne du temps

J'ai converti le code C# en PowerShell au sein d'un module. Un des 'soucis' avec la classe IpAddress est qu'on peut passer un entier au constructeur ou à la méthode Parse. Les qq méthodes du module suivant se basent sur des adresses IP respectant le format \"1.2.3.4\".
La méthode New-RangeIPAddress ne filtre pas les adresses pouvant être considérées comme interdites/réservées.
[code:1]
#Module IPAdress.psm1
#Routines autour de la gestion d'adresse IP v4

Function Compare-IPAddress{
#Compare deux adresses IP.
#Renvoi :
# -1 si x est inférieur à y.
# 1 si x est supérieur à y.
# 0 si x est égal à y.
param ([String] $IpAddressX,[String] $IpAddressY)

[long]$X=(ConvertTo-IPAddress $IPAddressX).SortableAddress
[long]$Y=(ConvertTo-IPAddress $IPAddressY).SortableAddress

if ($X -lt $Y) {-1}
elseif ($X -gt $Y) {1}
else {0}
}

function Test-DottedQuadNotation {
#renvoi $true si l'adresse contient trois points ('.')
# $true pour \"A.B.C.D\" et \"258.5.1.0\"
# $false pour \"0\" et \"258.5.1\"
param ( [String] $IpAddress )

$dotCount=0;
for($i=0; $i -lt $IpAddress.Length;$i++) {
if ($IpAddress[$i] -eq \".\"«»)
{$dotCount++}
}
$dotCount -eq 3
}

function Parse-IpAddress {
#renvoi une adresse IP valide ou $null
#On peut générer une adresse à partir d'un seul chiffre, ex : 450
param ( [String] $IpAddress )

[REF] $tmpIP=$null
[void][System.Net.IPAddress]::TryParse($IpAddress,$tmpIP)
$tmpIP.Value
}

Function Test-IPAddress{
#Teste la validité d'une adresse IP respectant le format A.B.C.D
param ( [String] $IpAddress )

(Test-DottedQuadNotation $IpAddress) -and (Parse-IpAddress $IpAddress)
}

Function ConvertTo-IPAddress {
#Convertie une chaîne au format A.B.C.D, en
# une instance de la classe [System.Net.IPAddress]
Param( [ValidateNotNullOrEmpty()]
[String] $IpAddress )
$ip=$null
if (Test-DottedQuadNotation $IpAddress)
{$Ip=Parse-IpAddress $IpAddress}
if ($ip -eq $null)
{Throw \"ConvertTo-IPAddress : L'adresse IP ($IpAddress) est invalide.\"}
$ip
}

Function New-RangeIPAddress{
#Renvoi une étendue d'adresses IP
#L'adresse $fromIp peut être supérieure à $toIp.
#Le résultat obtenu est identique pour les deux appels suivants :
# New-RangeIpAddress \"192.168.1.20\" \"192.168.1.30\"
# New-RangeIpAddress \"192.168.1.30\" \"192.168.1.20\"
#
#Adaptation du code suivant :
# technosrix.blogspot.com/2009/05/how-to-g...sses-from-given.html
Param(
[Parameter(Position=1,Mandatory=$true,HelpMessage=\"Adresse IP de début.\"«»)]
[ValidateNotNullOrEmpty()]
[string] $fromIp,
[Parameter(Position=2,Mandatory=$true,HelpMessage=\"Adresse IP de fin.\"«»)]
[ValidateNotNullOrEmpty()]
[string] $toIp)

process {
if ((Compare-IpAddress $fromIp $toIp) -eq 1)
#Swap
{$fromIp,$toIp=$toIp,$fromIp}

[int[]] $fromOct = ([system.net.ipaddress]$fromIp).GetAddressBytes()

[Int[]] $toOct = ([system.net.ipaddress]$toIp).GetAddressBytes()

[string] $a = [string] $b = [string] $c = $null

[int] $startA = $fromOct[0]
[int] $startB = $fromOct[1]
[int] $startC = [int] $startD = 1

[int] $endA = $toOct[0]
[int] $endB = [int] $endC = [int] $endD = 255

for ($intA = $startA; $intA -le $endA; $intA++)
{
$a = $intA

if ($intA -eq $fromOct[0])
{$startB = $fromOct[1]}
else {$startB = 1}

if ($intA -eq $toOct[0])
{$endB = $toOct[1]}
else {$endB = 255}

for ($intB = $startB; $intB -le $endB; $intB++)
{
$b = $intB

if (($intA -eq $fromOct[0]) -and ($intB -eq $fromOct[1]))
{$startC = $fromOct[2]}
else {$startC = 1}
if ( ($intA -eq $toOct[0]) -and ($intB -eq $toOct[1]))
{$endC = $toOct[2] }
else {$endC = 255}

for ($intC = $startC; $intC -le $endC; $intC++)
{
$c = $intC

if (($intA -eq $fromOct[0]) -and ($intB -eq $fromOct[1]) -and ($intC -eq $fromOct[2]))
{$startD = $fromOct[3]}
else {$startD = 1}

if ( ($intA -eq $toOct[0]) -and ($intB -eq $toOct[1]) -and ($intC -eq $toOct[2]))
{$endD = $toOct[3]}
else {$endD =255}

for ($intD = $startD; $intD -le $endD; $intD++)
{
\"{0}.{1}.{2}.{3}\" -F $a,$b,$c,$intD
} #for $intD
}#for $intC
}#for $intB
}#for $intA
}#Process
}#New-RangeIPAddress

Export-ModuleMember -function Compare-IPAddress,
Test-IPAddress,
ConvertTo-IPAddress,
New-RangeIPAddress

<#
www.indented.co.uk/index.php/2010/01/23/powershell-subnet-math/
( code source sur www.poshcode.com/975)

#Tests
New-RangeIpAddress
New-RangeIpAddress $null $null
New-RangeIpAddress \"\" \"\"
New-RangeIpAddress $null \"\"
New-RangeIpAddress \"\" $null
New-RangeIpAddress $null \"192.168.1.20\"
New-RangeIpAddress \"\" \"192.168.1.20\"
New-RangeIpAddress \"192.168.1.20\" $null
New-RangeIpAddress \"192.168.1.20\" \"\"
New-RangeIpAddress \"Test\" \"192.168.1.22\"
New-RangeIpAddress \"192.168.1.22\" \"Test\"
New-RangeIpAddress \"Test\" \"Test\"
New-RangeIpAddress \"0\" \"1\"
New-RangeIpAddress \"...\" \"...\"
New-RangeIpAddress \"A.0.0.0\" \"192.168.1.20\"
New-RangeIpAddress \"256.0.0.0\" \"192.168.1.20\"
New-RangeIpAddress \"192.168.1.20\" \"392.168.1.20\"
New-RangeIpAddress \"192.168.1.20\" \"192.168.1.20\"
New-RangeIpAddress \"192.168.1.21\" \"192.168.1.20\"
New-RangeIpAddress \"192.168.1.20\" \"192.168.1.22\"

Compare-IPAddress \"256.0.0.0\" \"192.168.1.20\"
Compare-IPAddress $null \"192.168.1.20\"
Compare-IPAddress \"...\" \"...\"
Compare-IPAddress \"192.168.1.20\" \"192.168.1.20\"
Compare-IPAddress \"192.168.1.20\" \"192.168.1.21\"
Compare-IPAddress \"192.168.1.21\" \"192.168.1.20\"


Test-IPAddress
Test-IPAddress $null
Test-IPAddress \"...\"
Test-IPAddress \"A.0.0.0\"
Test-IPAddress \"Test\"
Test-IPAddress \"150\"
Test-IPAddress \"192.168.1.257\"
Test-IPAddress \"192.168.1.\"
Test-IPAddress \"192.168.1.20\"


ConvertTo-IPAddress
ConvertTo-IPAddress $null
ConvertTo-IPAddress \"test\"
ConvertTo-IPAddress \"150\"
ConvertTo-IPAddress \"A.0.0.0\"
ConvertTo-IPAddress \"192.168.1.257\"
ConvertTo-IPAddress \"192.168.1.\"
ConvertTo-IPAddress \"192.168.1.20\"


#membres privés
Parse-IpAddress
Parse-IpAddress \"192.168.1.\"
(Parse-IpAddress \"192.168.1.\"«») -eq $null
Parse-IpAddress \"ssdsds\"
Parse-IpAddress \"A.0.0.0\"
Parse-IpAddress \"192.168.1.257\"
Parse-IpAddress 450
Parse-IpAddress 21474504587
Parse-IpAddress 21514504587
Parse-IpAddress \"192.168.1.2\"

Test-DottedQuadNotation
Test-DottedQuadNotation $null
Test-DottedQuadNotation \"fin.\"
Test-DottedQuadNotation \"...\"
Test-DottedQuadNotation \"1.2.3.\"
Test-DottedQuadNotation \"1.2.3.4\"
Test-DottedQuadNotation \"-1.2.3.4\"
Test-DottedQuadNotation \"A.B.C.D\"
#>
[/code:1]
Le lien dans les commentaires, pointe sur une suite des scripts intéressants. Ces derniers acceptent des entiers, a tester donc.<br><br>Message édité par: Laurent Dardenne, à: 14/06/10 19:26