Dreaming in PowerShell : cast

Creating IP Ranges (and other type magic)

Tobias — Sun, 20 Feb 2011 21:20:00 GMT

Recently I needed to create a range of IP addresses. No big deal, you think? Well, if it is just a small segment, then it *is* easy stuff:

1..255 | Foreach-Object { "192.168.2.$_" }

But what if you need larger segments?

Type Conversion Magic

Ok, you could use nested loops. However, there's also a type that represents IP addresses. It is called System.Net.IPAddress, and it can turn a string into an IP address. It even calculates the decimal value (check out property Address), and you can also convert a decimal value back into an IP address:

PS > [System.Net.IPAddress]'192.168.2.1'

Address : 16951488
AddressFamily : InterNetwork
ScopeId :
IsIPv6Multicast : False
IsIPv6LinkLocal : False
IsIPv6SiteLocal : False
IPAddressToString : 192.168.2.1

PS > [System.Net.IPAddress]16951488

Address : 16951488
AddressFamily : InterNetwork
ScopeId :
IsIPv6Multicast : False
IsIPv6LinkLocal : False
IsIPv6SiteLocal : False
IPAddressToString : 192.168.2.1

Now, since IP addresses really are just 32bit numeric values, this conversion is doing an amazing thing when you start thinking about it: it breaks up the decimal into its byte parts. Breaking up a number in its High/Low-part something needed very often, and most of the time people are coding confusing amounts of math into their scripts to do just that.

Breaking Up Decimals in Low-/High-Bytes

So the first thing I want to do is use the System.Net.IPAddress type to break up any decimal into its low/high bytes. I created a pretty small function called ConvertTo-HighLow which you can download here.

function ConvertTo-HighLow($number) {
$v = [System.Version][String]([System.Net.IPAddress]$number)
$o = 1 | Select-Object Low, High, Low32, High32
$o.Low, $o.High, $o.Low32, $o.High32 = $v.Major, $v.Minor, $v.Build, $v.Revision
$o
}

It accepts any unsigned 64bit number and returns its four bytes like this:

PS > ConvertTo-HighLow 255

Low High Low32 High32
--- ---- ----- ------
255 0 0 0

PS > ConvertTo-HighLow 256

Low High Low32 High32
--- ---- ----- ------
0 1 0 0

PS > ConvertTo-HighLow 52176537

Low High Low32 High32
--- ---- ----- ------
153 38 28 3

Here is what I did: I converted the number to an IP address. This did all the complex math by converting the number into four octets. Next, I converted the string IP address into a System.Version type. A version has four numbers, just like an IP address, so now I was able to create a new object (using the Select-Object trick) with the properties I needed and add the byte values to the appropriate properties of my return object - done.

If you just need the low or high byte of a decimal, you could also boil it down to this:

PS > $low = ([System.Net.IPAddress]15672).GetAddressBytes()[0]
PS > $high = ([System.Net.IPAddress]15672).GetAddressBytes()[1]
PS > $low
56
PS > $High
61
PS > $high*256 + $low
15672

Creating IP Address Ranges

Now that this worked perfectly, let's create IP address ranges. Here is the scoop: if every ip address is just a (large) decimal number, then why not convert start and end ip address into such a number and loop through that range? Each number could then be converted back into a valid IP address!

Sounds cool, BUT. IP addresses organize bytes in an unusual way. Turns out that the lowest byte represents the first octet. So if you counted up, you would not get consecutive ip address ranges.

The solution is simple, though. Just reverse the octets before you convert them, create the numeric range, and reverse them back. Here is the function New-IPRange (which you can also download here):

function New-IPRange ($start, $end) {
# created by Dr. Tobias Weltner, MVP PowerShell
$ip1 = ([System.Net.IPAddress]$start).GetAddressBytes()
[Array]::Reverse($ip1)
$ip1 = ([System.Net.IPAddress]($ip1 -join '.')).Address

$ip2 = ([System.Net.IPAddress]$end).GetAddressBytes()
[Array]::Reverse($ip2)
$ip2 = ([System.Net.IPAddress]($ip2 -join '.')).Address

for ($x=$ip1; $x -le $ip2; $x++) {
$ip = ([System.Net.IPAddress]$x).GetAddressBytes()
[Array]::Reverse($ip)
$ip -join '.'
}
}

Now it is really easy to create IP address ranges. Try this:

PS > New-IPRange 192.168.1.12 192.168.3.44
192.168.1.12
192.168.1.13
192.168.1.14
...
192.168.3.43
192.168.3.44

When you look at the code, it really is pretty straight-forward: both start and end address are converted into an ip address, then the four octets are read into an array (GetAddressBytes()). The static Reverse() method can reverse the array content.

Now we have two numbers, the start and the end point. A for loop can loop through that range (you cannot use the ".." trick because the numbers are 64bit values and ".." only deals with Int32). Finally, the numbers are again converted into an ip address and the bytes reversed. Now, -join can put the bytes together and create an ip address.

Wait, there is more!

Using types can be fun, and you can achive a lot of cool results. Now that you can easily create IP address segments, what is the purpose? Of course there is always a purpose. Originally, I wanted not just a tool to create addresses but also check which computers are online in that segment and what their names are.

If you did that with Test-Connection or ping, it could take forever because it would work sequentially. Next time around, I show you how to ping 500 computers at the same time, making analyzing an entire network segment only a matter of seconds.

