Keep your data to yourself!

Clipperz Community Edition is a community driven, free and anonymous online password manager based on on the Open Source Javascript Crypto Library. Clipperz is an online service so you can access your passwords from everywhere. Your data is stored decrypted on a server and will be encrypted locally within your browser using your personal passphrase. This ensures that only you can access your data! The Clipperz Community Edition is Open Source, so you can browse the code and see what is going on or you can event host your own Clipperz Community Edition. This is a huge profit since there is no third party involved! If you are interested in hosting your own Clipperz Community Edition backend, refer to the building and installing steps at GitHub.

Clipperz Integration

Because of Clipperz is a javascript application running as a webpage within your browser, it does not integrate well into your daily process. Before you can proceed an authentication process, you have to login to Clipperz, look for the corresponding password entry and copy & paste your username and password. Clipperz introduces some tools where you can easily create so called direct logins using a javascript bookmarklet. Since this is very inconvenient and time consuming I decided to write a Firefox Addon with some beneficial features:

• Integrates Clipperz into the Mozilla Firefox browser, no need to open the Clipperz Community Edition webpage.
• Automatically fills in your username and password for any registered direct login.
• Provides easy access to add, modify or delete a direct login of the currently active webpage.
• Integrates a password generator into the Firefox browser.
• Enables auto-login for Clipperz webpage and widget if activated.
• Connects either to the public Clipperz portal or to a third party hosted Clipperz Community Edition.
• Hopefully opens the way to even more features …

Be Careful!

Next to those benefits, you should notice the possible drawbacks. More features and the browser integration might degrade protection and security of your data stored by Clipperz:

• The auto-login is really comfortable but it is  an open door to your Clipperz account! Enabling your auto-login means that everybody who can access your browser can also access your data stored within Clipperz! You can disable the auto-login in the widget’s preferences. In this case, you will be prompted for your username and password the first time you start your browser.
• Both, the widget and the Clipperz webpage are designed to encrypt your data on-demand. That means, only if you request a password, the decrypted data will be downloaded and encrypted locally using  your passphrase. The Clipperz addon initially downloads and encrypts the URLs of  each of your registered direct logins in oder to match a webpage, your stored a direct login for. If an appropriate webpage was found, the data of this direct login will also be downloaded, encrypted and automatically pasted into the according username and password fields. It is unlikely that the addon matches a wrong webpage, but I will not guarantee, that this could be harmfully used for an exploit or anything else.
• In any case, you should notice that you degraded the level of data security Clipperz provides, if using this service in a traditional way. I assume no responsibility and liability for any damage, data loss or data thievery. Please use the Clipperz Firefox addon at your own risk!

Screenshots

Get Involved!

The Clipperz project is an awesome and pretty useful Open Source project from which everyone can profit! Most parts of this Firefox addon are based on the sources of the Clipperz community edition. So don’t forget to support those guys doing such a great work! I would also highly appreciate each kind of support to further improve the Clipperz addon. Like the Clipperz Community Edition, the addon is released under the AGPL. Feel free to give your feedback, add issues or access the code at github.

Download the Firefox Addon

The latest release of the Mozilla Firefox Addon can be downloaded here. Note that this project is under ongoing development. If you want to checkout the latest features, you might want to refer to github.

Before I start, let me say a few words about the background and about my experience with current service providers, which really drive me nuts! A few days ago, I wanted to install the latest WordPress updates and was confused when the WordPress 3.2.1 update failed because of not supporting MySQL 4 anymore. I checked the version of the MySQL server and figured out that my current hosting provider Server4You still has MySQL 4 installed on my web hosting server. So I asked them to update the MySQL server software to a current stable release. Unfortunately they told me that they can’t update the server since this would bring another huge amount of updates. I don’t think that any distribution still offers long term support for MySQL 4 – correct me if I’m wrong. This is why I decided to rent a vServer from Strato.

As I said, I followed the guide from the Gentoo wiki in order to replace the pre-installed Ubuntu with my favorite Gentoo distribution. Since Baselayout 2 and OpenRC, Gentoo supports the boot process in an OpenVZ container out of the box. Thus creating a Gentoo container is as easy as getting the latest stage3 and changing some configuration files. I also found a script which expects a stage3 archive and creates another archive which is ready to be started as an OpenVZ container. I found that script after I did all by hand, so I’ve not tested the script.

