David_Bennett

Australian Government and Parental Controls

David_Bennett — Thu, 23 Aug 2007 08:24:46 GMT

It is interesting that the Australian Government is getting into the act on releasing a free web filter for use with windows, I wonder if they are connecting up to the Vista parental controls settings built into vista. I have to wonder if they provide any better coverage than Vista already does. It is curious they didn't just try and do a deal with Microsoft (or something like that) who give away their parental control software for XP and it is included with Vista.

The more worrying part of the article is labours claim that when elected it will require all ISPs to implement filtering. This is not a realistic expectation and is also problematic, how do you define filtering? Who defines what is what and if it should be filtered? No filters are perfect, new sites come up all the time with new content and they may not be filtered by the system yet. Vista does try and do some automatic detection of the page but it is definitely not 100% accurate and doesn't look inside images. If labour does implement this once they get into office it will create a lot of problems for Australia's ISP industry, although a better idea of how it is going to implemented would be needed for a more indepth comment.

Meringue

David_Bennett — Thu, 23 Aug 2007 08:21:59 GMT

A tip when making Meringue is to use a teaspoon of vinegar (or lemon juice, something acidic) in the meringue mixture, it makes it a little tangier and works a lot better. Just a small amount of lemon juice can work really well with a lemon meringue pie.

I find cleaning the mixer with vinegar before I start mixing the egg whites helps as well, makes the whites a little fluffier and a bit stiffer.

Taking Responsability for your Code

David_Bennett — Mon, 23 Apr 2007 20:44:44 GMT

A co-worker (Kyle Olson) came up with a list of items about how to take responsability for your code that I thought was quite useful. I am reposting the article here.

I would like to add that one thing you should always be thinking about when writing code is how someone else is going to be able to read/maintain it. Code spends 80-90% of it's time in maintence mode, so the code has to be understandable to someone else can fix it and keep it working. If you don't comment or don't document then people will have no idea how to get it to work.

Relationship with testers:

If you can't reproduce a bug on your system, do you send the bug immediately back to the tester, or do you go to the tester for a repro? If you have trouble understanding a bug, do you punt the bug without a thought, or do you simply punt the bug away?

The testers are almost always willing to show you exactly what the problem is, and doing so will greatly reduce the time it takes to fix a bug. Spending just a few minutes debugging a tester's machine will allow you to uncover a myriad of problems. Your priority should not be to get bugs off of your plate, your priority should be to fix your bugs and make our product work properly.

Relationship with other developers:

If you create components and interfaces for other developers to consume, is there a strict contract that the code follows? Can the developer be certain how the code will behave? Does the other developer know what error codes will be returned? If the code fails, how will the consuming developers know that it has failed?

If another developer has a problem with your code, do you engage the other developer in an attempt to fix the problem, or do you attempt to force all the responsibility onto your coworker? Is your response to the developer to tell them the things that they did wrong, either in code or in the handling of the issue? Is your first response to keep bugs away from you by demanding the other developer perform a work around? Do you refuse to help the other developer unless they show you absolute proof of a problem in order to avoid the burden of testing your own code? Are you willing to investigate an issue even if it might not be your issue? When you do pass an issue onto another developer, do you help them get up to speed or do you push the bug on without comment?
Other developers are relying on you to help them accomplish their goals. If you fight other developers to keep work away from yourself, you create more work for everyone. Your goal is not to keep problems out of your territory. Treat other developers well, and our team will flourish. Treat others with arrogance, and our team will fade away.

Personal responsibility:

When an error occurs inside of your code, does the error become visible or is your only goal to appear to be running correctly? Do you trace out information which will help determine the source or your bugs, information such as error codes? Does your code contain useful Asserts?
It can be ok for our code to crash if that crash exposes an issue. Programming “defensively” can get you into trouble. Our programming conventions tell us not to use catch-all exception handlers. When we “catch (Exception)” we're hiding bugs. Only catch exceptions that you understand and expect. Any exceptions you don’t understand are cases we haven’t planned for or bugs we need to fix. If a function returns an HR, trap this value and act upon it appropriately. As with exceptions, don’t attempt to run correctly if you don’t understand the error that was returned. A failing product that appears to operate correctly is harder to fix than a product that fails loudly.
We all been reminded to buddy build before checking in, but we need to go further. When you finish writing your code, how much testing have you done? Have you only used one system, or have you worked to consider a variety of environments? Have you attempted to make your code fail? Are you ignoring some failure conditions, hoping that they never occur in testing?

Is your code complete when you check it in? Do you do only the minimum required to complete your work items? Do you demonstrate honesty, or do you say you've completed your work knowing there are many holes left, placing the responsibility on the testers to solve your problems? Have you written unit tests to ensure the code behaves as you expect, and to ensure that if that if the coding begins behaving incorrectly you will know?

