Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2005, 2010, 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 koncept.http.sun.net.httpserver;
 
 import java.net.URI;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 
 
 class ExchangeImpl {
 	private final Map<ConfigurationOptionStringoptions;
 	public static final String ATTRIBUTE_SCOPE_KEY = "httpexchange.attribute.scoping";
 	public static final ConfigurationOption ATTRIBUTE_SCOPE = new ConfigurationOption(new String[]{"context""exchange"});
 	
     Headers reqHdrsrspHdrs;
     Request req;
     String method;
     boolean writefinished;
     URI uri;
     long reqContentLen;
     long rspContentLen;
     /* raw streams which access the socket directly */
     InputStream ris;
     OutputStream ros;
     Thread thread;
     /* close the underlying connection when this exchange finished */
     boolean close;
     boolean closed;
     boolean http10 = false;
 
     /* for formatting the Date: header */
     private static final String pattern = "EEE, dd MMM yyyy HH:mm:ss zzz";
     private static final TimeZone gmtTZ = TimeZone.getTimeZone("GMT");
     private static final ThreadLocal<DateFormatdateFormat =
          new ThreadLocal<DateFormat>() {
              @Override protected DateFormat initialValue() {
                  DateFormat df = new SimpleDateFormat(.);
                  df.setTimeZone();
                  return df;
          }
      };
 
     private static final String HEAD = "HEAD";
 
     /* streams which take care of the HTTP protocol framing
      * and are passed up to higher layers
      */
     InputStream uis;
     OutputStream uos;
     LeftOverInputStream uis_orig// uis may have be a user supplied wrapper
 
    boolean sentHeaders/* true after response headers sent */
    int rcode = -1;
    ExchangeImpl (
        String mURI uRequest reqlong lenHttpConnection connection,
        Map<ConfigurationOptionStringoptions
    ) throws IOException {
    	this. = options;
        this. = req;
        this. = req.headers();
        this. = new Headers();
        this. = m;
        this. = u;
        this. = connection;
        this. = len;
        /* ros only used for headers, body written directly to stream */
        this. = req.outputStream();
        this. = req.inputStream();
         = getServerImpl();
        .startExchange();
    }
    public Headers getRequestHeaders () {
        return new UnmodifiableHeaders ();
    }
    public Headers getResponseHeaders () {
        return ;
    }
    public URI getRequestURI () {
        return ;
    }
    public String getRequestMethod (){
        return ;
    }
    public HttpContextImpl getHttpContext (){
        return .getHttpContext();
    }
    private boolean isHeadRequest() {
        return .equals(getRequestMethod());
    }
    public void close () {
        if () {
            return;
        }
         = true;
        /* close the underlying connection if,
         * a) the streams not set up yet, no response can be sent, or
         * b) if the wrapper output stream is not set up, or
         * c) if the close of the input/outpu stream fails
         */
        try {
            if ( == null ||  == null) {
                .close();
                return;
            }
            if (!.isWrapped()) {
                .close();
                return;
            }
            if (!.isClosed()) {
                .close();
            }
            .close();
        } catch (IOException e) {
            .close();
        }
    }
    public InputStream getRequestBody () {
        if ( != null) {
            return ;
        }
        if ( == -1L) {
             = new ChunkedInputStream (this);
             = ;
        } else {
             = new FixedLengthInputStream (this);
             = ;
        }
        return ;
    }
        return ;
    }
    public int getResponseCode () {
        return ;
    }
    public OutputStream getResponseBody () {
        /* TODO. Change spec to remove restriction below. Filters
         * cannot work with this restriction
         *
         * if (!sentHeaders) {
         *    throw new IllegalStateException ("headers not sent");
         * }
         */
        if ( == null) {
             = new PlaceholderOutputStream (null);
             = ;
        }
        return ;
    }
    /* returns the place holder stream, which is the stream
     * returned from the 1st call to getResponseBody()
     * The "real" ouputstream is then placed inside this
     */
        getResponseBody();
        return ;
    }
    public void sendResponseHeaders (int rCodelong contentLen)
    throws IOException
    {
        if () {
            throw new IOException ("headers already sent");
        }
        this. = rCode;
        String statusLine = "HTTP/1.1 "+rCode+Code.msg(rCode)+"\r\n";
        OutputStream tmpout = new BufferedOutputStream ();
        tmpout.write (bytes(statusLine, 0), 0, statusLine.length());
        boolean noContentToSend = false// assume there is content
        .set ("Date".get().format (new Date()));
        /* check for response type that is not allowed to send a body */
        if ((rCode>=100 && rCode <200) /* informational */
            ||(rCode == 204)           /* no content */
            ||(rCode == 304))          /* not modified */
        {
            if (contentLen != -1) {
                Logger logger = .getLogger();
                String msg = "sendResponseHeaders: rCode = "rCode
                    + ": forcing contentLen = -1";
                logger.warning (msg);
            }
            contentLen = -1;
        }
        if (isHeadRequest()) {
            /* HEAD requests should not set a content length by passing it
             * through this API, but should instead manually set the required
             * headers.*/
            if (contentLen >= 0) {
                final Logger logger = .getLogger();
                String msg =
                    "sendResponseHeaders: being invoked with a content length for a HEAD request";
                logger.warning (msg);
            }
            noContentToSend = true;
            contentLen = 0;
        } else { /* not a HEAD request */
            if (contentLen == 0) {
                if () {
                    o.setWrappedStream (new UndefLengthOutputStream (this));
                     = true;
                } else {
                    .set ("Transfer-encoding""chunked");
                    o.setWrappedStream (new ChunkedOutputStream (this));
                }
            } else {
                if (contentLen == -1) {
                    noContentToSend = true;
                    contentLen = 0;
                }
                .set("Content-length", Long.toString(contentLen));
                o.setWrappedStream (new FixedLengthOutputStream (thiscontentLen));
            }
        }
        write (tmpout);
        this. = contentLen;
        tmpout.flush() ;
        tmpout = null;
         = true;
        if (noContentToSend) {
            WriteFinishedEvent e = new WriteFinishedEvent (this);
            .addEvent (e);
             = true;
        }
        .logReply (rCode.requestLine(), null);
    }
    void write (Headers mapOutputStream osthrows IOException {
        Set<Map.Entry<String,List<String>>> entries = map.entrySet();
        for (Map.Entry<String,List<String>> entry : entries) {
            String key = entry.getKey();
            byte[] buf;
            List<Stringvalues = entry.getValue();
            for (String val : values) {
                int i = key.length();
                buf = bytes (key, 2);
                buf[i++] = ':';
                buf[i++] = ' ';
                os.write (buf, 0, i);
                buf = bytes (val, 2);
                i = val.length();
                buf[i++] = '\r';
                buf[i++] = '\n';
                os.write (buf, 0, i);
            }
        }
        os.write ('\r');
        os.write ('\n');
    }
    private byte[] rspbuf = new byte [128]; // used by bytes()

    
convert string to byte[], using rspbuf Make sure that at least "extra" bytes are free at end of rspbuf. Reallocate rspbuf if not big enough. caller must check return value to see if rspbuf moved
    private byte[] bytes (String sint extra) {
        int slen = s.length();
        if (slen+extra > .) {
            int diff = slen + extra - .;
             = new byte [2* (. + diff)];
        }
        char c[] = s.toCharArray();
        for (int i=0; i<c.lengthi++) {
            [i] = (byte)c[i];
        }
        return ;
    }
        Socket s = .getChannel().socket();
        InetAddress ia = s.getInetAddress();
        int port = s.getPort();
        return new InetSocketAddress (iaport);
    }
        Socket s = .getChannel().socket();
        InetAddress ia = s.getLocalAddress();
        int port = s.getLocalPort();
        return new InetSocketAddress (iaport);
    }
    public String getProtocol (){
        String reqline = .requestLine();
        int index = reqline.lastIndexOf (' ');
        return reqline.substring (index+1);
    }
    public SSLSession getSSLSession () {
        SSLEngine e = .getSSLEngine();
        if (e == null) {
            return null;
        }
        return e.getSession();
    }
    
    private Map<StringObjectattributes() {
    	 if ( == null) {
    		 String option = .get();
    		 if (option.equals("exchange")) {
    			  = new ConcurrentHashMap<StringObject>();
    		 } else if (option.equals("context")) {
    		 } else throw new IllegalStateException("Unknown scope: " + option);
         }
    	 return ;
    }
    public Object getAttribute (String name) {
        if (name == null) {
            throw new NullPointerException ("null name parameter");
        }
        return attributes().get(name);
    }
    public void setAttribute (String nameObject value) {
        if (name == null) {
            throw new NullPointerException ("null name parameter");
        }
        attributes().put (namevalue);
    }
    public void setStreams (InputStream iOutputStream o) {
        assert  != null;
        if (i != null) {
             = i;
        }
        if (o != null) {
             = o;
        }
    }

    
