Socket (Software): Unterschied zwischen den Versionen

Aus Foxwiki
Versionsgeschichte interaktiv durchsuchen
VisuellWikitext
Die Seite wurde neu angelegt: „ = TMP = Ein '''Socket''' (von engl. ''Sockel'', ''Steckverbindung'' oder ''Steckdose'') ist ein vom Betriebssystem bereitgestelltes Objekt, das als Kommunikationsendpunkt dient. Ein Programm verwendet Sockets, um Daten mit anderen Programmen auszutauschen. Das andere Programm kann sich dabei auf demselben Computer (Interprozesskommunikation) oder einem anderen, via Netzwerk erreichbaren Computer befi…“
 
Keine Bearbeitungszusammenfassung
 
(22 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
'''Socket''' - von [[Betriebssystem]]en bereitgestellter Kommunikationsendpunkt


= TMP =
== Beschreibung ==
Ein '''Socket''' (von [[Englische Sprache|engl.]] ''Sockel'', ''Steckverbindung'' oder ''Steckdose'') ist ein vom [[Betriebssystem]] bereitgestelltes Objekt, das als Kommunikationsendpunkt dient. Ein [[Computerprogramm|Programm]] verwendet Sockets, um Daten mit anderen Programmen auszutauschen. Das andere Programm kann sich dabei auf demselben Computer ([[Interprozesskommunikation]]) oder einem anderen, via [[Netzwerk]] erreichbaren Computer befinden. Die Kommunikation über Sockets erfolgt in der Regel [[bidirektional]], das heißt, über das Socket können Daten sowohl empfangen als auch gesendet werden.
Ein '''Socket''' (von [[Englische Sprache|engl.]] ''Sockel'', ''Steckverbindung'' oder ''Steckdose'') ist ein vom [[Betriebssystem]] bereitgestelltes Objekt, das als Kommunikationsendpunkt dient.  
* Ein [[Computerprogramm|Programm]] verwendet Sockets, um Daten mit anderen Programmen auszutauschen.  
* Das andere Programm kann sich dabei auf demselben Computer ([[Interprozesskommunikation]]) oder einem anderen, via [[Netzwerk]] erreichbaren Computer befinden.  
* Die Kommunikation über Sockets erfolgt in der Regel [[bidirektional]], das heißt, über das Socket können Daten sowohl empfangen als auch gesendet werden.


== Funktionsweise ==
== Funktionsweise ==
=== Allgemeines Funktionsprinzip ===
=== Funktionsprinzip ===
Sockets bilden eine plattformunabhängige [[Standard|standardisierte]] Schnittstelle ([[Application Programming Interface|API]]) zwischen der [[Netzwerkprotokoll]]-[[Implementierung]] des [[Betriebssystem]]s und der eigentlichen [[Anwendungssoftware]]. Ein Computerprogramm fordert einen Socket vom Betriebssystem an. Das Betriebssystem hat die Aufgabe, alle benutzten Sockets sowie die zugehörigen Verbindungsinformationen zu verwalten.
; Allgemeines Funktionsprinzip
Sockets bilden eine plattformunabhängige, [[Standard|standardisierte]] Schnittstelle ([[Application Programming Interface|API]]) zwischen der [[Netzwerkprotokoll]]-[[Implementierung]] des [[Betriebssystem]]s und der eigentlichen [[Anwendungssoftware]].  
* Ein Computerprogramm fordert einen Socket vom Betriebssystem an.  
* Das Betriebssystem hat die Aufgabe, alle benutzten Sockets sowie die zugehörigen Verbindungsinformationen zu verwalten.


=== Internet-Sockets ===
=== Internet-Sockets ===
Internet-Sockets ermöglichen die Kommunikation mittels bestimmter [[Kommunikationsprotokoll]]e.
Internet-Sockets ermöglichen die Kommunikation mittels bestimmter [[Kommunikationsprotokoll]]e.
Generell kann man unterscheiden zwischen '''Stream Sockets''' und '''Datagram Sockets''': Stream Sockets kommunizieren über einen [[Zeichen]]-[[Datenstrom]]; Datagramm Sockets über einzelne Nachrichten. In der Netzwerkkommunikation verwenden Stream Sockets meist [[Transmission Control Protocol|TCP]], Datagramm Sockets üblicherweise [[User Datagram Protocol|UDP]]. TCP ist verlässlicher, die Reihenfolge und Zustellung von Paketen werden garantiert (Prinzip: ganz oder gar nicht). UDP ist für bestimmte Aufgaben effizienter und flexibler, oft auch schneller (zeitlich) – Reihenfolge und Zustellung der Pakete werden jedoch nicht garantiert (weiterhin sind Duplikate möglich).
Generell kann man unterscheiden zwischen '''Stream Sockets''' und '''Datagram Sockets''': Stream Sockets kommunizieren über einen [[Zeichen]]-[[Datenstrom]]; Datagramm Sockets über einzelne Nachrichten.  
* In der Netzwerkkommunikation verwenden Stream Sockets meist [[Transmission Control Protocol|TCP]], Datagramm Sockets üblicherweise [[User Datagram Protocol|UDP]].  
* TCP ist verlässlicher, die Reihenfolge und Zustellung von Paketen werden garantiert (Prinzip: ganz oder gar nicht).  
* UDP ist für bestimmte Aufgaben effizienter und flexibler, oft auch schneller (zeitlich) – Reihenfolge und Zustellung der Pakete werden jedoch nicht garantiert (weiterhin sind Duplikate möglich).


Während Stream Sockets und Datagramm Sockets den TCP- oder UDP-[[Header]] eines [[Datenpaket]]s normalerweise verbergen und automatisch setzen, lassen '''Raw Sockets''' (''Raw'': roh) das Erstellen eigener TCP- und UDP-Header zu. Raw Sockets werden am ehesten in netzwerknahen Applikationen verwendet, z. B. für [[Router]], [[Sniffer|Packet-Sniffer]] oder bei [[Packet-Injection]].
Während Stream Sockets und Datagramm Sockets den TCP- oder UDP-[[Header]] eines [[Datenpaket]]s normalerweise verbergen und automatisch setzen, lassen '''Raw Sockets''' (''Raw'': roh) das Erstellen eigener TCP- und UDP-Header zu.  
* Raw Sockets werden am ehesten in netzwerknahen Applikationen verwendet, z. B. für [[Router]], [[Sniffer|Packet-Sniffer]] oder bei [[Packet-Injection]].


Ein Socket ist normalerweise die Verbindungsstelle zu einem bestimmten entfernten Programm, repräsentiert durch dessen Adressinformation (z. B. IP-Adresse und Portnummer). Dem Socket selbst ist natürlich auch die eigene Adressinformation zugeordnet. Eine Internet-Socket-[[Adresse]] der Familie AF_INET wird durch folgende Informationen repräsentiert:
Ein Socket ist normalerweise die Verbindungsstelle zu einem bestimmten entfernten Programm, repräsentiert durch dessen Adressinformation (z. B. IP-Adresse und Portnummer).  
* <code>sin_family</code>, das heißt der zugehörigen Adressfamilie des Netzwerks (z.&nbsp;B. AF_INET = Adressfamilie Internetadresse)
* Dem Socket selbst ist natürlich auch die eigene Adressinformation zugeordnet.  
* Eine Internet-Socket-[[Adresse]] der Familie AF_INET wird durch folgende Informationen repräsentiert:
* <code>sin_family</code>, das heißt der zugehörigen Adressfamilie des Netzwerks (z.&nbsp;B.&nbsp;AF_INET = Adressfamilie Internetadresse)
* die Identifikationsnummer des ''[[localhost]]'' / seiner 32-Bit-IP-Adresse
* die Identifikationsnummer des ''[[localhost]]'' / seiner 32-Bit-IP-Adresse
* die Portnummer des ''localhost'' / 16 Bit
* die Portnummer des ''localhost'' / 16 Bit
Diese Informationen sind allerdings vom verwendeten [[Netzwerkprotokoll|Protokoll]] abhängig. Typischerweise handelt es sich bei der Adressinformation im Internet um die [[IP-Adresse]] und den [[Port (Netzwerkadresse)|Port]]. Bei '''UNIX Domain Sockets''' ([[#Sockets und Interprozesskommunikation|s.&nbsp;u.]]) besteht die Identifikation aus einem Dateipfadnamen und der Adressfamilie AF_UNIX.
Diese Informationen sind allerdings vom verwendeten [[Netzwerkprotokoll|Protokoll]] abhängig.  
* Typischerweise handelt es sich bei der Adressinformation im Internet um die [[IP-Adresse]] und den [[Port (Netzwerkadresse)|Port]].  
* Bei '''UNIX Domain Sockets''' ([[#Sockets und Interprozesskommunikation|s.&nbsp;u.]]) besteht die Identifikation aus einem Dateipfadnamen und der Adressfamilie AF_UNIX.


Ein Server kann entweder auf Anfragen von einer bestimmten Adresse warten (und bindet sich von vornherein an diese Adresse) oder er wartet auf allen Adressen seines Rechners auf Anfragen. Dafür gibt es bei einigen Protokollen eine sogenannte ''Wildcard-Adresse'', bei der ein oder mehrere Teile der Adressinformation nicht spezifisch sind. Im Beispiel von TCP/IP und UDP/IP ist bei einer Wildcard-Adresse nur die Port-Nummer relevant, das heißt, es wird eine spezielle (ungültige) IP-Adresse angegeben, um zu signalisieren, dass Verbindungen auf allen IP-Adressen akzeptiert werden sollen. Unter Linux ist diese Wildcardadresse [[0.0.0.0]] (symbolische Konstante INADDR_ANY).
Ein Server kann entweder auf Anfragen von einer bestimmten Adresse warten (und bindet sich von vornherein an diese Adresse) oder er wartet auf allen Adressen seines Rechners auf Anfragen.  
* Dafür gibt es bei einigen Protokollen eine sogenannte ''Wildcard-Adresse'', bei der ein oder mehrere Teile der Adressinformation nicht spezifisch sind.  
* Im Beispiel von TCP/IP und UDP/IP ist bei einer Wildcard-Adresse nur die Port-Nummer relevant, das heißt, es wird eine spezielle (ungültige) IP-Adresse angegeben, um zu signalisieren, dass Verbindungen auf allen IP-Adressen akzeptiert werden sollen.  
* Unter Linux ist diese Wildcardadresse [[0.0.0.0]] (symbolische Konstante INADDR_ANY).


Wenn der Server eine Anfrage von einem Client erhält, wird aus dem lauschenden („listening“) Server-Socket der in Verbindung stehende („connected“) Server-Socket abgeleitet: Der ursprüngliche Server-Socket bleibt erhalten und wartet weiterhin auf neue Verbindungen, während ein neuer, auf den bestimmten Client gerichteter Socket geöffnet wird, der nur für die Kommunikation mit diesem einen Client verwendet wird. Dieser bleibt solange bestehen, bis die Verbindung zum Client von einer der beiden Seiten beendet wird. Dieses Ableiten kann dazu genutzt werden, eine parallelisierte Serverarchitektur zu schaffen, in der sich der Server bei einer Anfrage [[fork (Unix)|forkt]] und ein Kindprozess die Anfrage selbst beantwortet.
Wenn der Server eine Anfrage von einem Client erhält, wird aus dem lauschenden („listening“) Server-Socket der in Verbindung stehende („connected“) Server-Socket abgeleitet: Der ursprüngliche Server-Socket bleibt erhalten und wartet weiterhin auf neue Verbindungen, während ein neuer, auf den bestimmten Client gerichteter Socket geöffnet wird, der nur für die Kommunikation mit diesem einen Client verwendet wird.  
* Dieser bleibt solange bestehen, bis die Verbindung zum Client von einer der beiden Seiten beendet wird.  
* Dieses Ableiten kann dazu genutzt werden, eine parallelisierte Serverarchitektur zu schaffen, in der sich der Server bei einer Anfrage [[fork (Unix)|forkt]] und ein Kindprozess die Anfrage selbst beantwortet.


Das heißt, dass ein mit einem Client-Socket verbundener („connected“) Server-Socket genau die gleiche IP-Adresse und Port-Nummer trägt wie der lauschende („listen“) Server-Socket. Die Unterscheidung von gleichzeitigen Client-Verbindungen zum selben Server erfolgt daher durch das Paar von Server-Socket und Client-Socket. Dieses Paar muss zu jedem Zeitpunkt eindeutig auf jedem der beteiligten Kommunikationspartner sein.
Das heißt, dass ein mit einem Client-Socket verbundener („connected“) Server-Socket genau die gleiche IP-Adresse und Port-Nummer trägt wie der lauschende („listen“) Server-Socket.  
Als Beispiel sei ein HTTP-Server gegeben, der auf Port 80 lauscht. Die Verbindungen des Servers zu verschiedenen Clients führt zu folgenden eindeutigen „Connected“-Socket-Paaren auf dem Server-Rechner:
* Die Unterscheidung von gleichzeitigen Client-Verbindungen zum selben Server erfolgt daher durch das Paar von Server-Socket und Client-Socket.  
* Dieses Paar muss zu jedem Zeitpunkt eindeutig auf jedem der beteiligten Kommunikationspartner sein.
Als Beispiel sei ein HTTP-Server gegeben, der auf Port 80 lauscht.  
* Die Verbindungen des Servers zu verschiedenen Clients führt zu folgenden eindeutigen „Connected“-Socket-Paaren auf dem Server-Rechner:


(<Server-IP>:80;<Client_A-IP>:<Client_A_Port_1>), (<Server-IP>:80;<Client_A-IP>:<Client_A_Port_2>), (<Server-IP>:80;<Client_B-IP>:<Client_B_Port_1>) usw.
(<Server-IP>:80;<Client_A-IP>:<Client_A_Port_1>), (<Server-IP>:80;<Client_A-IP>:<Client_A_Port_2>), (<Server-IP>:80;<Client_B-IP>:<Client_B_Port_1>) usw.


== Ablauf der Socket-Kommunikation ==
== Socket-Kommunikation ==
Ablauf der Socket-Kommunikation
=== Stream Sockets ===
=== Stream Sockets ===
''Client-seitig'':
; Client-seitig
# Socket erstellen
# Socket erstellen
# erstellten Socket mit der Server-Adresse verbinden, von welcher Daten angefordert werden sollen
# erstellten Socket mit der Server-Adresse verbinden, von welcher Daten angefordert werden sollen
# Senden und Empfangen von Daten
# Senden und Empfangen von Daten
# evtl. Socket herunterfahren (<code>shutdown()</code>, <code>close()</code>)
# evtl.&nbsp;Socket herunterfahren (<code>shutdown()</code>, <code>close()</code>)
# Verbindung trennen, Socket schließen
# Verbindung trennen, Socket schließen


''Server-seitig'':
; Server-seitig
# Server-Socket erstellen
# Server-Socket erstellen
# Binden des Sockets an eine Adresse (Port), über welche Anfragen akzeptiert werden
# Binden des Sockets an eine Adresse (Port), über welche Anfragen akzeptiert werden
Zeile 46: Zeile 70:


=== Datagram Sockets ===
=== Datagram Sockets ===
''Client-seitig'':
; Client
# Socket erstellen
# Socket erstellen
# An Adresse senden
# An Adresse senden


''Server-seitig'':
; Server-seitig
# Socket erstellen
# Socket erstellen
# Socket binden
# Socket binden
# warten auf Pakete
# warten auf Pakete


== Sockets und Interprozesskommunikation ==
== Interprozesskommunikation ==
[[Unixoides System|Unix-Betriebssysteme]] verwenden zur lokalen [[Interprozesskommunikation]] sogenannte [[POSIX local inter-process communication socket|POSIX Local Inter-Process Communication Sockets]] (auch '''IPC Sockets''', von "inter-process communication sockets", oder '''Unix Domain Sockets'''). Auch hier gibt es Datagram und Stream Sockets; da die Kommunikation aber im Kernel stattfindet, verhalten sich Stream und Datagram Sockets sehr ähnlich (z.&nbsp;B. besteht hier auch bei Datagram Sockets keine Gefahr von Datenverlust). Ein Unix Domain Socket wird als Spezialdatei im Dateisystem repräsentiert. Anstelle von IP-Adresse und Port-Nummer dient der vollständige Pfad des Sockets als eindeutige Identifikation (z.&nbsp;B. /var/run/snmpd.sock). Unix Domain Sockets haben für die IPC gegenüber Verbindungen, die die [[Loopback]]-Schnittstelle nutzen, den Vorteil eines wesentlich höheren Durchsatzes.
; Sockets und Interprozesskommunikation
[[Unixoides System|Unix-Betriebssysteme]] verwenden zur lokalen [[Interprozesskommunikation]] sogenannte [[POSIX local inter-process communication socket|POSIX Local Inter-Process Communication Sockets]] (auch '''IPC Sockets''', von "inter-process communication sockets", oder '''Unix Domain Sockets''').  
* Auch hier gibt es Datagram und Stream Sockets; da die Kommunikation aber im Kernel stattfindet, verhalten sich Stream und Datagram Sockets sehr ähnlich (z.&nbsp;B.&nbsp;besteht hier auch bei Datagram Sockets keine Gefahr von Datenverlust).  
* Ein Unix Domain Socket wird als Spezialdatei im Dateisystem repräsentiert.  
* Anstelle von IP-Adresse und Port-Nummer dient der vollständige Pfad des Sockets als eindeutige Identifikation (z.&nbsp;B.&nbsp;/var/run/snmpd.sock).  
* Unix Domain Sockets haben für die IPC gegenüber Verbindungen, die die [[Loopback]]-Schnittstelle nutzen, den Vorteil eines wesentlich höheren Durchsatzes.


Alternativen zu Sockets in der Interprozesskommunikation sind [[Pipe (Informatik)|Pipes]] oder [[Shared Memory]].
Alternativen zu Sockets in der Interprozesskommunikation sind [[Pipe (Informatik)|Pipes]] oder [[Shared Memory]].


== Geschichte ==
== Geschichte ==
Ein zentrales Designprinzip von [[Unix]] ist: Alles ist eine Datei. Die vier am häufigsten benutzten Systemaufrufe für die Arbeit mit Dateien heißen: <code>open()</code> zum Öffnen, <code>read()</code> zum Lesen, <code>write()</code> zum Schreiben und <code>close()</code> zum Schließen. Sockets stellen die Umsetzung dieses Designprinzips dar.
; Ein zentrales Designprinzip von [[Unix]] ist: Alles ist eine Datei.  
* Die vier am häufigsten benutzten Systemaufrufe für die Arbeit mit Dateien heißen: <code>open()</code> zum Öffnen, <code>read()</code> zum Lesen, <code>write()</code> zum Schreiben und <code>close()</code> zum Schließen.  
* Sockets stellen die Umsetzung dieses Designprinzips dar.


Ursprünglich entwickelt worden ist die Socket-[[Programmierschnittstelle|API]] 1983 für [[Berkeley Software Distribution|BSD-Unix]]. Später ist die Spezifikation in den Standard [[POSIX]] eingeflossen. Damit ist sie heute auf jedem POSIX-konformen Betriebssystem verfügbar. Auch andere Betriebssysteme wie Microsoft Windows ([[Winsock]]) oder OS/2 haben die Socket-API übernommen. Die allgemeine Verbreitung von Sockets ist nicht nur dem Design von Sockets, sondern auch der allgemeinen Verfügbarkeit des Quellcodes dank der BSD-Lizenz geschuldet.
; Ursprünglich entwickelt worden ist die Socket-[[Programmierschnittstelle|API]] 1983 für [[Berkeley Software Distribution|BSD-Unix]].  
* Später ist die Spezifikation in den Standard [[POSIX]] eingeflossen.  
* Damit ist sie heute auf jedem POSIX-konformen Betriebssystem verfügbar.  
* Auch andere Betriebssysteme wie Microsoft Windows ([[Winsock]]) oder OS/2 haben die Socket-API übernommen.  
* Die allgemeine Verbreitung von Sockets ist nicht nur dem Design von Sockets, sondern auch der allgemeinen Verfügbarkeit des Quellcodes dank der BSD-Lizenz geschuldet.


== Verwendung in unterschiedlichen Betriebssystemen ==
== Verwendung in Betriebssystemen ==
[[Unix]] und [[Unixoides System|unixartige Betriebssysteme]] (wie [[Linux]]) benutzen sehr häufig BSD-Sockets zur Netzwerkkommunikation. Zur lokalen [[Interprozesskommunikation]] verwenden sie die oben beschriebenen [[Unix Domain Socket]]s (die Teil des [[POSIX]]-Standards sind) und mit denen Prozesse auf einfache Art und Weise miteinander kommunizieren können. Nach der Initialisierung des Sockets kann der Programmierer mit diesem wie mit einer Datei arbeiten.
; [[Unix]] und [[Unixoides System|unixartige Betriebssysteme]] (wie [[Linux]]) benutzen sehr häufig BSD-Sockets zur Netzwerkkommunikation.  
* Zur lokalen [[Interprozesskommunikation]] verwenden sie die oben beschriebenen [[Unix Domain Socket]]s (die Teil des [[POSIX]]-Standards sind) und mit denen Prozesse auf einfache Art und Weise miteinander kommunizieren können.  
* Nach der Initialisierung des Sockets kann der Programmierer mit diesem wie mit einer Datei arbeiten.


[[Microsoft Windows|Windows]] verwendet eine den BSD-Sockets nachempfundene sogenannte [[Winsock|Windows Sockets API]] (Winsock).
; [[Microsoft Windows|Windows]] verwendet eine den BSD-Sockets nachempfundene sogenannte [[Winsock|Windows Sockets API]] (Winsock).


== Socket-Programmierung ==
<noinclude>
=== BSD Sockets API ===
Sowohl Unix Sockets als auch Windows Sockets basieren auf der 1983 veröffentlichten BSD Sockets API. Für die nachfolgenden Programmierbeispiele sind wichtige Funktionen dieser API hier kurz zusammengefasst:
* <code>socket()</code> Erzeugt ein neues Socket bestimmten Types und alloziert hierfür Systemressourcen. Für die Identifizierung gibt die Funktion eine eindeutige Zahl vom Typ Integer zurück.
* <code>bind()</code> Bindet den Socket an eine Socket Adressinformation, in der Regel an eine IP-Adresse und Port. Wird typischerweise auf Server-Seite benutzt.
* <code>listen()</code> Versetzt einen gebundenen STREAM (TCP/IP) Socket in einen Lauschen-Modus. Wird auf Server-Seite benutzt.
* <code>connect()</code> Macht die Adressinformation (z.&nbsp;B. IP-Adresse und Port) eines anderen Sockets bekannt. Ordnet dem Socket einen freien lokalen Port zu. Im Falle eines STREAM Sockets wird versucht eine neue TCP/IP-Verbindung zu etablieren. Wird auf Client-Seite benutzt.
* <code>accept()</code> Akzeptiert einen eingehenden Versuch (Anfrage), eine neue TCP/IP-Verbindung zu einem entfernten Client aufzubauen, und erzeugt im Erfolgsfall ein neues Socket, assoziiert mit dem Adress-Paar der Verbindung. Dieses neu erzeugte Socket wird von der Funktion zurückgegeben. Wird auf Server-Seite benutzt.
* <code>send()</code> und <code>recv()</code>, oder <code>write()</code> und <code>read()</code>, oder <code>sendto()</code> und <code>recvfrom()</code> Schreibt / liest Daten an / von Socket(s). Hinweis: Ein einmaliger Funktionsaufruf von <code>recv()</code> garantiert nicht den Empfang aller vom Sender mittels <code>send()</code> gesendeten Daten, insbesondere nicht bei STREAM Sockets.
* <code>close()</code> Veranlasst das Betriebssystem alle für das Socket allozierten Ressourcen freizugeben. Liegt ein TCP/IP Socket vor, wird die Verbindung beendet.


=== C ===
== Anhang ==
Die abgeleitete POSIX-Sockets-API von Linux ist in C geschrieben. Ein Beispiel für einen TCP-Verbindungsaufbau eines Clients zu einem Server:
=== Siehe auch ===
{{Special:PrefixIndex/socket}}


<syntaxhighlight lang="c">
==== Links ====
int sockfd = socket(AF_INET, SOCK_STREAM, 0); // Erzeuge Socket
===== Weblinks =====
 
# https://de.wikipedia.org/wiki/Socket_(Software)
struct sockaddr_in srv;
 
memset(&srv, 0, sizeof(struct sockaddr_in));
 
srv.sin_family = AF_INET;
inet_pton(AF_INET, "1.2.3.4", &srv.sin_addr); // Schreibe IP-Adresse des Servers in die sockaddr_in-Struktur
srv.sin_port = htons(1234); // Schreibe Port in Network-Byte-Order (Big Endian) in das Feld sin_port
 
connect(sockfd, (struct sockaddr*)&srv, sizeof(struct sockaddr_in)); // Verbindung herstellen
 
// Ab jetzt kann mit write() und read() aus dem Socket gelesen und in das Socket geschrieben werden.
 
[...] // Datenaustausch
 
shutdown(sockfd, SHUT_WR); // Sende ein EOF-Byte, sodass der Server beim nächsten read() als Rückgabewert 0 bekommt
                          //und die Verbindung beenden kann
 
close(sockfd);
 
</syntaxhighlight>
 
=== C# ===
<syntaxhighlight lang="csharp">
// set IP adress and port for remote host
IPAddress ipAddress = IPAddress.Parse("192.168.xxx.yyy");
IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 9999);
Socket sock = new Socket(ipEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
// open socket
sock.Connect(ipEndPoint);
// check if socket is connected
if (sock.Connected)
{
// endless loop
while(true)
{
// set receive buffer and length, is buffer big enough?
byte[] bytesReceived = new byte[1024];
        int bytes = 0;
        // send message
byte[] msg1 = new byte[256];
// ... set your bytes, ASCII or whatever
        sock.Send(msg1, msg1.Length, SocketFlags.None);
// receive message
        bytes = sock.Receive(bytesReceived, bytesReceived.Length, SocketFlags.None);
}
sock.Shutdown(SocketShutdown.Both);
    sock.Close();
}
</syntaxhighlight>
 
=== Java ===
[[Java (Programmiersprache)|Java]] als [[Plattformunabhängigkeit|plattformunabhängige]] [[Programmiersprache]] unterstützt im Paket <code>java.net</code> unmittelbar die Socket-Programmierung. Das zeigt die Betriebssystemunabhängigkeit des Socket-Konzeptes. Die Implementierung der Sockets für die verschiedenen Plattformen (Linux, Windows, Spezialsysteme) erfolgt in der [[Klassenbibliothek]] der [[Java Virtual Machine|virtuellen Maschine]].
 
Die Klassen für die Socket-Programmierung sind <code>Socket</code> und <code>ServerSocket</code>. Folgendes Kurzbeispiel zeigt die Verwendung:
<syntaxhighlight lang="java">
ServerSocket serverSocket = new ServerSocket(port);    //Serversocket mit bestimmter Port-Nummer erstellen
while(true)
{
  Socket clientSocket = serverSocket.accept();        //auf Anfragen warten
  InputStream input  = clientSocket.getInputStream(); //InputStream-Objekt öffnen
  byte[] data        = new byte[1024];                //Datenpuffer deklarieren (anlegen)
  int numBytes        = 0;                            //Variable für Anzahl der tatsächlich gelesenen Bytes
  numBytes            = input.read(data);              //Daten lesen
  /*** gelesene Daten verarbeiten ***/
  clientSocket.close();                                //Verbindung schließen
}
</syntaxhighlight>
 
Weiterhin gibt es in der aktuellen Java-Version die Möglichkeit, Sockets über die NewIO-(nio)-Bibliothek anzusprechen.
Der Code ist etwas aufwändiger, kann jedoch schneller ausgeführt werden. Das Multiplexing mehrerer Sockets geschieht über einen so genannten Selector (vergleichbar dem Unix-Systemaufruf ''select'').
 
=== Haskell ===
Die rein funktionale Programmiersprache [[Haskell (Programmiersprache)|Haskell]] bietet durch das Modul <code>Network</code> eine [[Plattformunabhängigkeit|plattformunabhängige]] Möglichkeit zur Verwendung von Sockets. Das folgende Beispiel beinhaltet den vollständigen Code für einen sehr einfachen [[Server (Software)|Server]] und einen korrespondierenden [[Client]]. Der Client nimmt Textzeilen von der [[Standard-Datenströme|Standardeingabe]] entgegen und schickt diese über den Netzwerk-Socket an den Server. Dieser wiederum gibt die Textzeilen auf die [[Standard-Datenströme|Standardausgabe]] aus.
 
Der hier gezeigte Server ist insofern einfach, als er z.&nbsp;B. eine sichere Beendigung wahrscheinlich nicht ermöglicht. Eine Lösungsmöglichkeit wird in ''haskell.org''<ref>[https://wiki.haskell.org/Concurrency_demos/Graceful_exit ''Concurrency demos/Graceful exit''] auf wiki.haskell.org</ref> unter Verwendung von [[Transactional Memory|Software Transactional Memory (STM)]] aufgezeigt.
 
==== Einfacher Server ====
<syntaxhighlight lang="haskell">
module Main where
 
import Control.Concurrent
import Control.Monad
import System.IO
import Network
 
main : IO ()
main = withSocketsDo $ do
        theSocket <- listenOn (PortNumber 2048)
        forever $ acceptConnectionAndFork theSocket echoServer
 
type MessageHandler = (Handle, String, PortNumber) -> IO ()
 
acceptConnectionAndFork : Socket -> MessageHandler -> IO ()
acceptConnectionAndFork theSocket handler = do
  connection <- accept theSocket
  forkIO $ handler connection
  return ()
 
echoServer : MessageHandler
echoServer (handle,hostname,portnumber) = do
  putStrLn $ "("++hostname++":"++show portnumber++"): Open"
  c <- hGetContents handle
  mapM_ putStrLn ["("++hostname++":"++show portnumber++"): Msg "++show l | l<-lines c]
  putStrLn $ "("++hostname++":"++show portnumber++"): Close"
</syntaxhighlight>
 
==== Einfacher Client ====
<syntaxhighlight lang="haskell">
module Main where
 
import Network
import System.IO
import Control.Concurrent
 
main :: IO ()
main = withSocketsDo $ do
        handle <- connectTo "localhost" (PortNumber 2048)
        input <- getContents
        sequence_ [do
                      hPutStrLn handle l
                      hFlush handle |
                  l<-lines input]
        hClose handle
</syntaxhighlight>
 
=== Ruby ===
In Ruby stellt die Standardbibliothek <code>socket</code> ebenfalls plattformunabhängig eine Schnittstelle zur Programmierung von TCP-Sockets zur Verfügung.
 
Ein sehr einfacher Server (mit Multithreading), der einen Text an den Client schickt:
 
<syntaxhighlight lang="ruby">
require 'socket'
 
port = 2048
server = TCPServer.new(port)
loop do
  client = server.accept
  Thread.start(client) do |c|
    c.puts 'Hello!'
    c.close
  end
end
</syntaxhighlight>
 
=== Python 3 ===
Ein einfaches Programm, das über den Client Nachrichten an den Server schickt.
 
==== Server ====
<syntaxhighlight lang="python3">
import socket
 
# Server
 
host = "127.0.0.1"      # IP adress of the Server
port = 5000            # Port used by the server
   
s = socket.socket()
s.bind((host, port))
s.listen(1)
 
while True:
 
    client, addr = s.accept()
    print(f"Connected to {addr}")
 
    while True:
       
        data = client.recv(1024)
        if not data:
            break
       
        print(f"Received from client: {data.decode()}")
 
        client.sendall(data)
</syntaxhighlight>
 
==== Client ====
<syntaxhighlight lang="python3">
import socket
 
 
host = "127.0.0.1"      # IP adress of the Server
port = 5000            # Port used by server
 
s = socket.socket()   
s.connect((host, port))
 
while True:
    msg = str(input("Message -> "))
 
    s.sendall(msg.encode())
   
    data = s.recv(1024)
    print(f"Received from server: {data.decode()}")
 
</syntaxhighlight>
 
=== Node.js ===
In Node.js ermöglicht das Standardmodul "net" die Programmierung von TCP-Sockets.
 
<syntaxhighlight lang="javascript">
var net = require('net');
 
var server = net.createServer(function (socket) {
  socket.write('Echo server\r\n');
  socket.pipe(socket);
});
 
server.listen(1337, '127.0.0.1');
</syntaxhighlight>
 
== Weblinks ==
# [https://docs.freebsd.org/44doc/psd/20.ipctut/paper.pdf UNIX Programmer’s Supplementary Documents (PSD: 20-1)] (PDF; englisch)
# [https://docs.freebsd.org/44doc/psd/20.ipctut/paper.pdf UNIX Programmer’s Supplementary Documents (PSD: 20-1)] (PDF; englisch)
# [https://docs.python.org/3/howto/sockets.html Socket-Programmierung in Python] (englisch)
# [https://docs.python.org/3/howto/sockets.html Socket-Programmierung in Python] (englisch)
# [https://wiki.haskell.org/Concurrency_demos/Graceful_exit Realistisches Beispiel für die Konstruktion eines Socket-Servers mit sicherer Beendigung in Haskell]
# [https://wiki.haskell.org/Concurrency_demos/Graceful_exit Realistisches Beispiel für die Konstruktion eines Socket-Servers mit sicherer Beendigung in Haskell]
# [https://www.gnu.org/savannah-checkouts/gnu/libc/manual/html_node/Sockets.html ''Sockets''.] GNU-info-Page (englisch)
# [https://www.gnu.org/savannah-checkouts/gnu/libc/manual/html_node/Sockets.html ''Sockets''.] GNU-info-Page
 
[[Kategorie:Programmierung]]
[[Kategorie:Linux/Datei/Typ]]


[[Kategorie:Unix-Betriebssystemkomponente]]
</noinclude>
[[Kategorie:Programmierschnittstelle]]
[[Kategorie:Rechnernetze]]

Aktuelle Version vom 1. August 2024, 10:37 Uhr

Socket - von Betriebssystemen bereitgestellter Kommunikationsendpunkt

Beschreibung

Ein Socket (von engl. Sockel, Steckverbindung oder Steckdose) ist ein vom Betriebssystem bereitgestelltes Objekt, das als Kommunikationsendpunkt dient.

  • Ein Programm verwendet Sockets, um Daten mit anderen Programmen auszutauschen.
  • Das andere Programm kann sich dabei auf demselben Computer (Interprozesskommunikation) oder einem anderen, via Netzwerk erreichbaren Computer befinden.
  • Die Kommunikation über Sockets erfolgt in der Regel bidirektional, das heißt, über das Socket können Daten sowohl empfangen als auch gesendet werden.

Funktionsweise

Funktionsprinzip

Allgemeines Funktionsprinzip

Sockets bilden eine plattformunabhängige, standardisierte Schnittstelle (API) zwischen der Netzwerkprotokoll-Implementierung des Betriebssystems und der eigentlichen Anwendungssoftware.

  • Ein Computerprogramm fordert einen Socket vom Betriebssystem an.
  • Das Betriebssystem hat die Aufgabe, alle benutzten Sockets sowie die zugehörigen Verbindungsinformationen zu verwalten.

Internet-Sockets

Internet-Sockets ermöglichen die Kommunikation mittels bestimmter Kommunikationsprotokolle. Generell kann man unterscheiden zwischen Stream Sockets und Datagram Sockets: Stream Sockets kommunizieren über einen Zeichen-Datenstrom; Datagramm Sockets über einzelne Nachrichten.

  • In der Netzwerkkommunikation verwenden Stream Sockets meist TCP, Datagramm Sockets üblicherweise UDP.
  • TCP ist verlässlicher, die Reihenfolge und Zustellung von Paketen werden garantiert (Prinzip: ganz oder gar nicht).
  • UDP ist für bestimmte Aufgaben effizienter und flexibler, oft auch schneller (zeitlich) – Reihenfolge und Zustellung der Pakete werden jedoch nicht garantiert (weiterhin sind Duplikate möglich).

Während Stream Sockets und Datagramm Sockets den TCP- oder UDP-Header eines Datenpakets normalerweise verbergen und automatisch setzen, lassen Raw Sockets (Raw: roh) das Erstellen eigener TCP- und UDP-Header zu.

Ein Socket ist normalerweise die Verbindungsstelle zu einem bestimmten entfernten Programm, repräsentiert durch dessen Adressinformation (z. B. IP-Adresse und Portnummer).

  • Dem Socket selbst ist natürlich auch die eigene Adressinformation zugeordnet.
  • Eine Internet-Socket-Adresse der Familie AF_INET wird durch folgende Informationen repräsentiert:
  • sin_family, das heißt der zugehörigen Adressfamilie des Netzwerks (z. B. AF_INET = Adressfamilie Internetadresse)
  • die Identifikationsnummer des localhost / seiner 32-Bit-IP-Adresse
  • die Portnummer des localhost / 16 Bit

Diese Informationen sind allerdings vom verwendeten Protokoll abhängig.

  • Typischerweise handelt es sich bei der Adressinformation im Internet um die IP-Adresse und den Port.
  • Bei UNIX Domain Sockets (s. u.) besteht die Identifikation aus einem Dateipfadnamen und der Adressfamilie AF_UNIX.

Ein Server kann entweder auf Anfragen von einer bestimmten Adresse warten (und bindet sich von vornherein an diese Adresse) oder er wartet auf allen Adressen seines Rechners auf Anfragen.

  • Dafür gibt es bei einigen Protokollen eine sogenannte Wildcard-Adresse, bei der ein oder mehrere Teile der Adressinformation nicht spezifisch sind.
  • Im Beispiel von TCP/IP und UDP/IP ist bei einer Wildcard-Adresse nur die Port-Nummer relevant, das heißt, es wird eine spezielle (ungültige) IP-Adresse angegeben, um zu signalisieren, dass Verbindungen auf allen IP-Adressen akzeptiert werden sollen.
  • Unter Linux ist diese Wildcardadresse 0.0.0.0 (symbolische Konstante INADDR_ANY).

Wenn der Server eine Anfrage von einem Client erhält, wird aus dem lauschenden („listening“) Server-Socket der in Verbindung stehende („connected“) Server-Socket abgeleitet: Der ursprüngliche Server-Socket bleibt erhalten und wartet weiterhin auf neue Verbindungen, während ein neuer, auf den bestimmten Client gerichteter Socket geöffnet wird, der nur für die Kommunikation mit diesem einen Client verwendet wird.

  • Dieser bleibt solange bestehen, bis die Verbindung zum Client von einer der beiden Seiten beendet wird.
  • Dieses Ableiten kann dazu genutzt werden, eine parallelisierte Serverarchitektur zu schaffen, in der sich der Server bei einer Anfrage forkt und ein Kindprozess die Anfrage selbst beantwortet.

Das heißt, dass ein mit einem Client-Socket verbundener („connected“) Server-Socket genau die gleiche IP-Adresse und Port-Nummer trägt wie der lauschende („listen“) Server-Socket.

  • Die Unterscheidung von gleichzeitigen Client-Verbindungen zum selben Server erfolgt daher durch das Paar von Server-Socket und Client-Socket.
  • Dieses Paar muss zu jedem Zeitpunkt eindeutig auf jedem der beteiligten Kommunikationspartner sein.

Als Beispiel sei ein HTTP-Server gegeben, der auf Port 80 lauscht.

  • Die Verbindungen des Servers zu verschiedenen Clients führt zu folgenden eindeutigen „Connected“-Socket-Paaren auf dem Server-Rechner:

(<Server-IP>:80;<Client_A-IP>:<Client_A_Port_1>), (<Server-IP>:80;<Client_A-IP>:<Client_A_Port_2>), (<Server-IP>:80;<Client_B-IP>:<Client_B_Port_1>) usw.

Socket-Kommunikation

Ablauf der Socket-Kommunikation

Stream Sockets

Client-seitig
  1. Socket erstellen
  2. erstellten Socket mit der Server-Adresse verbinden, von welcher Daten angefordert werden sollen
  3. Senden und Empfangen von Daten
  4. evtl. Socket herunterfahren (shutdown(), close())
  5. Verbindung trennen, Socket schließen
Server-seitig
  1. Server-Socket erstellen
  2. Binden des Sockets an eine Adresse (Port), über welche Anfragen akzeptiert werden
  3. auf Anfragen warten
  4. Anfrage akzeptieren und damit ein neues Socket-Paar für diesen Client erstellen
  5. Bearbeiten der Client-Anfrage auf dem neuen Client-Socket
  6. Client-Socket wieder schließen.

Datagram Sockets

Client
  1. Socket erstellen
  2. An Adresse senden
Server-seitig
  1. Socket erstellen
  2. Socket binden
  3. warten auf Pakete

Interprozesskommunikation

Sockets und Interprozesskommunikation

Unix-Betriebssysteme verwenden zur lokalen Interprozesskommunikation sogenannte POSIX Local Inter-Process Communication Sockets (auch IPC Sockets, von "inter-process communication sockets", oder Unix Domain Sockets).

  • Auch hier gibt es Datagram und Stream Sockets; da die Kommunikation aber im Kernel stattfindet, verhalten sich Stream und Datagram Sockets sehr ähnlich (z. B. besteht hier auch bei Datagram Sockets keine Gefahr von Datenverlust).
  • Ein Unix Domain Socket wird als Spezialdatei im Dateisystem repräsentiert.
  • Anstelle von IP-Adresse und Port-Nummer dient der vollständige Pfad des Sockets als eindeutige Identifikation (z. B. /var/run/snmpd.sock).
  • Unix Domain Sockets haben für die IPC gegenüber Verbindungen, die die Loopback-Schnittstelle nutzen, den Vorteil eines wesentlich höheren Durchsatzes.

Alternativen zu Sockets in der Interprozesskommunikation sind Pipes oder Shared Memory.

Geschichte

Ein zentrales Designprinzip von Unix ist
Alles ist eine Datei.
  • Die vier am häufigsten benutzten Systemaufrufe für die Arbeit mit Dateien heißen: open() zum Öffnen, read() zum Lesen, write() zum Schreiben und close() zum Schließen.
  • Sockets stellen die Umsetzung dieses Designprinzips dar.
Ursprünglich entwickelt worden ist die Socket-API 1983 für BSD-Unix.
  • Später ist die Spezifikation in den Standard POSIX eingeflossen.
  • Damit ist sie heute auf jedem POSIX-konformen Betriebssystem verfügbar.
  • Auch andere Betriebssysteme wie Microsoft Windows (Winsock) oder OS/2 haben die Socket-API übernommen.
  • Die allgemeine Verbreitung von Sockets ist nicht nur dem Design von Sockets, sondern auch der allgemeinen Verfügbarkeit des Quellcodes dank der BSD-Lizenz geschuldet.

Verwendung in Betriebssystemen

Unix und unixartige Betriebssysteme (wie Linux) benutzen sehr häufig BSD-Sockets zur Netzwerkkommunikation.
  • Zur lokalen Interprozesskommunikation verwenden sie die oben beschriebenen Unix Domain Sockets (die Teil des POSIX-Standards sind) und mit denen Prozesse auf einfache Art und Weise miteinander kommunizieren können.
  • Nach der Initialisierung des Sockets kann der Programmierer mit diesem wie mit einer Datei arbeiten.
Windows verwendet eine den BSD-Sockets nachempfundene sogenannte Windows Sockets API (Winsock).


Anhang

Siehe auch

Links

Weblinks
  1. https://de.wikipedia.org/wiki/Socket_(Software)
  2. UNIX Programmer’s Supplementary Documents (PSD: 20-1) (PDF; englisch)
  3. Socket-Programmierung in Python (englisch)
  4. Realistisches Beispiel für die Konstruktion eines Socket-Servers mit sicherer Beendigung in Haskell
  5. Sockets. GNU-info-Page


Abgerufen von „https://wiki.foxtom.de/index.php?title=Socket_(Software)&oldid=104420“