WebSVN – Kolibri OS – Diff – /programs/network/ircc/serverparser.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2016. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;   Written by hidnplayr@kolibrios.org                            ;;
;;                                                                 ;;
;;         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      '001 ', cmd_welcome
        dd      '002 ', cmd_justprint
        dd      '003 ', cmd_justprint
        dd      '004 ', cmd_justprint
        dd      '005 ', cmd_justprint
 
        dd      '250 ', cmd_justprint
        dd      '251 ', cmd_justprint
        dd      '252 ', cmd_justprint
        dd      '253 ', cmd_justprint
        dd      '254 ', cmd_justprint
        dd      '255 ', cmd_justprint
 
        dd      '265 ', cmd_justprint
        dd      '266 ', cmd_justprint
 
        dd      '311 ', cmd_justprint   ; RPL_WHOISUSER
        dd      '312 ', cmd_justprint   ; RPL_WHOISSERVER
        dd      '318 ', cmd_justprint   ; RPL_ENDOFWHOIS
        dd      '322 ', cmd_322         ; RPL_LIST
        dd      '323 ', cmd_323         ; RPL_LISTEND
        dd      '324 ', cmd_justprint   ; RPL_CHANNELMODEIS
        dd      '328 ', cmd_justprint   ; RPL_CHANNEL_URL
        dd      '329 ', cmd_justprint   ; RPL_CREATIONTIME
        dd      '330 ', cmd_justprint
        dd      '332 ', cmd_topic       ; 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_justprint   ; motd
        dd      '375 ', cmd_justprint   ; start of motd
        dd      '376 ', cmd_justprint   ; end of motd
        dd      '421 ', cmd_justprint   ; unknown command
        dd      '432 ', cmd_justprint   ; erroneous nickname
        dd      '433 ', cmd_justprint   ; nickname already in use
        dd      '436 ', cmd_justprint   ; nickname collision
 
        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
 
 
align 4
compare_to_nick:
 
        push    esi
        mov     ecx, MAX_NICK_LEN
        mov     esi, user_nick
  .loop:
        lodsb
        cmp     al, ' '
        jbe     .done
        test    al, al
        jz      .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
 
 
 
align 4
skip_parameter:
 
; First: skip the parameter (scan untill space or colon)
  .part1:
        lodsb
        cmp     al, ' '
        je      .part2
        cmp     al, ':'
        jne     .part1
 
; Skip all trailing spaces
  .part3:
        lodsb
        cmp     al, ' '
        je      .part3
        dec     esi
        ret
 
; Now, skip all trailing spaces and first semicolon
  .part2:
        lodsb
        cmp     al, ' '
        je      .part2
        cmp     al, ':'
        je      .part3
        dec     esi
        ret
 
 
 
cmd_welcome:
 
        mov     [status], STATUS_LOGGED_IN
 
cmd_justprint:
 
        add     esi, 4
        call    skip_parameter          ; our nickname
 
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        ret
 
 
 
cmd_notice:
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        cmp     byte[servercommand], ':'
        jne     .gogogo
 
        mov     byte [esi-1], 0
        push    esi
        mov     esi, str_1
        call    print_asciiz
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
        mov     esi, str_2
        call    print_asciiz
        pop     esi
 
  .gogogo:
        add     esi, 6
        call    skip_parameter
        call    skip_parameter
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        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:
 
        mov     eax, dword[esi+4]
        or      eax, 0x20202020
        cmp     eax, 'msg '
        jne     .fail
        add     esi, 8          ; skip 'PRIVMSG '
 
        mov     edi, esi
        call    compare_to_nick
        jne     .channel
 
; private chat message
        push    esi
        mov     esi, servercommand+1
        call    window_open
        test    ebx, ebx
        jz      .fail2
        pop     esi
        call    skip_parameter  ; our own nickname
        jmp     .print
 
  .channel:
        call    window_open
        test    ebx, ebx
        jz      .fail
 
  .print:
        cmp     byte[esi], 1    ; Client to Client protocol?
        je      cmd_ctcp
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        push    esi
        mov     al, '<'
        call    print_char
 
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
 
        mov     al, '>'
        call    print_char
 
        mov     al, ' '
        call    print_char
 
        pop     esi
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        ret
 
  .fail2:
        pop     esi
  .fail:
        ret
 
 
 
 
