Win32 Systemprogrammierung

Transcription

Begrüßung
Fachhochschule Wiesbaden
Lehrveranstaltung: Systemprogrammierung
Prof. Dr. Weber
Christian Geiler [email protected]
Daniel Pielok [email protected]
Fouad Aberkane [email protected]
30.01.2009
1
Inhaltsverzeichnis
Kapitel 1
1. Einführung
2. Dateisysteme
3. I/O Systemaufrufe
4. Mutex/File Locking
30.01.2009
2
1.1 Einführung
WinApi
Ausgeschrieben steht WinAPI fürWindows Application
Programming Interface.Zu dt. bedeutet es Windows
Anwendungs-Programmierungs- Schnittstelle.Die
WinApi ist nix anderes als eine Programmierschnittstelle
und Laufzeitumgebung. Mit dieser Api kann man
Anwendungsprogrammen für Microsoft WindowsBetriebssysteme erstellen
30.01.2009
3
1.1 Einführung
WinApi
Die existierenden Funktionen der WinAPI sind
ausschließlich in der Programmiersprache C und
Assembler geschrieben.Die Funktionen befinden sich in
Bibliotheken, den sogenannten DLL-Dateien, wie
beispielsweise kernel32.dll, user32.dll und gdi32.dll. Die
Api kann in Verbindung mit C, C++ oder Delphi
eingesetzt werden.
30.01.2009
4
1.1 Einführung
Versionen
Win16 war die erste API, für die 16-Bit Versionen von
Microsoft Windows. Gängiger Begriff war schlicht
Windows API, wurde aber später umbenannt in Win16,
um sie von der neueren Windows API der 32-BitArchitektur unterscheiden zu können. Die Funktionen
der Win16 API liegen hauptsächlich im Kern des
Betriebssystems: kernel.exe (oder krnl286.exe oder
krnl386.exe), user.exe und gdi.exe. Trotz der
Dateiendung exe sind diese Dateien tatsächlich
sogenannte Programmbibliotheken.
30.01.2009
5
1.1 Einführung
Versionen
Win32 ist die 32-Bit-API für moderne Versionen von
Windows. Die API besteht aus Funktionen, die, wie bei
Win16, in Programmbibliotheken implementiert sind.
Die Kern-DLLs von Win32 sind kernel32.dll, user32.dll
und gdi32.dll. Win32 wurde mit Windows NT eingeführt.
Die Version von Win32, die mit Windows 95 ausgeliefert
wurde, lief ursprünglich unter dem Namen Win32c,
wobei das 'c' für Kompatibilität (engl. compatibility)
stand, aber dieser Ausdruck wurde später von Microsoft
zugunsten von Win32 wieder verworfen.
30.01.2009
6
1.1 Einführung
Versionen
Win32s ist die 32-Bit-API für die Windows 3.1x-Familie
von Microsoft Windows und als solche die 32-BitErweiterung für die ansonsten 16-bittigen
Betriebssysteme. Das „s“ steht für Teilmenge (engl.:
„subset“). Dabei wurden die Funktionsbibliotheken aus
Windows NT nicht komplett übernommen, sondern
lediglich eine Auswahl daraus, so ist beispielsweise MS
Office 97 unter Windows NT 3.51 lauffähig, nicht jedoch
unter Windows 3.1x. In Kombination mit
Grafikschnittstellen wie OpenGL oder Video for Windows
sollte damit jedoch bis zum Erscheinen von Windows 95
ein ausreichender Standard für Heimanwender gesetzt
werden.
30.01.2009
7
1.1 Einführung
Versionen
Win32 für 64-Bit-Windows, auch bekannt unter dem
Namen Win64, ist die Version der API die für 64-BitVersionen von Windows – namentlich Windows XP „x64
Edition“, Windows Server 2003 „x64 Edition“ (für
AMD64 Prozessoren), Windows XP 64-Bit Edition und
Windows Server 2003 für Itanium-Serien - entworfen
wurde. Bei den 64-Bit-Versionen handelt es sich nur um
zwei weitere unterstützte Plattformen innerhalb der
Windows-NT-Architektur, so dass sowohl die 32-Bit- als
auch die 64-Bit-Version einer Anwendung aus
demselben Quellcode kompiliert werden können.
30.01.2009
8
1.2 Dateisysteme
Dateisysteme
Das Dateisystem ist die Ablageorganisation auf einem
Datenträger eines Computers. Dateien müssen gelesen,
gespeichert oder verschoben werden. Für den
Menschen müssen Dateiname und computerinterne
Dateiadressen in Einklang gebracht werden. Das leichte
Wiederfinden und das sichere Abspeichern ist
wesentlich. Das Ordnungs- und Zugriffssystem
berücksichtigt die Geräteeigenschaften und ist
normalerweise Bestandteil des Betriebssystems.
30.01.2009
9
1.2 Dateisysteme
Welche Dateisysteme gibt es?
FAT16
FAT32
HPFS
NTFS
NetWare
ISO 9660 (CD-ROM) und ISO 13346 (DVD)
UDF
ReiserFS, ext, ext2, ext3, XFS, JFS
30.01.2009
10
1.2 Dateisysteme
Betriebssysteme & Dateisysteme
Die Betriebssysteme Windows 95 bis Windows ME
benutzen ausschließlich FAT16 & FAT32 Systeme. Die
folgenden Systeme Windows NT / 2000 / XP benutzen
NTFS. Anders als bei Windows Betriebssystemen
benutzt Unix/Linux ext2, ext3, ReiserFS, XFS, JFS.
30.01.2009
11
1.3 I/O Systemaufrufe
Systemaufrufe
Ein Systemaufruf ist eine vom Anwendungsprogrammen
benutzte Methode, um vom Betriebssystem
bereitgestellte Funktionalitäten
auszuführen.Systemaufrufe werden im Quellcode wie
Bibliotheksfunktionen aufgerufen. Jedoch die Leistung
solch eines Systemaufrufs wird im Kern des
Betriebssystems erbracht. Ein Systemaufruf führt
Assemblercode und C Code aus. In der folgenden
Abbildung wird ein Systemaufruf schematisch
dargestellt.
30.01.2009
12
Ablauf
In der Definition der Funktion
write befindet sich
C/Assemblercode
diese Zeilen haben die
Aufgabe den Adressraum
zu wechseln und zwar
vom Adressraum des Prozesses
in den Adressraum des Kern's
30.01.2009
13
Systemaufruf Beispiele
Unix
Win32
Beschreibung
open
CreateFile
Neue Datei erzeugen oder Datei öffnen
close
CloseHandle
Datei schließen
read
ReadFile
Daten aus einer Datei lesen
write
WriteFile
Daten in eine Datei schreiben
lseek
SetFilePointer
Warten auf ein Ereignis
stat
GetFileAttributes
Dateizeiger bewegen
unlink
DeleteFile
Datei löschen
mkdir
CreateDirectory
Neues Verzeichnis erzeugen
rmdir
RemoveDirectory
Leeres Verzeichnis löschen
30.01.2009
14
CreateFile
Die Funktion CreateFile erzeugt eine Datei der
Rückgabewert dieser Funktion ist ein Handle womit man
später die Datei eindeutig identifizieren kann.
HANDLE CreateFile (
LPCTSTR lpFileName, /*Name der Datei*/
DWORD dwDesiredAccess, /*Lesen, Schreiben, Beides*/
DWORD dwShareMode, /*Share Modus für Prozesse*/
[LPSECURITY_ATTRIBUTES lpSecurityAttributes,]
DWORD dwCreationDisposition, /*Überschreiben, Öffnen...*/
DWORD dwFlagsAndAttributes, /*Schreibgesch., Versteckt*/
[HANDLE hTemplateFile]);
30.01.2009
15
ReadFile
Die Funktion ReadFile liest aus einer gegebenen Datei
mithilfe eines HANDLE's.
BOOL ReadFile (
HANDLE hFile, /*Das Objekt das gelesen werden soll*/
LPVOID lpBuffer,/*Buffer*/
DWORD nNumberOfBytesToRead, /*Anzahl Max. Bytes*/
LPDWORD lpNumberOfBytesRead, /*Wirkl. gel. Bytes*/
[LPOVERLAPPED lpOverlapped]);
30.01.2009
16
CloseFile
Die Funktion CloseFile schließt eine Datei.
BOOL CloseFile (HANDLE hFile);
30.01.2009
17
Lese Beispiel
#include<windows.h>
#define SOURCE source.txt
#define MAXREADSIZE 1024
int main(int argc, char **argv[]) {
HANDLE hread;
DWORD readsize;
char buffer [MAXREADSIZE];
hread = CreateFile(SOURCE, GENERIC_READ, 0, NULL,OPEN_EXISTING, 0, NULL);
/*Mögliche Fehler abfangen*/
ReadFile (hread, buffer, MAXREADSIZE, &readsize, NULL);
/*Mögliche Fehler abfangen*/
printf(„%s“, buffer);
CloseFile(hread);
30.01.2009
18
1.4 Mutex
Mutex
Mutex bedeutet Wechselseitiger Ausschluss
(mutual exclusion).Ein Mutex ist nix anderes als eine
Gruppe von Verfahren mit denen das Problem des
kritischen Abschnitts gelöst wird.Damit wird verhindert,
dass nebenläufige Prozesse gleichzeitig oder zeitlich
verschränkt gemeinsam genutzte Datenstrukturen
unkoordiniert verändern. Zu dieser Gruppe gehören zB.
Semaphore, Monitore, Lock.
30.01.2009
19
1.4 File Locking
File Locking
Das File Locking ist einfaches Prinzipe das
folgendermaßen vorgeht nach dem dem Öffnen einer
Datei für andere automatisch gesperrt. Es ist notwendig
damit zwei Nutzer nicht gleichzeitig eine Datei
manipulieren.Es kann immer nur ein Anwender bzw.
immer nur ein Anwendungsprogramm zu einer Zeit die
Datei manipulieren. File Locking wird in
Netzwerkumgebungen oder auf multitaskingfähigen
Systemen wie beispielsweise Windows-Rechnern
eingesetzt
30.01.2009
20
1.4 File Locking
LockFile
Die WinApi stellt die Funktionalität für das File Locking
zur Verfügung mit der Methode LockFile kann man eine
ganze Datei oder bestimmte Abschnitte in Bytes für
andere Prozesse sperren.
BOOL WINAPI LockFile(
HANDLE hFile, /*Datei*/
DWORD dwFileOffsetLow, /*Offset*/
DWORD dwFileOffsetHigh, /*Offset*/
DWORD nNumberOfBytesToLockLow, /*Lock bytes*/
DWORD nNumberOfBytesToLockHigh /*Lock bytes*/
);
30.01.2009
21
1.4 File Locking
UnlockFile
Natürlich muss die gesperrte Datei bzw. der Abschnitt
wieder für andere Prozesse zugänglich sein dafür gibt’s
die Funktion UnlockFile sie besitzt dieselben argumente
wie die Funktion LockFile.
BOOL WINAPI UnlockFile(
HANDLE hFile, /*Datei*/
DWORD dwFileOffsetLow, /*Offset*/
DWORD dwFileOffsetHigh, /*Offset*/
DWORD nNumberOfBytesToUnlockLow, /*Unlock bytes*/
DWORD nNumberOfBytesToUnlockHigh /*Unlock bytes*/
);
30.01.2009
22
1.4 File Locking
File Locking Beispiel
#include<windows.h>
#define ANFANG 10
#define ENDE 20
HANDLE hFile;
hFile = CreateFile(TEXT("two.txt"),
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
/* Datei öffnen*/
/* Datei lesen*/
/* Mehrfache Lesen*/
/* Security Atrribut wird nich gebraucht */
/* Öffnen oder erstellen*/
/* Normale Datei*/
/* Kein Template*/
/*Fehler abfangen*/
LockFile(hFile, ANFANG, 0, ENDE, 0);
/*Datei lesen*/
UnlockFile(hFile, ANFANG, 0, ENDE, 0);
30.01.2009
23
Inhaltsverzeichnis
Kapitel 2
1. Windows Registry
2. Fehlerbehandlung
3. Windows Sockets
30.01.2009
24
2.1 Windows Registry
Registry
Zentrale, hierarchische Datenbank für Applikations- und
Konfigurationsinformationen
Registry-Editor wird durch den „regedit“ Befehl geöffnet
auf der Kommandozeile
Zugriff durch Schlüssel
Programme kommunizieren mit der Registry durch
Registry API Funktionsaufrufe
Registry-Programmierung ähnlich zur Dateiverarbeitung
30.01.2009
25
Registry
Registry enthält folgende Informationen:
Betriebssystem-Versionsnr., Build-Nr. und registrierte User
ähnliche Informationen für jede installierte Applikation
Hardware-Informationen über Prozessortyp, Anzahl an
Prozessoren, Arbeitsspeicher, etc.
Benutzerspezifische Informationen (Home-Verzeichnis,
bevorzugte Anwendungen)
installierte Services
Mappings von Dateiendungen zu deren ausführbaren
Programmen und Mappings von Netzwerkadressen zu
deren Hostnamen
30.01.2009
26
Registry
30.01.2009
27
Registry-Schlüssel
HKEY_LOCAL_MACHINE – Informationen über den
Rechner und darauf installierte Software
HKEY_USERS – Informationen über BenutzerKonfigurationen
HKEY_CURRENT_CONFIG – Informationen wie
Bildschirmauflösung und Schriftarten
HKEY_CLASSES_ROOT – Mappings von Dateiendungen
zu deren Anwendung
HKEY_CURRENT_USER – Benutzerspezifische
Informationen (Umgebungsvariablen, Drucker, ...)
30.01.2009
28
Registry API Calls
RegOpenKeyEx - vorhandenen Key öffnen
RegDeleteKeyEx - vorhandenen Key löschen
RegCreateKeyEx - neuen Key erzeugen
RegEnumKeyEx - Auflisten aller Subkeys im geöffneten
Key
RegSetValueEx – Setzen eines Name/Wert-Paares im
geöffneten Key
RegEnumValue - Auflisten aller Values im geöffneten
Key
30.01.2009
29
RegOpenKeyEx
LONG RegOpenKeyEx (
HKEY hKey,
/* Parent Key-Handle */
LPCTSTR lpSubKey,
DWORD ulOptions,
/* Name des Subkeys */
/* = 0 */
REGSAM samDesired,
PHKEY phkResult);
30.01.2009
/* Zugriffsrechte */
/* Key-Handle des neu geöffneten Keys*/
30
RegOpenKeyEx Beispiel
#include <windows.h>
HKEY hKey = Null;
/* Schlüssel öffnen */
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,
L“Software\\Alias\\Common“, 0, KEY_READ, &hKey)) {
}
printf(“Fehler beim Öffnen des Keys“);
30.01.2009
31
RegEnumKeyEx
LONG RegEnumKeyEx (
HKEY hKey,
DWORD dwIndex,
LPTSTR lpName,
/* Indexwert */
/* Name des Schlüssels */
LPDWORD lpcbName,
/* Größe des Keynamen*/
LPDWORD lpReserved,
LPTSTR lpClass,
/* reserviert */
/* Klassenname */
LPDWORD lpcbClass,
/* Größe des Klassennames*/
PFILETIME lpftLastWriteTime);
30.01.2009
/*Zeit des letzten Schreibens*/
32
RegCreateKeyEx
LONG RegCreateKeyEx (
HKEY hKey, LPCTSTR lpSubKey,
DWORD Reserved,
LPTSTR lpClass,
/* = 0 */
/* Typ des neuen Keys */
DWORD dwOptions,
REGSAM samDesired,
/* Zugriffsrechte */
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
PHKEY phkResult, LPDWORD lpdwDisposition);
30.01.2009
33
RegCreateKeyEx Beispiel
HKEY hKey = Null;
DWORD dwDisp = NULL;
/* Schlüssel mit Schreibrechten erzeugen */
if (ERROR_SUCCESS != RegCreateKeyEx(HKEY_LOCAL_MACHINE,
L“SYSTEM\\CurrentControlSet\\Services\\EventLog\\MyLog“,
0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE,
NULL, &hKey, &dwDisp)) {
}
printf(“Fehler beim Erzeugen des Keys“);
30.01.2009
34
Values in der Registry
Values sind typisiert
Einige Typen:
REG_BINARY – Binärdaten
REG_DWORD – 32 Bit Zahlen
REG_SZ – Strings
REG_EXPAND_SZ – Strings mit Verweisen auf
Umgebungsvariablen
30.01.2009
35
RegSetValueEx
LONG RegSetValueEx (
HKEY hKey,
/* Key-Handle */
LPCTSTR lpValueName,
DWORD Reserved,
DWORD dwType,
/* = 0 */
/* Datentyp des Values */
CONST BYTE * lpData,
DWORD cbData);
30.01.2009
/* Name des Values */
/* Daten (Value) */
/* Größe der Daten */
36
RegSetValueEx Beispiel
HKEY hKey = Null;
wchar_t *value = L“New Registry Value“;
/* Key öffnen oder neu erzeugen */
...
/* Wert setzen */
if (ERROR_SUCCESS != RegSetValueEx(hKey, L“MyValue“, 0,
REG_SZ, (LPBYTE) value,
(DWORD) ((lstrlen(value)+1) * sizeof(TCHAR))) {
}
printf(“Fehler beim Setzen des Wertes“);
30.01.2009
37
RegEnumValue
LONG RegEnumValue (
HKEY hKey,
DWORD dwIndex,
/* Indexwert */
LPTSTR lpValueName,
/* Name des Values */
LPDWORD lpcbValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
/* reserviert */
/* Typ des Values */
/* der zurückgegebene Wert */
LPDWORD lpcbData);
30.01.2009
/* Größe des Valuenamens */
/* Größe des Rückgabewertes */
38
2.2 Fehlerbehandlung
Fehlerbehandlung
Win32 Structured Exception Handling (SEH)
Exceptions, Arithmetikfehler und Systemfehler
SEH Support durch Win32 Funktionen, Sprachensupport
des Compilers und Run-Time Support
Beispiele für Fehlerbehandlungen:
Array-Out-Of-Bound-Exceptions
Pointer Dereferenzierung
Division durch Null
30.01.2009
39
Try / Except
ähnlich zum gewöhnlichen try-catch-Block:
__try {
/* Code, der einen Fehler werfen könnte */
}
__except (filter expression) {
/* Fehlerbehandlung */
}
Filter expression: nur auf bestimmte Fehlerereignisse im
except-Block reagieren
30.01.2009
40
Filterexpressions
Filterexpression in __except Anweisung wird direkt nach
Auftreten der Exception überprüft
normalerweise eine Konstante, eine Filterfunktion oder
ein konditionaler Ausdruck, wobei immer einer der
folgenden drei Typen zurückgegeben werden muss:
EXCEPTION_EXECUTE_HANDLER
EXCEPTION_CONTINUE_SEARCH
EXCEPTION_CONTINUE_EXECUTION
30.01.2009
41
Exceptions Beispiel 1
GetTempFileName (TempFile, ...);
while (...) __try {
/* Datei erzeugen */
hFile = CreateFile (TempFile, ..., OPEN_ALWAYS, ...);
SetFilePointer (hFile, 0, NULL, FILE_END);
…
/* in Datei schreiben */
WriteFile (hFile, ...);
/* hier kann ein Addressierungsfehler auftreten!!! */
i = *p;
...
CloseHandle (hFile);
}
__except (EXCEPTION_EXECUTE_HANDLER) {
CloseHandle (hFile);
DeleteFile (TempFile);
}
/* Datei am Ende immer geschlossen*/
30.01.2009
42
Fehlercodes
DWORD GetExceptionCode (VOID);
Funktion gibt Fehlercode zurück → Reagieren auf
bestimmte Fehlerereignisse möglich
einige wichtige Fehlercodes:
EXCEPTION_ACCESS_VIOLATION
EXCEPTION_NONCONTINUABLE_EXECUTION
EXCEPTION_INT_DIVIDE_BY_ZERO
EXCEPTION_BREAKPOINT
30.01.2009
43
Exceptions Beispiel 2
__try {
...
i = j / 0;
...
}
__except (Filter (GetExceptionCode ())) {
...
}
/* Filter Funktion, die auf bestimmte Fehler
DWORD Filter (DWORD ExCode) {
switch (ExCode) {
...
case EXCEPTION_INT_DIVISION_BY_ZERO:
...
return EXCEPTION_EXECUTE_HANDLER;
case ...
}
}
30.01.2009
reagiert*/
44
2.3 Windows Sockets
Windows Sockets
dienen der Interprozess-Kommunikation
fast identisch zu Berkeley Sockets
Initialisierung der WinSock API:
int WSAStartup (
30.01.2009
WORD wVersionRequired,
/* Socket Version
(Minimum) */
LPWSADATA lpWSAData);
/* Pointer zu WSADATA
Struct */
45
2.3 Windows Sockets
Sockets (TCP)
Quelle: Folienbeispiel von Herr Weber
30.01.2009
46
2.3 Windows Sockets
Sockets – socket, bind
Socket erzeugen:
SOCKET socket (int af,
int type,
/* Adress-Familie */
/* Typ des Sockets (DGRAM, STREAM) */
int protocol);
/* Protokoll */
Server: binden eines Sockets an einen Port:
int bind (SOCKET s,
/* Socket-Handle */
const struct sockaddr *saddr,
int namelen);
30.01.2009
/* Adresse/Port */
/* Größe der Adresse */
47
2.3 Windows Sockets
Sockets - sockaddr_in
sockaddr_in Struktur bei AF_INET verwenden:
struct sockaddr_in {
short sin_family;
/* AF_INET */
u_short sin_port;
/* Portnummer */
struct in_addr sin_addr;
char sin_zero [8];
/* 4-Byte IP-Adresse */
/* optional */
}
30.01.2009
48
2.3 Windows Sockets
Sockets - listen
Struktur sin_addr besitzt eine Variable s_addr, die die IP
Adresse speichert
Bsp.:
sa.sin_addr.s_addr = inet_addr (“192.13.12.1“);
Server: Socket auf Akzeptieren von Clients vorbereiten:
int listen (
SOCKET s,
/* Socket-Handle */
int nQueueSize);
30.01.2009
/* Größe der Warteschlange an
Clients*/
49
2.3 Windows Sockets
Sockets – accept, connect
Server: Warten auf Verbindungsanfrage:
SOCKET accept (SOCKET s,
LPSOCKADDR lpAddr,
LPINT lpAddrLen);
/* Socket-Handle */
/* Definition von Port und
Adresse */
Client: Verbindung aufbauen:
int connect (SOCKET s,
LPSOCKADDR lpAddr,
int nAddrLen);
30.01.2009
/* Socket-Handle */
/* Definition von Port und
Adresse */
50
2.3 Windows Sockets
Sockets – recv, send
Empfangen von Daten:
int recv ( SOCKET s,
/* Socket-Handle */
LPSTR lpBuffer, int nBufferLen,
/*Puffer und -größe*/
int nFlags);
Senden von Daten:
int send ( SOCKET s,
/* Socket-Handle *
LPSTR lpBuffer, int nBufferLen,
/*Puffer und -größe*/
int nFlags);
30.01.2009
51
2.3 Windows Sockets
Server Beispiel
#include <winsock.h>
struct sockaddr_in SrvSAddr,ConnectAddr;
SOCKET SrvSock, sockio;
...
SrvSock = socket (AF_INET, SOCK_STREAM, 0);
SrvSAddr.sin_family = AF_INET;
SrvSAddr.sin_addr.s_addr = htonl (INADDR_ANY);
SrvSAddr.sin_port = htons (SERVER_PORT);
/* Socket an Adresse binden */
bind (SrvSock, (struct sockaddr *) &SrvSAddr, sizeof (SrvSAddr);
listen (SrvSock, 5);
AddrLen = sizeof (ConnectAddr);
/* Client Verbindung akzeptieren*/
sockio = accept (SrvSock, (struct sockaddr *) &ConnectAddr,
&AddrLen);
...
/* Daten empfangen*/
ret = recv (sockio, buffer, sizeof(buffer), 0);
...
closesocket (sockio);
30.01.2009
52
2.3 Windows Sockets
Client Beispiel
#include <winsock.h>
SOCKET ClientSock;
…
/* Socket erzeugen */
ClientSock = socket (AF_INET, SOCK_STREAM, 0);
memset (&ClientSAddr, sizeof (ClientSAddr), 0);
ClientSAddr.sin_family = AF_INET;
ClientSAddr.sin_addr.s_addr = inet_addr (argv[1]);
ClientSAddr.sin_port = htons (SERVER_PORT);
/* Verbindung zu Server aufbauen */
ret = connect (ClientSock, (struct sockaddr *) &ClientSAddr,
sizeof (ClientSAddr));
...
/* Daten senden */
ret = send (ClientSock, buffer, sizeof(buffer), 0);
...
/* Socket und Verbindung schliessen*/
shutdown (ClientSock);
closesocket (ClientSock);
30.01.2009
53
Inhaltsverzeichnis
Kapitel 3
1. Win32 Adressraum
2. Virtuelle Adressierung
3. Heaps
4. Memory Mapped Files
5. Bibliotheken
6. Prozesse
30.01.2009
54
3.1 Win32 Adressraum
32-Bit Adressraum
32-Bit Zeiger (z.B.: LPCTSTR, LPDWORD...)
4GB adressierbarer Speicher
RING 0: Kernel-Mode, Prozesse können die vollen 4GB adressieren.
RING 3: User-Mode, Prozesse können nur 2-3 GB adressieren
(versionsabhängig). Der Rest ist exklusiv für Kernel, Gerätetreiber, DLL‘s
also für von mehreren Diensten genutzten Code Reserviert.
30.01.2009
55
3.2 Virtuelle Adressierung: Einführung I
Rechtfertigung: nicht alle Teile eines Programms werden immer
gleichzeitig benötigt
Funktionsweise:
- virtueller Speicher ist in „Seiten“ aufgeteilt.
- physikalischer Speicher ist in gleich große „Rahmen“ aufgeteilt.
- Zuordnung von Seiten zu Rahmen (Mappen).
- Auslagern von Rahmen (Swapen)
- Seitentausch-Strategien (swapen dann mappen):
random=schwach, RR=fair, FIFO=Sehr fair
30.01.2009
56
3.2 Virtuelle Adressierung: Einführung II
Vorteil:
Es ist mit nur 32MB physical Memory möglich einen 1GB Prozess laufen zu
lassen. Dazu werden die aktuell benötigten Speicherbereiche in den RAM
geladen und nicht benötigte aus diesem verdrängt .
Funktionen auf Seiten-Basis:
VirtualAlloc, VirtualFree, VirtualLock, VirtualUnlock ...
Funktionen auf definierbarer Basis (byte, word,...):
HeapAlloc, HeapCreate, HeapDestroy, HeapFree...
30.01.2009
57
3.2 Memory Management Architecture
Windows Program
C library: malloc, free
Heap API: H e a p C r e a t e ,
H e a p D e s t r o y ,
MMF API:
H e a p A l l o c , H e a p C F r re ea et e F
C r e a t e V
Virtual Memory API
i l e M
a p p i n
i e w O f F i l e
g
,
Windows Kernel with
Virtual Memory Manager
Disc &
File
System
Physical
Memory
30.01.2009
58
3.3 Heaps: Einführung
Ein Heap (engl: Haufen) ist ein Speichervorrat, welcher dem Stack (lokaler
Prozedur-Speicher) entgegen wächst.
Jeder Prozess besitzt min. einen Default-Heap.
Speicheranforderungen durch malloc, realloc, calloc, werden vom DefaultHeap abgezogen.
Jeder Heap wird automatisch bis zur definierten Obergrenze erweitert =>
und immer auf ganze Seiten gerundet.
Ein Heap in Windows ist ein Objekt somit existiert zu diesem ein Handle:
HANDLE GetProcessHeap(VOID)
30.01.2009
59
3.3 Heaps: Beispiel separater Heaps
Program
Virtual Address Space
Not allocated
P
Process
Heap
r o c H
p R
o o t
Not allocated
R
RecHeap
w
e a p
e c H
NodeHeap
e a p
o d e H
Record
h i l e
( ) {
pRecord
R e c
= H
· · ·
Node
Node
Node
Not allocated
e t P
r o c e s s H
e a p A l l o c
· · ·
RecordN
p allocated
N o d e
Not
}
= H
= G
= H
= H
(R
l l o c
e c H
(N
( );
e a p );
( );
e a p C r e a t e
l l o c
e a p A
r o c H
e a p C r e a t e
e a p = H
· · ·
e a p A
(P
e a p
( );
e a p );
o d e H
e a p );
H e a p F r e e
(R e c H e a p , 0 ,
· · ·
p R e c );
H e a p F r e e
(N o d e H e a p , 0 ,
p N o d e );
H e a p D e s t r o y
(R e c H e a p );
30.01.2009
H e a p D e s t r o y
(N o d e H e a p );
60
3.3 Heaps: Vorteile separater Heaps
Fairness: kein Thread kann mehr Speicher anfordern als für dessen Heap
reserviert ist. (Memory-Leaks betreffen nur diesen Thread)
Multithreaded-Preformence: Der Wettstreit um den default Heap des
Prozesses entfällt, dies kann substantielle preformence Verbesserung mit
sich bringen.
Allocation Efficency: Speicheranforderungen auf einen kleinen Heap
welche nur in einer bestimmten Größe auftreten sind effizienter als
Anforderungen auf einen großen Heap, welche in den verschiedensten
Größen auftreten. Somit Reduzierung von Fragmentration.
Deallocation Efficeny: Der gesamte Heap kann mit nur einem
Funktionsaufruf beseitigt werden, wobei auch Memory-Leaks beseitigt
werden.
Locality of Reference Efficency: Wird für eine Datenstruktur ein kleiner
Heap verwendet, so wird das Risiko von Page-Faults reduziert, da sich die
Struktur dann nur über wenige Speicherseiten erstreckt.
30.01.2009
61
3.3 Heaps: Optionen der Heap API
HEAP_GENERATE_EXCEPTIONS:
Nutzung eines SEH (StructuredExceptionHandler) zur Fehlerbehandlung.
Vorteil: Kein Fehlertest nach einer Heapoperation notwendig
HEAP_NO_SERIALIZE:
Schaltet Mutal-Exclusion Mechanismus bei zugriff auf Heap aus.
Sicher wenn:
1.) Der Prozess (Hauptthread) exklusiv den DefaultHeap und keinen der Thread-Heaps verwendet.
2.) Jeder Thread exklusiv seinen eigenen Heap besitzt.
sonst:
Bei gleichzeitiger Nutzung eines Heaps durch mehrere
Threads muss ein Mutal-Exclusion Mechanismus
implementiert werden.
HEAP_ZERO_MEMORY:
Angeforderter Speicher wird mit 0 Initialisiert.
30.01.2009
62
3.3 Heaps: Erstellung
HANDLE HeapCreate ( DWORD flOptions,
SIZE_T dwInitialSize,
SIZE_T dwMaximumSize );
Rückgabewerte:
NULL bei fehler sonst Heap-Handle.
Parameter:
- flOptions:
- dwInitialSize:
- dwMaximumSize:
HEAP_GENERATE_EXCEPTIONS,
HEAP_NO_SERIALIZE
Initiale Heapgröße
(wird in der Pagefile reserviert)
Maximale Heapgröße
(wenn nicht 0, kein wachsen möglich)
Anmerkungen:
- dwMaximumSize=0:
- dwMaximumSize<>0:
30.01.2009
bei bedarf gesamter freier virtueller Adressraum
dwMaximumSize wird allokiert aber es wird nur
dwInitialsize in der Pagefile reserviert.
63
3.3 Heaps: Loeschen
BOOL HeapDestroy ( HANDLE hHeap );
Rückgabewerte:
- Erfolg <> 0, sonst Misserfolg
Parameter:
- hHeap: Handle eines mit HeapCreate erstellten Heaps.
Anmerkungen:
- Loeschen eines Heaps
- Der Default-Heap des Prozesses darf niemals zerstört werden.
- Es werden auch die in der Pageing-File ausgelagerten Teile
freigegeben.
- Man kann somit durch nur einen Funktionsaufruf alle allokierten
Datenstrukturen des Heaps löschen => Sehr schnell!
30.01.2009
64
3.3 Heaps: Speicherbereich anfordern
HANDLE HeapAlloc ( HANDLE hHeap,
DWORD dwFlags, SIZE_T dwBytes );
Rückgabewerte:
- NULL bei Fehler (wenn kein SHE)
sonst Zeiger auf Speicherbereich der Größe dwBytes.
Parameter:
- hHeap:
- dwFlags:
- dwBytes :
Handle eines Heaps (GetProcessHeap, HeapCreate)
HEAP_NO_SERIALIZE,
HEAP_ZERO_MEMORY
Speicher in Byte welcher reserviert werden soll.
Anmerkungen:
- Anfordern eines Speicherberiches vom Heap
30.01.2009
65
3.3 Heaps: Speicherbereich freigeben
BOOL HeapFree ( HANDLE
hHeap,
DWORD
LPVOID
dwFlags,
lpMem );
Rückgabewerte:
- Erfolg <> 0, sonst Misserfolg
Parameter:
- hHeap:
- dwFlags:
- lpMem :
Handle eines Heaps (HeapCreate)
HEAP_NO_SERIALIZE,
Zeiger auf einen durch HeapAlloc oder HeapRelloc
allokierten Speicherbereich
Anmerkungen:
- Freigabe eines allokierten Speicherbereiches eines Heaps
30.01.2009
66
LPVOID HeapReAlloc ( HANDLE hHeap, DWORD dwFlags,
LPVOID lpMem, DWORD dwBytes );
3.3
Heaps: Speicherbereichsgröße ändern
Rückgabewerte:
Parameter:
- hHeap:
- dwFlags:
HEAP_NO_SERIALIZE,
HEAP_ZERO_MEMORY (neu allokierter Speicher),
HEAP_REALLOC_IN_PLACE_ONLY (Block nicht verschieben)
- lpMem :
Anmerkungen: allokierten Speicherbereich
- dwBytes :
Speicher in Byte welcher reallokiert werden soll.
- Keine
30.01.2009
67
3.3 Heaps: Speicherbereichsgröße ermitteln
DWORD HeapSize ( HANDLE hHeap, DWORD dwFlags,
LPVOID lpMem );
Rückgabewerte:
- 0 bei Fehler (wenn kein SHE) sonst Größe des Speicherbereiches in
Bytes.
Parameter:
- hHeap:
- dwFlags:
- lpMem :
HEAP_NO_SERIALIZE,
allokierten Speicherbereich
Anmerkungen:
- Ermittelt die Größe eines Speicherbereiches eines Heaps,
nicht die Größe des Heaps!
30.01.2009
68
3.3 Heaps: weitere Funktionen
HeapValidate:
Feststellen ob ein Heap korrupiert wurde.
HeapCompact:
Defragmentieren eines Heaps durch zusammenfassen von freien Blöcken
und freigeben von großen Freibereichen.
HeapWalk:
Ermittelt alle allokierten Speicherbereiche eines Heaps.
HeapLock, HeapUnlock:
Dient Mutal-Exclusion Mechanismen.
30.01.2009
69
3.3 Heaps: Systemaufrufe
Systemaufrufe
UNIX
Win32
Beschreibung
Nur default-Heap
HeapCreate
Erstellt einen Heap
Nicht vorhanden!
HeapDestroy
Löscht einen Heap
malloc
da nur default-Heap
HeapAlloc
Allokiert einen
Speicherbereich vom
Haeap
realloc
Da nur default-Heap
HeapReAlloc
Heap-Speicherbereich
neu dimensionieren.
Nicht vorhanden!
HeapSize
HeapSpeicherbereichgröße.
Nicht vorhanden!
HeapValidate
Heap korrupiert?
Nicht vorhanden!
HeapCompact
Heap defragmentieren
Nicht vorhanden!
HeapWalk
Heapgröße ermitteln
Nicht vorhanden!
HeapLock
Heap sperren (mutal exc.)
Nicht vorhanden!
HeapUnlock
Heap freigabe (mutal exc.)
30.01.2009
70
3.4 Memory-Mapped Files:
Files: Einführung
Rechtfertigung:
- Bei der Virtuellenspeicherverwaltung muss Speicher für Objekte
(Heap-Bereiche) in der Auslagerrungsdatei (Swaping)
bereitgestellt werden.
- Wird ein Prozess terminiert, so geht der zugehörige
Auslagerrungsdateispeicher verloren.
- Lösung: Man nutzt MMF's statt der Auslagerrungsdatei.
Vorteile:
- Ermöglichen das Einblenden eines Objektes in den
virtuellen Adressraum eines Prozesses.
- Für MMF‘s wird keine File-I/O-API benötigt
- Inhalte von Datenstrukturen können wiederverwendet werden.
- Implementierung für Dateipuffer entfällt!
- Bietet die Möglichkeit Daten mit anderen Prozessen zu teilen.
- Die Auslagerungsdatei wird entlastet.
30.01.2009
71
3.4 Memory-Mapped Files: Rechte
Für MMF‘s werden Rechte wie bei Dateien vergeben.
PAGE_READONLY:
Die Seiten des allokierten Speicherbereiches können nur gelesen
werden.
PAGE_READWRITE:
Vollzugriff, die Die Seiten des allokierten Speicherbereiches
können gelesen und beschrieben werden insofern für die
zugehörige Datei sowohl GENERIC_READ als auch GENERIC_WRITE
definiert wurden.
PAGE_WRITECOPY:
Wird die MMF verändert (beschrieben),
so wird eine Kopie dieser in der Pageing-File angelegt.
30.01.2009
72
Files: Erstellen I
HANDLE CreateFileMapping( HANDLE hFile,
LPSECURITY_ATTRIBUTES lpsa,
DWORD fdwProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCTSTR lpMapName );
Parameter:
- hFile: Datei-Handle mit kompatiblen Rechten zu fdwProtect.
- lpsa : Spezielle Zugriffsrechte, für normale Dateien: NULL
(wird z.B.: dann genutzt, wenn das MMF eine EXE-Datei ist)
- fdwProtect :
Zugriffsrechte der MMF siehe HIER
- dwMaximumSizeHigh : Absolute Maximalgröße der MMF,
MMF kann nicht darüber hinaus wachsen!
- dwMaximumSizeLow : Mindestgröße der MMF
- lpMapName: Namensraum, erlaubt den Zugriff von anderen Prozessen aus.
30.01.2009
73
Files: Erstellen II
HANDLE CreateFileMapping( HANDLE hFile,
LPSECURITY_ATTRIBUTES lpsa,
DWORD fdwProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCTSTR lpMapName );
Rückgabewerte:
- NULL bei Fehler sonst MMF-Handle.
Anmerkungen:
- Wenn dwMaximumSizeHigh=0 und dwMaximumSizeLow=0,
dann größe der MMF = Dateigröße
30.01.2009
74
Files: Öffnen
HANDLE OpenFileMapping ( DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCTSTR lpNameP );
Rückgabewerte:
Parameter:
- dwDesiredAccess:
- bInheritHandle:
- lpNameP:
Zugriffsrechte der MMF siehe HIER
Dient der Vererbung des Objektes.
Namensraum welcher durch
CreateFileMapping vergeben wurde.
Anmerkungen:
- Kann mit CloseHandle gelöscht werden.
30.01.2009
75
Files: Einblenden
HANDLE MapViewOfFile ( HANDLE hMapObject, DWORD dwAccess,
DWORD dwOffsetHigh,
DWORD dwOffsetLow, DWORD cbMap);
Rückgabewerte:
- NULL bei Fehler sonst Startadresse der file-view.
Parameter:
- hMapObject:
Handle eines MMF-Objektes.
- dwAccess:
Zugriffsrechte (Kompatibel zu MMF-Objekt wählen!)
- cbMap:
Größe der gemappten Region in Byte.
- dwOffsetHigh, dwOffsetLow: Startadresse der View im Objekt.
Anmerkungen:
- cbMap = 0 => ganzes File Mappen
- dwOffsetHigh und dwOffsetLow = 0 dann vom Dateianfang
mappen, sonst immer ein Vielfaches von 64K wählen
30.01.2009
76
Files: Beispiel
30.01.2009
77
3.4 MMF: Systemaufrufe
Systemaufrufe
UNIX
Win32
Beschreibung
Nicht vorhanden!
CreateFileMapping
Erstellt ein MMF
Nicht vorhanden!
OpenFileMapping
Öffnet eine MMF
mmap
(jede reguläre Datei)
MapViewOfFile
MMF in Addressraum
einblenden.
munmap
UnmapViewOfFile
MMF schließen
30.01.2009
78
3.5 Statische Bibliotheken
Eigenschaften:
beim Kompilationsvorgang werden Bibliothekskomponenten
ins Programm hineinkopiert. (Code und Daten)
Programm ist nach Kompilation unabhängig von der Bibliothek.
(Version bzw. Vorhandensein der Bibliothek)
Programme werden größer (Speicherbedarf!)
Um von Updates zu profitieren, muss das Programm neu kompiliert
werden.
Es findet eine statische Typenkontrolle statt.
Beim Linken des Programmes:
Linker verbindet Statische Bibliotheken mit dem Kompilat.
Linker setzt daraus ein ausführbares Programm zusammen.
Linker sucht aus den Bibliotheksdateien die im Programm referenzierten,
Komponenten heraus, und fügt sie dann in das Programm ein.
30.01.2009
79
3.5 Dynamische Bibliotheken
DLL allgemein:
werden bei bedarf von der Festplatte geladen (Ladeverzögerung!)
Versionswahl zur Laufzeit möglich (explizites linken).
DLL als shared library:
können von mehreren Programmen gleichzeitig benutzt werden
befinden sich nur ein mal im Speicher
DLL-Komponenten werden in den Adressraum des Programms
eingeblendet (gemappt)
30.01.2009
80
3.5 Dyn. Bibliothek erstellen UNIX:
//mydll.cpp
extern "C" int summe( int a, int b )
{
return a + b;
}
#include <stdio.h>
extern "C" void _init( void )
{
printf(„Bibliothek geöffnet“
}
extern "C" void _fini( void )
{
printf(„Bibliothek geschlossen“
}
g++ -Wall -shared mydll.cpp -o libmydll.so
30.01.2009
81
3.5 Dyn. Bibliothek erstellen Windows:
//mydll.cpp
extern "C" __declspec(dllexport) int summe( int a, int b )
{
return a + b;
}
BOOL APIENTRY DllMain( HANDLE ModulHandle, DWORD state, LPVOID lpReserved )
{
switch( state )
{
case DLL_PROCESS_ATTACH:
// Die DLL wird in den Adreßraum eines Prozesses eingeblendet
case DLL_THREAD_ATTACH:
// Der zugehörige Prozeß hat einen neuen thread gestartet.
case DLL_THREAD_DETACH:
// Der zugehörige Prozeß hat einen thread gestoppt.
case DLL_PROCESS_DETACH:
// Die DLL wird aus dem Prozeßraum eines Prozesses entfernt
default: /*ERROR*/ break;
}
return TRUE;
}
cl -LD -GX mydll.cpp
30.01.2009
82
3.5 Dyn. Bibliotheken: implizietes linken
Unter Windows entstehen beim Erzeugen einer DLL zwei Dateien:
lib-Datei: enthält Platzhalter für Programmcode bzw. Daten die sog.„stubs“
dll-Datei: enthält Programmcode bzw. die Daten
Es werden lediglich die Platzhalter in das Programm eingebunden.
Das Programm wird nicht so groß.
Es findet eine statische Typenkontrolle statt.
Beim starten des Programmes:
Benötigte DLL's werden geladen.
Verweise auf Dummyfunktionen im Programm werden ersetzt.
Dann Programmstart.
Beim ausführen des Programmes:
Kein Unterschied.
30.01.2009
83
3.5 Dyn. Bibliotheken: Einbinden (implizietes linken)
Windows oder UNIX:
#include <stdio.h>
extern "C" int summe( int, int );
int main()
{
printf( "Summe von %d und %d ist %d\n",i,i/2,summe( i, i/2 ));
return 0;
}
- Beim impliziten linken ist das Einbinden der Bibliothek für UNIX und
Windows gleich
30.01.2009
84
3.5 Dyn. Bibliotheken: explizites linken
Dem Compiler und damit dem Linker werden die Komponenten der Bibliothek
nicht bekannt gemacht.
Es findet für Bibliotheksfunktionen keine Typenkontrolle statt.
Nutzung On-Demand. (Programmierer hat mehr Kontrolle.)
Beim starten des Programmes:
Kein Unterschied.
Beim ausführen des Programmes:
Bibliotheken werden durch Betriebssystemfunktionen geladen.
Bibliothekskomponenten werden durch Betriebssystemfunktionen genutzt.
30.01.2009
85
3.5 Dyn. Bibliotheken explizites linken Systemaufrufe:
Systemaufrufe
UNIX
Win32
Beschreibung
void*
HINSTANCE
Typ des Objektes
dlopen
LoadLibrary
Bibliothek öffnen
dlclose
FreeLibrary
Bibliothek schließen
dlsym
GetProcAddress
Funktionspointer ermitteln
30.01.2009
86
3.5 Dyn. Bibliotheken: Einbinden (explizites linken)
UNIX:
// einmalig die Bibliothek laden:
so_handle = dlopen( "libmydll.so", RTLD_LAZY );
// Typ: Zeiger auf Funktion, die int liefert, zwei int erhält:
typedef int ( *pFuncSumme )( int, int );
// Zeiger auf die Funktion in der DLL:
pFuncSumme summe_pf = NULL;
if( !so_handle )
{
// Laden der Bibliothek hat nicht geklapppt!
char *Fehlertext = dlerror();
perror(Fehlertext);
exit(EXIT_FAILURE);
}
// Zeiger auf die darin enthaltenen Funktionen holen:
summe_pf = (pFuncSumme)dlsym( so_handle, "summe" );
30.01.2009
87
3.5 Dyn. Bibliotheken: Einbinden (explizites linken)
Windows:
// Typ: Zeiger auf Funktion, die int liefert, zwei int erhält:
typedef int ( *pFuncSumme )( int, int );
// Zeiger auf die Funktion in der DLL:
pFuncSumme summe_pf = NULL;
// einmalig die Bibliothek laden:
DLL_Handle = LoadLibrary( "mydll.dll");
if( !DLL_Handle )
{
}
GetLastError()
fprintf( stderr, "Fehler beim Laden der DLL!\n" );
exit( 2 );
// Zeiger auf die darin enthaltenen Funktionen holen:
summe_pf = (pFuncSumme) GetProcAddress( DLL_Handle, "summe" );
30.01.2009
88
3.6 Prozesse: Einführung
DJeder Prozess besitzt seinen eigenen und unabhängigen virtuellen
Adressraum.
Jeder Prozess besitzt 1..N Threads. (Leichtgewichtsprozesse)
Jeder Prozess kann:
- Neue Threads erstellen (vom Prozess abhängig).
- Neue unabhängige Prozesse erstellen.
- Mit anderen Prozessen Kommunizieren.
Jeder Prozess hat:
- Ein oder mehr Datensegmente mit
Globalen variablen
- Ein oder mehr Codesegmente
- Ein oder mehr Heaps
- Einen Stack (Prozess-Thread)
Jeder Thread:
- Nutzt Daten, Code, Heaps und
die Umgebungsvariablen des
Prozesses. (Synchronisation!)
Code
Global Variables
Process Heap
Process Resources
Open Files, Heaps,
· · ·
Environment Block
TLS
Stack
30.01.2009
Thread N
Thread 1
· · ·
TLS
Stack
89
3.6 Prozesse: erstellen I
LBOOL CreateProcess (
LPCTSTR lpImageName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpsaProcess,
LPSECURITY_ATTRIBUTES lpsaThread,
BOOL bInheritHandles,
DWORD dwCreate,
LPVOID lpvEnvironment,
LPCTSTR lpCurDir,
LPSTARTUPINFO lpsiStartInfo,
LPPROCESS_INFORMATION lppiProcInfo)
Rückgabewerte:
30.01.2009
90
3.6 Prozesse: erstellen II
Parameter:
- lpImageName:
Name des auszuführenden Programms.
- lpCommandLine: Komandozeilen Argumente
- lpsaProcess:
Sicherheitsattribute des Programms. (NULL=Default)
Sicherheitsattribute des Threads. (NULL=Default)
- lpsaThread:
- bInheritHandles: Option: Handles an Kinder vererben (Flag)
Handles müssen dennoch als vererbbar markiert sein.
- dwCreate:
Verschiedene Prozesserstellungsoptionen (Flags) siehe Hier
- lpvEnvironment: Umgebungsvariablen (NULL=Parrent's)
Umgebungsvariablen sind Paare: (Name;Wert)
- lpCurDir:
aktuelles Arbeitsverzeichnis (NULL=Parrent's)
- lpsiStartInfo:
Eigenschaften des Hauptfensters des Programms.
- lppiProcInfo:
Informationen über den erstellten Prozess
(Ausgabeparameter)
30.01.2009
91
3.6 Prozesse: Erstellungsoptionen (dwCreate)
CREATE_SUSPENDED:
Erstellt einen Prozess, dessen Prozess-Thread schlafen gelegt wird.
Der Prozess kann mit ResumeThread() geweckt werden.
DETACHED_PROCESS:
Erstellt einen Prozess ohne Konsole.
CREATE_NEW_CONSOLE:
Erstellt einen Prozess mit neuer Konsole
CREATE_NEW_PROCESS_GROUP :
Der 'Prozess eröffnet eine neue Gruppe in der alle
teilnehmenden Prozesse die gleiche Konsole benutzen.
30.01.2009
92
3.6 Prozesse: Prozessinformationen
Prozesse besitzen ID's und Handles:
typedef struct _PROCESS_INFORMATION
{
HANDLE hProcess;
HANDLE hThread;
DWORD dwProcessId;
DWORD dwThreadId;
} PROCESS_INFORMATION;
ID's und Handles:
- Es kann mehrere Handles zu einem Objekt geben ID's nicht
- Objekt-ID's sind einzigartig und unveränderlich.
- Jedes Objekt besitzt eine ID solange es existiert.
30.01.2009
93
3.6 Prozesse: Terminieren
VOID ExitProcess (UINT nExitCode);
Parameter:
- nExitCode: Terminierungsstatus
An merkungen:
BOOL TerminateProcess ( HANDLE hProcess, UINT uExitCode );
Parameter:
- Beendet den aufrufenden Prozess mit all seinen Threads
- Ignoriert _finaly und _except Handler des SEH! (Resourcen vorher freigeben!)
An merkungen:
- hProcess: Handle eines Prozesses.
- uExitCode: Terminirungsstatus (Eingabe-Parameter)
- Beendet einen anderen Prozess mit all einen Threads
- Ignoriert SEH komplett!
- Resourcen werden nicht freigeben!
30.01.2009
94
3.6 Prozesse: Auf Terminierung warten
HANDLE OpenProcess ( DWORD fdwAccess, BOOL fInherit,
DWORD IDProcess );
Parameter:
- hObject:
Handle eines Objektes. Hier: Prozess-Handle.
- dwTimeOut: Wartezeit in Millisekunden.
Rückgabewerte: 0=>blockiert nicht, INFINITE=>blockiert
- WAIT_OBJECT_0: Prozess wurde beendet.
- WAIT_TIMEOUT:
Wartezeit ist abgelaufen.
- WAIT_FAILED:
Warten fehlgeschlagen
(z.B.: keine SYNCHONIZE-Option gesetzt)
Anmerkungen:
- Keine
30.01.2009
95
3.6 Prozesse: Terminierungssignale
BOOL GenerateConsoleCtrlEvent ( DWORD dwCtrlEvent,
DWORD dwProcessGroup );
Rückgabewerte:
- 0 bei Fehler sonst Erfolg.
Parameter:
- dwCtrlEvent: Beenden: CTRL_C_EVENT
(Dabei: dwProcessGroup=NULL)
Unterbrechen: CTRL_BREAK_EVENT
- dwProcessGroup: Spezifiziert die betreffende Prozessgruppe
Anmerkungen:
- Ermöglicht es anderen Prozessen ihre Resourcen freizugeben
bevor sie terminieren.
30.01.2009
96
HANDLE OpenProcess ( DWORD fdwAccess, BOOL fInherit,
3.6 Prozesse: öffnenDWORD IDProcess );
Rückgabewerte:
Parameter:
- fdwAccess: Terminierungs Optionen:
- PROCESS_ALL_ACCESS: Alle Zugriffsrechte erlauben. (Default von CreateProcess)
- SYNCHRONIZE:
Erlaubt warten auf Beendigung.
- PROCESS_TERMINATE: Erlaubt Terminierung durch TerminateProcess()
- PROCESS_QUERY_INFORMATION: Erlaubt Abfrage von Prozessinformationen durch
GetExitCodeProcess() und GetPriorityClass()
- fInherit:
Anmerkungen:
- IDProcess:
Option: Rückgabe-Handle vererbbar?
Idendifiziert den zu öffnenden Prozess.
- Kann mit CloseHandle gelöscht werden.
30.01.2009
97
3.6 Prozesse: Terminierungsstatus abfragen
BOOL GetExitCodeProcess ( HANDLE hProcess,
LPDWORD
lpdwExitCode );
Rückgabewerte:
- Ungleich 0 bei Erfolg sonst Fehler.
Parameter:
- hProcess:
Handle eines Prozesses.
- lpdwExitCode: Terminirungsstatus (Ausgabeparameter)
Anmerkungen:
- Ermittelt den Terminierungsstatus eines Prozesses.
- Der Prozess muss die Abfrage durch
PROCESS_QUERY_INFORMATION erlauben
30.01.2009
98
3.6 Prozesse: Systemaufrufe
Systemaufrufe
UNIX
Win32
Beschreibung
fork, das Kind ruft execl
oder execle oder … auf.
CreateProcess
Einen neuen Prozess
erstellen
exit
- schliesst Dateien
- schreibt Pufferdaten in
Dateien
ExitProcess
- terminiet den Prozess
sofort
Prozess beendet sich
selbst.
Waitpid(unblocking option) WaitForSingleObject
wait (blocking)
Auf Terminierung von
Prozessen warten
kill
GenerateConsoleCtrlEv Terminierungssignal
senden
ent
Nicht vorhanden!
OpenProcess
Waitpid(unblocking option) GetExitCodeProcess
wait (blocking)
kill
mit SIGKILL, SIGTERM
30.01.2009
TerminateProcess
öffnet einen existierenden
Prozess
Terminierungsstatus
anderen Prozess
beenden
99
3.6 Prozesserstellung: Unix
int pid;
pid = fork();
if(pid==0)
{
// Kindprozess
execle ("/bin/ls", NULL);
}
// Wait until child process exits.
int status=0;
wait(&status);
30.01.2009
100
3.6 Prozesserstellung: Windows
STARTUPINFO si; PROCESS_INFORMATION pi;
// Start the child process.
CreateProcess( NULL, // No module name (use command line)
argv[1],
// Command line
NULL,
// Process handle not inheritable
NULL,
// Thread handle not inheritable
FALSE,
// Set handle inheritance to FALSE
0,
// No creation flags
NULL,
// Use parent's environment block
NULL,
// Use parent's starting directory
&si,
// Pointer to STARTUPINFO structure
&pi )
// Pointer to PROCESS_INFORMATION structure
);
// Wait until child process exits.
WaitForSingleObject( pi.hProcess, INFINITE );
// Close process and thread handles.
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
30.01.2009
101
3.6 Prozesse: Vererbung von Handles I
Vorteil: Erlaubt Zugriff auf Objekte des Elternprozesses.
Funktionsweise:
Handle muss (bei Erstellung bzw. Duplizierung) vererbbar
definiert werden (SECURITY_ATTRIBUTES)
Elternprozess erlaubt Nutzung seiner Handles
bInheritHandle=TRUE für CreateProcess()
Elternprozess sendet Handles an das Kind.
- durch die Struktur STARTUPINFO für CreateProcess()
in der STDIN bzw. STDOUT überschreiben werden.
- durch IPC, Umgebungsvariablen, CML-Parameter
Anmerkungen:
- vererbte Handles sind eigenständige Kopien.
(z.B.: unabhängiger File-Pointer bei Dateihandle)
- auch vererbte Handles müssen geschlossen werden
30.01.2009
102
3.6 Prozesse: Vererbung von Handles II
Handle Übermittlung:
Überschreiben von hStdInput bzw. hStdOutput
mit File-Handles welche an das Kind weitergereicht werden sollen.
dwFlags muss auf STARTF_USESTDHANDLES setzen.
Kindprozess erstellen.
typedef struct _STARTUPINFO
{
...
DWORD dwFlags;
HANDLE hStdInput;
HANDLE hStdOutput;
HANDLE hStdError;
} STARTUPINFO;
30.01.2009
103
3.6 Prozesse: Vererbung von Handles III
Erstellen von vererbaren Handles:
typedef struct
SECURITY_ATTRIBUTES
{
DWORD nLength;
LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;
} SECURITY_ATTRIBUTES;
Handle h1, h2, h3;
SECURITY_ATTRIBUTES sa =
(sizeof (SECURITY_ATTRIBUTES), NULL, TRUE);
...
h1 = CreateFile (..., &sa, ...) // vererbbares Handle
h2 = CreateFile (..., NULL,...) // nicht vererbbares Handle
30.01.2009
104
3.6 Prozesse: Vererbung von Handles IV
Process 1’s
Object Table
Process 2’s
Object Table
Handle 1
Inheritable
File A
Inherited
Handle 1
Handle 2
Not Inheritable
File B
Create File
Handle 2
Handle 3
Inheritable
File C
Inherited
Handle 3
Handle 4
Not Inheritable
File D
Create File
Handle 4
File E
Child
Parent
30.01.2009
105

Win32 Systemprogrammierung

Transcription

Similar documents

Media Player »PN40HD«

3.2.1 RSA

Das Frisör-Problem - Multitasking, Petrinetze und IPC mit Toolbook