Verbindungsorientierter Client bei AF_ISO

Im Beispielprogramm verwendet der Client die folgenden Funktionen der Socket-Schnittstelle:

• getbcamhost(): BCAM-Hostnamen abfragen

• socket(): Socket erzeugen

• bind(): dem Socket einen Namen zuordnen

• connect(): auf einem Socket eine Verbindung anfordern

• send(): Daten auf einen Socket schreiben

• soc_close(): Socket schließen

   
Beispiel: Verbindungsorientierter Client bei AF_ISO

/*
 * Beispiel: ISO CLIENT
 *
 * DESCRIPTION
 *   1. getbcamhost - socket - bind - connect
 *   2. send
 *   3. soc_close 
*/
   
#include <stdio.h>
#include <sys.types.h>
#include <sys.socket.h>
#include <iso.h>
#include <netinet.in.h>
#include <netdb.h>
   
#define INT 5
#define MAXREC 1000000
#define MAXTSEL 32
#define MAXNSEL 9
  
main(argc, argv)
int argc;
char *argv[];
{
  void error_exit(); 
  int sockfd, ret, lng;
  int tsellen, nsellen, par_tsellen, par_nsellen;
  char tsel[MAXTSEL];
  char par_tsel[MAXTSEL];
  char nsel[MAXNSEL];
  char par_nsel[MAXNSEL];
  char buffer [MAXREC];
struct sockaddr_iso cli_addr, serv_addr;
   
lng = 1024 ;
strcpy (tsel,"CLIENT");
tsellen = strlen(tsel);
strcpy (par_tsel,"SERVER");
par_tsellen = strlen(par_tsel);
nsel[MAXNSEL-1] = '\0';
   
/* Partner Host-Name besorgen */
if (argc > 1)
{
  strcpy (par_nsel,argv[1]);
  if ((par_nsellen = strlen(par_nsel)) != MAXNSEL - 1)
  {
     printf ("Fehler: Falscher Rechnername!!\n");
     exit (-1);
  }
}
else
{
   printf ("Partner Host-Name wurde nicht als Argument in der 
   Kommandozeile uebergeben!\n");
   exit (-1);
}
  
/* BCAM Host-Name besorgen */
errno = 0;
if (getbcamhost(nsel,sizeof(nsel)) < 0)
    error_exit("ISO_cli: getbcamhost failed ",errno);
else
    printf ("getbcamhost OK! (%s)\n",nsel);
nsellen = strlen(nsel);
  
/* Socket erzeugen */
errno = 0;
if ((sockfd = socket(AF_ISO, SOCK_STREAM, 0)) < 0)
    error_exit("ISO_cli: Socket Creation failed ",errno);
else
    printf ("socket OK!\n");
   
/* Dem Socket einen Namen zuordnen */
memset ((char *) &cli_addr, 0, sizeof(cli_addr));
cli_addr.siso_len = sizeof (struct sockaddr_iso);
cli_addr.siso_family = AF_ISO;
cli_addr.siso_plen = 0;
cli_addr.siso_slen = 0;
cli_addr.siso_tlen = tsellen;
cli_addr.siso_addr.isoa_len = tsellen + nsellen;
memcpy (cli_addr.siso_addr.isoa_genaddr,nsel,nsellen);
memcpy (cli_addr.siso_addr.isoa_genaddr + nsellen,tsel,tsellen);
   
memset ((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.siso_len = sizeof (struct sockaddr_iso);
serv_addr.siso_family = AF_ISO;
serv_addr.siso_plen = 0;
serv_addr.siso_slen = 0;
serv_addr.siso_tlen = par_tsellen;
serv_addr.siso_addr.isoa_len = par_tsellen + par_nsellen;
memcpy (serv_addr.siso_addr.isoa_genaddr,par_nsel,par_nsellen);
memcpy (serv_addr.siso_addr.isoa_genaddr + 
            par_nsellen,par_tsel,par_tsellen);
   
errno = 0;
if (bind (sockfd, (struct sockaddr_iso *) &cli_addr, sizeof(cli_addr)) < 0)
    error_exit("ISO_cli: Bind failed ",errno);
else
    printf ("bind OK!\n");
   
/* Verbindung starten */ 
errno = 0;
if (connect (sockfd, (struct sockaddr_iso *) &serv_addr, 
            sizeof(serv_addr)) < 0)
    error_exit("ISO_cli: Connect failed ",errno);
else
    printf ("connect OK!\n");
  
sleep(2);
   
/* Daten auf den Socket schreiben */
ret = send (sockfd, buffer, lng, 0);
if (ret == -1)
    error_exit("ISO_cli: Send in Error", errno);
else
    printf ("send OK!(%d)\n",ret);
  /* Socket schliessen */
  sleep (2);
  errno = 0;
  if (soc_close (sockfd) <0)
      error_exit("Tcp_svr: soc_close failed ",errno);
  else
      printf ("soc_close OK!\n");
   
} /* END MAIN */
   
void 
error_exit(estring,erno)
  char *estring;
  int erno;
{
  fprintf(stderr,"%s errno=%d\n",estring,erno);
  perror (estring);
  exit(erno);
}

Im Programm werden folgende Arbeitsschritte durchgeführt:

1. Der Client besorgt sich aus dem Kommandozeilen-Argument argc der main()-Funktion den Namen des Partner-Host.

2. Mit der Funktion getbcamhost() ermittelt der Client den BCAM-Host-Namen.

3. Der Client erzeugt mit der Funktion socket() einen Kommunikationsendpunkt (Client-Socket) sowie den zugehörigen Deskriptor.

4. Dem neu generierten Socket ordnet der Client mit bind() einen Namen zu.

5. Mit connect() stellt der Client die Verbindung zum Kommunikationspartner (Server-Socket) her.

6. Mit send() sendet der Client Benutzerdaten an den Partner-Socket (Server-Socket).

7. Mit der Funktion soc_close() wird der (Client-)Socket wieder geschlossen.