Mit Java über JPCSC auf den Smartcardreader und die Smartcard unter Linux zugreifen

Nach etwas Arbeit habe ich den JPCSC Wrapper in der Version 0.8.0 für PCSC unter Ubuntu Jaunty 9.04 zum laufen gebracht. Dafür waren diverse Änderungen am Quellcode von JPCSC notwendig, die ich zuerst beschreibe.

Die folgenden Pakete müssen zuerst auf dem System installiert werden:
[code]
sudo aptitude install sun-java6-jdk libpcsclite-dev libpcsclite1
[/code]

Danach muss JPCSC von der Linuxnet.com Seite runtergeladen und entpackt werden. Das Erstellen mit dem Befehl „make“ wird nicht funktionieren, weil diverse Header-Dateien von PCSC nicht in dem Standard-Pfad /usr/include/ liegen, sondern in dem Pfad /usr/include/PCSC/.

Die folgenden Header-Dateien sind davon betroffen:
[code]
ifdhandler.h
pcsclite.h
reader.h
winscard.h
wintypes.h
[/code]

Um dieses Problem zu lösen, ist es am Einfachsten die Bibliotheken in dem Pfad /usr/include zu verlinken. Dazu sollten die folgenden Befehle reichen:

[code]
cd /usr/include
sudo ln -s PCSC/ifdhandler.h ifdhandler.h
sudo ln -s PCSC/pcsclite.h pcsclite.h
sudo ln -s PCSC/reader.h reader.h
sudo ln -s PCSC/winscard.h winscard.h
sudo ln -s PCSC/wintypes.h wintypes.h
[/code]

Zusätzlich muss die Zeile 769 in der Datei jpcsc/src/jpcsc/jpcsc.c angepasst werden, weil sie nicht mehr dem Aufruf aus der pcsc-Bibliothek passt:

[code]
<      rv =  SCardControl(card, cin + joff, jlen, cout, &clen); --- >     rv =  SCardControl(card, SCARD_CTL_CODE(jcc), cin + joff, jlen, cout, clen, &clen);
[/code]

Also „SCardControl(card, cin + joff, jlen, cout, &clen);“ ersetzen durch „SCardControl(card, SCARD_CTL_CODE(jcc), cin + joff, jlen, cout, clen, &clen);“.

Danach sollte es möglich sein den Code zu erstellen.

Um über den Wrapper auf die Bibliothek zuzugreifen, muss die Bibliothek jpcsc.so und jpcsc.jar über den folgenden Parameter verlinkt werden. Der folgenden Parameter muss dem Aufruf vor der Ausführung als Parameter direkt übergeben werden:

[code]
java -Djava.library.path=lib/ Test
[/code]

In dem von mir gezeigten Beispiel müssen die beiden Dateien „jpcsc.so“ und „jpcsc.jar“ in den Ordner „lib/“ gelegt werden, damit sie angesteuert werden.

Unter Eclipse muss unter „Run as “ unter Configurations nur der Parameter bei VM-Arguments eingetragen werden:

[code]
-Djava.library.path=lib/
[/code]

Beispielcode:

[code]
import com.linuxnet.jpcsc.*;

