sun.misc.BASE64Decoder base64Dec = new sun.misc.BASE64Decoder();    // for sessions	int uniqer;    HttpSessionContextImpl sessions;		static int expiredIn;	protected Hashtable arguments;	     /// Constructor.    public Serve( Hashtable arguments, PrintStream logStream )    {        this.arguments = arguments;        this.logStream = logStream;        registry = new PathTreeDictionary();	    realms = new PathTreeDictionary();        attributes = new Hashtable();		sessions =  new HttpSessionContextImpl();		setAccessLogged();		expiredIn = arguments.get(ARG_SESSION_TIMEOUT) != null?					((Integer)arguments.get(ARG_SESSION_TIMEOUT)).intValue():DEF_SESSION_TIMEOUT;		port = arguments.get(ARG_PORT) != null?					((Integer)arguments.get(ARG_PORT)).intValue():DEF_PORT;    }        public Serve()    {        this( new Hashtable(), System.err );    }        	void setAccessLogged() {		String logflags = (String)arguments.get(ARG_LOG_OPTIONS);		if (logflags != null) {			useAccLog = true;			showUserAgent = logflags.indexOf('A') >= 0;			showReferer = logflags.indexOf('R') >= 0;		}	}		boolean isAccessLogged() {		return useAccLog;	}	boolean isShowReferer() {		return showReferer;	}	boolean isShowUserAgent() {		return showUserAgent;	}	    /// Register a Servlet by class name.  Registration consists of a URL    // pattern, which can contain wildcards, and the class name of the Servlet    // to launch when a matching URL comes in.  Patterns are checked for    // matches in the order they were added, and only the first match is run.    public void addServlet( String urlPat, String className )    {        addServlet( urlPat, className, (Hashtable)null );    }        public void addServlet( String urlPat, String className,  Hashtable initParams)    {                // Check if we're allowed to make one of these.        SecurityManager security = System.getSecurityManager();        if ( security != null )        {            int i = className.lastIndexOf( '.' );            if ( i != -1 )            {                security.checkPackageAccess(                    className.substring( 0, i ) );                security.checkPackageDefinition(                    className.substring( 0, i ) );            }        }                // Make a new one.        try        {            addServlet( urlPat, (Servlet) Class.forName( className ).newInstance(), initParams );            return;        }        catch ( ClassNotFoundException e )        {            log( "Class not found: " + className );        }        catch ( ClassCastException e )        {            log( "Class cast problem: " + e.getMessage() );        }        catch ( InstantiationException e )        {            log( "Instantiation problem: " + e.getMessage() );        }        catch ( IllegalAccessException e )        {            log( "Illegal class access: " + e.getMessage() );        }        catch ( Exception e )        {            log( "Unexpected problem creating servlet: " + e, e );        }    }        /// Register a Servlet.  Registration consists of a URL pattern,    // which can contain wildcards, and the Servlet to    // launch when a matching URL comes in.  Patterns are checked for    // matches in the order they were added, and only the first match is run.    public void addServlet( String urlPat, Servlet servlet )    {        addServlet( urlPat, servlet, (Hashtable)null);    }    public void addServlet( String urlPat, Servlet servlet, Hashtable initParams )    {        try        {            servlet.init( new ServeConfig( (ServletContext) this, initParams, urlPat ) );            registry.put( urlPat, servlet );        }        catch ( ServletException e )        {            log( "Problem initializing servlet: " + e );        }    }        /// Register a standard set of Servlets.  These will return    // files or directory listings, and run CGI programs, much like a    // standard HTTP server.    // <P>    // Because of the pattern checking order, this should be called    // <B>after</B> you've added any custom Servlets.    // <P>    // The current set of default servlet mappings:    // <UL>    // <LI> If enabled, *.cgi goes to CgiServlet, and gets run as a CGI program.    // <LI> * goes to FileServlet, and gets served up as a file or directory.    // </UL>    // @param cgi whether to run CGI programs	// TODO: provide user specified CGI directory	public void addDefaultServlets( String cgi ) { 		if ( cgi != null )			addServlet( "/"+cgi, new Acme.Serve.CgiServlet() );		addServlet( "/", new Acme.Serve.FileServlet() );	}        /// Register a standard set of Servlets, with throttles.    // @param cgi whether to run CGI programs    // @param throttles filename to read FileServlet throttle settings from	public void addDefaultServlets( String cgi, String throttles ) throws IOException { 		if ( cgi != null )			addServlet( "/"+cgi, new Acme.Serve.CgiServlet() );		addServlet( "/", new Acme.Serve.FileServlet( throttles ) );	}	        // Run the server.  Returns only on errors.    boolean running = true;    public void serve()    {        final ServerSocket serverSocket;        try        {            serverSocket = createServerSocket();         }        catch ( IOException e )        {            log( "Server socket: " + e );            return;        }		hostName = serverSocket.getInetAddress().getHostName();        new Thread(new Runnable() {            public void run() {                BufferedReader in = new BufferedReader(new InputStreamReader(System.in));                String line;                while (true) {                    try {                        System.out.print("Press \"q\" <ENTER>, for gracefully stopping the server ");                        line = in.readLine();                        if (line != null && line.length() > 0 && line.charAt(0) == 'q') {                            running = false;							serverSocket.close();                            break;                        }                    } catch(IOException e) {                    }                }				            }        }, "Stop Monitor").start();		if (expiredIn > 0) {			Thread t = new Thread(new Runnable() {				public void run() {					while ( running ) {						try {							Thread.sleep(expiredIn*60*1000);						} catch(InterruptedException ie) {						}						Enumeration e = sessions.keys();						while(e.hasMoreElements()) {							Object sid = e.nextElement();							if (sid != null) {								AcmeSession as = (AcmeSession)sessions.get(sid);								if (as != null 									&& (as.getMaxInactiveInterval()*1000 < System.currentTimeMillis() - as.getLastAccessedTime()									|| !as.isValid())) {  //log("sesion is timeouted, last accessed " + new Date(as.getLastAccessedTime()));									// hashtable is synchronized impl									as = (AcmeSession)sessions.remove(sid);									if (as != null && as.isValid()) 										try {											as.invalidate();										} catch(IllegalStateException ise) {																					}								}							}						}					}				}				}, "Session cleaner");			t.setPriority(Thread.MIN_PRIORITY);			t.start();		} else 			expiredIn = -expiredIn;        System.out.println("WebServer :"+port+" is ready.");        try        {            while ( running )            {                Socket socket = serverSocket.accept();                new ServeConnection( socket, this );            }        }        catch ( IOException e )        {            log( "Accept: " + e );        }        finally        {            try            {                serverSocket.close();            }            catch ( IOException e ) {}            destroyAllServlets();        }    }		public static interface SocketFactory {		public ServerSocket createSocket(Hashtable arguments) throws IOException, IllegalArgumentException;	}		protected ServerSocket createServerSocket() throws IOException {		String socketFactoryClass = (String)arguments.get(ARG_SOCKET_FACTORY);		if (socketFactoryClass != null) 		try {			return ((SocketFactory)Class.forName(socketFactoryClass).newInstance() ).createSocket(arguments);		} catch(Exception e) {			System.err.println("Couldn't create custom socket factory "+socketFactoryClass							   +" or call creation method. Standard socket will be created. "+e);		}		return new ServerSocket( port, 1000 );	}        // Methods from ServletContext.           /// Gets a servlet by name.    // @param name the servlet name    // @return null if the servlet does not exist	public Servlet getServlet( String name ) { 		try {		   return (Servlet) ((Object[])registry.get( name ))[0];		} catch(NullPointerException npe) {			return null;		}    }        /// Enumerates the servlets in this context (server). Only servlets that    // are accesible will be returned.  This enumeration always includes the    // servlet itself.    public Enumeration getServlets()    {        return registry.elements();    }        /// Enumerates the names of the servlets in this context (server). Only    // servlets that are accesible will be returned.  This enumeration always    // includes the servlet itself.    public Enumeration getServletNames()    {        return registry.keys();    }    /// Destroys all currently-loaded servlets.    public void destroyAllServlets()    {        Enumeration en = registry.elements();        while ( en.hasMoreElements() )        {            Servlet servlet = (Servlet) en.nextElement();             servlet.destroy();        }	registry = new PathTreeDictionary();        // invalidate all sessions?    }        public void setMappingTable(PathTreeDictionary mappingtable)    {        this.mappingtable = mappingtable;    }        public void setRealms(PathTreeDictionary realms)    {        this.realms = realms;    }		Object getSession(String id) {		   return sessions.get(id);	}		HttpSession createSession() {		HttpSession result = new AcmeSession(generateSessionId(), expiredIn*60, this, sessions);		sessions.put(result.getId(), result);		return result;	}		void removeSession(String id) {		sessions.remove(id);	}	    /// Write information to the servlet log.    // @param message the message to log    public void log( String message )    {        Date date = new Date( System.currentTimeMillis() );        logStream.println( "[" + date.toString() + "] " + message );    }        public void log(String message, Throwable throwable)    {        StringWriter sw=new StringWriter();        throwable.printStackTrace(new PrintWriter(sw));        log(message+'\n'+sw);    }        /// Write a stack trace to the servlet log.    // @param exception where to get the stack trace    // @param message the message to log    public void log( Exception exception, String message )    {        StringWriter sw=new StringWriter();        exception.printStackTrace(new PrintWriter(sw));        log( ""+sw+'\n'+message );    }        /// Applies alias rules to the specified virtual path and returns the    // corresponding real path.  It returns null if the translation    // cannot be performed.    // @param path the path to be translated	public String getRealPath( String path ) { 		//System.err.print("["+path+"]->[");		try { // this code only for debug purpose			// check if it absolute URL			URL url = new URL(path);			path = url.getFile();			new Exception("URL "+path+" specified in getRealPath").printStackTrace();			path = null;		} catch (MalformedURLException mfue) {		}		if (mappingtable != null) { 			// try find first sub-path			Object [] os = mappingtable.get(path);			if (os[0] == null)				return null;			int slpos = ((Integer)os[1]).intValue();			if (path.length() > slpos && slpos > 0) {				path = path.substring(slpos+1);			} else if (path.length() > 0) {				char s = path.charAt(0);				if(s == '/' || s == '\\')					path = path.substring(1);			}			//System.err.println("Base:"+((String)os[0])+"\npath="+path+"\n pos="+slpos+']');			return ((String)os[0])+File.separatorChar+path;		}		return path;	}