Changeset 598

Show
Ignore:
Timestamp:
12/03/07 15:48:44 (1 year ago)
Author:
blackhedd
Message:

supported chunked transfers.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • version_0/lib/protocols/httpcli2.rb

    r597 r598  
    6464                        end 
    6565 
     66 
     67                        #-- 
     68                        # 
     69                        def receive_line ln 
     70                                if @chunk_trailer 
     71                                        receive_chunk_trailer(ln) 
     72                                elsif @chunking 
     73                                        receive_chunk_header(ln) 
     74                                else 
     75                                        receive_header_line(ln) 
     76                                end 
     77                        end 
     78 
     79                        #-- 
     80                        # 
     81                        def receive_chunk_trailer ln 
     82                                if ln.length == 0 
     83                                        @conn.pop_request 
     84                                        succeed 
     85                                else 
     86                                        p "Received chunk trailer line" 
     87                                end 
     88                        end 
     89 
    6690                        #-- 
    6791                        # Allow up to ten blank lines before we get a real response line. 
    6892                        # Allow no more than 100 lines in the header. 
    6993                        # 
    70                         def receive_line ln 
     94                        def receive_header_line ln 
    7195                                if ln.length == 0 
    7296                                        if @header_lines.length > 0 
     
    87111                        end 
    88112 
    89  
    90113                        #-- 
     114                        # Cf RFC 2616 pgh 3.6.1 for the format of HTTP chunks. 
     115                        # 
     116                        def receive_chunk_header ln 
     117                                if ln.length > 0 
     118                                        chunksize = ln.to_i(16) 
     119                                        if chunksize > 0 
     120                                                @conn.set_text_mode(ln.to_i(16)) 
     121                                        else 
     122                                                @content = @content.join 
     123                                                @chunk_trailer = true 
     124                                        end 
     125                                else 
     126                                        # We correctly come here after each chunk gets read. 
     127                                        p "Got A BLANK chunk line" 
     128                                end 
     129 
     130                        end 
     131 
     132 
     133                        #-- 
     134                        # We get a single chunk. Append it to the incoming content and switch back to line mode. 
     135                        # 
     136                        def receive_chunked_text text 
     137                                p "RECEIVED #{text.length} CHUNK" 
     138                                (@content ||= []) << text 
     139                        end 
     140 
     141 
     142                        #-- 
     143                        # TODO, inefficient how we're handling this. Part of it is done so as to 
     144                        # make sure we don't have problems in detecting chunked-encoding, content-length, 
     145                        # etc. 
    91146                        # 
    92147                        # 
    93148                        HttpResponseRE = /\AHTTP\/(1.[01]) ([\d]{3})/i 
    94149                        ClenRE = /\AContent-length:\s*(\d+)/i 
     150                        ChunkedRE = /\ATransfer-encoding:\s*chunked/i 
    95151                        ColonRE = /\:\s*/ 
    96152 
     
    104160 
    105161                                clen = nil 
     162                                chunks = nil 
    106163                                @header_lines.each_with_index do |e,ix| 
    107164                                        if ix > 0 
     
    109166                                                (@headers[hdr.downcase] ||= []) << val 
    110167                                        end 
     168 
    111169                                        if clen == nil and e =~ ClenRE 
    112170                                                clen = $1.dup.to_i 
    113171                                        end 
     172                                        if e =~ ChunkedRE 
     173                                                chunks = true 
     174                                        end 
    114175                                end 
    115176 
    116177                                if clen 
    117178                                        @conn.set_text_mode clen 
     179                                elsif chunks 
     180                                        @chunking = true 
    118181                                else 
    119182                                        # Chunked transfer, multipart, or end-of-connection. 
     
    121184                                        # method and suppress its desire to fail us. 
    122185                                        p "NO CLEN" 
     186                                        p @args[:uri] 
     187                                        p @header_lines 
    123188                                        @internal_error = :unsupported_clen 
    124189                                        @conn.close_connection 
     
    126191                        end 
    127192                        private :process_header 
     193 
     194 
     195                        def receive_text text 
     196                                @chunking ? receive_chunked_text(text) : receive_sized_text(text) 
     197                        end 
    128198 
    129199                        #-- 
     
    131201                        # specified by the content-length header. 
    132202                        # 
    133                         def receive_text text 
     203                        def receive_sized_text text 
    134204                                @content = text 
    135205                                @conn.pop_request 
     
    233303 
    234304                def receive_line ln 
    235                         @requests.last.receive_line ln 
     305                        if req = @requests.last 
     306                                req.receive_line ln 
     307                        else 
     308                                p "??????????" 
     309                                p ln 
     310                        end 
     311 
    236312                end 
    237313                def receive_binary_data text