tox.js

/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright © 2016-2020 The TokTok team.
 * Copyright © 2014-2016 saneki <s@neki.me>
 */

/**
 * @file tox.js - Implementation for the new api
 * @todo Have all buffer.toString() specify "utf8"?
 * @todo Use max size for all getters?
 * @todo Solve potential TOCTOU/race issues when using async functions that get
 *       the size of some data, allocate a Buffer of that size and call a tox.h
 *       function to set the data to that Buffer.
 */

var events = require("events");
var fs = require("fs");
var ref = require("ref-napi");
var RefArray = require("ref-array-napi");
var ffi = require("ffi-napi");
var _ = require("underscore");
var _util = require("util");

require("buffer");

var consts = require("./consts");
var errors = require("./errors");
var toxEvents = require("./events");
var ToxEncryptSave = require("./toxencryptsave");
var ToxOptions = require("./toxoptions");

// Util functions
var util = require("./util");
var size_t = util.size_t;
var fromHex = util.fromHex;
var getDateFromUInt64 = util.getDateFromUInt64;

// Tox types
var ToxPtr = ref.refType(ref.types.void);
var ToxOptionsPtr = ref.refType(ToxOptions);

// Common types
var UInt8Ptr = ref.refType("uint8");
var Int8Ptr = ref.refType("int8");
var UInt32Ptr = ref.refType("uint32");
var UserData = "pointer";

// Tox enums and error types
var CEnum = "int32";
var TOX_CONNECTION = CEnum;
var TOX_FILE_CONTROL = CEnum;
var TOX_FILE_KIND = CEnum;
var TOX_MESSAGE_TYPE = CEnum;
var TOX_USER_STATUS = CEnum;
var TOX_ERR_BOOTSTRAP = CEnum;
var TOX_ERR_FILE_CONTROL = CEnum;
var TOX_ERR_FILE_GET = CEnum;
var TOX_ERR_FILE_SEEK = CEnum;
var TOX_ERR_FILE_SEND = CEnum;
var TOX_ERR_FILE_SEND_CHUNK = CEnum;
var TOX_ERR_FRIEND_ADD = CEnum;
var TOX_ERR_FRIEND_BY_PUBLIC_KEY = CEnum;
var TOX_ERR_FRIEND_CUSTOM_PACKET = CEnum;
var TOX_ERR_FRIEND_DELETE = CEnum;
var TOX_ERR_FRIEND_GET_LAST_ONLINE = CEnum;
var TOX_ERR_FRIEND_GET_PUBLIC_KEY = CEnum;
var TOX_ERR_FRIEND_QUERY = CEnum;
var TOX_ERR_FRIEND_SEND_MESSAGE = CEnum;
var TOX_ERR_GET_PORT = CEnum;
var TOX_ERR_NEW = CEnum;
var TOX_ERR_OPTIONS_NEW = CEnum;
var TOX_ERR_SET_INFO = CEnum;
var TOX_ERR_SET_TYPING = CEnum;

// Buffer sizes for callbacks
var KeyBuffer = RefArray("uint8", consts.TOX_KEY_SIZE);
var KeyBufferPtr = ref.refType(KeyBuffer);
var RequestMessageBuffer = RefArray("uint8", consts.TOX_MAX_FRIEND_REQUEST_LENGTH);
var RequestMessageBufferPtr = ref.refType(RequestMessageBuffer);
var MessageBuffer = RefArray("uint8", consts.TOX_MAX_MESSAGE_LENGTH);
var MessageBufferPtr = ref.refType(MessageBuffer);
var NameBuffer = RefArray("uint8", consts.TOX_MAX_NAME_LENGTH);
var NameBufferPtr = ref.refType(NameBuffer);
var StatusMessageBuffer = RefArray("uint8", consts.TOX_MAX_STATUS_MESSAGE_LENGTH);
var StatusMessageBufferPtr = ref.refType(StatusMessageBuffer);
var FilenameBuffer = RefArray("uint8", consts.TOX_MAX_FILENAME_LENGTH);
var FilenameBufferPtr = ref.refType(FilenameBuffer);
// Use ref.reinterpret() to re-size Buffer at some address
// https://tootallnate.github.io/ref/#exports-reinterpret
var UnknownSizeBuffer = RefArray("uint8", 1);
var UnknownSizeBufferPtr = ref.refType(UnknownSizeBuffer);

// Tox callback types
var SelfConnectionStatusCallback = ffi.Function("void", [ToxPtr, TOX_CONNECTION, UserData]);
var FriendNameCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  NameBufferPtr,
  "size_t",
  UserData,
]);
var FriendStatusMessageCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  StatusMessageBufferPtr,
  "size_t",
  UserData,
]);
var FriendStatusCallback = ffi.Function("void", [ToxPtr, "uint32", TOX_USER_STATUS, UserData]);
var FriendConnectionStatusCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  TOX_CONNECTION,
  UserData,
]);
var FriendTypingCallback = ffi.Function("void", [ToxPtr, "uint32", "bool", UserData]);
var FriendReadReceiptCallback = ffi.Function("void", [ToxPtr, "uint32", "uint32", UserData]);
var FriendRequestCallback = ffi.Function("void", [
  ToxPtr,
  KeyBufferPtr,
  RequestMessageBufferPtr,
  "size_t",
  UserData,
]);
var FriendMessageCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  TOX_MESSAGE_TYPE,
  MessageBufferPtr,
  "size_t",
  UserData,
]);
var FileRecvControlCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  "uint32",
  TOX_FILE_CONTROL,
  UserData,
]);
var FileChunkRequestCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  "uint32",
  "uint64",
  "size_t",
  UserData,
]);
var FileRecvCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  "uint32",
  "uint32",
  "uint64",
  FilenameBufferPtr,
  "size_t",
  UserData,
]);
var FileRecvChunkCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  "uint32",
  "uint64",
  UnknownSizeBufferPtr,
  "size_t",
  UserData,
]);
var FriendLosslessPacketCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  UInt8Ptr,
  "size_t",
  UserData,
]);
var FriendLossyPacketCallback = ffi.Function("void", [
  ToxPtr,
  "uint32",
  UInt8Ptr,
  "size_t",
  UserData,
]);

/**
 * Creates a Tox instance.
 * @class
 * @param {Object} [opts] Options
 */
var Tox = function (opts) {
  if (!opts) opts = {};
  var libpath = opts["path"];

  this._emitter = new events.EventEmitter();
  this._library = this.createLibrary(libpath);
  this._initCrypto(opts);
  this._options = this._createToxOptions(opts);
  this._initNew(this._options);
  this._initCallbacks();
};

/**
 * Return a string representation of the Tox instance using util.inspect.
 * @return {String} string representation
 */
Tox.prototype.inspect = function () {
  var obj = {};
  Object.keys(this).forEach(function (k) {
    obj[k] = this[k];
    // Hacky fix for StringSlice assert error:
    // void node::Buffer::StringSlice(const v8::FunctionCallbackInfo<v8::Value>&) [with node::encoding encoding = (node::encoding)5u]: Assertion `obj_data != __null' failed.
    if (k === "_options") {
      // linting is weird and wants us to specifically `.toString()` this
      obj[k.toString()] = "[ToxOptions]";
    }
  }, this);
  return _util.inspect(obj);
};

/**
 * Asynchronous-sorta Tox instance creation. Currently is only "async" if
 * given "data" as a filepath (string).
 * @param {Object} [opts] Options
 * @param {Tox~toxCallback} [callback]
 * @todo Implement with async tox_new?
 */
Tox.load = function (opts, callback) {
  // Handle Tox.load(callback)
  if (arguments.length === 1 && _.isFunction(opts)) {
    callback = opts;
    opts = {};
  }

  var data = opts["data"];
  if (_.isString(data)) {
    fs.readFile(data, function (err, data) {
      if (!err) {
        opts["data"] = data; // Overwrite data (path) with data (Buffer)
        var tox = new Tox(opts);
        if (callback) {
          callback(undefined, tox);
        }
      } else if (callback) {
        callback(err);
      }
    });
  } else {
    var tox = new Tox(opts);
    if (callback) {
      callback(undefined, tox);
    }
  }
};

/**
 * Create a libtoxcore Library instance. If given a path, will use
 * the specified path.
 * @param {String} [libpath="libtoxcore"] - Path to libtoxcore
 * @return {ffi.Library}
 */
