575 lines
19 KiB
C
Executable File
575 lines
19 KiB
C
Executable File
/* 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");
|
|
fclose(filePointer);
|
|
printf("\nBETREFF in readFile(): %s", my_record.betreff);
|
|
//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, sender);
|
|
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);
|
|
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");
|
|
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);
|
|
printf("\n\nNachricht: %d Betreff: %s\n\n", i, my_record_p.betreff);
|
|
userFilesStruct[i] = my_record_p;
|
|
printf("2.6.%d\n", i);
|
|
}
|
|
printf("3\n");
|
|
|
|
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);
|
|
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\nNachricht: %d Betreff: %s\n\n", i, my_record_p.betreff);
|
|
userFilesStructAusgang[i] = my_record_p;
|
|
printf("2.6.%d\n", i);
|
|
}
|
|
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;
|
|
} |