07.04.2017

Selbstmodifizierender Code

Heute zeige ich mal ein kleines Stück Skriptcode, das eine eigentlich verpönte Programmiertechnik zeigt, nämlich "selbstmodifizierenden Code". Das bedeutet, dass zur Laufzeit erst Programmcode erzeugt und dann direkt ausgeführt wird.

Am besten funktioniert das natürlich in Skriptsprachen, und es muss auch eine Möglichkeit geben, das ausführende Organ, also den Skript-Interpreter, darauf hinzuweisen, dass es neuen Code gibt.

Das Beispiel, das ich vorstellen möchte, ist eher harmlos. Generell sollte man aber bedenken, dass es gefährlich sein kann, wenn man einem Programm die Möglichkeit gibt, sich selbst zu verändern. Diese Technik darf man also insbesondere nicht verwenden, wenn man keine oder wenig Kontrolle über die "Zulieferung" hat, also z.B. bloß nicht in Software für's Web wie CGI-Skripte oder so was.

Mein Artikel beschreibt die Abfrage des Tintenstands eines Druckers. Auf dem Display bzw. im Webinterface zeigt der Drucker sehr schön an, zu wieviel Prozent die Patronen gefüllt sind. Es gibt noch eine weitere Technik: nämlich die Abfrage mit SNMP ("simple network management protocol"). SNMP an sich ist erst mal ziemlich dämlich: es beschreibt nur, wie Geräte Informationen liefern. Welcher Art die gelieferten Informationen sind, kann aber total unterschiedlich sein. SNMP wird von Routern, Switches, Servern, PCs, Druckern, Firewalls, NAS, SAN, Monitoring und vielen anderen Geräten gesprochen, und jedes davon hat ein anderes Spektrum an Parametern.

Deshalb gibt es zu Geräten der diversen Kategorien Beschreibungsdateien, in denen niedergelegt ist, welche Daten ein Gerät liefern kann. Diese Beschreibungen werden gesammelt in MIBs ("Management Information Base"). Es gibt standardisierte MIBs, und manchmal liefern Hersteller, wenn sie nett sind, auch eigene MIBs mit den spezifischen Erweiterungen, z.B. für ein bestimmtes Druckermodell. MIBs werden in einer syntaktisch festgelegten Grammatik geschrieben, in ASN.1.

Zur Abfrage eines Geräts benötigt man ein Hilfsprogramm, das SNMP spricht und eine Netzwerkverbindung zum Ziel aufbauen kann. Für Linux installiert man dazu "net-snmp", das es als fertiges Paket (sourceforge binaries download) oder zum Selbstbauen gibt.

Für die Abfrage muss man ein paar merkwürdige, sehr lange Zahlen wissen. Manchmal kann es trickreich sein, genau herauszufinden, was man braucht. Man kann die MIB-Datei lesen (braucht etwas Übung) oder man versucht es mit einer Suchmaschine (so wie ich, wenn ich faul bin).

Weiter unten stelle ich das komplette Skript vor, aber ich zerlege einzelne Zeilen in ihre Einzelteile und zeige, wie sie funktionieren.

Das Skript zum Abfragen der Tintenstände verwendet sogar zwei verschiedene Techniken aus der Kategorie "selbstmodifizierender Code". Zum Einen verwende ich den "eval"-Befehl der Linux-Shell (die /bin/sh ist bei mir bash), und zum anderen baue ich ein winziges Perl-Skript mit Inhalten zusammen, die ich mir gerade vorher erst im Shellskript aus einem snmp-Befehl zusammengesammelt habe.

Die eigentliche Abfrage des Tintenstands funktioniert so wie im folgenden Schnipsel gezeigt. Zuerst der Befehl, dann die Ergebnisse mit meinem speziellen Drucker. Der Befehl "snmpwalk" liefert mir mehrere Ergebnisse mit einer Abfrage; dazu "wandert" der Befehl durch alle Unter-Ergebnisse der angegebenen Nummer 1.3.6.1.2.1.43.11.1.1.6.0, also .6.0.1, .6.0.2 usw.
Diese spezielle Abfrage liefert mir die Zuordnung, welche Nummer zu welcher Farbpatrone gehört.

# snmpwalk -v1 -c public 192.168.100.173 1.3.6.1.2.1.43.11.1.1.6.0
SNMPv2-SMI::mib-2.43.11.1.1.6.0.1 = STRING: "black ink"
SNMPv2-SMI::mib-2.43.11.1.1.6.0.2 = STRING: "yellow ink"
SNMPv2-SMI::mib-2.43.11.1.1.6.0.3 = STRING: "cyan ink"
SNMPv2-SMI::mib-2.43.11.1.1.6.0.4 = STRING: "magenta ink"

Als nächstes beschaffe ich mir die Tintenstände und den Maximalwert, damit ich prozentual berechnen kann, wie voll jede Patrone noch ist.

# snmpwalk -v1 -c public 192.168.100.173 1.3.6.1.2.1.43.11.1.1.9.0
SNMPv2-SMI::mib-2.43.11.1.1.9.0.1 = INTEGER: 231
SNMPv2-SMI::mib-2.43.11.1.1.9.0.2 = INTEGER: 94
SNMPv2-SMI::mib-2.43.11.1.1.9.0.3 = INTEGER: 210
SNMPv2-SMI::mib-2.43.11.1.1.9.0.4 = INTEGER: 174

