Since last working the script, I’d like to think I’ve learned more and it was about to time clean up the code and make it a little more user friendly. It still relies on the original ImageProcessor.dll, but this time, I moved the files around so you just need to unzip the archive and changing your background. If you’re as paranoid as I am, the source for ImageProcessor.dll is still included, as well as the build.bat file.

Download win7logonui now!

So I did what any sensible geek does, I hacked something together.

This is just the proof of concept, and I do hope to someday have it more self contained. At the moment it relies on WinPcap and SharpPcap, which makes it quite large and cumbersome to deploy.

So far, there are two parts, inarp.exe and inarpd.exe. Inarp.exe gets the IP associated with the specified MAC, while inarpd.exe intercepts InARP packets and sends the appropriate replies.

Basic use:

//remote machine
inarpd.exe

//your machine
inarp "ma-ca-dd-re-ss-s0" //sends queries on all network interfaces
inarp "ma-ca-dd-re-ss-s0" "Network interface GUID" //Sends on a specific interface
No interface specified or matched criteria.
[ARPPacket: 8 AAAAAAAAAAAA -> BBBBBBBBBBBB, 0.0.0.0 -> 0.0.0.0] //InARP Request
[ARPPacket: 9 BBBBBBBBBBBB -> AAAAAAAAAAAA, 192.168.1.101 -> 0.0.0.0] //InARP Reply

inarp code and binaries.

All examples are in Powershell, however they could be translated to C#, any .NET language or even some other language quite easily.

Examples

Including System.net. This may not be necessary, but I’ve mucked with my Powershell settings way too much to know about a vanilla install.

#Powershell v1.0
[reflection.assembly]::LoadWithPartialName("system.net");
#Powershell v2.0
Add-Type -AssemblyName System.Net;

A common plight for me is finding out if two different IP addresses are on the same local network.

$router = [net.ipaddress]::Parse("192.168.1.254");
$subnet = [net.ipaddress]::Parse("255.255.255.0");
$IP_one = [net.ipaddress]::Parse("192.168.1.23");
$IP_two = [net.ipaddress]::Parse("192.168.1.55");
$IP_three = [net.ipaddress]::Parse("33.21.9.1");

#get the network ID
#in this case it's 192.168.1.0
$network = $router.address -band $subnet.Address

($network -band $IP_one.Address) -eq $network #True
($network -band $IP_two.Address) -eq $network #True
($network -band $IP_three.Address) -eq $network #False

Of course there are also times where I need to know how many addresses there are in the network or what they are.

$seed = [net.ipaddress]::Parse("192.168.23.45");
$subnet = [net.ipaddress]::Parse("255.255.252.0");

$begin = ($seed.address -band $subnet.address)
$end = (([net.ipaddress]::Broadcast.Address -bxor $subnet.Address) -bor $seed.address)

#It's the same for both start and ending IP's
#We convert from a 64 to 32 bit integer (8 to 4 bytes) and then reverse it so we can do addition/subtraction math to later on.
$start_bytes = new-object byte[] 4;
[array]::copy([bitconverter]::getBytes(($seed.address -band $subnet.address)), $start_bytes, 4);
[array]::Reverse($start_bytes);
$start_int = [bitconverter]::ToInt32($start_bytes,0);

$end_bytes = new-object byte[] 4;
[array]::copy([bitconverter]::getBytes((([net.ipaddress]::Broadcast.Address -bxor $subnet.Address) -bor $seed.address)), $end_bytes, 4);
[array]::Reverse($end_bytes);
$end_int = [bitconverter]::ToInt32($end_bytes,0);

#Entire range including the network ID and Broadcast addresses
[math]::Abs($start_int - $end_int) + 1

#Just the number of usable addresses
[math]::Abs($start_int - $end_int) - 1

