1. parted help states, that mkpart command syntax is:

# parted /dev/sdb help mkpart
mkpart PART-TYPE [FS-TYPE] START END make a partition

But, PART-TYPE is actually only supported for msdos and dvh partition tables. For gpt, it’s silently changed to:

mkpart NAME START END

There are so many examples around the internet, where people keep typing:

mkpart primary ext4 1024kb 2tb

and they just end up with partition named “primary” usually without even noticing.

2. I cannot find a way to omit partition name from command line. From parted interactive mode one can just hit Enter when prompted for partition name:

(parted) mkpart
Partition name? []?
File system type? [ext2]?

but apparently I can’t find a way to skip it in script mode:

# parted /dev/sdb mkpart "" 0% 300G
End? ^C


Rant done

There’s no way to configure idle detection parameters in the workrave UI, but they can be tuned by directly manipulating gsettings (or gconf for older versions). There are 3 parameters of interest (in milliseconds):

1. activity — how much time between key presses, to register activity (see bellow).
2. idle — how long before activity time expires and workrave goes back into idle mode.
3. noise — how long before activity timer is reset.

By default, single key press isn’t enough to take workrave out of idle mode — you must press at least two keys (or key + mouse) during the activity  window to count. With default settings if you press single key every 10 seconds, you are still detected as idle. For example reading a web page, and pressing PgDn every 20 seconds, won’t register as activity at all. There’s “Reading” mode for this in workrave, but you must remember to turn it on/off when you suddenly go away (long phone call?) from the computer.I’ve set my workrave to activity = 0, idle = 30. This is: every key press is activity and then I’m in active mode for the following 30 seconds. Here’s how to do it:

$ gsettings set org.workrave.monitor activity 0
$ gsettings set org.workrave.monitor idle 30000

$ gsettings list-recursively org.workrave.monitor
org.workrave.monitor activity 0
org.workrave.monitor idle 30000
org.workrave.monitor noise 9000

You must restart workrave for settings to take effect. Use gconf-editor for workrave versions < 1.10. If you are using Ubuntu, there’s 1.10 ppa: https://launchpad.net/~rob-caelers/+archive/workrave

All code is listed at the bottom of the article.

Versions: gcc 4.7.2, clang 3.0, perl 5.14.2, python 2.7.3, pypy 1.9.0, boost regex 1.49; everything stock from Ubuntu 12.10.

When I say “pointer” in the case of C it’s really advancing the pointer through the string and comparing character by character. AFAIK, you can’t go any faster than that, could you? I cheated and used std::map in the C case, because I was lazy and didn’t want to implement hash map myself, or include external libraries. I went the extra mile and used the map with char* instead of string though, so I guess it’s as fast as possible.

Although I use the same term “pointer” with python, it’s obviously not the same thing, because it’s not simple character array as in the C case, but a python str object, which is much higher level etc., so it is expected to be very slow (25x slower than O2 optimized C). The very curious thing is, that when you run the python “pointer” variant through pypy, it is only 2.4 times slower than optimized C, which is impressive! Obviously, it has some serious drawbacks too: you have to run it specifically through pypy, or you are going to be penalized heavily if you run it through standard python, and it’s also almost as verbose as the C variant — but still, you get the benefits of not needing to compile + not having to deal with pointers and all the low level stuff.

One pretty decent compromise in terms of flexibility and speed seems to be C++ with boost regex. Code is quite short and convenient, while only 2.4x slower than optimized C. On the other hand pypy with perl regex is really close behind, so I may still prefer the no-need-to-compile-and-less-arcane syntax solution.

Some day I may try extracting some more complex stats, like grouping by hits, traffic, referrers, requests etc. with pypy vs. perl vs. C++. I guess differences are going to be even larger.

Here’s the code:

g++ -Wall -O0 access.c -o access-g++-O0

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <map>
#include <iostream>
#include <cstring>

using namespace std;

struct cmp_str : public std::binary_function<const char*, const char*, bool> {
public:
	bool operator() (const char* str1, const char* str2) const
	{ return std::strcmp(str1, str2) < 0; }
};