cmd_ctcp:
 
        inc     esi
        mov     eax, dword[esi]
        or      eax, 0x20202020
 
        cmp     eax, 'vers'
        je      .version
        cmp     eax, 'time'
        je      .time
        cmp     eax, 'ping'
        je      .ping
        cmp     eax, 'acti'
        je      .action
        cmp     eax, 'dcc '    ; TODO
        je      cmd_dcc
 
; Unknown CTCP command: TODO: just print to window??
 
  .fail:
 
        ret
 
  .time:
        mov     byte[esi+4], ' '
        lea     edi, [esi+5]
 
        ; 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_asciiz
 
        mov     esi, servercommand+1
        call    print_asciiz
 
        mov     esi, ctcp_time
        call    print_asciiz
 
        ret
 
  .version:
        mov     esi, str_version
        call    ctcp_reply
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, ctcp_header
        call    print_asciiz
 
        mov     esi, servercommand+1
        call    print_asciiz
 
        mov     esi, ctcp_version
        call    print_asciiz
 
        ret
 
  .ping:
        call    ctcp_reply
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, ctcp_header
        call    print_asciiz
 
        mov     esi, servercommand+1
        call    print_asciiz
 
        mov     esi, ctcp_ping
        call    print_asciiz
 
        ret
 
  .action:
        add     esi, 7
        push    esi
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, action_header
        call    print_asciiz
 
        mov     esi, servercommand+1    ; print nickname
        mov     bl, '!'
        call    print_string
 
        mov     al, ' '
        call    print_char
 
        pop     esi
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        ret
 
 
cmd_dcc:
        add     esi, 4
        mov     eax, dword[esi]
        or      eax, 0x202020
 
        cmp     eax, 'send'
        je      .send
 
        ret
 
  .send:
        call    window_open
        test    ebx, ebx
        jz      .fail
        mov     [ebx + window.type], WINDOWTYPE_DCC
 
  .fail:
 
        ret
 
 
 
ctcp_reply:
 
        push    esi
        mov     dword[user_command], 'NOTI'
        mov     dword[user_command+4], 'CE  '
 
        mov     esi, servercommand+1
        mov     edi, user_command+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 - user_command]
        mcall   send, [socketnum], user_command, , 0
  .fail:
        ret
 
 
 
cmd_part:
 
        cmp     byte [esi+4], ' '
        jne     .fail
        add     esi, 5  ; skip 'PART '
 
; Is it me who parted?
        mov     edi, servercommand+1
        call    compare_to_nick
        jne     .not_me
 
; yes, close the window (if its open)
        call    window_find
        test    ebx, ebx
        jz      @f
        call    window_close
  @@:
  .fail:
 
        ret
 
 
; somebody else parted, just print message
  .not_me:
        push    esi
        call    window_open
        test    ebx, ebx
        jz      .fail2
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, part_header
        call    print_asciiz
 
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
 
        mov     esi, has_left_channel
        call    print_asciiz
 
        pop     esi
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        mov     ebx, [window_print]
        mov     esi, servercommand+1
        call    user_remove
 
        ret
 
  .fail2:
        pop     esi
 
        ret
 
 
 
cmd_join:
 
        cmp     byte[esi+4], ' '
        jne     .fail
        add     esi, 5  ; skip 'JOIN '
 
