WordPress shortcodes are great. They let you perform complex operations or display dynamic content with just a tiny bit of text in any page or post.

I recently needed a way to embed the most recent videos from a Youtube channel (very dynamic information) in a WordPress page, so I decided to write a shortcode for it.

The code is actually pretty simple. Just add the following to your theme’s functions.php file:

And it couldn’t be easier to use. The videos you see below were embedded simply by putting this code in the post:

The shortcode is completely configurable. The following code would have resulted in the exact same output:

You can change any option as needed.

You might have noticed the code gives each element a particular class to make it CSS friendly. All you have to do is add CSS rules for three classes: .youtubefeed, .youtubetitle, and .youtubecontent.

My stylesheet looks like this:

A quick note about requirements:

• Your server’s PHP configuration needs to have allow_url_fopen set to On.
• You’ll also need the PHP JSON extension

Most hosts meet those requirements.

So there you have it. It’s a quick and dirty way to get functional, always up-to-date Youtube streams in your WordPress posts and pages.

Related posts:

1. My first WordPress Plugin: Project Honey Pot
2. PHP – Redirect and continue (without abort)
3. PHP and FFMPEG – Performing intelligent video conversion

So you need to check if some string is a valid IP address. You could simply test it against a regular expression:

Regular Expression obtained here

This will actually work for most situations, but it’s lacking in a few ways. Suppose you want to exclude private or reserved IP addresses. Maybe you want to validate IPv6 addresses too; not just IPv4.

Enter PHP’s Data Filtering Extension. It just works, and you don’t have to worry about maintaining (or properly applying) complex regular expressions.

Now to test it.

The above will output:

Thank you PHP for making this otherwise complex task very simple. And even better: it’s fast!

I tested the regular expression and the filter_var functions by running each 100,000 times. Here are the timings for each test:

• 1.53423094749 seconds with the filter_var function
• 3.1516289711 seconds with the regular expression function

Not bad! Happy filtering.

Related posts:

1. My first WordPress Plugin: Project Honey Pot
2. Projects
3. PHP and FFMPEG – Performing intelligent video conversion

Yesterday, Google officially announced their new Chrome OS and explained what it will be when it’s released.  They also published the source code to allow developers and other interested parties to take a peek.  I’m one of those “other interested parties.”

The Setup

I didn’t build the OS from source myself, but downloaded a pre-compiled VMWare image.  Then, using CloneVDI, I converted it to a VirtualBox virtual hard disk.  I just created a new Virtual Machine for Linux and added the .vdi.  Done!

The Tour

First, you’re presented with a logon screen.  My first thought was “uhhh…. now what?  I didn’t create an account”.  Then I remembered: “This is a Google product.  Try your Google login.”  And whadayano?  It worked!

Login Screen

I don’t know why it was off-center like that.  It came up like that every time for me.

The first place I went to after logging in was a button at the top left that looked like a Chrome logo.  That gave me this page:

Google Short Links

I don’t know what “Google Short Links” is, but it wouldn’t let me login with my regular username/password here.

I wanted to see what I was working with, so I went to the “About” dialog.

About

It’s using Chromium 4.0.253.0 (32535).

Next, I went to the options menu.

Options Menu

The first page provides you with some time and touchpad settings.

Options Dialog

One setting that would be nice to have?  Screen resolution.  I couldn’t find any place to change that, and the 800×600 default resolution feels incredibly confining.  I found the bottom of the Basics tab humorous:

Basics Tab

Chromium cannot determine or set the default browser.

…oops.

As for the other two settings pages, they’re exactly what we all have in Google Chrome right now.

Let’s see… what should I try next?  Oh yeah!  How about my favorite Google service?  Hello Gmail

Revoked Security Certificate

Wait… what?  This happened to me several times.  After refreshing, it usually worked, but it took over 5 refreshes once.  Very annoying.

Once I finally got gmail to show up, I tried to enable offline mode.  Surely this OS has gears built-in, right?  Wrong.  It asked me to install Gears:

Gears

Unfortunately, it’s impossible to install Gears.  I learned through this process that currently, it is impossible to open any file in this OS.

Gears Install

Clicking on the downloaded file does nothing.  Clicking the “Open in folder” option from the file’s sub-menu… does nothing.  Google will have gears integrated by the time this is released.  They’d be crazy not to.

