Let me tell you, this has been one huge educational experience that never seems to end. My server is now running my LAN’s internal DHCP and DNS. It’s also a game application server, an internal samba file server, and an internal and external web server.

One of the things apps like WordPress, PunBB, and other content systems use is email. I’ve already discussed in the past how to make sendmail in Linux play nicely with Apache and PHP, but I realized that things were changing as I started migrating our websites and projects to an entirely different environment - Windows Server 2008 R2 Enterprise and IIS 7.0. There are some growing pains, but at least it gives me a lot to write about!

Anyhow, I realized shortly after the migration of Dan’s game servers (and related websites) that the server wasn’t sending mail. Since, you know, I hadn’t set up an SMTP service in Windows. “So what?” I thought to myself, “I’ll just install it and everything will be hunky-dory, right?”

Wrong.

It turns out that in 2009, every large mail service provider on the Internet really hates relaying email that comes from suspicious locations, including IP addresses that are part of residential ISPs. Even though we have a static IP address through Verizon Business, it’s still part of Verizon’s greater IP pool - which includes all their dynamic IPs for residential FiOS and DSL services.

Google blacklisted me the second I tried to send a message to an @gmail.com address. It was just downhill from there. I found out from some people on IRC that I needed a reverse DNS entry if I wanted anyone to relay my email, so I called up Verizon and got that taken care of. Yahoo, MSN, and AOL started relaying my mail, but Google kept delaying delivery, claiming that an “unusual amount of unsolicited email” was coming from my IP address.

After many hours on IRC and doing additional research on Google, I decided it probably wasn’t worth it to keep wrestling to make the big mail servers of cyberspace deem my rinky-dink little server worthy of their approval. It was time to look for other solutions.

I decided right from the start that I did not want to deal with hosting mail. I have no interest in trying to mitigate mass quantities of spam. My friend Julie over The Gadgeteer got on the Gmail Apps boat and moved her own email over to Google. It seemed appealing enough, so I decided to give it a shot. Google Apps offers a free version to cheapskates like me who can’t or don’t want to pay yet another monthly fee. The free version includes Google mail, calendar, sites, chat, and docs. Works for me!

Google was brilliant about the whole thing. I signed up, and when I clicked in the web-based control panel to set up email, it automagically discovered that my domain (polatrite.com, in this case) was registered with 1and1.com, so it directed me to a 1and1-specific how-to on setting up the MX records for my domain. About 18 hours later, 1and1 and Google had both updated their servers and records, and I was in business. Now it was time to figure out how to make my web server send email through Google’s SMTP servers.

Which is why we’re here today. If you’re still paying attention, that is. As always, this is a little screenshot-heavy, so hit the jump to carry onward.

First off, if you haven’t already, you need to install the SMTP service in Windows. Start by opening up your Server Manager. Click on Features in the lefthand pane, and then “Add Features”:

Make sure that both SMTP Server and SMTP Server Tools are checked. Windows, being the wizard-happy operating system that it is, will walk you through the steps to install SMTP, including installing any dependent services you may need. Once that’s done, we can continue to actually making your mail route through Google’s servers.

The SMTP standard allows for something called smart hosting. Essentially, an SMTP service set up with a smart host actually sends its mail to another SMTP server, which then relays the mail from there into the scary unknowns of cyberspace. This is exactly what I needed - by relaying my mail through Google’s servers, the outside world would see my mail as Google-sent, and nobody in their right mind is going to block Google mail (theoretically).

Before we can set up our server, we need enable IMAP in Gmail. Login to the Gmail web interface, and click Settings in the top right corner of your browser window. Select the Forwarding and POP/IMAP settings tab, and make sure Enable IMAP is selected. If it’s not, select it and save your changes.

Now that we have permission to access our mail outside of Google’s web interface, we can set up the server.

The SMTP service available in Windows Server 2008 is actually managed through IIS 6.0, not 7.0. Fire up the IIS 6.0 manager by going to Start > Administrative Tools > Internet Information Services (IIS) 6.0 Manager. Under your server, you’ll see a little hideous 16-color envelope icon. This is your SMTP virtual server, which IIS uses to send mail. Right-click on it and select Properties.

