Automate, else Enforce otherwise Path of Least Resistance.

This is well worth a read as far too many companies get burdened with process documentation over actual workable process.

A particular pet hate of mine is when people send a meeting invitation entitled “Foo Discussions” or some such, and fail to specify a location or any content. It’s even more irritating when I’m trying to be a good little corporate citizen and have my calendar auto-accept appointments, but they send it ten minutes before the thing actually starts. They’re going to receive an acceptance notice (of course) but my phone’s not going to synch for a good half-hour, and there’s just no way I’m going to be there. Funnily enough, I’m not just sitting around on my backside, waiting for someone to invite me to a meeting.

Oh, a meeting! How exciting! I’ve been waiting for one of these all day!

Of course, if you simply decline offending appointments manually, people tend to get offended. (Which may or may not be a good thing, depending on who it is.) A better way, however, is to automate the process.

Nothing personal, old chap – my calendar just has automation rules that apply to everyone.

The rules for getting into my calendar are simple:

1. Tell me everything I need to know about the meeting. This includes, specifically, its location. Outlook enforces pretty much everything else, but fails to enforce this one.
2. Please do me the courtesy of checking my free/busy information and do not attempt to trump something that’s already been organised. It shows a complete and utter disregard for my time and that of anyone with whom I’ve already agreed to meet.
3. Do me the courtesy of giving me at least 24 hours’ notice. Don’t send me a meeting request at 7pm on Monday evening for 7:30am on Tuesday morning. I’m not going to read it, and I’m not going to be there.

I finally snapped today, after another imbecilic meeting request, and wrote these two quick methods. They enforce the three rules above, automatically accept the request if it passes and automatically decline otherwise. They appear to work for me; your mileage may vary. No warranties, express or implied, etc.

Sub AutoProcessMeetingRequest(oRequest As MeetingItem)

    ' bail if this isn't a meeting request
    If oRequest.MessageClass <> "IPM.Schedule.Meeting.Request" Then Exit Sub

    Dim oAppt As AppointmentItem
    Set oAppt = oRequest.GetAssociatedAppointment(True)

    Dim declinedReasons As String
    declinedReasons = ""

    If (oAppt.Location = "") Then
        declinedReasons = declinedReasons & " * No location specified." & vbCrLf
    End If

    If (HasConflicts(oAppt)) Then
        declinedReasons = declinedReasons & " * It conflicts with an existing appointment." & vbCrLf
    End If

    If (DateTime.DateDiff("h", DateTime.Now, oAppt.Start) < 24) Then
        declinedReasons = declinedReasons & " * The meeting's start time is too close to the current time. " & vbCrLf
    End If

    Dim oResponse As MeetingItem
    If (declinedReasons = "") Then
        Set oResponse = oAppt.Respond(olMeetingAccepted, True)
    Else
        Set oResponse = oAppt.Respond(olMeetingDeclined, True)
        oResponse.Body = _
            "This meeting request has been automatically declined for the following reasons:" & vbCrLf & _
            declinedReasons

    End If

    oResponse.Send
    oRequest.Delete

End Sub

Function HasConflicts(oAppt As AppointmentItem) As Boolean
    Dim oCalendarFolder As Folder
    Set oCalendarFolder = ThisOutlookSession.Session.GetDefaultFolder(olFolderCalendar)

    Dim apptItem As AppointmentItem

    For Each apptItem In oCalendarFolder.Items
        If ((apptItem.BusyStatus <> olFree) And (oAppt <> apptItem)) Then
            If (apptItem.Start < oAppt.End) Then
                ' if this item starts before the given item ends, it must end before the given item starts
                If (apptItem.End > oAppt.Start) Then
                    HasConflicts = True
                    Exit Function
                End If
            End If
        End If
    Next

    HasConflicts = False
End Function

Just open the VBA editor from within Outlook (Alt-F11) and paste the subroutines into the ThisOutlookSession project.

Then go and create an Outlook rule that calls the AutoProcessMeetingRequest subroutine for every meeting request you receive:

Those of your colleagues who persistently refuse to learn how to use email (an essential business tool!) will receive responses along the following lines:

New features are all very nice, guys, but:

a) that feature’s been around for ages;

b) I hate it, as does everyone I know;

c) I’ve already told Messenger not to pop up the today box when I launch it, and this looks remarkably like you’re ignoring your users’ wishes for your own marketing purposes.

Back to Pidgin, methinks.

Is a conflict when two people have changed a file, or is it when two people have changed the same part of a file and VSTS needs assistance to resolve it? Every other (sane) version control system in the world interprets a conflict as the latter.

Stupid Question #2: How is it “Auto Merge” when I have to tell VSTS to merge?

Stupid Question #3: If VSTS could not-quite-auto-but-with-the-press-of-a-button merge, and it managed to resolve everything all by itself, why on earth does it pester me about non-existent conflicts all the time?!?!?

Perhaps these questions are stupid, but I most respectfully submit that the answers are stupider.

The icing on the cake was finding this article: Understanding and Solving Internet Explorer Leak Patterns. The markworthy text is this:

Pseudo-leaks almost always appear on the same page during dynamic scripting operations and should rarely be visible after navigation away from the page to a blank page.

In other words, Microsoft Word doesn’t leak memory either. All you have to do is close it, open it again and miraculously all the memory that it allocated and failed to release (but that somehow fails to meet the definition of “leaked”) is released.

The whole point of Internet Exploder 8 was to build an AJAX-friendly browser. The subtext went along the lines of, “Well, all those AJAX-heavy sites like GMail, Google Maps, Hotmail etc don’t perform well under IE7 and we’re losing browser market share, so let’s make a browser that is AJAX-friendly. But, at the same time, let’s make developers require people to navigate away from that application before any of its memory is released.”

We’ve just spent days diagnosing as many of the various ways that IE leaks memory (ways, incidentally, with which none of the other browsers seem to have problems), patching the jQuery core to cope with its idiocy and writing our own DOM garbage collection handlers to deal with it. The jQuery and GWT discussion forums reveal that these guys are having just as much pain, and for similar reasons.

To the IE development team: Please, please, please, guys, fix your sodding .removeChild method and everything that has anything to do with it. And don’t talk to me about setting .innerHTML properties either until you have a browser that doesn’t seg-fault when I do that to a table element, or when I manually break the relationship between a node and its parent. Finally, at least have the courage to confess that your browser does leak memory in these scenarios rather than some pathetic attempt at explaining why a leak isn’t a leak. Grr!!

