WebSVN – Kolibri OS – Diff – /kernel/branches/net/applications/ircc/serverparser.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;                                                                 ;;
;;         GNU GENERAL PUBLIC LICENSE                              ;;
;;          Version 2, June 1991                                   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
server_parser:
 
        mov     esi, servercommand
 
        cmp     byte [esi], ':'
        jne     .parse
 
  .spaceloop:
        lodsb
        test    al, al
        jz      .fail
        cmp     al, ' '
        jne     .spaceloop
 
  .parse:
        mov     eax, [esi]
        or      eax, 0x20202020
        mov     edi, server_commands
        mov     ecx, server_commands.number
 
  .loop:
        scasd
        je      .got_cmd
        add     edi, 4
        dec     ecx
        jnz     .loop
 
  .fail:
        ret
 
  .got_cmd:
        jmp     dword[edi]
 
 
server_commands:
 
        dd      '328 ', cmd_328
        dd      '332 ', cmd_topic
        dd      '333 ', cmd_333         ; nickname and time of topic
        dd      '353 ', cmd_353         ; name reply
        dd      '366 ', cmd_366         ; end of names list
        dd      '372 ', cmd_372         ; motd
        dd      '375 ', cmd_375         ; start of motd
        dd      '376 ', cmd_376         ; end of motd
        dd      '421 ', cmd_421         ; unknown command
        dd      'join', cmd_join
        dd      'kick', cmd_kick
        dd      'mode', cmd_mode
        dd      'nick', cmd_nick
        dd      'part', cmd_part
        dd      'ping', cmd_ping
        dd      'priv', cmd_privmsg
        dd      'quit', cmd_quit
        dd      'noti', cmd_notice
 
        .number = ($ - server_commands) / 8
 
compare_to_nick:
 
        push    esi
        mov     ecx, MAX_NICK_LEN
        mov     esi, user_nick
  .loop:
        lodsb
        cmp     al, ' '
        jbe     .done
        cmp     al, 'a'
        jb      .ok
        cmp     al, 'z'
        ja      .ok
        sub     al, 0x20
  .ok:
 
        mov     bl, byte[edi]
        cmp     bl, 'a'
        jb      .ok2
        cmp     bl, 'z'
        ja      .ok2
        sub     bl, 0x20
  .ok2:
        cmp     bl, al
        jne     .not_equal
        inc     edi
        dec     ecx
        jnz     .loop
 
  .done:
        xor     eax, eax
        pop     esi
        ret
 
  .not_equal:
        or      eax, -1
        pop     esi
        ret
 
 
 
find_window:
 
;        mov     [window_print],
 
        ret
 
 
 
cmd_328:
cmd_421:
cmd_372:
cmd_375:
cmd_376:
        add     esi, 4
        jmp     cmd_notice.loop
 
cmd_notice:
 
        cmp     byte[servercommand], ':'
        jne     .gogogo
 
        mov     byte [esi-1], 0
        push    esi
        mov     esi, str_1
        call    print_text2
        mov     esi, servercommand+1
        call    print_text2
        mov     esi, str_2
        call    print_text2
        pop     esi
 
  .gogogo:
        add     esi, 6
 
  .loop:
        inc     esi
        cmp     byte [esi], 0
        je      .fail
;        cmp     byte [esi], 10  ; newline
;        je      server_parser.parse
        cmp     byte [esi], ' '
        jne     .loop
 
  .loop2:
        inc     esi
        cmp     byte [esi], 0
        je      .fail
        cmp     byte [esi], ' '
        je      .loop2
        cmp     byte [esi], ':'
        je      .loop2
 
        call    print_text2
        mov     esi, str_newline
        call    print_text2
 
  .fail:
 
        ret
 
 
 
cmd_ping:
 
; Just change PING to PONG
        mov     dword[esi], 'PONG'
 
; Find the end of the command
        lea     edi, [esi + 5]
        xor     al, al
        repne   scasb
 
; Now send it back
        mov     edx, esi
        mov     esi, edi
        mov     word [esi], 0x0d0a
        inc     esi
        inc     esi
        sub     esi, edx
        mcall   send, [socketnum], , , 0
 
        ret
 
 
 
cmd_privmsg:
 
        add     esi, 8  ; skip 'PRIVMSG '
 
; Check if it was destined for me privately
        mov     edi, servercommand+1
        call    compare_to_nick
;;;        je      .private
 
; If not, find the correct window ???
 
; now find the end of nick
        mov     edi, esi
  .loop:
        inc     edi
        cmp     byte [edi], 0
        je      .fail
        cmp     byte [edi], ' '
        jne     .loop
 
  .loop2:
        inc     edi
        cmp     byte [edi], 0
        je      .fail
        cmp     byte [edi], ' '
        je      .loop2
        cmp     byte [edi], ':'
        je      .loop2
        cmp     byte [edi], 1
        je      cmd_ctcp
 
; Action?
        cmp     dword[edi+1], 'ACTI'
        je      .action
 
; nope, just plain old privmsg
if TIMESTAMP
        call    print_timestamp
