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;
 
 
 
 class Request {
 
     final static int BUF_LEN = 2048;
     final static byte CR = 13;
     final static byte LF = 10;
 
     private String startLine;
     private SocketChannel chan;
     private InputStream is;
     private OutputStream os;
 
     Request (InputStream rawInputStreamOutputStream rawoutthrows IOException {
         this. = ;
          = rawInputStream;
          = rawout;
         do {
              = readLine();
             if ( == null) {
                 return;
             }
             /* skip blank lines */
         } while ( == null ? false : .equals (""));
     }
 
 
     char[] buf = new char [];
     int pos;
 
     public InputStream inputStream () {
         return ;
     }
 
     public OutputStream outputStream () {
         return ;
     }

    
read a line from the stream returning as a String. Not used for reading headers.
 
 
     public String readLine () throws IOException {
         boolean gotCR = falsegotLF = false;
          = 0;  = new StringBuffer();
         while (!gotLF) {
             int c = .read();
             if (c == -1) {
                 return null;
             }
             if (gotCR) {
                 if (c == ) {
                     gotLF = true;
                 } else {
                     gotCR = false;
                     consume ();
                     consume (c);
                 }
             } else {
                 if (c == ) {
                    gotCR = true;
                } else {
                    consume (c);
                }
            }
        }
        .append (, 0, );
        return new String ();
    }
    private void consume (int c) {
        if ( == ) {
            .append ();
             = 0;
        }
        [++] = (char)c;
    }

    
returns the request line (first line of a request)
    public String requestLine () {
        return ;
    }
    Headers hdrs = null;
    Headers headers () throws IOException {
        if ( != null) {
            return ;
        }
         = new Headers();
        char s[] = new char[10];
        int len = 0;
        int firstc = .read();
        // check for empty headers
        if (firstc ==  || firstc == ) {
            int c = .read();
            if (c ==  || c == ) {
                return ;
            }
            s[0] = (char)firstc;
            len = 1;
            firstc = c;
        }
        while (firstc !=  && firstc !=  && firstc >= 0) {
            int keyend = -1;
            int c;
            boolean inKey = firstc > ' ';
            s[len++] = (charfirstc;
    parseloop:{
                while ((c = .read()) >= 0) {
                    switch (c) {
                      case ':':
                        if (inKey && len > 0)
                            keyend = len;
                        inKey = false;
                        break;
                      case '\t':
                        c = ' ';
                      case ' ':
                        inKey = false;
                        break;
                      case :
                      case :
                        firstc = .read();
                        if (c ==  && firstc == ) {
                            firstc = .read();
                            if (firstc == )
                                firstc = .read();
                        }
                        if (firstc ==  || firstc ==  || firstc > ' ')
                            break parseloop;
                        /* continuation */
                        c = ' ';
                        break;
                    }
                    if (len >= s.length) {
                        char ns[] = new char[s.length * 2];
                        System.arraycopy(s, 0, ns, 0, len);
                        s = ns;
                    }
                    s[len++] = (charc;
                }
                firstc = -1;
            }
            while (len > 0 && s[len - 1] <= ' ')
                len--;
            String k;
            if (keyend <= 0) {
                k = null;
                keyend = 0;
            } else {
                k = String.copyValueOf(s, 0, keyend);
                if (keyend < len && s[keyend] == ':')
                    keyend++;
                while (keyend < len && s[keyend] <= ' ')
                    keyend++;
            }
            String v;
            if (keyend >= len)
                v = new String();
            else
                v = String.copyValueOf(skeyendlen - keyend);
            .add (k,v);
            len = 0;
        }
        return ;
    }

    
Implements blocking reading semantics on top of a non-blocking channel
    static class ReadStream extends InputStream {
        SocketChannel channel;
        ByteBuffer chanbuf;
        byte[] one;
        private boolean closed = falseeof = false;
        ByteBuffer markBuf/* reads may be satisifed from this buffer */
        boolean marked;
        boolean reset;
        int readlimit;
        static long readTimeout;
        ServerImpl server;
        final static int BUFSIZE = 8 * 1024;
        public ReadStream (ServerImpl serverSocketChannel chanthrows IOException {
            this. = chan;
            this. = server;
             = ByteBuffer.allocate ();
            .clear();
             = new byte[1];
             =  =  = false;
        }
        public synchronized int read (byte[] bthrows IOException {
            return read (b, 0, b.length);
        }
        public synchronized int read () throws IOException {
            int result = read (, 0, 1);
            if (result == 1) {
                return [0] & 0xFF;
            } else {
                return -1;
            }
        }
        public synchronized int read (byte[] bint offint srclenthrows IOException {
            int canreturnwillreturn;
            if ()
                throw new IOException ("Stream closed");
            if () {
                return -1;
            }
            assert .isBlocking();
            if (off < 0 || srclen < 0|| srclen > (b.length-off)) {
                throw new IndexOutOfBoundsException ();
            }
            if () { /* satisfy from markBuf */
                canreturn = .remaining ();
                willreturn = canreturn>srclen ? srclen : canreturn;
                .get(boffwillreturn);
                if (canreturn == willreturn) {
                     = false;
                }
            } else { /* satisfy from channel */
                .clear ();
                if (srclen <  ) {
                    .limit (srclen);
                }
                do {
                    willreturn = .read ();
                } while (willreturn == 0);
                if (willreturn == -1) {
                     = true;
                    return -1;
                }
                .flip ();
                .get(boffwillreturn);
                if () { /* copy into markBuf */
                    try {
                        .put (boffwillreturn);
                    } catch (BufferOverflowException e) {
                         = false;
                    }
                }
            }
            return willreturn;
        }
        public boolean markSupported () {
            return true;
        }
        /* Does not query the OS socket */
        public synchronized int available () throws IOException {
            if ()
                throw new IOException ("Stream is closed");
            if ()
                return -1;
            if ()
                return .remaining();
            return .remaining();
        }
        public void close () throws IOException {
            if () {
                return;
            }
            .close ();
             = true;
        }
        public synchronized void mark (int readlimit) {
            if ()
                return;
            this. = readlimit;
             = ByteBuffer.allocate (readlimit);
             = true;
             = false;
        }
        public synchronized void reset () throws IOException {
            if ( )
                return;
            if (!)
                throw new IOException ("Stream not marked");
             = false;
             = true;
            .flip ();
        }
    }
    static class WriteStream extends java.io.OutputStream {
        SocketChannel channel;
        ByteBuffer buf;
        SelectionKey key;
        boolean closed;
        byte[] one;
        ServerImpl server;
        public WriteStream (ServerImpl serverSocketChannel channelthrows IOException {
            this. = channel;
            this. = server;
            assert channel.isBlocking();
             = false;
             = new byte [1];
             = ByteBuffer.allocate (4096);
        }
        public synchronized void write (int bthrows IOException {
            [0] = (byte)b;
            write (, 0, 1);
        }
        public synchronized void write (byte[] bthrows IOException {
            write (b, 0, b.length);
        }
        public synchronized void write (byte[] bint offint lenthrows IOException {
            int l = len;
            if ()
                throw new IOException ("stream is closed");
            int cap = .capacity();
            if (cap < len) {
                int diff = len - cap;
                 = ByteBuffer.allocate (2*(cap+diff));
            }
            .clear();
            .put (bofflen);
            .flip ();
            int n;
            while ((n = .write ()) < l) {
                l -= n;
                if (l == 0)
                    return;
            }
        }
        public void close () throws IOException {
            if ()
                return;
            //server.logStackTrace ("Request.OS.close: isOpen="+channel.isOpen());
            .close ();
             = true;
        }
    }
New to GrepCode? Check out our FAQ X