/*
* Copyright 2002-2004 Sun Microsystems, Inc. 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.
*
* 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.net.*;
import sun.net.www.MessageHeader;
/**
* This class encapsulates a HTTP request received and a response to be
* generated in one transaction. It provides methods for examaining the
* request from the client, and for building and sending a reply.
*/
public class HttpTransaction {
String command;
URI requesturi;
HttpServer.Server server;
MessageHeader reqheaders, reqtrailers;
String reqbody;
byte[] rspbody;
MessageHeader rspheaders, rsptrailers;
SelectionKey key;
int rspbodylen;
boolean rspchunked;
HttpTransaction (HttpServer.Server server, String command,
URI requesturi, MessageHeader headers,
String body, MessageHeader trailers, SelectionKey key) {
this.command = command;
this.requesturi = requesturi;
this.reqheaders = headers;
this.reqbody = body;
this.reqtrailers = trailers;
this.key = key;
this.server = server;
}
/**
* Get the value of a request header whose name is specified by the
* String argument.
*
* @param key the name of the request header
* @return the value of the header or null if it does not exist
*/
public String getRequestHeader (String key) {
return reqheaders.findValue (key);
}
/**
* Get the value of a response header whose name is specified by the
* String argument.
*
* @param key the name of the response header
* @return the value of the header or null if it does not exist
*/
public String getResponseHeader (String key) {
return rspheaders.findValue (key);
}
/**
* Get the request URI
*
* @return the request URI
*/
public URI getRequestURI () {
return requesturi;
}
public String toString () {
StringBuffer buf = new StringBuffer();
buf.append ("Request from: ").append (key.channel().toString()).append("\r\n");
buf.append ("Command: ").append (command).append("\r\n");
buf.append ("Request URI: ").append (requesturi).append("\r\n");
buf.append ("Headers: ").append("\r\n");
buf.append (reqheaders.toString()).append("\r\n");
buf.append ("Body: ").append (reqbody).append("\r\n");
buf.append ("---------Response-------\r\n");
buf.append ("Headers: ").append("\r\n");
if (rspheaders != null) {
buf.append (rspheaders.toString()).append("\r\n");
}
buf.append ("Body: ").append (new String(rspbody)).append("\r\n");
return new String (buf);
}
/**
* Get the value of a request trailer whose name is specified by
* the String argument.
*
* @param key the name of the request trailer
* @return the value of the trailer or null if it does not exist
*/
public String getRequestTrailer (String key) {
return reqtrailers.findValue (key);
}
/**
* Add a response header to the response. Multiple calls with the same
* key value result in multiple header lines with the same key identifier
* @param key the name of the request header to add
* @param val the value of the header
*/
public void addResponseHeader (String key, String val) {
if (rspheaders == null)
rspheaders = new MessageHeader ();
rspheaders.add (key, val);
}
/**
* Set a response header. Searches for first header with named key
* and replaces its value with val
* @param key the name of the request header to add
* @param val the value of the header
*/
public void setResponseHeader (String key, String val) {
if (rspheaders == null)
rspheaders = new MessageHeader ();
rspheaders.set (key, val);
}
/**
* Add a response trailer to the response. Multiple calls with the same
* key value result in multiple trailer lines with the same key identifier
* @param key the name of the request trailer to add
* @param val the value of the trailer
*/
public void addResponseTrailer (String key, String val) {
if (rsptrailers == null)
rsptrailers = new MessageHeader ();
rsptrailers.add (key, val);
}
/**
* Get the request method
*
* @return the request method
*/
public String getRequestMethod (){
return command;
}
/**
* Perform an orderly close of the TCP connection associated with this
* request. This method guarantees that any response already sent will
* not be reset (by this end). The implementation does a shutdownOutput()
* of the TCP connection and for a period of time consumes and discards
* data received on the reading side of the connection. This happens
* in the background. After the period has expired the
* connection is completely closed.
*/
public void orderlyClose () {
try {
server.orderlyCloseChannel (key);
} catch (IOException e) {
System.out.println (e);
}
}
/**
* Do an immediate abortive close of the TCP connection associated
* with this request.
*/
public void abortiveClose () {
try {
server.abortiveCloseChannel(key);
} catch (IOException e) {
System.out.println (e);
}
}
/**
* Get the SocketChannel associated with this request
*
* @return the socket channel
*/
public SocketChannel channel() {
return (SocketChannel) key.channel();
}
/**
* Get the request entity body associated with this request
* as a single String.
*
* @return the entity body in one String
*/
public String getRequestEntityBody (){
return reqbody;
}
/**
* Set the entity response body with the given string
* The content length is set to the length of the string
* @param body the string to send in the response
*/
public void setResponseEntityBody (String body){
rspbody = body.getBytes();
rspbodylen = body.length();
rspchunked = false;
addResponseHeader ("Content-length", Integer.toString (rspbodylen));
}
/**
* Set the entity response body with the given byte[]
* The content length is set to the gven length
* @param body the string to send in the response
*/
public void setResponseEntityBody (byte[] body, int len){
rspbody = body;
rspbodylen = len;
rspchunked = false;
addResponseHeader ("Content-length", Integer.toString (rspbodylen));
}
/**
* Set the entity response body by reading the given inputstream
*
* @param is the inputstream from which to read the body
*/
public void setResponseEntityBody (InputStream is) throws IOException {
byte[] buf = new byte [2048];
byte[] total = new byte [2048];
int total_len = 2048;
int c, len=0;
while ((c=is.read (buf)) != -1) {
if (len+c > total_len) {
byte[] total1 = new byte [total_len * 2];
System.arraycopy (total, 0, total1, 0, len);
total = total1;
total_len = total_len * 2;
}
System.arraycopy (buf, 0, total, len, c);
len += c;
}
setResponseEntityBody (total, len);
}
/* chunked */
/**
* Set the entity response body with the given array of strings
* The content encoding is set to "chunked" and each array element
* is sent as one chunk.
* @param body the array of string chunks to send in the response
*/
public void setResponseEntityBody (String[] body) {
StringBuffer buf = new StringBuffer ();
int len = 0;
for (int i=0; i<body.length; i++) {
String chunklen = Integer.toHexString (body[i].length());
len += body[i].length();
buf.append (chunklen).append ("\r\n");
buf.append (body[i]).append ("\r\n");
}
buf.append ("0\r\n");
rspbody = new String (buf).getBytes();
rspbodylen = rspbody.length;
rspchunked = true;
addResponseHeader ("Transfer-encoding", "chunked");
}
/**
* Send the response with the current set of response parameters
* but using the response code and string tag line as specified
* @param rCode the response code to send
* @param rTag the response string to send with the response code
*/
public void sendResponse (int rCode, String rTag) throws IOException {
OutputStream os = new HttpServer.NioOutputStream(channel());
PrintStream ps = new PrintStream (os);
ps.print ("HTTP/1.1 " + rCode + " " + rTag + "\r\n");
if (rspheaders != null) {
rspheaders.print (ps);
} else {
ps.print ("\r\n");
}
ps.flush ();
if (rspbody != null) {
os.write (rspbody, 0, rspbodylen);
os.flush();
}
if (rsptrailers != null) {
rsptrailers.print (ps);
} else if (rspchunked) {
ps.print ("\r\n");
}
ps.flush();
}
/* sends one byte less than intended */
public void sendPartialResponse (int rCode, String rTag)throws IOException {
OutputStream os = new HttpServer.NioOutputStream(channel());
PrintStream ps = new PrintStream (os);
ps.print ("HTTP/1.1 " + rCode + " " + rTag + "\r\n");
ps.flush();
if (rspbody != null) {
os.write (rspbody, 0, rspbodylen-1);
os.flush();
}
if (rsptrailers != null) {
rsptrailers.print (ps);
}
ps.flush();
}
}