tox 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1ab3125d380817a144ee66674764101ec8e86754
-  data.tar.gz: 2b4f4c0e20c4bec09f30a15db7414926a9eff90e
+SHA256:
+  metadata.gz: 9367ed9e38a09dccb4ff7e1f75ca32f92905923787c30b7024d4d34c178f6a0a
+  data.tar.gz: eefe7bec29169dd32706f5bea1a4f38898fa3f2a4b3de8e43e177c2f862420bd
 SHA512:
-  metadata.gz: 560228cc65e59acace9c3e56b36582124ca7372719ecb7b68fadee22eaf7869a88abebb51e0eb459a94066609ddb1ec802a1cc60d96c9d72c319104bdb6c93f7
-  data.tar.gz: 7d441fa2149a92729b072c7716ed3cec8a33968c92550c12caf715ee0b1a714efa5985c3ef348cf1e8869713726d31f82a079111f3bf4ade1d65ac5ec6c02d6d
+  metadata.gz: 7fc56ef3915fa04ed359e8acd1a48091477163c0886ef9098b3e1c421f927a68afb03c29d4b05def5c8be0702355d8f740d9646d7b3b86d1aef4e733f34f41ab
+  data.tar.gz: d5b7f0da8e46e010ebabd8108722368958b2e193d0dfeb3a594877b79589057760c769ddfbc035c8df0dabd00c36e9a19cfd7c5b81eac2dbabc19572e556948d

data/.gitignore

@@ -7,6 +7,7 @@
 *.gem
 *.rbc
 /.config
+/.rake_tasks~
 /coverage/
 /InstalledFiles
 /pkg/
@@ -42,3 +43,7 @@
 
 # Rake-compiled extension files:
 /lib/tox/tox.so
+
+# Vendored dependencies:
+/vendor/*
+!/vendor/src/

data/.gitmodules

@@ -1,6 +1,6 @@
 [submodule "vendor/libtoxcore"]
-	path = vendor/libtoxcore
+	path = vendor/src/libtoxcore
 	url = https://github.com/TokTok/c-toxcore.git
 [submodule "vendor/libsodium"]
-	path = vendor/libsodium
+	path = vendor/src/libsodium
 	url = https://github.com/jedisct1/libsodium.git

data/.rubocop.yml

@@ -17,6 +17,7 @@ Lint/InheritException:
 
 Metrics/BlockLength:
   Exclude:
+    - 'Rakefile'
     - '**/*.gemspec'
     - 'spec/**/*'
 
@@ -29,6 +30,11 @@ Style/DoubleNegation:
 Style/GlobalVars:
   Exclude:
     - 'ext/**/*'
+    - 'spec/network_helper.rb'
+
+Style/PredicateName:
+  Exclude:
+    - 'ext/tox/extconf.rb'
 
 Style/TrailingCommaInArguments:
   EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -3,17 +3,12 @@ language: ruby
 rvm:
   - 2.3
   - 2.4
+  - 2.5
+  - 2.6
 
 before_install:
   - sudo apt-get update
-  - sudo apt-get install -y build-essential libtool autotools-dev automake checkinstall check git yasm
-
-  - sudo ./bin/build/libsodium
-  - sudo ./bin/build/libtoxcore
-
-  - sudo mkdir -p '/etc/ld.so.conf.d/'
-  - echo '/usr/local/lib/' | sudo tee -a '/etc/ld.so.conf.d/locallib.conf'
-  - sudo ldconfig
+  - sudo apt-get install -y yasm libconfig-dev
 
 before_script:
-  - rake compile
+  - rake ext

data/README.md

