/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include "util.h"

#ifndef TRUE
#define TRUE 0
#endif

#ifndef FALSE
#define FALSE 1
#endif

#ifndef PASSWD_FILE
#define PASSWD_FILE "/etc/mypasswd"
#endif

int str2int(const char * string) {
/* -----------------------------------------------------------------------------
 * Convert a string to int 
 *
 * @param  const char *, the given string
 * @return int   -1 if the given string do not represent an integer
 * -------------------------------------------------------------------------- */

  int     result = 0;
  int     int_tmp;
  const char * pts = string;

  while (*pts != '\0') {
    int_tmp = *pts - 48;
    if((int_tmp >= 0) && (int_tmp <= 9)) {
      result = 10*result + int_tmp;
    }
    else if (*pts != ' ') {
      return -1;
    }
    pts++;
  }

  return result;

}

char * substring(const char * src, int start, int length) {
/* -----------------------------------------------------------------------------
 * get a substring in a string
 *
 * @param  const char *, source string
 * @param  int, the offset
 * @param  int, the length
 * @return char *, result in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */

  char *result = (char *)malloc(sizeof(char) * length + 1);

  if (result == NULL) {
    logmsg(LOG_ERR, "substring() : %s", strerror(errno));
    return NULL;
  }

  memcpy(result, &src[start], length);
  result[length] = '\0';
  return result;

}

char * str_replace(const char * strfrom, const char * strby, const char * strin) {
/* -----------------------------------------------------------------------------
 * Replace a string by another string in a string
 *
 * @param  const char *, string to replace
 * @param  const char *, string replacement
 * @param  const char *, source string
 * @return char *, result in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */

  char *result = NULL, *tmp, *pos;
  char *p = (char *)strin;
  size_t len_from, len_by, len, total_len = 0;

  len_from = strlen(strfrom);
  len_by = strlen(strby);

  while ((pos = strstr(p, strfrom)) != NULL) {
    /* Compute the new length */
    len = (pos - p) + len_by;
    tmp = realloc(result, (total_len + len) * sizeof(char) + 1);
    if (tmp == NULL) {
      logmsg(LOG_ERR, "str_replace() : %s", strerror(errno));
      return NULL;
    }
    result = tmp;

    memcpy(&result[total_len], p, sizeof(char) * (pos - p));
    memcpy(&result[total_len + (pos - p)], strby, sizeof(char) * len_by);

    total_len += len;
    p = pos + len_from;
  }
  if (*p) {
    len = strlen(p);
    tmp = realloc(result, (total_len + len) * sizeof(char) + 1);
    if (tmp == NULL) {
      logmsg(LOG_ERR, "str_replace() : %s", strerror(errno));
      return NULL;
    }
    result = tmp;
    memcpy(&result[total_len], p, sizeof(char) * len);
    total_len += len;
  }
  result[total_len] = '\0';

  if (total_len > 0)
    return result;
  return strdup(strin);
}

char * trim(const char * strin) {
/* -----------------------------------------------------------------------------
 * Trim in the given string
 *
 * @param  const char *
 * @return char *, result in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */
  char * result = NULL;
  char *pts_start, *pts_end;
  unsigned int left = 0;
  unsigned int right = 0;
  size_t size = strlen(strin);
  const char delimiters[] = " \t\n\r";

  if (size <= 0)
    return NULL;

  pts_start = (char *)strin;
  pts_end = (char *)&strin[size - 1];

  /* Left trim */
  while((*pts_start != '\0') && ((strchr(delimiters, (int)*pts_start)) != NULL)) {
    left++;
    pts_start++;
  }
  /* Right trim */
  while((pts_end != strin) && ((strchr(delimiters, (int)*pts_end)) != NULL)) {
    right++;
    pts_end--;
  }

  result = (char *)malloc((size - left - right) * sizeof(char) + 1);
  if (result == NULL) {
    logmsg(LOG_ERR, "trim() : %s", strerror(errno));
    return NULL;
  }

  memcpy(result, (void *)&strin[left], (size - left - right) * sizeof(char));
  result[size - left - right] = '\0';
  return result;
}

char * stripcrlf(char * str) {
/* -----------------------------------------------------------------------------
 * Strip CRLR in the given string
 *
 * @param  char *
 * @return char *
 * -------------------------------------------------------------------------- */
  char *pts = str + strlen(str);

  while(pts - str >= 0) {
    if ((*pts == 10) || (*pts == 13))
      *pts = '\0';
    pts--;
  }

  return pts;

}

char * str2upper(const char * strin) {
/* -----------------------------------------------------------------------------
 * Upper case all character in the given string
 *
 * @param  const char *
 * @return char *, result in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */

  char * result = NULL, * pts;
  result = strdup(strin);
  if (result == NULL) {
    logmsg(LOG_ERR, "str2upper() : strdup error");
    return NULL;
  }
  for (pts = result; *pts; pts++) {
    if ((*pts >= 97)
    && (*pts <= 122))
      *pts -= 32;
  }
  
  return result;
}

