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 tried following the On OS X guide with limited success. Apparently, ffmpeg won’t compile on Leopard and that caused the entire libxine compilation to fail. I tried various combinations of configure flags, but none seemed to help. I looked at the source to try and fix it, but unfortunately I’m not terribly familiar with x86 assembly.

The problem code had to do with video rendering, so since Amarok doesn’t use it I just cut it out of the build process. Edit src/combined/ffmpeg/Makefile and find

xineplug_LTLIBRARIES = xineplug_decode_ff.la xineplug_decode_dvaudio.la

xineplug_LTLIBRARIES = xineplug_decode_dvaudio.la

After that, edit src/post/Makefile and find

SUBDIRS = planar goom visualizations mosaico deinterlace audio

SUBDIRS = goom visualizations mosaico audio

With libxine installed, I had a few more steps to build Amarok. I installed taglib

$ sudo fink install taglib

LDFLAGS="-Wl,-dylib_file,/System/Library/Frameworks/OpenGL.framework/Versions/ \
  A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/ \
  A/Libraries/libGL.dylib"

./configure --prefix=/sw --with-qt-includes=/sw/include/qt \
  --with-qt-libraries=/sw/lib/qt3/lib

I now have Amarok successfully compiled and running on Leopard. This took me quite a bit of time to get right, so I’m hoping someone else will find it useful.

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.

The domain member box is running Gentoo Linux. So you may need to adjust the steps to fit your flavor. Make sure the USE flags kerberos, ldap, samba, ssl, and winbind are set. Start by installing an NTP client.

# emerge ntp

The purpose of NTP is to keep your computer’s clock in-sync with the domain controller. Edit your /etc/ntp.conf file to use your domain controller as the time server. Then sync your clock, start the NTP client, and install Samba:

# ntpdate ad01.rit.edu
# /etc/init.d/ntpd start
# rc-update add ntpd default
# emerge samba

Now you can configure kerberos. Open your /etc/krb5.conf file and make it look like this:

[libdefaults]
  ticket_lifetime = 600
  default_realm = RIT.EDU
  clockskew = 120

[realms]
  RIT.EDU = {
    kdc = ad01.rit.edu
    default_domain = RIT.EDU
  }

[domain_realm]
  .rit.edu = RIT.EDU
  rit.edu = RIT.EDU

Test your kerberos setup by requesting a ticket from your domain controller.

# kinit administrator
# klist
# kdestroy

Edit your Samba configuration.

[global]
  workgroup = RIT
  realm = RIT.EDU
  server string =

  log file = /var/log/samba/log.%m
  max log size = 50

  hosts allow = 127.0.0.1 129.21.0.0/16   
  hosts deny = 0.0.0.0/0
  security = ADS
  allow trusted domains = yes
  password server = ad01.rit.edu
  encrypt passwords = yes
  min protocol = NT1

  winbind enum users = yes
  winbind enum groups = yes
  winbind cache time = 600
  winbind use default domain = yes
  template homedir = /home/%U
  obey pam restrictions = yes
  template shell = /bin/bash

  socket options = TCP_NODELAY SO_RCVBUF=8192 SO_SNDBUF=8192
  domain master = no
  local master = no

  idmap uid = 10000-99999
  idmap gid = 10000-99999

Add winbind to the daemon_list variable in /etc/conf.d/samba.

daemon_list="smbd nmbd winbind"

Join the domain and start Samba.

# net ads join -U administrator
# /etc/init.d/samba start

Add winbind to the passwd and group lines in /etc/nsswitch.conf.

passwd:      compat winbind
shadow:      compat
group:       compat winbind

Test user resolution and add Samba to the startup:

# getent passwd administrator
# rc-update add samba default

Add the bolded lines to your /etc/pam.d/system-auth file.

auth required pam_env.so
auth sufficient	pam_winbind.so
auth sufficient	pam_unix.so likeauth nullok use_first_pass
auth required pam_deny.so