public class JPCSCUsecase {

public JPCSCUsecase() {
try {
Context context = new Context();
context.EstablishContext(PCSC.SCOPE_GLOBAL, null, null);

String[] readers = context.ListReaders();
if (readers.length <= 0) { System.err.println("No readers found..."); return; } //Talk to the first reader = 0 String reader = readers[0]; System.out.println("Using reader " + reader); Card card = context.Connect(reader); card.BeginTransaction(); //Do something with APDUS System.out.println("APDU: "+ readApduInfo(card)); card.EndTransaction(PCSC.RESET_CARD); card.Disconnect(); context.ReleaseContext(); } catch (Exception e) { e.printStackTrace(); } } private String readApduInfo(Card card) { Apdu apdu = new Apdu((byte) 0x20, (byte) 0x13, (byte) 0x00, (byte) 0x81, 0, null, 0, 5); byte[] data = card.Transmit(apdu); return bytesToString(data); } private String bytesToString(byte[] bytes) { String output = ""; for (int i = 0; i < bytes.length; i++) { output += "0x"+bytes[i]+ " "; } return output; } public static void main(String[] arg) { new JPCSCUsecase(); } } [/code] Eigentlich ist es besser und vor allem einfacher über die Implementierung von javax.smartcardio.* zuzugreifen. Weitere Informationen folgen noch.

Fehlende Umsatzsteuer-ID im Impressum ist abmahnfähig

Damit hat das Oberlandesgericht Hamm entschieden,  dass die Umsatzsteuer-Identifikationsnummer Pflichtangabe für das Impressum gewerblicher Webseiten ist.

Jeder gewerbliche Seitenbetreiber sollte bei Gelegenheit alle Punkte aus § 5 Allgemeine Informationspflichten prüfen. Es wird bestimmt wieder abmahnfreudige Anwälte geben, die sich damit schnell Geld verdienen wollen.

Quellen und weitere Hinweise

Zensursula Promotion Video

Für meinen Geschmack zu „poppig“, hätte es etwas rockiger gestaltet. Aber dafür habe ich wohl nicht den „Geschmack der Massen“. Schaut selber:

Es ist nur traurig, wie wenig Personen Ursula von der Leyen direkt kontaktieren: http://www.direktzu.de/vonderleyen

„Lobbyarbeit“ können auch auf diesem Weg Personen ohne Millionenbudget betreiben. Werden die Fragen gelöscht, so kann das wiederrum publik gemacht werden. Aber bitte sachlich bleiben, sonst wird es mehr schaden als bringen!

Aktualisierung des Intel Graphikkartentreibers unter Ubuntu 9.04 Jaunty löst viele Probleme

Heute habe ich mich nach längeren Problemen mit dem Intel Graphikkarten Treiber dazu entschieden diesen zu aktualisieren. Die Ubuntu 9.04 (Jaunty) Version kam zu einem denkbar schlechten Zeitpunkt aus Sicht des Kernels und der Intel Treiber raus. Intel hat kurz vorher begonnen die Treiber komplett auf die neue Kernel Architektur umzubauen.

Mit dem Kernel 2.6.28 und den in Jaunty enthaltenen Treibern enstand eine schlecht funktionierende Version.

Seit wenigen Minuten habe ich jetzt eine Lösung für das Problem und ja meine riesigen VertexArrays funktionieren wieder.

Die Lösung war relativ einfach. Ich habe zuerst von http://kernel.ubuntu.com/~kernel-ppa/mainline/ den neuesten Kernel (derzeit 2.6.30) installiert, damit der Treiber die UXA Graphikbeschleunigung Architektur nutzen kann.

Im nächsten Schritt habe ich die Quellen von X-Updates in die sources.list von apt aufgenommen und die Treiber aktualisiert. Siehe alle Informationen hier: https://launchpad.net/~ubuntu-x-swat/+archive/x-updates.

Zusätzlich müssen noch die neuesten X.org Pakete mit den folgenden Befehlen aktualisiert werden:

[code]
sudo aptitude update
sudo aptitude upgrade
[/code]

Im letzten Schritt musste ich die xorg.conf anpassen, damit UXA genutzt wird. Dafür muss  unter AccelMethod UXA aktiviert werden Der Abschnitt sieht so aus:

[code]
Section „Device“
Identifier „Configured Video Device“
Driver „intel“
# this one is important
Option „AccelMethod“ „UXA“
EndSection
[/code]

In vielen Anleitungen fehlen die Anführungszeichen um „AccelMethod“ was zu einer Fehlermeldung bei mir führt. Generell müssen Optionnen und die Optionen in Anführungszeichen gesetzt werden.

Quellen und weitere Hinweise:

http://www.ubuntugeek.com/new-intel-graphics-drivers-for-ubuntu-9-04-jaunty.html

Mit ThreadPoolExecutor Arbeit unter Java effizient parallelisieren

Es gibt immer wieder Aufgaben, die sehr lange dauern und sehr große Mengen an Daten verarbeiten müssen. Dabei geht es meistens um Minuten oder gar Stunden, Tage …

Diese sollten sinnvollerweise parallelisiert werden, um die Leistungs des Systems zu nutzen. Heutige Systeme sind sehr oft Mehrkern- bzw. Mehrprozessorsysteme. Auch ist das GHz-Rennen im Moment zu Ende und die Leistung steigt über die Anzahl der Prozessoren bzw. Kerne.

Das folgende Beispiel zeigt wie man unter Java Aufgaben parallel verarbeiten kann, ohne sich groß den Kopf um die Ausführung zerbrechen zu müssen. Der ThreadPoolExecutor ist meiner Meinung nach eine sehr gute Möglichkeit Aufgaben zu parallelisieren, die Parallel ausgeführt werden können. Der große Vorteil ist, dass er Threads für das Abarbeiten am laufen hält. Das bedeutet bei neuen Aufgaben werden normalerweise keine Threads gestartet und somit entfällt faktisch dieser Overhead. Threads im Pool werden nur beendet, wenn sie länger als der festgelegte Timeout nicht benutzt werden oder sie vom Programmierer explizit beendet werden.

Nicht erschrecken. Das meiste davon sind Kommentare und Beispielcode.

Ich weiß – weniger Gelaber und her mit dem Code!

[code]
import java.util.concurrent.*;

class MyThreadPoolExecutor
{
//Parallel running Threads(Executor) on System
int corePoolSize = 2;

//Maximum Threads allowed in Pool
int maxPoolSize = 4;

//Keep alive time for waiting threads for jobs(Runnable)
long keepAliveTime = 10;

//This is the one who manages and start the work
ThreadPoolExecutor threadPool = null;

//Working queue for jobs (Runnable). We add them finally here
final ArrayBlockingQueue workQueue = new ArrayBlockingQueue(5);

public MyThreadPoolExecutor() {
threadPool = new ThreadPoolExecutor(corePoolSize, maxPoolSize,
keepAliveTime, TimeUnit.SECONDS, workQueue);
}

/**
* Here we add our jobs to working queue
*
* @param task a Runnable task
*/
public void runTask(Runnable task) {
threadPool.execute(task);
System.out.println(„Tasks in workQueue..“ + workQueue.size());
}

/**
* Shutdown the Threadpool if it’s finished
*/
public void shutDown() {
threadPool.shutdown();
}

public static void main(String args[]) {
MyThreadPoolExecutor mtpe = new MyThreadPoolExecutor();

for (int i= 0; i < 6; i++ ) { mtpe.runTask(new WorkerRunnable(i)); } mtpe.shutDown(); System.out.println("Finished! :)"); } /** * This is the one who do the work * * This one is static for accessing from main class */ private static class WorkerRunnable implements Runnable { //so we can see which job is running private int jobNr; /** * This is for understanding only * * @param jobNr number for displaying */ public WorkerRunnable(int jobNr) { this.jobNr = jobNr; } @Override public void run() { for(int i = 0; i < 10; i++) { try { System.out.println("Thread "+jobNr+" calculated "+ i); Thread.currentThread().sleep(1000); } catch (InterruptedException ie) { ie.printStackTrace(); } } } } } [/code] Da in diesem Beispiel die Anzahl der Parallel laufender Threads (corePoolSize) auf statisch 2 begrenzt ist, sollte die Zahl über Prozessoranzahl (siehe hier) bestimmt werden. Auch sollte man nicht vergessen die maximale Anzahl an Threads (maxPoolSize) entsprechend anzupassen.

Anzahl Prozessoren bestimmen welche für die Java Virtual Machine (JVM) vom System zur Verfügung stehen

Da derzeitige Computersysteme in Anzahl der Prozessoren (im Moment Kerne) und nicht mehr im GHz wachsen, muss auch ein Umdenken bei der Programmierung passieren. Das bedeutet wir müssen als Programmierer Aufgaben parallelisieren oder unabhängige Prozesse bzw. Threads parallel ausführen, um die Leistung möglichst effizient ausnutzen zu können. Wenn das möglich ist, dann sollte das Programm über die Anzahl der Prozessoren (im Moment Kerne) selbstständig bestimmen, wie viele Prozesse bzw. Threads es parallel ausführt.

Das folgende Codefragment bestimmt die Prozessoranzahl unter Java:
[code]
public class ProcessorCounter {

public static void main(String[] args) {

Runtime runtime = Runtime.getRuntime();

int nrOfProcessors = runtime.availableProcessors();

System.out.println(„Number of processors available to the Java Virtual Machine: “ + nrOfProcessors);
}
}
[/code]

Home – ein Film von Yann Arthus-Bertrand

Der Film Home von Yann Arthus Bertrand zeigt eindrucksvoll, wie wir unsere Umwelt zerstören und noch immer glauben, dass die Erde genug Kraft hat sich parallel selbst vor unseren Schäden zu heilen. Wer der englischen Sprache mächtig ist, sollte sich diesen Film anschauen.

Der Link zum Film: http://www.youtube.com/homeprojectDE

Die Seite zum Film: http://www.home-2009.com/

Jeder sollte sich den Film zuerst anschauen, bevor er negative bzw. positive Meinungen verbreitet.

ext3 Performanzverbesserungen und CFQ Linux Scheduler Internals auf lwn.net

Heute bin ich zufälligerweise über den Artikel Solving the ext3 latency problem gestolpert. In diesem ist beschrieben wie Latency Probleme im ext3 Dateisystem untersucht, aufgedeckt und behoben wurden. Vor allem interessant finde ich die Beschreibung der internen Abläufe im Kernel und besonders im CFQ Scheduler. Dieser stellt in heutigen Betriebssystemen den modernsten Scheduler dar.

Besonders die Probleme mit fsync() Aufrufen sind mir sehr gut bekannt. Allerdings habe ich sie ohne weitere Untersuchungen auf die Festplatte geschoben, weil ich bei Windows XP deutlich schlimmere Verzögerungen miterleben muss. Ich freue mich schon auf den 2.6.30er Linux Kernel und den deutlichen Performanzzuwachs.

Vor allem lobe ich die ausführliche und aufschlussreiche Berichtserstattung des Problems. Dadurch wurde den Lesern gleichzeitig notwendiges Hintergrundwissen für die Optimierung des Dateisystems mitgeteilt. Auch wurde damit gezeigt, dass an Linux mehrere Personen arbeiten und allen sehr viel an der Qualität des Linux Kernels liegt.

Ich wechsele die Branche: Refelector Guy

Heute bin ich bei der Suche nach „Wie falte ich einen runden Reflector?“ auf das folgende Video gestoßen:
The Best Job In The World – Bikini Reflector

Da ich jetzt einen solchen Reflektor habe, werde ich kräftig üben und wenn die Zeit gekommen ist, dann bewerbe ich als Reflector Guy.

Den wichtigsten Spruch habe ich schon gelernt: „Nobody else in the world can hold the reflector in the angle, so the sun falls on the model. I’m the Reflector Guy!“

Wünscht mir viel Erfolg in der neuen Branche und Goodbye Informatik!

PS: Den Reflector kann ich schon mal falten. 😉