end if
 
        push    edi
        mov     bl, '<'
        call    print_character
 
        mov     eax, servercommand+1
        mov     dl, '!'
        call    print_text
 
        mov     bl, '>'
        call    print_character
 
        mov     bl, ' '
        call    print_character
 
        pop     esi
        call    print_text2
 
        mov     bl, 10
        call    print_character
 
  .fail:
        ret
 
  .action:
        push    edi
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, action_header_short
        call    print_text2
 
        mov     eax, servercommand+1
        mov     dl, ' '
        call    print_text
 
        mov     bl, ' '
        call    print_character
 
        pop     esi
        add     esi, 8
        call    print_text2
 
        mov     bl, 10
        call    print_character
 
        ret
 
cmd_ctcp:
 
        cmp     dword[edi+1], 'VERS'
        je      .version
 
        cmp     dword[edi+1], 'TIME'
        je      .time
 
        cmp     dword[edi+1], 'PING'
        je      .ping
 
        ret
 
  .time:
        lea     esi, [edi+1]
        mov     byte [edi+5], ' '
        add     edi, 6
 
        ; TODO: add system date (fn 29) in human readable format
 
        mcall   3                       ; get system time
 
        mov     ecx, 3
  .timeloop:
        mov     bl, al
        shr     al, 4
        add     al, '0'
        stosb
 
        mov     al, bl
        and     al, 0x0f
        add     al, '0'
        stosb
 
        dec     ecx
        jz      .timedone
 
        mov     al, ':'
        stosb
        shr     eax, 8
        jmp     .timeloop
 
  .timedone:
        xor     al, al
        stosb
        call    ctcp_reply
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, ctcp_header
        call    print_text2
 
        mov     esi, servercommand+1
        call    print_text2
 
        mov     esi, ctcp_time
        call    print_text2
 
        ret
 
  .version:
        mov     esi, str_version
        call    ctcp_reply
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, ctcp_header
        call    print_text2
 
        mov     esi, servercommand+1
        call    print_text2
 
        mov     esi, ctcp_version
        call    print_text2
 
        ret
 
  .ping:
        lea     esi, [edi+1]
        call    ctcp_reply
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, ctcp_header
        call    print_text2
 
        mov     esi, servercommand+1
        call    print_text2
 
        mov     esi, ctcp_ping
        call    print_text2
 
        ret
 
 
 
ctcp_reply:
 
        push    esi
 
        mov     dword [usercommand], 'NOTI'
        mov     dword [usercommand+4], 'CE  '
 
        mov     esi, servercommand+1
        mov     edi, usercommand+7
  .nickloop:
        lodsb
        cmp     al, '!'
        je      .done
        cmp     al, ' '
        je      .done
        test    al, al
        je      .fail
        stosb
        jmp     .nickloop
  .done:
        mov     byte [esi-1], 0
        mov     ax, ' :'
        stosw
        mov     al, 1
        stosb
 
        pop     esi
  .replyloop:
        lodsb
        cmp     al, 1
        jbe     .done2
        stosb
        jmp     .replyloop
  .done2:
 
        mov     al, 1
        stosb
        mov     ax, 0x0a0d
        stosw
 
        lea     esi, [edi - usercommand]
        mcall   send, [socketnum], usercommand, , 0
  .fail:
        ret
 
 
 
cmd_part:
        add     esi, 5  ; skip 'PART '
 
; Is it me who parted?
        mov     edi, servercommand+1
        call    compare_to_nick
        jne     .dont_close
 
; yes, close the window
        mov     edi, [window_print]
        mov     [edi + window.flags], FLAG_UPDATED + FLAG_CLOSE
 
        ret
 
; somebody else parted, just print message
  .dont_close:
        push    esi
        mov     esi, action_header
        call    print_text2
 
        mov     eax, servercommand+1
        mov     dl, '!'
        mov     cl, ' '
        call    print_text
 
        mov     esi, has_left_channel
        call    print_text2
 
        pop     esi
        call    print_text2
 
        mov     esi, str_newline
        call    print_text2
 
;;; TODO: dec [window.users], remove username from the userlist
 
 
        ret
 
 
 
cmd_join:
        add     esi, 5  ; skip 'JOIN '
 
; compare nick: did we join a channel?
        mov     edi, servercommand+1
        call    compare_to_nick
        jne     .no_new_window
 
; create channel window - search for empty slot
        mov     ebx, windows
        mov     ecx, MAX_WINDOWS
  .loop:
        cmp     [ebx + window.data_ptr], 0
        je      .free_found
        add     ebx, sizeof.window
        dec     ecx
        jnz     .loop
