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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2024. 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                                   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
user_parser:
 
        mov     ebp, [window_active]                    ; print to the current window
        mov     [window_print], ebp
 
        mov     ecx, [edit1.size]
        test    ecx, ecx
        jz      .ret                                    ; ignore empty commands
 
        mov     esi, input_text
        mov     edi, user_command
        call    recode                                  ; Convert to UTF-8
        mov     byte[edi], 0x0                          ; Terminate string with \0
        sub     edi, user_command
        mov     [user_command.size], edi
 
        cmp     byte[user_command], '/'                 ; is it a server command ?
        je      .command
 
        cmp     [status], STATUS_LOGGED_IN
        jne     .not_loggedin
 
        cmp     [ebp + window.type], WINDOWTYPE_CHANNEL
        je      .send_privmsg
        cmp     [ebp + window.type], WINDOWTYPE_CHAT
        jne     .not_channel
 
  .send_privmsg:
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     al, '<'
        call    print_char
 
        mov     esi, user_nick
        call    print_asciiz
 
        mov     al, '>'
        call    print_char
        mov     al, ' '
        call    print_char
 
        mov     eax, [user_command.size]
        mov     byte[user_command + eax],0
        mov     esi, user_command
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
; and now send it to the server
        mov     dword[packetbuf], 'PRIV'
        mov     dword[packetbuf+4], 'MSG '
 
        lea     esi, [ebp + window.name]
        mov     edi, packetbuf+8
        mov     ecx, MAX_WINDOWNAME_LEN
  .loop:
        lodsb
        test    al, al
        jz      .done
        stosb
        dec     ecx
        jnz     .loop
  .done:
 
        mov     ax, ' :'
        stosw
 
        mov     esi, user_command
        mov     ecx, [user_command.size]
;        inc     ecx
        rep     movsb
 
; end the command with a CRLF
        mov     ax, 0x0a0d
        stosw
 
        lea     esi, [edi - packetbuf]
        mcall   send, [socketnum], packetbuf, , 0
 
  .ret:
        ret
 
; Text begins with a '/' lets try to find the command in the lookup table.
  .command:
        mov     eax, dword[user_command+1]      ; skip '/'
        or      eax, 0x20202020                 ; convert to lowercase
 
        mov     edi, user_commands
        mov     ecx, user_commands.number
        cmp     [status], STATUS_CONNECTED
        jae     .cmd_loop
        mov     ecx, user_commands.number2
  .cmd_loop:
        scasd
        je      .got_cmd
        add     edi, 4
        dec     ecx
        jnz     .cmd_loop
 
        cmp     [status], STATUS_CONNECTED
        jb      .not_connected
 
; Commands shorter then 3 chars are placed here
        and     eax, 0x00ffffff
        cmp     eax, 'me '
        je      cmd_usr_me
 
; If none of the listed commands, send text straight to server
        jmp     cmd_usr_send
 
  .got_cmd:
        jmp     dword[edi]
 
  .not_loggedin:
        mov     esi, str_notloggedin
        call    print_asciiz
        ret
 
  .not_connected:
        mov     esi, str_notconnected
        call    print_asciiz
        ret
 
  .not_channel:
        mov     esi, str_notchannel
        call    print_asciiz
        ret
 
 
; user commands lookup table
user_commands:
        dd      'nick', cmd_usr_nick
        dd      'real', cmd_usr_real
        dd      'serv', cmd_usr_server
        dd      'help', cmd_usr_help
        dd      'code', cmd_usr_code
 
        .number2 = ($ - user_commands) / 8
 
; All following commands require a connection to the server.
        dd      'quer', cmd_usr_quer
        dd      'quit', cmd_usr_quit
        dd      'part', cmd_usr_part
        dd      'ctcp', cmd_usr_ctcp
        dd      'msg ', cmd_usr_msg
 
        .number = ($ - user_commands) / 8
 
 
 
cmd_usr_msg:
 
        lea     esi, [user_command+5]
 
        mov     dword[packetbuf], 'PRIV'
        mov     dword[packetbuf+4], 'MSG '
        lea     edi, [packetbuf+8]
 
  @@:
        lodsb
        test    al, al
        jz      .fail
        cmp     al, 10
        je      .fail
        cmp     al, 13
        je      .fail
        stosb
        cmp     al, ' '
        jne     @r
 
        mov     al, ':'
        stosb
 
        push    edi
  @@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, 10
        je      @f
        cmp     al, 13
        je      @f
        stosb
        jmp     @r
  @@:
; end the command with a CRLF
        mov     ax, 0x0a0d
        stosw
        mov     byte[edi], 0
 