#Address list!
for($i=0; $i -le [math]::abs($start_int - $end_int); $i++) {
    $tba = [bitconverter]::getbytes($i + $start_int);
	[array]::Reverse($tba)
    (new-object net.ipaddress ([bitconverter]::ToInt64($tba + [byte[]]@(0,0,0,0),0))).tostring();
}

Conclusion

As you can see, using bitwise operations greatly reduces the complexity required to calculate network addresses. By simplifying the process, it makes it much easier to maintain the code and build on it later!

It would seem everyone out there is happy with just merging their VHDs and getting back to work, but not me, no sir! I want things back the way they were! It took me about half a day to get this, so hopefully, this will save you some time for more important things, like tetris!

Steps

1. Create same number of pre-existing snapshots using the Hyper-V MMC.
2. Replace new snapshots with old snapshots while renaming the old to the same as the new, except the file extension should be “vhd” instead of “avhd”. The reason we’ll see later, but the Hyper-V tool to repair VHD chains auto-appends .vhd! (Grr Hyper-V Team, grr!)
3. Repair the vhd’s. Because of our renaming we’ve broken the differencing chain. To fix this, go to open Hyper-V, go to the VM’s Settings and then the hard drive. Change the VHD to the new one (simply changing the extension should work) and click “inspect disk”. This will walk you through fixing the chain.
4. Modify the ACL to include the VM specific account. This you must to in Powershell since the Explorer GUI can’t seem to find the account. I don’t know why and there may be a way, but I’m to lazy to dig into it and this works. (Below you can find some sample code.) The account to add from the old VHD, is the one that starts with “NT VIRTUAL MACHINE” and ends with a GUID.

   ##START POWERSHELL CODE
   #get the old vhd's permissions
   $vm_perm = (get-acl .\old.vhd).access | where { $_.IdentityReference.tostring().contains("NT VIRTUAL MACHINE") }
   
   #Load the new vhd's acl into memory
   $newvhd = get-acl .\new.vhd
   
   $newvhd.AddAccessRule($vm_perm)
   
   $newvhd | set-acl .\new.vhd
   ##END POWERSHELL CODE

5. Open all the VM’s XML setting files and make sure that any settings related the the VHD’s is correct. This should only be the filename. If you need to edit these files be sure to turn off the Hyper-V Management Service, this will not affect the VM’s running, only the managing of them. The XML files can be found wherever you made the VM.
6. You should now have a restored VM with the snapshot tree! Woo! Go you!

Download the source and binaries here. You should be able to open the solution with both Visual Studio or Visual C# Express, but if you have neither, you can build it from the command line (instructions included!). I don’t know if it’ll work with PowerShell V1, but you should have upgraded by now anyway.

I’d like to thank Mr. Cook from Cook Computing for writing an awesome tool, XML-RPC.NET. And I’d also like to thank Orbifold for their Wordpress XML-RPC library which helped decipher the RPC calls.

Test post.

However, unlike with Powershell where you can just set a variable, you gotta put more effort with C# to do something similar, especially when there’s so little documentation and I know so little about nitty gritty COM programming.

So getting the WUApi working in C# things to know.

1. You need to reference “c:\windows\system32\wuapi.dll”
2. You must have have the resulting “Interop.WUApi.DLL” in the same directory as you executable. (I haven’t figured out a way past this yet.)
3. WUApi likes to die and quickly if there is the slightest error, and under C# these errors seem to be harder to pick up on.
4. Some updates don’t like to report back how far they are in their process. IE8 for example sits at 0% until its done, so you just have to wait and wait some more.

The following code you can pretty much copy and paste into a cs file add the necessary hooks into the blank C# project, compile and it should work. It’s very Alpha and there is little error checking since I haven’t taken the time to throw test cases its way. It should also work on any OS from XP to 7.

namespace winupdate_scheduler
{
    /// <remarks>Methods actual shutdown.</remarks>
    public class grunt
    {
        public void shutdown()
        {
            throw new System.NotImplementedException();
        }