PP
        return ;
    }
        return getHttpContext().getServerImpl();
    }
    public HttpPrincipal getPrincipal () {
        return ;
    }
    void setPrincipal (HttpPrincipal principal) {
        this. = principal;
    }
    static ExchangeImpl get (HttpExchange t) {
        if (t instanceof HttpExchangeImpl) {
            return ((HttpExchangeImpl)t).getExchangeImpl();
        } else {
            assert t instanceof HttpsExchangeImpl;
            return ((HttpsExchangeImpl)t).getExchangeImpl();
        }
    }
An OutputStream which wraps another stream which is supplied either at creation time, or sometime later. If a caller/user tries to write to this stream before the wrapped stream has been provided, then an IOException will be thrown.
         = os;
    }
    void setWrappedStream (OutputStream os) {
         = os;
    }
    boolean isWrapped () {
        return  != null;
    }
    private void checkWrap () throws IOException {
        if ( == null) {
            throw new IOException ("response headers not sent yet");
        }
    }
    public void write(int bthrows IOException {
        checkWrap();
        .write (b);
    }
    public void write(byte b[]) throws IOException {
        checkWrap();
        .write (b);
    }
    public void write(byte b[], int offint lenthrows IOException {
        checkWrap();
        .write (bofflen);
    }
    public void flush() throws IOException {
        checkWrap();
        .flush();
    }
    public void close() throws IOException {
        checkWrap();
        .close();
    }
New to GrepCode? Check out our FAQ X