Click the Delivery tab, and then the Outbound Security… button. We want Basic Authentication. Enter your Google account credentials, and make sure TLS Encryption is enabled, since Google’s SMTP servers require SSL.

Click OK, then the Advanced… button on the same tab. Here’s where we set up our smart host that our own SMTP service will use to relay email. Enter the domain of your site under Fully-qualified domain name, and use smtp.gmail.com as the smart host.

Click OK. Now we’re going to enable logging, which will be critically important to ensure that your email is being accepted by receiving SMTP servers. Click the General tab. Make sure the Enable logging box is selected, and choose your log format. I’m not all that well-versed on what the different formats are. “Microsoft IIS Log File Format” has been working fine for me. Click Properties… next the log format drop-down to choose where your logs are going to reside. Click OK.

Double-check everything, and click OK to apply your new settings. I went ahead and restarted the SMTP service, just to make sure that everything was working correctly.

Now you can test your server and see if everything is working. I made a simple ColdFusion page that sent a test message to Gmail, AOL, Yahoo, and MSN (just to double-check!). It worked perfectly.

But…wait! Even though I had set the “from” parameter of the cfmail tag to come from my Gmail address, Google overrode this and used my polatrite.com email address as the “from” address in the message header. I don’t want all my websites sending mail from this one address! A Better Geek and Polatrite Gaming are two completely different entities, so I needed to remedy this right away.

Never fear, Google is here to save the day! Gmail has this neat feature, available in normal Gmail accounts and Google Apps accounts, that allows you to send mail from other mail accounts right from inside the Gmail web interface. It’s easy to set up, and it works well.

Log back in to your Gmail web interface, and go back to your settings. Navigate to the Accounts settings page. Select Add another email address you own in the Send mail as section, which will pop up a new window. Enter the name and email address you want to display on mail sent from this account.

On the next page, select to send the mail through the secondary address’s SMTP servers. It’s important to keep in mind that this will only work for email accounts that have given you permission to send mail externally (e.g. not through the webmail interface) - Yahoo and MSN/Live do not provide this functionality for free email accounts. However, all Gmail accounts and Google Apps accounts allow for external SMTP access. Enter smtp.gmail.com as the SMTP server, select port 465 or 587, and make sure Always use a secure connection (SSL) is enabled. Enter the username and password for this secondary email account, and click Add Account.

After you’ve added your account, Google will email that address with a confirmation message. Click the link in that email to validate that you are authorized to use it, and Google will enable that account in Gmail. Once your second account is activated, you can send mail from your websites with this second email address as the “from” address, and Google will send it accordingly.

Google does have some limitations on what is allowed with the free version of Google Apps, and it’s important to keep this in mind for your websites. A single message can have a maximum of 100 recipients. Additionally, you can send mail to a total of 500 recipients per day. If you have a very active server, you’re probably going to be better off running your own mail server or paying for a larger-scale male service (Google Apps Premier allows up to 2000 recipients daily), but for small-time stuff like I’m managing, this is going to work just fine. I’ll still try to get my server off Google’s mail blacklist so that I can eventually use my own SMTP server, but in the meantime, this is a fast and easy way to get Windows ready to go for sending mail through web applications.

Life is busy, work is extra busy, things are moving at a fast pace…so ABetterGeek has gone by the wayside a bit. Don’t worry; I’ll post soon.

Before the end of 2009, at least.

Fortunately, I discovered that Purdue has a deal with AT&T, so I was able to get 20% off both the voice and data portions of my wireless plan. I knew I wanted a smartphone, and after playing around with the options, there was no denying that the iPhone beat the competition in usability, speed, and general awesomeness.

After I bought my 60GB iPod Photo in 2004, I swore up and down that it was the last Apple product I would buy new - yet here I am, with a shiny new iPhone. So sue me…things change.

Anyhow, I’m big on hacking and tweaking my stuff. My last Verizon phone was a Motorola V325, and I hacked the hell out of it to make it work how I wanted. Naturally, I jailbroke my iPhone within 24 hours of my purchase, so that I could better customize stuff like sounds and the UI.

