Update libtox to 0.2.15

1 files changed, 234 insertions, 151 deletions

diff --git a/protocols/Tox/libtox/src/toxcore/tox.c b/protocols/Tox/libtox/src/toxcore/tox.c
index 780d913667..fce8347c5e 100644
--- a/protocols/Tox/libtox/src/toxcore/tox.c
+++ b/protocols/Tox/libtox/src/toxcore/tox.c
@@ -3,18 +3,12 @@
  * Copyright © 2013 Tox project.
  */
 
-/*
+/**
  * The Tox public API.
  */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifndef __cplusplus
 #ifndef _XOPEN_SOURCE
 #define _XOPEN_SOURCE 600
 #endif
-#endif
 
 #include "tox.h"
 #include "tox_private.h"
@@ -30,39 +24,29 @@
 
 #include "../toxencryptsave/defines.h"
 
-#define SET_ERROR_PARAMETER(param, x) do { if (param) { *param = x; } } while (0)
-
-#if TOX_HASH_LENGTH != CRYPTO_SHA256_SIZE
-#error "TOX_HASH_LENGTH is assumed to be equal to CRYPTO_SHA256_SIZE"
-#endif
-
-#if FILE_ID_LENGTH != CRYPTO_SYMMETRIC_KEY_SIZE
-#error "FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE"
-#endif
-
-#if TOX_FILE_ID_LENGTH != CRYPTO_SYMMETRIC_KEY_SIZE
-#error "TOX_FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE"
-#endif
-
-#if TOX_FILE_ID_LENGTH != TOX_HASH_LENGTH
-#error "TOX_FILE_ID_LENGTH is assumed to be equal to TOX_HASH_LENGTH"
-#endif
-
-#if TOX_PUBLIC_KEY_SIZE != CRYPTO_PUBLIC_KEY_SIZE
-#error "TOX_PUBLIC_KEY_SIZE is assumed to be equal to CRYPTO_PUBLIC_KEY_SIZE"
-#endif
-
-#if TOX_SECRET_KEY_SIZE != CRYPTO_SECRET_KEY_SIZE
-#error "TOX_SECRET_KEY_SIZE is assumed to be equal to CRYPTO_SECRET_KEY_SIZE"
-#endif
-
-#if TOX_MAX_NAME_LENGTH != MAX_NAME_LENGTH
-#error "TOX_MAX_NAME_LENGTH is assumed to be equal to MAX_NAME_LENGTH"
-#endif
-
-#if TOX_MAX_STATUS_MESSAGE_LENGTH != MAX_STATUSMESSAGE_LENGTH
-#error "TOX_MAX_STATUS_MESSAGE_LENGTH is assumed to be equal to MAX_STATUSMESSAGE_LENGTH"
-#endif
+#define SET_ERROR_PARAMETER(param, x) \
+    do {                              \
+        if (param) {                  \
+            *param = x;               \
+        }                             \
+    } while (0)
+
+static_assert(TOX_HASH_LENGTH == CRYPTO_SHA256_SIZE,
+              "TOX_HASH_LENGTH is assumed to be equal to CRYPTO_SHA256_SIZE");
+static_assert(FILE_ID_LENGTH == CRYPTO_SYMMETRIC_KEY_SIZE,
+              "FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE");
+static_assert(TOX_FILE_ID_LENGTH == CRYPTO_SYMMETRIC_KEY_SIZE,
+              "TOX_FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE");
+static_assert(TOX_FILE_ID_LENGTH == TOX_HASH_LENGTH,
+              "TOX_FILE_ID_LENGTH is assumed to be equal to TOX_HASH_LENGTH");
+static_assert(TOX_PUBLIC_KEY_SIZE == CRYPTO_PUBLIC_KEY_SIZE,
+              "TOX_PUBLIC_KEY_SIZE is assumed to be equal to CRYPTO_PUBLIC_KEY_SIZE");
+static_assert(TOX_SECRET_KEY_SIZE == CRYPTO_SECRET_KEY_SIZE,
+              "TOX_SECRET_KEY_SIZE is assumed to be equal to CRYPTO_SECRET_KEY_SIZE");
+static_assert(TOX_MAX_NAME_LENGTH == MAX_NAME_LENGTH,
+              "TOX_MAX_NAME_LENGTH is assumed to be equal to MAX_NAME_LENGTH");
+static_assert(TOX_MAX_STATUS_MESSAGE_LENGTH == MAX_STATUSMESSAGE_LENGTH,
+              "TOX_MAX_STATUS_MESSAGE_LENGTH is assumed to be equal to MAX_STATUSMESSAGE_LENGTH");
 
 struct Tox {
     // XXX: Messenger *must* be the first member, because toxav casts its
@@ -367,7 +351,7 @@ static State_Load_Status state_load_callback(void *outer, const uint8_t *data, u
     return STATE_LOAD_STATUS_CONTINUE;
 }
 
-/* Load tox from data of size length. */
+/** Load tox from data of size length. */
 static int tox_load(Tox *tox, const uint8_t *data, uint32_t length)
 {
     uint32_t data32[2];
@@ -388,7 +372,6 @@ static int tox_load(Tox *tox, const uint8_t *data, uint32_t length)
                       length - cookie_len, STATE_COOKIE_TYPE);
 }
 