Conclusion

Take responsibility for your code. Find ways to fix problems, rather than finding ways to make your problem someone else’s problem. By doing so, you show respect for your coworkers, your product, and ultimately your customers.

Kurt Vonnegut died

David_Bennett — Fri, 13 Apr 2007 21:18:41 GMT

On April the 11th Kurt Vonnegut died, one of my favourite authors. He wrote amazing books and short stories, like Breakfast of Champions and Slaughterhouse Five. I remember the first time I read Slaughterhouse Five, it amazed me and surprised me. One of the few books I read and came out thinking that it really had some effect on things, it really made me think and was overall just amazing. It is a shame to think that he will no longer be making any more books, luckily I got to see him talk once when he was in Seattle a while ago. It was his last tour through the region I think.

His dark humour and beautiful writing style were always a pleasure to read. So it goes.

Apple (uk) ad targeting Parental Controls

David_Bennett — Wed, 11 Apr 2007 02:42:46 GMT

Just wandering around on you tube and discovered an apple (uk) ad targeting parental controls, with the 'naughty step'. The Mac says something about blocking items being "isn't that what kids want to do?". The idea behind parental controls is to block good kids from running into bad stuff, I don't really see the built in parental controls as being that limiting. It does what parents have been asking us to do for a long time, allowing an easy mechanism to control web content. For a first run at Parental Controls is does a pretty good and comprehensive job. There are some things which could be fixed, like allowing for a system for setting a number of hours a week someone is allowed to use the computer rather than just the specific times they could log on. Another useful feature would be remote administration of the controls, so a parent from work could unblock sites or games for children to play/look at. With this ad, apple is barking up the wrong tree especially since they have their own parental control features.

Still, apple like a good tree to bark up especially if they can make the tree look like something else.

Reading WPC logs in C#

David_Bennett — Fri, 30 Mar 2007 23:31:06 GMT

Here is a conversion of the WPCEvents.h file that is used with the vista SDK to get the parts of the various crimson events converted into c#. I have written about this file before and how the parts are connected together and how all the numbers work. This is useful if you want to write c# code to read/write WPC events.

It uses a set of enums to encompass all the values, the values are copied directly from the c++ headers.

using System;
using System.Collections.Generic;
using System.Text;

namespace WebCplHost
{
    /// <summary>
    /// The enums for the specific event ids.
    /// </summary>
    public enum WPCEvents
    {
        SettingChangeEvent = 1,
        GameStartEvent = 2,
        UrlVisitEvent = 3,
        EmailReceivedEvent = 4,
        EmailSentEvent = 5,
        MediaPlaybackEvent = 6,
        IMInvitationEvent = 7,
        IMJoinEvent = 8,
        IMLeaveEvent = 9,
        FileDownloadEvent = 10,
        IMFeatureEvent = 11,
        CustomEvent = 13,
        EmailContactEvent = 14,
        IMContactEvent = 15,
        AppBlockedEvent = 16,
        AppOverrideEvent = 17,
        WebOverrideEvent = 18
    }

    /// <summary>
    /// The indexes into the user settings for the setting chane event.
    /// </summary>
    public enum WPC_ARGS_SETTINGSCHANGEEVENT
    {
        CLASS = 0,
        SETTING,
        OWNER,
        OLDVAL,
        NEWVAL,
        REASON,
        OPTIONAL
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the AppBlockedEvent.
    /// </summary>
    public enum WPC_ARGS_SAFERAPPBLOCKED
    {
        TIMESTAMP = 0,
        USERID,
        PATH,
        RULEID
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the EmailReceivedEvent.
    /// </summary>
    public enum WPC_ARGS_EMAILRECEIEVEDEVENT
    {
        SENDER = 0,
        APPNAME,
        APPVERSION,
        SUBJECT,
        REASON,
        RECIPCOUNT,
        RECIPIENT,
        ATTACHCOUNT,
        ATTACHMENTNAME,
        RECEIVEDTIME,
        EMAILACCOUNT
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the EmailSentEvent.
    /// </summary>
    public enum WPC_ARGS_EMAILSENTEVENT
    {
        SENDER = 0,
        APPNAME,
        APPVERSION,
        SUBJECT,
        REASON,
        RECIPCOUNT,
        RECIPIENT,
        ATTACHCOUNT,
        ATTACHMENTNAME,
        EMAILACCOUNT
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the EmailContactEvent.
    /// </summary>
    public enum WPC_ARGS_EMAILCONTACTEVENT
    {
        APPNAME = 0,
        APPVERSION,
        OLDNAME,
        OLDID,
        NEWNAME,
        NEWID,
        REASON,
        EMAILACCOUNT
    }

