twmailer_vsys/myserver.c

/* 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>
#define BUF 1024
#define PORT 6543

struct msgNumber
{
   int index;
};
struct msgNumberArr
{
   int lenght;
   int index[1024];
};

int writeUsersMessages(char username[1024], int *msgNumbs, int lenght)
{
   FILE *filePointer;
   printf("Start writeUsersMessages() username: %s", username);
   strcat(username, ".bin");
   filePointer = fopen(username, "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, username);
   strcat(filename, ".bin");
   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("\nmsgNumberSrtruct lenght: %d\n", msgNumbersStruct.lenght);
   //}
   //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;
   filePointer = fopen("msgNumber.bin", "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;
   filePointer = fopen("msgNumber.bin", "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];
   strcat(fullfilename, filename);
   strcat(fullfilename, ".bin");
   filePointer = fopen(fullfilename, "rb");
   struct rec my_record;
   if (!filePointer)
   {
      printf("\x1B[31mFile konnte nicht gelesen werden!\x1B[37m\n");
      my_record.sender = "0";
      my_record.receiver = "0";
      my_record.betreff = "0";
      my_record.msg = "0";
      return my_record;
   }
   fread(&my_record, sizeof(struct msgNumber), 1, filePointer);
   fclose(filePointer);
   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);
      sprintf(filename, "%d", msgNumber);
      strcat(filename, ".bin");
      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);
         int receiverresult = addUserMessage(receiver, msgNumber);
         printf("receiverresult: %d", receiverresult);
         int senderresult = addUserMessage(sender, 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;
         }
      }
   }
}

int main(int argc, char **argv)
{
   char *verzeichnis = 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);
                  printf("USERNAME: %s ENDE", username);

                  struct msgNumberArr msgNumbersStruct = getUserMessages(username);
                  printf("msgnumberstruct lenght: %d", msgNumbersStruct.lenght);
                  int msgNumbers[1024];
                  for (int i = 0; i < msgNumbersStruct.lenght; i++)
                  {
                     msgNumbers[i] = msgNumbersStruct.index[i];
                     printf("MSG NUMMBER IN addUserMessage(): %d\n", msgNumbers[i]);
                  }

                  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;
}