system(), exec() & shell()

Mit Programmiersprachen System-Befehle erteilen

Hier geht es darum, die System-Konsole in eigene Programme einzubinden. Ein (eigenes) Programm erteilt Konsolen-Befehle und wertet das Ergebnis aus. Das erfordert Zugriffs-Rechte auf den eigenen PC und kann daher leider nicht Live demonstriert werden.
Konsole Konsole Verwendung der "guten alten" Konsole (Linux-Shell, Windows cmd.exe)
C/C++ Funktionen system(), popen()
Java Die Methode exec der Klasse Runtime
Javascript Zugriff verboten !
Perl Die Funktionen system(), exec und qx (`Backquotes`), Kanal-Umleitung
PHP Die Funktionen system, exec(), shell_exec, ...
VBA Funktion Shell() und ActiveX
Windows-Konsole Optionen der Windows-Konsole cmd.exe
Linux-Konsole Optionen der Linux Shell-Konsole cmd.exe

C/C++

Funktion system()

Die Funktion führt einen Systembefehl aus und gibt bei Erfolg 0 zurück.
sie arbeitet synchron, d.h. sie wartet auf den Abschluss des Systembefehls.

Das Beispiel rechts gibt auf Linux eine Liste der Umgebungs-Variablen aus. Verwenden sie an Stelle des Befehls "export" die abgeschaltete Zeile, um die Umgebungs-Variablen auf Windows auszugeben.
♦ Details zu Umgebungs-Daten mit C/C++

Man kann hintereinander mehrere system() Funktionen ausführen, diese sind jedoch voneinander vollkommen unabhängig. Daher muss man z.B. einen Pfad in jedem Befehl einzeln angeben. 		Ausführung von System-Befehlen ohne Analyse der Ausgabe-Texte:
#include <stdio.h>
int main(void) {
int i;
char *s="export"; // Linux
// char *s="set"; // Windows
printf("System-Befehl: %s\n",s);
i = system(s);
printf ("Rueckgabe: %d\n",i);
return 0;
}
Windows-Pfade enthalten den \ Backslash als Trennzeichen, den man in einem String immer mit einem zweiten Backslash maskieren muss. Hinweis: Befehl "tree" erzeugt eine sehr umfangreiche Ausgabe.
system("dir C:\\Programme");
system("tree C:\\");
Man kann mit Funktion system() nicht nur jeden Konsolen-Befehl ausführen, sondern auch jedes andere Programm starten, z.B. Windows-Editor oder Rechner.
system("notepad.exe");
system("calc.exe");

Funktion popen()

Wenn man den Ausgabe-Text von System-Befehlen (oder anderen Konsolen-Programmen) im eigenen Programm verarbeiten will, dann muss man diesen Text mit einer Pipe umleiten.

Im Beispiel wird der gewünschte Befehl in die String-Variable s eingetragen und als Argument an popen() übergeben. Der vom ausgeführten Befehl oder Programm erzeugte Text wird in diesem Fall nicht an der Konsole angezeigt sondern zeilenweise in die String-Variable line umgeleitet (die ausreichend Platz für die längste erwartete Zeile bieten sollte).
Die while-Schleife wird für jede vom aufgerufenen Befehl oder Programm erzeugte Zeile 1mal durchlaufen. Die Variable line enthält als letztes Zeichen einen \n Zeilen-Umbruch. In der abgeschalteten Zeile wird angedeutet, wo der erhaltene Text am besten analysiert und verarbeitet wird.

Die System-Befehle des Beispiel liefern Datum und Zeit in einer einzigen Text-Zeile. Ersetzen sie den Inhalt der Variablen s, um mehrzeilige Antworten zu erhalten, z.B. auf Windows
char *s="dir C:\\";
Analyse der ausgeführten System-Befehle:
#include <stdio.h>
int main() {
char *s="date #+%F %T' ";   // Linux
//char *s="echo %date% %time%";   // Windows
char line[200];
FILE *pipe;
pipe = (FILE*)popen(s,"r");
if(pipe) {
while ( fgets( line, sizeof line, pipe)) {
printf("line=%s", line);
// Text hier verarbeiten
}
pclose(pipe);
}
return 0;
}

