So you can imagine how annoyed I was to come into work twice this week to the blue Windows logon screen. Every time this happens it takes me twenty minutes to figure out what I was doing the day before, what I have to do today, and where I stopped with my work. And really what made this so much more painful was that it happened without any advanced warning.

And that’s what got me thinking: could I block restart requests? I researched the Windows shut down process online and then went to work on a prototype. From what I read, calling ExitWindowsEx sends WM_QUERYENDSESSION to all top-level windows. Applications that are not ready to shut down should return false. I figured the best strategy was to install a system-wide hook and filter the message.

Initially I attempted to capture WM_QUERYENDSESSION with the WH_GETMESSAGE hook and replace it with WM_NULL, but trial-and-error revealed that it’s sent through SendMessage and not posted to the window’s queue. This meant that I couldn’t filter out the message.

I switched to WH_CALLWNDPROC and was able to capture the message, but not actually modify it. Since my DLL is memory-mapped into the local process space, it seemed like the only way to filter the message was to create a new WindowProc function that handles WM_QUERYENDSESSION and always returns false. Then inside the hook procedure, I could intercept the message and call SetWindowLong to replace the window’s message procedure.

This demonstrates the basic concept:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

LRESULT CALLBACK CallWndProc( int nCode, WPARAM wParam, LPARAM lParam )
{
  if( nCode == HC_ACTION ) {
      CWPSTRUCT *msg = (CWPSTRUCT*)lParam;
 
      /* hijack the window proc when we see a shut down message */
      if( msg->message == WM_QUERYENDSESSION )
          oldwndproc = SetWindowLong(msg->hwnd, GWL_WNDPROC, (DWORD)WindowProc);
  }
 
  return CallNextHookEx(g_callwndhk, nCode, wParam, lParam);
}
 
LRESULT CALLBACK WindowProc( HWND hWnd, UINT uiMessage, 
        WPARAM wParam, LPARAM lParam )
{
  /* intercept shut down messages */
  if( uiMessage == WM_QUERYENDSESSION )
      return 0;
 
  return DefWindowProc(hWnd, uiMessage, wParam, lParam);
}

When my little application starts, it calls SetProcessShutdownParameters with level 0×4FF to increase the chances of trapping the message first. I figured this was a good idea since I know its WindowProc function can be safely hijacked. Now when Windows sends WM_QUERYENDSESSION the response is always “NO!”. The added exclamation there is a call to AbortSystemShutdown, which is probably unnecessary but I do it just to be safe. Also, I added an alert message box to warn me when a reboot is triggered.

I’m sort of amazed this actually worked. Some day I’ll test it against InitiateSystemShutdown and ExitWindowsEx with EWX_FORCE to see how it holds up. Interestingly, Windows Vista/7 provides ShutdownBlockReasonCreate for seemingly outright blocking shut down attempts.

You can obtain the sources to this project here.

I use Spark on my workstation to connect to the company’s internal IM server. The application works alright, but the contacts window always appears in the taskbar. So I started to think about ways I could programmatically solve my problem.

I could set the WS_EX_TOOLWINDOW style on the window, but that would alter the window’s appearance. What I really wanted was a way to tell Windows to remove the tab. A quick search on Google turned up the answer: use COM to create an instance of ITaskbarList. The interface has the function ITaskbarList::DeleteTab() which takes a window handle. Perfect!

Now I just needed to get the window’s handle. FindWindow() would have worked, but that meant hard-coding my username into the program. I felt a more elegant solution was to enumerate all of the windows, and look for the one with the right class and title prefix.

Since the tab would reappear every time I brought the contact list window to the foreground, I ended up wrapping my fix with a loop and a timer. Here’s the finished product:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

/* NoSpark.cpp - Hides the Spark contacts window tab in the taskbar */
 
#include <windows.h>
#include <Shobjidl.h>
 