; now print to the window
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, msg_header
        call    print_asciiz
 
        mov     esi, packetbuf+8
        mov     bl, ' '
        call    print_string
 
        mov     al, '*'
        call    print_char
 
        mov     al, ' '
        call    print_char
 
        pop     esi
        push    esi
        call    print_asciiz
        pop     esi
 
 
        lea     esi, [edi - packetbuf]
        mcall   send, [socketnum], packetbuf, , 0
 
  .fail:
        ret
 
 
 
cmd_usr_quit:
 
        mov     esi, quit_msg
        cmp     byte[user_command+5], ' '
        jne     quit_server
        lea     esi, [user_command+6]
 
; esi = quit message
quit_server:
 
; User wants to close a channel, send PART command to server
        mov     dword[packetbuf], 'QUIT'
        mov     word[packetbuf+4], ' :'
        lea     edi, [packetbuf+6]
; Append our quit msg
  @@:
        lodsb
        cmp     al, 13
        je      @f
        test    al, al
        jz      @f
        stosb
        jmp     @r
  @@:
; end the command with a CRLF
        mov     ax, 0x0a0d
        stosw
 
        lea     esi, [edi - packetbuf]                  ; calculate length
        mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
 
        mov     ebp, windows
  .window_loop:
        cmp     [ebp + window.type], WINDOWTYPE_NONE
        je      .next_window
        mov     [window_print], ebp
        if TIMESTAMP
        call    print_timestamp
        end if
        mov     esi, str_disconnected
        call    print_asciiz
        cmp     [ebp + window.type], WINDOWTYPE_CHANNEL
        jne     .next_window
        call    user_remove_all
  .next_window:
        add     ebp, sizeof.window
        cmp     ebp, windows + (MAX_WINDOWS * sizeof.window)
        jb      .window_loop
 
        mov     [status], STATUS_DISCONNECTED
        mcall   close, [socketnum]
 
        ret
 
 
 
 
cmd_usr_nick:
 
        cmp     [user_command.size], 5
        je      .justprint
        cmp     byte[user_command+5], ' '
        jne     .fail
        cmp     [socketnum], 0
        je      .dontsend
 
; Request nickname change to server
        mov     dword[user_command+1], 'NICK'
        mov     esi, [user_command.size]
        mov     word[user_command + esi], 0x0a0d
        inc     esi
        mcall   send, [socketnum], user_command+1, , 0
 
  .fail:
        ret
 
; We arent logged in yet, directly change user_nick field and print notification to user.
  .dontsend:
        mov     ecx, MAX_NICK_LEN
        mov     esi, user_command+6
        mov     edi, user_nick
  @@:
        lodsb
        cmp     al, 13
        je      @f
        stosb
        dec     ecx
        jnz     @r
  @@:
        xor     al, al
        stosb
 
  .justprint:
        mov     esi, str_nickchange
        call    print_asciiz
 
        mov     esi, user_nick
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        ret
 
 
 
cmd_usr_real:
 
        cmp     byte[user_command+5], ' '
        jne     cmd_usr_send
 
        mov     ecx, MAX_REAL_LEN
        mov     esi, user_command+6
        mov     edi, user_real_name
  .loop:
        lodsb
        cmp     al, 13
        je      .done
        stosb
        dec     ecx
        jnz     .loop
  .done:
        xor     al, al
        stosb
 
        mov     esi, str_realchange
        call    print_asciiz
 
        mov     esi, user_real_name
        call    print_asciiz
 
        mov     al, 10
        call    print_char
 
        ret
 
 
 
cmd_usr_server:
 
        mov     eax, dword[user_command+5]      ; check for 'er ', we only checked 'serv'
        or      eax, 0x00002020
        and     eax, 0x00ffffff
        cmp     eax, 'er '
        jne     cmd_usr_send
 
; Server window is always first window in the list, switch to it.
        mov     [window_print], windows
        mov     [window_active], windows
 
        mov     ecx, [user_command.size]        ; ok now set the address
        sub     ecx, 8
 
        mov     esi, user_command+8
  .now:
        push    esi
        mov     edi, irc_server_name
  .loop:                                        ; copy until zero byte, or ecx reaches zero.
        lodsb
        stosb
        test    al, al
        jz      .done
        dec     ecx
        jnz     .loop
        xor     al, al
        stosb
  .done:
        pop     esi
 
; set it also in window name
        mov     ebx, [window_print]
        call    window_set_name
 
; now connect
        call    socket_connect
 
        ret
 
 
cmd_usr_quer:
 
        mov     esi, user_command+7
        call    window_open
;        test    ebx, ebx
;        jz      .fail
 
        ret
 
 
 
cmd_usr_help:
 
        mov     esi, str_help
        call    print_asciiz
 
        ret
 
 
 
