Page has probably been moved due to site reorganization.
"
+ "Please use site's "
+ "on-board search engine.
This is always up to date. Thanks."
+ "\n"; // add standard HTML file termination
// Create date + time stamp for message and log entry.
d = new Date().toString();
/* Construct the HTTP MIME error message comprising: HTTP Response
Header, newline, MIME header datestamp, newline, MIME server ID
newline, MIME content type newline, MIME content length, blank
line, then HTML error message. */
String s = M + "\nDate: " + d + "\nServer: RobServer 1.0"
+ "\nContent-Type: text/html"
+ "\nContent-Length: " + H.length() + "\n\n" + H;
try {
o.writeBytes(s); // send the HTML error message to the session socket
if(L.traceOn()) // if tracing is enabled, send it also to trace file
L.trace(s + "\r\n\r\n");
}
catch(Exception e) { // Catch any exception messages
L.exception("error.send(): " + e); // and send them to server log.
}
}
// READ-ONLY ACCESS METHODS
String getDate() { return d; }
String getHead() { return M; }
}
/* 4) THE LOGGER CLASS --------------------------------------------------------
Sample log entry: Wed Nov 24 12:06:40 GMT 1999 GET /index.htm
HTTP/1.0 HTTP/1.0 200 OK 4599 www.fred.com */
class logger {
private int
hits; // number of hits to this web site
private boolean
traceEnabled; // says whether or not trace file active
private String
N, // domain name of client machine from which request came
s, // string for assembling the log line
n[] = {
"00000", "0000", "000", "00", "0", "" // leading zeros
};
private Writer
W, // create a writer for the server's hits log file
X, // create a writer for the server's error log file
Y; // writer for browser-server conversation to trace file
/* CONSTRUCT A NEW SERVER LOGGER
Called only from one place in server(). */
logger(boolean s) { // The constructor enables the
traceEnabled = s; // session log if required.
}
/* CREATE WRITERS for the server's hits log file, the server's
error log file and one to record the raw conversation between
the browser and server. Called only from one place in server(). */
void open() {
try { W = new FileWriter("server.log");
X = new FileWriter("except.log");
Y = new FileWriter("trace.txt"); }
// Catch any exception messages and send them to server log.
catch(Exception e) {
System.out.println("logger.open() " + e);
}
}
/* LOG WHEN THE SERVER STARTS
Called only once from server.start(). */
void start(String D, int P) {
String
s = "00000 " // dummy hit count
+ new Date() // date/time stamp when server started
+ " Started serving " + D // local directory it is serving from
+ " on Port " + P + "\n"; // port it is listening for requests on
/* Write and flush the completed line to the server log file so each
new line can be displayed by file monitor in real-time. Log to the
terminal any exceptions that may occur. */
try {
W.write(s);
W.flush();
}
catch(Exception e) {
System.out.println("logger.start() " + s + e);
}
}
/* WRITE A NORMAL ENTRY TO THE SERVER LOG FILE
Called from only one place in listen(). */
void normal(request Q, response R, String N) {
hits++; // increment the total number of hits to this web site
String s; // to hold read-out of the number of hits
if(hits > 99999) // If string would be more than 5 characters
s = "#####"; // long, use '#####' to indicate overrflow.
/* Otherwise, the number of hits does not occupy more than 5 digits.
So convert the number of hits into String form and add the appr-
opriate number of leading zeros, the date and time of the response,
the request header, the response header and the URL from which the
request originated. */
else {
s = "" + hits;
s = n[s.length()]
+ s
+ " " + R.getDate()
+ " " + Q.getHead()
+ " " + R.getHead()
+ " " + N + "\n";
}
/* Write and flush the completed line to the server log file so each
new line can be displayed by file monitor in real-time. Log to the
terminal any exceptions that may occur. */
try {
W.write(s);
W.flush();
}
catch(Exception e) {
System.out.println("logger.normal() " + s + e);
}
}
/* WRITE AN HTTP ERROR ENTRY TO THE SERVER LOG FILE
Called from only one place in listen(). */
void error(request Q, errmsg E, String N) {
/* Construct the response line comprising: the dummy hit count '00000',
the date and time of the response, the name of the file served, the
response header and the URL from which the request originated. */
String s = "00000 "
+ E.getDate() + " "
+ Q.getHead() + " "
+ E.getHead() + " "
+ N + "\n";
/* Write and flush the completed line to the server log file so each
new line can be displayed by file monitor in real-time. Log to the
terminal any exceptions that may occur. */
try {
W.write(s);
W.flush();
}
catch(Exception e) {
System.out.println("logger.error() " + s + e);
}
}
/* WRITE A PROGRAM EXCEPTION ENTRY TO THE SERVER ERROR LOG FILE
Called once each from suck(), NotFound(), denied(), barf(), send()
and twice each from run() and listen(). */
void exception(String t) {
/* Construct the response line comprising: date
and time + location and type of exception. */
String s = "" + new Date() + " " + t + '\n';
/* Write and flush the completed line to the server log file so each
new line can be displayed by file monitor in real-time. Log to the
terminal any exceptions that may occur. */
try {
X.write(s);
X.flush();
}
catch(Exception e) {
System.out.println("logger.exception() " + s + e);
}
}
/* LOG WHEN THE SERVER STOPS
Called only once from server.stop(). */
void stop(String D, int P) {
/* Construct the response line comprising: the dummy hit count '00000',
the date and time when server started, local directory it is serving
from, port number it is listening for requests on. */
String s = "00000 " + new Date()
+ " Stopped serving " + D
+ " on Port " + P + "\n";
/* Write and flush the completed line to the server log file so each
new line can be displayed by file monitor in real-time. Log to the
terminal any exceptions that may occur. */
try {
W.write(s);
W.flush();
}
catch(Exception e) {
System.out.println("logger.stop() " + s + e);
}
}
/* DONE JUST BEFORE SERVER INSTANCE IS DESTROYED
Called only from server.destroy(). */
void close() {
/* Close the server log files. Close trace file only if it was enabled.
Log to the terminal any exceptions that may occur. */
try {
W.close();
X.close();
if(traceEnabled)
Y.close();
}
catch(Exception e) {
System.out.println("logger.close() " + e);
}
}
/* RECORDS THE RAW BROWSER-SERVER CONVERSATION
Called from one place each in valid() and send()
and from 3 places in barf(). */
void trace(String s) {
if(!traceEnabled)
return; // exit if session logger not enabled
try {
Y.write(s); // write and flush the trace file
Y.flush();
}
catch(Exception e) {
System.out.println("logger.trace() " + s + e);
}
}
/* ALLOWS OTHER CLASSES TO CHECK IF SOCKET IO TRACE IS ENABLED
Called from one place each in valid() and send()
and from 3 places in barf(). */
boolean traceOn() { return traceEnabled; }
}
// 5) THE SERVER CLASS --------------------------------------------------------
class server implements Runnable {
private int
P, // port number on which to listen for http requests
EC = 0; // run loop Exception events count
private String
EM1 = "Could not create ServerSocket on Port " + P,
EM2 = "Server ternimated because of excessive Exception count.",
D; // root directory of server's HTML documents eg "/home/rob/website"
private logger L; // log message handler
private Thread T; // thread for the run() loop
private ServerSocket S; // server socket to listen for requests
// on prescribed HTTP port P
/* INSTANCE CONSTRUCTOR OF THE WEB SERVER
Called from one place in starter.main(). */
server(String d, int p, boolean traceEnabled) {
D = d; // set absolute path of top level web site directory
P = p; // set port number to listen on for HTTP requests
L = new logger(traceEnabled); // create a log message handler
L.open(); // open the log files
}
/* LISTEN FOR REQUESTS AND WHEN ONE ARRIVES, DEAL WITH IT
Called from only one place in run(). */
private void listen() {
try { // see if there's an HTTP request present on Port 80
errmsg E = null; // start off with no error object
/* listen until an HTTP request appears on S [port 80] then, when one
does, allocate a session socket 's' [high-numbered session port]. */
Socket s = S.accept(); // returns after 60 seconds if no request
InputStream // set up an input stream for the allocated session socket
i = s.getInputStream();
/* Get the reference to the session socket's output stream and wrap
it in a data output stream so writeBytes(String) can be used to send
the content of the requested HTML file to the requestor. */
DataOutputStream
o = new DataOutputStream(s.getOutputStream());
String // get domain Name of client machine making the request
N = s.getInetAddress().getHostName();
/* De-comment the following 'if' statement if you want to restrict
the server to servicing requests only to "localhost" when Port 80
is open to the Internet [i.e. it is not blocked by a firewall]. */
// if(N.equals("localhost")) {
/* Create a new request object and, if data is present on the socket,
suck in the HTTP request from the session socket's byte stream. */
request Q = new request(L);
if(Q.suck(i)){
/* If the received HTTP request was malformed, or it was not a
simple HTTP/1.0 GET request [this server only implements the
GET request at the moment] then return the appropriate stan-
dard HTTP response message to the requesting server. */
if(!Q.valid())
E = new errmsg(400);
else if(!Q.canCope())
E = new errmsg(501);
else { // Else, set up the specification of the appropriate reply.
response R = new response(Q,D,L);
/* If the requested file does not exist or the file's permissions
do not include serving to the worldwide web, then return the appro-
priate standard HTTP response message to the requesting server. */
if(R.NotFound())
E = new errmsg(404);
else if(R.denied())
E = new errmsg(403);
else { // Else squirt the HTTP response header + file
R.barf(o); // down the session socket to the remote client
L.normal(Q,R,N); // and create a normal entry for this request
} // in the server log.
}
if(E != null) { // if an HTTP error occurredi
E.send(o,Q,L); // send an error message response to the browser
L.error(Q,E,N); // write an HTTP error entry in the server log
}
String // send details of this HTTP request to terminal (std out)
ps = new Date().toString()
+ " " + Q.getMN()
+ " " + Q.getMeth()
+ " " + Q.getName()
+ " from " + N;
if(E != null)
ps += " " + E.getHead();
System.out.println(ps);
}
// } // End of: only accept requests from localhost
o.close(); // Close the session socket's input and output
i.close(); // streams and the session socket itself when
s.close(); // the [final] request has been expedited.
}
/* An InterruptedIOException occurrs every time the method
ServerSocket.accept() returns a 'timed out' status, which
it does after 60 seconds if no request is present. */
catch(InterruptedIOException u) { }
/* Catch all other possible types of exception
and send them to the log message handler */
catch(Exception e) {
L.exception("listen(): " + e);
/* If the exception count on the server's run() thread ever becomes
too excessive, send Error Message 2 to the log file and also to
system.out [ie the terminal window] and stop the server thread. */
if(++EC > 100) {
L.exception(EM2);
System.out.println(EM2);
stop();
}
}
}
/* SET THE HTTP SERVER RUNNING
Called from only one place in stater.main(). */
public void start() {
if(T == null) { // if no thread yet created to run the server
L.start(D,P); // start the logger
T = new Thread(this); // create the run thread
T.start(); // set the run() method going
}
}
/* HALT THE HTTP SERVER:
Called from one place each in run() and destroy(). */
public void stop() {
if(T != null) { // if the server thread still exists
L.stop(D,P); // stop the logger
T = null; // destroy the server thread
}
}
/* DESTROY THE INSTANCE OF THE WEB SERVER:
Called from only one place in starter.main(). */
public void destroy() {
stop(); // stop the server thread
L.close(); // close the log files
L = null; // destroy the logger instance
}
/* RUN THE HTTP SERVER
Called from the Java Runtime System. */
public void run() {
try {
/* Create a new server socket S to listen on prescribed HTTP port.
Set a time limit of 1 minute for a complete request to arrive. */
S = new ServerSocket(P);
S.setSoTimeout(60000);
while(T != null) // For as long as it continues to exist,
listen(); // keep this thread in an infinite loop.
/* Catch any exception that may occur while the thread is running and send
them to the log message handler. Send Error Message 1 to the log file and
also to system.out ie the terminal window. Then stop the server thread. */
} catch(Exception e) {
L.exception("run(): " + e);
L.exception(EM1);
System.out.println(EM1);
stop();
}
}
}
/* 6) THE MAIN CLASS ----------------------------------------------------------
Contains main() and is thus called only by the operating system.
Its function is to enable the user to start the web server from
the terminal command line. */
public class webserver {
private static boolean
traceOn = false; // default is no session log
private static String
d = "/home/rob/Private/website", // default web site path
s = "You need to specify the following parameters on the command line:\n"
+ "1) Absolute path to top-level directory of web site (mandatory).\n"
+ "2) Listening port for HTTP requests (default = 80).\n"
+ "3) Optional switch \'-trace\' to enable log of session port io.\n"
+ "If you specify no parameters, the following defaults are used:\n"
+ "Document path: /home/rob/Private/website\n"
+ "Port Number 80\n"
+ "Trace off\n"
+ "YOU MUST RUN THIS PROGRAM AS ROOT EG sudo java starter\n"
+ "OR AS A MEMBER OF A GROUP WITH PORT ACCESS PRIVILEGES.\n";
private static int
p = 80; // default port number for HTTP servers
public static void main(String args[]) throws IOException {
int x = args.length; // number of arguments on command line
if(x > 0) { // provided there is at least one command line argument
if(args[0].equals("-help")) { // If the first argument is '-help'
System.out.print(s); // print the above help text in the
return; // terminal and exit.
}
else { // Else, it isn't the '-help' switch, so
d = args[0]; // assume it is the path to the top-level
// directory from which to serve.
if(x > 1) // If there is a second command line argument,
// assume it is a port number overriding the default Port 80.
p = Integer.parseInt(args[1]);
/* if there is a third command line argument, assume it
is the -trace switch, so enable the session log file. */
if(x > 2 && args[2].equalsIgnoreCase("-trace"))
traceOn = true;
}
}
// Create an instance 'R' of the web server
server R = new server(d,p,traceOn);
R.start(); // start the server thread
System.out.println(
"Web Server running:\ndocument root: "
+ d + "\nlistening on port: " + p
);
System.in.read(); // wait for input to continue...
R.stop(); // stop the server
R.destroy(); // destroy server instance
System.out.println("Server shutting down...");
}
}