I’ve been using one of the themes from Super Mario World for the past five years on each of my phones, so I knew I wanted to upload it to my iPhone. Turns out that adding ringtones takes a little work, but it can be done - for free, and with free software. iTunes will only let you create ringtones from songs you’ve downloaded from the iTunes Store. I’m going to show you how to create ringtones from any audio file, whether it’s WAV, MP3, AAC, or anything else.

First off, you need Audacity. This is a free, open-source sound editor that’s been around for awhile. You want to make sure to get the latest beta version, as it includes support for exporting to AAC (.m4a) format. Once you have Audacity, you also need to get the ffmpeg libraries, which will support exporting to multiple formats (including AAC). If this link is dead, try the version here.

You’ll notice that the file format of the downloaded libraries is a little odd (the second link will take you to a .7z version) - if you don’t already have it, 7-Zip will allow you to extract the files. Once you have the files extracted, copy them into the Plugins directory of your Audacity program folder - it should be something like C:\Program Files\Audacity 1.3 Beta (Unicode)\Plug-Ins.

If you want to make MP3 ringtones for phones other than the iPhone, you need the LAME libraries, available here.

Now you can load up Audacity (it’s in your Start Menu once you’ve installed it). The first thing you need to do is tell it where the ffmpeg libraries reside. Click the Edit menu, and select Preferences. Go down to Import/Export, where you’ll see a box about ffmpeg in the top left corner:

Click Find Library, and browse to the Plugins folder where you extracted the files. You’ll see that a single dll appears - click it, and click Open. You’ll now see something like this:

Now that Audacity is set up for exporting to AAC, we can start making our ringtones. It’s pretty screenshot-heavy, so click the jump to see the rest.

First, find a song you want to use for your ringtone. For this example, we’ll be using “Never Let You Go” by Third Eye Blind.

Your ringtone should be no longer than 40 seconds, so we’ll use Audacity to select a portion of the song. To open a file, either drag it into the Audacity window, or use the File > Open command. When you import an MP3, Audacity will automatically convert it so you can edit it:

Once it’s done importing, click the play button to start playing your song. Watch the vertical progress line to see where you want to crop down the track. For instance, I wanted to only use a part near the end of the song, rather than just the first 40 seconds of the track. The progress bar is a vertical line with an arrow at the top:

Once you’ve figured out what part of the song you want to use, highlight it with your mouse. If you need to be more precise, use Ctrl+1 to zoom in. You can see here the dark gray selection highlight from 0 to 25 seconds:

Once you’ve selected the portion of the track you want to use, copy it (Ctrl+C), open a new file (Ctrl+N), and paste it in (Ctrl+V).

You probably don’t want your song to just abruptly cut off, so you can fade it out at the end. Select the last five or ten seconds or so of the clip, and go to Effect > Utility > Fade Out.

You’ll see the selection taper off as the volume decreases. You can reapply this filter if you want it to fade out even more. Once you have your song edited how you want, you can export it to AAC. Just go to File > Export and select M4A (AAC) Files (FFmpeg) from the “Save As Type” drop-down:

Save your file. You’ll want to remember where you put it, so that you can import it into your iPhone.

iPhone ringtones are actually just M4A files with a different extension. Find your file in My Computer or Windows Explorer, right click on it, and click Rename. Change the file extension to .m4r. You’ll notice that the file type in Explorer’s detail view calls it a Ringtone:

Now, just drag the file into the Ringtones section of your iTunes library.

Assuming you already have iTunes configured to sync with your iPhone, you can now just drag the newly imported file onto your iPhone, and it will sync and be available in the ringtone selection preferences pane.

If your song seems a little distorted when your ringer volume is at maximum, you can try dropping the overall volume by a few decibels, using the Normalize utility under Effect > Utility > Normalize:

There’s no real magic number; it’s just a matter of trial and error to figure out what sounds best to you.

Getting MIDI files into the proper ringtone format takes a little more effort - I’ll show you how to do that next time!

This is accomplished by way of a fancy little bit of PHP. The image generation uses the GD library (with FreeType support), and the fonts are all TrueType.

Again, since my Linode didn’t come with anything preinstalled, I needed to install GD first. It seemed like it might be a bit of a pain - the PHP manual page indicates I was going to have to recompile PHP. Fortunately, this was not the case.

