---

dataclient.cc

Go to the documentation of this file.

//**************************************************************************
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include "dataclient.h"
#include "errcode.h"
//**************************************************************************
DataClient::DataClient()
{
keytable = new KeyTable;
connected = false;
portnum = 0;
strcpy(servername, "");
}
//**************************************************************************
DataClient::DataClient(char *host, int port)
{
keytable = new KeyTable;
connected = false;
portnum = 0;
strcpy(servername, "");
Connect(host, port);
}
//**************************************************************************
DataClient::~DataClient()
{
Disconnect();
delete keytable;
}
//**************************************************************************
int DataClient::Connect(char *host, int port)
{
//trap_sigpipe();
signal(SIGPIPE, SIG_IGN);
signal(SIGABRT, SIG_IGN);

if (!TCPSocket::Connect(host, port))
        {
//       cout << "Retrying after 5 seconds." << endl;
//       mySleep(5*1000000);
         return POSSE_RETRY;
        }

int a;
try
        {
         SendClientName();
         int size = QueryKeyword("_start_private");
         a = RecvVar<int>();
        }
catch (int &e)
        {
         if (e == ERR_RECV_MESG)
                {
#ifdef ANIDEBUG
                 cerr << "DataClient: Error: Initialization failed!! " << endl;
                 cerr << "\tNo DataServer listening on " << host << ":" << port << endl << flush;
                 cerr << "\tExiting!" << endl;
#endif
                }
         return POSSE_FAILURE;
        }

if (a != VERIFICATION_NUMBER)
        {
         cerr << "DataClient: Error: Initialization failed!! ";
         cerr << "[Recd " << a << ", expected " << VERIFICATION_NUMBER << "]!" << endl << flush;
         cerr << "\tExiting!" << endl;
         return POSSE_FAILURE;
        }

RecvKeyTable(keytable);

connected = true;
portnum = port;
strcpy(servername, host);

return POSSE_SUCCESS;
}
//**************************************************************************
int DataClient::Disconnect()
{
int a = 0;
if (connected)
        {
         try {
                a = SendKeyword("_q_private");
                TCPSocket::Close();
                }
         catch (int &err)
                {
                 cout << "DataClient::Disconnect(): Caught exception!!" << endl << flush;
                }
        }
portnum = 0;
strcpy(servername, "");
return a;
}
//**************************************************************************
int DataClient::RecvKeyTable(KeyTable *K)
{
if (K == NULL)
        K = keytable;
SendKeyword("keytable");
RemoteSocket::RecvStruct(K);
return 1;
}
//**************************************************************************
VariableType DataClient::VarType(char *keyword)
{
int handle = keytable->getKeyHandle(keyword);
if (handle == keytable->n)
        {
         cout << "Error: Unknown keyword \"" << keyword << "\"!!" << endl << flush;
         return UNKNOWN;
        }

return keytable->key[handle].vartype;
}
//**************************************************************************
char *DataClient::RecvValue(char *keyword)
{
char *val = new char[100];
VariableType vtype = UNKNOWN;

int handle = keytable->getKeyHandle(keyword);
if (handle < keytable->n && keytable->isViewableVar(handle))
        vtype = keytable->key[handle].vartype;

switch (vtype)
        {
         case CHAR:
                if (keytable->isCharArray(handle))
                        {
                         char s[100];
                         RecvArray(keyword, s);
                         memcpy(val, s, 99);
                         val[99] = '\0';
                        }
                else
                        {
                         char x_char;
                         RecvVariable(keyword, &x_char);
                         sprintf(val, "%c\0", x_char);
                        }
                break;

         case SHORT:
                short x_short;
                RecvVariable(keyword, &x_short);
                sprintf(val, "%d\0", x_short);
                break;

         case INT:
                int x_int;
                RecvVariable(keyword, &x_int);
                sprintf(val, "%d\0", x_int);
                break;

         case LONG:
                long x_long;
                RecvVariable(keyword, &x_long);
                sprintf(val, "%ld\0", x_long);
                break;

         case FLOAT:
                float x_float;
                RecvVariable(keyword, &x_float);
                sprintf(val, "%g\0", x_float);
                break;

         case DOUBLE:
                double x_double;
                RecvVariable(keyword, &x_double);
                sprintf(val, "%g\0", x_double);
                break;

         default:       // case UNKNOWN:
                strcpy(val, "error");
                break;
        }
        
return val;
}
//**************************************************************************
int DataClient::SendValue(char *keyword, char *value)
{
int handle = keytable->getKeyHandle(keyword);

if (handle == keytable->n)
        {
         cout << "Error: Keyword \"" << keyword << "\" not found!" << endl << flush;
         return POSSE_INVALID_KEY;
        }

if (!keytable->isViewableVar(handle))
        {
         cout << "Error: Keyword \"" << keyword << "\" not a valid Variable!" << endl << flush;
         return POSSE_INVALID_VARIABLE;
        }

if (!isWritable(keytable->key[handle].key))
        {
         return POSSE_READONLY_KEY;
        }

switch (keytable->key[handle].vartype)
        {
         case CHAR:
                if (keytable->isCharArray(handle))
                        {
                         SendArray(keyword, value);
                        }
                else
                        {
                         char x_char;
                         sscanf(value, "%c", &x_char);
                         SendVariable(keyword, x_char);
                        }
                break;


         case SHORT:
                short x_short;
                sscanf(value, "%d", &x_short);
                SendVariable(keyword, x_short);
                break;

         case INT:
                int x_int;
                sscanf(value, "%d", &x_int);
                SendVariable(keyword, x_int);
                break;

         case LONG:
                long x_long;
                sscanf(value, "%ld", &x_long);
                SendVariable(keyword, x_long);
                break;

         case FLOAT:
                float x_float;
                sscanf(value, "%f", &x_float);
                SendVariable(keyword, x_float);
                break;

         case DOUBLE:
                double x_double;
                sscanf(value, "%lf", &x_double);
                SendVariable(keyword, x_double);
                break;

         default:       // case UNKNOWN:
                cout << "Error: Undefined type for keyword \"" << keyword << "\"!!" << endl << flush;
                return -3;
                break;
        }
        
return POSSE_SUCCESS;
}
//**************************************************************************
void DataClient::ListKeywords()
{
keytable->List();
}
//**************************************************************************
void DataClient::ListValues()
{
RecvKeyTable(keytable);
keytable->ListValues();
}
//**************************************************************************
KeyTable *DataClient::GetTable()
{
return keytable;
}
//**************************************************************************
bool DataClient::isValidKeyword(char *keyword, int *handle)
{
#ifdef ANIDEBUG
cout << "DataClient::isValidKeyword: Checking for validity of keyword \"" << keyword << "\"." << endl << flush;
#endif
int i = keytable->getKeyHandle(keyword);
if (handle)
        *handle = i;
if (i == keytable->n)
        {
         cout << "Error!! Server does not identify keyword \"" << keyword << "\"!!" << endl << flush;
         return false;
        }
return true;
}
//**************************************************************************
bool DataClient::isWritable(int handle)
{
if (!keytable->isWritable(handle))
        {
         cout << "Error!! Data for keyword \"" << keytable->key[handle].key << "\" cannot be modified. ";
         cout << "It is marked READ-ONLY by the server!" << endl << flush;
         return false;
        }
return true;
}
//**************************************************************************
bool DataClient::isWritable(char *keyword)
{
int handle = keytable->getKeyHandle(keyword);
if (handle < keytable->n)
        return isWritable(handle);
return false;
}
//**************************************************************************
bool DataClient::isVariable(int handle)
{
int size = keytable->key[handle].elem_size;
if (!keytable->isVar(handle))
        {
         cout << "Error!! Incompatible data types for keyword \"" << keytable->key[handle].key << "\"!!" << endl;
         cout << "\tServer expects a \"" << keytable->key[handle].description << "\" of type \"" << keytable->key[handle].type << "\"." << endl;
         cout << "\tClient expects a \"Variable\"!!" << endl << flush;
         return false;
        }
return true;
}
//**************************************************************************
bool DataClient::VerifyElementSize(int handle, int elem_size)
{
int size = keytable->key[handle].elem_size;
if (size != elem_size)
        {
         cout << "Error!! Incompatible element type for keyword \"" << keytable->key[handle].key << "\"!!" << endl;
         cout << "\tServer expects element of type \"" << keytable->key[handle].type << "\" [" << size << " bytes]." << endl;
         cout << "\tClient expects element of size " << elem_size << " bytes!!" << endl << flush;
         return false;
        }
return true;
}
//**************************************************************************
bool DataClient::SendKeyword(char *keyword)
{
#ifdef ANIDEBUG
cout << "DataClient::SendKeyword: Sending keyword \"" << keyword << "\"." << e
ndl << flush;
#endif

SendLine(keyword);

return true;
}
//**************************************************************************
bool DataClient::SendKeyForDataSend(int handle)
{
#ifdef ANIDEBUG
cout << "DataClient::SendKeyForDataSend: Sending key \"" << keytable->key[handle].key << "\" to server." << endl << flush;
#endif
if (!isWritable(handle)) return false;

char key[100];
key[0] = 'R';
strcpy(&key[1], keytable->key[handle].key);
SendLine(key);

return true;
}
//**************************************************************************
bool DataClient::SendKeyForDataSend(char *keyword)
{
int handle = keytable->getKeyHandle(keyword);
if (handle < keytable->n)
        return SendKeyForDataSend(handle);
return false;
}
//**************************************************************************
int DataClient::RecvDummyBytes(int size)
{
cout << endl;   
cout << "Receiving " << size << " bytes of dummy data before exiting." << endl;
cout << flush; 
        
unsigned char *data; 
ALLOC1D(&data, size);
RecvBytes(size, data);
FREE1D(&data, size);

Release();
return 0;
}
//**************************************************************************
bool DataClient::isBigEndian()
{
int size = QueryKeyword("_isBigEndian");
int val = RecvVar<int>();
return (val == 1);
}
//**************************************************************************
int DataClient::SendClientName()
{
char hostname[200];
gethostname(hostname,200);
SendLine(hostname);

return 0;
}
//**************************************************************************
bool DataClient::isDynamicArray(int handle, int dim)
{
bool result = (keytable->key[handle].description == DYNAMIC_1D_ARRAY+dim-1);

if (!result)
        {
         cout << "Error!! Incompatible data type for keyword \"" << keytable->key[handle].key << "\"!!" << endl;
         cout << "\tServer expects a \"" << keytable->Description(handle) << "\" of type \"" << keytable->key[handle].type << "\"." << endl;
         cout << "\tClient expects a \"Dynamic " << dim << "D Array\"!!" << endl << flush;
        }
return result;
}
//**************************************************************************
int DataClient::getArrayDim(char *keyword, int dim)
{
int handle;
int err = ERR_BAD_DATA;
if (!isValidKeyword(keyword, &handle)) throw err;
if (!strstr(keytable->Description(handle), "Dynamic"))
        {
         cout << "DataClient::getArrayDim: Error!!" << endl;
         cout << "\t\"" << keyword << "\" is non-dynamic array!!" << endl << flush;
         exit(-1);
         throw err;
        }
int ndims = keytable->key[handle].description-DYNAMIC_1D_ARRAY+1;;

if (dim > ndims)
        {
         cout << "DataClient::getArrayDim: Error!!" << endl;
         cout << "\tDimension " << dim << " requested for a " << ndims << "D array!" << endl << flush;
         throw err;
        }

char key[100];
sprintf(key, "%s_dim%d", keyword, dim);

return RecvVariable<int>(key);
}
//**************************************************************************

---