/*
 *-------------------- DD_ADMIN ------------------------------- 
 *                      V.1.1
*/ 
/* name:         DDadmin.c
 * author:       Alexandr Grigoriev
 * Insitution:   IKI RAN lab.546 aug@afed.iki.rssi.ru
 * date :        March    1999
 * sinopsis:
 *
 * usage:
 *
 * Description: Program is to adding users into DD access list.
 *  Nov 30   2009 - V.1.1 - netCDF-3
    Nov 08   2011 - 
 */
  

#define _XOPEN_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <time.h>
#include <DD.h>
#include <netcdf.h>
#include <DD_Access.h>

#define FILE_PATH_LEN  1024
#define LOGIN_MIN_LEN  2
#define LOGIN_MAX_LEN  20
#define PWD_HASHED_LEN 13
#define PWD_MIN_LEN    5
#define PWD_MAX_LEN    80
#define PWD_GEN_SIZE   6

#define NC_USER_NAME     "user"
#define NC_USER_LEN_NAME "UserLength"
#define NC_PWD_LEN_NAME  "PasswdLength"
#define NC_MEMBER_NAME   "member"
#define NC_PWD_NAME      "passwd"

#define ERR_BAD_REQUEST      1
#define ERR_DDBASE_UNDEFINED 2
#define ERR_FILE_UNREACHABLE 3
#define ERR_FILE_BAD_INFO    4
#define ERR_MANUAL_ABORTED   5
#define ERR_REQUEST_FAILED   6

typedef enum {OP_ADD_MANUAL,
              OP_ADD_AUTO,  
              OP_MODIFY,
              OP_DELETE,
              OP_RESET,
	      OP_GET_SALT,
              OP_GET_LIST
             } t_Op;
   
typedef struct {
  t_Op op;
  char login[LOGIN_MAX_LEN+1];
  char pwd_hash[PWD_HASHED_LEN+1];
  char pwd_hash_new[PWD_HASHED_LEN+1];
} t_Request;

typedef struct {
  int  ncID; 
  int  UserID; 
  int  UserLenID; 
  int  PwdLenID;
  int  MemberID;
  int  PwdID;
  long MaxRecords; 
  long UserLen; 
  long PwdLen;
} t_UserFileInfo;