Java
Die Methode exec() der Klasse Runtime kann System-Befehle ausführen und deren Ergebnis verarbeiten.

Details in der Java-Doku unter Runtime # exec

Das erfordert jedoch ein ausführbares Java-Programm, da Java-Applets in Webseiten nicht auf den eigenen PC zugreifen dürfen. Aus dem gleichen Grund ist die Methode exec() in ↓ Javascript nicht verfügbar.
import java.io.*;
class execInput {
public static void main(String Argv[]) {
try {
String ls_str;
Process ls_proc = Runtime.getRuntime().exec("ls *.txt ");
DataInputStream ls_in=new DataInputStream( ls_proc.getInputStream());
try {
while((ls_str=ls_in.readLine())!=null) {
System.out.println(ls_str);
}
}
catch (IOException e) {System.exit(0);}
}
catch (IOException e1) {
System.err.println(e1);
System.exit(1);
}
System.exit(0);
}
}

JavaScript
Jede Webseite kann Programme dieser Programmiersprache enthalten. Da es für Webseiten grundsätzlich verboten ist, auf das Betriebs- oder Dateisystem des Client-PC zuzugreifen, gibt es in Javascript auch keine Funktionen dazu. Mittlerweile wird Javascript auch für (wenige) andere Anwendungen eingesetzt. In diesem Fall wird die Programmiersprache meist durch spezielle Klassen ergänzt, die evtl. auch einen Zugriff auf das Betriebssystem bieten können. Das sind jedoch individuelle Ergänzungen, die nicht Bestandteil des Standards sind und von Webseiten-Programmen nicht genutzt werden können.

Perl
Perl wird mit den hier vorgestellten Funktionen häufig zur System-Verwaltung eingesetzt. Mit wenig zusätzlichem Aufwand können die Script-Programme meist auch System-unabhängig erstellt werden. Systembefehle werden allerdings nur in Konsolen-Scripts verwendet. Für → CGI-Programme kommen sie aus Sicherheits-Gründen kaum in Frage: Webseiten zur Verwaltung des eigenen PC werden meist mit → PHP erstellt.

Umgebung:

Die Perl-Variable $^O gibt das aktuelle Betriebssystem zurück:, z.B. linux, MSWin32, . .
Die Umgebungs-Variablen $ENV{"OS"} (auf Windows) oder $ENV{"OSTYPE"} (auf Linux) geben das aktuelle Betriebssystem zurück: linux, Windows_NT, . .

Damit kann man die etwas unterschiedliche Syntax der Systembefehle in Linux und Windows umschalten. Wandeln sie alle Texte vor einem match sicherheitshalber in Kleinbuchstaben um. Leider scheinen die $^O-Strings nicht normiert zu sein, deshalb weitere Indizien:

Indizien für Linux-Systeme:
• Die Umgebungs-Variable $ENV{"Path"} enthält als Trennzeichen mehrere ':' und typische Pfade wie /usr/sbin.
• Eine Umgebungs-Variable $ENV{"Shell"} mit einem Linux-Pfad, z.B. /bin/bash
Indizien für Windows-Systeme:
• Eine Umgebungs-Variable $ENV{"Windir"}, die immer den String ''Windows' enthält, z.B. "C:\Windows"
• Eine Umgebungsvariable $ENV{"Systemdrive"}, die mit einem typischen Win-Pfad beginnt: 'Laufwerks-Buchstabe' und Doppelpunkt, z.B. "C:"
• Die Umgebungs-Variable $ENV{"Path"} enthält als Trennzeichen mehrere ';'. Sie beginnt mit einem Win-Pfad und enthält den String 'Windows', meist sogar mehrfach.

Am besten erzeugen sie sich ein kleines sub, welches das System aller von ihnen verwendeten PCs zuverlässig erkennt, und bauen dieses sub in alle Perl-Scripts ein, die mit System-Befehlen arbeiten.
♦ Details zur Perl - Umgebung.