    /// <summary>
    /// This is the values to use for the MEDIATYPE field in the
    /// WPC_ARGS_MEDIAPLAYBACKEVENT.
    /// </summary>
    public enum WPC_MEDIA_TYPE
    {
        OTHER = 0,
        DVD,
        RECORDED_TV,
        AUDIO_FILE,
        CD_AUDIO,
        VIDEO_FILE,
        PICTURE_FILE,
        MAX
    }

    /// <summary>
    /// This is the values to use for the EXPLICIT field in the
    /// WPC_ARGS_MEDIAPLAYBACKEVENT.
    /// </summary>
    public enum WPC_MEDIA_EXPLICIT_TYPE
    {
        FALSE = 0,
        TRUE,
        UNKNOWN
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the MediaPlaybackEvent.
    /// </summary>
    public enum WPC_ARGS_MEDIAPLAYBACKEVENT
    {
        APPNAME = 0,
        APPVERSION,
        MEDIATYPE,
        PATH,
        TITLE,
        PML,
        ALBUM,
        EXPLICIT,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the MediaDownloadEvent.
    /// </summary>
    public enum WPC_ARGS_MEDIADOWNLOADEVENT
    {
        APPNAME = 0,
        APPVERSION,
        MEDIATYPE,
        PATH,
        TITLE,
        PML,
        ALBUM,
        EXPLICIT,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMInvitationEvent.
    /// </summary>
    public enum WPC_ARGS_CONVERSATIONINITEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        REQUESTINGIP,
        SENDER,
        REASON,
        RECIPCOUNT,
        RECIPIENT
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMJoinEvent.
    /// </summary>
    public enum WPC_ARGS_CONVERSATIONJOINEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        JOININGIP,
        JOININGUSER,
        REASON,
        MEMBERCOUNT,
        MEMBER,
        SENDER
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMLeaveEvent.
    /// </summary>
    public enum WPC_ARGS_CONVERSATIONLEAVEEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        LEAVINGIP,
        LEAVINGUSER,
        REASON,
        MEMBERCOUNT,
        MEMBER,
        FLAGS
    }

