mcs.hh

Go to the documentation of this file.

// ----------------------------------------------------------------------^
// Copyright (C) 2004 -- 2011, Giorgio Calderone
// (mailto: <gcalderone@ifc.inaf.it>)
// 
// This file is part of MCS.
// 
// MCS is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// MCS is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with MCS; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
// 
// ----------------------------------------------------------------------$



#ifndef DEF_MCS_HH
#define DEF_MCS_HH


//The symbol COMPILING_MCS is defined when we are compiling the MCS library
#undef COMPILING_MCS
#ifdef HAVE_CONFIG_H
  //We are compiling the MCS library
#define COMPILING_MCS
#else
  //We are compiling a MCS-based program
#endif //HAVE_CONFIG_H



//We need the following includes only when compiling the MCS library
#ifdef COMPILING_MCS
//--------------------------------------------------------------------
//System's library include

//Portability with old libc
// LN
#ifndef __APPLE__
#include <wait.h>
#endif

#include <sys/stat.h>
#include <math.h>
#include <stdint.h>
#include <stdarg.h>
#include <dirent.h>
#include <pthread.h>
#include <errno.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <fcntl.h>

//Portability with old libc
#include <unistd.h>

#include <fstream>
#endif  //COMPILING_MCS


//The following include is necessary for some network related type
#include <netinet/in.h>


//The following includes are probably needed by user programs, so we
//include them here instead of in the "COMPILING_MCS" section.
#include <string>
#include <iostream>
#include <vector>
using namespace std;

//#include <stdlib.h>
#include <cstdlib>

//LN
#include <cstdio>
#include <cstring>




//--------------------------------------------------------------------
//MCS configuration file.
#include "mcs_config.h"







/*Pierre's stuff*/

#define TBOLD "\x1B[1m"
#define REV  "\x1B[7m"
#define RED  "\x1B[31m"
#define GREEN  "\x1B[32m"
#define BLUE  "\x1B[34m"
#define CYAN  "\x1B[36m"
#define YELLOW  "\x1B[33m"
#define MAGENTA "\x1B[35m"
#define BEEP  "\x7"
#define BGBLUE  "\x1B[44m"
#define NORMAL "\x1B[0m"
#define CLEANS  "\x1B[2J"


#define MERROR std::cerr << RED <<   "\r(E)\t"<< GREEN << __FILE__ << "," << __LINE__ << NORMAL << "\t" <<TBOLD<<__FUNCTION__<<NORMAL << "\t" 
#define MINFO std::cout << BLUE <<   "\r(I)\t"<< GREEN << __FILE__ << "," << __LINE__ << NORMAL << "\t" <<TBOLD<<__FUNCTION__<<NORMAL << "\t" 
#define MWARN std::cout << YELLOW << "\r(W)\t"<< GREEN << __FILE__ << "," << __LINE__ << NORMAL << "\t" <<TBOLD<<__FUNCTION__<<NORMAL << "\t" 


#if ENABLE_MYSQL
//--------------------------------------------------------------------
//MySQL include, this will be needed by user programs until the
//"mysql_stmt_param_metadata" function is available.
#include <mysql.h>
#define MYSQL_SOCK NULL

#else
//If MySQL facilities are disabled we need the following declaration to
//compile correctly.
#define MYSQL_BIND char
#define my_bool bool

//This has been copied from MySQL's include file mysql_time.h
typedef struct st_mysql_time
{
    unsigned int  year, month, day, hour, minute, second;
} MYSQL_TIME;
#endif  //ENABLE_MYSQL



//OpenSSL include
#ifdef HAVE_OPENSSL_SSL_H
#include <openssl/ssl.h>
#include <openssl/err.h>
#endif //HAVE_OPENSSL_SSL_H



#ifdef COMPILING_MCS

//--------------------------------------------------------------------
//PCRE include
#include <pcrecpp.h>
#endif  //COMPILING_MCS