Beispiel:
my $mysystem = 'linux';
if(lc($^O)=~m/win/) {$mysystem = 'windows';}
Funktion system() führt einen Systembefehl aus und gibt bei Erfolg 0 zurück.
Die Funktion arbeitet synchron, d.h. sie wartet auf den Abschluss des Systembefehls.
Das können sie demonstrieren, wenn sie z.B. eine große Datei kopieren, wie in diesem Beispiel.

Windows-Pfade kann man zwar in Perl auch mit dem üblichen Trennzeichen / verwenden, jedoch nicht für Konsolen-Befehle: Diese externen Programme verlangen (nur) auf Windows gnadenlos den \ Backslash als Trennzeichen.
$s = "copy c:\\small.dat d:\\test.dat";
print "s = $s .. rasch erledigt\n";
$r = system($s);
print "result = $r\n";
$s = "copy c:\\big.dat d:\\test.dat";
print "s = $s .. das wird dauern\n";
$r = system($s);
print "result = $r\n";
Funktion exec führt einen Systembefehl aus und kehrt nicht mehr (ins Perl-Programm) zurück. Allfällige im Perl-Programm folgende Befehle werden nicht mehr ausgeführt.
Diese Funktion eignet sich besonders für die Ausführung in → Child-Prozessen. Die Ausgabe wird meist in einer Pipe an das Parent-Programm übergeben oder in einer Datei gespeichert.
♦ Details im Perl-Manual unter perlfunc | exec
$s = "dir c:*.txt > c:test.txt";
exec $s;
print 'wird niemals ausgefuehrt';
Funktion qx führt System-Befehle aus und gibt deren Ausgabe-Text zurück. Das ist die einfachste und eleganteste Lösung, um sämtliche System-Programme nach Belieben in eigene Script-Programme einzubinden.
Das Ergebnis wird vorteilhaft mit → Regulären Ausdrücken analysiert, wie im Beispiel rechts angedeutet.

qx ist eigentlich keine Funktion sondern eine Syntax-Variante des `Backtick-Operator`. Für diese kurze Vorstellung ist das jedoch nicht erheblich.
♦ Details im Perl-Manual unter perlop | RegExp-Quotelike Operators

Die Anweisung startet den System-Befehl als → Child-Prozess. Man sollte unbedingt dessen Ende abwarten - Ein vorzeitiger Abbruch lässt das aufgerufene Konsolen-Programm als Zombie-Prozess im Hauptspeicher zurück !
# Systembefehl
my $result = qx('ipconfig');
# In Zeilen aufspalten
my @zeilen = split(/[\n\r]/,$result);
# Analysieren
foreach $line(@zeilen) {
print "$line\n";
if($line=~m/SuchBegriff/) {
print "Gefunden !\n";
}
}

Die Aufspaltung in Zeilen (split) funktioniert an den beiden Sonder-Zeichen LF,CR und daher mit allen gängigen Betriebssystemen.

Umleitung der Ausgabe eines Child-Prozesses

Eine besonders elegante Variente der → Umleitung ist es, mit Perl einen Child-Prozess zu starten, dessen Ausgabe anzunehmen und - mit oder ohne weitere Verarbeitung - wieder auszugeben.
$path = 'env.exe';
print "Ausgabe-Text von $path \n";
open(FILE,"$path |");
while ( <FILE> ) {
print;
}
print "Ende der Ausgabe von $path \n";

Zugriffsrechte:

Wie jedes andere Programm benötigt auch ein Perl-Script die Rechte für die Ausführung. Für den Einsatz von System-Befehlen brauchen sie daher entsprechende Rechte. Am eigenen PC ist das normalerweise kein Problem, ebenso für AdministratorInnen auf einem Server.
→ CGI-Programme unterliegen aus Sicherheitsgründen meist einigen Beschränkungen. Daher werden System-Befehle in solchen Programmen (Dynamische Webseiten) kaum verwendet. Das ist auch der Grund, warum Systembefehle auf dieser Webseite nicht Live demonstriert werden.
Weitere Perl-Funktionen in diesem Zusammenhang:
Perl verwendet ein eigenes System (Hash %SIG) zur Prozess-Kontrolle.
Einige Funktionen in Zusammenhang mit Prozessen:
alarm, fork, kill, pipe, sleep, syscall, times, wait, waitpid, ...
Perl bietet viele Möglichkeiten, um mehrere Arbeiten in parallel laufende → Child-Prozesse auszulagern.
Professionelle Arbeit ist in diesem Fall nur auf Linux-Systemen möglich. Das geht jedoch über den einfachen Rahmen dieser Vorstellung hinaus.
♦ Details im Kapitel → Child-Prozesse sowie im Perl-Manual unter perlipc | signals und bei den einzelnen Funktionen (perlfunc).