char * str2lower(const char * strin) {
/* -----------------------------------------------------------------------------
 * Lower case all character in the given string
 *
 * @param  const char *
 * @return char *, result in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */

  char * result = NULL, * pts;
  result = strdup(strin);
  if (result == NULL) {
    logmsg(LOG_ERR, "str2upper() : strdup error");
    return NULL;
  }
  for (pts = result; *pts; pts++) {
    if ((*pts >= 65)
    && (*pts <= 90))
      *pts += 32;
  }
  
  return result;
}

char * getlocaltime() {
/* -----------------------------------------------------------------------------
 * Get local datetime in YYY-MM-DD hh:mm:ss format
 *
 * @return char *, result in a statically allocated memory
 * -------------------------------------------------------------------------- */

  static char strtime[20];
  time_t timer = time(NULL);
  struct tm now = *localtime(&timer);

  snprintf(strtime, sizeof(strtime), "%4d-%02d-%02d %02d:%02d:%02d",
          now.tm_year + 1900, now.tm_mon, now.tm_mday,
          now.tm_hour, now.tm_min, now.tm_sec);

  return strtime;

}

char * getdate() {
/* -----------------------------------------------------------------------------
 * Get date in YYYY-MM-DD format
 *
 * @param  int
 * @return char *, result in a statically allocated memory
 * -------------------------------------------------------------------------- */

  static char strtime[11];
  time_t timer = time(NULL);
  struct tm now = *localtime(&timer);

  snprintf(strtime, sizeof(strtime), "%4d-%02d-%02d",
          now.tm_year+1900, now.tm_mon+1, now.tm_mday);

  return strtime;

}

char * gettime() {
/* -----------------------------------------------------------------------------
 * Get time
 *
 * @return char *, result in a statically allocated memory
 * -------------------------------------------------------------------------- */

  static char strtime[11];
  time_t timer = time(NULL);
  struct tm now = *localtime(&timer);

  snprintf(strtime, sizeof(strtime), "%02d:%02d:%02d",
          now.tm_hour, now.tm_min, now.tm_sec);

  return strtime;

}


char * formatdate(int secondes) {
/* -----------------------------------------------------------------------------
 * Format second to date
 *
 * @param  int
 * @return char *, result in a statically allocated memory
 * -------------------------------------------------------------------------- */

  int jour, heure, minute, seconde;
  static char strtime[20];

  jour = secondes / 86400;
  heure = (secondes  - (jour * 86400)) / 3600;
  minute = (secondes - (jour * 86400) - (heure * 3600)) / 60;
  seconde = secondes - (jour * 86400) - (heure * 3600) - (minute * 60);

  snprintf(strtime, sizeof(strtime), "%dj %02dh%02dm%02ds", jour, heure, minute, seconde);

  return strtime;

}

char * addslashes(char * str_in) {
/* -----------------------------------------------------------------------------
 * Addslashes before characters such as ', `, "
 *
 * @param  const char *
 * @return char *, result in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */

  char *result, *result_realloc, *result_tmp;
  char * pts = str_in;
  int len = strlen(str_in)+1;
  result = (char *)malloc(len);

  if (result == NULL) {
    logmsg(LOG_ERR, "addslashes : malloc error");
    return NULL;
  }

  memset(result, 0, len);

  result_tmp = result;
  /* printf("%s %d %d\n", pts, len, sizeof(char)); */

  while(*pts != '\0') {
    
    switch((int)*pts) {
      case 39: /* ' */
      case 34: /* " */
      case 96: /* ` */
        len++;
        result_realloc = (char *)realloc(result, len);
        if (result_realloc == NULL) {
          logmsg(LOG_ERR, "addslashes : realloc error");
          free(result);
          return NULL;
        }
        result = result_realloc;

        *(result+len-1) = '\0';
        *result_tmp = (char)92;
        result_tmp++;
        break;
    }
    *result_tmp = *pts;
    pts++;
    result_tmp++;
  }
  *result_tmp = '\0';
  /* printf("%s\n", result);
  printf("%s\n", result_tmp);
  printf("len %d, %d, %d, %d\n", len, result_tmp-result, strlen(result), strlen(result_tmp)); */

  return result;

}