Conclusion

My thoughts?  Looks like fun.  For how far along it is, the integration with Google services is impressive.  It’s definitely very rough right now.  For example: there’s no way to tell it to shut down.  That’s a pretty glaring oversight.  But obviously, this is an extremely early release which is by no means complete.

Also, speed was an issue.  Windows Vista Ultimate 64-bit runs faster in VirtualBox on my machine.  That is not an exaggeration.  In case you’re wondering:  My desktop runs on an Intel Core 2 Quad @ 2.66Ghz (Q9450) with 8GB of DDR3 1600Mhz RAM and a 10,000RPM boot drive (which also hosted the .vdi file), so the bottleneck was not my machine.

All problems aside, I can’t wait to see what the finished product looks like, or how Google’s new programming language will fit into it all.

Related posts:

1. Project Honey Pot WordPress Plugin
2. Contact Me
3. Install Ejabberd 2.0 on Ubuntu Hardy Heron 8.04 LTS – 6 Steps!

Problem:

You’ve chosen the most simple, solid Linux server – Ubuntu 8.04 LTS, and you want to run the most simple, solid XMPP server – ejabberd. BUT, the version of ejabberd in Hardy’s repositories is the really old (Sep 03, 2007!) 1.1.4 release.

Solution:

You could of course build ejabberd from source, but that’s not why you chose the “It Just Works^TM” Ubuntu server, is it? Have no fear. A simple and (mostly) painless solution awaits!

The key is in the Hardy-backports repository. Ubuntu Backports are updated versions of software that have not been fully tested with the default software packaged in the Ubuntu Installation. By default, the Ubuntu team only releases security updates and keeps all major versions of software constant throughout the release’s lifecycle.

Backports are an option for brave souls that want the latest major versions of software on their still perfectly relevant (but chronologically gifted) operating system. I say “brave” souls because there is one serious issue with this:

So make sure you keep that in mind and carefully monitor the security bulletins of the writers of any software package you install from backports. Since we don’t want every package to be upgraded to its non-security-checked newest backport version, we’ll enable pinning. Pinning allows us to enable the backports repository only for those packages we specifically request from it.

Instructions:

Enough of the explanation, here’s what you’re reading this for.

1) First, we need to add the backports repository. Fire up your favorite text editor (beginners should probably use nano) and open `/etc/apt/sources.list`.

and add these lines:

In my case, the lines were already there, and I just had to un-comment them. Your experience may vary.

2) Next, we’ll enable pinning. Run:

and add these lines:

3) Now all that’s left is to update apt and install ejabberd. The ‘-t hardy-backports’ line specifies that we want to get ejabberd from the backports repository:

Or, you can do it all in one command:

4) Once installation finishes, run:

And change the following lines to set your domain name and admin user (make sure the domain name matches the output from the ‘hostname‘ command):

5) Now, restart ejabberd:

6) Finally, create your admin user account:

That’s it! You’re done! Enjoy your fully-functional, up-to-date XMPP server.

Related posts:

1. PHP – Redirect and continue (without abort)
2. Google’s Chrome OS – First Impressions
3. Recover WordPress from broken theme

Thanks to my friend who sent me this.

Uber-geeks will recognize “RFC” (yet another TLA) as short for “Request For Comments.” But those with lives normal folks might need an explanation.

The Internet Engineering Task Force (IETF) has created RFC as a standard for documentation of Internet-related subjects. There is an RFC for just about everything, including:

• Internet Protocol (791)
• Email (5322)
• TCP (793)
• Instant Messaging (3290)

A lot of RFC’s are standards, but the vast majority of them are not. Almost all of them, though, are painfully dry reads. That said, there are some glaring exceptions.

Take RFC 1149 for example:

Standard for the transmission of IP datagrams on Avian Carriers

Overview and Rational

   Avian carriers can provide high delay, low throughput, and low
   altitude service.  The connection topology is limited to a single
   point-to-point path for each carrier, used with standard carriers,
   but many carriers can be used without significant interference with
   each other, outside of early spring.  This is because of the 3D ether
   space available to the carriers, in contrast to the 1D ether used by
   IEEE802.3.  The carriers have an intrinsic collision avoidance
   system, which increases availability.  Unlike some network
   technologies, such as packet radio, communication is not limited to
   line-of-sight distance.  Connection oriented service is available in
   some cities, usually based upon a central hub topology.