# snmpwalk -v1 -c praxis 192.168.100.173 1.3.6.1.2.1.43.11.1.1.8.0
SNMPv2-SMI::mib-2.43.11.1.1.8.0.1 = INTEGER: 674
SNMPv2-SMI::mib-2.43.11.1.1.8.0.2 = INTEGER: 240
SNMPv2-SMI::mib-2.43.11.1.1.8.0.3 = INTEGER: 226
SNMPv2-SMI::mib-2.43.11.1.1.8.0.4 = INTEGER: 241
"black" ist also noch zu 231/674 voll, umgerechnet ca. 34 %.

So, damit haben wir das Werkzeug, um Dinge zu tun. Wäre schön, wenn das noch mit etwas mehr Bequemlichkeit verbunden wäre. Also packen wir all das in ein Skript.

Dieses Skript muss also mehrere SNMP-Abfragen durchführen, sich die Werte merken, Prozente ausrechnen und den ganzen Spaß dann wieder ausgeben.

Die Technik der folgenden Zeile verwendet den bash-Befehl "eval", um Shell-Befehle in diesem Moment auszuführen.
eval $(snmpwalk -v1 -c praxis 192.168.100.173 \
  1.3.6.1.2.1.43.11.1.1.6.0 | perl -ne 'print "c[$1]=$2\n" \
if(m!SNMPv2-SMI::mib-2.43.11.1.1.6.0.(\d) = STRING:\s+"(\w+) ink"!i);')

Der Shell-Befehl, den das perl-Skript zusammenbaut, nimmt die Zahlenwerte aus der SNMP-Abfrage und erzeugt daraus die Zuweisung der Abfragewerte zu Shellvariablen in einem Array. Dazu nimmt der perl-Interpreter die Ausgabe des snmpwalk-Befehls zeilenweise und untersucht jede dieser Zeilen, ob sie einem vorgegebenen Textmuster entsprechen (regular expression). perl baut also ungefähr so etwas

c[1]=black
c[2]=yellow
c[3]=cyan
c[4]=magenta
Der "eval" in der Shell sorgt nun dafür, dass diese Zuweisung im bash-Skript zu diesem Zeitpunkt ausgeführt wird, als hätte ich es vorher in den Code geschrieben. Hier greift also der Begriff "selbstmodifizierend", weil im Skript etwas passiert, was das Skript selbst vorher zusammengebaut hat (mit Hilfe von perl).

Auf dieselbe Weise werden die Maximalwerte jeder Patrone vom Drucker geholt; durch den "eval"-Befehl erhält die Shell dann noch das Array "max" mit folgendem Inhalt:

max[1]=674
max[2]=240
max[3]=226
max[4]=241
Und im nächsten Schritt wird es noch trickreicher: mit den eben gerade gelernten Arrays wird ein perl-Skript dynamisch zusammengebaut, in dem diese Zahlenwerte von einem bash-Array in ein perl-Array umgebaut werden, und ich lasse dann die Prozentwerte in perl ausrechnen. Da die Arrays in perl bei 0 anfangen zu zählen, ist in jedem Array das nullte Element ein leerer Text, also "". Das perl-Skript erhält die Tintennamen und die Maximalwerte als fest einprogrammierte Werte, und die aktuellen Zahlenwerte liest es direkt aus der Standardausgabe von snmpwalk.

Wie funktioniert dieser Trick nun genau?

Üblicherweise ruft man den Skriptinterpreter (perl, awk, sed oder irgendwas anderes) so auf: perl -e 'bla mein programm usw.'. Die Apostrophe teilen der Shell mit, dass alles dazwischen unverändert an perl weitergegeben werden soll. Man kann allerdings diese '...' unterbrechen, und an dieser Unterbrechung setzt die Shell ihre Arbeit fort. Wenn ich also perl -e '...bla(' ${variable} ')...' schreibe, besteht das Programm für perl also an dieser Stelle aus dem aktuellen Inhalt der Shell-Variablen ${variable} (z.B. 5) und das ganze wird effektiv zu perl -e '...bla(5)...'! Das ganze muss natürlich syntaktisch korrekter perl-Code werden, also muss man auf Anführungszeichen für Strings usw. achten.
#!/bin/sh

PATH=/opt/bin${PATH:+:$PATH}

# get current ink levels
eval $(snmpwalk -v1 -c praxis 192.168.100.173 \
  1.3.6.1.2.1.43.11.1.1.6.0 |
perl -ne 'print "c[$1]=$2\n" \
  if(m!SNMPv2-SMI::mib-2.43.11.1.1.6.0.(\d) = STRING:\s+"(\w+) ink"!i);')

# get max ink level per cartridge
eval $(snmpwalk -v1 -c praxis 192.168.100.173 \
  1.3.6.1.2.1.43.11.1.1.8.0 |
perl -ne 'print "max[$1]=$2\n" \
  if(m!SNMPv2-SMI::mib-2.43.11.1.1.8.0.(\d) = INTEGER:\s+(\d+)!i);')

snmpwalk -v1 -c praxis 192.168.100.173 1.3.6.1.2.1.43.11.1.1.9.0 |
perl -ne '
    my @c=("","'${c[1]}'","'${c[2]}'","'${c[3]}'","'${c[4]}'");
    my @max=("","'${max[1]}'","'${max[2]}'","'${max[3]}'","'${max[4]}'");
    printf"# $c[$1]=$2 (%.0f)\n",$2/$max[$1]*100
        if(m!SNMPv2-SMI::mib-2.43.11.1.1.9.0.(\d) = INTEGER:\s+(\d+)!i);'
 Das Ergebnis sieht dann ungefähr so aus:
$ sh ./ink.sh
# black=247 (38)
# yellow=218 (95)
# cyan=127 (59)
# magenta=195 (85)