BOOL CALLBACK EnumWindowsProc(HWND, LPARAM);
 
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow )
{
	HANDLE htmr = CreateWaitableTimer(NULL, TRUE, L"CheckSpark");
	LARGE_INTEGER lidt;
	ITaskbarList* ptl;
 
	__int64 qwdt = -60 * 10000000; // 1 minute
	lidt.LowPart = (DWORD) (qwdt & 0xFFFFFFFF);
	lidt.HighPart = (LONG) (qwdt >> 32);
 
	while( TRUE ) {
		SetWaitableTimer(htmr, &lidt, 0, NULL, NULL, FALSE);
		WaitForSingleObject(htmr, INFINITE);
 
		HWND hsparkwnd = 0;
		EnumWindows(&EnumWindowsProc, (LPARAM) &hsparkwnd);
		if( hsparkwnd == 0 ) continue;
 
		CoInitialize(NULL);
		HRESULT ret = CoCreateInstance(
			CLSID_TaskbarList, 
			NULL, 
			CLSCTX_SERVER, 
			IID_ITaskbarList, 
			(LPVOID*) &ptl
		);
 
		if( ret == S_OK )
			ptl->DeleteTab(hsparkwnd);
 
		ptl->Release();
		CoUninitialize();
	}
 
	return 0;
}
 
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
	int tmpsz = 16;
	LPWSTR lptmp = (LPWSTR) malloc(sizeof(WCHAR) * tmpsz);
 
	RtlZeroMemory(lptmp, tmpsz);
	GetClassName(hwnd, lptmp, tmpsz);
 
	if( wcscmp(lptmp, L"SunAwtFrame") != 0 ) {
		free(lptmp);
		return TRUE;
	}
 
	RtlZeroMemory(lptmp, tmpsz);
	GetWindowText(hwnd, lptmp, tmpsz);
 
	if( wcscmp(lptmp, L"Spark -") > 0 ) {
		*((HWND*) lParam) = hwnd;
		free(lptmp);
		return FALSE;
	}
 
	free(lptmp);
	return TRUE;
}

To compile this program, create a new, empty Visual C++ project. Create a new cpp file and drop the code above inside. If you get compile errors about converting wchar_t* to const char* then change your character set from Multibyte to Unicode in the project properties.

Now you might be wondering why I don’t just change the screensaver time-out or turn off the requirement for a password. Well even though I’m a local administrator, there is a domain-wide GPO that prevents me from doing so. (Yes I know I can edit the registry, but that setting doesn’t survive a GP refresh.) I understand the reason for the policy, but five minutes seems a bit too short.

I wanted to fix this problem AND keep my job at the same time. Alice’s “dipping duck” inspired me to write a simple program to simulate mouse movement.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <windows.h>
 
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow )
{
    HANDLE htmr = CreateWaitableTimer(NULL, TRUE, L"CheckIdle");
    LARGE_INTEGER lidt;
    LASTINPUTINFO lii;
 
    __int64 qwdt = -30 * 10000000; // 30 seconds
    lidt.LowPart = (DWORD) (qwdt & 0xFFFFFFFF);
    lidt.HighPart = (LONG) (qwdt >> 32);
 
    while( TRUE ) {
        SetWaitableTimer(htmr, &lidt, 0, NULL, NULL, FALSE);
        WaitForSingleObject(htmr, INFINITE);
 
        RtlZeroMemory(&lii, sizeof(LASTINPUTINFO));
        lii.cbSize = sizeof(LASTINPUTINFO);
        BOOL ret = GetLastInputInfo(&lii);
 
        int threshold = 3 * 60; // 3 minutes
        int idletime = ret ? (GetTickCount() - lii.dwTime) / 1000 : 0;
 
        BOOL scrnsvr = FALSE;
        SystemParametersInfo(SPI_GETSCREENSAVERRUNNING, 0, &scrnsvr, 0);
 
        if( idletime > threshold && !scrnsvr ) {
            MOUSEINPUT mi;
            RtlZeroMemory(&mi, sizeof(MOUSEINPUT));
            mi.dwFlags = MOUSEEVENTF_MOVE;
            mi.dx = 1;
            mi.dy = 1;
 
            INPUT in;
            in.type = INPUT_MOUSE;
            in.mi = mi;
 
            SendInput(1, &in, sizeof(in));
        }
    }
 
    return 0;
}

