RiverRat  - An MIT iCampus project

http://web.mit.edu/riverrat/

BasicServer.java

package riverrat;

import org.xml.sax.*;
import org.xml.sax.helpers.*;

import java.net.*;
import java.io.*;
import java.util.*;
import javax.comm.*;

public class BasicServer extends DefaultHandler implements Runnable {
        protected int port = 8080;
        
        protected ServerSocket serverSocket;
        
        protected Socket clientSocket;
        
        protected OutputStream networkOutputStream;
        
        protected InputStream networkInputStream;
        
        protected int fElementDepth;
        
        protected Locator fLocator;
        
        protected PrintWriter sout;
        
        protected static final boolean DEFAULT_CANONICAL = true;
        
        public BasicServer() {
                serverSocket = null;
                sout = null;
        }
        
        public BasicServer(int newport) {
                try {
                        serverSocket = new ServerSocket(newport);
                } catch(IOException e) {
                        System.err.println("Could not listen on port: "+newport);
                        System.exit(1);
                }
                sout = null;
        }
        
        protected void openConnection() {
                if(serverSocket == null) {
                        try {
                                serverSocket = new ServerSocket(port);
                        } catch(IOException e) {
                                System.err.println("Could not listen on port: "+port);
                        }
                }
                try {
                        System.out.println("Waiting for a connection.");
                        clientSocket = serverSocket.accept();
                } catch(IOException e) {
                        System.err.println("Error trying to accept connection.");
                        System.exit(1);
                }
                setPrintWriter();
        }
        
        protected void setPrintWriter() {
                try {
                        System.out.println("Client connected "+clientSocket);
                        networkOutputStream = clientSocket.getOutputStream();
                        networkInputStream = clientSocket.getInputStream();
                } catch(IOException e) {
                        System.err.println("Error trying to get I/O stream from socket.");
                }
                sout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(networkOutputStream)));
        }
        
        protected void closeConnection() {
                sout.close();
                try {
                        networkInputStream.close();
                        networkOutputStream.close();
                        clientSocket.close();
                } catch(IOException e) {
                        System.err.println("Error closing connection.");
                        System.exit(1);
                }
        }
        
        protected void normalizeAndPrint(String s, boolean isAttValue) {
                //if string is null, it's length is 0, otherwise get length
                int length = (s != null) ? s.length() : 0;
                for(int i = 0; i < length; i++) {
                        char c = s.charAt(i);
                        normalizeAndPrint(c, isAttValue);
                }
        }
        
        protected void normalizeAndPrint(char[] ch, int offset, int length, boolean isAttValue) {
                for(int i = 0; i < length; i++) {
                        normalizeAndPrint(ch[offset + i], isAttValue);
                }
        }
        
        protected void normalizeAndPrint(char c, boolean isAttValue) {
                switch (c) {
                        case '<': { sout.print("&lt;"); break; }
                        case '>': { sout.print("&gt;"); break; }
                        case '&': { sout.print("&amp;"); break; }
                        case '"': {
                                if (isAttValue) {
                                        sout.print("&quot;");
                                } else {
                                        sout.print("\"");
                                }
                                break;
                        }
                        case '\r': { sout.print("&#xD;"); break; }
                        case '\n': {
                                if (DEFAULT_CANONICAL) {
                                        sout.print("&#xA;");
                                        break;
                                }
                                // else, default print char
                        }
                        default: {
                                if (((c >= 0x01 && c <= 0x1F && c != 0x09 && c != 0x0A) 
                                                        || (c >= 0x7F && c <= 0x9F) || c == 0x2028)
                                                        || isAttValue && (c == 0x09 || c == 0x0A)) {
                                        sout.print("&#x");
                                        sout.print(Integer.toHexString(c).toUpperCase());
                                        sout.print(";");
                                } else {
                                        sout.print(c);
                                }        
                        }
                }
        }
                
        public void startDocument()   {
                //System.out.println("Starting document in BasicServer");
                fElementDepth = 0;
        }
        
        public void startElement(String uri, String local, String raw, Attributes attrs){
                //System.out.println("Starting element in BasicServer");
                //System.out.println("---rawname is "+raw);
                fElementDepth++;
                sout.print('<');
                sout.print(raw);
                if(attrs != null) {
                        //attrs = sortAttributes(attrs);
                        for(int i = 0; i < attrs.getLength(); i++) {
                                sout.print(' ');
                                sout.print(attrs.getQName(i));
                                sout.print("=\"");
                                normalizeAndPrint(attrs.getValue(i), true);
                                sout.print('"');
                        }
                }
                sout.print('>');
                sout.flush();
        }
        
        public void endElement(String uri, String local, String raw)  {
                //System.out.println("Ending element in BasicServer");
                //System.out.println("---rawname is "+raw);
                fElementDepth--;
                sout.print("</");
                sout.print(raw);
                sout.print('>');
                sout.flush();
        }
        
        public void endDocument() {
                //System.out.println("Ending document in BasicServer");
                sout.print("\n");
        }
        
        public void warning(SAXParseException ex) throws SAXException {
                System.err.println("Warning: "+ex);
        }
        
        public void error(SAXParseException ex) throws SAXException {
                System.err.println("Error: "+ex);
        }
        
        public void fatalError(SAXParseException ex) throws SAXException {
                System.err.println("Fatal Error: "+ex);
        }
        
        public void setSocket(Socket s) {
                clientSocket = s;
                setPrintWriter();
        }
        
        public void run() {
                if(clientSocket == null) {
                        openConnection(); //openConnection is a blocking method
                }
                mainServer();
                closeConnection();
        }
        
        public void mainServer() {
                sout.println("wheeee... connected!");
                while(true) {
                        try {
                                Thread.sleep(1000);
                        } catch(InterruptedException e) {
                        }
                        sout.print("badger-");
                }
        }
        
        public static void main(String args[]) {
                
                //initialize server
                BasicServer testserver = new BasicServer();
                Thread serverthread = new Thread(testserver);
                serverthread.start();
                
                while(true) {
                        System.out.println("This is the main loop.");
                        try {
                                Thread.sleep(10000);
                        } catch(InterruptedException e) {
                                System.err.println("Interrupted.");
                        }
                }
        }
}

 

Brought to you by the RiverRat team.