For example:

Seems logical, right? Create a new array, with whatever width and height were passed to the function. And, as I said, g++ will happily let you do this (well, maybe not this particular example, but you get the idea), but VS complains.

As such, and since I have to have a Windows binary to submit to the professor, I’ve ventured into the world of malloc. Sounds like a villain’s name, doesn’t it? For those who don’t know, malloc is (one of?) C’s memory allocation function(s) — give it the amount of memory you need, it’ll reserve that much memory and return the base address (in the form of a “void *”. pfft.). Of course, it’s not that simple, but that’s the basic idea.

To get our two-dimensional array with malloc, you need to get fancy with the looping. For example:

What a freakin’ mess! Instead of reading “create a height-by-width array”, this reads more like “eat up as much memory as you can”. Yes, you have to semi-manually create each level of the “dynamic” array, all so you can conveniently use “Array[n][m]” later in your program. Want a three-dimensional array (used to hold RGB images — Array[height][width][3])?

And so on for each dimension you wish to add. Truly hideous. So many levels of pointers to keep track of, so many stinking loops! There is such a better way

Instead of using unsightly code to allow the convenience of multiple subscripts, you could just as well create a width*height(*3), single-dimensional array, and use some simple math to get the proper offset. Here are examples of up to three dimensions (I’ve actually used the three-dimension one in my program to load an image file, works perfectly):

If I’m not mistaken, the recursive pattern for the subscript is “(other-loops)*max+counter”, starting from the innermost loop. So three dimensions goes like this:

(other-loops)*3+k
((other-loops)*width+j)*3+k
(((other-loops)*height+i)*width+j)*3+k

no more loops, use "0":

(((0)*height+i)*width+j)*3+k
((i)*width+j)*3+k
(i*width+j)*3+k

So, for a fourth loop “m” going from 0 to, say, 40, we would probably have:

((i*width+j)*3+k)*40+m

And so on, but who uses 4D arrays, anyways?

