msd_soap_service.cc

//---------------------------------------------------
// msd_soap_service.cc
// 
// Project: PDBe API Framework 
// Module:  PDBe API Webservice (SOAP) Server (Main Web Server Program) 
//
// To build:
//    make wserviced / make wservice
//
// SOAP User Layer
// Last updated: 25 February 2004 10:17
// (C) Siamak Sobhany
//---------------------------------------------------
// 

#include <pthread.h> 
#include <iostream>
#include <fstream>
#include <string.h>
#include <time.h> 
#include <ctime>
#include <signal.h>
#include <sys/stat.h> // for open()
#include <sys/types.h>
#include <sys/socket.h>
#include <exception>
#include <typeinfo>

#ifndef __MSD_DEFS_H__
#include "msd_defs.h"
#endif

#ifndef __MSD_ADMIN_H__
#include "msd_admin.h"
#endif


#include "msd_soapH.h"

#ifndef __MSD_SAX_2_PARSER__
#include "msdSax2Parser.h"
#endif

#ifndef __MSD_SOAP_ENABLED__
#define __MSD_SOAP_ENABLED__
#endif


#ifndef __MSD_USER_H__
#include "msd_user.h"
#endif

#include "msd_soap_service.nsmap"

#ifndef  __SRV_PXML__
#include "srv_pxml.h"
#endif

#include "expat.h"


#define uSec *-1 
#define mSec *-1000 

#define BACKLOG 100 // Max. request backlog (queue size)
#define MAX_THR 16 // Max. threads to serve requests e.g. 8
#define SERVER_TIMEOUT (24*60*60) /* die after 24 hrs waiting */
#define IO_TIMEOUT 60 /* deny serving slow clients */
#define COOKIE_DOMAIN "localhost:8080" /* must be your current domain for cookies to work */

#define AUTH_USERID "admin"
#define AUTH_PASSWD "guest"

static time_t start = 0;
#define MAXRECORDS 5000
#define MAX_FILE_SIZE (10000000)
#define POOLSIZE 1000   // max number of remote objects that can be alive at any instance
#define LEASETERM 120 //(24*60*60)      // 60 lease term (in seconds). Also the rate at which objects are purged
#define N 4



int xml_elno=-1;
msd_xml_element * xml_inf;
char * xml_Buff;
char * xml_txtbuff;
const char msd_soap_service[] = "http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service.cgi";
int argcg;
char ** argvg;


void *process_request(void*); 

// xpath XML parser callbacks
void default_hndl(void *data, const char *s, int len);
void printcurrent(XML_Parser x_p); 
void start_hndl(void *data, const char *el, const char **attr);
void end_hndl(void *data, const char *el);
void char_hndl(void *data, const char *txt, int txtlen);
void proc_hndl(void *data, const char *target, const char *pidata);

// streaming DIME callbacks
static void *dime_read_open(struct soap*, void*, const char*, const char*, const char*);
static void dime_read_close(struct soap*, void*);
static size_t dime_read(struct soap*, void*, char*, size_t);

//~~~Daemon callback defenitions:
void showsignal(int signo);
void clone(int signo);
void sigpipe_handle(int x);
int copy_file(struct soap *soap, const char *name, const char *type);

//~~~~Functions:
bool msd_authenticate(struct soap* soap);



//
//  Server-side base connector class methods
//






void t__connect::set(char* host_n, char* user_n, char* passwd)
{ dbserver= (char*)soap_malloc(soap,32);
  username= (char*)soap_malloc(soap,32);
  password= (char*)soap_malloc(soap,32);
  strcpy(dbserver,host_n);
  strcpy(username,user_n);
  strcpy(password,passwd);
}

void t__connect::get()
{
}



void t__query::set(t__connect * pcon, t__resultset * prs, char* qry)
{char* hn = (char*)soap_malloc(soap,32);
 char* un = (char*)soap_malloc(soap,32);
 char* pw = (char*)soap_malloc(soap,32);
 char* ls = (char*)soap_malloc(soap,128);
 conn_name = (char*)soap_malloc(soap,64);
 result_name = (char*)soap_malloc(soap,64);
 loginstr= (char*)soap_malloc(soap,128);
 query_stm = (char*)soap_malloc(soap,3000);
 strcpy(conn_name, pcon->name);
 strcpy(result_name, prs->name);
 sprintf(query_stm,"%s", qry);
 //strcpy(query_stm, qry);
 strcpy(hn, pcon->dbserver);
 strcpy(un, pcon->username);
 strcpy(pw, pcon->password);
 sprintf(ls, "%s/%s@%s", un,pw,hn);
 strcpy(loginstr,ls);
 soap_dealloc(soap,(void*)hn);
 soap_dealloc(soap,(void*)un);
 soap_dealloc(soap,(void*)pw);
 soap_dealloc(soap,(void*)ls);
}

void  t__query::get()
{
}

void t__resultset::set(t__connect * pcon, char* queryn)
{conn_name=(char*)soap_malloc(soap,64);
 strcpy(conn_name, pcon->name);
 query_name=(char*)soap_malloc(soap,64);
 strcpy(query_name,queryn);
}

void t__resultset::get()
{
}




class MSDConnector
{ public:
  t__root *ref[POOLSIZE];       // pool of objects (t__root is base class)
  unsigned int handle;          // handle generation counter (is allowed to wrap around 32 bits)
  MSDConnector();
  ~MSDConnector();
  unsigned int create(struct soap *soap, enum t__object object, char *name);
  unsigned int lookup(enum t__object object, char *name);
  unsigned int rename(struct soap *soap, unsigned int handle, char *name);
  void release(unsigned int handle);
  void purge();
  t__root *get(unsigned int handle);
  t__root *root(unsigned int handle);
  t__connect *connect(unsigned int handle);
  t__query *query(unsigned int handle);
  t__resultset *resultset(unsigned int handle);
  int save(const char *file);
  int load(const char *file);
  int xf;
};

MSDConnector::MSDConnector()
{ for (int i = 0; i < POOLSIZE; i++)
        ref[i] = NULL;
    handle = 0;
        xf=0;
}

// Remove all objects from pool
MSDConnector::~MSDConnector()
{ for (int i = 0; i < POOLSIZE; i++)
    if (ref[i])
      delete ref[i];
}

// Create a new object, place it in the pool, and return handle
unsigned int MSDConnector::create(struct soap *soap, enum t__object object, char *name)
{ for (int i = 0; i < POOLSIZE; i++)
    if (!ref[++handle % POOLSIZE])      // succeeds if this slot is available
    { t__root *r = NULL;
      if (!handle)
        handle += POOLSIZE;             // make sure handle is never 0 (0 indicates invalid handle)
      switch (object)                   // type of object to instantiate
      { case ROOT:
          r = new t__root();
          break;
        case CONNECT:
          r = new t__connect();
      break;
            case QUERY:
          r = new t__query();
      break;
            case RESULTSET:
          r = new t__resultset();
      break;
      }
      if (r)
      { ref[handle % POOLSIZE] = r;             // add object to the pool
        r->object = object;                     // save type
          if (name)                             // save name (if assigned)
           { r->name = (char*)soap_malloc(soap,strlen(name)+1);
            strcpy(r->name, name);
           }
           else{
            r->name = NULL;
           }
      r->handle = handle;                       // keep handle for verification
      r->renew();                               // renew its lease
      return handle;
      }
      return 0;
    }
  return 0;
}

// Lookup the name of an object and return handle
unsigned int MSDConnector::lookup(enum t__object object, char *name)
{       for (int i = 0; i < POOLSIZE; i++)
    if (ref[i] && ref[i]->object == object && ref[i]->name && (strcmp(ref[i]->name, name)==0))
    { ref[i]->renew();
          return ref[i]->handle;
    }
    return 0;
 }

// Rename object and return handle if successful
unsigned int MSDConnector::rename(struct soap *soap,unsigned int handle, char *name)
{ t__root *r = get(handle);
  if (r)
  { if (r->name)
          soap_dealloc(soap,r->name);
      //free(r->name);
    r->name = (char*)soap_malloc(soap,strlen(name)+1);
    strcpy(r->name, name);
    r->renew();
    return handle;
  }
  return 0;
}

// get ref to object from handle
t__root *MSDConnector::get(unsigned int handle)
{ t__root *r = ref[handle % POOLSIZE];
  if (r && r->handle == handle)
    return r;
  return NULL;
}

// get ref to root object from handle and renew lease
t__root *MSDConnector::root(unsigned int handle)
{ t__root *r = get(handle);
  if (r)
    r->renew();
  return r;
}


t__connect *MSDConnector::connect(unsigned int handle)
{ t__connect *con = (t__connect*)get(handle);
  if (con)
  { if (con->object == CONNECT)
      con->renew();
    else
      con = NULL;
  }
  return con;
}
t__query *MSDConnector::query(unsigned int handle)
{ t__query *q = (t__query*)get(handle);
  if (q)
  { if (q->object == QUERY)
      q->renew();
    else
      q = NULL;
  }
  return q;
}
 
t__resultset *MSDConnector::resultset(unsigned int handle)
{ t__resultset *rs = (t__resultset*)get(handle);
  if (rs)
  { if (rs->object == RESULTSET)
      rs->renew();
    else
      rs = NULL;
  }
  return rs;
}





// remove all objects from pool whose lease has expired
void MSDConnector::purge()
{ time_t t = time(NULL);                // current time
  fprintf(stderr, "Purging objects...");
  for (int i = 0; i < POOLSIZE; i++)
  { t__root *r = ref[i];
    if (r && r->lease < t)              // expired?
    { if (r->name)
        fprintf(stderr, " %s(%u)", r->name, r->handle);
      else
        fprintf(stderr, " (%u)", r->handle);
      delete r;
      ref[i] = NULL;
    }
  }
  fprintf(stderr, "\nKeeping objects...");
  for (int i = 0; i < POOLSIZE; i++)
  { t__root *r = ref[i];
    if (r)
    { if (r->name)
        fprintf(stderr, " %s(%u)", r->name, r->handle);
      else
        fprintf(stderr, " (%u)", r->handle);
    }
  }
  fprintf(stderr, "\n");
}

// remove object from pool and release slot
void MSDConnector::release(unsigned int handle)
{ t__root *r = get(handle);
  if (r)
  { delete r;
    ref[handle % POOLSIZE] = NULL;
  }
}

// save object pool to file (or stdout)
int MSDConnector::save(const char *file)
{ struct soap soap;     // use a new local gSOAP environment
 
  soap_init(&soap);
  if (! file){
  
  soap_omode(&soap, SOAP_ENC_ZLIB); 
  }
  
  soap_begin(&soap);
  if (file){
    soap.sendfd = open(file, O_CREAT|O_TRUNC|O_WRONLY, S_IREAD|S_IWRITE);
        //soap.sendfd = fopen(file, "w+");
    if (soap.sendfd < 0)
    return -1;}
  soap_begin_send(&soap);
  for (int i = 0; i < POOLSIZE; i++)
    if (ref[i])
    { ref[i]->soap_serialize(&soap);
      soap_begin_send(&soap);
      ref[i]->soap_put(&soap, "item", NULL);
      soap_end_send(&soap);
    }
  if (file)
    close(soap.sendfd);
  soap_end(&soap);
  soap_done(&soap);
  return 0;
}

// load object pool from file (or stdin)
int MSDConnector::load(const char *file)
{ struct soap soap;
  t__root *r;
  
  soap_init(&soap);
  if (! file){
  
  soap_imode(&soap, SOAP_ENC_ZLIB);
  }
   
  if (file){
    soap.recvfd = open(file, O_RDONLY);
          if (soap.recvfd < 0)
    return -1;}
  soap_begin_recv(&soap);
  for (int i = 0; i < POOLSIZE; i++)
  { if (ref[i])
    { delete ref[i];
      ref[i] = NULL;
    }
  }
  for (;;)
  { r = soap_in_t__root(&soap, "item", NULL, NULL);     // use the 'in' routine ('get' will also attempt to parse the remaining XML)
    if (r)
      ref[r->handle % POOLSIZE] = r;
    else
      break;
  }
  if (file)
    close(soap.recvfd);

  soap_end_recv(&soap);
  if (soap.error != SOAP_OK && soap.error != SOAP_EOF)
  { soap_print_fault(&soap, stderr);
    soap_print_fault_location(&soap, stderr);
  }
  
  soap_free(&soap);     // do not call soap_end: this would remove all deserialized data
  soap_done(&soap);
  return 0;
}





int set_datafile_name (const char* fname ){
  char  buffer[64];
  char  newenv[64];
  sprintf(buffer,getenv ("MSD_WS_DATAFILE"));
  if (strstr(buffer, fname)==NULL)
  {
    sprintf(newenv , "MSD_WS_DATAFILE=%s",fname);
        putenv (newenv);
  }
 return 0;
}
 

//static char *TMPDIR = ".";



static msdUser supervisor_user;

int main(int argc, char **argv)
{  char logstr[128];
  
   msdAdmin admin_object;
  
   if (!msd_get_userinfo(admin_object, supervisor_user))
        {fprintf(stderr,"\nAuthentication failed, only Administrator can start the server.");
                  exit(1);
        }
   sprintf(logstr,"%s/%s@%s", supervisor_user.dbuname,supervisor_user.getDBPass(),supervisor_user.host);
   fprintf(stderr,logstr);
   struct soap soap;
   MSDConnector connector;
   

   soap_init(&soap);

  
   soap_set_omode(&soap, SOAP_XML_GRAPH);
   
   
   soap.accept_timeout = LEASETERM;     
  
   soap.user = (void*)&connector;               // associate connector with run-time
  
   char* fn;
   
   
   if (argc < 3)
        {
        fn=(char*)soap_malloc(&soap,65);
        if (argv[1] && (strlen(argv[1])!= 0)) // if Client has specified his session id
         sprintf(fn,"session%s.dat",argv[1]);
        else 
         sprintf(fn,"%s","sessioncommon.dat"); // if not, then  use sessioncommon and accept probably waiting
                                               // for file access.
        
    
        connector.load(fn);     // if CGI is used, load the entire pool (not very efficient and there may be a competition for access to this file! This is just to demonstrate load/save of the entire pool)
    connector.purge();
    soap_serve(&soap); // run as CGI application over the Web
    connector.save(fn);
  
   soap_free(&soap);
   soap_done(&soap);
   }
  else 
  
   {  int m, s; 
      
      
     
         
          struct soap *soap_thr[MAX_THR]; // each thread needs a runtime environment 
      
      pthread_t tid[MAX_THR]; 
      
          
          char *host = (char*)soap_malloc(&soap,strlen(argv[1])+1); 
          sprintf(host,"%s",argv[1]);
      int port = atoi(argv[2]); 
          
          msdPrompt(host);
          fprintf(stderr, "Starting PDBe SOAP Web API Server on port %d\n",  port);
        
        pid_t pid;
    signal(SIGINT,showsignal);
    signal(SIGUSR1,clone);
        pid = fork();

    if (pid <0){
                msdPrompt(host);
           fprintf(stderr, "Forking Error : )\n");
           exit(-1);
    }else if (pid !=0 ){
                msdPrompt(host);
        fprintf(stderr, "Parrent process level 1 started...\n");
    }else{
         pid = fork();

          if (pid <0){
                  msdPrompt(host);
                fprintf(stderr, "Forking error : )\n");
                exit(-1);
          }else if (pid !=0 ){
                  msdPrompt(host);
                fprintf(stderr, "Parrent process level 2 started...\n");
                }else {
          m = soap_bind(&soap, host, port, BACKLOG); 
      if (m < 0)
      {msdPrompt(host);
           fprintf(stderr,"Socket connection failed. %d \nTrying again, please wait...", m);
      }
          int nc=1;
          while (m < 0){  //if
        
             fprintf(stderr,"%2d", nc);
         wait(3);
                 m = soap_bind(&soap, host, port, BACKLOG);
                 fprintf(stderr,"");
                 nc++;
                 if (nc > 99)
                 {fprintf(stderr,"Socket connection failed. %d \nCan not bind to the port.", m);
                  exit(1);
                 }
                
          }
          msdPrompt(host);
          fprintf(stderr,"Port bind successful: master socket: %d \n", m);
          fprintf(stderr,"Server is running...\n");
          
          signal(SIGPIPE, sigpipe_handle); 
          
          for (int count = 0; count >= 0; count++)//(;;) 
      { soap.socket_flags = MSG_NOSIGNAL; // use this 
    
        msdPrompt(host);
                fprintf(stderr,"Starting Session or Job %d ...\n", count);
       
         
         for (int i = 0; i < MAX_THR; i++) 
         { 
            s = soap_accept(&soap); 
            if (s < 0)
                        
              { if (soap.errnum){
                                 
                 soap_print_fault(&soap, stderr);
                             break;
                                }
            
                    else                        // errnum is 0, which means a timeout has occurred
                    { connector.purge();        // purge objects whose lease has ran out
                      continue;
                    }
                  
              }
            
                
            msdPrompt(host);
                        fprintf(stderr,"Thread %d accepts socket %d connection from IP %d.%d.%d.%d \n", i, s, (soap.ip >> 24)&0xFF, (soap.ip >> 16)&0xFF, (soap.ip >> 8)&0xFF, soap.ip&0xFF);
                        if (!soap_thr[i]) // first time around 
            {  
                            soap_thr[i] = soap_copy(&soap);// make a safe copy  // Valid!
                if (!soap_thr[i]){
                                msdPrompt(host);
                                fprintf(stderr,"Can not soap copy for Thread %d ", i);
                exit(1); // could not allocate 
                            }else{
                        
                                  soap_set_omode(soap_thr[i], SOAP_XML_GRAPH); 
                              
                                  soap_thr[i]->socket = s; 
                              soap_thr[i]->user = (void*)&connector;
                  pthread_create(&tid[i], NULL, (void*(*)(void*))process_request, (void*)soap_thr[i]);
                        
                                
                            }
                           
                        } 
            else // recycle soap environment 
            {  pthread_join(tid[i], NULL); //pthread_join(tid[i], NULL); //
           
                           msdPrompt(host);
                           fprintf(stderr,"Thread %d from Job %d completed.\n", i, count);
                           
                           if (soap_thr[i]->error != SOAP_OK && soap_thr[i]->error != SOAP_EOF)//******* Valid code
                { soap_print_fault(soap_thr[i], stderr);                                                          //******* Valid code                              
                  soap_print_fault_location(soap_thr[i], stderr);                                         //******** Valid code                             
                }
                           
                          
                           soap_destroy(soap_thr[i]); //******* Valid code
                           soap_end(soap_thr[i]); //******* Valid code: deallocate data of old thread 
                           soap_free(soap_thr[i]); //******* Valid code
                           soap_done(soap_thr[i]); //******** Valid code
                         
                           soap_thr[i] = NULL;
                           //tid[i] = NULL;     
            } 
                        
         } // end for
                 for (int i = 0; i < MAX_THR; i++) {
          if (soap_thr[i])
          {soap_thr[i] = NULL;
                  }
                 }
          } // end for

        soap_done(&soap); // close master socket   
   } 
  } // else Forking (daemon code)
 } // else Forking (daemon code)
  return 0;
}

void *process_request(void *soap) 
{
   pthread_detach(pthread_self()); 
  
   soap_serve((struct soap*)soap);
 
   return NULL; 
} 

//~~~~~~~ expat Callback implementations:
void default_hndl(void *data, const char *s, int len) {
  
}  /* End default_hndl */

/****************************************************************
 ** Call from within a handler to print the currently recognized
 ** document fragment. Temporarily set the default handler and then
 ** invoke it via the the XML_DefaultCurrent call.
 */
void printcurrent(XML_Parser x_p) {
  XML_SetDefaultHandler(x_p, default_hndl);
  XML_DefaultCurrent(x_p);
  XML_SetDefaultHandler(x_p, (XML_DefaultHandler) 0);
}  /* End printcurrent */

void start_hndl(void *data, const char *el, const char **attr) {
xml_elno++;
xml_inf[xml_elno].tag=(char *)malloc(strlen(el)+1);
sprintf(xml_inf[xml_elno].tag,"%s",el);
xml_inf[xml_elno].data=(char *)malloc(strlen(xml_txtbuff)+1);
sprintf(xml_inf[xml_elno].data,"%s","");
sprintf(xml_txtbuff,"%s", "");  //NULL
  printcurrent((XML_Parser) data);
}  /* End of start_hndl */

void end_hndl(void *data, const char *el) {
 sprintf(xml_inf[xml_elno].data,"%s",xml_txtbuff);
 
}  /* End of end_hndl */

void char_hndl(void *data, const char *txt, int txtlen) {
 
 char* xbuf =(char*)SOAP_MALLOC(strlen(txt)+1);
 
 sprintf(xbuf,"%s","");
 strcpy(xbuf,txt);
 xbuf[txtlen]='\0';
 
 sprintf(xml_txtbuff,"%s%s", xml_txtbuff, xbuf);
  
}  /* End char_hndl */

void proc_hndl(void *data, const char *target, const char *pidata) {
 
  printcurrent((XML_Parser) data);

}  /* End proc_hndl */

        void showsignal(int signo){
        
        
                fprintf(stderr,"\nSignal : %d \n",signo);
                exit(1);
        }
        
        void clone(int signo){
                main(argcg, argvg);
                return;
        }

        void sigpipe_handle(int x) {} 
static void *dime_read_open(struct soap *soap, void *handle, const char *id, const char *type, const char *options)
{ // we should return NULL without setting soap->error if we don't want to use the streaming callback for this DIME attachment. The handle contains the non-NULL __ptr field value which should have been set in the application.
  // the value of the handle can be changed and will be passed on to the fdimeread and fdimereadclose callbacks. The value will not affect the __ptr field.
  return handle;
}

static void dime_read_close(struct soap *soap, void *handle)
{ fclose((FILE*)handle);
}

static size_t dime_read(struct soap *soap, void *handle, char *buf, size_t len)
{ return fread(buf, 1, len, (FILE*)handle);
}



int copy_file(struct soap *soap, const char *name, const char *type)
{ FILE *fd;
  size_t r;
  fd = fopen(name, "r"); /* open file to copy */
  if (!fd)
    return SOAP_EOF; /* return HTTP error? */
  soap->http_content = type;
  if (soap_begin_send(soap)
   || soap_response(soap, SOAP_FILE)) /* OK HTTP response header */
    return soap->error;
  for (;;)
  { r = fread(soap->tmpbuf, 1, sizeof(soap->tmpbuf), fd);
    if (!r)
      break;
    if (soap_send_raw(soap, soap->tmpbuf, r))
    { soap_end_send(soap);
      fclose(fd);
      return soap->error;
    }
  }
  fclose(fd);
  if (soap_end_send(soap))
    return soap->error;
  return SOAP_OK;
}

bool msd_authenticate(struct soap* soap){
  msdAdmin sec_check;  
  if (!soap->userid || !soap->passwd || !sec_check.msdLogin(soap->userid,soap->passwd ))
        return false;
        return true;
}


int ns4__msdGetSSMXml(struct soap *soap, char * sessionid, int &res_ssmxml)
{ if (sessionid)
  { char* session_id = (char*)soap_malloc(soap, strlen(sessionid)+1);
    sprintf(session_id,"%s",sessionid);
    char* name = (char*)soap_malloc(soap,256);
    sprintf(name,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.xml",session_id);
        soap_set_omode(soap, SOAP_IO_CHUNK);
    
        if (!strchr(name, '\\') && !strchr(name, ':')) // !strchr(name, '/') && 
      { 
                if (!soap_tag_cmp(name, "*.xml")
            || !soap_tag_cmp(name, "*.xsd")
            || !soap_tag_cmp(name, "*.wsdl"))
         if (copy_file(soap, name , "text/xml") == SOAP_OK)
         {res_ssmxml = 0;
                        return SOAP_OK;
         }else{res_ssmxml = 12;
                          return soap_sender_fault(soap, "Fille Can not be copied", NULL);
                         }
                
                
          }
 }
  else
    return soap_sender_fault(soap, "Fille name required to transfer", NULL);   
  return SOAP_OK;
}

int ns4__msdGetSoapBase64Data(struct soap *soap, int diyf, char * sessionid, SOAP_ENC__base64 &s_bindata)
{ if (sessionid)
  { char* session_id = (char*)soap_malloc(soap, strlen(sessionid)+1);
    sprintf(session_id,"%s",sessionid);
    char* name = (char*)soap_malloc(soap,256);
    sprintf(name,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.xml",session_id);
        int j=0;
        bool out_file_ok;
        if ((out_file_ok=fileexists(name)== false) && (diyf != 0))
    {return soap_sender_fault(soap, "Result fille not ready", NULL);
        }
        while(j<12*15) // up to 15 minutes wait for result
     { if (out_file_ok=fileexists(name)== true)
          {
            break;}else 
          {
                wait(2);
          } // wait 2 seconds and retry again
          j++;
     } // end while
        FILE *fd = NULL;
        struct stat sb;
    int i, c, xmlsize;
    fd = fopen(name, "rb");
    if (!fd || !out_file_ok)
      return soap_sender_fault(soap, "Cannot open file", NULL);
      if (!fstat(fileno(fd), &sb) && sb.st_size > 0)
     {xmlsize= sb.st_size;}
          else
           {xmlsize=MAX_FILE_SIZE;}
         
    
          
          s_bindata.__ptr = (unsigned char*)soap_malloc(soap, xmlsize);
      for (i = 0; i < xmlsize; i++)
      { if ((c = fgetc(fd)) == EOF)
          break;
        s_bindata.__ptr[i] = c;
      }
      fclose(fd);
      s_bindata.__size = i;
        
  }
  else
    return soap_sender_fault(soap, "Fille name required to transfer", NULL);   
  return SOAP_OK;
}


int ns4__msdGetDime(struct soap *soap, int diyf, char* sessionid , xsd__base64Binary &d_bindata)
{ if (sessionid)
  { char* session_id = (char*)soap_malloc(soap, strlen(sessionid)+1);
    sprintf(session_id,"%s",sessionid);
    char* name = (char*)soap_malloc(soap,256);
    sprintf(name,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.xml",session_id);
        int j=0;
        bool out_file_ok;
    if ((out_file_ok=fileexists(name)== false) && (diyf != 0))
    {return soap_sender_fault(soap, "Result fille not ready", NULL);
        }
        while(j<12*15) // up to 15 minutes wait for result
     { if (out_file_ok=fileexists(name)== true)
          {
            break;}else 
          {
                wait(2);
          } // wait 2 seconds and retry again
          j++;
     } // end while
    FILE *fd = NULL;
    struct stat sb;
    int i, c;
    // do some checks on the file name to verify it is local:
    if (!strchr(name, '\\') && !strchr(name, ':')) 
      fd = fopen(name, "rb");
    if (!fd)
      return soap_sender_fault(soap, "Cannot open file", NULL);
    if (!fstat(fileno(fd), &sb) && sb.st_size > 0)
    { // since we can get the length of the file, we can stream it
      soap->fdimereadopen = dime_read_open;
      soap->fdimereadclose = dime_read_close;
      soap->fdimeread = dime_read;
      d_bindata.__ptr = (unsigned char*)fd; // must set to non-NULL (this is our fd handle which we need in the callbacks
      d_bindata.__size = sb.st_size; // must set size
    }
    else // don't know the size, so buffer it
    { d_bindata.__ptr = (unsigned char*)soap_malloc(soap, MAX_FILE_SIZE);
      for (i = 0; i < MAX_FILE_SIZE; i++)
      { if ((c = fgetc(fd)) == EOF)
          break;
        d_bindata.__ptr[i] = c;
      }
      fclose(fd);
      d_bindata.__size = i;
    }
    d_bindata.id = "";  
        d_bindata.type = "text/xml";
        
    d_bindata.options = soap_dime_option(soap, 0, "SSM_XML_OUT");
        
  }
  else
    return soap_sender_fault(soap, "Fille name required to transfer", NULL);
  return SOAP_OK;
}

int ns4__msdGetXsdBase64BinData(struct soap *soap, int diyf, char * sessionid, xsd__base64Binary &x_bindata)
{ if (sessionid)
  { char* session_id = (char*)soap_malloc(soap, strlen(sessionid)+1);
    sprintf(session_id,"%s",sessionid);
    char* name = (char*)soap_malloc(soap,256);
    sprintf(name,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.xml",session_id);
        int j=0;
        bool out_file_ok;
        if ((out_file_ok=fileexists(name)== false) && (diyf != 0))
    {return soap_sender_fault(soap, "Result fille not ready", NULL);
        }
        while(j<12*15) // up to 15 minutes wait for result
     { if (out_file_ok=ssm_file_completed(name,"</SSMResults>")== true)
          {
            break;}else 
          {
                wait(2);
          } // wait 2 seconds and retry again
          j++;
     } // end while
        FILE *fd = NULL;
        struct stat sb;
    int i, c, xmlsize;
    fd = fopen(name, "rb");
    if (!fd || !out_file_ok)
      return soap_sender_fault(soap, "Cannot open file", NULL);
      if (!fstat(fileno(fd), &sb) && sb.st_size > 0)
     
      {xmlsize= sb.st_size;}
          else
           {xmlsize=MAX_FILE_SIZE;}
         
    
          
          x_bindata.__ptr = (unsigned char*)soap_malloc(soap, xmlsize);
      for (i = 0; i < xmlsize; i++)
      { if ((c = fgetc(fd)) == EOF)
          break;
        x_bindata.__ptr[i] = c;
      }
      fclose(fd);
      x_bindata.__size = i;
        
  }
  else
    return soap_sender_fault(soap, "Fille name required to transfer", NULL);   
  return SOAP_OK;
}



int ns4__msdValidate(struct soap *soap, char* UserXmlStr, char*&ServXmlStr)
{ char* tmpin=(char*)soap_malloc(soap, 2048);
  strcpy(tmpin,UserXmlStr);
  char* tmpout=(char*)soap_malloc(soap, 2048);
  msdSax2Parser* p = new msdSax2Parser();
  strcpy(tmpout, p->validate(tmpin));
  ServXmlStr = tmpout;
  return SOAP_OK;
}

















//
//  Remote connector method implementations
//

int ns4__create(struct soap *soap, enum t__object object, char *name, enum t__status &c_status)
{ char* oname;
  oname=(char*)soap_malloc(soap,strlen(name)+1);
  strcpy(oname,name);
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->create(soap, object, oname);
    if (soap->header->h__handle){
      c_status = OK;
        } else c_status = INVALID;
  }else c_status = RETRY;
  return SOAP_OK;
}

int ns4__lookup(struct soap *soap, enum t__object object, char *name, enum t__status &l_status)
{ char* oname;
  oname=(char*)soap_malloc(soap,strlen(name)+1);
  strcpy(oname,name);
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->lookup(object, oname);
    if (soap->header->h__handle)
      l_status = OK;
    else l_status = NOTFOUND;
  }else l_status = RETRY;
  return SOAP_OK;
}

int ns4__rename(struct soap *soap, char *name, enum t__status &ren_status)
{ char* oname;
  oname=(char*)soap_malloc(soap,strlen(name)+1);
  strcpy(oname,name);
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (soap->header)
  { soap->header->h__handle = connector->rename(soap, soap->header->h__handle, oname);
    if (soap->header->h__handle)
      ren_status = OK;
    else ren_status = INVALID;
  }else ren_status = INVALID;
  return SOAP_OK;
}

int ns4__release(struct soap *soap, enum t__status &rel_status)
{ MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (soap->header && soap->header->h__handle)
  { connector->release(soap->header->h__handle);
    rel_status = OK;
  }else rel_status = INVALID;
  return SOAP_OK;
}



//
//  Remote connect and stream methods implementations
//
int ns4__msdConnect(struct soap *soap, char* conn_name, int &conn_status)
{ extern msdUser supervisor_user;
  
  char* host = (char*)soap_malloc(soap,81);
  char* usern = (char*)soap_malloc(soap,81);
  char* pass = (char*)soap_malloc(soap,81);
  sprintf(host,"%s",supervisor_user.host);
  sprintf(usern,"%s", supervisor_user.dbuname);
  sprintf(pass,"%s", supervisor_user.getDBPass());
  char errmess[512];
  char* hn;
  char* un;
  char* pw;
  char* cn;
  cn = (char*)soap_malloc(soap, strlen(conn_name)+1);
  //strcpy(cn, conn_name);
  sprintf(cn,"%s", conn_name);
  hn = (char*)soap_malloc(soap, strlen(host)+1);
  //strcpy(hn, host);
  sprintf(hn, "%s" , host);
  un = (char*)soap_malloc(soap, strlen(usern)+1);
  //strcpy(un, usern);
  sprintf(un,"%s", usern);
  pw = (char*)soap_malloc(soap, strlen(pass)+1);
  //strcpy(pw, pass);
  sprintf(pw,"%s", pass);
 if (!msd_authenticate(soap))
 {
          conn_status = 7;
          return soap_sender_fault(soap, "\nLogin Failed. This method requires authentication.\n Username and Password" 
                                           " Should be set just before calling this method.", NULL);
 }
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->lookup(CONNECT, cn);
    if (soap->header->h__handle){
                sprintf(errmess,"A Connection Object with name: %s already exists.", cn);
                return soap_sender_fault(soap, errmess, NULL);
        }
          soap->header->h__handle = connector->create(soap, CONNECT, cn);
    if (soap->header->h__handle){
      t__connect * rc = connector->connect(soap->header->h__handle);
          if (rc)
          {rc->set(hn, un, pw); //  
           rc=NULL;
           conn_status = 0; // OK; 
          }else{  conn_status = 1; // INVALID;
                  return soap_sender_fault(soap, "Invalid Connect Object.", NULL);
                  } 
                 
        }else {  conn_status = 2; // NOTFOUND;
                 return soap_sender_fault(soap, "Connect Object not created.", NULL);
                  } 
                          
  }else {   conn_status = 3; // RETRY;
                return soap_sender_fault(soap, "Soap Header handle not found.", NULL);
                  }
         
 soap_dealloc(soap,(void*)hn);
 soap_dealloc(soap,(void*)un);
 soap_dealloc(soap,(void*)pw);
 soap_dealloc(soap,(void*)cn);
 return SOAP_OK;
 

}


int ns4__msdGetconnect(struct soap *soap, char* conn_name, int &gstatus )
{ MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  
  if (soap->header)
  { t__connect *conn = connector->connect(soap->header->h__handle);
    if (conn){
      //rc = *(msdbConnect*)conn->get();
          gstatus = 0;
  }else gstatus = 1;
  }
  return SOAP_OK;
}





int msd_sender_exception(struct soap *soap, msdbConnect& db, msdbException& p){ 
          char* errstr = (char*)soap_malloc(soap,sizeof(p.stm_text)+10);
                  char* errmsg = (char*)soap_malloc(soap,sizeof(p.msg)+1);
                  sprintf(errstr, "\nSQL: [%s]\n", p.stm_text);
                  stringstream buff;
          buff << p.msg;
              string buffstr = buff.str()+ errstr;
              sprintf(errmsg,"%s", buffstr.c_str());
              db.logoff();
          msdbConnect::otl_terminate();
                  return soap_sender_fault(soap, errmsg, NULL);
} 

int ns4__msdExecQuery(struct soap *soap, char* conn_name, char* query_name, char* result_name, int buf, int &exec_status)
{ char* sql;
  char* cn;
  char* qn;
  char* rn;
  int Nrecs=0;
  
  //double difs;
  //time_t starts;
  //time_t ends; 
  
  //clock_t time_start;
  //clock_t time_end;
  
  //starts = time (NULL);
  
  //time_start = clock();
  
  
  if (!msd_authenticate(soap))
  { exec_status = 7;
          return soap_sender_fault(soap, "\nLogin Failed. This method requires authentication.\n"
                                           " Username and Password Should be set just before calling this method."
                                                                 , NULL);
  }
  //sql = (char*)soap_malloc(soap, strlen(stm)+1);
  //sprintf(sql,"%s", stm);
  cn = (char*)soap_malloc(soap, strlen(conn_name)+1);
  sprintf(cn, "%s",conn_name);
  qn = (char*)soap_malloc(soap, strlen(query_name)+1);
  sprintf(qn, "%s",query_name);
  rn = (char*)soap_malloc(soap, strlen(result_name)+1);
  sprintf(rn, "%s",result_name);
  char* qr_err = (char*)soap_malloc(soap, 3072);
  char* qr_err_detail = (char*)soap_malloc(soap, 3072);
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->lookup(CONNECT, cn);
    if (soap->header->h__handle){
          t__connect * rc =connector->connect(soap->header->h__handle);
          soap->header->h__handle = connector->lookup(RESULTSET, rn);
          if (soap->header->h__handle){
           t__resultset* rs = connector->resultset(soap->header->h__handle);
           soap->header->h__handle = connector->lookup(QUERY, qn);
          if (soap->header->h__handle){
           t__query *qry = connector->query(soap->header->h__handle);
           if (qry && rc && rs)
       {sql = (char*)soap_malloc(soap, strlen(qry->query_stm)+1);
        sprintf(sql,"%s", qry->query_stm);
                
                //connector->xf=1;
                msdbConnect db;
        msdbConnect::msdbInit(1); // initialize OCI environment
        int j=0;
        int desc_len;
        otl_column_desc* desc;
                char* sqltmp=(char*)soap_malloc(soap,4096);
                sprintf(sqltmp,"%s",sql);
                char* sqlparam=(char*)soap_malloc(soap,4096);
                make_select_param(sqltmp,sqlparam);
                
        try{
         db.rlogon(qry->loginstr);
                 
                 db.set_max_long_size(MAXBLOBSIZE); // set maximum long string size for connect object
         
                 char* sqlcount=(char*)soap_malloc(soap,4096);
                 
                 
                 make_select_count (sqlparam,sqlcount);
                // cerr << "I'm here: " << endl << sqlcount << endl;
                msdbStream ic (buf, sqlcount, db);      
        ic << 1;
                
        while(!ic.eof()){ 
         ic >> Nrecs;
        } // end while
        }
        catch(msdbException& p){ // intercept OTL exceptions
          cerr<<p.msg<<endl; // print out error message
          cerr<<p.stm_text<<endl; // print out SQL that caused the error
          cerr<<p.var_info<<endl; // print out the variable that caused the error
          rs->hasdata=0;
                  qry->exf=0;
                  exec_status = 6; // database error
                  return msd_sender_exception(soap,db,p);
                 } // end catch
                
        try
        {
                
        
  if (Nrecs > 0){
        
  msdbStream i(buf, sqlparam, db); // buffer size -----(50)10
  //ins.set_flush(false); 
  //ins.open(bf, stmnt, r_db);
  // ***IMPORTANT*** : if there is  "cryteria" in the statement:
  i << 1; // assigning :f = 1
  desc=i.describe_select(desc_len);

 
  //soap_init(&tsoap);
  //xsd__anyType **  prs = (xsd__anyType**)soap_malloc(soap,desc_len*sizeof(xsd__anyType*));
  if (rs->prs){
        //for (int n=0;n<rs->cols;++n){
        //        for (int i=0;i<rs->rows ;++i){
        //              delete (*rs->prs[n])[i];
        //        }//end for
        //        soap_delete(soap, (void*)rs->prs[n]);
        //} //end for
        //soap_dealloc(soap,(void*)rs->prs);
    rs->prs=NULL;
  }
  rs->prs = (xsd__anyType**)soap_malloc(soap,desc_len*sizeof(xsd__anyType*));
  for(int n=0;n<desc_len;++n){
    //prs[n] = soap_new_xsd__anyType(soap,Nrecs);
        rs->prs[n] = new array(Nrecs);
    switch (desc[n].dbtype){                                                                   
         case 1 : {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__string(desc[n].dbsize+1);
                   }} break;         // desc[n].dbsize+1                  
         case 2 : {if (desc[n].scale == 129){ 
                       for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__float();
                   }}
                    else if (desc[n].scale==0)
                                {if ((desc[n].prec<=10 && desc[n].prec !=0) || has_integer_name(desc[n].name) == 1) // (desc[n].prec == 10 || desc[n].prec == 0)
                                                        {
                   for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__int();
                   }}else 
                                   {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__float();
                   }}
                                                }
                                else 
                       {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__int();
                           }}
                          } break;      // sprintf(type, "long int");   
                          
         case 3 : {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__float();
                   }} break;                               
         case 4 : {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__int();
                           }} break;                               
         case 5 : {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__int();
                           }} break;    // msd_unsignedint;                      
         case 6 : {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__short();
                   }} break;                         
         case 7 : {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__int();
                   }} break; // msd_long(0);
         case 12: {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__date();
                   }} break; // 93 in Oracle 9i
         case 96: {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__string(desc[n].dbsize+1); //(*prs[n])[i]= soap_new_xsd__string(soap,-1);
                   }} break;
         default: {for (int i=0;i<Nrecs ;++i )
                   {(*rs->prs[n])[i]= new xsd__string(desc[n].dbsize+1); //(*prs[n])[i]= soap_new_xsd__string(soap,-1);
                   }} 
        } // switch case
   
   //(*prs[n])[0]->msd_sym=intern( msdConst(desc[n].name));
                 
  }      // for loop
 
  
                      
  while(!i.eof()){ // while not end-of-data
        for (int n=0;n<desc_len ;++n ){
        (*rs->prs[n])[j]->getst(i);
        }
        ++j;
  }// end while loop      
         
                 
                 //out.__ptr=rs->prs;
                 //out.__size=desc_len;
                 rs->cols=desc_len;
                 rs->rows=Nrecs;
                 
                 rs->hasdata=1;
                 qry->exf=1;
  } //enf if 
                 //rs->r.__ptr=rs->prs;
                 //rs->r.__size=desc_len;
                 
                 
                 //for (int n=0;n<desc_len;++n){
                 // for (int i=j;i<Nrecs ;++i){
                 //     delete (*prs[n])[i];
                    // (*prs[n])[i]= NULL;
                    //  soap_delete(soap, (void*)(*prs[n])[i]);
                 // }//end for
                 // soap_delete(soap, (void*)prs[n]);
                 //} //end for
                
                } // end try
                
                //catch (std::exception& e)
        // {
                //      sprintf(qr_err, "Standard Exception occured:\n %s",e.what());
        //    return soap_sender_fault(soap, qr_err, NULL);
        // }

         catch(msdbException& p){ // intercept OTL exceptions
          cerr<<p.msg<<endl; // print out error message
          cerr<<p.stm_text<<endl; // print out SQL that caused the error
          cerr<<p.var_info<<endl; // print out the variable that caused the error
          rs->hasdata=0;
                  qry->exf=0;
                  exec_status = 6; // database error
                  return msd_sender_exception(soap,db,p);
                 } // end catch
                 db.logoff();
                 
                 //ends = time (NULL);
         //difs = difftime (ends,starts);
         //time_end= clock();
                //prs = NULL;
        

                 
                 
                 //ofstream outfile;
         //outfile.open("exec_queryServer.txt");
//~~~*****               outfile << "\nProcess has taken " << (time_end - time_start)/ CLOCKS_PER_SEC  << " seconds." << endl;
//~~~*****         outfile << "\nProcess has taken " <<  (1000*(time_end - time_start))/ CLOCKS_PER_SEC << " milliseconds.";
//~~~*****               outfile << "\nNo. of Columns: = " << desc_len <<endl;
//~~~*****               for(int j=0;j<N;++j){
//~~~*****          outfile << "\nRecord No.: " << j+1 << " Includes:" << endl;
//~~~*****                for(int n=0;n<desc_len;++n){
//~~~*****                      outfile << "Value of Field " << (*prs[n])[0]->msd_sym;//(*out.param[j])[n]->msd_sym;////
//~~~*****                      //(*out.ptr[j])[n]->fprint(outfile); //<< (*out.ptr[j])[n]->msd_val;
//~~~*****                      outfile << " = " ; 
//~~~*****                      (*prs[n])[j]->fprint(outfile);//(*out.param[j])[n]->fprint(outfile);//// //(*out.ptr[j])[n]->msd_val
//~~~*****                      outfile << endl; 
//~~~*****                }
//~~~*****               }
         //outfile << "\nSql Count:  " ;
                 //char* charout=(char*)soap_malloc(soap,strlen(sql)+1);
                 //make_select_count (sql,charout);
                 //outfile << charout;
                 //outfile << endl ;
                 //outfile.close();

                 qry=NULL;
                 rc=NULL;
                 rs=NULL;
                 exec_status = 0; // OK;
           } else { exec_status = 1; // NOTFOUND;
               return soap_sender_fault(soap, "Connection, Query, Resultset objects not found", NULL);
                  }
          } else  {exec_status = 2; // NOQUERY;
               return soap_sender_fault(soap, "Query object not found", NULL);
                  }
         } else   {exec_status = 3; // NORESULT;
               return soap_sender_fault(soap, "Resultset object not found", NULL);
                  }
        } else {exec_status = 4; // NOCONNECT;
               return soap_sender_fault(soap, "Connection object not found", NULL);
                  }
  } else { exec_status = 5; // RETRY;
               return soap_sender_fault(soap, "Invalid Soap Header", NULL);
             
         }
                 
                 //soap = soap_copy(soap);
                 //soap_dealloc(soap,(void*)sql);
                 //soap_dealloc(soap,(void*)cn);
                 //soap_dealloc(soap,(void*)qn);
                 //soap_dealloc(soap,(void*)rn);
        
        return SOAP_OK;
         

   
        
}
int ns4__msdGetResultSet(struct soap *soap, char* conn_name, char* query_name, char* result_name, array &resset_out) //array &resset_out
{
  char* cn;
  char* qn;
  char* rn;
  cn = (char*)soap_malloc(soap, strlen(conn_name)+1);
  sprintf(cn, "%s",conn_name);
  qn = (char*)soap_malloc(soap, strlen(query_name)+1);
  sprintf(qn, "%s",query_name);
  rn = (char*)soap_malloc(soap, strlen(result_name)+1);
  sprintf(rn, "%s",result_name);
  
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->lookup(CONNECT, cn);
    if (soap->header->h__handle){
          t__connect * rc =connector->connect(soap->header->h__handle);
          soap->header->h__handle = connector->lookup(RESULTSET, rn);
          if (soap->header->h__handle){
           t__resultset* rs = connector->resultset(soap->header->h__handle);
           soap->header->h__handle = connector->lookup(QUERY, qn);
          if (soap->header->h__handle){
           t__query *qry = connector->query(soap->header->h__handle);
           
           if (qry && rc && rs)
       { if (!qry->exf ==1)
         {return soap_sender_fault(soap, "Query not executed, no result available.", NULL);
         } else{
                 resset_out.__ptr=rs->prs;
                 resset_out.__size=rs->cols;
                 //resset_out.rs.prs=rs->prs;
                 
                 //--resset_out.cols=rs->cols;
                 //--resset_out.rows=rs->rows;
                 
                 //resset_out.rs.r.__ptr = rs->r.__ptr;
         //resset_out.rs.r.__size = rs->cols;
                 
                 //--resset_out.r.__ptr = rs->prs;
         //--resset_out.r.__size = rs->cols;
                 
                 qry=NULL;
                 rc=NULL;
                 rs=NULL;
                 //resset_out.exec_status = 0;
                 }
           } else { //resset_out.exec_status = 1;
               return soap_sender_fault(soap, "Connection, Query, Resultset objects not found", NULL);
                  }
          } else  { //resset_out.exec_status = 2;
               return soap_sender_fault(soap, "Query object not found", NULL);
                  }
         } else   { //resset_out.exec_status = 3;
               return soap_sender_fault(soap, "Resultset object not found", NULL);
                  }
        } else { //resset_out.exec_status = 4;
               return soap_sender_fault(soap, "Connection object not found", NULL);
                  }
  } else { //resset_out.exec_status = 1;
               return soap_sender_fault(soap, "Invalid Soap Header", NULL);
             
         }

                 //soap_dealloc(soap,(void*)cn);
                 //soap_dealloc(soap,(void*)qn);
                 //soap_dealloc(soap,(void*)rn);
                
                
  return SOAP_OK;
}

int ns4__msdGetResult(struct soap *soap, char* conn_name, char* query_name, char* result_name, ns4__msdGetResultResponse &res_out) //array &res_out
{
  char* cn;
  char* qn;
  char* rn;
  cn = (char*)soap_malloc(soap, strlen(conn_name)+1);
  sprintf(cn, "%s",conn_name);
  qn = (char*)soap_malloc(soap, strlen(query_name)+1);
  sprintf(qn, "%s",query_name);
  rn = (char*)soap_malloc(soap, strlen(result_name)+1);
  sprintf(rn, "%s",result_name);
  
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->lookup(CONNECT, cn);
    if (soap->header->h__handle){
          t__connect * rc =connector->connect(soap->header->h__handle);
          soap->header->h__handle = connector->lookup(RESULTSET, rn);
          if (soap->header->h__handle){
           t__resultset* rs = connector->resultset(soap->header->h__handle);
           soap->header->h__handle = connector->lookup(QUERY, qn);
          if (soap->header->h__handle){
           t__query *qry = connector->query(soap->header->h__handle);
           
           if (qry && rc && rs)
       { if (!qry->exf ==1)
         {return soap_sender_fault(soap, "Query not executed, no result available.", NULL);
         } else{
                 //res_out.__ptr=rs->prs;
                 //res_out.__size=rs->cols;
                 //res_out.rs.prs=rs->prs;
                 res_out.rs.cols=rs->cols;
                 res_out.rs.rows=rs->rows;
                 
                 //res_out.rs.r.__ptr = rs->r.__ptr;
         //res_out.rs.r.__size = rs->cols;
                 
                 res_out.rs.r.__ptr = rs->prs;
         res_out.rs.r.__size = rs->cols;
                 
                 qry=NULL;
                 rc=NULL;
                 rs=NULL;
                 //res_out.exec_status = 0;
                 }
           } else { //res_out.exec_status = 1;
               return soap_sender_fault(soap, "Connection, Query, Resultset objects not found", NULL);
                  }
          } else  { //res_out.exec_status = 2;
               return soap_sender_fault(soap, "Query object not found", NULL);
                  }
         } else   { //res_out.exec_status = 3;
               return soap_sender_fault(soap, "Resultset object not found", NULL);
                  }
        } else { //res_out.exec_status = 4;
               return soap_sender_fault(soap, "Connection object not found", NULL);
                  }
  } else { //res_out.exec_status = 1;
               return soap_sender_fault(soap, "Invalid Soap Header", NULL);
             
         }

                 //soap_dealloc(soap,(void*)cn);
                 //soap_dealloc(soap,(void*)qn);
                 //soap_dealloc(soap,(void*)rn);
                
                
  return SOAP_OK;
}


int ns4__msdEndQueryPack(struct soap *soap, char* query_name, char* result_name, int &endqp_out)
{ char* qn;
  char* rn;
  qn = (char*)soap_malloc(soap, strlen(query_name)+1);
  sprintf(qn, "%s",query_name);
  rn = (char*)soap_malloc(soap, strlen(result_name)+1);
  sprintf(rn, "%s",result_name);
  
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { //soap->header->h__handle = connector->lookup(CONNECT, cn);
    //if (soap->header->h__handle){
        // connector->release(soap->header->h__handle);
          soap->header->h__handle = connector->lookup(RESULTSET, rn);
          if (soap->header->h__handle){
           t__resultset* rs = connector->resultset(soap->header->h__handle);
                if (rs && rs->hasdata==1)
                {for (int n=0;n<rs->cols;++n){
                  for (int i=0;i<rs->rows ;++i){
                        if ((*rs->prs[n])[i])
                        {delete (*rs->prs[n])[i];
                        }
                        
                  }//end for
                  if (rs->prs[n])
                   {soap_delete(soap, (void*)rs->prs[n]);}
                 } //end for
                }
                
           connector->release(soap->header->h__handle);
           soap->header->h__handle = connector->lookup(QUERY, qn);
          if (soap->header->h__handle){
                  
           connector->release(soap->header->h__handle);
           rs=NULL;
           endqp_out = 0; // OK;
          } else  { endqp_out = 1; // NOQUERY;
               return soap_sender_fault(soap, "Query object not found", NULL);
                  }
         } else   { endqp_out = 2; // NORESULT;
               return soap_sender_fault(soap, "Resultset object not found", NULL);
                  }
        //} else { endqp_out = 3; // NOCONNECT;
        //       return soap_sender_fault(soap, "Connection object not found", NULL);
        //          }
  } else { endqp_out = 4; // RETRY;
               return soap_sender_fault(soap, "Invalid Soap Header", NULL);
             
         }
                  
                 
                  //soap_dealloc(soap,(void*)cn);
                  //soap_dealloc(soap,(void*)qn);
                  //soap_dealloc(soap,(void*)rn);
  return SOAP_OK;
}


int ns4__msdEndConnect(struct soap *soap, char* conn_name, int &endc_out)
{ char* cn;
  cn = (char*)soap_malloc(soap, strlen(conn_name)+1);
  sprintf(cn, "%s",conn_name);
 
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->lookup(CONNECT, cn);
    if (soap->header->h__handle){
        connector->release(soap->header->h__handle);
        } else { endc_out = 3; // NOCONNECT;
               return soap_sender_fault(soap, "Connection object not found", NULL);
                  }
  } else { endc_out = 4; // RETRY;
               return soap_sender_fault(soap, "Invalid Soap Header", NULL);
         }
  return SOAP_OK;
}

int ns4__msdEndSession(struct soap *soap, char* sessionid, int &ends_out){
 extern msdUser supervisor_user;
  char* host = (char*)soap_malloc(soap,81);
  char* usern = (char*)soap_malloc(soap,81);
  char* pass = (char*)soap_malloc(soap,81);
  sprintf(host,"%s",supervisor_user.host);
  sprintf(usern,"%s", supervisor_user.dbuname);
  sprintf(pass,"%s", supervisor_user.getDBPass());
 char* loginstr = (char*)soap_malloc(soap,256);
 char* sqldel = (char*)soap_malloc(soap,512);
 sprintf(sqldel, "delete from ssm_out_tab where session_id = '%s'", sessionid);
 sprintf(loginstr,"%s/%s@%s",usern,pass,host);
 msdbConnect db;
 msdbConnect::msdbInit();
 try{
  db.rlogon(loginstr); // connect to Oracle
  otl_cursor::direct_exec
   (db,sqldel,msdbException::disabled); // delete session rows from ssm_out_table
 }
 catch(msdbException& p){ // intercept OTL exceptions
  cerr<<p.msg<<endl; // print out error message
  cerr<<p.stm_text<<endl; // print out SQL that caused the error
  cerr<<p.var_info<<endl; // print out the variable that caused the error
  return msd_sender_exception(soap,db,p);
 }
 db.logoff(); // disconnect from Oracle
 return SOAP_OK;
}
int ns4__msdQuery(struct soap *soap, char* conn_name, char* query_name, char* result_name, char* stm, int &q_status)
{ char* cn;
  char* qn;
  char* rn;
  char* qr;
  char errmess[512];
  cn = (char*)soap_malloc(soap, strlen(conn_name)+1);
  //strcpy(cn, conn_name);
  sprintf(cn, "%s",conn_name);
  qn = (char*)soap_malloc(soap, strlen(query_name)+1);
  //strcpy(qn, query_name);
  sprintf(qn, "%s",query_name);
  rn = (char*)soap_malloc(soap, strlen(result_name)+1);
  //strcpy(rn, result_name);
  sprintf(rn, "%s",result_name);
  qr = (char*)soap_malloc(soap, strlen(stm)+1);
  //strcpy(qr, stm);
  sprintf(qr, "%s",stm);
  
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  { soap->header->h__handle = connector->lookup(CONNECT, cn);
    if (soap->header->h__handle){
          t__connect * rc =connector->connect(soap->header->h__handle);
          soap->header->h__handle = connector->lookup(RESULTSET, rn);
          if (soap->header->h__handle){
           t__resultset* rs = connector->resultset(soap->header->h__handle);
           soap->header->h__handle = connector->lookup(QUERY, qn);
       if (soap->header->h__handle){
                sprintf(errmess,"A Query Object with name: %s already exists.", qn);
                return soap_sender_fault(soap, errmess, NULL);
           }
           soap->header->h__handle = connector->create(soap, QUERY, qn);
          if (soap->header->h__handle){
           t__query *qry = connector->query(soap->header->h__handle);
           if (qry && rc && rs)
       {qry->set(rc,rs,qr);
            qry->exf=0;
            qry=NULL;
        rc=NULL;
        rs=NULL;
        q_status = 0; // OK;
           } else 
                   {  q_status = 1; // INVALID;
                  return soap_sender_fault(soap, "Invalid query Object.", NULL);
                } 
          } else {  q_status = 2; // NOTFOUND;
                  return soap_sender_fault(soap, "Query Object not created.", NULL);
                } 
         } else { q_status = 3; // NORESULT;
                  return soap_sender_fault(soap, "Result Object not found.", NULL);
                } 
                 
        } else { q_status = 4; // NOCONNECT;
                 return soap_sender_fault(soap, "Connect Object not found.", NULL);
                } 
                
  } else { q_status = 5; // RETRY;
               return soap_sender_fault(soap, "Invalid Soap Header", NULL);
         } 
          
   //soap_dealloc(soap,(void*)cn);
   //soap_dealloc(soap,(void*)qn);
   //soap_dealloc(soap,(void*)rn);
   //soap_dealloc(soap,(void*)qr);
  
  return SOAP_OK;
}




int ns4__msdResultset(struct soap *soap, char* conn_name, char* query_name, char* res_name, int &rs_status)
{ char* cn;
  char* qn;
  char* rn;
  char errmess[512];
  cn = (char*)soap_malloc(soap, strlen(conn_name)+1);
  //strcpy(cn, conn_name);
  sprintf(cn, "%s",conn_name);
  qn = (char*)soap_malloc(soap, strlen(query_name)+1);
  //strcpy(qn, query_name);
  sprintf(qn, "%s",query_name);
  rn = (char*)soap_malloc(soap, strlen(res_name)+1);
  //strcpy(rn, res_name);
  sprintf(rn, "%s",res_name);
  
  MSDConnector *connector = (MSDConnector*)soap->user;  // get connector from gSOAP environment
  if (!soap->header)
    soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
  if (soap->header)
  {soap->header->h__handle = connector->lookup(CONNECT, cn);
    if (soap->header->h__handle){
        t__connect * rc =connector->connect(soap->header->h__handle);
    soap->header->h__handle = connector->lookup(RESULTSET, rn);
       if (soap->header->h__handle){
                sprintf(errmess,"A Result Object with name: %s already exists.", rn);
                return soap_sender_fault(soap, errmess, NULL);
        }
        soap->header->h__handle = connector->create(soap, RESULTSET, rn);
     if (soap->header->h__handle){
      t__resultset * rs = connector->resultset(soap->header->h__handle);
          if (rs && rc)
          {rs->set(rc, qn);
           rs->hasdata=0; 
           rc=NULL;
           rs=NULL;
           rs_status = 0; // OK; 
          } else {  rs_status = 2; // INVALID;
                  return soap_sender_fault(soap, "Invalid Result object.", NULL);
                } 
         } else { rs_status = 3; // NORESULT;
                  return soap_sender_fault(soap, "Result Object not found.", NULL);
                } 
                 
        } else { rs_status = 4; // NOCONNECT;
                 return soap_sender_fault(soap, "Connect Object not found.", NULL);
                } 
                
  } else { rs_status = 5; // RETRY;
               return soap_sender_fault(soap, "Invalid Soap Header", NULL);
         } 
  //soap_dealloc(soap,(void*)cn);
  //soap_dealloc(soap,(void*)qn);
  //soap_dealloc(soap,(void*)rn);
 
 return SOAP_OK;
}



int ns4__msdLispInit(struct soap *soap, int argc, char* argv[], int &lispinit_result){
 lispinit_result = msd_lisp_init(argc, argv);      
 return SOAP_OK;
 }              


int ns4__msdLispLoad(struct soap *soap, char * fn, int &lispload_result){
 lispload_result = msd_lisp_load(fn);      
 return SOAP_OK;
 }              


int ns4__msdLispEval(struct soap *soap, int &lispeval_result){
 lispeval_result = msd_lisp_eval(); 
return SOAP_OK;
 }              


int ns4__msdWriteTableAtts(struct soap *soap, char* schema, char* connstr, char* fname, int &wta_result){
 wta_result = msd_write_table_attributes(schema,connstr, fname);      
 return SOAP_OK;
 }              


int ns4__msdGetTablesRelations(struct soap *soap, char* schema, char* connstr, int &gtr_result){
 gtr_result = msd_get_tables_relations(schema,connstr);      
 return SOAP_OK;
 }              

int ns4__msdGetDatamodel(struct soap *soap, char* schema, char* connstr, int &gdm_result){
 gdm_result = msd_get_datamodel(schema,connstr);      
 return SOAP_OK;
 }          


 
int ns4__echoMap(struct soap *soap, struct a__Map inputMap, struct a__Map & _return )
{ _return = inputMap;
  return SOAP_OK;
}

int ns4__echoMapArray(struct soap *soap, struct ArrayOfMap inputMapArray, struct ArrayOfMap & returns)
{ returns = inputMapArray;
  //_return.__ptr = inputMapArray.__ptr;
  //_return.__size = inputMapArray.__size;
  return SOAP_OK;
}



