;-------------------------------------------------------------------------
;   CHAT.ASM
;   Win32 Console Application
;-------------------------------------------------------------------------
;   Application uses the User Datagram Protocol (UDP)
;   to provide a direct communication between 2
;   computers in a peer to peer like environment.
;-------------------------------------------------------------------------
;   Fasm v1.69.20
;   20 Sep 2010, Picnic
;-------------------------------------------------------------------------

    format pe console
    entry main

    include "include\win32ax.inc"

section ".idata" import data readable writeable

    library\
    kernel32,"kernel32.dll",\
    user32,"user32.dll",\
    ws2_32,"ws2_32.dll",\
    msvcrt,"msvcrt.dll"

    include "include\api\kernel32.inc"
    include "include\api\user32.inc"

    import ws2_32,\
    gethostbyname,"gethostbyname",\
    gethostbyaddr,"gethostbyaddr",\
    WSAGetLastError,"WSAGetLastError",\
    WSAStartup,"WSAStartup",\
    WSACleanup,"WSACleanup",\
    closesocket,"closesocket",\
    inet_ntoa,"inet_ntoa",\
    inet_addr,"inet_addr",\
    recvfrom,"recvfrom",\
    sendto,"sendto",\
    socket,"socket",\
    listen,"listen",\
    bind,"bind",\
    htonl,"htonl",\
    htons,"htons",\
    ntohs,"ntohs"

    import msvcrt,\
    __getmainargs,"__getmainargs",\
    _beginthreadex,"_beginthreadex",\
    memset,"memset",\
    strcpy,"strcpy",\
    strlen,"strlen",\
    printf,"printf",\
    fgets,"fgets",\
    fflush,"fflush",\
    atoi,"atoi",\
    _iob,"_iob"

;-------------------------------------------------------------------------
;
section ".data" data readable writeable
;
;-------------------------------------------------------------------------

    MAX_SIZE = 2048
    INVALID_SOCKET = 0xFFFFFFFF
    crlf equ 0x0D,0x0A

    argc dd ?
    argv dd ?
    env dd ?
    listen_socket dd ?
    listen_port dd ?
    dest_port dd ?
    dest_name rb 256
    buffer rb MAX_SIZE

    align 4
    saddr sockaddr_in
    WSAData WSADATA

;-------------------------------------------------------------------------
;
section ".text" code readable executable
main:
;
;-------------------------------------------------------------------------

    cinvoke __getmainargs, addr argc, addr argv, addr env, 0
    .if ( dword [argc] = 4 )
        mov ebx, [argv]
        cinvoke atoi, dword [ebx+04h]
        mov dword [listen_port], eax
        push eax
        cinvoke atoi, dword [ebx+0Ch]
        mov dword [dest_port], eax
        pop ecx
    .endif

    ; Make sure data passed on command line is correct
    .if ( dword [argc] <> 4 | ~eax | ~ecx | eax > 65535 | ecx > 65535 | eax = ecx )
        cinvoke printf, <"Usage: chat [listen port] [destination machine] [destination port]",crlf>
        mov eax, 1
        ret
    .endif

    ; Save the destination machine's address/name
    cinvoke strcpy, addr dest_name, dword [ebx+08h]

    cinvoke printf, <"Initializing...",crlf>

    ; Starts the Winsock service
    invoke WSAStartup, 0202h, addr WSAData
    .if ( eax <> 0 )
        cinvoke printf, <"WSAStartup failed",crlf>
        mov eax, 1
        ret
    .endif

    ; Try to listen to requested port
    stdcall TryListen, dword [listen_port]
    .if ( ~eax )
        cinvoke printf, <"Error listening to port %d",crlf>, dword [listen_port]
        mov ebx, 1
    .else
        cinvoke printf, <"chat ready: <Ctrl-C> to exit",crlf>
        cinvoke fgets, addr buffer, MAX_SIZE, dword [_iob]

        .while ( eax <> 0 )
            ; Forward the sendbuf to destination machine
            ; Continue to grab input from stdin
            cinvoke strlen, addr buffer
            stdcall SendMsg, addr buffer, eax, addr dest_name, dword [dest_port]
            cinvoke fgets, addr buffer, MAX_SIZE, dword [_iob]
        .endw

        xor ebx, ebx
    .endif

    .if ( dword [listen_socket] <> INVALID_SOCKET )
        invoke closesocket, dword [listen_socket]
    .endif

    invoke WSACleanup
    invoke ExitProcess, ebx
    ret