account	required pam_access.so
account	sufficient pam_winbind.so
account	required pam_unix.so

password required pam_cracklib.so difok=2 minlen=8 dcredit=2 ocredit=2 retry=3
password sufficient pam_unix.so nullok md5 shadow use_authtok
password required pam_deny.so

session	required pam_limits.so
session	required pam_unix.so
session required pam_mkhomedir.so

That’s it! Now all you need to do is start samba and your box is an AD domain member.

Enter the “least privilege” security model. This approach to computing is very simple — only give yourself enough privileges to accomplish the task you need to perform. For example: do you need to be able to delete all of your system files while you write a letter in Microsoft Word? The answer would be “no, of course not!” But running with full privileges, you would be able to do so.

This is how malware spreads. Users visit websites that exploit known vulnerabilities in Internet Explorer. Since the default setup in Windows XP is to be an administrator, these programs can freely install themselves without your knowledge or consent. Working least-privileged solves this problem because without the privileges to tamper with system files, malware can’t invade your computer (easily).

Are you sold yet? Great! Now let’s set it up. Traditionally, working with with a non-privileged account has a real pain. But there are some tricks to help you.

1. Creating an Unprivileged Account

This step really depends on how you are setup right now. If you already have an account, then we need to adjust your privileges. Either way, you’ll need to logoff (Start > Logoff). Once you’re at the Welcome screen, press and hold the Control and Alt keys and the press the Delete key twice. You should now be presented with a login window. Type “administrator” for the user name and your password (or leave it empty).

Once logged in, pop yourself into the “User Accounts” control panel (Start > Control Panel > User Accounts). Select your own user account and choose “Change my account type”. Select “Limited User” and click OK. If you don’t have a password on your “administrator” account, you will want to set one now.

2. Turn-off Simple File Sharing (Optional)

This may fall more into the category of preference, but I think it makes life easier. Windows manages permission on securable objects (this includes files and folders) with Access Control Lists (ACL). When Simple File Sharing is turned-on, Windows will handle editing these lists for you. Doing this yourself gives you greater flexibility, but can cause you to lose data if you make a mistake.

To do this, open “My Computer”. From the “Tools” menu, choose “Folder Options”. Click on the “View” tab and you should see of list with checkboxes. Scroll to the bottom of this list, uncheck “Use Simple File Sharing (Recommended)”, and click OK.

3. Changing the Default Owner (XP Pro Only)

When a member of the Administrators group creates a file or folder, that user is the default owner. This can cause headaches when running least-privileged because you could end-up with write access to system files. By making the Administrators group the default owner, you eliminate that risk.

To accomplish this, you will need to open the Local Security Policy editor (Control Panel > Administrative Tools > Local Security Policy). In the left-hand pane, choose “Local Policies” and then “Security Options”. In the right-hand pane, find “System objects: Default owner for objects created by members of the administrators group”. Choose “Administrators Group” from the drop-down list and click OK.

4. Secondary Logon Service

What happens when you’re working and you need to make a change? Should you logoff and logon as an administrator? No!… there is an easier way. The Secondary Logon service allows you to run any application as another user by right-clicking on the file and choosing “Run As…”.

This should be enabled by default, but lets just make sure. Run the Computer Management applet (Control Panel > Administrative Tools > Computer Management). Choose “Services & Applications” and then “Services”. In the right-hand pane, find “Secondary Logon”, right-click, and choose “Properties”. Make sure startup type is “Automatic” and then click “Start” if the service is not already started.

5. Elevate Your Own Account (Optional)

Somtimes you need to make changes to your own account, but require administive privileges. You could change your account privileges (using Run As) and then logoff and logon again. But there is an easier way… Make Admin. This program will allow you to change your account privileges on-the-fly for specific applications.

Well, that was relatively painless (I hope). It will take some getting used to, but in the long-run, you’ll be glad you did. Oh, one more tip: you should do this on a clean install of Windows for best results.