; Error: no more available windows!! ;;;;; TODO
  .fail:
        ret
 
  .free_found:
        push    ebx
        call    window_create
        pop     ebx
        test    eax, eax
        jz      .fail
        mov     [ebx + window.data_ptr], eax
        mov     [ebx + window.type], WINDOWTYPE_CHANNEL
        mov     [ebx + window.flags], 0
 
        call    window_set_name
 
        mov     [window_open], ebx
        mov     [window_print], ebx
        call    window_refresh
 
        push    esi
        mov     esi, action_header
        call    print_text2
 
        mov     esi, str_talking
        call    print_text2
 
        pop     eax
        mov     dl, ' '
        call    print_text
 
        mov     esi, str_dotnewline
        call    print_text2
 
        call    draw_window
 
        ret
 
  .no_new_window:
        push    esi
        call    window_set_name
 
        mov     esi, action_header
        call    print_text2
 
        mov     eax, servercommand+1
        mov     dl, ' '
        call    print_text
 
        mov     esi, joins_channel
        call    print_text2
 
        pop     esi
        call    print_text2
 
        mov     esi, str_newline
        call    print_text2
 
;;; TODO: inc [window.users], add username to the userlist
 
        ret
 
 
 
 
cmd_nick:       ; FIXME
 
        add     esi, 5  ; skip 'NICK '
 
        push    esi
; test for change of my nick
        mov     esi, servercommand+1
        mov     edi, user_nick
        mov     ecx, MAX_NICK_LEN
        rep     cmpsb
        cmp     byte[edi-1], 0
        jne     .notmy
        cmp     byte[esi-1], '!'
        jne     .notmy
 
; yes, this is my nick, set to new
        pop     esi
        or      ecx, -1
        mov     edi, esi
        xor     eax, eax
        repne   scasb
        neg     ecx
        cmp     ecx, MAX_NICK_LEN
        jb      @f
        mov     ecx, MAX_NICK_LEN
      @@:
        mov     edi, user_nick
        rep     movsb
  .notmy:
 
; replace nick in all lists of users
        mov     ebx, windows
  .channels:
        mov     esi, [ebx + window.data_ptr]
        lea     esi, [esi + window_data.names]
;;;;;        mov     edx, [esi + window_data.nameslen]
        add     edx, esi
  .nicks:
        mov     edi, servercommand+1
        cmp     byte[esi], '@'
        jne     @f
        inc     esi
 
  @@:
        cmp     esi, edx
        jae     .srcdone
        lodsb
        cmp     al, ' '
        je      .srcdone
        scasb
        je      @b
 
  @@:
        cmp     esi, edx
        jae     .nextchannel
        lodsb
        cmp     al, ' '
        jne     @b
 
  .nextnick:
        cmp     esi, edx
        jae     .nextchannel
        lodsb
        cmp     al, ' '
        jz      .nextnick
        dec     esi
        jmp     .nicks
 
 
  .srcdone:
        cmp     byte [edi], '!'
        jne     .nextnick
 
; here we have esi -> end of nick which must be replaced to [servercommand_position]+6
        lea     edx, [edi-servercommand-1]
        sub     esi, edx
        or      ecx, -1
        xor     eax, eax
;        mov     edi, [servercommand_position]        ;;;;; FIXME
        repnz   scasb
        not     ecx
        dec     ecx
        push    ecx
        cmp     ecx, edx
        jb      .decrease
        jz      .copy
  .increase:
 
; new nick is longer than the old
        push    esi
        lea     edi, [ebx+120*10] ;;;;;;
        lea     esi, [edi+edx]
        sub     esi, ecx
        mov     ecx, esi
        sub     ecx, [esp]
        dec     esi
        dec     edi
        std
        rep     movsb
        cld
        pop     esi
        jmp     .copy
  .decrease:
; new nick is shorter than the old
        push    esi
        lea     edi, [esi+ecx]
        add     esi, edx
        lea     ecx, [ebx+120*10]
        sub     ecx, edi
        rep     movsb
        pop     esi
  .copy:
; copy nick
        mov     edi, esi
        dec     edi
;        mov     esi, [servercommand_position]        ;;;;; FIXME
        pop     ecx
        sub     edx, ecx
        sub     [ebx-4], edx
        rep     movsb
        mov     al, ' '
        stosb
 
  .nextchannel:
        add     ebx, sizeof.window
        cmp     ebx, windows + sizeof.window*MAX_WINDOWS
        jb      .channels
 
;        mov  [text_start], window_text + 120*80
 new_all_channels3:
 
        mov     esi, action_header_short
        call    print_text2
 
        mov     eax, servercommand+1
        mov     dl,'!'
        call    print_text
 
        mov     esi,is_now_known_as
        call    print_text2
 
;       mov     esi,[servercommand_position]        ;;;;; FIXME
        call    print_text2
 
;;;        call    notify_channel_thread
 
; go to next window (and check if its a channel!)
 
;        add     [text_start], 120*80
;        cmp     [text_start], I_END+120*80*20
;        jb      new_all_channels3
 
        ret
 
 
 
 
cmd_kick:
        add     esi, 5  ; skip 'KICK '
; Is it me who got kicked?
        mov     edi, servercommand+1
        call    compare_to_nick
        jne     .not_me
 
; TODO: mark channel as disconnected
 
  .not_me:
; find the channel user has been kicked from
        push    esi
        mov     esi, action_header_short
        call    print_text2
 
        mov     eax, servercommand+1
        mov     dl,'!'
        call    print_text
 
        mov     esi, kicked
        call    print_text2
 
        pop     esi
        call    print_text2
 
;;; TODO: dec [window.users], remove username from the userlist
 
        ret
 
 
 
cmd_quit:
 
        mov     esi, action_header
        call    print_text2
 
        mov     eax, servercommand+1
        mov     dl, '!'
        call    print_text
 
        mov     esi, has_quit_irc
        call    print_text2
 
;;; TODO: dec [window.users], remove username from the userlist
 
        ret
 
 
 
cmd_mode:
 
        add     esi, 5  ; skip 'MODE '
 
        push    esi
        mov     esi, action_header_short
        call    print_text2
 
        mov     eax, servercommand+1
        mov     dl, ' '
        call    print_text
 
        mov     esi, sets_mode
        call    print_text2
 
        pop     esi
        call    print_text2
 
        mov     esi, str_newline
        call    print_text2
 
;;; TODO: change username if needed
 
        ret
 
 
cmd_353:        ; channel usernames reply
 
        add     esi, 4  ; skip '353 '
 
; TODO: mark a bit that we are receiving names
 
; first, find the channel name
  .loop1:
        lodsb
        cmp     al, '#'
        je      .got_channel
        test    al, al
        jnz     .loop1
 
        ret
 
  .got_channel:
;        call    find_channel   ;;;; ASSUME current channel for now
        mov     ebx, [window_print]
        mov     [ebx + window.users], 0              ;;; FIXME: Only if we have just set the receiving names bit
        mov     eax, [ebx + window.data_ptr]
        lea     edi, [eax + window_data.names]
        mov     edx, edi
 
; now find the semicolon separating channelname and usernames
  .loop2:
        lodsb
        cmp     al, ':'
        je      .newname
        test    al, al
        jnz     .loop2
 
        ret
 
  .next:
        add     edx, MAX_NICK_LEN
        mov     edi, edx
;;;        cmp     edi, ..              ; TODO: Check for buffer overflow
        jmp     .namesloop            ;;;;
 
  .newname:
        inc     [ebx + window.users]
  .namesloop:
; now the names list begins, separated with spaces
        lodsb
        test    al, al
        jz      .done
        cmp     al, ' '
        jz      .next
        stosb
        jmp     .namesloop
 
 
 
 
 
 
 
 
 
  .done:
        call    users_calculate
        call    print_channel_list
 
        ret
 
 
users_calculate:
 
 
 
 
 
 
 
 
        mov     ebx, [window_print]
        mov     eax, [ebx + window.users]
        mov     [scroll1.max_area], eax
        ; TODO: check if cur pos isnt greater then max
 
        ; OK, now redraw the scrollbar
        mov     [scroll1.all_redraw], 1
        push    dword scroll1
        call    [scrollbar_v_draw]
 
        ret
 
 
 
 
 
cmd_366:        ; channel usernames end
 
; TODO: clear the bit that we are receiving names
 
 
        ret
 
 
cmd_topic:
 
        add     esi, 4  ; skip '332 '
 
  .loop:
        lodsb
        test    al, al
        je      .fail
        cmp     al, ':'
        jne     .loop
 
        push    esi
        mov     esi, action_header
        call    print_text2
 
        mov     esi, str_topic
        call    print_text2
 
        pop     esi
        call    print_text2
 
        mov     esi, str_newline
        call    print_text2
 
  .fail:
        ret
 
 
cmd_333:
 
        add     esi, 4  ; skip '333 '
 
; TODO: check channelname and change pointer accordingly
 
        mov     ecx, 3  ; number of spaces to find
  .loop:
        lodsb
        test    al, al
        je      .fail
        cmp     al, ' '
        jne     .loop
        dec     ecx
        jnz     .loop   ; find some more spaces
 
        push    esi
        mov     esi, action_header
        call    print_text2
 
        mov     esi, str_setby
        call    print_text2
 
        pop     esi
        call    print_text2
 
        mov     esi, str_newline
        call    print_text2
 
  .fail:
        ret
>