Nevertheless, the guide and I guess also the gentoovz script cannot manage the whole configuration and some parts are missing which have to be be done manually. I experienced some trouble with the device naming support udev. Fortunately, I enabled the OpenRC logger in /etc/rc.conf:

This will make OpenRC to log the boot process into /var/log/rc.log. After switching back into recovery mode, I found the following in the OpenRC log:

It seems that udev-mount did not start because the mount operation is not supported within the OpenVZ container and thus, the boot process stopped. Since we don’t need udev anyways, uninstalling this service was the fastest solution:

The most time consuming part was in fact the network configuration. I found several other guides mainly based on this blog where the system configuration is described briefly. Further they figure out their static IP address which is obviously the external IP address of the vServer and a gateway IP address for the default route. Seems to be easy, but it seems that Strato has changed their OpenVZ networking and do not offer any gateway IP address anymore:

Further more confusing was the network setup of the rescue system and the pre-configured Ubuntu on the vServer. The virtual interface venet0 which is created by OpenVZ as a point-to-point connection between the host and the guest system has had the address of the loop back device 127.0.0.1/32 – you noticed the netmask? Further there was an alias venet0.0 of the virtual interface which was configured with my static IP address. Obviously this was kind of OpenVZ magic which makes troubleshooting really difficult. It turned out that one do not need the venet0.0 alias and it is fine to configure venet0 with the external IP address where the vServer should be reachable:

Since I don’t find any configured default gateways on the previously installed system and also not on the rescue system, I gave it a try and exit the rescue system and started the booting of my Gentoo container via the Strato web interface. Of course, I could not reach the server neither with ping nor with ssh. So I’m not the best in networking but that has shown that I have to set any routing information. I remember that once I used pppoe, I also had to define a default route without a gateway IP address:

The question is how to configure that default route in /etc/rc.conf. It seems that this is really difficult to find if you have only networking basics. Google always brought me to Gentoo’s handbook where they describe how to set the default route with a default gateway IP! I also asked in Gentoo’s IRC where they did not even believe that this is my network configuration which is in fact working in the rescue system. One of these guys called me a “Troll” and I also felt like one – but that guy did not know the answer either. So trial and error gave me that:

Note the line break after “scope link” which turned out to be essential. Adding the remaining parts from the howtos I finally got my networking configuration working:

After re-building the kernel, we wondered why the module rndis_host was missing, which is required to recognize the USB ethernet device. After searching the kernel configuration we find out, that another option must enabled to compile this module:

We now can modprobe the rndis host module which also loads the dependent modules:

We were using the Google Nexus One with CyanogenMod-7.1.0-RC1-N1 and Android version 2.3.4. After attaching the device and enabling USB tethering, we got the following dmesg:

We expected a new USB ethernet device usb0 but got a bad cdc descriptor error instead. Googling the issue leads us to a wrong way: We found lots of posts and bug entries which indicates kernel bugs e.g. with non-unique USB id’s or even a not-working Cyanogenmod. Fortunately that does not apply to our issue since we have to enable another kernel setting to fix it:

After re-bulding the kernel, we got the following when attaching the N1 and enabling USB tethering:

We now can run ifconfig or dhcpcd in order to configure the new ethernet device to establish a network connection:

Because the face authentication it is based on OpenCV, we need to install this library first. Fortunately, it’s located in portage:

Next, we need to download and extract the sources for the face authentication pam:

We can use cmake to build the source and install the binaries:

Next, the pam module must be configured to be use for system authentication:

As you see, I configured pam_face_authentication.so right after the traditional login using password. By doing so, first the user is asked to type a password. If this authentication has failed (or the user just hit enter), it is tried to recognize the face. If this has failed, the user is asked for finger print, which is described in an earlier post.

After this steps, we can train the faces for each user:

In order to enable face recognition authentication for the root user i.e. su and sudo, we have to run qt-facetrainer as root:

That’s it. The face recognition is now enabled as fallback method for authentication in any pam based service i.e. gdm/xdm and gnome-screensaver. Please note that this authentication method can be easily circumvented. The qt-facetrainer offers some advanced settings to configure the tradeoff between security and recognition performance in order to avoid false-positives. But one could simply use a photo of the corresponding user in order to grant access to the system. I did not try that, but please keep that in mind.