I just had to download it from Ubuntu’s package manager…

apt-get install php5-gd

…and add it to the “extensions” section of php.ini…

nano /etc/php5/apache2/php.ini
 
extension=gd.so

…and restart Apache.

apache2ctl -k graceful

Once that’s out of the way, creating the image was remarkably simple - especially since I found a ready-made script that did exactly what I wanted.

The code is pretty long, so hit the jump to see the rest.

Here’s the actual script,  broken down into sections:

First, we tell the browser that this page is a PNG image. This line needs to come before any other code, or else you might start seeing errors.

Next, we create a class with all the values we want to use for our image, except for the font and text.

$transparent tells GD to create a transparent image, so that it can be used against any background. The first set of RGB values indicate the color of the text, and the second set is for the background color, in order to antialias the text. I selected a shade of green in the same area of my header gradient where the text appears, and it blends in pretty smoothly.

<?
  Header("Content-type: image/png");
 
  class textPNG {
    var $size = 20;
    var $rot = 0; // rotation in degrees
    var $pad = 0; // padding
    var $transparent = 1; // transparency set to on
    var $red = 255; // text colors
    var $grn = 255;
    var $blu = 255;
    var $bg_red = 110; // background colors
    var $bg_grn = 218;
    var $bg_blu = 110;

Next, we write the function that will actually create the image, starting out with some empty variables. The two variables that are passed to the function ($foo and $font) are going to give us the text to display, and the font file to use.

    function draw($foo, $font) {
      $width = 0;
      $height = 0;
      $offset_x = 0;
      $offset_y = 0;
      $bounds = array();
      $image = "";

Now we need to figure out how big the image should be. First, we determine the height of the text based on a capital “W”. This will work for most fonts, but some of the handwriting ones I use in my tagline image have unusually tall characters, so I ended up manually specifying the height (e.g. $font-height = 55;).

      // determine font height.
      $bounds = ImageTTFBBox($this->size, $this->rot, $font, "W");
      if ($this->rot < 0) {
        $font_height = abs($bounds[7]-$bounds[1]);
      } else if ($this->rot > 0) {
        $font_height = abs($bounds[1]-$bounds[7]);
      } else {
        $font_height = abs($bounds[7]-$bounds[1]);
      }

Then we determine the width and the vertical and horiztonal coordinates for the bottom left corner of the text. I ended up setting the $height variable to a specific value.

      // determine bounding box.
      $bounds = ImageTTFBBox($this->size, $this->rot, $font, $foo);
      if ($this->rot < 0) {
        $width = abs($bounds[4]-$bounds[0]);
        $height = abs($bounds[3]-$bounds[7]);
        $offset_y = $font_height;
        $offset_x = 0;
 
      } else if ($this->rot > 0) {
        $width = abs($bounds[2]-$bounds[6]);
        $height = abs($bounds[1]-$bounds[5]);
        $offset_y = abs($bounds[7]-$bounds[5])+$font_height;
        $offset_x = abs($bounds[0]-$bounds[6]);
 
      } else {
        $width = abs($bounds[4]-$bounds[6]);
        $height = abs($bounds[7]-$bounds[1]);
        $offset_y = $font_height;
        $offset_x = 0;
      }

The last bit of our function generates the actual image, using the imagettftext function of the GD library.

      $image = imagecreate($width+($this->pad*2)+1,$height+($this->pad*2)+1);
 
      $background = ImageColorAllocate($image, $this->bg_red, $this->bg_grn, $this->bg_blu);
      $foreground = ImageColorAllocate($image, $this->red, $this->grn, $this->blu);
 
      if ($this->transparent) ImageColorTransparent($image, $background);
      ImageInterlace($image, false);
 
      // render it.
      ImageTTFText($image, $this->size, $this->rot, $offset_x+$this->pad, $offset_y+$this->pad, $foreground, $font, $foo);
 
      // output PNG object.
      imagePNG($image);
    }
  }

