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

 ;;------------------------------------------------------------------------------------------------;;
 ;< eax = -1 (not finished) / 0 finished                                                           ;;
 ;;================================================================================================;;
         pusha
         mov     ebp, [identifier]
+; Receive some data
         mcall   recv, [ebp + http_msg.socket], [ebp + http_msg.write_ptr], \
                       [ebp + http_msg.buffer_length], MSG_DONTWAIT
         cmp     eax, 0xffffffff
         je      .check_socket
         DEBUGF  1, "Received %u bytes\n", eax
 ; Update pointers
         mov     edi, [ebp + http_msg.write_ptr]
         add     [ebp + http_msg.write_ptr], eax
         sub     [ebp + http_msg.buffer_length], eax
+        jz      .got_all_data
+; If data is chunked, combine chunks into contiguous data.
+        test    [ebp + http_msg.flags], FLAG_CHUNKED
+        jnz     .chunk_loop
-        jz      .got_all_data
+; Did we detect the header yet?
         test    [ebp + http_msg.flags], FLAG_GOT_HEADER
+        jnz     .header_parsed
         jnz     .header_parsed
+; We havent found the header yet, search for it..
         sub     eax, 4
-        jl      .no_header
+        jl      .need_more_data
   .scan:
         ; scan for end of header (empty line)
         cmp     dword[edi], 0x0a0d0a0d                  ; end of header
         je      .end_of_header
         cmp     word[edi+2], 0x0a0a
         je      .end_of_header
         inc     edi
-        dec     eax
-        jnz     .scan
-  .no_header:
-        popa
-        xor     eax, eax
         dec     eax
-        ret
+        jnz     .scan
   .end_of_header:
         add     edi, 4 - http_msg.data
         stdcall find_header_field, ebp, str_te
         test    eax, eax
         jz      .invalid_header
         mov     ebx, dword[eax]
-        or      eax, 0x20202020
+        or      ebx, 0x20202020
         cmp     ebx, 'chun'
         jne     .invalid_header
         mov     ebx, dword[eax+4]
-        or      eax, 0x00202020
+        or      ebx, 0x00202020
-        and     eax, 0x00ffffff
+        and     ebx, 0x00ffffff
         cmp     ebx, 'ked'
         jne     .invalid_header
         or      [ebp + http_msg.flags], FLAG_CHUNKED
         or      [ebp + http_msg.flags], FLAG_CHUNKED
         DEBUGF  1, "Transfer type is: chunked\n"
 ; Set chunk pointer where first chunk should begin.
-        mov     eax, [ebp + http_msg.header_length]
-        add     eax, http_msg.data
-        mov     [ebp + http_msg.chunk_ptr], eax
-  .header_parsed:
-; If data is chunked, combine chunks into contiguous data if so.
+        lea     eax, [ebp + http_msg.data]
-        test    [ebp + http_msg.flags], FLAG_CHUNKED
+        add     eax, [ebp + http_msg.header_length]
-        jz      .not_chunked
+        mov     [ebp + http_msg.chunk_ptr], eax
+  .chunk_loop:
-  .chunkloop:
+        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]
+        jb      .need_more_data_chunked
         jb      .not_finished
 ; TODO: make sure we have the complete chunkline header
         mov     esi, [ebp + http_msg.chunk_ptr]
         xor     ebx, ebx
   .chunk_hexloop:
         lodsb
         sub     al, '0'
         jb      .chunk_
         cmp     al, 9
         jbe     .chunk_hex
-        sub     al, 'A' - '0'
+        sub     al, 'A' - '0' - 10
         jb      .chunk_
-        cmp     al, 5
+        cmp     al, 15
         jbe     .chunk_hex
         sub     al, 'a' - 'A'
-        cmp     al, 5
+        cmp     al, 15
         ja      .chunk_
   .chunk_hex:
         shl     ebx, 4
         add     bl, al
         jmp     .chunk_hexloop
+  .chunk_:
-  .chunk_:
+        DEBUGF  1, "got chunk of %u bytes\n", ebx
-        DEBUGF  1, "got chunk of %u bytes\n", ebx
+; If chunk size is 0, all chunks have been received.
-; If chunk size is 0, all chunks have been received.
+        test    ebx, ebx
-        test    ebx, ebx
+        jz      .got_all_data_chunked           ; last chunk, hooray! FIXME: what if it wasnt a valid hex number???
-        jz      .got_all_data   ; last chunk, hooray! FIXME: what if it wasnt a valid hex number???
+        mov     edi, [ebp + http_msg.chunk_ptr] ; we'll need this in about 25 lines...
         add     [ebp + http_msg.chunk_ptr], ebx
 ; Chunkline ends with a CR, LF or simply LF
   .end_of_chunkline?:           ; FIXME: buffer overflow possible!
         cmp     al, 10
         je      .end_of_chunkline
         lodsb
         jmp     .end_of_chunkline?
+  .end_of_chunkline:
+; Realloc buffer, make it 'chunksize' bigger.
+        mov     eax, [ebp + http_msg.buffer_length]
         add     eax, ebx
-  .end_of_chunkline:
+        invoke  mem.realloc, ebp, eax
-; Now move all received data to the left (remove chunk header).
+        or      eax, eax
+        jz      .no_ram
+        add     [ebp + http_msg.buffer_length], ebx
+; Update write ptr
+        mov     eax, esi
-; Meanwhile, update write_ptr and content_length accordingly.
+        sub     eax, edi
-        mov     edi, [ebp + http_msg.chunk_ptr]
+        sub     [ebp + http_msg.write_ptr], eax
-        mov     ecx, [ebp + http_msg.write_ptr]
-        sub     ecx, esi
-        mov     eax, esi
+; Now move all received data to the left (remove chunk header).
+; Update content_length accordingly.
-        sub     eax, edi
+        mov     ecx, [ebp + http_msg.write_ptr]
-        sub     [ebp + http_msg.write_ptr], eax
+        sub     ecx, esi
         add     [ebp + http_msg.content_length], ecx
         rep     movsb
+        jmp     .chunk_loop
+; Check if we got all the data.
+  .header_parsed:
+        mov     eax, [ebp + http_msg.header_length]
-        jmp     .chunkloop
+        add     eax, [ebp + http_msg.content_length]
+        cmp     eax, [ebp + http_msg.buffer_length]
-  .not_chunked:
+        je      .got_all_data
-; Check if we got all the data.
+  .need_more_data:
-        mov     eax, [ebp + http_msg.header_length]
+        popa
-        add     eax, [ebp + http_msg.content_length]
+        xor     eax, eax
+        dec     eax
+        ret
+  .need_more_data_chunked:
+        add     [ebp + http_msg.content_length], eax
+        popa
+        xor     eax, eax
-        cmp     eax, [ebp + http_msg.buffer_length]
+        dec     eax
-        je      .got_all_data
+        ret
-  .not_finished:
+  .got_all_data_chunked:
-;        DEBUGF  1, "Needs more processing...\n"
+        mov     eax, [ebp + http_msg.chunk_ptr]
-        popa
+        sub     eax, [ebp + http_msg.header_length]
-        xor     eax, eax
+        sub     eax, http_msg.data
-        dec     eax
+        sub     eax, ebp
-        ret
+        mov     [ebp + http_msg.content_length], eax
   .got_all_data:
-        DEBUGF  1, "We got all the data!\n"
+        DEBUGF  1, "We got all the data! (%u bytes)\n", [ebp + http_msg.content_length]
         or      [ebp + http_msg.flags], FLAG_GOT_DATA
         mcall   close, [ebp + http_msg.socket]

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/http/http.asm – Rev 4161 → 4162