You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1949 lines
57 KiB
1949 lines
57 KiB
/***************************************************************************
|
|
knutnet.cpp - description
|
|
-------------------
|
|
begin : Ne led 12 2003
|
|
copyright : (C) 2003 by Daniel Prynych
|
|
email : Daniel.Prynych@alo.cz
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program 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. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "knutnet.h"
|
|
|
|
#include <tqtextstream.h>
|
|
#include <tqstring.h>
|
|
#include <tqcstring.h>
|
|
#include <tqtimer.h>
|
|
|
|
|
|
#include <unistd.h> // for function sleep
|
|
|
|
//#include <iostream>
|
|
|
|
|
|
|
|
/****** CONSTS ***********/
|
|
|
|
//const TQ_ULONG rBufferLen = 1024;
|
|
|
|
|
|
|
|
KNutNet::KNutNet (const TQString upsAddress, const TQString upsName, const unsigned short port, unsigned int countRepeat, const unsigned int delay)
|
|
: TQObject(), m_upsAddress(upsAddress), m_upsName(upsName), m_countRepeat(countRepeat), m_port(port), m_delay(delay) {
|
|
|
|
|
|
//tqDebug ("KNutNet::KNutNet");
|
|
|
|
m_state = Idle; //idle is value
|
|
m_numberVars = 0;
|
|
m_numberRWVars = 0;
|
|
m_numberIComms = 0;
|
|
m_upsStatusVar = 0;
|
|
m_nutProtocol = 0;
|
|
m_nutVariables = 0;
|
|
m_switchToTCP = false;
|
|
|
|
m_description = false; // popis neni natazen - description is not loaded
|
|
|
|
m_unConnectTimer = new TQTimer( this );
|
|
connect( m_unConnectTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotTimerReconnect()) );
|
|
|
|
m_error = NoError;
|
|
|
|
m_commandSocket = new TQSocket( this );
|
|
connect( m_commandSocket, TQT_SIGNAL( hostFound()),this, TQT_SLOT( slotHostFound()));
|
|
connect( m_commandSocket, TQT_SIGNAL( connected()),this,TQT_SLOT( slotConnected()));
|
|
connect( m_commandSocket, TQT_SIGNAL( connectionClosed()),this, TQT_SLOT( slotConnectionClosed()));
|
|
connect( m_commandSocket, TQT_SIGNAL( error(int)),this, TQT_SLOT( slotConnectionError(int)));
|
|
}
|
|
|
|
|
|
KNutNet::~KNutNet(){
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
|
|
close(); // close connetion when is existed
|
|
while (m_state == Closing ) {
|
|
sleep (100);
|
|
}
|
|
// deleteVars() is made in close();
|
|
}
|
|
|
|
|
|
void KNutNet::close (void) {
|
|
// std::cout << "--KNutNet::close" << std::endl;
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
|
|
m_unConnectTimer->stop();
|
|
deleteVars();
|
|
if ((m_state == Connected) || (m_state == Connecting)) {
|
|
m_state = Closing;
|
|
if (m_state == Connected) {
|
|
inBuffer="LOGOUT\n";
|
|
getUpsData (inBuffer,outBuffer);
|
|
// getUpsDate makes "commandSocket->flush()"
|
|
}
|
|
|
|
if (m_commandSocket->bytesToWrite () > 0) sleep (1000);
|
|
m_commandSocket->clearPendingData (); // data in output buffer will be errased
|
|
m_commandSocket->close(); // closes the socket
|
|
|
|
if ( m_commandSocket->state() == TQSocket::Closing ) {
|
|
connect( m_commandSocket, TQT_SIGNAL(delayedCloseFinished()),this,TQT_SLOT(slotClosed()) );
|
|
}
|
|
else {
|
|
slotClosed();
|
|
}
|
|
}
|
|
}
|
|
|
|
void KNutNet::slotClosed (void) {
|
|
|
|
disconnect( m_commandSocket,TQT_SIGNAL(delayedCloseFinished()),this, TQT_SLOT(slotClosed()) );
|
|
m_state = Idle;
|
|
}
|
|
|
|
|
|
void KNutNet::open (void) {
|
|
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
|
|
if ((m_state == Connected) || (m_state == Connecting)) close(); // close connetion when is existed
|
|
else {
|
|
while (m_state == Closing ) {
|
|
sleep (100);
|
|
}
|
|
}
|
|
if (m_upsAddress != "") {
|
|
if ( m_commandSocket->state() != TQSocket::Connecting ) {
|
|
m_firstConnect=true;
|
|
m_numberConnection=0;
|
|
m_state = HostLookup;
|
|
emit tryFirstConnection(m_countRepeat); // how many times we can try to connect with ups server /upsd/
|
|
// std::cout << "--KNutNet :: Open emit - tryFirstConnection" << std::endl;
|
|
m_commandSocket->connectToHost(m_upsAddress,m_port);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void KNutNet::newUPS (const TQString upsAddress, const TQString upsName, const unsigned short port) {
|
|
|
|
if ((m_state == Connected) || (m_state == Connecting)) {
|
|
close();
|
|
while (m_state == Closing ) {
|
|
sleep (100);
|
|
}
|
|
}
|
|
|
|
m_upsAddress = upsAddress;
|
|
m_upsName = upsName;
|
|
m_port = port;
|
|
|
|
m_state = Idle;
|
|
m_numberVars = 0;
|
|
m_numberRWVars = 0;
|
|
m_numberIComms = 0;
|
|
m_upsStatusVar = 0;
|
|
m_nutProtocol = 0;
|
|
m_nutVariables = 0;
|
|
m_switchToTCP = false;
|
|
|
|
m_error = NoError;
|
|
//firstConnect=true;
|
|
//numberConnection=0;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getError ( void ) { return m_error; }
|
|
|
|
int KNutNet::getState ( void ){ return m_state; }
|
|
|
|
bool KNutNet::isDescription ( void ){ return m_description; }
|
|
|
|
int KNutNet::getNutProtocol ( void ) { return m_nutProtocol; }
|
|
|
|
int KNutNet::getNutVariables ( void ) { return m_nutVariables; }
|
|
|
|
bool KNutNet::switchedToTCP ( void ) { return m_switchToTCP; }
|
|
|
|
|
|
int KNutNet::getUpsVars ( void) {
|
|
int returnValue;
|
|
|
|
m_error=0;
|
|
if (m_state == Connected) {
|
|
|
|
// init vars and lists
|
|
m_numberVars = 0;
|
|
m_numberRWVars = 0;
|
|
m_numberIComms = 0;
|
|
deleteVars();
|
|
int countWaitRevision = 5;
|
|
do {
|
|
switch (m_nutProtocol) {
|
|
case 1:
|
|
returnValue = getUpsVars1();
|
|
break;
|
|
case 2:
|
|
returnValue = getUpsVars2();
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
if ( readStatus() != KNutNet::WAIT) return returnValue;
|
|
countWaitRevision--;
|
|
if (countWaitRevision) sleep (2);
|
|
}
|
|
while (countWaitRevision);
|
|
return NoListVars; //getUpsVars can't read list variables
|
|
}
|
|
else {
|
|
return NotConnection;
|
|
}
|
|
}
|
|
|
|
|
|
int KNutNet::getUpsValues (const bool allVars ) {// allVars = true vse; allVars = false jen activate
|
|
|
|
m_error=0; // vynulujeme chyby
|
|
if (m_state == Connected) {
|
|
// init vars and lists
|
|
switch (m_nutProtocol) {
|
|
case 1:
|
|
return getUpsValues1(allVars);
|
|
break;
|
|
case 2:
|
|
return getUpsValues2(allVars);
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
else {
|
|
return NotConnection;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getDescription (bool always) {
|
|
|
|
m_error=0; // vynulujeme chyby
|
|
if (m_state == Connected) {
|
|
switch (m_nutProtocol) {
|
|
case 1:
|
|
return getDescription1 (always);
|
|
break;
|
|
case 2:
|
|
return getDescription2 (always);
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
|
|
int KNutNet::instantCommand (const TQString command, const TQString userName, const TQString password, const bool onlyCommand) {
|
|
m_error=0; // vynulujeme chyby
|
|
|
|
if (m_state == Connected) {
|
|
TQString outBuffer;
|
|
|
|
// funkce sendComm sama mastavi promenou error
|
|
if (onlyCommand) {
|
|
if (!(m_error = sendComm("INSTCMD", command, "",true))) {
|
|
// netMutex=false;
|
|
return 0;
|
|
}
|
|
else {
|
|
// netMutex=false;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
|
|
|
|
|
|
|
|
if (!(m_error = sendComm ("USERNAME", userName, ""))) {
|
|
if (!(m_error = sendComm("PASSWORD", password, ""))) {
|
|
if (!(m_error = sendComm("INSTCMD", command, "",true))) {
|
|
// netMutex=false;
|
|
return 0;
|
|
}
|
|
else {
|
|
return m_error; // spatny prikaz
|
|
}
|
|
} //username
|
|
else {
|
|
return m_error; //spatne helso
|
|
}
|
|
}
|
|
else {
|
|
return m_error; // spatne jmeno
|
|
}
|
|
}
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
|
|
int KNutNet::setVariable (const TQString variable, const TQString value, const TQString userName, const TQString password, const bool onlyVariable) {
|
|
m_error=0; // vynulujeme chyby
|
|
if (m_state == Connected) {
|
|
TQString outBuffer;
|
|
TQString setCommand;
|
|
|
|
switch (m_nutProtocol) {
|
|
case 1: setCommand = "SET";
|
|
break;
|
|
case 2: setCommand = "SET VAR";
|
|
}
|
|
if (onlyVariable) {
|
|
if (!(m_error = sendComm(setCommand, variable, value, true))) {
|
|
return 0;
|
|
}
|
|
else {
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
if (!(m_error = sendComm ("USERNAME", userName, ""))) {
|
|
if (!(m_error = sendComm("PASSWORD", password, ""))) {
|
|
if (!(m_error = sendComm(setCommand, variable, value, true))) {
|
|
//netMutex=false;
|
|
return 0;
|
|
}
|
|
else {
|
|
return m_error;
|
|
}
|
|
} //username
|
|
else {
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
return m_error;
|
|
}
|
|
}
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
|
|
int KNutNet::readNumberVars (typeOfVar typVar) {
|
|
// Vraci pocet promenych
|
|
m_error=0;
|
|
if (m_state == Connected) {
|
|
switch (typVar) {
|
|
case AllVars:
|
|
return m_numberVars;
|
|
break;
|
|
case ROVars:
|
|
return m_numberVars - m_numberRWVars;
|
|
break;
|
|
case RWVars:
|
|
return m_numberRWVars;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
else return -1;
|
|
}
|
|
|
|
int KNutNet::readNumberComms (void) {
|
|
// Vraci pocet prikazu
|
|
m_error=0;
|
|
if (m_state == Connected) return m_numberIComms;
|
|
else return -1;
|
|
}
|
|
|
|
|
|
int KNutNet::readIComm (const int seqNumber, upsICommDef& upsIComm) {
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
if ((seqNumber < 1) || ((unsigned int)seqNumber > m_listIComms.size())) {
|
|
m_error=CommNotFind;
|
|
return m_error;
|
|
}
|
|
upsIComm = m_listIComms[seqNumber-1];
|
|
return 0;
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
|
|
int KNutNet::readVars (const TQString name, struct upsVarDef& allVar) {
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
TQValueVector<upsVarDef>::const_iterator it;
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((*it).upsVarName == name) {
|
|
allVar = (*it);
|
|
return 0;
|
|
}
|
|
}
|
|
m_error=VarNotFind;
|
|
return m_error;
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
int KNutNet::readVars (const int seqNumber, struct upsVarDef& allVar, const typeOfVar typVar) {
|
|
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
int n = 1;
|
|
TQValueVector<upsVarDef>::const_iterator it;
|
|
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((typVar== AllVars) || ((typVar==ROVars) && ((*it).upsVarType)) ||
|
|
((typVar==RWVars) && (!(*it).upsVarType))) {
|
|
if (n == seqNumber) {
|
|
allVar = (*it);
|
|
return 0;
|
|
}
|
|
n++;
|
|
}
|
|
}
|
|
m_error=VarNotFind;
|
|
return m_error;
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
|
|
TQString KNutNet::readStringVar (const TQString name) {
|
|
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
TQValueVector<upsVarDef>::const_iterator it;
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((*it).upsVarName == name) return (*it).upsValue;
|
|
}
|
|
m_error = VarNotFind;
|
|
return 0l;
|
|
}
|
|
else return 0l;
|
|
}
|
|
|
|
|
|
TQString KNutNet::readEnumValueVar (const TQString name, const int valueNumber) {
|
|
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
// #if defined (TDE_VERSION_MAJOR)
|
|
// #if TDE_VERSION_MAJOR >= 3
|
|
TQValueVector<upsVarDef>::const_iterator it;
|
|
// #else
|
|
// TQValueList<upsVar>::ConstIterator it;
|
|
// #endif
|
|
// #else
|
|
// TQValueList<upsVar>::ConstIterator it;
|
|
// #endif
|
|
|
|
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((*it).upsVarName == name) {
|
|
if ((valueNumber < 1) || (valueNumber > (*it).upsVarMax)) {
|
|
m_error=EnumValueNotFind;
|
|
return 0l;
|
|
}
|
|
// vratime hodnotu
|
|
return (*(*it).upsEnumValues)[valueNumber-1];
|
|
}
|
|
}
|
|
m_error = VarNotFind;
|
|
return 0;
|
|
}
|
|
else return 0;
|
|
}
|
|
|
|
|
|
int KNutNet::readStatus(void) {
|
|
|
|
m_error=0;
|
|
return m_upsStatusVar;
|
|
}
|
|
|
|
|
|
int KNutNet::setActivate ( const TQString name ) {
|
|
return activate (name,true);
|
|
}
|
|
|
|
|
|
int KNutNet::unSetActivate ( const TQString name ) {
|
|
return activate (name,false);
|
|
}
|
|
|
|
|
|
int KNutNet::unSetActivateAll ( void ) {
|
|
return activateAll (false);
|
|
}
|
|
|
|
|
|
int KNutNet::existName ( const TQString name ) {
|
|
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
TQValueVector<upsVarDef>::const_iterator it;
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((*it).upsVarName == name) return 0;
|
|
}
|
|
m_error = VarNotFind;
|
|
return m_error;
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* PRIVATE FUNCTIONS */
|
|
/* */
|
|
/*************************************************************************/
|
|
|
|
|
|
int KNutNet::version (int countRepeat, const int delay) {
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
|
|
m_error =0;
|
|
do {
|
|
inBuffer="VER\n";
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
|
|
if (outBuffer.length() > 0) {
|
|
outBuffer = outBuffer.mid(outBuffer.find("upsd")+4);
|
|
int n = outBuffer.find(".");
|
|
if (n > 0) {
|
|
TQString firstNumber= outBuffer.left(n);
|
|
TQString secondNumber= outBuffer.mid(n+1);
|
|
int n = secondNumber.find(".");
|
|
if (n > 0) {
|
|
bool ok;
|
|
secondNumber = secondNumber.left(n);
|
|
int secondInt = secondNumber.toInt(&ok);
|
|
if (!ok) {m_error = UnknownFormatVer; return m_error;}
|
|
int firstInt = firstNumber.toInt(&ok);
|
|
if (!ok) {m_error = UnknownFormatVer; return m_error;}
|
|
if ((firstInt == 0) || ((firstInt == 1) && (secondInt < 3))) {
|
|
m_nutProtocol =1;
|
|
m_nutVariables =1;
|
|
}
|
|
else {
|
|
m_nutProtocol =2;
|
|
m_nutVariables =2;
|
|
}
|
|
return 0;
|
|
}
|
|
else m_error = UnknownFormatVer; // n is <= 0 the second dot
|
|
}
|
|
else m_error = UnknownFormatVer; // n is <= 0 the first dot
|
|
}
|
|
m_error = UnknownAnswer; // i cannot specify number of protocol and number of variables
|
|
return m_error;
|
|
}
|
|
countRepeat--;
|
|
if (countRepeat) sleep (delay);
|
|
}
|
|
while ((countRepeat));
|
|
return m_error;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getFirstUpsName (TQString& firstUpsName) {
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
TQString varOutBuffer;
|
|
int lenString;
|
|
|
|
m_error=0;
|
|
inBuffer = "LIST UPS\n";
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer,"END LIST UPS"))) {
|
|
|
|
TQString inLine, upsNameRet, varName, value;
|
|
int key, typeValue;
|
|
bool beginList = false;
|
|
TQTextIStream varInputStream(&outBuffer);
|
|
while (!(inLine = varInputStream.readLine()).isNull()) {
|
|
key = parseLine (inLine, upsNameRet, varName, value, typeValue, lenString);
|
|
switch (key) {
|
|
case BEGIN_LIST_UPS: {
|
|
beginList = true;;
|
|
break;
|
|
}
|
|
case UPS:
|
|
if (beginList ) {
|
|
firstUpsName = upsNameRet;
|
|
return 0;
|
|
}
|
|
case END_LIST_UPS:
|
|
firstUpsName = "";
|
|
m_error=NoUpsHere;
|
|
return m_error;
|
|
case ERR:
|
|
m_error = upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}// end while
|
|
}
|
|
else {m_error=NoData; return m_error; }
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::setKey (const TQString line) {
|
|
|
|
TQString myLine=line.stripWhiteSpace();
|
|
if (myLine == "OK") return OK;
|
|
if (myLine == "ERR") return ERR;
|
|
if (myLine == "BEGIN") return BEGIN;
|
|
if (myLine == "END") return END;
|
|
if (myLine == "VAR") return VAR;
|
|
if (myLine == "TYPE") return TYPE;
|
|
if (myLine == "DESC") return DESC;
|
|
if (myLine == "CMDDESC") return CMDDESC;
|
|
if (myLine == "UPSDESC") return CMDDESC;
|
|
if (myLine == "UPS") return UPS;
|
|
if (myLine == "LIST") return LIST;
|
|
if (myLine == "RW") return RW;
|
|
if (myLine == "CMD") return CMD;
|
|
if (myLine == "ENUM") return ENUM;
|
|
if (myLine == "STARTTLS") return STARTTLS;
|
|
return NONE;
|
|
}
|
|
|
|
TQString KNutNet::parseValue (const TQString line) {
|
|
|
|
if (line.isEmpty()) return "";
|
|
if (line[0] != "\"") {
|
|
if ((m_posChar=line.find(' ')) == -1) return line;
|
|
else return line.left(m_posChar+1);
|
|
}
|
|
else {
|
|
int len = line.length();
|
|
TQString outString = "";
|
|
for (int i=1; i < len; i++) {
|
|
if ( line[i] == "\\") {
|
|
if ((i+1) <len) {
|
|
if ((line[i+1] == "\"") || (line[i+1] == "\"")) {
|
|
outString +=line[i+1];
|
|
i++;
|
|
}
|
|
else i +=2;
|
|
}
|
|
outString +=line[i];
|
|
continue;
|
|
}
|
|
if (line [i] == "\"") {
|
|
return outString;
|
|
}
|
|
outString += line[i];
|
|
}
|
|
return outString;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
int KNutNet::parseTypeValue (TQString line, int& lenString ) {
|
|
int ret=0;
|
|
TQString word;
|
|
|
|
lenString = 0;
|
|
if (line.isEmpty()) return 0;
|
|
TQTextIStream inputStream(&line);
|
|
while (!inputStream.atEnd()) {
|
|
inputStream >> word;
|
|
if (word == "RW") ret += RW_FLAG;
|
|
if (word == "ENUM") ret += ENUM_FLAG;
|
|
if (word.find("STRING:") != -1) {
|
|
word = word.mid(7);
|
|
ret += STRING_FLAG;
|
|
lenString = word.toInt();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
int KNutNet::parseLine(TQString& line, TQString& upsName ,TQString& varName, TQString& value, int& typeValue, int& lenString) {
|
|
int posChar;
|
|
TQString word1, word2, word3;
|
|
int key1, key2, key3;
|
|
|
|
line = line.stripWhiteSpace();
|
|
|
|
upsName = "";
|
|
varName = "";
|
|
value = "";
|
|
typeValue =0;
|
|
|
|
if (line.isEmpty()) return NONE;
|
|
|
|
if ((posChar=line.find(' ')) == -1) {
|
|
if (setKey(line) == OK) return OK;
|
|
else return NONE;
|
|
}
|
|
else {
|
|
key1 = setKey( line.left(posChar));
|
|
line = line.mid(posChar+1);
|
|
|
|
switch (key1) {
|
|
|
|
case NONE:
|
|
return key1;
|
|
case OK:
|
|
return key1;
|
|
case ERR:
|
|
value = parseValue(line);
|
|
return key1;
|
|
default:
|
|
if ((posChar=line.find(' ')) == -1) return NONE;
|
|
word2 = line.left(posChar);
|
|
key2 = setKey( word2);
|
|
line = line.mid(posChar+1);
|
|
|
|
switch (key1) {
|
|
case BEGIN:
|
|
if ((key2 == LIST) && (setKey(line) == UPS)) return BEGIN_LIST_UPS;
|
|
break;
|
|
case END:
|
|
if ((key2 == LIST) && (setKey(line) == UPS)) return END_LIST_UPS;
|
|
break;
|
|
case UPS:
|
|
upsName = word2;
|
|
value = parseValue(line);
|
|
return key1;
|
|
case CMD:
|
|
upsName = word2;
|
|
varName = parseValue(line);
|
|
return key1;
|
|
}
|
|
|
|
if ((posChar=line.find(' ')) == -1) return NONE;
|
|
|
|
word3 = line.left(posChar);
|
|
key3 = setKey( word3);
|
|
line = line.mid(posChar+1);
|
|
|
|
switch (key1) {
|
|
case VAR:
|
|
upsName = word2;
|
|
varName = word3;
|
|
value = parseValue(line);
|
|
return VAR;
|
|
case TYPE:
|
|
upsName = word2;
|
|
varName = word3;
|
|
typeValue = parseTypeValue(line,lenString);
|
|
return TYPE;
|
|
case ENUM:
|
|
upsName = word2;
|
|
varName = word3;
|
|
value = parseValue(line);
|
|
return ENUM;
|
|
case DESC:
|
|
upsName = word2;
|
|
varName = word3;
|
|
value = parseValue(line);
|
|
return DESC;
|
|
case CMDDESC:
|
|
upsName = word2;
|
|
varName = word3;
|
|
value = parseValue(line);
|
|
return CMDDESC;
|
|
case BEGIN:
|
|
if (key2 != LIST) return NONE;
|
|
if (key3 == VAR) {
|
|
upsName=line.stripWhiteSpace();
|
|
return BEGIN_LIST_VAR;
|
|
}
|
|
if (key3 == RW) {
|
|
upsName=line.stripWhiteSpace();
|
|
return BEGIN_LIST_RW;
|
|
}
|
|
if (key3 == CMD) {
|
|
upsName=line.stripWhiteSpace();
|
|
return BEGIN_LIST_CMD;
|
|
}
|
|
if (key3 == ENUM) {
|
|
if ((posChar=line.find(' ')) == -1) return NONE;
|
|
upsName = line.left(posChar);
|
|
line=line.mid(posChar+1);
|
|
varName = line.stripWhiteSpace();
|
|
return BEGIN_LIST_ENUM;
|
|
}
|
|
return NONE;
|
|
case END:
|
|
if (key2 != LIST) return NONE;
|
|
if (key3 == VAR) {
|
|
upsName=line.stripWhiteSpace();
|
|
return END_LIST_VAR;
|
|
}
|
|
if (key3 == RW) {
|
|
upsName=line.stripWhiteSpace();
|
|
return END_LIST_RW;
|
|
}
|
|
if (key3 == CMD) {
|
|
upsName=line.stripWhiteSpace();
|
|
return END_LIST_CMD;
|
|
}
|
|
if (key3 == ENUM) {
|
|
if ((posChar=line.find(' ')) == -1) return NONE;
|
|
upsName = line.left(posChar);
|
|
line=line.mid(posChar+1);
|
|
varName = line.stripWhiteSpace();
|
|
return END_LIST_ENUM;
|
|
}
|
|
return NONE;
|
|
default:
|
|
return NONE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int KNutNet::newDescription (const TQCString inBuffer, TQString& upsDescription) {
|
|
TQString outBuffer;
|
|
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
TQString word1, word2, word3;
|
|
|
|
if ((m_posChar = outBuffer.find(' ')) == -1)
|
|
word1 = outBuffer;
|
|
else {
|
|
word1 = outBuffer.left(m_posChar);
|
|
word2 = outBuffer.mid(m_posChar+1);
|
|
}
|
|
if (word1 == "DESC") {
|
|
if ((m_posChar = word2.find('\"')) == -1) word3="";
|
|
else
|
|
{
|
|
word3 = word2.mid(m_posChar+1);
|
|
if ((m_posChar = word3.find('\"')) != -1) word3=word3.left(m_posChar);
|
|
}
|
|
if (!word3.isEmpty()) upsDescription=word3;
|
|
}
|
|
else {
|
|
if (word1 == "ERR" ) return upsTranslateError(word2);
|
|
else return UnknownAnswer;
|
|
}
|
|
}
|
|
else return m_error;
|
|
return 0;
|
|
}
|
|
|
|
|
|
void KNutNet::cleanConnecting (void) {
|
|
TQ_ULONG rMaxLen;
|
|
TQCString recvBuffer(rBufferLen);
|
|
TQ_LONG lengthInputData;
|
|
|
|
int n = 0;
|
|
while (m_commandSocket->bytesAvailable() > 0) {
|
|
|
|
if ( (m_commandSocket->bytesAvailable()+1) > rBufferLen) rMaxLen = rBufferLen;
|
|
else rMaxLen=m_commandSocket->bytesAvailable()+1;
|
|
|
|
recvBuffer.resize(rMaxLen);
|
|
if ((lengthInputData = m_commandSocket->readBlock(recvBuffer.data(),rMaxLen)) == -1) {
|
|
}
|
|
if (lengthInputData == 0) break;
|
|
if (n > 20) break; else n++;
|
|
}
|
|
}
|
|
|
|
|
|
int KNutNet::getUpsData (const TQCString sBuffer, TQString& rBuffer, const TQCString endString) {
|
|
|
|
//rbufferLen a sbufferLen are maximal value of buffers
|
|
TQCString recvBuffer(rBufferLen);
|
|
TQ_LONG lengthInputData;
|
|
TQ_ULONG dataAvailable;
|
|
|
|
|
|
TQMutexLocker getUpsDataLocker( &m_getUpsDataMutex );
|
|
|
|
cleanConnecting();
|
|
// first we clean input TCP buffer
|
|
|
|
//cleans buffer
|
|
rBuffer=""; // clean main input buffer;
|
|
|
|
|
|
// after write block, runs command flush for sending data to server inmediately
|
|
if (m_commandSocket->writeBlock(sBuffer.data(),sBuffer.length()) < 0 ) return SendErr;
|
|
m_commandSocket->flush();
|
|
|
|
if (m_commandSocket->waitForMore(1000) == 0) {
|
|
m_commandSocket->waitForMore(500); // workaround
|
|
}
|
|
bool endRecv = false;
|
|
do {
|
|
dataAvailable=m_commandSocket->bytesAvailable();
|
|
if (recvBuffer.size() < (dataAvailable+1) ) recvBuffer.resize(dataAvailable+1);
|
|
if ((lengthInputData = m_commandSocket->readBlock(recvBuffer.data(),dataAvailable)) == -1) return RecvErr;
|
|
|
|
//correct for X86_64 by Alexey Sidorov
|
|
recvBuffer[(int)lengthInputData]='\0';
|
|
// recvBuffer[lengthInputData]='\0';
|
|
|
|
//Problem is that
|
|
//for 64bit environment is TQ_LONG defined like _int64 and
|
|
//for other environments is TQ_LONG defined like long
|
|
|
|
|
|
|
|
|
|
rBuffer.append(recvBuffer.data()); // adds reading data to main input buffer
|
|
if (endString.isEmpty()) endRecv = false;
|
|
else {
|
|
if (recvBuffer.findRev(endString.data()) == -1) {
|
|
//doesn't find right end of input data
|
|
if (m_commandSocket->bytesAvailable() == 0) m_commandSocket->waitForMore(1000);
|
|
if (m_commandSocket->bytesAvailable() > 0) endRecv=true; // makes other cyckle og while
|
|
else endRecv=false;
|
|
}
|
|
//finds right end of input data
|
|
else endRecv = false; // we have found what we want to find
|
|
}
|
|
} while (endRecv);
|
|
return 0; // all is OK
|
|
}
|
|
|
|
|
|
|
|
void KNutNet::setRWVars (const TQString varName, const bool valueType, const int varMax, TQValueVector<TQString>* enumValues) {
|
|
TQValueVector<upsVarDef>::iterator it;
|
|
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((*it).upsVarName == varName) {
|
|
(*it).upsVarMax = varMax;
|
|
(*it).upsValueType=valueType;
|
|
(*it).upsEnumValues=enumValues;
|
|
(*it).upsVarType=false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void KNutNet::upsSetType (struct upsVarDef& upsVar, const TQString name, const TQString value) {
|
|
|
|
if (((m_nutVariables = 2) && (name == "STATUS")) || ((m_nutVariables = 2) && (name == "ups.status")))
|
|
upsVar.upsVarActivate=true;
|
|
else upsVar.upsVarActivate=false;
|
|
|
|
upsVar.upsVarName = name;
|
|
upsVar.upsVarType=true;
|
|
upsVar.upsValueType=true;
|
|
upsVar.upsVarMax=0;
|
|
upsVar.upsValue=value;
|
|
upsVar.upsDescription="";
|
|
upsVar.upsEnumValues=0L;
|
|
}
|
|
|
|
|
|
void KNutNet::deleteVars (void) {
|
|
// #if defined (TDE_VERSION_MAJOR)
|
|
// #if TDE_VERSION_MAJOR >= 3
|
|
TQValueVector<upsVarDef>::iterator it;
|
|
// #else
|
|
// TQValueList<upsVar>::Iterator it;
|
|
// #endif
|
|
// #else
|
|
// TQValueList<upsVar>::Iterator it;
|
|
// #endif
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((*it).upsEnumValues != 0) {
|
|
(*it).upsEnumValues->clear();
|
|
delete (*it).upsEnumValues;
|
|
}
|
|
}
|
|
m_listVars.clear();
|
|
m_listIComms.clear();
|
|
}
|
|
|
|
void KNutNet::genStatusFlags (TQString value) {
|
|
m_upsStatusVar = 0;
|
|
TQTextIStream inputStream(&value);
|
|
TQString word;
|
|
while (!inputStream.atEnd()) {
|
|
inputStream >> word;
|
|
if (word == "OFF") m_upsStatusVar +=OFF;
|
|
if (word == "OL") m_upsStatusVar +=OL;
|
|
if (word == "OB") m_upsStatusVar +=OB;
|
|
if (word == "LB") m_upsStatusVar +=LB;
|
|
if (word == "CAL") m_upsStatusVar +=CAL;
|
|
if (word == "TRIM") m_upsStatusVar +=TRIM;
|
|
if (word == "BOOST") m_upsStatusVar +=BOOST;
|
|
if (word == "OVER") m_upsStatusVar +=OVER;
|
|
if (word == "RB") m_upsStatusVar +=RB;
|
|
if (word == "WAIT") m_upsStatusVar = WAIT;
|
|
//OFF - 1 ups je vypnuta
|
|
//OL - 2 ups je bezi na sit
|
|
//OB - 4 ups bezi na baterie
|
|
//LB - 8 baterie je vybyta (pokud je zaroven OB dojde k shutdownu)
|
|
//CAL - 16 je spustena kalibrace
|
|
//OVER - 128 ups je pretizena
|
|
//RB - 256 ups pozaduje vymenu baterie
|
|
//WAIT - 512 ups zada o strpeni // UPS asks for waiting
|
|
}
|
|
}
|
|
|
|
|
|
int KNutNet::getDescription1 (bool always) {
|
|
|
|
if (always || (! m_description)) {
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
|
|
TQValueVector<upsVarDef>::iterator itv;
|
|
TQValueVector<upsICommDef>::iterator itc;
|
|
for (itv = m_listVars.begin(); itv != m_listVars.end(); itv++) {
|
|
//nacteme promenou
|
|
inBuffer = "VARDESC " + (*itv).upsVarName.local8Bit() + "\n";
|
|
if ((m_error = newDescription (inBuffer, (*itv).upsDescription))) {
|
|
//netMutex.unlock();
|
|
// netMutex=false;
|
|
return m_error;
|
|
}
|
|
}
|
|
for (itc = m_listIComms.begin(); itc != m_listIComms.end(); itc++) {
|
|
//nacteme promenou
|
|
inBuffer = "INSTCMDDESC "+(*itc).upsCommName.local8Bit()+"\n";
|
|
if ((m_error = newDescription (inBuffer, (*itc).upsDescription))) {
|
|
//netMutex.unlock();
|
|
//netMutex=false;
|
|
return m_error;
|
|
}
|
|
}
|
|
//netMutex=false;
|
|
m_description = true;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getDescription2 (bool always) {
|
|
|
|
if (always || (! m_description)) {
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
TQString upsNameRet;
|
|
TQString varName;
|
|
TQString value;
|
|
int typeValue;
|
|
int lenString;
|
|
|
|
TQValueVector<upsVarDef>::iterator itv;
|
|
TQValueVector<upsICommDef>::iterator itc;
|
|
for (itv = m_listVars.begin(); itv != m_listVars.end(); itv++) {
|
|
//nacteme promenou
|
|
inBuffer = "GET DESC " + m_upsName.local8Bit() + " " + (*itv).upsVarName.local8Bit()+"\n";
|
|
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
if ( !outBuffer.isEmpty() ) {
|
|
int key = parseLine(outBuffer, upsNameRet, varName, value, typeValue, lenString);
|
|
switch (key) {
|
|
case DESC:
|
|
(*itv).upsDescription = value;
|
|
break;
|
|
case ERR:
|
|
m_error=upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
m_error = NoData;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
return m_error;
|
|
}
|
|
}
|
|
for (itc = m_listIComms.begin(); itc != m_listIComms.end(); itc++) {
|
|
//nacteme promenou
|
|
inBuffer = "GET CMDDESC " + m_upsName.local8Bit() + " " + (*itc).upsCommName.local8Bit()+"\n";
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
if ( !outBuffer.isEmpty() ) {
|
|
int key = parseLine(outBuffer, upsNameRet, varName, value, typeValue, lenString);
|
|
switch (key) {
|
|
case CMDDESC:
|
|
(*itc).upsDescription = value;
|
|
break;
|
|
case ERR:
|
|
m_error=upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
m_error = NoData;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
return m_error;
|
|
}
|
|
}
|
|
m_description = true;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getUpsVars1 ( void) {
|
|
// getUpsVars nacte promene a jejich typ
|
|
// vraci kod chyby nebo 0 pokud je vse v poradku
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
TQString varOutBuffer;
|
|
upsVarDef upsVar;
|
|
upsICommDef upsIComm;
|
|
|
|
// init vars and lists
|
|
if (!m_upsName.isEmpty()) { // pokud upsName neni je vzdy nastaveno na null
|
|
inBuffer="LISTVARS ";
|
|
inBuffer.append(m_upsName.local8Bit());
|
|
inBuffer.append("\n");
|
|
}
|
|
else inBuffer ="LISTVARS\n";
|
|
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
if (outBuffer.length() > 0) {
|
|
// precteme data
|
|
TQTextIStream inputStream(&outBuffer);
|
|
TQString word;
|
|
int count =1 ;
|
|
while (!inputStream.atEnd()) {
|
|
inputStream >> word;
|
|
switch (count) {
|
|
case 1:
|
|
// vyndame prvni polozku
|
|
if (word == "VARS") count++;
|
|
else {
|
|
if (word == "ERR") {
|
|
inputStream >> word;
|
|
m_error = upsTranslateError(word);
|
|
}
|
|
else m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
break;
|
|
case 2:
|
|
count++;
|
|
if ((word.length() > 0) && word.startsWith("@")) break;
|
|
default:
|
|
// pridame polozku do tabulky
|
|
upsSetType(upsVar, word);
|
|
m_listVars.push_back(upsVar);
|
|
m_numberVars++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else { m_error=NoData; return m_error; }
|
|
}
|
|
else return m_error;
|
|
|
|
if ((m_error = getUpsValues1(true))) return m_error;
|
|
|
|
// *********** RW VARIABLES
|
|
if (!m_upsName.isEmpty()) { // pokud upsName neni je vzdy nastaveno na null
|
|
inBuffer="LISTRW ";
|
|
inBuffer.append(m_upsName.local8Bit());
|
|
inBuffer.append("\n");
|
|
}
|
|
else inBuffer ="LISTRW\n";
|
|
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace();
|
|
if (!outBuffer.isEmpty()) {
|
|
// precteme data
|
|
TQTextIStream inputStream(&outBuffer);
|
|
TQString word;
|
|
int count =1 ;
|
|
bool valueType;
|
|
int varMax;
|
|
while (!inputStream.atEnd()) {
|
|
inputStream >> word;
|
|
switch (count) {
|
|
case 1:
|
|
// vyndame prvni polozku
|
|
if (word == "RW") count++;
|
|
else {
|
|
if (word == "ERR") {
|
|
inputStream >> word;
|
|
m_error = upsTranslateError(word);
|
|
}
|
|
else m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
break;
|
|
case 2:
|
|
count++;
|
|
if ((word.length() > 0) && word.startsWith("@")) break;
|
|
default:
|
|
// Zpracujeme polozku v tabulce
|
|
// zjistime informaci o promene
|
|
inBuffer="VARTYPE ";
|
|
inBuffer.append(word.local8Bit());
|
|
if (!m_upsName.isEmpty()) {
|
|
inBuffer.append("@"); // pokud upsName neni je vzdy nastaveno na null
|
|
inBuffer.append(m_upsName.local8Bit());
|
|
}
|
|
inBuffer.append("\n");
|
|
if (!(m_error=getUpsData (inBuffer,varOutBuffer))) {
|
|
varOutBuffer=varOutBuffer.stripWhiteSpace();
|
|
if ( !outBuffer.isEmpty() ) {
|
|
TQTextIStream varInputStream(&varOutBuffer);
|
|
TQString word1, word2, word3;
|
|
varInputStream >> word1;
|
|
varInputStream >> word2;
|
|
varInputStream >> word3;
|
|
if (word1 == "TYPE") {
|
|
if ((word2.isEmpty()) || (word3.isEmpty())) {
|
|
m_error=UnknownFormat;
|
|
return m_error;
|
|
}
|
|
if (word2 == "ENUM") valueType=false;
|
|
else {
|
|
if (word2 =="STRING") valueType=true;
|
|
else {
|
|
m_error=UnknownFormat;
|
|
return m_error;
|
|
}
|
|
}
|
|
bool ok = true;
|
|
varMax=word3.toInt(&ok);
|
|
if (!ok) {m_error=UnknownFormat; return m_error;};
|
|
} // word1 = Type
|
|
else {
|
|
if (word1=="ERR") {
|
|
m_error = upsTranslateError(word2);
|
|
return m_error;
|
|
}
|
|
else {
|
|
m_error = UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}
|
|
}
|
|
else { m_error=NoData; return m_error; }
|
|
}
|
|
else return m_error;
|
|
// ********** ENUM / STRING ******************
|
|
|
|
TQValueVector<TQString>* enumString=0;
|
|
if (!valueType) {
|
|
// nacteme enum hodnoty
|
|
inBuffer="ENUM ";
|
|
inBuffer.append(word.local8Bit());
|
|
// pokud existuje pridame jmeno UPS-ky
|
|
if (!m_upsName.isEmpty()) {
|
|
inBuffer.append("@");
|
|
inBuffer.append(m_upsName.local8Bit());
|
|
}
|
|
inBuffer.append("\n");
|
|
if (!(m_error=getUpsData (inBuffer,varOutBuffer,"END\n"))) {
|
|
// varOutBuffer.stripWhiteSpace(); nemuze provest protoze bychom si odstranili konce radek
|
|
if (!varOutBuffer.isEmpty()) {
|
|
TQString inLine, word1, word2;
|
|
TQTextIStream varInputStream(&varOutBuffer);
|
|
int inCountLine=1;
|
|
while (!(inLine = varInputStream.readLine()).isNull()) {
|
|
inLine=inLine.stripWhiteSpace();
|
|
|
|
if ((m_posChar=inLine.find(' ')) == -1) word1=inLine;
|
|
else {
|
|
word1=inLine.left(m_posChar);
|
|
inLine = inLine.mid(m_posChar+1);
|
|
}
|
|
if (word1.isEmpty()) { m_error = UnknownFormat; return m_error; }
|
|
if (inCountLine == 1) {
|
|
if ((m_posChar=inLine.find(' ')) == -1) word2=inLine;
|
|
else word2=inLine.left(m_posChar);
|
|
if (word1 =="ENUM") {
|
|
if (word2 != word) { m_error = UnknownFormat; return m_error; }
|
|
varMax=0;
|
|
inCountLine++;
|
|
enumString = new TQValueVector<TQString>;
|
|
enumString->clear();
|
|
}
|
|
else {
|
|
if (word1=="ERR")
|
|
m_error=upsTranslateError(word2); // prevede chybu na jeji kod
|
|
else m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
if (word1 == "END") break;
|
|
if (word1 != "OPTION") { m_error = UnknownFormat; return m_error; }
|
|
if ((m_posChar = inLine.find('\"')) == -1) word2 = "";
|
|
else {
|
|
word2 = inLine.mid(m_posChar+1);
|
|
if ((m_posChar=word2.find('\"')) != -1) word2 = word2.left(m_posChar);
|
|
}
|
|
enumString->push_back(word2);
|
|
varMax++;
|
|
}
|
|
} // end while
|
|
} // buffer is not empty
|
|
else { m_error = NoData ; return m_error; }
|
|
} // getUpsData
|
|
else return m_error;
|
|
} // type of var
|
|
else enumString = 0l;
|
|
// nacteme stringovou promenou
|
|
// ulozime promene
|
|
setRWVars (word,valueType,varMax,enumString);
|
|
m_numberRWVars++;
|
|
break;
|
|
}
|
|
} // end while (!inputStream.atEnd())
|
|
}
|
|
else { m_error = NoData ; return m_error; }
|
|
}
|
|
else return m_error;
|
|
|
|
// *************** INSTANT COMMAND
|
|
if (!m_upsName.isEmpty()) { // pokud upsName neni je vzdy nastaveno na null
|
|
inBuffer="LISTINSTCMD ";
|
|
inBuffer.append(m_upsName.local8Bit());
|
|
inBuffer.append("\n");
|
|
}
|
|
else inBuffer ="LISTINSTCMD\n";
|
|
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
if ( !outBuffer.isEmpty() ) {
|
|
// precteme data
|
|
TQTextIStream inputStream(&outBuffer);
|
|
TQString word;
|
|
int count =1 ;
|
|
while (!inputStream.atEnd()) {
|
|
inputStream >> word;
|
|
switch (count) {
|
|
case 1:
|
|
// vyndame prvni polozku
|
|
if (word == "INSTCMDS") count++;
|
|
else {
|
|
if (word == "ERR") {
|
|
inputStream >> word;
|
|
m_error = upsTranslateError(word);
|
|
}
|
|
else m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
break;
|
|
case 2:
|
|
count++;
|
|
if ((word.length() > 0) && word.startsWith("@")) break;
|
|
default:
|
|
// Zpracujeme polozku v tabulky
|
|
upsIComm.upsCommName=word;
|
|
upsIComm.upsDescription="";
|
|
m_listIComms.push_back(upsIComm);
|
|
m_numberIComms++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else { m_error=NoData; return m_error; }
|
|
}
|
|
else return m_error;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getUpsVars2 ( void) {
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
TQString varOutBuffer;
|
|
upsVarDef upsVar;
|
|
upsICommDef upsIComm;
|
|
int key;
|
|
int typeValue;
|
|
int lenString;
|
|
int varMax=0;
|
|
|
|
TQValueVector<TQString>* enumString=0;
|
|
inBuffer = "LIST VAR " + m_upsName.local8Bit() + "\n";
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer,"END LIST VAR"))) {
|
|
TQString inLine, upsNameRet, varName, varNameRet, value;
|
|
bool beginList = false;
|
|
TQTextIStream varInputStream(&outBuffer);
|
|
while (!(inLine = varInputStream.readLine()).isNull()) {
|
|
|
|
key = parseLine (inLine, upsNameRet, varName, value, typeValue, lenString);
|
|
switch (key) {
|
|
case BEGIN_LIST_VAR:
|
|
if (upsNameRet == m_upsName) beginList = true;
|
|
break;
|
|
case VAR:
|
|
if (beginList ) {
|
|
upsSetType(upsVar, varName, value);
|
|
|
|
if (varName == "ups.status") genStatusFlags(value);
|
|
inBuffer = "GET TYPE " + m_upsName.local8Bit() + " " + varName.local8Bit() +"\n";
|
|
if (!(m_error=getUpsData (inBuffer,varOutBuffer))) {
|
|
key = parseLine (varOutBuffer, upsNameRet, varNameRet, value, typeValue, lenString);
|
|
switch (key) {
|
|
case TYPE:
|
|
if (typeValue & RW_FLAG) {
|
|
upsVar.upsVarMax = 0;
|
|
upsVar.upsEnumValues=0L;
|
|
if (typeValue & ENUM_FLAG) {
|
|
upsVar.upsValueType=false;
|
|
// nacteme enumValues
|
|
inBuffer = "LIST ENUM " + m_upsName.local8Bit() + " " + varName.local8Bit() +"\n";
|
|
if (!(m_error=getUpsData (inBuffer,varOutBuffer,"END LIST ENUM"))) {
|
|
bool beginEnumList = false;
|
|
TQTextIStream varInputStream(&varOutBuffer);
|
|
while (!(inLine = varInputStream.readLine()).isNull()) {
|
|
key = parseLine (inLine, upsNameRet, varName, value, typeValue, lenString);
|
|
switch (key) {
|
|
case BEGIN_LIST_ENUM:
|
|
beginEnumList = true;
|
|
varMax=0;
|
|
enumString = new TQValueVector<TQString>;
|
|
enumString->clear();
|
|
upsVar.upsEnumValues=enumString;
|
|
break;
|
|
case ENUM:
|
|
if (beginList ) {
|
|
enumString->push_back(value);
|
|
varMax++;
|
|
}
|
|
break;
|
|
case ERR:
|
|
m_error = upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
case END_LIST_ENUM:
|
|
upsVar.upsVarMax=varMax;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// Vse co nenini ENUM je STRING
|
|
upsVar.upsValueType=true;
|
|
upsVar.upsVarMax=lenString;
|
|
}
|
|
upsVar.upsVarType=false;
|
|
m_numberRWVars++;
|
|
}
|
|
break;
|
|
case ERR:
|
|
m_error = upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}
|
|
else { return m_error; }
|
|
m_listVars.push_back(upsVar);
|
|
m_numberVars++;
|
|
}
|
|
break;
|
|
case END_LIST_VAR:
|
|
break;
|
|
case ERR:
|
|
m_error = upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
} // end switch
|
|
} // end while
|
|
}
|
|
else { return m_error; }
|
|
// INSTANT COMMANDS
|
|
|
|
inBuffer = "LIST CMD " + m_upsName.local8Bit() + "\n";
|
|
if (!(m_error=getUpsData (inBuffer,outBuffer,"END LIST CMD"))) {
|
|
|
|
TQString inLine, upsNameRet, varName, value;
|
|
int key, typeValue;
|
|
bool beginList = false;
|
|
//std::cout << "CMD Buffer " << outBuffer << std::endl;
|
|
|
|
TQTextIStream varInputStream(&outBuffer);
|
|
while (!(inLine = varInputStream.readLine()).isNull()) {
|
|
key = parseLine (inLine, upsNameRet, varName, value, typeValue, lenString);
|
|
//std::cout << "CMD Line " << inLine << std::endl;
|
|
|
|
switch (key) {
|
|
case BEGIN_LIST_CMD: {
|
|
if (upsNameRet == m_upsName) beginList = true;
|
|
break;
|
|
}
|
|
case CMD:
|
|
if (beginList ) {
|
|
// Zpracujeme polozku v tabulky
|
|
upsIComm.upsCommName=varName;
|
|
upsIComm.upsDescription="";
|
|
m_listIComms.push_back(upsIComm);
|
|
m_numberIComms++;
|
|
}
|
|
break;
|
|
case END_LIST_CMD:
|
|
break;
|
|
case ERR:
|
|
m_error = upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
} // end switch
|
|
} // end while
|
|
}
|
|
else { return m_error; }
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getUpsValues1 (const bool allVars ) {// allVars = true vse; allVars = false jen activate
|
|
TQString endChar;
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
TQValueVector<upsVarDef>::iterator it;
|
|
|
|
// Nacte hodnotu promenych
|
|
// reads value of variables
|
|
|
|
|
|
emit getVarDesc (m_numberVars, 0);
|
|
|
|
int numberVar = 0;
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
numberVar++;
|
|
if ((allVars) || ((*it).upsVarActivate)) {
|
|
//nacteme promenou
|
|
inBuffer = "REQ ";
|
|
inBuffer.append((*it).upsVarName.local8Bit());
|
|
if (!m_upsName.isEmpty()) { // pokud upsName neni je vzdy nastaveno na null
|
|
inBuffer.append("@");
|
|
inBuffer.append(m_upsName.local8Bit());
|
|
}
|
|
inBuffer.append("\n");
|
|
// if (!(error=getUpsData (inBuffer,outBuffer))) {
|
|
m_error=getUpsData (inBuffer,outBuffer);
|
|
// when outBuffer is empty sends and reads date again, but only the only time
|
|
if ((!(m_error)) && (outBuffer.isEmpty())) m_error=getUpsData (inBuffer,outBuffer);
|
|
if (!(m_error)) {
|
|
|
|
endChar = "";
|
|
if ((outBuffer.length()>0) && (outBuffer.at(outBuffer.length()-2)==' ')) endChar=' ';
|
|
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
outBuffer += endChar;
|
|
emit getVarDesc (m_numberVars, numberVar);
|
|
|
|
if ( !outBuffer.isEmpty() ) {
|
|
TQTextIStream inputStream(&outBuffer);
|
|
TQString word1, word2, word3 ;
|
|
inputStream >> word1;
|
|
inputStream >> word2;
|
|
if (inputStream.atEnd()) { // neexistuje treti cast VALUE
|
|
if (word1 == "ERR") {
|
|
// vracena chyba
|
|
m_error=upsTranslateError(word2);
|
|
return m_error;
|
|
}
|
|
else {
|
|
// if ((word2 != "MODEL") && (word2 != "MFR")) {
|
|
if (endChar != " ") { // if values of variable is empty, string is ended on char space
|
|
m_error=UnknownFormat;
|
|
return m_error;
|
|
}
|
|
}
|
|
}
|
|
inputStream >> word3;
|
|
if (word1 == "ANS") {
|
|
// answer - odpoved
|
|
// odstranime pripadne jmeno upsky
|
|
if ((m_posChar = word2.find('@')) != -1) word2 = word2.left(m_posChar);
|
|
if ( word2 != (*it).upsVarName ) {
|
|
m_error=UnknownAnswer;
|
|
return m_error;// neni to odpoved na spravnou promennou
|
|
}
|
|
// test pro starsi format modulu, vraceli chybu v hodnote promene
|
|
if ((m_error=upsOldTranslateError(word3))) {
|
|
return m_error;
|
|
}
|
|
// zalozime hodnotu do vectoru;
|
|
(*it).upsValue=word3;
|
|
if ((*it).upsVarName == "STATUS") {
|
|
// dogenerujeme dalsi slova pro status
|
|
word3 += inputStream.readLine();
|
|
genStatusFlags(word3);
|
|
}
|
|
}
|
|
else {
|
|
// neznama odpoved - neni ANS ani ERR
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
m_error=NoData;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
return m_error;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int KNutNet::getUpsValues2 (const bool allVars ) {// allVars = true vse; allVars = false jen activate
|
|
TQString varName;
|
|
TQString upsNameRet;
|
|
TQString value;
|
|
int typeValue;
|
|
int lenString;
|
|
|
|
// reads value of variables
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
TQValueVector<upsVarDef>::iterator it;
|
|
|
|
emit getVarDesc (m_numberVars, 0);
|
|
int numberVar = 0;
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
numberVar++;
|
|
if ((allVars) || ((*it).upsVarActivate)) {
|
|
//reads variable
|
|
inBuffer = "GET VAR "+m_upsName.local8Bit()+" "+(*it).upsVarName.local8Bit()+"\n";
|
|
// if (!(error=getUpsData (inBuffer,outBuffer))) {
|
|
m_error=getUpsData (inBuffer,outBuffer);
|
|
// when outBuffer is empty sends and reads date again, but only the only time
|
|
if ((!(m_error)) && (outBuffer.isEmpty())) m_error=getUpsData (inBuffer,outBuffer);
|
|
if (!(m_error)) {
|
|
outBuffer=outBuffer.stripWhiteSpace ();
|
|
emit getVarDesc (m_numberVars, numberVar);
|
|
if ( !outBuffer.isEmpty() ) {
|
|
int key = parseLine(outBuffer, upsNameRet, varName, value, typeValue, lenString);
|
|
switch (key) {
|
|
case VAR:
|
|
if ( varName != (*it).upsVarName ) {
|
|
m_error=UnknownAnswer;
|
|
return m_error;// it isn't answer for right variable - neni to odpoved na spravnou promennou
|
|
}
|
|
(*it).upsValue=value;
|
|
if ((((*it).upsVarName == "STATUS") && (m_nutVariables == 1)) || (((*it).upsVarName == "ups.status") && (m_nutVariables == 2))) {
|
|
// dogenerujeme dalsi slova pro status
|
|
genStatusFlags(value);
|
|
}
|
|
break;
|
|
case ERR:
|
|
m_error=upsTranslateError(value);
|
|
return m_error;
|
|
default:
|
|
m_error=UnknownAnswer;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
m_error= NoData;
|
|
return m_error;
|
|
}
|
|
}
|
|
else {
|
|
return m_error;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int KNutNet::sendComm (const TQString command, const TQString arg1, const TQString arg2, const bool useUpsName) {
|
|
int localError;
|
|
// nenastavi promenou error ale nenuluje ji
|
|
TQCString inBuffer;
|
|
TQString outBuffer;
|
|
|
|
switch (m_nutProtocol) {
|
|
case 1:
|
|
inBuffer=command.local8Bit() + " " + arg1.local8Bit();
|
|
if (useUpsName && (!m_upsName.isEmpty())) { // pokud upsName neni je vzdy prazdne
|
|
inBuffer += "@"+m_upsName.local8Bit();
|
|
}
|
|
if (!arg2.isEmpty()) {
|
|
inBuffer += " " + arg2.local8Bit();
|
|
}
|
|
break;
|
|
case 2:
|
|
inBuffer = command.local8Bit() + " ";
|
|
if (useUpsName) {
|
|
inBuffer += m_upsName.local8Bit() + " ";
|
|
}
|
|
inBuffer.append(arg1.local8Bit());
|
|
if (!arg2.isEmpty()) {
|
|
inBuffer += " \"" + arg2.local8Bit() +"\"";
|
|
}
|
|
break;
|
|
}
|
|
inBuffer.append("\n");
|
|
|
|
if (!(localError=getUpsData (inBuffer,outBuffer))) {
|
|
outBuffer=outBuffer.stripWhiteSpace();
|
|
TQTextIStream inputStream(&outBuffer);
|
|
TQString word1, word2;
|
|
inputStream >> word1;
|
|
inputStream >> word2;
|
|
if (word1.isEmpty()) return UnknownAnswer; // zadna odpoved
|
|
if (word1 != "OK") {
|
|
// neni rovno OK
|
|
if (word1 == "ERR") return upsTranslateError (word2);
|
|
else return UnknownAnswer;
|
|
}
|
|
else return 0;
|
|
}
|
|
else return localError;
|
|
}
|
|
|
|
|
|
int KNutNet::activate ( const TQString name, const bool setActivate ) {
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
TQValueVector<upsVarDef>::iterator it;
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
if ((*it).upsVarName == name) {
|
|
(*it).upsVarActivate = setActivate;
|
|
return 0;
|
|
}
|
|
}
|
|
m_error = VarNotFind;
|
|
return m_error;
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
int KNutNet::activateAll ( const bool setActivate ) {
|
|
m_error =0;
|
|
if (m_state == Connected) {
|
|
TQValueVector<upsVarDef>::iterator it;
|
|
for (it = m_listVars.begin(); it != m_listVars.end(); it++) {
|
|
(*it).upsVarActivate = setActivate;
|
|
}
|
|
return 0;
|
|
}
|
|
else return NotConnection;
|
|
}
|
|
|
|
|
|
int KNutNet::upsTranslateError (const TQString string) {
|
|
if (string == "VAR-NOT-SUPPORTED") return VarNotSupported;
|
|
if (string == "VAR-UNKNOWN") return VarUnknown;
|
|
|
|
if (string == "ACCESS-DENIED") return AccessDenied;
|
|
if (string == "PASSWORD-REQUIRED") return PasswordRequired;
|
|
if (string == "PASSWORD-INCORRECT") return PasswordIncorrect;
|
|
if (string == "UNKNOWN-UPS") return UnknownUps;
|
|
if (string == "ALREADY-LOGGED_IN") return AlreadyLoggedIn;
|
|
if (string == "ALREADY-SET-PASSWORD") return AlreadySetPassword;
|
|
if (string == "ALREADY-SET-USERNAME") return AlreadySetUsername;
|
|
if (string == "UNKNOWN-COMMAND") return UnknownCommand;
|
|
|
|
if (string == "UNKNOWN-INSTCMD") return UnknownInstCmd;
|
|
if (string == "CMD-NOT-SUPPORTED") return CmdNotSupported;
|
|
|
|
if (string == "INVALID-VALUE") return InvalidValue;
|
|
|
|
if (string == "NO-RESPONSE") return NoResponse;
|
|
if (string == "UNKNOWN-REPLY") return UnknownReply;
|
|
if (string == "NOT-IMPLEMENTED") return NotImplemented;
|
|
if (string == "COMMAND-FAILED") return CommandFailed;
|
|
|
|
if (string == "MISSING-ARGUMENT") return MissingArgument;
|
|
if (string == "DATA-STALE") return DataStale;
|
|
if (string == "UNKNOWN-TYPE") return UnknownType;
|
|
|
|
if (string == "DRIVER-NOT-CONNECTED") return DriverNotConnected;
|
|
|
|
if (string == "") return UnknownFormat;
|
|
|
|
return UnknownErr;
|
|
}
|
|
|
|
int KNutNet::upsOldTranslateError (const TQString string) {
|
|
if (string == "NOT-SUPPORTED") return VarNotSupported;
|
|
if (string == "UNKNOWN") return VarUnknown;
|
|
if (string == "DATA-STALE") return DataStale;
|
|
return 0; // nebylo nalezeno
|
|
}
|
|
|
|
//--------------------Socket----------------
|
|
|
|
|
|
void KNutNet::slotConnectionError(int error) {
|
|
//std::cout << "--KNutNet::slotConnectionError" << std::endl;
|
|
//tqDebug ("--KNutNet::slotConnectionError");
|
|
|
|
m_state = ConnectError;
|
|
m_unConnectTimer->stop();
|
|
if (error == TQSocket::ErrHostNotFound) {
|
|
error = NoSuchHost;
|
|
emit connectionError(error);
|
|
return;
|
|
}
|
|
//connection was refused // no connection
|
|
if ((error == TQSocket::ErrConnectionRefused) && (m_commandSocket->state()==TQSocket::Idle)) {
|
|
if (m_firstConnect) {
|
|
if (m_numberConnection < m_countRepeat) {
|
|
m_numberConnection++;
|
|
// tqDebug ("--KNutNet:: connect error - try connect on next time");
|
|
m_unConnectTimer->start( m_delay, TRUE );
|
|
}
|
|
else {
|
|
// i don't connect server
|
|
error=CantConnect;
|
|
// tqDebug("--KNutNet::emit - connection error ");
|
|
emit connectionError(error);
|
|
return;
|
|
}
|
|
} // end of if (firstConnection)
|
|
else {
|
|
// connecting is down, try repeated connection
|
|
|
|
// tqDebug ("--KNutNet::no first connect connection error ");
|
|
m_unConnectTimer->start( m_delay, TRUE );
|
|
}
|
|
return;
|
|
}
|
|
if (error == TQSocket::ErrConnectionRefused) {
|
|
error = ConnectionRefused;
|
|
// std::cout << "--KNutNet::connection error ErrConnectionRefused " << TQSocket::Idle << " - " << error << std::endl;
|
|
emit connectionError(error);
|
|
return;
|
|
}
|
|
if (error == TQSocket::ErrSocketRead) {
|
|
error = SocketReadErr;
|
|
// std::cout << "--KNutNet::connection error TQSocket::ErrSocketRead " << error << std::endl;
|
|
emit connectionError(error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
void KNutNet::slotConnected(void) {
|
|
int n;
|
|
|
|
if ((n = version (m_countRepeat, m_delay)) == 0) { // 0 OK, 0> error
|
|
if ((m_nutProtocol == 0) || (m_nutVariables == 0)) { // answer from upsd (VER) is unknown
|
|
m_error=NutProtocolVarErr;
|
|
m_state = Closing;
|
|
m_commandSocket->close();
|
|
while (m_commandSocket->state() == TQSocket::Closing) {
|
|
sleep (100);
|
|
}
|
|
m_state = ConnectError;
|
|
|
|
return;
|
|
}
|
|
if ((m_nutProtocol == 2) && m_upsName.isEmpty()) {
|
|
// if upsName is empty reads first ups name from upsd server
|
|
if ((m_error =KNutNet::getFirstUpsName (m_upsName))) { // reading first upsName
|
|
// upsd server doesn't support any ups
|
|
m_state = Closing;
|
|
m_commandSocket->close();
|
|
while (m_commandSocket->state() == TQSocket::Closing) {
|
|
sleep (100);
|
|
}
|
|
m_state = ConnectError;
|
|
|
|
}
|
|
}
|
|
m_state=Connected;
|
|
}
|
|
else {
|
|
m_commandSocket->close();
|
|
}
|
|
emit firstConnection();
|
|
// std::cout << "KNutNet::emit - firstConnection" << std::endl;
|
|
}
|
|
|
|
void KNutNet::slotHostFound(void) {
|
|
|
|
// std::cout << "--KNutNet::slotHostFound" << std::endl;
|
|
m_state = Connecting;
|
|
emit hostFound();
|
|
}
|
|
|
|
|
|
void KNutNet::slotConnectionClosed(void) {
|
|
|
|
// std::cout << "--KNutNet::slotConnectionClosed" << std::endl;
|
|
m_unConnectTimer->stop();
|
|
deleteVars();
|
|
m_state = Idle;
|
|
emit connectionClosed();
|
|
}
|
|
|
|
|
|
|
|
void KNutNet::slotTimerReconnect(void) {
|
|
// std::cout << "--KNutNet::slotTimerReconnect" << std::endl;
|
|
|
|
m_unConnectTimer->stop();
|
|
if (m_commandSocket->state()==TQSocket::Idle) {
|
|
//std::cout << "--KNutNet::slotTimerReconnect TQSOcket::Idle" << std::endl;
|
|
emit tryRepeatFirstConnection(m_numberConnection);
|
|
// std::cout << "KNutNet::emit-tryRepeatFirstConnection" << std::endl;
|
|
m_state=Connecting;
|
|
if ( m_commandSocket->state() != TQSocket::Connecting )
|
|
m_commandSocket->connectToHost(m_upsAddress,m_port);
|
|
}
|
|
}
|
|
|
|
|
|
#include "knutnet.moc"
|