Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;                                                  ;

;      BROWSER for KolibriOS                       ;

;                                                  ;

;      Compile with FASM                           ;

;                                                  ;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; It's a work in progress but I (esevece) commit it, because if I don't continue developing it someone can continue.

; Please, keep the code clean

; The header

use32                                   ; Tell compiler to use 32 bit instructions

org 0x0                                 ; the base address of code, always 0x0

db 'MENUET01'

dd 0x01

dd START

dd I_END

dd 0x100000

dd 0x7fff0

dd 0, 0

; The code area

;include 'macros.inc'

START:                                  ; start of execution

        call    draw_window             ; draw the window

; After the window is drawn, it's practical to have the main loop.

; Events are distributed from here.

event_wait:

        mov     eax, 10                 ; function 10 : wait until event

        int     0x40                    ; event type is returned in eax

        cmp     eax, 1                  ; Event redraw request ?

        je      redraw                  ; Expl.: there has been activity on screen and

                                        ; parts of the applications has to be redrawn.

        cmp     eax, 2                  ; Event key in buffer ?

        je      key                     ; Expl.: User has pressed a key while the

                                        ; app is at the top of the window stack.

        cmp     eax, 3                  ; Event button in buffer ?

        je      button                  ; Expl.: User has pressed one of the

                                        ; applications buttons.

        jmp     event_wait

;  The next section reads the event and processes data.

redraw:                                 ; Redraw event handler

        call    draw_window             ; We call the window_draw function and

        jmp     event_wait              ; jump back to event_wait

key:                                    ; Keypress event handler

        mov     eax, 2                  ; The key is returned in ah. The key must be

        int     0x40                    ; read and cleared from the system queue.

        jmp     event_wait              ; Just read the key, ignore it and jump to event_wait.

button:                                 ; Buttonpress event handler

        mov     eax,17                  ; The button number defined in window_draw

        int     0x40                    ; is returned to ah.

        cmp     ah,1                    ; button id=1 ?

        jne     noclose

        mov     eax,-1                  ; Function -1 : close this program

        int     0x40

noclose:

        cmp     ah, 2                   ; call fetch_thread

        jne     no_fetch_thread

        call    fetch_thread

        jmp     event_wait              ; This is for ignored events, useful at development

no_fetch_thread:

        jmp     event_wait

; FETCHER

FETCH:

        mov     ecx, 1000

get_free_port:

        inc     ecx

        mov     eax, 53

        mov     ebx, 9

        int     0x40

        cmp     eax, 0    ; is port used?

        jz      get_free_port

open_socket:

        mov     eax, 53

        mov     ebx, 5

        mov     edx, 80

        mov     esi, 0x0417042E ; 46.4.23.4 (kolibrios.org), only for try

        mov     edi, 1

        int     0x40

        mov     [socket], eax

        cmp     [socket], -1    ; error?

        jne      status_socket

        ret

status_socket:

        mov     eax, 53

        mov     ebx, 6

        mov     ecx, [socket]

        int     0x40

        cmp     eax, 4   ; connected?

        jne     status_socket

send_request:

.concat_request:

        mov     edi, request

        mov     ebx, 0   ; request_length

        mov     esi, request_first_line

._first_line:

        movsb

        inc     ebx  ; request_length

        cmp     byte [edi], 0

        jne     ._first_line

        mov     esi, request_second_line

._second_line:

        movsb

        inc     ebx  ; request_length

        cmp     byte [edi], 0

        jne     ._second_line

        mov     esi, host

._second_line_host:

        movsb

        inc     ebx  ; request_length

        cmp     byte [edi], 0

        jne     ._second_line_host

        mov     esi, request_third_line

._third_line:

        movsb

        inc     ebx  ; request_length

        cmp     byte [edi], 0

        jne     ._third_line

        mov     [request_length], ebx

.write_to_socket:

        mov     eax, 53

        mov     ebx, 7

        mov     ecx, [socket]

        mov     edx, [request_length]

        mov     esi, request

        int     0x40

        cmp     eax, -1   ; error?

        je      .write_to_socket

.poll_socket:

	mov     eax, 53

	mov     ebx, 2

	mov     ecx, [socket]

	int     0x40

	cmp     eax, 0

	jne      .read_socket

	; only for test purposes

	mov     eax, 63

        mov     ebx, 1

        mov     cl,  's'

        int     0x40

.status_socket:

	mov     eax, 53

	mov	ebx, 6

	mov	ecx, [socket]

	int	0x40

	cmp	eax, 4

	jne	end_of_request

