/* aide, Advanced Intrusion Detection Environment

 *

 * Copyright (C) 2000-2002,2004-2006,2011 Rami Lehti, Pablo Virolainen,

 * Richard van den Berg, Hannes von Haugwitz

 * $Header$

 *

 * 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

 * 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 "aide.h"

/*for locale support*/

#include "locale-aide.h"

/*for locale support*/

#ifdef WITH_PSQL

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <gcrypt.h>

#include "base64.h"

#include "db.h"

#include "db_sql.h"

#include "db_config.h"

#include "libpq-fe.h"

#include "report.h"

#ifdef WITH_MHASH

#include <mhash.h>

#endif

char* db_get_sql(db_line*,db_config*);

int _db_check_result(PGconn *conn, PGresult *res, char *query) 

{

  int status = 0;

  int ret = RETOK;

  if (!res || ( (PQresultStatus(res) != PGRES_COMMAND_OK) &&

                (PQresultStatus(res) != PGRES_TUPLES_OK) )){

    ret = RETFAIL;

    if (res!=NULL) {

        error(0,"Sql error %s while doing %s\n", PQerrorMessage(conn), query);

    } else {

        error(0,"Sql error while doing %s.\n",query);

    }

  } else {

    error(255,"Sql went ok.\n");

    status = 1;

  }

  return status;

}

int db_writespec_sql(db_config* conf){

  PGresult *res;

  int i;

  int table_exists;

  char* s;

  int ret = RETOK;

  s = (char*) malloc(sizeof(char)*1024); /* Hope 1023 bytes is

					    enough for string...

					    390 + length of table

					    name should be enough.

					 */

  /* We have to ensure that the database table not exist */

  /* check if the table exists already */

  sprintf(s, "SELECT * FROM pg_class WHERE relname = '%s'", 

             ((psql_data*)conf->db_out)->table);

  res = PQexec(((psql_data*)conf->db_out)->conn, s);

  if ( _db_check_result(((psql_data*)conf->db_out)->conn, res, s) == 0 ) {

    ret = RETFAIL;

  }

  table_exists = PQntuples(res) == 1 ? 1 : 0;

  PQclear(res);

  *s = '\0';  /* reset query string */

  if (table_exists == 0) {

    /* we need to create the table */

    s = strcat(s, "CREATE TABLE ");

    s = strcat(s, ((psql_data*)conf->db_out)->table);

    s = strcat(s, "(");

    for (i=0;i<conf->db_out_size;i++) {

      if (i!=0) {

        s = strcat(s, ",");

      }

      s = strcat(s, db_names[conf->db_out_order[i]]);

      s = strcat(s, " ");

      s = strcat(s, db_sql_types[conf->db_out_order[i]]);

    }

    s = strcat(s,");");

    error(255,"SQL:%s\n",s);

    res = PQexec(((psql_data*)conf->db_out)->conn,s);

    if (_db_check_result(((psql_data*)conf->db_out)->conn, res, s) == 0) {

      ret = RETFAIL;

    }

    PQclear(res);  

  }

  free(s); /* Just say no to memoryleaks. */

  return ret;

  /* FIXME!! No error checkin may be broken. Fix malloc also */ 

}

int db_writeline_sql(db_line* line,db_config* conf){

  PGresult *res;

  int i;

  int ret=RETOK;

  char* s=db_get_sql(line,conf) ;

  if (s==NULL) {

    return RETFAIL;

  }

  error(255,"SQL:%s",s);

  res = PQexec(((psql_data*)conf->db_out)->conn,s);

  if ( _db_check_result(((psql_data*)conf->db_out)->conn, res, s) == 0 ) {

    ret = RETFAIL;

  }

  PQclear(res);

  free(s);

  return ret;

}

void db_readline_sql_int(int* d,int db,int i, db_config* conf) 

{

  FILE** db_filep=NULL;

  switch (db) {

  case DB_OLD: {

    db_filep=&(conf->db_in);

    break;

  }

  case DB_NEW: {

    db_filep=&(conf->db_new);

    break;

  }

  }

  if (((psql_data*)(*db_filep))->des[i]!=-1) {

    *d=(int)PQgetvalue(((psql_data*)(*db_filep))->res, 

		       ((psql_data*)(*db_filep))->curread,

		       ((psql_data*)(*db_filep))->des[i]);

  } else {

    *d=0;

  }

  error(254,"sql_readline_sql_int %s got %i\n",db_names[i],*d);

}

void db_readline_sql_char(void** d,int db,const int i, db_config* conf) 

{

  volatile int cr,des;

  psql_data* data;

  FILE** db_filep=NULL;

  switch (db) {

  case DB_OLD: {

    db_filep=&(conf->db_in);

    break;

  }

  case DB_NEW: {

    db_filep=&(conf->db_new);

    break;

  }

  }

  data=((psql_data*)(*db_filep));

  cr=data->curread;

  des=data->des[i];

  if (des!=-1) {

    volatile char* s=NULL;

    s = (char*)PQgetvalue(data->res,cr,des);

    if (s!=NULL) {

      *d=(void*)strdup((char*)s);

    } else {

      *d=NULL;

    }

    error(254,"sql_readline_sql_char %i,%i %s got %s\n",cr,des,db_names[i],*d);

  } else {

    *d=NULL;

    error(254,"sql_readline_sql_char %i,%i %s got NULL\n",cr,des,db_names[i]);

  }

}

