11.19 Multicast-Socket
 
Wenn es die Umstände erfordern, dass ein Server Datagramme gleichzeitig an mehrere Clients verschicken muss, können Sie Folgendes tun: Entweder Sie bauen mehrere einzelne Verbindungen (man spricht dabei von Unicast-Verbindungen) auf, was allerdings sehr ineffektiv ist und die Bandbreite des Servers erheblich belastet, oder Sie verwenden Multicast-Verbindungen. Hinter Multicast verbirgt sich eine Technik, um Ihnen die Arbeit einfacher in Bezug einer UDP-Verbindung zu machen.
Multicast ist eine beliebte Technik, die u. a. in Anwendungen wie Videokonferenzen oder interaktiven Online-Spielen eingesetzt wird. Multicast-Sockets lassen sich zum Glück auch noch relativ einfach entwickeln. Dabei handelt es sich nicht einmal um ein neues API, sondern es werden lediglich fünf neue Socket-Optionen benötigt, die mit der Funktion setsockopt() gesetzt werden. Zur Übertragung der Daten wird das UDP-Protokoll verwendet. Um Multicast-Anwendungen zu schreiben, benötigen Sie eine spezielle IP-Adresse. Dazu wird der Adressraum der Klasse D im Bereich von 224.0.0.0 bis 239.255.255.255 verwendet. Die unteren 28 Bit werden dabei als Multicast-Gruppen-ID und die 32-Bit-Adresse als Gruppenadresse bezeichnet.
Prüfen Sie erst, ob Multicast überhaupt in den aktuellen Kernel einkompiliert ist:
# gzip -cd /proc/config.gz | egrep \
"IP_MULTICAST|IP_MROUTE|IP_PIMSM"
CONFIG_IP_MULTICAST=y
CONFIG_IP_MROUTE=y
CONFIG_IP_PIMSM_V1=y
CONFIG_IP_PIMSM_V2=y
Da nicht alle Linux-Systeme für IP Multicast-Adressen konfiguriert sind, kann es sein, dass hier ein wenig Nacharbeit fällig wird. Gewöhnlich ist die Multicast-IP-Funktion nur abgeschaltet und kann recht einfach eingerichtet werden. Machen Sie sich zum Superuser, und geben Sie Folgendes in der Konsole ein:
# route add -net 224.0.0.0 netmask 240.0.0.0 dev lo
# route -e
Kernel IP Routentabelle
Ziel Router Genmask Flags MSS Fenster irtt Iface
224.0.0.0 * 240.0.0.0 U 0 0 0 lo
#
Wenn zum Beispiel Ihre lokale Adresse zuvor 127.x.x.x war, lautet diese jetzt 224.x.x.x. Sollte sich partout keine Multicast-IP einrichten lassen, kann es sein, dass der aktuelle Kernel dies im Augenblick nicht unterstützt. Dann müssen Sie Ihren Kernel neu »bauen«. Wie dies genau funktioniert, entnehmen Sie bitte der jeweiligen Linux-Distribution. Gewöhnlich sollte der Vorgang überall ähnlich ablaufen. Um also den Kernel mit Multicast-Unterstützung neu zu erstellen, müssen Sie bei make menuconfig nach der Option select networking options Ausschau halten und ein Häkchen vor »IP: multicasting« und am besten auch gleich vor »IP: multicasting routing« sowie »PIM-SM version 1« und version 2 setzen.
Damit die Netzwerk-API Multicasting unterstützt, sind lediglich fünf neue Optionen nötig. Hierzu eine kurze Beschreibung der Socket-Optionen, die mit den Funktionen getsockopt() und setsockopt() erfragt bzw. gesetzt werden können. Beide Funktionen wurden ja zuvor schon näher beschrieben.
|
IP_ADD_MEMBERSHIP – Damit schließen Sie das Socket an eine bestimmte Multicast-Gruppe an. Als Argument des Datentyps für setsockopt() oder getsockopt() wird die Struktur ip_mreq erwartet: |
struct ip_mreq {
//Ipc4-KlasseD-Multicast-Adresse
struct in_addr imr_multiaddr;
//Ipv4-Adresse der lokalen Schnittstelle
struct in_addr imr_interface;
}
|
|
IP_DROP_MEMBERSHIP – Das Gegenstück zu IP_ADD_MEMBERSHIP. Damit verlässt das Socket die Multicast-Gruppe. Als Argument des Datentyps für setsockopt() oder getsockopt() wird auch hier die Struktur ip_mreq erwartet. |
|
|
IP_MULTICAST_IF – Damit wird die Schnittstelle für ausgehende Multicast-Pakete festgelegt, worauf Sockets verschickt werden. Als Argument des Datentyps für setsockopt() oder getsockopt() wird die Struktur ip_mreq erwartet. |
|
|
IP_MULTICAST_TTL – Hier wird TTL für das ausgehende Multicast festgelegt. Als Argument des Datentyps für setsockopt() oder getsockopt() wird u_char erwartet. |
|
|
IP_MULTICAST_LOOP – Damit lässt sich der lokale Loopback von Multicast-Datagrammen aktivieren bzw. deaktivieren. Als Argument des Datentyps für setsockopt() oder getsockopt() wird u_char erwartet. |
|
Hinweis Bei IPv6 wird vor die Socket-Optionen IPV6_ anstatt IP_ geschrieben. Z. B. aus IP_ADD_MEMBERSHIP wird IPV6_ADD_MEMBERSHIP. Die Struktur ip_mreq heißt hierbei dann auch ipv6_mreq.
|
Hierzu soll ein einfaches Beispiel realisiert werden. Im Beispiel wird wieder davon ausgegangen, dass Sie die Anwendung auf dem lokalen Rechner ausführen, was bedeutet, wie oben eingerichtet, dass hierbei die IP-Adresse 224.0.0.1 verwendet wird. Zuerst folgt die Serveranwendung.
/* server.c */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd. h.>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
static int port = 1234;
int main (void) {
int socket_descriptor;
struct sockaddr_in address;
socket_descriptor = socket (AF_INET, SOCK_DGRAM, 0);
if (socket_descriptor == -1) {
perror ("socket()");
exit (EXIT_FAILURE);
}
memset (&address, 0, sizeof (address));
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr ("224.0.0.1");
address.sin_port = htons (port);
printf ("Server ist bereit ...\n");
/* Broadcasting beginnen */
while (1) {
if (sendto( socket_descriptor,
"broadcast test (hallo client)",
sizeof ("broadcast test (hallo client)"),
0,
(struct sockaddr *) &address,
sizeof (address)) < 0) {
perror ("sendto()");
exit (EXIT_FAILURE);
}
sleep (1);
}
return EXIT_SUCCESS;
}
Der einzige Unterschied zu herkömmlichen Unicast-Verbindungen liegt hier in der IP-Adresse, womit der Server mit dem Client kommuniziert:
address.sin_addr.s_addr = inet_addr ("224.0.0.1");
Die Clientanwendung gestaltet sich ein wenig umfangreicher. Daher wurde der Code, mit dem eine Multicast-Verbindung eingerichtet und aufgebaut wird, extra in eine Funktion namens setup_multicast_socket() zusammengefasst. Hierzu der komplette Quellcode zum Client mit anschließender Erläuterung.
/* client.c */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdlib.h>
#include <unistd. h.>
#include <string.h>
#include <errno.h>
/* Adresse für multicast IP */
static char *host_name = "224.0.0.1";
static int port = 1234;
static struct ip_mreq command;
static int setup_multicast_socket (void) {
int loop = 1;
int socket_descriptor;
struct sockaddr_in sin;
memset (&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl (INADDR_ANY);
sin.sin_port = htons (port);
if ( ( socket_descriptor = socket(PF_INET,
SOCK_DGRAM, 0)) == -1) {
perror ("socket()");
exit (EXIT_FAILURE);
}
/* Mehr Prozessen erlauben, denselben Port zu nutzen */
loop = 1;
if (setsockopt ( socket_descriptor,
SOL_SOCKET,
SO_REUSEADDR,
&loop, sizeof (loop)) < 0) {
perror ("setsockopt:SO_REUSEADDR");
exit (EXIT_FAILURE);
}
if(bind( socket_descriptor,
(struct sockaddr *)&sin,
sizeof(sin)) < 0) {
perror ("bind");
exit (EXIT_FAILURE);
}
/* Broadcast auf dieser Maschine zulassen */
loop = 1;
if (setsockopt ( socket_descriptor,
IPPROTO_IP,
IP_MULTICAST_LOOP,
&loop, sizeof (loop)) < 0) {
perror ("setsockopt:IP_MULTICAST_LOOP");
exit (EXIT_FAILURE);
}
/* Join the broadcast group: */
command.imr_multiaddr.s_addr = inet_addr ("224.0.0.1");
command.imr_interface.s_addr = htonl (INADDR_ANY);
if (command.imr_multiaddr.s_addr == -1) {
perror ("224.0.0.1 ist keine Multicast-Adresse\n");
exit (EXIT_FAILURE);
}
if (setsockopt ( socket_descriptor,
IPPROTO_IP,
IP_ADD_MEMBERSHIP,
&command, sizeof (command)) < 0) {
perror ("setsockopt:IP_ADD_MEMBERSHIP");
}
return socket_descriptor;
}
int main (void) {
int iter = 0;
int sin_len;
char message[256];
int socket;
struct sockaddr_in sin;
struct hostent *server_host_name;
if ((server_host_name = gethostbyname (host_name)) == 0) {
perror ("gethostbyname");
exit (EXIT_FAILURE);
}
socket = setup_multicast_socket ();
/* Broadcast-Nachrichten empfangen */
while (iter++ < 10) {
sin_len = sizeof (sin);
if (recvfrom( socket, message, 256, 0,
(struct sockaddr *) &sin, &sin_len)==-1) {
perror ("recvfrom");
}
printf ("Antwort #%-2d vom Server: %s\n",
iter, message);
sleep (2);
}
/* Multicast-Socket aus der Gruppe entfernen */
if (setsockopt ( socket,
IPPROTO_IP,
IP_DROP_MEMBERSHIP,
&command, sizeof (command)) < 0 ) {
perror ("setsockopt:IP_DROP_MEMBERSHIP");
}
close (socket);
return EXIT_SUCCESS;
}
Zuerst wird im Listing über den gewöhnlichen Weg ein Socket eingerichtet (gethostbyname() und socket()). Im nächsten Schritt richten Sie das Socket mit setsockopt() ein, womit dieses erlaubt, dass mehrere Prozesse (Clients) denselben Port teilen – sprich: Mehrere Clients können innerhalb kürzester Zeit mit dem Server in Verbindung treten. Außerdem lösen Sie damit auch das Problem, dass der Server beim Neustart seinen lokalen Port erst nach zwei Minuten Wartezeit wieder benutzen kann (weshalb auch in allen obigen Codesnippets setsockopt hinzugefügt wurde).
loop = 1;
if (setsockopt ( socket_descriptor,
SOL_SOCKET,
SO_REUSEADDR,
&loop, sizeof (loop)) < 0 ) {
perror ("setsockopt:SO_REUSEADDR");
exit (EXIT_FAILURE);
}
Das Setzen dieser Option hat allerdings noch überhaupt nichts mit dem Multicasting zu tun. Betrachten Sie es jetzt einfach als Beiwerk des Listings. Anschließend wird das Socket über den gewöhnlichen Weg gebunden (bind()).
Nach dem Binden richten Sie das Socket für das Broadcasting auf der Maschine ein – genauer den lokalen Loopback der Multicast-Datagramme:
loop = 1;
if (setsockopt ( socket_descriptor,
IPPROTO_IP,
IP_MULTICAST_LOOP,
&loop, sizeof (loop)) < 0) {
perror ("setsockopt:IP_MULTICAST_LOOP");
exit (EXIT_FAILURE);
}
Jetzt, nachdem Sie die Erlaubnis haben, über die Maschine eine Multicast-Verbindung einzugehen, müssen Sie den Linux-Kernel über die Daten des speziellen Sockets informieren und sich der Multicast-Gruppe anschließen:
command.imr_multiaddr.s_addr = inet_addr ("224.0.0.1");
command.imr_interface.s_addr = htonl (INADDR_ANY);
if (command.imr_multiaddr.s_addr == -1) {
perror ("224.0.0.1 ist keine Multicast-Adresse\n");
exit (EXIT_FAILURE);
}
if (setsockopt ( socket_descriptor,
IPPROTO_IP,
IP_ADD_MEMBERSHIP,
&command, sizeof (command) ) < 0 ) {
perror ("setsockopt:IP_ADD_MEMBERSHIP");
}
Jetzt ist das Socket für die Multicast-Verbindung eingerichtet. Anschließend können Sie, in die main()-Funktion zurückgekehrt, am Port mit recvfrom() lauschen.
In diesem Beispiel wurde eine Schleife eingerichtet, die nach zehn Durchgängen mit der Arbeit fertig ist. Am Ende der Multicast-Sitzung müssen Sie die Multicast-Gruppe wieder ordentlich verlassen und das Socket schließen:
if (setsockopt ( socket,
IPPROTO_IP,
IP_DROP_MEMBERSHIP,
&command, sizeof (command) ) < 0 ) {
perror ("setsockopt:IP_DROP_MEMBERSHIP");
}
Das Programm bei der Ausführung:
$ gcc -o server server.c
$ gcc -o client client.c
$ ./server
Server ist bereit ...
---[neue Konsole]---
$ ./client
Antwort #1 vom Server: broadcast test (hallo client)
Antwort #2 vom Server: broadcast test (hallo client)
Antwort #3 vom Server: broadcast test (hallo client)
Antwort #4 vom Server: broadcast test (hallo client)
Antwort #5 vom Server: broadcast test (hallo client)
Antwort #6 vom Server: broadcast test (hallo client)
Antwort #7 vom Server: broadcast test (hallo client)
Antwort #8 vom Server: broadcast test (hallo client)
Antwort #9 vom Server: broadcast test (hallo client)
Antwort #10 vom Server: broadcast test (hallo client)
Sie können während der Zeit, nachdem Sie den ersten Client gestartet haben, gerne weitere Konsolen öffnen und weitere Clients starten. Kein Client muss dabei warten und wird genauso abgearbeitet wie der erste Client. Bei einer gewöhnlichen Unicast-Verbindung wären der Aufwand des Programms und auch der Aufwand der Bandbreite erheblich umfangreicher gewesen.
11.19.1 Anwendungsgebiete von Multicast-Verbindungen
Ganz klar, die wichtigste Frage dürfte lauten, wann und wo setzt man am besten Multicast-Verbindungen ein. Natürlich ist dies nur sinnvoll für Anwendungen, die eine 1:n-Kommunikation erfordern. Und dies könnten u. a. folgende Anwendungsgebiete sein:
|
|
Interaktive Simulationen, Online-Spiele |
|
|
Effiziente Verteilung von Daten an eine große Anzahl von Empfängern (Software-Updates, Newsticker ...) |
|
|
Fileserver |
|
|
Clustering |
|
|
Multimedia-Anwendungen |
Videokonferenz
Near-Video-on-Demand
Verteilkommunikation (Broadcast)
|
