/* $Id: DD_client.c,v 1.3 2009/04/14 08:37:28 budnik Exp $ */
/*==============================================================
* DD SYSTEM
* DD_client.c
* V.4.8
* List of changes:
* November 1995, Version 1.0
* August 1999 :Access security system was installed by Alexandr Grigoriev (v3.0)
* October 22, 2002 - Communication ideology is changed (V.4.0)
* Oct 29, 2002 - Add DD_GetVersion() and some bags are corrected (V.4.1)
* May 1, 2003 - Network error is developped. (The header receiving is changed): V.4.2
* Nov 18, 2004 - Cach error is fixed.
* Jun 17, 2007 - Fedorov, V.4.5 Create new VI and Update data requests
* Sep 24, 2007 - Fedorov, V.4.6 Processing of return of Get_Data
* Dec 03, 2007 - Budnik, V.4.7 There may be several sessions with DD Server inside ONE
* Client session. Keep UserHost & UserName
* Oct 18, 2012 - Knizhnikova, V.4.8 new DD_SetTimeInfo() function
*===============================================================*/
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "DD.hh"
#ifdef LOG4CXX
log4cxx::LoggerPtr DD_Client::_logger = log4cxx::Logger::getLogger(
"AMDA-Kernel.DD_Client");
#endif
/*------------------ GLOBAL STATIC VARIABLES --------------------------*/
//extern int errno;
/*================== FUNCTIONS =================================*/
/*----------------------- GET User Host-------------------------------*/
static size_t unixlen[] = {sizeof(char),sizeof(int),sizeof(float),sizeof(double),sizeof(short)};
static xdrproc_t ConvFunc[5] = {(xdrproc_t )xdr_char, (xdrproc_t )xdr_int, (xdrproc_t )xdr_float, (xdrproc_t )xdr_double, (xdrproc_t )xdr_short};
DD_Client:: DD_Client() :
idd (DD_CHAR, 0, NULL,1, (void**) malloc(sizeof(void*))),
CurrentData(NULL),
_varNumber(0),
SocketID( -1),
UserID(0),
m1(0X000000FF),
m2( 0X0000FF00),
m3(0X00FF0000),
m4( 0XFF000000),
//Host(NULL),
buffSetVarialbe(NULL),
bufDD_SetTime (NULL),
op(TIMESETREQ),
bufDD_GetData( NULL),
LastPacketFlag(OK),
bufDD_Close (NULL),
opDD_Close(CLOSEINSREQ),
bufDD_AddDataSet(NULL),
opDD_AddDataSet(ADDVIREQ),
Version(VERSION)
{
UserName[0] = '\0';
UserHost[0] = '\0';
RemSerName[0]='\0';
strcpy(TimeInt, "0000000000001000");
idd.Variables[0]=NULL;
}
int DD_Client::GetUserHost() {
int userid;
userid = getuid(); /* Get a client user ID */
#ifdef LOG4CXX
//LOG4CXX_DEBUG(_logger, "DD_Client::GetUserHost - UserId : " << userid);
#endif
/* UserHost can be set by extern WEB function in case of WEB communicatio,
* or it should be defined as local host if DD_client is installed at USER
* computer
*/
if (UserHost[0] == '\0') {
char HostName[HOSTNAMELENGTH];
gethostname(HostName, HOSTNAMELENGTH); /* Get a client host name */
struct sockaddr_in addr;
if (getInfoFromHostName(HostName,addr) != 0)
return NOHOST;
unsigned int b1, b2, b3, b4;
sscanf(inet_ntoa( addr.sin_addr), "%3u.%3u.%3u.%3u", &b1, &b2, &b3, &b4);
snprintf(UserHost, MAXHOSTLENGTH, "%03u.%03u.%03u.%03u", b1, b2, b3, b4);
#ifdef LOG4CXX
// LOG4CXX_DEBUG(_logger, "DD_Client::GetUserHost - UserHost : " << UserHost);
#endif
}
return userid;
}
void DD_Client::setUserHost(const char* host) {
snprintf(UserHost, MAXHOSTLENGTH, "%s", host);
#ifdef LOG4CXX
// LOG4CXX_DEBUG(_logger, "DD_Client::setUserHost - UserHost : " << UserHost);
#endif
}
void DD_Client::setUserName(const char* name) {
snprintf(UserName, USRLENGTH, "%s", name);
#ifdef LOG4CXX
// LOG4CXX_DEBUG(_logger, "DD_Client::setUserName - UserName : " << UserName);
#endif
}
int DD_Client::getInfoFromHostName(const char *hostName, struct sockaddr_in &addr)
{
struct addrinfo hints;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
hints.ai_protocol = 0;
hints.ai_canonname = NULL;
hints.ai_addr = NULL;
hints.ai_next = NULL;
struct addrinfo *result;
int s;
s = getaddrinfo(hostName, NULL, &hints, &result);
if (s != 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::getIpFromHostName - Cannot get ip from host name " << hostName);
#endif
return NOHOST;
}
struct sockaddr_in *h;
h = (struct sockaddr_in *) result->ai_addr;
memcpy(&addr,h,sizeof(struct sockaddr_in));
freeaddrinfo(result);
return 0;
}
/*-------------------------------------------------------------------*/
/*------------------ MAKE_CONNECTION ---------------------------*/
/*
* The function returns opened socket, ready to read and write
*/
int DD_Client::GetSocket()
/*
* Connect with remote server, and returns socket ID
* In case of error return error number according DD_comm.h
*/
{
/*-------- Variables for resource file -----------------*/
char rname[PATHLENGTH]; /* name of res file */
char line[PATHLENGTH];
char *path;
FILE *resfile; /* resource file */
/*---------- Variables for network ---------------------*/
int normaddr;
/*
*---------- Getting socket and its address ---------------------*/
/*---------------- HOST and PORT ------------------------------*/
if((path = getenv("DDPATH")) == NULL)
{
strcpy(rname,"DD.res");
}
else
{
strcpy(rname,path);
strcat(rname, "/DD.res");
}
/*
(void *)strcpy(rname,"./DD.res");
*/
if((resfile = fopen(rname,"r")) == NULL)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::GetSocket - Cannot find resource file " << rname);
#endif
fprintf(stderr,"No resource file, sorry\n");
exit(1);
}
fgets(RemSerName, PATHLENGTH-1, resfile);
fgets(line, PATHLENGTH-1, resfile);
fclose(resfile);
RemSerName[strlen(RemSerName)-1] = '\0';
sscanf(line,"%5d",&(normaddr));
/*---------------- END of FILE READING --------------------------*/
/*
*------- Trying to open socket with this address and name ---------
*/
if((SocketID = socket(AF_INET,SOCK_STREAM,PROTOCOL)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::GetSocket - Socket error ");
#endif
perror("Socket:"); return(-1);
}
/* Filling full internet address for socket "name"
* this address will be used to get communication point */
struct sockaddr_in IntAFAddr;
if (getInfoFromHostName(RemSerName,IntAFAddr) != 0)
return NOHOST;
IntAFAddr.sin_port = htons((uint16_t)normaddr); /* Conversion of the port number to
universal net form */
#ifdef LOG4CXX
//LOG4CXX_DEBUG(_logger, "DD_Client::GetSocket - HostName : " << RemSerName << " - IP : " << inet_ntoa(IntAFAddr.sin_addr) << " - Port : " << IntAFAddr.sin_port);
#endif
/* Connection to server socket on remote computer */
int errnum = connect(SocketID,(struct sockaddr *)&IntAFAddr,sizeof(struct sockaddr_in));
if(errnum < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::GetSocket - Connection to server socket error - " << strerror (errnum));
#endif
perror("connect");
return(-1);
}
/*
* Get Host name and Host ID for security application
*/
if((UserID = GetUserHost()) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::GetSocket - NOHOST error");
#endif
return(NOHOST);
}
return SocketID;
}
/*------------------- end of GetSocket ---------------------*/
/*==================== Receive From Net ======================*/
/*
* Smart buffered receiver
*/
int DD_Client::ReceiveFromNet(char *buf, int PacketSize)
{
int CurLength = 0;
do
{
int i = 0;
int cc = 0;
while(( (cc = recv(SocketID,buf+ CurLength,PacketSize - CurLength,0)) < 0) && (i < TRY)) i++;
if(cc <= 0) return -1;
CurLength = CurLength + cc;
} while(CurLength < PacketSize);
return 1;
}
/*------------------ Open Virtual Instrument -----------------------*/
/*
* If no connection, connect to server, then try to order data set and return
* ID if OK or ErrorNumber if not
*/
int DD_Client::DD_SetVariable(char *InstrName)
{
int InstrID; /* Instrumnet ID to return */
int Request = OPENINSREQ;
int hostlen,userlen;
char *PUserHost = UserHost, *PUserName = UserName;
char *pDDuser;
/* We need this because XDR works with adresses of pointers */
/* If there is no connection, try to get it */
if(SocketID < 0)
if((SocketID = GetSocket()) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetVariable - No connection");
#endif
return(NOCONNECTION);
}
/* Encoding request by XDR to buf */
/* Buffer and stream allocation */
buffSetVarialbe = (caddr_t)calloc(REQUESTLENGTH, 1);
xdrmem_create(&xdrs, buffSetVarialbe, REQUESTLENGTH, XDR_ENCODE);
xdr_int(&xdrs,&Request);
xdr_string(&xdrs, &InstrName, strlen(InstrName));
/* Send Open Virtual Instrument request */
if( send(SocketID,buffSetVarialbe,REQUESTLENGTH,0) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetVariable - Cannot open virtual instrument");
#endif
perror("DD_SetVariable:");
free(buffSetVarialbe);
xdr_destroy(&xdrs);
return(REQSENDERR);
}
xdrmem_create(&xdrs, buffSetVarialbe, REQUESTLENGTH, XDR_FREE);
/*-------- preparation an authorization request ----------------*/
if(UserName[0] == '\0') {
pDDuser = getenv ("DDUSER");
if (pDDuser != NULL) strcpy(UserName, pDDuser);
else {
strcpy(UserName,NONAME);
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetVariable - UserName is undefined");
#endif
}
}
hostlen = strlen(UserHost);
userlen = strlen(UserName);
xdrmem_create(&xdrs, buffSetVarialbe,REQUESTLENGTH, XDR_ENCODE);
xdr_int(&xdrs,&UserID);
xdr_string(&xdrs, &PUserHost, hostlen);
xdr_string(&xdrs, &PUserName, userlen);
//fprintf(stderr,"userid %d host %s DD_name %s\n",UserID,UserHost,UserName);
/* Send request */
if( send(SocketID,buffSetVarialbe,REQUESTLENGTH,0) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetVariable - Cannot send request");
#endif
perror("DD_Set_Variable:");
free(buffSetVarialbe);
xdr_destroy(&xdrs);
return(REQSENDERR);
}
free(buffSetVarialbe);
xdr_destroy(&xdrs);
/* Get reply */
buffSetVarialbe = (caddr_t)malloc(REPLYLENGTH);
/*
i=0;
while(((cc = recv(SocketID,buff,REPLYLENGTH,0)) < 0) && (i < TRY)) i++;
*/
if( ReceiveFromNet(buffSetVarialbe, REPLYLENGTH) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetVariable - Cannot receive from net");
#endif
perror("DD_SET_Variable:");
free(buffSetVarialbe);
return(REPLYRECERR);
}
xdrmem_create(&xdrs, buffSetVarialbe, REPLYLENGTH, XDR_DECODE);
xdr_int(&xdrs,&InstrID);
/* Free all */
free(buffSetVarialbe);
xdr_destroy(&xdrs);
return InstrID;
}
/*----------------------- DD_GetInform -----------------------------*/
/*
* Returns "OK" if OK, fill DD_Data structure
* Return negative value if error
*/
int DD_Client::DD_GetInform(int VarID,char *AttrName,DD_data_t **data)
{
XDR xdrs;
caddr_t bufDD_GetInform = NULL;
int length;
int op = DATAINFOREQ;
int type; /* type of information or error */
int DimNumbers;
int PacketSize;
u_int count;
u_int MaxNumber;
/*------------------- Empty static data ------------------------*/
if(idd.Dimensions != NULL)
{
free(idd.Dimensions);
idd.Dimensions = NULL;
}
if(idd.Variables[0] != NULL)
{
free(idd.Variables[0]);
idd.Variables[0] = NULL;
}
/*------------------ Check the Name length -----------------------*/
if(strlen(AttrName) > MAXVARLENGTH) length = MAXVARLENGTH;
else length = strlen(AttrName);
/*----------- Allocation of memory and stream --------------------*/
bufDD_GetInform = (caddr_t)calloc(REQUESTLENGTH,1);
xdrmem_create(&xdrs, bufDD_GetInform, REQUESTLENGTH, XDR_ENCODE);
/*------------------- Encoding the request ----------------------*/
xdr_int(&xdrs,&op);
xdr_int(&xdrs,&VarID);
xdr_string(&xdrs, &AttrName, length);
/*------------------------ Send request ---------------------------*/
if( send(SocketID,bufDD_GetInform,REQUESTLENGTH,0) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetInform - Cannot send request");
#endif
perror("DD_GetInform:");
free(bufDD_GetInform);
xdr_destroy(&xdrs);
return(REQSENDERR);
}
free(bufDD_GetInform);
xdr_destroy(&xdrs);
/*------------------------ Get reply header ------------------------*/
bufDD_GetInform = (caddr_t)malloc(REPLYLENGTH);
/*
i=0;
while(((cc = recv(SocketID,buf,REPLYLENGTH,0)) < 0) && (i < TRY)) i++;
if(cc < 0)
*/
if(( ReceiveFromNet(bufDD_GetInform, REPLYLENGTH)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetInform - Cannot receive from net");
#endif
perror("DD_GetInform:");
free(bufDD_GetInform);
return(REPLYRECERR);
}
xdrmem_create(&xdrs, bufDD_GetInform, REPLYLENGTH, XDR_DECODE);
xdr_int(&xdrs,&type);
if(type < 0)
{
free(bufDD_GetInform);
xdr_destroy(&xdrs);
return(type);
}
xdr_int(&xdrs,&DimNumbers);
xdr_int(&xdrs,&PacketSize);
free(bufDD_GetInform);
xdr_destroy(&xdrs);
idd.DimNumber = DimNumbers;
idd.type = type;
/*---------------------------- Get Data Packet ----------------------*/
if(PacketSize > 0) bufDD_GetInform = (caddr_t)malloc(PacketSize);
else
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetInform - Cannot Cannot get data packet");
#endif
return(REPLYRECERR);
}
if(( ReceiveFromNet(bufDD_GetInform, PacketSize)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetInform - Cannot receive from net");
#endif
perror("DD_GetInform:");
free(bufDD_GetInform);
return(REPLYRECERR);
}
/*--------------------- Decoding data packet ------------------------*/
if(DimNumbers > 0)
{
/*----------- Memory allocation and xdr creating -----------------*/
xdrmem_create(&xdrs, bufDD_GetInform, (u_int)PacketSize, XDR_DECODE);
/*----------------- Dimensions decoding -------------------------*/
if(idd.Dimensions !=NULL) free(idd.Dimensions);
idd.Dimensions = (int *)malloc(DimNumbers*sizeof(int));
xdr_array(&xdrs, (caddr_t *)&(idd.Dimensions),
&count,
(u_int )DimNumbers,
unixlen[DD_INT],
(xdrproc_t)xdr_int);
count = 1;
for(int i=0; i < DimNumbers;i++)
count = count*idd.Dimensions[i];
MaxNumber = count;
}
else
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetInform - Cannot decoding data packet");
#endif
free(bufDD_GetInform);
return(REPLYRECERR);
}
/*---------------- Allocate memory for Variables and decoding ------------------*/
if(idd.Variables[0] != NULL) free(idd.Variables[0]);
idd.Variables[0] = (int *)malloc(unixlen[type] * MaxNumber);
xdr_array(&xdrs,((caddr_t*)(&idd.Variables[0])),&count,
MaxNumber, unixlen[type], ConvFunc[type]);
/*-------------------------- Free all ------------------------------*/
free(bufDD_GetInform);
xdr_destroy(&xdrs);
*data = &idd;
return OK;
}
/*------------------- DD_SETTIME ------------------------------------*/
/*
* VarID - ID of Data Set
* Time - string in DD type
* Returns 1 if OK and negative in case of err
*/
int DD_Client:: DD_SetTime(int VarID,char *Time)
{
int type;
int DoneFlag = 0;
while(DoneFlag == 0)
{
/* Allocatein memory and stream */
bufDD_SetTime = (caddr_t)calloc(REQUESTLENGTH, 1);
xdrmem_create(&xdrsDD_SetTime, bufDD_SetTime, REQUESTLENGTH, XDR_ENCODE);
/* Encoding the request */
xdr_int(&xdrsDD_SetTime,&op);
xdr_int(&xdrsDD_SetTime,&VarID);
xdr_string(&xdrsDD_SetTime, &Time, TIMELENGTH);
/* Send request */
if(( send(SocketID,bufDD_SetTime,REQUESTLENGTH,0)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetTime - Cannot send request");
#endif
perror("DD_SetTime:");
free(bufDD_SetTime);
xdr_destroy(&xdrsDD_SetTime);
return(REQSENDERR);
}
free(bufDD_SetTime);
xdr_destroy(&xdrsDD_SetTime);
/* Get reply header */
bufDD_SetTime = (caddr_t)malloc(REPLYLENGTH);
if(( ReceiveFromNet(bufDD_SetTime, REPLYLENGTH)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetTime - Cannot receive from net");
#endif
perror("DD_SetTime:");
free(bufDD_SetTime);
return(REPLYRECERR);
}
xdrmem_create(&xdrsDD_SetTime, bufDD_SetTime, REPLYLENGTH, XDR_DECODE);
xdr_int(&xdrsDD_SetTime,&type);
free(bufDD_SetTime);
xdr_destroy(&xdrsDD_SetTime);
if(type < 0)
{
if(type == CACHTOOREC) sleep((unsigned )(FILEACCMARG));
else return type;
}
else DoneFlag = 1;
}
return 1 ;
}
/*------------------- DD_SETTIMEINFO ------------------------------------*/
/*
* VarID - ID of Data Set
* Time - string in DD type
* RealTime - double : time value pointer points to
* Returns 1 if OK and negative in case of err
*/
int DD_Client:: DD_SetTimeInfo(int VarID, char *Time, double *RealTime)
{
int err;
DD_data_t *data;
if ((err = DD_SetTime(VarID, Time)) < 0)
{
while ((err == WAITEXTCALL) || (err == TRYAGAIN))
{
sleep(2);
err = DD_SetTime(VarID, Time);
}
}
if (err < 1)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetTimeInfo - Cannot set time " << Time);
#endif
return err;
}
if ((err = DD_GetData(VarID, (char *)"Time", TimeInt, &data)) < 0)
{
while ((err == WAITEXTCALL) || (err == TRYAGAIN))
{
sleep(2);
err = DD_GetData(VarID, (char *)"Time", TimeInt, &data);
}
}
if (err < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetTimeInfo - Cannot get data " << Time);
#endif
return err;
}
if (data->VarNumber < 1)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_SetTimeInfo - OUTOFTIME error " << Time);
#endif
return OUTOFTIME;
}
*RealTime = DD_Time2Double((char *)data->Variables[0]);
//BRE - When the corresponding time is the last one of a file, MOREDATA is returned by DDServer.
// => force recall of DD_GetData to open the next file and finish correctly the request
if (err == MOREDATA)
{
if ((err = DD_GetData(VarID, (char *)"Time", TimeInt, &data)) < 0)
{
while ((err == WAITEXTCALL) || (err == TRYAGAIN))
{
sleep(2);
err = DD_GetData(VarID, (char *)"Time", TimeInt, &data);
}
}
}
return 1 ;
}
/*------------------------- DD_GETDATA --------------------------------*/
/*
* VarID - ID of open virtual instrument
* VarName - Variable name associated with this virtual instrument
* TimeInt - Time interval in DD_time style
* data - returned data
* Return values:
* positives:
* MOREDELAY - call this function again after delay
* MOREDATA - call this function again to complete request
* OK - all data received
* negative value - error (see DD.h)
*/
int DD_Client::DD_GetData(int VarID,char *VarName,char *TimeInt,DD_data_t **data)
{
char *xxx=VarName;
int err = DD_GetMultiData(VarID, 1, &xxx, TimeInt, data, 1);
return err;
}
/*------------------------- DD_GetMultiData() --------------------------------*/
/*---------------------------------------------------------
* VarID - ID of open virtual instrument
* VarSize - the size of the array names
* VarNames - array of the variables names
* TimeInt - Time interval in DD_time style
* data - returned data
* Return values:
* positives:
* MOREDELAY - call this function again after delay
* MOREDATA - call this function again to complete request
* OK - all data received
* negative value - error (see DD.h)
*/
int DD_Client::DD_GetMultiData(int VarID,size_t VarSize, char **VarNames,char *TimeInt,DD_data_t **data, int BackFlag)
{
size_t id;
int *NameLength = NULL; /* Array of lengths */
int XDRStrLen; /* xdr length of a string */
int XDRReqlength; // Length in bytes the XDR stream
int op = DATAGETREQ;
int type; /* type of information or error */
int DimNumbers;
int PacketSize;
u_int count, MaxSize=0;
int i;
/*--------------------------------------
* Create a new Current Data empty array
*-------------------------------------*/
for( int i = 0; i < _varNumber; ++i) {
CurrentData[i].clear();
}
delete[] CurrentData;
_varNumber = VarSize;
CurrentData = new DD_data_t[_varNumber];
/*--------------------------------------------------------------
* The follows request preparation and send is performed only
* if the priveous data packed is completely received
*--------------------------------------------------------------*/
if((LastPacketFlag == OK) || (LastPacketFlag == MOREDELAY))
{
/*---------------------------------------
* Preparation of the array the name lengths
* Note that the names are cut down to the MAXVARLENGTH
* Calculation the packet size
*---------------------------------------*/
NameLength = (int *)malloc(sizeof(int)*VarSize);
XDRReqlength = 8; /* the length of the first+last arguments */
for(id = 0; id < VarSize; id++)
{
if(strlen(VarNames[id]) > MAXVARLENGTH) NameLength[id] = MAXVARLENGTH;
else NameLength[id] = strlen(VarNames[id]);
XDRStrLen = (NameLength[id] / 4) * 4;
if((NameLength[id] % 4) > 0) XDRStrLen += 4;
XDRReqlength += XDRStrLen + 4; // String length + 4 bytes length coding
//fprintf(stderr,"Variable %s, length %d, total %d\n",VarNames[id],XDRStrLen,XDRReqlength);
}
/*--------------------------------
* The first packet of the request of the standard size
* Allocation corresponding memory and stream
*------------------------------*/
bufDD_GetData = (caddr_t)calloc(REQUESTLENGTH, 1);
xdrmem_create(&xdrsDD_GetData, bufDD_GetData, REQUESTLENGTH, XDR_ENCODE);
/* Encoding the request */
xdr_int(&xdrsDD_GetData,&op);
xdr_int(&xdrsDD_GetData,&VarID);
xdr_string(&xdrsDD_GetData,&TimeInt,TIMELENGTH);
xdr_int(&xdrsDD_GetData,&XDRReqlength);
/* Send the first request */
if(( send(SocketID,bufDD_GetData,REQUESTLENGTH,0)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetMultiData - Cannot send the first request");
#endif
perror("DD_GetData: First Request");
free(bufDD_GetData);
free(NameLength);
xdr_destroy(&xdrsDD_GetData);
return(REQSENDERR);
}
free(bufDD_GetData);
xdr_destroy(&xdrsDD_GetData);
/*--------------------------------
* The Second packet of XDRReqlength size
* Allocation corresponding memory and stream
*------------------------------*/
bufDD_GetData = (caddr_t)malloc(XDRReqlength);
xdrmem_create(&xdrsDD_GetData, bufDD_GetData, XDRReqlength, XDR_ENCODE);
xdr_int(&xdrsDD_GetData,(int *)(&VarSize));
for(id = 0; id < VarSize; id++) xdr_string(&xdrsDD_GetData, &VarNames[id], NameLength[id]);
free(NameLength);
NameLength = NULL;
xdr_int(&xdrsDD_GetData,&BackFlag);
/* Send the second request */
if(( send(SocketID,bufDD_GetData,XDRReqlength,0)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetMultiData - Cannot send the second request");
#endif
perror("DD_GetData:Second Packet");
free(bufDD_GetData);
xdr_destroy(&xdrsDD_GetData);
return(REQSENDERR);
}
free(bufDD_GetData);
xdr_destroy(&xdrsDD_GetData);
}
/*-----------------------------------------------------------
* Get the VarSize reply headers and VarSize data
*----------------------------------------------------------*/
for(id = 0; id < VarSize; id++)
{
/*-------------------
* The header
*-----------------*/
bufDD_GetData = (caddr_t)malloc(REPLYLENGTH);
if(( ReceiveFromNet(bufDD_GetData, REPLYLENGTH)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetMultiData - Cannot receive header");
#endif
perror("DD_GetData:Error while header receive");
free(bufDD_GetData);
return(REPLYRECERR);
}
xdrmem_create(&xdrsDD_GetData, bufDD_GetData, REPLYLENGTH, XDR_DECODE);
xdr_int(&xdrsDD_GetData,&type);
xdr_int(&xdrsDD_GetData,&DimNumbers);
xdr_int(&xdrsDD_GetData,&PacketSize);
free(bufDD_GetData);
xdr_destroy(&xdrsDD_GetData);
if (type < 0) /* Server returns unrecoverable error */
{
#ifdef LOG4CXX
LOG4CXX_DEBUG(_logger, "DD_Client::DD_GetMultiData - Server returns " << type << ", no data\n");
#endif
fprintf(stderr, "DD_GetData: Server returns %d, no data\n", type);
return type;
}
/*----------- Header is received ----------------------*/
CurrentData[id].DimNumber = DimNumbers - 1;
CurrentData[id].type = type;
/*--------------- Receive Data Packet ------------------------------*/
if(PacketSize > 0) bufDD_GetData = (caddr_t)malloc(PacketSize);
else
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetMultiData - Cannot receive data packet");
#endif
return(REPLYRECERR);
}
if((ReceiveFromNet(bufDD_GetData, PacketSize)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetMultiData - Cannot receive data packet from web");
#endif
perror("DD_GetData: Error while data packet receive");
free(bufDD_GetData);
return(REPLYRECERR);
}
/*----------------- Decoding data packet --------------------*/
if(DimNumbers > 1)
{
xdrmem_create(&xdrsDD_GetData, bufDD_GetData, (u_int)PacketSize, XDR_DECODE);
count = DimNumbers-1;
/* allocation memory for dimensions */
CurrentData[id].Dimensions = (int *)malloc((DimNumbers-1)*sizeof(int));
xdr_int(&xdrsDD_GetData,&LastPacketFlag); /* Last Paket Indicatort*/
xdr_int(&xdrsDD_GetData,&CurrentData[id].VarNumber); /* Variables number */
if(LastPacketFlag > 2)
{
LastPacketFlag = OK;
CurrentData[id].VarNumber = 0;
free(bufDD_GetData);
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetMultiData - Reply received error");
#endif
return(REPLYRECERR);
}
/*----- Decoding dimensions array -------------------*/
xdr_array(&xdrsDD_GetData, (caddr_t *)&(CurrentData[id].Dimensions),
&count,
(u_int )DimNumbers-1,
unixlen[DD_INT],
(xdrproc_t)xdr_int);
count = 1;
for(i=0; i < DimNumbers-1;i++)
{
count = count*CurrentData[id].Dimensions[i];
}
MaxSize = count;
}
else {
if (type != NOVAR) {
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_GetMultiData - Reply received error");
#endif
free (bufDD_GetData);
return (REPLYRECERR);
} else {
CurrentData[id].VarNumber = 0;
}
}
/*---------- Decoding variables -------------------------*/
if (CurrentData[id].VarNumber != 0) {
CurrentData[id].Variables = (void **) malloc(CurrentData[id].VarNumber * sizeof(void *));
} else {
CurrentData[id].Variables = NULL;
}
for(i = 0; i < CurrentData[id].VarNumber; i++)
{
CurrentData[id].Variables[i] = (void *)malloc(unixlen[type]*MaxSize);
count = MaxSize;
xdr_array(&xdrsDD_GetData,(caddr_t *)(&(CurrentData[id].Variables[i])),&count,MaxSize,unixlen[type], (xdrproc_t)ConvFunc[type]);
}
/* Free all */
free(bufDD_GetData);
xdr_destroy(&xdrsDD_GetData);
}
*data = CurrentData;
return(LastPacketFlag);
}
/*===================================================================*/
/*-------------------------- DD_CLOSE --------------------------------*/
/*
*
* VarID - entry point of ID table
* Returns 1 if OK or negative err
* Close Socket if no VarID more ( this information supplyed by server )
*/
int DD_Client:: DD_Close(int VarID)
{
int RemainedID; /* Server returns number of remained ID */
/* Allocatein memory and stream */
bufDD_Close = (caddr_t)calloc(REQUESTLENGTH, 1);
xdrmem_create(&xdrsDD_Close, bufDD_Close, REQUESTLENGTH, XDR_ENCODE);
/* Encoding the request */
xdr_int(&xdrsDD_Close,&opDD_Close);
xdr_int(&xdrsDD_Close,&VarID);
/* Send request */
if(( send(SocketID,bufDD_Close,REQUESTLENGTH,0)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_Close - Cannot send request " << VarID);
#endif
perror("DD_Close:");
free(bufDD_Close);
xdr_destroy(&xdrsDD_Close);
return(REQSENDERR);
}
free(bufDD_Close);
xdr_destroy(&xdrsDD_Close);
/* Get reply header */
bufDD_Close = (caddr_t)malloc(REPLYLENGTH);
/*
i = 0;
while(((cc = recv(SocketID,buf,REPLYLENGTH,0)) < 0) && (i < TRY)) i++;
if(cc < 0)
*/
if(( ReceiveFromNet(bufDD_Close, REPLYLENGTH)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_Close - Cannot receive from net " << VarID);
#endif
perror("DD_Close:");
free(bufDD_Close);
return(REPLYRECERR);
}
xdrmem_create(&xdrsDD_Close, bufDD_Close, REPLYLENGTH, XDR_DECODE);
xdr_int(&xdrsDD_Close,&RemainedID);
if(RemainedID< 0)
{
free(bufDD_Close);
xdr_destroy(&xdrsDD_Close);
return(RemainedID);
}
free(bufDD_Close);
xdr_destroy(&xdrsDD_Close);
if(RemainedID == 0)
{
shutdown(SocketID,2);
close(SocketID);
SocketID = -1;
/*
UserHost[0] = '\0';
UserName[0] = '\0';
*/
}
return(1);
}
DD_Client::~DD_Client() {
for( int i = 0; i < _varNumber; ++i) {
CurrentData[i].clear();
}
delete[] CurrentData;
}
/*------------------------------------------------------------------------------*/
/*=============== DATABASE UPDATE FUNCTIONS ====================================*/
/*------------------ DD_AddDataSet() -------------------------------------------*/
int DD_Client:: DD_AddDataSet(char *DataSetName, char *RemSetID, char *BaseName)
{
int Err; /* Server returns OK or NOEXEC */
int length;
int CloseFlag = 0;
/* If there is no connection, try to get it */
if(SocketID < 0)
{
if((SocketID = GetSocket()) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_AddDataSet - No connection");
#endif
return(NOCONNECTION);
}
CloseFlag = 1; // To close Connection at the end
}
/* Allocatein memory and stream */
bufDD_AddDataSet = (caddr_t)malloc(REQUESTLENGTH);
xdrmem_create(&xdrsDD_AddDataSet, bufDD_AddDataSet, REQUESTLENGTH, XDR_ENCODE);
/* Encoding the request */
xdr_int(&xdrsDD_AddDataSet,&opDD_AddDataSet);
/* Coding DataSetName */
if((length = strlen(DataSetName)) > MAXSETLENGTH) length = MAXSETLENGTH;
xdr_string(&xdrsDD_AddDataSet, &DataSetName, length);
/* Coding RemSetID */
if((length = strlen(RemSetID)) > MAXVARLENGTH) length = MAXVARLENGTH;
xdr_string(&xdrsDD_AddDataSet, &RemSetID, length);
/* Coding BaseName */
if((length = strlen(BaseName)) > MAXVARLENGTH) length = MAXVARLENGTH;
xdr_string(&xdrsDD_AddDataSet, &BaseName, length);
/* Send request */
if(( send(SocketID,bufDD_AddDataSet,REQUESTLENGTH,0)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_AddDataSet - Cannot send request");
#endif
perror("DD_AddDataSet:");
free(bufDD_AddDataSet);
xdr_destroy(&xdrsDD_AddDataSet);
return(REQSENDERR);
}
free(bufDD_AddDataSet);
xdr_destroy(&xdrsDD_AddDataSet);
/* Get reply header */
bufDD_AddDataSet = (caddr_t)malloc(REPLYLENGTH);
if(( ReceiveFromNet(bufDD_AddDataSet, REPLYLENGTH)) < 0)
{
#ifdef LOG4CXX
LOG4CXX_ERROR(_logger, "DD_Client::DD_AddDataSet - Cannot receive from net");
#endif
perror("DD_AddDataSet:");
free(bufDD_AddDataSet);
return(REPLYRECERR);
}
xdrmem_create(&xdrsDD_AddDataSet, bufDD_AddDataSet, REPLYLENGTH, XDR_DECODE);
xdr_int(&xdrsDD_AddDataSet,&Err);
if(CloseFlag) // Close everything if function established connection
{
shutdown(SocketID,2);
close(SocketID);
SocketID = -1;
/* Session with DD Server was closed, but User Session continues !!!!! */
/* UserHost[0] = '\0';
UserName[0] = '\0'; */
}
return Err;
}
/*-----------------------------------------------------------------------------*/
/*---------------------- DD GET VERSION ---------------------------------------*/
const char *DD_Client:: DD_GetVersion()
/*
* return static pointer to internal string with the DDLIB-SERVER package version
*/
{
return Version;
}
/*------------------------- End Library -------------------------------*/