int ns4__msdSSM(struct soap *soap,int numofpars, array *inparams, int &res_ssm){

char* xmlstr = (char*)soap_malloc(soap,4096);
char* xmlstrn = (char*)soap_malloc(soap,4096);
char* infname = (char*)soap_malloc(soap,256);
char* outfname = (char*)soap_malloc(soap,256);

if (inparams)
{   inparams->__size=numofpars;
        if (!(*inparams)[0])
     {return soap_sender_fault(soap, "Missing or bad first argument, which  should be XML query.", NULL);
         }
  if (!(*inparams)[1])
     {return soap_sender_fault(soap, "Missing second argument, which should be session number.", NULL);
         }
} else 
{return soap_sender_fault(soap, "Invalid Array of arguments.", NULL);
}


sprintf(xmlstr,"%s",(*inparams)[0]->__item);

 
char * pch;
  pch = strtok (xmlstr,">");
  sprintf (xmlstrn,"%s", "");
  while (pch != NULL){
        //int i=1;
    if (pch[0]==' ' || pch[0]=='\n')
    { while (pch[0]==' ' || pch[0]=='\n'){ 
           pch++;
      }
          sprintf (xmlstrn,"%s%s>",xmlstrn, pch);
    }else{
        sprintf (xmlstrn,"%s%s>",xmlstrn, pch);}
        pch = strtok (NULL, ">");
  }
  sprintf (xmlstr, "%s",xmlstrn);
  pch = strtok (xmlstr,">");
  sprintf (xmlstrn,"%s", "");
  while (pch != NULL)
  { if (pch[0]=='<' )
    {sprintf (xmlstrn,"%s\n%s>",xmlstrn, pch);
    }else{
        sprintf (xmlstrn,"%s%s>",xmlstrn, pch);}
        pch = strtok (NULL, ">\n");
  }
sprintf (xmlstrn,"%s\n",xmlstrn);

// if (!(*inparams)[1]->__item)
//{return soap_sender_fault(soap, "second argument should be session number.", NULL);
        //return SOAP_FAULT;
//}

sprintf(infname,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_in.xml",(*inparams)[1]->__item);
 FILE * pfile;
 if (fileexists(infname)== true)
 { res_ssm = 4; //Invalid session number 
         return soap_sender_fault(soap, "Invalid session number, Session already exists.",
                 "<error xmlns=\"http://tempuri.org/\">Session already exists.</error>");
         //return SOAP_FAULT;
         //cerr << "Invalid session number, Session already exists. " << (*inparams)[1]->__item  << endl;
  //exit(1);
 }
 pfile = fopen (infname,"w+t");
   if (pfile==NULL)
   {res_ssm = 3; // could not create input file
           return soap_sender_fault(soap, "error: could not create input file. " , NULL);
           //cerr << "error: could not create " << infname  << endl;
    //exit(1);
        }
 fwrite (xmlstrn , 1 , strlen(xmlstrn), pfile);
 fclose (pfile);
 pfile=NULL;
 sprintf(outfname,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.xml",(*inparams)[1]->__item);
 char* buff;
 char* syscall;
  size_t buffsize=0;
 //char* rm;
 //rm = (char*)soap_malloc(soap,64);
 //sprintf(rm, "rm -f %s" , outfname);
 //if (fileexists(outfname))
 //{ res_ssm = system(rm);
 //  if (res_ssm < 0){
 //      res_ssm = errno;         
 //  }
 //}
 char ** tmp = (char**)soap_malloc(soap,5*256);
 for (int i=0;i<5 ;i++ ){
 tmp[i]= (char*)soap_malloc(soap,256);
 } 
 sprintf(tmp[0],"%s","/ebi/msd/ssm/cgi-bin/ssmserver -offline");
 sprintf(tmp[1],"%s",infname);
 sprintf(tmp[2],"%s",outfname);
 sprintf(tmp[3],"%s","/ebi/msd/ssm/ssmdata/ssm_sawebservice.conf");
 sprintf(tmp[4]," > /tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_ssmws.log", (*inparams)[1]->__item);
 buff=(char *)soap_malloc(soap, 5*(256+1));
 sprintf(buff,"%s",tmp[0]);
 for (int i=1;i<5 ;i++ )
 {sprintf(buff,"%s %s",buff,tmp[i]);
 }
 //for (int i = 0; i < 5; i++){
 //       delete tmp[i];
 //}
 syscall = (char*)soap_malloc(soap, strlen(buff)+1);
 sprintf(syscall,"%s", buff);
 pfile=fopen (infname,"rt");
 if (pfile)
 {fclose (pfile);
  pfile=NULL;
  res_ssm = system(syscall);
 }
 
 if (res_ssm < 0){
         res_ssm = errno;         
 }
 return SOAP_OK;
 }          

int ns4__msdSSMPurge(struct soap *soap,  char* sessionid, int &res_ssmpurge){
 char* syscall = (char*)soap_malloc(soap,512);
 sprintf(syscall, "rm -frR /tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_*", sessionid);
  res_ssmpurge = system(syscall);
  if (res_ssmpurge < 0){
         res_ssmpurge = errno;         
 }
return SOAP_OK;
}


int ns4__msdSSMParser(struct soap *soap, int diyf, char* sessionid, int &res_ssmparser){
 extern msdUser supervisor_user;
 char* xmlfn = (char*)soap_malloc(soap,256);
 char* session = (char*)soap_malloc(soap,64);
 char* db_server= (char*)soap_malloc(soap,81);
 char* loginstr = (char*)soap_malloc(soap,256);
 char* syscall = (char*)soap_malloc(soap,256);
 char* fname = (char*)soap_malloc(soap,512);
 char* ofname = (char*)soap_malloc(soap,512);
 char* typechecker = (char*)soap_malloc(soap,32);
 char* tmp = (char*)soap_malloc(soap,64);
 char* usern = (char*)soap_malloc(soap,81);
 char* pass = (char*)soap_malloc(soap,81);
 sprintf(db_server,"%s",supervisor_user.host);
 sprintf(usern,"%s", supervisor_user.dbuname);
 sprintf(pass,"%s", supervisor_user.getDBPass());
 
 sprintf(loginstr,"%s/%s@%s",usern,pass,db_server);
 sprintf(session,"%s",sessionid);
 ucase(usern);
 
 
 sprintf(xmlfn,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.xml",session);
 sprintf(fname,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_in.xml",session);
 sprintf(ofname,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_log.txt",session);
 char write_line[1024];
  char* stmnt = (char*)soap_malloc(soap,512);
  
  if (sessionid)
  { 
        int j=0;
        bool out_file_ok;
        if ((out_file_ok=fileexists(xmlfn)== false) && (diyf != 0))
    {res_ssmparser = 5; // file not ready yet
         return soap_sender_fault(soap, "Result fille not ready", NULL);
        }
        while(j<30*15) // up to 15 minutes wait for result
     { if (out_file_ok=fileexists(xmlfn)== true)
          {
            break;}else 
          {
                wait(5);
          } // wait 2 seconds and retry again
          j++;
     } // end while
        
    if (!out_file_ok){
      res_ssmparser =6; // file will not be ready in less than 15 minutes.
          return soap_sender_fault(soap, "XML SSM file will not be ready in less than 15 minutes.", NULL);}
 PCSSMXML SSMXML;
 char*  queryID = (char*)soap_malloc(soap,500);
 char*  targetID = (char*)soap_malloc(soap,500);
 char*  queryCh = (char*)soap_malloc(soap,10);
 char*  targetCh = (char*)soap_malloc(soap,10);
 mat44    RT;
 int      rc, nMatches;
 
 InitMatType();

 SSMXML = new CSSMXML();


 rc = SSMXML->readSSMXML ( xmlfn );
 
 if (rc) {
 res_ssmparser=rc;

 }

 nMatches = SSMXML->getNofMatches();
  sprintf (write_line, "  Total %i matches\n",nMatches );
  
  if (nMatches<=0){
          res_ssmparser=2;
         
          }
 
  char* insert_stm = (char*)soap_malloc(soap,4096);
  
  sprintf(stmnt, "insert into %s.ssm_out_tab values ('%s' ", usern, session); 
  
  rc = SSMXML->getQueryID ( queryID );
 
 char*  table_exists_stm = (char*)soap_malloc(soap,3072);
 int n;
 char* create_table_stm = (char*)soap_malloc(soap, 3072);
 sprintf(create_table_stm, "create table %s.ssm_out_tab(session_id varchar2(64), query_id varchar2(10), target_id  varchar2(10), query_chain varchar2(6), target_chain  varchar2(6),"
 "p_score number, z_score number, rmsd number, r_xx number, r_xy number, r_xz number, r_yx number, r_yy number, r_yz number, r_zx number, r_zy number, r_zz number,"
 "t_x number, t_y number, t_z number, pair_query_start varchar2(10), pair_query_end varchar2(10),pair_target_chain varchar2(6), pair_target_start varchar2(6), " 
 "pair_target_end varchar2(6),querydate varchar2(32) DEFAULT TO_CHAR(SYSDATE, 'MM-DD-YYYY HH24:MI:SS'))", usern);
 sprintf(table_exists_stm, "select count(*) " 
 "from all_objects o where o.object_name like 'SSM_OUT_TAB' and o.owner = '%s'", usern);
 msdbConnect db;
 msdbConnect::msdbInit(); // initialize OCI environment
 try{
  fprintf(stderr,loginstr);
  db.rlogon(loginstr); // connect to Oracle
 
 msdbStream i(1, table_exists_stm, db);
 i >> n;
 if (n==0)
 {otl_cursor::direct_exec(db,create_table_stm);  // create table
 }
 
  
 } //try
 catch(msdbException& p){ // intercept OTL exceptions
  cerr<<p.msg<<endl; // print out error message
  cerr<<p.stm_text<<endl; // print out SQL that caused the error
  cerr<<p.var_info<<endl; // print out the variable that caused the error
  //outfile <<p.msg<<endl; // print out error message                          
  //outfile <<p.stm_text<<endl; // print out SQL that caused the error         
  //outfile <<p.var_info<<endl; // print out the variable that caused the error
  return msd_sender_exception(soap,db,p);
 
 }
 if (rc==query_pdbentry)  {
          sprintf(stmnt, "%s, '%s'",stmnt,queryID);
         
          }
  else if (rc==query_file) {
          sprintf(stmnt, "%s, '%s'",stmnt,queryID);
         
          }
                      else {
                                                  sprintf(stmnt, "%s, NULL",stmnt);
                                                  
                                                  }
 
  for (int i=1;i<=nMatches;i++)  { //nMatches
    sprintf (insert_stm,"%s",stmnt);
   
    rc = SSMXML->getTargetID ( targetID,i );
    switch (rc)  {
      case target_pdbentry   :
        {
            sprintf(insert_stm, "%s, '%s'",insert_stm,targetID);
                
                }
                break;
      case target_file       :
        {
             sprintf(insert_stm, "%s, '%s'",insert_stm,targetID);
                 
                 } 
           break;
      case target_pdb        :
        {
            sprintf(insert_stm, "%s, '%s'",insert_stm,targetID);
                
                }
                break;
      case target_scop       :
        {
            sprintf(insert_stm, "%s, '%s'",insert_stm,targetID);
                
                }
                break;
      case target_scopsubset :
        {
            sprintf(insert_stm, "%s, '%s'",insert_stm,targetID);
                
                }
                break;
      default :
        {
                 sprintf(insert_stm, "%s, NULL",insert_stm);}
    } // end switch
    
    SSMXML->getQueryChain  ( queryCh ,i );
    SSMXML->getTargetChain ( targetCh,i );
    
    
        if (!queryCh || strlen(queryCh)==0 || queryCh==NULL)
     {sprintf(insert_stm, "%s, NULL",insert_stm);}
          else
         {sprintf(insert_stm, "%s, '%s'",insert_stm,queryCh);
          
          }
        if (!targetCh || strlen(targetCh)==0 || targetCh==NULL)
     {sprintf(insert_stm, "%s, NULL",insert_stm);}
          else
         {sprintf(insert_stm, "%s, '%s'",insert_stm,targetCh);
        
         }
        
        sprintf(typechecker,"%11.4f",SSMXML->getPScore(i));
        if (isnum(typechecker))
        {sprintf(insert_stm, "%s, %11.4f",insert_stm,SSMXML->getPScore(i));}
         else
                 {sprintf(insert_stm, "%s, NULL",insert_stm);
        }
    sprintf(typechecker,"%11.4f",SSMXML->getZScore(i));
        if (isnum(typechecker))
        {sprintf(insert_stm, "%s, %11.4f",insert_stm,SSMXML->getZScore(i));}
         else
                 {sprintf(insert_stm, "%s, NULL",insert_stm);
        }
        sprintf(typechecker,"%11.4f",SSMXML->getRMSD(i));
        if (isnum(typechecker))
        {sprintf(insert_stm, "%s, %11.4f",insert_stm,SSMXML->getRMSD(i));}
         else
                 {sprintf(insert_stm, "%s, NULL",insert_stm);
        }
        
        
        
    rc = SSMXML->getRTMatrix ( RT,i );
    if (rc)  {
   
          for (int x=0;x<3 ;x++ )
   {for (int y=0;y<4 ;y++ )
    {sprintf(insert_stm, "%s, NULL",insert_stm);}
   }
          sprintf(insert_stm, "%s )",insert_stm);
     
      break;
    }
    
   for (int x=0;x<3 ;x++ )
   {for (int y=0;y<4 ;y++ )
    {sprintf(insert_stm, "%s, %10.3f",insert_stm, RT[x][y]);}
   }
   sprintf(insert_stm, "%s, NULL, NULL, NULL, NULL, NULL, TO_CHAR(SYSDATE, 'MM-DD-YYYY HH24:MI:SS'))",insert_stm);
   
   //TO_DATE(TO_CHAR(SYSDATE, 'MM-DD-YYYY HH24:MI:SS'),'MM-DD-YYYY HH24:MI:SS')
   //~*******sprintf(insert_stm, "%s )",insert_stm);
   
   try
  {
        otl_cursor::direct_exec(db,insert_stm);
  }
   catch(msdbException& p){ // intercept OTL exceptions
   cerr<<p.msg<<endl; // print out error message
   cerr<<p.stm_text<<endl; // print out SQL that caused the error
   cerr<<p.var_info<<endl; // print out the variable that caused the error
   return msd_sender_exception(soap,db,p);
   //return soap_sender_fault(soap, p.stm_text , NULL);   
   //outfile <<p.msg<<endl; // print out error message                          
   //outfile <<p.stm_text<<endl; // print out SQL that caused the error         
   //outfile <<p.var_info<<endl; // print out the variable that caused the error
  }

  } // for loop
 
 
  db.logoff(); // disconnect from Oracle 

  sprintf(syscall, "rm -f %s %s", fname,xmlfn);
  res_ssmparser = system(syscall); // syscall to delete files 
  if (res_ssmparser < 0){
          res_ssmparser = errno;
  }else{
          res_ssmparser=0;
  }
  
  
  
  //msdbStream o(50, // buffer size
  //            "insert into test_tab values(12345678900000000+:f1<int>,:f11<int>,:f2<char[31]>, SYSDATE)", 
  //               // SQL statement
  //            db // connect object
  //           );

      
  }
  else{
          res_ssmparser = 3;
    return soap_sender_fault(soap, "session id required", NULL); 
  }
  return SOAP_OK;
}




          


int ns4__msdAppServer(struct soap *soap, int numofpars, array *inparams,  int &res_appserver){
 inparams->__size=numofpars;
 size_t buffsize=0;
 char* syscall;
 char * buff;
 for (int i=0;i<numofpars ;i++ )
 {buffsize = buffsize + strlen((*inparams)[i]->__item)+1;
 }
 buff=(char *)soap_malloc(soap, buffsize);
 sprintf(buff,"%s",(*inparams)[0]->__item);
 for (int i=1;i<numofpars ;i++ )
 {sprintf(buff,"%s %s",buff,(*inparams)[i]->__item);
 }
 syscall = (char*)soap_malloc(soap, strlen(buff)+1);
 sprintf(syscall,"%s", buff);
 res_appserver = system(syscall); // syscall
 if (res_appserver < 0)
 {res_appserver = errno;
 }
  return SOAP_OK;
}       

int ns4__msdFasta(struct soap *soap, int numofpars, array *inparams,  int &res_fasta){
char* xmlstr=(char*)soap_malloc(soap,4096); //4096
char* infname=(char*)soap_malloc(soap,256);
char* sessionid=(char*)soap_malloc(soap,64);
char* outfname=(char*)soap_malloc(soap,256);
char* sequence=(char*)soap_malloc(soap,3072);
char* evalue=(char*)soap_malloc(soap,256);
char* xmlstrn=(char*)soap_malloc(soap,4096);
char* libref=(char*)soap_malloc(soap,8);
char* library=(char*)soap_malloc(soap,256);

// char* xmlstr=new char[4096];
// char* infname=new char[256];
// char* sessionid=new char[64];
// char* outfname=new char[256];
// char* sequence=new char[3072];
// char* evalue=new char[256];
// char* xmlstrn=new char[4096];
// char* libref=new char[8];
// char* library=new char[256];
// 
 inparams->__size=numofpars;
 size_t buffsize=0;
 sprintf(xmlstr,"%s",(*inparams)[0]->__item);

 xml_Buff=(char*)soap_malloc(soap,strlen(xmlstr)+1);
 sprintf(xml_Buff,"%s",xmlstr);
 sprintf(sessionid,"%s",(*inparams)[1]->__item);
 sprintf(infname,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_in.fasta",sessionid);
 sprintf(outfname,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.fasta",sessionid);
 
 xml_inf = (msd_xml_element *) soap_malloc(soap, sizeof(msd_xml_element)*10);
 xml_txtbuff = (char*)soap_malloc(soap, 3072);
 
    
 
 XML_Parser xp = XML_ParserCreate(NULL);
 XML_Parser * pxp;
  if (! xp) {
    fprintf(stderr, "Couldn't allocate memory for parser\n");
    exit(-1);
  } else {
   pxp=(XML_Parser *)soap_malloc(soap, sizeof(XML_Parser));
   pxp=&xp;
  }
 

  
  XML_UseParserAsHandlerArg(*pxp);
  //XML_SetUserData(*pxp, soap);
  XML_SetElementHandler(*pxp, start_hndl, end_hndl);
  XML_SetCharacterDataHandler(*pxp, char_hndl);
  XML_SetProcessingInstructionHandler(*pxp, proc_hndl);
if (! XML_Parse(*pxp, xml_Buff, strlen(xml_Buff), true)) {
        fprintf(stderr, "Parse error at line %d:\n%s\n",
              XML_GetCurrentLineNumber(*pxp),
              XML_ErrorString(XML_GetErrorCode(*pxp)));
      exit(-1);
    }
        
        XML_ParserFree(xp);
        
for (int i=0;i<=xml_elno ;i++ ){
        if (strcmp(xml_inf[i].tag,"evalue")==0)
        {sprintf(evalue,"%s",xml_inf[i].data);}else if (strcmp(xml_inf[i].tag,"sequence")==0)
        {removena(xml_inf[i].data);
         sprintf(sequence,">Q\n%s\n",xml_inf[i].data);}else if (strcmp(xml_inf[i].tag,"library")==0)
        {sprintf(libref,"%s",xml_inf[i].data);}
} //end for



FILE * pfile;
 pfile = fopen (infname,"w+t");
   if (pfile==NULL)
   {cerr << "error: could not create " << infname  << endl;
    exit(1);}
 fwrite (sequence , 1 , strlen(sequence), pfile);
 

fclose (pfile);
pfile=NULL; 




lcase(libref);
if (strcmp(libref, "pdb")==0) // strcmp((*inparams)[3]->__item 
{sprintf(library,"/ebi/msd/ssm/cgi-bin/ws/fasta/pdb_aa.fasta"); // /ebi/ftp/pub/databases/msd/pdb_aa.fasta
} 
 xml_elno = -1;
 char* buff;
 char* syscall;
 
 

 int noarr = 8;
 char ** tmp = (char**)soap_malloc(soap,noarr*256);
 for (int i=0;i<noarr ;i++ ){
 tmp[i]= (char*)soap_malloc(soap,256);
 } 
 sprintf(tmp[0],"%s","bsub -q extsrv_interactive -R msd_ssm -o");
 sprintf(tmp[1],"%s",outfname);
 sprintf(tmp[2],"%s","/ebi/msd/ssm/cgi-bin/ws/fasta/bin/fasta -Q -H -E ");
 sprintf(tmp[3],"%s",evalue);
 sprintf(tmp[4],"%s",infname);
 sprintf(tmp[5],"%s",library);
 sprintf(tmp[6],"%s",">");
 sprintf(tmp[7],"%s",outfname);

 buff=(char *)soap_malloc(soap, noarr*(256+1));
 sprintf(buff,"%s",tmp[0]);
 for (int i=1;i<noarr ;i++ )
 {sprintf(buff,"%s %s",buff,tmp[i]);
  //soap_dealloc(soap, (void*)tmp[i]);
  //soap_unlink(soap, (void*)tmp[i]);
 }
 

 sprintf(buff,"%s",tmp[0]);
 for (int i=1;i<noarr ;i++ ) 
 {sprintf(buff,"%s %s",buff,tmp[i]);
 }
 


 syscall = (char*)soap_malloc(soap, strlen(buff)+1);
 sprintf(syscall,"%s", buff);
 
 


 
 pfile=fopen (infname,"r+t");
 if (pfile)
 { //fwrite (syscall, 1 , strlen(syscall), pfile);
  fclose (pfile);
  pfile=NULL;
 
  res_fasta = system(syscall);
  
 
 } 
 
  
  if (res_fasta < 0)
  {res_fasta = errno;         
  }


 
// soap_dealloc(soap, (void*)xmlstr);
// soap_dealloc(soap, (void*)xmlstrn);
// soap_dealloc(soap, (void*)xml_Buff);
// soap_dealloc(soap, (void*)xml_txtbuff);
// soap_dealloc(soap, (void*)buff);
// soap_dealloc(soap, (void*)syscall);
// soap_dealloc(soap, (void*)sequence);
// 
// soap_delete(soap, (void*)xmlstr);
// soap_delete(soap, (void*)xmlstrn);
// soap_delete(soap, (void*)xml_Buff);
// soap_delete(soap, (void*)xml_txtbuff);
// soap_delete(soap, (void*)buff);
// soap_delete(soap, (void*)syscall);
// soap_delete(soap, (void*)sequence);
// 
// soap_unlink(soap, (void*)xmlstr);
// soap_unlink(soap, (void*)xmlstrn);
// soap_unlink(soap, (void*)xml_Buff);
// soap_unlink(soap, (void*)xml_txtbuff);
// soap_unlink(soap, (void*)buff);
// soap_unlink(soap, (void*)syscall);
// soap_unlink(soap, (void*)sequence);
// 
//delete xmlstr;  
//delete infname;  
//delete sessionid; 
//delete outfname; 
//delete sequence;
//delete evalue;   
//delete xmlstrn; 
//delete libref;     
//delete library;  





 return SOAP_OK;
}       

int ns4__msdFastaParser(struct soap *soap, char* sessionid, int &res_fastaparser){
 char* fastafn = (char*)soap_malloc(soap,256);
 char* loginstr = (char*)soap_malloc(soap,256);
 char* db_server = (char*)soap_malloc(soap,81);
 char* fasta_parser = (char*)soap_malloc(soap,256);
 char* syscall = (char*)soap_malloc(soap,256);
 char* session_id =(char*)soap_malloc(soap, strlen(sessionid)+1);
 extern msdUser supervisor_user;
 char* usern = (char*)soap_malloc(soap,81);
 char* pass = (char*)soap_malloc(soap,81);
 sprintf(db_server,"%s",supervisor_user.host);
 sprintf(usern,"%s", supervisor_user.dbuname);
 sprintf(pass,"%s", supervisor_user.getDBPass());
 sprintf(loginstr,"%s/%s@%s",usern,pass,db_server);
 strcpy(session_id,sessionid);
 ucase(usern);

 sprintf(fastafn,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_out.fasta",session_id);
 sprintf(fasta_parser,"/tmp_mnt/net_nfs5/vol4/research-thornton/ssmout/%s_in.fasta",session_id);
 char* read_line = (char*)soap_malloc(soap,1024);
 char* stmnt = (char*)soap_malloc(soap,256);
  int j=0;
  //wait(5);
  while(!lsf_file_completed(fastafn) && j<12*15) // fileexists --- up to 15 minutes wait for result
  { wait(5); // wait 5 seconds and retry again
        j++;
  } // end while
  
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    ifstream infile;
        infile.open(fastafn);
        //ofstream outfile;
        //outfile.open(fasta_parser);
        
        char * search = ">>";
        char * replace = "Record No.";
        char * linebuf = (char*)soap_malloc(soap,256);
        char * tempbuf = (char*)soap_malloc(soap,256);
        char * lastTok = (char*)soap_malloc(soap,256);
        char * record = (char*)soap_malloc(soap,7000);
    char * tmprec = (char*)soap_malloc(soap,7000);
    char * evalue_result = (char*)soap_malloc(soap,16);
        char * id_chain = (char*)soap_malloc(soap,16);
        char * id = (char*)soap_malloc(soap,12);
        char * chain = (char*)soap_malloc(soap,4);
        char * alignment = (char*)soap_malloc(soap,6000);
        char*  midbuf = (char*)soap_malloc(soap,12);
        char* tmp = (char*)soap_malloc(soap,16);
        char * outBuf = (char*)soap_malloc(soap,6000);
        // char tokbuf[100]= "";
    char * pchs;
        char * pche;
        //char * pche;
        char * per;
        char * tok;
        char * pid;
        char * pch;
        char * token = (char*)soap_malloc(soap,16);
        int start,end,len,newrecord,recno;
        newrecord=0;
        char* insert_stm = (char*)soap_malloc(soap,4096);
    sprintf(stmnt, "insert into fasta_out_tab values ('%s' ", session_id);   
        char* table_exists_stm = (char*)soap_malloc(soap,3072);
 int n;
 char* create_table_stm = (char*)soap_malloc(soap, 3072);
 sprintf(create_table_stm, "create table %s.fasta_out_tab(session_id varchar2(64), e_value_result varchar2(16), lib_id_and_chain varchar2(16), lib_id varchar2(12), chain  varchar2(4),"
 "alignment blob, querydate varchar2(32) DEFAULT TO_CHAR(SYSDATE, 'MM-DD-YYYY HH24:MI:SS'))", usern);
 sprintf(table_exists_stm, "select count(*) " 
 "from all_objects o where o.object_name like 'FASTA_OUT_TAB' and o.owner = '%s'", usern);
 msdbConnect db;
 msdbConnect::msdbInit(); // initialize OCI environment
 try{
  db.rlogon(loginstr); // connect to Oracle
 // otl_cursor::direct_exec(db,"drop table ssm_out_tab",
 //   msdbException::disabled // disable OTL exceptions
 //  ); // drop table
 
 otl_long_string alignment_blob(6000); // define long string variable for blob
 db.set_max_long_size(6000); // set maximum long string size for connect object
 msdbStream i(1, table_exists_stm, db);
 i >> n;
 if (n==0)
 {otl_cursor::direct_exec(db,create_table_stm);  // create table
 }
 //otl_cursor::direct_exec(db,insert_stm);
 //} //------------> try
// catch(msdbException& p){ // intercept OTL exceptions
//  cerr<<p.msg<<endl; // print out error message
//  cerr<<p.stm_text<<endl; // print out SQL that caused the error
//  cerr<<p.var_info<<endl; // print out the variable that caused the error
// }
        
 
 msdbStream o(1, // buffer size has to be set to 1 for operations with LOBs
 "insert into fasta_out_tab values(:session_id<char[64]>,:e_value_result<char[16]>,:lib_id_and_chain<char[16]>, "
 ":lib_id<char[12]>,:chain<char[4]>,empty_blob(),TO_CHAR(SYSDATE, 'MM-DD-YYYY HH24:MI:SS')) returning alignment into :alignment<blob> ",
 db );  
 recno=0;
        do {      //newrecord=0;
                      infile.getline(linebuf, 256);
                      if(linebuf != NULL)
                                { strcpy(tempbuf, linebuf);
                                  pchs = strstr (tempbuf, ">>");
                                  pche = strstr (tempbuf, "Library scan:");
                  if ((pchs != NULL) || (newrecord == 1) || (pche != NULL))
                    {   
                                          sprintf(record,"%s%s\n",record, linebuf);
                                          do {
                                                 infile.getline(linebuf, 256);
                                                 if(linebuf != NULL)
                                          {strcpy(tempbuf, linebuf);
                                                   pchs = strstr (tempbuf, ">>");
                                                   pche = strstr (tempbuf, "Library scan:");
                                                   if ((pchs == NULL) && (pche == NULL)){
                                                    sprintf(record,"%s%s\n",record, linebuf);
                                                        }else{
                                                                //recore has been completed and should be processed

                                                                sprintf(tmprec,"%s",record);
                                                    per = strstr (tmprec,":");
                                                tok = strtok (tmprec," ");
                                                sprintf(token,"%s", tok);
                                len=strlen(token);
                                                    start=per-tok+1;
                                                    end=len;
                                                    midcopy(token,midbuf,start,end);
                                                    sprintf(id_chain,"%s",midbuf);
                                                                sprintf(tmp,"%s",id_chain);
                                                                pid = strtok (tmp,"_");
                                                                sprintf(id,"%s",pid);
                                                                start=strlen(id)+1;
                                                                end=strlen(id_chain);
                                                                if (start != end)
                                                                {midcopy(id_chain,chain,start,end);
                                                                }else sprintf(chain,"%s","");
                                                                
                                                                sprintf(tmprec,"%s",record);
                                per = strstr (tmprec,"E():");
                                                                tok = strtok(per,"\n");
                                                                sprintf(token,"%s", tok);
                                                                start=per-tok+5;
                                                    end=strlen(token);
                                                                midcopy(token,midbuf,start,end);
                                                    sprintf(evalue_result,"%s",midbuf);
                                                                sprintf(tmprec,"%s",record);
                                                                per = strstr (tmprec,"Q   ");
                                                                sprintf(alignment,"%s",per-68);

//~~~~~~~~~                                      outfile << session_id <<endl;
//~~~~~~~~~                                      outfile << record <<endl;
//~~~~~~~~~                  outfile << id_chain <<endl;
//~~~~~~~~~                                      outfile << id <<endl;
//~~~~~~~~~                                      outfile << chain <<endl;
//~~~~~~~~~                                      outfile << evalue_result << endl;
//~~~~~~~~~                  outfile << alignment << endl;
//~~~~~~~~~                                      outfile << "Record finished~~~~~~~~" << endl;
                                         
                                         recno++;
                                         len=strlen(alignment);
                                         
                     for (int i=0;i< len ;i++ )
                     {alignment_blob[i] = alignment[i];
                     }
                                         alignment_blob.set_len(len+1); 
                                          o << session_id << evalue_result << id_chain << id << chain << alignment_blob;         
                                                                sprintf(record,"%s","");
                                                                sprintf(record,"%s\n", linebuf);
                                                                newrecord=1; // new record starts
                                                                //pchs=NULL;
                                                                } 
                                                  }
                                                 } while ((pchs == NULL) && !infile.eof() && (pche == NULL));
                                    }
                                  }
                        else linebuf[0] = '0';
                        
                 } while ( ! infile.eof());
 
 
//--- otl_long_string blob_result(4000); // define long string variable
//--- db.set_max_long_size(4000); // set maximum long string size for connect object
//---
//--- msdbStream si(10, // buffer size. To read BLOBs, it can be set to a size greater than 1
//---              "select alignment from fasta_out_tab",
//---                 // SELECT statement
//---              db // connect object
//---             ); 
//--- while(!si.eof()){ // while not end-of-data
//---  si>>blob_result;
//---  outfile <<"blob_result="<<blob_result[0]<<blob_result[blob_result.len()-1]<<", len="<<blob_result.len()<<endl;
//--- } // end while
 
 
 } // try
 catch(msdbException& p){ // intercept OTL exceptions
  cerr<<p.msg<<endl; // print out error message
  cerr<<p.stm_text<<endl; // print out SQL that caused the error
  cerr<<p.var_info<<endl; // print out the variable that caused the error
  return msd_sender_exception(soap,db,p);
//~~~~~~~  outfile <<p.msg<<endl; // print out error message
//~~~~~~~  outfile <<p.stm_text<<endl; // print out SQL that caused the error
//~~~~~~~  outfile <<p.var_info<<endl; // print out the variable that caused the error
 }
//~~~~~~~  outfile << "Total Records: " << recno <<endl;
    db.logoff();        
        infile.close();
        //~~~~~~~ outfile.close();
        sprintf(syscall, "rm -f %s %s", fasta_parser,fastafn);
    //res_fastaparser = system(syscall); // syscall
   if (res_fastaparser < 0){
          res_fastaparser = errno;
   }else{
          res_fastaparser=0;
   }

  return SOAP_OK;
}





//int ns__sqrt(struct soap *soap, double a, double &result);  
//{  
//   if (a > = 0)  
//   {  
//      result = sqrt(a);  
//      return SOAP_OK;  
//   }  
//   else 
//   {  
//      soap_fault(soap); 
//      soap->fault->faultstring = "Square root of negative number";  
//      soap->fault->detail = "I can only take the square root of a non-negative number";  
//      return SOAP_FAULT;  
//   }  
//}  
// As always, a namespace mapping table is needed:  

//struct Namespace namespaces[] =  
//{   // {"ns-prefix", "ns-name" [, "ns-pattern"]}  
//   {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"},  
//   {"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"},  
//   {"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance"},  
//   {"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema"},  
//   {"t", "urn:msd_soap_types"},
//   {"h", "urn:msd_soap_serviceHandles"},
//   {"ns", "urn:msd_soap_serviceService"},  
//   {NULL, NULL}  
//};
// In .wsdl file:
//  Replace       With  
//  %{Service}%   the file name of the CGI service application (without a file name extension)  
//  %{URL}%       the endpoint URL of the service (without the CGI file name)  
//  %{URI}%       the namespace URI of the service (can be the same as the URL)  
//
//  For Example: 
//  Replace       With  
//  %{Service}%   msd_soap_service  
//  %{URL}%       http://parrot.ebi.ac.uk:8099/ 
//  %{URI}%       http://parrot.ebi.ac.uk:8099/ 
//This information can also be provided in the header file which will then be automatically incorporated in the WSDL file, see advanced features Section 12.2. 
//
//In addition to the generation of the ns.wsdl file, a file with a namespace mapping table is generated by the gSOAP compiler. An example mapping table is shown below: 
//
//struct Namespace namespaces[] = 
//{ 
//   {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"}, 
//   {"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"}, 
//   {"xsi", "http://www.w3.org/2001/XMLSchema-instance", \"http://www.w3.org/*/XMLSchema-instance"}, 
//   {"xsd", "http://www.w3.org/2001/XMLSchema", \"http://www.w3.org/*/XMLSchema"}, 
//   {"ns", "%{URI}%"}, 
//   {NULL, NULL} 
//};  
//
//After replacing the %{}% patterns in the namespace mapping table file, this file can be incorporated in the client/service application.


//6.4  Using gSOAP for Creating Web Services and Clients in C
//The gSOAP compiler can be used to create C (instead of C++) Web services and clients. The gSOAP stub and skeleton compiler soapcpp2 generates .cpp files by default. However, these files only use C syntax and data types if the header file input to soapcpp2 uses C syntax and data types. Therefore, a C compiler can be used to compile the .cpp files (e.g. by renaming the extensions to .c) to create C Web service and client executables. For example, with symbolic links on Unix/Linux: 
//ln -s soapC.cpp soapC.c 
//ln -s soapClient.cpp soapClient.c 
//ln -s soapServer.cpp soapServer.c 
//soapcpp2 quote.h 
//gcc quote.c stdsoap2.c soapC.c soapClient.c  

//--int set_ld_lib_path (){
//--char * buffer;
//--   char * libenv;
//--   char * oldenv;
//--   char * newenv;
//--  buffer = getenv ("LD_LIBRARY_PATH");
//--  sprintf(oldenv , "LD_LIBRARY_PATH=%s", buffer);
//--  sprintf(libenv , "/sw/arch/dbtools/oracle/product/8.1.7/lib");
//--  
//--  if (strstr(buffer, libenv)==NULL)
//--  {
//--    sprintf(newenv , "LD_LIBRARY_PATH=%s%s",buffer,libenv);
//--    putenv (newenv);
//--   
//--  }
//--putenv (oldenv);
//--}


//---------int ns__servercookies(struct soap *soap, ...) 
//---------{ 
//---------   int n; 
//---------   const char *s; 
//---------   s = soap_cookie_value(soap, "session", NULL, NULL); // cookie returned by client? 
//---------   if (!s) 
//---------      s = "init-value"; // no: set initial cookie value 
//---------   else 
//---------      s =  "wbe-services-client";//... modify 's' to reflect session control 
//---------   soap_set_cookie(soap, "session", s, NULL, NULL); 
//---------   soap_set_cookie_expire(soap, "session", 5, NULL, NULL); // cookie may expire at client-side in 5 seconds 
//---------   return SOAP_OK; 
//---------} 

// Web service remote method implementation:

//~~~~~~~int ns__polytest(struct soap *soap, ns__Object *in, struct ns__polytestResponse &result)
//~~~~~~~{ result.out = in;
//~~~~~~~  return SOAP_OK;
//~~~~~~~}

   

---