namespace mcs
{



//--------------------------------------------------------------------
//MCS constants

#define MCS_DEFAULT_PORT 6523


#define MCS_DEFAULTCHUNKSIZE      16384


#define MCS_DEFAULT_MAX_USERS 100


#define MCS_DEFAULT_CLIENT_TIMEOUT 10 * 60 * 1000
//                                 min  sec  msec

#define MCS_COMMBUFSIZE    1024



#define MCS_SSLCERT     "mcscert.pem"
#define MCS_SSLPRIV     "mcspkey.pem"

//Grants constants
#define MCS_GRANT_NO_GRANTS        0
#define MCS_GRANT_LOGIN            1
#define MCS_GRANT_SQL_SCRIPTS      2
#define MCS_GRANT_SCRIPTS          4
#define MCS_GRANT_QUERY            8
#define MCS_GRANT_BATCH           16
#define MCS_GRANT_GET             32
#define MCS_GRANT_PUT             64
#define MCS_GRANT_SYS            128
#define MCS_GRANT_ADMIN          256
#define MCS_GRANT_ALL            511


#define MCS_BANNER "\nMy Customizable Server (MCS) ver. " PACKAGE_VERSION "\n"


#define MCS_MISSING_COPY_CONSTRUCTOR(CLASS) \
CLASS(const CLASS&);


#define MCS_MISSING_ASSIGNMENT_OPERATOR(CLASS)  \
CLASS& operator=(const CLASS&);


enum BufferFreeOnDestroy
{
  AUTO_FREE, 
  DONT_FREE  
};



enum ThrowExceptions
{
  DONT_THROW,  
  THROW        
};




//--------------------------------------------------------------------
//Protocol Specification:

#define MCS_PRE                         "#"

#define MCS_SEP                         "|"

#define MCS_PROMPT_OK           MCS_PRE "0--"

#define MCS_PROMPT_WARN         MCS_PRE "0W-"

#define MCS_PROMPT_ERROR        MCS_PRE "0E-"


//Protocol messages and numeric identifiers
#include <mcsmsg.hh>

//Protocol commands: (help lines MUST ends on column 93)

#define MCS_CMD_NOP                     "NOP"
#define MCS_CMD_NOP_HELP                "No operation (dummy) command."


#define MCS_CMD_CLIENT_INFO             "CLINFO"
#define MCS_CMD_CLIENT_INFO_HELP        "Return all client informations."


#define MCS_CMD_USERNAME                "USR"
#define MCS_CMD_USERNAME_HELP           "Supply user name.\n" \
                                        "USR <user_name>"

#define MCS_CMD_PASSWORD                "PWD"
#define MCS_CMD_PASSWORD_HELP           "Supply password.\n"  \
                                        "PWD <password>"

#define MCS_CMD_DBNAME                  "DBN"
#define MCS_CMD_DBNAME_HELP             "Supply application (database) name.\n" \
                                        "DBN <application_name>"


#define MCS_CMD_DBCONNECT               "CON"
#define MCS_CMD_DBCONNECT_HELP          "Finalize the authentication process and log in.\n" \
                                        "CON"

#define MCS_CMD_CLOSECLIENT             "BYE"
#define MCS_CMD_CLOSECLIENT_HELP        "Close the session.\n" \
                                        "BYE"

#define MCS_CMD_CID                     "CID"
#define MCS_CMD_CID_HELP                "Retrieve the Client identifier.\n" \
                                        "CID"



#define MCS_CMD_RECORD                  "FETCH"
#define MCS_CMD_RECORD_HELP             "Retrieve the record at a specified position, or at\n" \
                                        "current position (if none is specified) of the last\n" \
                                        "query executed.\n" \
                                        "FETCH [position]"


#if ENABLE_MYSQL
//Commands for DB access

#define MCS_CMD_QUERY                   "QRY"
#define MCS_CMD_QUERY_HELP              "Execute queries on the database.\n" \
                                        "QRY <SQL query>"

#define MCS_CMD_SENDQUERYRES            "QRES"
#define MCS_CMD_SENDQUERYRES_HELP       "Retrieve a file with an ASCII dump of the entire set\n" \
                                        "of records returned by the last query." \
                                        "QRES"


#define MCS_CMD_TABLELIST               "TLIST"
#define MCS_CMD_TABLELIST_HELP          "Retrieve the list of tables actually present in the\n" \
                                        "database.\n" \
                                        "TLIST"

#define MCS_CMD_TABLEINFO               "TINFO"
#define MCS_CMD_TABLEINFO_HELP          "Retrieve information about a table.\n" \
                                        "TINFO"
#endif  //ENABLE_MYSQL




//Options (to be used with "-" like in a shell command)


#define MCS_OPT_SAVEQUERYFITS           "sqfits"
#define MCS_OPT_SAVEQUERYFITS_HELP      "Save query result in FITS format.\n " \
                                        "-sqfits"

#define MCS_OPT_SAVEQUERYASCII          "sqascii"
#define MCS_OPT_SAVEQUERYASCII_HELP     "Save query result in ASCII format.\n"  \
                                        "-sqascii"


#define MCS_OPT_FORCE                   "force"
#define MCS_OPT_FORCE_HELP              "Continue execution of commands even if an error\n" \
                                        "occurred.\n" \
                                        "-force"

#define MCS_OPT_ALL_ERRORS              "werr"
#define MCS_OPT_ALL_ERRORS_HELP         "Turns all warning into errors, so that a warning can\n" \
                    "stop the execution.\n" \
                                        "-werr"

#define MCS_OPT_LOOP                    "loop"
#define MCS_OPT_LOOP_HELP               "Put a copy of thr received Data object in the \n" \
                                        "\"send\" vector.\n" \
                                        "-loop"

#define MCS_OPT_HELP                    "help"


#define MCS_CMD_EXEC                    "EXEC"
#define MCS_CMD_EXEC_HELP               "Execute an external program, SQL or batch file.\n" \
                                        "EXEC <alias> [[PAR1] [PAR2] ...]"

#define MCS_CMD_GET                     "GET"
#define MCS_CMD_GET_HELP                "Download a file from the work directory.\n" \
                                        "GET <filename>"

#define MCS_CMD_PUT                     "PUT"
#define MCS_CMD_PUT_HELP                "Upload a file to the work directory.\n" \
                                        "PUT <filename> <size>"

#define MCS_CMD_GETDATA                 "GDATA"
#define MCS_CMD_GETDATA_HELP            "Download Data objects.\n" \
                                        "GDATA <position>"

#define MCS_CMD_PUTDATA                 "PDATA"
#define MCS_CMD_PUTDATA_HELP            "Upload Data objects.\n" \
                                        "PDATA <size>"





//--------------------------------------------------------------------
//MCS enumerations

enum RetValue {
  OK,     
  WARN,   
  ERROR,  
  FATAL   
};


#include "mcstypes.hh"


//--------------------------------------------------------------------
//MCS macro facilities

#define csz            c_str()


#define my_mempcpy(D, S, N) ((void *) ((char *) memcpy (D, S, N) + (N)))




//--------------------------------------------------------------------
//MCS utilities functions

#define MCS_SUBST_QUOTE_WITH 1

#define MCS_SUBST_LEADING    4

#define MCS_SUBST_TRAILING   8

string subst(string s, string what, string with, int op = 0);


string trim(string s);

string chomp(string s);

string remTabs(string s);

string remLeading(string& s, const char* p);

string remTrailing(string& s, const char* p);

vector<string> split(string s, string sep = " ");

int extractCode(const char* msg);

bool File_Dir_Exist(string fn, unsigned int& size);

string itos(int i);


int stoi(string s);

int stoi(string s, int errval);


string btos(bool b);

string vtos(vector<string> vec);

string dtos(double f);

string Pwd();

string hexDump(const void* buf, unsigned int size);


#define MCS_MKDIR_UMASK 0
#define MCS_MKDIR_PROTECT S_IRUSR | S_IWUSR | S_IXUSR

bool mkDir(string path, mode_t perm = 0, enum ThrowExceptions throwexc = THROW);


mode_t read_umask();

bool rmDir(string path, enum ThrowExceptions throwexc = THROW);

class Record;

void ls2Record(string fn, Record& v);

string Types2Str(Types type, bool isunsigned);

bool VarLenType(Types type);

bool IntType(Types type);

bool FloatType(Types type);

int copy(char* OLDNAME, char* NEWNAME);

int move(char* OLDNAME, char* NEWNAME);


#if ENABLE_MYSQL
string MYSQL2Str(enum_field_types type);


bool MYSQL2Types(enum_field_types mtype, Types& type);

bool Types2MYSQL(Types& type, enum_field_types& mtype);

string Types2MYSQLStr(Types& type, bool isunsigned);

#endif //ENABLE_MYSQL


#if ENABLE_CFITSIO

bool FITS2Types(int fits, Types& dbt, bool& isunsigned);

bool Types2FITS(Types dbt, bool isunsigned, int& fits);

bool Types2S_FITS(Types dbt, int len, bool isunsigned, string& fits);


string fitsError(int status);
#endif //ENABLE_CFITSIO



//--------------------------------------------------------------------
#define MCS_VMSG_SIZE 1000

class Event
{
private:
  string latFile;

  int latLine;

  char buf[MCS_COMMBUFSIZE];

  string lmsg;

  int lcode;

  int lsubcode;

  RetValue ltype;

  friend class UserThread;

  static const char* vmsg[MCS_VMSG_SIZE];

  static void init_vmsg();

  static bool flInitialized;

  void init(string atFile, unsigned int atLine, RetValue type, int code);

public:
  static void (*custom_init_vmsg) (const char* vmsg[MCS_VMSG_SIZE]);

  Event(string atFile, unsigned int atLine, RetValue type, int code,
    string s1 = "", string s2 = "", string s3 = "");

  Event(string atFile, unsigned int atLine, RetValue type, int code,
    string s1, int i1);

  Event(string atFile, unsigned int atLine, RetValue type, int code,
    int i1, string s1 = "");


  Event(string atFile, unsigned int atLine, RetValue type, int code,
    int i1, int i2);

  ~Event();

  string msg();

  string where();

  int code();

  int subcode();

  Event& subcode(int subcode);

  string codemsg();

  string file();

  unsigned int line();

  RetValue type();

  static string static_vmsg(unsigned int i);
};


#define MCS_OK(A, rest...)     mcs::Event(__FILE__, __LINE__, mcs::OK,    A, ## rest)

#define MCS_WARN(A, rest...)   mcs::Event(__FILE__, __LINE__, mcs::WARN,  A, ## rest)

#define MCS_ERROR(A, rest...)  mcs::Event(__FILE__, __LINE__, mcs::ERROR, A, ## rest)

#define MCS_FATAL(A, rest...)  mcs::Event(__FILE__, __LINE__, mcs::FATAL, A, ## rest)

#define MCS_(TYPE, rest...)    mcs::Event(__FILE__, __LINE__, TYPE    , ## rest)


#ifndef DOXYGEN_SKIP
//--------------------------------------------------------------------
//MCS macro facilities for debug, see also the Debug class
#ifndef NOARGS
#define NOARGS
#endif  //NOARGS

#define MCS_DEBUG_ALLOC
#define MCS_DEBUG_SETUP(A, B)
#define MCS_DEBUG(A)
#define MCS_DEBUG_ENTER(A)
#define MCS_DEBUG_LEAVE(A)

#if ENABLE_DEBUG
#undef  MCS_DEBUG_ALLOC
#undef  MCS_DEBUG_SETUP
#undef  MCS_DEBUG
#undef  MCS_DEBUG_ENTER
#undef  MCS_DEBUG_LEAVE

#define MCS_DEBUG_ALLOC Debug _debug_
#define MCS_DEBUG_SETUP(A, B) _debug_.setDebug(B, this, A)
#define MCS_DEBUG(A)  if (_debug_.getDebugFlag()) { cout << _debug_.debug(__FILE__, __LINE__, __FUNCTION__) << A << endl; }
#define MCS_DEBUG_ENTER(A) MCS_DEBUG("-> "  A);
#define MCS_DEBUG_LEAVE(A) MCS_DEBUG("<- "  A);

#define MCS_DEBUG_NTHR 100

class Debug
{
private:
  bool active;
  string className;
  void* pThis;

  static pthread_t thrs[MCS_DEBUG_NTHR];
  static bool thrmap[MCS_DEBUG_NTHR];
  static int dummy;
  static int init();

public:
  Debug();
  ~Debug();

  string debug(const char* file, int line, const char* function);

