Important Update:

- Improve parameter checking before function execution
- Rename functions:
  Get->Peek, ReadFD->ReadFromFD, WriteFD->WriteToFD
- Add StartPos param to Peek() & FindChar()
- Add ClearChar param for GetChar()
- Add default values for Position and Lengths
  Get, Set, Clear, Push, Peek, GetChar, FindChar

BufferCore.cpp

@@ -48,11 +48,15 @@ CBuffer::~CBuffer()
 //---------------------------------------------------------------------------
 
 // Over write existing buffer with new data
-int CBuffer::Set( char * Data, int Len )
+int CBuffer::Set( const char * Data, int Len )
 {
     // Validate data
-    if (!Data || !Len)
+    if (!Data || !Len) {
         return 0;
+    }
+    else if (Len == -1) {
+        Len = strlen( Data );
+    }
 
     if (Len <= BufSize) {
         memcpy( Buffer, Data, Len );
@@ -71,9 +75,10 @@ int CBuffer::Set( char * Data, int Len )
 //---------------------------------------------------------------------------
 
 // Return "stitched" buffer data in temporary buffer
-int CBuffer::Get( char ** Data, int MaxLen )
+int CBuffer::Peek( char ** Data, int PeekPos, int MaxLen )
 {
     int     BytesReturned   = 0;
+    int     StartPos        = 0;
 
     // Check if any data
     if (!BufLen || !MaxLen) {
@@ -81,19 +86,31 @@ int CBuffer::Get( char ** Data, int MaxLen )
         return 0;
     }
 
+    // Validate start position
+    if (PeekPos >= BufLen) {
+        *Data = NULL;
+        return 0;
+    }
+    else if (BufStart + StartPos < BufSize) {
+        StartPos = BufStart + PeekPos;
+    }
+    else {
+        StartPos = BufStart + PeekPos - BufSize;
+    }
+
     // Validate MaxLen
     if ((MaxLen == -1) || (MaxLen > BufSize)) {
         MaxLen = BufSize;
     }
-    BytesReturned = (MaxLen > BufLen)? BufLen : MaxLen;
+    BytesReturned = (MaxLen > BufLen - PeekPos)? (BufLen - PeekPos) : MaxLen;
 
     // Copy Data from Buffer
-    if (BufStart + BytesReturned < BufSize) {
+    if (StartPos + BytesReturned <= BufSize) {
-        memcpy( OutBuffer, &Buffer[BufStart], BytesReturned );
+        memcpy( OutBuffer, &Buffer[StartPos], BytesReturned );
     }
     else {
-        memcpy( OutBuffer, &Buffer[BufStart], BufSize-BufStart );  // Copy from end of buffer
+        memcpy( OutBuffer, &Buffer[StartPos], BufSize-StartPos );                           // Copy from end of buffer
-        memcpy( &OutBuffer[BufSize-BufStart], Buffer, (BytesReturned-(BufSize-BufStart)) );    // Copy rollover from start of buffer
+        memcpy( &OutBuffer[BufSize-StartPos], Buffer, (BytesReturned-(BufSize-StartPos)) ); // Copy rollover from start of buffer
     }
     OutBuffer[BytesReturned] = 0;
 
@@ -108,7 +125,12 @@ int CBuffer::Clear( int ClearLen )
     int BytesCleared;
 
     // Validate ClearLen
-    BytesCleared = (ClearLen > BufSize)? BufSize : ClearLen;
+    if (ClearLen == -1) {
+        BytesCleared = BufLen;
+    }
+    else {
+        BytesCleared = (ClearLen > BufLen)? BufLen : ClearLen;
+    }
 
     // Update Buffer pointers
     if (BufStart + BytesCleared < BufSize) {
@@ -139,17 +161,20 @@ int CBuffer::Reset()
 
 // Add bytes to end of buffer
 // Return "stitched" buffer data in temporary buffer
-int CBuffer::Push( char * Data, int Len )
+int CBuffer::Push( const char * Data, int Len )
 {
     int     BytesPushed       = 0;
     int     TotalPushed       = 0;
     int     BufRemain       = 0;
     int     DataRemain      = Len;
 
-    // Check if buffer created
+    // Validate Buffer and Len
-    if (!BufSize) {
+    if (!BufSize || !Len) {
         return 0;
     }
+    else if (Len == -1) {
+        Len = strlen( Data );
+    }
 
     // Read Data into buffer
     while (TotalPushed < Len)
@@ -188,7 +213,7 @@ int CBuffer::Pop( char ** Data, int MaxLen )
     int     BytesWritten    = 0;
 
     // Read data
-    BytesWritten = Get( Data, MaxLen );
+    BytesWritten = Peek( Data, MaxLen );
 
     // Clear bytes
     Clear( BytesWritten );
@@ -199,7 +224,7 @@ int CBuffer::Pop( char ** Data, int MaxLen )
 //---------------------------------------------------------------------------
 
 // Read File descriptor directly into rolling buffer
-int CBuffer::ReadFD( int Handle, int MaxRead )
+int CBuffer::ReadFromFD( int Handle, int MaxRead )
 {
     int     BytesRead       = 0;
     int     TotalRead       = 0;
@@ -242,12 +267,13 @@ int CBuffer::ReadFD( int Handle, int MaxRead )
 //---------------------------------------------------------------------------
 
 // Write given number of bytes directly from buffer to File descriptor
-int CBuffer::WriteFD( int Handle, int MaxLen )
+int CBuffer::WriteToFD( int Handle, int MaxLen )
 {
     int     BytesWritten    = 0;
     int     TotalWritten    = 0;
     int     BufRemain       = 0;
     int     DataRemain      = 0;
+    int     ReadPos         = 0;
 
     // Check if buffer created
     if (!BufSize) {
@@ -255,12 +281,13 @@ int CBuffer::WriteFD( int Handle, int MaxLen )
     }
 
     // Read Data into buffer
+    ReadPos = BufStart;
     DataRemain = (MaxLen == -1)? BufLen : MaxLen;
     while ((TotalWritten < MaxLen) && (BufLen > 0))
     {
         // Read from file descriptor
-        BufRemain = BufSize - BufStart;
+        BufRemain = BufSize - ReadPos;
-        BytesWritten = write( Handle, &Buffer[BufStart], ((BufRemain > DataRemain)? DataRemain : BufRemain) );
+        BytesWritten = write( Handle, &Buffer[ReadPos], ((BufRemain > DataRemain)? DataRemain : BufRemain) );
         if (BytesWritten <= 0)
             break;
 
@@ -270,10 +297,9 @@ int CBuffer::WriteFD( int Handle, int MaxLen )
 
         // Update Buffer Pointers
         BufLen -= BytesWritten;
-        BufStart += BytesWritten;
+        ReadPos += BytesWritten;
-        if (BufStart >= BufSize) {
+        if (ReadPos >= BufSize) {
-            // Rolling over end of buffer, start at beginning
+            ReadPos = 0;   // Rolling over end of buffer, start at beginning
-            BufStart = 0;
         }
     }
 
@@ -282,48 +308,78 @@ int CBuffer::WriteFD( int Handle, int MaxLen )
 //---------------------------------------------------------------------------
 
 // Return specific character for current rolling data
-char CBuffer::GetChar( int Pos )
+char CBuffer::PeekChar( int Pos, bool ClearChar )
 {
+    char    CharValue   = 0;
+
+    // Validate buffer and Pos
     if (!BufLen) {
         return 0;
     }
-    else if (BufStart + Pos < BufSize) {
+
-        return Buffer[ BufStart+Pos ];
+    // Get char
+    if (BufStart + Pos < BufSize) {
+        CharValue = Buffer[ BufStart+Pos ];
     }
     else {
-        return Buffer[ BufStart+Pos-BufSize ];
+        CharValue = Buffer[ BufStart+Pos-BufSize ];
     }
+
+    // Clear Char
+    if (ClearChar && (Pos == 0)) {
+        BufStart++;
+        BufLen--;
+    }
+
+    // Return char
+    return CharValue;
 }
 //---------------------------------------------------------------------------
 
-// Look for first occureance of character in buffer
+// Look for first occurrence of character in buffer
-bool CBuffer::FindChar( char SearchChar, int &Pos )
+bool CBuffer::FindChar( char SearchChar, int &FoundPos, int StartPos )
 {
     char *  CheckPos;
     char *  Limit;
 
     // Check if buffer exists
     if (!BufLen) {
+        FoundPos = -1;
         return false;
     }
 
+    // Validate start Pos
+    if (StartPos >= BufLen) {
+        FoundPos = -1;
+        return false;
+    }
+
+    // Get Search start point
+    if (BufStart + StartPos < BufSize) {
+        CheckPos = &Buffer[ BufStart+StartPos ];
+    } else {
+        CheckPos = &Buffer[ (BufStart+StartPos)-BufSize ];
+    }
+
     // Search for char
-    Pos = 0;
+    FoundPos = StartPos;
-    CheckPos = &Buffer[BufStart];
     Limit = &Buffer[BufSize-1];
-    while (Pos < BufLen)
+    while (FoundPos < BufLen)
     {
         if (*CheckPos == SearchChar)
             return true;
 
         // Next char
-        Pos++;
+        FoundPos++;
         if (CheckPos == Limit) {
             CheckPos = Buffer;   // Roll-over, Start at beginning of buffer
         } else {
             CheckPos++;
         }
     }
+
+    // Not Found
+    FoundPos = -1;
     return false;
 }
 //---------------------------------------------------------------------------

BufferCore.h

@@ -38,21 +38,21 @@ public:
 
     // Direct Operations
     int Reset();
-    int Set( char * Data, int Len );
+    int Set( const char * Data, int Len = -1 );
-    int Get( char ** Data, int MaxLen = -1 );
+    int Peek( char ** Data, int PeekPos = 0, int MaxLen = -1 );
-    int Clear( int ClearLen );
+    int Clear( int ClearLen = -1 );
 
     // FiFo operations
-    int Push( char * Data, int Len );
+    int Push( const char * Data, int Len = -1 );
     int Pop( char ** Data, int MaxLen = -1 );
 
     // File operations
-    int ReadFD( int Handle, int MaxRead = -1 );
+    int ReadFromFD( int Handle, int MaxRead = -1 );
-    int WriteFD( int Handle, int MaxWrite = -1 );
+    int WriteToFD( int Handle, int MaxWrite = -1 );
 
     // Character Operations
-    char GetChar( int Pos );
+    char PeekChar( int Pos = 0, bool ClearChar = false );
-    bool FindChar( char SearchChar, int &Pos );
+    bool FindChar( char SearchChar, int &FoundPos, int StartPos = 0 );
 
     // Miscellaneous
     int Size()          { return BufSize; };

PortCore.cpp

@@ -59,10 +59,12 @@ CPortCore::~CPortCore()
     if (Name) {
         free( Name );
     }
-
     if (Buffer) {
         delete Buffer;
     }
+    if (InMarkers) {
+        free( InMarkers );
+    }
 }
 //---------------------------------------------------------------------------
 
@@ -122,6 +124,7 @@ bool CPortCore::InputConfig( const long InputTimeout, const char * InputMarkers,
     InTimeout = InputTimeout;
     if (InputMarkerLen && InputMarkers) {
         InMarkerLen = InputMarkerLen;
+        if (InMarkers) { free( InMarkers ); }
         InMarkers = (char *)malloc( InMarkerLen );
         memcpy( InMarkers, InputMarkers, InMarkerLen );
     }
@@ -285,7 +288,7 @@ bool CPortCore::Read( const int MaxRead )
     int     BytesRead   = 0;
 
     // Read File directly into buffer
-    if (!(BytesRead = Buffer->ReadFD( Handle )))
+    if (!(BytesRead = Buffer->ReadFromFD( Handle )))
         return false;
 
     // Process Buffer
@@ -313,11 +316,11 @@ bool CPortCore::ProcessBuffer( bool Force )
     if (Force)
     {
         // Show Packet
-        Len = Buffer->Get( &Data );
+        Len = Buffer->Peek( &Data );
         ShowOutput( "Port In", OUT_NORMAL, Data, Len );
 
         // Write buffer to Port
-        Buffer->WriteFD( OutputHandle, Len );
+        Buffer->WriteToFD( OutputHandle, Len );
     }
     else
     {
@@ -325,13 +328,16 @@ bool CPortCore::ProcessBuffer( bool Force )
         while (Buffer->FindChar( '\n', Pos ))
         {
             // Show Packet
-            Len = Buffer->Get( &Data, Pos+1 );
+            Len = Buffer->Peek( &Data, Pos+1 );
             ShowOutput( "Port In", OUT_NORMAL, Data, Len );
 
             // Write buffer to Port
-            Buffer->WriteFD( OutputHandle, Len );
+            Buffer->WriteToFD( OutputHandle, Len );
         }
     }
+    // Clear processed bytes from buffer
+    Buffer->Clear( Len );
+
     return true;
 }
 //---------------------------------------------------------------------------