Unix Domain Sockets - Versionsgeschichte

PhilKa am 21. Oktober 2025 um 14:03 Uhr

2025-10-21T14:03:16Z

← Nächstältere Version		Version vom 21. Oktober 2025, 16:03 Uhr
Zeile 2:		Zeile 2:

	'''Unix Domain Sockets''' (auch '''Local Sockets''' oder '''AF_UNIX-Sockets''') sind eine Form der Interprozesskommunikation (IPC) unter Unix-ähnlichen Betriebssystemen (Linux, macOS, BSD).		'''Unix Domain Sockets''' (auch '''Local Sockets''' oder '''AF_UNIX-Sockets''') sind eine Form der Interprozesskommunikation (IPC) unter Unix-ähnlichen Betriebssystemen (Linux, macOS, BSD).
	Im Gegensatz zu Internet-Sockets (z. B. TCP/UDP über IPv4 oder IPv6) ermöglichen Unix Domain Sockets eine schnelle und sichere Kommunikation zwischen Prozessen auf demselben System.		Im Gegensatz zu Internet-Sockets (z. B. TCP/UDP über IPv4 oder IPv6) ermöglichen Unix Domain Sockets eine ''schnelle und sichere Kommunikation zwischen Prozessen auf demselben System''.

	---		---
Zeile 8:		Zeile 8:
	== Grundprinzip ==		== Grundprinzip ==
	Unix Domain Sockets verwenden das Dateisystem als Namensraum:		Unix Domain Sockets verwenden das Dateisystem als Namensraum:
	Jeder Socket wird durch einen Dateipfad (z. B. <code>/tmp/socket</code>) repräsentiert.		Jeder Socket wird durch einen ''Dateipfad'' (z. B. <code>/tmp/socket</code>) repräsentiert.

	Prozesse können über diesen Pfad eine Verbindung aufbauen und bidirektional Daten austauschen – ähnlich wie über Netzwerk-Sockets, jedoch ohne Netzwerkprotokoll-Overhead.		Prozesse können über diesen Pfad eine Verbindung aufbauen und bidirektional Daten austauschen – ähnlich wie über Netzwerk-Sockets, jedoch ''ohne Netzwerkprotokoll-Overhead''.

	<pre>		<pre>
Zeile 25:		Zeile 25:

	== Eigenschaften ==		== Eigenschaften ==
	* Kommunikation nur lokal (kein Routing über Netzwerke)		* Kommunikation ''nur lokal'' (kein Routing über Netzwerke)
	* Sehr geringe Latenz und hohe Geschwindigkeit		* Sehr ''geringe Latenz'' und ''hohe Geschwindigkeit''
	* Unterstützt Stream (SOCK_STREAM) und Datagram (SOCK_DGRAM)-Typen		* Unterstützt ''Stream (SOCK_STREAM)'' und ''Datagram (SOCK_DGRAM)''-Typen
	* Nutzung von Dateisystemrechten zur Zugriffskontrolle		* Nutzung von ''Dateisystemrechten'' zur Zugriffskontrolle
	* Ermöglicht Dateideskriptor-Weitergabe (Advanced IPC)		* Ermöglicht ''Dateideskriptor-Weitergabe'' (Advanced IPC)

	---		---
Zeile 211:		Zeile 211:

	== Zugriffsschutz ==		== Zugriffsschutz ==
	Unix Domain Sockets nutzen das Dateisystem-Rechtesystem.		Unix Domain Sockets nutzen das ''Dateisystem-Rechtesystem''.
	Nur Prozesse mit ausreichenden Rechten (z. B. Besitzer, Gruppe, `chmod`-Berechtigungen) dürfen sich verbinden.		Nur Prozesse mit ausreichenden Rechten (z. B. Besitzer, Gruppe, `chmod`-Berechtigungen) dürfen sich verbinden.
	Das macht sie sicherer als Netzwerk-Sockets für lokale Kommunikation.		Das macht sie sicherer als Netzwerk-Sockets für lokale Kommunikation.