; did we join a channel?
        mov     edi, servercommand+1
        call    compare_to_nick
        jne     .not_me
 
        push    esi
        call    window_open
        test    ebx, ebx
        jz      .fail
        mov     [ebx + window.type], WINDOWTYPE_CHANNEL
        mov     [window_active], ebx
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, join_header
        call    print_asciiz
 
        mov     esi, str_talking
        call    print_asciiz
 
        pop     esi
        mov     bl, ' '
        call    print_string
 
        mov     al, 10
        call    print_char
 
        call    draw_window
 
        ret
 
  .not_me:
        push    esi
        call    window_open
        test    ebx, ebx
        jz      .fail
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, join_header
        call    print_asciiz
 
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
 
        mov     esi, joins_channel
        call    print_asciiz
 
        pop     esi
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        mov     ebx, [window_print]
        mov     esi, servercommand+1
        call    user_add
 
        ret
 
  .fail:
        pop     esi
        ret
 
 
 
 
cmd_nick:
 
        cmp     byte[esi+4], ' '
        jne     .fail
        add     esi, 5          ; skip 'NICK '
        cmp     byte[esi], ':'
        jne     @f
        inc     esi
  @@:
 
; Is it me who changed nick?
        push    esi
        mov     edi, servercommand+1
        call    compare_to_nick
        jne     .not_me
 
; Yup, update user_nick
        mov     ecx, MAX_NICK_LEN-1
        mov     esi, [esp]
        mov     edi, user_nick
  @@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, ' '
        je      @f
        cmp     al, 10
        je      @f
        cmp     al, 13
        je      @f
        cmp     al, ':'
        je      @r
        stosb
        dec     ecx
        jnz     @r
  @@:
        xor     al, al
        stosb
 
; Print a message on the server window
        mov     [window_print], windows
 
        mov     esi, str_nickchange
        call    print_asciiz
 
        mov     esi, user_nick
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
  .not_me:
 
; Update in userlist
        mov     ebx, windows
        mov     ecx, MAX_WINDOWS
  .window_loop:
        push    ecx ebx
        cmp     [ebx + window.type], WINDOWTYPE_CHANNEL
        jne     .next_window
 
        mov     esi, servercommand+1
        call    user_remove
        test    edi, edi
        jz      .next_window
 
        mov     esi, [esp + 8]
        call    user_add
 
; And print a notification in the channel
        mov     [window_print], ebx
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, nick_header
        call    print_asciiz
 
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
 
        mov     esi, is_now_known_as
        call    print_asciiz
 
        mov     esi, [esp + 8]
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
; Now do this for all open windows
  .next_window:
        pop     ebx ecx
        add     ebx, sizeof.window
        dec     ecx
        jnz     .window_loop
 
        pop     esi
 
  .fail:
 
        ret
 
 
 
 
cmd_kick:
 
        cmp     byte [esi+4], ' '
        jne     .fail
        add     esi, 5  ; skip 'KICK '
 
; TODO: Is it me who got kicked?
; if so, mark channel as disconnected
 
  .not_me:
; find the channel user has been kicked from
        push    esi
        call    window_open
        test    ebx, ebx
        jz      .fail
        push    esi
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, kick_header
        call    print_asciiz
 
        pop     esi
        mov     bl, ' '
        call    print_string
 
        mov     esi, str_kicked
        call    print_asciiz
 
        pop     esi
        mov     bl, ' '
        call    print_string
 
        mov     esi, str_by
        call    print_asciiz
 
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
 
        mov     al, 10
        call    print_char
 
        mov     ebx, [window_print]
        mov     esi, servercommand+1
        call    user_remove
 
        ret
 
  .fail:
        pop     esi
 
        ret
 
 
 
cmd_quit:
 
        cmp     byte [esi+4], ' '
        jne     .fail
 
        mov     ebx, windows
        mov     ecx, MAX_WINDOWS
 
  .window_loop:
        push    ecx
        cmp     [ebx + window.type], WINDOWTYPE_CHANNEL
        jne     .next_window
 
        mov     esi, servercommand+1
        call    user_remove
        test    edi, edi
        jz      .next_window
 
        push    ebx
        mov     [window_print], ebx
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, quit_header
        call    print_asciiz
 
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
 
        mov     esi, has_quit_irc
        call    print_asciiz
 