In any case, this method should neither be used in security critical systems nor it should be used as a required pam method, because different illumination seems also to be a problem so that under bad circumstances, the face cannot be recognized correctly.

So we just have to unbind those devices:

Note that your USB attached devices will stop working until you re-bind them:

You can put the stuff together in a scriptlet to do an unbind before suspend and a re-bind on resume:

To install the scriptlet just create a file in /etc/hibernate/scriptlets.d and define a device list e.g. in /etc/hibernate/common.conf:

Unforunately the aproach above did not work. Some USB devices seems to be still active and refused to suspend. Since I do not really have any USB 3.0 device, I decided to disable USB 3.0 until I get the above approach working:

With this kernel configuration, we get suspend to disk working. But resuming the systems brings another problem with NVidia drivers 260.19.21 (64bit): The resumed system was either extremely slow or we just got a white screen. In both cases, restarting X fixed the problem but this is obviously not a solution. I found some information about a bug using NVidia’s TwinView together with hibernation. Following the proposed workaround, I enabled the NvAGP driver option:

And prevent the kernel from loading intel_agp module. Either by adding the following line to the modprobe blacklist:

Or you just make sure that the modules is neither build-in nor compiled as module in the current kernel configuration.

Before we start, we have to make sure that the fingerprint read is recognized correctly. On the W510, the fingerprint reader is recognized as USB input device:

If there is no appropriate device id, there might be something wrong with the kernel USB configuration. Refer to Gentoo on a Lenovo Thinkpad W510 and make sure, the USB configuration works fine.

Further we installed the corresponding Gentoo packages from portage.

Note that libfprint is required by fprintd, hence you must not explicit install that package. But it might be that the packages are masked as unstable and you have to unmask them:

Finally we start recording fingerprints using fprintd-enroll:

Note that we got some problems when we tried to envroll the fingerprint as non-root user:

We fixed that by editing /usr/share/polkit-1/actions/net.reactivated.fprint.device.policy where we allow action id net.reactivated.fprint.device.verify and net.reactivated.fprint.device.enroll for any user and not only for the active one. There might be a bug in sys-auth/consolekit but we did not yet have time to work on that and hence are using that workaround.

Finally, we modified /etc/pam.d/system-auth configuration in order to use the fingerprint mechanism:

Thank to the Dbus integration, there are no further needs to enable the fingerprint reader in e.g. the gnome screensaver (gnome-screensaver) or the gnome display manager (gdm) – that stuff works just out of the box:

Related Posts

Lenovo W510 Integrated Webcam & Face Authentication
Lenovo W510 Fingerprint Reader & Gnome Integration
Suspend2 on Thinkpad W510
Debian GNU/Linux on the Thinkpad W510
Find more manuals for Linux on IBM/Lenovo Laptops on tuxmobile.org

Hardware

• Intel(R) Core(TM) i7 CPU Q 720 @ 1.60GHz

• 1x 4 GB DDR3 RAM
• 128 GB SATA Solid State Disk (Linux System, Linux Swap ~5 GB, Windows NTFS)
• 500 GB SATA Hard Disk
• Nvidia Quadro FX880M
• Intel Corporation 82577LM Gigabit Network Connection
• Intel Corporation WiFi Link 6000 Series

Details

64 Bit Architecture

The laptop comes with the Intel i7 720 QM processor which is a real quad core processor providing 8 cores (4 * 2 due to hyperthreading). Since we have “only” 4 GB of DDR3 memory, there would be no further needs for a 64 bit arch! But we have the option to add another 4 GB of RAM where a 64 bit arch would make sense.

The correct arch is not IA-64 which is for Itanium processors, a series of 64-bit Intel microprocessors. What we have to use is Intel’s x86-64 arch which first specs came from AMD and hence is known as AMD64.

Installing Gentoo Base

For system setup, we followed the steps in the Gentoo Quickinstall Guide. For any issues, read below!

Booting & Ext4 Filesystem