Every thirty seconds the program checks to see if the computer is idle. After three minutes of inactivity (and if the screensaver isn’t running), it moves the mouse cursor one pixel down and to the right. If I lock the workstation or manually activate the screensaver, the program won’t do anything. To compile this program, create a new empty C++ Win32 application project. Add a new cpp file, drop in the code above, and hit “Build Solution”.

Now the screensaver won’t be a nuisance when I’m trying to read. I just have to make sure to hit Win-L before I leave my desk!

I had originally implemented the ListView using a control style to eliminate the annoying flicker every time the list was repainted. Once I started custom drawing the control, I saw odd artifacts in the ListView’s client area when I scrolled or moved the mouse. If I turned off double buffering, it worked fine.

I studied the custom draw process looking for my mistake, but I couldn’t find any. I even used the .NET Reflector to look at Microsoft’s implementation. The message I’m filtering has a handle to the control’s back-buffer. So it seemed like I should just be able to draw directly into that. But no matter what I did, it produced the same artifacts.

After about three days of banging my head, I managed to make it work by drawing into my own buffer and then using BitBlt() to copy my image to the control’s buffer. I also had to set the double buffer style with a window message rather than using the built-in property, although admittedly, I’m not sure why.

I like visual aids, so here’s a code snippet from my project. I changed names and removed a bunch of unnecessary lines for easier reading.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#include "stdafx.h"
#include "MyListViewControl.h"
 
using namespace MyListViewControl;
using namespace System::Drawing;
using namespace System::Windows::Forms;
 
MyListViewControl::MyListViewControl() { }
 
bool MyListViewControl::CustomDraw( Message% m )
{
	System::Drawing::Rectangle^ mprc;
	System::String^ cchQueueIndex;
	ListViewItem^ mpItem;
	LPNMCUSTOMDRAW lpnmcd;
	Graphics^ mpgfx;
	HDC hmemdc;
	RECT sOrderRect;
	RECT sStopRect;
	Brush^ mpbgbr;
	Brush^ mpfgbr;
	int nOrderLen;
	int nOrderOffset;
	int nRightEdge;
	int nRectWidth;
	int nItem;
 
	// Grab the custom draw info
	lpnmcd = (LPNMCUSTOMDRAW) m.LParam.ToPointer();
 
	// Figure out which drawing stage we're in
	switch( lpnmcd->dwDrawStage )
	{	
 
	// Control Pre-paint
	case( CDDS_PREPAINT ):
 
		// Request to be notified during item draw
		__super::WndProc( m );
		m.Result = (System::IntPtr) CDRF_NOTIFYITEMDRAW;
		return true;
 
 
	// List Item Pre-paint
	case( CDDS_ITEMPREPAINT ):
 
		// Request to be notified after item draw
		__super::WndProc( m );
		m.Result = (System::IntPtr) CDRF_NOTIFYPOSTPAINT;
		return true;
 
 
	// List Item Post-paint
	case( CDDS_ITEMPOSTPAINT ):
 
		__super::WndProc( m );
 
		// Get the current item
		nItem = static_cast<int>( lpnmcd->dwItemSpec );
		mpItem = (ListViewItem^) this->Items[nItem];		
 
		// Get the device context and item bounds
		mpgfx = this->CreateGraphics();
		mprc = this->GetItemRect( nItem, ItemBoundsPortion::Label );
 
		// *** Your custom drawing code here ***
 
		// Copy the bubble to the screen DC
		hmemdc = reinterpret_cast<HDC>( static_cast<void*>(mpgfx->GetHdc()) );
		BitBlt( 
			lpnmcd->hdc, 
			sOrderRect.left, 
			mprc->Y, 
			nRectWidth, 
			mprc->Height, 
			hmemdc, 
			sOrderRect.left, 
			mprc->Y, 
			SRCCOPY );
		mpgfx->ReleaseHdc( (System::IntPtr) hmemdc );
 
		// Let Windows redraw the border
		m.Result = (System::IntPtr) CDRF_DODEFAULT;
		return true;
	}
 
	return false;
}
 