cmd_usr_code:
 
        ; TODO
 
        ret
 
 
 
; User typed a part command
cmd_usr_part:
 
        cmp     byte[user_command+5], 13        ; parameters given?
        jne     cmd_usr_send                    ; yes, send command straight to server
 
; close active window
cmd_usr_close_window:
 
        mov     esi, [window_active]
        mov     [window_print], esi
        cmp     [esi + window.type], WINDOWTYPE_SERVER
        je      .not_channel
 
        lea     esi, [esi + window.name]
        call    cmd_usr_part_channel
        call    window_close
        ret
 
  .not_channel:
        cmp     [esi + window.type], WINDOWTYPE_CHAT
        jne     .not_chat
 
        call    window_close
  .not_chat:
 
        ret
 
 
 
; Send part command to server
; esi must point to channel name (ASCIIZ)
cmd_usr_part_channel:
 
; User wants to close a channel, send PART command to server
        mov     dword[packetbuf], 'PART'
        mov     byte[packetbuf+4], ' '
        lea     edi, [packetbuf+5]
  @@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, 13
        je      @f
        cmp     al, 10
        je      @f
        stosb
        jmp     @r
  @@:
; end the command with a CRLF
        mov     ax, 0x0a0d
        stosw
 
        lea     esi, [edi - packetbuf]                  ; calculate length
        mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
 
        ret
 
 
 
cmd_usr_ctcp:
 
        cmp     byte[user_command+5], ' '
        jne     cmd_usr_send
 
        mov     esi, user_command+6
; prepare a 'PRIVMSG '
        mov     dword[packetbuf], 'PRIV'
        mov     dword[packetbuf+4], 'MSG '
        lea     edi, [packetbuf+8]
 
; append the destination (nickname/channel)
  @@:
        lodsb
        test    al, al
        jz      .fail
        cmp     al, ' '
        je      @f
        stosb
        jmp     @r
  @@:
 
        mov     ax, ' :'
        stosw
        mov     al, 0x01
        stosb
 
        push edi esi
 
; copy the message itself
  @@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, 13
        je      @f
        cmp     al, 10
        je      @f
        stosb
        jmp     @r
  @@:
 
; end of message
        mov     al, 0x01
        stosb
        mov     ax, 0x0a0d
        stosw
        mov     byte[edi], 0
 
; now print to the window
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, ctcp_header
        call    print_asciiz
 
        mov     esi, packetbuf+8
        mov     bl, ' '
        call    print_string
 
        mov     al, ']'
        call    print_char
 
        mov     al, ' '
        call    print_char
 
        pop     esi
        call    print_asciiz
        pop     esi
 
 
; now send it away
        lea     esi, [edi - packetbuf]                  ; calculate length
        mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
 
  .fail:
 
        ret
 
 
 
cmd_usr_me:
 
; prepare a 'PRIVMSG '
        mov     dword[packetbuf], 'PRIV'
        mov     dword[packetbuf+4], 'MSG '
        lea     edi, [packetbuf+8]
 
; append the destination (nickname/channel)
        mov     esi, [window_active]
        lea     esi, [esi + window.name]
  @@:
        lodsb
        test    al, al
        je      @f
        stosb
        jmp     @r
  @@:
 
; Make the CTCP action header
        mov     eax, ' :' + 0x01 shl 16 + 'A' shl 24
        stosd
        mov     eax, 'CTIO'
        stosd
        mov     al, 'N'
        stosb
 
; copy the message itself (including first space)
        mov     esi, user_command+3
  @@:
        lodsb
        cmp     al, 13
        je      @f
        stosb
        jmp     @r
  @@:
 
; end of CTCP message
        mov     al, 0x01
        stosb
        mov     ax, 0x0a0d
        stosw
 
; now send it to the server
        lea     esi, [edi - packetbuf]                  ; calculate length
        mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
 
; print to local window
        if TIMESTAMP
        call    print_timestamp
        end if
 
        mov     esi, action_header
        call    print_asciiz
 
        mov     esi, user_nick
        call    print_asciiz
 
        mov     esi, user_command+3
        mov     bl, 13
        call    print_string
 
        mov     al, 10
        call    print_char
 
        ret
 
 
 
; The user typed some undefined command, just send it to the server
cmd_usr_send:
 
        mov     esi, [user_command.size]
        mov     eax, [user_command.size]
        add     eax, user_command
        mov     word[eax], 0x0a0d
        inc     esi                     ; Skip / add \r\n
        mcall   send, [socketnum], user_command+1, , 0
 
        ret
>

