790 lines
32 KiB
C++
790 lines
32 KiB
C++
/*=============================================================================|
|
|
| PROJECT SNAP7 1.3.0 |
|
|
|==============================================================================|
|
|
| Copyright (C) 2013, 2015 Davide Nardella |
|
|
| All rights reserved. |
|
|
|==============================================================================|
|
|
| SNAP7 is free software: you can redistribute it and/or modify |
|
|
| it under the terms of the Lesser GNU General Public License as published by |
|
|
| the Free Software Foundation, either version 3 of the License, or |
|
|
| (at your option) any later version. |
|
|
| |
|
|
| It means that you can distribute your commercial software linked with |
|
|
| SNAP7 without the requirement to distribute the source code of your |
|
|
| application and without the requirement that your application be itself |
|
|
| distributed under LGPL. |
|
|
| |
|
|
| SNAP7 is distributed in the hope that it will be useful, |
|
|
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
| Lesser GNU General Public License for more details. |
|
|
| |
|
|
| You should have received a copy of the GNU General Public License and a |
|
|
| copy of Lesser GNU General Public License along with Snap7. |
|
|
| If not, see http://www.gnu.org/licenses/ |
|
|
|=============================================================================*/
|
|
#include "s7_text.h"
|
|
//---------------------------------------------------------------------------
|
|
#ifndef S7_OS_WINDOWS
|
|
static char* itoa(int value, char* result, int base) {
|
|
// check that the base if valid
|
|
if (base < 2 || base > 36){
|
|
*result = '\0'; return result;
|
|
|
|
}
|
|
char* ptr = result, *ptr1 = result, tmp_char;
|
|
int tmp_value;
|
|
|
|
do {
|
|
tmp_value = value;
|
|
value /= base;
|
|
*ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)];
|
|
} while ( value );
|
|
|
|
// Apply negative sign
|
|
if (tmp_value < 0) *ptr++ = '-';
|
|
*ptr-- = '\0';
|
|
while(ptr1 < ptr) {
|
|
tmp_char = *ptr;
|
|
*ptr--= *ptr1;
|
|
*ptr1++ = tmp_char;
|
|
}
|
|
return result;
|
|
}
|
|
#endif
|
|
//---------------------------------------------------------------------------
|
|
char* NumToString(int Value, int Base, int Len, char* Result)
|
|
{
|
|
char CNumber[64];
|
|
char Pad[65] = "0000000000000000000000000000000000000000000000000000000000000000";
|
|
|
|
_itoa_s(Value, CNumber,64, Base);
|
|
|
|
if (Len > 0)
|
|
{
|
|
int Delta = Len - strlen(CNumber); // Len is max 8 in this program
|
|
if (Delta > 0)
|
|
{
|
|
strncpy_s(Result,64, Pad, Delta);
|
|
Result[Delta] = '\0';
|
|
strcat_s(Result,64, CNumber);
|
|
}
|
|
else
|
|
strcpy_s(Result,64, CNumber);
|
|
}
|
|
else
|
|
strcpy_s(Result,64, CNumber);
|
|
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* IntToString(int Value, char* Result)
|
|
{
|
|
return NumToString(Value, 10, 0, Result);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* TimeToString(time_t dt, char* Result)
|
|
{
|
|
struct tm DateTime;
|
|
if (localtime_s(&DateTime,&dt) == 0)
|
|
strftime(Result, 50, "%Y-%m-%d %H:%M:%S", &DateTime);
|
|
else
|
|
*Result = '\0';
|
|
return Result;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
char* IpAddressToString(int IP, char* Result)
|
|
{
|
|
in_addr Addr;
|
|
Addr.s_addr = IP;
|
|
strcpy_s(Result, 16,inet_ntoa(Addr));
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
#define WSAEINVALIDADDRESS 12001
|
|
|
|
char* TcpTextOf(int Error, char* Result)
|
|
{
|
|
switch (Error)
|
|
{
|
|
case 0: *Result='\0';break;
|
|
case WSAEINTR: strcpy_s(Result,128," TCP : Interrupted system call\0");break;
|
|
case WSAEBADF: strcpy_s(Result,128," TCP : Bad file number\0");break;
|
|
case WSAEACCES: strcpy_s(Result,128," TCP : Permission denied\0");break;
|
|
case WSAEFAULT: strcpy_s(Result,128," TCP : Bad address\0");break;
|
|
case WSAEINVAL: strcpy_s(Result,128," TCP : Invalid argument\0");break;
|
|
case WSAEMFILE: strcpy_s(Result,128," TCP : Too many open files\0");break;
|
|
case WSAEWOULDBLOCK: strcpy_s(Result,128," TCP : Operation would block\0");break;
|
|
case WSAEINPROGRESS: strcpy_s(Result,128," TCP : Operation now in progress\0");break;
|
|
case WSAEALREADY: strcpy_s(Result,128," TCP : Operation already in progress\0");break;
|
|
case WSAENOTSOCK: strcpy_s(Result,128," TCP : Socket operation on non socket\0");break;
|
|
case WSAEDESTADDRREQ: strcpy_s(Result,128," TCP : Destination address required\0");break;
|
|
case WSAEMSGSIZE: strcpy_s(Result,128," TCP : Message too long\0");break;
|
|
case WSAEPROTOTYPE: strcpy_s(Result,128," TCP : Protocol wrong type for Socket\0");break;
|
|
case WSAENOPROTOOPT: strcpy_s(Result,128," TCP : Protocol not available\0");break;
|
|
case WSAEPROTONOSUPPORT: strcpy_s(Result,128," TCP : Protocol not supported\0");break;
|
|
case WSAESOCKTNOSUPPORT: strcpy_s(Result,128," TCP : Socket not supported\0");break;
|
|
case WSAEOPNOTSUPP: strcpy_s(Result,128," TCP : Operation not supported on Socket\0");break;
|
|
case WSAEPFNOSUPPORT: strcpy_s(Result,128," TCP : Protocol family not supported\0");break;
|
|
case WSAEAFNOSUPPORT: strcpy_s(Result,128," TCP : Address family not supported\0");break;
|
|
case WSAEADDRINUSE: strcpy_s(Result,128," TCP : Address already in use\0");break;
|
|
case WSAEADDRNOTAVAIL: strcpy_s(Result,128," TCP : Can't assign requested address\0");break;
|
|
case WSAENETDOWN: strcpy_s(Result,128," TCP : Network is down\0");break;
|
|
case WSAENETUNREACH: strcpy_s(Result,128," TCP : Network is unreachable\0");break;
|
|
case WSAENETRESET: strcpy_s(Result,128," TCP : Network dropped connection on reset\0");break;
|
|
case WSAECONNABORTED: strcpy_s(Result,128," TCP : Software caused connection abort\0");break;
|
|
case WSAECONNRESET: strcpy_s(Result,128," TCP : Connection reset by peer\0");break;
|
|
case WSAENOBUFS: strcpy_s(Result,128," TCP : No Buffer space available\0");break;
|
|
case WSAEISCONN: strcpy_s(Result,128," TCP : Socket is already connected\0");break;
|
|
case WSAENOTCONN: strcpy_s(Result,128," TCP : Socket is not connected\0");break;
|
|
case WSAESHUTDOWN: strcpy_s(Result,128," TCP : Can't send after Socket shutdown\0");break;
|
|
case WSAETOOMANYREFS: strcpy_s(Result,128," TCP : Too many references:can't splice\0");break;
|
|
case WSAETIMEDOUT: strcpy_s(Result,128," TCP : Connection timed out\0");break;
|
|
case WSAECONNREFUSED: strcpy_s(Result,128," TCP : Connection refused\0");break;
|
|
case WSAELOOP: strcpy_s(Result,128," TCP : Too many levels of symbolic links\0");break;
|
|
case WSAENAMETOOLONG: strcpy_s(Result,128," TCP : File name is too long\0");break;
|
|
case WSAEHOSTDOWN: strcpy_s(Result,128," TCP : Host is down\0");break;
|
|
case WSAEHOSTUNREACH: strcpy_s(Result,128," TCP : Unreachable peer\0");break;
|
|
case WSAENOTEMPTY: strcpy_s(Result,128," TCP : Directory is not empty\0");break;
|
|
case WSAEUSERS: strcpy_s(Result,128," TCP : Too many users\0");break;
|
|
case WSAEDQUOT: strcpy_s(Result,128," TCP : Disk quota exceeded\0");break;
|
|
case WSAESTALE: strcpy_s(Result,128," TCP : Stale NFS file handle\0");break;
|
|
case WSAEREMOTE: strcpy_s(Result,128," TCP : Too many levels of remote in path\0");break;
|
|
#ifdef S7_OS_WINDOWS
|
|
case WSAEPROCLIM: strcpy_s(Result,128," TCP : Too many processes\0");break;
|
|
case WSASYSNOTREADY: strcpy_s(Result,128," TCP : Network subsystem is unusable\0");break;
|
|
case WSAVERNOTSUPPORTED: strcpy_s(Result,128," TCP : Winsock DLL cannot support this application\0");break;
|
|
case WSANOTINITIALISED: strcpy_s(Result,128," TCP : Winsock not initialized\0");break;
|
|
case WSAEDISCON: strcpy_s(Result,128," TCP : Disconnect\0");break;
|
|
case WSAHOST_NOT_FOUND: strcpy_s(Result,128," TCP : Host not found\0");break;
|
|
case WSATRY_AGAIN: strcpy_s(Result,128," TCP : Non authoritative - host not found\0");break;
|
|
case WSANO_RECOVERY: strcpy_s(Result,128," TCP : Non recoverable error\0");break;
|
|
case WSANO_DATA: strcpy_s(Result,128," TCP : Valid name, no data record of requested type\0");break;
|
|
#endif
|
|
case WSAEINVALIDADDRESS: strcpy_s(Result,128," TCP : Invalid address\0");break;
|
|
default:
|
|
{
|
|
char CNumber[16];
|
|
strcpy_s(Result,128, " TCP : Other Socket error (");
|
|
strcat_s(Result,128, IntToString(Error, CNumber));
|
|
strcat_s(Result,128, ")");
|
|
break;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* IsoTextOf(int Error, char* Result)
|
|
{
|
|
switch (Error)
|
|
{
|
|
case 0 : *Result='\0';break;
|
|
case errIsoConnect: strcpy_s(Result,128," ISO : Connection error\0");break;
|
|
case errIsoDisconnect: strcpy_s(Result,128," ISO : Disconnect error\0");break;
|
|
case errIsoInvalidPDU: strcpy_s(Result,128," ISO : Bad PDU format\0");break;
|
|
case errIsoInvalidDataSize: strcpy_s(Result,128," ISO : Datasize passed to send/recv buffer is invalid\0");break;
|
|
case errIsoNullPointer: strcpy_s(Result,128," ISO : Null passed as pointer\0");break;
|
|
case errIsoShortPacket: strcpy_s(Result,128," ISO : A short packet received\0");break;
|
|
case errIsoTooManyFragments: strcpy_s(Result,128," ISO : Too many packets without EoT flag\0");break;
|
|
case errIsoPduOverflow: strcpy_s(Result,128," ISO : The sum of fragments data exceded maximum packet size\0");break;
|
|
case errIsoSendPacket: strcpy_s(Result,128," ISO : An error occurred during send\0");break;
|
|
case errIsoRecvPacket: strcpy_s(Result,128," ISO : An error occurred during recv\0");break;
|
|
case errIsoInvalidParams: strcpy_s(Result,128," ISO : Invalid connection params (wrong TSAPs)\0");break;
|
|
default:
|
|
{
|
|
char CNumber[16];
|
|
strcpy_s(Result,128, " ISO : Unknown error (0x");
|
|
strcat_s(Result,128, NumToString(Error, 16, 8, CNumber));
|
|
strcat_s(Result,128, ")");
|
|
break;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* CliTextOf(int Error, char* Result)
|
|
{
|
|
switch (Error)
|
|
{
|
|
case 0 : *Result='\0';break;
|
|
case errNegotiatingPDU : strcpy_s(Result,128,"CPU : Error in PDU negotiation\0");break;
|
|
case errCliInvalidParams : strcpy_s(Result,128,"CLI : invalid param(s) supplied\0");break;
|
|
case errCliJobPending : strcpy_s(Result,128,"CLI : Job pending\0");break;
|
|
case errCliTooManyItems : strcpy_s(Result,128,"CLI : too may items (>20) in multi read/write\0");break;
|
|
case errCliInvalidWordLen : strcpy_s(Result,128,"CLI : invalid WordLength\0");break;
|
|
case errCliPartialDataWritten : strcpy_s(Result,128,"CLI : Partial data written\0");break;
|
|
case errCliSizeOverPDU : strcpy_s(Result,128,"CPU : total data exceeds the PDU size\0");break;
|
|
case errCliInvalidPlcAnswer : strcpy_s(Result,128,"CLI : invalid CPU answer\0");break;
|
|
case errCliAddressOutOfRange : strcpy_s(Result,128,"CPU : Address out of range\0");break;
|
|
case errCliInvalidTransportSize : strcpy_s(Result,128,"CPU : Invalid Transport size\0");break;
|
|
case errCliWriteDataSizeMismatch : strcpy_s(Result,128,"CPU : Data size mismatch\0");break;
|
|
case errCliItemNotAvailable : strcpy_s(Result,128,"CPU : Item not available\0");break;
|
|
case errCliInvalidValue : strcpy_s(Result,128,"CPU : Invalid value supplied\0");break;
|
|
case errCliCannotStartPLC : strcpy_s(Result,128,"CPU : Cannot start PLC\0");break;
|
|
case errCliAlreadyRun : strcpy_s(Result,128,"CPU : PLC already RUN\0");break;
|
|
case errCliCannotStopPLC : strcpy_s(Result,128,"CPU : Cannot stop PLC\0");break;
|
|
case errCliCannotCopyRamToRom : strcpy_s(Result,128,"CPU : Cannot copy RAM to ROM\0");break;
|
|
case errCliCannotCompress : strcpy_s(Result,128,"CPU : Cannot compress\0");break;
|
|
case errCliAlreadyStop : strcpy_s(Result,128,"CPU : PLC already STOP\0");break;
|
|
case errCliFunNotAvailable : strcpy_s(Result,128,"CPU : Function not available\0");break;
|
|
case errCliUploadSequenceFailed : strcpy_s(Result,128,"CPU : Upload sequence failed\0");break;
|
|
case errCliInvalidDataSizeRecvd : strcpy_s(Result,128,"CLI : Invalid data size received\0");break;
|
|
case errCliInvalidBlockType : strcpy_s(Result,128,"CLI : Invalid block type\0");break;
|
|
case errCliInvalidBlockNumber : strcpy_s(Result,128,"CLI : Invalid block number\0");break;
|
|
case errCliInvalidBlockSize : strcpy_s(Result,128,"CLI : Invalid block size\0");break;
|
|
case errCliDownloadSequenceFailed : strcpy_s(Result,128,"CPU : Download sequence failed\0");break;
|
|
case errCliInsertRefused : strcpy_s(Result,128,"CPU : block insert refused\0");break;
|
|
case errCliDeleteRefused : strcpy_s(Result,128,"CPU : block delete refused\0");break;
|
|
case errCliNeedPassword : strcpy_s(Result,128,"CPU : Function not authorized for current protection level\0");break;
|
|
case errCliInvalidPassword : strcpy_s(Result,128,"CPU : Invalid password\0");break;
|
|
case errCliNoPasswordToSetOrClear : strcpy_s(Result,128,"CPU : No password to set or clear\0");break;
|
|
case errCliJobTimeout : strcpy_s(Result,128,"CLI : Job Timeout\0");break;
|
|
case errCliFunctionRefused : strcpy_s(Result,128,"CLI : function refused by CPU (Unknown error)\0");break;
|
|
case errCliPartialDataRead : strcpy_s(Result,128,"CLI : Partial data read\0");break;
|
|
case errCliBufferTooSmall : strcpy_s(Result,128,"CLI : The buffer supplied is too small to accomplish the operation\0");break;
|
|
case errCliDestroying : strcpy_s(Result,128,"CLI : Cannot perform (destroying)\0");break;
|
|
case errCliInvalidParamNumber : strcpy_s(Result,128,"CLI : Invalid Param Number\0");break;
|
|
case errCliCannotChangeParam : strcpy_s(Result,128,"CLI : Cannot change this param now\0");break;
|
|
default :
|
|
{
|
|
char CNumber[16];
|
|
strcpy_s(Result,128, "CLI : Unknown error (0x");
|
|
strcat_s(Result,128, NumToString(Error, 16, 8, CNumber));
|
|
strcat_s(Result,128, ")");
|
|
break;
|
|
}
|
|
};
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* SrvTextOf(int Error, char* Result)
|
|
{
|
|
switch (Error)
|
|
{
|
|
case 0: *Result = '\0'; break;
|
|
case errSrvCannotStart: strcpy_s(Result,128, "SRV : Server cannot start\0"); break;
|
|
case errSrvDBNullPointer: strcpy_s(Result,128, "SRV : Null passed as area pointer\0"); break;
|
|
case errSrvAreaAlreadyExists: strcpy_s(Result,128, "SRV : Cannot register area since already exists\0"); break;
|
|
case errSrvUnknownArea: strcpy_s(Result,128, "SRV : Unknown Area code\0"); break;
|
|
case errSrvInvalidParams: strcpy_s(Result,128, "SRV : Invalid param(s) supplied\0"); break;
|
|
case errSrvTooManyDB: strcpy_s(Result,128, "SRV : DB Limit reached\0"); break;
|
|
case errSrvInvalidParamNumber: strcpy_s(Result,128, "SRV : Invalid Param Number\0"); break;
|
|
case errSrvCannotChangeParam: strcpy_s(Result,128, "SRV : Cannot change this param now\0");break;
|
|
default:
|
|
{
|
|
char CNumber[16];
|
|
strcpy_s(Result,128, "SRV : Unknown error (0x");
|
|
strcat_s(Result,128, NumToString(Error, 16, 8, CNumber));
|
|
strcat_s(Result,128, ")");
|
|
break;
|
|
}
|
|
};
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* ParTextOf(int Error, char* Result)
|
|
{
|
|
switch(Error)
|
|
{
|
|
case 0: *Result = '\0'; break;
|
|
case errParAddressInUse : strcpy_s(Result, 128,"PAR : Local address already in use");break;
|
|
case errParNoRoom : strcpy_s(Result, 128,"PAR : No more partners available");break;
|
|
case errServerNoRoom : strcpy_s(Result, 128,"PAR : No more servers available");break;
|
|
case errParInvalidParams : strcpy_s(Result, 128,"PAR : Invalid parameter supplied");break;
|
|
case errParNotLinked : strcpy_s(Result,128, "PAR : Cannot perform, Partner not linked");break;
|
|
case errParBusy : strcpy_s(Result,128, "PAR : Cannot perform, Partner Busy");break;
|
|
case errParFrameTimeout : strcpy_s(Result,128, "PAR : Frame timeout");break;
|
|
case errParInvalidPDU : strcpy_s(Result,128, "PAR : Invalid PDU received");break;
|
|
case errParSendTimeout : strcpy_s(Result,128, "PAR : Send timeout");break;
|
|
case errParRecvTimeout : strcpy_s(Result,128, "PAR : Recv timeout");break;
|
|
case errParSendRefused : strcpy_s(Result,128, "PAR : Send refused by peer");break;
|
|
case errParNegotiatingPDU : strcpy_s(Result, 128,"PAR : Error negotiating PDU");break;
|
|
case errParSendingBlock : strcpy_s(Result, 128,"PAR : Error Sending Block");break;
|
|
case errParRecvingBlock : strcpy_s(Result,128, "PAR : Error Receiving Block");break;
|
|
case errParBindError : strcpy_s(Result,128, "PAR : Error Binding");break;
|
|
case errParDestroying : strcpy_s(Result, 128,"PAR : Cannot perform (destroying)");break;
|
|
case errParInvalidParamNumber: strcpy_s(Result, 128,"PAR : Invalid Param Number");break;
|
|
case errParCannotChangeParam : strcpy_s(Result, 128,"PAR : Cannot change this param now");break;
|
|
case errParBufferTooSmall : strcpy_s(Result,128, "PAR : The buffer supplied is too small to accomplish the operation");break;
|
|
default:
|
|
{
|
|
char CNumber[16];
|
|
strcpy_s(Result,128, "PAR : Unknown error (0x");
|
|
strcat_s(Result, 128,NumToString(Error, 16, 8, CNumber));
|
|
strcat_s(Result, 128,")");
|
|
break;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* ErrCliText(int Error, char * Result, int TextLen)
|
|
{
|
|
char TcpError[128];
|
|
char IsoError[128];
|
|
char CliError[256];
|
|
if (Error != 0)
|
|
{
|
|
switch (Error)
|
|
{
|
|
case errLibInvalidParam : strncpy_s(Result,128,"LIB : Invalid param supplied\0",TextLen);break;
|
|
case errLibInvalidObject: strncpy_s(Result,128, "LIB : Invalid object supplied\0", TextLen); break;
|
|
default :
|
|
{
|
|
CliTextOf(Error & ErrS7Mask, CliError);
|
|
strcat_s(CliError, 256,IsoTextOf(Error & ErrIsoMask, IsoError));
|
|
strcat_s(CliError, 256,TcpTextOf(Error & ErrTcpMask, TcpError));
|
|
strncpy_s(Result,128, CliError, TextLen);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
strncpy_s(Result,128, "OK\0", TextLen);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* ErrSrvText(int Error, char* Result, int TextLen)
|
|
{
|
|
char TcpError[128];
|
|
char IsoError[128];
|
|
char SrvError[256];
|
|
if (Error != 0)
|
|
{
|
|
switch (Error)
|
|
{
|
|
case errLibInvalidParam: strncpy_s(Result,128, "LIB : Invalid param supplied\0", TextLen); break;
|
|
case errLibInvalidObject: strncpy_s(Result,128, "LIB : Invalid object supplied\0", TextLen); break;
|
|
default:
|
|
{
|
|
SrvTextOf(Error & ErrS7Mask, SrvError);
|
|
strcat_s(SrvError,256, IsoTextOf(Error & ErrIsoMask, IsoError));
|
|
strcat_s(SrvError,256, TcpTextOf(Error & ErrTcpMask, TcpError));
|
|
strncpy_s(Result,128, SrvError, TextLen);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
strncpy_s(Result,128, "OK\0", TextLen);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* ErrParText(int Error, char* Result, int TextLen)
|
|
{
|
|
char TcpError[128];
|
|
char IsoError[128];
|
|
char ParError[256];
|
|
if (Error != 0)
|
|
{
|
|
switch (Error)
|
|
{
|
|
case errLibInvalidParam: strncpy_s(Result,128, "LIB : Invalid param supplied\0", TextLen); break;
|
|
case errLibInvalidObject: strncpy_s(Result,128, "LIB : Invalid object supplied\0", TextLen); break;
|
|
default:
|
|
{
|
|
ParTextOf(Error & ErrS7Mask, ParError);
|
|
strcat_s(ParError,256, IsoTextOf(Error & ErrIsoMask, IsoError));
|
|
strcat_s(ParError,256, TcpTextOf(Error & ErrTcpMask, TcpError));
|
|
strncpy_s(Result,128, ParError, TextLen);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
strncpy_s(Result,128, "OK\0", TextLen);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
// SERVER EVENTS TEXT
|
|
//---------------------------------------------------------------------------
|
|
char* SenderText(TSrvEvent &Event, char* Result)
|
|
{
|
|
char Buf[64];
|
|
char Add[16];
|
|
TimeToString(Event.EvtTime, Buf);
|
|
if (Event.EvtSender != 0)
|
|
{
|
|
strcat_s(Buf,64, " [");
|
|
strcat_s(Buf,64, IpAddressToString(Event.EvtSender, Add));
|
|
strcat_s(Buf,64, "] ");
|
|
}
|
|
else
|
|
strcat_s(Buf,64, " Server ");
|
|
strcpy_s(Result,128, Buf);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* TcpServerEventText(TSrvEvent &Event, char* Result)
|
|
{
|
|
char S[256];
|
|
char Buf[128];
|
|
|
|
strcpy_s(S,256, SenderText(Event, Buf));
|
|
|
|
switch (Event.EvtCode)
|
|
{
|
|
case evcServerStarted : strcat_s(S,256,"started");break;
|
|
case evcServerStopped : strcat_s(S,256,"stopped");break;
|
|
case evcListenerCannotStart:
|
|
strcat_s(S,256 ,"Cannot start listener - Socket Error : ");
|
|
strcat_s(S,256, TcpTextOf(Event.EvtRetCode,Buf));
|
|
break;
|
|
case evcClientAdded : strcat_s(S,256,"Client added");break;
|
|
case evcClientRejected : strcat_s(S,256,"Client refused");break;
|
|
case evcClientNoRoom : strcat_s(S,256,"A client was refused due to maximum connections number");break;
|
|
case evcClientException : strcat_s(S,256,"Client exception");break;
|
|
case evcClientDisconnected : strcat_s(S,256,"Client disconnected by peer");break;
|
|
case evcClientTerminated : strcat_s(S,256,"Client terminated");break;
|
|
case evcClientsDropped:
|
|
strcat_s(S,256, IntToString(Event.EvtParam1, Buf));
|
|
strcat_s(S,256, " clients have been dropped bacause unresponsive");
|
|
break;
|
|
default:
|
|
strcat_s(S,256,"Unknown event (");
|
|
strcat_s(S,256, IntToString(Event.EvtCode, Buf));
|
|
strcat_s(S,256,")");
|
|
break;
|
|
};
|
|
strcpy_s(Result,128, S);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* PDUText(TSrvEvent &Event, char* Result)
|
|
{
|
|
char S[256];
|
|
char Buf[128];
|
|
switch (Event.EvtRetCode)
|
|
{
|
|
case evrFragmentRejected:
|
|
strcpy_s(S,256, "Fragment of ");
|
|
strcat_s(S,256, IntToString(Event.EvtParam1, Buf));
|
|
strcat_s(S,256, " bytes rejected");
|
|
break;
|
|
case evrMalformedPDU:
|
|
strcpy_s(S,256, "Malformed PDU of ");
|
|
strcat_s(S,256, IntToString(Event.EvtParam1, Buf));
|
|
strcat_s(S,256, " bytes rejected");
|
|
break;
|
|
case evrSparseBytes:
|
|
strcpy_s(S,256, "Message of sparse ");
|
|
strcat_s(S,256, IntToString(Event.EvtParam1, Buf));
|
|
strcat_s(S,256, " bytes rejected");
|
|
break;
|
|
case evrCannotHandlePDU:
|
|
strcpy_s(S,256, "Cannot handle this PDU");
|
|
break;
|
|
case evrNotImplemented:
|
|
switch (Event.EvtParam1)
|
|
{
|
|
case grCyclicData:
|
|
strcpy_s(S,256, "Function group cyclic data not yet implemented");
|
|
break;
|
|
case grProgrammer:
|
|
strcpy_s(S,256, "Function group programmer not yet implemented");
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
strcpy_s(S,256, "Unknown Return code (");
|
|
strcat_s(S,256, IntToString(Event.EvtRetCode, Buf));
|
|
strcat_s(S,256, ")");
|
|
break;
|
|
}
|
|
strcpy_s(Result,128, S);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* TxtArea(TSrvEvent &Event, char* Result)
|
|
{
|
|
char S[64];
|
|
char Buf[32];
|
|
switch (Event.EvtParam1)
|
|
{
|
|
case S7AreaPE: strcpy_s(S,64, "Area : PE, "); break;
|
|
case S7AreaPA: strcpy_s(S,64, "Area : PA, "); break;
|
|
case S7AreaMK: strcpy_s(S,64, "Area : MK, "); break;
|
|
case S7AreaCT: strcpy_s(S,64, "Area : CT, "); break;
|
|
case S7AreaTM: strcpy_s(S,64, "Area : TM, "); break;
|
|
case S7AreaDB:
|
|
strcpy_s(S,64, "Area : DB");
|
|
strcat_s(S,64, IntToString(Event.EvtParam2, Buf));
|
|
strcat_s(S,64,", ");
|
|
break;
|
|
default:
|
|
strcpy_s(S,64, "Unknown area (");
|
|
strcat_s(S,64, IntToString(Event.EvtParam2, Buf));
|
|
strcat_s(S,64,")");
|
|
break;
|
|
}
|
|
strcpy_s(Result,128, S);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* TxtStartSize(TSrvEvent &Event, char* Result)
|
|
{
|
|
char N[32];
|
|
strcpy_s(Result,128, "Start : ");
|
|
strcat_s(Result,128, IntToString(Event.EvtParam3, N));
|
|
strcat_s(Result, 128,", Size : ");
|
|
strcat_s(Result,128, IntToString(Event.EvtParam4, N));
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* TxtDataResult(TSrvEvent &Event, char* Result)
|
|
{
|
|
char N[32];
|
|
switch (Event.EvtRetCode)
|
|
{
|
|
case evrNoError:
|
|
strcpy_s(Result,128," --> OK");
|
|
break;
|
|
case evrErrException:
|
|
strcpy_s(Result,128, " --> Exception error");
|
|
break;
|
|
case evrErrAreaNotFound:
|
|
strcpy_s(Result,128, " --> Area not found");
|
|
break;
|
|
case evrErrOutOfRange:
|
|
strcpy_s(Result,128, " --> Out of range");
|
|
break;
|
|
case evrErrOverPDU:
|
|
strcpy_s(Result,128, " --> Data size exceeds PDU size");
|
|
break;
|
|
case evrErrTransportSize:
|
|
strcpy_s(Result,128, " --> Invalid transport size");
|
|
break;
|
|
case evrDataSizeMismatch:
|
|
strcpy_s(Result,128, " --> Data size mismatch");
|
|
break;
|
|
default:
|
|
strcpy_s(Result,128, " --> Unknown error code (");
|
|
strcat_s(Result,128, IntToString(Event.EvtRetCode, N));
|
|
strcat_s(Result,128,")");
|
|
break;
|
|
};
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* ControlText(word Code, char* Result)
|
|
{
|
|
char N[64];
|
|
strcpy_s(Result,128, "CPU Control request : ");
|
|
switch (Code)
|
|
{
|
|
case CodeControlUnknown:
|
|
strcat_s(Result,128, "Unknown");
|
|
break;
|
|
case CodeControlColdStart:
|
|
strcat_s(Result,128, "Cold START --> OK");
|
|
break;
|
|
case CodeControlWarmStart:
|
|
strcat_s(Result,128, "Warm START --> OK");
|
|
break;
|
|
case CodeControlStop:
|
|
strcat_s(Result,128, "STOP --> OK");
|
|
break;
|
|
case CodeControlCompress:
|
|
strcat_s(Result,128, "Memory compress --> OK");
|
|
break;
|
|
case CodeControlCpyRamRom:
|
|
strcat_s(Result,128, "Copy Ram to Rom --> OK");
|
|
break;
|
|
case CodeControlInsDel:
|
|
strcat_s(Result,128, "Block Insert or Delete --> OK");
|
|
break;
|
|
default :
|
|
strcat_s(Result,128, "Unknown control code (");
|
|
strcat_s(Result,128, IntToString(Code, N));
|
|
strcat_s(Result,128, ")");
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* ClockText(word Code, char* Result)
|
|
{
|
|
if (Code==evsGetClock)
|
|
strcpy_s(Result,128, "System clock read requested");
|
|
else
|
|
strcpy_s(Result, 128, "System clock write requested");
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* ReadSZLText(TSrvEvent &Event, char* Result)
|
|
{
|
|
char S[128];
|
|
char N[64];
|
|
strcpy_s(S, 128, "Read SZL request, ID:0x");
|
|
strcat_s(S, 128, NumToString(Event.EvtParam1, 16, 4, N));
|
|
strcat_s(S, 128, " INDEX:0x");
|
|
strcat_s(S,128, NumToString(Event.EvtParam2, 16, 4, N));
|
|
|
|
if (Event.EvtRetCode == evrNoError)
|
|
strcat_s(S,128, " --> OK");
|
|
else
|
|
strcat_s(S, 128, " --> NOT AVAILABLE");
|
|
strcpy_s(Result,128, S);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* UploadText(TSrvEvent &Event, char* Result)
|
|
{
|
|
strcpy_s(Result,128,"Block upload requested --> NOT PERFORMED (due to invalid security level)");
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* DownloadText(TSrvEvent &Event, char* Result)
|
|
{
|
|
strcpy_s(Result,128, "Block download requested --> NOT PERFORMED (due to invalid security level)");
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* StrBlockType(word Code, char* Result)
|
|
{
|
|
char N[64];
|
|
switch (Code)
|
|
{
|
|
case Block_OB:
|
|
strcpy_s(Result, 64,"OB");
|
|
break;
|
|
case Block_DB:
|
|
strcpy_s(Result,64, "DB");
|
|
break;
|
|
case Block_SDB:
|
|
strcpy_s(Result,64, "SDB");
|
|
break;
|
|
case Block_FC:
|
|
strcpy_s(Result,64, "FC");
|
|
break;
|
|
case Block_SFC:
|
|
strcpy_s(Result,64, "SFC");
|
|
break;
|
|
case Block_FB:
|
|
strcpy_s(Result,64, "FB");
|
|
break;
|
|
case Block_SFB:
|
|
strcpy_s(Result,64, "SFB");
|
|
break;
|
|
default:
|
|
strcpy_s(Result,64, "[Unknown 0x");
|
|
strcat_s(Result,64, NumToString(Code, 16, 4, N));
|
|
strcat_s(Result,64,"]");
|
|
break;
|
|
};
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* BlockInfoText(TSrvEvent &Event, char* Result)
|
|
{
|
|
char S[64];
|
|
switch (Event.EvtParam1)
|
|
{
|
|
case evsGetBlockList:
|
|
strcpy_s(Result,128, "Block list requested");
|
|
break;
|
|
case evsStartListBoT:
|
|
strcpy_s(Result,128, "Block of type ");
|
|
strcat_s(Result,128, StrBlockType(Event.EvtParam2,S));
|
|
strcat_s(Result,128, " list requested (start sequence)");
|
|
break;
|
|
case evsListBoT:
|
|
strcpy_s(Result,128, "Block of type ");
|
|
strcat_s(Result,128, StrBlockType(Event.EvtParam2, S));
|
|
strcat_s(Result, 128," list requested (next part)");
|
|
break;
|
|
case evsGetBlockInfo:
|
|
strcpy_s(Result,128, "Block info requested ");
|
|
strcat_s(Result,128, StrBlockType(Event.EvtParam2, S));
|
|
strcat_s(Result,128, " ");
|
|
strcat_s(Result, 128,IntToString(Event.EvtParam3,S));
|
|
break;
|
|
};
|
|
if (Event.EvtRetCode == evrNoError)
|
|
strcat_s(Result, 128," --> OK");
|
|
else
|
|
strcat_s(Result, 128," --> NOT AVAILABLE");
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* SecurityText(TSrvEvent &Event, char* Result)
|
|
{
|
|
switch (Event.EvtParam1)
|
|
{
|
|
case evsSetPassword:
|
|
strcpy_s(Result,128,"Security request : Set session password --> OK");
|
|
break;
|
|
case evsClrPassword:
|
|
strcpy_s(Result, 128,"Security request : Clear session password --> OK");
|
|
break;
|
|
default:
|
|
strcpy_s(Result,128, "Security request : Unknown Subfunction");
|
|
break;
|
|
};
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
char* EvtSrvText(TSrvEvent &Event, char* Result, int TextLen)
|
|
{
|
|
char S[256];
|
|
char C[128];
|
|
|
|
if (Event.EvtCode > evcSnap7Base)
|
|
{
|
|
strcpy_s(S,256, SenderText(Event, C));
|
|
switch (Event.EvtCode)
|
|
{
|
|
case evcPDUincoming:
|
|
strcat_s(S,256, "PDU incoming : ");
|
|
strcat_s(S,256,PDUText(Event,C));
|
|
break;
|
|
case evcDataRead:
|
|
strcat_s(S,256, "Read request, ");
|
|
strcat_s(S,256, TxtArea(Event, C));
|
|
strcat_s(S,256, TxtStartSize(Event, C));
|
|
strcat_s(S,256, TxtDataResult(Event, C));
|
|
break;
|
|
case evcDataWrite:
|
|
strcat_s(S, 256,"Write request, ");
|
|
strcat_s(S, 256,TxtArea(Event, C));
|
|
strcat_s(S,256, TxtStartSize(Event, C));
|
|
strcat_s(S, 256,TxtDataResult(Event, C));
|
|
break;
|
|
case evcNegotiatePDU:
|
|
strcat_s(S, 256,"The client requires a PDU size of ");
|
|
strcat_s(S,256, IntToString(Event.EvtParam1, C));
|
|
strcat_s(S,256," bytes");
|
|
break;
|
|
case evcControl:
|
|
strcat_s(S,256, ControlText(Event.EvtParam1,C));
|
|
break;
|
|
case evcReadSZL:
|
|
strcat_s(S, 256,ReadSZLText(Event,C));
|
|
break;
|
|
case evcClock:
|
|
strcat_s(S,256, ClockText(Event.EvtParam1,C));
|
|
break;
|
|
case evcUpload:
|
|
strcat_s(S, 256,UploadText(Event,C));
|
|
break;
|
|
case evcDownload:
|
|
strcat_s(S,256, DownloadText(Event,C));
|
|
break;
|
|
case evcDirectory:
|
|
strcat_s(S,256, BlockInfoText(Event,C));
|
|
break;
|
|
case evcSecurity:
|
|
strcat_s(S,256, SecurityText(Event,C));
|
|
break;
|
|
default:
|
|
strcat_s(S,256, "Unknown event (");
|
|
strcat_s(S,256, IntToString(Event.EvtCode, C));
|
|
strcat_s(S,256,")");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
strcpy_s(S,256,TcpServerEventText(Event,C));
|
|
|
|
strncpy_s(Result,128, S, TextLen);
|
|
return Result;
|
|
}
|
|
|