Back to index...

	/*
	* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.net.httpserver;

	import java.net.*;
	import java.io.*;
	import java.nio.channels.*;
	import java.util.*;
	import java.util.concurrent.*;
	import java.util.logging.Logger;
	import java.util.logging.Level;
	import javax.net.ssl.*;
	import com.sun.net.httpserver.*;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import sun.net.httpserver.HttpConnection.State;

	/**
	* Provides implementation for both HTTP and HTTPS
	*/
	class ServerImpl implements TimeSource {

	private String protocol;
	private boolean https;
	private Executor executor;
	private HttpsConfigurator httpsConfig;
	private SSLContext sslContext;
	private ContextList contexts;
	private InetSocketAddress address;
	private ServerSocketChannel schan;
	private Selector selector;
	private SelectionKey listenerKey;
	private Set<HttpConnection> idleConnections;
	private Set<HttpConnection> allConnections;
	/* following two are used to keep track of the times
	* when a connection/request is first received
	* and when we start to send the response
	*/
	private Set<HttpConnection> reqConnections;
	private Set<HttpConnection> rspConnections;
	private List<Event> events;
	private Object lolock = new Object();
	private volatile boolean finished = false;
	private volatile boolean terminating = false;
	private boolean bound = false;
	private boolean started = false;
	private volatile long time; /* current time */
	private volatile long subticks = 0;
	private volatile long ticks; /* number of clock ticks since server started */
	private HttpServer wrapper;

	final static int CLOCK_TICK = ServerConfig.getClockTick();
	final static long IDLE_INTERVAL = ServerConfig.getIdleInterval();
	final static int MAX_IDLE_CONNECTIONS = ServerConfig.getMaxIdleConnections();
	final static long TIMER_MILLIS = ServerConfig.getTimerMillis ();
	final static long MAX_REQ_TIME=getTimeMillis(ServerConfig.getMaxReqTime());
	final static long MAX_RSP_TIME=getTimeMillis(ServerConfig.getMaxRspTime());
	final static boolean timer1Enabled = MAX_REQ_TIME != -1 \|\| MAX_RSP_TIME != -1;

	private Timer timer, timer1;
	private Logger logger;

	ServerImpl (
	HttpServer wrapper, String protocol, InetSocketAddress addr, int backlog
	) throws IOException {

	this.protocol = protocol;
	this.wrapper = wrapper;
	this.logger = Logger.getLogger ("com.sun.net.httpserver");
	ServerConfig.checkLegacyProperties (logger);
	https = protocol.equalsIgnoreCase ("https");
	this.address = addr;
	contexts = new ContextList();
	schan = ServerSocketChannel.open();
	if (addr != null) {
	ServerSocket socket = schan.socket();
	socket.bind (addr, backlog);
	bound = true;
	}
	selector = Selector.open ();
	schan.configureBlocking (false);
	listenerKey = schan.register (selector, SelectionKey.OP_ACCEPT);
	dispatcher = new Dispatcher();
	idleConnections = Collections.synchronizedSet (new HashSet<HttpConnection>());
	allConnections = Collections.synchronizedSet (new HashSet<HttpConnection>());
	reqConnections = Collections.synchronizedSet (new HashSet<HttpConnection>());
	rspConnections = Collections.synchronizedSet (new HashSet<HttpConnection>());
	time = System.currentTimeMillis();
	timer = new Timer ("server-timer", true);
	timer.schedule (new ServerTimerTask(), CLOCK_TICK, CLOCK_TICK);
	if (timer1Enabled) {
	timer1 = new Timer ("server-timer1", true);
	timer1.schedule (new ServerTimerTask1(),TIMER_MILLIS,TIMER_MILLIS);
	logger.config ("HttpServer timer1 enabled period in ms: "+TIMER_MILLIS);
	logger.config ("MAX_REQ_TIME: "+MAX_REQ_TIME);
	logger.config ("MAX_RSP_TIME: "+MAX_RSP_TIME);
	}
	events = new LinkedList<Event>();
	logger.config ("HttpServer created "+protocol+" "+ addr);
	}

	public void bind (InetSocketAddress addr, int backlog) throws IOException {
	if (bound) {
	throw new BindException ("HttpServer already bound");
	}
	if (addr == null) {
	throw new NullPointerException ("null address");
	}
	ServerSocket socket = schan.socket();
	socket.bind (addr, backlog);
	bound = true;
	}

	public void start () {
	if (!bound \|\| started \|\| finished) {
	throw new IllegalStateException ("server in wrong state");
	}
	if (executor == null) {
	executor = new DefaultExecutor();
	}
	Thread t = new Thread (dispatcher);
	started = true;
	t.start();
	}

	public void setExecutor (Executor executor) {
	if (started) {
	throw new IllegalStateException ("server already started");
	}
	this.executor = executor;
	}

	private static class DefaultExecutor implements Executor {
	public void execute (Runnable task) {
	task.run();
	}
	}

	public Executor getExecutor () {
	return executor;
	}

	public void setHttpsConfigurator (HttpsConfigurator config) {
	if (config == null) {
	throw new NullPointerException ("null HttpsConfigurator");
	}
	if (started) {
	throw new IllegalStateException ("server already started");
	}
	this.httpsConfig = config;
	sslContext = config.getSSLContext();
	}

	public HttpsConfigurator getHttpsConfigurator () {
	return httpsConfig;
	}

	public void stop (int delay) {
	if (delay < 0) {
	throw new IllegalArgumentException ("negative delay parameter");
	}
	terminating = true;
	try { schan.close(); } catch (IOException e) {}
	selector.wakeup();
	long latest = System.currentTimeMillis() + delay * 1000;
	while (System.currentTimeMillis() < latest) {
	delay();
	if (finished) {
	break;
	}
	}
	finished = true;
	selector.wakeup();
	synchronized (allConnections) {
	for (HttpConnection c : allConnections) {
	c.close();
	}
	}
	allConnections.clear();
	idleConnections.clear();
	timer.cancel();
	if (timer1Enabled) {
	timer1.cancel();
	}
	}

	Dispatcher dispatcher;

	public synchronized HttpContextImpl createContext (String path, HttpHandler handler) {
	if (handler == null \|\| path == null) {
	throw new NullPointerException ("null handler, or path parameter");
	}
	HttpContextImpl context = new HttpContextImpl (protocol, path, handler, this);
	contexts.add (context);
	logger.config ("context created: " + path);
	return context;
	}

	public synchronized HttpContextImpl createContext (String path) {
	if (path == null) {
	throw new NullPointerException ("null path parameter");
	}
	HttpContextImpl context = new HttpContextImpl (protocol, path, null, this);
	contexts.add (context);
	logger.config ("context created: " + path);
	return context;
	}

	public synchronized void removeContext (String path) throws IllegalArgumentException {
	if (path == null) {
	throw new NullPointerException ("null path parameter");
	}
	contexts.remove (protocol, path);
	logger.config ("context removed: " + path);
	}

	public synchronized void removeContext (HttpContext context) throws IllegalArgumentException {
	if (!(context instanceof HttpContextImpl)) {
	throw new IllegalArgumentException ("wrong HttpContext type");
	}
	contexts.remove ((HttpContextImpl)context);
	logger.config ("context removed: " + context.getPath());
	}

	public InetSocketAddress getAddress() {
	return AccessController.doPrivileged(
	new PrivilegedAction<InetSocketAddress>() {
	public InetSocketAddress run() {
	return
	(InetSocketAddress)schan.socket()
	.getLocalSocketAddress();
	}
	});
	}

	Selector getSelector () {
	return selector;
	}

	void addEvent (Event r) {
	synchronized (lolock) {
	events.add (r);
	selector.wakeup();
	}
	}

	/* main server listener task */

	class Dispatcher implements Runnable {

	private void handleEvent (Event r) {
	ExchangeImpl t = r.exchange;
	HttpConnection c = t.getConnection();
	try {
	if (r instanceof WriteFinishedEvent) {

	int exchanges = endExchange();
	if (terminating && exchanges == 0) {
	finished = true;
	}
	responseCompleted (c);
	LeftOverInputStream is = t.getOriginalInputStream();
	if (!is.isEOF()) {
	t.close = true;
	}
	if (t.close \|\| idleConnections.size() >= MAX_IDLE_CONNECTIONS) {
	c.close();
	allConnections.remove (c);
	} else {
	if (is.isDataBuffered()) {
	/* don't re-enable the interestops, just handle it */
	requestStarted (c);
	handle (c.getChannel(), c);
	} else {
	connsToRegister.add (c);
	}
	}
	}
	} catch (IOException e) {
	logger.log (
	Level.FINER, "Dispatcher (1)", e
	);
	c.close();
	}
	}

	final LinkedList<HttpConnection> connsToRegister =
	new LinkedList<HttpConnection>();

	void reRegister (HttpConnection c) {
	/* re-register with selector */
	try {
	SocketChannel chan = c.getChannel();
	chan.configureBlocking (false);
	SelectionKey key = chan.register (selector, SelectionKey.OP_READ);
	key.attach (c);
	c.selectionKey = key;
	c.time = getTime() + IDLE_INTERVAL;
	idleConnections.add (c);
	} catch (IOException e) {
	dprint(e);
	logger.log(Level.FINER, "Dispatcher(8)", e);
	c.close();
	}
	}

	public void run() {
	while (!finished) {
	try {
	List<Event> list = null;
	synchronized (lolock) {
	if (events.size() > 0) {
	list = events;
	events = new LinkedList<Event>();
	}
	}

	if (list != null) {
	for (Event r: list) {
	handleEvent (r);
	}
	}

	for (HttpConnection c : connsToRegister) {
	reRegister(c);
	}
	connsToRegister.clear();

	selector.select(1000);

	/* process the selected list now */
	Set<SelectionKey> selected = selector.selectedKeys();
	Iterator<SelectionKey> iter = selected.iterator();
	while (iter.hasNext()) {
	SelectionKey key = iter.next();
	iter.remove ();
	if (key.equals (listenerKey)) {
	if (terminating) {
	continue;
	}
	SocketChannel chan = schan.accept();

	// Set TCP_NODELAY, if appropriate
	if (ServerConfig.noDelay()) {
	chan.socket().setTcpNoDelay(true);
	}

	if (chan == null) {
	continue; /* cancel something ? */
	}
	chan.configureBlocking (false);
	SelectionKey newkey = chan.register (selector, SelectionKey.OP_READ);
	HttpConnection c = new HttpConnection ();
	c.selectionKey = newkey;
	c.setChannel (chan);
	newkey.attach (c);
	requestStarted (c);
	allConnections.add (c);
	} else {
	try {
	if (key.isReadable()) {
	boolean closed;
	SocketChannel chan = (SocketChannel)key.channel();
	HttpConnection conn = (HttpConnection)key.attachment();

	key.cancel();
	chan.configureBlocking (true);
	if (idleConnections.remove(conn)) {
	// was an idle connection so add it
	// to reqConnections set.
	requestStarted (conn);
	}
	handle (chan, conn);
	} else {
	assert false;
	}
	} catch (CancelledKeyException e) {
	handleException(key, null);
	} catch (IOException e) {
	handleException(key, e);
	}
	}
	}
	// call the selector just to process the cancelled keys
	selector.selectNow();
	} catch (IOException e) {
	logger.log (Level.FINER, "Dispatcher (4)", e);
	} catch (Exception e) {
	logger.log (Level.FINER, "Dispatcher (7)", e);
	}
	}
	try {selector.close(); } catch (Exception e) {}
	}

	private void handleException (SelectionKey key, Exception e) {
	HttpConnection conn = (HttpConnection)key.attachment();
	if (e != null) {
	logger.log (Level.FINER, "Dispatcher (2)", e);
	}
	closeConnection(conn);
	}

	public void handle (SocketChannel chan, HttpConnection conn)
	throws IOException
	{
	try {
	Exchange t = new Exchange (chan, protocol, conn);
	executor.execute (t);
	} catch (HttpError e1) {
	logger.log (Level.FINER, "Dispatcher (4)", e1);
	closeConnection(conn);
	} catch (IOException e) {
	logger.log (Level.FINER, "Dispatcher (5)", e);
	closeConnection(conn);
	}
	}
	}

	static boolean debug = ServerConfig.debugEnabled ();

	static synchronized void dprint (String s) {
	if (debug) {
	System.out.println (s);
	}
	}

	static synchronized void dprint (Exception e) {
	if (debug) {
	System.out.println (e);
	e.printStackTrace();
	}
	}

	Logger getLogger () {
	return logger;
	}

	private void closeConnection(HttpConnection conn) {
	conn.close();
	allConnections.remove(conn);
	switch (conn.getState()) {
	case REQUEST:
	reqConnections.remove(conn);
	break;
	case RESPONSE:
	rspConnections.remove(conn);
	break;
	case IDLE:
	idleConnections.remove(conn);
	break;
	}
	assert !reqConnections.remove(conn);
	assert !rspConnections.remove(conn);
	assert !idleConnections.remove(conn);
	}

	/* per exchange task */

	class Exchange implements Runnable {
	SocketChannel chan;
	HttpConnection connection;
	HttpContextImpl context;
	InputStream rawin;
	OutputStream rawout;
	String protocol;
	ExchangeImpl tx;
	HttpContextImpl ctx;
	boolean rejected = false;

	Exchange (SocketChannel chan, String protocol, HttpConnection conn) throws IOException {
	this.chan = chan;
	this.connection = conn;
	this.protocol = protocol;
	}

	public void run () {
	/* context will be null for new connections */
	context = connection.getHttpContext();
	boolean newconnection;
	SSLEngine engine = null;
	String requestLine = null;
	SSLStreams sslStreams = null;
	try {
	if (context != null ) {
	this.rawin = connection.getInputStream();
	this.rawout = connection.getRawOutputStream();
	newconnection = false;
	} else {
	/* figure out what kind of connection this is */
	newconnection = true;
	if (https) {
	if (sslContext == null) {
	logger.warning ("SSL connection received. No https contxt created");
	throw new HttpError ("No SSL context established");
	}
	sslStreams = new SSLStreams (ServerImpl.this, sslContext, chan);
	rawin = sslStreams.getInputStream();
	rawout = sslStreams.getOutputStream();
	engine = sslStreams.getSSLEngine();
	connection.sslStreams = sslStreams;
	} else {
	rawin = new BufferedInputStream(
	new Request.ReadStream (
	ServerImpl.this, chan
	));
	rawout = new Request.WriteStream (
	ServerImpl.this, chan
	);
	}
	connection.raw = rawin;
	connection.rawout = rawout;
	}
	Request req = new Request (rawin, rawout);
	requestLine = req.requestLine();
	if (requestLine == null) {
	/* connection closed */
	closeConnection(connection);
	return;
	}
	int space = requestLine.indexOf (' ');
	if (space == -1) {
	reject (Code.HTTP_BAD_REQUEST,
	requestLine, "Bad request line");
	return;
	}
	String method = requestLine.substring (0, space);
	int start = space+1;
	space = requestLine.indexOf(' ', start);
	if (space == -1) {
	reject (Code.HTTP_BAD_REQUEST,
	requestLine, "Bad request line");
	return;
	}
	String uriStr = requestLine.substring (start, space);
	URI uri = new URI (uriStr);
	start = space+1;
	String version = requestLine.substring (start);
	Headers headers = req.headers();
	String s = headers.getFirst ("Transfer-encoding");
	long clen = 0L;
	if (s !=null && s.equalsIgnoreCase ("chunked")) {
	clen = -1L;
	} else {
	s = headers.getFirst ("Content-Length");
	if (s != null) {
	clen = Long.parseLong(s);
	}
	if (clen == 0) {
	requestCompleted (connection);
	}
	}
	ctx = contexts.findContext (protocol, uri.getPath());
	if (ctx == null) {
	reject (Code.HTTP_NOT_FOUND,
	requestLine, "No context found for request");
	return;
	}
	connection.setContext (ctx);
	if (ctx.getHandler() == null) {
	reject (Code.HTTP_INTERNAL_ERROR,
	requestLine, "No handler for context");
	return;
	}
	tx = new ExchangeImpl (
	method, uri, req, clen, connection
	);
	String chdr = headers.getFirst("Connection");
	Headers rheaders = tx.getResponseHeaders();

	if (chdr != null && chdr.equalsIgnoreCase ("close")) {
	tx.close = true;
	}
	if (version.equalsIgnoreCase ("http/1.0")) {
	tx.http10 = true;
	if (chdr == null) {
	tx.close = true;
	rheaders.set ("Connection", "close");
	} else if (chdr.equalsIgnoreCase ("keep-alive")) {
	rheaders.set ("Connection", "keep-alive");
	int idle=(int)(ServerConfig.getIdleInterval()/1000);
	int max=ServerConfig.getMaxIdleConnections();
	String val = "timeout="+idle+", max="+max;
	rheaders.set ("Keep-Alive", val);
	}
	}

	if (newconnection) {
	connection.setParameters (
	rawin, rawout, chan, engine, sslStreams,
	sslContext, protocol, ctx, rawin
	);
	}
	/* check if client sent an Expect 100 Continue.
	* In that case, need to send an interim response.
	* In future API may be modified to allow app to
	* be involved in this process.
	*/
	String exp = headers.getFirst("Expect");
	if (exp != null && exp.equalsIgnoreCase ("100-continue")) {
	logReply (100, requestLine, null);
	sendReply (
	Code.HTTP_CONTINUE, false, null
	);
	}
	/* uf is the list of filters seen/set by the user.
	* sf is the list of filters established internally
	* and which are not visible to the user. uc and sc
	* are the corresponding Filter.Chains.
	* They are linked together by a LinkHandler
	* so that they can both be invoked in one call.
	*/
	List<Filter> sf = ctx.getSystemFilters();
	List<Filter> uf = ctx.getFilters();

	Filter.Chain sc = new Filter.Chain(sf, ctx.getHandler());
	Filter.Chain uc = new Filter.Chain(uf, new LinkHandler (sc));

	/* set up the two stream references */
	tx.getRequestBody();
	tx.getResponseBody();
	if (https) {
	uc.doFilter (new HttpsExchangeImpl (tx));
	} else {
	uc.doFilter (new HttpExchangeImpl (tx));
	}

	} catch (IOException e1) {
	logger.log (Level.FINER, "ServerImpl.Exchange (1)", e1);
	closeConnection(connection);
	} catch (NumberFormatException e3) {
	reject (Code.HTTP_BAD_REQUEST,
	requestLine, "NumberFormatException thrown");
	} catch (URISyntaxException e) {
	reject (Code.HTTP_BAD_REQUEST,
	requestLine, "URISyntaxException thrown");
	} catch (Exception e4) {
	logger.log (Level.FINER, "ServerImpl.Exchange (2)", e4);
	closeConnection(connection);
	}
	}

	/* used to link to 2 or more Filter.Chains together */

	class LinkHandler implements HttpHandler {
	Filter.Chain nextChain;

	LinkHandler (Filter.Chain nextChain) {
	this.nextChain = nextChain;
	}

	public void handle (HttpExchange exchange) throws IOException {
	nextChain.doFilter (exchange);
	}
	}

	void reject (int code, String requestStr, String message) {
	rejected = true;
	logReply (code, requestStr, message);
	sendReply (
	code, false, "<h1>"+code+Code.msg(code)+"</h1>"+message
	);
	closeConnection(connection);
	}

	void sendReply (
	int code, boolean closeNow, String text)
	{
	try {
	StringBuilder builder = new StringBuilder (512);
	builder.append ("HTTP/1.1 ")
	.append (code).append (Code.msg(code)).append ("\r\n");

	if (text != null && text.length() != 0) {
	builder.append ("Content-Length: ")
	.append (text.length()).append ("\r\n")
	.append ("Content-Type: text/html\r\n");
	} else {
	builder.append ("Content-Length: 0\r\n");
	text = "";
	}
	if (closeNow) {
	builder.append ("Connection: close\r\n");
	}
	builder.append ("\r\n").append (text);
	String s = builder.toString();
	byte[] b = s.getBytes("ISO8859_1");
	rawout.write (b);
	rawout.flush();
	if (closeNow) {
	closeConnection(connection);
	}
	} catch (IOException e) {
	logger.log (Level.FINER, "ServerImpl.sendReply", e);
	closeConnection(connection);
	}
	}

	}

	void logReply (int code, String requestStr, String text) {
	if (!logger.isLoggable(Level.FINE)) {
	return;
	}
	if (text == null) {
	text = "";
	}
	String r;
	if (requestStr.length() > 80) {
	r = requestStr.substring (0, 80) + "<TRUNCATED>";
	} else {
	r = requestStr;
	}
	String message = r + " [" + code + " " +
	Code.msg(code) + "] ("+text+")";
	logger.fine (message);
	}

	long getTicks() {
	return ticks;
	}

	public long getTime() {
	return time;
	}

	void delay () {
	Thread.yield();
	try {
	Thread.sleep (200);
	} catch (InterruptedException e) {}
	}

	private int exchangeCount = 0;

	synchronized void startExchange () {
	exchangeCount ++;
	}

	synchronized int endExchange () {
	exchangeCount --;
	assert exchangeCount >= 0;
	return exchangeCount;
	}

	HttpServer getWrapper () {
	return wrapper;
	}

	void requestStarted (HttpConnection c) {
	c.creationTime = getTime();
	c.setState (State.REQUEST);
	reqConnections.add (c);
	}

	// called after a request has been completely read
	// by the server. This stops the timer which would
	// close the connection if the request doesn't arrive
	// quickly enough. It then starts the timer
	// that ensures the client reads the response in a timely
	// fashion.

	void requestCompleted (HttpConnection c) {
	assert c.getState() == State.REQUEST;
	reqConnections.remove (c);
	c.rspStartedTime = getTime();
	rspConnections.add (c);
	c.setState (State.RESPONSE);
	}

	// called after response has been sent
	void responseCompleted (HttpConnection c) {
	assert c.getState() == State.RESPONSE;
	rspConnections.remove (c);
	c.setState (State.IDLE);
	}

	/**
	* TimerTask run every CLOCK_TICK ms
	*/
	class ServerTimerTask extends TimerTask {
	public void run () {
	LinkedList<HttpConnection> toClose = new LinkedList<HttpConnection>();
	time = System.currentTimeMillis();
	ticks ++;
	synchronized (idleConnections) {
	for (HttpConnection c : idleConnections) {
	if (c.time <= time) {
	toClose.add (c);
	}
	}
	for (HttpConnection c : toClose) {
	idleConnections.remove (c);
	allConnections.remove (c);
	c.close();
	}
	}
	}
	}

	class ServerTimerTask1 extends TimerTask {

	// runs every TIMER_MILLIS
	public void run () {
	LinkedList<HttpConnection> toClose = new LinkedList<HttpConnection>();
	time = System.currentTimeMillis();
	synchronized (reqConnections) {
	if (MAX_REQ_TIME != -1) {
	for (HttpConnection c : reqConnections) {
	if (c.creationTime + TIMER_MILLIS + MAX_REQ_TIME <= time) {
	toClose.add (c);
	}
	}
	for (HttpConnection c : toClose) {
	logger.log (Level.FINE, "closing: no request: " + c);
	reqConnections.remove (c);
	allConnections.remove (c);
	c.close();
	}
	}
	}
	toClose = new LinkedList<HttpConnection>();
	synchronized (rspConnections) {
	if (MAX_RSP_TIME != -1) {
	for (HttpConnection c : rspConnections) {
	if (c.rspStartedTime + TIMER_MILLIS +MAX_RSP_TIME <= time) {
	toClose.add (c);
	}
	}
	for (HttpConnection c : toClose) {
	logger.log (Level.FINE, "closing: no response: " + c);
	rspConnections.remove (c);
	allConnections.remove (c);
	c.close();
	}
	}
	}
	}
	}

	void logStackTrace (String s) {
	logger.finest (s);
	StringBuilder b = new StringBuilder ();
	StackTraceElement[] e = Thread.currentThread().getStackTrace();
	for (int i=0; i<e.length; i++) {
	b.append (e[i].toString()).append("\n");
	}
	logger.finest (b.toString());
	}

	static long getTimeMillis(long secs) {
	if (secs == -1) {
	return -1;
	} else {
	return secs * 1000;
	}
	}
	}

Back to index...