Zeile 218:		Zeile 218:

	== Leistung ==		== Leistung ==
	Da keine Protokollkonvertierung (IP, Routing, Checksummen etc.) notwendig ist, sind Unix Domain Sockets deutlich schneller als TCP/IP-Sockets auf demselben Rechner.		Da keine Protokollkonvertierung (IP, Routing, Checksummen etc.) notwendig ist, sind Unix Domain Sockets ''deutlich schneller'' als TCP/IP-Sockets auf demselben Rechner.
	Sie erreichen Übertragungsraten ähnlich wie anonyme Pipes oder Shared Memory, bieten aber zugleich vollwertige bidirektionale Kommunikation.		Sie erreichen Übertragungsraten ähnlich wie anonyme Pipes oder Shared Memory, bieten aber zugleich ''vollwertige bidirektionale Kommunikation''.

	---		---
Zeile 243:		Zeile 243:

	== Einsatzgebiete ==		== Einsatzgebiete ==
	* Kommunikation zwischen Daemon und Client (z. B. <code>systemd</code>, <code>dbus</code>)		* Kommunikation zwischen ''Daemon'' und ''Client'' (z. B. <code>systemd</code>, <code>dbus</code>)
	* Datenbanken (z. B. PostgreSQL, MySQL)		* ''Datenbanken'' (z. B. PostgreSQL, MySQL)
	* Container-Kommunikation (z. B. Docker Socket: <code>/var/run/docker.sock</code>)		* ''Container-Kommunikation'' (z. B. Docker Socket: <code>/var/run/docker.sock</code>)
	* Lokale IPC zwischen GUI-Programmen und Hintergrunddiensten		* ''Lokale IPC'' zwischen GUI-Programmen und Hintergrunddiensten

	---		---

PhilKa am 21. Oktober 2025 um 14:00 Uhr

2025-10-21T14:00:19Z

@@ Zeile 184: / Zeile 184: @@
 socklen_t len = sizeof(client);
 recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr*)&client, &len);