Windows-Pfade:

Wenn man Windows-Pfade originalgetreu verwendet, muss man jedes Backslash-\-Zeichen (mit einem zusätzlichen \) maskieren.
♦ Details im Perl-Manual unter perlfunc | system
$s = "copy c:\\small.dat d:\\test.dat";
$r = system($s);
Allerdings gibt es eine 'freundliche Alternative': Verwenden sie einfach allgemein übliche Pfad.Angaben mit Slash-/-Zeichen als Separator. Perl setzt sie sinngemäß ein.
$s = "copy c:/small.dat d:/test.dat";
$r = system($s);

Windows-Registry

Eine (schnellere) Alternative zu System-Befehlen ist oft durch Zugriff auf die Registry-Datenbank möglich.
Vorher müssen sie jedoch die Namen jener Registry-Daten kennen, die sie lesen und/oder ändern wollen.

Die Registry ist leider nicht zusammenhängend dokumentiert, man findet jedoch im Internet zahllose einzelne Hinweise zu einzelnen Stichworten, kombiniert mit registry

Alle Windows-Systeme enthalten das Programm regedit.exe, mit dem man die Registry ansehen und ändern kann - Vorsicht ! Änderungen können Daten, Programme und Betriebssystem zerstören.

Wenn die Registry-Aufgabe erst einmal recherchiert und getestet ist, dann ist die Automatisierung mit Perl kein Problem.

♦ Details zum Thema Perl & Windows-Registry
♦ Details zum Thema Perl-Entwicklung

PHP
▲ PHP bietet für die Ausführung von Systembefehlen eine Vielzahl von teilweise sehr ähnlichen Funktionen an:
system, exec, shell_exec, passthru, popen, proc_open, pcntl_exec, ..
▲ Für den Einstieg am besten geeignet sind die Funktionen exec und shell_exec (s.u.). 		Damit besteht eine elegante Möglichkeit, alle gewünschten Systemfunktionen über Webseiten zu steuern. Gegenüber allen anderen Möglichkeiten (z.B. direkte Eingabe über Konsole) ergeben sich interessante Vorteile:
Rasche und einfache Entwicklung eines guten User-Interface:
Alle Bedienungs-Elemente, Daten und Links können optimal angeordnet werden.
Wenig bekannt, aber ausgezeichnet brauchbar sind → PHP Konsolen-Programme. Man kann sie zur Automatisierung und allgemein dort einsetzen, wo kein User-Interface erwünscht ist.

Sicherheit:

▲ Jede einzelne der hier vorgestellten Funktionen kann ein erhebliches Sicherheits-Risiko darstellen und wird daher im safe_mode eingeschränkt, bei den meisten Providern ganz abgeschaltet. Diese Funktionen sind daher für öffentliche Server ungeeignet.
▲ Für lokale Server im LAN oder für einen privaten Webserver am eigenen PC bieten sie jedoch ausgezeichnete Möglichkeiten. In diesem Fall kann man bei Bedarf die notwendigen Zugriffs-Rechte erteilen.
▲ Man sollte alle Möglichkeiten unterbinden, Systembefehle durch User-Eingabe zu manipulieren. Legen sie daher die Befehlstexte im Programm als Strings fest oder 'berechnen' sie diese. Bieten sie jedoch keine Möglichkeit, die Befehle durch User-Eingabe zu verändern.
▲ Auf dem eigenen PC können sie diese Einschränkungen lockern. Sie sollten sich in diesem Fall jedoch gegen Missbrauch schützen (z.B. kein externer Zugriff auf den privaten Webserver, Firewall, ...)