If you want to cringe, grab the sIEve tool (see Memory leak detector for Internet Explorer for a link) and point it at http://msdn.microsoft.com. Navigate around a bit and then have a look at the number of orphan DOM nodes. Consider how many full-page reloads MSDN causes, and compare this to your own AJAX application. Weep.

Drip / IESieve, Memory leak detector for IE Internet Explorer .

If you haven’t looked at your application with sIEve, you really should.

For anyone who’s ever tried to debug a whole bunch of JavaScript code and ended up with myriad alert(‘here’) and alert(‘here2’) calls just so they could see what was happening, console.log() became our friend very, very quickly. No surprise, however, that IE didn’t have it.

It becomes significantly more painful, however, when you’re trying to clean up JS code for the sake of performance. The usefulness of any metrics collected goes out the window once there’s user activity involved. (Besides, clicking “OK” for all those alert boxes is a royal pain.)

(Hint to the IE8 team: Your product is still in beta. You must have a logging call somewhere. Publish it, please. Please. All the other browsers of note do.)

There are quite a few good console.log() equivalents out there, not the least of which are Faux Console and the Yahoo User Interface Logger Widget. For extremely light-weight applications, though, there was nothing that did just what I wanted, so I wrote one. You’ll be depressed at how simple it is, and how easy it would have been for the IE team to have included this functionality at almost any point in IE’s development cycle.

The JavaScript code:

// rudimentary javascript logging to emulate console.log(). If there already exists
// an object named "console" (defined by most *useful* browsers :p) then we
// won't do anything here at all.
if (typeof (console) === 'undefined') {

    // define "console" namespace
    console = new function() {
        // this is the Id of the console div. It doesn't actually need to be a div,
        // as long as it has an innerHTML property.
        this.ConsoleDivId = "JavaScriptConsole";

        // maintains a reference to the console output div, so that we don't have to
        // call document.getElementById a bunch of times.
        this.ConsoleDiv = null;

        // allows us to cache whether or not the console div exists, so that we can
        // just do an early exit from the console.log method and similar if we're not
        // going to put any useful output anywhere.
        this.ConsoleDivExists = null;
    };

    // this is an expensive (really quite expensive) string padding function. Don't use
    // it for large strings.  -andrewh 11/3/09
    console.padString = function(s, padToLength, padCharacter) {
        var response = "" + s;
        while (response.length < padToLength) {
            response = padCharacter + response;
        }

        return response;
    }

    console.log = function(message) {

        // this will be executed once, on first method invocation, to get a reference to the
        // output div if it exists
        if (console.ConsoleDivExists == null) {
            console.ConsoleDiv = document.getElementById(console.ConsoleDivId);
            console.ConsoleDivExists = (console.ConsoleDiv != null);
        }

        // only do any logging if we actually have an output div.  (Check using the cached
        // variable so that we don't end up with a bunch of failed calls to
        // document.getElementById).
        if (console.ConsoleDivExists) {
            var date = new Date();
            var entireMessage =
                console.padString(date.getHours(), 2, "0") + ":" +
                console.padString(date.getMinutes(), 2, "0") + ":" +
                console.padString(date.getSeconds(), 2, "0") + "." +
                console.padString(date.getMilliseconds(), 3, "0") + " " + message;
            delete date;

            // append the message
            console.ConsoleDiv.innerHTML = console.ConsoleDiv.innerHTML + "<br />" + entireMessage;

            // scroll the div to the bottom
            console.ConsoleDiv.scrollTop = console.ConsoleDiv.scrollHeight;
        }
    }
}

Ideally you’d drop this into an included script file, but it’s more likely that you’ll paste it into a <script> tag in the header of your HTML document.

The HTML that creates the DIV to contain the output:

<!--
 This is here for JavaScript debugging. Please use calls to console.log(message) to log to this console, as
 we're emulating the console.log() function that real browsers provide.  -andrewh 11/3/09
 -->
 <div id="JavaScriptConsole" style="position: absolute; bottom: 30px; left: 30px; width: 600px; height: 200px; overflow: scroll; background-color: Yellow; color: Red;">
     <a href="javascript:document.getElementById('JavascriptConsole').style.visibility = 'hidden';" style="float: right;">Close</a> <span style="font-weight: bold;">JavaScript Console</span><br />
 </div>

Note that this div also contains a hyperlink with JavaScript code in it to hide it.

A simple hello world script to log to it:

<script type="text/javascript">
   1: console.log("Hello, world!");
</script>

… and finally, the output:

I’m sitting in a Microsoft user group meeting right now, and I am, to be honest, pretty unimpressed. Not with the presenters – they’re doing a good job – or with the presentation, which is on what should be a fascinating topic, but with the people. Sorry, Microsoft, but the greatest problem you face right now is not your technology; it’s pretty damn good[1]. It’s the people who are afraid of using it – who, sadly, aren’t very.

OK, I’m home now, so I can type properly.

The presentation topic was the Azure Services Platform, which is Microsoft’s  answer to the Google cloud. Azure is a fascinating topic, both technically and strategically. The technical merits I’ll discuss in a minute. Strategically, however, this platform shows that Microsoft is quaking in its boots over what Google’s been doing with cloud computing, and is now trying to play catch-up. The degree of success a) remains to be seen; and b) depends upon the aforementioned people who are going to have to want to learn to use and exploit its strengths.

This platform gives immeasurable advantages to whomever wants them: almost infinite scalability, massive parallelism and redundancy, no more worries about server provisioning or downtime… the list goes on.

One of the reasons I’m so irritated is that instead of asking intelligent questions like, “How much can we scale a single computational task?” or even “How does this compare to the Google cloud in terms of speed, flexibility and response time?” people asked questions around keeping their own servers (“Can I still be woken up at 3am when a server falls over, please?”) and security (“Can I host my own database and have the platform talk to it?” or, in other words, “Can I still trust Microsoft with my unencrypted data, but nonetheless re-introduce my own single point of failure into an otherwise-well-designed system?”). Honestly.

I don’t want to rant, so suffice it to say this:

Learn about your craft. Go and sign up for the Azure CTP. Go and get your Google App Engine key. Read about the Google file-system and Amazon’s S3. And, while you’re at it, go and re-read some Knuth and some Fowler[2], just because you should, and probably haven’t.

Get some enthusiasm about what you’re seeing, people. It’s brilliant. Go and learn about it. For what it’s worth, if you haven’t been hanging out for a cloud computing solution from Microsoft for a very long time, I most respectfully suggest that you might be in the wrong profession.