  void setDebug(string className, void* pthis = 0, bool active = false);
  void setDebug();
  bool getDebugFlag();
};
#endif  //ENABLE_DEBUG
#endif  //DOXYGEN_SKIP






class Buffer {
private:
  char* buf;

  unsigned int bufsize;

  enum BufferFreeOnDestroy freebuffer;

  bool extbuffer;

  bool select;

  unsigned int wstart;

  unsigned int wlen;

public:
  Buffer(enum BufferFreeOnDestroy freeBuffer = AUTO_FREE);

  Buffer(void* extbuf, unsigned int size,
     enum BufferFreeOnDestroy freeBuffer = DONT_FREE);

  MCS_MISSING_COPY_CONSTRUCTOR(Buffer);


  MCS_MISSING_ASSIGNMENT_OPERATOR(Buffer);

  ~Buffer();


  void set(void* extbuf, unsigned int size, enum BufferFreeOnDestroy freeBuffer);


  Buffer& operator()(unsigned int start, unsigned int len);


  Buffer& operator()(unsigned int len);


  Buffer& operator<<(const void* extbuf);

  Buffer& operator<<(istream& stream);

  Buffer& operator>>(void* extbuf);

  Buffer& operator>>(ostream& stream);

  operator void*() const { return buf; }


  char* operator[](unsigned int pos);


  void free();


  void resize(unsigned int size);

  unsigned int size();
};


















#define MCS_SERIAL_UNKNOWN       0
#define MCS_SERIAL_BUFFER        1
#define MCS_SERIAL_FILENAME      2

//--------------------------------------------------------------------
//MCS Serializable class
class Serializable
{
private:
  MCS_DEBUG_ALLOC;

  char* buf;

  unsigned int maxChunksize;

  unsigned int lsize;

  string filename;

  int type;

  char* from;

  bool freeAfterUse;

  ifstream* stream;

  void init(int type, unsigned int lmaxChunksize);

  char* userdata; //To be used with virtual_nextChunk

  bool firstTime; //To be used with virtual_nextChunk

  virtual char* nextChunk_unknown(char* userdata, char* buf,
                  unsigned int& chunksize, bool firstTime);

  virtual char* serialize_unknown();

  virtual bool serialize_buffer(char*& from, unsigned int& size);

  virtual string serialize_filename();

  void serialize();

  void serialize_end();

public:
  MCS_MISSING_COPY_CONSTRUCTOR(Serializable);


  MCS_MISSING_ASSIGNMENT_OPERATOR(Serializable);

  Serializable(unsigned int lmaxChunksize = MCS_DEFAULTCHUNKSIZE);


  Serializable(void* from, unsigned int size, bool freeAfterUse,
           unsigned int lmaxChunksize = MCS_DEFAULTCHUNKSIZE);


  Serializable(string filename, unsigned int lmaxChunksize = MCS_DEFAULTCHUNKSIZE);

  Serializable(int type, unsigned int lmaxChunksize = MCS_DEFAULTCHUNKSIZE);

    virtual ~Serializable();


//    /*!
//      \brief Fills a buffer with next chunk to be sent.
//
//      \param chunksize Upon exit contains the size of the chunk.
//      \return Address of the buffer containing the chunk, or NULL if there are
//      no more data.
//    */
//    char* fillBuffer(unsigned int& chunksize);

  void* nextChunk(unsigned int& chunksize);

  void* getEntireBuffer(unsigned int& size);

    unsigned int maxChunkSize();


//    /*!
//      \brief Reinitialize internal data.
//
//      Reinitialize internal data, so that next call to fillBuffer() will read
//      data from the beginning of the buffer or the file. If type =
//      SERIAL_UNKNOWN the next call to fillBuffer will have firstTime =
//      true.
//    */
//    void abort();


//    /*!
//      \brief Tells if the object is in use.
//
//      If a call to fillBuffer() has already be done, and data are not yet
//      finished this will return true. Otherwise return false.
//    */
//    bool inUse();


    bool knowSize();

    unsigned int nChunk();


    unsigned int size();
};







//--------------------------------------------------------------------
class NetInterface
{
protected:
  unsigned int lindex;

  int req(int ioctl_num, struct ifreq *ifr);
  int getflags();
  bool isup();
  void str_sockaddr(struct sockaddr* sa);
  void str_sockaddr_in(struct sockaddr_in* sin);

  vector<string> names;

public:
//LN-darwin
#ifdef __APPLE__
  NetInterface(string name = "lo0");
#else
  NetInterface(string name = "lo");
#endif

//NetInterface(string name = "127.0.0.1");

  ~NetInterface();

  MCS_MISSING_COPY_CONSTRUCTOR(NetInterface);

  MCS_MISSING_ASSIGNMENT_OPERATOR(NetInterface);

  string name(int index = -1);

  unsigned int index();

  unsigned int count();

  string ipaddress(int index = -1);
};







//--------------------------------------------------------------------
class HostInfo
{
protected:
  struct sockaddr_in sin;
  string host;
  string ipaddr;
  void populate_sockaddr_in();

public:
  MCS_MISSING_COPY_CONSTRUCTOR(HostInfo);

  MCS_MISSING_ASSIGNMENT_OPERATOR(HostInfo);

  HostInfo(string host);

  HostInfo(int sockfd);

  ~HostInfo();

  string hostname();

  string ipaddress();
};






//--------------------------------------------------------------------
class Socket : public HostInfo
{
private:
  MCS_DEBUG_ALLOC;

  int sockfd;

  fd_set fds;

#ifdef HAVE_OPENSSL_SSL_H
  SSL_CTX* ssl_ctx;

  SSL *ssl;

  BIO *sbio;

  void initialize_ssl_bio(string keyfile);
#endif //HAVE_OPENSSL_SSL_H

  unsigned short int port;

  bool use_ssl;

  struct timeval readto;

  struct timeval writeto;

  int socketToHost(unsigned short port);


  void sendChunk(void* buf, unsigned int size);


  unsigned int recvChunk(void* buf, unsigned int size);

  unsigned int recvChunk(Buffer* buf);

protected:
  bool chkSend(enum ThrowExceptions throwexc = THROW);


  bool chkRecv(bool chkDataAvailable = false, enum ThrowExceptions throwexc = THROW);




public:
  MCS_MISSING_COPY_CONSTRUCTOR(Socket);

  MCS_MISSING_ASSIGNMENT_OPERATOR(Socket);

  Socket(string host, unsigned short int port=0,
     unsigned int readTimeout = 1000,
     unsigned int writeTimeout = 1000,
     bool ssl = false);


  Socket(int sockfd,
     unsigned int readTimeout = 1000,
     unsigned int writeTimeout = 1000,
     void* ssl_ctx = NULL);


  ~Socket();

  void Close();

  static void set_struct_timeval(unsigned int millisec, struct timeval* time);


  unsigned int read(void* buf, unsigned int count);


  unsigned int write(void* buf, unsigned int count);


  string getline();


  void print(string s);


  void sendData(Serializable* from);


  unsigned int recvData(char** buffer, unsigned int maxsize);


  unsigned int recvData(string filename);

  unsigned int recvData(int filedes);

  unsigned int recvData(ofstream& stream);
};





//--------------------------------------------------------------------
class ServerSocket : public NetInterface
{
private:
  int sockfd;

  bool use_ssl;

#ifdef HAVE_OPENSSL_SSL_H
  SSL_CTX* ssl_ctx;
#endif //HAVE_OPENSSL_SSL_H

public:
  MCS_MISSING_COPY_CONSTRUCTOR(ServerSocket);

  MCS_MISSING_ASSIGNMENT_OPERATOR(ServerSocket);

  ServerSocket(string interface, unsigned short int port,
           bool use_ssl = false, string sslcert = "", string sslpriv = "");

  ~ServerSocket();

  bool acceptConnection(int& newsock, unsigned int millisec);

  void* getSSLContext();
};





//--------------------------------------------------------------------
class Synchro
{
private:

  //  MCS_DEBUG_ALLOC;

//LN-darwin
#if defined(_POSIX_TIMEOUTS) && (_POSIX_TIMEOUTS - 200112L) >= 0L
/* POSIX Timeouts are supported - option group [TMO] */
 
  //  struct _pthread_cleanup_buffer _buf;
#endif

  pthread_mutex_t mutex;

  pthread_mutexattr_t attr;

  int Count;

