• http://feeds.ubuntu-nl.org/UbuntuSecurityNotices
• http://feeds.ubuntu-nl.org/DapperChanges
• http://feeds.ubuntu-nl.org/EdgyChanges
• http://feeds.ubuntu-nl.org/FeistyChanges
• http://feeds.ubuntu-nl.org/GutsyChanges
• http://feeds.ubuntu-nl.org/HardyChanges
• http://feeds.ubuntu-nl.org/IntrepidChanges (still empty of course :))

In related news: It’s now happened too often that I had to walk a user through the boot with live cd/find partition/chroot/passwd hoops after they forget the password for their account. So I whipped up a shellscript that one can wget and run from a live cd. It searches for partitions with linux installs on them and allows you to the password for any account on them that has a usable password. So now these hoops are reduced to:

• Boot from a live cd
• Go to applications » accessories » terminal
• Type this: wget http://media.kaarsemaker.net/reset_passwords && bash reset_passwords
• Reboot

Result:

Now this is bad for you but tastes soooooo good!

Anyway, apparently someone uploaded both his shows to youtube and sure enough I watched them. Jeff’s quite rude at times but overall pretty funny, at least much funnier than many so-called comedians out there. Motivated by this, I searched for ‘ventriloquist’ on youtube and sadly the result was less than stellar.

Until I saw Terry Fator that is. Last year Terry apparently was a candidate in “America’s got talent”, a show I didn’t even know existed. He is absolutely brilliant! Funny, good impersonator, excellent singer and amazing entertainer. If you’ve never seen him, you absolutely should go to youtube and search for his impersonation of Roy Orbison. While you’re at it, watch it all. BRILLIANT!

