Subversion Repositories Kolibri OS

Rev

Rev 6026 | Rev 9979 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                                 ;;
  3. ;; Copyright (C) KolibriOS team 2004-2016. All rights reserved.    ;;
  4. ;; Distributed under terms of the GNU General Public License       ;;
  5. ;;                                                                 ;;
  6. ;;   Written by hidnplayr@kolibrios.org                            ;;
  7. ;;                                                                 ;;
  8. ;;         GNU GENERAL PUBLIC LICENSE                              ;;
  9. ;;          Version 2, June 1991                                   ;;
  10. ;;                                                                 ;;
  11. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  12.  
  13.  
  14. user_parser:
  15.  
  16.         mov     ebp, [window_active]                    ; print to the current window
  17.         mov     [window_print], ebp
  18.  
  19.         mov     ecx, [edit1.size]
  20.         test    ecx, ecx
  21.         jz      .ret                                    ; ignore empty commands
  22.  
  23.         mov     esi, input_text
  24.         mov     edi, user_command
  25.         call    recode                                  ; Convert to UTF-8
  26.         mov     word[edi], 0x0a0d                       ; terminate the line
  27.         sub     edi, user_command
  28.         mov     [user_command.size], edi
  29.  
  30.         cmp     byte[user_command], '/'                 ; is it a server command ?
  31.         je      .command
  32.  
  33.         cmp     [status], STATUS_LOGGED_IN
  34.         jne     .not_loggedin
  35.  
  36.         cmp     [ebp + window.type], WINDOWTYPE_CHANNEL
  37.         je      .send_privmsg
  38.         cmp     [ebp + window.type], WINDOWTYPE_CHAT
  39.         jne     .not_channel
  40.  
  41.   .send_privmsg:
  42.         if TIMESTAMP
  43.         call    print_timestamp
  44.         end if
  45.  
  46.         mov     al, '<'
  47.         call    print_char
  48.  
  49.         mov     esi, user_nick
  50.         call    print_asciiz
  51.  
  52.         mov     al, '>'
  53.         call    print_char
  54.         mov     al, ' '
  55.         call    print_char
  56.  
  57.         mov     eax, [user_command.size]
  58.         mov     byte[user_command + eax],0
  59.         mov     esi, user_command
  60.         call    print_asciiz
  61.  
  62.         mov     al, 10
  63.         call    print_char
  64.  
  65. ; and now send it to the server
  66.         mov     dword[packetbuf], 'PRIV'
  67.         mov     dword[packetbuf+4], 'MSG '
  68.  
  69.         lea     esi, [ebp + window.name]
  70.         mov     edi, packetbuf+8
  71.         mov     ecx, MAX_WINDOWNAME_LEN
  72.   .loop:
  73.         lodsb
  74.         test    al, al
  75.         jz      .done
  76.         stosb
  77.         dec     ecx
  78.         jnz     .loop
  79.   .done:
  80.  
  81.         mov     ax, ' :'
  82.         stosw
  83.  
  84.         mov     esi, user_command
  85.         mov     ecx, [user_command.size]
  86. ;        inc     ecx
  87.         rep     movsb
  88.  
  89. ; end the command with a CRLF
  90.         mov     ax, 0x0a0d
  91.         stosw
  92.  
  93.         lea     esi, [edi - packetbuf]
  94.         mcall   send, [socketnum], packetbuf, , 0
  95.  
  96.   .ret:
  97.         ret
  98.  
  99. ; Text begins with a '/' lets try to find the command in the lookup table.
  100.   .command:
  101.         mov     eax, dword[user_command+1]      ; skip '/'
  102.         or      eax, 0x20202020                 ; convert to lowercase
  103.  
  104.         mov     edi, user_commands
  105.         mov     ecx, user_commands.number
  106.         cmp     [status], STATUS_CONNECTED
  107.         jae     .cmd_loop
  108.         mov     ecx, user_commands.number2
  109.   .cmd_loop:
  110.         scasd
  111.         je      .got_cmd
  112.         add     edi, 4
  113.         dec     ecx
  114.         jnz     .cmd_loop
  115.  
  116.         cmp     [status], STATUS_CONNECTED
  117.         jb      .not_connected
  118.  
  119. ; Commands shorter then 3 chars are placed here
  120.         and     eax, 0x00ffffff
  121.         cmp     eax, 'me '
  122.         je      cmd_usr_me
  123.  
  124. ; If none of the listed commands, send text straight to server
  125.         jmp     cmd_usr_send
  126.  
  127.   .got_cmd:
  128.         jmp     dword[edi]
  129.  
  130.   .not_loggedin:
  131.         mov     esi, str_notloggedin
  132.         call    print_asciiz
  133.         ret
  134.  
  135.   .not_connected:
  136.         mov     esi, str_notconnected
  137.         call    print_asciiz
  138.         ret
  139.  
  140.   .not_channel:
  141.         mov     esi, str_notchannel
  142.         call    print_asciiz
  143.         ret
  144.  
  145.  
  146. ; user commands lookup table
  147. user_commands:
  148.         dd      'nick', cmd_usr_nick
  149.         dd      'real', cmd_usr_real
  150.         dd      'serv', cmd_usr_server
  151.         dd      'help', cmd_usr_help
  152.         dd      'code', cmd_usr_code
  153.  
  154.         .number2 = ($ - user_commands) / 8
  155.  
  156. ; All following commands require a connection to the server.
  157.         dd      'quer', cmd_usr_quer
  158.         dd      'quit', cmd_usr_quit
  159.         dd      'part', cmd_usr_part
  160.         dd      'ctcp', cmd_usr_ctcp
  161.         dd      'msg ', cmd_usr_msg
  162.  
  163.         .number = ($ - user_commands) / 8
  164.  
  165.  
  166.  
  167. cmd_usr_msg:
  168.  
  169.         lea     esi, [user_command+5]
  170.  
  171.         mov     dword[packetbuf], 'PRIV'
  172.         mov     dword[packetbuf+4], 'MSG '
  173.         lea     edi, [packetbuf+8]
  174.  
  175.   @@:
  176.         lodsb
  177.         test    al, al
  178.         jz      .fail
  179.         cmp     al, 10
  180.         je      .fail
  181.         cmp     al, 13
  182.         je      .fail
  183.         stosb
  184.         cmp     al, ' '
  185.         jne     @r
  186.  
  187.         mov     al, ':'
  188.         stosb
  189.  
  190.         push    edi
  191.   @@:
  192.         lodsb
  193.         test    al, al
  194.         jz      @f
  195.         cmp     al, 10
  196.         je      @f
  197.         cmp     al, 13
  198.         je      @f
  199.         stosb
  200.         jmp     @r
  201.   @@:
  202. ; end the command with a CRLF
  203.         mov     ax, 0x0a0d
  204.         stosw
  205.         mov     byte[edi], 0
  206.  
  207.         lea     esi, [edi - packetbuf]
  208.         mcall   send, [socketnum], packetbuf, , 0
  209.  
  210. ; now print to the window
  211.         if TIMESTAMP
  212.         call    print_timestamp
  213.         end if
  214.  
  215.         mov     esi, msg_header
  216.         call    print_asciiz
  217.  
  218.         mov     esi, packetbuf+8
  219.         mov     bl, ' '
  220.         call    print_string
  221.  
  222.         mov     al, '*'
  223.         call    print_char
  224.  
  225.         mov     al, ' '
  226.         call    print_char
  227.  
  228.         pop     esi
  229.         call    print_asciiz
  230.  
  231.   .fail:
  232.         ret
  233.  
  234.  
  235.  
  236. cmd_usr_quit:
  237.  
  238.         mov     esi, quit_msg
  239.         cmp     byte[user_command+5], ' '
  240.         jne     quit_server
  241.         lea     esi, [user_command+6]
  242.  
  243. ; esi = quit message
  244. quit_server:
  245.  
  246. ; User wants to close a channel, send PART command to server
  247.         mov     dword[packetbuf], 'QUIT'
  248.         mov     word[packetbuf+4], ' :'
  249.         lea     edi, [packetbuf+6]
  250. ; Append our quit msg
  251.   @@:
  252.         lodsb
  253.         cmp     al, 13
  254.         je      @f
  255.         test    al, al
  256.         jz      @f
  257.         stosb
  258.         jmp     @r
  259.   @@:
  260. ; end the command with a CRLF
  261.         mov     ax, 0x0a0d
  262.         stosw
  263.  
  264.         lea     esi, [edi - packetbuf]                  ; calculate length
  265.         mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
  266.  
  267.         mov     ebp, windows
  268.   .window_loop:
  269.         cmp     [ebp + window.type], WINDOWTYPE_NONE
  270.         je      .next_window
  271.         mov     [window_print], ebp
  272.         if TIMESTAMP
  273.         call    print_timestamp
  274.         end if
  275.         mov     esi, str_disconnected
  276.         call    print_asciiz
  277.         cmp     [ebp + window.type], WINDOWTYPE_CHANNEL
  278.         jne     .next_window
  279.         call    user_remove_all
  280.   .next_window:
  281.         add     ebp, sizeof.window
  282.         cmp     ebp, windows + (MAX_WINDOWS * sizeof.window)
  283.         jb      .window_loop
  284.  
  285.         mov     [status], STATUS_DISCONNECTED
  286.         mcall   close, [socketnum]
  287.  
  288.         ret
  289.  
  290.  
  291.  
  292.  
  293. cmd_usr_nick:
  294.  
  295.         cmp     [user_command.size], 5
  296.         je      .justprint
  297.         cmp     byte[user_command+5], ' '
  298.         jne     .fail
  299.         cmp     [socketnum], 0
  300.         je      .dontsend
  301.  
  302. ; Request nickname change to server
  303.         mov     dword[user_command+1], 'NICK'
  304.         mov     esi, [user_command.size]
  305.         mov     word[user_command + esi], 0x0a0d
  306.         inc     esi
  307.         mcall   send, [socketnum], user_command+1, , 0
  308.  
  309.   .fail:
  310.         ret
  311.  
  312. ; We arent logged in yet, directly change user_nick field and print notification to user.
  313.   .dontsend:
  314.         mov     ecx, MAX_NICK_LEN
  315.         mov     esi, user_command+6
  316.         mov     edi, user_nick
  317.   @@:
  318.         lodsb
  319.         cmp     al, 13
  320.         je      @f
  321.         stosb
  322.         dec     ecx
  323.         jnz     @r
  324.   @@:
  325.         xor     al, al
  326.         stosb
  327.  
  328.   .justprint:
  329.         mov     esi, str_nickchange
  330.         call    print_asciiz
  331.  
  332.         mov     esi, user_nick
  333.         call    print_asciiz
  334.  
  335.         mov     al, 10
  336.         call    print_char
  337.  
  338.         ret
  339.  
  340.  
  341.  
  342. cmd_usr_real:
  343.  
  344.         cmp     byte[user_command+5], ' '
  345.         jne     cmd_usr_send
  346.  
  347.         mov     ecx, MAX_REAL_LEN
  348.         mov     esi, user_command+6
  349.         mov     edi, user_real_name
  350.   .loop:
  351.         lodsb
  352.         cmp     al, 13
  353.         je      .done
  354.         stosb
  355.         dec     ecx
  356.         jnz     .loop
  357.   .done:
  358.         xor     al, al
  359.         stosb
  360.  
  361.         mov     esi, str_realchange
  362.         call    print_asciiz
  363.  
  364.         mov     esi, user_real_name
  365.         call    print_asciiz
  366.  
  367.         mov     al, 10
  368.         call    print_char
  369.  
  370.         ret
  371.  
  372.  
  373.  
  374. cmd_usr_server:
  375.  
  376.         mov     eax, dword[user_command+5]      ; check for 'er ', we only checked 'serv'
  377.         or      eax, 0x00002020
  378.         and     eax, 0x00ffffff
  379.         cmp     eax, 'er '
  380.         jne     cmd_usr_send
  381.  
  382. ; Server window is always first window in the list, switch to it.
  383.         mov     [window_print], windows
  384.         mov     [window_active], windows
  385.  
  386.         mov     ecx, [user_command.size]        ; ok now set the address
  387.         sub     ecx, 8
  388.  
  389.         mov     esi, user_command+8
  390.   .now:
  391.         push    esi
  392.         mov     edi, irc_server_name
  393.   .loop:                                        ; copy until zero byte, or ecx reaches zero.
  394.         lodsb
  395.         stosb
  396.         test    al, al
  397.         jz      .done
  398.         dec     ecx
  399.         jnz     .loop
  400.         xor     al, al
  401.         stosb
  402.   .done:
  403.         pop     esi
  404.  
  405. ; set it also in window name
  406.         mov     ebx, [window_print]
  407.         call    window_set_name
  408.  
  409. ; now connect
  410.         call    socket_connect
  411.  
  412.         ret
  413.  
  414.  
  415. cmd_usr_quer:
  416.  
  417.         mov     esi, user_command+7
  418.         call    window_open
  419. ;        test    ebx, ebx
  420. ;        jz      .fail
  421.  
  422.         ret
  423.  
  424.  
  425.  
  426. cmd_usr_help:
  427.  
  428.         mov     esi, str_help
  429.         call    print_asciiz
  430.  
  431.         ret
  432.  
  433.  
  434.  
  435. cmd_usr_code:
  436.  
  437.         ; TODO
  438.  
  439.         ret
  440.  
  441.  
  442.  
  443. ; User typed a part command
  444. cmd_usr_part:
  445.  
  446.         cmp     byte[user_command+5], 13        ; parameters given?
  447.         jne     cmd_usr_send                    ; yes, send command straight to server
  448.  
  449. ; close active window
  450. cmd_usr_close_window:
  451.  
  452.         mov     esi, [window_active]
  453.         mov     [window_print], esi
  454.         cmp     [esi + window.type], WINDOWTYPE_SERVER
  455.         je      .not_channel
  456.  
  457.         lea     esi, [esi + window.name]
  458.         call    cmd_usr_part_channel
  459.         call    window_close
  460.         ret
  461.  
  462.   .not_channel:
  463.         cmp     [esi + window.type], WINDOWTYPE_CHAT
  464.         jne     .not_chat
  465.  
  466.         call    window_close
  467.   .not_chat:
  468.  
  469.         ret
  470.  
  471.  
  472.  
  473. ; Send part command to server
  474. ; esi must point to channel name (ASCIIZ)
  475. cmd_usr_part_channel:
  476.  
  477. ; User wants to close a channel, send PART command to server
  478.         mov     dword[packetbuf], 'PART'
  479.         mov     byte[packetbuf+4], ' '
  480.         lea     edi, [packetbuf+5]
  481.   @@:
  482.         lodsb
  483.         test    al, al
  484.         jz      @f
  485.         cmp     al, 13
  486.         je      @f
  487.         cmp     al, 10
  488.         je      @f
  489.         stosb
  490.         jmp     @r
  491.   @@:
  492. ; end the command with a CRLF
  493.         mov     ax, 0x0a0d
  494.         stosw
  495.  
  496.         lea     esi, [edi - packetbuf]                  ; calculate length
  497.         mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
  498.  
  499.         ret
  500.  
  501.  
  502.  
  503. cmd_usr_ctcp:
  504.  
  505.         cmp     byte[user_command+5], ' '
  506.         jne     cmd_usr_send
  507.  
  508.         mov     esi, user_command+6
  509. ; prepare a 'PRIVMSG '
  510.         mov     dword[packetbuf], 'PRIV'
  511.         mov     dword[packetbuf+4], 'MSG '
  512.         lea     edi, [packetbuf+8]
  513.  
  514. ; append the destination (nickname/channel)
  515.   @@:
  516.         lodsb
  517.         test    al, al
  518.         jz      .fail
  519.         cmp     al, ' '
  520.         je      @f
  521.         stosb
  522.         jmp     @r
  523.   @@:
  524.  
  525.         mov     ax, ' :'
  526.         stosw
  527.         mov     al, 0x01
  528.         stosb
  529.  
  530. ; copy the message itself
  531.   @@:
  532.         lodsb
  533.         test    al, al
  534.         jz      @f
  535.         cmp     al, 13
  536.         je      @f
  537.         cmp     al, 10
  538.         je      @f
  539.         stosb
  540.         jmp     @r
  541.   @@:
  542.  
  543. ; end of message
  544.         mov     al, 0x01
  545.         stosb
  546.         mov     ax, 0x0a0d
  547.         stosw
  548.  
  549. ; now send it away
  550.         lea     esi, [edi - packetbuf]                  ; calculate length
  551.         mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
  552.  
  553. ;; TODO: print to window
  554.  
  555.   .fail:
  556.  
  557.         ret
  558.  
  559.  
  560.  
  561. cmd_usr_me:
  562.  
  563. ; prepare a 'PRIVMSG '
  564.         mov     dword[packetbuf], 'PRIV'
  565.         mov     dword[packetbuf+4], 'MSG '
  566.         lea     edi, [packetbuf+8]
  567.  
  568. ; append the destination (nickname/channel)
  569.         mov     esi, [window_active]
  570.         lea     esi, [esi + window.name]
  571.   @@:
  572.         lodsb
  573.         test    al, al
  574.         je      @f
  575.         stosb
  576.         jmp     @r
  577.   @@:
  578.  
  579. ; Make the CTCP action header
  580.         mov     eax, ' :' + 0x01 shl 16 + 'A' shl 24
  581.         stosd
  582.         mov     eax, 'CTIO'
  583.         stosd
  584.         mov     al, 'N'
  585.         stosb
  586.  
  587. ; copy the message itself (including first space)
  588.         mov     esi, user_command+3
  589.   @@:
  590.         lodsb
  591.         cmp     al, 13
  592.         je      @f
  593.         stosb
  594.         jmp     @r
  595.   @@:
  596.  
  597. ; end of CTCP message
  598.         mov     al, 0x01
  599.         stosb
  600.         mov     ax, 0x0a0d
  601.         stosw
  602.  
  603. ; now send it to the server
  604.         lea     esi, [edi - packetbuf]                  ; calculate length
  605.         mcall   send, [socketnum], packetbuf, , 0       ; and finally send to server
  606.  
  607. ; print to local window
  608.         if TIMESTAMP
  609.         call    print_timestamp
  610.         end if
  611.  
  612.         mov     esi, action_header
  613.         call    print_asciiz
  614.  
  615.         mov     esi, user_nick
  616.         call    print_asciiz
  617.  
  618.         mov     esi, user_command+3
  619.         mov     bl, 13
  620.         call    print_string
  621.  
  622.         mov     al, 10
  623.         call    print_char
  624.  
  625.         ret
  626.  
  627.  
  628.  
  629. ; The user typed some undefined command, just send it to the server
  630. cmd_usr_send:
  631.  
  632.         mov     esi, [user_command.size]
  633.         mov     eax, [user_command.size]
  634.         add     eax, user_command+1
  635.         mov     word[eax], 0x0d0a
  636.         inc     esi
  637.         mcall   send, [socketnum], user_command+1, , 0
  638.  
  639.         ret
  640.  
  641.  
  642.  
  643.  
  644.  
  645.