;-------------------------------------------------------------------------
;
;   SendMsg()
;
;-------------------------------------------------------------------------

align 4
proc SendMsg uses ecx ebx edx,\
sendbuf:dword, sendlen:dword, host:dword, port:dword

    local ipaddr dd ?
    local to sockaddr_in

    ; Is the host passed a name?
    cinvoke atoi, dword [host]
    .if ( ~eax )
        invoke gethostbyname, [host]
    .else
        ; Otherwise, assume it's IP format
        cinvoke inet_addr, dword [host]
        mov dword [ipaddr], eax
        invoke gethostbyaddr, addr ipaddr, 4, AF_INET
    .endif

    .if ( ~eax )
        invoke WSAGetLastError
        cinvoke printf, <"Error getting host address - code: %ld",crlf>, eax
        xor eax, eax
        ret
    .endif

    virtual at eax
        .hostdata hostent
    end virtual
    mov eax, [.hostdata.h_addr_list]
    mov eax, [eax]
    mov eax, [eax]

    ; Endpoint address of the destination computer
    mov dword [to.sin_addr], eax
    mov dword [to.sin_family], AF_INET
    invoke htons, dword [port]
    mov word [to.sin_port], ax

    cinvoke printf, <"Message being sent to host %s port %d",crlf>, dword [host], dword [port]

    invoke sendto, dword [listen_socket], dword [sendbuf], dword [sendlen], 0, addr to, sizeof.sockaddr_in

    .if ( eax > dword [sendlen] | eax = INVALID_SOCKET )
        cinvoke printf, <"Error sending UDP packet from listen socket",crlf>
        xor eax, eax
        ret
    .endif

    mov eax, 1
    ret
endp

;-------------------------------------------------------------------------
;
;   TryListen()
;
;-------------------------------------------------------------------------

align 4
proc TryListen uses ecx ebx edx, port:dword

    local thread dd ?

    mov dword [listen_socket], INVALID_SOCKET

    ; This socket uses the User Datagram Protocol (UDP)
    invoke socket, AF_INET, SOCK_DGRAM, 17
    .if ( eax = INVALID_SOCKET )
        cinvoke printf, <"Error: listen socket creation failed",crlf>
        xor eax, eax
        ret
    .endif

    mov dword [listen_socket], eax

    mov dword [saddr.sin_family], AF_INET
    invoke htonl, 0 ; any address
    mov dword [saddr.sin_addr], eax
    invoke htons, dword [port]
    mov word [saddr.sin_port], ax

    invoke bind, dword [listen_socket], addr saddr, sizeof.sockaddr_in
    .if ( eax <> 0 )
        cinvoke printf, <"Error: bind on listen socket failed",crlf>
        invoke closesocket, dword [listen_socket]
        xor eax, eax
        ret
    .endif

    cinvoke _beginthreadex, 0, 0, addr ListenThread, dword [listen_socket], 0, addr thread
    .if ( ~eax )
        cinvoke printf, <"Error creating listen thread",crlf>
        xor eax, eax
        ret
    .endif

    invoke CloseHandle, eax

    mov eax, 1
    ret
endp

;-------------------------------------------------------------------------
;
;   ListenThread()
;
;-------------------------------------------------------------------------

align 4
proc ListenThread uses ecx ebx edx, s:dword

    local from_len dd ?
    local from sockaddr_in
    local recvbuf rb MAX_SIZE+100

    .while ( 1 )    ; loop forever

        mov [from_len], sizeof.sockaddr_in
        cinvoke memset, addr recvbuf, 0, MAX_SIZE
        invoke recvfrom, dword [s], addr recvbuf, MAX_SIZE-1, 0, addr from, addr from_len

        .if ( signed eax > 0 )

            lea ebx, dword [recvbuf]
            mov byte [ebx+eax], 0

            invoke inet_ntoa, dword [from.sin_addr]
            push eax
            movzx eax, word [from.sin_port]
            invoke ntohs, eax
            pop ecx

            cinvoke printf, <"Message received from host %s port %d",crlf>, ecx, eax
            cinvoke printf, ">> %s", addr recvbuf

        .endif

    .endw

    ret
endp
    

; import winsock

; Define our interface here. Just a struct

struct ISocketEvent
         onDataArrival   dd ? ; implement as proc onDataArrival, handle, lpData, dwSize
         onClientReady dd ? ; implement as proc onClientReady, handle, lpData, lpdwSize   ; return data to send and size in the last two parameters. (See below)
         onError           dd ? ; implement as proc onError, dwCode, pszDecription
         onConnect      dd ? ; implement as proc onConnect, handle, pszRemoteHost, dwPort
         onDisconnect   dd ? ; implement as proc onDisconnect, handle