void MyListViewControl::WndProc( Message% m )
{
	LPNMHDR lpnmhdr;
 
	switch( m.Msg )
	{
 
	// Reflected Notifications
	case( OCM_NOTIFY ):
 
		// Get the notification
		lpnmhdr = (LPNMHDR) m.LParam.ToPointer();
		if( lpnmhdr == NULL ) break;
 
		// We want custom draw messages
		if( lpnmhdr->code == NM_CUSTOMDRAW  
			&& lpnmhdr->hwndFrom == this->Handle.ToPointer() )
		{
			if( this->CustomDraw(m) ) return;
		}
 
		break;
 
	}
 
	__super::WndProc( m );
}

And here’s the header file with the double buffering message call:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#pragma once
 
namespace MyListView
{
	public ref class MyListView : 
		public System::Windows::Forms::ListView
	{
 
	private:
		bool CustomDraw( System::Windows::Forms::Message% m );
 
	public:
		virtual property bool DoubleBuffered
		{
			bool get() override
			{
				LRESULT lStyles = ::SendMessage( 
					(HWND) this->Handle.ToPointer(), 
					LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0 );
				return (lStyles & LVS_EX_DOUBLEBUFFER) != 0;
			}
 
			void set( bool fValue ) override
			{
				// I tried using the DoubleBuffered property, but I
				// get artifacts. So, let's do this the MFC way...
				::SendMessage( 
					(HWND) this->Handle.ToPointer(), 
					LVM_SETEXTENDEDLISTVIEWSTYLE, 
					LVS_EX_DOUBLEBUFFER, 
					LVS_EX_DOUBLEBUFFER );
			}
		}
 
	protected:
		virtual void WndProc( System::Windows::Forms::Message% m ) override;
 
	public:
		MyListViewControl();
 
	};
}

I spend days searching online and couldn’t find anyone who talked about custom drawing a .NET ListView with double buffering. I hope somebody will find this useful.

I came home from work Monday to find that my computer had restarted after seventy-two days uptime. I had been in the middle of a project the night before so I already wasn’t happy when I sat down. I tried to launch the Event Viewer to see what had caused the reboot, but got this error:

“Windows cannot access the specified device, path, or file. You may not have appropriate permissions to access the item.”

I downloaded the NT Offline Password Cracker and unlocked the local administrator account. This let me at least login with admin privileges. I tried again to launch the Event Viewer, but this time it silently failed. Strangely, starting the Microsoft Management Console and then adding the Event Viewer snap-in worked.

The log showed that several services were failing to start on boot due to insufficient privileges. I opened “My Computer” to look at the file ACLs and the label for my boot disk said “Access Denied”. Clicking on the icon yielded the same error in a message box.

Upon reboot, most services were able to start again. The System Event Notification Service wouldn’t start because it couldn’t write to the event logs. So I granted “Local Service” full permissions on the logs. Everything seemed to be fixed.

I let Windows install its 3,278,904,732,984 updates and then finally Service Pack 1. After the SP1 installation, I tried to login but was greeted with this little gem:

“The Software Licensing Service reported that the license store contains inconsistent data.”

I wasn’t exactly sure what to do since my copy of Windows was genuine. So, I thought, what if I forced Windows to re-activate? I remembered reading several months prior, that it was possible to “re-arm” Windows and set the evaluation clock back to zero. That fixed the licensing error and I didn’t even have to re-activate.

Everything seemed to finally be working again. Except Windows Update wanted to download and install SP1 again. So, I let it do that and it broke the licensing mechanism again! After fixing that again, Windows Update still thought SP1 wasn’t installed. I checked the Windows version and sure enough, I was using build 6000! wtf?

In the end, I had to flatten my machine to completely fix everything. I now have Windows installed and up-to-date. I’m annoyed that I had go to such lengths to re-gain access to my computer. But as a developer, I understand that sometimes software fails. File system corruption isn’t fun, but it was mostly fixable.

The part that I find really bothersome is that Windows wouldn’t let me use MY computer with MY licensed installation because something was corrupted. I understand the desire for ISVs to protect their products, but licensing mechanisms can introduce defects and cause undesirable side-effects. Like any operating system, Linux has issues. But there’s one issue it will never have: failure due to licensing software.