Befehls- und Rückgabe-Texte:

▲ Auf Win-Systemen muss jeder Pfad-Separator \ mit einem zusätzlichen Backslash maskiert werden.
▲ Verwenden sie keine mehrzeiligen Systembefehle, obwohl das auf Linux möglich wäre. Außerdem wird ihr PHP-Script übersichtlicher und einfacher zu debuggen.
▲ Zur Anzeige des Ausgabe-Textes ist das HTML-Element <pre></pre> gut geeignet. Es formatiert den gesamten darin enthaltenen Text so wie auf einer System-Konsole (Leerzeichen, Zeilen-Umbruch). 		▲ Der Ausgabe-Text wird meist nur teilweise oder gar nicht angezeigt, sondern analysiert. Dazu verwendet man am besten → Reguläre Ausdrücke.
▲ Der üblicherweise zurückgegebene → ASCII-Code muss für die Ausgabe auf Webseiten (meist → ISO-8859-Code) geändert werden. Wandeln sie alle Zeichen mit Codes >127. (>#7F) um, z.B. äöüÄÖÜß, usw.
Alternativ können sie die Ausgabe auf eine Text-Datei leiten, diese umwandeln und in ihrem Script weiter verwenden:
exec ("dir c:\\*.txt > c:\\temp.txt");
exec ("ascii2ansi c:\\temp.txt");
$daten = file("c:\\temp.txt");
print "<pre>$daten</pre>";
exec ("del c:\\temp.txt");

Speicher:

▲ Die gestarteten (System)-Programme verwenden den für PHP reservierten Speicher (RAM, Memory).
Daher sind Speicher-intensive Programme von dieser Verwendung ausgeschlossen.
Funktion system() führt einen Systembefehl aus und leitet die gesamte Ausgabe an PHP. Argument: Systembefehl als String. 2. Argument (optional) Rückgabe-Status. Die Funktion gibt die letzte Zeile der Ausgabe zurück (hier an $lastlin).
▲ Die Ausführung erfolgt synchron, d.h. PHP wartet auf das Ende des gestarteten Programms und führt erst dann sein Script weiter aus.
♦ Original-Dokumentation der Funktion system() bei php.net.
$syscmd = "dir c:\\*.txt";
print "syscmd = $syscmd <br />\n";
print "<pre>\n";
$lastlin = system($syscmd ,$rs);
print "</pre>\n";
print "lastlin = $lastlin<br />\n";
print "rs = $rs<br />\n";
Funktion exec() führt einen Systembefehl aus und kann das Ergebnis verarbeiten. Im Unterschied zu system() wird die Ausgabe nicht angezeigt. Argument: Systembefehl als String. 2. Argument (optional) Ausgabe-Zeilen als Array. 3. Argument (optional): Rückgabe-Status). Rückgabe der letzten Ausgabe-Zeile.
Diese Funktion wird von allen hier angeführten Funktionen am häufigsten eingesetzt.
▲ Die Rückgabe des Befehls ist im Array $ra zeilenweise verfügbar.
Die Rückgabe-Zeilen werden an vorhandene Inhalte des Arrays ($ra) angehängt, daher wird dieses evtl. vor Gebrauch mit unset gelöscht.
♦ Original-Dokumentation der Funktion exec() bei php.net.
$syscmd = "dir c:\\*.txt";
print "syscmd = $syscmd <br />\n";
// unset($ra);
$lastlin = exec($syscmd,$ra,$rc);
print "lastlin = $lastlin<br />\n";
foreach($ra as $z) {
// Zeilen-Text hier verarbeiten
print "$z<br />\n";
}
print "rc = $rc<br />\n";
Funktion shell_exec() (identisch mit Backtick Operator) führt einen Systembefehl aus und gibt den Ergebnis-Text in einer einzigen Variablen zurück.
Die Funktion ist ebenso wie exec() ausgezeichnet für eigene Anwendungen geeignet.
♦ Original-Dokumentation der Funktion shell_exec() bei php.net.
$syscmd = 'ls *.txt';
// $syscmd = "dir *.txt";
$r = shell_exec ($syscmd);
print "<pre>$r</pre>";
Funktion passthru() führt einen Systembefehl aus und kann auch ein binäres Ergebnis zurückliefern. Das wird bei jenen wenigen Systembefehlen verwendet, welche binäre Daten (z.B. ein Bild) zurückgeben.
♦ Original-Dokumentation der Funktion passthru() bei php.net. 		Diese Funktion geht über einfache Anwendungen hinaus und wird nur selten verwendet. Beachten sie die Sicherheits-Vorbehalte zu dieser Funktion !
Funktion popen() öffnet einen Datenstrom (pipe) zu einem Prozess, welcher den gewünschten Systembefehl ausführt. Sie arbeitet wie eine Kombination aus Systembefehl und → Datei-Input/Output. Der Rückgabe-Text beim Lesen wird genauso wie bei einer Text-Datei verarbeitet.
▲ popen() kann man auch zum Schreiben verwenden. Als 2. Argument verwenden sie dann statt 'r' (read) 'w' (write). Sehen sie dazu Beispiele in der Doku und im Internet.
Hinweis aus einer Fehlermeldung: Wenn eine PHP-session verwendet wird, dann sollte diese vorher beendet werden.
♦ Original-Dokumentation der Funktion popen() bei php.net.
$syscmd = "dir c:\\*.txt";
print "syscmd = $syscmd<br />\n";
// session_write_close();
$fp = popen($syscmd, 'r');
print "fp = $fp<br />\n";
while(!feof($fp)) {
$line = fgets($fp,1000);
// Verarbeitung hier
print "$line <br />";
}
fclose($fp);
Funktion proc_open() öffnet einen bidirektionalen Datenstrom zu einem Prozess. Das PHP-Script kann daher mit einem Prozess interaktiv kommunizieren (Lesen und Schreiben), genauso wie ein/e menschliche AnwenderIn.
♦ Original-Dokumentation der Funktion proc_open() bei php.net. 		Diese Funktion geht über einfache Anwendungen hinaus und wird daher hier vorläufig nicht vorgestellt.
Funktion pcntl_exec() startet ein ausführbares Programm oder ein Script, welches selbsttätig das passende ausführbare Programm öffnet.
♦ Original-Dokumentation der Funktion pcntl_exec() bei php.net. 		PHP bietet eine ganze Familie von ' Process Control Functions', welche es erlauben, Programme zu starten und deren Ausführung zu kontrollieren. Das geht jedoch über einfache Anwendungen hinaus und wird daher hier vorläufig nicht vorgestellt.
♦ Details zu PHP und zum Einsatz von PHP als Konsolen-Programm (Commandline Interrpreter).

