Ldap Login, Makefile, Color

client.c

@@ -0,0 +1,298 @@
+/* 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>
+#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");
+         fgets (pw, 50, stdin);
+
+         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, 1024); 
+         printf("\n%s\n", readBuffer);
+         if (strncmp(readBuffer, "OK", 2) == 0)
+         {
+            login = true;
+         }
+     }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[8] = "";  
+         char empfaenger[8] = "";
+         char betreff[80] = "";
+         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, 8, stdin);
+
+         printf("\x1b[35m<Empfänger max. 8 Zeichen>\x1b[0m\n");
+         fgets (empfaenger, 8, stdin);
+
+         printf("\x1b[35m<Betreff max. 80 Zeichen>\x1b[0m\n");
+         fgets (betreff, 80, stdin);
+
+         printf("\x1b[35m<Nachricht, beliebige Anzahl an Zeilen>\x1b[0m\n");
+         fgets (nachricht, 80, 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);
+         //printf("Buffer: %s", 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[8] = "";
+         char p[20] = "";
+         int counter = 0;
+
+         printf("\x1b[35m<Username max. 8 Zeichen>\x1b[0m\n");
+         fgets (username, 8, stdin);
+         printf("\x1b[35m<Posteingang oder Postausgang>\x1b[0m\n");
+         fgets (p, 20, stdin);
+
+         strcat(bufferString, ";");
+         strcat(bufferString, username);
+         strcat(bufferString, ";");
+         strcat(bufferString, p);
+         remN(bufferString);
+         printf("%s ", 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);
+               //printf("%.*s", 17, ptr + 5);
+            }
+            
+            counter = counter + 1;
+
+            // naechsten Abschnitt erstellen
+ 	         ptr = strtok(NULL, delimiter);
+         }
+
+      }
+
+      else if(startsWith("read", command) == true) {
+         char bufferString[BUF] = "read";
+         char username[8] = "";
+         char nid[80] = "";
+         char folder[20] = "";
+
+         printf("\x1b[35m<Username max. 8 Zeichen>\x1b[0m\n");
+         fgets (username, 8, stdin);
+         printf("\x1b[35m<posteingang oder postausgang>\x1b[0m\n");
+         fgets (folder, 20, stdin);
+         printf("\x1b[35m<Nachrichten-Nummer>\x1b[0m\n");
+         fgets (nid, 80, stdin);
+
+         strcat(bufferString, ";");
+         strcat(bufferString, username);
+         strcat(bufferString, ";");
+         strcat(bufferString, folder);
+         strcat(bufferString, ";");
+         strcat(bufferString, nid);
+         remN(bufferString);
+
+         //printf("%s ", bufferString);
+
+         send(create_socket, bufferString, strlen (bufferString), 0);
+
+         //strcpy(buffer, "");
+         //buffer[size]= '\0';
+         char readBuffer[BUF] = "";
+         read(create_socket , readBuffer, 1000); 
+         printf("\n%s\n", readBuffer ); 
+
+      }
+
+      else if(startsWith("del", command) == true) {
+         //printf("\n del");
+
+         char username[8] = "";  
+         char nachrichtennummer[80] = "";
+         char bufferString[BUF] = "del";
+         char p[20] = "";
+
+         printf("\x1b[35m<Username max. 8 Zeichen>\x1b[0m\n");
+         fgets (username, 8, stdin);
+         printf("\x1b[35m<Posteingang oder Postausgang>\x1b[0m\n");
+         fgets (p, 20, stdin);
+         printf("\x1b[35m<Nachrichten-Nummer>\x1b[0m\n");
+         fgets (nachrichtennummer, 80, stdin);
+
+         strcat(bufferString, ";");
+         strcat(bufferString, username);
+         strcat(bufferString, ";");
+         strcat(bufferString, p);
+         strcat(bufferString, ";");
+         strcat(bufferString, nachrichtennummer);
+         remN(bufferString);
+         //printf("%s ", 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;
+}

makefile

@@ -0,0 +1,26 @@
+#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
+

myclient.c

@@ -1,103 +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>
-#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 {
-      char *p=getenv("USER");
-      printf("\x1B[32m");
-      printf("%s@%s:%d", p, inet_ntoa (address.sin_addr),ntohs(address.sin_port));
-      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 ){
-         printf("LIST wurde endlich erkannt!\n");
-      }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");
-      }
-      printf("\033[0;33m");
-      printf("$ ");
-      printf("\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;
-}

myserver.c

@@ -1,466 +0,0 @@
-/* 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];
-   strcpy(filename, username);
-   strcat(filename, ".bin");
-   filePointer = fopen(filename, "wb");
-   printf("start getUserMessages() Filename: %s, Username: %s\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)
-{
-   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);
-                  username[strlen(username)-1] = '\0';
-                  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;
-}

readme.md

@@ -0,0 +1,14 @@
+
+# Protokoll 🔧
+
+```
+SEND: send;sender;empänger;betreff;nachricht
+LIST: list:username;postEinAusgang
+READ: read;username;postEinAusgang;nid
+DEL: del;username;postEinAusgang;nid
+```
+
+# Erstellt von 
+
+* Lukas Nowy
+* Georg Reisinger

server.c

@@ -0,0 +1,765 @@
+/* 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 <unistd.h>
+#include <sys/types.h>  /* Linux/UNIX */
+#include <sys/stat.h>   /* Linux/UNIX */
+#include <stdbool.h>
+#include <dirent.h>
+#include <time.h>
+#include <pthread.h>
+#include <ldap.h>
+#include <termios.h>
+
+#define MAXCHAR 1000
+
+#define BUF 1024
+
+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;
+}
+
+void mstore_data(const char *filepath, const char *data)
+{
+    FILE *fp = fopen(filepath, "ab");
+    if (fp != NULL)
+    {
+        fputs(data, fp);
+        fclose(fp);
+    }
+}
+
+int countFiles(char path[]) {
+    int file_count = 0;
+    DIR * dirp;
+    struct dirent * entry;
+
+    dirp = opendir(path); /* There should be error handling after this */
+    while ((entry = readdir(dirp)) != NULL) {
+        if (entry->d_type == DT_REG) { /* If the entry is a regular file */
+            file_count++;
+        }
+    }
+    closedir(dirp);
+
+    return file_count;
+}
+
+int login_user(char username[8], char pw[50])
+{
+    ////////////////////////////////////////////////////////////////////////////
+    // LDAP config
+    // anonymous bind with user and pw empty
+    const char *ldapUri = "ldap://ldap.technikum-wien.at:389";
+    const int ldapVersion = LDAP_VERSION3;
+
+    // read username (bash: export ldapuser=<yourUsername>)
+    char ldapBindUser[256];
+    char rawLdapUser[128];
+    strcpy(rawLdapUser, username);
+    sprintf(ldapBindUser, "uid=%s,ou=people,dc=technikum-wien,dc=at", rawLdapUser);
+    printf("user set to: %s\n", ldapBindUser);
+
+
+    // read password (bash: export ldappw=<yourPW>)
+    char ldapBindPassword[256];
+    strcpy(ldapBindPassword, pw);
+    printf("pw taken over from commandline: %s\n", pw);
+   
+
+   // search settings
+   const char *ldapSearchBaseDomainComponent = "dc=technikum-wien,dc=at";
+   const char *ldapSearchFilter = "(uid=if20b20*)";
+   ber_int_t ldapSearchScope = LDAP_SCOPE_SUBTREE;
+   const char *ldapSearchResultAttributes[] = {"uid", "cn", NULL};
+
+   // general
+   int rc = 0; // return code
+
+   ////////////////////////////////////////////////////////////////////////////
+   // setup LDAP connection
+   // https://linux.die.net/man/3/ldap_initialize
+   LDAP *ldapHandle;
+   rc = ldap_initialize(&ldapHandle, ldapUri);
+   if (rc != LDAP_SUCCESS)
+   {
+      fprintf(stderr, "ldap_init failed\n");
+      return 0;
+   }
+   printf("connected to LDAP server %s\n", ldapUri);
+
+   ////////////////////////////////////////////////////////////////////////////
+   // set verison options
+   // https://linux.die.net/man/3/ldap_set_option
+   rc = ldap_set_option(
+       ldapHandle,
+       LDAP_OPT_PROTOCOL_VERSION, // OPTION
+       &ldapVersion);             // IN-Value
+   if (rc != LDAP_OPT_SUCCESS)
+   {
+      // https://www.openldap.org/software/man.cgi?query=ldap_err2string&sektion=3&apropos=0&manpath=OpenLDAP+2.4-Release
+      fprintf(stderr, "ldap_set_option(PROTOCOL_VERSION): %s\n", ldap_err2string(rc));
+      ldap_unbind_ext_s(ldapHandle, NULL, NULL);
+      return 0;
+   }
+
+   ////////////////////////////////////////////////////////////////////////////
+   // start connection secure (initialize TLS)
+   // https://linux.die.net/man/3/ldap_start_tls_s
+   // int ldap_start_tls_s(LDAP *ld,
+   //                      LDAPControl **serverctrls,
+   //                      LDAPControl **clientctrls);
+   // https://linux.die.net/man/3/ldap
+   // https://docs.oracle.com/cd/E19957-01/817-6707/controls.html
+   //    The LDAPv3, as documented in RFC 2251 - Lightweight Directory Access
+   //    Protocol (v3) (http://www.faqs.org/rfcs/rfc2251.html), allows clients
+   //    and servers to use controls as a mechanism for extending an LDAP
+   //    operation. A control is a way to specify additional information as
+   //    part of a request and a response. For example, a client can send a
+   //    control to a server as part of a search request to indicate that the
+   //    server should sort the search results before sending the results back
+   //    to the client.
+   rc = ldap_start_tls_s(
+       ldapHandle,
+       NULL,
+       NULL);
+   if (rc != LDAP_SUCCESS)
+   {
+      fprintf(stderr, "ldap_start_tls_s(): %s\n", ldap_err2string(rc));
+      ldap_unbind_ext_s(ldapHandle, NULL, NULL);
+      return 0;
+   }
+
+   ////////////////////////////////////////////////////////////////////////////
+   // bind credentials
+   // https://linux.die.net/man/3/lber-types
+   // SASL (Simple Authentication and Security Layer)
+   // https://linux.die.net/man/3/ldap_sasl_bind_s
+   // int ldap_sasl_bind_s(
+   //       LDAP *ld,
+   //       const char *dn,
+   //       const char *mechanism,
+   //       struct berval *cred,
+   //       LDAPControl *sctrls[],
+   //       LDAPControl *cctrls[],
+   //       struct berval **servercredp);
+
+   BerValue bindCredentials;
+   bindCredentials.bv_val = (char *)ldapBindPassword;
+   bindCredentials.bv_len = strlen(ldapBindPassword);
+   BerValue *servercredp; // server's credentials
+   rc = ldap_sasl_bind_s(
+       ldapHandle,
+       ldapBindUser,
+       LDAP_SASL_SIMPLE,
+       &bindCredentials,
+       NULL,
+       NULL,
+       &servercredp);
+   if (rc != LDAP_SUCCESS)
+   {
+      fprintf(stderr, "LDAP bind error: %s\n", ldap_err2string(rc));
+      ldap_unbind_ext_s(ldapHandle, NULL, NULL);
+      return 0;
+   }
+
+   ////////////////////////////////////////////////////////////////////////////
+   // perform ldap search
+   // https://linux.die.net/man/3/ldap_search_ext_s
+   // _s : synchronous
+   // int ldap_search_ext_s(
+   //     LDAP *ld,
+   //     char *base,
+   //     int scope,
+   //     char *filter,
+   //     char *attrs[],
+   //     int attrsonly,
+   //     LDAPControl **serverctrls,
+   //     LDAPControl **clientctrls,
+   //     struct timeval *timeout,
+   //     int sizelimit,
+   //     LDAPMessage **res );
+   LDAPMessage *searchResult;
+   rc = ldap_search_ext_s(
+       ldapHandle,
+       ldapSearchBaseDomainComponent,
+       ldapSearchScope,
+       ldapSearchFilter,
+       (char **)ldapSearchResultAttributes,
+       0,
+       NULL,
+       NULL,
+       NULL,
+       500,
+       &searchResult);
+   if (rc != LDAP_SUCCESS)
+   {
+      fprintf(stderr, "LDAP search error: %s\n", ldap_err2string(rc));
+      ldap_unbind_ext_s(ldapHandle, NULL, NULL);
+      return 0;
+   }
+   // https://linux.die.net/man/3/ldap_count_entries
+   printf("Total results: %d\n", ldap_count_entries(ldapHandle, searchResult));
+
+   ////////////////////////////////////////////////////////////////////////////
+   // get result of search
+   // https://linux.die.net/man/3/ldap_first_entry
+   // https://linux.die.net/man/3/ldap_next_entry
+   LDAPMessage *searchResultEntry;
+   for (searchResultEntry = ldap_first_entry(ldapHandle, searchResult);
+        searchResultEntry != NULL;
+        searchResultEntry = ldap_next_entry(ldapHandle, searchResultEntry))
+   {
+      /////////////////////////////////////////////////////////////////////////
+      // Base Information of the search result entry
+      // https://linux.die.net/man/3/ldap_get_dn
+      printf("DN: %s\n", ldap_get_dn(ldapHandle, searchResultEntry));
+
+      /////////////////////////////////////////////////////////////////////////
+      // Attributes
+      // https://linux.die.net/man/3/ldap_first_attribute
+      // https://linux.die.net/man/3/ldap_next_attribute
+      //
+      // berptr: berptr, a pointer to a BerElement it has allocated to keep
+      //         track of its current position. This pointer should be passed
+      //         to subsequent calls to ldap_next_attribute() and is used to
+      //         effectively step through the entry's attributes.
+      BerElement *ber;
+      char *searchResultEntryAttribute;
+      for (searchResultEntryAttribute = ldap_first_attribute(ldapHandle, searchResultEntry, &ber);
+           searchResultEntryAttribute != NULL;
+           searchResultEntryAttribute = ldap_next_attribute(ldapHandle, searchResultEntry, ber))
+      {
+         BerValue **vals;
+         if ((vals = ldap_get_values_len(ldapHandle, searchResultEntry, searchResultEntryAttribute)) != NULL)
+         {
+            for (int i = 0; i < ldap_count_values_len(vals); i++)
+            {
+               printf("\t%s: %s\n", searchResultEntryAttribute, vals[i]->bv_val);
+               if(strcmp(searchResultEntryAttribute,"uid") == 0){
+                   if(strcmp(vals[i]->bv_val,rawLdapUser) == 0){                        
+                        printf("\n\nGEFUNDEN!!!!!!!!!!!!!!!!!\n\n");
+                        // Free Memory
+                        ldap_value_free_len(vals);
+                        ldap_memfree(searchResultEntryAttribute);
+                        if (ber != NULL){
+                            ber_free(ber, 0);
+                        }
+                        printf("\n");
+                        ldap_msgfree(searchResult);
+                        ldap_unbind_ext_s(ldapHandle, NULL, NULL);
+                        return 1;
+                   }
+               }
+            }
+            ldap_value_free_len(vals);
+         }
+
+         // free memory
+         ldap_memfree(searchResultEntryAttribute);
+      }
+      // free memory
+      if (ber != NULL)
+      {
+         ber_free(ber, 0);
+      }
+
+      printf("\n");
+   }
+
+   // free memory
+   ldap_msgfree(searchResult);
+
+   ////////////////////////////////////////////////////////////////////////////
+   // https://linux.die.net/man/3/ldap_unbind_ext_s
+   // int ldap_unbind_ext_s(
+   //       LDAP *ld,
+   //       LDAPControl *sctrls[],
+   //       LDAPControl *cctrls[]);
+   ldap_unbind_ext_s(ldapHandle, NULL, NULL);
+
+   return 0;
+}
+
+void *threadFun(void *arg){
+   int new_socket = *((int *)arg);
+   char buffer[BUF];
+   pthread_detach(pthread_self());
+   if(new_socket > 0){
+      strcpy(buffer, "Welcome to Lukas & Georgs Server, Please type <login> to login:\n");
+      send(new_socket, buffer, strlen(buffer),0);
+   }
+   bool login = false;
+   do {
+        int size = recv (new_socket, buffer, BUF-1, 0);
+        if( size > 0)
+        {
+
+           buffer[size] = '\0';
+            if (login == false)
+            {
+               // Do login
+               if (strncmp("login", buffer, 5) == 0)
+               {
+                  char delimiter[] = ";";
+                  char *ptr;
+                  //den buffer mit dem seperator splitten
+                  ptr = strtok(buffer, delimiter);
+                  int counter = 0;
+                  char username[9];
+                  char pw[50];
+                  while(ptr != NULL) {
+                     if (counter == 1) {
+                        strcpy(username, ptr);
+                     }else if(counter == 2)
+                     {
+                        strcpy(pw, ptr);
+                     }
+                     counter = counter + 1;
+                     // naechsten Abschnitt erstellen
+                     ptr = strtok(NULL, delimiter);
+                  }
+                  if(login_user(username, pw) == 1){
+                     login = true;
+                     printf("Login geschafft!!");
+                     //OK an den client zurücksenden
+                     char suc[] = "OK";
+                     send(new_socket , suc , strlen(suc) , 0 );
+                  }else
+                  {
+                     printf("Login error!!!");
+                     //OK an den client zurücksenden
+                     char err[] = "ERR";
+                     send(new_socket , err , strlen(err) , 0 );
+                  }
+                  
+               }
+               
+            }else{// Is logedin
+               // Überprüfen welchen command der client eingegeben hat,
+               // wenn command nicht zutreffend error zurücksenden
+               if(startsWith("send", buffer) == true) {
+
+                  char delimiter[] = ";";
+                  char *ptr;
+                  //den buffer mit dem seperator splitten
+                  ptr = strtok(buffer, delimiter);
+
+                  int counter = 0;
+                  char sender[8] = "";
+                  char empfaenger[8] = "";
+                  char betreff[80] = "";
+
+                  //timestamp als ersten teil der id erstellen
+                  char ts[20];
+                  time_t now = time(NULL);
+                  strftime(ts, 20, "%Y-%m-%d%H:%M:%S", localtime(&now));
+                  
+
+                  //den gesplitteten buffer schritt für schritt durchgehen
+                  while(ptr != NULL) {
+                     //printf("Abschnitt gefunden: %s\n", ptr);
+                     //sender auslesen, ordner für sender erstellen, wenn nicht vorhanden
+                     if (counter == 1) {
+                        struct stat st = {0};
+                        char dir[] = "./data/postausgang/";
+                        strcat(dir, ptr);
+
+                        if (stat(dir, &st) == -1) {
+                           mkdir(dir, 0700);
+                        }
+
+                        strcat(sender, ptr);
+                        printf("1 %s \n", ptr);
+                     }
+                     
+                     //empfänger auslesen, ordner für empfänger erstellen, wenn nicht vorhanden
+                     if (counter == 2) {
+                        struct stat st2 = {0};
+                        char dir2[] = "./data/posteingang/";
+                        strcat(dir2, ptr);
+
+                        if (stat(dir2, &st2) == -1) {
+                           mkdir(dir2, 0700);
+                        }
+
+                        strcat(empfaenger, ptr);
+                        printf("2 %s \n" , ptr);
+                     }
+
+                     //betreff auslesen, id (ts) fertigstellen,  
+                     //2 dateien erstellen für sender und empfänger mit ts als filename
+                     if (counter == 3) {
+                        //printf("3 %s \n", ptr);
+
+                        strcat(betreff, ptr);
+                        strcat(ts, betreff);
+
+                        //Pfad erstellen für den sender und file erstellen
+                        char fb[100] = "touch ./data/postausgang/";
+                        strcat(fb, "/");
+                        strcat(fb, sender);
+                        strcat(fb, "/");
+                        strcat(fb, ts);
+                        printf("PATH: %s \n", fb);
+                        system(fb);
+
+                        //Pfad erstellen für den empfänger und file erstellen
+                        strcpy(fb, "touch ./data/posteingang/");
+                        strcat(fb, "/");
+                        strcat(fb, empfaenger);
+                        strcat(fb, "/");
+                        strcat(fb, ts);
+                        printf("PATH: %s \n", fb);
+                        system(fb);
+
+                     }
+
+                     //buffer in files schreiben
+                     if (counter == 4) {
+                           //printf("4 %s \n", ptr);
+
+                           //file content für den empfänger erstellen
+                           char fp[100] = "./data/posteingang/";
+                           char content1[1000] = "";
+                           strcpy(content1, "ID: ");
+                           strcat(content1, ts);
+                           strcat(content1, "\n");
+                           strcat(content1, "Received from: ");
+                           strcat(content1, sender);
+                           strcat(content1, "\n");
+                           strcat(content1, "Betreff: ");
+                           strcat(content1, betreff);
+                           strcat(content1, "\n");
+                           strcat(content1, "Message: ");
+                           strcat(content1, ptr); 
+
+                           strcat(fp, empfaenger);
+                           strcat(fp, "/");
+                           strcat(fp, ts);
+                           //content in das file storen
+                           mstore_data(fp, content1);
+
+                           //file content für den sender erstellen
+                           char content2[1000] = "";
+                           strcpy(content2, "ID: ");
+                           strcat(content2, ts);
+                           strcat(content2, "\n");
+                           strcat(content2, "Sent to: ");
+                           strcat(content2, empfaenger);
+                           strcat(content2, "\n");
+                           strcat(content2, "Betreff: ");
+                           strcat(content2, betreff);
+                           strcat(content2, "\n");
+                           strcat(content2, "Message: ");
+                           strcat(content2, ptr);
+
+                           strcpy(fp, "./data/postausgang/");
+                           strcat(fp, sender);
+                           strcat(fp, "/");
+                           strcat(fp, ts);
+                           //content2 in das file storen
+                           mstore_data(fp, content2);
+
+                     }
+                     counter = counter + 1;
+                     // naechsten Abschnitt erstellen
+                     ptr = strtok(NULL, delimiter);
+
+                  }
+
+                  //printf ("\n Message received: \n %s", buffer);
+                  //OK an den client zurücksenden
+                  char suc[] = "OK";
+                  send(new_socket , suc , strlen(suc) , 0 );
+
+               }
+
+               else if(startsWith("del", buffer) == true) {
+                  printf("delete: %s ", buffer);
+
+                  char delimiter[] = ";";
+                  char *ptr;
+                  ptr = strtok(buffer, delimiter);
+
+                  int counter = 0;
+
+                  char username[8] = "";
+                  char nid[80] = "";
+                  char p[20] = "";
+                  char path[100] = "";
+
+                  while(ptr != NULL) {
+
+                     //username speichern
+                     if(counter == 1) {
+                        strcat(username, ptr);
+                     }
+
+                     //post ein- oder ausgang speichern
+                     if(counter == 2) {
+                        strcpy(p, ptr);
+                     }
+
+                     //nid speichern, den path string erstellen, rm -rf path ausführen
+                     if(counter == 3) {
+                        strcat(nid, ptr);
+                        if(strcmp(p, "postausgang") == 0) {
+                           strcpy(path, "rm -rf ./data/postausgang/");
+                        }
+
+                        if(strcmp(p, "posteingang") == 0) {
+                           strcpy(path, "rm -rf ./data/posteingang/");
+                        }
+                        
+                        strcat(path, username);
+                        strcat(path, "/");
+                        strcat(path, nid);
+
+                        system(path);
+                     }
+                     counter = counter + 1;
+
+                     // naechsten Abschnitt erstellen
+                     ptr = strtok(NULL, delimiter);
+                  }
+
+               //OK an client zurücksenden
+               char resBuff[BUF] = "OK\n";
+               send(new_socket, resBuff, strlen(resBuff),0);
+               strcpy(buffer, "");
+
+               }
+
+               //read
+               else if(startsWith("read", buffer) == true) {
+
+                  char delimiter[] = ";";
+                  char *ptr;
+                  ptr = strtok(buffer, delimiter);
+
+                  int counter = 0;
+                  char username[8] = "";
+                  char nid[80] = "";
+                  char betreff[80] = "";
+                  char folder[20] = "";
+
+                  while(ptr != NULL) { 
+
+                     if(counter == 1) {
+                        //username speichern
+                        strcat(username, ptr);
+                     }
+
+                     //postein- oder ausgang speichern
+                     if(counter == 2) {
+                           strcpy(folder, ptr);
+                     }
+
+                     //nid speichern, file mit dem path lesen und an client zzrücksenden
+                     if(counter == 3) {
+                        //nid
+                        strcat(nid, ptr);
+                        strcpy(betreff, nid);
+                        
+
+                        char filename[] = "./data/";
+                        strcat(filename, folder);
+                        strcat(filename, "/");
+
+                        strcat(filename, username);
+                        strcat(filename, "/");
+                        strcat(filename, nid);
+                        printf("PATH: %s", filename);
+   
+                        FILE *ptr_file;
+                        char buf[1000];
+                        char res[1000];
+
+                        ptr_file = fopen(filename,"r");
+                        if (!ptr_file)
+                           perror("File Open error!");
+
+                        while (fgets(buf,1000, ptr_file)!=NULL) {
+                           strcat(res, buf);
+                        }
+
+
+                        fclose(ptr_file);
+
+                        
+                        // and send that buffer to client 
+
+                        printf("%s", res);
+                        send(new_socket , res, strlen(res), 0 );
+
+                     }
+
+                     counter = counter + 1;
+
+                     // naechsten Abschnitt erstellen
+                     ptr = strtok(NULL, delimiter);
+                  }
+               }
+
+               //list
+               else if(startsWith("list", buffer) == true) {
+
+                  char delimiter[] = ";";
+                  char *ptr;
+                  ptr = strtok(buffer, delimiter);
+
+                  int counter = 0;
+                  char username[8] = "";
+                  char p[20] = "";
+                  char path[100] = "";
+
+                  while(ptr != NULL) {
+
+                     //username speichern
+                     if(counter == 1) {
+                        strcat(username, ptr);
+                     }
+
+                     //postein - oder ausgang speichern
+                     if(counter == 2) {
+                        strcat(p, ptr);
+
+                        if(strcmp(p, "postausgang") == 0) {
+                           strcpy(path, "./data/postausgang/");
+                        }
+
+                        if(strcmp(p, "posteingang") == 0) {
+                           strcpy(path, "./data/posteingang/");
+                        }
+                        
+                        strcat(path, username);
+                        strcat(path, "/");
+
+                        DIR *d;
+                        struct dirent *dir;
+                        char filenames[1000] = "";
+
+                        //Messages zählen
+                        int fc = countFiles(path);
+                        char str[1000];
+                        //int in string konverten
+                        sprintf(str, "%d", fc);
+
+                        strcat(filenames, str);
+                        strcat(filenames, ";");
+
+                        //file lesen
+                        d = opendir(path);
+
+                        if (d)
+                        {
+
+                           while ((dir = readdir(d)) != NULL)
+                           {
+                              strcat(filenames, dir->d_name);
+                              strcat(filenames, ";");
+                           }
+
+                        closedir(d);
+
+                        //an client senden
+                        send(new_socket , filenames , strlen(filenames) , 0 );
+                        strcpy(buffer, "");
+
+                        }
+
+                     }
+
+
+                     counter = counter + 1;
+
+                     // naechsten Abschnitt erstellen
+                     ptr = strtok(NULL, delimiter);
+                  }
+
+
+               }else {
+                  printf("error");
+                  char err[] = "ERR";
+                  send(new_socket , err , strlen(err) , 0 );
+
+               }
+            }
+
+            //printf ("\n content: \n %s", buffer);
+
+
+        }
+        else if (size == 0)
+        {
+           printf("Client closed remote socket\n");
+           break;
+        }
+        else
+        {
+           perror("recv error");
+           char err[] = "ERR";
+           send(new_socket , err , strlen(err) , 0 );
+        }
+
+     } while (strncmp (buffer, "quit", 4)  != 0);
+     close (new_socket);
+     pthread_exit(NULL);
+}
+
+
+int main (int argc, char **argv) {
+  int create_socket, new_socket;
+  socklen_t addrlen;
+  struct sockaddr_in address, cliaddress;
+
+  if( argc < 3 ){
+     printf("Usage: %s S Port Verzeichniss\n", argv[0]);
+     exit(EXIT_FAILURE);
+  }
+
+  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 (atoi(argv[1]));
+
+  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);
+
+  //Verzeichniss erstellen
+
+  mkdir(argv[2], 0711);
+  pthread_t tid;
+  while (1) {
+     printf("Waiting for connections...\n");
+     new_socket = accept ( create_socket, (struct sockaddr *) &cliaddress, &addrlen );
+     if (new_socket > 0)
+     {
+        printf ("Client connected from %s:%d...\n", inet_ntoa (cliaddress.sin_addr),ntohs(cliaddress.sin_port));
+     }
+     if (pthread_create(&tid, NULL, threadFun, &new_socket) != 0)
+     {
+        perror("Failed to create thread");
+        exit(EXIT_FAILURE);
+     }
+  }
+  close (create_socket);
+  return EXIT_SUCCESS;
+}