The proxy is now running on my local server which sits behind the real gateway. Besides making the device use the server as gateway and enable NAT on the server this single iptables rule is all that is needed:

iptables -t nat -A PREROUTING -s $CLIENT_IP -p tcp --dport 80 -j REDIRECT --to-port 8080

After some digging it turned out to be a problem with locking. A mutex was never unlocked when returning in the exception handler. This was very strange as the unlocking should be done by the MutexLocker destructor.

I was able to reproduce the problem with a simple test program so I concluded that it was indeed a compiler bug and reported it: Destructor not called when returning in exception handler.

Not every day you get to find a compiler bug…

As a test I converted my program that enables the volume knob on Dell USB keyboards. You can find it on my gitweb site.

Also there is the selinux policy module I blogged about in my previous post, and a new one that I had to do to get gitweb to work. Getting gitweb to work also required the git repositories to be properly labelled:

semanage fcontext -a -t httpd_sys_script_ro_t '/home/git(/.*)?'
restorecon -Rv /home/git

Some day I need to figure out the correct syntax for putting file contexts in the policy module.

While on the subject, I have to remember to try Korundum when I get back to Linköping.

Instead of merely testing a boolean expression, you can assign the expression to a variable that makes the implication of the test unmistakable.

The following code was my first try, not employing the tip.

void CETabWidget::wheelEvent(QWheelEvent *e)
{
  QTabBar *tabs = tabBar();
  if (e->y() < tabs->y() || e->y() > (tabs->y() + tabs.height())) {
    e->ignore();
    return;
  }
 
  // handle wheel event
}

Even though I wrote the code myself, I have problems understanding it. And making sure it’s correct takes more than a quick glance. If you want to understand this code in six months, you have to add a comment. So let us take a look at the same code rewritten to use two extra booleans.

void CETabWidget::wheelEvent(QWheelEvent *e)
{
  QTabBar *tabs = tabBar();
  const bool cursorAboveTabBar = (e->y() < tabs->y());
  const bool cursorBelowTabBar = (e->y() > (tabs->y() + tabs->height()));
  if (cursorAboveTabBar || cursorBelowTabBar) {
    e->ignore();
    return;
  }
 
  // handle wheel event
}

Now you can quickly figure out that the wheel event is only handled if the cursor is inside the tabBar. And it’s actually possible to take a quick look and be sure that the code is doing what it’s supposed to.

Of course, for this to be of any good, you need to give the boolean variables meaningful names. Naming them a and b wouldn’t help a bit.

The best thing with this approach? You don’t have to write comments and still get code that people can understand. Ah, the joy!

The use of ‘protagonist’ in place of ‘proponent’ has become common in the 20th century and may have been influenced by a misconception that the first syllable of the word represents the prefix pro- (ie. ‘favoring’) rather than proto-, meaning first (as opposed to deuter-, second, in deuteragonist, or tri-, third, in tritagonist). For example, usage such as “He was an early protagonist of nuclear power” can be replaced by ‘advocate’ or ‘proponent’.

So, now that you know that, go read this post about language protagonist. Great read.

First: “the named return value extension”. The idea is to avoid creating a temporary variable that’s assigned a value and then returned by value, thus creating an unnecessary copy. A small example:

std::list<int> foo(int j) return l();
{
  l.push_back(j);
}

This example will create just one list and append j to that. Without this extension a local list needs to be created, j appended to that and the copy constructor invoked when returning. This extension is deprecated in g++ 3.3 and removed in g++ 4.0.

My other example is the “min and max operators”. No, this is not about min and max macros nor the std::min and std::max functions. This is the min and max operators.

int min = x <? y;
int max = x >? y;

There is of course also a short-hand version for assigning one of the variables the smallest (or biggest) value of the two.

x <?= y;
x >?= y;

They are all deprecated in g++ 4.0.