tox 0.0.2 → 0.0.3

data/ext/tox/tox.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"
 
 #if !(TOX_VERSION_IS_API_COMPATIBLE(0, 2, 1))
@@ -28,27 +10,37 @@ VALUE mTox;
 
 VALUE mTox_eNullError;
 VALUE mTox_eUnknownError;
-VALUE mTox_eUnknownSecurityError;
 
 VALUE mTox_mVersion;
 VALUE mTox_mUserStatus;
+VALUE mTox_mConnectionStatus;
+VALUE mTox_mProxyType;
 VALUE mTox_cOptions;
 VALUE mTox_cClient;
 VALUE mTox_cNode;
 VALUE mTox_cFriend;
 VALUE mTox_cAddress;
+VALUE mTox_cNospam;
 VALUE mTox_cPublicKey;
 VALUE mTox_mOutMessage;
+VALUE mTox_cOutFriendMessage;
 
 VALUE mTox_mUserStatus_NONE;
 VALUE mTox_mUserStatus_AWAY;
 VALUE mTox_mUserStatus_BUSY;
 
+VALUE mTox_mProxyType_NONE;
+VALUE mTox_mProxyType_HTTP;
+VALUE mTox_mProxyType_SOCKS5;
+
+VALUE mTox_mConnectionStatus_NONE;
+VALUE mTox_mConnectionStatus_TCP;
+VALUE mTox_mConnectionStatus_UDP;
+
 VALUE mTox_cClient_eBadSavedataError;
 
 VALUE mTox_cFriend_eNotFoundError;
 VALUE mTox_cFriend_eNotConnectedError;
-VALUE mTox_cFriend_cOutMessage;
 
 VALUE mTox_mOutMessage_eSendQueueAllocError;
 VALUE mTox_mOutMessage_eTooLongError;
@@ -72,29 +64,39 @@ void Init_tox()
 
   mTox = rb_const_get(rb_cObject, rb_intern("Tox"));
 
-  mTox_eNullError            = rb_const_get(mTox, rb_intern("NullError"));
-  mTox_eUnknownError         = rb_const_get(mTox, rb_intern("UnknownError"));
-  mTox_eUnknownSecurityError = rb_const_get(mTox, rb_intern("UnknownSecurityError"));
-
-  mTox_mVersion    = rb_const_get(mTox, rb_intern("Version"));
-  mTox_mUserStatus = rb_const_get(mTox, rb_intern("UserStatus"));
-  mTox_cOptions    = rb_const_get(mTox, rb_intern("Options"));
-  mTox_cClient     = rb_const_get(mTox, rb_intern("Client"));
-  mTox_cNode       = rb_const_get(mTox, rb_intern("Node"));
-  mTox_cFriend     = rb_const_get(mTox, rb_intern("Friend"));
-  mTox_cAddress    = rb_const_get(mTox, rb_intern("Address"));
-  mTox_cPublicKey  = rb_const_get(mTox, rb_intern("PublicKey"));
-  mTox_mOutMessage = rb_const_get(mTox, rb_intern("OutMessage"));
+  mTox_eNullError    = rb_const_get(mTox, rb_intern("NullError"));
+  mTox_eUnknownError = rb_const_get(mTox, rb_intern("UnknownError"));
+
+  mTox_mVersion          = rb_const_get(mTox, rb_intern("Version"));
+  mTox_mUserStatus       = rb_const_get(mTox, rb_intern("UserStatus"));
+  mTox_mConnectionStatus = rb_const_get(mTox, rb_intern("ConnectionStatus"));
+  mTox_mProxyType        = rb_const_get(mTox, rb_intern("ProxyType"));
+  mTox_cOptions          = rb_const_get(mTox, rb_intern("Options"));
+  mTox_cClient           = rb_const_get(mTox, rb_intern("Client"));
+  mTox_cNode             = rb_const_get(mTox, rb_intern("Node"));
+  mTox_cFriend           = rb_const_get(mTox, rb_intern("Friend"));
+  mTox_cAddress          = rb_const_get(mTox, rb_intern("Address"));
+  mTox_cNospam           = rb_const_get(mTox, rb_intern("Nospam"));
+  mTox_cPublicKey        = rb_const_get(mTox, rb_intern("PublicKey"));
+  mTox_mOutMessage       = rb_const_get(mTox, rb_intern("OutMessage"));
+  mTox_cOutFriendMessage = rb_const_get(mTox, rb_intern("OutFriendMessage"));
 
   mTox_mUserStatus_NONE = rb_const_get(mTox_mUserStatus, rb_intern("NONE"));
   mTox_mUserStatus_AWAY = rb_const_get(mTox_mUserStatus, rb_intern("AWAY"));
   mTox_mUserStatus_BUSY = rb_const_get(mTox_mUserStatus, rb_intern("BUSY"));
 