void db_readline_sql_byte(void** d,int db,int i, db_config* conf) {

  db_readline_sql_char(d,db,i, conf);

  if (*d!=NULL) {

    *((byte*)d)=base64tobyte(*d,strlen(*d));

  }

}

void db_readline_sql_time(void** d,int db,int i, db_config* conf) {

  db_readline_sql_char(d,db,i, conf);

  if (*d!=NULL) {

    *((time_t*)d)=base64totime_t(*d);

  }

}

db_line* db_readline_sql(int db, db_config* conf) {

  volatile db_line* rline;

  int i;

  url_t* db_url=NULL;

  FILE** db_filep=NULL;

  int* db_osize=0;

  DB_FIELD** db_order=NULL;

  switch (db) {

  case DB_OLD: {

    db_url=conf->db_in_url;

    db_filep=&(conf->db_in);

    db_osize=&(conf->db_in_size);

    db_order=&(conf->db_in_order);

    break;

  }

  case DB_NEW: {

    db_url=conf->db_new_url;

    db_filep=&(conf->db_new);

    db_osize=&(conf->db_new_size);

    db_order=&(conf->db_new_order);

    break;

  }

  }

  if (((psql_data*)(*db_filep))->curread>=

      ((psql_data*)(*db_filep))->maxread) {

    error(255,"Everything read from SQL\n");

    return NULL;

  }

  rline=(db_line*)malloc(1*sizeof(db_line));

  db_readline_sql_byte((void*)&(rline->md5),db,(int)db_md5, conf);

  db_readline_sql_byte((void*)&(rline->sha1),db,db_sha1, conf);

  db_readline_sql_byte((void*)&(rline->rmd160),db,db_rmd160, conf);

  db_readline_sql_byte((void*)&(rline->tiger),db,db_tiger, conf);

#ifdef WITH_MHASH

  db_readline_sql_byte((void*)&(rline->crc32),db,db_crc32, conf);

  db_readline_sql_byte((void*)&(rline->haval),db,db_haval, conf);

  db_readline_sql_byte((void*)&(rline->gost),db,db_gost, conf);

#endif

  db_readline_sql_char((void*)&(rline->fullpath),db,db_filename, conf);

  rline->filename=rline->fullpath;

  db_readline_sql_char((void*)&(rline->linkname),db,db_linkname, conf);

  db_readline_sql_int((void*)&(rline->perm),db,db_perm, conf);

  db_readline_sql_int((void*)&(rline->uid),db,db_uid, conf);

  db_readline_sql_int((void*)&(rline->gid),db,db_gid, conf);

  db_readline_sql_int((void*)&(rline->inode),db,db_inode, conf);

  db_readline_sql_int((void*)&(rline->nlink),db,db_lnkcount, conf);

  db_readline_sql_int((void*)&(rline->size),db,*db_osize, conf);

  db_readline_sql_int((void*)&(rline->bcount),db,db_bcount, conf);

  db_readline_sql_int((void*)&(rline->attr),db,db_attr, conf);

  db_readline_sql_time((void*)&(rline->atime),db,db_atime, conf);

  db_readline_sql_time((void*)&(rline->ctime),db,db_ctime, conf);

  db_readline_sql_time((void*)&(rline->mtime),db,db_mtime, conf);

#ifdef WITH_ACL

  rline->acl=NULL;

#endif

  ((psql_data*)(*db_filep))->curread++;

  error(255,"filename %s\n",rline->filename);

  return rline;

}

void sql_writeint(int data,char *s,int i){

  char t[10];

  t[0]=0;

  if (i!=0) {

    s = strcat(s,",");

  }

  sprintf(t,"%i",data);

  strcat(s,t);

}

void sql_writeoct(int data,char *s,int i){

  char t[10];

  t[0]=0;

  if (i!=0) {

    s = strcat(s,",");

  }

  sprintf(t,"%lo",data);

  strcat(s,t);

}

void sql_write_time_base64(time_t data,char* s,int i){

  static char* ptr=NULL;

  char* tmpstr=NULL;

  int retval=0;

  if(i!=0){

    strcat(s,",");

  }

  if(data==0){

    strcat(s,"''");

    return;

  }

  ptr=(char*)malloc(sizeof(char)*TIMEBUFSIZE);

  if (ptr==NULL) {

    error(0,"\nCannot allocate memory..\n");

    abort();

  }

  memset((void*)ptr,0,sizeof(char)*TIMEBUFSIZE);

  sprintf(ptr,"%li",data);

  tmpstr=encode_base64(ptr,strlen(ptr));

  strcat(s,"'");

  strcat(s,tmpstr);

  strcat(s,"'");

  free(tmpstr);

  free(ptr);

  return;

}