//---------------------------------------------------------------------------
void Usage(void)
{
  printf("DDadmin [-option] [login] [pwd_hash] [pwd_hash_new]\n");
  printf("  * without arguments: add new user manually\n");
  printf("  * -option :\n");
  printf("      -a : add new user [login] with the hashed password [pwd_hash]\n");
  printf("      -m : modify the password of user [login]. [pwd_hash] is checked, and replace by [pwd_hash_new]\n");
  printf("      -r : reset the password of user [login]. A new one is generated\n");
  printf("      -d : delete the user [login]\n");
  printf("      -s : return salt used to crypt the password of user [login]\n");
  printf("      -l : return a list of users\n");
  printf("      -h : this help\n");
}
//---------------------------------------------------------------------------
unsigned char GetRandomChar(void)
{
  return (unsigned char)(rand()%26+'a');
}
//--------------------------------------------------------------------------
int TestLogin(char *login)
{
  int j = strlen(login);
  if(j<LOGIN_MIN_LEN)
    {
      printf("login is too short.\n");
      return 0;
    }
  if(j>LOGIN_MAX_LEN) 
    {
      printf("login is too long.\n");
      return 0;
    }
  return 1;
}
//-------------------------------------------------------------------------
int GetLogin(char *login)
{
  printf("login:");
  
  char l = '\0';
  int j = 0;

  while((l!='\n'))
    {
      l=getchar();
      if(j < LOGIN_MAX_LEN) 
	login[j] = l;
      j++;
    }

  login[j-1] = '\0';

  if (!TestLogin(login))
    return 0;

  return 1;
}
//--------------------------------------------------------------------
int TestPwd(char *pwd)
{
  int j = strlen(pwd);
  if(j < PWD_MIN_LEN)
    {
      printf("Password is too short.\n");
      return 0;
    }
  if(j > PWD_MAX_LEN) 
    {
      printf("Password is too long.\n");
      return 0;
    }
  return 1;
}
//--------------------------------------------------------------------
int GetNewPwd(char *pwd)
{
  char pas1[PWD_MAX_LEN+1];
  char pas2[PWD_MAX_LEN+1];

  int isFinish = 0;
  while (!isFinish)
    {
      strcpy(pas1,getpass("New password:"));
      pas1[strlen(pas1)] = '\0';
      isFinish = TestPwd(pas1);
    }

  strcpy(pas2,getpass("Retype new password:"));
  pas2[strlen(pas2)] = '\0';

  int ok = (strcmp(pas1,pas2) == 0);

  if (ok)
    strcpy(pwd,pas1);

  memset(pas1,0,(PWD_MAX_LEN+1)*sizeof(char));
  memset(pas2,0,(PWD_MAX_LEN+1)*sizeof(char));

  if (!ok)
    {
      printf("Error - Passwords mismatch\n");
      return 0;
    }

  return 1;
}
//--------------------------------------------------------------------
int GeneratePwd(char *pwd)
{
  int i = 0;
  for (i = 0; i < PWD_GEN_SIZE; i++)
    pwd[i] = GetRandomChar();
  return 1;
}
//--------------------------------------------------------------------
int GetRequest(int argc, char *argv[], t_Request *request)
{
  memset(request,0,sizeof(t_Request));

  if (argc < 2)
    {
      request->op = OP_ADD_MANUAL;
      return 1;
    }

  if ((strlen(argv[1]) != 2) || (argv[1][0] != '-'))
    {
      printf("Error - Bad option\n");
      Usage();
      return 0;
    }

  //option
  switch (argv[1][1])
    {
    case 'a' :
      request->op = OP_ADD_AUTO;
      break;
    case 'm' :
      request->op = OP_MODIFY;
      break;
    case 'd' :
      request->op = OP_DELETE;
      break;
    case 'r' :
      request->op = OP_RESET;
      break;
    case 'h' :
      Usage();
      return 0;
    case 's' :
      request->op = OP_GET_SALT;
      break;
    case 'l' :
      request->op = OP_GET_LIST;
      return 1;
    default :
      printf("Error - Bad option\n");
      Usage();
      return 0;
    }

  //login
  if (argc < 3)
    {
      printf("Error - Cannot get login\n");
      Usage();
      return 0;
    }      
  
  if (!TestLogin(argv[2]))
    {
      Usage();
      return 0;
    }

  strcpy(request->login, argv[2]);

  if ((request->op == OP_ADD_AUTO) || (request->op == OP_MODIFY))
    {
      //password hash code
      if (argc < 4)
	{
	  printf("Error - Cannot get password hash code\n");
	  Usage();
	  return 0;
	}
      if (strlen(argv[3]) != PWD_HASHED_LEN)
	{
	  printf("Error - Incorrect password hash code\n");
	  Usage();
	  return 0;
	}
      strcpy(request->pwd_hash, argv[3]);

      if (request->op == OP_MODIFY)
	{
	  //new password hash code
	  if (argc < 5)
	    {
	      printf("Error - Cannot get new password hash code\n");
	      Usage();
	      return 0;
	    }
	  if (strlen(argv[4]) != PWD_HASHED_LEN)
	    {
	      printf("Error - Incorrect new password hash code\n");
	      Usage();
	      return 0;
	    }
	  strcpy(request->pwd_hash_new, argv[4]); 
	}
    }

  return 1;
}
//--------------------------------------------------------------------------
int GetUserFilePath(char *path)
{
  path[0]='\0';
  char *ddbase;
  if((ddbase = getenv("DDBASE")) == NULL)
    {
      printf("No DDBASE info \n");
      return 0;
    }
  strcpy(path,ddbase);
  strcat(path,USERREFNAME);
  return 1;
}
//--------------------------------------------------------------------------
int OpenUserFile(char *path, t_UserFileInfo *fileInfo)
{
  int status;
  if((status = nc_open(path, NC_WRITE, &fileInfo->ncID)) != NC_NOERR)
    {
      printf("Error in opening file = %u\n", fileInfo->ncID);
      return 0;
   }
  return 1;
}
//--------------------------------------------------------------------------
int CloseUserFile(t_UserFileInfo *fileInfo)
{
  nc_close(fileInfo->ncID);
  memset(fileInfo,0,sizeof(t_UserFileInfo));
  return 1;
}
//---------------------------------------------------------------------------
int GetFileInfo(t_UserFileInfo *fileInfo)
{
  int status;

  if (((status = nc_inq_unlimdim(fileInfo->ncID, (int *)&fileInfo->UserID))                       != NC_NOERR) ||
      ((status = nc_inq_dimlen(fileInfo->ncID, fileInfo->UserID,  (size_t *)&fileInfo->MaxRecords))  != NC_NOERR) ||
      ((status = nc_inq_dimid(fileInfo->ncID, NC_USER_LEN_NAME, &fileInfo->UserLenID))     != NC_NOERR) ||
      ((status = nc_inq_dimid(fileInfo->ncID, NC_PWD_LEN_NAME, &fileInfo->PwdLenID))       != NC_NOERR) ||
      ((status = nc_inq_dimlen(fileInfo->ncID, fileInfo->UserLenID, (size_t *)&fileInfo->UserLen))   != NC_NOERR) ||
      ((status = nc_inq_dimlen(fileInfo->ncID, fileInfo->PwdLenID,  (size_t *)&fileInfo->PwdLen))    != NC_NOERR) ||
      ((status = nc_inq_varid(fileInfo->ncID, NC_MEMBER_NAME, &fileInfo->MemberID))        != NC_NOERR) ||
      ((status = nc_inq_varid(fileInfo->ncID, NC_PWD_NAME, &fileInfo->PwdID))              != NC_NOERR))
    {
      printf("Error - Cannot get file information\n");
      return 0;
    }

  fileInfo->UserLen = LOGIN_MAX_LEN;
  fileInfo->PwdLen = PWD_HASHED_LEN;

  return 1;
}
//--------------------------------------------------------------------------
int CreateUserFile(char *filePath, t_UserFileInfo *fileInfo)
{
  int status;
  fileInfo->UserLen = LOGIN_MAX_LEN;
  fileInfo->PwdLen = PWD_HASHED_LEN;

  if (((status = nc_create (filePath,NC_SHARE,&fileInfo->ncID))                                              != NC_NOERR) ||
      ((status = nc_def_dim (fileInfo->ncID, NC_USER_NAME, NC_UNLIMITED, &fileInfo->UserID))                 != NC_NOERR) ||
      ((status = nc_def_dim (fileInfo->ncID, NC_USER_LEN_NAME, fileInfo->UserLen+1, &fileInfo->UserLenID))   != NC_NOERR) ||
      ((status = nc_def_dim (fileInfo->ncID, NC_PWD_LEN_NAME, fileInfo->PwdLen+1, &fileInfo->PwdLenID))      != NC_NOERR))
    {
      printf("Error - Cannot create users file\n");
      return 0;
    }

  int MemberDimVector[2] = {fileInfo->UserID,fileInfo->UserLenID};
  int PwdDimVector[2] = {fileInfo->UserID,fileInfo->PwdLenID};
  if (((status = nc_def_var (fileInfo->ncID, NC_MEMBER_NAME,NC_CHAR,2, MemberDimVector,&fileInfo->MemberID)) != NC_NOERR) ||
      ((status = nc_def_var (fileInfo->ncID, NC_PWD_NAME, NC_CHAR, 2, PwdDimVector, &fileInfo->PwdID))       != NC_NOERR))
    {
      printf("Error - Cannot create users file\n");
      return 0;
    }
  
  nc_enddef(fileInfo->ncID);

  return 1;
}
//--------------------------------------------------------------------------
int CleanUserFile(void)
{
  t_UserFileInfo fileInfo, tmpFileInfo;
  memset(&fileInfo,0,sizeof(t_UserFileInfo));
  memset(&tmpFileInfo,0,sizeof(t_UserFileInfo));
  
  char refname[FILE_PATH_LEN], tmpname[FILE_PATH_LEN];
  if (!GetUserFilePath(refname))
    return 0;
  strcpy(tmpname,refname);
  strcat(tmpname,".tmp");

  if (!OpenUserFile(refname,&fileInfo))
    return 0;

  if (!GetFileInfo(&fileInfo))
    return 0;

  if (!CreateUserFile(tmpname,&tmpFileInfo))
    return 0;

  int i; 
  int c = 0;
  char crtLogin[LOGIN_MAX_LEN+1];
  char crtPwd[PWD_MAX_LEN+1];
  for(i = 0; i < fileInfo.MaxRecords; i++) 
    {
      if (!GetLoginFromIndex(i,&fileInfo,crtLogin) || !GetPwdFromIndex(i,&fileInfo,crtPwd))
	continue;
      
      //clean login string
      memset(crtLogin+strlen(crtLogin),0,(LOGIN_MAX_LEN+1-strlen(crtLogin))*sizeof(char));

      if ((strcmp(crtLogin,"") == 0) || (strcmp(crtPwd,"") == 0))
	continue;
      
      if (!SetLoginToIndex(c, &tmpFileInfo, crtLogin))
	{
	  printf("Error - Cannot add a login on the temporary file\n");
	  return 0;
	}

      if (!SetPwdToIndex(c, &tmpFileInfo, crtPwd))
	{
	  printf("Error - Cannot add a password on the temporary file\n");
	  return 0;
	}

      c++;
    }

  CloseUserFile(&fileInfo);
  CloseUserFile(&tmpFileInfo);

  char cmd[2048];
  sprintf(cmd,"cp %s %s",tmpname,refname);
  system(cmd);
  sprintf(cmd,"rm %s",tmpname);
  system(cmd);

  return 1;
}
//---------------------------------------------------------------------------
int CreateSaveUserFile(void)
{
  char refname[FILE_PATH_LEN];
  char savename[FILE_PATH_LEN];
  
  if (!GetUserFilePath(refname))
    return 0;
  strcpy(savename,refname);
  strcat(savename,"~");

  char cmd[2048];
  sprintf(cmd,"cp %s %s",refname,savename);
  system(cmd);

  return 1;
}
//---------------------------------------------------------------------------
int GetPwdFromIndex(int index, t_UserFileInfo *fileInfo, char *pwd_hash)
{
  long start[2] = {0L,0L}, count[2]={1L,1L};
  start[0] = index;
  count[1] = fileInfo->PwdLen;
  return (nc_get_vara_text(fileInfo->ncID,fileInfo->PwdID,(size_t *)start,(size_t *)count, pwd_hash) == NC_NOERR);
}
//---------------------------------------------------------------------------
int GetLoginFromIndex(int index, t_UserFileInfo *fileInfo, char *login)
{
  long start[2] = {0L,0L}, count[2]={1L,1L};
  start[0] = index;
  count[1] = fileInfo->UserLen;
  return (nc_get_vara_text(fileInfo->ncID,fileInfo->MemberID,(size_t *)start,(size_t *)count, login) == NC_NOERR);
}
//--------------------------------------------------------------------------
int SetPwdToIndex(int index, t_UserFileInfo *fileInfo, char *pwd_hash)
{
  long start[2] = {0L,0L}, count[2]={1L,1L};
  start[0] = index;
  count[1] = fileInfo->PwdLen;
  return (nc_put_vara_text(fileInfo->ncID,fileInfo->PwdID,(size_t *)start,(size_t *)count, pwd_hash) == NC_NOERR);
}
//---------------------------------------------------------------------------
int SetLoginToIndex(int index, t_UserFileInfo *fileInfo, char *login)
{
  long start[2] = {0L,0L}, count[2]={1L,1L};
  start[0] = index;
  count[1] = fileInfo->UserLen;
  return (nc_put_vara_text(fileInfo->ncID,fileInfo->MemberID,(size_t *)start,(size_t *)count, login) == NC_NOERR);
}
//---------------------------------------------------------------------------
int SearchLoginIndex(char *login, t_UserFileInfo *fileInfo)
{
  char crtLogin[LOGIN_MAX_LEN+1];
  int i;

  for(i = 0; i < fileInfo->MaxRecords; i++) 
    {
      if (!GetLoginFromIndex(i,fileInfo,crtLogin))
	continue;
      crtLogin[fileInfo->UserLen] = '\0';
      
     if(strcmp(crtLogin,login) == 0)
       return i;
    }
  
  return -1;
}

