TCP Socket Server

This code has been declared by its author to be Public Domain code.

TCP Socket Server by CoderLaureate

2005

TCPSocketServer

I thought I'd throw my hat into the "TCPSocket Ring". This is an OOP
approach to creating a TCPSocket server. Callbacks are used for extensibility.
You can create functions to handle events and add whatever functionality you
like. You can create many different servers listening to different ports, and
assign different functionality to each server. The benefit of doing this is
that each server is running withing the same process, and therefor causes
less overhead drain on your system resources.

The Event Callback handles are:

NewConnectionCallback

Triggered whenever a new client connects.
The callback function takes one parameter of type TCPSocketConnection.
Your callback function can access the various fields and methods of
the connection. A link back to the connection's server is also provided
to give you access to the various fields and methods of the server.

LostConnectionCallback

Triggered whenever a client disconnects from the server.
This callback also takes a TCPSocketConnection. After the server calls
the callback function it removes the connection from it's collection.

MsgRcvdCallback

Triggered whenever a client sends a message to the server.
The callback function takes one parameter of type TCPSocketConnection.
Your callback function can access the message in the connection object's
"Buffer" field. The field is a string, but can easily be converted to
an array of bytes for whatever processing you need to do. This
function is where you would add any "Intelligence" to your server, ie,
processing commands, etc.

Methods

Broadcast(Message:String, [conn:TCPSocketConnection = Null])

If a TCPSocketConnection is provided the server only broadcasts the message
to that specific connection. Otherwise the server will broadcast the message
to all of it's connections.

Listen()

Updates the server connections and triggers events as they occure.

TCPSocketConnections

A TCPSocketConnection is the "pipeline" through which the server communicates
with the clients that are connected. Each server object has it's own
collection of TCPSocketConnection objects.

Methods

Recieves messages from your program and tells the server to trigger the
MsgRcvdCallback event. This works in a "Non-Blocking" fashion, so as not
to hold up your application while waiting for input. You're program
causes the server to trigger this event by sending a "Stop Sequence". The
server defaults this stop sequence to a Carriange Return/Line Feed {~r~n}.
But you can change it to whatever you want by setting the server's "StopSeq"
field.

Rem

	Title:   TCPSocket Server
	
	Author:  Jim Pishlo  (CoderLaureate)
	            (J9T@Jimmy9Toes.com)
	
End Rem

Strict

Type TCPSocketServer
	
	'Properties
	Field MyPort:Int = 3849
	Field MySocket:TSocket
	Field MyStream:TSocketStream
	Field Connections:TList = New TList
	Field StopSeq:String = "~r~n"
	
	'Callback handles
	Field NewConnectionCallback(Conn:TCPSocketConnection)
	Field MsgRcvdCallback(Conn:TCPSocketConnection)
	Field LostConnectionCallback(Conn:TCPSocketConnection)
	
	'Constructor (for lack of a better word)
	Function Create:TCPSocketServer(_Port:Int = 3849)
		Local s:TCPSocketServer = New TCPSocketServer
		s.MyPort = _Port
		s.MySocket = CreateTCPSocket()
		s.MyStream = CreateSocketStream(s.MySocket)
		s.MySocket.Bind(_Port)
		s.MySocket.Listen(0)
		Return s
	End Function
	
	'The main method.
	'Monitors connections and triggers events.
	Method Listen()
		Local newConn:TSocket = MySocket.Accept(0)
		If newConn <> Null Then
			Local conn:TCPSocketConnection = TCPSocketConnection.Create(Self,newConn)
			'Add the new connection to the collection
			Connections.AddLast(conn)
			'If a callback has been assigned call it.
			If NewConnectionCallback <> Null Then
				NewConnectionCallback(conn)	'Pass a refernce to the new connection
			End If
		End If
		
		'Clean up closed connections
		For Local c:TCPSocketConnection = EachIn Connections
			If Not c.MySocket.Connected() Then
				If LostConnectionCallback <> Null Then
					LostConnectionCallback(c)
				End If
				Connections.Remove(c)	'Remove connection from collection
			End If
		Next
		
		'Receive Data from connections
		'Trigger callback if neccesary
		For Local c:TCPSocketConnection = EachIn Connections
			If c.MySocket.Connected() Then
				Local t:String = c.Receive()
				If t <> "" Then
					If MsgRcvdCallback <> Null Then
						MsgRcvdCallback(c)
						c.Buffer = ""
					End If
				End If
			End If
		Next 
	End Method
	
	Method Broadcast(Message:String, Conn:TCPSocketConnection = Null)
		If Conn <> Null Then
			Conn.Send(Message)
		Else
			Local c:TCPSocketConnection
			For c = EachIn Connections
				If c.MySocket.Connected() Then
					c.Send(Message)
				End If
			Next
		End If	
	End Method
	