-
 Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
 {
     Tox *tox = (Tox *)calloc(1, sizeof(Tox));
@@ -410,13 +393,15 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
         default_options = tox_options_new(&err);
 
         switch (err) {
-            case TOX_ERR_OPTIONS_NEW_OK:
+            case TOX_ERR_OPTIONS_NEW_OK: {
                 break;
+            }
 
-            case TOX_ERR_OPTIONS_NEW_MALLOC:
+            case TOX_ERR_OPTIONS_NEW_MALLOC: {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
                 free(tox);
                 return nullptr;
+            }
         }
     }
 
@@ -449,7 +434,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
             return nullptr;
         }
 
-        if (crypto_memcmp(tox_options_get_savedata_data(opts), TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) == 0) {
+        if (memcmp(tox_options_get_savedata_data(opts), TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) == 0) {
             SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_ENCRYPTED);
             tox_options_free(default_options);
             free(tox);
@@ -472,23 +457,27 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
     m_options.log_user_data = tox_options_get_log_user_data(opts);
 
     switch (tox_options_get_proxy_type(opts)) {
-        case TOX_PROXY_TYPE_HTTP:
+        case TOX_PROXY_TYPE_HTTP: {
             m_options.proxy_info.proxy_type = TCP_PROXY_HTTP;
             break;
+        }
 
-        case TOX_PROXY_TYPE_SOCKS5:
+        case TOX_PROXY_TYPE_SOCKS5: {
             m_options.proxy_info.proxy_type = TCP_PROXY_SOCKS5;
             break;
+        }
 
-        case TOX_PROXY_TYPE_NONE:
+        case TOX_PROXY_TYPE_NONE: {
             m_options.proxy_info.proxy_type = TCP_PROXY_NONE;
             break;
+        }
 
-        default:
+        default: {
             SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_TYPE);
             tox_options_free(default_options);
             free(tox);
             return nullptr;
+        }
     }
 
     if (m_options.proxy_info.proxy_type != TCP_PROXY_NONE) {
@@ -526,7 +515,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
     }
 
     if (tox_options_get_experimental_thread_safety(opts)) {
-        tox->mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+        tox->mutex = (pthread_mutex_t *)calloc(1, sizeof(pthread_mutex_t));
 
         if (tox->mutex == nullptr) {
             SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
@@ -703,20 +692,22 @@ bool tox_bootstrap(Tox *tox, const char *host, uint16_t port, const uint8_t *pub
     const int32_t count = net_getipport(host, &root, TOX_SOCK_DGRAM);
 
     if (count == -1) {
+        LOGGER_DEBUG(tox->m->log, "could not resolve bootstrap node '%s'", host);
         net_freeipport(root);
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
         return 0;
     }
 
-    unsigned int i;
-
     lock(tox);
 
-    for (i = 0; i < count; ++i) {
+    for (int32_t i = 0; i < count; ++i) {
         root[i].port = net_htons(port);
 
-        onion_add_bs_path_node(tox->m->onion_c, root[i], public_key);
-        dht_bootstrap(tox->m->dht, root[i], public_key);
+        onion_add_bs_path_node(tox->m->onion_c, &root[i], public_key);
+
+        if (!tox->m->options.udp_disabled) {
+            dht_bootstrap(tox->m->dht, &root[i], public_key);
+        }
     }
 
     unlock(tox);
@@ -728,6 +719,7 @@ bool tox_bootstrap(Tox *tox, const char *host, uint16_t port, const uint8_t *pub
         return 1;
     }
 
+    LOGGER_DEBUG(tox->m->log, "bootstrap node '%s' resolved to 0 IP_Ports", host);
     SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
     return 0;
 }
@@ -749,7 +741,7 @@ bool tox_add_tcp_relay(Tox *tox, const char *host, uint16_t port, const uint8_t
 
     IP_Port *root;
 
-    int32_t count = net_getipport(host, &root, TOX_SOCK_STREAM);
+    const int32_t count = net_getipport(host, &root, TOX_SOCK_STREAM);
 
     if (count == -1) {
         net_freeipport(root);
@@ -757,14 +749,12 @@ bool tox_add_tcp_relay(Tox *tox, const char *host, uint16_t port, const uint8_t
         return 0;
     }
 
-    unsigned int i;
-
     lock(tox);
 
-    for (i = 0; i < count; ++i) {
+    for (int32_t i = 0; i < count; ++i) {
         root[i].port = net_htons(port);
 
-        add_tcp_relay(tox->m->net_crypto, root[i], public_key);
+        add_tcp_relay(tox->m->net_crypto, &root[i], public_key);
     }
 
     unlock(tox);
@@ -984,38 +974,46 @@ Tox_User_Status tox_self_get_status(const Tox *tox)
 static void set_friend_error(const Logger *log, int32_t ret, Tox_Err_Friend_Add *error)
 {
     switch (ret) {
-        case FAERR_TOOLONG:
+        case FAERR_TOOLONG: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_TOO_LONG);
             break;
+        }
 
-        case FAERR_NOMESSAGE:
+        case FAERR_NOMESSAGE: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_NO_MESSAGE);
             break;
+        }
 
-        case FAERR_OWNKEY:
+        case FAERR_OWNKEY: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_OWN_KEY);
             break;
+        }
 
-        case FAERR_ALREADYSENT:
+        case FAERR_ALREADYSENT: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_ALREADY_SENT);
             break;
+        }
 