        public void restart()
        {
            throw new System.NotImplementedException();
        }

        /// <summary>
        /// Initiate the update for great justice!
        /// </summary>
        public void update()
        {
            try
            {
                //Initate the session and begin the search!
                WUApiLib.UpdateSessionClass session = new WUApiLib.UpdateSessionClass();
                WUApiLib.IUpdateSearcher searcher = session.CreateUpdateSearcher();
                WUApiLib.ISearchResult result = searcher.Search("IsInstalled=0 and IsAssigned=1");

                //Initate the interfaces for progress and wholeness.
                InstallProgress progress = new InstallProgress();
                InstallComplete completion = new InstallComplete();

                //Dummy object for installer.BeginInstall
                object t3 = (new object());

                //Do we have anything to do?
                if (result.Updates.Count > 0)
                {
                    //Begin the long wait.
                    //Probably should look into doing that async thing here too....later.
                    Console.WriteLine("Downloading...");
                    WUApiLib.IUpdateDownloader download = session.CreateUpdateDownloader();
                    download.Updates = result.Updates;
                    download.Download();

                    //Finally, get around to installing the suckers!
                    Console.WriteLine("Installing...");
                    WUApiLib.IUpdateInstaller installer = session.CreateUpdateInstaller();
                    installer.Updates = download.Updates;
                    installer.BeginInstall(progress, completion, t3);

                    //Hold your horses! We're not done yet!
                    while (!completion.jobdone)
                    {
                        System.Threading.Thread.Sleep(2000);
                    }
                }

                //Now you can let go of your horses!
                Console.WriteLine("Done");
            }
                //Until I can get a grasp of all the exceptions that can be raised, this will have to do.
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

        /// <summary>
        /// Get list of updates
        /// </summary>
        public void getupdates()
        {
            throw new System.NotImplementedException();
            WUApiLib.UpdateSessionClass session = new WUApiLib.UpdateSessionClass();
            WUApiLib.IUpdateSearcher searcher = session.CreateUpdateSearcher();
            WUApiLib.ISearchResult result = searcher.Search("IsInstalled=0 and IsAssigned=1");
        }
    }

    class InstallProgress : WUApiLib.IInstallationProgressChangedCallback
    {

        public void Invoke(WUApiLib.IInstallationJob job, WUApiLib.IInstallationProgressChangedCallbackArgs args)
        {
            this.job = job;
            this.OverallProgress = this.job.GetProgress().PercentComplete;
            this.UpdateProgress = this.job.GetProgress().CurrentUpdatePercentComplete;
            this.UpdateIndex = this.job.GetProgress().CurrentUpdateIndex;

            this.Update = this.job.Updates[this.UpdateIndex];

            string str = "Update: {0}, UpdateProgress: {1}%, Progress {2}%";
            Console.WriteLine(string.Format(str, (this.UpdateIndex + 1), this.UpdateProgress, this.OverallProgress));
        }

        public WUApiLib.IInstallationJob job;

        public int OverallProgress = 0;
        public int UpdateProgress = 0;
        public int UpdateIndex = 0;
        public WUApiLib.IUpdate Update;

    }

