Latest posts for the topic "Building a simple socket based HTTP server"

Building a simple socket based HTTP server

stdunbar — GMT

I'd like to create an article on building a very simple HTTP server. There are other tutorials out there but I'll try my shot at it too. It seems that sockets are a common discussion topic. As part of this the first post will be about the requirements that I'm going to try to satisfy.

The first and most important thing is that the purpose of this is to provide a framework for learning. It is not to produce a production quality web server like Apache or Tomcat. While the code will be high quality I may take shortcuts or leave some features out in the interest of time or clarity. I will try to point out where I feel that a shortcut or non-enterprise design has been used. A side effect of this requirement is we will not use anything except for the classes available in 1.4 J2SE. There are many excellent libraries available for networking. But this is meant to be a learning program. By doing it "by hand" one time I find that you learn significantly more than jumping straight to a thrid party library.

Which leads to the second requirement. I'm going to limit the initial scope to only handle the HTTP GET command. This is the most commonly used HTTP command. However, this means that the first version of the software will not be able to handle form processing. As time permits I will also include the HTTP POST command.

The server should comply with [url=http://www.w3.org/Protocols/rfc2616/rfc2616.html]RFC 2616[/url] in the GET area where possible. Where it isn't possible it should work well with any HTTP client. While the majority of the HTTP clients are browsers the server should work equally well with programs such as [url=http://www.gnu.org/software/wget/wget.html]wget[/url] where there is much more limited user interaction.

Lastly, the code will be developed in a Java [b]1.4[/b] environment. While Java 1.5/5.0 is the current release the intention is to allow the most number of people to benefit from this. 1.5 is still in limited use outside of schools. From what I can see a significant number of people are still using 1.4. Where something might be easier in 1.5 we will try to point that out.

If you'd like to see other requirements please feel free to post it in this thread. We can discuss what else may be useful and add it to the requirements as time permits.

Re:Building a simple socket based HTTP server

stdunbar — GMT

The core of the server will be based on [url=http://java.sun.com/j2se/1.4.2/docs/api/java/net/ServerSocket.html]ServerSocket[/url]. This is the base server side class when using TCP sockets.

Let's look at the some of the methods that I'll be using (quotes from the Javadoc):

[quote]public ServerSocket(int port) throws IOException

Creates a server socket, bound to the specified port.[/quote]

This is the basis of our server. We'll create a ServerSocket that, in the Berkeley sockets (regular C sockets on most Unix systems) terminology does a bind() to a particular port. What this means is that once you call this (and assuming that no exceptions get thrown) there will be a socket ready to accept connections on the port we specify. So lets start with a little code to test this:

[code]
import java.net.ServerSocket;
import java.net.Socket;

public class SimpleHTTPServer
{
private ServerSocket serverSocket = null;

public void runServer( int port )
{
try
{
// create a new ServerSocket and bind it to the specified port
serverSocket = new ServerSocket( port );
// now do the same thing as a listen(). this method will block until a client connects to us.
Socket nextClientSocket = serverSocket.accept();
// print a little bit out about the client
System.out.println( "got a connection from " + nextClientSocket.getInetAddress().toString() );
// close the socket for now as we're just testing
nextClientSocket.close();
}
catch( Exception e )
{
System.err.println( "cannot create new server socket on port " + port );
e.printStackTrace( System.err );
return;
}
}

public static void main( String[] argv )
{
int port = 0;

if( argv.length != 1 )
{
System.err.println( "usage: java SimpleHTTPServer " );
System.exit( 1 );
}

try
{
port = Integer.parseInt( argv[0] );
}
catch( NumberFormatException nfe )
{
System.err.println( "please use a valid integer for the port" );
System.exit( 1 );
}

SimpleHTTPServer server = new SimpleHTTPServer();
server.runServer( port );
}
}
[/code]

We'll setup a real build environment in a bit but this can be compiled by hand:

[code]
javac SimpleHTTPServer.java
[/code]

and run with

[code]
java SimpleHTTPServer 1234
[/code]

You can select anything you want for the port number as long as two conditions are satisfied. The first is that, on Unix and Linux the default configuration only allows you to bind to a port number of 1024 and higher. If you try to bind to something less you'll get an exception like:

[code]
[httpserver]$ java SimpleHTTPServer 123
cannot create new server socket on port 123
java.net.BindException: Permission denied
at java.net.PlainSocketImpl.socketBind(Native Method)
at java.net.PlainSocketImpl.bind(PlainSocketImpl.java:331)
at java.net.ServerSocket.bind(ServerSocket.java:318)
at java.net.ServerSocket.(ServerSocket.java:185)
at java.net.ServerSocket.(ServerSocket.java:97)
at SimpleHTTPServer.runServer(SimpleHTTPServer.java:14)
at SimpleHTTPServer.main(SimpleHTTPServer.java:51)
[/code]

Secondly, if you try to use a port that is already in use you'll get something like:

[code]
[httpserver]$ java SimpleHTTPServer 8009
cannot create new server socket on port 8009
java.net.BindException: Address already in use
at java.net.PlainSocketImpl.socketBind(Native Method)
at java.net.PlainSocketImpl.bind(PlainSocketImpl.java:331)
at java.net.ServerSocket.bind(ServerSocket.java:318)
at java.net.ServerSocket.(ServerSocket.java:185)
at java.net.ServerSocket.(ServerSocket.java:97)
at SimpleHTTPServer.runServer(SimpleHTTPServer.java:14)
at SimpleHTTPServer.main(SimpleHTTPServer.java:51)
[/code]

Otherwise, you can test that this works by using the telnet program. You'll want to do something like:

[code]
telnet localhost 1234
[/code]

(assuming that you're running the client - telnet - and the server on the same machine).

You will get something like:

[code]
[httpserver]$ java SimpleHTTPServer 1234
got a connection from /127.0.0.1
[/code]

on the server side and:
[code]
[httpserver]$ telnet localhost 1234
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Connection closed by foreign host.
[/code]

in the telnet window. This is exactly what we expect as the server simply closes the new socket once it is done. Note that the exact messages may be slightly different depending on your operating system and the version of Java you're using. These messages were generated on a Fedora Core 3 Linux system using Java version 1.4.2_08.

Looks good so far!

tfecw — GMT

[quote]
We'll setup a real build environment in a bit but this can be compiled by hand:
[/quote]

Has it been a bit yet? I'm a little curious how an experienced developer does this. I've just got a bat file that automates an ant file for me. All in all it’s just a mess of exist bat/com files mixed together into one giant intelligible mess.

Looks like a good start. Instead of doing some research and answering my own question I’d figure I’d ask them here to stimulate conversation...yeah that's the ticket

With just the ServerSocket looking accepting on a port, we don't specifically have a HTTP server right? I was able to test it via the telnet as well as through my browser (http://localhost:1234) I guess to put it another way. What makes an HTTP Server an HTTP Server over a gaming server or over a FTP server? (I realize that I’m probably butchering the networking lingo)
Is the underlying setup the same for all of these? In other words, would an HTTPServer just open a ServerSocket then call a GetMethod, a FTP server would open a ServerSocket then call a doFTPHandshake method, etc.

Is it even possible to look at a connection and figure out which protocol to send it on to, or would you need to open an HTTP socket, an FTP socket, and a GameProtocol socket?

EDIT: ugh...didn't mean to post a new thread. Can you move this to the HTTPServer thread or delete this post and I'll repost it?

Looks good so far!

stdunbar — GMT

[quote=tfecw]Has it been a bit yet? I'm a little curious how an experienced developer does this. I've just got a bat file that automates an ant file for me. All in all it’s just a mess of exist bat/com files mixed together into one giant intelligible mess.[/quote]

Well I don't know what experienced developers do but I'll use that as a lead into my next post

[quote=tfecw]Is the underlying setup the same for all of these? In other words, would an HTTPServer just open a ServerSocket then call a GetMethod, a FTP server would open a ServerSocket then call a doFTPHandshake method, etc.
[/quote]
The underlying setup [b]is[/b] the same for all of them, though FTP has a bit of a strange protocol by default. With what exists so far it could be made into an HTTP server, a chat server, a game server, an email server and so on. HTTP follows a long line of successful character based network servers. Basically these are servers that communicate actions via simple character interaction.

[quote=tfecw]
Is it even possible to look at a connection and figure out which protocol to send it on to, or would you need to open an HTTP socket, an FTP socket, and a GameProtocol socket?
[/quote]
By itself, no. The socket is waiting for someone to connect to it and start a conversation. HTTP, like many other networking services, is at the application layer of the [url=http://en.wikipedia.org/wiki/OSI_model]7 layer OSI networking model[/url]. But you can't really tell what is sitting on the port. There are [url=http://www.iana.org/assignments/port-numbers]well known port numbers[/url] so that if you connect to, for example, port 80 then you are very likely talking to an HTTP server but there is nothing that enforces this other than a desire to work with other applications.

Re:Building a simple socket based HTTP server

stdunbar — GMT

On to the build environment!

For this example we're going to use a pretty simple directory structure. It is going to look like:

[code]
httpserver/
src/
com/
hotjoe/
http/
server/
SimpleHTTPServer.java
build.xml
lib/
[/code]

So there are two things with this. The first is that the code I posted before will now need a package declaration:

[code]
package com.hotjoe.http.server;

import java.net.ServerSocket;
import java.net.Socket;

...
[/code]

and we will need to create a build.xml file for [url=http://ant.apache.org/]Ant[/url].

Ant is a build tool that takes care of things like making sure that if a source file (.java) has changed it recompiles the file into a new .class file. There are many other things it can do but that is the crux of what we will be using it for.

So lets create a pretty simple build.xml (the default file name that ant uses) and go through it:

[code]

destdir="${dest.classes.dir}"
debug="${compile.debug}"
deprecation="${compile.deprecation}"
optimize="${compile.optimize}"
source="${compile.source}"
target="${compile.target}" >

destdir="${javadoc.dir}"
author="true"
version="true"
private="false"
packagenames="${javadoc.package.names}">

[/code]

This build file checks the environment in which it is running to make sure that everything looks correct. At the top of the file the defaults are set. Any of these can be overridden if you were to create a file named build.properties in the same directory as the build.xml file. The idea is that you may need build.properties changed depending on, for example, what O/S you are using at the time.

Once you have added the package declaration to SimpleHTTPServer.java and moved it to src/com/hotjoe/http/server, just run "ant" in the directory. You should get an output that looks similar to:

[code]
[httpserver]$ ant
Buildfile: build.xml

check.src.dir.set:

check.dest.classes.set:

check.dest.lib.set:

check.javadoc.dir.set:

set.src.dir.exists:

check.src.dir:

checks:

compile:
[mkdir] Created dir: /home/scott/hotjoe/httpserver/classes
[mkdir] Created dir: /home/scott/hotjoe/httpserver/lib
[javac] Compiling 1 source file to /home/scott/hotjoe/httpserver/classes

jar:
[jar] Building jar: /home/scott/hotjoe/httpserver/lib/httpserver.jar

main:

BUILD SUCCESSFUL
Total time: 3 seconds
[/code]

Lets start with that and see if there are any issues.