End Type

Type TCPSocketConnection
	Field MyID:String
	Field MyServer:TCPSocketServer
	Field MySocket:TSocket
	Field MyStream:TSocketStream
	Field Buffer:String = ""
	Field StopSeq:String
	
	Function Create:TCPSocketConnection(s:TCPSocketServer, NewSocket:TSocket)
		Local c:TCPSocketConnection = New TCPSocketConnection
		c.MyServer = s
		c.MySocket = NewSocket
		c.MyStream = CreateSocketStream(c.MySocket)
		c.StopSeq = c.MyServer.StopSeq
		c.MyID = DottedIP(c.MySocket.RemoteIP())
		Return c
	End Function

	Method Send(Text:String)
		MySTream.WriteString(Text)
	End Method

	Method Receive:String()
		Local nBytes:Int = MySocket.ReadAvail()
		Local s:String = StopSeq
		If nBytes Then
			Local in:String = ReadString(MyStream,nBytes)
			Buffer:+ in
			If Buffer.Length >= s.Length And Right$(Buffer,s.Length) = s Then
				Local t:String = Buffer.Replace(s,"") 'Strip out the stop sequence
				Return t
			End If
		End If
	End Method
	
End Type


Function CreateTCPSocketServer:TCPSocketServer(_Port:Int = 3849)
	Return TCPSocketServer.Create(_Port)
End Function





'Test Code:  This is a simple Telnet Chat Server.  Run this program, then
'            open up a command prompt and type:
'  
'				Telnet localhost 3849
'
'			 You can telnet into this server from anywhere in the world
'            and do *very basic* text chatting.  To log in from another
'            computer, type:
'
'				Telnet {host computer ip} 3849
'
'			 This is just a sample program to show you what you can do
'			 with the TCPSocketServer object.
'----------------------------------------------------------------------

'Create callback functions for interaction with the TCPSocketServer Object.

'Function to handle data recieved by server
'------------------------------------------
Function TextHandler(C:TCPSocketConnection)
	C.MyServer.BroadCast(C.MyID + ": " + C.Buffer)
End Function

'Greet new users and assign an ID
'--------------------------------
Function Greet(C:TCPSocketConnection)
	C.MyID = "User [" + MilliSecs() + "]"
	C.MyServer.BroadCast("Welcome!~r~n",C)
	C.MyServer.BroadCast(C.MyID + " has entered the room.~r~n")	
End Function

'Alert other users when a user leaves
'------------------------------------
Function LostConnection(C:TCPSocketConnection)
	C.MyServer.BroadCast("~r~n" + C.MyID + " has left the room.~r~n~r~n")
End Function

'Create an Instance of the TCPSocketServer Class
'-------------------------------------------------
Global Server:TCPSocketServer = CreateTCPSocketServer()

'Assign Function Pointers to Server's callback handles
'-----------------------------------------------------
Server.MsgRcvdCallback = TextHandler
Server.NewConnectionCallback = Greet
Server.LostConnectionCallback = LostConnection


'The Main Loop
'--------------
While Not KeyHit(KEY_ESCAPE)
	Server.Listen()		'That's it!
Wend

Comments

kronholm

2006

Very nice example :) I wish I had found it sooner though , as I spent the last two nights figuring out how to do exactly what you did here :)

kronholm

2006

Sorry double post

CoderLaureate

2006

Thanks for the comment!

Chroma

2007

Is this true multi-threading?

Chroma

2007

Here's an optimisation:

In the Listen method you iterate through the connections twice. Once to see if the users are connected and once to get the messages. Here's some pseudo code to speed it up a bit.