The latest quick hack didn’t work properly at the 2nd station, so I looked up documentation, found my error and now I present: nm_unset - a very simple tool with which you can remove wifi networks for network manager from gconf. I simply got tired of having to use gconftool-2 –recursive-unset /system/networking/wireless/networks/$ssid all the time (and of having to explain how to do this to new users on #ubuntu). I’m really hoping that they soon provide something in n-m for this so I can toss this out again.

…oh crap, it’s the 11th already

Been quite busy the past weeks, so not much writing has happened. After christmas I finally picked up work on falcon again. Version 2.0.0 was finally finished and Brandon Holtsclaw was kind enough to upload it to Ubuntu, Yeah! Of course a few bugs were found (and fixed) after that, so version 2.0.4 will be uploaded shortly, which is the recommended one.

At work (where we need more linux sysadmins, prod if interested!) I have been working on a project I called imagine, it’s an OS ‘installer’ that can make an image of your harddrive and install it on another machine. That’s nowhere near unique of course, but this thing runs entirely from initramfs so you can simply use network booting and don’t need other media than a server to store the compressed images. Best thing about it is that the COO allowed me to distribute the code as free sofware, so when that finally clears with legal, you’ll see more of it!.

(more…)

def factorial(x):
    if x < 0:
        raise ValueError("Factorial is only defined for x >= 0")
    y = 1
    while x >= 2:
        y *= x
        x -= 1
    return y

Permutations can easily be defined recursively, but that limits you to sets of 1000 items (maximum recursion depth). So better to make an iterative function. Even better: instead of returning a list, use a generator so you don’t have to copy an array many times. This is also a perfect example of writing obfuscated code in a clean language like python.

def permute(items, i):
    items = items[:]
    n = len(items)
    m = factorial(n)
    while n:
        c = (i%m) * n / m
        yield items[c]
        items.pop(c)
        m /= n
        n -= 1

Example:

>>> import permute
>>> items = [1,2,3]
>>> for i in range(permute.factorial(len(items))):
...     print list(permute.permute(items, i))
...
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

Every day, I travel about 80 minutes to work and 80 minutes back, by public transport. This is rather boring but fortunately I usually have my laptop with me, so I can do some work or experiments. Last week I started a little project I call traincoding: trying to accompish some small tasks while on the train. This is the first episode of the traincoding log.

Per-thread global variables

A simple way to make your library cumbersome to use in a threaded environment, is the use of global variables. They often have to be locked and unlocked, which costs quite a bit of time. If the global variables aren’t neccessarily global in the process but shared between functions (a good example is the infamous errno variable, which is thread-local by the way), the posix specification gives you something useful: pthread_setspecific. With this and some other functions from libpthread you can make an errno-like thread-local global variable.

In a modern glibc, errno is no longer an extern int errno; but a macro:

#define errno (*__errno_location ())

the __errno_location function finds out the thread-local address where errno is stored. This does not need pthread_getspecific since the C runtime allocates memory for errno explicitely. For our purposes we need to do our own allocation. Of course this is not limited to integers. The only thing we store is a pointer, the C runtime does not care what the pointer points to.

So, let’s define our macro first:

#define my_var (*(__get_my_var_location()))

The __get_my_var_location function now creates the key when it’s first called. It also allocates memory when it is first called in a specific thread:

pthread_key_t __my_var_location;
pthread_once_t __my_var_init;

void __init_my_var(void) {
    pthread_key_create(&__my_var_location, NULL);
}

int *__get_my_var_location(void) {
    void *ptr;
    (void) pthread_once(&__my_var_init, __init_my_var);
    ptr = pthread_getspecific(__my_var_location);
    if(!ptr) {
        ptr = malloc(sizeof(my_var_t));
        pthread_setspecific(__my_var_location, ptr);
    }
    return (int*)ptr;
}

That’s easy to use already, but having to type out 2 functions for every variable-like macro which you want to use this way is still a bit cumbersome, so why not let the C preprocessor do it for you? Here’s where it gets evil! You can download the code at the bottom as perthread.h and simply use the following in your code (here’s a full test):

#include
#include "perthread.h"

PER_THREAD(unsigned int, foo) /* NOTE: no semicolon! */
#define foo (*(__get_foo_location()))

static pthread_barrier_t barrier;
void *thread(void *arg) {
    foo = (unsigned int)pthread_self();
    printf("thread: %u foo: %un", (unsigned int)pthread_self(), foo);
    pthread_barrier_wait(&barrier);
    printf("thread: %u foo: %un", (unsigned int)pthread_self(), foo);
    return NULL;
}

int main(int argc, char **argv) {
    pthread_t t1, t2, t3;
    void *res;

    pthread_barrier_init(&barrier, NULL, 3);
    pthread_create(&t1, NULL, thread, NULL);
    pthread_create(&t2, NULL, thread, NULL);
    pthread_create(&t3, NULL, thread, NULL);
    pthread_join(t1, &res);
    pthread_join(t2, &res);
    pthread_join(t3, &res);

    return 0;
}

perthread.h contains the following PER_THREAD macro (you have to imagine a backslash at the endo of each line, wordpress messes it up):

#define PER_THREAD(type, name)
static pthread_once_t __ ## name ## _init = PTHREAD_ONCE_INIT;
static pthread_key_t __ ## name ## _location;
void __init_ ## name (void) {
    pthread_key_create(&__ ## name ## _location, free);
}
int *__get_ ## name ## _location(void) {
    void *ptr;
    (void) pthread_once(&__ ## name ## _init, __init_ ## name);
    ptr = pthread_getspecific(__ ## name ## _location);
    if(!ptr) {
        ptr = malloc(sizeof(type));
        pthread_setspecific(__ ## name ## _location, ptr);
    }
    return (type*)ptr;
}

This macro takes care of creating your initialization function and get_location function, all with the correct type and name. To see that it’s correct, run it through the C preprocessor.

That’s part one of traincoding. See you next time!

In the past 3 years it’s been a fun ride from Ubuntu user/channel visitor in 2004, through IRC op, and then representative of Ubuntu on freenode. Earlier this year we have worked on a more formal IRC governance, resulting in an IRC council of which I have been a proud member.

But today that has all come to an end, I have resigned from the council and have placed the responsibility for Ubuntu’s presence on freenode in the caring hands of the other council members. The IRC community is a vital part of the community and is in good shape, it is time for me to do the same for my other big love inside the Ubuntu community: the dutch locoteam.

Founded in 2004, the dutch locoteam it is one of the oldest locoteams around and has seen a steady growth over the past years. We have many forum contributors and a good crew of active people, it is time to turn this enthousiastic group of people into a professional team of Ubuntu supporters.

We’re halfway there already, the active members all have great ideas on how to move forward and lots of progress has been made already. The best part so far of this is the AWESOME release party we had last saturday, we estimate the number of visitors at over 400!

On to 2008, the year of Ubuntu-NL!

At that point I slapped myself in the head for overlooking the obvious solution for the ultimate password manager: vim. It is my editor of choice and can be scripted. 2 lines in ~/.vimrc and it’s the ultimate password editor, allowing you to encrypt everything with gpg easily. Only two passwords left to remember: user account and gpg key. Profit.

map <F12> <Esc>:%!gpg --encrypt --armor --recipient dennis@kaarsemaker.net<CR><CR><C-l>
map <S-F12> <Esc>:%!gpg --decrypt 2>/dev/null<CR><CR><C-l>

F12 now encrypts and Shifs+F12 decrypts. Yay!

Update: it can be done even nicer