266 lines
6.9 KiB
C++
266 lines
6.9 KiB
C++
/*
|
|
*
|
|
* NOTES:
|
|
*
|
|
* REVISIONS:
|
|
* pcy29Nov92: New defines from codes.h
|
|
* sja08Dec92: Changed #define BATTERY_TYPE to RATED_BATTERY_VOLTAGE
|
|
* jod13Jan93: Added eventList to InterpretMessage
|
|
* jod28Jan93: Added fixes for support of Data and Decrement Sets
|
|
* pcy02Feb93: InterpretSetMessage needs to return a value
|
|
* ane03Feb93: Changed BuildPollTransactionGroupMessages to check IsPollSet
|
|
* differently
|
|
* jod14Feb93: Handle mulit char sets (@ddd, KK, etc)
|
|
* pcy16Feb92: Move UPS_STATE_SET define to err.h to avoid conflicts
|
|
* pcy16Feb92: Allow gets of UpsState params
|
|
* pcy16Feb93: Made battery test results pollable
|
|
* pcy21Apr93: OS/2 2.0 FE Merge
|
|
* jod05Apr93: Added changes for Deep Discharge
|
|
* jod14May93: Added Matrix changes.
|
|
* cad10Jun93: Added Mups parms
|
|
* cad22Jul93: Fixed up destructor conflicts and omissions
|
|
* cad27Aug93: Added MeasureUPS firmware poll param
|
|
* cad07Oct93: Plugging Memory Leaks
|
|
* pcy08Apr94: Trim size, use static iterators, dead code removal
|
|
* mwh01Jun94: port for INTERACTIVE
|
|
* jps14Jul94: commented out INCL_NOPMAPI
|
|
* ajr15Feb96: Sinix Merge
|
|
* cgm23Jul97: BuildStandardSetMessage creates Message(aCode,SET)
|
|
*
|
|
* v-stebe 29Jul2000 Fixed PREfix errors (bugs #46353-#46355)
|
|
*/
|
|
#define INCL_BASE
|
|
#define INCL_NOPM
|
|
/* #define INCL_NOPMAPI jwa */
|
|
|
|
#include "cdefine.h"
|
|
|
|
extern "C" {
|
|
#if (C_OS & C_OS2)
|
|
#include <process.h>
|
|
#include <os2.h>
|
|
#endif
|
|
#include <stdlib.h>
|
|
#if (!(C_OS & C_INTERACTIVE))
|
|
#include <malloc.h>
|
|
#endif
|
|
#include <string.h>
|
|
#include <time.h>
|
|
}
|
|
|
|
#include "_defs.h"
|
|
#include "event.h"
|
|
#include "codes.h"
|
|
#include "message.h"
|
|
#include "pollparm.h"
|
|
#include "trans.h"
|
|
#include "protsimp.h"
|
|
#include "err.h"
|
|
|
|
#if (C_OS & C_UNIX)
|
|
#include "utils.h"
|
|
#endif
|
|
|
|
|
|
|
|
|
|
SimpleUpsProtocol:: SimpleUpsProtocol() : Protocol()
|
|
{
|
|
InitProtocol();
|
|
}
|
|
|
|
SimpleUpsProtocol:: ~SimpleUpsProtocol()
|
|
{
|
|
}
|
|
|
|
VOID SimpleUpsProtocol::InitProtocol()
|
|
{
|
|
char buffer[5];
|
|
|
|
for(int i=0; i<PROTOSIZE; i++) {
|
|
ProtoList[i]=(PollParam*)NULL;
|
|
}
|
|
|
|
ProtoList[UTILITY_LINE_CONDITION] = new SimplePollParam(UTILITY_LINE_CONDITION, _itoa(UTILITY_LINE_CONDITION,buffer,10), 0, POLL);
|
|
ProtoList[BATTERY_CONDITION] = new SimplePollParam(BATTERY_CONDITION, _itoa(BATTERY_CONDITION,buffer,10), 0, POLL);
|
|
ProtoList[TURN_OFF_UPS] = new SimplePollParam(TURN_OFF_UPS, _itoa(TURN_OFF_UPS,buffer,10), 0, NO_POLL);
|
|
ProtoList[TURN_ON_SMART_MODE] = new SimplePollParam(TURN_ON_SMART_MODE, _itoa(TURN_ON_SMART_MODE,buffer,10), 0, NO_POLL);
|
|
ProtoList[TURN_OFF_UPS_ON_BATTERY] = new SimplePollParam(TURN_OFF_UPS_ON_BATTERY, _itoa(TURN_OFF_UPS_ON_BATTERY,buffer,10), 0, NO_POLL);
|
|
|
|
return;
|
|
}
|
|
|
|
INT SimpleUpsProtocol :: BuildMessage(Message*, List* )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
INT SimpleUpsProtocol :: BuildPollTransactionGroupMessages(PTransactionGroup aTransactionGroup)
|
|
{
|
|
int err = ErrNO_ERROR;
|
|
|
|
PTransactionItem theItem = aTransactionGroup->GetFirstTransactionItem();
|
|
while ((theItem != NULL) && (err == ErrNO_ERROR))
|
|
{
|
|
if (ProtoList[theItem->GetCode()] != (PollParam*)NULL)
|
|
{
|
|
PollParam* poll_param = ProtoList[theItem->GetCode()];
|
|
/********************************************************
|
|
* *
|
|
* There is no test for POLLABLE in the Simple Protocol *
|
|
* *
|
|
*********************************************************/
|
|
}
|
|
else
|
|
err = ErrNOT_POLLABLE;
|
|
|
|
theItem = aTransactionGroup->GetNextTransactionItem();
|
|
}
|
|
if (err == ErrNO_ERROR)
|
|
{
|
|
err = BuildTransactionGroupMessages(aTransactionGroup);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
INT SimpleUpsProtocol :: BuildTransactionGroupMessages(PTransactionGroup aTransactionGroup)
|
|
{
|
|
int err = ErrNO_ERROR;
|
|
|
|
PTransactionItem theItem = aTransactionGroup->GetFirstTransactionItem();
|
|
while ((theItem != NULL) && (err == ErrNO_ERROR))
|
|
{
|
|
List* msglist = BuildTransactionMessageList(theItem->GetType(), theItem->GetCode(), theItem->GetValue());
|
|
|
|
if (msglist)
|
|
{
|
|
ListIterator iterator(*msglist);
|
|
|
|
PMessage msg = (PMessage)&(iterator.Current());
|
|
while (msg) {
|
|
theItem->AddMessage(msg);
|
|
PMessage copy_msg = new Message(msg);
|
|
aTransactionGroup->AddMessage(copy_msg);
|
|
msg = (PMessage)iterator.Next();
|
|
}
|
|
// don't flush list, we just gave away all the elements
|
|
delete msglist;
|
|
msglist = NULL;
|
|
}
|
|
else
|
|
{
|
|
theItem->SetErrorCode(ErrBUILD_FAILED);
|
|
err = ErrBUILD_FAILED;
|
|
}
|
|
theItem = aTransactionGroup->GetNextTransactionItem();
|
|
}
|
|
return err;
|
|
}
|
|
|
|
|
|
List* SimpleUpsProtocol :: BuildTransactionMessageList(Type aType, INT aCode, CHAR* aValue)
|
|
{
|
|
List* msglist;
|
|
|
|
PollParam* poll_param = ProtoList[aCode];
|
|
|
|
if(poll_param == NULL) {
|
|
return (List*)NULL;
|
|
}
|
|
|
|
switch(aType) {
|
|
case GET:
|
|
msglist = BuildGetMessage(aCode);
|
|
break;
|
|
|
|
case SET:
|
|
msglist = BuildStandardSetMessage(aCode, aValue);
|
|
break;
|
|
}
|
|
|
|
return msglist;
|
|
}
|
|
|
|
List* SimpleUpsProtocol :: BuildGetMessage(INT aCode)
|
|
{
|
|
List* msglist = NULL;
|
|
|
|
PMessage msg = new Message(aCode);
|
|
|
|
if (msg)
|
|
{
|
|
PollParam* poll_param = ProtoList[aCode];
|
|
PCHAR cmd = poll_param->Query();
|
|
|
|
msg->setSubmit(cmd);
|
|
msg->setTimeout(poll_param->GetTime());
|
|
|
|
msglist = new List();
|
|
msglist->Append(msg);
|
|
|
|
free(cmd);
|
|
}
|
|
else {
|
|
;// setError(ErrMESSAGE_CREATE_FAILED);
|
|
}
|
|
return msglist;
|
|
}
|
|
|
|
List* SimpleUpsProtocol :: BuildStandardSetMessage(INT aCode, CHAR* aValue)
|
|
{
|
|
List* msglist = new List();
|
|
|
|
// Really only action type stuff. How will we deal with commands that
|
|
// require two letters (S, wait 1 seconds, S). Possibly use
|
|
// TURN_OFF_UPS as the code, and set an inter character delay as part of
|
|
// protocol message. For now this only handles the simple stuff.
|
|
PollParam* poll_param = ProtoList[aCode];
|
|
PMessage msg = new Message(aCode,SET);
|
|
|
|
CHAR submit_string[50];
|
|
*submit_string = '\0';
|
|
PCHAR cmd = poll_param->Query();
|
|
|
|
if (cmd != NULL) {
|
|
strcpy(submit_string,cmd);
|
|
free(cmd);
|
|
}
|
|
|
|
if(poll_param->GetSetType() != SIMPLE_SET) {
|
|
if (aValue) {
|
|
strcat(submit_string,aValue);
|
|
}
|
|
}
|
|
|
|
if (msg != NULL) {
|
|
msg->setSubmit(submit_string);
|
|
msg->setTimeout(poll_param->GetTime());
|
|
msglist->Append(msg);
|
|
}
|
|
|
|
return msglist;
|
|
}
|
|
|
|
|
|
|
|
|
|
INT SimpleUpsProtocol :: InterpretMessage(Message* msg, List* eventList, List* newmsglist)
|
|
{
|
|
PList tiList = theCurrentTransactionGroup->GetTransactionItemList();
|
|
TransactionItem tmpti(GET,msg->getId());
|
|
PTransactionItem trans_item = (PTransactionItem)tiList->Find(&tmpti);
|
|
if (trans_item) {
|
|
trans_item->SetErrorCode(msg->getErrcode());
|
|
trans_item->SetValue(msg->getResponse());
|
|
}
|
|
|
|
#if 0
|
|
PEvent event = new Event(msg->getId(), msg->getResponse());
|
|
// event->setResponse(msg->getResponse());
|
|
eventList->Append(event);
|
|
#endif
|
|
return ErrNO_ERROR;
|
|
}
|
|
|
|
|