If Not user.Connected()
     userList.Remove(user)
Else
     user.CheckForMsg
Endif

That way you only go through the connections once.

Koriolis

2007

Nice.
I've written an HTTP server in BlitzMax, and was precisely going to add some kind of productor/consumer pattern.
More precisely I wanted to implement the Proactor design pattern and reimplement the server with.
I may as well use your code.

I have some critics though: your code is not correct in that you just read as much data as there is until now (ReadString) and pass that to the callback.
But what if the client sends 2 small chunks of data in a row? You're likely to receive it as a whole. This ends up in the handler to get 2 messages in one single call. Worse, you may receive the fist part plus half of the second part, and never detect the terminating CR+LF. Or more simply you may also receive half of the first message. Same problem.

Also you never give any explicit way of deciding when to stop reading and return the result to the handler (MsgRcvdCallback), it is always the CRLF delimitor that is used.

I propose a fairly simple modification:

Add a method to explicitely register interest in a read event. You should be able to specify how to determine enough data has been read. I personnaly see good uses in the two following criterias:
- a specified sequence of bytes has been read (example: CR+LF when reading HTTP header fields)
- a specified amount of bytes has been read, in which case return no more than that amount of data to the handler (example : reading the body of an http POST request).

Finally, add a "timeout" parameter (and a dedicated handler callback) to stop the wait after a given amount of time has passed without getting all the expected data (and pass to the timeout callback the data read until now).

These parameters should be set by connection, not by server.

This would make the whole pretty much perfect.

Though I'd make one final modification: store the read data as raw bytes (and provide a method returning the same data as a string). This would improve efficiency for the cases where the ahndler will act on raw bytes anyway (removes 2 unneeded conversions).

rdodson41

2007

Is this true multi-threading?

Unfortunately no, but CoderLaureate did a nice job of making it work so as to seem that way, since all you have to call is the Listen() method.

Koriolis

2007

Finally I implemented the corrections I mentioned:

Rem

	Title:   TcpServer
	
	Authors:  	Jim Pishlo  (CoderLaureate)		:	Initial version
	            (J9T@...)
	
				Régis JEAN-GILLES (Koriolis)	:	Corrections and enhancements
				(koriolis.fx@...)	
	
	TODO:	- handle timeout
			- ensure that we treat the remaining data when a connection is lost
			- add flush method in connection
			- register each server in a global list, and add a static method ListenAll that calls listen on each server
			- encapsulate somewhere the following idiom (used for preserving both the cpu usage and the speed)
				Local idleCount% = 0
				Local t% = MilliSecs()
				Repeat
					Server.Listen()		
			
					Local t_% = MilliSecs()
					If (t-t_) = 0 Then
						idleCount :+ 1				
					Else
						t = t_
						idleCount = 0
					EndIf
					
					If idleCount > 10 Then
						Delay(1)
					EndIf
				Forever
End Rem

Strict