Now we set variables based on the values specified in the original class we created.

  $text = new textPNG;
 
  if (isset($msg)) $text->msg = $msg; // text to display
  if (isset($font)) $text->font = $font; // font to use (include directory if needed).
  if (isset($size)) $text->size = $size; // size in points
  if (isset($rot)) $text->rot = $rot; // rotation
  if (isset($pad)) $text->pad = $pad; // padding in pixels around text.
  if (isset($red)) $text->red = $red; // text color
  if (isset($grn)) $text->grn = $grn; // ..
  if (isset($blu)) $text->blu = $blu; // ..
  if (isset($bg_red)) $text->bg_red = $bg_red; // background color.
  if (isset($bg_grn)) $text->bg_grn = $bg_grn; // ..
  if (isset($bg_blu)) $text->bg_blu = $bg_blu; // ..
  if (isset($tr)) $text->transparent = $tr; // transparency flag (boolean).

These next two sections are specifically for my application, with a random tagline and font file. First, we read the text file and create an array, using each line as an array element. Then, we select a random element from the array and set it to a variable. The text file is stored in the same directory as the PHP page.

  //get a random tagline from the text file
  $fname = file_get_contents('tags.txt');
  $tagarray = explode("\n", $fname);
  $tagnum = count($tagarray)-1;
  $line = $tagarray[rand(0,$tagnum)];

Second, the directory of fonts is read, and a random one is pulled from the list. You need to make sure to have the ./ before the directory and filenames (assuming your font directory is a subdirectory of your PHP page).

  //get random font from ttf directory
  $dir = opendir("./ttf/");
  $i = 0;
  while($theFile = readdir($dir)) {
    if($theFile != "." && $theFile != "..") {
      $array[$i] = $theFile;
      $i++;
    }
  }
 
  closedir($dir);
  $fontnum = count($array)-1;
 
  $ttfLine = $array[rand(0,$fontnum)];
 
  $ttf = "./ttf/" . $ttfLine;

Finally, we invoke the function to create the image, passing to it both the tagline and the font file.

  //draw the image
  $text->draw($line, $ttf);
?>

Now, this is a little modified from the original code. The code has the font and text variables set to static values. I wanted my code to randomly select both a font file and a tagline, so I stuck a bunch of fonts in a folder called ttf, and created a file named tags.txt with several taglines.

The ttf directory and tags.txt are both located in the same directory as the PHP file containing this code. Each tagline is on a separate line in the text file, so the loop looks for line breaks to indicate individual taglines.

You can call to the image just like you would any normal image file:

#tagline {
  background: url(img/tagline.php) no-repeat;
}

You’ll quickly discover that since IE 6 doesn’t support transparent PNGs, your image won’t look very good. This is easily solved with a little hack that I discovered at twinhelix.com. I couldn’t get the repeating background feature of the beta version to work properly, but it worked beautifully for this generated image.

IE 7 and up support transparent PNGs natively, so you only need to apply this for IE 6 and 5.5. If you’re already properly identifying the client browser and adding the appropriate stylesheet, this is a breeze.

The possibilities for this script are pretty endless, and it can be tweaked to meet your specific needs. Happy coding!

Let me know what you think, if you find something broken, etc.

One of the neat features is the ability to add and remove plugins from the web interface. Unfortunately, WordPress only works with FTP and FTPS (FTP over SSL) by default. I don’t have an FTP server installed on my Linode, so I decided to see if I could use SSH instead.

Turns out it’s possible, but it sure was a beast to get up and running. I’ll go through what I did, in case anyone else had as much trouble with this as I did.

First off, you need to install PEAR. This is a nifty little utility that can automatically compile PHP extensions.

Keep in mind that I’m working in Ubuntu 8.04.1 here, and my Linode installation is very stripped down.

First, you need to install the command-line interface for PHP, which allows you to run PHP scripts from a terminal.

apt-get install php5-cli

Seeing as my installation of Ubuntu is devoid of pretty much any extras, I needed to install wget too.

apt-get install wget

Once that’s done, we can install PEAR.

cd /
wget http://pear.php.net/go-pear -O go-pear.php
php go-pear.php

Once the PEAR installation script is running, you need to configure the locations of each of the components. I chose to stick everything in /pear, but you may want to put it somewhere else. I’d recommend keeping option 3 to my setting, though.

1    /
2    /pear/temp
3    /bin
4    /pear
5    /pear/docs
6    /pear/data
7    /pear/tests

