ABP/Android Process chunked requests

src/sunlabs/brazil/util/http/HttpRequest.java

 /*
  * HttpRequest.java
  *
  * Brazil project web application toolkit,
  * export version: 2.3 
  * Copyright (c) 1999-2007 Sun Microsystems, Inc.
  *
  * Sun Public License Notice
  *
  * The contents of this file are subject to the Sun Public License Version 
  * 1.0 (the "License"). You may not use this file except in compliance with 
  * the License. A copy of the License is included as the file "license.terms",
  * and also available at http://www.sun.com/
  * 
  * The Original Code is from:
  *    Brazil project web application toolkit release 2.3.
  * The Initial Developer of the Original Code is: cstevens.
  * Portions created by cstevens are Copyright (C) Sun Microsystems, Inc.
  * All Rights Reserved.
  * 
  * Contributor(s): cstevens, drach, suhler.
  *
  * Version:  2.7
  * Created by cstevens on 99/09/15
  * Last modified by suhler on 07/03/26 13:53:18
  *
  * Version Histories:
+ *
+ * 13/04/09-12:44:12 (andrey@adblockplus.org)
+ *   implemented proxying chunked request body
  *
  * 2.7 07/03/26-13:53:18 (suhler)
  *   doc updates
  *
  * 2.6 07/03/26-13:44:17 (suhler)
  *   add sample main() to act as a simple "wget"
  *
  * 2.5 04/11/30-15:19:40 (suhler)
  *   fixed sccs version string
  *
@@ skipping 629 matching lines @@
     {
         if (postData == null) {
             postData = new ByteArrayOutputStream();
         }
         return postData;
     }
 
     public void
     setHttpInputStream(HttpInputStream cs)
     {
-    this.cs = cs;

[Wladimir Palant, 2013/04/05 14:27:09]

Bad indentation here - are you mixing tabs and spaces?

[Andrey Novikov, 2013/04/05 14:34:28]

No, I'm trying to preserve ugly Brazil code style.

[Wladimir Palant, 2013/04/09 07:44:45]

Indentation is fine in the Brazil code above...

+        this.cs = cs;
     }
 
     /**
      * Connect to the target host (or proxy), send the request, and read the
      * response headers.  Any setup routines must be called before the call
      * to this method, and routines to examine the result must be called after
      * this method.
      * <p>
      *
      * @throws  UnknownHostException
@@ skipping 184 matching lines @@
         requestHeaders.print(p);
         p.print("\r\n");
 
         if (postData != null) {
             postData.writeTo(p);
             postData = null;                    // Release memory.
         }
         
         // Pass any data left in client stream (in case of chunked request content)
         String encoding = requestHeaders.get("Transfer-Encoding", "");
         if (encoding != null && encoding.equals("chunked") && cs != null)

[Wladimir Palant, 2013/04/05 14:27:09]

Should we really limit it to the chunked encoding? This probably should just
check for cs.

[Andrey Novikov, 2013/04/05 14:34:28]

Why should we not?

[Wladimir Palant, 2013/04/09 07:44:45]

Yes, if we cannot avoid parsing chunked encoding then we need to special-case it
of course...

[Felix Dahlke, 2013/04/09 09:16:48]

You could just do '"chunked".equals(encoding)' to avoid the null check.

[Andrey Novikov, 2013/04/10 08:30:30]

Done.

         {
-            byte[] buf = new byte[4096];
-            int bytesLeft = -1;
-            while (true)
-            {
-                // Read chunk size
-                if (bytesLeft <= 0)
-                {
-                    bytesLeft = getChunkSize(cs);

[Wladimir Palant, 2013/04/05 14:27:09]

Why do we care about the encoding and make tons of assumptions while at it?

byte[] buf = new byte[4096];
while (true)
{
   int bytesRead = cs.read(buf);
   if (bytesRead < 0)
     break;
   p.write(buf, 0 bytesRead);
}

This should do the same. Does it?

[Andrey Novikov, 2013/04/05 14:34:28]

Because input stream never ends. I've talked about it yesterday in chat. We have
a Keep-alive request. Your code (in fact I began doing it with the same code)
will cause timeout error.

-                    // Output chunk size
-                    p.print(Integer.toHexString(bytesLeft) + "\r\n");
-                }
-                if (bytesLeft == 0)
-                    break;
-                // Pass chunk data
-                int count = cs.read(buf, 0, Math.min(bytesLeft, buf.length));
-                if (count < 0)
-                {
-                    // This shouldn't occur - no final zero chunk
-                    bytesLeft = -1;
-                    break;
-                }
-            p.write(buf, 0, count);

[Wladimir Palant, 2013/04/05 14:27:09]

Mixing tabs and spaces again.

-                bytesLeft -= count;
-                if (bytesLeft == 0)
-                    p.print("\r\n");
-            }
-            // Pass the trailer
-            if (bytesLeft == 0)
-            {
-                while (true)
-                {
-                    String line = cs.readLine(LINE_LIMIT);
-                    if (line == null)
-                        break;
-                    p.print(line + "\r\n");
-                    if (line.length() == 0)
-                        break;
-                }
-            }
+                byte[] buf = new byte[4096];

[Felix Dahlke, 2013/04/09 09:16:48]

Indentation is off here

+                int bytesLeft = -1;
+                while (true)
+                {
+                        // Read chunk size
+                        if (bytesLeft <= 0)
+                        {
+                                bytesLeft = getChunkSize(cs);
+                                // Output chunk size
+                                p.print(Integer.toHexString(bytesLeft) + "\r\n");
+                        }
+                        if (bytesLeft == 0)
+                                break;
+                        // Pass chunk data
+                        int count = cs.read(buf, 0, Math.min(bytesLeft, buf.length));
+                        if (count < 0)
+                        {
+                                // This shouldn't occur - no final zero chunk
+                                bytesLeft = -1;
+                                break;
+                        }
+                        p.write(buf, 0, count);
+                        bytesLeft -= count;
+                        if (bytesLeft == 0)
+                                p.print("\r\n");
+                }
+                // Pass the trailer
+                if (bytesLeft == 0)
+                {
+                        while (true)
+                        {
+                                String line = cs.readLine(LINE_LIMIT);
+                                if (line == null)
+                                        break;
+                                p.print(line + "\r\n");
+                                if (line.length() == 0)
+                                        break;
+                        }
+                }
         }
         
         p.flush();
     }
 
+    /*
+     * Copied (with some amendmends) from UnchunkingInputStream / andrey@adblockplus.org
+     */
     private int
     getChunkSize(HttpInputStream is)

