Subversion Repositories Kolibri OS

;

;

; VNC Client for kolibrios by hidnplayr

;

;

; WORK IN PROGRESS...

;

; FEEL FREE TO CONTRIBUTE !

;

; hidnplayr@gmail.com

;

use32

		org	0x0

		db	'MENUET00'		; 8 byte id

		dd	38			; required os

		dd	START			; program start

		dd	I_END			; program image size

		dd	IM_END			; required amount of memory

		dd	0			; reserved=no extended header

__DEBUG__ equ 1

__DEBUG_LEVEL__ equ 1

STRLEN = 64

xpos = 4

ypos = 22

TIMEOUT = 60	 ; timeout in seconds

BUFFER	= 512	 ; Buffer size for DNS

include 'fdo.inc'

include 'ETH.INC'

include 'logon.inc'

include 'raw.inc'

include 'copyrect.inc'

START:				       ; start of execution

    call    red_logon

    mov     eax,40		       ; Report events

    mov     ebx,10000000b	       ; Only Stack

    int     0x40

    mov     eax,67		       ; resize the window (hide it)

    xor     ebx,ebx

    mov     ecx,ebx

    mov     edx,ebx

    mov     esi,ebx

    int     0x40

    resolve first,[server_ip]	       ; the input window putted the server @ 'first', resolve it into a real ip

    mov     [server_port],5900	       ; no port input for now, only standard port 5900

    DEBUGF  1,'connecting to %u.%u.%u.%u:%u\n',1[server_ip],1[server_ip+1],1[server_ip+2],1[server_ip+3],4[server_port]

    eth.search_port 1000,edx					  ; Find a free port starting from 1001 and store in edx

    eth.open_tcp edx,[server_port],[server_ip],1,[socket]	  ; open socket

    DEBUGF 1,'Socket opened: %u (port %u)\n',[socket],ecx

    call    read_data

    cmp     dword[receive_buffer+1],'RFB '

    jne     no_rfb

    eth.write_tcp [socket],12,handshake

    DEBUGF 1,'Sending handshake: protocol version\n'

    call    read_data

    mov     eax,receive_buffer+1

    mov     eax,[eax]

    bswap   eax

    cmp     eax,0

    je	    invalid_security

    cmp     eax,1

    je	    no_security

    cmp     eax,2

    je	    vnc_security

    jmp     close

   vnc_security:

    mov     byte[mode],1

    call    red_logon

   no_security:

    eth.write_tcp [socket],1,shared

    DEBUGF 1,'Sending handshake: shared session?\n'

    eth.wait_for_data [socket],TIMEOUT*10,close

    eth.read_data [socket],framebuffer,[datapointer],IM_END-receive_buffer ; now the server should send init message

    DEBUGF 1,'Serverinit: bpp:%u depth:%u bigendian:%u truecolor:%u\n',1[pixelformat.bpp],1[pixelformat.depth],1[pixelformat.big_endian],1[pixelformat.true_color]

    mov     eax,dword[framebuffer]

    bswap   eax

    mov     dword[screen],eax

    eth.write_tcp [socket],20,pixel_format32

    DEBUGF 1,'Sending pixel format\n'

    call    read_data

;    eth.write_tcp [socket],8,encodings

;    DEBUGF 1,'Sending encoding info\n'

;    call    read_data

    mov     eax,dword[framebuffer.width]

    mov     dword[fbur.width],eax

    mov     eax,40		   ; report events

    mov     ebx,10100111b	   ; stack, mouse, button, key, redraw

    int     0x40

    mov     eax,67		   ; resize the window

    mov     ebx,10

    mov     ecx,10

    mov     edx,dword[framebuffer]

    bswap   edx

    movzx   esi,dx

    shr     edx,16

    add     edx,2*xpos

    add     esi,ypos+xpos

    int     0x40

;    mov     byte[fbur.inc],0       ; request a framebufferupdate