-        case FAERR_BADCHECKSUM:
+        case FAERR_BADCHECKSUM: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_BAD_CHECKSUM);
             break;
+        }
 
-        case FAERR_SETNEWNOSPAM:
+        case FAERR_SETNEWNOSPAM: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM);
             break;
+        }
 
-        case FAERR_NOMEM:
+        case FAERR_NOMEM: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_MALLOC);
             break;
+        }
 
-        default:
+        default: {
             /* can't happen */
-            LOGGER_FATAL(log, "impossible: unknown friend-add error");
+            LOGGER_FATAL(log, "impossible return value: %d", ret);
             break;
+        }
     }
 }
 
@@ -1351,34 +1349,41 @@ bool tox_self_set_typing(Tox *tox, uint32_t friend_number, bool typing, Tox_Err_
 static void set_message_error(const Logger *log, int ret, Tox_Err_Friend_Send_Message *error)
 {
     switch (ret) {
-        case 0:
+        case 0: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_SEND_MESSAGE_OK);
             break;
+        }
 
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_FOUND);
             break;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG);
             break;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_CONNECTED);
             break;
+        }
 
-        case -4:
+        case -4: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ);
             break;
+        }
 
-        case -5:
+        case -5: {
             LOGGER_FATAL(log, "impossible: Messenger and Tox disagree on message types");
             break;
+        }
 
-        default:
+        default: {
             /* can't happen */
-            LOGGER_FATAL(log, "impossible: unknown send-message error: %d", ret);
+            LOGGER_FATAL(log, "impossible return value: %d", ret);
             break;
+        }
     }
 }
 
@@ -1447,40 +1452,51 @@ bool tox_file_control(Tox *tox, uint32_t friend_number, uint32_t file_number, To
     }
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND);
             return 0;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_CONTROL_FRIEND_NOT_CONNECTED);
             return 0;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_CONTROL_NOT_FOUND);
             return 0;
+        }
 
-        case -4:
-            /* can't happen */
+        case -4: {
+            /* can't happen (this code is returned if `control` is invalid type) */
+            LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret);
             return 0;
