/* 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
char *verzeichnis;

// Entfernt das \n und macht \0 daraus
void remN(char *s) {
    char *p2 = s;
    while(*s != '\0') {
        if(*s != '\t' && *s != '\n') {
            *p2++ = *s++;
        } else {
            ++s;
        }
    }
    *p2 = '\0';
}

//Checkt ob ein dir bereits existiert
bool dirExists(const char path[300]){
   struct stat st = {0};
   char cwd[300];
   if (getcwd(cwd, sizeof(cwd)) != NULL) {
      //printf("Current working dir: %s\n", cwd);
   } else {
      perror("getcwd() error");
   }
   strcat(cwd, path);
   if (stat(cwd, &st) == 0) {
      printf("\x1b[32mDir: %s exists!\x1b[0m\n", cwd);
      return true;
   }else
   {
      printf("\x1b[31mDir: %s gibt es NICHT!\x1b[0m\n", cwd);
      return false;
   }
}

//Erstellt ein Dir wenn nicht bereits vorhanden
void createDir(const char dir[]){
   if(dirExists(dir) == false){
      char cwd[300];
      if (getcwd(cwd, sizeof(cwd)) != NULL) {
      //printf("Current working dir: %s\n", cwd);
      } else {
         perror("getcwd() error");
      }
      strcat(cwd, dir);
      if(mkdir(cwd, 0700) == -1)
      {
         printf("\x1b[31mFailed to create %s\x1b[0m\n", cwd);
         perror("mkdir");
         exit(EXIT_FAILURE);
      }
      else{
         printf("\x1b[33mCreated directory: %s\x1b[0m\n", cwd);
      }
   }
}

// Die Denyfiles werden gelöscht -1 ist error
int stopDenyUser(char username[10]){
   char cwd[300];
   if (getcwd(cwd, sizeof(cwd)) != NULL) {
      //printf("Current working dir: %s\n", cwd);
   } else {
      perror("getcwd() error");
   }
   strcat(cwd, "/");
   strcat(cwd, verzeichnis);
   strcat(cwd, "/deny/");
   strcat(cwd, username);
   DIR *d = opendir(cwd);
   size_t path_len = strlen(cwd);
   int r = -1;
   if (d) {
      struct dirent *p;
      r = 0;
      while (!r && (p=readdir(d))) {
         int r2 = -1;
         char *buf;
         size_t len;
         /* Skip the names "." and ".." as we don't want to recurse on them. */
         if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
            continue;
         len = path_len + strlen(p->d_name) + 2; 
         buf = malloc(len);
         if (buf) {
            struct stat statbuf;
            snprintf(buf, len, "%s/%s", cwd, p->d_name);
            if (!stat(buf, &statbuf)) {
               if (S_ISDIR(statbuf.st_mode))
                  r2 = stopDenyUser(buf);
               else
                  r2 = unlink(buf);
            }
            free(buf);
         }
         r = r2;
      }
      closedir(d);
   }
   if (!r)
      r = rmdir(cwd);
   return r;
}