Rev 3215	Rev 3216
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; ;;	6	;; ;;
7	;; GNU GENERAL PUBLIC LICENSE ;;	7	;; GNU GENERAL PUBLIC LICENSE ;;
8	;; Version 2, June 1991 ;;	8	;; Version 2, June 1991 ;;
9	;; ;;	9	;; ;;
10	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	10	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11		11
12		12
13	server_parser:	13	server_parser:
14		14
15	mov esi, servercommand	15	mov esi, servercommand
16		16
17	cmp byte [esi], ':'	17	cmp byte [esi], ':'
18	jne .parse	18	jne .parse
19		19
20	.spaceloop:	20	.spaceloop:
21	lodsb	21	lodsb
22	test al, al	22	test al, al
23	jz .fail	23	jz .fail
24	cmp al, ' '	24	cmp al, ' '
25	jne .spaceloop	25	jne .spaceloop
26		26
27	.parse:	27	.parse:
28	mov eax, [esi]	28	mov eax, [esi]
29	or eax, 0x20202020	29	or eax, 0x20202020
30	mov edi, server_commands	30	mov edi, server_commands
31	mov ecx, server_commands.number	31	mov ecx, server_commands.number
32		32
33	.loop:	33	.loop:
34	scasd	34	scasd
35	je .got_cmd	35	je .got_cmd
36	add edi, 4	36	add edi, 4
37	dec ecx	37	dec ecx
38	jnz .loop	38	jnz .loop
39		39
40	.fail:	40	.fail:
41	ret	41	ret
42		42
43	.got_cmd:	43	.got_cmd:
44	jmp dword[edi]	44	jmp dword[edi]
45		45
46		46
47	server_commands:	47	server_commands:
48		48
49	dd '328 ', cmd_328	49	dd '328 ', cmd_328
50	dd '332 ', cmd_topic	50	dd '332 ', cmd_topic
51	dd '333 ', cmd_333 ; nickname and time of topic	51	dd '333 ', cmd_333 ; nickname and time of topic
52	dd '353 ', cmd_353 ; name reply	52	dd '353 ', cmd_353 ; name reply
53	dd '366 ', cmd_366 ; end of names list	53	dd '366 ', cmd_366 ; end of names list
54	dd '372 ', cmd_372 ; motd	54	dd '372 ', cmd_372 ; motd
55	dd '375 ', cmd_375 ; start of motd	55	dd '375 ', cmd_375 ; start of motd
56	dd '376 ', cmd_376 ; end of motd	56	dd '376 ', cmd_376 ; end of motd
57	dd '421 ', cmd_421 ; unknown command	57	dd '421 ', cmd_421 ; unknown command
58	dd 'join', cmd_join	58	dd 'join', cmd_join
59	dd 'kick', cmd_kick	59	dd 'kick', cmd_kick
60	dd 'mode', cmd_mode	60	dd 'mode', cmd_mode
61	dd 'nick', cmd_nick	61	dd 'nick', cmd_nick
62	dd 'part', cmd_part	62	dd 'part', cmd_part
63	dd 'ping', cmd_ping	63	dd 'ping', cmd_ping
64	dd 'priv', cmd_privmsg	64	dd 'priv', cmd_privmsg
65	dd 'quit', cmd_quit	65	dd 'quit', cmd_quit
66	dd 'noti', cmd_notice	66	dd 'noti', cmd_notice
67		67
68	.number = ($ - server_commands) / 8	68	.number = ($ - server_commands) / 8
69		69
70	compare_to_nick:	70	compare_to_nick:
71		71
72	push esi	72	push esi
73	mov ecx, MAX_NICK_LEN	73	mov ecx, MAX_NICK_LEN
74	mov esi, user_nick	74	mov esi, user_nick
75	.loop:	75	.loop:
76	lodsb	76	lodsb
77	cmp al, ' '	77	cmp al, ' '
78	jbe .done	78	jbe .done
79	cmp al, 'a'	79	cmp al, 'a'
80	jb .ok	80	jb .ok
81	cmp al, 'z'	81	cmp al, 'z'
82	ja .ok	82	ja .ok
83	sub al, 0x20	83	sub al, 0x20
84	.ok:	84	.ok:
85		85
86	mov bl, byte[edi]	86	mov bl, byte[edi]
87	cmp bl, 'a'	87	cmp bl, 'a'
88	jb .ok2	88	jb .ok2
89	cmp bl, 'z'	89	cmp bl, 'z'
90	ja .ok2	90	ja .ok2
91	sub bl, 0x20	91	sub bl, 0x20
92	.ok2:	92	.ok2:
93	cmp bl, al	93	cmp bl, al
94	jne .not_equal	94	jne .not_equal
95	inc edi	95	inc edi
96	dec ecx	96	dec ecx
97	jnz .loop	97	jnz .loop
98		98
99	.done:	99	.done:
100	xor eax, eax	100	xor eax, eax
101	pop esi	101	pop esi
102	ret	102	ret
103		103
104	.not_equal:	104	.not_equal:
105	or eax, -1	105	or eax, -1
106	pop esi	106	pop esi
107	ret	107	ret
108		108
109		109
110		110
111	find_window:	111	find_window:
112		112
113	; mov [window_print],	113	; mov [window_print],
114		114
115	ret	115	ret
116		116
117		117
118		118
119	cmd_328:	119	cmd_328:
120	cmd_421:	120	cmd_421:
121	cmd_372:	121	cmd_372:
122	cmd_375:	122	cmd_375:
123	cmd_376:	123	cmd_376:
124	add esi, 4	124	add esi, 4
125	jmp cmd_notice.loop	125	jmp cmd_notice.loop
126		126
127	cmd_notice:	127	cmd_notice:
128		128
129	cmp byte[servercommand], ':'	129	cmp byte[servercommand], ':'
130	jne .gogogo	130	jne .gogogo
131		131
132	mov byte [esi-1], 0	132	mov byte [esi-1], 0
133	push esi	133	push esi
134	mov esi, str_1	134	mov esi, str_1
135	call print_text2	135	call print_text2
136	mov esi, servercommand+1	136	mov esi, servercommand+1
137	call print_text2	137	call print_text2
138	mov esi, str_2	138	mov esi, str_2
139	call print_text2	139	call print_text2
140	pop esi	140	pop esi
141		141
142	.gogogo:	142	.gogogo:
143	add esi, 6	143	add esi, 6
144		144
145	.loop:	145	.loop:
146	inc esi	146	inc esi
147	cmp byte [esi], 0	147	cmp byte [esi], 0
148	je .fail	148	je .fail
149	; cmp byte [esi], 10 ; newline	149	; cmp byte [esi], 10 ; newline
150	; je server_parser.parse	150	; je server_parser.parse
151	cmp byte [esi], ' '	151	cmp byte [esi], ' '
152	jne .loop	152	jne .loop
153		153
154	.loop2:	154	.loop2:
155	inc esi	155	inc esi
156	cmp byte [esi], 0	156	cmp byte [esi], 0
157	je .fail	157	je .fail
158	cmp byte [esi], ' '	158	cmp byte [esi], ' '
159	je .loop2	159	je .loop2
160	cmp byte [esi], ':'	160	cmp byte [esi], ':'
161	je .loop2	161	je .loop2
162		162
163	call print_text2	163	call print_text2
164	mov esi, str_newline	164	mov esi, str_newline
165	call print_text2	165	call print_text2
166		166
167	.fail:	167	.fail:
168		168
169	ret	169	ret
170		170
171		171
172		172
173	cmd_ping:	173	cmd_ping:
174		174
175	; Just change PING to PONG	175	; Just change PING to PONG
176	mov dword[esi], 'PONG'	176	mov dword[esi], 'PONG'
177		177
178	; Find the end of the command	178	; Find the end of the command
179	lea edi, [esi + 5]	179	lea edi, [esi + 5]
180	xor al, al	180	xor al, al
181	repne scasb	181	repne scasb
182		182
183	; Now send it back	183	; Now send it back
184	mov edx, esi	184	mov edx, esi
185	mov esi, edi	185	mov esi, edi
186	mov word [esi], 0x0d0a	186	mov word [esi], 0x0d0a
187	inc esi	187	inc esi
188	inc esi	188	inc esi
189	sub esi, edx	189	sub esi, edx
190	mcall send, [socketnum], , , 0	190	mcall send, [socketnum], , , 0
191		191
192	ret	192	ret
193		193
194		194
195		195
196	cmd_privmsg:	196	cmd_privmsg:
197		197
198	add esi, 8 ; skip 'PRIVMSG '	198	add esi, 8 ; skip 'PRIVMSG '
199		199
200	; Check if it was destined for me privately	200	; Check if it was destined for me privately
201	mov edi, servercommand+1	201	mov edi, servercommand+1
202	call compare_to_nick	202	call compare_to_nick
203	;;; je .private	203	;;; je .private
204		204
205	; If not, find the correct window ???	205	; If not, find the correct window ???
206		206
207	; now find the end of nick	207	; now find the end of nick
208	mov edi, esi	208	mov edi, esi
209	.loop:	209	.loop:
210	inc edi	210	inc edi
211	cmp byte [edi], 0	211	cmp byte [edi], 0
212	je .fail	212	je .fail
213	cmp byte [edi], ' '	213	cmp byte [edi], ' '
214	jne .loop	214	jne .loop
215		215
216	.loop2:	216	.loop2:
217	inc edi	217	inc edi
218	cmp byte [edi], 0	218	cmp byte [edi], 0
219	je .fail	219	je .fail
220	cmp byte [edi], ' '	220	cmp byte [edi], ' '
221	je .loop2	221	je .loop2
222	cmp byte [edi], ':'	222	cmp byte [edi], ':'
223	je .loop2	223	je .loop2
224	cmp byte [edi], 1	224	cmp byte [edi], 1
225	je cmd_ctcp	225	je cmd_ctcp
226		226
227	; Action?	227	; Action?
228	cmp dword[edi+1], 'ACTI'	228	cmp dword[edi+1], 'ACTI'
229	je .action	229	je .action
230		230
231	; nope, just plain old privmsg	231	; nope, just plain old privmsg
232	if TIMESTAMP	232	if TIMESTAMP
233	call print_timestamp	233	call print_timestamp
234	end if	234	end if
235		235
236	push edi	236	push edi
237	mov bl, '<'	237	mov bl, '<'
238	call print_character	238	call print_character
239		239
240	mov eax, servercommand+1	240	mov eax, servercommand+1
241	mov dl, '!'	241	mov dl, '!'
242	call print_text	242	call print_text
243		243
244	mov bl, '>'	244	mov bl, '>'
245	call print_character	245	call print_character
246		246
247	mov bl, ' '	247	mov bl, ' '
248	call print_character	248	call print_character
249		249
250	pop esi	250	pop esi
251	call print_text2	251	call print_text2
252		252
253	mov bl, 10	253	mov bl, 10
254	call print_character	254	call print_character
255		255
256	.fail:	256	.fail:
257	ret	257	ret
258		258
259	.action:	259	.action:
260	push edi	260	push edi
261	if TIMESTAMP	261	if TIMESTAMP
262	call print_timestamp	262	call print_timestamp
263	end if	263	end if
264		264
265	mov esi, action_header_short	265	mov esi, action_header_short
266	call print_text2	266	call print_text2
267		267
268	mov eax, servercommand+1	268	mov eax, servercommand+1
269	mov dl, ' '	269	mov dl, ' '
270	call print_text	270	call print_text
271		271
272	mov bl, ' '	272	mov bl, ' '
273	call print_character	273	call print_character
274		274
275	pop esi	275	pop esi
276	add esi, 8	276	add esi, 8
277	call print_text2	277	call print_text2
278		278
279	mov bl, 10	279	mov bl, 10
280	call print_character	280	call print_character
281		281
282	ret	282	ret
283		283
284	cmd_ctcp:	284	cmd_ctcp:
285		285
286	cmp dword[edi+1], 'VERS'	286	cmp dword[edi+1], 'VERS'
287	je .version	287	je .version
288		288
289	cmp dword[edi+1], 'TIME'	289	cmp dword[edi+1], 'TIME'
290	je .time	290	je .time
291		291
292	cmp dword[edi+1], 'PING'	292	cmp dword[edi+1], 'PING'
293	je .ping	293	je .ping
294		294
295	ret	295	ret
296		296
297	.time:	297	.time:
298	lea esi, [edi+1]	298	lea esi, [edi+1]
299	mov byte [edi+5], ' '	299	mov byte [edi+5], ' '
300	add edi, 6	300	add edi, 6
301		301
302	; TODO: add system date (fn 29) in human readable format	302	; TODO: add system date (fn 29) in human readable format
303		303
304	mcall 3 ; get system time	304	mcall 3 ; get system time
305		305
306	mov ecx, 3	306	mov ecx, 3
307	.timeloop:	307	.timeloop:
308	mov bl, al	308	mov bl, al
309	shr al, 4	309	shr al, 4
310	add al, '0'	310	add al, '0'
311	stosb	311	stosb
312		312
313	mov al, bl	313	mov al, bl
314	and al, 0x0f	314	and al, 0x0f
315	add al, '0'	315	add al, '0'
316	stosb	316	stosb
317		317
318	dec ecx	318	dec ecx
319	jz .timedone	319	jz .timedone
320		320
321	mov al, ':'	321	mov al, ':'
322	stosb	322	stosb
323	shr eax, 8	323	shr eax, 8
324	jmp .timeloop	324	jmp .timeloop
325		325
326	.timedone:	326	.timedone:
327	xor al, al	327	xor al, al
328	stosb	328	stosb
329	call ctcp_reply	329	call ctcp_reply
330		330
331	if TIMESTAMP	331	if TIMESTAMP
332	call print_timestamp	332	call print_timestamp
333	end if	333	end if
334		334
335	mov esi, ctcp_header	335	mov esi, ctcp_header
336	call print_text2	336	call print_text2
337		337
338	mov esi, servercommand+1	338	mov esi, servercommand+1
339	call print_text2	339	call print_text2
340		340
341	mov esi, ctcp_time	341	mov esi, ctcp_time
342	call print_text2	342	call print_text2
343		343
344	ret	344	ret
345		345
346	.version:	346	.version:
347	mov esi, str_version	347	mov esi, str_version
348	call ctcp_reply	348	call ctcp_reply
349		349
350	if TIMESTAMP	350	if TIMESTAMP
351	call print_timestamp	351	call print_timestamp
352	end if	352	end if
353		353
354	mov esi, ctcp_header	354	mov esi, ctcp_header
355	call print_text2	355	call print_text2
356		356
357	mov esi, servercommand+1	357	mov esi, servercommand+1
358	call print_text2	358	call print_text2
359		359
360	mov esi, ctcp_version	360	mov esi, ctcp_version
361	call print_text2	361	call print_text2
362		362
363	ret	363	ret
364		364
365	.ping:	365	.ping:
366	lea esi, [edi+1]	366	lea esi, [edi+1]
367	call ctcp_reply	367	call ctcp_reply
368		368
369	if TIMESTAMP	369	if TIMESTAMP
370	call print_timestamp	370	call print_timestamp
371	end if	371	end if
372		372
373	mov esi, ctcp_header	373	mov esi, ctcp_header
374	call print_text2	374	call print_text2
375		375
376	mov esi, servercommand+1	376	mov esi, servercommand+1
377	call print_text2	377	call print_text2
378		378
379	mov esi, ctcp_ping	379	mov esi, ctcp_ping
380	call print_text2	380	call print_text2
381		381
382	ret	382	ret
383		383
384		384
385		385
386	ctcp_reply:	386	ctcp_reply:
387		387
388	push esi	388	push esi
389		389
390	mov dword [usercommand], 'NOTI'	390	mov dword [usercommand], 'NOTI'
391	mov dword [usercommand+4], 'CE '	391	mov dword [usercommand+4], 'CE '
392		392
393	mov esi, servercommand+1	393	mov esi, servercommand+1
394	mov edi, usercommand+7	394	mov edi, usercommand+7
395	.nickloop:	395	.nickloop:
396	lodsb	396	lodsb
397	cmp al, '!'	397	cmp al, '!'
398	je .done	398	je .done
399	cmp al, ' '	399	cmp al, ' '
400	je .done	400	je .done
401	test al, al	401	test al, al
402	je .fail	402	je .fail
403	stosb	403	stosb
404	jmp .nickloop	404	jmp .nickloop
405	.done:	405	.done:
406	mov byte [esi-1], 0	406	mov byte [esi-1], 0
407	mov ax, ' :'	407	mov ax, ' :'
408	stosw	408	stosw
409	mov al, 1	409	mov al, 1
410	stosb	410	stosb
411		411
412	pop esi	412	pop esi
413	.replyloop:	413	.replyloop:
414	lodsb	414	lodsb
415	cmp al, 1	415	cmp al, 1
416	jbe .done2	416	jbe .done2
417	stosb	417	stosb
418	jmp .replyloop	418	jmp .replyloop
419	.done2:	419	.done2:
420		420
421	mov al, 1	421	mov al, 1
422	stosb	422	stosb
423	mov ax, 0x0a0d	423	mov ax, 0x0a0d
424	stosw	424	stosw
425		425
426	lea esi, [edi - usercommand]	426	lea esi, [edi - usercommand]
427	mcall send, [socketnum], usercommand, , 0	427	mcall send, [socketnum], usercommand, , 0
428	.fail:	428	.fail:
429	ret	429	ret
430		430
431		431
432		432
433	cmd_part:	433	cmd_part:
434	add esi, 5 ; skip 'PART '	434	add esi, 5 ; skip 'PART '
435		435
436	; Is it me who parted?	436	; Is it me who parted?
437	mov edi, servercommand+1	437	mov edi, servercommand+1
438	call compare_to_nick	438	call compare_to_nick
439	jne .dont_close	439	jne .dont_close
440		440
441	; yes, close the window	441	; yes, close the window
442	mov edi, [window_print]	442	mov edi, [window_print]
443	mov [edi + window.flags], FLAG_UPDATED + FLAG_CLOSE	443	mov [edi + window.flags], FLAG_UPDATED + FLAG_CLOSE
444		444
445	ret	445	ret
446		446
447	; somebody else parted, just print message	447	; somebody else parted, just print message
448	.dont_close:	448	.dont_close:
449	push esi	449	push esi
450	mov esi, action_header	450	mov esi, action_header
451	call print_text2	451	call print_text2
452		452
453	mov eax, servercommand+1	453	mov eax, servercommand+1
454	mov dl, '!'	454	mov dl, '!'
455	mov cl, ' '	455	mov cl, ' '
456	call print_text	456	call print_text
457		457
458	mov esi, has_left_channel	458	mov esi, has_left_channel
459	call print_text2	459	call print_text2
460		460
461	pop esi	461	pop esi
462	call print_text2	462	call print_text2
463		463
464	mov esi, str_newline	464	mov esi, str_newline
465	call print_text2	465	call print_text2
466		466
467	;;; TODO: dec [window.users], remove username from the userlist	467	;;; TODO: dec [window.users], remove username from the userlist
468		468
469		469
470	ret	470	ret
471		471
472		472
473		473
474	cmd_join:	474	cmd_join:
475	add esi, 5 ; skip 'JOIN '	475	add esi, 5 ; skip 'JOIN '
476		476
477	; compare nick: did we join a channel?	477	; compare nick: did we join a channel?
478	mov edi, servercommand+1	478	mov edi, servercommand+1
479	call compare_to_nick	479	call compare_to_nick
480	jne .no_new_window	480	jne .no_new_window
481		481
482	; create channel window - search for empty slot	482	; create channel window - search for empty slot
483	mov ebx, windows	483	mov ebx, windows
484	mov ecx, MAX_WINDOWS	484	mov ecx, MAX_WINDOWS
485	.loop:	485	.loop:
486	cmp [ebx + window.data_ptr], 0	486	cmp [ebx + window.data_ptr], 0
487	je .free_found	487	je .free_found
488	add ebx, sizeof.window	488	add ebx, sizeof.window
489	dec ecx	489	dec ecx
490	jnz .loop	490	jnz .loop
491	; Error: no more available windows!! ;;;;; TODO	491	; Error: no more available windows!! ;;;;; TODO
492	.fail:	492	.fail:
493	ret	493	ret
494		494
495	.free_found:	495	.free_found:
496	push ebx	496	push ebx
497	call window_create	497	call window_create
498	pop ebx	498	pop ebx
499	test eax, eax	499	test eax, eax
500	jz .fail	500	jz .fail

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/applications/ircc/serverparser.inc – Rev 3215 → 3216