  bool isActive;

public:
    MCS_MISSING_COPY_CONSTRUCTOR(Synchro);

    MCS_MISSING_ASSIGNMENT_OPERATOR(Synchro);

  Synchro();

  ~Synchro();

  void synchronize(bool setactive);

#define MCS_SYNCHRO_LOCK        1

#define MCS_SYNCHRO_TRY_LOCK    2

#define MCS_SYNCHRO_TRY_TIMED   3

  bool enter(int op = MCS_SYNCHRO_LOCK, unsigned int timeout = 0);

  bool tryenter(unsigned int timeout = 0);

  int count();

  int leave();

#ifdef ENABLE_CLEANUP_HANDLERS

 static void CH_leave(void* This);
#endif //ENABLE_CLEANUP_HANDLERS

  //  \brief Waits until some other thread locks and unlocks the same
  //  Synchro object.
  //
  //  The mutex MUST be locked before using wait() (with enter()) and unlocked
  //  after this method returns (with leave()).
  //
  //  When this method is called it immediately unlock the mutex, so
  //  that another thread can lock it.
  //
  //  If it return true then another thread has locked and unlocked the same
  //  Synchro object, if it returns false a timeout occurred before other
  //  threads can lock and unlock the mutex. in any case the mutex is now locked
  //  by the current thread, so you have to unlock it with leave().
  //
  //  An example follows:
  //  \code
  //  ...
  //  enter();
  //  bool b = wait(1000); //Leaving the critical section and wait
  //                       //for someone else to lock and unlock the
  //             //same Synchro object, or a timeout of 1
  //             //second occur.
  //
  //  if (b) {  //Another thread entered and leave a critical section
  //    ... //Do some work
  //  }
  //  else { //A timeout occurred
  //    ...
  //  }
  //  leave();
  //  \endcode
  //
  //  \param timeout Timeout in millisecond.
  //  \return False if a timeout or an interrupt occurred, true otherwise.
  //*/
};


#define MCS_CRITICAL_SECTION_BEGIN  enter(); try {


#define MCS_CRITICAL_SECTION_END    } catch(Event e) { leave(); throw e; } leave();

#define MCS_CRITICAL_SECTION_END_RETURN(What...)  \
leave(); return What; }                           \
catch(Event e) { leave(); throw e; }


#define MCS_CRITICAL_SECTION(BLOCK...) \
MCS_CRITICAL_SECTION_BEGIN             \
  BLOCK;                               \
MCS_CRITICAL_SECTION_END







//--------------------------------------------------------------------
#define MCS_STATE_CREATED                1

#define MCS_STATE_RUNNING                2

#define MCS_STATE_TERMINATING            3

#define MCS_STATE_END                    4



class Thread
{
private:

  //  MCS_DEBUG_ALLOC;

  static void* RunThread(void* args);

  Thread* lparent;

  pthread_t lthrID;

  int lid;

  int lstate;

  //Synchronization for lstate variable.
  //  Synchro syn_lstate;

  static void cleanup_Handler(void* This);

  bool checkTerminating();

  bool detached;

  bool selfDelete;

protected:
  virtual void notify(int id, Thread* ref);


  virtual void initial();


  virtual void final();


  virtual void run();

  void set_cancel_state(bool cancel);

  void test_cancel();

  Event* lerror;

public:
  Event* error();

  //  MCS_MISSING_COPY_CONSTRUCTOR(Thread);

  //  MCS_MISSING_ASSIGNMENT_OPERATOR(Thread);

  Thread(int id = 0, Thread* parent = NULL);

  virtual ~Thread();

  void start();


  void startDetached(bool selfDelete = false);


  void stop();

  int id();

  Thread* parent();


  int state();
};



template<class BASE>
class ThreadSpecificData
{
private:
  pthread_key_t key;
  int ltag;

  static void generic_destructor(void* p)
  { delete ((BASE*) p); }

  void (*destructor)(void*);

public:
  ThreadSpecificData(void (*ext_destructor)(void*) = NULL)
  {
    destructor = generic_destructor;
    if (ext_destructor)
      destructor = ext_destructor;

    pthread_key_create(&key, destructor);
  }

  ~ThreadSpecificData()
  { pthread_key_delete(key); }

  void clear()
  {
    void* p = getp();
    if (p)
      (destructor)(p);

    pthread_setspecific(key, NULL);
  }

  void init(BASE* p = NULL, int tag = 0)
  {
    clear();

    if (! p)
      p = new BASE();

    pthread_setspecific(key, p);
    ltag = tag;
  }

  int tag()
  { return ltag; }

  BASE* operator->() const
  { return  ((BASE*) pthread_getspecific(key)); }

  BASE* getp()
  { return  ((BASE*) pthread_getspecific(key)); }
};





class ThreadFunc : public Thread
{
private:
  int    (*start_routine1)(void*);
  Event* (*start_routine2)(void*);
  void* arg;
  int ret;

  void run();

public:
  ThreadFunc(int    (*start_routine)(void*), void* arg);
  ThreadFunc(Event* (*start_routine)(void*), void* arg);

  int retcode();
};



void sleep_ms(unsigned int millisec);



enum TimeMode {
  UTC,
  LOCAL
};





time_t my_timelocal(struct tm* tm);




class DateTime {

private:
  time_t time;

  enum TimeMode timemode;

  MYSQL_TIME* mysql;

  static const char* parseTime(const char* s, struct tm* tm);


  void to_MYSQL_TIME();


  time_t getTime() const;


public:
  DateTime();

  void setMysqlBuffer(MYSQL_TIME* mysql);

  void setTimeMode(enum TimeMode tm);


  void now();


  void settval(time_t t);

  DateTime& operator=(time_t t)
    { settval(t); return *this; }


  void setsval(string s);

  DateTime& operator=(string s)
    { setsval(s); return *this; }

  void settmval(struct tm& ltm);

  DateTime& operator=(struct tm& ltm)
    { settmval(ltm); return *this; }


  time_t tval() const;

  operator time_t() const
    { return tval(); }


  struct tm tmval() const;

  operator struct tm() const
    { return tmval(); }

  string sval() const;

  operator string() const
    { return sval(); }
};



#define MCS_ID_UNKNOWN  -1
#define MCS_ID_LOCAL    -2
#define MCS_ID_CLIENT   -3


//  Another wide use of the Data class is to to set/retrieve data of
//  prepared statement executions on the database. The Query class has
//  two fundamental methods that returns address of Data objects:
//  param() (to input data on prepared statement) and field() (to
//  retrieve data from an executed query on the database.



//Max number of dimensions in a Data multi-dimensional array. Note
//that this number influences the declaration and implementation of
//Data::array and Data::operator=.
#define MCS_DATA_NDIM   15



//--------------------------------------------------------------------
class Data : public Serializable
{
private:
  MCS_DEBUG_ALLOC;

  void reallocBuffer();

#if ENABLE_MYSQL
  MYSQL_BIND* lbind;
#endif

  Types ltype;

  string lname;

  unsigned int lflags;

  unsigned short int lmaxlength;

  unsigned long llength;

  bool lisunsigned;

  my_bool lisnull;

  bool lautoincr;

  unsigned char tag;

  char* buf;

  unsigned int bufsize;

  static const char* dtfmt;

  static const char* dafmt;

  static const char* tmfmt;

  static const char* ifmt;

  static const char* lfmt;

  static const char* ffmt;

  static const char* dfmt;

  DateTime dt;


  void init(MYSQL_BIND* bind, Types type, const char* name="",
        unsigned short int maxLength=0, bool isunsigned=false,
        unsigned int flags = 0);

  //void MySQL_TIME_2_time_t(MYSQL_TIME* mtime, time_t* t);
  //
  //void time_t_2_MySQL_TIME(time_t* t, MYSQL_TIME* mtime);

  bool serialize_buffer(char*& from, unsigned int& size);

  int id_source;

  int id_dest;

  unsigned char ldimspec;

  unsigned short int ldim[MCS_DATA_NDIM];

  unsigned short int mult[MCS_DATA_NDIM];

  unsigned int arrsize;

  unsigned int arrpos;

public:
  unsigned int objSize();


  Data();

  Data(const Data& from);


  Data(Types type, unsigned short int maxLength = 0,
       bool isunsigned = false, string dimSpec = "");