int main() {
	#define BUFSZ 8192
	char line[BUFSZ];
	char vhost[BUFSZ];
	char size[BUFSZ];
	int i, p;
	map <const char*, int, cmp_str> vhosts;

	while(fgets(line, BUFSZ, stdin)) {
		for (i=0; i<BUFSZ && line[i] != '\0' && line[i] != ' '; i++) {
			vhost[i] = line[i];
		}
		vhost[i] = '\0';

		// fast fwd two '"'
		for (/* keep from prev. for */; i<BUFSZ && line[i] != '\0' && line[i] != '"'; i++);
		for (i++; i<BUFSZ && line[i] != '\0' && line[i] != '"'; i++);

		// fast fwd two ' '
		for (/* keep from prev. for */; i<BUFSZ && line[i] != '\0' && line[i] != ' '; i++);
		for (i++; i<BUFSZ && line[i] != '\0' && line[i] != ' '; i++);

		p = 0;
		for (i++; i<BUFSZ && line[i] != '\0' && line[i] != ' '; i++) {
			size[p] = line[i];
			p++;
		}
		size[p] = '\0';

		vhosts[strdup(vhost)] += strtoul(size, NULL, 10);
	}

	cout << "vhosts:" << vhosts.size() << endl;

	return 0;
}

-

g++ -Wall -O2 access.cpp -o access-cpp-g++-O2

#include <string>
#include <map>
#include <iostream>
#include <cstdlib>

using namespace std;

int main() {
	string line;
	string vhost;
	string size;
	map <string, size_t> vhosts;
	size_t b, e;

	ios::sync_with_stdio(false);

	while (getline(cin, line)) {
		e = line.find(' ');
		vhost = line.substr(0, e);

		b = line.find('"', e+1);
		b = line.find(' ', b+1);
		b = line.find(' ', b+1);
		e = line.find(' ', b+1);
		size = line.substr(b, e);

		vhosts[vhost] += strtoul(size.c_str(), NULL, 10);
	}

	cout << "vhosts:" << vhosts.size() << endl;

	return 0;
}

-

g++     -Wall -O2 access-boostre.cpp -o access-boostre-g++-O2 -lboost_regex

#include <string>
#include <map>
#include <iostream>
#include <boost/regex.hpp>
#include <cstdlib>

int main() {
	std::string line;
	std::string vhost;
	std::string size;

	boost::regex re ("^\\([^[:space:]]+\\) [^[:space:]]+ [^[:space:]]+ [^[:space:]]+ .*? \".*?\" [[:digit:]]+ \\([^[:space:]]+\\)", boost::regex::emacs);
	boost::cmatch m;
	std::string::const_iterator start, end;

	std::map <std::string, size_t> vhosts;

	std::ios::sync_with_stdio(false);
	while (getline(std::cin, line)) {
		start = line.begin();
		end = line.end();
		if (boost::regex_search(line.c_str(), m, re)) {
			vhost = m[1];
			size = m[2];
		} else {
			std::cout << "Not found." << std::endl;
		}

		vhosts[vhost] += strtoul(size.c_str(), NULL, 10);
	}

	std::cout << "vhosts:" << vhosts.size() << std::endl;

	return 0;
}

-

#!/usr/bin/perl
use warnings;
use strict;

my %stats;

while (<STDIN>) {
	/^(\S+) \S+ \S+ \S+ \[.*?\] ".*?" \d+ (\S+)/;
	$stats{$1} += $2;
}

printf "vhosts:%d\n", scalar keys %stats;

-

#!/usr/bin/pypy

import sys
import re

def f1():
        stats = {}
        prog = re.compile(r'^(\S+) \S+ \S+ \S+ \[.*?\] ".*?" \d+ (\S+)');
        for line in sys.stdin:
                m = prog.match(line)
                (vhost, size) = m.groups()

                if vhost not in stats:
                        stats[vhost] = 0
                else:
                        stats[vhost] += int(size)

        return len(stats.keys())

def f2():
	stats = {}
	for line in sys.stdin:
		vhost = line.split(" ", 1)[0]
		split = line.split('"', 2)
		size = int(split[2].split(" ", 3)[2])

		if vhost not in stats:
			stats[vhost] = 0
		else:
			stats[vhost] += size

	return len(stats.keys())

def f3():
	stats = {}
	for line in sys.stdin:
		llen = len(line)-1

		for i in range(0, llen):
			if (line[i] == ' '):
				vhost = line[0:i]
				break

		for i in range(i+1, llen):
			if (line[i] == '"'):
				break
		for i in range(i+1, llen):
			if (line[i] == '"'):
				break

		for i in range(i+1, llen):
			if (line[i] == ' '):
				break
		for i in range(i+1, llen):
			if (line[i] == ' '):
				break

		s = i
		for i in range(i+1, llen):
			if (line[i] == ' '):
				size = int(line[s:i])
				break

		if vhost not in stats:
			stats[vhost] = 0
		else:
			stats[vhost] += size

	return len(stats.keys())

