Nonetheless, I thought that since I’m here anyway, I may as well give a brief summary of what is going on and what I have planned – albeit not very exciting plans. If you’re still reading this, I suggest you take up a hobby. I digress…

The Past

While my original plan involved writing a crap ton of technical articles and creating other content-related thingies, I had diverged slightly…and fell off the face of the planet. I had try to revive my motivation by posting a “Haha, how about them content?” post back in February but things/life kind of got in the way (I apologize, Internet). I had silently buried the existence of this website to the back of my mind thinking, no…believing it would update itself automatically. Imagine my surprise when I found that wasn’t how blogs work at all…

Sometime around the middle of March, I had joined TiVo as a Sr. Software Engineer and had been spending a lot of my personal time warming up to their rather complex build and development environment. Also, due to things like NDAs and mechanical heat-seeking lawyer grenades, work isn’t something I can blog too much about. Like, I can’t tell you about things such as the Make Dinner feature we’re…oh…oops…

The Present

Now that things are mellowing out a bit, I’ve been doing a bit of weekend/after-work tinkering again. While I admit that I’ve been a bit disorganized with what I’ve been focusing on, my plan is to create a workflow that I can start following. One of those tasks will involve dedicating time to updating my blog – hopefully with actual content and not just “hah, yeah…I’ll write content someday…you’ll see…”

Okay, I may have also played a few video games on the weekend. (Replaying Half Life 1/2).

The Future

Sometime between now and the Great Robot War, I plan to do the following:

• Create a workflow which will allow me to organize my personal time.
• Document what I’ve been working on in my blog (I may have said this before…).
• [write step 3].

My first project which I plan to document here will be Elixir – my virtual/theoretical CPU architecture. I’ve already written the datasheet (which I’ve been cleaning up a bit recently) and I’ll be posting updates about my progress with the assembler and compiler.

Anyway, here’s to me maybe, possibly updating this blog and doing what I said I will. Cheers.

I doubt that anybody besides people Googling my name will read this, the least I can do now is show some signs of life.

Download Example

• Visual Studio 2005 Project (ZIP File: 33,789 bytes)
• Example Binary (ZIP File: 19,414 bytes)

Refresher: Resources

You can embed just about anything into an application’s resource area, and fonts are no exception. Once added, the resources are readily accessible (read-only) from the application’s strongly-typed Properties.Resource class generated for you by the compiler. The resource class nativity supports strings, images, icons, audio, files and any other binary data (like fonts) and will allow you to access it through .NET’s System.Drawing.Bitmap, System.String, System.IO.Stream and System.Byte[] types. You can read more about adding and editing resources on MSDN from here.

Since .NET does not make the connection between a font file and System.Drawing.Font object for you, there is a bit of work required so that we can turn the resources into a usable font.

System.Drawing.Font

In .NET 2.0, the System.Drawing.Font object has 13 different constructors. You will very quickly realize that none of them accept a file path or a byte array of a font file (which is what we currently have from the resources class). Upon closer inspection of the Font class, you will also realize some static functions allowing you to create a font instance from a device context, Windows handle or from a Logical GDI structure – all of which is of no use to us.

The problem is that the Font class can only access fonts which have been “installed” on the user’s system. This means that Windows needs to have the font registered internally for it to be accessible to applications. What we need to do is to get our font, in the application resources, temporarily “registered” with Windows. Luckily, Windows has a Win32 function (in gdi32.dll) called AddFontMemResourceEx which allows us to do just that.

Registering the Font

Since .NET does not natively have the functions we need to call, we’re going to need to import them from the gdi32 DLL by using P/Invoke. We’re going to be using AddFontResourceEx to register the font, and then RemoveFontMemResourceEx when we’re ready to clean up (discussed later).

using System.Runtime.InteropServices;
 
...
 
[DllImport("gdi32")]
private static extern IntPtr
 AddFontMemResourceEx(IntPtr pbFont,
 uint   cbFont,
 IntPtr pdv,
 [In] ref uint pcFonts);
 