  Data(MYSQL_BIND* bind = NULL, Types type = STRING,
       const char* name="", unsigned short int maxLength=0,
       bool isunsigned=false, unsigned int flags = 0,
       unsigned char tag = 0);


  Data(int                    v, unsigned char tag = 0);

  Data(long long int          v, unsigned char tag = 0);

  Data(double                 v, unsigned char tag = 0);

  Data(string                 v, unsigned char tag = 0);

  Data(struct tm             v, unsigned char tag = 0);

  Data(time_t                 v, unsigned char tag = 0);

  Data(void* lbuf, unsigned int size, unsigned char tag = 0);


  Data(void* lbuf);

  ~Data();

  void emptyName();


  string name();

  //Set the name of the object.
  void setName(string name);

  //unsigned int flags();

  Types type();

  unsigned short int maxLength();

  unsigned short int length();

  bool isUnsigned();

  bool isNull();

  bool isAutoIncrement();

  void* buffer() const;

  int ival() const;

  unsigned int uival() const;

  long long int lval() const;

  unsigned long long int ulval() const;

  float fval() const;

  double dval() const;

  string sval(bool addWhiteSpaces = false) const;

  int cval(char* c, int maxlength) const;

  time_t tval() const;

  void tval(struct tm* t) const;


  void* pval() const;

  void setpval(void* p);


  void setNull(bool null = true);

  void setival(int v);

  void setuival(unsigned int v);

  void setlval(long long int v);

  void setulval(unsigned long long int v);

  void setdval(double v);

  void setcval(const char* v);

  void setsval(string v);

  void setblob(void* lbuf, unsigned int size);

  void settimeval(struct tm v);

  void settimeval(time_t v);

  void settimenow();

  void setTimeMode(enum TimeMode tm);

  //Wrapper to setsval(int).
  //void setval(string v);

  //Wrapper to setival(int).
  //void setval(int v);

  //Wrapper to setdval(int).
  //void setval(double v);

  //Wrapper to setcval(int).
  //void setval(const char* v);

  void resize(string dimSpec);

  void resizeVaryingDim(unsigned short int newsize);

  unsigned short int dim(int d);


  //How many dimensions, 0 means scalar value

  unsigned int howManyDim();

  unsigned int varyingDim();

  unsigned int arraySize();


  unsigned int array(unsigned short int i1 = 0,
             unsigned short int i2 = 0,
             unsigned short int i3 = 0,
             unsigned short int i4 = 0,
             unsigned short int i5 = 0,
             unsigned short int i6 = 0,
             unsigned short int i7 = 0,
             unsigned short int i8 = 0,
             unsigned short int i9 = 0,
             unsigned short int i10 = 0,
             unsigned short int i11 = 0,
             unsigned short int i12 = 0,
             unsigned short int i13 = 0,
             unsigned short int i14 = 0,
             unsigned short int i15 = 0);

  Data& operator()(const int i1 = 0,
           const int i2 = 0,
           const int i3 = 0,
           const int i4 = 0,
           const int i5 = 0,
           const int i6 = 0,
           const int i7 = 0,
           const int i8 = 0,
           const int i9 = 0,
           const int i10 = 0,
           const int i11 = 0,
           const int i12 = 0,
           const int i13 = 0,
           const int i14 = 0,
           const int i15 = 0);

  Data& operator=(const int v)
    { setival(v); return *this; }

  Data& operator=(const unsigned int v)
    { setuival(v); return *this; }

  Data& operator=(const long long int v)
    { setlval(v); return *this; }

  Data& operator=(const unsigned long long int v)
    { setulval(v); return *this; }

  Data& operator=(const double v)
    { setdval(v); return *this; }

  Data& operator=(const char*  v)
    { setsval(v); return *this; }

  Data& operator=(const string v)
    { setsval(v); return *this; }

  Data& operator=(const struct tm v)
    { settimeval(v); return *this; }

  Data& operator=(const time_t v)
    { settimeval(v); return *this; }

  operator const int                    () const { return ival     (); }

  operator const unsigned int           () const { return uival    (); }

  operator const long long int          () const { return lval     (); }

  operator const unsigned long long int () const { return ulval    (); }

  operator const float                  () const { return dval     (); }

  operator const double                 () const { return dval     (); }

  operator const char*                  () const { return (char*) pval(); }

  operator const string                 () const { return sval     (); }

  operator const struct tm              () const { struct tm v; tval(&v); return v; }

  operator const time_t                 () const { return tval     (); }


  Data& operator=(Data& d);

  //static void default_struct_tm(struct tm* t);

  static void parseTime(string s, struct tm* ts);

  static long long int MinValue(Types ltype, bool flunsigned);

  static long long int MaxValue(Types ltype, bool flunsigned);

  string print();

  void setTag(unsigned char tag);

  unsigned char getTag();

  int getSourceID();
  int getDestID();
  void setSourceID(int id);
  void setDestID(int id);
};



#define DYNAMIC_ARRAY_DEFAULT_STEP 10



template<class BASE>
class Dynamic_Array : public Synchro {
private:
  BASE** arr;

  int step_alloc;

  int lcount;

  void check_allocation(int count);

protected:
  Dynamic_Array<BASE>& array;

public:
  Dynamic_Array(bool synchro);

  MCS_MISSING_COPY_CONSTRUCTOR(Dynamic_Array);


  Dynamic_Array& operator=(Dynamic_Array& from);


  ~Dynamic_Array();

  int count();

  bool ready();

  void push(BASE* d);

  void push(BASE& d);

  BASE pop(int pos = 0);

  BASE& operator[](int pos);

  BASE peek(int pos);

  void clear();
};


//Methods implementation of template classes must be in the header file
template<class BASE>
void mcs::Dynamic_Array<BASE>::check_allocation(int count) {
  unsigned int size;
  static int max_size = Data::MaxValue(SMALL, true);

  if (count >= max_size)
    throw MCS_ERROR(MSG_INDEX_OUT_RANGE, count, max_size);

  if (count > (step_alloc * DYNAMIC_ARRAY_DEFAULT_STEP)) {
    step_alloc++;
    size = sizeof(BASE*) * step_alloc * DYNAMIC_ARRAY_DEFAULT_STEP;

    if (step_alloc == 1) //First allocation
      arr = (BASE**) malloc(size);
    else
      arr = (BASE**) realloc(arr, size);
  }
}


template<class BASE>
mcs::Dynamic_Array<BASE>::Dynamic_Array(bool synchro) :
  Synchro(), array(*this)
{
  synchronize(synchro);
  lcount = 0;
  step_alloc = 0;
  arr = NULL;
}


template<class BASE>
mcs::Dynamic_Array<BASE>::~Dynamic_Array() {
  clear();
}



template<class BASE>
mcs::Dynamic_Array<BASE>&
mcs::Dynamic_Array<BASE>::operator=(Dynamic_Array<BASE>& from) {
  int i;

  clear();
  for (i=0; i<from.count(); i++)
    push(from[i]);

  return *this;
}


template<class BASE>
void mcs::Dynamic_Array<BASE>::push(BASE* d) {
  MCS_CRITICAL_SECTION_BEGIN;

  check_allocation(lcount + 1);
  arr[lcount++] = d;

  MCS_CRITICAL_SECTION_END;
}


template<class BASE>
void mcs::Dynamic_Array<BASE>::push(BASE& d) {
  MCS_CRITICAL_SECTION_BEGIN;

  check_allocation(lcount + 1);
  arr[lcount++] = new BASE(d);

  MCS_CRITICAL_SECTION_END;
}



//#define EVENT_IS_THROWN(INSTR...)
//try { INSTR;}  catch(Event e) { leave(); throw; }
//{ bool _EVENT_IS_THROWN



template<class BASE>
BASE mcs::Dynamic_Array<BASE>::pop(int pos) {
  int i;

  MCS_CRITICAL_SECTION_BEGIN;

  BASE d = BASE(operator[](pos));

  if (pos < lcount) {
    delete arr[pos];

    lcount--;
    for (i=pos; i<lcount; i++)
      arr[i] = arr[i+1];
  }

  MCS_CRITICAL_SECTION_END_RETURN(d);
}


template<class BASE>
BASE& mcs::Dynamic_Array<BASE>::operator[](int pos) {
  if (pos < 0)
    pos += lcount;

  if (pos < 0)
    throw MCS_ERROR(MSG_INVALID_POSITION, pos);

  if (pos >= lcount)
    throw MCS_ERROR(MSG_INDEX_OUT_RANGE, pos, lcount);

  return *(arr[pos]);
}


template<class BASE>
BASE mcs::Dynamic_Array<BASE>::peek(int pos)
{
  MCS_CRITICAL_SECTION_BEGIN;

  BASE d = operator[](pos);

  MCS_CRITICAL_SECTION_END_RETURN(d);
}


template<class BASE>
int mcs::Dynamic_Array<BASE>::count() {
  return lcount;
}


template<class BASE>
bool mcs::Dynamic_Array<BASE>::ready() {
  return (bool) (lcount > 0);
}


template<class BASE>
void mcs::Dynamic_Array<BASE>::clear() {
  int i;

  MCS_CRITICAL_SECTION_BEGIN;

  for (i=0; i<lcount; i++)
    delete arr[i];

  if (arr) {
    free(arr);
      arr = NULL;
  }

  lcount = 0;
  step_alloc = 0;

  MCS_CRITICAL_SECTION_END;
}




//#define MCS_VECTOR_MOVE_TO_END -1

class Record : public Serializable, public Synchro
{
private:
  MCS_DEBUG_ALLOC;

  Dynamic_Array<Data> array;

  Dynamic_Array<int> lmap;

  string smap;

  bool serialize_buffer(char*& from, unsigned int& size);



public:
  Record(Record& from);

  Record& operator=(Record& from);

  void emptyName();

  void setNull();


  Record(bool synchro = false);


  Record(void* lbuf, bool synchro = false);


  ~Record();

  int count();

  void addField(Data* d);

  void addField(Data& d);

  void addField(string s, char tag = 0);

  void addField(int i, char tag = 0);

  void addField(long long int i, char tag = 0);

  void addField(double f, char tag = 0);

  Data pop(int x = 0);

  int posWhoseNameIs(string name , enum ThrowExceptions throwexc = THROW);


  void setFieldMap(string s = "");

  void setFieldMap(Record& rec);

  void clear();


  Data& operator[](string name);

  Data& operator[](int pos);

  Data field(string name);

  Data field(int pos);


  unsigned int objSize();

  string asString(string sep = "\t");
  string asStringNames(string sep = "\t");
  string asStringTypes(string sep = "\t");


  //  \brief Move element in the Record from one position to another.
  //
  //  Both indexes must be allowed ones, and "from" must be less than
  //  "to". All elements after "from" will be shifted one position
  //  towards the exit of the queue. This is a thread safe method.
  //
  //  \param from Source position;
  //  \param to Destination position.
  //
  //  \exception ERROR MSG_INDEX_OUT_RANGE.
  // */
  //void move(int from, int to);
};











#define MCS_RS_ACCUM        1


#define MCS_RS_USEMETAREC   2

#define MCS_RS_KNOW_NROWS   4

#define MCS_RS_RANDOM       8


#define MCS_RS_INSERT      16




class RecordSet {
private:
  short int lid;

  unsigned char code;

  bool lknow_nrows;

  unsigned int lnrows;

  bool laccum;

  bool lrandom;

  bool lusemetarec;

  bool lfetch;

  bool linsert;

  unsigned int lpos;

  unsigned int current;

  Record lmetarec;

  bool leof;

  Dynamic_Array<Record> rs;

  virtual Record* newRecord();

  //Clear the entire Record set and the lmetarec object.
  void clear();

  bool internal_fetch(unsigned int newpos);


protected:
  void init(unsigned char code, unsigned int nrows = 0, Record* meta = NULL,
        short int id = 0);

  void startFetch();

  virtual bool fetch(unsigned int newpos, bool random);

  virtual void hk_dump(string fn);


public:
  MCS_MISSING_COPY_CONSTRUCTOR(RecordSet);

  MCS_MISSING_ASSIGNMENT_OPERATOR(RecordSet);

  RecordSet();

  virtual ~RecordSet();



  void setFieldMap(string s = "");


  void insert(Record* rec);

  void insert(Record& rec);


  bool setFirst();

  bool setLast();

  bool setNext();

  bool setPrev();

  bool setWhere(int i, string equalTo);

  bool setWhere(int field, int equalTo);

  bool setPos(unsigned int i);

  void dump(string fn);

  bool know_nRows();
  unsigned int nRows();

  int nFields();

  unsigned int pos();
  bool eof();
  bool alwaysSameStructure();

  Record& rec();
  Record& metarec();

  Record* prepRecToSend();
};





//--------------------------------------------------------------------
class Conf
{
private:
  string filename;

  vector<string> sections;

  vector<string> keys;

  vector<string> values;

  vector<string> comments;

  int index(string section, string key);

  Data lastval;

public:
  MCS_MISSING_COPY_CONSTRUCTOR(Conf);

  MCS_MISSING_ASSIGNMENT_OPERATOR(Conf);

  Conf(string filename = "");

  ~Conf();

  void open(string filename);

  bool search(string section, string key, enum ThrowExceptions throwexc = DONT_THROW);


  Data& val(string section = "", string key = "");

  string sval(string section, string key);

  string sval(string section, string key, string defval);



  int ival(string section, string key);

  int ival(string section, string key, int defval);


  long long int lval(string section, string key);

  long long int lval(string section, string key, int defval);


  void setval(string section, string key, string val, string comment = "");

  void setval(string section, string key, long long int val, string comment = "");
  void setval(string section, string key, int val, string comment = "");

  void setval(string section, string key, Data* val, string comment = "");


  void save(string filename = "");
};







//--------------------------------------------------------------------
#define MCS_CMD_MAX_TOKENS 100

class CommandParser {
private:
  MCS_DEBUG_ALLOC;

  string origcmdline;

  string lcmd;

  vector<string> tokens;

  vector<string> rest;

  vector<string> args;

  vector<string> opts;

  vector<string> optargs;

  Data* md_args[MCS_CMD_MAX_TOKENS];

  Data* md_optargs[MCS_CMD_MAX_TOKENS];

  static string clean(string c);

  void clearArgs();

public:
  MCS_MISSING_COPY_CONSTRUCTOR(CommandParser);

  MCS_MISSING_ASSIGNMENT_OPERATOR(CommandParser);

  CommandParser();

  ~CommandParser();

  int tokenc();

  string token(int i);

  string line_afterToken(int i);


  Data& arg(int i);

  string sarg(int i);


  int argc();


  string opt(int i);

  int optc();


  Data& optarg(int i);

  void parseCmd(string c);

  void parseCmd(int argc, char* argv[]);



  string cline();

  string cmd();

  string allargs();

  bool cmpCmd(string cmd);

  bool givenOpt(string opt);

  bool givenOpt(string opt, int& i);


  vector<string> replPars_onFile(string fn);


  string replPars(string str);
};






#if ENABLE_MYSQL
//--------------------------------------------------------------------
class DBConn
{
private:
  MCS_DEBUG_ALLOC;

  MYSQL* lconn;

  bool lconnInitialized;

  bool lconnOpened;

  string luser;

  string lpass;

  string ldb  ;

  string lhost;

  friend class Query;

public:
  MCS_MISSING_COPY_CONSTRUCTOR(DBConn);

  MCS_MISSING_ASSIGNMENT_OPERATOR(DBConn);

  DBConn();

  ~DBConn();

  void connect(string user, string pass, string db, string host="");

  void close();

  bool isOpen();

  unsigned long id();

  DBConn* newDBConn();
};






//--------------------------------------------------------------------
class Query : public RecordSet
{
private:
  MCS_DEBUG_ALLOC;

  DBConn* ldbc;

  bool lhandleNewDBConn;

  MYSQL* lconn;

  bool gotStmtInitialized;

  bool gotResult;

  unsigned int laffectedRows;

  long long int lastid;

  Record lparam;


  vector<string> printResultSet(unsigned int& nrows,
                unsigned int& nfields,
                MYSQL_RES* res = NULL);

  MYSQL_STMT* lstmt;

  MYSQL_BIND* lbparam;

  int nlparam;


  MYSQL_BIND* lbrec;

  bool fetch(unsigned int newpos, bool random);

  Record* myrec;

  Record* newRecord();

