Home  |  Map  |  Index  |  Zoek

Convert to GutenPalm or to PalmDoc door Angel Lopez <alogo(at)mx2.redestb.es> Over de auteur: Angel is aan het afstuderen in Computer Engineering. Op dit moment geeft hij les als docent bij Sun Microsystems in Solaris en netwerkbeheer. Hij heeft net als co-auteur met Ra-Ma een boek uitgebracht met als titel Internet design and implementation on Unix systems. Het meest interessant vindt hij netwerken, beveiliging, programmeren onder Unix en, sinds kort, houdt het hacken in de Linux kernel hem wakker ;) Vertaald naar het Nederlands door: Tom Uijldert <Tom.Uijldert(at)cmgplc.com> Inhoud: Inleiding Het Multicast adres Multicast in actie De koppeling IP_ADD_MEMBERSHIP IP_DROP_MEMBERSHIP IP_MULTICAST_IF IP_MULTICAST_TTL IP_MULTICAST_LOOP Een praktijkvoorbeeld Server Client Kernel en Multicast Talkback voor dit artikel

Multicast

Kort:

Dit artikel gaat in op de multicast technologie in een TCP/IP netwerk. Het gaat in op de theorie over het gebruik van Multicast communicatie en de Linuxkoppeling die we hiervoor kunnen gebruiken. Om het geheel te completeren wordt ook de kernel-code bekeken die dit implementeert onder Linux. Het wordt afgerond met een voorbeeldprogramma in C dat het gebruik van Multicast in een applicatie illustreert.

 

Inleiding

• unicast adres. Dit is een adres wat uniek is voor een bepaalde machine binnen een netwerk. Een voorbeeld hiervan is 192.168.100.9. Een voorbeeld van een unicast Ethernet (MAC) adres is 80:C0:F6:A0:4A:B1.
• broadcast adres. Hiermee bereik je alle machines binnen een netwerk. Een voorbeeld IP-adres is 192.168.100.255 en voor Ethernet (MAC): FF:FF:FF:FF:FF:FF.
• multicast adres. Hiermee bereik je een bepaalde groep machines binnen het netwerk.

Het Multicast adres

De vier meest-significante bits van het adres bepalen de waarde tussen 224 en 239. De andere 28 bits vormen de groepsidentificatie, zoals hieronder weergegeven:

Op netwerkniveau moeten de Multicast adressen naar echte adressen worden vertaald, afhankelijk van het soort netwerk. Voor unicast kan hiervoor het ARP protocol worden gebruikt. Dit kan echter niet voor Multicast adressen en dus zal dit op een andere manier moeten. Een aantal RFC documenten gaan in op het vertalen van een Multicast adres naar echte adressen:

• Multicast IPv4 to Ethernet physical address correspondence: RFC 1112.
• Correspondence to FDDI networks:RFC 1390.
• Correspondence to Token-Ring networks:RFC 1469.

Er zijn een aantal bijzondere Multicast adressen:

• Adres 224.0.0.1 adresseert iedere machine in een sub-netwerk. Iedere machine die Multicast kan praten binnen een dergelijk sub-netwerk moet zich bij deze groep aansluiten.
• Adres 224.0.0.2 adresseert iedere router in een sub-netwerk die Multicast kan praten.
• Het adresbereik tussen 224.0.0.0 - 224.0.0.255 is gereserveerd voor machineprotocollen. Dit soort adressen zullen nooit door routers die multicast praten door worden gegeven naar andere netwerken.
• Het adresbereik 239.0.0.0 - 239.255.255.255 is gereserveerd voor administratieve doeleinden. Deze adressen kunnen binnen een organisatie of bedrijf worden gebruikt maar mogen nooit door bedrijfsrouters door worden gegeven naar de buitenwereld.

Onderstaande tabel geeft een overzicht van het complete Multicast adresbereik met de gebruikelijke benoeming van ieder bereik en de bijbehorende TTL teller (Time To Live teller in ieder IP-pakket). In IP versie 4 heeft deze teller een dubbele betekenis. Zoals waarschijnlijk bekend bepaalt deze teller de levensduur van een datagram in het netwerk om oneindige lussen door verkeerde configuratie van routing-tabellen tegen te gaan. Binnen Multicast bepaalt de teller ook het bereik van het datagram (oftewel hoe ver het pakket in het netwerk mag gaan). Hiermee wordt het mogelijk een bereik te definiëren op basis van de categorie van een datagram.