.read_socket:

	mov     eax, 53

	mov	ebx, 11

	mov 	ecx, [socket]

	mov	edx, [buffer]

	mov     esi, 4096

	int	0x40

	; only for test purposes

	mov     eax, 63

        mov     ebx, 1

        mov     cl,  'p'

        int     0x40

	jmp	.poll_socket

end_of_request:

.close_socket:

        mov     eax, 53

        mov     ebx, 8

        mov     ecx, [socket]

        int     0x40

        ; only for test purposes

        mov     eax, 63

        mov     ebx, 1

        mov     cl,  'b'

        int     0x40

        jmp    terminate_thread

fetch_thread:

        cmp     [thread_id], 0

        jne     terminate_thread

        mov     eax, 51

        mov     ebx, 1

        mov     ecx, FETCH

        mov     edx, [thread_stack]

        int     0x40

        jmp     event_wait

no_new_thread:

        ret

terminate_thread:

        mov     eax, 18

        mov     ebx, 18

        mov     ecx, [thread_id]

        int     0x40

        cmp     eax, 0

        jne 	terminate_thread

        mov     [thread_id], 0

        ret

thread_stack dd 0x80000

thread_id    dd 0x0

;  *********************************************

;  ******  WINDOW DEFINITIONS AND DRAW  ********

;  *********************************************

;

;  The static window parts are drawn in this function. The window canvas can

;  be accessed later from any parts of this code (thread) for displaying

;  processes or recorded data, for example.

;

;  The static parts *must* be placed within the fn 12 , ebx = 1 and ebx = 2.

draw_window:

        mov     eax, 12                 ; function 12: tell os about windowdraw

        mov     ebx, 1                  ; 1, start of draw

        int     0x40

        mov     eax, 0                  ; function 0 : define and draw window

        mov     ebx, 100 * 65536 + 300  ; [x start] *65536 + [x size]

        mov     ecx, 100 * 65536 + 120  ; [y start] *65536 + [y size]

        mov     edx, 0x14ffffff         ; color of work area RRGGBB

                                        ; 0x02000000 = window type 4 (fixed size, skinned window)

        mov     esi, 0x808899ff         ; color of grab bar  RRGGBB

                                        ; 0x80000000 = color glide

        mov     edi, title

        int     0x40

        ; Fetch button

        mov     eax, 8

        mov     ebx, 25 * 65536 + 128

        mov     ecx, 88 * 65536 + 20

        mov     edx, 2

        mov     esi, 0x6677cc

        int     0x40

        mov     ebx, 25 * 65536 + 35    ; draw info text with function 4

        mov     ecx, 0x224466

        mov     edx, text

        mov     esi, 40

        mov     eax, 4

  .newline:                             ; text from the DATA AREA

        int     0x40

        add     ebx, 10

        add     edx, 40

        cmp     byte[edx], 0

        jne     .newline

        mov     eax, 12                 ; function 12:tell os about windowdraw

        mov     ebx, 2                  ; 2, end of draw

        int     0x40

        ret

;  *********************************************

;  *************   DATA AREA   *****************

;  *********************************************

;

; Data can be freely mixed with code to any parts of the image.

; Only the header information is required at the beginning of the image.

text    db  "It look's like you have just compiled   "

        db  "your first program for KolibriOS.       "

        db  "                                        "

        db  "Congratulations!                        ", 0

title   db  "KolibriOS Browser", 0

socket          dd  0

socket_status   dd  0

server_ip       db  046,004,023,004

server_port     db  0,0

request_first_line  db 'GET / HTTP/1.1',0

request_second_line db 13,10,'Host: ',0

request_third_line  db 13,10,'Connection: close',13,10,13,10,0

request             db 0

request_length      dd 0

host                db 'kolibrios.org',0

buffer		dd  0

I_END:

; The area after I_END is free for use as the application memory,

; just avoid the stack.

;

; Application memory structure, according to the used header, 1 Mb.

;

; 0x00000   - Start of compiled image

; I_END     - End of compiled image

;

;           + Free for use in the application

;

; 0x7ff00   - Start of stack area

; 0x7fff0   - End of stack area                 - defined in the header

;

;           + Free for use in the application

;

; 0xFFFFF   - End of freely useable memory      - defined in the header

;

; All of the the areas can be modified within the application with a

; direct reference.

; For example, mov [0x80000],byte 1 moves a byte above the stack area.