My setup runs on Apache/Linux, on a subdomain of one of my sites. I have a root SVN directory that can hold multiple repositories. While the repos are accessible via SVN, you can also browse them through a web interface (though it’s fairly simple, basically just lists of “directory” contents). The repos give anonymous access for checkouts and other “read” functions, but are login-protected for commits and other “write” functions.

The guides I came across for setting up SVN mostly want you to put your settings in the file /etc/apache2/mods-available/dav_svn.conf , but I found that it works just fine if you set it up like a regular site/subdomain. That is, as a VirtualHost entry in a file in /etc/apache2/sites-available. So here is my VHost entry for SVN:

<VirtualHost *>
        ServerName svn.eternicode.com
        <Location />
                Order allow,deny
                Allow from all
                DAV svn
                SVNParentPath /var/www/svn
                SVNListParentPath on
                AuthType Basic
                AuthName "Eternicode SVN Repo"
                AuthUserFile /etc/apache2/mods-available/dav_svn.passwd
                <LimitExcept GET PROPFIND OPTIONS REPORT>
                        Require valid-user
                </LimitExcept>
        </Location>
        ErrorLog /var/log/apache2/error_svn.log
        CustomLog /var/log/apache2/access_svn.log combined
</VirtualHost>

Most of the special, SVN-specific stuff comes inside the <Location> tags; the ServerName, ErrorLog, and CustomLog are standard Apache directives.

SVNParentPath is the “root” repo directory; your various repos will be below this directory. If you only want to host a single repo here, change the directive to just “SVNPath”. The SVNListParentPath allows web access to a listing of all available repos; if you use SVNPath, remove SVNListParentPath. If SVNListParentPath is off or omitted, users will get a 403 Forbidden error when browsing the parent directory.

AuthType, AuthName, and AuthUserFile define the login settings; the AuthUserFile is created with the htpasswd command.

The LimitExcept section is where we differentiate between anonymous reads and protected writes. For everything other than GET, PROPFIND, OPTIONS, and REPORT methods, we want to Require a valid-user; if someone wants to commit, they have to authenticate according to the AuthUserFile defined above.

One issue I ran into was that, after everything was seemingly set up properly, any svn commands would result in a “Moved Permanently” error. It turned out that I had defined the DocumentRoot to also be /var/www/svn; this would conflict with the svn settings, confuse apache, and result in the Moved error. Don’t include a DocumentRoot; the svn setup will take care of everything once you give it an SVNParentPath.

Credits: Sematopia.com has a nice little guide that takes you through steps outside of the apache configuration (though their 4-line apache config is scarily sparse). Sellersrank.com has a guide for setting up Apache-run SVN over https; though I’m not using https, this guide helped me get my settings right.

A few notes: Don’t use a DocumentRoot, only use the SVNParentPath. Make sure the parent path is owned by user and group www-data (or whatever user your apache instance uses). You can ensure this by:

$ sudo chown -R www-data.www-data /var/www/svn

While it would be extremely nice to be able to create new repositories with a simple “svn import”, it seems svn’s capabilities are restricted in that area. It wouldn’t be too difficult to set up a cron job to monitor the SVN logs and create new repos as required, but that’d be hacky and inadequate. To create a new repository, you first have to run

$ sudo svnadmin create /var/www/svn/new_repo

on the server. However, in order to not have issues with the fact that the web server owns all the svn files, I’d recommend creating new repos as the www-data user:

$ sudo su www-data -c "svnadmin create /var/ww/svn/new_repo"

Once the initial repo structure is created, you can then use “svn import” on a remote machine to import the first revision.

$ echo `printf "%05d" 3`
00003

However, this only works with numbers. Actually, it only works with integers (bash can’t handle floats, apparently). Worse, it only pads on the left with zeros. No right-padding, no “other character” padding.

$ echo `printf "%05d" -`
bash: printf: -: invalid number
00000
$ echo `printf "%05s" -`
-

Breaking out of numbers and into string concatenation, however, makes it a bit easier:

function lpad {
    word="$1"
    while [ ${#word} -lt $2 ]; do
        word="$3$word";
    done;
    echo "$word";
}
$ lpad 3 5 0
00003

“But it’s the same output!” you say? Well, for this input it happens to be, yes.

$ lpad 4 5 -
----4
$ lpad hello 11 -
------hello
$ lpad hello 11 !
!!!!!!hello

We can even pad with whitespace:

$ echo "'`lpad hello 11 \ `'"
'      hello'

Here I’ve printed single quotes around the results to show the space padding, and used the backslash to escape the space in the command, so it would be used as $3 rather than be seen as CLI whitespace (and ignored).

Of course, this function can be switched around to make an rpad function, and extended to make a cpad function:

function rpad {
    word="$1"
    while [ ${#word} -lt $2 ]; do
        word="$word$3";
    done;
    echo "$word";
}
function cpad {
    word="$1"
    while [ ${#word} -lt $2 ]; do
        word="$word$3";
        if [ ${#word} -lt $2 ]; then
            word="$3$word"
        fi;
    done;
    echo "$word";
}
$ rpad "w00t" 15 ^
w00t^^^^^^^^^^^
$ cpad "hello, world" 50 -
-------------------hello, world-------------------

Of course, these functions aren’t perfect, as they make (at least) the following assumptions:

1. Inputs $1 (word to pad), $2 (length to pad to), and $3 (padding characters) are given.
2. Input $2 is a number.
3. Input $3 is one character, and no more.

Assumption #1 means that if, for example, only $1 and $2 are given, the function will go into an infinite loop (or actually exit with an error, “bash: [: 8: unary operator expected"). This can be fixed by checking for those variables' existence, and initializing some internal variables to default values if they are not:

function lpad {
    if [ "$1" ]; then
        word="$1";
    else
        word="";
    fi;

    if [ "$2" ]; then
        len=$2;
    else
        len=${#word};
    fi;

    if [ "$3" ]; then
        padding="$3";
    else
        padding=" ";
    fi;

    while [ ${#word} -lt $len ]; do
        word="$padding$word";
    done;
    echo "$word";
}

Here, the "word" defaults to a blank string, the "length" defaults to the length of the word, and the "padding" defaults to a space. If only the word is given, the word will be returned. If word and length are given, word will be padded with spaces. If all three are given, it works fine.

Assumption #2 means that if $2 is a string containing anything other than digits 0-9, the function will exit with an error ("bash: [: <length>: integer expression expected"). This can be fixed by "filtering" any non-digit characters out of the length string:

    if [ "$2" ]; then
        len=$((`echo $2 | sed 's/[^0-9]//g'`));
    else
        len=${#word};
    fi;

This uses the sed tool, which should be available on most if not all *nix systems, to replace all non-digits ([^0-9], in regex notation) with nothing, then converts the result from a string of numbers to an actual number with $(()). This means that "5uh0oh0" will be turned into 500. We'll get a scary big string in that case, but at least we won't get errors!

Assumption #3 means that if the pad string is more than one character, the result *could* be longer than the length we wanted. For example:

$ string=`cpad hey 50 -`
$ echo ${#string}
50
$ string=`cpad hey 50 -=`
$ echo ${#string}
51

In the second example there, the length of the output string actually has one extra character. This is because the function only adds the padding while the length of the string is less than our specified length; it doesn't actually do any length-checking once we've gone beyond the "length less than" test. This is fixed slightly less simply, and requires different logic for each function:

function rpad {
    ...
    while [ ${#word} -lt $len ]; do
        word="$word$padding";
    done;
    while [ ${#word} -gt $len ]; do
        word=${word:0:$((${#word}-1))}
    done;
    echo "$word";
}
function lpad {
    ...
    while [ ${#word} -lt $len ]; do
        word="$padding$word";
    done;
    while [ ${#word} -gt $len ]; do
        word=${word:1:$((${#word}-1))}
    done;
    echo "$word";
}
function cpad {
    ...
    while [ ${#word} -lt $len ]; do
        word="$word$padding";
        if [ ${#word} -lt $len ]; then
            word="$padding$word"
        fi;
    done;
    while [ ${#word} -gt $len ]; do
        word=${word:0:$((${#word}-1))}
        if [ ${#word} -gt $len ]; then
            word=${word:1:$((${#word}-1))}
        fi;
    done;
    echo "$word";
}

The solution uses the bash substring notation, ${variable:start:length}, to strip off extra characters at the end/beginning when the resulting string is too long. Of course, this isn't a perfect fix; if you specify a shorter length than your input string, the string will simply be truncated to that length. Also, if you use a long string for padding with cpad, you'll get unbalanced output.

$ lpad "hello, world" 5
world
$ rpad "hello, world" 5
hello
$ cpad "hello, world" 5
lo, w
$ cpad hello 50 ---=--=---
-=--=------=--=---hello---=--=------=--=------=--=

You could easily continue to refine this function to make it obey all sorts of preconceptions, but I'm going to stop here. If you use the functions as they're meant to be used -- numerical lengths and single-character paddings, etc -- it'll all be fine.

Though if you do find a nice, concise way to make these behave "properly", feel free to share in the comments!

Occasionally, I’ll want to keep an eye on specific processes and their resource usage, but they won’t show up in my “top” screen, no matter how I sort the fields. At this point, I have to use “ps” to find the PID (process ID) of each process I want to watch and add each PID to the end of the “top” command (using the -p switch for each PID), just to watch a few specific processes.

This little process is well-defined and repeating. Just the kind of task computers were designed to handle. I wrote a bash script which takes any number of arguments — all of them names of processes you want to watch — finds all related PIDs, and tacks them on to a top command.

#!/bin/bash

ps=""

for p in $*; do
    ps="$ps `ps -e | grep $p | awk '{print $1}' | sort -n | sed 's/^/-p /' | tr '\n' ' '`"
done

while [ `echo "$ps" | grep -c "  "` -ne 0 ]; do
    ps=`echo "$ps" | sed 's/  / /'`
done
ps=`echo "$ps" | sed 's/\(^\s*\)\|\(\s*$\)//'`

if [ -z "$ps" ]; then
    echo "No processes found."
else
    top $ps
fi

Please only use the above as a reference! The script uses a lot of single quotes, which WordPress likes to convert to “smart” quotes. To see the script as it should be, you can view the script as a text file.

The first chunk (”for p in $*…”) iterates over all the arguments, pulling out all the associated PIDs. The second block (”while…”) replaces multiple spaces with single spaces within the extracted process list, and trims any whitespace off of the beginning and end, to prepare the string for the test at the end. The last part (”if [ -z…”) checks if the process list is empty or not (if it’s all spaces, it’s “not”). If it is empty, the script alerts you and exits — you won’t get an empty top list (or full, since there are no arguments passed). If it’s not empty, we can assume we found some PIDs, so we tack that on to the top command and take you straight there.

If you want to use this, just stick it in an executable file in your path (see “echo $PATH” at the command line); I simply named mine “btm”, but it doesn’t matter what you call it. If you have any command line arguments you like to pass on to top, you can stick them between “top” and “$ps” in the “else” part of the script. Once it’s all set up, just call the script with the process names you want to watch:

$ btm rsync firefox thunderbird

Keep in mind that this will only work with processes that are currently running — once that rsync job is done, it’ll disappear from the list, but no new rsync jobs will show up unless you re-run the script.

In this case, I’ve spent the past couple days messing with Conky (yes, it is as addicting as they say). A google search will tell you what it is, and another will show you all the cool things it can do. One thing that absolutely irked me, though, was the lack of transparency under KDE4. Basically, my options were:

1. Use “own_window_type override”, which seemed to allow transparency, but conky would crash unless I set use_xft to no. So I got true transparency, but no sexy fonts.
2. Use “own_window_type normal”, and use sexy fonts with use_xft set to true, but using the “pseudo-transparency” that conky uses would use the wrong wallpaper.
3. Use #2 above, but set own_window_transparency to no, and use a solid color background.

While I was tweaking conky, I was using #3. Not the best I could hope for, but the best I could get without any help. And good enough for development.

When I asked google for help, I found out several things:

1. Conky uses the wallpaper set on the “root window” for its pseudo-transparency.
2. KDE4/Plasma uses its own desktop-drawing to draw the wallpaper.
3. KDE4/Plasma does not update the root window’s wallpaper when it updates the desktop’s wallpaper.
4. The latest and greatest KDE4 versions are phasing out DCOP support in favor of DBUS. DCOP, coupled with a program called “feh”, is what many workarounds to this issue have used.
5. The DBUS interface to KDE4 is not yet fully developed, and, as such, has no way to get the current desktop wallpaper.
6. A method has been pieced together that greps the user’s appletsrc file to get the user-set wallpaper:

   feh --bg-scale "`grep 'wallpaper=' ~/.kde4/share/config/plasma-appletsrc | tail --bytes=+11`"
   

7. Nobody seems to have hacked together anything that works for those of us who use the slideshow feature of KDE4.

Figures. Anyway, after some more digging around, I’ve created a script which fixes the problem for slideshow-users:

#!/bin/bash
# kde4bg - by Andrew Rowls <andrew@techknack.net>

SLIDEPATH=`grep slidepaths ~/.kde/share/config/plasma-appletsrc | tail --lines=1 | tail --bytes=+12`
WALL=`ls --sort=time --time=atime "$SLIDEPATH" | head --lines=1`
feh --bg-scale "$SLIDEPATH/$WALL"

Part one (SLIDEPATH) greps your appletsrc file for the directory(ies) set as your slidepath. In the appletsrc file, this is probably a comma-separated list of directories, but I only wrote the script to handle one directory. Also, you may have noticed that I used the directory ~/.kde rather than ~/.kde4. I looked at the ctimes (modification times) of those files (basically, the times KDE4 last modified them). The ctime for ~/.kde4/share/config/plasma-appletsrc was about 5 days earlier than ~/.kde/share/config/plasma-appletsrc . A little further digging, and I found that the “kde4 version” had an old path to my slideshow directory, while the “kde version” had the current (ie, correct) path. If your KDE4 installation still uses ~/.kde4, change the directory appropriately.

Part two (WALL) gets the last-accessed file in that slidepath. Basically, every time Plasma changes the wallpaper, it has to *access* the image file, read it into memory, and display it. As long as the access times (read: wallpaper switches) are at least a minute apart, the current wallpaper will bubble to the top so we can grab its name. This, of course, assumes that 1) only your slideshow images are in your slidepath directory and 2) you don’t go messing with those image files very often.

Finally, part three uses feh to set the root window’s wallpaper, giving it the full path to the image file.

Now, every time you run this script, it will find the last-accessed (presumably by Plasma itself) file and set it as the background, at which point Conky can use that image for its pseudo-transparency. Since the script has to be manually run, you could put it on cron or as a part of Conky’s updating, like this:

${texeci 3 /path/to/kde4bg}

That’ll execute the script every 3 seconds from conky. You could put it as every 1 second, but I noticed that, when I tried it, the cpu usage would get a little carried away. 3 seconds is enough to keep cpu usage down while keeping the “transparency” sufficiently up-to-date.

Quick disclaimer: This was just a quick throw-together script, written based on my needs. The main issue with it right now is it only supports one slide directory. In KDE4, you can set multiple directories, but I really don’t know what that would do to the script. Probably just confuse it, but then it wouldn’t work.

Enjoy.

Before I begin listing off links, I feel the need to put a disclaimer. I realize that the title for this post will make many laugh. It makes me laugh. Why, after all, would you want to make Windows act like Linux when you can have the real deal for free? The answer is just that: Linux is not free, not in the modern sense. The switch from windows to linux is a shift in the way your world works. It’s often a shift for the better, but the shift itself almost always takes time — time to get used to a new ideology, time to figure things out, time to make things work just the way you want them to. Time that many people don’t have.

Truth is, there is simply no way to make Windows akin to Linux in any way, shape, or form. They are two different environments, two different philosophies. However, thanks to third-party developers and a fairly open distribution platform (I’m looking at you, Apple), it’s possible to bring some functionality to the Windows desktop. You can’t change its personality, but you can change its behavior. This list is meant to bring some linux-y goodness to those without the time to jump in head first.

Now, with that out of the way, the list:

• Clipboard history: something so small, so unnoticeable until you need it, and so nice to have when you do need it. ClipX; 131K download; 252K footprint (no plugins, 25 items, text only).
• Virtual desktops: Most linux distros come with virtual desktops or workspaces. Once you learn to work with them, you can’t work without them. VirtuaWin; 385K download; 1.3M footprint (four desktops). Won’t give you the Compiz cube, but you shouldn’t be expecting that anyways .
• Window snapping: a nice feature for those who like to work with non-maximized windows in the corners of their desktops. AllSnap; 69.4K download; just over 1M footprint (portable version via startup folder, desktop snapping only)
• Systray minimization: I got used to Amarok minimizing to the systray, and I wanted Windows Media Player to do the same. TrayIt!; 327K download; just over 1M footprint (one window rule for WMP).
• Launchy/Gnome-Do/Program Launcher: I never had much luck with launchy under linux, so I ended up using Gnome-Do for app launching. Win7, however, seems to do fine with its Start Menu searchbar. No download, native footprint.
• Wallpaper rotater: while not strictly functional, it is nice to be able to choose a number of images to auto-rotate through as a wallpaper. Win7 has this built in. No download, native footprint.

Moving from a well-established Linux environment to a squeaky-clean Windows environment is bound to be a bumpy experience without first determining suitable replacements for all the programs that one uses on a daily basis. After my initial move-in, I was rather ad-hoc in finding replacements. Now that I’ve found suitable replacements for my most-used programs, perhaps this list can help those of you looking to make n experimental switch.

• BitTorrent: I do a lot of torrenting, so a good replacement for KTorrent is necessary. uTorrent has so far served my purposes for the odd torrent, while I continue to use my automated torrent system on my home server for TV shows and such.
• IM client with AIM and IRC: I sit on IRC channels all day long these days, occasionally throwing in a word or two, but mainly gleaning whatever knowledge I can from the chatter. Also, I have an AIM account that is my main real-time online point-of-access. I’ve gotten used to Kopete, but it’s lacking in just the right areas so as to make me dissatisfied with it. Recently I’ve installed Pidgin (under Kubuntu), and I’ve found that it has its own quirks that I’m dissatisfied with, perhaps more so than with Kopete. The release of kDE4-only Kubuntu 8.10 has further disappointed me: Kopete lost its IRC capabilities, and I was forced to use Konversation for IRC, but it has been an exceptional IRC program. Here on Windows, the options are rather scarce — Pidgin is available, but suffers from the aforementioned shortcomings. I’ve heard great things about Digsby, but it doesn’t seem to support IRC at the moment. However, as I was forced to split my chatting between two programs on linux, doing the same on windows isn’t too bad a compromise. I use Digsby for AIM, and YChat, which seems to be a branch of XChat, for IRC. I am not completely satisfied with YChat as a Konversation replacement, because it has no auto-login, auto-identification, or auto-join features that work on Win7 (seems to be a dll issue here), but it works well enough.
• Desktop Feed Reader: My primary feed reader for feeds of interest to me is Google Reader, and that isn’t going to change. However, I also use a desktop feed reader to toss temporary feeds like ebay and craigslist search results into. On linux I’ve grown accustomed to using Akregator, simply because it’s included with Kubuntu. Here on Windows, however, FeedDemon has taken the role quite nicely.
• Music/Video playback, a la Amarok/Kaffeine: I love my music. And I love my video, whether it be downloaded TV shows or a DVD. And I have to have some way to play them. Regarding music, my needs are not outrageous — I just need some way to organize my music, fetch album info from the net, and perhaps display album art for me. I don’t care for song ratings or anything fancy like that. Windows Media Player works well in regards to both audio and video, and even works with my Inspiron’s front-side music player controls.
• Gimp or PhotoShop: Being in web development, I do occasionally do graphics editing. For this, I need Gimp at the least, though I would like to try PhotoShop. I’m going to attempt to install PS CS4 at some point, but I’m afraid I won’t have the free disk space for it. Bummer.
• Advanced text editor: On Kubuntu, I used Kate for text editing (HTML, CSS, PHP, etc files). My requirements here are syntax highlighting, tabs, and sessions. Code collapsing is a nice feature, but not required. I will likely use Notepad++ on Windows, though I haven’t done much development lately to really test its workflow yet.
• Firefox, Thunderbird, and Sunbird: I’m sorry, there is no replacement for these three .
• Office software: On Linux, I got by fine using OpenOffice. However, since I have free access to Office 2007, I am using that. Sorry, OSS radicals.
• Filezilla: Again, no replacement.
• PDF Viewer/Printer: Another thing that comes stock with Kubuntu. Foxit is good for PDF viewing, and CutePDF works for a printer.
• File manager: Requirements in this area include all the things I’ve come to expect from Konqueror: tabbed interface (with spring-loaded tabs, no less), session management, and easy switching amongst various folder views (icons, details, etc). CubicExplorer fits the bill quite nicely, though I still find myself opening Windows Explorer for short filemanaging stints.
• SSHfs: This was rather high on my priority list, as I have my web development folders, which reside on my server, mounted locally as SSHfs shares. This means that, whenever I have internet access, I can simply open, edit, and save the files at home as if they were on my local machine. Unfortunately, no SSHfs for Windows seems to exist. I had heard things about Novell’s netdrive.exe, but it doesn’t support sftp. Dokan’s SSHfs looked promising, but, alas, would not install on a Windows 7 environment (even in Vista compatibility mode). For now, I have to resort to WinSCP for SSH-based editing, but it doesn’t come near the convenience of SSHfs.

For example:

void blah(int width, int height) {
    unsigned char Array[height][width];
}

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:

void blah(int width, int height) {
    unsigned char** Array = (unsigned char**)malloc(height*sizeof(unsigned char*));
    for (int i=0; i<height ; i++) {
        Array[i] = (unsigned char*)malloc(width*sizeof(unsigned char));
    }
}

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])?

void blah(int width, int height) {
    unsigned char*** Array = (unsigned char***)malloc(height*sizeof(unsigned char**));
    for (int i=0; i<height ; i++) {
        Array[i] = (unsigned char**)malloc(width*sizeof(unsigned char*));
        for (int j=0; j<width; j++) {
            Array[i][j] = (unsigned char*)malloc(3*sizeof(unsigned char));
        }
    }
}

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):

// One dimension -- easy enough:
unsigned char* OneDim = (unsigned char*)malloc(width*sizeof(unsigned char));
for (int i=0; i<width ; i++) {
    OneDim[i];
}

// Two dimensions -- a little trickier:
unsigned char* TwoDim = (unsigned char*)malloc(width*height*sizeof(unsigned char));
for (int i=0; i<height; i++) {
    for (int j=0; j<width; j++) {
        // TwoDim[i][j] =
        TwoDim[i*width+j];
    }
}

// Three dimensions -- w00t, crazy!
unsigned char* ThreeDim = (unsigned char*)malloc(width*height*3*sizeof(unsigned char));
for (int i=0; i<height; i++) {
    for (int j=0; j<width; j++) {
        for (int k=0; k&lt;3; k++) {
            // ThreeDim[i][j][k] =
            ThreeDim[(i*width+j)*3+k];
        }
    }
}

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

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):

#************** Automagic Torrent Management  ****************#

# Maintain session info in /torrents/session
session=/torrents/session

# Drop .torrent files in /torrents/loading (or /torrents, if starttor can handle "misguided" files)

# Use "starttor" script on cronjob to keep /torrents/watch occupied with three or fewer .torrents

# Load torrents in "watch" directory (check every 5sec)
schedule = watch_directory,5,5,load_start=/torrents/watch/*.torrent

# Download torrents to "active" directory
directory = /torrents/active

# Move to "seeding" directory and seed when downloaded
on_finished = seed,"execute=mv,-u,$d.get_base_path=,/torrents/seeding/ ;d.set_directory=/torrents/seeding/"

# Close when seed ratio reached (check every 60sec)
schedule = ratio,60,60,"close_on_ratio=110"

# Move to "finished" on close (when both the file is downloaded and the ratio is reached)
on_close = move_fin,"execute=mv,-u,$d.get_base_path=,/torrents/finished/ ;d.set_directory=/torrents/finished/"

# Delete .torrent files in /torrents/watch when torrent is closed
on_close = remove_fin,"execute=rm,$d.get_tied_to_file="

# Torrent is downloaded, seeded, and done with.  Use custom script to move to appropriate directory.

#*************************************************************#

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:

#!/bin/bash

# Root dir (for finding "misguided" torrents)
root="/torrents"
# Loading dir (for inactives)
loading="/torrents/loading"
# Watching dir (for actives)
watch="/torrents/watch"
# Archive dir - leave blank (archive="") if you don't use one
archive="/torrents/.archive"
# max # torrents at once
N=3

# max-1 for comparisons
N=$(($N-1))

# Move all "misguided" torrents (thrown into the root dir) to the "loading" dir
misguided=`ls "$root" | grep .*\.torrent | replace " " "~"`
for torrent in $misguided; do
    torrent=`echo $torrent | replace "~" " "`
    # Make all .torrent files rw/r/r
    chmod 644 "$root/$torrent"
    mv "$root/$torrent" "$loading/"
done

# If N or more active torrents, don't do anything
active=`ls "$watch" | grep .*\.torrent | grep ".*" -c`
if [ $active -gt $N ]; then
    exit 0;
fi

# If no inactive torrents, do nothing
inactive=`ls "$loading" | grep .*\.torrent | grep ".*" -c`
if [ $inactive -eq 0 ]; then
    exit 0;
fi

# While we have inactive torrents and less than 3 active, copy over inactives
tostart=`ls "$loading" | grep .*\.torrent | replace " " "~"`
for torrent in $tostart; do
    torrent=`echo "$loading/$torrent" | replace "~" " "`
    active=`ls "$watch" | grep .*\.torrent | grep ".*" -c`
    if [ $active -gt $N ]; then
        exit 0;
    fi
    if [ -n $archive ]; then
        cp "$torrent" "$archive/"
    fi
    mv "$torrent" "$watch/"
done

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:

*/10 * * * * /home/andrew/bin/starttor

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.

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):

10 * * * * wget http://www.opentopia.com/images/cams/world_sunlight_map_rectangular.jpg -O- | convert - -scale 1440x900 /usr/share/wallpapers/worldmap/worldmap.png && cp /usr/share/wallpapers/worldmap/worldmap.png /usr/share/wallpapers/worldmap/worldmap1.png

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:

#!/bin/bash

dir="/usr/share/wallpapers/worldmap"
file="worldmap"
file2="worldmap1"
format="png"
scale="1440x900"

wget http://www.opentopia.com/images/cams/world_sunlight_map_rectangular.jpg -O- | convert - -scale ${scale} ${dir}/${file}.${format}
cp ${dir}/${file}.${format} ${dir}/${file2}.${format}

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.

To host your own website, you need a computer with an HTTP server, and a decent (not dialup) always-on internet connection. A spare computer (used as a “dedicated server”) with, say, a 333MHz processor and 256MB memory is plenty sufficient to serve a low-traffic website, especially if you put an operating system with low resource requirements on it. If you have a “modern” home computer (usually 1GHz+ and 512MB+), you could even install the web server on that machine, provided you always leave the machine running. Hard drive requirements are very small as well; if you are using a dedicated server, you could use a 10GB hard drive and have more than enough space for your website.

Once you have a machine designated as your server, you need to set it up. If you have a dedicated server, and you plan on using the existing operating system, make sure that no unnecessary programs start running at startup. Once the operating system is prepped (or installed, as the case may be; your home computer can most likely be run normally), you need to install the web server.

In terms of web servers, Apache is the most widely used. And it’s free. And it’s bundled with Ubuntu server edition, should you choose to add it during installation. These reasons and more make Apache a good web server to start with (and, ultimately, stick with). Once you have Apache installed, it needs to be setup to know what files to serve as what website. Check out the Apache Virtual Host documentation for details on setting up individual websites.