VBA
Funktion Shell()
VBA und ActiveX sind an Windows-Betriebssysteme gebunden und können daher nicht System-unabhängig eingesetzt werden.
Shell() ist die Standard-Funktion zur Erteilung von Befehlen an die Windows-Konsole.
Der erste Befehl des Beispiels geht an cmd.exe, erstellt eine Dateiliste von Verzeichnis C:\ und gibt sie an Datei C:\dir.dat aus. Danach wird die Konsole mit Option /C geschlossen.
Der zweite Befehl öffnet die soeben erstellte Datei mit dem Windows Editor-Programm. 		VBA-Beispiel:
Sub test()
s = "cmd.exe /C dir c:>c:dir.dat"
Shell (s)
s = "notepad.exe c:\dir.dat"
Shell (s, vbNormalFocus)
End Sub
Als optionales Argument akzeptiert Shell() die Fenster-Steuerung für das erzeugte Programmfenster. Ohne Argument (default) wird das Fenster im Hintergrund erzeugt. Mit der Konstante vbNormalFocus wird das Fenster im Vordergrund angezeigt. Weitere Optionen finden sie in der VBA-Hilfe.
s = "dir c:"
Shell ("" & s, vbNormalFocus)
Shell()-Befehle werden asynchron ausgeführt.
Das bedeutet: Ein VBA-Programm wird mit der nächsten Programmzeile weiter ausgeführt, noch bevor das mit Shell ausgelöste Programm beendet ist.
Eine synchrone Ausführung ist vermutlich nicht möglich, kann aber mit einem Trick erreicht werden: Shell() gibt die Task-ID des gestarteten Prozesses zurück. Diesen kann man in einer Schleife oder mit einem Timer so lange lesen, bis der Prozess beendet wurde. Das erfordert jedoch API-Zugriff und geht damit über den Rahmen dieses Kapitels hinaus.
taskid = Shell ("dauert_lange.exe")
MsgBox "Bin schon weiter"
Die Umleitung der Ausgabe an das VBA-Programm scheint zumindest in einfacher Form nicht vorgesehen. Um den Ausgabe-Text zu analysieren, schreiben sie diesen in eine Text-Datei und lesen sie anschließend.