// Zählt wv denys ein user bereits hat
int countDenyUser(char username[10]){
   char dir[50];
   strcpy(dir, "/");
   strcat(dir, verzeichnis);
   strcat(dir, "/deny/");
   strcat(dir, username);
   if (dirExists(dir) == false)
   {
      printf("\x1b[31mDIR Exists NICHT!\x1b[0m\n");
      return 0;
   }else
   {
      int file_count = 0;
      DIR * dirp;
      struct dirent * entry;

      char cwd[1000];
      if (getcwd(cwd, sizeof(cwd)) != NULL) {
         //printf("Current working dir: %s\n", cwd);
      } else {
         perror("getcwd() error");
      }
      strcat(cwd, "/");
      strcat(cwd, verzeichnis);
      strcat(cwd, "/deny/");
      strcat(cwd, username);
      dirp = opendir(cwd); /* 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;
   }
}

// Wenn der User 3 Deny Files hat, ist er gesperrt und es kommt true zurück
bool userDenied(char username[10]){
   if (countDenyUser(username) == 3)
   {
      printf("\x1b[31mUser: %s ist gesperrt!\x1b[0m\n", username);
      return true;
   }else
   {
      printf("\x1b[32mUser: %s ist NICHT gesperrt!\x1b[0m\n", username);
      return false;
   }
}

// Erstellt ein Deny User eintrag
void createDenyUser(char username[10]){
   char filename[1000];
   strcpy(filename, "/");
   strcat(filename, verzeichnis);
   strcat(filename, "/deny/");
   strcat(filename, username);
   createDir(filename);
   FILE *fp;
   // Datum besorgen
   char timeStr[22];
   time_t now = time(NULL);
   struct tm *t = localtime(&now);
   strftime(timeStr, sizeof(timeStr)-1, "%H:%M:%S", t);
   char cwd[300];
   if (getcwd(cwd, sizeof(cwd)) != NULL) {
      //printf("Current working dir: %s\n", cwd);
   } else {
      perror("getcwd() error");
   }
   // Filename erstellen
   strcpy(filename, cwd);
   strcat(filename, "/");
   strcat(filename, verzeichnis);
   strcat(filename, "/deny/");
   strcat(filename, username);
   strcat(filename,"/");
   strcat(filename,timeStr);
   strcat(filename, ".txt");
   // File erstellen
   fp = fopen(filename, "w");
   if(fp == NULL){
      perror("fopen");
   }
   fprintf(fp, "DENY");
   fclose(fp);
}

// True wenn der user wieder zugelassen werden darf
bool checkDeniedUser(char username[10]){
   time_t now;
   time(&now);
   struct tm*local = localtime(&now);
   int readHour = 0, readMinutes = 0, readSekundes = 0;
   char cwd[1000];
   if (getcwd(cwd, sizeof(cwd)) != NULL) {
      //printf("Current working dir: %s\n", cwd);
   } else {
      perror("getcwd() error");
   }
   strcat(cwd, "/");
   strcat(cwd, verzeichnis);
   strcat(cwd, "/deny/");
   strcat(cwd, username);
   DIR *d;
   struct dirent *dir;
   d = opendir(cwd);
   if (d)
   {
      while ((dir = readdir(d)) != NULL)
      {
         if(strcmp(dir->d_name, ".") != 0 && strcmp(dir->d_name, "..") != 0){
               //printf("%s\n", dir->d_name);
               sscanf(dir->d_name, "%2d:%2d:%2d", &readHour, &readMinutes, &readSekundes);
               struct tm breakdown = {0};
               breakdown.tm_sec = readSekundes;
               breakdown.tm_hour = readHour;
               breakdown.tm_min = readMinutes;
               breakdown.tm_year = local->tm_year;
               breakdown.tm_mon = local->tm_mon;
               breakdown.tm_mday = local->tm_mday;
               time_t result;
               
               if ((result = mktime(&breakdown)) == (time_t)-1) {
                  fprintf(stderr, "Could not convert time input to time_t\n");
                  perror("checkDeniedUser Read time from file");
               }
               double diff_t;
               diff_t = difftime(now, result);
               printf("\x1b[34mZeitdifferenz: %f\x1b[0m\n", diff_t);
               if (diff_t >= 300 || diff_t <= -300) //300 = 5min
               {
                  return true;
               }
         }
      }
      closedir(d);
   }
   return false;
}

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); 
   while ((entry = readdir(dirp)) != NULL) {
      if (entry->d_type == DT_REG) { 
         file_count++;
      }
   }
   closedir(dirp);
   return file_count;
}

int login_user(char username[10], 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);

    // read password (bash: export ldappw=<yourPW>)
    char ldapBindPassword[256];
    strcpy(ldapBindPassword, 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("\x1b[32mconnected to LDAP server %s\x1b[0m\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("\x1b[34mTotal results: %d\x1b[0m\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("\x1b[35mDN: %s\x1b[0m\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\x1b[35m%s: %s\x1b[0m\n", searchResultEntryAttribute, vals[i]->bv_val);
               if(strcmp(searchResultEntryAttribute,"uid") == 0){
                   if(strcmp(vals[i]->bv_val,rawLdapUser) == 0){                        
                        printf("\n\n\x1b[32mGEFUNDEN!!!!!!!!!!!!!!!!!\x1b[0m\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[10];
                  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){
                     printf("\x1b[32mUser: %s hat den Login geschafft!!\x1b[0m\n", username);
                     if(checkDeniedUser(username) == true){
                           stopDenyUser(username);
                     }
                     if(userDenied(username) == true){
                        //ERR an den client zurücksenden
                        char err[] = "Client Gesperrt";
                        send(new_socket , err , strlen(err) , 0 );
                     }else{
                        //OK an den client zurücksenden
                        char suc[] = "OK";
                        login = true;
                        send(new_socket , suc , strlen(suc) , 0 );
                        stopDenyUser(username);
                     }
                  }else
                  {
                     printf("\x1b[31mUser: %s hat den Login NICHT geschafft!!\x1b[0m\n", username);

                     if(userDenied(username) == false){
                        createDenyUser(username);
                        //ERR an den client zurücksenden
                        char err[] = "ERR";
                        send(new_socket , err , strlen(err) , 0 );
                     }else{
                        //ERR an den client zurücksenden
                        char err[] = "Client Gesperrt";
                        send(new_socket , err , strlen(err) , 0 );
                        if(checkDeniedUser(username) == true){
                           stopDenyUser(username);
                        }
                     }
                  }
                  
               }
               
            }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[10] = "";
                  char empfaenger[10] = "";
                  char betreff[82] = "";

                  //timestamp als ersten teil der id erstellen
                  char ts[22];
                  time_t now = time(NULL);
                  strftime(ts, 22, "%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[300] = "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[300] = "./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[10] = "";
                  char nid[82] = "";
                  char p[22] = "";
                  char path[300] = "";

                  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[10] = "";
                  char nid[82] = "";
                  char betreff[82] = "";
                  char folder[22] = "";

                  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[10] = "";
                  char p[22] = "";
                  char path[300] = "";

                  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("\x1b[33mClient closed remote socket\x1b[0m\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);

   //Verzeichnisse erstellen
   verzeichnis = argv[2];
   char tmpVerzeichnis[300];
   strcpy(tmpVerzeichnis, "/");
   strcat(tmpVerzeichnis, verzeichnis);
   createDir(tmpVerzeichnis);
   char denyDir[300];
   strcpy(denyDir, tmpVerzeichnis);
   strcat(denyDir, "/deny");
   createDir(denyDir);
   char postausgang[300];
   char posteingang[300];
   strcpy(postausgang, tmpVerzeichnis);
   strcat(postausgang, "/postausgang");
   strcpy(posteingang, tmpVerzeichnis);
   strcat(posteingang, "/posteingang");
   createDir(postausgang);
   createDir(posteingang);

  pthread_t tid;
  while (1) {
     printf("\x1b[34mWaiting for connections...\x1b[0m\n");
     new_socket = accept ( create_socket, (struct sockaddr *) &cliaddress, &addrlen );
     if (new_socket > 0)
     {
        printf ("\x1b[32mClient connected from %s:%d...\x1b[0m\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;
}