    /// <summary>
    /// This is the flags to use in the MEDIA_TYPE setction of the WPC_ARGS_IMFEATUREEVENT
    /// when reading it out of the crimson logs.
    /// </summary>
    public enum WPCFLAG_IM_FEATURE : uint
    {
        NONE = 0x00,
        VIDEO = 0x01,
        AUDIO = 0x02,
        GAME = 0x04,
        SMS = 0x08,
        FILESWAP = 0x10,
        URLSWAP = 0x20,
        SENDING = 0x80000000, // Top bit means sending or receiving.
        ALL = 0xFFFFFFFF
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMFeatureEvent.
    /// </summary>
    public enum WPC_ARGS_IMFEATUREEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        MEDIATYPE,
        REASON,
        RECIPCOUNT,
        RECIPIENT,
        SENDER,
        SENDERIP,
        DATA
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMContactEvent.
    /// </summary>
    public enum WPC_ARGS_IMCONTACTEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        OLDNAME,
        OLDID,
        NEWNAME,
        NEWID,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the GameStartEvent.
    /// </summary>
    public enum WPC_ARGS_GAMESTARTEVENT
    {
        APPID = 0,
        INSTANCEID,
        APPVERSION,
        PATH,
        RATING,
        RATINGSYSTEM,
        REASON,
        DESCCOUNT,
        DESCRIPTOR,
        PID
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the FileDownloadEvent.
    /// </summary>
    public enum WPC_ARGS_FILEDOWNLOADEVENT
    {
        URL = 0,
        APPNAME,
        VERSION,
        BLOCKED,
        PATH,
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the UrlVisitEvent.
    /// </summary>
    public enum WPC_ARGS_URLVISITEVENT
    {
        URL = 0,
        APPNAME,
        VERSION,
        REASON,
        RATINGSYSTEMID,
        CATCOUNT,
        CATEGORY
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the CustomEvent.
    /// </summary>
    public enum WPC_ARGS_CUSTOMEVENT
    {
        PUBLISHER = 0,
        APPNAME,
        APPVERSION,
        EVENT,
        VALUE1,
        VALUE2,
        VALUE3,
        BLOCKED,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the WebOverrideEvent.
    /// </summary>
    public enum WPC_ARGS_WEBOVERRIDEEVENT
    {
        USERID = 0,
        URL,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the AppOverrideEvent.
    /// </summary>
    public enum WPC_ARGS_APPOVERRIDEEVENT
    {
        USERID = 0,
        PATH,
        REASON
    }
}

Log Viewer, behind the scenes

David_Bennett — Sat, 03 Mar 2007 02:04:48 GMT

The log viewer in Parental Controls reads in the public available system logs and turns them into the data you can see in the control panel. The logs are brought in from a couple of places, the System logs, the Application logs and the Parental controls log itself. These logs are manipulated in various ways to find the information in the viewer itself.

I am not documenting the event numbers for the parental control log itself in this post, since this information was posted up on my blog previously.

The web, im, email, media, system clock changes, account changes and changes to settings logs are all 1 to 1 correspondants into the logs itself. One entry in the log file ends up being one entry in the log viewer.

The Applications run log is generated by reading the applications log and matching start PIDs with end PIDs to find the duration the app ran for. These are then cached as well so that the game events can use this information to get the durations for their logons. It uses the events SE_AUDITID_ETW_PROCESS_CREATED and SE_AUDITID_ETW_PROCESS_EXIT to do the matching.

The game log uses the parental controls game event, which logs a PID the game ran as. This PID is then looked up in the stored list of apps run from the application log to match the time it ran for. The system looks for logs that are close to the time the game started with the right PID.

Logon times are generated from the system logs, matching the login times with the logoff times. The logon events are logged with a LOGONID which can be matched in the both of the events to make sure you have the right logon and logoff event to get the times right. This also deals with cases where there are overlapping logons (runas counts as a logon event). This uses the events SE_AUDITID_ETW_BEGIN_LOGOFF, SE_AUDITID_ETW_LOGOFF and SE_AUDITID_ETW_SUCCESSFUL_LOGON. It uses two log off events because windows generates one of them in some cases and one in the other.

Failed logon attempts are filtered to display the correct output. WIndows generates a failed login attempt every time someone opens up the control panel and looks at the user list and every time someone opens up the parental controls panel, viewing the hub page. This is because the way to check for blank passwords is to try and login with a blank password. So the the logs are filtered to try and find the failed logins that are not generated by the various control panels and are real failed login attempts. This problem should be addressed in the next version of windows, adding an API specifically to find if the password is blank or not. The logon failures are logged into the system log with the log id of SE_AUDITID_ETW_LOGON_FAILURE.

The account changes are not manipulated, but the logs of the type SE_AUDITID_ETW_USER_CREATED, SE_AUDITID_ETW_USER_DELETED, SE_AUDITID_ETW_USER_DELETED and SE_AUDITID_ETW_LOCAL_GROUP_REM are processed to find which users are added/deleted as well as which users have been added into the administrators group.

Parental Controls used by everyone

David_Bennett — Wed, 21 Feb 2007 21:54:00 GMT

Looks like Bill Gates is using parental controls for his children these days, nice to see that people within the company are buying off and using the technology as well. We have had a surprisingly small amount of negative press on the parental controls issues so far. Seems to be one of the things that people really like in Vista.

A tale of Two Cockies

David_Bennett — Wed, 21 Feb 2007 10:20:00 GMT

This is a nifty site with an interesting story.

Parental Controls and Press Coverage

David_Bennett — Sat, 10 Feb 2007 00:37:59 GMT

We have had a lot of good press coverage from Parental Controls over the past few days, which has been great. Bill Gates and various other people have been pressing it as one of the main reasons to upgrade to Vista, I think it is a very good reason to upgrade if you are worried about your children's safety on the net. The system provides a lot of useful easy controls to make it easier to make sure your child is safer. Of course no system is completely fool proof and there will always be some things that have not yet been plugged up.

The New York Times says "But some of the most powerful new features in Vista are not for hard-core players at all. Instead they are aimed at casual players and, most important, at families. It is not overreaching to say that if you have young children who play computer games or use the Internet you are basically remiss if you do not upgrade to Vista as soon as possible.", which is a nice endorsements of our product.

While most of all the press on the subject has been good, there have been a few negative pieces on the web here and there. There were the comments I talked about previously about the system feeling overwhelming for a parent to use, although really I don't think this is the case for most of what the system does. There is also the stuff Alex St John has written about vista and parental controls. He does make some reasonable points, it is true that ESRB licensing is expensive and not likely to be obtained for downloadable content. This is being fixed though, by ESRB, so that downloadable games can be rated in a reasonable fashion. His comments on the elevation dialog are silly, you want the system to ask if you really want to install something. It should be saying this, since otherwise it might be installing something you don't want it to (like spyware). It is also possible to set the rating on each game seperately so you don't need to use the rating system to achieve this. This article covers the points he brings up quite well too.