Rev 9979	Rev 9981
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2024. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2024. 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	user_parser:	14	user_parser:
15		15
16	mov ebp, [window_active] ; print to the current window	16	mov ebp, [window_active] ; print to the current window
17	mov [window_print], ebp	17	mov [window_print], ebp
18		18
19	mov ecx, [edit1.size]	19	mov ecx, [edit1.size]
20	test ecx, ecx	20	test ecx, ecx
21	jz .ret ; ignore empty commands	21	jz .ret ; ignore empty commands
22		22
23	mov esi, input_text	23	mov esi, input_text
24	mov edi, user_command	24	mov edi, user_command
25	call recode ; Convert to UTF-8	25	call recode ; Convert to UTF-8
26	mov word[edi], 0x0a0d ; terminate the line	26	mov byte[edi], 0x0 ; Terminate string with \0
27	sub edi, user_command	27	sub edi, user_command
28	mov [user_command.size], edi	28	mov [user_command.size], edi
29		29
30	cmp byte[user_command], '/' ; is it a server command ?	30	cmp byte[user_command], '/' ; is it a server command ?
31	je .command	31	je .command
32		32
33	cmp [status], STATUS_LOGGED_IN	33	cmp [status], STATUS_LOGGED_IN
34	jne .not_loggedin	34	jne .not_loggedin
35		35
36	cmp [ebp + window.type], WINDOWTYPE_CHANNEL	36	cmp [ebp + window.type], WINDOWTYPE_CHANNEL
37	je .send_privmsg	37	je .send_privmsg
38	cmp [ebp + window.type], WINDOWTYPE_CHAT	38	cmp [ebp + window.type], WINDOWTYPE_CHAT
39	jne .not_channel	39	jne .not_channel
40		40
41	.send_privmsg:	41	.send_privmsg:
42	if TIMESTAMP	42	if TIMESTAMP
43	call print_timestamp	43	call print_timestamp
44	end if	44	end if
45		45
46	mov al, '<'	46	mov al, '<'
47	call print_char	47	call print_char
48		48
49	mov esi, user_nick	49	mov esi, user_nick
50	call print_asciiz	50	call print_asciiz
51		51
52	mov al, '>'	52	mov al, '>'
53	call print_char	53	call print_char
54	mov al, ' '	54	mov al, ' '
55	call print_char	55	call print_char
56		56
57	mov eax, [user_command.size]	57	mov eax, [user_command.size]
58	mov byte[user_command + eax],0	58	mov byte[user_command + eax],0
59	mov esi, user_command	59	mov esi, user_command
60	call print_asciiz	60	call print_asciiz
61		61
62	mov al, 10	62	mov al, 10
63	call print_char	63	call print_char
64		64
65	; and now send it to the server	65	; and now send it to the server
66	mov dword[packetbuf], 'PRIV'	66	mov dword[packetbuf], 'PRIV'
67	mov dword[packetbuf+4], 'MSG '	67	mov dword[packetbuf+4], 'MSG '
68		68
69	lea esi, [ebp + window.name]	69	lea esi, [ebp + window.name]
70	mov edi, packetbuf+8	70	mov edi, packetbuf+8
71	mov ecx, MAX_WINDOWNAME_LEN	71	mov ecx, MAX_WINDOWNAME_LEN
72	.loop:	72	.loop:
73	lodsb	73	lodsb
74	test al, al	74	test al, al
75	jz .done	75	jz .done
76	stosb	76	stosb
77	dec ecx	77	dec ecx
78	jnz .loop	78	jnz .loop
79	.done:	79	.done:
80		80
81	mov ax, ' :'	81	mov ax, ' :'
82	stosw	82	stosw
83		83
84	mov esi, user_command	84	mov esi, user_command
85	mov ecx, [user_command.size]	85	mov ecx, [user_command.size]
86	; inc ecx	86	; inc ecx
87	rep movsb	87	rep movsb
88		88
89	; end the command with a CRLF	89	; end the command with a CRLF
90	mov ax, 0x0a0d	90	mov ax, 0x0a0d
91	stosw	91	stosw
92		92
93	lea esi, [edi - packetbuf]	93	lea esi, [edi - packetbuf]
94	mcall send, [socketnum], packetbuf, , 0	94	mcall send, [socketnum], packetbuf, , 0
95		95
96	.ret:	96	.ret:
97	ret	97	ret
98		98
99	; Text begins with a '/' lets try to find the command in the lookup table.	99	; Text begins with a '/' lets try to find the command in the lookup table.
100	.command:	100	.command:
101	mov eax, dword[user_command+1] ; skip '/'	101	mov eax, dword[user_command+1] ; skip '/'
102	or eax, 0x20202020 ; convert to lowercase	102	or eax, 0x20202020 ; convert to lowercase
103		103
104	mov edi, user_commands	104	mov edi, user_commands
105	mov ecx, user_commands.number	105	mov ecx, user_commands.number
106	cmp [status], STATUS_CONNECTED	106	cmp [status], STATUS_CONNECTED
107	jae .cmd_loop	107	jae .cmd_loop
108	mov ecx, user_commands.number2	108	mov ecx, user_commands.number2
109	.cmd_loop:	109	.cmd_loop:
110	scasd	110	scasd
111	je .got_cmd	111	je .got_cmd
112	add edi, 4	112	add edi, 4
113	dec ecx	113	dec ecx
114	jnz .cmd_loop	114	jnz .cmd_loop
115		115
116	cmp [status], STATUS_CONNECTED	116	cmp [status], STATUS_CONNECTED
117	jb .not_connected	117	jb .not_connected
118		118
119	; Commands shorter then 3 chars are placed here	119	; Commands shorter then 3 chars are placed here
120	and eax, 0x00ffffff	120	and eax, 0x00ffffff
121	cmp eax, 'me '	121	cmp eax, 'me '
122	je cmd_usr_me	122	je cmd_usr_me
123		123
124	; If none of the listed commands, send text straight to server	124	; If none of the listed commands, send text straight to server
125	jmp cmd_usr_send	125	jmp cmd_usr_send
126		126
127	.got_cmd:	127	.got_cmd:
128	jmp dword[edi]	128	jmp dword[edi]
129		129
130	.not_loggedin:	130	.not_loggedin:
131	mov esi, str_notloggedin	131	mov esi, str_notloggedin
132	call print_asciiz	132	call print_asciiz
133	ret	133	ret
134		134
135	.not_connected:	135	.not_connected:
136	mov esi, str_notconnected	136	mov esi, str_notconnected
137	call print_asciiz	137	call print_asciiz
138	ret	138	ret
139		139
140	.not_channel:	140	.not_channel:
141	mov esi, str_notchannel	141	mov esi, str_notchannel
142	call print_asciiz	142	call print_asciiz
143	ret	143	ret
144		144
145		145
146	; user commands lookup table	146	; user commands lookup table
147	user_commands:	147	user_commands:
148	dd 'nick', cmd_usr_nick	148	dd 'nick', cmd_usr_nick
149	dd 'real', cmd_usr_real	149	dd 'real', cmd_usr_real
150	dd 'serv', cmd_usr_server	150	dd 'serv', cmd_usr_server
151	dd 'help', cmd_usr_help	151	dd 'help', cmd_usr_help
152	dd 'code', cmd_usr_code	152	dd 'code', cmd_usr_code
153		153
154	.number2 = ($ - user_commands) / 8	154	.number2 = ($ - user_commands) / 8
155		155
156	; All following commands require a connection to the server.	156	; All following commands require a connection to the server.
157	dd 'quer', cmd_usr_quer	157	dd 'quer', cmd_usr_quer
158	dd 'quit', cmd_usr_quit	158	dd 'quit', cmd_usr_quit
159	dd 'part', cmd_usr_part	159	dd 'part', cmd_usr_part
160	dd 'ctcp', cmd_usr_ctcp	160	dd 'ctcp', cmd_usr_ctcp
161	dd 'msg ', cmd_usr_msg	161	dd 'msg ', cmd_usr_msg
162		162
163	.number = ($ - user_commands) / 8	163	.number = ($ - user_commands) / 8
164		164
165		165
166		166
167	cmd_usr_msg:	167	cmd_usr_msg:
168		168
169	lea esi, [user_command+5]	169	lea esi, [user_command+5]
170		170
171	mov dword[packetbuf], 'PRIV'	171	mov dword[packetbuf], 'PRIV'
172	mov dword[packetbuf+4], 'MSG '	172	mov dword[packetbuf+4], 'MSG '
173	lea edi, [packetbuf+8]	173	lea edi, [packetbuf+8]
174		174
175	@@:	175	@@:
176	lodsb	176	lodsb
177	test al, al	177	test al, al
178	jz .fail	178	jz .fail
179	cmp al, 10	179	cmp al, 10
180	je .fail	180	je .fail
181	cmp al, 13	181	cmp al, 13
182	je .fail	182	je .fail
183	stosb	183	stosb
184	cmp al, ' '	184	cmp al, ' '
185	jne @r	185	jne @r
186		186
187	mov al, ':'	187	mov al, ':'
188	stosb	188	stosb
189		189
190	push edi	190	push edi
191	@@:	191	@@:
192	lodsb	192	lodsb
193	test al, al	193	test al, al
194	jz @f	194	jz @f
195	cmp al, 10	195	cmp al, 10
196	je @f	196	je @f
197	cmp al, 13	197	cmp al, 13
198	je @f	198	je @f
199	stosb	199	stosb
200	jmp @r	200	jmp @r
201	@@:	201	@@:
202	; end the command with a CRLF	202	; end the command with a CRLF
203	mov ax, 0x0a0d	203	mov ax, 0x0a0d
204	stosw	204	stosw
205	mov byte[edi], 0	205	mov byte[edi], 0
206		206
207	; now print to the window	207	; now print to the window
208	if TIMESTAMP	208	if TIMESTAMP
209	call print_timestamp	209	call print_timestamp
210	end if	210	end if
211		211
212	mov esi, msg_header	212	mov esi, msg_header
213	call print_asciiz	213	call print_asciiz
214		214
215	mov esi, packetbuf+8	215	mov esi, packetbuf+8
216	mov bl, ' '	216	mov bl, ' '
217	call print_string	217	call print_string
218		218
219	mov al, '*'	219	mov al, '*'
220	call print_char	220	call print_char
221		221
222	mov al, ' '	222	mov al, ' '
223	call print_char	223	call print_char
224		224
225	pop esi	225	pop esi
226	push esi	226	push esi
227	call print_asciiz	227	call print_asciiz
228	pop esi	228	pop esi
229		229
230		230
231	lea esi, [edi - packetbuf]	231	lea esi, [edi - packetbuf]
232	mcall send, [socketnum], packetbuf, , 0	232	mcall send, [socketnum], packetbuf, , 0
233		233
234	.fail:	234	.fail:
235	ret	235	ret
236		236
237		237
238		238
239	cmd_usr_quit:	239	cmd_usr_quit:
240		240
241	mov esi, quit_msg	241	mov esi, quit_msg
242	cmp byte[user_command+5], ' '	242	cmp byte[user_command+5], ' '
243	jne quit_server	243	jne quit_server
244	lea esi, [user_command+6]	244	lea esi, [user_command+6]
245		245
246	; esi = quit message	246	; esi = quit message
247	quit_server:	247	quit_server:
248		248
249	; User wants to close a channel, send PART command to server	249	; User wants to close a channel, send PART command to server
250	mov dword[packetbuf], 'QUIT'	250	mov dword[packetbuf], 'QUIT'
251	mov word[packetbuf+4], ' :'	251	mov word[packetbuf+4], ' :'
252	lea edi, [packetbuf+6]	252	lea edi, [packetbuf+6]
253	; Append our quit msg	253	; Append our quit msg
254	@@:	254	@@:
255	lodsb	255	lodsb
256	cmp al, 13	256	cmp al, 13
257	je @f	257	je @f
258	test al, al	258	test al, al
259	jz @f	259	jz @f
260	stosb	260	stosb
261	jmp @r	261	jmp @r
262	@@:	262	@@:
263	; end the command with a CRLF	263	; end the command with a CRLF
264	mov ax, 0x0a0d	264	mov ax, 0x0a0d
265	stosw	265	stosw
266		266
267	lea esi, [edi - packetbuf] ; calculate length	267	lea esi, [edi - packetbuf] ; calculate length
268	mcall send, [socketnum], packetbuf, , 0 ; and finally send to server	268	mcall send, [socketnum], packetbuf, , 0 ; and finally send to server
269		269
270	mov ebp, windows	270	mov ebp, windows
271	.window_loop:	271	.window_loop:
272	cmp [ebp + window.type], WINDOWTYPE_NONE	272	cmp [ebp + window.type], WINDOWTYPE_NONE
273	je .next_window	273	je .next_window
274	mov [window_print], ebp	274	mov [window_print], ebp
275	if TIMESTAMP	275	if TIMESTAMP
276	call print_timestamp	276	call print_timestamp
277	end if	277	end if
278	mov esi, str_disconnected	278	mov esi, str_disconnected
279	call print_asciiz	279	call print_asciiz
280	cmp [ebp + window.type], WINDOWTYPE_CHANNEL	280	cmp [ebp + window.type], WINDOWTYPE_CHANNEL
281	jne .next_window	281	jne .next_window
282	call user_remove_all	282	call user_remove_all
283	.next_window:	283	.next_window:
284	add ebp, sizeof.window	284	add ebp, sizeof.window
285	cmp ebp, windows + (MAX_WINDOWS * sizeof.window)	285	cmp ebp, windows + (MAX_WINDOWS * sizeof.window)
286	jb .window_loop	286	jb .window_loop
287		287
288	mov [status], STATUS_DISCONNECTED	288	mov [status], STATUS_DISCONNECTED
289	mcall close, [socketnum]	289	mcall close, [socketnum]
290		290
291	ret	291	ret
292		292
293		293
294		294
295		295
296	cmd_usr_nick:	296	cmd_usr_nick:
297		297
298	cmp [user_command.size], 5	298	cmp [user_command.size], 5
299	je .justprint	299	je .justprint
300	cmp byte[user_command+5], ' '	300	cmp byte[user_command+5], ' '
301	jne .fail	301	jne .fail
302	cmp [socketnum], 0	302	cmp [socketnum], 0
303	je .dontsend	303	je .dontsend
304		304
305	; Request nickname change to server	305	; Request nickname change to server
306	mov dword[user_command+1], 'NICK'	306	mov dword[user_command+1], 'NICK'
307	mov esi, [user_command.size]	307	mov esi, [user_command.size]
308	mov word[user_command + esi], 0x0a0d	308	mov word[user_command + esi], 0x0a0d
309	inc esi	309	inc esi
310	mcall send, [socketnum], user_command+1, , 0	310	mcall send, [socketnum], user_command+1, , 0
311		311
312	.fail:	312	.fail:
313	ret	313	ret
314		314
315	; We arent logged in yet, directly change user_nick field and print notification to user.	315	; We arent logged in yet, directly change user_nick field and print notification to user.
316	.dontsend:	316	.dontsend:
317	mov ecx, MAX_NICK_LEN	317	mov ecx, MAX_NICK_LEN
318	mov esi, user_command+6	318	mov esi, user_command+6
319	mov edi, user_nick	319	mov edi, user_nick
320	@@:	320	@@:
321	lodsb	321	lodsb
322	cmp al, 13	322	cmp al, 13
323	je @f	323	je @f
324	stosb	324	stosb
325	dec ecx	325	dec ecx
326	jnz @r	326	jnz @r
327	@@:	327	@@:
328	xor al, al	328	xor al, al
329	stosb	329	stosb
330		330
331	.justprint:	331	.justprint:
332	mov esi, str_nickchange	332	mov esi, str_nickchange
333	call print_asciiz	333	call print_asciiz
334		334
335	mov esi, user_nick	335	mov esi, user_nick
336	call print_asciiz	336	call print_asciiz
337		337
338	mov al, 10	338	mov al, 10
339	call print_char	339	call print_char
340		340
341	ret	341	ret
342		342
343		343
344		344
345	cmd_usr_real:	345	cmd_usr_real:
346		346
347	cmp byte[user_command+5], ' '	347	cmp byte[user_command+5], ' '
348	jne cmd_usr_send	348	jne cmd_usr_send
349		349
350	mov ecx, MAX_REAL_LEN	350	mov ecx, MAX_REAL_LEN
351	mov esi, user_command+6	351	mov esi, user_command+6
352	mov edi, user_real_name	352	mov edi, user_real_name
353	.loop:	353	.loop:
354	lodsb	354	lodsb
355	cmp al, 13	355	cmp al, 13
356	je .done	356	je .done
357	stosb	357	stosb
358	dec ecx	358	dec ecx
359	jnz .loop	359	jnz .loop
360	.done:	360	.done:
361	xor al, al	361	xor al, al
362	stosb	362	stosb
363		363
364	mov esi, str_realchange	364	mov esi, str_realchange
365	call print_asciiz	365	call print_asciiz
366		366
367	mov esi, user_real_name	367	mov esi, user_real_name
368	call print_asciiz	368	call print_asciiz
369		369
370	mov al, 10	370	mov al, 10
371	call print_char	371	call print_char
372		372
373	ret	373	ret
374		374
375		375
376		376
377	cmd_usr_server:	377	cmd_usr_server:
378		378
379	mov eax, dword[user_command+5] ; check for 'er ', we only checked 'serv'	379	mov eax, dword[user_command+5] ; check for 'er ', we only checked 'serv'
380	or eax, 0x00002020	380	or eax, 0x00002020
381	and eax, 0x00ffffff	381	and eax, 0x00ffffff
382	cmp eax, 'er '	382	cmp eax, 'er '
383	jne cmd_usr_send	383	jne cmd_usr_send
384		384
385	; Server window is always first window in the list, switch to it.	385	; Server window is always first window in the list, switch to it.
386	mov [window_print], windows	386	mov [window_print], windows
387	mov [window_active], windows	387	mov [window_active], windows
388		388
389	mov ecx, [user_command.size] ; ok now set the address	389	mov ecx, [user_command.size] ; ok now set the address
390	sub ecx, 8	390	sub ecx, 8
391		391
392	mov esi, user_command+8	392	mov esi, user_command+8
393	.now:	393	.now:
394	push esi	394	push esi
395	mov edi, irc_server_name	395	mov edi, irc_server_name
396	.loop: ; copy until zero byte, or ecx reaches zero.	396	.loop: ; copy until zero byte, or ecx reaches zero.
397	lodsb	397	lodsb
398	stosb	398	stosb
399	test al, al	399	test al, al
400	jz .done	400	jz .done
401	dec ecx	401	dec ecx
402	jnz .loop	402	jnz .loop
403	xor al, al	403	xor al, al
404	stosb	404	stosb
405	.done:	405	.done:
406	pop esi	406	pop esi
407		407
408	; set it also in window name	408	; set it also in window name
409	mov ebx, [window_print]	409	mov ebx, [window_print]
410	call window_set_name	410	call window_set_name
411		411
412	; now connect	412	; now connect
413	call socket_connect	413	call socket_connect
414		414
415	ret	415	ret
416		416
417		417
418	cmd_usr_quer:	418	cmd_usr_quer:
419		419
420	mov esi, user_command+7	420	mov esi, user_command+7
421	call window_open	421	call window_open
422	; test ebx, ebx	422	; test ebx, ebx
423	; jz .fail	423	; jz .fail
424		424
425	ret	425	ret
426		426
427		427
428		428
429	cmd_usr_help:	429	cmd_usr_help:
430		430
431	mov esi, str_help	431	mov esi, str_help
432	call print_asciiz	432	call print_asciiz
433		433
434	ret	434	ret
435		435
436		436
437		437
438	cmd_usr_code:	438	cmd_usr_code:
439		439
440	; TODO	440	; TODO
441		441
442	ret	442	ret
443		443
444		444
445		445
446	; User typed a part command	446	; User typed a part command
447	cmd_usr_part:	447	cmd_usr_part:
448		448
449	cmp byte[user_command+5], 13 ; parameters given?	449	cmp byte[user_command+5], 13 ; parameters given?
450	jne cmd_usr_send ; yes, send command straight to server	450	jne cmd_usr_send ; yes, send command straight to server
451		451
452	; close active window	452	; close active window
453	cmd_usr_close_window:	453	cmd_usr_close_window:
454		454
455	mov esi, [window_active]	455	mov esi, [window_active]
456	mov [window_print], esi	456	mov [window_print], esi
457	cmp [esi + window.type], WINDOWTYPE_SERVER	457	cmp [esi + window.type], WINDOWTYPE_SERVER
458	je .not_channel	458	je .not_channel
459		459
460	lea esi, [esi + window.name]	460	lea esi, [esi + window.name]
461	call cmd_usr_part_channel	461	call cmd_usr_part_channel
462	call window_close	462	call window_close
463	ret	463	ret
464		464
465	.not_channel:	465	.not_channel:
466	cmp [esi + window.type], WINDOWTYPE_CHAT	466	cmp [esi + window.type], WINDOWTYPE_CHAT
467	jne .not_chat	467	jne .not_chat
468		468
469	call window_close	469	call window_close
470	.not_chat:	470	.not_chat:
471		471
472	ret	472	ret
473		473
474		474
475		475
476	; Send part command to server	476	; Send part command to server
477	; esi must point to channel name (ASCIIZ)	477	; esi must point to channel name (ASCIIZ)
478	cmd_usr_part_channel:	478	cmd_usr_part_channel:
479		479
480	; User wants to close a channel, send PART command to server	480	; User wants to close a channel, send PART command to server
481	mov dword[packetbuf], 'PART'	481	mov dword[packetbuf], 'PART'
482	mov byte[packetbuf+4], ' '	482	mov byte[packetbuf+4], ' '
483	lea edi, [packetbuf+5]	483	lea edi, [packetbuf+5]
484	@@:	484	@@:
485	lodsb	485	lodsb
486	test al, al	486	test al, al
487	jz @f	487	jz @f
488	cmp al, 13	488	cmp al, 13
489	je @f	489	je @f
490	cmp al, 10	490	cmp al, 10
491	je @f	491	je @f
492	stosb	492	stosb
493	jmp @r	493	jmp @r
494	@@:	494	@@:
495	; end the command with a CRLF	495	; end the command with a CRLF
496	mov ax, 0x0a0d	496	mov ax, 0x0a0d
497	stosw	497	stosw
498		498
499	lea esi, [edi - packetbuf] ; calculate length	499	lea esi, [edi - packetbuf] ; calculate length
500	mcall send, [socketnum], packetbuf, , 0 ; and finally send to server	500	mcall send, [socketnum], packetbuf, , 0 ; and finally send to server

Subversion Repositories Kolibri OS

(root)/programs/network/ircc/userparser.inc @ 4710 – Rev 9979 → 9981