+        }
 
-        case -5:
+        case -5: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_CONTROL_ALREADY_PAUSED);
             return 0;
+        }
 
-        case -6:
+        case -6: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_CONTROL_DENIED);
             return 0;
+        }
 
-        case -7:
+        case -7: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_CONTROL_NOT_PAUSED);
             return 0;
+        }
 
-        case -8:
+        case -8: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_CONTROL_SENDQ);
             return 0;
+        }
     }
 
     /* can't happen */
+    LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret);
+
     return 0;
 }
 
@@ -1498,33 +1514,41 @@ bool tox_file_seek(Tox *tox, uint32_t friend_number, uint32_t file_number, uint6
     }
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_FRIEND_NOT_FOUND);
             return 0;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_FRIEND_NOT_CONNECTED);
             return 0;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_NOT_FOUND);
             return 0;
+        }
 
         case -4: // fall-through
-        case -5:
+        case -5: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_DENIED);
             return 0;
+        }
 
-        case -6:
+        case -6: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_INVALID_POSITION);
             return 0;
+        }
 
-        case -8:
+        case -8: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_SENDQ);
             return 0;
+        }
     }
 
     /* can't happen */
+    LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret);
+
     return 0;
 }
 
@@ -1590,24 +1614,30 @@ uint32_t tox_file_send(Tox *tox, uint32_t friend_number, uint32_t kind, uint64_t
     }
 
     switch (file_num) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND);
             return UINT32_MAX;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_NAME_TOO_LONG);
             return UINT32_MAX;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_TOO_MANY);
             return UINT32_MAX;
+        }
 
-        case -4:
+        case -4: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED);
             return UINT32_MAX;
+        }
     }
 
     /* can't happen */
+    LOGGER_FATAL(tox->m->log, "impossible return value: %ld", file_num);
+
     return UINT32_MAX;
 }
 
@@ -1625,36 +1655,45 @@ bool tox_file_send_chunk(Tox *tox, uint32_t friend_number, uint32_t file_number,
     }
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_FOUND);
             return 0;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_CONNECTED);
             return 0;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_CHUNK_NOT_FOUND);
             return 0;
+        }
 
-        case -4:
+        case -4: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_CHUNK_NOT_TRANSFERRING);
             return 0;
+        }
 
-        case -5:
+        case -5: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_CHUNK_INVALID_LENGTH);
             return 0;
+        }
 
-        case -6:
+        case -6: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_CHUNK_SENDQ);
             return 0;
+        }
 
-        case -7:
+        case -7: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEND_CHUNK_WRONG_POSITION);
             return 0;
+        }
     }
 
     /* can't happen */
+    LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret);
+
     return 0;
 }
 
@@ -1769,13 +1808,15 @@ size_t tox_conference_peer_get_name_size(const Tox *tox, uint32_t conference_num
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return -1;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return -1;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1791,13 +1832,15 @@ bool tox_conference_peer_get_name(const Tox *tox, uint32_t conference_number, ui
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1813,13 +1856,15 @@ bool tox_conference_peer_get_public_key(const Tox *tox, uint32_t conference_numb
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1835,17 +1880,20 @@ bool tox_conference_peer_number_is_ours(const Tox *tox, uint32_t conference_numb
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return false;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_NO_CONNECTION);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1879,13 +1927,15 @@ size_t tox_conference_offline_peer_get_name_size(const Tox *tox, uint32_t confer
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return -1;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return -1;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1902,13 +1952,15 @@ bool tox_conference_offline_peer_get_name(const Tox *tox, uint32_t conference_nu
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1925,13 +1977,15 @@ bool tox_conference_offline_peer_get_public_key(const Tox *tox, uint32_t confere
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1950,13 +2004,15 @@ uint64_t tox_conference_offline_peer_get_last_active(const Tox *tox, uint32_t co
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
             return UINT64_MAX;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
             return UINT64_MAX;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@@ -1990,17 +2046,20 @@ bool tox_conference_invite(Tox *tox, uint32_t friend_number, uint32_t conference
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_INVITE_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_INVITE_FAIL_SEND);
             return false;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_INVITE_NO_CONNECTION);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_INVITE_OK);
@@ -2016,29 +2075,35 @@ uint32_t tox_conference_join(Tox *tox, uint32_t friend_number, const uint8_t *co
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_INVALID_LENGTH);
             return UINT32_MAX;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_WRONG_TYPE);
             return UINT32_MAX;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_FRIEND_NOT_FOUND);
             return UINT32_MAX;
+        }
 
-        case -4:
+        case -4: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_DUPLICATE);
             return UINT32_MAX;
+        }
 
