Adding Colors to IRC Outgoing Messages

The other day, I participated in a discussion on GimpNet IRC (irc:// I saw there a message in which some words were colored. Since my client is Pidgin, I cannot add colors simply by clicking on the Font button, and selecting a color: all the menu options are disabled.

Searching the web for IRC colors, I found that mIRC supports adding colors to the text. If you are not a mIRC user, at least you can find the list of color codes here. The page does not describe how to add colors and other text attributes in other clients, but to learn at least about the sequences to be sent to the server, writing a script is recommended. To find the way to write scripts using the IRC protocol, I recommend using the PERL language. A great place to find PERL modules is the CPAN (Comprehensive PERL Archive Network) site. Search for IRC. A good class to create mIRC color strings is String::IRC – add color codes for mIRC compatible client.

Following is a script I’ve written to print the sequences:

use String::IRC;
use strict;

sub print_char {
    my $ch=shift;
    my $ord=ord($ch);
    if ($ord<32 or $ord>126){
        printf "\033[37;1m<%x>\033[0m", $ord;
    } else {
        print $ch;

sub print_string {
    my $str=shift;
    my $len=length($str);
    for (my $i=0; $i<$len;$i++){
    print "\n";

my $red=String::IRC->new("Red")->red;
print_string "Red: $red";
my $red_underlined=String::IRC->new("Red Underlined")->red->underline;
print_string "Red Underlined $red_underlined";
my $red_bold=String::IRC->new("Red Bold")->red->bold;
print_string "Red Bold: $red_bold";
my $red_inverse=String::IRC->new("Red Inverse")->red->inverse;
print_string "Red Inverse: $red_inverse";

The output of the script is in the following image:

The hex codes of control characters appear in white. They can be added as Unicode characters.


  • Unicode character 0x02 begins a bold string or sub-string.
  • Unicode character 0x1f begins an underlined string or sub-string.
  • Unicode character 0x03 begins a colored string or sub-string when followed by:
    • A foreground code
    • Foreground and background codes separated by a comma.
  • Unicode character 0x0f resumes to the default text format.

Now, to add a Control Character in Pidgin

First, check that the input method is “System”. To do it, left-click inside the input area and choose the input method:

Use your system’s method to insert a Unicode characterFor example, In Linux/UNIX, type <Ctrl>+<shift>+U followed by the hexadecimal code of the character, and the space or Enter.


Implementing Web Sockets With cURL

WebSocket is an internet protocol that allow full-duplex communication between a client and a TCP/HTTP server. This means that data can be passed in both directions simultaneously. Unlike HTTP, in WebSocket protocol, the client doesn’t have to send a request in order to get responses. Incoming messages are handled by event handlers. HTML5 supports the javascript object WebSocket.  This object has the function ‘send’ that sends a message to the server, and event listener defined by the developer:

onOpen(evt) – Connection Opened.

onMessage(evt) – Message received.

onError(evt) – Error occured.

onClose – Connection Closed.

A little example can be found here.

How to do it with cURL?

cURL does not support the WebSocket protocol. It won’t process a request if the URL string begins with ‘ws://’. You should use the ‘http’ or ‘https’ prefixes instead -for example ‘‘, and define request headers and cURL event listeners yourself. In cURL, you’ll define:

  •  A header function using the option ‘CURLOPT_HTTPHEADER’ to check if a connection has been established.
  •  A write function using ‘CURLOPT_WRITEFUNCTION’ to handle in-coming messages.
  •  A socket function using CURLOPT_OPENSOCKETFUNCTION to obtain an IO socket thru which to send messages to the server.

The WebSocket protocol is standardized by RFC 6455,

The following sections will discuss the parts of a C program implementing a Web Socket.

The Main Loop

This part creates a cURL handle by calling curl_easy_init(), defines headers, URL and callback functions using curl_easy_setopt(), and finally call ‘curl_easy_perform().

Following is an example:

#define concat(a,b) a b
  handle = curl_easy_init();
  // Add headers
  header_list_ptr = curl_slist_append(NULL , "HTTP/1.1 101 WebSocket Protocol Handshake");
  header_list_ptr = curl_slist_append(header_list_ptr , "Upgrade: WebSocket");
  header_list_ptr = curl_slist_append(header_list_ptr , "Connection: Upgrade");
  header_list_ptr = curl_slist_append(header_list_ptr , "Sec-WebSocket-Version: 13");
  header_list_ptr = curl_slist_append(header_list_ptr , "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==");
  curl_easy_setopt(handle, CURLOPT_URL, concat("http","://"));
  curl_easy_setopt(handle, CURLOPT_HTTPHEADER, header_list_ptr);
  curl_easy_setopt(handle, CURLOPT_OPENSOCKETFUNCTION, my_opensocketfunc);
  curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, my_func);
  curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, my_writefunc);

Obtaining a Socket

The socket is a resource used for sending messages to the server. Messages received from the server will be handled by the write function. Following is a function that returns the desired socket:

curl_socket_t my_opensocketfunc(void *clientp,
curlsocktype purpose,
struct curl_sockaddr *address){

return sock=socket(address->family, address->socktype, address->protocol);

The Request Header

The request header is defined in section 4.1 Client Requirements of RFC 6455.

The Response Header

The response header is defined in section 4.2.1. Reading the Client’s Opening Handshake of RFC 6455.

The response header fields should be checked by the header function. The format of a field is:

title: value <CRLF>

When the last field is received, the data contained in the first argument to the header function is a buffer of lenght two bytes,: <CRLF> i.e. byte 0x0d followed by 0x0a.

The structures of responses is defined here.

Sending and Receiving Messages

The format of messages is defined in section 5.2. Base Framing Protocol of RFC 6455.

A simple example is an unmask text message. In such a message the 1st byte will contain the hexadecimal value ‘0x81’. The 1st bit denotes that it is the final fragment, and the last 4 bits denotes a text message. The next byte will contain the length if shorter than 126 bytes. If the length is a 16bit number larger than 125 the byte will hold the value 0x7E, and the following 2 bytes the 16bit length. If the message is longer than 65,535 bytes, the 2nd byte will hold the value 0x7F, and the following 8 bytes will hold the length. The rest of the bytes are the payload data.

To send a message, use the C function ‘write’, as foolows:

write(sock, buff, length);

Incoming messages will be handle by the write function, given as the 3rd parameter to the curl_easy_setopt with the option ‘CURLOPT_WRITEFUNCTION’.

Read more about libcurl here.