  /*
    IMPORTANT NOTE: lbparam and lparam are protected because the Table class
    needs them to bind parameters. Anyway this should be automatically done
    via mysql_stmt_param_metadata, but it is not yet implemented. When this
    routine will became available this two variables will become private, so
    users should use the method "param" wherever possible.
  */

  void bind();

  string SQL;

  void parseFieldList(int op, string& fields, string& values, int& autoIncr);


public:
  MCS_MISSING_COPY_CONSTRUCTOR(Query);

  MCS_MISSING_ASSIGNMENT_OPERATOR(Query);

  Query(DBConn* lconn, bool call_newDBConn = false);

  ~Query();

  void query(string SQL, bool StoreResult = false);


  vector<string> simpleQuery(string SQL,
                 unsigned int& nrows, unsigned int& nfields);


  vector<string> simpleQuery(string SQL);


  void prepare(string SQL="");

#define MCS_PAB_INSERT 1
#define MCS_PAB_UPDATE 2
#define MCS_PAB_REPLACE 3


  void prepare_with_parameters(int op, string fields, string table,
                               string where="", int nrec=1);


  void prepare_with_parameters(int op, char** fields, int nfields,
                               string table, string where="", int nrec=1);


  unsigned int nAffectedRows();


  Record& param();

  //  \brief Returns the current record set.
  //*/
  //DBRecordSet* result();

  Data& lookup(string field, string table, string where = "");


  void execute(bool StoreResult = false);


  bool gotRecordSet();


  void close();


  void readTableList();

  vector<string>tableList;

  vector<string> tableInfo(string tbl);


  vector<string> ExecutionDetails(string pre = "");


  void customFillBuffer(char* buf, unsigned int& chunksize, bool firstTime);

  void Result2Ascii(string fn);

  long long int last_id();
};







//--------------------------------------------------------------------
class Table : public Query
{
private:
  MCS_DEBUG_ALLOC;

  string ltable;

  string lfieldkey;

  unsigned int posfieldkey;

  Record newrec;

  void insert_or_update(int op);

public:
  MCS_MISSING_COPY_CONSTRUCTOR(Table);

  MCS_MISSING_ASSIGNMENT_OPERATOR(Table);

  Table(DBConn* db, string table, string fieldkey);

  ~Table();

  void loadTable();

  Record& newRec();

  void insert();

  void replace();


  void update();
};
#endif





//Forward declaration
class Env;
class Server;



//
//--------------------------------------------------------------------
class BaseThread : public Thread {
private:
  MCS_DEBUG_ALLOC;

  char tID[4];

protected:
  RetValue Log(Event e);

  static Env* env;

public:
  MCS_MISSING_COPY_CONSTRUCTOR(BaseThread);

  MCS_MISSING_ASSIGNMENT_OPERATOR(BaseThread);

  BaseThread(Thread* parent, int lID);

  BaseThread(Thread* parent, const char *ltID);

  ~BaseThread();

  const char *tid();


  static int fileType(string fn);

  int chkExt(string& s);

  static int spawn(string fn, string pars,
           string wpath = ".",
           string thrID = "x",
           string user = "x",
           string pass = "x",
           string dbname = "x",
           string fout = "out",
           string ferr = "err");
};




//--------------------------------------------------------------------
#define MCS_FT_UNKNOWN  0

#define MCS_FT_BATCH    1

#define MCS_FT_SQL      2

#define MCS_FT_SCRIPT   3

#define MCS_FT_BIN      4



class ClientInfo : public Record
{
public:
  Data& id();

  Data& ipaddress();

  Data& hostname();

  Data& timeConnetcted();

  Data& username();

  Data& lastCommand();

  Data& timeLastCommand();

  Data& commandExecuted();

  Data& logged();

public:
  ClientInfo();
};





class UserThread : public BaseThread {
private:
  MCS_DEBUG_ALLOC;

  int csocket;

  ClientInfo linfo;

  RecordSet* rs;

  bool deleters;

  Synchro syn;

protected:
  Socket* sock;

  int luserid;

  int batchlevel;

  bool loginok;

  int grants;

  string fnout;

  string fnerr;

  string user;

  string pass;

  string dbname;

  string dbhost;

#if ENABLE_MYSQL
  DBConn db;

  Query* query;
#endif

  void setActiveRS(RecordSet* rs, bool delWhenFinished = true);

  string wpath(string fn = "");


  RetValue sendStrings(string str);


  RetValue Send(Event e, bool log = true);

  RetValue Send(Data& data);

  RetValue Send(Record& vec);

  RetValue Send(string filename, string path);

  RetValue Send(vector<string> vec);


#if ENABLE_MYSQL

  RetValue sendQueryRes();
#endif


  void prompt(RetValue ret);


  void run();


  virtual RetValue hk_connect();


  virtual RetValue hk_auth(int& grants, bool& loginok);


  virtual RetValue hk_exec(CommandParser* cmd, bool& cmd_executed);


  virtual void hk_postexec(CommandParser* cmd, RetValue ret);


  virtual void hk_disconnect();


  RetValue exec(string cmd, string pars = "");


  Server* parent();


  void send2OtherThread(Data& d, int destid);

public:
  MCS_MISSING_COPY_CONSTRUCTOR(UserThread);

  MCS_MISSING_ASSIGNMENT_OPERATOR(UserThread);

  UserThread(Thread* parent, int lID, int newsock);

  ~UserThread();

  ClientInfo& info();

  void wakeUpClient(Event* e = NULL);

  Record send;

  Record recv;

  string userName();

  int userID();
};




// -------------------------------------------------------------------
class LocalThread : public BaseThread
{
private:
  MCS_DEBUG_ALLOC;

  virtual void run();


protected:
  UserThread** client;

  UserThread** serverClients();

  void dataDispatcher();

  bool userID2clientID(int userid, int* cid);


public:
  MCS_MISSING_COPY_CONSTRUCTOR(LocalThread);

  MCS_MISSING_ASSIGNMENT_OPERATOR(LocalThread);

  LocalThread(Thread* parent);


  ~LocalThread();


  virtual void hk_log(UserThread* p, Event e);

  Record recv;
};




//--------------------------------------------------------------------
class Env {
private:
#if ENABLE_MYSQL
  DBConn db;
#endif //ENABLE_MYSQL

  void chkTree();

  void LoadConf();

  void DumpConf();


public:
  Env(string app = "mcs", string inipath = "mcs.conf");

  MCS_MISSING_COPY_CONSTRUCTOR(Env);

  MCS_MISSING_ASSIGNMENT_OPERATOR(Env);

  ~Env();

  LocalThread* local;

  Conf* cnf;

  string appname;

  string appvers;

  string path;

  string inipath;

  string localhost;

  string interface;

  int port;

  //bool server_running;

  Server* server;

  int max_users;

  bool cl_local_kills_mcs;

  bool cl_have_db;

  bool cl_custom_auth;

  bool cl_logfile;

  bool cl_work;

  bool cl_work_cid;

  bool cl_logstdout;

  bool cl_createlocal;

  bool cl_restartlocal;

  bool cl_clean_logout;

  bool cl_read_grants;

  bool cl_autoexec;

  bool cl_use_ssl;

  string sslcert;

  string sslpriv;

  ofstream* flog;

  string db_user;

  string db_pass;

  string db_name;

  string db_host;

  unsigned int timeout;

  int cl_chunksize;

  void* ssl_ctx;
};












//--------------------------------------------------------------------
class Server : public BaseThread
{
private:
  MCS_DEBUG_ALLOC;

  UserThread** pClient;

  friend class LocalThread; //To give access to pClient

  void run();

  int find_free_id();

protected:
  void notify(int id, Thread* ref);

  void newClient(int newsock);

  //void freeClient(int i);

  void killAllClients();

  virtual void hk_newClient(int i);

  void killClient(int i);


  virtual UserThread* newUserThread(int lID, int newsock);

  virtual LocalThread*  newLocalThread();

public:
  MCS_MISSING_COPY_CONSTRUCTOR(Server);

  MCS_MISSING_ASSIGNMENT_OPERATOR(Server);

  Server(Env* lenv);

  ~Server();

  RecordSet* getAll_ClientInfo();

  void     (*cb_log)         (UserThread* p, Event e);

  RetValue (*cb_connect)     ();

  RetValue (*cb_auth)        (int&, bool&);