I’m happy to see the “reduced functionality mode” has been eliminated in Vista SP1. But, in following with a good article on the subject, I think Microsoft should spend less time on license enforcement and more time on software quality.

The suite now includes a special management studio that uses the VS IDE. In the past, developers needed to use an MMC snap-in to manage databases. It was usable, but generic. Features weren’t obvious and the interface was clumsy. The new feature-rich interface is much more friendly and intuitive.

But the IDE does, however, carry the same massive footprint as Visual Studio. I would have preferred it if they had kept the MMC snap-in for server use. Needing to install the IDE on the server seems silly, considering the amount of use it would get. Overall, though, I’m impressed with the software.

I opened my existing “Beta 1″ virtual machine with 256 MB of RAM and 8 GB of hard disk space, set the ISO as the boot media, and started it. Setup started, but then presented me with this:

The file WinSetup.dll could not be loaded or is corrupt. Setup cannot continue.

Disappointment took hold, but a quick Google search told me that my RAM was insufficient. So I increased it to 512 MB and the problem disappeared. With a renewed hope, I again started setup. This time setup prompted me with a different message:

A required CD/DVD device driver is missing. If you have a driver floppy disk, CD, DVD, or USB flash drive, please insert it now.

I created a new virtual disk, installed Windows XP, and booted into it. I was able to start Windows Vista setup from there without error. I typed my product key and started the installation process. While attempting to copy files, setup threw up with this error:

Setup was unable to locate a locally attached hard drive suitable for holding temporary Setup files.

Once Vista was installed, it was time to remove the Windows XP virtual disk. So I copied “bootsect.exe” from the Vista DVD, onto a floppy disk, and booted with a BartPE CD. I copied “C:\bootmgr” and “C:\Boot\” to the “e” drive and then ran “bootsect.exe /nt60 /force e:”. Once I verified that the boot loader was working, I removed the virtual disk and… tada!… it worked.

VMware tools installation was smooth, with the exception of the network adapter drivers. Back when I tested Beta 1, the vmxnet driver was not yet compatible with Vista. Following a suggestion from the VMware community, I switched the card to AMD PCnet. Since I had that setup already, I chose to install the driver and let it be. But I am curious if vmxnet works now.

While I realize this is a beta test release, the setup process leaves much to be desired. Development releases should contain more information, not less. Indescript errors are frustrating and difficult to diagnose. Hopefully, the operating system itself is better in this regard.

My first chore was to install Windows Server 2003 and configure it to be a domain controller. This part was fairly easy, although a little time-consuming. Once that was working I was able to quickly join the Windows machines to the domain. Now to deal with Linux… for that I chose Windows Services for Unix. This software alters the AD schema to allow for Unix account attributes. On the Linux machines, I installed OpenLDAP, a Kerberos client, configured PAM… and voila! Now AD users can authenticate on the Linux machines.

My home-made DHCP/DNS configuration tool, however, was a little trickier. The data for this tool is stored in a MySQL database and accessed via a PHP script. If I wanted to grant someone access to the tool, I needed to first give them a MySQL account. Since Active Directory is basically an LDAP server, I rewrote the authentication mechanism to query AD.

With very little work, I was able to simplify authentication and account management. While this is not new technology, I still feel all warm and fuzzy with a sense of accomplishment.

The bad part is that only Windows client operating systems are capable of supporting trusted connections (NT Authentication). This means that I can’t write a program to interface with the database server unless it’s running on Windows. So when I was asked to make my Windows creation work on a Mac, I was at a loss. Fortunately, I had been writing the suite of tools in VB.NET, so I started investigating the possibility of running a .NET app on OS X.

I found two contenders: Mono and DotGNU Portable .NET. Both projects are free implementations of the .NET standard. Mono doesn’t seem to have the anti-Microsoft sentiment and was easier to install. Right out of the gate, Mono allowed me to run a .NET app on OS X. PNET complained about ncurses not being installed. While this is probably a simple fix, it was one step that Mono did not require.

The end result? I managed to clone my VB.NET app in C# and make it run smoothly on a Mac. High five for .NET!