Type TTcpServer
	
	'Properties
	Field Port_:Int
	Field Socket_:TSocket
	Field SocketStream_:TSocketStream
	Field Connections:TList = New TList
		
	Field Extra:Object	' Extra field that can be used to store any additional data
						' Handy to associate data to the server without extending the type

	' Pointer to connection factory function
	'Field CreateConnection:TTcpConnection(s:TTcpServer, NewSocket:TSocket) = TStdTcpConnection.Create
	Field CreateConnection:TTcpConnection(s:TTcpServer, NewSocket:TSocket) = CreateStdTcpConnection
	
	'Constructor (for lack of a better word)
	'Returns Null if the port cannot be bound
	Function Create:TTcpServer(Port:Int, CreateConnection:TTcpConnection(s:TTcpServer, NewSocket:TSocket) = Null)
		Local s:TTcpServer = New TTcpServer
		s.Port_ = Port
		s.Socket_ = CreateTCPSocket()
		If Not s.Socket_.Bind(Port) Then			
			Return Null
		EndIf
		s.Socket_.Listen(0)
		s.SocketStream_ = CreateSocketStream(s.Socket_)
		s.CreateConnection = CreateConnection
		Return s
	End Function
	
	'The main method.
	'Monitors connections and triggers events.
	Method Listen()
		Local clientSocket:TSocket = Socket_.Accept(0)
		If clientSocket <> Null Then
			Local conn:TTcpConnection = CreateConnection(Self, clientSocket)
			'Add the new connection to the collection
			Connections.AddLast(conn)
			'Call the "new connection" event handler
			conn.OnNewConnection()
		End If
		
		'Receive Data from connections
		'Trigger callback if neccesary
		For Local c:TTcpConnection = EachIn Connections ' TODO: use prioritizer
			If c.Socket.Connected() Then
				If c.Receive_() Then
					c.OnMsgReceived()
				End If
			End If
		Next 
		
		'Clean up closed connections
		For Local c:TTcpConnection = EachIn Connections
			If Not c.Socket.Connected() Then
				c.OnConnectionLost()
				Connections.Remove(c)	'Remove connection from collection
			End If
		Next
	End Method
	
	Method BroadcastString(Message:String, ExcludedConn:TTcpConnection = Null)
		For Local c:TTcpConnection = EachIn Connections
			If c <> ExcludedConn Then
				If c.Socket.Connected() Then
					c.SendString(Message)
				End If
			EndIf
		Next
	End Method
	
	Method BroadcastBytes(buf:Byte Ptr, count:Int, ExcludedConn:TTcpConnection = Null)
		For Local c:TTcpConnection = EachIn Connections
			If c <> ExcludedConn Then
				If c.Socket.Connected() Then
					c.SendBytes(buf, count)
				End If
			EndIf
		Next
	End Method
	
	Method Close()
		CloseStream(SocketStream_)
		For Local conn:TTcpConnection = EachIn Connections
			conn.OnServerShutdown()
			conn.Close()
		Next
	End Method
	
End Type


?Debug
' Stream wrapper that only allows writing.
' Used in debug mode only to easily detect if a TTcpConnection 
' object tries to read directly from the socket stream, which may block and is forbidden.
' In Release mode, direct access to the underlying stream is done, to avoid the extra indirection.
Type TTcpConnection_WriteOnlyStreamWrapper Extends TStream
	Field stream_:TStream
	
	Function Create:TTcpConnection_WriteOnlyStreamWrapper (stream:TStream )
		Local s:TTcpConnection_WriteOnlyStreamWrapper = New TTcpConnection_WriteOnlyStreamWrapper
		s.SetStream(stream)
		Return s
	End Function

	Method SetStream( stream:TStream )
		stream_=stream
	End Method	

	Method Eof()
		Return stream_.Eof()
	End Method

	Method Pos()
		Return stream_.Pos()
	End Method

	Method Size()
		Return stream_.Size()
	End Method
	
	Method Seek( pos )
		Return stream_.Seek( pos )
	End Method

	Method Flush()
		stream_.Flush
	End Method

	Method Close()
		stream_.Close
	End Method

	Method Write( buf:Byte Ptr,count )
		Return stream_.Write( buf,count )
	End Method
	
	Method WriteByte( n )
		stream_.WriteByte n
	End Method
	
	Method WriteShort( n )
		stream_.WriteShort n
	End Method
	
	Method WriteInt( n )
		stream_.WriteInt n
	End Method
	
	Method WriteFloat( n:Float )
		stream_.WriteFloat n
	End Method
	
	Method WriteDouble( n:Double )
		stream_.WriteDouble n
	End Method
	
	Method WriteLine( t$ )
		Return stream_.WriteLine( t )
	End Method
	
	Method WriteString( t$ )
		stream_.WriteString t
	End Method
	
	Method WriteObject( obj:Object )
		stream_.WriteObject obj
	End Method
	
End Type	
?

Rem
Base TCP connection type.
Is abstract and thus must be inherited.
The inherited type must implement the abstract method, as well as setup 'Socket', 'Server' and 'OutStream'

Reading must always be done implicitely by handling the dedicated event (OnMsgReceived).
This ensures a non blocking read.

Writing can be done either by calling SendString or SendBytes, or by accessing the writing stream.

