/* Result Sets Interface */
#ifndef SQL_CRSR
#  define SQL_CRSR
  struct sql_cursor
  {
    unsigned int curocn;
    void *ptr1;
    void *ptr2;
    unsigned int magic;
  };
  typedef struct sql_cursor sql_cursor;
  typedef struct sql_cursor SQL_CURSOR;
#endif /* SQL_CRSR */

/* Thread Safety */
typedef void * sql_context;
typedef void * SQL_CONTEXT;

/* Object support */
struct sqltvn
{
  unsigned char *tvnvsn; 
  unsigned short tvnvsnl; 
  unsigned char *tvnnm;
  unsigned short tvnnml; 
  unsigned char *tvnsnm;
  unsigned short tvnsnml;
};
typedef struct sqltvn sqltvn;

struct sqladts
{
  unsigned int adtvsn; 
  unsigned short adtmode; 
  unsigned short adtnum;  
  sqltvn adttvn[1];       
};
typedef struct sqladts sqladts;

static struct sqladts sqladt = {
  1,1,0,
};

/* Binding to PL/SQL Records */
struct sqltdss
{
  unsigned int tdsvsn; 
  unsigned short tdsnum; 
  unsigned char *tdsval[1]; 
};
typedef struct sqltdss sqltdss;
static struct sqltdss sqltds =
{
  1,
  0,
};

/* File name & Package Name */
struct sqlcxp
{
  unsigned short fillen;
           char  filnam[11];
};
static const struct sqlcxp sqlfpn =
{
    10,
    "hdbconn.pc"
};


static unsigned int sqlctx = 71819;


static struct sqlexd {
   unsigned int   sqlvsn;
   unsigned int   arrsiz;
   unsigned int   iters;
   unsigned int   offset;
   unsigned short selerr;
   unsigned short sqlety;
   unsigned int   occurs;
      const short *cud;
   unsigned char  *sqlest;
      const char  *stmt;
   sqladts *sqladtp;
   sqltdss *sqltdsp;
            void  **sqphsv;
   unsigned int   *sqphsl;
            int   *sqphss;
            void  **sqpind;
            int   *sqpins;
   unsigned int   *sqparm;
   unsigned int   **sqparc;
   unsigned short  *sqpadto;
   unsigned short  *sqptdso;
   unsigned int   sqlcmax;
   unsigned int   sqlcmin;
   unsigned int   sqlcincr;
   unsigned int   sqlctimeout;
   unsigned int   sqlcnowait;
              int   sqfoff;
   unsigned int   sqcmod;
   unsigned int   sqfmod;
            void  *sqhstv[4];
   unsigned int   sqhstl[4];
            int   sqhsts[4];
            void  *sqindv[4];
            int   sqinds[4];
   unsigned int   sqharm[4];
   unsigned int   *sqharc[4];
   unsigned short  sqadto[4];
   unsigned short  sqtdso[4];
} sqlstm = {12,4};

// Prototypes
extern "C" {
  void sqlcxt (void **, unsigned int *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlcx2t(void **, unsigned int *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlbuft(void **, char *);
  void sqlgs2t(void **, char *);
  void sqlorat(void **, unsigned int *, void *);
}

// Forms Interface
static const int IAPSUCC = 0;
static const int IAPFAIL = 1403;
static const int IAPFTL  = 535;
extern "C" { void sqliem(char *, int *); }

typedef struct { unsigned short len; unsigned char arr[1]; } VARCHAR;
typedef struct { unsigned short len; unsigned char arr[1]; } varchar;

/* cud (compilation unit data) array */
static const short sqlcud0[] =
{12,4130,1,0,0,
5,0,0,1,0,0,27,97,0,0,4,4,0,1,0,1,97,0,0,1,97,0,0,1,10,0,0,1,10,0,0,
36,0,0,2,0,0,32,114,0,0,0,0,0,1,0,
};


//*-- AUTHOR : Ilse Koenig
//*-- Modified : 05/07/2001

//_HADES_CLASS_DESCRIPTION 
/////////////////////////////////////////////////////////////
// HDbConn
//
// Oracle connection class (used for Oracle utility programs)
// (uses the Oracle C/C++ precompiler)
//
/////////////////////////////////////////////////////////////
using namespace std;
#include "hdbconn.h"
#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

// Oracle communication area
#include <oraca.h>
// SQL Communications Area
#include <sqlca.h>
// SQL prototype routines
#include <sqlcpr.h> 
 
ClassImp(HDbConn)

HDbConn::HDbConn() {
  // Default constructor (Connection not yet open)
  dbIsOpen=kFALSE;
  noDDL=kTRUE;
}

HDbConn::~HDbConn() {
  // Destructor
  closeDbConn();
}

Bool_t HDbConn::connectDb(TString userName, TString dbName) {
  // Opens an Oracle connection (e.g.with:  "hades","db-hades")
  // Asks for a password.
  uName=userName;
  uName.ToUpper();
  if (uName.CompareTo("SCOTT")==0) {
    cout<<"User SCOTT is not allowed to use this program!"<<endl;
    return kFALSE;
  }
  TString connString=uName+"@"+dbName;
  Char_t* passwd = new Char_t[20];
  if (uName.CompareTo("HADES_ANA")==0) {
    strcpy(passwd,"hades");
    noDDL=kTRUE;
  } else {
    if (uName.CompareTo("HADES")==0) {
      cout<<"User HADES has readonly access!"<<endl;
      noDDL=kTRUE;
    } else {
      noDDL=kFALSE;
    }
    Char_t buf[20];
    Int_t ttyfd = 0;
    struct termios tio, itio;
    if ((ttyfd = ::open("/dev/tty", O_RDWR)) < 0) {
      fprintf(stderr, "cannot open tty, using stdin\n");
      ttyfd = 0;
    }
    if (tcgetattr(ttyfd, &tio) < 0) {
      fprintf (stderr, "\nUnable to get terminal characteristics: ");
      cout<<"enter password for user "<<userName<<" > ";
      scanf("%[^\n]%*c",passwd);
    }
    itio = tio;
    tio.c_lflag &= ~(ECHO|ICANON);         
    tcsetattr (ttyfd, TCSAFLUSH, &tio);
    cout<<"enter password for user "<<userName<<" > ";
    fgets(buf, 19, stdin);
    tcsetattr (ttyfd, TCSAFLUSH, &itio);
    //close(ttyfd);
    sscanf(buf, "%s", passwd);
    cout<<endl;
  }
  if (dbIsOpen) closeDbConn();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* uN;
    char* pW;
  /* EXEC SQL END DECLARE SECTION; */ 

  uN=(Char_t*)connString.Data();
  pW=passwd;
  /* EXEC SQL WHENEVER SQLERROR DO
    showSqlError("ORACLE error in HDbConn::openConnection(...):"); */ 

  /* EXEC SQL CONNECT :uN IDENTIFIED BY :pW; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )10;
  sqlstm.offset = (unsigned int  )5;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)uN;
  sqlstm.sqhstl[0] = (unsigned int  )0;
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)pW;
  sqlstm.sqhstl[1] = (unsigned int  )0;
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlstm.sqlcmax = (unsigned int )100;
  sqlstm.sqlcmin = (unsigned int )2;
  sqlstm.sqlcincr = (unsigned int )1;
  sqlstm.sqlctimeout = (unsigned int )0;
  sqlstm.sqlcnowait = (unsigned int )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("ORACLE error in HDbConn::openConnection(...):");
}


  if (sqlca.sqlcode==0) {
    dbIsOpen=kTRUE;
    cout<<"Connected to Oracle database"<<endl;
  }
  else cout<<"*** Failed to connect to Oracle ***"<<endl;
  delete [] passwd;
  return dbIsOpen;
}   
 
void HDbConn::closeDbConn() {  
  // Disconnects from ORACLE
  // A transaction will be automatically rolled back, that means,
  // changes in the database are not stored without an explicit COMMIT before
  /* EXEC SQL WHENEVER SQLERROR DO
    showSqlError("ORACLE error in HDbConn::closeDbConn():"); */ 

  if (dbIsOpen) {
    /* EXEC SQL ROLLBACK RELEASE; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 4;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )36;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) showSqlError("ORACLE error in HDbConn::closeDbConn():");
}


    dbIsOpen=kFALSE;
    cout<<"connection to Oracle closed"<<endl;
  }
}

void HDbConn::showSqlError(const Char_t* f) {
  // shows SQL error messages
  Char_t errmsg[513];
  size_t buflen, msglen;
  buflen=sizeof(errmsg)-1;
  sqlglm(errmsg,&buflen,&msglen);
  if ((++msglen)<buflen) {
    errmsg[msglen]='\0';
  } else {
    errmsg[buflen]='\0';
  }
  Error(f,"\n%s\n",errmsg);
//  Error(f,"\n%s",sqlca.sqlerrm.sqlerrmc);
}