;    eth.write_tcp [socket],10,fbur

  mainloop:

    eth.socket_status [socket],eax

    cmp     al,TCB_CLOSE_WAIT

    je	    close

    mov     eax,23		   ; wait for event with timeout

    mov     ebx,50		   ; 0,5 s

    int     0x40

    cmp     eax,1		   ; redraw

    je	    redraw

    cmp     eax,2		   ; key

    je	    key

    cmp     eax,3		   ; button

    je	    button

    cmp     eax,6		   ; mouse

    je	    mouse

    cmp     eax,8

    je	    network

    ; request an FRB update

    jmp     mainloop

   network:

    call    read_data		   ; Read the data into the buffer

    mov     eax,[datapointer]	   ; at least 2 bytes should be received

    sub     eax,receive_buffer

    cmp     eax,1

    jle     mainloop

    DEBUGF 1,'Data received, %u bytes\n',eax

    cmp     byte[receive_buffer],0

    je	    framebufferupdate

    cmp     byte[receive_buffer],1

    je	    setcolourmapentries

    cmp     byte[receive_buffer],2

    je	    bell

    cmp     byte[receive_buffer],3

    je	    servercuttext

    jmp     mainloop

   framebufferupdate:

    DEBUGF 1,'Framebufferupdate!\n'

    mov     di,word[receive_buffer+2]

    bswap   edi

    shr     edi,16

    mov     esi,receive_buffer+4

   rectangle_loop:

    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

    DEBUGF 1,'screen: width=%u height=%u\nframe: width=%u height=%u x=%u y=%u\n',2[screen.width],2[screen.height],2[frame.width],2[frame.height],2[frame.x],2[frame.y]

    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

    DEBUGF 1,'FRAME: unknown encoding\n'

    jmp     mainloop

   next_rectangle:

    dec     di

    pusha

    call    drawbuffer

    popa

    cmp     di,0

    jg	    rectangle_loop

    jmp     mainloop

  encoding_RRE:

    DEBUGF 1,'FRAME: RRE\n'

    jmp     next_rectangle

  encoding_hextile:

    DEBUGF 1,'FRAME: hextile\n'

    jmp     next_rectangle

  encoding_ZRLE:

    DEBUGF 1,'FRAME: ZRLE\n'

    jmp     next_rectangle

  setcolourmapentries:

    DEBUGF 1,'Server sended an SetColourMapEntries message\n'

    jmp     mainloop

  bell:

    mov     eax,55

    mov     ebx,eax

    mov     esi,beep

    int     0x40

    jmp     mainloop

  servercuttext:

    jmp mainloop

  key:

    DEBUGF 1,'Sending key event\n'

    mov     eax,2

    int     0x40

    mov     byte[keyevent.key+3],ah

;   eth.write_tcp [socket],8,keyevent

    cmp     ah,13

    jne     @f

    mov     byte[fbur.inc],1

    eth.write_tcp [socket],10,fbur

    jmp     mainloop

  @@:

    cmp     ah,30

    jne     @f

    mov     byte[fbur.inc],12

    eth.write_tcp [socket],10,fbur

    jmp     mainloop

  @@:

    mov     byte[fbur.inc],0

    eth.write_tcp [socket],10,fbur

    jmp     mainloop

  mouse:

    DEBUGF 1,'Sending mouse event\n'

    mov     eax,37

    mov     ebx,1

    int     0x40

    sub     eax,xpos*65536+ypos

    bswap   eax

    mov     word[pointerevent.x],ax

    shr     eax,16

    mov     word[pointerevent.y],ax

    mov     eax,37

    mov     ebx,2

    int     0x40

    cmp     al,2

    jne     @f	      ; in kolibri right click is 2 (decimal), in RFB protocol it is bit 2 (counting from 0)

    mov     al,100b

   @@:

    mov     byte[pointerevent.mask],al

    eth.write_tcp [socket],6,pointerevent

    jmp     mainloop

  redraw:

    DEBUGF 1,'Drawing window\n'

    mov     eax,12

    mov     ebx,1

    int     0x40

    mov     eax,0		      ; draw window

    mov     ebx,dword[framebuffer]

    bswap   ebx

    movzx   ecx,bx

    shr     ebx,16

    add     ebx,2*xpos

    add     ecx,ypos+xpos

    mov     edx,0x03ffffff

    mov     esi,0x80555599

    mov     edi,0x00ffffff

    int     0x40

    mov     eax,4		      ; label

    mov     ebx,9*65536+8

    mov     ecx,0x10ffffff

    mov     edx,name

    mov     esi,[name_length]

    bswap   esi

    int     0x40

    call    drawbuffer

    mov     eax,12

    mov     ebx,2

    int     0x40

    jmp     mainloop

  drawbuffer:

    mov     eax,7

    mov     ebx,framebuffer_data

    mov     ecx,dword[screen]

    mov     edx,xpos*65536+ypos

    int     0x40

    ret

  button:			  ; button

    mov     eax,17		  ; get id

    int     0x40

  close:

    call    read_data