[Wladimir Palant, 2013/04/09 07:44:45]

Feel free to add a comment: This function has been copy&paste'd from
HttpRequest.java.

[Andrey Novikov, 2013/04/09 08:03:56]

What's the reason? I have copied it from Brazil code to Brazil code, not our
code.

[Wladimir Palant, 2013/04/09 08:31:55]

You forked Brazil code, later somebody will still have to understand what you
did. I found the source of this function by doing a Google search, this
shouldn't be necessary.

[Andrey Novikov, 2013/04/09 08:46:10]

But this is the same file. :) Anyway, done.

-    throws IOException
-    {
-    /*
-     * Although HTTP/1.1 chunking spec says that there is one "\r\n"
-     * between chunks, some servers (for example, maps.yahoo.com) 
-     * send more than one blank line between chunks.  So, read and skip
-     * all the blank lines seen between chunks.
-     */
-
-    int bytesLeft = 0;
-    String line;
-    do {
-        // Sanity check: limit chars when expecting a chunk size.
-
-        line = is.readLine(HttpRequest.LINE_LIMIT);
-    } while ((line != null) && (line.length() == 0));
-
-    try {
-        bytesLeft = Integer.parseInt(line.trim(), 16);
-    } catch (Exception e) {
-        throw new IOException("malformed chunk");
-    }
-    return bytesLeft;
+        throws IOException
+    {
+        /*
+        * Although HTTP/1.1 chunking spec says that there is one "\r\n"
+        * between chunks, some servers (for example, maps.yahoo.com) 
+        * send more than one blank line between chunks.  So, read and skip
+        * all the blank lines seen between chunks.
+        */
+
+        int bytesLeft = 0;
+        String line;
+        do {
+                // Sanity check: limit chars when expecting a chunk size.
+                line = is.readLine(HttpRequest.LINE_LIMIT);
+        } while ((line != null) && (line.length() == 0));

[Felix Dahlke, 2013/04/09 09:16:48]

Here's a shorter alternative: while("".equals(line))

[Andrey Novikov, 2013/04/10 08:30:30]

This was copied from another part of Brazil, I'll keep it as is for consistency.

+
+        try {
+                bytesLeft = Integer.parseInt(line.trim(), 16);
+        } catch (Exception e) {
+                throw new IOException("malformed chunk");
+        }
+        return bytesLeft;
     }
 
     void
     readStatusLine()
         throws IOException
     {
         while (true) {
             status = in.readLine(LINE_LIMIT);
             if (status == null) {
                 throw new EOFException();
@@ skipping 879 matching lines @@
             return "(null)";
         }
         StringBuffer sb = new StringBuffer();
         for (int i = 0; i < idle.size(); i++) {
             HttpSocket hs = (HttpSocket) idle.elementAt(i);
             sb.append(hs.toString() + ", ");
         }
         return sb.toString();
     }
 }