Da Shell() asynchron arbeitet, muss man zunächst warten, bis die Ausgabe-Datei verfügbar ist. Man kann z.B. in einer While-Schleife warten, sollte diese allerdings gegen Endlos-Durchlauf absichern.
♦ Details zum FileSystemObject im Kapitel Datei-IO mit VBA.
temp = "c:\_temp.txt"
Shell ("dir c: > " & temp)
Set fso = CreateObject("Scripting.FileSystemObject")
exist = False
While (Not exist)
exist = fso.fileexists(temp)
Wend
Open temp For Input As #FileNum
While (Not EOF(FileNum))
Line Input #FileNum, zeile
' Text-Zeile verarbeiten
Wend
Close #FileNum
Shell ("del " & temp)

ActiveX

Diese Technik (nur auf Windows) kann nicht nur von VBA verwendet werden, sondern auch von → VBScript oder → JavaScript und damit von jeder Webseite. Allerdings sind die Sicherheits-Einrichtungen meist so eingestellt, dass der Zugriff durch Webseiten beschränkt ist.
Damit ist es u.a. möglich, beliebige Programme zu starten:
Mit Befehl cmd.exe oder cmd lässt sich eine Konsole starten. Wenn zusätzlich Argumente (commandline-arguments) im Befehl enthalten sind, dann werden diese an die Konsole weitergegeben, d.h. ausgeführt:
Beispiel:
cmd /K c: & DIR/A:HS > spy.dat
erstellt eine Liste der 'hidden' und 'system'-Dateien im Verzeichnis C:\ und speichert sie in der Datei spy.dat
♦ Details zur (riskanten) Anwendung von ActiveX auf Webseiten. 		Beispiel: ActiveX mit VBA:
Set axo = CreateObject("WScript.Shell")
'Set axo = CreateObject("Scripting.FileSystemObject")
s = "cmd /K dir c:>dirc.txt"
axo.Run(s, 1, True)

Beispiel: ActiveX mit Javascript
<script type="text/javascript">
var axo = new ActiveXObject('WScript.Shell');
//var axo = new ActiveXObject('WScript.Network');
s = "cmd /K c: & DIR/A:HS>spy.dat ";
axo.Run(s);
</script>
♦ Mehr über VBA im VBA-Kapitel dieses Webs.

cmd.exe - Optionen der Windows-Konsole
Bei der Erteilung von Befehlen kann man die Optionen der Windows-Konsole ausnutzen:
Optionen beim Start von cmd.exe:
/C Führt den Befehl aus und endet dann.
/K Führt den Befehl aus und endet dann nicht - Das Konsolen-Fenster bleibt offen, man kann das Ergebnis ablesen. 		Details zu den vielen Optionen von cmd.exe erhalten sie mit dem Konsolen-Befehl
C:\> cmd /?
oder besser gleich
C:\> cmd /? > c:\cmd_help.txt
C:\> notepad.exe c:\cmd_help.txt

Verknüpfung

Man kann auch zu einem Konsolen-Befehl oder -Programm eine Verknüpfung (Alias, SoftLink) anlegen. Solche Verknüpfungen können am Desktop oder im Menü Start | Programme sinnvoll sein. Eine direkte Verknüpfung wird zwar ausgeführt, jedoch so schnell wieder geschlossen, dass man den Text nicht lesen kann.