#ifdef USE_CRYPT
char * md5(const char * pwd) {
/* -----------------------------------------------------------------------------
 * Crypt a string in a md5 crypt manner
 *
 * @param  const char *, the string to crypt
 * @return char *, the crypt result in a static memory
 * -------------------------------------------------------------------------- */

  char salt[3];
  char des_salt[12];
  char *tmp = NULL;
  memset(&salt, 0, 3);
  memset(&des_salt, 0, 12);

  if (strlen(pwd) < 2) {
    return NULL;
  }
  snprintf(salt, sizeof(salt), "%c%c", *pwd, *(pwd+1));
  tmp = crypt(pwd, salt);
  if (tmp != NULL && strlen(tmp) > 2) {
    snprintf(des_salt, sizeof(des_salt), "$1$%s", tmp + 2);
    des_salt[12] = '\0';
    return (char *)crypt(pwd, des_salt);
  }
  return NULL;
}
#endif

void vsysdaemonlog(const char *pgm, const char * filename, const char * line, va_list ap) {
/* -----------------------------------------------------------------------------
 * Custom log system to a file
 *
 * @param  const char *, program name
 * @param  const char *, file name
 * @param  const char *, printf format
 * @param  va_list, arguments list
 * -------------------------------------------------------------------------- */

  int pid;
  char *msg = NULL, *logline = NULL, *date = NULL, *time = NULL;
  FILE *fd = NULL;

  vasprintf(&msg, line, ap);

  date = getdate();
  time = gettime();
  pid = getpid();

  logline = xstrdup("%s %s %s[%d]: %s", date, time, pgm, pid, msg);
  free(msg);
  msg = NULL;
  if (logline == NULL)
    logmsg(LOG_ERR, "%s at vsysdaemonlog() : Error on xstrdup", pgm);

  fd = fopen(filename, "a");
  if (fd != NULL) {
    
    if (!fwrite((void *)logline, 1, strlen(logline), fd)) {
      logmsg(LOG_ERR, "%s at vsysdaemonlog() : Log failed on %s", pgm, filename);
    }
  }
  else {
    logmsg(LOG_ERR, "%s at vsysdaemonlog() : Open Log file failed on %s", pgm, filename);
  }
  free(logline);
  fclose(fd);

}

void sysdaemonlog(const char *pgm, const char * filename, const char * line, ...) {
/* -----------------------------------------------------------------------------
 * Custom log system to a file
 *
 * @param  const char *, program name
 * @param  const char *, file name
 * @param  const char *, printf format
 * -------------------------------------------------------------------------- */
  va_list args;
  va_start(args, line);
  vsysdaemonlog(pgm, filename, line, args);
  va_end(args);  
}
  
char * xstrdup(const char * str, ...) {
/* -----------------------------------------------------------------------------
 * Concat strings in a newly allocated memory
 *
 * @param  const char *, printf format
 * @return char *, result in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */
  va_list ap;
  char *result = NULL;
  va_start(ap, str);
  vasprintf(&result, str, ap);
  va_end(ap);
  return result;
}

int getuidbyname(const char *login) {
/* -----------------------------------------------------------------------------
 * Get the uid number by name
 *
 * @param  const char *, login name
 * @return int or -1 if login is not found
 * -------------------------------------------------------------------------- */
  struct passwd * usrinfo;
  usrinfo = getpwnam(login);
  
  if (usrinfo == NULL) {
    logmsg(LOG_ERR, "getuidbyname() : no such user %s", login);
    return -1;
  }
  return usrinfo->pw_uid;
}

int getgidbyname(const char *group) {
/* -----------------------------------------------------------------------------
 * Get the gid number by name
 *
 * @param  const char *, group name
 * @return int or -1 if group is not found
 * -------------------------------------------------------------------------- */
  struct group * grpinfo;
  grpinfo = getgrnam(group);
  
  if (grpinfo == NULL) {
    logmsg(LOG_ERR, "getgidbyname() : no such group %s", group);
    return -1;
  }
  return grpinfo->gr_gid;
}

char *get_homedir() {
/* -----------------------------------------------------------------------------
 * Get home path
 *
 * @return char *, path in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */
  char *path = NULL;
  struct passwd * usrinfo;
  usrinfo = getpwuid(getuid());
  
  if ((path = strdup((const char *)usrinfo->pw_dir)) == NULL) {
    logmsg(LOG_ERR, "get_homedir() : strdup error");
  }
  return path;
}
  
char *get_currentdir() {
/* -----------------------------------------------------------------------------
 * Get current path
 *
 * @return char *, path in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */
  char * path = NULL;
  char * path_tmp = NULL;
  int size = 16;
  
  for(;;) {
    if ((path_tmp = (char *)realloc(path, size)) == NULL) {
      logmsg(LOG_ERR, "get_currentdir() : realloc error");
      break;
    }
    path = path_tmp;
    if (getcwd(path, size) != NULL) {
      break;
    }
    if (errno != ERANGE) {
      break;
    }
    size *= 2;
  }
  return path;
  
}