if len(sys.argv) < 2:
	print "Usage: <fN>\n"
	exit(1)

stats = locals()[sys.argv[1]]()
print "vhosts:%d" % (stats)

-

So, that’s all about my running until last year. I’ve never run more than 3 km in my 35 years on earth. So, this last summer I was on a month long business trip to Boston, and I wouldn’t be able to ride my bike (my favourite thing). So, I decided I shall give running a try. Moreover, getting a new GPS/HR unit was in my plans (my old Sigma broke down) and they are quite cheaper in the US than Europe. There you have it: the measuring geek in me + the need to move. To make it more interesting I challenged some friends and we set a date for a friendly 5k run.

I looked around the net for some training plans and started running. I also signed with Strava – it’s much more fun than Garmin Connect. Initially, I couldn’t keep my heart rate at the low rates they recommended in the training plans. It seems, despite my MTB induced fitness (hey 2012 I rode 100km around Vitosha in 6:20!), running is too different beast and requires quite a bit of specific training to get the hang of it. All was going well – I run in the Boston area in July & August, then some more running back in Sofia. In October we went to Sithonia, Greece for few days and from there we drove through all of Greece and much of Italy up to Sardinia

In Sardinia initially everything was perfect running wise (and otherwise too), but then maybe I went too far too fast, and my right knee started to ache a bit. Some searching through the interwebs, made me think it is a case of Iliotibial Band Syndrome (ITBS). Btw, I had somewhat similar case just before “Vitosha 100″ 2012, but it was my left knee. The interesting thing about both cases is – they start to hurt some time into the exercise. The pain goes completely away the moment you stop the specific movement that “aggravates” it. For example, last year I had to ride my bike for about 45 minutes to an hour before my left knee begins to hurt. No pain whatsoever while walking. Now, this year I have to run for about 5-10 minutes before my knee begins to hurt. No pain whatsoever if I walk or if I ride my bicycle.

I quit running for almost 3 weeks prior to our friendly 5k run. Unfortunately I don’t have the means to test whether the underlying issue was healed – I had to run to see, and I was afraid I’d make it worse, so I restrained. My next run was the 5k itself on 28 October. I took one acetaminophen (paracetamol) 15 minutes before the run, just in case (I know it’s toxic to the liver). The pain flared up about 10 minutes into the run, but it was bearable, so I pushed through it and finished in 31 minutes. My hope was sub 30 minutes, but it didn’t work out :-/

November and December were the lazy months. No running at all, only very sporadic weight lifting and cycling to work here and there. I figured I’d give the knee 2 months of rest and see if it’s going to recover.

So, my plan is to ease into C25K around mid January 2012 and see how it goes. If I manage to build up without further issues till around 1 March, we’re gonna stage another friendly run around end of March or early April.

I’ve also decided to take more active part in MTB racing this year, so I’m slowly building my base fitness on the bike as well. It’s great fun commuting to work through the snow and slush

Fingers crossed.

sed -i -e 's/BAR="-c5"/BAR="-c4"/' foo

If your version of sed is antiquated and doesn’t support in-place editing you can do the same using perl:

perl -i -p -e 's/BAR="-c5"/BAR="-c4"/' foo

The problem with this approach is that if the needle doesn’t exist, sed and perl will silently skip doing the replacement. For example if upstream changes BAR="-c5" to BAR="-c3" then your sed/perl will happily and silently leave it at -c3 instead of changing to -c4 and most probably you will not notice until much later.

One can use patch instead, but it is somewhat clumsy to save a diff file with at least 5 lines in it, just to change one character in the input file…

There’s always the possibility to add some more perl code and make it:

perl -i -pe 's/BAR="-c5"/BAR="-c4"/ and $e|=1; END{exit(!$e)}' foo

I feel this is hackish and somewhat error prone though.

What’s your solution?

The theory is an evolutionary and cognitive explanation of how and why any individual finds anything funny. Effectively, it explains that humour occurs when the brain recognizes a pattern that surprises it, and that recognition of this sort is rewarded with the experience of the humorous response, an element of which is broadcast as laughter.

The theory further identifies the importance of pattern recognition in human evolution:

An ability to recognize patterns instantly and unconsciously has proved a fundamental weapon in the cognitive arsenal of human beings. The humorous reward has encouraged the development of such faculties, leading to the unique perceptual and intellectual abilities of our species.

http://www.eurekalert.org/pub_releases/2008-06/ph-maf062708.php