@@ -4,8 +4,17 @@
 [![Gem Version](https://badge.fury.io/rb/tox.svg)](http://badge.fury.io/rb/tox)
 [![Build Status](https://travis-ci.org/toxon/tox.rb.svg)](https://travis-ci.org/toxon/tox.rb)
 [![Coverage Status](https://coveralls.io/repos/github/toxon/tox.rb/badge.svg)](https://coveralls.io/github/toxon/tox.rb)
+[![Inline docs](http://inch-ci.org/github/toxon/tox.rb.svg?branch=master)](http://inch-ci.org/github/toxon/tox.rb)
 
 Ruby interface for [libtoxcore](https://github.com/TokTok/c-toxcore).
 It can be used to create [Tox chat](https://tox.chat) client or bot.
 The interface is object-oriented instead of C-style (raises exceptions
 instead of returning error codes, uses classes to represent primitives, etc.)
+
+
+
+Table of contents
+-----------------
+
+* [Overview](#tox)
+* [Table of contents](#table-of-contents)

data/Rakefile

@@ -2,17 +2,31 @@
 
 require 'bundler/gem_tasks'
 
-GEMSPEC = Gem::Specification.load 'lita-tox.gemspec'
+VENDOR_PREFIX = File.expand_path('vendor', __dir__).freeze
 
-task default: %i[compile spec lint]
+VENDOR_PKG_CONFIG_PATH = File.join(VENDOR_PREFIX, 'lib', 'pkgconfig').freeze
 
+desc 'Run all checks (test, lint...)'
+task default: %i[test lint]
+
+desc 'Run all tests (specs, benchmarks...)'
+task test: :spec
+
+desc 'Run all code analysis tools (RuboCop...)'
 task lint: :rubocop
 
+desc 'Fix code style (rubocop --auto-correct)'
 task fix: 'rubocop:auto_correct'
 
+desc 'Compile all extensions (and their dependencies)'
+task ext: %i[ext:tox]
+
+require 'pry'
+
 begin
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new
+  Rake::Task[:spec].enhance %i[ext]
 rescue LoadError
   nil
 end
@@ -34,9 +48,104 @@ end
 begin
   require 'rake/extensiontask'
 
-  Rake::ExtensionTask.new 'tox', GEMSPEC do |ext|
+  Rake::ExtensionTask.new 'tox' do |ext|
     ext.lib_dir = 'lib/tox'
+    ext.config_options << "--with-opt-dir=#{VENDOR_PREFIX.shellescape}"
   end
+
+  Rake::Task[:compile].clear_comments
+  Rake::Task['compile:tox'].clear_comments
 rescue LoadError
   nil
 end
+
+namespace :ext do
+  desc 'Compile "tox" extension (and it\'s dependencies)'
+  task tox: %i[
+    vendor/lib/pkgconfig/libtoxcore.pc
+    compile:tox
+  ]
+end
+
+namespace :vendor do
+  desc 'Install vendored dependencies into "./vendor/{bin,include,lib}/"'
+  task install: %i[install:libsodium install:libtoxcore]
+
+  desc 'Uninstall vendored dependencies from "./vendor/{bin,include,lib}/"'
+  task :uninstall do
+    rm_rf File.join VENDOR_PREFIX, 'bin'
+    rm_rf File.join VENDOR_PREFIX, 'include'
+    rm_rf File.join VENDOR_PREFIX, 'lib'
+  end
+
+  desc 'Delete compiled vendored dependencies from "./vendor/"'
+  task clean: %i[uninstall clean:libsodium clean:libtoxcore]
+
+  namespace :install do
+    task libsodium: 'vendor/lib/pkgconfig/libsodium.pc'
+    task libtoxcore: 'vendor/lib/pkgconfig/libtoxcore.pc'
+  end
+
+  namespace :clean do
+    task :libsodium do
+      chdir 'vendor/src/libsodium' do
+        sh 'make clean'
+      end
+    end
+
+    task :libtoxcore do
+      chdir 'vendor/src/libtoxcore' do
+        sh 'make clean'
+      end
+    end
+  end
+end
+
+file 'vendor/lib/pkgconfig/libsodium.pc': 'vendor/src/libsodium/Makefile' do
+  chdir 'vendor/src/libsodium' do
+    sh 'make install'
+  end
+end
+
+file 'vendor/lib/pkgconfig/libtoxcore.pc': 'vendor/src/libtoxcore/Makefile' do
+  chdir 'vendor/src/libtoxcore' do
+    sh 'make install'
+  end
+end
+
+file 'vendor/src/libsodium/Makefile': 'vendor/src/libsodium/configure' do |t|
+  chdir File.dirname t.name do
+    sh(
+      { 'PKG_CONFIG_PATH' => VENDOR_PKG_CONFIG_PATH },
+      './configure',
+      '--prefix',
+      VENDOR_PREFIX,
+    )
+  end
+end
+
+file 'vendor/src/libtoxcore/Makefile':
+       %i[vendor/src/libtoxcore/configure
+          vendor/lib/pkgconfig/libsodium.pc] do |t|
+  chdir File.dirname t.name do
+    sh(
+      { 'PKG_CONFIG_PATH' => VENDOR_PKG_CONFIG_PATH },
+      './configure',
+      '--prefix',
+      VENDOR_PREFIX,
+      '--enable-daemon',
+    )
+  end
+end
+
+file 'vendor/src/libsodium/configure' do |t|
+  chdir File.dirname t.name do
+    sh './autogen.sh'
+  end
+end
+
+file 'vendor/src/libtoxcore/configure' do |t|
+  chdir File.dirname t.name do
+    sh './autogen.sh'
+  end
+end

data/bin/childprocess

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This wrapper ensures than child process is terminated/killed
+# if parent process does not exist anymore.
+
+require 'English'
+
+TRAPS = %i[HUP INT QUIT TRAP ABRT TERM USR1 USR2].freeze
+
+pid = spawn(*ARGV, in: :in, out: :out, err: :err)
+
+signal = lambda do |signo|
+  begin
+    Process.kill signo, pid
+  rescue
+    nil
+  end
+end
+
+TRAPS.each do |signame|
+  trap signame, &signal
+end
+
+Thread.start pid do |pid| # rubocop:disable Lint/ShadowingOuterLocalVariable
+  loop do
+    begin
+      sleep 1
+      Process.kill 0, Process.ppid
+    rescue
+      begin
+        Process.kill :SIGTERM, pid
+        sleep 2
+        Process.kill :SIGKILL, pid
+      rescue
+        nil
+      end
+    end
+  end
+end
+
+Process.wait pid
+
+exit $CHILD_STATUS.exitstatus || 1

data/examples/echo_bot.rb

@@ -31,7 +31,7 @@ tox_client.status = Tox::UserStatus::NONE
 tox_client.status_message = STATUS_MESSAGE
 
 puts
-puts "Address:        #{tox_client.address.to_hex}"
+puts "Address:        #{tox_client.address}"
 puts "Name:           #{tox_client.name}"
 puts "Status:         #{tox_client.status}"
 puts "Status message: #{tox_client.status_message}"
@@ -40,9 +40,10 @@ puts
 puts 'Connecting to the nodes from official list...'
 tox_client.bootstrap_official
 
-tox_client.on_friend_request do |public_key|
-  puts "Got friend request with public key #{public_key.to_hex}. " \
-       'Adding to contacts...'
+tox_client.on_friend_request do |public_key, text|
+  puts 'Friend request. Adding to contacts...'
+  puts "Public key: #{public_key}"
+  puts "Text:       #{text.inspect}"
   puts
 
   tox_client.friend_add_norequest public_key
@@ -52,10 +53,10 @@ tox_client.on_friend_message do |friend, text|
   puts 'Message from friend'
   puts "Number:         #{friend.number}"
   puts "Name:           #{friend.name}"
-  puts "Public key:     #{friend.public_key.to_hex}"
+  puts "Public key:     #{friend.public_key}"
   puts "Status:         #{friend.status}"
   puts "Status message: #{friend.status_message}"
-  puts text.inspect
+  puts "Text:           #{text.inspect}"
   puts
 
   friend.send_message text
@@ -66,7 +67,10 @@ puts 'Running. Send me friend request, I\'ll accept it immediately. ' \
 
 begin
   puts
-  tox_client.run
+  loop do
+    sleep tox_client.iteration_interval
+    tox_client.iterate
+  end
   puts
 rescue SignalException
   puts

data/ext/tox/client.c

@@ -1,21 +1,3 @@
-/*
- * tox.rb - Ruby interface for libtoxcore
- * Copyright (C) 2015-2017  Braiden Vasco
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
 #include "tox.h"
 
 #include <time.h>
@@ -26,29 +8,38 @@ static void  mTox_cClient_free(mTox_cClient_CDATA *free_cdata);
 
 // Public methods
 
+static VALUE mTox_cClient_iteration_interval(VALUE self);
+static VALUE mTox_cClient_iterate(VALUE self);
+
+static VALUE mTox_cClient_connection_status(VALUE self);
 static VALUE mTox_cClient_public_key(VALUE self);
 static VALUE mTox_cClient_address(VALUE self);
+static VALUE mTox_cClient_nospam(VALUE self);
+static VALUE mTox_cClient_nospam_ASSIGN(VALUE self, VALUE nospam);
 static VALUE mTox_cClient_savedata(VALUE self);
+static VALUE mTox_cClient_udp_port(VALUE self);
+static VALUE mTox_cClient_tcp_port(VALUE self);
 
-static VALUE mTox_cClient_bootstrap(VALUE self, VALUE node);
+static VALUE mTox_cClient_bootstrap(VALUE self, VALUE address, VALUE port, VALUE public_key);
+static VALUE mTox_cClient_add_tcp_relay(VALUE self, VALUE address, VALUE port, VALUE public_key);
 
 static VALUE mTox_cClient_name(VALUE self);
-static VALUE mTox_cClient_name_EQUALS(VALUE self, VALUE name);
+static VALUE mTox_cClient_name_ASSIGN(VALUE self, VALUE name);
 
 static VALUE mTox_cClient_status(VALUE self);
-static VALUE mTox_cClient_status_EQUALS(VALUE self, VALUE status);
+static VALUE mTox_cClient_status_ASSIGN(VALUE self, VALUE status);
 
 static VALUE mTox_cClient_status_message(VALUE self);
-static VALUE mTox_cClient_status_message_EQUALS(VALUE self, VALUE status_message);
+static VALUE mTox_cClient_status_message_ASSIGN(VALUE self, VALUE status_message);
 
 static VALUE mTox_cClient_friend_numbers(VALUE self);
 
 static VALUE mTox_cClient_friend_add_norequest(VALUE self, VALUE public_key);
+static VALUE mTox_cClient_friend_add(VALUE self, VALUE address, VALUE text);
 
 // Private methods
 
 static VALUE mTox_cClient_initialize_with(VALUE self, VALUE options);
-static VALUE mTox_cClient_run_loop(VALUE self);
 
 // Callbacks
 
@@ -103,29 +94,38 @@ void mTox_cClient_INIT()
 
   // Public methods
 
-  rb_define_method(mTox_cClient, "public_key", mTox_cClient_public_key, 0);
-  rb_define_method(mTox_cClient, "address",    mTox_cClient_address,    0);
-  rb_define_method(mTox_cClient, "savedata",   mTox_cClient_savedata,   0);
+  rb_define_method(mTox_cClient, "iteration_interval", mTox_cClient_iteration_interval, 0);
+  rb_define_method(mTox_cClient, "iterate",            mTox_cClient_iterate,            0);
+
+  rb_define_method(mTox_cClient, "connection_status", mTox_cClient_connection_status, 0);
+  rb_define_method(mTox_cClient, "public_key",        mTox_cClient_public_key,        0);
+  rb_define_method(mTox_cClient, "address",           mTox_cClient_address,           0);
+  rb_define_method(mTox_cClient, "nospam",            mTox_cClient_nospam,            0);
+  rb_define_method(mTox_cClient, "nospam=",           mTox_cClient_nospam_ASSIGN,     1);
+  rb_define_method(mTox_cClient, "savedata",          mTox_cClient_savedata,          0);
+  rb_define_method(mTox_cClient, "udp_port",          mTox_cClient_udp_port,          0);
+  rb_define_method(mTox_cClient, "tcp_port",          mTox_cClient_tcp_port,          0);
 
-  rb_define_method(mTox_cClient, "bootstrap", mTox_cClient_bootstrap, 1);
+  rb_define_method(mTox_cClient, "bootstrap",     mTox_cClient_bootstrap,     3);
+  rb_define_method(mTox_cClient, "add_tcp_relay", mTox_cClient_add_tcp_relay, 3);
 
   rb_define_method(mTox_cClient, "name",  mTox_cClient_name,        0);
-  rb_define_method(mTox_cClient, "name=", mTox_cClient_name_EQUALS, 1);
+  rb_define_method(mTox_cClient, "name=", mTox_cClient_name_ASSIGN, 1);
 
   rb_define_method(mTox_cClient, "status",  mTox_cClient_status,        0);
-  rb_define_method(mTox_cClient, "status=", mTox_cClient_status_EQUALS, 1);
+  rb_define_method(mTox_cClient, "status=", mTox_cClient_status_ASSIGN, 1);
 
   rb_define_method(mTox_cClient, "status_message",  mTox_cClient_status_message,        0);
-  rb_define_method(mTox_cClient, "status_message=", mTox_cClient_status_message_EQUALS, 1);
+  rb_define_method(mTox_cClient, "status_message=", mTox_cClient_status_message_ASSIGN, 1);
 
   rb_define_method(mTox_cClient, "friend_numbers", mTox_cClient_friend_numbers, 0);
 
   rb_define_method(mTox_cClient, "friend_add_norequest", mTox_cClient_friend_add_norequest, 1);
+  rb_define_method(mTox_cClient, "friend_add",           mTox_cClient_friend_add,           2);
 
   // Private methods
 
   rb_define_private_method(mTox_cClient, "initialize_with", mTox_cClient_initialize_with, 1);
-  rb_define_private_method(mTox_cClient, "run_loop",        mTox_cClient_run_loop,        0);
 }
 
 /*************************************************************
@@ -154,84 +154,257 @@ void mTox_cClient_free(mTox_cClient_CDATA *const free_cdata)
  * Public methods
  *************************************************************/
 
+// Tox::Client#iteration_interval
+VALUE mTox_cClient_iteration_interval(const VALUE self)
+{
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  uint32_t iteration_interval_msec_data =
+    tox_iteration_interval(self_cdata->tox);
+
+  const double iteration_interval_sec_data =
+    ((double)iteration_interval_msec_data) * 0.001;
+
+  const VALUE iteration_interval_sec = DBL2NUM(iteration_interval_sec_data);
+
+  return iteration_interval_sec;
+}
+
+// Tox::Client#iterate
+VALUE mTox_cClient_iterate(const VALUE self)
+{
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  tox_iterate(self_cdata->tox, self);
+
+  return Qnil;
+}
+
+// Tox::Client#connection_status
+VALUE mTox_cClient_connection_status(const VALUE self)
+{
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  TOX_CONNECTION connection_status_data =
+    tox_self_get_connection_status(self_cdata->tox);
+
+  const VALUE connection_status =
+    mTox_mConnectionStatus_FROM_DATA(connection_status_data);
+
+  return connection_status;
+}
+
 // Tox::Client#public_key
 VALUE mTox_cClient_public_key(const VALUE self)
 {
-  mTox_cClient_CDATA *self_cdata;
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  char public_key_data[TOX_PUBLIC_KEY_SIZE];
 
-  char public_key[TOX_PUBLIC_KEY_SIZE];
+  tox_self_get_public_key(self_cdata->tox, public_key_data);
 
-  tox_self_get_public_key(self_cdata->tox, (uint8_t*)public_key);
+  const VALUE public_key_value =
+    rb_str_new(public_key_data, TOX_PUBLIC_KEY_SIZE);
 
-  return rb_funcall(
-    mTox_cPublicKey,
-    rb_intern("new"),
-    1,
-    rb_str_new(public_key, TOX_PUBLIC_KEY_SIZE)
-  );
+  const VALUE public_key = rb_funcall(mTox_cPublicKey, rb_intern("new"), 1,
+                                      public_key_value);
+
+  return public_key;
 }
 
 // Tox::Client#address
 VALUE mTox_cClient_address(const VALUE self)
 {
-  mTox_cClient_CDATA *self_cdata;
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  char address_data[TOX_ADDRESS_SIZE];
+
+  tox_self_get_address(self_cdata->tox, address_data);
+
+  const VALUE address_value = rb_str_new(address_data, TOX_ADDRESS_SIZE);
+
+  const VALUE address = rb_funcall(mTox_cAddress, rb_intern("new"), 1,
+                                   address_value);
+
+  return address;
+}
+
+// Tox::Client#nospam
+VALUE mTox_cClient_nospam(const VALUE self)
+{
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  uint32_t nospam_data = tox_self_get_nospam(self_cdata->tox);
+
+  const VALUE nospam_as_integer = LONG2FIX(nospam_data);
+
+  const VALUE nospam = rb_funcall(mTox_cNospam, rb_intern("new"), 1,
+                                  nospam_as_integer);
+
+  return nospam;
+}
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+// Tox::Client#nospam
+VALUE mTox_cClient_nospam_ASSIGN(const VALUE self, const VALUE nospam)
+{
+  if (!rb_funcall(nospam, rb_intern("is_a?"), 1, mTox_cNospam)) {
+    RAISE_TYPECHECK("Tox::Client#nospam=", "nospam", "Tox::Nospam");
+  }
 
-  char address[TOX_ADDRESS_SIZE];
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  tox_self_get_address(self_cdata->tox, (uint8_t*)address);
+  const VALUE nospam_as_integer = rb_funcall(nospam, rb_intern("to_i"), 0);
 
-  return rb_funcall(
-    mTox_cAddress,
-    rb_intern("new"),
-    1,
-    rb_str_new(address, TOX_ADDRESS_SIZE)
+  tox_self_set_nospam(
+    self_cdata->tox,
+    FIX2LONG(nospam_as_integer)
   );
+
+  return Qnil;
 }
 
 // Tox::Client#savedata
 VALUE mTox_cClient_savedata(const VALUE self)
 {
-  mTox_cClient_CDATA *self_cdata;
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  size_t data_size = tox_get_savedata_size(self_cdata->tox);
+  char *data = ALLOC_N(char, data_size);
+
+  tox_get_savedata(self_cdata->tox, data);
+
+  const VALUE savedata = rb_str_new(data, data_size);
+
+  return savedata;
+}
+
+// Tox::Client#udp_port
+VALUE mTox_cClient_udp_port(const VALUE self)
+{
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  TOX_ERR_GET_PORT error;
+
+  const uint16_t udp_port_data = tox_self_get_udp_port(self_cdata->tox, &error);
+
+  switch (error) {
+    case TOX_ERR_GET_PORT_OK:
+      break;
+    case TOX_ERR_GET_PORT_NOT_BOUND:
+      return Qnil;
+    default:
+      return Qnil;
+  }
+
+  const VALUE udp_port = LONG2FIX(udp_port_data);
+
+  return udp_port;
+}
+
+// Tox::Client#tcp_port
+VALUE mTox_cClient_tcp_port(const VALUE self)
+{
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  size_t data_size;
-  char *data;
+  TOX_ERR_GET_PORT error;
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  const uint16_t tcp_port_data = tox_self_get_tcp_port(self_cdata->tox, &error);
 
-  data_size = tox_get_savedata_size(self_cdata->tox);
-  data = ALLOC_N(char, data_size);
+  switch (error) {
+    case TOX_ERR_GET_PORT_OK:
+      break;
+    case TOX_ERR_GET_PORT_NOT_BOUND:
+      return Qnil;
+    default:
+      return Qnil;
+  }
 
-  tox_get_savedata(self_cdata->tox, (uint8_t*)data);
+  const VALUE tcp_port = LONG2FIX(tcp_port_data);
 
-  return rb_str_new(data, data_size);
+  return tcp_port;
 }
 
 // Tox::Client#bootstrap
-VALUE mTox_cClient_bootstrap(const VALUE self, const VALUE node)
+VALUE mTox_cClient_bootstrap(const VALUE self, const VALUE address, const VALUE port, const VALUE public_key)
+{
+  Check_Type(address, T_STRING);
+
+  if (!rb_funcall(public_key, rb_intern("is_a?"), 1, mTox_cPublicKey)) {
+    RAISE_TYPECHECK("Tox::Client#bootstrap", "public_key", "Tox::PublicKey");
+  }
+
+  StringValueCStr(address);
+
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  const VALUE public_key_value = rb_funcall(public_key, rb_intern("value"), 0);
+
+  const char *address_data = RSTRING_PTR(address);
+  const uint16_t port_data = NUM2USHORT(port);
+  const char *public_key_data = RSTRING_PTR(public_key_value);
+
+  TOX_ERR_BOOTSTRAP error;
+
+  const bool result = tox_bootstrap(
+    self_cdata->tox,
+    address_data,
+    port_data,
+    public_key_data,
+    &error
+  );
+
+  switch (error) {
+    case TOX_ERR_BOOTSTRAP_OK:
+      break;
+    case TOX_ERR_BOOTSTRAP_NULL:
+      return Qfalse;
+    case TOX_ERR_BOOTSTRAP_BAD_HOST:
+      return Qfalse;
+    case TOX_ERR_BOOTSTRAP_BAD_PORT:
+      return Qfalse;
+    default:
+      return Qfalse;
+  }
+
+  if (!result) {
+    return Qfalse;
+  }
+
+  return Qtrue;
+}
+
+// Tox::Client#add_tcp_relay
+VALUE mTox_cClient_add_tcp_relay(const VALUE self, const VALUE address, const VALUE port, const VALUE public_key)
 {
-  if (!rb_funcall(node, rb_intern("is_a?"), 1, mTox_cNode)) {
-    rb_raise(rb_eTypeError, "expected argument 1 to be a Tox::Node");
+  Check_Type(address, T_STRING);
+
+  if (!rb_funcall(public_key, rb_intern("is_a?"), 1, mTox_cPublicKey)) {
+    RAISE_TYPECHECK("Tox::Client#bootstrap", "public_key", "Tox::PublicKey");
   }
 
-  mTox_cClient_CDATA *self_cdata;
+  StringValueCStr(address);
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  const VALUE public_key_value = rb_funcall(public_key, rb_intern("value"), 0);
+
+  const char *address_data = RSTRING_PTR(address);
+  const uint16_t port_data = NUM2USHORT(port);
+  const char *public_key_data = RSTRING_PTR(public_key_value);
 
   TOX_ERR_BOOTSTRAP error;
 
-  tox_bootstrap(self_cdata->tox,
-                RSTRING_PTR(rb_funcall(node, rb_intern("resolv_ipv4"), 0)),
-                NUM2INT(rb_funcall(node, rb_intern("port"), 0)),
-                RSTRING_PTR(rb_funcall(node, rb_intern("public_key"), 0)),
-                &error);
+  const bool result = tox_add_tcp_relay(
+    self_cdata->tox,
+    address_data,
+    port_data,
+    public_key_data,
+    &error
+  );
 
   switch (error) {
     case TOX_ERR_BOOTSTRAP_OK:
-      return Qtrue;
+      break;
     case TOX_ERR_BOOTSTRAP_NULL:
       return Qfalse;
     case TOX_ERR_BOOTSTRAP_BAD_HOST:
@@ -241,40 +414,44 @@ VALUE mTox_cClient_bootstrap(const VALUE self, const VALUE node)
     default:
       return Qfalse;
   }
+
+  if (!result) {
+    return Qfalse;
+  }
+
+  return Qtrue;
 }
 
 // Tox::Client#name
 VALUE mTox_cClient_name(const VALUE self)
 {
-  mTox_cClient_CDATA *self_cdata;
-
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  const size_t name_size = tox_self_get_name_size(self_cdata->tox);
+  const size_t name_size_data = tox_self_get_name_size(self_cdata->tox);
 
-  char name[name_size];
+  char name_data[name_size_data];
 
-  if (name_size > 0) {
-    tox_self_get_name(self_cdata->tox, (uint8_t*)name);
+  if (name_size_data > 0) {
+    tox_self_get_name(self_cdata->tox, name_data);
   }
 
-  return rb_str_new(name, name_size);
+  const VALUE name = rb_str_new(name_data, name_size_data);
+
+  return name;
 }
 
 // Tox::Client#name=
-VALUE mTox_cClient_name_EQUALS(const VALUE self, const VALUE name)
+VALUE mTox_cClient_name_ASSIGN(const VALUE self, const VALUE name)
 {
   Check_Type(name, T_STRING);
 
-  mTox_cClient_CDATA *self_cdata;
-
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
   TOX_ERR_SET_INFO error;
 
   const bool result = tox_self_set_name(
     self_cdata->tox,
-    (uint8_t**)RSTRING_PTR(name),
+    RSTRING_PTR(name),
     RSTRING_LEN(name),
     &error
   );
@@ -283,15 +460,23 @@ VALUE mTox_cClient_name_EQUALS(const VALUE self, const VALUE name)
     case TOX_ERR_SET_INFO_OK:
       break;
     case TOX_ERR_SET_INFO_NULL:
-      rb_raise(mTox_eNullError, "tox_self_set_name() failed with TOX_ERR_SET_INFO_NULL");
+      RAISE_FUNC_ERROR(
+        "tox_self_set_name",
+        mTox_eNullError,
+        "TOX_ERR_SET_INFO_NULL"
+      );
     case TOX_ERR_SET_INFO_TOO_LONG:
-      rb_raise(rb_eRuntimeError, "tox_self_set_name() failed with TOX_ERR_SET_INFO_TOO_LONG");
+      RAISE_FUNC_ERROR(
+        "tox_self_set_name",
+        rb_eRuntimeError,
+        "TOX_ERR_SET_INFO_TOO_LONG"
+      );
     default:
-      rb_raise(mTox_eUnknownError, "tox_self_set_name() failed");
+      RAISE_FUNC_ERROR_DEFAULT("tox_self_set_name");
   }
 
   if (!result) {
-    rb_raise(mTox_eUnknownError, "tox_self_set_name() failed");
+    RAISE_FUNC_RESULT("tox_self_set_name");
   }
 
   return name;
@@ -300,43 +485,23 @@ VALUE mTox_cClient_name_EQUALS(const VALUE self, const VALUE name)
 // Tox::Client#status
 VALUE mTox_cClient_status(const VALUE self)
 {
-  mTox_cClient_CDATA *self_cdata;
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  const TOX_USER_STATUS status_data = tox_self_get_status(self_cdata->tox);
 
-  const TOX_USER_STATUS result = tox_self_get_status(self_cdata->tox);
+  const VALUE status = mTox_mUserStatus_FROM_DATA(status_data);
 
-  switch (result) {
-    case TOX_USER_STATUS_NONE:
-      return mTox_mUserStatus_NONE;
-    case TOX_USER_STATUS_AWAY:
-      return mTox_mUserStatus_AWAY;
-    case TOX_USER_STATUS_BUSY:
-      return mTox_mUserStatus_BUSY;
-    default:
-      rb_raise(rb_eNotImpError, "Tox::Client#status has unknown value");
-  }
+  return status;
 }
 
 // Tox::Client#status=
-VALUE mTox_cClient_status_EQUALS(const VALUE self, const VALUE status)
+VALUE mTox_cClient_status_ASSIGN(const VALUE self, const VALUE status)
 {
-  mTox_cClient_CDATA *self_cdata;
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  const TOX_USER_STATUS status_data = mTox_mUserStatus_TO_DATA(status);
 
-  if (rb_funcall(mTox_mUserStatus_NONE, rb_intern("=="), 1, status)) {
-    tox_self_set_status(self_cdata->tox, TOX_USER_STATUS_NONE);
-  }
-  else if (rb_funcall(mTox_mUserStatus_AWAY, rb_intern("=="), 1, status)) {
-    tox_self_set_status(self_cdata->tox, TOX_USER_STATUS_AWAY);
-  }
-  else if (rb_funcall(mTox_mUserStatus_BUSY, rb_intern("=="), 1, status)) {
-    tox_self_set_status(self_cdata->tox, TOX_USER_STATUS_BUSY);
-  }
-  else {
-    rb_raise(rb_eArgError, "invalid value for Tox::Client#status=");
-  }
+  tox_self_set_status(self_cdata->tox, status_data);
 
   return status;
 }
@@ -344,35 +509,35 @@ VALUE mTox_cClient_status_EQUALS(const VALUE self, const VALUE status)
 // Tox::Client#status_message
 VALUE mTox_cClient_status_message(const VALUE self)
 {
-  mTox_cClient_CDATA *self_cdata;
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  const size_t status_message_size_data =
+    tox_self_get_status_message_size(self_cdata->tox);
 
-  const size_t status_message_size = tox_self_get_status_message_size(self_cdata->tox);
+  char status_message_data[status_message_size_data];
 
-  char status_message[status_message_size];
-
-  if (status_message_size > 0) {
-    tox_self_get_status_message(self_cdata->tox, (uint8_t*)status_message);
+  if (status_message_size_data > 0) {
+    tox_self_get_status_message(self_cdata->tox, status_message_data);
   }
 
-  return rb_str_new(status_message, status_message_size);
+  const VALUE status_message =
+    rb_str_new(status_message_data, status_message_size_data);
+
+  return status_message;
 }
 
 // Tox::Client#status_message=
-VALUE mTox_cClient_status_message_EQUALS(const VALUE self, const VALUE status_message)
+VALUE mTox_cClient_status_message_ASSIGN(const VALUE self, const VALUE status_message)
 {
   Check_Type(status_message, T_STRING);
 
-  mTox_cClient_CDATA *self_cdata;
-
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
   TOX_ERR_SET_INFO error;
 
   const bool result = tox_self_set_status_message(
     self_cdata->tox,
-    (uint8_t**)RSTRING_PTR(status_message),
+    RSTRING_PTR(status_message),
     RSTRING_LEN(status_message),
     &error
   );
@@ -381,15 +546,23 @@ VALUE mTox_cClient_status_message_EQUALS(const VALUE self, const VALUE status_me
     case TOX_ERR_SET_INFO_OK:
       break;
     case TOX_ERR_SET_INFO_NULL:
-      rb_raise(mTox_eNullError, "tox_self_set_status_message() failed with TOX_ERR_SET_INFO_NULL");
+      RAISE_FUNC_ERROR(
+        "tox_self_set_status_message",
+        mTox_eNullError,
+        "TOX_ERR_SET_INFO_NULL"
+      );
     case TOX_ERR_SET_INFO_TOO_LONG:
-      rb_raise(rb_eRuntimeError, "tox_self_set_status_message() failed with TOX_ERR_SET_INFO_TOO_LONG");
+      RAISE_FUNC_ERROR(
+        "tox_self_set_status_message",
+        rb_eRuntimeError,
+        "TOX_ERR_SET_INFO_TOO_LONG"
+      );
     default:
-      rb_raise(mTox_eUnknownError, "tox_self_set_status_message() failed");
+      RAISE_FUNC_ERROR_DEFAULT("tox_self_set_status_message");
   }
 
   if (!result) {
-    rb_raise(mTox_eUnknownError, "tox_self_set_status_message() failed");
+    RAISE_FUNC_RESULT("tox_self_set_status_message");
   }
 
   return status_message;
@@ -398,14 +571,13 @@ VALUE mTox_cClient_status_message_EQUALS(const VALUE self, const VALUE status_me
 // Tox::Client#friend_numbers
 VALUE mTox_cClient_friend_numbers(const VALUE self)
 {
-  mTox_cClient_CDATA *self_cdata;
-
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
   const size_t friend_numbers_size = tox_self_get_friend_list_size(self_cdata->tox);
 
   if (friend_numbers_size == 0) {
-    return rb_ary_new();
+    const VALUE friends = rb_ary_new();
+    return friends;
   }
 
   uint32_t friend_numbers[friend_numbers_size];
@@ -418,30 +590,159 @@ VALUE mTox_cClient_friend_numbers(const VALUE self)
     friend_number_values[i] = LONG2NUM(friend_numbers[i]);
   }
 
-  return rb_ary_new4(friend_numbers_size, friend_number_values);
+  const VALUE friends = rb_ary_new4(friend_numbers_size, friend_number_values);
+
+  return friends;
 }
 
 // Tox::Client#friend_add_norequest
 VALUE mTox_cClient_friend_add_norequest(const VALUE self, const VALUE public_key)
 {
-  Check_Type(public_key, T_STRING);
+  if (!rb_funcall(public_key, rb_intern("is_a?"), 1, mTox_cPublicKey)) {
+    RAISE_TYPECHECK("Tox::Client#friend_add_norequest", "public_key", "Tox::PublicKey");
+  }
+
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
 
-  mTox_cClient_CDATA *self_cdata;
+  const VALUE public_key_value = rb_funcall(public_key, rb_intern("value"), 0);
 
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+  TOX_ERR_FRIEND_ADD error;
 
   const VALUE friend_number = LONG2FIX(tox_friend_add_norequest(
     self_cdata->tox,
-    (uint8_t*)RSTRING_PTR(public_key),
-    NULL
+    RSTRING_PTR(public_key_value),
+    &error
   ));
 
-  return rb_funcall(
-    self,
-    rb_intern("friend"),
-    1,
-    friend_number
-  );
+  switch (error) {
+    case TOX_ERR_FRIEND_ADD_OK:
+      break;
+    case TOX_ERR_FRIEND_ADD_NULL:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add_norequest",
+        mTox_eNullError,
+        "TOX_ERR_FRIEND_ADD_NULL"
+      );
+    case TOX_ERR_FRIEND_ADD_OWN_KEY:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add_norequest",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_OWN_KEY"
+      );
+    case TOX_ERR_FRIEND_ADD_ALREADY_SENT:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add_norequest",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_ALREADY_SENT"
+      );
+    case TOX_ERR_FRIEND_ADD_BAD_CHECKSUM:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add_norequest",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_BAD_CHECKSUM"
+      );
+    case TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add_norequest",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM"
+      );
+    case TOX_ERR_FRIEND_ADD_MALLOC:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add_norequest",
+        rb_eNoMemError,
+        "TOX_ERR_FRIEND_ADD_MALLOC"
+      );
+    default:
+      RAISE_FUNC_ERROR_DEFAULT("tox_friend_add_norequest");
+  }
+
+  const VALUE friend = rb_funcall(self, rb_intern("friend"), 1,
+                                  friend_number);
+
+  return friend;
+}
+
+// Tox::Client#friend_add
+VALUE mTox_cClient_friend_add(const VALUE self, const VALUE address, const VALUE text)
+{
+  if (!rb_funcall(address, rb_intern("is_a?"), 1, mTox_cAddress)) {
+    RAISE_TYPECHECK("Tox::Client#friend_add", "address", "Tox::Address");
+  }
+
+  Check_Type(text, T_STRING);
+
+  CDATA(self, mTox_cClient_CDATA, self_cdata);
+
+  TOX_ERR_FRIEND_ADD error;
+
+  const VALUE address_value = rb_funcall(address, rb_intern("value"), 0);
+
+  const VALUE friend_number = LONG2FIX(tox_friend_add(
+    self_cdata->tox,
+    RSTRING_PTR(address_value),
+    RSTRING_PTR(text),
+    RSTRING_LEN(text),
+    &error
+  ));
+
+  switch (error) {
+    case TOX_ERR_FRIEND_ADD_OK:
+      break;
+    case TOX_ERR_FRIEND_ADD_NULL:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        mTox_eNullError,
+        "TOX_ERR_FRIEND_ADD_NULL"
+      );
+    case TOX_ERR_FRIEND_ADD_NO_MESSAGE:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        mTox_eNullError,
+        "TOX_ERR_FRIEND_ADD_NO_MESSAGE"
+      );
+    case TOX_ERR_FRIEND_ADD_TOO_LONG:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        mTox_eNullError,
+        "TOX_ERR_FRIEND_ADD_TOO_LONG"
+      );
+    case TOX_ERR_FRIEND_ADD_OWN_KEY:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_OWN_KEY"
+      );
+    case TOX_ERR_FRIEND_ADD_ALREADY_SENT:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_ALREADY_SENT"
+      );
+    case TOX_ERR_FRIEND_ADD_BAD_CHECKSUM:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_BAD_CHECKSUM"
+      );
+    case TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        rb_eRuntimeError,
+        "TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM"
+      );
+    case TOX_ERR_FRIEND_ADD_MALLOC:
+      RAISE_FUNC_ERROR(
+        "tox_friend_add",
+        rb_eNoMemError,
+        "TOX_ERR_FRIEND_ADD_MALLOC"
+      );
+  }
+
+  const VALUE friend = rb_funcall(self, rb_intern("friend"), 1,
+                                  friend_number);
+
+  return friend;
 }
 
 /*************************************************************
@@ -451,43 +752,80 @@ VALUE mTox_cClient_friend_add_norequest(const VALUE self, const VALUE public_key
 // Tox::Client#initialize_with
 VALUE mTox_cClient_initialize_with(const VALUE self, const VALUE options)
 {
-  mTox_cClient_CDATA  *self_cdata;
-  mTox_cOptions_CDATA *options_cdata;
-
   if (!rb_funcall(options, rb_intern("is_a?"), 1, mTox_cOptions)) {
-    rb_raise(rb_eTypeError, "expected options to be a Tox::Options");
+    RAISE_TYPECHECK("Tox::Client#initialize_with", "options", "Tox::Options");
   }
 
-  Data_Get_Struct(self,    mTox_cClient_CDATA,  self_cdata);
-  Data_Get_Struct(options, mTox_cOptions_CDATA, options_cdata);
+  CDATA(self,    mTox_cClient_CDATA,  self_cdata);
+  CDATA(options, mTox_cOptions_CDATA, options_cdata);
 
   TOX_ERR_NEW error;
 
-  self_cdata->tox = tox_new(options_cdata, &error);
+  self_cdata->tox = tox_new(options_cdata->tox_options, &error);
 
   switch (error) {
     case TOX_ERR_NEW_OK:
       break;
     case TOX_ERR_NEW_NULL:
-      rb_raise(mTox_eNullError, "tox_new() failed with TOX_ERR_NEW_NULL");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        mTox_eNullError,
+        "TOX_ERR_NEW_NULL"
+      );
     case TOX_ERR_NEW_MALLOC:
-      rb_raise(rb_eNoMemError, "tox_new() failed with TOX_ERR_NEW_MALLOC");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        rb_eNoMemError,
+        "TOX_ERR_NEW_MALLOC"
+      );
     case TOX_ERR_NEW_PORT_ALLOC:
-      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PORT_ALLOC");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        rb_eRuntimeError,
+        "TOX_ERR_NEW_PORT_ALLOC"
+      );
     case TOX_ERR_NEW_PROXY_BAD_TYPE:
-      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_BAD_TYPE");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        rb_eRuntimeError,
+        "TOX_ERR_NEW_PROXY_BAD_TYPE"
+      );
     case TOX_ERR_NEW_PROXY_BAD_HOST:
-      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_BAD_HOST");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        rb_eRuntimeError,
+        "TOX_ERR_NEW_PROXY_BAD_HOST"
+      );
     case TOX_ERR_NEW_PROXY_BAD_PORT:
-      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_BAD_PORT");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        rb_eRuntimeError,
+        "TOX_ERR_NEW_PROXY_BAD_PORT"
+      );
     case TOX_ERR_NEW_PROXY_NOT_FOUND:
-      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_NOT_FOUND");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        rb_eRuntimeError,
+        "TOX_ERR_NEW_PROXY_NOT_FOUND"
+      );
     case TOX_ERR_NEW_LOAD_ENCRYPTED:
-      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_LOAD_ENCRYPTED");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        rb_eRuntimeError,
+        "TOX_ERR_NEW_LOAD_ENCRYPTED"
+      );
     case TOX_ERR_NEW_LOAD_BAD_FORMAT:
-      rb_raise(mTox_cClient_eBadSavedataError, "tox_new() failed with TOX_ERR_NEW_LOAD_BAD_FORMAT");
+      RAISE_FUNC_ERROR(
+        "tox_new",
+        mTox_cClient_eBadSavedataError,
+        "TOX_ERR_NEW_LOAD_BAD_FORMAT"
+      );
     default:
-      rb_raise(mTox_eUnknownError, "tox_new() failed");
+      RAISE_FUNC_ERROR_DEFAULT("tox_new");
+  }
+
+  if (!self_cdata->tox) {
+    RAISE_FUNC_RESULT("tox_new");
   }
 
   tox_callback_friend_request       (self_cdata->tox, on_friend_request);
@@ -499,42 +837,15 @@ VALUE mTox_cClient_initialize_with(const VALUE self, const VALUE options)
   return self;
 }
 
-// Tox::Client#run_loop
-VALUE mTox_cClient_run_loop(const VALUE self)
-{
-  mTox_cClient_CDATA *self_cdata;
-
-  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
-
-  struct timespec delay;
-
-  delay.tv_sec = 0;
-
-  const VALUE ivar_on_iteration = rb_iv_get(self, "@on_iteration");
-
-  while (rb_funcall(self, rb_intern("running?"), 0)) {
-    delay.tv_nsec = tox_iteration_interval(self_cdata->tox) * 1000000;
-    nanosleep(&delay, NULL);
-
-    tox_iterate(self_cdata->tox, self);
-
-    if (Qnil != ivar_on_iteration) {
-      rb_funcall(ivar_on_iteration, rb_intern("call"), 0);
-    }
-  }
-
-  return self;
-}
-
 /*************************************************************
  * Callbacks
  *************************************************************/
 
 void on_friend_request(
   Tox *const tox,
-  const uint8_t *const public_key,
-  const uint8_t *const data,
-  const size_t length,
+  const uint8_t *const public_key_data,
+  const uint8_t *const text_data,
+  const size_t text_length_data,
   const VALUE self
 )
 {
@@ -544,26 +855,25 @@ void on_friend_request(
     return;
   }
 
-  rb_funcall(
-    ivar_on_friend_request,
-    rb_intern("call"),
-    2,
-    rb_funcall(
-      mTox_cPublicKey,
-      rb_intern("new"),
-      1,
-      rb_str_new(public_key, TOX_PUBLIC_KEY_SIZE)
-    ),
-    rb_str_new((char*)data, length)
-  );
+  const VALUE public_key_value =
+    rb_str_new(public_key_data, TOX_PUBLIC_KEY_SIZE);
+
+  const VALUE public_key = rb_funcall(mTox_cPublicKey, rb_intern("new"), 1,
+                                      public_key_value);
+
+  const VALUE text = rb_str_new(text_data, text_length_data);
+
+  rb_funcall(ivar_on_friend_request, rb_intern("call"), 2,
+             public_key,
+             text);
 }
 
 void on_friend_message(
   Tox *const tox,
-  const uint32_t friend_number,
+  const uint32_t friend_number_data,
   const TOX_MESSAGE_TYPE type,
-  const uint8_t *const text,
-  const size_t length,
+  const uint8_t *const text_data,
+  const size_t text_length_data,
   const VALUE self
 )
 {
@@ -573,119 +883,103 @@ void on_friend_message(
     return;
   }
 
-  rb_funcall(
-    ivar_on_friend_message,
-    rb_intern("call"),
-    2,
-    rb_funcall(
-      mTox_cFriend,
-      rb_intern("new"),
-      2,
-      self,
-      LONG2FIX(friend_number)
-    ),
-    rb_str_new((char*)text, length)
-  );
+  const VALUE friend_number = LONG2FIX(friend_number_data);
+
+  const VALUE friend = rb_funcall(mTox_cFriend, rb_intern("new"), 2,
+                                  self,
+                                  friend_number);
+
+  const VALUE text = rb_str_new(text_data, text_length_data);
+
+  rb_funcall(ivar_on_friend_message, rb_intern("call"), 2,
+             friend,
+             text);
 }
 
 void on_friend_name_change(
   Tox *const tox,
-  const uint32_t friend_number,
-  const uint8_t *const name,
-  const size_t length,
+  const uint32_t friend_number_data,
+  const uint8_t *const name_data,
+  const size_t name_length_data,
   const VALUE self
 )
 {
-  const VALUE ivar_on_friend_name_change = rb_iv_get(self, "@on_friend_name_change");
+  const VALUE ivar_on_friend_name_change =
+    rb_iv_get(self, "@on_friend_name_change");
 
   if (Qnil == ivar_on_friend_name_change) {
     return;
   }
 
-  rb_funcall(
-    ivar_on_friend_name_change,
-    rb_intern("call"),
-    2,
-    rb_funcall(
-      mTox_cFriend,
-      rb_intern("new"),
-      2,
-      self,
-      LONG2FIX(friend_number)
-    ),
-    rb_str_new(name, length)
-  );
+  const VALUE friend_number = LONG2FIX(friend_number_data);
+
+  const VALUE friend = rb_funcall(mTox_cFriend, rb_intern("new"), 2,
+                                  self,
+                                  friend_number);
+
+  const VALUE name = rb_str_new(name_data, name_length_data);
+
+  rb_funcall(ivar_on_friend_name_change, rb_intern("call"), 2,
+             friend,
+             name);
 }
 
 void on_friend_status_message_change(
   Tox *const tox,
-  const uint32_t friend_number,
-  const uint8_t *const status_message,
-  size_t length,
+  const uint32_t friend_number_data,
+  const uint8_t *const status_message_data,
+  size_t status_message_length_data,
   const VALUE self
 )
 {
-  const VALUE ivar_on_friend_status_message_change = rb_iv_get(self, "@on_friend_status_message_change");
+  const VALUE ivar_on_friend_status_message_change =
+    rb_iv_get(self, "@on_friend_status_message_change");
 
   if (Qnil == ivar_on_friend_status_message_change) {
     return;
   }
 
-  rb_funcall(
-    ivar_on_friend_status_message_change,
-    rb_intern("call"),
-    2,
-    rb_funcall(
-      mTox_cFriend,
-      rb_intern("new"),
-      2,
-      self,
-      LONG2FIX(friend_number)
-    ),
-    rb_str_new(status_message, length)
-  );
+  const VALUE friend_number = LONG2FIX(friend_number_data);
+
+  const VALUE friend = rb_funcall(mTox_cFriend, rb_intern("new"), 2,
+                                  self,
+                                  friend_number);
+
+  const VALUE status_message =
+    rb_str_new(status_message_data, status_message_length_data);
+
+  rb_funcall(ivar_on_friend_status_message_change, rb_intern("call"), 2,
+             friend,
+             status_message);
 }
 
 void on_friend_status_change(
   Tox *const tox,
-  const uint32_t friend_number,
-  const TOX_USER_STATUS status,
+  const uint32_t friend_number_data,
+  const TOX_USER_STATUS status_data,
   const VALUE self
 )
 {
-  const VALUE ivar_on_friend_status_change = rb_iv_get(self, "@on_friend_status_change");
+  const VALUE ivar_on_friend_status_change =
+    rb_iv_get(self, "@on_friend_status_change");
 
   if (Qnil == ivar_on_friend_status_change) {
     return;
   }
 
-  VALUE status_value;
+  const VALUE status = mTox_mUserStatus_TRY_DATA(status_data);
 
-  switch (status) {
-    case TOX_USER_STATUS_NONE:
-      status_value = mTox_mUserStatus_NONE;
-      break;
-    case TOX_USER_STATUS_AWAY:
-      status_value = mTox_mUserStatus_AWAY;
-      break;
-    case TOX_USER_STATUS_BUSY:
-      status_value = mTox_mUserStatus_BUSY;
-      break;
-    default:
-      return;
+  if (status == Qnil) {
+    return;
   }
 
-  rb_funcall(
-    ivar_on_friend_status_change,
-    rb_intern("call"),
-    2,
-    rb_funcall(
-      mTox_cFriend,
-      rb_intern("new"),
-      2,
-      self,
-      LONG2FIX(friend_number)
-    ),
-    status_value
-  );
+  const VALUE friend_number = LONG2FIX(friend_number_data);
+
+  const VALUE friend = rb_funcall(mTox_cFriend, rb_intern("new"), 2,
+                                  self,
+                                  friend_number);
+
+  rb_funcall(ivar_on_friend_status_change, rb_intern("call"), 2,
+             friend,
+             status);
 }