  RetValue (*cb_exec)        (CommandParser*, bool&_executed);

  void     (*cb_postexec)    (CommandParser*, RetValue);

  void     (*cb_disconnect)  ();

  void     (*cbwa_log)       ();

  void     (*cbwa_connect)   ();

  void     (*cbwa_auth)      ();

  void     (*cbwa_exec)      ();

  void     (*cbwa_postexec)  ();

  void     (*cb_newClient)   (int i);

  Record dispatch;
};




Env* mcsStart(string appname, string inipath = "",
          Server* (*cb_newServer)(Env*) = NULL);


//void mcsWait(Env* env);


#define MCS_CUSTOM_USER(CLASS)                                        \
class CLASS : public mcs::UserThread                          \
{                                     \
public:                                   \
    CLASS(mcs::Thread* p, int id, int sock) :                     \
    UserThread(p, id, sock) {}                        \
    ~CLASS() {}
#define MCS_CUSTOM_USER_END(CLASS)  };


#define MCS_CUSTOM_LOCAL(CLASS)                                       \
class CLASS : public mcs::LocalThread                     \
{                                     \
public:                                   \
    CLASS(mcs::Thread* p) :                                           \
    LocalThread(p) {}                             \
    ~CLASS() {}
#define MCS_CUSTOM_LOCAL_END(CLASS)  };


#define MCS_CUSTOM_SERVER(CLIENT, LOCAL)                              \
mcs::Server* newCustomServer(mcs::Env* env);                          \
                                      \
class mcsCustomServer : public mcs::Server                            \
{                                                     \
private:                                                              \
    mcs::UserThread* newUserThread(int id, int sock) {                \
    return new CLIENT(this, id, sock);                \
    }                                     \
                                      \
    mcs::LocalThread* newLocalThread() {                              \
    return new LOCAL(this);                           \
    }                                     \
                                      \
public:                                   \
    mcsCustomServer(mcs::Env* lenv): Server(lenv) {}              \
                                      \
    ~mcsCustomServer() {}                                             \
};                                                                    \
                                                                      \
mcs::Server* newCustomServer(Env* env)                                \
{  return new mcsCustomServer(env); }                                 \
                                                                      \
mcs::Env* mcsCustomStart(string appname, string inipath = "")         \
{ return mcsStart(appname, inipath, &newCustomServer); }



//--------------------------------------------------------------------
class Client :  public Socket, public RecordSet
{
protected:
  string lpath;

  bool connected;

  void clearRecords();

  bool writetofile;

  int fileDescriptor;

  bool fetch(unsigned int newpos, bool random);

  Record* lrecord;

  //Server side Client Identificator.
  int lcid;

  //Server side chunk size.
  int lchunksize;

public:
  MCS_MISSING_COPY_CONSTRUCTOR(Client);

  MCS_MISSING_ASSIGNMENT_OPERATOR(Client);


  Record code;

  Record msg;

  Record out;

  Record recv;

  Record aux;

  Client(string path, string server, int port=MCS_DEFAULT_PORT,
     bool synchro = false, bool SSL = false,
     unsigned int timeout = MCS_DEFAULT_CLIENT_TIMEOUT);

  virtual ~Client();


  bool login(string user, string pass, string db = "");

  bool exec(string cmd, Data* data = NULL);

  void writeToFile(int des);

#define MCS_CLIENT_ERROR       1
#define MCS_CLIENT_DATA        2
#define MCS_CLIENT_FILE        3
#define MCS_CLIENT_DISCONNECT  4
  virtual void event(int op, Data d, int code = 0);

  bool isConnected();

  int cid();

  int chunksize();
};



class Pipe {
private:
  Synchro synchro;

  static int filecount;

  string pipefn;

  int pipefd[2];

  bool flcreated;

  bool named;

public:
  Pipe();

  ~Pipe();

  bool isReady();

  string filename();


  bool consumerHasGone();


  void create();

  string createNamed();

  int openRead();

  int openWrite();

  void closeRead();

  void closeWrite();
};





#if ENABLE_CURL

class URLReader : Pipe
{
private:
  static bool fl_curl_global_init;

  string lurl;

  bool local;

  static size_t cb_write(void *ptr, size_t size, size_t nmemb, void *This);

  ThreadFunc* thr;
  static int thread_run(void* p);
  void thread_fetch();

protected:
  virtual unsigned int Write(void *ptr, unsigned int size, unsigned int nmemb);

  void flush();

public:
  URLReader();

  virtual ~URLReader();

  int OpenAsFD(string url);

  const char* OpenAsFifo(string url);

  void Download(string url, string fn);


  int Read(char* buf, int maxlen);

  void Close();

  string url();

  //Event* thread_error();

  static bool chkLocal(string& url);
};
#endif



#if ENABLE_CFITSIO

class FITSReader:  public RecordSet
{
private:
  void* fptr;
  long int nrows;
  int ncols;
  bool local;
  int nhdu;
  bool fetch(unsigned int newpos, bool random);

  Buffer memfile;
  void*  memfilep;
  size_t memfilesize;

public:
  FITSReader();
  ~FITSReader();

  void open(Buffer& buf);
  void open(string fn);
  void close();

  Record header;
  Record header_comments;

  void selectHDU(int hdunum);
  bool selectNextHDU();

  void selectHDU(string name, int extver = 0);
  int currentHDU();
  int HDUCount();

  bool ffile_is_compressed(string fn);

  void read_json_header(const string& json_string);
};


class FITSWriter:  public Record
{
private:
  void* fptr;

public:
  FITSWriter();
  ~FITSWriter();

  void open(string fn, bool compressed = false);
  void close();

  void newKeyword(string key, string value, string comment = "");
  void newBinTable(Record& meta, string name = "");
  void newAsciiTable(int nfields, string name = "");
  void newImage(Types bitpix, unsigned int naxis, unsigned int naxes,
        void* buf, string name = "");

  //The "buf" parameter is used only to write a image HDU.
  void write(void* buf);
};
#endif //ENABLE_CFITSIO


//class FileReader : public RecordSet
//{
//private:
//  URLReader input;
//  int fd;
//
//  Record master;
//  string sep;
//  string eor;
//
//  Buffer buf;
//
//  bool fetch(unsigned int newpos, bool random);
//
//public:
//  FileReader();
//  ~FileReader();
//
//  void open(string url);
//  void close();
//
//  void setMaster(Record& rec);
//  void setMaster(Record& rec, string sep);
//  void setMaster(Record& rec, string sep, string eor);
//};



#define MCS_B64_DEF_LINE   72
#define MCS_B64_MIN_LINE    4

#define MCS_B64_ENCODE         0
#define MCS_B64_DECODE         1
#define MCS_B64_DECODEINPLACE  2

class B64_Codec {
private:
  /*
  ** Translation Table as described in RFC1113
  */
  static const char* cb64;

  /*
  ** Translation Table to decode (created by author)
  */
  static const char* cd64;

  char* bufAllocated;

  unsigned int bufsize;

  void requireSpace(unsigned int Length);

  void freeBuffer();

  char* buf_out;

  unsigned int bufused;

  char* pin;

  char* pout;

  char* EOIB;

  unsigned int linesize;

  unsigned int blocksout;

  unsigned char precData[4];
  int precDataCount;

  bool eob();

  unsigned char readData();

  void writeData(unsigned char d);

  void encodeblock(unsigned char in[3], unsigned char out[4], int len);

  void decodeblock(unsigned char in[4], unsigned char out[3]);

public:

  B64_Codec();

  ~B64_Codec();

  //DO NOT SET par_buf_out = buf_in (sigsegv)

  unsigned int encode(char* buf_in, int Length, char* par_buf_out = NULL,
              unsigned int linesize = MCS_B64_DEF_LINE);

  //Decode may happen also in the same buffer (set par_buf_out =
  //buf_in).

  unsigned int decode(char* buf_in, int Length, char* par_buf_out = NULL);

  char* buffer();
  unsigned int bufUsed();
};



#define MCS_SELECT_READ 0
#define MCS_SELECT_WRITE 1


int Select(int fd, unsigned int sec_timeout, unsigned int usec_timeout, int op);
int Select(int fd[], int nfd, unsigned int sec_timeout, unsigned int usec_timeout, int op);



} //Namespace mcs
#endif //DEF_MCS_HH