Tox.prototype.createLibrary = function (libpath) {
  libpath = libpath || "libtoxcore";
  return ffi.Library(libpath, {
    tox_add_tcp_relay: [
      "bool",
      [ToxPtr, Int8Ptr, "uint16", UInt8Ptr, ref.refType(TOX_ERR_BOOTSTRAP)],
    ],
    tox_bootstrap: ["bool", [ToxPtr, Int8Ptr, "uint16", UInt8Ptr, ref.refType(TOX_ERR_BOOTSTRAP)]],
    tox_callback_file_chunk_request: ["void", [ToxPtr, FileChunkRequestCallback, UserData]],
    tox_callback_file_recv: ["void", [ToxPtr, FileRecvCallback, UserData]],
    tox_callback_file_recv_chunk: ["void", [ToxPtr, FileRecvChunkCallback, UserData]],
    tox_callback_file_recv_control: ["void", [ToxPtr, FileRecvControlCallback, UserData]],
    tox_callback_friend_connection_status: [
      "void",
      [ToxPtr, FriendConnectionStatusCallback, UserData],
    ],
    tox_callback_friend_message: ["void", [ToxPtr, FriendMessageCallback, UserData]],
    tox_callback_friend_name: ["void", [ToxPtr, FriendNameCallback, UserData]],
    tox_callback_friend_read_receipt: ["void", [ToxPtr, FriendReadReceiptCallback, UserData]],
    tox_callback_friend_request: ["void", [ToxPtr, FriendRequestCallback, UserData]],
    tox_callback_friend_status: ["void", [ToxPtr, FriendStatusCallback, UserData]],
    tox_callback_friend_status_message: ["void", [ToxPtr, FriendStatusMessageCallback, UserData]],
    tox_callback_friend_typing: ["void", [ToxPtr, FriendTypingCallback, UserData]],
    tox_callback_self_connection_status: ["void", [ToxPtr, SelfConnectionStatusCallback, UserData]],
    tox_callback_friend_lossless_packet: ["void", [ToxPtr, FriendLosslessPacketCallback, UserData]],
    tox_callback_friend_lossy_packet: ["void", [ToxPtr, FriendLossyPacketCallback, UserData]],
    tox_file_control: [
      "bool",
      [ToxPtr, "uint32", "uint32", TOX_FILE_CONTROL, ref.refType(TOX_ERR_FILE_CONTROL)],
    ],
    tox_file_get_file_id: [
      "bool",
      [ToxPtr, "uint32", "uint32", UInt8Ptr, ref.refType(TOX_ERR_FILE_GET)],
    ],
    tox_file_seek: ["bool", [ToxPtr, "uint32", "uint32", "uint64", ref.refType(TOX_ERR_FILE_SEEK)]],
    tox_file_send: [
      "uint32",
      [
        ToxPtr,
        "uint32",
        "uint32",
        "uint64",
        UInt8Ptr,
        UInt8Ptr,
        "size_t",
        ref.refType(TOX_ERR_FILE_SEND),
      ],
    ],
    tox_file_send_chunk: [
      "bool",
      [
        ToxPtr,
        "uint32",
        "uint32",
        "uint64",
        UInt8Ptr,
        "size_t",
        ref.refType(TOX_ERR_FILE_SEND_CHUNK),
      ],
    ],
    tox_friend_add: [
      "uint32",
      [ToxPtr, UInt8Ptr, UInt8Ptr, "size_t", ref.refType(TOX_ERR_FRIEND_ADD)],
    ],
    tox_friend_add_norequest: ["uint32", [ToxPtr, UInt8Ptr, ref.refType(TOX_ERR_FRIEND_ADD)]],
    tox_friend_by_public_key: [
      "uint32",
      [ToxPtr, UInt8Ptr, ref.refType(TOX_ERR_FRIEND_BY_PUBLIC_KEY)],
    ],
    tox_friend_delete: ["bool", [ToxPtr, "uint32", ref.refType(TOX_ERR_FRIEND_DELETE)]],
    tox_friend_exists: ["bool", [ToxPtr, "uint32"]],
    tox_friend_get_connection_status: [
      TOX_CONNECTION,
      [ToxPtr, "uint32", ref.refType(TOX_ERR_FRIEND_QUERY)],
    ],
    tox_friend_get_last_online: [
      "uint64",
      [ToxPtr, "uint32", ref.refType(TOX_ERR_FRIEND_GET_LAST_ONLINE)],
    ],
    tox_friend_get_name: ["bool", [ToxPtr, "uint32", UInt8Ptr, ref.refType(TOX_ERR_FRIEND_QUERY)]],
    tox_friend_get_name_size: ["size_t", [ToxPtr, "uint32", ref.refType(TOX_ERR_FRIEND_QUERY)]],
    tox_friend_get_public_key: [
      "uint32",
      [ToxPtr, "uint32", UInt8Ptr, ref.refType(TOX_ERR_FRIEND_GET_PUBLIC_KEY)],
    ],
    tox_friend_get_status: [TOX_USER_STATUS, [ToxPtr, "uint32", ref.refType(TOX_ERR_FRIEND_QUERY)]],
    tox_friend_get_status_message: [
      "bool",
      [ToxPtr, "uint32", UInt8Ptr, ref.refType(TOX_ERR_FRIEND_QUERY)],
    ],
    tox_friend_get_status_message_size: [
      "size_t",
      [ToxPtr, "uint32", ref.refType(TOX_ERR_FRIEND_QUERY)],
    ],
    tox_friend_send_lossless_packet: [
      "bool",
      [ToxPtr, "uint32", UInt8Ptr, "size_t", ref.refType(TOX_ERR_FRIEND_CUSTOM_PACKET)],
    ],
    tox_friend_send_lossy_packet: [
      "bool",
      [ToxPtr, "uint32", UInt8Ptr, "size_t", ref.refType(TOX_ERR_FRIEND_CUSTOM_PACKET)],
    ],
    tox_friend_send_message: [
      "uint32",
      [
        ToxPtr,
        "uint32",
        TOX_MESSAGE_TYPE,
        UInt8Ptr,
        "size_t",
        ref.refType(TOX_ERR_FRIEND_SEND_MESSAGE),
      ],
    ],
    tox_hash: ["bool", [UInt8Ptr, UInt8Ptr, "size_t"]],
    tox_iteration_interval: ["uint32", [ToxPtr]],
    tox_iterate: ["void", [ToxPtr]],
    tox_kill: ["void", [ToxPtr]],
    tox_new: [ToxPtr, [ToxOptionsPtr, ref.refType(TOX_ERR_NEW)]],
    tox_get_savedata: ["void", [ToxPtr, UInt8Ptr]],
    tox_get_savedata_size: ["size_t", [ToxPtr]],
    tox_options_default: ["void", [ToxOptionsPtr]],
    tox_options_free: ["void", [ToxOptionsPtr]],
    tox_options_new: [ToxOptionsPtr, [ref.refType(TOX_ERR_OPTIONS_NEW)]],
    tox_self_get_address: ["void", [ToxPtr, UInt8Ptr]],
    tox_self_get_connection_status: [TOX_CONNECTION, [ToxPtr]],
    tox_self_get_friend_list: ["void", [ToxPtr, UInt32Ptr]],
    tox_self_get_friend_list_size: ["size_t", [ToxPtr]],
    tox_self_get_name: ["void", [ToxPtr, UInt8Ptr]],
    tox_self_get_name_size: ["size_t", [ToxPtr]],
    tox_self_get_nospam: ["uint32", [ToxPtr]],
    tox_self_get_public_key: ["void", [ToxPtr, UInt8Ptr]],
    tox_self_get_secret_key: ["void", [ToxPtr, UInt8Ptr]],
    tox_self_get_status: [TOX_USER_STATUS, [ToxPtr]],
    tox_self_get_status_message: ["void", [ToxPtr, UInt8Ptr]],
    tox_self_get_status_message_size: ["size_t", [ToxPtr]],
    tox_self_get_tcp_port: ["uint16", [ToxPtr, ref.refType(TOX_ERR_GET_PORT)]],
    tox_self_get_udp_port: ["uint16", [ToxPtr, ref.refType(TOX_ERR_GET_PORT)]],
    tox_self_set_name: ["bool", [ToxPtr, UInt8Ptr, "size_t", ref.refType(TOX_ERR_SET_INFO)]],
    tox_self_set_nospam: ["void", [ToxPtr, "uint32"]],
    tox_self_set_status: ["void", [ToxPtr, TOX_USER_STATUS]],
    tox_self_set_status_message: [
      "bool",
      [ToxPtr, UInt8Ptr, "size_t", ref.refType(TOX_ERR_SET_INFO)],
    ],
    tox_self_set_typing: ["bool", [ToxPtr, "uint32", "bool", ref.refType(TOX_ERR_SET_TYPING)]],
    tox_version_major: ["uint32", []],
    tox_version_minor: ["uint32", []],
    tox_version_patch: ["uint32", []],
  });
};

///////////////////////////////////////
//> Wrapper methods for tox.h functions
///////////////////////////////////////

/**
 * Asynchronous tox_version_major(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.versionMajor = function (callback) {
  this._performVersion({
    api: this.getLibrary().tox_version_major.async,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_version_major(3).
 * @return {Number} major version number
 */
Tox.prototype.versionMajorSync = function (callback) {
  return this._performVersion({
    api: this.getLibrary().tox_version_major,
  });
};

/**
 * Asynchronous tox_version_minor(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.versionMinor = function (callback) {
  this._performVersion({
    api: this.getLibrary().tox_version_minor.async,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_version_minor(3).
 * @return {Number} minor version number
 */
Tox.prototype.versionMinorSync = function (callback) {
  return this._performVersion({
    api: this.getLibrary().tox_version_minor,
  });
};

/**
 * Asynchronous tox_version_patch(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.versionPatch = function (callback) {
  this._performVersion({
    api: this.getLibrary().tox_version_patch.async,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_version_patch(3).
 * @return {Number} patch version number
 */
Tox.prototype.versionPatchSync = function (callback) {
  return this._performVersion({
    api: this.getLibrary().tox_version_patch,
  });
};

/**
 * Asynchronous tox_options_free(3).
 * @param {ToxOptions} opts
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.freeOptions = function (opts, callback) {
  this.getLibrary().tox_options_free.async(opts.ref(), callback);
};

/**
 * Synchronous tox_options_free(3).
 * @param {ToxOptions} opts
 */
Tox.prototype.freeOptionsSync = function (opts) {
  this.getLibrary().tox_options_free(opts.ref());
};

/**
 * Asynchronous tox_options_new(3).
 * @note Expects caller to free
 * @param {Tox~optionsCallback} [callback]
 * @return {ToxOptions} Options
 * @todo Error handling
 */
Tox.prototype.newOptions = function (callback) {
  this.getLibrary().tox_options_new.async(ref.NULL, function (err, options) {
    var opts;
    if (!err) opts = options.deref();
    if (callback) {
      callback(err, opts);
    }
  });
};

/**
 * Synchronous tox_options_new(3).
 * @note Expects caller to free
 * @return {ToxOptions} Options
 * @todo Error handling
 */
Tox.prototype.newOptionsSync = function () {
  var options = this.getLibrary().tox_options_new(ref.NULL);
  return options.deref();
};

/**
 * Asynchronous tox_bootstrap(3).
 * @param {String} address
 * @param {Number} port
 * @param {(Buffer|String)} publicKey
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.bootstrap = function (address, port, publicKey, callback) {
  this._performBootstrap({
    api: this.getLibrary().tox_bootstrap.async.bind(undefined, this.getHandle()),
    args: [address, port, publicKey],
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_bootstrap(3).
 * @param {String} address
 * @param {Number} port
 * @param {(Buffer|String)} publicKey
 * @throws Error if tox_bootstrap errors or returns false
 */
Tox.prototype.bootstrapSync = function (address, port, publicKey) {
  this._performBootstrap({
    api: this.getLibrary().tox_bootstrap.bind(undefined, this.getHandle()),
    args: [address, port, publicKey],
    async: false,
  });
};

/**
 * Asynchronous tox_add_tcp_relay(3).
 * @param {String} address
 * @param {Number} port
 * @param {(Buffer|String)} publicKey
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.addTCPRelay = function (address, port, publicKey, callback) {
  this._performBootstrap({
    api: this.getLibrary().tox_add_tcp_relay.async.bind(undefined, this.getHandle()),
    args: [address, port, publicKey],
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_add_tcp_relay(3).
 * @param {String} address
 * @param {Number} port
 * @param {(Buffer|String)} publicKey
 * @throws Error if tox_add_tcp_relay errors or returns false
 */
Tox.prototype.addTCPRelaySync = function (address, port, publicKey) {
  this._performBootstrap({
    api: this.getLibrary().tox_add_tcp_relay.bind(undefined, this.getHandle()),
    args: [address, port, publicKey],
    async: false,
  });
};

/**
 * Asynchronous tox_iteration_interval(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.iterationInterval = function (callback) {
  if (!this._checkHandle(callback)) {
    return;
  }

  this.getLibrary().tox_iteration_interval.async(this.getHandle(), callback);
};

/**
 * Synchronous tox_iteration_interval(3).
 * @return {Number} milliseconds until the next tox_iterate should occur
 */
Tox.prototype.iterationIntervalSync = function () {
  this._checkHandleSync();
  return this.getLibrary().tox_iteration_interval(this.getHandle());
};

/**
 * Asynchronous tox_iterate(3).
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.iterate = function (callback) {
  if (!this._checkHandle(callback)) {
    return;
  }

  this.getLibrary().tox_iterate(this.getHandle(), callback);
};

/**
 * Synchronous tox_iterate(3).
 */
Tox.prototype.iterateSync = function () {
  this._checkHandleSync();
  this.getLibrary().tox_iterate(this.getHandle());
};

/**
 * Asynchronous tox_self_get_address(3).
 * @param {Tox~dataCallback} [callback]
 */