One very important aspect is the need for secure connection between sellers and prospective buyers. That’s were SSL/TLS come into play. The TLS protocol allows applications to communicate across Internet in a way designed to prevent eavesdropping, tampering, and message forgery. TLS provides endpoint authentication and communications confidentiality by using cryptography. If we talk about web that’s the https protocol.

With virtual web hosting, which is the most common type of shared hosting, one web server provides many domains through the same IP address and port. The server examines each request to determine which domain is being served by looking at HTTP request headers. Unfortunately, when the appropriate headers are received the server has already established the secure connection and cannot change to another SSL certificate.

So, SSL enabled virtual hosting isn’t exactly possible. Every SSL site need it’s own dedicated IP address. And there are quite a lot SSL sites out there lately, so quite a lot IP addresses are wasted.

An extension to TLS called Server Name Indication (SNI) addresses this issue. By sending the name of the virtual domain as part of the TLS negotiation it enables the server to “switch” to the correct virtual domain early and present the browser with correct SSL certificate.

The most popular web server software on the Internet, the apache web server, has had support for TLS SNI as external patch for some time (in combination with OpenSSL). It’s integrated since version 2.12 and recently even entered the Debian testing repository.

All major browsers have TLS SNI support as well, so we are almost there. Current versions of Firefox, Internet Explorer, Opera, Google Chrome, Safari do support TLS SNI. Or… wait… Internet Explorer for Windows XP doesn’t support it? Yeah, that’s right. Seems we are out of luck, because despite Microsoft releasing Vista and Windows 7, the now eight years old Windows XP is still the most popular desktop operating system on the planet.

One often overlooked asset that you badly need in order to be productive (or sometimes just to be) is your body. If you get ill or die, your performance may drop dramatically.

Maybe one of the reasons so many people neglect their health is because it takes quite a long time to collect enough damage and notice that something is wrong. One can lead a sedentary life, eat too much bad food or overeat, smoke cigarettes, and nothing bad happens overnight. Now, imagine that you are 20 years old and in rather good shape. Add 15 more years and the very next day your teeth and skin are bad, you can’t breath after climbing the stairs up to the 3rd floor, and you find it difficult to bend and tie your shoe laces. I’m sure anyone would panic in this situation. Usually, this happens very gradually. It would take, let say, ten or twenty years and every day you lose just a tiny bit from your health.

The care for your health is definitely a Q2 activity. It is important, but it doesn’t seem urgent.

With reference to evolution, humans need to move a lot. It’s not natural to be sedentary for long periods of time. Frequent and regular physical exercise boosts the immune system, and helps prevent diseases such as heart disease, cardiovascular disease, high blood pressure, diabetes, and obesity. It also improves mental health and helps prevent depression and insomnia. Exercise has been shown to improve cognitive functioning.

At the same time, excessive body weight is associated with various cardiovascular diseases, diabetes, obstructive sleep apnea, certain types of cancer, and osteoarthritis. As a result, it reduces life expectancy.

It is not only the matter of life expectancy that is at stake here but also the quality of life. It feels great to have your full range of motion, to be able to climb a flight of stairs, or to run to catch the bus with ease. These are some of the things that most of us were able to do at some time in our lives. Personally, I’ve found that it’s so much easier to learn to ski, to ice skate, or to discover a new skill once you are in good shape. Being physically fit also allows me to enjoy some outdoor sports like mountain biking for example. Some people may think that the flexibility and the joy of movement and sports is a childhood hallmark, but that’s not true. Sports are not only for professionals either.

If nutrition and physical activity have profound effects on human health, then, why are they so often overlooked? I mean, what is more important that you and your health?

Now, go and put some physical activity on your calendar. Thirty minutes of brisk walking, 5 days a week is a good start. You can also go to work on foot or by riding a bicycle. There are lots of physical activities that you can do aside from what I have already mentioned. I’ll cover some of my workouts and results in a future post so stay tuned.

Inevitably, this reminded me of a very similar situation from few years ago. In 2006, CVE-2006-2451, which is another kernel vulnerability, allowed core to be dumped in a directory that the attacker isn’t allowed to write to. A weakness in cron.d parsing similar to that in recent versions of logrotate was used as attack vector.

Just a few weeks ago, I had another deja vu. There’s a flaw in udev versions before 1.4.1 that allows local users to gain root privileges by not checking whether a NETLINK message originates from kernel (CVE-2009-1185). It took me some time to remember why this sounded so familiar since the older case is from 2003. Back then, the zebra routing suite failed to check the NETLINK message originators (CVE-2003-0858).

Oh well, to err is human, don’t you think?