Multicast in actie

Aldus zal de koppeling met fysiek adres 80:C0:F6:A0:4A:B1 die zich bij Multicast groep 224.0.1.10 heeft aangesloten, alle pakketten doorgeven, gericht aan één van de volgende adressen:

• Het adres van de koppeling: 80:C0:F6:A0:4A:B1
• Het broadcast-adres: FF:FF:FF:FF:FF:FF
• Het adres van de Multicast groep: 01:00:5E:00:01:0A

Routers zenden ook IGMP-pakketten naar groep 224.0.0.1 om machines te vragen op welke groepen ze geabonneerd zijn. Machines zullen niet direct antwoorden maar een teller op een willekeurige waarde zetten. Pas als deze teller op nul staat zal een machine antwoorden. Dit om te voorkomen dat alle machines tegelijk antwoorden en zo teveel verkeer op het netwerk genereren. Een machine die aldus antwoordt zal de adressen van de groep uitzenden waarop hij is geabonneerd. Andere machines met hetzelfde abonnement vangen dit op en zullen dit niet meer antwoorden. Eén antwoord van een machine is voor een router voldoende om te weten welk Multicast-verkeer hij door moet sturen.

Wanneer alle machines van de groep zijn afgekoppeld zal er geen antwoord meer komen op dit soort verkeer en zullen routers dus concluderen dat niemand meer op de groep is geabonneerd. Het doorgeven van Multicast verkeer voor dit adres zal dan worden gestopt. Een andere mogelijkheid in IGMP versie 2 is het versturen van een pakket vanuit de machine waarmee men expliciet het abonnement opzegt via adres 224.0.0.2.  

De koppeling

struct ip_mreq {
   struct in_addr imr_multiaddr; /* IP multicast address of group */
   struct in_addr imr_interface; /* local IP address of interface */
   };

#define IP_MULTICAST_IF  32
#define IP_MULTICAST_TTL 33
#define IP_MULTICAST_LOOP 34
#define IP_ADD_MEMBERSHIP 35
#define IP_DROP_MEMBERSHIP 36

IP_ADD_MEMBERSHIP

IP_DROP_MEMBERSHIP

IP_MULTICAST_IF

IP_MULTICAST_TTL

IP_MULTICAST_LOOP

Een praktijkvoorbeeld

Het volgende programma is een server die alles wat aan de invoer wordt aangeboden (stdin) naar de Multicast groep 224.0.1.1 uitzend. Zoals te zien hoeven er geen bijzondere handelingen te worden verricht. Het opgeven van het adres voldoet.
Opties aangaande loopback en TTL kunnen worden veranderd mochten de standaard waarden niet voldoen.  

Server

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdio.h>

#define MAXBUF 256
#define PUERTO 5000
#define GRUPO "224.0.1.1"

int main(void) {
  int s;
  struct sockaddr_in srv;
  char buf[MAXBUF];

  bzero(&srv, sizeof(srv));
  srv.sin_family = AF_INET;
  srv.sin_port = htons(PUERTO);
  if (inet_aton(GRUPO, &srv.sin_addr) < 0) {
   perror("inet_aton");
   return 1;
  }
  if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
   perror("socket");
   return 1;
  }

  while (fgets(buf, MAXBUF, stdin)) {
    if (sendto(s, buf, strlen(buf), 0, (struct sockaddr *)&srv, sizeof(srv)) < 0) {
      perror("recvfrom");
    } else {
      fprintf(stdout, "Enviado a %s: %s\n", GRUPO, buf);
    }
  }
}

Client

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>

#define MAXBUF 256
#define PUERTO 5000
#define GRUPO "224.0.1.1"