Now that PEAR is installed, we can get into installing OpenSSL and the necessary packages to make it work with PHP.

apt-get install openssl
apt-get install lsh-client
apt-get install libssh2-1
apt-get install libssh2-1-dev

With our libraries and packages installed, we can compile our ssh2 extension for PHP.

pecl install -f ssh2-beta

Finally, we need to add the extension to php.ini.

nano /etc/php5/apache/php.ini

Find the section titled “Extensions” and add this line:

extension=ssh2.so

And restart Apache:

apache2ctl -k graceful

In your WordPress admin interface, you should now see an “SSH” option when you go to add, remove, or update files on your server. WordPress provides text boxes to use your private and public SSH keys, but I found I only needed to use one of my user account’s credentials to authenticate to the server.

Recently I needed to find out which folders a certain person was able to access on our Windows network. Apparently, this was extremely easy in Novell. Since it isn’t 1995 anymore, I tried to find a way to do this on the Internet. I couldn’t, so I set about making my own.

Microsoft has a utility called xcacls.vbs (if you’re using Vista, you’ll have to make sure WMI is installed, and modify the script. If you can’t do that comfortably, you probably don’t want to be messing with the rest of this anyway). It will allow you to change and view ACL’s from a command line. Since I’m not that interested in modifying the ACL’s in a script, the usage is fairly simple “xcacls c:\windows” will result in a listing of who has entries in the ACL and what the entry is (n.b. you’ll also have to have the default script host be cscript. Wscript won’t work).

In order for this to be useful, we really need to be able to have it run automatically on several, if not all, folders on a computer. The first step would be to get a list of the folders we want to run this on. I chose to limit it to one folder and all its subfolders only (c:\ will do everything, while c:\windows will only do the folders in c:\windows. If you want to do c:\windows and c:\program files only, you’ll have to run it twice).

What I was looking for was basically a text file that just had all the folders. This command will create exactly that:

dir "c:\program files" /s /b /o:gn /a:d > c:\batch\xcacls\dirlist.txt

Now that we’ve got a list of all the folders we need to search, we need to actually loop through it.

For /F "tokens=*" %%i in (dirlist.txt) do c:\batch\xcacls\aclSearch.bat administrator %%i

C:\batch\xcacls\aclSearch.bat is another batch file which takes two parameters (I’ll show you it in a minute). I call the other batch file so I don’t have to worry about how DOS handles variables (it doesn’t like to evaluate them during runtime, and will wait until the loop is done and use the final value for each iteration. It’s weird, I know).

A caveat about the for loop: when using for in an interactive CLI you use a single % sign in front of the i, when using it in a batch file, it’s a double %. Don’t ask me why.

aclSearch.bat contains the following

call c:\batch\xcacls\xcacls.vbs "%2" > c:\batch\xcacls\xcaclsResults.txt
 
find /i %1 c:\batch\xcacls\xcaclsResults.txt
 
if %errorlevel%==0 goto Found
 
goto End
 
:Found
 
echo %2 >>c:\batch\xcacls\%1results.txt
 
:End

This calls xcacls.vbs (from Microsoft) passing it the folder name. The quotes are there to handle filenames with spaces. It then sends the results into a temporary file called xcaclsResults.txt

Next we do a find using the search string (the first item passed – administrator in this example) on that file. If Find finds a match, the errorlevel is 0; if not, it is 1. If the errorlevel is 0, then the folder name is put into a results file named whatever the search string is, with results.txt appended (in this example it’d be administratorresults.txt).

So, how do you actually use all this? FindPermission.bat contains:

dir %1 /s /b /o:gn /a:d>"c:\batch\xcacls\dirlist.txt"
 
for /F "tokens=*" %%i in (dirlist.txt) do c:\batch\xcacls\aclSearch.bat %2 %%i

To search the c:\program files directory for anything the administrators group has access to you’d type:

Findpermission.bat "c:\program files" administrators

The results will be in the same folder you ran findpermissons from and be called administratorsResults.txt. To search the C drive for anything Danny Parrott has access to, you’d need:

Findpermission.bat c:\ "Danny Parrott"

The results from this one will be in Danny Parrottresults.txt.

