C Benannte Pipe Erstellen und Client/Server Applikation

fifo.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<errno.h>

#define FIFO_NAME "fifo"
#define ARGUMENT_ERROR "a.out < s/r >\n"
#define BUFFER_SIZE 100

#define FIFO_ERROR "Konnte FIFO nicht oeffnen! \n"
#define FIFO_BUILD_ERROR "Konnte keinen FIFO erzeugen! \n"
#define MALLOC_ERROR "Es konnte kein Speicher reserviert werden! \n"

/*
Moeglicher Aufruf
./a.out r     # Als Sender aufrufen
./a.out s     # Als Receiver aufrufen
*/

// caeser rechen funktion
char * caeser(const char * kette, int rot)
{
	int count = strlen(kette);
	// Auf terminierendes NULL Byte pruefen
	if(count == -1) return NULL;
	// rot invertieren
	if(rot < 0){
		rot = 26 + rot;
	}	
	// Speicher reservieren mit terminierenden NULL Byte !
	char * ergebnis = malloc( sizeof( char ) * ( count + 1 ));
	if(ergebnis == NULL) return NULL;
	int i;	//Laufvariable
	// Caeser Verschiebung
	for(i = 0 ; i < count ; i++)
	{
		// shifte nur Buchstaben
		if(kette[i] >= 'a' && kette[i] <= 'z')
		{
			char zeichen = kette[i] - 0x61; // a = 0
			ergebnis[i] = (zeichen + rot) % 26 + 0x61;
		}
		else if(kette[i] >= 'A' && kette[i] <= 'Z')
		{
			char zeichen = kette[i] - 0x41; // A = 0
			ergebnis[i] = (zeichen + rot) % 26 + 0x41;
		}
		else
		{
			ergebnis[i] = kette[i];
		}
	}
	// terminierendes NULL Byte anfuegen
	ergebnis[i+1]='\0';
	return ergebnis;
}

// Sender Routine (Kann mit Strg+D abegebrochen werden)
int sender(int rot)
{
	char send[BUFFER_SIZE];
	int fifo;
	fflush(stdin);	// Puffer jeweils leeren
	// Eingabemaske des Sender bis EOF erzeugt wird (Leerzeichen mitnehemen)
	while(scanf("%[^\n]",send) != EOF)
	{
		fflush(stdin);  // Puffer jeweils leeren
		// Oeffne den FIFO
		if((fifo = open(FIFO_NAME, O_WRONLY )) < 0)
		{
			printf(FIFO_ERROR);
			return EXIT_FAILURE;
		}
		// in fifo schreiben und schliessen + EOF	
		write(fifo,caeser(send,rot),strlen(send)+1);
		close(fifo);
		fifo = 0;
	}
	return EXIT_SUCCESS;
}

// Receiver Routine (Kann mit Strg+C abegebrochen werden)
int receiver(int rot)
{
	// Lesepuffer
	char buffer[BUFFER_SIZE];
	int fifo, bytes, i, keep_running = 1;
	// oeffne FIFO nur lesend
	if((fifo = open(FIFO_NAME, O_RDONLY )) < 0)
	{
		printf(FIFO_ERROR);
		return EXIT_FAILURE;
	}
	// Dauerschleife zum Empfangen
	while(keep_running == 1)
	{
		// Lese den FIFO
		if(bytes = read(fifo, buffer, BUFFER_SIZE) > 0)
		{	
			// wenn Lesevorgang erfolgreich, entschluesseln und darstellen
			printf("%s\n",caeser(buffer,-rot));
			fflush(stdout);
		}
		sleep(1);
	}
	return EXIT_SUCCESS;
}

// Hauptroutine
int main(int argc,char * argv[])
{
	// Caeser Verschiebeschluessel
	int rot = 0;
	// Falsche Parameteruebergabe
	if(argc != 2)
	{
		printf(ARGUMENT_ERROR);
		return EXIT_FAILURE;
	}

	// Schluesseleingabe
	printf("Schluessel( > 0 ):");
	scanf("%d",&rot);
	umask(0); // Alle Zugrifsrechte auf Dateikreierungsmaske erlauben
	// FIFO erzeugen falls er noch nicht existiert
	if(mkfifo(FIFO_NAME, 0666 | O_RDWR) < 0)
	{
		// Falls er nicht bereits existiert 
		if(errno != EEXIST)
		{
			printf(FIFO_BUILD_ERROR);
			return EXIT_FAILURE;
		}
	}
	else
	{
		printf("FIFO wurde erzeugt ...\n");
	}
	// Unterscheidung ob Sender oder Receiver
	if(argv[1][0]=='s')
	{
		// SENDER
		printf("Sender mit Schluessel %d\n",rot);
		return sender(rot);
	}
	else
	{
		// RECEIVER
		printf("Receiver mit Schluessel %d\n",rot);
		return receiver(rot);
	}
	return EXIT_SUCCESS;
}