/programs/network/vncc/structs.inc |
---|
File deleted |
\ No newline at end of file |
/programs/network/vncc/logon.inc |
---|
1,204 → 1,43 |
red_logon: |
call draw_window_logon ; at first, draw the window |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2010-2015. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;; VNC client for KolibriOS ;; |
;; ;; |
;; Written by hidnplayr@kolibrios.org ;; |
;; ;; |
;; GNU GENERAL PUBLIC LICENSE ;; |
;; Version 2, June 1991 ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
still_logon: ; main cycle of application begins here |
mov eax,10 ; wait here for event |
mcall |
logon: |
mcall 40, EVM_MOUSE + EVM_MOUSE_FILTER + EVM_REDRAW + EVM_BUTTON + EVM_KEY |
checkevent_logon: ; Check what event was called _logon: this will be used to return from textbox focus |
dec eax ; redraw request ? |
jz red_logon |
dec eax ; key in buffer ? |
jz key_logon |
dec eax ; button in buffer ? |
jz button_logon |
jmp still_logon |
key_logon: ; key event handler |
mov al,2 ; eax was zero so will now be 2 |
mcall ; just read it and ignore |
cmp ah,13 |
jne still_logon ; return to main loop |
ret ; enter key was pressed => return to logon |
button_logon: ; eax was zero so will now be 17 |
mov al,17 ; get id |
mcall |
cmp ah,1 ; close ? |
jz close_logon |
cmp ah,2 ; logon ? |
je connect_logon |
cmp ah,5 ; first ? |
jz dstbtn_logon |
srcbtn_logon: |
mov dword[addr],first |
jmp rk_logon |
dstbtn_logon: |
mov dword[addr],second |
rk_logon: |
mov edi,[addr] ; load the address of the string |
xor al,al ; mov al,0 ; the symbol we will search for |
mov ecx,STRLEN+1 ; length of the string (+1) |
cld ; search forward |
repne scasb ; do search now |
inc ecx ; we've found a zero or ecx became 0 |
mov eax,STRLEN+1 |
sub eax,ecx ; eax = address of <0> character |
mov [temp],eax ; position |
cmp dword[addr],dword second |
jne @f |
mov dword [passlen],eax |
@@: |
call print_text_logon |
mov edi,[addr] ; address of string |
add edi,[temp] ; cursor position |
.waitev_logon: |
mov eax,10 ; wait for event |
mcall |
cmp eax,2 ; button presed ? |
jne checkevent_logon ; a key is pressed or redraw is nessesary, goto checkevent |
mcall ; eax = 2, read button |
shr eax,8 |
cmp eax,8 |
jnz .nobs_logon ; BACKSPACE |
cmp edi,[addr] |
jz .waitev_logon |
dec edi |
mov byte[edi],0 |
cmp dword[addr],second |
jne @f |
dec [passlen] |
@@: |
call print_text_logon |
jmp .waitev_logon |
.nobs_logon: |
cmp eax,13 ; ENTER |
je still_logon |
cmp eax,192 |
jne .noclear_logon |
xor al,al |
mov edi,[addr] |
mov ecx,STRLEN |
rep stosb |
mov edi,[addr] |
call print_text_logon |
jmp .waitev_logon |
.noclear_logon: |
mov [edi],al |
cmp dword[addr],second |
jne @f |
inc [passlen] |
@@: |
call print_text_logon |
inc edi |
mov esi,[addr] |
add esi,STRLEN |
cmp esi,edi |
jnz .waitev_logon |
jmp still_logon |
; print strings (source & destination) |
print_text_logon: |
pusha |
mov eax, 8 |
mov ebx, 105*65536+200 |
mov ecx, 31*65536+13 |
mov edx, 4 |
mov esi, 0xEBEBEB |
mcall |
cmp byte[mode],0 |
je @f |
mov ecx, 49*65536+12 |
inc edx |
mcall |
@@: |
mov eax, 4 ; function 4 _logon: write text to window |
mov ebx, 107*65536+34 ; [x start] *65536 + [y start] |
xor ecx, ecx ; color of text RRGGBB |
mov edx, first ; pointer to text beginning |
mov esi, STRLEN ; text length |
mcall |
cmp byte[mode],0 |
je dont_draw_pass |
add ebx,16 |
mov edi,[passlen] |
@@: |
cmp edi,0 |
jle dont_draw_pass |
dec edi |
mov edx, passchar |
mov esi, 1 |
mcall |
add ebx,6*65536 |
jmp @r |
dont_draw_pass: |
popa |
ret |
close_logon: |
or eax,-1 |
mcall |
connect_logon: |
ret |
draw_window_logon: |
.redraw: |
mcall 12, 1 ; start window draw |
pusha |
; DRAW WINDOW |
xor eax, eax ; function 0 _logon: define and draw window |
mov ebx, 160*65536+330 ; [x start] *65536 + [x size] |
mov ecx, 160*65536+100 ; [y start] *65536 + [y size] |
mov edx, 0x13DDDDDD ; color of work area RRGGBB |
mov edi, title ; WINDOW LABEL |
mov ebx, 160 shl 16 + 330 ; [x start]:[x size] |
mov ecx, 160 shl 16 + 100 ; [y start]:[y size] |
mov edx, 0x34DDDDDD ; color of work area RRGGBB |
mov edi, name ; WINDOW LABEL |
mcall |
mov eax, 8 ; LOGON BUTTON |
mov ebx, 220*65536+85 |
mov ecx, 63*65536+16 |
mov ebx, 220 shl 16 + 85 |
mov ecx, 47 shl 16 + 16 |
mov edx, 2 |
mov esi, 0xCCCCCC |
mcall |
call print_text_logon |
cmp byte[mode], 0 |
je servermode_ |
je .servermode |
mov eax, 4 ; function 4 write text to window |
mov ebx, 25*65536+33 ; [x start] *65536 + [y start] |
mov ebx, 25 shl 16 + 15 ; [x start]:[y start] |
xor ecx, ecx |
mov edx, userstr ; pointer to text beginning |
mov esi, passstr-userstr ; text length |
209,20 → 48,20 |
mov esi, connectstr-passstr ; text length |
mcall |
jmp drawtherest_ |
jmp .drawtherest |
servermode_: |
.servermode: |
mov eax, 4 ; function 4 write text to window |
mov ebx, 25*65536+33 ; [x start] *65536 + [y start] |
mov ebx, 25 shl 16 + 15 ; [x start] *65536 + [y start] |
xor ecx, ecx |
mov edx, serverstr ; pointer to text beginning |
mov esi, userstr-serverstr ; text length |
mcall |
drawtherest_: |
invoke edit_box_draw, URLbox |
mov ebx, 240*65536+67 ; [x start] *65536 + [y start] |
.drawtherest: |
mov ebx, 240 shl 16 + 49 ; [x start] *65536 + [y start] |
mov edx, connectstr ; pointer to text beginning |
mov esi, connect_e-connectstr ; text length |
mcall |
231,17 → 70,56 |
inc ebx |
mcall |
.loop: |
mcall 10 ; wait for event |
dec eax ; redraw request ? |
jz .redraw |
dec eax ; key in buffer ? |
jz .key |
dec eax ; button in buffer ? |
jz .btn |
sub eax, 3 |
jz .mouse |
jmp .loop |
.key: ; key event handler |
mcall 2 ; read key |
test [URLbox.flags], ed_focus |
jz mainloop |
cmp ah, 13 ; enter (return) key |
je .go |
invoke edit_box_key, URLbox |
jmp .loop |
.go: |
mov eax, [URLbox.pos] |
mov byte[serveraddr+eax], 0 |
ret |
.btn: |
mcall 17 ; get id |
cmp ah, 1 ; close ? |
jz .close |
cmp ah, 2 ; logon ? |
je .go |
jmp .loop |
.mouse: |
mcall 23 |
invoke edit_box_mouse, URLbox |
jmp .loop |
.close: |
mcall -1 |
; DATA AREA |
title db 'Kolibrios VNC client by HIDNPLAYR',0 |
first: db '192.168.1.5' |
rb STRLEN |
second: rb STRLEN |
passchar db '*' |
passchar db "*" |
passlen dd 0 |
addr dd 0 |
248,10 → 126,10 |
temp dd 0 |
mode db 0 ; 0 = connection details, 1 = authentication |
serverstr: db 'server:' |
userstr: db 'username:' |
passstr: db 'password:' |
connectstr: db 'connect !' |
serverstr db "server:" |
userstr db "username:" |
passstr db "password:" |
connectstr db "connect !" |
connect_e: |
I_END_logon: |
/programs/network/vncc/raw.inc |
---|
1,153 → 1,78 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2010-2015. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;; VNC client for KolibriOS ;; |
;; ;; |
;; Written by hidnplayr@kolibrios.org ;; |
;; ;; |
;; GNU GENERAL PUBLIC LICENSE ;; |
;; Version 2, June 1991 ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
encoding_raw: |
DEBUGF 1,'RAW\n' |
mov ax,[frame.y] ; |
mov bx,[screen.width] ; |
mul bx ; |
shl edx,16 ; |
mov dx,ax ; [screen.width]*[frame.y] |
movzx eax,[frame.x] |
add edx,eax ; [screen.width]*[frame.y]+[frame.x] |
DEBUGF 1,"RAW\n" |
mov eax,3 ; |
mul edx ; ([screen.width]*[frame.y]+[frame.x])*3 |
movzx eax, [rectangle.width] |
movzx ebx, [rectangle.height] |
mul ebx |
add eax, esi |
@@: |
cmp [datapointer], eax |
jae @f |
push eax |
call read_data.more |
pop eax |
jmp @b |
@@: |
add eax,framebuffer_data ; |
push eax ; framebuffer_data+([screen.width]*[frame.y]+[frame.x])*3 |
movzx eax, [rectangle.y] |
movzx ebx, [screen.width] |
mul ebx ; [screen.width]*[rectangle.y] |
movzx ebx, [rectangle.x] |
add eax, ebx ; [screen.width]*[rectangle.y]+[rectangle.x] |
lea edi, [framebuffer_data+eax*3] ; edi = framebuffer_data+([screen.width]*[rectangle.y]+[rectangle.x])*3 |
mov ax,[frame.width] ; |
mov bx,3 ; |
mul bx ; |
shl edx,16 ; |
mov dx,ax ; [frame.width]*3 |
movzx eax, [screen.width] |
sub ax, [rectangle.width] |
lea ebp, [eax*3] ; ebp = ([screen.width]-[rectangle.width])*3 |
pop eax ; |
add edx,eax ; framebuffer_data+([screen.width]*[frame.y]+[frame.x])*3+[frame.width]*3 |
push eax ; |
push edx ; |
mov bl, 85 |
mov ax,[frame.height] ; |
dec ax ; |
mov bx,3 ; |
mul bx ; |
mov bx,[screen.width] ; |
mul bx ; |
shl edx,16 ; |
mov dx,ax ; |
mov ecx,edx ; |
pop edx ; |
add ecx,edx ; mov ecx,edx+([frame.height]-1)*[screen.width]*3 |
pop ebx |
movzx edx, [rectangle.height] |
.pixelloop32: |
cmp ebx,ecx |
jge next_rectangle |
.lineloop: |
movzx ecx, [rectangle.width] |
; add esi,2 ; 32 bit code RAW - OK |
; mov al,[esi] ; |
; mov [ebx],al ; |
; inc ebx ; |
; dec esi ; |
; ; |
; mov al,[esi] ; |
; mov [ebx],al ; |
; inc ebx ; |
; dec esi ; |
; ; |
; mov al,[esi] ; |
; mov [ebx],al ; |
; inc ebx ; |
; add esi,4 ; |
.pixelloop: |
mov al, [esi] |
shr al, 4 |
and al, 3 |
mul bl |
stosb |
; push ecx ; 16 bit code RAW |
; mov cl,51 |
; |
; mov ax,[esi] ; |
; xchg al,ah |
; and al,00011111b ; |
; xchg al,ah |
; mul cl |
; mov [ebx],al ; |
; inc ebx ; |
; |
; mov ax,[esi] ; |
; xchg al,ah |
; shr ax,5 ; |
; xchg al,ah |
; and al,00011111b ; |
; mul cl |
; mov [ebx],al ; |
; inc ebx ; |
; |
; mov ax,[esi] ; |
; xchg al,ah |
; shr ax,10 ; |
; and al,00011111b ; |
; mul cl |
; mov [ebx],al ; |
; inc ebx ; |
; |
; inc esi ; |
; inc esi ; |
; pop ecx |
mov al, [esi] |
shr al, 2 |
and al, 3 |
mul bl |
stosb |
push ecx ; 8 bit code RAW - OK |
mov cl,85 ; |
; |
mov al,[esi] ; |
shr al,4 ; |
and al,3 ; |
mul cl ; |
mov [ebx],al ; |
inc ebx ; |
; |
mov al,[esi] ; |
shr al,2 ; |
and al,3 ; |
mul cl ; |
mov [ebx],al ; |
inc ebx ; |
; |
mov al,[esi] ; |
and al,3 ; |
mul cl ; |
mov byte[ebx],al ; |
inc ebx ; |
inc esi ; |
pop ecx ; |
mov al, [esi] |
and al, 3 |
mul bl |
stosb |
inc esi |
dec ecx |
jnz .pixelloop |
cmp ebx,edx |
jl .pixelloop32 |
add edi, ebp |
dec edx |
jnz .lineloop |
jmp next_rectangle |
push edx |
push ebx |
mov ax,[screen.width] |
mov bx,3 |
mul bx |
shl edx,16 |
mov dx,ax |
mov eax,edx |
pop ebx |
pop edx |
add ebx,eax ; eax = [screen.width]*3 |
add edx,eax |
push edx |
push ebx |
mov ax,[frame.width] |
mov bx,3 |
mul bx |
shl edx,16 |
mov dx,ax |
mov eax,edx |
pop ebx |
pop edx |
sub ebx,eax ; eax = [frame.width]*3 |
jmp .pixelloop32 |
/programs/network/vncc/thread.inc |
---|
1,13 → 1,26 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2010-2015. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;; VNC client for KolibriOS ;; |
;; ;; |
;; Written by hidnplayr@kolibrios.org ;; |
;; ;; |
;; GNU GENERAL PUBLIC LICENSE ;; |
;; Version 2, June 1991 ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
thread_start: |
DEBUGF 1, 'I am the thread!\n' |
DEBUGF 1, "I am the thread!\n" |
mcall 40, 0 |
mcall 40, 0 ; disable all events |
; resolve name |
push esp ; reserve stack place |
invoke getaddrinfo, first, 0, 0, esp |
invoke getaddrinfo, serveraddr, 0, 0, esp |
pop esi |
; test for error |
test eax, eax |
17,22 → 30,27 |
mov eax, [eax+sockaddr_in.sin_addr] |
mov [sockaddr1.ip], eax |
; DEBUGF 1, 'Connecting to %u.%u.%u.%u:%u\n', \ |
; [server_ip]:1, [server_ip+1]:1, \ |
; [server_ip+2]:1, [server_ip+3]:1, \ |
; [server_port]:2 |
DEBUGF 1, "Connecting to %u.%u.%u.%u:%u\n", \ |
[sockaddr1.ip]:1, [sockaddr1.ip+1]:1, \ |
[sockaddr1.ip+2]:1, [sockaddr1.ip+3]:1, \ |
[sockaddr1.port]:2 |
mcall socket, AF_INET4, SOCK_STREAM, 0 |
test eax, eax |
jz exit |
;;; invoke freeaddrinfo, ?? |
mov [socketnum], eax |
mcall connect, [socketnum], sockaddr1, 18 |
;;; test eax, eax |
; TODO: implement timeout |
call wait_for_data |
cmp dword [receive_buffer], 'RFB ' |
cmp dword[receive_buffer], "RFB " |
jne no_rfb |
DEBUGF 1, 'received: %s\n', receive_buffer |
DEBUGF 1, "received: %s\n", receive_buffer |
mcall send, [socketnum], handshake, 12, 0 |
DEBUGF 1, 'Sending handshake: protocol version\n' |
DEBUGF 1, "Sending handshake: protocol version\n" |
call wait_for_data |
45,187 → 63,212 |
cmp dword [receive_buffer], 0x02000000 |
je vnc_security |
DEBUGF 1, "Unknown security type\n" |
jmp exit |
vnc_security: |
mov byte[mode], 1 |
call red_logon |
call logon |
no_security: |
mcall send, [socketnum], shared, 1, 0 |
DEBUGF 1, 'Sending handshake: shared session?\n' |
mcall send, [socketnum], ClientInit, 1, 0 |
DEBUGF 1, "ClientInit sent\n" |
call wait_for_data ; now the server should send init message |
DEBUGF 1, 'Serverinit: bpp: %u depth: %u bigendian: %u truecolor: %u\n', \ |
DEBUGF 1, "Serverinit: bpp: %u depth: %u bigendian: %u truecolor: %u\n", \ |
[receive_buffer+framebuffer.pixelformat.bpp]:1, \ |
[receive_buffer+framebuffer.pixelformat.depth]:1, \ |
[receive_buffer+framebuffer.pixelformat.big_endian]:1, \ |
[receive_buffer+framebuffer.pixelformat.true_color]:1 |
mov eax, dword [receive_buffer] |
mov eax, dword[receive_buffer+framebuffer.width] |
mov dword [fbur.width], eax |
bswap eax |
mov dword [screen], eax |
DEBUGF 1, "Screen width=%u, height=%u\n", [screen.width]:2, [screen.height]:2 |
mcall send, [socketnum], pixel_format8, 20, 0 |
DEBUGF 1, 'Sending pixel format\n' |
call read_data |
DEBUGF 1, "Sending pixel format\n" |
; eth.write_tcp [socket],8,encodings |
; DEBUGF 1,'Sending encoding info\n' |
; call read_data |
mcall send, [socketnum], encodings, 8, 0 |
DEBUGF 1, "Sending encoding info\n" |
mov byte [thread_ready], 1 |
mov [thread_ready], 1 |
request_rfb: |
mov [fbur.inc], 2 |
; Request initial update |
mov [fbur.inc], 0 |
request_fbu: |
DEBUGF 1, "Requesting framebuffer update\n" |
mcall send, [socketnum], fbur, 10, 0 |
mov [fbur.inc], 1 |
thread_loop: |
call read_data ; Read the data into the buffer |
; cmp eax, 2 |
; jb mainloop |
DEBUGF 1,'Data received, %u bytes\n', eax |
cmp byte [receive_buffer],0 |
lodsb |
cmp al, 0 |
je framebufferupdate |
cmp byte [receive_buffer],1 |
cmp al, 1 |
je setcolourmapentries |
cmp byte [receive_buffer],2 |
cmp al, 2 |
je bell |
cmp byte [receive_buffer],3 |
cmp al, 3 |
je servercuttext |
DEBUGF 1, "Unknown server command: %u\n", al |
jmp thread_loop |
align 4 |
framebufferupdate: |
mov ax, word [receive_buffer+2] |
@@: |
lea eax, [esi+6] |
cmp [datapointer], eax |
jae @f |
call read_data.more |
jmp @b |
@@: |
inc esi ; padding |
lodsw |
xchg al, ah |
mov di, ax |
DEBUGF 1, 'Framebufferupdate: %u frames\n', di |
mov esi, receive_buffer+4 |
jmp rectangle_loop |
mov [rectangles], ax |
DEBUGF 1, "Framebufferupdate: %u rectangles\n", ax |
rectangle_loop: |
next_rectangle: |
call drawbuffer |
@@: |
lea eax, [esi+12] |
cmp [datapointer], eax |
jae @f |
call read_data.more |
jmp @b |
@@: |
dec di |
test di, di |
jz request_rfb |
lodsd ; position |
bswap eax |
mov [rectangle.y], ax |
shr eax, 16 |
mov [rectangle.x], ax |
rectangle_loop: |
lodsd ; size |
bswap eax |
mov [rectangle.height], ax |
shr eax, 16 |
mov [rectangle.width], ax |
mov edx, [esi] |
bswap edx |
mov ebx, edx |
shr edx, 16 |
mov [frame.x], dx |
mov [frame.y], bx |
add esi, 4 |
mov ecx, [esi] |
bswap ecx |
mov eax, ecx |
shr ecx, 16 |
mov [frame.width], cx |
mov [frame.height], ax |
add esi, 4 |
mov eax, [esi] |
add esi, 4 |
lodsd ; encoding |
DEBUGF 1, "rectangle: width=%u height=%u x=%u y=%u encoding: ",\ |
[rectangle.width]:2, [rectangle.height]:2, [rectangle.x]:2, [rectangle.y]:2 |
mov ebx, esi |
sub ebx, receive_buffer+12 |
DEBUGF 1, 'frame: width=%u height=%u x=%u y=%u offset:%u encoding:',\ |
[frame.width]:2, [frame.height]:2, [frame.x]:2, [frame.y]:2, ebx |
cmp eax, 0 |
je encoding_raw |
; cmp eax, 1 |
; je encoding_copyrect |
cmp eax, 2 |
je encoding_RRE |
cmp eax, 5 |
je encoding_hextile |
cmp eax, 16 |
je encoding_ZRLE |
; cmp eax, 2 |
; je encoding_RRE |
; cmp eax, 5 |
; je encoding_hextile |
; cmp eax, 15 |
; je encoding_TRLE |
; cmp eax, 16 |
; je encoding_ZRLE |
mov ebx, esi |
sub ebx, receive_buffer+8 |
DEBUGF 1, '\nunknown encoding: %u (offset %u)\n', eax, ebx |
jmp bell |
DEBUGF 1, "\nunknown encoding: %u\n", eax |
jmp thread_loop |
encoding_RRE: |
;; jmp rectangle_loop |
DEBUGF 1, 'RRE\n' |
next_rectangle: |
push esi |
call drawbuffer |
pop esi |
jmp next_rectangle |
dec [rectangles] |
jnz rectangle_loop |
jmp request_fbu |
encoding_hextile: |
DEBUGF 1, 'hextile\n' |
setcolourmapentries: |
jmp next_rectangle |
DEBUGF 1, "Server sent SetColourMapEntries message\n" |
encoding_ZRLE: |
; TODO |
DEBUGF 1, 'ZRLE\n' |
jmp next_rectangle |
setcolourmapentries: |
DEBUGF 1, 'Server sent SetColourMapEntries message\n' |
jmp thread_loop |
bell: |
mcall 55, 55, , , beep |
jmp thread_loop |
servercuttext: |
DEBUGF 1, 'Server cut text\n' |
DEBUGF 1, "Server cut text\n" |
@@: |
lea eax, [esi+7] |
cmp [datapointer], eax |
jae @f |
call read_data.more |
jmp @b |
@@: |
add esi, 3 |
lodsd |
bswap eax |
mov ecx, eax |
@@: |
lea eax, [esi+ecx] |
cmp [datapointer], eax |
jae @f |
call read_data.more |
jmp @b |
@@: |
; TODO: paste text to clipboard |
DEBUGF 1, "%u bytes of text\n", ecx |
add esi, ecx |
jmp thread_loop |
read_data: |
mov [datapointer], receive_buffer |
.loop: |
mov esi, receive_buffer |
.more: |
push ebx ecx edx esi edi |
mcall recv, [socketnum], [datapointer], 4096, 0 |
pop edi esi edx ecx ebx |
cmp eax, -1 |
je .done |
add [datapointer], eax |
je .error |
add [datapointer], eax ; TODO: check for buffer overflow |
cmp eax, 4096 |
je .loop |
je .more |
ret |
.done: |
mov eax, [datapointer] |
sub eax, receive_buffer |
.error: |
DEBUGF 1, "Socket error!\n" |
mcall -1 |
ret |
wait_for_data: |
wait_for_data: ; FIXME: add timeout |
mcall recv, [socketnum], receive_buffer, 4096, 0 |
cmp eax, -1 |
je wait_for_data |
je .error |
test eax, eax |
jz wait_for_data |
ret |
.error: |
DEBUGF 1, "Socket error!\n" |
mcall -1 |
ret |
/programs/network/vncc/vncc.asm |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2010-2013. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2010-2015. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;; vncc.asm - VNC client for KolibriOS ;; |
17,7 → 17,6 |
__DEBUG__ = 1 |
__DEBUG_LEVEL__ = 1 |
STRLEN = 64 ; password and server max length |
xpos = 4 ; coordinates of image |
ypos = 22 ; |
27,7 → 26,7 |
org 0x0 |
db 'MENUET01' ; 8 byte id |
db "MENUET01" ; 8 byte id |
dd 0x01 ; header version |
dd START ; start of code |
dd I_END ; size of image |
36,18 → 35,40 |
dd 0x0 , 0x0 ; I_Param , I_Path |
include '../../macros.inc' |
include '../../debug-fdo.inc' |
include '../../proc32.inc' |
include '../../dll.inc' |
include '../../struct.inc' |
include '../../network.inc' |
include "../../macros.inc" |
include "../../debug-fdo.inc" |
include "../../proc32.inc" |
include "../../dll.inc" |
include "../../struct.inc" |
include "../../develop/libraries/box_lib/trunk/box_lib.mac" |
include "../../network.inc" |
include 'structs.inc' |
include 'logon.inc' |
include 'raw.inc' |
include 'thread.inc' |
struct pixel_format |
bpp db ? |
depth db ? |
big_endian db ? |
true_color db ? |
red_max dw ? |
green_max dw ? |
blue_max dw ? |
red_shift db ? |
green_shift db ? |
blue_shift db ? |
padding rb 3 |
ends |
struct framebuffer |
width dw ? |
height dw ? |
pixelformat pixel_format |
name_length dd ? |
name rb 256 |
ends |
include "logon.inc" |
include "raw.inc" |
include "thread.inc" |
START: |
mcall 68, 11 ; init heap |
57,13 → 78,13 |
test eax, eax |
jnz exit |
call red_logon |
call logon |
mcall 40, 0 ; no events |
mcall 40, 0 ; disable all events |
mcall 67, 0, 0, 0, 0 ; resize the window (hide it) |
mcall 51, 1, thread_start, thread_stack |
DEBUGF 1,'Thread created: %u\n', eax |
DEBUGF 1,"Thread created: %u\n", eax |
@@: |
mcall 5, 10 |
70,9 → 91,8 |
cmp byte [thread_ready], 0 |
je @r |
mcall 40, 100111b ; mouse, button, key, redraw |
mcall 40, EVM_MOUSE + EVM_MOUSE_FILTER + EVM_KEY + EVM_REDRAW + EVM_BUTTON |
mov edx, dword [screen] |
movzx esi, dx |
shr edx, 16 |
81,25 → 101,21 |
mcall 67, 10, 10 ; resize the window |
mainloop: |
mcall 23, 50 ; wait for event, 0,5s timeout |
mcall 10 ; wait for event |
dec eax |
jz redraw |
dec eax |
jz key |
dec eax |
jz button |
sub eax, 3 |
jz mouse |
jmp mainloop |
key: |
DEBUGF 1,'Sending key event\n' |
; DEBUGF 1,"Sending key event\n" |
mcall 2 |
mov byte [keyevent.key+3], ah |
109,7 → 125,7 |
mouse: |
DEBUGF 1,'Sending mouse event\n' |
; DEBUGF 1,"Sending mouse event\n" |
mcall 37, 1 ; get mouse pos |
sub eax, xpos shl 16 + ypos |
121,7 → 137,7 |
mcall 37, 2 ; get mouse buttons |
test al, 00000010b ; test if right button was pressed (bit 1 in kolibri) |
jz @f |
add al, 00000010b ; in RFB protocol it is bit 2, so if we add bit 2 again, we'll get bit 3 and bit 1 will remain the same |
add al, 00000010b ; in RFB protocol it is bit 2, so if we add bit 2 again, we"ll get bit 3 and bit 1 will remain the same |
@@: |
mov [pointerevent.mask],al |
130,7 → 146,7 |
redraw: |
DEBUGF 1,'Drawing window\n' |
; DEBUGF 1,"Drawing window\n" |
mcall 12, 1 |
148,25 → 164,23 |
jmp mainloop |
drawbuffer: |
mcall 7, framebuffer_data, dword[screen], 0 |
ret |
button: |
mcall 17 ; get id |
exit: |
DEBUGF 1, 'Closing time!\n' |
DEBUGF 1, "Closing time!\n" |
mcall close, [socketnum] |
mcall -1 |
no_rfb: |
DEBUGF 1, 'This is no vnc server!\n' |
DEBUGF 1, "This is no vnc server!\n" |
jmp exit |
invalid_security: |
DEBUGF 1, 'Security error: %s\n', receive_buffer+5 |
DEBUGF 1, "Security error: %s\n", receive_buffer+5 |
jmp exit |
174,12 → 188,12 |
include_debug_strings ; ALWAYS present in data section |
handshake db 'RFB 003.003', 10 |
shared db 0 |
handshake db "RFB 003.003", 10 |
ClientInit db 0 ; not shared |
beep db 0x85,0x25,0x85,0x40,0 |
pixel_format32 db 0 ; setPixelformat |
rb 3 ; padding |
db 0, 0, 0 ; padding |
.bpp db 32 ; bits per pixel |
.depth db 32 ; depth |
.big_endian db 0 ; big-endian flag |
190,10 → 204,10 |
.red_shif db 0 ; red-shift |
.green_shift db 8 ; green-shift |
.blue_shift db 16 ; blue-shift |
rb 3 ; padding |
db 0, 0, 0 ; padding |
pixel_format16 db 0 ; setPixelformat |
rb 3 ; padding |
db 0, 0, 0 ; padding |
.bpp db 16 ; bits per pixel |
.depth db 15 ; depth |
.big_endian db 0 ; big-endian flag |
204,10 → 218,10 |
.red_shif db 0 ; red-shift |
.green_shift db 5 ; green-shift |
.blue_shift db 10 ; blue-shift |
rb 3 ; padding |
db 0, 0, 0 ; padding |
pixel_format8 db 0 ; setPixelformat |
rb 3 ; padding |
db 0, 0, 0 ; padding |
.bpp db 8 ; bits per pixel |
.depth db 6 ; depth |
.big_endian db 0 ; big-endian flag |
218,13 → 232,14 |
.red_shif db 0 ; red-shift |
.green_shift db 2 ; green-shift |
.blue_shift db 4 ; blue-shift |
rb 3 ; padding |
db 0, 0, 0 ; padding |
encodings db 2 ; setEncodings |
rb 1 ; padding |
db 1,0 ; number of encodings |
db 0 ; padding |
db 0, 1 ; number of encodings |
db 0,0,0,0 ; raw encoding (DWORD, Big endian order) |
db 1,0,0,0 ; Copyrect encoding |
; db 1, 0, 0, 0 ; Copyrect encoding |
; db |
fbur db 3 ; frame buffer update request |
.inc db 0 ; incremental |
251,41 → 266,65 |
rb 10 |
thread_ready db 0 |
mouse_dd dd ? |
URLbox edit_box 200, 25, 16, 0xffffff, 0x6f9480, 0, 0, 0, 65535, serveraddr, mouse_dd, ed_focus, 0, 0 |
; import |
align 4 |
@IMPORT: |
library network, 'network.obj' |
library network, "network.obj",\ |
box_lib, "box_lib.obj",\ |
archiver, "archiver.obj" |
import network, \ |
getaddrinfo, 'getaddrinfo', \ |
freeaddrinfo, 'freeaddrinfo', \ |
inet_ntoa, 'inet_ntoa' |
getaddrinfo, "getaddrinfo", \ |
freeaddrinfo, "freeaddrinfo", \ |
inet_ntoa, "inet_ntoa" |
name db 'VNC client', 0 |
import box_lib,\ |
edit_box_draw, "edit_box",\ |
edit_box_key, "edit_box_key",\ |
edit_box_mouse, "edit_box_mouse",\ |
scrollbar_v_draw, "scrollbar_v_draw",\ |
scrollbar_v_mouse, "scrollbar_v_mouse",\ |
scrollbar_h_draw, "scrollbar_h_draw",\ |
scrollbar_h_mouse, "scrollbar_h_mouse" |
import archiver,\ |
deflate_unpack, "deflate_unpack" |
name db "VNC client " |
name.dash db 0, " " |
I_END: |
servername rb 64+1 |
socketnum dd ? |
datapointer dd ? |
rectangles dw ? |
frame: |
rectangle: |
.width dw ? |
.height dw ? |
.x dw ? |
.y dw ? |
screen: |
screen: ; Remote screen resolution |
.height dw ? |
.width dw ? |
serveraddr rb 65536 |
receive_buffer rb 5*1024*1024 ; 5 mb buffer for received data (incoming frbupdate etc) |
framebuffer_data rb 1024*768*3 ; framebuffer |
framebuffer_data rb 1024*1024*3 ; framebuffer |
rb 0x1000 |
thread_stack: |
rb 0x1000 |
IM_END: |