Tox.prototype.getAddress = function (callback) {
  this._performGetter({
    api: this.getLibrary().tox_self_get_address.async.bind(undefined, this.getHandle()),
    format: "raw",
    size: consts.TOX_FRIEND_ADDRESS_SIZE,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_address(3).
 * @return {Buffer} address
 */
Tox.prototype.getAddressSync = function () {
  return this._performGetter({
    api: this.getLibrary().tox_self_get_address.bind(undefined, this.getHandle()),
    format: "raw",
    size: consts.TOX_FRIEND_ADDRESS_SIZE,
  });
};

/**
 * Asynchronous tox_self_get_connection_status(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getConnectionStatus = function (callback) {
  this._performNumberGetter({
    api: this.getLibrary().tox_self_get_connection_status.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_connection_status(3).
 * @return {Number} connection status
 */
Tox.prototype.getConnectionStatusSync = function () {
  return this._performNumberGetter({
    api: this.getLibrary().tox_self_get_connection_status.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_self_set_nospam(3).
 * @param {Number} nospam
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.setNospam = function (nospam, callback) {
  if (!this._checkHandle(callback)) return;
  this.getLibrary().tox_self_set_nospam.async(this.getHandle(), nospam, function (err) {
    if (callback) {
      callback(err);
    }
  });
};

/**
 * Synchronous tox_self_set_nospam(3).
 * @param {Number} nospam
 */
Tox.prototype.setNospamSync = function (nospam) {
  this._checkHandleSync();
  this.getLibrary().tox_self_set_nospam(this.getHandle(), nospam);
};

/**
 * Asynchronous tox_self_get_nospam(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getNospam = function (callback) {
  if (!this._checkHandle(callback)) return;
  this.getLibrary().tox_self_get_nospam.async(this.getHandle(), function (err, nospam) {
    if (callback) {
      callback(err, nospam);
    }
  });
};

/**
 * Synchronous tox_self_get_nospam(3).
 * @return {Number} nospam
 */
Tox.prototype.getNospamSync = function () {
  this._checkHandleSync();
  return this.getLibrary().tox_self_get_nospam(this.getHandle());
};

/**
 * Asynchronous tox_self_get_public_key(3).
 * @param {Tox~dataCallback} [callback]
 */
Tox.prototype.getPublicKey = function (callback) {
  this._performGetter({
    api: this.getLibrary().tox_self_get_public_key.async.bind(undefined, this.getHandle()),
    format: "raw",
    size: consts.TOX_PUBLIC_KEY_SIZE,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_public_key(3).
 * @return {Buffer} public key
 */
Tox.prototype.getPublicKeySync = function () {
  return this._performGetter({
    api: this.getLibrary().tox_self_get_public_key.bind(undefined, this.getHandle()),
    format: "raw",
    size: consts.TOX_PUBLIC_KEY_SIZE,
  });
};

/**
 * Asynchronous tox_self_get_secret_key(3).
 * @param {Tox~dataCallback} [callback]
 */
Tox.prototype.getSecretKey = function (callback) {
  this._performGetter({
    api: this.getLibrary().tox_self_get_secret_key.async.bind(undefined, this.getHandle()),
    format: "raw",
    size: consts.TOX_PUBLIC_KEY_SIZE,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_secret_key(3).
 * @return {Buffer} secret key
 */
Tox.prototype.getSecretKeySync = function () {
  return this._performGetter({
    api: this.getLibrary().tox_self_get_secret_key.bind(undefined, this.getHandle()),
    format: "raw",
    size: consts.TOX_SECRET_KEY_SIZE,
  });
};

/**
 * Asynchronous tox_self_set_name(3).
 * @param {String} name
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.setName = function (name, callback) {
  this._performSetter({
    api: this.getLibrary().tox_self_set_name.async.bind(undefined, this.getHandle()),
    data: name,
    error: errors.setInfo,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_set_name(3).
 * @param {String} name
 */
Tox.prototype.setNameSync = function (name) {
  this._performSetter({
    api: this.getLibrary().tox_self_set_name.bind(undefined, this.getHandle()),
    error: errors.setInfo,
    data: name,
  });
};

/**
 * Asynchronous tox_self_get_name_size(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getNameSize = function (callback) {
  this._performSizeGetter({
    api: this.getLibrary().tox_self_get_name_size.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_name_size(3).
 * @return {Number} name size
 */
Tox.prototype.getNameSizeSync = function () {
  return this._performSizeGetter({
    api: this.getLibrary().tox_self_get_name_size.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_self_get_name(3).
 * @param {Tox~stringCallback} [callback]
 */
Tox.prototype.getName = function (callback) {
  this._performGetter({
    api: this.getLibrary().tox_self_get_name.async.bind(undefined, this.getHandle()),
    format: "string",
    size: Tox.prototype.getNameSize.bind(this),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_name(3).
 * @return {String} name
 */
Tox.prototype.getNameSync = function () {
  return this._performGetter({
    api: this.getLibrary().tox_self_get_name.bind(undefined, this.getHandle()),
    format: "string",
    size: Tox.prototype.getNameSizeSync.bind(this),
  });
};

/**
 * Asynchronous tox_self_set_status_message(3).
 * @param {String} status_message
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.setStatusMessage = function (statusMessage, callback) {
  this._performSetter({
    api: this.getLibrary().tox_self_set_status_message.async.bind(undefined, this.getHandle()),
    data: statusMessage,
    error: errors.setInfo,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_set_status_message(3).
 * @param {String} status_message
 */
Tox.prototype.setStatusMessageSync = function (statusMessage) {
  this._performSetter({
    api: this.getLibrary().tox_self_set_status_message.bind(undefined, this.getHandle()),
    error: errors.setInfo,
    data: statusMessage,
  });
};

/**
 * Asynchronous tox_self_get_status_message_size(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getStatusMessageSize = function (callback) {
  this._performSizeGetter({
    api: this.getLibrary().tox_self_get_status_message_size.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_status_message_size(3).
 * @return {Number} status_message size
 */
Tox.prototype.getStatusMessageSizeSync = function () {
  return this._performSizeGetter({
    api: this.getLibrary().tox_self_get_status_message_size.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_self_get_status_message(3).
 * @param {Tox~stringCallback} [callback]
 */
Tox.prototype.getStatusMessage = function (callback) {
  this._performGetter({
    api: this.getLibrary().tox_self_get_status_message.async.bind(undefined, this.getHandle()),
    format: "string",
    size: Tox.prototype.getStatusMessageSize.bind(this),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_status_message(3).
 * @return {String} status message
 */
Tox.prototype.getStatusMessageSync = function () {
  return this._performGetter({
    api: this.getLibrary().tox_self_get_status_message.bind(undefined, this.getHandle()),
    format: "string",
    size: Tox.prototype.getStatusMessageSizeSync.bind(this),
  });
};

/**
 * Asynchronous tox_self_set_status(3).
 * @param {Number} status
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.setStatus = function (status, callback) {
  this._performNumberSetter({
    api: this.getLibrary().tox_self_set_status.async.bind(undefined, this.getHandle()),
    value: status,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_set_status(3).
 * @param {Number} status
 */
Tox.prototype.setStatusSync = function (status) {
  this._performNumberSetter({
    api: this.getLibrary().tox_self_set_status.bind(undefined, this.getHandle()),
    value: status,
  });
};

/**
 * Asynchronous tox_self_get_status(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getStatus = function (callback) {
  this._performNumberGetter({
    api: this.getLibrary().tox_self_get_status.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_status(3).
 * @return {Number} status
 */
Tox.prototype.getStatusSync = function () {
  return this._performNumberGetter({
    api: this.getLibrary().tox_self_get_status.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_friend_add(3).
 * @param {(Buffer|String)} address
 * @param {(Buffer|String)} message
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.addFriend = function (address, message, callback) {
  if (!this._checkHandle(callback)) return;

  address = fromHex(address);
  if (_.isString(message)) {
    message = Buffer.from(message);
  }

  var eptr = ref.alloc(TOX_ERR_FRIEND_ADD);
  this.getLibrary().tox_friend_add.async(
    this.getHandle(),
    address,
    message,
    size_t(message.length),
    eptr,
    function (err, friend) {
      var terr = errors.friendAdd(eptr.deref());
      if (!err && terr) err = terr;
      if (callback) {
        callback(err, friend);
      }
    }
  );
};

/**
 * Synchronous tox_friend_add(3).
 * @param {(Buffer|String)} address
 * @param {(Buffer|String)} message
 * @return {Number} friend number
 */
Tox.prototype.addFriendSync = function (address, message) {
  this._checkHandleSync();

  address = fromHex(address);
  if (_.isString(message)) {
    message = Buffer.from(message);
  }

  var eptr = ref.alloc(TOX_ERR_FRIEND_ADD),
    friend = this.getLibrary().tox_friend_add(
      this.getHandle(),
      address,
      message,
      size_t(message.length),
      eptr
    ),
    err = errors.friendAdd(eptr.deref());
  if (err) throw err;
  return friend;
};

/**
 * Asynchronous tox_friend_add_norequest(3).
 * @param {(Buffer|String)} publicKey
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.addFriendNoRequest = function (publicKey, callback) {
  if (!this._checkHandle(callback)) return;
  publicKey = fromHex(publicKey);
  var eptr = ref.alloc(TOX_ERR_FRIEND_ADD);
  this.getLibrary().tox_friend_add_norequest.async(
    this.getHandle(),
    publicKey,
    eptr,
    function (err, friend) {
      var terr = errors.friendAdd(eptr.deref());
      if (!err && terr) err = terr;
      if (callback) {
        callback(err, friend);
      }
    }
  );
};

/**
 * Synchronous tox_friend_add_norequest(3).
 * @param {(Buffer|String)} publicKey
 * @return {Number} friend number
 */
Tox.prototype.addFriendNoRequestSync = function (publicKey) {
  this._checkHandleSync();
  publicKey = fromHex(publicKey);
  var eptr = ref.alloc(TOX_ERR_FRIEND_ADD),
    friend = this.getLibrary().tox_friend_add_norequest(this.getHandle(), publicKey, eptr),
    err = errors.friendAdd(eptr.deref());
  if (err) throw err;
  return friend;
};

/**
 * Asynchronous tox_friend_delete(3).
 * @param {Number} friend
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.deleteFriend = function (friend, callback) {
  if (!this._checkHandle(callback)) return;
  var eptr = ref.alloc(TOX_ERR_FRIEND_DELETE);
  this.getLibrary().tox_friend_delete.async(
    this.getHandle(),
    friend,
    eptr,
    function (err, success) {
      var terr = errors.friendDelete(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    }
  );
};

/**
 * Synchronous tox_friend_delete(3).
 * @param {Number} friend
 */
Tox.prototype.deleteFriendSync = function (friend) {
  this._checkHandle();
  var eptr = ref.alloc(TOX_ERR_FRIEND_DELETE),
    success = this.getLibrary().tox_friend_delete(this.getHandle(), friend, eptr);
  var err = errors.friendDelete(eptr.deref());
  if (err) throw err;
  if (!success) throw errors.unsuccessful();
};

/**
 * Asynchronous tox_friend_by_public_key(3).
 * @param {(Buffer|String)} publicKey
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getFriendByPublicKey = function (publicKey, callback) {
  if (!this._checkHandle(callback)) return;
  publicKey = fromHex(publicKey);
  var eptr = ref.alloc(TOX_ERR_FRIEND_BY_PUBLIC_KEY);
  this.getLibrary().tox_friend_by_public_key.async(
    this.getHandle(),
    publicKey,
    eptr,
    function (err, friend) {
      var terr = errors.friendByPublicKey(eptr.deref());
      if (!err && terr) err = terr;
      if (callback) {
        callback(err, friend);
      }
    }
  );
};

/**
 * Synchronous tox_friend_by_public_key(3).
 * @param {(Buffer|String)} publicKey
 * @return {Number} friend number
 */
Tox.prototype.getFriendByPublicKeySync = function (publicKey) {
  this._checkHandle();
  publicKey = fromHex(publicKey);
  var eptr = ref.alloc(TOX_ERR_FRIEND_BY_PUBLIC_KEY),
    friend = this.getLibrary().tox_friend_by_public_key(this.getHandle(), publicKey, eptr);
  var err = errors.friendByPublicKey(eptr.deref());
  if (err) throw err;
  return friend;
};

/**
 * Asynchronous tox_friend_get_public_key(3).
 * @param {Number} friend
 * @param {Tox~dataCallback} [callback]
 */
Tox.prototype.getFriendPublicKey = function (friend, callback) {
  if (!this._checkHandle(callback)) return;
  var eptr = ref.alloc(TOX_ERR_FRIEND_GET_PUBLIC_KEY),
    buffer = Buffer.alloc(consts.TOX_PUBLIC_KEY_SIZE);
  this.getLibrary().tox_friend_get_public_key.async(
    this.getHandle(),
    friend,
    buffer,
    eptr,
    function (err, friend) {
      var terr = errors.friendGetPublicKey(eptr.deref());
      if (!err && terr) err = terr;
      if (callback) {
        callback(err, buffer);
      }
    }
  );
};

/**
 * Synchronous tox_friend_get_public_key(3).
 * @param {Number} friend
 * @return {Buffer} public key
 */
Tox.prototype.getFriendPublicKeySync = function (friend) {
  this._checkHandle();
  var eptr = ref.alloc(TOX_ERR_FRIEND_GET_PUBLIC_KEY),
    buffer = Buffer.alloc(consts.TOX_PUBLIC_KEY_SIZE),
    success = this.getLibrary().tox_friend_get_public_key(this.getHandle(), friend, buffer, eptr);
  var err = errors.friendGetPublicKey(eptr.deref());
  if (err) throw err;
  if (!success) throw errors.unsuccessful();
  return buffer;
};

/**
 * Asynchronous tox_friend_exists(3).
 * @param {Number} friend
 * @param {Tox~booleanCallback} [callback]
 */
Tox.prototype.hasFriend = function (friend, callback) {
  if (!this._checkHandle(callback)) return;
  this.getLibrary().tox_friend_exists.async(this.getHandle(), friend, function (err, exists) {
    if (callback) {
      callback(err, exists);
    }
  });
};

/**
 * Synchronous tox_friend_exists(3).
 * @param {Number} friend
 * @return {Boolean} true if has friend, false if not
 */
Tox.prototype.hasFriendSync = function (friend) {
  this._checkHandleSync();
  return this.getLibrary().tox_friend_exists(this.getHandle(), friend);
};

/**
 * Asynchronous tox_friend_get_last_online(3).
 * @param {Number} friend
 * @param {Tox~dateCallback} [callback]
 * @note This deals with a tox.h function that returns an uint64, which
 *       may lead to inaccuracy, as Javascript numbers are essentially
 *       doubles and "considered accurate up to 15 digits"
 *       www.w3schools.com/js/js_numbers.asp
 */
Tox.prototype.getFriendLastOnline = function (friend, callback) {
  if (!this._checkHandle(callback)) return;
  var eptr = ref.alloc(TOX_ERR_FRIEND_GET_LAST_ONLINE);
  this.getLibrary().tox_friend_get_last_online.async(
    this.getHandle(),
    friend,
    eptr,
    function (err, timeval) {
      var terr = errors.friendGetLastOnline(eptr.deref());
      if (!err && terr) err = terr;

      var date;
      if (!err) date = getDateFromUInt64(timeval);

      if (callback) {
        callback(err, date);
      }
    }
  );
};

/**
 * Synchronous tox_friend_get_last_online(3).
 * @param {Number} friend
 * @return {Date} last online date, may be backed by NaN
 * @note See note for Tox#getFriendLastOnline()
 */
Tox.prototype.getFriendLastOnlineSync = function (friend) {
  this._checkHandle();
  var eptr = ref.alloc(TOX_ERR_FRIEND_GET_LAST_ONLINE),
    timeval = this.getLibrary().tox_friend_get_last_online(this.getHandle(), friend, eptr);
  var err = errors.friendGetLastOnline(eptr.deref());
  if (err) throw err;
  return getDateFromUInt64(timeval);
};

/**
 * Asynchronous tox_self_get_friend_list_size(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getFriendListSize = function (callback) {
  this._performSizeGetter({
    api: this.getLibrary().tox_self_get_friend_list_size.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_friend_list_size(3).
 * @return {Number} friend count
 */
Tox.prototype.getFriendListSizeSync = function () {
  return this._performSizeGetter({
    api: this.getLibrary().tox_self_get_friend_list_size.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_self_get_friend_list(3).
 * @param {Tox~numberArrayCallback} [callback]
 * @note Between getting the size and calling tox_self_get_friend_list,
 *       we may have another friend leading to an overflow.
 */
Tox.prototype.getFriendList = function (callback) {
  if (!this._checkHandle(callback)) return;
  var _this = this;
  this.getFriendListSize(function (err, size) {
    if (!err) {
      var arr = new RefArray("uint32")(size);
      _this
        .getLibrary()
        .tox_self_get_friend_list.async(_this.getHandle(), arr.buffer, function (err) {
          // RefArray -> Javascript Array
          // @todo Make this RefArrayToArray()?
          var nums = [];
          if (!err) {
            for (var i = 0; i < arr.length; i++) nums.push(arr[i]);
          }

          if (callback) {
            callback(err, nums);
          }
        });
    } else if (callback) {
      callback(err);
    }
  });
};

/**
 * Synchronous tox_self_get_friend_list(3).
 * @return {Number[]} array of friend numbers
 * @note See overflow note for Tox#getFriendList()
 */
Tox.prototype.getFriendListSync = function () {
  this._checkHandleSync();
  var size = this.getFriendListSizeSync(),
    arr = new RefArray("uint32")(size);
  this.getLibrary().tox_self_get_friend_list(this.getHandle(), arr.buffer);

  // RefArray -> Javascript Array
  var nums = [];
  for (var i = 0; i < arr.length; i++) nums.push(arr[i]);

  return nums;
};

/**
 * Asynchronous tox_friend_get_name_size(3).
 * @param {Number} friend
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getFriendNameSize = function (friend, callback) {
  this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_name_size.async.bind(undefined, this.getHandle()),
    friend: friend,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_get_name_size(3).
 * @param {Number} friend
 * @return {Number} name size
 */
Tox.prototype.getFriendNameSizeSync = function (friend) {
  return this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_name_size.bind(undefined, this.getHandle()),
    friend: friend,
  });
};

/**
 * Asynchronous tox_friend_get_name(3).
 * @param {Number} friend
 * @param {Tox~stringCallback} [callback]
 */
Tox.prototype.getFriendName = function (friend, callback) {
  this._performFriendGetter({
    api: this.getLibrary().tox_friend_get_name.async.bind(undefined, this.getHandle()),
    format: "string",
    friend: friend,
    size: consts.TOX_MAX_NAME_LENGTH,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_get_name(3).
 * @param {Number} friend
 * @return {String} friend name
 */
Tox.prototype.getFriendNameSync = function (friend) {
  return this._performFriendGetter({
    api: this.getLibrary().tox_friend_get_name.bind(undefined, this.getHandle()),
    format: "string",
    friend: friend,
    size: consts.TOX_MAX_NAME_LENGTH,
  });
};

/**
 * Asynchronous tox_friend_get_status_message_size(3).
 * @param {Number} friend
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getFriendStatusMessageSize = function (friend, callback) {
  this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_status_message_size.async.bind(
      undefined,
      this.getHandle()
    ),
    friend: friend,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_get_status_message_size(3).
 * @param {Number} friend
 * @return {Number} status message size
 */
Tox.prototype.getFriendStatusMessageSizeSync = function (friend) {
  return this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_status_message_size.bind(undefined, this.getHandle()),
    friend: friend,
  });
};

/**
 * Asynchronous tox_friend_get_status_message(3).
 * @param {Number} friend
 * @param {Tox~stringCallback} [callback]
 */
Tox.prototype.getFriendStatusMessage = function (friend, callback) {
  this._performFriendGetter({
    api: this.getLibrary().tox_friend_get_status_message.async.bind(undefined, this.getHandle()),
    format: "string",
    friend: friend,
    size: consts.TOX_MAX_STATUS_MESSAGE_LENGTH,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_get_status_message(3).
 * @param {Number} friend
 * @return {String} friend status message
 */
Tox.prototype.getFriendStatusMessageSync = function (friend) {
  return this._performFriendGetter({
    api: this.getLibrary().tox_friend_get_status_message.bind(undefined, this.getHandle()),
    format: "string",
    friend: friend,
    size: consts.TOX_MAX_STATUS_MESSAGE_LENGTH,
  });
};

/**
 * Asynchronous tox_friend_get_status(3).
 * @param {Number} friend
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getFriendStatus = function (friend, callback) {
  this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_status.async.bind(undefined, this.getHandle()),
    friend: friend,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_get_status(3).
 * @param {Number} friend
 * @return {Number} friend status
 */
Tox.prototype.getFriendStatusSync = function (friend) {
  return this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_status.bind(undefined, this.getHandle()),
    friend: friend,
  });
};

/**
 * Asynchronous tox_friend_get_connection_status(3).
 * @param {Number} friend
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getFriendConnectionStatus = function (friend, callback) {
  this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_connection_status.async.bind(undefined, this.getHandle()),
    friend: friend,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_get_connection_status(3).
 * @param {Number} friend
 * @return {Number} friend status
 */
Tox.prototype.getFriendConnectionStatusSync = function (friend) {
  return this._performFriendNumberGetter({
    api: this.getLibrary().tox_friend_get_connection_status.bind(undefined, this.getHandle()),
    friend: friend,
  });
};

/**
 * Asynchronous tox_self_get_udp_port(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getUdpPort = function (callback) {
  this._performGetPort({
    api: this.getLibrary().tox_self_get_udp_port.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_udp_port(3).
 * @returns {Number} Port
 * @throws Error if TOX_ERR_GET_PORT set.
 */
Tox.prototype.getUdpPortSync = function () {
  return this._performGetPort({
    api: this.getLibrary().tox_self_get_udp_port.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_self_get_tcp_port(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getTcpPort = function (callback) {
  this._performGetPort({
    api: this.getLibrary().tox_self_get_tcp_port.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_self_get_tcp_port(3).
 * @returns {Number} Port
 * @throws Error if TOX_ERR_GET_PORT set.
 */
Tox.prototype.getTcpPortSync = function () {
  return this._performGetPort({
    api: this.getLibrary().tox_self_get_tcp_port.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_self_set_typing(3).
 * @param {Number} friend
 * @param {Boolean} typing
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.setTyping = function (friend, typing, callback) {
  if (!this._checkHandle(callback)) return;
  var eptr = ref.alloc(TOX_ERR_SET_TYPING);
  this.getLibrary().tox_self_set_typing.async(
    this.getHandle(),
    friend,
    typing,
    eptr,
    function (err, success) {
      var terr = errors.setTyping(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    }
  );
};

/**
 * Synchronous tox_self_set_typing(3).
 * @param {Number} friend
 * @param {Boolean} typing
 */
Tox.prototype.setTypingSync = function (friend, typing) {
  this._checkHandleSync();
  var eptr = ref.alloc(TOX_ERR_SET_TYPING),
    success = this.getLibrary().tox_self_set_typing(this.getHandle(), friend, typing, eptr);

  var err = errors.setTyping(eptr.deref());
  if (err) throw err;
  if (!success) throw errors.unsuccessful();
};

/**
 * Asynchronous tox_friend_send_message(3).
 * @param {Number} friend
 * @param {(Buffer|String)} message
 * @param {(Boolean|Number|String)} [type] - If boolean, assumed isAction
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.sendFriendMessage = function (friend, message, type, callback) {
  if (!this._checkHandle(callback)) return;

  // If #sendFriendMessage(friend, message, callback), use default type
  if (arguments.length === 3 && _.isFunction(type)) {
    callback = type;
    type = undefined;
  }

  var args = this._fixSendMessageArgs(friend, message, type),
    friend = args[0],
    message = args[1],
    type = args[2],
    eptr = ref.alloc(TOX_ERR_FRIEND_SEND_MESSAGE);

  this.getLibrary().tox_friend_send_message.async(
    this.getHandle(),
    friend,
    type,
    message,
    message.length,
    eptr,
    function (err, mid) {
      var terr = errors.friendSendMessage(eptr.deref());
      if (!err && terr) err = terr;
      if (callback) {
        callback(err, mid);
      }
    }
  );
};

/**
 * Synchronous tox_friend_send_message(3).
 * @param {Number} friend
 * @param {(Buffer|String)} message
 * @param {(Boolean|Number|String)} [type] - If boolean, assumed isAction
 * @return {Number} message id
 */
Tox.prototype.sendFriendMessageSync = function (friend, message, type) {
  this._checkHandleSync();
  var args = this._fixSendMessageArgs(friend, message, type),
    friend = args[0],
    message = args[1],
    type = args[2],
    eptr = ref.alloc(TOX_ERR_FRIEND_SEND_MESSAGE);

  var mid = this.getLibrary().tox_friend_send_message(
    this.getHandle(),
    friend,
    type,
    message,
    message.length,
    eptr
  );

  var err = errors.friendSendMessage(eptr.deref());
  if (err) throw err;
  return mid;
};

/**
 * Asynchronous tox_hash(3).
 * @param {(Buffer|String)} data
 * @param {Tox~dataCallback} [callback]
 */
Tox.prototype.hash = function (data, callback) {
  if (_.isString(data)) data = Buffer.from(data);
  var hash = Buffer.alloc(consts.TOX_HASH_LENGTH);
  this.getLibrary().tox_hash.async(hash, data, data.length, function (err, success) {
    if (!err && !success) err = errors.unsuccessful();
    if (callback) {
      callback(err, hash);
    }
  });
};

/**
 * Synchronous tox_hash(3).
 * @param {(Buffer|String)} data
 * @return {Buffer} hash
 */
Tox.prototype.hashSync = function (data) {
  if (_.isString(data)) data = Buffer.from(data);
  var hash = Buffer.alloc(consts.TOX_HASH_LENGTH),
    success = this.getLibrary().tox_hash(hash, data, data.length);
  if (!success) throw errors.unsuccessful();
  return hash;
};

/**
 * Asynchronous tox_file_control(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @param {Number} control
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.controlFile = function (friendnum, filenum, control, callback) {
  if (!this._checkHandle(callback)) return;
  control = this._fixFileControl(control);
  var eptr = ref.alloc(TOX_ERR_FILE_CONTROL);
  this.getLibrary().tox_file_control.async(
    this.getHandle(),
    friendnum,
    filenum,
    control,
    eptr,
    function (err, success) {
      var terr = errors.fileControl(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    }
  );
};

/**
 * Synchronous tox_file_control(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @param {Number} control
 */
Tox.prototype.controlFileSync = function (friendnum, filenum, control) {
  this._checkHandleSync();
  control = this._fixFileControl(control);
  var eptr = ref.alloc(TOX_ERR_FILE_CONTROL),
    success = this.getLibrary().tox_file_control(
      this.getHandle(),
      friendnum,
      filenum,
      control,
      eptr
    );
  var err = errors.fileControl(eptr.deref());
  if (err) throw err;
  if (!success) throw errors.unsuccessful();
};

/**
 * Asynchronous tox_file_seek(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @param {Number} position
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.seekFile = function (friendnum, filenum, position, callback) {
  if (!this._checkHandle(callback)) return;
  var eptr = ref.alloc(TOX_ERR_FILE_SEEK);
  this.getLibrary().tox_file_seek.async(
    this.getHandle(),
    friendnum,
    filenum,
    position,
    eptr,
    function (err, success) {
      var terr = errors.fileSeek(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    }
  );
};

/**
 * Synchronous tox_file_seek(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @param {Number} position
 */
Tox.prototype.seekFileSync = function (friendnum, filenum, position) {
  this._checkHandleSync();
  var eptr = ref.alloc(TOX_ERR_FILE_SEEK),
    success = this.getLibrary().tox_file_seek(this.getHandle(), friendnum, filenum, position, eptr);
  var err = errors.fileSeek(eptr.deref());
  if (err) throw err;
  if (!success) throw errors.unsuccessful();
};

/**
 * Asynchronous tox_file_get_file_id(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @param {Tox~dataCallback} [callback]
 */
Tox.prototype.getFileId = function (friendnum, filenum, callback) {
  if (!this._checkHandle(callback)) return;
  var eptr = ref.alloc(TOX_ERR_FILE_GET),
    fileid = Buffer.alloc(consts.TOX_FILE_ID_LENGTH);
  this.getLibrary().tox_file_get_file_id.async(
    this.getHandle(),
    friendnum,
    filenum,
    fileid,
    eptr,
    function (err, success) {
      var terr = errors.fileGet(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err, fileid);
      }
    }
  );
};

/**
 * Synchronous tox_file_get_file_id(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @return {Buffer} file id
 */
Tox.prototype.getFileIdSync = function (friendnum, filenum) {
  this._checkHandleSync();
  var eptr = ref.alloc(TOX_ERR_FILE_GET),
    fileid = Buffer.alloc(consts.TOX_FILE_ID_LENGTH),
    success = this.getLibrary().tox_file_get_file_id(
      this.getHandle(),
      friendnum,
      filenum,
      fileid,
      eptr
    );
  var err = errors.fileGet(eptr.deref());
  if (err) throw err;
  if (!success) throw errors.unsuccessful();
  return fileid;
};

/**
 * Asynchronous tox_file_send(3).
 * @param {Number} friendnum
 * @param {Number} kind
 * @param {(Buffer|String)} filename
 * @param {Number} size
 * @param {Buffer} [fileid]
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.sendFile = function (friendnum, kind, filename, size, fileid, callback) {
  if (!this._checkHandle(callback)) return;
  if (arguments.length === 5 && _.isFunction(fileid)) {
    callback = fileid;
    fileid = undefined;
  }
  if (!fileid) fileid = ref.NULL;
  if (_.isString(filename)) {
    filename = Buffer.from(filename);
  }
  var eptr = ref.alloc(TOX_ERR_FILE_SEND);
  this.getLibrary().tox_file_send.async(
    this.getHandle(),
    friendnum,
    kind,
    size,
    fileid,
    filename,
    filename.length,
    eptr,
    function (err, filenum) {
      var terr = errors.fileSend(eptr.deref());
      if (!err && terr) err = terr;
      if (callback) {
        callback(err, filenum);
      }
    }
  );
};

/**
 * Synchronous tox_file_send(3).
 * @param {Number} friendnum
 * @param {Number} kind
 * @param {(Buffer|String)} filename
 * @param {Number} size
 * @param {Buffer} [fileid]
 * @return {Number} file number
 */
Tox.prototype.sendFileSync = function (friendnum, kind, filename, size, fileid) {
  this._checkHandleSync();
  if (!fileid) fileid = ref.NULL;
  if (_.isString(filename)) {
    filename = Buffer.from(filename);
  }
  var eptr = ref.alloc(TOX_ERR_FILE_SEND),
    filenum = this.getLibrary().tox_file_send(
      this.getHandle(),
      friendnum,
      kind,
      size,
      fileid,
      filename,
      filename.length,
      eptr
    );
  var err = errors.fileSend(eptr.deref());
  if (err) throw err;
  return filenum;
};

/**
 * Asynchronous tox_file_send_chunk(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @param {Number} position
 * @param {Buffer} data
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.sendFileChunk = function (friendnum, filenum, position, data, callback) {
  if (!this._checkHandle(callback)) return;
  var eptr = ref.alloc(TOX_ERR_FILE_SEND_CHUNK);
  this.getLibrary().tox_file_send_chunk.async(
    this.getHandle(),
    friendnum,
    filenum,
    position,
    data,
    data.length,
    eptr,
    function (err, success) {
      var terr = errors.fileSendChunk(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    }
  );
};

/**
 * Synchronous tox_file_send_chunk(3).
 * @param {Number} friendnum
 * @param {Number} filenum
 * @param {Number} position
 * @param {Buffer} data
 */
Tox.prototype.sendFileChunkSync = function (friendnum, filenum, position, data) {
  this._checkHandleSync();
  var eptr = ref.alloc(TOX_ERR_FILE_SEND_CHUNK),
    success = this.getLibrary().tox_file_send_chunk(
      this.getHandle(),
      friendnum,
      filenum,
      position,
      data,
      data.length,
      eptr
    );
  var err = errors.fileSendChunk(eptr.deref());
  if (err) throw err;
  if (!success) throw errors.unsuccessful();
};

/**
 * Asynchronous tox_friend_send_lossless_packet(3).
 * @param {Number} friendnum
 * @param {Number} [id] - Leading byte in the range [160, 191]
 * @param {Buffer} data
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.sendLosslessPacket = function (friendnum, id, data, callback) {
  if (_.isNumber(id)) {
    data = this._fixPacketBuffer(id, data);
  } else {
    callback = data;
    data = id;
  }

  this._performSendPacket({
    api: this.getLibrary().tox_friend_send_lossless_packet.async.bind(undefined, this.getHandle()),
    data: data,
    friend: friendnum,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_send_lossless_packet(3).
 * @param {Number} friendnum
 * @param {Number} [id] - Leading byte in the range [160, 191]
 * @param {Buffer} data
 * @throws Error if TOX_ERR_FRIEND_CUSTOM_PACKET set
 * @throws Error if tox_friend_send_lossless_packet returns false
 */
Tox.prototype.sendLosslessPacketSync = function (friendnum, id, data) {
  if (_.isNumber(id)) {
    data = this._fixPacketBuffer(id, data);
  } else {
    data = id;
  }

  this._performSendPacket({
    api: this.getLibrary().tox_friend_send_lossless_packet.bind(undefined, this.getHandle()),
    data: data,
    friend: friendnum,
  });
};

/**
 * Asynchronous tox_friend_send_lossy_packet(3).
 * @untested
 * @param {Number} friendnum
 * @param {Number} [id] - Leading byte in the range [200, 254]
 * @param {Buffer} data
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.sendLossyPacket = function (friendnum, data, callback) {
  if (_.isNumber(id)) {
    data = this._fixPacketBuffer(id, data);
  } else {
    callback = data;
    data = id;
  }

  this._performSendPacket({
    api: this.getLibrary().tox_friend_send_lossy_packet.async.bind(undefined, this.getHandle()),
    data: data,
    friend: friendnum,
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_friend_send_lossy_packet(3).
 * @untested
 * @param {Number} friendnum
 * @param {Number} [id] - Leading byte in the range [200, 254]
 * @param {Buffer} data
 * @throws Error if TOX_ERR_FRIEND_CUSTOM_PACKET set
 * @throws Error if tox_friend_send_lossy_packet returns false
 */
Tox.prototype.sendLossyPacketSync = function (friendnum, id, data) {
  if (_.isNumber(id)) {
    data = this._fixPacketBuffer(id, data);
  } else {
    data = id;
  }

  this._performSendPacket({
    api: this.getLibrary().tox_friend_send_lossy_packet.bind(undefined, this.getHandle()),
    data: data,
    friend: friendnum,
  });
};

/**
 * Asynchronous tox_kill(3). Will also set handle to undefined.
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.kill = function (callback) {
  if (!this._checkHandle(callback)) {
    return;
  }

  var _this = this;
  this.getLibrary().tox_kill.async(this.getHandle(), function (err) {
    if (!err) {
      _this._handle = undefined;
    }

    if (callback) {
      callback(err);
    }
  });
};

/**
 * Synchronous tox_kill(3). Will also set handle to undefined.
 */
Tox.prototype.killSync = function () {
  this._checkHandleSync();
  this.getLibrary().tox_kill(this.getHandle());
  this._handle = undefined;
};

/**
 * Asynchronous tox_get_savedata_size(3).
 * @param {Tox~numberCallback} [callback]
 */
Tox.prototype.getSavedataSize = function (callback) {
  this._performSizeGetter({
    api: this.getLibrary().tox_get_savedata_size.async.bind(undefined, this.getHandle()),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_get_savedata_size(3).
 * @return {Number} savedata size
 */
Tox.prototype.getSavedataSizeSync = function (callback) {
  return this._performSizeGetter({
    api: this.getLibrary().tox_get_savedata_size.bind(undefined, this.getHandle()),
  });
};

/**
 * Asynchronous tox_get_savedata(3).
 * @param {Tox~dataCallback} [callback]
 */
Tox.prototype.getSavedata = function (callback) {
  this._performGetter({
    api: this.getLibrary().tox_get_savedata.async.bind(undefined, this.getHandle()),
    format: "raw",
    size: Tox.prototype.getSavedataSize.bind(this),
    async: true,
    callback: callback,
  });
};

/**
 * Synchronous tox_get_savedata(3).
 * @return {Buffer} savedata
 */
Tox.prototype.getSavedataSync = function () {
  return this._performGetter({
    api: this.getLibrary().tox_get_savedata.bind(undefined, this.getHandle()),
    format: "raw",
    size: Tox.prototype.getSavedataSizeSync.bind(this),
  });
};

/////////////////////////////
//> Other convenience methods
/////////////////////////////

/**
 * Get the ToxEncryptSave instance associated with this Tox object,
 * if any.
 * @return {ToxEncryptSave} Crypto handler
 */
Tox.prototype.crypto = function () {
  return this._crypto;
};

/**
 * Get the handle object.
 * @return {Object}
 */
Tox.prototype.getHandle = function () {
  return this._handle;
};

/**
 * Whether or not this Tox instance has a crypto handler.
 * @return {Boolean} true if it has a crypto handler, false if not
 */
Tox.prototype.hasCrypto = function () {
  return this._crypto instanceof ToxEncryptSave;
};

/**
 * Whether or not this Tox instance has a handle.
 * @return {Boolean} true if handle, false if none
 */
Tox.prototype.hasHandle = function () {
  return !!this.getHandle();
};

/**
 * Get the internal Library instance.
 * @return {ffi.Library}
 */
Tox.prototype.getLibrary = function () {
  return this._library;
};

/**
 * Frees the ToxOptions and calls tox_kill synchronously.
 */
Tox.prototype.free = function () {
  this.freeOptionsSync(this._options);
  this._options = undefined;
  this.killSync();
};

/**
 * Get the event emitter.
 * @return {EventEmitter} emitter
 */
Tox.prototype.getEmitter = function () {
  return this._emitter;
};

/**
 * Get the ToxOptions as an object.
 * @return {Object} object
 */
Tox.prototype.getOptions = function () {
  var options = this._options;

  var proxyAddress = undefined;
  if (ref.address(options.proxy_address) !== 0) {
    proxyAddress = ref.reinterpretUntilZeros(options.proxy_address, ref.types.char.size).toString();
  }

  return {
    ipv6_enabled: options.ipv6_enabled,
    udp_enabled: options.udp_enabled,
    proxy_type: options.proxy_type,
    proxy_address: proxyAddress,
    proxy_port: options.proxy_port,
    start_port: options.start_port,
    end_port: options.end_port,
    savedata_type: options.savedata_type,
    savedata_data: ref.address(options.savedata_data),
    savedata_length: options.savedata_length,
  };
};

/**
 * Check whether or not an iterateSync loop is running.
 * @return {Boolean} true if loop running, false if not
 */
Tox.prototype.isStarted = function () {
  return !!this._interval;
};

/**
 * Checks if listening on a tcp port.
 * @return {Boolean} true if tcp, false if not
 */
Tox.prototype.isTcp = function () {
  try {
    this.getTcpPortSync();
    return true;
  } catch (e) {
    return false;
  }
};

/**
 * Checks if listening on a udp port.
 * @return {Boolean} true if udp, false if not
 */
Tox.prototype.isUdp = function () {
  try {
    this.getUdpPortSync();
    return true;
  } catch (e) {
    return false;
  }
};

/**
 * Wrapper method for _emitter.removeListener.
 */
Tox.prototype.off = function () {
  this._emitter.removeListener.apply(this._emitter, arguments);
};

/**
 * Wrapper method for _emitter.on.
 */
Tox.prototype.on = function () {
  this._emitter.on.apply(this._emitter, arguments);
};

/**
 * Asynchronously save state to a tox file.
 * @param {String} filepath
 * @param {Tox~errorCallback} [callback]
 */
Tox.prototype.saveToFile = function (filepath, callback) {
  this.getSavedata(function (err, buffer) {
    if (!err) {
      // Using hex number because "grunt jsdoc" doesn't understand octal.
      fs.writeFile(filepath, buffer, { mode: 0x180 /* 0600 */ }, callback);
    } else if (callback) {
      callback(err);
    }
  });
};

/**
 * Synchronously save state to a tox file.
 * @param {String} filepath
 */
Tox.prototype.saveToFileSync = function (filepath) {
  // Using hex number because "grunt jsdoc" doesn't understand octal.
  fs.writeFileSync(filepath, this.getSavedataSync(), {
    mode: 0x180 /* 0600 */,
  });
};

/**
 * Start an interateSync loop using setInterval.
 * @param {Number} [wait] - Milliseconds to wait between iterateSync calls
 * @todo Maybe do one iterateSync(), then iterationIntervalSync(), and use that
 *       value as "wait"?
 */
Tox.prototype.start = function (wait) {
  if (!this.isStarted()) {
    if (isNaN(wait) || wait <= 0) wait = 40; // Default milliseconds to wait
    this._interval = setInterval(Tox.prototype.iterateSync.bind(this), wait);
  }
};

/**
 * Stop the iterateSync loop if there is one running.
 */
Tox.prototype.stop = function () {
  if (this._interval) {
    clearInterval(this._interval);
    this._interval = undefined;
  }
};

/**
 * Asynchronously get the address as a hex string.
 */
Tox.prototype.getAddressHex = function (callback) {
  util.hexify(this.getAddress.bind(this), callback);
};

/**
 * Synchronously get the address as a hex string.
 * @return {String} Address hex string
 */
Tox.prototype.getAddressHexSync = function () {
  return util.hexifySync(this.getAddressSync.bind(this));
};

/**
 * Asynchronously get the public key of a friend as a hex string.
 */
Tox.prototype.getFriendPublicKeyHex = function (friend, callback) {
  util.hexify(this.getFriendPublicKey.bind(this, friend), callback);
};

/**
 * Synchronously get the public key of a friend as a hex string.
 * @return {String} Friend public key hex string
 */
Tox.prototype.getFriendPublicKeyHexSync = function (friend) {
  return util.hexifySync(this.getFriendPublicKeySync.bind(this, friend));
};

/**
 * Asynchronously get the public key as a hex string.
 */
Tox.prototype.getPublicKeyHex = function (callback) {
  util.hexify(this.getPublicKey.bind(this), callback);
};

/**
 * Synchronously get the public key as a hex string.
 * @return {String} Public key hex string
 */
Tox.prototype.getPublicKeyHexSync = function () {
  return util.hexifySync(this.getPublicKeySync.bind(this));
};

/**
 * Asynchronously get the secret key as a hex string.
 */
Tox.prototype.getSecretKeyHex = function (callback) {
  util.hexify(this.getSecretKey.bind(this), callback);
};

/**
 * Synchronously get the secret key as a hex string.
 * @return {String} Secret key hex string
 */
Tox.prototype.getSecretKeyHexSync = function () {
  return util.hexifySync(this.getSecretKeySync.bind(this));
};

//////////////////////////
//> Private helper methods
//////////////////////////

/**
 * Check if this Tox instance has a handle associated with it.
 * @private
 * @param {Tox~errorCallback} callback - Callback to pass Error object to if no handle
 * @return {Boolean} true if has handle (no error), false if no handle (error)
 */
Tox.prototype._checkHandle = function (callback) {
  if (!this.hasHandle()) {
    var err = new Error("No toxcore handle");
    err.code = "NO_HANDLE";
    if (callback) {
      callback(err);
    }

    return false;
  } else {
    return true;
  }
};

/**
 * Check to make sure this Tox instance has a handle associated
 * with it. If not, will throw an exception. Meant to be used
 * in sync functions.
 * @private
 * @throws Error if no handle
 */
Tox.prototype._checkHandleSync = function () {
  if (!this.hasHandle()) {
    var err = new Error("No toxcore handle");
    err.code = "NO_HANDLE";
    throw err;
  }
};

/**
 * Create a ToxOptions from opts passed to Tox. This uses
 * Tox#newOptionsSync(), so it expects the ToxOptions struct
 * to be freed by the caller sometime later using
 * Tox#freeOptionsSync().
 * @private
 * @param {Object} opts
 * @return {ToxOptions} Options
 */
Tox.prototype._createToxOptions = function (opts) {
  var toxopts = this.newOptionsSync(),
    ipv6 = opts["ipv6"],
    udp = opts["udp"],
    startPort = opts["startPort"],
    endPort = opts["endPort"],
    data = opts["data"],
    pass = opts["pass"];

  // If pass is a string or Buffer, have pass be a function that returns
  // the string or Buffer
  if (_.isString(pass) || Buffer.isBuffer(pass)) {
    var passData = pass;
    pass = function () {
      return passData;
    };
  }

  // If "data" is a string, assume filepath to read data from
  if (_.isString(data)) {
    data = fs.readFileSync(data);
  }

  if (data) {
    if (this.hasCrypto() && _.isFunction(pass) && this.crypto().isDataEncryptedSync(data)) {
      var passphrase = pass();
      data = this.crypto().decryptSync(data, passphrase);
    }

    toxopts.savedata_type = consts.TOX_SAVEDATA_TYPE_TOX_SAVE;
    toxopts.savedata_length = size_t(data.length);
  } else {
    data = ref.NULL;
    toxopts.savedata_type = consts.TOX_SAVEDATA_TYPE_NONE;
    toxopts.savedata_length = 0;
  }

  toxopts.savedata_data = data;

  // Default proxy values
  toxopts.proxy_address = ref.NULL;
  toxopts.proxy_type = consts.TOX_PROXY_TYPE_NONE;
  toxopts.proxy_port = 0;

  // If ipv6 not set, use default of false
  ipv6 = ipv6 !== undefined ? !!ipv6 : false;

  // If udp not set, use default of true
  udp = udp !== undefined ? !!udp : true;

  toxopts.ipv6_enabled = ipv6 ? 1 : 0;
  toxopts.udp_enabled = udp ? 1 : 0;

  if (_.isNumber(startPort)) {
    toxopts.start_port = startPort;
  }

  if (_.isNumber(endPort)) {
    toxopts.end_port = endPort;
  }

  this._setProxyToToxOptions(opts, toxopts);

  return toxopts;
};

/**
 * Wrapper method for _emitter.emit.
 * @private
 */
Tox.prototype._emit = function () {
  this._emitter.emit.apply(this._emitter, arguments);
};

/**
 * Fix arguments passed to bootstrap functions.
 * @private
 */
Tox.prototype._fixBootstrapArgs = function (address, port, publicKey) {
  address = Buffer.from(address + "\0");

  if (_.isString(publicKey)) {
    publicKey = Buffer.from(publicKey, "hex");
  }

  return [address, port, publicKey];
};

/**
 * Fix arguments passed to send-message functions.
 * @private
 */
Tox.prototype._fixSendMessageArgs = function (to, message, type) {
  if (_.isString(message)) {
    message = Buffer.from(message);
  }

  if (_.isBoolean(type)) {
    type = type ? consts.TOX_MESSAGE_TYPE_ACTION : consts.TOX_MESSAGE_TYPE_NORMAL;
  } else if (_.isString(type)) {
    type = /^action$/i.test(type) ? consts.TOX_MESSAGE_TYPE_ACTION : consts.TOX_MESSAGE_TYPE_NORMAL;
  } else if (!_.isNumber(type)) {
    type = consts.TOX_MESSAGE_TYPE_NORMAL;
  }

  return [to, message, type];
};

/**
 * Fix a control file value. If a string, convert to its numeric value
 * ("resume", "pause", "cancel").
 * @private
 * @param {(Number|String)} control
 * @return {Number} control value
 */
Tox.prototype._fixFileControl = function (control) {
  if (_.isString(control)) {
    if (/^resume$/i.test(control)) {
      return consts.TOX_FILE_CONTROL_RESUME;
    } else if (/^pause$/i.test(control)) {
      return consts.TOX_FILE_CONTROL_PAUSE;
    } else if (/^cancel$/i.test(control)) {
      return consts.TOX_FILE_CONTROL_CANCEL;
    }
  }
  return control;
};

/**
 * Fix a send lossless packet value. Adds magic byte(160) to the first byte of data
 * @private
 * @param {Buffer} data
 * @return {Buffer} new data
 */
Tox.prototype._fixSendLosslessPacket = function (data) {
  //160: magic byte
  return Buffer.concat([Buffer.from([160]), data]);
};

/**
 * Fix a lossless/lossy packet buffer by prepending an id byte.
 * @private
 * @param {Number} id - Byte to prepend, according to tox.h it should be in the range
 *                      [160, 191] if lossless and [200, 254] if lossy.
 * @param {Buffer} data - Data buffer to prepend to
 * @return {Buffer} new data
 */
Tox.prototype._fixPacketBuffer = function (id, data) {
  return Buffer.concat([Buffer.from([id]), data]);
};

/**
 * Initialize the crypto (ToxEncryptSave) object.
 * @param {Object} opts - Tox constructor options object
 * @private
 */
Tox.prototype._initCrypto = function (opts) {
  var crypto = opts["crypto"];
  if (crypto === undefined || crypto === true) {
    // If not given, use a default instance
    this._crypto = new ToxEncryptSave();
  } else if (crypto instanceof ToxEncryptSave) {
    // If given an existing instance, use that
    this._crypto = crypto;
  } else if (_.isString(crypto) || _.isObject(crypto)) {
    // If given an object or string, use it as the constructor opts
    this._crypto = new ToxEncryptSave(crypto);
  } else if (!crypto) {
    // If something falsy, don't use
    this._crypto = undefined;
  } else {
    // If something else, use a default instance
    this._crypto = new ToxEncryptSave();
  }
};

/**
 * Initialize with tox_new.
 * @private
 * @param {ToxOptions} [options]
 * @param {(Buffer|String)} [data]
 * @todo Take one param (opts map)
 */
Tox.prototype._initNew = function (options, data) {
  var eptr = ref.alloc(TOX_ERR_NEW);

  if (options) {
    options = options.ref();
  } else {
    // If no options passed, use null pointer
    options = ref.NULL;
  }

  this._handle = this.getLibrary().tox_new(options, eptr);

  errors.checkToxNewError(eptr.deref());
};

/**
 * Set the proxy part of ToxOptions from opts.
 * @private
 * @param {Object} opts
 * @param {ToxOptions} options
 * @todo Update for char* proxy_host, instead of char[256] proxy_host
 */
Tox.prototype._setProxyToToxOptions = function (opts, options) {
  var proxy = opts["proxy"];

  if (_.isString(proxy)) {
    proxy = util.parseProxy(proxy);
    // Todo: Debug/error log if couldn't parse proxy string?
  }

  if (_.isObject(proxy)) {
    if (_.isString(proxy.type)) {
      if (/^http$/i.test(proxy.type)) options.proxy_type = consts.TOX_PROXY_TYPE_HTTP;
      else if (/^socks5?$/i.test(proxy.type)) options.proxy_type = consts.TOX_PROXY_TYPE_SOCKS5;
    }

    if (options.proxy_type !== consts.TOX_PROXY_TYPE_NONE) {
      // Set address, max string length 255
      // @todo Enforce 255 max length
      if (_.isString(proxy.address)) {
        // Store in "this' so it isn"t GC-d?
        this._proxyAddress = Buffer.from(proxy.address + "\0");
        options.proxy_address = this._proxyAddress;
      }

      // Set port
      if (_.isNumber(proxy.port)) {
        options.proxy_port = proxy.port;
      }
    }
  }
};

/**
 * Store an ffi.Callback. This is to prevent an annoying ffi garbage collection bug.
 * @private
 * @param {Object} key - Key
 * @param {ffi.Callback} callback - Callback
 */
Tox.prototype._storeFFICallback = function (key, callback) {
  if (!this._ffiCallbacks) this._ffiCallbacks = {};

  if (this._ffiCallbacks[key] === undefined) this._ffiCallbacks[key] = [callback];
  else this._ffiCallbacks[key].push(callback);
};

/**
 * Helper for node-ffi's Function to Callback.
 * @private
 * @param {ffi.Function} ffiFunc - Function definition
 * @param {Function} callback - Callback function
 * @return {ffi.Callback} ffi callback
 */
Tox.prototype._toFFICallback = function (ffiFunc, callback) {
  return ffi.Callback(ffiFunc.retType, ffiFunc.argTypes, callback);
};

/////////////////////
//> Perform functions
/////////////////////

/**
 * Used in: Tox#bootstrap(), Tox#bootstrapSync(), Tox#addTCPRelay(), Tox#addTCPRelaySync().
 * @private
 */
Tox.prototype._performBootstrap = function (opts) {
  var api = opts["api"],
    args = opts["args"],
    async = opts["async"],
    callback = opts["callback"],
    address = args[0],
    port = args[1],
    publicKey = args[2];

  // Fix address and public key
  address = Buffer.from(address + "\0");
  if (_.isString(publicKey)) {
    publicKey = Buffer.from(publicKey, "hex");
  }

  var eptr = ref.alloc(TOX_ERR_BOOTSTRAP);

  if (async) {
    if (!this._checkHandle(callback)) return;
    api(address, port, publicKey, eptr, function (err, success) {
      var terr = errors.bootstrap(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    });
  } else {
    this._checkHandleSync();
    var success = api(address, port, publicKey, eptr);
    var err = errors.bootstrap(eptr.deref());
    if (err) throw err;
    if (!success) throw errors.unsuccessful();
  }
};

/**
 * Helper wrapper function for friend getters that take a Buffer of
 * some size and set data to it.
 * @todo Custom error type/function, ex. TOX_ERR_FRIEND_GET_PUBLIC_KEY
 * @private
 */
Tox.prototype._performFriendGetter = function (opts) {
  var api = opts["api"],
    friend = opts["friend"],
    raw = opts["format"] === "raw",
    _size = opts["size"],
    async = opts["async"],
    callback = opts["callback"];

  if (_.isNumber(_size)) {
    var size;
    if (async)
      size = function (cb) {
        cb(undefined, _size);
      };
    else
      size = function () {
        return _size;
      };
  } else size = _size; // Assumes size is a Function

  var eptr = ref.alloc(TOX_ERR_FRIEND_QUERY);

  if (async) {
    if (!this._checkHandle(callback)) return;
    size(function (err, size) {
      if (!err) {
        var buffer = Buffer.alloc(size);
        buffer.fill(0);
        api(friend, buffer, eptr, function (err, success) {
          var terr = errors.friendQuery(eptr.deref());
          if (!err && terr) err = terr;
          if (!err && !success) err = errors.unsuccessful();
          if (!err && !raw) buffer = buffer.toString("utf8");
          if (callback) {
            callback(err, buffer);
          }
        });
      } else if (callback) {
        callback(err);
      }
    });
  } else {
    this._checkHandleSync();
    size = size();
    var buffer = Buffer.alloc(size);
    buffer.fill(0);
    var success = api(friend, buffer, eptr);
    var err = errors.friendQuery(eptr.deref());
    if (err) throw err;
    if (!success) throw errors.unsuccessful();
    if (!raw) buffer = buffer.toString("utf8");
    return buffer;
  }
};

/**
 * Helper wrapper function for friend api functions that return
 * a Number.
 * @private
 */
Tox.prototype._performFriendNumberGetter = function (opts) {
  var api = opts["api"],
    friend = opts["friend"],
    async = opts["async"],
    callback = opts["callback"];

  var eptr = ref.alloc(TOX_ERR_FRIEND_QUERY);

  if (async) {
    if (!this._checkHandle(callback)) return;
    api(friend, eptr, function (err, size) {
      var terr = errors.friendQuery(eptr.deref());
      if (!err && terr) err = terr;
      if (!err) size = Number(size);
      if (callback) {
        callback(err, size);
      }
    });
  } else {
    this._checkHandleSync();
    var size = api(friend, eptr);
    var err = errors.friendQuery(eptr.deref());
    if (err) throw err;
    return Number(size);
  }
};

/**
 * Helper wrapper function for api functions that take a buffer
 * (char*, uint8_t*) of some size and set data to it.
 * @todo Write tests to make sure there's no possibility of overflow, as
 *       things may change between the size function running (creating
 *       a Buffer of that size) and trying to move data to that Buffer.
 * @private
 */
Tox.prototype._performGetter = function (opts) {
  var api = opts["api"],
    raw = opts["format"] === "raw",
    _size = opts["size"],
    async = opts["async"],
    callback = opts["callback"];

  if (_.isNumber(_size)) {
    var size;
    if (async)
      size = function (cb) {
        cb(undefined, _size);
      };
    else
      size = function () {
        return _size;
      };
  } else size = _size; // Assumes size is a Function

  if (async) {
    if (!this._checkHandle(callback)) return;
    size(function (err, size) {
      if (!err) {
        var buffer = Buffer.alloc(size);
        api(buffer, function (err) {
          if (!err && !raw) buffer = buffer.toString("utf8");
          if (callback) {
            callback(err, buffer);
          }
        });
      } else if (callback) {
        callback(err);
      }
    });
  } else {
    this._checkHandleSync();
    size = size();
    var buffer = Buffer.alloc(size);
    api(buffer);
    if (!raw) buffer = buffer.toString("utf8");
    return buffer;
  }
};

/**
 * Helper wrapper function for api functions that return a Number.
 * @private
 */
Tox.prototype._performNumberGetter = function (opts) {
  var api = opts["api"],
    async = opts["async"],
    callback = opts["callback"];

  if (async) {
    if (!this._checkHandle(callback)) return;
    api(function (err, size) {
      if (!err) size = Number(size);
      if (callback) {
        callback(err, size);
      }
    });
  } else {
    this._checkHandleSync();
    var size = api();
    return Number(size);
  }
};

/**
 * @private
 */
Tox.prototype._performNumberSetter = function (opts) {
  var api = opts["api"],
    value = opts["value"],
    async = opts["async"],
    callback = opts["callback"];

  if (async) {
    if (!this._checkHandle(callback)) return;
    api(value, function (err) {
      if (callback) {
        callback(err);
      }
    });
  } else {
    this._checkHandleSync();
    api(value);
  }
};

/**
 * Helper wrapper function for api functions that get a size_t.
 * @private
 */
Tox.prototype._performSizeGetter = function (opts) {
  return this._performNumberGetter(opts);
};

/**
 * Helper wrapper function for api functions that take a buffer
 * (char*, uint8_t*) or a string of some size and use it to set data.
 * @private
 */
Tox.prototype._performSetter = function (opts) {
  var api = opts["api"],
    data = opts["data"],
    errorCheck = opts["error"],
    async = opts["async"],
    callback = opts["callback"];

  if (_.isString(data)) {
    data = Buffer.from(data);
  }

  var eptr = ref.alloc(CEnum); // @todo: Make this more specific?

  if (async) {
    if (!this._checkHandle(callback)) return;
    api(data, size_t(data.length), eptr, function (err, success) {
      var terr = errorCheck(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !success) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    });
  } else {
    this._checkHandleSync();
    var success = api(data, size_t(data.length), eptr),
      err = errorCheck(eptr.deref());
    if (err) throw err;
    if (!success) throw errors.unsuccessful();
  }
};

/**
 * Helper wrapper function for api functions that take a friend and a
 * Buffer to send a packet.
 * @private
 */
Tox.prototype._performSendPacket = function (opts) {
  var api = opts["api"],
    data = opts["data"],
    friendnum = opts["friend"],
    async = opts["async"],
    callback = opts["callback"];

  var eptr = ref.alloc(TOX_ERR_FRIEND_CUSTOM_PACKET);

  if (async) {
    if (!this._checkHandle(callback)) return;
    api(friendnum, data, size_t(data.length), eptr, function (err, res) {
      var terr = errors.friendCustomPacket(eptr.deref());
      if (!err && terr) err = terr;
      if (!err && !res) err = errors.unsuccessful();
      if (callback) {
        callback(err);
      }
    });
  } else {
    this._checkHandleSync();
    var success = api(friendnum, data, size_t(data.length), eptr),
      err = errors.friendCustomPacket(eptr.deref());
    if (err) throw err;
    if (!success) throw errors.unsuccessful();
  }
};

/**
 * Helper wrapper function for api functions that get a port.
 * @private
 */
Tox.prototype._performGetPort = function (opts) {
  var api = opts["api"],
    async = opts["async"],
    callback = opts["callback"];

  var eptr = ref.alloc(TOX_ERR_GET_PORT);

  if (async) {
    if (!this._checkHandle(callback)) return;
    api(eptr, function (err, port) {
      var terr = errors.getPort(eptr.deref());
      if (!err && terr) err = terr;
      if (callback) {
        callback(err, port);
      }
    });
  } else {
    this._checkHandleSync();
    var port = api(eptr);
    var err = errors.getPort(eptr.deref());
    if (err) throw err;
    return port;
  }
};

/**
 * Helper wrapper function for version api functions.
 * @private
 */
Tox.prototype._performVersion = function (opts) {
  var api = opts["api"],
    async = opts["async"],
    callback = opts["callback"];
  if (async) {
    api(function (err, version) {
      if (callback) {
        callback(err, version);
      }
    });
  } else {
    return api();
  }
};

///////////////////////
//> Events initializers
///////////////////////

/**
 * Initialize all callbacks.
 * @private
 */
Tox.prototype._initCallbacks = function () {
  this._initSelfConnectionStatusCb();
  this._initFriendNameCb();
  this._initFriendStatusMessageCb();
  this._initFriendStatusCb();
  this._initFriendConnectionStatusCb();
  this._initFriendTypingCb();
  this._initFriendReadReceiptCb();
  this._initFriendRequestCb();
  this._initFriendMessageCb();
  this._initFileRecvControlCb();
  this._initFileChunkRequestCb();
  this._initFileRecvCb();
  this._initFileRecvChunkCb();
  this._initFriendLosslessPacketCb();
  this._initFriendLossyPacketCb();
};

/**
 * Helper function for initializing tox callbacks.
 * @private
 */
Tox.prototype._initCallback = function (opts) {
  this._checkHandleSync();

  var api = opts["api"],
    cb = opts["cb"], // Callback type
    name = opts["name"],
    wrapper = opts["wrapper"];

  var x = this._toFFICallback(cb, wrapper);
  this._storeFFICallback(name, x); // Store for GC issues
  api(x, ref.NULL);
};

/**
 * Initialize the selfConnectionStatus event callback.
 * @private
 */
Tox.prototype._initSelfConnectionStatusCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_self_connection_status.bind(undefined, this.getHandle()),
    cb: SelfConnectionStatusCallback,
    name: "SelfConnectionStatus",
    wrapper: function (handle, connection, userdata) {
      _this._emit("selfConnectionStatus", new toxEvents.SelfConnectionStatusEvent(connection));
    },
  });
};

/**
 * Initialize the friendName event callback.
 * @private
 */
Tox.prototype._initFriendNameCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_name.bind(undefined, this.getHandle()),
    cb: FriendNameCallback,
    name: "FriendName",
    wrapper: function (handle, friend, buffer, size, userdata) {
      var name = buffer.slice(0, size).toString();
      _this._emit("friendName", new toxEvents.FriendNameEvent(friend, name));
    },
  });
};

/**
 * Initialize the friendStatusMessage event callback.
 * @private
 */
Tox.prototype._initFriendStatusMessageCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_status_message.bind(undefined, this.getHandle()),
    cb: FriendStatusMessageCallback,
    name: "FriendStatusMessage",
    wrapper: function (handle, friend, buffer, size, userdata) {
      var statusMessage = buffer.slice(0, size).toString();
      _this._emit(
        "friendStatusMessage",
        new toxEvents.FriendStatusMessageEvent(friend, statusMessage)
      );
    },
  });
};

/**
 * Initialize the friendStatus event callback.
 * @private
 */
Tox.prototype._initFriendStatusCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_status.bind(undefined, this.getHandle()),
    cb: FriendStatusCallback,
    name: "FriendStatus",
    wrapper: function (handle, friend, status, userdata) {
      _this._emit("friendStatus", new toxEvents.FriendStatusEvent(friend, status));
    },
  });
};

/**
 * Initialize the friendConnectionStatus event callback.
 * @private
 */
Tox.prototype._initFriendConnectionStatusCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_connection_status.bind(undefined, this.getHandle()),
    cb: FriendConnectionStatusCallback,
    name: "FriendConnectionStatus",
    wrapper: function (handle, friend, connection, userdata) {
      _this._emit(
        "friendConnectionStatus",
        new toxEvents.FriendConnectionStatusEvent(friend, connection)
      );
    },
  });
};

/**
 * Initialize the friendTyping event callback.
 * @private
 */
Tox.prototype._initFriendTypingCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_typing.bind(undefined, this.getHandle()),
    cb: FriendTypingCallback,
    name: "FriendTypingStatus",
    wrapper: function (handle, friend, typing, userdata) {
      _this._emit("friendTyping", new toxEvents.FriendTypingEvent(friend, typing));
    },
  });
};

/**
 * Initialize the friendReadReceipt event callback.
 * @private
 */
Tox.prototype._initFriendReadReceiptCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_read_receipt.bind(undefined, this.getHandle()),
    cb: FriendReadReceiptCallback,
    name: "FriendReadReceiptStatus",
    wrapper: function (handle, friend, receipt, userdata) {
      _this._emit("friendReadReceipt", new toxEvents.FriendReadReceiptEvent(friend, receipt));
    },
  });
};

/**
 * Initialize the friendRequest event callback.
 * @private
 */
Tox.prototype._initFriendRequestCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_request.bind(undefined, this.getHandle()),
    cb: FriendRequestCallback,
    name: "FriendRequestStatus",
    wrapper: function (handle, publicKey, data, size, userdata) {
      publicKey = Buffer.from(publicKey); // Copy into persistent Buffer
      var message = data.slice(0, size).toString();
      _this._emit("friendRequest", new toxEvents.FriendRequestEvent(publicKey, message));
    },
  });
};

/**
 * Initialize the friendMessage event callback.
 * @private
 */
Tox.prototype._initFriendMessageCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_message.bind(undefined, this.getHandle()),
    cb: FriendMessageCallback,
    name: "FriendMessage",
    wrapper: function (handle, friend, type, data, size, userdata) {
      var message = data.slice(0, size).toString();
      _this._emit("friendMessage", new toxEvents.FriendMessageEvent(friend, type, message));
    },
  });
};

/**
 * Initialize the fileRecvControl event callback.
 * @private
 */
Tox.prototype._initFileRecvControlCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_file_recv_control.bind(undefined, this.getHandle()),
    cb: FileRecvControlCallback,
    name: "FileRecvControlCallback",
    wrapper: function (handle, friend, file, control, userdata) {
      _this._emit("fileRecvControl", new toxEvents.FileRecvControlEvent(friend, file, control));
    },
  });
};

/**
 * Initialize the fileChunkRequest event callback.
 * @private
 */
Tox.prototype._initFileChunkRequestCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_file_chunk_request.bind(undefined, this.getHandle()),
    cb: FileChunkRequestCallback,
    name: "FileChunkRequestCallback",
    wrapper: function (handle, friend, file, position, length, userdata) {
      _this._emit(
        "fileChunkRequest",
        new toxEvents.FileChunkRequestEvent(friend, file, position, length)
      );
    },
  });
};

/**
 * Initialize the fileRecv event callback.
 * @private
 */
Tox.prototype._initFileRecvCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_file_recv.bind(undefined, this.getHandle()),
    cb: FileRecvCallback,
    name: "FileRecvCallback",
    wrapper: function (handle, friend, file, kind, size, filename, length, userdata) {
      // Filename might be NULL, probably if file kind is AVATAR or non-DATA
      if (ref.address(filename) !== 0) {
        filename = ref.reinterpret(filename, length).toString("utf8");
      } else {
        filename = undefined;
      }
      _this._emit("fileRecv", new toxEvents.FileRecvEvent(friend, file, kind, size, filename));
    },
  });
};

/**
 * Initialize the fileRecvChunk event callback.
 * @private
 */
Tox.prototype._initFileRecvChunkCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_file_recv_chunk.bind(undefined, this.getHandle()),
    cb: FileRecvChunkCallback,
    name: "FileRecvChunkCallback",
    wrapper: function (handle, friend, file, position, data, size, userdata) {
      // Apparently data can sometimes be a NULL pointer, set data to undefined if so
      // This should only happen on final chunk?
      if (ref.address(data) !== 0) {
        data = Buffer.from(ref.reinterpret(data, size)); // Copy to another Buffer
      } else {
        data = undefined;
      }
      _this._emit("fileRecvChunk", new toxEvents.FileRecvChunkEvent(friend, file, position, data));
    },
  });
};

/**
 * Initialize the friendLosslessPacket event callback.
 * @private
 */
Tox.prototype._initFriendLosslessPacketCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_lossless_packet.bind(undefined, this.getHandle()),
    cb: FriendLosslessPacketCallback,
    name: "FriendLosslessPacketCallback",
    wrapper: function (handle, friend, data, length, userdata) {
      //if(ref.address(data) !== 0) {
      //  //first byte is magic byte(160) so ignore it
      //  data = Buffer.from(ref.reinterpret(data, (length - 1), 1)); // Copy to another Buffer
      //} else {
      //  data = undefined;
      //}
      if (ref.address(data) === 0) {
        throw new Error("NULL data packet");
      }
      data = Buffer.from(ref.reinterpret(data, length));
      _this._emit("friendLosslessPacket", new toxEvents.FriendPacketEvent(friend, data, true));
    },
  });
};

/**
 * Initialize the friendLossyPacket event callback.
 * @private
 */
Tox.prototype._initFriendLossyPacketCb = function () {
  var _this = this;
  this._initCallback({
    api: this.getLibrary().tox_callback_friend_lossy_packet.bind(undefined, this.getHandle()),
    cb: FriendLossyPacketCallback,
    name: "FriendLossyPacketCallback",
    wrapper: function (handle, friend, data, length, userdata) {
      if (ref.address(data) === 0) {
        throw new Error("NULL data packet");
      }
      data = Buffer.from(ref.reinterpret(data, length));
      _this._emit("friendLossyPacket", new toxEvents.FriendPacketEvent(friend, data, false));
    },
  });
};

///////////////////
//> JSDoc callbacks
///////////////////

/**
 * Callback that returns some error, if any.
 * @callback Tox~errorCallback
 * @param {Error} error - error, if any
 */

/**
 * Callback that returns some boolean.
 * @callback Tox~booleanCallback
 * @param {Error} error - error, if any
 * @param {Boolean} value
 */

/**
 * Callback that returns some data in a Buffer.
 * @callback Tox~dataCallback
 * @param {Error} error - error, if any
 * @param {Buffer} data
 */

/**
 * Callback that returns a Date object.
 * @callback Tox~dateCallback
 * @param {Error} error - error, if any
 * @param {Date} date
 */

/**
 * Callback that returns some number.
 * @callback Tox~numberCallback
 * @param {Error} error - error, if any
 * @param {Number} value
 */

/**
 * Callback that returns an array of numbers.
 * @callback Tox~numberArrayCallback
 * @param {Error} error - error, if any
 * @param {Number[]} numbers
 */

/**
 * Callback that returns a ToxOptions object.
 * @callback Tox~optionsCallback
 * @param {Error} error - error if any
 * @param {ToxOptions} options
 */

/**
 * Callback that returns some string.
 * @callback Tox~stringCallback
 * @param {Error} error - error, if any
 * @param {String} value
 */

/**
 * Callback that returns a Tox object.
 * @callback Tox~toxCallback
 * @param {Error} error - error, if any
 * @param {Tox} tox
 */

module.exports = Tox;