EndRem
Type TTcpConnection Abstract
	Field Socket:TSocket
	Field Server:TTcpServer
	Field OutStream:TStream		' Stream for the connection, to use for writing only
	
	Method Receive_:Int() Abstract	
	
	Method OnNewConnection() Abstract
	Method OnMsgReceived() Abstract
	Method OnReadTimeout() Abstract
	Method OnConnectionLost() Abstract
	Method OnServerShutdown() Abstract
	
	Method GetBytesMsg:Byte Ptr() Abstract
	Method GetBytesMsgLen:Int() Abstract

	Method Close() Abstract

	' Just a Shortcut
	Method SendString(Text:String)
		Return OutStream.WriteString(Text)
	End Method
	
	' Just a Shortcut
	Method SendBytes(Buf:Byte Ptr, count:Int)
		Return OutStream.WriteBytes(buf, count)
	End Method
	
	Method GetStringMsg:String()
		Return String.FromBytes(GetBytesMsg(), GetBytesMsgLen())
	End Method
	
	Method BroadcastString(Message:String, bExcludeSelf% = True)
		Local ExcludedConn:TTcpConnection = Null
		If bExcludeSelf Then
			ExcludedConn = Self
		EndIf
		Return Server.BroadcastString(Message, ExcludedConn)
	End Method
	
	Method BroadcastBytes(buf:Byte Ptr, count:Int, bExcludeSelf% = True) Final
		Local ExcludedConn:TTcpConnection = Null
		If bExcludeSelf Then
			ExcludedConn = Self
		EndIf
		Return Server.BroadcastBytes(buf, count, ExcludedConn)
	End Method
	
End Type

Rem
Default implementation of TCP connection:
- Forwards the events to user defined callbacks
- Implements two ways of determining how to slice the input stream in distinct messages:
	- By finding a stop sequence (defined by StopSeq).
	  the data passed to the OnMsgRecevied method
	- By reading a specified amount of data	 (defined by StopSize)
	
	The first criteria is chosen first: if a stop sequence is specified, the StopSize is
	ignored.

	The stop sequence and data size can be modified at will, even while executing a handler.
	This makes it possible to change the criteria as you go. 
	For example in a http server you'd first use a stop sequence for the header, and then
	a stop size for the body.
		
- Can be used as is by setting the functions pointers (NewConnectionCallback etc) to 
  the appropriate user-defined function.
- Can also be extended to override the "On*" methods and implement the behaviour right 
  into the type. The default implementation of these methods is to forward the call to 
  the functions pointed by the user specified function pointers (NewConnectionCallback etc)
EndRem
Function CreateStdTcpConnection:TStdTcpConnection(s:TTcpServer, newSocket:TSocket)
	Return (New TStdTcpConnection).Init(s, newSocket)
End Function

Type TStdTcpConnection Extends TTcpConnection
	' [Private]
	Field SocketStream_:TSocketStream
	Field Buffer_:Byte[] = New Byte[DEFAULT_BUFFER_SIZE]
	Field BufferIndex_:Int = 0				' Index into 'Buffer' where next incoming data is going to be written
	Field UnconsumedBytesStart_:Int = 0
	Field UnconsumedBytesLength_:Int = 0
	Field ScanStartPos% = 0 ' Position where to start scanning for stop seq (ie past the bytes already scanned)
	Field MsgLen_:Int = 0
	

	' [Public]
	Const DEFAULT_BUFFER_SIZE% = 4096
	Const LOG2:Double = 0.69314718055994529:Double
	
	Field Extra:Object	' Extra field that can be used to store any additional data
						' Handy to associate data to the connecion without extend the type

	Field CRLF_StopSeq:Byte[] = [Byte(Asc("~r")), Byte(Asc("~n"))]
	
	Field StopSeq:Byte[] = CRLF_StopSeq
	Field StopSize:Int = 0
	
	'Callbacks
	Field NewConnectionCallback(Conn:TStdTcpConnection)
	Field MsgRcvdCallback(Conn:TStdTcpConnection)
	Field ReadTimeoutCallback(Conn:TStdTcpConnection)
	Field ConnectionLostCallback(Conn:TStdTcpConnection)
	Field ServerShutdownCallback(Conn:TStdTcpConnection)
	
	Method OnNewConnection()
		If NewConnectionCallback Then
			Return NewConnectionCallback(Self)
		End If
	End Method
	
	Method OnMsgReceived()
		If MsgRcvdCallback Then
			'DebugStop'!!!
			Return MsgRcvdCallback(Self)
		End If
	End Method
	
	Method OnReadTimeout()
		If ReadTimeoutCallback Then
			Return ReadTimeoutCallback(Self)
		End If
	End Method
	
	Method OnConnectionLost()
		If ConnectionLostCallback Then
			Return ConnectionLostCallback(Self)
		End If
	End Method
	
	Method OnServerShutdown()
		If ServerShutdownCallback Then
			Return ServerShutdownCallback(Self)
		End If
	End Method
	
	Method GetBytesMsg:Byte Ptr()
		Return Buffer_
	End Method
	
	Method GetBytesMsgLen:Int()
		Return MsgLen_
	End Method

	Method Init:TStdTcpConnection(s:TTcpServer, NewSocket:TSocket)
		Server = s
		Socket = NewSocket
		SocketStream_ = CreateSocketStream(Socket)
		OutStream = SocketStream_