int main(void) {
  int s, n, r;
  struct sockaddr_in srv, cli;
  struct ip_mreq mreq;
  char buf[MAXBUF];

  bzero(&srv, sizeof(srv));
  srv.sin_family = AF_INET;
  srv.sin_port = htons(PUERTO);
  if (inet_aton(GRUPO, &srv.sin_addr) < 0) {
    perror("inet_aton");
    return 1;
  }

  if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    perror("socket");
    return 1;
  }

  if (bind(s, (struct sockaddr *)&srv, sizeof(srv)) < 0) {
    perror("bind");
    return 1;
  }

  if (inet_aton(GRUPO, &mreq.imr_multiaddr) < 0) {
    perror("inet_aton");
    return 1;
  }
  mreq.imr_interface.s_addr = htonl(INADDR_ANY);

  if (setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
    perror("setsockopt");
    return 1;
  }

  n = sizeof(cli);
  while (1) {
    if ((r = recvfrom(s, buf, MAXBUF, 0, (struct sockaddr *) &cli, &n)) < 0) {
      perror("recvfrom");
    } else {
      buf[r] = 0;
      fprintf(stdout, "Mensaje desde %s: %s\n", inet_ntoa(cli.sin_addr), buf);
    }
  }
}

Kernel en Multicast

struct ip_mreqn mreq;

if (optlen < sizeof(struct ip_mreq))
  return -EINVAL;
if (optlen >= sizeof(struct ip_mreqn)) {
  if(copy_from_user(&mreq,optval,sizeof(mreq)))
    return -EFAULT;
} else {
  memset(&mreq, 0, sizeof(mreq));
  if (copy_from_user(&mreq,optval,sizeof(struct ip_mreq)))
    return -EFAULT;
}
if (optname == IP_ADD_MEMBERSHIP)
  return ip_mc_join_group(sk,&mreq);
else
  return ip_mc_leave_group(sk,&mreq);

De code voor deze functies kun je vinden in /usr/src/linux/net/ipv4/igmp.c. Voor het abonneren op een groep is de code als volgt:

int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr)
{
  int err;
  u32 addr = imr->imr_multiaddr.s_addr;
  struct ip_mc_socklist, *iml, *i;
  struct in_device *in_dev;
  int count = 0;

  if (!MULTICAST(addr))
    return -EINVAL;

    rtnl_shlock();

  if (!imr->imr_ifindex)
    in_dev = ip_mc_find_dev(imr);
  else
    in_dev = inetdev_by_index(imr->imr_ifindex);

  if (!in_dev) {
    iml = NULL;
    err = -ENODEV;
    goto done;
  }

  iml = (struct ip_mc_socklist *)sock_kmalloc(sk, sizeof(*iml),
    GFP_KERNEL);
  err = -EADDRINUSE;
  for (i=sk->ip_mc_list; i; i=i->next) {
    if (memcmp(&i->multi, imr, sizeof(*imr)) == 0) {
      /* New style additions are reference counted */
      if (imr->imr_address.s_addr == 0) {
        i->count++;
        err = 0;
      }
      goto done;
    }
    count++;
  }
  err = -ENOBUFS;
  if (iml == NULL || count >= sysctl_igmp_max_memberships)
    goto done;

  memcpy(&iml->multi,imr, sizeof(*imr));
  iml->next = sk->ip_mc_list;
  iml->count = 1;
  sk->ip_mc_list = iml;
  ip_mc_inc_group(in_dev,addr);
  iml = NULL;
  err = 0;
done:
  rtnl_shunlock();
  if (iml)
    sock_kfree_s(sk, iml, sizeof(*iml));
  return err;
}

int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
{
  struct ip_mc_socklist *iml, **imlp;
  for (imlp=&sk->ip_mc_list;(iml=*imlp)!=NULL; imlp=&iml->next) {
    if (iml->multi.imr_multiaddr.s_addr==imr->imr_multiaddr.s_addr
     && iml->multi.imr_address.s_addr==imr->imr_address.s_addr &&
     (!imr->imr_ifindex || iml->multi.imr_ifindex==imr->imr_ifindex)) {
      struct in_device *in_dev;
      if (--iml->count)
        return 0;

      *imlp = iml->next;
      synchronize_bh();

      in_dev = inetdev_by_index(iml->multi.imr_ifindex);
      if (in_dev)
        ip_mc_dec_group(in_dev, imr->imr_multiaddr.s_addr);
      sock_kfree_s(sk, iml, sizeof(*iml));
      return 0;
    }
  }
  return -EADDRNOTAVAIL;
}

Talkback voor dit artikel

2002-06-08, generated by lfparser version 2.28