0,0 → 1,321 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
; ; |
; 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. |