4802452a7c
- CLiteProtocol: - Set input string on methods to const char * - Simplify checking for verification - Ensure Length parameter can be left out on all methods - Add quick functions for structured commands: To, From, Command - CLogCore: - Use only "\n", not "\r\n" - SignalCore: - Use std::endl instead of "\r\n"
1503 lines
45 KiB
C++
1503 lines
45 KiB
C++
/*
|
|
* SelectableCore.cpp
|
|
*
|
|
* Created on: 20 May 2016
|
|
* Author: wentzelc
|
|
*/
|
|
|
|
// redA Libraries
|
|
#include "SelectableCore.h"
|
|
#include "TimingCore.h"
|
|
#include "LogCore.h"
|
|
|
|
// Standard C/C++ Libraries
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
|
#include <termios.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
|
|
#include <netinet/in.h>
|
|
#include <netinet/tcp.h>
|
|
#include <arpa/inet.h>
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
CSelectableCore::CSelectableCore( const char * Name, CSelect * Selector, CLogCore * pLog, EDebugLevel pDebugLevel, int pOutputDisplay ) :
|
|
CFunctionCore( Name, pLog, pDebugLevel, pOutputDisplay )
|
|
{
|
|
// Handles
|
|
FirstHandle = NULL;
|
|
|
|
// Select
|
|
Select = Selector;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
CSelectableCore::~CSelectableCore()
|
|
{
|
|
THandle * NextHandle = NULL;
|
|
|
|
// Destroy File Handles
|
|
while (FirstHandle)
|
|
{
|
|
// Close handle if open
|
|
if ((FirstHandle->State == csOpen) || (FirstHandle->State == csWaitingtoOpen)) {
|
|
Close( FirstHandle, true );
|
|
}
|
|
|
|
NextHandle = FirstHandle->Next;
|
|
DestroyHandle( FirstHandle );
|
|
FirstHandle = NextHandle;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
THandle * CSelectableCore::CreateHandle( const char * HandleName, bool CreateChannel )
|
|
{
|
|
THandle ** Handle = NULL;
|
|
|
|
// Find Handle by Name or get end of list
|
|
Handle = &FirstHandle;
|
|
while ( *Handle && strcmp( HandleName, (*Handle)->Name ))
|
|
Handle = &((*Handle)->Next);
|
|
|
|
// Create if necessary
|
|
if (!*Handle)
|
|
{
|
|
// Create File handle at end of list
|
|
*Handle = (THandle*)calloc( 1, sizeof(THandle) );
|
|
|
|
// Set name
|
|
if (HandleName) {
|
|
(*Handle)->Name = (char*)malloc( strlen(HandleName)+1 );
|
|
strcpy( (*Handle)->Name, HandleName );
|
|
}
|
|
|
|
// Set File Descriptor
|
|
(*Handle)->FD = -1;
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Created", Name, HandleName );
|
|
}
|
|
|
|
// Create Matching Channel
|
|
if (CreateChannel) {
|
|
(*Handle)->Channel = AddChannel( HandleName );
|
|
}
|
|
|
|
return *Handle;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::RemoveHandle( THandle * Handle )
|
|
{
|
|
THandle ** HandlePtr = NULL;
|
|
|
|
// Validate
|
|
if (!Handle || (Handle->State == csOpen) || (Handle->State == csWaitingtoOpen)) {
|
|
return false;
|
|
}
|
|
|
|
// Find in List
|
|
HandlePtr = &FirstHandle;
|
|
while (*HandlePtr && (*HandlePtr != Handle)) {
|
|
HandlePtr = &((*HandlePtr)->Next);
|
|
}
|
|
// Remove from list if found
|
|
if (*HandlePtr) {
|
|
*HandlePtr = (*HandlePtr)->Next;
|
|
}
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Removed", Name, Handle->Name );
|
|
|
|
// Destroy Child handle
|
|
DestroyHandle( Handle );
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::DestroyHandle( THandle * Handle )
|
|
{
|
|
// Validate Handle
|
|
if (!Handle)
|
|
return false;
|
|
|
|
// Clear parameters
|
|
if (Handle->Name)
|
|
free( Handle->Name );
|
|
if (Handle->Path)
|
|
free( Handle->Path );
|
|
if (Handle->Address)
|
|
free( Handle->Address );
|
|
|
|
// Destroy Buffers
|
|
if (Handle->InBuffer)
|
|
delete Handle->InBuffer;
|
|
if (Handle->OutBuffer)
|
|
delete Handle->OutBuffer;
|
|
|
|
// Clear Input Markers
|
|
if (Handle->InMarker)
|
|
free( Handle->InMarker );
|
|
|
|
// Destroy Pointer
|
|
free( Handle );
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::SetPortHandle( THandle * Handle, const char * FileName )
|
|
{
|
|
// Validate
|
|
if (!Handle || (Handle->Type != ctNone) || !FileName) {
|
|
return false;
|
|
}
|
|
|
|
// Set Type
|
|
Handle->Type = ctPort;
|
|
|
|
// Clear File Name
|
|
if (Handle->Path) {
|
|
free( Handle->Path );
|
|
}
|
|
|
|
// Set name
|
|
Handle->Path = (char*)malloc( strlen(FileName)+1 );
|
|
strcpy( Handle->Path, FileName );
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Set as Port [%s]", Name, Handle->Name, FileName );
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::SetForkPipeHandle( THandle * Handle, const char * ExecPath )
|
|
{
|
|
// Validate
|
|
if (!Handle || ((Handle->Type != ctNone) && (Handle->Type != ctForkPipe)) || !ExecPath) {
|
|
return false;
|
|
}
|
|
|
|
// Set Type
|
|
Handle->Type = ctForkPipe;
|
|
|
|
// Clear File Name
|
|
if (Handle->Path) {
|
|
free( Handle->Path );
|
|
}
|
|
|
|
// Set name
|
|
Handle->Path = (char*)malloc( strlen(ExecPath)+1 );
|
|
strcpy( Handle->Path, ExecPath );
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Set as ForkPipe [%s]", Name, Handle->Name, ExecPath );
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::SetSocketHandle( THandle * Handle, EConnectType Type, const char * Address, const int PortNo, bool KeepAlive )
|
|
{
|
|
// Validate
|
|
if (!Handle || (Handle->Type != ctNone) || !Address || (Type == ctNone) || (Type == ctPort)) {
|
|
return false;
|
|
}
|
|
|
|
// Set Type
|
|
Handle->Type = Type;
|
|
Handle->KeepAlive = KeepAlive;
|
|
|
|
// Clear Address
|
|
if (Handle->Address) {
|
|
free( Handle->Address );
|
|
}
|
|
|
|
// Set Address & Port
|
|
Handle->Address = (char*)malloc( strlen(Address)+1 );
|
|
strcpy( Handle->Address, Address );
|
|
Handle->PortNo = PortNo;
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Set as %s [%s:%d]", Name, Handle->Name, ConnectTypeName[Type], Address, PortNo );
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::ClearHandle( THandle * Handle )
|
|
{
|
|
// Validate
|
|
if (!Handle) {
|
|
return false;
|
|
}
|
|
|
|
// Reset Type related parameters
|
|
if (Handle->Path) {
|
|
free( Handle->Path );
|
|
Handle->Path = NULL;
|
|
}
|
|
if (Handle->Address) {
|
|
free( Handle->Address );
|
|
Handle->Address = NULL;
|
|
}
|
|
Handle->PortNo = 0;
|
|
|
|
// Reset Parameters
|
|
Handle->Type = ctNone;
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Set as None", Name, Handle->Name );
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::SetCallback( THandle * Handle, EConnectState pState, FHandleCallback pCallback )
|
|
{
|
|
// Validate
|
|
if (!Handle) {
|
|
return false;
|
|
}
|
|
|
|
// Set callback
|
|
Handle->StateCallback[ (int)pState ] = pCallback;
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::SetAutoManage( THandle * Handle, bool AutoManage, int ReopenTime )
|
|
{
|
|
// Validate
|
|
if (!Handle) {
|
|
return false;
|
|
}
|
|
|
|
// Set params
|
|
Handle->Auto = AutoManage;
|
|
Handle->ReopenTimeout = ReopenTime;
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::SetBuffers( THandle * Handle, int InBufSize, int OutBufSize, int InTimeout, const char * InMarker, int InMarkerLen )
|
|
{
|
|
// Validate
|
|
if (!Handle) {
|
|
return false;
|
|
}
|
|
|
|
// Input Buffer
|
|
if (Handle->InBuffer) {
|
|
delete Handle->InBuffer;
|
|
Handle->InBuffer = NULL;
|
|
}
|
|
if (InBufSize) {
|
|
Handle->InBuffer = (CRollingBuffer*) new CRollingBuffer( InBufSize );
|
|
}
|
|
|
|
// Output Buffer
|
|
if (Handle->OutBuffer) {
|
|
delete Handle->OutBuffer;
|
|
Handle->OutBuffer = NULL;
|
|
}
|
|
if (OutBufSize) {
|
|
Handle->OutBuffer = (CRollingBuffer*) new CRollingBuffer( OutBufSize );
|
|
}
|
|
|
|
// Set Input Timeout
|
|
Handle->InTimeout = InTimeout;
|
|
|
|
// Set Input Markers
|
|
if (InMarkerLen && InMarker) {
|
|
Handle->InMarkerLen = InMarkerLen;
|
|
Handle->InMarker = (char *)malloc( InMarkerLen+1 );
|
|
memcpy( Handle->InMarker, InMarker, InMarkerLen );
|
|
Handle->InMarker[InMarkerLen] = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::OpenPort( THandle * Handle )
|
|
{
|
|
// Validate
|
|
if (!Handle || (Handle->Type == ctNone)) {
|
|
return -1;
|
|
} else if (Handle->State == csOpen) {
|
|
return Handle->FD;
|
|
}
|
|
|
|
// Check if port exits
|
|
if (access( Handle->Path, F_OK ) != 0)
|
|
{
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Port not found [%s]", Name, Handle->Name, Handle->Path );
|
|
return -1;
|
|
}
|
|
|
|
// Open Port
|
|
Handle->FD = open( Handle->Path, O_RDWR );
|
|
if (Handle->FD == -1)
|
|
{
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Could not open Port [%s]", Name, Handle->Name, Handle->Path );
|
|
return -1;
|
|
}
|
|
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Port opened [%s]", Name, Handle->Name, Handle->Path );
|
|
|
|
// Add to Select Lists
|
|
if (Select) {
|
|
Select->Add( Handle->FD, true, false, this );
|
|
}
|
|
|
|
// Set state
|
|
ChangeState( Handle, csOpen );
|
|
return Handle->FD;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::OpenForkPipe( THandle * Handle )
|
|
{
|
|
int pipefd[2];
|
|
char * Args[50];
|
|
int Count = 0;
|
|
|
|
// Validate
|
|
if (!Handle || (Handle->Type == ctNone)) {
|
|
return -1;
|
|
} else if (Handle->State == csOpen) {
|
|
return Handle->FD;
|
|
}
|
|
|
|
// Validate Exec path
|
|
if (!Handle->Path || !*(Handle->Path))
|
|
{
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Invalid path for Exec", Name, Handle->Name );
|
|
return -1;
|
|
}
|
|
|
|
// Create Pipe
|
|
pipe( pipefd );
|
|
if ((pipefd[0] == -1) || (pipefd[1] == -1))
|
|
{
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Could not open Pipe", Name, Handle->Name );
|
|
return -1;
|
|
}
|
|
|
|
// Fork process
|
|
Handle->ChildPID = fork();
|
|
if (Handle->ChildPID < 0)
|
|
{
|
|
// Fork has failed
|
|
// Close both ends of the pipe
|
|
close( pipefd[0] );
|
|
close( pipefd[1] );
|
|
Handle->FD = -1;
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Could not Fork process", Name, Handle->Name );
|
|
return -1;
|
|
}
|
|
else if (Handle->ChildPID > 0)
|
|
{
|
|
// Fork success - this is parent
|
|
// Close Read-end of pipe, but keep the Write-end
|
|
close( pipefd[0] );
|
|
Handle->FD = pipefd[1];
|
|
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Process forked successfully", Name, Handle->Name );
|
|
}
|
|
else
|
|
{
|
|
// Fork success - this is child
|
|
// Replace stdin with Read-end of pipe
|
|
close( 0 );
|
|
dup( pipefd[0] );
|
|
close( pipefd[0] );
|
|
|
|
// Close Write-end of pipe
|
|
close( pipefd[1] );
|
|
|
|
// Replace Processing image
|
|
BuildArgs( Handle->Path, Count, Args );
|
|
// printf( "Execute params [%d]:\n", Count );
|
|
// int i = 0;
|
|
// while (Args[i]) {
|
|
// printf( "%d: %s\n", i, Args[i] );
|
|
// i++;
|
|
// }
|
|
execvp( Args[0], Args );
|
|
|
|
// Replace failed, exit immediately
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Exec on forked process failed", Name, Handle->Name );
|
|
exit(127);
|
|
}
|
|
|
|
// Add to Select Lists
|
|
if (Select) {
|
|
Select->Add( Handle->FD, false, true, this );
|
|
}
|
|
|
|
// Set state
|
|
ChangeState( Handle, csOpen );
|
|
return Handle->FD;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::OpenServerSocket( THandle * Handle )
|
|
{
|
|
socklen_t addr_len;
|
|
struct sockaddr_in address;
|
|
|
|
// Socket options
|
|
struct linger ServerLinger_opt;
|
|
ServerLinger_opt.l_onoff = 1;
|
|
ServerLinger_opt.l_linger = 5;
|
|
|
|
int Reuse_opt = 1;
|
|
int KeepAlive_opt = 1;
|
|
int TCPidle_opt = 60;
|
|
int TCPint_opt = 15;
|
|
int TCPcnt_opt = 3;
|
|
|
|
// Validate Handle
|
|
if (Handle->Type != ctServer) {
|
|
return false;
|
|
}
|
|
|
|
// Create address
|
|
address.sin_family = AF_INET;
|
|
address.sin_addr.s_addr = inet_addr(Handle->Address);
|
|
address.sin_port = htons(Handle->PortNo);
|
|
addr_len = sizeof(address);
|
|
|
|
// Create socket
|
|
if ((Handle->FD = socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Failed to create Server socket [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Set state
|
|
ChangeState( Handle, csFailed );
|
|
return -1;
|
|
};
|
|
|
|
// Configure connection
|
|
if ((setsockopt( Handle->FD, SOL_SOCKET, SO_LINGER, &ServerLinger_opt, sizeof(ServerLinger_opt)) == -1) ||
|
|
(setsockopt( Handle->FD, SOL_SOCKET, SO_REUSEADDR, &Reuse_opt, sizeof(Reuse_opt)) == -1))
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Could not set socket options [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Set state
|
|
ChangeState( Handle, csFailed );
|
|
return -1;
|
|
}
|
|
|
|
// Configure TCP keep alive settings
|
|
if (Handle->KeepAlive &&
|
|
((setsockopt( Handle->FD, SOL_SOCKET, SO_KEEPALIVE, &KeepAlive_opt, sizeof(KeepAlive_opt)) == -1) ||
|
|
(setsockopt( Handle->FD, SOL_TCP, TCP_KEEPIDLE, &TCPidle_opt, sizeof(TCPidle_opt)) == -1) ||
|
|
(setsockopt( Handle->FD, SOL_TCP, TCP_KEEPCNT, &TCPcnt_opt, sizeof(TCPcnt_opt)) == -1) ||
|
|
(setsockopt( Handle->FD, SOL_TCP, TCP_KEEPINTVL, &TCPint_opt, sizeof(TCPint_opt)) == -1) ))
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Could not set KeepAlive options [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Set state
|
|
ChangeState( Handle, csFailed );
|
|
return -1;
|
|
}
|
|
|
|
// Set non-blocking flag
|
|
int flags = fcntl( Handle->FD, F_GETFL, 0 );
|
|
fcntl( Handle->FD, F_SETFL, flags | O_NONBLOCK );
|
|
|
|
// Bind socket
|
|
if (bind( Handle->FD, (struct sockaddr *)&address, addr_len ) < 0)
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Failed to bind Server socket [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Set state
|
|
close( Handle->FD );
|
|
Handle->FD = -1;
|
|
ChangeState( Handle, csFailed );
|
|
return -1;
|
|
};
|
|
|
|
// Create que for 5 connections
|
|
if (listen( Handle->FD, 5 ) < 0)
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Failed to listen on Server socket [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Set state
|
|
close( Handle->FD );
|
|
Handle->FD = -1;
|
|
ChangeState( Handle, csFailed );
|
|
return -1;
|
|
};
|
|
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Server binded and listening [%s:%d]", Name, Handle->Name, Handle->Address, Handle->PortNo );
|
|
|
|
// Add to Select Lists
|
|
if (Select) {
|
|
Select->Add( Handle->FD, true, false, this );
|
|
}
|
|
|
|
// Set state
|
|
ChangeState( Handle, csOpen );
|
|
return Handle->FD;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::OpenRemoteClientSocket( THandle * Handle )
|
|
{
|
|
THandle ** RemoteClient;
|
|
int ClientFD;
|
|
char ClientAddress[100];
|
|
char ClientName[100];
|
|
|
|
socklen_t addr_len;
|
|
struct sockaddr_in address;
|
|
|
|
// Validate
|
|
if (!Handle) {
|
|
return -1;
|
|
}
|
|
|
|
// Check Handle type
|
|
if (Handle->Type == ctServer)
|
|
{
|
|
// Accept connection on current socket
|
|
addr_len = sizeof( address );
|
|
if ((ClientFD = accept( Handle->FD, (struct sockaddr *)&address, &addr_len)) == -1)
|
|
{
|
|
// Log Event
|
|
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Server failed to accept blocking connection (%s)", Name, Handle->Name, strerror(errno) );
|
|
}
|
|
else {
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Server failed to accept connection (%s)", Name, Handle->Name, strerror(errno) );
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Set non-blocking flag
|
|
int flags = fcntl( ClientFD, F_GETFL, 0 );
|
|
fcntl( ClientFD, F_SETFL, flags | O_NONBLOCK );
|
|
|
|
// Return client address
|
|
strcpy( ClientAddress, inet_ntoa(address.sin_addr) );
|
|
|
|
// Get end of client list
|
|
RemoteClient = &FirstHandle;
|
|
while (*RemoteClient) {
|
|
RemoteClient = &((*RemoteClient)->Next);
|
|
}
|
|
|
|
// Create Remote Client Handle
|
|
sprintf( ClientName, "%s-%d", Handle->Name, ClientFD );
|
|
*RemoteClient = CreateHandle( ClientName, false );
|
|
SetSocketHandle( *RemoteClient, ctRemoteClient, ClientAddress, 0, Handle->KeepAlive );
|
|
|
|
// Copy Parent Buffer setup
|
|
SetBuffers( *RemoteClient, ((Handle->InBuffer)? Handle->InBuffer->Size() : 0),
|
|
((Handle->OutBuffer)? Handle->OutBuffer->Size() : 0),
|
|
Handle->InTimeout, Handle->InMarker, Handle->InMarkerLen );
|
|
|
|
// Set Key parameters
|
|
(*RemoteClient)->FD = ClientFD;
|
|
(*RemoteClient)->Parent = Handle;
|
|
(*RemoteClient)->State = csWaitingtoOpen;
|
|
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Server accepted Remote Client connection [%s]", Name, Handle->Name, ClientAddress );
|
|
|
|
// Add to Select Lists
|
|
if (Select) {
|
|
Select->Add( (*RemoteClient)->FD, true, true, this );
|
|
}
|
|
|
|
return (*RemoteClient)->FD;
|
|
}
|
|
else if (Handle->Type == ctRemoteClient)
|
|
{
|
|
// Check state
|
|
if (Handle->State == csOpen)
|
|
{
|
|
// Already open
|
|
return Handle->FD;
|
|
}
|
|
else if (Handle->State == csWaitingtoOpen)
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Remote Client connection open [%s]", Name, Handle->Name, Handle->Address );
|
|
|
|
// Update state
|
|
ChangeState( Handle, csOpen );
|
|
return Handle->FD;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::OpenClientSocket( THandle * Handle )
|
|
{
|
|
socklen_t addr_len;
|
|
struct sockaddr_in address;
|
|
|
|
// Socket options
|
|
int KeepAlive_opt = 1;
|
|
int TCPidle_opt = 5;
|
|
int TCPcnt_opt = 3;
|
|
int TCPint_opt = 2;
|
|
|
|
// Check state
|
|
if (Handle->State == csOpen) {
|
|
// Already open
|
|
return Handle->FD;
|
|
}
|
|
|
|
if (Handle->State != csWaitingtoOpen)
|
|
{
|
|
// Create File descriptor
|
|
if ((Handle->FD = socket( AF_INET, SOCK_STREAM, 0 )) < 0)
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Failed to create Client socket [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Set Status
|
|
ChangeState( Handle, csFailed );
|
|
return -1;
|
|
};
|
|
|
|
// Set Non blocking open
|
|
int flags = fcntl( Handle->FD, F_GETFL, 0 );
|
|
fcntl( Handle->FD, F_SETFL, O_NONBLOCK|flags );
|
|
|
|
// Configure TCP keep alive settings
|
|
if (Handle->KeepAlive &&
|
|
((setsockopt( Handle->FD, SOL_SOCKET, SO_KEEPALIVE, &KeepAlive_opt, sizeof(KeepAlive_opt)) == -1) ||
|
|
(setsockopt( Handle->FD, SOL_TCP, TCP_KEEPIDLE, &TCPidle_opt, sizeof(TCPidle_opt)) == -1) ||
|
|
(setsockopt( Handle->FD, SOL_TCP, TCP_KEEPCNT, &TCPcnt_opt, sizeof(TCPcnt_opt)) == -1) ||
|
|
(setsockopt( Handle->FD, SOL_TCP, TCP_KEEPINTVL, &TCPint_opt, sizeof(TCPint_opt)) == -1) ))
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Could not set KeepAlive options [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Set State
|
|
close( Handle->FD );
|
|
Handle->FD = -1;
|
|
ChangeState( Handle, csFailed );
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Declare address
|
|
address.sin_family = AF_INET;
|
|
address.sin_addr.s_addr = inet_addr( Handle->Address );
|
|
address.sin_port = htons( Handle->PortNo );
|
|
addr_len = sizeof(address);
|
|
|
|
if (!connect( Handle->FD, (struct sockaddr *)&address, addr_len ))
|
|
{
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Client connected [%s:%d]", Name, Handle->Name, Handle->Address, Handle->PortNo );
|
|
|
|
// Add to Select Lists
|
|
if (Select) {
|
|
Select->Add( Handle->FD, true, true, this );
|
|
}
|
|
|
|
// Set status
|
|
ChangeState( Handle, csOpen );
|
|
return Handle->FD;
|
|
}
|
|
else if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINPROGRESS) || (errno == EALREADY))
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Client waiting to connect [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Add to Select Lists
|
|
if (Select) {
|
|
Select->Add( Handle->FD, true, true, this );
|
|
}
|
|
|
|
// Set status
|
|
ChangeState( Handle, csWaitingtoOpen );
|
|
return Handle->FD;
|
|
}
|
|
else
|
|
{
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Client could not connect [%s:%d] (%s)", Name, Handle->Name, Handle->Address, Handle->PortNo, strerror(errno) );
|
|
|
|
// Remove from Select List
|
|
if (Select) {
|
|
Select->Remove( Handle->FD, true, true );
|
|
}
|
|
|
|
// Close socket
|
|
close( Handle->FD );
|
|
ChangeState( Handle, csFailed );
|
|
|
|
// Start re-open timer
|
|
SetStartTime( &(Handle->ReopenStart) );
|
|
|
|
// Reset Handle
|
|
Handle->FD = -1;
|
|
return -1;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::Open( THandle * Handle )
|
|
{
|
|
int FD = -1;
|
|
|
|
// Validate
|
|
if (!Handle) {
|
|
return -1;
|
|
}
|
|
|
|
// Open correctly
|
|
switch (Handle->Type) {
|
|
case ctPort :
|
|
FD = OpenPort( Handle );
|
|
break;
|
|
case ctForkPipe :
|
|
FD = OpenForkPipe( Handle );
|
|
break;
|
|
case ctServer :
|
|
FD = OpenServerSocket( Handle );
|
|
break;
|
|
case ctClient :
|
|
FD = OpenClientSocket( Handle );
|
|
break;
|
|
case ctRemoteClient :
|
|
FD = OpenRemoteClientSocket( Handle );
|
|
break;
|
|
default:
|
|
FD = -1;
|
|
}
|
|
return FD;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Delete socket
|
|
bool CSelectableCore::Close( THandle * Handle, bool CloseChildren )
|
|
{
|
|
bool Fail;
|
|
THandle * ChildHandle = NULL;
|
|
THandle * NextHandle = NULL;
|
|
|
|
// Validate
|
|
if (!Handle || (Handle->FD == -1))
|
|
return false;
|
|
|
|
// Close Children
|
|
if (CloseChildren && (Handle->Type == ctServer)) {
|
|
ChildHandle = FirstHandle;
|
|
while (ChildHandle) {
|
|
if (ChildHandle->Parent == Handle) {
|
|
NextHandle = ChildHandle->Next;
|
|
|
|
// Close
|
|
Close( ChildHandle );
|
|
|
|
// Next Handle
|
|
ChildHandle = NextHandle;
|
|
} else {
|
|
// Next Handle
|
|
ChildHandle = ChildHandle->Next;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Close Handle
|
|
Fail = (close( Handle->FD ))? true : false;
|
|
ChangeState( Handle, ((Fail)? csFailed : csClosed) );
|
|
|
|
// Start re-open timer
|
|
SetStartTime( &(Handle->ReopenStart) );
|
|
|
|
// Show action
|
|
switch (Handle->Type)
|
|
{
|
|
case ctPort:
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Port %s [%s]", Name, Handle->Name, ((Fail)? "failed" : "closed"), Handle->Path );
|
|
break;
|
|
|
|
case ctForkPipe:
|
|
// Log Event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Forked Pipe %s", Name, Handle->Name, ((Fail)? "failed" : "closed"));
|
|
break;
|
|
|
|
case ctServer:
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Server %s [%s:%d]", Name, Handle->Name, ((Fail)? "failed" : "closed"), Handle->Address, Handle->PortNo );
|
|
break;
|
|
|
|
case ctRemoteClient:
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Remote Client connection %s [%s]", Name, Handle->Name, ((Fail)? "failed" : "closed"), Handle->Address );
|
|
break;
|
|
|
|
case ctClient:
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Client connection %s [%s:%d]", Name, Handle->Name, ((Fail)? "failed" : "closed"), Handle->Address, Handle->PortNo );
|
|
break;
|
|
|
|
case ctNone:
|
|
default:
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - %s, invalid Handle type", Name, Handle->Name, ((Fail)? "failed" : "closed") );
|
|
break;
|
|
};
|
|
|
|
// Remove from Select List
|
|
if (!Fail && Select) {
|
|
Select->Remove( Handle->FD, true, true );
|
|
}
|
|
|
|
// Reset FD
|
|
Handle->FD = ((Fail)? Handle->FD : -1);
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Device Interface
|
|
bool CSelectableCore::Read( THandle * Handle )
|
|
{
|
|
int ClientFD = -1;
|
|
int BytesRead = 0;
|
|
int BytesWaiting = -1;
|
|
|
|
// Validate
|
|
if (!Handle || (Handle->State == csNone) || (Handle->State == csFailed) || (Handle->State == csClosed)) {
|
|
return false;
|
|
}
|
|
|
|
// Log Read Event
|
|
if (Log) Log->Message( DebugLevel, dlHigh, "%s: Handle '%s' - Read Event", Name, Handle->Name );
|
|
|
|
// Check for closing/opening event on Socket
|
|
if (Handle->Type == ctServer)
|
|
{
|
|
// Incoming client request
|
|
ClientFD = OpenRemoteClientSocket( Handle );
|
|
if (ClientFD != -1) {
|
|
// Add to Select Lists
|
|
if (Select) {
|
|
Select->Add( ClientFD, true, true, this );
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
else if ((Handle->Type == ctRemoteClient) || (Handle->Type == ctClient))
|
|
{
|
|
// Check if socket ready (non-block open in progress)
|
|
if (Handle->State == csWaitingtoOpen)
|
|
{
|
|
if (Handle->Type == ctRemoteClient) {
|
|
OpenRemoteClientSocket( Handle );
|
|
} else if (Handle->Type == ctClient) {
|
|
OpenClientSocket( Handle );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Check if anything to read
|
|
ioctl( Handle->FD, FIONREAD, &BytesWaiting );
|
|
|
|
// EOF from server
|
|
if (!BytesWaiting)
|
|
{
|
|
// Close Handle
|
|
Close( Handle );
|
|
|
|
// Destroy Remote Client
|
|
if (Handle->Type == ctRemoteClient) {
|
|
RemoveHandle( Handle );
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Validate
|
|
if (Handle->State != csOpen) {
|
|
return false;
|
|
}
|
|
|
|
// Read File directly into buffer
|
|
if (Handle->InBuffer && (BytesRead = Handle->InBuffer->ReadFromFD( Handle->FD )))
|
|
{
|
|
// Process Buffer
|
|
ProcessBuffer( Handle, false );
|
|
}
|
|
|
|
// Reset timer
|
|
SetStartTime( &(Handle->InStart) );
|
|
|
|
return (bool)BytesRead;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::Write( THandle * Handle )
|
|
{
|
|
int Len = 0;
|
|
char * Data = NULL;
|
|
int BytesWritten = 0;
|
|
|
|
// Validate
|
|
if (!Handle || (Handle->State == csNone) || (Handle->State == csFailed) || (Handle->State == csClosed)) {
|
|
return false;
|
|
}
|
|
|
|
// Log Ready for Write Event
|
|
if (Log) Log->Message( DebugLevel, dlHigh, "%s: Handle '%s' - Write Event", Name, Handle->Name );
|
|
|
|
if (Handle->State == csWaitingtoOpen)
|
|
{
|
|
// Complete socket open process
|
|
if (Handle->Type == ctRemoteClient) {
|
|
OpenRemoteClientSocket( Handle );
|
|
} else if (Handle->Type == ctClient) {
|
|
OpenClientSocket( Handle );
|
|
}
|
|
|
|
// Remove from set for select write
|
|
if (Select) {
|
|
Select->Remove( Handle->FD, false, true );
|
|
}
|
|
return true;
|
|
}
|
|
else if (Handle->State == csOpen)
|
|
{
|
|
if (Handle->OutBuffer)
|
|
{
|
|
// Write to FD directly from output buffer
|
|
if ((BytesWritten = Handle->OutBuffer->WriteToFD( Handle->FD )))
|
|
{
|
|
if (DebugLevel >= dlHigh) {
|
|
// Show event
|
|
Len = Handle->OutBuffer->Peek( &Data );
|
|
if (Log) Log->Output( DebugLevel, dlHigh, OutputDisplay, Data, Len, "%s: Handle '%s' - OUT:", Name, Handle->Name );
|
|
}
|
|
|
|
// Update Buffer
|
|
Handle->OutBuffer->Clear( BytesWritten );
|
|
}
|
|
|
|
// Check if Buffer emtpy
|
|
if (!Handle->OutBuffer->Len()) {
|
|
// Add to Select Write list
|
|
if (Select) {
|
|
Select->Remove( Handle->FD, false, true );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No Output buffer to write from, so remove from Write list
|
|
if (Select) {
|
|
Select->Remove( Handle->FD, false, true );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::ProcessBuffer( THandle * Handle, bool Force )
|
|
{
|
|
int Pos = 0;
|
|
int Len = 0;
|
|
char * Data = NULL;
|
|
|
|
// Check if buffered data
|
|
if (!Handle || !Handle->InBuffer || !Handle->InBuffer->Len()) {
|
|
return false;
|
|
}
|
|
|
|
// Check if forced processed
|
|
if (Force || !Handle->InMarkerLen)
|
|
{
|
|
// Show Packet
|
|
Len = Handle->InBuffer->Peek( &Data );
|
|
if (Log) Log->Output( DebugLevel, dlHigh, OutputDisplay, Data, Len, "%s: Handle '%s' - IN-T:", Name, Handle->Name );
|
|
|
|
// Write buffer to Outputs
|
|
if (Handle->Type == ctRemoteClient) {
|
|
Output( Handle->Parent->Channel, Data, Len );
|
|
} else {
|
|
Output( Handle->Channel, Data, Len );
|
|
}
|
|
|
|
// Clear processed bytes from buffer
|
|
Handle->InBuffer->Clear( Len );
|
|
}
|
|
else
|
|
{
|
|
// Search for end of packet marker
|
|
while (Handle->InBuffer->FindStr( Handle->InMarker, Handle->InMarkerLen, Pos ))
|
|
{
|
|
// Show Packet
|
|
Len = Handle->InBuffer->Peek( &Data, 0, Pos+Handle->InMarkerLen );
|
|
if (Log) Log->Output( DebugLevel, dlHigh, OutputDisplay, Data, Len, "%s: Handle '%s' - IN-M:", Name, Handle->Name );
|
|
|
|
// Write buffer to Outputs
|
|
if (Handle->Type == ctRemoteClient) {
|
|
Output( Handle->Parent->Channel, Data, Len );
|
|
} else {
|
|
Output( Handle->Channel, Data, Len );
|
|
}
|
|
|
|
// Clear processed bytes from buffer
|
|
Handle->InBuffer->Clear( Len );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::ReadFromFD( int FD, char * Data, int MaxLen )
|
|
{
|
|
int BytesRead = 0;
|
|
int TotalRead = 0;
|
|
int DataRemain = 0;
|
|
|
|
// Check if buffer created
|
|
if ((FD == -1) || !Data) {
|
|
return 0;
|
|
}
|
|
|
|
// Read Data into buffer
|
|
DataRemain = (MaxLen == -1)? strlen(Data) : MaxLen;
|
|
while (DataRemain)
|
|
{
|
|
// Read from file descriptor
|
|
BytesRead = read( FD, &Data[TotalRead], DataRemain );
|
|
if ((BytesRead <= 0)) {
|
|
break;
|
|
}
|
|
|
|
// Update Data Pointers
|
|
TotalRead += BytesRead;
|
|
DataRemain -= BytesRead;
|
|
}
|
|
return TotalRead;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::WriteToFD( int FD, const char * Data, int Len, bool Force )
|
|
{
|
|
int BytesWritten = 0;
|
|
int TotalWritten = 0;
|
|
int DataRemain = 0;
|
|
|
|
// Check if buffer created
|
|
if ((FD == -1) || !Data) {
|
|
return 0;
|
|
}
|
|
|
|
// Read Data into buffer
|
|
DataRemain = (Len == -1)? strlen(Data) : Len;
|
|
while (DataRemain)
|
|
{
|
|
// Read from file descriptor
|
|
BytesWritten = write( FD, &Data[TotalWritten], DataRemain );
|
|
if ((BytesWritten <= 0) && (!Force || (errno != EAGAIN))) {
|
|
break;
|
|
}
|
|
|
|
// Update Data Pointers
|
|
TotalWritten += BytesWritten;
|
|
DataRemain -= BytesWritten;
|
|
}
|
|
return TotalWritten;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int CSelectableCore::Input( const char * ChannelName, const char * Data, int Len )
|
|
{
|
|
THandle * Handle = NULL;
|
|
THandle * ChildHandle = NULL;
|
|
int BytesWritten = 0;
|
|
|
|
// Validate
|
|
if (!ChannelName || !Data) {
|
|
return 0;
|
|
}
|
|
|
|
// Get File handle
|
|
if (!(Handle = GetHandle( ChannelName ))) {
|
|
// Handle not found
|
|
if (Log) Log->Message( DebugLevel, dlHigh, "%s: Channel '%s' - Input rejected, Handle not found", Name, ChannelName );
|
|
return 0;
|
|
}
|
|
else if (Handle->Channel && !Handle->Channel->InputEnabled) {
|
|
// Handle is not open
|
|
if (Log) Log->Message( DebugLevel, dlHigh, "%s: Channel '%s' - Input rejected, Channel input disabled", Name, ChannelName );
|
|
return 0;
|
|
}
|
|
else if (Handle->State != csOpen) {
|
|
// Handle is not open
|
|
if (Log) Log->Message( DebugLevel, dlHigh, "%s: Channel '%s' - Input rejected, Handle not Open", Name, ChannelName );
|
|
return 0;
|
|
}
|
|
|
|
// Log event
|
|
if (Log) Log->Output( DebugLevel, dlHigh, OutputDisplay, Data, Len, "%s: Channel '%s' - IN:", Name, ChannelName );
|
|
|
|
// Check packet length
|
|
if (Len == -1) {
|
|
Len = strlen( Data );
|
|
}
|
|
|
|
if (Handle->Type == ctServer)
|
|
{
|
|
// Cannot write to server socket, so Update Remote Client connections individually
|
|
ChildHandle = FirstHandle;
|
|
while (ChildHandle)
|
|
{
|
|
// Check if child
|
|
if (ChildHandle->Parent == Handle)
|
|
{
|
|
// Decide where to put data
|
|
if (ChildHandle->OutBuffer)
|
|
{
|
|
// Write to buffer
|
|
BytesWritten = ChildHandle->OutBuffer->Push( true, Data, Len );
|
|
|
|
// Add to select write list
|
|
if (BytesWritten) {
|
|
Select->Add( ChildHandle->FD, false, true, this );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Write directly to handle
|
|
BytesWritten = WriteToFD( ChildHandle->FD, Data, Len, true );
|
|
|
|
// Show event
|
|
if (Log) Log->Output( DebugLevel, dlHigh, OutputDisplay, Data, Len, "%s: Handle '%s' - OUT:", Name, ChildHandle->Name );
|
|
}
|
|
}
|
|
// Next
|
|
ChildHandle = ChildHandle->Next;
|
|
}
|
|
|
|
// Cannot verify individually, so assume all bytes was written
|
|
BytesWritten = Len;
|
|
}
|
|
else
|
|
{
|
|
// Decide where to put data
|
|
if (Handle->OutBuffer)
|
|
{
|
|
// Write to buffer
|
|
BytesWritten = Handle->OutBuffer->Push( true, Data, Len );
|
|
|
|
// Add to select write list
|
|
if (BytesWritten) {
|
|
Select->Add( Handle->FD, false, true, this );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Show event
|
|
if (Log) Log->Output( DebugLevel, dlHigh, OutputDisplay, Data, Len, "%s: Handle '%s' - OUT:", Name, Handle->Name );
|
|
|
|
// Write directly to handle
|
|
BytesWritten = WriteToFD( Handle->FD, Data, Len, true );
|
|
}
|
|
}
|
|
|
|
return BytesWritten;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::Process()
|
|
{
|
|
THandle * Handle = NULL;
|
|
|
|
// Check all handles
|
|
Handle = FirstHandle;
|
|
while (Handle)
|
|
{
|
|
// Auto manage handles
|
|
if (Handle->Auto && ((Handle->State == csNone) || (Handle->State == csFailed) || (Handle->State == csClosed)))
|
|
{
|
|
// Check duration since last PortIn
|
|
if (Timeout( Handle->ReopenStart, Handle->ReopenTimeout ))
|
|
{
|
|
// Complete opening process
|
|
if (Open( Handle ) == -1)
|
|
{
|
|
// Reset Timer
|
|
SetStartTime( &(Handle->ReopenStart) );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check Input buffers
|
|
if (Handle->InBuffer && (Handle->InBuffer->Len() > 0))
|
|
{
|
|
// Check duration since last PortIn
|
|
if (Timeout( Handle->InStart, Handle->InTimeout ))
|
|
{
|
|
// Process Input
|
|
ProcessBuffer( Handle, true );
|
|
|
|
// Reset timer
|
|
ClearStartTime( &(Handle->InStart) );
|
|
}
|
|
}
|
|
Handle = Handle->Next;
|
|
}
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Set serial port configuration parameters
|
|
bool CSelectableCore::SerialConfig( THandle * Handle, int Baud, short DataBits, short StopBits, short Parity, short FlowCtrl, int Wait )
|
|
{
|
|
struct termios newtio;
|
|
int flags = 0;
|
|
speed_t _baud = 0;
|
|
int mcs = 0;
|
|
|
|
// Get Handle
|
|
if (!Handle || (Handle->Type != ctPort)) {
|
|
return false;
|
|
}
|
|
|
|
// Flush Data from port
|
|
tcflush( Handle->FD, TCIFLUSH );
|
|
|
|
// Set Open flags
|
|
flags = fcntl( Handle->FD, F_GETFL, 0 );
|
|
fcntl( Handle->FD, F_SETFL, flags & ~O_NDELAY );
|
|
|
|
// Read options
|
|
if (tcgetattr( Handle->FD, &newtio ) != 0)
|
|
return false;
|
|
|
|
// Process the baud rate
|
|
switch (Baud)
|
|
{
|
|
case 921600: _baud = B921600; break;
|
|
case 576000: _baud = B576000; break;
|
|
case 460800: _baud = B460800; break;
|
|
case 230400: _baud = B230400; break;
|
|
//case 128000: _baud = B128000; break;
|
|
case 115200: _baud = B115200; break;
|
|
//case 76800: _baud = B76800; break;
|
|
case 57600: _baud = B57600; break;
|
|
case 38400: _baud = B38400; break;
|
|
//case 28800: _baud = B28800; break;
|
|
case 19200: _baud = B19200; break;
|
|
//case 14400: _baud = B14400; break;
|
|
case 9600: _baud = B9600; break;
|
|
case 4800: _baud = B4800; break;
|
|
case 2400: _baud = B2400; break;
|
|
case 1800: _baud = B1800; break;
|
|
case 1200: _baud = B1200; break;
|
|
case 600: _baud = B600; break;
|
|
case 300: _baud = B300; break;
|
|
case 200: _baud = B200; break;
|
|
case 150: _baud = B150; break;
|
|
case 134: _baud = B134; break;
|
|
case 110: _baud = B110; break;
|
|
case 75: _baud = B75; break;
|
|
case 50: _baud = B50; break;
|
|
|
|
default: _baud = B9600; break;
|
|
}
|
|
|
|
// Set Baud rate
|
|
cfsetospeed( &newtio, (speed_t)_baud );
|
|
cfsetispeed( &newtio, (speed_t)_baud );
|
|
|
|
// Generate Mark/Space parity
|
|
if ((DataBits == 7) && ((Parity == MARK_PARITY) || (Parity == SPACE_PARITY)))
|
|
DataBits = 8;
|
|
|
|
// Process the data bits
|
|
newtio.c_cflag &= ~CSIZE;
|
|
switch (DataBits)
|
|
{
|
|
case 5: newtio.c_cflag |= CS5; break;
|
|
case 6: newtio.c_cflag |= CS6; break;
|
|
case 7: newtio.c_cflag |= CS7; break;
|
|
case 8: newtio.c_cflag |= CS8; break;
|
|
|
|
default: newtio.c_cflag |= CS8; break;
|
|
}
|
|
|
|
// Set other flags
|
|
newtio.c_cflag |= CLOCAL | CREAD;
|
|
|
|
// Process Parity
|
|
newtio.c_cflag &= ~(PARENB | PARODD);
|
|
if (Parity == EVEN_PARITY)
|
|
newtio.c_cflag |= PARENB;
|
|
else if (Parity == ODD_PARITY)
|
|
newtio.c_cflag |= (PARENB | PARODD);
|
|
|
|
// Flow Control (for now)
|
|
newtio.c_cflag &= ~CRTSCTS;
|
|
|
|
// Process Stop Bits
|
|
if (StopBits == 2)
|
|
newtio.c_cflag |= CSTOPB;
|
|
else
|
|
newtio.c_cflag &= ~CSTOPB;
|
|
|
|
newtio.c_iflag = IGNBRK;
|
|
|
|
// Software Flow Control
|
|
if (FlowCtrl == SW_FLOWCTRL)
|
|
newtio.c_iflag |= IXON | IXOFF;
|
|
else
|
|
newtio.c_iflag &= ~(IXON | IXOFF | IXANY);
|
|
|
|
// Set RAW input & output
|
|
newtio.c_lflag=0;
|
|
newtio.c_oflag=0;
|
|
|
|
// Set wait parameters
|
|
newtio.c_cc[VTIME] = Wait; // Blocking: Allow at least a tenth of a second to wait for data
|
|
newtio.c_cc[VMIN] = 0; // Non-blocking: Don't set min bytes to receive
|
|
|
|
// Set Options (first time)
|
|
//tcflush( Handle->FD, TCIFLUSH);
|
|
if (tcsetattr( Handle->FD, TCSANOW, &newtio)!=0)
|
|
return false;
|
|
|
|
// Set Terminal options
|
|
ioctl( Handle->FD, TIOCMGET, &mcs);
|
|
mcs |= TIOCM_RTS;
|
|
ioctl( Handle->FD, TIOCMSET, &mcs);
|
|
|
|
// Get Options (again)
|
|
if (tcgetattr( Handle->FD, &newtio) != 0)
|
|
return false;
|
|
|
|
// Process Hardware Flow Control
|
|
if (FlowCtrl == HW_FLOWCTRL)
|
|
newtio.c_cflag |= CRTSCTS;
|
|
else
|
|
newtio.c_cflag &= ~CRTSCTS;
|
|
|
|
// Set Options (second time)
|
|
if (tcsetattr( Handle->FD, TCSANOW, &newtio ) != 0)
|
|
{
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Port not configured", Name, Handle->Name );
|
|
return false;
|
|
}
|
|
|
|
// Port configured
|
|
// Log event
|
|
if (Log) Log->Message( DebugLevel, dlMedium, "%s: Handle '%s' - Port configured", Name, Handle->Name );
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CSelectableCore::BuildArgs( const char * ExecPath, int &Count, char * Args[] )
|
|
{
|
|
bool ParamStarted = false;
|
|
bool OpenQuotes = false;
|
|
char * MatchPos = NULL;
|
|
char * StartPos = NULL;
|
|
int Len;
|
|
|
|
// Validate
|
|
if (!ExecPath || !*ExecPath) {
|
|
return false;
|
|
}
|
|
|
|
// Split params
|
|
MatchPos = (char*)ExecPath;
|
|
for (;;)
|
|
{
|
|
// Look for whitespace
|
|
if (!ParamStarted)
|
|
{
|
|
// Quotes starts quoted parameter
|
|
if (*MatchPos == '"') {
|
|
ParamStarted = true;
|
|
OpenQuotes = true;
|
|
StartPos = MatchPos+1; // Skip starting quote
|
|
}
|
|
// Non-whitespace starts normal parameter
|
|
else if ((*MatchPos != ' ') && (*MatchPos != 0)) {
|
|
ParamStarted = true;
|
|
StartPos = MatchPos;
|
|
}
|
|
}
|
|
else if (OpenQuotes)
|
|
{
|
|
// Another quote ends parameter
|
|
if (*MatchPos == '"') {
|
|
Len = MatchPos-StartPos-1; // Skip end quote
|
|
Args[Count] = (char*)malloc( Len+1 );
|
|
strncpy( Args[Count], StartPos, Len );
|
|
Args[Count][Len] = 0;
|
|
Count++;
|
|
ParamStarted = false;
|
|
OpenQuotes = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Whitespace ends parameter
|
|
if ((*MatchPos == ' ') || (*MatchPos == 0)) {
|
|
Len = MatchPos-StartPos;
|
|
Args[Count] = (char*)malloc( Len+1 );
|
|
strncpy( Args[Count], StartPos, Len );
|
|
Args[Count][Len] = 0;
|
|
Count++;
|
|
ParamStarted = false;
|
|
}
|
|
}
|
|
// Next char, unless NULL
|
|
if (*MatchPos)
|
|
MatchPos++;
|
|
else
|
|
break;
|
|
}
|
|
|
|
// Check all parameters closed
|
|
if (ParamStarted) {
|
|
Count = 0;
|
|
Args[0] = NULL;
|
|
return false;
|
|
}
|
|
|
|
// Set last Param to NULL
|
|
Args[Count] = NULL;
|
|
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|