-printf("Empfange
+printf("Empfangen: %s\n", buf);

PhilKa: Die Seite wurde neu angelegt: „= Unix Domain Sockets = '''Unix Domain Sockets''' (auch '''Local Sockets''' oder '''AF_UNIX-Sockets''') sind eine Form der Interprozesskommunikation (IPC) unter Unix-ähnlichen Betriebssystemen (Linux, macOS, BSD). Im Gegensatz zu Internet-Sockets (z. B. TCP/UDP über IPv4 oder IPv6) ermöglichen Unix Domain Sockets eine schnelle und sichere Kommunikation zwischen Prozessen auf demselben System. --- == Grundprinzip == Unix Domain Sockets verwende…“

2025-10-21T13:59:42Z

Die Seite wurde neu angelegt: „= Unix Domain Sockets = '''Unix Domain Sockets''' (auch '''Local Sockets''' oder '''AF_UNIX-Sockets''') sind eine Form der Interprozesskommunikation (IPC) unter Unix-ähnlichen Betriebssystemen (Linux, macOS, BSD). Im Gegensatz zu Internet-Sockets (z. B. TCP/UDP über IPv4 oder IPv6) ermöglichen Unix Domain Sockets eine **schnelle und sichere Kommunikation zwischen Prozessen auf demselben System**. --- == Grundprinzip == Unix Domain Sockets verwende…“

Neue Seite

= Unix Domain Sockets =

'''Unix Domain Sockets''' (auch '''Local Sockets''' oder '''AF_UNIX-Sockets''') sind eine Form der Interprozesskommunikation (IPC) unter Unix-ähnlichen Betriebssystemen (Linux, macOS, BSD).
Im Gegensatz zu Internet-Sockets (z. B. TCP/UDP über IPv4 oder IPv6) ermöglichen Unix Domain Sockets eine **schnelle und sichere Kommunikation zwischen Prozessen auf demselben System**.

---

== Grundprinzip ==
Unix Domain Sockets verwenden das Dateisystem als Namensraum:
Jeder Socket wird durch einen **Dateipfad** (z. B. <code>/tmp/socket</code>) repräsentiert.

Prozesse können über diesen Pfad eine Verbindung aufbauen und bidirektional Daten austauschen – ähnlich wie über Netzwerk-Sockets, jedoch **ohne Netzwerkprotokoll-Overhead**.

<pre>
+-------------+ +-------------+
| Prozess A | <---------> | Prozess B |
| (Client) | | (Server) |
+-------------+ +-------------+
\ /
\_________________/
Unix Domain Socket (/tmp/demo.sock)
</pre>

---

== Eigenschaften ==
* Kommunikation **nur lokal** (kein Routing über Netzwerke)
* Sehr **geringe Latenz** und **hohe Geschwindigkeit**
* Unterstützt **Stream (SOCK_STREAM)** und **Datagram (SOCK_DGRAM)**-Typen
* Nutzung von **Dateisystemrechten** zur Zugriffskontrolle
* Ermöglicht **Dateideskriptor-Weitergabe** (Advanced IPC)

---

== Socket-Typen ==
{| class="wikitable"
! Typ !! Beschreibung !! Entspricht
|-
| <code>SOCK_STREAM</code> || zuverlässige, verbindungsorientierte Kommunikation || ähnlich wie TCP
|-
| <code>SOCK_DGRAM</code> || verbindungslos, Nachrichten-orientiert || ähnlich wie UDP
|-
| <code>SOCK_SEQPACKET</code> || sequenziell, aber paketorientiert || Hybridform
|}

---

== Header und Adressstruktur ==
<syntaxhighlight lang="c">
#include <sys/socket.h>
#include <sys/un.h>
</syntaxhighlight>

Adresse einer Unix-Socket-Verbindung:
<syntaxhighlight lang="c">
struct sockaddr_un {
sa_family_t sun_family; // AF_UNIX
char sun_path[108]; // Pfadname des Sockets
};
</syntaxhighlight>

---

== Beispiel 1: Server mit Unix Domain Stream Socket ==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_PATH "/tmp/unix_demo.sock"

int main() {
int server_fd, client_fd;
struct sockaddr_un addr;
char buffer[128];

unlink(SOCKET_PATH); // alten Socket-Pfad löschen

if ((server_fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(EXIT_FAILURE);
}

memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);

if (bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
perror("bind");
exit(EXIT_FAILURE);
}

if (listen(server_fd, 5) == -1) {
perror("listen");
exit(EXIT_FAILURE);
}

printf("Server wartet auf Verbindung...\n");
client_fd = accept(server_fd, NULL, NULL);
if (client_fd == -1) {
perror("accept");
exit(EXIT_FAILURE);
}

read(client_fd, buffer, sizeof(buffer));
printf("Nachricht vom Client: %s\n", buffer);

const char* reply = "Hallo vom Server!";
write(client_fd, reply, strlen(reply));

close(client_fd);
close(server_fd);
unlink(SOCKET_PATH); // Socket-Datei entfernen
return 0;
}
</syntaxhighlight>

---

== Beispiel 2: Client ==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_PATH "/tmp/unix_demo.sock"

int main() {
int sock;
struct sockaddr_un addr;
char buffer[128];

if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(EXIT_FAILURE);
}

memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);

if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
perror("connect");
exit(EXIT_FAILURE);
}

const char* message = "Hallo Server!";
write(sock, message, strlen(message));

int n = read(sock, buffer, sizeof(buffer) - 1);
buffer[n] = '\0';
printf("Antwort vom Server: %s\n", buffer);

close(sock);
return 0;
}
</syntaxhighlight>

---

== Beispiel 3: Datagram-Variante (SOCK_DGRAM) ==
Bei <code>SOCK_DGRAM</code> ist keine Verbindung nötig.
Client und Server tauschen Nachrichten ähnlich wie UDP aus.

Server:
<syntaxhighlight lang="c">
int fd;
struct sockaddr_un addr;
char buf[100];

fd = socket(AF_UNIX, SOCK_DGRAM, 0);
addr.sun_family = AF_UNIX;
strcpy(addr.sun_path, "/tmp/server_dgram.sock");
unlink(addr.sun_path);
bind(fd, (struct sockaddr*)&addr, sizeof(addr));

struct sockaddr_un client;
socklen_t len = sizeof(client);
recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr*)&client, &len);
printf("Empfange