void sql_write_byte_base64(byte*data,size_t len,char* s,int i )

{

  char* tmpstr=NULL;

  int retval=0;

  tmpstr=encode_base64(data,len);

  if(i){

    strcat(s,",");

  }

  strcat(s,"'");

  if(tmpstr){

    strcat(s,tmpstr);

    free(tmpstr);

  }else {

    /* Do nothing.. */

  }

  strcat(s,"'");

  return;

}

char* db_get_sql(db_line* line,db_config* conf){

  int i;

  char* s=(char*) malloc(sizeof(char)*10240); /* FIXME .. */

  if (s==NULL) {

    error(0,"\nCannot allocate memory..\n");

    abort();

  }

  s[0]=0;

  /* Insertion was hardcoded into aide-table, now we will use the

     provided name from the configfile */

  s = strcat(s,"INSERT INTO ");

  s = strcat(s, ((psql_data*)conf->db_out)->table);

  s = strcat(s," values(");

  for(i=0;i<conf->db_out_size;i++){

    switch (conf->db_out_order[i]) {

    case db_filename : {

      char* tmp;

      if ( i!=0 ) {

	s = strcat(s,",");

      }

      strcat(s,"'");

      tmp=encode_string(line->filename);

      s = strcat(s,tmp);

      free(tmp);

      strcat(s,"'");

      break;

    }

    case db_linkname : {

      if ( i!=0 ) {

	s = strcat(s,",");

      }

      strcat(s,"'");

      if (line->linkname != NULL) {

	char* tmp;

	tmp=encode_string(line->linkname);

	s = strcat(s,tmp);

	free(tmp);

      }

      strcat(s,"'");

      break;

    }  

    case db_attr : {

      sql_writeint(line->attr,s,i);

      break;

    }

    case db_bcount : {

      sql_writeint(line->bcount,s,i);

      break;

    }

    case db_mtime : {

      sql_write_time_base64(line->mtime,s,i);

      break;

    }

    case db_atime : {

      sql_write_time_base64(line->atime,s,i);

      break;

    }

    case db_ctime : {

      sql_write_time_base64(line->ctime,s,i);

      break;

    }

    case db_inode : {

      sql_writeint(line->inode,s,i);

      break;

    }

    case db_lnkcount : {

      sql_writeint(line->nlink,s,i);

      break;

    }

    case db_uid : {

      sql_writeint(line->uid,s,i);

      break;

    }

    case db_gid : {

      sql_writeint(line->gid,s,i);

      break;

    }

    case db_size : {

      sql_writeint(line->size,s,i);

      break;

    }

    case db_md5 : {

      sql_write_byte_base64(line->md5,

			   gcry_md_get_algo_dlen(GCRY_MD_MD5),s,i);

      break;

    }

    case db_sha1 : {

      sql_write_byte_base64(line->sha1,

			   gcry_md_get_algo_dlen(GCRY_MD_SHA1),s,i);

      break;

    }

    case db_rmd160 : {

      sql_write_byte_base64(line->rmd160,

			   gcry_md_get_algo_dlen(GCRY_MD_RMD160),

			   s,i);

      break;

    }

    case db_tiger : {

      sql_write_byte_base64(line->tiger,

			   gcry_md_get_algo_dlen(GCRY_MD_TIGER),

			   s,i);

      break;

    }

    case db_perm : {

      sql_writeoct(line->perm,s,i);

      break;

    }

#ifdef WITH_MHASH

    case db_crc32 : {

      sql_write_byte_base64(line->crc32,

			   mhash_get_block_size(MHASH_CRC32),

			   s,i);

      break;

    }

    case db_crc32b : {

      sql_write_byte_base64(line->crc32b,

			   mhash_get_block_size(MHASH_CRC32B),

			   s,i);

      break;

    }

    case db_haval : {

      sql_write_byte_base64(line->haval,

			   mhash_get_block_size(MHASH_HAVAL256),

			   s,i);

      break;

    }

    case db_gost : {

      sql_write_byte_base64(line->gost ,

			   mhash_get_block_size(MHASH_GOST),

			   s,i);

      break;

    }

#endif

    case db_acl : {

      error(0,"TODO db_acl write to db_sql.c");

      /* TODO */

      break;

    }

    case db_xattrs : {

      error(0,"TODO db_xattrs write to db_sql.c");

      /* TODO */

      break;

    }

    case db_checkmask : {

      sql_writeoct(line->attr,s,i);

      break;

    }

    default : {

      error(0,"Not implemented in sql_writeline_file %i\n",

	    conf->db_out_order[i]);

      return NULL;

    }

    }

  }

  strcat(s,");");

  return s;

}

int db_close_sql(void* db){

  PQexec(((psql_data*)db)->conn,"commit");

  PQfinish(((psql_data*)db)->conn);

  return RETOK;

}

#endif