+  mTox_mProxyType_NONE   = rb_const_get(mTox_mProxyType, rb_intern("NONE"));
+  mTox_mProxyType_HTTP   = rb_const_get(mTox_mProxyType, rb_intern("HTTP"));
+  mTox_mProxyType_SOCKS5 = rb_const_get(mTox_mProxyType, rb_intern("SOCKS5"));
+
+  mTox_mConnectionStatus_NONE = rb_const_get(mTox_mConnectionStatus, rb_intern("NONE"));
+  mTox_mConnectionStatus_TCP  = rb_const_get(mTox_mConnectionStatus, rb_intern("TCP"));
+  mTox_mConnectionStatus_UDP  = rb_const_get(mTox_mConnectionStatus, rb_intern("UDP"));
+
   mTox_cClient_eBadSavedataError = rb_const_get(mTox_cClient, rb_intern("BadSavedataError"));
 
   mTox_cFriend_eNotFoundError     = rb_const_get(mTox_cFriend, rb_intern("NotFoundError"));
   mTox_cFriend_eNotConnectedError = rb_const_get(mTox_cFriend, rb_intern("NotConnectedError"));
-  mTox_cFriend_cOutMessage        = rb_const_get(mTox_cFriend, rb_intern("OutMessage"));
 
   mTox_mOutMessage_eSendQueueAllocError = rb_const_get(mTox_mOutMessage, rb_intern("SendQueueAllocError"));
   mTox_mOutMessage_eTooLongError        = rb_const_get(mTox_mOutMessage, rb_intern("TooLongError"));
@@ -121,9 +123,11 @@ VALUE mTox_hash(const VALUE self, const VALUE data)
 
   const uint8_t result[TOX_HASH_LENGTH];
 
-  if (true != tox_hash(result, (const uint8_t*)RSTRING_PTR(data), RSTRING_LEN(data))) {
-    rb_raise(mTox_eUnknownSecurityError, "tox_hash() failed");
+  if (true != tox_hash(result, RSTRING_PTR(data), RSTRING_LEN(data))) {
+    RAISE_FUNC_RESULT("tox_hash");
   }
 
-  return rb_str_new(result, TOX_HASH_LENGTH);
+  const VALUE hash = rb_str_new(result, TOX_HASH_LENGTH);
+
+  return hash;
 }

data/ext/tox/tox.h

@@ -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 <ruby.h>
 
 #include <tox/tox.h>
@@ -30,7 +12,12 @@ void mTox_cFriend_INIT();
 
 // C data
 