• Rechtsklicken sie in das gewünschte Verzeichnis (z.B. in den Dekstop) und verwenden sie den Befehl Neu | Verknüpfung
Geben sie als Speicherort an: cmd.exe
Geben sie einen beliebigen Namen an, z.B. test
Die fertig gestellte Verknüpfung sollte bereits automatisch das schwarze Icon der Konsole erhalten.
test
• Rechtsklicken sie die neu erstellte Verknüpfung und wählen sie Eigenschaften
Im Feld 'Ziel' ist bereits das Konsolen-Programm eingetragen, z.B.
%windir%\system32\cmd.exe
• Fügen sie am Ende die Option /K und danach den gewünschten Konsolen-Befehl an, z.B.
%windir%\system32\cmd.exe /K ipconfig
• Der im Feld 'Ausführen in' automatisch eingetragene Pfad ist nur selten sinnvoll. Ändern sie ihn nach Bedarf, z.B. auf C:\

● Die Verknüpfung ist nun fertig gestellt: Beim Anklicken öffnet sich ein Konsolen-Fenster, das eingetragene Programm (hier ipconfig) wird ausgeführt und das Fenster bleibt offen.
Man kann mehrere Befehle in einer einzigen Zeile eingeben. Sie werden voneinander mit dem Zeichen & getrennt. Verwechseln sie das Trennzeichen (innerhalb der " ") nicht mit dem VBA-Operator & für die Verkettung von Strings.
Für komplexe Beispiele ist es jedoch übersichtlicher, eine → Script-Datei (*.cmd) zu erstellen. 		Beispiel (VBA) für das Erteilen mehrerer Befehle in einer Befehlszeile:
s = "echo start"
s = s & " & date/T"
s = s & " & time/T"
s = s & " & echo stop"
Shell "cmd.exe /K " & s, vbNormalFocus

Ausgewählte Optionen der Linux Shell-Konsole
Linux bietet die Auswahl unter mehreren Konsolen-Programmen. Als Standard wird meist ein Alias zur Shell-Konsole bin/sh eingesetzt.
Die Linux-Shell wird von fortgeschrittenen AnwenderInnen wesentlich öfter verwendet als die Windows-Konsole. Allerdings ist es wegen der Vielfalt möglicher Betriebssysteme, Programme und Konfigurationen schwierig, ein einfaches Rezept anzugeben (Auf Windows gibt es nur 1 Desktop-Programm, das man zwangsweise verwenden muss). 		Details zu den vielen Optionen erhalten sie mit dem Konsolen-Befehl
# man sh
Im Manual navigieren sie mit den Pfeiltasten, oder verlassen es mit Taste q

SoftLink

So legt man einen SoftLink (Verknüpfung, Alias) zu einem Linux Konsolen-Programm: Das Konsolen-Fenster wird je nach Desktop-Programm mit konsole (K-Desktop) oder terminal (Gnome) adressiert.

Es ist - je nach Desktop und Konfiguration - oft nicht mehr vorgesehen, Desktop-Icons anzulegen. Wenn möglich (evtl. in einem Panel oder Menü), dann erhalten sie mit Rechtsklick Möglichkeiten wie z.B. Create new | Link to Location (URL)
In jedem Fall können sie mindestens den Namen des Alias-Objekts und den auszuführenden Befehl angeben, und mindestens nachträglich kann man auch ein Icon zuweisen.
Tragen sie als Befehl ein: Name des Konsolen-Programms, Option (z.B. -noclose) und zuletzt das auszuführende Konsolen-Programm, z.B.
konsole -noclose -e ifconfig

● Das Alias ist nun fertig gestellt: Beim Anklicken öffnet sich ein Konsolen-Fenster, das eingetragene Programm (hier ifconfig) wird ausgeführt und das Fenster bleibt offen.
• Wenn der Befehl ifconfigfür normale User nicht zugelassen ist, dann verwenden sie z.B.
# ip addr show
# ip addr show | grep 'inet '

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Konsole   >   System-Befehle