badpork/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

Trying to make a web browser

Browse Source 
git-svn-id: svn://kolibrios.org@3530 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
esevece 2013-05-23 01:50:34 +00:00
parent 560ccdd0f3
commit 4d079770dc
3 changed files with 340 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

321
programs/network/browser/browser.asm Normal file
View File

@ -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.

6
programs/network/browser/build.bat Executable file
View File

@ -0,0 +1,6 @@
@erase lang.inc
@echo lang fix en >lang.inc
@fasm browser.asm browser
@kpack browser
@erase lang.inc
@pause

13
programs/network/browser/build.sh Executable file
View File

@ -0,0 +1,13 @@
#!/bin/bash
# This script does for linux the same as build.bat for DOS,
# it compiles the KoOS kernel, hopefully ;-)
echo "lang fix en"
echo "lang fix en" > lang.inc
fasm -m 16384 browser.asm browser
rm -f lang.inc
exit 0