; TODO: check if quit message was given, and print it to the window
        pop     ebx
  .next_window:
        pop     ecx
        add     ebx, sizeof.window
        dec     ecx
        jnz     .window_loop
 
  .fail:
 
 
        ret
 
 
 
cmd_mode:
 
        cmp     byte [esi+4], ' '
        jne     .fail
        add     esi, 5  ; skip 'MODE '
        push    esi
        call    window_find
        test    ebx, ebx
        jz      .user
        mov     [esp], esi
        mov     [window_print], ebx
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, mode_header
        call    print_asciiz
 
        mov     esi, servercommand+1
        mov     bl, '!'
        call    print_string
 
        mov     esi, sets_mode
        call    print_asciiz
 
        pop     esi
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
; TODO: keep track of user modes in username list
 
  .fail:
        ret
 
 
  .user:
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, mode_header
        call    print_asciiz
 
        mov     esi, [esp]
        mov     bl, ' '
        call    print_string
 
        mov     esi, sets_mode
        call    print_asciiz
 
        pop     esi
        call    skip_parameter
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        ret
 
 
cmd_353:                ; channel usernames reply
 
        add     esi, 4  ; skip '353 '
        call    skip_parameter
        inc     esi     ; channel type '*', '=' or '@'
        inc     esi     ; ' '
        call    window_open
        test    ebx, ebx
        jz      .fail
 
; now find window ptr and check if this is the first 353 message
        mov     ebx, [window_print]
        test    [ebx + window.flags], FLAG_RECEIVING_NAMES
        jnz     .add
 
        or      [ebx + window.flags], FLAG_RECEIVING_NAMES
;        mov     [ebx + window.users], 0
        ; TODO: remove all users?
 
  .add:
        push    esi
        call    user_add
        pop     esi
 
  .namesloop:
        lodsb
        test    al, al
        jz      .done
        cmp     al, ' '                 ; names list is separated with spaces
        jne     .namesloop
        jmp     .add
 
  .done:
        call    draw_user_list
  .fail:
 
        ret
 
 
 
 
 
cmd_366:        ; channel usernames end
 
        add     esi, 4          ; skip '366 '
        call    skip_parameter
        call    window_open
        test    ebx, ebx
        jz      .fail
        and     [ebx + window.flags], not FLAG_RECEIVING_NAMES
  .fail:
 
        ret
 
 
 
 
cmd_topic:
 
        add     esi, 4          ; skip '332 '
        call    skip_parameter
        call    window_open
        test    ebx, ebx
        jz      .fail
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        push    esi
        mov     esi, topic_header
        call    print_asciiz
 
        mov     esi, str_topic
        call    print_asciiz
 
        pop     esi
        call    print_asciiz
 
        mov     esi, str_topic_end
        call    print_asciiz
 
  .fail:
 
        ret
 
 
cmd_333:
 
        add     esi, 4          ; skip '333 '
        call    skip_parameter
        call    window_open
        test    ebx, ebx
        jz      .fail
 
        if TIMESTAMP
        call    print_timestamp
        end if
 
        push    esi
        mov     esi, topic_header
        call    print_asciiz
 
        mov     esi, str_setby
        call    print_asciiz
 
        pop     esi
        mov     bl, '!'
        call    print_string
 
        mov     al, 10
        call    print_char
 
  .fail:
 
        ret
 
 
 
cmd_322:        ; LIST
 
        add     esi, 4
        call    skip_parameter
 
        push    esi
        mov     esi, str_list
        call    window_open
        test    ebx, ebx
        jz      .fail
 
        mov     [window_active], ebx
        call    draw_window_tabs
        pop     esi
        call    print_asciiz
        mov     al, 10
        call    print_char
 
        ret
 
  .fail:
        pop     esi
 
        ret
 
cmd_323:        ; LIST END
 
        ret
>

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

Subversion Repositories Kolibri OS

(root)/programs/network/ircc/serverparser.inc @ 7300 – Rev 6026 → 6027