This does require that Findpermission.bat, aclSearch.bat, and xcacls.vbs be either in the same folder, or in a folder that’s in the path variable. It will work for either users or groups. This process is also not instantaneous. The xcacl.vbs script can take upwards of half a second to run, so on larger systems, this is something you’d want to start and come back to later. On the plus side, though, it hardly uses any system resources while running (5MB RAM and 2-4% CPU time on a four-year-old server at work) so you can run it during the day.

INSERT INTO
  People (
    Name
  ) VALUES (
    'Joe'
  );
  SELECT @@IDENTITY AS NewName;

This query will create a new person and also return the identity value of the newly created record. It can be useful for all kinds of things - I use it frequently.

We recently upgraded to ColdFusion 8 here at Purdue, and my code started breaking.

It turns out that CF8 attempts to “help” you by automatically running SELECT @@IDENTITY after any INSERT query. This is problematic in two ways - it cancels out your own @@IDENTITY query, and it arbitrarily names the result Generated_Keys.

So instead of being able to do something like this:

<cfset TheNewName = People.NewName>

You must use this:

<cfset TheNewName = People.Generated_Keys>

It’s really more annoying than anything else. It seems like a good idea to include the code automatically, but I think it would probably be a little better if there were a conditional in there that prevents CF8 from inserting its automatic query if a SELECT @@IDENTITY query is already present.

We removed all the USB host items from the Device Manager and reinstalled them, to no avail. Then I tried disabling the USB enhanced controller item (this is generally what lets Windows know that a USB controller is capable of USB 2.0). This worked, but kept his devices from working at USB 2.0 speeds. We even reinstalling Windows completely and still had the same problem.

I started Googling around and found this article regarding my exact problem - the SiS PCI to USB Enhanced Host Controller mysteriously quit working, and took all USB 2.0 devices down with it. This blogger’s solution was to shutdown and unplug the computer, wait for about half an hour, hold in the power button for a minute, and then restart the machine.

And, like magic…it worked.

I can only begin to guess why. Like this other blogger, my neighbor’s machine had a Gigabyte-brand motherboard. My theory is that something was getting corrupted or otherwise mistranslated by the motherboard regarding the USB 2.0 controller, and whatever was breaking things was being remembered across shutdowns and reboots.

By letting the machine sit for awhile, all the capacitors on the motherboard and power supply emptied out, thereby completely cutting power to the machine. This apparently reset whatever dark magic was causing the problem in the first place.

It’s likely that in Matt’s case, Linux was allowing the ports to work, but only at 1.1 speeds. Since we didn’t test how quickly file transfers took place in Linux, I can’t confirm this theory, but it would fit with my above assumptions.

At any rate, now we have our answer. The next time this happens (and I imagine it will), I’ll try the fixes listed on usbman.com first, so we can try to cure the problem once and for all.

I wouldn’t recommend using Apple’s VNC server; it’s far more restrictive than alternatives. Vine server is much more robust and customizable, and it’s open-source.

However, if you find it necessary to use Apple’s built-in VNC for whatever reason, you may also find yourself needing to control the server from the command line (for instance, if the server application fails and you need to SSH into your remote Mac to restart the service).

I found out the hard way that the Perl script Apple uses to restart the server stores the VNC password in plaintext. This is wrong on a lot of levels, one being that it’s completely user-unfriendly. At any rate, after some Googling around, I found a Perl script that will encode the password with the necessary key. You can then input the encoded password in your VNC restart command.

The Perl script looks like this:

perl -nwe 'BEGIN { @k = unpack "C*", pack "H*", "1734516E8BA8C5E2FF1C39567390ADCA"}; \
chomp; s/^(.{8}).*/$1/; @p = unpack "C*", $_; foreach (@k) { printf "%02X", $_ ^ (shift @p || 0) }; print "\n"'

Paste this at your bash prompt and hit enter. You can then type your password, hit enter again, and have the encoded password ready to go. Once you have your encoded password, you can use the kickstart command to restart the VNC server. Apple has some documentation on using kickstart here.

Overall, Apple made a major blunder by not correctly encoding the password with the kickstart utility. Hopefully this will be remedied in a future release of OS X.