That’s just the overview. Here’s the rest, including my favorite part: the Discussion.

Frame Format

   The IP datagram is printed, on a small scroll of paper, in
   hexadecimal, with each octet separated by whitestuff and blackstuff.
   The scroll of paper is wrapped around one leg of the avian carrier.
   A band of duct tape is used to secure the datagram's edges.  The
   bandwidth is limited to the leg length.  The MTU is variable, and
   paradoxically, generally increases with increased carrier age.  A
   typical MTU is 256 milligrams.  Some datagram padding may be needed.

   Upon receipt, the duct tape is removed and the paper copy of the
   datagram is optically scanned into a electronically transmittable
   form.

Discussion

   Multiple types of service can be provided with a prioritized pecking
   order.  An additional property is built-in worm detection and
   eradication.  Because IP only guarantees best effort delivery, loss
   of a carrier can be tolerated.  With time, the carriers are self-
   regenerating.  While broadcasting is not specified, storms can cause
   data loss.  There is persistent delivery retry, until the carrier
   drops.  Audit trails are automatically generated, and can often be
   found on logs and cable trays.

Security Considerations

   Security is not generally a problem in normal operation, but special
   measures must be taken (such as data encryption) when avian carriers
   are used in a tactical environment.

There are a lot more joke RFC’s on this Wikipedia page.

Related posts:

1. power’s out
2. C# Detect Windows OS Version – Part 2 (WMI)
3. Day 3 – Venice (Yasolow)

Recap

In case you missed Part 1, I briefly summarized 4 different strategies for programmatically determining the current Operating System in C#.  The code I posted there utilizes the System.Environment class.  It works great and is sufficient for most uses, but sometimes you want need to know everything about the OS, including the edition (i.e. “XP Pro” vs. “XP Home”).

Summary

For that, Microsoft gives us the lovely Windows Management Instrumentation (WMI) Interface.  You can do a lot of really powerful and interesting things with WMI and WQL, but for this purpose, all we care about is getting some information from it.

The Code

Not all Windows versions support WMI, so we always have to fall back on the Environment class code from Part 1.  Without wasting your time, let’s get straight to the code.

WMI

Legacy code

Download this code

Notes

Server Versions

In part 1, the code was completely unaware of Windows Server operating systems.  Fortunately, this WMI approach will tell us about server versions too!  However, you’ll notice that it falls back on the old, non-server-aware code.

If detecting server versions is really important to you, you’ll probably want to separate out the functions so that you can know every case that the WMI code fails to detect the OS.

OS Architecture

Just a reminder: The code that detects OS Architecture (both WMI, and Environment-class-based) tells us about the Operating System version only.

1. Even though the physical CPU’s architecture may support 64-bit operations, the methods in my code will always return the architecture of the OS. So 32-bit Windows running on a 64-bit capable processor will return 32-bit.
2. Even though the CPU is 64-bit capable, and the OS architecture is 64-bit, your .Net program could still be running as a 32-bit application. Sometimes, this information is more useful than knowing whether Windows is 32- or 64-bit. To see if your program is actually running in 64-bit mode, check to see if IntPtr.Size == 8. It will be 4 in 32-bit mode and 8 in 64-bit mode.

Related posts:

1. C# Detect Windows OS Version – Part 1
2. Install Ejabberd 2.0 on Ubuntu Hardy Heron 8.04 LTS – 6 Steps!
3. WordPress: Embed Youtube Feed With a Simple Shortcode

Whenever I have limited experience with something or just need to do some research, I go straight to StackOverflow.com – a computer programming question and answer site.  Out of the 24 questions I’ve asked on the site, only one has gone unanswered to date, and I’ve gleaned countless other answers from questions others have already asked.  In case you haven’t already guessed, I really like the site.

Not long ago, I needed to convert uploaded video files for a project in PHP.  FFMPEG was a clear and obvious choice for the job, but I had never used it before, so I turned to my favorite resource.  Sure enough, I got enough information in the answers to build a fully working solution.  I posted that solution as an answer to my own question in case anyone else could use it.

Unfortunately, StackOverflow seems to be having trouble displaying my answer, so I’ve reposted it here for anyone who needs it.

