Title: Socket based communication
Submitter: Jeff Hobbs (other recipes)
Last Updated: 2001/06/21
Version no: 1.0
Category: Distributed processing, Network resources

Description:

Here we write the most simple socket based server application we
can think of. Starting from this minimal example it is very easy to
extend it to the actually wanted functionality

Source: Text Source

#!/usr/local/bin/tcl
# fileevent/socket example

# Change the port to meet requirements.  Read it for example from the
# commandline or a configuration file

socket -server on_connect 18018

# Procedure called whenever a new connection is made by a client.
proc on_connect {newsock clientAddress clientPort} {

    # This is the place to add checks disallowing connections based
    # upon the hostname/ipaddress of the peer.

    fconfigure $newsock -blocking 0
    fileevent  $newsock readable [list handleInput $newsock]
}

# Procedure called whenever input arrives on a connection.
proc handleInput {f} {
    # Delete the handler if the input was exhausted.
    if {[eof $f]} {
        fileevent $f readable {}
        close     $f
        return
    }

    # Read and handle the incoming information. Here we just log it to
    # stdout.

    puts [read $f]
}

The license for this recipe is available here.

Discussion:

When it comes to the handling of the data read by the server on
the connections developers have quite many ways to do so. Under the
assumption of a line-oriented protocol where the first word in a line
contains the command sent by the client we have:

Use a [switch] statement to decode the protocol command and to dispatch to the procedure implementing it.

Use an array to map from the protocol command to the procedure implementing it, then use [eval] to execute it. UUnknown and thus illegal commands can be detected by using [info exists] to check whether there actually is a mapping or not.

Construct the name of the procedure directly from the protocol command and then [eval] it. Use [info command] to check the existence of the procedure before doing so.

The simplest way of doing the construction is to use the name of the protocol command itself as the name of the procedure to execute. Note that this method is extremely unsafe as the client may send arbitrary tcl commands. This insecurity is commonly avoided through the use of a safe interpreter containing just the legal commands and thus providing a sandbox the client cannot leave.

Another thing to note: When reading data from a socket we should always be aware that it can arrive choppeed up into blocks of arbitrary length without relation to the blocks which were send. TCP guarantees arrival of bytes in order, but nothing more.

This means that in the case of line-oriented we should always use

if {[gets $sock line] < 0} {return}

append buffer [read $sock]
if {[data-complete buffer]} {
    # Return the data we need and leave everything we didn't need in the buffer.
    set data [get-data buffer]
    handle $data
}