Disclaimers:
“for (int i=0; …” syntax is, as far as I know, a C++ feature; in true C, you would have to declare “i” beforehand, then use it in the loop.
When creating objects with malloc, be sure to free the memory when you’re done with it; I refuse to be held responsible for memory leaks in your program.
C library “stdlib.h” must be included to use these functions.
Yes, you have to typecast malloc’s return value to whatever your data type is, unless your variable itself is a “void *”, but why would you need a pointer to nothing?
For each level of the array in the first malloc example, you need as many “*” as you have levels left to create — three for the first level, two for the next, one for the last, etc.
Strictly speaking, “sizeof(unsigned char)” translates to “1″, so it’s not necessary here; however, it is required to get the right size for other data types, in which case the hideous factor is no more reduced.
I have not tested, nor plan on testing, the four-dimensional subscript example given above. If it doesn’t work and you figure out how to make it work, feel free to post your solution

I’ve been developing an IRC bot as a side project, and three of its functions require the use of web services. It can shorten urls using http://is.gd/, search google, and validate web pages using the W3C’s HTML and CSS validators. Fortunately, and to my great elation, all four services have APIs available.

Is.gd’s API is straightforward and easy to use: call the page http://is.gd/api.php?longurl=http://really-long-url-goes-here.com , and is.gd will return the shortened url (or an error message) as the only text. You’ll have to parse out the HTTP headers, of course, but that’s the easy part.

The W3C’s APIs are just as easy to use. For HTML validation, fetch the page http://validator.w3.org/check?uri=http://webpage-to-check.com . This is the same page you would navigate to in a browser, and returns a full-on HTML page with the results. However, it also puts custom headers in the HTTP response. To get the results, you have to parse out the values of the X-W3C-Validator-Status, X-W3C-Validator-Errors, and X-W3C-Validator-Warnings headers. For CSS, the same info comes in the headers of a call to http://jigsaw.w3.org/css-validator/validator?uri=http://webpage-to-check.com . In the case of the CSS validator, though, the X-W3C-Validator-Warnings header is not returned.

Google’s search API is a little more involved. Not only because it uses JSON, but because it’s a secret. Google’s AJAX Search package is no secret of course, but the API calls that it makes are hidden away. Fortunately, Google set up an experimental search site called SearchMash.com, along with an API of its own. Simply fetch the page http://www.searchmash.com/results/search+terms+go+here , and searchmash will return a JSON string which can then be parsed out to obtain the google search results, alternate spelling suggestions, estimated number of results, the works. Even better, you can append “?n=X” to the end to limit the search to X results. Using ?n=1 returns the top result only.

These APIs all save processing power that would otherwise be spent parsing out possibly badly-formed HTML from HTTP responses.

Aside: If you would like to check the bot out, it currently resides on #webdezvous and #ecode on the freenode network. It goes by the name of “ecode”.

The new layout, also my first WordPress theme (yay), is a bit more flexible. By default, it is full-browser-width, with reasonable space allotted to the right sidebar and the main content areas. For modern browsers that support max-width CSS, the design will stop “growing” at 1,000 pixels, just short of full-width on a 1024×768 resolution. The content and sidebar columns have, in addition to their own (possibly redundant) max-widths, reasonable min-widths. This is to prevent the content from being squashed beyond recognition should someone with an abnormally small browser come along. In this case, the sidebar will drop below the content area when the point-of-no-more-shrinkage is reached.

There’s a whopping 6.3KB worth of images to load per page. Unfortunately, they’re almost all translucent gradients, so IE6 users will receive *html hacks in the CSS to clear most of them, to avoid unsightly grey blocks that would otherwise obscure text. The color scheme was heavily based on Cool Grays Lavender by julievonderropp on Kuler.

In addition to the right-hand sidebar, I put two separate “widget areas” in the footer, one above the other. The bottom section is primarily for displaying the archives links — there are a lot of them (one for each month the site’s been up), and they don’t fit very nicely in vertical sidebars. The top section is simply another sidebar, designed to fit up to three widgets.

A decent amount of work went into the comments section, along with some help and ideas from a comments template posted at ChristianMontoya.com. Even/odd comments are striped for easy differentiation. The post’s author’s name is retrieved via an extra database query, and comments made by that author are given an additional class name, used to attach another gradient image to the background. Also, comments and pingbacks are listed separately, comments first, along with their respective counts. This change is extended to the front and search pages, where another extra query is executed for each post to obtain the number of actual comments for that post. A small amount of extra overhead, but it might be worth it for the extra accuracy. Unfortunately, I haven’t yet thought of a succinct way of displaying the total number of responses (comments plus pingbacks).

Concerning the actual theme construction, at the outset, I really had no clue about making WordPress themes, other than that it involved PHP, HTML, CSS, and some MySQL. The design itself started as an HTML file on my local harddrive, just an idea I started tweaking around. Fortunately, in my research I ran across a full-fledged WordPress theme tutorial on WPDesigner.com; it’s really a great tutorial for beginners to the whole WordPress skinning idea. For what the tutorial lacked, the WordPress Codex was a great reference, along with a couple of google searches for some unclear topics. I did have to consult PHP.net a couple of times, but that’s normal for any PHP project. Overall, though, it wasn’t too difficult, just a matter of putting the right pieces in the right places .

So, there you have it. My first post in almost a month (sorry ) is a self-centered look-at-me post. Criticisms, comments, and congratulations on the design are welcome. As are lectures about what coding, design, or WordPress standards I may have broken . In other words, I look forward to your feedback.

There are a lot of GUI clients that claim to do a lot of this stuff, but I prefer the KDE-native KTorrent as my desktop client. For a management system, though, the GUI is almost irrelevant — a set-it-and-forget-it system needs to sit in the background until called to the foreground, and rTorrent does this very nicely. Coupled with an always-on-and-connected home server, some bash scripting, and the linux “screen” program, rTorrent is fully capable of automating torrent downloads.

In researching others’ systems, I came across “rTorrent as a download manager“, a text file detailing what the author expected from his management system, and how he went about obtaining the desired results. I also came across an rTorrent and libtorrent user guide on the official rTorrent site. Unfortunately, there is little up-to-date, detailed info on all the options offered for rTorrent customization.

According to the first resource, the (initial) main goals of the TMS are:

1. Limit the number of concurrent active torrents
2. Queue and start inactive torrents
3. Move downloaded files to another directory and remove the associated .torrent file
4. Manage bandwidth usage to keep the DSL connection useful

These are all well and good, and relatively simple to achieve with little bash scripting, but rTorrent is capable of more. When a torrent is finished, I want to move it to another directory before I continue seeding. When it’s done seeding, I want to move it to another directory, so I can know, simply by looking at directory contents, which files are completely done. And, of course, I want to move the downloaded files to the appropriate directories. So the complete list of TMS requirements is:

1. Limit the number of concurrent active torrents
2. Queue and start inactive torrents
3. Move downloaded files to a second directory and continue to seed the torrent to a specific ratio
4. Move seeded files to a third directory and remove associated .torrent files
5. Manage bandwidth usage to keep the DSL connection useful
6. Move files from the final directory to the appropriate external locations

The first two can be accomplished with rTorrent’s directory watching and a simple bash script. The next three can be implemented solely within rTorrent. And the final point can be implemented with a more complicated bash script that takes advantage of community torrent naming conventions.

First, the directory structure. Let us assume that the base directory for torrent activity is /torrents. Limiting torrents is a simple matter of making sure that rTorrent’s watched directory never contains more than N .torrent files, where N is our maximum. This gives us two directories: /torrents/watch and /torrents/loading. The watch directory is the one rTorrent will watch for torrents, and the loading directory will be a holding cell for inactive torrents. Points 3 and 4 give us three more directories, /torrents/active, /torrents/seeding, and /torrents/finished. These are for active, downloaded (seeding), and completely finished torrents, respectively. Another directory to use is /torrents/session, for use with rTorrent’s session feature. Finally, I have a hidden directory /torrents/.archive where I send copies of activated .torrent files.

Once the directory structure is in place, rTorrent needs to be told how to manage things. This is done in the .rtorrent.rc file, which, by default, is in the initiating user’s home directory. Here is the section of my .rtorrent.rc file that handles torrent management (make sure each command is on one line):

All other “schedule” and “on_whatever” commands that were in the example .rtorrent.rc file are commented out. This defines the session, watch, and active download directories; specifies that downloaded files should be moved to the seeding directory and seeded; specifies what ratio to stop a seeding torrent at; and specifies that completely finished torrents should be moved to the finished directory. Getting finished files to be moved before seeding was fairly straightforward; in fact, there were already examples floating around the internet on how to do just that. Getting the files moved when the torrent was finished was tricky. All the examples I could find only showed “stop_on_ratio=” for the ratio schedule. Unfortunately, this leaves the torrent sitting in rTorrent as “inactive”, and, were I to use the “on_stop” command, the torrent would be moved when Ctrl-D was pushed (which temporarily stops the torrent). So I decided to try “close_on_ratio” instead, and that particular command happened to exist. Thanks to this, the torrent is closed (and moved according to the following on_close command) when my 1.10 ratio is reached, freeing up space for the next torrent. The only downside is if you are the original seed for a torrent (or are trying to seed a torrent beyond 1.10) and try to temporarily stop that torrent, it will be moved if the ratio is above 1.10. Other commands in .rtorrent.rc (upload_rate and download_rate) allow bandwidth control.

Once rTorrent knows how to manage the torrents (and you can test this by starting rTorrent and dropping a torrent in the watch directory), you need to implement the “queuing system”. Here is the “starttor” bash script that I use:

This script moves any stray torrents from the root directory (the easiest place to drop them) to the loading directory; I refer to these as “misguided” torrents, since they are not in the main loading directory. It then checks for the number of active torrents; if the number is greater than or equal to the max, the script exits, doing nothing. If there’s room for more, it checks for any torrents in the loading directory. If there are torrents there, it will move them, one at a time, into the watch directory, until the max is reached. If the archive variable is set, it will also save a copy to the specified directory. You can use this script with cron; I use this line in root’s crontab to run it every ten minutes:

Moving the finished files to their appropriate places is more complicated. Basically, you have to write a script that takes into account the common layout of filenames as well as your specific organizational directory tree. For example, I like to download TV shows. My directory structure is TV > Show Name > Season #. Most TV torrent files follow the conventional naming scheme of TV.Show.Name.S01E03.Episode.Name.Release.Group.avi. My script recursively goes through all the .avi files in the finished directory, for each file pulling out everything up to the season number (in this case, “TV.Show.Name.S01″). It then splits it at the S##, extracting the show name and season number. It then replaces all periods, underscores, and dashes in the show name with spaces, and reduces multiple consecutive spaces to one space each. Once the show name is prepped, the script checks if the directory “TV Show Name” exists in the TV directory. If it does, it checks for “Season #” (if that doesn’t exist, it checks for “Season#”, without the space, just in case). If that exists, the file is moved to that Season directory. If not, the file is left alone, for me to move manually if I need to. This leaves other, non-TV torrents in the finished directory for me to work with later. I also have this script on cron, but it is set to run every hour.

RTorrent makes building a TMS easy, as long as you know what settings to use. To really automate the whole thing, I could add a script which daily (or weekly) checks various RSS feeds for new torrents of shows I like, but I haven’t gotten that far yet — I’m still manually hunting down my shows. Since copying and pasting the file contents I’ve given is not ideal, copies of the files I use are available for download, just be sure to rename and chmod them as appropriate.

If you feel I left out any details, feel free to ask questions in the comments, and I’ll answer to the best of my ability.

There doesn’t seem to be much info on Google regarding un-spamming comments, so I thought I’d look into the database to see what I could do. Comments are held in the MySQL table “[wp-prefix]comments” (the default is “wp_comments”). One of the columns in that table is “comment_approved”. Unmoderated comments have a 0 in this column. Approved comments have a 1. And marked-as-spam comments have “spam”. To un-spam a comment, use your MySQL client (be it phpMyAdmin or the MySQL command line program) to edit the comment_approved field back to 0 (or 1) in the appropriate comment’s row. Unfortunately, “delete” really means “delete” — a deleted comment is removed from the database altogether, so you’ll have to scrounge legit comments back together from the emails that WP sends.

I really don’t see why the WP devs didn’t build an un-spam function into the WP admin. It seems like an obvious addition, given the structure of the database.

The features touted on Google’s promotional website include searchable history / smart address bar, a “portal” page as the default “new tab” view, individual tab processes, dynamic tabs (ala Safari 3.1), and “incognito mode” (is that the Red Hat mascot I see in the corner?). Underneath the hood, I’ve heard it uses a combination of opensource code from Safari’s Webkit and Mozilla’s Gecko engines, so it should be interesting from a web development perspective.

All in all, from what I’ve read others saying, it looks like Google took some opensource browser code, implemented a few nifty FireFox addons as default features, and slapped a shiny Google interface on it. My test run for Chrome won’t happen until it’s available for linux, but if you’re itching to see it, check out LifeHacker’s first look at Chrome (using the Windows release).

If any of you have a question you think I could answer (that other readers would be interested in, of course ), by all means, shoot me an email. Tips on possible subjects would be appreciated, too.

I found this trick over at labnol.org. Simply change the about:config key keyword.url to http://www.google.com/search?q= and make sure keyword.enabled is set to true.

The default value of keyword.url is http://www.google.com/search?ie=UTF-8&oe=UTF-8&sourceid=navclient&gfns=1&q=. Most likely, OpenDNS has this particular string programmed into their system, to catch navbar searches from FireFox (and IE) with default settings. Change the setting, and you can skirt the redirect .

Apparently, Gnome will automatically detect changes in the wallpaper image file, and update the desktop accordingly. No joy with KDE4 - apparently the devs assume we’ll never change the image . Fortunately, there’s a way to “trick” the KDE4 wallpaper rotator into updating the wallpaper with the latest sun map image.

First, create a folder to contain the sun map images, I created /usr/share/wallpapers/worldmap . Next, setup a cron job to automatically pull the updated image. Run “sudo crontab -e” in a terminal. This will start you editing root’s cron file. Paste the following as it’s own line in the cron file (Shift+Insert usually acts as paste for CLI editors):

Be sure that it’s all on one line, and be sure to edit the -scale option for the convert command to match your own screen resolution, and the directory paths to match your directory. Save and exit. This command will pull the sun map image from the server that maintains it, and run it through the convert command to rescale it and convert it to a PNG image. Then, it will copy the output file to a file in the same directory with a different name. The cron options (the “10 * * * *”) specify that the command will be run ten minutes after every hour (apparently the map image is updated shortly after every hour).

Alternatively, you can copy and paste the following into a plain text file, add the proper permissions to make the file executable (chmod +x file), and use whatever scheduling software you like to run the script shortly after every hour:

This script does the same thing, but in a more easily customizable form.

Once you have the script setup, run it once to get the initial files, and point KDE4’s wallpaper slideshow to the directory containing the two files. It will loop through the two files (both of which are updated every hour), constantly updating your wallpaper with the changes.

In addition to gmail-style email hosting for your domain (and ThunderBird and Outlook hookup instructions to boot), GAppsFYD, as LifeHacker calls it, sports Docs, Chat, and Calendar, all private to specified users of your domain. It also includes Web Pages, giving you space to host static web pages (but you have your own server for that — right?); Sites, a collaborative intranet-style hosting space; and a Start Page, a central page from which all domain users can access the activated services. Best of all, you can activate/deactivate whichever services you choose, allowing only what you need.

Each domain you set up with Google Apps can accomodate up to 100 users under the free version. If the email service is activated, each user gets their own inbox with up to 6GB of storage. You can also setup multiple addresses per user (with one shared inbox amongst them), and a “catchall” email address, where mail sent to a nonexistent user will end up. And, of course, you get all the standard advantages of gmail.