[1] Except for Live Writer. What were you thinking, guys? Writing this post has been painful. I tried to screenshot the crash messages and embed them into another blog post (also in Live Writer) and it crashed, too. Fail.

[2] Who are they? Shame on you.

This post is specific to C#, as .NET has the very nice feature of code attributes, specifically the ConditionalAttribute class which allows methods to be compiled and invoked by the JIT compiler only if there’s a particular compilation variable set.

Consider the code below:

private static void Hello()
{
    Console.WriteLine("Hello, world!");
}

private static void Goodbye()
{
    Console.WriteLine("Goodbye, cruel world!");
}

public static void GreetTheWorld()
{
    #if DEBUG
    Hello();
    #endif

    Goodbye();
}

Let’s say that we compile this in Debug mode with code analysis turned on and warnings set to errors. (We all compile with warnings == errors, right?) All is well.

We go to run our unit tests again in Release mode prior to check-in, so we recompile in Release mode. (Or, if we’re lazy, we just check in from our Debug build and let our build server compile and run the tests in Release mode.)

Oops. CA1811 violation: you have uncalled private methods in your code. Please call them if you meant to call them, or remove them if not. The FxCop engine will never notice that our #if DEBUG directive has compiled out the call to our Hello() method, so code analysis throws an error.

Use this one instead:

[Conditional("DEBUG")]
private static void Hello()
{
    Console.WriteLine("Hello, world!");
}

private static void Goodbye()
{
    Console.WriteLine("Goodbye, cruel world!");
}

public static void GreetTheWorld()
{
    Hello();
    Goodbye();
}

This makes the compiler much happier.

Let’s consider the first piece of code again, though, and edit it in Release mode. Perhaps we’d like to rename our methods to something more descriptive of what they do: PrintHello() and PrintGoodbye(). So, we whip out our trusty refactoring tool (^R ^R in Visual Studio) and tell it to rename our methods.

Here’s what we end up with (remembering that we’re in Release mode):

private static void PrintHello()
{
    Console.WriteLine("Hello, world!");
}

private static void PrintGoodbye()
{
    Console.WriteLine("Goodbye, cruel world!");
}

public static void GreetTheWorld()
{
    #if DEBUG
    Hello();
    #endif

    PrintGoodbye();
}

Oh, sod. We’ve introduced a compilation error because the refactor/rename operation uses the compiled version of the code to check for symbol usage, and our call to the former Hello() method doesn’t appear in the compiled assembly because the #if DEBUG check caused it to not be compiled. We’ve left the old call to Hello() unchanged.

If we’d performed the same operation on the second piece of code instead, we’d be laughing.

The Windows 7 Beta Kicks Off This Week – Windows 7 Team Blog – The Windows Blog .

As I’ve been officially on holidays for the last four days (yes, four days includes two days of weekend; /sigh) I haven’t fetched it yet so I have no wisdom for anyone about what’s good and what’s not. Why not try it and see?

The problem? My JavaScript was a function declaration and therefore contained braces, but the placeholder delimiters in string.Format also use braces.

The solution: braces get escaped using another brace of the same sort.

string jsConditionalHelloWorldTemplate =
    "if ({0}) {{\r\n" +
    "    alert('Hello, world!');" +
    "}}" +
    "";

string sendToBrowser = string.Format(jsConditionalHelloWorldTemplate, "true")
writer.Write(sendToBrowser);

Simple, really, but not intuitive – most civilized formatters use a backslash to escape characters. Hmm.

Here’s one that will one day bite you. Consider this code:

<html>
    <head>
        <script type="text/javascript">

            var OnLoad = function() {
                document.getElementById("cloneme").onclick = function() { alert("onload");};
                document.body.appendChild(document.getElementById("cloneme").cloneNode(true));
            }

            window.attachEvent("onload", OnLoad);
        </script>
    </head>
    <body>
        <a id="cloneme" href="javascript:alert('href');">Test Hyperlink</a><br />
        <br />
    </body>
</html>

If you drop it into a local .html file and point a browser at it, it’ll look something like this:

There is a catch, however: although one hyperlink is a direct clone of the other, they’re not identical.

If you click the first one, you’ll see the order in which the events should fire represented by two alert boxes, the first one shouting “onload” and the second “href”.

If you click the second one, you’ll only see the “href” message.

Why is this?

The key point to remember is that the DOM object is being cloned from its textual representation. In other words, .clone() does not do a deep copy; rather, it effectively just creates a new node based on the .outerHtml property of the old node. Notably, that does not include any event handlers that have been attached programmatically.

Internet Exploder runs script evaluated using the JavaScript eval() function in the global scope.

So what?

Well, if you’re doing something silly, as I’m being obliged to do right now, such as dynamically adding and removing click handlers based on CSS attributes, fake HtmlTextWriter objects and third-party controls (over which I have no control), you’re eventually going to run into the error above.

Your code might look, in a very simplified form, something like this:

var RunCrazyUnsafeScript = function(scriptToEval) {
    eval(scriptToEval);
}

… and you’re probably invoking it something like this:

RunCrazyUnsafeScript("alert('Hello, world!');");

… and by and large, this all works perfectly well. Occasionally, however, you’ll see the error above. The odds are that you’re probably doing something like this:

RunCrazyUnsafeScript("alert('Hello, world!'); return false;");

This is perfectly legitimate in an event handler, and there are plenty of cases in which you actually want to return a value from evaluated code. I can’t understand why the JavaScript implementation of eval() doesn’t function more along the lines of perl, where eval() can be used to return all sorts of things, including – gasp! – the return value of the evaluated code. Wow.

Anyway… I’ll come to the code snippet that you can copy and paste so that you can leave this blog and go back to your own code.

var ScriptHelpers = function() {
    var _this = this;    // don't trust "this" in JS unless you *really* know what you're doing

    // IMPORTANT: This function is NOT thread safe. If you want to use it in a
    // multi-threaded application, you need to make it so. Or, preferably, fix
    // the code that's forcing you do use this approach at all.
    _this.EvalWithReturnValue = function(scriptToEval) {
        returnValue = undefined;
        scriptToEval = expToEval.replace(" return ", " returnValue= ");    // euww.. global. icky, icky, icky.  -andrewh 25/11/08
        eval(scriptToEval);
        return returnValue;
    }
}

var scriptWotWeGotFromSomeBlokeInAPub = "alert('Hello, world!'); return false;";
var scriptReturnValue = ScriptHelpers.EvalWithReturnValue(scriptWotWeGotFromSomeBlokeInAPub);