The original question

I’m converting videos uploaded to a php script from various formats (.avi, .mpg, .wmv, .mov, etc.) to a single .flv format. The conversion is working great but what I’m having trouble with is the resolution of the videos.

This is the command I’m currently running (with PHP vars):

Both $original and $converted contain the full paths to those files. My problem is that this always converts to 640×480 (like I’m telling it to) even when the source is smaller. Obviously, this is a waste of disk space and bandwidth when the video is downloaded. Also, this doesn’t account for input videos being in any aspect ratio other than 4:3, resulting in a “squished” conversion if I upload a 16:9 video.

There are 3 things I need to do:

1. Determine the aspect ratio of the original video.
2. If not 4:3, pad top and bottom with black bars.
3. Convert to 640×480 if either dimension of the original is larger or a 4:3 aspect ratio relating to the width/height of the original (whichever is closer to 640×480).

I’ve run ffmpeg -i on a few videos, but I don’t see a consistent format or location to find the original’s resolution from. Once I’m able to figure that out, I know I can “do the math” to figure out the right size and specify padding to fix the aspect ratio with -padttop, -padbottom, etc.

The final result

Getting FFMPEG’s output

First I had to get the output from ffmpeg -i, which was a challenge in itself. Thanks to hegemon‘s answer on my other question, I was finally able to get it working with 2>&1 at the end of my command. And thanks to Evert‘s answer to this question, I was able to parse the output with preg_match to find the original file’s height and width.

Determining the best dimensions

I wrote this function to determine the best dimensions to use for conversion. It takes the original’s dimensions, target dimensions, and whether or not to force conversion to the target aspect ratio (determined from its width/height). The target dimensions will always be the largest result this function can return.

Usage

Here are a few examples of what you will get from get_dimensions() to make things more clear:

The Finished Product

Now, to put it all together:

 I hope this is helpful to someone.

Related posts:

1. WordPress: Embed Youtube Feed With a Simple Shortcode
2. PHP: Validate an IP Address
3. PHP – Redirect and continue (without abort)

I hate spam. I hate it. That’s why I’ve been a participant in Project Honey Pot for the past several years.  For those who don’t know what Project Honey Pot is, here’s their About page

To summarize, the project catches spammers by putting fake e-mail addresses on special pages that only harvesters crawling websites should ever find.  When one of those addresses get spam, they’ve caught a harvester and know exactly when and from what IP the e-mail address was harvested.

It only just recently occurred to me that there really is no good WordPress plugin that allows you to hide honey pot links in your website. So I wrote one.

I was surprised at how easy it was actually. I hope it’s helpful to someone, somewhere.

Go to the plugin page now

Related posts:

1. Project Honey Pot WordPress Plugin
2. Projects
3. WordPress: Embed Youtube Feed With a Simple Shortcode

The Problem

Sometimes, in PHP, we have to do things that take a long time (like converting user-submitted videos, say), but there’s a problem with that: the user has to wait until we’re done with whatever we’re doing.  The worst part is, it looks like their request was dropped because the browser just sits there “loading” forever and shows no sign of progress until the page is finally done loading or – *shudder* – times out.

Solutions

There are a few strategies to solve this problem:

1. You could have your PHP script create a cron job on the server.  This approach is overly complex in my opinion and has some problems: You have to be running your PHP code on a Linux server, and you have to have access to cron – not really an option for most people who don’t host their own server.
2. You could write a special PHP script that gets called via AJAX after the page is loaded and returns the results from the operation.  That works just fine and is a great option for someone comfortable with AJAX.  I’ve actually used this strategy myself, but it’s still too complicated for my taste.
3. My weapon of choice: The PHP redirect and continue.

Summary

It works like this: worker.php is the worker script.  At the very beginning of worker.php, it redirects the user’s browser to messageToUser.php, but worker.php keeps working.  Then you can do anything you want in worker.php just like normal, and you can send the user a message when it’s finished by whatever means you choose (you do already have a user message system, right?).

The Code

Say the user just finished uploading a video that needs to be converted.  The page they should be taken to is worker.php, which instantly redirects them to messageToUser.php.

messageToUser.php:

worker.php:

Some notes about the last few lines:

1. flush() has to be called even though we just called ob_end_flush() because:
   

   flush() has no effect on the buffering scheme of your web server or the browser on the client side. Thus you need to call both ob_flush() and flush() to flush the output buffers. ~PHP.net flush() docs

2. We need to call session_write_close() because session data is locked while in use, which means only one PHP script can access a single session at a time.  So, since our script is going to take a while, we need to make sure other scripts can access the session instead of waiting for worker.php to finish.  That would kinda defeat the whole purpose.

That’s it.  While this may seem like a complex fix to some, as long as you have PHP 4.0.4 or above, it Just Works^tm, and you can use and reuse it anywhere you want.  Just copy and paste.  No AJAX.  No cron jobs.  Nothing more to deal with than PHP itself.  I like it.

Related posts:

1. PHP and FFMPEG – Performing intelligent video conversion
2. WordPress: Embed Youtube Feed With a Simple Shortcode
3. My first WordPress Plugin: Project Honey Pot

Introduction

I recently needed to programmatically determine the Operating System my software is running on.  I was amazed at how difficult it was to find reliable, useful information on this subject.  There were bits and pieces here and there, but almost everyone assumed I had some pre-existing knowledge of the process in one manner or another.  Hopefully, this little series will save somebody some time in the future.

The thing that makes this so difficult is that there are almost as many different ways to detect the operating system as there are operating systems!  It’s an unbelievably frustrating experience trying to reinvent this wheel, so I’ll try to walk through it here.

Strategies

There are 4 basic strategies:

1. Read and parse information from files in the Windows directory.  This is probably the most difficult and least rewarding method.  The files are different for each generation of OS and the format is not guaranteed in almost any case.
2. Read information from the registry.  This method works a little better, but you still have varying locations for the information based on which OS you’re dealing with.
3. Use Environment variables.  Nothing is more reliable.  However, it doesn’t give you the nitty-gritty detail you might want.  For example: There’s no way to detect XP Home vs. XP Professional.
4. Use WMI to query for information about the OS.  This gives you everything you could possibly want all in one shot.  Unfortunately, it’s not supported in pre-NT versions of Windows.

I started with number 1.  After pulling most of my hair out and wanting to punch my keyboard, I moved on to number 2.  That was a dead end too.  I could have made it work, but I didn’t have the patience.  I gave number 3 a try and was very happy…  …until I decided that the specific version of 2000, XP, Vista, and 7 mattered to me.  So I finally ended up with a combination of 3 and 4.

For part 1 of this series, I’m going to focus on number 3, a.k.a. The Easy Way^tm

The Code

The key to everything is the Environment class.  It has everything we need in a property called OSVersion.  However, the information is a little cryptic (mostly a bunch of numbers), so it takes some work to get a “friendly” value returned.

This first method gives us the Operating system architecture as an integer. The environment variable “PROCESSOR_ARCHITECTURE” is either set to “x86″ or doesn’t exist on 32-bit versions of Windows. It’s always set to something other than “x86″ on 64-bit versions of Windows.

For something that seems so simple, this can actually be very confusing. There are two important notes about this method:

1. Even though the physical CPU‘s architecture may support 64-bit operations, this environment variable will always return the architecture of the OS. So 32-bit Windows running on a 64-bit capable processor will return 32-bit. It’s a bit of a misnomer, but provides the information we really want anyway.
2. Even though the CPU is 64-bit capable, and the OS architecture is 64-bit, your .Net program could still be running as a 32-bit application. Sometimes, this information is more useful than knowing whether Windows is 32- or 64-bit. To see if your program is actually running in 64-bit mode, check to see if IntPtr.Size == 8. It will be 4 in 32-bit mode and 8 in 64-bit mode.

Now onto the actual Operating System version. The following code is largely based on what I found on the Microsoft Knowledge Base article: How to determine the Windows version by using Visual C#.

Notice that getOSInfo() returns an empty string if it was unable to determine the OS version.

The code should be pretty self-explanatory, and the great thing is that you don’t have to reference any special assemblies. Everything is right there in System.

Part 2: Using WMI

Related posts:

1. C# Detect Windows OS Version – Part 2 (WMI)
2. RFC Standard for the transmission of IP datagrams on Avian Carriers
3. Install Ejabberd 2.0 on Ubuntu Hardy Heron 8.04 LTS – 6 Steps!