;    eth.close_tcp [socket]             ; We're done, close the socket ;;; BUG WHEN CLOSING SCOKET !!

    DEBUGF 1,'Socket closed\n'

    mov     eax,-1

    int     0x40

    no_rfb:

    DEBUGF 1,'This is no vnc server!\n'

    jmp     close

    invalid_security:

    DEBUGF 1,'Security error: %s\n',receive_buffer+5

    jmp     close

read_data:

    eth.read_data [socket],receive_buffer,[datapointer],IM_END-receive_buffer

ret

; DATA AREA

include_debug_strings	 ; ALWAYS present in data section

handshake	   db 'RFB 003.003',0x0a

shared		   db 0

beep		   db 0x85,0x25,0x85,0x40,0

pixel_format32	   db 0       ; setPixelformat

		   rb 3       ; padding

.bpp		   db 32      ; bits per pixel

.depth		   db 32      ; depth

.big_endian	   db 0       ; big-endian flag

.true_color	   db 1       ; true-colour flag

.red_max	   db 0,255   ; red-max

.green_max	   db 0,255   ; green-max

.blue_max	   db 0,255   ; blue-max

.red_shif	   db 0       ; red-shift

.green_shift	   db 8       ; green-shift

.blue_shift	   db 16      ; blue-shift

		   rb 3       ; padding

pixel_format16	   db 0       ; setPixelformat

		   rb 3       ; padding

.bpp		   db 16      ; bits per pixel

.depth		   db 16      ; depth

.big_endian	   db 0       ; big-endian flag

.true_color	   db 1       ; true-colour flag

.red_max	   db 0,32    ; red-max

.green_max	   db 0,32    ; green-max

.blue_max	   db 0,64    ; blue-max

.red_shif	   db 0       ; red-shift

.green_shift	   db 5       ; green-shift

.blue_shift	   db 10      ; blue-shift

		   rb 3       ; padding

pixel_format8	   db 0       ; setPixelformat

		   rb 3       ; padding

.bpp		   db 8       ; bits per pixel

.depth		   db 8       ; depth

.big_endian	   db 0       ; big-endian flag

.true_color	   db 1       ; true-colour flag

.red_max	   db 0,7     ; red-max

.green_max	   db 0,7     ; green-max

.blue_max	   db 0,3     ; blue-max

.red_shif	   db 0       ; red-shift

.green_shift	   db 3       ; green-shift

.blue_shift	   db 6       ; blue-shift

		   rb 3       ; padding

encodings	   db 2       ; setEncodings

		   rb 1       ; padding

		   db 1,0     ; number of encodings

		   db 0,0,0,0 ; raw encoding        (DWORD, Big endian order)

		   db 1,0,0,0 ; Copyrect encoding

fbur		   db 3       ; frame buffer update request

.inc		   db 0       ; incremental

.x		   dw 0

.y		   dw 0

.width		   dw 0

.height 	   dw 0

keyevent	   db 4       ; keyevent

.down		   db 0       ; down-flag

		   dw 0       ; padding

.key		   dd 0       ; key

pointerevent	   db 5       ; pointerevent

.mask		   db 0       ; button-mask

.x		   dw 0       ; x-position

.y		   dw 0       ; y-position

I_END:

framebuffer:

.width		   dw ?

.height 	   dw ?

pixelformat:

.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

name_length	   dd ?

name		   rb 256

server_ip	   dd 0

server_port	   dd 0

socket		   dd 0

datapointer	   dd 0

frame:

.width		   dw 0

.height 	   dw 0

.x		   dw 0

.y		   dw 0

screen:

.height 	   dw 0

.width		   dw 0

dnsMsg:

receive_buffer	   rb 5*1024*1024 ; 5 mb buffer for received data (incoming frbupdate etc)

framebuffer_data   rb 1024*768*3  ; framebuffer

IM_END: