Programming challenge: Listen on a socket

[RupertPupkin]

Time for a new programming challenge! This one should be easier than the last one, and can probably be done in a lot more languages: listen on a socket for messages coming over the network, then print out the messages to a log file.

The rules for this challenge are as follows:

1. Open a TCP socket on some open port (say, port 6789). Do NOT just call an external program to do this for you!
2. When messages are received on that port, print to a log file /tmp/socket.log the following information:
   1. the date and time that the message was received
   2. the IP address that the message came from
   3. the message itself
3. The above information should be appended to the log file in the following format:
   

   <YYYY-MM-DD> <hh:mm:ss AM|PM> from <address>: <message>

   For example, if the message "hello there!" was sent from IP address 127.0.0.1 at 2:53:58 PM on April 25, 2013, then you would append this to the log file:
   

   2013-04-25 02:53:58 PM from 127.0.0.1: hello there!

4. Post your code (and any special compilation instructions, if necessary).

You don't have to worry about writing a network client to test your code, since in Linux you can just use bash to send messages to a port:

echo 'hello there!' > /dev/tcp/127.0.0.1/6789

That sends the message 'hello there!' to port 6789 at the address 127.0.0.1. You can replace that IP address and port number with whatever you're using.

I'll get the challenge started with an example in Tcl:

#!/usr/bin/tclsh
set log [open "/tmp/socket.log" a+]
set sock [socket -server accept 6789]
fconfigure ${sock} -blocking 0 -encoding utf-8 -buffering line
proc accept {s addr p} {
   fileevent $s readable [list process $s ${addr}]
}
proc process {s addr} {
   global forever log
   set message [gets $s]
   if {[eof $s]} {
      close $s
      set forever done
   } else {
      puts ${log} "[clock format [clock seconds] -format "%Y-%m-%d %I:%M:%S %p"]\
                   from ${addr}: ${message}"
      flush ${log}
   }
}
while {1} {vwait forever}

Here's a message I sent from another machine (192.168.1.3) to my machine (192.168.1.100) where the program is listening on port 6789:

$ echo 'hello there!' > /dev/tcp/192.168.1.100/6789

Here's what the log file looks like:

$ tail -f /tmp/socket.log
2013-04-25 02:53:58 PM from 192.168.1.3: hello there!
2013-04-25 03:23:46 PM from 192.168.1.3: hello again!

[Flounder]

Looks like I am the first after you to post a sample. This example is in C. I was waiting for another one of these programming challenges.

Here is my code for simpleserver.c:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#include <time.h>

void sigchld_handler(int s)
{
    while (waitpid(-1, NULL, WNOHANG) > 0);
}

void *get_in_addr(struct sockaddr *sa)
{
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*)sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int main()
{
    FILE *fp;
    int status, listenfd, commfd;
    int yes = 1;
    struct addrinfo hint, *res, *p;
    struct sockaddr_storage their_addr;
    struct sigaction sa;
    socklen_t addr_size;
    char message[128];
    char s[INET6_ADDRSTRLEN];

    fp = fopen("/tmp/socket.log", "a");

    memset(&hint, 0, sizeof hint);
    hint.ai_family = AF_UNSPEC;
    hint.ai_socktype = SOCK_STREAM;
    hint.ai_flags = AI_PASSIVE;

    if ((status = getaddrinfo(NULL, "6789", &hint, &res)) != 0) {
	fprintf(stderr, "getaddrinfo error %s\n", gai_strerror(status));
        exit(1);
    }

    for (p = res; p != NULL; p = p->ai_next) {
	if ((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
            perror("server: socket");
            continue;
        }

        if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &yes,
                       sizeof(int)) == -1) {
            perror("setsockopt");
            exit(1);
        }

        if (bind(listenfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(listenfd);
            perror("server: bind");
            continue;
        }

        break;
    }

    if (p == NULL) {
        fprintf(stderr, "server: failed to bind\n");
        return 2;
    }

    freeaddrinfo(res);

    if (listen(listenfd, 20) == -1) {
        perror("listen");
        exit(1);
    }

    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1);
    }

    printf("server: waiting for connections...\n");

    while (1) {
        addr_size = sizeof their_addr;
	commfd = accept(listenfd, (struct sockaddr *)&their_addr, &addr_size);
        if (commfd == -1) {
            perror("accept");
            continue;
        }

        inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr),
                  s, sizeof s);
        printf("server: got connection from %s\n", s);

        if (!fork()) {
            close(listenfd);
            if (recv(commfd, message, 128, 0) == -1) {
                perror("recv");
	    }
            else {
                char *newline;
                newline = strpbrk(message, "\n");
		*newline = '\0';
                char date[25];
                time_t ourtime;
                time(&ourtime);
                struct tm *tmrecv = localtime(&ourtime);
                strftime(date, 25, "%Y-%m-%d %I:%M:%S %p", tmrecv);
		fprintf(fp, "%s ", date);
                fprintf(fp, "from %s: %s\n", s, message);
            }
            close(commfd);
            exit(0);
        }
	close(commfd);
    }

    fclose(fp);

    return 0;
}

Most of the original code is from Beej's guide as this was the perfect excuse to go read up on sockets. Compiling is fairly simple just use clang or gcc.

Here is the log file after I ran it:

2013-04-26 11:54:50 AM from 127.0.0.1: hello there!
2013-04-26 11:55:07 AM from 127.0.0.1: This time we should have some output in the log rather than stdout.

[Skull One]

Using bash and nc:

#!/bin/bash

PORT=5555

while MSG=$(nc -lv $PORT &>/dev/stdout); do 

        DATE=$(date +"%Y-%m-%d %I:%M:%S %p"); 
        FROM=$(head -n 1 <<< "$MSG"); 
        HST=$(echo $FROM|awk '{print $3}'); 
        TEXT=$(tail -n -1 <<< "$MSG"); 

        echo "$DATE from $HST: $TEXT" >> /tmp/socket.log ; 

done

[RupertPupkin]

@Flounder: Nice! Got it working on my machine.

@Skull One: Calling an external program like nc to listen on a socket for you kind of defeats the whole purpose of the challenge (which is to write that program yourself). I've modified the rules to not allow that.

Here's an example using Java. It can handle simultaneous connections by creating a new thread for each connection.

import java.net.*;
import java.io.*;
import java.text.*;
public class socket {
   public static void main(String[] args) throws IOException {
      ServerSocket servsock = null;
      Thread sThread = null;
      try {
         servsock = new ServerSocket(6789);
      } catch (IOException e) {
         e.printStackTrace();
         System.exit(-1); 
      }
      while(true) {
         sThread = new socketThread(servsock.accept());
         sThread.start();
      }
   }
}
class socketThread extends Thread {
   private Socket sock = null;
   public socketThread(Socket s) {
      super("socketThread");
      this.sock = s;
   }
   public void run() {
      try {
         File log = new File("/tmp/socket.log");
         if (!log.exists()) log.createNewFile();
         BufferedReader in = new BufferedReader(new InputStreamReader(sock.getInputStream()));
         BufferedWriter logFile = new BufferedWriter(new FileWriter(log, true));
         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss a");
         String timestamp = dateFormat.format(new java.util.Date());
         logFile.write(timestamp + " from " + sock.getInetAddress().toString().substring(1));
         StringBuffer message = new StringBuffer();
         String inputLine = null;
         while ((inputLine = in.readLine()) != null) {
            message.append(inputLine + "\n");
         }
         in.close();
         sock.close();
         logFile.write(": " + message);
         logFile.close();
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Save that in a file called socket.java, then compile and run like this:

javac socket.java
java socket

Some sample log entries after running it:

2013-04-26 17:45:34 PM from 127.0.0.1: Java rules!
2013-04-26 17:47:05 PM from 127.0.0.1: This is a new thread.

[ptuk]

Here's an example using Java. It can handle simultaneous connections by creating a new thread for each connection.

[Snip]

I was writing Java code like that back in the 1990s before app servers became ubiquitous.

[ah7013]

using Perl and the core module IO::Socket::INET

#!/usr/bin/perl
use strict;
use warnings;
use IO::Socket::INET;
use POSIX qw/strftime/;

$| = 1;

my $s = IO::Socket::INET->new(
    LocalHost => '0.0.0.0',
    LocalPort => 6789,
    Proto => 'tcp',
    Reuse => 1,
    Listen => 10,
);

while (my $c = $s->accept) {
    my $t = strftime("%Y-%m-%d %I:%M:%S %p", localtime);
    chomp(my $r = <$c>);
    last if $r =~ /^(?:quit|exit)$/i;
    my $f = $c->peerhost;
    open(my $FH, '>>', '/tmp/socket.log');
    print $FH "$t from $f: $r\n";
    close($FH);
}

$s->close;

The log file:

[andrew@localhost ~]$ tailf /tmp/socket.log
2013-04-27 10:30:28 AM from 127.0.0.1: hello
2013-04-27 10:30:53 AM from 127.0.0.1: hello there!
2013-04-27 10:31:14 AM from 127.0.0.1: hello there!
2013-04-27 10:32:21 AM from 127.0.0.1: hello there!
2013-04-27 10:33:22 AM from 127.0.0.1: hello there!
2013-04-27 10:35:00 AM from 127.0.0.1: hello there!
2013-04-27 10:35:32 AM from 10.1.3.1: hello there!
2013-04-27 10:37:03 AM from 10.1.3.1: another test
2013-04-27 10:43:12 AM from 10.1.3.1: another test 2

[Skull One]

Calling an external program like nc to listen on a socket for you kind of defeats the whole purpose of the challenge (which is to write that program yourself). I've modified the rules to not allow that.

How rude! That is the unix way of scripting. It is not different than using a module to do the job.

By the way, I was pretty sure to be disqualified with this one , but I could not think of anything else with bash.

[jpollard]

It is only a little harder to setup a SSL secured socket... using OpenSSL to create the client and server, then using bash/perl to do any real work.

The "harder" part is setting up the certificates...

[RupertPupkin]

Here's an example in Scheme. Save the script below as socket.scm and make it executable. It works with Guile 1.8.8 in Fedora 18 (yum install guile):

#!/bin/sh
exec guile -s $0
!#
(use-modules (ice-9 rdelim))
(let* ((s (socket PF_INET SOCK_STREAM 0))
      (log (open-file "/tmp/socket.log" "al")))
   (setsockopt s SOL_SOCKET SO_REUSEADDR 1)
   (bind s AF_INET INADDR_ANY 6789)
   (listen s 5)
   (while #t
      (let* ((client_connection (accept s))
             (remote_addr (cdr client_connection))
             (client_port (car client_connection))
             (data (read-line client_port)))
         (format log "~a from ~a: ~a~%"
            (strftime "%Y-%m-%d %H:%M:%S %p" (localtime (current-time)))
            (inet-ntoa (sockaddr:addr remote_addr)) data)
         (close client_port))))

Some sample log contents:

$ tail -f /tmp/socket.log
2013-04-29 00:25:18 AM from 127.0.0.1: This is a Scheme socket!
2013-04-29 00:25:54 AM from 192.168.1.100: Guile is cool!

[RupertPupkin]

I found a way to do this in Octave. For this you'll need to compile and install the octave-sockets package, since it's not in the Fedora repos. Luckily, Octave can do it for you. Just run octave as root and do this at the octave prompt:

pkg -forge -auto install sockets

After it finishes you should then be able to use the sockets package.

Here's the Octave code, which you can make an executable script:

#!/usr/bin/octave -q
f = fopen("/tmp/socket.log", "a");
sock = socket();
bind(sock, 6789);
a = listen(sock, 5);
while true
   [client, info] = accept(sock);
   [data, count] = recv(client, 256, MSG_WAITALL);
   fprintf(f, "%s from %s: %s", strftime("%Y-%m-%d %r", localtime(time())), info.sin_addr, char(data))
   fflush(f);
   disconnect(client);
end

It will keep running until you hit Ctrl-c three times.

Some sample log entries:

$ tail -f /tmp/socket.log
2013-04-29 11:04:19 PM from 127.0.0.1: Sockets in Octave? No way!
2013-04-29 11:04:36 PM from 192.168.1.100: Yes way!!

[RupertPupkin]

Here's an example in Lua. You'll need the lua-socket package from the Fedora repos for this.

#!/usr/bin/lua
socket = require("socket")
server = assert(socket.bind("*", 6789))
log = io.open("/tmp/socket.log", "a+")
while true do
   client = server:accept()
   line = client:receive()
   log:write(string.format("%s from %s: %s\n", os.date("%Y-%m-%d %r"), client:getpeername(), line))
   log:flush()
   client:close()
end

Make that an executable script with a name like socket_test.lua (not socket.lua, as that will cause a conflict with a built-in Lua file).

Some sample log entries:

$ tail -f /tmp/socket.log
2013-05-01 01:02:05 AM from 192.168.1.100: A-lua lua, woah woah!
2013-05-01 01:02:49 AM from 127.0.0.1: Yeah yeah yeah yeah!

[RupertPupkin]

Here's an example in REXX. For this you'll need to install the oorexx-devel package from the Fedora repos.

#!/usr/bin/rexx
log = .stream~new("/tmp/socket.log")
log~command("OPEN APPEND NOBUFFER")
sock = .socket~new()
sock~bind(.inetaddress~new(INADDR_ANY, 6789))
sock~listen(5)
do forever
   client = sock~accept()
   msg = client~recv(256)
   log~lineout(DATE("S", DATE(), "N", "-") TIME("N") RIGHT(UPPER(TIME("C")), 2),
          "from" client~getPeerName()~address() || ":" STRIP(msg, "T", D2C(10)))
   client~close()
end
::requires '/usr/share/ooRexx/socket.cls'

If you're not running Fedora (shame on you!) then you might have to modify the last line to have the correct location of the socket.cls class file.

Sample log entries after running that script:

$ tail -f /tmp/socket.log
2013-05-01 21:30:54 PM from 127.0.0.1: REXX is king!
2013-05-01 21:31:04 PM from 192.168.1.100: The king is dead. Long live the king.

[ocratato]

Hmmm, the Lua and REXX versions don't seem to be significantly different from the bash version. I am not sure that there is really much difference between using a separate program (nc) in bash and a packaged library like socket.lua or socket.cls.

[RupertPupkin]

The problem with using an external program is that pretty much every language has some kind of system exec method that would allow them all to call the same external program. And that would be boring. At least with libraries (which even C and C++ use) you have to code in that library's API, which will be different for most languages. It's more work, and you get to learn a new API, so I just think that's better.

I've actually used bash to do something like this before, though I had inetd handling the socket work instead of nc. I didn't want to post it for the reasons I gave; it just feels too much like cheating to me.

[jpollard]

The problem with using an external program is the same as using any package or utility library for a language in the same manner.

All are just ways of providing a reusable method of accomplishing the same thing.

The only way to not do that is to always code at the lowest level... And then you are just coding for the API that the kernel provides.

I once wrote an utility library that included nearly everything - server, client, AND authentication + encryption (Kerberos based). You only needed about five calls to do everything (init, setup, sending data, receiving data, closing/shutdown). Sending and receiving data had two specific functions - one for TCP and one for UDP.

Quite simple to use, patterned mostly after the fopen/fread/fwrite/fclose approach, with additional one of initialization. MUCH simpler than trying to use the Kerberos API directly.