dergeorg/twmailer_vsys
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: dergeorg:master
Branches Tags
dergeorg:master
dergeorg:3.0.0
dergeorg:2.0.1
dergeorg:2.0.0
dergeorg:1.1.1
dergeorg:1.1.0
dergeorg:1.0.0
dergeorg:0.2.1
dergeorg:0.2.0
dergeorg:0.1.3
dergeorg:0.1.2
dergeorg:0.1.1
dergeorg:0.1.0
dergeorg:0.0.1
..
compare: dergeorg:0.2.1
Branches Tags
dergeorg:master
dergeorg:3.0.0
dergeorg:2.0.1
dergeorg:2.0.0
dergeorg:1.1.1
dergeorg:1.1.0
dergeorg:1.0.0
dergeorg:0.2.1
dergeorg:0.2.0
dergeorg:0.1.3
dergeorg:0.1.2
dergeorg:0.1.1
dergeorg:0.1.0
dergeorg:0.0.1

No commits in common. "master" and "0.2.1" have entirely different histories.
master ... 0.2.1

7 changed files with 749 additions and 1361 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +0,0 @@
.vscode/

248
client.c
View File

@ -1,248 +0,0 @@
/* myclient.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <termios.h>
#define BUF 1024
void remN(char *s) {
char *p2 = s;
while(*s != '\0') {
if(*s != '\t' && *s != '\n') {
*p2++ = *s++;
} else {
++s;
}
}
*p2 = '\0';
}
bool startsWith(const char *pre, const char *str)
{
size_t lenpre = strlen(pre),
lenstr = strlen(str);
return lenstr < lenpre ? false : memcmp(pre, str, lenpre) == 0;
}
int main (int argc, char **argv) {
int create_socket;
char buffer[BUF];
struct sockaddr_in address;
int size;
if( argc < 3 ){
printf("Usage: %s ServerAdresse Port\n", argv[0]);
exit(EXIT_FAILURE);
}
if ((create_socket = socket (AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("Socket error");
return EXIT_FAILURE;
}
memset(&address,0,sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons (atoi(argv[2]));
inet_aton (argv[1], &address.sin_addr);
if (connect ( create_socket, (struct sockaddr *) &address, sizeof (address)) == 0)
{
printf ("\x1b[32mConnection with server (%s) established\n\x1b[0m", inet_ntoa (address.sin_addr));
size=recv(create_socket,buffer,BUF-1, 0);
if (size>0)
{
buffer[size]= '\0';
printf("\x1b[36m%s\x1b[0m",buffer);
}
}
else
{
perror("\x1b[31mConnect error - no server available\x1b[0m");
return EXIT_FAILURE;
}
bool login = false;
do {
//command vom user überprüfen
char command[7] = "";
printf ("\n\x1b[35mEnter Command:\x1b[0m \n");
fgets (command, 7, stdin);
if (startsWith("login", command) == true && login == false)
{
char username[10] = "";
char pw[50] = "";
char bufferString[BUF] = "";
strcpy(bufferString, "login;");
//User Dateneingabe und daten einlesen
printf("\x1b[35m<Username max. 8 Zeichen>\x1b[0m\n");
fgets (username, 10, stdin);
printf("\x1b[35m<Passwort max. 50 Zeichen>\x1b[0m\n");
//PW eingabe unsichtbar machen
struct termios term, term_orig;
tcgetattr(STDIN_FILENO, &term);
term_orig = term;
term.c_lflag &= ~ECHO;
tcsetattr(STDIN_FILENO, TCSANOW, &term);
scanf("%s", pw);
// Eingabe wieder sichtbar schalten
tcsetattr(STDIN_FILENO, TCSANOW, &term_orig);
strcat(bufferString, username);
strcat(bufferString, ";");
strcat(bufferString, pw);
remN(bufferString);
send(create_socket, bufferString, strlen (bufferString), 0);
//Response vom Server (OK oder ERR) empfangen und ausgeben
char readBuffer[BUF] = "";
read(create_socket , readBuffer, 1023);
remN(readBuffer);
if (strcmp("OK", readBuffer) == 0)
{
printf("\n\x1b[32m%s\x1b[0m\n", readBuffer);
login = true;
}else if (strcmp("ERR", readBuffer) == 0 || strcmp("Client Gesperrt", readBuffer) == 0)
{
printf("\n\x1b[31m%s\x1b[0m\n", readBuffer);
}
}else if (login == false && startsWith("quit", command) == true)
{
strcpy(buffer, "quit\n");
}else if (login == false)
{
printf("\x1b[33mBitte zuerst <login> eingeben. Erst danach können sie auf das Program zugreifen!\x1b[0m\n");
}
if(login == true){
//je nach command wird was audgeführt
if(startsWith("send", command) == true) {
char sender[10] = "";
char empfaenger[10] = "";
char betreff[82] = "";
char nachricht[128] = "";
char bufferString[BUF] = "";
strcpy(bufferString, "");
strcat(bufferString, "send");
//User Dateneingabe und daten einlesen
printf("\x1b[35m<Sender max. 8 Zeichen>\x1b[0m\n");
fgets (sender, 10, stdin);
printf("\x1b[35m<Empfänger max. 8 Zeichen>\x1b[0m\n");
fgets (empfaenger, 10, stdin);
printf("\x1b[35m<Betreff max. 80 Zeichen>\x1b[0m\n");
fgets (betreff, 82, stdin);
printf("\x1b[35m<Nachricht, beliebige Anzahl an Zeilen>\x1b[0m\n");
fgets (nachricht, 82, stdin);
//Buffer formatieren
strcat(bufferString, ";");
strcat(bufferString, sender);
strcat(bufferString, ";");
strcat(bufferString, empfaenger);
strcat(bufferString, ";");
strcat(bufferString, betreff);
strcat(bufferString, ";");
strcat(bufferString, nachricht);
remN(bufferString);
send(create_socket, bufferString, strlen (bufferString), 0);
//Response vom Server (OK oder ERR) empfangen und ausgeben
char readBuffer[BUF] = "";
read(create_socket , readBuffer, 1024);
printf("\n%s\n", readBuffer);
}else if(startsWith("list", command) == true) {
char bufferString[BUF] = "list";
char username[10] = "";
char p[22] = "";
int counter = 0;
printf("\x1b[35m<Username max. 8 Zeichen>\x1b[0m\n");
fgets (username, 10, stdin);
printf("\x1b[35m<Posteingang oder Postausgang>\x1b[0m\n");
fgets (p, 22, stdin);
strcat(bufferString, ";");
strcat(bufferString, username);
strcat(bufferString, ";");
strcat(bufferString, p);
remN(bufferString);
send(create_socket, bufferString, strlen (bufferString), 0);
char readBuffer[BUF] = "";
read(create_socket , readBuffer, 1024);
char delimiter[] = ";";
char *ptr;
ptr = strtok(readBuffer, delimiter);
while(ptr != NULL) {
if(strcmp(ptr, ".") == 0) {
}else if(strcmp(ptr, "..") == 0) {
}else if (counter == 0) {
printf("\x1b[35m<Anzahl der Nachrichten für den User: %s>\x1b[0m\n", ptr);
}else {
printf("Betreff: %s \n", ptr);
}
counter = counter + 1;
// naechsten Abschnitt erstellen
ptr = strtok(NULL, delimiter);
}
}else if(startsWith("read", command) == true) {
char bufferString[BUF] = "read";
char username[10] = "";
char nid[82] = "";
char folder[22] = "";
printf("\x1b[35m<Username max. 8 Zeichen>\x1b[0m\n");
fgets (username, 10, stdin);
printf("\x1b[35m<posteingang oder postausgang>\x1b[0m\n");
fgets (folder, 22, stdin);
printf("\x1b[35m<Nachrichten-Nummer>\x1b[0m\n");
fgets (nid, 82, stdin);
strcat(bufferString, ";");
strcat(bufferString, username);
strcat(bufferString, ";");
strcat(bufferString, folder);
strcat(bufferString, ";");
strcat(bufferString, nid);
remN(bufferString);
send(create_socket, bufferString, strlen (bufferString), 0);
char readBuffer[BUF] = "";
read(create_socket , readBuffer, 1000);
printf("\n%s\n", readBuffer );
}else if(startsWith("del", command) == true) {
char username[10] = "";
char nachrichtennummer[82] = "";
char bufferString[BUF] = "del";
char p[22] = "";
printf("\x1b[35m<Username max. 8 Zeichen>\x1b[0m\n");
fgets (username, 10, stdin);
printf("\x1b[35m<Posteingang oder Postausgang>\x1b[0m\n");
fgets (p, 22, stdin);
printf("\x1b[35m<Nachrichten-Nummer>\x1b[0m\n");
fgets (nachrichtennummer, 82, stdin);
strcat(bufferString, ";");
strcat(bufferString, username);
strcat(bufferString, ";");
strcat(bufferString, p);
strcat(bufferString, ";");
strcat(bufferString, nachrichtennummer);
remN(bufferString);
send(create_socket, bufferString, strlen (bufferString), 0);
char readBuffer[BUF] = "";
read(create_socket , readBuffer, 1024);
printf("\n%s\n", readBuffer );
}else if(startsWith("quit", command) == true) {
strcpy(buffer, "quit\n");
}else {
printf("DAS IST KEIN COMMAND!!!!!");
}
}
}while (strcmp (buffer, "quit\n") != 0);
close (create_socket);
return EXIT_SUCCESS;
}

26
makefile
View File

@ -1,26 +0,0 @@
#Client und Server kompilieren
all: server.c client.c
gcc -Wall -o server server.c -lldap -llber -lpthread
gcc -Wall -o client client.c -lldap -llber -lpthread
#Kompilierten Client und Server löschen
clean: client server
rm -f client server
#Nur den Client kompilieren:
client: client.c
gcc -Wall -o client client.c -lldap -llber -lpthread
#Nur den Server kompilieren:
server: server.c
gcc -Wall -o server server.c -lldap -llber -lpthread
#Kompilierten Server löschen
cleanS: server
rm -f server
#Kompilierten Client löschen
cleanC: client
rm -f client

142
myclient.c Executable file
View File

@ -0,0 +1,142 @@
/* myclient.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUF 1024
#define PORT 6543
int main(int argc, char **argv)
{
char *meinport = argv[2];
int create_socket;
char buffer[BUF];
struct sockaddr_in address;
int size;
if (argc < 2)
{
printf("Usage: %s ServerAdresse\n", argv[0]);
exit(EXIT_FAILURE);
}
if ((create_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("Socket error");
return EXIT_FAILURE;
}
memset(&address, 0, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(*meinport);
inet_aton(argv[1], &address.sin_addr);
if (connect(create_socket, (struct sockaddr *)&address, sizeof(address)) == 0)
{
printf("Connection with server (%s) established\n", inet_ntoa(address.sin_addr));
size = recv(create_socket, buffer, BUF - 1, 0);
if (size > 0)
{
buffer[size] = '\0';
printf("%s", buffer);
}
}
else
{
perror("Connect error - no server available");
return EXIT_FAILURE;
}
int last = 0;
int mode = 0;
char bufferString[1024];
do
{
if (strncmp(bufferString, "send", 4) == 0 || mode == 1)
{
switch (last)
{
case 0:
last += 1;
mode = 1;
printf("\x1B[34m");
printf("->SEND->Sender eingeben: \n");
break;
case 1:
last += 1;
printf("\x1B[34m");
printf("->SEND->Empfänger eingeben: \n");
break;
case 2:
last += 1;
printf("\x1B[34m");
printf("->SEND->Betreff eingeben: \n");
break;
case 3:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->SEND->Nachricht eingeben: \n");
break;
}
}
else if (strncmp(bufferString, "list", 4) == 0 || mode == 2)
{
switch (last)
{
case 0:
last += 1;
mode = 2;
printf("\x1B[34m");
printf("->LIST->Username eingeben: \n");
break;
case 1:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->List");
do
{
size = recv(create_socket, buffer, BUF - 1, 0);
if (size > 0)
{
buffer[size] = '\0';
//if (strcmp(buffer, "LISTREADSTOPNOW\n") == 0)
//{
printf("\x1B[37m %s", buffer);
printf("CHECK LASTLINE: %d", strncmp(buffer, "LISTREADSTOPNOW\n", strlen("LISTREADSTOPNOW\n")));
printf("CHECK LASTLINE other: %d", strcmp(buffer, "LISTREADSTOPNOW\n"));
//}
}
}
while (strncmp(buffer, "LISTREADSTOPNOW\n", strlen("LISTREADSTOPNOW\n")) != 0);
break;
}
}
else if (strncmp(bufferString, "read", 4) == 0)
{
printf("READ wurde endlich erkannt!\n");
}
else if (strncmp(bufferString, "del", 4) == 0)
{
printf("DEL wurde endlich erkannt!\n");
}
else
{
char *p = getenv("USER");
printf("\x1B[32m");
printf("%s@%s:%d", p, inet_ntoa(address.sin_addr), ntohs(address.sin_port));
}
printf("\x1B[33m$ \x1B[37m");
fgets(buffer, BUF, stdin);
strcpy(bufferString, buffer);
send(create_socket, buffer, strlen(buffer), 0);
} while (strcmp(buffer, "quit\n") != 0);
close(create_socket);
return EXIT_SUCCESS;
}

607
myserver.c Executable file
View File

@ -0,0 +1,607 @@
/* myserver.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#define BUF 1024
#define PORT 6543
char *verzeichnis;
struct msgNumber
{
int index;
};
struct msgNumberArr
{
int lenght;
int index[1024];
};
int writeUsersMessages(char username[1024], int *msgNumbs, int lenght)
{
FILE *filePointer;
char filename[1024];
strcpy(filename, verzeichnis);
strcat(filename, username);
strcat(filename, ".bin");
printf("Start writeUsersMessages() filename: %s\n", filename);
filePointer = fopen(filename, "wb");
/**/
if (!filePointer)
{
printf("\x1B[31mUser Message Speicher konnte nicht geschrieben werden!\x1B[37m\n");
return 0;
}
struct msgNumberArr msgNumberStruct;
msgNumberStruct.lenght = lenght;
for (int i = 0; i < lenght; i++)
{
printf("MSG NUMMBER IN writeUserMessages(): %d\n", msgNumbs[i]);
msgNumberStruct.index[i] = msgNumbs[i];
}
fwrite(&msgNumberStruct, sizeof(struct msgNumberArr), 1, filePointer);
free(msgNumbs);
fclose(filePointer);
return 1;
}
struct msgNumberArr getUserMessages(char username[1024])
{
FILE *filePointer;
char filename[1024];
if ('\n' == username[strlen(username) - 1])
{
username[strlen(username) - 1] = '\0';
}
strcpy(filename, verzeichnis);
strcat(filename, username);
strcat(filename, ".bin");
printf("getUserMessages() Filename: %s\n", filename);
filePointer = fopen(filename, "rb");
printf("\n\nstart getUserMessages() Filename: %s, Username: %s\n\n", filename, username);
if (!filePointer)
{
printf("\x1B[31User Message Speicher konnte nicht gelesen werden!\x1B[37m\n");
struct msgNumberArr nullstruct;
nullstruct.lenght = 0;
return nullstruct;
}
int i = 0;
struct msgNumberArr msgNumbersStruct;
//int msgNumberArr[1024];
//printf("Vorm while\n");
//while(!feof(filePointer))
//while (fread(&msgNumbers, sizeof(struct msgNumber), 1, filePointer))
//{
//printf("Im while\n");
fread(&msgNumbersStruct, sizeof(struct msgNumberArr), 1, filePointer);
//}
//printf("Nach dem while\n");
fclose(filePointer);
return msgNumbersStruct;
}
int addUserMessage(char username[1024], int msgNumber)
{
if ('\n' == username[strlen(username) - 1])
{
username[strlen(username) - 1] = '\0';
}
//username[strlen(username)-1] = "\0";
printf("addUserMessage(), username: %s, msgNumber: %d\n", username, msgNumber);
int msgNumbers[1024];
struct msgNumberArr msgNumbersStruct = getUserMessages(username);
printf("msgnumberstruct lenght: %d", msgNumbersStruct.lenght);
for (int i = 0; i < msgNumbersStruct.lenght; i++)
{
msgNumbers[i] = msgNumbersStruct.index[i];
printf("MSG NUMMBER IN addUserMessage(): %d\n", msgNumbers[i]);
}
printf("Nach getUserMessages()\n");
int result;
if (msgNumbersStruct.lenght == 0)
{
printf("Es wurden keine vorherigen Messages des Users gefunden!\n");
int *msgNumbs = malloc(1024);
msgNumbs[0] = msgNumber;
printf("Username in addUserMessage(): %s", username);
result = writeUsersMessages(username, msgNumbs, 1);
}
else
{
printf("Es wurden vorherige Messages des Users gefunden, füge neue Message an alte Messages an!\n");
int nMsgs = msgNumbersStruct.lenght;
int *newNumbers = malloc(1024);
newNumbers[0] = msgNumber;
for (int i = 1; i <= nMsgs; i++)
{
printf("addUserMessage() msg number old: %d", msgNumbers[i - 1]);
newNumbers[i] = msgNumbers[i - 1];
}
printf("Vor dem writeUsersMessages() username: %s", username);
result = writeUsersMessages(username, newNumbers, nMsgs + 1);
printf("Nach dem writeUsersMessages() result: %d", result);
}
//free(msgNumbers);
if (result == 0)
{
printf("\x1B[31mMessage konnte wegen eines fehlers, in writeUserMessages(), nicht gespeichert werden!\x1B[37m\n");
return 0;
}
else
{
return 1;
}
}
int writeMessageNumber(int number)
{
FILE *filePointer;
char filename[1024];
strcpy(filename, verzeichnis);
strcat(filename, "msgNumber.bin");
filePointer = fopen(filename, "wb");
struct msgNumber my_record;
my_record.index = number;
printf("MSG NUMMBER IN writeMessageNumber(): %d\n", number);
if (!filePointer)
{
printf("\x1B[31mMessage Nummer Speicher konnte nicht geschrieben werden!\x1B[37m\n");
return 0;
}
fwrite(&my_record, sizeof(struct msgNumber), 1, filePointer);
fclose(filePointer);
printf("MSG NUMMBER IN writeMessageNumber() ist FERTIG!\n");
return 1;
}
int readLastMessageNumber()
{
FILE *filePointer;
char filename[1024];
strcpy(filename, verzeichnis);
strcat(filename, "msgNumber.bin");
filePointer = fopen(filename, "rb");
struct msgNumber my_record;
if (!filePointer)
{
printf("\x1B[31mMessage Nummer Speicher wurde nicht gefunden!\n\x1B[32mNeuer Nummer Speicher wird angelegt!\x1B[37m\n");
int result = writeMessageNumber(1);
if (result == 0)
{
return 0;
}
else
{
return 1;
}
}
fread(&my_record, sizeof(struct msgNumber), 1, filePointer);
fclose(filePointer);
printf("MSG NUMMBER IN readLastMessageNumber(): %d\n", my_record.index);
return my_record.index;
}
int getNextMessageNumber()
{
int msgNumber = readLastMessageNumber();
printf("MSG NUMMBER IN getNextMessageNumber() lastmsgNumber: %d\n", msgNumber);
if (msgNumber == 0)
{
printf("\x1B[31mMessage Nummer kam nicht von readLastMessageNumber()!\x1B[37m\n");
return 0;
}
else
{
int result = writeMessageNumber(msgNumber + 1);
printf("After write MEssage nummber, result: %d\n", result);
if (result == 0)
{
printf("\x1B[31mMessage Nummer konnte nicht gespeichert werden!\x1B[37m\n");
return 0;
}
else
{
printf("MSG NUMMBER IN getNextMessageNumber() FERTIG!\n");
return msgNumber + 1;
}
}
}
struct rec
{
char *sender, *receiver, *betreff, *msg;
};
struct rec readFile(char filename[1024])
{
FILE *filePointer;
char fullfilename[1024];
strcpy(fullfilename, verzeichnis);
strcat(fullfilename, filename);
strcat(fullfilename, ".bin");
filePointer = fopen(fullfilename, "rb");
printf("ReadFile Fullfilename: %s\n", fullfilename);
if (!filePointer)
{
perror("\x1B[31mFile konnte nicht gelesen werden!\x1B[37m\n");
//printf("\x1B[31mFile konnte nicht gelesen werden!\x1B[37m\n");
//struct rec nullstruct;
//nullstruct.sender = "0";
//nullstruct.receiver = "0";
//nullstruct.betreff = "0";
//nullstruct.msg = "0";
//return &nullstruct;
}
printf("A");
struct rec *my_record;
//struct rec *my_record_p = malloc(sizeof(struct rec));
printf("B");
fread(my_record, sizeof(struct rec), 1, filePointer);
printf("C");
printf("\nBETREFF in readFile(): %s", my_record->betreff);
printf("D");
fclose(filePointer);
//my_record_p->betreff = my_record.betreff;
//my_record_p->sender = my_record.sender;
//my_record_p->receiver = my_record.receiver;
//my_record_p->msg = my_record.msg;
return *my_record;
}
int writeToFile(char sender[1024], char betreff[1024], char receiver[1024], char message[1024])
{
FILE *filePointer;
char filename[1024];
int msgNumber = getNextMessageNumber();
if (msgNumber == 0)
{
printf("\x1B[31mWrite File konnte nicht geöffnet werden!\x1B[37m\n");
return 0;
}
else
{
printf("MSG NUMMBER found, schreibe file mit msgNummber: %d!\n", msgNumber);
strcpy(filename, verzeichnis);
char msgNumberStr[1024];
sprintf(msgNumberStr, "%d", msgNumber);
strcat(filename, msgNumberStr);
strcat(filename, ".bin");
printf("\nwriteToFile() Filename: %s\n", filename);
filePointer = fopen(filename, "wb");
struct rec my_record;
if (!filePointer)
{
printf("\x1B[31mWrite File konnte nicht geöffnet werden!\x1B[37m\n");
return 0;
}
else
{
my_record.sender = sender;
my_record.receiver = receiver;
my_record.betreff = betreff;
my_record.msg = message;
printf("Vor useradd() in writeToFile()! sender: %s, msgnumber: %d, msg: %s, betrf: %s, empf: %s\n", sender, msgNumber, message, betreff, receiver);
char receiverfile[1024];
strcpy(receiverfile, "posteingang/");
strcat(receiverfile, receiver);
int receiverresult = addUserMessage(receiverfile, msgNumber);
printf("receiverresult: %d", receiverresult);
char senderfile[1024];
strcpy(senderfile, "postausgang/");
strcat(senderfile, sender);
int senderresult = addUserMessage(senderfile, msgNumber);
printf("senderresult: %d", senderresult);
if (senderresult == 0 || receiverresult == 0)
{
printf("\x1B[31mKonnte die Nachricht dem User nicht hinzufügen! Das Speichern der Nachricht wird abgebrochen!\x1B[37m\n");
return 0;
}
else
{
fwrite(&my_record, sizeof(struct rec), 1, filePointer);
fclose(filePointer);
printf("MSG NUMMBER IN writeToFile(): %d\n", msgNumber);
return 1;
}
}
}
}
//struct rec *readFromFile(char msgNumber[1024])
//{
// FILE *filePointer;
// char filename[1024];
// strcpy(filename, msgNumber);
// strcat(filename, ".bin");
// filePointer = fopen(filename, "rb");
// struct rec *my_record_pointer = malloc(sizeof(struct rec));
// struct rec my_record;
// if (!filePointer)
// {
// perror("\x1B[31mWrite File konnte nicht geöffnet werden!\x1B[37m\n");
// }
// else
// {
//
// fread(&my_record, sizeof(struct rec), 1, filePointer);
// fclose(filePointer);
// printf("\n\nReadFile Number: %s Betreff: %s\n\n", msgNumber, my_record.betreff);
// my_record_pointer = &my_record;
// return my_record_pointer;
// }
//}
int main(int argc, char **argv)
{
verzeichnis = strdup(argv[1]);
char *meinport = argv[2];
printf("\x1B[35mMein server Verzeichniss: %s\n", verzeichnis);
printf("Mein server Port: %s\n", meinport);
int create_socket, new_socket;
socklen_t addrlen;
char buffer[BUF];
int size;
struct sockaddr_in address, cliaddress;
create_socket = socket(AF_INET, SOCK_STREAM, 0);
memset(&address, 0, sizeof(address));
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(*meinport);
if (bind(create_socket, (struct sockaddr *)&address, sizeof(address)) != 0)
{
perror("bind error");
return EXIT_FAILURE;
}
listen(create_socket, 5);
addrlen = sizeof(struct sockaddr_in);
struct rec recToSave;
while (1)
{
printf("\x1B[36mWaiting for connections...\n");
new_socket = accept(create_socket, (struct sockaddr *)&cliaddress, &addrlen);
if (new_socket > 0)
{
printf("\x1B[32mClient connected from %s:%d...\n", inet_ntoa(cliaddress.sin_addr), ntohs(cliaddress.sin_port));
strcpy(buffer, "\x1B[34mWelcome to myserver, Please enter your command:\x1B[37m\n");
send(new_socket, buffer, strlen(buffer), 0);
}
char bufferString[BUF];
int last = 0;
int mode = 0;
do
{
size = read(new_socket, buffer, BUF - 1);
if (size > 0)
{
buffer[size] = '\0';
strcpy(bufferString, buffer);
if (strncmp(bufferString, "send", 4) == 0 || mode == 1)
{
switch (last)
{
case 0:
last += 1;
mode = 1;
printf("\x1B[34m");
printf("->SEND:\x1B[33m %s\x1B[37m\n", bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
case 1:
last += 1;
printf("\x1B[34m");
printf("->SEND->Sender wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char sender[1024];
strcat(sender, bufferString);
recToSave.sender = strdup(bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
//recToSave.sender = sender;
break;
case 2:
last += 1;
printf("\x1B[34m");
printf("->SEND->Empfänger wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char empf[1024];
strcat(empf, bufferString);
recToSave.receiver = strdup(bufferString);
//recToSave.receiver = empf;
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
case 3:
last += 1;
printf("\x1B[34m");
printf("->SEND->Betreff wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char betreff[1024];
strcat(betreff, bufferString);
recToSave.betreff = strdup(bufferString);
//recToSave.betreff = betreff;
bufferString[0] = '\0';
buffer[0] = '\0';
break;
case 4:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->SEND->Nachricht wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char msg[1024];
strcat(msg, bufferString);
recToSave.msg = strdup(bufferString);
//recToSave.msg = msg;
printf("BUFFER STRING: %s", bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
printf("Sender: %s, Empf: %s, Betreff: %s, MSG: %s", recToSave.sender, recToSave.receiver, recToSave.betreff, recToSave.msg);
int returnWrite = writeToFile(recToSave.sender, recToSave.betreff, recToSave.receiver, recToSave.msg);
if (returnWrite == 0)
{
printf("\x1B[31mNachricht konnte nicht gespeichert werden!\x1B[33m\n");
}
else
{
printf("\x1B[32mNachricht wurde gespeichert!\x1B[33m\n");
}
break;
}
}
else if (strncmp(bufferString, "list", 4) == 0 || mode == 2)
{
switch (last)
{
case 0:
last += 1;
mode = 2;
printf("\x1B[34m");
printf("->LIST:\x1B[33m %s\x1B[37m\n", bufferString);
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
case 1:
last = 0;
mode = 0;
printf("\x1B[34m");
printf("->LIST->Username wurde eingegeben:\x1B[33m %s\x1B[37m\n", bufferString);
char *username;
username = strdup(bufferString);
//POSTEINGANG
char filename[1024];
strcpy(filename, "posteingang/");
strcat(filename, username);
printf("Filename: %s ENDE\n", filename);
struct msgNumberArr msgNumbersStruct = getUserMessages(filename);
printf("msgnumberstruct lenght: %d\n", msgNumbersStruct.lenght);
printf("0\n");
printf("0.1\n");
struct rec userFilesStruct[1024];
printf("1\n");
//Send to client
char posteingangMsg[1024];
sprintf(posteingangMsg, "\x1B[32mPOSTEINGANG Nachrichten: %d\n\n\n\n", msgNumbersStruct.lenght);
int sendresult = send(new_socket, posteingangMsg, strlen(posteingangMsg), 0);
printf("Send result: %d", sendresult);
for (int i = 0; i < msgNumbersStruct.lenght; i++)
{
printf("2.1&2.%d\n", i);
char filename[1024];
printf("2.3.%d\n", i);
sprintf(filename, "%d", msgNumbersStruct.index[i]);
printf("2.4.%d\n", i);
struct rec my_record_p = readFile(filename);
printf("2.5.%d\n", i);
//Send to client
printf("\n\nEINGANG -- Nachricht: %d Betreff: %s", i, my_record_p.betreff);
sprintf(posteingangMsg, "\x1B[34mBetreff: %s\n", my_record_p.betreff);
sendresult = send(new_socket, posteingangMsg, strlen(posteingangMsg), 0);
printf("Send result: %d\n", sendresult);
userFilesStruct[i] = my_record_p;
printf("2.6.%d\n", i);
}
printf("3\n");
//postausgang
filename[1024];
strcpy(filename, "postausgang/");
strcat(filename, username);
printf("Filename: %s ENDE\n", filename);
struct msgNumberArr msgNumbersStructAusgang = getUserMessages(filename);
printf("msgnumberstruct lenght: %d\n", msgNumbersStructAusgang.lenght);
//Send to client
char postausgangMsg[1024];
sprintf(postausgangMsg, "\x1B[32mPOSTAUSGANG Nachrichten: %d\n", msgNumbersStructAusgang.lenght);
sendresult = send(new_socket, postausgangMsg, strlen(postausgangMsg), 0);
printf("Send result: %d", sendresult);
printf("0\n");
printf("0.1\n");
struct rec userFilesStructAusgang[1024];
printf("1\n");
for (int i = 0; i < msgNumbersStructAusgang.lenght; i++)
{
printf("2.1&2.%d\n", i);
char filename[1024];
printf("2.3.%d\n", i);
sprintf(filename, "%d", msgNumbersStructAusgang.index[i]);
printf("2.4.%d\n", i);
struct rec my_record_p = readFile(filename);
printf("2.5.%d\n", i);
printf("\n\nAUSGANG -- Nachricht: %d Betreff: %s\n\n", i, my_record_p.betreff);
//Send to client
char postausgangMsg[1024];
sprintf(postausgangMsg, "\x1B[34mBetreff: %s\n", my_record_p.betreff);
sendresult = send(new_socket, postausgangMsg, strlen(postausgangMsg), 0);
printf("Send result: %d", sendresult);
userFilesStructAusgang[i] = my_record_p;
printf("2.6.%d\n", i);
}
//Send to client
sendresult = send(new_socket, "LISTREADSTOPNOW\n", strlen("LISTREADSTOPNOW\n"), 0);
printf("Send result: %d", sendresult);
printf("3\n");
bufferString[0] = '\0';
buffer[0] = '\0';
fflush(stdout);
break;
}
}
else if (strncmp(bufferString, "read", 4) == 0)
{
printf("READ wurde endlich erkannt!\n");
}
else if (strncmp(bufferString, "del", 4) == 0)
{
printf("DEL wurde endlich erkannt!\n");
}
else
{
printf("\x1B[33mBefehl wurde nicht erkannt: \x1B[31m%s\n", bufferString);
}
printf("\x1B[37m");
}
else if (size == 0)
{
printf("\x1B[33mClient closed remote socket\x1B[37m\n");
break;
}
else
{
perror("recv error");
return EXIT_FAILURE;
}
} while (strncmp(buffer, "quit", 4) != 0);
close(new_socket);
}
close(create_socket);
return EXIT_SUCCESS;
}

47
readme.md
View File

@ -1,47 +0,0 @@
# Protokoll 🔧
```
Als erstes muss der User immer der Befehl eingegeben (send, read, list oder delete). Danach schreibt der Client
immer eine Zeile, was der User als nächstes eingeben soll. Die Buffer Strings der Befehle sind folgerndermaßen
aufgebaut:
SEND: send;sender;empänger;betreff;nachricht
LIST: list;username;postEinAusgang
READ: read;username;postEinAusgang;nid
DEL: del;username;postEinAusgang;nid
Der Buffer wird immer als Ganzes (wie oben beschrieben) vom Client an den Server übertragen (nicht Blockweise).
Der Client fügt die Usereingaben als String zusammen und trennt sie mit einem ";". Der Server splittet den Befehl
dann anhand des Delimiters ";" und geht jedes einzelne Attribut (z.B. username, nid) in einer Schleife durch und
führt den entsprechende Aktionen aus. Als erstes Attribut steht immer der Befehl, damit der Server sofort erkennt,
welche Aktion er ausführen soll. Die nid (Nachrichten ID) wird am Server erzeugt und setzt sich aus einem Timestamp
+ dem Betreff zusammen.
Bei send und delete sendet der Server entweder OK oder ERR zurück. Bei list, die Anzahl der Nachrichten und pro
Zeile den Betreff. Bei read wird die gesamte Nachricht (nid, Sent From/To, Betreff, Nachricht) zurückgesendet.
Am Server gibt es die Verzeichnisse Posteingang und Postausgang. Darin sind Verzeichniss mit den jeweiligen
Usernamen und darin befinden sich .txt Dateien mit den Nachrichten.
Eine Nachricht wird zb. folgerndermaßen am Server gespeichert:
ID: 2020-10-2918:05:32hallo
Sent to: if20b206
Betreff: hallo
Message: wie gehts
```
# Installation
```
sudo apt-get install ldap-utils
sudo apt-get install libldap
sudo apt-get update -y
sudo apt-get install -y libldap-dev
```
# Erstellt von
* Lukas Nowy
* Georg Reisinger

1039
server.c
View File

File diff suppressed because it is too large Load Diff