TuxPool

Replay Gain on Sansa Clip+ with mp3gain

2011-12-11T14:50:00.001+01:00

If you play MP3 songs from different sources in shuffle mode on a MP3 player, their difference in loudness become apparent and you are constantly keep adjusting the volume.

In order to prevent that, Replay Gain can be used. With this function the MP3 player uses loudness information in the header of a MP3 file to adjust the volume automatically.

However, the loudness information is not present by default. You need software to analyse the content and store those values in the MP3 header. Replay Gain does not change the underlying (music) data, thus avoiding loss in quality by decoding, processing and re-encoding.

A popular utility in the Linux world to calculate these values and tagging the file is mp3gain.

I used it regularly, but I was still adjusting the volume on my Sansa Clip+ ...

What I didn't know was, that by default mp3gain stores the information in the APEv2 tag which the Sansa Clip does not read. In order to be used by the Sansa Clip's Replay Gain function, it must be stored in the ID3v2 tag.

mp3gain has an option to do exactly that: -s i

I'm now using the following command to analyse and tag my MP3 files:

mp3gain -p -s i *

Where the option -p also preserves the original file date.

Lift and AutoComplete

2011-03-03T21:58:00.001+01:00

The Lift-Web-Framework allows you easy access to JQuery's AutoComplete widget. If you have used Google, you might agree that the drop down list which is populated with entries depending on your current input is a nice thing to have.

Here is how you integrate it into your Lift application.

First you have to add a dependency to your project (in this case Lift 2.2, using Scala 2.8.0):

If you use SBT in ./project/build/Project.scala