Hope you had fun, see you next week around...

Tobias

Microsoft MVP PowerShell Germany

P.S.
If you live in Germany or other parts of Europe and your company would like to set up a truly great PowerShell training, just contact me! I regularly train mid- to large-size companies. Trainings are always a blast with tons of real-world-examples and solutions. Here's how to get in touch with me: tobias.weltner@scriptinternals.de

Casting Data and Creating Validators

Tobias Weltner — Sat, 22 Nov 2008 21:30:00 GMT

Casting data from one type into another type has a lot of uses. One is data validation. Let's take a look at how that works.

Casting Data: What's that anyway?

Whenever you store information, PowerShell automatically picks the right "container type" for you.

So when you assign text to a variable, the variable will internally use the System.String type. When you assign a whole number, it picks System.Int32. Every .NET object supports the GetType() method which tells you the type PowerShell picked for you:

PS> $a = "Hello"
PS> $a.GetType().FullName
System.String
PS> $a = 100
PS> $a.GetType().FullName
System.Int32

You can override the automatic type selection and convert data into any type you want which is sometimes called "casting".

Why would you do that? There are hundreds of types, and some of them are highly specialized to deal with certain data such as types for XML, DateTimes or IPAddresses. PowerShell always selects a basic or "primitive" type like Integer or String.

To get access to more specialized data, override the internal type selection and choose the best type manually.

How Do I Cast Data?

There are two ways to convert data from one type to another. The first one takes the new target type and puts it in square brackets.

The following line takes a string and converts it into a specialized DateTime. DateTime gives you all kinds of specialized methods to deal with dates so you now can easily add time intervals:

$raw = '1.1.2000'
$raw.GetType().FullName
$raw

$date = [DateTime] $raw
$date.GetType().FullName
$date
$date.AddDays(10)
$date.AddDays(-10)

This simple casting approach will fail if the raw data cannot be converted to the specified target type so you generally need an error handler to catch exceptions if you cannot make sure the raw data meets the requirements.

So for example, if you accept user input, you generally never know what the user enters. If the user enters invalid data that cannot be converted to the target type, you want to make sure the exception is caught.

Here is a simple script. It asks for your birthday and calculates your age in days. If you enter something that cannot be converted to a DateTime, the script handles the error using Trap and outputs an error message:

trap { 'Your input was invalid!'; continue }

& {
 $date = Read-Host "Enter your birthday"
 $difference = (New-TimeSpan $date).totalDays
 'You are {0:0} days old' -f $difference
}

There is a second approach to cast data which is widely unknown: the -as operator.

This operator tries to cast the data to the new type, and if that won't work, it does not raise an exception. Instead, it simply returns $null.

With this approach, you can simplify your script because you no longer need an error handler:

$date = Read-Host "Enter your birthday"
if ($date -as [DateTime]) {
  $difference = (New-TimeSpan $date).totalDays
  'You are {0:0} days old' -f $difference
} else {
  'Your input was invalid.'
}

Creating Custom Validators

When you look at the previous example, you can see that type casting is a great way of automatically validating data. All you need to do is try to cast to the desired target type. If it works, the validation was successful. If it fails, the data was in the wrong format. As long as you find a type that represents a certain date format, you can delegate validation entirely to the type conversion process.

For example, to write a little function that checks for valid date input, try this:

function isDate($object) {
  [Boolean]($object -as [DateTime])
}

isDate('1.1.2000')
isDate('hehehe')
isDate('September 12, 2008')

Likewise, if you'd like to check for a valid IP address, don't waste your time writing own validation code or figuring out tricky regular expressions. Instead, use the System.Net.IPAddress like so:

function isIPAddress($object) {
  [Boolean]($object -as [System.Net.IPAddress])
}

isIPAddress('10.10.10.10')
isIPAddress('500.10.10.10')
isIPAddress('2001:0:d5c7:a2ca:184a:7bd:a865:5fb4')

As you can see, your validator also accepts V6 IP addresses which is pretty cool. Your own regular expression validator would have had a hard time figuring that out.

With your new validator function, you can easily check user input and make sure only the desired data is entered:

function isIPAddress($object) {
  [Boolean]($object -as [System.Net.IPAddress])
}

$prompt = 'Enter IP Address'
do {
  $ip = Read-Host $prompt
  $prompt = 'Invalid input. Try again and enter IP Address'
} while (-not (isIPAddress($ip)))

"You entered this IP address: $ip"

As Alexander and Shay pointed out to me, validators are only as good as the underlying .NET type converter. As it turns out, .NET is quite liberal and even happily accepts a single number which it turns into a (correct) IP-Address:

[system.Net.IPAddress]'1'

So in real life, you may want to look how liberal .NET conversion is, and if it is too liberal, add a simple manual check like this:

$ip -like '*.*.*.*'

Or, you look at the conversion result and check to make sure it is identical to the user input. If it is not, you know that the conversion mechanism was too liberal:

function isIPAddress($object) { 
	($object -as [System.Net.IPAddress]).IPAddressToString -eq $object
}

Call for Action

If you happen to know other interesting .NET types for certain data formats, please add a comment. You have seen how you can use the -as operator in conjunction with any .NET type to validate raw data and make sure it is convertible into that type. Check out PowerShellPlus to discover types and get rich code completion!

See ya soon,

-Tobias