9.10 A more complex example - a simple WWW server

Usually WWW involves HTML. HTML (Hyper-Text Markup Language) is a way to write documents with embedded pictures and links to other pages. These links are normally displayed underlined and if you click them your WWW- browser will load whatever document that link leads to.

#!/usr/local/bin/pike
                
/* A very small httpd capable of fetching files only.
 * Written by Fredrik Hübinette as a demonstration of Pike.
 */
                
inherit Stdio.Port;

Next are some constants that will affect how uHTTPD will operate. This uses the preprocessor directive #define. The preprocessor is the first stage in the compiling process and can make textual processing of the code before it is compiled. As an example, after the first define below, all occurrences of 'BLOCK' will be replaced with 16060.

/* Amount of data moved in one operation */
#define BLOCK 16060
                
/* Where do we have the html files ? */
#define BASE "/usr/local/html/"
                
/* File to return when we can't find the file requested */
#define NOFILE "/user/local/html/nofile.html"
                
/* Port to open */
#define PORT 1905

Next we declare a class called output_class. Later we will clone one instance of this class for each incoming HTTP connection.

class output_class
{
    inherit Stdio.File : socket;
    inherit Stdio.File : file;

    int offset=0;

Next we define the function write_callback(). Later the program will go into a 'waiting' state, until something is received to process, or until there is buffer space available to write output to. When that happens a callback will be called to do this. The write_callback() is called when there is buffer space available. In the following lines 'void' means that it does not return a value. Write callback will be used further down as a callback and will be called whenever there is room in the socket output buffer.

    void write_callback()
    {
        int written;
        string data;

        file::seek(offset);

        data=file::read(BLOCK);

        if(strlen(data))
        {

            written=socket::write(data);

            if(written >= 0)
            {
                offset+=written;
                return;
            }

            werror("Error: "+socket::errno()+".\n");
        }

        destruct(this_object());
    }

Next we need a variable to buffer the input received in. We initialize it to an empty string.

    string input="";

    void read_callback(mixed id,string data)
    {
        string cmd;
                
        input+=data;

        if(sscanf(input,"%s %s%*[\012\015 \t]",cmd,input)>2)
        {

            if(cmd!="GET")
            {
                werror("Only method GET is supported.\n");
                destruct(this_object());
                return;
            }

            sscanf(input,"%*[/]%s",input);

            input=BASE+combine_path("/",input);

            if(!file::open(input,"r"))
            {

if(!file::open(NOFILE,"r"))
{

    werror("Couldn't find default file.\n");
    destruct(this_object());
    return;
}
            }

            socket::set_buffer(65536,"w");

            socket::set_nonblocking(0,write_callback,0);

            write_callback();

        }
    }

This function is called if the connection is closed while we are reading from the socket.

    void selfdestruct() { destruct(this_object()); }

    void create(object f)
    {
        socket::assign(f);

        socket::set_nonblocking(read_callback,0,selfdestruct);

    }

};

Next we define the function called when someone connects.

void accept_callback()
{
    object tmp_output;

    tmp_output=accept();

    if(!tmp_output) return;

    output_class(tmp_output);

    destruct(tmp_output);

}

int main(int argc, array(string) argv)
{
    werror("Starting minimal httpd\n");

    if(!bind(PORT, accept_callback))
    {
        werror("Failed to open socket (already bound?)\n");
        return 17;
    }

    return - 17; /* Keep going */

}