char * get_dir_cdup(const char *path) {
/* -----------------------------------------------------------------------------
 * Get parent path
 *
 * @param  const char *, directory
 * @return char *, path in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */
  unsigned int i = 0;
  char *result = NULL;
  unsigned int last_i = strlen(path) - 1;
  
  result = strdup(path);
  if (result == NULL)
    return NULL;
  for (i = last_i; (i >= 0) && (*(result+i) != '/'); i--) {
    *(result+i) = '\0';
  }
  if ((*(result+i) == '/') && (i > 0))
    *(result+i) = '\0';
  return result;
}

unsigned int fexist(const char *path, char type) {
/* -----------------------------------------------------------------------------
 * Check if file exists
 *
 * @param  const char *, port number or name service
 * @param  char, 'd' for a directory, 'f' for a file
 * @return int
 * -------------------------------------------------------------------------- */
  struct stat s;
  int status;
  status = stat (path, &s);
  switch(type) {
  case 'd':
    if (status == 0 && S_ISDIR (s.st_mode))
      return s.st_size;
    break;
  case 'f':
    if (status == 0 && S_ISREG (s.st_mode))
      return s.st_size;
    break;
  }
  return 0;
}

char * file_exists (const char *directory, const char *filename) {
/* -----------------------------------------------------------------------------
 * Check if file exists in a directory
 *
 * @param  const char *, directory
 * @param  const char *, file name
 * @return char *, the full path in a dynamically allocated memory
 *   so the result must be free()
 * -------------------------------------------------------------------------- */
  
  char *full_filename = NULL;
  struct stat s;
  int status;
  size_t len = strlen(directory) + 1 + strlen(filename) + 1;

  full_filename = (char *) malloc(sizeof(char) * len);
  if (full_filename == NULL) {
    logmsg(LOG_ERR, "file_exists() : malloc error");
    return NULL;
  }

  strlcpy(full_filename, directory, sizeof(char) * len);
  strlcat(full_filename, "/", sizeof(char) * len);
  strlcat(full_filename, filename, sizeof(char) * len);

  status = stat (full_filename, &s);
  if (status == 0 && S_ISREG (s.st_mode))
    return full_filename;
  free (full_filename);
  return NULL;
}

int init_perl_script(const char *path, int pipes[2]) {
/* -----------------------------------------------------------------------------
 * Init a perl script with the associated pipe descriptor to write and read
 *
 * @param  const char *, perl script path
 * @param  int[2], that will contains 2 descriptors
 * @return int, 1 for parent process
 * -------------------------------------------------------------------------- */
  
  int tube1[2];
  int tube2[2];
  char *argv[3];
  int i;
    
  if ((pipe(tube1) != 0) || (pipe(tube2) != 0))
    return 0;
   
  switch(fork()) {
  case -1: /* Erreur fork */
    close(tube1[0]);
    close(tube1[1]);
    close(tube2[0]);
    close(tube2[1]);
    exit(-1);
    break;
  case 0 : /* Processus enfant */
    signal(SIGHUP, SIG_IGN);
  
    close(tube1[1]);  /* Fermeture tube1 entrée ECRITURE  */
    close(tube2[0]);  /* Fermeture tube2 sortie LECTURE */
    dup2(tube1[0], STDIN_FILENO);
    close(tube1[0]);
    dup2(tube2[1], STDOUT_FILENO);
    close(tube2[1]);
  
    /* On ferme tous les descripteurs sauf STDOUT et STDIN */
    for(i = 2; i < OPEN_MAX; i++)
      close(i);
    
    argv[0] = "/usr/bin/perl";
    argv[1] = (char *)path;
    argv[2] = NULL;
  
    execv("/usr/bin/perl", argv);
    return 0;
    break;
  default :
  /* Processus père lisant dans la socket */    
    close(tube1[0]);  /* Fermeture tube1 sortie LECTURE */
    close(tube2[1]);  /* Fermeture tube2 entrée ECRITURE */
    /*tubes[0] = tube2[0];*/  /* Tube de lecture */
    /*tubes[1] = tube1[1];*/  /* Tube d'écriture */
    
    pipes[1] = tube1[1];
    pipes[0] = tube2[0];
    
    signal(SIGCHLD, SIG_IGN);
    break;
  }
  
  return 1;
}

int process_daemon() {
/* -----------------------------------------------------------------------------
 * Daemonize a process
 
 * @return int, 1 for parent process, 0 for child process
 * -------------------------------------------------------------------------- */
  
  int i = 0;
  /* Processus Démon */
  switch (fork ()) {
  case -1: /* Erreur fork */
    logmsg(LOG_ERR, "process_daemon() : %s (%d) : Fork Error", strerror(errno), errno);

    return errno;
    break;
  case 0: /* Processus enfant = démon: */

    chdir("/");
    setsid();
    /* Fermeture de tous les descripteurs */
    for (i = 0; i < _POSIX_OPEN_MAX; i++)
      close(i);
    break;
  default: /* Processus Parent */
    return 1;
  }
  
  return 0;

}