WebSVN – Kolibri OS – Diff – /programs/develop/libraries/http/http.asm

 ; "Hypertext Transfer Protocol -- HTTP/1.1", http://tools.ietf.org/html/rfc2616
         URLMAXLEN       = 65535
         BUFFERSIZE      = 8192
-        TIMEOUT         = 1000  ; in 1/100 s
+        TIMEOUT         = 500  ; in 1/100 s
         mov     [eax + http_msg.content_length], 0
         mov     [eax + http_msg.content_received], 0
         push    eax ebp
         mov     ebp, eax
-        mcall   29, 9
+        mcall   26, 9
         mov     [ebp + http_msg.timestamp], eax
         pop     ebp eax
+}
 ;;------------------------------------------------------------------------------------------------;;
 ;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
 ;;------------------------------------------------------------------------------------------------;;
 ;< eax = -1 (not finished) / 0 finished                                                           ;;
 ;;================================================================================================;;
         pusha
         mov     ebp, [identifier]
 ; If the connection is closed, return immediately
         jz      .server_closed
         DEBUGF  1, "Received %u bytes\n", eax
 ; Update timestamp
         push    eax
-        mcall   29, 9
+        mcall   26, 9
         mov     [ebp + http_msg.timestamp], eax
         pop     eax
 ; Update pointers
         mov     edi, [ebp + http_msg.write_ptr]
-        add     [ebp + http_msg.write_ptr], eax
-        sub     [ebp + http_msg.buffer_length], eax
+        add     [ebp + http_msg.write_ptr], eax
-;        jz      .got_all_data
+        sub     [ebp + http_msg.buffer_length], eax
 ; If data is chunked, combine chunks into contiguous data.
         test    [ebp + http_msg.flags], FLAG_CHUNKED
         jnz     .chunk_loop
+; Did we detect the (final) header yet?
+        test    [ebp + http_msg.flags], FLAG_GOT_HEADER
+        jnz     .header_parsed
 ;--------------------------------------------------------------
 ; Did we detect the (final) header yet?
-        test    [ebp + http_msg.flags], FLAG_GOT_HEADER
+; Header parsing code begins here
         jnz     .header_parsed
         lea     edi, [ebp + http_msg.http_header]
         add     edi, [ebp + http_msg.header_length]
         ; put it in esi for next proc too
         mov     esi, edi
         sub     eax, 3
-        jle     .need_more_data
+        jle     .need_more_data_for_header
   .scan_loop:
         ; scan for end of header (empty line)
         cmp     dword[edi], 0x0a0d0a0d                  ; end of header
         je      .end_of_header
         cmp     word[edi+2], 0x0a0a                     ; notice the use of offset + 2, to calculate header length correctly :)
         je      .end_of_header
         inc     edi
         dec     eax
         jnz     .scan_loop
-        jmp     .need_more_data
+        jmp     .need_more_data_for_header
   .end_of_header:
         add     edi, 4 - http_msg.http_header
         sub     edi, ebp
         mov     [ebp + http_msg.header_length], edi     ; If this isnt the final header, we'll use this as an offset to find real header.
         DEBUGF  1, "Header length: %u\n", edi
-; Ok, we have found header:
+; Ok, we have found the header
         cmp     dword[esi], 'HTTP'
-        jne     .invalid_header
+        jne     .err_header
         cmp     dword[esi+4], '/1.0'
         je      .http_1.0
         cmp     dword[esi+4], '/1.1'
-        jne     .invalid_header
+        jne     .err_header
         or      [ebp + http_msg.flags], FLAG_HTTP11
   .http_1.0:
         cmp     byte[esi+8], ' '
-        jne     .invalid_header
+        jne     .err_header
         add     esi, 9
         xor     eax, eax
         xor     ebx, ebx
         mov     ecx, 3
   .statusloop:
         lodsb
         sub     al, '0'
-        jb      .invalid_header
+        jb      .err_header
         cmp     al, 9
-        ja      .invalid_header
+        ja      .err_header
         lea     ebx, [ebx + 4*ebx]
         shl     ebx, 1
         add     ebx, eax
         dec     ecx
         jnz     .statusloop
-; Ignore "100 - Continue" headers
+; Ignore "100 - Continue" lines
         cmp     ebx, 100
         je      .scan_again
-        DEBUGF  1, "Status: %u\n", ebx
-        mov     [ebp + http_msg.status], ebx
+        DEBUGF  1, "Status: %u\n", ebx
-        or      [ebp + http_msg.flags], FLAG_GOT_HEADER
+        mov     [ebp + http_msg.status], ebx
         or      [ebp + http_msg.flags], FLAG_GOT_HEADER
 ; Now, convert all header names to lowercase.