For example, we need to create a strongly-typed collection class that contains them all (presumably a left-over from the .NET 1.x days where there were no generic types), we need a configuration section class just to support an addition to the (web|app).config file, we need the provider class itself (effectively a factory class) and we need the class(es) of which it provides instances. Oh, and the interface that our provider stuff actually provides.

Here’s a code snippet (what’s a code snippet?) for creating a .NET provider and all the associated paraphernalia. Unfortunately it dumps all the classes into one .cs file, but AFAIK there’s no way to get a single snippet to create multiple files. You can (and should) do that yourself, though.

Handily, the snippet will also generate XML for you that can be copied/pasted directly into your (web|app).config file.

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>provider</Title>
      <Shortcut>provider</Shortcut>
      <Description>Code snippet for a .NET Provider implementation</Description>
      <Author>Andrew Harcourt</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>providerName</ID>
          <ToolTip>The name of the provider (e.g. "Cache", "Licence").</ToolTip>
          <Default>Stupid</Default>
        </Literal>
        <Literal>
          <ID>interfaceName</ID>
            <ToolTip>The name of the interface that the provider will return (e.g. "ICache", "ILicence").</ToolTip>
            <Default>IStupid</Default>
        </Literal>
        <Literal>
          <ID>defaultProvider</ID>
          <ToolTip>The name of the default provider instance to use (e.g. "Web", "File"). The suffix "$providerName$Provider" will be added automatically.</ToolTip>
          <Default>Default</Default>
        </Literal>

        <Literal Editable="false">
          <ID>className</ID>
          <ToolTip>The type of the owning class.</ToolTip>
          <Function>ClassName()</Function>
          <Default>StupidClass</Default>
        </Literal>

      </Declarations>
      <Code Language="csharp">
        <![CDATA[using System;
using System.Collections.Specialized;
using System.Configuration;
using System.Configuration.Provider;
using System.Diagnostics;
using System.Reflection;
using System.Web.Configuration;

#region $providerName$Provider

    [Serializable]
    public abstract class $providerName$Provider : ProviderBase
    {

        protected abstract string DefaultName { get; }
        protected abstract string DefaultDescription { get; }

        public abstract $interfaceName$ Get$providerName$();

        protected static void CheckForUnrecognizedAttributes(NameValueCollection config)
        {
            if (null == config)
            {
                throw new ArgumentNullException("config");
            }
            if (config.Count > 0)
            {
                string attr = config.GetKey(0);
                if (!string.IsNullOrEmpty(attr))
                {
                    throw new ProviderException("Unrecognized attribute: " + attr);
                }
            }
        }

        protected string VerifyInitParams(NameValueCollection config, string name)
        {
            if (null == config)
            {
                throw new ArgumentNullException("config");
            }

            if (string.IsNullOrEmpty(name))
            {
                name = DefaultName;
            }

            if (string.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", DefaultDescription);
            }

            return name;
        }
    }

#endregion

#region $defaultProvider$$providerName$Provider

    public class $defaultProvider$$providerName$Provider : $providerName$$end$Provider  //TODO Implement abstract class "$providerName$$end$Provider"
    {
        //TODO Add or merge the following into your (web|app).config file.
        /*
        <configuration>
          <configSections>
            <section name="$providerName$ProviderService" type="FULL_NAMESPACE_HERE.$providerName$ProviderSection, ASSEMBLY_NAME_HERE" />
          </configSections>

          <$providerName$ProviderService defaultProvider="$defaultProvider$$providerName$Provider">
            <providers>
              <clear />
              <add name="$defaultProvider$$providerName$Provider" type="FULL_NAMESPACE_HERE.$defaultProvider$$providerName$Provider, ASSEMBLY_NAME_HERE" />
            </providers>
          </$providerName$ProviderService>

        </configuration>
        */
    }

#endregion

// The code below here is auto-generated and shouldn't need any manual
// editing unless you want to do interesting stuff.  -andrewh 18/9/08

#region $providerName$ProviderSection

    [Obfuscation(Feature = "renaming", Exclude = true, ApplyToMembers = false)]
    public class $providerName$ProviderSection : ConfigurationSection
    {
        [ConfigurationProperty("providers")]
        public ProviderSettingsCollection Providers
        {
            get { return (ProviderSettingsCollection)base["providers"]; }
        }

        [StringValidator(MinLength = 1)]
        [ConfigurationProperty("defaultProvider", DefaultValue = "$defaultProvider$$providerName$Provider")]
        public string DefaultProvider
        {
            get { return (string)base["defaultProvider"]; }
            set { base["defaultProvider"] = value; }
        }
    }

#endregion

#region $providerName$ProviderService

    [Serializable]
    public class $providerName$ProviderService
    {
        private static $interfaceName$ _instance;
        private static $providerName$Provider _provider;
        private static $providerName$ProviderCollection _providers;
        private static object _lock = new object();

        public static $providerName$Provider Provider
        {
            get { return _provider; }
        }

        public static $providerName$ProviderCollection Providers
        {
            get {
              LoadProviders();
              return _providers;
            }
        }

        public static $interfaceName$ $providerName$
        {
            get
            {
                if (_instance == null)
                {
                    _instance = LoadInstance();
                }

                return _instance;
            }
        }

        private static $interfaceName$ LoadInstance()
        {
            LoadProviders();
            $interfaceName$ instance = _provider.Get$providerName$();

            // if the default provider fails, try the others
            if (instance == null)
            {
                foreach ($providerName$Provider p in _providers)
                {
                    if (p != _provider) // don't retry the default one
                    {
                        instance = p.Get$providerName$();
                        if (instance != null) // success?
                        {
                            _provider = p;
                            break;
                        }
                    }
                }
            }

            Debug.Assert(instance != null);
            return instance;
        }

        private static void LoadProviders()
        {
            if (null == _provider)
            {
                lock (_lock)
                {
                    // do this again to make sure _provider is still null
                    if (null == _provider)
                    {
                        $providerName$ProviderSection section = LoadAndVerifyProviderSection();
                        BuildProviderCollection(section);
                    }
                }
            }
        }

        private static void BuildProviderCollection($providerName$ProviderSection section)
        {
            _providers = new $providerName$ProviderCollection();
            ProvidersHelper.InstantiateProviders(section.Providers, _providers, typeof($providerName$Provider));

            if (_providers.Count == 0)
            {
                throw new ProviderException("No providers instantiated");
            }

            _provider = _providers[section.DefaultProvider];
            if (null == _provider)
            {
                throw new ProviderException("Unable to load provider");
            }
        }

        private static $providerName$ProviderSection LoadAndVerifyProviderSection()
        {
            // fetch the section from the application's configuration file
            $providerName$ProviderSection section = ($providerName$ProviderSection)ConfigurationManager.GetSection("$providerName$ProviderService");
            if (section == null)
            {
                throw new ProviderException("$providerName$ProviderService section missing from (web|app).config");
            }

            return section;
        }
    }

#endregion

#region $providerName$ProviderCollection

    [Serializable]
    public class $providerName$ProviderCollection : ProviderCollection
    {
        public new $providerName$Provider this[string name]
        {
            get { return ($providerName$Provider)base[name]; }
        }

        public override void Add(ProviderBase provider)
        {
            if (null == provider)
            {
                throw new ArgumentNullException("provider");
            }

            if (!(provider is $providerName$Provider))
            {
                throw new ArgumentException("Invalid provider type", "provider");
            }

            base.Add(provider);
        }
    }

#endregion
]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

From Simon Willison’s blog:

Just don’t look at the actual execution times below, or you’ll cry (as I am :’( ).

Anyway, to the point. Below is a code analysis rule (don’t ask me what a CA rule is; ask Google) to encourage developers to check all parameters to their public methods.

It’s not the complete rule; you’ll need your own BaseRule class and XML rule definition file, but if you’re competent enough to write these rules in general then you’re competent enough to find examples of those elsewhere.

internal class EnforceArgumentChecking : BaseRule
{
    #region Constructors

    public EnforceArgumentChecking()
        : base(typeof(EnforceArgumentChecking).Name) { }

    #endregion

    #region Public Properties

    public override Microsoft.FxCop.Sdk.TargetVisibilities TargetVisibility
    {
        get
        {
            return TargetVisibilities.All;
        }
    }

    #endregion

    #region Public Methods

    public override ProblemCollection Check(Member member)
    {
        ProblemCollection problems = new ProblemCollection();

        Method method = member as Method;
        if (ShouldCheck(method))
        {
            Dictionary<string, int> parameterExceptions = GetParameterExceptionCounts(method);

            // require that each parameter have at least one /Argument.*Exception/ associated with it
            foreach (string parameterName in GetParametersToCheck(method))
            {
                // if there's no count for this parameter name, or the count's less than one, we have a problem.
                if ((!parameterExceptions.ContainsKey(parameterName)) || ((parameterExceptions[parameterName] < 1)))
                {
                    Resolution resolution = GetNamedResolution("ArgumentNotChecked", parameterName, method.Name.ToString());
                    problems.Add(new Problem(resolution));
                }
            }
        }

        return problems;
    }

    #endregion

    #region Helper Methods

    /// <summary>
    /// Gets a list of the parameter names to check. This will return all parameter names except those
    /// that have a Zap.Attributes.SuspressParameterCheck entry for that individual parameter.
    /// </summary>
    /// <param name="method">The method whose parameter collection to scan.</param>
    private IEnumerable<string> GetParametersToCheck(Method method)
    {
        List<string> parametersToIgnore = new List<string>();

        foreach (AttributeNode attr in method.Attributes)
        {
            if (attr.Type.FullName.Equals("Zap.Attributes.SuppressParameterCheck"))
            {
                Expression paramName = attr.GetPositionalArgument(0);
                Expression justification = attr.GetPositionalArgument(1);

                if (!string.IsNullOrEmpty(justification.ToString()))
                {
                    parametersToIgnore.Add(paramName.ToString());
                }
            }
        }

        foreach (Parameter p in method.Parameters)
        {
            string paramName = p.Name.ToString();

            if (parametersToIgnore.Contains(paramName))
            {
                continue;
            }

            yield return paramName;
        }
    }

    /// <summary>
    /// Decides whether we should apply this rule to the given method.
    /// </summary>
    /// <param name="method">The method.</param>
    /// <returns>False if the method is null, non-public, an interface or abstract method, a public property setter; true otherwise.</returns>
    private static bool ShouldCheck(Method method)
    {
        if (method == null) { return false; }

        if (!method.IsPublic) { return false; }

        // this will catch methods that are defined as either abstract or interface methods
        if (method.IsAbstract) { return false; }

        if (method.IsAccessor) { return false; }

        // we don't check operators - they all generally call the AreEqual, Add, Append or other named methods anyway - and they're almost
        // always overloads.
        if (method.Name.ToString().StartsWith("op_", StringComparison.Ordinal)) { return false; }

        return true;
    }

    /// <summary>
    /// Looks for the creation of instances of /Argument.*Exception/ and counts them for each parameter on the method.
    /// </summary>
    /// <returns>A dictionary mapping the parameter name to the number of /Argument.*Exception/ thrown against that parameter.</returns>
    private static Dictionary<string, int> GetParameterExceptionCounts(Method method)
    {
        Dictionary<string, int> exceptionsThrownOnParameters = new Dictionary<string, int>();

        // count the exceptions thrown on each parameter.
        for (int i = 2; i < method.Instructions.Count; i++) // start from 2 because it's pretty much impossible to throw a useful exception before this.
        {
            Instruction instruction = method.Instructions[i];

            // are creating a new Argument*.Exception object?
            if (instruction.OpCode == OpCode.Newobj)
            {
                InstanceInitializer initializer = (InstanceInitializer)instruction.Value;
                if (Regex.IsMatch(initializer.FullName, "Argument.*Exception"))
                {
                    for (int paramIdx = 0; paramIdx < initializer.Parameters.Count; paramIdx++)
                    {
                        Parameter p = initializer.Parameters[paramIdx];
                        if (p.Name.ToString().Equals("paramName"))
                        {
                            int paramOffset = initializer.Parameters.Count - paramIdx;

                            Instruction loadStringInstruction = method.Instructions[i - paramOffset];
                            if (loadStringInstruction.OpCode == OpCode.Ldstr)
                            {
                                string parameterValue = loadStringInstruction.Value.ToString();

                                if (!exceptionsThrownOnParameters.ContainsKey(parameterValue))
                                {
                                    exceptionsThrownOnParameters[parameterValue] = 1;
                                }
                                else
                                {
                                    exceptionsThrownOnParameters[parameterValue]++;
                                }
                            }
                        }
                    }
                }
            }
        }

        return exceptionsThrownOnParameters;
    }

    #endregion

}

Hand in hand with this rule is a code attribute that allows the programmer to suppress warnings on individual method parameters, rather than just suppressing the entire rule for a particular method:

[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = true)]
public sealed class SuppressParameterCheck : Attribute
{
    private string _parameterName;
    private string _justification;

    public SuppressParameterCheck(string parameterName, string justification)
    {
        if ((string.IsNullOrEmpty(justification)) || (justification.Length < 10))
        {
            throw new ArgumentNullException("justification", "If you're going to suppress a parameter check, you MUST MUST MUST give a reason.");
        }

        _parameterName = parameterName;
        _justification = justification;
    }

    public string ParameterName
    {
        get { return _parameterName; }
    }

    public string Justification
    {
        get { return _justification; }
    }
}

And an example of how to use the SuppressParameterCheck attribute:

public void Insert(string key, object value)
{
    #region Argument Checking

    #region Argument Check for "key"

    if (string.IsNullOrEmpty(key))
    {
        throw new ArgumentNullException("key");
    }

    #endregion

    #region Argument Check for "value"

    if (value == null)
    {
        throw new ArgumentNullException("value");
    }
    #endregion

    #endregion

    // Accept the object, but don't cache it.
}

[SuppressParameterCheck("key", "This will be checked in a called method.")]
[SuppressParameterCheck("value", "This will be checked in a called method.")]
public void Insert(string key, object value, CacheExpireType expireType)
{
    Insert(key, value);    // Accept the object, but don't cache it.
}

Of course, it goes without saying that you’re compiling with warnings == errors, right?

If you have a Windows Mobile device and get synchronization error 0x8503001c, your life is close to over. Trust me.

You can delete and re-create the sync partnerships between your PC and your Windows Mobile device as many times as you want, with whatever permutations of synchronization settings you choose, but it’s not likely to help. Try it anyway, but don’t waste too much time on it.

What you’re going to do, at some point after you’ve realized that it’s all hopeless, is reset everything to factory defaults and start over.

The first tool you’ll want is Dotfred’s PIM Backup tool, available at http://www.dotfred.net/. Get it and back your device up (NOT to your device memory!).

Reset your device to factory defaults. On my Dopod you hold both of the multi-function buttons (the “-” buttons) while poking the reset button with your stylus. Press the Send button when it prompts you to confirm. Yours is probably different.

Re-create the sync relationship between your phone and your PC.

Re-sync everything.

Restore your backup.

Cry.

http://thedailywtf.com/Articles/We-Burned-the-Poop.aspx

The sordid details are not included here to preserve the dignity of the guilty parties, but basically it boils down to: a property getter/setter is NOT the same as a public instance variable.

In other words, you are never guaranteed that the value you put in will be the value you get back. Consider the following:

this.Foo = "Hello, world!";
Debug.Assert(this.Foo.Equals("Hello, world!");

If I were evil (or just incompetent, as the developers of certain pieces of code I’ve had to deal with recently were), my definition of Foo could be as below:

private string _foo;
public string Foo
{
    get
    {
        return _foo;
    }
    set
    {
        Trace.WriteLine("The caller asked me to store '{0}', but I'm going to drop it on the floor instead. <snigger />".FormatWith(value));
    }
}

As I said, this is an elementary distinction (and a trivial example) but do not not not assume that just because you’ve asked a setter to store a value that you’ll get the same value back from the getter. You should, but “should” is the most over-used word in this industry.

For example, if one wanted to display a “Hello, world!” message whenever several different attributes were changed, the conventional approach would be to embed the call to alert() in each of the event handlers. Obviously, for such a simple example, this isn’t such a big deal, but for more sophisticated logic it becomes unwieldy very, very rapidly.

One common approach is to use externally-referenced script files. Great, but imagine the horror when you suddenly discover that your system administrator has been religiously backing up your CRM server for the last six years, but hasn’t backed up the web server from which you were serving your scripts… We still have the problem of how to reference them, too.

Variable declarations in JavaScript (evilly) default to global. What you can do to exploit this, however, is to declare a global function pointer from within an OnLoad event handler as follows:

// This is the OnLoad event handler provided by CRM
function OnLoad() {
    // This is the function that we want to make
    // available globally. Note the lack of a
    // "var" declaration.
    helloWorldFunction = function() {
        alert("Hello, world!");
    }
}

Then, in your event handler for other controls on the page, you can re-use that global variable:

// This is the OnChange event handler provided by CRM
function OnChange() {
    // ... and here's the one we prepared earlier.
    helloWorldFunction();
}

… and Bob’s your father’s creepy brother, you have code reuse with no external dependencies.

• Why do we write unit tests?
  • Improve code quality
  • Fewer reported defects
  • Make checking code faster
  • Tell us when we’ve broken something
  • Tell us when our work is done
  • Allow others to check our code
  • Encourage modular design
  • Keep behaviour constant during refactoring Functions as a spec (think TDD)
• The law of diminishing returns most definitely applies here
  • Testing everything is infeasible. Don’t be unrealistic.
  • 70% code coverage is actually pretty decent for most classes.
  • First, test the common stuff.
  • Next, test the common exception-case stuff.
  • Then test the critical stuff.
  • Add other tests as appropriate.
• When to write a unit test
  • Use a unit test to provide a framework for writing your code
  • If you find yourself running up an entire application more than once or twice to test a particular
  • method you’ve written, wrap it in a unit test and use that test to invoke it directly
  • ^R ^T is your friend
  • When someone comes to you with a bug report, write a test to reproduce the bug.

Key Principles for Unit Tests

• Each and every test must be able to be run in isolation
  • Tests should the environment up for themselves and clean up afterwards
    • Use your ClassInitialize, ClassCleanup, TestInitialize and TestCleanup attributes
  • Tests should never rely on being executed in any particular order (that’s part of the meaning of “unit”)
  • Tests should not rely overmuch on their environment
    • Don’t depend on files’ being anywhere
    • Never, ever, ever hard-code a path. Find a better way.
    • For the Zap crowd: anyone who codes “C:\Projects” into a unit test (again!) is going to get a swift kicking. Politely, of course
  • If a class depends on another class that depends on another class that you can’t easily instantiate in your unit test, this suggests that your classes need refactoring. Writing tests should be easy. If your classes make it hard, fix your classes first.
• Tests should be cheap to write
  • Don’t worry about exception-handling – if an unexpected exception is thrown, the test fails. Don’t bother catching it and manually asserting failure.
  • Be as explicit as you can
    • Don’t allow for variations in your output unless you absolutely have to.
    • If there are going to be different outputs, ideally there should be different tests
• Tests should be numerous and cheap to maintain
  • Each test should test one (perhaps two or three, but generally just one) behaviour
  • It’s much better to have lots of small tests that check individual functionality rather than fewer, complex tests that test many things.
  • When a test breaks, we want to know exactly where the problem is, not just that there’s a problem somewhere in a call stack seven classes deep.
• Tests should be disposable
  • When the code it tests is gone, the test should be dropped on the floor.
  • If it’s a simple, obvious test, it will be simple and obvious to identify when this should happen.
• Tests need not be efficient

Cool Stuff

• Private Accessors
  • These allow you to call private methods and access private variables from another class
  • This deliberately breaks OO principles
  • Use it for testing implementation-specific stuff, but depend on concrete types when you do.

• ASPX page testing
  • You can automate all sorts of stuff with respect to ASPX pages
  • Button clicks
  • Form inputs
  • 
  • This does not replace regression test automation (e.g. Mercury et al), but should be used by individual developers when writing new ASPX pages and ASCX controls.
  • Don’t run the application and click stuff manually
  • Write a unit test and tell it to click stuff automatically

• Testing web service methods
  • The unit test framework will get confused
  • Use either a wrapper (think Adapter or Façade pattern) and/or a Strategy-pattern.

• Using the unit testing framework for integration testing
  • Have a couple of common-case “unit” tests that actually represent an end-to-end use case of your application.

Note for young players: if you get an invalid cast exception such as…

Test method Test.Zap.CubeModel.DigitalSearchTreeTest.TestInsert threw exception: System.InvalidCastException: Unable to cast object of type ‘Node`1[System.Char,System.Char]‘ to type ‘Node`1[System.Char,System.Char]‘..

…it may be that your type is a nested class or similar and does not have public visibility.

Service Contracts and Operation Contracts

This is what your WCF service promises faithfully to do for its callers.

Data Contracts

These are the data types that your WCF service expects its callers to understand. Thankfully, it will happily explain these data types to its callers.

Events (… or “Duplex Contracts”)

Out of scope for this presentation, but see http://msdn.microsoft.com/en-us/library/ms731184.aspx for a pretty decent explanation.

Hosting Your WCF Service

Note the endpoint address:

Adding a service reference to your project

The metadata exchange address is the equivalent of the old Web Service Definition Language (WSDL) address.

Calling the WCF Service

Call it just as you would your local methods.

It’s that easy.

Purely for edification, this is what some of the generated code looks like:

http://bloggingabout.net/blogs/jschreuder/archive/2006/11/02/Centralizing-AssemblyInfo-settings_2C00_-or-simplify-versioning-of-solutions.aspx

A .NET provider specified in a web.config file has its status set to enabled=false by default. Don’t ask me why.

This problem, when using a custom role provider, might manifest as the above error. Very frustrating, as none of the Google results I’ve seen will mention this particular cause of this error, anything about how to actually fix it.

.NET 3.5 rocks.

http://blogs.msdn.com/wriju/archive/2007/11/27/linq-to-sql-enabling-dbml-file-for-wcf.aspx

When using WPF OnContextMenuOpening, ContextMenu doesn’t display on first load.

The reason:

The OnContextMenuOpening routed event is used for dynamically creating a ContextMenu object for a particular UIElement.

Each UIElement has a ContextMenu property which dictates what gets displayed when a user right-clicks on it. If the property is null, nothing will be displayed. If the property is not null, the context menu that it references will be displayed.

The catch? The ContextMenu property must not be null before the event handler first fires, or the menu won’t load. This appears to be a WPF bug, but it’s a pain either way.

The solution:

Create an empty ContextMenu object and assign it to each UIElement that’s going to have any context menu displayed. In the OnContextMenuOpening event, either Clear() the existing context menu or just create a new one and assign the property to the object reference. Either will work.

Update: I just received mail from Matt Johnston (thanks, Matt!) about a simpler way to flash the cards. I haven’t tested it personally, but if it works for you, it looks like it will be much quicker. Have a quick read here and see what you think.

Update (18/3/03): Enterasys appear to be keeping reasonably up-to-date with their driver releases, so unless you’re looking to use the card under a non-supported OS or you want to flash your 40-bit WEP card to 128-bit, this is probably a bit too much trouble to go to

Update (28/8/03): This page is no longer being updated. If you have queries about anything to do with your card’s configuration, please visit either the manufacturer’s web site or Melbourne Wireless.

Frequently Asked Questions

Why would I want to do this? 

• To fix broken Enterasys firmware that doesn’t properly support ad-hoc mode
• To ensure inter-operability with other Lucent cards (not that this really seems to be a problem)
• The possibility that you can then upgrade (using an Apple Airport) this firmware to Orinoco Gold, and thus get better encryption. (Try this link).

Does it change the way my operating system identifies the card? 

• No. Initial reports suggested that it did; after subsequent checking it appears that this is not the case. This is not to say that it cannot be done; simply that upgrading the firmware does not do it.

How can I make my Windows OS think the card is a true Lucent card? 

• We don’t know. If you can work it out, please tell us. We have tried using PCI Set Register calls to change the card’s device ID; we have tried flashing them with all sorts of firmware. No change.
• You could try seeing if there’s any other EEPROM on the cards themselves – and then writing your own flashing program to write a new image to it. Good luck

How can I make my Linux OS think the card is a true Lucent card? 

• No need. It already uses the orinoco_cs driver anyway, so the card will perform exactly the same.

Which drivers should I use with the card after I update its firmware? 

• The Enterasys ones.
• They’ll still identify the card as a RoamAbout but its MAC functions will behave like a Lucent card.

So, why would I want to do this again? 

• To fix ad-hoc mode.
• Peace of mind that you’re running the latest (and presumably best) firmware that Lucent have released.

To re-flash your card, follow these steps:

1. Find a computer with a PCMCIA slot and a working installation of Windows 9x. 98SE is fine, as is Windows ME. Windows NT, 2000 and XP all appear not to work – there have been many reports of people struggling with it, and I haven’t heard of anyone doing it successfully.
2. Boot the machine without the card inserted.
3. Download an old version of the Orinoco drivers onto the machine and un-archive them into C:\TEMP\ORINOCO-OLD. You can download the drivers from uglybugger.org here. Do not use a more recent version of the drivers – they will refuse to detect the card. Do not install the drivers at this stage – simply unarchive them.
4. Optional: Download the current version of the Orinoco drivers onto the machine get the most recent of these from www.orinocowireless.com. Unarchive these into C:\TEMP\ORINOCO-NEW. Again, do not install these drivers – just unarchive them.
5. Insert your Enterasys card into one of the machine’s PCMCIA slots. If your machine does not support hot-insertion of PCMCIA devices, reboot after this step.
6. When prompted for a driver for the card, click the Have Disk button and browse to C:\TEMP\ORINOCO-OLD\DRIVER.
7. Click OK and install the drivers for the card. You want the “5V Only” PCMCIA driver, not the 3.3/5V one.
8. Reboot the machine.
9. Run the program C:\TEMP\ORINOCO-OLD\FIRMWARE\WSU10728.EXE
10. Click Update in the firmware update program, then OK to confirm.
11. Wait a few seconds
12. Close the program.
13. Your card will now identify itself as an Orinoco card (at least, according to the old driver), but it has an old firmware version and will probably not work correctly yet. Not to worry – that will soon be fixed.
14. Run the program C:\TEMP\ORINOCO-NEW\FIRMWARE\WSU10810.EXE. (If you didn’t download the new drivers, then just use the link given here.
15. Click Update in the new firmware update program, then OK to confirm.
16. Your card is now running the most recent Orinoco firmware. Be happy
17. If you have more than one card, remove the current one, replace it with another card to be updated, then repeat the last 9 steps.
18. Close the new firmware flashing program.
19. Now install the latest Enterasys drivers onto your machine. You can download these from their web site.).

Thanks to Will Lanigan and Danny (last name??) from Melbourne Wireless for the general information on how to do this.

> -----Original Message-----
> From: Matt Johnston [mailto:matt [at] ucc [dot] gu [dot] uwa [dot] edu [dot] au]
> Sent: Friday, 11 October 2002 12:38 AM
> To: andrewh@uglybugger.org
> Subject: Enterasys to Orinoco
>
>
> Hi.
>
> I've used the instructions on your page for Enterasys ->
> Orinoco, and they've worked nicely. However I think I've
> found a nicely simpler way to do it.
>
> Simply open the binary (the .exe) in a hexeditor (or capable
> text editor such as vim), and replace "LUC" with "RBT". There
> should only be one instance of it, it stands out.
>
> Now you can run the updater, and it'll happily work.
>
> I haven't done a huge lot of testing, but it appears to work.
>
> Cheers,
> Matt

Good luck

I shudder to think how much this PERL code looks like it was written by a C programmer…

If you still find it useful, great. If you’d like to mess with the code, great too. If you’re really annoyed with fetchmail and it doesn’t already have this feature built in, why not change the fetchmail code yourself and submit it to the maintainers?

Why don’t I? Because I wanted to learn PERL…

I recently had some trouble with fetchmail and multidrop mailboxes. fetchmail handles mail well when a local address is found in the To: field of an email, but badly when it has to extract address information from the other headers of an email. In particular, people on the BCC list of an email (and who never appear in “official” mail headers) are likely to never receive emails addressed to them when handled via fetchmail with a multidrop mailbox.

I was also looking for an excuse to learn PERL (08/2004 update: wow, this page really is old…).

qmail has a nice solution where it inserts an Delivered-To: line into the mail headers. For virtual hosts, it prepends the domain name to the email account it was delivered to. My domain is uglybugger.org, so when the MX host for mail.uglybugger.org accepts mail for me, it dumps it into a single account. The headers it inserts look like this:

Return-Path: Andrew.Harcourt@team.telstra.com
Delivered-To: uglybugger.org%uglybugger@uglybugger.org
Received: (cpmta 5066 invoked from network); 2 Apr 2001 21:59:52 -0700
Delivered-To: uglybugger.org%andrewh@uglybugger.org
Received: (cpmta 5062 invoked from network); 2 Apr 2001 21:59:51 -0700

Read this from the bottom up. You’ll see that the first Delivered-To: line reads uglybugger.org%andrewh@uglybugger.org and the second Delivered-To: line reads uglybugger.org%uglybugger@uglybugger.org.

fetchmail can be configured to read envelope addresses. These are the addresses (such as the Delivered-To: line) that mail servers include in mail headers to record which account the mail was delivered to. This is an important distinction from which address the mail was intended for. You can tell fetchmail to use these headers by specifying the following in your .fetchmailrc file:

envelope "Delivered-To:"
qvirtual "uglybugger.org%"

Obviously, please change the qvirtual line to read your domain

The problem here is that fetchmail will only read headers top-down, and it matches the first one it finds. This breaks the envelope/qvirtual delivery process completely as fetchmail is unable to ignore the first line it receives. So if the envelope/qvirtual settings do not solve your problem, read on.

What we need to do is specify an alternate delivery agent, so that we can handle our processing ourselves. You can do this by specifying an external Mail Delivery Agent for fetchmail. Use the mda keyword to point mail to a script that you can copy and paste from here:

----- /usr/sbin/fetchmail-inject ----------
#!/usr/bin/perl
# fetchmail-inject
# Andrew Harcourt, 1 May, 2001
#
# this script removes a nasty header that fetchmail can't handle
# from incoming mail and then passes the mail to sendmail to
# deliver locally

# write the mail to a temp file on disk
# as we do, parse it for the address
# lines
local($outputName, $fromAddress, $toAddress, $cmd);

$outputName = "/tmp/message.".$$;
open(OUTFILE,"> ".$outputName)
        || die "could not open $outputName!";

while (&ltSTDIN&gt) {
        if (/^Delivered-To: uglybugger\.org\%uglybugger\@uglybugger\.org/) {
                # just ignore this line - it's ugly
        }
        elsif (/^Delivered-To: uglybugger\.org\%(.*)\@uglybugger.org/) {
                $toAddress = $1."\@uglybugger.org";
        }
        elsif (/^From: .* /) {
                $fromAddress = $1;
        }
        elsif (/^From: /) {
                $fromAddress = $1;
        }
        elsif (/^From: .*/) {
                $fromAddress = $1
        }
        print OUTFILE $_;
}

close(OUTFILE);

# check that we have our addresses correct
if ($toAddress eq "") {
        $toAddress = "postmaster\@uglybugger.org";
}
if ($fromAddress eq "") {
        $fromAddress = "postmaster\@uglybugger.org";
}

# now call sendmail to deliver the message
$cmd = "/usr/sbin/sendmail -f $fromAddress $toAddress < $outputName";
system($cmd);

-------------------------------------------

Good luck