336 lines
10 KiB
C++
336 lines
10 KiB
C++
#include "cliever-md.h"
|
|
#include "masterDaemon.h"
|
|
#include "Listener.cpp"
|
|
#include "EventSender2.cpp"
|
|
using namespace std;
|
|
|
|
/*! \brief Client object implementatios
|
|
*
|
|
*/
|
|
|
|
int getHandle() {
|
|
|
|
map<int,mdACClient*>::iterator it;
|
|
|
|
bool collision = thisConfig->allClients.size() > 0 ? false: true, found;
|
|
int value; srand ( time(NULL) );
|
|
|
|
value = (rand() % (MAX_DEVICE * 10)) + 1;
|
|
|
|
while(collision) {
|
|
for(found = false, it = thisConfig->allClients.begin();
|
|
it != thisConfig->allClients.end() && !found;
|
|
found = (it->first == value ? true : false), it++);
|
|
if (!found) collision = false;
|
|
else value = (rand() % (MAX_DEVICE * 10)) + 1;
|
|
|
|
}
|
|
return value;
|
|
|
|
}
|
|
template<class T> T* mdHost<T>::registeR(md_device t) {
|
|
|
|
T *value=NULL;
|
|
int h = getHandle();
|
|
|
|
if (value=mdHost<T>::validateClient(h)) {
|
|
theseLogs->logN(2,"Handle %d assigned to new client of type: %s",clientTypes[t]);
|
|
} else {
|
|
theseLogs->logN(2,"Validation failed for client type: %s",clientTypes[t]);
|
|
return value;
|
|
}
|
|
|
|
value->handle = h;
|
|
value->create();
|
|
thisConfig->allClients[h] = value; // validateClient has already added to group
|
|
return value ;
|
|
|
|
}
|
|
template<class T>
|
|
void mdHost<T>::registrY(T *device, std::string fullText) {
|
|
|
|
T *target = device;
|
|
char *ip,*port,*command,*timeout,*argv[5];
|
|
|
|
argv[1] = ip = (char *)malloc(32);
|
|
argv[2] = port = (char *)malloc(16);
|
|
argv[3] = timeout = (char *)malloc(32);
|
|
argv[4] = command = (char *)malloc(1024);
|
|
|
|
sprintf(ip,"--ip %s",target->ip.c_str());
|
|
sprintf(port,"--port %s",target->port.c_str());
|
|
sprintf(timeout,"--timeout %s",target->timeout.c_str());
|
|
sprintf(command,"--scpi %s",fullText.c_str());
|
|
|
|
vendor = fullText;
|
|
|
|
free(ip);
|
|
free(port);
|
|
free(timeout);
|
|
free(command);
|
|
|
|
}
|
|
mdClientServer* mdClientServer::validateClient(int handle, mdResponse &r) {
|
|
|
|
bool isNew=true;
|
|
int i,m=-1,n=-1;
|
|
mdClientServer *value=NULL;
|
|
|
|
if (!thisConfig->nClievers) {m =0; isNew = true;}
|
|
else for(i=0;i<MAX_CLIEVER && isNew;i++)
|
|
{if (m < 0 && thisConfig->clievers[i].empty()) m = i;
|
|
if (ip.address().to_string() == thisConfig->clievers[i]) isNew = false;
|
|
}
|
|
|
|
if (isNew && thisConfig->nClievers < MAX_CLIEVER)
|
|
{ for (n=i=0;i<thisConfig->nClievers && n < 0;i++)
|
|
if (!thisConfig->cliever[i]) n = i;
|
|
thisConfig->nClievers++;
|
|
thisConfig->cliever[n] = value = this;
|
|
mdStdDevIdx = n + 1;
|
|
ip = r.ip;
|
|
thisConfig->clievers[n] = ip.address().to_string();
|
|
}
|
|
else {
|
|
theseLogs->logN(1,"Either a Cliever already active at %s or limit number (%d) reached.",ip.address().to_string().c_str(),MAX_CLIEVER);
|
|
}
|
|
return value;
|
|
|
|
}
|
|
mdMachine* mdMachine::validateClient(int handle, const mdClientBirth &c, mdResponse &r) {
|
|
|
|
char *cp;
|
|
mdMachine *value=NULL;
|
|
|
|
if (!theMachine) {
|
|
if (c.dg.hdr.dgType.clieverGroup) {
|
|
theseLogs->logN(1,"Machine specified non-zero cliever group(%d) in GDOLMS 1.x, rejected.",c.dg.hdr.dgType.clieverGroup);
|
|
goto done;
|
|
}
|
|
if (!thisConfig->cliever[c.dg.hdr.dgType.clieverGroup]) {
|
|
theseLogs->logN(1,"The cliever for this device group (%d) is not online, machine birth rejected.",c.dg.hdr.dgType.clieverGroup);
|
|
goto done;
|
|
}
|
|
strcpy(r.reply.dg.payLoad,thisConfig->clievers[c.dg.hdr.dgType.clieverGroup].c_str());
|
|
cp = &r.reply.dg.payLoad[0] + strlen(r.reply.dg.payLoad) + 1;
|
|
*((unsigned short *)cp) = thisConfig->cliever[c.dg.hdr.dgType.clieverGroup]->ip.port();
|
|
theMachine = value = this;
|
|
mdStdDevIdx = MAX_CLIEVER + 1;
|
|
}
|
|
|
|
done:
|
|
return value;
|
|
|
|
}
|
|
mdPeer* mdPeer::validateClient(int handle, const mdClientBirth &c, mdResponse &r) {
|
|
|
|
mdPeer *value=NULL;
|
|
|
|
if (thisConfig->allEPPPeers.size() < MAX_PEER) {
|
|
thisConfig->allEPPPeers[handle] = value = this;
|
|
// mdStdDevIdx =
|
|
}
|
|
else theseLogs->logN(1,"Too many EPP Servers, configured limit is: %d.",MAX_PEER);
|
|
|
|
return value;
|
|
|
|
}
|
|
std::string mdHostFabrik::newFromAPI(md_device type,std::string thisSpecialOne) {
|
|
// stub for XMLRPC/APIG dynamic API
|
|
}
|
|
void mdHostFabrik::newFromHeartbeat(const mdClientBirth &thisOne) {
|
|
|
|
const char *kind,*outcome;
|
|
void *resultat;
|
|
|
|
int i,mdStdDevIdx;
|
|
md_device thisKind;
|
|
mdCB *newControlBlock;
|
|
mdACClient *newAllMap;
|
|
mdClientServer *newCliever;
|
|
mdMachine *newMachine;
|
|
mdPeer *newEPPServer;
|
|
mdResponse *result = new mdResponse(thisService->bg,thisOne.ip);
|
|
|
|
int maybe=getHandle();
|
|
|
|
result->dCat = MD_NEWBORN;
|
|
result->reply.dg.hdr = thisOne.dg.hdr;
|
|
result->reply.dg.hdr.dgType.isAckNak = true;
|
|
result->reply.dg.hdr.dgType.value = true;
|
|
result->ip = thisOne.ip;
|
|
|
|
switch(thisOne.dg.hdr.clientType) {
|
|
case MDDEV_CD:
|
|
thisKind = MDDEV_CD;
|
|
kind = "cliever";
|
|
newCliever = new mdClientServer();
|
|
if (resultat = newCliever = newCliever->validateClient( maybe, *result )) {
|
|
newCliever->ip = thisOne.ip;
|
|
mdStdDevIdx = newCliever->mdStdDevIdx;
|
|
}
|
|
else delete newCliever;
|
|
break;
|
|
case MACHINE:
|
|
thisKind = MACHINE;
|
|
kind = "machine";
|
|
newMachine = new mdMachine();
|
|
if (resultat = newMachine = newMachine->validateClient( maybe, thisOne, *result )) {
|
|
theMachine = newMachine;
|
|
newMachine->ip = thisOne.ip;
|
|
mdStdDevIdx = MAX_CLIEVER + thisOne.dg.hdr.dgType.clieverGroup;
|
|
}
|
|
else delete newMachine;
|
|
break;
|
|
case MDDEV_PEER:
|
|
thisKind = MDDEV_PEER;
|
|
kind = "EPP Server";
|
|
newEPPServer = new mdPeer();
|
|
if (!(resultat = newEPPServer = newEPPServer->validateClient( maybe, thisOne, *result )))
|
|
delete newEPPServer;
|
|
else {newEPPServer->ip = thisOne.ip;
|
|
for (i=0;i<MAX_PEER && thisService->eppPeers[i];i++);
|
|
thisService->eppPeers[i] = maybe;
|
|
mdStdDevIdx = 2+i;
|
|
}
|
|
break;
|
|
}
|
|
|
|
outcome = resultat ? "succeeded" : "failed";
|
|
theseLogs->logN(2,"The %s instantiation request %s.",kind,outcome);
|
|
|
|
if (!resultat) { result->reply.dg.hdr.dgType.value = false;
|
|
result->mdStdDevIdx = MDDEV_MD;
|
|
}
|
|
else { newAllMap = new mdACClient();
|
|
newAllMap->devType = thisKind;
|
|
newAllMap->mdStdDevIdx = mdStdDevIdx;
|
|
thisConfig->allClients[maybe] = newAllMap;
|
|
result->reply.dg.hdr.sinkHandle = maybe;
|
|
result->mdStdDevIdx = mdStdDevIdx;
|
|
cb[mdStdDevIdx] = newControlBlock = new mdCB;
|
|
newControlBlock->handle = maybe;
|
|
}
|
|
|
|
result->send();
|
|
|
|
}
|
|
void mdMachine::registerCmd(const char *cmdName,const mdIncoming &thisOne) {
|
|
|
|
const char *msg;
|
|
char *name;
|
|
int value = OK;
|
|
std::string arg = std::string(cmdName);
|
|
std::map<int,mdACClient*>::iterator iter = thisConfig->allClients.find(thisOne.dg.hdr.handle);
|
|
mdResponse *result = new mdResponse(thisService->bg,thisOne.ip);
|
|
|
|
result->reply.dg.hdr = thisOne.dg.hdr;
|
|
result->dCat = DV_MDQUERY;
|
|
|
|
if( iter == thisConfig->allClients.end() ) {
|
|
theseLogs->logN(1,"Cmd reg for device whose handle (%d) absent, ignored.", thisOne.dg.hdr.handle );
|
|
value = MDERR_NOTREADY;
|
|
goto done;
|
|
}
|
|
|
|
result->mdStdDevIdx = iter->second->mdStdDevIdx;
|
|
|
|
if (cmds.empty()) {
|
|
theseLogs->logN(1,"attempt to register '%s' but device not ready to accept command registration.",cmdName);
|
|
value = MDERR_NOTREADY;
|
|
goto done;
|
|
}
|
|
|
|
if( cmds.find(arg) == cmds.end() ) {
|
|
theseLogs->logN(1,"attempt to register '%s' whose rules has not yet been defined.",cmdName);
|
|
value = MDERR_MISSING;
|
|
goto done;
|
|
}
|
|
|
|
// Currently presumes SCPI.
|
|
|
|
if (cmds[arg]->getHandler())
|
|
{value = MDERR_CONFLICT; goto done;}
|
|
else{
|
|
cmds[arg]->setHandler(cmds[arg]);
|
|
result->reply.dg.hdr.dgSubType = MDDG_REGSCPI;
|
|
}
|
|
|
|
done:
|
|
|
|
if (value == OK) {
|
|
msg = cmdName;
|
|
result->reply.dg.hdr.dgType.value = 1;
|
|
}
|
|
else msg = thisConfig->err[value];
|
|
|
|
result->reply.dg.hdr.msgType = MDDG_MDQUERY;
|
|
name = (char *)(&result->reply.dg.payLoad[0] + result->reply.dg.hdr.primeOffset);
|
|
|
|
strcpy(name,msg);
|
|
result->reply.dg.hdr.payloadSize = result->reply.dg.hdr.primeOffset + strlen(name) + 1;
|
|
result->send();
|
|
|
|
}
|
|
//
|
|
// TODO: figure out how to avoid this duplication in gcc and msvc 10.
|
|
//
|
|
void mdPeer::registerCmd(const char *cmdName,const mdIncoming &thisOne) {
|
|
|
|
const char *msg;
|
|
char *name;
|
|
int value = OK;
|
|
std::string arg = std::string(cmdName);
|
|
std::map<int,mdACClient*>::iterator iter = thisConfig->allClients.find(thisOne.dg.hdr.handle);
|
|
mdResponse *result = new mdResponse(thisService->bg,thisOne.ip);
|
|
|
|
result->reply.dg.hdr = thisOne.dg.hdr;
|
|
result->dCat = DV_MDQUERY;
|
|
|
|
if( iter == thisConfig->allClients.end() ) {
|
|
theseLogs->logN(1,"Cmd reg for device whose handle (%d) absent, ignored.", thisOne.dg.hdr.handle );
|
|
value = MDERR_NOTREADY;
|
|
goto done;
|
|
}
|
|
|
|
result->mdStdDevIdx = iter->second->mdStdDevIdx;
|
|
|
|
if (cmds.empty()) {
|
|
theseLogs->logN(1,"attempt to register '%s' but device not ready to accept command registration.",cmdName);
|
|
value = MDERR_NOTREADY;
|
|
goto done;
|
|
}
|
|
|
|
if( cmds.find(arg) == cmds.end() ) {
|
|
theseLogs->logN(1,"attempt to register '%s' which has no rules basis.",cmdName);
|
|
value = MDERR_MISSING;
|
|
goto done;
|
|
}
|
|
|
|
// Currently presumes SCPI.
|
|
|
|
if (cmds[arg]->getHandler())
|
|
{value = MDERR_CONFLICT; goto done;}
|
|
else{
|
|
cmds[arg]->setHandler(cmds[arg]);
|
|
result->reply.dg.hdr.dgSubType = MDDG_REGSCPI;
|
|
}
|
|
|
|
done:
|
|
|
|
if (value == OK) {
|
|
msg = cmdName;
|
|
result->reply.dg.hdr.dgType.value = 1;
|
|
}
|
|
else msg = thisConfig->err[value];
|
|
|
|
result->reply.dg.hdr.msgType = MDDG_MDQUERY;
|
|
name = (char *)(&result->reply.dg.payLoad[0] + result->reply.dg.hdr.primeOffset);
|
|
|
|
strcpy(name,msg);
|
|
result->reply.dg.hdr.payloadSize = result->reply.dg.hdr.primeOffset + strlen(name) + 1;
|
|
result->send();
|
|
|
|
}
|
|
|