ends

; Object identifiers
struct  SocketObject
          .socket   dd 0             ; socket handle
          .sai        sockaddr_in 
          .stop      dd 1             ; connection state (closed, this stops the loop)
          .ISocketEventPtr         ; the callback table pointer to user functions
endp


; impl

proc Startup
        ... winsock initialization here
endp 

/// Returns a handle (Basically a pointer to SocketObject struct)
proc Connect pszIP_or_DNS, port, iCallbackPtr

 
      handle =    memalloc SocketObject.Size

      handle.sai.port = port;
      handle.ISocketEventPtr = iCallbackPtr

      ... start connection thread
      CreateThread.. ConnectionThread, handle

      return handle
endp
proc ConnectionThread, handle
        ..winsock connection functions here


         handle.socket = socket(...);
           .. if error call  handle.ISocketEventPtr.onError, socket_error_code, "Custom or system description"

        .. if connection made
             call  handle.ISocketEventPtr.onConnect, handle, pszHostName, port
                          
             CreateThread( MonitorThread, handle )

       .. if not
             call handle.ISocketEventPtr.onError, socket_error_code, "Custom or system description"

       .. this thread exits
endp


/// Returns a handle (Basically a pointer to SocketObject struct)
proc Listen, port, iCallbackPtr
              handle = memalloc , SocketObject.Size

              handle.sai.port = port
              handle.ISocketEventPtr = iCallbackPtr

             // start listening thread
endp

proc ListenThread, handle
         while handle.stop = false
                 // you know the drill here boys
         end while
endp

proc MonitorThread, handle

      while handle.stop = false

      fd_set read_set.
      fd_set write_set.
      fd_set error_set.

      // check states here

      ..if(read_set)
         dwBytes = 0
         ioctlsocket(handle.socket, FIONREAD, dwBytes); .. available bytes to read
         
         buffer = memalloc dwBytes
         .. if not
             call handle.ISocketEventPtr.onError, custom_error_code, "Custom or system description"

         ..else
             recv(handle.socket, buffer, dwBytes)
             .. if not 
                 call handle.ISocketEventPtr.onError, socket_error_code, "Custom or system description"
             .. else
                 call handle.ISocketEventPtr.onDataAvailable, handle, buffer, dwBytes
                    if(buffer != null)    ; in case user did something stupid with the buffer
                         memfree(buffer)
                

      .. if(write_set)
          dwSize = 0
          lpBuffer= 0
          buffer = call handle.ISocketEventPtr.onClientReady, handle, buffer, dwSize

         if(buffer != null and dwSize > 0 )
            send(handle.socket, buffer, dwSize);

         .. if not
             call handle.ISocketEventPtr.onError, socket_error_code, "Custom or system description"

      if(error_set)
           get error code
            call handle.ISocketEventPtr.onError, socket_error_code, "Custom or system description"

      // check MSDN for more on how to check for a closed/disconnected socket
      if(read_set && <some other byte checks>)
           call handle.ISocketEventPtr.onDisconnected, handle
           exit here
           break;

         // pause or sleep here

      end while

        closesocket handle.socket
endp

proc FreeHandle, handle
         memfree, handle
endp

proc Close, handle
        handle.stop = true // this will stop the thread
endp

; exports

Startup
Connect
Listen
Send
Close
FreeHandle
    

; setup GUI
myGui.setup;

libSocket.Statup


proc onDataArrival, handle, bytes, size
         if(handle = my_handle)  ; of course you'd know how to do this
           myGui.RichEdit.Text.Append(bytes)
endp

proc onDisconnect
         myGui.Button.Connect.Enabled = true;
endp

my_handle dd 0
proc myGui.button.Connent.Click
          host = myGui.Edit.Host.Text
          port = int( myGui.Edit.Port.Text )
           my_handle = libSOcket.Connect, host, port
endp

    

I thought to make it better, a login system with username and password for each account would be nice but to be honest i'm bored now. Feel free to modify source as you wish.
Ansi colors were added, exploited the fact that clients like telnet.exe are forgiving, and overlook that proper use requires an exchanging information first. Also a server log added.
Here you are, sorry for any inconvenience.


Silent Edit
I started re-writing the chat program. I upload new sources as soon as possible.

Unfortunately many of my fasm console programs that using sockets are recognized as viruses. I can not resolve this.

pe console