We decide to use ext4 filesystem but we ran into trouble (got stupid beginner – you forgot to compile for boot fs driver into the kernel – panic) when we tried to boot from that ext4 partition using Grub 0.97. Following the ext4.wiki.kernel.org, at least Grub2 1.97 is required for doing so. That’s the reason we gave Grub2 a chance and set it up following Gentoo’s Grub2 Wiki.

If you are chrooted from the Gentoo live CD you probably will get the warning “Cannot find list of partitions” when invoking “grub-mkconfig -o /boot/grub/grub.cfg”. Any Windows installation won’t be found in that case. That’s fine as long you linux was found correctly. Just re-run “grub-mkconfig -o /boot/grub/grub.cfg” when you get your system up. Without chrooting, os-prober will work properly.

If you cannot load the kernel, because the root (/dev/sd*) was not found, check whether you have enabled Intel PATA/SATA support at:

Don’t enable PATA/SATA support as module since like the filesystem driver, this is required before any module is loaded.

Human Beeings Grub2 Howto

USE Flags

We found the following at the Gentoo development guide:

Modern x86 processors support special instruction sets like mmx, sse, SSE2 and 3DNow! AMD64 also provides support for them, but in most cases, x86 assembler code is incompatible with AMD64 assembler. There are lots of packages that provide support through USE flags for these instruction sets. Originally, the USE flags were introduced to keep support for older processors such as the Pentium I that can’t handle such code. Currently, all AMD64s support the same combination of extended instruction sets, so there is no reason to make use of the mentioned USE flags. That’s why these USE flags are hard-masked in all AMD64-profiles. This doesn’t mean we don’t support the extensions themselves, instead, we hard-enable them.

So we just ignored the following use flags:

• mmx
• mmx2
• sse
• sse2
• 3dnow
• 3dnowext

Further we defined the following use flags in make.conf:

C Flags

Fortunately, the Gentoo people made their thoughts about Safe CFlags.

Following their advice, I use the following cflags for my 64 bit profile (amd64) and >= GCC 4.3:

Kernel Configuration

We are using latest sys-kernel/tuxonice-sources which is the latest kernel 2.6.34 patched with tuxonice stuff to enable enhaced suspend. We started from scratch and we’ve chosen kernel options from which we thought that they were required. Further we partly follow the configuration which was linked by numerical analysis team on their website.

Specific things which might be useful:

• For USB 3.0 support:
  Device Drivers
      [*] USB support
          [*]  xHCI HCD
• For smart card reader to work properly:
  Device Drivers
      [M] MMC/SD/SDIO card support
          [M]   Secure Digital Host Controller Interface support
• For integrated webcam, enable options for uvcvideo.
• The correct kernel module for Intel Corporatio 82577LM Gigabit Network Connection (e1000e) and for Intel Corporation WiFi Link 6000 Series (iwlagn):
  Device Drivers
      [*] Network device support
          [*] Ethernet (1000 Mbit)
              [M] Intel(R) PRO/1000 PCI-Express Gigabit Ethernet support
          [*]  Wireless LAN
              [M] Intel Wireless Wifi
              [M] Intel Wireless WiFi Next Gen AGN (iwlagn)
• According processor type and features:
  Processor type and features
      [*] ScaleMP vSMP
      (8) Maximum number of CPUs
      [*] SMT (Hyperthreading) scheduler support
      [*] Multi-core scheduler support
      Processor family (Core 2/newer Xeon)
• Thinkpad specific drivers:
  Device Drivers
      [*] X86 Platform Specific Device Drivers
          [*] ThinkPad ACPI Laptop Extras
              [*] Allow control of important LEDs (unsafe)
              [*] Video output control support
              [*] Support NVRAM polling for hot keys

Our latest running kernel configuration can be found here.

X Server

Further followed Gentoo X Server Configuration Howto to setup the X server, framebuffer and the nouveau driver. This guide is using hal which “makes” the x server working out-of-the-box without any configuration file.

First try results in:

Following this, nouveau_dri.so is in development and not supported. In order to get rid of that warning, we have to disable AIGLX in the xorg configuration.

Second try started my login manager but without mouse and keyboard. I double checked whether synaptics and evdev is configured properly:

While looking for some troubleshooting docs, we found the Gentoo Xorg 1.8 Upgrade Guide which stated that since Xorg 1.8 hal is deprecated and replaced by udev. So to not troubleshooting the deprecated hal, we decided to upgrade to current unstable xorg server. We emerged =x11-base/xorg-server-1.9.0-r2 with the newly introduced udev USE flag and all peripherals worked!

Nvidia & Compiz

We want to use compiz-fusion and we tried the unstable nouveau 3D acceleration following the Gentoo Wiki. Starting x server worked properly, but when we started compiz-manager to initialize the compiz stuff, things went wrong and we did not get compiz running. This is why we use the proprietary x11-drivers/nvidia-drivers which results in additional problems:

• Dots per inch (dpi) value could not be determined correctly which ends up in huge font-sizes
  It seems that the nvidia-driver calculates the dpi in a different way than the nouveau driver does. Anyways, we adjusted the font sizes in gnome to fix that.
• Following Gentoo Nvidia Guide, the in kernel drivers conflicts with the proprietary driver – in fact when we installed x11-drivers/nvidia-drivers, the framebuffer support was gone.
  Fortunately, uvesafb is a generic driver and does not program the nvidia card at all (in contrast to the nouveau driver which supports acceleration and stuff). Because uvesafb doesn’t do that we can use both, nvidia proprietary driver for X and uvesafb driver for frambuffer. We followed the uvesafb guide in order to setup uvesafb. Further we used /sys/bus/platform/drivers/uvesafb/uvesafb.0/vbe_modes in order to get supported modes and modified the grub kernel parameter accordingly:
  [2:24] 0 root /root $ cat /etc/default/grub | grep -C2 uvesafb
  # This line imports any entries to the end of the 'linux' line.
  # The entries are appended to the end of the normal mode only.
  GRUB_CMDLINE_LINUX_DEFAULT="video=uvesafb:1280x800-32,mtrr:3,ywrap"
• After starting compiz fusion using compiz-manager we see a white screen.
  In order to fix that, we set the nvidia option AddARGBGLXVisuals to true:
  [2:25] 0 root / $ cat /etc/X11/xorg.conf.d/04-nvidia.conf
  Section "Device"
      Identifier  "Device0"
      Driver  "nvidia"
      VendorName  "NVIDIA Corporation"
      BoardName   "Nvidia Quadro FX880M"
      Option  "AddARGBGLXVisuals" "true"
  EndSection
  
  Section "Extensions"
      Option  "Composite" "enable"
  EndSection

My wrapper uses parts of the Zend framework. If you use Gentoo just let portage do that task: emerge -av dev-php5/ZendFramework.
I’m sure that other distributions also maintain packages for that framework. If not, you’ve to install the Zend Framework by hand like desribed here.

You need at least a running PHP interpreter (here: dev-lang/php-5.2.13).

Import XML

In order to start, connect and login to the Google calendar service:

Before we create an event, we’ve to organize data. This is done by creating xpath mapping between your custom XML and the expected attributes:

As you see, I try to import dates for a national volleyball league. Fortunately they provide some XML exports like the following:

If you are oblivious, just add some reminders:

Finally we can start adding our stuff. This can take several time, so please make sure that you set PHP’s executable environment accordingly:

Sources

You can checkout the latest version from Google code:
svn checkout http://matchimport.googlecode.com/svn/trunk/ matchimport-read-only.
There’s an example script run.php which contains the basic steps to initialize a mass-import.

The source is under Free BDS license, so feel free to modify the code.
Visit the Google code project for more details.

Whenever that error occurred, the server response is empty. In my case, that issue mostly happens in ajax requests where the server response should be some XML snippets. But if the segfault occurs, the XML snippet is empty – the onliest hint I get is the log entry in /var/log/apache/error.log.

First thing I tried is to debug applications using Zend Debugger, but if the debugger was enabled and I step through the application, the error did not happen and the request finishes correctly. Because Google did not lead to an answer, I sat down and tried until I was able to reproduce the error with a simple PHP script:

