Socket (Software)

Ein Socket (abgel. von engl. Sockel oder Steckverbindung, Steckdose) ist ein Software-Modul, mit dessen Hilfe sich ein Computerprogramm mit einem Rechnernetz verbinden und mit anderen Computern Daten austauschen kann. Sockets werden auch verwendet, um zwischen Prozessen auf demselben Computer Daten zu verschicken (Interprozesskommunikation). 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

Sockets bilden eine plattformunabhängige, standardisierte Schnittstelle (API) zwischen der Netzwerkprotokoll-Implementierung des Betriebssystems und der eigentlichen Anwendungssoftware. Ein Computerprogramm fordert einen Socket in der Regel vom Betriebssystem an. Das Betriebssystem hat die Aufgabe, alle benutzten Sockets sowie die zugehörigen Verbindungsinformationen zu verwalten.

Internet-Sockets

Generell kann man unterscheiden zwischen Stream Sockets und Datagram Sockets: Stream Sockets kommunizieren über einen Zeichen-Datenstrom; Datagram Sockets über einzelne Nachrichten. In der Netzwerkkommunikation verwenden Stream Sockets meist TCP, Datagram Sockets üblicherweise UDP. TCP ist verlässlicher, UDP für viele Aufgaben effizienter und flexibler, oft auch schneller (zeitlich).

Während Stream Sockets und Datagram Sockets den TCP- bzw. UDP-Header eines Datenpakets 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, 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:

• sin_family, das heißt der zugehörigen Adressfamilie des Netzwerks (z. B. AF_INET = Adressfamilie Internetadresse)
• die Identifikationsnummer des Local-Host/seiner 32-Bit-IP-Adresse
• die Portnummer des Local-Host/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 das 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, ein 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. .

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())
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-seitig:

1. Socket erstellen
2. An Adresse senden

Server-seitig:

1. Socket erstellen
2. Socket binden
3. warten auf Pakete

Interprozesskommunikations-Sockets

Unix-Betriebssysteme verwenden zur lokalen Interprozesskommunikation sogenannter 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, die als Analogon zum Paar aus IP-Adresse und Port bei AF_INET-Sockets betrachtet werden kann. Unix Domain Sockets haben für die IPC gegenüber „normalen“ Sockets, die die Loopback-Schnitstelle nutzen, den Vorteil eines wesentlich höheren Durchsatzes.

Ursprung

Unter Unix folgt die Eingabe/Ausgabe-Behandlung (I/O) dem sogenannten Open-Read-Write-Close-Algorithmus:

1. „Open“ (= Öffne) überprüft die Berechtigung bzw. gewährleistet den Zugriff auf I/O-Ressourcen.
2. Darauf folgen eine oder mehrere Read/Write (= Lies/Schreibe)-Zyklen, wobei „Read“ Daten von der I/O-Ressource liest und dem Benutzer zur Verfügung stellt, „Write“ hingegen Daten schreibt (z. B. Speichervorgang).
3. Zum Abschluss des Vorgangs erfolgt das Kommando „Close“.

Als Netzwerkunterstützung in Unix-Systemen integriert wurde, wollte man die Kommunikation ähnlich diesem ORWC-Algorithmus gestalten. So entstand 1983 die Berkeley Sockets API für BSD-Unix.

Verwendung in unterschiedlichen Betriebssystemen

Unix und unixartige Betriebssysteme (wie Linux) benutzen sehr häufig BSD-Sockets zur Netzwerkkommunikation. Zur lokalen Interprozesskommunikation verwenden sie sogenannte Unix Domain Sockets (die Teil des POSIX-Standards sind): Hierbei können Prozesse auf einfache Art und Weise miteinander kommunizieren. Für den Programmierer sieht die Kommunikation fast genauso aus, als würde er in einer normalen Datei lesen und schreiben, es werden dieselben Befehle verwendet.

Windows verwendet eine den BSD-Sockets nachempfundene sogenannte Windows Sockets API (Winsock).

Alternativen

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

Socket-Programmierung

C

Die ursprüngliche Sprache für BSD-Sockets war C. Auch heute noch ist sie sehr wichtig, da z.B. die Linux-Sockets-API ebenfalls in C geschrieben wurde. Ein Beispiel für eine TCP-Verbindung:

int sockfd = socket(AF_INET,SOCK_STREAM,0); // Erzeuge Socket
 
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);

Java

Java als plattformunabhängige Programmiersprache unterstützt im Paket java.net 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 virtuellen Maschine.

Die Klassen für die Socket-Programmierung sind Socket und ServerSocket. Folgendes Kurzbeispiel zeigt die Verwendung:

 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
 }

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 bietet durch das Modul Network eine plattformunabhängige Möglichkeit zur Verwendung von Sockets. Das folgende Beispiel beinhaltet den vollständigen Code für einen sehr einfachen Server und einen korrespondierenden Client. Der Client nimmt Textzeilen von der Standardeingabe entgegen und schickt diese über den Netzwerk-Socket an den Server. Dieser wiederum gibt die Textzeilen auf die Standardausgabe aus.

Der hier gezeigte Server ist insofern einfach, als er z. B. eine sichere Beendigung wahrscheinlich nicht ermöglicht. Eine Lösungsmöglichkeit wird in http://www.haskell.org/haskellwiki/Concurrency_demos/Graceful_exit unter Verwendung von Software Transactional Memory (STM) aufgezeigt.

Einfacher Server

module Main where
 
import Control.Concurrent
import Control.Monad
import 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"

Einfacher Client

module Main where
 
import Network
import 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

Weblinks

• Socket-Programmierung in Python (en)
• Socket-Programmierung
• c-worker.ch, Winsock-Tutorials
• Realistisches Beispiel für die Konstruktion eines Socket-Servers mit sicherer Beendigung in Haskell
• Guide to Network Programming Using Internet Sockets (en) (PDF-Datei; 720 kB)
• GNU-info-Page über Sockets (en)
• Echoserver basierend auf der Linux-Sockets-API und TCP-Sockets