diff --git a/README.md b/README.md
index 4fdf1e7..f517cdf 100644
--- a/README.md
+++ b/README.md
@@ -1,176 +1,178 @@
 # ExIrc
 
 [![Build Status](https://travis-ci.org/bitwalker/exirc.svg?branch=master)](https://travis-ci.org/bitwalker/exirc)
 [![Hex.pm Version](http://img.shields.io/hexpm/v/exirc.svg?style=flat)](https://hex.pm/packages/exirc)
 
 ExIrc is a IRC client library for Elixir projects. It aims to have a clear, well
 documented API, with the minimal amount of code necessary to allow you to connect and
 communicate with IRC servers effectively. It aims to implement the full RFC2812 protocol,
 and relevant parts of RFC1459.
 
 ## Getting Started
 
 Add ExIrc as a dependency to your project in mix.exs, and add it as an application:
 
 ```elixir
   defp deps do
     [{:exirc, "~> x.x.x"}]
   end
 
   defp application do
     [applications: [:exirc],
      ...]
   end
 ```
 
 Then fetch it using `mix deps.get`.
 
 To use ExIrc, you need to start a new client process, and add event handlers. An example event handler module
 is located in `lib/exirc/example_handler.ex`. **The example handler is kept up to date with all events you can
 expect to receive from the client**. A simple module is defined below as an example of how you might
 use ExIrc in practice. ExampleHandler here is the one that comes bundled with ExIrc.
 
+There is also a variety of examples in `examples`, the most up to date of which is `examples/bot`.
+
 ```elixir
 defmodule ExampleSupervisor do
     defmodule State do
         defstruct host: "chat.freenode.net",
                   port: 6667,
                   pass: "",
                   nick: "bitwalker",
                   user: "bitwalker",
                   name: "Paul Schoenfelder",
                   client: nil,
                   handlers: []
     end
 
     def start_link(_) do
         :gen_server.start_link(__MODULE__, [%State{}])
     end
 
     def init(state) do
         # Start the client and handler processes, the ExIrc supervisor is automatically started when your app runs
         {:ok, client}  = ExIrc.start_client!()
         {:ok, handler} = ExampleHandler.start_link(nil)
 
         # Register the event handler with ExIrc
         ExIrc.Client.add_handler client, handler
 
         # Connect and logon to a server, join a channel and send a simple message
         ExIrc.Client.connect!   client, state.host, state.port
         ExIrc.Client.logon      client, state.pass, state.nick, state.user, state.name
         ExIrc.Client.join       client, "#elixir-lang"
         ExIrc.Client.msg        client, :privmsg, "#elixir-lang", "Hello world!"
 
         {:ok, %{state | :client => client, :handlers => [handler]}}
     end
 
     def terminate(_, state) do
         # Quit the channel and close the underlying client connection when the process is terminating
         ExIrc.Client.quit state.client, "Goodbye, cruel world."
         ExIrc.Client.stop! state.client
         :ok
     end
 end
 ```
 
 A more robust example usage will wait until connected before it attempts to logon and then wait until logged
 on until it attempts to join a channel. Please see the `examples` directory for more in-depth examples cases.
 
 ```elixir
 
 defmodule ExampleApplication do
   use Application
 
   # See http://elixir-lang.org/docs/stable/elixir/Application.html
   # for more information on OTP Applications
   def start(_type, _args) do
     import Supervisor.Spec, warn: false
 
     {:ok, client} = ExIrc.start_client!
 
     children = [
       # Define workers and child supervisors to be supervised
       worker(ExampleConnectionHandler, [client]),
       # here's where we specify the channels to join:
       worker(ExampleLoginHandler, [client, ["#ohaibot-testing"]])
     ]
 
     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
     # for other strategies and supported options
     opts = [strategy: :one_for_one, name: ExampleApplication.Supervisor]
     Supervisor.start_link(children, opts)
   end
 end
 
 defmodule ExampleConnectionHandler do
   defmodule State do
     defstruct host: "chat.freenode.net",
               port: 6667,
               pass: "",
               nick: "bitwalker",
               user: "bitwalker",
               name: "Paul Schoenfelder",
               client: nil
   end
 
   def start_link(client, state \\ %State{}) do
     GenServer.start_link(__MODULE__, [%{state | client: client}])
   end
 
   def init([state]) do
     ExIrc.Client.add_handler state.client, self
     ExIrc.Client.connect! state.client, state.host, state.port
     {:ok, state}
   end
 
   def handle_info({:connected, server, port}, state) do
     debug "Connected to #{server}:#{port}"
     ExIrc.Client.logon state.client, state.pass, state.nick, state.user, state.name
     {:noreply, state}
   end
 
   # Catch-all for messages you don't care about
   def handle_info(msg, state) do
     debug "Received unknown messsage:"
     IO.inspect msg
     {:noreply, state}
   end
 
   defp debug(msg) do
     IO.puts IO.ANSI.yellow() <> msg <> IO.ANSI.reset()
   end
 end
 
 defmodule ExampleLoginHandler do
   @moduledoc """
   This is an example event handler that listens for login events and then
   joins the appropriate channels. We actually need this because we can't
   join channels until we've waited for login to complete. We could just
   attempt to sleep until login is complete, but that's just hacky. This
   as an event handler is a far more elegant solution.
   """
   def start_link(client, channels) do
     GenServer.start_link(__MODULE__, [client, channels])
   end
 
   def init([client, channels]) do
     ExIrc.Client.add_handler client, self
     {:ok, {client, channels}}
   end
 
   def handle_info(:logged_in, state = {client, channels}) do
     debug "Logged in to server"
     channels |> Enum.map(&ExIrc.Client.join client, &1)
     {:noreply, state}
   end
 
   # Catch-all for messages you don't care about
   def handle_info(_msg, state) do
     {:noreply, state}
   end
 
   defp debug(msg) do
     IO.puts IO.ANSI.yellow() <> msg <> IO.ANSI.reset()
   end
 end
 ```
diff --git a/examples/bot/lib/bot.ex b/examples/bot/lib/bot.ex
index e73bb4c..46dd6b6 100644
--- a/examples/bot/lib/bot.ex
+++ b/examples/bot/lib/bot.ex
@@ -1,107 +1,107 @@
 defmodule Example.Bot do
   use GenServer
   require Logger
 
   defmodule Config do
     defstruct server:  nil,
               port:    nil,
               pass:    nil,
               nick:    nil,
               user:    nil,
               name:    nil,
               channel: nil,
               client:  nil
 
     def from_params(params) when is_map(params) do
       Enum.reduce(params, %Config{}, fn {k, v}, acc ->
         case Map.has_key?(acc, k) do
           true  -> Map.put(acc, k, v)
           false -> acc
         end
       end)
     end
   end
 
   alias ExIrc.Client
 
   def start_link(%{:nick => nick} = params) when is_map(params) do
     config = Config.from_params(params)
     GenServer.start_link(__MODULE__, [config], name: String.to_atom(nick))
   end
 
   def init([config]) do
     # Start the client and handler processes, the ExIrc supervisor is automatically started when your app runs
     {:ok, client}  = ExIrc.start_client!()
 
     # Register the event handler with ExIrc
     Client.add_handler client, self()
 
     # Connect and logon to a server, join a channel and send a simple message
     Logger.debug "Connecting to #{server}:#{port}"
     Client.connect! client, config.server, config.port
 
     {:ok, %Config{config | :client => client}}
   end
 
   def handle_info({:connected, server, port}, config) do
     Logger.debug "Connected to #{server}:#{port}"
     Logger.debug "Logging to #{server}:#{port} as #{config.nick}.."
     Client.logon config.client, config.pass, config.nick, config.user, config.name
     {:noreply, config}
   end
   def handle_info(:logged_in, config) do
     Logger.debug "Logged in to #{config.server}:#{config.port}"
     Logger.debug "Joining #{config.channel}.."
     Client.join config.client, config.channel
     {:noreply, config}
   end
   def handle_info(:disconnected, config) do
     Logger.debug "Disconnected from #{config.server}:#{config.port}"
     {:stop, :normal, config}
   end
   def handle_info({:joined, channel}, config) do
     Logger.debug "Joined #{channel}"
     Client.msg config.client, :privmsg, config.channel, "Hello world!"
     {:noreply, config}
   end
   def handle_info({:names_list, channel, names_list}, config) do
     names = String.split(names_list, " ", trim: true)
             |> Enum.map(fn name -> " #{name}\n" end)
     Logger.info "Users logged in to #{channel}:\n#{names}"
     {:noreply, config}
   end
-  def handle_info({:received, msg, nick, channel}, config) do
+  def handle_info({:received, msg, %SenderInfo{:nick => nick}, channel}, config) do
     Logger.info "#{nick} from #{channel}: #{msg}"
     {:noreply, config}
   end
-  def handle_info({:mentioned, msg, nick, channel}, config) do
+  def handle_info({:mentioned, msg, %SenderInfo{:nick => nick}, channel}, config) do
     Logger.warn "#{nick} mentioned you in #{channel}"
     case String.contains?(msg, "hi") do
       true ->
         reply = "Hi #{nick}!"
         Client.msg config.client, :privmsg, config.channel, reply
         Logger.info "Sent #{reply} to #{config.channel}"
       false ->
         :ok
     end
     {:noreply, config}
   end
-  def handle_info({:received, msg, nick}, config) do
+  def handle_info({:received, msg, %SenderInfo{:nick => nick}}, config) do
     Logger.warn "#{nick}: #{msg}"
     reply = "Hi!"
     Client.msg config.client, :privmsg, nick, reply
     Logger.info "Sent #{reply} to #{nick}"
     {:noreply, config}
   end
   # Catch-all for messages you don't care about
   def handle_info(_msg, config) do
     {:noreply, config}
   end
 
   def terminate(_, state) do
     # Quit the channel and close the underlying client connection when the process is terminating
     Client.quit state.client, "Goodbye, cruel world."
     Client.stop! state.client
     :ok
   end
 end
diff --git a/lib/exirc/client.ex b/lib/exirc/client.ex
index 5cddc98..3b430e4 100644
--- a/lib/exirc/client.ex
+++ b/lib/exirc/client.ex
@@ -1,737 +1,734 @@
 defmodule ExIrc.Client do
   @moduledoc """
   Maintains the state and behaviour for individual IRC client connections
   """
   use    Irc.Commands
   import ExIrc.Logger
 
-  alias ExIrc.Channels, as: Channels
-  alias ExIrc.Utils,    as: Utils
-
-  alias ExIrc.Client.Transport, as: Transport
+  alias ExIrc.Channels
+  alias ExIrc.Utils
+  alias ExIrc.SenderInfo
+  alias ExIrc.Client.Transport
 
   # Client internal state
   defmodule ClientState do
     defstruct event_handlers:   [],
               server:           "localhost",
               port:             6667,
               socket:           nil,
               nick:             "",
               pass:             "",
               user:             "",
               name:             "",
               ssl?:             false,
               connected?:       false,
               logged_on?:       false,
               autoping:         true,
               channel_prefixes: "",
               network:          "",
               user_prefixes:    "",
               login_time:       "",
               channels:         [],
               debug?:           false
   end
-  defmodule SenderInfo do
-    defstruct nick: nil, host: nil, user: nil
-  end
 
   #################
   # External API
   #################
 
   @doc """
   Start a new IRC client process
 
   Returns either {:ok, pid} or {:error, reason}
   """
   @spec start!(options :: list() | nil) :: {:ok, pid} | {:error, term}
   def start!(options \\ []) do
     start_link(options)
   end
   @doc """
   Start a new IRC client process.
 
   Returns either {:ok, pid} or {:error, reason}
   """
   @spec start_link(options :: list() | nil, process_opts :: list() | nil) :: {:ok, pid} | {:error, term}
   def start_link(options \\ [], process_opts \\ []) do
     GenServer.start_link(__MODULE__, options, process_opts)
   end
   @doc """
   Stop the IRC client process
   """
   @spec stop!(client :: pid) :: {:stop, :normal, :ok, ClientState.t}
   def stop!(client) do
     :gen_server.call(client, :stop)
   end
   @doc """
   Connect to a server with the provided server and port
 
   Example:
     Client.connect! pid, "localhost", 6667
   """
   @spec connect!(client :: pid, server :: binary, port :: non_neg_integer, options :: list() | nil) :: :ok
   def connect!(client, server, port, options \\ []) do
     :gen_server.call(client, {:connect, server, port, options, false}, :infinity)
   end
   @doc """
   Connect to a server with the provided server and port via SSL
 
   Example:
     Client.connect! pid, "localhost", 6697
   """
   @spec connect_ssl!(client :: pid, server :: binary, port :: non_neg_integer, options :: list() | nil) :: :ok
   def connect_ssl!(client, server, port, options \\ []) do
     :gen_server.call(client, {:connect, server, port, options, true}, :infinity)
   end
   @doc """
   Determine if the provided client process has an open connection to a server
   """
   @spec is_connected?(client :: pid) :: true | false
   def is_connected?(client) do
     :gen_server.call(client, :is_connected?)
   end
   @doc """
   Logon to a server
 
   Example:
     Client.logon pid, "password", "mynick", "username", "My Name"
   """
   @spec logon(client :: pid, pass :: binary, nick :: binary, user :: binary, name :: binary) :: :ok | {:error, :not_connected}
   def logon(client, pass, nick, user, name) do
     :gen_server.call(client, {:logon, pass, nick, user, name}, :infinity)
   end
   @doc """
   Determine if the provided client is logged on to a server
   """
   @spec is_logged_on?(client :: pid) :: true | false
   def is_logged_on?(client) do
     :gen_server.call(client, :is_logged_on?)
   end
   @doc """
   Send a message to a nick or channel
   Message types are:
     :privmsg
     :notice
     :ctcp
   """
   @spec msg(client :: pid, type :: atom, nick :: binary, msg :: binary) :: :ok | {:error, atom}
   def msg(client, type, nick, msg) do
     :gen_server.call(client, {:msg, type, nick, msg}, :infinity)
   end
   @doc """
   Send an action message, i.e. (/me slaps someone with a big trout)
   """
   @spec me(client :: pid, channel :: binary, msg :: binary) :: :ok | {:error, atom}
   def me(client, channel, msg) do
     :gen_server.call(client, {:me, channel, msg}, :infinity)
   end
   @doc """
   Change the client's nick
   """
   @spec nick(client :: pid, new_nick :: binary) :: :ok | {:error, atom}
   def nick(client, new_nick) do
     :gen_server.call(client, {:nick, new_nick}, :infinity)
   end
   @doc """
   Send a raw IRC command
   """
   @spec cmd(client :: pid, raw_cmd :: binary) :: :ok | {:error, atom}
   def cmd(client, raw_cmd) do
     :gen_server.call(client, {:cmd, raw_cmd})
   end
   @doc """
   Join a channel, with an optional password
   """
   @spec join(client :: pid, channel :: binary, key :: binary | nil) :: :ok | {:error, atom}
   def join(client, channel, key \\ "") do
     :gen_server.call(client, {:join, channel, key}, :infinity)
   end
   @doc """
   Leave a channel
   """
   @spec part(client :: pid, channel :: binary) :: :ok | {:error, atom}
   def part(client, channel) do
     :gen_server.call(client, {:part, channel}, :infinity)
   end
   @doc """
   Kick a user from a channel
   """
   @spec kick(client :: pid, channel :: binary, nick :: binary, message :: binary | nil) :: :ok | {:error, atom}
   def kick(client, channel, nick, message \\ "") do
     :gen_server.call(client, {:kick, channel, nick, message}, :infinity)
   end
   @spec names(client :: pid, channel :: binary) :: :ok | {:error, atom}
   def names(client, channel) do
     :gen_server.call(client, {:names, channel}, :infinity)
   end
   @doc """
   Change mode for a user or channel
   """
   @spec mode(client :: pid, channel_or_nick :: binary, flags :: binary, args :: binary | nil) :: :ok | {:error, atom}
   def mode(client, channel_or_nick, flags, args \\ "") do
     :gen_server.call(client, {:mode, channel_or_nick, flags, args}, :infinity)
   end
   @doc """
   Invite a user to a channel
   """
   @spec invite(client :: pid, nick :: binary, channel :: binary) :: :ok | {:error, atom}
   def invite(client, nick, channel) do
     :gen_server.call(client, {:invite, nick, channel}, :infinity)
   end
   @doc """
   Quit the server, with an optional part message
   """
   @spec quit(client :: pid, msg :: binary | nil) :: :ok | {:error, atom}
   def quit(client, msg \\ "Leaving..") do
     :gen_server.call(client, {:quit, msg}, :infinity)
   end
   @doc """
   Get details about each of the client's currently joined channels
   """
   @spec channels(client :: pid) :: list(binary) | [] | {:error, atom}
   def channels(client) do
     :gen_server.call(client, :channels)
   end
   @doc """
   Get a list of users in the provided channel
   """
   @spec channel_users(client :: pid, channel :: binary) :: list(binary) | [] | {:error, atom}
   def channel_users(client, channel) do
     :gen_server.call(client, {:channel_users, channel})
   end
   @doc """
   Get the topic of the provided channel
   """
   @spec channel_topic(client :: pid, channel :: binary) :: binary | {:error, atom}
   def channel_topic(client, channel) do
     :gen_server.call(client, {:channel_topic, channel})
   end
   @doc """
   Get the channel type of the provided channel
   """
   @spec channel_type(client :: pid, channel :: binary) :: atom | {:error, atom}
   def channel_type(client, channel) do
     :gen_server.call(client, {:channel_type, channel})
   end
   @doc """
   Determine if a nick is present in the provided channel
   """
   @spec channel_has_user?(client :: pid, channel :: binary, nick :: binary) :: true | false | {:error, atom}
   def channel_has_user?(client, channel, nick) do
     :gen_server.call(client, {:channel_has_user?, channel, nick})
   end
   @doc """
   Add a new event handler process
   """
   @spec add_handler(client :: pid, pid) :: :ok
   def add_handler(client, pid) do
     :gen_server.call(client, {:add_handler, pid})
   end
   @doc """
   Add a new event handler process, asynchronously
   """
   @spec add_handler_async(client :: pid, pid) :: :ok
   def add_handler_async(client, pid) do
     :gen_server.cast(client, {:add_handler, pid})
   end
   @doc """
   Remove an event handler process
   """
   @spec remove_handler(client :: pid, pid) :: :ok
   def remove_handler(client, pid) do
     :gen_server.call(client, {:remove_handler, pid})
   end
   @doc """
   Remove an event handler process, asynchronously
   """
   @spec remove_handler_async(client :: pid, pid) :: :ok
   def remove_handler_async(client, pid) do
     :gen_server.cast(client, {:remove_handler, pid})
   end
   @doc """
   Get the current state of the provided client
   """
   @spec state(client :: pid) :: [{atom, any}]
   def state(client) do
     state = :gen_server.call(client, :state)
     [server:            state.server,
      port:              state.port,
      nick:              state.nick,
      pass:              state.pass,
      user:              state.user,
      name:              state.name,
      autoping:          state.autoping,
      ssl?:              state.ssl?,
      connected?:        state.connected?,
      logged_on?:        state.logged_on?,
      channel_prefixes:  state.channel_prefixes,
      user_prefixes:     state.user_prefixes,
      channels:          Channels.to_proplist(state.channels),
      network:           state.network,
      login_time:        state.login_time,
      debug?:            state.debug?,
      event_handlers:    state.event_handlers]
   end
 
   ###############
   # GenServer API
   ###############
 
   @doc """
   Called when :gen_server initializes the client
   """
   @spec init(list(any) | []) :: {:ok, ClientState.t}
   def init(options \\ []) do
     autoping = Keyword.get(options, :autoping, true)
     debug    = Keyword.get(options, :debug, false)
     # Add event handlers
     handlers =
       Keyword.get(options, :event_handlers, [])
       |> List.foldl([], &do_add_handler/2)
     # Return initial state
     {:ok, %ClientState{
       event_handlers: handlers,
       autoping:       autoping,
       logged_on?:     false,
       debug?:         debug,
       channels:       ExIrc.Channels.init()}}
   end
   @doc """
   Handle calls from the external API. It is not recommended to call these directly.
   """
   # Handle call to get the current state of the client process
   def handle_call(:state, _from, state), do: {:reply, state, state}
   # Handle call to stop the current client process
   def handle_call(:stop, _from, state) do
     # Ensure the socket connection is closed if stop is called while still connected to the server
     if state.connected?, do: Transport.close(state)
     {:stop, :normal, :ok, %{state | :connected? => false, :logged_on? => false, :socket => nil}}
   end
   # Handles call to add a new event handler process
   def handle_call({:add_handler, pid}, _from, state) do
     handlers = do_add_handler(pid, state.event_handlers)
     {:reply, :ok, %{state | :event_handlers => handlers}}
   end
   # Handles call to remove an event handler process
   def handle_call({:remove_handler, pid}, _from, state) do
     handlers = do_remove_handler(pid, state.event_handlers)
     {:reply, :ok, %{state | :event_handlers => handlers}}
   end
   # Handle call to connect to an IRC server
   def handle_call({:connect, server, port, options, ssl}, _from, state) do
     # If there is an open connection already, close it.
     if state.socket != nil, do: Transport.close(state)
     # Set SSL mode
     state = %{state | ssl?: ssl}
     # Open a new connection
     case Transport.connect(state, String.to_char_list(server), port, [:list, {:packet, :line}, {:keepalive, true}] ++ options) do
       {:ok, socket} ->
         send_event {:connected, server, port}, state
         {:reply, :ok, %{state | :connected? => true, :server => server, :port => port, :socket => socket}}
       error ->
         {:reply, error, state}
     end
   end
   # Handle call to determine if the client is connected
   def handle_call(:is_connected?, _from, state), do: {:reply, state.connected?, state}
   # Prevents any of the following messages from being handled if the client is not connected to a server.
   # Instead, it returns {:error, :not_connected}.
   def handle_call(_, _from, %ClientState{:connected? => false} = state), do: {:reply, {:error, :not_connected}, state}
   # Handle call to login to the connected IRC server
   def handle_call({:logon, pass, nick, user, name}, _from, %ClientState{:logged_on? => false} = state) do
     Transport.send state, pass!(pass)
     Transport.send state, nick!(nick)
     Transport.send state, user!(user, name)
     {:reply, :ok, %{state | :pass => pass, :nick => nick, :user => user, :name => name} }
   end
   # Handles call to change the client's nick.
   def handle_call({:nick, new_nick}, _from, %ClientState{:logged_on? => false} = state) do
     Transport.send state, nick!(new_nick)
     # Since we've not yet logged on, we won't get a nick change message, so we have to remember the nick here.
     {:reply, :ok, %{state | :nick => new_nick}}
   end
   # Handle call to determine if client is logged on to a server
   def handle_call(:is_logged_on?, _from, state), do: {:reply, state.logged_on?, state}
   # Prevents any of the following messages from being handled if the client is not logged on to a server.
   # Instead, it returns {:error, :not_logged_in}.
   def handle_call(_, _from, %ClientState{:logged_on? => false} = state), do: {:reply, {:error, :not_logged_in}, state}
   # Handles call to send a message
   def handle_call({:msg, type, nick, msg}, _from, state) do
     data = case type do
       :privmsg -> privmsg!(nick, msg)
       :notice  -> notice!(nick, msg)
       :ctcp    -> notice!(nick, ctcp!(msg))
     end
     Transport.send state, data
     {:reply, :ok, state}
   end
   # Handle /me messages
   def handle_call({:me, channel, msg}, _from, state) do
     data = me!(channel, msg)
     Transport.send state, data
     {:reply, :ok, state}
   end
   # Handles call to join a channel
   def handle_call({:join, channel, key}, _from, state) do
     Transport.send(state, join!(channel, key))
     {:reply, :ok, state}
   end
   # Handles a call to leave a channel
   def handle_call({:part, channel}, _from, state) do
     Transport.send(state, part!(channel))
     {:reply, :ok, state}
   end
   # Handles a call to kick a client
   def handle_call({:kick, channel, nick, message}, _from, state) do
     Transport.send(state, kick!(channel, nick, message))
     {:reply, :ok, state}
   end
   # Handles a call to send the NAMES command to the server
   def handle_call({:names, channel}, _from, state) do
     Transport.send(state, names!(channel))
     {:reply, :ok, state}
   end
   # Handles a call to change mode for a user or channel
   def handle_call({:mode, channel_or_nick, flags, args}, _from, state) do
     Transport.send(state, mode!(channel_or_nick, flags, args))
     {:reply, :ok, state}
   end
   # Handle call to invite a user to a channel
   def handle_call({:invite, nick, channel}, _from, state) do
     Transport.send(state, invite!(nick, channel))
     {:reply, :ok, state}
   end
   # Handle call to quit the server and close the socket connection
   def handle_call({:quit, msg}, _from, state) do
     if state.connected? do
       Transport.send state, quit!(msg)
       send_event :disconnected, state
       Transport.close state
     end
     {:reply, :ok, %{state | :connected? => false, :logged_on? => false, :socket => nil}}
   end
   # Handles call to change the client's nick
   def handle_call({:nick, new_nick}, _from, state) do Transport.send(state, nick!(new_nick)); {:reply, :ok, state} end
   # Handles call to send a raw command to the IRC server
   def handle_call({:cmd, raw_cmd}, _from, state) do Transport.send(state, command!(raw_cmd)); {:reply, :ok, state} end
   # Handles call to return the client's channel data
   def handle_call(:channels, _from, state), do: {:reply, Channels.channels(state.channels), state}
   # Handles call to return a list of users for a given channel
   def handle_call({:channel_users, channel}, _from, state), do: {:reply, Channels.channel_users(state.channels, channel), state}
   # Handles call to return the given channel's topic
   def handle_call({:channel_topic, channel}, _from, state), do: {:reply, Channels.channel_topic(state.channels, channel), state}
   # Handles call to return the type of the given channel
   def handle_call({:channel_type, channel}, _from, state), do: {:reply, Channels.channel_type(state.channels, channel), state}
   # Handles call to determine if a nick is present in the given channel
   def handle_call({:channel_has_user?, channel, nick}, _from, state) do
     {:reply, Channels.channel_has_user?(state.channels, channel, nick), state}
   end
   # Handles message to add a new event handler process asynchronously
   def handle_cast({:add_handler, pid}, state) do
     handlers = do_add_handler(pid, state.event_handlers)
     {:noreply, %{state | :event_handlers => handlers}}
   end
   @doc """
   Handles asynchronous messages from the external API. Not recommended to call these directly.
   """
   # Handles message to remove an event handler process asynchronously
   def handle_cast({:remove_handler, pid}, state) do
     handlers = do_remove_handler(pid, state.event_handlers)
     {:noreply, %{state | :event_handlers => handlers}}
   end
   @doc """
   Handle messages from the TCP socket connection.
   """
   # Handles the client's socket connection 'closed' event
   def handle_info({:tcp_closed, _socket}, %ClientState{:server => server, :port => port} = state) do
     info "Connection to #{server}:#{port} closed!"
     send_event :disconnected, state
     new_state = %{state |
       :socket =>     nil,
       :connected? => false,
       :logged_on? => false,
       :channels =>   Channels.init()
     }
     {:noreply, new_state}
   end
   @doc """
   Handle messages from the SSL socket connection.
   """
   # Handles the client's socket connection 'closed' event
   def handle_info({:ssl_closed, socket}, state) do
     handle_info({:tcp_closed, socket}, state)
   end
   # Handles any TCP errors in the client's socket connection
   def handle_info({:tcp_error, socket, reason}, %ClientState{:server => server, :port => port} = state) do
     error "TCP error in connection to #{server}:#{port}:\r\n#{reason}\r\nClient connection closed."
     new_state = %{state |
       :socket =>     nil,
       :connected? => false,
       :logged_on? => false,
       :channels =>   Channels.init()
     }
     {:stop, {:tcp_error, socket}, new_state}
   end
   # Handles any SSL errors in the client's socket connection
   def handle_info({:ssl_error, socket, reason}, state) do
     handle_info({:tcp_error, socket, reason}, state)
   end
   # General handler for messages from the IRC server
   def handle_info({:tcp, _, data}, state) do
     debug? = state.debug?
     case Utils.parse(data) do
       %IrcMessage{:ctcp => true} = msg ->
         handle_data msg, state
         {:noreply, state}
       %IrcMessage{:ctcp => false} = msg ->
         handle_data msg, state
       %IrcMessage{:ctcp => :invalid} = msg when debug? ->
         send_event msg, state
         {:noreply, state}
       _ ->
         {:noreply, state}
     end
   end
   # Wrapper for SSL socket messages
   def handle_info({:ssl, socket, data}, state) do
     handle_info({:tcp, socket, data}, state)
   end
   # If an event handler process dies, remove it from the list of event handlers
   def handle_info({:DOWN, _, _, pid, _}, state) do
     handlers = do_remove_handler(pid, state.event_handlers)
     {:noreply, %{state | :event_handlers => handlers}}
   end
   # Catch-all for unrecognized messages (do nothing)
   def handle_info(_, state) do
     {:noreply, state}
   end
   @doc """
   Handle termination
   """
   def terminate(_reason, state) do
     if state.socket != nil do
       Transport.close state
       %{state | :socket => nil}
     end
     :ok
   end
   @doc """
   Transform state for hot upgrades/downgrades
   """
   def code_change(_old, state, _extra), do: {:ok, state}
 
   ################
   # Data handling
   ################
 
   @doc """
   Handle IrcMessages received from the server.
   """
   # Called upon successful login
   def handle_data(%IrcMessage{:cmd => @rpl_welcome}, %ClientState{:logged_on? => false} = state) do
     if state.debug?, do: debug "SUCCESFULLY LOGGED ON"
     new_state = %{state | :logged_on? => true, :login_time => :erlang.timestamp()}
     send_event :logged_in, new_state
     {:noreply, new_state}
   end
   # Called when the server sends it's current capabilities
   def handle_data(%IrcMessage{:cmd => @rpl_isupport} = msg, state) do
     if state.debug?, do: debug "RECEIVING SERVER CAPABILITIES"
     {:noreply, Utils.isup(msg.args, state)}
   end
   # Called when the client enters a channel
   def handle_data(%IrcMessage{:nick => nick, :cmd => "JOIN"} = msg, %ClientState{:nick => nick} = state) do
     channel = msg.args |> List.first |> String.strip
     if state.debug?, do: debug "JOINED A CHANNEL #{channel}"
     channels  = Channels.join(state.channels, channel)
     new_state = %{state | :channels => channels}
     send_event {:joined, channel}, new_state
     {:noreply, new_state}
   end
   # Called when another user joins a channel the client is in
   def handle_data(%IrcMessage{:nick => user_nick, :cmd => "JOIN"} = msg, state) do
     channel = msg.args |> List.first |> String.strip
     if state.debug?, do: debug "ANOTHER USER JOINED A CHANNEL: #{channel} - #{user_nick}"
     channels  = Channels.user_join(state.channels, channel, user_nick)
     new_state = %{state | :channels => channels}
     send_event {:joined, channel, user_nick}, new_state
     {:noreply, new_state}
   end
   # Called on joining a channel, to tell us the channel topic
   # Message with three arguments is not RFC compliant but very common
   # Message with two arguments is RFC compliant
   def handle_data(%IrcMessage{:cmd => @rpl_topic} = msg, state) do
     {channel, topic} = case msg.args do
       [_nick, channel, topic] -> {channel, topic}
       [channel, topic]        -> {channel, topic}
     end
     if state.debug? do
       debug "INITIAL TOPIC MSG"
       debug "1. TOPIC SET FOR #{channel} TO #{topic}"
     end
     channels  = Channels.set_topic(state.channels, channel, topic)
     new_state = %{state | :channels => channels}
     send_event {:topic_changed, channel, topic}, new_state
     {:noreply, new_state}
   end
   # Called when the topic changes while we're in the channel
   def handle_data(%IrcMessage{:cmd => "TOPIC", :args => [channel, topic]}, state) do
     if state.debug?, do: debug "TOPIC CHANGED FOR #{channel} TO #{topic}"
     channels  = Channels.set_topic(state.channels, channel, topic)
     new_state = %{state | :channels => channels}
     send_event {:topic_changed, channel, topic}, new_state
     {:noreply, new_state}
   end
   # Called when joining a channel with the list of current users in that channel, or when the NAMES command is sent
   def handle_data(%IrcMessage{:cmd => @rpl_namereply} = msg, state) do
     if state.debug?, do: debug "NAMES LIST RECEIVED"
     {_nick, channel_type, channel, names} = case msg.args do
       [nick, channel_type, channel, names]  -> {nick, channel_type, channel, names}
       [channel_type, channel, names]        -> {nil, channel_type, channel, names}
     end
     channels = Channels.set_type(
       Channels.users_join(state.channels, channel, String.split(names, " ", trim: true)),
       channel,
       channel_type)
 
     send_event({:names_list, channel, names}, state)
 
     {:noreply, %{state | :channels => channels}}
   end
   # Called when our nick has succesfully changed
   def handle_data(%IrcMessage{:cmd => "NICK", :nick => nick, :args => [new_nick]}, %ClientState{:nick => nick} = state) do
     if state.debug?, do: debug "NICK CHANGED FROM #{nick} TO #{new_nick}"
     new_state = %{state | :nick => new_nick}
     send_event {:nick_changed, new_nick}, new_state
     {:noreply, new_state}
   end
   # Called when someone visible to us changes their nick
   def handle_data(%IrcMessage{:cmd => "NICK", :nick => nick, :args => [new_nick]}, state) do
     if state.debug?, do: debug "#{nick} CHANGED THEIR NICK TO #{new_nick}"
     channels  = Channels.user_rename(state.channels, nick, new_nick)
     new_state = %{state | :channels => channels}
     send_event {:nick_changed, nick, new_nick}, new_state
     {:noreply, new_state}
   end
   # Called upon mode change
   def handle_data(%IrcMessage{:cmd => "MODE", args: [channel, op, user]}, state) do
     if state.debug?, do: debug "MODE #{channel} #{op} #{user}"
     send_event {:mode, [channel, op, user]}, state
     {:noreply, state}
   end
   # Called when we leave a channel
   def handle_data(%IrcMessage{:cmd => "PART", :nick => nick} = msg, %ClientState{:nick => nick} = state) do
     channel = msg.args |> List.first |> String.strip
     if state.debug?, do: debug "WE LEFT A CHANNEL: #{channel}"
     channels  = Channels.part(state.channels, channel)
     new_state = %{state | :channels => channels}
     send_event {:parted, channel}, new_state
     {:noreply, new_state}
   end
   # Called when someone else in our channel leaves
   def handle_data(%IrcMessage{:cmd => "PART", :nick => from, :host => host, :user => user} = msg, state) do
     sender = %SenderInfo{:nick => from, :host => host, :user => user}
     channel = msg.args |> List.first |> String.strip
     if state.debug?, do: debug "#{from} LEFT A CHANNEL: #{channel}"
     channels  = Channels.user_part(state.channels, channel, from)
     new_state = %{state | :channels => channels}
     send_event {:parted, channel, sender}, new_state
     {:noreply, new_state}
   end
   # Called when we receive a PING
   def handle_data(%IrcMessage{:cmd => "PING"} = msg, %ClientState{:autoping => true} = state) do
     if state.debug?, do: debug "RECEIVED A PING!"
     case msg do
       %IrcMessage{:args => [from]} ->
         if state.debug?, do: debug("SENT PONG2")
         Transport.send(state, pong2!(from, msg.server))
       _ ->
         if state.debug?, do: debug("SENT PONG1")
         Transport.send(state, pong1!(state.nick))
     end
     {:noreply, state};
   end
   # Called when we are invited to a channel
   def handle_data(%IrcMessage{:cmd => "INVITE", :args => [nick, channel], :nick => by, :host => host, :user => user} = msg, %ClientState{:nick => nick} = state) do
     sender = %SenderInfo{:nick => by, :host => host, :user => user}
     if state.debug?, do: debug "RECEIVED AN INVITE: #{msg.args |> Enum.join(" ")}"
     send_event {:invited, sender, channel}, state
     {:noreply, state}
   end
   # Called when we are kicked from a channel
   def handle_data(%IrcMessage{:cmd => "KICK", :args => [channel, nick], :nick => by, :host => host, :user => user} = _msg, %ClientState{:nick => nick} = state) do
     sender = %SenderInfo{:nick => by, :host => host, :user => user}
     if state.debug?, do: debug "WE WERE KICKED FROM #{channel} BY #{by}"
     send_event {:kicked, sender, channel}, state
     {:noreply, state}
   end
   # Called when someone else was kicked from a channel
   def handle_data(%IrcMessage{:cmd => "KICK", :args => [channel, nick], :nick => by, :host => host, :user => user} = _msg, state) do
     sender = %SenderInfo{:nick => by, :host => host, :user => user}
     if state.debug?, do: debug "#{nick} WAS KICKED FROM #{channel} BY #{by}"
     send_event {:kicked, nick, sender, channel}, state
     {:noreply, state}
   end
   # Called when someone sends us a message
   def handle_data(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => [nick, message], :host => host, :user => user} = _msg, %ClientState{:nick => nick} = state) do
     sender = %SenderInfo{:nick => from, :host => host, :user => user}
     if state.debug?, do: debug "#{from} SENT US #{message}"
     send_event {:received, message, sender}, state
     {:noreply, state}
   end
   # Called when someone sends a message to a channel we're in, or a list of users
   def handle_data(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => [to, message], :host => host, :user => user} = _msg, %ClientState{:nick => nick} = state) do
     sender = %SenderInfo{:nick => from, :host => host, :user => user}
     if state.debug?, do: debug "#{from} SENT #{message} TO #{to}"
     send_event {:received, message, sender, to}, state
     # If we were mentioned, fire that event as well
     if String.contains?(message, nick), do: send_event({:mentioned, message, sender, to}, state)
     {:noreply, state}
   end
   # Called when someone uses ACTION, i.e. `/me dies`
   def handle_data(%IrcMessage{:nick => from, :cmd => "ACTION", :args => [channel, message], :host => host, :user => user} = _msg, state) do
     sender = %SenderInfo{:nick => from, :host => host, :user => user}
     if state.debug?, do: debug "* #{from} #{message} in #{channel}"
     send_event {:me, message, sender, channel}, state
     {:noreply, state}
   end
   # Called any time we receive an unrecognized message
   def handle_data(msg, state) do
     if state.debug? do debug "UNRECOGNIZED MSG: #{msg.cmd}"; IO.inspect(msg) end
     send_event {:unrecognized, msg.cmd, msg}, state
     {:noreply, state}
   end
 
   ###############
   # Internal API
   ###############
   defp send_event(msg, %ClientState{:event_handlers => handlers}) when is_list(handlers) do
     Enum.each(handlers, fn({pid, _}) -> Kernel.send(pid, msg) end)
   end
 
   defp do_add_handler(pid, handlers) do
     case Enum.member?(handlers, pid) do
       false ->
         ref = Process.monitor(pid)
         [{pid, ref} | handlers]
       true ->
         handlers
     end
   end
 
   defp do_remove_handler(pid, handlers) do
     case List.keyfind(handlers, pid, 0) do
       {pid, ref} ->
         Process.demonitor(ref)
         List.keydelete(handlers, pid, 0)
       nil ->
         handlers
     end
   end
 
   defp debug(msg) do
     IO.puts(IO.ANSI.green() <> msg <> IO.ANSI.reset())
   end
 
 end
diff --git a/lib/exirc/commands.ex b/lib/exirc/commands.ex
index dcb892f..9f52b75 100644
--- a/lib/exirc/commands.ex
+++ b/lib/exirc/commands.ex
@@ -1,263 +1,263 @@
 defmodule Irc.Commands do
   @moduledoc """
   Defines IRC command constants, and methods for generating valid commands to send to an IRC server.
   """
 
   defmacro __using__(_) do
 
     quote do
       import Irc.Commands
 
       ####################
       # IRC Numeric Codes
       ####################
 
       @rpl_welcome "001"
       @rpl_yourhost "002"
       @rpl_created "003"
       @rpl_myinfo "004"
       @rpl_isupport "005" # Defacto standard for server support
       @rpl_bounce "010"   # Defacto replacement of "005" in RFC2812
       @rpl_statsdline "250"
       #@doc """
       #":There are <integer> users and <integer> invisible on <integer> servers"
       #"""
       @rpl_luserclient "251"
       #@doc """
       # "<integer> :operator(s) online"
       #"""
       @rpl_luserop "252"
       #@doc """
       #"<integer> :unknown connection(s)"
       #"""
       @rpl_luserunknown "253"
       #@doc """
       #"<integer> :channels formed"
       #"""
       @rpl_luserchannels "254"
       #@doc """
       #":I have <integer> clients and <integer> servers"
       #"""
       @rpl_luserme "255"
       #@doc """
       #Local/Global user stats
       #"""
       @rpl_localusers "265"
       @rpl_globalusers "266"
       #@doc """
       #When sending a TOPIC message to determine the channel topic, 
       #one of two replies is sent. If the topic is set, RPL_TOPIC is sent back else
       #RPL_NOTOPIC.
       #"""
       @rpl_notopic "331"
       @rpl_topic "332"
       #@doc """
       #To reply to a NAMES message, a reply pair consisting
       #of RPL_NAMREPLY and RPL_ENDOFNAMES is sent by the
       #server back to the client. If there is no channel
       #found as in the query, then only RPL_ENDOFNAMES is
       #returned. The exception to this is when a NAMES
       #message is sent with no parameters and all visible
       #channels and contents are sent back in a series of
       #RPL_NAMEREPLY messages with a RPL_ENDOFNAMES to mark
       #the end.
 
       #Format: "<channel> :[[@|+]<nick> [[@|+]<nick> [...]]]"
       #"""
       @rpl_namereply "353"
       @rpl_endofnames "366"
       #@doc """
       #When responding to the MOTD message and the MOTD file
       #is found, the file is displayed line by line, with
       #each line no longer than 80 characters, using
       #RPL_MOTD format replies. These should be surrounded
       #by a RPL_MOTDSTART (before the RPL_MOTDs) and an
       #RPL_ENDOFMOTD (after).
       #"""
       @rpl_motd "372"
       @rpl_motdstart "375"
       @rpl_endofmotd "376"
 
       ################
       # Error Codes
       ################
 
       #@doc """
       #Used to indicate the nickname parameter supplied to a command is currently unused.
       #"""
       @err_no_such_nick "401"
       #@doc """
       #Used to indicate the server name given currently doesn"t exist.
       #"""
       @err_no_such_server "402"
       #@doc """
       #Used to indicate the given channel name is invalid.
       #"""
       @err_no_such_channel "403"
       #@doc """
       #Sent to a user who is either (a) not on a channel which is mode +n or (b),
       #not a chanop (or mode +v) on a channel which has mode +m set, and is trying 
       #to send a PRIVMSG message to that channel.
       #"""
       @err_cannot_send_to_chan "404"
       #@doc """
       #Sent to a user when they have joined the maximum number of allowed channels 
       #and they try to join another channel.
       #"""
       @err_too_many_channels "405"
       #@doc """
       #Returned to a registered client to indicate that the command sent is unknown by the server.
       #"""
       @err_unknown_command "421"
       #@doc """
       #Returned when a nickname parameter expected for a command and isn"t found.
       #"""
       @err_no_nickname_given "431"
       #@doc """
       #Returned after receiving a NICK message which contains characters which do not fall in the defined set.
       #"""
       @err_erroneus_nickname "432"
       #@doc """
       #Returned when a NICK message is processed that results in an attempt to 
       #change to a currently existing nickname.
       #"""
       @err_nickname_in_use "433"
       #@doc """
       #Returned by a server to a client when it detects a nickname collision
       #(registered of a NICK that already exists by another server).
       #"""
       @err_nick_collision "436"
       #@doc """
       #"""
       @err_unavail_resource "437"
       #@doc """
       #Returned by the server to indicate that the client must be registered before 
       #the server will allow it to be parsed in detail.
       #"""
       @err_not_registered "451"
       #"""
       # Returned by the server by numerous commands to indicate to the client that 
       # it didn"t supply enough parameters.
       #"""
       @err_need_more_params "461"
       #@doc """
       #Returned by the server to any link which tries to change part of the registered 
       #details (such as password or user details from second USER message).
       #"""
       @err_already_registered "462"
       #@doc """
       #Returned by the server to the client when the issued command is restricted
       #"""
       @err_restricted "484"
 
       ###############
       # Code groups
       ###############
 
       @logon_errors [ @err_no_nickname_given,   @err_erroneus_nickname,
                       @err_nickname_in_use,     @err_nick_collision,
                       @err_unavail_resource,    @err_need_more_params,
                       @err_already_registered,  @err_restricted ]
     end
 
   end
 
   ############
   # Helpers
   ############
   @ctcp_delimiter 0o001
 
   @doc """
   Builds a valid IRC command.
   """
   def command!(cmd), do: [cmd, '\r\n']
   @doc """
   Builds a valid CTCP command.
   """
   def ctcp!(cmd),       do: command! [@ctcp_delimiter, cmd, @ctcp_delimiter]
   def ctcp!(cmd, args) do
     expanded = args |> Enum.intersperse(' ')
     command! [@ctcp_delimiter, cmd, expanded, @ctcp_delimiter]
   end
 
   # IRC Commands
 
   @doc """
   Send password to server
   """
   def pass!(pwd), do: command! ['PASS ', pwd]
   @doc """
   Send nick to server. (Changes or sets your nick)
   """
   def nick!(nick), do: command! ['NICK ', nick]
   @doc """
   Send username to server. (Changes or sets your username)
   """
   def user!(user, name) do
     command! ['USER ', user, ' 0 * :', name]
   end
   @doc """
   Send PONG in response to PING
   """
   def pong1!(nick), do: command! ['PONG ', nick]
   @doc """
   Send a targeted PONG in response to PING
   """
   def pong2!(nick, to), do: command! ['PONG ', nick, ' ', to]
   @doc """
   Send message to channel or user
   """
   def privmsg!(nick, msg), do: command! ['PRIVMSG ', nick, ' :', msg]
   @doc """
   Send a `/me <msg>` CTCP command to t
   """
   def me!(channel, msg), do: command! ['PRIVMSG ', channel, ' :', @ctcp_delimiter, 'ACTION ', msg, @ctcp_delimiter]
   @doc """
   Sends a command to the server to get the list of names back
   """
-  def names!(channel), do: command! ['NAMES']
+  def names!(_channel), do: command! ['NAMES']
   @doc """
   Send notice to channel or user
   """
   def notice!(nick, msg), do: command! ['NOTICE ', nick, ' :', msg]
   @doc """
   Send join command to server (join a channel)
   """
   def join!(channel), do: command! ['JOIN ', channel]
   def join!(channel, key), do: command! ['JOIN ', channel, ' ', key]
   @doc """
   Send part command to server (leave a channel)
   """
   def part!(channel), do: command! ['PART ', channel]
   @doc """
   Send quit command to server (disconnect from server)
   """
   def quit!(msg \\ "Leaving"), do: command! ['QUIT :', msg]
   @doc """
   Send kick command to server
   """
   def kick!(channel, nick, message \\ "") do
     case "#{message}" |> String.length do
       0 -> command! ['KICK ', channel, ' ', nick]
       _ -> command! ['KICK ', channel, ' ', nick, ' ', message]
     end
   end
   @doc """
   Send mode command to server
   MODE <nick> <flags>
   MODE <channel> <flags> [<args>]
   """
   def mode!(channel_or_nick, flags, args \\ "") do
     case "#{args}" |> String.length do
       0 -> command! ['MODE ', channel_or_nick, ' ', flags]
       _ -> command! ['MODE ', channel_or_nick, ' ', flags, ' ', args]
     end
   end
   @doc """
   Send an invite command
   """
   def invite!(nick, channel) do
     command! ['INVITE ', nick, ' ', channel]
   end
 
 end
diff --git a/lib/exirc/sender_info.ex b/lib/exirc/sender_info.ex
new file mode 100644
index 0000000..0cb30c8
--- /dev/null
+++ b/lib/exirc/sender_info.ex
@@ -0,0 +1,8 @@
+defmodule SenderInfo do
+  @moduledoc """
+  This struct represents information available about the sender of a message.
+  """
+  defstruct nick: nil, 
+            host: nil, 
+            user: nil
+end