//--------------------------------------------------------------------------
int AddUser(t_Request request, t_UserFileInfo *fileInfo)
{
  if (!SetLoginToIndex(fileInfo->MaxRecords,fileInfo,request.login))
    {
      printf("Error to add new login user");
      return 0;
    }

  if (!SetPwdToIndex(fileInfo->MaxRecords,fileInfo,request.pwd_hash))
    {
      printf("Error to add new login user");
      return 0;
    }

  return 1;
}
//-------------------------------------------------------------------------
int ModifyUser(t_Request request, t_UserFileInfo *fileInfo, int check)
{
  int index = SearchLoginIndex(request.login, fileInfo);

  if (index < 0)
    {
      printf("User %s not found\n",request.login);
      return 0;
    }

  if (check)
    {
      char pwd_hash[PWD_HASHED_LEN+1];
      memset(pwd_hash,0,(PWD_HASHED_LEN+1)*sizeof(char));
      if (!GetPwdFromIndex(index,fileInfo,pwd_hash))
	{
	  printf("Error to get user password\n");
	  return 0;
	}
      if (strcmp(pwd_hash,request.pwd_hash) != 0)
	{
	  printf("Bad password\n");
	  return 0;
	}
    }
     
  if (!SetPwdToIndex(index,fileInfo,request.pwd_hash_new))
    {
      printf("Error to set new user password\n");
      return 0;
    }
  
  return 1;
}
//--------------------------------------------------------------------------
int DeleteUser(t_Request request, t_UserFileInfo *fileInfo)
{
  int index = SearchLoginIndex(request.login, fileInfo);

  if (index < 0)
    {
      printf("User %s not found\n",request.login);
      return 0;
    }
 
  char login[LOGIN_MAX_LEN+1];
  memset(login,0,(LOGIN_MAX_LEN+1)*sizeof(char));

  if (!SetLoginToIndex(index,fileInfo,login))
    {
      printf("Error to delete user password\n");
      return 0;
    }

  char pwd_hash[PWD_HASHED_LEN+1];
  memset(pwd_hash,0,(PWD_HASHED_LEN+1)*sizeof(char));

  if (!SetPwdToIndex(index,fileInfo,pwd_hash))
    {
      printf("Error to delete user password\n");
      return 0;
    } 
  
  return 1;
}
//--------------------------------------------------------------------------
int ResetUser(t_Request request, t_UserFileInfo *fileInfo)
{
  char salt[2];
  salt[0] = GetRandomChar();

  char pwd[PWD_GEN_SIZE+1];
  memset(pwd,0,(PWD_GEN_SIZE+1)*sizeof(char));
  GeneratePwd(pwd);

  printf("%s\n",pwd);

  salt[1] = GetRandomChar();

  //hash pwd
  strcpy(request.pwd_hash_new,crypt(pwd,salt));
  memset(pwd,0,(PWD_GEN_SIZE+1)*sizeof(char));
  
  return ModifyUser(request, fileInfo, 0);
}
//--------------------------------------------------------------------------
int GetSalt(t_Request request, t_UserFileInfo *fileInfo)
{
  int index = SearchLoginIndex(request.login, fileInfo);

  if (index < 0)
    {
      printf("User %s not found\n",request.login);
      return 0;
    }

  char pwd_hash[PWD_HASHED_LEN+1];
  if (!GetPwdFromIndex(index,fileInfo,pwd_hash))
    {
      printf("Error to get user password\n");
      return 0;
    }

  char salt[3];
  strncpy(salt,pwd_hash,2);
  salt[2] = '\0';
  printf("%s\n",salt);

  return 1;
}
//---------------------------------------------------------------------------
int GetUsersList(t_Request request, t_UserFileInfo *fileInfo)
{
  char crtLogin[LOGIN_MAX_LEN+1];
  int i;

  int addComa = 0;

  for(i = 0; i < fileInfo->MaxRecords; i++)
    {
      if (!GetLoginFromIndex(i,fileInfo,crtLogin))
        continue;
      if (addComa)
        printf(",");
      printf("%s",crtLogin);
      addComa = 1;
    }

  printf("\n");

  return 1;

}
//---------------------------------------------------------------------------
int CompleteRequest(t_Request *request, t_UserFileInfo *fileInfo)
{
  char salt[2];
  salt[0] = GetRandomChar();

  //get login
  int isFinish = 0;
  while (!isFinish)
    {
      GetLogin(request->login);
      if (SearchLoginIndex(request->login, fileInfo) > -1)
	printf("User login not available. Change your login please.\n");
      else
	isFinish = 1;
    }

  //get password
  char pwd[PWD_MAX_LEN+1];
  if (!GetNewPwd(pwd))
    return 0;
  
  salt[1] = GetRandomChar();

  //hash pwd
  strcpy(request->pwd_hash,crypt(pwd,salt));
  memset(pwd,0,(PWD_MAX_LEN+1)*sizeof(char));

  return 1;
}
//---------------------------------------------------------------------------
main (int argc, char *argv[])
{  
  srand(time(NULL));

  t_Request request;
  if (!GetRequest(argc, argv, &request))
    exit(ERR_BAD_REQUEST);
  
  char refname[FILE_PATH_LEN];
  if (!GetUserFilePath(refname))
    exit(ERR_DDBASE_UNDEFINED);
  
  t_UserFileInfo fileInfo;
  memset(&fileInfo,0,sizeof(t_UserFileInfo));

  if (!OpenUserFile(refname,&fileInfo))
    exit(ERR_FILE_UNREACHABLE);
  
  
  if (!GetFileInfo(&fileInfo)) 
    exit(ERR_FILE_BAD_INFO);
  
  if (request.op == OP_ADD_MANUAL) 
    if (!CompleteRequest(&request,&fileInfo))
      {
	CloseUserFile(&fileInfo);
	exit(ERR_MANUAL_ABORTED);
      }

  int res = 0;
  if ((request.op != OP_GET_SALT) && (request.op != OP_GET_LIST))
    CreateSaveUserFile();
  switch (request.op)
    {
    case OP_ADD_MANUAL :
    case OP_ADD_AUTO   :
      res = AddUser(request,&fileInfo);
      break;
    case OP_MODIFY :
      res = ModifyUser(request,&fileInfo,1);
      break;
    case OP_DELETE :
      res = DeleteUser(request,&fileInfo);
      break;
    case OP_RESET  :
      res = ResetUser(request,&fileInfo);
      break;
    case OP_GET_SALT :
      res = GetSalt(request,&fileInfo);
      break;
    case OP_GET_LIST :
      res = GetUsersList(request,&fileInfo);
      break;
    }

  CloseUserFile(&fileInfo);

  if (res && (request.op == OP_DELETE))
    CleanUserFile();

  memset(&request,0,sizeof(t_Request));

  if (!res)
    exit(ERR_REQUEST_FAILED);

  return 0;
}