mirror of
https://github.com/thiagoralves/OpenPLC_v3.git
synced 2025-05-09 04:41:06 +08:00
Add files via upload
This commit is contained in:
Dave Nardella
GitHub
parent
ddcae72b01
commit
f3da2df734
923
utils/snap7_src/src/sys/snap_msgsock.cpp
Normal file
923
utils/snap7_src/src/sys/snap_msgsock.cpp
Normal file
@ -0,0 +1,923 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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 "snap_msgsock.h"
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
static SocketsLayer SocketsLayerInitializer;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// Base class endian aware
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TSnapBase::TSnapBase()
|
||||||
|
{
|
||||||
|
int x = 1;
|
||||||
|
LittleEndian=*(char *)&x == 1;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
word TSnapBase::SwapWord(word Value)
|
||||||
|
{
|
||||||
|
if (LittleEndian)
|
||||||
|
return ((Value >> 8) & 0xFF) | ((Value << 8) & 0xFF00);
|
||||||
|
else
|
||||||
|
return Value;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
longword TSnapBase::SwapDWord(longword Value)
|
||||||
|
{
|
||||||
|
if (LittleEndian)
|
||||||
|
return (Value >> 24) | ((Value << 8) & 0x00FF0000) | ((Value >> 8) & 0x0000FF00) | (Value << 24);
|
||||||
|
else
|
||||||
|
return Value;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void Msg_CloseSocket(socket_t FSocket)
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
closesocket(FSocket);
|
||||||
|
#else
|
||||||
|
close(FSocket);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
longword Msg_GetSockAddr(socket_t FSocket)
|
||||||
|
{
|
||||||
|
sockaddr_in RemoteSin;
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
int namelen = sizeof(RemoteSin);
|
||||||
|
#else
|
||||||
|
uint32_t namelen = sizeof(RemoteSin);
|
||||||
|
#endif
|
||||||
|
namelen=sizeof(sockaddr_in);
|
||||||
|
if (getpeername(FSocket,(struct sockaddr*)&RemoteSin, &namelen)==0)
|
||||||
|
return RemoteSin.sin_addr.s_addr;
|
||||||
|
else
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TMsgSocket::TMsgSocket()
|
||||||
|
{
|
||||||
|
Pinger = new TPinger();
|
||||||
|
// Set Defaults
|
||||||
|
strcpy(LocalAddress,"0.0.0.0");
|
||||||
|
LocalPort=0;
|
||||||
|
strcpy(RemoteAddress,"127.0.0.1");
|
||||||
|
RemotePort=0;
|
||||||
|
WorkInterval=100;
|
||||||
|
RecvTimeout=500;
|
||||||
|
SendTimeout=10;
|
||||||
|
PingTimeout=750;
|
||||||
|
Connected=false;
|
||||||
|
FSocket=INVALID_SOCKET;
|
||||||
|
LastTcpError=0;
|
||||||
|
LocalBind=0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TMsgSocket::~TMsgSocket()
|
||||||
|
{
|
||||||
|
DestroySocket();
|
||||||
|
delete Pinger;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::SetSin(sockaddr_in &sin, char *Address, u_short Port)
|
||||||
|
{
|
||||||
|
uint32_t in_addr;
|
||||||
|
in_addr=inet_addr(Address);
|
||||||
|
memset(&sin, 0, sizeof(sin));
|
||||||
|
LastTcpError=0;
|
||||||
|
|
||||||
|
if (in_addr!=INADDR_NONE)
|
||||||
|
{
|
||||||
|
sin.sin_addr.s_addr = in_addr; //INADDR_ANY;
|
||||||
|
sin.sin_family = AF_INET;
|
||||||
|
sin.sin_port = htons(Port);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
LastTcpError=WSAEINVALIDADDRESS;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::GetSin(sockaddr_in sin, char *Address, u_short &Port)
|
||||||
|
{
|
||||||
|
strcpy(Address,inet_ntoa(sin.sin_addr));
|
||||||
|
Port=htons(sin.sin_port);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::GetLocal()
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
int namelen = sizeof(LocalSin);
|
||||||
|
#else
|
||||||
|
uint32_t namelen = sizeof(LocalSin);
|
||||||
|
#endif
|
||||||
|
if (getsockname(FSocket, (struct sockaddr*)&LocalSin, &namelen)==0)
|
||||||
|
GetSin(LocalSin, LocalAddress, LocalPort);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::GetRemote()
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
int namelen = sizeof(RemoteSin);
|
||||||
|
#else
|
||||||
|
uint32_t namelen = sizeof(RemoteSin);
|
||||||
|
#endif
|
||||||
|
if (getpeername(FSocket,(struct sockaddr*)&RemoteSin, &namelen)==0)
|
||||||
|
GetSin(RemoteSin, RemoteAddress, RemotePort);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::GetLastSocketError()
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
return WSAGetLastError();
|
||||||
|
#else
|
||||||
|
return errno;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::Purge()
|
||||||
|
{
|
||||||
|
// small buffer to empty the socket
|
||||||
|
char Trash[512];
|
||||||
|
int Read;
|
||||||
|
if (LastTcpError!=WSAECONNRESET)
|
||||||
|
{
|
||||||
|
if (CanRead(0)) {
|
||||||
|
do
|
||||||
|
{
|
||||||
|
Read=recv(FSocket, Trash, 512, MSG_NOSIGNAL );
|
||||||
|
} while(Read==512);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::CreateSocket()
|
||||||
|
{
|
||||||
|
DestroySocket();
|
||||||
|
LastTcpError=0;
|
||||||
|
FSocket =socket(AF_INET, SOCK_STREAM, IPPROTO_TCP );
|
||||||
|
if (FSocket!=INVALID_SOCKET)
|
||||||
|
SetSocketOptions();
|
||||||
|
else
|
||||||
|
LastTcpError =GetLastSocketError();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::GotSocket()
|
||||||
|
{
|
||||||
|
ClientHandle=RemoteSin.sin_addr.s_addr;
|
||||||
|
// could be inherited it if wee need further actions on the socket
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::SetSocket(socket_t s)
|
||||||
|
{
|
||||||
|
FSocket=s;
|
||||||
|
if (FSocket!=INVALID_SOCKET)
|
||||||
|
{
|
||||||
|
SetSocketOptions();
|
||||||
|
GetLocal();
|
||||||
|
GetRemote();
|
||||||
|
GotSocket();
|
||||||
|
}
|
||||||
|
Connected=FSocket!=INVALID_SOCKET;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::DestroySocket()
|
||||||
|
{
|
||||||
|
if(FSocket != INVALID_SOCKET)
|
||||||
|
{
|
||||||
|
if (shutdown(FSocket, SD_SEND)==0)
|
||||||
|
Purge();
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
closesocket(FSocket);
|
||||||
|
#else
|
||||||
|
close(FSocket);
|
||||||
|
#endif
|
||||||
|
FSocket=INVALID_SOCKET;
|
||||||
|
}
|
||||||
|
LastTcpError=0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::WaitingData()
|
||||||
|
{
|
||||||
|
int result = 0;
|
||||||
|
u_long x = 0;
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
if (ioctlsocket(FSocket, FIONREAD, &x) == 0)
|
||||||
|
result = x;
|
||||||
|
#else
|
||||||
|
if (ioctl(FSocket, FIONREAD, &x) == 0)
|
||||||
|
result = x;
|
||||||
|
#endif
|
||||||
|
if (result>MaxPacketSize)
|
||||||
|
result = MaxPacketSize;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::WaitForData(int Size, int Timeout)
|
||||||
|
{
|
||||||
|
longword Elapsed;
|
||||||
|
|
||||||
|
// Check for connection active
|
||||||
|
if (CanRead(0) && (WaitingData()==0))
|
||||||
|
LastTcpError=WSAECONNRESET;
|
||||||
|
else
|
||||||
|
LastTcpError=0;
|
||||||
|
|
||||||
|
// Enter main loop
|
||||||
|
if (LastTcpError==0)
|
||||||
|
{
|
||||||
|
Elapsed =SysGetTick();
|
||||||
|
while((WaitingData()<Size) && (LastTcpError==0))
|
||||||
|
{
|
||||||
|
// Checks timeout
|
||||||
|
if (DeltaTime(Elapsed)>=(longword)(Timeout))
|
||||||
|
LastTcpError =WSAETIMEDOUT;
|
||||||
|
else
|
||||||
|
SysSleep(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(LastTcpError==WSAECONNRESET)
|
||||||
|
Connected =false;
|
||||||
|
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::SetSocketOptions()
|
||||||
|
{
|
||||||
|
int NoDelay = 1;
|
||||||
|
int KeepAlive = 1;
|
||||||
|
LastTcpError=0;
|
||||||
|
SockCheck(setsockopt(FSocket, IPPROTO_TCP, TCP_NODELAY,(char*)&NoDelay, sizeof(NoDelay)));
|
||||||
|
|
||||||
|
if (LastTcpError==0)
|
||||||
|
SockCheck(setsockopt(FSocket, SOL_SOCKET, SO_KEEPALIVE,(char*)&KeepAlive, sizeof(KeepAlive)));
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::SockCheck(int SockResult)
|
||||||
|
{
|
||||||
|
if (SockResult == (int)(SOCKET_ERROR))
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgSocket::CanWrite(int Timeout)
|
||||||
|
{
|
||||||
|
timeval TimeV;
|
||||||
|
int64_t x;
|
||||||
|
fd_set FDset;
|
||||||
|
|
||||||
|
if(FSocket == INVALID_SOCKET)
|
||||||
|
return false;
|
||||||
|
|
||||||
|
TimeV.tv_usec = (Timeout % 1000) * 1000;
|
||||||
|
TimeV.tv_sec = Timeout / 1000;
|
||||||
|
|
||||||
|
FD_ZERO(&FDset);
|
||||||
|
FD_SET(FSocket, &FDset);
|
||||||
|
|
||||||
|
x = select(FSocket + 1, NULL, &FDset, NULL, &TimeV); //<-Ignore this warning in 64bit Visual Studio
|
||||||
|
if (x==(int)SOCKET_ERROR)
|
||||||
|
{
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
x=0;
|
||||||
|
}
|
||||||
|
return (x > 0);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgSocket::CanRead(int Timeout)
|
||||||
|
{
|
||||||
|
timeval TimeV;
|
||||||
|
int64_t x;
|
||||||
|
fd_set FDset;
|
||||||
|
|
||||||
|
if(FSocket == INVALID_SOCKET)
|
||||||
|
return false;
|
||||||
|
|
||||||
|
TimeV.tv_usec = (Timeout % 1000) * 1000;
|
||||||
|
TimeV.tv_sec = Timeout / 1000;
|
||||||
|
|
||||||
|
FD_ZERO(&FDset);
|
||||||
|
FD_SET(FSocket, &FDset);
|
||||||
|
|
||||||
|
x = select(FSocket + 1, &FDset, NULL, NULL, &TimeV); //<-Ignore this warning in 64bit Visual Studio
|
||||||
|
if (x==(int)SOCKET_ERROR)
|
||||||
|
{
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
x=0;
|
||||||
|
}
|
||||||
|
return (x > 0);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#ifdef NON_BLOCKING_CONNECT
|
||||||
|
//
|
||||||
|
// Non blocking connection (UNIX) Thanks to Rolf Stalder
|
||||||
|
//
|
||||||
|
int TMsgSocket::SckConnect()
|
||||||
|
{
|
||||||
|
int n, flags, err;
|
||||||
|
socklen_t len;
|
||||||
|
fd_set rset, wset;
|
||||||
|
struct timeval tval;
|
||||||
|
|
||||||
|
SetSin(RemoteSin, RemoteAddress, RemotePort);
|
||||||
|
|
||||||
|
if (LastTcpError == 0) {
|
||||||
|
CreateSocket();
|
||||||
|
if (LastTcpError == 0) {
|
||||||
|
flags = fcntl(FSocket, F_GETFL, 0);
|
||||||
|
if (flags >= 0) {
|
||||||
|
if (fcntl(FSocket, F_SETFL, flags | O_NONBLOCK) != -1) {
|
||||||
|
n = connect(FSocket, (struct sockaddr*)&RemoteSin, sizeof(RemoteSin));
|
||||||
|
if (n < 0) {
|
||||||
|
if (errno != EINPROGRESS) {
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// still connecting ...
|
||||||
|
FD_ZERO(&rset);
|
||||||
|
FD_SET(FSocket, &rset);
|
||||||
|
wset = rset;
|
||||||
|
tval.tv_sec = PingTimeout / 1000;
|
||||||
|
tval.tv_usec = (PingTimeout % 1000) * 1000;
|
||||||
|
|
||||||
|
n = select(FSocket+1, &rset, &wset, NULL,
|
||||||
|
(PingTimeout ? &tval : NULL));
|
||||||
|
if (n == 0) {
|
||||||
|
// timeout
|
||||||
|
LastTcpError = WSAEHOSTUNREACH;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
if (FD_ISSET(FSocket, &rset) || FD_ISSET(FSocket, &wset)) {
|
||||||
|
err = 0;
|
||||||
|
len = sizeof(err);
|
||||||
|
if (getsockopt(
|
||||||
|
FSocket, SOL_SOCKET, SO_ERROR, &err, &len) == 0) {
|
||||||
|
if (err) {
|
||||||
|
LastTcpError = err;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
if (fcntl(FSocket, F_SETFL, flags) != -1) {
|
||||||
|
GetLocal();
|
||||||
|
ClientHandle = LocalSin.sin_addr.s_addr;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
LastTcpError = -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // still connecting
|
||||||
|
}
|
||||||
|
else if (n == 0) {
|
||||||
|
// connected immediatly
|
||||||
|
GetLocal();
|
||||||
|
ClientHandle = LocalSin.sin_addr.s_addr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
} // fcntl(F_SETFL)
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
} // fcntl(F_GETFL)
|
||||||
|
} //valid socket
|
||||||
|
} // LastTcpError==0
|
||||||
|
Connected=LastTcpError==0;
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
//
|
||||||
|
// Regular connection (Windows)
|
||||||
|
//
|
||||||
|
int TMsgSocket::SckConnect()
|
||||||
|
{
|
||||||
|
int Result;
|
||||||
|
SetSin(RemoteSin, RemoteAddress, RemotePort);
|
||||||
|
if (LastTcpError==0)
|
||||||
|
{
|
||||||
|
if (Ping(RemoteSin))
|
||||||
|
{
|
||||||
|
CreateSocket();
|
||||||
|
if (LastTcpError==0)
|
||||||
|
{
|
||||||
|
Result=connect(FSocket, (struct sockaddr*)&RemoteSin, sizeof(RemoteSin));
|
||||||
|
if (SockCheck(Result)==0)
|
||||||
|
{
|
||||||
|
GetLocal();
|
||||||
|
// Client handle is self_address (here the connection is ACTIVE)
|
||||||
|
ClientHandle=LocalSin.sin_addr.s_addr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
LastTcpError=WSAEHOSTUNREACH;
|
||||||
|
}
|
||||||
|
Connected=LastTcpError==0;
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::SckDisconnect()
|
||||||
|
{
|
||||||
|
DestroySocket();
|
||||||
|
Connected=false;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgSocket::ForceClose()
|
||||||
|
{
|
||||||
|
if(FSocket != INVALID_SOCKET)
|
||||||
|
{
|
||||||
|
try {
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
closesocket(FSocket);
|
||||||
|
#else
|
||||||
|
close(FSocket);
|
||||||
|
#endif
|
||||||
|
} catch (...) {
|
||||||
|
}
|
||||||
|
FSocket=INVALID_SOCKET;
|
||||||
|
}
|
||||||
|
LastTcpError=0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::SckBind()
|
||||||
|
{
|
||||||
|
int Res;
|
||||||
|
int Opt=1;
|
||||||
|
SetSin(LocalSin, LocalAddress, LocalPort);
|
||||||
|
if (LastTcpError==0)
|
||||||
|
{
|
||||||
|
CreateSocket();
|
||||||
|
if (LastTcpError==0)
|
||||||
|
{
|
||||||
|
setsockopt(FSocket ,SOL_SOCKET, SO_REUSEADDR, (const char *)&Opt, sizeof(int));
|
||||||
|
Res =bind(FSocket, (struct sockaddr*)&LocalSin, sizeof(sockaddr_in));
|
||||||
|
SockCheck(Res);
|
||||||
|
if (Res==0)
|
||||||
|
{
|
||||||
|
LocalBind=LocalSin.sin_addr.s_addr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
LastTcpError=WSAEINVALIDADDRESS;
|
||||||
|
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::SckListen()
|
||||||
|
{
|
||||||
|
LastTcpError=0;
|
||||||
|
SockCheck(listen(FSocket ,SOMAXCONN));
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgSocket::Ping(char *Host)
|
||||||
|
{
|
||||||
|
return Pinger->Ping(Host, PingTimeout);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgSocket::Ping(sockaddr_in Addr)
|
||||||
|
{
|
||||||
|
if (PingTimeout == 0)
|
||||||
|
return true;
|
||||||
|
else
|
||||||
|
return Pinger->Ping(Addr.sin_addr.s_addr, PingTimeout);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
socket_t TMsgSocket::SckAccept()
|
||||||
|
{
|
||||||
|
socket_t result;
|
||||||
|
LastTcpError=0;
|
||||||
|
result = accept(FSocket, NULL, NULL);
|
||||||
|
if(result==INVALID_SOCKET)
|
||||||
|
LastTcpError =GetLastSocketError();
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::SendPacket(void *Data, int Size)
|
||||||
|
{
|
||||||
|
int Result;
|
||||||
|
|
||||||
|
LastTcpError=0;
|
||||||
|
if (SendTimeout>0)
|
||||||
|
{
|
||||||
|
if (!CanWrite(SendTimeout))
|
||||||
|
{
|
||||||
|
LastTcpError = WSAETIMEDOUT;
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (send(FSocket, (char*)Data, Size, MSG_NOSIGNAL)==Size)
|
||||||
|
return 0;
|
||||||
|
else
|
||||||
|
Result =SOCKET_ERROR;
|
||||||
|
|
||||||
|
SockCheck(Result);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgSocket::PacketReady(int Size)
|
||||||
|
{
|
||||||
|
return (WaitingData()>=Size);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::Receive(void *Data, int BufSize, int &SizeRecvd)
|
||||||
|
{
|
||||||
|
LastTcpError=0;
|
||||||
|
if (CanRead(RecvTimeout))
|
||||||
|
{
|
||||||
|
SizeRecvd=recv(FSocket ,(char*)Data ,BufSize ,MSG_NOSIGNAL );
|
||||||
|
|
||||||
|
if (SizeRecvd>0) // something read (default case)
|
||||||
|
LastTcpError=0;
|
||||||
|
else
|
||||||
|
if (SizeRecvd==0)
|
||||||
|
LastTcpError = WSAECONNRESET; // Connection reset by Peer
|
||||||
|
else
|
||||||
|
LastTcpError=GetLastSocketError(); // we need to know what happened
|
||||||
|
}
|
||||||
|
else
|
||||||
|
LastTcpError = WSAETIMEDOUT;
|
||||||
|
|
||||||
|
if (LastTcpError==WSAECONNRESET)
|
||||||
|
Connected = false;
|
||||||
|
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::RecvPacket(void *Data, int Size)
|
||||||
|
{
|
||||||
|
int BytesRead;
|
||||||
|
WaitForData(Size, RecvTimeout);
|
||||||
|
if (LastTcpError==0)
|
||||||
|
{
|
||||||
|
BytesRead=recv(FSocket, (char*)Data, Size, MSG_NOSIGNAL);
|
||||||
|
if (BytesRead==0)
|
||||||
|
LastTcpError = WSAECONNRESET; // Connection reset by Peer
|
||||||
|
else
|
||||||
|
if (BytesRead<0)
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
}
|
||||||
|
else // After the timeout the bytes waiting were less then we expected
|
||||||
|
if (LastTcpError==WSAETIMEDOUT)
|
||||||
|
Purge();
|
||||||
|
|
||||||
|
if (LastTcpError==WSAECONNRESET)
|
||||||
|
Connected =false;
|
||||||
|
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TMsgSocket::PeekPacket(void *Data, int Size)
|
||||||
|
{
|
||||||
|
int BytesRead;
|
||||||
|
WaitForData(Size, RecvTimeout);
|
||||||
|
if (LastTcpError==0)
|
||||||
|
{
|
||||||
|
BytesRead=recv(FSocket, (char*)Data, Size, MSG_PEEK | MSG_NOSIGNAL );
|
||||||
|
if (BytesRead==0)
|
||||||
|
LastTcpError = WSAECONNRESET; // Connection reset by Peer
|
||||||
|
else
|
||||||
|
if (BytesRead<0)
|
||||||
|
LastTcpError = GetLastSocketError();
|
||||||
|
}
|
||||||
|
else // After the timeout the bytes waiting were less then we expected
|
||||||
|
if (LastTcpError==WSAETIMEDOUT)
|
||||||
|
Purge();
|
||||||
|
|
||||||
|
if (LastTcpError==WSAECONNRESET)
|
||||||
|
Connected =false;
|
||||||
|
|
||||||
|
return LastTcpError;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgSocket::Execute()
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
//==============================================================================
|
||||||
|
// PING
|
||||||
|
//==============================================================================
|
||||||
|
|
||||||
|
static int PingKind;
|
||||||
|
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
// iphlpapi, is loaded dinamically because if this fails we can still try
|
||||||
|
// to use raw sockets
|
||||||
|
|
||||||
|
static char const *iphlpapi = "\\iphlpapi.dll";
|
||||||
|
#pragma pack(1)
|
||||||
|
|
||||||
|
//typedef byte TTxBuffer[40];
|
||||||
|
typedef byte TTxBuffer[32];
|
||||||
|
#pragma pack()
|
||||||
|
|
||||||
|
typedef HANDLE (__stdcall *pfn_IcmpCreateFile)();
|
||||||
|
typedef bool (__stdcall *pfn_IcmpCloseHandle)(HANDLE PingHandle);
|
||||||
|
|
||||||
|
typedef int (__stdcall *pfn_IcmpSendEcho2)(
|
||||||
|
HANDLE PingHandle,
|
||||||
|
void *Event,
|
||||||
|
void *AcpRoutine,
|
||||||
|
void *AcpContext,
|
||||||
|
unsigned long DestinationAddress,
|
||||||
|
void *RequestData,
|
||||||
|
int RequestSize,
|
||||||
|
void *not_used, //should be *IP_OPTION_INFORMATION but we don't use it
|
||||||
|
void *ReplyBuffer,
|
||||||
|
int ReplySize,
|
||||||
|
int Timeout
|
||||||
|
);
|
||||||
|
|
||||||
|
static pfn_IcmpCreateFile IcmpCreateFile;
|
||||||
|
static pfn_IcmpCloseHandle IcmpCloseHandle;
|
||||||
|
static pfn_IcmpSendEcho2 IcmpSendEcho2;
|
||||||
|
static HINSTANCE IcmpDllHandle = 0;
|
||||||
|
static bool IcmpAvail = false;
|
||||||
|
|
||||||
|
bool IcmpInit()
|
||||||
|
{
|
||||||
|
char iphlppath[MAX_PATH+12];
|
||||||
|
|
||||||
|
int PathLen = GetSystemDirectoryA(iphlppath, MAX_PATH);
|
||||||
|
if (PathLen != 0)
|
||||||
|
{
|
||||||
|
strcat(iphlppath, iphlpapi);
|
||||||
|
IcmpDllHandle = LoadLibraryA(iphlppath);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
IcmpDllHandle = 0;
|
||||||
|
|
||||||
|
if (IcmpDllHandle != 0)
|
||||||
|
{
|
||||||
|
IcmpCreateFile=(pfn_IcmpCreateFile)GetProcAddress(IcmpDllHandle,"IcmpCreateFile");
|
||||||
|
IcmpCloseHandle=(pfn_IcmpCloseHandle)GetProcAddress(IcmpDllHandle,"IcmpCloseHandle");
|
||||||
|
IcmpSendEcho2=(pfn_IcmpSendEcho2)GetProcAddress(IcmpDllHandle,"IcmpSendEcho2");
|
||||||
|
return (IcmpCreateFile!=NULL) && (IcmpCloseHandle!=NULL) && (IcmpSendEcho2!=NULL);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void IcmpDone()
|
||||||
|
{
|
||||||
|
if (IcmpDllHandle!=0)
|
||||||
|
FreeLibrary(IcmpDllHandle);
|
||||||
|
IcmpAvail=false;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// RAW Socket Pinger
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TRawSocketPinger::TRawSocketPinger()
|
||||||
|
{
|
||||||
|
FSocket =socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
|
||||||
|
FId =word(size_t(this));
|
||||||
|
FSeq =0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TRawSocketPinger::~TRawSocketPinger()
|
||||||
|
{
|
||||||
|
if (FSocket!=INVALID_SOCKET)
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
closesocket(FSocket);
|
||||||
|
#else
|
||||||
|
close(FSocket);
|
||||||
|
#endif
|
||||||
|
FSocket=INVALID_SOCKET;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TRawSocketPinger::InitPacket()
|
||||||
|
{
|
||||||
|
memset(&IcmpBuffer,0,ICmpBufferSize);
|
||||||
|
FSeq++;
|
||||||
|
|
||||||
|
SendPacket=PIcmpPacket(pbyte(&IcmpBuffer)+sizeof(TIPHeader));
|
||||||
|
SendPacket->Header.ic_type=ICMP_ECHORQ;
|
||||||
|
SendPacket->Header.ic_code=0;
|
||||||
|
SendPacket->Header.ic_cksum=0;
|
||||||
|
SendPacket->Header.ic_id=FId;
|
||||||
|
SendPacket->Header.ic_seq=FSeq;
|
||||||
|
|
||||||
|
memset(&SendPacket->Data,0,sizeof(SendPacket->Data));
|
||||||
|
SendPacket->Header.ic_cksum=PacketChecksum();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
word TRawSocketPinger::PacketChecksum()
|
||||||
|
{
|
||||||
|
word *P = (word*)(SendPacket);
|
||||||
|
longword Sum = 0;
|
||||||
|
int c;
|
||||||
|
for (c = 0; c < int(sizeof(TIcmpPacket) / 2); c++) {
|
||||||
|
Sum+=*P;
|
||||||
|
P++;
|
||||||
|
}
|
||||||
|
Sum=(Sum >> 16) + (Sum & 0xFFFF);
|
||||||
|
Sum=Sum+(Sum >> 16);
|
||||||
|
return word(~Sum);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TRawSocketPinger::CanRead(int Timeout)
|
||||||
|
{
|
||||||
|
timeval TimeV;
|
||||||
|
int64_t x;
|
||||||
|
fd_set FDset;
|
||||||
|
|
||||||
|
TimeV.tv_usec = (Timeout % 1000) * 1000;
|
||||||
|
TimeV.tv_sec = Timeout / 1000;
|
||||||
|
|
||||||
|
FD_ZERO(&FDset);
|
||||||
|
FD_SET(FSocket, &FDset);
|
||||||
|
|
||||||
|
x = select(FSocket + 1, &FDset, NULL, NULL, &TimeV); //<-Ignore this warning in 64bit Visual Studio
|
||||||
|
if (x==(int)(SOCKET_ERROR))
|
||||||
|
x=0;
|
||||||
|
return (x > 0);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TRawSocketPinger::Ping(longword ip_addr, int Timeout)
|
||||||
|
{
|
||||||
|
sockaddr_in LSockAddr;
|
||||||
|
sockaddr_in RSockAddr;
|
||||||
|
PIcmpReply Reply;
|
||||||
|
|
||||||
|
if (FSocket==INVALID_SOCKET)
|
||||||
|
return true;
|
||||||
|
|
||||||
|
// Init packet
|
||||||
|
InitPacket();
|
||||||
|
Reply=PIcmpReply(&IcmpBuffer);
|
||||||
|
// Init Remote and Local Addresses struct
|
||||||
|
RSockAddr.sin_family=AF_INET;
|
||||||
|
RSockAddr.sin_port=0;
|
||||||
|
RSockAddr.sin_addr.s_addr=ip_addr;
|
||||||
|
|
||||||
|
LSockAddr.sin_family=AF_INET;
|
||||||
|
LSockAddr.sin_port=0;
|
||||||
|
LSockAddr.sin_addr.s_addr=inet_addr("0.0.0.0");
|
||||||
|
|
||||||
|
// Bind to local
|
||||||
|
if (bind(FSocket, (struct sockaddr*)&LSockAddr, sizeof(sockaddr_in))!=0)
|
||||||
|
return false;
|
||||||
|
// Connect to remote (not a really TCP connection, only to setup the socket)
|
||||||
|
if (connect(FSocket, (struct sockaddr*)&RSockAddr, sizeof(sockaddr_in))!=0)
|
||||||
|
return false;
|
||||||
|
// Send ICMP packet
|
||||||
|
if (send(FSocket, (char*)SendPacket, sizeof(TIcmpPacket), MSG_NOSIGNAL)!=int(sizeof(TIcmpPacket)))
|
||||||
|
return false;
|
||||||
|
// Wait for a reply
|
||||||
|
if (!CanRead(Timeout))
|
||||||
|
return false;// time expired
|
||||||
|
// Get the answer
|
||||||
|
if (recv(FSocket, (char*)&IcmpBuffer, ICmpBufferSize, MSG_NOSIGNAL)<int(sizeof(TIcmpReply)))
|
||||||
|
return false;
|
||||||
|
// Check the answer
|
||||||
|
return (Reply->IPH.ip_src==RSockAddr.sin_addr.s_addr) && // the peer is what we are looking for
|
||||||
|
(Reply->ICmpReply.Header.ic_type==ICMP_ECHORP); // type = reply
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// Pinger
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TPinger::TPinger()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TPinger::~TPinger()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TPinger::RawPing(longword ip_addr, int Timeout)
|
||||||
|
{
|
||||||
|
PRawSocketPinger RawPinger = new TRawSocketPinger();
|
||||||
|
bool Result;
|
||||||
|
Result=RawPinger->Ping(ip_addr, Timeout);
|
||||||
|
delete RawPinger;
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
bool TPinger::WinPing(longword ip_addr, int Timeout)
|
||||||
|
{
|
||||||
|
HANDLE PingHandle;
|
||||||
|
TTxBuffer TxBuffer;
|
||||||
|
TIcmpBuffer IcmpBuffer;
|
||||||
|
bool Result;
|
||||||
|
|
||||||
|
PingHandle = IcmpCreateFile();
|
||||||
|
if (PingHandle != INVALID_HANDLE_VALUE)
|
||||||
|
{
|
||||||
|
memset(&TxBuffer,'\55',sizeof(TTxBuffer));
|
||||||
|
Result=(IcmpSendEcho2(PingHandle, NULL, NULL, NULL, ip_addr,
|
||||||
|
&TxBuffer, sizeof(TxBuffer), NULL, &IcmpBuffer, ICmpBufferSize, Timeout))>0;
|
||||||
|
IcmpCloseHandle(PingHandle);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TPinger::Ping(char *Host, int Timeout)
|
||||||
|
{
|
||||||
|
longword Addr;
|
||||||
|
Addr=inet_addr(Host);
|
||||||
|
return Ping(Addr, Timeout);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TPinger::Ping(longword ip_addr, int Timeout)
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
if (PingKind==pkWinHelper)
|
||||||
|
return WinPing(ip_addr, Timeout);
|
||||||
|
else
|
||||||
|
#endif
|
||||||
|
if (PingKind==pkRawSocket)
|
||||||
|
return RawPing(ip_addr, Timeout);
|
||||||
|
else
|
||||||
|
return true; // we still need to continue
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// Checks if raw sockets are allowed
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool RawSocketsCheck()
|
||||||
|
{
|
||||||
|
socket_t RawSocket;
|
||||||
|
bool Result;
|
||||||
|
RawSocket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
|
||||||
|
|
||||||
|
Result=RawSocket != INVALID_SOCKET;
|
||||||
|
if (Result)
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
closesocket(RawSocket);
|
||||||
|
#else
|
||||||
|
close(RawSocket);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// Sockets init
|
||||||
|
// - Winsock Startup (Windows)
|
||||||
|
// - ICMP Helper Load (Windows)
|
||||||
|
// - Check for raw socket (Unix or Windows if ICMP load failed)
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
SocketsLayer::SocketsLayer()
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
timeBeginPeriod(1); // it's not strictly related to socket but here is a nice place
|
||||||
|
WSAStartup(0x202,&wsaData);
|
||||||
|
if (IcmpInit())
|
||||||
|
PingKind=pkWinHelper;
|
||||||
|
else
|
||||||
|
#endif
|
||||||
|
if (RawSocketsCheck())
|
||||||
|
PingKind=pkRawSocket;
|
||||||
|
else
|
||||||
|
PingKind=pkCannotPing;
|
||||||
|
}
|
||||||
|
|
||||||
|
SocketsLayer::~SocketsLayer()
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
IcmpDone();
|
||||||
|
WSACleanup();
|
||||||
|
timeEndPeriod(1);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
339
utils/snap7_src/src/sys/snap_msgsock.h
Normal file
339
utils/snap7_src/src/sys/snap_msgsock.h
Normal file
@ -0,0 +1,339 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef snap_msgsock_h
|
||||||
|
#define snap_msgsock_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#include "snap_platform.h"
|
||||||
|
#include "snap_sysutils.h"
|
||||||
|
//----------------------------------------------------------------------------
|
||||||
|
#if defined(OS_WINDOWS) || defined (OS_SOLARIS) || defined(OS_OSX)
|
||||||
|
# define MSG_NOSIGNAL 0
|
||||||
|
#endif
|
||||||
|
//----------------------------------------------------------------------------
|
||||||
|
// Non blocking connection to avoid root priviledges under UNIX
|
||||||
|
// i.e. raw socket pinger is not more used.
|
||||||
|
// Thanks to Rolf Stalder that made it ;)
|
||||||
|
//----------------------------------------------------------------------------
|
||||||
|
#ifdef PLATFORM_UNIX
|
||||||
|
#define NON_BLOCKING_CONNECT
|
||||||
|
#endif
|
||||||
|
#ifdef NON_BLOCKING_CONNECT
|
||||||
|
#include <fcntl.h>
|
||||||
|
#endif
|
||||||
|
//----------------------------------------------------------------------------
|
||||||
|
/*
|
||||||
|
In Windows sizeof socket varies depending of the platform :
|
||||||
|
win32 -> sizeof(SOCKET) = 4
|
||||||
|
win64 -> sizeof(SOCKET) = 8
|
||||||
|
|
||||||
|
Even though sizeof(SOCKET) is 8, should be safe to cast it to int, because
|
||||||
|
the value constitutes an index in per-process table of limited size
|
||||||
|
and not a real pointer.
|
||||||
|
|
||||||
|
Other Os define the socket as int regardless of the processor.
|
||||||
|
|
||||||
|
We want to sleep peacefully, so it's better to define a portable socket.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
typedef SOCKET socket_t;
|
||||||
|
#else
|
||||||
|
typedef int socket_t;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
//----------------------------------------------------------------------------
|
||||||
|
#define SD_RECEIVE 0x00
|
||||||
|
#define SD_SEND 0x01
|
||||||
|
#define SD_BOTH 0x02
|
||||||
|
#define MaxPacketSize 65536
|
||||||
|
|
||||||
|
//----------------------------------------------------------------------------
|
||||||
|
// For other platform we need to re-define next constants
|
||||||
|
#if defined(PLATFORM_UNIX) || defined(OS_OSX)
|
||||||
|
|
||||||
|
#define INVALID_SOCKET (socket_t)(~0)
|
||||||
|
#define SOCKET_ERROR (-1)
|
||||||
|
|
||||||
|
#define WSAEINTR EINTR
|
||||||
|
#define WSAEBADF EBADF
|
||||||
|
#define WSAEACCES EACCES
|
||||||
|
#define WSAEFAULT EFAULT
|
||||||
|
#define WSAEINVAL EINVAL
|
||||||
|
#define WSAEMFILE EMFILE
|
||||||
|
#define WSAEWOULDBLOCK EWOULDBLOCK
|
||||||
|
#define WSAEINPROGRESS EINPROGRESS
|
||||||
|
#define WSAEALREADY EALREADY
|
||||||
|
#define WSAENOTSOCK ENOTSOCK
|
||||||
|
#define WSAEDESTADDRREQ EDESTADDRREQ
|
||||||
|
#define WSAEMSGSIZE EMSGSIZE
|
||||||
|
#define WSAEPROTOTYPE EPROTOTYPE
|
||||||
|
#define WSAENOPROTOOPT ENOPROTOOPT
|
||||||
|
#define WSAEPROTONOSUPPORT EPROTONOSUPPORT
|
||||||
|
#define WSAESOCKTNOSUPPORT ESOCKTNOSUPPORT
|
||||||
|
#define WSAEOPNOTSUPP EOPNOTSUPP
|
||||||
|
#define WSAEPFNOSUPPORT EPFNOSUPPORT
|
||||||
|
#define WSAEAFNOSUPPORT EAFNOSUPPORT
|
||||||
|
#define WSAEADDRINUSE EADDRINUSE
|
||||||
|
#define WSAEADDRNOTAVAIL EADDRNOTAVAIL
|
||||||
|
#define WSAENETDOWN ENETDOWN
|
||||||
|
#define WSAENETUNREACH ENETUNREACH
|
||||||
|
#define WSAENETRESET ENETRESET
|
||||||
|
#define WSAECONNABORTED ECONNABORTED
|
||||||
|
#define WSAECONNRESET ECONNRESET
|
||||||
|
#define WSAENOBUFS ENOBUFS
|
||||||
|
#define WSAEISCONN EISCONN
|
||||||
|
#define WSAENOTCONN ENOTCONN
|
||||||
|
#define WSAESHUTDOWN ESHUTDOWN
|
||||||
|
#define WSAETOOMANYREFS ETOOMANYREFS
|
||||||
|
#define WSAETIMEDOUT ETIMEDOUT
|
||||||
|
#define WSAECONNREFUSED ECONNREFUSED
|
||||||
|
#define WSAELOOP ELOOP
|
||||||
|
#define WSAENAMETOOLONG ENAMETOOLONG
|
||||||
|
#define WSAEHOSTDOWN EHOSTDOWN
|
||||||
|
#define WSAEHOSTUNREACH EHOSTUNREACH
|
||||||
|
#define WSAENOTEMPTY ENOTEMPTY
|
||||||
|
#define WSAEUSERS EUSERS
|
||||||
|
#define WSAEDQUOT EDQUOT
|
||||||
|
#define WSAESTALE ESTALE
|
||||||
|
#define WSAEREMOTE EREMOTE
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define WSAEINVALIDADDRESS 12001
|
||||||
|
|
||||||
|
#define ICmpBufferSize 4096
|
||||||
|
typedef byte TIcmpBuffer[ICmpBufferSize];
|
||||||
|
|
||||||
|
// Ping result
|
||||||
|
#define PR_CANNOT_PERFORM -1 // cannot ping :
|
||||||
|
// unix : no root rights or SUID flag set to
|
||||||
|
// open raw sockets
|
||||||
|
// windows : neither helper DLL found nor raw
|
||||||
|
// sockets can be opened (no administrator rights)
|
||||||
|
// In this case the execution continues whitout
|
||||||
|
// the benefit of the smart-connect.
|
||||||
|
|
||||||
|
#define PR_SUCCESS 0 // Host found
|
||||||
|
#define PR_ERROR 1 // Ping Error, Ping was performed but ...
|
||||||
|
// - host didn't replied (not found)
|
||||||
|
// - routing error
|
||||||
|
// - TTL expired
|
||||||
|
// - ... all other icmp error that we don't need
|
||||||
|
// to know.
|
||||||
|
|
||||||
|
// Ping Kind
|
||||||
|
#define pkCannotPing 1 // see PR_CANNOT_PERFORM comments
|
||||||
|
#define pkWinHelper 2 // use iphlpapi.dll (only windows)
|
||||||
|
#define pkRawSocket 3 // use raw sockets (unix/windows)
|
||||||
|
|
||||||
|
const byte ICMP_ECHORP = 0; // ECHO Reply
|
||||||
|
const byte ICMP_ECHORQ = 8; // ECHO Request
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// RAW SOCKET PING STRUCTS
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#pragma pack(1)
|
||||||
|
typedef struct{
|
||||||
|
byte ip_hl_v;
|
||||||
|
byte ip_tos;
|
||||||
|
word ip_len;
|
||||||
|
word ip_id ;
|
||||||
|
word ip_off;
|
||||||
|
byte ip_ttl;
|
||||||
|
byte ip_p;
|
||||||
|
word ip_sum;
|
||||||
|
longword ip_src;
|
||||||
|
longword ip_dst;
|
||||||
|
}TIPHeader;
|
||||||
|
|
||||||
|
typedef struct{
|
||||||
|
byte ic_type; // Type of message
|
||||||
|
byte ic_code; // Code
|
||||||
|
word ic_cksum; // 16 bit checksum
|
||||||
|
word ic_id; // ID (ic1 : ipv4)
|
||||||
|
word ic_seq; // Sequence
|
||||||
|
}TIcmpHeader;
|
||||||
|
|
||||||
|
typedef struct{
|
||||||
|
TIcmpHeader Header;
|
||||||
|
byte Data[32]; // use the well known default
|
||||||
|
}TIcmpPacket, *PIcmpPacket;
|
||||||
|
|
||||||
|
typedef struct{
|
||||||
|
TIPHeader IPH;
|
||||||
|
TIcmpPacket ICmpReply;
|
||||||
|
}TIcmpReply, *PIcmpReply;
|
||||||
|
#pragma pack()
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class TRawSocketPinger
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
socket_t FSocket;
|
||||||
|
PIcmpPacket SendPacket;
|
||||||
|
TIcmpBuffer IcmpBuffer;
|
||||||
|
word FId, FSeq;
|
||||||
|
void InitPacket();
|
||||||
|
word PacketChecksum();
|
||||||
|
bool CanRead(int Timeout);
|
||||||
|
public:
|
||||||
|
bool Ping(longword ip_addr, int Timeout);
|
||||||
|
TRawSocketPinger();
|
||||||
|
~TRawSocketPinger();
|
||||||
|
};
|
||||||
|
typedef TRawSocketPinger *PRawSocketPinger;
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class TPinger
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
PRawSocketPinger RawPinger;
|
||||||
|
bool RawAvail;
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
bool WinPing(longword ip_addr, int Timeout);
|
||||||
|
#endif
|
||||||
|
bool RawPing(longword ip_addr, int Timeout);
|
||||||
|
public:
|
||||||
|
TPinger();
|
||||||
|
~TPinger();
|
||||||
|
bool Ping(char *Host, int Timeout);
|
||||||
|
bool Ping(longword ip_addr, int Timeout);
|
||||||
|
};
|
||||||
|
typedef TPinger *PPinger;
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class TSnapBase // base class endian-aware
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
bool LittleEndian;
|
||||||
|
protected:
|
||||||
|
longword SwapDWord(longword Value);
|
||||||
|
word SwapWord(word Value);
|
||||||
|
public:
|
||||||
|
TSnapBase();
|
||||||
|
};
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class TMsgSocket : public TSnapBase
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
PPinger Pinger;
|
||||||
|
int GetLastSocketError();
|
||||||
|
int SockCheck(int SockResult);
|
||||||
|
void DestroySocket();
|
||||||
|
void SetSocketOptions();
|
||||||
|
bool CanWrite(int Timeout);
|
||||||
|
void GetLocal();
|
||||||
|
void GetRemote();
|
||||||
|
void SetSin(sockaddr_in &sin, char *Address, u_short Port);
|
||||||
|
void GetSin(sockaddr_in sin, char *Address, u_short &Port);
|
||||||
|
protected:
|
||||||
|
socket_t FSocket;
|
||||||
|
sockaddr_in LocalSin;
|
||||||
|
sockaddr_in RemoteSin;
|
||||||
|
//--------------------------------------------------------------------------
|
||||||
|
// low level socket
|
||||||
|
void CreateSocket();
|
||||||
|
// Called when a socket is assigned externally
|
||||||
|
void GotSocket();
|
||||||
|
// Returns how many bytes are ready to be read in the winsock buffer
|
||||||
|
int WaitingData();
|
||||||
|
// Waits until there at least "size" bytes ready to be read or until receive timeout occurs
|
||||||
|
int WaitForData(int Size, int Timeout);
|
||||||
|
// Clear socket input buffer
|
||||||
|
void Purge();
|
||||||
|
public:
|
||||||
|
longword ClientHandle;
|
||||||
|
longword LocalBind;
|
||||||
|
// Coordinates Address:Port
|
||||||
|
char LocalAddress[16];
|
||||||
|
char RemoteAddress[16];
|
||||||
|
word LocalPort;
|
||||||
|
word RemotePort;
|
||||||
|
// "speed" of the socket listener (used server-side)
|
||||||
|
int WorkInterval;
|
||||||
|
// Timeouts : 3 different values for fine tuning.
|
||||||
|
// Send timeout should be small since with work with small packets and TCP_NO_DELAY
|
||||||
|
// option, so we don't expect "time to wait".
|
||||||
|
// Recv timeout depends of equipment's processing time : we send a packet, the equipment
|
||||||
|
// processes the message, finally it sends the answer. In any case Recv timeout > Send Timeout.
|
||||||
|
// PingTimeout is the maximum time interval during which we expect that the PLC answers.
|
||||||
|
// By default is 750 ms, increase it if there are many switch/repeaters.
|
||||||
|
int PingTimeout;
|
||||||
|
int RecvTimeout;
|
||||||
|
int SendTimeout;
|
||||||
|
//int ConnTimeout;
|
||||||
|
// Output : Last operation error
|
||||||
|
int LastTcpError;
|
||||||
|
// Output : Connected to the remote Host/Peer/Client
|
||||||
|
bool Connected;
|
||||||
|
//--------------------------------------------------------------------------
|
||||||
|
TMsgSocket();
|
||||||
|
virtual ~TMsgSocket();
|
||||||
|
// Returns true if "something" can be read during the Timeout interval..
|
||||||
|
bool CanRead(int Timeout);
|
||||||
|
// Connects to a peer (using RemoteAddress and RemotePort)
|
||||||
|
int SckConnect(); // (client-side)
|
||||||
|
// Disconnects from a peer (gracefully)
|
||||||
|
void SckDisconnect();
|
||||||
|
// Disconnects RAW
|
||||||
|
void ForceClose();
|
||||||
|
// Binds to a local adapter (using LocalAddress and LocalPort) (server-side)
|
||||||
|
int SckBind();
|
||||||
|
// Listens for an incoming connection (server-side)
|
||||||
|
int SckListen();
|
||||||
|
// Set an external socket reference (tipically from a listener)
|
||||||
|
void SetSocket(socket_t s);
|
||||||
|
// Accepts an incoming connection returning a socket descriptor (server-side)
|
||||||
|
socket_t SckAccept();
|
||||||
|
// Pings the peer before connecting
|
||||||
|
bool Ping(char *Host);
|
||||||
|
bool Ping(sockaddr_in Addr);
|
||||||
|
// Sends a packet
|
||||||
|
int SendPacket(void *Data, int Size);
|
||||||
|
// Returns true if a Packet at least of "Size" bytes is ready to be read
|
||||||
|
bool PacketReady(int Size);
|
||||||
|
// Receives everything
|
||||||
|
int Receive(void *Data, int BufSize, int & SizeRecvd);
|
||||||
|
// Receives a packet of size specified.
|
||||||
|
int RecvPacket(void *Data, int Size);
|
||||||
|
// Peeks a packet of size specified without extract it from the socket queue
|
||||||
|
int PeekPacket(void *Data, int Size);
|
||||||
|
virtual bool Execute();
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef TMsgSocket *PMsgSocket;
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void Msg_CloseSocket(socket_t FSocket);
|
||||||
|
longword Msg_GetSockAddr(socket_t FSocket);
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class SocketsLayer
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
WSADATA wsaData;
|
||||||
|
#endif
|
||||||
|
public:
|
||||||
|
SocketsLayer();
|
||||||
|
~SocketsLayer();
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // snap_msgsock_h
|
||||||
152
utils/snap7_src/src/sys/snap_platform.h
Normal file
152
utils/snap7_src/src/sys/snap_platform.h
Normal file
@ -0,0 +1,152 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| PROJECT SNAP7 1.4.1 |
|
||||||
|
|==============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef snap_platform_h
|
||||||
|
#define snap_platform_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#if defined (_WIN32)|| defined(_WIN64)|| defined(__WIN32__) || defined(__WINDOWS__)
|
||||||
|
# define OS_WINDOWS
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Visual Studio needs this to use the correct time_t size
|
||||||
|
#if defined (_WIN32) && !defined(_WIN64) && !defined(_EMBEDDING_VS2013UP)
|
||||||
|
# define _USE_32BIT_TIME_T
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Linux, BSD and Solaris define "unix", OSX doesn't, even though it derives from BSD
|
||||||
|
#if defined(unix) || defined(__unix__) || defined(__unix)
|
||||||
|
# define PLATFORM_UNIX
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if BSD>=0
|
||||||
|
# define OS_BSD
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if __APPLE__
|
||||||
|
# define OS_OSX
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__SVR4) || defined(__svr4__)
|
||||||
|
# define OS_SOLARIS
|
||||||
|
// Thanks to Rolf Stalder now it's possible to use pthreads also for Solaris
|
||||||
|
// In any case the Solaris native threads model is still present and can be
|
||||||
|
// used uncommenting the #define line below.
|
||||||
|
# undef OS_SOLARIS_NATIVE_THREADS
|
||||||
|
// # define OS_SOLARIS_NATIVE_THREADS
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(PLATFORM_UNIX)
|
||||||
|
# include <unistd.h>
|
||||||
|
# include <sys/param.h>
|
||||||
|
# if defined(_POSIX_VERSION)
|
||||||
|
# define POSIX
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef OS_OSX
|
||||||
|
# include <unistd.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if (!defined (OS_WINDOWS)) && (!defined(PLATFORM_UNIX)) && (!defined(OS_BSD)) && (!defined(OS_OSX))
|
||||||
|
# error platform still unsupported (please add it yourself and report ;-)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Visual C++ not C99 compliant (VS2008--)
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
# if _MSC_VER >= 1600
|
||||||
|
# include <stdint.h> // VS2010++ have it
|
||||||
|
# else
|
||||||
|
typedef signed __int8 int8_t;
|
||||||
|
typedef signed __int16 int16_t;
|
||||||
|
typedef signed __int32 int32_t;
|
||||||
|
typedef signed __int64 int64_t;
|
||||||
|
typedef unsigned __int8 uint8_t;
|
||||||
|
typedef unsigned __int16 uint16_t;
|
||||||
|
typedef unsigned __int32 uint32_t;
|
||||||
|
typedef unsigned __int64 uint64_t;
|
||||||
|
#ifdef _WIN64
|
||||||
|
typedef unsigned __int64 uintptr_t;
|
||||||
|
#else
|
||||||
|
typedef unsigned __int32 uintptr_t;
|
||||||
|
#endif
|
||||||
|
# endif
|
||||||
|
#else
|
||||||
|
# include <stdint.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include <time.h>
|
||||||
|
#include <cstring>
|
||||||
|
#include <stdlib.h>
|
||||||
|
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
# define WIN32_LEAN_AND_MEAN
|
||||||
|
# include <windows.h>
|
||||||
|
# include <winsock2.h>
|
||||||
|
# include <mmsystem.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef OS_SOLARIS
|
||||||
|
# include <sys/filio.h>
|
||||||
|
# include <cstdlib>
|
||||||
|
# include <string.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(PLATFORM_UNIX) || defined(OS_OSX)
|
||||||
|
# include <errno.h>
|
||||||
|
# include <sys/time.h>
|
||||||
|
# include <sys/socket.h>
|
||||||
|
# include <arpa/inet.h>
|
||||||
|
# include <netinet/tcp.h>
|
||||||
|
# include <netinet/in.h>
|
||||||
|
# include <sys/ioctl.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
# define EXPORTSPEC extern "C" __declspec ( dllexport )
|
||||||
|
# define S7API __stdcall
|
||||||
|
#else
|
||||||
|
# define EXPORTSPEC extern "C"
|
||||||
|
# define S7API
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Exact length types regardless of platform/processor
|
||||||
|
// We absolute need of them, all structs have an exact size that
|
||||||
|
// must be the same across the processor used 32/64 bit
|
||||||
|
|
||||||
|
// *Use them* if you change/expand the code and avoid long, u_long and so on...
|
||||||
|
|
||||||
|
typedef uint8_t byte;
|
||||||
|
typedef uint16_t word;
|
||||||
|
typedef uint32_t longword;
|
||||||
|
typedef byte *pbyte;
|
||||||
|
typedef word *pword;
|
||||||
|
typedef uintptr_t snap_obj; // multi platform/processor object reference
|
||||||
|
|
||||||
|
#ifndef OS_WINDOWS
|
||||||
|
# define INFINITE 0XFFFFFFFF
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
#endif // snap_platform_h
|
||||||
73
utils/snap7_src/src/sys/snap_sysutils.cpp
Normal file
73
utils/snap7_src/src/sys/snap_sysutils.cpp
Normal file
@ -0,0 +1,73 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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 "snap_sysutils.h"
|
||||||
|
|
||||||
|
#ifdef OS_OSX
|
||||||
|
int clock_gettime(int clk_id, struct timespec* t)
|
||||||
|
{
|
||||||
|
struct timeval now;
|
||||||
|
int rv = gettimeofday(&now, NULL);
|
||||||
|
if (rv) return rv;
|
||||||
|
t->tv_sec = now.tv_sec;
|
||||||
|
t->tv_nsec = now.tv_usec * 1000;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
longword SysGetTick()
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
return timeGetTime();
|
||||||
|
#else
|
||||||
|
struct timespec ts;
|
||||||
|
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||||
|
return (longword) (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void SysSleep(longword Delay_ms)
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
Sleep(Delay_ms);
|
||||||
|
#else
|
||||||
|
struct timespec ts;
|
||||||
|
ts.tv_sec = (time_t)(Delay_ms / 1000);
|
||||||
|
ts.tv_nsec =(long)((Delay_ms - ts.tv_sec) * 1000000);
|
||||||
|
nanosleep(&ts, (struct timespec *)0);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
longword DeltaTime(longword &Elapsed)
|
||||||
|
{
|
||||||
|
longword TheTime;
|
||||||
|
TheTime=SysGetTick();
|
||||||
|
// Checks for rollover
|
||||||
|
if (TheTime<Elapsed)
|
||||||
|
Elapsed=0;
|
||||||
|
return TheTime-Elapsed;
|
||||||
|
}
|
||||||
39
utils/snap7_src/src/sys/snap_sysutils.h
Normal file
39
utils/snap7_src/src/sys/snap_sysutils.h
Normal file
@ -0,0 +1,39 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef snap_sysutils_h
|
||||||
|
#define snap_sysutils_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#include "snap_platform.h"
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#ifdef OS_OSX
|
||||||
|
# define CLOCK_MONOTONIC 0
|
||||||
|
#endif
|
||||||
|
|
||||||
|
longword SysGetTick();
|
||||||
|
void SysSleep(longword Delay_ms);
|
||||||
|
longword DeltaTime(longword &Elapsed);
|
||||||
|
|
||||||
|
#endif // snap_sysutils_h
|
||||||
487
utils/snap7_src/src/sys/snap_tcpsrvr.cpp
Normal file
487
utils/snap7_src/src/sys/snap_tcpsrvr.cpp
Normal file
@ -0,0 +1,487 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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 "snap_tcpsrvr.h"
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// EVENTS QUEUE
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
TMsgEventQueue::TMsgEventQueue(const int Capacity, const int BlockSize)
|
||||||
|
{
|
||||||
|
FCapacity = Capacity;
|
||||||
|
Max = FCapacity - 1;
|
||||||
|
FBlockSize = BlockSize;
|
||||||
|
Buffer = new byte[FCapacity * FBlockSize];
|
||||||
|
Flush();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TMsgEventQueue::~TMsgEventQueue()
|
||||||
|
{
|
||||||
|
delete[] Buffer;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgEventQueue::Flush()
|
||||||
|
{
|
||||||
|
IndexIn = 0;
|
||||||
|
IndexOut = 0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgEventQueue::Insert(void *lpdata)
|
||||||
|
{
|
||||||
|
pbyte PBlock;
|
||||||
|
if (!Full())
|
||||||
|
{
|
||||||
|
// Calc offset
|
||||||
|
if (IndexIn < Max) IndexIn++;
|
||||||
|
else IndexIn = 0;
|
||||||
|
PBlock = Buffer + uintptr_t(IndexIn * FBlockSize);
|
||||||
|
memcpy(PBlock, lpdata, FBlockSize);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgEventQueue::Extract(void *lpdata)
|
||||||
|
{
|
||||||
|
int IdxOut;
|
||||||
|
pbyte PBlock;
|
||||||
|
|
||||||
|
if (!Empty())
|
||||||
|
{
|
||||||
|
// stores IndexOut
|
||||||
|
IdxOut = IndexOut;
|
||||||
|
if (IdxOut < Max) IdxOut++;
|
||||||
|
else IdxOut = 0;
|
||||||
|
PBlock = Buffer + uintptr_t(IdxOut * FBlockSize);
|
||||||
|
// moves data
|
||||||
|
memcpy(lpdata, PBlock, FBlockSize);
|
||||||
|
// Updates IndexOut
|
||||||
|
IndexOut = IdxOut;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgEventQueue::Empty()
|
||||||
|
{
|
||||||
|
return (IndexIn == IndexOut);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TMsgEventQueue::Full()
|
||||||
|
{
|
||||||
|
int IdxOut = IndexOut; // To avoid troubles if IndexOut changes during next line
|
||||||
|
return ( (IdxOut == IndexIn + 1) || ((IndexIn == Max) && (IdxOut == 0)));
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// WORKER THREAD
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TMsgWorkerThread::TMsgWorkerThread(TMsgSocket *Socket, TCustomMsgServer *Server)
|
||||||
|
{
|
||||||
|
FreeOnTerminate = true;
|
||||||
|
WorkerSocket = Socket;
|
||||||
|
FServer = Server;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TMsgWorkerThread::Execute()
|
||||||
|
{
|
||||||
|
bool Exception = false;
|
||||||
|
bool SelfClose = false;
|
||||||
|
// Working loop
|
||||||
|
while (!Terminated && !SelfClose && !Exception && !FServer->Destroying)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (!WorkerSocket->Execute()) // False -> End of Activities
|
||||||
|
SelfClose = true;
|
||||||
|
} catch (...)
|
||||||
|
{
|
||||||
|
Exception = true;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
if (!FServer->Destroying)
|
||||||
|
{
|
||||||
|
// Exception detected during Worker activity
|
||||||
|
if (Exception)
|
||||||
|
{
|
||||||
|
WorkerSocket->ForceClose();
|
||||||
|
FServer->DoEvent(WorkerSocket->ClientHandle, evcClientException, 0, 0, 0, 0, 0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
if (SelfClose)
|
||||||
|
{
|
||||||
|
FServer->DoEvent(WorkerSocket->ClientHandle, evcClientDisconnected, 0, 0, 0, 0, 0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
FServer->DoEvent(WorkerSocket->ClientHandle, evcClientTerminated, 0, 0, 0, 0, 0);
|
||||||
|
}
|
||||||
|
delete WorkerSocket;
|
||||||
|
// Delete reference from list
|
||||||
|
FServer->Delete(Index);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// LISTENER THREAD
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
TMsgListenerThread::TMsgListenerThread(TMsgSocket *Listener, TCustomMsgServer *Server)
|
||||||
|
{
|
||||||
|
FServer = Server;
|
||||||
|
FListener = Listener;
|
||||||
|
FreeOnTerminate = false;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
void TMsgListenerThread::Execute()
|
||||||
|
{
|
||||||
|
socket_t Sock;
|
||||||
|
bool Valid;
|
||||||
|
|
||||||
|
while (!Terminated)
|
||||||
|
{
|
||||||
|
if (FListener->CanRead(FListener->WorkInterval))
|
||||||
|
{
|
||||||
|
Sock = FListener->SckAccept(); // in any case we must accept
|
||||||
|
Valid = Sock != INVALID_SOCKET;
|
||||||
|
// check if we are not destroying
|
||||||
|
if ((!Terminated) && (!FServer->Destroying))
|
||||||
|
{
|
||||||
|
if (Valid)
|
||||||
|
FServer->Incoming(Sock);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
if (Valid)
|
||||||
|
Msg_CloseSocket(Sock);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// TCP SERVER
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TCustomMsgServer::TCustomMsgServer()
|
||||||
|
{
|
||||||
|
strcpy(FLocalAddress, "0.0.0.0");
|
||||||
|
CSList = new TSnapCriticalSection();
|
||||||
|
CSEvent = new TSnapCriticalSection();
|
||||||
|
FEventQueue = new TMsgEventQueue(MaxEvents, sizeof (TSrvEvent));
|
||||||
|
memset(Workers, 0, sizeof (Workers));
|
||||||
|
for (int i = 0; i < MaxWorkers; i++)
|
||||||
|
Workers[i] = NULL;
|
||||||
|
Status = SrvStopped;
|
||||||
|
EventMask = 0xFFFFFFFF;
|
||||||
|
LogMask = 0xFFFFFFFF;
|
||||||
|
Destroying = false;
|
||||||
|
FLastError = 0;
|
||||||
|
ClientsCount = 0;
|
||||||
|
LocalBind = 0;
|
||||||
|
MaxClients = MaxWorkers;
|
||||||
|
OnEvent = NULL;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TCustomMsgServer::~TCustomMsgServer()
|
||||||
|
{
|
||||||
|
Destroying = true;
|
||||||
|
Stop();
|
||||||
|
OnEvent = NULL;
|
||||||
|
delete CSList;
|
||||||
|
delete CSEvent;
|
||||||
|
delete FEventQueue;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::LockList()
|
||||||
|
{
|
||||||
|
CSList->Enter();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::UnlockList()
|
||||||
|
{
|
||||||
|
CSList->Leave();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TCustomMsgServer::FirstFree()
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
for (i = 0; i < MaxWorkers; i++)
|
||||||
|
{
|
||||||
|
if (Workers[i] == 0)
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
int TCustomMsgServer::StartListener()
|
||||||
|
{
|
||||||
|
int Result;
|
||||||
|
// Creates the listener
|
||||||
|
SockListener = new TMsgSocket();
|
||||||
|
strncpy(SockListener->LocalAddress, FLocalAddress, 16);
|
||||||
|
SockListener->LocalPort = LocalPort;
|
||||||
|
// Binds
|
||||||
|
Result = SockListener->SckBind();
|
||||||
|
if (Result == 0)
|
||||||
|
{
|
||||||
|
LocalBind = SockListener->LocalBind;
|
||||||
|
// Listen
|
||||||
|
Result = SockListener->SckListen();
|
||||||
|
if (Result == 0)
|
||||||
|
{
|
||||||
|
// Creates the Listener thread
|
||||||
|
ServerThread = new TMsgListenerThread(SockListener, this);
|
||||||
|
ServerThread->Start();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
delete SockListener;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
delete SockListener;
|
||||||
|
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::TerminateAll()
|
||||||
|
{
|
||||||
|
int c;
|
||||||
|
longword Elapsed;
|
||||||
|
bool Timeout;
|
||||||
|
|
||||||
|
if (ClientsCount > 0)
|
||||||
|
{
|
||||||
|
for (c = 0; c < MaxWorkers; c++)
|
||||||
|
{
|
||||||
|
if (Workers[c] != 0)
|
||||||
|
PMsgWorkerThread(Workers[c])->Terminate();
|
||||||
|
}
|
||||||
|
// Wait for closing
|
||||||
|
Elapsed = SysGetTick();
|
||||||
|
Timeout = false;
|
||||||
|
while (!Timeout && (ClientsCount > 0))
|
||||||
|
{
|
||||||
|
Timeout = DeltaTime(Elapsed) > WkTimeout;
|
||||||
|
if (!Timeout)
|
||||||
|
SysSleep(100);
|
||||||
|
};
|
||||||
|
if (ClientsCount > 0)
|
||||||
|
KillAll(); // one o more threads are hanged
|
||||||
|
ClientsCount = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::KillAll()
|
||||||
|
{
|
||||||
|
int c, cnt = 0;
|
||||||
|
LockList();
|
||||||
|
for (c = 0; c < MaxWorkers; c++)
|
||||||
|
{
|
||||||
|
if (Workers[c] != 0)
|
||||||
|
try
|
||||||
|
{
|
||||||
|
PMsgWorkerThread(Workers[c])->Kill();
|
||||||
|
PMsgWorkerThread(Workers[c])->WorkerSocket->ForceClose();
|
||||||
|
delete PMsgWorkerThread(Workers[c]);
|
||||||
|
Workers[c] = 0;
|
||||||
|
cnt++;
|
||||||
|
} catch (...)
|
||||||
|
{
|
||||||
|
};
|
||||||
|
}
|
||||||
|
UnlockList();
|
||||||
|
DoEvent(0, evcClientsDropped, 0, cnt, 0, 0, 0);
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TCustomMsgServer::CanAccept(socket_t Socket)
|
||||||
|
{
|
||||||
|
return ((MaxClients == 0) || (ClientsCount < MaxClients));
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
PWorkerSocket TCustomMsgServer::CreateWorkerSocket(socket_t Sock)
|
||||||
|
{
|
||||||
|
PWorkerSocket Result;
|
||||||
|
// Creates a funny default class : a tcp echo worker
|
||||||
|
Result = new TEcoTcpWorker();
|
||||||
|
Result->SetSocket(Sock);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::DoEvent(int Sender, longword Code, word RetCode, word Param1, word Param2, word Param3, word Param4)
|
||||||
|
{
|
||||||
|
TSrvEvent SrvEvent;
|
||||||
|
bool GoLog = (Code & LogMask) != 0;
|
||||||
|
bool GoEvent = (Code & EventMask) != 0;
|
||||||
|
|
||||||
|
if (!Destroying && (GoLog || GoEvent))
|
||||||
|
{
|
||||||
|
CSEvent->Enter();
|
||||||
|
|
||||||
|
time(&SrvEvent.EvtTime);
|
||||||
|
SrvEvent.EvtSender = Sender;
|
||||||
|
SrvEvent.EvtCode = Code;
|
||||||
|
SrvEvent.EvtRetCode = RetCode;
|
||||||
|
SrvEvent.EvtParam1 = Param1;
|
||||||
|
SrvEvent.EvtParam2 = Param2;
|
||||||
|
SrvEvent.EvtParam3 = Param3;
|
||||||
|
SrvEvent.EvtParam4 = Param4;
|
||||||
|
|
||||||
|
if (GoEvent && (OnEvent != NULL))
|
||||||
|
try
|
||||||
|
{ // callback is outside here, we have to shield it
|
||||||
|
OnEvent(FUsrPtr, &SrvEvent, sizeof (TSrvEvent));
|
||||||
|
} catch (...)
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
if (GoLog)
|
||||||
|
FEventQueue->Insert(&SrvEvent);
|
||||||
|
|
||||||
|
CSEvent->Leave();
|
||||||
|
};
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::Delete(int Index)
|
||||||
|
{
|
||||||
|
LockList();
|
||||||
|
Workers[Index] = 0;
|
||||||
|
ClientsCount--;
|
||||||
|
UnlockList();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::Incoming(socket_t Sock)
|
||||||
|
{
|
||||||
|
int idx;
|
||||||
|
PWorkerSocket WorkerSocket;
|
||||||
|
longword ClientHandle = Msg_GetSockAddr(Sock);
|
||||||
|
|
||||||
|
if (CanAccept(Sock))
|
||||||
|
{
|
||||||
|
LockList();
|
||||||
|
// First position available in the thread buffer
|
||||||
|
idx = FirstFree();
|
||||||
|
if (idx >= 0)
|
||||||
|
{
|
||||||
|
// Creates the Worker and assigns it the connected socket
|
||||||
|
WorkerSocket = CreateWorkerSocket(Sock);
|
||||||
|
// Creates the Worker thread
|
||||||
|
Workers[idx] = new TMsgWorkerThread(WorkerSocket, this);
|
||||||
|
PMsgWorkerThread(Workers[idx])->Index = idx;
|
||||||
|
// Update the number
|
||||||
|
ClientsCount++;
|
||||||
|
// And Starts the worker
|
||||||
|
PMsgWorkerThread(Workers[idx])->Start();
|
||||||
|
DoEvent(WorkerSocket->ClientHandle, evcClientAdded, 0, 0, 0, 0, 0);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
DoEvent(ClientHandle, evcClientNoRoom, 0, 0, 0, 0, 0);
|
||||||
|
Msg_CloseSocket(Sock);
|
||||||
|
}
|
||||||
|
UnlockList();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Msg_CloseSocket(Sock);
|
||||||
|
DoEvent(ClientHandle, evcClientRejected, 0, 0, 0, 0, 0);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TCustomMsgServer::Start()
|
||||||
|
{
|
||||||
|
int Result = 0;
|
||||||
|
if (Status != SrvRunning)
|
||||||
|
{
|
||||||
|
Result = StartListener();
|
||||||
|
if (Result != 0)
|
||||||
|
{
|
||||||
|
DoEvent(0, evcListenerCannotStart, Result, 0, 0, 0, 0);
|
||||||
|
Status = SrvError;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
DoEvent(0, evcServerStarted, SockListener->ClientHandle, LocalPort, 0, 0, 0);
|
||||||
|
Status = SrvRunning;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
FLastError = Result;
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TCustomMsgServer::StartTo(const char *Address, word Port)
|
||||||
|
{
|
||||||
|
strncpy(FLocalAddress, Address, 16);
|
||||||
|
LocalPort = Port;
|
||||||
|
return Start();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::Stop()
|
||||||
|
{
|
||||||
|
if (Status == SrvRunning)
|
||||||
|
{
|
||||||
|
// Kills the listener thread
|
||||||
|
ServerThread->Terminate();
|
||||||
|
if (ServerThread->WaitFor(ThTimeout) != WAIT_OBJECT_0)
|
||||||
|
ServerThread->Kill();
|
||||||
|
delete ServerThread;
|
||||||
|
// Kills the listener
|
||||||
|
delete SockListener;
|
||||||
|
|
||||||
|
// Terminate all client threads
|
||||||
|
TerminateAll();
|
||||||
|
|
||||||
|
Status = SrvStopped;
|
||||||
|
LocalBind = 0;
|
||||||
|
DoEvent(0, evcServerStopped, 0, 0, 0, 0, 0);
|
||||||
|
};
|
||||||
|
FLastError = 0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
int TCustomMsgServer::SetEventsCallBack(pfn_SrvCallBack PCallBack, void *UsrPtr)
|
||||||
|
{
|
||||||
|
OnEvent = PCallBack;
|
||||||
|
FUsrPtr = UsrPtr;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TCustomMsgServer::PickEvent(void *pEvent)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
return FEventQueue->Extract(pEvent);
|
||||||
|
} catch (...)
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
bool TCustomMsgServer::EventEmpty()
|
||||||
|
{
|
||||||
|
return FEventQueue->Empty();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TCustomMsgServer::EventsFlush()
|
||||||
|
{
|
||||||
|
CSEvent->Enter();
|
||||||
|
FEventQueue->Flush();
|
||||||
|
CSEvent->Leave();
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
247
utils/snap7_src/src/sys/snap_tcpsrvr.h
Normal file
247
utils/snap7_src/src/sys/snap_tcpsrvr.h
Normal file
@ -0,0 +1,247 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef snap_tcpsrvr_h
|
||||||
|
#define snap_tcpsrvr_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#include "snap_msgsock.h"
|
||||||
|
#include "snap_threads.h"
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
#define MaxWorkers 1024
|
||||||
|
#define MaxEvents 1500
|
||||||
|
|
||||||
|
const int SrvStopped = 0;
|
||||||
|
const int SrvRunning = 1;
|
||||||
|
const int SrvError = 2;
|
||||||
|
|
||||||
|
const longword evcServerStarted = 0x00000001;
|
||||||
|
const longword evcServerStopped = 0x00000002;
|
||||||
|
const longword evcListenerCannotStart = 0x00000004;
|
||||||
|
const longword evcClientAdded = 0x00000008;
|
||||||
|
const longword evcClientRejected = 0x00000010;
|
||||||
|
const longword evcClientNoRoom = 0x00000020;
|
||||||
|
const longword evcClientException = 0x00000040;
|
||||||
|
const longword evcClientDisconnected = 0x00000080;
|
||||||
|
const longword evcClientTerminated = 0x00000100;
|
||||||
|
const longword evcClientsDropped = 0x00000200;
|
||||||
|
const longword evcReserved_00000400 = 0x00000400;
|
||||||
|
const longword evcReserved_00000800 = 0x00000800;
|
||||||
|
const longword evcReserved_00001000 = 0x00001000;
|
||||||
|
const longword evcReserved_00002000 = 0x00002000;
|
||||||
|
const longword evcReserved_00004000 = 0x00004000;
|
||||||
|
const longword evcReserved_00008000 = 0x00008000;
|
||||||
|
|
||||||
|
// Server Interface errors
|
||||||
|
const longword errSrvBase = 0x0000FFFF;
|
||||||
|
const longword errSrvMask = 0xFFFF0000;
|
||||||
|
const longword errSrvCannotStart = 0x00100000;
|
||||||
|
|
||||||
|
const longword ThTimeout = 2000; // Thread timeout
|
||||||
|
const longword WkTimeout = 3000; // Workers termination timeout
|
||||||
|
|
||||||
|
#pragma pack(1)
|
||||||
|
|
||||||
|
typedef struct{
|
||||||
|
time_t EvtTime; // Timestamp
|
||||||
|
int EvtSender; // Sender
|
||||||
|
longword EvtCode; // Event code
|
||||||
|
word EvtRetCode; // Event result
|
||||||
|
word EvtParam1; // Param 1 (if available)
|
||||||
|
word EvtParam2; // Param 2 (if available)
|
||||||
|
word EvtParam3; // Param 3 (if available)
|
||||||
|
word EvtParam4; // Param 4 (if available)
|
||||||
|
}TSrvEvent, *PSrvEvent;
|
||||||
|
|
||||||
|
extern "C"
|
||||||
|
{
|
||||||
|
typedef void (S7API *pfn_SrvCallBack)(void * usrPtr, PSrvEvent PEvent, int Size);
|
||||||
|
}
|
||||||
|
#pragma pack()
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// EVENTS QUEUE
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class TMsgEventQueue
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
int IndexIn; // <-- insert index
|
||||||
|
int IndexOut; // --> extract index
|
||||||
|
int Max; // Buffer upper bound [0..Max]
|
||||||
|
int FCapacity; // Queue capacity
|
||||||
|
pbyte Buffer;
|
||||||
|
int FBlockSize;
|
||||||
|
public:
|
||||||
|
TMsgEventQueue(const int Capacity, const int BlockSize);
|
||||||
|
~TMsgEventQueue();
|
||||||
|
void Flush();
|
||||||
|
void Insert(void *lpdata);
|
||||||
|
bool Extract(void *lpdata);
|
||||||
|
bool Empty();
|
||||||
|
bool Full();
|
||||||
|
};
|
||||||
|
typedef TMsgEventQueue *PMsgEventQueue;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// WORKER THREAD
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class TCustomMsgServer; // forward declaration
|
||||||
|
|
||||||
|
// It's created when connection is accepted, it will interface with the client.
|
||||||
|
class TMsgWorkerThread : public TSnapThread
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
TCustomMsgServer *FServer;
|
||||||
|
protected:
|
||||||
|
TMsgSocket *WorkerSocket;
|
||||||
|
public:
|
||||||
|
int Index;
|
||||||
|
friend class TCustomMsgServer;
|
||||||
|
TMsgWorkerThread(TMsgSocket *Socket, TCustomMsgServer *Server);
|
||||||
|
void Execute();
|
||||||
|
};
|
||||||
|
typedef TMsgWorkerThread *PMsgWorkerThread;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// LISTENER THREAD
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// It listens for incoming connection.
|
||||||
|
class TMsgListenerThread : public TSnapThread
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
TMsgSocket *FListener;
|
||||||
|
TCustomMsgServer *FServer;
|
||||||
|
public:
|
||||||
|
TMsgListenerThread(TMsgSocket *Listener, TCustomMsgServer *Server);
|
||||||
|
void Execute();
|
||||||
|
};
|
||||||
|
typedef TMsgListenerThread *PMsgListenerThread;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// TCP SERVER
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
typedef TMsgSocket *PWorkerSocket;
|
||||||
|
|
||||||
|
class TCustomMsgServer
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
int FLastError;
|
||||||
|
char FLocalAddress[16];
|
||||||
|
// Socket listener
|
||||||
|
PMsgSocket SockListener;
|
||||||
|
// Server listener
|
||||||
|
PMsgListenerThread ServerThread;
|
||||||
|
// Critical section to lock Workers list activities
|
||||||
|
PSnapCriticalSection CSList;
|
||||||
|
// Event queue
|
||||||
|
PMsgEventQueue FEventQueue;
|
||||||
|
// Callback related
|
||||||
|
pfn_SrvCallBack OnEvent;
|
||||||
|
void *FUsrPtr;
|
||||||
|
// private methods
|
||||||
|
int StartListener();
|
||||||
|
void LockList();
|
||||||
|
void UnlockList();
|
||||||
|
int FirstFree();
|
||||||
|
protected:
|
||||||
|
bool Destroying;
|
||||||
|
// Critical section to lock Event activities
|
||||||
|
PSnapCriticalSection CSEvent;
|
||||||
|
// Workers list
|
||||||
|
void *Workers[MaxWorkers];
|
||||||
|
// Terminates all worker threads
|
||||||
|
virtual void TerminateAll();
|
||||||
|
// Kills all worker threads that are unresponsive
|
||||||
|
void KillAll();
|
||||||
|
// if (true the connection is accepted, otherwise the connection
|
||||||
|
// is closed gracefully
|
||||||
|
virtual bool CanAccept(socket_t Socket);
|
||||||
|
// Returns the class of the worker socket, override it for real servers
|
||||||
|
virtual PWorkerSocket CreateWorkerSocket(socket_t Sock);
|
||||||
|
// Handles the event
|
||||||
|
virtual void DoEvent(int Sender, longword Code, word RetCode, word Param1,
|
||||||
|
word Param2, word Param3, word Param4);
|
||||||
|
// Delete the worker from the list (It's invoked by Worker Thread)
|
||||||
|
void Delete(int Index);
|
||||||
|
// Incoming connection (It's invoked by ServerThread, the listener)
|
||||||
|
virtual void Incoming(socket_t Sock);
|
||||||
|
public:
|
||||||
|
friend class TMsgWorkerThread;
|
||||||
|
friend class TMsgListenerThread;
|
||||||
|
word LocalPort;
|
||||||
|
longword LocalBind;
|
||||||
|
longword LogMask;
|
||||||
|
longword EventMask;
|
||||||
|
int Status;
|
||||||
|
int ClientsCount;
|
||||||
|
int MaxClients;
|
||||||
|
TCustomMsgServer();
|
||||||
|
virtual ~TCustomMsgServer();
|
||||||
|
// Starts the server
|
||||||
|
int Start();
|
||||||
|
int StartTo(const char *Address, word Port);
|
||||||
|
// Stops the server
|
||||||
|
void Stop();
|
||||||
|
// Sets Event callback
|
||||||
|
int SetEventsCallBack(pfn_SrvCallBack PCallBack, void *UsrPtr);
|
||||||
|
// Pick an event from the circular queue
|
||||||
|
bool PickEvent(void *pEvent);
|
||||||
|
// Returns true if (the Event queue is empty
|
||||||
|
bool EventEmpty();
|
||||||
|
// Flushes Event queue
|
||||||
|
void EventsFlush();
|
||||||
|
};
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// TCP WORKER
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
// Default worker class, a simply tcp echo to test the connection and
|
||||||
|
// data I/O to use the server outside the project
|
||||||
|
class TEcoTcpWorker : public TMsgSocket
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
bool Execute()
|
||||||
|
{
|
||||||
|
byte Buffer[4096];
|
||||||
|
int Size;
|
||||||
|
|
||||||
|
if (CanRead(WorkInterval)) // Small time to avoid time wait during the close
|
||||||
|
{
|
||||||
|
Receive(&Buffer,sizeof(Buffer),Size);
|
||||||
|
if ((LastTcpError==0) && (Size>0))
|
||||||
|
{
|
||||||
|
SendPacket(&Buffer,Size);
|
||||||
|
return LastTcpError==0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return true;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#endif // snap_tcpsrvr_h
|
||||||
162
utils/snap7_src/src/sys/snap_threads.cpp
Normal file
162
utils/snap7_src/src/sys/snap_threads.cpp
Normal file
@ -0,0 +1,162 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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 "snap_threads.h"
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
DWORD WINAPI ThreadProc(LPVOID param)
|
||||||
|
#else
|
||||||
|
|
||||||
|
void* ThreadProc(void* param)
|
||||||
|
#endif
|
||||||
|
{
|
||||||
|
PSnapThread Thread;
|
||||||
|
// Unix but not Solaris
|
||||||
|
#if (defined(POSIX) || defined(OS_OSX)) && (!defined(OS_SOLARIS_NATIVE_THREADS))
|
||||||
|
int last_type, last_state;
|
||||||
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &last_type);
|
||||||
|
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &last_state);
|
||||||
|
#endif
|
||||||
|
Thread = PSnapThread(param);
|
||||||
|
|
||||||
|
if (!Thread->Terminated)
|
||||||
|
try
|
||||||
|
{
|
||||||
|
Thread->Execute();
|
||||||
|
} catch (...)
|
||||||
|
{
|
||||||
|
};
|
||||||
|
Thread->Closed = true;
|
||||||
|
if (Thread->FreeOnTerminate)
|
||||||
|
{
|
||||||
|
delete Thread;
|
||||||
|
};
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
ExitThread(0);
|
||||||
|
#endif
|
||||||
|
#if defined(POSIX) && (!defined(OS_SOLARIS_NATIVE_THREADS))
|
||||||
|
pthread_exit((void*)0);
|
||||||
|
#endif
|
||||||
|
#if defined(OS_OSX)
|
||||||
|
pthread_exit((void*)0);
|
||||||
|
#endif
|
||||||
|
#ifdef OS_SOLARIS_NATIVE_THREADS
|
||||||
|
thr_exit((void*)0);
|
||||||
|
#endif
|
||||||
|
return 0; // never reach, only to avoid compiler warning
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TSnapThread::TSnapThread()
|
||||||
|
{
|
||||||
|
Started = false;
|
||||||
|
Closed=false;
|
||||||
|
Terminated = false;
|
||||||
|
FreeOnTerminate = false;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
TSnapThread::~TSnapThread()
|
||||||
|
{
|
||||||
|
if (Started && !Closed)
|
||||||
|
{
|
||||||
|
Terminate();
|
||||||
|
Join();
|
||||||
|
};
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
if (Started)
|
||||||
|
CloseHandle(th);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TSnapThread::ThreadCreate()
|
||||||
|
{
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
th = CreateThread(0, 0, ThreadProc, this, 0, 0);
|
||||||
|
#endif
|
||||||
|
#if defined(POSIX) && (!defined(OS_SOLARIS_NATIVE_THREADS))
|
||||||
|
pthread_attr_t a;
|
||||||
|
pthread_attr_init(&a);
|
||||||
|
pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
|
||||||
|
pthread_create(&th, &a, &ThreadProc, this);
|
||||||
|
#endif
|
||||||
|
#if defined(OS_OSX)
|
||||||
|
pthread_create(&th, 0, &ThreadProc, this);
|
||||||
|
#endif
|
||||||
|
#ifdef OS_SOLARIS_NATIVE_THREADS
|
||||||
|
thr_create(0, // default stack base
|
||||||
|
0, // default stack size
|
||||||
|
&ThreadProc, // Thread routine
|
||||||
|
this, // argument
|
||||||
|
0,
|
||||||
|
&th);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TSnapThread::Start()
|
||||||
|
{
|
||||||
|
if (!Started)
|
||||||
|
{
|
||||||
|
ThreadCreate();
|
||||||
|
Started = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TSnapThread::Terminate()
|
||||||
|
{
|
||||||
|
Terminated = true;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TSnapThread::Kill()
|
||||||
|
{
|
||||||
|
if (Started && !Closed)
|
||||||
|
{
|
||||||
|
ThreadKill();
|
||||||
|
Closed = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
void TSnapThread::Join()
|
||||||
|
{
|
||||||
|
if (Started && !Closed)
|
||||||
|
{
|
||||||
|
ThreadJoin();
|
||||||
|
Closed = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
longword TSnapThread::WaitFor(uint64_t Timeout)
|
||||||
|
{
|
||||||
|
if (Started)
|
||||||
|
{
|
||||||
|
if (!Closed)
|
||||||
|
return ThreadWait(Timeout);
|
||||||
|
else
|
||||||
|
return WAIT_OBJECT_0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
return WAIT_OBJECT_0;
|
||||||
|
}
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
45
utils/snap7_src/src/sys/snap_threads.h
Normal file
45
utils/snap7_src/src/sys/snap_threads.h
Normal file
@ -0,0 +1,45 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef snap_threads_h
|
||||||
|
#define snap_threads_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#include "snap_platform.h"
|
||||||
|
|
||||||
|
#ifdef OS_WINDOWS
|
||||||
|
# include "win_threads.h"
|
||||||
|
#endif
|
||||||
|
#if defined(POSIX) && (!defined(OS_SOLARIS_NATIVE_THREADS))
|
||||||
|
# include "unix_threads.h"
|
||||||
|
#endif
|
||||||
|
#ifdef OS_SOLARIS_NATIVE_THREADS
|
||||||
|
# include "sol_threads.h"
|
||||||
|
#endif
|
||||||
|
#if defined(OS_OSX)
|
||||||
|
# include "unix_threads.h"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#endif // snap_threads_h
|
||||||
208
utils/snap7_src/src/sys/sol_threads.h
Normal file
208
utils/snap7_src/src/sys/sol_threads.h
Normal file
@ -0,0 +1,208 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|==============================================================================|
|
||||||
|
| |
|
||||||
|
| Solaris 11 Threads support |
|
||||||
|
| |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef sol_threads_h
|
||||||
|
#define sol_threads_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#include "snap_platform.h"
|
||||||
|
#include "snap_sysutils.h"
|
||||||
|
#include <thread.h>
|
||||||
|
#include <synch.h>
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class TSnapCriticalSection {
|
||||||
|
private:
|
||||||
|
mutex_t mx;
|
||||||
|
int result;
|
||||||
|
public:
|
||||||
|
|
||||||
|
TSnapCriticalSection() {
|
||||||
|
mutex_init(&mx, USYNC_THREAD, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
~TSnapCriticalSection() {
|
||||||
|
mutex_destroy(&mx);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Enter() {
|
||||||
|
mutex_lock(&mx);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Leave() {
|
||||||
|
mutex_unlock(&mx);
|
||||||
|
};
|
||||||
|
|
||||||
|
bool TryEnter() {
|
||||||
|
return mutex_trylock(&mx) == 0;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
typedef TSnapCriticalSection *PSnapCriticalSection;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
const longword WAIT_OBJECT_0 = 0x00000000L;
|
||||||
|
const longword WAIT_ABANDONED = 0x00000080L;
|
||||||
|
const longword WAIT_TIMEOUT = 0x00000102L;
|
||||||
|
const longword WAIT_FAILED = 0xFFFFFFFFL;
|
||||||
|
|
||||||
|
class TSnapEvent {
|
||||||
|
private:
|
||||||
|
cond_t CVariable;
|
||||||
|
mutex_t Mutex;
|
||||||
|
bool AutoReset;
|
||||||
|
bool State;
|
||||||
|
public:
|
||||||
|
|
||||||
|
TSnapEvent(bool ManualReset)
|
||||||
|
{
|
||||||
|
AutoReset = !ManualReset;
|
||||||
|
cond_init(&CVariable, USYNC_THREAD, 0) == 0;
|
||||||
|
mutex_init(&Mutex, USYNC_THREAD, 0);
|
||||||
|
State = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
~TSnapEvent()
|
||||||
|
{
|
||||||
|
cond_destroy(&CVariable);
|
||||||
|
mutex_destroy(&Mutex);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Set()
|
||||||
|
{
|
||||||
|
mutex_lock(&Mutex);
|
||||||
|
State = true;
|
||||||
|
if (AutoReset)
|
||||||
|
cond_signal(&CVariable);
|
||||||
|
else
|
||||||
|
cond_broadcast(&CVariable);
|
||||||
|
mutex_unlock(&Mutex);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Reset()
|
||||||
|
{
|
||||||
|
mutex_lock(&Mutex);
|
||||||
|
State = false;
|
||||||
|
mutex_unlock(&Mutex);
|
||||||
|
}
|
||||||
|
|
||||||
|
longword WaitForever()
|
||||||
|
{
|
||||||
|
mutex_lock(&Mutex);
|
||||||
|
while (!State) // <-- to avoid spurious wakeups
|
||||||
|
cond_wait(&CVariable, &Mutex);
|
||||||
|
if (AutoReset)
|
||||||
|
State = false;
|
||||||
|
mutex_unlock(&Mutex);
|
||||||
|
return WAIT_OBJECT_0;
|
||||||
|
};
|
||||||
|
|
||||||
|
longword WaitFor(int64_t Timeout)
|
||||||
|
{
|
||||||
|
longword Result = WAIT_OBJECT_0;
|
||||||
|
if (Timeout == 0)
|
||||||
|
Timeout = 1; // 0 is not allowed
|
||||||
|
|
||||||
|
if (Timeout > 0) {
|
||||||
|
mutex_lock(&Mutex);
|
||||||
|
if (!State) {
|
||||||
|
timespec ts;
|
||||||
|
timeval tv;
|
||||||
|
gettimeofday(&tv, NULL);
|
||||||
|
uint64_t nsecs = ((uint64_t) tv.tv_sec) * 1000000000 +
|
||||||
|
Timeout * 1000000 +
|
||||||
|
((uint64_t) tv.tv_usec) * 1000;
|
||||||
|
ts.tv_sec = nsecs / 1000000000;
|
||||||
|
ts.tv_nsec = (nsecs - ((uint64_t) ts.tv_sec) * 1000000000);
|
||||||
|
do
|
||||||
|
{
|
||||||
|
Result = cond_timedwait(&CVariable, &Mutex, &ts);
|
||||||
|
if (Result == ETIMEDOUT)
|
||||||
|
Result = WAIT_TIMEOUT;
|
||||||
|
}
|
||||||
|
while (Result == 0 && !State);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
if (AutoReset) // take the ownership
|
||||||
|
State = false;
|
||||||
|
mutex_unlock(&Mutex);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
else // Timeout<0
|
||||||
|
return WaitForever();
|
||||||
|
};
|
||||||
|
};
|
||||||
|
typedef TSnapEvent *PSnapEvent;
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class TSnapThread {
|
||||||
|
private:
|
||||||
|
thread_t th;
|
||||||
|
bool FCreateSuspended;
|
||||||
|
void ThreadCreate();
|
||||||
|
|
||||||
|
void ThreadJoin()
|
||||||
|
{
|
||||||
|
thr_join(th, 0, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
void ThreadKill()
|
||||||
|
{
|
||||||
|
thr_kill(th, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
longword ThreadWait(uint64_t Timeout)
|
||||||
|
{
|
||||||
|
longword Elapsed = SysGetTick();
|
||||||
|
while (!Closed && !(DeltaTime(Elapsed) > Timeout))
|
||||||
|
SysSleep(100);
|
||||||
|
if (Closed)
|
||||||
|
return WAIT_OBJECT_0;
|
||||||
|
else
|
||||||
|
return WAIT_TIMEOUT;
|
||||||
|
};
|
||||||
|
protected:
|
||||||
|
bool Started;
|
||||||
|
public:
|
||||||
|
bool Terminated;
|
||||||
|
bool Closed;
|
||||||
|
bool FreeOnTerminate;
|
||||||
|
TSnapThread();
|
||||||
|
virtual ~TSnapThread();
|
||||||
|
|
||||||
|
virtual void Execute() {
|
||||||
|
};
|
||||||
|
void Start();
|
||||||
|
void Terminate();
|
||||||
|
void Kill();
|
||||||
|
void Join();
|
||||||
|
longword WaitFor(uint64_t Timeout);
|
||||||
|
};
|
||||||
|
typedef TSnapThread *PSnapThread;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#endif // sol_threads_h
|
||||||
228
utils/snap7_src/src/sys/unix_threads.h
Normal file
228
utils/snap7_src/src/sys/unix_threads.h
Normal file
@ -0,0 +1,228 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|==============================================================================|
|
||||||
|
| |
|
||||||
|
| Posix Threads support (Linux, FreeBSD) |
|
||||||
|
| |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef unix_threads_h
|
||||||
|
#define unix_threads_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#include "snap_platform.h"
|
||||||
|
#include "snap_sysutils.h"
|
||||||
|
#include <semaphore.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class TSnapCriticalSection
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
pthread_mutex_t mx;
|
||||||
|
// int result;
|
||||||
|
public:
|
||||||
|
|
||||||
|
TSnapCriticalSection()
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
|
||||||
|
This would be the best code, but very often it causes a segmentation fault in many
|
||||||
|
unix systems (the problem seems to be pthread_mutexattr_destroy()).
|
||||||
|
So, to avoid problems in future kernel/libc release, we use the "safe" default.
|
||||||
|
|
||||||
|
pthread_mutexattr_t mxAttr;
|
||||||
|
pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE);
|
||||||
|
pthread_mutex_init(&mx, &mxAttr);
|
||||||
|
pthread_mutexattr_destroy(&mxAttr);
|
||||||
|
|
||||||
|
*/
|
||||||
|
pthread_mutex_init(&mx, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
~TSnapCriticalSection()
|
||||||
|
{
|
||||||
|
pthread_mutex_destroy(&mx);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Enter()
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&mx);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Leave()
|
||||||
|
{
|
||||||
|
pthread_mutex_unlock(&mx);
|
||||||
|
};
|
||||||
|
|
||||||
|
bool TryEnter()
|
||||||
|
{
|
||||||
|
return pthread_mutex_trylock(&mx) == 0;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
typedef TSnapCriticalSection *PSnapCriticalSection;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
const longword WAIT_OBJECT_0 = 0x00000000L;
|
||||||
|
const longword WAIT_ABANDONED = 0x00000080L;
|
||||||
|
const longword WAIT_TIMEOUT = 0x00000102L;
|
||||||
|
const longword WAIT_FAILED = 0xFFFFFFFFL;
|
||||||
|
|
||||||
|
class TSnapEvent
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
pthread_cond_t CVariable;
|
||||||
|
pthread_mutex_t Mutex;
|
||||||
|
bool AutoReset;
|
||||||
|
bool State;
|
||||||
|
public:
|
||||||
|
|
||||||
|
TSnapEvent(bool ManualReset)
|
||||||
|
{
|
||||||
|
AutoReset = !ManualReset;
|
||||||
|
if (pthread_cond_init(&CVariable, 0) == 0)
|
||||||
|
pthread_mutex_init(&Mutex, 0);
|
||||||
|
State = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
~TSnapEvent()
|
||||||
|
{
|
||||||
|
pthread_cond_destroy(&CVariable);
|
||||||
|
pthread_mutex_destroy(&Mutex);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Set()
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&Mutex);
|
||||||
|
State = true;
|
||||||
|
if (AutoReset)
|
||||||
|
pthread_cond_signal(&CVariable);
|
||||||
|
else
|
||||||
|
pthread_cond_broadcast(&CVariable);
|
||||||
|
pthread_mutex_unlock(&Mutex);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Reset()
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&Mutex);
|
||||||
|
State = false;
|
||||||
|
pthread_mutex_unlock(&Mutex);
|
||||||
|
}
|
||||||
|
|
||||||
|
longword WaitForever()
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&Mutex);
|
||||||
|
while (!State) // <-- to avoid spurious wakeups
|
||||||
|
pthread_cond_wait(&CVariable, &Mutex);
|
||||||
|
if (AutoReset)
|
||||||
|
State = false;
|
||||||
|
pthread_mutex_unlock(&Mutex);
|
||||||
|
return WAIT_OBJECT_0;
|
||||||
|
};
|
||||||
|
|
||||||
|
longword WaitFor(int64_t Timeout)
|
||||||
|
{
|
||||||
|
longword Result = WAIT_OBJECT_0;
|
||||||
|
if (Timeout == 0)
|
||||||
|
Timeout = 1; // 0 is not allowed
|
||||||
|
|
||||||
|
if (Timeout > 0)
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&Mutex);
|
||||||
|
if (!State)
|
||||||
|
{
|
||||||
|
timespec ts;
|
||||||
|
timeval tv;
|
||||||
|
gettimeofday(&tv, NULL);
|
||||||
|
uint64_t nsecs = ((uint64_t) tv.tv_sec) * 1000000000 +
|
||||||
|
Timeout * 1000000 +
|
||||||
|
((uint64_t) tv.tv_usec) * 1000;
|
||||||
|
ts.tv_sec = nsecs / 1000000000;
|
||||||
|
ts.tv_nsec = (nsecs - ((uint64_t) ts.tv_sec) * 1000000000);
|
||||||
|
do {
|
||||||
|
Result = pthread_cond_timedwait(&CVariable, &Mutex, &ts);
|
||||||
|
if (Result == ETIMEDOUT)
|
||||||
|
Result = WAIT_TIMEOUT;
|
||||||
|
} while (Result == 0 && !State);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
if (AutoReset) // take the ownership
|
||||||
|
State = false;
|
||||||
|
pthread_mutex_unlock(&Mutex);
|
||||||
|
return Result;
|
||||||
|
}
|
||||||
|
else // Timeout<0
|
||||||
|
return WaitForever();
|
||||||
|
};
|
||||||
|
};
|
||||||
|
typedef TSnapEvent *PSnapEvent;
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
class TSnapThread
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
pthread_t th;
|
||||||
|
bool FCreateSuspended;
|
||||||
|
void ThreadCreate();
|
||||||
|
|
||||||
|
void ThreadJoin()
|
||||||
|
{
|
||||||
|
pthread_join(th, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
void ThreadKill()
|
||||||
|
{
|
||||||
|
pthread_cancel(th);
|
||||||
|
};
|
||||||
|
|
||||||
|
longword ThreadWait(uint64_t Timeout)
|
||||||
|
{
|
||||||
|
longword Elapsed = SysGetTick();
|
||||||
|
while (!Closed && !(DeltaTime(Elapsed) > Timeout))
|
||||||
|
SysSleep(100);
|
||||||
|
if (Closed)
|
||||||
|
return WAIT_OBJECT_0;
|
||||||
|
else
|
||||||
|
return WAIT_TIMEOUT;
|
||||||
|
};
|
||||||
|
protected:
|
||||||
|
bool Started;
|
||||||
|
public:
|
||||||
|
bool Terminated;
|
||||||
|
bool Closed;
|
||||||
|
bool FreeOnTerminate;
|
||||||
|
TSnapThread();
|
||||||
|
virtual ~TSnapThread();
|
||||||
|
|
||||||
|
virtual void Execute()
|
||||||
|
{
|
||||||
|
};
|
||||||
|
void Start();
|
||||||
|
void Terminate();
|
||||||
|
void Kill();
|
||||||
|
void Join();
|
||||||
|
longword WaitFor(uint64_t Timeout);
|
||||||
|
};
|
||||||
|
typedef TSnapThread *PSnapThread;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#endif // unix_threads_h
|
||||||
159
utils/snap7_src/src/sys/win_threads.h
Normal file
159
utils/snap7_src/src/sys/win_threads.h
Normal file
@ -0,0 +1,159 @@
|
|||||||
|
/*=============================================================================|
|
||||||
|
| 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/ |
|
||||||
|
|==============================================================================|
|
||||||
|
| |
|
||||||
|
| Windows Threads support (Windows, ReactOS) |
|
||||||
|
| |
|
||||||
|
|=============================================================================*/
|
||||||
|
#ifndef win_threads_h
|
||||||
|
#define win_threads_h
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#include "snap_platform.h"
|
||||||
|
#include "snap_sysutils.h"
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class TSnapCriticalSection
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
CRITICAL_SECTION cs;
|
||||||
|
public:
|
||||||
|
|
||||||
|
TSnapCriticalSection()
|
||||||
|
{
|
||||||
|
InitializeCriticalSection(&cs);
|
||||||
|
};
|
||||||
|
|
||||||
|
~TSnapCriticalSection()
|
||||||
|
{
|
||||||
|
DeleteCriticalSection(&cs);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Enter()
|
||||||
|
{
|
||||||
|
EnterCriticalSection(&cs);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Leave()
|
||||||
|
{
|
||||||
|
LeaveCriticalSection(&cs);
|
||||||
|
};
|
||||||
|
|
||||||
|
bool TryEnter()
|
||||||
|
{
|
||||||
|
return (TryEnterCriticalSection(&cs) != 0);
|
||||||
|
};
|
||||||
|
};
|
||||||
|
typedef TSnapCriticalSection *PSnapCriticalSection;
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class TSnapEvent
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
HANDLE Event;
|
||||||
|
public:
|
||||||
|
|
||||||
|
TSnapEvent(bool ManualReset)
|
||||||
|
{
|
||||||
|
Event = CreateEvent(0, ManualReset, false, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
~TSnapEvent()
|
||||||
|
{
|
||||||
|
if (Event != 0)
|
||||||
|
CloseHandle(Event);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Set()
|
||||||
|
{
|
||||||
|
if (Event != 0)
|
||||||
|
SetEvent(Event);
|
||||||
|
};
|
||||||
|
|
||||||
|
void Reset()
|
||||||
|
{
|
||||||
|
if (Event != 0)
|
||||||
|
ResetEvent(Event);
|
||||||
|
};
|
||||||
|
|
||||||
|
longword WaitForever()
|
||||||
|
{
|
||||||
|
if (Event != 0)
|
||||||
|
return WaitForSingleObject(Event, INFINITE);
|
||||||
|
else
|
||||||
|
return WAIT_FAILED;
|
||||||
|
};
|
||||||
|
|
||||||
|
longword WaitFor(int64_t Timeout) {
|
||||||
|
if (Event != 0)
|
||||||
|
return WaitForSingleObject(Event, DWORD(Timeout));
|
||||||
|
else
|
||||||
|
return WAIT_FAILED;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
typedef TSnapEvent *PSnapEvent;
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class TSnapThread {
|
||||||
|
private:
|
||||||
|
HANDLE th;
|
||||||
|
bool FCreateSuspended;
|
||||||
|
void ThreadCreate();
|
||||||
|
|
||||||
|
void ThreadJoin()
|
||||||
|
{
|
||||||
|
WaitForSingleObject(th, INFINITE);
|
||||||
|
};
|
||||||
|
|
||||||
|
void ThreadKill()
|
||||||
|
{
|
||||||
|
TerminateThread(th, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
longword ThreadWait(uint64_t Timeout)
|
||||||
|
{
|
||||||
|
return WaitForSingleObject(th, DWORD(Timeout));
|
||||||
|
};
|
||||||
|
protected:
|
||||||
|
bool Started;
|
||||||
|
public:
|
||||||
|
bool Terminated;
|
||||||
|
bool Closed;
|
||||||
|
bool FreeOnTerminate;
|
||||||
|
TSnapThread();
|
||||||
|
virtual ~TSnapThread();
|
||||||
|
|
||||||
|
virtual void Execute()
|
||||||
|
{
|
||||||
|
};
|
||||||
|
void Start();
|
||||||
|
void Terminate();
|
||||||
|
void Kill();
|
||||||
|
void Join();
|
||||||
|
longword WaitFor(uint64_t Timeout);
|
||||||
|
};
|
||||||
|
typedef TSnapThread *PSnapThread;
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
#endif // win_threads_h
|
||||||
Loading…
x
Reference in New Issue
Block a user