-typedef struct Tox_Options mTox_cOptions_CDATA;
+#define mTox_cOptions_CDATA_PROXY_HOST_BUFFER_SIZE 256
+
+typedef struct {
+  struct Tox_Options *tox_options;
+  char proxy_host[mTox_cOptions_CDATA_PROXY_HOST_BUFFER_SIZE];
+} mTox_cOptions_CDATA;
 
 typedef struct {
   Tox *tox;
@@ -42,28 +29,221 @@ extern VALUE mTox;
 
 extern VALUE mTox_eNullError;
 extern VALUE mTox_eUnknownError;
-extern VALUE mTox_eUnknownSecurityError;
 
 extern VALUE mTox_mVersion;
 extern VALUE mTox_mUserStatus;
+extern VALUE mTox_mConnectionStatus;
+extern VALUE mTox_mProxyType;
 extern VALUE mTox_cOptions;
 extern VALUE mTox_cClient;
 extern VALUE mTox_cNode;
 extern VALUE mTox_cFriend;
 extern VALUE mTox_cAddress;
 extern VALUE mTox_cPublicKey;
+extern VALUE mTox_cNospam;
 extern VALUE mTox_mOutMessage;
+extern VALUE mTox_cOutFriendMessage;
 
 extern VALUE mTox_mUserStatus_NONE;
 extern VALUE mTox_mUserStatus_AWAY;
 extern VALUE mTox_mUserStatus_BUSY;
 
+extern VALUE mTox_mProxyType_NONE;
+extern VALUE mTox_mProxyType_HTTP;
+extern VALUE mTox_mProxyType_SOCKS5;
+
+extern VALUE mTox_mConnectionStatus_NONE;
+extern VALUE mTox_mConnectionStatus_TCP;
+extern VALUE mTox_mConnectionStatus_UDP;
+
 extern VALUE mTox_cClient_eBadSavedataError;
 
 extern VALUE mTox_cFriend_eNotFoundError;
 extern VALUE mTox_cFriend_eNotConnectedError;
-extern VALUE mTox_cFriend_cOutMessage;
 
 extern VALUE mTox_mOutMessage_eSendQueueAllocError;
 extern VALUE mTox_mOutMessage_eTooLongError;
 extern VALUE mTox_mOutMessage_eEmptyError;
+
+// Inline functions
+
+static inline VALUE           mTox_mUserStatus_FROM_DATA(TOX_USER_STATUS data);
+static inline VALUE           mTox_mUserStatus_TRY_DATA(TOX_USER_STATUS data);
+static inline TOX_USER_STATUS mTox_mUserStatus_TO_DATA(VALUE value);
+
+static inline VALUE          mTox_mProxyType_FROM_DATA(TOX_PROXY_TYPE data);
+static inline VALUE          mTox_mProxyType_TRY_DATA(TOX_PROXY_TYPE data);
+static inline TOX_PROXY_TYPE mTox_mProxyType_TO_DATA(VALUE value);
+
+static inline VALUE          mTox_mConnectionStatus_FROM_DATA(TOX_CONNECTION data);
+static inline VALUE          mTox_mConnectionStatus_TRY_DATA(TOX_CONNECTION data);
+static inline TOX_CONNECTION mTox_mConnectionStatus_TO_DATA(VALUE value);
+
+// Macros
+
+#define CDATA(value, cdata_type, cdata)          \
+  cdata_type *(cdata);                           \
+  Data_Get_Struct((value), cdata_type, (cdata));
+
+#define RAISE_TYPECHECK(method_name, arg_name, expected_type) \
+  rb_raise(                                                   \
+    rb_eTypeError,                                            \
+    "Expected method "method_name                             \
+      " argument \""arg_name                                  \
+      "\" to be a "expected_type                              \
+  )
+
+#define RAISE_ENUM(enum_name)      \
+  rb_raise(                        \
+    rb_eNotImpError,               \
+    enum_name" has unknown value"  \
+  )
+
+#define RAISE_OPTION(enum_module)    \
+  rb_raise(                          \
+    rb_eArgError,                    \
+    "Invalid value from "enum_module \
+  )
+
+#define RAISE_FUNC_RESULT(func_name) \
+  rb_raise(                          \
+    mTox_eUnknownError,              \
+    func_name"() failed"             \
+  )
+
+#define RAISE_FUNC_ERROR_DEFAULT(func_name) \
+  rb_raise(                                 \
+    mTox_eUnknownError,                     \
+    func_name"() failed"                    \
+  )
+
+#define RAISE_FUNC_ERROR(func_name, exception_class, error) \
+  rb_raise(                                                 \
+    exception_class,                                        \
+    func_name"() failed with "error                         \
+  )
+
+// Inline function implementations
+
+VALUE mTox_mUserStatus_FROM_DATA(const TOX_USER_STATUS data)
+{
+  const VALUE result = mTox_mUserStatus_TRY_DATA(data);
+
+  if (result == Qnil) {
+    RAISE_ENUM("TOX_USER_STATUS");
+  }
+
+  return result;
+}
+
+VALUE mTox_mUserStatus_TRY_DATA(const TOX_USER_STATUS data)
+{
+  switch (data) {
+    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:
+      return Qnil;
+  }
+}
+
+TOX_USER_STATUS mTox_mUserStatus_TO_DATA(const VALUE value)
+{
+  if (rb_funcall(mTox_mUserStatus_NONE, rb_intern("=="), 1, value)) {
+    return TOX_USER_STATUS_NONE;
+  }
+  else if (rb_funcall(mTox_mUserStatus_AWAY, rb_intern("=="), 1, value)) {
+    return TOX_USER_STATUS_AWAY;
+  }
+  else if (rb_funcall(mTox_mUserStatus_BUSY, rb_intern("=="), 1, value)) {
+    return TOX_USER_STATUS_BUSY;
+  }
+  else {
+    RAISE_OPTION("Tox::UserStatus");
+  }
+}
+
+VALUE mTox_mProxyType_FROM_DATA(const TOX_PROXY_TYPE data)
+{
+  const VALUE result = mTox_mProxyType_TRY_DATA(data);
+
+  if (result == Qnil) {
+    RAISE_ENUM("TOX_PROXY_TYPE");
+  }
+
+  return result;
+}
+
+VALUE mTox_mProxyType_TRY_DATA(const TOX_PROXY_TYPE data)
+{
+  switch (data) {
+    case TOX_PROXY_TYPE_NONE:
+      return mTox_mProxyType_NONE;
+    case TOX_PROXY_TYPE_HTTP:
+      return mTox_mProxyType_HTTP;
+    case TOX_PROXY_TYPE_SOCKS5:
+      return mTox_mProxyType_SOCKS5;
+    default:
+      return Qnil;
+  }
+}
+
+TOX_PROXY_TYPE mTox_mProxyType_TO_DATA(const VALUE value)
+{
+  if (value == mTox_mProxyType_NONE) {
+    return TOX_PROXY_TYPE_NONE;
+  }
+  else if (value == mTox_mProxyType_HTTP) {
+    return TOX_PROXY_TYPE_HTTP;
+  }
+  else if (value == mTox_mProxyType_SOCKS5) {
+    return TOX_PROXY_TYPE_SOCKS5;
+  }
+  else {
+    RAISE_OPTION("Tox::ProxyType");
+  }
+}
+
+VALUE mTox_mConnectionStatus_FROM_DATA(const TOX_CONNECTION data)
+{
+  const VALUE result = mTox_mConnectionStatus_TRY_DATA(data);
+
+  if (result == Qnil) {
+    RAISE_ENUM("TOX_CONNECTION");
+  }
+
+  return result;
+}
+
+VALUE mTox_mConnectionStatus_TRY_DATA(const TOX_CONNECTION data)
+{
+  switch (data) {
+    case TOX_CONNECTION_NONE:
+      return mTox_mConnectionStatus_NONE;
+    case TOX_CONNECTION_TCP:
+      return mTox_mConnectionStatus_TCP;
+    case TOX_CONNECTION_UDP:
+      return mTox_mConnectionStatus_UDP;
+    default:
+      return Qnil;
+  }
+}
+
+TOX_CONNECTION mTox_mConnectionStatus_TO_DATA(const VALUE value)
+{
+  if (value == mTox_mConnectionStatus_NONE) {
+    return TOX_CONNECTION_NONE;
+  }
+  else if (value == mTox_mConnectionStatus_TCP) {
+    return TOX_CONNECTION_TCP;
+  }
+  else if (value == mTox_mConnectionStatus_UDP) {
+    return TOX_CONNECTION_UDP;
+  }
+  else {
+    RAISE_OPTION("Tox::ConnectionStatus");
+  }
+}

data/ext/tox/version.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"
 
 // Singleton methods

data/lib/tox.rb

@@ -1,41 +1,33 @@
 # frozen_string_literal: true
 
-# 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/>.
-
-require 'thread'
 require 'uri'
 require 'net/http'
 require 'json'
 require 'resolv'
 
 require 'tox/version'
-require 'tox/user_status'
 require 'tox/options'
 require 'tox/client'
 require 'tox/status'
 require 'tox/node'
 require 'tox/out_message'
+require 'tox/out_friend_message'
 require 'tox/friend'
-require 'tox/friend/out_message'
+
+require 'tox/proxies/base'
+require 'tox/proxies/http'
+require 'tox/proxies/socks5'
+
+# Enumerations
+require 'tox/user_status'
+require 'tox/proxy_type'
+require 'tox/connection_status'
 
 # Primitives
 require 'tox/binary'
 require 'tox/public_key'
 require 'tox/nospam'
+require 'tox/address_checksum'
 require 'tox/address'
 
 ##
@@ -61,15 +53,6 @@ module Tox
   # upgrade of libtoxcore. Specific handling is not needed for the time beeing.
   #
   class UnknownError < RuntimeError; end
-
-  ##
-  # Exception of this type is raised in similar cases to {Tox::UnknownError}
-  # when it can have security implications. This should happen rarely after
-  # the gem release. However, for now it can be raised when key-related
-  # functions fail because of unknown reason for better feedback
-  # during development.
-  #
-  class UnknownSecurityError < SecurityError; end
 end
 
 # C extension