?Debug
		' In debug mode, wrap it with TTcpConnection_WriteOnlyStreamWrapper to ensure we don't try to
		' read from OutStream.
		OutStream = TTcpConnection_WriteOnlyStreamWrapper.Create(OutStream)
?
		Extra = DottedIP(Socket.RemoteIP()) ' Init default id
		Return Self
	End Method

	'Function Create:TStdTcpConnection(s:TTcpServer, newSocket:TSocket)
	'	Return (New TStdTcpConnection).Init(s, newSocket)
	'End Function

'	Method SendString(Text:String)
'		SocketStream_.WriteString(Text)
'	End Method
'
'	Method SendBytes(Buf:Byte Ptr, count:Int)
'		SocketStream_.WriteBytes(buf, count)
'	End Method

'	Method GetWriteStream:Stream()
'		Return SocketStream
'	End Method

	Method Receive_:Int()
		If StopSeq.Length > 0 Then
			Return ReceiveByStopSeq ()
		Else
			Return ReceiveBySize()
		EndIf
	End Method
	
	Method BufferReserve_(size:Int)
		If Buffer_.Length < size Then
			Local newSize:Int = 1 Shl Int(Ceil(Log(size) / LOG2))
			Assert(newSize  >= size)
			Buffer_ = Buffer_[0..newSize]
		EndIf
	End Method
	
	Method ReceiveByStopSeq:Int()
		' TODO: enhance, we do a copy of the remaining data, which is clearly inefficient
		If UnconsumedBytesStart_ > 0 Then
'			DebugStop
			If UnconsumedBytesLength_ > 0 Then
				MemCopy(Buffer_, Varptr Buffer_[UnconsumedBytesStart_], UnconsumedBytesLength_)
			EndIf
			'BufferIndex_ :- UnconsumedBytesStart_
			BufferIndex_ = UnconsumedBytesLength_
			ScanStartPos :- UnconsumedBytesStart_
			UnconsumedBytesStart_ = 0
			UnconsumedBytesLength_ = 0
'			If Buffer_[UnconsumedBytesStart_] = Asc("~r") And Buffer_[UnconsumedBytesStart_+1] = Asc("~n") ..
'				And Buffer_[UnconsumedBytesStart_+2] = Asc("G") Then
'				DebugStop
'			EndIf
		EndIf
		
		Local nBytes:Int = Socket.ReadAvail()
		If nBytes > 0 Then
			
			' If needed expand the buffer
			BufferReserve_(BufferIndex_+nBytes)
						
			' Read bytes from stream
			SocketStream_.ReadBytes(Varptr Buffer_[BufferIndex_], nBytes)
			
			BufferIndex_ :+ nBytes
		EndIf
		
		' Search stop sequence in the data that has not been scanned already
		
		If BufferIndex_ >= StopSeq.Length Then
	'		Local ScanEndPos:Int = Max(0, BufferIndex_ - StopSeq.Length)' + 1
			Local ScanEndPos:Int = BufferIndex_ - StopSeq.Length' + 1
			
			#BufferLoop
			For Local i:Int = ScanStartPos To ScanEndPos
				For Local j:Int = 0 Until StopSeq.Length
					If Buffer_[i+j] <> StopSeq[j] Then
						Continue BufferLoop
					EndIf
				Next
				' We got a match
				'DebugStop
				MsgLen_ = i
				UnconsumedBytesLength_ = BufferIndex_ - MsgLen_ - StopSeq.Length
				UnconsumedBytesStart_ = MsgLen_ + StopSeq.Length
				ScanStartPos = i + StopSeq.Length
				
				Return True
			Next
			
			ScanStartPos = ScanEndPos + 1
			
		EndIf
					
		Return False
	End Method
	
	Method ReceiveBySize:Int()
		Local nBytes:Int = Socket.ReadAvail()
		If nBytes >= StopSize Then
	 		MsgLen_ = StopSize
			UnconsumedBytesStart_ = 0
			UnconsumedBytesLength_ = 0
			BufferIndex_ = 0
			
			' If needed expand the buffer
			BufferReserve_(MsgLen_)
			
			' Read bytes from stream
			SocketStream_.ReadBytes(Buffer_, MsgLen_)
			Return True
		EndIf
		Return 0
	End Method
	
	Method Close()
		CloseStream(SocketStream_)
		SocketStream_ = Null
		'Socket = Null
	End Method