-; This way, it will be much easier to find certain header fields, later on.
+; Now, convert all header names to lowercase.
 ; This way, it will be much easier to find certain header fields, later on.
         lea     esi, [ebp + http_msg.http_header]
         mov     ecx, [ebp + http_msg.header_length]
+  .need_newline:
-  .need_newline:
+        inc     esi
-        inc     esi
         dec     ecx
         jz      .convert_done
         cmp     byte[esi], 10
         jne     .need_newline
-; Ok, we have a newline, a line beginning with space or tabs has no header fields.
+; We have found a newline
         cmp     bl, 13
         je      .cl_ok
         cmp     bl, ' '
         je      .cl_ok
         sub     bl, '0'
-        jb      .invalid_header
+        jb      .err_header
         cmp     bl, 9
-        ja      .invalid_header
+        ja      .err_header
         lea     edx, [edx + edx*4]      ; edx = edx*10
         shl     edx, 1                  ;
         add     edx, ebx
         jmp     .cl_loop
         test    edx, edx
         jz      .got_all_data
         call    alloc_contentbuff
         test    eax, eax
-        jz      .no_ram
+        jz      .err_no_ram
         xor     eax, eax
         jmp     .header_parsed
   .not_chunked:
         mov     edx, BUFFERSIZE
         call    alloc_contentbuff
         test    eax, eax
-        jz      .no_ram
+        jz      .err_no_ram
         xor     eax, eax
         jmp     .header_parsed
         DEBUGF  1, "Transfer type is: chunked\n"
         mov     edx, BUFFERSIZE
         call    alloc_contentbuff
         test    eax, eax
-        jz      .no_ram
+        jz      .err_no_ram
 ; Set chunk pointer where first chunk should begin.
+        mov     eax, [ebp + http_msg.content_ptr]
+        mov     [ebp + http_msg.chunk_ptr], eax
+;--------------------------------------------------------------
+;
-        mov     eax, [ebp + http_msg.content_ptr]
+; Chunk parsing code begins here
         mov     [ebp + http_msg.chunk_ptr], eax
   .chunk_loop:
+        mov     ecx, [ebp + http_msg.write_ptr]
-        mov     ecx, [ebp + http_msg.write_ptr]
+        sub     ecx, [ebp + http_msg.chunk_ptr]
-        sub     ecx, [ebp + http_msg.chunk_ptr]
+        jbe     .need_more_data_chunked
+; Chunkline starts here, convert the ASCII hex number into ebx
-        jb      .need_more_data_chunked
+        mov     esi, [ebp + http_msg.chunk_ptr]
+        DEBUGF  1, "Chunkline begins at 0x%x\n", esi
+        xor     ebx, ebx
+        cmp     byte[esi], 0x0d
+        jne     .chunk_hex_loop
+        dec     ecx
+        jz      .need_more_data_chunked
+        inc     esi
+        cmp     byte[esi], 0x0a
+        jne     .chunk_hex_loop
-; Chunkline starts here, convert the ASCII hex number into ebx
+        dec     ecx
-        mov     esi, [ebp + http_msg.chunk_ptr]
+        jz      .need_more_data_chunked
-        xor     ebx, ebx
+        inc     esi
-  .chunk_hexloop:
+  .chunk_hex_loop:
         lodsb
         sub     al, '0'
-        jb      .chunk_
+        jb      .chunk_hex_end
         cmp     al, 9
         jbe     .chunk_hex
         sub     al, 'A' - '0' - 10
-        jb      .chunk_
+        jb      .chunk_hex_end
         cmp     al, 15
         jbe     .chunk_hex
         sub     al, 'a' - 'A'
         cmp     al, 15
-        ja      .chunk_
+        ja      .chunk_hex_end
+  .chunk_hex:
-  .chunk_hex:
+        shl     ebx, 4
+        add     bl, al
-        shl     ebx, 4
+        dec     ecx
-        add     bl, al
+        jnz     .chunk_hex_loop
-        jmp     .chunk_hexloop
+        jmp     .need_more_data_chunked
-  .chunk_:
+  .chunk_hex_end:
-; Chunkline ends with a CR, LF or simply LF
+; Chunkline ends with a CR LF or simply LF
         dec     esi
   .end_of_chunkline?:
         lodsb
-        cmp     al, 10
+        cmp     al, 10                                  ; chunkline must always end with LF
         je      .end_of_chunkline
+        dec     ecx
-        cmp     esi, [ebp + http_msg.write_ptr]
+        jnz     .end_of_chunkline?
-        jb      .end_of_chunkline?
+        xor     eax, eax
-        jmp     .need_more_data
+        jmp     .need_more_data_chunked                 ; chunkline is incomplete, request more data
   .end_of_chunkline:
-        DEBUGF  1, "Chunk of %u bytes\n", ebx
+        DEBUGF  1, "Chunk of 0x%x bytes\n", ebx
 ; If chunk size is 0, all chunks have been received.
         test    ebx, ebx
         jz      .got_all_data_chunked
-; Calculate how many data bytes we'll need to shift
+; Calculate how many data bytes we have received already
         mov     ecx, [ebp + http_msg.write_ptr]
-        sub     ecx, [ebp + http_msg.chunk_ptr]
+        sub     ecx, [ebp + http_msg.chunk_ptr]         ; ecx is now number of received data bytes
+; Update content_received counter
+        add     [ebp + http_msg.content_received], ecx
-; Calculate how many bytes we'll need to shift them
+; Calculate new write ptr
-        sub     esi, [ebp + http_msg.chunk_ptr]
+        mov     edx, esi
-; Update write ptr
+        sub     edx, [ebp + http_msg.chunk_ptr]         ; edx is now length of chunkline
+        sub     [ebp + http_msg.write_ptr], edx
-        sub     [ebp + http_msg.write_ptr], esi
+; Realloc buffer, make it 'chunksize' bigger.
-; Realloc buffer, make it 'chunksize' bigger.
+        lea     edx, [ebx + BUFFERSIZE]
-        add     ebx, [ebp + http_msg.chunk_ptr]
+        mov     [ebp + http_msg.buffer_length], edx     ; remaining space in new buffer
-        sub     ebx, [ebp + http_msg.content_ptr]
+        add     edx, [ebp + http_msg.write_ptr]
-        add     ebx, BUFFERSIZE                 ; add some space for new chunkline header
+        sub     edx, [ebp + http_msg.content_ptr]
-        DEBUGF  1, "Resizing buffer 0x%x, it will now be %u bytes\n", [ebp + http_msg.content_ptr], ebx
+        DEBUGF  1, "Resizing buffer 0x%x, it will now be %u bytes\n", [ebp + http_msg.content_ptr], edx
-        invoke  mem.realloc, [ebp + http_msg.content_ptr], ebx
+        invoke  mem.realloc, [ebp + http_msg.content_ptr], edx
         DEBUGF  1, "New buffer = 0x%x\n", eax
-        or      eax, eax
-        jz      .no_ram
+        or      eax, eax
-        call    recalculate_pointers
-; Calculate remaining available buffer size
-        mov     eax, [ebp + http_msg.content_ptr]
-        add     eax, ebx
+        jz      .err_no_ram
-        sub     eax, [ebp + http_msg.write_ptr]
+        call    recalculate_pointers                    ; Because it's possible that buffer begins on another address now
-        mov     [ebp + http_msg.buffer_length], eax
-; Move all received data to the left (remove chunk header).
-        mov     edi, [ebp + http_msg.chunk_ptr]
-        add     esi, edi
-        ; Update chunk ptr so it points to next chunk
-        sub     ebx, BUFFERSIZE
-        add     [ebp + http_msg.chunk_ptr], ebx
-        ; Update number of received content bytes
+        add     esi, eax                                ; recalculate esi too!
-        add     [ebp + http_msg.content_received], ecx
+; Remove chunk header (aka chunkline) from the buffer by shifting all received data after chunkt_ptr to the left
+        mov     edi, [ebp + http_msg.chunk_ptr]
+        rep movsb
-        DEBUGF  1, "Moving %u bytes from 0x%x to 0x%x\n", ecx, esi, edi
+; Update chunk ptr to point to next chunk
-        rep movsb
+        add     [ebp + http_msg.chunk_ptr], ebx
+; Set number of received bytes to 0, we already updated content_received
+        xor     eax, eax
-        xor     eax, eax
+        jmp     .chunk_loop
+;--------------------------------------------------------------
         jmp     .chunk_loop
