core/redAcore
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Important Update:

Browse Source 
- Complete Async resolve:
  - Remove Resolving param from THandle
  - Rename state csResolving -> csPreparing
  - Added handle state csPrepared, to indicated resolve complete
  - Open handle if state = csPrepared
  - Remove Resolve delay (not required since async resolve)
    - remove from JSON config as well
This commit is contained in:
Charl Wentzel
2019-06-10 10:44:51 +02:00
parent bde14a13da
commit 7787da5119
3 changed files with 64 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
SelectableBare.cpp
View File

@@ -184,7 +184,7 @@ bool CSelectableBare::HandleState( THandle * Handle, EConnectState State )
// Update Channel // Update Channel
if (Handle->Channel) { if (Handle->Channel) {
if ((Handle->State == csOpenRequest) || (Handle->State == csWaitingtoOpen)) if ((Handle->State == csPreparing) || (Handle->State == csPrepared) || (Handle->State == csWaitingtoOpen))
ChannelState = CH_wait; ChannelState = CH_wait;
else if ((Handle->State == csOpen) || (Handle->State == csDataWaiting)) else if ((Handle->State == csOpen) || (Handle->State == csDataWaiting))
ChannelState = CH_ready; ChannelState = CH_ready;
@@ -331,7 +331,7 @@ bool CSelectableBare::ProcessInputBuffer( THandle * Handle, bool Force )
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int CSelectableBare::Open( THandle * Handle, bool DelayResolve ) int CSelectableBare::Open( THandle * Handle )
{ {
THandle * NewHandle = NULL; THandle * NewHandle = NULL;
@@ -513,7 +513,7 @@ bool CSelectableBare::Write( THandle * Handle )
else if (Timeout( Handle->LastAction, Handle->ReopenDelay )) else if (Timeout( Handle->LastAction, Handle->ReopenDelay ))
{ {
// Attempt to re-open port // Attempt to re-open port
Open( Handle, true ); Open( Handle );
} }
} }
@@ -731,11 +731,11 @@ int CSelectableBare::OutputHandle( THandle * Handle, const char * Data, int Len
else if (Timeout( Handle->LastAction, Handle->ReopenDelay )) else if (Timeout( Handle->LastAction, Handle->ReopenDelay ))
{ {
// Complete opening process // Complete opening process
Open( Handle, true ); Open( Handle );
// Check if Handle is open // Check if Handle is open
if (Handle->State == csOpenRequest) { if ((Handle->State == csPreparing) || (Handle->State == csPrepared)) {
if (Log) Log->Message( LogLevel, dlHigh, "%s/%s: Handle '%s' - Input rejected, Request to resolve (auto-managed) Handle", if (Log) Log->Message( LogLevel, dlHigh, "%s/%s: Handle '%s' - Input rejected, Preparing (auto-managed) Handle",
ProcessName, Name, Handle->Name ); ProcessName, Name, Handle->Name );
return 0; return 0;
} }
@@ -812,27 +812,21 @@ bool CSelectableBare::Process()
while (Handle) while (Handle)
{ {
// Auto manage handles // Auto manage handles
if ((Handle->State == csOpenRequest)) if (Handle->State == csPrepared) {
{ // Proceed to open
// Resolve then open socket Open( Handle );
if (Timeout( Handle->LastAction, Handle->ResolveDelay )) {
Open( Handle, false );
} }
} else if ((Handle->State != csOpen) && Handle->AutoManage && Handle->Persistent) {
else if (((Handle->State != csOpen) && Handle->AutoManage && Handle->Persistent) )
{
// Try to re-open port after delay // Try to re-open port after delay
if (Timeout( Handle->LastAction, Handle->ReopenDelay )) { if (Timeout( Handle->LastAction, Handle->ReopenDelay )) {
Open( Handle, false ); Open( Handle );
} }
} }
// Check Input buffers // Check Input buffers
if (Handle->InBuffer && (Handle->InBuffer->Len() > 0)) if (Handle->InBuffer && (Handle->InBuffer->Len() > 0)) {
{
// Check duration since last PortIn // Check duration since last PortIn
if (Timeout( Handle->InStart, Handle->InTimeout )) if (Timeout( Handle->InStart, Handle->InTimeout )) {
{
// Process Input // Process Input
ProcessInputBuffer( Handle, true ); ProcessInputBuffer( Handle, true );
@@ -842,14 +836,12 @@ bool CSelectableBare::Process()
} }
// Check for auto close (but not on servers) // Check for auto close (but not on servers)
if ((Handle->State == csOpen) && (Handle->Type != ctTCPserver) && (Handle->Type != ctUNIXserver) && Handle->AutoManage && !Handle->Persistent) if ((Handle->State == csOpen) && Handle->AutoManage && !Handle->Persistent) {
{
// Close port after timeout // Close port after timeout
if (Timeout( Handle->LastAction, Handle->CloseTimeout )) { if (Timeout( Handle->LastAction, Handle->CloseTimeout )) {
Close( Handle, true ); Close( Handle, true );
} }
} }
Handle = Handle->Next; Handle = Handle->Next;
} }
return true; return true;

95
SelectableCore.cpp
View File

@@ -79,7 +79,7 @@ CSelectableCore::~CSelectableCore()
while (FirstHandle) while (FirstHandle)
{ {
// Close active resolve request // Close active resolve request
if (FirstHandle->Resolving && FirstHandle->ResolveReq) { if (FirstHandle->ResolveReq) {
if ((Result = gai_cancel( FirstHandle->ResolveReq->Request )) != 0) { if ((Result = gai_cancel( FirstHandle->ResolveReq->Request )) != 0) {
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Error canceling Host Name resolve [%s:%s] (%s)", if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Error canceling Host Name resolve [%s:%s] (%s)",
ProcessName, Name, FirstHandle->Name, FirstHandle->HostName, FirstHandle->PortName, gai_strerror(Result) ); ProcessName, Name, FirstHandle->Name, FirstHandle->HostName, FirstHandle->PortName, gai_strerror(Result) );
@@ -114,7 +114,6 @@ bool CSelectableCore::Init( CDataMember * FunctionConfig )
short Parity; short Parity;
short FlowCtrl; short FlowCtrl;
short Queue; short Queue;
long Delay;
// Call Previous load config // Call Previous load config
if (!CFunctionCore::Init( FunctionConfig )) if (!CFunctionCore::Init( FunctionConfig ))
@@ -210,8 +209,7 @@ bool CSelectableCore::Init( CDataMember * FunctionConfig )
Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value
Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value
} }
Delay = HandleConfig->GetChInt( "Socket/ResolveDelay", 0, true ); SetSocketHandle( Handle, ctUDPserver, Address, strlcase(Port), 0 );
SetSocketHandle( Handle, ctUDPserver, Address, strlcase(Port), 0, Delay );
} }
else if (!strcasecmp( Type, "UDPclient" )) else if (!strcasecmp( Type, "UDPclient" ))
{ {
@@ -222,8 +220,7 @@ bool CSelectableCore::Init( CDataMember * FunctionConfig )
Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value
Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value
} }
Delay = HandleConfig->GetChInt( "Socket/ResolveDelay", 0, true ); SetSocketHandle( Handle, ctUDPclient, Address, strlcase(Port), 0 );
SetSocketHandle( Handle, ctUDPclient, Address, strlcase(Port), 0, Delay );
} }
else if (!strcasecmp( Type, "TCPserver" )) else if (!strcasecmp( Type, "TCPserver" ))
{ {
@@ -234,9 +231,8 @@ bool CSelectableCore::Init( CDataMember * FunctionConfig )
Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value
Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value
} }
Delay = HandleConfig->GetChInt( "Socket/ResolveDelay", 0, true );
Queue = HandleConfig->GetChInt( "Socket/Queue", 2, true ); Queue = HandleConfig->GetChInt( "Socket/Queue", 2, true );
SetSocketHandle( Handle, ctTCPserver, Address, strlcase(Port), Queue, Delay ); SetSocketHandle( Handle, ctTCPserver, Address, strlcase(Port), Queue );
} }
else if (!strcasecmp( Type, "TCPclient" )) else if (!strcasecmp( Type, "TCPclient" ))
{ {
@@ -247,8 +243,7 @@ bool CSelectableCore::Init( CDataMember * FunctionConfig )
Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value Address = (char*)HandleConfig->GetChStr( "Socket/Address", NULL, true ); // Get default Address value
Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value Port = (char*)HandleConfig->GetChStr( "Socket/Port", "0", true ); // Get default Port value
} }
Delay = HandleConfig->GetChInt( "Socket/ResolveDelay", 0, true ); SetSocketHandle( Handle, ctTCPclient, Address, strlcase(Port), 0 );
SetSocketHandle( Handle, ctTCPclient, Address, strlcase(Port), 0, Delay );
} }
else if (!strcasecmp( Type, "ForkPipe" )) { else if (!strcasecmp( Type, "ForkPipe" )) {
Address = (char*)HandleConfig->GetChStr( "Fork/ExecPath", NULL, true ); // Get default value Address = (char*)HandleConfig->GetChStr( "Fork/ExecPath", NULL, true ); // Get default value
@@ -285,7 +280,7 @@ bool CSelectableCore::DestroyHandle( THandle * Handle )
return false; return false;
// Destroy Resolve request // Destroy Resolve request
if (Handle->Resolving && Handle->ResolveReq) { if (Handle->ResolveReq) {
if ((Result = gai_cancel( Handle->ResolveReq->Request )) != 0) { if ((Result = gai_cancel( Handle->ResolveReq->Request )) != 0) {
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Error canceling Host Name resolve [%s:%s] (%s)", if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Error canceling Host Name resolve [%s:%s] (%s)",
ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName, gai_strerror(Result) ); ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName, gai_strerror(Result) );
@@ -467,7 +462,7 @@ bool CSelectableCore::SetUnixHandle( THandle * Handle, EConnectType Type, const
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CSelectableCore::SetSocketHandle( THandle * Handle, EConnectType Type, const char * HostName, const char * PortName, short Queue, long ResolveDelay ) bool CSelectableCore::SetSocketHandle( THandle * Handle, EConnectType Type, const char * HostName, const char * PortName, short Queue )
{ {
// Validate // Validate
if (!Handle || !HostName || !PortName || if (!Handle || !HostName || !PortName ||
@@ -478,7 +473,6 @@ bool CSelectableCore::SetSocketHandle( THandle * Handle, EConnectType Type, con
// Set Type // Set Type
Handle->Type = Type; Handle->Type = Type;
Handle->ResolveDelay = ResolveDelay;
// Clear HostName & Port Name // Clear HostName & Port Name
if (Handle->HostName) if (Handle->HostName)
@@ -984,7 +978,7 @@ THandle * CSelectableCore::OpenUNIXremoteSocket( THandle * Handle )
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CSelectableCore::ResolveAddress( THandle * Handle, bool DelayResolve ) bool CSelectableCore::ResolveAddress( THandle * Handle )
{ {
struct addrinfo * Hints; struct addrinfo * Hints;
TResolveReq * ResolveReq; TResolveReq * ResolveReq;
@@ -992,7 +986,7 @@ bool CSelectableCore::ResolveAddress( THandle * Handle, bool DelayResolve )
int Result; int Result;
// Ignore if busy resolving // Ignore if busy resolving
if (Handle->Resolving) if (Handle->State == csPreparing)
return false; return false;
// Check if resolved address available // Check if resolved address available
@@ -1057,17 +1051,9 @@ bool CSelectableCore::ResolveAddress( THandle * Handle, bool DelayResolve )
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Resolving Host name [%s:%s]...", if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Resolving Host name [%s:%s]...",
ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName ); ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName );
// Should address be resolved later during process()
if (DelayResolve) {
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Delay resolving of Host Name [%s:%s]",
ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName );
HandleState( Handle, csOpenRequest );
return false;
}
// Resolve Host & Port Names // Resolve Host & Port Names
Handle->Resolving = true; HandleState( Handle, csPreparing );
if ((Result = getaddrinfo_a( GAI_NOWAIT, &(Handle->ResolveReq->Request), 1, &ResolveEvt )) != 0) { if ((Result = getaddrinfo_a( GAI_NOWAIT, &(Handle->ResolveReq->Request), 1, &ResolveEvt )) != 0) {
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Error resolving Host Name [%s:%s] (%s)", if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Error resolving Host Name [%s:%s] (%s)",
ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName, gai_strerror(Result) ); ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName, gai_strerror(Result) );
@@ -1086,9 +1072,6 @@ bool CSelectableCore::DestroyResolveReq( THandle * Handle, bool DestroyResult )
if (!Handle || !Handle->ResolveReq) if (!Handle || !Handle->ResolveReq)
return false; return false;
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - Destroying resolve request [%s:%s]",
ProcessName, Name, Handle->Name, Handle->HostName, Handle->PortName );
// Destroy // Destroy
if (DestroyResult) { if (DestroyResult) {
if (Handle->ResolveReq->Request->ar_result) if (Handle->ResolveReq->Request->ar_result)
@@ -1103,7 +1086,6 @@ bool CSelectableCore::DestroyResolveReq( THandle * Handle, bool DestroyResult )
// Reset request // Reset request
Handle->ResolveReq = NULL; Handle->ResolveReq = NULL;
Handle->Resolving = false;
return true; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@@ -1149,11 +1131,12 @@ bool CSelectableCore::HandleResolve( THandle * Handle )
// Destroy request // Destroy request
DestroyResolveReq( Handle, false ); DestroyResolveReq( Handle, false );
HandleState( Handle, csPrepared );
return true; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
THandle * CSelectableCore::OpenUDPserverSocket( THandle * Handle, bool DelayResolve ) THandle * CSelectableCore::OpenUDPserverSocket( THandle * Handle )
{ {
// Validate Handle // Validate Handle
if (Handle->Type != ctUDPserver) { if (Handle->Type != ctUDPserver) {
@@ -1161,7 +1144,7 @@ THandle * CSelectableCore::OpenUDPserverSocket( THandle * Handle, bool DelayReso
} }
// Resolve Host & Port Names // Resolve Host & Port Names
if (!ResolveAddress( Handle, DelayResolve )) if (!ResolveAddress( Handle ))
return NULL; return NULL;
// Create socket // Create socket
@@ -1237,7 +1220,7 @@ THandle * CSelectableCore::OpenUDPremoteSocket( THandle * Handle, char * ClientA
// Create Remote Client Handle // Create Remote Client Handle
sprintf( ClientName, "%s-%d", Handle->Name, ClientCount ); sprintf( ClientName, "%s-%d", Handle->Name, ClientCount );
*RemoteClient = CreateHandle( ClientName, false ); *RemoteClient = CreateHandle( ClientName, false );
if (!SetSocketHandle( *RemoteClient, ctUDPremote, ClientAddress, ClientPort, 0, 0 )) { if (!SetSocketHandle( *RemoteClient, ctUDPremote, ClientAddress, ClientPort, 0 )) {
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - UDP Server failed to configure Remote Client connection (%s)", if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - UDP Server failed to configure Remote Client connection (%s)",
ProcessName, Name, Handle->Name, strerror(errno) ); ProcessName, Name, Handle->Name, strerror(errno) );
return NULL; return NULL;
@@ -1269,7 +1252,7 @@ THandle * CSelectableCore::OpenUDPremoteSocket( THandle * Handle, char * ClientA
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
THandle * CSelectableCore::OpenUDPclientSocket( THandle * Handle, bool DelayResolve ) THandle * CSelectableCore::OpenUDPclientSocket( THandle * Handle )
{ {
// Check state // Check state
if (Handle->State == csOpen) { if (Handle->State == csOpen) {
@@ -1278,7 +1261,7 @@ THandle * CSelectableCore::OpenUDPclientSocket( THandle * Handle, bool DelayReso
} }
// Resolve IP Address // Resolve IP Address
if (!ResolveAddress( Handle, DelayResolve )) if (!ResolveAddress( Handle ))
return NULL; return NULL;
// Create File descriptor // Create File descriptor
@@ -1311,7 +1294,7 @@ THandle * CSelectableCore::OpenUDPclientSocket( THandle * Handle, bool DelayReso
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
THandle * CSelectableCore::OpenTCPserverSocket( THandle * Handle, bool DelayResolve ) THandle * CSelectableCore::OpenTCPserverSocket( THandle * Handle )
{ {
// Socket options // Socket options
struct linger ServerLinger_opt; struct linger ServerLinger_opt;
@@ -1330,7 +1313,7 @@ THandle * CSelectableCore::OpenTCPserverSocket( THandle * Handle, bool DelayReso
} }
// Resolve Host & Port Names // Resolve Host & Port Names
if (!ResolveAddress( Handle, DelayResolve )) if (!ResolveAddress( Handle ))
return NULL; return NULL;
// Create socket // Create socket
@@ -1476,7 +1459,7 @@ THandle * CSelectableCore::OpenTCPremoteSocket( THandle * Handle )
// Create Remote Client Handle // Create Remote Client Handle
sprintf( ClientName, "%s-%d", Handle->Name, ClientFD ); sprintf( ClientName, "%s-%d", Handle->Name, ClientFD );
*RemoteClient = CreateHandle( ClientName, false ); *RemoteClient = CreateHandle( ClientName, false );
if (!SetSocketHandle( *RemoteClient, ctTCPremote, ClientAddress, ClientPort, 0, 0 )) { if (!SetSocketHandle( *RemoteClient, ctTCPremote, ClientAddress, ClientPort, 0 )) {
if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - TCP Server failed to configure Remote Client connection (%s)", if (Log) Log->Message( LogLevel, dlMedium, "%s/%s: Handle '%s' - TCP Server failed to configure Remote Client connection (%s)",
ProcessName, Name, Handle->Name, strerror(errno) ); ProcessName, Name, Handle->Name, strerror(errno) );
return NULL; return NULL;
@@ -1529,7 +1512,7 @@ THandle * CSelectableCore::OpenTCPremoteSocket( THandle * Handle )
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
THandle * CSelectableCore::OpenTCPclientSocket( THandle * Handle, bool DelayResolve ) THandle * CSelectableCore::OpenTCPclientSocket( THandle * Handle )
{ {
// Socket options // Socket options
int KeepAlive_opt = 1; // Enable/disable keep alive int KeepAlive_opt = 1; // Enable/disable keep alive
@@ -1547,7 +1530,7 @@ THandle * CSelectableCore::OpenTCPclientSocket( THandle * Handle, bool DelayReso
if (Handle->State != csWaitingtoOpen) if (Handle->State != csWaitingtoOpen)
{ {
// Resolve IP Address // Resolve IP Address
if (!ResolveAddress( Handle, DelayResolve )) if (!ResolveAddress( Handle ))
return NULL; return NULL;
// Create File descriptor // Create File descriptor
@@ -1638,7 +1621,7 @@ THandle * CSelectableCore::OpenTCPclientSocket( THandle * Handle, bool DelayReso
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int CSelectableCore::Open( THandle * Handle, bool DelayResolve ) int CSelectableCore::Open( THandle * Handle )
{ {
THandle * NewHandle = NULL; THandle * NewHandle = NULL;
@@ -1665,16 +1648,16 @@ int CSelectableCore::Open( THandle * Handle, bool DelayResolve )
NewHandle = OpenUNIXclientSocket( Handle ); NewHandle = OpenUNIXclientSocket( Handle );
break; break;
case ctUDPserver : case ctUDPserver :
NewHandle = OpenUDPserverSocket( Handle, DelayResolve ); NewHandle = OpenUDPserverSocket( Handle );
break; break;
case ctUDPclient : case ctUDPclient :
NewHandle = OpenUDPclientSocket( Handle, DelayResolve ); NewHandle = OpenUDPclientSocket( Handle );
break; break;
case ctTCPserver : case ctTCPserver :
NewHandle = OpenTCPserverSocket( Handle, DelayResolve ); NewHandle = OpenTCPserverSocket( Handle );
break; break;
case ctTCPclient : case ctTCPclient :
NewHandle = OpenTCPclientSocket( Handle, DelayResolve ); NewHandle = OpenTCPclientSocket( Handle );
break; break;
default: default:
NewHandle = NULL; NewHandle = NULL;
@@ -1880,7 +1863,7 @@ bool CSelectableCore::Read( THandle * Handle )
if (Handle->Type == ctTCPremote) { if (Handle->Type == ctTCPremote) {
OpenTCPremoteSocket( Handle ); OpenTCPremoteSocket( Handle );
} else if (Handle->Type == ctTCPclient) { } else if (Handle->Type == ctTCPclient) {
OpenTCPclientSocket( Handle, true ); OpenTCPclientSocket( Handle );
} else if (Handle->Type == ctUNIXremote) { } else if (Handle->Type == ctUNIXremote) {
OpenUNIXremoteSocket( Handle ); OpenUNIXremoteSocket( Handle );
} else if (Handle->Type == ctUNIXclient) { } else if (Handle->Type == ctUNIXclient) {
@@ -2042,7 +2025,7 @@ bool CSelectableCore::Write( THandle * Handle )
else if (Timeout( Handle->LastAction, Handle->ReopenDelay )) else if (Timeout( Handle->LastAction, Handle->ReopenDelay ))
{ {
// Attempt to re-open port // Attempt to re-open port
Open( Handle, true ); Open( Handle );
} }
} }
@@ -2056,7 +2039,7 @@ bool CSelectableCore::Write( THandle * Handle )
if (Handle->Type == ctTCPremote) { if (Handle->Type == ctTCPremote) {
OpenTCPremoteSocket( Handle ); OpenTCPremoteSocket( Handle );
} else if (Handle->Type == ctTCPclient) { } else if (Handle->Type == ctTCPclient) {
OpenTCPclientSocket( Handle, true ); OpenTCPclientSocket( Handle );
} else if (Handle->Type == ctUNIXremote) { } else if (Handle->Type == ctUNIXremote) {
OpenUNIXremoteSocket( Handle ); OpenUNIXremoteSocket( Handle );
} else if (Handle->Type == ctUNIXclient) { } else if (Handle->Type == ctUNIXclient) {
@@ -2207,11 +2190,11 @@ int CSelectableCore::OutputHandle( THandle * Handle, const char * Data, int Len
else if (Timeout( Handle->LastAction, Handle->ReopenDelay )) else if (Timeout( Handle->LastAction, Handle->ReopenDelay ))
{ {
// Complete opening process // Complete opening process
Open( Handle, true ); Open( Handle );
// Check if Handle is open // Check if Handle is open
if (Handle->State == csOpenRequest) { if (Handle->State == csPreparing) {
if (Log) Log->Message( LogLevel, dlHigh, "%s/%s: Handle '%s' - Input rejected, Request to resolve (auto-managed) Handle", if (Log) Log->Message( LogLevel, dlHigh, "%s/%s: Handle '%s' - Input rejected, Resolving (auto-managed) Handle",
ProcessName, Name, Handle->Name ); ProcessName, Name, Handle->Name );
return 0; return 0;
} }
@@ -2353,16 +2336,14 @@ bool CSelectableCore::Process()
while (Handle) while (Handle)
{ {
// Auto manage handles // Auto manage handles
if ((Handle->State == csOpenRequest)) { if (Handle->State == csPrepared) {
// Resolve then open socket // Proceed to open
if (Timeout( Handle->LastAction, Handle->ResolveDelay )) { Open( Handle );
Open( Handle, false );
} }
} else if ((Handle->State != csOpen) && Handle->AutoManage && Handle->Persistent) {
else if (((Handle->State != csOpen) && Handle->AutoManage && Handle->Persistent) ) {
// Try to re-open port after delay // Try to re-open port after delay
if (Timeout( Handle->LastAction, Handle->ReopenDelay )) { if (Timeout( Handle->LastAction, Handle->ReopenDelay )) {
Open( Handle, false ); Open( Handle );
} }
} }

26
SelectableCore.h
View File

@@ -24,8 +24,8 @@ typedef enum { ctNone = 0, ctSerial = 1, ctLinePrinter = 2, ctForkPipe = 3, ctUN
const char ConnectTypeName[][20] = { "None", "Serial Port", "Line Printer", "Fork Pipe", "UNIX Server", "UNIX Client", "UNIX Remote Client", const char ConnectTypeName[][20] = { "None", "Serial Port", "Line Printer", "Fork Pipe", "UNIX Server", "UNIX Client", "UNIX Remote Client",
"UDP Server", "UDP Client", "UDP Remote Client", "TCP Server", "TCP Client", "TCP Remote Client", "Custom" }; "UDP Server", "UDP Client", "UDP Remote Client", "TCP Server", "TCP Client", "TCP Remote Client", "Custom" };
typedef enum { csNone = 0, csOpenRequest = 1, csWaitingtoOpen = 2, csOpen = 3, csDataWaiting = 4, csClosed = 5, csFailed = 6 } EConnectState; typedef enum { csNone = 0, csPreparing = 1, csPrepared = 2, csWaitingtoOpen = 3, csOpen = 4, csDataWaiting = 5, csClosed = 6, csFailed = 7 } EConnectState;
const char ConnectStateName[][15] = { "None", "OpenRequest", "WaitingToOpen", "Open", "DataWaiting", "Closed", "Failed" }; const char ConnectStateName[][15] = { "None", "Preparing", "Prepared", "WaitingToOpen", "Open", "DataWaiting", "Closed", "Failed" };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@@ -91,7 +91,7 @@ struct SHandle {
long CloseTimeout = 1000; // millisecs of no traffic before closing socket long CloseTimeout = 1000; // millisecs of no traffic before closing socket
// Callback functions // Callback functions
FHandleCallback StateCallback[ 7 ] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL}; FHandleCallback StateCallback[ 8 ] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
// Type specific parameters // Type specific parameters
char * Path = NULL; // Port (file)name or Exec path char * Path = NULL; // Port (file)name or Exec path
@@ -107,9 +107,7 @@ struct SHandle {
bool AddressFailed = false; // Indicate failure to connect to address bool AddressFailed = false; // Indicate failure to connect to address
short Queue = 2; // Max waiting connections short Queue = 2; // Max waiting connections
long ResolveDelay = 0; // Delay before resolving hostname via DNS
TResolveReq * ResolveReq = NULL; // DNS resolve request TResolveReq * ResolveReq = NULL; // DNS resolve request
bool Resolving = false; // Busy resolving address
// Serial Port config // Serial Port config
bool SerialConfig = false; bool SerialConfig = false;
@@ -266,13 +264,13 @@ public:
bool SetOutBuffer( THandle * Handle, int OutBufSize ); bool SetOutBuffer( THandle * Handle, int OutBufSize );
// FD Operations // FD Operations
virtual int Open( THandle * Handle, bool DelayResolve = false ) = 0; virtual int Open( THandle * Handle ) = 0;
virtual bool Close( THandle * Handle, bool QuickReopen ); virtual bool Close( THandle * Handle, bool QuickReopen );
virtual bool Read( THandle * Handle ); virtual bool Read( THandle * Handle );
virtual bool Write( THandle * Handle ); virtual bool Write( THandle * Handle );
// FD operations // FD operations
inline virtual int Open( const char * HandleName, bool DelayResolve = false ) { return (Open( GetHandle( HandleName ), DelayResolve)); }; inline virtual int Open( const char * HandleName ) { return (Open( GetHandle( HandleName ))); };
inline virtual bool Close( const char * HandleName, bool QuickReopen ) { return (Close( GetHandle( HandleName ), QuickReopen )); }; inline virtual bool Close( const char * HandleName, bool QuickReopen ) { return (Close( GetHandle( HandleName ), QuickReopen )); };
inline virtual bool Close( int FD, bool QuickReopen ) { return (Close( GetHandle( FD ), QuickReopen )); }; inline virtual bool Close( int FD, bool QuickReopen ) { return (Close( GetHandle( FD ), QuickReopen )); };
@@ -320,19 +318,19 @@ protected:
THandle * OpenUNIXremoteSocket( THandle * Handle ); THandle * OpenUNIXremoteSocket( THandle * Handle );
// Socket Operations // Socket Operations
bool ResolveAddress( THandle * Handle, bool DelayResolve ); bool ResolveAddress( THandle * Handle );
bool HandleResolve( THandle * Handle ); bool HandleResolve( THandle * Handle );
bool DestroyResolveReq( THandle * Handle, bool DestroyResult ); bool DestroyResolveReq( THandle * Handle, bool DestroyResult );
// Managing File Handles // Managing File Handles
virtual bool DestroyHandle( THandle * Handle ); virtual bool DestroyHandle( THandle * Handle );
THandle * OpenUDPserverSocket( THandle * Handle, bool DelayResolve ); THandle * OpenUDPserverSocket( THandle * Handle );
THandle * OpenUDPremoteSocket( THandle * Handle, char * RemoteAddr, char * RemotePort ); THandle * OpenUDPremoteSocket( THandle * Handle, char * RemoteAddr, char * RemotePort );
THandle * OpenUDPclientSocket( THandle * Handle, bool DelayResolve ); THandle * OpenUDPclientSocket( THandle * Handle );
THandle * OpenTCPserverSocket( THandle * Handle, bool DelayResolve ); THandle * OpenTCPserverSocket( THandle * Handle );
THandle * OpenTCPremoteSocket( THandle * Handle ); THandle * OpenTCPremoteSocket( THandle * Handle );
THandle * OpenTCPclientSocket( THandle * Handle, bool DelayResolve ); THandle * OpenTCPclientSocket( THandle * Handle );
// Mutual Operations // Mutual Operations
int ReadFromUDP( THandle * Handle, char * RemoteAddr, char * RemotePort, char * Data, int MaxLen ); int ReadFromUDP( THandle * Handle, char * RemoteAddr, char * RemotePort, char * Data, int MaxLen );
@@ -357,10 +355,10 @@ public:
bool SetLinePrinterHandle( THandle * Handle, const char * FileName ); bool SetLinePrinterHandle( THandle * Handle, const char * FileName );
bool SetForkPipeHandle( THandle * Handle, const char * ExecPath ); bool SetForkPipeHandle( THandle * Handle, const char * ExecPath );
bool SetUnixHandle( THandle * Handle, EConnectType Type, const char * FileName, short Queue ); bool SetUnixHandle( THandle * Handle, EConnectType Type, const char * FileName, short Queue );
bool SetSocketHandle( THandle * Handle, EConnectType Type, const char * HostName, const char * PortName, short Queue, long ResolveDelay ); bool SetSocketHandle( THandle * Handle, EConnectType Type, const char * HostName, const char * PortName, short Queue );
// FD Operations // FD Operations
virtual int Open( THandle * Handle, bool DelayResolve = false ); virtual int Open( THandle * Handle );
virtual bool Close( THandle * Handle, bool QuickReopen ); virtual bool Close( THandle * Handle, bool QuickReopen );
virtual bool Read( THandle * Handle ); virtual bool Read( THandle * Handle );
virtual bool Write( THandle * Handle ); virtual bool Write( THandle * Handle );