Simple Echo Server

Question

I wrote this echo server in Haskell as a way to introduced myself to programming with sockets in Haskell and generally practice Haskell. The echo server has a simple purpose: accept connections from a port (provided as a command line argument) and echo data read from the port back one line at a time.

import Control.Applicative
import Control.Concurrent
import Control.Monad
import Network.Socket
import System.Environment
import System.IO

main :: IO ()
main = withSocketsDo $ do
  port <- toEnum . read . head <$> getArgs 
  newSocket <- socket AF_INET Stream defaultProtocol 
  setSocketOption newSocket ReuseAddr 1
  bindSocket newSocket $ SockAddrInet port iNADDR_ANY
  listen newSocket 2
  runServer echo newSocket

runServer :: (String -> String) -> Socket -> IO()
runServer f s = forever $ do
  (usableSocket,_) <- accept s
  forkIO $ interactWithSocket f usableSocket 

interactWithSocket :: (String -> String) -> Socket -> IO()
interactWithSocket f s = do 
  handle <- socketToHandle s ReadWriteMode
  forever $ f <$> hGetLine handle >>= hPutStrLn handle 

echo :: String -> String  
echo = id

General review of my Haskell coding is appreciated as well as advice on better or alternate ways to interact with sockets in Haskell. Finally, I plan on implementing more complex servers in Haskell so, I'm looking for tips on how to make my code more extensible.

Answer 1

I quite like the code, there isn't much to say. There are small improvements to make - better command line arguments handling, and perhaps graceful handling of EOF (and possibly other exceptions) in the server code, but as it is it works also just fine.

Perhaps the only more important comment is that your server is vulnerable to a memory exhaustion attack, if an adversary passes extremely long line.

The most interesting part is how to make the server code extensible. You very nicely pass the server function String -> String as a parameter to the server implementation. But it transforms lines one by one, so it won't be possible to implement more complex interaction.

So the next step would be to apply a String -> String function to the whole input, in the spirit of interact (IIRC this is how early functional languages defined their input/output, before monads and the IO monad were invented). But this has drawbacks too:

• Either you read the whole input and then produce the whole output, which is rather limiting.
• Or you use lazy IO, which is very tricky and problematic. I certainly don't recommend it.
• The server code can't do anything except computing output from input.

The last point can be solved by extending the type to String -> IO String. But still doesn't solve the lazy IO problem.

One step further would be to define a data type that'd consume a piece of output, produce a piece of input, and a continuation to proceed further:

data Application = String -> IO (String, Maybe Application)

This works nicely for applications that have well defined input/output tokes, such as interacting line-by-line. But for more complex operations, it's still not sufficient. In particular, sometimes you need to consume several input chunks until producing an output one, or vice versa. For example imagine you need to implement splitting input into lines by yourself - you need to read possibly multiple (or no) chunks until you encounter \n.

The solution to this are several libraries that more or less do the same thing: iteratees, conduit, pipes (for comparison see this question). Conduit is used in the Yesod web server and has a lot of different libraries. In conduit-extra you have libraries for connecting a conduit to a socket, for creating conduits from a parser, splitting input into lines etc. It also works on more efficient ByteStrings, rather than Strings.