override def libraryDependencies = Set(
...
"net.liftweb" % "lift-widgets_2.8.0" % “2.2” % "compile->default",

In a Maven project this should translate to (in pom.xls - not tested, I'm using SBT):


<dependency>
  <groupid>net.liftweb</groupid>
  <artifactid>lift-widgets</artifactid>
  <version>2.2-scala280</version>
</dependency>

The first step in your application is the initialisation, by adding the following code – usually into into Boot.scala

import _root_.net.liftweb.widgets.autocomplete._

class Boot {
def boot {
…
AutoComplete.init

In your template, the widget is represented like any other input field with a tag of your choice. This example uses

Here the snippet code to bind it:

Helpers.bind("dt", in,
...
"autocomplete" -> AutoComplete(startValue,
buildQuery _,
value => processResult(value)
),
...

where:
startValue is a string for the initial value of the AutoComplete text field.
buildQuery is a function to populate the drop down list.
processResult is a function called when the form is submitted, containing the value of the widget (or not, see bug report below).

Here is a simple example of processResult

def processResult(s : String) = {
println("%s".format(s))
}

The interesting part is the buildQuery function. It has the following signature:

def buildQuery(current: String, limit: Int): Seq[String] = {
...
}

where
current is the string typed into the autoComplete text field.
limit is an integer to limit the number of Strings returned by the function

A valid but not very useful implementation would be (from http://demo.liftweb.net/ajax)

def buildQuery(current: String, limit: Int): Seq[String] = {
(1 to limit).map(n => current+""+n)
}

Most application however will query a database. Lets assume that Mydatabase has a field called name (e.g. with the names of employees). A query might look like this:

def buildQuery(current: String, limit: Int): Seq[String] = {
Mydatabase.findAll(
Like(Mydatabase.name,(current + "%")),
OrderBy(Mydatabase.name,Ascending),
MaxRows(limit)
).map( _.name.is)
}

This will findAll names in Mydatabase which start with the currently entered string, sorts them, and limit the number of results.

That's all you need.

Bug or a feature?

The current implementation of the AutoComplete functionality (Lift 2.2) only allows the selection from a drop down list as a valid input. This sounds reasonable, but it also prevents you from clearing the input after you have made a selection. This can lead to the following situation:

At a shopping site, the user selects an article via an autocomplete field. Then he changes his mind and clears the input field using the delete key. When he clicks on the submit button the previous selected article is sent to the server, even if the screen shows an empty text field.

With the help of Sergey Andreev, I have developed a small patch which has also been published in Lift ticket 892. Even though it is only 8 lines long, it is unlikely to make it into Lift due to Intellectual Property policy consideration by DPP.

The patched version is available on GitHub.

If you copy it into your project, you might want to change the package name (first and last three lines) and replace

import _root_.net.liftweb.widgets.autocomplete._

with your package name.

Keep in mind that the returned result may contain strings (including an empty string) that might be invalid.

itrackutil 0.1.3 available

2010-12-15T01:46:00.001+01:00

After a recent update in Ubuntu 10.10 and 10.04 itrackutil.py exits with the the error message “USBError: Resource Busy” before the user is able to download GPS data from the device.
This version fixes the problem.

Developer information:

A previously unrelated kernel module (cdc_acm) suddenly started to grab the USB device. cdc_acm which usually supports USB modems now creates the device /dev/ttyACM0 as soon as the GPS mouse is plugged in.

If you read /dev/ttyACM0 you get the real-time GPS data in NEMA format. This is an unusual use case. The normal data connection is over Bluetooth.

However, the creation of this device file blocks all other USB access to the GPS mouse; in this case the direct USB communication which itrackutil.py uses to access the data stored within the unit's memory.

Fortunately there is an USB API call for this situation: detachKernelDriver.
This function does, what it says it does. You have to call it after opening the device. Root privileges are not necessary.

The call will fail, if there is no kernel driver to detach. You have to catch this exceptions:

... determine device, interface, and configuration ...

try:
    handle = device.open()
    handle.detachKernelDriver(interface)
except usb.USBError, err:
    if str(err).find('could not detach kernel driver from interface') >= 0:
        pass
    else:
        raise usb.USBError,err       # any other USB error

handle.setConfiguration(configuration)

The companion API call attachKernelDriver is not available via PyUSB 0.1. But this is only a minor problem, because as soon as you unplug the unit and reconnect it, a new USB device file is created (with the kernel driver attached).

WinTV-HVR-1900 under Ubuntu 10.04 and 10.10

2010-11-13T20:37:00.001+01:00

A few weeks ago I bought a Hauppauge WinTV-HVR-1900 (USB id 2040:7300) which I wanted to use with a (32 bit) Ubuntu 10.04 and 10.10 system.

Quick installation summary:

Does it work out of the box: No
Does it work at all: Yes
If you are able to update to Ubuntu 10.10, do it.

This post only describes how to get the basic functionality working (i.e. display/record a signal on the composite video input).

The HVR 1900 is a small box which is connected via a USB2 port (USB1 is not supported for bandwidth reasons). There are inputs for composite video (e.g. VCR or set-top box) an antenna input and a S-VHS input. The device comes with a UK power supply (with a UK mains plug) and a bulky mains plug adapter for continental Europe.

In order to get the digitizer running, this device needs firmware. Ubuntu comes with a selection of firmware images for various Hauppauge systems, but none was suitable for this device.

The firmware is included on the Windows driver disk you get with the device, but which files do you need? Fortunately there is a perl script available that scans the CD and extracts the files you need based on a bunch of MD5 sums stored in that script. Perl is installed by default on a Ubuntu system, so slide in the CD, open a terminal and enter

perl fwextract.pl /media/XXXXXXXXXX

(where XXXXX is the CD title)

In my case the following files were found:

v4l-cx2341x-enc.fw
v4l-cx25840.fw
v4l-pvrusb2-29xxx-01.fw
v4l-pvrusb2-73xxx-01.fw

For the next steps you need root privileges:

Change the ownership of those files to root (for security reasons)
sudo chown root:root *fw
Copy the extracted files to /lib/firmware
sudo cp *fw /lib/firmware

If you're running Ubuntu 10.10, that's all you have to do.

Keep an eye on the system log when you now plug the digitizer into the USB port.
tail -f /var/log/syslog

Among other messages, it should confirm that the firmware was uploaded successfully.

...
cx25840 5-0044: firmware: requesting v4l-cx25840.fw
cx25840 5-0044: loaded v4l-cx25840.fw firmware (16382 bytes)
...

Utilities for controlling the device from the command line can be found in the package ivtv-utils (from the Ubuntu repo).

v4l2-ctl --set-input 1
switches to the composite video input

v4l2-ctl --set-ctrl=brightness=128,hue=0,contrast=68,volume=54000
sets basic parameters for the digitizer.

Call v4l2-ctl without parameters for more help, and you will definitively want to try the switch -L

Recording is as simple as:
cp /dev/video0 video.mp2

This works most of the time. Approx. 5% of the recordings contain a distorted audio stream. This distortion is present for the whole length of the recording and usually ends the next time the device /dev/video0 is opened.

If the audio is ok at the beginning, it stays that way. This looks like an initialization problem when the device is opened. I haven't found a fix, yet.

Now to the more difficult part:

Getting the device to work under Ubuntu 10.04.

As mentioned before, many Hauppauge devices need firmware, which is uploaded to the unit when you plug it into the USB port. Older hardware only needed 8192 bytes of firmware. The firmware for this device however is 16382 bytes long (see the above firmware upload message from the log). The device driver controlling the HVR-1900 (pvrusb2) that comes with kernel 2.6.32 and earlier is only capable of transferring 8192 bytes. And Ubuntu 4.10 LTS uses... 2.6.32.

Newer versions of the pvrusb2 driver can also upload the larger firmware. For older kernels (like the one used in Ubuntu 4.10), you have to compile the updated driver yourself.

Compiling a kernel is usually a simple task, because the kernel source code already contains all dependencies. But this time, there were complications.

You need:

the kernel source
the tools to compile the kernel
and the source of the updated driver

The easiest way to get the Ubuntu Linux source is by installing a package named "linux-source". It will store the source code as an archive in /usr/src/linux-source-2.6.32.tar.bz2

You have to unpack it - make sure that you have plenty of disk space available:

cd /usr/src
tar xvfj linux-source-2.6.32.tar.bz2

Then run the following commands

cd linux-source-2.6.32
make oldconfig
make prepare

This will "regenerate" the .config file used by your distribution's kernel. This file is needed during the kernel compilation.

Now we have to download the source code of the current pvrusb2 driver which can be found here. Unpack it and copy the content of the directory driver to /usr/src/linux-source-2.6.32/drivers/media/video/pvrusb2/ overriding the current files with the same name.

(Please note: the pvrusb2 documentation is describing a different approach, that did not work for me (modprobe rejected the module))

The next step would be:

make modules

But due to a totally unrelated bug the compilation will fail, while trying to compile the "omnibook" files.

Download the patch for this bug from here and apply it

cd /usr/src
patch -p0 _name_of_the_path_file_

Now it's time to compile the modules:

cd /usr/src/linux-source-2.6.32
make modules

This step is very time consuming. If you have a multi core processor use the -j# option (where # is the number of cores you have).

Copy the new module from
/usr/src/linux-source-2.6.32/drivers/media/video/pvrusb2/pvrusb2.ko
to
/lib/modules/`uname -r`/kernel/drivers/media/video/pvrusb2/pvrusb2.ko

(where `uname -r` (backticks!) will be replaced by the name of your current kernel)

Keep in mind that you have to repeat that process after each kernel update.

After the next reboot the new module should be active. If you can't wait, unload the old one and load the new module manually:

rmmod pvrusb2
modprobe pvrusb2

Again, check /var/log/syslog for any problems.

Links:

http://www.isely.net/pvrusb2
http://www.isely.net/pipermail/pvrusb2/
https://help.ubuntu.com/community/Kernel/Compile
http://www.isely.net/downloads/fwextract.pl

ColorCube on a 64 bit machine

2010-10-20T21:42:00.002+02:00

After a recent interview with Quentin Bolsee, the lead developer of the game ColorCube, I downloaded the demo version of his game. ColorCube is a simple nice puzzle game that can keep you occupied for hours.

But I had to find out that the program did not start on my main machine.

The command

ldd Launcher

quickly revealed that it a 32 bit application, and various libraries were missing on my 64 bit system.

The package ia32-libs which provide 32 libraries for 64 bit systems does understandably not contain all libraries that may be installed on a 32 bit system. A simple work-around is to copy these files from a 32 bit set-up (/usr/lib) to the 64 bit system (/usr/lib32).

Don't forget to set the file owner to root on the target system., and keep in mind that those libraries will not be updated.

In order go get ColorCube running, I needed to copy the following libraries:

libHalf.so.6
libIlmImf.so.6
libIlmThread.so.6
libspeex.so.1
libtheora.so.0
libIex.so.6
libImath.so.6
libraw1394.so.11
libusb-1.0.so.0

Happy gaming...

Lift + Scala, Installation + First contact

2010-08-11T00:49:00.003+02:00

I have installed Lift and Scala on a Linux computer running the current Ubuntu version 10.04. Depending on your distribution, the commands may be different.

What you need is:

maven2 - a Java software project management and comprehension tool
jetty - a Java servlet engine
Java

Note that this is not the only possible configuration. There are other project management tools like SBT and other servlet engines, e.g. Tomcat. However, the documentation I've seen mostly describes maven and jetty.

Installation of Scala

Please note: The following step will install Scala. It also lets you run Scala commands interactively from the command line. This is a very good learning tool, especially for beginners.

This is a modified version of the instructions given by the London Scala User Group Dojo:

Warning: Do not use Scala from the Ubuntu (10.04) repositories. The repo contains an older 2.7 variant - we want 2.8!
Create a folder that will hold one or more versions of Scala:
sudo mkdir /opt/scala
Change that folders ownership to your username:
sudo chown -R username.username /opt/scala
From http://www.scala-lang.org/downloads download Scala final for Unix, Mac OS X, Cygwin. This is a gziped tar archive file.
Open the dowloaded file (Archive manager - file-roller) and extract to /opt/scala/
Create a sybolic link (future proof the install):
ln -s /opt/scala/scala-2.8.0.final /opt/scala/current
Define environment variable SCALA_HOME by editing ~/.bashrc and adding the line:
export SCALA_HOME=/opt/scala/current
Add the Scala executables to your path by editing ~/.bashrc and adding the line:
export PATH=$PATH:$SCALA_HOME/bin
Open a new terminal or load the changes in your ~/.bashrc file using the command:
source ~/.bashrc
Test scala is working using the following command:
scala -version or scalac -version
You should see the following as output:
Scala code runner version 2.8.0.final -- Copyright 2002-2010, LAMP/EPFL
Scala compiler version 2.8.0.final -- Copyright 2002-2010, LAMP/EPFL

The version of Scala used for compiling the web app is stored in the maven repos and is at the moment (Juli 2010) at version 2.8.0.RC7. It will be downloaded and executed during the build process.

Installation of Java

Ubuntu comes with OpenJDK as standard. You might want to download the official Java from Sun... I mean Oracle:

Enable the partner repositories in Synaptic (or uncomment them in /etc/apt/sources.list) and reload the indices:
sudo apt-get update
Download Java
sudo apt-get install sun-java6-jdk sun-java6-plugin
Switch to the Oracle version:
sudo update-alternatives --config java
sudo update-alternatives --config javac

Installation of maven2 and jetty

sudo apt-get install maven2 jetty

Your first lift application:

Go into an empty directory an issue the following maven2 command:

mvn archetype:generate \
-DarchetypeGroupId=net.liftweb \
-DarchetypeArtifactId=lift-archetype-blank \
-DarchetypeVersion=2.0-scala280-SNAPSHOT \
-DarchetypeRepository=http://scala-tools.org/repo-snapshots \
-DremoteRepositories=http://scala-tools.org/repo-snapshots \
-DgroupId=com.example  \
-DartifactId=lift.test \
-Dversion=0.1 \
-DscalaVersion=2.8.0.RC7

An archetype is a project template. lift-archetype-blank is a simple example Lift application, which is downloaded from http://scala-tools.org/repo-snapshots. You can browse this repository at http://scala-tools.org/repo-snapshots/net/liftweb
If you use http://scala-tools.org/repo-releases instead you get older more stable builds. repo-snapshots contains the nightly builds.

The artifactId (lift.test) is the name of the top level directory for this project (your choice).
The groupId is mapped (Java style: com.example becomes com/example) to the ./src/main/scala directory (also your choice).
version refers to the version of YOUR software.
scalaVersion of Scala in the maven repo.

After the download the project tree looks like this

This might look scary at first. But there are only 10 files.

./pom.xml
./src/main/scala/bootstrap/liftweb/Boot.scala
./src/main/scala/com/example/snippet/HelloWorld.scala
./src/main/webapp/index.html
./src/main/webapp/templates-hidden/default.html

./src/main/webapp/WEB-INF/web.xml
./src/packageLinkDefs.properties
./src/test/scala/com/example/AppTest.scala
./src/test/scala/LiftConsole.scala
./src/test/scala/RunWebApp.scala

I'm not sure yet about the last group. My guess is they are used for unit testing and packaging of the WAR files for later deployment.

As for the first group:

pom.xml:
This is the maven configuration file.
It contains (among others) the URL of the repositories and the dependencies which have to be resolved during the build process. You will rarely edit this file. However, if you need modules that are not within the “standard” scope (e.g. a connector to MySQL servers), you have to edit this file in order to get them drawn into your project.
Boot.scala (in ./src/main/scala/bootstrap/liftweb/):
This file contains code that is run once when the application is started.
It is used to set-up menus, database connections, etc. You will have to edit this Scala code frequently when you want to use and configure these features.
index.html (in ./src/main/webapp/):
The default template
This is the template that is evaluated when you access it via the application server without any special file name (e.g. http://localhost:8080/). You will most likely create other templates.
This particular template refers back to
default.html (in ./src/main/webapp/templates-hidden/default.html).
This is also a template, but one that you will rarely change. It defines the “frame” in which your application runs, i.e. header, footer, menu bar, the html HEAD section (page title, meta tags, CSS definitions, etc.).
Not all of its content is static. This file may contain Lift tags, most commonly the ones for displaying the menu, to change the page title, and to display feedback to the user (error messages, notices, warnings).
You may create and use more of these “frame” templates, but in most cases you only need one.
HelloWorld.scala (in ./src/main/scala/com/example/snippet/):
a so called snippet.
These files contain the Scala code which fills the in the templates (e.g. index.html). This is where most of your coding will happen. You will create more than one snippet file.

Some folders are currently empty:
model, view, comet (in ./src/main/scala/com/example/).

In the example code I have seen so far, Scala code that defines persistent data structures (e.g. for a database) is stored here.

Bringing your application to life

In order to start the application change into the top directory (lift.web) and type

mvn jetty:run

After maven has finished downloading all dependencies and building the application, you can access the web application in your browser via http://localhost:8080

Lift + Scala, Introduction

2010-08-09T23:56:00.001+02:00

A recent show of Floss Weekly made me curious about Lift, a web framework using Scala.

“Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way.” so they promise on the Scala website.

The Lift project leader praises his product as “a concise language, frame work with security features, very performant...”

A first glance

Lift, like any framework that you haven't written yourself, will take some time getting familiar with, and Scala, well, it's just another computer language... or so I thought.

Lift

Perhaps the most important feature of Lift is its template system. These templates are strictly XML based text files without any programming logic. Tags within the template link to functions in your Scala code that generates some output. This output (also XML) then replaces the tag. After a few more processing steps the result is returned to the enquiring web browser, your page gets rendered, end of story. Yes, there are lots of support features within the framework – like html form generation, database connectivity, page access control – but this is the basic principle of Lift.

Scala

The designers of Scala cherry-picked the best features and concepts from other programming languages, some object-oriented stuff but they also borrowed heavily from functional programming. Its mantra: “everything is an object” and “if it's worth saying, say it with a function”.

Scala's smart compiler can in most cases infer types of variables, so you don't have to declare it manually. The language has lots of these simplyfications, dramatical reducing boiler plate code. However, you have to be familiar with these in order to be able to revert the expression back to its more verbose form, otherwise you will scratch your head when you encounter the “Scala smiley”:

( _ + _ )

Some language constructs help you avoiding Null pointer dereferences, or to catch all possible cases in a matching construct. And being a statically typed language the Scala compiler will be very stubborn if your types don't match.

You can write very elegant code – even though I wouldn't call deeply nested function calls simple to read, at least not yet.

Treacherous simplicity

Letting the compiler infer types looks like a good idea. On second sight, it also means that you need a good memory or at least a helpful IDE.

Simplifying

   val a: Int = 1

   val a = 1

is simple and easy to understand. (The literal 1 is an integer, i.e. “a” must be integer as well). But:


val a = function_i_wrote_ealier_and_dont_remember_the_return_type()
val b = another_cool_function_from_the_web_framework(User => go look)

does work just as well. And now you either know the types or you have to look it up.

The possibility to drop dots and brackets in some situation lets you further “simplify” things:

   a.+(b)

becomes a much more friendlier

   a + b

(+ is a valid function name in Scala).

But

   a :: b

does not mean

   a.::(b)

but

   b.::(a)

(“Operators” that end with “:” bind from right to left).

Another nice feature: When defining a class how often have you assigned the values from the constructor parameter list to class variables for later use? It's usually the first thing you do. In Scala this is done automatically. Why hasn't somebody invented this earlier?

Documentation + support

There is documentation available for Lift and Scala on the web. While perhaps not exactly light reading, they will get you started.

For Scala http://programming-scala.labs.oreilly.com/index.html from O'Reilly is a good start, and on the Scala website there is http://www.scala-lang.org/docu/files/ScalaByExample.pdf. Both publications expect that you have done some programming before.

For Lift you should check out master.pdf from http://groups.google.com/group/the-lift-book/files. More information is available at the Lift Wiki and a subscription to the Lift newsgroup is also recommended.

Update with caution - Firefox 3.6.6

2010-06-28T02:14:00.001+02:00

The recent update to Firefox 3.6.6 seems to cause more problems than usual.

Over here, a Mac was the first to update - and Firefox did not re-start. Having discovered the safe-mode option recently, I used it on the Mac:

/Applications/Firefox.app/Contents/MacOS/firefox-bin -safe-mode

After disabling all add-ons, Firefox 3.6.6 did start normally.

On my Ubuntu machine, Firefox is still on version 3.6.3. So I decided to test FF 3.6.6 before the Ubuntu updater pushes the update. I downloaded the Linux version of 3.6.6 from Mozilla and installed it in a separate directory.

Multiple versions of Firefox can coexist on the same machine, but only one can run at any given time. I.e. you have to close ALL Firefox windows of one version before starting the other.

Strangely enough, the new version worked even with the add-ons that crashed Firefox on the Mac. But there were other issues:

no graphics on Google Analytics
no address resolution of a web server on the LAN (worked on FF 3.6.3, might be a 64 bit issue - ping is ok)

I think, I'll skip this one.

If the new versions has already been installed...

If you hover your mouse over the appropriate download button on the Mozillas website, you see a link like this one (perhaps with different o/s and language settings) in the status bar:

http://download.mozilla.org/?product=firefox-3.6.6&os=osx&lang=de

You can copy the link, modify the version number to get the older Firefox version.

[Update, June 29th]
Firefox 3.6.6 (32 bit and 64 bit) from the Ubuntu repositories run without problems.

Integrating a re-branded Huawai UMTS modem into Ubuntu 10.04

2010-06-26T12:35:00.001+02:00

The Huawai E160 is a popular UMTS stick and works with Ubuntu Lucid Lynx out-of-the-box.

It is also commonly used by European phone companies in their mobile internet starter packs. Unfortunately these sticks are usually sim-locked to the phone company and some identify themselves with a USB id unknown to current Ubuntu setup.

When you plug the stick into the computer, all you see is a small flash drive icon containing the Windows and sometimes Macintosh drivers. On these systems the drivers switches the stick from mass storage device mode into modem mode after the initial phase.

The Linux utility for this task is called modem-modeswitch, and can be found in /lib/udev. The actual task is to automate the execution of this utility when the UMTS stick is plugged in.

The UMTS stick in this example is/was sold by the Belgian phone company Mobistar. When you query the USB IDs:

sudo lsusb

it is identified as

12d1:1446 Huawei Technologies Co., Ltd.

The two numbers at the beginning of the line are the vendor ID and product ID of the stick in the current mode.

To check if the modem switch works as expected, call the utility manually:

sudo /lib/udev/modem-modeswitch -v 0x12d1 -p 0x1446 -t option-zerocd

Wait a few seconds and check the USB IDs again. The entry should now read:

12d1:1003 Huawei Technologies Co., Ltd. E220 HSDPA Modem / E270 HSDPA/HSUPA Modem

If nothing happens, David Santinoli suggests in a related document to unmount the device containing the drivers before attempting the switch.

You can automate the process by creating the file 62-huawai.rules in /lib/udev/rules.d:

ATTRS{idVendor}=="12d1", ATTRS{idProduct}=="1446", RUN+="modem-modeswitch -v 0x%s{idVendor} -p 0x%s{idProduct} -t option-zerocd"

(The file name is arbitrary, as long as it starts with “62-” and ends with “.rules”.) The rule itself is based on similar entries in 61-option-modem-modeswitch.rules.

Next time you boot your computer, the rule becomes active, and the modem should be recognized automatically.

Firefox - Ausfall der rechten Maustaste

2010-06-14T12:16:00.001+02:00

In den letzten Wochen ist es bei mir häufiger vorgekommen, dass Firefox 3.5 (unter Ubuntu 10.04) nicht mehr auf die rechte Maustaste reagierte. Auf dem Desktop und in den übrigen Programmen funktionierte sie weiterhin, sodass ein Problem mit der Maus ausgeschlossen werden konnte.

Der eigentliche Grund des Problems ist weiterhin unklar. Mit dem folgenden Trick kann man Firefox jedoch in den Normalzustand zurücksetzen:

Hierzu beendet man Firefox vollständig und ruft es von der Kommandozeile mit

firefox -safe-mode

auf. Daraufhin erscheint der folgende Bildschirm:

Im Safe-Mode startet Firefox - ähnlich wie der Safe-Mode bei Windows - ohne Erweiterungen.

Wie man sieht kann man fast alles zurücksetzen, was man in den letzten Jahren in mühsamer Kleinarbeit zusammengetragen hat.

"Reset toolbars and controls" scheint die Option mit dem geringsten "Lösch-Potenzial" zu sein, und in meinem Fall reichte sie auch aus. Nach "Make Changes and Restart" reagierte Firefox wieder auf die rechte Maustaste.

Touch Me, Tux - die Zweite

2010-05-25T12:26:00.001+02:00

Im Zuge der in einigen Tagen beginnenden Fußball-WM 2010 verkaufte Aldi-Süd letzte Wochen den „TEVION® Tragbarer 11 cm/4,3'' Touch Multimediaplayer“ (MD 82700) mit eingebautem DVB-T-Empfänger. So können sich die Fußballfans per „Überall-Fernsehen“ auf dem Laufenden halten - wenigstens „überall“ dort, wo es empfangbar ist.

Im Lieferumfang befinden sich neben dem Netzteil, ein USB-Kabel, ein Ohrhörer und eine kleine DVB-T-Magnetfußantenne.

Daneben gibt der Player Videos, Musik und Fotos wieder. Und auch Text kann man sich anzeigen lassen; natürlich kein Vergleich zu Kindle und Co – weshalb das Feature wahrscheinlich nicht einmal beworben wurde.

Das Gerät meldet sich unter Linux als USB-Massenspeicher (MD 82700) an. Je nachdem, ob eine zusätzlich Micro-SD Karte eingelegt ist, erscheinen ein (intern: 4 GB) bzw. zwei USB-Laufwerke. Bilder und Video lassen sich auch mit gängigen Werkzeugen unter Linux so codieren, dass sie vom Player wiedergegeben werden.

Als Wiedergabeformate werden JPEG, MP3, MPEG4, RM, RMVB, Divx und Xvid beworben. Zu RM und RMVB kann ich nichts sagen, da ich unter Linux keine Encoder dafür laufen habe.

Die Angabe von MPEG4 ist zwar nicht falsch, aber vielleicht etwas missverständlich. MPEG4 ist ähnlich wie AVI ein Container-Format. Es sagt nichts über die darin verwendeten Codecs aus.

Um normale Dateien zu komprimieren gibt unterschiedliche Algorithmen (ZIP, RAR, LZH, usw.). Ein sehr bekannt Algorithmus für Audio ist MP3, aber er ist halt nicht der einzige. Im Open-Souce-Bereich ist auch Ogg Vorbis verbreitet, Mac-User kennen AAC usw. Und auch bei den Videocodecs sind mittlerweile nicht nur Eingeweihten mehrere Codecs bekannt: DivX (und sein Open-Source-Pendant Xvid) sowie MPEG2 von den DVDs.

Häufig genutzte Quellen für MP4-Dateien sind heutzutage Video-Portale wie Youtube und Vimeo. Die dort erhältlichen Videos werden mit dem sehr effektiven Codec H.264 für Video und häufig mit AAC für Audio komprimiert. Diese beiden Codecs versteht das Gerät allerdings nicht. Solche Dateien können nicht direkt wiedergegeben werden und müssen auf dem Computer umcodiert werden.

Wenn man einmal vom DVB-T absieht, so erinnert der Player sehr an das Technaxx-Gerät, mit dem dieses Blog vor über einem Jahr begann. Die verfügbaren Formate, Aufbau und Inhalt der Menüs, exotische Funktionen wie Liedtext-Wiedergabe mit .lirc-Dateien, ähneln sehr der Software im Technaxx-Player. Selbst der vor einem Jahr genannte Konvertier-Befehl kann so (und in leicht abgewandelter Form) verwendet werden.

Von der Auflösung her unterscheiden sich der Technaxx- (320 x 240) und der Medion-Player (480 x 272) nicht sonderlich. Die höhere Pixelzahl ist fast ausschließlich dem Wechsel vom 4:3- zum 16:9-Format zu verdanken; aber natürlich ist der Bildschirm jetzt deutlich größer.

Der Wiedergabe-Chip ist leistungsstärker geworden, so dass viele Einschränkungen weggefallen sind: Es werden höhere Bildfrequenzen (Technaxx: max. 20 Bilder pro Sekunde) und höhere Bitraten für Video und Audio wiedergegeben. Auch B-Frames werden nun unterstützt, die eine höhere Komprimierung erlauben.

Die alten für den Technaxx kodierten Dateien lassen sich daher weiter abspielen. Und da diverse Einschränkungen wegfallen, lassen sich mit Avidemux erstellte Dateien nun direkt verwenden.

Erfolgreich getestete Formate:

Container-Formate: AVI, MP4
Videocodecs: DivX, Xvid
Audiocodecs: MP2, MP3, AC3
Videofrequenz (Bilder/Sekunde): 20, 25
Bildformate: JPEG, BMP

Hier ein Konvertierbefehl im Bausatz

Dateinamen, Ausgabeformat: AVI
mencoder -noodml QUELLDATEI -of avi -o ZIELDATEI

Videocodec XVID, Bitrate
-ovc xvid -xvidencopts bitrate=VIDEOBITRATE:quant_type=h263:me_quality=6
VIDEOBITRATE: je nach Qualität, typische Werte 800 bis 1000

Audiocodec
-oac AUDIOCODEC
AUDIOCODEC: mp3lame, mp2, ac3

Beispiel:
mencoder -noodml ein.mp4 -of avi -o aus.avi -ovc xvid -xvidencopts bitrate=1000:quant_type=h263:me_quality=6 -oac mp3lame

The wow factor book

2010-05-19T12:16:00.003+02:00

Yesterday, a young man in Australia became victim of his own success.

Andrew Price of blenderguru.com fame had demonstrated in the past that he can produce good and easy to understand blender text and video tutorials.

He peaked the community's interest when he announced an e-book - “the wow-factor” - about the compositor of Blender 2.5, something that hasn't got a lot of coverage so far.

During the last weeks he released a sample chapter of his book and produced a promotional video worthy of a shopping channel. Apart from detailing the content of the e-book, it listed all the bonuses which come with it, and culminated in the display of the e-book itself and all the bonuses as CDs and booklets which, of course, all exist - in good Blender fashion - only virtually.

One day before the release he offered a chance to win a free copy of the e-book. It got 700+ entries which should have been a warning about what was going to hit him.

With only a few hours to go, his website become slower and slower, and when the first message "error 500" appeared, it was clear that the demand crashed his server. The move to a more powerful home took another 3+ hours which deprived a few of his costumers of the chance to be among the first hundred buyers eligible for “the vault” - the collection of source material which made up the book.

Before going to bed myself, I skimmed the e-book. It delivers what was promised: an overview of glares, blurs and optical effects - many of which most of us have never heard of - and how to create them in Blender.

The bonuses provide additional information which are not available in this completeness at this time anywhere else. The “node encyclopaedia” for example will save you hours of gathering this information and will hopefully become part of the regular Blender documentation once the final 2.5 version is released, which can still take some time.

The reason that the compositor is not the most prominent feature in most other Blender tutorials is, that it is one of the last steps of creating something in Blender used to polish your render. This means that you must already have something to work with – a fact that has been taken care of by two video tutorials showing how to build a scene in which to use the effects. Unfortunately they are only available in a time limited fashion.

All in all it seems to provide a lot of useful information which I can hopefully learn during the coming weeks while reading, watching and listening to the provided material.

I wonder if there were free bonus steak knives mentioned in the commercial... .blend files would suffice. :-)

dbus tutorial - part 3

2010-05-07T01:48:00.001+02:00

The last part started with the basic structure of the dbus part of the CD file listing utility and then showed the particular problems with the HAL implementation.

DeviceKit.Disks has to overcome similar problems, but due to the different concepts behind DeviceKit they have to be solved slightly differently.

DeviceKit.Disks

Like HAL, DeviceKit.Disks is another daemon handling devices and is offering similar services under different names. HAL is a jack of all trades, providing information about nearly everything in your system. This lead to its downfall, because the code base became huge and unmaintainable. DeviceKit on the other hand is split into individual more specialised daemons. DeviceKit.Disks is strictly focussed on disks and drives.

Differences to HAL from a programmers point of view:

As already seen: A different function is used to install the callbacks.
The string given to the callback function (e.g. /org/freedesktop/DeviceKit/Disks/devices/sr0) is the name of a Devkit device. It points to a hardware device (e.g. the CDROM drive) not a volume (the inserted medium). And because the string already points to the hardware device we don't have to check for any parent object.
Being a fixed drive, we also don't need the device_added_callback or device_removed_callback, because the physical CDROM device is not likely to be removed during the lifetime of the program and only changing the medium does not trigger these callbacks. (Note: A USB stick where the physical device itself is being unplugged does trigger these callbacks.).
Which leaves the device_changed_callback. However, unlike HAL, there is no indication which property has changed when it is being triggered. We have to track the appropriate properties ourselves.

Initialization
(See part 2)

import gobject
import dbus
...
gobject.threads_init()
dbus.glib.threads_init()

Adding the callback
(See part 1)

bus = dbus.SystemBus()
devkit_object = bus.get_object("org.freedesktop.DeviceKit.Disks",
"/org/freedesktop/DeviceKit/Disks")
devkit_disks = dbus.Interface(devkit_object, 'org.freedesktop.DeviceKit.Disks')
devkit_disks.connect_to_signal('DeviceChanged', device_changed_callback)

...

def device_changed_callback(device):
print 'Device %s was changed' % (device)

Device properties in Devicekit.Disks

DeviceKit.Disks devices implement an interface named Properties which gives access to the device properties:

device_object = bus.get_object("org.freedesktop.DeviceKit.Disks", udi)
device_prop = dbus.Interface(device_object, "org.freedesktop.DBus.Properties")
property = device_prop.Get("org.freedesktop.DeviceKit.Disks.Device","name_of_property")

# or

all_properties = device_prop.GetAll("org.freedesktop.DeviceKit.Disks.Device")

Interesting properties are:

DriveMediaCompatibility
description: hardware compatibility
typical values: optical_cd, optical_cd_r, optical_cd_rw, optical_dvd, optical_dvd_r, optical_dvd_ram
DeviceIsOpticalDisc
typical values: 0/1
0: disk tray empty
1: optical media has been found
DeviceIsMounted
typical values: 0/1
0: nothing mounted yet
1: valid DeviceMountPaths
IdLabel
description: label of CD/DVD
DeviceMountPaths
descirption: mount point, if a CD/DVD has been mounted
OpticalDiscIsBlank
typical values: 0/1
0: media in the drive is not blank
1: media in the drive is blank
DeviceIsRemovable
typical values: 0/1
1: device can contain removable media (-> Eject should work)

See also: http://hal.freedesktop.org/docs/DeviceKit/

You can get a quick overview with human readable property names with

devkit-disks --dump | more

How to filter out events that are not CD related

The most promising way is to check DriveMediaCompatibility for the value optical_cd or optical_dvd.

device_object = bus.get_object("org.freedesktop.DeviceKit.Disks", udi)
device_prop = dbus.Interface(device_object, "org.freedesktop.DBus.Properties")
md = device_prop.Get("org.freedesktop.DeviceKit.Disks.Device","DriveMediaCompatibility")
print "is CD-ROM:", (u"optical_cd" in md) or (u"optical_dvd" in md)

If you observe the events (using the dbus-monitor) when inserting or ejecting a CD, the following patterns emerge:
(I haven't found any authoritative documentation yet, but the steps seem logical):

When the CDROM tray is empty:
DeviceIsOpticalDisc == 0
Blank medium inserted:
DeviceIsOpticalDisc == 1
OpticalDiscIsBlank == 1
After ejecting the blank medium:
DeviceIsOpticalDisc == 0

Insert a medium containing data
- step 1 (medium gets recognized):
  DeviceIsOpticalDisc == 1
  OpticalDiscIsBlank == 0
  DeviceIsMounted == 0
- step 2 (medium gets auto mounted):
  DeviceIsOpticalDisc == 1
  OpticalDiscIsBlank == 0
  DeviceIsMounted == 1
eject medium:
- step 1 (auto umount)
  DeviceIsOpticalDisc == 1
  OpticalDiscIsBlank == 0
  DeviceIsMounted == 0
- step 2 (eject)
  DeviceIsOpticalDisc == 0
  OpticalDiscIsBlank == 0
  DeviceIsMounted == 0

If DeviceIsOpticalDisc is being set to 1, the property IdLabel becomes valid.
If DeviceIsMounted is being set to 1, the property DeviceMountPaths becomes valid.

When to read the file list

As DeviceKit.Disks does not provide the information which property was modified, we have to track the state of DeviceIsMounted ourselves and read the files below the mount point(s) when DeviceIsMounted changes from 0 to 1.

Eject via software

This function is located in the interface org.freedesktop.DeviceKit.Disks.Device. Note that a volume must be unmounted first before it can be ejected (see property DeviceIsMounted).

system_bus = dbus.SystemBus()
device_object = system_bus.get_object("org.freedesktop.DeviceKit.Disks", udi)

# get properties
device_prop = dbus.Interface(device_object, "org.freedesktop.DBus.Properties")
all_properties = device_prop.GetAll("org.freedesktop.DeviceKit.Disks.Device")

# call unmount/eject depending on the device state
disk_dev_func = dbus.Interface(device_object, "org.freedesktop.DeviceKit.Disks.Device")
if all_properties['DeviceIsMounted'] == 1:
disk_dev_func.FilesystemUnmount('')
if all_properties['DeviceIsOpticalDisc'] == 1:
disk_dev_func.DriveEject('')

With this, we have all the building blocks for DeviceKit.disks implementation of the CD file listing utility

dbus tutorial - part 2

2010-04-28T00:57:00.000+02:00

Implementation overview

The first part introduced the dbus components and how to access them using Python.

The goal is to write a program that lists and stores the names of the files on a CD after it has been inserted. The basic steps are:

Initialize dbus
Wait for the notification when a CD is inserted into the drive.
Wait for the notification when the volume is mounted by the (Gnome) automounter
Read the file list below that mount point and store the info.
Then perhaps eject the CD.
Go back to step 2

Initialize dbus: Starting dbus threads

In order to get the dbus communication running in the python application, the following threads have to be started before you connect to any bus:

import gobject
import dbus
import dbus.glib
...
gobject.threads_init()
dbus.glib.threads_init()

This piece of code uses Python threads in the background.

HAL implementation specifics

In the first part we've seen how callbacks are hooked into the system:

bus = dbus.SystemBus()
bus.add_signal_receiver(device_added_callback,
                                 "DeviceAdded",
                                 "org.freedesktop.Hal.Manager",
                                 "org.freedesktop.Hal",
                                 "/org/freedesktop/Hal/Manager")
bus.add_signal_receiver(device_removed_callback,
                                 "DeviceRemoved",
                                 "org.freedesktop.Hal.Manager",
                                 "org.freedesktop.Hal",
                                 "/org/freedesktop/Hal/Manager")

When a CD is inserted DeviceAdded receives a string like this:

/org/freedesktop/Hal/devices/volume_label_backupcd1________

When the CD is ejected, DeviceRemoved is executed, receiving the same information. I'll refer to this string as udi in the following code.

This string refers to an HAL object, and describes a volume i.e. the medium you inserted, not the actual hardware (i.e. the CDROM drive). To get more information about this volume you have to get the HAL object via bus.get_object (as described before):

d_object = bus.get_object('org.freedesktop.Hal',udi)

Objects starting with /org/freedesktop/Hal/devices/... implement the interface org.freedesktop.Hal.Device, which in turn exposes (among others) the function GetAllProperties which returns a dictionary that contains further useful information:

d_interface = dbus.Interface(d_object,'org.freedesktop.Hal.Device')
properties = d_interface.GetAllProperties()

Interesting keys in this dictionary are:

volume.label
description: CD label
typical value: empty, backup123
volume.disc.has_data
description: data disk
typical value: 0, 1
volume.disc.is_blank
description: blank media
typical value: 0, 1
volume.mount_point
description: CD mount point
typical value: /media/backup123
block.device
description: linux device descriptor
typical value: /dev/sr0
storage.drive_type
typical value: cdrom

See also HAL specification

To get a quick overview, type

lshal | more

in a shell. (You will need the more command.)

The interface org.freedesktop.Hal.Device (implemented by all .../Hal/devices/ ) also contains the signal PropertyModified - which will be fired when properties change (in our example: the info volume.mount_point is empty when the device is added. It becomes available later when the auto-mounter of the desktop framework has mounted the device.). You can add a callback for this signal:

def device_added_hook(udi):
    ....
    bus.add_signal_receiver(property_modified_callback,
           "PropertyModified",
           "org.freedesktop.Hal.Device",
           "org.freedesktop.Hal",
           udi)

def property_modified_callback(numupdates,updates):
    ...

numupdates are the number of entries in a list of updates. An "update" is a tuple with the following signature: (key_name, was_added, was_removed)

If a CD/DVD was mounted, the list of updates contains (among others) the following tuples:

('volume.mount_point', False, False)
('volume.is_mounted', False, False)

This means that the property was neither added (1st False) nor removed (2nd False), it was merely modified. We don't get any information about the new value of the property and more importantly we don't get any information about the object (i.e. the device) that triggered it.

For this reason the method add_signal_receiver can be extended:

...
    bus.add_signal_receiver(property_modified_callback,
           "PropertyModified",
           "org.freedesktop.Hal.Device",
           "org.freedesktop.Hal",
           udi,
           path_keyword = "sending_device" )

The parameter path_keyword defines the name of an additional parameter (in this example sending_device) for the property_modified_callback which will contain the “path” - or in my parlance “the object” - that triggered the signal. Now the property_modified_callback looks like this:

def property_modified_callback(numupdates, updates, sending_device = None):
    ...

Apart from path_keyword, add_signal_receiver can define even more additional parameters for the callback function:

sender_keyword - for the connection name (usually in the internal numeric format)
destination_keyword - None for broadcasts
interface_keyword - interface name
member_keyword - signal name
path_keyword - object name

each followed by a string containing the name of the parameter in the callback function. The variable will contains the appropriate information.

HAL implementation: Filter out events that are not CD related

DeviceAdded is called for every new device in the system (network devices, bluetooth devices, etc.), and the property_modified_callback is invoked if any property of any device changes.

In order to filter out the CD related calls, we have to check the properties for suitable keys.

First, we have to ensure that the object describes a volume. For this we have to check if the property block.is_volume is present, and if so, that it is set to True.
The object will then have a property named info.parent, pointing back to the physical drive.

After retrieving the properties of that parent object, we first check block.is_volume, which has to be set to False, and then obtain the value of storage.drive_type, which is set to "cdrom", if the device is an optical drive.

...
# get object of the device that triggered the property_modified_callback
d_object = self.system_bus.get_object('org.freedesktop.Hal',sending_device)
d_interface = dbus.Interface(d_object,'org.freedesktop.Hal.Device')

# get their properties
d_properties = d_interface.GetAllProperties()

if not d_properties.has_key("block.is_volume"): return
if not d_properties["block.is_volume"]: return

parent_device = d_properties["info.parent"]
p_object = system_bus.get_object('org.freedesktop.Hal',parent_device)
p_interface = dbus.Interface(p_object,'org.freedesktop.Hal.Device')
p_properties = p_interface.GetAllProperties()
if not p_properties["block.is_volume"]:
   if p_properties["storage.drive_type"] == "cdrom":
       # further code here

Another approach is to get the list of all optical drives when the utility is launched and check the parent udi against this list:

system_bus = dbus.SystemBus()
hal_object = system_bus.get_object('org.freedesktop.Hal', '/org/freedesktop/Hal/Manager')
hal_manager = dbus.Interface(hal_object, 'org.freedesktop.Hal.Manager')
...
installed_optical_drives = hal_manager.FindDeviceStringMatch("storage.drive_type","cdrom")
...
if parent in installed_optical_drives:
   ...

Mount point is empty
At the time when the device is added volume.mount_point is empty. That's why the signals DeviceAdded and DeviceRemoved are not important in our application. You might want to use them anyway to display the state of your drive (e.g. disk inserted or nor) in the GUI.

The import part is the property_modified_callback. After the checks described above we know the label of the CD and its mount point. With this information we can obtain a file list and store it in any form we want.

The next part will show how DeviceKit.Disks handles these problems.

dbus tutorial - part 1

2010-04-23T01:35:00.004+02:00

Basic dbus concepts

What is dbus?

dbus is part of most modern Linux distros. It handles interprocess communication, either between desktop applications or between systems daemons and applications (e.g. a desktop framework like Gnome or KDE, or user applications).

Overview

The goal of this series of postings is the creation of a small desktop example application written in Python which reads the name of the files on a CD or DVD after the media has been inserted, and to store these names together with the CD label in a file. The graphical user interface will be based on wxWidgets.

The first part contains an introduction to the basic dbus components.
The second part discusses the implementation using the Hardware Abstraction Layer (HAL).
The following part shows the differences in implementation between HAL to the DeviceKit.Disks.

Prerequisites

Python: which is part of any current Linux distribution. (I'm using Python 2.6).
python-dbus: the dbus bindings for Python
python-wxgtk2.8: wxWidgets and its Python bindings (for the GUI)

Useful additions

python-wxglade: GUI builder for wxWidgets, creates Python source code (and C source code...)

d-feet: graphical display of dbus components

dbus components

In our example dbus is used to catch the notifications sent by the kernel when a CD or DVD has been inserted, as well as the notification when Gnome has mounted this medium. (There were times when you had to do this manually.)

In some places I will differ from the official dbus designations for these components to make their distinction easier. In some cases different components share the same name. This makes their close relation quite obvious, but it becomes difficult to determine if a given name refers to a connection or an interface, for example.

Buses

In dbus “buses” are at the root of a hierarchy. In normal applications you encounter mostly the following two buses:

bus = dbus.SessionBus()

for communication between desktop applications, and

bus = dbus.SystemBus()

for communication with system programs and daemons like the NetworkManager, the ModemManager, the Hardware Abstraction Layer daemon (HAL) or DeviceKit, to name but a few.

When you insert a disc, a notification is routed via HAL or DeviceKit, depending on which daemon is installed.

Note: Ubuntu Karmic uses HAL and DeviceKit simultaneously. However, the Hardware Abstraction Layer is being phased out from most Linux distributions, and the upcoming version of Ubuntu 10.04 (Lucid Lynx) will drop it completely.

Connections

“Connections” are the layer below the buses. You can use a "connection" to “connect” to a specific daemon or application. Please note the dotted notation:
The NetworkManager is available via a connection named org.freedesktop.NetworkManger.

The connection org.freedesktop.Hal will connect you to the HAL daemon.
The "disks" part of DeviceKit is available via the connection named org.freedesktop.DeviceKit.Disks.

Objects

These programs (NetworkManager, HAL, DeviceKit.Disks, etc.) will offer their services via one or more "objects". Object names contain slashes and look like file paths, which might be the reason that they are sometimes called "paths".

Examples:
/org/freedesktop/Hal/devices

/org/freedesktop/Hal/Manager

/org/freedesktop/Hal/devices/volume_label_backupcd1________
/org/freedesktop/DeviceKit/Disks/devices/sr0

Interfaces

Objects export methods and and signals grouped into one or more "interfaces". The names of these interfaces again contain dots, e.g. org.freedesktop.Hal.Manager or org.freedesktop.DeviceKit.Disks.Device.

Methods

Methods are functions you can invoke. One method of the org.freedesktop.Hal.Manager interface for example is DeviceExists. The interface org.freedesktop.DeviceKit.Disks implements e.g. EnumerateDevices, etc.

Signals

An interface may also export "signals". Signals of the org.freedesktop.Hal.Manager interface that we are going to use are DeviceAdded and DeviceRemoved, which are triggered when you put a new CD into the drive or eject it, but also if any other device is added (an USB stick, a new network interface, etc.), as well as the signal PropertiesModified.

Introspect

One interface that is implemented by all objects is org.freedesktop.DBus.Introspectable which offers one method: Introspect().
This function returns a description of the object's interfaces, i.e. what methods and signals are available and what parameters they use. The above mentioned utility d-feet uses this method to display the information in a nice graphical way. (Note: In d-feet a "Connection" is called "Bus Name").

If you want to see the dbus messaging at work (for the SystemBus) open a shell and start:

dbus-monitor --system

Summary

bus: top level (SessionBus or SystemBus)

connection: from the bus to a daemon; names with dots

object: logical part within that daemon; names with slashes

interface: one or more within an object (same interface on different objects means same API (methods and signals)); names with dots

methods and signals (none or more within an object)

Examples

How to call a method (HAL)

In order to call a method like DeviceExists, you have to know, that this particular function is

part of the interface org.freedesktop.Hal.Manager

that this interface is implemented by the object named /org/freedesktop/Hal/Manager

which in turn can be reached via the connection org.freedesktop.Hal

on the SystemBus

In Python:
# (4)
bus = dbus.SystemBus()
# (3 + 2)
object = bus.get_object("org.freedesktop.Hal","/org/freedesktop/Hal/Manager")
# (1)
interface = dbus.Interface(object,"org.freedesktop.Hal.Manager")
#
result = interface.DeviceExists(...)

As mentioned earlier, you have to know which parameter of bus.get_object and dbus.Interface is the object name, the connection name, and the interface name. The names themselves are usually not a great help.

Signal callbacks (HAL)

In order to make dbus call a method in your program when a signal is triggered you have to add a signal receiver:

bus.add_signal_receiver(
   handler_name_in_your_program,
   "signal_name",
   "interface_name",
   "connection_name",
   "object_name")

The handler method looks like this:

def handler(...):
   ...

The parameters used when this handler is executed (the so called "signature") differ from signal to signal. (This info can be obtained via the Introspect interface.) Here the example for the methods DeviceAdded and DeviceRemoved:

bus = dbus.SystemBus()
bus.add_signal_receiver(device_added_callback,
                                 "DeviceAdded",
                                 "org.freedesktop.Hal.Manager",
                                 "org.freedesktop.Hal",
                                 "/org/freedesktop/Hal/Manager")
bus.add_signal_receiver(device_removed_callback,
                                 "DeviceRemoved",
                                 "org.freedesktop.Hal.Manager",
                                 "org.freedesktop.Hal",
                                 "/org/freedesktop/Hal/Manager")

....

def device_added_callback(udi):
    print udi

def device_removed_callback(udi):
   print udi

(More on add_signal_receiver in the next post)

How to call a function (DeviceKit.Disks)

The fundamental dbus principles described in the HAL example still apply:

# (4)
bus = dbus.SystemBus()
# (3 + 2)
devkit_object = bus.get_object("org.freedesktop.DeviceKit.Disks",
                       "/org/freedesktop/DeviceKit/Disks")
# (1)
devkit_disks = dbus.Interface(devkit_object, 'org.freedesktop.DeviceKit.Disks')
#
all_devices = devkit_disks.EnumerateDevices()

Note: This time the connection/object/interface names are nearly identical. Keep in mind which parameter describes what

Signal callbacks (DeviceKit.Disks)
Even tough a few handler names are identical to HAL and their functions are similar, their parameters are different. Also note that the way DeviceKit.Disks adds callbacks is different:

devkit_disks.connect_to_signal('DeviceAdded', device_added_callback)
devkit_disks.connect_to_signal('DeviceRemoved', device_removed_callback)
devkit_disks.connect_to_signal('DeviceChanged', device_changed_callback)

def device_added_callback(device):
    # not really needed
    print 'Device %s was added' % (device)

def device_removed_callback(device):
    # not really needed
    print 'Device %s was removed' % (device)

def device_changed_callback(device):
    print 'Device %s was changed' % (device)

Other daemons

There are other interesting daemons, like the ModemManager, which not only can control modems, but also allows access to your mobile phone, SMS etc.

Ein Tag ohne E-Mail

2010-04-10T23:48:00.001+02:00

Nach einem Sicherheitsupdate in Ubuntu Karmic meldete sich Thunderbird beim Start mit:

Die Sicherheitskomponente der Anwendung konnte nicht
initialisiert werden. Der wahrscheinlichste Grund dafür sind
Probleme mit Dateien im Profil-Ordner Ihrer Anwendung.
Bitte stellen Sie sicher, dass der Ordner keine Lese- und
Schreibbeschränkung hat und Ihre Festplatte nicht voll oder
fast voll ist. Es wird empfohlen,  dass Sie die Anwendung
jetzt beenden und das Problem beheben. Wenn Sie diese Sitzung
weiter verwenden, können Sie unkorrektes Verhalten der Anwendung
beim Zugriff auf Sicherheitsfunktionen feststellen.

und sämtliche mit SSL gesicherten Verbindungen zu POP- und SMTP-Servern schlugen fehl... und das sind bei mir alle.

I hate it when this happens.

Gegenmaßnahmen, die ich bei einer ersten Google-Suche nach dieser Fehlermeldung gefunden hatte (Neuinstallation von Thunderbird, Löschen von cert8.db, Anlegen eines neuen Profils) waren jedoch wirkungslos.

Beim Sicherheitsupdate wurde unter anderem die Bibliothek libnss aktualisiert, die für Verschlüsselung zuständig ist.

Ein Eintrag im Ubuntu-Form bestätigte diesen Verdacht. In meinem Fall reichte es, die veraltete Bibliothek libnss3-0d in Synaptic zu deinstallieren.

T60: Die Tastatur, die Henne und das Ei

2010-03-13T18:20:00.007+01:00

Seit einigen Wochen habe ich einen neuen Laptop...

Naja, ein Gebrauchtgerät - Lenovo T60 - erworben beim Gebraucht-Laptop-Händler meines Vertrauens, bei dem ich über die Jahre schon einige Geräte der jeweils vorletzten Generation erworben habe.

Wie bei früheren Laptops, so hatte auch dieser eine ausländische Tastatur. Der Laptop kam mit Etiketten zum Überkleben der Tasten. Das war bei früheren Käufen auch so gewesen und die Etiketten halten immer noch.

Unterdessen läuft Ubuntu Karmic mit Gnome auf dem Rechner. Die diversen Funktionstasten werden unterstützt (laut, leise, heller, dunker) und auch Blender ist dank der Kraft der zwei Kerne halbwegs flott.

Etwas gestutzt hatte ich dann gestern, als ich auf der Kommandozeile eine etwas längere Ausgabe mit | less seitenweise anzeigen wollte. Nirgendwo war der senkrechts Strich zu finden.

Sollten die Aufkleber doch nicht so vollständig gewesen sein? Nachdem ich alle Tasten mit gedrückter Alt-Gr-Taste durchprobiert hatte stand fest: kein senkrechter Strich. Nun gut, dann eben eine Umleitung in eine Datei - aber auch das Größerzeichen war nirgends zu finden.

Fehlt also eine Taste?

Die Antwort ist: ja. Nach ein wenig googlen fand ich auf Notebookcheck ein Bild des Laptops mit aufgeklappter Tastatur. Die dort gezeigte Tastatur (oben rechts) hat im Gegensatz zu meiner eine schmalere linke Shift-Taste. In dem freiwerdenden Zwischenraum liegt normalerweise: < > |

Wahrscheinlich hat Sprache, für die die Tastatur eigentlich ausgelegt ist, weniger Sonderzeichen, braucht weniger Tasten und das < > befinden sich irgendwo unter den Tasten Ä Ö oder Ü.

Was also tun? Ohne "größer" und "kleiner" ist das Programmieren recht umständlich. Und wie häufig man auf der Kommandoebene die Pipe benutzt merkt man erst dann, wenn es nicht mehr geht...

Umdefinieren der Tastatur mit Xmodmap

Im Ubuntu-Wiki gibt es hierzu einen ausführlichen Eintrag.

Erster Schritt: Auslesen der aktuellen Zuweisung.

Hierzu muss im Home-Verzeichnis der Befehl

xmodmap -pke > .Xmodmap

eingegeben werden, was bei fehlendem ">" ein echtes Henne- und Ei-Problem ist. (Ich habe schließlich auf einem anderen Rechner (mit voller Tastatur) ein einzeiliges Skript geschrieben und auf den Laptop kopiert).

Sucht man in .Xmodmap nach "greater", so findet man zwar:

keycode  94 = less greater less greater bar brokenbar bar

Versucht man aber - nach Aufruf des Programms xev - die Taste mit dem Keycode 94 zu finden, so wird man nicht fündig. Ich habe mich schließlich für die Tasten "Blättern" (links und rechts über "Cursor links" und "Cursor rechts", Keycode 166 bzw. 167) entschieden und die Belegung dort wie folgt geändert:

keycode 166 = less bar XF86Back NoSymbol XF86Back

keycode 167 = greater NoSymbol XF86Forward NoSymbol XF86Forward

Nachdem Aufruf

xmodmap .Xmodmap

sind die fehlenden Zeichen nun zugänglich.

Spezielle Behandlung von ~/.Xmodmap

Nach einer einmaligen Nachfrage beim nächsten Einloggen wird die geänderte Tastaturbelegung unter X dauerhaft aktiv.

Hugin - Probleme unter Windows

2010-03-01T23:17:00.001+01:00

Hugin ist ein Open-Source-Projekt dessen Software u.a. dazu eingesetzt werden kann mehrere Einzelbilder zu einem Panorama zu kombinieren, ein Vorgang, der als "Stiching" bezeichnet wird.

Damit die Aufnahmen nahtlos ineinander übergehen müssen sog. Kontrollpunkte gesetzt werden. Der Kontrollpunkt in Bild A und der zugehörige Kontrollpunkt in Bild B bezeichnen den gleichen Ort in der realen Welt.

Man kann diese Kontrollpunkte von Hand setzen, aber auch dafür gibt es mittlerweile Hilfsprogramme. Ein bei Hugin-Usern sehr beliebtes (weil schnelles) Programm ist autopano-sift-c. Es sucht in den Bildern nach markanten Punkten und versucht diese zuzuordnen.

Im nächsten Schritt beginnt Hugin anhand dieser Daten die Bilder passend zu verzerren, zu verschieben und zu überblenden.

Die Probleme

Hugin ist mittlerweile auf diverse Plattformen portiert - so auch Windows - von wo mich der Hilferuf erreichte, der zu diesem Posting führte. Es waren mehrere Probleme aufgetreten, die das Programm unbrauchbar machten.

Hugin wird bei SourceForge gehostet. Die zurzeit (März 2010) dort verfügbare Windows-Version ist schon 2 Monate alt.

Unterdessen sind compilierte neuere Builds aus dem Hugin Subversion Repository aus anderen Quellen verfügbar und mein Bekannter hatte das neuste Build installiert (als User von Blender 2.5 kann ich das nachfühlen).
Diese Builds führen jedoch beim Laden der von ihm verwendeten TIFF-Dateien zu einem "TIFF library error". Ein Downgrade auf die ältere SourceForge-Version beseitigte das Problem.

Auch beim Suchen der Kontrollpunkte ist die neuere Variante (Autopano-SIFT-C version 2.5.2 23July2009) nicht die bessere.

Das Fehlerbild hier: Hugin meldet, dass keine Kontrollpunkte gefunden wurden.

Ruft man das Programm über die Kommandozeile auf, erkennt man, dass zwar einige Punkte gefunden werden (einige Hundert), normal sind jedoch 1000 und mehr. So verwundert es nicht, dass beim Abgleich, welche markanten Punkte aus Bild A zu denen in Bild B passen könnten, zum Schluß keiner übrig bleibt.

Abhilfe schafft hier, wie von Bart van Andel in einem Google-Groups-Thread beschrieben, die ältere Version 2.5.1 (Download Link siehe erwähnter Thread). Das Einbinden der neuen Version erfolgt über "Datei - Einstellungen - Kontrollpunkt-Detektoren".

Fazit

Sollte eines der oben erwähnten Probleme auftreten, so scheint zurzeit die folgende Kombination am stabilsten zu laufen:

Hugin_2009.4 von SourceForge und Autopano-SIFT-C 2.5.1.

Blender 2.5 alpha 1 verfügbar

2010-02-20T21:12:00.001+01:00

Seit heute ist Blender 2.5 alpha 1 verfügbar.

Dieses offizielle Release läuft auch unter Ubuntu Hardy - der (noch) aktuellen LTS-Version von Ubuntu.

Bei den aktuelleren Blender Builds auf GraphicAll.org war das seit dem Übergang von Alpha 0 auf Alpha 1 leider nicht mehr der Fall.

Python: cStringIO vs. StringIO

2010-01-01T08:59:00.004+01:00

If a function expects a file handle as an input parameter, but the data you want to process is stored in a string variable, you could store its content in a temporary file on disk, then open that file and use its file handle for the above mentioned function.

A nicer way to do this is the python function StringIO in the StringIO library. It takes the string as an argument and returns a file handle, from which the function can read(). The conversion happens in memory, i.e. no tedious creation of temporary files.

Depending on how often you need this functionality and how large the data is, the StringIO.StringIO - which is programmed purely in Python - may be too slow.

The library cStringIO offers a function with the same name with the same functionality carried out by a faster C-implementation. This function should be a drop-in replacement for the Python version.

However, since more and more strings are stored in unicode this function has an unexpected side effect. This side effect is detailed in the library description, if you look close enough.

cStringIO.StringIO does not return the original encoded text, but the "representation of the Unicode string", which may differ from machine to machine:

>>>import StringIO
>>> a = StringIO.StringIO(u"test")
>>> a.read()
u'test'

>>>import cStringIO
>>> a = cStringIO.StringIO(u"test")
>>> a.read()
't\x00\x00\x00e\x00\x00\x00s\x00\x00\x00t\x00\x00\x00'

A patch to fix this was proposed but rejected due to backwards compatibility.

So be aware...

wxPython-Versionen auswählen

2009-12-28T14:02:00.001+01:00

Wenn mehrere wxPython-Versionen gleichzeitig auf einem System installiert sind, so lädt ein einfaches

import wx

natürlich immer die Version, mit der man gerade nicht arbeiten will.

import wxversion
wxversion.select('2.8')
import wx

Die Version des gerade geladenen Moduls erhält man mit:

print wx.__version__

Changing USB device permissions in Ubuntu Karmic

2009-12-25T22:36:00.001+01:00

If you plug an USB device into a Linux box that uses a current distro, udev dynamically creates an entry in the /dev directory. You can list all currently available USB units with the lsusb command:

$ lsusbBus 002 Device 003: ID 03eb:6125 Atmel Corp. Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hubBus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

The only "real" device here is my XAiOX GPS logger (first entry). The output shows that it has the vendor id (hex) 03eb, the product id (hex) 6125.

The device file created by udev is: /dev/bus/usb/002/003
(Yes, these are the bus and device numbers shown in the lsusb output).

The default permissions are rather restrictive:

$ ls -l /dev/bus/usb/002insgesamt 0crw-rw-r-- 1 root root 189, 128 2009-12-23 22:14 001crw-rw-r-- 1 root root 189, 128 2009-12-23 22:19 003

Only root can read and write to the USB device. Anybody else only has read access.

In order to retrieve the stored GPS info from my GPS logger (e.g. by using itrackutil), I have to instruct the device to send the data. In order to send this command I need the write privileges.

I could start the itrackutil as root, but from a security standpoint that is not what you want.

This problem usually arises only, if the USB device is not (yet) managed by the system, because part of that managing process is... changing the permissions.

The solution I'm suggesting here works with Ubuntu Karmic.

The first step is to create a group named usbusers (or any other name), then make yourself member of that group and instruct udev to set the device group id to usbusers and set the permissions accordingly.

On the command line, creating a group and adding the user (e.g. mike) is quite simple:

sudo groupadd usbuserssudo adduser mike usbusers

If you pefer the Gnome GUI, you find the appropriate program under "System - Administration - User and groups":

After unlocking the panel ("Click to make changes"), click onto "Manage Groups".

"Add Group".

Make enter "usbusers" as group name, make sure that the group id suggested by the system is not zero. It's usually in the 1000+ range, enable the "Group Members" and click "Ok".

As a last step you have to create a new udev rule:

SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", MODE="0664", GROUP="usbusers"

Save it under the following name: /etc/udev/rules.d/45-xaiox.rules

Then reboot.

Two remarks regarding the filename:

in order to be executed, the filename must end with .rules (all other files are ignored)
the 45 ensures that the file is executed before the corresponding "old" rule found in /lib/udev/rules.d/50-udev-default.rules

If you now plug-in your usb device, the permissions look like this:

$ ls -l /dev/bus/usb/002/total 0crw-rw-r-- 1 root usbusers 189, 128 2009-12-25 20:20 001crw-rw-r-- 1 root usbusers 189, 133 2009-12-25 22:22 006

And being a member of usbusers, you have read and write access.

Blender 2.5 alpha, slow screen update

2009-12-10T01:17:00.002+01:00

Now that I got Blender 2.5 alpha 0 running on my old laptop, I noticed that when rotating what must be the most deleted cube in the 3D world, the refresh rate was very slow. An update rate of 2 or 3 times per second makes the program unusable.

Granted, the laptop is not very fast, but in the old version of Blender (2.49a) the cube followed the mouse movement without any visible delay.

Having seen Blender using OpenGL without hardware acceleration before, I tried pressing one of the OpenGL buttons down in the "header" of the 3D window:

This produced the error: "Failed to create OpenGL offscreen buffer".

Something was wrong with the use of OpenGL.

User teeth in the developer IRC channel #blendercoders on freenet.org, suggested to change the user preferences from "Triple Buffer" to "Overlap".

You can display these settings using "File - User Preferences" or Ctrl-Alt-U. Then select "System" and look for the "Window draw method".

Don't forget to "Save as default".

It worked here. If you have the same problem, it's worth a try.

Bisecting mesa - bug 446632

2009-12-01T23:20:00.012+01:00

Bug 446632 is responsible for the segfaulting blender on start-up on machines with ATI graphics cards running Ubuntu Karmic.

Analysis showed that the segfault originated in the mesa library. The code of the mesa contains the OpenGL implementation under Linux, and is used by Blender and various other programs.

During the pre-release process of Karmic, various builds of the mesa package have been made and are still available online. Tests showed that the last build without the bug was 7.6.0~git20090817.7c422387-0ubuntu8. The next one was 7.6.0-1ubuntu1.

To determine which patch between those two releases is responsible for the bug, a process called git-bisecting is used. For this, you give git the id of a version with and without the bug. Git chooses a version in the middle. You check it out, compile it and test it. After that you tell git if this version was good or bad. After that git chooses another version halfway between the last good and the first bad one. This process is repeated until you find the bad commit.

Sounds simple enough.... but it raises the following questions:

What Git repository does Ubuntu use for the mesa package?
Which commits correspond to the above mentioned builds?
And once you have the source, how do you compile, package and use it?

Within the Ubuntu project there is no git repository that describes the way from 7.6.0~git20090817.7c422387-0ubuntu8 to 7.6.0-1ubuntu1. Therefore we use the upstream git repository at git://anongit.freedesktop.org/mesa/mesa (browseable: http://cgit.freedesktop.org/mesa/mesa) on which the Ubuntu version is based.

7c422387 is the commit id within the freedesktop repository (well, not quite. The real commit ID is 7c4223876b4f8a78335687c7fcd7448b5a83ad10, but the first few digits are usually sufficient to find it).

The last commit of the 7.6.0 branch in this repository has the label mesa_7_6

The way to compile the source is described later in this post. As you will see, packaging is not necessary. The compiled drivers can be used directly.

"Git"ting started

You need git-core - and also download gitk (which is not really necessary, but makes a nice graphical representation).

sudo apt-get install git-core gitk

choose a directory and download the entire repository (in this tutorial I use my home directory).

cd ~
git clone git://anongit.freedesktop.org/mesa/mesa

This will create the subdirectory mesa, and a subdirectory .git, that contains the content of the cloned repository.

Be patient. After counting the elements to be transferred it takes some time before the actual download begins. All in all around 100 MB.

The code that we are going to compile needs some additional source files:

sudo apt-get build-dep mesa
sudo apt-get install libx11-dev libxt-dev libxmu-dev libxi-dev

Further preparations

make clean
./autogen.sh
./configure --prefix=/usr --mandir=\${prefix}/share/man \
--infodir=\${prefix}/share/info --sysconfdir=/etc \
--localstatedir=/var --build=i486-linux-gnu --disable-gallium --with-driver=dri \
--with-dri-drivers="r200 r300 radeon" --with-demos=xdemos --libdir=/usr/lib/glx \
--with-dri-driverdir=/usr/lib/dri --enable-glx-tls --enable-driglx-direct --disable-egl \
--disable-glu --disable-glut --disable-glw CFLAGS="-Wall -g -O2"

make clean removes the "debris" from previous compilations. But we haven't created any yet... Do it anyway - it's good practice :-)

./autogen.sh verifies that all prerequisites are met. If anything is missing, it will complain.

./configure sets up what is compiled, where and how.

During the tests remove -O2 (under CFLAGS). This disables compiler optimisations. The resulting code is a bit larger and a little bit slower, but it is easier to use during debugging.

--with-dri-drivers="..." determines which drivers are compiled. As the original bug only affects ATI machines, we only need the drivers we use. That saves a lot of compile time. If yours is not among them, check out ~/mesa/src/mesa/drivers/dri/ and add it.

You can find out which driver you are using with:

xdriinfo driver 0

Verify the good build

We know that build 7c4223876b4f8a78335687c7fcd7448b5a83ad10 still works with Blender. So let's check it out, compile it and test it. If Blender does not crash, we know that the process so far is working correctly.

git checkout 7c422387
make

We could enter the entire ID, but the first few digits are usually sufficient.

make should finish without errors. Now we start Blender using:

LD_LIBRARY_PATH="~/mesa/glx" LIBGL_DRIVERS_PATH="~/mesa/src/mesa/drivers/dri/radeon" Blender

LD_LIBRARY_PATH and LIBGL_DRIVERS_PATH make Blender (and only Blender, or any other program you specify) use the just compiled libraries. No need to reboot or to restart X. No effects to the remaining programs.

Please note, that you may need to replace the radeon part of the driver path with r200 or r300 depending on the driver you use.

Blender should run correctly.

Bisecting

We now officially start the bisecting process:

git bisect start

... and tell git that this was a "good" build.

git bisect good

Checking out the bad build

As we can not pinpoint which git version corresponds to first bad Ubuntu build (7.6.0-1ubuntu1) we simply start at the newest commit in the mesa_7_6 branch:

git checkout mesa_7_6

This replaces the files in the mesa directories and its subdirectories (except .git) with the new ones.

We compile it:

make

and test it:

LD_LIBRARY_PATH="~/mesa/glx" LIBGL_DRIVERS_PATH="~/mesa/src/mesa/drivers/dri/radeon" Blender

This time Blender should crash. We notify git:

git bisect bad

With this command, git chooses a commit approx. in the middle:

Bisecting: 482 revisions left to test after this (roughly 9 steps)
[ee066eaf6d0dd3c771dc3e37390f3665e747af2a] llvmpipe: Allow to dump the disassembly byte code.

The make, test, bisect process is repeated until git displays the first bad commit.

bfbad4fbb7420d3b5e8761c08d197574bfcd44b2 is first bad commit
commit bfbad4fbb7420d3b5e8761c08d197574bfcd44b2
Author: Pauli Nieminen 
Date: Fri Aug 28 04:58:50 2009 +0300
r100/r200: Share PolygonStripple code.
:040000 040000 1b1f09ef26e217307a5768bb9806072dc50f2a14 eb20bf89c37b2f59ce2c243b361587918d3c9021 M src

As an interesting side note, the driver from this commit does crash Blender, but not with a segfault. There is even an output on the console: "drmRadeonCmdBuffer: -22".

The next commit in this branch 4322181e6a07ecb8891c2d1ada74fd48c996a8fc makes Blender crash the way we have come to know.

The previous commit (e541845959761e9f47d14ade6b58a32db04ef7e4) would be a good candidate to keep Blender running until mesa is fixed:

git checkout e541845959761e9f47d14ade6b58a32db04ef7e4
make
LD_LIBRARY_PATH="~/mesa/glx" LIBGL_DRIVERS_PATH="~/mesa/src/mesa/drivers/dri/radeon" Blender

Ackowledgements
Tormod Volden for creating and updating https://wiki.ubuntu.com/X/BisectingMesa and various other info.

References
https://bugs.launchpad.net/ubuntu/+source/mesa/+bug/446632
http://bugs.freedesktop.org/show_bug.cgi?id=25354
https://wiki.ubuntu.com/X/Bisecting
https://wiki.ubuntu.com/X/BisectingMesa
https://launchpad.net/~xorg-edgers/+archive/ppa
http://www.kernel.org/pub/software/scm/git/docs/user-manual.html
http://cgit.freedesktop.org/mesa/mesa

Update zum "Blender"-Bug

2009-11-30T13:09:00.004+01:00

Bei den Abstürzen von Blender unter Ubuntu Karmic scheint es sich nicht um einen Fehler in Blender zu handeln, sondern um einen Bug im Paket mesa, das für die OpenGL-Implementierung unter Linux zuständig ist.

Der Bug-Report ist unterdessen upstream gemeldet.

Blender-Absturz in Karmic

2009-11-27T00:41:00.006+01:00

Blender 2.5 Alpha 0 ist gerade erschienen, und dass dies nicht auf Anhieb funktioniert erwartet man fast.

Dass allerdings die ältere Version von Blender (2.49a) aus den Ubuntu-Repositories nicht funktioniert, ist dann schon ärgerlicher, zumal sich wahrscheinlich das nächste halbe Jahr nichts daran ändern wird.

Blender stürzt nach dem Aufruf mit einem Segfault ab.

Probleme scheinen mal wieder nur die ATI-Karten zu haben.

Bug-Report in Ubuntu's Launchpad

itrackutil 0.1 veröffentlicht

2009-11-18T00:13:00.009+01:00

Seit einigen Wochen bin ich Besitzer eines XAiOX iTrackU GPS Loggers.

Das Gerät verwendet den SirfIII Chipsatz, besitzt Bluetooth und kann bis zu 250.000 Wegpunkte speichern, das sind, wenn man einen Punkt pro Sekunde aufzeichnet, fast drei Tage.

So lange hält der eingebaute Akku zwar nicht, aber die - laut Prospekt - immerhin 17 Stunden sind reichlich bemessen.

Außerdem hat er eine Sprachansage, zur Quittierung verschiedener Betriebszustände (Bluetooth ein/aus, Satellitensuche, Fix).

Die Sprachansage ist wohl eher dem (bis auf die Firmware) baugleichen Gerät mit dem Namen TrapScout zu verdanken, das als "Speed Camera Detector" per USB eine Datenbank mit Koordinaten programmiert bekommt und dann an den "Points of Interest" die Ansage "Sie fahren zu schnell." ausgibt.

Für OSM-Tracker ist natürlich die erste Variante interessanter.

Und zunächst sah es so aus, als hätte ich nach längerer Zeit ein Gerät gefunden, für das es unter Linux keine Software gab. Aber auch hier war mir jemand zuvorgekommen. Harmut Schimmel hatte bereits vor einiger Zeit ein paar Perl-Skripte geschrieben, mit denen das Gerät von der Kommandozeile aus programmiert und ausgelesen werden konnte und diese auf seiner Site veröffentlicht.

Ein paar offene Fragen gab es dann aber doch noch. Die Ergebnisse von USB Sniffer und ein wenig Knobelei habe ich dokumentiert und sie sind in meine Utility itrackutil, das auf SourceForge in der Version 0.1 veröffentlicht worden ist, eingeflossen.

Viele Stellen in den vom Logger gesendeten Daten sind noch unklar, und können nur durch Vergleich mit anderen XAiOX iTrackU mit SirfIII Chipsatz vielleicht weiter entschlüsselt werden.

Außerdem berichtet Hartmut, dass weitere Geräte "kompatibel" sind. Tester mit diesen Geräten suche ich auch:

XAiOX iTrackU mit Nemerix Chipsatz
Gisteq PhotoTrackr
Gisteq PhotoTrackr Lite (DPL700)

Das Programm läuft zurzeit unter Linux (Ubuntu Karmic), stellt aber von den weiteren Abhängigkeiten keine allzu großen Hürden auf.

Und obwohl diese Pakete auch unter Windows verfügbar sind, haben erste Versuche gezeigt, dass die zur USB-Kommunikation eingesetzte Bibliothek libusb dann doch nicht 100%ig ihrem Linux-Pendant entspricht.

USB Sniffing unter Linux

2009-10-21T10:07:00.005+02:00

USB Sniffing – also das „Belauschen“ der USB-Kommunikation zwischen Computer und Endgerät – wird gerne eingesetzt, wenn für ein Gerät zwar ein Windows-Treiber aber kein Linux-Treiber vorhanden ist. Man versucht dabei herauszubekommen, welche Aktionen in der Windows-Anwendung welche USB-Kommunikation nach sich zieht, um dies dann in einer Linux-Anwendung nachzubilden.

Hierzu wird normalerweise ein Treiber im Windows-System installiert, der die Daten abfängt und protokolliert, bevor Sie an die USB-Schnittstelle weitergeleitet werden.

Auch unter Linux gibt es eine derartige Einrichtung. Sie nennt sich:

usbmon

Das Aktivieren ist unter Ubuntu Jaunty denkbar einfach:

sudo mount -t debugfs none_debugs /sys/kernel/debug

Unter Hardy ist usbmon noch ein separates Kernelmodul, das zusätzlich mit

sudo modprobe usbmon

eingebunden werden muss.

Danach erscheinen unter /sys/kernel/debug/usbmon diverse Dateien. Zum Beispiel:

$ls /sys/kernel/debug/usbmon

0s 0t 0u 1s 1t 1u 2s 2t 2u 3s 3t 3u

Die Zahl im Namen bezeichnet die Nummer des USB-Busses (hier 1, 2 und 3). Der virtuelle „Bus 0“ liefert die Events aller Busse. Der Buchstabe hinter der Zahl (s, t, u) beschreibt, was ausgegeben werden soll:

u – der mitgeschnittene Datenverkehr
s – Statusmeldungen
t – eine Teilmenge von „u“ (dieser Eintrag wird in absehbarer Zeit nicht mehr unterstützt).

Was bleibt, ist diese Datei auszugeben und/oder in eine Datei umzuleiten, z.B.:

cat /sys/kernel/debug/usbmon/0u > usbmon.txt

Wireshark

Ganz ohne dieses Modul kommt Wireshark aus. Mit „Capture – Interfaces“ kann auch ein USB-Bus ausgewählt werden. Hierzu sind natürlich root-Rechte notwendig.

Wireshark stellt die USB-Kommunikation in ähnlicher Weise wie sonst den Netzwerkverkehr dar. Außerdem werden die diversen Konstanten und Strukturen, wie bei Wireshark üblich, schon dekodiert und mit Klartext ausgegeben.

Was bringt's?

Virtuelle Maschinen (z.B. VirtualBox, Vmware) haben unterdessen die Möglichkeit, USB-Geräte im virtualisierten System laufen zu lassen, die über das Gast-System auf die USB-Schnittstelle zugreifen.

Kombiniert man diese beiden Möglichkeiten, so lassen sich z.B. Geräte in einer virtualisierten Windows-Umgebung betreiben, und „von außen“ belauschen.

Licht im Tunnel

2009-09-22T00:17:00.004+02:00

Um die meist textbasierten Internet-Protokolle von Hand auszuprobieren verwendet man häufig Telnet. So kann man sich mit

telnet www.google.de 80

mit einem Web-Server verbinden und eine Seite mit

GET / HTTP/1.0

abrufen.

In ähnlicher Weise kann man andere Protokolle ausprobieren.Wenn Sie also immer schon wissen wollen, was der Befehl UIDL bei POP3-Servern bewirkt, telnet bringt Sie Ihrem POP3-Server näher.

Wenn die Verbindung mit SSL verschlüsselt ist, hilft telnet nicht mehr weiter.

In einem Artikel bei Heise wird der Einsatz von openssl beschrieben. Die Unterfunktion s_client stellt das SSL-Pendant zum guten alten telnet dar.

openssl s_client -connect www.heise.de:443

Nachdem die SSL-Verbindung aufgebaut ist, werden diverse Informationen angezeigt (chain of trust, Serverzertifikat, verwendete Verschlüsselungsalgorithmen usw.).

Danach kann man sich - wie bei Telnet - mit dem Server unterhalten.

Der lange Marsch nach Huawei

2009-09-14T00:36:00.011+02:00

Das UMTS-Modem

Zurzeit gibt es bei Aldi-Süd den „Internet-USB-Stick S4011“ für knapp 60 €.

Die von lsusb ausgegebene USB-ID sowie die „Selbstauskunft“ des Sticks zeigen aber, dass es sich um ein Huawei E160 handelt, wie sie im Augenblick zu Tausenden in Startersets von diversen Mobilfunkanbietern unter die Leute gebracht werden.

Unter der Glasabdeckung des Lebensmitteldiscounters war jedoch die Rückseite nicht zu erkennen, die auf das hauseigene Starterset hinweist. Ganz unten findet sich dann aber dann der Hinweis, dass dieses Starterset nicht im Lieferumfang enthalten ist.

Und in der Tat hat dieser Stick, im Gegensatz zu vielen anderen (teilweise teureren) „Startersets“, keinen Sim-Lock und ist hier schon mit den SIM-Karten der unterschiedlichsten Mobilfunkanbieter gelaufen.

Eine kurze Recherche zeigte, dass der Stick vom (noch) aktuellen Ubuntu Jaunty unterstützt wird, und in der Tat läuft er mit dem Network-Manager ohne Probleme.

Der Datentarif

Ohne SIM-Karte läuft aber auch dieses Modem nicht. Da der Stick nur gelegentlich eingesetzt werden soll, fiel die Wahl - nach einiger Suche - auf die Prepaid-Karte von Fonic.

Auch dort gibt es ein Starterset – 69,95 € mit 5 Tagen freies Surfen. Der Stick, ein – wer hätte es gedacht – Huawai E160, hat jedoch, nach Auskunft der Hotline, einen Simlock.

Da ich ja nun bereits ein simlock-freies E160 habe war die Alternative die normale SIM-Karte von Fonic (mit 111 Freiminuten). Da die Freiminuten bzw. die „Frei-Tage“ als Guthaben auf das Prepaid-Konto gutgeschrieben werden besteht zwischen den Angeboten kein großer Unterschied.

Der normale Datentarif kostet zurzeit 0,24 €/MB und kann von der Hotline vom Volumentarif auf die Tagesflatrate zu 2,50 € umgestellt werden. Bei der Flatrate wird nach 1 GB am Tag die Geschwindigkeit gedrosselt.

UMTSmon

Wie bereits erwähnt läuft der Stick unter Network-Manager ohne Probleme. Bei meiner Recherche bin ich aber auf das Programm UMTSmon gestoßen.

UMTSmon gab es schon bevor die Funktion in den Network-Manager integriert wurde. Es hat ein paar nützlich Zusatzfunktionen, wie das Anzeigen der Empfangsfeldstärke, SMS-Versand und das Nachhalten der verbrauchten Zeit und des verbrauchten Datenvolumens.

UMTSmon ist leider nicht in den Ubuntu-Repositories verfügbar. Ein i386 Binary ist jedoch im Download-Bereich des Projekts zu finden.

usb_modeswitch

UMTSmon verlangt nach einem weiteren Progamm: usb_modeswitch. Das Programm ist auf der Seite des Autors erhältlich. Das Debian-Projekt hält es als .deb-Paket vor. Bei neueren Kernels ist usb_modeswitch eigentlich nicht mehr notwendig, da der Kernel diese Funktion übernimmt.

Die Huawai-Sticks melden sich nämlich zunächst als USB-Massenspeicher an. Dieser Massenspeicher enthält Software und Treiber, die unter Windows per Autorun gestartet und installiert werden. Diese Treiber schalten dann den Stick in den „Modem-Modus“ um. Unter Linux übernimmt diese Funktion usb_modeswitch, und seit einiger Zeit der Kernel. Diese Technik ist auch als ZeroCD bekannt.

… und die Problemchen

Beim ersten Aufruf prüft UMTSmon diverse Abhängigkeiten. Zunächst bemängelte es das fehlende SUID-Bit bei usb_modeswitch. usb_modeswitch braucht für seine Aufgabe Root-Rechte. Diese waren schnell nachgetragen mit:

sudo chmod u+s /usr/sbin/usb_modeswitch

Das nächste Problem bestand darin, dass sich das Modem in kein Netz einwählen konnte. Der Network Operator Wizard (Verbindung – Netzbetreiber auswählen) zeigte zwar diverse Netze an, nur ansprechen konnte ich sie nicht. Dieses Problem löste sich aber mit der Zeit von selbst. Man sollte bei neuen SIM-Karten warten bis sie freigeschaltet sind... :-)

Nach der Freischaltung fand das Modem auch das von Fonic verwendete O2-Netz.

Danach habe ich eine neues Profil für Fonic angelegt (Verbindung – Profile bearbeiten – Add Profile). Als APN (Zugangspunkt) habe ich die im Netz angegebene Adresse „pinternet.interkom.de“ verwendet (ohne Gewähr). Ansonsten habe ich die Standardeinstellungen belassen.

pppd

Der Versuch, sich mit dem Internet zu verbinden (2. Icon von links - „Connect to default profile“), scheiterte mit der Fehlermeldung:

und den vielsagenden Erklärungen:

<< ppp did not provide any stdout information >> und
<< ppp did not provide any stderr information >>

Leider brachte mich der gutgemeinte Hinweis auf die Kommandozeilen-Option -v4 nicht viel weiter. Sie bewirkt, dass UMTSmon Debug-Informationen ausgibt. Unter anderem sieht man die Kommunikation mit dem Modem.

Zum Einbinden des Internets ruft UMTSmon den pppd Daemon auf. Sehen wir uns die Datei pppd mal genauer an:

$ ls -l /usr/sbin/pppd
-rwsr-xr-- 1 root dip 277352 2009-02-20 18:25 /usr/sbin/pppd

Das Programm kann nur von root oder einem Mitglied der Gruppe dip gestartet werden – und das bin ich „normalerweise“ nicht. Der Grund, weshalb UMTSmon keine Informationen von ppp erhält ist, dass das pppd mangels fehlender Rechte nicht gestartet wurde.

Wo ist dip?

Natürlich könnte man UMTSmon einfach mit root-Rechten aufrufen, aber das gehört sich nicht. Die einfachste Variante zum Mitglied der Gruppe dip zu werden ist der Befehl:

sudo adduser user_name dip

Der Versuch dies über die GUI (System – Systemverwaltung – Benutzer und Gruppen) zu erledigen läuft zunächst ins Leere. Ruft man nach dem „Entsperren“ den Punkt „Gruppen verwalten“ auf, so sucht man dort die Gruppe dip vergebens. Diese Gruppe versteckt sich bei den Benutzerrechten.

Also: Benutzer anklicken – Eigenschaften – Benutzerrechte – „Internet-Verbindung mit Modem aufbauen“ ankreuzen.

Eigentlich logisch – aber das muss man wirklich erst einmal wissen. Die Option „Modems verwenden“ muss ebenfalls aktiv sein, was sie jedoch standardmäßig ist. Sie macht einem zum Mitglied der Gruppe dialout.

Dann muss man sich erst einmal ab- und wieder anmelden, bevor diese neue Einstellung aktiv ist. Ein Neustart ist jedoch nicht nötig.

Ein neuer Versuch

Der nächste Versuch, ins Internet zu kommen, scheiterte auch. Diesmal war die Fehlermeldung (stdout) etwas umfangreicher. Hier ein gekürzter Ausschnitt:

pppd options in effect:
debug debug debug # (from command line)
...
/dev/ttyUSB1 # (from command line)
460800 # (from command line)
lock # (from command line)
crtscts # (from command line)
...
Using interface ppp0
Connect: ppp0 <--> /dev/ttyUSB1
...
LCP: timeout sending Config-Requests
Connection terminated.
Receive serial link is not 8-bit clean:
Problem: all had bit 7 set to 0
Modem hangup

Im Rahmen der Fehlersuche hatte ich mit dmesg das Boot-Protokoll abgefragt. Dort findet man u.a.:

[ 11.424602] USB Serial support registered for GSM modem (1-port)
[ 11.424737] option 2-2:1.0: GSM modem (1-port) converter detected
[ 11.425007] usb 2-2: GSM modem (1-port) converter now attached to ttyUSB0
[ 11.425071] option 2-2:1.1: GSM modem (1-port) converter detected
[ 11.425322] usb 2-2: GSM modem (1-port) converter now attached to ttyUSB1
[ 11.425405] usbcore: registered new interface driver option
[ 11.425452] option: v0.7.2:USB Driver for GSM modems

Hier ist zu erkennen, dass der Kernel für das Modem zwei serielle Devices einrichtet: /dev/ttyUSB0 und /dev/ttyUSB1

Startet man umtsmon mit den Optionen -v4 und --force-autodetect kann man schön verfolgen, wie

zunächst das Modem als solches erkannt wird
die beiden seriellen Devices gefunden und
nacheinander getestet werden (ein Modem antwortet auf „AT“ mit „OK“)
und dann sowohl für die AT-Befehle als auch für die PPP-Verbindung /dev/ttyUSB1 ausgewählt wird.

Hier die interessanten Ausgaben:

##P3 t=372: Start iterating through all AutoDetectors
…
##P3 t=372: Let's continue with the next AutoDetector

##P3 t=372: AutoDetectBase::go() for 'USB ZeroCD Autodetection'
##P3 t=372: AutoDetect_USB::traverseTrees()
##P4 t=372: Checking USB device on 001:006
##P3 t=372: AutoDetect_USB::matchIDs(0x12d1, 0x1003)
##P3 t=372: This is a known ZeroCD Device: "Huawei E220 / E800"
##P3 t=372: AutoDetect_USB_ZeroCD::findPortNames()
##P3 t=372: AutoDetect_USB::findPortNames()
##P4 t=372: looking for ttyUSB ports
##P4 t=372: Found serial port number 1 with name 'ttyUSB0'
##P4 t=372: Found serial port number 2 with name 'ttyUSB1'
##P3 t=372: INFO: 'There are 2 ports available'
…
##P3 t=372: AutoDetect_USB::traverseTrees()
##P4 t=372: Checking USB device on 001:006
##P3 t=372: AutoDetect_USB::matchIDs(0x12d1, 0x1003)
##P2 t=372: GOOD: 'A 'Huawei E220 / E800' modem detected'
##P3 t=372: AutoDetect_USB::findPortNames()
##P4 t=372: looking for ttyUSB ports
##P4 t=372: Found serial port number 1 with name 'ttyUSB0'
##P4 t=372: Found serial port number 2 with name 'ttyUSB1'
##P3 t=372: INFO: 'There are 2 ports available'
...
##P3 t=372: Device: probing port '/dev/ttyUSB0' for AT commands
##P3 t=372: TempSerialPort::TempSerialPort()
##P3 t=372: Serial::openDev('/dev/ttyUSB0') as FD 7 - Serial instance 0xbfa4eec0
##P4 t=372: Query sends the following mesage: 'AT'
##P2 t=372: Device port '/dev/ttyUSB0': no response to "AT", return code 5
##P3 t=372: Device: probing port '/dev/ttyUSB0' failed
##P3 t=372: TempSerialPort::~TempSerialPort()
##P3 t=372: SerialPort::closeDev() for FD 7
##P3 t=372: Device: probing port '/dev/ttyUSB1' for AT commands
##P3 t=372: TempSerialPort::TempSerialPort()
##P3 t=372: Serial::openDev('/dev/ttyUSB1') as FD 7 - Serial instance 0xbfa4eec0
##P4 t=372: Query sends the following mesage: 'AT'
##P4 t=372: answer 1:'AT'
##P4 t=372: answer 2:'OK'
##P3 t=372: Got Query::OK from port
##P3 t=372: Device: probing port '/dev/ttyUSB1' successful
…
##P3 t=372: TempSerialPort::~TempSerialPort()
##P3 t=372: SerialPort::closeDev() for FD 7
##P3 t=372: set AT serial to '/dev/ttyUSB1'
##P3 t=372: set PPP serial to '/dev/ttyUSB1'
##P3 t=373: Serial::openDev('/dev/ttyUSB1') as FD 7 - Serial instance 0x9ff3b70
##P2 t=373: GOOD: 'Device created successfully'
##P1 t=373: Found hardware configuration stored to disk
##P3 t=373: TheDeviceManagerSingleton::writeToConfigFile()
##P3 t=373: Everything done - device created

Könnte es also sein, dass man für die PPP-Verbindung /dev/ttyUSB0 statt 1 verwenden sollte? Die entsprechende Option beim Aufruf lautet:

umtsmon -s/dev/ttyUSB1,/dev/ttyUSB0

Und siehe da... Internet!

Damit man dies nicht andauernd eingeben muss, kann man es auch in der Konfiguration von UMTSmon dauerhaft ändern (zu finden unter ~/.umtsmon/umtsmonrc):

[device]
ATPortName=/dev/ttyUSB1
PPPPortName=/dev/ttyUSB0

Happy surfing.

Linux, Python und die MS-Access-Datenbank

2009-07-29T00:09:00.014+02:00

Hier lag sie nun - ein Überbleibsel aus einer anderen Zeit und Welt. Eine Bilderdatenbank, die ich vor Jahren unter Windows mit dem bekannten Programm "Daumen Plus" erstellt hatte und deren Daten ich nun gerne nutzen wollte. Das Problem war das Format: MS-Access

Dieses Format ist unter Linux nicht gerade gängig, der Zugriff ist aber - wenn auch nicht "out of the box" - durchaus möglich.

Die hier beschriebenen Schritte beziehen sich auf eine Standardinstallation von Ubuntu Jaunty - sie dürften sich aber so oder ähnlich auch auf anderen Systemen nachvollziehen lassen.

Der Treiber

Der eigentliche Treiber findet man im Paket libmdbodbc. Wie der Name schon andeutet, läuft der Treiber im ODBC-Framework.

Die Schnittstelle ODBC

ODBC ist eine standardisierte Schnittstelle, in der auf der einen Seite Treiber wie Plugins die Verbindung zu den verschiedenen Datenbankentypen herstellen, und die auf der anderen Seite von Programmen - unabhängig vom Typ der Datenbank - immer in der gleichen Weise angesprochen werden können.

ODBC ist in Jaunty nicht standardmäßig installiert. Man braucht das Paket unixodbc. Zusätzlich sollte man noch unixodbc-dev holen, das wir weiter unten brauchen.

Zunächst muss man ODBC über das Vorhandensein des Treibers informieren. Die Treiber werden in Form sog. Templates eingerichtet. Hier das Template für MS Access.

[MDB]
Description = Microsoft Access ODBC Driver
Driver = /usr/lib/libmdbodbc.so.0
Setup =
FileUsage = 1
CPTimeout =
CPReuse =
UsageCount = 1

Es besagt, dass der Treiber libmdbodbc.so.0 nun im ODBC-Framework unter dem Namen frei gewählten Namen MDB angesprochen werden kann.

Speichern Sie dieses Template (z.B. unter derm Namen msaccess.template) und installieren Sie es mit dem folgenden Befehl:

odbcinst -i -d -f msaccess.template

Das Template wird in der Datei /etc/odbcinst.ini abgelegt. Diese Datei im INI-Format könnte man natürlich auch von Hand editieren.

Die Datenquelle

Eine Datenquelle fasst mehrere Parameter unter einem Namen (Data Source Name, DSN) zusammen. Diese Parameter könnten zwar auch beim Aufruf der Datenbank angegeben werden, aber der Parameterstring wird schnell sehr lang und seine Länge ist begrenzt.
Unter einem DSN werden in diesem Beispiel der verwendete Treiber, der Server und der Pfad zur Datenbank hinterlegt. Weitere Angaben sind je nach verwendetem Treiber möglich.

Das Verfahren ähnelt dem Einrichten des Treibers. Hier ein Beispiel:

[bilderdb]
Description = Bilder-Datenbank
Driver = MDB
Database = /home/mike/fotos.mdb
Servername = localhost
UserName =
Password =
Port = 5432

Abgespeichert in einer Textdatei mit dem Namen bilder.template, erfolgt die Installation entweder systemweit mit

odbcinst -i -s -l -f bilder.template

oder benutzerspezifisch mit

odbcinst -i -s -f bilder.template

Gespeichert wird diese Information in der INI-Datei /etc/odbc.ini (systemweit) bzw. ~/.odbc.ini (benutzerspezifisch).

Zugriff via Python

Zum Zugriff braucht man das Paket pyodbc. Das wiederum gibt es leider zurzeit nicht in einem Ubuntu-Paket. Man muss es - wie früher - aus dem Quellcode kompilieren. Hierzu braucht man zum einen den Sourcecode von pyodbc sowie die oben erwähnte Datei unixodbc-dev.

Wer das erste Mal selbst kompiliert, installiert noch build-essential, letzteres ist wieder bequem über apt-get oder Synaptic aus den Ubuntu-Archiven verfügbar.

Das pyodbc-Archiv muss entpackt werden. Danach begibt man sich in das beim Auspacken angelegte Verzeichnis und gibt

sudo python setup.py build install

ein. Das war es schon.

Kurze Zusammenfassung:

Aus den Ubuntu-Repositories braucht man:
build-essential, unixodbc-dev, unix-odbc und libmdbodbc.
Aus dem Web:
pyodbc

Und los geht's

import odbc

con = pyodbc.connect("DSN=bilderdb")
cursor = con.cursor()
cursor.execute("sinnvoller SQL-Befehl")
result = cursor.fetchone()

Jedem, der in Python mit Datenbanken zu tun hatte, sollten diese Zeilen bekannt vorkommen.

Die bei connect verwendete Zeichenkette, die in diesem Beispiel nur auf eine Datenquelle (DSN) verweist, kann viele andere Parameter aufnehmen, z.B. Username und Passwort bei einer passwortgeschützten Datenbank:

con = pyodbc.connect("DSN=bilderdb;UID=name;PWD=passwort")

Die einzelnen Parameter werden, durch Semikolon getrennt, in der Form Attribut=Wert aneinandergereiht. Die Namen der Attribute hängen vom verwendeten Treiber ab und sind recht vielfältig.

Zum Schluss noch ein paar nützliche Tipps beim Erkunden einer MS-Access-Datenbank:

Liste der Tabellen in einer Datenbank

import pyodbc

con = pyodbc.connect('DSN=bilderdb')
cursor = con.cursor()

for row in cursor.table():
print row

Die Zeilen haben den Aufbau (Werte: String oder None):

table_cat
table_schem
table_name Name der Tabelle
table_type SYSTEM TABLE, VIEW, TABLE

Die eigentlichen Tabellen werden unter dem Typ TABLE aufgelistet.

Aufbau einer Tabelle

Dieser lässt sich mit dem normalen SQL-Befehl erfragen:

cursor.execute('DESCRIBE TABLE tablenname")

Das Ergebnis wird in der Form (Name, Type, Größe) zurückgegeben.

Webdav-Bug in Ubuntu Jaunty

2009-07-26T01:01:00.016+02:00

Möchte man das Mediacenter vom GMX nutzen, so hat man mehrere Optionen, die Daten zum GMX-Server zu übertragen und dort zu verwalten (löschen, umbenennen usw.).

Zum einen den klassischen Weg über das Web-Interface mit Javascript, oder - sehr viel einfacher - über Webdav.

Mit Webdav lässt sich der Webspace so einbinden, als wäre er ein normaler Ordner, auf den man dann mit den normalen Funktionen des Betriebssystems zugreifen kann. In der Windows-Welt ist diese Funktion als "Webordner" bekannt.

Zum Einbinden sind die folgenden Informationen nötig:

Adresse: mediacenter.gmx.net
Username: die GMX-Kundennummer
Passwort: das GMX E-Mail-Passwort

Die Kommunikation kann verschlüsselt oder unverschlüsselt erfolgen. Da bei Webdav das Passwort (hier ist es sogar das E-Mail-Passwort) bei jedem Zugriff quasi unverschlüsselt übertragen wird, sollte man die Kommunikation als Ganzes absichern und die Option "davs:" bzw. "https:" wählen.

Unter Gnome gibt es diverse Möglichkeiten eine Verbindung zu einem Webdav-Server herzustellen. Am häufigsten dürfte wohl "Verbindung zu Server" im Menü "Orte" eingesetzt werden.

Wenn man diesen Menüpunkt aufruft, öffnet sich ein Fenster, in dem man das Protokoll ("sicheres WebDAV"),

den Server und den Benutzernamen eingeben kann.

Nach einem Klick auf "Verbinden" öffnet sich erwartungsgemäß ein weiteres Fenster, das nach dem Passwort fragt...
und nach dessen Eingabe erscheint in "Ubuntu Jaunty" eine Fehlermeldung, die sich über eine nicht korrekte Identifizierung beklagt.

Dies scheint ein Bug in der augenblicklichen Gnome-Version zu sein, unter Ubuntu Hardy und Intrepid arbeitet dieser Menüpunkt korrekt.

Der Work-Around

Einfach keinen Usernamen im ersten Fenster eintragen.

In diesem Fall wird in der zweiten Abfrage nach Usernamen und Passwort gefragt.

Nach deren korrekten Eingabe öffnet sich dann das gewünschte Nautlius-Fenster.

Ähnlich verhält es sich mit bei der zweiten Möglichkeit Webdav-Server anzusprechen:

Man gibt in der Adresszeile eines Nautilus-Fensters

davs://mediacenter.gmx.net

ein, statt einer URI mit Username:

davs://username@mediacenter.gmx.net

Die Ergebnisse und Fehlermeldungen sind entsprechend.

Und warum?

Schaut man sich mit einem Paket-Sniffer die Kommunikation zwischen Gnome und GMX an, dann läuft diese im Fall ohne Angabe des Usernamens wie folgt ab:

Gnome sendet eine OPTIONS-Abfrage an GMX, ohne Username und Passwort.
GMX antwortet mit dem Fehler 401 (Nicht authentifiziert) und Angabe eines sog. Realms.
Gnome fordert den Usernamen und das Passwort vom Benutzer an und
sendet eine erneute OPTIONS-Abfrage, diemal mit Username + Passwort.
GMX sendet ein OK (200) - und es folgt der normale Datenaustausch.

Gibt man hingegen den Username vorher an, so sind Schritt 1 und 2 identisch.
In Schritt 3 wird nur noch das Passwort abgefragt.
Schritt 4 fehlt, und deshalb gibt es auch keinen Schritt 5.
Nur eine Fehlmeldung von Gnome, dass es nicht geklappt hat.

Der Bug ist unterdessen gemeldet. Bis dahin halt den Usernamen nicht direkt angeben.

Eigene Videos auf das Cybershot

2009-07-14T01:52:00.015+02:00

Das Handy Sony Ericsson Cybershot C902 ist keine eierlegende Wollmilchsau (auch Eier legende Wollmilchsau) wie das iPhone - sondern eher zum Telefonieren gedacht.

Nun gut - ein paar Multimedia- und Organizer-Funktionen hat es dann doch, sowie einen 5 Megapixel-Fotosensor, und es kann Videos aufnehmen und wiedergeben.

Die Handhabung ist ... naja - aber hier geht es ja um...

Die Zusammenarbeit mit Linux

Die Kamera wird unter Linux über das mitgelieferte USB-Kabel als Standard-Massenspeicher erkannt und wie ein normaler USB-Stick behandelt, was den Datentransport sehr beschleunigt. Und seitdem unter Ubuntu Jaunty die Bluetooth-Treiber wieder funktionieren, klappt der Datenaustausch auch drahtlos.

Als Videoformate können 3GP- und MP4-Dateien wiedergegeben werden. Das Display hat 320 x 240 Pixel. Was die Bildgröße der Videos angeht, so skaliert und dreht das Handy (es hat einen Lagesensor) den wiedergegeben Clip, wenn dieser größer oder kleiner als das Display ist.

Erstellen einer MP4-Datei über die Kommandozeile

Ein auf verschiedenen Seiten empfohlener Workflow ist - das Codieren mit mencoder:

mencoder input_file \
-vf scale=320:240 \
-ovc lavc -lavcopts vcodec=mpeg4:vbitrate=300 \
-ofps 25 \
-oac faac -faacopts br=64:object=2 -channels 2 -srate 44100 \
-o output.avi

Dieser Aufruf skaliert das Video auf 320x240 Pixel, codiert es als mpeg4 mit einer Bitrate von 300 kbps und 25 Bildern pro Sekunde. Das Audio wird mit AAC codiert (hierzu muss ggf. das Paket libfaac0 nachinstalliert werden). Audioeinstellungen: Bitrate 64 kbps, Stereo (2 Kanäle) und eine Samplerate von 44100 Hz.

Weil mencoder angeblich kein normgerechtes MP4 erzeugen kann, wird das Ergebnis zunächst als AVI gespeichert, und im nächsten Schritt mit mplayer wieder in eine Video- und eine Audio-Datei getrennt:

mplayer output.avi -dumpvideo -dumpfile temp.mp4v
mplayer output.avi -dumpaudio -dumpfile temp.aac

Diese werden dann mit dem Programm mp4creator (aus dem Paket mpeg4ip-server) wieder zusammengefügt - diesmal normgerecht:

rm output.mp4
mp4creator -r 25 -c temp.mp4v output.mp4
mp4creator -c temp.aac output.mp4
mp4creator -optimize output.mp4

Das Ergebnis ist dann eine MP4-Datei, die vom C902 wiedergegeben werden kann. Die Bildrate (in diesem Beispiel 25 fps) muss hier explizit angegeben werden.

Man kann mit den Werten ein wenig spielen und z.B. die Audio-Abtastrate an das Quellmaterial anpassen. 300 kbps für Video und 64 kbps für Audio liefern für die Wiedergabe auf dem Handy brauchbare Ergebnisse.

Erstellen der MP4-Datei mit Avidemux

Avidemux ist ein Videokonvertier-Programm mit einigen rudimentären Schnittmöglichkeiten und diversen Bearbeitungsoptionen. Es lässt sich meist über das Repository der jeweiligen Distribution nachinstallieren.

Im Programm selber nimmt man dann - in Anlehnung an die von mencoder verwendeten Werte - folgende Grundeinstellungen vor:

Video: MPEG-4 ASP
Audio: AAC (FAAC)
Format: MP4

Video - Konfigurieren

Benutzerschnittstelle
Kodier-Modus:
Einfacher/zweifacher Durchlauf mit (Durchschnitts-)Bitrate

Bitrate (kb/s): 300

Audio - Konfigurieren

Konfigurieren:
Bitrate: 64 kb/s

Nun können auch die restlichen Filter und Bearbeitungsfunktonen zum Einsatz kommen. z.B. das Zuschneiden des Clips, Änderungen in der Bildgröße, De-Inferlace-Funktionen, Anlegen neuer Tonspuren, um nur einige zu nennen.

Das Ergebnis ist nach einem "Datei - Speicher - Video speichern" direkt auf dem C902 einsetzbar.

Und sollte die Wiedergabe des Videos das Handy einmal zum Absturz bringen - die Batterie lässt sich ja einfach aus- und wieder einbauen.

Firefox 3.5 in Ubuntu (AMD 64)

2009-07-12T12:40:00.004+02:00

Nun sollte es aber auch jeder mitbekommen haben... Die endgültige Version von Firefox 3.5 ist fertig.

Und da, wie zuletzt berichtet, bei der jetzigen Ubuntu-Version (Jaunty) nicht damit zu rechnen ist, dass ein Update verfügbar wird... auf zu mozilla.org, Firefox runtergeladen, läuft...

... wenn da nicht die Flash-Integration wäre. Die ist auf AMD64-Systemen nämlich ohne Tricks nicht so einfach zu haben.

Das Flash-Plugin von Adobe gibt es nur in 32 Bit, und läuft ohne weiteres nicht in 64-Bit-Versionen von Firefox. Dafür gibt es dann den npwrapper, mit dem dann 32-Bit-Plugins auch im 64-Bit-Firefox laufen.

Und auch wenn der Firefox von mozilla.org eine 32-Bit-Version war, so erkannte das von Adobe geladene Installationsprogramm für Flash eine 64-Bit-Umgebung, und brach ab.

Aber es geht auch einfacher!

Christoph Langner fasst in seinem Blog die Möglichkeiten in einem FAQ zusammen. Im Fall von Jaunty ist es besonders einfach - es gibt bereits ein Paket mit dem Namen "firefox-3.5". Dieser übernimmt auch die bestehenden Einstellungen (inklusive der Plugins).

Eine detaillierte Liste der installierten Plugins gibt es im übrigen mit der Eingabe about:plugins in der Adress-Zeile.

eth-Null bleibt eth-Null bleibt eth-Null

2009-06-19T22:20:00.005+02:00

In früheren Linux-Versionen hatte man in Systemen mit mehreren Ethernet-Netzwerkkarten hin und wieder das Problem, dass sich die eth-Gerätenummer z.B. nach einem Kernel-Update änderte, weil die Reihenfolge, in der Treiber aufgerufen wurden, auf einmal anders war.

Funktionen, die auf diesen Gerätenummern aufbauten - wie z.B. iptables-Firewalls - bringt dies natürlich durcheinander; und man hat sich unter Umständen ausgesperrt. Wenn der Computer dann nicht so einfach zugänglich ist, ist das... unangenehm.

Bei neueren, auf udev basierenden Systemen passiert das nicht mehr. Das System merkt sich die MAC-Adresse der Karte und weist ihr fest einen Gerätenamen zu. Das Ergebnis sind udev-Regeln, die man in /etc/udev/rules.d/70-persistent-net.rules * finden kann:

# PCI device 0x10de:0x0057 (forcedeth)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:11:22:33:44:55", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"

Diese Datei ist Ergebnis des Scripts /lib/udev/write_net_rules welches seinerseit von der udev-Regel /etc/udev/rules.d/75-persistent-net-generator.rules gestartet wird. (Beispiele aus Ubuntu Hardy).

In anderen Systemen, stehen diese Dateien teilweise in anderen Verzeichnissen, und die Nummer im Dateiname ist leicht verändert. Mit locate lassen sie sich aber leicht finden.

Die Kehrseite der häufigen Ubuntu-Releases

2009-06-16T00:10:00.003+02:00

Kehrseite der halbjährlichen Ubuntu-Releases ist die Tatsache, das während eines Release-Zyklus zwar Sicherheitsupdates veröffentlicht werden, Feature-Updates oder nicht sicherheitsrelevante Fehler frühestens mit dem nächsten Release behoben werden.

War es im vorletzten Release (Intrepid) - wegen Änderungen im Bluetooth-Stack - der nicht mehr funktionierende Bluetooth-Dongle, so schmerzen die beiden Bugs in Jaunty dann doch:

In OpenOffice verschwinden plötzlich Tabellen aus Word-Dokumenten, und Inkscape lässt sich nach dem Update wegen Durcheinander in den zu ladenden Bibliotheken nicht mehr starten.

Diese beiden Fehler treten bei mir nur in der wohl nicht so weit verbreiteten 64-Bit-Versionen auf und sollen teilweise schon behoben sein.

Auch wenn der Besuch auf dem Ubuntu-Bugtracker-Portal Launchpad einem das warme Gefühl vermittelt, dass man mit dem Problem nicht allein ist, dem Durchschnitts-Ubuntuaner (oder heißen Sie Ubuntuniken...) also dem Durchschnitts-Ubunter-User werden diese Updates wohl frühestens ab Oktober mit Karmic zur Verfügung stehen.

Firefox - online auch ohne Internet

2009-06-08T09:07:00.004+02:00

Es kommt zwar selten vor, aber hin und wieder betreibe ich meinen Ubuntu-Laptop auch ohne Verbindung zum Internet. Unterwegs - z.B. beim Erste-Hilfe-Einsatz als Computer-Doktor - ist der Zugriff auf die Laptop-Kopie meines Wikis recht nützlich.

Wenn eine Netzwerkverbindung fehlt schaltet Firefox in den Offline-Modus. Auf einen im Laptop laufenden Apache-Server kann so nicht zugegriffen werden.

Natürlich kann man nun mit "Datei - Offline arbeiten" diesen Modus wieder ausschalten. Auf die Dauer nervt diese Zwischenschritt; deshalb hier die Option, wie man ihn umgehen kann:

Mit der Eingabe about:config in der Adresszeile zeigt Firefox seine diversen Konfigurations-Optionen an, die so selten gebraucht werden, dass sich ein eigenes Panel dafür nicht lohnt. Hier sucht man nun nach

toolkit.networkmanager.disable

und setzt die Option auf True.

Man kann sich die Suche erleichtern, wenn man z.B. toolkit als Filterausdruck eingibt.

Hiermit wird Firefox angewiesen den Netzwerkstatus nicht beim Networkmanager zu erfragen und bleibt deshalb immer im Online-Modus. Das als Startseite konfigurierte Wiki wird nun direkt angezeigt.

ng-upnp2mrtg Version 0.2.3 freigegeben

2009-06-06T00:19:00.002+02:00

Das Dienstprogramm ng-upnp2mrtg zur Abfrage von Byte-Countern in UPNP-Routern ist nun in Version 0.2.3 verfügbar.

Neu in dieser Version ist die Option --nowrap

Beim Neuaufbau von Verbindungen (z.B. nach einer Zwangstrennung) setzen Modems häufig die Empfangs- und Sende-Zählerstände auf Null zurück. MRTG interpretiert dies als 32-Bit-Zählerüberlauf, was in der grafischen Darstellung zu einer Spitze führt. Diese lässt sich auch durch andere MRTG-Optionen nicht sicher verhindern.

Wenn diese ng-upnp2mrtg-Option gesetzt ist, werden die Zählerstände vom Skript zwischengespeichert und nach einem Reset als Offset bei allen nachfolgenden Ausgaben hinzuaddiert.

Ohne diese Spitzen kann die Funktion zur automatischen Skalierung wieder richtig arbeiten.

T-Mobile und GnuPG/PGP

2009-05-09T00:17:00.005+02:00

Ab diesem Monat gibt es die Handy-Rechnung nicht mehr auf Papier – natürlich aus Umweltschutzgründen. Wohin die gesparten Druck- und Versandkosten fließen, bleibt ungenannt.

Zu bekommen ist die Rechnung über das T-Mobile-Internet-Portal, aber auch der zusätzliche Versand per E-Mail ist vorgesehen. Diese E-Mail kann sogar mit PGP/GnuPG verschlüsselt werden. Falls der Rechnung noch der Einzelverbindungsnachweis beiliegen soll, ist die Verschlüsselung sogar zwingend vorgeschrieben.

Den Masken zum Einrichten ist eine ausführliche Seite mit Anweisungen vorgeschaltet. Jeder der in der Lage ist, ein GnuPG/PGP-Schlüsselpaar zu generieren, den öffentlichen Schlüssel auszulagern und hochzuladen, wird mit der Beschreibung keine Probleme haben...

Probleme hatte an diesem Tag hingegen der entsprechende Server bei T-Mobile, der den Versuch diese Konfiguration einzurichten mit einem „unbekannten Fehler“ quittierte. Zwar erhielt ich nach dem Einrichten die zugehörige verschlüsselte E-Mail mit der Bestätigung, der darin enthaltene Bestätigungscode wurde aber nicht angenommen. Unterdessen funktioniert aber auch das.

So sehr man T-Mobile für eine der ersten realen Einsatzmöglichkeit für GnuPG/PGP danken möchte, ein weit verbreiteter Einsatz ist nicht zuletzt wegen des umständlichen Verfahrens unwahrscheinlich.

UPnP – Entdeckungsreise... zu Fuß

2009-04-20T14:19:00.009+02:00

Für die im Folgenden beschrieben Abläufe gibt es sicher spezialisierte Programme. Das Ziel war aber ein kurzes Skript, das von mrtg aufgerufen werden soll. Hierzu ist nur die Kenntnis einer Handvoll Strings notwendig, die in das Skript integriert werden müssen.

Auch will ich hier nicht das UPnP-Protokoll vollständig wiedergeben. Vielmehr werden nur die Teile vorgestellt, die zur Abfrage von Werten (z.B. der Anzahl der übertragenen Bytes) benötigt werden.

Mit diesen Kenntnissen sollte sich ng-upnp2mrtg eigentlich an alle UPnP-Modems, die die UPnP-Abfrage unterstützen anpassen lassen.

Die eigentliche Abfrage

Nachdem eine TCP-Verbindung zum UPnP-Server im Modem aufgebaut ist, erfolgt die Kommunikation nach dem HTTP-Protokoll.

Schauen wir uns eine typische Abfrage an.

Der Client sendet:

POST /WANCommonInterfaceConfigService/control HTTP/1.0
HOST: 192.168.0.1:49300
CONTENT-LENGTH: 340
CONTENT-TYPE: text/xml; charset="utf-8"
SOAPACTION: "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1#GetTotalBytesReceived"

<?xml version="1.0"?>
<s:Envelope
xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"
s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<s:Body>
<u:GetTotalBytesReceived xmlns:u="urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1">
</u:GetTotalBytesReceived>
</s:Body>
</s:Envelope>

Die erste Zeile ist ein HTTP-Befehl (eine Methode, gefolgt von einer URL, gefolgt von der Protokollversion).
Ihr folgen einige Header-Zeilen in der Form 'Schlüssel: Wert'.
Eine Leerzeile trennt den Header von der eigentlichen Nachricht.
Diese liegt im XML-Format vor (SOAP).

Die interessanten variablen Teile sind fett dargestellt. Dies sind zum einen die URL in der ersten Zeile, und in der Zeile SOAPACTION den – nennen wir ihn – Dienstbezeichner (vor dem #-Zeichen mit 'urn:schemas-upnp.org' beginnend) und die darauf anzuwendende Aktion (hinter dem #).

Natürlich müssen auch die Werte für HOST und CONTENT-LENGTH angepasst werden. Sie haben die im HTTP-Protokoll definierten Bedeutungen und sind selbsterklärend.

Die variablen Teile in der XML-Nachricht kennen wir schon aus dem Header.

In der gleich TCP-Verbindung liefert der Server seine Antwort. Hier wieder ein typisches Beispiel:

HTTP/1.1 200 OK
EXT:
CONTENT-TYPE: text/xml; charset="utf-8"
SERVER: IAD, UPnP/1.0, MicroStack v1.0.2777

<?xml version="1.0" encoding="utf-8"?>
<s:Envelope s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"       xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
<s:Body>
<u:GetStatusInfoResponse xmlns:u="urn:schemas-upnp-org:service:WANIPConnection:1">
  <NewConnectionStatus>Connected</NewConnectionStatus>
  <NewLastConnectionError>ERROR_NONE</NewLastConnectionError>
  <NewUptime>30864</NewUptime>
</u:GetStatusInfoResponse>
</s:Body>
</s:Envelope>

Man erkennt eine Standard-HTTP-Antwort, mit dem HTTP-Ergebniscode in Zeile 1, weitere Headerzeilen, die unvermeidliche Leerzeile, gefolgt von Text, wieder im XML-Format. Im <u>-Tag selbst findet man wieder die Werte für Aktion und Dienst-Bezeichner. Der <u>-Tag umschließt die gewünschten Information, die ihrerseits von <tag> ...</tag> eingeschlossen sind.

Der Ergebniscode hat die bei HTTP definierte Bedeutung – kurz gesagt: 200 ist ok, bei allen anderen Werten muss man nachforschen.

Um also eine bestimmte Information abzufragen braucht man:

IP-Adresse und Port-Nummer des UPnP-Servers
die URL
den Bezeichner für den Dienst bzw. das Gerät und die Aktion
sowie den Namen des Tags, in dem in der Antwort die gewünschte Information steht.

Die IP-Adresse ist meist mit der des Routers identisch, doch spätestens bei der Port-Nummer wird es schwierig. So verwendet die FritzBox Port 49000, das NetCologne-Modem hingegen Port 49300.

Der Weg in den Router

Glücklicherweise werden diese Informationen – und noch einige mehr – vom UPnP-Server per UDP-Broadcast verbreitet. Standardmäßig wird dieser Broadcast an die IP-Adresse 239.255.255.250. Port 1900 gerichtet. Das Protokoll heißt SSDP (Simple Service Discovery Protocol).

Die Pakete kann man z.B. mit Wireshark auffangen und decodieren. Grenzen Sie ggf. die Anzeige mit 'ip.addr == a.b.c.d' auf die IP des Routers ein.

Lassen Sie sich Zeit. Es kann einige Minuten dauern, bis die ersten SSDP-Pakete angezeigt werden. Untersuchen Sie den Text-Inhalt. Nach einiger Zeit wird dieser sich wiederholen, Sie sollten aber mehrere unterschiedliche Pakete finden.

Hier der Textinhalt eines solchen Pakets

NOTIFY * HTTP/1.1
HOST: 239.255.255.250:1900
LOCATION: http://192.168.0.99:49000/igddesc.xml
SERVER: mynet UPnP/1.0 AVM FRITZ!Box WLAN 3170 49.04.57
CACHE-CONTROL: max-age=1800
NT: urn:schemas-upnp-org:device:InternetGatewayDevice:1
NTS: ssdp:alive
USN: uuid:75802409-bccb-40e7-8e6c-001C4A50656D::urn:schemas-upnp-org:device:InternetGatewayDevice:1

Auch hier erkennt man wieder die HTTP-Struktur: eine Methode (NOTIFY), eine URL (*) (naja) und die Protokollversion, gefolgt von UPnP-Headern, die diverse nützliche Informationen enthalten.

LOCATION: eine URL mit einer XML-Datei, die die Dienste weiter beschreibt.
NT: den „Dienst-Bezeichner“
NTS: ssdp:alive = das Geräte meldet sich an; ssdp:byebye = das Gerät meldet sich ab
USN: nochmal der Name des Diensts, diesmal mit einer eindeutigen ID, die von Gerät zu Gerät unterschiedlich ist, auch wenn die Dienstnamen identisch sind.

Tell me more...

Der nächste Schritt ist, die URL aus LOCATION in den Browser einzugeben. Ergebnis ist eine weitere XML-Datei. (Wenn Sie hierzu Firefox verwenden, wird die Datei übersichtlich formatiert dargestellt.) Interessant sind die Einträge unter <serviceList>, die an mehreren Stellen und in unterschiedlichen Ebenen im XML-Baum auftreten können:

Hier ein Beispiel:

...
<serviceList>
<service>
<serviceType>urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1</serviceType>
<serviceId>urn:upnp-org:serviceId:WANCommonIFC1</serviceId>
<SCPDURL>WANCommonInterfaceConfigService/scpd.xml</SCPDURL>
<controlURL>WANCommonInterfaceConfigService/control</controlURL>
...
</service>
...
</serviceList>

Unterhalb von <serviceList> findet man diverse Dienste mit <service> aufgelistet.

Der <serviceType> ist der Dienst-Bezeichner, den wir in der UPnP-Abfrage brauchen.
Die <controlURL> ist die URL für die UPnP-Abfrage (ohne vorangestellten Backslash).
<SCPDURL> verweist auf eine weitere XML-Datei, die die Aktionen näher beschreibt.

Stellen Sie der <SCPDURL> 'http://IP-Adresse:Port/' voran und geben Sie sie im Browser ein.

In dieser XML-Datei findet sich unter <actionList> ein oder mehrere Einträge <action>. Eine Ebene tiefer finden sich <name> und die <argumentList> mit einem oder mehreren <argument> Einträgen. Und bei <argument> interessieren wir uns vor allem für <name> und <direction>.

Prinzipieller Aufbau:

<scpd>
...
<actionList>
<action>
 <name>Name_der_Aktion</name>
 <argumentList>
  <argument>
   <name>ArgumentName_1</name>
   <direction>in</direction>
  </argument>
  <argument>
   <name>ArgumentName_2</name>
   <direction>out</direction>
  </argument>
...
 </argumentList>
</action>
...
</actionList>
</scpd>

Die Namen der Tags sind selbsterklärend. Interessant für eine Abfrage sind natürlich nur die Aktionen mit der <direction> out.

Der Name der <action> ist der Aktionsname für unsere Abfrage.
Der Name bei <argument> ist der Name des Tags bei der Antwort, der den entsprechenden Wert einklammert.

Somit hätten wir also alle Informationen zusammen, die wir für die Abfrage brauchen.

Zum Abschluss

Die Stellen in ng-upnp2mrtg, an denen diese Werte eingetragen werden müssen, sind im Quelltext einfach zu finden.
Die Byte-Counter befinden sich meist in einer Aktion, die als Antwort die Tags „NewTotalBytesReceived“ und „NewTotalBytesReceived“ zurück gibt. Für die Verbindungsdauer sucht man am besten nach „NewUpTime“. Alle Werte werden bei einem Verbindungsaufbau zurückgesetzt, was bei MRTG leider einen Spike erzeugt.

ng-upnp2mrtg nun auf SourceForge

2009-04-15T23:42:00.002+02:00

Das Projekt ng-upnp2mrtg wird ab heute auf SourceForge gehosted.

Neuere Versionen sind künftig dort erhältlich.

NetCologne Premium-Modem und die Statusabfrage via UPnP

2009-04-02T23:08:00.010+02:00

Sysadmins lieben schöne Bilder. Durch die grafische Darstellung des zeitlichen Verlaufs von Systemvariablen wie dem Durchsatz einer Internet-Verbindung oder der Temperaturen von Festplatten, fallen Veränderungen gegenüber der Norm meist recht schnell auf.

Ein dafür sehr gern eingesetztes Werkzeug ist das Round Robin Database Tool (RRDtool) von Tobias Oetiker und der speziell für den Einsatz in Netzwerken angepasste Multi Router Traffic Grapher MRTG vom gleichen Author.

MRTG beherrscht SNMP, das Protokoll mit dem sich bei industriell eingesetzten Netzwerkgeräten Statusmeldungen, wie eben die übertragene Datenmenge, abfragen lassen. Router für Endkunden besitzen diese Option meist nicht. Dafür beherrschen diese zunehmend UPnP (Universal Plug and Play). Dieser Standard wurde entwickelt, damit z.B. die Internet-fähige Stereoanlage den Internet-Router für ihre Bedürfnissen konfigurieren kann.

Was die Internet-fähige Stereoanlage kann, können aber auch Schadprogramme, die den Router dann z.B. so programmieren können, dass der Rechner direkt von außen erreichbar wird. Deshalb ist diese Option bei den meisten sicherheitsbewussten Anwendern ausgeschaltet.

Neben der Programmierung eines Routers sieht UPnP aber auch die Möglichkeit der Statusabfrage vor. Leider kann MRTG Daten nicht direkt über UPnP abfragen. In der Konfigurationsdatei /etc/mrtg.cfg kann jedoch unter Target[XXX] statt einer SNMP-OID ein Programm angegeben werden, das von MRTG aufgerufen wird, um die Daten zu ermitteln und an MRTG weiterzureichen (siehe auch „man mrtg-reference“). Für die weit verbreiteten Router der Marke FritzBox kommt hier meist upnp2mrtg zum Einsatz.

Vorbereitungen beim NetCologne-Router Premium

Bei diesem NetCologne-Router kann im Expertenmodus über „Sicherheit – UPnP“ getrennt eingestellt werden, ob UPnP zur Programmierung von Portweiterleitungen und/oder (nur) zur Statusabfrage eingesetzt wird. Hier muss die UPnP-Abfrage freigeschaltet (und die UPnP-Steuerung sollte aus den oben genannten Gründe deaktiviert) werden.

Bei gleicher Gelegenheit sollte man mit „System – Zugangsschutz“ ein Passwort für die Web-Schnittstelle definieren – standardmäßig ist leider kein Passwort definiert.

Probleme bei der Abfrage mit upnp2mrtg

Leider schlägt der Aufruf von upnp2mrtg fehl. Die Standardwerte für HOST („firtz.box“) und PORT (49000) passen nicht zur NetCologne-Box.

Der HOST beim NetCologne-Router heißt „netconnect.box“ (oder man verwendet die entsprechende IP-Adresse, standardmäßig wird „192.168.0.1“ verwendet).
Port 49000 ist beim NetCologne-Router jedoch geschlossen. Ein Port-Scan zeigt, dass Port 49300 offen ist (dieser Wert liegt zumindest in der Nähe von 49000).
Jeses UPnP-Gerät sendet aber auch sog. SSDP-Notify-Pakete, um sich bekannt zu machen. Mit Wireshark können diese Pakete aufgezeichnet und analysiert werden:

Der Inhalt dieser Pakete bestätigt Port 49300 als UPnP-Port. Aber der entsprechend modifizierte Aufruf von upnp2mrtg:

sudo upnp2mrtg -a netconnect.box -p 49300

liefert kein Ergebnis.

Der Grund hierfür – so fand ich bei der Programmierung des Tools ng-upnp2mrtg heraus – liegt darin, dass der NetCologne-Router auf CR LF als Zeilenende-Zeichen besteht – die FritzBox begnügt sich auch mit dem Unix-Standardwert LF.

Unterschiede ng-upnp2mrtg.py / upnp2mrtg

upnp2mrtg ist ein Bash-Script, während ng-upnp2mrtg.py ein Python-Script ist. Python ist heutzutage auf jedem Linux-System standardmäßig installiert. Das ng-Script ist genügsam und nutzt nur die Python-Standardbibliotheken.

Wie in einem der nächsten Blog-Postings gezeigt braucht man zur Abfrage eines bestimmten Router-Werts nur vier Parameter. Diese scheinen sich von Router zu Router geringfügig zu unterscheiden. Hat man diese Information erst einmal ermittelt, lässt sich das Python-Programm leicht an andere Geräte anpassen. Sollten Sie das Programm mit anderen Router-Typen erfolgreich einsetzen, lassen Sie es mich wissen.

Die jetzige Version des Skripts ng-upnp2mrtg enthält neben den Parametern für den NetCologne-Router auch die für eine Fritzbox. Mangels Internetverbindung über eine FritzBox kann ich sie leider nicht testen. Die Auswahl erfolgt zurzeit noch durch ein- und auskommentieren am Ende des Skripts.

ng-upnp2mrtg - Was Sie brauchen

mrtg: Dieses Programm sollte über die Repositories Ihrer Distribution erhältlich sein. Ansonsten finden Sie es hier.

ng-upnp2mrtg.py: Das Skript läuft unter Python, was heute auf jedem Linux-System installiert sein sollte, und braucht keine besonderen Bibliotheken. Im Augenblick ist es hier abrufbar.

mrtg.cfg: Konfigurationsdatei für mrtg angepasst an ng-upnp2mrtg.py, Im Augenblick hier zu bekommen.

Ich werde versuchen das Skript bei einem der OpenSource-Projekt-Sites als Projekt anzumelden. Die Dateien und neuere Versionen werden dann dort abrufbar sein.

Installation von ng-upnp2mrtg

Für die folgenden Schritte brauchen Sie Root-Rechte:

Passen Sie oben im Skript ng-upnp2mrtg.py die Variablen HOST und PORT an.
Kopieren Sie das Skript nach /usr/local/bin und machen Sie es ausführbar
Die Konfigurationsdatei mrtg.cfg kommt nach /etc.

cp -a ng-upnp2mrtg.py /usr/local/bin
chmod 755 /usr/local/bin/ng-upnp2mrtg.py
cp -a mrtg.cfg /etc

Für den regelmäßige Aufruf von mrtg sorgt der folgende crontab-Eintrag:

0-59/5 * * * * env LANG=C /usr/bin/mrtg --logging /var/log/mrtg.log

Das Ganze wurde getestet mit Ubuntu 8.04, mrtg 2.14.7, Python 2.5.2.
Schwierigkeiten bei der Übernahme auf andere System sind eigentlich nicht zu erwarten... aber das sagt man ja vorher immer.

Debian's OpenSSL-Lücke – die nächste Stufe

2009-02-22T21:06:00.003+01:00

Joshua Wright beschreibt die Dekodierung SSL-verschlüsselter Kommunikation.

Die Debian OpenSSL-Schwachstelle hatte Anfang 2008 im IT-Sektor für große Aufregung gesorgt. Ein Patch war bei der Linux-Distribution Debian dafür verantwortlich, dass die entsprechenden Systeme fast eineinhalb Jahre lang Schlüsselpaare nur aus einem sehr überschaubaren Pool ausgaben. Diese Schlüssel kommen u.a. bei der Verschlüsselung von Web-Kommunikation (https:) zum Einsatz.

Auch wenn die meisten Systeme mittlerweile aktualisiert sein dürften, bestand und besteht die weitere Aufgabe darin, keines der von diesen Systemen erzeugten schwachen Schlüsselpaare auf einem aktiven Webserver zu vergessen.

Die „verhältnismäßig“ geringe Anzahl möglicher Schlüsselpaare erlaubt es, diese vorauszuberechnen, und einen Surfer zu warnen, wenn ein solcher Schlüssel von einer Website verwendet wird. Eine entsprechende Erweiterung steht für Firefox-Benutzer schon seit längerem zur Verfügung.

Joshua Wright beschreibt nun, wie der Inhalt einer mitgeschnittenen verschlüsselten SSL-Verbindung wieder dekodiert werden kann, wenn derart schwache Schlüssel zum Einsatz kamen.

Es ist zu hoffen, dass nicht allzu viele Verbindungen mitgeschnitten wurden, in der Hoffnung sie irgendwann einmal dekodieren zu können.

Touch Me, Tux

2009-02-21T00:41:00.000+01:00

Das Technaxx TOUCHME ist ein portabler Multimedia-Player mit einem 2,8“ Farb-Touchscreen. Es kann Audio (MP3, WMA), Video (MPEG4 AVI) und Bilder (JPG, BMP) wiedergeben.

Es hat eine USB 2.0-Schnittstelle und ist mit einer MicroSD-Karte erweiterbar.

Der Hauptbildschirm ist dem Handy einer bekannten amerikanischen Firma nachempfunden. Die Icons sind jedoch statisch und auch sonst kommt die Benutzerführung nicht an das Vorbild heran.

Mit Linux lässt sich das Gerät aber hervorragend betreiben.

Es meldet sich als normaler USB-Massenspeicher an, und man kann die Dateien in der gewohnten Art und Weise kopieren und löschen. Kein DRM, nur Formate, die man unter Linux auch erstellen kann.

Das mitgelieferte “Konvertierungs-Tool“ ist natürlich ein Windows-Programm. Ein Blick mit dem Hex-Editor auf die damit erzeugten Dateien zeigt, dass diese mit mencoder erstellt wurden, ein unter Linux weit verbreiteter Open-Source-Videokonverter.

Das Windows-Konvertierungs-Tool ist also nichts anderes als eine GUI für mencoder.

Schnell ein kleines Windowsprogramm geschrieben, dessen Aufgabe es war, die Aufrufparameter anzeigen, und dem Konvertierungs-Tool anstatt mencoder untergeschoben, schon standen die Parameter fest:

mencoder -noodml INPUTFILE -of avi -o OUTPUTFILE -ofps 20 -vf-add scale=SCALEX:SCALEY -vf-add expand=320:240:-1:-1:1 -srate 44100 -ovc xvid -xvidencopts bitrate=VIDEOBITRATE:max_bframes=0:quant_type=h263:me_quality=4 -oac lavc -lavcopts acodec=mp2:abitrate=AUDIOBITRATE

Je nach gewünschter Qualität für VIDEOBITRATE die Werte 450, 500 oder 600 und für AUDIOBITRATE die Werte 64 oder 128 einsetzen.

SCALEX und SCALEY sind die Höhe und Breite in Pixel, auf die das Video herunter gerechnet werden muss, um unverzerrt angezeigt zu werden. Bei 4:3-Material sind das 320:240, bei 16:9 muss hier 320:180 eingesetzt werden („expand“ fügt dann die schwarzen Ränder hinzu).

Die erzeugte Datei muss einen Stereo-Track enthalten. Andernfalls kommt es bei der Wiedergabe zu seltsamen Effekten.

Ich kodiere jetzt schon seit längerer Zeit mit diesen Parametern erfolgreich kleine Clips z.B. von YouTube für den Player. Längere Videos sind zwar auch möglich, die prellenden Vor- und Rückspultasten (On-Screen) machen die Wiedergabe aber zur Geduldsprobe.

Podcasts kann man mit dem Player natürlich auch wiedergeben. Der Player merkt sich beim Ausschalten aber leider nicht, an welcher Stelle man war. Für Songs also geeignet, für längere Audiodateien leider nicht.

Bilder sollte man vorher skalieren. Der Player kann das zwar auch, nimmt sich aber Zeit dafür.

Ich habe diesen Player vor über einem Jahr bei einer Supermarktkette erworben. Wenn Geräte bereits dort verkauft werden, zerschlagen sich jegliche Hoffnung auf Updates – Schade.