End Type


Function CreateTcpServer:TTcpServer(Port:Int, CreateConnection:TTcpConnection(s:TTcpServer, NewSocket:TSocket) = Null)
	Return TTcpServer.Create(Port, CreateConnection)
End Function




'Test Code:  This is a simple Telnet Chat Server.  Run this program, then
'            open up a command prompt and type:
'  
'				Telnet localhost 3849
'
'			 You can telnet into this server from anywhere in the world
'            and do *very basic* text chatting.  To log in from another
'            computer, type:
'
'				Telnet {host computer ip} 3849
'
'			 This is just a sample program to show you what you can do
'			 with the TTcpServer object.
'----------------------------------------------------------------------

'Create callback functions for interaction with the TTcpServer Object.

Function MyId$(C:TStdTcpConnection)
	Return String(C.Extra)
End Function

'Function to handle data recieved by server
'------------------------------------------
Function TextHandler(C:TStdTcpConnection)
	C.BroadCastString(MyId(C) + ": " + C.GetStringMsg() + "~r~n")
End Function

'Greet new users and assign an ID
'--------------------------------
Function Greet(C:TStdTcpConnection)
	C.Extra = "User [" + MilliSecs() + "]" ' Store the user ID in the 'Extra' field.
	C.SendString("Welcome!~r~n")
	C.BroadCastString(MyId(C) + " has entered the room.~r~n")
End Function

'Alert other users when a user leaves
'------------------------------------
Function ConnectionLost(C:TStdTcpConnection)
	C.BroadCastString("~r~n" + MyId(C) + " has left the room.~r~n~r~n")
End Function

' Instanciates a new connection object
' And assign Function Pointers to connection's callback handles
'------------------------------------
Function CreateMyConnection:TStdTcpConnection(s:TTcpServer, NewSocket:TSocket)
'	Local conn:TStdTcpConnection = TStdTcpConnection.Create(s, NewSocket)
	Local conn:TStdTcpConnection = (New TStdTcpConnection).Init(s, newSocket)
	conn.MsgRcvdCallback = TextHandler
	conn.NewConnectionCallback = Greet
	conn.ConnectionLostCallback = ConnectionLost
	Return conn
End Function

'Create an Instance of the TTcpServer Class
'-------------------------------------------------
Global Server:TTcpServer = CreateTcpServer(3849, CreateMyConnection)

'The Main Loop
'--------------
While Not KeyHit(KEY_ESCAPE)
	Server.Listen()		'That's it!
		
	Delay(1)
Wend

There are certainly still some enhancements to do, but it's already more flexible, and it works (well I think, it's not like I tested it extensively).

EDIT(21/03/2007): updated code to correct some bugs that real usage only could easily reveal.

CoderLaureate

2007

Wow! It looks like you've taken my little program and really vamped it up! Excellent Job. Do you mind if I use your new code in a project of mine?

Koriolis

2007

Absolutely not, go on.

Trader3564

2008

nice code! i was wondering wheter there maybe an update for the things todo that are still open in this one. is there an update? thanks!

Code Archives Forum