-        case -5:
+        case -5: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_INIT_FAIL);
             return UINT32_MAX;
+        }
 
-        case -6:
+        case -6: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_FAIL_SEND);
             return UINT32_MAX;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_OK);
@@ -2061,21 +2126,25 @@ bool tox_conference_send_message(Tox *tox, uint32_t conference_number, Tox_Messa
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_TOO_LONG);
             return false;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_NO_CONNECTION);
             return false;
+        }
 
-        case -4:
+        case -4: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_FAIL_SEND);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_OK);
@@ -2090,13 +2159,15 @@ size_t tox_conference_get_title_size(const Tox *tox, uint32_t conference_number,
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND);
             return -1;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH);
             return -1;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_OK);
@@ -2112,13 +2183,15 @@ bool tox_conference_get_title(const Tox *tox, uint32_t conference_number, uint8_
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_OK);
@@ -2134,17 +2207,20 @@ bool tox_conference_set_title(Tox *tox, uint32_t conference_number, const uint8_
     unlock(tox);
 
     switch (ret) {
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND);
             return false;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH);
             return false;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_FAIL_SEND);
             return false;
+        }
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_OK);
@@ -2186,7 +2262,6 @@ Tox_Conference_Type tox_conference_get_type(const Tox *tox, uint32_t conference_
     return (Tox_Conference_Type)ret;
 }
 
-/* id is TOX_CONFERENCE_ID_SIZE bytes */
 bool tox_conference_get_id(const Tox *tox, uint32_t conference_number, uint8_t *id)
 {
     assert(tox != nullptr);
@@ -2197,7 +2272,6 @@ bool tox_conference_get_id(const Tox *tox, uint32_t conference_number, uint8_t *
 }
 
 // TODO(iphydf): Delete in 0.3.0.
-/* uid is TOX_CONFERENCE_ID_SIZE bytes */
 bool tox_conference_get_uid(const Tox *tox, uint32_t conference_number, uint8_t *uid)
 {
     assert(tox != nullptr);
@@ -2234,17 +2308,20 @@ uint32_t tox_conference_by_uid(const Tox *tox, const uint8_t *uid, Tox_Err_Confe
     const uint32_t res = tox_conference_by_id(tox, uid, &id_error);
 
     switch (id_error) {
-        case TOX_ERR_CONFERENCE_BY_ID_OK:
+        case TOX_ERR_CONFERENCE_BY_ID_OK: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_BY_UID_OK);
             break;
+        }
 
-        case TOX_ERR_CONFERENCE_BY_ID_NULL:
+        case TOX_ERR_CONFERENCE_BY_ID_NULL: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_BY_UID_NULL);
             break;
+        }
 
-        case TOX_ERR_CONFERENCE_BY_ID_NOT_FOUND:
+        case TOX_ERR_CONFERENCE_BY_ID_NOT_FOUND: {
             SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_BY_UID_NOT_FOUND);
             break;
+        }
     }
 
     return res;
@@ -2253,29 +2330,35 @@ uint32_t tox_conference_by_uid(const Tox *tox, const uint8_t *uid, Tox_Err_Confe
 static void set_custom_packet_error(int ret, Tox_Err_Friend_Custom_Packet *error)
 {
     switch (ret) {
-        case 0:
+        case 0: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_CUSTOM_PACKET_OK);
             break;
+        }
 
-        case -1:
+        case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_FOUND);
             break;
+        }
 
-        case -2:
+        case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_CUSTOM_PACKET_TOO_LONG);
             break;
+        }
 
-        case -3:
+        case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_CUSTOM_PACKET_INVALID);
             break;
+        }
 
-        case -4:
+        case -4: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_CONNECTED);
             break;
+        }
 
-        case -5:
+        case -5: {
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_CUSTOM_PACKET_SENDQ);
             break;
+        }
     }
 }