    class InstallComplete : WUApiLib.IInstallationCompletedCallback
    {
        public void Invoke(WUApiLib.IInstallationJob job, WUApiLib.IInstallationCompletedCallbackArgs args)
        {
            //string str = "job.IsCompleted: {0}, args.Progress: {1}% completed";
            //Console.WriteLine(string.Format(str, job.IsCompleted, job.GetProgress().PercentComplete));
            this.jobdone = job.IsCompleted;
        }
        public bool jobdone = false;
    }
}

More reading:

• Windows Update Agent (WUA) API Reference
  • Interfaces
• C# Interfaces
• Finding applicable Windows Updates via cli

<#
.SYNOPSIS
Ping a node as fast as you can.
.DESCRIPTION
Whereas the ping.exe utility keeps steady at 1 ping per second,
this will ping with custom wait periods as low as 0 milliseconds.
.Parameter ip
IP or hostname of network node.
.Parameter count
Number of pings to execute (defaults to 4)
.Parameter wait
Time to wait for a reply.
.Parameter sleep
Time to wait between pings.
.Parameter size
Number of bytes to send (all Null or 0).
.Parameter ttl
Time to live.
.INPUTS
None. You cannot pipe objects to fastping.
.OUTPUTS
Reply from {host}: status={status bytes={bytes} time={tripTime}
(xxx% loss)
.Example
    PS> fastping.ps1 -ip josherickson.org -size 1337 -wait 1
	Reply from josherickson.org: status=Success bytes=1337 time=81
	Reply from josherickson.org: status=Success bytes=1337 time=96
	Reply from josherickson.org: status=Success bytes=1337 time=81
	Reply from josherickson.org: status=TimedOut bytes=1337 time=0
	(25% loss)
.LINK
Original: http://josherickson.org/2009/09/24/586/ping-faster-from-powershell-with-fastping
.Notes
TODO: Add object based return instead of just text strings.
NAME:      verb
AUTHOR:    josherickson.org\josh
LASTEDIT:  09/25/2009
#>
param (
	[string]$ip = "127.0.0.1",
	[int]$count = 4,
	[int]$wait = 5,
	[int]$sleep = 0,
	[int]$size = 32,
	[int]$ttl = 128
)

$ping = new-object System.Net.NetworkInformation.ping
$pingo = new-object System.Net.NetworkInformation.PingOptions $ttl, $false

if($size -gt 65500) {
	throw "`$size must be equal to or less than 65500";
}

$bsize = new-object byte[] $size;

$s = 0;
$f = 0;
for($i = 0; $i -lt $count; $i++) {
	$pr = $ping.Send($ip, $wait, $bsize, $pingo)
	$s += [int][bool]($pr.status -eq "Success");
	$f += [int][bool]($pr.status -ne "Success");

	"Reply from $($ip): status=$($pr.status) bytes=$size time=$($pr.RoundtripTime)" | write-host

	sleep -Milliseconds $sleep;
}

if($f -gt 0) {
	"(" + ((100/$count)*$f) + "% loss)";
} else {
	"(0% loss)";
}
return;

<#
.Synopsis
    Ping a node as fast as you can.
.Description
    Whereas the ping.exe utility keeps steady at 1 ping per second,
	this will ping with custom wait periods as low as 0 milliseconds.
.Parameter ip
	IP or hostname of network node.
.Parameter count
	Number of pings to execute (defaults to 4)
.Parameter wait
	Time to wait for a reply.
.Parameter sleep
	Time to wait between pings.
.Parameter size
	Number of bytes to send (all Null or 0).
.Parameter ttl
	Time to live.
.Example
    PS> fastping.ps1 -ip josherickson.org -size 1337 -wait 1
	Reply from josherickson.org: status=Success bytes=1337 time=81
	Reply from josherickson.org: status=Success bytes=1337 time=96
	Reply from josherickson.org: status=Success bytes=1337 time=81
	Reply from josherickson.org: status=TimedOut bytes=1337 time=0
	(25% loss)

.ReturnValue
    [string]

.Link
.Notes
	TODO: Add object based return instead of just text strings.
NAME:      verb
AUTHOR:    josherickson.org\josh
LASTEDIT:  09/24/2009
#Requires -Version 2.0
#>
param (
	[string]$ip = "127.0.0.1",
	[int]$count = 4,
	[int]$wait = 5,
	[int]$sleep = 0,
	[int]$size = 32,
	[int]$ttl = 128
)

$ping = new-object System.Net.NetworkInformation.ping
$pingo = new-object System.Net.NetworkInformation.PingOptions $ttl, $false

if($size -gt 65500) {
	throw "`$size must be equal to or less than 65500";
}

$bsize = new-object byte[] $size;

$s = 0;
$f = 0;
for($i = 0; $i -lt $count; $i++) {
	$pr = $ping.Send($ip, $wait, $bsize, $pingo)
	$s += [int][bool]($pr.status -eq "Success");
	$f += [int][bool]($pr.status -ne "Success");

	"Reply from $($ip): status=$($pr.status) bytes=$size time=$($pr.RoundtripTime)"

	sleep -Milliseconds $sleep;
}

if($f -gt 0) {
	"(" + ((100/$count)*$f) + "% loss)";
} else {
	"(0% loss)";
}

Note that the time it takes to ping a place reflects the round trip time, which is how long it takes to get the entire reply, that is why you can see times greater than the specified wait time.

So now, we’re working on a set of tools that can initiate Windows Updates, check if other servers are up or down, and then restart accordingly. Thus far, I’ve just finished this script, the rest of the tool will likely be done with C# and set as a service on each machine. With this script, you can check the updates for other machines from the comfort of your desktop/laptop and send it off to a text file for later viewing. You can even initiate the update process! Albeit, only on the machine you’re running on due to constraints of the Microsoft.Update.Session COM.

param (
	$computer = $env:computername,
	[switch]$searchOnly
)
[Reflection.Assembly]::LoadFrom("C:\WINDOWS\Microsoft.NET\Framework64\v2.0.50727\Microsoft.VisualBasic.dll") | out-null;

#Create an update session
#Using the vb createObject method, we are able to connect to remote machines to view
#it's update list
$updateSession = [microsoft.visualbasic.interaction]::CreateObject("Microsoft.Update.Session", $computer);

"Finding updates on $($computer)"
$updateSearch = $updateSession.CreateUpdateSearcher()
#Here we're only wanting to know what it needs and what it has been assigned.
#IsAssigned should really only apply to networks that utilize WSUS.

$results = $updateSearch.Search('IsInstalled=0 and IsAssigned=1')

if($searchOnly.IsPresent -or $computer -ne $env:computername) {
	$results.Updates
} else {
	"Downloading updates"
	$updateDownload = $updateSession.CreateUpdateDownloader()
	$updateDownload.Updates =$results.Updates
	$updateDownload.Download()

	"Installing updates"
	$installer = $updateSession.CreateUpdateInstaller()
	$installer.Updates = $updateDownload.Updates
	$installer.install()
}

To learn more check out the MSDN pages on the Microsoft.SqlServer.Management.Smo namespace.

#
#	Temp database backup
#
$d = date;

#filename: db_full_MM-DD-YYYY-HH.bak
$backupfile = "db_full_" + ($d.ToShortDateString().replace("/","-")) + "-" + ($d.hour) + "h.bak";

#should you use drive paths (ie c:\) it will save to the SQL server's drive.
$backuppath = "\\path\to\save\location\doesnt\need\to\be\unc\";

[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo");
[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.SmoExtended");
$ser = New-Object "Microsoft.SqlServer.Management.Smo.Server" "server\instance";
$backup = New-Object Microsoft.SqlServer.Management.Smo.Backup
$bdevice = New-Object microsoft.sqlserver.management.smo.backupdeviceitem -ArgumentList ($backuppath + $backupfile), "File"

$backup.Action = [Microsoft.SqlServer.Management.Smo.BackupActionType]::Database
$backup.BackupSetName = "Daily Full Database";
$backup.Database = "DatabaseName"

$backup.Initialize = $True
$backup.Checksum = $True
$backup.ContinueAfterError = $true
$backup.Devices.Add($bdevice)
$backup.Incremental = $false
$backup.CopyOnly = $true
$backup.LogTruncation ="NoTruncate" #meant for bandaid approach and for less "impact" on database.
$backup.FormatMedia = $false
$backup.SqlBackup($ser); #save it.