+; end of proc code begins here
+;
+  .header_parsed:
-;---------------------------------------------------------
+        ; Header was already parsed and connection isnt chunked.
-; Check if we got all the data.
+        ; Update content_received
-  .header_parsed:
+        add     [ebp + http_msg.content_received], eax
-        add     [ebp + http_msg.content_received], eax
+        ; If we received content-length parameter, check if we received all the data
         test    [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
+        jz      @f
+        mov     eax, [ebp + http_msg.content_received]
+        cmp     eax, [ebp + http_msg.content_length]
-        jz      .need_more_data_and_space
+        jae     .got_all_data
+  @@:
+        cmp     [ebp + http_msg.buffer_length], 0
+        je      .buffer_full
+        ; Need more data
-        mov     eax, [ebp + http_msg.content_received]
+        popa
-        cmp     eax, [ebp + http_msg.content_length]
+        xor     eax, eax
-        jae     .got_all_data
-        jmp     .need_more_data
+        dec     eax
         ret
   .need_more_data_and_space:
-        test    [ebp + http_msg.flags], FLAG_GOT_HEADER
+  .buffer_full:
-        jz      .invalid_header                 ; It's just too damn long!
+        ; Lets make it bigger..
         mov     eax, [ebp + http_msg.write_ptr]
         add     eax, BUFFERSIZE
         sub     eax, [ebp + http_msg.content_ptr]
+        invoke  mem.realloc, [ebp + http_msg.content_ptr], eax
+        or      eax, eax
+        jz      .err_no_ram
+        call    recalculate_pointers
+        mov     [ebp + http_msg.buffer_length], BUFFERSIZE
-        invoke  mem.realloc, [ebp + http_msg.content_ptr], eax
+        ; Need more data
+        popa
+        xor     eax, eax
+        dec     eax
-        or      eax, eax
+        ret
         jz      .no_ram
-        call    recalculate_pointers
+  .need_more_data_for_header:
-        mov     [ebp + http_msg.buffer_length], BUFFERSIZE
+        cmp     [ebp + http_msg.buffer_length], 0
         je      .err_header                     ; It's just too damn long!
+        ; Need more data
-  .need_more_data:
+        popa
-        popa
+        xor     eax, eax
-        xor     eax, eax
+        dec     eax
-        dec     eax
+        ret
         ret
   .need_more_data_chunked:
+        ; We only got a partial chunk, or need more chunks, update content_received and request more data
-  .need_more_data_chunked:
+        add     [ebp + http_msg.content_received], eax
-        add     [ebp + http_msg.content_received], eax
+        popa
-        popa
+        xor     eax, eax
-        xor     eax, eax
+        dec     eax
-        dec     eax
+        ret
         mcall   close, [ebp + http_msg.socket]
         popa
         xor     eax, eax
         ret
+;--------------------------------------------------------------
+;
+; error handeling code begins here
+;
   .check_socket:
         cmp     ebx, EWOULDBLOCK
-        jne     .socket_error
+        jne     .err_socket
+        mcall   26, 9
-        mcall   29, 9
+        sub     eax, [ebp + http_msg.timestamp]
-        sub     eax, TIMEOUT
+        cmp     eax, TIMEOUT
-        cmp     eax, [ebp + http_msg.timestamp]
+        ja      .err_timeout
-        jl      .need_more_data
+        ; Need more data
-        DEBUGF  1, "ERROR: timeout\n"
+        popa
-        or      [ebp + http_msg.flags], FLAG_TIMEOUT_ERROR
+        xor     eax, eax
+        dec     eax
-        jmp     .disconnect
+        ret
   .server_closed:
         DEBUGF  1, "server closed connection, transfer complete?\n"
         test    [ebp + http_msg.flags], FLAG_GOT_HEADER
-        jz      .server_error
+        jz      .err_server_closed
-        test    [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
-        jz      .got_all_data
+        test    [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
         jz      .got_all_data
-  .server_error:
+  .err_server_closed:
         pop     eax
         DEBUGF  1, "ERROR: server closed connection unexpectedly\n"
         or      [ebp + http_msg.flags], FLAG_TRANSFER_FAILED
-        jmp     .disconnect
+        jmp     .abort
-  .invalid_header:
+  .err_header:
         pop     eax
         DEBUGF  1, "ERROR: invalid header\n"
         or      [ebp + http_msg.flags], FLAG_INVALID_HEADER
-        jmp     .disconnect
+        jmp     .abort
+  .err_no_ram:
+        DEBUGF  1, "ERROR: out of RAM\n"
+        or      [ebp + http_msg.flags], FLAG_NO_RAM
+        jmp     .abort
-  .no_ram:
+  .err_timeout:
-        DEBUGF  1, "ERROR: out of RAM\n"
+        DEBUGF  1, "ERROR: timeout\n"
-        or      [ebp + http_msg.flags], FLAG_NO_RAM
+        or      [ebp + http_msg.flags], FLAG_TIMEOUT_ERROR
-        jmp     .disconnect
+        jmp     .abort
-  .socket_error:
+  .err_socket:
         DEBUGF  1, "ERROR: socket error %u\n", ebx
         or      [ebp + http_msg.flags], FLAG_SOCKET_ERROR
-  .disconnect:
+  .abort:

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/http/http.asm – Rev 4561 → 4690