First time I called this script via web browser all things are good. But the second time, I get an segmentation fault error in the apache log and the browser just displays nothing. Reason for that is that I try to store the current object in the session variable. When I do this the very first time, it work’s because $_SESSION["MyObject"] is not defined. But for any further call, $_SESSION["MyObject"] is defined with the current object and it will be undefined in order to assign the new value. Thus A::__destruct() is called a second time, where $_SESSION["MyObject"] will be re-defined again. This results in a endless loop and ends up in a segmentation fault of the currently used worker thread of the apache webserver.
Note that in PHP 5.2 (and earlier?), there’s a Bug which causes a segmentation fault whenever a PHP function is called recursively more than a definit times. I tried to reproduced and got a segmentation fault after about 900000 recursions.
To do things right, we should check $_SESSION["MyObject"] whether it contains the current object. Only if $_SESSION["MyObject"] contains another object than the current, we can safely define another value!

Storing objects in session variables brings another issue: The destructor of each object stored in the session is called each time, the current script ends. But the constructor is never called, because the initialized object already exists in the session. In order to avoid the destructor call, I recommend to serialize the object by using serialize() before storing it in the session:

In order to access the serialized object, you should unserialize the object first by using unserialize(). Please note, that no every object property can be serialized and should be handled separately. You can use PHP’s magic methods like __sleep() or __wakeup() to handle those properties.

Back from hell after long I post a workaround for the ondblclick and onclick javascript issue: It’s not possible to define both handlers so that the onclick handler won’t get active on a doubleclick.

A possible workaround is to use a semaphore-like global variable (here: dblclick). This is set to true whenever the doubleclick handler is performed.
Further we delay the single click handler for some miliseconds (here: 250) and check against the dblclick semaphore until continue.

Find sources at code.google.com

The main problem when booting from USB is the following: First of all, the BIOS is setting up its USB drivers to load the kernel into the RAM. After this step, the BIOS makes the kernel booting. When the kernel is booting, it unloads the BIOS USB drivers to load the kernel specific USB drivers. There is some time between unload the BIOS drivers and loading the kernel drivers where no USB driver is active – without an USB driver, the kernel cannot access the root filesystem and panics.

The solution is to delay the kernel boot process until the kernel USB drivers are loaded and the kernel can access the root filesystem. I found the rootdelay boot parameter in my current kernel documentation:

So booting your linux distribution from an USB disk is quiet easy:

• Just append the rootdelay parameter to your boot loader configuration (in my case, this is grub):
  $ cat /boot/grub/grub.cfg
  # 2.6.22-suspend2-r1
  title 2.6.22-suspend2-r1
  root (hd0,1)
  kernel /boot/vmlinuz-2.6.22-suspend2-r1 root=/dev/sdb2 video=vesafb-tng:mtrr,ywrap resume2=swap:/dev/sdb5 rootdelay=5

• When you boot your system from USB, you have to think about changing device names. If your device was at /dev/hda, the USB device will be at /dev/sda. So you have to figure out your USB device name, adjust the fstab configuration and the root kernel parameter in your grub configuration.
• Finally you have to make sure, that you build-in the needed USB drivers into your kernel. So I set the following options in my kernel configuration:
  Device Drivers  --->
       USB support  --->
            < *> Support for Host-side USB
             [*]   USB device filesystem
            < *>   EHCI HCD (USB 2.0) support
             [*]     Full speed ISO transactions (EXPERIMENTAL)
             [*]     Root Hub Transaction Translators (EXPERIMENTAL)
             [*]     Improved Transaction Translator scheduling (EXPERIMENTAL)
            < *>   UHCI HCD (most Intel and VIA) support
            < *> USB Mass Storage support
• It depends on your architecture whether you have to build-in EHCI, OHCI or UHCI. Just use lspci to detect you requirements. In my case I got the following output:
  $ lspci | grep -i UHCI
  00:1d.0 USB Controller: Intel Corporation 82801G (ICH7 Family) USB UHCI #1 (rev 01)
  00:1d.1 USB Controller: Intel Corporation 82801G (ICH7 Family) USB UHCI #2 (rev 01)
  00:1d.2 USB Controller: Intel Corporation 82801G (ICH7 Family) USB UHCI #3 (rev 01)
  00:1d.3 USB Controller: Intel Corporation 82801G (ICH7 Family) USB UHCI #4 (rev 01)
  ws1 linux # lspci | grep -i OHCI
  ws1 linux # lspci | grep -i EHCI
  00:1d.7 USB Controller: Intel Corporation 82801G (ICH7 Family) USB2 EHCI Controller (rev 01)
  ws1 linux #

