Lisp Chat

An experimental chat irc-like written in Lisp.

lisp-chat-screenshot

Installation

You'll need in your system:

Make sure that ~/.sbclrc has a entry calling to the Quicklisp setup.

(load "~/.quicklisp/setup.lisp")

Since that ~/.quicklisp is the Quicklisp instalation distribution, clone this repository with:

git clone https://www.github.com/ryukinix/lisp-chat.git ~/.quicklisp/local-projects/lisp-chat

Tip for Quicklisp

As I said, we'll need a proper instalation of Quicklisp to getting this running. To accomplish that, if you are not familiar with the CL ecossystem, I'll guide you in a simple way: clone the Quicklisp Client and execute the setup.lisp with sbcl --script setup.lisp.

In general Quicklisp distribution provide the folder ~/quicklisp instead of ~/.quicklisp, but I personally don't like it much. Make sure to synchronize with the quicklisp correct folder. Maybe will need change the .sblcrc file to accomplish that, since for default as I said quicklisp set ~/quicklisp folder.

Usage

Load the server bash $ ./lisp-chat-server

Get a client bash $ ./lisp-chat

You can easilly setup your own configuration of *port* and *domain* for running a new instance of the server and client. For now we have a instance of lisp-chat as example running. If you really want to runs locally, you can just change the *domain* variable to "localhost" as:

(require 'lisp-chat)
(setq lisp-chat-config:*domain* "localhost")

For Non-lispers

If you want test this and don't have the Lisp environment with SBCL and Quicklisp, I have two alternative choices for you:

Python client
Netcat client (wtf?)

On Python client, I wrote in a way only using ths stdlib avoiding pain to handle the dependency hell, so you can just call that:

$ python client.py

So finally... netcat. Yes! You can even just use netcat! An user called Chris in past days just logged in the server with the following message:

|16:30:37| [Chris]: Used netcad
|16:30:41| [Chris]: netcat*
|16:30:50| [Chris]: bye

So you can type netcat chat.lerax.me 5558 and go on! I tested on my machine and works fine! The main reason is because the communication between server and client just use raw data. For better synchronization with text data from server while you typing, I suggest you to use a readline wrapper like rlwrap calling as rlwrap netcat ryukinix.tk 5558.

Copyright

lisp-chat is licensed under the MIT license. © Manoel Vilela .

Package Index

LISP-CHAT-CONFIG

special

`DEBUG`

Run application in debug mode with extra info in terminal

special
*HOST*
```
Host used in server and client
```
special
*PORT*
```
Default port
```

LISP-CHAT-CLIENT

special

`IO-MUTEX`

I/O Mutex for avoid terminal race conditions

function (

`CLIENT-LOOP`

)

Dispatch client threads for basic functioning system

function (

`CLIENT-SENDER`

SOCKET USERNAME)

Routine to check new messages being typed by the user

function (
GET-USER-INPUT
USERNAME)
```
Get the user input by using readline
```
function (
MAIN
)
```
Main function of client
```

function (

`RECEIVE-MESSAGE`

MESSAGE)

Receive a message and print in the terminal carefully with IO race conditions

function (

`SEND-MESSAGE`

MESSAGE SOCKET)

Send a MESSAGE string through a SOCKET instance

function (

`SERVER-BROADCAST`

SOCKET)

Call server-listener treating exceptional cases

function (

`SERVER-LISTENER`

SOCKET)

Routine to check new messages coming from the server

LISP-CHAT-SERVER

special
*CLIENT-MUTEX*

No docstring provided.
special
*CLIENTS*
```
List of clients
```

special

`COMMANDS-NAMES`

Allowed command names to be called by client user

special
*MESSAGE-SEMAPHORE*

No docstring provided.
special
*MESSAGES-LOG*
```
Messages log
```

special

`MESSAGES-STACK`

Messages pending to be send by broadcasting

special
*SERVER-NICKNAME*
```
The server nickname
```
special
*UPTIME*
```
Uptime of server variable
```

class

`CLIENT`

This structure handle the creation/control of the clients of the server.
   NAME is a string. Socket is a USOCKET:SOCKET and address is a ipv4 encoded
   string.

class

`MESSAGE`

This structure abstract the type message with is saved
   into *messages-log* and until consumed, temporally pushed
   to *messages-stack*. FROM, CONTENT and TIME has type string

function (

`/HELP`

CLIENT &REST ARGS)

Show a list of the available commands of lisp-chat

function (

`/LOG`

CLIENT &OPTIONAL (DEPTH "20") &REST ARGS)

Show the last messages typed on the server.
   DEPTH is optional number of messages frames from log

function (

`/NICK`

CLIENT &OPTIONAL (NEW-NICK NIL) &REST ARGS)

Change the client-name given a NEW-NICK which should be a string

function (

`/UPTIME`

CLIENT &REST ARGS)

Return a string nice encoded to preset the uptime since the server started.

function (

`/USERS`

CLIENT &REST ARGS)

Return a list separated by commas of the currently logged users

function (
CALL-COMMAND
CLIENT MESSAGE)

No docstring provided.

function (

`CALL-COMMAND-BY-NAME`

STRING PARAMS)

Wow, this is a horrible hack to get a string as symbol for functions/command
  like /help /users /log and so on.

function (
CLIENT-DELETE
CLIENT)
```
Delete a CLIENT from the list *clients*
```

function (

`CLIENT-READER`

CLIENT)

This procedure is a wrapper for CLIENT-READER-ROUTINE
   treating all the possible errors based on HANDLER-CASE macro.

function (

`CLIENT-READER-ROUTINE`

CLIENT)

This function create a IO-bound procedure to act
   by reading the events of a specific CLIENT.
   On this software each client talks on your own thread.

function (
CLIENT-STREAM
C)
```
Select the stream IO from the client
```

function (

`COMMAND-MESSAGE`

CONTENT)

This function prepare the CONTENT as a message by the @server

function (

`CONNECTION-HANDLER`

SOCKET-SERVER)

This is a special thread just for accepting connections from SOCKET-SERVER
   and creating new clients from it.

function (

`CREATE-CLIENT`

CONNECTION)

This procedure create a new client based on CONNECTION made by
  USOCKET:SOCKET-ACCEPT. This shit create a lot of side effects as messages
  if the debug is on because this makes all the log stuff to make analysis

function (

`DEBUG-FORMAT`

&REST ARGS)

If *debug* from lisp-chat-config is true, print debug info on
   running based on ARGS

function (
EXTRACT-PARAMS
STRING)

No docstring provided.

function (

`FORMATED-MESSAGE`

MESSAGE)

The default message format of this server. MESSAGE is a string
   Changing this reflects all the layout from client/server.
   Probably this would be the MFRP: Manoel Fucking Raw Protocol.
   Because this we can still use netcat as client for lisp-chat.

function (

`GET-TIME`

)

Return a encoded string as HH:MM:SS based on the current timestamp.

function (

`MAIN`

)

Well, this function run all the necessary shits.

function (

`MESSAGE-BROADCAST`

)

This procedure is a general independent thread to run brodcasting
   all the clients when a message is ping on this server

function (

`PUSH-MESSAGE`

FROM CONTENT)

Push a messaged FROM as CONTENT into the *messages-stack*

function (

`SAFE-CLIENT-THREAD`

CONNECTION)

This function is a wrapper for CREATE-CLIENT treating the
exceptions.

function (
SEND-MESSAGE
CLIENT MESSAGE)
```
Send to CLIENT a MESSAGE :type string
```

function (

`SERVER-LOOP`

SOCKET-SERVER)

This is the general server-loop procedure. Create the threads
   necessary for the basic working state of this chat. The main idea
   is creating a MESSAGE-BROADCAST procedure and CONNECTION-HANDLER
   procedure running as separated threads.

   The first procedure send always a new message too all clients
   defined on *clients* when *messages-semaphore* is signalized.
   The second procedure is a general connection-handler for new
   clients trying connecting to the server.

function (

`SOCKET-PEER-ADDRESS`

SOCKET)

Given a USOCKET:SOCKET instance return a ipv4 encoded IP string

function (

`SPLIT`

STRING DELIMITERP)

Split a string by a delimiterp function character checking

function (
STARTSWITH
STRING SUBSTRING)
```
Check if STRING starts with SUBSTRING.
```