[DllImport("gdi32")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool
 RemoveFontMemResourceEx(IntPtr fh);

In our Windows Forms application, the best place to initialize the custom font(s) is from the class constructor of the main form used in the application. From here, we’re going to need to do a couple of things:

• Create a new System.Drawing.Text.PrivateFontCollection instance which will store our dynamically-loaded font(s).
• Tell the garbage collector to pin down the font’s binary data in memory so Windows can access it from outside our .NET managed bubble.
• Add the font handle to our private font collection (in memory).
• Register the font with Windows using the AddFontMemResourceEx function call.

The following code demonstrates the above description:

using System.Drawing;
using System.Drawing.Text;
 
...
 
/* Member Variables */
private PrivateFontCollection m_PFC;
private GCHandle              m_pFont;
private IntPtr                m_hFont;
 
...
 
// Somewhere called from the form constructor...
m_PFC = new PrivateFontCollection();
 
int  rsxLen  = Properties.Resources.ClientFont.Length;
     m_pFont = GCHandle.Alloc(Properties.Resources.MyFont, GCHandleType.Pinned);
     m_PFC.AddMemoryFont(m_pFont.AddrOfPinnedObject(), rsxLen);
uint rsxCnt  = 1; /* We're only installing one font. */
 
// This is where we do the actual "registration" to get the font handle
m_hFont      = AddFontMemResourceEx(m_pFont.AddrOfPinnedObject(),
                                    (uint)rsxLen, IntPtr.Zero, ref rsxCnt);

In this example, we’re just going to register a single font called MyFont from the application resources class. To add multiple fonts, we would just need to create a font handle to each font we wish to add, create a pinned GC handle to it, add it to the private font collection and register it using AddFontMemResourceEx. Lather, rinse, repeat.

Creating the Font

Now that Windows knows about our custom font, all we have to do now is create a System.Drawing.Font instance of it so we can use it in our form controls (and whatever else). The private font collection allows us to iterate over all the System.Drawing.FontFamily objects available from the font(s) we’ve added. It is important to note that since not all fonts support all font styles (Regular, Bold, Italic, etc), we have to make sure the font we’re going to create supports the style we wish to use – otherwise, we’ll end up with a default fallback font.

The following code demonstrates how we can create a font we registered from the previous example:

...
 
/* Member Variables */
private Font m_Font;
 
...
 
FontFamily ff = m_PFC.Families[0]; /* I know, bad practice. */
if (ff.IsStyleAvailable(FontStyle.Regular))
{
    m_Font = new Font(ff, 7f, FontStyle.Regular, GraphicsUnit.Point);
}
else
{
    // ...cry...
}

Now that we have an instance of System.Drawing.Font, we can pass this into any control and presto-chango, our font should show up:

Clean Up

Before the application exits, it is important to properly dispose of any unmanaged handles we were using. Remember the RemoveFontMemResourceEx function mentioned earlier? This is where will will be using it. The following example demonstrates the very simple clean-up process:

protected override void Dispose(bool disposing)
{
    #region Release Managed
    if (disposing && (components != null))
    {
        components.Dispose();
    }
    #endregion
 
    #region Release Unmanaged
    m_PFC.Dispose();
    m_pFont.Free();
    RemoveFontMemResourceEx(m_hFont);
    #endregion
 
    base.Dispose(disposing);
}

First we dispose of all the managed components (as usual) and then we clean up the objects we allocated for the font(s). We just dispose of the private font collection, the GC handle to the font data and finally remove the font handle from memory (unregistration). Not much to it at all.

Credits

Barcode Font: Anke Arnold – www.anke-art.de

Firefox, Not So Safe

As Firefox becomes more prevalent, so do the exploits. Going back a few years, it wasn’t hard to entice us all with a browser that did such nifty tricks as stopping pop-up advertisements, not being so laughably exploitable and just plain performing faster. There were a few performance and security hiccups along the way, but overall, we were happy.

Early on, exploiting Firefox was left to hacker conferences where large bearded men with Linux laptops wrote complex proof-of-concept hacks to break through the boundaries of Firefox and System. Fundamentally, however, even the average user was safe from himself with Firefox. As popularity grew, malware authors began to take notice.

Browser development is akin to operating system development. It is terribly complex and tedious to develop. Just breaking into the market is difficult enough – even as I write this, a television somewhere is playing a Google Chrome ad. As complexity grows, so do the vulnerabilities – and someone, somewhere will have time/incentive/moral ambiguity to find and exploit them. The more eyes you have searching, the faster this process becomes.

Unfortunately, Firefox wasn’t written by cybernetic foxes from future. No, they were written by fallible humans who have had gone to bed at 5am the previous night because they had ran out of coffee. As a result, bugs and vulnerabilities are bound to occur. And while the Mozilla team are very good about releasing frequent patches, there always seem to be something else.

The Infection

The latest Firefox exploits I’ve seen come from JavaScript, Java and sometimes obscure things you wouldn’t expect like GIFs, PDFs and Flash. The malware my fiancee’s system encountered, however, likely came from a JavaScript exploit. Although I am uncertain of the exact means her machine became infected, the immediate sign was unmistakable:

A program that suddenly appears on the screen claiming to be a virus scanner…which you didn’t install…is a pretty good indication you’re system has been compromised. But, as it turns out, this was just one of the many friends the original virus invited to join the party. Overall, her system became infected with 18 different virus and virus traces, according to the initial real malware scanner used.

So, what now?

Short of ripping out the network card and ceremoniously launching it into the sun, the best thing to do now is to enact some preventive measures. But finding the balance between crippling the user experience and not doing enough is a difficult task indeed. What are the options?

Disable Java. This is simple enough and not all too inconvenient as not too many sites directly use Java to serve content. If there is a site I know that requires it, and it is a site I trust, it is easy enough to turn it back on.

While tempting, disabling JavaScript is out of the picture. Thanks to Web 2.0, there are very few sites (especially community and media-heavy) that will work (properly, if at all) without JavaScript. The alternative is to install the [terribly inconvenient] NOSCRIPT Firefox plug-in. Even though it is better than nothing, there are still ways around it as it too has vulnerabilities.

If you’re good at staying away from the seedier parts of the Internet, you still have to worry about well-known sites being compromised either by getting entirely hacked or having one of their ad networks compromised or going rogue. To further secure your browser, Flashblock will disable any Flash animation until you click on it (which is also good for getting rid of some truly annoying and sometimes noisy ads).

With those plug-ins (and some common sense), you’re likely in good shape. By diminishing the ability for client-side execution of just about anything (which mostly includes Java, JavaScript and Flash), you’re chances of picking up drive-by-downloaded malware also diminish. If you absolutely must visit a questionable site, use a virtual machine.

Topic Hierarchy

I wanted to partition the blog into different top-level categories where each category is tied to the page being viewed. You’re currently reading this post under the “Home” category’s General topic group. If you were to switch to the projects or articles page, you’ll only see the posts under their respective top-level category pages (Projects & Articles). So, this makes the site map look somewhat like this:

Home: Typical blogging topics, such as general, news, politics, technology, etc.
Projects: Project “micro-blogs” for each project I’m working on.
Articles: My professional opinion/insights into the various technical topics I’ll be writing about.

Demographic

Primarily, this is a technically-oriented blog. As such, I will be posting a lot of heavy-duty technical information aimed at software engineers. With that said, this is also my personal blog, so I will be posting about not-so-technical opinions and articles here (including politics). Buyer beware, I’m liberal-minded and I share many of the views of my fellow liberal, left-wing thinkers – not saying I don’t have an open mind, though. So, if you like any of these kinds of topics:

• Computer Technology (Hardware, Software).
• Software Engineering.
• Robotics.
• Politics.
• Lime-Jello.

…you may like this site.

I’ve created this website for three reasons: 1) Enhance the Googability of my name for employment, fame, fortune and free candy, 2) have a place where I can write articles that, maybe, some people may find useful, and 3) have a place to share my projects.

Well, now that we have become acquainted, Internet User, hopefully my efforts will prove to bring you back for more. Or something.