• -v Verbose execution
• -J Generate Joliet directory records in addition to regular iso9660 file names. (Windows compatibility)
• -r Adapt file mode bits
• -i Defines ouput image

After you created an ISO image, you can burn the image onto CD/DVD using cdrecord

• -v Increment the verbose level
• -eject Eject the CD/DVD after process has finished
• -driveropts=burnfree Turn on support for buffer underrun free writing
• -dao Write your CD/DVD in Disk At Once Mode
• -dev Define the device

That’s it – with increased verbose level, you can watch the process of your burn job.
Alternatively, you can create the image and burn the CD/DVD on the fly using linux pipes:

In this case, mkisofs prints the image data to stdout. We catch this and redirect the image data directly to cdrecord. Note, that if mkisofs fails creating the image completely, cdrecord might rubish your CD/DVD.

The following algorithm shows you howto decode the digital product id to fetch your raw product key. If you loose your product key, this should help you to get it back without spending money. Please use this knowledge only for legal use! This is the onliest limitation to the following algorithm:

You got the raw decoded key in the Result variable. After decoding, you have to format the product key e.g. adding “-” after every 5th char and so on. I used Microsoft .NET Framework and C# to access the registry and decode the byte progression.

It seems that there is a problem with the gnome dbus daemon running in background. There are several workarounds at web on vmware and gentoo pages which propose either to change soft-links linking corresponding libraries or start vmware with changed library dependings.
My workaround is quiet easy: Just stop the dbus daemon before starting vmware:

This will prevent you from changing any software preferences and is likely to be removed easily when this dbus vmware bug is hopefully fixed.

Using CGI PHP

There are different possibilities, you can run PHP. In general, PHP runs as module, e.g. in a apache web server. But there is another interesting method to run PHP. If you run a PHP script as CGI program, a new process is forked and the PHP interpreter is loaded into this process. This method allows us to run several PHP scripts concurrently.
Imagine, that we have a PHP script to transfer the file and periodically write out the size of transfered data into a temporary state file. Further another script exists to read out the state file information, calculate the percentage of transfered data and displays a cute progress bar. Now we can use the concurrency described above to let the two scripts run concurrently. So you see, the main idea is to separate the upload and the statistic script. While the upload script transfers data, the statistic script will show the progress bar.

Filetransfer Management

The idea of transfering is quit easy: We read a data package of a couple of bytes (e.g. 1024 bytes), examine it and save it in a temporary file. After we reach the end of file (eof), we move the temporary file to the destination file. You can get an idea of this transfer from the following code example:

#!/usr/bin/php

Note, that this script run as CGI program, like I desribed above.

As you see, I periodically read 1024 bytes from STDIN. This wrapps the input stream e.g. coming from a HTML input form. Let’s have a look at the input stream layout.

Further you are able, to validate the content length by using $_ENV['CONTENT_LENGTH'] at the beginning of the upload script, like I did on line 4.

Data Streaming

If you look at the uploaded file, you will see something like the following snippet I got after uploading a jpeg file:

-----------------------------1951833994121914805585029106
Content-Disposition: form-data; name="datei"; filename="sysarc.jpg"
Content-Type: image/jpeg
some binary or ASCII code
-----------------------------1951833994121914805585029106--

As you see, we got the basic information Content-Disposition and Content-Type at the beginning of the file stream. So the idea is to parse the first lines of an incoming transfer until the header is completely transfered. Further one can examine the header information and perhaps, you can stop the file transfer, e.g. if someone wants to upload a forbidden content type.

To sum up, we have an upload control script, which can hand over essential information (filetype, filename, filesize, transfered bytes) to another statistic script. It’s your turn to create a statistic script which analysis this information.

Avoiding Javascript

Now, you know the basic ideas about uploading files with pure PHP. You don’t need further client-side scripting languages like Javascript to use the upload script. Think about multiple frames (I know, that’s very old-school, but I found no other possibility). If your are using two frames, one frame can show the upload form and can call the upload script while the other frame can show the statistic page all the time. The statistic page refreshes itself every few seconds using the following html meta tag:

If an upload begins, the upload script hands over upload information to the statistic script which creates an upload progress bar.